BOOL ProcessApiMon::INTViewer(IntVisitor& Visitor) { IMAGE_DOS_HEADER* pDos; IMAGE_NT_HEADERS* pNt; IMAGE_DATA_DIRECTORY* pDataDir; IMAGE_IMPORT_DESCRIPTOR* piid; HANDLE hProcess = NULL; LPVOID pBuf = NULL; BOOL ret = FALSE; DWORD nBytes; if (!(hProcess = OpenProcess(PROCESS_VM_READ, NULL, m_dwPid))) { printf("OpenProcess failed[%d]\n", GetLastError()); return FALSE; } pBuf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, m_ModuleBaseSize); if (!pBuf) { printf("HeapAlloc failed[%d]\n", GetLastError()); goto $Cleanup; } if (!ReadProcessMemory(hProcess, m_ModulepBaseMem, pBuf, m_ModuleBaseSize, &nBytes)) { printf("ReadProcessMemory failed[%d]\n", GetLastError()); goto $Cleanup; } pDos = (IMAGE_DOS_HEADER*)pBuf; if (pDos->e_magic != IMAGE_DOS_SIGNATURE) goto $Cleanup; pNt = (IMAGE_NT_HEADERS*)XGetPtr(pBuf, (DWORD_PTR)pDos->e_lfanew); if (pNt->Signature != IMAGE_NT_SIGNATURE) goto $Cleanup; pDataDir = &pNt->OptionalHeader.DataDirectory[1]; piid = (IMAGE_IMPORT_DESCRIPTOR*)XGetPtr(pBuf, (DWORD_PTR)pDataDir->VirtualAddress); for (DWORD i = 0; piid[i].Name; i++) { try { if (!Visitor.visit(piid[i], pBuf)) break; } catch (...) { goto $Cleanup; } } ret = TRUE; $Cleanup: if (hProcess) CloseHandle(hProcess); if (pBuf) HeapFree(GetProcessHeap(), 0, pBuf); return ret; }
static BOOL wined3d_dll_init(HINSTANCE hInstDLL) { DWORD wined3d_context_tls_idx; HMODULE mod; char buffer[MAX_PATH+10]; DWORD size = sizeof(buffer); HKEY hkey = 0; HKEY appkey = 0; DWORD len, tmpvalue; WNDCLASSA wc; wined3d_context_tls_idx = TlsAlloc(); if (wined3d_context_tls_idx == TLS_OUT_OF_INDEXES) { DWORD err = GetLastError(); ERR("Failed to allocate context TLS index, err %#x.\n", err); return FALSE; } context_set_tls_idx(wined3d_context_tls_idx); /* We need our own window class for a fake window which we use to retrieve GL capabilities */ /* We might need CS_OWNDC in the future if we notice strange things on Windows. * Various articles/posts about OpenGL problems on Windows recommend this. */ wc.style = CS_HREDRAW | CS_VREDRAW; wc.lpfnWndProc = DefWindowProcA; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = hInstDLL; wc.hIcon = LoadIconA(NULL, (LPCSTR)IDI_WINLOGO); wc.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW); wc.hbrBackground = NULL; wc.lpszMenuName = NULL; wc.lpszClassName = WINED3D_OPENGL_WINDOW_CLASS_NAME; if (!RegisterClassA(&wc)) { ERR("Failed to register window class 'WineD3D_OpenGL'!\n"); if (!TlsFree(wined3d_context_tls_idx)) { DWORD err = GetLastError(); ERR("Failed to free context TLS index, err %#x.\n", err); } return FALSE; } DisableThreadLibraryCalls(hInstDLL); mod = GetModuleHandleA( "winex11.drv" ); if (mod) { wine_tsx11_lock_ptr = (void *)GetProcAddress( mod, "wine_tsx11_lock" ); wine_tsx11_unlock_ptr = (void *)GetProcAddress( mod, "wine_tsx11_unlock" ); } else /* We are most likely on Windows */ { wine_tsx11_lock_ptr = wined3d_do_nothing; wine_tsx11_unlock_ptr = wined3d_do_nothing; } /* @@ Wine registry key: HKCU\Software\Wine\Direct3D */ if ( RegOpenKeyA( HKEY_CURRENT_USER, "Software\\Wine\\Direct3D", &hkey ) ) hkey = 0; len = GetModuleFileNameA( 0, buffer, MAX_PATH ); if (len && len < MAX_PATH) { HKEY tmpkey; /* @@ Wine registry key: HKCU\Software\Wine\AppDefaults\app.exe\Direct3D */ if (!RegOpenKeyA( HKEY_CURRENT_USER, "Software\\Wine\\AppDefaults", &tmpkey )) { char *p, *appname = buffer; if ((p = strrchr( appname, '/' ))) appname = p + 1; if ((p = strrchr( appname, '\\' ))) appname = p + 1; strcat( appname, "\\Direct3D" ); TRACE("appname = [%s]\n", appname); if (RegOpenKeyA( tmpkey, appname, &appkey )) appkey = 0; RegCloseKey( tmpkey ); } } if (hkey || appkey) { if ( !get_config_key( hkey, appkey, "VertexShaderMode", buffer, size) ) { if (!strcmp(buffer,"none")) { TRACE("Disable vertex shaders\n"); wined3d_settings.vs_mode = VS_NONE; } } if ( !get_config_key( hkey, appkey, "PixelShaderMode", buffer, size) ) { if (!strcmp(buffer,"enabled")) { TRACE("Allow pixel shaders\n"); wined3d_settings.ps_mode = PS_HW; } if (!strcmp(buffer,"disabled")) { TRACE("Disable pixel shaders\n"); wined3d_settings.ps_mode = PS_NONE; } } if ( !get_config_key( hkey, appkey, "UseGLSL", buffer, size) ) { if (!strcmp(buffer,"disabled")) { TRACE("Use of GL Shading Language disabled\n"); wined3d_settings.glslRequested = FALSE; } } if ( !get_config_key( hkey, appkey, "OffscreenRenderingMode", buffer, size) ) { if (!strcmp(buffer,"backbuffer")) { TRACE("Using the backbuffer for offscreen rendering\n"); wined3d_settings.offscreen_rendering_mode = ORM_BACKBUFFER; } else if (!strcmp(buffer,"fbo")) { TRACE("Using FBOs for offscreen rendering\n"); wined3d_settings.offscreen_rendering_mode = ORM_FBO; } } if ( !get_config_key( hkey, appkey, "RenderTargetLockMode", buffer, size) ) { if (!strcmp(buffer,"disabled")) { TRACE("Disabling render target locking\n"); wined3d_settings.rendertargetlock_mode = RTL_DISABLE; } else if (!strcmp(buffer,"readdraw")) { TRACE("Using glReadPixels for render target reading and glDrawPixels for writing\n"); wined3d_settings.rendertargetlock_mode = RTL_READDRAW; } else if (!strcmp(buffer,"readtex")) { TRACE("Using glReadPixels for render target reading and textures for writing\n"); wined3d_settings.rendertargetlock_mode = RTL_READTEX; } } if ( !get_config_key_dword( hkey, appkey, "VideoPciDeviceID", &tmpvalue) ) { int pci_device_id = tmpvalue; /* A pci device id is 16-bit */ if(pci_device_id > 0xffff) { ERR("Invalid value for VideoPciDeviceID. The value should be smaller or equal to 65535 or 0xffff\n"); } else { TRACE("Using PCI Device ID %04x\n", pci_device_id); wined3d_settings.pci_device_id = pci_device_id; } } if ( !get_config_key_dword( hkey, appkey, "VideoPciVendorID", &tmpvalue) ) { int pci_vendor_id = tmpvalue; /* A pci device id is 16-bit */ if(pci_vendor_id > 0xffff) { ERR("Invalid value for VideoPciVendorID. The value should be smaller or equal to 65535 or 0xffff\n"); } else { TRACE("Using PCI Vendor ID %04x\n", pci_vendor_id); wined3d_settings.pci_vendor_id = pci_vendor_id; } } if ( !get_config_key( hkey, appkey, "VideoMemorySize", buffer, size) ) { int TmpVideoMemorySize = atoi(buffer); if(TmpVideoMemorySize > 0) { wined3d_settings.emulated_textureram = TmpVideoMemorySize *1024*1024; TRACE("Use %iMB = %d byte for emulated_textureram\n", TmpVideoMemorySize, wined3d_settings.emulated_textureram); } else ERR("VideoMemorySize is %i but must be >0\n", TmpVideoMemorySize); } if ( !get_config_key( hkey, appkey, "WineLogo", buffer, size) ) { size_t len = strlen(buffer) + 1; wined3d_settings.logo = HeapAlloc(GetProcessHeap(), 0, len); if (!wined3d_settings.logo) ERR("Failed to allocate logo path memory.\n"); else memcpy(wined3d_settings.logo, buffer, len); } if ( !get_config_key( hkey, appkey, "Multisampling", buffer, size) ) { if (!strcmp(buffer,"enabled")) { TRACE("Allow multisampling\n"); wined3d_settings.allow_multisampling = TRUE; } } if (!get_config_key(hkey, appkey, "StrictDrawOrdering", buffer, size) && !strcmp(buffer,"enabled")) { TRACE("Enforcing strict draw ordering.\n"); wined3d_settings.strict_draw_ordering = TRUE; } } if (wined3d_settings.vs_mode == VS_HW) TRACE("Allow HW vertex shaders\n"); if (wined3d_settings.ps_mode == PS_NONE) TRACE("Disable pixel shaders\n"); if (wined3d_settings.glslRequested) TRACE("If supported by your system, GL Shading Language will be used\n"); if (appkey) RegCloseKey( appkey ); if (hkey) RegCloseKey( hkey ); return TRUE; }
static void test_32bit_win(void) { DWORD hdlA, retvalA; DWORD hdlW, retvalW = 0; BOOL retA,retW; PVOID pVersionInfoA = NULL; PVOID pVersionInfoW = NULL; char *pBufA; WCHAR *pBufW; UINT uiLengthA, uiLengthW; char mypathA[MAX_PATH]; WCHAR mypathW[MAX_PATH]; char rootA[] = "\\"; WCHAR rootW[] = { '\\', 0 }; WCHAR emptyW[] = { 0 }; char varfileinfoA[] = "\\VarFileInfo\\Translation"; WCHAR varfileinfoW[] = { '\\','V','a','r','F','i','l','e','I','n','f','o', '\\','T','r','a','n','s','l','a','t','i','o','n', 0 }; char WineVarFileInfoA[] = { 0x09, 0x04, 0xE4, 0x04 }; char FileDescriptionA[] = "\\StringFileInfo\\040904E4\\FileDescription"; WCHAR FileDescriptionW[] = { '\\','S','t','r','i','n','g','F','i','l','e','I','n','f','o', '\\','0','4','0','9','0','4','E','4', '\\','F','i','l','e','D','e','s','c','r','i','p','t','i','o','n', 0 }; char WineFileDescriptionA[] = "FileDescription"; WCHAR WineFileDescriptionW[] = { 'F','i','l','e','D','e','s','c','r','i','p','t','i','o','n', 0 }; BOOL is_unicode_enabled = TRUE; /* A copy from dlls/version/info.c */ typedef struct { WORD wLength; WORD wValueLength; WORD wType; WCHAR szKey[1]; #if 0 /* variable length structure */ /* DWORD aligned */ BYTE Value[]; /* DWORD aligned */ VS_VERSION_INFO_STRUCT32 Children[]; #endif } VS_VERSION_INFO_STRUCT32; /* If we call GetFileVersionInfoA on a system that supports Unicode, NT/W2K/XP/W2K3 (by default) and Wine, * the versioninfo will contain Unicode strings. * Part of the test is to call both the A and W versions, which should have the same Version Information * for some requests, on systems that support both calls. */ /* First get the versioninfo via the W versions */ SetLastError(0xdeadbeef); GetModuleFileNameW(NULL, mypathW, MAX_PATH); if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) { win_skip("GetModuleFileNameW not existing on this platform, skipping comparison between A- and W-calls\n"); is_unicode_enabled = FALSE; } if (is_unicode_enabled) { retvalW = GetFileVersionInfoSizeW( mypathW, &hdlW); pVersionInfoW = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, retvalW ); retW = GetFileVersionInfoW( mypathW, 0, retvalW, pVersionInfoW ); ok(retW, "GetFileVersionInfo failed: GetLastError = %u\n", GetLastError()); } GetModuleFileNameA(NULL, mypathA, MAX_PATH); retvalA = GetFileVersionInfoSizeA( mypathA, &hdlA); pVersionInfoA = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, retvalA ); retA = GetFileVersionInfoA( mypathA, 0, retvalA, pVersionInfoA ); ok(retA, "GetFileVersionInfo failed: GetLastError = %u\n", GetLastError()); if (is_unicode_enabled) { ok( retvalA == retvalW, "The size of the struct should be the same for both A/W calls, it is (%d) vs. (%d)\n", retvalA, retvalW); ok( !memcmp(pVersionInfoA, pVersionInfoW, retvalA), "Both structs should be the same, they aren't\n"); } /* The structs on Windows are bigger than just the struct for the basic information. The total struct * contains also an empty part, which is used for converted strings. The converted strings are a result * of calling VerQueryValueA on a 32bit resource and calling VerQueryValueW on a 16bit resource. * The first WORD of the structure (wLength) shows the size of the base struct. The total struct size depends * on the Windows version: * * 16bits resource (numbers are from a sample app): * * Windows Version Retrieved with A/W wLength StructSize * ==================================================================================== * Win98 A 0x01B4 (436) 436 * NT4 A/W 0x01B4 (436) 2048 ??? * W2K/XP/W2K3 A/W 0x01B4 (436) 1536 which is (436 - sizeof(VS_FIXEDFILEINFO)) * 4 * * 32bits resource (numbers are from this test executable version_crosstest.exe): * Windows Version Retrieved with A/W wLength StructSize * ============================================================= * Win98 A 0x01E0 (480) 848 (structure data doesn't seem correct) * NT4 A/W 0x0350 (848) 1272 (848 * 1.5) * W2K/XP/W2K3 A/W 0x0350 (848) 1700 which is (848 * 2) + 4 * * Wine will follow the implementation (eventually) of W2K/XP/W2K3 */ /* Now some tests for the above (only if we are unicode enabled) */ if (is_unicode_enabled) { VS_VERSION_INFO_STRUCT32 *vvis = pVersionInfoW; ok ( retvalW == ((vvis->wLength * 2) + 4) || retvalW == (vvis->wLength * 1.5), "Structure is not of the correct size\n"); } /* Although the 32bit resource structures contain Unicode strings, VerQueryValueA will always return normal strings, * VerQueryValueW will always return Unicode ones. (That means everything returned for StringFileInfo requests). */ /* Get the VS_FIXEDFILEINFO information, this must be the same for both A- and W-Calls */ retA = VerQueryValueA( pVersionInfoA, rootA, (LPVOID *)&pBufA, &uiLengthA ); ok (retA, "VerQueryValueA failed: GetLastError = %u\n", GetLastError()); ok ( uiLengthA == sizeof(VS_FIXEDFILEINFO), "Size (%d) doesn't match the size of the VS_FIXEDFILEINFO struct\n", uiLengthA); if (is_unicode_enabled) { if(0) { /* This causes Vista and w2k8 to crash */ retW = VerQueryValueW( pVersionInfoW, NULL, (LPVOID *)&pBufW, &uiLengthW ); ok (retW, "VerQueryValueW failed: GetLastError = %u\n", GetLastError()); } retW = VerQueryValueW( pVersionInfoW, emptyW, (LPVOID *)&pBufW, &uiLengthW ); ok (retW, "VerQueryValueW failed: GetLastError = %u\n", GetLastError()); retW = VerQueryValueW( pVersionInfoW, rootW, (LPVOID *)&pBufW, &uiLengthW ); ok (retW, "VerQueryValueW failed: GetLastError = %u\n", GetLastError()); ok ( uiLengthW == sizeof(VS_FIXEDFILEINFO), "Size (%d) doesn't match the size of the VS_FIXEDFILEINFO struct\n", uiLengthW ); ok( uiLengthA == uiLengthW, "The size of VS_FIXEDFILEINFO should be the same for both A/W calls, it is (%d) vs. (%d)\n", uiLengthA, uiLengthW); ok( !memcmp(pBufA, pBufW, uiLengthA), "Both values should be the same, they aren't\n"); } /* Get some VarFileInfo information, this must be the same for both A- and W-Calls */ retA = VerQueryValueA( pVersionInfoA, varfileinfoA, (LPVOID *)&pBufA, &uiLengthA ); ok (retA, "VerQueryValueA failed: GetLastError = %u\n", GetLastError()); ok( !memcmp(pBufA, WineVarFileInfoA, uiLengthA), "The VarFileInfo should have matched 0904e404 (non case sensitive)\n"); if (is_unicode_enabled) { retW = VerQueryValueW( pVersionInfoW, varfileinfoW, (LPVOID *)&pBufW, &uiLengthW ); ok (retW, "VerQueryValueW failed: GetLastError = %u\n", GetLastError()); ok( uiLengthA == uiLengthW, "The size of the VarFileInfo information should be the same for both A/W calls, it is (%d) vs. (%d)\n", uiLengthA, uiLengthW); ok( !memcmp(pBufA, pBufW, uiLengthA), "Both values should be the same, they aren't\n"); } /* Get some StringFileInfo information, this will be ANSI for A-Calls and Unicode for W-Calls */ retA = VerQueryValueA( pVersionInfoA, FileDescriptionA, (LPVOID *)&pBufA, &uiLengthA ); ok (retA, "VerQueryValueA failed: GetLastError = %u\n", GetLastError()); ok( !lstrcmpA(WineFileDescriptionA, pBufA), "expected '%s' got '%s'\n", WineFileDescriptionA, pBufA); /* Test a second time */ retA = VerQueryValueA( pVersionInfoA, FileDescriptionA, (LPVOID *)&pBufA, &uiLengthA ); ok (retA, "VerQueryValueA failed: GetLastError = %u\n", GetLastError()); ok( !lstrcmpA(WineFileDescriptionA, pBufA), "expected '%s' got '%s'\n", WineFileDescriptionA, pBufA); if (is_unicode_enabled) { retW = VerQueryValueW( pVersionInfoW, FileDescriptionW, (LPVOID *)&pBufW, &uiLengthW ); ok (retW, "VerQueryValueW failed: GetLastError = %u\n", GetLastError()); ok( !lstrcmpW(WineFileDescriptionW, pBufW), "FileDescription should have been '%s'\n", WineFileDescriptionA); } HeapFree( GetProcessHeap(), 0, pVersionInfoA); if (is_unicode_enabled) HeapFree( GetProcessHeap(), 0, pVersionInfoW); }
static void wave_in_test_device(UINT_PTR device) { WAVEINCAPSA capsA; WAVEINCAPSW capsW; WAVEFORMATEX format; WAVEFORMATEXTENSIBLE wfex; HWAVEIN win; MMRESULT rc; UINT f; WCHAR * nameW; CHAR * nameA; DWORD size; DWORD dwPageSize; BYTE * twoPages; SYSTEM_INFO sSysInfo; DWORD flOldProtect; BOOL res; GetSystemInfo(&sSysInfo); dwPageSize = sSysInfo.dwPageSize; rc=waveInGetDevCapsA(device,&capsA,sizeof(capsA)); ok(rc==MMSYSERR_NOERROR || rc==MMSYSERR_BADDEVICEID || rc==MMSYSERR_NODRIVER, "waveInGetDevCapsA(%s): failed to get capabilities: rc=%s\n", dev_name(device),wave_in_error(rc)); if (rc==MMSYSERR_BADDEVICEID || rc==MMSYSERR_NODRIVER) return; rc=waveInGetDevCapsW(device,&capsW,sizeof(capsW)); ok(rc==MMSYSERR_NOERROR || rc==MMSYSERR_NOTSUPPORTED, "waveInGetDevCapsW(%s): MMSYSERR_NOERROR or MMSYSERR_NOTSUPPORTED " "expected, got %s\n",dev_name(device),wave_in_error(rc)); rc=waveInGetDevCapsA(device,NULL,sizeof(capsA)); ok(rc==MMSYSERR_INVALPARAM, "waveInGetDevCapsA(%s): MMSYSERR_INVALPARAM expected, got %s\n", dev_name(device),wave_in_error(rc)); rc=waveInGetDevCapsW(device,NULL,sizeof(capsW)); ok(rc==MMSYSERR_INVALPARAM || rc==MMSYSERR_NOTSUPPORTED, "waveInGetDevCapsW(%s): MMSYSERR_INVALPARAM or MMSYSERR_NOTSUPPORTED " "expected, got %s\n",dev_name(device),wave_in_error(rc)); if (0) { /* FIXME: this works on windows but crashes wine */ rc=waveInGetDevCapsA(device,(LPWAVEINCAPSA)1,sizeof(capsA)); ok(rc==MMSYSERR_INVALPARAM, "waveInGetDevCapsA(%s): MMSYSERR_INVALPARAM expected, got %s\n", dev_name(device),wave_in_error(rc)); rc=waveInGetDevCapsW(device,(LPWAVEINCAPSW)1,sizeof(capsW)); ok(rc==MMSYSERR_INVALPARAM || rc==MMSYSERR_NOTSUPPORTED, "waveInGetDevCapsW(%s): MMSYSERR_INVALPARAM or MMSYSERR_NOTSUPPORTED " "expected, got %s\n",dev_name(device),wave_in_error(rc)); } rc=waveInGetDevCapsA(device,&capsA,4); ok(rc==MMSYSERR_NOERROR, "waveInGetDevCapsA(%s): MMSYSERR_NOERROR expected, got %s\n", dev_name(device),wave_in_error(rc)); rc=waveInGetDevCapsW(device,&capsW,4); ok(rc==MMSYSERR_NOERROR || rc==MMSYSERR_NOTSUPPORTED || rc==MMSYSERR_INVALPARAM, /* Vista, W2K8 */ "waveInGetDevCapsW(%s): unexpected return value %s\n", dev_name(device),wave_in_error(rc)); nameA=NULL; rc=waveInMessage((HWAVEIN)device, DRV_QUERYDEVICEINTERFACESIZE, (DWORD_PTR)&size, 0); ok(rc==MMSYSERR_NOERROR || rc==MMSYSERR_INVALPARAM || rc==MMSYSERR_NOTSUPPORTED, "waveInMessage(%s): failed to get interface size: rc=%s\n", dev_name(device),wave_in_error(rc)); if (rc==MMSYSERR_NOERROR) { nameW = HeapAlloc(GetProcessHeap(), 0, size); rc=waveInMessage((HWAVEIN)device, DRV_QUERYDEVICEINTERFACE, (DWORD_PTR)nameW, size); ok(rc==MMSYSERR_NOERROR,"waveInMessage(%s): failed to get interface " "name: rc=%s\n",dev_name(device),wave_in_error(rc)); ok(lstrlenW(nameW)+1==size/sizeof(WCHAR), "got an incorrect size %d\n", size); if (rc==MMSYSERR_NOERROR) { nameA = HeapAlloc(GetProcessHeap(), 0, size/sizeof(WCHAR)); WideCharToMultiByte(CP_ACP, 0, nameW, size/sizeof(WCHAR), nameA, size/sizeof(WCHAR), NULL, NULL); } HeapFree(GetProcessHeap(), 0, nameW); } else if (rc==MMSYSERR_NOTSUPPORTED) { nameA=HeapAlloc(GetProcessHeap(), 0, sizeof("not supported")); strcpy(nameA, "not supported"); } trace(" %s: \"%s\" (%s) %d.%d (%d:%d)\n",dev_name(device),capsA.szPname, (nameA?nameA:"failed"),capsA.vDriverVersion >> 8, capsA.vDriverVersion & 0xff,capsA.wMid,capsA.wPid); trace(" channels=%d formats=%05x\n", capsA.wChannels,capsA.dwFormats); HeapFree(GetProcessHeap(), 0, nameA); for (f=0;f<NB_WIN_FORMATS;f++) { format.wFormatTag=WAVE_FORMAT_PCM; format.nChannels=win_formats[f][3]; format.wBitsPerSample=win_formats[f][2]; format.nSamplesPerSec=win_formats[f][1]; format.nBlockAlign=format.nChannels*format.wBitsPerSample/8; format.nAvgBytesPerSec=format.nSamplesPerSec*format.nBlockAlign; format.cbSize=0; wave_in_test_deviceIn(device,&format,win_formats[f][0],0, &capsA); if (device != WAVE_MAPPER) { wave_in_test_deviceIn(device,&format,win_formats[f][0], WAVE_FORMAT_DIRECT, &capsA); wave_in_test_deviceIn(device,&format,win_formats[f][0], WAVE_MAPPED, &capsA); } } /* Try a PCMWAVEFORMAT aligned next to an unaccessible page for bounds * checking */ twoPages = VirtualAlloc(NULL, 2 * dwPageSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE); ok(twoPages!=NULL,"Failed to allocate 2 pages of memory\n"); if (twoPages) { res = VirtualProtect(twoPages + dwPageSize, dwPageSize, PAGE_NOACCESS, &flOldProtect); ok(res, "Failed to set memory access on second page\n"); if (res) { LPWAVEFORMATEX pwfx = (LPWAVEFORMATEX)(twoPages + dwPageSize - sizeof(PCMWAVEFORMAT)); pwfx->wFormatTag=WAVE_FORMAT_PCM; pwfx->nChannels=1; pwfx->wBitsPerSample=8; pwfx->nSamplesPerSec=22050; pwfx->nBlockAlign=pwfx->nChannels*pwfx->wBitsPerSample/8; pwfx->nAvgBytesPerSec=pwfx->nSamplesPerSec*pwfx->nBlockAlign; wave_in_test_deviceIn(device,pwfx,WAVE_FORMAT_2M08,0, &capsA); if (device != WAVE_MAPPER) { wave_in_test_deviceIn(device,pwfx,WAVE_FORMAT_2M08, WAVE_FORMAT_DIRECT, &capsA); wave_in_test_deviceIn(device,pwfx,WAVE_FORMAT_2M08, WAVE_MAPPED, &capsA); } } VirtualFree(twoPages, 2 * dwPageSize, MEM_RELEASE); } /* test non PCM formats */ format.wFormatTag=WAVE_FORMAT_MULAW; format.nChannels=1; format.wBitsPerSample=8; format.nSamplesPerSec=8000; format.nBlockAlign=format.nChannels*format.wBitsPerSample/8; format.nAvgBytesPerSec=format.nSamplesPerSec*format.nBlockAlign; format.cbSize=0; rc=waveInOpen(&win,device,&format,0,0,CALLBACK_NULL|WAVE_FORMAT_DIRECT); ok(rc==MMSYSERR_NOERROR || rc==WAVERR_BADFORMAT || rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM, "waveInOpen(%s): returned: %s\n",dev_name(device),wave_in_error(rc)); if (rc==MMSYSERR_NOERROR) { waveInClose(win); wave_in_test_deviceIn(device,&format,0,0,&capsA); } else trace("waveInOpen(%s): WAVE_FORMAT_MULAW not supported\n", dev_name(device)); format.wFormatTag=WAVE_FORMAT_ADPCM; format.nChannels=2; format.wBitsPerSample=4; format.nSamplesPerSec=22050; format.nBlockAlign=format.nChannels*format.wBitsPerSample/8; format.nAvgBytesPerSec=format.nSamplesPerSec*format.nBlockAlign; format.cbSize=0; rc=waveInOpen(&win,device,&format,0,0,CALLBACK_NULL|WAVE_FORMAT_DIRECT); ok(rc==MMSYSERR_NOERROR || rc==WAVERR_BADFORMAT || rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM, "waveInOpen(%s): returned: %s\n",dev_name(device),wave_in_error(rc)); if (rc==MMSYSERR_NOERROR) { waveInClose(win); wave_in_test_deviceIn(device,&format,0,0,&capsA); } else trace("waveInOpen(%s): WAVE_FORMAT_ADPCM not supported\n", dev_name(device)); /* test if WAVEFORMATEXTENSIBLE supported */ wfex.Format.wFormatTag=WAVE_FORMAT_EXTENSIBLE; wfex.Format.nChannels=2; wfex.Format.wBitsPerSample=16; wfex.Format.nSamplesPerSec=22050; wfex.Format.nBlockAlign=wfex.Format.nChannels*wfex.Format.wBitsPerSample/8; wfex.Format.nAvgBytesPerSec=wfex.Format.nSamplesPerSec* wfex.Format.nBlockAlign; wfex.Format.cbSize=22; wfex.Samples.wValidBitsPerSample=wfex.Format.wBitsPerSample; wfex.dwChannelMask=SPEAKER_ALL; wfex.SubFormat=KSDATAFORMAT_SUBTYPE_PCM; rc=waveInOpen(&win,device,&wfex.Format,0,0, CALLBACK_NULL|WAVE_FORMAT_DIRECT); ok(rc==MMSYSERR_NOERROR || rc==WAVERR_BADFORMAT || rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM, "waveInOpen(%s): returned: %s\n",dev_name(device),wave_in_error(rc)); if (rc==MMSYSERR_NOERROR) { waveInClose(win); wave_in_test_deviceIn(device,&wfex.Format,0,0,&capsA); } else trace("waveInOpen(%s): WAVE_FORMAT_EXTENSIBLE not supported\n", dev_name(device)); /* test if 4 channels supported */ wfex.Format.wFormatTag=WAVE_FORMAT_EXTENSIBLE; wfex.Format.nChannels=4; wfex.Format.wBitsPerSample=16; wfex.Format.nSamplesPerSec=22050; wfex.Format.nBlockAlign=wfex.Format.nChannels*wfex.Format.wBitsPerSample/8; wfex.Format.nAvgBytesPerSec=wfex.Format.nSamplesPerSec* wfex.Format.nBlockAlign; wfex.Format.cbSize=22; wfex.Samples.wValidBitsPerSample=wfex.Format.wBitsPerSample; wfex.dwChannelMask=SPEAKER_ALL; wfex.SubFormat=KSDATAFORMAT_SUBTYPE_PCM; rc=waveInOpen(&win,device,&wfex.Format,0,0, CALLBACK_NULL|WAVE_FORMAT_DIRECT); ok(rc==MMSYSERR_NOERROR || rc==WAVERR_BADFORMAT || rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM, "waveInOpen(%s): returned: %s\n",dev_name(device),wave_in_error(rc)); if (rc==MMSYSERR_NOERROR) { waveInClose(win); wave_in_test_deviceIn(device,&wfex.Format,0,0,&capsA); } else trace("waveInOpen(%s): 4 channels not supported\n", dev_name(device)); /* test if 6 channels supported */ wfex.Format.wFormatTag=WAVE_FORMAT_EXTENSIBLE; wfex.Format.nChannels=6; wfex.Format.wBitsPerSample=16; wfex.Format.nSamplesPerSec=22050; wfex.Format.nBlockAlign=wfex.Format.nChannels*wfex.Format.wBitsPerSample/8; wfex.Format.nAvgBytesPerSec=wfex.Format.nSamplesPerSec* wfex.Format.nBlockAlign; wfex.Format.cbSize=22; wfex.Samples.wValidBitsPerSample=wfex.Format.wBitsPerSample; wfex.dwChannelMask=SPEAKER_ALL; wfex.SubFormat=KSDATAFORMAT_SUBTYPE_PCM; rc=waveInOpen(&win,device,&wfex.Format,0,0, CALLBACK_NULL|WAVE_FORMAT_DIRECT); ok(rc==MMSYSERR_NOERROR || rc==WAVERR_BADFORMAT || rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM, "waveInOpen(%s): returned: %s\n",dev_name(device),wave_in_error(rc)); if (rc==MMSYSERR_NOERROR) { waveInClose(win); wave_in_test_deviceIn(device,&wfex.Format,0,0,&capsA); } else trace("waveInOpen(%s): 6 channels not supported\n", dev_name(device)); if (0) { /* FIXME: ALSA doesn't like this */ /* test if 24 bit samples supported */ wfex.Format.wFormatTag=WAVE_FORMAT_EXTENSIBLE; wfex.Format.nChannels=2; wfex.Format.wBitsPerSample=24; wfex.Format.nSamplesPerSec=22050; wfex.Format.nBlockAlign=wfex.Format.nChannels*wfex.Format.wBitsPerSample/8; wfex.Format.nAvgBytesPerSec=wfex.Format.nSamplesPerSec* wfex.Format.nBlockAlign; wfex.Format.cbSize=22; wfex.Samples.wValidBitsPerSample=wfex.Format.wBitsPerSample; wfex.dwChannelMask=SPEAKER_ALL; wfex.SubFormat=KSDATAFORMAT_SUBTYPE_PCM; rc=waveInOpen(&win,device,&wfex.Format,0,0, CALLBACK_NULL|WAVE_FORMAT_DIRECT); ok(rc==MMSYSERR_NOERROR || rc==WAVERR_BADFORMAT || rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM, "waveInOpen(%s): returned: %s\n",dev_name(device),wave_in_error(rc)); if (rc==MMSYSERR_NOERROR) { waveInClose(win); wave_in_test_deviceIn(device,&wfex.Format,0,0,&capsA); } else trace("waveInOpen(%s): 24 bit samples not supported\n", dev_name(device)); } /* test if 32 bit samples supported */ wfex.Format.wFormatTag=WAVE_FORMAT_EXTENSIBLE; wfex.Format.nChannels=2; wfex.Format.wBitsPerSample=32; wfex.Format.nSamplesPerSec=22050; wfex.Format.nBlockAlign=wfex.Format.nChannels*wfex.Format.wBitsPerSample/8; wfex.Format.nAvgBytesPerSec=wfex.Format.nSamplesPerSec* wfex.Format.nBlockAlign; wfex.Format.cbSize=22; wfex.Samples.wValidBitsPerSample=wfex.Format.wBitsPerSample; wfex.dwChannelMask=SPEAKER_ALL; wfex.SubFormat=KSDATAFORMAT_SUBTYPE_PCM; rc=waveInOpen(&win,device,&wfex.Format,0,0, CALLBACK_NULL|WAVE_FORMAT_DIRECT); ok(rc==MMSYSERR_NOERROR || rc==WAVERR_BADFORMAT || rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM, "waveInOpen(%s): returned: %s\n",dev_name(device),wave_in_error(rc)); if (rc==MMSYSERR_NOERROR) { waveInClose(win); wave_in_test_deviceIn(device,&wfex.Format,0,0,&capsA); } else trace("waveInOpen(%s): 32 bit samples not supported\n", dev_name(device)); /* test if 32 bit float samples supported */ wfex.Format.wFormatTag=WAVE_FORMAT_EXTENSIBLE; wfex.Format.nChannels=2; wfex.Format.wBitsPerSample=32; wfex.Format.nSamplesPerSec=22050; wfex.Format.nBlockAlign=wfex.Format.nChannels*wfex.Format.wBitsPerSample/8; wfex.Format.nAvgBytesPerSec=wfex.Format.nSamplesPerSec* wfex.Format.nBlockAlign; wfex.Format.cbSize=22; wfex.Samples.wValidBitsPerSample=wfex.Format.wBitsPerSample; wfex.dwChannelMask=SPEAKER_ALL; wfex.SubFormat=KSDATAFORMAT_SUBTYPE_IEEE_FLOAT; rc=waveInOpen(&win,device,&wfex.Format,0,0, CALLBACK_NULL|WAVE_FORMAT_DIRECT); ok(rc==MMSYSERR_NOERROR || rc==WAVERR_BADFORMAT || rc==MMSYSERR_INVALFLAG || rc==MMSYSERR_INVALPARAM, "waveInOpen(%s): returned: %s\n",dev_name(device),wave_in_error(rc)); if (rc==MMSYSERR_NOERROR) { waveInClose(win); wave_in_test_deviceIn(device,&wfex.Format,0,0,&capsA); } else trace("waveInOpen(%s): 32 bit float samples not supported\n", dev_name(device)); }
/*********************************************************************** * VideoCapDriverDescAndVer [MSVIDEO.22] */ DWORD WINAPI VideoCapDriverDescAndVer16(WORD nr, LPSTR buf1, WORD buf1len, LPSTR buf2, WORD buf2len) { static const char version_info_spec[] = "\\StringFileInfo\\040904E4\\FileDescription"; DWORD verhandle; DWORD infosize; UINT subblocklen; char *s, buf[2048], fn[260]; LPBYTE infobuf; LPVOID subblock; DWORD i, cnt = 0, lRet; DWORD bufLen, fnLen; FILETIME lastWrite; HKEY hKey; BOOL found = FALSE; TRACE("(%d,%p,%d,%p,%d)\n", nr, buf1, buf1len, buf2, buf2len); lRet = RegOpenKeyExA(HKEY_LOCAL_MACHINE, HKLM_DRIVERS32, 0, KEY_QUERY_VALUE, &hKey); if (lRet == ERROR_SUCCESS) { RegQueryInfoKeyA( hKey, 0, 0, 0, &cnt, 0, 0, 0, 0, 0, 0, 0); for (i = 0; i < cnt; i++) { bufLen = sizeof(buf) / sizeof(buf[0]); lRet = RegEnumKeyExA(hKey, i, buf, &bufLen, 0, 0, 0, &lastWrite); if (lRet != ERROR_SUCCESS) continue; if (strncasecmp(buf, "vid", 3)) continue; if (nr--) continue; fnLen = sizeof(fn); lRet = RegQueryValueExA(hKey, buf, 0, 0, (LPBYTE)fn, &fnLen); if (lRet == ERROR_SUCCESS) found = TRUE; break; } RegCloseKey( hKey ); } /* search system.ini if not found in the registry */ if (!found && GetPrivateProfileStringA("drivers32", NULL, NULL, buf, sizeof(buf), "system.ini")) { for (s = buf; *s; s += strlen(s) + 1) { if (strncasecmp(s, "vid", 3)) continue; if (nr--) continue; if (GetPrivateProfileStringA("drivers32", s, NULL, fn, sizeof(fn), "system.ini")) found = TRUE; break; } } if (!found) { TRACE("No more VID* entries found nr=%d\n", nr); return 20; } infosize = GetFileVersionInfoSizeA(fn, &verhandle); if (!infosize) { TRACE("%s has no fileversioninfo.\n", fn); return 18; } infobuf = HeapAlloc(GetProcessHeap(), 0, infosize); if (GetFileVersionInfoA(fn, verhandle, infosize, infobuf)) { /* Yes, two space behind : */ /* FIXME: test for buflen */ snprintf(buf2, buf2len, "Version: %d.%d.%d.%d\n", ((WORD*)infobuf)[0x0f], ((WORD*)infobuf)[0x0e], ((WORD*)infobuf)[0x11], ((WORD*)infobuf)[0x10] ); TRACE("version of %s is %s\n", fn, buf2); } else { TRACE("GetFileVersionInfoA failed for %s.\n", fn); lstrcpynA(buf2, fn, buf2len); /* msvideo.dll appears to copy fn*/ } /* FIXME: language problem? */ if (VerQueryValueA( infobuf, version_info_spec, &subblock, &subblocklen )) { UINT copylen = min(subblocklen,buf1len-1); memcpy(buf1, subblock, copylen); buf1[copylen] = '\0'; TRACE("VQA returned %s\n", (LPCSTR)subblock); } else { TRACE("VQA did not return on query \\StringFileInfo\\040904E4\\FileDescription?\n"); lstrcpynA(buf1, fn, buf1len); /* msvideo.dll appears to copy fn*/ } HeapFree(GetProcessHeap(), 0, infobuf); return 0; }
static UINT cp_fields_resample(IDirectSoundBufferImpl *dsb, UINT count, float *freqAcc) { UINT i, channel; UINT istride = dsb->pwfx->nBlockAlign; UINT ostride = dsb->device->pwfx->nChannels * sizeof(float); float freqAdjust = dsb->freqAdjust; float freqAcc_start = *freqAcc; float freqAcc_end = freqAcc_start + count * freqAdjust; UINT dsbfirstep = dsb->firstep; UINT channels = dsb->mix_channels; UINT max_ipos = freqAcc_start + count * freqAdjust; UINT fir_cachesize = (fir_len + dsbfirstep - 2) / dsbfirstep; UINT required_input = max_ipos + fir_cachesize; float* intermediate = HeapAlloc(GetProcessHeap(), 0, sizeof(float) * required_input * channels); float* fir_copy = HeapAlloc(GetProcessHeap(), 0, sizeof(float) * fir_cachesize); /* Important: this buffer MUST be non-interleaved * if you want -msse3 to have any effect. * This is good for CPU cache effects, too. */ float* itmp = intermediate; for (channel = 0; channel < channels; channel++) for (i = 0; i < required_input; i++) *(itmp++) = get_current_sample(dsb, dsb->sec_mixpos + i * istride, channel); for(i = 0; i < count; ++i) { float total_fir_steps = (freqAcc_start + i * freqAdjust) * dsbfirstep; UINT int_fir_steps = total_fir_steps; UINT ipos = int_fir_steps / dsbfirstep; UINT idx = (ipos + 1) * dsbfirstep - int_fir_steps - 1; float rem = int_fir_steps + 1.0 - total_fir_steps; int fir_used = 0; while (idx < fir_len - 1) { fir_copy[fir_used++] = fir[idx] * (1.0 - rem) + fir[idx + 1] * rem; idx += dsb->firstep; } assert(fir_used <= fir_cachesize); assert(ipos + fir_used <= required_input); for (channel = 0; channel < dsb->mix_channels; channel++) { int j; float sum = 0.0; float* cache = &intermediate[channel * required_input + ipos]; for (j = 0; j < fir_used; j++) sum += fir_copy[j] * cache[j]; dsb->put(dsb, i * ostride, channel, sum * dsb->firgain); } } freqAcc_end -= (int)freqAcc_end; *freqAcc = freqAcc_end; HeapFree(GetProcessHeap(), 0, fir_copy); HeapFree(GetProcessHeap(), 0, intermediate); return max_ipos; }
// Allocates memory with @size, if requested (@zeromem) the memory will be filled with 0x0 void* Alloc(size_t size, bool zeromem = false) { return HeapAlloc(GetController()->heap, zeromem? HEAP_ZERO_MEMORY : 0, size); }
void * __cdecl _realloc_base (void * pBlock, size_t newsize) { void * pvReturn; size_t origSize = newsize; // if ptr is NULL, call malloc if (pBlock == NULL) return(_malloc_base(newsize)); // if ptr is nonNULL and size is zero, call free and return NULL if (newsize == 0) { _free_base(pBlock); return(NULL); } #ifndef _WIN64 if ( __active_heap == __V6_HEAP ) { PHEADER pHeader; size_t oldsize; for (;;) { pvReturn = NULL; if (newsize <= _HEAP_MAXREQ) { _mlock( _HEAP_LOCK ); __try { // test if current block is in the small-block heap if ((pHeader = __sbh_find_block(pBlock)) != NULL) { // if the new size is not over __sbh_threshold, attempt // to reallocate within the small-block heap if (newsize <= __sbh_threshold) { if (__sbh_resize_block(pHeader, pBlock, (int)newsize)) pvReturn = pBlock; else if ((pvReturn = __sbh_alloc_block((int)newsize)) != NULL) { oldsize = ((PENTRY)((char *)pBlock - sizeof(int)))->sizeFront - 1; memcpy(pvReturn, pBlock, __min(oldsize, newsize)); // headers may have moved, get pHeader again pHeader = __sbh_find_block(pBlock); __sbh_free_block(pHeader, pBlock); } } // If the reallocation has not been (successfully) // performed in the small-block heap, try to allocate // a new block with HeapAlloc. if (pvReturn == NULL) { if (newsize == 0) newsize = 1; newsize = (newsize + BYTES_PER_PARA - 1) & ~(BYTES_PER_PARA - 1); if ((pvReturn = HeapAlloc(_crtheap, 0, newsize)) != NULL) { oldsize = ((PENTRY)((char *)pBlock - sizeof(int)))->sizeFront - 1; memcpy(pvReturn, pBlock, __min(oldsize, newsize)); __sbh_free_block(pHeader, pBlock); } } } } __finally { _munlock( _HEAP_LOCK ); } // the current block is NOT in the small block heap iff pHeader // is NULL if ( pHeader == NULL ) { if (newsize == 0) newsize = 1; newsize = (newsize + BYTES_PER_PARA - 1) & ~(BYTES_PER_PARA - 1); pvReturn = HeapReAlloc(_crtheap, 0, pBlock, newsize); } } else /* newsize > _HEAP_MAXREQ */ {
static int aes_ctr_init(archive_crypto_ctx *ctx, const uint8_t *key, size_t key_len) { BCRYPT_ALG_HANDLE hAlg; BCRYPT_KEY_HANDLE hKey; DWORD keyObj_len, aes_key_len; PBYTE keyObj; ULONG result; NTSTATUS status; BCRYPT_KEY_LENGTHS_STRUCT key_lengths; ctx->hAlg = NULL; ctx->hKey = NULL; ctx->keyObj = NULL; switch (key_len) { case 16: aes_key_len = 128; break; case 24: aes_key_len = 192; break; case 32: aes_key_len = 256; break; default: return -1; } status = BCryptOpenAlgorithmProvider(&hAlg, BCRYPT_AES_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0); if (!BCRYPT_SUCCESS(status)) return -1; status = BCryptGetProperty(hAlg, BCRYPT_KEY_LENGTHS, (PUCHAR)&key_lengths, sizeof(key_lengths), &result, 0); if (!BCRYPT_SUCCESS(status)) { BCryptCloseAlgorithmProvider(hAlg, 0); return -1; } if (key_lengths.dwMinLength > aes_key_len || key_lengths.dwMaxLength < aes_key_len) { BCryptCloseAlgorithmProvider(hAlg, 0); return -1; } status = BCryptGetProperty(hAlg, BCRYPT_OBJECT_LENGTH, (PUCHAR)&keyObj_len, sizeof(keyObj_len), &result, 0); if (!BCRYPT_SUCCESS(status)) { BCryptCloseAlgorithmProvider(hAlg, 0); return -1; } keyObj = (PBYTE)HeapAlloc(GetProcessHeap(), 0, keyObj_len); if (keyObj == NULL) { BCryptCloseAlgorithmProvider(hAlg, 0); return -1; } status = BCryptSetProperty(hAlg, BCRYPT_CHAINING_MODE, (PUCHAR)BCRYPT_CHAIN_MODE_ECB, sizeof(BCRYPT_CHAIN_MODE_ECB), 0); if (!BCRYPT_SUCCESS(status)) { BCryptCloseAlgorithmProvider(hAlg, 0); HeapFree(GetProcessHeap(), 0, keyObj); return -1; } status = BCryptGenerateSymmetricKey(hAlg, &hKey, keyObj, keyObj_len, (PUCHAR)(uintptr_t)key, (ULONG)key_len, 0); if (!BCRYPT_SUCCESS(status)) { BCryptCloseAlgorithmProvider(hAlg, 0); HeapFree(GetProcessHeap(), 0, keyObj); return -1; } ctx->hAlg = hAlg; ctx->hKey = hKey; ctx->keyObj = keyObj; ctx->keyObj_len = keyObj_len; ctx->encr_pos = AES_BLOCK_SIZE; return 0; }
INT_PTR CALLBACK UsersPageProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) { PUSER_DATA pUserData; UNREFERENCED_PARAMETER(wParam); pUserData = (PUSER_DATA)GetWindowLongPtr(hwndDlg, DWLP_USER); switch (uMsg) { case WM_INITDIALOG: pUserData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(USER_DATA)); SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)pUserData); pUserData->hPopupMenu = LoadMenu(hApplet, MAKEINTRESOURCE(IDM_POPUP_USER)); OnInitDialog(hwndDlg); SetMenuDefaultItem(GetSubMenu(pUserData->hPopupMenu, 1), IDM_USER_PROPERTIES, FALSE); break; case WM_COMMAND: switch (LOWORD(wParam)) { case IDM_USER_CHANGE_PASSWORD: DialogBoxParam(hApplet, MAKEINTRESOURCE(IDD_CHANGE_PASSWORD), hwndDlg, ChangePasswordDlgProc, (LPARAM)NULL); break; case IDM_USER_RENAME: UserRename(hwndDlg); break; case IDM_USER_NEW: case IDC_USERS_ADD: UserNew(hwndDlg); break; case IDM_USER_DELETE: case IDC_USERS_REMOVE: UserDelete(hwndDlg); break; case IDM_USER_PROPERTIES: case IDC_USERS_PROPERTIES: if (UserProperties(hwndDlg)) { UpdateUserProperties(hwndDlg); } break; } break; case WM_NOTIFY: return OnNotify(hwndDlg, pUserData, (NMHDR *)lParam); case WM_DESTROY: DestroyMenu(pUserData->hPopupMenu); HeapFree(GetProcessHeap(), 0, pUserData); break; } return FALSE; }
/****************************************************************************** * I_RpcAllocate (rpcrt4.@) */ void * WINAPI I_RpcAllocate(unsigned int Size) { return HeapAlloc(GetProcessHeap(), 0, Size); }
INT_PTR CALLBACK NewUserDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) { PUSER_INFO_3 userInfo; INT nLength; UNREFERENCED_PARAMETER(wParam); userInfo = (PUSER_INFO_3)GetWindowLongPtr(hwndDlg, DWLP_USER); switch (uMsg) { case WM_INITDIALOG: userInfo = (PUSER_INFO_3)lParam; SetWindowLongPtr(hwndDlg, DWLP_USER, lParam); SendDlgItemMessage(hwndDlg, IDC_USER_NEW_NAME, EM_SETLIMITTEXT, 20, 0); UpdateUserOptions(hwndDlg, userInfo, TRUE); break; case WM_COMMAND: switch (LOWORD(wParam)) { case IDC_USER_NEW_NAME: if (HIWORD(wParam) == EN_CHANGE) { nLength = SendDlgItemMessage(hwndDlg, IDC_USER_NEW_NAME, WM_GETTEXTLENGTH, 0, 0); EnableWindow(GetDlgItem(hwndDlg, IDOK), (nLength > 0)); } break; case IDC_USER_NEW_FORCE_CHANGE: userInfo->usri3_password_expired = !userInfo->usri3_password_expired; UpdateUserOptions(hwndDlg, userInfo, FALSE); break; case IDC_USER_NEW_CANNOT_CHANGE: userInfo->usri3_flags ^= UF_PASSWD_CANT_CHANGE; UpdateUserOptions(hwndDlg, userInfo, FALSE); break; case IDC_USER_NEW_NEVER_EXPIRES: userInfo->usri3_flags ^= UF_DONT_EXPIRE_PASSWD; UpdateUserOptions(hwndDlg, userInfo, FALSE); break; case IDC_USER_NEW_DISABLED: userInfo->usri3_flags ^= UF_ACCOUNTDISABLE; break; case IDOK: if (!CheckAccountName(hwndDlg, IDC_USER_NEW_NAME, NULL)) { SetFocus(GetDlgItem(hwndDlg, IDC_USER_NEW_NAME)); SendDlgItemMessage(hwndDlg, IDC_USER_NEW_NAME, EM_SETSEL, 0, -1); break; } if (!CheckPasswords(hwndDlg, IDC_USER_NEW_PASSWORD1, IDC_USER_NEW_PASSWORD2)) { SetDlgItemText(hwndDlg, IDC_USER_NEW_PASSWORD1, TEXT("")); SetDlgItemText(hwndDlg, IDC_USER_NEW_PASSWORD2, TEXT("")); break; } /* Store the user name */ nLength = SendDlgItemMessage(hwndDlg, IDC_USER_NEW_NAME, WM_GETTEXTLENGTH, 0, 0); if (nLength > 0) { userInfo->usri3_name = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (nLength + 1) * sizeof(WCHAR)); GetDlgItemText(hwndDlg, IDC_USER_NEW_NAME, userInfo->usri3_name, nLength + 1); } /* Store the full user name */ nLength = SendDlgItemMessage(hwndDlg, IDC_USER_NEW_FULL_NAME, WM_GETTEXTLENGTH, 0, 0); if (nLength > 0) { userInfo->usri3_full_name = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (nLength + 1) * sizeof(WCHAR)); GetDlgItemText(hwndDlg, IDC_USER_NEW_FULL_NAME, userInfo->usri3_full_name, nLength + 1); } /* Store the description */ nLength = SendDlgItemMessage(hwndDlg, IDC_USER_NEW_DESCRIPTION, WM_GETTEXTLENGTH, 0, 0); if (nLength > 0) { userInfo->usri3_comment = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (nLength + 1) * sizeof(WCHAR)); GetDlgItemText(hwndDlg, IDC_USER_NEW_DESCRIPTION, userInfo->usri3_comment, nLength + 1); } /* Store the password */ nLength = SendDlgItemMessage(hwndDlg, IDC_USER_NEW_PASSWORD1, WM_GETTEXTLENGTH, 0, 0); if (nLength > 0) { userInfo->usri3_password = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (nLength + 1) * sizeof(WCHAR)); GetDlgItemText(hwndDlg, IDC_USER_NEW_PASSWORD1, userInfo->usri3_password, nLength + 1); } EndDialog(hwndDlg, IDOK); break; case IDCANCEL: EndDialog(hwndDlg, IDCANCEL); break; } break; default: return FALSE; } return TRUE; }
//enum processes void CDlgProcList::EnumProc2List() { if(ZwQuerySystemInformation!=NULL) { HANDLE hHeap = GetProcessHeap(); NTSTATUS Status; ULONG cbBuffer = 0x8000; PVOID pBuffer = NULL; do { pBuffer = HeapAlloc(hHeap, 0, cbBuffer); if (pBuffer == NULL) return; Status = ZwQuerySystemInformation( SystemProcessesAndThreadsInformation, pBuffer, cbBuffer, NULL); if (Status == STATUS_INFO_LENGTH_MISMATCH) { HeapFree(hHeap, 0, pBuffer); cbBuffer *= 2; } else if (!NT_SUCCESS(Status)) { HeapFree(hHeap, 0, pBuffer); return; } } while (Status == STATUS_INFO_LENGTH_MISMATCH); PSYSTEM_PROCESS_INFORMATION pProcesses = (PSYSTEM_PROCESS_INFORMATION)pBuffer; for (;;) { PCWSTR pszProcessName = pProcesses->ProcessName.Buffer; if (pszProcessName == NULL) pszProcessName = L"Idle"; USES_CONVERSION; std::string strProcessName=W2A(pszProcessName); /*m_processlists.insert(std::make_pair(strProcessName,pProcesses->ProcessId));*/ FillRecord2List(strProcessName.c_str(),pProcesses->ProcessId); if (pProcesses->NextEntryDelta == 0) break; // find the address of the next process structure pProcesses = (PSYSTEM_PROCESS_INFORMATION)(((LPBYTE)pProcesses) + pProcesses->NextEntryDelta); } HeapFree(hHeap, 0, pBuffer); } if(m_processlists.size()!=0) { std::map<std::string,DWORD>::iterator iter; for(iter=m_processlists.begin();iter!=m_processlists.end();iter++) { FillRecord2List(iter->first.c_str(),iter->second); } } }
/********************************************************************** * * PSDRV_Brush * */ BOOL PSDRV_Brush(PSDRV_PDEVICE *physDev, BOOL EO) { LOGBRUSH logbrush; BOOL ret = TRUE; if(physDev->pathdepth) return FALSE; if (!GetObjectA( GetCurrentObject(physDev->hdc,OBJ_BRUSH), sizeof(logbrush), &logbrush )) { ERR("Can't get BRUSHOBJ\n"); return FALSE; } switch (logbrush.lbStyle) { case BS_SOLID: PSDRV_WriteGSave(physDev); PSDRV_SetBrush(physDev); PSDRV_Fill(physDev, EO); PSDRV_WriteGRestore(physDev); break; case BS_HATCHED: PSDRV_WriteGSave(physDev); PSDRV_SetBrush(physDev); switch(logbrush.lbHatch) { case HS_VERTICAL: case HS_CROSS: PSDRV_WriteGSave(physDev); PSDRV_Clip(physDev, EO); PSDRV_WriteHatch(physDev); PSDRV_WriteStroke(physDev); PSDRV_WriteGRestore(physDev); if(logbrush.lbHatch == HS_VERTICAL) break; /* else fallthrough for HS_CROSS */ case HS_HORIZONTAL: PSDRV_WriteGSave(physDev); PSDRV_Clip(physDev, EO); PSDRV_WriteRotate(physDev, 90.0); PSDRV_WriteHatch(physDev); PSDRV_WriteStroke(physDev); PSDRV_WriteGRestore(physDev); break; case HS_FDIAGONAL: case HS_DIAGCROSS: PSDRV_WriteGSave(physDev); PSDRV_Clip(physDev, EO); PSDRV_WriteRotate(physDev, -45.0); PSDRV_WriteHatch(physDev); PSDRV_WriteStroke(physDev); PSDRV_WriteGRestore(physDev); if(logbrush.lbHatch == HS_FDIAGONAL) break; /* else fallthrough for HS_DIAGCROSS */ case HS_BDIAGONAL: PSDRV_WriteGSave(physDev); PSDRV_Clip(physDev, EO); PSDRV_WriteRotate(physDev, 45.0); PSDRV_WriteHatch(physDev); PSDRV_WriteStroke(physDev); PSDRV_WriteGRestore(physDev); break; default: ERR("Unknown hatch style\n"); ret = FALSE; break; } PSDRV_WriteGRestore(physDev); break; case BS_NULL: break; case BS_PATTERN: { BITMAP bm; BYTE *bits; GetObjectA( (HBITMAP)logbrush.lbHatch, sizeof(BITMAP), &bm); TRACE("BS_PATTERN %dx%d %d bpp\n", bm.bmWidth, bm.bmHeight, bm.bmBitsPixel); bits = HeapAlloc(PSDRV_Heap, 0, bm.bmWidthBytes * bm.bmHeight); GetBitmapBits( (HBITMAP)logbrush.lbHatch, bm.bmWidthBytes * bm.bmHeight, bits); if(physDev->pi->ppd->LanguageLevel > 1) { PSDRV_WriteGSave(physDev); PSDRV_WritePatternDict(physDev, &bm, bits); PSDRV_Fill(physDev, EO); PSDRV_WriteGRestore(physDev); } else { FIXME("Trying to set a pattern brush on a level 1 printer\n"); ret = FALSE; } HeapFree(PSDRV_Heap, 0, bits); } break; case BS_DIBPATTERN: { BITMAPINFO *bmi = GlobalLock( (HGLOBAL)logbrush.lbHatch ); UINT usage = logbrush.lbColor; TRACE("size %dx%dx%d\n", bmi->bmiHeader.biWidth, bmi->bmiHeader.biHeight, bmi->bmiHeader.biBitCount); if(physDev->pi->ppd->LanguageLevel > 1) { PSDRV_WriteGSave(physDev); ret = PSDRV_WriteDIBPatternDict(physDev, bmi, usage); PSDRV_Fill(physDev, EO); PSDRV_WriteGRestore(physDev); } else { FIXME("Trying to set a pattern brush on a level 1 printer\n"); ret = FALSE; } GlobalUnlock( (HGLOBAL)logbrush.lbHatch ); } break; default: ret = FALSE; break; } return ret; }
// // Unrostered runs report // BOOL FAR TMSRPT14(TMSRPTPassedDataDef *pPassedData) { TMSRPT14RDataDef *pTMSRPT14RData[ROSTER_MAX_DAYS]; HFILE hfOutputFile; BOOL bKeepGoing = FALSE; BOOL bFound; long numRuns[ROSTER_MAX_DAYS]; char szOutputString[128]; char szDay[16]; char dummy[256]; long maxRuns; int days[ROSTER_MAX_DAYS] = {TEXT_009, TEXT_010, TEXT_011, TEXT_012, TEXT_013, TEXT_014, TEXT_015}; int nI; int nJ; int nK; int nL; int rcode2; pPassedData->nReportNumber = 13; pPassedData->numDataFiles = 1; for(nI = 0; nI < m_LastReport; nI++) { if(TMSRPT[nI].originalReportNumber == pPassedData->nReportNumber) { StatusBarStart(hWndMain, TMSRPT[nI].szReportName); break; } } // // Open the output file // StatusBarText("Opening output file..."); strcpy(tempString, szReportsTempFolder); strcat(tempString, "\\tmsrpt14.txt"); hfOutputFile = _lcreat(tempString, 0); if(hfOutputFile == HFILE_ERROR) { LoadString(hInst, ERROR_202, szFormatString, sizeof(szFormatString)); sprintf(szarString, szFormatString, tempString); MessageBeep(MB_ICONSTOP); MessageBox((HWND)NULL, szarString, TMS, MB_ICONSTOP); goto deallocate; } strcpy(pPassedData->szReportDataFile[0], tempString); // // Initialize the TMSRPT14RData and TMSRPT14RDataData structures // rcode2 = btrieve(B_STAT, TMS_RUNS, &BSTAT, dummy, 0); if(rcode2 != 0 || BSTAT.numRecords == 0) { TMSError((HWND)NULL, MB_ICONSTOP, ERROR_266, (HANDLE)NULL); goto deallocate; } maxRuns = BSTAT.numRecords; for(nI = 0; nI < ROSTER_MAX_DAYS; nI++) { numRuns[nI] = 0; pTMSRPT14RData[nI] = (TMSRPT14RDataDef *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(TMSRPT14RDataDef) * maxRuns); if(pTMSRPT14RData[nI] == NULL) { AllocationError(__FILE__, __LINE__, FALSE); goto deallocate; } } // // Read the runs into TMSRPT14RData // for(nI = 0; nI < ROSTER_MAX_DAYS; nI++) { LoadString(hInst, days[nI], szDay, sizeof(szDay)); sprintf(tempString, "Reading %s runs...", szDay); StatusBarText(tempString); if(StatusBarAbort()) { goto deallocate; } if(ROSTERPARMS.serviceDays[nI] == NO_RECORD) { continue; } RUNSKey1.DIVISIONSrecordID = m_DivisionRecordID; RUNSKey1.SERVICESrecordID = ROSTERPARMS.serviceDays[nI]; RUNSKey1.runNumber = NO_RECORD; RUNSKey1.pieceNumber = NO_RECORD; rcode2 = btrieve(B_GETGREATER, TMS_RUNS, &RUNS, &RUNSKey1, 1); while(rcode2 == 0 && RUNS.DIVISIONSrecordID == m_DivisionRecordID && RUNS.SERVICESrecordID == ROSTERPARMS.serviceDays[nI]) { if(RUNS.pieceNumber == 1) { pTMSRPT14RData[nI][numRuns[nI]].recordID = RUNS.recordID; pTMSRPT14RData[nI][numRuns[nI]].runNumber = RUNS.runNumber; pTMSRPT14RData[nI][numRuns[nI]].cutAsRuntype = RUNS.cutAsRuntype; numRuns[nI]++; } rcode2 = btrieve(B_GETNEXT, TMS_RUNS, &RUNS, &RUNSKey1, 1); } } // // Go through the roster. Each time a run number shows up, kill it // from the list inside TMSRPT14RData. // rcode2 = btrieve(B_GETFIRST, TMS_ROSTER, &ROSTER, &ROSTERKey0, 0); while(rcode2 == 0) { StatusBarText("Cycling through the roster..."); for(nI = 0; nI < ROSTER_MAX_DAYS; nI++) { if(StatusBarAbort()) { goto deallocate; } if(ROSTER.WEEK[m_RosterWeek].RUNSrecordIDs[nI] == NO_RECORD) { continue; } for(nJ = 0; nJ < numRuns[nI]; nJ++) { if(ROSTER.WEEK[m_RosterWeek].RUNSrecordIDs[nI] == pTMSRPT14RData[nI][nJ].recordID) { pTMSRPT14RData[nI][nJ].recordID = NO_RECORD; break; } } } rcode2 = btrieve(B_GETNEXT, TMS_ROSTER, &ROSTER, &ROSTERKey0, 0); } // // Dump out the remaining runs // for(nI = 0; nI < ROSTER_MAX_DAYS; nI++) { if(StatusBarAbort()) { goto deallocate; } LoadString(hInst, days[nI], szDay, sizeof(szDay)); sprintf(tempString, "Writing output for day %s...", szDay); StatusBarText(tempString); for(bFound = FALSE, nJ = 0; nJ < numRuns[nI]; nJ++) { if(pTMSRPT14RData[nI][nJ].recordID != NO_RECORD) { bFound = TRUE; break; } } if(!bFound) { sprintf(szOutputString, "%10s\t", szDay); strcat(szOutputString, " 0\tNo runs\r\n"); _lwrite(hfOutputFile, szOutputString, strlen(szOutputString)); } else { for(; nJ < numRuns[nI]; nJ++) { sprintf(szOutputString, "%10s\t", szDay); if(pTMSRPT14RData[nI][nJ].recordID != NO_RECORD) { sprintf(tempString, "%6ld\t", pTMSRPT14RData[nI][nJ].runNumber); strcat(szOutputString, tempString); nK = (short int)LOWORD(pTMSRPT14RData[nI][nJ].cutAsRuntype); nL = (short int)HIWORD(pTMSRPT14RData[nI][nJ].cutAsRuntype); if(nK >= 0 && nK < NUMRUNTYPES && nL >= 0 && nL < NUMRUNTYPESLOTS) { strcat(szOutputString, RUNTYPE[nK][nL].localName); } strcat(szOutputString, "\r\n"); _lwrite(hfOutputFile, szOutputString, strlen(szOutputString)); } } } } bKeepGoing = TRUE; // // Free allocated memory // deallocate: for(nI = 0; nI < ROSTER_MAX_DAYS; nI++) { TMSHeapFree(pTMSRPT14RData[nI]); } _lclose(hfOutputFile); StatusBarEnd(); if(!bKeepGoing) { return(FALSE); } // // All done // return(TRUE); }
void __RPC_FAR * __RPC_USER midl_user_allocate(SIZE_T len) { return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len); }
static HRESULT swapchain_init(struct wined3d_swapchain *swapchain, struct wined3d_device *device, struct wined3d_swapchain_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops) { const struct wined3d_adapter *adapter = device->adapter; struct wined3d_resource_desc texture_desc; struct wined3d_surface *front_buffer; BOOL displaymode_set = FALSE; RECT client_rect; HWND window; HRESULT hr; UINT i; if (desc->backbuffer_count > 1) { FIXME("The application requested more than one back buffer, this is not properly supported.\n" "Please configure the application to use double buffering (1 back buffer) if possible.\n"); } if (device->wined3d->flags & WINED3D_NO3D) swapchain->swapchain_ops = &swapchain_gdi_ops; else swapchain->swapchain_ops = &swapchain_gl_ops; window = desc->device_window ? desc->device_window : device->create_parms.focus_window; swapchain->device = device; swapchain->parent = parent; swapchain->parent_ops = parent_ops; swapchain->ref = 1; swapchain->win_handle = window; swapchain->device_window = window; if (FAILED(hr = wined3d_get_adapter_display_mode(device->wined3d, adapter->ordinal, &swapchain->original_mode, NULL))) { ERR("Failed to get current display mode, hr %#x.\n", hr); goto err; } GetClientRect(window, &client_rect); if (desc->windowed && (!desc->backbuffer_width || !desc->backbuffer_height || desc->backbuffer_format == WINED3DFMT_UNKNOWN)) { if (!desc->backbuffer_width) { desc->backbuffer_width = client_rect.right; TRACE("Updating width to %u.\n", desc->backbuffer_width); } if (!desc->backbuffer_height) { desc->backbuffer_height = client_rect.bottom; TRACE("Updating height to %u.\n", desc->backbuffer_height); } if (desc->backbuffer_format == WINED3DFMT_UNKNOWN) { desc->backbuffer_format = swapchain->original_mode.format_id; TRACE("Updating format to %s.\n", debug_d3dformat(swapchain->original_mode.format_id)); } } swapchain->desc = *desc; swapchain_update_render_to_fbo(swapchain); TRACE("Creating front buffer.\n"); texture_desc.resource_type = WINED3D_RTYPE_TEXTURE_2D; texture_desc.format = swapchain->desc.backbuffer_format; texture_desc.multisample_type = swapchain->desc.multisample_type; texture_desc.multisample_quality = swapchain->desc.multisample_quality; texture_desc.usage = 0; texture_desc.pool = WINED3D_POOL_DEFAULT; texture_desc.width = swapchain->desc.backbuffer_width; texture_desc.height = swapchain->desc.backbuffer_height; texture_desc.depth = 1; texture_desc.size = 0; if (FAILED(hr = device->device_parent->ops->create_swapchain_texture(device->device_parent, parent, &texture_desc, &swapchain->front_buffer))) { WARN("Failed to create front buffer, hr %#x.\n", hr); goto err; } wined3d_texture_set_swapchain(swapchain->front_buffer, swapchain); front_buffer = surface_from_resource(wined3d_texture_get_sub_resource(swapchain->front_buffer, 0)); if (!(device->wined3d->flags & WINED3D_NO3D)) { surface_validate_location(front_buffer, WINED3D_LOCATION_DRAWABLE); surface_invalidate_location(front_buffer, ~WINED3D_LOCATION_DRAWABLE); } /* MSDN says we're only allowed a single fullscreen swapchain per device, * so we should really check to see if there is a fullscreen swapchain * already. Does a single head count as full screen? */ if (!desc->windowed) { /* Change the display settings */ swapchain->d3d_mode.width = desc->backbuffer_width; swapchain->d3d_mode.height = desc->backbuffer_height; swapchain->d3d_mode.format_id = desc->backbuffer_format; swapchain->d3d_mode.refresh_rate = desc->refresh_rate; swapchain->d3d_mode.scanline_ordering = WINED3D_SCANLINE_ORDERING_UNKNOWN; if (FAILED(hr = wined3d_set_adapter_display_mode(device->wined3d, adapter->ordinal, &swapchain->d3d_mode))) { WARN("Failed to set display mode, hr %#x.\n", hr); goto err; } displaymode_set = TRUE; } if (!(device->wined3d->flags & WINED3D_NO3D)) { static const enum wined3d_format_id formats[] = { WINED3DFMT_D24_UNORM_S8_UINT, WINED3DFMT_D32_UNORM, WINED3DFMT_R24_UNORM_X8_TYPELESS, WINED3DFMT_D16_UNORM, WINED3DFMT_S1_UINT_D15_UNORM }; const struct wined3d_gl_info *gl_info = &adapter->gl_info; swapchain->context = HeapAlloc(GetProcessHeap(), 0, sizeof(*swapchain->context)); if (!swapchain->context) { ERR("Failed to create the context array.\n"); hr = E_OUTOFMEMORY; goto err; } swapchain->num_contexts = 1; /* In WGL both color, depth and stencil are features of a pixel format. In case of D3D they are separate. * You are able to add a depth + stencil surface at a later stage when you need it. * In order to support this properly in WineD3D we need the ability to recreate the opengl context and * drawable when this is required. This is very tricky as we need to reapply ALL opengl states for the new * context, need torecreate shaders, textures and other resources. * * The context manager already takes care of the state problem and for the other tasks code from Reset * can be used. These changes are way to risky during the 1.0 code freeze which is taking place right now. * Likely a lot of other new bugs will be exposed. For that reason request a depth stencil surface all the * time. It can cause a slight performance hit but fixes a lot of regressions. A fixme reminds of that this * issue needs to be fixed. */ for (i = 0; i < (sizeof(formats) / sizeof(*formats)); i++) { swapchain->ds_format = wined3d_get_format(gl_info, formats[i]); swapchain->context[0] = context_create(swapchain, front_buffer, swapchain->ds_format); if (swapchain->context[0]) break; TRACE("Depth stencil format %s is not supported, trying next format\n", debug_d3dformat(formats[i])); } if (!swapchain->context[0]) { WARN("Failed to create context.\n"); hr = WINED3DERR_NOTAVAILABLE; goto err; } if (wined3d_settings.offscreen_rendering_mode != ORM_FBO && (!desc->enable_auto_depth_stencil || swapchain->desc.auto_depth_stencil_format != swapchain->ds_format->id)) { FIXME("Add OpenGL context recreation support to context_validate_onscreen_formats\n"); } context_release(swapchain->context[0]); } if (swapchain->desc.backbuffer_count > 0) { swapchain->back_buffers = HeapAlloc(GetProcessHeap(), 0, sizeof(*swapchain->back_buffers) * swapchain->desc.backbuffer_count); if (!swapchain->back_buffers) { ERR("Failed to allocate backbuffer array memory.\n"); hr = E_OUTOFMEMORY; goto err; } texture_desc.usage |= WINED3DUSAGE_RENDERTARGET; for (i = 0; i < swapchain->desc.backbuffer_count; ++i) { TRACE("Creating back buffer %u.\n", i); if (FAILED(hr = device->device_parent->ops->create_swapchain_texture(device->device_parent, parent, &texture_desc, &swapchain->back_buffers[i]))) { WARN("Failed to create back buffer %u, hr %#x.\n", i, hr); swapchain->desc.backbuffer_count = i; goto err; } wined3d_texture_set_swapchain(swapchain->back_buffers[i], swapchain); } } /* Swapchains share the depth/stencil buffer, so only create a single depthstencil surface. */ if (desc->enable_auto_depth_stencil && !(device->wined3d->flags & WINED3D_NO3D)) { TRACE("Creating depth/stencil buffer.\n"); if (!device->auto_depth_stencil_view) { struct wined3d_texture *ds; struct wined3d_rendertarget_view_desc desc; texture_desc.format = swapchain->desc.auto_depth_stencil_format; texture_desc.usage = WINED3DUSAGE_DEPTHSTENCIL; if (FAILED(hr = device->device_parent->ops->create_swapchain_texture(device->device_parent, device->device_parent, &texture_desc, &ds))) { WARN("Failed to create the auto depth/stencil surface, hr %#x.\n", hr); goto err; } desc.format_id = ds->resource.format->id; desc.u.texture.level_idx = 0; desc.u.texture.layer_idx = 0; desc.u.texture.layer_count = 1; hr = wined3d_rendertarget_view_create(&desc, &ds->resource, NULL, &wined3d_null_parent_ops, &device->auto_depth_stencil_view); wined3d_texture_decref(ds); if (FAILED(hr)) { ERR("Failed to create rendertarget view, hr %#x.\n", hr); goto err; } } } wined3d_swapchain_get_gamma_ramp(swapchain, &swapchain->orig_gamma); return WINED3D_OK; err: if (displaymode_set) { if (FAILED(wined3d_set_adapter_display_mode(device->wined3d, adapter->ordinal, &swapchain->original_mode))) ERR("Failed to restore display mode.\n"); ClipCursor(NULL); } if (swapchain->back_buffers) { for (i = 0; i < swapchain->desc.backbuffer_count; ++i) { if (swapchain->back_buffers[i]) { wined3d_texture_set_swapchain(swapchain->back_buffers[i], NULL); wined3d_texture_decref(swapchain->back_buffers[i]); } } HeapFree(GetProcessHeap(), 0, swapchain->back_buffers); } if (swapchain->context) { if (swapchain->context[0]) { context_release(swapchain->context[0]); context_destroy(device, swapchain->context[0]); swapchain->num_contexts = 0; } HeapFree(GetProcessHeap(), 0, swapchain->context); } if (swapchain->front_buffer) { wined3d_texture_set_swapchain(swapchain->front_buffer, NULL); wined3d_texture_decref(swapchain->front_buffer); } return hr; }
PVOID WINAPI WlanAllocateMemory(IN DWORD dwSize) { return HeapAlloc(GetProcessHeap(), 0, dwSize); }
/*************************************************************************** * MCIAVI_mciOpen [internal] */ static DWORD MCIAVI_mciOpen(UINT wDevID, DWORD dwFlags, LPMCI_DGV_OPEN_PARMSW lpOpenParms) { WINE_MCIAVI *wma; LRESULT dwRet = 0; TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpOpenParms); if (lpOpenParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK; wma = (WINE_MCIAVI *)mciGetDriverData(wDevID); if (wma == NULL) return MCIERR_INVALID_DEVICE_ID; EnterCriticalSection(&wma->cs); if (wma->nUseCount > 0) { /* The driver is already open on this channel */ /* If the driver was opened shareable before and this open specifies */ /* shareable then increment the use count */ if (wma->fShareable && (dwFlags & MCI_OPEN_SHAREABLE)) ++wma->nUseCount; else { LeaveCriticalSection(&wma->cs); return MCIERR_MUST_USE_SHAREABLE; } } else { wma->nUseCount = 1; wma->fShareable = dwFlags & MCI_OPEN_SHAREABLE; } wma->dwStatus = MCI_MODE_NOT_READY; if (dwFlags & MCI_OPEN_ELEMENT) { if (dwFlags & MCI_OPEN_ELEMENT_ID) { /* could it be that (DWORD)lpOpenParms->lpstrElementName * contains the hFile value ? */ dwRet = MCIERR_UNRECOGNIZED_COMMAND; } else if (lpOpenParms->lpstrElementName && lpOpenParms->lpstrElementName[0]) { /* FIXME : what should be done id wma->hFile is already != 0, or the driver is playin' */ TRACE("MCI_OPEN_ELEMENT %s!\n", debugstr_w(lpOpenParms->lpstrElementName)); wma->lpFileName = HeapAlloc(GetProcessHeap(), 0, (strlenW(lpOpenParms->lpstrElementName) + 1) * sizeof(WCHAR)); strcpyW(wma->lpFileName, lpOpenParms->lpstrElementName); if (lpOpenParms->lpstrElementName[0] == '@') { /* The file name @11223344 encodes an AVIFile handle in decimal notation * in Win3.1 and w2k/NT, but this feature is absent in win95 (KB140750). * wma->hFile = LongToHandle(strtolW(lpOpenParms->lpstrElementName+1, NULL, 10)); */ FIXME("Using AVIFile/Stream %s NIY\n", debugstr_w(lpOpenParms->lpstrElementName)); } wma->hFile = mmioOpenW(lpOpenParms->lpstrElementName, NULL, MMIO_ALLOCBUF | MMIO_DENYWRITE | MMIO_READ); if (wma->hFile == 0) { WARN("can't find file=%s!\n", debugstr_w(lpOpenParms->lpstrElementName)); dwRet = MCIERR_FILE_NOT_FOUND; } else { if (!MCIAVI_GetInfo(wma)) dwRet = MCIERR_INVALID_FILE; else if (!MCIAVI_OpenVideo(wma)) dwRet = MCIERR_CANNOT_LOAD_DRIVER; else if (!MCIAVI_CreateWindow(wma, dwFlags, lpOpenParms)) dwRet = MCIERR_CREATEWINDOW; } } else { FIXME("Don't record yet\n"); dwRet = MCIERR_UNSUPPORTED_FUNCTION; } } if (dwRet == 0) { TRACE("lpOpenParms->wDeviceID = %04x\n", lpOpenParms->wDeviceID); wma->dwStatus = MCI_MODE_STOP; wma->dwMciTimeFormat = MCI_FORMAT_FRAMES; } else { MCIAVI_CleanUp(wma); } LeaveCriticalSection(&wma->cs); if (!dwRet && (dwFlags & MCI_NOTIFY)) { mciDriverNotify(HWND_32(LOWORD(lpOpenParms->dwCallback)), wDevID, MCI_NOTIFY_SUCCESSFUL); } return dwRet; }
/* loads the INF file and performs checks on it */ static HRESULT install_init(LPCWSTR inf_filename, LPCWSTR install_sec, LPCWSTR working_dir, DWORD flags, ADVInfo *info) { DWORD len; HRESULT hr; LPCWSTR ptr, path; static const WCHAR backslash[] = {'\\',0}; static const WCHAR default_install[] = { 'D','e','f','a','u','l','t','I','n','s','t','a','l','l',0 }; if (!(ptr = strrchrW(inf_filename, '\\'))) ptr = inf_filename; len = lstrlenW(ptr); info->inf_filename = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR)); if (!info->inf_filename) return E_OUTOFMEMORY; lstrcpyW(info->inf_filename, ptr); /* FIXME: determine the proper platform to install (NTx86, etc) */ if (!install_sec || !*install_sec) { len = sizeof(default_install) - 1; ptr = default_install; } else { len = lstrlenW(install_sec); ptr = install_sec; } info->install_sec = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR)); if (!info->install_sec) return E_OUTOFMEMORY; lstrcpyW(info->install_sec, ptr); hr = get_working_dir(info, inf_filename, working_dir); if (FAILED(hr)) return hr; len = lstrlenW(info->working_dir) + lstrlenW(info->inf_filename) + 2; info->inf_path = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); if (!info->inf_path) return E_OUTOFMEMORY; lstrcpyW(info->inf_path, info->working_dir); lstrcatW(info->inf_path, backslash); lstrcatW(info->inf_path, info->inf_filename); /* RunSetupCommand opens unmodifed filename parameter */ if (flags & RSC_FLAG_INF) path = inf_filename; else path = info->inf_path; info->hinf = SetupOpenInfFileW(path, NULL, INF_STYLE_WIN4, NULL); if (info->hinf == INVALID_HANDLE_VALUE) return ADV_HRESULT(GetLastError()); set_ldids(info->hinf, info->install_sec, info->working_dir); /* FIXME: check that the INF is advanced */ info->flags = flags; info->need_reboot = FALSE; return S_OK; }
static void wave_in_test_deviceIn(int device, WAVEFORMATEX *pwfx, DWORD format, DWORD flags, WAVEINCAPSA *pcaps) { HWAVEIN win; HANDLE hevent = CreateEventW(NULL, FALSE, FALSE, NULL); WAVEHDR frag; MMRESULT rc; DWORD res; MMTIME mmt; WORD nChannels = pwfx->nChannels; WORD wBitsPerSample = pwfx->wBitsPerSample; DWORD nSamplesPerSec = pwfx->nSamplesPerSec; win=NULL; rc=waveInOpen(&win,device,pwfx,(DWORD_PTR)hevent,0,CALLBACK_EVENT|flags); /* Note: Win9x doesn't know WAVE_FORMAT_DIRECT */ ok(rc==MMSYSERR_NOERROR || rc==MMSYSERR_BADDEVICEID || rc==MMSYSERR_NOTENABLED || rc==MMSYSERR_NODRIVER || rc==MMSYSERR_ALLOCATED || ((rc==WAVERR_BADFORMAT || rc==MMSYSERR_NOTSUPPORTED) && (flags & WAVE_FORMAT_DIRECT) && !(pcaps->dwFormats & format)) || ((rc==WAVERR_BADFORMAT || rc==MMSYSERR_NOTSUPPORTED) && (!(flags & WAVE_FORMAT_DIRECT) || (flags & WAVE_MAPPED)) && !(pcaps->dwFormats & format)) || (rc==MMSYSERR_INVALFLAG && (flags & WAVE_FORMAT_DIRECT)), "waveInOpen(%s): format=%dx%2dx%d flags=%x(%s) rc=%s\n", dev_name(device),pwfx->nSamplesPerSec,pwfx->wBitsPerSample, pwfx->nChannels,CALLBACK_EVENT|flags, wave_open_flags(CALLBACK_EVENT|flags),wave_in_error(rc)); if ((rc==WAVERR_BADFORMAT || rc==MMSYSERR_NOTSUPPORTED) && (flags & WAVE_FORMAT_DIRECT) && (pcaps->dwFormats & format)) trace(" Reason: The device lists this format as supported in it's " "capabilities but opening it failed.\n"); if ((rc==WAVERR_BADFORMAT || rc==MMSYSERR_NOTSUPPORTED) && !(pcaps->dwFormats & format)) trace("waveInOpen(%s): format=%dx%2dx%d %s rc=%s failed but format " "not supported so OK.\n",dev_name(device),pwfx->nSamplesPerSec, pwfx->wBitsPerSample,pwfx->nChannels, flags & WAVE_FORMAT_DIRECT ? "flags=WAVE_FORMAT_DIRECT" : flags & WAVE_MAPPED ? "flags=WAVE_MAPPED" : "", mmsys_error(rc)); if (rc!=MMSYSERR_NOERROR) { CloseHandle(hevent); return; } res=WaitForSingleObject(hevent,1000); ok(res==WAIT_OBJECT_0,"WaitForSingleObject failed for open\n"); ok(pwfx->nChannels==nChannels && pwfx->wBitsPerSample==wBitsPerSample && pwfx->nSamplesPerSec==nSamplesPerSec, "got the wrong format: %dx%2dx%d instead of %dx%2dx%d\n", pwfx->nSamplesPerSec, pwfx->wBitsPerSample, pwfx->nChannels, nSamplesPerSec, wBitsPerSample, nChannels); /* Check that the position is 0 at start */ check_position(device, win, 0, pwfx); frag.lpData=HeapAlloc(GetProcessHeap(), 0, pwfx->nAvgBytesPerSec); frag.dwBufferLength=pwfx->nAvgBytesPerSec; frag.dwBytesRecorded=0; frag.dwUser=0; frag.dwFlags=0; frag.dwLoops=0; frag.lpNext=0; rc=waveInPrepareHeader(win, &frag, sizeof(frag)); ok(rc==MMSYSERR_NOERROR, "waveInPrepareHeader(%s): rc=%s\n", dev_name(device),wave_in_error(rc)); ok(frag.dwFlags&WHDR_PREPARED,"waveInPrepareHeader(%s): prepared flag " "not set\n",dev_name(device)); if (winetest_interactive && rc==MMSYSERR_NOERROR) { trace("Recording for 1 second at %5dx%2dx%d %s %s\n", pwfx->nSamplesPerSec, pwfx->wBitsPerSample,pwfx->nChannels, get_format_str(pwfx->wFormatTag), flags & WAVE_FORMAT_DIRECT ? "WAVE_FORMAT_DIRECT" : flags & WAVE_MAPPED ? "WAVE_MAPPED" : ""); rc=waveInAddBuffer(win, &frag, sizeof(frag)); ok(rc==MMSYSERR_NOERROR,"waveInAddBuffer(%s): rc=%s\n", dev_name(device),wave_in_error(rc)); /* Check that the position is 0 at start */ check_position(device, win, 0, pwfx); rc=waveInStart(win); ok(rc==MMSYSERR_NOERROR,"waveInStart(%s): rc=%s\n", dev_name(device),wave_in_error(rc)); res = WaitForSingleObject(hevent,1200); ok(res==WAIT_OBJECT_0,"WaitForSingleObject failed for header\n"); ok(frag.dwFlags&WHDR_DONE,"WHDR_DONE not set in frag.dwFlags\n"); ok(frag.dwBytesRecorded==pwfx->nAvgBytesPerSec, "frag.dwBytesRecorded=%d, should=%d\n", frag.dwBytesRecorded,pwfx->nAvgBytesPerSec); mmt.wType = TIME_BYTES; rc=waveInGetPosition(win, &mmt, sizeof(mmt)); ok(rc==MMSYSERR_NOERROR,"waveInGetPosition(%s): rc=%s\n", dev_name(device),wave_in_error(rc)); ok(mmt.wType == TIME_BYTES, "doesn't support TIME_BYTES: %u\n", mmt.wType); ok(mmt.u.cb == frag.dwBytesRecorded, "Got wrong position: %u\n", mmt.u.cb); /* stop playing on error */ if (res!=WAIT_OBJECT_0) { rc=waveInStop(win); ok(rc==MMSYSERR_NOERROR, "waveInStop(%s): rc=%s\n",dev_name(device),wave_in_error(rc)); } } rc=waveInUnprepareHeader(win, &frag, sizeof(frag)); ok(rc==MMSYSERR_NOERROR,"waveInUnprepareHeader(%s): rc=%s\n", dev_name(device),wave_in_error(rc)); rc=waveInClose(win); ok(rc==MMSYSERR_NOERROR, "waveInClose(%s): rc=%s\n",dev_name(device),wave_in_error(rc)); res=WaitForSingleObject(hevent,1000); ok(res==WAIT_OBJECT_0,"WaitForSingleObject failed for close\n"); if (winetest_interactive) { /* * Now play back what we recorded */ HWAVEOUT wout; trace("Playing back recorded sound\n"); rc=waveOutOpen(&wout,WAVE_MAPPER,pwfx,(DWORD_PTR)hevent,0,CALLBACK_EVENT); ok(rc==MMSYSERR_NOERROR || rc==MMSYSERR_BADDEVICEID || rc==MMSYSERR_NOTENABLED || rc==MMSYSERR_NODRIVER || rc==MMSYSERR_ALLOCATED || ((rc==WAVERR_BADFORMAT || rc==MMSYSERR_NOTSUPPORTED) && !(pcaps->dwFormats & format)), "waveOutOpen(%s) format=%dx%2dx%d flags=%x(%s) rc=%s\n", dev_name(device),pwfx->nSamplesPerSec,pwfx->wBitsPerSample, pwfx->nChannels,CALLBACK_EVENT|flags, wave_open_flags(CALLBACK_EVENT),wave_out_error(rc)); if (rc==MMSYSERR_NOERROR) { rc=waveOutPrepareHeader(wout, &frag, sizeof(frag)); ok(rc==MMSYSERR_NOERROR,"waveOutPrepareHeader(%s): rc=%s\n", dev_name(device),wave_out_error(rc)); if (rc==MMSYSERR_NOERROR) { WaitForSingleObject(hevent,INFINITE); rc=waveOutWrite(wout, &frag, sizeof(frag)); ok(rc==MMSYSERR_NOERROR,"waveOutWrite(%s): rc=%s\n", dev_name(device),wave_out_error(rc)); WaitForSingleObject(hevent,INFINITE); rc=waveOutUnprepareHeader(wout, &frag, sizeof(frag)); ok(rc==MMSYSERR_NOERROR,"waveOutUnprepareHeader(%s): rc=%s\n", dev_name(device),wave_out_error(rc)); } rc=waveOutClose(wout); ok(rc==MMSYSERR_NOERROR,"waveOutClose(%s): rc=%s\n", dev_name(device),wave_out_error(rc)); } else trace("Unable to play back the recorded sound\n"); } HeapFree(GetProcessHeap(), 0, frag.lpData); CloseHandle(hevent); }
HRESULT swapchain_init(IWineD3DSwapChainImpl *swapchain, WINED3DSURFTYPE surface_type, IWineD3DDeviceImpl *device, WINED3DPRESENT_PARAMETERS *present_parameters, IUnknown *parent) { const struct wined3d_adapter *adapter = device->adapter; const struct wined3d_format_desc *format_desc; BOOL displaymode_set = FALSE; WINED3DDISPLAYMODE mode; RECT client_rect; HWND window = NULL; #ifdef VBOX_WITH_WDDM IWineD3DSwapChainImpl *overridenSwapchain = NULL; HDC hDC = NULL; #endif HRESULT hr; UINT i; if (present_parameters->BackBufferCount > WINED3DPRESENT_BACK_BUFFER_MAX) { ERR("The application requested %u back buffers, this is not supported.\n", present_parameters->BackBufferCount); return WINED3DERR_INVALIDCALL; } if (present_parameters->BackBufferCount > 1) { FIXME("The application requested more than one back buffer, this is not properly supported.\n" "Please configure the application to use double buffering (1 back buffer) if possible.\n"); } switch (surface_type) { case SURFACE_GDI: swapchain->lpVtbl = &IWineGDISwapChain_Vtbl; break; case SURFACE_OPENGL: swapchain->lpVtbl = &IWineD3DSwapChain_Vtbl; break; case SURFACE_UNKNOWN: FIXME("Caller tried to create a SURFACE_UNKNOWN swapchain.\n"); return WINED3DERR_INVALIDCALL; } #ifdef VBOX_WITH_WDDM if (present_parameters->hDeviceWindow) { overridenSwapchain = swapchain_find(device, present_parameters->hDeviceWindow); if (!overridenSwapchain) { ERR("invalid window handle supplied"); return E_FAIL; } window = overridenSwapchain->win_handle; hDC = overridenSwapchain->hDC; } else { hr = VBoxExtWndCreate(present_parameters->BackBufferWidth, present_parameters->BackBufferHeight, &window, &hDC); if (FAILED(hr)) { ERR("VBoxExtWndCreate failed, hr 0x%x", hr); return hr; } } Assert(window); Assert(hDC); present_parameters->hDeviceWindow = window; #else window = present_parameters->hDeviceWindow ? present_parameters->hDeviceWindow : device->createParms.hFocusWindow; #endif swapchain->device = device; swapchain->parent = parent; swapchain->ref = 1; swapchain->win_handle = window; #ifndef VBOX_WITH_WDDM swapchain->device_window = window; #else Assert(window); swapchain->hDC = hDC; swapchain->presentRt = NULL; #endif if (!present_parameters->Windowed && window) { swapchain_setup_fullscreen_window(swapchain, present_parameters->BackBufferWidth, present_parameters->BackBufferHeight); } IWineD3D_GetAdapterDisplayMode(device->wined3d, adapter->ordinal, &mode); swapchain->orig_width = mode.Width; swapchain->orig_height = mode.Height; swapchain->orig_fmt = mode.Format; format_desc = getFormatDescEntry(mode.Format, &adapter->gl_info); #ifndef VBOX_WITH_WDDM GetClientRect(window, &client_rect); #else client_rect.left = 0; client_rect.top = 0; client_rect.right = present_parameters->BackBufferWidth; client_rect.bottom = present_parameters->BackBufferHeight; #endif if (present_parameters->Windowed && (!present_parameters->BackBufferWidth || !present_parameters->BackBufferHeight || present_parameters->BackBufferFormat == WINED3DFMT_UNKNOWN)) { if (!present_parameters->BackBufferWidth) { present_parameters->BackBufferWidth = client_rect.right; TRACE("Updating width to %u.\n", present_parameters->BackBufferWidth); } if (!present_parameters->BackBufferHeight) { present_parameters->BackBufferHeight = client_rect.bottom; TRACE("Updating height to %u.\n", present_parameters->BackBufferHeight); } if (present_parameters->BackBufferFormat == WINED3DFMT_UNKNOWN) { present_parameters->BackBufferFormat = swapchain->orig_fmt; TRACE("Updating format to %s.\n", debug_d3dformat(swapchain->orig_fmt)); } } swapchain->presentParms = *present_parameters; if (wined3d_settings.offscreen_rendering_mode == ORM_FBO && present_parameters->BackBufferCount && (present_parameters->BackBufferWidth != client_rect.right || present_parameters->BackBufferHeight != client_rect.bottom)) { TRACE("Rendering to FBO. Backbuffer %ux%u, window %ux%u.\n", present_parameters->BackBufferWidth, present_parameters->BackBufferHeight, client_rect.right, client_rect.bottom); swapchain->render_to_fbo = TRUE; } TRACE("Creating front buffer.\n"); hr = IWineD3DDeviceParent_CreateRenderTarget(device->device_parent, parent, swapchain->presentParms.BackBufferWidth, swapchain->presentParms.BackBufferHeight, swapchain->presentParms.BackBufferFormat, swapchain->presentParms.MultiSampleType, swapchain->presentParms.MultiSampleQuality, TRUE /* Lockable */, &swapchain->frontBuffer); if (FAILED(hr)) { WARN("Failed to create front buffer, hr %#x.\n", hr); goto err; } IWineD3DSurface_SetContainer(swapchain->frontBuffer, (IWineD3DBase *)swapchain); ((IWineD3DSurfaceImpl *)swapchain->frontBuffer)->Flags |= SFLAG_SWAPCHAIN; if (surface_type == SURFACE_OPENGL) { IWineD3DSurface_ModifyLocation(swapchain->frontBuffer, SFLAG_INDRAWABLE, TRUE); } /* MSDN says we're only allowed a single fullscreen swapchain per device, * so we should really check to see if there is a fullscreen swapchain * already. Does a single head count as full screen? */ if (!present_parameters->Windowed) { WINED3DDISPLAYMODE mode; /* Change the display settings */ mode.Width = present_parameters->BackBufferWidth; mode.Height = present_parameters->BackBufferHeight; mode.Format = present_parameters->BackBufferFormat; mode.RefreshRate = present_parameters->FullScreen_RefreshRateInHz; hr = IWineD3DDevice_SetDisplayMode((IWineD3DDevice *)device, 0, &mode); if (FAILED(hr)) { WARN("Failed to set display mode, hr %#x.\n", hr); goto err; } displaymode_set = TRUE; } #ifndef VBOX_WITH_WDDM swapchain->context = HeapAlloc(GetProcessHeap(), 0, sizeof(swapchain->context)); if (!swapchain->context) { ERR("Failed to create the context array.\n"); hr = E_OUTOFMEMORY; goto err; } swapchain->num_contexts = 1; #endif if (surface_type == SURFACE_OPENGL) { #ifdef VBOX_WITH_WDDM struct wined3d_context * swapchainContext; #endif const struct wined3d_gl_info *gl_info = &device->adapter->gl_info; /* In WGL both color, depth and stencil are features of a pixel format. In case of D3D they are separate. * You are able to add a depth + stencil surface at a later stage when you need it. * In order to support this properly in WineD3D we need the ability to recreate the opengl context and * drawable when this is required. This is very tricky as we need to reapply ALL opengl states for the new * context, need torecreate shaders, textures and other resources. * * The context manager already takes care of the state problem and for the other tasks code from Reset * can be used. These changes are way to risky during the 1.0 code freeze which is taking place right now. * Likely a lot of other new bugs will be exposed. For that reason request a depth stencil surface all the * time. It can cause a slight performance hit but fixes a lot of regressions. A fixme reminds of that this * issue needs to be fixed. */ if (!present_parameters->EnableAutoDepthStencil || swapchain->presentParms.AutoDepthStencilFormat != WINED3DFMT_D24_UNORM_S8_UINT) { FIXME("Add OpenGL context recreation support to context_validate_onscreen_formats\n"); } swapchain->ds_format = getFormatDescEntry(WINED3DFMT_D24_UNORM_S8_UINT, gl_info); #ifdef VBOX_WITH_WDDM swapchainContext = context_find_create(device, swapchain, (IWineD3DSurfaceImpl *)swapchain->frontBuffer, swapchain->ds_format); if (!swapchainContext) #else swapchain->context[0] = context_create(swapchain, (IWineD3DSurfaceImpl *)swapchain->frontBuffer, swapchain->ds_format); if (!swapchain->context[0]) #endif { WARN("Failed to create context.\n"); hr = WINED3DERR_NOTAVAILABLE; goto err; } #ifdef VBOX_WITH_WDDM context_release(swapchainContext); #else context_release(swapchain->context[0]); #endif } else { #ifndef VBOX_WITH_WDDM swapchain->context[0] = NULL; #endif } if (swapchain->presentParms.BackBufferCount > 0) { swapchain->backBuffer = HeapAlloc(GetProcessHeap(), 0, sizeof(*swapchain->backBuffer) * swapchain->presentParms.BackBufferCount); if (!swapchain->backBuffer) { ERR("Failed to allocate backbuffer array memory.\n"); hr = E_OUTOFMEMORY; goto err; } for (i = 0; i < swapchain->presentParms.BackBufferCount; ++i) { TRACE("Creating back buffer %u.\n", i); hr = IWineD3DDeviceParent_CreateRenderTarget(device->device_parent, parent, swapchain->presentParms.BackBufferWidth, swapchain->presentParms.BackBufferHeight, swapchain->presentParms.BackBufferFormat, swapchain->presentParms.MultiSampleType, swapchain->presentParms.MultiSampleQuality, TRUE /* Lockable */, &swapchain->backBuffer[i]); if (FAILED(hr)) { WARN("Failed to create back buffer %u, hr %#x.\n", i, hr); goto err; } IWineD3DSurface_SetContainer(swapchain->backBuffer[i], (IWineD3DBase *)swapchain); ((IWineD3DSurfaceImpl *)swapchain->backBuffer[i])->Flags |= SFLAG_SWAPCHAIN; } } /* Swapchains share the depth/stencil buffer, so only create a single depthstencil surface. */ if (present_parameters->EnableAutoDepthStencil && surface_type == SURFACE_OPENGL) { TRACE("Creating depth/stencil buffer.\n"); if (!device->auto_depth_stencil_buffer) { hr = IWineD3DDeviceParent_CreateDepthStencilSurface(device->device_parent, parent, swapchain->presentParms.BackBufferWidth, swapchain->presentParms.BackBufferHeight, swapchain->presentParms.AutoDepthStencilFormat, swapchain->presentParms.MultiSampleType, swapchain->presentParms.MultiSampleQuality, FALSE /* FIXME: Discard */, &device->auto_depth_stencil_buffer); if (FAILED(hr)) { WARN("Failed to create the auto depth stencil, hr %#x.\n", hr); goto err; } IWineD3DSurface_SetContainer(device->auto_depth_stencil_buffer, NULL); } } IWineD3DSwapChain_GetGammaRamp((IWineD3DSwapChain *)swapchain, &swapchain->orig_gamma); #ifdef VBOX_WITH_WDDM if (overridenSwapchain) { swapchain_invalidate(overridenSwapchain); } #endif return WINED3D_OK; err: if (displaymode_set) { DEVMODEW devmode; ClipCursor(NULL); /* Change the display settings */ memset(&devmode, 0, sizeof(devmode)); devmode.dmSize = sizeof(devmode); devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT; devmode.dmBitsPerPel = format_desc->byte_count * 8; devmode.dmPelsWidth = swapchain->orig_width; devmode.dmPelsHeight = swapchain->orig_height; ChangeDisplaySettingsExW(adapter->DeviceName, &devmode, NULL, CDS_FULLSCREEN, NULL); } if (swapchain->backBuffer) { for (i = 0; i < swapchain->presentParms.BackBufferCount; ++i) { if (swapchain->backBuffer[i]) IWineD3DSurface_Release(swapchain->backBuffer[i]); } HeapFree(GetProcessHeap(), 0, swapchain->backBuffer); } #ifdef VBOX_WITH_WDDM if (!device->NumberOfSwapChains) { while (device->numContexts) { context_destroy(device, device->contexts[0]); } } #else if (swapchain->context) { if (swapchain->context[0]) { context_release(swapchain->context[0]); context_destroy(device, swapchain->context[0]); swapchain->num_contexts = 0; } HeapFree(GetProcessHeap(), 0, swapchain->context); } #endif if (swapchain->frontBuffer) IWineD3DSurface_Release(swapchain->frontBuffer); #ifdef VBOX_WITH_WDDM if (!overridenSwapchain && swapchain->win_handle) { VBoxExtWndDestroy(swapchain->win_handle, swapchain->hDC); } swapchain_invalidate(swapchain); #endif return hr; }
/****************************************************************** * MSVIDEO_MapMsg16To32 * * */ static LPVOID MSVIDEO_MapMsg16To32(UINT msg, LPDWORD lParam1, LPDWORD lParam2) { LPVOID ret = 0; TRACE("Mapping %d\n", msg); switch (msg) { case DRV_LOAD: case DRV_ENABLE: case DRV_CLOSE: case DRV_DISABLE: case DRV_FREE: case ICM_ABOUT: case ICM_CONFIGURE: case ICM_COMPRESS_END: case ICM_DECOMPRESS_END: case ICM_DECOMPRESSEX_END: case ICM_SETQUALITY: case ICM_DRAW_START_PLAY: case ICM_DRAW_STOP_PLAY: case ICM_DRAW_REALIZE: case ICM_DRAW_RENDERBUFFER: case ICM_DRAW_END: break; case DRV_OPEN: case ICM_GETDEFAULTQUALITY: case ICM_GETQUALITY: case ICM_SETSTATE: case ICM_DRAW_WINDOW: case ICM_GETBUFFERSWANTED: *lParam1 = (DWORD)MapSL(*lParam1); break; case ICM_GETINFO: { ICINFO *ici = HeapAlloc(GetProcessHeap(), 0, sizeof(ICINFO)); ICINFO16 *ici16; ici16 = MapSL(*lParam1); ret = ici16; ici->dwSize = sizeof(ICINFO); COPY(ici, fccType); COPY(ici, fccHandler); COPY(ici, dwFlags); COPY(ici, dwVersion); COPY(ici, dwVersionICM); MultiByteToWideChar( CP_ACP, 0, ici16->szName, -1, ici->szName, 16 ); MultiByteToWideChar( CP_ACP, 0, ici16->szDescription, -1, ici->szDescription, 128 ); MultiByteToWideChar( CP_ACP, 0, ici16->szDriver, -1, ici->szDriver, 128 ); *lParam1 = (DWORD)(ici); *lParam2 = sizeof(ICINFO); } break; case ICM_COMPRESS: { ICCOMPRESS *icc = HeapAlloc(GetProcessHeap(), 0, sizeof(ICCOMPRESS)); ICCOMPRESS *icc16; icc16 = MapSL(*lParam1); ret = icc16; COPY(icc, dwFlags); COPYPTR(icc, lpbiOutput); COPYPTR(icc, lpOutput); COPYPTR(icc, lpbiInput); COPYPTR(icc, lpInput); COPYPTR(icc, lpckid); COPYPTR(icc, lpdwFlags); COPY(icc, lFrameNum); COPY(icc, dwFrameSize); COPY(icc, dwQuality); COPYPTR(icc, lpbiPrev); COPYPTR(icc, lpPrev); *lParam1 = (DWORD)(icc); *lParam2 = sizeof(ICCOMPRESS); } break; case ICM_DECOMPRESS: { ICDECOMPRESS *icd = HeapAlloc(GetProcessHeap(), 0, sizeof(ICDECOMPRESS)); ICDECOMPRESS *icd16; /* Same structure except for the pointers */ icd16 = MapSL(*lParam1); ret = icd16; COPY(icd, dwFlags); COPYPTR(icd, lpbiInput); COPYPTR(icd, lpInput); COPYPTR(icd, lpbiOutput); COPYPTR(icd, lpOutput); COPY(icd, ckid); *lParam1 = (DWORD)(icd); *lParam2 = sizeof(ICDECOMPRESS); } break; case ICM_COMPRESS_BEGIN: case ICM_COMPRESS_GET_FORMAT: case ICM_COMPRESS_GET_SIZE: case ICM_COMPRESS_QUERY: case ICM_DECOMPRESS_GET_FORMAT: case ICM_DECOMPRESS_QUERY: case ICM_DECOMPRESS_BEGIN: case ICM_DECOMPRESS_SET_PALETTE: case ICM_DECOMPRESS_GET_PALETTE: *lParam1 = (DWORD)MapSL(*lParam1); *lParam2 = (DWORD)MapSL(*lParam2); break; case ICM_DECOMPRESSEX_QUERY: if ((*lParam2 != sizeof(ICDECOMPRESSEX16)) && (*lParam2 != 0)) WARN("*lParam2 has unknown value %p\n", (ICDECOMPRESSEX16*)*lParam2); /* FIXME: *lParm2 is meant to be 0 or an ICDECOMPRESSEX16*, but is sizeof(ICDECOMRPESSEX16) * This is because of ICMessage(). Special case it? { LPVOID* addr = HeapAlloc(GetProcessHeap(), 0, 2*sizeof(LPVOID)); addr[0] = MSVIDEO_MapICDEX16To32(lParam1); if (*lParam2) addr[1] = MSVIDEO_MapICDEX16To32(lParam2); else addr[1] = 0; ret = addr; } break;*/ case ICM_DECOMPRESSEX_BEGIN: case ICM_DECOMPRESSEX: ret = MSVIDEO_MapICDEX16To32(lParam1); *lParam2 = sizeof(ICDECOMPRESSEX); break; case ICM_DRAW_BEGIN: { ICDRAWBEGIN *icdb = HeapAlloc(GetProcessHeap(), 0, sizeof(ICDRAWBEGIN)); ICDRAWBEGIN16 *icdb16 = MapSL(*lParam1); ret = icdb16; COPY(icdb, dwFlags); icdb->hpal = HPALETTE_32(icdb16->hpal); icdb->hwnd = HWND_32(icdb16->hwnd); icdb->hdc = HDC_32(icdb16->hdc); COPY(icdb, xDst); COPY(icdb, yDst); COPY(icdb, dxDst); COPY(icdb, dyDst); COPYPTR(icdb, lpbi); COPY(icdb, xSrc); COPY(icdb, ySrc); COPY(icdb, dxSrc); COPY(icdb, dySrc); COPY(icdb, dwRate); COPY(icdb, dwScale); *lParam1 = (DWORD)(icdb); *lParam2 = sizeof(ICDRAWBEGIN); } break; case ICM_DRAW_SUGGESTFORMAT: { ICDRAWSUGGEST *icds = HeapAlloc(GetProcessHeap(), 0, sizeof(ICDRAWSUGGEST)); ICDRAWSUGGEST16 *icds16 = MapSL(*lParam1); ret = icds16; COPY(icds, dwFlags); COPYPTR(icds, lpbiIn); COPYPTR(icds, lpbiSuggest); COPY(icds, dxSrc); COPY(icds, dySrc); COPY(icds, dxDst); COPY(icds, dyDst); icds->hicDecompressor = HIC_32(icds16->hicDecompressor); *lParam1 = (DWORD)(icds); *lParam2 = sizeof(ICDRAWSUGGEST); } break; case ICM_DRAW: { ICDRAW *icd = HeapAlloc(GetProcessHeap(), 0, sizeof(ICDRAW)); ICDRAW *icd16 = MapSL(*lParam1); ret = icd16; COPY(icd, dwFlags); COPYPTR(icd, lpFormat); COPYPTR(icd, lpData); COPY(icd, cbData); COPY(icd, lTime); *lParam1 = (DWORD)(icd); *lParam2 = sizeof(ICDRAW); } break; case ICM_DRAW_START: case ICM_DRAW_STOP: break; default: FIXME("%d is not yet handled. Expect a crash.\n", msg); } return ret; }
/* Tesselates a high order rectangular patch into single triangles using gl evaluators * * The problem is that OpenGL does not offer a direct way to return the tesselated primitives, * and they can't be sent off for rendering directly either. Tesselating is slow, so we want * to cache the patches in a vertex buffer. But more importantly, gl can't bind generated * attributes to numbered shader attributes, so we have to store them and rebind them as needed * in drawprim. * * To read back, the opengl feedback mode is used. This creates a problem because we want * untransformed, unlit vertices, but feedback runs everything through transform and lighting. * Thus disable lighting and set identity matrices to get unmodified colors and positions. * To overcome clipping find the biggest x, y and z values of the vertices in the patch and scale * them to [-1.0;+1.0] and set the viewport up to scale them back. * * Normals are more tricky: Draw white vertices with 3 directional lights, and calculate the * resulting colors back to the normals. * * NOTE: This function activates a context for blitting, modifies matrices & viewport, but * does not restore it because normally a draw follows immediately afterwards. The caller is * responsible of taking care that either the gl states are restored, or the context activated * for drawing to reset the lastWasBlit flag. */ HRESULT tesselate_rectpatch(IWineD3DDeviceImpl *This, struct WineD3DRectPatch *patch) { unsigned int i, j, num_quads, out_vertex_size, buffer_size, d3d_out_vertex_size; float max_x = 0.0f, max_y = 0.0f, max_z = 0.0f, neg_z = 0.0f; struct wined3d_stream_info stream_info; struct wined3d_stream_info_element *e; struct wined3d_context *context; const BYTE *data; const WINED3DRECTPATCH_INFO *info = &patch->RectPatchInfo; DWORD vtxStride; GLenum feedback_type; GLfloat *feedbuffer; /* Simply activate the context for blitting. This disables all the things we don't want and * takes care of dirtifying. Dirtifying is preferred over pushing / popping, since drawing the * patch (as opposed to normal draws) will most likely need different changes anyway. */ context = context_acquire(This, NULL); context_apply_blit_state(context, This); /* First, locate the position data. This is provided in a vertex buffer in the stateblock. * Beware of vbos */ device_stream_info_from_declaration(This, FALSE, &stream_info, NULL); e = &stream_info.elements[WINED3D_FFP_POSITION]; if (e->buffer_object) { struct wined3d_buffer *vb; vb = (struct wined3d_buffer *)This->stateBlock->streamSource[e->stream_idx]; e->data = (BYTE *)((ULONG_PTR)e->data + (ULONG_PTR)buffer_get_sysmem(vb, context->gl_info)); } vtxStride = e->stride; data = e->data + vtxStride * info->Stride * info->StartVertexOffsetHeight + vtxStride * info->StartVertexOffsetWidth; /* Not entirely sure about what happens with transformed vertices */ if (stream_info.position_transformed) FIXME("Transformed position in rectpatch generation\n"); if(vtxStride % sizeof(GLfloat)) { /* glMap2f reads vertex sizes in GLfloats, the d3d stride is in bytes. * I don't see how the stride could not be a multiple of 4, but make sure * to check it */ ERR("Vertex stride is not a multiple of sizeof(GLfloat)\n"); } if(info->Basis != WINED3DBASIS_BEZIER) { FIXME("Basis is %s, how to handle this?\n", debug_d3dbasis(info->Basis)); } if(info->Degree != WINED3DDEGREE_CUBIC) { FIXME("Degree is %s, how to handle this?\n", debug_d3ddegree(info->Degree)); } /* First, get the boundary cube of the input data */ for(j = 0; j < info->Height; j++) { for(i = 0; i < info->Width; i++) { const float *v = (const float *)(data + vtxStride * i + vtxStride * info->Stride * j); if(fabs(v[0]) > max_x) max_x = fabs(v[0]); if(fabs(v[1]) > max_y) max_y = fabs(v[1]); if(fabs(v[2]) > max_z) max_z = fabs(v[2]); if(v[2] < neg_z) neg_z = v[2]; } } /* This needs some improvements in the vertex decl code */ FIXME("Cannot find data to generate. Only generating position and normals\n"); patch->has_normals = TRUE; patch->has_texcoords = FALSE; ENTER_GL(); glMatrixMode(GL_PROJECTION); checkGLcall("glMatrixMode(GL_PROJECTION)"); glLoadIdentity(); checkGLcall("glLoadIndentity()"); glScalef(1.0f / (max_x), 1.0f / (max_y), max_z == 0.0f ? 1.0f : 1.0f / (2.0f * max_z)); glTranslatef(0.0f, 0.0f, 0.5f); checkGLcall("glScalef"); glViewport(-max_x, -max_y, 2 * (max_x), 2 * (max_y)); checkGLcall("glViewport"); /* Some states to take care of. If we're in wireframe opengl will produce lines, and confuse * our feedback buffer parser */ glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)"); IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_FILLMODE)); if(patch->has_normals) { static const GLfloat black[] = {0.0f, 0.0f, 0.0f, 0.0f}; static const GLfloat red[] = {1.0f, 0.0f, 0.0f, 0.0f}; static const GLfloat green[] = {0.0f, 1.0f, 0.0f, 0.0f}; static const GLfloat blue[] = {0.0f, 0.0f, 1.0f, 0.0f}; static const GLfloat white[] = {1.0f, 1.0f, 1.0f, 1.0f}; glEnable(GL_LIGHTING); checkGLcall("glEnable(GL_LIGHTING)"); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, black); checkGLcall("glLightModel for MODEL_AMBIENT"); IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_AMBIENT)); for (i = 3; i < context->gl_info->limits.lights; ++i) { glDisable(GL_LIGHT0 + i); checkGLcall("glDisable(GL_LIGHT0 + i)"); IWineD3DDeviceImpl_MarkStateDirty(This, STATE_ACTIVELIGHT(i)); } IWineD3DDeviceImpl_MarkStateDirty(This, STATE_ACTIVELIGHT(0)); glLightfv(GL_LIGHT0, GL_DIFFUSE, red); glLightfv(GL_LIGHT0, GL_SPECULAR, black); glLightfv(GL_LIGHT0, GL_AMBIENT, black); glLightfv(GL_LIGHT0, GL_POSITION, red); glEnable(GL_LIGHT0); checkGLcall("Setting up light 1"); IWineD3DDeviceImpl_MarkStateDirty(This, STATE_ACTIVELIGHT(1)); glLightfv(GL_LIGHT1, GL_DIFFUSE, green); glLightfv(GL_LIGHT1, GL_SPECULAR, black); glLightfv(GL_LIGHT1, GL_AMBIENT, black); glLightfv(GL_LIGHT1, GL_POSITION, green); glEnable(GL_LIGHT1); checkGLcall("Setting up light 2"); IWineD3DDeviceImpl_MarkStateDirty(This, STATE_ACTIVELIGHT(2)); glLightfv(GL_LIGHT2, GL_DIFFUSE, blue); glLightfv(GL_LIGHT2, GL_SPECULAR, black); glLightfv(GL_LIGHT2, GL_AMBIENT, black); glLightfv(GL_LIGHT2, GL_POSITION, blue); glEnable(GL_LIGHT2); checkGLcall("Setting up light 3"); IWineD3DDeviceImpl_MarkStateDirty(This, STATE_MATERIAL); IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_COLORVERTEX)); glDisable(GL_COLOR_MATERIAL); glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, black); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, black); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, white); checkGLcall("Setting up materials"); } /* Enable the needed maps. * GL_MAP2_VERTEX_3 is needed for positional data. * GL_AUTO_NORMAL to generate normals from the position. Do not use GL_MAP2_NORMAL. * GL_MAP2_TEXTURE_COORD_4 for texture coords */ num_quads = ceilf(patch->numSegs[0]) * ceilf(patch->numSegs[1]); out_vertex_size = 3 /* position */; d3d_out_vertex_size = 3; glEnable(GL_MAP2_VERTEX_3); if(patch->has_normals && patch->has_texcoords) { FIXME("Texcoords not handled yet\n"); feedback_type = GL_3D_COLOR_TEXTURE; out_vertex_size += 8; d3d_out_vertex_size += 7; glEnable(GL_AUTO_NORMAL); glEnable(GL_MAP2_TEXTURE_COORD_4); } else if(patch->has_texcoords) { FIXME("Texcoords not handled yet\n"); feedback_type = GL_3D_COLOR_TEXTURE; out_vertex_size += 7; d3d_out_vertex_size += 4; glEnable(GL_MAP2_TEXTURE_COORD_4); } else if(patch->has_normals) { feedback_type = GL_3D_COLOR; out_vertex_size += 4; d3d_out_vertex_size += 3; glEnable(GL_AUTO_NORMAL); } else { feedback_type = GL_3D; } checkGLcall("glEnable vertex attrib generation"); buffer_size = num_quads * out_vertex_size * 2 /* triangle list */ * 3 /* verts per tri */ + 4 * num_quads /* 2 triangle markers per quad + num verts in tri */; feedbuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buffer_size * sizeof(float) * 8); glMap2f(GL_MAP2_VERTEX_3, 0.0f, 1.0f, vtxStride / sizeof(float), info->Width, 0.0f, 1.0f, info->Stride * vtxStride / sizeof(float), info->Height, (const GLfloat *)data); checkGLcall("glMap2f"); if(patch->has_texcoords) { glMap2f(GL_MAP2_TEXTURE_COORD_4, 0.0f, 1.0f, vtxStride / sizeof(float), info->Width, 0.0f, 1.0f, info->Stride * vtxStride / sizeof(float), info->Height, (const GLfloat *)data); checkGLcall("glMap2f"); } glMapGrid2f(ceilf(patch->numSegs[0]), 0.0f, 1.0f, ceilf(patch->numSegs[1]), 0.0f, 1.0f); checkGLcall("glMapGrid2f"); glFeedbackBuffer(buffer_size * 2, feedback_type, feedbuffer); checkGLcall("glFeedbackBuffer"); glRenderMode(GL_FEEDBACK); glEvalMesh2(GL_FILL, 0, ceilf(patch->numSegs[0]), 0, ceilf(patch->numSegs[1])); checkGLcall("glEvalMesh2"); i = glRenderMode(GL_RENDER); if(i == -1) { LEAVE_GL(); ERR("Feedback failed. Expected %d elements back\n", buffer_size); HeapFree(GetProcessHeap(), 0, feedbuffer); context_release(context); return WINED3DERR_DRIVERINTERNALERROR; } else if(i != buffer_size) { LEAVE_GL(); ERR("Unexpected amount of elements returned. Expected %d, got %d\n", buffer_size, i); HeapFree(GetProcessHeap(), 0, feedbuffer); context_release(context); return WINED3DERR_DRIVERINTERNALERROR; } else { TRACE("Got %d elements as expected\n", i); } HeapFree(GetProcessHeap(), 0, patch->mem); patch->mem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, num_quads * 6 * d3d_out_vertex_size * sizeof(float) * 8); i = 0; for(j = 0; j < buffer_size; j += (3 /* num verts */ * out_vertex_size + 2 /* tri marker */)) { if(feedbuffer[j] != GL_POLYGON_TOKEN) { ERR("Unexpected token: %f\n", feedbuffer[j]); continue; } if(feedbuffer[j + 1] != 3) { ERR("Unexpected polygon: %f corners\n", feedbuffer[j + 1]); continue; } /* Somehow there are different ideas about back / front facing, so fix up the * vertex order */ patch->mem[i + 0] = feedbuffer[j + out_vertex_size * 2 + 2]; /* x, triangle 2 */ patch->mem[i + 1] = feedbuffer[j + out_vertex_size * 2 + 3]; /* y, triangle 2 */ patch->mem[i + 2] = (feedbuffer[j + out_vertex_size * 2 + 4] - 0.5f) * 4.0f * max_z; /* z, triangle 3 */ if(patch->has_normals) { patch->mem[i + 3] = feedbuffer[j + out_vertex_size * 2 + 5]; patch->mem[i + 4] = feedbuffer[j + out_vertex_size * 2 + 6]; patch->mem[i + 5] = feedbuffer[j + out_vertex_size * 2 + 7]; } i += d3d_out_vertex_size; patch->mem[i + 0] = feedbuffer[j + out_vertex_size * 1 + 2]; /* x, triangle 2 */ patch->mem[i + 1] = feedbuffer[j + out_vertex_size * 1 + 3]; /* y, triangle 2 */ patch->mem[i + 2] = (feedbuffer[j + out_vertex_size * 1 + 4] - 0.5f) * 4.0f * max_z; /* z, triangle 2 */ if(patch->has_normals) { patch->mem[i + 3] = feedbuffer[j + out_vertex_size * 1 + 5]; patch->mem[i + 4] = feedbuffer[j + out_vertex_size * 1 + 6]; patch->mem[i + 5] = feedbuffer[j + out_vertex_size * 1 + 7]; } i += d3d_out_vertex_size; patch->mem[i + 0] = feedbuffer[j + out_vertex_size * 0 + 2]; /* x, triangle 1 */ patch->mem[i + 1] = feedbuffer[j + out_vertex_size * 0 + 3]; /* y, triangle 1 */ patch->mem[i + 2] = (feedbuffer[j + out_vertex_size * 0 + 4] - 0.5f) * 4.0f * max_z; /* z, triangle 1 */ if(patch->has_normals) { patch->mem[i + 3] = feedbuffer[j + out_vertex_size * 0 + 5]; patch->mem[i + 4] = feedbuffer[j + out_vertex_size * 0 + 6]; patch->mem[i + 5] = feedbuffer[j + out_vertex_size * 0 + 7]; } i += d3d_out_vertex_size; } if(patch->has_normals) { /* Now do the same with reverse light directions */ static const GLfloat x[] = {-1.0f, 0.0f, 0.0f, 0.0f}; static const GLfloat y[] = { 0.0f, -1.0f, 0.0f, 0.0f}; static const GLfloat z[] = { 0.0f, 0.0f, -1.0f, 0.0f}; glLightfv(GL_LIGHT0, GL_POSITION, x); glLightfv(GL_LIGHT1, GL_POSITION, y); glLightfv(GL_LIGHT2, GL_POSITION, z); checkGLcall("Setting up reverse light directions"); glRenderMode(GL_FEEDBACK); checkGLcall("glRenderMode(GL_FEEDBACK)"); glEvalMesh2(GL_FILL, 0, ceilf(patch->numSegs[0]), 0, ceilf(patch->numSegs[1])); checkGLcall("glEvalMesh2"); i = glRenderMode(GL_RENDER); checkGLcall("glRenderMode(GL_RENDER)"); i = 0; for(j = 0; j < buffer_size; j += (3 /* num verts */ * out_vertex_size + 2 /* tri marker */)) { if(feedbuffer[j] != GL_POLYGON_TOKEN) { ERR("Unexpected token: %f\n", feedbuffer[j]); continue; } if(feedbuffer[j + 1] != 3) { ERR("Unexpected polygon: %f corners\n", feedbuffer[j + 1]); continue; } if(patch->mem[i + 3] == 0.0f) patch->mem[i + 3] = -feedbuffer[j + out_vertex_size * 2 + 5]; if(patch->mem[i + 4] == 0.0f) patch->mem[i + 4] = -feedbuffer[j + out_vertex_size * 2 + 6]; if(patch->mem[i + 5] == 0.0f) patch->mem[i + 5] = -feedbuffer[j + out_vertex_size * 2 + 7]; normalize_normal(patch->mem + i + 3); i += d3d_out_vertex_size; if(patch->mem[i + 3] == 0.0f) patch->mem[i + 3] = -feedbuffer[j + out_vertex_size * 1 + 5]; if(patch->mem[i + 4] == 0.0f) patch->mem[i + 4] = -feedbuffer[j + out_vertex_size * 1 + 6]; if(patch->mem[i + 5] == 0.0f) patch->mem[i + 5] = -feedbuffer[j + out_vertex_size * 1 + 7]; normalize_normal(patch->mem + i + 3); i += d3d_out_vertex_size; if(patch->mem[i + 3] == 0.0f) patch->mem[i + 3] = -feedbuffer[j + out_vertex_size * 0 + 5]; if(patch->mem[i + 4] == 0.0f) patch->mem[i + 4] = -feedbuffer[j + out_vertex_size * 0 + 6]; if(patch->mem[i + 5] == 0.0f) patch->mem[i + 5] = -feedbuffer[j + out_vertex_size * 0 + 7]; normalize_normal(patch->mem + i + 3); i += d3d_out_vertex_size; } } glDisable(GL_MAP2_VERTEX_3); glDisable(GL_AUTO_NORMAL); glDisable(GL_MAP2_NORMAL); glDisable(GL_MAP2_TEXTURE_COORD_4); checkGLcall("glDisable vertex attrib generation"); LEAVE_GL(); context_release(context); HeapFree(GetProcessHeap(), 0, feedbuffer); vtxStride = 3 * sizeof(float); if(patch->has_normals) { vtxStride += 3 * sizeof(float); } if(patch->has_texcoords) { vtxStride += 4 * sizeof(float); } memset(&patch->strided, 0, sizeof(patch->strided)); patch->strided.position.format = WINED3DFMT_R32G32B32_FLOAT; patch->strided.position.lpData = (BYTE *) patch->mem; patch->strided.position.dwStride = vtxStride; if(patch->has_normals) { patch->strided.normal.format = WINED3DFMT_R32G32B32_FLOAT; patch->strided.normal.lpData = (BYTE *) patch->mem + 3 * sizeof(float) /* pos */; patch->strided.normal.dwStride = vtxStride; } if(patch->has_texcoords) { patch->strided.texCoords[0].format = WINED3DFMT_R32G32B32A32_FLOAT; patch->strided.texCoords[0].lpData = (BYTE *) patch->mem + 3 * sizeof(float) /* pos */; if(patch->has_normals) { patch->strided.texCoords[0].lpData += 3 * sizeof(float); } patch->strided.texCoords[0].dwStride = vtxStride; } return WINED3D_OK; }
static BOOL EnumServices(ENUM_SERVICE_STATUS_PROCESS **pServiceStatus, DWORD ServiceType, DWORD ServiceState) { SC_HANDLE hSCManager; DWORD BufSize = 0; DWORD BytesNeeded = 0; DWORD ResumeHandle = 0; DWORD NumServices = 0; DWORD Ret; hSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ENUMERATE_SERVICE); if (hSCManager == NULL) { ReportLastError(); return FALSE; } Ret = EnumServicesStatusEx(hSCManager, SC_ENUM_PROCESS_INFO, ServiceType, ServiceState, (LPBYTE)*pServiceStatus, BufSize, &BytesNeeded, &NumServices, &ResumeHandle, 0); if ((Ret == 0) && (GetLastError() == ERROR_MORE_DATA)) { *pServiceStatus = (ENUM_SERVICE_STATUS_PROCESS *) HeapAlloc(GetProcessHeap(), 0, BytesNeeded); if (*pServiceStatus != NULL) { if (EnumServicesStatusEx(hSCManager, SC_ENUM_PROCESS_INFO, ServiceType, ServiceState, (LPBYTE)*pServiceStatus, BytesNeeded, &BytesNeeded, &NumServices, &ResumeHandle, 0)) { CloseServiceHandle(hSCManager); return NumServices; } } } ReportLastError(); if (*pServiceStatus) HeapFree(GetProcessHeap(), 0, *pServiceStatus); CloseServiceHandle(hSCManager); return NumServices; }
/************************************************************* * BIDI_Reorder * * Returns TRUE if reordering was required and done. */ BOOL BIDI_Reorder( HDC hDC, /*[in] Display DC */ LPCWSTR lpString, /* [in] The string for which information is to be returned */ INT uCount, /* [in] Number of WCHARs in string. */ DWORD dwFlags, /* [in] GetCharacterPlacement compatible flags specifying how to process the string */ DWORD dwWineGCP_Flags, /* [in] Wine internal flags - Force paragraph direction */ LPWSTR lpOutString, /* [out] Reordered string */ INT uCountOut, /* [in] Size of output buffer */ UINT *lpOrder, /* [out] Logical -> Visual order map */ WORD **lpGlyphs, /* [out] reordered, mirrored, shaped glyphs to display */ INT *cGlyphs /* [out] number of glyphs generated */ ) { WORD *chartype; BYTE *levels; INT i, done; unsigned glyph_i; BOOL is_complex; int maxItems; int nItems; SCRIPT_CONTROL Control; SCRIPT_STATE State; SCRIPT_ITEM *pItems; HRESULT res; SCRIPT_CACHE psc = NULL; WORD *run_glyphs = NULL; WORD *pwLogClust = NULL; SCRIPT_VISATTR *psva = NULL; DWORD cMaxGlyphs = 0; BOOL doGlyphs = TRUE; TRACE("%s, %d, 0x%08x lpOutString=%p, lpOrder=%p\n", debugstr_wn(lpString, uCount), uCount, dwFlags, lpOutString, lpOrder); memset(&Control, 0, sizeof(Control)); memset(&State, 0, sizeof(State)); if (lpGlyphs) *lpGlyphs = NULL; if (!(dwFlags & GCP_REORDER)) { FIXME("Asked to reorder without reorder flag set\n"); return FALSE; } if (lpOutString && uCountOut < uCount) { FIXME("lpOutString too small\n"); return FALSE; } chartype = HeapAlloc(GetProcessHeap(), 0, uCount * sizeof(WORD)); if (!chartype) { WARN("Out of memory\n"); return FALSE; } if (lpOutString) memcpy(lpOutString, lpString, uCount * sizeof(WCHAR)); is_complex = FALSE; for (i = 0; i < uCount && !is_complex; i++) { if ((lpString[i] >= 0x900 && lpString[i] <= 0xfff) || (lpString[i] >= 0x1cd0 && lpString[i] <= 0x1cff) || (lpString[i] >= 0xa840 && lpString[i] <= 0xa8ff)) is_complex = TRUE; } /* Verify reordering will be required */ if ((WINE_GCPW_FORCE_RTL == (dwWineGCP_Flags&WINE_GCPW_DIR_MASK)) || ((dwWineGCP_Flags&WINE_GCPW_DIR_MASK) == WINE_GCPW_LOOSE_RTL)) State.uBidiLevel = 1; else if (!is_complex) { done = 1; classify(lpString, chartype, uCount); for (i = 0; i < uCount; i++) switch (chartype[i]) { case R: case AL: case RLE: case RLO: done = 0; break; } if (done) { HeapFree(GetProcessHeap(), 0, chartype); if (lpOrder) { for (i = 0; i < uCount; i++) lpOrder[i] = i; } return TRUE; } } levels = HeapAlloc(GetProcessHeap(), 0, uCount * sizeof(BYTE)); if (!levels) { WARN("Out of memory\n"); HeapFree(GetProcessHeap(), 0, chartype); return FALSE; } maxItems = 5; pItems = HeapAlloc(GetProcessHeap(),0, maxItems * sizeof(SCRIPT_ITEM)); if (!pItems) { WARN("Out of memory\n"); HeapFree(GetProcessHeap(), 0, chartype); HeapFree(GetProcessHeap(), 0, levels); return FALSE; } if (lpGlyphs) { #ifdef __REACTOS__ /* ReactOS r57677 and r57679 */ cMaxGlyphs = 3 * uCount / 2 + 16; #else cMaxGlyphs = 1.5 * uCount + 16; #endif run_glyphs = HeapAlloc(GetProcessHeap(),0,sizeof(WORD) * cMaxGlyphs); if (!run_glyphs) { WARN("Out of memory\n"); HeapFree(GetProcessHeap(), 0, chartype); HeapFree(GetProcessHeap(), 0, levels); HeapFree(GetProcessHeap(), 0, pItems); return FALSE; } pwLogClust = HeapAlloc(GetProcessHeap(),0,sizeof(WORD) * uCount); if (!pwLogClust) { WARN("Out of memory\n"); HeapFree(GetProcessHeap(), 0, chartype); HeapFree(GetProcessHeap(), 0, levels); HeapFree(GetProcessHeap(), 0, pItems); HeapFree(GetProcessHeap(), 0, run_glyphs); return FALSE; } psva = HeapAlloc(GetProcessHeap(),0,sizeof(SCRIPT_VISATTR) * uCount); if (!psva) { WARN("Out of memory\n"); HeapFree(GetProcessHeap(), 0, chartype); HeapFree(GetProcessHeap(), 0, levels); HeapFree(GetProcessHeap(), 0, pItems); HeapFree(GetProcessHeap(), 0, run_glyphs); HeapFree(GetProcessHeap(), 0, pwLogClust); return FALSE; } } done = 0; glyph_i = 0; while (done < uCount) { INT j; classify(lpString + done, chartype, uCount - done); /* limit text to first block */ i = resolveParagraphs(chartype, uCount - done); for (j = 0; j < i; ++j) switch(chartype[j]) { case B: case S: case WS: case ON: chartype[j] = N; default: continue; } if ((dwWineGCP_Flags&WINE_GCPW_DIR_MASK) == WINE_GCPW_LOOSE_RTL) State.uBidiLevel = 1; else if ((dwWineGCP_Flags&WINE_GCPW_DIR_MASK) == WINE_GCPW_LOOSE_LTR) State.uBidiLevel = 0; if (dwWineGCP_Flags & WINE_GCPW_LOOSE_MASK) { for (j = 0; j < i; ++j) if (chartype[j] == L) { State.uBidiLevel = 0; break; } else if (chartype[j] == R || chartype[j] == AL) { State.uBidiLevel = 1; break; } } res = ScriptItemize(lpString + done, i, maxItems, &Control, &State, pItems, &nItems); while (res == E_OUTOFMEMORY) { maxItems = maxItems * 2; pItems = HeapReAlloc(GetProcessHeap(), 0, pItems, sizeof(SCRIPT_ITEM) * maxItems); if (!pItems) { WARN("Out of memory\n"); HeapFree(GetProcessHeap(), 0, chartype); HeapFree(GetProcessHeap(), 0, levels); HeapFree(GetProcessHeap(), 0, run_glyphs); HeapFree(GetProcessHeap(), 0, pwLogClust); HeapFree(GetProcessHeap(), 0, psva); return FALSE; } res = ScriptItemize(lpString + done, i, maxItems, &Control, &State, pItems, &nItems); } if (lpOutString || lpOrder) for (j = 0; j < nItems; j++) { int k; for (k = pItems[j].iCharPos; k < pItems[j+1].iCharPos; k++) levels[k] = pItems[j].a.s.uBidiLevel; } if (lpOutString) { /* assign directional types again, but for WS, S this time */ classify(lpString + done, chartype, i); BidiLines(State.uBidiLevel, lpOutString + done, lpString + done, chartype, levels, i, 0); } if (lpOrder) { int k, lastgood; for (j = lastgood = 0; j < i; ++j) if (levels[j] != levels[lastgood]) { --j; if (odd(levels[lastgood])) for (k = j; k >= lastgood; --k) lpOrder[done + k] = done + j - k; else for (k = lastgood; k <= j; ++k) lpOrder[done + k] = done + k; lastgood = ++j; } if (odd(levels[lastgood])) for (k = j - 1; k >= lastgood; --k) lpOrder[done + k] = done + j - 1 - k; else for (k = lastgood; k < j; ++k) lpOrder[done + k] = done + k; } if (lpGlyphs && doGlyphs) { BYTE *runOrder; int *visOrder; SCRIPT_ITEM *curItem; runOrder = HeapAlloc(GetProcessHeap(), 0, maxItems * sizeof(*runOrder)); visOrder = HeapAlloc(GetProcessHeap(), 0, maxItems * sizeof(*visOrder)); if (!runOrder || !visOrder) { WARN("Out of memory\n"); HeapFree(GetProcessHeap(), 0, runOrder); HeapFree(GetProcessHeap(), 0, visOrder); HeapFree(GetProcessHeap(), 0, chartype); HeapFree(GetProcessHeap(), 0, levels); HeapFree(GetProcessHeap(), 0, pItems); HeapFree(GetProcessHeap(), 0, psva); HeapFree(GetProcessHeap(), 0, pwLogClust); return FALSE; } for (j = 0; j < nItems; j++) runOrder[j] = pItems[j].a.s.uBidiLevel; ScriptLayout(nItems, runOrder, visOrder, NULL); for (j = 0; j < nItems; j++) { int k; int cChars,cOutGlyphs; curItem = &pItems[visOrder[j]]; cChars = pItems[visOrder[j]+1].iCharPos - curItem->iCharPos; res = ScriptShape(hDC, &psc, lpString + done + curItem->iCharPos, cChars, cMaxGlyphs, &curItem->a, run_glyphs, pwLogClust, psva, &cOutGlyphs); while (res == E_OUTOFMEMORY) { cMaxGlyphs *= 2; run_glyphs = HeapReAlloc(GetProcessHeap(), 0, run_glyphs, sizeof(WORD) * cMaxGlyphs); if (!run_glyphs) { WARN("Out of memory\n"); HeapFree(GetProcessHeap(), 0, runOrder); HeapFree(GetProcessHeap(), 0, visOrder); HeapFree(GetProcessHeap(), 0, chartype); HeapFree(GetProcessHeap(), 0, levels); HeapFree(GetProcessHeap(), 0, pItems); HeapFree(GetProcessHeap(), 0, psva); HeapFree(GetProcessHeap(), 0, pwLogClust); HeapFree(GetProcessHeap(), 0, *lpGlyphs); ScriptFreeCache(&psc); *lpGlyphs = NULL; return FALSE; } res = ScriptShape(hDC, &psc, lpString + done + curItem->iCharPos, cChars, cMaxGlyphs, &curItem->a, run_glyphs, pwLogClust, psva, &cOutGlyphs); } if (res) { if (res == USP_E_SCRIPT_NOT_IN_FONT) TRACE("Unable to shape with currently selected font\n"); else FIXME("Unable to shape string (%x)\n",res); j = nItems; doGlyphs = FALSE; HeapFree(GetProcessHeap(), 0, *lpGlyphs); *lpGlyphs = NULL; } else { if (*lpGlyphs) *lpGlyphs = HeapReAlloc(GetProcessHeap(), 0, *lpGlyphs, sizeof(WORD) * (glyph_i + cOutGlyphs)); else *lpGlyphs = HeapAlloc(GetProcessHeap(), 0, sizeof(WORD) * (glyph_i + cOutGlyphs)); for (k = 0; k < cOutGlyphs; k++) (*lpGlyphs)[glyph_i+k] = run_glyphs[k]; glyph_i += cOutGlyphs; } } HeapFree(GetProcessHeap(), 0, runOrder); HeapFree(GetProcessHeap(), 0, visOrder); } done += i; } if (cGlyphs) *cGlyphs = glyph_i; HeapFree(GetProcessHeap(), 0, chartype); HeapFree(GetProcessHeap(), 0, levels); HeapFree(GetProcessHeap(), 0, pItems); HeapFree(GetProcessHeap(), 0, run_glyphs); HeapFree(GetProcessHeap(), 0, pwLogClust); HeapFree(GetProcessHeap(), 0, psva); ScriptFreeCache(&psc); return TRUE; }
static void test_info(void) { DWORD hdl, retval; PVOID pVersionInfo = NULL; BOOL boolret; VS_FIXEDFILEINFO *pFixedVersionInfo; UINT uiLength; char VersionString[MAX_PATH]; static const char backslash[] = "\\"; DWORDLONG dwlVersion; hdl = 0x55555555; SetLastError(MY_LAST_ERROR); retval = GetFileVersionInfoSizeA( "kernel32.dll", &hdl); ok( retval, "GetFileVersionInfoSizeA result wrong! <> 0L expected, got 0x%08x\n", retval); ok((NO_ERROR == GetLastError()) || (MY_LAST_ERROR == GetLastError()), "Last error wrong! NO_ERROR/0x%08x (NT4) expected, got %u\n", MY_LAST_ERROR, GetLastError()); ok( hdl == 0L, "Handle wrong! 0L expected, got 0x%08x\n", hdl); if ( retval == 0 || hdl != 0) return; pVersionInfo = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, retval ); ok(pVersionInfo != 0, "HeapAlloc failed\n" ); if (pVersionInfo == 0) return; if (0) { /* this test crashes on WinNT4 */ boolret = GetFileVersionInfoA( "kernel32.dll", 0, retval, 0); ok (!boolret, "GetFileVersionInfoA should have failed: GetLastError = %u\n", GetLastError()); ok ((GetLastError() == ERROR_INVALID_DATA) || (GetLastError() == ERROR_BAD_PATHNAME) || (GetLastError() == NO_ERROR), "Last error wrong! ERROR_INVALID_DATA/ERROR_BAD_PATHNAME (ME)/" "NO_ERROR (95) expected, got %u\n", GetLastError()); } boolret = GetFileVersionInfoA( "kernel32.dll", 0, retval, pVersionInfo ); ok (boolret, "GetFileVersionInfoA failed: GetLastError = %u\n", GetLastError()); if (!boolret) goto cleanup; boolret = VerQueryValueA( pVersionInfo, NULL, (LPVOID *)&pFixedVersionInfo, &uiLength ); ok (boolret || GetLastError() == NO_ERROR /* Win98 */, "VerQueryValueA failed: GetLastError = %u\n", GetLastError()); boolret = VerQueryValueA( pVersionInfo, "", (LPVOID *)&pFixedVersionInfo, &uiLength ); ok (boolret, "VerQueryValueA failed: GetLastError = %u\n", GetLastError()); boolret = VerQueryValueA( pVersionInfo, backslash, (LPVOID *)&pFixedVersionInfo, &uiLength ); ok (boolret, "VerQueryValueA failed: GetLastError = %u\n", GetLastError()); if (!boolret) goto cleanup; dwlVersion = (((DWORDLONG)pFixedVersionInfo->dwFileVersionMS) << 32) + pFixedVersionInfo->dwFileVersionLS; VersionDwordLong2String(dwlVersion, VersionString); trace("kernel32.dll version: %s\n", VersionString); if (0) { /* this test crashes on WinNT4 */ boolret = VerQueryValueA( pVersionInfo, backslash, (LPVOID *)&pFixedVersionInfo, 0); ok (boolret, "VerQueryValue failed: GetLastError = %u\n", GetLastError()); } cleanup: HeapFree( GetProcessHeap(), 0, pVersionInfo); }
static HRESULT IDirectMusicBandImpl_IPersistStream_ParseInstrument (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm) { ICOM_THIS_MULTI(IDirectMusicBandImpl, PersistStreamVtbl, iface); DMUS_PRIVATE_CHUNK Chunk; DWORD ListSize[3], ListCount[3]; LARGE_INTEGER liMove; /* used when skipping chunks */ HRESULT hr; DMUS_IO_INSTRUMENT inst; LPDMUS_PRIVATE_INSTRUMENT pNewInstrument; IDirectMusicObject* pObject = NULL; if (pChunk->fccID != DMUS_FOURCC_INSTRUMENT_LIST) { ERR_(dmfile)(": %s chunk should be an INSTRUMENT list\n", debugstr_fourcc (pChunk->fccID)); return E_FAIL; } ListSize[0] = pChunk->dwSize - sizeof(FOURCC); ListCount[0] = 0; do { IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); switch (Chunk.fccID) { case DMUS_FOURCC_INSTRUMENT_CHUNK: { TRACE_(dmfile)(": Instrument chunk\n"); if (Chunk.dwSize != sizeof(DMUS_IO_INSTRUMENT)) return E_FAIL; IStream_Read (pStm, &inst, sizeof(DMUS_IO_INSTRUMENT), NULL); TRACE_(dmfile)(" - dwPatch: %lu\n", inst.dwPatch); TRACE_(dmfile)(" - dwAssignPatch: %lu\n", inst.dwAssignPatch); TRACE_(dmfile)(" - dwNoteRanges[0]: %lu\n", inst.dwNoteRanges[0]); TRACE_(dmfile)(" - dwNoteRanges[1]: %lu\n", inst.dwNoteRanges[1]); TRACE_(dmfile)(" - dwNoteRanges[2]: %lu\n", inst.dwNoteRanges[2]); TRACE_(dmfile)(" - dwNoteRanges[3]: %lu\n", inst.dwNoteRanges[3]); TRACE_(dmfile)(" - dwPChannel: %lu\n", inst.dwPChannel); TRACE_(dmfile)(" - dwFlags: %lu\n", inst.dwFlags); TRACE_(dmfile)(" - bPan: %u\n", inst.bPan); TRACE_(dmfile)(" - bVolume: %u\n", inst.bVolume); TRACE_(dmfile)(" - nTranspose: %d\n", inst.nTranspose); TRACE_(dmfile)(" - dwChannelPriority: %lu\n", inst.dwChannelPriority); TRACE_(dmfile)(" - nPitchBendRange: %d\n", inst.nPitchBendRange); break; } case FOURCC_LIST: { IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL); TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID)); ListSize[1] = Chunk.dwSize - sizeof(FOURCC); ListCount[1] = 0; switch (Chunk.fccID) { case DMUS_FOURCC_REF_LIST: { FIXME_(dmfile)(": DMRF (DM References) list\n"); hr = IDirectMusicUtils_IPersistStream_ParseReference (iface, &Chunk, pStm, &pObject); if (FAILED(hr)) { ERR(": could not load Reference\n"); return hr; } break; } default: { TRACE_(dmfile)(": unknown (skipping)\n"); liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC); IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); break; } } break; } default: { TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n"); liMove.QuadPart = Chunk.dwSize; IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); break; } } TRACE_(dmfile)(": ListCount[0] = %ld < ListSize[0] = %ld\n", ListCount[0], ListSize[0]); } while (ListCount[0] < ListSize[0]); /* * @TODO insert pNewInstrument into This */ pNewInstrument = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, sizeof(DMUS_PRIVATE_INSTRUMENT)); if (NULL == pNewInstrument) { ERR(": no more memory\n"); return E_OUTOFMEMORY; } memcpy(&pNewInstrument->pInstrument, &inst, sizeof(DMUS_IO_INSTRUMENT)); pNewInstrument->ppReferenceCollection = NULL; if (NULL != pObject) { IDirectMusicCollection* pCol = NULL; hr = IDirectMusicObject_QueryInterface (pObject, &IID_IDirectMusicCollection, (void**) &pCol); if (FAILED(hr)) { ERR(": failed to get IDirectMusicCollection Interface from DMObject\n"); return hr; } pNewInstrument->ppReferenceCollection = pCol; IDirectMusicObject_Release(pObject); } list_add_tail (&This->Instruments, &pNewInstrument->entry); return S_OK; }
static void test_VerQueryValueA(void) { static const char * const value_name[] = { "Product", "CompanyName", "FileDescription", "Internal", "ProductVersion", "InternalName", "File", "LegalCopyright", "FileVersion", "Legal", "OriginalFilename", "ProductName", "Company", "Original" }; char *ver, *p; UINT len, ret, translation, i; char buf[MAX_PATH]; ret = GetModuleFileNameA(NULL, buf, sizeof(buf)); assert(ret); SetLastError(0xdeadbeef); len = GetFileVersionInfoSizeA(buf, NULL); ok(len, "GetFileVersionInfoSizeA(%s) error %u\n", buf, GetLastError()); ver = HeapAlloc(GetProcessHeap(), 0, len); assert(ver); SetLastError(0xdeadbeef); ret = GetFileVersionInfoA(buf, 0, len, ver); ok(ret, "GetFileVersionInfoA error %u\n", GetLastError()); p = (char *)0xdeadbeef; len = 0xdeadbeef; SetLastError(0xdeadbeef); ret = VerQueryValueA(ver, "\\VarFileInfo\\Translation", (LPVOID*)&p, &len); ok(ret, "VerQueryValue error %u\n", GetLastError()); ok(len == 4, "VerQueryValue returned %u, expected 4\n", len); translation = *(UINT *)p; translation = MAKELONG(HIWORD(translation), LOWORD(translation)); p = (char *)0xdeadbeef; len = 0xdeadbeef; SetLastError(0xdeadbeef); ret = VerQueryValueA(ver, "String", (LPVOID*)&p, &len); ok(!ret, "VerQueryValue should fail\n"); ok(GetLastError() == ERROR_RESOURCE_TYPE_NOT_FOUND || GetLastError() == 0xdeadbeef /* NT4, W2K */, "VerQueryValue returned %u\n", GetLastError()); ok(p == (char *)0xdeadbeef, "expected 0xdeadbeef got %p\n", p); ok(len == 0, "expected 0 got %x\n", len); p = (char *)0xdeadbeef; len = 0xdeadbeef; SetLastError(0xdeadbeef); ret = VerQueryValueA(ver, "StringFileInfo", (LPVOID*)&p, &len); ok(ret, "VerQueryValue error %u\n", GetLastError()); ok(len == 0, "VerQueryValue returned %u, expected 0\n", len); ok(p != (char *)0xdeadbeef, "not expected 0xdeadbeef\n"); p = (char *)0xdeadbeef; len = 0xdeadbeef; SetLastError(0xdeadbeef); ret = VerQueryValueA(ver, "\\StringFileInfo", (LPVOID*)&p, &len); ok(ret, "VerQueryValue error %u\n", GetLastError()); ok(len == 0, "VerQueryValue returned %u, expected 0\n", len); ok(p != (char *)0xdeadbeef, "not expected 0xdeadbeef\n"); p = (char *)0xdeadbeef; len = 0xdeadbeef; SetLastError(0xdeadbeef); ret = VerQueryValueA(ver, "\\\\StringFileInfo", (LPVOID*)&p, &len); ok(ret, "VerQueryValue error %u\n", GetLastError()); ok(len == 0, "VerQueryValue returned %u, expected 0\n", len); ok(p != (char *)0xdeadbeef, "not expected 0xdeadbeef\n"); p = (char *)0xdeadbeef; len = 0xdeadbeef; SetLastError(0xdeadbeef); ret = VerQueryValueA(ver, "\\StringFileInfo\\\\", (LPVOID*)&p, &len); ok(ret, "VerQueryValue error %u\n", GetLastError()); ok(len == 0, "VerQueryValue returned %u, expected 0\n", len); ok(p != (char *)0xdeadbeef, "not expected 0xdeadbeef\n"); sprintf(buf, "\\StringFileInfo\\%08x", translation); p = (char *)0xdeadbeef; len = 0xdeadbeef; SetLastError(0xdeadbeef); ret = VerQueryValueA(ver, buf, (LPVOID*)&p, &len); ok(ret, "VerQueryValue error %u\n", GetLastError()); ok(len == 0, "VerQueryValue returned %u, expected 0\n", len); ok(p != (char *)0xdeadbeef, "not expected 0xdeadbeef\n"); for (i = 0; i < ARRAY_SIZE(value_name); i++) { sprintf(buf, "\\StringFileInfo\\%08x\\%s", translation, value_name[i]); p = (char *)0xdeadbeef; len = 0xdeadbeef; SetLastError(0xdeadbeef); ret = VerQueryValueA(ver, buf, (LPVOID*)&p, &len); ok(ret, "VerQueryValueA(%s) error %u\n", buf, GetLastError()); ok(len == strlen(value_name[i]) + 1, "VerQueryValue returned %u\n", len); ok(!strcmp(value_name[i], p), "expected \"%s\", got \"%s\"\n", value_name[i], p); /* test partial value names */ len = lstrlenA(buf); buf[len - 2] = 0; p = (char *)0xdeadbeef; len = 0xdeadbeef; SetLastError(0xdeadbeef); ret = VerQueryValueA(ver, buf, (LPVOID*)&p, &len); ok(!ret, "VerQueryValueA(%s) succeeded\n", buf); ok(GetLastError() == ERROR_RESOURCE_TYPE_NOT_FOUND || GetLastError() == 0xdeadbeef /* NT4, W2K */, "VerQueryValue returned %u\n", GetLastError()); ok(p == (char *)0xdeadbeef, "expected 0xdeadbeef got %p\n", p); ok(len == 0, "expected 0 or 0xbeef, got %x\n", len); } HeapFree(GetProcessHeap(), 0, ver); }
bool UpdateExports() { Exports.clear(); //if (!gbExports) // return; static HMODULE hNtDll = (HMODULE)Utils::GetLocalModuleHandle("ntdll.dll"); static tNtQueryInformationProcess NtQueryInformationProcess = (tNtQueryInformationProcess)Utils::GetProcAddress(hNtDll, "NtQueryInformationProcess"); PPROCESS_BASIC_INFORMATION ProcessInfo = NULL; PEB Peb; PEB_LDR_DATA LdrData; // Try to allocate buffer HANDLE hHeap = GetProcessHeap(); DWORD dwSize = sizeof(PROCESS_BASIC_INFORMATION); ProcessInfo = (PPROCESS_BASIC_INFORMATION)HeapAlloc(hHeap, HEAP_ZERO_MEMORY | HEAP_GENERATE_EXCEPTIONS, dwSize); ULONG dwSizeNeeded = 0; NTSTATUS status = NtQueryInformationProcess(g_hProcess, ProcessBasicInformation, ProcessInfo, dwSize, &dwSizeNeeded); if (status >= 0 && dwSize < dwSizeNeeded) { if (ProcessInfo) HeapFree(hHeap, 0, ProcessInfo); ProcessInfo = (PPROCESS_BASIC_INFORMATION)HeapAlloc(hHeap, HEAP_ZERO_MEMORY | HEAP_GENERATE_EXCEPTIONS, dwSizeNeeded); if (!ProcessInfo) { #ifdef _DEBUG PrintOut(_T("[UpdateExports]: Couldn't allocate heap buffer!")); #endif return 0; } status = NtQueryInformationProcess(g_hProcess, ProcessBasicInformation, ProcessInfo, dwSizeNeeded, &dwSizeNeeded); } // Did we successfully get basic info on process if (NT_SUCCESS(status)) { // Check for PEB if (!ProcessInfo->PebBaseAddress) { #ifdef _DEBUG PrintOut(_T("[UpdateExports]: PEB is null! Aborting...")); #endif if (ProcessInfo) HeapFree(hHeap, 0, ProcessInfo); return 0; } // Read Process Environment Block (PEB) SIZE_T dwBytesRead = 0; if ( ReadMemory( ProcessInfo->PebBaseAddress, &Peb, sizeof(PEB), &dwBytesRead) == 0) { #ifdef _DEBUG PrintOut(_T("[UpdateExports]: Failed to read PEB! Aborting UpdateExports.")); #endif if (ProcessInfo) HeapFree(hHeap, 0, ProcessInfo); return 0; } // Get Ldr dwBytesRead = 0; if ( ReadMemory( Peb.Ldr, &LdrData, sizeof(LdrData), &dwBytesRead) == 0) { #ifdef _DEBUG PrintOut(_T("[UpdateExports]: Failed to read PEB Ldr Data! Aborting UpdateExports.")); #endif if (ProcessInfo) HeapFree(hHeap, 0, ProcessInfo); return 0; } LIST_ENTRY *pLdrListHead = (LIST_ENTRY *)LdrData.InLoadOrderModuleList.Flink; LIST_ENTRY *pLdrCurrentNode = LdrData.InLoadOrderModuleList.Flink; do { LDR_DATA_TABLE_ENTRY lstEntry = { 0 }; dwBytesRead = 0; if (! ReadMemory( (void*)pLdrCurrentNode, &lstEntry, sizeof(LDR_DATA_TABLE_ENTRY), &dwBytesRead)) { #ifdef _DEBUG PrintOut(_T("[UpdateExports]: Could not read list entry from LDR list. Error = %s"), Utils::GetLastErrorString().GetString()); #endif if (ProcessInfo) HeapFree(hHeap, 0, ProcessInfo); return 0; } pLdrCurrentNode = lstEntry.InLoadOrderLinks.Flink; if (lstEntry.DllBase != nullptr && lstEntry.SizeOfImage != 0) { unsigned char* ModuleHandle = (unsigned char*)lstEntry.DllBase; wchar_t wcsDllName[MAX_PATH] = { 0 }; wchar_t ModuleName[MAX_PATH] = { 0 }; if (lstEntry.BaseDllName.Length > 0) { dwBytesRead = 0; if ( ReadMemory( (LPVOID)lstEntry.BaseDllName.Buffer, &wcsDllName, lstEntry.BaseDllName.Length, &dwBytesRead)) { wcscpy_s(ModuleName, wcsDllName); } } IMAGE_DOS_HEADER DosHdr; IMAGE_NT_HEADERS NtHdr; ReadMemory( ModuleHandle, &DosHdr, sizeof(DosHdr), NULL); ReadMemory( ModuleHandle + DosHdr.e_lfanew, &NtHdr, sizeof(IMAGE_NT_HEADERS), NULL); if (NtHdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress != 0) { IMAGE_EXPORT_DIRECTORY ExpDir; ReadMemory( (LPVOID)(ModuleHandle + NtHdr.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress), &ExpDir, sizeof(ExpDir), NULL); PVOID pName = (PVOID)(ModuleHandle + ExpDir.AddressOfNames); PVOID pOrd = (PVOID)(ModuleHandle + ExpDir.AddressOfNameOrdinals); PVOID pAddress = (PVOID)(ModuleHandle + ExpDir.AddressOfFunctions); ULONG aNames[MAX_EXPORTS]; WORD aOrds[MAX_EXPORTS]; ULONG aAddresses[MAX_EXPORTS]; ReadMemory( (LPVOID)pName, aNames, ExpDir.NumberOfNames * sizeof(aNames[0]), NULL); ReadMemory( (LPVOID)pOrd, aOrds, ExpDir.NumberOfNames * sizeof(aOrds[0]), NULL); ReadMemory( (LPVOID)pAddress, aAddresses, ExpDir.NumberOfFunctions * sizeof(aAddresses[0]), NULL); for (DWORD i = 0; i < ExpDir.NumberOfNames; i++) { char ExportName[256]; ReadMemory( (LPVOID)(ModuleHandle + aNames[i]), ExportName, 256, NULL); DWORD_PTR Address = (DWORD_PTR)ModuleHandle + aAddresses[aOrds[i]]; AddressName Entry; Entry.Name.Format(_T("%ls.%hs"), ModuleName, ExportName); Entry.Address = Address; // Add export entry to array Exports.push_back(Entry); } } } } while (pLdrListHead != pLdrCurrentNode); } else { #ifdef _DEBUG PrintOut(_T("[UpdateExports]: NtQueryInformationProcess failed! Aborting...")); #endif if (ProcessInfo) HeapFree(hHeap, 0, ProcessInfo); return 0; } if (ProcessInfo) HeapFree(hHeap, 0, ProcessInfo); return 1; }