decoder.cpp

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

        break;
      } // JPEG_PROGRESSIVE

      case JPEG_LOSSLESS:
      {
        ss_buf_size = m_numxMCU * m_mcuWidth * sizeof(Ipp16s) * 2;
        cc_buf_size = m_numxMCU * m_mcuWidth * sizeof(Ipp16s);

        if(0 == m_block_buffer)
        {
          sz = m_numxMCU * sizeof(Ipp16s);

          m_block_buffer = (Ipp16s*)ippMalloc(sz);
          if(0 == m_block_buffer)
          {
            return JPEG_OUT_OF_MEMORY;
          }

          ippsZero_8u((Ipp8u*)m_block_buffer,sz);
        }

        break;
      } // JPEG_LOSSLESS
    } // m_jpeg_mode

    if(0 == m_ccomp[i].m_ss_buffer)
    {
      if(ss_buf_size)
      {
        m_ccomp[i].m_ss_buffer = (Ipp8u*)ippMalloc(ss_buf_size);
        if(0 == m_ccomp[i].m_ss_buffer)
        {
          return JPEG_OUT_OF_MEMORY;
        }
      }
      m_ccomp[i].m_curr_row = (Ipp16s*)m_ccomp[i].m_ss_buffer;
      m_ccomp[i].m_prev_row = (Ipp16s*)m_ccomp[i].m_ss_buffer + m_dst.width;
    }

    if(0 == m_ccomp[i].m_cc_buffer)
    {
      m_ccomp[i].m_cc_buffer = (Ipp8u*)ippMalloc(cc_buf_size);
      if(0 == m_ccomp[i].m_cc_buffer)
      {
        return JPEG_OUT_OF_MEMORY;
      }
    }
  } // m_jpeg_ncomp

  m_state.Create();

  return JPEG_OK;
} // CJPEGDecoder::Init()


