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

#include "mpeg12data.h"

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

36

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

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

55
#ifdef CONFIG_ENCODERS
Fabrice Bellard's avatar
Fabrice Bellard committed
56 57 58
static void mpeg1_encode_block(MpegEncContext *s, 
                         DCTELEM *block, 
                         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
Fabrice Bellard's avatar
Fabrice Bellard committed
61
static void mpeg1_skip_picture(MpegEncContext *s, int pict_num);
62 63 64 65
static inline int mpeg1_decode_block_inter(MpegEncContext *s, 
                              DCTELEM *block, 
                              int n);
static inline int mpeg1_decode_block_intra(MpegEncContext *s, 
Fabrice Bellard's avatar
Fabrice Bellard committed
66 67
                              DCTELEM *block, 
                              int n);
68
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 
Fabrice Bellard's avatar
Fabrice Bellard committed
69 70
                                        DCTELEM *block, 
                                        int n);
71
static inline int mpeg2_decode_block_intra(MpegEncContext *s, 
Fabrice Bellard's avatar
Fabrice Bellard committed
72 73 74
                                    DCTELEM *block, 
                                    int n);
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred);
Ivan Kalvachev's avatar
Ivan Kalvachev committed
75
static void exchange_uv(MpegEncContext *s);
Fabrice Bellard's avatar
Fabrice Bellard committed
76

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

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

88 89
static uint32_t uni_mpeg1_ac_vlc_bits[64*64*2];
static uint8_t  uni_mpeg1_ac_vlc_len [64*64*2];
90 91 92 93 94 95 96

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

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

99 100
static void init_2d_vlc_rl(RLTable *rl)
{
101
    int i;
102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124
    
    init_vlc(&rl->vlc, TEX_VLC_BITS, rl->n + 2, 
             &rl->table_vlc[0][1], 4, 2,
             &rl->table_vlc[0][0], 4, 2);

    
    rl->rl_vlc[0]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
    for(i=0; i<rl->vlc.table_size; i++){
        int code= rl->vlc.table[i][0];
        int len = rl->vlc.table[i][1];
        int level, run;
    
        if(len==0){ // illegal code
            run= 65;
            level= MAX_LEVEL;
        }else if(len<0){ //more bits needed
            run= 0;
            level= code;
        }else{
            if(code==rl->n){ //esc
                run= 65;
                level= 0;
            }else if(code==rl->n+1){ //eob
125 126
                run= 0;
                level= 127;
127 128 129 130 131 132 133 134 135 136 137
            }else{
                run=   rl->table_run  [code] + 1;
                level= rl->table_level[code];
            }
        }
        rl->rl_vlc[0][i].len= len;
        rl->rl_vlc[0][i].level= level;
        rl->rl_vlc[0][i].run= run;
    }
}

138
#ifdef CONFIG_ENCODERS
139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
static void init_uni_ac_vlc(RLTable *rl, uint32_t *uni_ac_vlc_bits, uint8_t *uni_ac_vlc_len){
    int i;

    for(i=0; i<128; i++){
        int level= i-64;
        int run;
        for(run=0; run<64; run++){
            int len, bits, code;
            
            int alevel= ABS(level);
            int sign= (level>>31)&1;

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

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

                bits|= run;
                if (alevel < 128) {
                    bits<<=8; len+=8;
                    bits|= level & 0xff;
                } else {
                    bits<<=16; len+=16;
                    bits|= level & 0xff;
                    if (level < 0) {
                        bits|= 0x8001 + level + 255;
                    } else {
                        bits|= level & 0xffff;
                    }
                }
            }

            uni_ac_vlc_bits[UNI_AC_ENC_INDEX(run, i)]= bits;
            uni_ac_vlc_len [UNI_AC_ENC_INDEX(run, i)]= len;
        }
    }
}
184

Fabrice Bellard's avatar
Fabrice Bellard committed
185 186 187
static void put_header(MpegEncContext *s, int header)
{
    align_put_bits(&s->pb);
188 189
    put_bits(&s->pb, 16, header>>16);
    put_bits(&s->pb, 16, header&0xFFFF);
Fabrice Bellard's avatar
Fabrice Bellard committed
190 191 192 193 194 195
}

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

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

            put_bits(&s->pb, 18, v & 0x3FFFF);
            put_bits(&s->pb, 1, 1); /* marker */
263 264 265 266 267 268 269 270 271 272 273 274
            put_bits(&s->pb, 10, vbv_buffer_size & 0x3FF);

            constraint_parameter_flag= 
                s->width <= 768 && s->height <= 576 && 
                s->mb_width * s->mb_height <= 396 &&
                s->mb_width * s->mb_height * frame_rate_tab[s->frame_rate_index] <= MPEG1_FRAME_RATE_BASE*396*25 &&
                frame_rate_tab[s->frame_rate_index] <= MPEG1_FRAME_RATE_BASE*30 &&
                vbv_buffer_size <= 20 &&
                v <= 1856000/400 &&
                s->codec_id == CODEC_ID_MPEG1VIDEO;
                
            put_bits(&s->pb, 1, constraint_parameter_flag);
