Initial community commit

Src/libvpShared/corelibs/cdxv/dxv/win32/dkprof.c

@@ -0,0 +1,104 @@
+/***********************************************\
+??? dkprof.c
+? profiling functions
+? also see perf.asm and pentium.asm
+\***********************************************/
+#include "duck_mem.h"
+#include "dkprof.h"
+
+#define MAX_PROFILE 15
+
+int profStarted = 0;
+ 
+enum PROFILESECTION { 
+    LOSSLESSDX = 0, 
+    PLANARDX, 
+    BLITME,
+    RD_FRAME_DESC,
+    RASTER_CONFIG,
+    DELTA_TABLES,
+    HANDLER_CONFIG, 
+    STRING_DECODER,
+    STRING_DATA,
+    TSC0,
+    TSC1,
+    TSC2,
+    TSC3
+};
+
+PSECTION pSectionArray[MAX_PROFILE];
+
+unsigned long pentiumKiloCycles(void);
+
+#if 1
+/***********************************************/
+void tscStart(enum PROFILESECTION sel) 
+{
+    PSECTION *pSection;
+
+    if(profStarted) {
+        pSection = &pSectionArray[sel];
+        pSection->pkc1 = pentiumKiloCycles();
+    }        
+}
+
+/***********************************************/
+void tscEnd(enum PROFILESECTION sel) 
+{
+    PSECTION *pSection;
+
+    if(profStarted) {
+        pSection = &pSectionArray[sel];
+
+        pSection->pkc2 = pentiumKiloCycles();
+        pSection->pkc2 = (pSection->pkc2 - pSection->pkc1);
+        pSection->avgKc += pSection->pkc2;
+        pSection->numTimes += 1;
+
+        if(pSection->pkc2 < pSection->minKc)
+            pSection->minKc = pSection->pkc2;
+
+        if(pSection->pkc2 > pSection->maxKc)
+            pSection->maxKc = pSection->pkc2;
+    }
+}
+
+/***********************************************/
+void tscInit() 
+{
+    int i;
+
+    for(i=0; i<MAX_PROFILE; i++) {
+        duck_memset(&pSectionArray[i],0,sizeof(PSECTION));
+        pSectionArray[i].minKc = 0xffffffff;
+    }
+
+    profStarted = 1;
+}
+
+/***********************************************/
+void tscUninit() 
+{
+    profStarted = 0;
+}
+
+/***********************************************/
+unsigned long tscProcessCounts(unsigned long *cnt, enum PROFILESECTION sel) 
+{
+    unsigned long rv = 0;
+
+    *cnt = 0;
+    if(profStarted) {
+        if(pSectionArray[sel].numTimes) {
+            rv = pSectionArray[sel].avgKc /= pSectionArray[sel].numTimes;
+            *cnt = pSectionArray[sel].numTimes;
+            duck_memset(&pSectionArray[sel],0,sizeof(PSECTION));
+            pSectionArray[sel].minKc = 0xffffffff;
+        }
+        /* reset all vars */
+    }
+    return (rv);
+}
+#endif
+
+

Src/libvpShared/corelibs/cdxv/dxv/win32/dxAccurateTime.c

@@ -0,0 +1,30 @@
+#include "dkpltfrm.h"
+
+
+static void readTSC(UINT64 *bigOne)
+{
+	unsigned long xhigh;
+	unsigned long xlow;
+	
+	__asm 
+	{
+		
+		rdtsc
+			
+		mov [xlow],EAX;
+		mov [xhigh],edx;
+		
+	}
+	
+	*bigOne =  xhigh ;
+	*bigOne <<= 32;
+	*bigOne |= xlow;
+	
+	return;
+}
+
+
+void DXL_AccurateTime(UINT64 *temp)
+{
+	readTSC(temp);
+}

Src/libvpShared/corelibs/cdxv/dxv/win32/dxl_feat.c

@@ -0,0 +1,20 @@
+#include "dkpltfrm.h"
+#include "dxl_main.h"                                            
+
+unsigned long cpuFeatures;
+
+#define CHECK_MMX       0x800000
+#define CHECK_TSC       0x10
+#define CHECK_CMOV      0x8000
+#define CHECK_FCMOV     0x10000
+
+CPU_FEATURES DXL_GetCPUFeatures(void)
+{
+    enum CPU_FEATURES currentFeatures = NO_FEATURES;
+
+    if(cpuFeatures & CHECK_MMX)
+        currentFeatures |= MMX_SUPPORTED;
+        
+    return currentFeatures;
+}              
+

Src/libvpShared/corelibs/cdxv/dxv/win32/dxv.cpp

@@ -0,0 +1,70 @@
+#include <stdio.h>
+#include <windows.h>
+#include <windowsx.h>
+
+
+// ************************************************************************
+// FUNCTION : DllMain( HINSTANCE, DWORD, LPVOID )
+// PURPOSE  : DllMain is called by the C run-time library from the
+//            _DllMainCRTStartup entry point.  The DLL entry point gets
+//            called (entered) on the following events: "Process Attach",
+//            "Thread Attach", "Thread Detach" or "Process Detach".
+// COMMENTS : No initialization is needed here so this entry point simply
+//            returns TRUE.
+// ************************************************************************
+BOOL WINAPI
+DllMain( HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpvReserved )
+{
+  UNREFERENCED_PARAMETER( hInstDLL );
+  UNREFERENCED_PARAMETER( fdwReason );
+  UNREFERENCED_PARAMETER( lpvReserved );
+  
+  return( TRUE );
+}
+
+int DXV_GetVersion()
+{
+	return (int)0x0365;
+}
+
+extern "C" {
+
+char* pannounce;
+char *announcestart;
+#define ANNBUFSIZE 2048
+
+FILE* hf = NULL;
+
+void Announcement(const char* lpszString)
+{
+#if _DEBUG
+	if (!hf)	{
+		hf = fopen("Announce.txt","w");
+	}
+	if (hf) {
+		fprintf(hf,lpszString);
+		fflush(hf);
+	}
+#endif
+	if ((2 * strlen(lpszString) + pannounce) > announcestart + ANNBUFSIZE)	{
+		pannounce = announcestart + ANNBUFSIZE - 2 * strlen(lpszString);	// lock up at end
+	}
+	strcpy(pannounce,lpszString);  // copy and bump
+	pannounce += strlen(lpszString);
+}
+
+void AnnDone()
+{
+#if _DEBUG
+	Announcement("Closing Announcements");
+	if(hf) fclose(hf);
+//	hf = 0;			// don't reset handle or file will re-open on next call
+#endif
+}
+
+void ErrorBuffer(char *errorbuf)
+{
+	pannounce = announcestart = errorbuf;
+}
+
+}

Src/libvpShared/corelibs/cdxv/dxv/win32/dxv.def

