364 lines
16 KiB
C
364 lines
16 KiB
C
//==========================================================================
|
|
//
|
|
// 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 */
|