jpegdec.cpp

audio-video-codecs.rar语音编解码器

  TRC0("-> RST");

  if(m_marker == 0xff)
  {
    jerr = m_BitStreamIn.Seek(-1);
    if(JPEG_OK != jerr)
      return jerr;

    m_marker = JM_NONE;
  }

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

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

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

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


JERRCODE CJPEGDecoder::ParseSOS(JOPERATION op)
{
  int i;
  int ci;
  int len;
  JERRCODE jerr;

  TRC0("-> SOS");

  jerr = m_BitStreamIn.ReadWord(&len);
  if(JPEG_OK != jerr)
    return jerr;

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

  len -= 2;

  jerr = m_BitStreamIn.ReadByte(&m_scan_ncomps);
  if(JPEG_OK != jerr)
    return jerr;

  if(m_scan_ncomps < 1 || m_scan_ncomps > MAX_COMPS_PER_SCAN)
  {
    return JPEG_ERR_SOS_DATA;
  }

  if(JPEG_PROGRESSIVE != m_jpeg_mode && m_scan_ncomps < m_jpeg_ncomp && m_scan_ncomps != 1)
  {
    // TODO:
    // does not support baseline multi-scan images with more than 1 component per scan for now..
    return JPEG_NOT_IMPLEMENTED;
  }

  if(len != ((m_scan_ncomps * 2) + 4))
  {
    return JPEG_ERR_SOS_DATA;
  }

  TRC1("  ncomps - ",m_scan_ncomps);

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

    jerr = m_BitStreamIn.ReadByte(&id);
    if(JPEG_OK != jerr)
      return jerr;

    jerr = m_BitStreamIn.ReadByte(&huff_sel);
    if(JPEG_OK != jerr)
      return jerr;

    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;
        m_ccomp[ci].m_comp_no = ci;
        goto comp_id_match;
      }
    }

    return JPEG_ERR_SOS_DATA;

comp_id_match:

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

  jerr = m_BitStreamIn.ReadByte(&m_ss);
  if(JPEG_OK != jerr)
    return jerr;

  jerr = m_BitStreamIn.ReadByte(&m_se);
  if(JPEG_OK != jerr)
    return jerr;

  int t;

  jerr = m_BitStreamIn.ReadByte(&t);
  if(JPEG_OK != jerr)
    return jerr;

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

  if(JO_READ_HEADER == op)
  {
    // 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 = (m_jpeg_mode != JPEG_LOSSLESS && m_jpeg_precision == 8) ? JC_YCBCR : JC_UNKNOWN; 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;
#ifdef __TIMING__
  Ipp64u   c0;
  Ipp64u   c1;
#endif
  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:
      jerr = ParseSOF0();
      if(JPEG_OK != jerr)
      {
        return jerr;
      }
      break;

    case JM_SOF1:
      jerr = ParseSOF1();
      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(op);
      if(JPEG_OK != jerr)
      {
        return jerr;
      }

      if(JO_READ_HEADER == op)
      {
        jerr = m_BitStreamIn.Seek(-(m_sos_len + 2));
        if(JPEG_OK != jerr)
          return jerr;

        // 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:
        case JPEG_EXTENDED:
          if(m_scan_ncomps == m_jpeg_ncomp)
          {
            if(JD_PLANE == m_dst.order && JS_411 == m_dst.sampling && m_jpeg_precision == 8)
              jerr = DecodeScanBaselineIN_P();
            else
              jerr = DecodeScanBaselineIN();

            if(JPEG_OK != jerr)
              return jerr;
          }
          else
          {
            jerr = DecodeScanBaselineNI();
            if(JPEG_OK != jerr)
              return jerr;

            if(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);
#ifdef __TIMING__
                c0 = ippGetCpuClocks();
#endif
                jerr = ReconstructMCURowBL8x8(pMCUBuf);
                if(JPEG_OK != jerr)
                  return jerr;
#ifdef __TIMING__
                c1 = ippGetCpuClocks();
                m_clk_dct += c1 - c0;
#endif

#ifdef __TIMING__
                c0 = ippGetCpuClocks();
#endif
                jerr = UpSampling(i);
                if(JPEG_OK != jerr)
                  return jerr;
#ifdef __TIMING__
                c1 = ippGetCpuClocks();
                m_clk_ss += c1 - c0;
#endif

#ifdef __TIMING__
                c0 = ippGetCpuClocks();
#endif
                jerr = ColorConvert(i);
                if(JPEG_OK != jerr)
                  return jerr;
#ifdef __TIMING__
                c1 = ippGetCpuClocks();
                m_clk_cc += c1 - c0;
#endif
              }
            }
          }
          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);

#ifdef __TIMING__
                c0 = ippGetCpuClocks();
#endif
                jerr = ReconstructMCURowBL8x8(pMCUBuf);
                if(JPEG_OK != jerr)
                  return jerr;
#ifdef __TIMING__
                c1 = ippGetCpuClocks();
                m_clk_dct += c1 - c0;
#endif
                if(JD_PIXEL == m_dst.order) // pixel by pixel order
                {
#ifdef __TIMING__
                  c0 = ippGetCpuClocks();
#endif
                  jerr = UpSampling(i);
                  if(JPEG_OK != jerr)
                    return jerr;
#ifdef __TIMING__
                  c1 = ippGetCpuClocks();
                  m_clk_ss += c1 - c0;
#endif

#ifdef __TIMING__
                  c0 = ippGetCpuClocks();
#endif
                 jerr = ColorConvert(i);
                  if(JPEG_OK != jerr)
                    return jerr;
#ifdef __TIMING__
                  c1 = ippGetCpuClocks();
                  m_clk_cc += c1 - c0;
#endif
                }
                else          // plane order
                {
                  if(m_jpeg_precision == 8)
                  {
                    jerr = ProcessBuffer(i);
                    if(JPEG_OK != jerr)
                      return jerr;
                  }
                  else
                    return JPEG_NOT_IMPLEMENTED; //not support 16-bit PLANE image
                }
              }
            }
          }
          break;

        case JPEG_LOSSLESS:
          if(m_scan_ncomps == m_jpeg_ncomp)
          {
            jerr = DecodeScanLosslessIN();
            if(JPEG_OK != jerr)
              return jerr;
          }
          else
          {
            jerr = DecodeScanLosslessNI();
            if(JPEG_OK != jerr)
              return jerr;

            if(m_ac_scans_completed == m_jpeg_ncomp)
            {
              Ipp16s* pMCUBuf = m_block_buffer;

              for(i = 0; i < m_numyMCU; i++)
              {
                if(m_jpeg_restart_interval && i*m_numxMCU % m_jpeg_restart_interval == 0)
                  m_rst_go = 1;

#ifdef __TIMING__
                c0 = ippGetCpuClocks();
#endif
                jerr = ReconstructMCURowLS(pMCUBuf, i);
                if(JPEG_OK != jerr)
                  return jerr;
#ifdef __TIMING__
                c1 = ippGetCpuClocks();
                m_clk_diff += c1 - c0;
#endif

#ifdef __TIMING__
                c0 = ippGetCpuClocks();
#endif
                jerr = ColorConvert(i);
                if(JPEG_OK != jerr)
                  return jerr;
#ifdef __TIMING__
                c1 = ippGetCpuClocks();
                m_clk_cc += c1 - c0;
#endif

                m_rst_go = 0;
              } // for m_numyMCU
            }
          }
          break;

        default:
    jerr = JPEG_ERR_INTERNAL;
    break;

        } // m_jpeg_mode

        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;