Merge pull request #5 from WinampDesktop/community

Merge to main

1 files changed, 363 insertions, 0 deletions

diff --git a/Src/vp32/include/cclib.h b/Src/vp32/include/cclib.h
new file mode 100644
index 00000000..0822d375
--- /dev/null
+++ b/Src/vp32/include/cclib.h
@@ -0,0 +1,363 @@
+//==========================================================================
+//
+//  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 */