yuvtofromrgb.c

魔兽2Linux版

//==========================================================================
//
//  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
//  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
//  PURPOSE.
//
//  Copyright (c) 1999 - 2001  On2 Technologies Inc. All Rights Reserved.
//
//--------------------------------------------------------------------------


/****************************************************************************
*
*   Module Title :     YUVtofromRGB
*
*   Description  :     YUV/RGB conversion functions
*
*
*****************************************************************************
*/

/****************************************************************************
*  Header Files
*****************************************************************************
*/

#define STRICT              /* Strict type checking. */


#include <string.h>

#include "pbdll.h"


/****************************************************************************
*  Module constants.
*****************************************************************************
*/        

#define YFACTOR         0.8588235
 
/****************************************************************************
*  Explicit imports
*****************************************************************************
*/

               
/****************************************************************************
*  Exported Global Variables
*****************************************************************************
*/
// Multiplication tables for TIMs (scalar version of) RGB -> smpte YVU
int RintoY[ 256];	// * 66
int GintoY[ 256];	// * 129
int BintoY[ 256];	// * 25
int RBintoVU[ 1024]; // * 28
int y_intoY[ 256];	// 149 * (i - 16) clamped to [ 0, 149 * 219]
int v_intoR[ 256]; 	// 204 * (i - 128)
int u_intoB[ 256]; 	// 258 * (i - 128)
int y_intoG[ 256];	// 254 * (i - 16) clamped to [ 0, 254 * 219]
int RintoG[ 256];	// *65
static int * const BintoG = BintoY;	// * 25

// RGB and YUV accelerator structures.
UINT8 CalcUTable[VAL_RANGE * 2];
INT32 CalcRUTable[VAL_RANGE];
UINT8 CalcVTable[VAL_RANGE * 2];
INT32 CalcRVTable[VAL_RANGE];
INT32 InvYScale[VAL_RANGE * 2];
UINT8 DivByTen[VAL_RANGE * 10];
UINT8 DivBy5p87[VAL_RANGE * 14];
INT32 Times2p99[VAL_RANGE];
INT32 Times5p87[VAL_RANGE];
INT32 Times1p14[VAL_RANGE];
INT32 TimesTen[VAL_RANGE];

UINT8 LimitVal_VP31[VAL_RANGE * 3];

/****************************************************************************
*  Forward References
*****************************************************************************
*/  

/****************************************************************************
*  Module Variables.
*****************************************************************************
*/  


/****************************************************************************
 * 
 *  ROUTINE       :     ScalarYUVtoRGB
 *
 *  INPUTS        :     yblock, ublock, vblock
 *                           Blocks of Y U and V data.
 *                      uvoffset
 *                           Offset of UV quadrant
 *                      RGBPtr
 *                           RGB structure to write into.
 *                      ReconBuffer
 *                           Is the YUV source in reconstruction buffer format.
 *
 *  OUTPUTS       :     
 *           
 *
 *  RETURNS       :     None.
 *
 *  FUNCTION      :     Converst one block to RGB
 *
 *  SPECIAL NOTES :     None. 
 *
 *
 *  ERRORS        :     None.
 *
 ****************************************************************************/
