/**************************************************************************** video.c Contains video APIs Copyright (c) Microsoft Corporation 1992. All rights reserved ****************************************************************************/ #include #include #include #include #include "msviddrv.h" #include "ivideo32.h" // includes msvideo.h #include "msvideoi.h" #ifdef _WIN32 #include "profile.h" #include #include #include #else #include #endif #include "debug.h" #ifndef DEVNODE typedef DWORD DEVNODE; // Devnode. #endif #ifndef LPHKEY typedef HKEY FAR * LPHKEY; #endif #if defined _WIN32 && !defined UNICODE HDRVR WINAPI OpenDriverA( LPCSTR szDriverName, LPCSTR szSectionName, LPARAM lParam2); #endif /***************************************************************************** * Variables * ****************************************************************************/ #ifdef WIN16 // All of this is currently only used in 16 bit land SZCODE szVideo[] = TEXT("msvideo"); #ifndef UNICODE // Registry settings of interest to capture drivers SZCODE szRegKey[] = TEXT("SYSTEM\\CurrentControlSet\\Control\\MediaResources\\msvideo"); SZCODE szRegActive[] = TEXT("Active"); SZCODE szRegDisabled[] = TEXT("Disabled"); SZCODE szRegDescription[] = TEXT("Description"); SZCODE szRegDevNode[] = TEXT("DevNode"); SZCODE szRegDriver[] = TEXT("Driver"); SZCODE szRegSoftwareKey[] = TEXT("SOFTWAREKEY"); #endif #ifndef _WIN32 SZCODE szDrivers[] = "Drivers"; #else STATICDT SZCODE szDrivers[] = DRIVERS_SECTION; #endif STATICDT SZCODE szSystemIni[] = TEXT("system.ini"); static SZCODE szNull[] = TEXT(""); UINT wTotalVideoDevs; // total video devices LPCAPDRIVERINFO aCapDriverList[MAXVIDEODRIVERS]; // Array of all capture drivers /***************************************************************************** * @doc INTERNAL VIDEO validation code for VIDEOHDRs ****************************************************************************/ #define IsVideoHeaderPrepared(hVideo, lpwh) ((lpwh)->dwFlags & VHDR_PREPARED) #define MarkVideoHeaderPrepared(hVideo, lpwh) ((lpwh)->dwFlags |= VHDR_PREPARED) #define MarkVideoHeaderUnprepared(hVideo, lpwh) ((lpwh)->dwFlags &=~VHDR_PREPARED) /***************************************************************************** * @doc INTERNAL VIDEO * * @api BOOL | videoRegOpenMSVideoKey | This function returns a key * for the msvideo node in the registry. * If the key does not exist it will be created, * and the default entries made. * * @rdesc Returns Key on success, else NULL. ****************************************************************************/ HKEY videoRegOpenMSVideoKey (void) { HKEY hKey = NULL; // Get the key if it already exists if (RegOpenKey ( HKEY_LOCAL_MACHINE, szRegKey, &hKey) != ERROR_SUCCESS) { // Otherwise make a new key if (RegCreateKey ( HKEY_LOCAL_MACHINE, szRegKey, &hKey) == ERROR_SUCCESS) { // Add the default entries to the msvideo node? } } return hKey; } /***************************************************************************** * @doc INTERNAL VIDEO * * @api BOOL | videoRegGetDriverByIndex | This function returns information * about a capture driver by index from the registry. * * @parm DWORD | dwDeviceID | Identifies the video device to open. * The value of

varies from zero to one less * than the number of video capture devices installed in the system. * * @parm LPDEVNODE | lpDevnode | Specifies a far pointer to a buffer * used to return an handle. For non Plug-and-Play devices, * this return value will be NULL. * * @parm LPBOOL | lpEnabled | Specifies a far pointer to a buffer * used to return a flag. If this value is TRUE, the driver is * enabled, if FALSE, the corresponding device is disabled. * * @rdesc Returns TRUE if successful, or FALSE if a driver was not found * with the

