mpeg12.c 63 KB
Newer Older
Fabrice Bellard's avatar
Fabrice Bellard committed
1 2
/*
 * MPEG1 encoder / MPEG2 decoder
Fabrice Bellard's avatar
Fabrice Bellard committed
3
 * Copyright (c) 2000,2001 Fabrice Bellard.
Fabrice Bellard's avatar
Fabrice Bellard committed
4
 *
Fabrice Bellard's avatar
Fabrice Bellard committed
5 6 7 8
 * 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
9
 *
Fabrice Bellard's avatar
Fabrice Bellard committed
10
 * This library is distributed in the hope that it will be useful,
Fabrice Bellard's avatar
Fabrice Bellard committed
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
Fabrice Bellard's avatar
Fabrice Bellard committed
12 13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
Fabrice Bellard's avatar
Fabrice Bellard committed
14
 *
Fabrice Bellard's avatar
Fabrice Bellard committed
15 16 17
 * 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
18
 */
Fabrice Bellard's avatar
Fabrice Bellard committed
19
//#define DEBUG
Fabrice Bellard's avatar
Fabrice Bellard committed
20 21 22 23 24 25
#include "avcodec.h"
#include "dsputil.h"
#include "mpegvideo.h"

#include "mpeg12data.h"

26 27 28 29 30 31
#if 1
#define PRINT_QP(a, b) {}
#else
#define PRINT_QP(a, b) printf(a, b)
#endif

Fabrice Bellard's avatar
Fabrice Bellard committed
32 33 34 35 36 37 38 39 40 41
/* 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

42 43 44 45 46 47 48 49
#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

Fabrice Bellard's avatar
Fabrice Bellard committed
50 51 52 53 54
static void mpeg1_encode_block(MpegEncContext *s, 
                         DCTELEM *block, 
                         int component);
static void mpeg1_encode_motion(MpegEncContext *s, int val);
static void mpeg1_skip_picture(MpegEncContext *s, int pict_num);
55 56 57 58
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
59 60
                              DCTELEM *block, 
                              int n);
61
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 
Fabrice Bellard's avatar
Fabrice Bellard committed
62 63
                                        DCTELEM *block, 
                                        int n);
64
static inline int mpeg2_decode_block_intra(MpegEncContext *s, 
Fabrice Bellard's avatar
Fabrice Bellard committed
65 66 67 68
                                    DCTELEM *block, 
                                    int n);
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred);

69
static UINT16 mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
70 71
static UINT8 fcode_tab[MAX_MV*2+1];

72 73
static void init_2d_vlc_rl(RLTable *rl)
{
74
    int i;
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97
    
    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
98 99
                run= 0;
                level= 127;
100 101 102 103 104 105 106 107 108 109 110 111
            }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;
    }
}


Fabrice Bellard's avatar
Fabrice Bellard committed
112 113 114
static void put_header(MpegEncContext *s, int header)
{
    align_put_bits(&s->pb);
115 116
    put_bits(&s->pb, 16, header>>16);
    put_bits(&s->pb, 16, header&0xFFFF);
Fabrice Bellard's avatar
Fabrice Bellard committed
117 118 119 120 121 122
}

/* 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
123 124
        unsigned int fps, v;
        int n;
Fabrice Bellard's avatar
Fabrice Bellard committed
125 126
        UINT64 time_code;
        
127
        if (s->picture_in_gop_number == 0) {
Fabrice Bellard's avatar
Fabrice Bellard committed
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
            /* 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;
                for(i=1;i<9;i++) {
                    d = abs(s->frame_rate - frame_rate_tab[i]);
                    if (d < dmin) {
                        dmin = d;
                        s->frame_rate_index = i;
                    }
                }
            }
 
            put_bits(&s->pb, 12, s->width);
            put_bits(&s->pb, 12, s->height);
            put_bits(&s->pb, 4, 1); /* 1/1 aspect ratio */
            put_bits(&s->pb, 4, s->frame_rate_index);
            v = s->bit_rate / 400;
            if (v > 0x3ffff)
                v = 0x3ffff;
            put_bits(&s->pb, 18, v);
            put_bits(&s->pb, 1, 1); /* marker */
