encoder.cpp

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

    m_scan_script[0].id[2] = 2;
    m_scan_script[0].id[3] = 3;
    m_scan_script[0].Ss    = 0;
    m_scan_script[0].Se    = 0;
    m_scan_script[0].Ah    = 0;
    m_scan_script[0].Al    = 1;
    // 2 AC scan, def(0)
    m_scan_script[1].ncomp = 1;
    m_scan_script[1].id[0] = 0;
    m_scan_script[1].Ss    = 1;
    m_scan_script[1].Se    = 5;
    m_scan_script[1].Ah    = 0;
    m_scan_script[1].Al    = 2;
    // 3 AC scan, def(1)
    m_scan_script[2].ncomp = 1;
    m_scan_script[2].id[0] = 1;
    m_scan_script[2].Ss    = 1;
    m_scan_script[2].Se    = 5;
    m_scan_script[2].Ah    = 0;
    m_scan_script[2].Al    = 2;
    // 4 AC scan, def(2)
    m_scan_script[3].ncomp = 1;
    m_scan_script[3].id[0] = 2;
    m_scan_script[3].Ss    = 1;
    m_scan_script[3].Se    = 5;
    m_scan_script[3].Ah    = 0;
    m_scan_script[3].Al    = 2;
    // 5 AC scan, def(3)
    m_scan_script[4].ncomp = 1;
    m_scan_script[4].id[0] = 3;
    m_scan_script[4].Ss    = 1;
    m_scan_script[4].Se    = 5;
    m_scan_script[4].Ah    = 0;
    m_scan_script[4].Al    = 2;
    // 6 AC scan, def(0)
    m_scan_script[5].ncomp = 1;
    m_scan_script[5].id[0] = 0;
    m_scan_script[5].Ss    = 6;
    m_scan_script[5].Se    = 63;
    m_scan_script[5].Ah    = 0;
    m_scan_script[5].Al    = 2;
    // 7 AC scan, def(1)
    m_scan_script[6].ncomp = 1;
    m_scan_script[6].id[0] = 1;
    m_scan_script[6].Ss    = 6;
    m_scan_script[6].Se    = 63;
    m_scan_script[6].Ah    = 0;
    m_scan_script[6].Al    = 2;
    // 8 AC scan, def(2)
    m_scan_script[7].ncomp = 1;
    m_scan_script[7].id[0] = 2;
    m_scan_script[7].Ss    = 6;
    m_scan_script[7].Se    = 63;
    m_scan_script[7].Ah    = 0;
    m_scan_script[7].Al    = 2;
    // 9 AC scan, def(3)
    m_scan_script[8].ncomp = 1;
    m_scan_script[8].id[0] = 3;
    m_scan_script[8].Ss    = 6;
    m_scan_script[8].Se    = 63;
    m_scan_script[8].Ah    = 0;
    m_scan_script[8].Al    = 2;
    // 10 AC scan, ref(0)
    m_scan_script[9].ncomp = 1;
    m_scan_script[9].id[0] = 0;
    m_scan_script[9].Ss    = 1;
    m_scan_script[9].Se    = 63;
    m_scan_script[9].Ah    = 2;
    m_scan_script[9].Al    = 1;
    // 11 AC scan, ref(1)
    m_scan_script[10].ncomp = 1;
    m_scan_script[10].id[0] = 1;
    m_scan_script[10].Ss    = 1;
    m_scan_script[10].Se    = 63;
    m_scan_script[10].Ah    = 2;
    m_scan_script[10].Al    = 1;
    // 12 AC scan, ref(2)
    m_scan_script[11].ncomp = 1;
    m_scan_script[11].id[0] = 2;
    m_scan_script[11].Ss    = 1;
    m_scan_script[11].Se    = 63;
    m_scan_script[11].Ah    = 2;
    m_scan_script[11].Al    = 1;
    // 13 AC scan, ref(3)
    m_scan_script[12].ncomp = 1;
    m_scan_script[12].id[0] = 3;
    m_scan_script[12].Ss    = 1;
    m_scan_script[12].Se    = 63;
    m_scan_script[12].Ah    = 2;
    m_scan_script[12].Al    = 1;
    // 14 DC scan, ref
    m_scan_script[13].ncomp = 4;
    m_scan_script[13].id[0] = 0;
    m_scan_script[13].id[1] = 1;
    m_scan_script[13].id[2] = 2;
    m_scan_script[13].id[3] = 3;
    m_scan_script[13].Ss    = 0;
    m_scan_script[13].Se    = 0;
    m_scan_script[13].Ah    = 1;
    m_scan_script[13].Al    = 0;
    // 15 AC scan, ref(0)
    m_scan_script[14].ncomp = 1;
    m_scan_script[14].id[0] = 0;
    m_scan_script[14].Ss    = 1;
    m_scan_script[14].Se    = 63;
    m_scan_script[14].Ah    = 1;
    m_scan_script[14].Al    = 0;
    // 16 AC scan, ref(1)
    m_scan_script[15].ncomp = 1;
    m_scan_script[15].id[0] = 1;
    m_scan_script[15].Ss    = 1;
    m_scan_script[15].Se    = 63;
    m_scan_script[15].Ah    = 1;
    m_scan_script[15].Al    = 0;
    // 17 AC scan, ref(2)
    m_scan_script[16].ncomp = 1;
    m_scan_script[16].id[0] = 2;
    m_scan_script[16].Ss    = 1;
    m_scan_script[16].Se    = 63;
    m_scan_script[16].Ah    = 1;
    m_scan_script[16].Al    = 0;
    // 18 AC scan, ref(3)
    m_scan_script[17].ncomp = 1;
    m_scan_script[17].id[0] = 3;
    m_scan_script[17].Ss    = 1;
    m_scan_script[17].Se    = 63;
    m_scan_script[17].Ah    = 1;
    m_scan_script[17].Al    = 0;
    break;

  default:
    return JPEG_NOT_IMPLEMENTED;
  }

  return JPEG_OK;
} // CJPEGEncoder::SelectScanScripts()


