OS_Develop/Windows-Server-2003
OS_Develop/Windows-Server-2003
1
0
Fork 0
Code Pull Requests Activity
7507d3c0e1
Windows-Server-2003/multimedia/media/avi/avicap.io/video.c

2115 lines
71 KiB
C
Raw Normal View History

Initiall commit
2024-08-04 01:28:15 +02:00
/****************************************************************************
video.c
Contains video APIs
Copyright (c) Microsoft Corporation 1992 - 1995. All rights reserved.
****************************************************************************/
#include <windows.h>
#include <mmsystem.h>
#include "win32.h"
#include "msviddrv.h"
#include <vfw.h>
#include <ivideo32.h>
#include "msvideoi.h"
#ifdef DEBUG
extern void FAR CDECL dprintf(LPSTR, ...);
#else
#define dprintf ; / ## /
#endif
#ifdef WIN32
#include <mmddk.h>
#include <stdlib.h>
#endif
/*****************************************************************************
* Variables
*
****************************************************************************/
SZCODE szNull[] = TEXT("");
SZCODE szVideo[] = TEXT("msvideo");
#ifndef WIN32
SZCODE szDrivers[] = "Drivers";
#else
STATICDT SZCODE szDrivers[] = DRIVERS_SECTION;
#endif
SZCODE szDriversDescRegKey[] = TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion\\drivers.desc");
STATICDT SZCODE szSystemIni[] = TEXT("system.ini");
UINT wTotalVideoDevs; // total video devices
extern HINSTANCE ghInstDll; // our module handle
// -----------------------------------------------------------
// If the following structure changes, update AVICAP and AVICAP.32 also!!!
typedef struct tCapDriverInfo {
TCHAR szKeyEnumName[MAX_PATH];
TCHAR szDriverName[MAX_PATH];
TCHAR szDriverDescription[MAX_PATH];
TCHAR szDriverVersion[80];
TCHAR szSoftwareKey[MAX_PATH];
DWORD dnDevNode; // Set if this is a PnP device
BOOL fOnlySystemIni; // If the [path]drivername is only in system.ini
BOOL fDisabled; // User has disabled driver in the control panel
BOOL fActive; // Reserved
} CAPDRIVERINFO, FAR *LPCAPDRIVERINFO;
#ifndef DEVNODE
typedef DWORD DEVNODE; // Devnode.
#endif
#ifndef LPHKEY
typedef HKEY FAR * LPHKEY;
#endif
// 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");
LPCAPDRIVERINFO aCapDriverList[MAXVIDEODRIVERS]; // Array of all capture drivers
/*****************************************************************************
* @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 <p dwDeviceID> 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 <t DEVNODE> 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 <t BOOL> 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 <p dwDeviceID> 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
}
// Only get its driver name
if (GetPrivateProfileString(szDrivers, szKey, szNull,
lpCapDriverInfo->szDriverName,
sizeof(lpCapDriverInfo->szDriverName)/sizeof(TCHAR),
szSystemIni)) {
HKEY hKey = NULL;
DWORD dwSize, dwType;
// Get the key if it already exists
// Get Drivers.Desc from its Drivers32 driver name
if (ERROR_SUCCESS == RegOpenKey (
HKEY_LOCAL_MACHINE,
szDriversDescRegKey,
&hKey) != ERROR_SUCCESS) {
// DriverDescription
dwSize = sizeof (lpCapDriverInfo->szDriverDescription) / sizeof (TCHAR);
// [drivers.desc]
// DriverName = DriverDescription
dwType = REG_SZ;
RegQueryValueEx(
hKey,
lpCapDriverInfo->szDriverName,
NULL,
&dwType,
(LPBYTE) lpCapDriverInfo->szDriverDescription,
&dwSize);
RegCloseKey (hKey);
} else {
dprintf("videoIniGetDriverByIndex: RegOpenKey of Drivers.Desc failed !!\n");
}
// 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;
}
wTotalVideoDevs = 0;
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;
// 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) {
videoFreeDriverList ();
return DV_ERR_NOMEM;
}
}
// Walk the list of Registry drivers and get each entry
// Get VFW drivers from MediaResource\MsVideo
for (i = 0; i < MAXVIDEODRIVERS; i++) {
if (videoRegGetDriverByIndex (
(DWORD) i, aCapDriverList[wTotalVideoDevs])) {
dprintf("MediaResource: idx %d, DriverName %x, Desc %x\n", wTotalVideoDevs, aCapDriverList[wTotalVideoDevs]->szDriverName, aCapDriverList[wTotalVideoDevs]->szDriverDescription);
wTotalVideoDevs++;
}
else
break;
}
if (wTotalVideoDevs == MAXVIDEODRIVERS)
goto AllDone;
// Now add the entries listed in system.ini, [Drivers#2] section, (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++) {
// Get driver name such as *.dll
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;
dprintf("Drivers32: idx %d, DriverName %x\n", wTotalVideoDevs, aCapDriverList[wTotalVideoDevs]->szDriverName);
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
}
}
dprintf("videoCreateDriverList: DeviceList contains %d Video Device(s).\n", wTotalVideoDevs);
return DV_ERR_OK;
}
// ----------------------------------------------------------------------
//
// To clean up when a WOW app exits, we need to maintain a list of
// open devices. A list of HANDLEINFO structs is hung off g_pHandles.
// An item is added to the head of this list in videoOpen, and removed
// in videoClose. When a WOW app exits, winmm will call our WOWAppExit
// function: for each entry in the list that is owned by the exiting thread,
// we call videoClose to close the device and remove the handle entry.
//
// one of these per open handle
typedef struct _HANDLEINFO {
HVIDEO hv;
HANDLE hThread;
struct _HANDLEINFO * pNext;
} HANDLEINFO, * PHANDLEINFO;
// head of global list of open handles
PHANDLEINFO g_pHandles;
// critical section that protects global list
CRITICAL_SECTION csHandles;
// init list and critsec
void
videoInitHandleList()
{
g_pHandles = NULL;
InitializeCriticalSection(&csHandles);
}
// finished with critsec list
void
videoDeleteHandleList()
{
// don't need critical section as no-one else can be using
// it now (we are about to delete the critsec)
// empty everything out of the list
while (g_pHandles) {
videoClose(g_pHandles->hv);
}
DeleteCriticalSection(&csHandles);
}
// add a handle to the list
void
videoAddHandle(HVIDEO hv)
{
PHANDLEINFO pinfo = HeapAlloc(GetProcessHeap(), 0, sizeof(HANDLEINFO));
if (!pinfo) {
// couldn't allocate the memory - best thing to do is
// forget it - nothing bad will happen except that we
// might possibly fail to clean up if this is a wow app and
// it exits without closing the capture device.
return;
}
pinfo->hv = hv;
pinfo->hThread = GetCurrentTask();
EnterCriticalSection(&csHandles);
pinfo->pNext = g_pHandles;
g_pHandles = pinfo;
LeaveCriticalSection(&csHandles);
}
// delete an entry from the handle list given the HVIDEO.
// caller must close the HVIDEO
// should be called before closing (in case the HVIDEO is reassigned after
// closing and before removing from the list
void
videoDelete(HVIDEO hv)
{
PHANDLEINFO * ppNext;
PHANDLEINFO pinfo;
EnterCriticalSection(&csHandles);
ppNext = &g_pHandles;
while (*ppNext) {
if ((*ppNext)->hv == hv) {
pinfo = *ppNext;
*ppNext = pinfo->pNext;
HeapFree(GetProcessHeap(), 0, pinfo);
break;
} else {
ppNext = &(*ppNext)->pNext;
}
}
LeaveCriticalSection(&csHandles);
}
// close any handles open by this task
void
AppCleanup(HANDLE hTask)
{
PHANDLEINFO pinfo;
EnterCriticalSection(&csHandles);
pinfo = g_pHandles;
while (pinfo) {
if (pinfo->hThread == hTask) {
// get the next pointer before videoClose deletes the entry
HVIDEO hv = pinfo->hv;
pinfo = pinfo->pNext;
videoClose(hv);
} else {
pinfo = pinfo->pNext;
}
}
LeaveCriticalSection(&csHandles);
}
// ----------------------------------------------------------------------
/*****************************************************************************
* @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 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
* <m DVM_SRC_RECT> and <m DVM_DST_RECT>, and
* device specific messages.
*
* @xref <f videoConfigure>
*
****************************************************************************/
LRESULT WINAPI videoMessage(HVIDEO hVideo, UINT msg, LPARAM dwP1, LPARAM 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.
*
* @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 <f videoOpen>
****************************************************************************/
DWORD WINAPI videoGetNumDevs(void)
{
DWORD dwNumDevs = 0;
if(DV_ERR_OK == videoCreateDriverList ()) {
dwNumDevs = wTotalVideoDevs; // Save it before reseting to 0 in videoFreeDriverList.
videoFreeDriverList ();
}
return dwNumDevs;
}
/*****************************************************************************
* @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 <p lpText>.
*
* @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 <p wSize> is zero, nothing is copied and zero
* is returned.
****************************************************************************/
#ifdef UNICODE // Translate UNICODE response to ansi
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(ghInstDll, 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 = (DWORD) videoMessage (hVideo, DVM_GETERRORTEXT, (DWORD_PTR) (LPVOID) &vet,
(DWORD_PTR) NULL);
if (DV_ERR_OK == dwResult) {
Iwcstombs(lpText, lpwstr, wSize);
}
LocalFree(lpwstr);
return(dwResult);
}
else
return DV_ERR_BADERRNUM;
}
#endif //UNICODE
//
// The unicode/Win16 equivalent of the above
//
DWORD WINAPI videoGetErrorText(HVIDEO hVideo, UINT wError,
LPTSTR lpText, UINT wSize)
{
VIDEO_GETERRORTEXT_PARMS vet;
lpText[0] = 0;
if (((wError > DV_ERR_BASE) && (wError <= DV_ERR_LASTERROR))) {
if (wSize > 1) {
if (!LoadString(ghInstDll, 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) {
vet.dwError = (DWORD) wError;
vet.lpText = lpText;
vet.dwLength = (DWORD) wSize;
return (DWORD) videoMessage (hVideo, DVM_GETERRORTEXT, (DWORD_PTR) (LPVOID) &vet,
(DWORD_PTR) 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
* <t CHANNEL_CAPS> structure.
*
* @parm DWORD | dwSize | Specifies the size, in bytes, of the
* <t CHANNEL_CAPS> 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 <t CHANNEL_CAPS> 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 (DWORD) videoMessage(hVideo, DVM_GET_CHANNEL_CAPS, (DWORD_PTR) lpChannelCaps,
(DWORD_PTR) 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 <m WM_MOVE>, <m WM_SIZE>,
* or <m WM_PAINT> message.
****************************************************************************/
DWORD WINAPI videoUpdate (HVIDEO hVideo, HWND hWnd, HDC hDC)
{
if ((!hVideo) || (!hWnd) || (!hDC) )
return DV_ERR_INVALHANDLE;
return (DWORD) videoMessage(hVideo, DVM_UPDATE, (DWORD_PTR) hWnd, (DWORD_PTR) 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 <t HVIDEO> 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 <p dwDeviceID> 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 <f videoGetNumDevs> to determine the number of video
* devices present in the system.
*
* @xref <f videoClose>
****************************************************************************/
DWORD WINAPI videoOpen (LPHVIDEO lphVideo, DWORD dwDeviceID, DWORD dwFlags)
{
TCHAR szKey[MAX_PATH];
TCHAR szbuf[MAX_PATH];
UINT w;
VIDEO_OPEN_PARMS vop; // Same as IC_OPEN struct!!!
DWORD dwVersion = VIDEOAPIVERSION;
DWORD dwErr;
DWORD dwNumDevs = 0;
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;
dwNumDevs = videoGetNumDevs();
// No drivers installed
if (dwNumDevs == 0)
return DV_ERR_BADINSTALL;
if (w >= MAXVIDEODRIVERS)
return DV_ERR_BADDEVICEID;
dwErr = videoCreateDriverList ();
if(DV_ERR_OK != dwErr)
return dwErr;
if(w < dwNumDevs) {
lstrcpyn(szKey, aCapDriverList[w]->szDriverName, MAX_PATH);
lstrcpyn(szbuf, aCapDriverList[w]->szDriverName, MAX_PATH);
videoFreeDriverList ();
dprintf("szKey %x, szDrivers %x, szbuf %x\n", szKey, szDrivers, szbuf);
#ifdef THIS_IS_ANCIENT_CODE
// Removed for VFW1.1
// Only early Alpha 1.0 drivers required this...
// Check driver version number by doing a configuration open...
// Version 1 used LPARAM = dwFlags
// Version 2 uses LPARAM = LPVIDEO_OPEN_PARMS
if (hVideoTemp = OpenDriver(szKey, szDrivers, (LPARAM) NULL)) {
HVIDEO hVideoTemp;
// Version 1 drivers had the added bug of returning
// the version from this message, instead of in
// lParam1
if (videoMessage (hVideoTemp, DVM_GETVIDEOAPIVER,
(LPARAM) (LPVOID) &dwVersion, 0L) == 1)
dwVersion = 1;
CloseDriver(hVideoTemp, 0L, 0L );
}
if (dwVersion == 1)
*lphVideo = OpenDriver(szKey, szDrivers, dwFlags);
else
#endif // THIS_IS_ANCIENT_CODE
*lphVideo = (HVIDEO)OpenDriver(szKey, szDrivers, (LPARAM) (LPVOID) &vop);
if( ! *lphVideo ) {
if (vop.dwError) // if driver returned an error code...
return vop.dwError;
else {
#ifdef WIN32
if (GetFileAttributes(szbuf) == (DWORD) -1)
#else
OFSTRUCT of;
if (OpenFile (szbuf, &of, OF_EXIST) == HFILE_ERROR)
#endif
return (DV_ERR_BADINSTALL);
else
return (DV_ERR_NOTDETECTED);
}
}
} else {
videoFreeDriverList ();
return( DV_ERR_BADINSTALL );
}
videoAddHandle(*lphVideo);
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 <f videoStreamAddBuffer> and
* they haven't been returned to the application,
* the close operation fails. You can use <f videoStreamReset> to mark all
* pending buffers as done.
*
* @xref <f videoOpen> <f videoStreamInit> <f videoStreamFini> <f videoStreamReset>
****************************************************************************/
DWORD WINAPI videoClose (HVIDEO hVideo)
{
if (!hVideo)
return DV_ERR_INVALHANDLE;
videoDelete(hVideo);
return (CloseDriver((HDRVR)hVideo, 0L, 0L ) ? DV_ERR_OK : 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 <p msg>. This flag
* should be combined with either the VIDEO_CONFIGURE_SET or
* VIDEO_CONFIGURE_GET flag. If this flag is
* set, the <p lpData1>, <p dwSize1>, <p lpData2>, and <p dwSize2>
* parameters are ignored.
*
* @flag VIDEO_CONFIGURE_QUERYSIZE | Returns the size, in bytes,
* of the configuration option in <p lpdwReturn>. 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, <p lpdwReturn> 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 <p lpData1>
* buffer.
*
* @parm LPVOID | lpData2 | Specifies a pointer to message specific data.
*
* @parm DWORD | dwSize2 | Specifies the size, in bytes, of the <p lpData2>
* 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 <f videoOpen> <f videoMessage>
*
****************************************************************************/
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 (*lpdwReturn)) )
return DV_ERR_NONSPECIFIC;
}
vcp.lpdwReturn = lpdwReturn;
vcp.lpData1 = lpData1;
vcp.dwSize1 = dwSize1;
vcp.lpData2 = lpData2;
vcp.dwSize2 = dwSize2;
return (DWORD) videoMessage(hVideo, msg, dwFlags,
(DWORD_PTR)(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 <f videoOpen>
****************************************************************************/
#ifdef UNICODE
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);
}
Imbstowcs(lpwstr, lpstrIdent, ret);
ret = (DWORD) videoMessage(hVideo, DVM_CONFIGURESTORAGE,
(DWORD_PTR)lpwstr, dwFlags);
LocalFree(lpwstr);
return(ret);
}
#endif
// On NT the header file will have ensured that videoConfigureStorage is
// defined by a macro to videoConfigureStorageW
DWORD WINAPI videoConfigureStorage(HVIDEO hVideo,
LPWSTR lpstrIdent, DWORD dwFlags)
{
if (!hVideo)
return DV_ERR_INVALHANDLE;
return (DWORD) videoMessage(hVideo, DVM_CONFIGURESTORAGE,
(DWORD_PTR)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 <f videoOpen> <f videoConfigureStorage>
****************************************************************************/
DWORD WINAPI videoDialog (HVIDEO hVideo, HWND hWndParent, DWORD dwFlags)
{
if (!hVideo)
return DV_ERR_INVALHANDLE;
if ((!hWndParent) || (!IsWindow (hWndParent)) )
return DV_ERR_INVALHANDLE;
return (DWORD) videoMessage(hVideo, DVM_DIALOG, (DWORD_PTR)hWndParent, dwFlags);
}
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
/*****************************************************************************
* @doc INTERNAL VIDEO
*
* @api DWORD | videoPrepareHeader | This function prepares the
* header and data
* by performing a <f GlobalPageLock>.
*
* @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_PTR)sizeof(VIDEOHDR)))
return DV_ERR_NOMEM;
if (!HugePageLock(lpVideoHdr->lpData, lpVideoHdr->dwBufferLength)) {
HugePageUnlock(lpVideoHdr, (DWORD_PTR)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_PTR)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
* <t VIDEOHDR> 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 <t VIDEOHDR> 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 <f videoStreamPrepareHeader> and
* <f videoStreamUnprepareHeader> functions should be used.
*
* The buffer allocated must be accessible for DMA by the host.
*
* @xref <f videoStreamPrepareHeader>
****************************************************************************/
DWORD WINAPI videoStreamAllocHdrAndBuffer(HVIDEO hVideo,
LPVIDEOHDR FAR * plpvideoHdr, DWORD dwSize)
{
#ifdef OBSOLETE
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_PTR)plpvideoHdr, (DWORD_PTR)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;
#endif
return DV_ERR_NOTSUPPORTED;
}
/*****************************************************************************
* @doc EXTERNAL VIDEO
*
* @api DWORD | videoStreamFreeHdrAndBuffer | This function is used to free
* buffers allocated by the driver using the <f videoStreamAllocHdrAndBuffer>
* function.
*
* @parm HVIDEO | hVideo | Specifies a handle to the video
* device channel.
*
* @parm LPVIDEOHDR | lpvideoHdr | Specifies a pointer to the
* <t VIDEOHDR> 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 <f videoStreamPrepareHeader> and
* <f videoStreamUnprepareHeader> functions should be used.
*
* @xref <f videoStreamPrepareHeader>
****************************************************************************/
DWORD WINAPI videoStreamFreeHdrAndBuffer(HVIDEO hVideo,
LPVIDEOHDR lpvideoHdr)
{
#ifdef OBSOLETE
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_PTR)lpvideoHdr, (DWORD_PTR)0);
if (wRet != DV_ERR_OK)
{
DebugErr(DBF_WARNING,"videoStreamFreeHdrAndBuffer: Error freeing buffer.");
}
return wRet;
#endif
return DV_ERR_NOTSUPPORTED;
}
DWORD WINAPI videoStreamAllocBuffer(HVIDEO hVideo,
LPVOID FAR * plBuffer, DWORD dwSize)
{
DWORD wRet;
if (!hVideo)
return DV_ERR_INVALHANDLE;
// as this code is internal to our dll we do not need to check access rights
// if (IsBadWritePtr (plpvideoHdr, sizeof (VIDEOHDR *)) )
// return DV_ERR_PARAM1;
*plBuffer = NULL; // Init to NULL ptr
wRet = (DWORD)videoMessage((HVIDEO)hVideo, DVM_STREAM_ALLOCBUFFER,
(DWORD_PTR)plBuffer, (DWORD_PTR)dwSize);
if (*plBuffer == NULL) {
DebugErr(DBF_WARNING,"videoStreamAllocBuffer: Allocation failed.");
dprintf("videoStreamAllocBuffer: Allocation failed, wRet=0x%d",wRet);
*plBuffer = NULL;
return wRet;
}
return wRet;
}
DWORD WINAPI videoStreamFreeBuffer(HVIDEO hVideo,
LPVOID lpBuffer)
{
DWORD wRet;
if (!hVideo)
return DV_ERR_INVALHANDLE;
wRet = (DWORD)videoMessage((HVIDEO)hVideo, DVM_STREAM_FREEBUFFER,
(DWORD_PTR)lpBuffer, (DWORD_PTR)0);
if (wRet != DV_ERR_OK)
{
DebugErr(DBF_WARNING,"videoStreamFreeBuffer: Error freeing buffer.");
dprintf("videoStreamFreeBuffer: error %d freeing buffer", wRet);
}
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
* <t VIDEOHDR> structure identifying the buffer to be prepared.
*
* @parm DWORD | dwSize | Specifies the size of the <t VIDEOHDR> 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 <f videoStreamInit> or
* after <f videoStreamReset> to prepare the data buffers
* for streaming data.
*
* The <t VIDEOHDR> data structure and the data block pointed to by its
* <e VIDEOHDR.lpData> member must be allocated with <f GlobalAlloc> using the
* GMEM_MOVEABLE and GMEM_SHARE flags, and locked with <f GlobalLock>.
* 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 <f videoStreamUnprepareHeader>
****************************************************************************/
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_PTR)lpvideoHdr, (DWORD_PTR)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 <f videoStreamPrepareHeader>.
*
* @parm HVIDEO | hVideo | Specifies a handle to the video
* device channel.
*
* @parm LPVIDEOHDR | lpvideoHdr | Specifies a pointer to a <t VIDEOHDR>
* structure identifying the data buffer to be unprepared.
*
* @parm DWORD | dwSize | Specifies the size of the <t VIDEOHDR> 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 <p lpvideoHdr>
* is still in the queue.
*
* @comm This function is the complementary function to <f videoStreamPrepareHeader>.
* You must call this function before freeing the data buffer with <f GlobalFree>.
* After passing a buffer to the device driver with <f videoStreamAddBuffer>, you
* must wait until the driver is finished with the buffer before calling
* <f videoStreamUnprepareHeader>. Unpreparing a buffer that has not been
* prepared or has been already unprepared has no effect,
* and the function returns zero.
*
* @xref <f videoStreamPrepareHeader>
****************************************************************************/
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_PTR)lpvideoHdr, (DWORD_PTR)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 <t VIDEOHDR>
* structure that identifies the buffer.
*
* @parm DWORD | dwSize | Specifies the size of the <t VIDEOHDR> 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 <p lpvideoHdr> structure hasn't been prepared.
* @flag DV_ERR_STILLPLAYING | Indicates a buffer is still in the queue.
* @flag DV_ERR_PARAM1 | The <p lpvideoHdr> parameter is invalid or
* the <e VIDEOHDR.dwBufferLength> member of the <t VIDEOHDR>
* structure is not set to the proper value.
*
* @comm The data buffer must be prepared with <f videoStreamPrepareHeader>
* before it is passed to <f videoStreamAddBuffer>. The <t VIDEOHDR> data
* structure and the data buffer referenced by its <e VIDEOHDR.lpData>
* member must be allocated with <f GlobalAlloc> using the GMEM_MOVEABLE
* and GMEM_SHARE flags, and locked with <f GlobalLock>. Set the
* <e VIDEOHDR.dwBufferLength> member to the size of the header.
*
* @xref <f videoStreamPrepareHeader>
****************************************************************************/
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_PTR)lpvideoHdr, (DWORD_PTR)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 <e VIDEOHDR.dwBytesRecorded> member in
* the <t VIDEOHDR> 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 <f videoStreamStart> <f videoStreamReset>
****************************************************************************/
DWORD WINAPI videoStreamStop(HVIDEO hVideo)
{
if (!hVideo)
return DV_ERR_INVALHANDLE;
return (DWORD) 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 <f videoStreamReset> <f videoStreamStop> <f videoStreamAddBuffer> <f videoStreamClose>
/****************************************************************************/
DWORD WINAPI videoStreamReset(HVIDEO hVideo)
{
if (!hVideo)
return DV_ERR_INVALHANDLE;
return (DWORD) 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 <t MMTIME>
* structure.
*
* @parm DWORD | dwSize | Specifies the size of the <t MMTIME> 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 <f videoStreamGetPosition>, set the
* <e MMTIME.wType> member of the <t MMTIME> structure to indicate
* the time format desired. After
* <f videoStreamGetPosition> returns, check the <e MMTIME.wType>
* member to determine if the your time format is supported. If
* not, <e MMTIME.wType> specifies an alternate format.
* Video capture drivers typically provide the millisecond time
* format.
*
* The position is set to zero when streaming is started with
* <f videoStreamStart>.
****************************************************************************/
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 (DWORD) videoMessage(hVideo, DVM_STREAM_GETPOSITION,
(DWORD_PTR)lpInfo, (DWORD_PTR)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, <p dwCallback> is
* a window handle.
* @flag CALLBACK_FUNCTION | If this flag is specified, <p dwCallback> 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
* <p hVideo> 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:
*
* <m MM_DRVM_OPEN> is sent at the time of <f videoStreamInit>
*
* <m MM_DRVM_CLOSE> is sent at the time of <f videoStreamFini>
*
* <m MM_DRVM_DATA> is sent when a buffer of image data is available
*
* <m MM_DRVM_ERROR> is sent when an error occurs
*
* Callback functions must reside in a DLL.
* You do not have to use <f MakeProcInstance> to get
* a procedure-instance address for the callback function.
*
* @cb void CALLBACK | videoFunc | <f 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
* <f videoStreamInit>.
*
* @parm HVIDEO | hVideo | Specifies a handle to the video device channel
* associated with the callback.
*
* @parm DWORD | wMsg | Specifies the <m MM_DRVM_> messages. Messages indicate
* errors and when image data is available. For information on
* these messages, see <f videoStreamInit>.
*
* @parm DWORD | dwInstance | Specifies the user instance
* data specified with <f videoStreamInit>.
*
* @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 <f PostMessage>, <f timeGetSystemTime>,
* <f timeGetTime>, <f timeSetEvent>, <f timeKillEvent>,
* <f midiOutShortMsg>, <f midiOutLongMsg>, and <f OutputDebugStr>.
*
* @xref <f videoOpen> <f videoStreamFini> <f videoClose>
****************************************************************************/
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 (DWORD) videoMessage(hVideo, DVM_STREAM_INIT,
(DWORD_PTR) (LPVIDEO_STREAM_INIT_PARMS) &vsip,
(DWORD_PTR) 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
* <f videoStreamAddBuffer> that haven't been returned to the application,
* this operation will fail. Use <f videoStreamReset> to return all
* pending buffers.
*
* Each call to <f videoStreamInit> must be matched with a call to
* <f videoStreamFini>.
*
* 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 <f videoStreamInit>
****************************************************************************/
DWORD WINAPI videoStreamFini(HVIDEO hVideo)
{
if (!hVideo)
return DV_ERR_INVALHANDLE;
return (DWORD) 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 <f videoStreamReset> <f videoStreamStop> <f videoStreamAddBuffer> <f videoStreamClose>
/****************************************************************************/
DWORD WINAPI videoStreamStart(HVIDEO hVideo)
{
if (!hVideo)
return DV_ERR_INVALHANDLE;
return (DWORD) 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 <t DWORD>
* used to return the error ID.
*
* @parm LPDWORD | lpdwErrorValue | Specifies a far pointer to the <t DWORD>
* 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 <p lpdwErrorID>
* and <p lpdwErrorValue> 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 <f videoOpen>
/****************************************************************************/
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 (DWORD) videoMessage(hVideo, DVM_STREAM_GETERROR, (DWORD_PTR) lpdwError,
(DWORD_PTR) 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 <t VIDEOHDR>
* 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 <p lpVDHdr> parameter is invalid or
* the <e VIDEOHDR.dwBufferLength> member of the <t VIDEOHDR>
* 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 <f videoOpen>
/****************************************************************************/
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 (DWORD) videoMessage(hVideo, DVM_FRAME, (DWORD_PTR) lpVHdr,
sizeof(VIDEOHDR));
}
/**************************************************************************
* @doc INTERNAL VIDEO
*
* @api void | videoCleanup | clean up video stuff
* called in MSVIDEOs WEP()
*
**************************************************************************/
void FAR PASCAL videoCleanup(HTASK hTask)
{
}
//
// Assist with unicode conversions
//
int Iwcstombs(LPSTR lpstr, LPCWSTR lpwstr, int len)
{
return WideCharToMultiByte(GetACP(), 0, lpwstr, -1, lpstr, len, NULL, NULL);
}
int Imbstowcs(LPWSTR lpwstr, LPCSTR lpstr, int len)
{
return MultiByteToWideChar(GetACP(),
MB_PRECOMPOSED,
lpstr,
-1,
lpwstr,
len);
}
Copy Permalink