encoder.cpp

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

  m_dst._WRITE_WORD(m_src.height);
  m_dst._WRITE_WORD(m_src.width);

  m_dst._WRITE_BYTE(m_jpeg_ncomp);

  for(int i = 0; i < m_jpeg_ncomp; i++)
  {
    m_dst._WRITE_BYTE(i);
    m_dst._WRITE_BYTE((m_ccomp[i]->m_hsampling << 4) | m_ccomp[i]->m_vsampling);
    m_dst._WRITE_BYTE(m_ccomp[i]->m_q_selector);
  }

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


JERRCODE CJPEGEncoder::WriteSOF2(void)
{
  int len;

  TRC0("-> WriteSOF2");

  len = 8 + m_jpeg_ncomp * 3;

  if(m_dst.currPos + len >= m_dst.DataLen)
  {
    LOG0("Error: buffer too small");
    return JPEG_BUFF_TOO_SMALL;
  }

  TRC1("  emit marker ",JM_SOF2);
  TRC1("    length ",len);

  m_dst._WRITE_WORD(0xff00 | JM_SOF2);
  m_dst._WRITE_WORD(len);

  // sample precision
  m_dst._WRITE_BYTE(8);

  m_dst._WRITE_WORD(m_src.height);
  m_dst._WRITE_WORD(m_src.width);

  TRC1("  height ",m_src.height);
  TRC1("  width  ",m_src.width);

  m_dst._WRITE_BYTE(m_jpeg_ncomp);

  for(int i = 0; i < m_jpeg_ncomp; i++)
  {
    m_dst._WRITE_BYTE(i);
    m_dst._WRITE_BYTE((m_ccomp[i]->m_hsampling << 4) | m_ccomp[i]->m_vsampling);
    m_dst._WRITE_BYTE(m_ccomp[i]->m_q_selector);

    TRC1("    id ",i);
    TRC1("      h_sampling ",m_ccomp[i]->m_hsampling);
    TRC1("      v_sampling ",m_ccomp[i]->m_vsampling);
    TRC1("      q_selector ",m_ccomp[i]->m_q_selector);
  }

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


JERRCODE CJPEGEncoder::WriteSOF3(void)
{
  int len;

  TRC0("-> WriteSOF3");

  len = 8 + m_jpeg_ncomp * 3;

  if(m_dst.currPos + len >= m_dst.DataLen)
  {
    LOG0("Error: buffer too small");
    return JPEG_BUFF_TOO_SMALL;
  }

  TRC1("  emit marker ",JM_SOF3);
  TRC1("    length ",len);

  m_dst._WRITE_WORD(0xff00 | JM_SOF3);
  m_dst._WRITE_WORD(len);

  // sample precision
  m_dst._WRITE_BYTE(m_jpeg_precision);

  m_dst._WRITE_WORD(m_src.height);
  m_dst._WRITE_WORD(m_src.width);

  m_dst._WRITE_BYTE(m_jpeg_ncomp);

  for(int i = 0; i < m_jpeg_ncomp; i++)
  {
    m_dst._WRITE_BYTE(i);
    m_dst._WRITE_BYTE((m_ccomp[i]->m_hsampling << 4) | m_ccomp[i]->m_vsampling);
    m_dst._WRITE_BYTE(m_ccomp[i]->m_q_selector);
  }

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


JERRCODE CJPEGEncoder::WriteDRI(
  int    restart_interval)
{
  int len;

  TRC0("-> WriteDRI");

  len = 2 + 2;

  if(m_dst.currPos + len >= m_dst.DataLen)
  {
    LOG0("Error: buffer too small");
    return JPEG_BUFF_TOO_SMALL;
  }

  TRC1("  emit marker ",JM_DRI);
  TRC1("    length ",len);

  m_dst._WRITE_WORD(0xff00 | JM_DRI);
  m_dst._WRITE_WORD(len);

  // emit restart interval
  m_dst._WRITE_WORD(restart_interval);

  m_restarts_to_go = m_jpeg_restart_interval;
  m_next_restart_num = 0;

  TRC1("  restart ",restart_interval);

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


JERRCODE CJPEGEncoder::WriteRST(
  int    next_restart_num)
{
  int len;

  TRC0("-> WriteRST");

  len = 2;

  if(m_dst.currPos + len >= m_dst.DataLen)
  {
    LOG0("Error: buffer too small");
    return JPEG_BUFF_TOO_SMALL;
  }

  TRC1("  emit marker ",JM_RST0 + next_restart_num);
  TRC1("    RST ",0xfff0 | (JM_RST0 + next_restart_num));

  // emit restart interval
  m_dst._WRITE_BYTE(0xff);
  m_dst._WRITE_BYTE(0xff00 | (JM_RST0 + next_restart_num));

  // Update next-restart state
  m_next_restart_num = (next_restart_num + 1) & 7;

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


JERRCODE CJPEGEncoder::ProcessRestart(
  int    id[MAX_COMPS_PER_SCAN],
  int    Ss,
  int    Se,
  int    Ah,
  int    Al)
{
  JERRCODE  jerr;
  IppStatus status = ippStsNoErr;

  TRC0("-> ProcessRestart");

  // flush IppiEncodeHuffmanState
  switch(m_jpeg_mode)
  {
  case JPEG_BASELINE:
    status = ippiEncodeHuffman8x8_JPEG_16s1u_C1(
               0,m_dst.pData,m_dst.DataLen,&m_dst.currPos,0,0,0,m_state,1);
    break;

  case JPEG_PROGRESSIVE:
    if(Ss == 0 && Se == 0)
    {
      // DC scan
      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);
      }
      else
      {
        status = ippiEncodeHuffman8x8_DCRefine_JPEG_16s1u_C1(
                   0,m_dst.pData,m_dst.DataLen,&m_dst.currPos,0,m_state,1);
      }
    }
    else
    {
      // AC scan
      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);
      }
      else
      {
        status = ippiEncodeHuffman8x8_ACRefine_JPEG_16s1u_C1(
                   0,m_dst.pData,m_dst.DataLen,&m_dst.currPos,Ss,Se,Al,actbl,m_state,1);
      }
    }
    break;

  case JPEG_LOSSLESS:
    status = ippiEncodeHuffmanOne_JPEG_16s1u_C1(
               0,m_dst.pData,m_dst.DataLen,&m_dst.currPos,0,m_state,1);
    break;
  }

  if(ippStsNoErr > status)
  {
    LOG1("IPP Error: ippiEncodeHuffman8x8_JPEG_16s1u_C1() failed - ",status);
    return JPEG_INTERNAL_ERROR;
  }

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

  jerr = WriteRST(m_next_restart_num);
  if(JPEG_OK != jerr)
  {
    LOG1("IPP Error: WriteRST() failed - ",jerr);
    return JPEG_INTERNAL_ERROR;
  }

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

  m_restarts_to_go = m_jpeg_restart_interval;

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


JERRCODE CJPEGEncoder::ProcessRestart(
  int    stat[2][256],
  int    id[MAX_COMPS_PER_SCAN],
  int    Ss,
  int    Se,
  int    Ah,
  int    Al)
{
  IppStatus status;

  TRC0("-> ProcessRestart");

  // flush IppiEncodeHuffmanState
  if(JPEG_PROGRESSIVE == m_jpeg_mode)
  {
    if(Ss == 0 && Se == 0)
    {
      // DC scan
      // nothing to do
    }
    else
    {
      // AC scan

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

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

        if(ippStsNoErr > status)
        {
          LOG1("IPP Error: ippiGetHuffmanStatistics8x8_ACRefine_JPEG_16s_C1() failed - ",status);
          return JPEG_INTERNAL_ERROR;
        }
      }
    }
  }

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

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

  m_restarts_to_go = m_jpeg_restart_interval;

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


JERRCODE CJPEGEncoder::WriteSOS(void)
{
  int len;

  TRC0("-> WriteSOS");

  len = 3 + m_jpeg_ncomp*2 + 3;

  if(m_dst.currPos + len >= m_dst.DataLen)
  {
    LOG0("Error: buffer too small");
    return JPEG_BUFF_TOO_SMALL;
  }

  TRC1("  emit marker ",JM_SOS);
  TRC1("    length ",len);

  m_dst._WRITE_WORD(0xff00 | JM_SOS);
  m_dst._WRITE_WORD(len);

  m_dst._WRITE_BYTE(m_jpeg_ncomp);

  TRC1("  ncomp ",m_jpeg_ncomp);

  for(int i = 0; i < m_jpeg_ncomp; i++)
  {
    m_dst._WRITE_BYTE(i);
    m_dst._WRITE_BYTE((m_ccomp[i]->m_dc_selector << 4) | m_ccomp[i]->m_ac_selector);

    TRC1("    id ",i);
    TRC1("      dc_selector ",m_ccomp[i]->m_dc_selector);
    TRC1("      ac_selector ",m_ccomp[i]->m_ac_selector);
  }

  m_dst._WRITE_BYTE(m_ss); // Ss
  m_dst._WRITE_BYTE(m_se); // Se
  m_dst._WRITE_BYTE(((m_ah << 4) | m_al));  // Ah/Al

  TRC1("  Ss ",m_ss);
  TRC1("  Se ",m_se);
  TRC1("  Ah ",m_ah);
  TRC1("  Al ",m_al);

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


JERRCODE CJPEGEncoder::WriteSOS(
  int    ncomp,
  int    id[MAX_COMPS_PER_SCAN],
  int    Ss,
  int    Se,
  int    Ah,
  int    Al)
{
  int len;

  TRC0("-> WriteSOS");

  len = 3 + ncomp*2 + 3;

  if(m_dst.currPos + len >= m_dst.DataLen)
  {
    LOG0("Error: buffer too small");
    return JPEG_BUFF_TOO_SMALL;
  }

  TRC1("  emit marker ",JM_SOS);
  TRC1("    length ",len);

  m_dst._WRITE_WORD(0xff00 | JM_SOS);
  m_dst._WRITE_WORD(len);

  m_dst._WRITE_BYTE(ncomp);

  TRC1("  ncomp ",ncomp);

  for(int i = 0; i < ncomp; i++)
  {
    m_dst._WRITE_BYTE(id[i]);
    m_dst._WRITE_BYTE((m_ccomp[id[i]]->m_dc_selector << 4) | m_ccomp[id[i]]->m_ac_selector);

    TRC1("    id ",id[i]);
    TRC1("    dc_selector ",m_ccomp[id[i]]->m_dc_selector);
    TRC1("    ac_selector ",m_ccomp[id[i]]->m_ac_selector);
  }

  m_dst._WRITE_BYTE(Ss);       // Ss
  m_dst._WRITE_BYTE(Se);       // Se
  m_dst._WRITE_BYTE(((Ah & 0x0f) << 4) | (Al & 0x0f));  // Ah/Al

  TRC1("  Ss ",Ss);
  TRC1("  Se ",Se);
  TRC1("  Ah ",Ah);
  TRC1("  Al ",Al);

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


JERRCODE CJPEGEncoder::SelectScanScripts(void)
{
  if(0 != m_scan_script)
  {
    delete[] m_scan_script;
    m_scan_script = 0;
  }

  switch(m_jpeg_ncomp)
  {
  case 1:
    m_scan_count = 6;
    m_scan_script = new JPEG_SCAN [m_scan_count];

    // 1 DC scan, def
    m_scan_script[0].ncomp = 1;
    m_scan_script[0].id[0] = 0;
    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(luma)
    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(luma)
    m_scan_script[2].ncomp = 1;
    m_scan_script[2].id[0] = 0;
    m_scan_script[2].Ss    = 6;
    m_scan_script[2].Se    = 63;
    m_scan_script[2].Ah    = 0;
    m_scan_script[2].Al    = 2;
    // 4 AC scan, ref(luma)
    m_scan_script[3].ncomp = 1;
    m_scan_script[3].id[0] = 0;
    m_scan_script[3].Ss    = 1;
    m_scan_script[3].Se    = 63;
    m_scan_script[3].Ah    = 2;
    m_scan_script[3].Al    = 1;
    // 5 DC scan, ref
    m_scan_script[4].ncomp = 1;
    m_scan_script[4].id[0] = 0;
    m_scan_script[4].Ss    = 0;
    m_scan_script[4].Se    = 0;
    m_scan_script[4].Ah    = 1;
    m_scan_script[4].Al    = 0;
    // 6 AC scan, ref(luma)
    m_scan_script[5].ncomp = 1;
    m_scan_script[5].id[0] = 0;
    m_scan_script[5].Ss    = 1;
    m_scan_script[5].Se    = 63;
    m_scan_script[5].Ah    = 1;
    m_scan_script[5].Al    = 0;
    break;

  case 3:
    m_scan_count = 10;
    m_scan_script = new JPEG_SCAN [m_scan_count];

    // 1 DC scan, def
    m_scan_script[0].ncomp = 3;
    m_scan_script[0].id[0] = 0;
    m_scan_script[0].id[1] = 1;
    m_scan_script[0].id[2] = 2;
    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(luma)
    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(cr)
    m_scan_script[2].ncomp = 1;
    m_scan_script[2].id[0] = 2;
    m_scan_script[2].Ss    = 1;
    m_scan_script[2].Se    = 63;
    m_scan_script[2].Ah    = 0;
    m_scan_script[2].Al    = 1;
    // 4 AC scan, def(cb)
    m_scan_script[3].ncomp = 1;
    m_scan_script[3].id[0] = 1;
    m_scan_script[3].Ss    = 1;
    m_scan_script[3].Se    = 63;
    m_scan_script[3].Ah    = 0;
    m_scan_script[3].Al    = 1;
    // 5 AC scan, def(luma)
    m_scan_script[4].ncomp = 1;
    m_scan_script[4].id[0] = 0;
    m_scan_script[4].Ss    = 6;
    m_scan_script[4].Se    = 63;
    m_scan_script[4].Ah    = 0;
    m_scan_script[4].Al    = 2;
    // 7 AC scan, ref(luma)
    m_scan_script[5].ncomp = 1;
    m_scan_script[5].id[0] = 0;
    m_scan_script[5].Ss    = 1;
    m_scan_script[5].Se    = 63;
    m_scan_script[5].Ah    = 2;
    m_scan_script[5].Al    = 1;
    // 6 DC scan, ref
    m_scan_script[6].ncomp = 3;
    m_scan_script[6].id[0] = 0;
    m_scan_script[6].id[1] = 1;
    m_scan_script[6].id[2] = 2;
    m_scan_script[6].Ss    = 0;
    m_scan_script[6].Se    = 0;
    m_scan_script[6].Ah    = 1;
    m_scan_script[6].Al    = 0;
    // 8 AC scan, ref(cr)
    m_scan_script[7].ncomp = 1;
    m_scan_script[7].id[0] = 2;
    m_scan_script[7].Ss    = 1;
    m_scan_script[7].Se    = 63;
    m_scan_script[7].Ah    = 1;
    m_scan_script[7].Al    = 0;
    // 9 AC scan, ref(cb)
    m_scan_script[8].ncomp = 1;
    m_scan_script[8].id[0] = 1;
    m_scan_script[8].Ss    = 1;
    m_scan_script[8].Se    = 63;
    m_scan_script[8].Ah    = 1;
    m_scan_script[8].Al    = 0;
    // 10 AC scan, ref(luma)
    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    = 1;
    m_scan_script[9].Al    = 0;
    break;

  case 4:
    m_scan_count = 18;
    m_scan_script = new JPEG_SCAN [m_scan_count];

    // 1 DC scan, def
    m_scan_script[0].ncomp = 4;
    m_scan_script[0].id[0] = 0;
    m_scan_script[0].id[1] = 1;