275 276 277
            
            ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
            ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
Fabrice Bellard's avatar
Fabrice Bellard committed
278

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

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

        }
}

327 328 329 330 331 332 333 334
static inline void encode_mb_skip_run(MpegEncContext *s, int run){
    while (run >= 33) {
        put_bits(&s->pb, 11, 0x008);
        run -= 33;
    }
    put_bits(&s->pb, mbAddrIncrTable[run][1], 
             mbAddrIncrTable[run][0]);
}
Fabrice Bellard's avatar
Fabrice Bellard committed
335 336 337 338

/* insert a fake P picture */
static void mpeg1_skip_picture(MpegEncContext *s, int pict_num)
{
Michael Niedermayer's avatar
Michael Niedermayer committed
339 340
    assert(s->codec_id == CODEC_ID_MPEG1VIDEO); // mpeg2 can do these repeat things

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

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

380
static void common_init(MpegEncContext *s)
Fabrice Bellard's avatar
Fabrice Bellard committed
381
{
382 383 384
    s->y_dc_scale_table=
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
}
385

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

393
#ifdef CONFIG_ENCODERS
394 395 396 397 398 399 400

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

401 402
void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
{
Fabrice Bellard's avatar
Fabrice Bellard committed
403 404 405 406 407
    mpeg1_encode_sequence_header(s);

    /* mpeg1 picture header */
    put_header(s, PICTURE_START_CODE);
    /* temporal reference */
408 409 410

    // RAL: s->picture_number instead of s->fake_picture_number
    put_bits(&s->pb, 10, (s->picture_number - 
Fabrice Bellard's avatar
Fabrice Bellard committed
411
                          s->gop_picture_number) & 0x3ff); 
412
    s->fake_picture_number++;
Fabrice Bellard's avatar
Fabrice Bellard committed
413 414
    
    put_bits(&s->pb, 3, s->pict_type);
Michael Niedermayer's avatar
Michael Niedermayer committed
415 416 417

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

Fabrice Bellard's avatar
Fabrice Bellard committed
437
    put_bits(&s->pb, 1, 0); /* extra bit picture */
438 439

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

        put_header(s, USER_START_CODE);
        for(i=0; i<sizeof(svcd_scan_offset_placeholder); i++){
            put_bits(&s->pb, 8, svcd_scan_offset_placeholder[i]);
        }
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
485
    
486 487
    s->mb_y=0;
    ff_mpeg1_encode_slice_header(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
488 489
}

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

Fabrice Bellard's avatar
Fabrice Bellard committed
501 502 503 504
void mpeg1_encode_mb(MpegEncContext *s,
                     DCTELEM block[6][64],
                     int motion_x, int motion_y)
{
505 506 507 508
    int i, cbp;
    const int mb_x = s->mb_x;
    const int mb_y = s->mb_y;
    const int first_mb= mb_x == s->resync_mb_x && mb_y == s->resync_mb_y;
Fabrice Bellard's avatar
Fabrice Bellard committed
509 510 511 512 513 514 515

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

                if (cbp) {
                    if(s->dquant){
                        put_mb_modes(s, 5, 2, 1, 1); /* motion + cbp */
                        put_bits(&s->pb, 5, s->qscale);
                    }else{
                        put_mb_modes(s, 1, 1, 1, 1); /* motion + cbp */
603
                    }
604 605 606
                } else {
                    put_bits(&s->pb, 3, 1); /* motion only */
                    put_bits(&s->pb, 2, 1); /* motion_type: field */
607
                    s->qscale -= s->dquant;
608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668
                }
                s->misc_bits+= get_bits_diff(s);
                for(i=0; i<2; i++){
                    put_bits(&s->pb, 1, s->field_select[0][i]);
                    mpeg1_encode_motion(s, s->mv[0][i][0] -  s->last_mv[0][i][0]    , s->f_code);
                    mpeg1_encode_motion(s, s->mv[0][i][1] - (s->last_mv[0][i][1]>>1), s->f_code);
                    s->last_mv[0][i][0]=   s->mv[0][i][0];
                    s->last_mv[0][i][1]= 2*s->mv[0][i][1];
                }
                s->mv_bits+= get_bits_diff(s);
            }
            if(cbp)
                put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
            s->f_count++;
        } else{  
            static const int mb_type_len[4]={0,3,4,2}; //bak,for,bi

            if(s->mv_type == MV_TYPE_16X16){
                if (cbp){    // With coded bloc pattern
                    if (s->dquant) {
                        if(s->mv_dir == MV_DIR_FORWARD)
                            put_mb_modes(s, 6, 3, 1, 0);
                        else
                            put_mb_modes(s, mb_type_len[s->mv_dir]+3, 2, 1, 0);
                        put_bits(&s->pb, 5, s->qscale);
                    } else {
                        put_mb_modes(s, mb_type_len[s->mv_dir], 3, 1, 0);
                    }
                }else{    // No coded bloc pattern
                    put_bits(&s->pb, mb_type_len[s->mv_dir], 2);
                    if (!s->frame_pred_frame_dct)
                        put_bits(&s->pb, 2, 2); /* motion_type: frame */
                    s->qscale -= s->dquant;
                }
                s->misc_bits += get_bits_diff(s);
                if (s->mv_dir&MV_DIR_FORWARD){
                    mpeg1_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code); 
                    mpeg1_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code); 
                    s->last_mv[0][0][0]=s->last_mv[0][1][0]= s->mv[0][0][0];
                    s->last_mv[0][0][1]=s->last_mv[0][1][1]= s->mv[0][0][1];
                    s->f_count++;
                }
                if (s->mv_dir&MV_DIR_BACKWARD){
                    mpeg1_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code); 
                    mpeg1_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code); 
                    s->last_mv[1][0][0]=s->last_mv[1][1][0]= s->mv[1][0][0];
                    s->last_mv[1][0][1]=s->last_mv[1][1][1]= s->mv[1][0][1];
                    s->b_count++;
                }
            }else{
                assert(s->mv_type == MV_TYPE_FIELD);
                assert(!s->frame_pred_frame_dct);
                if (cbp){    // With coded bloc pattern
                    if (s->dquant) {
                        if(s->mv_dir == MV_DIR_FORWARD)
                            put_mb_modes(s, 6, 3, 1, 1);
                        else
                            put_mb_modes(s, mb_type_len[s->mv_dir]+3, 2, 1, 1);
                        put_bits(&s->pb, 5, s->qscale);
                    } else {
                        put_mb_modes(s, mb_type_len[s->mv_dir], 3, 1, 1);
669
                    }
670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695
                }else{    // No coded bloc pattern
                    put_bits(&s->pb, mb_type_len[s->mv_dir], 2);
                    put_bits(&s->pb, 2, 1); /* motion_type: field */
                    s->qscale -= s->dquant;
                }
                s->misc_bits += get_bits_diff(s);
                if (s->mv_dir&MV_DIR_FORWARD){
                    for(i=0; i<2; i++){
                        put_bits(&s->pb, 1, s->field_select[0][i]);
                        mpeg1_encode_motion(s, s->mv[0][i][0] -  s->last_mv[0][i][0]    , s->f_code);
                        mpeg1_encode_motion(s, s->mv[0][i][1] - (s->last_mv[0][i][1]>>1), s->f_code);
                        s->last_mv[0][i][0]=   s->mv[0][i][0];
                        s->last_mv[0][i][1]= 2*s->mv[0][i][1];
                    }
                    s->f_count++;
                }
                if (s->mv_dir&MV_DIR_BACKWARD){
                    for(i=0; i<2; i++){
                        put_bits(&s->pb, 1, s->field_select[1][i]);
                        mpeg1_encode_motion(s, s->mv[1][i][0] -  s->last_mv[1][i][0]    , s->b_code);
                        mpeg1_encode_motion(s, s->mv[1][i][1] - (s->last_mv[1][i][1]>>1), s->b_code);
                        s->last_mv[1][i][0]=   s->mv[1][i][0];
                        s->last_mv[1][i][1]= 2*s->mv[1][i][1];
                    }
                    s->b_count++;
                }
Fabrice Bellard's avatar
Fabrice Bellard committed
696
            }