JERRCODE CJPEGDecoder::ColorConvert(int nMCURow,int idThread)
{
  int       threadoffset;
  Ipp8u*    dst;
  IppiSize  roi;
  IppStatus status;
  threadoffset = m_numxMCU * m_mcuWidth * m_mcuHeight * idThread;

  if(nMCURow == m_numyMCU - 1)
  {
    m_ccHeight = m_mcuHeight - m_yPadding;
  }

  roi.width  = m_dst.width;
  roi.height = m_ccHeight;

  dst = m_dst.p.Data8u + nMCURow * m_mcuHeight * m_dst.lineStep;

  if(m_jpeg_color == JC_UNKNOWN && m_dst.color == JC_UNKNOWN)
  {
    switch(m_jpeg_ncomp)
    {
    case 1:
      {
        const Ipp8u* src = m_ccomp[0].m_cc_buffer + threadoffset;
        status = ippiCopy_8u_C1R(src,m_ccWidth,dst,m_dst.lineStep,roi);

        if(ippStsNoErr != status)
        {
          LOG1("IPP Error: ippiCopy_8u_C1R() failed - ",status);
          return JPEG_INTERNAL_ERROR;
        }
      }
      break;

    case 3:
      {
        const Ipp8u* src[3];
        src[0] = m_ccomp[0].m_cc_buffer + threadoffset;
        src[1] = m_ccomp[1].m_cc_buffer + threadoffset;
        src[2] = m_ccomp[2].m_cc_buffer + threadoffset;

        status = ippiCopy_8u_P3C3R(src,m_ccWidth,dst,m_dst.lineStep,roi);

        if(ippStsNoErr != status)
        {
          LOG1("IPP Error: ippiCopy_8u_P3C3R() failed - ",status);
          return JPEG_INTERNAL_ERROR;
        }
      }
      break;

    case 4:
      {
        const Ipp8u* src[4];
        src[0] = m_ccomp[0].m_cc_buffer + threadoffset;
        src[1] = m_ccomp[1].m_cc_buffer + threadoffset;
        src[2] = m_ccomp[2].m_cc_buffer + threadoffset;
        src[3] = m_ccomp[3].m_cc_buffer + threadoffset;

        status = ippiCopy_8u_P4C4R(src,m_ccWidth,dst,m_dst.lineStep,roi);

        if(ippStsNoErr != status)
        {
          LOG1("IPP Error: ippiCopy_8u_P4C4R() failed - ",status);
          return JPEG_INTERNAL_ERROR;
        }
      }
      break;

    default:
      return JPEG_NOT_IMPLEMENTED;
    }
  }

  // Gray to Gray
  if(m_jpeg_color == JC_GRAY && m_dst.color == JC_GRAY)
  {
    const Ipp8u* src = m_ccomp[0].m_cc_buffer + threadoffset;
    status = ippiCopy_8u_C1R(src,m_ccWidth,dst,m_dst.lineStep,roi);

    if(ippStsNoErr != status)
    {
      LOG1("IPP Error: ippiCopy_8u_C1R() failed - ",status);
      return JPEG_INTERNAL_ERROR;
    }
  }

  // Gray to RGB
  if(m_jpeg_color == JC_GRAY && m_dst.color == JC_RGB)
  {
    const Ipp8u* src[3];
    src[0] = m_ccomp[0].m_cc_buffer + threadoffset;
    src[1] = m_ccomp[0].m_cc_buffer + threadoffset;
    src[2] = m_ccomp[0].m_cc_buffer + threadoffset;

    status = ippiCopy_8u_P3C3R(src,m_ccWidth,dst,m_dst.lineStep,roi);

    if(ippStsNoErr != status)
    {
      LOG1("IPP Error: ippiCopy_8u_P3C3R() failed - ",status);
      return JPEG_INTERNAL_ERROR;
    }
  }

  // Gray to BGR
  if(m_jpeg_color == JC_GRAY && m_dst.color == JC_BGR)
  {
    const Ipp8u* src[3];
    src[0] = m_ccomp[0].m_cc_buffer + threadoffset;
    src[1] = m_ccomp[0].m_cc_buffer + threadoffset;
    src[2] = m_ccomp[0].m_cc_buffer + threadoffset;

    status = ippiCopy_8u_P3C3R(src,m_ccWidth,dst,m_dst.lineStep,roi);

    if(ippStsNoErr != status)
    {
      LOG1("IPP Error: ippiCopy_8u_P3C3R() failed - ",status);
      return JPEG_INTERNAL_ERROR;
    }
  }

  // RGB to RGB
  if(m_jpeg_color == JC_RGB && m_dst.color == JC_RGB)
  {
    const Ipp8u* src[3];
    src[0] = m_ccomp[0].m_cc_buffer + threadoffset;
    src[1] = m_ccomp[1].m_cc_buffer + threadoffset;
    src[2] = m_ccomp[2].m_cc_buffer + threadoffset;

    status = ippiCopy_8u_P3C3R(src,m_ccWidth,dst,m_dst.lineStep,roi);

    if(ippStsNoErr != status)
    {
      LOG1("IPP Error: ippiCopy_8u_P3C3R() failed - ",status);
      return JPEG_INTERNAL_ERROR;
    }
  }

  // RGB to BGR
  if(m_jpeg_color == JC_RGB && m_dst.color == JC_BGR)
  {
    const Ipp8u* src[3];
    src[0] = m_ccomp[2].m_cc_buffer + threadoffset;
    src[1] = m_ccomp[1].m_cc_buffer + threadoffset;
    src[2] = m_ccomp[0].m_cc_buffer + threadoffset;

    status = ippiCopy_8u_P3C3R(src,m_ccWidth,dst,m_dst.lineStep,roi);

    if(ippStsNoErr != status)
    {
      LOG1("IPP Error: ippiCopy_8u_P3C3R() failed - ",status);
      return JPEG_INTERNAL_ERROR;
    }
  }

  // YCbCr to RGB
  if(m_jpeg_color == JC_YCBCR && m_dst.color == JC_RGB)
  {
    const Ipp8u* src[3];
    src[0] = m_ccomp[0].m_cc_buffer + threadoffset;
    src[1] = m_ccomp[1].m_cc_buffer + threadoffset;
    src[2] = m_ccomp[2].m_cc_buffer + threadoffset;

    status = ippiYCbCrToRGB_JPEG_8u_P3C3R(src,m_ccWidth,dst,m_dst.lineStep,roi);

    if(ippStsNoErr != status)
    {
      LOG1("IPP Error: ippiYCbCrToRGB_JPEG_8u_P3C3R() failed - ",status);
      return JPEG_INTERNAL_ERROR;
    }
  }

  // YCbCr to BGR
  if(m_jpeg_color == JC_YCBCR && m_dst.color == JC_BGR)
  {
    const Ipp8u* src[3];
    src[0] = m_ccomp[0].m_cc_buffer + threadoffset;
    src[1] = m_ccomp[1].m_cc_buffer + threadoffset;
    src[2] = m_ccomp[2].m_cc_buffer + threadoffset;

    status = ippiYCbCrToBGR_JPEG_8u_P3C3R(src,m_ccWidth,dst,m_dst.lineStep,roi);

    if(ippStsNoErr != status)
    {
      LOG1("IPP Error: ippiYCbCrToBGR_JPEG_8u_P3C3R() failed - ",status);
      return JPEG_INTERNAL_ERROR;
    }
  }

  // YCbCr to YCbCr (422 sampling)
  if(m_jpeg_color == JC_YCBCR && m_dst.color == JC_YCBCR &&
     m_jpeg_sampling == JS_422 && m_dst.sampling == JS_422)
  {
    const Ipp8u* src[3];
    int step[3];
    src[0] = m_ccomp[0].m_cc_buffer + threadoffset;
    src[1] = m_ccomp[1].m_cc_buffer + threadoffset;
    src[2] = m_ccomp[2].m_cc_buffer + threadoffset;
    step[0] = m_ccWidth;
    step[1] = m_ccWidth;
    step[2] = m_ccWidth;

    status = ippiYCbCr422_8u_P3C2R(src,step,dst,m_dst.lineStep,roi);

    if(ippStsNoErr != status)
    {
      LOG1("IPP Error: ippiYCbCrToRGB_JPEG_8u_P3C3R() failed - ",status);
      return JPEG_INTERNAL_ERROR;
    }
  }

  // CMYK to CMYK
  if(m_jpeg_color == JC_CMYK && m_dst.color == JC_CMYK)
  {
    const Ipp8u* src[4];
    src[0] = m_ccomp[0].m_cc_buffer + threadoffset;
    src[1] = m_ccomp[1].m_cc_buffer + threadoffset;
    src[2] = m_ccomp[2].m_cc_buffer + threadoffset;
    src[3] = m_ccomp[3].m_cc_buffer + threadoffset;

    status = ippiCopy_8u_P4C4R(src,m_ccWidth,dst,m_dst.lineStep,roi);

    if(ippStsNoErr != status)
    {
      LOG1("IPP Error: ippiCopy_8u_P4C4R() failed - ",status);
      return JPEG_INTERNAL_ERROR;
    }
  }

  // YCCK to CMYK
  if(m_jpeg_color == JC_YCCK && m_dst.color == JC_CMYK)
  {
    const Ipp8u* src[4];
    src[0] = m_ccomp[0].m_cc_buffer + threadoffset;
    src[1] = m_ccomp[1].m_cc_buffer + threadoffset;
    src[2] = m_ccomp[2].m_cc_buffer + threadoffset;
    src[3] = m_ccomp[3].m_cc_buffer + threadoffset;

    status = ippiYCCKToCMYK_JPEG_8u_P4C4R(src,m_ccWidth,dst,m_dst.lineStep,roi);

    if(ippStsNoErr != status)
    {
      LOG1("IPP Error: ippiYCCKToCMYK_JPEG_8u_P4C4R() failed - ",status);
      return JPEG_INTERNAL_ERROR;
    }
  }

  return JPEG_OK;
} // CJPEGDecoder::ColorConvert()


