/* * parseblock.c -- * *      Procedures to read in the values of a block and store them *      in a place where the player can use them. * *//* * Copyright (c) 1995 The Regents of the University of California. * All rights reserved. *  * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without written agreement is * hereby granted, provided that the above copyright notice and the following * two paragraphs appear in all copies of this software. *  * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *  * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. *//* * Portions of this software Copyright (c) 1995 Brown University. * All rights reserved. *  * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without written agreement * is hereby granted, provided that the above copyright notice and the * following two paragraphs appear in all copies of this software. *  * IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF BROWN * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *  * BROWN UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" * BASIS, AND BROWN UNIVERSITY HAS NO OBLIGATION TO PROVIDE MAINTENANCE, * SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */#define NO_SANITY_CHECKS#include <assert.h>#include "video.h"#include "proto.h"#include "decoders.h"/*   Changes to make the code reentrant:      deglobalized: curBits, bitOffset, bitLength, bitBuffer, curVidStream,      zigzag_direct now a const int variable initialized once   -lsh@cs.brown.edu (Loring Holden) *//* External declarations. */extern const int zigzag_direct[];#ifdef DCPRECextern int dcprec;#endif/* Macro for returning 1 if num is positive, -1 if negative, 0 if 0. */#define Sign(num) ((num > 0) ? 1 : ((num == 0) ? 0 : -1))/* *-------------------------------------------------------------- * * ParseReconBlock -- * *    Parse values for block structure from bitstream. *      n is an indication of the position of the block within *      the macroblock (i.e. 0-5) and indicates the type of  *      block (i.e. luminance or chrominance). Reconstructs *      coefficients from values parsed and puts in  *      block.dct_recon array in vid stream structure. *      sparseFlag is set when the block contains only one *      coeffictient and is used by the IDCT. * * Results: *     * * Side effects: *      Bit stream irreversibly parsed. * *-------------------------------------------------------------- */#define DCT_recon blockPtr->dct_recon#define DCT_dc_y_past blockPtr->dct_dc_y_past#define DCT_dc_cr_past blockPtr->dct_dc_cr_past#define DCT_dc_cb_past blockPtr->dct_dc_cb_past#define DECODE_DCT_COEFF_FIRST DecodeDCTCoeffFirst#define DECODE_DCT_COEFF_NEXT DecodeDCTCoeffNextvoidParseReconBlock(n, vid_stream)     int n;     VidStream *vid_stream;{#ifdef RISC  unsigned int temp_curBits;  int temp_bitOffset;  int temp_bufLength;  unsigned int *temp_bitBuffer;#endif  Block *blockPtr = &vid_stream->block;  int coeffCount=0;    if (vid_stream->buf_length < 100)    correct_underflow(vid_stream);#ifdef RISC  temp_curBits = vid_stream->curBits;  temp_bitOffset = vid_stream->buf_offset;  temp_bufLength = vid_stream->buf_length;  temp_bitBuffer = bitBuffer;#endif  {    /*     * Copy the VidStream fields curBits, bitOffset, and bitBuffer     * into local variables with the same names, so the macros use the     * local variables instead.  This allows register allocation and     * can provide 1-2 fps speedup.  On machines with not so many registers,     * don't do this.     */#ifdef RISC    register unsigned int curBits = temp_curBits;    register int bitOffset = temp_bitOffset;    register int bufLength = temp_bufLength;    register unsigned int *bitBuffer = temp_bitBuffer;#endif    int diff;    int size, level=0, i, run, pos, coeff;    short int *reconptr;    unsigned char *iqmatrixptr, *niqmatrixptr;    int qscale;    reconptr = DCT_recon[0];    /*      * Hand coded version of memset that's a little faster...     * Old call:     *    memset((char *) DCT_recon, 0, 64*sizeof(short int));     */    {      INT32 *p;      p = (INT32 *) reconptr;      p[0] = p[1] = p[2] = p[3] = p[4] = p[5] = p[6] = p[7] = p[8] = p[9] =       p[10] = p[11] = p[12] = p[13] = p[14] = p[15] = p[16] = p[17] = p[18] =      p[19] = p[20] = p[21] = p[22] = p[23] = p[24] = p[25] = p[26] = p[27] =      p[28] = p[29] = p[30] = p[31] = 0;    }    if (vid_stream->mblock.mb_intra) {      if (n < 4) {    /*     * Get the luminance bits.  This code has been hand optimized to     * get by the normal bit parsing routines.  We get some speedup     * by grabbing the next 16 bits and parsing things locally.     * Thus, calls are translated as:     *     *    show_bitsX  <-->   next16bits >> (16-X)     *    get_bitsX   <-->   val = next16bits >> (16-flushed-X);     *               flushed += X;     *               next16bits &= bitMask[flushed];     *    flush_bitsX <-->   flushed += X;     *               next16bits &= bitMask[flushed];     *     * I've streamlined the code a lot, so that we don't have to mask     * out the low order bits and a few of the extra adds are removed.     *    bsmith     */    unsigned int next16bits, index, flushed;        show_bits16(next16bits);        index = next16bits >> (16-5);        if (index < 31) {          size = dct_dc_size_luminance[index].value;          flushed = dct_dc_size_luminance[index].num_bits;        } else {          index = next16bits >> (16-9);          index -= 0x1f0;          size = dct_dc_size_luminance1[index].value;          flushed = dct_dc_size_luminance1[index].num_bits;        }        next16bits &= bitMask[16+flushed];        if (size != 0) {          flushed += size;          diff = next16bits >> (16-flushed);          if (!(diff & bitTest[32-size])) {            diff = rBitMask[size] | (diff + 1);          }        } else {          diff = 0;        }        flush_bits(flushed);        if (n == 0) {          coeff = diff << 3;          if (vid_stream->mblock.mb_address -              vid_stream->mblock.past_intra_addr > 1) {            coeff += 1024;          } else {		    coeff += DCT_dc_y_past;          }          DCT_dc_y_past = coeff;        } else {          coeff = DCT_dc_y_past + (diff << 3);          DCT_dc_y_past = coeff;        }      } else { /* n = 4 or 5 */        /*     * Get the chrominance bits.  This code has been hand optimized to     * as described above     */    unsigned int next16bits, index, flushed;        show_bits16(next16bits);        index = next16bits >> (16-5);        if (index < 31) {          size = dct_dc_size_chrominance[index].value;          flushed = dct_dc_size_chrominance[index].num_bits;        } else {          index = next16bits >> (16-10);          index -= 0x3e0;          size = dct_dc_size_chrominance1[index].value;          flushed = dct_dc_size_chrominance1[index].num_bits;        }        next16bits &= bitMask[16+flushed];            if (size != 0) {          flushed += size;          diff = next16bits >> (16-flushed);          if (!(diff & bitTest[32-size])) {            diff = rBitMask[size] | (diff + 1);          }        } else {          diff = 0;        }        flush_bits(flushed);          /* We test 5 first; a result of the mixup of Cr and Cb */        if (n == 5) {          coeff = diff << 3;          if (vid_stream->mblock.mb_address -              vid_stream->mblock.past_intra_addr > 1) {            coeff += 1024;          } else {            coeff += DCT_dc_cr_past;          }          DCT_dc_cr_past = coeff;        } else {          coeff = diff << 3;          if (vid_stream->mblock.mb_address -              vid_stream->mblock.past_intra_addr > 1) {            coeff += 1024;          } else {            coeff += DCT_dc_cb_past;          }          DCT_dc_cb_past = coeff;        }      }            *reconptr = coeff;      i = 0;       pos = 0;      coeffCount = (coeff != 0);          if (vid_stream->picture.code_type != 4) {            qscale = vid_stream->slice.quant_scale;        iqmatrixptr = vid_stream->intra_quant_matrix[0];            while(1) {                DECODE_DCT_COEFF_NEXT(run, level);          if (run >= END_OF_BLOCK) break;          i = i + run + 1;          pos = zigzag_direct[i];          /* quantizes and oddifies each coefficient */          if (level < 0) {            coeff = ((level<<1) * qscale *                      ((int) (iqmatrixptr[pos]))) / 16;             coeff += (1 - (coeff & 1));          } else {            coeff = ((level<<1) * qscale *                      ((int) (*(iqmatrixptr+pos)))) >> 4;             coeff -= (1 - (coeff & 1));          }#ifdef QUANT_CHECK          printf ("coeff: %d\n", coeff);#endif          reconptr[pos] = coeff;          coeffCount++;        }#ifdef QUANT_CHECK		printf ("\n");#endif#ifdef ANALYSIS         {          extern unsigned int *mbCoeffPtr;          mbCoeffPtr[pos]++;        }#endif        flush_bits(2);		goto end;      }    } else { /* non-intra-coded macroblock */            niqmatrixptr = vid_stream->non_intra_quant_matrix[0];      qscale = vid_stream->slice.quant_scale;            DECODE_DCT_COEFF_FIRST(run, level);      i = run;      pos = zigzag_direct[i];        /* quantizes and oddifies each coefficient */      if (level < 0) {        coeff = (((level<<1) - 1) * qscale *                  ((int) (niqmatrixptr[pos]))) / 16; 	if ((coeff & 1) == 0) {coeff = coeff + 1;}      } else {        coeff = (((level<<1) + 1) * qscale *                  ((int) (*(niqmatrixptr+pos)))) >> 4; 	coeff = (coeff-1) | 1; /* equivalent to: if ((coeff&1)==0) coeff = coeff - 1; */      }      reconptr[pos] = coeff;      if (coeff) {          coeffCount = 1;      }      if (vid_stream->picture.code_type != 4) {            while(1) {                DECODE_DCT_COEFF_NEXT(run, level);          if (run >= END_OF_BLOCK) {	       	break;          }          i = i+run+1;          pos = zigzag_direct[i];          if (level < 0) {            coeff = (((level<<1) - 1) * qscale *                      ((int) (niqmatrixptr[pos]))) / 16;             if ((coeff & 1) == 0) {coeff = coeff + 1;}          } else {            coeff = (((level<<1) + 1) * qscale *                      ((int) (*(niqmatrixptr+pos)))) >> 4;             coeff = (coeff-1) | 1; /* equivalent to: if ((coeff&1)==0) coeff = coeff - 1; */          }          reconptr[pos] = coeff;          coeffCount++;        } /* end while */#ifdef ANALYSIS        {          extern unsigned int *mbCoeffPtr;          mbCoeffPtr[pos]++;        }#endif        flush_bits(2);        goto end;      } /* end if (vid_stream->picture.code_type != 4) */    }      end:    if (coeffCount == 1) {      j_rev_dct_sparse (reconptr, pos);    }    else {#ifdef FLOATDCT      if (qualityFlag) {     	float_idct(reconptr);      } else {#endif        j_rev_dct(reconptr);#ifdef FLOATDCT      }#endif    }#ifdef RISC    temp_curBits = vid_stream->curBits;    temp_bitOffset = vid_stream->bit_offset;    temp_bufLength = vid_stream->buf_length;    temp_bitBuffer = bitBuffer;#endif  }#ifdef RISC  vid_stream->curBits = temp_curBits;  vid_stream->bitOffset = temp_bitOffset;  vid_stream->buf_length = temp_bufLength;  bitBuffer = temp_bitBuffer;#endif}    #undef DCT_recon #undef DCT_dc_y_past #undef DCT_dc_cr_past #undef DCT_dc_cb_past /* *-------------------------------------------------------------- * * ParseAwayBlock -- * *    Parses off block values, throwing them away. *      Used with grayscale dithering. * * Results: *    None. * * Side effects: *      None. * *-------------------------------------------------------------- */voidParseAwayBlock(n, vid_stream)     int n;     VidStream *vid_stream;{  unsigned int diff;  unsigned int size, run;  int level;  if (vid_stream->buf_length < 100)    correct_underflow(vid_stream);  if (vid_stream->mblock.mb_intra) {    /* If the block is a luminance block... */    if (n < 4) {      /* Parse and decode size of first coefficient. */      DecodeDCTDCSizeLum(size);      /* Parse first coefficient. */      if (size != 0) {        get_bitsn(size, diff);      }    }    /* Otherwise, block is chrominance block... */    else {      /* Parse and decode size of first coefficient. */      DecodeDCTDCSizeChrom(size);      /* Parse first coefficient. */      if (size != 0) {        get_bitsn(size, diff);      }    }  }  /* Otherwise, block is not intracoded... */  else {    /* Decode and set first coefficient. */    DECODE_DCT_COEFF_FIRST(run, level);  }  /* If picture is not D type (i.e. I, P, or B)... */  if (vid_stream->picture.code_type != 4) {    /* While end of macroblock has not been reached... */    while (1) {      /* Get the dct_coeff_next */      DECODE_DCT_COEFF_NEXT(run, level);      if (run >= END_OF_BLOCK) break;    }    /* End_of_block */    flush_bits(2);  }}