697 698 699 700
            s->mv_bits += get_bits_diff(s);
            if(cbp)
                put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
701 702 703 704 705
        for(i=0;i<6;i++) {
            if (cbp & (1 << (5 - i))) {
                mpeg1_encode_block(s, block[i], i);
            }
        }
706
        s->mb_skip_run = 0;
707 708 709 710
        if(s->mb_intra)
            s->i_tex_bits+= get_bits_diff(s);
        else
            s->p_tex_bits+= get_bits_diff(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
711 712 713
    }
}

714 715
// RAL: Parameter added: f_or_b_code
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
Fabrice Bellard's avatar
Fabrice Bellard committed
716 717 718 719 720 721 722 723 724 725
{
    int code, bit_size, l, m, bits, range, sign;

    if (val == 0) {
        /* zero vector */
        code = 0;
        put_bits(&s->pb,
                 mbMotionVectorTable[0][1], 
                 mbMotionVectorTable[0][0]); 
    } else {
726
        bit_size = f_or_b_code - 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748
        range = 1 << bit_size;
        /* modulo encoding */
        l = 16 * range;
        m = 2 * l;
        if (val < -l) {
            val += m;
        } else if (val >= l) {
            val -= m;
        }

        if (val >= 0) {
            val--;
            code = (val >> bit_size) + 1;
            bits = val & (range - 1);
            sign = 0;
        } else {
            val = -val;
            val--;
            code = (val >> bit_size) + 1;
            bits = val & (range - 1);
            sign = 1;
        }
749 750 751

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

Fabrice Bellard's avatar
Fabrice Bellard committed
752 753 754
        put_bits(&s->pb,
                 mbMotionVectorTable[code][1], 
                 mbMotionVectorTable[code][0]); 
755

Fabrice Bellard's avatar
Fabrice Bellard committed
756 757 758 759 760 761 762
        put_bits(&s->pb, 1, sign);
        if (bit_size > 0) {
            put_bits(&s->pb, bit_size, bits);
        }
    }
}

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

    common_init(s);

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

        done=1;