JERRCODE CJPEGDecoder::UpSampling(int nMCURow,int idThread)
{
  int i, k, n;
  int threadOffsetCC;
  int threadOffsetSS;
  IppStatus status;

  threadOffsetCC = m_numxMCU * m_mcuWidth * m_mcuHeight * idThread;

  switch(m_jpeg_sampling)
  {
    default:
    case JS_444:
      threadOffsetSS = 0;
      break;

    case JS_422:
      threadOffsetSS = m_numxMCU * (m_mcuWidth>>1) * m_mcuHeight * idThread;
      break;

    case JS_244:
      threadOffsetSS = m_numxMCU * m_mcuWidth * ((m_mcuHeight>>1)) * idThread;
      break;
    case JS_411:
      threadOffsetSS = m_numxMCU * (m_mcuWidth>>1) * ((m_mcuHeight>>1)+2) * idThread;
      break;
  }

  for(k = 0; k < m_jpeg_ncomp; k++)
  {
    // sampling 444
    // nothing to do for 444

    // sampling 422
    if(m_ccomp[k].m_h_factor == 2 && m_ccomp[k].m_v_factor == 1)
    {
      Ipp8u* src = m_ccomp[k].m_ss_buffer + threadOffsetSS;
      Ipp8u* dst = m_ccomp[k].m_cc_buffer + threadOffsetCC;

      if(m_dst.sampling == JS_422)
      {
        IppiSize roi;
        roi.width  = m_ccWidth >> 1;
        roi.height = m_mcuHeight;

        status = ippiCopy_8u_C1R(src,m_ccWidth >> 1,dst,m_ccWidth,roi);
        if(ippStsNoErr != status)
        {
          LOG0("Error: ippiCopy_8u_C1R() failed!");
          return JPEG_INTERNAL_ERROR;
        }
      }
      else
      {
        for(i = 0; i < m_mcuHeight; i++)
        {
          status = ippiSampleUpRowH2V1_Triangle_JPEG_8u_C1(src,m_ccWidth >> 1,dst);
          if(ippStsNoErr != status)
          {
            LOG0("Error: ippiSampleUpRowH2V1_Triangle_JPEG_8u_C1() failed!");
            return JPEG_INTERNAL_ERROR;
          }
          src += (m_ccWidth >> 1);
          dst += m_ccWidth;
        }
      }
    }

    // sampling 244
    if(m_ccomp[k].m_h_factor == 1 && m_ccomp[k].m_v_factor == 2)
    {
      Ipp8u* src = m_ccomp[k].m_ss_buffer + threadOffsetSS + m_ccWidth;
      Ipp8u* dst = m_ccomp[k].m_cc_buffer + threadOffsetCC;

      for(i = 0; i < m_mcuHeight >> 1; i++)
      {
        for(n = 0; n < 2; n++)
        {
          status = ippsCopy_8u(src,dst,m_ccWidth);
          if(ippStsNoErr != status)
          {
            LOG0("Error: ippsCopy_8u() failed!");
            return JPEG_INTERNAL_ERROR;
          }
          dst += m_ccWidth;
        }
        src += m_ccWidth;
      }
    }

    // sampling 411
    if(m_ccomp[k].m_h_factor == 2 && m_ccomp[k].m_v_factor == 2)
    {
      int step = m_ccWidth >> 1;
      Ipp8u* ss_buf = m_ccomp[k].m_ss_buffer + threadOffsetSS;
      Ipp8u* p1 = ss_buf + step;
      Ipp8u* p2 = ss_buf;
      Ipp8u* dst = m_ccomp[k].m_cc_buffer + threadOffsetCC;

      if(nMCURow == 0)
      {
        ippsCopy_8u(ss_buf +   step,ss_buf,         step);
        ippsCopy_8u(ss_buf + 8*step,ss_buf + 9*step,step);
      }
      else
      {
        ippsCopy_8u(ss_buf + 9*step,ss_buf,         step);
        ippsCopy_8u(ss_buf + 8*step,ss_buf + 9*step,step);
      }

      for(i = 0; i < m_mcuHeight >> 1; i++)
      {
        for(n = 0; n < 2; n++)
        {
          p2 = (n == 0) ? p1 - step : p1 + step;

          status = ippiSampleUpRowH2V2_Triangle_JPEG_8u_C1(p1,p2,m_ccWidth >> 1,dst);
          if(ippStsNoErr != status)
          {
            LOG0("Error: ippiSampleUpRowH2V2_Triangle_JPEG_8u_C1() failed!");
            return JPEG_INTERNAL_ERROR;
          }
          dst += m_ccWidth;
        }
        p1 += step;
      }
    } // 411
  } // for m_jpeg_ncomp

  return JPEG_OK;
} // CJPEGDecoder::UpSampling()


