Initial community commit

Src/libvpShared/corelibs/cdxv/dxv/generic/dxl_attr.c

@@ -0,0 +1,33 @@
+//==========================================================================
+//
+//  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.
+//
+//--------------------------------------------------------------------------
+
+
+#include "dxl_main.h"                                            
+
+int DXL_SetVScreenBlitQuality(DXL_VSCREEN_HANDLE dst, enum BLITQUALITY blitquality)                  
+{
+	int oldBQ;
+	
+	validate(dst);
+
+	oldBQ = dst->bq;
+	dst->bq = blitquality;
+
+	return oldBQ;
+}
+
+enum BLITQUALITY DXL_GetVScreenBlitQuality(DXL_VSCREEN_HANDLE dst)                  
+{
+	if (dst)	{
+		return dst->bq;
+	}
+	return DXBLIT_SAME;
+}

Src/libvpShared/corelibs/cdxv/dxv/generic/dxl_main.c

@@ -0,0 +1,69 @@
+//==========================================================================
+//
+//  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.
+//
+//--------------------------------------------------------------------------
+
+
+#include "duck_mem.h"
+#include "dxl_main.h"       
+
+static DXL_VSCREEN_HANDLE vScreens = NULL;
+static int maxScreens;
+
+int preallocVScreens(int lmaxScreens)
+{
+	(void) lmaxScreens;  // not used
+#if PRE_ALLOCATE
+    vScreens = (DXL_VSCREEN_HANDLE)duck_calloc(maxScreens = lmaxScreens,sizeof(DXL_VSCREEN),DMEM_GENERAL);
+    
+	if (vScreens == NULL) 
+		return DXL_ALLOC_FAILED;
+#endif
+	return DXL_OK;
+}
+
+void freeVScreens(void)
+{                                     
+#if PRE_ALLOCATE
+    int i;
+    
+    if (vScreens)
+	{
+        for(i = 0; i < maxScreens; i++)
+            DXL_DestroyVScreen(&vScreens[i]);
+        duck_free(vScreens);
+    }
+#endif
+}
+        
+DXL_VSCREEN_HANDLE vScreenCreate(void)
+{
+	DXL_VSCREEN_HANDLE nScreen;
+
+#if PRE_ALLOCATE
+	if (vScreens)
+	{
+		int i;
+		nScreen = vScreens;
+    
+		for(i=0; i < maxScreens; i++,nScreen++)
+			if (!nScreen->dkFlags.inUse) break;
+
+		if (i < maxScreens) 
+			return nScreen;
+    }
+#endif
+
+    nScreen = (DXL_VSCREEN_HANDLE)duck_calloc(1,sizeof(DXL_VSCREEN),DMEM_GENERAL);
+	
+	if (nScreen)
+		nScreen->dkFlags.allocated = 1;
+
+    return nScreen;
+}

Src/libvpShared/corelibs/cdxv/dxv/generic/dxl_reg.c