775
        init_rl(&rl_mpeg1);
776

777 778 779 780 781
	for(i=0; i<64; i++)
	{
		mpeg1_max_level[0][i]= rl_mpeg1.max_level[0][i];
		mpeg1_index_run[0][i]= rl_mpeg1.index_run[0][i];
	}
782 783
        
        init_uni_ac_vlc(&rl_mpeg1, uni_mpeg1_ac_vlc_bits, uni_mpeg1_ac_vlc_len);
784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804

	/* build unified dc encoding tables */
	for(i=-255; i<256; i++)
	{
		int adiff, index;
		int bits, code;
		int diff=i;

		adiff = ABS(diff);
		if(diff<0) diff--;
		index = vlc_dc_table[adiff];

		bits= vlc_dc_lum_bits[index] + index;
		code= (vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1));
		mpeg1_lum_dc_uni[i+255]= bits + (code<<8);
		
		bits= vlc_dc_chroma_bits[index] + index;
		code= (vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1));
		mpeg1_chr_dc_uni[i+255]= bits + (code<<8);
	}

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

807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840
        for(f_code=1; f_code<=MAX_FCODE; f_code++){
            for(mv=-MAX_MV; mv<=MAX_MV; mv++){
                int len;

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

                    bit_size = s->f_code - 1;
                    range = 1 << bit_size;

                    val=mv;
                    if (val < 0) 
                        val = -val;
                    val--;
                    code = (val >> bit_size) + 1;
                    if(code<17){
                        len= mbMotionVectorTable[code][1] + 1 + bit_size;
                    }else{
                        len= mbMotionVectorTable[16][1] + 2 + bit_size;
                    }
                }

                mv_penalty[f_code][mv+MAX_MV]= len;
            }
        }
        

        for(f_code=MAX_FCODE; f_code>0; f_code--){
            for(mv=-(8<<f_code); mv<(8<<f_code); mv++){
                fcode_tab[mv+MAX_MV]= f_code;
            }
        }
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
841
    s->me.mv_penalty= mv_penalty;
842
    s->fcode_tab= fcode_tab;
Michael Niedermayer's avatar
Michael Niedermayer committed
843 844 845 846 847 848 849
    if(s->codec_id == CODEC_ID_MPEG1VIDEO){
        s->min_qcoeff=-255;
        s->max_qcoeff= 255;
    }else{
        s->min_qcoeff=-2047;
        s->max_qcoeff= 2047;
    }
850
    s->intra_ac_vlc_length=
851 852 853
    s->inter_ac_vlc_length=
    s->intra_ac_vlc_last_length=
    s->inter_ac_vlc_last_length= uni_mpeg1_ac_vlc_len;
854
}
855

Fabrice Bellard's avatar
Fabrice Bellard committed
856 857 858
static inline void encode_dc(MpegEncContext *s, int diff, int component)
{
    if (component == 0) {
859 860 861 862
        put_bits(
	    &s->pb, 
	    mpeg1_lum_dc_uni[diff+255]&0xFF,
	    mpeg1_lum_dc_uni[diff+255]>>8);
Fabrice Bellard's avatar
Fabrice Bellard committed
863
    } else {
864 865 866 867
        put_bits(
            &s->pb, 
	    mpeg1_chr_dc_uni[diff+255]&0xFF,
	    mpeg1_chr_dc_uni[diff+255]>>8);
Fabrice Bellard's avatar
Fabrice Bellard committed
868 869 870 871 872 873 874 875 876
    }
}

