// // Created 31-Jul-96 [JonT] // PhilF-: This needs to be rewritten. You should have two classes // (CVfWCap & WDMCap) that derive from the same capture class instead // of those C-like functions... #include "Precomp.h" #ifndef WIDTHBYTES #define WIDTHBYTES(bits) (((bits) + 31) / 32 * 4) #endif #ifdef _DEBUG static PTCHAR _rgZonesCap[] = { TEXT("dcap"), TEXT("Init"), TEXT("Streaming"), TEXT("Callback"), TEXT("Dialogs"), TEXT("Trace") }; #endif #ifndef __NT_BUILD__ extern "C" { // Special thunk prototype BOOL thk_ThunkConnect32(LPSTR pszDll16, LPSTR pszDll32, HINSTANCE hInst, DWORD dwReason); //; Magic Function code values for DeviceIOControl code. //DCAPVXD_THREADTIMESERVICE equ 101h //DCAPVXD_R0THREADIDSERVICE equ 102h #define DCAPVXD_THREADTIMESERVICE 0x101 #define DCAPVXD_R0THREADIDSERVICE 0x102 // KERNEL32 prototypes (not in headers but are exported by name on Win95) void* WINAPI MapSL(DWORD dw1616Ptr); HANDLE WINAPI OpenVxDHandle(HANDLE h); } #endif // Helper function prototypes BOOL initializeCaptureDeviceList(void); HVIDEO openVideoChannel(DWORD dwDeviceID, DWORD dwFlags); BOOL allocateBuffers(HCAPDEV hcd, int nBuffers); void freeBuffers(HCAPDEV hcd); // Globals HINSTANCE g_hInst; int g_cDevices; LPINTERNALCAPDEV g_aCapDevices[DCAP_MAX_DEVICES]; BOOL g_fInitCapDevList; #define INIT_CAP_DEV_LIST() if (g_fInitCapDevList) { initializeCaptureDeviceList(); } #ifndef __NT_BUILD__ HANDLE s_hVxD = NULL; #endif //__NT_BUILD__ // Strings #ifdef __NT_BUILD__ char g_szVFWRegKey[] = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Drivers32"; char g_szVFWRegDescKey[] = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\drivers.desc"; char g_szDriverName[] = "MSVIDEOx"; #ifndef SHOW_VFW2WDM_MAPPER char g_szVfWToWDMMapperDescription[] = "WDM Video For Windows Capture Driver (Win32)"; char g_szVfWToWDMMapperName[] = "VfWWDM32.dll"; #endif #else char g_szVFWRegKey[] = "SYSTEM\\CurrentControlSet\\Control\\MediaResources\\msvideo"; char g_szRegDescription[] = "Description"; char g_szRegName[] = "Driver"; char g_szRegDisabled[] = "Disabled"; char g_szDevNode[] = "DevNode"; char g_szSystemIni[] = "system.ini"; char g_szDriverSection[] = "drivers"; char g_szDriverKey[] = "MSVIDEOx"; #ifndef SHOW_VFW2WDM_MAPPER char g_szVfWToWDMMapperDescription[] = "VfW MM 16bit Driver for WDM V. Cap. Devices"; char g_szVfWToWDMMapperName[] = "vfwwdm.drv"; #endif #endif char g_szMSOfficeCamcorderDescription[] = "Screen Capture Device Driver for AVI"; char g_szMSOfficeCamcorderName[] = "Gdicap97.drv"; char g_szVerQueryForDesc[] = "\\StringFileInfo\\040904E4\\FileDescription"; void DoClose(HCAPDEV hcd); #define ENTER_DCAP(hcd) InterlockedIncrement(&(hcd)->busyCount); #define LEAVE_DCAP(hcd) if (InterlockedDecrement(&(hcd)->busyCount) == 0) DoClose((hcd)); // DllEntryPoint extern "C" BOOL DllEntryPoint( HINSTANCE hInst, DWORD dwReason, LPVOID lpReserved ) { static int s_nProcesses = 0; FX_ENTRY("DllEntryPoint"); #ifndef __NT_BUILD__ // We want to load the VxD even before initializing the thunks // because the 16-bit half initializes the VxD during the thk_ThunkConnect32 call if (!s_hVxD) { s_hVxD = CreateFile("\\\\.\\DCAPVXD.VXD", 0,0,0,0, FILE_FLAG_DELETE_ON_CLOSE, 0); if (s_hVxD == INVALID_HANDLE_VALUE) { ERRORMESSAGE(("%s: Failure loading VxD - Fatal\r\n", _fx_)); return FALSE; } } // Initialize the thunks if (!(thk_ThunkConnect32("DCAP16.DLL", "DCAP32.DLL", hInst, dwReason))) { ERRORMESSAGE(("%s: thk_ThunkConnect32 failed!\r\n", _fx_)); return FALSE; } #endif switch (dwReason) { case DLL_PROCESS_ATTACH: // Save global hinst g_hInst = hInst; // Only initialize on the first DLL load if (s_nProcesses++ == 0) { DBGINIT(&ghDbgZoneCap, _rgZonesCap); DBG_INIT_MEMORY_TRACKING(hInst); g_fInitCapDevList = TRUE; } else return FALSE; // fail to load multiple instances break; case DLL_PROCESS_DETACH: if (--s_nProcesses == 0) // Are we going away? { #ifndef __NT_BUILD__ CloseHandle(s_hVxD); s_hVxD = NULL; #endif DBG_CHECK_MEMORY_TRACKING(hInst); DBGDEINIT(&ghDbgZoneCap); } break; } return TRUE; } void GetVersionData (LPINTERNALCAPDEV lpcd) { int j; DWORD dwVerInfoSize; LPSTR lpstrInfo; LPSTR lpDesc; // Version number // You must find the size first before getting any file info dwVerInfoSize = GetFileVersionInfoSize(lpcd->szDeviceName, NULL); if (dwVerInfoSize && (lpstrInfo = (LPSTR)LocalAlloc(LPTR, dwVerInfoSize))) { // Read from the file into our block if (GetFileVersionInfo(lpcd->szDeviceName, 0L, dwVerInfoSize, lpstrInfo)) { lpDesc = NULL; if (VerQueryValue(lpstrInfo, g_szVerQueryForDesc, (LPVOID *)&lpDesc, (PUINT)&j) && lpDesc) { lstrcpyn(lpcd->szDeviceDescription, lpDesc, j); wsprintf(lpcd->szDeviceVersion, TEXT("Version: %d.%d.%d.%d"), HIWORD(((VS_VERSION *)lpstrInfo)->vffInfo.dwFileVersionMS), LOWORD(((VS_VERSION *)lpstrInfo)->vffInfo.dwFileVersionMS), HIWORD(((VS_VERSION *)lpstrInfo)->vffInfo.dwFileVersionLS), LOWORD(((VS_VERSION *)lpstrInfo)->vffInfo.dwFileVersionLS)); } } LocalFree(lpstrInfo); } } #ifdef __NT_BUILD__ // initializeCaptureDeviceList // Sets up our static array of available capture devices from the registry // Returns FALSE iff there are no video devices. BOOL initializeCaptureDeviceList(void) { HKEY hkeyVFW, hkeyVFWdesc; DWORD dwType; DWORD dwSize; int i; LPINTERNALCAPDEV lpcd; HCAPDEV hCapDev; FX_ENTRY("initializeCaptureDeviceList"); // Clear the entire array and start with zero devices g_cDevices = 0; ZeroMemory(g_aCapDevices, sizeof (g_aCapDevices)); // Open the reg key in question if (RegOpenKey(HKEY_LOCAL_MACHINE, g_szVFWRegKey, &hkeyVFW) == ERROR_SUCCESS) { if (RegOpenKey(HKEY_LOCAL_MACHINE, g_szVFWRegDescKey, &hkeyVFWdesc) != ERROR_SUCCESS) hkeyVFWdesc = 0; lpcd = (LPINTERNALCAPDEV)LocalAlloc(LPTR, sizeof (INTERNALCAPDEV)); if (lpcd) { // Loop through all possible VFW drivers in registry for (i = 0 ; i < DCAP_MAX_VFW_DEVICES ; i++) { // Create the key name if (i == 0) g_szDriverName[sizeof (g_szDriverName) - 2] = 0; else g_szDriverName[sizeof (g_szDriverName) - 2] = (BYTE)i + '0'; // Name dwSize = sizeof(lpcd->szDeviceName); if (RegQueryValueEx(hkeyVFW, g_szDriverName, NULL, &dwType, (LPBYTE)lpcd->szDeviceName, &dwSize) == ERROR_SUCCESS) { // Description if (hkeyVFWdesc) { dwSize = sizeof(lpcd->szDeviceDescription); RegQueryValueEx(hkeyVFWdesc, lpcd->szDeviceName, NULL, &dwType, (LPBYTE)lpcd->szDeviceDescription, &dwSize); } else lstrcpy (lpcd->szDeviceDescription, lpcd->szDeviceName); // Devnode lpcd->dwDevNode = 0; lpcd->nDeviceIndex = g_cDevices; GetVersionData(lpcd); #ifndef SHOW_VFW2WDM_MAPPER // Remove bogus Camcorder capture device from list of devices shown to the user // The Camcorder driver is a fake capture device used by the MS Office Camcorder // to capture screen activity to an AVI file. This not a legit capture device driver // and is extremely buggy. // We also remove the VfW to WDM mapper if we are on NT5. if (lstrcmp(lpcd->szDeviceDescription, g_szMSOfficeCamcorderDescription) && lstrcmp(lpcd->szDeviceName, g_szMSOfficeCamcorderName) && lstrcmp(lpcd->szDeviceDescription, g_szVfWToWDMMapperDescription) && lstrcmp(lpcd->szDeviceName, g_szVfWToWDMMapperName)) { #endif g_aCapDevices[g_cDevices] = lpcd; g_aCapDevices[g_cDevices]->nDeviceIndex = g_cDevices; g_cDevices++; #ifndef SHOW_VFW2WDM_MAPPER } else LocalFree(lpcd); #endif lpcd = (LPINTERNALCAPDEV)LocalAlloc(LPTR, sizeof (INTERNALCAPDEV)); if (!lpcd) { ERRORMESSAGE(("%s: Failed to allocate an INTERNALCAPDEV buffer\r\n", _fx_)); break; // break out of the FOR loop } } } } else { ERRORMESSAGE(("%s: Failed to allocate an INTERNALCAPDEV buffer\r\n", _fx_)); } if (lpcd) LocalFree (lpcd); // free the extra buffer RegCloseKey(hkeyVFW); if (hkeyVFWdesc) RegCloseKey(hkeyVFWdesc); } #ifndef HIDE_WDM_DEVICES WDMGetDevices(); #endif g_fInitCapDevList = FALSE; return TRUE; } #else //__NT_BUILD__ // initializeCaptureDeviceList // Sets up our static array of available capture devices from the registry and // from SYSTEM.INI. // Returns FALSE iff there are no video devices. BOOL initializeCaptureDeviceList(void) { int i, j, index; HKEY hkeyVFW; HKEY hkeyEnum; DWORD dwType; DWORD dwSize; LPINTERNALCAPDEV lpcd; char szEnumName[MAX_PATH]; char szDisabled[3]; HCAPDEV hCapDev; OSVERSIONINFO osvInfo = {0}; FX_ENTRY("initializeCaptureDeviceList"); // Clear the entire array and start with zero devices g_cDevices = 0; ZeroMemory(g_aCapDevices, sizeof (g_aCapDevices)); // If we are on a version on Win95 (OSRx) use the mapper to talk to WDM devices. // The WDM drivers used on OSR2 are not stream class minidrivers so we fail // to handle them properly. Let the mapper do this for us. osvInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); GetVersionEx(&osvInfo); // Open the reg key in question if (RegOpenKey(HKEY_LOCAL_MACHINE, g_szVFWRegKey, &hkeyVFW) == ERROR_SUCCESS) { // Loop through all possible VFW drivers in registry for (i = 0 ; i < DCAP_MAX_VFW_DEVICES ; i++) { // See if the key is there and if not, we're done. Note that registry // keys have to be sequential, no holes allowed since the only way // to query is sequential... if (RegEnumKey(hkeyVFW, i, szEnumName, MAX_PATH) != ERROR_SUCCESS || RegOpenKey(hkeyVFW, szEnumName, &hkeyEnum) != ERROR_SUCCESS) break; lpcd = (LPINTERNALCAPDEV)LocalAlloc(LPTR, sizeof (INTERNALCAPDEV)); if (!lpcd) { ERRORMESSAGE(("%s: Failed to allocate an INTERNALCAPDEV buffer\r\n", _fx_)); break; // break from the FOR loop } // Description dwSize = sizeof (lpcd->szDeviceDescription); RegQueryValueEx(hkeyEnum, g_szRegDescription, NULL, &dwType, (LPBYTE)lpcd->szDeviceDescription, &dwSize); // Name dwSize = sizeof (lpcd->szDeviceName); RegQueryValueEx(hkeyEnum, g_szRegName, NULL, &dwType, (LPBYTE)lpcd->szDeviceName, &dwSize); // Disabled dwSize = sizeof (szDisabled); if (RegQueryValueEx(hkeyEnum, g_szRegDisabled, NULL, &dwType, (LPBYTE)szDisabled, &dwSize) == ERROR_SUCCESS && szDisabled[0] == '1') lpcd->dwFlags |= CAPTURE_DEVICE_DISABLED; // Devnode dwSize = sizeof (DWORD); RegQueryValueEx(hkeyEnum, g_szDevNode, NULL, &dwType, (BYTE*)&lpcd->dwDevNode, &dwSize); GetVersionData(lpcd); #ifndef SHOW_VFW2WDM_MAPPER // Remove bogus Camcorder capture device from list of devices shown to the user // The Camcorder driver is a fake capture device used by the MS Office Camcorder // to capture screen activity to an AVI file. This not a legit capture device driver // and is extremely buggy. // We also remove the VfW to WDM mapper if we are on Win98. On Win95 we still use // it to get access to USB devices developed for OSR2. if ((lstrcmp(lpcd->szDeviceDescription, g_szMSOfficeCamcorderDescription) && lstrcmp(lpcd->szDeviceName, g_szMSOfficeCamcorderName)) && (((osvInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) && (osvInfo.dwMinorVersion == 0)) || lstrcmp(lpcd->szDeviceDescription, g_szVfWToWDMMapperDescription) && lstrcmp(lpcd->szDeviceName, g_szVfWToWDMMapperName))) { #endif g_aCapDevices[g_cDevices] = lpcd; g_aCapDevices[g_cDevices]->nDeviceIndex = g_cDevices; g_cDevices++; #ifndef SHOW_VFW2WDM_MAPPER } else LocalFree(lpcd); #endif RegCloseKey(hkeyEnum); } RegCloseKey(hkeyVFW); } // Now get the rest from system.ini, if any for (i = 0 ; i < DCAP_MAX_VFW_DEVICES ; i++) { // Create the key name if (i == 0) g_szDriverKey[sizeof (g_szDriverKey) - 2] = 0; else g_szDriverKey[sizeof (g_szDriverKey) - 2] = (BYTE)i + '0'; // See if there's a profile string if (GetPrivateProfileString(g_szDriverSection, g_szDriverKey, "", szEnumName, MAX_PATH, g_szSystemIni)) { // First check to see if this is a dupe. If it is, go no further. if (g_cDevices) { for (j = 0 ; j < g_cDevices ; j++) if (!lstrcmpi(g_aCapDevices[j]->szDeviceName, szEnumName)) goto NextDriver; } lpcd = (LPINTERNALCAPDEV)LocalAlloc(LPTR, sizeof (INTERNALCAPDEV)); if (!lpcd) { ERRORMESSAGE(("%s: Failed to allocate an INTERNALCAPDEV buffer\r\n", _fx_)); break; // break from the FOR loop } // We have a unique name, copy in the driver name and find the description // by reading the driver's versioninfo resource. lstrcpy(lpcd->szDeviceName, szEnumName); GetVersionData(lpcd); #ifndef SHOW_VFW2WDM_MAPPER // Remove bogus Camcorder capture device from list of devices shown to the user // The Camcorder driver is a fake capture device used by the MS Office Camcorder // to capture screen activity to an AVI file. This not a legit capture device driver // and is extremely buggy. // We also remove the VfW to WDM mapper if we are on Win98. On Win95 we still use // it to get access to USB devices developed for OSR2. if ((lstrcmp(lpcd->szDeviceDescription, g_szMSOfficeCamcorderDescription) && lstrcmp(lpcd->szDeviceName, g_szMSOfficeCamcorderName)) && (((osvInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) && (osvInfo.dwMinorVersion == 0)) || lstrcmp(lpcd->szDeviceDescription, g_szVfWToWDMMapperDescription) && lstrcmp(lpcd->szDeviceName, g_szVfWToWDMMapperName))) { #endif g_aCapDevices[g_cDevices] = lpcd; g_aCapDevices[g_cDevices]->nDeviceIndex = g_cDevices; g_cDevices++; #ifndef SHOW_VFW2WDM_MAPPER } else LocalFree(lpcd); #endif } NextDriver: ; } #ifndef HIDE_WDM_DEVICES WDMGetDevices(); #endif g_fInitCapDevList = FALSE; return TRUE; } #endif //__NT_BUILD__ // GetNumCaptureDevice // Returns the number of *ENABLED* capture devices /**************************************************************************** * @doc EXTERNAL DCAP32 * * @func int DCAPI | GetNumCaptureDevices | This function returns the number * of *ENABLED* capture devices. * * @rdesc Returns the number of *ENABLE* capture devices. ***************************************************************************/ int DCAPI GetNumCaptureDevices() { int nNumCapDevices = 0; int nDeviceIndex = 0; INIT_CAP_DEV_LIST(); while (nDeviceIndex < g_cDevices) if (!(g_aCapDevices[nDeviceIndex++]->dwFlags & CAPTURE_DEVICE_DISABLED)) nNumCapDevices++; return nNumCapDevices; } // FindFirstCaptureDevice // Returns the first capture device available that matches the string // or the first one registered if szDeviceDescription is NULL BOOL DCAPI FindFirstCaptureDevice( IN OUT FINDCAPTUREDEVICE* lpfcd, char* szDeviceDescription ) { int i; static HCAPDEV hcap = NULL; INIT_CAP_DEV_LIST(); // Validate size if (lpfcd->dwSize != sizeof (FINDCAPTUREDEVICE)) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // hack to avoid quickcam driver problem when hardware not installed if (g_cDevices && !hcap) { for (i = 0; ((i < g_cDevices) && (g_aCapDevices[i]->dwFlags & CAPTURE_DEVICE_DISABLED)); i++); if ((i < g_cDevices) && (hcap = OpenCaptureDevice(i))) { CloseCaptureDevice (hcap); } else { if (i < g_cDevices) { g_aCapDevices[i]->dwFlags |= CAPTURE_DEVICE_DISABLED; #ifdef _DEBUG OutputDebugString((i == 0) ? "DCAP32: 1st capture device fails to open!\r\n" : (i == 1) ? "DCAP32: 2nd capture device fails to open!\r\n" : (i == 2) ? "DCAP32: 3rd capture device fails to open!\r\n" : "DCAP32: 4th capture device fails to open!\r\n"); #endif } } } // Search if necessary if (szDeviceDescription) { for (i = 0 ; i < g_cDevices ; i++) if (!lstrcmpi(g_aCapDevices[i]->szDeviceDescription, szDeviceDescription) && !(g_aCapDevices[i]->dwFlags & CAPTURE_DEVICE_DISABLED)) break; } else for (i = 0; ((i < g_cDevices) && (g_aCapDevices[i]->dwFlags & CAPTURE_DEVICE_DISABLED)); i++); // Return the info if (i == g_cDevices) { SetLastError(ERROR_FILE_NOT_FOUND); return FALSE; } else { lpfcd->nDeviceIndex = i; lstrcpy(lpfcd->szDeviceName, g_aCapDevices[lpfcd->nDeviceIndex]->szDeviceName); lstrcpy(lpfcd->szDeviceDescription, g_aCapDevices[i]->szDeviceDescription); lstrcpy(lpfcd->szDeviceVersion, g_aCapDevices[i]->szDeviceVersion); return TRUE; } } // FindFirstCaptureDeviceByIndex // Returns the device with the specified index. BOOL DCAPI FindFirstCaptureDeviceByIndex( IN OUT FINDCAPTUREDEVICE* lpfcd, int nDeviceIndex ) { INIT_CAP_DEV_LIST(); // Validate size and index if (lpfcd->dwSize != sizeof (FINDCAPTUREDEVICE) || nDeviceIndex >= g_cDevices || (nDeviceIndex < 0) || (g_aCapDevices[nDeviceIndex]->dwFlags & CAPTURE_DEVICE_DISABLED)) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } // Return the info lpfcd->nDeviceIndex = nDeviceIndex; lstrcpy(lpfcd->szDeviceName, g_aCapDevices[lpfcd->nDeviceIndex]->szDeviceName); lstrcpy(lpfcd->szDeviceDescription, g_aCapDevices[nDeviceIndex]->szDeviceDescription); lstrcpy(lpfcd->szDeviceVersion, g_aCapDevices[nDeviceIndex]->szDeviceVersion); return TRUE; } // FindNextCaptureDevice // Returns the next capture device in list. BOOL DCAPI FindNextCaptureDevice( IN OUT FINDCAPTUREDEVICE* lpfcd ) { HCAPDEV hcap = NULL; INIT_CAP_DEV_LIST(); // Parameter validate the passed in structure if (lpfcd->dwSize != sizeof (FINDCAPTUREDEVICE)) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } while (++lpfcd->nDeviceIndex < g_cDevices) { if ((!(g_aCapDevices[lpfcd->nDeviceIndex]->dwFlags & CAPTURE_DEVICE_DISABLED))) { if (g_aCapDevices[lpfcd->nDeviceIndex]->dwFlags & CAPTURE_DEVICE_OPEN) break; else { if (hcap = OpenCaptureDevice(lpfcd->nDeviceIndex)) { CloseCaptureDevice (hcap); break; } else g_aCapDevices[lpfcd->nDeviceIndex]->dwFlags |= CAPTURE_DEVICE_DISABLED; } } } // See if we're at the end if (lpfcd->nDeviceIndex >= g_cDevices) { SetLastError(ERROR_NO_MORE_FILES); return FALSE; } // Otherwise, fill in the info for the next one lstrcpy(lpfcd->szDeviceName, g_aCapDevices[lpfcd->nDeviceIndex]->szDeviceName); lstrcpy(lpfcd->szDeviceDescription, g_aCapDevices[lpfcd->nDeviceIndex]->szDeviceDescription); lstrcpy(lpfcd->szDeviceVersion, g_aCapDevices[lpfcd->nDeviceIndex]->szDeviceVersion); return TRUE; } // OpenCaptureDevice HCAPDEV DCAPI OpenCaptureDevice( int nDeviceIndex ) { LPINTERNALCAPDEV hcd; LPBITMAPINFOHEADER lpbmih = NULL; DWORD err, dwLen; BOOL fl; FX_ENTRY("OpenCaptureDevice"); DEBUGMSG(ZONE_CALLS, ("%s() - Begin\r\n", _fx_)); INIT_CAP_DEV_LIST(); // Validate the device index if ((unsigned)nDeviceIndex >= (unsigned)g_cDevices || (g_aCapDevices[nDeviceIndex]->dwFlags & (CAPTURE_DEVICE_DISABLED | CAPTURE_DEVICE_OPEN))) { SetLastError(ERROR_INVALID_PARAMETER); DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); return NULL; } hcd = g_aCapDevices[nDeviceIndex]; hcd->busyCount = 1; // we start at 1 to say that we're open // DoClose happens when count goes to 0 if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) { #ifndef __NT_BUILD__ // Allocate some memory we can lock for the LOCKEDINFO structure hcd->wselLockedInfo = _AllocateLockableBuffer(sizeof (LOCKEDINFO)); if (!hcd->wselLockedInfo) { err = ERROR_OUTOFMEMORY; goto Error; } // Do our own thunking so we can track the selector for this buffer hcd->lpli = (LPLOCKEDINFO)MapSL(((DWORD)hcd->wselLockedInfo) << 16); #endif // Open the necessary video channels if (!(hcd->hvideoIn = openVideoChannel(nDeviceIndex, VIDEO_IN)) || !(hcd->hvideoCapture = openVideoChannel(nDeviceIndex, VIDEO_EXTERNALIN))) { ERRORMESSAGE(("%s: Couldn't open video channel(s)\r\n", _fx_)); if (hcd->hvideoIn) _CloseDriver((HDRVR)hcd->hvideoIn, 0, 0); SetLastError(ERROR_DCAP_DEVICE_IN_USE); DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); return FALSE; } #ifdef USE_VIDEO_OVERLAY if (hcd->hvideoOverlay = openVideoChannel(nDeviceIndex, VIDEO_EXTERNALOUT)) { DEBUGMSG(ZONE_INIT, ("%s: Capture device supports overlay!\r\n", _fx_)); } else { DEBUGMSG(ZONE_INIT, ("%s: Capture device does not support overlay\r\n", _fx_)); } #endif } else { if (!WDMOpenDevice(nDeviceIndex)) { ERRORMESSAGE(("%s: Couldn't open WDM device\r\n", _fx_)); SetLastError(ERROR_DCAP_DEVICE_IN_USE); DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); return FALSE; } } hcd->dwFlags |= CAPTURE_DEVICE_OPEN; // Get the initial format and set the values dwLen = GetCaptureDeviceFormatHeaderSize(hcd); if (lpbmih = (LPBITMAPINFOHEADER)LocalAlloc(LPTR, dwLen)) { lpbmih->biSize = dwLen; fl = GetCaptureDeviceFormat(hcd, lpbmih); //If we can't get a format, or height and/or width are 0, don't use this device if (!fl || lpbmih->biWidth == 0 || lpbmih->biHeight == 0) { ERRORMESSAGE(("%s: GetCaptureDeviceFormat failed\r\n", _fx_)); err = ERROR_DCAP_NO_DRIVER_SUPPORT; goto Error; } fl = SetCaptureDeviceFormat(hcd, lpbmih, 0, 0); if (!fl) { ERRORMESSAGE(("%s: SetCaptureDeviceFormat failed\r\n", _fx_)); err = ERROR_DCAP_NO_DRIVER_SUPPORT; goto Error; } #if 0 _SetCaptureRect(hcd->hvideoIn, DVM_DST_RECT, 0, 0, lpbmih->biWidth, lpbmih->biHeight); _SetCaptureRect(hcd->hvideoCapture, DVM_SRC_RECT, 0, 0, lpbmih->biWidth, lpbmih->biHeight); _SetCaptureRect(hcd->hvideoCapture, DVM_DST_RECT, 0, 0, lpbmih->biWidth, lpbmih->biHeight); #endif LocalFree((HANDLE)lpbmih); } else { err = ERROR_OUTOFMEMORY; goto Error; } // Keep a stream running all the time on EXTERNALIN (capture->frame buffer). if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) { #ifdef USE_VIDEO_OVERLAY if (hcd->hvideoOverlay) _InitializeExternalVideoStream(hcd->hvideoOverlay); #else _InitializeExternalVideoStream(hcd->hvideoCapture); #endif #ifndef __NT_BUILD__ // Lock our structure so it can be touched at interrupt time _LockBuffer(hcd->wselLockedInfo); #endif } DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); return hcd; Error: hcd->dwFlags &= ~CAPTURE_DEVICE_OPEN; if (lpbmih) { LocalFree((HANDLE)lpbmih); lpbmih = NULL; } if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) { if (hcd->hvideoIn) { _CloseDriver((HDRVR)hcd->hvideoIn, 0, 0); hcd->hvideoIn = NULL; } if (hcd->hvideoCapture) { _CloseDriver((HDRVR)hcd->hvideoCapture, 0, 0); hcd->hvideoCapture = NULL; } #ifdef USE_VIDEO_OVERLAY if (hcd->hvideoOverlay) { _CloseDriver((HDRVR)hcd->hvideoOverlay, 0, 0); hcd->hvideoOverlay = NULL; } #endif } else { WDMCloseDevice(nDeviceIndex); } SetLastError(err); DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); return NULL; } void DoClose( HCAPDEV hcd ) { FX_ENTRY("DoClose"); DEBUGMSG(ZONE_CALLS, ("%s() - Begin\r\n", _fx_)); // Clean up streaming on main channel, including freeing all buffers if (hcd->dwFlags & HCAPDEV_STREAMING_INITIALIZED) UninitializeStreaming(hcd); // Stop streaming on the capture channel if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) { #ifdef USE_VIDEO_OVERLAY if (hcd->hvideoOverlay) { _SendDriverMessage((HDRVR)hcd->hvideoOverlay, DVM_STREAM_FINI, 0L, 0L); _CloseDriver((HDRVR)hcd->hvideoOverlay, 0, 0); hcd->hvideoOverlay = NULL; } #else _SendDriverMessage((HDRVR)hcd->hvideoCapture, DVM_STREAM_FINI, 0L, 0L); #endif #ifdef USE_VIDEO_OVERLAY if (hcd->hvideoOverlay) { _CloseDriver((HDRVR)hcd->hvideoOverlay, 0, 0); hcd->hvideoOverlay = NULL; } #endif // Close the driver channels if (!_CloseDriver((HDRVR)hcd->hvideoCapture, 0, 0) || !_CloseDriver((HDRVR)hcd->hvideoIn, 0, 0)) { SetLastError(ERROR_DCAP_NONSPECIFIC); ERRORMESSAGE(("%s: Couldn't close channel, error unknown\r\n", _fx_)); // with delayed close this is catastrophic, we can't just return that the device is still // open, but we can't get the device to close either, so we'll have to just leave it in this // hung open state - hopefully this never happens... } hcd->hvideoCapture = NULL; hcd->hvideoIn = NULL; #ifndef __NT_BUILD__ // Free the LOCKEDINFO structure _FreeLockableBuffer(hcd->wselLockedInfo); hcd->wselLockedInfo = 0; #endif } else { WDMCloseDevice(hcd->nDeviceIndex); } hcd->dwFlags &= ~CAPTURE_DEVICE_OPEN; DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); } BOOL DCAPI CloseCaptureDevice( HCAPDEV hcd ) { FX_ENTRY("CloseCaptureDevice"); DEBUGMSG(ZONE_CALLS, ("%s() - Begin\r\n", _fx_)); INIT_CAP_DEV_LIST(); VALIDATE_CAPDEV(hcd); hcd->dwFlags &= ~CAPTURE_DEVICE_OPEN; // clear flag to disable other API's LEAVE_DCAP(hcd); // dec our enter count, if no other thread is in a DCAP // service, then this dec will go to 0 and we'll call // DoClose; else we won't call DoClose until the other // active service dec's the count to 0 DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); return TRUE; } DWORD DCAPI GetCaptureDeviceFormatHeaderSize( HCAPDEV hcd ) { DWORD res; INIT_CAP_DEV_LIST(); VALIDATE_CAPDEV(hcd); ENTER_DCAP(hcd); if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) res = _GetVideoFormatSize(reinterpret_cast(hcd->hvideoIn)); else res = WDMGetVideoFormatSize(hcd->nDeviceIndex); LEAVE_DCAP(hcd); return res; } BOOL DCAPI GetCaptureDeviceFormat( HCAPDEV hcd, LPBITMAPINFOHEADER lpbmih ) { BOOL fRes; FX_ENTRY("GetCaptureDeviceFormat"); INIT_CAP_DEV_LIST(); VALIDATE_CAPDEV(hcd); ENTER_DCAP(hcd); // Call the driver to get the bitmap information if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) fRes = _GetVideoFormat(hcd->hvideoIn, lpbmih); else fRes = WDMGetVideoFormat(hcd->nDeviceIndex, lpbmih); if (!fRes) { // This is DOOM if the driver doesn't support this. // It might be useful have some sort of fallback code here, // or else we should try this when the connection is made and // fail it unless this call works. ERRORMESSAGE(("%s: Failed to get video format\r\n", _fx_)); SetLastError(ERROR_NOT_SUPPORTED); LEAVE_DCAP(hcd); return FALSE; } if (lpbmih->biCompression == BI_RGB) lpbmih->biSizeImage = WIDTHBYTES(lpbmih->biWidth * lpbmih->biBitCount) * lpbmih->biHeight; // Keep track of current buffer size needed hcd->dwcbBuffers = sizeof(CAPBUFFERHDR) + lpbmih->biSizeImage; LEAVE_DCAP(hcd); return TRUE; } BOOL DCAPI SetCaptureDeviceFormat( HCAPDEV hcd, LPBITMAPINFOHEADER lpbmih, LONG srcwidth, LONG srcheight ) { BOOL fRes; #ifdef USE_VIDEO_OVERLAY RECT rect; #endif INIT_CAP_DEV_LIST(); VALIDATE_CAPDEV(hcd); // Don't allow this if streaming if (hcd->dwFlags & HCAPDEV_STREAMING) { SetLastError(ERROR_DCAP_NOT_WHILE_STREAMING); return FALSE; } ENTER_DCAP(hcd); // Call the driver to set the format if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) { fRes = _SetVideoFormat(hcd->hvideoCapture, hcd->hvideoIn, lpbmih); #ifdef USE_VIDEO_OVERLAY if (fRes && hcd->hvideoOverlay) { // Get the current rectangles _SendDriverMessage((HDRVR)hcd->hvideoOverlay, DVM_DST_RECT, (LPARAM)(LPVOID)&rect, VIDEO_CONFIGURE_GET); DEBUGMSG(ZONE_INIT, ("%s: Current overlay dst rect is rect.left=%ld, rect.top=%ld, rect.right=%ld, rect.bottom=%ld\r\n", _fx_, rect.left, rect.top, rect.right, rect.bottom)); _SendDriverMessage((HDRVR)hcd->hvideoOverlay, DVM_SRC_RECT, (LPARAM)(LPVOID)&rect, VIDEO_CONFIGURE_GET); DEBUGMSG(ZONE_INIT, ("%s: Current overlay src rect is rect.left=%ld, rect.top=%ld, rect.right=%ld, rect.bottom=%ld\r\n", _fx_, rect.left, rect.top, rect.right, rect.bottom)); // Set the rectangles rect.left = rect.top = 0; rect.right = (WORD)lpbmih->biWidth; rect.bottom = (WORD)lpbmih->biHeight; _SendDriverMessage((HDRVR)hcd->hvideoOverlay, DVM_DST_RECT, (LPARAM)(LPVOID)&rect, VIDEO_CONFIGURE_SET); _SendDriverMessage((HDRVR)hcd->hvideoOverlay, DVM_SRC_RECT, (LPARAM)(LPVOID)&rect, VIDEO_CONFIGURE_SET); if (hcd->hvideoOverlay) _InitializeExternalVideoStream(hcd->hvideoOverlay); } #endif } else fRes = WDMSetVideoFormat(hcd->nDeviceIndex, lpbmih); if (!fRes) { SetLastError(ERROR_DCAP_FORMAT_NOT_SUPPORTED); LEAVE_DCAP(hcd); return FALSE; } // Cache the bitmap size we're dealing with now if (lpbmih->biCompression == BI_RGB) hcd->dwcbBuffers = sizeof (CAPBUFFERHDR) + lpbmih->biWidth * lpbmih->biHeight * lpbmih->biBitCount / 8; else hcd->dwcbBuffers = sizeof (CAPBUFFERHDR) + lpbmih->biSizeImage; LEAVE_DCAP(hcd); return TRUE; } // GetCaptureDevicePalette // Gets the current palette from the capture device. The entries are returned to // the caller who normally calls CreatePalette on the structure. It may, however, // want to translate the palette entries into some preexisting palette or identity // palette before calling CreatePalette, hence the need for passing back the entries. BOOL DCAPI GetCaptureDevicePalette( HCAPDEV hcd, CAPTUREPALETTE* lpcp ) { BOOL fRes; FX_ENTRY("GetCaptureDevicePalette"); INIT_CAP_DEV_LIST(); VALIDATE_CAPDEV(hcd); ENTER_DCAP(hcd); // The caller doesn't have to initialize the structure. // The driver should fill it in, but it may want it preininitialized so we do that here. lpcp->wVersion = 0x0300; lpcp->wcEntries = 256; // Get the palette entries from the driver and return to the user if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) fRes = _GetVideoPalette(hcd->hvideoIn, lpcp, sizeof (CAPTUREPALETTE)); else fRes = WDMGetVideoPalette(hcd->nDeviceIndex, lpcp, sizeof (CAPTUREPALETTE)); if (!fRes) { ERRORMESSAGE(("%s: No palette returned from driver\r\n", _fx_)); SetLastError(ERROR_DCAP_NO_DRIVER_SUPPORT); LEAVE_DCAP(hcd); return FALSE; } LEAVE_DCAP(hcd); return TRUE; } void TerminateStreaming( HCAPDEV hcd ) { DWORD dwTicks; LPCAPBUFFER lpcbuf; DWORD dwlpvh; BOOL fRes; FX_ENTRY("TerminateStreaming"); DEBUGMSG(ZONE_CALLS, ("%s() - Begin\r\n", _fx_)); StopStreaming(hcd); if (!(hcd->dwFlags & HCAPDEV_STREAMING_FRAME_GRAB)) { hcd->dwFlags |= HCAPDEV_STREAMING_PAUSED; // Make sure we aren't streaming if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) { #ifndef __NT_BUILD__ hcd->lpli->dwFlags |= LIF_STOPSTREAM; #endif _SendDriverMessage((HDRVR)hcd->hvideoIn, DVM_STREAM_RESET, 0, 0); } else WDMVideoStreamReset(hcd->nDeviceIndex); dwTicks = GetTickCount(); lpcbuf = hcd->lpcbufList; while (lpcbuf && GetTickCount() < dwTicks + 1000) { dwlpvh = (DWORD)lpcbuf->vh.lpData - sizeof(CAPBUFFERHDR); // 16:16 ptr to vh = 16:16 ptr to data - sizeof(CAPBUFFERHDR) // 32bit ptr to vh = 32bit ptr to data - sizeof(CAPBUFFERHDR) if (!(lpcbuf->vh.dwFlags & VHDR_DONE)) { if (WaitForSingleObject(hcd->hevWait, 500) == WAIT_TIMEOUT) { ERRORMESSAGE(("%s: Timeout waiting for all buffers done after DVM_STREAM_RESET\r\n", _fx_)); break; // looks like it isn't going to happen, so quit waiting } //else recheck done bit on current buffer if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE) && (lpcbuf->vh.dwFlags & VHDR_DONE) && (lpcbuf->vh.dwFlags & VHDR_PREPARED)) { // AVICap32 clears the prepared flag even if the driver failed the operation - do the same thing _SendDriverMessage((HDRVR)hcd->hvideoIn, DVM_STREAM_UNPREPAREHEADER, dwlpvh, sizeof(VIDEOHDR)); lpcbuf->vh.dwFlags &= ~VHDR_PREPARED; } } else { if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE) && (lpcbuf->vh.dwFlags & VHDR_PREPARED)) { // AVICap32 clears the prepared flag even if the driver failed the operation - do the same thing _SendDriverMessage((HDRVR)hcd->hvideoIn, DVM_STREAM_UNPREPAREHEADER, dwlpvh, sizeof(VIDEOHDR)); lpcbuf->vh.dwFlags &= ~VHDR_PREPARED; } lpcbuf = (LPCAPBUFFER)lpcbuf->vh.dwUser; // next buffer } } DEBUGMSG(ZONE_STREAMING, ("%s: Done trying to clear buffers\r\n", _fx_)); // Clean up flags in order to reuse buffers - drivers do not like to be // given buffers with a dirty dwFlags at the start of streaming... for (lpcbuf = hcd->lpcbufList ; lpcbuf ; lpcbuf = (LPCAPBUFFER)lpcbuf->vh.dwUser) lpcbuf->vh.dwFlags = 0; // Terminate streaming with the driver if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) fRes = _UninitializeVideoStream(hcd->hvideoIn); else fRes = WDMUnInitializeVideoStream(hcd->nDeviceIndex); if (!fRes) { ERRORMESSAGE(("%s: Error returned from XXXUninitializeVideoStream\r\n", _fx_)); } } DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); } BOOL ReinitStreaming( HCAPDEV hcd ) { LPCAPBUFFER lpcbuf; DWORD dwlpvh; BOOL fRes; FX_ENTRY("ReinitStreaming"); DEBUGMSG(ZONE_CALLS, ("%s() - Begin\r\n", _fx_)); if (!(hcd->dwFlags & HCAPDEV_STREAMING_FRAME_GRAB)) { // Tell the driver to prepare for streaming. This sets up the callback if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) #ifdef __NT_BUILD__ fRes = _InitializeVideoStream(hcd->hvideoIn, hcd->dw_usecperframe, (DWORD)hcd); #else fRes = _InitializeVideoStream(hcd->hvideoIn, hcd->dw_usecperframe, (DWORD)hcd->wselLockedInfo << 16); #endif else fRes = WDMInitializeVideoStream(hcd, hcd->nDeviceIndex, hcd->dw_usecperframe); if (!fRes) { ERRORMESSAGE(("%s: Error returned from XXXInitializeVideoStream\r\n", _fx_)); SetLastError(ERROR_DCAP_BAD_FRAMERATE); DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); return FALSE; } // Sleep (10); hcd->dwFlags &= ~HCAPDEV_STREAMING_PAUSED; // If any buffers are not marked DONE, then give them back to the driver; let all // DONE buffers get processed by the app first for (lpcbuf = hcd->lpcbufList ; lpcbuf ; lpcbuf = (LPCAPBUFFER)lpcbuf->vh.dwUser) { if (!(lpcbuf->vh.dwFlags & VHDR_DONE)) { dwlpvh = (DWORD)lpcbuf->vh.lpData - sizeof(CAPBUFFERHDR); // 16:16 ptr to vh = 16:16 ptr to data - sizeof(CAPBUFFERHDR) // 32bit ptr to vh = 32bit ptr to data - sizeof(CAPBUFFERHDR) if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) { // AVICap32 sets the prepared flag even if the driver failed the operation - do the same thing _SendDriverMessage((HDRVR)hcd->hvideoIn, DVM_STREAM_PREPAREHEADER, dwlpvh, sizeof(VIDEOHDR)); lpcbuf->vh.dwFlags |= VHDR_PREPARED; fRes = (_SendDriverMessage((HDRVR)hcd->hvideoIn, DVM_STREAM_ADDBUFFER, dwlpvh, sizeof(VIDEOHDR)) == DV_ERR_OK); } else fRes = WDMVideoStreamAddBuffer(hcd->nDeviceIndex, (PVOID)dwlpvh); if (!fRes) { DEBUGMSG(ZONE_STREAMING, ("%s: Failed with lpcbuf=0x%08lX, lpcbuf->vh.lpData=0x%08lX, dwlpvh=0x%08lX\r\n", _fx_, lpcbuf, lpcbuf->vh.lpData, dwlpvh)); DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); return FALSE; } else { DEBUGMSG(ZONE_STREAMING, ("%s: Succeeded with lpcbuf=0x%08lX, lpcbuf->vh.lpData=0x%08lX, dwlpvh=0x%08lX\r\n", _fx_, lpcbuf, lpcbuf->vh.lpData, dwlpvh)); } } } } DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); return TRUE; } // CaptureDeviceDialog // Puts up one of the driver's dialogs for the user to twiddle. // If I can figure out ANY way to avoid this, I will. BOOL DCAPI CaptureDeviceDialog( HCAPDEV hcd, HWND hwndParent, DWORD dwFlags, LPBITMAPINFOHEADER lpbmih //OPTIONAL ) { DWORD dwDriverFlags = 0; HVIDEO hvid; DWORD dwSize; LPBITMAPINFOHEADER lpbmihCur; #ifdef _DEBUG LPBITMAPINFOHEADER lpbmihPre = NULL; #endif BOOL res = TRUE; FX_ENTRY("CaptureDeviceDialog"); INIT_CAP_DEV_LIST(); VALIDATE_CAPDEV(hcd); if (hcd->dwFlags & HCAPDEV_IN_DRIVER_DIALOG) return FALSE; // don't allow re-entering ENTER_DCAP(hcd); if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) { // See if we are just querying the driver for existence if (dwFlags & CAPDEV_DIALOG_QUERY) dwDriverFlags |= VIDEO_DLG_QUERY; // Select the correct channel to query if (dwFlags & CAPDEV_DIALOG_SOURCE) { hvid = hcd->hvideoCapture; if (!(dwFlags & CAPDEV_DIALOG_QUERY)) { dwDriverFlags |= VIDEO_DLG_QUERY; if (_SendDriverMessage((HDRVR)hvid, DVM_DIALOG, (DWORD)hwndParent, dwDriverFlags) == DV_ERR_NOTSUPPORTED) { hvid = hcd->hvideoIn; } dwDriverFlags &= ~VIDEO_DLG_QUERY; } } else hvid = hcd->hvideoIn; // Don't stop streaming. This make the source dialog totally useless // if the user can't see what is going on. #ifdef _DEBUG if (!lpbmih) { dwSize = GetCaptureDeviceFormatHeaderSize(hcd); if (lpbmihPre = (LPBITMAPINFOHEADER)LocalAlloc(LPTR, dwSize)) { lpbmihPre->biSize = dwSize; GetCaptureDeviceFormat(hcd, lpbmihPre); } lpbmih = lpbmihPre; } #endif // Call the driver hcd->dwFlags |= HCAPDEV_IN_DRIVER_DIALOG; if (_SendDriverMessage((HDRVR)hvid, DVM_DIALOG, (DWORD)hwndParent, dwDriverFlags)) { SetLastError(ERROR_DCAP_NO_DRIVER_SUPPORT); res = FALSE; // restart still ok } else if (lpbmih) { dwSize = GetCaptureDeviceFormatHeaderSize(hcd); if (lpbmihCur = (LPBITMAPINFOHEADER)LocalAlloc(LPTR, dwSize)) { lpbmihCur->biSize = dwSize; GetCaptureDeviceFormat(hcd, lpbmihCur); if (lpbmih->biSize != lpbmihCur->biSize || lpbmih->biWidth != lpbmihCur->biWidth || lpbmih->biHeight != lpbmihCur->biHeight || lpbmih->biBitCount != lpbmihCur->biBitCount || lpbmih->biCompression != lpbmihCur->biCompression) { ERRORMESSAGE(("%s: Format changed in dialog!!\r\n", _fx_)); #ifdef _DEBUG DebugBreak(); #endif // dialog changed format, so try to set it back if (!SetCaptureDeviceFormat(hcd, lpbmih, 0, 0)) { SetLastError (ERROR_DCAP_DIALOG_FORMAT); res = FALSE; } } LocalFree ((HANDLE)lpbmihCur); } #ifdef _DEBUG if (lpbmih == lpbmihPre) { LocalFree ((HANDLE)lpbmihPre); lpbmih = NULL; lpbmihPre = NULL; } #endif } hcd->dwFlags &= ~HCAPDEV_IN_DRIVER_DIALOG; if (hcd->dwFlags & HCAPDEV_STREAMING) { // The Intel Smart Video Recorder Pro stops streaming // on exit from the source dialog (!?!?). Make sure // we reset the streaming on any kind of device right // after we exit the source dialog. I verified this on // the CQC, ISVR Pro, Video Stinger and Video Blaster SE100. // They all seem to take this pretty well... TerminateStreaming(hcd); if (ReinitStreaming(hcd)) StartStreaming(hcd); else { SetLastError(ERROR_DCAP_DIALOG_STREAM); res = FALSE; ERRORMESSAGE(("%s: Couldn't reinit streaming after dialog!\r\n", _fx_)); } } } else { // See if we are just querying the driver for existence if (dwFlags & CAPDEV_DIALOG_QUERY) { // We only expose a settings dialog if (dwFlags & CAPDEV_DIALOG_IMAGE) { SetLastError(ERROR_DCAP_NO_DRIVER_SUPPORT); res = FALSE; ERRORMESSAGE(("%s: Driver does not support this dialog!\r\n", _fx_)); } } else { if (!WDMShowSettingsDialog(hcd->nDeviceIndex, hwndParent)) { SetLastError(ERROR_DCAP_NO_DRIVER_SUPPORT); res = FALSE; ERRORMESSAGE(("%s: Driver does not support this dialog!\r\n", _fx_)); } } hcd->dwFlags &= ~HCAPDEV_IN_DRIVER_DIALOG; // No need to restart streaming on WDM devices tested so far // Will add this feature if problems come up } LEAVE_DCAP(hcd); return res; } // InitializeStreaming // Allocates all memory and other objects necessary for streaming. BOOL DCAPI InitializeStreaming( HCAPDEV hcd, CAPSTREAM* lpcs, DWORD flags ) { LPCAPBUFFER lpcbuf; DWORD dwRound; LPBITMAPINFOHEADER lpbmih; BOOL bHaveBuffers = FALSE; FX_ENTRY("InitializeStreaming"); DEBUGMSG(ZONE_CALLS, ("%s() - Begin\r\n", _fx_)); INIT_CAP_DEV_LIST(); VALIDATE_CAPDEV(hcd); // It doesn't make sense to stream with less than 2 buffers if (lpcs->ncCapBuffers < MIN_STREAMING_CAPTURE_BUFFERS || flags & 0xfffffffe || hcd->dwFlags & HCAPDEV_STREAMING_INITIALIZED) { SetLastError(ERROR_INVALID_PARAMETER); DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); return FALSE; } ENTER_DCAP(hcd); hcd->dwFlags &= ~(HCAPDEV_STREAMING | HCAPDEV_STREAMING_INITIALIZED | HCAPDEV_STREAMING_FRAME_GRAB | HCAPDEV_STREAMING_FRAME_TIME | HCAPDEV_STREAMING_PAUSED); // Before allocating, make sure we have the current format. // This sets our idea of the current size we need for the buffer by // setting hcd->dwcbBuffers as a side effect dwRound = GetCaptureDeviceFormatHeaderSize(hcd); if (lpbmih = (LPBITMAPINFOHEADER)LocalAlloc(LPTR, dwRound)) { lpbmih->biSize = dwRound; GetCaptureDeviceFormat(hcd, lpbmih); LocalFree ((HANDLE)lpbmih); } else { SetLastError(ERROR_OUTOFMEMORY); goto Error; } // BUGBUG - add logic to determine if we should automatically use FRAME_GRAB mode // Try allocating the number asked for if (flags & STREAMING_PREFER_FRAME_GRAB) { hcd->dwFlags |= HCAPDEV_STREAMING_FRAME_GRAB; } if (!allocateBuffers(hcd, lpcs->ncCapBuffers)) { SetLastError(ERROR_OUTOFMEMORY); goto Error; } // Create the event we need so we can signal at interrupt time if (!(hcd->hevWait = CreateEvent(NULL, FALSE, FALSE, NULL))) { ERRORMESSAGE(("%s: CreateEvent failed!\r\n", _fx_)); SetLastError(ERROR_OUTOFMEMORY); goto Error; } // Init CS used to serialize buffer list management InitializeCriticalSection(&hcd->bufferlistCS); // We were given frames per second times 100. Converting this to // usec per frame is 1/fps * 1,000,000 * 100. Here, do 1/fps * 1,000,000,000 // to give us an extra digit to do rounding on, then do a final / 10 hcd->dw_usecperframe = (unsigned)1000000000 / (unsigned)lpcs->nFPSx100; dwRound = hcd->dw_usecperframe % 10; // Could have done with one less divide, hcd->dw_usecperframe /= 10; // but this is clearer, and this is just // an init call... if (dwRound >= 5) hcd->dw_usecperframe++; hcd->lpCurrent = NULL; hcd->lpHead = NULL; hcd->lpTail = NULL; if (hcd->dwFlags & HCAPDEV_STREAMING_FRAME_GRAB) { #ifndef __NT_BUILD__ if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) hcd->lpli->pevWait = 0; #endif // link the buffers into the available list // start with empty list hcd->lpHead = (LPCAPBUFFER)(((LPBYTE)&hcd->lpHead) - sizeof(VIDEOHDR)); // fake CAPBUFFERHDR hcd->lpTail = (LPCAPBUFFER)(((LPBYTE)&hcd->lpHead) - sizeof(VIDEOHDR)); // fake CAPBUFFERHDR // now insert the buffers for (lpcbuf = hcd->lpcbufList ; lpcbuf ; lpcbuf = (LPCAPBUFFER)lpcbuf->vh.dwUser) { lpcbuf->lpPrev = hcd->lpTail; hcd->lpTail = lpcbuf; lpcbuf->lpNext = lpcbuf->lpPrev->lpNext; lpcbuf->lpPrev->lpNext = lpcbuf; lpcbuf->vh.dwFlags |= VHDR_INQUEUE; } } else { #ifndef __NT_BUILD__ if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) { hcd->lpli->pevWait = (DWORD)OpenVxDHandle(hcd->hevWait); // Lock down the LOCKEDINFO structure if (!_LockBuffer(hcd->wselLockedInfo)) { SetLastError(ERROR_OUTOFMEMORY); goto Error; } hcd->lpli->lp1616Head = 0; hcd->lpli->lp1616Tail = 0; hcd->lpli->lp1616Current = 0; } #endif if (!ReinitStreaming(hcd)) goto Error; } lpcs->hevWait = hcd->hevWait; // Flag that streaming is initialized hcd->dwFlags |= HCAPDEV_STREAMING_INITIALIZED; LEAVE_DCAP(hcd); DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); return TRUE; Error: freeBuffers(hcd); if (hcd->hevWait) { CloseHandle(hcd->hevWait); #ifndef __NT_BUILD__ if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE) && hcd->lpli->pevWait) _CloseVxDHandle(hcd->lpli->pevWait); #endif } LEAVE_DCAP(hcd); DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); return FALSE; } // SetStreamFrameRate // Changes the frame rate of a stream initialized channel. // PhilF-: This call is not used by NMCAP and NAC. So remove it or // start using it. BOOL DCAPI SetStreamFrameRate( HCAPDEV hcd, int nFPSx100 ) { DWORD dwNew, dwRound; BOOL restart; BOOL res = TRUE; INIT_CAP_DEV_LIST(); VALIDATE_CAPDEV(hcd); if (!(hcd->dwFlags & HCAPDEV_STREAMING_INITIALIZED)) { // must already have the channel initialized for streaming SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } ENTER_DCAP(hcd); restart = (hcd->dwFlags & HCAPDEV_STREAMING); // We were given frames per second times 100. Converting this to // usec per frame is 1/fps * 1,000,000 * 100. Here, do 1/fps * 1,000,000,000 // to give us an extra digit to do rounding on, then do a final / 10 dwNew = (unsigned)1000000000 / (unsigned)nFPSx100; dwRound = dwNew % 10; // Could have done with one less divide, dwNew /= 10; // but this is clearer, and this is just an init call... if (dwRound >= 5) dwNew++; if (dwNew != hcd->dw_usecperframe) { TerminateStreaming(hcd); hcd->dw_usecperframe = dwNew; res = ReinitStreaming(hcd); if (restart && res) StartStreaming(hcd); } LEAVE_DCAP(hcd); return res; } // UninitializeStreaming // Frees all memory and objects associated with streaming. BOOL DCAPI UninitializeStreaming( HCAPDEV hcd ) { DWORD dwTicks; LPCAPBUFFER lpcbuf; FX_ENTRY("UninitializeStreaming"); DEBUGMSG(ZONE_CALLS, ("%s() - Begin\r\n", _fx_)); INIT_CAP_DEV_LIST(); VALIDATE_CAPDEV(hcd); if (!(hcd->dwFlags & HCAPDEV_STREAMING_INITIALIZED)) { SetLastError(ERROR_INVALID_PARAMETER); DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); return FALSE; } ENTER_DCAP(hcd); TerminateStreaming(hcd); #ifndef __NT_BUILD__ if (!(hcd->dwFlags & HCAPDEV_STREAMING_FRAME_GRAB) && !(hcd->dwFlags & WDM_CAPTURE_DEVICE)) { // Unlock our locked structure _UnlockBuffer(hcd->wselLockedInfo); // Free the event _CloseVxDHandle(hcd->lpli->pevWait); } #endif DeleteCriticalSection(&hcd->bufferlistCS); CloseHandle(hcd->hevWait); // BUGBUG - what about app still owning buffers // Loop through freeing all the buffers freeBuffers(hcd); hcd->dwFlags &= ~(HCAPDEV_STREAMING_INITIALIZED + HCAPDEV_STREAMING_PAUSED); LEAVE_DCAP(hcd); DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); return TRUE; } void CALLBACK TimeCallback( UINT uID, UINT uMsg, HCAPDEV hcd, DWORD dw1, DWORD dw2 ) { hcd->dwFlags |= HCAPDEV_STREAMING_FRAME_TIME; // flag time for a new frame SetEvent (hcd->hevWait); // signal client to initiate frame grab } // StartStreaming // Begins streaming. BOOL DCAPI StartStreaming( HCAPDEV hcd ) { BOOL fRet; DWORD dwRet; FX_ENTRY("StartStreaming"); DEBUGMSG(ZONE_CALLS, ("%s() - Begin\r\n", _fx_)); INIT_CAP_DEV_LIST(); VALIDATE_CAPDEV(hcd); ENTER_DCAP(hcd); if (hcd->dwFlags & HCAPDEV_STREAMING_FRAME_GRAB) { fRet = ((hcd->timerID = timeSetEvent(hcd->dw_usecperframe/1000, 5, (LPTIMECALLBACK)&TimeCallback, (DWORD)hcd, TIME_PERIODIC)) != 0); } else { int i; fRet = FALSE; #ifndef __NT_BUILD__ if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) hcd->lpli->dwFlags &= ~LIF_STOPSTREAM; #endif for (i = 0; i < 5; i++) { if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) { dwRet = _SendDriverMessage((HDRVR)hcd->hvideoIn, DVM_STREAM_START, 0, 0); fRet = (dwRet == DV_ERR_OK); if (dwRet) { ERRORMESSAGE(("%s: DVM_STREAM_START failed, return code was %ld\r\n", _fx_, dwRet)); } } else fRet = WDMVideoStreamStart(hcd->nDeviceIndex); if (fRet) break; else if (i > 1) Sleep(10); } } if (fRet) hcd->dwFlags |= HCAPDEV_STREAMING; LEAVE_DCAP(hcd); DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); return fRet; } // StopStreaming // Stops streaming but doesn't free any memory associated with streaming // so that it can be restarted with StartStreaming. BOOL DCAPI StopStreaming( HCAPDEV hcd ) { BOOL fRet; FX_ENTRY("StopStreaming"); DEBUGMSG(ZONE_CALLS, ("%s() - Begin\r\n", _fx_)); INIT_CAP_DEV_LIST(); VALIDATE_CAPDEV(hcd); ENTER_DCAP(hcd); if (hcd->dwFlags & HCAPDEV_STREAMING_FRAME_GRAB) { timeKillEvent(hcd->timerID); hcd->dwFlags &= ~HCAPDEV_STREAMING; // grab CS to ensure that no frame grab is in progress EnterCriticalSection(&hcd->bufferlistCS); LeaveCriticalSection(&hcd->bufferlistCS); fRet = TRUE; } else { if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) fRet = (_SendDriverMessage((HDRVR)hcd->hvideoIn, DVM_STREAM_STOP, 0, 0) == DV_ERR_OK); else fRet = WDMVideoStreamStop(hcd->nDeviceIndex); } if (fRet) hcd->dwFlags &= ~HCAPDEV_STREAMING; LEAVE_DCAP(hcd); DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); return fRet; } // GetNextReadyBuffer // Called by the app to find the next buffer that has been marked as // done by the driver and has data to be displayed. LPSTR DCAPI GetNextReadyBuffer( HCAPDEV hcd, CAPFRAMEINFO* lpcfi ) { LPCAPBUFFER lpcbuf; DWORD dwlpvh; BOOL fRet; FX_ENTRY("GetNextReadyBuffer"); INIT_CAP_DEV_LIST(); ENTER_DCAP(hcd); if (hcd->dwFlags & HCAPDEV_STREAMING_FRAME_GRAB) { lpcbuf = (LPCAPBUFFER)hcd->lpHead; if ((hcd->dwFlags & HCAPDEV_STREAMING_FRAME_TIME) && (lpcbuf != (LPCAPBUFFER)(((LPBYTE)&hcd->lpHead) - sizeof(VIDEOHDR)))) /* fake CAPBUFFERHDR */ { // remove buffer from list EnterCriticalSection(&hcd->bufferlistCS); hcd->dwFlags &= ~HCAPDEV_STREAMING_FRAME_TIME; lpcbuf->lpPrev->lpNext = lpcbuf->lpNext; lpcbuf->lpNext->lpPrev = lpcbuf->lpPrev; lpcbuf->vh.dwFlags &= ~VHDR_INQUEUE; lpcbuf->vh.dwFlags |= VHDR_DONE; LeaveCriticalSection(&hcd->bufferlistCS); dwlpvh = (DWORD)lpcbuf->vh.lpData - sizeof(CAPBUFFERHDR); // 16:16 ptr to vh = 16:16 ptr to data - sizeof(CAPBUFFERHDR) // 32bit ptr to vh = 32bit ptr to data - sizeof(CAPBUFFERHDR) if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) fRet = (SendDriverMessage((HDRVR)hcd->hvideoIn, DVM_FRAME, dwlpvh, sizeof(VIDEOHDR)) == DV_ERR_OK); else fRet = WDMGetFrame(hcd->nDeviceIndex, (PVOID)dwlpvh); if (!fRet) { // put buffer back into list EnterCriticalSection(&hcd->bufferlistCS); lpcbuf->lpPrev = hcd->lpTail; hcd->lpTail = lpcbuf; lpcbuf->lpNext = lpcbuf->lpPrev->lpNext; lpcbuf->lpPrev->lpNext = lpcbuf; lpcbuf->vh.dwFlags |= VHDR_INQUEUE; LeaveCriticalSection(&hcd->bufferlistCS); lpcbuf = NULL; } } else lpcbuf = NULL; } else { #ifdef __NT_BUILD__ // If the current pointer is NULL, there is no frame ready so bail if (!hcd->lpCurrent) lpcbuf = NULL; else { // Get the linear address of the buffer lpcbuf = hcd->lpCurrent; // Move to the next ready buffer hcd->lpCurrent = lpcbuf->lpPrev; } #else //-------------------- // Buffer ready queue: // We maintain a doubly-linked list of our buffers so that we can buffer up // multiple ready frames when the app isn't ready to handle them. Two things // complicate what ought to be a very simple thing: (1) Thunking issues: the pointers // used on the 16-bit side are 16:16 (2) Interrupt time issues: the FrameCallback // gets called at interrupt time. GetNextReadyBuffer must handle the fact that // buffers get added to the list asynchronously. // // To handle this, the scheme implemented here is to have a double-linked list // of buffers with all insertions and deletions happening in FrameCallback // (interrupt time). This allows the GetNextReadyBuffer routine to simply // find the previous block on the list any time it needs a new buffer without // fear of getting tromped (as would be the case if it had to dequeue buffers). // The FrameCallback routine is responsible to dequeue blocks that GetNextReadyBuffer // is done with. Dequeueing is simple since we don't need to unlink the blocks: // no code ever walks the list! All we have to do is move the tail pointer back up // the list. All the pointers, head, tail, next, prev, are all 16:16 pointers // since all the list manipulation is on the 16-bit side AND because MapSL is // much more efficient and safer than MapLS since MapLS has to allocate selectors. //-------------------- // If the current pointer is NULL, there is no frame ready so bail if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) { if (!hcd->lpli->lp1616Current) lpcbuf = NULL; else { // Get the linear address of the buffer lpcbuf = (LPCAPBUFFER)MapSL(hcd->lpli->lp1616Current); // Move to the next ready buffer hcd->lpli->lp1616Current = lpcbuf->lp1616Prev; } } else { // If the current pointer is NULL, there is no frame ready so bail if (!hcd->lpCurrent) lpcbuf = NULL; else { // Get the linear address of the buffer lpcbuf = hcd->lpCurrent; // Move to the next ready buffer hcd->lpCurrent = lpcbuf->lpPrev; } } #endif } if (!lpcbuf) { lpcfi->lpData = NULL; DEBUGMSG(ZONE_STREAMING, ("\r\n { %s: Fails with lpcbuf=NULL\r\n", _fx_)); LEAVE_DCAP(hcd); return NULL; } // Build the CAPFRAMEINFO from the VIDEOHDR information lpcfi->lpData = ((LPSTR)lpcbuf) + sizeof(CAPBUFFERHDR); lpcfi->dwcbData = lpcbuf->vh.dwBytesUsed; lpcfi->dwTimestamp = lpcbuf->vh.dwTimeCaptured; lpcfi->dwFlags = 0; lpcbuf->lpNext = NULL; DEBUGMSG(ZONE_STREAMING, ("\r\n { %s: Succeeded with lpcbuf=0x%08lX\r\n lpcbuf->vh.lpData=0x%08lX\r\n lpcbuf->vh.dwBufferLength=%ld\r\n", _fx_, lpcbuf, lpcbuf->vh.lpData, lpcbuf->vh.dwBufferLength)); DEBUGMSG(ZONE_STREAMING, (" lpcbuf->vh.dwBytesUsed=%ld\r\n lpcbuf->vh.dwTimeCaptured=%ld\r\n lpcbuf->vh.dwFlags=0x%08lX\r\n", lpcbuf->vh.dwBytesUsed, lpcbuf->vh.dwTimeCaptured, lpcbuf->vh.dwFlags)); LEAVE_DCAP(hcd); return lpcfi->lpData; } // PutBufferIntoStream // When the app is finished using a buffer, it must allow it to be requeued // by calling this API. BOOL DCAPI PutBufferIntoStream( HCAPDEV hcd, BYTE* lpBits ) { LPCAPBUFFER lpcbuf; DWORD dwlpvh; BOOL res; FX_ENTRY("PutBufferIntoStream"); INIT_CAP_DEV_LIST(); ENTER_DCAP(hcd); // From the CAPFRAMEINFO, find the appropriate CAPBUFFER pointer lpcbuf = (LPCAPBUFFER)(lpBits - sizeof(CAPBUFFERHDR)); DEBUGMSG(ZONE_STREAMING, ("\r\n%s: Returning buffer lpcbuf=0x%08lX\r\n", _fx_, lpcbuf)); lpcbuf->vh.dwFlags &= ~VHDR_DONE; // mark that app no longer owns buffer if (hcd->dwFlags & HCAPDEV_STREAMING_FRAME_GRAB) { EnterCriticalSection(&hcd->bufferlistCS); lpcbuf->lpPrev = hcd->lpTail; hcd->lpTail = lpcbuf; lpcbuf->lpNext = lpcbuf->lpPrev->lpNext; lpcbuf->lpPrev->lpNext = lpcbuf; lpcbuf->vh.dwFlags |= VHDR_INQUEUE; res = TRUE; LeaveCriticalSection(&hcd->bufferlistCS); } else if (!(hcd->dwFlags & HCAPDEV_STREAMING_PAUSED)) { // if streaming is paused, then just return with the busy bit cleared, we'll add the // buffer into the stream in ReinitStreaming // // if streaming isn't paused, then call the driver to add the buffer dwlpvh = (DWORD)lpcbuf->vh.lpData - sizeof(CAPBUFFERHDR); // 16:16 ptr to vh = 16:16 ptr to data - sizeof(CAPBUFFERHDR) // 32bit ptr to vh = 32bit ptr to data - sizeof(CAPBUFFERHDR) if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) res = (_SendDriverMessage((HDRVR)hcd->hvideoIn, DVM_STREAM_ADDBUFFER, dwlpvh, sizeof(VIDEOHDR)) == DV_ERR_OK); else res = WDMVideoStreamAddBuffer(hcd->nDeviceIndex, (PVOID)dwlpvh); if (res) { DEBUGMSG(ZONE_STREAMING, (" } %s: Succeeded with lpcbuf=0x%08lX\r\n lpcbuf->vh.lpData=0x%08lX\r\n dwlpvh=0x%08lX\r\n", _fx_, lpcbuf, lpcbuf->vh.lpData, dwlpvh)); } else { DEBUGMSG(ZONE_STREAMING, (" } %s: Failed with lpcbuf=0x%08lX\r\n lpcbuf->vh.lpData=0x%08lX\r\n dwlpvh=0x%08lX\r\n", _fx_, lpcbuf, lpcbuf->vh.lpData, dwlpvh)); } } LEAVE_DCAP(hcd); return res; } // CaptureFrame LPBYTE DCAPI CaptureFrame( HCAPDEV hcd, HFRAMEBUF hbuf ) { DWORD dwlpvh; LPBYTE lpbuf; BOOL fRet; FX_ENTRY("CaptureFrame"); INIT_CAP_DEV_LIST(); VALIDATE_CAPDEV(hcd); ENTER_DCAP(hcd); dwlpvh = (DWORD)hbuf->vh.lpData - sizeof(CAPBUFFERHDR); // 16:16 ptr to vh = 16:16 ptr to data - sizeof(CAPBUFFERHDR) // 32bit ptr to vh = 32bit ptr to data - sizeof(CAPBUFFERHDR) if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) fRet = (_SendDriverMessage((HDRVR)hcd->hvideoIn, DVM_FRAME, dwlpvh, sizeof(VIDEOHDR)) == DV_ERR_OK); else fRet = WDMGetFrame(hcd->nDeviceIndex, (PVOID)dwlpvh); if (!fRet) { ERRORMESSAGE(("%s: DVM_FRAME failed!\r\n", _fx_)); lpbuf = NULL; } else lpbuf = ((LPBYTE)hbuf) + sizeof(CAPBUFFERHDR); // return ptr to buffer immediately following hdr LEAVE_DCAP(hcd); return lpbuf; } LPBYTE DCAPI GetFrameBufferPtr( HCAPDEV hcd, HFRAMEBUF hbuf ) { INIT_CAP_DEV_LIST(); if (hbuf) return ((LPBYTE)hbuf) + sizeof(CAPBUFFERHDR); // return ptr to buffer immediately following hdr else return NULL; } HFRAMEBUF DCAPI AllocFrameBuffer( HCAPDEV hcd ) { LPCAPBUFFER hbuf = NULL; DWORD dpBuf; INIT_CAP_DEV_LIST(); ENTER_DCAP(hcd); #ifdef __NT_BUILD__ if (dpBuf = (DWORD)LocalAlloc(LPTR, hcd->dwcbBuffers)) { hbuf = (LPCAPBUFFER)dpBuf; #else if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) { dpBuf = (DWORD)_AllocateLockableBuffer(hcd->dwcbBuffers) << 16; hbuf = (LPCAPBUFFER)MapSL(dpBuf); } else { dpBuf = (DWORD)LocalAlloc(LPTR, hcd->dwcbBuffers); hbuf = (LPCAPBUFFER)dpBuf; } if (dpBuf) { #endif // Initialize the VIDEOHDR structure hbuf->vh.lpData = (LPBYTE)(dpBuf + sizeof(CAPBUFFERHDR)); hbuf->vh.dwBufferLength = hcd->dwcbBuffers - sizeof(CAPBUFFERHDR); hbuf->vh.dwFlags = 0UL; } LEAVE_DCAP(hcd); return (HFRAMEBUF)hbuf; } VOID DCAPI FreeFrameBuffer( HCAPDEV hcd, HFRAMEBUF hbuf ) { INIT_CAP_DEV_LIST(); if (hbuf) { ENTER_DCAP(hcd); #ifdef __NT_BUILD__ LocalFree((HANDLE)hbuf); #else if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) _FreeLockableBuffer(HIWORD((DWORD)hbuf->vh.lpData)); else LocalFree((HANDLE)hbuf); #endif LEAVE_DCAP(hcd); } } //===================================================================== // Helper functions HVIDEO openVideoChannel( DWORD dwDeviceID, DWORD dwFlags ) { HVIDEO hvidRet = NULL; VIDEO_OPEN_PARMS vop; #ifdef __NT_BUILD__ WCHAR devName[MAX_PATH]; #else #define LPWSTR LPSTR #define devName g_aCapDevices[dwDeviceID]->szDeviceName #endif FX_ENTRY("openVideoChannel"); DEBUGMSG(ZONE_CALLS, ("%s() - Begin\r\n", _fx_)); // Validate parameters if (!g_cDevices) { SetLastError(ERROR_DCAP_BAD_INSTALL); DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); return NULL; } if (dwDeviceID > (DWORD)g_cDevices) { SetLastError(ERROR_INVALID_PARAMETER); DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); return NULL; } // Prepare to call the driver vop.dwSize = sizeof (VIDEO_OPEN_PARMS); vop.fccType = OPEN_TYPE_VCAP; vop.fccComp = 0L; vop.dwVersion = VIDEOAPIVERSION; vop.dwFlags = dwFlags; // In, Out, External In, External Out vop.dwError = 0; vop.dnDevNode = g_aCapDevices[dwDeviceID]->dwDevNode; #ifdef __NT_BUILD__ MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, (LPSTR)&(g_aCapDevices[dwDeviceID]->szDeviceName), -1, (LPWSTR)&devName, MAX_PATH); #endif hvidRet = (HVIDEO)_OpenDriver((LPWSTR)&devName, NULL, (LONG)&vop); #ifndef NO_DRIVER_HACKS if (!hvidRet) { // backward compatibility hack // Some drivers fail to open because of the extra fields that were added to // VIDEO_OPEN_PARAMS struct for Win95. Therefore, if the open fails, try // decrementing the dwSize field back to VFW1.1 size and try again. Also try // decrementing the API version field. vop.dwSize -= sizeof(DWORD) + sizeof(LPVOID)*2; #if 0 while (--vop.dwVersion > 2 && !hvidRet) #endif while (--vop.dwVersion > 0 && !hvidRet) hvidRet = (HVIDEO)_OpenDriver((LPWSTR)&devName, NULL, (LONG)&vop); } #endif //NO_DRIVER_HACKS // BUGBUG [JonT] 31-Jul-96 // Translate error values from DV_ERR_* values if (!hvidRet) SetLastError(vop.dwError); DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); return hvidRet; } // allocateBuffers BOOL allocateBuffers( HCAPDEV hcd, int nBuffers ) { int i; LPCAPBUFFER lpcbuf; DWORD dpBuf; FX_ENTRY("allocateBuffers"); DEBUGMSG(ZONE_CALLS, ("%s() - Begin\r\n", _fx_)); // Try to allocate all they ask for for (i = 0 ; i < nBuffers ; i++) { #ifdef __NT_BUILD__ if (!(dpBuf = (DWORD)LocalAlloc(LPTR, hcd->dwcbBuffers))) goto Error; else lpcbuf = (LPCAPBUFFER)dpBuf; #else if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) { if (!(dpBuf = (DWORD)_AllocateLockableBuffer(hcd->dwcbBuffers) << 16) || !_LockBuffer((WORD)(dpBuf >> 16))) goto Error; else lpcbuf = (LPCAPBUFFER)MapSL(dpBuf); } else { if (!(dpBuf = (DWORD)LocalAlloc(LPTR, hcd->dwcbBuffers))) goto Error; else lpcbuf = (LPCAPBUFFER)dpBuf; } #endif // Initialize the VIDEOHDR structure lpcbuf->vh.lpData = (LPBYTE)(dpBuf + sizeof(CAPBUFFERHDR)); lpcbuf->vh.dwUser = (DWORD)hcd->lpcbufList; hcd->lpcbufList = lpcbuf; lpcbuf->vh.dwBufferLength = hcd->dwcbBuffers - sizeof(CAPBUFFERHDR); lpcbuf->vh.dwFlags = 0UL; } #ifdef _DEBUG // Show buffer map DEBUGMSG(ZONE_STREAMING, ("%s: Streaming Buffer map:\r\n", _fx_)); DEBUGMSG(ZONE_STREAMING, ("Root: hcd->lpcbufList=0x%08lX\r\n", hcd->lpcbufList)); for (i = 0, lpcbuf=hcd->lpcbufList ; i < nBuffers ; i++, lpcbuf=(LPCAPBUFFER)lpcbuf->vh.dwUser) { DEBUGMSG(ZONE_STREAMING, ("Buffer[%ld]: lpcbuf=0x%08lX\r\n lpcbuf->vh.lpData=0x%08lX\r\n", i, lpcbuf, lpcbuf->vh.lpData)); DEBUGMSG(ZONE_STREAMING, (" lpcbuf->vh.dwBufferLength=%ld\r\n lpcbuf->vh.dwBytesUsed=%ld\r\n", lpcbuf->vh.dwBufferLength, lpcbuf->vh.dwBytesUsed)); DEBUGMSG(ZONE_STREAMING, (" lpcbuf->vh.dwTimeCaptured=%ld\r\n lpcbuf->vh.dwUser=0x%08lX\r\n", lpcbuf->vh.dwTimeCaptured, lpcbuf->vh.dwUser)); } #endif DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); return TRUE; // In the error case, we have to get rid of this page locked memory Error: freeBuffers(hcd); DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); return FALSE; } // freeBuffers void freeBuffers( HCAPDEV hcd ) { LPCAPBUFFER lpcbuf; FX_ENTRY("freeBuffers"); DEBUGMSG(ZONE_CALLS, ("%s() - Begin\r\n", _fx_)); while (hcd->lpcbufList) { lpcbuf = hcd->lpcbufList; hcd->lpcbufList = (LPCAPBUFFER)lpcbuf->vh.dwUser; #ifdef __NT_BUILD__ LocalFree((HANDLE)lpcbuf); #else if (!(hcd->dwFlags & WDM_CAPTURE_DEVICE)) { _UnlockBuffer(HIWORD((DWORD)lpcbuf->vh.lpData)); _FreeLockableBuffer(HIWORD((DWORD)lpcbuf->vh.lpData)); } else LocalFree((HANDLE)lpcbuf); #endif } DEBUGMSG(ZONE_CALLS, ("%s() - End\r\n", _fx_)); }