154 155 156 157 158 159

            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 */
                vbv_buffer_size = (( 20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024;	 
Fabrice Bellard's avatar
Fabrice Bellard committed
160 161 162 163 164 165 166 167 168 169
            put_bits(&s->pb, 10, (vbv_buffer_size + 16383) / 16384); 
            put_bits(&s->pb, 1, 1); /* constrained parameter flag */
            put_bits(&s->pb, 1, 0); /* no custom intra matrix */
            put_bits(&s->pb, 1, 0); /* no custom non intra matrix */

            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 */
            fps = frame_rate_tab[s->frame_rate_index];
170
            time_code = (INT64)s->fake_picture_number * FRAME_RATE_BASE;
Fabrice Bellard's avatar
Fabrice Bellard committed
171
            s->gop_picture_number = s->fake_picture_number;
Fabrice Bellard's avatar
Fabrice Bellard committed
172 173
            put_bits(&s->pb, 5, (UINT32)((time_code / (fps * 3600)) % 24));
            put_bits(&s->pb, 6, (UINT32)((time_code / (fps * 60)) % 60));
Fabrice Bellard's avatar
Fabrice Bellard committed
174
            put_bits(&s->pb, 1, 1);
Fabrice Bellard's avatar
Fabrice Bellard committed
175 176
            put_bits(&s->pb, 6, (UINT32)((time_code / fps) % 60));
            put_bits(&s->pb, 6, (UINT32)((time_code % fps) / FRAME_RATE_BASE));
Fabrice Bellard's avatar
Fabrice Bellard committed
177 178 179 180 181 182 183 184
            put_bits(&s->pb, 1, 1); /* closed gop */
            put_bits(&s->pb, 1, 0); /* broken link */
        }

        if (s->frame_rate < (24 * FRAME_RATE_BASE) && s->picture_number > 0) {
            /* 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];
185
            n = (((INT64)s->picture_number * fps) / s->frame_rate) - 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246
            while (s->fake_picture_number < n) {
                mpeg1_skip_picture(s, s->fake_picture_number - 
                                   s->gop_picture_number); 
                s->fake_picture_number++;
            }

        }
}


/* insert a fake P picture */
static void mpeg1_skip_picture(MpegEncContext *s, int pict_num)
{
    unsigned int mb_incr;

    /* 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 */
    
    mb_incr = 1;
    put_bits(&s->pb, mbAddrIncrTable[mb_incr - 1][1], 
             mbAddrIncrTable[mb_incr - 1][0]);
    
    /* 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 */
    mb_incr = s->mb_width * s->mb_height - 1;
    while (mb_incr > 33) {
        put_bits(&s->pb, 11, 0x008);
        mb_incr -= 33;
    }
    put_bits(&s->pb, mbAddrIncrTable[mb_incr - 1][1], 
             mbAddrIncrTable[mb_incr - 1][0]);
    
    /* 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); 
}

247
static void common_init(MpegEncContext *s)
Fabrice Bellard's avatar
Fabrice Bellard committed
248
{
249 250 251
    s->y_dc_scale_table=
    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
}
252

253 254
void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
{
Fabrice Bellard's avatar
Fabrice Bellard committed
255 256 257 258 259 260 261
    mpeg1_encode_sequence_header(s);

    /* mpeg1 picture header */
    put_header(s, PICTURE_START_CODE);
    /* temporal reference */
    put_bits(&s->pb, 10, (s->fake_picture_number - 
                          s->gop_picture_number) & 0x3ff); 
262
    s->fake_picture_number++;
Fabrice Bellard's avatar
Fabrice Bellard committed
263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
    
    put_bits(&s->pb, 3, s->pict_type);
    put_bits(&s->pb, 16, 0xffff); /* non constant bit rate */
    
    if (s->pict_type == P_TYPE) {
        put_bits(&s->pb, 1, 0); /* half pel coordinates */
        put_bits(&s->pb, 3, s->f_code); /* 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, s->qscale); /* quantizer scale */
    put_bits(&s->pb, 1, 0); /* slice extra information */
}

void mpeg1_encode_mb(MpegEncContext *s,
                     DCTELEM block[6][64],
                     int motion_x, int motion_y)
{
    int mb_incr, i, cbp, mb_x, mb_y;

    mb_x = s->mb_x;
    mb_y = s->mb_y;

    /* compute cbp */
    cbp = 0;
    for(i=0;i<6;i++) {
        if (s->block_last_index[i] >= 0)
            cbp |= 1 << (5 - i);
    }

    /* skip macroblock, except if first or last macroblock of a slice */
    if ((cbp | motion_x | motion_y) == 0 &&
        (!((mb_x | mb_y) == 0 ||
           (mb_x == s->mb_width - 1 && mb_y == s->mb_height - 1)))) {
        s->mb_incr++;
301
        s->qscale -= s->dquant;
Fabrice Bellard's avatar
Fabrice Bellard committed
302 303 304 305 306 307 308 309 310 311 312 313
    } else {
        /* output mb incr */
        mb_incr = s->mb_incr;

        while (mb_incr > 33) {
            put_bits(&s->pb, 11, 0x008);
            mb_incr -= 33;
        }
        put_bits(&s->pb, mbAddrIncrTable[mb_incr - 1][1], 
                 mbAddrIncrTable[mb_incr - 1][0]);
        
        if (s->pict_type == I_TYPE) {
314 315 316 317 318 319 320
            if(s->dquant && cbp){
                put_bits(&s->pb, 2, 1); /* macroblock_type : macroblock_quant = 1 */
                put_bits(&s->pb, 5, s->qscale);
            }else{
                put_bits(&s->pb, 1, 1); /* macroblock_type : macroblock_quant = 0 */
                s->qscale -= s->dquant;
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
321 322
        } else {
            if (s->mb_intra) {
323 324 325 326 327 328 329
                if(s->dquant && cbp){
                    put_bits(&s->pb, 6, 0x01);
                    put_bits(&s->pb, 5, s->qscale);
                }else{
                    put_bits(&s->pb, 5, 0x03);
                    s->qscale -= s->dquant;
                }
Fabrice Bellard's avatar
Fabrice Bellard committed
330 331 332
            } else {
                if (cbp != 0) {
                    if (motion_x == 0 && motion_y == 0) {
333 334 335 336 337 338
                        if(s->dquant){
                            put_bits(&s->pb, 5, 1); /* macroblock_pattern & quant */
                            put_bits(&s->pb, 5, s->qscale);
                        }else{
                            put_bits(&s->pb, 2, 1); /* macroblock_pattern only */
                        }
Fabrice Bellard's avatar
Fabrice Bellard committed
339 340
                        put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
                    } else {
341 342 343 344 345 346
                        if(s->dquant){
                            put_bits(&s->pb, 5, 2); /* motion + cbp */
                            put_bits(&s->pb, 5, s->qscale);
                        }else{
                            put_bits(&s->pb, 1, 1); /* motion + cbp */
                        }
Fabrice Bellard's avatar
Fabrice Bellard committed
347 348 349 350 351 352 353 354
                        mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0]); 
                        mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1]); 
                        put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
                    }
                } else {
                    put_bits(&s->pb, 3, 1); /* motion only */
                    mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0]); 
                    mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1]); 
355
                    s->qscale -= s->dquant;
Fabrice Bellard's avatar
Fabrice Bellard committed
356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413
                }
            }
        }
        for(i=0;i<6;i++) {
            if (cbp & (1 << (5 - i))) {
                mpeg1_encode_block(s, block[i], i);
            }
        }
        s->mb_incr = 1;
    }
    s->last_mv[0][0][0] = motion_x;
    s->last_mv[0][0][1] = motion_y;
}