@@ -0,0 +1,97 @@
+; -------------------------------------------------------------------------
+;
+;                       Duck Developer Support
+;              Copyright (c) 1995 Duck Corporation
+; -------------------------------------------------------------------------
+; MODULE   : Dukdll.DEF
+; PURPOSE  : module-definition file for the Duck Player
+; COMMENTS :
+; -------------------------------------------------------------------------
+;LIBRARY      DXV
+DESCRIPTION  'Duck Windows Player'
+
+EXPORTS
+	DXL_InitVideo @2
+	DXL_ExitVideo @3
+	DXL_CreateVScreen @4
+	DXL_DestroyVScreen @5
+	DXL_AlterVScreen @6
+	DXL_AlterVScreenClip @7
+	DXL_AlterVScreenView @8
+	DXL_AlterVScreenBackground @9
+	DXL_CreateXImage @10
+	DXL_DestroyXImage @11
+	DXL_AlterXImageData @12
+	DXL_MoveXImage @13
+
+;	DXL_AlterXImageSpriteModes @14
+
+	DXL_GetXImageColorDepth @15
+;	DXL_GetXImageDirtyXYWH @16
+	DXL_GetXImageXYWH @17
+	DXL_dxImageToVScreen @19
+	DXL_IsXImageKeyFrame @20
+	DXL_GetVScreenView   @21
+
+;	DXL_CreateDirtyBuffer @22
+;	DXL_DeriveVScreenFromXImage @23
+;	DXL_DisplayVScreen @24
+	DXL_SetVScreenBlitQuality @25
+	DXL_GetVScreenBlitQuality @26
+	DXL_GetVScreenAddr @27
+	DXL_CreateGenericXImage @28
+	DXL_EraseVScreen		@29
+
+	DXL_BlitXImageToVScreen @30
+
+	DXL_BlitVScreenToVScreen @31
+
+	DXL_GetXImageFrameBuffer @32
+	DXL_AlterXImage		@33
+	DXL_SetVScreenCLUTs @34
+	DXL_ResetVScreenCLUTs @35
+
+
+;	BlackBox     		@81
+
+	AnnDone				@86
+	Announcement		@88
+
+;	RestoreDirty		@90
+;	GetScreenAddr		@91
+;	resetDisplay		@92
+;	SetClutPtrs			@93
+;	MarkSkips		  	@94
+
+	DXL_Decompress16BitAs565 @107
+	
+	ErrorBuffer			@108
+	DXL_SetXImageBlitAll @109
+
+	DXV_Setmalloc		@111
+	DXV_Setcalloc		@112
+	DXV_Setfree			@113
+
+;    DUCK_rdtsc_Start    @114
+;    DUCK_rdtsc_End      @115
+;    DUCK_InitProfile    @116
+;    DUCK_ProcessCounts  @117
+;    DUCK_UninitProfile  @118
+;    DUCK_ClearI         @119
+;    DUCK_SetI           @120
+
+	DXL_CheckdxImageToVScreen @121
+	DXL_GetFourCCList @122
+	DXL_CreateXImageOfType @123
+	DXL_GetXImageCSize @124
+	DXL_GetBitDepthPalette @125
+
+	DXL_CheckVScreenBlit @126
+	DXL_CheckVScreenXImageBlit @127
+
+    DXL_BlackLineVScreen @128
+    DXL_GetCPUFeatures @129
+    DXL_GetXImageFOURCC @130
+
+	DXL_SetXImageCSize @131
+	DXL_InitVideoEx @132

Src/libvpShared/corelibs/cdxv/dxv/win32/dxv.rc

@@ -0,0 +1,126 @@
+//Microsoft Developer Studio generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "afxres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifndef MAJ 
+#define MAJ 0 
+#endif
+#ifndef MIN 
+#define MIN 0 
+#endif
+#ifndef PVER 
+#define PVER 0 
+#endif
+#ifndef BVER
+#define BVER ".b1"
+#endif
+
+#ifndef PROJ
+#define PROJ UNKNOWN!!
+#endif
+
+#define DT(x) #x
+#define VTEXT(x) DT(x)
+#define VERSTRING(w,x,y,z) DT(w) "." DT(x) "." DT(y) DT(z) "\0"
+
+#ifndef _MAC
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION 1,0,0,1
+ PRODUCTVERSION 1,0,0,1
+ FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x10004L
+ FILETYPE 0x1L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "CompanyName", "The Duck Corporation\0"
+            VALUE "FileDescription", "TruePlay SDK Library - " VTEXT(PROJ) ".dll\0"
+            VALUE "FileVersion", VERSTRING(MAJ,MIN,PVER,BVER)
+            VALUE "InternalName", "MPVE - " VTEXT(PROJ) "\0"
+            VALUE "LegalCopyright", "Copyright ©1998 The Duck Corp.\0"
+            VALUE "ProductName", "TruePlay SDK - " VTEXT(PROJ) " Library \0"
+            VALUE "ProductVersion", VERSTRING(MAJ,MIN,PVER,BVER)
+            VALUE "Providing", VTEXT(ALG)
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
+#endif    // !_MAC
+//resource
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#include ""afxres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+

Src/libvpShared/corelibs/cdxv/dxv/win32/dxv_mem.c

@@ -0,0 +1,103 @@
+/*
+    Windows 95 Memory allocation abstraction functions
+ */
+
+#include <stdio.h>
+#include <windows.h>
+
+#include "dkpltfrm.h"
+#include "duck_mem.h"
+
+#define CHECK_FOR_MEMORY_LEAK 0
+
+void *malloc_32b(size_t size)
+{
+	return LocalAlloc( LMEM_FIXED, size );
+	
+}
+void *calloc_32b(size_t count,size_t size)
+{
+	/* maybe we should rewrite this to use dwords 
+	    (who knows if they do it automatica like) */
+	return LocalAlloc( LMEM_ZEROINIT, size*count );
+	
+}
+
+void free_32b(void * hMem)
+{
+	LocalFree(hMem);
+}
+
+static void *(*ptr_malloc)(size_t size) = malloc_32b;
+static void *(*ptr_calloc)(size_t, size_t size) = calloc_32b;
+static void (*ptr_free)(void *) = free_32b;
+ 
+void *duck_malloc(size_t size, enum tmemtype fred)
+{   
+	void *temp;
+	
+	temp = (*ptr_malloc)(size);
+	
+#if CHECK_FOR_MEMORY_LEAK
+{
+	FILE * out;
+	
+	if ((out = fopen("c:\\sjl.log","a")) != NULL) {
+        fprintf(out,"DXV duck_malloc:%x %d\n", temp, size);
+        fclose(out);
+    }
+}
+#endif
+
+	return temp;
+}
+
+void *duck_calloc(size_t n,size_t size, enum tmemtype  fred)
+{   
+	void *temp = (*ptr_calloc) (n, size);
+
+#if CHECK_FOR_MEMORY_LEAK
+{
+	FILE * out;
+	
+	if ((out = fopen("c:\\sjl.log","a")) != NULL) {
+        fprintf(out,"DXV duck_calloc:%x %d %d \n", temp, n, size);
+        fclose(out);
+    }
+}
+#endif
+
+	return temp;
+}
+
+void duck_free(void *old_blk) 
+{  
+
+#if CHECK_FOR_MEMORY_LEAK
+{
+	FILE * out;
+	
+	if ((out = fopen("c:\\sjl.log","a")) != NULL) {
+        fprintf(out,"DXV duck_free:%x\n", old_blk);
+        fclose(out);
+    }
+}
+#endif
+
+	(*ptr_free) (old_blk);
+}
+
+void DXV_Setmalloc(void *(*ptr)(size_t))
+{
+	ptr_malloc = ptr;
+}
+ 
+void DXV_Setcalloc(void *(*ptr)(size_t, size_t))
+{
+	ptr_calloc = ptr;
+}
+
+void DXV_Setfree(void (*ptr)(void *))
+{
+	ptr_free = ptr;
+}

