jpegenc.cpp

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

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

    pDst8u = m_ccomp[0].GetCCBufferPtr(thread_id);

    status = ippiRGBToY_JPEG_8u_C3C1R(pSrc8u,srcStep,pDst8u,dstStep,roi);
    if(ippStsNoErr != status)
    {
      LOG1("IPP Error: ippiRGBToY_JPEG_8u_C3C1R() failed - ",status);
      return JPEG_ERR_INTERNAL;
    }
  }

  // RGB to RGB
  if(m_src.color == JC_RGB && m_jpeg_color == JC_RGB)
  {
    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;
    }
  }

  // BGR to RGB
  if(m_src.color == JC_BGR && m_jpeg_color == JC_RGB)
  {
    int     dstStep;
    Ipp8u*  pDst8u[3];
    Ipp16u* pDst16u[3];

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

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

      status = ippiCopy_8u_C3P3R(pSrc8u,srcStep,pDst8u,dstStep,roi);
    }
    else
    {
      pDst16u[2] = (Ipp16u*)m_ccomp[0].GetCCBufferPtr(thread_id);
      pDst16u[1] = (Ipp16u*)m_ccomp[1].GetCCBufferPtr(thread_id);
      pDst16u[0] = (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;
    }
  }

  // RGB to YCbCr
  if(m_src.color == JC_RGB && m_jpeg_color == JC_YCBCR)
  {
    int    dstStep;
    Ipp8u* pDst8u[3];

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

    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 = ippiRGBToYCbCr_JPEG_8u_C3P3R(pSrc8u,srcStep,pDst8u,dstStep,roi);

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

  // BGR to YCbCr
  if(m_src.color == JC_BGR && m_jpeg_color == JC_YCBCR)
  {
    int    dstStep;
    Ipp8u* pDst8u[3];

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

    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 = ippiBGRToYCbCr_JPEG_8u_C3P3R(pSrc8u,srcStep,pDst8u,dstStep,roi);

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

  // YCbCr to YCbCr (422 sampling)
  if(m_src.color == JC_YCBCR && m_jpeg_color == JC_YCBCR &&
     m_src.sampling == JS_422 && m_jpeg_sampling == JS_422)
  {
    int    dstStep[3];
    Ipp8u* pDst8u[3];

    convert = 1;

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

    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 = ippiYCbCr422_8u_C2P3R(pSrc8u,srcStep,pDst8u,dstStep,roi);

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

  // CMYK to CMYK
  if(m_src.color == JC_CMYK && m_jpeg_color == JC_CMYK)
  {
    int    dstStep;
    Ipp8u* pDst8u[4];

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

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

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

  // CMYK to YCCK
  if(m_src.color == JC_CMYK && m_jpeg_color == JC_YCCK)
  {
    int    dstStep;
    Ipp8u* pDst8u[4];

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

    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 = ippiCMYKToYCCK_JPEG_8u_C4P4R(pSrc8u,srcStep,pDst8u,dstStep,roi);

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

  if(!convert)
    return JPEG_NOT_IMPLEMENTED;

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


JERRCODE CJPEGEncoder::DownSampling(int nMCURow, int thread_id)
{
  int i, j, k;
  CJPEGColorComponent* curr_comp;
  IppStatus status;

  Ipp8u  val;
  Ipp8u* p;
  Ipp8u* p1;
  Ipp8u* p2;

  for(k = 0; k < m_jpeg_ncomp; k++)
  {
    curr_comp = &m_ccomp[k];

    // expand right edge
    if(m_xPadding)
    {
      for(i = 0; i < curr_comp->m_cc_height; i++)
      {
        if(m_src.precision <= 8)
        {
          p = curr_comp->GetCCBufferPtr(thread_id) + i*curr_comp->m_cc_step;
          val = p[m_src.width - 1];
          for(j = 0; j < m_xPadding; j++)
          {
            p[m_src.width + j] = val;
          }
        }
        else
        {
          Ipp16u* p16;
          Ipp16u  v16;
          p16 = (Ipp16u*)(curr_comp->GetCCBufferPtr(thread_id) + i*curr_comp->m_cc_step);
          v16 = p16[m_src.width - 1];
          for(j = 0; j < m_xPadding; j++)
          {
            p16[m_src.width + j] = v16;
          }
        }
      }
    }

    // expand bottom edge only for last MCU row
    if(nMCURow == m_numyMCU - 1)
    {
      curr_comp->m_cc_height -= m_yPadding;
      p = curr_comp->GetCCBufferPtr(thread_id) + (curr_comp->m_cc_height-1) * curr_comp->m_cc_step;
      p1 = p;

      for(i = 0; i < m_yPadding; i++)
      {
        p1 += curr_comp->m_cc_step;
        ippsCopy_8u(p,p1,curr_comp->m_cc_step);
      }
    }

    // sampling 444
    if(curr_comp->m_h_factor == 1 && curr_comp->m_v_factor == 1)
    {
      Ipp8u* pSrc = curr_comp->GetCCBufferPtr(thread_id);
      Ipp8u* pDst = curr_comp->GetSSBufferPtr(thread_id);

      ippsCopy_8u(pSrc,pDst,curr_comp->m_cc_bufsize);
    }

    // sampling 422
    if(curr_comp->m_h_factor == 2 && curr_comp->m_v_factor == 1)
    {
      int    srcStep;
      int    dstStep;
      Ipp8u* pSrc;
      Ipp8u* pDst;

      srcStep = curr_comp->m_cc_step;
      dstStep = curr_comp->m_ss_step;

      pSrc = curr_comp->GetCCBufferPtr(thread_id);
      pDst = curr_comp->GetSSBufferPtr(thread_id);

      if(m_src.sampling == JS_422)
      {
        IppiSize roi;
        roi.width  = curr_comp->m_ss_step;
        roi.height = curr_comp->m_ss_height;

        status = ippiCopy_8u_C1R(pSrc,srcStep,pDst,dstStep,roi);
        if(ippStsNoErr != status)
        {
          LOG0("Error: ippiCopy_8u_C1R() failed!");
          return JPEG_ERR_INTERNAL;
        }
      }
      else
      {
        for(i = 0; i < m_mcuHeight; i++)
        {
          status = ippiSampleDownRowH2V1_Box_JPEG_8u_C1(pSrc,srcStep,pDst);
          if(ippStsNoErr != status)
          {
            LOG0("Error: ippiSampleDownRowH2V1_Box_JPEG_8u_C1() failed!");
            return JPEG_ERR_INTERNAL;
          }

          pSrc += srcStep;
          pDst += dstStep;
        }
      }
    }

    // sampling 411
    if(curr_comp->m_h_factor == 2 && curr_comp->m_v_factor == 2)
    {
      int    srcStep;
      Ipp8u* pSrc;
      Ipp8u* pDst;

      srcStep = curr_comp->m_cc_step;

      pSrc = curr_comp->GetCCBufferPtr(thread_id);
      pDst = curr_comp->GetSSBufferPtr(thread_id);

      for(i = 0; i < curr_comp->m_cc_height; i += 2)
      {
        p1 = pSrc + (i+0)*srcStep;
        p2 = pSrc + (i+1)*srcStep;

        status = ippiSampleDownRowH2V2_Box_JPEG_8u_C1(p1,p2,srcStep,pDst);
        if(ippStsNoErr != status)
        {
          LOG0("Error: ippiSampleUpRowH2V2_Triangle_JPEG_8u_C1() failed!");
          return JPEG_ERR_INTERNAL;
        }

        pDst += curr_comp->m_ss_step;
      }
    }
  } // for m_jpeg_ncomp

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


JERRCODE CJPEGEncoder::ProcessBuffer(int nMCURow, int thread_id)
{
  int                  i,j,c;
  int                  copyHeight;
  int                  yPadd, xPadd;
  int                  srcStep;
  Ipp8u*               pSrc8u;
  Ipp8u*               pDst8u;
  CJPEGColorComponent* curr_comp;
  IppStatus            status;
  IppiSize             roi;

  Ipp8u  val;
  Ipp8u* p;
  Ipp8u* p1;

  for(c = 0; c < m_jpeg_ncomp; c++)
  {
    curr_comp = &m_ccomp[c];
    srcStep   = m_src.lineStep[c];
    pSrc8u    = m_src.p.Data8u[c]  + nMCURow * curr_comp->m_ss_height * srcStep;

    copyHeight = curr_comp->m_ss_height;
    if(nMCURow == m_numyMCU - 1)
    {
      yPadd = (c == 0)? m_yPadding : m_yPadding/2;
      copyHeight -= yPadd;
    }

    roi.width  = srcStep;
    roi.height = copyHeight;

    pDst8u = curr_comp->GetSSBufferPtr(thread_id);

    status = ippiCopy_8u_C1R(pSrc8u, srcStep, pDst8u, curr_comp->m_ss_step, roi);
    if(ippStsNoErr != status)
    {
      LOG1("IPP Error: ippiCopy_8u_C1R() failed - ",status);
      return JPEG_ERR_INTERNAL;
    }

    // expand right edge
    if(m_xPadding)
    {
      for(i = 0; i < curr_comp->m_ss_height; i++)
      {
        if(m_src.precision <= 8)
        {
          int width;

          width = (c == 0) ? m_src.width : m_src.width/2;
          xPadd = (c == 0) ? m_xPadding : m_xPadding/2;
          p     = curr_comp->GetSSBufferPtr(thread_id) + i*curr_comp->m_ss_step;
          val   = p[width - 1];

          for(j = 0; j < xPadd; j++)
          {
            p[width + j] = val;
          }
        }
      }
    }

    // expand bottom edge only for last MCU row
    if(nMCURow == m_numyMCU - 1)
    {
      curr_comp->m_cc_height -= yPadd;
      p = curr_comp->GetSSBufferPtr(thread_id) + (copyHeight - 1) * curr_comp->m_ss_step;
      p1 = p;

      for(i = 0; i < yPadd; i++)
      {
        p1 += curr_comp->m_ss_step;
        ippsCopy_8u(p,p1,curr_comp->m_ss_step);
      }
    }
 } // for m_jpeg_comp

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


JERRCODE CJPEGEncoder::TransformMCURowBL(
  Ipp16s* pMCUBuf,
  int     thread_id)
{
  int c;
  int vs;
  int hs;
  int curr_mcu;
  int srcStep;
  Ipp8u*               src;
  Ipp16u*              qtbl;
  CJPEGColorComponent* curr_comp;
  IppStatus            status;

  for(curr_mcu = 0; curr_mcu < m_numxMCU; curr_mcu++)
  {
    for(c = 0; c < m_jpeg_ncomp; c++)
    {
      curr_comp = &m_ccomp[c];

      qtbl = m_qntbl[curr_comp->m_q_selector];

      srcStep = curr_comp->m_ss_step;

      for(vs = 0; vs < curr_comp->m_vsampling; vs++)
      {
        src  = curr_comp->GetSSBufferPtr(thread_id) +
               8*curr_mcu*curr_comp->m_hsampling +
               8*vs*srcStep;

        for(hs = 0; hs < curr_comp->m_hsampling; hs++)
        {
          src += 8*hs;

          status = ippiDCTQuantFwd8x8LS_JPEG_8u16s_C1R(
                     src,srcStep,pMCUBuf,qtbl);

          if(ippStsNoErr != status)
          {
            LOG0("Error: ippiDCTQuantFwd8x8LS_JPEG_8u16s_C1R() failed!");
            return JPEG_ERR_INTERNAL;
          }

          pMCUBuf += DCTSIZE2;
        } // for m_hsampling
      } // for m_vsampling
    } // for m_jpeg_ncomp
  } // for m_numxMCU

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


JERRCODE CJPEGEncoder::TransformMCURowEX(
  Ipp16s* pMCUBuf,
  int     thread_id)
{
  int c;
  int vs;
  int hs;
  int curr_mcu;
  int srcStep;
  Ipp16u*              src;
  Ipp32f*              qtbl;
  CJPEGColorComponent* curr_comp;
  IppStatus            status;

  for(curr_mcu = 0; curr_mcu < m_numxMCU; curr_mcu++)
  {
    for(c = 0; c < m_jpeg_ncomp; c++)
    {
      curr_comp = &m_ccomp[c];

      qtbl = m_qntbl[curr_comp->m_q_selector];

      srcStep = curr_comp->m_ss_step;

      for(vs = 0; vs < curr_comp->m_vsampling; vs++)
      {
        src  = (Ipp16u*)curr_comp->GetSSBufferPtr(thread_id) +
               8*curr_mcu*curr_comp->m_hsampling +
               8*vs*srcStep;

        for(hs = 0; hs < curr_comp->m_hsampling; hs++)
        {
          src += 8*hs;

          status = ippiDCTQuantFwd8x8LS_JPEG_16u16s_C1R(
                     src,srcStep,pMCUBuf,qtbl);

          if(ippStsNoErr != status)
          {
            LOG0("Error: ippiDCTQuantFwd8x8LS_JPEG_8u16s_C1R() failed!");
            return JPEG_ERR_INTERNAL;
          }

          pMCUBuf += DCTSIZE2;
        } // for m_hsampling
      } // for m_vsampling
    } // for m_jpeg_ncomp
  } // for m_numxMCU

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


JERRCODE CJPEGEncoder::TransformMCURowLS(Ipp16s* pMCUBuf, int nMCURow, int thread_id)
{
  int                    c;
  Ipp16s*                pDst;
  Ipp16s*                pCurrRow;
  Ipp16s*                pPrevRow;
  CJPEGColorComponent*   curr_comp;
  IppStatus