static void mpeg1_encode_motion(MpegEncContext *s, int val)
{
    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 {
        bit_size = s->f_code - 1;
        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;
        }
        put_bits(&s->pb,
                 mbMotionVectorTable[code][1], 
                 mbMotionVectorTable[code][0]); 
        put_bits(&s->pb, 1, sign);
        if (bit_size > 0) {
            put_bits(&s->pb, bit_size, bits);
        }
    }
}

414
void ff_mpeg1_encode_init(MpegEncContext *s)
415 416
{
    static int done=0;
417 418 419

    common_init(s);

420 421 422
    if(!done){
        int f_code;
        int mv;
423
	int i;
424 425

        done=1;
426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453
        init_rl(&rl_mpeg1);
	
	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];
	}

	/* 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);
	}

454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489
        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;
            }
        }
    }
    s->mv_penalty= mv_penalty;
    s->fcode_tab= fcode_tab;
490 491 492 493
    s->min_qcoeff=-255;
    s->max_qcoeff= 255;
    s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
    s->inter_quant_bias= 0;
494
}
495

Fabrice Bellard's avatar
Fabrice Bellard committed
496 497 498
static inline void encode_dc(MpegEncContext *s, int diff, int component)
{
    if (component == 0) {
499 500 501 502
        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
503
    } else {
504 505 506 507
        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
508 509 510 511 512 513 514 515 516
    }
}

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;
517
//    RLTable *rl = &rl_mpeg1;
Fabrice Bellard's avatar
Fabrice Bellard committed
518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545

    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;
    } else {
        /* encode the first coefficient : needs to be done here because
           it is handled slightly differently */
        level = block[0];
        if (abs(level) == 1) {
                code = ((UINT32)level >> 31); /* the sign bit */
                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;
546

Fabrice Bellard's avatar
Fabrice Bellard committed
547
    for(;i<=last_index;i++) {
548
        j = s->intra_scantable.permutated[i];
Fabrice Bellard's avatar
Fabrice Bellard committed
549 550 551 552 553 554 555 556 557
        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;
558 559 560 561 562
            
            alevel= level;
            MASK_ABS(sign, alevel)
            sign&=1;

563 564 565 566 567 568 569 570 571
//            code = get_rl_index(rl, 0, run, alevel);
            if (alevel > mpeg1_max_level[0][run])
                code= 111; /*rl->n*/
            else
                code= mpeg1_index_run[0][run] + alevel - 1;

            if (code < 111 /* rl->n */) {
	    	/* 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
572
            } else {
573 574
		/* 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
575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604
                /* escape: only clip in this case */
                put_bits(&s->pb, 6, run);
                if (alevel < 128) {
                    put_bits(&s->pb, 8, level & 0xff);
                } else {
                    if (level < 0) {
                        put_bits(&s->pb, 16, 0x8001 + level + 255);
                    } else {
                        put_bits(&s->pb, 16, level & 0xffff);
                    }
                }
            }
            last_non_zero = i;
        }
    }
    /* end of block */
    put_bits(&s->pb, 2, 0x2);
}

