able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/mvdm/wow32/wdib.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

860 lines
25 KiB
C
Raw Blame History

/*++
*
* WOW v1.0
*
* Copyright (c) 1991, Microsoft Corporation
*
* WDIB.C
* DIB.DRV support
*
* History:
* 28-Apr-1994 Sudeep Bharati
* Created.
*
--*/
#include "precomp.h"
#pragma hdrstop
#include "wowgdip.h"
#include "wdib.h"
#include "memapi.h"
MODNAME(wdib.c);
#define CJSCAN(width,planes,bits) ((((width)*(planes)*(bits)+31) & ~31) / 8)
#define ABS(X) (((X) < 0 ) ? -(X) : (X))
BOOL W32CheckDibColorIndices(LPBITMAPINFOHEADER lpbmi);
// VGA colors
RGBQUAD rgbVGA[] = {
// Blue Green Red
0x00, 0x00, 0x00, 0, // 0 ; black
0x00, 0x00, 0x80, 0, // 1 ; dark red
0x00, 0x80, 0x00, 0, // 2 ; dark green
0x00, 0x80, 0x80, 0, // 3 ; mustard
0x80, 0x00, 0x00, 0, // 4 ; dark blue
0x80, 0x00, 0x80, 0, // 5 ; purple
0x80, 0x80, 0x00, 0, // 6 ; dark turquoise
0xc0, 0xc0, 0xc0, 0, // 7 ; gray
0x80, 0x80, 0x80, 0, // 8 ; dark gray
0x00, 0x00, 0xff, 0, // 9 ; red
0x00, 0xff, 0x00, 0, // a ; green
0x00, 0xff, 0xff, 0, // b ; yellow
0xff, 0x00, 0x00, 0, // c ; blue
0xff, 0x00, 0xff, 0, // d ; magenta
0xff, 0xff, 0x00, 0, // e ; cyan
0xff, 0xff, 0xff, 0 // f ; white
};
RGBQUAD rgb4[] = {
0xc0, 0xdc, 0xc0, 0, // 8
0xf0, 0xca, 0xa6, 0, // 9
0xf0, 0xfb, 0xff, 0, // 246
0xa4, 0xa0, 0xa0, 0 // 247
};
PDIBINFO pDibInfoHead = NULL;
PDIBSECTIONINFO pDibSectionInfoHead = NULL;
HDC W32HandleDibDrv (PVPVOID vpbmi16)
{
HDC hdcMem = NULL;
HBITMAP hbm = NULL;
PVOID pvBits, pvIntelBits;
STACKBMI32 bmi32;
LPBITMAPINFO lpbmi32;
DWORD dwClrUsed,nSize,nAlignmentSpace;
PBITMAPINFOHEADER16 pbmi16;
INT nbmiSize,nBytesWritten;
HANDLE hfile=NULL,hsec=NULL;
ULONG RetVal,OriginalSelLimit,SelectorLimit,OriginalFlags;
PARM16 Parm16;
CHAR pchTempFile[MAX_PATH];
BOOL bRet = FALSE;
PVPVOID vpBase16 = (PVPVOID) ((ULONG) vpbmi16 & 0xffff0000);
if ((hdcMem = W32FindAndLockDibInfo((USHORT)HIWORD(vpbmi16))) != (HDC)NULL) {
return hdcMem;
}
// First create a memory device context compatible to
// the app's current screen
if ((hdcMem = CreateCompatibleDC (NULL)) == NULL) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv CreateCompatibleDC failed\n"));
return NULL;
}
// Copy bmi16 to bmi32. DIB.DRV only supports DIB_RGB_COLORS
lpbmi32 = CopyBMI16ToBMI32(
vpbmi16,
(LPBITMAPINFO)&bmi32,
(WORD) DIB_RGB_COLORS);
// this hack for Director 4.0 does essentially what WFW does
// if this bitmap is 0 sized, just return an hDC for something simple
if(bmi32.bmiHeader.biSizeImage == 0 &&
(CURRENTPTD()->dwWOWCompatFlagsEx & WOWCFEX_DIBDRVIMAGESIZEZERO)) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv:Zero biSizeImage, returning memory DC!\n"));
return hdcMem;
}
try {
// Copy the wholething into a temp file. First get a temp file name
if ((nSize = GetTempPath (MAX_PATH, pchTempFile)) == 0 ||
nSize >= MAX_PATH)
goto hdd_err;
if (GetTempFileName (pchTempFile,
"DIB",
0,
pchTempFile) == 0)
goto hdd_err;
if ((hfile = CreateFile (pchTempFile,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_WRITE,
NULL,
CREATE_ALWAYS,
(FILE_ATTRIBUTE_NORMAL |
FILE_ATTRIBUTE_TEMPORARY |
FILE_FLAG_DELETE_ON_CLOSE),
NULL)) == INVALID_HANDLE_VALUE) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv CreateFile failed\n"));
goto hdd_err;
}
// call back to get the size of the global object
// associated with vpbmi16
Parm16.WndProc.wParam = HIWORD(vpbmi16);
CallBack16(RET_GETDIBSIZE,
&Parm16,
0,
(PVPVOID)&SelectorLimit);
Parm16.WndProc.wParam = HIWORD(vpbmi16);
if (SelectorLimit == 0xffffffff || SelectorLimit == 0) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv Invalid Selector %x\n",HIWORD(vpbmi16)));
goto hdd_err;
}
SelectorLimit++;
OriginalSelLimit = SelectorLimit;
CallBack16(RET_GETDIBFLAGS,
&Parm16,
0,
(PVPVOID)&OriginalFlags);
if (OriginalFlags == 0x4) { //GA_DGROUP
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv GA_DGROUP Not Handled\n"));
goto hdd_err;
}
GETVDMPTR(vpBase16, SelectorLimit, pbmi16);
nbmiSize = GetBMI16Size(vpbmi16, (WORD) DIB_RGB_COLORS, &dwClrUsed);
// Under NT CreateDIBSection will fail if the offset to the bits
// is not dword aligned. So we may have to add some space at the top
// of the section to get the offset correctly aligned.
nAlignmentSpace = (nbmiSize+LOWORD(vpbmi16)) % 4;
if (nAlignmentSpace) {
if (WriteFile (hfile,
pbmi16,
nAlignmentSpace,
&nBytesWritten,
NULL) == FALSE ||
nBytesWritten != (INT) nAlignmentSpace)
goto hdd_err;
}
//
// detect a clinical case of bitedit screwing around dib.drv
//
// code below is using dib macros declared in wdib.h
// namely:
// DibNumColors - yields max number of colors in dib
// DibColors - yields pointer to a dib color table
//
// Function W32CheckDibColorIndices checks to see if DIB color
// table looks like a number (defined usually by biClrImportant)
// of WORD indices in a sequential order (0, 1, 2, ...)
// if this is the case, app is trying to use undocumented feature
// of DIB.DRV that turns color matching off in this case.
// Since we cannot enforce that rule, we approximate it by filling
// color table by a number of known (and always same) entries
// When blitting occurs, no color matching will be performed (when
// both target and destination are of this very nature).
// For no reason at all we fill color table with vga colors.
// Sequential indices could have worked just as well.
//
// Modifications are made to memory pointed to by lpbmi32
if (W32CheckDibColorIndices((LPBITMAPINFOHEADER)lpbmi32)) {
BYTE i;
INT nColors;
LPBITMAPINFOHEADER lpbmi = (LPBITMAPINFOHEADER)lpbmi32;
LPRGBQUAD lprgbq = (LPRGBQUAD)DibColors(lpbmi);
nColors = DibNumColors(lpbmi);
lpbmi->biClrImportant = nColors;
switch (lpbmi->biBitCount) {
case 1:
lprgbq[0] = rgbVGA[0];
lprgbq[1] = rgbVGA[0x0f];
break;
case 4:
RtlCopyMemory(lprgbq, rgbVGA, sizeof(rgbVGA));
break;
case 8:
RtlCopyMemory(lprgbq, rgbVGA, 8*sizeof(RGBQUAD));
RtlCopyMemory(lprgbq+248, rgbVGA+8, 8*sizeof(RGBQUAD));
RtlCopyMemory(lprgbq+8, rgb4, 2*sizeof(RGBQUAD));
RtlCopyMemory(lprgbq+246, rgb4+2, 2*sizeof(RGBQUAD));
for (i = 10; i < 246; ++i) {
lprgbq[i].rgbBlue = i;
lprgbq[i].rgbGreen= 0;
lprgbq[i].rgbRed = 0;
lprgbq[i].rgbReserved = 0;
}
break;
default: // this should never happen
break;
}
}
if (WriteFile (hfile,
pbmi16,
SelectorLimit,
&nBytesWritten,
NULL) == FALSE || nBytesWritten != (INT) SelectorLimit)
goto hdd_err;
if (SelectorLimit < 64*1024) {
if (SetFilePointer (hfile,
64*1024+nAlignmentSpace,
NULL,
FILE_BEGIN) == -1)
goto hdd_err;
if (SetEndOfFile (hfile) == FALSE)
goto hdd_err;
SelectorLimit = 64*1024;
}
if ((hsec = CreateFileMapping (hfile,
NULL,
PAGE_READWRITE | SEC_COMMIT,
0,
SelectorLimit+nAlignmentSpace,
NULL)) == NULL) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv CreateFileMapping Failed\n"));
goto hdd_err;
}
// Now create the DIB section
if ((hbm = CreateDIBSection (hdcMem,
lpbmi32,
DIB_RGB_COLORS,
&pvBits,
hsec,
nAlignmentSpace + LOWORD(vpbmi16) + nbmiSize
)) == NULL) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv CreateDibSection Failed\n"));
goto hdd_err;
}
FREEVDMPTR(pbmi16);
if((pvBits = MapViewOfFile(hsec,
FILE_MAP_WRITE,
0,
0,
SelectorLimit+nAlignmentSpace)) == NULL) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv MapViewOfFile Failed\n"));
goto hdd_err;
}
pvBits = (PVOID) ((ULONG)pvBits + nAlignmentSpace);
SelectObject (hdcMem, hbm);
GdiSetBatchLimit(1);
#ifndef i386
if (!NT_SUCCESS(VdmAddVirtualMemory((ULONG)pvBits,
(ULONG)SelectorLimit,
(PULONG)&pvIntelBits))) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv VdmAddVirtualMemory failed\n"));
goto hdd_err;
}
// On risc platforms, the intel base + the intel linear address
// of the DIB section is not equal to the DIB section's process
// address. This is because of the VdmAddVirtualMemory call
// above. So here we zap the correct address into the flataddress
// array.
if (!VdmAddDescriptorMapping(HIWORD(vpbmi16),
(USHORT) ((SelectorLimit+65535)/65536),
(ULONG) pvIntelBits,
(ULONG) pvBits)) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv VdmAddDescriptorMapping failed\n"));
goto hdd_err;
}
#else
pvIntelBits = pvBits;
#endif
// Finally set the selectors to the new DIB
Parm16.WndProc.wParam = HIWORD(vpbmi16);
Parm16.WndProc.lParam = (LONG)pvIntelBits;
Parm16.WndProc.wMsg = 0x10; // GA_NOCOMPACT
Parm16.WndProc.hwnd = 1; // set so it's not randomly 0
CallBack16(RET_SETDIBSEL,
&Parm16,
0,
(PVPVOID)&RetVal);
if (!RetVal) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32HandleDibDrv Callback set_sel_for_dib failed\n"));
goto hdd_err;
}
// Store all the relevant information so that DeleteDC could
// free all the resources later.
if (W32AddDibInfo(hdcMem,
hfile,
hsec,
nAlignmentSpace,
pvBits,
pvIntelBits,
hbm,
OriginalSelLimit,
(USHORT)OriginalFlags,
(USHORT)((HIWORD(vpbmi16)))) == FALSE)
goto hdd_err;
// Finally spit out the dump for debugging
LOGDEBUG(6,("\t\tWOW::W32HandleDibDrv hdc=%04x nAlignment=%04x\n\t\tNewDib=%x OldDib=%04x:%04x DibSize=%x DibFlags=%x\n",hdcMem,nAlignmentSpace,pvBits,HIWORD(vpbmi16),LOWORD(vpbmi16),OriginalSelLimit,(USHORT)OriginalFlags));
bRet = TRUE;
hdd_err:;
}
finally {
if (!bRet) {
if (hdcMem) {
DeleteDC (hdcMem);
hdcMem = NULL;
}
if (hfile)
CloseHandle (hfile);
if (hsec)
CloseHandle (hsec);
if (hbm)
CloseHandle (hbm);
}
}
return hdcMem;
}
BOOL W32AddDibInfo (
HDC hdcMem,
HANDLE hfile,
HANDLE hsec,
ULONG nalignment,
PVOID newdib,
PVOID newIntelDib,
HBITMAP hbm,
ULONG dibsize,
USHORT originaldibflags,
USHORT originaldibsel
)
{
PDIBINFO pdi;
if ((pdi = malloc_w (sizeof (DIBINFO))) == NULL)
return FALSE;
pdi->di_hdc = hdcMem;
pdi->di_hfile = hfile;
pdi->di_hsec = hsec;
pdi->di_nalignment = nalignment;
pdi->di_newdib = newdib;
pdi->di_newIntelDib = newIntelDib;
pdi->di_hbm = hbm;
pdi->di_dibsize = dibsize;
pdi->di_originaldibsel = originaldibsel;
pdi->di_originaldibflags = originaldibflags;
pdi->di_next = pDibInfoHead;
pdi->di_lockcount = 1;
pDibInfoHead = pdi;
return TRUE;
}
BOOL W32FreeDibInfoHandle(PDIBINFO pdi, PDIBINFO pdiLast)
{
if (W32RestoreOldDib (pdi) == 0) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::W32RestoreDib failed\n"));
return FALSE;
}
#ifndef i386
VdmRemoveVirtualMemory((ULONG)pdi->di_newIntelDib);
#endif
UnmapViewOfFile ((LPVOID)((ULONG)pdi->di_newdib - pdi->di_nalignment));
DeleteObject (pdi->di_hbm);
CloseHandle (pdi->di_hsec);
CloseHandle (pdi->di_hfile);
DeleteDC(pdi->di_hdc);
W32FreeDibInfo (pdi, pdiLast);
return TRUE;
}
BOOL W32CheckAndFreeDibInfo (HDC hdc)
{
PDIBINFO pdi = pDibInfoHead,pdiLast=NULL;
while (pdi) {
if (pdi->di_hdc == hdc){
if (--pdi->di_lockcount) {
//
// This must be a releasedc within a nested call to createdc.
// Just return, as this should be released again later.
//
LOGDEBUG(LOG_ALWAYS, ("\nW32CheckAndFreeDibInfo: lockcount!=0\n"));
return TRUE;
}
return W32FreeDibInfoHandle(pdi, pdiLast);
}
pdiLast = pdi;
pdi = pdi->di_next;
}
return FALSE;
}
VOID W32FreeDibInfo (PDIBINFO pdiCur, PDIBINFO pdiLast)
{
if (pdiLast == NULL)
pDibInfoHead = pdiCur->di_next;
else
pdiLast->di_next = pdiCur->di_next;
free_w (pdiCur);
}
ULONG W32RestoreOldDib (PDIBINFO pdi)
{
PARM16 Parm16;
ULONG retval;
// callback to allocate memory and copy the dib from dib section
Parm16.WndProc.wParam = pdi->di_originaldibsel;
Parm16.WndProc.lParam = (LONG) (pdi->di_newdib);
Parm16.WndProc.wMsg = pdi->di_originaldibflags;
CallBack16(RET_FREEDIBSEL,
&Parm16,
0,
(PVPVOID)&retval);
return retval;
}
HDC W32FindAndLockDibInfo (USHORT sel)
{
PDIBINFO pdi = pDibInfoHead;
while (pdi) {
if (pdi->di_originaldibsel == sel){
pdi->di_lockcount++;
return (pdi->di_hdc);
}
pdi = pdi->di_next;
}
return (HDC) NULL;
}
//
// This function is called from krnl386 if GlobalReAlloc or GlobalFree is
// trying to operate on memory which we suspect is dib-mapped. It finds
// dib by original selector and restores it, thus allowing respective function
// to succeede. Bitedit is the app that does globalrealloc before DeleteDC
//
//
ULONG FASTCALL WK32FindAndReleaseDib(PVDMFRAME pvf)
{
USHORT sel;
PFINDANDRELEASEDIB16 parg;
PDIBINFO pdi;
PDIBINFO pdiLast = NULL;
// get the argument pointer, see wowkrnl.h
GETARGPTR(pvf, sizeof(*parg), parg);
// get selector from the handle
sel = parg->hdib | (USHORT)0x01; // "convert to sel"
// find this said sel in the dibinfo
pdi = pDibInfoHead;
while (pdi) {
if (pdi->di_originaldibsel == sel) {
// found ! this is what we are releasing or reallocating
LOGDEBUG(LOG_ALWAYS, ("\nWOW: In FindAndReleaseDIB function %d\n", (DWORD)parg->wFunId));
// see if we need to nuke...
if (--pdi->di_lockcount) {
// the problem with lock count...
LOGDEBUG(LOG_ALWAYS, ("\nWOW: FindAndReleaseDib failed (lock count!)\n"));
return FALSE;
}
return W32FreeDibInfoHandle(pdi, pdiLast);
}
pdiLast = pdi;
pdi = pdi->di_next;
}
return FALSE;
}
BOOL W32CheckDibColorIndices(LPBITMAPINFOHEADER lpbmi)
{
WORD i, nColors;
LPWORD lpw = (LPWORD)DibColors(lpbmi);
nColors = DibNumColors(lpbmi);
if (lpbmi->biClrImportant) {
nColors = min(nColors, (WORD)lpbmi->biClrImportant);
}
for (i = 0; i < nColors; ++i) {
if (*lpw++ != i) {
return FALSE;
}
}
LOGDEBUG(LOG_ALWAYS, ("\nUndocumented Dib.Drv behaviour used\n"));
return TRUE;
}
/******************************Public*Routine******************************\
* DIBSection specific calls
*
* History:
* 04-May-1994 -by- Eric Kutter [erick]
* Wrote it.
\**************************************************************************/
ULONG cjBitmapBitsSize(CONST BITMAPINFO *pbmi)
{
// Check for PM-style DIB
if (pbmi->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
{
LPBITMAPCOREINFO pbmci;
pbmci = (LPBITMAPCOREINFO)pbmi;
return(CJSCAN(pbmci->bmciHeader.bcWidth,pbmci->bmciHeader.bcPlanes,
pbmci->bmciHeader.bcBitCount) *
pbmci->bmciHeader.bcHeight);
}
// not a core header
if ((pbmi->bmiHeader.biCompression == BI_RGB) ||
(pbmi->bmiHeader.biCompression == BI_BITFIELDS))
{
return(CJSCAN(pbmi->bmiHeader.biWidth,pbmi->bmiHeader.biPlanes,
pbmi->bmiHeader.biBitCount) *
ABS(pbmi->bmiHeader.biHeight));
}
else
{
return(pbmi->bmiHeader.biSizeImage);
}
}
ULONG FASTCALL WG32CreateDIBSection(PVDMFRAME pFrame)
{
ULONG ul = 0;
STACKBMI32 bmi32;
LPBITMAPINFO lpbmi32;
HBITMAP hbm32;
PVOID pv16, pvBits, pvIntelBits;
PVPVOID vpbmi16;
PVOID pvBits32;
DWORD dwArg16;
register PCREATEDIBSECTION16 parg16;
GETARGPTR(pFrame, sizeof(CREATEDIBSECTION16), parg16);
// this is performance hack so we don't generate extra code
dwArg16 = FETCHDWORD(parg16->f4); // do it once here
pv16 = (PVOID)GetPModeVDMPointer(dwArg16, sizeof(DWORD)); // aligned here!
WOW32ASSERTMSG(((parg16->f5 == 0) && (parg16->f6 == 0)),
("WOW:WG32CreateDIBSection, hSection/dwOffset non-null\n"));
vpbmi16 = (PVPVOID)FETCHDWORD(parg16->f2);
lpbmi32 = CopyBMI16ToBMI32(vpbmi16,
(LPBITMAPINFO)&bmi32,
FETCHWORD(parg16->f3));
hbm32 = CreateDIBSection(HDC32(parg16->f1),
lpbmi32,
WORD32(parg16->f3),
&pvBits,
NULL,
0);
if (hbm32 != 0)
{
PARM16 Parm16;
PDIBSECTIONINFO pdi;
ULONG SelectorLimit;
SelectorLimit = (ULONG)cjBitmapBitsSize(lpbmi32);
#ifndef i386
if (!NT_SUCCESS(VdmAddVirtualMemory((ULONG)pvBits,
SelectorLimit,
(PULONG)&pvIntelBits))) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::WG32CreateDibSection VdmAddVirtualMemory failed\n"));
goto cds_err;
}
#else
pvIntelBits = pvBits;
#endif
// Create a selector array for the bits backed by pvIntelBits
Parm16.WndProc.wParam = (WORD)-1; // -1 => allocate selectors
Parm16.WndProc.lParam = (LONG) pvIntelBits; // backing pointer
Parm16.WndProc.wMsg = 0x10; // GA_NOCOMPACT
Parm16.WndProc.hwnd = (WORD)((SelectorLimit+65535)/65536);// selector count
CallBack16(RET_SETDIBSEL,
&Parm16,
0,
(PVPVOID)&pvBits32);
// 16:16 pointer is still valid as call above makes no difference
if (pv16 != NULL) {
*(UNALIGNED PVOID*)pv16 = pvBits32;
}
if (pvBits32 == NULL) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::WG32CreateDibSection, Callback set_sel_for_dib failed\n"));
goto cds_err;
}
#ifndef i386
// okay, that was successful - map the descriptors properly
if (!VdmAddDescriptorMapping(HIWORD(pvBits32),
(USHORT) ((SelectorLimit+65535)/65536),
(ULONG) pvIntelBits,
(ULONG) pvBits)) {
LOGDEBUG(LOG_ALWAYS,("\nWOW::WG32CreateDibSection VdmAddDescriptorMapping failed\n"));
goto cds_err;
}
#endif
LOGDEBUG(LOG_ALWAYS, ("\nWOW:CreateDIBSection: [16:16 %x] [Intel %x] [Flat %x]\n",
pvBits32, pvIntelBits, pvBits));
ul = GETHBITMAP16(hbm32);
// Add it to the list used for cleanup at DeleteObject time.
if ((pdi = malloc_w (sizeof (DIBSECTIONINFO))) != NULL) {
pdi->di_hbm = hbm32;
pdi->di_pv16 = pvBits32;
#ifndef i386
pdi->di_newIntelDib = pvIntelBits;
#endif
pdi->di_next = pDibSectionInfoHead;
pDibSectionInfoHead = pdi;
// need to turn batching off since a DIBSECTION means the app can
// also draw on the bitmap and we need synchronization.
GdiSetBatchLimit(1);
goto cds_ok;
}
else {
// Failure, free the selector array
Parm16.WndProc.wParam = (WORD)-1; // -1 => allocate/free
Parm16.WndProc.lParam = (LONG) pvBits32; // pointer
Parm16.WndProc.wMsg = 0x10; // GA_NOCOMPACT
Parm16.WndProc.hwnd = 0; // 0 => free
CallBack16(RET_SETDIBSEL,
&Parm16,
0,
(PVPVOID)&ul);
#ifndef i386
VdmRemoveVirtualMemory((ULONG)pvIntelBits);
#endif
}
}
else {
LOGDEBUG(LOG_ALWAYS,("\nWOW::WG32CreateDibSection, CreateDibSection Failed\n"));
}
cds_err:
if (hbm32 != 0) {
DeleteObject(hbm32);
}
LOGDEBUG(LOG_ALWAYS,("\nWOW::WG32CreateDibSection returning failure\n"));
ul = 0;
cds_ok:
WOW32APIWARN(ul, "CreateDIBSection");
FREEMISCPTR(pv16);
FREEARGPTR(parg16);
return(ul);
}
ULONG FASTCALL WG32GetDIBColorTable(PVDMFRAME pFrame)
{
ULONG ul = 0;
RGBQUAD * prgb;
register PGETDIBCOLORTABLE16 parg16;
GETARGPTR(pFrame, sizeof(GETDIBCOLORTABLE16), parg16);
GETMISCPTR(parg16->f4,prgb);
ul = (ULONG)GetDIBColorTable(HDC32(parg16->f1),
parg16->f2,
parg16->f3,
prgb);
WOW32APIWARN(ul, "GetDIBColorTable");
if (ul)
FLUSHVDMPTR(parg16->f4,sizeof(RGBQUAD) * ul,prgb);
FREEMISCPTR(prgb);
FREEARGPTR(parg16);
return(ul);
}
ULONG FASTCALL WG32SetDIBColorTable(PVDMFRAME pFrame)
{
ULONG ul = 0;
RGBQUAD * prgb;
register PSETDIBCOLORTABLE16 parg16;
GETARGPTR(pFrame, sizeof(SETDIBCOLORTABLE16), parg16);
GETMISCPTR(parg16->f4,prgb);
ul = (ULONG)SetDIBColorTable(HDC32(parg16->f1),
parg16->f2,
parg16->f3,
prgb);
WOW32APIWARN(ul, "SetDIBColorTable");
FREEMISCPTR(prgb);
FREEARGPTR(parg16);
return(ul);
}
// DIBSection routines
BOOL W32CheckAndFreeDibSectionInfo (HBITMAP hbm)
{
PDIBSECTIONINFO pdi = pDibSectionInfoHead,pdiLast=NULL;
while (pdi) {
if (pdi->di_hbm == hbm){
PARM16 Parm16;
ULONG ulRet;
// need to free the selector array for the memory
Parm16.WndProc.wParam = (WORD)-1; // selector, -1 == allocate/free
Parm16.WndProc.lParam = (LONG) pdi->di_pv16; // pointer
Parm16.WndProc.wMsg = 0x10; // GA_NOCOMPACT
Parm16.WndProc.hwnd = 0; // selector count, 0 == free
CallBack16(RET_SETDIBSEL,
&Parm16,
0,
(PVPVOID)&ulRet);
#ifndef i386
VdmRemoveVirtualMemory((ULONG)pdi->di_newIntelDib);
#endif
if (pdiLast == NULL)
pDibSectionInfoHead = pdi->di_next;
else
pdiLast->di_next = pdi->di_next;
// now delete the object
DeleteObject (pdi->di_hbm);
free_w(pdi);
return TRUE;
}
pdiLast = pdi;
pdi = pdi->di_next;
}
return FALSE;
}
Reference in a new issue View git blame Copy permalink