yuvai.cpp

网络MPEG4IP流媒体开发源代码

/*************************************************************************

This software module was originally developed by 

	Ming-Chieh Lee ([e-mail]), Microsoft Corporation
	Wei-ge Chen ([e-mail]), Microsoft Corporation
	Bruce Lin ([e-mail]), Microsoft Corporation
	Chuang Gu ([e-mail]), Microsoft Corporation
	(date: March, 1996)

in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
This software module is an implementation of a part of one or more MPEG-4 Video tools 
as specified by the MPEG-4 Video. 
ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
The original developer of this software module and his/her company, 
the subsequent editors and their companies, 
and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
Copyright is not released for non MPEG-4 Video conforming products. 
Microsoft retains full right to use the code for his/her own purpose, 
assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
This copyright notice must be included in all copies or derivative works. 

Copyright (c) 1996, 1997.

Module Name:

	yuva.hpp

Abstract:

	YUVA (4:2:0) VOP 

Revision History:

*************************************************************************/

#include "typeapi.h"

#ifdef __MFC_
#ifdef _DEBUG
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif

#define new DEBUG_NEW				   
#endif // __MFC_

CVOPIntYUVBA::~CVOPIntYUVBA ()
{
	delete m_piiY;
	delete m_piiU;
	delete m_piiV;
	delete m_piiBY;
	delete m_piiBUV;
	delete m_piiA;
}

Void CVOPIntYUVBA::constructFromVOPF (const CVOPIntYUVBA& vopi, const CRct& rc)
{
	if (rc.valid ()) {
		CRct rY = (rc.valid ()) ? rc : vopi.whereY ();
		CRct rUV = rY / 2;
		m_piiY = new CIntImage (*vopi.getPlane (Y_PLANE), rY);
		m_piiU = new CIntImage (*vopi.getPlane (U_PLANE), rUV);
		m_piiV = new CIntImage (*vopi.getPlane (V_PLANE), rUV);
		m_piiBY = new CIntImage (*vopi.getPlane (BY_PLANE), rY);
		m_piiBUV = new CIntImage (*vopi.getPlane (BUV_PLANE), rUV);
		if (m_fAUsage == EIGHT_BIT) {
			m_piiA = new CIntImage (*vopi.getPlane (A_PLANE), rY);
			assert (m_piiA != NULL);
		}
	}
	else {
		m_piiY = new CIntImage (*vopi.getPlane (Y_PLANE));
		m_piiU = new CIntImage (*vopi.getPlane (U_PLANE));
		m_piiV = new CIntImage (*vopi.getPlane (V_PLANE));
		m_piiBY = new CIntImage (*vopi.getPlane (BY_PLANE));
		m_piiBUV = new CIntImage (*vopi.getPlane (BUV_PLANE));
		if (m_fAUsage == EIGHT_BIT) {
			m_piiA = new CIntImage (*vopi.getPlane (A_PLANE));
			assert (m_piiA != NULL);
		}
	}
	assert (m_piiY != NULL);
	assert (m_piiU != NULL);
	assert (m_piiV != NULL);
	assert (m_piiBY != NULL);
	assert (m_piiBUV != NULL);
}

CVOPIntYUVBA::CVOPIntYUVBA (const CVOPIntYUVBA& vopi, AlphaUsage fAUsage, const CRct& rc) : 
	m_fAUsage (fAUsage), m_piiY (NULL), m_piiU (NULL), m_piiV (NULL), m_piiBY (NULL), m_piiBUV (NULL), m_piiA (NULL)
	
{
	constructFromVOPF (vopi, rc);
}

		
CVOPIntYUVBA::CVOPIntYUVBA (const CVOPIntYUVBA& vopi, const CRct& rc) : 
	m_piiY (NULL), m_piiU (NULL), m_piiV (NULL), m_piiBY (NULL), m_piiBUV (NULL), m_piiA (NULL)
{
	m_fAUsage = vopi.fAUsage ();
	constructFromVOPF (vopi, rc);
}

CVOPIntYUVBA::CVOPIntYUVBA (const CVideoObjectPlane& vop, AlphaUsage fAUsage, const CRct& rc) : 
	m_fAUsage (fAUsage), m_piiY (NULL), m_piiU (NULL), m_piiV (NULL), m_piiBY (NULL), m_piiBUV (NULL), m_piiA (NULL)
	