@@ -0,0 +1,236 @@
+//==========================================================================
+//
+//  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.
+//
+//--------------------------------------------------------------------------
+
+
+/********
+
+  DXL_REG.C - functions for registration of "Blit" functions
+  (C)1996 The Duck Corporation
+
+********/
+#include <assert.h>
+#include <dxl_main.h>
+#include <stdio.h>
+#include <string.h>
+#include "duck_mem.h"
+
+typedef struct tBlitStruct {
+	blitFunc setup, blit, exit;
+} DXL_BLITTER, DXL_BLITTER_HANDLE;
+
+static int nextBlitter = 1;
+                                  /**************/
+static DXL_BLITTER blitTable[32][DXL_MAX_IFORMATS];
+static signed char blitTranslateTable[MAX_BQUALITIES][MAX_CDEPTHS];
+
+static void nullBlitter(void){}
+
+static DXL_INTERNAL_FORMAT iFormats[] = {
+	DXL_NULL_IFORMAT,
+	DXL_NULL_IFORMAT,
+	DXL_NULL_IFORMAT,
+	DXL_NULL_IFORMAT,
+	DXL_NULL_IFORMAT,
+	DXL_NULL_IFORMAT,
+	DXL_NULL_IFORMAT,
+	DXL_NULL_IFORMAT
+};
+DXL_INTERNAL_FORMAT dxl_GetFOURCCInternalFormat(unsigned long fourcc)
+{
+	int aHandle = dxl_GetAlgHandle(fourcc);
+
+	if (aHandle != -1)
+		return iFormats[aHandle];
+
+	return DXL_NULL_IFORMAT;
+}
+
+int dxl_RegisterInternalFormat(int xHandle, DXL_INTERNAL_FORMAT xFormat)
+{
+	iFormats[xHandle] = xFormat;
+
+	return DXL_OK;
+}
+
+DXL_BLIT_FORMAT DXL_ReserveBlitter(void)
+{
+	if (nextBlitter >= 32)
+		return -1; /*DXL_EXCEEDED_MAX_BLITTERS;*/
+
+	return nextBlitter++;
+}
+
+DXL_BLIT_FORMAT DXL_OverrideBlitter(enum BLITQUALITY bq,enum BITDEPTH bd)
+{
+    if(blitTranslateTable[bq][bd] == (signed char)-1)
+	    blitTranslateTable[bq][bd] =  (char)DXL_ReserveBlitter();
+
+    return blitTranslateTable[bq][bd];
+}
+
+int DXL_RegisterBlitter(DXL_BLIT_FORMAT dFormat, DXL_INTERNAL_FORMAT sFormat, 
+						blitFunc blit, blitFunc setup, blitFunc exit)
+{
+	if ((dFormat >= nextBlitter) || (sFormat >= DXL_MAX_IFORMATS))
+		return -1; /*DXL_INVALID_BLIT_FORMAT;*/
+
+	blitTable[dFormat][sFormat].setup = setup;
+	blitTable[dFormat][sFormat].exit = exit;
+	blitTable[dFormat][sFormat].blit = blit;
+
+	return 0; /*DXL_OK;*/
+}
+
+DXL_INTERNAL_FORMAT DXL_GetXImageInternalFormat(DXL_XIMAGE_HANDLE xImage,
+												DXL_VSCREEN_HANDLE vScreen)
+{
+	int ret;
+
+	ret = xImage->internalFormat(xImage,vScreen);
+
+	if (ret == DXL_NULL_IFORMAT)
+	{
+		return (DXL_INTERNAL_FORMAT )
+			dxl_GetFOURCCInternalFormat(DXL_GetXImageFOURCC(xImage));
+	}
+	return (DXL_INTERNAL_FORMAT ) ret;
+}
+
+DXL_INTERNAL_FORMAT DXL_GetVScreenInternalFormat(DXL_VSCREEN_HANDLE vScreen)
+{
+	if (vScreen->bd == DXRGB16){
+		return DXL_LINE16;
+	}else if (vScreen->bd == DXRGB8||vScreen->bd == DXHALFTONE8){
+		return DXL_LINE8;
+	}else
+		return (DXL_INTERNAL_FORMAT) -1;
+}
+
+blitFunc DXL_GetVBlitFunc(DXL_VSCREEN_HANDLE src,DXL_VSCREEN_HANDLE dst)
+{    
+	return blitTable[DXL_GetVScreenBlitFormat(dst)]
+		[DXL_GetVScreenInternalFormat(src)].blit;
+}
+
+blitFunc DXL_GetVBlitSetupFunc(DXL_VSCREEN_HANDLE src,DXL_VSCREEN_HANDLE dst)
+{    
+	return blitTable[DXL_GetVScreenBlitFormat(dst)]
+		[DXL_GetVScreenInternalFormat(src)].setup;
+}
+
+blitFunc DXL_GetBlitFunc(DXL_XIMAGE_HANDLE xImage,DXL_VSCREEN_HANDLE vScreen)
+{   
+	DXL_BLIT_FORMAT i = DXL_GetVScreenBlitFormat(vScreen);
+	DXL_INTERNAL_FORMAT j = DXL_GetXImageInternalFormat(xImage,vScreen);
+
+	if(i == -1)
+		return (blitFunc)-1;
+
+	if(j == DXL_NULL_IFORMAT) 
+#pragma warning(disable:4054) // typecase from function pointer to data pointer
+		return (blitFunc)nullBlitter;
+#pragma warning(default:4054) // typecase from function pointer to data pointer
+	else
+		return blitTable[i][j].blit;
+}
+
+void *DXL_GetBlitSetupFunc(DXL_XIMAGE_HANDLE xImage,DXL_VSCREEN_HANDLE vScreen)
+{    
+	return blitTable[DXL_GetVScreenBlitFormat(vScreen)]
+		[DXL_GetXImageInternalFormat(xImage,vScreen)].setup;
+}
+
+void *DXL_GetBlitExitFunc(DXL_XIMAGE_HANDLE xImage,DXL_VSCREEN_HANDLE vScreen)
+{    
+	return blitTable[DXL_GetVScreenBlitFormat(vScreen)]
+		[DXL_GetXImageInternalFormat(xImage,vScreen)].exit;
+}
+ 
+DXL_BLIT_FORMAT DXL_GetVScreenBlitFormat(DXL_VSCREEN_HANDLE vScreen)
+{   enum BLITQUALITY bq;
+
+	if (vScreen->blitFormat != (signed char)-1)
+		return vScreen->blitFormat;
+		
+	bq = DXL_GetVScreenBlitQuality(vScreen);
+
+	return blitTranslateTable[bq]
+		[vScreen->bd];
+}
+
+void resetBlitters(void)
+{    
+	nextBlitter = 0;
+
+	duck_memset(blitTable,-1,sizeof(blitTable));
+	duck_memset(blitTranslateTable,-1,sizeof(blitTranslateTable));
+}
+
+
+
+int DXL_CheckFCCToVScreenFormat(unsigned long FCC,enum BITDEPTH format, enum BLITQUALITY bq)
+{
+	DXL_XIMAGE_HANDLE src;
+	DXL_VSCREEN_HANDLE dst;
+	int ret = DXL_INVALID_BLIT;
+
+	src = DXL_CreateXImageOfType(NULL,FCC);	
+	assert(src != NULL);
+
+	if (src)
+	{
+		dst = DXL_CreateVScreen(
+			(unsigned char *)0xDEADBEEF, format, 1280,480);
+
+		assert(dst != NULL);
+		if (dst)
+		{
+			dst->bq = bq;
+			ret = DXL_CheckdxImageToVScreen(src, dst);
+			DXL_DestroyVScreen(dst);
+		}
+		DXL_DestroyXImage(src);
+	}
+	return ret;
+}
+
+int DXL_CheckVScreenXImageBlit(DXL_VSCREEN_HANDLE dst,DXL_XIMAGE_HANDLE src)
+{
+    validate(src);
+
+    if (!src->dx)
+        return -1;
+	
+	if (!dst) return -1;
+
+	if (src->verify != NULL)
+		return(src->verify(src,dst));
+
+#pragma warning(disable:4054) // typecase from function pointer to data pointer
+    if((void *)(src->internalFormat) != NULL){
+        dst->blitter = DXL_GetBlitFunc(src, dst); 
+
+        if ((dst->blitter !=  (void *) -1) && (dst->blitter !=  nullBlitter))
+			return DXL_OK;
+    }
+#pragma warning(default:4054) // typecase from function pointer to data pointer
+	return DXL_INVALID_BLIT;
+}
+
+int DXL_CheckVScreenBlit(DXL_VSCREEN_HANDLE dst,unsigned long fourcc)
+{
+	return DXL_CheckFCCToVScreenFormat(fourcc,dst->bd, dst->bq);
+}
+
+int DXL_CheckdxImageToVScreen(DXL_XIMAGE_HANDLE src, DXL_VSCREEN_HANDLE dst)
+{
+	return DXL_CheckVScreenXImageBlit( dst, src);
+}