/******************************************/
/* 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;

605
static void init_vlcs(MpegEncContext *s)
Fabrice Bellard's avatar
Fabrice Bellard committed
606 607 608 609
{
    static int done = 0;

    if (!done) {
610
        done = 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
611

612
        init_vlc(&dc_lum_vlc, DC_VLC_BITS, 12, 
Fabrice Bellard's avatar
Fabrice Bellard committed
613 614
                 vlc_dc_lum_bits, 1, 1,
                 vlc_dc_lum_code, 2, 2);
615
        init_vlc(&dc_chroma_vlc,  DC_VLC_BITS, 12, 
Fabrice Bellard's avatar
Fabrice Bellard committed
616 617
                 vlc_dc_chroma_bits, 1, 1,
                 vlc_dc_chroma_code, 2, 2);
618
        init_vlc(&mv_vlc, MV_VLC_BITS, 17, 
Fabrice Bellard's avatar
Fabrice Bellard committed
619 620
                 &mbMotionVectorTable[0][1], 2, 1,
                 &mbMotionVectorTable[0][0], 2, 1);
621
        init_vlc(&mbincr_vlc, MBINCR_VLC_BITS, 35, 
Fabrice Bellard's avatar
Fabrice Bellard committed
622 623
                 &mbAddrIncrTable[0][1], 2, 1,
                 &mbAddrIncrTable[0][0], 2, 1);
624
        init_vlc(&mb_pat_vlc, MB_PAT_VLC_BITS, 63, 
Fabrice Bellard's avatar
Fabrice Bellard committed
625 626 627
                 &mbPatTable[0][1], 2, 1,
                 &mbPatTable[0][0], 2, 1);
        
628
        init_vlc(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 32, 
Fabrice Bellard's avatar
Fabrice Bellard committed
629 630
                 &table_mb_ptype[0][1], 2, 1,
                 &table_mb_ptype[0][0], 2, 1);
631
        init_vlc(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 32, 
Fabrice Bellard's avatar
Fabrice Bellard committed
632 633 634 635
                 &table_mb_btype[0][1], 2, 1,
                 &table_mb_btype[0][0], 2, 1);
        init_rl(&rl_mpeg1);
        init_rl(&rl_mpeg2);
636 637 638

        init_2d_vlc_rl(&rl_mpeg1);
        init_2d_vlc_rl(&rl_mpeg2);
Fabrice Bellard's avatar
Fabrice Bellard committed
639 640 641 642 643
    }
}

static inline int get_dmv(MpegEncContext *s)
{
644 645
    if(get_bits1(&s->gb)) 
        return 1 - (get_bits1(&s->gb) << 1);
Fabrice Bellard's avatar
Fabrice Bellard committed
646 647 648 649
    else
        return 0;
}

Fabrice Bellard's avatar
Fabrice Bellard committed
650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665
static inline int get_qscale(MpegEncContext *s)
{
    int qscale;
    if (s->mpeg2) {
        if (s->q_scale_type) {
            qscale = non_linear_qscale[get_bits(&s->gb, 5)];
        } else {
            qscale = get_bits(&s->gb, 5) << 1;
        }
    } else {
        /* for mpeg1, we use the generic unquant code */
        qscale = get_bits(&s->gb, 5);
    }
    return qscale;
}