{
	CRct r = (rc.valid ()) ? rc : vop.where ();
	m_piiY = new CIntImage (r);
	CIntImage* piiU = new CIntImage (r);
	CIntImage* piiV = new CIntImage (r);
	m_piiBY = new CIntImage (r);
	if (m_fAUsage == EIGHT_BIT)
		m_piiA = new CIntImage (r);

	if (r == vop.where ()) { // faster operation if these two has the same rects
		PixelI* ppxlfY = (PixelI*) m_piiY -> pixels ();
		PixelI* ppxlfU = (PixelI*) piiU -> pixels ();
		PixelI* ppxlfV = (PixelI*) piiV -> pixels ();
		PixelI* ppxlfB = (PixelI*) m_piiBY -> pixels ();
		const CPixel* ppxl = vop.pixels ();
		UInt area = vop.where ().area ();
		UInt ip;
		for (ip = 0; ip < area; ip++, ppxl++, ppxlfY++, ppxlfU++, ppxlfV++, ppxlfB++) {
			*ppxlfY = ppxl -> pxlU.yuv.y;
			*ppxlfU = ppxl -> pxlU.yuv.u;
			*ppxlfV = ppxl -> pxlU.yuv.v;
			*ppxlfB = (ppxl -> pxlU.yuv.a == transpValue) ? 0 : 255;
		}
		if (m_fAUsage == EIGHT_BIT) {
			ppxl = vop.pixels ();
			PixelI* ppxlfA = (PixelI*) m_piiA -> pixels ();
			for (ip = 0; ip < area; ip++, ppxl++, ppxlfA++)
				*ppxlfA = ppxl -> pxlU.yuv.a;
		}
	}
	else {
		for (CoordI y = r.top; y < r.bottom; y++) {
			PixelI* ppxlfY = (PixelI*) m_piiY -> pixels (r.left, y);
			PixelI* ppxlfU = (PixelI*) piiU -> pixels (r.left, y);
			PixelI* ppxlfV = (PixelI*) piiV -> pixels (r.left, y);
			PixelI* ppxlfB = (PixelI*) m_piiBY -> pixels (r.left, y);
			const CPixel* ppxl = vop.pixels (r.left, y);
			for (CoordI x = r.left; x < r.right; x++, ppxl++, ppxlfY++, ppxlfU++, ppxlfV++, ppxlfB++) {
				*ppxlfY = ppxl -> pxlU.yuv.y;
				*ppxlfU = ppxl -> pxlU.yuv.u;
				*ppxlfV = ppxl -> pxlU.yuv.v;
				*ppxlfB++ = (ppxl -> pxlU.yuv.a == transpValue) ? 0 : 255;
			}
			if (m_fAUsage == EIGHT_BIT) {
				ppxl = vop.pixels ();
				PixelI* ppxlfA = (PixelI*) m_piiA -> pixels ();
				for (CoordI x = r.left; x < r.right; x++, ppxl++, ppxlfA++)
					*ppxlfA = ppxl -> pxlU.yuv.a;
			}
		}
	}
	CRct rctBoxY = m_piiBY -> whereVisible ();
	if (rctBoxY.left % 2 != 0)
		rctBoxY.left--;
	if (rctBoxY.top % 2 != 0)
		rctBoxY.top--;
	m_piiBY -> where (rctBoxY);
	m_piiY -> where (rctBoxY);
	if (m_fAUsage == EIGHT_BIT)
		m_piiA -> where (rctBoxY);
	piiU -> where (rctBoxY);
	piiV -> where (rctBoxY);
	m_piiU = piiU -> decimate (2, 2);
	delete piiU;
	m_piiV = piiV -> decimate (2, 2);	
	delete piiV;
	m_piiBUV = m_piiBY -> decimateBinaryShape (2, 2);	//conservative decimation
}


CVOPIntYUVBA::CVOPIntYUVBA (AlphaUsage fAUsage, const CRct& rc) :
	m_fAUsage (fAUsage), m_piiY (NULL), m_piiU (NULL), m_piiV (NULL), m_piiBY (NULL), m_piiBUV (NULL), m_piiA (NULL)
{
	CRct rcY = rc;
	CRct rcUV = rc / 2;
	m_piiY = new CIntImage (rcY);
	assert (m_piiY != NULL);
	m_piiU = new CIntImage (rcUV);
	assert (m_piiU != NULL);
	m_piiV = new CIntImage (rcUV);
	assert (m_piiV != NULL);
	m_piiBY = new CIntImage (rcY);
	assert (m_piiBY != NULL);
	m_piiBUV = new CIntImage (rcUV);
	assert (m_piiBUV != NULL);
	if (m_fAUsage == EIGHT_BIT) {
		m_piiA = new CIntImage (rcY);
		assert (m_piiA != NULL);
	}
}

CVOPIntYUVBA::CVOPIntYUVBA (AlphaUsage fAUsage, const CRct& rcY, const CRct& rcUV) :
	m_fAUsage (fAUsage), m_piiY (NULL), m_piiU (NULL), m_piiV (NULL), m_piiBY (NULL), m_piiBUV (NULL), m_piiA (NULL)
	