static void mpeg1_encode_block(MpegEncContext *s, 
                               DCTELEM *block, 
                               int n)
{
    int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
    int code, component;
877
//    RLTable *rl = &rl_mpeg1;
Fabrice Bellard's avatar
Fabrice Bellard committed
878 879 880 881 882 883 884 885 886 887 888

    last_index = s->block_last_index[n];

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

    /* now quantify & encode AC coefs */
    last_non_zero = i - 1;
912

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

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

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

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

972
static void init_vlcs()
Fabrice Bellard's avatar
Fabrice Bellard committed
973 974 975 976
{
    static int done = 0;

    if (!done) {
977
        done = 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
978

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

        init_2d_vlc_rl(&rl_mpeg1);
        init_2d_vlc_rl(&rl_mpeg2);
Fabrice Bellard's avatar
Fabrice Bellard committed
1006 1007 1008 1009 1010
    }
}

static inline int get_dmv(MpegEncContext *s)
{
1011 1012
    if(get_bits1(&s->gb)) 
        return 1 - (get_bits1(&s->gb) << 1);
Fabrice Bellard's avatar
Fabrice Bellard committed
1013 1014 1015 1016
    else
        return 0;
}

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

Fabrice Bellard's avatar
Fabrice Bellard committed
1027 1028 1029 1030 1031 1032 1033 1034 1035
/* motion type (for mpeg2) */
#define MT_FIELD 1
#define MT_FRAME 2
#define MT_16X8  2
#define MT_DMV   3

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

1040 1041
    assert(s->mb_skiped==0);

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

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

1072 1073
            if((s->mv[0][0][0]|s->mv[0][0][1]|s->mv[1][0][0]|s->mv[1][0][1])==0) 
                s->mb_skiped = 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
1074
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
1075

Fabrice Bellard's avatar
Fabrice Bellard committed
1076 1077 1078 1079 1080 1081
        return 0;
    }

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

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

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

Michael Niedermayer's avatar
Michael Niedermayer committed
1145
        if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
1146
            for(i=0;i<6;i++) {
1147
                if (mpeg2_decode_block_intra(s, s->pblocks[i], i) < 0)
1148 1149 1150 1151
                    return -1;
            }
        } else {
            for(i=0;i<6;i++) {
1152
                if (mpeg1_decode_block_intra(s, s->pblocks[i], i) < 0)
1153 1154 1155
                    return -1;
            }
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
1156
    } else {
1157
        if (mb_type & MB_TYPE_ZERO_MV){
1158
            assert(mb_type & MB_TYPE_CBP);
1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188

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

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

            s->mv_dir = MV_DIR_FORWARD;
            s->mv_type = MV_TYPE_16X16;
            s->last_mv[0][0][0] = 0;
            s->last_mv[0][0][1] = 0;
            s->last_mv[0][1][0] = 0;
            s->last_mv[0][1][1] = 0;
            s->mv[0][0][0] = 0;
            s->mv[0][0][1] = 0;
        }else{
            assert(mb_type & MB_TYPE_L0L1);
//FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
            /* get additionnal motion vector type */
            if (s->frame_pred_frame_dct) 
                motion_type = MT_FRAME;
            else{
                motion_type = get_bits(&s->gb, 2);
            }

            /* compute dct type */
            if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1189
                !s->frame_pred_frame_dct && HAS_CBP(mb_type)) {
1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211
                s->interlaced_dct = get_bits1(&s->gb);
            }

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

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

                            mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0], 
                                                    s->last_mv[i][0][0]);
                            s->last_mv[i][0][0] = mx;
                            s->last_mv[i][1][0] = mx;
                            dmx = get_dmv(s);
                            my = mpeg_decode_motion(s, s->mpeg_f_code[i][1], 
                                                    s->last_mv[i][0][1] >> 1);
                            dmy = get_dmv(s);
                            s->mv_type = MV_TYPE_DMV;
1274 1275 1276 1277 1278 1279 1280 1281 1282 1283


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

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

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

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

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

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

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

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

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

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

Fabrice Bellard's avatar
Fabrice Bellard committed
1365 1366 1367 1368 1369 1370
    return 0;
}