JERRCODE CJPEGEncoder::Init(void)
{
  JERRCODE  jerr;

  switch(m_jpeg_color)
  {
  case JC_GRAY:  m_jpeg_ncomp = 1; break;
  case JC_RGB:   m_jpeg_ncomp = 3; break;
  case JC_YCBCR: m_jpeg_ncomp = 3; break;
  case JC_CMYK:  m_jpeg_ncomp = 4; break;
  case JC_YCCK:  m_jpeg_ncomp = 4; break;
  default:
    // let to user selects the number of component
    break;
  }

  m_xPadding = m_numxMCU * m_mcuWidth  - m_src.width;
  m_yPadding = m_numyMCU * m_mcuHeight - m_src.height;

  m_ccWidth  = m_mcuWidth * m_numxMCU;
  m_ccHeight = m_mcuHeight;

  for(int i = 0; i < m_jpeg_ncomp; i++)
  {
    int cc_buf_size;
    int ss_buf_size;

    switch(m_jpeg_mode)
    {
    case JPEG_BASELINE:
      cc_buf_size = m_ccWidth*m_ccHeight;
      ss_buf_size = m_ccWidth*m_ccHeight;
      break;

    case JPEG_PROGRESSIVE:
      cc_buf_size = (m_mcuWidth*m_mcuHeight)*(m_numxMCU*m_numyMCU);
      ss_buf_size = (m_mcuWidth*m_mcuHeight)*(m_numxMCU*m_numyMCU);
      break;

    case JPEG_LOSSLESS:
      cc_buf_size = m_ccWidth*sizeof(Ipp16s);
      ss_buf_size = m_ccWidth*sizeof(Ipp16s);
      break;

    default:
      return JPEG_INTERNAL_ERROR;
    }

    if(0 != m_ccomp[i])
    {
      if(0 != m_ccomp[i]->m_cc_buffer)
      {
        ippFree(m_ccomp[i]->m_cc_buffer);
        m_ccomp[i]->m_cc_buffer = 0;
      }

      if(0 != m_ccomp[i]->m_ss_buffer)
      {
        ippFree(m_ccomp[i]->m_ss_buffer);
        m_ccomp[i]->m_ss_buffer = 0;
      }

      delete m_ccomp[i];
    }

    m_ccomp[i] = new CJPEGColorComponent;
    if(0 == m_ccomp[i])
    {
      return JPEG_OUT_OF_MEMORY;
    }

    m_ccomp[i]->m_id          = i;
    m_ccomp[i]->m_comp_no     = i;
    m_ccomp[i]->m_hsampling   = (m_jpeg_sampling == JS_444) ? 1 : (i == 0 || i == 3 ? 2 : 1);
    m_ccomp[i]->m_vsampling   = (m_jpeg_sampling == JS_411) ? (i == 0 || i == 3 ? 2 : 1) : 1;
    m_ccomp[i]->m_h_factor    = (m_jpeg_sampling == JS_444) ? 1 : (i == 0 || i == 3? 1 : 2);
    m_ccomp[i]->m_v_factor    = (m_jpeg_sampling == JS_411) ? (i == 0 || i == 3 ? 1 : 2) : 1;
    m_ccomp[i]->m_nblocks     = m_ccomp[i]->m_hsampling * m_ccomp[i]->m_vsampling;
    m_ccomp[i]->m_q_selector  = (i == 0 || i == 3) ? 0 : (m_jpeg_color == JC_YCBCR || m_jpeg_color == JC_YCCK ? 1 : 0);
    m_ccomp[i]->m_dc_selector = (i == 0 || i == 3) ? 0 : 1;
    m_ccomp[i]->m_ac_selector = (i == 0 || i == 3) ? 0 : 1;

    // color convert intermediate 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;
    }

    // subsampling buffer
    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_cc_buffer;
    m_ccomp[i]->m_prev_row = (Ipp16s*)m_ccomp[i]->m_ss_buffer;
  }

  if(JPEG_PROGRESSIVE == m_jpeg_mode)
  {
    SelectScanScripts();
  }

  if(JPEG_PROGRESSIVE == m_jpeg_mode)
  {
    if(0 == m_coefbuf)
    {
      int sz = m_numxMCU*m_numyMCU*MAX_BYTES_PER_MCU*sizeof(Ipp16s);

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

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

  if(JPEG_LOSSLESS == m_jpeg_mode)
  {
      int sz = m_numxMCU*sizeof(Ipp16s);

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

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

  m_dctbl[0].Create();
  m_dctbl[1].Create();
  m_actbl[0].Create();
  m_actbl[1].Create();

  if(JPEG_LOSSLESS != m_jpeg_mode)
  {
    jerr = m_qntbl[0].Init(0,m_jpeg_quality,(Ipp8u*)DefaultLuminanceQuant);
    if(JPEG_OK != jerr)
    {
      LOG0("Error: can't init quant table");
      return jerr;
    }

    jerr = m_qntbl[1].Init(1,m_jpeg_quality,(Ipp8u*)DefaultChrominanceQuant);
    if(JPEG_OK != jerr)
    {
      LOG0("Error: can't init quant table");
      return jerr;
    }
  }

  jerr = m_dctbl[0].Init(0,0,(Ipp8u*)DefaultLuminanceDCBits,(Ipp8u*)DefaultLuminanceDCValues);
  if(JPEG_OK != jerr)
  {
    LOG0("Error: can't init huffman table");
    return jerr;
  }

  jerr = m_dctbl[1].Init(1,0,(Ipp8u*)DefaultChrominanceDCBits,(Ipp8u*)DefaultChrominanceDCValues);
  if(JPEG_OK != jerr)
  {
    LOG0("Error: can't init huffman table");
    return jerr;
  }

  jerr = m_actbl[0].Init(0,1,(Ipp8u*)DefaultLuminanceACBits,(Ipp8u*)DefaultLuminanceACValues);
  if(JPEG_OK != jerr)
  {
    LOG0("Error: can't init huffman table");
    return jerr;
  }

  jerr = m_actbl[1].Init(1,1,(Ipp8u*)DefaultChrominanceACBits,(Ipp8u*)DefaultChrominanceACValues);
  if(JPEG_OK != jerr)
  {
    LOG0("Error: can't init huffman table");
    return jerr;
  }

  m_state.Create();

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


JERRCODE CJPEGEncoder::ColorConvert(void)
{
  IppStatus status;

  IppiSize roi = { m_src.width, m_src.height };

  Ipp8u* src = m_src.p.Data8u;

  if(m_jpeg_color == JC_UNKNOWN && m_src.color == JC_UNKNOWN)
  {
    switch(m_jpeg_ncomp)
    {
    case 1:
      {
        Ipp8u* dst = m_ccomp[0]->m_cc_buffer;

        status = ippiCopy_8u_C1R(src,m_src.lineStep,dst,m_ccWidth,roi);
        if(ippStsNoErr != status)
        {
          LOG1("IPP Error: ippiCopy_8u_C1R() failed - ",status);
          return JPEG_INTERNAL_ERROR;
        }
      }
      break;

    case 3:
      {
        Ipp8u* dst[3];
        dst[0] = m_ccomp[0]->m_cc_buffer;
        dst[1] = m_ccomp[1]->m_cc_buffer;
        dst[2] = m_ccomp[2]->m_cc_buffer;

        status = ippiCopy_8u_C3P3R(src,m_src.lineStep,dst,m_ccWidth,roi);

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

    case 4:
      {
        Ipp8u* dst[4];
        dst[0] = m_ccomp[0]->m_cc_buffer;
        dst[1] = m_ccomp[1]->m_cc_buffer;
        dst[2] = m_ccomp[2]->m_cc_buffer;
        dst[3] = m_ccomp[3]->m_cc_buffer;

        status = ippiCopy_8u_C4P4R(src,m_src.lineStep,dst,m_ccWidth,roi);

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

    default:
      return JPEG_NOT_IMPLEMENTED;
    }
  }

  // Gray to Gray
  if(m_src.color == JC_GRAY && m_jpeg_color == JC_GRAY)
  {
    Ipp8u* dst = m_ccomp[0]->m_cc_buffer;

    status = ippiCopy_8u_C1R(src,m_src.lineStep,dst,m_ccWidth,roi);
    if(ippStsNoErr != status)
    {
      LOG1("IPP Error: ippiCopy_8u_C1R() failed - ",status);
      return JPEG_INTERNAL_ERROR;
    }
  }

  // RGB to Gray
  if(m_src.color == JC_RGB && m_jpeg_color == JC_GRAY)
  {
    Ipp8u* dst = m_ccomp[0]->m_cc_buffer;

    status = ippiRGBToY_JPEG_8u_C3C1R(src,m_src.lineStep,dst,m_ccWidth,roi);
    if(ippStsNoErr != status)
    {
      LOG1("IPP Error: ippiRGBToY_JPEG_8u_C3C1R() failed - ",status);
      return JPEG_INTERNAL_ERROR;
    }
  }

  // RGB to RGB
  if(m_src.color == JC_RGB && m_jpeg_color == JC_RGB)
  {
    Ipp8u* dst[3];
    dst[0] = m_ccomp[0]->m_cc_buffer;
    dst[1] = m_ccomp[1]->m_cc_buffer;
    dst[2] = m_ccomp[2]->m_cc_buffer;

    status = ippiCopy_8u_C3P3R(src,m_src.lineStep,dst,m_ccWidth,roi);

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

  // RGB to YCbCr
  if(m_src.color == JC_RGB && m_jpeg_color == JC_YCBCR)
  {
    Ipp8u* dst[3];
    dst[0] = m_ccomp[0]->m_cc_buffer;
    dst[1] = m_ccomp[1]->m_cc_buffer;
    dst[2] = m_ccomp[2]->m_cc_buffer;

    status = ippiRGBToYCbCr_JPEG_8u_C3P3R(src,m_src.lineStep,dst,m_ccWidth,roi);

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

  // BGR to YCbCr
  if(m_src.color == JC_BGR && m_jpeg_color == JC_YCBCR)
  {
    Ipp8u* dst[3];
    dst[0] = m_ccomp[0]->m_cc_buffer;
    dst[1] = m_ccomp[1]->m_cc_buffer;
    dst[2] = m_ccomp[2]->m_cc_buffer;

    status = ippiBGRToYCbCr_JPEG_8u_C3P3R(src,m_src.lineStep,dst,m_ccWidth,roi);

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

  // CMYK to CMYK
  if(m_src.color == JC_CMYK && m_jpeg_color == JC_CMYK)
  {
    Ipp8u* dst[4];
    dst[0] = m_ccomp[0]->m_cc_buffer;
    dst[1] = m_ccomp[1]->m_cc_buffer;
    dst[2] = m_ccomp[2]->m_cc_buffer;
    dst[3] = m_ccomp[3]->m_cc_buffer;

    status = ippiCopy_8u_C4P4R(src,m_src.lineStep,dst,m_ccWidth,roi);

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

  // CMYK to YCCK
  if(m_src.color == JC_CMYK && m_jpeg_color == JC_YCCK)
  {
    Ipp8u* dst[4];
    dst[0] = m_ccomp[0]->m_cc_buffer;
    dst[1] = m_ccomp[1]->m_cc_buffer;
    dst[2] = m_ccomp[2]->m_cc_buffer;
    dst[3] = m_ccomp[3]->m_cc_buffer;

    status = ippiCMYKToYCCK_JPEG_8u_C4P4R(src,m_src.lineStep,dst,m_ccWidth,roi);

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

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


JERRCODE CJPEGEncoder::ColorConvert(int nMCURow)
{
  IppStatus status;

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

  IppiSize roi = { m_src.width, m_ccHeight };

  Ipp8u* src = m_src.p.Data8u + nMCURow*m_mcuHeight*m_src.lineStep;

  if(m_jpeg_color == JC_UNKNOWN && m_src.color == JC_UNKNOWN)
  {
    switch(m_jpeg_ncomp)
    {
    case 1:
      {
        Ipp8u* dst = m_ccomp[0]->m_cc_buffer;

        status = ippiCopy_8u_C1R(src,m_src.lineStep,dst,m_ccWidth,roi);
        if(ippStsNoErr != status)
        {
          LOG1("IPP Error: ippiCopy_8u_C1R() failed - ",status);
          return JPEG_INTERNAL_ERROR;
        }
      }
      break;

    case 3:
      {
        Ipp8u* dst[3];
        dst[0] = m_ccomp[0]->m_cc_buffer;
        dst[1] = m_ccomp[1]->m_cc_buffer;
        dst[2] = m_ccomp[2]->m_cc_buffer;

        status = ippiCopy_8u_C3P3R(src,m_src.lineStep,dst,m_ccWidth,roi);

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

    case 4:
      {
        Ipp8u* dst[4];
        dst[0] = m_ccomp[0]->m_cc_buffer;
        dst[1] = m_ccomp[1]->m_cc_buffer;
        dst[2] = m_ccomp[2]->m_cc_buffer;
        dst[3] = m_ccomp[3]->m_cc_buffer;

        status = ippiCopy_8u_C4P4R(src,m_src.lineStep,dst,m_ccWidth,roi);