vopses.cpp

完整的RTP RTSP代码库

						tmp.right = (pvopcUpSampled->whereY ()).right;
					if(!(tmp.bottom <= (pvopcUpSampled->whereY ()).bottom))
						tmp.bottom = (pvopcUpSampled->whereY ()).bottom;
				}
//~OBSS_SAIT_FIX000524
			}
		}
//~OBSSFIX_MODE3_02
		else if(m_volmd.fAUsage == ONE_BIT) {
			tmp = m_rctBase;
			tmp.left = (int)((tmp.left) * (m_volmd.ihor_sampling_factor_n_shape)/(m_volmd.ihor_sampling_factor_m_shape));
			tmp.right = (int)((tmp.right) * (m_volmd.ihor_sampling_factor_n_shape)/(m_volmd.ihor_sampling_factor_m_shape));
			tmp.top = (int)((tmp.top) * (m_volmd.iver_sampling_factor_n_shape)/(m_volmd.iver_sampling_factor_m_shape));
			tmp.bottom = (int)((tmp.bottom) * (m_volmd.iver_sampling_factor_n_shape)/(m_volmd.iver_sampling_factor_m_shape));
			tmp.width = tmp.right - tmp.left ;
			tmp.left -= 32; tmp.right += 32;
			tmp.top -= 32; tmp.bottom += 32;
			tmp.width += 64;
//OBSS_SAIT_FIX000524
			if(!( tmp <= pvopcUpSampled->whereY () )) {
				if(!(tmp.left >= (pvopcUpSampled->whereY ()).left))
					tmp.left = (pvopcUpSampled->whereY ()).left;
				if(!(tmp.top >= (pvopcUpSampled->whereY ()).top))
					tmp.top = (pvopcUpSampled->whereY ()).top;
				if(!(tmp.right <= (pvopcUpSampled->whereY ()).right))
					tmp.right = (pvopcUpSampled->whereY ()).right;
				if(!(tmp.bottom <= (pvopcUpSampled->whereY ()).bottom))
					tmp.bottom = (pvopcUpSampled->whereY ()).bottom;
			}
//~OBSS_SAIT_FIX000524
		}
//~OBSS_SAIT_991015

		m_rctRefVOPY0 = m_rctRefVOPY1;
		m_rctRefVOPY1 = tmp;
		swapVOPU8Pointers (m_pvopcRefQ0,m_pvopcRefQ1);
		swapVOPU8Pointers (m_pvopcRefQ1,pvopcUpSampled);
		m_pvopcRefQ0->setBoundRct(m_rctRefVOPY0);
		m_pvopcRefQ1->setBoundRct(m_rctRefVOPY1);
		delete pvopcUpSampled;
	}
}

Void CVideoObject::swapVOPU8Pointers (CVOPU8YUVBA*& pvopc0, CVOPU8YUVBA*& pvopc1)
{
	CVOPU8YUVBA* pvopcTmp = pvopc0;
	pvopc0 = pvopc1;
	pvopc1 = pvopcTmp;
}

Void CVideoObject::swapVOPIntPointers (CVOPIntYUVBA*& pvopi0, CVOPIntYUVBA*& pvopi1)
{
	CVOPIntYUVBA* pvopiTmp = pvopi0;
	pvopi0 = pvopi1;
	pvopi1 = pvopiTmp;
}

Void CVideoObject::setRefStartingPointers ()
{
	m_iStartInRefToCurrRctY = m_rctRefFrameY.offset (m_rctCurrVOPY.left, m_rctCurrVOPY.top);
	m_iStartInRefToCurrRctUV = m_rctRefFrameUV.offset (m_rctCurrVOPUV.left, m_rctCurrVOPUV.top);
}

