//========================================================================== // // 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. // //-------------------------------------------------------------------------- #ifndef _CCLIB_H #define _CCLIB_H #include "cpuidlib.h" #ifdef __cplusplus extern "C" { #endif /* * **-CCLIB.H * * ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** * ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** * ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** * * * * The library contains color space conversion functions. The proper way to use this library is to * call InitCCLib with a value of "SpecialProc" BEFORE attempting any color space conversions. DeInitCCLib * should be called when you are done with the libary. It will preform any clean up that is necessary. * * * * * ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** * ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** * ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** Usage ** */ /* * **-InitCCLib * * This function MUST be called before attempting to use any of the functions in the library. * This function will initilize all the function pointers to point to valid routines. * * Assumptions: * Assumes that it is safe to write to the function pointers. * * Input: * CpuType - If CpuType type is set to "SpecialProc" the code will autodetect the CPU and initilize the function * pointers appropiatly. If CpuType is set to any other value it will assume that that was the CPUType * detected. NOTE: You should be careful when forcing the CPU to a specific type. If you force the * CPU type to one that is not valid for your system you will most likely crash. * * Output: * Return Non-Zero value if there was a problem initilizing the function pointers * * Function pointers RGB32toYV12FuncPtr * RGB24toYV12FuncPtr * YVYUtoYV12FuncPtr * * Initilized to point to the proper routines for this system */ int InitCCLib( PROCTYPE CpuType ); /* * **-DeInitCCLib * * You should call this function when you are done using the color conversion library. * * Assumptions: * You are done with the color conversion library and would like it to clean up after itself * * Input: * None * * Output: * No explicit return value * * color conversion library cleaned up */ void DeInitCCLib( void ); /* * *** N O T E *** N O T E *** *** N O T E *** N O T E *** *** N O T E *** N O T E *** *** N O T E *** N O T E *** *** N O T E *** N O T E *** * * * There are macros below to reduce the pain needed to use these functions * * * *** N O T E *** N O T E *** *** N O T E *** N O T E *** *** N O T E *** N O T E *** *** N O T E *** N O T E *** *** N O T E *** N O T E *** */ /* * **-RGB32toYV12FuncPtr * * This function pointer points to the fastest version of the function that will convert a RGB32 buffer to planer YV12 output * Alpha is ignored. * * InitCCLib MUST be called before using this function pointer or you will go off into the weeds. * * Inputs: * RGBABuffer - Pointer to buffer containing RGB data. We assume that data looks like * * +---+---+---+---+---+---+---+---+ * Memory Address | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | * +---+---+---+---+---+---+---+---+ * Contents | B | G | R | A | B | G | R | A | * +---+---+---+---+---+---+---+---+ * * ImageWidth - Width (in pixels) of the image to be processed * * ImageHeight - Height (in pixels) of the image to be processed * * YBuffer - Pointer to buffer where we should place the converted Y data. The caller needs to * ensure that sufficent memory is allocated. We do not check. * * UBuffer - Pointer to buffer where we should place the converted U data. The caller needs to * ensure that sufficent memory is allocated. We do not check. * * VBuffer - Pointer to buffer where we should place the converted U data. The caller needs to * ensure that sufficent memory is allocated. We do not check. * * Outputs: * YBuffer - Buffer filled with RGB data converted to YV12 format * * UBuffer - Buffer filled with RGB data converted to YV12 format * * VBuffer - Buffer filled with RGB data converted to YV12 format * * Assumptions: * Assumes that InitCCLib has been called to initilize this function pointer * * We assume that the width and height of the image passed in is even. If it is not * the last line and column will get bad U and V values. This is due to us averging * 4x4 block to get U and V values. * * Formulas: * Cb = U * Cr = V * * Y = 0.257R + 0.504G + 0.098B + 16 * Cb = -0.148R - 0.291G + 0.439B + 128 * Cr = 0.439R - 0.368G - 0.071B + 128 * * The formulas above were obtained from the book Video Demistyfied. * * The YV12 format drops every other U and V across and every other U, V vertical line. * To calculate U and V we will average the 4 RGB values before we convert to U and V. * This is slightly less accurate than converting the 4 RGB values to 4 U and V values * and then averaging the U and V values. The plus side of averaging before is that * we the coversion is about 10% faster than if we were to convert the values and then * average. * * We process the image in 2x2 blocks. From left to right then from top to bottom. * Given the following image we will process it in the following order * * 1) (0,0), (0,1), (1,0), (1,1) * 2) (0,2), (0,3), (1,2), (1,3) * 3) (2,0), (2,1), (2,2), (2,3) * 4) (3,0), (3,1), (3,2), (3,3) * * +-----+-----+-----+-----+ * | 0,0 | 0,1 | 0,2 | 0,3 | * +-----+-----+-----+-----+ * | 1,0 | 1,1 | 1,2 | 1,3 | * +-----+-----+-----+-----+ * | 2,0 | 2,1 | 2,2 | 2,3 | * +-----+-----+-----+-----+ * | 3,0 | 3,1 | 3,2 | 3,3 | * +-----+-----+-----+-----+ * * To try and avoid rounding errors we are going to scale the number and only * convert when we write the number to memory. * * When we finally scale the numbers down we will round values with fractions * greater than .5 up and less than .5 down. To achieve this we add in a round * factor which is equal to half of the amount that we divide by. * * The values that this function generates for Y, Cr, Cb are very accurate. * Utilizing double precision floating point will not generate more accurate * results. * * When converting from the 32-bit Y, Cb, Cr to the 8-bit Y, Cb, Cr values we do * not need to worry about over flowing the 8-bit value. Using the worst R, G, B * values we get the following Min and Max values for Y, Cb, Cr. * * +=====+=====+=====++=====+=====+=====++=========+ * | R | G | B || Y | Cb | Cr || | * +=====+=====+=====++=====+=====+=====++=========+ * | 255 | 255 | 0 || 210 | 16 | 146 || Min Cb | * +-----+-----+-----++-----+-----+-----++---------+ * | 0 | 0 | 255 || 40 | 239 | 109 || Max Cb | * +-----+-----+-----++-----+-----+-----++---------+ * | 0 | 255 | 255 || 169 | 165 | 16 || Min Cr | * +-----+-----+-----++-----+-----+-----++---------+ * | 255 | 0 | 0 || 81 | 90 | 239 || Max Cr | * +-----+-----+-----++-----+-----+-----++---------+ * | 0 | 0 | 0 || 16 | 128 | 128 || Min Y | * +-----+-----+-----++-----+-----+-----++---------+ * | 255 | 255 | 255 || 235 | 128 | 128 || Max Y | * +-----+-----+-----++-----+-----+-----++---------+ * * */ extern void (*RGB32toYV12FuncPtr)( unsigned char *RGBABuffer, int ImageWidth, int ImageHeight, unsigned char *YBuffer, unsigned char *UBuffer, unsigned char *VBuffer ); /* * **-RGB24toYV12FuncPtr * * This function is 99.99% the same as CC_RGB32toYV12 see comments for CC_RGB32toYV12 if you want to know how this * function works. The only difference from CC_RGB32toYV12 is we assume that * the input buffer is of the RGB 24 format given below. * * +---+---+---+---+---+---+---+---+ * Memory Address | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | * +---+---+---+---+---+---+---+---+ * Contents | B | G | R | B | G | R | B | G | * +---+---+---+---+---+---+---+---+ * */ extern void (*RGB24toYV12FuncPtr)( unsigned char *RGBBuffer, int ImageWidth, int ImageHeight, unsigned char *YBuffer, unsigned char *UBuffer, unsigned char *VBuffer ); /* * **-YVYUtoYV12FuncPtr * * This function pointer points to the fastest version of the following function that will run on * this system. * * InitCCLib MUST be called before trying to use this pointer. If you do not you will be in the * weeds * * The function will convert a YVYU (a.k.a. YUV 4:2:2) format YUV buffer to YV12 format buffer. * The YVYU format has two lines of U and V data per two lines of Y data. The YV12 format only * has one line of U, V data per two lines of Y data. To fit the extra U, V data into a single U, V * line we will average the two U, V lines. * * Example: * +--------+--------+--------+--------+--------+--------+--------+--------+-----+ * | Y(0,0) | U(0,0) | Y(0,1) | V(0,0) | Y(0,2) | U(0,1) | Y(0,1) | V(0,1) | ... | * +--------+--------+--------+--------+--------+--------+--------+--------+-----+ * | Y(1,0) | U(1,0) | Y(1,1) | V(1,0) | Y(1,2) | U(1,1) | Y(1,1) | V(1,1) | ... | * +--------+--------+--------+--------+--------+--------+--------+--------+-----+ * | Y(2,0) | U(2,0) | Y(2,1) | V(2,0) | Y(2,2) | U(2,1) | Y(2,1) | V(2,1) | ... | * +--------+--------+--------+--------+--------+--------+--------+--------+-----+ * | Y(3,0) | U(3,0) | Y(3,1) | V(3,0) | Y(3,2) | U(3,1) | Y(3,1) | V(3,1) | ... | * +--------+--------+--------+--------+--------+--------+--------+--------+-----+ * | ... | ... | ... | ... | ... | ... | ... | ... | ... | * +--------+--------+--------+--------+--------+--------+--------+--------+-----+ * * * == * * +--------+--------+--------+--------+-----+ * | Y(0,0) | Y(0,1) | Y(0,2) | Y(0,1) | ... | * +--------+--------+--------+--------+-----+ * | Y(1,0) | Y(1,1) | Y(1,2) | Y(1,1) | ... | * +--------+--------+--------+--------+-----+ * | Y(2,0) | Y(2,1) | Y(2,2) | Y(2,1) | ... | * +--------+--------+--------+--------+-----+ * | Y(3,0) | Y(3,1) | Y(3,2) | Y(3,1) | ... | * +--------+--------+--------+--------+-----+ * | ... | ... | ... | ... | ... | * +--------+--------+--------+--------+-----+ * * * +--------------------+--------------------+------+ * | AVG[U(0,0),U(1,0)] | AVG[U(0,1),U(1,1)] | ... | * +--------------------+--------------------+------+ * | AVG[U(2,0),U(3,0)] | AVG[U(2,1),U(3,1)] | ... | * +--------------------+--------------------+------+ * | ... | ... | ... | * +--------------------+--------------------+------+ * * * +--------------------+--------------------+------+ * | AVG[V(0,0),U(1,0)] | AVG[V(0,1),U(1,1)] | ... | * +--------------------+--------------------+------+ * | AVG[V(2,0),U(3,0)] | AVG[V(2,1),U(3,1)] | ... | * +--------------------+--------------------+------+ * | ... | ... | ... | * +--------------------+--------------------+------+ * * A single pass of the core look will process two horizontal lines of the image at once. * The makes it easier to average the U and V values. * * * Inputs: * YVYUBuffer - Pointer to buffer containing YVYU data. We assume that the data looks like * * +---+---+---+---+---+---+---+---+ * Memory Address | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | * +---+---+---+---+---+---+---+---+ * Contents | Y | V | Y | U | Y | V | Y | U | * +---+---+---+---+---+---+---+---+ * * ImageWidth - Width (in pixels) of the image to be processed * * ImageHeight - Height (in pixels) of the image to be processed * * YBuffer - Pointer to buffer where we should place the converted Y data. The caller needs to * ensure that sufficent memory is allocated. We do not check. * * UBuffer - Pointer to buffer where we should place the converted U data. The caller needs to * ensure that sufficent memory is allocated. We do not check. * * VBuffer - Pointer to buffer where we should place the converted U data. The caller needs to * ensure that sufficent memory is allocated. We do not check. * * Outputs: * YBuffer - Buffer filled with YVYU data converted to YV12 format * * UBuffer - Buffer filled with YVYU data converted to YV12 format * * VBuffer - Buffer filled with YVYU data converted to YV12 format * * Assumptions: * Assumes that InitCCLib has been called to initilize this function pointer * * Height of the image that we are processing is assumed to be even. If * the height is not even the last line of the image will be corrupted. * * For the C version the width of the image must be a multiple of two. For * the assembly version the width of the image must be a multiple of 8. * */ extern void (*YVYUtoYV12FuncPtr)( unsigned char *YVYUBuffer, int ImageWidth, int ImageHeight, unsigned char *YBuffer, unsigned char *UBuffer, unsigned char *VBuffer ); /* * Macros to make it easier to call the needed functions */ #define CC_RGB32toYV12( _RGBABuffer, _ImageWidth, _ImageHeight, _YBuffer, _UBuffer, _VBuffer ) \ (*RGB32toYV12FuncPtr)( _RGBABuffer, _ImageWidth, _ImageHeight, _YBuffer, _UBuffer, _VBuffer ) #define CC_RGB24toYV12( _RGBBuffer, _ImageWidth, _ImageHeight, _YBuffer, _UBuffer, _VBuffer ) \ (*RGB24toYV12FuncPtr)( _RGBBuffer, _ImageWidth, _ImageHeight, _YBuffer, _UBuffer, _VBuffer ) #define CC_YVYUtoYV12( _YVYUBuffer, _ImageWidth, _ImageHeight, _YBuffer, _UBuffer, _VBuffer ) \ (*YVYUtoYV12FuncPtr)( _YVYUBuffer, _ImageWidth, _ImageHeight, _YBuffer, _UBuffer, _VBuffer ) void ConvertRGBtoYUV( unsigned char *r_src,unsigned char *g_src,unsigned char *b_src, int width, int height, int rgb_step, int rgb_pitch, unsigned char *y_src, unsigned char *u_src, unsigned char *v_src, int uv_width_shift, int uv_height_shift, int y_step, int y_pitch,int uv_step,int uv_pitch ); #ifdef __cplusplus } #endif #endif /* _CCLIB_H */