umc_mpeg2_dec_blk.cpp

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

      i++;
      UNPACK_VLC2(tbl, run, val, len);

      i += run;
      i &= 63;
      j = scanMatrix[i];
      val = (val*(quant*pQuantMatrix[j])) >> 4;
      sign = SHBITS(code << len, 1);
      val = (val ^ sign) - sign;

      SKIP_BITS(BS, (len + 1));
      pDstBlock[j] = val;
      mask ^= val;
      SHOW_HI9BITS(BS, code);
    }
    pDstBlock[63] ^= mask & 1;
    *pDstSize = i;
    SKIP_BITS(BS, 2);
    COPY_BITSTREAM(*BitStream, BS)
  }
  return ippiDCT8x8Inv_AANTransposed_16s8u_C1R(pDstBlock, pDst, dstStep, *pDstSize);
}

/********************************************************************/

MP2_FUNC(IppStatus, ippiDecodeInter8x8IDCTAdd_MPEG1_1u8u, (
    Ipp8u**                            BitStream_curr_ptr,
    Ipp32s*                            BitStream_bit_offset,
    IppiDecodeInterSpec_MPEG2*         pQuantSpec,
    int                                quant,
    Ipp8u*                             pSrcDst,
    int                                srcDstStep))
{
  Ipp16s idct[64];
  DEF_BLOCK;
  Ipp32s *scanMatrix = pQuantSpec->scanMatrix;
  Ipp16s *pQuantMatrix = pQuantSpec->quantMatrix;
  Ipp32s pDstSize[1];
  Ipp8u *BS_curr_ptr;
  Ipp32s BS_bit_offset;
  int i, j, k;
  int val, run, len, sign, mask;
  Ipp32u tbl;
  Ipp32u code;

  COPY_BITSTREAM(BS, *BitStream)

  if (!pQuantMatrix) pQuantMatrix = Qmatrix;
  mask = 1;

  SHOW_HI9BITS(BS, code);

  if (code & 0x80000000) { /* first 2-bit code */
    val = (3*quant*pQuantMatrix[0]) >> 4;
    val = (val - 1) | 1;
    sign = SHBITS(code + code, 1);
    val = (val ^ sign) - sign;

    for (k = 0; k < 64; k++) {
      pDstBlock[k] = 0;
    }
    pDstBlock[0] = val;

    SKIP_BITS(BS, 2);
    SHOW_HI9BITS(BS, code);
    i = 0;
  } else {
    for (k = 0; k < 64; k++) {
      pDstBlock[k] = 0;
    }
    i = -1;
  }

  for (;;) {
    if ((code & 0xc0000000) == 0x80000000) {
      break;
    } else if (code >= 0x08000000) {
      tbl = MPEG2_VLC_TAB1[UHBITS(code - 0x08000000, 8)];
common:
      i++;
      UNPACK_VLC1(tbl, run, val, len)

      i += run;
      i &= 63;
      j = scanMatrix[i];
      val = (val * (quant*pQuantMatrix[j])) >> 4;
      val = (val - 1) | 1;
      sign = SHBITS(code << len, 1);
      val += sign;
      if (val > 2047) val = 2047;
      val ^= sign;

      SKIP_BITS(BS, (len + 1));
      pDstBlock[j] = val;
      mask ^= val;
      SHOW_HI9BITS(BS, code);
      continue;
    } else if (code >= 0x04000000) {
      EXPAND_17BITS(BS, code);
      i += 1 + UHBITS (code << 6, 6);
      i &= 63;
      j = scanMatrix[i];

      SKIP_BITS(BS, 12);
      GET_TO9BITS(BS, 8, val);
      val = (Ipp8s)val;
      if (!(val & 0x7f))
      {
        Ipp32s val2;
        GET_TO9BITS(BS, 8, val2);
        val = 2*val + val2;
      }
      sign = SHBITS(val, 1);
      val = 2*(val + sign) + 1;
      val = (val * (quant*pQuantMatrix[j])) / 16;
      val = (val + ~sign) | 1;

      if (val > 2047) val = 2047;
      if (val < -2048) val = -2048;
      pDstBlock[j] = val;

      SHOW_HI9BITS(BS, code);
      continue;
    } else {
      EXPAND_17BITS(BS, code);
      if (code >= 0x00800000) {
        tbl = MPEG2_VLC_TAB1[TAB1_OFFSET_10BIT + UHBITS(code, 13)];
        goto common;
      } else if (code >= 0x00200000) {
        tbl = MPEG2_VLC_TAB1[TAB1_OFFSET_15BIT + UHBITS(code, 15)];
        goto common;
      } else {
        tbl = MPEG2_VLC_TAB1[TAB1_OFFSET_16BIT + UHBITS(code, 16)];
        if (code < 16)
          return ippStsVLCErr;
        code <<= 16;
        SKIP_BITS(BS, 16);
        goto common;
      }
    }
  }

//  pDstBlock[63] ^= mask & 1;
  SKIP_BITS(BS, 2);
  *pDstSize = i;
  COPY_BITSTREAM(*BitStream, BS)

  ippiDCT8x8Inv_16s_C1R(pDstBlock, idct, 16);

  return ippiAdd8x8_16s8u_C1IRS(idct, 16, pSrcDst, srcDstStep);
}