{
	m_piiY = new CIntImage (rcY);
	assert (m_piiY != NULL);
	m_piiU = new CIntImage (rcUV);
	assert (m_piiU != NULL);
	m_piiV = new CIntImage (rcUV);
	assert (m_piiV != NULL);
	m_piiBY = new CIntImage (rcY);
	assert (m_piiBY != NULL);
	m_piiBUV = new CIntImage (rcUV);
	assert (m_piiBUV != NULL);
	if (m_fAUsage == EIGHT_BIT) {
		m_piiA = new CIntImage (rcY);
		assert (m_piiA != NULL);
	}
}

CVOPIntYUVBA::CVOPIntYUVBA (AlphaUsage fAUsage) : 
	m_fAUsage (fAUsage), m_piiY (NULL), m_piiU (NULL), m_piiV (NULL), m_piiBY (NULL), m_piiBUV (NULL), m_piiA (NULL)
	
{
}

const CIntImage* CVOPIntYUVBA::getPlane (PlaneType plnType) const
{
	if (plnType == Y_PLANE) return m_piiY;
	else if (plnType == U_PLANE) return m_piiU;
	else if (plnType == V_PLANE) return m_piiV;
	else if (plnType == BY_PLANE) return m_piiBY;
	else if (plnType == BUV_PLANE) return m_piiBUV;
	else if (plnType == A_PLANE) return m_piiA;
	else return NULL;
}

Void CVOPIntYUVBA::where (const CRct& rct)
{
	whereY (rct);
	CRct rctUV = rct / 2;
	whereUV (rctUV);
}

Void CVOPIntYUVBA::whereY (const CRct& rct)
{
	m_piiY -> where (rct);
	m_piiBY -> where (rct);
	if (m_fAUsage == EIGHT_BIT)
		m_piiA -> where (rct);
}

Void CVOPIntYUVBA::whereUV (const CRct& rct)
{
	m_piiU -> where (rct);
	m_piiV -> where (rct);
	m_piiBUV -> where (rct);
}

Void CVOPIntYUVBA::setPlane (const CIntImage* pii, PlaneType plnType, Bool bBUV)
{
	if (pii == NULL)
		return;
	if (plnType == Y_PLANE) {
		delete m_piiY;
		m_piiY = new CIntImage (*pii);
	}
	else if (plnType == U_PLANE) {
		delete m_piiU;
		m_piiU = new CIntImage (*pii);
	}
	else if (plnType == V_PLANE) {
		delete m_piiV;
		m_piiV = new CIntImage (*pii);
	}
	else if (plnType == BY_PLANE) {
		delete m_piiBY;
		m_piiBY = new CIntImage (*pii);
		if (bBUV) {
			delete m_piiBUV;
			m_piiBUV = m_piiBY -> decimate (2, 2);
			m_piiBUV -> setRect (whereUV ());
		}
	}
	else if (plnType == BUV_PLANE) {
		delete m_piiBUV;
		m_piiBUV = new CIntImage (*pii);
	}
	else if (plnType == A_PLANE) {
		delete m_piiA;
		m_piiA = new CIntImage (*pii);
	}
	else assert (FALSE);
}

Void CVOPIntYUVBA::cropOnAlpha ()
{
	m_piiBY -> cropOnAlpha ();
	m_piiBUV -> cropOnAlpha ();
	m_piiY -> where (m_piiBY -> where ());
	m_piiU -> where (m_piiBUV -> where ());
	m_piiV -> where (m_piiBUV -> where ());
	if (m_fAUsage == EIGHT_BIT)
		m_piiA -> where (m_piiBY -> where ());
}

Void overlayMB (CIntImage* piiBig, const CIntImage* piiSmall, const CIntImage* piiMskSmall)
{
	if (piiSmall == NULL)
		return;
	PixelI* ppxlfBig = (PixelI*) piiBig -> pixels (piiSmall -> where ().left, piiSmall -> where ().top);
	Int unit = piiSmall -> where ().width;
	Int skipBig = piiBig -> where ().width - unit;
	const PixelI* ppxlfSmall = piiSmall -> pixels ();
	const PixelI* ppxlfMsk = piiMskSmall -> pixels ();
	for (Int i = 0; i < unit; i++) {
		for (Int j = 0; j < unit; j++) {
			*ppxlfBig = *ppxlfSmall;
			ppxlfBig++;
			ppxlfSmall++;
			ppxlfMsk++;
		}
		ppxlfBig += skipBig;
	}
}

Void CVOPIntYUVBA::overlay (const CVOPIntYUVBA& vopi)
{
	if (!vopi.valid ()) return;