Src/libvpShared/corelibs/cdxv/dxv/win32/goals.mk

@@ -0,0 +1,9 @@
+
+$(OBJDIR)sc_$(PROJECT).lib: $(LIBDIR)\sc_tm20.lib $(LIBDIR)\sc_torq.lib
+    LIB $(OBJS) /OUT:$@
+    LIB $@ $(LIBDIR)\s_tm1.lib /OUT:$@
+    LIB $@ $(LIBDIR)\sc_tm20.lib /OUT:$@
+    LIB $@ $(LIBDIR)\s_tmrt.lib /OUT:$@
+    LIB $@ $(LIBDIR)\sc_torq.lib /OUT:$@
+    copy $@ $(LIBDIR)
+

Src/libvpShared/corelibs/cdxv/dxv/win32/icmdxv.c

@@ -0,0 +1,717 @@
+// dxvmpg.cpp : Defines the entry point for the console application.
+//
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "dkpltfrm.h" /* platform specifics */
+#include "duktypes.h" /* predefined general types used at duck */
+
+#include "duck_mem.h" /* interface to memory manager */
+#include "dxl_main.h" /* interface to dxv */
+
+#include <windows.h>
+#include <mmsystem.h>
+#include <vfw.h>
+
+
+
+/* formats that might be supported by a codec and dxv */
+/* call me crazy ... but I want to make this public ... ie in the HEADER ! */
+BMIMapping DXL_BMIMap[] = 
+{
+	{ DXL_MKFOURCC('Y','V','1','2'),	12, 3, DXYV12 },
+
+	{ DXL_MKFOURCC('I','Y','U','V'),	12, 1, DXI420 },
+
+	{ DXL_MKFOURCC('Y','U','Y','2'),	16, 1, DXYUY2 },
+
+	{ DXL_MKFOURCC('Y','V','Y','U'),	16, 1, DXYVYU },
+
+	{ DXL_MKFOURCC('U','Y','V','Y'),	16, 1, DXUYVY },
+
+	{ 0,								24, 1, DXRGB24 },
+
+	{ 0,								32, 1, DXRGB32 }
+
+};	
+
+
+
+static char *MakeFourCCString(unsigned long fcc, char *buff)
+{
+	sprintf(buff,"%c%c%c%c",
+		(fcc & 0xFF) >> 0,
+		(fcc & 0xFF00) >> 8,
+		(fcc & 0xFF0000) >> 16,
+		(fcc & 0xFF000000) >> 24
+		); 
+	return buff;
+}
+
+
+/* Report to a little HTML file */
+void DXL_ReportBMIMapping(char *filename)
+{
+	FILE *fp;
+	int len = sizeof(DXL_BMIMap) / sizeof(BMIMapping);
+
+	fp = fopen(filename,"w");
+
+	if (fp)
+	{
+		int t;
+		char temp[5];
+		fprintf(fp, "<table BORDER=1>");
+		fprintf(fp, "<tr><td>FOURCC</td><td>BitDepth</td><td>Planes</td><td>dxvBitDepth</td></tr>");
+
+		for(t = 0; t < len; t++)
+		{
+			fprintf(fp, "<tr><td>%s<br>%x</td> <td>%ld</td> <td>%ld</td>  <td>%ld</td></tr>",
+				MakeFourCCString(DXL_BMIMap[t].biCompression,temp),
+				DXL_BMIMap[t].biCompression,
+				DXL_BMIMap[t].biBitCount,
+				DXL_BMIMap[t].biPlanes,
+				DXL_BMIMap[t].bd 
+				);
+		}
+
+		fprintf(fp,"</table>");
+		fclose(fp);
+	}
+
+}
+
+
+
+
+/*********  USAGE
+
+In addition to regular DXV services, this library will invoke VFW 
+codecs for decompression services.
+
+Because of a bug in the frame parsing, the library is compiled to 
+decompress TM2X via its codec as well. So be certain to have a
+TM2X VFW codec installed.
+
+The library has only been tested with TM2X(2.5.1.8), 
+Indeo 5.2 and MPEG4.2.  Other codecs may work, but only if 
+they support RGB32, RGB24, and RGB16 (555 and/or 565).
+MS-CRAM and Cinepak crashed painfully in tests so far.
+
+The library assumes support for all 4 RGB truecolor modes 
+mentioned above, (NOTE: TM2X doesn't support RGB24 yet!)
+
+- 5/19/99 - 
+We added black-lining blitters for stretched modes.  Note that
+24 bit display uses a 32bit offscreen buffer which is blitted
+down to 24bit when stretched, this makes the asm code that much
+simpler.
+
+To use:
+
+in addition to the regular DXV, 
+link s_icm.lib to your application and do the following
+
+substitute:
+DXL_InitVideoEx(int lmaxScreens,int lmaxImages);
+in place of: 
+DXL_InitVideo(int lmaxScreens,int lmaxImages)
+
+use:
+movie->xImage = 
+DXL_AlterXImage(movie->xImage,movie->vData,
+HFB_GetStreamInfo(movie->vStream)->a.BitmapInfo.ulHandler,
+0,
+HFB_GetStreamInfo(movie->vStream)->a.BitmapInfo.usWidth,
+HFB_GetStreamInfo(movie->vStream)->a.BitmapInfo.usHeight);
+
+in place of:
+movie->xImage = DXL_CreateXImage(movie->vData);
+
+and, prior to any calls to:
+DXL_dxImageToVScreen(movie->xImage, movie->vScreen);
+
+you must call:
+DXL_SetXImageCSize(movie->xImage, movie->vLength);
+
+********/
+
+
+static dxvBitDepth bitDepths[] = 
+{
+	DXRGB32,DXRGB24,DXRGB16,DXRGBNULL
+};
+
+/* define an xImage structure based on the core xImage struct */
+
+
+
+typedef struct tXImageCODEC{  
+	xImageBaseStruct;
+
+	DK_BITMAPINFOHEADER bihIn;
+	unsigned long bihInFields[3];
+	DK_BITMAPINFOHEADER bihOut;
+	unsigned long bihOutFields[3];
+	HIC hic;
+	int changeVScreen;
+
+	BMIMapping* maps[20];
+	int maxMaps;
+
+} DXL_CODEC,*DXL_CODEC_HANDLE;
+
+
+
+
+
+char* DXL_DecodeICERR(int err, char *storage, int length)
+{
+	(void)length; // not used
+
+	switch (err)
+	{
+	case ICERR_UNSUPPORTED  :
+		strcpy(storage,"ICERR_UNSUPPORTED");
+		break;
+
+	case ICERR_BADFORMAT :
+		strcpy(storage,"ICERR_BADFORMAT");
+		break;
+
+	case ICERR_MEMORY  :
+		strcpy(storage,"ICERR_MEMORY");
+		break;
+
+	case ICERR_ERROR :
+		strcpy(storage,"ICERR_ERROR");
+		break;
+
+	default :
+		strcpy(storage,"Defaulted to ICERR_ERROR");
+		break;
+
+	}
+
+	return storage;
+}
+
+
+
+
+DK_BITMAPINFOHEADER* DXL_VSCREEN_2_BMI
+(
+ DXL_XIMAGE_HANDLE xImage, 
+ DXL_VSCREEN_HANDLE vScreen, 
+ DK_BITMAPINFOHEADER *bmih,
+ dxvBitDepth* bd1
+ )
+{
+	unsigned char *addr;
+	dxvBlitQuality bq;
+	dxvBitDepth bd;
+	short pitch;
+	short height;
+	int t;
+
+	DXL_CODEC_HANDLE src = (DXL_CODEC_HANDLE ) xImage;
+
+
+	duck_memcpy(bmih,&((DXL_CODEC_HANDLE ) xImage)->bihIn,sizeof(DK_BITMAPINFOHEADER));
+
+	DXL_GetVScreenAttributes(vScreen, (void **) &addr, &bq, &bd, &pitch, &height );
+
+	for(t = 0; t < src->maxMaps; t++)
+	{
+		if (src->maps[t]->bd == bd)
+		{
+			bmih->biBitCount		= src->maps[t]->biBitCount;
+			bmih->biCompression		= src->maps[t]->biCompression;
+			bmih->biPlanes			= src->maps[t]->biPlanes;
+
+			bmih->biWidth = pitch / (bmih->biBitCount / 8);
+			bmih->biHeight = height;
+			bmih->biSizeImage = pitch * bmih->biHeight;
+
+			fprintf(stderr,"\nBMI from VScreen attributes ...\n");
+			fprintf(stderr,"\t pitch = %ld\n", pitch);
+			fprintf(stderr,"\t width = %ld\n", bmih->biWidth);
+			fprintf(stderr,"\t height = %ld\n", bmih->biHeight);
+			fprintf(stderr,"\t biCompression = %c%c%c%c\n", 
+				((char *) &bmih->biCompression)[0],
+				((char *) &bmih->biCompression)[1],
+				((char *) &bmih->biCompression)[2],
+				((char *) &bmih->biCompression)[3]
+			);
+
+			fflush(stderr);
+
+			return bmih;
+		}
+	}
+
+	*bd1 = bd;
+
+	return 0;
+}
+
+
+
+
+int DXL_ReportBestBMIMatch(DXL_XIMAGE_HANDLE xImage, BMIMapping** map, int *maxMaps, int doConsoleReport)
+{
+	int t;
+	int ret;
+	char buff[5];
+	int len = sizeof(DXL_BMIMap)/sizeof(BMIMapping);
+	int matches = 0;
+	DXL_CODEC_HANDLE src = (DXL_CODEC_HANDLE ) xImage;
+	DK_BITMAPINFOHEADER temp;
+
+	(void)doConsoleReport; //unused
+
+	src->bihIn.dxFlavor = 2;  /* use the extended ICM functions */
+
+	duck_memcpy(&temp,&src->bihIn,sizeof(DK_BITMAPINFOHEADER));
+
+	for(t = 0; t < len; t++)  /* for each one we support with out mapping */
+	{
+
+		temp.biBitCount =	DXL_BMIMap[t].biBitCount;
+		temp.biCompression = DXL_BMIMap[t].biCompression;
+		temp.biPlanes =		DXL_BMIMap[t].biPlanes;
+		temp.biSizeImage = temp.biBitCount * temp.biWidth * temp.biHeight / 8;
+		ret =  ICDecompressQuery(src->hic, &(src->bihIn), &temp );
+
+		if (ret == ICERR_OK)
+		{
+			fprintf(stderr,"format of %s supported, planes = %ld, rank = %ld\n",
+				MakeFourCCString(temp.biCompression, buff ), temp.biPlanes, matches + 1);
+			fflush(stderr);
+
+
+			if (matches < *maxMaps)
+			{
+				src->maps[matches] = map[matches] = &DXL_BMIMap[t];
+				matches += 1;
+			}
+		}
+		else 
+		{
+			fprintf(stderr,"format of %s NOT supported, planes = %ld\n",
+				MakeFourCCString(temp.biCompression, buff ), temp.biPlanes);
+			fflush(stderr);
+
+		}
+	} 
+
+
+	src->maxMaps = *maxMaps = matches;
+
+	/* This could be done somewhere else ! */
+	duck_memset(&src->bihOut,0,sizeof(DK_BITMAPINFOHEADER));
+
+	return matches;
+}			
+
+
+
+static int decompress1(DXL_XIMAGE_HANDLE xImage, DXL_VSCREEN_HANDLE vScreen)
+{
+	/* Keep the warnings away ! */
+	DXL_CODEC_HANDLE src = (DXL_CODEC_HANDLE ) xImage;
+	//	DWORD dwFlags = 0;
+	DWORD ret;
+	dxvBitDepth bd;
+
+
+	int changeOutput = src->changeVScreen;
+
+	if (changeOutput)
+	{
+
+		/* should be cleared first time in so width zero ! */
+		if (src->bihOut.biWidth != 0)
+			ICDecompressEnd(src->hic);
+
+
+		if ( DXL_VSCREEN_2_BMI(xImage, vScreen, (DK_BITMAPINFOHEADER *) &(src->bihOut), &bd ) == 0)
+		{
+			/* user asks for unsupported surface FOURCC */
+			fprintf(stderr, "User asks for unsupported dxvBitDepth = %ld\n", bd  );
+			fflush(stderr);
+
+			return ICERR_BADFORMAT;
+		}
+
+
+		ret = ICDecompressBegin(src->hic, &src->bihIn,  &src->bihOut);
+
+
+		if (ret != ICERR_OK)
+		{
+			return ret;
+		}	
+
+	}
+
+
+	src->bihIn.biSizeImage = src->fSize;
+
+	ret = ICDecompress( src->hic, 0,
+		(BITMAPINFOHEADER *) &src->bihIn, src->addr, 
+		(BITMAPINFOHEADER *) &src->bihOut, 
+		(char *) vScreen->addr);
+
+
+	if (ret != ICERR_OK)
+	{
+		fprintf(stderr,"Oh boy decompress may have failed !\n");
+		assert(0);
+		exit(0);
+	}
+
+	src->changeVScreen = 0;
+
+	return ICERR_OK;
+}
+
+
+static int decompress2(DXL_XIMAGE_HANDLE xImage, DXL_VSCREEN_HANDLE vScreen)
+{
+	/* Keep the warnings away ! */
+	DXL_CODEC_HANDLE src = (DXL_CODEC_HANDLE ) xImage;
+	DWORD dwFlags = 0;
+	DWORD ret;
+	dxvBitDepth bd;
+
+
+	if (src->changeVScreen)
+	{
+
+		/* should be cleared first time in so width zero ! */
+		if (src->bihOut.biWidth != 0)
+			ICDecompressExEnd(src->hic);
+
+
+		if ( DXL_VSCREEN_2_BMI(xImage, vScreen, (DK_BITMAPINFOHEADER *) &(src->bihOut), &bd ) == 0)
+		{
+			/* user asks for unsupported surface FOURCC */
+			fprintf(stderr, "User asks for unsupported dxvBitDepth = %ld\n", bd  );
+			fflush(stderr);
+
+			return ICERR_BADFORMAT;
+		}
+
+
+
+		ret = ICDecompressExBegin(
+			src->hic, 
+			dwFlags,
+			(BITMAPINFOHEADER *) &(src->bihIn), 
+			src->addr,
+			0,                    
+			0,                    
+			src->bihIn.biWidth,                   
+			src->bihIn.biHeight,        
+			(BITMAPINFOHEADER *) &(src->bihOut),
+			(char *) vScreen->addr,
+			0,
+			0,
+			src->bihIn.biWidth,                   
+			src->bihIn.biHeight
+			);
+
+
+		if (ret == ICERR_UNSUPPORTED)
+		{
+			return ICERR_UNSUPPORTED;
+		}
+		if (ret != ICERR_OK)
+		{
+			char *storage = (char *) calloc(256,sizeof(char));
+			fprintf(stderr,"ICDecompressExBegin returns error code = %ld\n", ret);
+			fprintf(stderr,"Decoded as ... %s\n", DXL_DecodeICERR(ret, storage, sizeof(storage) - 1));
+			fflush(stderr);
+
+			if (storage)
+				free(storage);
+			assert(0);
+		}	
+
+
+		src->changeVScreen = 0;
+	}
+
+
+	src->bihIn.biSizeImage = src->fSize;
+
+
+	ret = ICDecompressEx(
+		src->hic,                     
+		dwFlags,               
+		(BITMAPINFOHEADER *) &src->bihIn,
+		src->addr,          
+		0,                    
+		0,                    
+		src->bihIn.biWidth,                   
+		src->bihIn.biHeight,                      
+		(BITMAPINFOHEADER *) &src->bihOut,
+		(char *) vScreen->addr,          
+		0,                    
+		0,                    
+		src->bihIn.biWidth,                   
+		src->bihIn.biHeight          
+		);
+
+
+
+	if (ret != ICERR_OK)
+	{
+		fprintf(stderr,"Oh boy decompress may have failed !\n");
+		assert(0);
+		exit(0);
+	}
+
+
+	return 0;
+}
+
+
+
+static int decompress(DXL_XIMAGE_HANDLE xImage, DXL_VSCREEN_HANDLE vScreen2)
+{
+	DXL_CODEC_HANDLE xThis = (DXL_CODEC_HANDLE) xImage;
+
+	int retVal = ICERR_OK;
+
+	/* Try the version that handles wack pitch first ! */
+	if (xThis->bihIn.dxFlavor == 2)
+	{
+		retVal = decompress2(xImage, vScreen2);
+		if (retVal == ICERR_UNSUPPORTED)
+		{
+			xThis->bihIn.dxFlavor = 1;
+		}
+	}
+
+	/* if the wack pitch one failed */
+	if (xThis->bihIn.dxFlavor == 1)
+	{
+		retVal = decompress1(xImage, vScreen2);
+	}
+
+	return retVal;
+}
+
+
+
+
+
+/* 
+close down a decompressor, releasing the icm decompressor, 
+the xImage (decompressor), and the intermediate vScreen (surface)
+*/
+
+static int destroyCodec(DXL_XIMAGE_HANDLE xImage)
+{
+	DXL_CODEC_HANDLE xThis = (DXL_CODEC_HANDLE ) xImage;
+	if (xThis)
+	{
+
+		if (xThis->hic)
+		{
+
+			ICDecompressEnd(xThis->hic);
+			ICClose(xThis->hic); 
+
+		}
+		duck_free(xThis);
+
+	}
+
+	return DXL_OK;
+}
+
+
+
+
+static char* duckToNarrow(char *s)
+{
+	char dst[256];
+
+	int t=0;
+
+	if (s)
+	{
+		do 
+		{
+			dst[t] = s[2*t];
+			t = t + 1;
+		}
+		while ( *((short *) &s[t])   );
+
+		dst[t] = '\0';
+
+		strcpy(s,dst);
+
+		return s;
+	}
+	else
+	{
+		return 0;
+	}
+
+}  /* end duckToNarrow */
+
+
+
+
+
+/* 
+called during initialization and/or when xImage (decompressor)
+attributes change, note that nImage and src are actually
+synonymous and should be cleared out a bit (to say the least!)
+
+
+!!!!!!
+This function should be prepared to get data that is NOT of the 
+type native to the decoder,  It should do it's best to verify it 
+as valid data and should clean up after itself and return NULL
+if it doesn't recognize the format of the data
+*/
+
+static DXL_XIMAGE_HANDLE reCreateCodec(DXL_CODEC_HANDLE src,unsigned char *data,
+																			 int type,enum BITDEPTH bitDepth,int w,int h)
+{  
+#pragma warning(disable: 4210) // nonstandard extension used : function given file scope
+	DXL_XIMAGE_HANDLE createCodec(unsigned char *data);
+#pragma warning(default: 4210) // nonstandard extension used : function given file scope
+
+	DXL_XIMAGE_HANDLE nImage;
+	DK_BITMAPINFOHEADER *bmiHeader = (DK_BITMAPINFOHEADER *) data;
+	unsigned long fccHandler;
+
+	(void)h; // unused
+	(void)w; // unused
+	(void)bitDepth; //unused
+	(void)type; //unused
+
+	if (src != NULL)	/* if an xImage/decompressor already exists, destroy it */
+		destroyCodec((DXL_XIMAGE_HANDLE ) src);
+
+	/* create a new xImage, specific to this type of decoder, (
+	see "DXL_CODEC" struct above and dxl_main.h) */
+
+	nImage = (DXL_XIMAGE_HANDLE)duck_calloc(1,sizeof(DXL_CODEC),DMEM_GENERAL);
+	src = (DXL_CODEC_HANDLE ) nImage;
+
+	if (!nImage) return NULL;
+
+	duck_memset(nImage,0,sizeof(DXL_CODEC));
+
+
+	src->changeVScreen = 1; /* True ... inform decompresss the dest has changed */
+
+
+	/* set up the "vtable" of interface calls */
+	src->create =  		(DXL_XIMAGE_HANDLE (*)(void *)) createCodec;
+	src->recreate =  	(DXL_XIMAGE_HANDLE (*)(DXL_XIMAGE_HANDLE,void *,int,int,int,int)) reCreateCodec;
+
+	nImage->destroy = destroyCodec;
+	nImage->dx = 		decompress;
+	nImage->blit = 		NULL; /* there is no interleaved blitter for codecs */
+
+	src->bdPrefs = 		bitDepths; /* plug in the list of prefered bit depths */
+
+	nImage->addr = data;
+	nImage->dkFlags.inUse = 1;
+
+	duck_memcpy(&src->bihIn, bmiHeader,sizeof(DK_BITMAPINFOHEADER));
+	duck_memset(&src->bihOut, 0, sizeof(DK_BITMAPINFOHEADER));
+
+	src->w = (short ) (src->bihIn.biWidth);
+	src->h = (short ) (src->bihIn.biHeight);
+
+	src->imWidth = (short) src->w;
+	src->imHeight = (short) src->h;
+
+	fccHandler = src->bihIn.fccHandler;
+
+	if (fccHandler == 0)
+	{
+		src->hic=ICLocate(ICTYPE_VIDEO, fccHandler, (BITMAPINFOHEADER *) &src->bihIn, 0, ICMODE_DECOMPRESS); 
+	}
+	else
+	{
+		src->hic=ICOpen(ICTYPE_VIDEO, fccHandler, ICMODE_DECOMPRESS); 
+	}
+
+
+
+
+	{
+		ICINFO i;
+
+		memset(&i,0,sizeof(ICINFO));
+		if (ICGetInfo( src->hic, &i, sizeof(ICINFO) ))
+		{
+
+			char temp[5];
+
+			unsigned long biCompression = src->bihIn.biCompression;
+
+			fccHandler = src->bihIn.fccHandler = i.fccHandler;
+
+
+			fprintf(stderr,	"Short Name : %s\n"
+				"Driver : %s\n"
+				"driver version = %d %d  or as hex = %x\n"
+				"Description : %s\n"
+				"Codec biCompression = %s\n"
+				"Codec fccHandler = %s\n", 
+				duckToNarrow( (char *) i.szName),
+				duckToNarrow( (char *) i.szDriver), 
+				((i.dwVersion & 0x0000FFFF) >> 0 ),  
+				((i.dwVersion & 0xFFFF0000) >> 16 ), 
+				i.dwVersion,
+				duckToNarrow( (char *) i.szDescription), 
+				MakeFourCCString(biCompression, temp),
+				MakeFourCCString(fccHandler, temp)
+				);
+			fflush(stderr);
+
+		}
+	}
+
+
+	if (src->hic == 0)
+	{
+		destroyCodec((DXL_XIMAGE_HANDLE ) src);
+
+		fprintf(stderr, "codec for fourCC = %c%c%c%c, %x won't open\n",
+			(fccHandler & 0xFF000000) >> 24,
+			(fccHandler & 0xFF0000) >> 16,
+			(fccHandler & 0xFF00) >> 8,
+			(fccHandler & 0xFF) >> 0,
+			fccHandler
+			);
+		fflush(stderr);
+
+
+		return 0;
+	}
+
+
+	return nImage;
+}
+
+/* in this "glue" case, just calls through to the create function */
+
+#pragma warning(disable:4211) //nonstandard extension used : redefined extern to static
+static DXL_XIMAGE_HANDLE createCodec(unsigned char *bmih)
+{
+	return reCreateCodec(NULL, bmih ,0,(enum BITDEPTH ) 0,0,0);
+}
+#pragma warning(default:4211) //nonstandard extension used : redefined extern to static
+