Src/libvpShared/corelibs/cdxv/dxv/generic/dxlvinfd.c

@@ -0,0 +1,76 @@
+//==========================================================================
+//
+//  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.
+//
+//--------------------------------------------------------------------------
+
+
+/*/////////////////////////////////////////////////////////////////////////
+//
+// dxlvinfd.c
+//
+// Purpose: A list of helper functions to the quick time codec code
+//
+///////////////////////////////////////////////////////////////////////*/
+
+//#include <stdio.h>
+//#include <math.h>
+//#include <string.h>
+#include "dxl_main.h"
+
+struct DisplaySetting {
+	long dotOne;
+	long dotTwo;
+	long dotThree;
+	long dotFour;
+	long dotFive;
+};
+
+static struct DisplaySetting id_RGB24 ={0x00000000,0x00000000,0xffffffff,0x00000000,0xffffffff}; 
+static struct DisplaySetting id_RGB32 ={0x00000000,0x00000000,0x00000000,0x00000000,0xffffffff}; 
+static struct DisplaySetting id_RGB555={0xffffffff,0x00000000,0xffffffff,0x00000000,0xffffffff}; 
+static struct DisplaySetting id_RGB565={0xffffffff,0x00000000,0x00000000,0x00000000,0xffffffff}; 
+static struct DisplaySetting id_UYVY  ={0xff80ff80,0x00800080,0xff80ff80,0x00800080,0x00800080}; 
+static struct DisplaySetting id_YUY2  ={0x80ff80ff,0x80008000,0x80008000,0x80008000,0x80008000}; 
+static struct DisplaySetting id_YVU9  ={0x80008000,0x80008000,0xff80ff80,0xff80ff80,0xff80ff80}; 
+static struct DisplaySetting id_RGB8  ={0x00000000,0xffffffff,0x00000000,0xffffffff,0x00000000}; 
+
+
+static struct DisplaySetting id_STRETCH 		={0x00000000,0xffffffff,0x00000000,0x00000000,0x00000000}; 
+static struct DisplaySetting id_STRETCH_BRIGHT ={0xffffffff,0xffffffff,0x00000000,0x00000000,0x00000000}; 
+static struct DisplaySetting id_STRETCH_SAME   ={0xffffffff,0x00000000,0x00000000,0x00000000,0x00000000}; 
+
+static struct DisplaySetting id_KEY 	= 	{0x00000000,0x00000000,0xffffffff,0x00000000,0x00000000}; 
+static struct DisplaySetting id_NOTKEY 	=	{0x00000000,0x00000000,0x00000000,0x00000000,0x00000000}; 
+
+static struct DisplaySetting id_CLEAR_ME 	=	{0x00000000,0x00000000,0x00000000,0x00000000,0x00000000}; 
+
+
+static void OrSettings(struct DisplaySetting *src1,struct DisplaySetting *src2, struct DisplaySetting *dst)
+{
+	if (dst) {
+		dst->dotOne = src1->dotOne | src2->dotOne;
+		dst->dotTwo = src1->dotTwo | src2->dotTwo;
+		dst->dotThree = src1->dotThree | src2->dotThree;
+		dst->dotFour = src1->dotFour | src2->dotFour;
+		dst->dotFive = src1->dotFive | src2->dotFive;
+	}
+}
+
+
+static void SetSettings(struct DisplaySetting *dst,struct DisplaySetting *src)
+{
+	if (dst) {
+		dst->dotOne = src->dotOne ;
+		dst->dotTwo = src->dotTwo ;
+		dst->dotThree = src->dotThree ;
+		dst->dotFour = src->dotFour ;
+		dst->dotFive = src->dotFive ;
+	}
+}
+