/* as h263, but only 17 codes */
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
{
1371
    int code, sign, val, l, shift;
Fabrice Bellard's avatar
Fabrice Bellard committed
1372

1373
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
Fabrice Bellard's avatar
Fabrice Bellard committed
1374 1375 1376
    if (code == 0) {
        return pred;
    }
1377 1378 1379 1380
    if (code < 0) {
        return 0xffff;
    }

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

1399
static inline int decode_dc(GetBitContext *gb, int component)
Fabrice Bellard's avatar
Fabrice Bellard committed
1400 1401 1402 1403
{
    int code, diff;

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

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

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

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

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

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

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

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

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

    mismatch = 1;

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

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

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

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

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

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

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

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

static int mpeg_decode_init(AVCodecContext *avctx)
{
    Mpeg1Context *s = avctx->priv_data;
1740
    
1741
    s->mpeg_enc_ctx.avctx= avctx;
Michael Niedermayer's avatar
Michael Niedermayer committed
1742
    s->mpeg_enc_ctx.flags= avctx->flags;
1743
    common_init(&s->mpeg_enc_ctx);
1744
    init_vlcs();
Fabrice Bellard's avatar
Fabrice Bellard committed
1745 1746 1747

    s->mpeg_enc_ctx_allocated = 0;
    s->mpeg_enc_ctx.picture_number = 0;
1748
    s->repeat_field = 0;
1749
    s->mpeg_enc_ctx.codec_id= avctx->codec->id;
Fabrice Bellard's avatar
Fabrice Bellard committed
1750 1751 1752 1753 1754
    return 0;
}

/* return the 8 bit start code value and update the search
   state. Return -1 if no start code found */
1755
static int find_start_code(uint8_t **pbuf_ptr, uint8_t *buf_end)
Fabrice Bellard's avatar
Fabrice Bellard committed
1756
{
1757
    uint8_t *buf_ptr;
1758
    unsigned int state=0xFFFFFFFF, v;
Fabrice Bellard's avatar
Fabrice Bellard committed
1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777
    int val;

    buf_ptr = *pbuf_ptr;
    while (buf_ptr < buf_end) {
        v = *buf_ptr++;
        if (state == 0x000001) {
            state = ((state << 8) | v) & 0xffffff;
            val = state;
            goto found;
        }
        state = ((state << 8) | v) & 0xffffff;
    }
    val = -1;
 found:
    *pbuf_ptr = buf_ptr;
    return val;
}

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

1784
    init_get_bits(&s->gb, buf, buf_size*8);
Fabrice Bellard's avatar
Fabrice Bellard committed
1785 1786 1787

    ref = get_bits(&s->gb, 10); /* temporal ref */
    s->pict_type = get_bits(&s->gb, 3);
Michael Niedermayer's avatar
Michael Niedermayer committed
1788

Michael Niedermayer's avatar
Michael Niedermayer committed
1789
    vbv_delay= get_bits(&s->gb, 16);
Fabrice Bellard's avatar
Fabrice Bellard committed
1790
    if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
1791
        s->full_pel[0] = get_bits1(&s->gb);
Fabrice Bellard's avatar
Fabrice Bellard committed
1792 1793 1794 1795 1796 1797 1798
        f_code = get_bits(&s->gb, 3);
        if (f_code == 0)
            return -1;
        s->mpeg_f_code[0][0] = f_code;
        s->mpeg_f_code[0][1] = f_code;
    }
    if (s->pict_type == B_TYPE) {
1799
        s->full_pel[1] = get_bits1(&s->gb);
Fabrice Bellard's avatar
Fabrice Bellard committed
1800 1801 1802 1803 1804 1805
        f_code = get_bits(&s->gb, 3);
        if (f_code == 0)
            return -1;
        s->mpeg_f_code[1][0] = f_code;
        s->mpeg_f_code[1][1] = f_code;
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
1806 1807
    s->current_picture.pict_type= s->pict_type;
    s->current_picture.key_frame= s->pict_type == I_TYPE;
1808
    
Michael Niedermayer's avatar
Michael Niedermayer committed
1809 1810 1811
//    if(avctx->debug & FF_DEBUG_PICT_INFO)
//        av_log(avctx, AV_LOG_DEBUG, "vbv_delay %d, ref %d\n", vbv_delay, ref);
    
Fabrice Bellard's avatar
Fabrice Bellard committed
1812 1813 1814 1815 1816 1817 1818 1819 1820
    s->y_dc_scale = 8;
    s->c_dc_scale = 8;
    s->first_slice = 1;
    return 0;
}

static void mpeg_decode_sequence_extension(MpegEncContext *s)
{
    int horiz_size_ext, vert_size_ext;
1821
    int bit_rate_ext;
Fabrice Bellard's avatar
Fabrice Bellard committed
1822
    int frame_rate_ext_n, frame_rate_ext_d;
Michael Niedermayer's avatar
Michael Niedermayer committed
1823
    int level, profile;
Fabrice Bellard's avatar
Fabrice Bellard committed
1824

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

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

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

Fabrice Bellard's avatar
Fabrice Bellard committed
1851
    dprintf("sequence extension\n");
Michael Niedermayer's avatar
Michael Niedermayer committed
1852
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
1853
    s->avctx->sub_id = 2; /* indicates mpeg2 found */
1854

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

1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889
static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
{
    MpegEncContext *s= &s1->mpeg_enc_ctx;
    int color_description, w, h;

    skip_bits(&s->gb, 3); /* video format */
    color_description= get_bits1(&s->gb);
    if(color_description){
        skip_bits(&s->gb, 8); /* color primaries */
        skip_bits(&s->gb, 8); /* transfer_characteristics */
        skip_bits(&s->gb, 8); /* matrix_coefficients */
    }
    w= get_bits(&s->gb, 14);
    skip_bits(&s->gb, 1); //marker
    h= get_bits(&s->gb, 14);
    skip_bits(&s->gb, 1); //marker
    
    s1->pan_scan.width= 16*w;
    s1->pan_scan.height=16*h;

Michael Niedermayer's avatar
Michael Niedermayer committed
1890 1891 1892 1893 1894 1895
    if(s->aspect_ratio_info > 1)
        s->avctx->sample_aspect_ratio= 
            av_div_q(
                mpeg2_aspect[s->aspect_ratio_info], 
                (AVRational){w, h}
            );
1896 1897
    
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1898
        av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913
}

static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
{
    MpegEncContext *s= &s1->mpeg_enc_ctx;
    int i;

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

Fabrice Bellard's avatar
Fabrice Bellard committed
1921 1922
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
{
1923
    int i, v, j;
Fabrice Bellard's avatar
Fabrice Bellard committed
1924

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

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

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

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

static void mpeg_decode_extension(AVCodecContext *avctx, 
2006
                                  uint8_t *buf, int buf_size)
Fabrice Bellard's avatar
Fabrice Bellard committed
2007 2008 2009 2010 2011
{
    Mpeg1Context *s1 = avctx->priv_data;
    MpegEncContext *s = &s1->mpeg_enc_ctx;
    int ext_type;

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

2034 2035 2036 2037 2038 2039
static void exchange_uv(MpegEncContext *s){
short * tmp;

    tmp = s->pblocks[4];
    s->pblocks[4] = s->pblocks[5];
    s->pblocks[5] = tmp;
Michael Niedermayer's avatar
Michael Niedermayer committed
2040 2041
}

Michael Niedermayer's avatar
Michael Niedermayer committed
2042 2043 2044 2045 2046 2047 2048 2049 2050 2051
#define DECODE_SLICE_FATAL_ERROR -2
#define DECODE_SLICE_ERROR -1
#define DECODE_SLICE_OK 0

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

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

        ff_er_frame_start(s);

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

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

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

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

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

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

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

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

2177
        ret = mpeg_decode_mb(s, s->block);
Michael Niedermayer's avatar
Michael Niedermayer committed
2178
        s->chroma_qscale= s->qscale;
2179

Fabrice Bellard's avatar
Fabrice Bellard committed
2180 2181 2182
        dprintf("ret=%d\n", ret);
        if (ret < 0)
            return -1;
2183

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

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

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

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

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

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

2238 2239
        MPV_decode_mb(s, s->block);
        
2240
        if (++s->mb_x >= s->mb_width) {
Michael Niedermayer's avatar
Michael Niedermayer committed
2241

2242
            ff_draw_horiz_band(s, 16*s->mb_y, 16);
2243 2244 2245

            s->mb_x = 0;
            s->mb_y++;
2246 2247 2248 2249 2250 2251

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

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

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

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

Ivan Kalvachev's avatar
Ivan Kalvachev committed
2307 2308 2309 2310
#ifdef HAVE_XVMC
    if(s->avctx->xvmc_acceleration)
        XVMC_field_end(s);
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
2311
    /* end of slice reached */
2312
    if (/*s->mb_y<<field_pic == s->mb_height &&*/ !s->first_field) {
Fabrice Bellard's avatar
Fabrice Bellard committed
2313
        /* end of image */
Michael Niedermayer's avatar
Michael Niedermayer committed
2314

Michael Niedermayer's avatar
Michael Niedermayer committed
2315
        s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2;
Michael Niedermayer's avatar
Michael Niedermayer committed
2316

2317
        ff_er_frame_end(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
2318 2319 2320

        MPV_frame_end(s);

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

2334
        return 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
2335
    } else {
2336
        return 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
2337 2338 2339 2340
    }
}

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

2348
    init_get_bits(&s->gb, buf, buf_size*8);
Fabrice Bellard's avatar
Fabrice Bellard committed
2349 2350 2351

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

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

Fabrice Bellard's avatar
Fabrice Bellard committed
2394 2395 2396
        if (MPV_common_init(s) < 0)
            return -1;
        s1->mpeg_enc_ctx_allocated = 1;
2397
        s->swap_uv = 0;//just in case vcr2 and mpeg2 stream have been concatinated
Fabrice Bellard's avatar
Fabrice Bellard committed
2398 2399
    }

2400
    s->avctx->rc_buffer_size= get_bits(&s->gb, 10) * 1024*16;
2401
    skip_bits(&s->gb, 1);
Fabrice Bellard's avatar
Fabrice Bellard committed
2402 2403

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

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

2463 2464 2465 2466
static int vcr2_init_sequence(AVCodecContext *avctx)
{
    Mpeg1Context *s1 = avctx->priv_data;
    MpegEncContext *s = &s1->mpeg_enc_ctx;
Michael Niedermayer's avatar
Michael Niedermayer committed
2467
    int i, v;
2468 2469 2470 2471 2472 2473 2474 2475 2476

    /* start new mpeg1 context decoding */
    s->out_format = FMT_MPEG1;
    if (s1->mpeg_enc_ctx_allocated) {
        MPV_common_end(s);
    }
    s->width = avctx->width;
    s->height = avctx->height;
    avctx->has_b_frames= 0; //true?
Michael Niedermayer's avatar
Michael Niedermayer committed
2477
    s->low_delay= 1;
Ivan Kalvachev's avatar
Ivan Kalvachev committed
2478 2479 2480 2481

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

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

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

    s->progressive_sequence = 1;
    s->progressive_frame = 1;
    s->picture_structure = PICT_FRAME;
    s->frame_pred_frame_dct = 1;
Michael Niedermayer's avatar
Michael Niedermayer committed
2506
    s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
Michael Niedermayer's avatar
Michael Niedermayer committed
2507
    avctx->sub_id = 2; /* indicates mpeg2 */
2508 2509 2510 2511
    return 0;
}


2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540
static void mpeg_decode_user_data(AVCodecContext *avctx, 
                                  const uint8_t *buf, int buf_size)
{
    const uint8_t *p;
    int len, flags;
    p = buf;
    len = buf_size;

    /* we parse the DTG active format information */
    if (len >= 5 &&
        p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
        flags = p[4];
        p += 5;
        len -= 5;
        if (flags & 0x80) {
            /* skip event id */
            if (len < 2)
                return;
            p += 2;
            len -= 2;
        }
        if (flags & 0x40) {
            if (len < 1)
                return;
            avctx->dtg_active_format = p[0] & 0x0f;
        }
    }
}

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

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

    *data_size = 0;
2593

Fabrice Bellard's avatar
Fabrice Bellard committed
2594
    /* special case for last picture */
2595 2596 2597
    if (buf_size == 0 && s2->low_delay==0 && s2->next_picture_ptr) {
        *picture= *(AVFrame*)s2->next_picture_ptr;
        s2->next_picture_ptr= NULL;
Michael Niedermayer's avatar
Michael Niedermayer committed
2598

2599
        *data_size = sizeof(AVFrame);
Fabrice Bellard's avatar
Fabrice Bellard committed
2600 2601 2602
        return 0;
    }

2603
    if(s2->flags&CODEC_FLAG_TRUNCATED){
2604
        int next= mpeg1_find_frame_end(s2, buf, buf_size);
2605 2606 2607 2608 2609
        
        if( ff_combine_frame(s2, next, &buf, &buf_size) < 0 )
            return buf_size;
    }    
    
Fabrice Bellard's avatar
Fabrice Bellard committed
2610 2611
    buf_ptr = buf;
    buf_end = buf + buf_size;
2612 2613 2614

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

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

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

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

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

Fabrice Bellard's avatar
Fabrice Bellard committed
2683
                        ret = mpeg_decode_slice(avctx, picture,
2684
                                                start_code, &buf_ptr, input_size);
2685
                        emms_c();
2686

2687 2688
                        if(ret < 0){
                            if(s2->resync_mb_x>=0 && s2->resync_mb_y>=0)
2689
                                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);
2690 2691 2692
                            if(ret==DECODE_SLICE_FATAL_ERROR) return -1;
                        }else{
                            ff_er_add_slice(s2, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x-1, s2->mb_y, AC_END|DC_END|MV_END);
Fabrice Bellard's avatar
Fabrice Bellard committed
2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708
                        }
                    }
                    break;
                }
    }
}

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

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