MP2_FUNC(IppStatus, ippiDecodeIntra8x8IDCT_MPEG1_1u8u, (
    Ipp8u**                            BitStream_curr_ptr,
    int*                               BitStream_bit_offset,
    IppiDecodeIntraSpec_MPEG2*         pQuantSpec,
    int                                quant,
    int                                blockType,
    Ipp16s*                            dct_dc_past,
    Ipp8u*                             pDst,
    int                                dstStep))
{
  Ipp32s *scanMatrix = pQuantSpec->scanMatrix;
  Ipp16s *pQuantMatrix = pQuantSpec->quantMatrix;
  DEF_BLOCK;
  Ipp32s chromaFlag = blockType & 1;
  Ipp32s flag = blockType & 4;
  Ipp32s pDstSize[1];
  Ipp8u *BS_curr_ptr;
  Ipp32s BS_bit_offset;
  int i, j, k;
  int val, run, len, sign, mask;
  Ipp32u tbl;
  Ipp32u code;
  for (k = 0; k < 64; k++) {
    pDstBlock[k] = 0;
  }

  COPY_BITSTREAM(BS, *BitStream)

  /* DC */
  DECODE_DC(val)
  val <<= 3;
  val += *dct_dc_past;
  *dct_dc_past = val;
  pDstBlock[0] = val;

  if (flag) {
    *pDstSize = 0;
    COPY_BITSTREAM(*BitStream, BS)
    ippiDCT8x8Inv_16s8u_C1R(pDstBlock, pDst, dstStep);
    return ippStsOk;
  }

  i = 0;
  SHOW_HI9BITS(BS, code);

  for (;;) {
    if ((code & 0xc0000000) == 0x80000000) {
      break;
    } else if (code >= 0x08000000) {
      tbl = MPEG2_VLC_TAB1[UHBITS(code - 0x08000000, 8)];
    } else if (code >= 0x04000000) {
      EXPAND_17BITS(BS, code);
      i += 1 + UHBITS(code << 6, 6);
      i &= 63;
      j = scanMatrix[i];

      SKIP_BITS(BS, 12);
      GET_TO9BITS(BS, 8, val);
      val = (Ipp8s)val;
      if (!(val & (Ipp8s)0x7f))
      {
        Ipp16s base = (val & 0x80) ? -256 : 0;
        GET_TO9BITS(BS, 8, val);
        val = (Ipp16s)(val+base);
      }
      sign = SHBITS(val, 1);
      val = (val * (quant*pQuantMatrix[j])) / 8;
      val = (val + ~sign) | 1;

      if (val > 2047) val = 2047;
      if (val < -2048) val = -2048;
      pDstBlock[j] = val;
      mask ^= val;

      SHOW_HI9BITS(BS, code);
      continue;
    } else {

      EXPAND_17BITS(BS, code);
      if (code >= 0x00800000) {
        tbl = MPEG2_VLC_TAB1[TAB1_OFFSET_10BIT + UHBITS(code, 13)];
      } else if (code >= 0x00200000) {
        tbl = MPEG2_VLC_TAB1[TAB1_OFFSET_15BIT + UHBITS(code, 15)];
      } else {
        tbl = MPEG2_VLC_TAB1[TAB1_OFFSET_16BIT + UHBITS(code, 16)];
        if (code < 16)
          return ippStsVLCErr;
        code <<= 16;
        SKIP_BITS(BS, 16);
      }
    }
    i++;
    UNPACK_VLC2(tbl, run, val, len)
    i += run;
    i &= 63;
    j = scanMatrix[i];
    val = (val*(quant*pQuantMatrix[j])) >> 3;
    sign = SHBITS(code << len, 1);
    val = (val-1) | 1;
    val += sign;
    if (val > 2047) val = 2047;
    val ^= sign;

    SKIP_BITS(BS, (len + 1));
    pDstBlock[j] = val;
//    mask ^= val;
    SHOW_HI9BITS(BS, code);
  }
//  pDstBlock[63] ^= mask & 1;
  *pDstSize = i;
  SKIP_BITS(BS, 2);
  COPY_BITSTREAM(*BitStream, BS)
  return ippiDCT8x8Inv_16s8u_C1R(pDstBlock, pDst, dstStep);
}