Src/libvpShared/corelibs/cdxv/dxv/win32/makefile

@@ -0,0 +1,339 @@
+everything : all 
+###### dxv standard project specs
+     
+PROJECT = dxv
+# project name
+
+# standard modules for this library
+
+OBJS = \
+    $(OBJDIR)dxlcsize.$(OBJ) \
+    $(OBJDIR)dxv_init.$(OBJ) \
+    $(OBJDIR)dxv_initex.$(OBJ) \
+    $(OBJDIR)dxl_main.$(OBJ) \
+    $(OBJDIR)vscreen.$(OBJ) \
+    $(OBJDIR)ximage.$(OBJ) \
+    $(OBJDIR)ximgblit.$(OBJ) \
+    $(OBJDIR)getprefs.$(OBJ) \
+    $(OBJDIR)dxl_clip.$(OBJ) \
+	$(OBJDIR)dxl_bkgr.$(OBJ) \
+    $(OBJDIR)dxl_view.$(OBJ) \
+	$(OBJDIR)vgetview.$(OBJ) \
+	$(OBJDIR)vscerase.$(OBJ) \
+    $(OBJDIR)dxl_attr.$(OBJ) \
+    $(OBJDIR)dxl_reg.$(OBJ) \
+    $(OBJDIR)dxl_feat.$(OBJ) \
+	$(OBJDIR)genximg.$(OBJ) \
+    $(OBJDIR)svsbitdp.$(OBJ) \
+	$(OBJDIR)vscraddr.$(OBJ) \
+    $(OBJDIR)blitall.$(OBJ) \
+    $(OBJDIR)dxlvinfd.$(OBJ) \
+    $(OBJDIR)cpuid.$(OBJ) \
+	$(OBJDIR)count_tm.$(OBJ)
+
+!ifndef NOCLUT
+
+OBJS = $(OBJS) \
+	$(OBJDIR)dxl_clut.$(OBJ)
+    
+!endif
+	
+!ifndef NOLOGO
+
+OBJS = $(OBJS) \
+	$(OBJDIR)on2logo.$(OBJ) \
+	$(OBJDIR)tmlogo55.$(OBJ) \
+	$(OBJDIR)tmlogo56.$(OBJ) \
+	$(OBJDIR)tmlogo24.$(OBJ) \
+	$(OBJDIR)ducklogo.$(OBJ) 
+
+!endif
+	
+
+MAJREV = 6		# major library revision
+MINREV = 0		# minor library revision
+PVER = 1		# minor.minor library revision
+BVER = ".b1"	# build version
+
+# libraries on which this should be built
+
+!if 0
+    $(LIBDIR)$(LIBPREFIX)tmrt$(LIBSUFFIX) \
+	$(LIBDIR)$(LIBPREFIX)tm1$(LIBSUFFIX) \
+	$(LIBDIR)$(LIBPREFIX)tm20$(LIBSUFFIX) \
+
+	$(LIBDIR)$(LIBPREFIX)vp3$(LIBSUFFIX) \
+	$(LIBDIR)$(LIBPREFIX)vp31d$(LIBSUFFIX)
+
+
+!endif
+
+!if 0
+USER_LIBS = \
+	$(LIBDIR)$(LIBPREFIX)torq$(LIBSUFFIX)
+!endif
+
+#
+# project sub options sent to compilers
+#
+!ifndef CENV
+CENV = -DTORQB -DTM1B -DTM2B -DTMRTB
+!endif
+
+# add sub-options to c options (allows for environment override)
+C_FLAGS = $(CENV)
+c_flags = $(C_FLAGS)
+
+# this proj library is to be built as a shared or master library
+SHAREDLIB = 0
+
+M_INCLUDES = -I$(INCDIR)/$(OS) -I$(INCDIR) -I. -I../generic $(M_INCLUDES)
+# win95 specific modules
+
+OBJS = $(OBJS) \
+	$(OBJDIR)dxv.$(OBJ) \
+    $(OBJDIR)dkprof.$(OBJ) \
+	$(OBJDIR)perf.$(OBJ) \
+    $(OBJDIR)pentium.$(OBJ) \
+	$(OBJDIR)$(PROJECT).res
+
+# modules specifically sent to linker,
+# others are provided in libraries
+
+DLLOBJS = $(OBJDIR)dxl_main.obj \
+	$(OBJDIR)dxv_mem.$(OBJ) \
+	$(OBJDIR)dxv_mems.$(OBJ) \
+	$(OBJDIR)$(PROJECT).res \
+	$(OBJDIR)$(PROJECT).$(OBJ)
+
+PROJLIBS = $(PROJLIBS) 
+
+#$(OBJDIR)sc_$(PROJECT).lib
+
+THISFILE = makefile
+
+SRCDIR    = .
+GENDIR    = ..\generic
+OBJDIR    = obj\  
+LIBDIR    = obj\ 
+INCDIR    = $(CORELIBS_INC)
+
+ASMDIR    = ..\X86\ 
+MMXDIR    = ..\mmx\ 
+WASMDIR   = ..\wX86\ 
+
+OBJRELDIR = $(ROOT)Object\CoreLibs\$(PROJECT)\Dx\$(OS)\Release\ 
+OBJDEBDIR = $(ROOT)Object\CoreLibs\$(PROJECT)\Dx\$(OS)\Debug\ 
+LIBRELDIR = $(ROOT)Private\CoreLibs\Lib\$(OS)\Release 
+LIBDEBDIR = $(ROOT)Private\CoreLibs\Lib\$(OS)\Debug 
+
+OBJ = obj
+
+
+MKDIR = 
+
+# tools 
+CC = cl
+ASM = tasm /ml /m8 /dWINP /zd /I$(ASMDIR) /dWIN95
+WASM = wasm /dWINP /dWIN95 /I=$(ASMDIR) /I=$(MMXDIR) -q
+RC = rc
+
+LIBNAME = $(OBJDIR)$(PROJECT).lib
+SLIBNAME = $(OBJDIR)s_$(PROJECT).lib
+EXENAME = $(OBJDIR)$(PROJECT).exe
+###DEFNAME = $(SRCDIR)$(PROJECT).DEF
+DEFNAME = $(PROJECT).DEF
+
+LIBPREFIX = \s_
+LIBSUFFIX = .lib
+
+# Include Path Variable Extensible
+include = $(SDK)/inc;$(include)
+
+
+############################################################
+# Global Flags (compiler / linker)
+C_FLAGS = $(C_FLAGS) -Gy -W3 -nologo -DWIN32 -D_MBCS -D_AFXDLL -D_WINDOWS -DHIRES\
+ -DDOS32 -c  $(M_INCLUDES:/=\) 
+#-WX
+
+L_FLAGS = $(L_FLAGS) /SUBSYSTEM:windows /INCREMENTAL:no /MACHINE:I386 
+
+############################################################
+# Locally Overridable Flags
+
+!ifndef DLLNAME
+DLLNAME = $(OBJDIR)$(PROJECT).dll
+!endif
+
+!ifndef c_thread
+
+## SJL - NEED TO USE LIBCMT NOW
+## c_thread = -MD
+c_thread = -MT
+!endif 
+
+!ifndef c_ndebugflags
+c_ndebugflags = -DNDEBUG -Ob2 -Ot -O2 -G5
+!endif 
+
+!ifndef c_debugflags
+c_debugflags = -D_DEBUG -GX -Od -Z7 
+!endif 
+
+!ifndef l_ndebugflags
+l_ndebugflags = 
+!endif 
+
+!ifndef l_debugflags
+l_debugflags = -DEBUG -DEBUGTYPE:BOTH
+!endif 
+
+# exe flags / objects
+!ifndef l_exe_flags
+l_exe_flags = 
+!endif
+
+
+# DLL flags / objects
+!ifndef l_dll_flags
+l_dll_flags = -DLL -DEF:$(DEFNAME)
+!endif
+
+!ifndef DLLOBJS
+DLLOBJS = $(OBJS)
+!endif
+
+# targets we will build
+!ifndef targets
+targets = $(SLIBNAME) 
+!ifdef SHAREDLIB
+!if $(SHAREDLIB) == 1
+targets = $(TARGETS) $(DLLNAME) 
+!endif
+!endif 
+!endif 
+
+
+# versions we will build
+!ifndef VERSIONS
+VERSIONS = release.ver debug.ver
+!endif 
+
+############################################################
+# inference rules
+#    -mkdir $(OBJDIR:\= )
+#    -mkdir $(MKOBJDIR:\= ) 
+
+# Target Directories
+#$(OBJDIR:\= ) :
+!if 0
+$(OBJDIR:\= ) :
+	mkdir $*
+	cd $* 
+!endif
+
+$(LIBDIR) :
+#    -mkdir $(LIBDIR)\..
+	-mkdir $(MKLIBDIR)
+
+# Object files 
+
+{$(GENDIR)}.c{$(OBJDIR)}.obj:
+	$(CC)  $(C_FLAGS)  $<  -Fo$@
+
+{$(GENDIR)}.cpp{$(OBJDIR)}.obj:
+	$(CC)  $(C_FLAGS)  $<  -Fo$@
+
+{$(SRCDIR)}.c{$(OBJDIR)}.obj:
+	$(CC)  $(C_FLAGS)  $<  -Fo$@
+
+{$(SRCDIR)}.cpp{$(OBJDIR)}.obj:
+	$(CC)  $(C_FLAGS)  $<  -Fo$@
+
+{$(WASMDIR)}.asm{$(OBJDIR)}.obj:
+    $(WASM) $< -fo=$@ 
+    editbin /NOLOGO /RELEASE $@
+
+{$(ASMDIR)}.asm{$(OBJDIR)}.obj:
+    $(ASM) $< $@ 
+    editbin /NOLOGO /RELEASE $@
+
+{$(SRCDIR)}.rc{$(OBJDIR)}.res:
+    $(RC) /fo$@ /dALG="$(CENV:-D= )"  /dPROJ=$(PROJECT) /dMAJ=$(MAJREV) /dMIN=$(MINREV) /dPVER=$(PVER) /dBVER=$(BVER) $< 
+
+#
+# building of targets 
+#
+
+###$(SLIBNAME): $(OBJDIR:\= ) $(LIBDIR) $(OBJS) 
+$(SLIBNAME): $(OBJS) 
+	LIB $(OBJS) /OUT:$@
+!ifdef USER_LIBS
+	for %i in ($(USER_LIBS)) do LIB $(SLIBNAME) %i /OUT:$@
+!endif
+	copy $(SLIBNAME) $(LIBDIR)
+
+##$(DLLNAME): $(SLIBNAME) $(OBJDIR:\= ) $(LIBDIR) $(DEFNAME) $(OBJDIR)$(PROJECT).res $(SLIBNAME) $(DLLOBJS)
+$(DLLNAME): $(SLIBNAME) $(LIBDIR) $(DEFNAME) $(OBJDIR)$(PROJECT).res $(SLIBNAME) $(DLLOBJS)
+	link $(L_FLAGS) $(l_dll_flags) /OUT:$(DLLNAME) $(DLLOBJS) $(SLIBNAME) /MAP:$(OBJDIR)$(PROJECT).map 
+	copy $@ $(LIBDIR)
+	copy $(LIBNAME) $(LIBDIR)
+
+$(EXENAME): $(OBJDIR:\= ) $(DEFNAME) $(OBJDIR)$(PROJECT).res $(OBJS) 
+	link $(L_FLAGS) $(l_exe_flags) /OUT:$(EXENAME) $(OBJS) /MAP:$(OBJDIR)$(PROJECT).map 
+
+#
+# Goals
+#
+build_me: $(targets) $(PROJLIBS)
+    @echo Build Completed
+
+#
+# there should be a more elegant way to build the following directories
+#
+build_dirs:
+	@echo BUILDING DIRECTORIES
+	mkdir $(ROOT)Object
+	mkdir $(ROOT)Object\CoreLibs
+	mkdir $(ROOT)Object\CoreLibs\$(PROJECT)
+	mkdir $(ROOT)Object\CoreLibs\$(PROJECT)\Dx
+	mkdir $(ROOT)Object\CoreLibs\$(PROJECT)\Dx\$(OS)
+	mkdir $(ROOT)Object\CoreLibs\$(PROJECT)\Dx\$(OS)
+	mkdir $(ROOT)Object\CoreLibs\$(PROJECT)\Dx\$(OS)\Release
+	mkdir $(ROOT)Object\CoreLibs\$(PROJECT)\Dx\$(OS)\Debug
+
+release.ver:
+    set C_FLAGS=$(C_FLAGS) $(c_ndebugflags) $(c_thread) $(c_local)
+    set L_FLAGS=$(L_FLAGS) $(l_ndebugflags)
+    set OBJDIR=$(OBJRELDIR) 
+    set LIBDIR=$(LIBRELDIR) 
+	nmake /NOLOGO /C /S build_dirs
+    nmake /NOLOGO -f $(THISFILE) build_me
+
+debug.ver:
+	@echo NOW DOING DEBUG VERSION
+    set C_FLAGS=$(C_FLAGS) $(c_debugflags) $(c_thread) $(c_local)
+    set L_FLAGS=$(L_FLAGS) $(l_debugflags)
+    set OBJDIR=$(OBJDEBDIR) 
+    set LIBDIR=$(LIBDEBDIR) 
+	nmake /NOLOGO /C /S build_dirs
+    nmake /NOLOGO -f $(THISFILE) build_me
+
+all:: $(VERSIONS)
+
+clean:
+    deltree /Y obj
+    deltree /Y obj.*
+
+
+
+
+$(OBJDIR)sc_$(PROJECT).lib: $(LIBDIR)\sc_tm20.lib $(LIBDIR)\sc_torq.lib
+    LIB $(OBJS) /OUT:$@
+    LIB $@ $(LIBDIR)\s_tm1.lib /OUT:$@
+    LIB $@ $(LIBDIR)\sc_tm20.lib /OUT:$@
+    LIB $@ $(LIBDIR)\s_tmrt.lib /OUT:$@
+    LIB $@ $(LIBDIR)\sc_torq.lib /OUT:$@
+    copy $@ $(LIBDIR)
+

Src/libvpShared/corelibs/cdxv/dxv/win32/resource.h

@@ -0,0 +1,15 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by dxv.rc
+//
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        101
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1000
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif

Src/libvpShared/corelibs/cdxv/dxv/win32/template.mk

@@ -0,0 +1,22 @@
+# win95 specific modules
+
+OBJS = $(OBJS) \
+	$(OBJDIR)dxv.$(OBJ) \
+    $(OBJDIR)dkprof.$(OBJ) \
+	$(OBJDIR)perf.$(OBJ) \
+    $(OBJDIR)pentium.$(OBJ) \
+	$(OBJDIR)$(PROJECT).res
+
+# modules specifically sent to linker,
+# others are provided in libraries
+
+DLLOBJS = $(OBJDIR)dxl_main.obj \
+	$(OBJDIR)dxv_mem.$(OBJ) \
+	$(OBJDIR)dxv_mems.$(OBJ) \
+	$(OBJDIR)$(PROJECT).res \
+	$(OBJDIR)$(PROJECT).$(OBJ)
+
+PROJLIBS = $(PROJLIBS) 
+
+#$(OBJDIR)sc_$(PROJECT).lib
+