void ScalarYUVtoRGB ( PB_INSTANCE * pbi,
					  YUV_BUFFER_ENTRY_PTR yblock,		// Y block to be decoded
		              YUV_BUFFER_ENTRY_PTR ublock,		// U block to be used
				      YUV_BUFFER_ENTRY_PTR vblock,		// V block to be used
			          int uvoffset,					    // Offset to UV quadrant to be used
				      BGR_TYPE * RGBPtr,                // RGB bitmap data pointer
                      BOOL ReconBuffer )				// YUV buffer format
{
	INT32 UFactor;
	INT32 VFactor;
    INT32 YVal;
    UINT8 RVal;
	UINT8 BVal;
	INT32 n;
    INT32 RGB_YStep = (pbi->Configuration.VideoFrameWidth * 2);
    INT32 YStep;
    INT32 UVStep;

    UINT32 * InvYScaleTable = (UINT32 *)&InvYScale[0];
    UINT8 * LimitTable = &LimitVal_VP31[VAL_RANGE];

    UINT8 * DivBy5p87Table = &DivBy5p87[VAL_RANGE * 4];

	YUV_BUFFER_ENTRY_PTR YPtr;
	YUV_BUFFER_ENTRY_PTR YPtr2;
	YUV_BUFFER_ENTRY_PTR UPtr;
	YUV_BUFFER_ENTRY_PTR VPtr;

	BGR_TYPE * RGBPtr2 = RGBPtr + pbi->Configuration.VideoFrameWidth;

    // Set up starting values for YUV pointers
    YPtr = yblock;
    UPtr = ublock + uvoffset;
    VPtr = vblock + uvoffset;

    // Set the line step for the Y and UV planes and YPtr2
    if ( ReconBuffer )
    {
        YStep = (pbi->Configuration.YStride * 2);
        UVStep = pbi->Configuration.UVStride;
        YPtr2 = YPtr + pbi->Configuration.YStride;
    }
    else
    {
        YStep = (pbi->Configuration.VideoFrameWidth * 2);
        UVStep = (pbi->Configuration.VideoFrameWidth / 2);
        YPtr2 = YPtr + pbi->Configuration.VideoFrameWidth;
    }

    for ( n = 0; n < BLOCK_HEIGHT_WIDTH/2; n++ )
    {
		// First group of four pixels
		UFactor = CalcRUTable[UPtr[0]];
		VFactor = CalcRVTable[VPtr[0]];

        YVal = InvYScaleTable[YPtr[0]];
        RVal = LimitTable[ YVal + VFactor ];
		BVal = LimitTable[ YVal + UFactor ];
		RGBPtr[0].Blue	= BVal;
		RGBPtr[0].Red	= RVal;
		RGBPtr[0].Green	= (UINT8)DivBy5p87Table[ TimesTen[YVal] - Times2p99[RVal] - Times1p14[BVal] ];

        YVal = InvYScaleTable[YPtr[1]];
        RVal = LimitTable[ YVal + VFactor ];
		BVal = LimitTable[ YVal + UFactor ];
		RGBPtr[1].Blue	= BVal;
		RGBPtr[1].Red	= RVal;
		RGBPtr[1].Green	= (UINT8)DivBy5p87Table[ TimesTen[YVal] - Times2p99[RVal] - Times1p14[BVal] ];

        YVal = InvYScaleTable[YPtr2[0]];
        RVal = LimitTable[ YVal + VFactor ];
		BVal = LimitTable[ YVal + UFactor ];
		RGBPtr2[0].Blue	= BVal;
		RGBPtr2[0].Red	= RVal;
		RGBPtr2[0].Green = (UINT8)DivBy5p87Table[ TimesTen[YVal] - Times2p99[RVal] - Times1p14[BVal] ];

        YVal = InvYScaleTable[YPtr2[1]];
        RVal = LimitTable[ YVal + VFactor ];
		BVal = LimitTable[ YVal + UFactor ];
		RGBPtr2[1].Blue	= BVal;
		RGBPtr2[1].Red	= RVal;
		RGBPtr2[1].Green = (UINT8)DivBy5p87Table[ TimesTen[YVal] - Times2p99[RVal] - Times1p14[BVal] ];

		// Group 2
		UFactor = CalcRUTable[UPtr[1]];
		VFactor = CalcRVTable[VPtr[1]];

        YVal = InvYScaleTable[YPtr[2]];
        RVal = LimitTable[ YVal + VFactor ];
		BVal = LimitTable[ YVal + UFactor ];
		RGBPtr[2].Blue	= BVal;
		RGBPtr[2].Red	= RVal;
		RGBPtr[2].Green	= (UINT8)DivBy5p87Table[ TimesTen[YVal] - Times2p99[RVal] - Times1p14[BVal] ];

        YVal = InvYScaleTable[YPtr[3]];
        RVal = LimitTable[ YVal + VFactor ];
		BVal = LimitTable[ YVal + UFactor ];
		RGBPtr[3].Blue	= BVal;
		RGBPtr[3].Red	= RVal;
		RGBPtr[3].Green	= (UINT8)DivBy5p87Table[ TimesTen[YVal] - Times2p99[RVal] - Times1p14[BVal] ];

        YVal = InvYScaleTable[YPtr2[2]];
        RVal = LimitTable[ YVal + VFactor ];
		BVal = LimitTable[ YVal + UFactor ];
		RGBPtr2[2].Blue	= BVal;
		RGBPtr2[2].Red	= RVal;
		RGBPtr2[2].Green = (UINT8)DivBy5p87Table[ TimesTen[YVal] - Times2p99[RVal] - Times1p14[BVal] ];

        YVal = InvYScaleTable[YPtr2[3]];
        RVal = LimitTable[ YVal + VFactor ];
		BVal = LimitTable[ YVal + UFactor ];
		RGBPtr2[3].Blue	= BVal;
		RGBPtr2[3].Red	= RVal;
		RGBPtr2[3].Green = (UINT8)DivBy5p87Table[ TimesTen[YVal] - Times2p99[RVal] - Times1p14[BVal] ];

		// Group 3
		UFactor = CalcRUTable[UPtr[2]];
		VFactor = CalcRVTable[VPtr[2]];

        YVal = InvYScaleTable[YPtr[4]];
        RVal = LimitTable[ YVal + VFactor ];
		BVal = LimitTable[ YVal + UFactor ];
		RGBPtr[4].Blue	= BVal;
		RGBPtr[4].Red	= RVal;
		RGBPtr[4].Green	= (UINT8)DivBy5p87Table[ TimesTen[YVal] - Times2p99[RVal] - Times1p14[BVal] ];

        YVal = InvYScaleTable[YPtr[5]];
        RVal = LimitTable[ YVal + VFactor ];
		BVal = LimitTable[ YVal + UFactor ];
		RGBPtr[5].Blue	= BVal;
		RGBPtr[5].Red	= RVal;
		RGBPtr[5].Green	= (UINT8)DivBy5p87Table[ TimesTen[YVal] - Times2p99[RVal] - Times1p14[BVal] ];

        YVal = InvYScaleTable[YPtr2[4]];
        RVal = LimitTable[ YVal + VFactor ];
		BVal = LimitTable[ YVal + UFactor ];
		RGBPtr2[4].Blue	= BVal;
		RGBPtr2[4].Red	= RVal;
		RGBPtr2[4].Green = (UINT8)DivBy5p87Table[ TimesTen[YVal] - Times2p99[RVal] - Times1p14[BVal] ];

        YVal = InvYScaleTable[YPtr2[5]];
        RVal = LimitTable[ YVal + VFactor ];
		BVal = LimitTable[ YVal + UFactor ];
		RGBPtr2[5].Blue	= BVal;
		RGBPtr2[5].Red	= RVal;
		RGBPtr2[5].Green = (UINT8)DivBy5p87Table[ TimesTen[YVal] - Times2p99[RVal] - Times1p14[BVal] ];
		
		// Group 4
		UFactor = CalcRUTable[UPtr[3]];
		VFactor = CalcRVTable[VPtr[3]];

        YVal = InvYScaleTable[YPtr[6]];
        RVal = LimitTable[ YVal + VFactor ];
		BVal = LimitTable[ YVal + UFactor ];
		RGBPtr[6].Blue	= BVal;
		RGBPtr[6].Red	= RVal;
		RGBPtr[6].Green	= (UINT8)DivBy5p87Table[ TimesTen[YVal] - Times2p99[RVal] - Times1p14[BVal] ];

        YVal = InvYScaleTable[YPtr[7]];
        RVal = LimitTable[ YVal + VFactor ];
		BVal = LimitTable[ YVal + UFactor ];
		RGBPtr[7].Blue	= BVal;
		RGBPtr[7].Red	= RVal;
		RGBPtr[7].Green	= (UINT8)DivBy5p87Table[ TimesTen[YVal] - Times2p99[RVal] - Times1p14[BVal] ];

        YVal = InvYScaleTable[YPtr2[6]];
        RVal = LimitTable[ YVal + VFactor ];
		BVal = LimitTable[ YVal + UFactor ];
		RGBPtr2[6].Blue	= BVal;
		RGBPtr2[6].Red	= RVal;
		RGBPtr2[6].Green = (UINT8)DivBy5p87Table[ TimesTen[YVal] - Times2p99[RVal] - Times1p14[BVal] ];

        YVal = InvYScaleTable[YPtr2[7]];
        RVal = LimitTable[ YVal + VFactor ];
		BVal = LimitTable[ YVal + UFactor ];
		RGBPtr2[7].Blue	= BVal;
		RGBPtr2[7].Red	= RVal;
		RGBPtr2[7].Green = (UINT8)DivBy5p87Table[ TimesTen[YVal] - Times2p99[RVal] - Times1p14[BVal] ];
	
		// Increment the various pointers
 		YPtr += YStep;
		YPtr2 += YStep;
		UPtr += UVStep;
		VPtr += UVStep;
		RGBPtr += RGB_YStep;
		RGBPtr2 += RGB_YStep;
	}
}