const CVOPU8YUVBA* CVideoObject::pvopcReconCurr () const
{
	if ((m_uiSprite == 1 && m_vopmd.vopPredType == SPRITE) && m_iNumOfPnts > 0) // GMC
		return m_pvopcCurrQ;
	else if ((m_uiSprite == 1 && m_vopmd.vopPredType == SPRITE) && m_iNumOfPnts == 0) { // GMC
		if (m_sptMode != BASIC_SPRITE) 
			return m_pvopcSptQ;
		else 
			return m_pvopcRefQ1;
	}
	else if ((m_vopmd.vopPredType == BVOP && m_volmd.volType == BASE_LAYER) 
			 ||(m_vopmd.vopPredType == BVOP && m_vopmd.iRefSelectCode != 0))
		return m_pvopcCurrQ;
	else
		return m_pvopcRefQ1;
}
////////// 97/12/22 start
Void CVideoObject::compute_bfShapeMembers ()
{
	m_iVOPWidthY = m_rctCurrVOPY.width;
	m_iVOPWidthUV = m_rctCurrVOPUV.width;
	m_iNumMBX = m_iVOPWidthY / MB_SIZE; 
	m_iNumMBY = m_rctCurrVOPY.height () / MB_SIZE;
	m_iNumMB = m_iNumMBX * m_iNumMBY;
//	m_iNumOfTotalMVPerRow = 5 * m_iNumMBX;
//  wchen: changed to const as discussed with Bob.
	m_iNumOfTotalMVPerRow = PVOP_MV_PER_REF_PER_MB * m_iNumMBX;
}

Void CVideoObject::copyVOPU8YUVBA(CVOPU8YUVBA*& pvopc0, CVOPU8YUVBA*& pvopc1)
{
	delete pvopc0;  pvopc0 = NULL;
	pvopc0 = new CVOPU8YUVBA (*pvopc1);	/* i.e. pvopc0 = pvopc1; */
}

Void CVideoObject::copyVOPU8YUVBA(CVOPU8YUVBA*& pvopc0, CVOPU8YUVBA*& pvopc1, CVOPU8YUVBA*& pvopc2)
{
	delete pvopc0;  pvopc0 = NULL;
	pvopc0 = (pvopc1 != NULL) ?
		new CVOPU8YUVBA (*pvopc1) : new CVOPU8YUVBA (*pvopc2);
}
///// 97/12/22 end

