jpegenc.cpp

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

    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;
    m_scan_script[0].id[2] = 2;
    m_scan_script[0].id[3] = 3;
    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(0)
    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(1)
    m_scan_script[2].ncomp = 1;
    m_scan_script[2].id[0] = 1;
    m_scan_script[2].Ss    = 1;
    m_scan_script[2].Se    = 5;
    m_scan_script[2].Ah    = 0;
    m_scan_script[2].Al    = 2;
    // 4 AC scan, def(2)
    m_scan_script[3].ncomp = 1;
    m_scan_script[3].id[0] = 2;
    m_scan_script[3].Ss    = 1;
    m_scan_script[3].Se    = 5;
    m_scan_script[3].Ah    = 0;
    m_scan_script[3].Al    = 2;
    // 5 AC scan, def(3)
    m_scan_script[4].ncomp = 1;
    m_scan_script[4].id[0] = 3;
    m_scan_script[4].Ss    = 1;
    m_scan_script[4].Se    = 5;
    m_scan_script[4].Ah    = 0;
    m_scan_script[4].Al    = 2;
    // 6 AC scan, def(0)
    m_scan_script[5].ncomp = 1;
    m_scan_script[5].id[0] = 0;
    m_scan_script[5].Ss    = 6;
    m_scan_script[5].Se    = 63;
    m_scan_script[5].Ah    = 0;
    m_scan_script[5].Al    = 2;
    // 7 AC scan, def(1)
    m_scan_script[6].ncomp = 1;
    m_scan_script[6].id[0] = 1;
    m_scan_script[6].Ss    = 6;
    m_scan_script[6].Se    = 63;
    m_scan_script[6].Ah    = 0;
    m_scan_script[6].Al    = 2;
    // 8 AC scan, def(2)
    m_scan_script[7].ncomp = 1;
    m_scan_script[7].id[0] = 2;
    m_scan_script[7].Ss    = 6;
    m_scan_script[7].Se    = 63;
    m_scan_script[7].Ah    = 0;
    m_scan_script[7].Al    = 2;
    // 9 AC scan, def(3)
    m_scan_script[8].ncomp = 1;
    m_scan_script[8].id[0] = 3;
    m_scan_script[8].Ss    = 6;
    m_scan_script[8].Se    = 63;
    m_scan_script[8].Ah    = 0;
    m_scan_script[8].Al    = 2;
    // 10 AC scan, ref(0)
    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    = 2;
    m_scan_script[9].Al    = 1;
    // 11 AC scan, ref(1)
    m_scan_script[10].ncomp = 1;
    m_scan_script[10].id[0] = 1;
    m_scan_script[10].Ss    = 1;
    m_scan_script[10].Se    = 63;
    m_scan_script[10].Ah    = 2;
    m_scan_script[10].Al    = 1;
    // 12 AC scan, ref(2)
    m_scan_script[11].ncomp = 1;
    m_scan_script[11].id[0] = 2;
    m_scan_script[11].Ss    = 1;
    m_scan_script[11].Se    = 63;
    m_scan_script[11].Ah    = 2;
    m_scan_script[11].Al    = 1;
    // 13 AC scan, ref(3)
    m_scan_script[12].ncomp = 1;
    m_scan_script[12].id[0] = 3;
    m_scan_script[12].Ss    = 1;
    m_scan_script[12].Se    = 63;
    m_scan_script[12].Ah    = 2;
    m_scan_script[12].Al    = 1;
    // 14 DC scan, ref
    m_scan_script[13].ncomp = 4;
    m_scan_script[13].id[0] = 0;
    m_scan_script[13].id[1] = 1;
    m_scan_script[13].id[2] = 2;
    m_scan_script[13].id[3] = 3;
    m_scan_script[13].Ss    = 0;
    m_scan_script[13].Se    = 0;
    m_scan_script[13].Ah    = 1;
    m_scan_script[13].Al    = 0;
    // 15 AC scan, ref(0)
    m_scan_script[14].ncomp = 1;
    m_scan_script[14].id[0] = 0;
    m_scan_script[14].Ss    = 1;
    m_scan_script[14].Se    = 63;
    m_scan_script[14].Ah    = 1;
    m_scan_script[14].Al    = 0;
    // 16 AC scan, ref(1)
    m_scan_script[15].ncomp = 1;
    m_scan_script[15].id[0] = 1;
    m_scan_script[15].Ss    = 1;
    m_scan_script[15].Se    = 63;
    m_scan_script[15].Ah    = 1;
    m_scan_script[15].Al    = 0;
    // 17 AC scan, ref(2)
    m_scan_script[16].ncomp = 1;
    m_scan_script[16].id[0] = 2;
    m_scan_script[16].Ss    = 1;
    m_scan_script[16].Se    = 63;
    m_scan_script[16].Ah    = 1;
    m_scan_script[16].Al    = 0;
    // 18 AC scan, ref(3)
    m_scan_script[17].ncomp = 1;
    m_scan_script[17].id[0] = 3;
    m_scan_script[17].Ss    = 1;
    m_scan_script[17].Se    = 63;
    m_scan_script[17].Ah    = 1;
    m_scan_script[17].Al    = 0;
    break;

  default:
    return JPEG_NOT_IMPLEMENTED;
  }

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


