decoder.cpp

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

    if(m_max_vsampling < m_ccomp[i].m_vsampling)
      m_max_vsampling = m_ccomp[i].m_vsampling;
  }

  for(i = 0; i < m_jpeg_ncomp; i++)
  {
    m_ccomp[i].m_h_factor = m_max_hsampling / m_ccomp[i].m_hsampling;
    m_ccomp[i].m_v_factor = m_max_vsampling / m_ccomp[i].m_vsampling;
  }

  m_jpeg_mode = JPEG_LOSSLESS;

  m_marker = JM_NONE;

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


JERRCODE CJPEGDecoder::ParseDRI(void)
{
  int len;

  TRC0("-> DRI");

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

  m_src._READ_WORD(&len);
  len -= 2;

  if(len != 2)
  {
    return JPEG_BAD_SEGMENT_LENGTH;
  }

  m_src._READ_WORD(&m_jpeg_restart_interval);

  TRC1("  restart interval - ",m_jpeg_restart_interval);

  m_restarts_to_go = m_jpeg_restart_interval;

  m_marker = JM_NONE;

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


JERRCODE CJPEGDecoder::ParseRST(void)
{
  JERRCODE jerr;

  TRC0("-> RST");

  if(m_marker == 0xff)
  {
    m_src.currPos--;
    m_marker = JM_NONE;
  }

  if(m_marker == JM_NONE)
  {
    jerr = NextMarker(&m_marker);
    if(JPEG_OK != jerr)
    {
      LOG0("Error: NextMarker() failed");
      return JPEG_INTERNAL_ERROR;
    }
  }

  TRC1("restart interval ",m_next_restart_num);
  if(m_marker == ((int)JM_RST0 + m_next_restart_num))
  {
    m_marker = JM_NONE;
  }
  else
  {
    LOG1("  - got marker   - ",m_marker);
    LOG1("  - but expected - ",(int)JM_RST0 + m_next_restart_num);
    m_marker = JM_NONE;
//    return JPEG_BAD_RESTART;
  }

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

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


JERRCODE CJPEGDecoder::ParseSOS(void)
{
  int i;
  int ci;
  int len;

  TRC0("-> SOS");

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

  m_src._READ_WORD(&len);

  // store position to return to in subsequent ReadData call
  m_sos_len = len;

  len -= 2;

  int ncomps;

  m_src._READ_BYTE(&ncomps);

  if(ncomps < 1 || ncomps > MAX_COMPS_PER_SCAN)
  {
    return JPEG_BAD_SCAN_SEGMENT;
  }

  if(JPEG_PROGRESSIVE != m_jpeg_mode && ncomps < m_jpeg_ncomp)
  {
    // does not support scan-interleaved images for now..
    return JPEG_NOT_IMPLEMENTED;
  }

  if(len != ((ncomps * 2) + 4))
  {
    return JPEG_BAD_SEGMENT_LENGTH;
  }

  TRC1("  ncomps - ",ncomps);

  for(i = 0; i < ncomps; i++)
  {
    int id;
    int huff_sel;

    m_src._READ_BYTE(&id);
    m_src._READ_BYTE(&huff_sel);

    TRC1("    id - ",id);
    TRC1("      dc_selector - ",(huff_sel >> 4) & 0x0f);
    TRC1("      ac_selector - ",(huff_sel     ) & 0x0f);

    m_ccomp[i].m_lastDC = 0;

    for(ci = 0; ci < m_jpeg_ncomp; ci++)
    {
      if(id == m_ccomp[ci].m_id)
      {
        m_curr_comp_no = ci;
        goto comp_id_match;
      }
    }

    return JPEG_BAD_COMPONENT_ID;

comp_id_match:

    m_ccomp[ci].m_dc_selector = (huff_sel >> 4) & 0x0f;
    m_ccomp[ci].m_ac_selector = (huff_sel     ) & 0x0f;
  }

  m_src._READ_BYTE(&m_ss);
  m_src._READ_BYTE(&m_se);

  int t;

  m_src._READ_BYTE(&t);

  m_ah = (t >> 4) & 0x0f;
  m_al = (t     ) & 0x0f;

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

  // detect JPEG color space
  if(m_jfif_app0_detected)
  {
    switch(m_jpeg_ncomp)
    {
    case 1:  m_jpeg_color = JC_GRAY;    break;
    case 3:  m_jpeg_color = JC_YCBCR;   break;
    default: m_jpeg_color = JC_UNKNOWN; break;
    }
  }

  if(m_adobe_app14_detected)
  {
    switch(m_adobe_app14_transform)
    {
    case 0:
      switch(m_jpeg_ncomp)
      {
      case 1:  m_jpeg_color = JC_GRAY;    break;
      case 3:  m_jpeg_color = JC_RGB;     break;
      case 4:  m_jpeg_color = JC_CMYK;    break;
      default: m_jpeg_color = JC_UNKNOWN; break;
      }
      break;

    case 1:  m_jpeg_color = JC_YCBCR;   break;
    case 2:  m_jpeg_color = JC_YCCK;    break;
    default: m_jpeg_color = JC_UNKNOWN; break;
    }
  }

  // try to guess what color space is used...
  if(!m_jfif_app0_detected && !m_adobe_app14_detected)
  {
    switch(m_jpeg_ncomp)
    {
    case 1:  m_jpeg_color = JC_GRAY;    break;
    case 3:  m_jpeg_color = JC_YCBCR;   break;
    default: m_jpeg_color = JC_UNKNOWN; break;
    }
  }

  m_restarts_to_go   = m_jpeg_restart_interval;
  m_next_restart_num = 0;

  m_marker = JM_NONE;

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


JERRCODE CJPEGDecoder::ParseJPEGBitStream(JOPERATION op)
{
  int      i;
  JERRCODE jerr = JPEG_OK;

  m_marker = JM_NONE;

  for(;;)
  {
    if(JM_NONE == m_marker)
    {
      jerr = NextMarker(&m_marker);
      if(JPEG_OK != jerr)
      {
        return jerr;
      }
    }

    switch(m_marker)
    {
    case JM_SOI:
      jerr = ParseSOI();
      if(JPEG_OK != jerr)
      {
        return jerr;
      }
      break;

    case JM_APP0:
      jerr = ParseAPP0();
      if(JPEG_OK != jerr)
      {
        return jerr;
      }
      break;

    case JM_APP1:
      jerr = ParseAPP1();
      if(JPEG_OK != jerr)
      {
        return jerr;
      }
      break;

    case JM_APP14:
      jerr = ParseAPP14();
      if(JPEG_OK != jerr)
      {
        return jerr;
      }
      break;

    case JM_COM:
      jerr = ParseCOM();
      if(JPEG_OK != jerr)
      {
        return jerr;
      }
      break;

    case JM_DQT:
      jerr = ParseDQT();
      if(JPEG_OK != jerr)
      {
        return jerr;
      }
      break;

    case JM_SOF0:
    case JM_SOF1:
      jerr = ParseSOF0();
      if(JPEG_OK != jerr)
      {
        return jerr;
      }
      break;

    case JM_SOF2:
      jerr = ParseSOF2();
      if(JPEG_OK != jerr)
      {
        return jerr;
      }
      break;

    case JM_SOF3:
      jerr = ParseSOF3();
      if(JPEG_OK != jerr)
      {
        return jerr;
      }
      break;

    case JM_SOF5:
    case JM_SOF6:
    case JM_SOF7:
    case JM_SOF9:
    case JM_SOFA:
    case JM_SOFB:
    case JM_SOFD:
    case JM_SOFE:
    case JM_SOFF:
      return JPEG_NOT_IMPLEMENTED;

    case JM_DHT:
      jerr = ParseDHT();
      if(JPEG_OK != jerr)
      {
        return jerr;
      }
      break;

    case JM_DRI:
      jerr = ParseDRI();
      if(JPEG_OK != jerr)
      {
        return jerr;
      }
      break;

    case JM_SOS:
      jerr = ParseSOS();
      if(JPEG_OK != jerr)
      {
        return jerr;
      }

      if(JO_READ_HEADER == op)
      {
        m_src.currPos -= m_sos_len + 2;
        // stop here, when we are reading header
        return JPEG_OK;
      }

      if(JO_READ_DATA == op)
      {
        jerr = Init();
        if(JPEG_OK != jerr)
        {
          return jerr;
        }

        switch(m_jpeg_mode)
        {
        case JPEG_BASELINE:
          jerr = DecodeScanBaseline();
          break;

        case JPEG_PROGRESSIVE:
          {
            jerr = DecodeScanProgressive();

            m_ac_scans_completed = 0;
            for(i = 0; i < m_jpeg_ncomp; i++)
            {
              m_ac_scans_completed += m_ccomp[i].m_ac_scan_completed;
            }

            if(JPEG_OK != jerr ||
              (m_dc_scan_completed != 0 && m_ac_scans_completed == m_jpeg_ncomp))
            {
              Ipp16s* pMCUBuf;
              for(i = 0; i < m_numyMCU; i++)
              {
                pMCUBuf = m_block_buffer + (i* m_numxMCU * DCTSIZE2* m_nblock);
//                DCTQntSSCCMCURow(pMCUBuf,0,i);
                ReconstructMCURowBL(pMCUBuf,i,0);
                UpSampling(i,0);
                ColorConvert(i,0);
              }
            }

            break;
          }

        case JPEG_LOSSLESS:
          jerr = DecodeScanLossless();
          break;
        }

        if(JPEG_OK != jerr)
          return jerr;
      }

      break;

    case JM_RST0:
    case JM_RST1:
    case JM_RST2:
    case JM_RST3:
    case JM_RST4:
    case JM_RST5:
    case JM_RST6:
    case JM_RST7:
      jerr = ParseRST();
      if(JPEG_OK != jerr)
      {
        return jerr;
      }
      break;

    case JM_EOI:
      jerr = ParseEOI();
      goto Exit;

    default:
      TRC1("-> Unknown marker ",m_marker);
      TRC0("..Skipping");
      jerr = SkipMarker();
      if(JPEG_OK != jerr)
        return jerr;

      break;
    }
  }

Exit:

  return jerr;
} // CJPEGDecoder::ParseJPEGBitStream()


JERRCODE CJPEGDecoder::Init(void)
{
  int i;
  int sz;
  int num_threads = 1;
  int ss_buf_size = 0;
  int cc_buf_size = 0;

  m_nblock    = 1;
  num_threads = get_num_threads();

  m_num_threads = num_threads;

  // not implemented yet
  if(m_jpeg_sampling == JS_OTHER)
  {
    return JPEG_NOT_IMPLEMENTED;
  }

  // TODO: need to modify it for multi-scan baseline images and
  //       for images with more then 4 components
  for(m_nblock = 0, i = 0; i < m_jpeg_ncomp; i++)
  {
    m_nblock += (m_ccomp[i].m_hsampling * m_ccomp[i].m_vsampling);
  }

  for(i = 0; i < m_jpeg_ncomp; i++)
  {
    switch(m_jpeg_mode)
    {
    case JPEG_BASELINE:
      {
        switch(m_jpeg_sampling)
        {
        case JS_444:
          {
            ss_buf_size = 0;
            break;
          }

        case JS_422:
          {
            if(i == 0 || i == 3)
              ss_buf_size = 0;
            else
              ss_buf_size = m_numxMCU * (m_mcuWidth>>1) * m_mcuHeight * num_threads;
            break;
          }

        case JS_244:
          {
            if(i == 0 || i == 3)
              ss_buf_size = 0;
            else
              ss_buf_size = m_numxMCU * m_mcuWidth * ((m_mcuHeight>>1)+2) * num_threads;
            break;
          }

        case JS_411:
          {
            if(i == 0 || i == 3)
              ss_buf_size = 0;
            else
              ss_buf_size = m_numxMCU * (m_mcuWidth>>1) * ((m_mcuHeight>>1)+2) * num_threads;
            break;
          }
        }

        cc_buf_size = m_numxMCU * m_mcuWidth * m_mcuHeight * num_threads;

        if(0 == m_block_buffer)
        {
          sz = DCTSIZE2 * m_nblock * m_numxMCU * num_threads * 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_BASELINE

      case JPEG_PROGRESSIVE:
      {
        switch(m_jpeg_sampling)
        {
        case JS_444:
          {
            ss_buf_size = 0;
            break;
          }

        case JS_422:
          {
            if(i == 0 || i == 3)
              ss_buf_size = 0;
            else
              ss_buf_size = m_numxMCU * (m_mcuWidth>>1) * m_mcuHeight * num_threads;
            break;
          }

        case JS_244:
          {
            if(i == 0 || i == 3)
              ss_buf_size = 0;
            else
              ss_buf_size = m_numxMCU * m_mcuWidth * ((m_mcuHeight>>1)+2) * num_threads;
            break;
          }

        case JS_411:
          {
            if(i == 0 || i == 3)
              ss_buf_size = 0;
            else
              ss_buf_size = m_numxMCU * (m_mcuWidth>>1) * ((m_mcuHeight>>1)+2) * num_threads;
            break;
          }
        }

        cc_buf_size = m_numxMCU * m_mcuWidth * m_mcuHeight * num_threads;

        if(0 == m_block_buffer)
        {
          sz = m_numxMCU * m_numyMCU * DCTSIZE2 * m_nblock * num_threads * 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);
        }