// QuarterSample
Void CVideoObject::blkInterpolateY (
	                 const PixelC* ppxlcRefLeftTop, 
                     // point to left-top of the frame
					 Int blkSize, // Blocksize (0=16x8, 8=8x8, 16=16x16)
					 Int xRef, Int yRef, // x + mvX in quarter pel unit
					 U8* ppxlcblk, // Pointer to quarter sample interpolated block
                     Int iRoundingControl
					 ) 
{
  Int maxVal = (1<<m_volmd.nBits)-1; // mwi
  Int c[]={160, -48, 24, -8}; // Filter Coefficients

  U8 refblk[MB_SIZE+7][MB_SIZE+7];
  U8 tmpblk0[MB_SIZE+7][MB_SIZE+7];  
  U8 tmpblk1[MB_SIZE+1][MB_SIZE+1];

  Int x_int, y_int, x_frac, y_frac;
  Int blkSizeX, blkSizeY, iWidthY;  
  Int ix, iy, k;

  Long u;
  Int yTmp = yRef>>1;  // Field MV!

  if (blkSize == 0) {
    blkSizeX = 16;
    blkSizeY = 8;
    iWidthY  = 2*m_iFrameWidthY;
    
    y_int  = yTmp/4;
    if (yTmp < 0)
      if (yTmp%4) y_int--;
    y_frac = yTmp - (4*y_int);
  }
  else {
    blkSizeX = blkSize;
    blkSizeY = blkSize;
    iWidthY  = m_iFrameWidthY;
    y_int  = yRef/4;
    if (yRef < 0)
      if (yRef%4) y_int--;
    y_frac = yRef - (4*y_int);
  }

  x_int  = xRef/4;
  if (xRef < 0)
    if (xRef%4) x_int--;
  x_frac = xRef - (4*x_int);
  
  
  // Initialization
  const PixelC* ppxlcRef = ppxlcRefLeftTop + y_int * iWidthY + EXPANDY_REF_FRAME
    * m_iFrameWidthY + x_int + EXPANDY_REF_FRAME;
  for (iy=0; iy <= blkSizeY; iy++) {
    for (ix=0; ix <= blkSizeX; ix++) {
      refblk[iy+3][ix+3] = ppxlcRef[ix+iy*iWidthY];
    }
  }
   
  // Horizontal Mirroring

   for (iy=0; iy <= blkSizeY; iy++) {
	 for (ix=0; ix <= 2; ix++) {
	   refblk[iy+3][ix] = refblk[iy+3][5-ix];
	   refblk[iy+3][blkSizeX+ix+4] = refblk[iy+3][blkSizeX-ix+3];
	 }
   }
   
   switch (x_frac) {
	 
     case 0 : // Full Pel Position
       for (iy=0; iy <= blkSizeY; iy++) {
	     for (ix=0; ix <= blkSizeX-1; ix++) {
		   tmpblk0[iy+3][ix] = refblk[iy+3][ix+3];
	     }
	   }
	 break;
	 
     case 1 : // Quarter Pel Position
       for (iy=0; iy <= blkSizeY; iy++) {
	     for (ix=0; ix <= blkSizeX-1; ix++) {
           u = 0;
		   for (k=0; k<=3; k++) {
			 u += c[k] * ( refblk[iy+3][ix+3-k] + refblk[iy+3][ix+4+k] );
		   }
		   u = (u+128-iRoundingControl)/256;
		   u = max(0,min(maxVal,u));
		   tmpblk1[iy][ix] = (U8)u; 
	     }
	   }
       for (iy=0; iy <= blkSizeY; iy++) {
		 for (ix=0; ix <= blkSizeX-1; ix++) {
		   tmpblk0[iy+3][ix] = ( refblk[iy+3][ix+3] + tmpblk1[iy][ix] + 1 - iRoundingControl)/2;
		 }
	   }
     break;
	   
     case 2 : // Half Pel Position
       for (iy=0; iy <= blkSizeY; iy++) {
	     for (ix=0; ix <= blkSizeX-1; ix++) {
           u = 0;
		   for (k=0; k<=3; k++) {
			 u += c[k] * ( refblk[iy+3][ix+3-k] + refblk[iy+3][ix+4+k] );
		   }
		   u = (u+128-iRoundingControl)/256;
		   u = max(0,min(maxVal,u));
// GMC_V3
		   tmpblk0[iy+3][ix] = (U8)u; 
//		   tmpblk1[iy][ix] = (U8)u; 
// ~GMC_V3
	     }
	   }
	 break;
	   
     case 3 : // Quarter Pel Position
       for (iy=0; iy <= blkSizeY; iy++) {
	     for (ix=0; ix <= blkSizeX-1; ix++) {
           u = 0;
		   for (k=0; k<=3; k++) {
			 u += c[k] * ( refblk[iy+3][ix+3-k] + refblk[iy+3][ix+4+k] );
		   }
		   u = (u+128-iRoundingControl)/256;
		   u = max(0,min(maxVal,u));
		   tmpblk1[iy][ix] = (U8)u; 
	     }
	   }
       for (iy=0; iy <= blkSizeY; iy++) {
		 for (ix=0; ix <= blkSizeX-1; ix++) {
		   tmpblk0[iy+3][ix] = ( refblk[iy+3][ix+4] + tmpblk1[iy][ix] + 1 - iRoundingControl)/2;
		 }
	   }
     break;
	 
   }

   // Copy tmpblk0 -> refblk

   for (iy=0; iy <= blkSizeY; iy++) {
	 for (ix=0; ix <= blkSizeX-1; ix++) {
	   refblk[iy+3][ix] = tmpblk0[iy+3][ix];
	 }
   }
   
   // Vertical Mirroring

   for (iy=0; iy <= 2; iy++) {
	 for (ix=0; ix <= blkSizeX-1; ix++) {
	   refblk[iy][ix] = refblk[5-iy][ix];
	   refblk[blkSizeY+iy+4][ix] = refblk[blkSizeY-iy+3][ix];
	 }
   }
   
   switch (y_frac) {
	 
     case 0 : // Full Pel Position
       for (iy=0; iy <= blkSizeY-1; iy++) {
	     for (ix=0; ix <= blkSizeX-1; ix++) {
		   tmpblk0[iy][ix] = refblk[iy+3][ix];
	     }
	   }
	 break;
	 
     case 1 : // Quarter Pel Position
       for (iy=0; iy <= blkSizeY-1; iy++) {
	     for (ix=0; ix <= blkSizeX-1; ix++) {		   
           u = 0;
		   for (k=0; k<=3; k++) {
			 u += c[k] * ( refblk[iy+3-k][ix] + refblk[iy+4+k][ix] );
		   }
		   u = (u+128-iRoundingControl)/256;
		   u = max(0,min(maxVal,u));
		   tmpblk1[iy][ix] = (U8)u; 
	     }
	   }
       for (iy=0; iy <= blkSizeY-1; iy++) {
		 for (ix=0; ix <= blkSizeX-1; ix++) {
		   tmpblk0[iy][ix] = ( refblk[iy+3][ix] + tmpblk1[iy][ix] + 1 - iRoundingControl)/2;
		 }
	   }
     break;
	   
     case 2 : // Half Pel Position
       for (iy=0; iy <= blkSizeY-1; iy++) {
	     for (ix=0; ix <= blkSizeX-1; ix++) {
           u = 0;
		   for (k=0; k<=3; k++) {
			 u += c[k] * ( refblk[iy+3-k][ix] + refblk[iy+4+k][ix] );
		   }
		   u = (u+128-iRoundingControl)/256;
		   u = max(0,min(maxVal,u));
// GMC_V3
		   tmpblk0[iy][ix] = (U8)u; 
//		   tmpblk1[iy][ix] = (U8)u; 
// ~GMC_V3
	     }
	   }
	 break;
	   
     case 3 : // Quarter Pel Position
       for (iy=0; iy <= blkSizeY-1; iy++) {
	     for (ix=0; ix <= blkSizeX-1; ix++) {
           u = 0;
		   for (k=0; k<=3; k++) {
			 u += c[k] * ( refblk[iy+3-k][ix] + refblk[iy+4+k][ix] );
		   }
		   u = (u+128-iRoundingControl)/256;
		   u = max(0,min(maxVal,u));
		   tmpblk1[iy][ix] = (U8)u; 
	     }
	   }
       for (iy=0; iy <= blkSizeY-1; iy++) {
		 for (ix=0; ix <= blkSizeX-1; ix++) {
		   tmpblk0[iy][ix] = ( refblk[iy+4][ix] + tmpblk1[iy][ix] + 1 - iRoundingControl)/2;
		 }
	   }
     break;
	 
   }

   // Copy tmpblk0 -> ppxlcblk

   if (blkSize == 0) {
     for (iy=0; iy <= blkSizeY-1; iy++) {
       for (ix=0; ix <= blkSizeX-1; ix++) {
	     *(ppxlcblk+ix+iy*2*blkSizeX) = tmpblk0[iy][ix];
	   }
     }
   }
   else {
     for (iy=0; iy <= blkSizeY-1; iy++) {
       for (ix=0; ix <= blkSizeX-1; ix++) {
	     *(ppxlcblk+ix+iy*blkSizeX) = tmpblk0[iy][ix];
	   }
     }
   }
}
// ~QuarterSample