Src/libvpShared/corelibs/cdxv/dxv/generic/dxv_init.c

@@ -0,0 +1,43 @@
+//==========================================================================
+//
+//  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.
+//
+//--------------------------------------------------------------------------
+
+
+#include "duck_mem.h"
+#include "dxl_main.h"       
+
+
+#if defined(DISPLAYDIB)
+#if DISPLAYDIB
+int globalIsDIB,globalDIBWidth,globalDIBHeight;
+#endif
+#endif    
+
+extern int preallocVScreens(int lmaxScreens);
+extern void freeVScreens(void);
+
+
+int DXL_InitVideo(int lmaxScreens,int lmaxImages)
+{
+	(void)lmaxImages; // Not Used;
+/*    registerDuckBlitters(); */
+	resetBlitters();
+
+//	DXL_RegisterXImage(NULL,0L,(DXL_INTERNAL_FORMAT ) 0);
+
+	preallocVScreens(lmaxScreens);
+	return DXL_OK;
+}
+
+
+void DXL_ExitVideo(void)
+{                                     
+    freeVScreens();
+}

Src/libvpShared/corelibs/cdxv/dxv/generic/vscreen.c

@@ -0,0 +1,175 @@
+//==========================================================================
+//
+//  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.
+//
+//--------------------------------------------------------------------------
+
+
+#include "duck_mem.h"
+#include "dxl_main.h"                                            
+#include <assert.h>
+/***********************************************/
+
+int DXL_GetVScreenSizeOfPixel(DXL_VSCREEN_HANDLE vSc)
+{
+    switch (vSc->bd){
+        case DXRGB8: 
+		case DXHALFTONE8:
+        case DXRGB8VESA:            
+            return 1;
+        case DXRGB16_555:
+        case DXRGB16_565:
+        case DXRGB16VESA:
+        case DXYUY2:
+        case DXUYVY:
+            return 2;
+        case DXRGB24:
+            return 3;
+        case DXRGB32:
+			return 4;
+		default:
+			return -1;
+    }
+}
+
+void DXL_DestroyVScreen(DXL_VSCREEN_HANDLE dst)
+{
+    if (dst != NULL){
+        dst->dkFlags.inUse = 0;
+        dst->addr = NULL;
+		if (dst->dkFlags.allocated)
+			duck_free(dst);
+    }
+}
+
+int DXL_AlterVScreen(DXL_VSCREEN_HANDLE dst, unsigned char *addr,enum BITDEPTH bd, int p,int h) 
+{       
+    validate(dst);
+
+    if (addr != NULL) dst->addr = addr;
+
+    if (bd != DXRGBNULL) dst->bd = bd;
+
+    if (p != -1) dst->pitch = (short) p;
+    
+    if (h != -1) dst->height = (short) h;
+
+    return DXL_OK;
+}           
+
+int DXL_AlterVScreenView(DXL_VSCREEN_HANDLE dst,int x,int y,int w,int h)
+{
+    validate(dst);
+
+	if (x > -1)	dst->viewX = (short)x;// & 0xfffe;
+    if (y > -1)	dst->viewY = (short)y;
+    if (w > -1) dst->viewW = (short)w;// & 0xfffe;
+    if (h > -1) dst->viewH = (short)h;
+
+    return DXL_OK;
+}   
+        
+DXL_VSCREEN_HANDLE DXL_CreateVScreen(unsigned char *addr, enum BITDEPTH bd, short p,short h)
+{
+#pragma warning(disable: 4210) // nonstandard extension used : function given file scope
+	DXL_VSCREEN_HANDLE vScreenCreate(void);
+#pragma warning(default: 4210) // nonstandard extension used : function given file scope
+
+	DXL_VSCREEN_HANDLE nScreen = vScreenCreate();
+
+	if (!nScreen) return NULL;
+
+	nScreen->dkFlags.inUse = 1;
+	nScreen->blitFormat = -1;
+
+	DXL_AlterVScreen(nScreen, addr, bd, p, h);
+
+	nScreen->bx = nScreen->by = 0;
+	nScreen->bAddr = NULL;
+	nScreen->bq = DXBLIT_SAME;
+
+	return nScreen;
+}
+
+int DXL_GetVScreenView(DXL_VSCREEN_HANDLE dst,int *x,int *y,int *w,int *h)
+{
+	validate(dst);
+
+	*x = dst->viewX;
+	*y = dst->viewY;
+	*w = dst->viewW;
+	*h = dst->viewH;
+
+	return DXL_OK;
+}
+
+
+
+int DXL_GetVScreenAttributes(
+    DXL_VSCREEN_HANDLE vScreen,
+    void **addr, 
+    dxvBlitQuality *bq, 
+    dxvBitDepth *bd,
+    short *pitch, 
+    short *height
+	)
+{
+	if (addr)
+	{
+		*addr = (void *) (vScreen->addr);
+	}
+	else
+	{
+		assert(0);
+	}
+
+
+	if (bq)
+	{
+		*bq = vScreen->bq;
+	}
+	else
+	{
+		assert(0);
+	}
+
+
+
+	if (bd)
+	{
+		*bd = vScreen->bd;
+	}
+	else
+	{
+		assert(0);
+	}
+
+
+	if (pitch)
+	{
+		*pitch = vScreen->pitch;
+	}
+	else
+	{
+		assert(0);
+	}
+
+
+
+	if (height)
+	{
+		*height = vScreen->height;
+	}
+	else
+	{
+		assert(0);
+	}
+
+
+	return 0;
+}  /* end get attributes */

