newpred.cpp

小波图像变换

		memcpy(Refpoint , ppxlcRef + RefSize.left, RefSize.width);
		if(Refpoint == Refbuf0) break;
		assert(Refpoint > Refbuf0);
	}
	Refpoint = (PixelC *)ppxlcRef + RefSize.left;

	if(MBA == -1){
		Refpoint += (m_iHeight/MB_SIZE - iMBY) * RefSize.width * MB_SIZE / magnification;
	}else{
		i = MBA/(m_iWidth / MB_SIZE) - iMBY;
		if (flag == 0)
			i = 1;
		Refpoint += i*RefSize.width * MB_SIZE / magnification;
	}

	// padding below
	memcpy(Refpoint, Refpoint - RefSize.width, RefSize.width);
	while(1){
		Refpoint += RefSize.width;
		memcpy(Refpoint, Refpoint - RefSize.width, RefSize.width);
		if(Refpoint == Refbuf0 + (RefSize.bottom - RefSize.top - 1) * RefSize.width) break;
		assert(Refpoint < Refbuf0 + (RefSize.bottom - RefSize.top- 1) * RefSize.width);
	}
}

void CNewPred::CopyReftoBuf(const PixelC* RefbufY, const PixelC* RefbufU, const PixelC* RefbufV, 
							CRct rctRefFrameY, CRct rctRefFrameUV)
{
	CopyRefYtoBufY(RefbufY, rctRefFrameY);
	CopyRefUtoBufU(RefbufU, rctRefFrameUV);
	CopyRefVtoBufV(RefbufV, rctRefFrameUV);
}

void CNewPred::CopyRefYtoBufY(const PixelC*	ppxlcRefY,CRct RefSize)
{
	memcpy(m_pchNewPredRefY, ppxlcRefY, RefSize.width*(RefSize.bottom - RefSize.top));
}

void CNewPred::CopyBufYtoRefY(const PixelC*	ppxlcRefY,CRct RefSize)
{
	memcpy((PixelC *)ppxlcRefY, m_pchNewPredRefY, RefSize.width*(RefSize.bottom - RefSize.top));
}

void CNewPred::CopyRefUtoBufU(const PixelC*	ppxlcRefU,CRct RefSize)
{
	memcpy(m_pchNewPredRefU, ppxlcRefU, RefSize.width*(RefSize.bottom - RefSize.top));
}

void CNewPred::CopyBufUtoRefU(const PixelC*	ppxlcRefU,CRct RefSize)
{
	memcpy((PixelC *)ppxlcRefU, m_pchNewPredRefU, RefSize.width*(RefSize.bottom - RefSize.top));
}

void CNewPred::CopyRefVtoBufV(const PixelC*	ppxlcRefV,CRct RefSize)
{
	memcpy(m_pchNewPredRefV, ppxlcRefV, RefSize.width*(RefSize.bottom - RefSize.top));
}

void CNewPred::CopyBufVtoRefV(const PixelC*	ppxlcRefV,CRct RefSize)
{
	memcpy((PixelC *)ppxlcRefV, m_pchNewPredRefV, RefSize.width*(RefSize.bottom - RefSize.top));
}

void CNewPred::ChangeRefOfSlice(const PixelC* ppxlcRefY, const PixelC* RefbufY, const PixelC* ppxlcRefU,
								const PixelC* RefbufU, const PixelC* ppxlcRefV, const PixelC* RefbufV,
								Int iMBX, Int iMBY, CRct rctRefFrameY, CRct rctRefFrameUV)
{
	ChangeRefOfSliceYUV(ppxlcRefY, RefbufY, iMBX, iMBY,rctRefFrameY,'Y');
	ChangeRefOfSliceYUV(ppxlcRefU, RefbufU, iMBX, iMBY,rctRefFrameUV,'U');
	ChangeRefOfSliceYUV(ppxlcRefV, RefbufV, iMBX, iMBY,rctRefFrameUV,'V');
}