JERRCODE CJPEGEncoder::Init(void)
{
  int       i;
  int       tr_buf_size = 0;
  CJPEGColorComponent* curr_comp;
  JERRCODE  jerr;

  m_num_threads = get_num_threads();

  m_xPadding = m_numxMCU * m_mcuWidth  - m_src.width;
  m_yPadding = m_numyMCU * m_mcuHeight - m_src.height;

  m_ccWidth  = m_mcuWidth * m_numxMCU;
  m_ccHeight = m_mcuHeight;

  for(m_nblock = 0, i = 0; i < m_jpeg_ncomp; i++)
  {
    curr_comp = &m_ccomp[i];

    curr_comp->m_id          = i;
    curr_comp->m_comp_no     = i;
    curr_comp->m_hsampling   = (m_jpeg_sampling == JS_444) ? 1 : (i == 0 || i == 3 ? 2 : 1);
    curr_comp->m_vsampling   = (m_jpeg_sampling == JS_411) ? (i == 0 || i == 3 ? 2 : 1) : 1;
    curr_comp->m_h_factor    = (m_jpeg_sampling == JS_444) ? 1 : (i == 0 || i == 3 ? 1 : 2);
    curr_comp->m_v_factor    = (m_jpeg_sampling == JS_411) ? (i == 0 || i == 3 ? 1 : 2) : 1;
    curr_comp->m_nblocks     = curr_comp->m_hsampling * curr_comp->m_vsampling;

    m_nblock += curr_comp->m_nblocks;

    switch(m_jpeg_mode)
    {
    case JPEG_BASELINE:
      curr_comp->m_cc_height = m_mcuHeight;
      curr_comp->m_cc_step   = m_numxMCU * m_mcuWidth;
      break;

    case JPEG_EXTENDED:
      curr_comp->m_cc_height = m_mcuHeight;
      curr_comp->m_cc_step   = m_numxMCU * m_mcuWidth * ((m_jpeg_precision <= 8) ? sizeof(Ipp8u) : sizeof(Ipp16s));
      break;

    case JPEG_PROGRESSIVE:
      curr_comp->m_cc_height = m_mcuHeight;
      curr_comp->m_cc_step   = m_numxMCU * m_mcuWidth;
      break;

    case JPEG_LOSSLESS:
      curr_comp->m_cc_height = m_mcuHeight;
      curr_comp->m_cc_step   = m_numxMCU * m_mcuWidth * sizeof(Ipp16s);
      break;

    default:
      return JPEG_ERR_INTERNAL;
    }

    curr_comp->m_ss_height = curr_comp->m_cc_height / curr_comp->m_v_factor;
    curr_comp->m_ss_step   = curr_comp->m_cc_step   / curr_comp->m_h_factor;

    // color convert buffer
    jerr = curr_comp->CreateBufferCC(m_num_threads);
    if(JPEG_OK != jerr)
      return jerr;

    // sub-sampling buffer
    jerr = curr_comp->CreateBufferSS(m_num_threads);
    if(JPEG_OK != jerr)
      return jerr;

    if(JPEG_LOSSLESS == m_jpeg_mode)
    {
      curr_comp->m_row1.Allocate(curr_comp->m_cc_step);
      curr_comp->m_row2.Allocate(curr_comp->m_cc_step);
      curr_comp->m_curr_row = (Ipp16s*)curr_comp->m_row1.m_buffer;
      curr_comp->m_prev_row = (Ipp16s*)curr_comp->m_row2.m_buffer;
    }
  } // for m_jpeg_ncomp

  if(JPEG_PROGRESSIVE == m_jpeg_mode)
  {
    SelectScanScripts();
  }

  switch(m_jpeg_mode)
  {
  case JPEG_BASELINE:
    tr_buf_size = m_numxMCU * m_nblock * DCTSIZE2 * sizeof(Ipp16s) * m_num_threads;
    break;

  case JPEG_EXTENDED:
    if(!m_optimal_htbl)
      tr_buf_size = m_numxMCU * m_nblock * DCTSIZE2 * sizeof(Ipp16s) * m_num_threads;
    else
      tr_buf_size = m_numxMCU * m_numyMCU * m_nblock * DCTSIZE2 * sizeof(Ipp16s) * m_num_threads;
    break;

  case JPEG_PROGRESSIVE:
    tr_buf_size = m_numxMCU * m_numyMCU * m_nblock * DCTSIZE2 * sizeof(Ipp16s) * m_num_threads;
    break;

  case JPEG_LOSSLESS:
  default:
    if(!m_optimal_htbl)
      tr_buf_size = m_numxMCU * m_nblock * sizeof(Ipp16s) * m_num_threads;
    else
      tr_buf_size = m_numxMCU * m_numyMCU * m_nblock * sizeof(Ipp16s) * m_num_threads;
    break;
  }

  // MCUs buffer
  if(0 == m_block_buffer)
  {
    m_block_buffer = (Ipp16s*)ippMalloc(tr_buf_size);
    if(0 == m_block_buffer)
    {
      return JPEG_ERR_ALLOC;
    }

    ippsZero_8u((Ipp8u*)m_block_buffer,tr_buf_size);
  }

  m_state.Create();

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


JERRCODE CJPEGEncoder::ColorConvert(int nMCURow, int thread_id)
{
  int       srcStep;
  int       convert = 0;

  Ipp8u*    pSrc8u = 0;
  Ipp16u*   pSrc16u = 0;
  IppiSize  roi;
  IppStatus status;

  if(nMCURow == m_numyMCU - 1)
  {
    m_ccHeight = m_mcuHeight - m_yPadding;
  }

  roi.width  = m_src.width;
  roi.height = m_ccHeight;

  srcStep = m_src.lineStep[0];

  if(m_src.precision <= 8)
    pSrc8u  =                   m_src.p.Data8u[0]  + nMCURow * m_mcuHeight * srcStep;
  else
    pSrc16u = (Ipp16u*)((Ipp8u*)m_src.p.Data16s[0] + nMCURow * m_mcuHeight * srcStep);

  if(m_jpeg_color == JC_UNKNOWN && m_src.color == JC_UNKNOWN)
  {

    switch(m_jpeg_ncomp)
    {
    case 1:
      {
        int     dstStep;
        Ipp8u*  pDst8u;
        Ipp16u* pDst16u;

        dstStep = m_ccomp[0].m_cc_step;
        convert = 1;

        if(m_src.precision <= 8)
        {
          pDst8u = m_ccomp[0].GetCCBufferPtr(thread_id);

          status = ippiCopy_8u_C1R(pSrc8u,srcStep,pDst8u,dstStep,roi);
        }
        else
        {
          pDst16u = (Ipp16u*)m_ccomp[0].GetCCBufferPtr(thread_id);

          status = ippiCopy_16s_C1R((Ipp16s*)pSrc16u,srcStep,(Ipp16s*)pDst16u,dstStep,roi);
        }

        if(ippStsNoErr != status)
        {
          LOG1("IPP Error: ippiCopy_8u_C1R() failed - ",status);
          return JPEG_ERR_INTERNAL;
        }
      }
      break;

    case 3:
      {
        int     dstStep;
        Ipp8u*  pDst8u[3];
        Ipp16u* pDst16u[3];

        dstStep = m_ccomp[0].m_cc_step;
        convert = 1;

        if(m_src.precision <= 8)
        {
          pDst8u[0] = m_ccomp[0].GetCCBufferPtr(thread_id);
          pDst8u[1] = m_ccomp[1].GetCCBufferPtr(thread_id);
          pDst8u[2] = m_ccomp[2].GetCCBufferPtr(thread_id);

          status = ippiCopy_8u_C3P3R(pSrc8u,srcStep,pDst8u,dstStep,roi);
        }
        else
        {
          pDst16u[0] = (Ipp16u*)m_ccomp[0].GetCCBufferPtr(thread_id);
          pDst16u[1] = (Ipp16u*)m_ccomp[1].GetCCBufferPtr(thread_id);
          pDst16u[2] = (Ipp16u*)m_ccomp[2].GetCCBufferPtr(thread_id);

          status = ippiCopy_16s_C3P3R((Ipp16s*)pSrc16u,srcStep,(Ipp16s**)pDst16u,dstStep,roi);
        }

        if(ippStsNoErr != status)
        {
          LOG1("IPP Error: ippiCopy_8u_C3P3R() failed - ",status);
          return JPEG_ERR_INTERNAL;
        }
      }
      break;

    case 4:
      {
        int     dstStep;
        Ipp8u*  pDst8u[4];
        Ipp16u* pDst16u[4];

        dstStep = m_ccomp[0].m_cc_step;
        convert = 1;

        if(m_src.precision <= 8)
        {
          pDst8u[0] = m_ccomp[0].GetCCBufferPtr(thread_id);
          pDst8u[1] = m_ccomp[1].GetCCBufferPtr(thread_id);
          pDst8u[2] = m_ccomp[2].GetCCBufferPtr(thread_id);
          pDst8u[3] = m_ccomp[3].GetCCBufferPtr(thread_id);

          status = ippiCopy_8u_C4P4R(pSrc8u,srcStep,pDst8u,dstStep,roi);
        }
        else
        {
          pDst16u[0] = (Ipp16u*)m_ccomp[0].GetCCBufferPtr(thread_id);
          pDst16u[1] = (Ipp16u*)m_ccomp[1].GetCCBufferPtr(thread_id);
          pDst16u[2] = (Ipp16u*)m_ccomp[2].GetCCBufferPtr(thread_id);
          pDst16u[3] = (Ipp16u*)m_ccomp[3].GetCCBufferPtr(thread_id);

          status = ippiCopy_16s_C4P4R((Ipp16s*)pSrc16u,srcStep,(Ipp16s**)pDst16u,dstStep,roi);
        }

        if(ippStsNoErr != status)
        {
          LOG1("IPP Error: ippiCopy_8u_C4P4R() failed - ",status);
          return JPEG_ERR_INTERNAL;
        }
      }
      break;

    default:
      return JPEG_NOT_IMPLEMENTED;
    }
  }

  // Gray to Gray
  if(m_src.color == JC_GRAY && m_jpeg_color == JC_GRAY)
  {
    int     dstStep;
    Ipp8u*  pDst8u;
    Ipp16u* pDst16u;

    dstStep = m_ccomp[0].m_cc_step;
    convert = 1;

    if(m_src.precision <= 8)
    {
      pDst8u  = m_ccomp[0].GetCCBufferPtr(thread_id);

      status  = ippiCopy_8u_C1R(pSrc8u,srcStep,pDst8u,dstStep,roi);
    }
    else
    {
      pDst16u = (Ipp16u*)m_ccomp[0].GetCCBufferPtr(thread_id);

      status = ippiCopy_16s_C1R((Ipp16s*)pSrc16u,srcStep,(Ipp16s*)pDst16u,dstStep,roi);
    }

    if(ippStsNoErr != status)
    {
      LOG1("IPP Error: ippiCopy_8u_C1R() failed - ",status);
      return JPEG_ERR_INTERNAL;
    }
  }

  // RGB to Gray
  if(m_src.color == JC_RGB && m_jpeg_color == JC_GRAY)
  {
    int    dstStep;
    Ipp8u* pDst8u;