Fabrice Bellard's avatar
Fabrice Bellard committed
666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689
/* 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])
{
    int i, j, k, cbp, val, code, mb_type, motion_type;
    
    dprintf("decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);

    if (--s->mb_incr != 0) {
        /* 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;
690
            s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
691 692 693 694 695 696 697
        } 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];
        }
698
        s->mb_skiped = 1;
Fabrice Bellard's avatar
Fabrice Bellard committed
699 700 701 702 703 704
        return 0;
    }

    switch(s->pict_type) {
    default:
    case I_TYPE:
705 706
        if (get_bits1(&s->gb) == 0) {
            if (get_bits1(&s->gb) == 0)
Fabrice Bellard's avatar
Fabrice Bellard committed
707 708 709 710 711 712 713
                return -1;
            mb_type = MB_QUANT | MB_INTRA;
        } else {
            mb_type = MB_INTRA;
        }
        break;
    case P_TYPE:
714
        mb_type = get_vlc2(&s->gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
715 716
        if (mb_type < 0){
            fprintf(stderr, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
Fabrice Bellard's avatar
Fabrice Bellard committed
717
            return -1;
718
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
719 720
        break;
    case B_TYPE:
721
        mb_type = get_vlc2(&s->gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
722 723
        if (mb_type < 0){
            fprintf(stderr, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
Fabrice Bellard's avatar
Fabrice Bellard committed
724
            return -1;
725
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
726 727 728 729 730 731 732 733 734 735 736 737 738 739 740
        break;
    }
    dprintf("mb_type=%x\n", mb_type);
    motion_type = 0; /* avoid warning */
    if (mb_type & (MB_FOR|MB_BACK)) {
        /* get additionnal motion vector type */
        if (s->picture_structure == PICT_FRAME && 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 && 
        !s->frame_pred_frame_dct &&
        (mb_type & (MB_PAT | MB_INTRA))) {
741
        s->interlaced_dct = get_bits1(&s->gb);
Fabrice Bellard's avatar
Fabrice Bellard committed
742 743 744 745 746 747 748 749 750
#ifdef DEBUG
        if (s->interlaced_dct)
            printf("interlaced_dct\n");
#endif
    } else {
        s->interlaced_dct = 0; /* frame based */
    }

    if (mb_type & MB_QUANT) {
Fabrice Bellard's avatar
Fabrice Bellard committed
751
        s->qscale = get_qscale(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
752 753 754 755 756
    }
    if (mb_type & MB_INTRA) {
        if (s->concealment_motion_vectors) {
            /* just parse them */
            if (s->picture_structure != PICT_FRAME) 
757
                skip_bits1(&s->gb); /* field select */
Fabrice Bellard's avatar
Fabrice Bellard committed
758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773
            mpeg_decode_motion(s, s->mpeg_f_code[0][0], 0);
            mpeg_decode_motion(s, s->mpeg_f_code[0][1], 0);
        }
        s->mb_intra = 1;
        cbp = 0x3f;
        memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
    } else {
        s->mb_intra = 0;
        cbp = 0;
    }
    /* special case of implicit zero motion vector */
    if (s->pict_type == P_TYPE && !(mb_type & MB_FOR)) {
        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;
774 775
        s->last_mv[0][1][0] = 0;
        s->last_mv[0][1][1] = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
776 777 778 779 780 781 782 783
        s->mv[0][0][0] = 0;
        s->mv[0][0][1] = 0;
    } else if (mb_type & (MB_FOR | MB_BACK)) {
        /* motion vectors */
        s->mv_dir = 0;
        for(i=0;i<2;i++) {
            if (mb_type & (MB_FOR >> i)) {
                s->mv_dir |= (MV_DIR_FORWARD >> i);
784
                dprintf("motion_type=%d\n", motion_type);
Fabrice Bellard's avatar
Fabrice Bellard committed
785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804
                switch(motion_type) {
                case MT_FRAME: /* or MT_16X8 */
                    if (s->picture_structure == PICT_FRAME) {
                        /* MT_FRAME */
                        s->mv_type = MV_TYPE_16X16;
                        for(k=0;k<2;k++) {
                            val = mpeg_decode_motion(s, s->mpeg_f_code[i][k], 
                                                     s->last_mv[i][0][k]);
                            s->last_mv[i][0][k] = val;
                            s->last_mv[i][1][k] = val;
                            /* full_pel: only for mpeg1 */
                            if (s->full_pel[i])
                                val = val << 1;
                            s->mv[i][0][k] = val;
                            dprintf("mv%d: %d\n", k, val);
                        }
                    } else {
                        /* MT_16X8 */
                        s->mv_type = MV_TYPE_16X8;
                        for(j=0;j<2;j++) {
805
                            s->field_select[i][j] = get_bits1(&s->gb);
Fabrice Bellard's avatar
Fabrice Bellard committed
806 807 808 809 810 811 812 813 814 815 816 817 818
                            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;
                            }
                        }
                    }
                    break;
                case MT_FIELD:
                    if (s->picture_structure == PICT_FRAME) {
                        s->mv_type = MV_TYPE_FIELD;
                        for(j=0;j<2;j++) {
819
                            s->field_select[i][j] = get_bits1(&s->gb);
Fabrice Bellard's avatar
Fabrice Bellard committed
820 821 822 823 824 825 826 827 828 829 830 831 832
                            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 {
                        s->mv_type = MV_TYPE_16X16;
833
                        s->field_select[i][0] = get_bits1(&s->gb);
Fabrice Bellard's avatar
Fabrice Bellard committed
834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888
                        for(k=0;k<2;k++) {
                            val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
                                                     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;
                        }
                    }
                    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;
                        /* XXX: totally broken */
                        if (s->picture_structure == PICT_FRAME) {
                            s->last_mv[i][0][1] = my << 1;
                            s->last_mv[i][1][1] = my << 1;

                            m = s->top_field_first ? 1 : 3;
                            /* top -> top pred */
                            s->mv[i][0][0] = mx; 
                            s->mv[i][0][1] = my << 1;
                            s->mv[i][1][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
                            s->mv[i][1][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
                            m = 4 - m;
                            s->mv[i][2][0] = mx;
                            s->mv[i][2][1] = my << 1;
                            s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
                            s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
                        } else {
                            s->last_mv[i][0][1] = my;
                            s->last_mv[i][1][1] = my;
                            s->mv[i][0][0] = mx;
                            s->mv[i][0][1] = my;
                            s->mv[i][1][0] = ((mx + (mx > 0)) >> 1) + dmx;
                            s->mv[i][1][1] = ((my + (my > 0)) >> 1) + dmy - 1 
                                /* + 2 * cur_field */;
                        }
                    }
                    break;
                }
            }
        }
    }

    if ((mb_type & MB_INTRA) && s->concealment_motion_vectors) {
889
        skip_bits1(&s->gb); /* marker */
Fabrice Bellard's avatar
Fabrice Bellard committed
890 891 892
    }
    
    if (mb_type & MB_PAT) {
893
        cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
894 895
        if (cbp < 0){
            fprintf(stderr, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
Fabrice Bellard's avatar
Fabrice Bellard committed
896
            return -1;
897
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
898 899 900 901 902 903 904
        cbp++;
    }
    dprintf("cbp=%x\n", cbp);

    if (s->mpeg2) {
        if (s->mb_intra) {
            for(i=0;i<6;i++) {
905 906
                if (mpeg2_decode_block_intra(s, block[i], i) < 0)
                    return -1;
Fabrice Bellard's avatar
Fabrice Bellard committed
907 908 909
            }
        } else {
            for(i=0;i<6;i++) {
910
                if (cbp & 32) {
Fabrice Bellard's avatar
Fabrice Bellard committed
911 912
                    if (mpeg2_decode_block_non_intra(s, block[i], i) < 0)
                        return -1;
913 914
                } else {
                    s->block_last_index[i] = -1;
Fabrice Bellard's avatar
Fabrice Bellard committed
915
                }
916
                cbp+=cbp;
Fabrice Bellard's avatar
Fabrice Bellard committed
917 918 919
            }
        }
    } else {
920 921 922
        if (s->mb_intra) {
            for(i=0;i<6;i++) {
                if (mpeg1_decode_block_intra(s, block[i], i) < 0)
Fabrice Bellard's avatar
Fabrice Bellard committed
923
                    return -1;
924 925 926 927 928 929 930 931 932 933
            }
        }else{
            for(i=0;i<6;i++) {
                if (cbp & 32) {
                    if (mpeg1_decode_block_inter(s, block[i], i) < 0)
                        return -1;
                } else {
                    s->block_last_index[i] = -1;
                }
                cbp+=cbp;
Fabrice Bellard's avatar
Fabrice Bellard committed
934 935 936 937 938 939 940 941 942 943 944
            }
        }
    }
    return 0;
}

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

945
    code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
Fabrice Bellard's avatar
Fabrice Bellard committed
946 947 948 949 950 951
    if (code < 0) {
        return 0xffff;
    }
    if (code == 0) {
        return pred;
    }
952
    sign = get_bits1(&s->gb);
Fabrice Bellard's avatar
Fabrice Bellard committed
953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977
    shift = fcode - 1;
    val = (code - 1) << shift;
    if (shift > 0)
        val |= get_bits(&s->gb, shift);
    val++;
    if (sign)
        val = -val;
    val += pred;
    
    /* modulo decoding */
    l = (1 << shift) * 16;
    m = 2 * l;
    if (val < -l) {
        val += m;
    } else if (val >= l) {
        val -= m;
    }
    return val;
}

static inline int decode_dc(MpegEncContext *s, int component)
{
    int code, diff;

    if (component == 0) {
978
        code = get_vlc2(&s->gb, dc_lum_vlc.table, DC_VLC_BITS, 2);
Fabrice Bellard's avatar
Fabrice Bellard committed
979
    } else {
980
        code = get_vlc2(&s->gb, dc_chroma_vlc.table, DC_VLC_BITS, 2);
Fabrice Bellard's avatar
Fabrice Bellard committed
981
    }
982 983
    if (code < 0){
        fprintf(stderr, "invalid dc code at %d %d\n", s->mb_x, s->mb_y);
Fabrice Bellard's avatar
Fabrice Bellard committed
984
        return 0xffff;
985
    }
Fabrice Bellard's avatar
Fabrice Bellard committed
986 987 988 989 990 991 992 993 994 995
    if (code == 0) {
        diff = 0;
    } else {
        diff = get_bits(&s->gb, code);
        if ((diff & (1 << (code - 1))) == 0) 
            diff = (-1 << code) | (diff + 1);
    }
    return diff;
}

996
static inline int mpeg1_decode_block_intra(MpegEncContext *s, 
Fabrice Bellard's avatar
Fabrice Bellard committed
997 998 999 1000
                               DCTELEM *block, 
                               int n)
{
    int level, dc, diff, i, j, run;
1001
    int component;
Fabrice Bellard's avatar
Fabrice Bellard committed
1002
    RLTable *rl = &rl_mpeg1;
1003
    UINT8 * const scantable= s->intra_scantable.permutated;
1004 1005
    const UINT16 *quant_matrix= s->intra_matrix;
    const int qscale= s->qscale;
Fabrice Bellard's avatar
Fabrice Bellard committed
1006

1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079
    /* DC coef */
    component = (n <= 3 ? 0 : n - 4 + 1);
    diff = decode_dc(s, component);
    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];
                level= (level*qscale*quant_matrix[j])>>3;
                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;
                    level= (level*qscale*quant_matrix[j])>>3;
                    level= (level-1)|1;
                    level= -level;
                }else{
                    level= (level*qscale*quant_matrix[j])>>3;
                    level= (level-1)|1;
                }
            }
            if (i > 63){
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
                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;
    UINT8 * const scantable= s->intra_scantable.permutated;
    const UINT16 *quant_matrix= s->inter_matrix;
    const int qscale= s->qscale;

    {
1080 1081
        int v;
        OPEN_READER(re, &s->gb);
1082
        i = -1;
Fabrice Bellard's avatar
Fabrice Bellard committed
1083
        /* special case for the first coef. no need to add a second vlc table */
1084 1085
        UPDATE_CACHE(re, &s->gb);
        v= SHOW_UBITS(re, &s->gb, 2);
Fabrice Bellard's avatar
Fabrice Bellard committed
1086
        if (v & 2) {
1087
            LAST_SKIP_BITS(re, &s->gb, 2);
1088 1089 1090 1091
            level= (3*qscale*quant_matrix[0])>>4;
            level= (level-1)|1;
            if(v&1)
                level= -level;
1092
            block[0] = level;
1093
            i++;
Fabrice Bellard's avatar
Fabrice Bellard committed
1094
        }
1095

1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130
        /* 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])>>4;
                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;
                    level= ((level*2+1)*qscale*quant_matrix[j])>>4;
                    level= (level-1)|1;
                    level= -level;
                }else{
                    level= ((level*2+1)*qscale*quant_matrix[j])>>4;
                    level= (level-1)|1;
                }
Fabrice Bellard's avatar
Fabrice Bellard committed
1131
            }
1132 1133 1134 1135 1136 1137
            if (i > 63){
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
                return -1;
            }

            block[j] = level;
Fabrice Bellard's avatar
Fabrice Bellard committed
1138
        }
1139
        CLOSE_READER(re, &s->gb);
Fabrice Bellard's avatar
Fabrice Bellard committed
1140
    }
1141
    s->block_last_index[n] = i;
Fabrice Bellard's avatar
Fabrice Bellard committed
1142 1143 1144 1145 1146
    return 0;
}

/* Also does unquantization here, since I will never support mpeg2
   encoding */
1147 1148 1149
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 
                               DCTELEM *block, 
                               int n)
Fabrice Bellard's avatar
Fabrice Bellard committed
1150 1151 1152
{
    int level, i, j, run;
    RLTable *rl = &rl_mpeg1;
1153
    UINT8 * const scantable= s->intra_scantable.permutated;
1154 1155
    const UINT16 *quant_matrix;
    const int qscale= s->qscale;
Fabrice Bellard's avatar
Fabrice Bellard committed
1156 1157 1158 1159 1160
    int mismatch;

    mismatch = 1;

    {
1161 1162
        int v;
        OPEN_READER(re, &s->gb);
1163
        i = -1;
1164
        if (n < 4)
1165
            quant_matrix = s->inter_matrix;
Fabrice Bellard's avatar
Fabrice Bellard committed
1166
        else
1167
            quant_matrix = s->chroma_inter_matrix;
1168

Fabrice Bellard's avatar
Fabrice Bellard committed
1169
        /* special case for the first coef. no need to add a second vlc table */
1170 1171
        UPDATE_CACHE(re, &s->gb);
        v= SHOW_UBITS(re, &s->gb, 2);
Fabrice Bellard's avatar
Fabrice Bellard committed
1172
        if (v & 2) {
1173 1174 1175 1176 1177 1178 1179
            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
1180 1181
        }

1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216
        /* 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){
                fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
                return -1;
            }
            
            mismatch ^= level;
            block[j] = level;
1217
        }