Bool CNewPred::CopyNPtoVM(Int iSlice_no, PixelC* RefpointY, PixelC* RefpointU, PixelC* RefpointV)
{
	int ww, hh, st;
	int dist;
	int j;
	int cur_slice_no, next_slice_no;

	cur_slice_no = *(m_piSlicePoint + iSlice_no);
	next_slice_no = *(m_piSlicePoint + iSlice_no +1);
	if (next_slice_no == -1)
		next_slice_no = m_iNPNumMBX*m_iNPNumMBY;

	st = (cur_slice_no % m_iNPNumMBX) + EXPANDY_REF_FRAME/MB_SIZE;
	ww = next_slice_no - cur_slice_no;
	if (ww <= m_iNPNumMBX)
		hh = 1;
	else {
		hh = ww / m_iNPNumMBX;
		ww = m_iNPNumMBX;
	}

	for (Int i=0; i < (Who_Am_I() == NP_ENCODER?m_iNumBuffEnc:m_iNumBuffDec); i++) {
		if (m_pNewPredControl->ref[iSlice_no] == 0) {
			break;
		}
		if( (m_pNewPredControl->NPRefBuf[iSlice_no][i]->vop_id 
			== m_pNewPredControl->ref[iSlice_no]) )
		{
			for (j = 0; j < hh * MB_SIZE; j++) {
				dist = st*MB_SIZE + j* m_rctNPFrameY.width;
				memcpy(RefpointY+dist, m_pNewPredControl->NPRefBuf[iSlice_no][i]->pdata.pchY+dist, ww*MB_SIZE);
			}
			for (j = 0; j < hh * BLOCK_SIZE; j++) {
				dist = st*BLOCK_SIZE + j* m_rctNPFrameUV.width;
				memcpy(RefpointU+dist, m_pNewPredControl->NPRefBuf[iSlice_no][i]->pdata.pchU+dist, ww*BLOCK_SIZE);
				memcpy(RefpointV+dist, m_pNewPredControl->NPRefBuf[iSlice_no][i]->pdata.pchV+dist, ww*BLOCK_SIZE);
			}
			return TRUE;
		}
#ifdef _DEBUG
		else
		{
			NPDebugMessage("Not find NP memory (%02d:%02d)\n", m_pNewPredControl->ref[iSlice_no], iSlice_no);
		}
#endif
	}
	return FALSE;
}

Bool CNewPred::CopyNPtoPrev(Int iSlice_no, PixelC* RefpointY, PixelC* RefpointU, PixelC* RefpointV)
{
	int ww, hh, st;
	int dist;
	int j;
	int cur_slice_no, next_slice_no;

	cur_slice_no = *(m_piSlicePoint + iSlice_no);
	next_slice_no = *(m_piSlicePoint + iSlice_no +1);
	if (next_slice_no == -1)
		next_slice_no = m_iNPNumMBX*m_iNPNumMBY;

	st = (cur_slice_no % m_iNPNumMBX) + EXPANDY_REF_FRAME/MB_SIZE;
	ww = next_slice_no - cur_slice_no;
	if (ww <= m_iNPNumMBX)
		hh = 1;
	else {
		hh = ww / m_iNPNumMBX;
		ww = m_iNPNumMBX;
	}
	if (Who_Am_I() == NP_ENCODER) {
		m_pNewPredControl->ref[iSlice_no] = m_pNewPredControl->NPRefBuf[iSlice_no][0]->vop_id;
	} else {
		if (m_pNewPredControl->NPRefBuf[iSlice_no][0]->vop_id != 1) {
			m_pNewPredControl->ref[iSlice_no] = m_pNewPredControl->NPRefBuf[iSlice_no][0]->vop_id - 1;
		} else {
			m_pNewPredControl->ref[iSlice_no] = m_maxVopID;
		}
	}
	for (Int i=0; i < (Who_Am_I() == NP_ENCODER?m_iNumBuffEnc:m_iNumBuffDec); i++) {
		if( (m_pNewPredControl->NPRefBuf[iSlice_no][i]->vop_id 
			== m_pNewPredControl->ref[iSlice_no]) )
		{
			for (j = 0; j < hh * MB_SIZE; j++) {
				dist = st*MB_SIZE + j* m_rctNPFrameY.width;
				memcpy(RefpointY+dist, m_pNewPredControl->NPRefBuf[iSlice_no][i]->pdata.pchY+dist, ww*MB_SIZE);
			}
			for (j = 0; j < hh * BLOCK_SIZE; j++) {
				dist = st*BLOCK_SIZE + j* m_rctNPFrameUV.width;
				memcpy(RefpointU+dist, m_pNewPredControl->NPRefBuf[iSlice_no][i]->pdata.pchU+dist, ww*BLOCK_SIZE);
				memcpy(RefpointV+dist, m_pNewPredControl->NPRefBuf[iSlice_no][i]->pdata.pchV+dist, ww*BLOCK_SIZE);
			}
			return TRUE;

		}
	}
	return FALSE;
}


#include <stdarg.h>

// 1999.8.30 NTT
#ifdef	_DEBUG
void cdecl CNewPred::NPDebugMessage( char* pszMsg, ... )
{
//#ifdef	_DEBUG
	va_list	arg_ptr;
	char	szBuf[256];

	va_start( arg_ptr, pszMsg );
	vsprintf( szBuf, pszMsg, arg_ptr );
	
	_RPT0(_CRT_WARN, szBuf);
//#endif
}
#endif

