encoder.cpp

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

        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::DownSampling(void)
{
  int i, j, k;

  Ipp8u val;
  Ipp8u* p;
  Ipp8u* p1;

  for(k = 0; k < m_jpeg_ncomp; k++)
  {
    // expand right edge
    if(m_xPadding)
    {
      for(i = 0; i < m_src.height; i++)
      {
        p = m_ccomp[k]->m_cc_buffer + i*m_mcuWidth*m_numxMCU;
        val = p[m_src.width - 1];
        for(j = 0; j < m_xPadding; j++)
        {
          p[m_src.width + j] = val;
        }
      }
    }

    // expand bottom edge only for last MCU row

    if(m_yPadding)
    {
      p = m_ccomp[k]->m_cc_buffer + (m_src.height-1)*m_mcuWidth*m_numxMCU;

      for(i = 0; i < m_yPadding; i++)
      {
        p1 = m_ccomp[k]->m_cc_buffer + m_src.height*m_mcuWidth*m_numxMCU + i*m_mcuWidth*m_numxMCU;
        ippsCopy_8u(p,p1,m_mcuWidth*m_numxMCU);
      }
    }

    // sampling 444
    if(m_ccomp[k]->m_h_factor == 1 && m_ccomp[k]->m_v_factor == 1)
    {
      Ipp8u* src = m_ccomp[k]->m_cc_buffer;
      Ipp8u* dst = m_ccomp[k]->m_ss_buffer;

      ippsCopy_8u(src,dst,m_ccWidth*m_mcuHeight*m_numyMCU);
    }

    IppStatus status;

    // sampling 422
    if(m_ccomp[k]->m_h_factor == 2 && m_ccomp[k]->m_v_factor == 1)
    {
      Ipp8u* src = m_ccomp[k]->m_cc_buffer;
      Ipp8u* dst = m_ccomp[k]->m_ss_buffer;
      IppiSize srcRoi = { m_ccWidth,    m_mcuHeight*m_numyMCU };
      IppiSize dstRoi = { m_ccWidth>>1, m_mcuHeight*m_numyMCU };

      status = ippiSampleDownH2V1_JPEG_8u_C1R(src,m_ccWidth,srcRoi,dst,m_ccWidth,dstRoi);

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

    // sampling 411
    if(m_ccomp[k]->m_h_factor == 2 && m_ccomp[k]->m_v_factor == 2)
    {
      Ipp8u* src = m_ccomp[k]->m_cc_buffer;
      Ipp8u* dst = m_ccomp[k]->m_ss_buffer;
      IppiSize srcRoi = { m_ccWidth,    m_mcuHeight*m_numyMCU    };
      IppiSize dstRoi = { m_ccWidth>>1, m_mcuHeight*m_numyMCU>>1 };

      status = ippiSampleDownH2V2_JPEG_8u_C1R(src,m_ccWidth,srcRoi,dst,m_ccWidth,dstRoi);

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

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


JERRCODE CJPEGEncoder::DownSampling(int nMCURow)
{
  int i, j, k;

  Ipp8u val;
  Ipp8u* p;
  Ipp8u* p1;

  for(k = 0; k < m_jpeg_ncomp; k++)
  {
    // expand right edge
    if(m_xPadding)
    {
      for(i = 0; i < m_ccHeight; i++)
      {
        p = m_ccomp[k]->m_cc_buffer + i*m_ccWidth;
        val = p[m_src.width - 1];
        for(j = 0; j < m_xPadding; j++)
        {
          p[m_src.width + j] = val;
        }
      }
    }

    // expand bottom edge only for last MCU row
    if(nMCURow == m_numyMCU - 1)
    {
      p = m_ccomp[k]->m_cc_buffer + (m_ccHeight-1)*m_ccWidth;

      for(i = 0; i < m_yPadding; i++)
      {
        p1 = m_ccomp[k]->m_cc_buffer + m_ccHeight*m_ccWidth + i*m_ccWidth;
        ippsCopy_8u(p,p1,m_ccWidth);
      }
    }

    // sampling 444
    if(m_ccomp[k]->m_h_factor == 1 && m_ccomp[k]->m_v_factor == 1)
    {
      Ipp8u* src = m_ccomp[k]->m_cc_buffer;
      Ipp8u* dst = m_ccomp[k]->m_ss_buffer;

      ippsCopy_8u(src,dst,m_ccWidth*m_mcuHeight);
    }

    IppStatus status;

    // sampling 422
    if(m_ccomp[k]->m_h_factor == 2 && m_ccomp[k]->m_v_factor == 1)
    {
      Ipp8u* src = m_ccomp[k]->m_cc_buffer;
      Ipp8u* dst = m_ccomp[k]->m_ss_buffer;
      IppiSize srcRoi = { m_ccWidth,    m_mcuHeight };
      IppiSize dstRoi = { m_ccWidth>>1, m_mcuHeight };

      ippsZero_8u(dst,m_ccWidth*m_mcuHeight);

      status = ippiSampleDownH2V1_JPEG_8u_C1R(src,m_ccWidth,srcRoi,dst,m_ccWidth,dstRoi);

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

    // sampling 411
    if(m_ccomp[k]->m_h_factor == 2 && m_ccomp[k]->m_v_factor == 2)
    {
      Ipp8u* src = m_ccomp[k]->m_cc_buffer;
      Ipp8u* dst = m_ccomp[k]->m_ss_buffer;
      IppiSize srcRoi = { m_ccWidth,    m_mcuHeight    };
      IppiSize dstRoi = { m_ccWidth>>1, m_mcuHeight>>1 };

      status = ippiSampleDownH2V2_JPEG_8u_C1R(src,m_ccWidth,srcRoi,dst,m_ccWidth,dstRoi);

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

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


JERRCODE CJPEGEncoder::PerformDCT(void)
{
  int i;
  int j;
  int n;
  int k;
  int l;
  int size;
  int src_step;
  Ipp8u* src;
  Ipp16u* qtbl;
  Ipp16s* block;
  IppStatus status;

  src_step = m_mcuWidth*m_numxMCU;

  for(size = 0, n = 0; n < m_jpeg_ncomp; n++)
  {
    size += (m_ccomp[n]->m_hsampling * m_ccomp[n]->m_vsampling);
  }


  for(i = 0; i < m_numyMCU; i++)
  {
    for(j = 0; j < m_numxMCU; j++)
    {
      block = m_coefbuf + (DCTSIZE2*size*(j+(i*m_numxMCU)));
      for(n = 0; n < m_jpeg_ncomp; n++)
      {
        for(k = 0; k < m_ccomp[n]->m_vsampling; k++)
        {
          for(l = 0; l < m_ccomp[n]->m_hsampling; l++)
          {
            qtbl = m_qntbl[m_ccomp[n]->m_q_selector];

            src  = m_ccomp[n]->m_ss_buffer +
                   i*8*m_ccomp[n]->m_vsampling*m_ccWidth +
                   j*8*m_ccomp[n]->m_hsampling +
                   k*8*m_ccWidth;

            src += l*8;

            status = ippiDCTQuantFwd8x8LS_JPEG_8u16s_C1R(
              src,
              src_step,
              block,
              qtbl);

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

            block += DCTSIZE2;
          } // for m_hsampling
        } // for m_vsampling
      }
    }
  }

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


JERRCODE CJPEGEncoder::GenerateHuffmanTables(
  int ncomp,
  int id[MAX_COMPS_PER_SCAN],
  int Ss,
  int Se,
  int Ah,
  int Al)
{
  int  i;
  int  j;
  int  k;
  int  n;
  int  l;
  int  c;
  int  size;
  int  dc_statistics[2][256];
  int  ac_statistics[2][256];
  JERRCODE jerr;
  IppStatus status;

  ippsZero_8u((Ipp8u*)dc_statistics,sizeof(dc_statistics));
  ippsZero_8u((Ipp8u*)ac_statistics,sizeof(ac_statistics));

  for(n = 0; n < m_jpeg_ncomp; n++)
  {
    m_ccomp[n]->m_lastDC = 0;
  }

  status = ippiEncodeHuffmanStateInit_JPEG_8u(m_state);
  if(ippStsNoErr != status)
  {
    return JPEG_INTERNAL_ERROR;
  }

  for(size = 0, k = 0; k < m_jpeg_ncomp; k++)
  {
    size += (m_ccomp[k]->m_hsampling * m_ccomp[k]->m_vsampling);
  }

  Ipp16s* block;

  if(Ss != 0 && Se != 0)
  {
    // AC scan
    for(i = 0; i < m_numyMCU; i++)
    {
      for(k = 0; k < m_ccomp[id[0]]->m_vsampling; k++)
      {
        if(i*m_ccomp[id[0]]->m_vsampling*8 + k*8 >= m_src.height)
          break;

        for(j = 0; j < m_numxMCU; j++)
        {
          block = m_coefbuf + (DCTSIZE2*size*(j+(i*m_numxMCU)));

          // skip any relevant components
          for(c = 0; c < m_ccomp[id[0]]->m_comp_no; c++)
          {
            block += (DCTSIZE2*m_ccomp[c]->m_hsampling*
                               m_ccomp[c]->m_vsampling);
          }

          // Skip over relevant 8x8 blocks from this component.
          block += (k * DCTSIZE2 * m_ccomp[id[0]]->m_hsampling);

          for(l = 0; l < m_ccomp[id[0]]->m_hsampling; l++)
          {
            if(m_jpeg_restart_interval)
            {
              if(m_restarts_to_go == 0)
              {
                jerr = ProcessRestart(ac_statistics,id,Ss,Se,Ah,Al);
                if(JPEG_OK != jerr)
                {
                  LOG0("Error: ProcessRestart() failed!");
                  return jerr;
                }
              }
            }

            // Ignore the last column(s) of the image.
            if(((j*m_ccomp[id[0]]->m_hsampling*8) + (l*8)) >= m_src.width)
              break;

            if(Ah == 0)
            {
              status = ippiGetHuffmanStatistics8x8_ACFirst_JPEG_16s_C1(
                block,
                &ac_statistics[m_ccomp[id[0]]->m_ac_selector][0],
                Ss,
                Se,
                Al,
                m_state,
                0);

              if(ippStsNoErr > status)
              {
                LOG0("Error: ippiGetHuffmanStatistics8x8_ACFirst_JPEG_16s_C1() failed!");
                return JPEG_INTERNAL_ERROR;
              }
            }
            else
            {
              status = ippiGetHuffmanStatistics8x8_ACRefine_JPEG_16s_C1(
                block,
                &ac_statistics[m_ccomp[id[0]]->m_ac_selector][0],
                Ss,
                Se,
                Al,
                m_state,
                0);

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

            block += DCTSIZE2;
            m_restarts_to_go --;
          } // for m_hsampling
        } // for m_numxMCU
      } // for m_vsampling
    } // for m_numyMCU

    if(Ah == 0)
    {
      status = ippiGetHuffmanStatistics8x8_ACFirst_JPEG_16s_C1(
        0,
        ac_statistics[m_ccomp[id[0]]->m_ac_selector],
        Ss,
        Se,
        Al,
        m_state,
        1);

      if(ippStsNoErr > status)
      {
        LOG0("Error: ippiGetHuffmanStatistics8x8_ACFirst_JPEG_16s_C1() failed!");
        return JPEG_INTERNAL_ERROR;
      }
    }
    else
    {
      status = ippiGetHuffmanStatistics8x8_ACRefine_JPEG_16s_C1(
        0,
        ac_statistics[m_ccomp[id[0]]->m_ac_selector],
        Ss,
        Se,
        Al,
        m_state,
        1);

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

    Ipp8u bits[16];
    Ipp8u vals[256];

    ippsZero_8u(bits,sizeof(bits));
    ippsZero_8u(vals,sizeof(vals));

    status = ippiEncodeHuffmanRawTableInit_JPEG_8u(
               &ac_statistics[m_ccomp[id[0]]->m_ac_selector][0],
               bits,
               vals);

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

    jerr = m_actbl[m_ccomp[id[0]]->m_ac_selector].Init(m_ccomp[id[0]]->m_ac_selector,1,bits,vals);
    if(JPEG_OK != jerr)
    {
      LOG0("Error: can't init huffman table");
      return jerr;
    }
  }
  else
  {
    // DC scan
    if(Ah == 0)
    {
      for(i = 0; i < m_numyMCU; i++)
      {
        for(j = 0; j < m_numxMCU; j++)
        {
          if(m_jpeg_restart_interval)