Src/libvpShared/corelibs/cdxv/dxv/generic/ximage.c

@@ -0,0 +1,353 @@
+//==========================================================================
+//
+//  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.
+//
+//--------------------------------------------------------------------------
+
+
+#include "duck_mem.h"
+#include "dxl_main.h" 
+
+
+
+int DXL_SetXImageCSize(DXL_XIMAGE_HANDLE src, int temp)
+{
+	src->fSize = temp;
+
+	return temp;
+}
+
+void DXL_DestroyXImage(DXL_XIMAGE_HANDLE src)
+{
+
+	{
+#pragma warning(disable:4210) //nonstandard extension used : function given file scope
+		void DXL_AccurateTime(UINT64* time);
+#pragma warning(default:4210) //nonstandard extension used : function given file scope
+
+		UINT64 clocksTotal;
+		double ratio, ratio2;
+		DXL_AccurateTime(&src->prof.profileEnd);
+		clocksTotal = (src->prof.profileEnd - src->prof.profileStart);
+		if (clocksTotal)
+		{
+			ratio = src->prof.dxClocks * 1.0 / clocksTotal;
+			ratio2 = (double)(src->prof.dxClocks / src->prof.frameCount);
+		}
+	}
+
+
+	if (src != NULL)
+	{
+		if (src->dkFlags.inUse)
+		{
+			src->destroy(src);
+		}
+	}
+}
+
+int DXL_MoveXImage(DXL_XIMAGE_HANDLE src,enum OFFSETXY mode, int x,int y)
+{
+	validate(src);
+
+	if (mode != DXL_RELATIVE){
+		src->x = 0;
+		src->y = 0;
+	}
+	src->x = (short)(src->x + x);
+	src->y = (short)(src->y + y);
+	return DXL_OK;
+}
+
+int DXL_AlterXImageData(DXL_XIMAGE_HANDLE src, unsigned char *data)
+{                    
+	validate(src);
+
+	src->addr = data;       
+	src->dkFlags.DXed = 0;
+
+	if (data == NULL) return DXL_OK;
+
+	if (src->seedData)
+		return src->seedData(src);
+	else
+		return 0;
+}
+
+int DXL_GetXImageXYWH(DXL_XIMAGE_HANDLE src,int *x,int *y,int *w, int *h)
+{
+	validate(src);
+
+	*x = src->x;
+	*y = src->y;
+	*w = src->w;
+	*h = src->h;
+
+	return DXL_OK;
+}
+
+int DXL_IsXImageKeyFrame(DXL_XIMAGE_HANDLE src)
+{
+	validate(src);
+
+	return src->dkFlags.keyFrame;
+}
+
+/* typedef DXL_XIMAGE_HANDLE (*createFunc)(unsigned char *data);   */
+#define NUM_ALG 16
+static createFunc creator[NUM_ALG];
+static unsigned long fourCC[NUM_ALG];
+
+DXL_XIMAGE_HANDLE DXL_CreateXImage(unsigned char *data)
+{
+	int i;
+	DXL_XIMAGE_HANDLE nImage = NULL;
+
+	for(i = 0; i < NUM_ALG; i++){
+		if (fourCC[i]){
+			nImage = creator[i](data);
+			if ( nImage )
+				break;
+		}else
+			break;
+	}
+
+	if (nImage) 
+	{
+		nImage->dkFlags.inUse = 1;
+		nImage->addr = data;
+		nImage->create = (struct tXImage *(__cdecl *)(void *))creator[i];
+	}
+
+	return nImage;
+}
+
+
+
+
+DXL_XIMAGE_HANDLE DXL_CreateXImageOfType(unsigned char *data,unsigned long type)
+{
+	int i;
+	DXL_XIMAGE_HANDLE nImage = NULL;
+
+	for(i = 0; i < NUM_ALG; i++){
+		if (fourCC[i] == type){
+			nImage = creator[i](data);
+			if ( nImage )
+				break;
+		}
+	}
+
+	if (nImage) 
+	{
+		nImage->dkFlags.inUse = 1;
+		nImage->addr = data;
+		nImage->prof.profileStart = 0;
+		nImage->prof.dxClocks = 0;
+		nImage->prof.frameCount = 0;
+	}
+
+	return nImage;
+}
+
+
+
+
+DXL_XIMAGE_HANDLE DXL_CreateXImageFromBMI(
+	unsigned char *data, 
+	unsigned long fcc, 
+	DK_BITMAPINFOHEADER *srcAndDest  /* There will always be two Obiwan */
+	)
+{
+	int i;
+	DXL_XIMAGE_HANDLE nImage = NULL;
+
+	for(i = 0; i < NUM_ALG; i++){
+		if (fourCC[i] == fcc){
+			nImage = creator[i]((unsigned char *) srcAndDest);
+			if ( nImage )
+				break;
+		}
+	}
+
+	if (nImage) 
+	{
+		nImage->dkFlags.inUse = 1;
+		nImage->addr = data;
+		duck_memset(&nImage->prof,0,sizeof(DXL_PROFILEPACK)); /* probably redundent */
+	}
+
+	return nImage;
+}
+
+
+
+
+
+
+int DXL_RegisterXImage(createFunc myCreator,unsigned long fourcc, DXL_INTERNAL_FORMAT xFormat)
+{
+	int i;
+
+	if (!fourcc){
+		duck_memset(creator,0,sizeof(creator));
+		duck_memset(fourCC,0,sizeof(fourCC));
+		return 0;
+	}
+
+	for (i = 0; i < sizeof(fourCC)/sizeof(unsigned long);i++){
+		if (!fourCC[i]){
+			creator[i] = myCreator;
+			fourCC[i] = fourcc;
+			dxl_RegisterInternalFormat(i, xFormat);
+			return i;
+		}
+	}
+	return -1;
+}
+
+unsigned long *DXL_GetFourCCList(void)
+{
+	/*********
+	return a list of all supported fourccs
+	*********/
+	return fourCC;
+}
+
+
+int dxl_GetAlgHandle(unsigned long fourcc)
+{
+	/*********
+	search through the fourcc table to find a dx'er's index
+	*********/
+	int i;
+
+	for (i = 0; i < sizeof(fourCC)/sizeof(unsigned long);i++)
+		if (fourCC[i] == fourcc) return i;
+
+	return -1;
+}
+
+
+unsigned long DXL_GetXImageFOURCC(DXL_XIMAGE_HANDLE src)
+{
+	/*********
+	find an ximages fourcc (by comparing creator functions)
+	*********/
+	int i;
+
+	for (i = 0; i < sizeof(fourCC)/sizeof(unsigned long);i++)
+		if (creator[i] == (createFunc)src->create) 
+			return fourCC[i];
+
+	return 0L;
+}
+
+unsigned char *DXL_GetDestAddress(DXL_XIMAGE_HANDLE src, DXL_VSCREEN_HANDLE dst)
+{
+	/*********
+	get the address within the vscreen to start writing at
+	*********/
+	unsigned char *scrnDest = (unsigned char *)0L;
+	int x,y;
+
+	y = dst->viewY + src->y;           
+	x = dst->viewX + src->x;
+
+	scrnDest = (unsigned char *) dst->addr;
+	scrnDest += (x * DXL_GetVScreenSizeOfPixel(dst)) + (y * dst->pitch);
+
+	return scrnDest;
+}
+
+int DXL_dxImageToVScreen(DXL_XIMAGE_HANDLE src, DXL_VSCREEN_HANDLE dst)
+{
+	int dxvCode; 
+	validate(src);
+
+	if (!src->dx)
+		return -1;
+
+#pragma warning(disable:4054) // typecase from function pointer to data pointer
+	if(dst && ((void *)(src->internalFormat) != NULL)) {
+		/* get your hamdy damdy((c)1997 Duck North) registered blitter setup */
+		dst->blitSetup = DXL_GetBlitSetupFunc(src,dst);
+		dst->blitExit = DXL_GetBlitExitFunc(src,dst);
+		dst->blitter = DXL_GetBlitFunc(src, dst); 
+
+		if (dst->blitter ==  (void *) -1)
+			return DXL_INVALID_BLIT;
+	}
+#pragma warning(default:4054) // typecase from function pointer to data pointer
+
+	//	if (!src->addr)
+	//		return 1;
+
+#if 1  /* we want to profile ... this should constitute no performance hit to profile */
+	{
+		UINT64 timerStart;
+		UINT64 timerEnd;
+
+		void DXL_AccurateTime(UINT64* time);
+		DXL_AccurateTime(&timerStart);
+
+		if (src->prof.profileStart == 0)
+			src->prof.profileStart = timerStart;	
+		dxvCode = src->dx(src,dst);
+		DXL_AccurateTime(&timerEnd);
+		src->prof.dxClocks += (timerEnd - timerStart);
+		src->prof.frameCount += 1;
+	}
+#else
+	dxvCode = src->dx(src,dst);
+#endif
+
+
+	return dxvCode;
+}
+
+
+long DXL_GetXImageCSize(DXL_XIMAGE_HANDLE src)
+{
+	if (src == NULL) return -1;
+
+	if (!src->GetXImageCSize)
+		return -2;
+
+	return(src->GetXImageCSize(src));
+}
+
+/***********************************************/
+
+DXL_XIMAGE_HANDLE DXL_AlterXImage(DXL_XIMAGE_HANDLE src,
+																	unsigned char *data,int type,
+																	enum BITDEPTH bitDepth,int width,int height)
+{
+	if (src == NULL)
+	{
+		if (type) /* if type specified, try using it as the fourcc */
+			src = DXL_CreateXImageOfType(data,type);
+
+		if (src == NULL) /* if still null, try creating it blind from the data */
+			src = DXL_CreateXImage(data);
+
+		if (src == NULL) /* if still null, give up */
+			return NULL;
+	}
+
+	if (!src->recreate) /* no way to recreate, assume create is good enough */
+		return src;
+
+	return(src->recreate(src,data,type,bitDepth,width,height));
+}
+
+
+void DXL_SetParameter(DXL_XIMAGE_HANDLE src, int Command, unsigned long Parameter )
+{
+	src->setParameter(src,Command,Parameter);
+}