1082 lines
36 KiB
C
1082 lines
36 KiB
C
/****************************************************************************
|
||
*
|
||
* capmci.c
|
||
*
|
||
* Control of MCI devices during capture.
|
||
*
|
||
* Microsoft Video for Windows Sample Capture Class
|
||
*
|
||
* Copyright (c) 1992 - 1995 Microsoft Corporation. All Rights Reserved.
|
||
*
|
||
* You have a royalty-free right to use, modify, reproduce and
|
||
* distribute the Sample Files (and/or any modified version) in
|
||
* any way you find useful, provided that you agree that
|
||
* Microsoft has no warranty obligations or liability for any
|
||
* Sample Application Files which are modified.
|
||
*
|
||
***************************************************************************/
|
||
|
||
#define INC_OLE2
|
||
#pragma warning(disable:4103)
|
||
#include <windows.h>
|
||
#include <windowsx.h>
|
||
#include <win32.h>
|
||
#include <mmsystem.h>
|
||
#include <stdlib.h>
|
||
#include <ctype.h>
|
||
#include <string.h>
|
||
#include <msvideo.h>
|
||
#include <drawdib.h>
|
||
#include <mmddk.h>
|
||
|
||
#include <avifmt.h>
|
||
#include "ivideo32.h"
|
||
#include "avicap.h"
|
||
#include "avicapi.h"
|
||
|
||
#include "mmdebug.h"
|
||
|
||
#ifdef _DEBUG
|
||
#define DSTATUS(lpcs, sz) statusUpdateStatus(lpcs, IDS_CAP_INFO, (LPTSTR) TEXT(sz))
|
||
#else
|
||
#define DSTATUS(lpcs, sz)
|
||
#endif
|
||
|
||
DWORD SendDriverFormat (LPCAPSTREAM lpcs, LPBITMAPINFOHEADER lpbih, DWORD dwInfoHeaderSize);
|
||
|
||
/*--------------------------------------------------------------+
|
||
| TimeMSToHMSString() - change milliseconds into SMPTE time |
|
||
+--------------------------------------------------------------*/
|
||
void FAR PASCAL TimeMSToSMPTE (DWORD dwMS, LPTSTR lpTime)
|
||
{
|
||
DWORD dwTotalSecs;
|
||
LONG lHundredths;
|
||
WORD wSecs;
|
||
WORD wMins;
|
||
WORD wHours;
|
||
|
||
/* convert to number of seconds */
|
||
dwTotalSecs = dwMS / 1000;
|
||
|
||
/* keep the remainder part */
|
||
lHundredths = (dwMS - (dwTotalSecs * 1000)) / 10;
|
||
|
||
/* break down into other components */
|
||
wHours = (WORD)(dwTotalSecs / 3600); // get # Hours
|
||
dwTotalSecs -= (wHours * 3600);
|
||
|
||
wMins = (WORD)(dwTotalSecs / 60); // get # Mins
|
||
dwTotalSecs -= (wMins * 60);
|
||
|
||
wSecs = (WORD)dwTotalSecs; // what's left is # seconds
|
||
|
||
/* build the string */
|
||
/* KLUDGE, force hundredths to SMPTE approximation of PAL frames */
|
||
wsprintf((LPTSTR)lpTime, TEXT("%02u:%02u:%02u:%02lu"), wHours, wMins,
|
||
wSecs, (lHundredths * 25) / 100);
|
||
}
|
||
|
||
|
||
/*--------------------------------------------------------------+
|
||
| START OF MCI CONTROL SECTION |
|
||
+--------------------------------------------------------------*/
|
||
|
||
/*
|
||
* CountMCIDevicesByType
|
||
* Returns a count of the number of VCR or Videodisc
|
||
* devices that MCI claims to know about.
|
||
*/
|
||
|
||
int CountMCIDevicesByType ( UINT wType )
|
||
{
|
||
int nTotal;
|
||
DWORD dwCount;
|
||
MCI_SYSINFO_PARMS mciSIP;
|
||
|
||
mciSIP.dwCallback = 0;
|
||
mciSIP.lpstrReturn = (LPTSTR) (LPVOID) &dwCount;
|
||
mciSIP.dwRetSize = sizeof (dwCount);
|
||
|
||
mciSIP.wDeviceType = wType;
|
||
|
||
if (!mciSendCommand (0, MCI_SYSINFO, MCI_SYSINFO_QUANTITY,
|
||
(DWORD) (LPVOID) &mciSIP))
|
||
nTotal = (int) *( (LPDWORD) mciSIP.lpstrReturn);
|
||
|
||
return nTotal;
|
||
}
|
||
|
||
/*
|
||
* MCIDeviceClose
|
||
* This routine closes the open MCI device.
|
||
*/
|
||
|
||
void MCIDeviceClose (LPCAPSTREAM lpcs)
|
||
{
|
||
mciSendString( TEXT("close mciframes"), NULL, 0, NULL );
|
||
}
|
||
|
||
/*
|
||
* MCIDeviceOpen
|
||
* This routine opens the mci device for use, and sets the
|
||
* time format to milliseconds.
|
||
* Return FALSE on error;
|
||
*/
|
||
|
||
BOOL MCIDeviceOpen (LPCAPSTREAM lpcs)
|
||
{
|
||
TCHAR ach[160];
|
||
|
||
wsprintf( ach, TEXT("open %s shareable alias mciframes"),
|
||
(LPTSTR) lpcs->achMCIDevice);
|
||
lpcs->dwMCIError = mciSendString( ach, NULL, 0, NULL );
|
||
if( lpcs->dwMCIError ) {
|
||
DPF (" MCI Error, open %s shareable alias mciframes", lpcs->achMCIDevice);
|
||
goto err_return;
|
||
}
|
||
lpcs->dwMCIError = mciSendString( TEXT("set mciframes time format milliseconds"),
|
||
NULL, 0, NULL );
|
||
if( lpcs->dwMCIError ) {
|
||
DPF (" MCI Error, set mciframes time format milliseconds");
|
||
goto err_close;
|
||
}
|
||
return ( TRUE );
|
||
|
||
err_close:
|
||
MCIDeviceClose (lpcs);
|
||
err_return:
|
||
return ( FALSE );
|
||
}
|
||
|
||
|
||
/*
|
||
* MCIDeviceGetPosition
|
||
* Stores the current device position in milliseconds in lpdwPos.
|
||
* Returns TRUE on success, FALSE if error.
|
||
*/
|
||
BOOL FAR PASCAL MCIDeviceGetPosition (LPCAPSTREAM lpcs, LPDWORD lpdwPos)
|
||
{
|
||
TCHAR ach[80];
|
||
LPTSTR p;
|
||
LONG lv;
|
||
|
||
lpcs->dwMCIError = mciSendString( TEXT("status mciframes position wait"),
|
||
ach, sizeof(ach)/sizeof(TCHAR), NULL );
|
||
if( lpcs->dwMCIError ) {
|
||
DPF (" MCI Error, status mciframes position wait");
|
||
*lpdwPos = 0L;
|
||
return FALSE;
|
||
}
|
||
|
||
p = ach;
|
||
|
||
while (*p == ' ') p++;
|
||
for (lv = 0; *p >= '0' && *p <= '9'; p++)
|
||
lv = (10 * lv) + (*p - '0');
|
||
*lpdwPos = lv;
|
||
return TRUE;
|
||
}
|
||
|
||
/*
|
||
* MCIDeviceSetPosition
|
||
* Sets the current device position in milliseconds.
|
||
* Returns TRUE on success, FALSE if error.
|
||
*/
|
||
BOOL FAR PASCAL MCIDeviceSetPosition (LPCAPSTREAM lpcs, DWORD dwPos)
|
||
{
|
||
TCHAR achCommand[40];
|
||
TCHAR ach[80];
|
||
|
||
lpcs->dwMCIError = mciSendString( TEXT("pause mciframes wait"), ach, sizeof(ach)/sizeof(TCHAR), NULL );
|
||
if (lpcs->dwMCIError) {
|
||
DPF (" MCI Error, pause mciframes wait");
|
||
return FALSE;
|
||
}
|
||
wsprintf(achCommand, TEXT("seek mciframes to %ld wait"), dwPos);
|
||
lpcs->dwMCIError = mciSendString( achCommand, ach, sizeof(ach)/sizeof(TCHAR), NULL );
|
||
if (lpcs->dwMCIError)
|
||
DPF (" MCI Error, seek mciframes to %ld wait", dwPos);
|
||
return ( lpcs->dwMCIError == 0 ? TRUE : FALSE );
|
||
}
|
||
|
||
|
||
/*
|
||
* MCIDevicePlay
|
||
* Start playing the current MCI device from the current position
|
||
* Returns TRUE on success, FALSE if error.
|
||
*/
|
||
BOOL FAR PASCAL MCIDevicePlay (LPCAPSTREAM lpcs)
|
||
{
|
||
TCHAR ach[80];
|
||
|
||
lpcs->dwMCIError = mciSendString( TEXT("play mciframes"), ach, sizeof(ach)/sizeof(TCHAR), NULL );
|
||
if (lpcs->dwMCIError)
|
||
DPF (" MCI Error, play mciframes");
|
||
return ( lpcs->dwMCIError == 0 ? TRUE : FALSE );
|
||
}
|
||
|
||
/*
|
||
* MCIDevicePause
|
||
* Pauses the current MCI device at the current position
|
||
* Returns TRUE on success, FALSE if error.
|
||
*/
|
||
BOOL FAR PASCAL MCIDevicePause (LPCAPSTREAM lpcs)
|
||
{
|
||
TCHAR ach[80];
|
||
|
||
lpcs->dwMCIError = mciSendString( TEXT("pause mciframes wait"), ach, sizeof(ach)/sizeof(TCHAR), NULL );
|
||
if (lpcs->dwMCIError)
|
||
DPF (" MCI Error, pause mciframes wait");
|
||
return ( lpcs->dwMCIError == 0 ? TRUE : FALSE );
|
||
}
|
||
|
||
/*
|
||
* MCIDeviceStop
|
||
* Stops the current MCI device
|
||
* Returns TRUE on success, FALSE if error.
|
||
*/
|
||
BOOL FAR PASCAL MCIDeviceStop (LPCAPSTREAM lpcs)
|
||
{
|
||
TCHAR ach[80];
|
||
|
||
lpcs->dwMCIError = mciSendString( TEXT("stop mciframes wait"), ach, sizeof(ach)/sizeof(TCHAR), NULL );
|
||
if (lpcs->dwMCIError)
|
||
DPF (" MCI Error, stop mciframes wait");
|
||
return ( lpcs->dwMCIError == 0 ? TRUE : FALSE );
|
||
}
|
||
|
||
/*
|
||
* MCIDeviceStep
|
||
* Step the current MCI at the current position
|
||
* Returns TRUE on success, FALSE if error.
|
||
*/
|
||
BOOL FAR PASCAL MCIDeviceStep (LPCAPSTREAM lpcs, BOOL fForward)
|
||
{
|
||
TCHAR ach[80];
|
||
|
||
lpcs->dwMCIError = mciSendString(
|
||
fForward ? TEXT("step mciframes wait") :
|
||
TEXT("step mciframes reverse wait"), ach, sizeof(ach)/sizeof(TCHAR), NULL );
|
||
if (lpcs->dwMCIError)
|
||
DPF (" MCI Error, step mciframes wait");
|
||
return ( lpcs->dwMCIError == 0 ? TRUE : FALSE );
|
||
}
|
||
|
||
/*
|
||
* MCIDeviceFreeze
|
||
* freeze the current frame
|
||
* Returns TRUE on success, FALSE if error.
|
||
*/
|
||
BOOL FAR PASCAL MCIDeviceFreeze(LPCAPSTREAM lpcs, BOOL fFreeze)
|
||
{
|
||
lpcs->dwMCIError = mciSendString( fFreeze ? TEXT("freeze mciframes wait") :
|
||
TEXT("unfreeze mciframes wait"), NULL, 0, NULL);
|
||
if (lpcs->dwMCIError)
|
||
DPF (" MCI Error, freeze mciframes wait");
|
||
return ( lpcs->dwMCIError == 0 ? TRUE : FALSE );
|
||
}
|
||
|
||
|
||
/*
|
||
* MCIStepCapture
|
||
* Main routine for performing MCI step capture.
|
||
*
|
||
*/
|
||
void FAR PASCAL _LOADDS MCIStepCapture (LPCAPSTREAM lpcs)
|
||
{
|
||
BOOL fOK = TRUE;
|
||
BOOL fT;
|
||
BOOL fStopping; // True when finishing capture
|
||
DWORD dw;
|
||
int iNumAudio;
|
||
UINT wError; // Error String ID
|
||
LPVIDEOHDR lpVidHdr;
|
||
LPWAVEHDR lpWaveHdr;
|
||
DWORD dwTimeToStop; // Lesser of MCI capture time or frame limit
|
||
BOOL fTryToPaint = FALSE;
|
||
HDC hdc;
|
||
HPALETTE hpalT;
|
||
RECT rcDrawRect;
|
||
#define PROMPTFORSTEPCAPTURE
|
||
#ifdef PROMPTFORSTEPCAPTURE
|
||
TCHAR ach[128];
|
||
TCHAR achMsg[128];
|
||
#endif
|
||
|
||
statusUpdateStatus(lpcs, IDS_CAP_BEGIN); // Always the first message
|
||
|
||
// Verify capture parameters
|
||
if ((!lpcs->sCapParms.fMCIControl) ||
|
||
(!lpcs->sCapParms.fStepMCIDevice))
|
||
goto EarlyExit;
|
||
|
||
lpcs->MCICaptureState = CAPMCI_STATE_Uninitialized;
|
||
|
||
lpcs->fCaptureFlags |= (CAP_fCapturingNow | CAP_fStepCapturingNow);
|
||
lpcs->dwReturn = DV_ERR_OK;
|
||
|
||
// If not 1 Meg. free, give it up!!!
|
||
if (GetFreePhysicalMemory () < (1024L * 1024L)) {
|
||
errorUpdateError (lpcs, IDS_CAP_OUTOFMEM);
|
||
goto EarlyExit;
|
||
}
|
||
|
||
statusUpdateStatus(lpcs, IDS_CAP_STAT_CAP_INIT);
|
||
|
||
// Try painting the DIB only if Live window
|
||
fTryToPaint = lpcs->fLiveWindow;
|
||
|
||
if (fTryToPaint) {
|
||
hdc = GetDC(lpcs->hwnd);
|
||
SetWindowOrgEx(hdc, lpcs->ptScroll.x, lpcs->ptScroll.y, NULL);
|
||
hpalT = DrawDibGetPalette (lpcs->hdd);
|
||
if (hpalT)
|
||
hpalT = SelectPalette( hdc, hpalT, FALSE);
|
||
RealizePalette(hdc);
|
||
if (lpcs->fScale)
|
||
GetClientRect (lpcs->hwnd, &rcDrawRect);
|
||
else
|
||
SetRect (&rcDrawRect, 0, 0, lpcs->dxBits, lpcs->dyBits);
|
||
}
|
||
|
||
// -------------------------------------------------------
|
||
// When should capture stop?
|
||
// -------------------------------------------------------
|
||
|
||
// If using MCI, capture for the shorter of the MCI period,
|
||
// or the capture limit
|
||
|
||
if (lpcs->sCapParms.fLimitEnabled)
|
||
dwTimeToStop = (DWORD) ((DWORD) 1000 * lpcs->sCapParms.wTimeLimit);
|
||
else
|
||
dwTimeToStop = (DWORD) -1L; // very large
|
||
|
||
if (lpcs->sCapParms.fMCIControl) {
|
||
// if MCI stop time not given, use lpcs->sCapParms.wTimeLimit
|
||
if (lpcs->sCapParms.dwMCIStopTime == lpcs->sCapParms.dwMCIStartTime)
|
||
lpcs->sCapParms.dwMCIStopTime = lpcs->sCapParms.dwMCIStartTime +
|
||
(DWORD) ((DWORD)1000 * lpcs->sCapParms.wTimeLimit);
|
||
|
||
dw = lpcs->sCapParms.dwMCIStopTime - lpcs->sCapParms.dwMCIStartTime;
|
||
|
||
if (lpcs->sCapParms.fLimitEnabled)
|
||
dwTimeToStop = min (dw, dwTimeToStop);
|
||
else
|
||
dwTimeToStop = dw;
|
||
}
|
||
|
||
//
|
||
// never ever try to capture more than the index size!
|
||
//
|
||
if (lpcs->fCaptureFlags & CAP_fCapturingToDisk) {
|
||
dw = MulDiv(lpcs->sCapParms.dwIndexSize,
|
||
lpcs->sCapParms.dwRequestMicroSecPerFrame,
|
||
1000l);
|
||
dwTimeToStop = min (dw, dwTimeToStop);
|
||
}
|
||
|
||
fOK = FALSE; // Assume the worst
|
||
if (MCIDeviceOpen (lpcs)) {
|
||
if (MCIDeviceSetPosition (lpcs, lpcs->sCapParms.dwMCIStartTime))
|
||
if (MCIDeviceStep (lpcs, TRUE))
|
||
fOK = TRUE;
|
||
}
|
||
if (!fOK) {
|
||
errorUpdateError (lpcs, IDS_CAP_MCI_CONTROL_ERROR);
|
||
statusUpdateStatus(lpcs, 0); // Clear status
|
||
goto EarlyExit;
|
||
}
|
||
|
||
// -------------------------------------------------------
|
||
// Spatial and temporal averaging
|
||
// -------------------------------------------------------
|
||
|
||
// Frame Averaging, capture the same frame multiple times...
|
||
lpcs->lpia = NULL;
|
||
if (lpcs->sCapParms.wStepCaptureAverageFrames == 0)
|
||
lpcs->sCapParms.wStepCaptureAverageFrames = 1;
|
||
|
||
// Only allow averaging if an RGB format
|
||
if (lpcs->lpBitsInfo->bmiHeader.biCompression != BI_RGB)
|
||
lpcs->sCapParms.wStepCaptureAverageFrames = 1;
|
||
|
||
// 2x Scaling
|
||
lpcs->lpbmih2x = NULL;
|
||
lpcs->VidHdr2x = lpcs->VidHdr; // Init the 2x copy
|
||
|
||
if (lpcs->sCapParms.fStepCaptureAt2x &&
|
||
lpcs->lpBitsInfo->bmiHeader.biCompression == BI_RGB) {
|
||
lpcs->VidHdr2x.lpData = NULL;
|
||
lpcs->lpbmih2x = (LPBITMAPINFOHEADER) GlobalAllocPtr (GHND,
|
||
sizeof (BITMAPINFOHEADER) +
|
||
256 * sizeof (RGBQUAD));
|
||
CopyMemory (lpcs->lpbmih2x, lpcs->lpBitsInfo,
|
||
sizeof (BITMAPINFOHEADER) + 256 * sizeof (RGBQUAD));
|
||
|
||
// Try to force the driver into 2x mode
|
||
lpcs->lpbmih2x->biHeight *= 2;
|
||
lpcs->lpbmih2x->biWidth *= 2;
|
||
lpcs->lpbmih2x->biSizeImage *= 4;
|
||
if (!SendDriverFormat (lpcs, lpcs->lpbmih2x, sizeof (BITMAPINFOHEADER))) {
|
||
// Success, allocate new bitspace
|
||
lpcs->VidHdr2x.lpData = GlobalAllocPtr (GHND,
|
||
lpcs->lpbmih2x->biSizeImage);
|
||
lpcs->VidHdr2x.dwBufferLength = lpcs->lpbmih2x->biSizeImage;
|
||
}
|
||
|
||
// Something went wrong, no memory, or driver failed request
|
||
// so revert back to original settings
|
||
if (!lpcs->VidHdr2x.lpData) {
|
||
SendDriverFormat (lpcs, (LPBITMAPINFOHEADER) lpcs->lpBitsInfo,
|
||
sizeof (BITMAPINFOHEADER));
|
||
lpcs->sCapParms.fStepCaptureAt2x = FALSE;
|
||
lpcs->VidHdr2x = lpcs->VidHdr; // Back to the original settings
|
||
}
|
||
}
|
||
else
|
||
lpcs->sCapParms.fStepCaptureAt2x = FALSE;
|
||
|
||
DPF (" StepCaptureAt2x = %d\r\n", (int) lpcs->sCapParms.fStepCaptureAt2x);
|
||
|
||
//
|
||
// If we're compressing while capturing, warm up the compressor
|
||
//
|
||
#ifdef NEW_COMPMAN
|
||
if (lpcs->CompVars.hic) {
|
||
if (ICSeqCompressFrameStart(&lpcs->CompVars, lpcs->lpBitsInfo) == 0) {
|
||
|
||
// !!! We're in trouble here!
|
||
dprintf("ICSeqCompressFrameStart failed !!!\n");
|
||
errorUpdateError (lpcs, IDS_CAP_COMPRESSOR_ERROR);
|
||
goto EarlyExit;
|
||
}
|
||
// Kludge, offset the lpBitsOut ptr
|
||
// Compman allocates the compress buffer too large by
|
||
// 2048 + 16 so we will still have room
|
||
((LPBYTE) lpcs->CompVars.lpBitsOut) += 8;
|
||
}
|
||
|
||
// No compression desired
|
||
if (!lpcs->CompVars.hic)
|
||
WinAssert(lpcs->CompVars.lpbiOut == NULL);
|
||
#endif
|
||
|
||
|
||
// -------------------------------------------------------
|
||
// Open the output file
|
||
// -------------------------------------------------------
|
||
|
||
if (lpcs->fCaptureFlags & CAP_fCapturingToDisk) {
|
||
if (!CapFileInit(lpcs)) {
|
||
errorUpdateError (lpcs, IDS_CAP_FILE_OPEN_ERROR);
|
||
goto EarlyExit;
|
||
}
|
||
}
|
||
|
||
/* Make sure the parent has been repainted */
|
||
UpdateWindow(lpcs->hwnd);
|
||
|
||
//
|
||
// AVIInit will allocate sound buffers, but not video buffers
|
||
// when performing step capture.
|
||
//
|
||
|
||
wError = IDS_CAP_AVI_INIT_ERROR;
|
||
lpcs->hCaptureEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
|
||
if (lpcs->hCaptureEvent)
|
||
{
|
||
#ifdef CHICAGO
|
||
lpcs->hRing0CapEvt = OpenVxDHandle (lpcs->hCaptureEvent);
|
||
if ( ! lpcs->hRing0CapEvt)
|
||
CloseHandle (lpcs->hCaptureEvent), lpcs->hCaptureEvent = NULL;
|
||
else
|
||
#endif
|
||
wError = AVIInit(lpcs);
|
||
}
|
||
|
||
if (wError) {
|
||
lpcs->sCapParms.fUsingDOSMemory = FALSE;
|
||
wError = AVIInit(lpcs);
|
||
}
|
||
|
||
if (wError) {
|
||
/* Error in initalization - return */
|
||
errorUpdateError (lpcs, wError);
|
||
AVIFini(lpcs);
|
||
AVIFileFini(lpcs, TRUE /* fWroteJunkChunks */, TRUE /* fAbort */);
|
||
statusUpdateStatus(lpcs, 0); // Clear status
|
||
// assert(lpcs->dwReturn == wError);
|
||
goto EarlyExit;
|
||
}
|
||
|
||
#ifdef PROMPTFORSTEPCAPTURE
|
||
// -------------------------------------------------------
|
||
// Ready to go, make the user click OK?
|
||
// -------------------------------------------------------
|
||
|
||
// Click OK to capture string (must follow AVIInit)
|
||
//
|
||
LoadString(lpcs->hInst, IDS_CAP_SEQ_MSGSTART, ach, NUMELMS(ach));
|
||
wsprintf(achMsg, ach, (LPBYTE)lpcs->achFile);
|
||
|
||
if (lpcs->sCapParms.fMakeUserHitOKToCapture && (lpcs->fCaptureFlags & CAP_fCapturingToDisk))
|
||
{
|
||
UINT idBtn;
|
||
|
||
idBtn = MessageBox (lpcs->hwnd, achMsg, TEXT(""),
|
||
MB_OKCANCEL | MB_ICONEXCLAMATION);
|
||
|
||
if (idBtn == IDCANCEL)
|
||
{
|
||
AVIFini(lpcs);
|
||
AVIFileFini (lpcs, TRUE, TRUE);
|
||
statusUpdateStatus (lpcs, 0);
|
||
goto EarlyExit;
|
||
}
|
||
}
|
||
#endif // PROMPTFORSTEPCAPTURE
|
||
|
||
/* update the status, so the user knows how to stop */
|
||
statusUpdateStatus(lpcs, IDS_CAP_SEQ_MSGSTOP);
|
||
UpdateWindow(lpcs->hwnd);
|
||
|
||
|
||
if (lpcs->sCapParms.fStepCaptureAt2x || (lpcs->sCapParms.wStepCaptureAverageFrames != 1)) {
|
||
LPIAVERAGE FAR * lppia = (LPIAVERAGE FAR *) &lpcs->lpia;
|
||
|
||
statusUpdateStatus (lpcs, IDS_CAP_STAT_PALETTE_BUILD);
|
||
if (!iaverageInit (lppia, lpcs->lpBitsInfo, lpcs->hPalCurrent)) {
|
||
lpcs->dwReturn = IDS_CAP_OUTOFMEM;
|
||
goto CompressFrameFailure;
|
||
}
|
||
statusUpdateStatus(lpcs, 0);
|
||
}
|
||
DPF (" Averaging %d frames\r\n", lpcs->sCapParms.wStepCaptureAverageFrames);
|
||
|
||
GetAsyncKeyState(lpcs->sCapParms.vKeyAbort);
|
||
GetAsyncKeyState(VK_ESCAPE);
|
||
GetAsyncKeyState(VK_LBUTTON);
|
||
GetAsyncKeyState(VK_RBUTTON);
|
||
|
||
|
||
// -------------------------------------------------------
|
||
// MAIN VIDEO CAPTURE LOOP
|
||
// -------------------------------------------------------
|
||
|
||
fOK=TRUE; // Set FALSE on write errors
|
||
fStopping = FALSE; // TRUE when we need to stop
|
||
|
||
lpVidHdr = &lpcs->VidHdr;
|
||
lpWaveHdr = lpcs->alpWaveHdr[lpcs->iNextWave];
|
||
|
||
lpcs->MCICaptureState = CAPMCI_STATE_Initialized;
|
||
lpcs->dwTimeElapsedMS = 0;
|
||
|
||
// Move back to the starting position
|
||
MCIDeviceSetPosition (lpcs, lpcs->sCapParms.dwMCIStartTime);
|
||
MCIDevicePause (lpcs);
|
||
|
||
// Where are we *really*
|
||
MCIDeviceGetPosition (lpcs, &lpcs->dwMCIActualStartMS);
|
||
|
||
// freeze video
|
||
MCIDeviceFreeze(lpcs, TRUE);
|
||
|
||
while (lpcs->MCICaptureState != CAPMCI_STATE_AllFini) {
|
||
|
||
// -------------------------------------------------------
|
||
// is there any reason to stop or change states
|
||
// -------------------------------------------------------
|
||
if (lpcs->sCapParms.vKeyAbort) {
|
||
if (GetAsyncKeyState(lpcs->sCapParms.vKeyAbort & 0x00ff) & 0x0001) {
|
||
fT = TRUE;
|
||
if (lpcs->sCapParms.vKeyAbort & 0x8000) // Ctrl?
|
||
fT = fT && (GetAsyncKeyState(VK_CONTROL) & 0x8000);
|
||
if (lpcs->sCapParms.vKeyAbort & 0x4000) // Shift?
|
||
fT = fT && (GetAsyncKeyState(VK_SHIFT) & 0x8000);
|
||
fStopping = fT; // User aborts
|
||
}
|
||
}
|
||
#if 0
|
||
// Ignore Left mouse on MCI Capture!!!
|
||
if (lpcs->sCapParms.fAbortLeftMouse)
|
||
if (GetAsyncKeyState(VK_LBUTTON) & 0x0001)
|
||
fStopping = TRUE; // User aborts
|
||
#endif
|
||
|
||
if (lpcs->sCapParms.fAbortRightMouse)
|
||
if (GetAsyncKeyState(VK_RBUTTON) & 0x0001)
|
||
fStopping = TRUE; // User aborts
|
||
if (lpcs->fCaptureFlags & CAP_fAbortCapture) {
|
||
fStopping = TRUE; // Somebody above wants us to quit
|
||
}
|
||
if (lpcs->dwTimeElapsedMS > dwTimeToStop)
|
||
fStopping = TRUE; // all done
|
||
|
||
|
||
// -------------------------------------------------------
|
||
// State machine
|
||
// -------------------------------------------------------
|
||
switch (lpcs->MCICaptureState) {
|
||
|
||
case CAPMCI_STATE_Initialized:
|
||
// Begin video step capture
|
||
DSTATUS(lpcs, "MCIState: Initialized");
|
||
lpcs->MCICaptureState = CAPMCI_STATE_StartVideo;
|
||
break;
|
||
|
||
case CAPMCI_STATE_StartVideo:
|
||
// Begin video step capture
|
||
lpcs->dwTimeElapsedMS = 0;
|
||
lpcs->MCICaptureState = CAPMCI_STATE_CapturingVideo;
|
||
break;
|
||
|
||
case CAPMCI_STATE_CapturingVideo:
|
||
// In the state of capturing video
|
||
if ((lpcs->fCaptureFlags & CAP_fStopCapture) || (lpcs->fCaptureFlags & CAP_fAbortCapture))
|
||
fStopping = TRUE;
|
||
|
||
if (fStopping) {
|
||
MCIDeviceGetPosition (lpcs, &lpcs->dwMCIActualEndMS);
|
||
MCIDevicePause (lpcs);
|
||
|
||
DSTATUS(lpcs, "MCIState: StoppingVideo");
|
||
|
||
if (fOK && !(lpcs->fCaptureFlags & CAP_fAbortCapture))
|
||
lpcs->MCICaptureState = CAPMCI_STATE_VideoFini;
|
||
else
|
||
lpcs->MCICaptureState = CAPMCI_STATE_AllFini;
|
||
|
||
lpcs->fCaptureFlags &= ~CAP_fStopCapture;
|
||
lpcs->fCaptureFlags &= ~CAP_fAbortCapture;
|
||
fStopping = FALSE;
|
||
}
|
||
break;
|
||
|
||
case CAPMCI_STATE_VideoFini:
|
||
// Wait for all buffers to be returned from the driver
|
||
// Then move on to audio capture
|
||
lpcs->MCICaptureState = CAPMCI_STATE_StartAudio;
|
||
DSTATUS(lpcs, "MCIState: VideoFini");
|
||
break;
|
||
|
||
case CAPMCI_STATE_StartAudio:
|
||
// If no audio, go to AllFini state
|
||
if (!lpcs->sCapParms.fCaptureAudio || !fOK) {
|
||
lpcs->MCICaptureState = CAPMCI_STATE_AllFini;
|
||
break;
|
||
}
|
||
|
||
// Move back to the starting position
|
||
MCIDeviceSetPosition (lpcs, lpcs->dwMCIActualStartMS);
|
||
MCIDeviceGetPosition (lpcs, &lpcs->dwMCICurrentMS);
|
||
DSTATUS(lpcs, "MCIState: StartAudio");
|
||
MCIDevicePlay (lpcs);
|
||
waveInStart(lpcs->hWaveIn);
|
||
lpcs->MCICaptureState = CAPMCI_STATE_CapturingAudio;
|
||
lpcs->dwTimeElapsedMS = 0;
|
||
fStopping = FALSE;
|
||
break;
|
||
|
||
case CAPMCI_STATE_CapturingAudio:
|
||
// In the state of capturing audio
|
||
if ((lpcs->fCaptureFlags & CAP_fStopCapture) || (lpcs->fCaptureFlags & CAP_fAbortCapture))
|
||
fStopping = TRUE;
|
||
|
||
MCIDeviceGetPosition (lpcs, &lpcs->dwMCICurrentMS);
|
||
if (lpcs->dwMCICurrentMS + 100 > lpcs->dwMCIActualEndMS)
|
||
fStopping = TRUE;
|
||
if (fStopping) {
|
||
waveInStop(lpcs->hWaveIn);
|
||
MCIDevicePause (lpcs);
|
||
waveInReset(lpcs->hWaveIn);
|
||
lpcs->MCICaptureState = CAPMCI_STATE_AudioFini;
|
||
}
|
||
break;
|
||
|
||
case CAPMCI_STATE_AudioFini:
|
||
// While more audio buffers to process
|
||
if (lpWaveHdr->dwFlags & WHDR_DONE)
|
||
break;
|
||
lpcs->MCICaptureState = CAPMCI_STATE_AllFini;
|
||
break;
|
||
|
||
case CAPMCI_STATE_AllFini:
|
||
DSTATUS(lpcs, "MCIState: AllFini");
|
||
if (fOK)
|
||
statusUpdateStatus(lpcs, IDS_CAP_STAT_CAP_FINI, lpcs->dwVideoChunkCount);
|
||
else
|
||
statusUpdateStatus(lpcs, IDS_CAP_RECORDING_ERROR2);
|
||
break;
|
||
}
|
||
|
||
// -------------------------------------------------------
|
||
// If we are in the video capture phase
|
||
// -------------------------------------------------------
|
||
|
||
if (lpcs->MCICaptureState == CAPMCI_STATE_CapturingVideo) {
|
||
BOOL fKeyFrame;
|
||
LPBYTE lpData;
|
||
DWORD dwBytesUsed;
|
||
|
||
// if averaging...
|
||
if (lpcs->lpia) {
|
||
int j;
|
||
|
||
iaverageZero (lpcs->lpia);
|
||
|
||
// sum together a bunch of frames
|
||
for (j = 0; j < (int)lpcs->sCapParms.wStepCaptureAverageFrames; j++) {
|
||
|
||
videoFrame( lpcs->hVideoIn, &lpcs->VidHdr2x);
|
||
|
||
// Shrink by 2x??
|
||
if (lpcs->sCapParms.fStepCaptureAt2x) {
|
||
CrunchDIB(
|
||
lpcs->lpia, // image averaging structure
|
||
(LPBITMAPINFOHEADER) lpcs->lpbmih2x, // BITMAPINFO src
|
||
(LPVOID) lpcs->VidHdr2x.lpData, // input bits
|
||
(LPBITMAPINFOHEADER) lpcs->lpBitsInfo, // BITMAPINFO dst
|
||
(LPVOID) lpcs->VidHdr.lpData); // output bits
|
||
}
|
||
iaverageSum (lpcs->lpia, lpcs->lpBits);
|
||
}
|
||
iaverageDivide (lpcs->lpia, lpcs->lpBits);
|
||
}
|
||
// otherwise, not averaging, just get a frame
|
||
else {
|
||
videoFrame( lpcs->hVideoIn, &lpcs->VidHdr);
|
||
}
|
||
fKeyFrame = lpVidHdr->dwFlags & VHDR_KEYFRAME;
|
||
|
||
#ifdef NEW_COMPMAN
|
||
//
|
||
// If we are automatically compressing during capture
|
||
// compress the frame before we write it
|
||
//
|
||
if (lpcs->CompVars.hic)
|
||
{
|
||
LPRIFF priff;
|
||
|
||
dwBytesUsed = 0;
|
||
lpData = ICSeqCompressFrame(&lpcs->CompVars, 0,
|
||
lpVidHdr->lpData,
|
||
&fKeyFrame,
|
||
&dwBytesUsed);
|
||
|
||
// so what if compression fails??
|
||
|
||
priff = ((LPRIFF)lpData) -1;
|
||
priff->dwType = MAKEAVICKID(cktypeDIBbits, 0);
|
||
priff->dwSize = dwBytesUsed;
|
||
} else
|
||
#endif // NEW_COMPMAN
|
||
{
|
||
lpData = lpVidHdr->lpData;
|
||
dwBytesUsed = lpVidHdr->dwBytesUsed;
|
||
}
|
||
|
||
if (lpcs->CallbackOnVideoFrame)
|
||
lpcs->CallbackOnVideoFrame(lpcs->hwnd, &lpcs->VidHdr);
|
||
|
||
// Update the display
|
||
InvalidateRect(lpcs->hwnd, NULL, TRUE);
|
||
UpdateWindow(lpcs->hwnd);
|
||
|
||
if (lpcs->fCaptureFlags & CAP_fCapturingToDisk) {
|
||
UINT wError;
|
||
BOOL bPending;
|
||
if (!AVIWriteVideoFrame (lpcs,
|
||
lpData,
|
||
dwBytesUsed,
|
||
fKeyFrame,
|
||
(UINT)-1, 0, &wError, &bPending)) {
|
||
fStopping = TRUE;
|
||
if (wError)
|
||
{
|
||
fOK = FALSE;
|
||
errorUpdateError(lpcs, wError);
|
||
}
|
||
assert (!bPending);
|
||
}
|
||
} // endif fCapturingToDisk
|
||
// Warning: Kludge to create frame chunk count when net capture
|
||
// follows.
|
||
else
|
||
lpcs->dwVideoChunkCount++;
|
||
|
||
// if there is still more time, (or at least every 100 frames)
|
||
// show status if we're not ending the capture
|
||
if ((!fStopping) && (lpcs->fCaptureFlags & CAP_fCapturingToDisk) &&
|
||
(lpcs->dwVideoChunkCount)) {
|
||
|
||
// "Captured %ld frames (Dropped %ld) %d.%03d sec. Hit Escape to Stop"
|
||
statusUpdateStatus(lpcs, IDS_CAP_STAT_VIDEOCURRENT,
|
||
lpcs->dwVideoChunkCount, lpcs->dwFramesDropped,
|
||
(int)(lpcs->dwTimeElapsedMS/1000),
|
||
(int)(lpcs->dwTimeElapsedMS%1000)
|
||
);
|
||
} // endif next buffer not ready
|
||
|
||
// Move the MCI source to the next capture point
|
||
// unfreeze video
|
||
MCIDeviceFreeze(lpcs, FALSE);
|
||
for (;;) {
|
||
MCIDeviceGetPosition (lpcs, &lpcs->dwMCICurrentMS);
|
||
if (lpcs->dwMCICurrentMS > ((DWORD) (lpcs->dwMCIActualStartMS +
|
||
MulDiv (lpcs->dwVideoChunkCount,
|
||
lpcs->sCapParms.dwRequestMicroSecPerFrame,
|
||
1000L))))
|
||
break;
|
||
MCIDeviceStep (lpcs, TRUE);
|
||
}
|
||
// freeze video
|
||
MCIDeviceFreeze(lpcs, TRUE);
|
||
lpcs->dwTimeElapsedMS =
|
||
lpcs->dwMCICurrentMS - lpcs->dwMCIActualStartMS;
|
||
|
||
/* return the emptied buffer to the que */
|
||
lpVidHdr->dwFlags &= ~VHDR_DONE;
|
||
}
|
||
|
||
if (lpcs->CallbackOnYield) {
|
||
// If the yield callback returns FALSE, abort
|
||
if ( ! lpcs->CallbackOnYield(lpcs->hwnd))
|
||
fStopping = TRUE;
|
||
}
|
||
|
||
if (lpcs->sCapParms.fYield) {
|
||
MSG msg;
|
||
|
||
if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) {
|
||
// Kludge to get rid of timers from lpcs->hwnd
|
||
if (msg.message == WM_TIMER && msg.hwnd == lpcs->hwnd)
|
||
;
|
||
else {
|
||
TranslateMessage(&msg);
|
||
DispatchMessage(&msg);
|
||
}
|
||
}
|
||
}
|
||
|
||
// -------------------------------------------------------
|
||
// Is audio buffer ready to be written?
|
||
// -------------------------------------------------------
|
||
if (lpcs->sCapParms.fCaptureAudio &&
|
||
(lpcs->MCICaptureState == CAPMCI_STATE_CapturingAudio ||
|
||
lpcs->MCICaptureState == CAPMCI_STATE_StartAudio ||
|
||
lpcs->MCICaptureState == CAPMCI_STATE_AudioFini)) {
|
||
int iLastWave;
|
||
|
||
//
|
||
// we may need to yield for audio to get converted.
|
||
//
|
||
if (lpcs->fAudioYield)
|
||
Yield();
|
||
|
||
//
|
||
// if all buffers are done, we have broke audio.
|
||
//
|
||
iLastWave = lpcs->iNextWave == 0 ?
|
||
lpcs->iNumAudio -1 : lpcs->iNextWave-1;
|
||
|
||
if (!fStopping &&
|
||
lpcs->alpWaveHdr[iLastWave]->dwFlags & WHDR_DONE)
|
||
lpcs->fAudioBreak = TRUE;
|
||
|
||
iNumAudio = lpcs->iNumAudio; // don't get stuck here forever...
|
||
// We should probably assert that iNumAudio is >= 0...
|
||
|
||
while (iNumAudio && fOK && (lpWaveHdr->dwFlags & WHDR_DONE)) {
|
||
iNumAudio--;
|
||
if (lpWaveHdr->dwBytesRecorded) {
|
||
/* Chunk info is included in the wave data */
|
||
/* Reset Chunk Size in buffer */
|
||
((LPRIFF)(lpWaveHdr->lpData))[-1].dwSize =
|
||
lpWaveHdr->dwBytesRecorded;
|
||
if (lpcs->CallbackOnWaveStream) {
|
||
lpcs->CallbackOnWaveStream(lpcs->hwnd, lpWaveHdr);
|
||
}
|
||
if (lpcs->fCaptureFlags & CAP_fCapturingToDisk) {
|
||
BOOL bPending = FALSE;
|
||
UINT wError;
|
||
|
||
if(!AVIWriteAudio(lpcs, lpWaveHdr, lpcs->iNextWave, &wError, &bPending)) {
|
||
fStopping = TRUE;
|
||
if (wError) {
|
||
fOK = FALSE;
|
||
errorUpdateError (lpcs, wError);
|
||
}
|
||
}
|
||
} // endif capturing to disk
|
||
// Warning: Kludge to create wave chunk count when net capture
|
||
// follows.
|
||
else {
|
||
lpcs->dwWaveChunkCount++;
|
||
lpcs->dwWaveBytes += lpWaveHdr->dwBytesRecorded;
|
||
}
|
||
} // endif dwBytesRecorded
|
||
|
||
lpWaveHdr->dwBytesRecorded = 0;
|
||
lpWaveHdr->dwFlags &= ~WHDR_DONE;
|
||
|
||
/* return the emptied buffer to the device que */
|
||
if(waveInAddBuffer(lpcs->hWaveIn, lpWaveHdr, sizeof(WAVEHDR))) {
|
||
fOK = FALSE;
|
||
fStopping = TRUE;
|
||
errorUpdateError(lpcs, IDS_CAP_WAVE_ADD_ERROR);
|
||
}
|
||
|
||
/* increment the next wave buffer pointer */
|
||
if(++lpcs->iNextWave >= lpcs->iNumAudio)
|
||
lpcs->iNextWave = 0;
|
||
|
||
lpWaveHdr = lpcs->alpWaveHdr[lpcs->iNextWave];
|
||
|
||
} // endwhile buffer available
|
||
} // endif sound enabled
|
||
} // end of forever
|
||
|
||
CompressFrameFailure:
|
||
|
||
iaverageFini (lpcs->lpia);
|
||
|
||
// Switch back to the normal format
|
||
if (lpcs->sCapParms.fStepCaptureAt2x) {
|
||
SendDriverFormat (lpcs, (LPBITMAPINFOHEADER) lpcs->lpBitsInfo,
|
||
sizeof (BITMAPINFOHEADER));
|
||
GlobalFreePtr (lpcs->VidHdr2x.lpData);
|
||
lpcs->VidHdr2x.lpData = NULL;
|
||
}
|
||
|
||
// And free the 2x memory
|
||
if (lpcs->lpbmih2x) {
|
||
GlobalFreePtr (lpcs->lpbmih2x);
|
||
lpcs->lpbmih2x = NULL;
|
||
}
|
||
|
||
// -------------------------------------------------------
|
||
// END OF MAIN CAPTURE LOOP
|
||
// -------------------------------------------------------
|
||
|
||
lpcs->dwTimeElapsedMS = lpcs->dwMCIActualEndMS - lpcs->dwMCIActualStartMS;
|
||
|
||
/* eat any keys that have been pressed */
|
||
while(GetKey(FALSE))
|
||
;
|
||
|
||
AVIFini(lpcs); // does the Reset, and frees all buffers
|
||
AVIFileFini(lpcs, TRUE /* fWroteJunkChunks */, FALSE /* fAbort */);
|
||
|
||
|
||
/* Notify if there was an error while recording */
|
||
|
||
if(!fOK) {
|
||
dprintf("Replacing error %x with %x (IDS_CAP_RECORDING_ERROR)\n", lpcs->dwReturn, IDS_CAP_RECORDING_ERROR);
|
||
errorUpdateError (lpcs, IDS_CAP_RECORDING_ERROR);
|
||
}
|
||
|
||
if (lpcs->fCaptureFlags & CAP_fCapturingToDisk) {
|
||
if (lpcs->dwVideoChunkCount)
|
||
dw = MulDiv(lpcs->dwVideoChunkCount,1000000,lpcs->dwTimeElapsedMS);
|
||
else
|
||
dw = 0; // The MulDiv doesn't give 0 if numerator is zero
|
||
|
||
if(lpcs->sCapParms.fCaptureAudio) {
|
||
// "Captured %d.%03d sec. %ld frames (%d dropped) (%d.%03d fps). %ld audio bytes (%d.%03d sps)"
|
||
statusUpdateStatus(lpcs, IDS_CAP_STAT_VIDEOAUDIO,
|
||
(UINT)(lpcs->dwTimeElapsedMS/1000),
|
||
(UINT)(lpcs->dwTimeElapsedMS%1000),
|
||
lpcs->dwVideoChunkCount,
|
||
lpcs->dwFramesDropped,
|
||
(UINT)(dw / 1000),
|
||
(UINT)(dw % 1000),
|
||
lpcs->dwWaveBytes,
|
||
(UINT) lpcs->lpWaveFormat->nSamplesPerSec / 1000,
|
||
(UINT) lpcs->lpWaveFormat->nSamplesPerSec % 1000);
|
||
} else {
|
||
// "Captured %d.%03d sec. %ld frames (%d dropped) (%d.%03d fps)."
|
||
statusUpdateStatus(lpcs, IDS_CAP_STAT_VIDEOONLY,
|
||
(UINT)(lpcs->dwTimeElapsedMS/1000),
|
||
(UINT)(lpcs->dwTimeElapsedMS%1000),
|
||
lpcs->dwVideoChunkCount,
|
||
lpcs->dwFramesDropped,
|
||
(UINT)(dw / 1000),
|
||
(UINT)(dw % 1000));
|
||
}
|
||
} // endif capturing to disk (no warnings or errors if to net)
|
||
|
||
if (fOK) {
|
||
// No frames captured, warn user that interrupts are probably not enabled.
|
||
if (lpcs->dwVideoChunkCount == 0) {
|
||
errorUpdateError (lpcs, IDS_CAP_NO_FRAME_CAP_ERROR);
|
||
}
|
||
// No audio captured, (but enabled), warn user audio card is hosed
|
||
else if (lpcs->sCapParms.fCaptureAudio && (lpcs->dwWaveBytes == 0)) {
|
||
errorUpdateError (lpcs, IDS_CAP_NO_AUDIO_CAP_ERROR);
|
||
}
|
||
|
||
// Audio underrun, inform user
|
||
else if (lpcs->sCapParms.fCaptureAudio && lpcs->fAudioBreak) {
|
||
if(lpcs->CompVars.hic) {
|
||
errorUpdateError (lpcs, IDS_CAP_AUDIO_DROP_COMPERROR);
|
||
} else {
|
||
errorUpdateError (lpcs, IDS_CAP_AUDIO_DROP_ERROR);
|
||
}
|
||
}
|
||
|
||
// If frames dropped, or changed capture rate, warn the user
|
||
else if (lpcs->dwVideoChunkCount && (lpcs->fCaptureFlags & CAP_fCapturingToDisk)) {
|
||
|
||
// Warn user if dropped > 10% (default) of the frames
|
||
if ((DWORD)100 * lpcs->dwFramesDropped / lpcs->dwVideoChunkCount >
|
||
lpcs->sCapParms.wPercentDropForError) {
|
||
|
||
// "%d of %ld frames (%d.%03d\%) dropped during capture."
|
||
errorUpdateError (lpcs, IDS_CAP_STAT_FRAMESDROPPED,
|
||
lpcs->dwFramesDropped,
|
||
lpcs->dwVideoChunkCount,
|
||
(UINT)(MulDiv(lpcs->dwFramesDropped,10000,lpcs->dwVideoChunkCount)/100),
|
||
(UINT)(MulDiv(lpcs->dwFramesDropped,10000,lpcs->dwVideoChunkCount)%100)/10
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
EarlyExit:
|
||
|
||
//
|
||
// If we were compressing while capturing, close it down
|
||
//
|
||
#ifdef NEW_COMPMAN
|
||
if (lpcs->CompVars.hic) {
|
||
// Kludge, reset the lpBitsOut pointer
|
||
if (lpcs->CompVars.lpBitsOut)
|
||
((LPBYTE) lpcs->CompVars.lpBitsOut) -= 8;
|
||
ICSeqCompressFrameEnd(&lpcs->CompVars);
|
||
}
|
||
#endif
|
||
|
||
if (fTryToPaint) {
|
||
if (hpalT)
|
||
SelectPalette(hdc, hpalT, FALSE);
|
||
ReleaseDC (lpcs->hwnd, hdc);
|
||
}
|
||
|
||
if (lpcs->sCapParms.fMCIControl)
|
||
MCIDeviceClose (lpcs);
|
||
|
||
// Let the user see where capture stopped
|
||
if ((!lpcs->fLiveWindow) && (!lpcs->fOverlayWindow))
|
||
videoFrame( lpcs->hVideoIn, &lpcs->VidHdr );
|
||
InvalidateRect( lpcs->hwnd, NULL, TRUE);
|
||
|
||
lpcs->fCapFileExists = (lpcs->dwReturn == DV_ERR_OK);
|
||
lpcs->fCaptureFlags &= ~CAP_fCapturingNow;
|
||
lpcs->fCaptureFlags &= ~CAP_fStepCapturingNow;
|
||
|
||
statusUpdateStatus(lpcs, IDS_CAP_END); // Always the last message
|
||
|
||
return;
|
||
}
|
||
|