JERRCODE CJPEGDecoder::ReadHeader(
  int*    width,
  int*    height,
  int*    nchannels,
  JCOLOR* color,
  JSS*    sampling,
  int*    precision)
{
  JERRCODE jerr;

  jerr = ParseJPEGBitStream(JO_READ_HEADER);

  if(JPEG_OK != jerr)
  {
    LOG0("Error: ParseJPEGBitStream() failed");
    return jerr;
  }

  int du_width  = (JPEG_LOSSLESS == m_jpeg_mode) ? 1 : 8;
  int du_height = (JPEG_LOSSLESS == m_jpeg_mode) ? 1 : 8;

  m_mcuWidth  = du_width  * m_max_hsampling;
  m_mcuHeight = du_height * m_max_vsampling;

  m_numxMCU = (m_jpeg_width  + (m_mcuWidth  - 1)) / m_mcuWidth;
  m_numyMCU = (m_jpeg_height + (m_mcuHeight - 1)) / m_mcuHeight;

  m_xPadding = m_numxMCU * m_mcuWidth  - m_jpeg_width;
  m_yPadding = m_numyMCU * m_mcuHeight - m_jpeg_height;

  m_ccWidth  = m_mcuWidth * m_numxMCU;
  m_ccHeight = m_mcuHeight;

  *width     = m_jpeg_width;
  *height    = m_jpeg_height;
  *nchannels = m_jpeg_ncomp;
  *precision = m_jpeg_precision;
  *color     = m_jpeg_color;
  *sampling  = m_jpeg_sampling;

  return JPEG_OK;
} // CJPEGDecoder::ReadHeader()


