jpegenc.cpp

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

  jerr = m_BitStreamOut.WriteWord(m_src.width);
  if(JPEG_OK != jerr)
    return jerr;

  jerr = m_BitStreamOut.WriteByte(m_jpeg_ncomp);
  if(JPEG_OK != jerr)
    return jerr;

  for(int i = 0; i < m_jpeg_ncomp; i++)
  {
    jerr = m_BitStreamOut.WriteByte(i);
    if(JPEG_OK != jerr)
      return jerr;

    jerr = m_BitStreamOut.WriteByte((m_ccomp[i].m_hsampling << 4) | m_ccomp[i].m_vsampling);
    if(JPEG_OK != jerr)
      return jerr;

    jerr = m_BitStreamOut.WriteByte(m_ccomp[i].m_q_selector);
    if(JPEG_OK != jerr)
      return jerr;
  }

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


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

  TRC0("-> WriteSOF2");

  len = 8 + m_jpeg_ncomp * 3;

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

  jerr = m_BitStreamOut.WriteWord(0xff00 | JM_SOF2);
  if(JPEG_OK != jerr)
    return jerr;

  jerr = m_BitStreamOut.WriteWord(len);
  if(JPEG_OK != jerr)
    return jerr;

  // sample precision
  jerr = m_BitStreamOut.WriteByte(8);
  if(JPEG_OK != jerr)
    return jerr;

  jerr = m_BitStreamOut.WriteWord(m_src.height);
  if(JPEG_OK != jerr)
    return jerr;

  jerr = m_BitStreamOut.WriteWord(m_src.width);
  if(JPEG_OK != jerr)
    return jerr;

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

  jerr = m_BitStreamOut.WriteByte(m_jpeg_ncomp);
  if(JPEG_OK != jerr)
    return jerr;

  for(int i = 0; i < m_jpeg_ncomp; i++)
  {
    jerr = m_BitStreamOut.WriteByte(i);
    if(JPEG_OK != jerr)
      return jerr;

    jerr = m_BitStreamOut.WriteByte((m_ccomp[i].m_hsampling << 4) | m_ccomp[i].m_vsampling);
    if(JPEG_OK != jerr)
      return jerr;

    jerr = m_BitStreamOut.WriteByte(m_ccomp[i].m_q_selector);
    if(JPEG_OK != jerr)
      return jerr;

    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;
  JERRCODE jerr;

  TRC0("-> WriteSOF3");

  len = 8 + m_jpeg_ncomp * 3;

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

  jerr = m_BitStreamOut.WriteWord(0xff00 | JM_SOF3);
  if(JPEG_OK != jerr)
    return jerr;

  jerr = m_BitStreamOut.WriteWord(len);
  if(JPEG_OK != jerr)
    return jerr;

  // sample precision
  jerr = m_BitStreamOut.WriteByte(m_jpeg_precision);
  if(JPEG_OK != jerr)
    return jerr;

  jerr = m_BitStreamOut.WriteWord(m_src.height);
  if(JPEG_OK != jerr)
    return jerr;

  jerr = m_BitStreamOut.WriteWord(m_src.width);
  if(JPEG_OK != jerr)
    return jerr;

  jerr = m_BitStreamOut.WriteByte(m_jpeg_ncomp);
  if(JPEG_OK != jerr)
    return jerr;

  for(int i = 0; i < m_jpeg_ncomp; i++)
  {
    jerr = m_BitStreamOut.WriteByte(i);
    if(JPEG_OK != jerr)
      return jerr;

    jerr = m_BitStreamOut.WriteByte((m_ccomp[i].m_hsampling << 4) | m_ccomp[i].m_vsampling);
    if(JPEG_OK != jerr)
      return jerr;

    jerr = m_BitStreamOut.WriteByte(m_ccomp[i].m_q_selector);
    if(JPEG_OK != jerr)
      return jerr;
  }

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


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

  TRC0("-> WriteDRI");

  len = 2 + 2;

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

  jerr = m_BitStreamOut.WriteWord(0xff00 | JM_DRI);
  if(JPEG_OK != jerr)
    return jerr;

  jerr = m_BitStreamOut.WriteWord(len);
  if(JPEG_OK != jerr)
    return jerr;

  // emit restart interval
  jerr = m_BitStreamOut.WriteWord(restart_interval);
  if(JPEG_OK != jerr)
    return jerr;

  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;
  JERRCODE jerr;

  TRC0("-> WriteRST");

  len = 2;

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

  // emit restart interval
  jerr = m_BitStreamOut.WriteWord(0xff00 | (JM_RST0 + next_restart_num));
  if(JPEG_OK != jerr)
    return jerr;

  // 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)
{
  int       dstLen;
  int       currPos;
  Ipp8u*    dst;
  JERRCODE  jerr;
  IppStatus status = ippStsNoErr;

  TRC0("-> ProcessRestart");

  dst    = m_BitStreamOut.GetDataPtr();
  dstLen = m_BitStreamOut.GetDataLen();

  jerr = m_BitStreamOut.FlushBuffer(/*SAFE_NBYTES*/4096);
  if(JPEG_OK != jerr)
    return jerr;

  currPos = m_BitStreamOut.GetCurrPos();

  // flush IppiEncodeHuffmanState
  switch(m_jpeg_mode)
  {
  case JPEG_BASELINE:
  case JPEG_EXTENDED:
    {
      status = ippiEncodeHuffman8x8_JPEG_16s1u_C1(
                 0,dst,dstLen,&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,dst,dstLen,&currPos,0,0,0,m_state,1);
      }
      else
      {
        status = ippiEncodeHuffman8x8_DCRefine_JPEG_16s1u_C1(
                   0,dst,dstLen,&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,dst,dstLen,&currPos,Ss,Se,Al,actbl,m_state,1);
      }
      else
      {
        status = ippiEncodeHuffman8x8_ACRefine_JPEG_16s1u_C1(
                   0,dst,dstLen,&currPos,Ss,Se,Al,actbl,m_state,1);
      }
    }
    break;

  case JPEG_LOSSLESS:
    status = ippiEncodeHuffmanOne_JPEG_16s1u_C1(
               0,dst,dstLen,&currPos,0,m_state,1);
    break;
  }

  m_BitStreamOut.SetCurrPos(currPos);

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

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

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

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

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

  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;
  JERRCODE jerr;

  TRC0("-> WriteSOS");

  len = 3 + m_jpeg_ncomp*2 + 3;

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

  jerr = m_BitStreamOut.WriteWord(0xff00 | JM_SOS);
  if(JPEG_OK != jerr)
    return jerr;

  jerr = m_BitStreamOut.WriteWord(len);
  if(JPEG_OK != jerr)
    return jerr;

  jerr = m_BitStreamOut.WriteByte(m_jpeg_ncomp);
  if(JPEG_OK != jerr)
    return jerr;

  TRC1("  ncomp ",m_jpeg_ncomp);

  for(int i = 0; i < m_jpeg_ncomp; i++)
  {
    jerr = m_BitStreamOut.WriteByte(i);
    if(JPEG_OK != jerr)
      return jerr;

    jerr = m_BitStreamOut.WriteByte((m_ccomp[i].m_dc_selector << 4) | m_ccomp[i].m_ac_selector);
    if(JPEG_OK != jerr)
      return jerr;

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

  jerr = m_BitStreamOut.WriteByte(m_ss); // Ss
  if(JPEG_OK != jerr)
    return jerr;

  jerr = m_BitStreamOut.WriteByte(m_se); // se
  if(JPEG_OK != jerr)
    return jerr;

  jerr = m_BitStreamOut.WriteByte(((m_ah << 4) | m_al));  // Ah/Al
  if(JPEG_OK != jerr)
    return jerr;

  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;
  JERRCODE jerr;

  TRC0("-> WriteSOS");

  len = 3 + ncomp*2 + 3;

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

  jerr = m_BitStreamOut.WriteWord(0xff00 | JM_SOS);
  if(JPEG_OK != jerr)
    return jerr;

  jerr = m_BitStreamOut.WriteWord(len);
  if(JPEG_OK != jerr)
    return jerr;

  jerr = m_BitStreamOut.WriteByte(ncomp);
  if(JPEG_OK != jerr)
    return jerr;

  TRC1("  ncomp ",ncomp);

  for(int i = 0; i < ncomp; i++)
  {
    jerr = m_BitStreamOut.WriteByte(id[i]);
    if(JPEG_OK != jerr)
      return jerr;

    jerr = m_BitStreamOut.WriteByte((m_ccomp[id[i]].m_dc_selector << 4) | m_ccomp[id[i]].m_ac_selector);
    if(JPEG_OK != jerr)
      return jerr;

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

  jerr = m_BitStreamOut.WriteByte(Ss);       // Ss
  if(JPEG_OK != jerr)
    return jerr;

  jerr = m_BitStreamOut.WriteByte(Se);       // Se
  if(JPEG_OK != jerr)
    return jerr;

  jerr = m_BitStreamOut.WriteByte(((Ah & 0x0f) << 4) | (Al & 0x0f));  // Ah/Al
  if(JPEG_OK != jerr)
    return jerr;

  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)