Void dumpNonCodedFrame(FILE* pfYUV, FILE* pfSeg, FILE **ppfAux, Int iAuxCompCount, CRct& rct, UInt nBits)
{
	// black frame
	Int iW = rct.width;
	Int iH = rct.height();
	Int i;

	PixelC *ppxlcPix = new PixelC [iW];

	pxlcmemset(ppxlcPix, 0, iW);
	for(i=0; i<iH; i++) // Y
		fwrite(ppxlcPix, sizeof(PixelC), iW, pfYUV);

	if(pfSeg!=NULL)
	{
		for(i=0; i<iH; i++) // A
			fwrite(ppxlcPix, sizeof(PixelC), iW, pfSeg);
	}
	if(ppfAux!=NULL)
	{
		Int iAux;
		for(iAux=0; iAux<iAuxCompCount; iAux++)
			if(ppfAux[iAux]!=NULL)
			{
				for(i=0; i<iH; i++)
					fwrite(ppxlcPix, sizeof(PixelC), iW, ppfAux[iAux]);
			}
	}

	PixelC pxlcValUV = 1<<(nBits-1);
	pxlcmemset(ppxlcPix, pxlcValUV, iW>>1);
	for(i=0; i<iH; i++) // UV
		fwrite(ppxlcPix, sizeof(PixelC), iW>>1, pfYUV);

	delete ppxlcPix;
}

Int CVideoObject::getAuxCompCount(Int vol_shape_extension)
{
  switch (vol_shape_extension) {  /* see N2687, pg. 178, tab. V2-1 */
    case -1:	return 1;
    case 0:  return 1;
    case 1:  return 1;
    case 2:  return 2;
    case 3:  return 2;      
    case 4:  return 3;
    case 5:  return 1;
    case 6:  return 2;
    case 7:  return 1;
    case 8:  return 1;
    case 9:  return 2;
    case 10: return 3;
    case 11: return 2;
    case 12: return 3;
    default: return 1;
  }  
}