index. * * @comm Because the indexes of the MSVIDEO devices in the SYSTEM.INI * file can be non-contiguous, applications should not assume * the indexes range between zero and the number of devices minus * one. * ****************************************************************************/ BOOL videoRegGetKeyByIndex ( HKEY hKeyMSVideoRoot, DWORD dwDeviceID, LPCAPDRIVERINFO lpCapDriverInfo, LPHKEY phKeyChild) { BOOL fOK = FALSE; HKEY hKeyEnum; int i; *phKeyChild = (HKEY) 0; for (i=0; i < MAXVIDEODRIVERS; i++) { if (RegEnumKey ( hKeyMSVideoRoot, i, lpCapDriverInfo-> szKeyEnumName, sizeof(lpCapDriverInfo->szKeyEnumName)/sizeof(TCHAR)) != ERROR_SUCCESS) break; // Found a subkey, does it match the requested index? if (i == (int) dwDeviceID) { if (RegOpenKey ( hKeyMSVideoRoot, lpCapDriverInfo-> szKeyEnumName, &hKeyEnum) == ERROR_SUCCESS) { *phKeyChild = hKeyEnum; // Found it!!! fOK = TRUE; } break; } } // endof all driver indices return fOK; } // Fetches driver info listed in the registry. // Returns: TRUE if the index was valid, FALSE if no driver at that index // Note: Registry entry ordering is random. BOOL videoRegGetDriverByIndex ( DWORD dwDeviceID, LPCAPDRIVERINFO lpCapDriverInfo) { DWORD dwType; DWORD dwSize; BOOL fOK; HKEY hKeyChild; HKEY hKeyMSVideoRoot; // Always start clean since the entry may be recycled _fmemset (lpCapDriverInfo, 0, sizeof (CAPDRIVERINFO)); if (!(hKeyMSVideoRoot = videoRegOpenMSVideoKey())) return FALSE; if (fOK = videoRegGetKeyByIndex ( hKeyMSVideoRoot, dwDeviceID, lpCapDriverInfo, &hKeyChild)) { // Fetch the values: // Active // Disabled // Description // DEVNODE // Driver // SOFTWAREKEY dwSize = sizeof(BOOL); // Active RegQueryValueEx( hKeyChild, szRegActive, NULL, &dwType, (LPBYTE) &lpCapDriverInfo->fActive, &dwSize); dwSize = sizeof(BOOL); // Enabled RegQueryValueEx( hKeyChild, szRegDisabled, NULL, &dwType, (LPBYTE) &lpCapDriverInfo->fDisabled, &dwSize); // Convert this thing to a bool lpCapDriverInfo->fDisabled = (lpCapDriverInfo->fDisabled == '1'); // DriverDescription dwSize = sizeof (lpCapDriverInfo->szDriverDescription) / sizeof (TCHAR); RegQueryValueEx( hKeyChild, szRegDescription, NULL, &dwType, (LPBYTE) lpCapDriverInfo->szDriverDescription, &dwSize); // DEVNODE dwSize = sizeof(DEVNODE); RegQueryValueEx( hKeyChild, szRegDevNode, NULL, &dwType, (LPBYTE) &lpCapDriverInfo->dnDevNode, &dwSize); // DriverName dwSize = sizeof (lpCapDriverInfo->szDriverName) / sizeof (TCHAR); RegQueryValueEx( hKeyChild, szRegDriver, NULL, &dwType, (LPBYTE) lpCapDriverInfo->szDriverName, &dwSize); // SoftwareKey dwSize = sizeof (lpCapDriverInfo->szSoftwareKey) / sizeof (TCHAR); RegQueryValueEx( hKeyChild, szRegSoftwareKey, NULL, &dwType, (LPBYTE) lpCapDriverInfo->szSoftwareKey, &dwSize); RegCloseKey (hKeyChild); } // if the subkey could be opened RegCloseKey (hKeyMSVideoRoot); return fOK; } // Fetches driver info listed in system.ini // Returns: TRUE if the index was valid, FALSE if no driver at that index BOOL videoIniGetDriverByIndex ( DWORD dwDeviceID, LPCAPDRIVERINFO lpCapDriverInfo) { TCHAR szKey[sizeof(szVideo)/sizeof(TCHAR) + 2]; int w = (int) dwDeviceID; BOOL fOK = FALSE; // Always start clean since the entry may be recycled _fmemset (lpCapDriverInfo, 0, sizeof (CAPDRIVERINFO)); lstrcpy(szKey, szVideo); szKey[(sizeof(szVideo)/sizeof(TCHAR)) - 1] = (TCHAR)0; if( w > 0 ) { szKey[(sizeof(szVideo)/sizeof(TCHAR))] = (TCHAR)0; szKey[(sizeof(szVideo)/sizeof(TCHAR))-1] = (TCHAR) TEXT('1' + (w-1) ); // driver ordinal } if (GetPrivateProfileString(szDrivers, szKey, szNull, lpCapDriverInfo->szDriverName, sizeof(lpCapDriverInfo->szDriverName)/sizeof(TCHAR), szSystemIni)) { // Found an entry at the requested index // The description and version info will be inserted as // requested by the client app. lpCapDriverInfo-> fOnlySystemIni = TRUE; fOK = TRUE; } return fOK; } DWORD videoFreeDriverList (void) { int i; // Free the driver list for (i = 0; i < MAXVIDEODRIVERS; i++) { if (aCapDriverList[i]) GlobalFreePtr (aCapDriverList[i]); aCapDriverList[i] = NULL; } return DV_ERR_OK; } // This function may be called a number of times to create the // current driver array. Since Capscrn assumes it can throw a // driver into system.ini on the fly and have it immediately accessible, // this routine is called on videoGetNumDevs() and when AVICapx.dll // tries to get the driver description and version. // // Drivers in the registry will be the first entries in the list. // // If a driver is listed in the registry AND in system.ini AND // the full path to the drivers match, the system.ini entry will NOT // be in the resulting list. // The variable wTotalVideoDevs is set as a byproduct of this function. // Returns DV_ERR_OK on success, even if no drivers are installed. // DWORD videoCreateDriverList (void) { int i, j, k; wTotalVideoDevs = 0; // Delete the existing list videoFreeDriverList (); // Allocate an array of pointers to all possible capture drivers for (i = 0; i < MAXVIDEODRIVERS; i++) { aCapDriverList[i] = (LPCAPDRIVERINFO) GlobalAllocPtr ( GMEM_MOVEABLE | GMEM_SHARE | GMEM_ZEROINIT, sizeof (CAPDRIVERINFO)); if (aCapDriverList[i] == NULL) return DV_ERR_NOMEM; } // Walk the list of Registry drivers and get each entry for (i = 0; i < MAXVIDEODRIVERS; i++) { if (videoRegGetDriverByIndex ( (DWORD) i, aCapDriverList[wTotalVideoDevs])) { wTotalVideoDevs++; } else break; } if (wTotalVideoDevs == MAXVIDEODRIVERS) goto AllDone; // Now add the entries listed in system.ini, (msvideo[0-9] = driver.drv) // to the driver array, ONLY if the entry doesn't exactly match // an existing registry entry. for (j = 0; j < MAXVIDEODRIVERS; j++) { if (videoIniGetDriverByIndex ((DWORD) j, aCapDriverList[wTotalVideoDevs])) { // Found an entry, now see if it is a duplicate of an existing // registry entry for (k = 0; k < (int) wTotalVideoDevs; k++) { if (lstrcmpi (aCapDriverList[k]->szDriverName, aCapDriverList[wTotalVideoDevs]->szDriverName) == 0) { // Found an exact match, so skip it! goto SkipThisEntry; } } if (wTotalVideoDevs >= MAXVIDEODRIVERS - 1) break; wTotalVideoDevs++; SkipThisEntry: ; } // If sytem.ini entry was found } // For all system.ini possibilities AllDone: // Decrement wTotalVideoDevs for any entries which are marked as disabled // And remove disabled entries from the list for (i = 0; i < MAXVIDEODRIVERS; ) { if (aCapDriverList[i] && aCapDriverList[i]->fDisabled) { GlobalFreePtr (aCapDriverList[i]); // Shift down the remaining drivers for (j = i; j < MAXVIDEODRIVERS - 1; j++) { aCapDriverList[j] = aCapDriverList[j + 1]; } aCapDriverList[MAXVIDEODRIVERS - 1] = NULL; wTotalVideoDevs--; } else i++; } // Free the unused pointers for (i = wTotalVideoDevs; i < MAXVIDEODRIVERS; i++) { if (aCapDriverList[i]) GlobalFreePtr (aCapDriverList[i]); aCapDriverList[i] = NULL; } // Put PnP drivers first in the list // These are the only entries that have a DevNode for (k = i = 0; i < (int) wTotalVideoDevs; i++) { if (aCapDriverList[i]-> dnDevNode) { LPCAPDRIVERINFO lpCDTemp; if (k != i) { // Swap the entries lpCDTemp = aCapDriverList[k]; aCapDriverList[k] = aCapDriverList[i]; aCapDriverList[i] = lpCDTemp; } k++; // Index of first non-PnP driver } } return DV_ERR_OK; } typedef struct tagVS_VERSION { WORD wTotLen; WORD wValLen; char szSig[16]; VS_FIXEDFILEINFO vffInfo; } VS_VERSION; typedef struct tagLANGANDCP { WORD wLanguage; WORD wCodePage; } LANGANDCP; // Extracts the Description string and version info from a driver. // Drivers listed in the registry will typically already include a // description string, but not version info. // Drivers listed in system.ini will fetch both. // // Returns DV_ERR_OK on success, even if no version info was available. // DWORD WINAPI videoGetDriverDescAndVer ( LPCAPDRIVERINFO lpCapDriverInfo) { LPSTR lpVersion; WORD wVersionLen; BOOL bRetCode; DWORD dwVerInfoSize; DWORD dwVerHnd; TCHAR szBuf[MAX_PATH]; BOOL fGetDesc; BOOL fGetVersion; // Only get the description if not already supplied by the registry fGetDesc = (lpCapDriverInfo->szDriverDescription[0] == '\0'); fGetVersion = (lpCapDriverInfo->szDriverVersion[0] == '\0'); if (fGetDesc) lpCapDriverInfo->szDriverDescription[0] = '\0'; if (fGetVersion) lpCapDriverInfo->szDriverVersion [0] = '\0'; // Copy in the driver name initially, just in case the driver // has omitted a description field. if (fGetDesc) lstrcpyn (lpCapDriverInfo->szDriverDescription, lpCapDriverInfo->szDriverName, sizeof (lpCapDriverInfo->szDriverDescription) / sizeof (TCHAR)); // You must find the size first before getting any file info dwVerInfoSize = GetFileVersionInfoSize(lpCapDriverInfo->szDriverName, &dwVerHnd); if (dwVerInfoSize) { LPSTR lpstrVffInfo; // Pointer to block to hold info // Get a block big enough to hold version info if (lpstrVffInfo = GlobalAllocPtr(GMEM_MOVEABLE, dwVerInfoSize)) { // Get the File Version first if(GetFileVersionInfo(lpCapDriverInfo->szDriverName, 0L, dwVerInfoSize, lpstrVffInfo)) { VS_VERSION FAR *pVerInfo = (VS_VERSION FAR *) lpstrVffInfo; // fill in the file version wsprintf(szBuf, "Version: %d.%d.%d.%d", HIWORD(pVerInfo->vffInfo.dwFileVersionMS), LOWORD(pVerInfo->vffInfo.dwFileVersionMS), HIWORD(pVerInfo->vffInfo.dwFileVersionLS), LOWORD(pVerInfo->vffInfo.dwFileVersionLS)); if (fGetVersion) lstrcpyn (lpCapDriverInfo->szDriverVersion, szBuf, sizeof (lpCapDriverInfo->szDriverVersion) / sizeof(TCHAR)); } // Now try to get the FileDescription // First try this for the "Translation" entry, and then // try the American english translation. // Keep track of the string length for easy updating. // 040904E4 represents the language ID and the four // least significant digits represent the codepage for // which the data is formatted. The language ID is // composed of two parts: the low ten bits represent // the major language and the high six bits represent // the sub language. lstrcpy(szBuf, "\\StringFileInfo\\040904E4\\FileDescription"); wVersionLen = 0; lpVersion = NULL; // Look for the corresponding string. bRetCode = VerQueryValue((LPVOID)lpstrVffInfo, (LPSTR)szBuf, (void FAR* FAR*)&lpVersion, (UINT FAR *) &wVersionLen); if (fGetDesc && bRetCode && wVersionLen && lpVersion) lstrcpyn (lpCapDriverInfo->szDriverDescription, lpVersion, sizeof (lpCapDriverInfo->szDriverDescription) / sizeof(TCHAR)); // Let go of the memory GlobalFreePtr(lpstrVffInfo); } else return DV_ERR_NOMEM; } return DV_ERR_OK; } // Called by AVICap and AVICap32 to get driver strings // Returns: // DV_ERR_OK on success // DV_ERR_BADINSTALL if the driver at the specified index is not found DWORD WINAPI videoCapDriverDescAndVer ( DWORD dwDeviceID, LPTSTR lpszDesc, UINT cbDesc, LPTSTR lpszVer, UINT cbVer) { DWORD dwR = DV_ERR_OK; if (lpszDesc && IsBadWritePtr (lpszDesc, cbDesc)) return DV_ERR_NONSPECIFIC; else if (lpszDesc) *lpszDesc = '\0'; if (lpszVer && IsBadWritePtr (lpszVer, cbVer)) return DV_ERR_NONSPECIFIC; else if (lpszVer) *lpszVer = '\0'; if (!wTotalVideoDevs) dwR = videoCreateDriverList (); if (dwR != DV_ERR_OK) return dwR; if ((WORD) dwDeviceID >= wTotalVideoDevs) return DV_ERR_BADDEVICEID; dwR = videoGetDriverDescAndVer (aCapDriverList[(int)dwDeviceID]); if (dwR == DV_ERR_OK) { if (lpszDesc) lstrcpyn (lpszDesc, aCapDriverList[(int)dwDeviceID]->szDriverDescription, cbDesc); if (lpszVer) lstrcpyn (lpszVer, aCapDriverList[(int)dwDeviceID]->szDriverVersion, cbVer); } return (dwR); } /***************************************************************************** * @doc EXTERNAL VIDEO * * @func DWORD | videoMessage | This function sends messages to a * video device channel. * * @parm HVIDEO | hVideo | Specifies the handle to the video device channel. * * @parm UINT | wMsg | Specifies the message to send. * * @parm DWORD | dwP1 | Specifies the first parameter for the message. * * @parm DWORD | dwP2 | Specifies the second parameter for the message. * * @rdesc Returns the message specific value returned from the driver. * * @comm This function is used for configuration messages such as * and , and * device specific messages. * * @xref * ****************************************************************************/ DWORD WINAPI videoMessage(HVIDEO hVideo, UINT msg, DWORD dwP1, DWORD dwP2) { if (!hVideo) return DV_ERR_INVALHANDLE; return SendDriverMessage ((HDRVR)hVideo, msg, dwP1, dwP2); } /***************************************************************************** * @doc EXTERNAL VIDEO * * @api DWORD | videoGetNumDevs | This function returns the number of MSVIDEO * devices installed. * * @rdesc Returns the number of MSVIDEO devices listed in the * [drivers] (or [drivers32] for NT) section of the SYSTEM.INI file * plus drivers listed in the registry. * * @comm Because the indexes of the MSVIDEO devices in the SYSTEM.INI * file can be non-contiguous, applications should not assume * the indexes range between zero and the number of devices minus * one. * * @xref ****************************************************************************/ DWORD WINAPI videoGetNumDevs(void) { if (wTotalVideoDevs) return (DWORD)wTotalVideoDevs; videoCreateDriverList (); return (DWORD)wTotalVideoDevs; } /***************************************************************************** * @doc EXTERNAL VIDEO * * @func DWORD | videoGetErrorText | This function retrieves a * description of the error identified by the error number. * * @parm HVIDEO | hVideo | Specifies a handle to the video device channel. * This might be NULL if the error is not device specific. * * @parm UINT | wError | Specifies the error number. * * @parm LPSTR | lpText | Specifies a far pointer to a buffer used to * return the zero-terminated string corresponding to the error number. * * @parm UINT | wSize | Specifies the length, in bytes, of the buffer * referenced by

. * * @rdesc Returns zero if the function was successful. Otherwise, it returns * an error number. The following error is defined: * @flag DV_ERR_BADERRNUM | Specified error number is out of range. * @flag DV_ERR_SIZEFIELD | The return buffer is not large enough * to handle the error text. * * @comm If the error description is longer than the buffer, * the description is truncated. The returned error string is always * zero-terminated. If

is zero, nothing is copied and zero * is returned. ****************************************************************************/ #if defined _WIN32 // // for WIN32 this is the ansi entry point // DWORD WINAPI videoGetErrorTextA (HVIDEO hVideo, UINT wError, LPSTR lpText, UINT wSize) { VIDEO_GETERRORTEXT_PARMS vet; if (IsBadWritePtr (lpText, wSize)) return DV_ERR_PARAM1; lpText[0] = 0; if (((wError >= DV_ERR_BASE) && (wError <= DV_ERR_LASTERROR))) { if (wSize > 1) { if (!LoadStringA(ghInst, wError, lpText, wSize)) return DV_ERR_BADERRNUM; else return DV_ERR_OK; } else return DV_ERR_SIZEFIELD; } else if (wError >= DV_ERR_USER_MSG && hVideo) { DWORD dwResult; LPWSTR lpwstr = LocalAlloc(LPTR, wSize*sizeof(WCHAR)); if (NULL == lpwstr) { return(DV_ERR_NOMEM); } vet.dwError = (DWORD) wError; vet.lpText = lpwstr; vet.dwLength = (DWORD) wSize; dwResult = videoMessage (hVideo, DVM_GETERRORTEXT, (DWORD) (LPVOID) &vet, (DWORD) NULL); if (DV_ERR_OK == dwResult) { wcstombs(lpText, lpwstr, wSize); } LocalFree(lpwstr); return(dwResult); } else return DV_ERR_BADERRNUM; } #endif // // The unicode/Win16 equivalent of the above // #ifdef _WIN32 DWORD WINAPI videoGetErrorTextW (HVIDEO hVideo, UINT wError, LPWSTR lpText, UINT wSize) #else DWORD WINAPI videoGetErrorText (HVIDEO hVideo, UINT wError, LPSTR lpText, UINT wSize) #endif { VIDEO_GETERRORTEXT_PARMS vet; lpText[0] = 0; if (((wError > DV_ERR_BASE) && (wError <= DV_ERR_LASTERROR))) { if (wSize > 1) { #ifdef _WIN32 LPSTR lpsz = LocalAlloc (LPTR, wSize); UINT cch; if (!lpsz) return DV_ERR_NOMEM; cch = LoadString (ghInst, wError, lpsz, wSize); lpsz[cch] = 0; mbstowcs (lpText, lpsz, cch+1); LocalFree (lpsz); if (!cch) #else if (!LoadString(ghInst, wError, lpText, wSize)) #endif return DV_ERR_BADERRNUM; else return DV_ERR_OK; } else return DV_ERR_SIZEFIELD; } else if (wError >= DV_ERR_USER_MSG && hVideo) { vet.dwError = (DWORD) wError; vet.lpText = lpText; vet.dwLength = wSize; return videoMessage (hVideo, DVM_GETERRORTEXT, (DWORD) (LPVOID) &vet, (DWORD) NULL); } else return DV_ERR_BADERRNUM; } /***************************************************************************** * @doc EXTERNAL VIDEO * * @func DWORD | videoGetChannelCaps | This function retrieves a * description of the capabilities of a channel. * * @parm HVIDEO | hVideo | Specifies a handle to the video device channel. * * @parm LPCHANNEL_CAPS | lpChannelCaps | Specifies a far pointer to a * structure. * * @parm DWORD | dwSize | Specifies the size, in bytes, of the * structure. * * @rdesc Returns zero if the function is successful. Otherwise, it returns * an error number. The following errors are defined: * @flag DV_ERR_INVALHANDLE | Specified device handle is invalid. * @flag DV_ERR_UNSUPPORTED | Function is not supported. * * @comm The structure returns the capability * information. For example, capability information might * include whether or not the channel can crop and scale images, * or show overlay. ****************************************************************************/ DWORD WINAPI videoGetChannelCaps(HVIDEO hVideo, LPCHANNEL_CAPS lpChannelCaps, DWORD dwSize) { if (!hVideo) return DV_ERR_INVALHANDLE; if (IsBadWritePtr (lpChannelCaps, sizeof (CHANNEL_CAPS))) return DV_ERR_PARAM1; // _fmemset (lpChannelCaps, 0, sizeof (CHANNEL_CAPS)); lpChannelCaps->dwFlags = 0; lpChannelCaps->dwSrcRectXMod = 0; lpChannelCaps->dwSrcRectYMod = 0; lpChannelCaps->dwSrcRectWidthMod = 0; lpChannelCaps->dwSrcRectHeightMod = 0; lpChannelCaps->dwDstRectXMod = 0; lpChannelCaps->dwDstRectYMod = 0; lpChannelCaps->dwDstRectWidthMod = 0; lpChannelCaps->dwDstRectHeightMod = 0; return videoMessage(hVideo, DVM_GET_CHANNEL_CAPS, (DWORD) lpChannelCaps, (DWORD) dwSize); } /***************************************************************************** * @doc EXTERNAL VIDEO * * @func DWORD | videoUpdate | This function directs a channel to * repaint the display. It applies only to VIDEO_EXTERNALOUT channels. * * @parm HVIDEO | hVideo | Specifies a handle to the video device channel. * * @parm HWND | hWnd | Specifies the handle of the window to be used * by the channel for image display. * * @parm HDC | hDC | Specifies a handle to a device context. * * @rdesc Returns zero if the function was successful. Otherwise, it returns * an error number. The following errors are defined: * @flag DV_ERR_UNSUPPORTED | Specified message is unsupported. * @flag DV_ERR_INVALHANDLE | Indicates the device handle specified is invalid. * * @comm This message is normally sent * whenever the client window receives a , , * or message. ****************************************************************************/ DWORD WINAPI videoUpdate (HVIDEO hVideo, HWND hWnd, HDC hDC) { if ((!hVideo) || (!hWnd) || (!hDC) ) return DV_ERR_INVALHANDLE; return videoMessage(hVideo, DVM_UPDATE, (DWORD) hWnd, (DWORD) hDC); } /***************************************************************************** * @doc EXTERNAL VIDEO * * @api DWORD | videoOpen | This function opens a channel on the * specified video device. * * @parm LPHVIDEO | lphvideo | Specifies a far pointer to a buffer * used to return an handle. The video capture driver * uses this location to return * a handle that uniquely identifies the opened video device channel. * Use the returned handle to identify the device channel when * calling other video functions. * * @parm DWORD | dwDeviceID | Identifies the video device to open. * The value of

varies from zero to one less * than the number of video capture devices installed in the system. * * @parm DWORD | dwFlags | Specifies flags for opening the device. * The following flags are defined: * * @flag VIDEO_EXTERNALIN| Specifies the channel is opened * for external input. Typically, external input channels * capture images into a frame buffer. * * @flag VIDEO_EXTERNALOUT| Specifies the channel is opened * for external output. Typically, external output channels * display images stored in a frame buffer on an auxilary monitor * or overlay. * * @flag VIDEO_IN| Specifies the channel is opened * for video input. Video input channels transfer images * from a frame buffer to system memory buffers. * * @flag VIDEO_OUT| Specifies the channel is opened * for video output. Video output channels transfer images * from system memory buffers to a frame buffer. * * @rdesc Returns zero if the function was successful. Otherwise, it returns * an error number. The following errors are defined: * @flag DV_ERR_BADDEVICEID | Indicates the specified device ID is out of range. * @flag DV_ERR_ALLOCATED | Indicates the specified resource is already allocated. * @flag DV_ERR_NOMEM | Indicates the device is unable to allocate or lock memory. * * @comm * At a minimum, all capture drivers support a VIDEO_EXTERNALIN * and a VIDEO_IN channel. * Use to determine the number of video * devices present in the system. * * @xref ****************************************************************************/ DWORD WINAPI videoOpen (LPHVIDEO lphVideo, DWORD dwDeviceID, DWORD dwFlags) { UINT w; VIDEO_OPEN_PARMS vop; // Same as IC_OPEN struct!!! DWORD dwVersion = VIDEOAPIVERSION; if (IsBadWritePtr ((LPVOID) lphVideo, sizeof (HVIDEO)) ) return DV_ERR_PARAM1; vop.dwSize = sizeof (VIDEO_OPEN_PARMS); vop.fccType = OPEN_TYPE_VCAP; // "vcap" vop.fccComp = 0L; vop.dwVersion = VIDEOAPIVERSION; vop.dwFlags = dwFlags; // In, Out, External In, External Out vop.dwError = DV_ERR_OK; w = (UINT) dwDeviceID; *lphVideo = NULL; if (!wTotalVideoDevs) // trying to open without finding how many devs. videoGetNumDevs(); if (!wTotalVideoDevs) // No drivers installed return DV_ERR_BADINSTALL; if (w >= wTotalVideoDevs) return DV_ERR_BADDEVICEID; // New for Chicago, drivers are passed a Devnode if PnP at Open time vop.dnDevNode = aCapDriverList[w]->dnDevNode; #ifdef UNICODE *lphVideo = (HVIDEO) OpenDriver(aCapDriverList[w]->szDriverName, NULL, (LPARAM) (LPVOID) &vop); #else #if defined _WIN32 *lphVideo = (HVIDEO) OpenDriverA(aCapDriverList[w]->szDriverName, NULL, (LPARAM) (LPVOID) &vop); #else *lphVideo = (HVIDEO) OpenDriver(aCapDriverList[w]->szDriverName, NULL, (LPARAM) (LPVOID) &vop); #endif #endif if( ! *lphVideo ) { if (vop.dwError) // if driver returned an error code... return vop.dwError; else { #ifdef _WIN32 if (GetFileAttributes(aCapDriverList[w]->szDriverName) == (DWORD) -1) #else OFSTRUCT of; if (OpenFile (aCapDriverList[w]->szDriverName, &of, OF_EXIST) == HFILE_ERROR) #endif return (DV_ERR_BADINSTALL); else return (DV_ERR_NOTDETECTED); } } return DV_ERR_OK; } /***************************************************************************** * @doc EXTERNAL VIDEO * * @api DWORD | videoClose | This function closes the specified video * device channel. * * @parm HVIDEO | hVideo | Specifies a handle to the video device channel. * If this function is successful, the handle is invalid * after this call. * * @rdesc Returns zero if the function was successful. Otherwise, it returns * an error number. The following errors are defined: * @flag DV_ERR_INVALHANDLE | Specified device handle is invalid. * @flag DV_ERR_NONSPECIFIC | The driver failed to close the channel. * * @comm If buffers have been sent with and * they haven't been returned to the application, * the close operation fails. You can use to mark all * pending buffers as done. * * @xref ****************************************************************************/ DWORD WINAPI videoClose (HVIDEO hVideo) { if (!hVideo) return DV_ERR_INVALHANDLE; if (CloseDriver((HDRVR)hVideo, 0L, 0L )) return DV_ERR_OK; return DV_ERR_NONSPECIFIC; } /***************************************************************************** * @doc EXTERNAL VIDEO * * @api DWORD | videoConfigure | This function sets or retrieves * the options for a configurable driver. * * @parm HVIDEO | hVideo | Specifies a handle to the video device channel. * * @parm UINT | msg | Specifies the option to set or retrieve. The * following options are defined: * * @flag DVM_PALETTE | Indicates a palette is being sent to the driver * or retrieved from the driver. * * @flag DVM_PALETTERGB555 | Indicates an RGB555 palette is being * sent to the driver. * * @flag DVM_FORMAT | Indicates format information is being sent to * the driver or retrieved from the driver. * * @parm DWORD | dwFlags | Specifies flags for configuring or * interrogating the device driver. The following flags are defined: * * @flag VIDEO_CONFIGURE_SET | Indicates values are being sent to the driver. * * @flag VIDEO_CONFIGURE_GET | Indicates values are being obtained from the driver. * * @flag VIDEO_CONFIGURE_QUERY | Determines if the * driver supports the option specified by

. This flag * should be combined with either the VIDEO_CONFIGURE_SET or * VIDEO_CONFIGURE_GET flag. If this flag is * set, the

,

,

, and

* parameters are ignored. * * @flag VIDEO_CONFIGURE_QUERYSIZE | Returns the size, in bytes, * of the configuration option in

. This flag is only valid if * the VIDEO_CONFIGURE_GET flag is also set. * * @flag VIDEO_CONFIGURE_CURRENT | Requests the current value. * This flag is valid only if the VIDEO_CONFIGURE_GET flag is also set. * @flag VIDEO_CONFIGURE_NOMINAL | Requests the nominal value. * This flag is valid only if the VIDEO_CONFIGURE_GET flag is also set. * @flag VIDEO_CONFIGURE_MIN | Requests the minimum value. * This flag is valid only if the VIDEO_CONFIGURE_GET flag is also set. * @flag VIDEO_CONFIGURE_MAX | Get the maximum value. * This flag is valid only if the VIDEO_CONFIGURE_GET flag is also set. * * @parm LPDWORD | lpdwReturn | Points to a DWORD used for returning information * from the driver. If * the VIDEO_CONFIGURE_QUERYSIZE flag is set,

is * filled with the size of the configuration option. * * @parm LPVOID | lpData1 |Specifies a pointer to message specific data. * * @parm DWORD | dwSize1 | Specifies the size, in bytes, of the

* buffer. * * @parm LPVOID | lpData2 | Specifies a pointer to message specific data. * * @parm DWORD | dwSize2 | Specifies the size, in bytes, of the

* buffer. * * @rdesc Returns zero if the function was successful. Otherwise, it returns * an error number. The following errors are defined: * @flag DV_ERR_INVALHANDLE | Specified device handle is invalid. * @flag DV_ERR_NOTSUPPORTED | Function is not supported. * * @xref * ****************************************************************************/ DWORD WINAPI videoConfigure (HVIDEO hVideo, UINT msg, DWORD dwFlags, LPDWORD lpdwReturn, LPVOID lpData1, DWORD dwSize1, LPVOID lpData2, DWORD dwSize2) { VIDEOCONFIGPARMS vcp; if (!hVideo) return DV_ERR_INVALHANDLE; if (lpData1) if (IsBadHugeReadPtr (lpData1, dwSize1)) return DV_ERR_CONFIG1; if (lpData2) if (IsBadHugeReadPtr (lpData2, dwSize2)) return DV_ERR_CONFIG2; if (dwFlags & VIDEO_CONFIGURE_QUERYSIZE) { if (!lpdwReturn) return DV_ERR_NONSPECIFIC; if (IsBadWritePtr (lpdwReturn, sizeof (DWORD)) ) return DV_ERR_NONSPECIFIC; } vcp.lpdwReturn = lpdwReturn; vcp.lpData1 = lpData1; vcp.dwSize1 = dwSize1; vcp.lpData2 = lpData2; vcp.dwSize2 = dwSize2; return videoMessage(hVideo, msg, dwFlags, (DWORD)(LPVIDEOCONFIGPARMS)&vcp ); } /***************************************************************************** * @doc EXTERNAL VIDEO * * @api DWORD | videoConfigureStorage | This function saves or loads * all configurable options for a channel. Options * can be saved and recalled for each application or each application * instance. * * @parm HVIDEO | hVideo | Specifies a handle to the video device channel. * * @parm LPSTR | lpstrIdent | Identifies the application or instance. * Use an arbitrary string which uniquely identifies your application * or instance. * * @parm DWORD | dwFlags | Specifies any flags for the function. The following * flags are defined: * @flag VIDEO_CONFIGURE_GET | Requests that the values be loaded. * @flag VIDEO_CONFIGURE_SET | Requests that the values be saved. * * @rdesc Returns zero if the function was successful. Otherwise, it returns * an error number. The following errors are defined: * @flag DV_ERR_INVALHANDLE | Specified device handle is invalid. * @flag DV_ERR_NOTSUPPORTED | Function is not supported. * * @comm The method used by a driver to save configuration options is * device dependent. * * @xref ****************************************************************************/ #if defined _WIN32 // // for win32 this is the ansi entry point // DWORD WINAPI videoConfigureStorageA ( HVIDEO hVideo, LPSTR lpstrIdent, DWORD dwFlags) { DWORD ret; LPWSTR lpwstr; if (!hVideo) return DV_ERR_INVALHANDLE; // Convert the input string to Unicode // Call the driver, free the Unicode string and return the result ret = strlen(lpstrIdent); lpwstr = LocalAlloc(LPTR, ret*sizeof(WCHAR)); if (!lpwstr) { return(DV_ERR_NOMEM); } mbstowcs(lpwstr, lpstrIdent, ret); ret = videoMessage(hVideo, DVM_CONFIGURESTORAGE, (DWORD)lpwstr, dwFlags); LocalFree(lpwstr); return(ret); } #endif // _WIN32 // this code is correct for WIN32 UNICODE and for win16 // messages we send are expected to contain unicode strings. // so send them off... // #ifdef _WIN32 DWORD WINAPI videoConfigureStorageW (HVIDEO hVideo, LPWSTR lpstrIdent, DWORD dwFlags) #else DWORD WINAPI videoConfigureStorage (HVIDEO hVideo, LPSTR lpstrIdent, DWORD dwFlags) #endif { if (!hVideo) return DV_ERR_INVALHANDLE; return videoMessage(hVideo, DVM_CONFIGURESTORAGE, (DWORD)lpstrIdent, dwFlags); } /***************************************************************************** * @doc EXTERNAL VIDEO * * @api DWORD | videoDialog | This function displays a channel-specific * dialog box used to set configuration parameters. * * @parm HVIDEO | hVideo | Specifies a handle to the video device channel. * * @parm HWND | hWndParent | Specifies the parent window handle. * * @parm DWORD | dwFlags | Specifies flags for the dialog box. The * following flag is defined: * @flag VIDEO_DLG_QUERY | If this flag is set, the driver immediately * returns zero if it supplies a dialog box for the channel, * or DV_ERR_NOTSUPPORTED if it does not. * * @rdesc Returns zero if the function was successful. Otherwise, it returns * an error number. The following errors are defined: * @flag DV_ERR_INVALHANDLE | Specified device handle is invalid. * @flag DV_ERR_NOTSUPPORTED | Function is not supported. * * @comm Typically, each dialog box displayed by this * function lets the user select options appropriate for the channel. * For example, a VIDEO_IN channel dialog box lets the user select * the image dimensions and bit depth. * * @xref ****************************************************************************/ DWORD WINAPI videoDialog (HVIDEO hVideo, HWND hWndParent, DWORD dwFlags) { if (!hVideo) return DV_ERR_INVALHANDLE; if ((!hWndParent) || (!IsWindow (hWndParent)) ) return DV_ERR_INVALHANDLE; return videoMessage(hVideo, DVM_DIALOG, (DWORD)hWndParent, dwFlags); } ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// /***************************************************************************** * @doc INTERNAL VIDEO * * @api DWORD | videoPrepareHeader | This function prepares the * header and data * by performing a . * * @rdesc Returns zero if the function was successful. Otherwise, it * specifies an error number. ****************************************************************************/ DWORD WINAPI videoPrepareHeader(LPVIDEOHDR lpVideoHdr, DWORD dwSize) { if (!HugePageLock(lpVideoHdr, (DWORD)sizeof(VIDEOHDR))) return DV_ERR_NOMEM; if (!HugePageLock(lpVideoHdr->lpData, lpVideoHdr->dwBufferLength)) { HugePageUnlock(lpVideoHdr, (DWORD)sizeof(VIDEOHDR)); return DV_ERR_NOMEM; } lpVideoHdr->dwFlags |= VHDR_PREPARED; return DV_ERR_OK; } /***************************************************************************** * @doc INTERNAL VIDEO * * @api DWORD | videoUnprepareHeader | This function unprepares the header and * data if the driver returns DV_ERR_NOTSUPPORTED. * * @rdesc Currently always returns DV_ERR_OK. ****************************************************************************/ DWORD WINAPI videoUnprepareHeader(LPVIDEOHDR lpVideoHdr, DWORD dwSize) { HugePageUnlock(lpVideoHdr->lpData, lpVideoHdr->dwBufferLength); HugePageUnlock(lpVideoHdr, (DWORD)sizeof(VIDEOHDR)); lpVideoHdr->dwFlags &= ~VHDR_PREPARED; return DV_ERR_OK; } ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// /***************************************************************************** * @doc EXTERNAL VIDEO * * @api DWORD | videoStreamAllocHdrAndBuffer | This function is used to allow * drivers to optionally allocate video buffers. Normally, the client * application is responsible for allocating buffer memory, but devices * which have on-board memory may optionally allocate headers and buffers * using this function. Generally, this will avoid an additional data copy, * resulting in faster capture rates. * * @parm HVIDEO | hVideo | Specifies a handle to the video * device channel. * * @parm LPVIDEOHDR FAR * | plpvideoHdr | Specifies a pointer to the address of a * structure. The driver saves the buffer address in this * location, or NULL if it cannot allocate a buffer. * * @parm DWORD | dwSize | Specifies the size of the structure * and associated video buffer in bytes. * * @rdesc Returns zero if the function was successful. Otherwise, it returns * an error number. The following errors are defined: * @flag DV_ERR_INVALHANDLE | Indicates the specified device handle is invalid. * @flag DV_ERR_NOMEM | Indicates the device is unable to allocate or lock memory. * @flag DV_ERR_NOTSUPPORTED | Indicates the driver does not have on-board memory. * * @comm If the driver * allocates buffers via this method, the and * functions must not be used. * * The buffer allocated must be accessible for DMA by the host. * * @xref ****************************************************************************/ DWORD WINAPI videoStreamAllocHdrAndBuffer(HVIDEO hVideo, LPVIDEOHDR FAR * plpvideoHdr, DWORD dwSize) { DWORD wRet; if (!hVideo) return DV_ERR_INVALHANDLE; if (IsBadWritePtr (plpvideoHdr, sizeof (VIDEOHDR *)) ) return DV_ERR_PARAM1; *plpvideoHdr = NULL; // Init to NULL ptr wRet = (DWORD)videoMessage((HVIDEO)hVideo, DVM_STREAM_ALLOCHDRANDBUFFER, (DWORD)plpvideoHdr, (DWORD)dwSize); if (*plpvideoHdr == NULL || IsBadHugeWritePtr (*plpvideoHdr, dwSize)) { DebugErr(DBF_WARNING,"videoStreamAllocHdrAndBuffer: Allocation failed."); *plpvideoHdr = NULL; return wRet; } if (IsVideoHeaderPrepared(HVIDEO, *plpvideoHdr)) { DebugErr(DBF_WARNING,"videoStreamAllocHdrAndBuffer: header is already prepared."); return DV_ERR_OK; } (*plpvideoHdr)->dwFlags = 0; if (wRet == DV_ERR_OK) MarkVideoHeaderPrepared(hVideo, *plpvideoHdr); return wRet; } /***************************************************************************** * @doc EXTERNAL VIDEO * * @api DWORD | videoStreamFreeHdrAndBuffer | This function is used to free * buffers allocated by the driver using the * function. * * @parm HVIDEO | hVideo | Specifies a handle to the video * device channel. * * @parm LPVIDEOHDR | lpvideoHdr | Specifies a pointer to the * structure and associated buffer to be freed. * * @rdesc Returns zero if the function was successful. Otherwise, it returns * an error number. The following errors are defined: * @flag DV_ERR_INVALHANDLE | Indicates the specified device handle is invalid. * @flag DV_ERR_NOTSUPPORTED | Indicates the driver does not have on-board memory. * * @comm If the driver * allocates buffers via this method, the and * functions must not be used. * * @xref ****************************************************************************/ DWORD WINAPI videoStreamFreeHdrAndBuffer(HVIDEO hVideo, LPVIDEOHDR lpvideoHdr) { DWORD wRet; if (!hVideo) return DV_ERR_INVALHANDLE; if (IsBadWritePtr (lpvideoHdr, sizeof (VIDEOHDR)) ) return DV_ERR_PARAM1; if (lpvideoHdr->dwFlags & VHDR_INQUEUE) { DebugErr(DBF_WARNING, "videoStreamFreeHdrAndBuffer: buffer still in queue."); return DV_ERR_STILLPLAYING; } if (!IsVideoHeaderPrepared(hVideo, lpvideoHdr)) { DebugErr(DBF_WARNING,"videoStreamFreeHdrAndBuffer: header is not prepared."); } wRet = (DWORD)videoMessage((HVIDEO)hVideo, DVM_STREAM_FREEHDRANDBUFFER, (DWORD)lpvideoHdr, (DWORD)0); if (wRet != DV_ERR_OK) { DebugErr(DBF_WARNING,"videoStreamFreeHdrAndBuffer: Error freeing buffer."); } return wRet; } /***************************************************************************** * @doc EXTERNAL VIDEO * * @api DWORD | videoStreamPrepareHeader | This function prepares a buffer * for video streaming. * * @parm HVIDEO | hVideo | Specifies a handle to the video * device channel. * * @parm LPVIDEOHDR | lpvideoHdr | Specifies a pointer to a * structure identifying the buffer to be prepared. * * @parm DWORD | dwSize | Specifies the size of the structure in bytes. * * @rdesc Returns zero if the function was successful. Otherwise, it returns * an error number. The following errors are defined: * @flag DV_ERR_INVALHANDLE | Indicates the specified device handle is invalid. * @flag DV_ERR_NOMEM | Indicates the device is unable to allocate or lock memory. * * @comm Use this function after or * after to prepare the data buffers * for streaming data. * * The data structure and the data block pointed to by its * member must be allocated with using the * GMEM_MOVEABLE and GMEM_SHARE flags, and locked with . * Preparing a header that has already been prepared will have no effect * and the function will return zero. Typically, this function is used * to ensure that the buffer will be available for use at interrupt time. * * @xref ****************************************************************************/ DWORD WINAPI videoStreamPrepareHeader(HVIDEO hVideo, LPVIDEOHDR lpvideoHdr, DWORD dwSize) { DWORD wRet; if (!hVideo) return DV_ERR_INVALHANDLE; if (IsBadWritePtr (lpvideoHdr, sizeof (VIDEOHDR)) ) return DV_ERR_PARAM1; if (IsVideoHeaderPrepared(HVIDEO, lpvideoHdr)) { DebugErr(DBF_WARNING,"videoStreamPrepareHeader: header is already prepared."); return DV_ERR_OK; } lpvideoHdr->dwFlags = 0; wRet = (DWORD)videoMessage((HVIDEO)hVideo, DVM_STREAM_PREPAREHEADER, (DWORD)lpvideoHdr, (DWORD)dwSize); if (wRet == DV_ERR_NOTSUPPORTED) wRet = videoPrepareHeader(lpvideoHdr, dwSize); if (wRet == DV_ERR_OK) MarkVideoHeaderPrepared(hVideo, lpvideoHdr); return wRet; } /***************************************************************************** * @doc EXTERNAL VIDEO * * @api DWORD | videoStreamUnprepareHeader | This function clears the * preparation performed by . * * @parm HVIDEO | hVideo | Specifies a handle to the video * device channel. * * @parm LPVIDEOHDR | lpvideoHdr | Specifies a pointer to a * structure identifying the data buffer to be unprepared. * * @parm DWORD | dwSize | Specifies the size of the structure in bytes. * * @rdesc Returns zero if the function was successful. Otherwise, it returns * an error number. The following errors are defined: * @flag DV_ERR_INVALHANDLE | Indicates the device handle specified is invalid. * @flag DV_ERR_STILLPLAYING | Indicates the structure identified by

* is still in the queue. * * @comm This function is the complementary function to . * You must call this function before freeing the data buffer with . * After passing a buffer to the device driver with , you * must wait until the driver is finished with the buffer before calling * . Unpreparing a buffer that has not been * prepared or has been already unprepared has no effect, * and the function returns zero. * * @xref ****************************************************************************/ DWORD WINAPI videoStreamUnprepareHeader(HVIDEO hVideo, LPVIDEOHDR lpvideoHdr, DWORD dwSize) { DWORD wRet; if (!hVideo) return DV_ERR_INVALHANDLE; if (IsBadWritePtr (lpvideoHdr, sizeof (VIDEOHDR)) ) return DV_ERR_PARAM1; if (lpvideoHdr->dwFlags & VHDR_INQUEUE) { DebugErr(DBF_WARNING, "videoStreamUnprepareHeader: buffer still in queue."); return DV_ERR_STILLPLAYING; } if (!IsVideoHeaderPrepared(hVideo, lpvideoHdr)) { DebugErr(DBF_WARNING,"videoStreamUnprepareHeader: header is not prepared."); return DV_ERR_OK; } wRet = (DWORD)videoMessage((HVIDEO)hVideo, DVM_STREAM_UNPREPAREHEADER, (DWORD)lpvideoHdr, (DWORD)dwSize); if (wRet == DV_ERR_NOTSUPPORTED) wRet = videoUnprepareHeader(lpvideoHdr, dwSize); if (wRet == DV_ERR_OK) MarkVideoHeaderUnprepared(hVideo, lpvideoHdr); return wRet; } /***************************************************************************** * @doc EXTERNAL VIDEO * * @api DWORD | videoStreamAddBuffer | This function sends a buffer to a * video-capture device. After the buffer is filled by the device, * the device sends it back to the application. * * @parm HVIDEO | hVideo | Specifies a handle to the video device channel. * * @parm LPVIDEOHDR | lpvideoHdr | Specifies a far pointer to a * structure that identifies the buffer. * * @parm DWORD | dwSize | Specifies the size of the structure in bytes. * * @rdesc Returns zero if the function was successful. Otherwise, it returns * an error number. The following errors are defined: * @flag DV_ERR_INVALHANDLE | Indicates the device handle specified is invalid. * @flag DV_ERR_UNPREPARED | Indicates the

structure hasn't been prepared. * @flag DV_ERR_STILLPLAYING | Indicates a buffer is still in the queue. * @flag DV_ERR_PARAM1 | The

parameter is invalid or * the member of the * structure is not set to the proper value. * * @comm The data buffer must be prepared with * before it is passed to . The data * structure and the data buffer referenced by its * member must be allocated with using the GMEM_MOVEABLE * and GMEM_SHARE flags, and locked with . Set the * member to the size of the header. * * @xref ****************************************************************************/ DWORD WINAPI videoStreamAddBuffer(HVIDEO hVideo, LPVIDEOHDR lpvideoHdr, DWORD dwSize) { if (!hVideo) return DV_ERR_INVALHANDLE; if (IsBadWritePtr (lpvideoHdr, sizeof (VIDEOHDR)) ) return DV_ERR_PARAM1; if (!IsVideoHeaderPrepared(hVideo, lpvideoHdr)) { DebugErr(DBF_WARNING, "videoStreamAddBuffer: buffer not prepared."); return DV_ERR_UNPREPARED; } if (lpvideoHdr->dwFlags & VHDR_INQUEUE) { DebugErr(DBF_WARNING, "videoStreamAddBuffer: buffer already in queue."); return DV_ERR_STILLPLAYING; } return (DWORD)videoMessage((HVIDEO)hVideo, DVM_STREAM_ADDBUFFER, (DWORD)lpvideoHdr, (DWORD)dwSize); } /***************************************************************************** * @doc EXTERNAL VIDEO * * @api DWORD | videoStreamStop | This function stops streaming on a video channel. * * @parm HVIDEO | hVideo | Specifies a handle to the video * device channel. * * @rdesc Returns zero if the function was successful. Otherwise, it returns * an error number. The following error is defined: * @flag DV_ERR_INVALHANDLE | Indicates the specified device handle is invalid. * * @flag DV_ERR_NOTSUPPORTED | Indicates the device does not support this * function. * @comm If there are any buffers in the queue, the current buffer will be * marked as done (the member in * the header will contain the actual length of data), but any * empty buffers in the queue will remain there. Calling this * function when the channel is not started has no effect, and the * function returns zero. * * @xref ****************************************************************************/ DWORD WINAPI videoStreamStop(HVIDEO hVideo) { if (!hVideo) return DV_ERR_INVALHANDLE; return videoMessage((HVIDEO)hVideo, DVM_STREAM_STOP, 0L, 0L); } /***************************************************************************** * @doc EXTERNAL VIDEO * * @api DWORD | videoStreamReset | This function stops streaming * on the specified video device channel and resets the current position * to zero. All pending buffers are marked as done and * are returned to the application. * * @parm HVIDEO | hVideo | Specifies a handle to the video device channel. * * @rdesc Returns zero if the function was successful. Otherwise, it returns * an error number. The following errors are defined: * * @flag DV_ERR_INVALHANDLE | Indicates the device handle specified is invalid. * * @flag DV_ERR_NOTSUPPORTED | Indicates the device does not support this * function. * * @xref /****************************************************************************/ DWORD WINAPI videoStreamReset(HVIDEO hVideo) { if (!hVideo) return DV_ERR_INVALHANDLE; return videoMessage((HVIDEO)hVideo, DVM_STREAM_RESET, 0L, 0L); } /***************************************************************************** * @doc EXTERNAL VIDEO * * @api DWORD | videoStreamGetPosition | This function retrieves the current * position of the specified video device channel. * * @parm HVIDEO | hVideo | Specifies a handle to the video device channel. * * @parm LPMMTIME | lpInfo | Specifies a far pointer to an * structure. * * @parm DWORD | dwSize | Specifies the size of the structure in bytes. * * @rdesc Returns zero if the function was successful. Otherwise, it returns * an error number. The following errors are defined: * * @flag DV_ERR_INVALHANDLE | Indicates the specified device handle is invalid. * * @comm Before using , set the * member of the structure to indicate * the time format desired. After * returns, check the * member to determine if the your time format is supported. If * not, specifies an alternate format. * Video capture drivers typically provide the millisecond time * format. * * The position is set to zero when streaming is started with * . ****************************************************************************/ DWORD WINAPI videoStreamGetPosition(HVIDEO hVideo, LPMMTIME lpInfo, DWORD dwSize) { if (!hVideo) return DV_ERR_INVALHANDLE; if (IsBadWritePtr (lpInfo, sizeof (MMTIME)) ) return DV_ERR_PARAM1; return videoMessage(hVideo, DVM_STREAM_GETPOSITION, (DWORD)lpInfo, (DWORD)dwSize); } // ============================================ /***************************************************************************** * @doc EXTERNAL VIDEO * * @api DWORD | videoStreamInit | This function initializes a video * device channel for streaming. * * @parm HVIDEO | hVideo | Specifies a handle to the video device channel. * * @parm DWORD | dwMicroSecPerFrame | Specifies the number of microseconds * between frames. * * @parm DWORD | dwCallback | Specifies the address of a callback * function or a handle to a window called during video * streaming. The callback function or window processes * messages related to the progress of streaming. * * @parm DWORD | dwCallbackInstance | Specifies user * instance data passed to the callback function. This parameter is not * used with window callbacks. * * @parm DWORD | dwFlags | Specifies flags for opening the device channel. * The following flags are defined: * @flag CALLBACK_WINDOW | If this flag is specified,

is * a window handle. * @flag CALLBACK_FUNCTION | If this flag is specified,

is * a callback procedure address. * * @rdesc Returns zero if the function was successful. Otherwise, it returns * an error number. The following errors are defined: * @flag DV_ERR_BADDEVICEID | Indicates the device ID specified in *

is not valid. * @flag DV_ERR_ALLOCATED | Indicates the resource specified is already allocated. * @flag DV_ERR_NOMEM | Indicates the device is unable to allocate or lock memory. * * @comm If a window or function is chosen to receive callback information, the following * messages are sent to it to indicate the * progress of video input: * * is sent at the time of * * is sent at the time of * * is sent when a buffer of image data is available * * is sent when an error occurs * * Callback functions must reside in a DLL. * You do not have to use to get * a procedure-instance address for the callback function. * * @cb void CALLBACK | videoFunc | is a placeholder for an * application-supplied function name. The actual name must be exported by * including it in an EXPORTS statement in the DLL's module-definition file. * This is used only when a callback function is specified in * . * * @parm HVIDEO | hVideo | Specifies a handle to the video device channel * associated with the callback. * * @parm DWORD | wMsg | Specifies the messages. Messages indicate * errors and when image data is available. For information on * these messages, see . * * @parm DWORD | dwInstance | Specifies the user instance * data specified with . * * @parm DWORD | dwParam1 | Specifies a parameter for the message. * * @parm DWORD | dwParam2 | Specifies a parameter for the message. * * @comm Because the callback is accessed at interrupt time, it must reside * in a DLL and its code segment must be specified as FIXED in the * module-definition file for the DLL. Any data the callback accesses * must be in a FIXED data segment as well. The callback may not make any * system calls except for , , * , , , * , , and . * * @xref ****************************************************************************/ DWORD WINAPI videoStreamInit(HVIDEO hVideo, DWORD dwMicroSecPerFrame, DWORD_PTR dwCallback, DWORD_PTR dwCallbackInst, DWORD dwFlags) { VIDEO_STREAM_INIT_PARMS vsip; if (!hVideo) return DV_ERR_INVALHANDLE; if (dwCallback && ((dwFlags & CALLBACK_TYPEMASK) == CALLBACK_FUNCTION) ) { if (IsBadCodePtr ((FARPROC) dwCallback) ) return DV_ERR_PARAM2; if (!dwCallbackInst) return DV_ERR_PARAM2; } if (dwCallback && ((dwFlags & CALLBACK_TYPEMASK) == CALLBACK_WINDOW) ) { if (!IsWindow((HWND) dwCallback) ) return DV_ERR_PARAM2; } vsip.dwMicroSecPerFrame = dwMicroSecPerFrame; vsip.dwCallback = dwCallback; vsip.dwCallbackInst = dwCallbackInst; vsip.dwFlags = dwFlags; vsip.hVideo = (DWORD_PTR)hVideo; return videoMessage(hVideo, DVM_STREAM_INIT, (DWORD_PTR) (LPVIDEO_STREAM_INIT_PARMS) &vsip, (DWORD) sizeof (VIDEO_STREAM_INIT_PARMS)); } /***************************************************************************** * @doc EXTERNAL VIDEO * * @api DWORD | videoStreamFini | This function terminates streaming * from the specified device channel. * * @parm HVIDEO | hVideo | Specifies a handle to the video device channel. * * @rdesc Returns zero if the function was successful. Otherwise, it returns * an error number. The following errors are defined: * @flag DV_ERR_INVALHANDLE | Indicates the device handle specified is invalid. * @flag DV_ERR_STILLPLAYING | Indicates there are still buffers in the queue. * * @comm If there are buffers that have been sent with * that haven't been returned to the application, * this operation will fail. Use to return all * pending buffers. * * Each call to must be matched with a call to * . * * For VIDEO_EXTERNALIN channels, this function is used to * halt capturing of data to the frame buffer. * * For VIDEO_EXTERNALOUT channels supporting overlay, * this function is used to disable the overlay. * * @xref ****************************************************************************/ DWORD WINAPI videoStreamFini(HVIDEO hVideo) { if (!hVideo) return DV_ERR_INVALHANDLE; return videoMessage(hVideo, DVM_STREAM_FINI, 0L, 0L); } /***************************************************************************** * @doc EXTERNAL VIDEO * * @api DWORD | videoStreamStart | This function starts streaming on the * specified video device channel. * * @parm HVIDEO | hVideo | Specifies a handle to the video device channel. * * @rdesc Returns zero if the function was successful. Otherwise, it returns * an error number. The following errors are defined: * @flag DV_ERR_INVALHANDLE | Indicates the device handle specified is invalid. * * @flag DV_ERR_NOTSUPPORTED | Indicates the device does not support this * function. * * @xref /****************************************************************************/ DWORD WINAPI videoStreamStart(HVIDEO hVideo) { if (!hVideo) return DV_ERR_INVALHANDLE; return videoMessage(hVideo, DVM_STREAM_START, 0L, 0L); } /***************************************************************************** * @doc EXTERNAL VIDEO * * @api DWORD | videoStreamGetError | This function returns the error * most recently encountered. * * @parm HVIDEO | hVideo | Specifies a handle to the video device channel. * * @parm LPDWORD | lpdwErrorID | Specifies a far pointer to the * used to return the error ID. * * @parm LPDWORD | lpdwErrorValue | Specifies a far pointer to the * used to return the number of frames skipped. * * @rdesc Returns zero if the function was successful. Otherwise, it returns * an error number. The following error is defined: * @flag DV_ERR_INVALHANDLE | Indicates the device handle specified is invalid. * * @comm While streaming video data, a capture * driver can fill buffers faster than the client application can * save the buffers to disk. In this case, the * DV_ERR_NO_BUFFERS error is returned in

* and

contains a count of the number of * frames missed. After * receiving this message and returning the error status, a driver * should reset its internal error flag to DV_ERR_OK and * the count of missed frames to zero. * * Applications should send this message frequently during capture * since some drivers which do not have access to interrupts use * this message to trigger buffer processing. * * @xref /****************************************************************************/ DWORD WINAPI videoStreamGetError(HVIDEO hVideo, LPDWORD lpdwError, LPDWORD lpdwFramesSkipped) { if (!hVideo) return DV_ERR_INVALHANDLE; if (IsBadWritePtr (lpdwError, sizeof (DWORD)) ) return DV_ERR_PARAM1; if (IsBadWritePtr (lpdwFramesSkipped, sizeof (DWORD)) ) return DV_ERR_PARAM2; return videoMessage(hVideo, DVM_STREAM_GETERROR, (DWORD) lpdwError, (DWORD) lpdwFramesSkipped); } /***************************************************************************** * @doc EXTERNAL VIDEO * * @api DWORD | videoFrame | This function transfers a single frame * to or from a video device channel. * * @parm HVIDEO | hVideo | Specifies a handle to the video device channel. * The channel must be of type VIDEO_IN or VIDEO_OUT. * * @parm LPVIDEOHDR | lpVHdr | Specifies a far pointer to an * structure. * * @rdesc Returns zero if the function was successful. Otherwise, it returns * an error number. The following errors are defined: * @flag DV_ERR_INVALHANDLE | Specified device handle is invalid. * @flag DV_ERR_PARAM1 | The

parameter is invalid or * the member of the * structure is not set to the proper value. * * @comm Use this function with a VIDEO_IN channel to transfer a single * image from the frame buffer. * Use this function with a VIDEO_OUT channel to transfer a single * image to the frame buffer. * * @xref /****************************************************************************/ DWORD WINAPI videoFrame (HVIDEO hVideo, LPVIDEOHDR lpVHdr) { if (!hVideo) return DV_ERR_INVALHANDLE; if (!lpVHdr) return DV_ERR_PARAM1; if (IsBadWritePtr (lpVHdr, sizeof (VIDEOHDR)) ) return DV_ERR_PARAM1; return videoMessage(hVideo, DVM_FRAME, (DWORD) lpVHdr, sizeof(VIDEOHDR)); } #endif // ifdef WIN16 /************************************************************************** * @doc INTERNAL VIDEO * * @api void | videoCleanup | clean up video stuff * called in MSVIDEOs WEP() * **************************************************************************/ void FAR PASCAL videoCleanup(HTASK hTask) { #ifdef WIN16 videoFreeDriverList(); #endif }