encoder.cpp

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

          {
            if(m_restarts_to_go == 0)
            {
              jerr = ProcessRestart(dc_statistics,id,Ss,Se,Ah,Al);
              if(JPEG_OK != jerr)
              {
                LOG0("Error: ProcessRestart() failed!");
                return jerr;
              }
            }
          }

          block = m_coefbuf + (DCTSIZE2*size*(j+(i*m_numxMCU)));

          // first DC scan
          for(n = 0; n < m_jpeg_ncomp; n++)
          {
            Ipp16s* lastDC = &m_ccomp[n]->m_lastDC;

            for(k = 0; k < m_ccomp[n]->m_vsampling; k++)
            {
              for(l = 0; l < m_ccomp[n]->m_hsampling; l++)
              {
                status = ippiGetHuffmanStatistics8x8_DCFirst_JPEG_16s_C1(
                  block,
                  dc_statistics[m_ccomp[n]->m_dc_selector],
                  lastDC,
                  Al);

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

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

      for(n = 0; n < ncomp; n++)
      {
        Ipp8u bits[16];
        Ipp8u vals[256];

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

        status = ippiEncodeHuffmanRawTableInit_JPEG_8u(
                   dc_statistics[m_ccomp[n]->m_dc_selector],
                   bits,
                   vals);

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

        jerr = m_dctbl[m_ccomp[n]->m_dc_selector].Init(m_ccomp[n]->m_dc_selector,0,bits,vals);
        if(JPEG_OK != jerr)
        {
          LOG0("Error: can't init huffman table");
          return jerr;
        }
      }
    } // Ah == 0
  }

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


JERRCODE CJPEGEncoder::EncodeScan(
  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;
  Ipp16s* block;
  JERRCODE jerr;
  IppStatus status;

  GenerateHuffmanTables(ncomp,id,Ss,Se,Ah,Al);

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

  m_restarts_to_go = m_jpeg_restart_interval;

  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);
  }

  if(Ss != 0 && Se != 0)
  {
    jerr = WriteDHT(&m_actbl[m_ccomp[id[0]]->m_ac_selector]);
    if(JPEG_OK != jerr)
    {
      LOG0("Error: WriteDHT() failed");
      return jerr;
    }

    jerr = WriteSOS(ncomp,id,Ss,Se,Ah,Al);
    if(JPEG_OK != jerr)
    {
      LOG0("Error: WriteSOS() failed");
      return jerr;
    }

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

            if(m_jpeg_restart_interval)
            {
              if(m_restarts_to_go == 0)
              {
                jerr = ProcessRestart(id,Ss,Se,Ah,Al);
                if(JPEG_OK != jerr)
                {
                  LOG0("Error: ProcessRestart() failed!");
                  return jerr;
                }
              }
            }

            IppiEncodeHuffmanSpec* actbl = m_actbl[m_ccomp[id[0]]->m_ac_selector];

            if(Ah == 0)
            {
              status = ippiEncodeHuffman8x8_ACFirst_JPEG_16s1u_C1(
                block,
                m_dst.pData,
                m_dst.DataLen,
                &m_dst.currPos,
                Ss,
                Se,
                Al,
                actbl,
                m_state,
                0);

              if(ippStsNoErr > status)
              {
                LOG1("Error: ippiEncodeHuffman8x8_ACFirst_JPEG_16s1u_C1() failed!",ippGetStatusString(status));
                return JPEG_INTERNAL_ERROR;
              }
            }
            else
            {
              status = ippiEncodeHuffman8x8_ACRefine_JPEG_16s1u_C1(
                block,
                m_dst.pData,
                m_dst.DataLen,
                &m_dst.currPos,
                Ss,
                Se,
                Al,
                actbl,
                m_state,
                0);

              if(ippStsNoErr > status)
              {
                LOG1("Error: ippiEncodeHuffman8x8_ACRefine_JPEG_16s1u_C1() failed!",ippGetStatusString(status));
                return JPEG_INTERNAL_ERROR;
              }
            }

            block += DCTSIZE2;

            m_restarts_to_go --;
          } // for m_hsampling
        } // for m_numxMCU
      } // for m_vsampling
    } // for m_numyMCU

    IppiEncodeHuffmanSpec* actbl = m_actbl[m_ccomp[id[0]]->m_ac_selector];

    if(Ah == 0)
    {
      status = ippiEncodeHuffman8x8_ACFirst_JPEG_16s1u_C1(
        0,
        m_dst.pData,
        m_dst.DataLen,
        &m_dst.currPos,
        Ss,
        Se,
        Al,
        actbl,
        m_state,
        1);

      if(ippStsNoErr > status)
      {
        LOG0("Error: ippiEncodeHuffman8x8_ACFirst_JPEG_16s1u_C1() failed!");
        return JPEG_INTERNAL_ERROR;
      }
    }
    else
    {
      status = ippiEncodeHuffman8x8_ACRefine_JPEG_16s1u_C1(
        0,
        m_dst.pData,
        m_dst.DataLen,
        &m_dst.currPos,
        Ss,
        Se,
        Al,
        actbl,
        m_state,
        1);

      if(ippStsNoErr > status)
      {
        LOG0("Error: ippiEncodeHuffman8x8_ACRefine_JPEG_16s1u_C1() failed!");
        return JPEG_INTERNAL_ERROR;
      }
    }
  }
  else
  {
    if(Ah == 0)
    {
      jerr = WriteDHT(&m_dctbl[0]);
      if(JPEG_OK != jerr)
      {
        LOG0("Error: WriteDHT() failed");
        return jerr;
      }

      if(m_jpeg_ncomp != 1)
      {
        jerr = WriteDHT(&m_dctbl[1]);
        if(JPEG_OK != jerr)
        {
          LOG0("Error: WriteDHT() failed");
          return jerr;
        }
      }
    }

    jerr = WriteSOS(ncomp,id,Ss,Se,Ah,Al);
    if(JPEG_OK != jerr)
    {
      LOG0("Error: WriteSOS() failed");
      return jerr;
    }

    // DC scan
    for(i = 0; i < m_numyMCU; i++)
    {
      for(j = 0; j < m_numxMCU; j++)
      {
        if(m_jpeg_restart_interval)
        {
          if(m_restarts_to_go == 0)
          {
            jerr = ProcessRestart(id,Ss,Se,Ah,Al);
            if(JPEG_OK != jerr)
            {
              LOG0("Error: ProcessRestart() failed!");
              return jerr;
            }
          }
        }

        block = m_coefbuf + (DCTSIZE2*size*(j+(i*m_numxMCU)));

        if(Ah == 0)
        {
          // first DC scan
          for(n = 0; n < m_jpeg_ncomp; n++)
          {
            Ipp16s* lastDC = &m_ccomp[n]->m_lastDC;
            IppiEncodeHuffmanSpec* 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 = ippiEncodeHuffman8x8_DCFirst_JPEG_16s1u_C1(
                  block,
                  m_dst.pData,
                  m_dst.DataLen,
                  &m_dst.currPos,
                  lastDC,
                  Al,
                  dctbl,
                  m_state,
                  0);

                if(ippStsNoErr > status)
                {
                  LOG1("Error: ippiEncodeHuffman8x8_DCFirst_JPEG_16s1u_C1() failed!",ippGetStatusString(status));
                  return JPEG_INTERNAL_ERROR;
                }

                block += DCTSIZE2;
              } // for m_hsampling
            } // for m_vsampling
          } // for m_jpeg_ncomp
        }
        else
        {
          // refine DC scan
          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++)
              {
                status = ippiEncodeHuffman8x8_DCRefine_JPEG_16s1u_C1(
                  block,
                  m_dst.pData,
                  m_dst.DataLen,
                  &m_dst.currPos,
                  Al,
                  m_state,
                  0);

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

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

    if(Ah == 0)
    {
      status = ippiEncodeHuffman8x8_DCFirst_JPEG_16s1u_C1(
                 0,m_dst.pData,m_dst.DataLen,&m_dst.currPos,0,0,0,m_state,1);

      if(ippStsNoErr > status)
      {
        LOG0("Error: ippiEncodeHuffman8x8_DCFirst_JPEG_16s1u_C1() failed!");
        return JPEG_INTERNAL_ERROR;
      }
    }
    else
    {
      status = ippiEncodeHuffman8x8_DCRefine_JPEG_16s1u_C1(
                 0,m_dst.pData,m_dst.DataLen,&m_dst.currPos,0,m_state,1);

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

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


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

  jerr = Init();
  if(JPEG_OK != jerr)
  {
    LOG0("Error: can't init encoder");
    return jerr;
  }

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

  if(m_jpeg_color == JC_GRAY || m_jpeg_color == JC_YCBCR)
  {
    jerr = WriteAPP0();
    if(JPEG_OK != jerr)
    {
      LOG0("Error: WriteAPP0() failed");
      return jerr;
    }
  }

  if(m_jpeg_color == JC_RGB || m_jpeg_color == JC_CMYK || m_jpeg_color == JC_YCCK)
  {
    jerr = WriteAPP14();
    if(JPEG_OK != jerr)
    {
      LOG0("Error: WriteAPP14() failed");
      return jerr;
    }
  }

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

  jerr = WriteDQT(&m_qntbl[0]);
  if(JPEG_OK != jerr)
  {
    LOG0("Error: WriteDQT() failed");
    return jerr;
  }

  if(m_jpeg_ncomp != 1)
  {
    jerr = WriteDQT(&m_qntbl[1]);
    if(JPEG_OK != jerr)
    {
      LOG0("Error: WriteDQT() failed");
      return jerr;
    }
  }

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

  jerr = WriteDHT(&m_dctbl[0]);
  if(JPEG_OK != jerr)
  {
    LOG0("Error: WriteDHT() failed");
    return jerr;
  }

  if(m_jpeg_ncomp != 1)
  {
    jerr = WriteDHT(&m_dctbl[1]);
    if(JPEG_OK != jerr)
    {
      LOG0("Error: WriteDHT() failed");
      return jerr;
    }
  }

  jerr = WriteDHT(&m_actbl[0]);
  if(JPEG_OK != jerr)
  {
    LOG0("Error: WriteDHT() failed");
    return jerr;
  }

  if(m_jpeg_ncomp != 1)
  {
    jerr = WriteDHT(&m_actbl[1]);
    if(JPEG_OK != jerr)
    {
      LOG0("Error: WriteDHT() failed");
      return jerr;
    }
  }

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

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

  IppStatus status;
  IppiEncodeHuffmanSpec* pDCTbl = 0;
  IppiEncodeHuffmanSpec* pACTbl = 0;
  Ipp8u   tmp[DCTSIZE2*sizeof(Ipp16s)+(CPU_CACHE_LINE-1)];
  Ipp16s* block = (Ipp16s*)OWN_ALIGN_PTR(&tmp[0],CPU_CACHE_LINE);

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

  for(int i = 0; i < m_numyMCU; i++)
  {
    jerr = ColorConvert(i);
    if(JPEG_OK != jerr)
    {
      LOG0("Error: ColorConvert() failed");
      return jerr;
    }

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

    Ipp8u* src = 0;
    int src_step = m_ccWidth;

    for(int j = 0; j < m_numxMCU; j++)
    {
      // process restart interval, if any