int CNewPred::SliceTailMBA(int iMBX, int iMBY)
{	
	int iNumMBX = m_iWidth / MB_SIZE;
	int iMBNum = iMBX + (iMBY * iNumMBX);
	int iresult;

	if(iMBNum > m_iWidth/MB_SIZE*m_iHeight/MB_SIZE-1) return(-1);
	for( int iLocal = 0; *(m_piSlicePoint + iLocal) >= 0; iLocal++ ) {
		if( *(m_piSlicePoint + iLocal) > iMBNum ) {
			if(*(m_piSlicePoint + iLocal) == -1){
				iresult = m_iWidth/MB_SIZE*m_iHeight/MB_SIZE-1;
			}
			else{
				iresult = *(m_piSlicePoint + iLocal)-1;
			}
			return(iresult);
		}
	}
	return(m_iWidth/MB_SIZE*m_iHeight/MB_SIZE-1);
}

void CNewPred::GetSlicePoint(char * pchSlicePointParam) 
{
	char*	pchSlicePoint = pchSlicePointParam;
	int		iLocal;
	int		iScanValue = 0;
	char* pchWrok = pchSlicePoint;

	if (pchSlicePointParam[0]) {
		iLocal = 0;
		while (sscanf( pchWrok, "%d", &iScanValue ) != EOF) {
			iLocal++;
			pchWrok = strchr( pchWrok, ',' );
			if (pchWrok == NULL)
				break;
			++pchWrok;
		}
		if (m_bNewPredSegmentType == 1) // VOP segment
			iLocal = 1;
		m_piSlicePoint = new int[iLocal+1];			// generate slice point

		if (m_bNewPredSegmentType == 1) { // VOP segment
			m_iNumSlice = 1;
			iLocal = 0;
			*(m_piSlicePoint + iLocal) = 0;
			iLocal++;
			*(m_piSlicePoint + iLocal) = -1;
		} else {
			m_iNumSlice = iLocal;
			iLocal = 0;
				while (sscanf(pchSlicePoint, "%d", &iScanValue ) != EOF) {
				*(m_piSlicePoint + iLocal) = iScanValue;
				iLocal++;
				pchSlicePoint = strchr( pchSlicePoint, ',' );
				if (pchSlicePoint == NULL)
					break;
				++pchSlicePoint;
			}
			*(m_piSlicePoint + iLocal) = -1;

			if (*m_piSlicePoint != 0) {
				fprintf (stderr, "Wrong slice number\n");
				exit (1);
			}

			int i, before_x, next_x, flag = 0;
			for (iLocal = 0; iLocal < m_iNumSlice; iLocal++) {
				if ((*(m_piSlicePoint + iLocal)) % m_iNPNumMBX) {
					flag = 0;
					before_x = ((*(m_piSlicePoint + iLocal)) / m_iNPNumMBX) * m_iNPNumMBX;
					next_x = (before_x == (m_iNPNumMBY-1)*m_iNPNumMBX) ? -1 : (before_x + m_iNPNumMBX);
					for (i = 0; i <= m_iNumSlice; i++) {
						if ((*(m_piSlicePoint + i)) == before_x)
							flag++;
						if ((*(m_piSlicePoint + i)) == next_x)
							flag++;					
					}
					if (flag != 2) {
						fprintf (stderr, "Wrong slice number\n");
						exit (1);
					}
				}
			}
		}
	}
}


void  CNewPred::check_comment(char *buf)
{
	while(*buf != '\0'){
		if (*buf == '%') {
			*buf = '\0';
		}
		buf++;
	}
}

short  CNewPred::check_space(char *buf)
{
	short	i;
	i=0;

	if(*buf == (char)NULL)
		i=1;
	else if(strspn(buf," \t\n")==strlen(buf))
		i=1;

	return(i);
}

int CNewPred::make_next_decbuf(
	NEWPREDcnt*	newpredCnt,
	int			vop_id,
	int			slice_no)
{
  int		noStore_vop_id = 0;

	m_pShiftBufTmp = newpredCnt->NPRefBuf[slice_no];
	shiftBuffer(vop_id, m_iNumBuffDec);

	return(noStore_vop_id);
}

void  CNewPred::shiftBuffer(
				int		vop_id,
				int		max_refsel)
{
	int			i;
	int			iMoveCnt = max_refsel-1;
	NEWPRED_buf *tmpbuf;

	if(m_pShiftBufTmp) {
		tmpbuf = m_pShiftBufTmp[iMoveCnt];
	}

	for(i=iMoveCnt; i>0; i--) {
		if(m_pShiftBufTmp)
		{
			m_pShiftBufTmp[i] = m_pShiftBufTmp[i-1];
		}
	}

	if(m_pShiftBufTmp) {
		m_pShiftBufTmp[0] = tmpbuf;
		SetNPRefBuf(m_pShiftBufTmp, vop_id, 0);
	}
	return;
}