2709 2710
AVCodec mpeg1video_decoder = {
    "mpeg1video",
Fabrice Bellard's avatar
Fabrice Bellard committed
2711 2712 2713 2714 2715 2716 2717
    CODEC_TYPE_VIDEO,
    CODEC_ID_MPEG1VIDEO,
    sizeof(Mpeg1Context),
    mpeg_decode_init,
    NULL,
    mpeg_decode_end,
    mpeg_decode_frame,
2718
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731
    .flush= ff_mpeg_flush,
};

AVCodec mpeg2video_decoder = {
    "mpeg2video",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MPEG2VIDEO,
    sizeof(Mpeg1Context),
    mpeg_decode_init,
    NULL,
    mpeg_decode_end,
    mpeg_decode_frame,
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
Ivan Kalvachev's avatar
Ivan Kalvachev committed
2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745
    .flush= ff_mpeg_flush,
};

//legacy decoder
AVCodec mpegvideo_decoder = {
    "mpegvideo",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MPEG2VIDEO,
    sizeof(Mpeg1Context),
    mpeg_decode_init,
    NULL,
    mpeg_decode_end,
    mpeg_decode_frame,
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
Michael Niedermayer's avatar
Michael Niedermayer committed
2746
    .flush= ff_mpeg_flush,
Fabrice Bellard's avatar
Fabrice Bellard committed
2747
};
Ivan Kalvachev's avatar
Ivan Kalvachev committed
2748 2749 2750 2751 2752 2753 2754

#ifdef HAVE_XVMC
static int mpeg_mc_decode_init(AVCodecContext *avctx){
    Mpeg1Context *s;

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

    avctx->pix_fmt = PIX_FMT_XVMC_MPEG2_IDCT;
2762
    avctx->xvmc_acceleration = 2;//2 - the blocks are packed!
Ivan Kalvachev's avatar
Ivan Kalvachev committed
2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779

    return 0;
}

AVCodec mpeg_xvmc_decoder = {
    "mpegvideo_xvmc",
    CODEC_TYPE_VIDEO,
    CODEC_ID_MPEG2VIDEO_XVMC,
    sizeof(Mpeg1Context),
    mpeg_mc_decode_init,
    NULL,
    mpeg_decode_end,
    mpeg_decode_frame,
    CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
};

#endif
2780 2781 2782 2783 2784

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