JERRCODE CJPEGDecoder::ReadData(void)
{
  return ParseJPEGBitStream(JO_READ_DATA);
} // CJPEGDecoder::ReadData()


JERRCODE CJPEGDecoder::DecodeHuffmanMCURowBL(Ipp16s* pMCUBuf)
{
  int       j, n, k, l;
  Ipp8u*    src;
  int       srcLen;
  JERRCODE  jerr;
  IppStatus status;

  src    = m_src.pData;
  srcLen = m_src.DataLen;

  for(j = 0; j < m_numxMCU; j++)
  {
    if(m_jpeg_restart_interval)
    {
      if(m_restarts_to_go == 0)
      {
        jerr = ProcessRestart();
        if(JPEG_OK != jerr)
        {
          LOG0("Error: ProcessRestart() failed!");
          return jerr;
        }
      }
    }

    for(n = 0; n < m_jpeg_ncomp; n++)
    {
      Ipp16s*                lastDC = &m_ccomp[n].m_lastDC;
      IppiDecodeHuffmanSpec* dctbl  = m_dctbl[m_ccomp[n].m_dc_selector];
      IppiDecodeHuffmanSpec* actbl  = m_actbl[m_ccomp[n].m_ac_selector];

      for(k = 0; k < m_ccomp[n].m_vsampling; k++)
      {
        for(l = 0; l < m_ccomp[n].m_hsampling; l++)
        {
          status = ippiDecodeHuffman8x8_JPEG_1u16s_C1(
            src,
            srcLen,
            &m_src.currPos,
            pMCUBuf,
            lastDC,
            (int*)&m_marker,
            dctbl,
            actbl,
            m_state);

          if(ippStsNoErr > status)
          {
            LOG0("Error: ippiDecodeHuffman8x8_JPEG_1u16s_C1() failed!");
            return JPEG_INTERNAL_ERROR;
          }

          pMCUBuf += DCTSIZE2;
        } // for m_hsampling
      } // for m_vsampling
    } // for m_jpeg_ncomp

    m_restarts_to_go--;
  } // for m_numxMCU

  return JPEG_OK;
} // CJPEGDecoder::DecodeHuffmanMCURowBL()


JERRCODE CJPEGDecoder::DecodeHuffmanMCURowLS(Ipp16s* pMCUBuf)
{
  int       j, n, k, l;
  Ipp8u*    src;
  int       srcLen;
  JERRCODE  jerr;
  IppStatus status;

  src    = m_src.pData;
  srcLen = m_src.DataLen;

  for(j = 0; j < m_numxMCU; j++)
  {
    if(m_jpeg_restart_interval)
    {
      if(m_restarts_to_go == 0)
      {
        jerr = ProcessRestart();
        if(JPEG_OK != jerr)
        {
          LOG0("Error: ProcessRestart() failed!");
          return jerr;
        }
      }
    }

    for(n = 0; n < m_jpeg_ncomp; n++)
    {
      IppiDecodeHuffmanSpec* dctbl = m_dctbl[m_ccomp[n].m_dc_selector];

      for(k = 0; k < m_ccomp[n].m_vsampling; k++)
      {
        for(l = 0; l < m_ccomp[n].m_hsampling; l++)
        {
          status = ippiDecodeHuffmanOne_JPEG_1u16s_C1(
                     src,
                     srcLen,
                     &m_src.currPos,
                     pMCUBuf,