You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
531 lines
14 KiB
531 lines
14 KiB
// DCAP16.C
|
|
//
|
|
// Created 31-Jul-96 [JonT]
|
|
|
|
#include <windows.h>
|
|
#define NODRAWDIB
|
|
#define NOCOMPMAN
|
|
#define NOAVIFILE
|
|
#define NOMSACM
|
|
#define NOAVIFMT
|
|
#define NOMCIWND
|
|
#define NOAVICAP
|
|
#include <vfw.h>
|
|
#include "..\inc\idcap.h"
|
|
#include "..\inc\msviddrv.h"
|
|
|
|
#define FP_SEG(fp) (*((unsigned *)&(fp) + 1))
|
|
#define FP_OFF(fp) (*((unsigned *)&(fp)))
|
|
|
|
// Equates
|
|
#define DCAP16API __far __pascal __loadds
|
|
#define DCAP16LOCAL __near __pascal
|
|
#define DLL_PROCESS_ATTACH 1 // Not in 16-bit windows.h
|
|
|
|
|
|
|
|
#ifdef DEBUG_SPEW_VERBOSE
|
|
#define DEBUGSPEW(str) DebugSpew((str))
|
|
#else
|
|
#define DEBUGSPEW(str)
|
|
#endif
|
|
|
|
|
|
// Structures thunked down
|
|
typedef struct _CAPTUREPALETTE
|
|
{
|
|
WORD wVersion;
|
|
WORD wcEntries;
|
|
PALETTEENTRY pe[256];
|
|
} CAPTUREPALETTE, FAR* LPCAPTUREPALETTE;
|
|
|
|
// Special thunking prototypes
|
|
BOOL DCAP16API __export DllEntryPoint(DWORD dwReason,
|
|
WORD hInst, WORD wDS, WORD wHeapSize, DWORD dwReserved1,
|
|
WORD wReserved2);
|
|
BOOL __far __pascal thk_ThunkConnect16(LPSTR pszDll16, LPSTR pszDll32,
|
|
WORD hInst, DWORD dwReason);
|
|
|
|
// Helper functions
|
|
WORD DCAP16LOCAL ReturnSel(BOOL fCS);
|
|
DWORD DCAP16LOCAL GetVxDEntrypoint(void);
|
|
int DCAP16LOCAL SetWin32Event(DWORD dwEvent);
|
|
void DCAP16API FrameCallback(HVIDEO hvideo, WORD wMsg, LPLOCKEDINFO lpli,
|
|
LPVIDEOHDR lpvh, DWORD dwParam2);
|
|
void DCAP16LOCAL ZeroMemory(LPSTR lp, WORD wSize);
|
|
|
|
// Globals
|
|
HANDLE g_hInst;
|
|
DWORD g_dwEntrypoint;
|
|
|
|
LPLOCKEDINFO g_lpli;
|
|
|
|
// LibMain
|
|
|
|
int
|
|
CALLBACK
|
|
LibMain(
|
|
HINSTANCE hinst,
|
|
WORD wDataSeg,
|
|
WORD cbHeapSize,
|
|
LPSTR lpszCmdLine
|
|
)
|
|
{
|
|
// Save global hinst
|
|
g_hInst = hinst;
|
|
|
|
// Still necessary?
|
|
if (cbHeapSize)
|
|
UnlockData(wDataSeg);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// DllEntryPoint
|
|
|
|
BOOL
|
|
__far __pascal __export __loadds
|
|
DllEntryPoint(
|
|
DWORD dwReason,
|
|
WORD hInst,
|
|
WORD wDS,
|
|
WORD wHeapSize,
|
|
DWORD dwReserved1,
|
|
WORD wReserved2
|
|
)
|
|
{
|
|
if (!thk_ThunkConnect16("DCAP16.DLL", "DCAP32.DLL", hInst, dwReason))
|
|
{
|
|
DebugSpew("DllEntrypoint: thk_ThunkConnect16 failed!");
|
|
return FALSE;
|
|
}
|
|
|
|
switch (dwReason)
|
|
{
|
|
case DLL_PROCESS_ATTACH:
|
|
g_dwEntrypoint = GetVxDEntrypoint();
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// APIs
|
|
|
|
|
|
// _InitializeExternalVideoStream
|
|
// Initializes a video stream for the external channel. We don't
|
|
// have to deal with locking or ever set a callback on this channel.
|
|
|
|
BOOL
|
|
DCAP16API
|
|
_InitializeExternalVideoStream(
|
|
HANDLE hvideo
|
|
)
|
|
{
|
|
VIDEO_STREAM_INIT_PARMS vsip;
|
|
|
|
vsip.dwMicroSecPerFrame = 0; // Ignored by driver for this channel
|
|
vsip.dwCallback = NULL; // No callback for now
|
|
vsip.dwCallbackInst = NULL;
|
|
vsip.dwFlags = 0;
|
|
vsip.hVideo = (DWORD)hvideo;
|
|
|
|
return !SendDriverMessage(hvideo, DVM_STREAM_INIT,
|
|
(DWORD) (LPVIDEO_STREAM_INIT_PARMS) &vsip,
|
|
(DWORD) sizeof (VIDEO_STREAM_INIT_PARMS));
|
|
}
|
|
|
|
|
|
void
|
|
DCAP16API
|
|
FrameCallback(
|
|
HVIDEO hvideo,
|
|
WORD wMsg,
|
|
LPLOCKEDINFO lpli, // Note that this is our instance data
|
|
LPVIDEOHDR lpvh,
|
|
DWORD dwParam2
|
|
)
|
|
{
|
|
LPCAPBUFFER lpcbuf;
|
|
|
|
if (!lpli) {
|
|
// Connectix hack: driver doesn't pass our instance data, so we keep it global
|
|
lpli = g_lpli;
|
|
}
|
|
|
|
// The client can put us in shutdown mode. This means that we will not queue
|
|
// any more buffers onto the ready queue, even if they were ready.
|
|
// This keeps the buffers from being given back to the driver, so it will eventually
|
|
// stop streaming. Of course, it will spew errors, but we just ignore these.
|
|
// Shutdown mode is defined when there is no event ready to signal.
|
|
if (!lpli->pevWait)
|
|
return;
|
|
|
|
// If it's not a data ready message, just set the event and get out.
|
|
// The reason we do this is that if we get behind and start getting a stream
|
|
// of MM_DRVM_ERROR messages (usually because we're stopped in the debugger),
|
|
// we want to make sure we are getting events so we get restarted to handle
|
|
// the frames that are 'stuck.'
|
|
if (wMsg != MM_DRVM_DATA)
|
|
{
|
|
DEBUGSPEW("Setting hcd->hevWait - no data\r\n");
|
|
SetWin32Event(lpli->pevWait);
|
|
return;
|
|
}
|
|
|
|
//--------------------
|
|
// Buffer ready queue:
|
|
// We maintain a doubly-linked list of our buffers so that we can buffer up
|
|
// multiple ready frames when the app isn't ready to handle them. Two things
|
|
// complicate what ought to be a very simple thing: (1) Thunking issues: the pointers
|
|
// used on the 16-bit side are 16:16 (2) Interrupt time issues: the FrameCallback
|
|
// gets called at interrupt time. GetNextReadyBuffer must handle the fact that
|
|
// buffers get added to the list asynchronously.
|
|
//
|
|
// To handle this, the scheme implemented here is to have a double-linked list
|
|
// of buffers with all insertions and deletions happening in FrameCallback
|
|
// (interrupt time). This allows the GetNextReadyBuffer routine to simply
|
|
// find the previous block on the list any time it needs a new buffer without
|
|
// fear of getting tromped (as would be the case if it had to dequeue buffers).
|
|
// The FrameCallback routine is responsible to dequeue blocks that GetNextReadyBuffer
|
|
// is done with. Dequeueing is simple since we don't need to unlink the blocks:
|
|
// no code ever walks the list! All we have to do is move the tail pointer back up
|
|
// the list. All the pointers, head, tail, next, prev, are all 16:16 pointers
|
|
// since all the list manipulation is on the 16-bit side AND because MapSL is
|
|
// much more efficient and safer than MapLS since MapLS has to allocate selectors.
|
|
//--------------------
|
|
|
|
// Move the tail back to skip all buffers already used.
|
|
// Note that there is no need to actually unhook the buffer pointers since no one
|
|
// ever walks the list!
|
|
// This makes STRICT assumptions that the current pointer will always be earlier in
|
|
// the list than the tail and that the tail will never be NULL unless the
|
|
// current pointer is too.
|
|
while (lpli->lp1616Tail != lpli->lp1616Current)
|
|
lpli->lp1616Tail = lpli->lp1616Tail->lp1616Prev;
|
|
|
|
// If all buffers have been used, then the tail pointer will fall off the list.
|
|
// This is normal and the most common code path. In this event, just set the head
|
|
// to NULL as the list is now empty.
|
|
if (!lpli->lp1616Tail)
|
|
lpli->lp1616Head = NULL;
|
|
|
|
// Add the new buffer to the ready queue
|
|
lpcbuf = (LPCAPBUFFER)((LPBYTE)lpvh - ((LPBYTE)&lpcbuf->vh - (LPBYTE)lpcbuf));
|
|
|
|
lpcbuf->lp1616Next = lpli->lp1616Head;
|
|
lpcbuf->lp1616Prev = NULL;
|
|
if (lpli->lp1616Head)
|
|
lpli->lp1616Head->lp1616Prev = lpcbuf;
|
|
else
|
|
lpli->lp1616Tail = lpcbuf;
|
|
lpli->lp1616Head = lpcbuf;
|
|
|
|
#if 1
|
|
if (lpli->lp1616Current) {
|
|
if (!(lpli->dwFlags & LIF_STOPSTREAM)) {
|
|
// if client hasn't consumed last frame, then release it
|
|
lpvh = &lpli->lp1616Current->vh;
|
|
lpli->lp1616Current = lpli->lp1616Current->lp1616Prev;
|
|
DEBUGSPEW("Sending DVM_STREAM_ADDBUFFER");
|
|
// Signal that the application is done with the buffer
|
|
lpvh->dwFlags &= ~VHDR_DONE;
|
|
if (SendDriverMessage(hvideo, DVM_STREAM_ADDBUFFER, *((DWORD*)&lpvh), sizeof(VIDEOHDR)) != 0)
|
|
DebugSpew("attempt to reuse unconsumed buffer failed");
|
|
}
|
|
}
|
|
else {
|
|
#else
|
|
if (!lpli->lp1616Current) {
|
|
// If there was no current buffer before, we have one now, so set it to the end.
|
|
#endif
|
|
lpli->lp1616Current = lpli->lp1616Tail;
|
|
}
|
|
|
|
// Now set the event saying it's time to process the ready frame
|
|
DEBUGSPEW("Setting hcd->hevWait - some data\r\n");
|
|
SetWin32Event(lpli->pevWait);
|
|
}
|
|
|
|
|
|
// _InitializeVideoStream
|
|
// Initializes a driver's video stream for the video in channel.
|
|
// This requires us to pagelock the memory for everything that will
|
|
// be touched at interrupt time.
|
|
|
|
BOOL
|
|
DCAP16API
|
|
_InitializeVideoStream(
|
|
HANDLE hvideo,
|
|
DWORD dwMicroSecPerFrame,
|
|
LPLOCKEDINFO lpli
|
|
)
|
|
{
|
|
DWORD dwRet;
|
|
WORD wsel;
|
|
VIDEO_STREAM_INIT_PARMS vsip;
|
|
|
|
ZeroMemory((LPSTR)&vsip, sizeof (VIDEO_STREAM_INIT_PARMS));
|
|
vsip.dwMicroSecPerFrame = dwMicroSecPerFrame;
|
|
vsip.dwCallback = (DWORD)FrameCallback;
|
|
vsip.dwCallbackInst = (DWORD)lpli; // LOCKEDINFO* is instance data for callback
|
|
vsip.dwFlags = CALLBACK_FUNCTION;
|
|
vsip.hVideo = (DWORD)hvideo;
|
|
|
|
g_lpli = lpli;
|
|
|
|
dwRet = SendDriverMessage(hvideo, DVM_STREAM_INIT,
|
|
(DWORD) (LPVIDEO_STREAM_INIT_PARMS) &vsip,
|
|
(DWORD) sizeof (VIDEO_STREAM_INIT_PARMS));
|
|
|
|
// If we succeeded, we now lock down our code and data
|
|
if (dwRet == 0)
|
|
{
|
|
// Lock CS
|
|
wsel = ReturnSel(TRUE);
|
|
GlobalSmartPageLock(wsel);
|
|
|
|
// Lock DS
|
|
wsel = ReturnSel(FALSE);
|
|
GlobalSmartPageLock(wsel);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// _UninitializeVideoStream
|
|
// Tells the driver we are done streaming. It also unlocks the memory
|
|
// we locked for interrupt time access.
|
|
|
|
BOOL
|
|
DCAP16API
|
|
_UninitializeVideoStream(
|
|
HANDLE hvideo
|
|
)
|
|
{
|
|
DWORD dwRet;
|
|
WORD wsel;
|
|
|
|
dwRet = SendDriverMessage(hvideo, DVM_STREAM_FINI, 0L, 0L);
|
|
|
|
// Unlock our code and data
|
|
if (dwRet == 0)
|
|
{
|
|
// Unlock CS
|
|
wsel = ReturnSel(TRUE);
|
|
GlobalSmartPageUnlock(wsel);
|
|
|
|
// Unlock DS
|
|
wsel = ReturnSel(FALSE);
|
|
GlobalSmartPageUnlock(wsel);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// _GetVideoPalette
|
|
// Get the current palette from the driver
|
|
|
|
HPALETTE
|
|
DCAP16API
|
|
_GetVideoPalette(
|
|
HANDLE hvideo,
|
|
LPCAPTUREPALETTE lpcp,
|
|
DWORD dwcbSize
|
|
)
|
|
{
|
|
VIDEOCONFIGPARMS vcp;
|
|
|
|
vcp.lpdwReturn = NULL;
|
|
vcp.lpData1 = (LPVOID)lpcp;
|
|
vcp.dwSize1 = dwcbSize;
|
|
vcp.lpData2 = NULL;
|
|
vcp.dwSize2 = 0;
|
|
|
|
return !SendDriverMessage(hvideo, DVM_PALETTE,
|
|
(DWORD)(VIDEO_CONFIGURE_GET | VIDEO_CONFIGURE_CURRENT),
|
|
(DWORD)(LPVIDEOCONFIGPARMS)&vcp);
|
|
}
|
|
|
|
|
|
// _GetVideoFormatSize
|
|
// Gets the current format header size required by driver
|
|
|
|
DWORD
|
|
DCAP16API
|
|
_GetVideoFormatSize(
|
|
HANDLE hvideo
|
|
)
|
|
{
|
|
DWORD bufsize;
|
|
VIDEOCONFIGPARMS vcp;
|
|
|
|
vcp.lpdwReturn = &bufsize;
|
|
vcp.lpData1 = NULL;
|
|
vcp.dwSize1 = 0L;
|
|
vcp.lpData2 = NULL;
|
|
vcp.dwSize2 = 0L;
|
|
|
|
#if 0
|
|
// it makes sense to query if DVM_FORMAT is available, but not all drivers support it!
|
|
if (SendDriverMessage(hvideo, DVM_FORMAT,
|
|
(LPARAM)(DWORD)(VIDEO_CONFIGURE_GET | VIDEO_CONFIGURE_QUERY),
|
|
(LPARAM)(LPVOID)&vcp) == DV_ERR_OK) {
|
|
#endif
|
|
SendDriverMessage(hvideo, DVM_FORMAT,
|
|
(LPARAM)(DWORD)(VIDEO_CONFIGURE_GET | VIDEO_CONFIGURE_QUERYSIZE),
|
|
(LPARAM)(LPVOID)&vcp);
|
|
if (!bufsize)
|
|
bufsize = sizeof(BITMAPINFOHEADER);
|
|
return bufsize;
|
|
#if 0
|
|
} else
|
|
return sizeof(BITMAPINFOHEADER);
|
|
#endif
|
|
}
|
|
|
|
// _GetVideoFormat
|
|
// Gets the current format (dib header) the capture device is blting to
|
|
|
|
BOOL
|
|
DCAP16API
|
|
_GetVideoFormat(
|
|
HANDLE hvideo,
|
|
LPBITMAPINFOHEADER lpbmih
|
|
)
|
|
{
|
|
BOOL res;
|
|
VIDEOCONFIGPARMS vcp;
|
|
|
|
if (!lpbmih->biSize)
|
|
lpbmih->biSize = sizeof (BITMAPINFOHEADER);
|
|
|
|
vcp.lpdwReturn = NULL;
|
|
vcp.lpData1 = lpbmih;
|
|
vcp.dwSize1 = lpbmih->biSize;
|
|
vcp.lpData2 = NULL;
|
|
vcp.dwSize2 = 0L;
|
|
|
|
res = !SendDriverMessage(hvideo, DVM_FORMAT,
|
|
(LPARAM)(DWORD)(VIDEO_CONFIGURE_GET | VIDEO_CONFIGURE_CURRENT),
|
|
(LPARAM)(LPVOID)&vcp);
|
|
if (res) {
|
|
// hack for Connectix QuickCam - set format needs to be called
|
|
// to set internal globals so that streaming can be enabled
|
|
SendDriverMessage(hvideo, DVM_FORMAT, (LPARAM)(DWORD)VIDEO_CONFIGURE_SET,
|
|
(LPARAM)(LPVOID)&vcp);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
|
|
// _SetVideoFormat
|
|
// Sets the format (dib header) the capture device is blting to.
|
|
|
|
BOOL
|
|
DCAP16API
|
|
_SetVideoFormat(
|
|
HANDLE hvideoExtIn,
|
|
HANDLE hvideoIn,
|
|
LPBITMAPINFOHEADER lpbmih
|
|
)
|
|
{
|
|
RECT rect;
|
|
VIDEOCONFIGPARMS vcp;
|
|
|
|
vcp.lpdwReturn = NULL;
|
|
vcp.lpData1 = lpbmih;
|
|
vcp.dwSize1 = lpbmih->biSize;
|
|
vcp.lpData2 = NULL;
|
|
vcp.dwSize2 = 0L;
|
|
|
|
// See if the driver likes the format
|
|
if (SendDriverMessage(hvideoIn, DVM_FORMAT, (LPARAM)(DWORD)VIDEO_CONFIGURE_SET,
|
|
(LPARAM)(LPVOID)&vcp))
|
|
return FALSE;
|
|
|
|
// Set the rectangles
|
|
rect.left = rect.top = 0;
|
|
rect.right = (WORD)lpbmih->biWidth;
|
|
rect.bottom = (WORD)lpbmih->biHeight;
|
|
SendDriverMessage(hvideoExtIn, DVM_DST_RECT, (LPARAM)(LPVOID)&rect, VIDEO_CONFIGURE_SET);
|
|
SendDriverMessage(hvideoIn, DVM_SRC_RECT, (LPARAM)(LPVOID)&rect, VIDEO_CONFIGURE_SET);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// _AllocateLockableBuffer
|
|
// Allocates memory that can be page locked. Just returns the selector.
|
|
|
|
WORD
|
|
DCAP16API
|
|
_AllocateLockableBuffer(
|
|
DWORD dwSize
|
|
)
|
|
{
|
|
return GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, dwSize);
|
|
}
|
|
|
|
|
|
// _LockBuffer
|
|
// Page locks (if necessary) a buffer allocated with _AllocateLockableBuffer.
|
|
|
|
BOOL
|
|
DCAP16API
|
|
_LockBuffer(
|
|
WORD wBuffer
|
|
)
|
|
{
|
|
return GlobalSmartPageLock(wBuffer);
|
|
}
|
|
|
|
// _UnlockBuffer
|
|
// Unlocks a buffer locked with _LockBuffer.
|
|
|
|
void
|
|
DCAP16API
|
|
_UnlockBuffer(
|
|
WORD wBuffer
|
|
)
|
|
{
|
|
GlobalSmartPageUnlock(wBuffer);
|
|
}
|
|
|
|
|
|
// _FreeLockableBuffer
|
|
// Frees a buffer allocated with _AllocateLockableBuffer.
|
|
|
|
void
|
|
DCAP16API
|
|
_FreeLockableBuffer(
|
|
WORD wBuffer
|
|
)
|
|
{
|
|
GlobalFree(wBuffer);
|
|
}
|
|
|
|
|
|
// _SendDriverMessage
|
|
// Sends a generic, dword only parameters, message to the driver channel of choice
|
|
|
|
DWORD
|
|
DCAP16API
|
|
_SendDriverMessage(
|
|
HVIDEO hvideo,
|
|
DWORD wMessage,
|
|
DWORD param1,
|
|
DWORD param2
|
|
)
|
|
{
|
|
return SendDriverMessage(hvideo, (WORD)wMessage, param1, param2);
|
|
}
|