/*******************************************************/

/* ///////////////////////////////////////////////////////////////////////////
//  Name:
//    ippiDecodeIntraInit_MPEG2
//    ippiDecodeInterInit_MPEG2
//
//  Purpose:
//    Initialized IppiDecodeIntraSpec_16s(IppiDecodeInterSpec_MPEG2) structure.
//    If pQuantMatrix is NULL this means default quantization matrix.
//
//  Parameters:
//    pQuantMatrix   Pointer to the quantization matrix size of 64.
//    scan           Type of the scan, takes one of the following values:
//                       IPPVC_SCAN_ZIGZAG, indicating the classical zigzag scan,
//                       IPPVC_SCAN_VERTICAL - alternate-vertical scan
//    intraVLCFormat 0 or 1, defines one of two VLC tables for decoding intra blocks
//    intraShiftDC   Integer value for shifting intra DC coefficient after VLC decoding
//    pSpec          Pointer to the structure IppiDecodeIntraSpec_16s or
//                   IppiDecodeInterSpec_MPEG2 which will initialized.
//
//  Returns:
//    ippStsNoErr        No error.
//    ippStsNullPtrErr   Indicates an error when pointer pSpec is NULL.
*/

MP2_FUNC(IppStatus, ippiDecodeIntraInit_MPEG2, (
    const Ipp8u*                 pQuantMatrix,
    int                          flag,
    int                          intraVLCFormat,
    int                          intraShiftDC,
    IppiDecodeIntraSpec_MPEG2*   pSpec))
{
  int *scan = scan_tbl[flag & 3];
  pSpec->intraVLCFormat = intraVLCFormat;
  pSpec->intraShiftDC = intraShiftDC;
  if (!(flag & IPPVC_LEAVE_SCAN_UNCHANGED)) {
    pSpec->scanMatrix = scan;
  }
  if (!(flag & IPPVC_LEAVE_QUANT_UNCHANGED)) {
    int i;
    if (!pQuantMatrix) pQuantMatrix = default_intra_quantizer_matrix;
    pSpec->quantMatrix = pSpec->_quantMatrix;
    for (i = 0; i < 64; i++) {
      pSpec->quantMatrix[scan[i]] = pQuantMatrix[i];
    }
  }
  return ippStsNoErr;
}

MP2_FUNC(IppStatus, ippiDecodeInterInit_MPEG2, (
    const Ipp8u*                 pQuantMatrix,
    int                          flag,
    IppiDecodeInterSpec_MPEG2*   pSpec))
{
  int *scan = scan_tbl[flag & 3];
  if (!(flag & IPPVC_LEAVE_SCAN_UNCHANGED)) {
    pSpec->scanMatrix = scan;
  }
  if (!(flag & IPPVC_LEAVE_QUANT_UNCHANGED)) {
    if (pQuantMatrix) {
      int i, mask = 0;
      pSpec->quantMatrix = pSpec->_quantMatrix;
      for (i = 0; i < 64; i++) {
        pSpec->quantMatrix[scan[i]] = pQuantMatrix[i];
        mask |= pQuantMatrix[i];
      }
      if (mask == 16) { // default matrix
        pSpec->quantMatrix = NULL;
      }
    } else {
      pSpec->quantMatrix = NULL;
    }
  }
  return ippStsNoErr;
}