colorspaceconvert.cpp

一个优化的H.263解码器,性能达到商用级

// ColorSpaceConvert.cpp: implementation of the CColorSpaceConvert class.
//
//////////////////////////////////////////////////////////////////////

#include "ColorSpaceConvert.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CColorSpaceConvert::CColorSpaceConvert()
{
	int i =0;
	int r,g,b;

	for(i = 0; i < 512; i ++)
		m_limit_rgb[i] = 0;
	for(i = 512; i < 768; i ++)
		m_limit_rgb[i] = (i - 512);
	for(i = 768; i < 1024; i ++)
		m_limit_rgb[i] = 255;

	for(i = 0; i < 256; ++i)
	{
		m_y2rgb[i] = 0;
		r = g = b = i; // >> 1);
		m_y2rgb[i] = r | g << 10 | b << 20;
	}

	for( i = 0; i < 128; ++i)
	{
		r = 256; //int((-0.001 * (i-128)) + 0.5);
		g = 256 + (int)((-0.3441 * (i-128)) + 0.5);
		b = 256 + (int)((1.772 * (i-128)) + 0.5);
		m_u2rgb[i] = 0;
		m_u2rgb[i] = r | g << 10 | b << 20;

		r = 256 + (int)((1.402 * (i-128)) + 0.5);
		g = 256 + (int)((-0.7141 * (i-128)) + 0.5);
		b = 256; //int((0.001 * (i-128)) + 0.5);
		m_v2rgb[i] = 0;
		m_v2rgb[i] = r | g << 10 | b << 20;
	}
	for( i = 128; i < 256; ++i)
	{
		r = 256; //int((-0.001 * (i-128)) + 0.5);
		g = 256 + (int)((-0.3441 * (i-128)) + 0.5);
		b = 256 + (int)((1.772 * (i-128)) + 0.5);
		m_u2rgb[i] = 0;
		m_u2rgb[i] = r | g << 10 | b << 20;

		r = 256 + (int)((1.402 * (i-128)) + 0.5);
		g = 256 + (int)((-0.7141 * (i-128)) + 0.5);
		b = 256; //int((0.001 * (i-128)) + 0.5);
		m_v2rgb[i] = 0;
		m_v2rgb[i] = r | g << 10 | b << 20;
	}
}

CColorSpaceConvert::~CColorSpaceConvert()
{

}
void CColorSpaceConvert::ConvertYUVtoRGB (const unsigned char *src0, 
						 const unsigned char *src1, 
						 const unsigned char *src2, 
						 unsigned char *rgb_bits, 
						 int width,
						 int height
						 )
{
//	switch(width)
//	{
//	case 128:
//		break;
//
//	case 176:
//		break;
//
//	case 320:
//		break;
//
//	case 352:
//		break;
//
//	case 640:
//		break;
//
//	case 704:
//		break;
//
//	case 1408:
//		break;
//
//	default:
//		return;
//	}

	const unsigned char  *yp = src0;
	const unsigned char  *up = src1;
	const unsigned char  *vp = src2;

	unsigned char  * rgb = rgb_bits;

	unsigned int  *Y = m_y2rgb;
	unsigned int  *U = m_u2rgb;
	unsigned int  *V = m_v2rgb;

	int stride = width * 3;
	int h = height >> 1, w = width >> 1;
	int i,j;
	unsigned int uv, tmp;
	for(j = 0; j < h; j ++)
	{
		for(i = 0; i < w; i ++)
		{
			uv = U[up[0]] + V[vp[0]];
            tmp =Y[yp[0]] + uv ;

			rgb[0] = m_limit_rgb[(tmp & 0x3ff)];
			rgb[1] = m_limit_rgb[((tmp >> 10) & 0x3ff)];
			rgb[2] = m_limit_rgb[(tmp >> 20)];

			tmp = Y[yp[width]] + uv;
			rgb[stride] = m_limit_rgb[(tmp & 0x3ff)];
			rgb[stride + 1] = m_limit_rgb[((tmp >> 10) & 0x3ff)];
			rgb[stride + 2] = m_limit_rgb[(tmp >> 20)];

			yp++;
			rgb += 3;

			tmp = Y[yp[0]] + uv ;
			rgb[0] = m_limit_rgb[(tmp & 0x3ff)]  ;
			rgb[1] = m_limit_rgb[((tmp >> 10) & 0x3ff)];
			rgb[2] = m_limit_rgb[(tmp >> 20) ];

			tmp = Y[yp[width]] + uv;
			rgb[stride ] = m_limit_rgb[(tmp & 0x3ff)];
			rgb[stride + 1] = m_limit_rgb[((tmp >> 10) & 0x3ff)];
			rgb[stride+ 2] = m_limit_rgb[(tmp >> 20)];

			yp ++; up ++; vp ++;
			rgb += 3;
		}

		yp += width; //up += uvwid; vp += uvwid;
		rgb += stride;
	}
}