windows-xp/Source/XPSP1/NT/multimedia/media/avi/avicap.16/capavi.c

/****************************************************************************
 *
 *   capavi.c
 *
 *   Main video capture module.
 *
 *   Microsoft Video for Windows Sample Capture Class
 *
 *   Copyright (c) 1992, 1993 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.
 *
 ***************************************************************************/

#include <windows.h>
#include <windowsx.h>
#include <mmsystem.h>
#include <memory.h>         // for _fmemset
#include <msvideo.h>
#include <drawdib.h>
#include <mmreg.h>
#include <mmddk.h>
#include <msacm.h>
#include <avifmt.h>
#include "avicap.h"
#include "avicapi.h"
#include "time.h"

time_t      ltime;

extern void NEAR PASCAL MemCopy(LPVOID, LPVOID, DWORD); // in memcopy.asm
extern WORD FAR PASCAL SmartDrv(char chDrive, WORD w);
extern WORD GetSizeOfWaveFormat (LPWAVEFORMATEX lpwf);

/* dialog function prototype */
LONG FAR PASCAL _export capseqDlgProc(HWND hwnd, unsigned msg, WORD wParam, LONG lParam);

#ifdef _DEBUG
    #define DSTATUS(lpcs, sz) statusUpdateStatus(lpcs, IDS_CAP_INFO, (LPSTR) sz)
#else
    #define DSTATUS(lpcs, sz)
#endif

///////////////////////////////////////////////////////////////////////////
//  The index array is used to record the positions
//  of every chunk in the RIFF (avi) file.
//
//  what this array is:
//
//      each entry contains the size of the data
//      high order bits encode the type of data (audio / video)
//      and whether the video chunk is a key frame, dropped frame, etc.
///////////////////////////////////////////////////////////////////////////

// The following are anded with the size in the index
#define IS_AUDIO_CHUNK        0x80000000
#define IS_KEYFRAME_CHUNK     0x40000000
#define IS_DUMMY_CHUNK        0x20000000
#define IS_LAST_DUMMY_CHUNK   0x10000000
#define INDEX_MASK  (IS_AUDIO_CHUNK | IS_KEYFRAME_CHUNK | IS_DUMMY_CHUNK | IS_LAST_DUMMY_CHUNK)


// Allocate the index table
// Returns: TRUE if index can be allocated
BOOL InitIndex (LPCAPSTREAM lpcs)
{
    lpcs->dwIndex = 0;

    WinAssert (lpcs->lpdwIndexStart == NULL);

    // Limit index size between 1 minute at 30fps and 3 hours at 30fps
    lpcs->sCapParms.dwIndexSize = max (lpcs->sCapParms.dwIndexSize, 1800);
    lpcs->sCapParms.dwIndexSize = min (lpcs->sCapParms.dwIndexSize, 324000L);
    dprintf("Max Index Size = %ld \n", lpcs->sCapParms.dwIndexSize);

    if (lpcs->hIndex = GlobalAlloc (GMEM_MOVEABLE,
                lpcs->sCapParms.dwIndexSize * sizeof (DWORD))) {
        if (lpcs->lpdwIndexEntry =
                lpcs->lpdwIndexStart =
                (DWORD _huge *)GlobalLock (lpcs->hIndex)) {
            GlobalPageLock (lpcs->hIndex);
            return TRUE;        // Success
        }
        GlobalFree (lpcs->hIndex);
    }
    lpcs->hIndex = NULL;
    lpcs->lpdwIndexStart = NULL;
    return FALSE;
}

// Deallocate the index table
void FiniIndex (LPCAPSTREAM lpcs)
{
    if (lpcs->hIndex) {
        GlobalPageUnlock (lpcs->hIndex);
        if (lpcs->lpdwIndexStart)
            GlobalUnlock (lpcs->hIndex);
        GlobalFree (lpcs->hIndex);
    }
    lpcs->hIndex = NULL;
    lpcs->lpdwIndexStart = NULL;
}


// Add an index entry for a video frame
// dwSize is the size of data ONLY, not including the chunk or junk
// Returns: TRUE if index space is not exhausted
BOOL IndexVideo (LPCAPSTREAM lpcs, DWORD dwSize, BOOL bKeyFrame)
{
    BOOL fOK = lpcs->dwIndex < lpcs->sCapParms.dwIndexSize;

    if (fOK) {
        *lpcs->lpdwIndexEntry++ = dwSize | (bKeyFrame ? IS_KEYFRAME_CHUNK : 0);
        lpcs->dwIndex++;
        lpcs->dwVideoChunkCount++;
    }
    return (fOK);
}


// Add an index entry for an audio buffer
// dwSize is the size of data ONLY, not including the chunk or junk
// Returns: TRUE if index space is not exhausted
BOOL IndexAudio (LPCAPSTREAM lpcs, DWORD dwSize)
{
    BOOL fOK = lpcs->dwIndex < lpcs->sCapParms.dwIndexSize;

    if (fOK) {
        *lpcs->lpdwIndexEntry++ = dwSize | IS_AUDIO_CHUNK;
        lpcs->dwIndex++;
        lpcs->dwWaveChunkCount++;
    }
    return (fOK);
}


// Write out the index at the end of the capture file.
// The single frame capture methods do not append
// JunkChunks!  Audio chunks do not have junk appended.
BOOL WriteIndex (LPCAPSTREAM lpcs, BOOL fJunkChunkWritten)
{
    BOOL  fChunkIsAudio;
    BOOL  fChunkIsKeyFrame;
    BOOL  fChunkIsDummy;
    BOOL  fChunkIsLastDummy;
    DWORD dwIndex;
    DWORD dw;
    DWORD dwDummySize;
    DWORD dwJunk;
    DWORD off;
    AVIINDEXENTRY   avii;
    MMCKINFO    ck;
    DWORD _huge *lpdw;

    if (lpcs->dwIndex > lpcs->sCapParms.dwIndexSize)
        return TRUE;

    off        = lpcs->dwAVIHdrSize;

    ck.cksize  = 0;
    ck.ckid    = ckidAVINEWINDEX;
    ck.fccType = 0;

    if (mmioCreateChunk(lpcs->hmmio,&ck,0))
        return FALSE;

    lpdw = lpcs->lpdwIndexStart;
    for (dwIndex= 0; dwIndex< lpcs->dwIndex; dwIndex++) {

        dw = *lpdw++;

        fChunkIsAudio      = (BOOL) ((dw & IS_AUDIO_CHUNK) != 0);
        fChunkIsKeyFrame   = (BOOL) ((dw & IS_KEYFRAME_CHUNK) != 0);
        fChunkIsDummy      = (BOOL) ((dw & IS_DUMMY_CHUNK) != 0);
        fChunkIsLastDummy  = (BOOL) ((dw & IS_LAST_DUMMY_CHUNK) != 0);
        dw &= ~(INDEX_MASK);

        if (fChunkIsAudio) {
            avii.ckid         = MAKEAVICKID(cktypeWAVEbytes, 1);
            avii.dwFlags      = 0;
        } else {
        if (lpcs->lpBitsInfo->bmiHeader.biCompression == BI_RLE8)
            avii.ckid         = MAKEAVICKID(cktypeDIBcompressed, 0);
        else
            avii.ckid         = MAKEAVICKID(cktypeDIBbits, 0);
            avii.dwFlags      = fChunkIsKeyFrame ? AVIIF_KEYFRAME : 0;
        }
        avii.dwChunkLength    = dw;
        avii.dwChunkOffset    = off;

        if (mmioWrite(lpcs->hmmio, (LPVOID)&avii, sizeof(avii)) != sizeof(avii))
            return FALSE;

        dw += sizeof (RIFF);
        off += dw;

        // ooh, getting messy. We know that dummy chunks come in a group
        // (1 or more) and are always terminated by a IS_LAST_DUMMY_CHUNK flag.
        // only the last one gets junk append to round out to 2K
        if (fChunkIsDummy) {
            dwDummySize += sizeof(RIFF);
            if (!fChunkIsLastDummy)
                continue;
            else
                dw = dwDummySize;   // total size of all dummy entries in group
        }
        else
            dwDummySize = 0;

        if (fJunkChunkWritten & !fChunkIsAudio) {
           // If a Junk chunk was appended, move past it
           if (dw % lpcs->sCapParms.wChunkGranularity) {
                dwJunk = lpcs->sCapParms.wChunkGranularity - (dw % lpcs->sCapParms.wChunkGranularity);

                if (dwJunk < sizeof (RIFF))
                    off += lpcs->sCapParms.wChunkGranularity + dwJunk;
                else
                    off += dwJunk;
           }
        }

         if (off & 1)
             off++;
    }

    if (mmioAscend(lpcs->hmmio, &ck, 0))
        return FALSE;

    return TRUE;
}



// Allocate DOS memory for faster disk writes
LPVOID NEAR PASCAL AllocDosMem (DWORD dw)
{
    HANDLE h;

    if (h = LOWORD (GlobalDosAlloc(dw)))
        return (GlobalLock (h));
    return NULL;
}

// General purpose memory allocator
LPVOID NEAR PASCAL AllocMem (DWORD dw, BOOL fUseDOSMemory)
{
#if 0
    if (fUseDOSMemory)
        return AllocDosMem(dw);
#endif

    return GlobalAllocPtr (GMEM_MOVEABLE, dw);
}

void NEAR PASCAL FreeMem(LPVOID p)
{
    GlobalFreePtr(p);
}


#pragma optimize ("", off)

DWORD GetFreePhysicalMemory(void)
{
    DWORD   adw[ 0x30 / sizeof(DWORD) ];
    WORD    fFail;

    //
    //  if standard mode just ask KERNEL how much memory is free
    //
    //  if enhanced mode, call DPMI and find out how much *real*
    //  memory is free.
    //
    if (GetWinFlags() & WF_STANDARD)
    {
        return GetFreeSpace(0);
    }
    else _asm
    {
        mov     ax, 0500h
        push    ss
        pop     es
        lea     di, word ptr adw
        int     31h
        sbb     ax, ax
        mov     fFail, ax
    }

    if (fFail)
        return (0l);

    return (adw[2] * 4096);
}
#pragma optimize ("", on)

/*
 *  CalcWaveBufferSize   - Figure out how large to make the wave buffers
 *    a. At least .5 seconds
 *    b. But not less than 10K, (else capture frmae rate suffers)
 *    c. A multiple of lpcs->sCapParms.wChunkGranularity
 */
DWORD CalcWaveBufferSize (LPCAPSTREAM lpcs)
{
    DWORD dw;

    if (!lpcs-> lpWaveFormat)
        return 0L;

    // at least .5 second
    dw = (DWORD) lpcs->lpWaveFormat->nChannels *
         (DWORD) lpcs->lpWaveFormat->nSamplesPerSec *
         (lpcs->lpWaveFormat->wBitsPerSample / 8) / 2L;
    dw -= dw % lpcs->sCapParms.wChunkGranularity;
    dw = max ((1024L * 10), dw);                // at least 10K

//    dprintf("Wave buffer size = %ld \n", dw);
    return dw;
}

static BOOL IsWaveInDeviceMapped(HWAVEIN hWaveIn)
{
    DWORD err;
    DWORD dw;

    err = waveInMessage(hWaveIn,
        WIDM_MAPPER_STATUS,
        WAVEIN_MAPPER_STATUS_MAPPED,
        (DWORD)(LPVOID)&dw);

    return err == 0 && dw != 0;
}

// ****************************************************************
// ******************** Capture File Routines *********************
// ****************************************************************


/*
 * AVIFileInit
 *
 *       Perform all initialization required to write a capture file.
 *
 *       We take a slightly strange approach: We don't write
 *       out the header until we're done capturing.  For now,
 *       we just seek 2K into the file, which is where all of
 *       the real data will go.
 *
 *       When we're done, we'll come back and write out the header,
 *       because then we'll know all of the values we need.
 *
 *      Also allocate and init the index.
 */
BOOL AVIFileInit(LPCAPSTREAM lpcs)
{
#define TEMP_BUFF_SIZE  128
    LONG l;
    char ach[TEMP_BUFF_SIZE];
    LPBITMAPINFO lpBitsInfoOut;    // Possibly compressed output format

    /* No special video format given -- use the default */
    if (lpcs->CompVars.hic == NULL)
	lpBitsInfoOut = lpcs->lpBitsInfo;
    else
	lpBitsInfoOut = lpcs->CompVars.lpbiOut;

    WinAssert (lpcs->hmmio == NULL);   // Should never have a file handle on entry

    /* if the capture file has not been set then set it now */
    if (!(*lpcs->achFile)){
//       if (!fileSetCapFile())
             goto INIT_FILE_OPEN_ERROR;
    }

    /* we have a capture file, open it and set it up */
    lpcs->hmmio = mmioOpen(lpcs->achFile, NULL, MMIO_WRITE);
    if (!lpcs->hmmio) {
         /* try and create */
         lpcs->hmmio = mmioOpen(lpcs->achFile, NULL, MMIO_CREATE | MMIO_WRITE);
         if (!lpcs->hmmio) {
             goto INIT_FILE_OPEN_ERROR;
         }
    }

    /* pre-read the file */
    l = mmioSeek( lpcs->hmmio, 0L, SEEK_END );
    while( l > 0 ) {
         l = mmioSeek( lpcs->hmmio, -min(l, 50000L), SEEK_CUR );
        mmioRead( lpcs->hmmio, ach, sizeof(ach) );
    }

    /* Seek to 2K (or multiple of 2K), where we're going to write our data.
    ** later, we'll come back and fill in the file.
    */

    // l is zero for standard wave and video formats
    l = (GetSizeOfWaveFormat ((LPWAVEFORMATEX) lpcs->lpWaveFormat) -
                sizeof (PCMWAVEFORMAT)) +
                (lpBitsInfoOut->bmiHeader.biSize -
                sizeof (BITMAPINFOHEADER));

    // (2K + size of wave and video stream headers) rounded to next 2K
    lpcs->dwAVIHdrSize = AVI_HEADERSIZE +
        (((lpcs->cbInfoChunks + l + lpcs->sCapParms.wChunkGranularity - 1)
        / lpcs->sCapParms.wChunkGranularity) * lpcs->sCapParms.wChunkGranularity);


    dprintf("AVIHdrSize = %ld \n", lpcs->dwAVIHdrSize);
    mmioSeek(lpcs->hmmio, lpcs->dwAVIHdrSize, SEEK_SET);

    if (!InitIndex (lpcs))           // do all Index allocations
        mmioClose (lpcs->hmmio, 0);

    lpcs->dwVideoChunkCount = 0;
    lpcs->dwWaveChunkCount = 0;

INIT_FILE_OPEN_ERROR:
    return (lpcs->hmmio != NULL);
}

/*
 * AVIFileFini
 *
 *       Write out the index, deallocate the index, and close the file.
 *
 */
BOOL AVIFileFini (LPCAPSTREAM lpcs, BOOL fWroteJunkChunks, BOOL fAbort)
{
    MMCKINFO      ckRiff;
    MMCKINFO      ckList;
    MMCKINFO      ckStream;
    MMCKINFO      ck;
    int           i;
    DWORD         dw;
    AVIStreamHeader        strhdr;
    DWORD         dwDataEnd;
    BOOL        fRet = TRUE;
    RGBQUAD     argbq[256];
    MainAVIHeader   aviHdr;
    BOOL        fSound = lpcs->sCapParms.fCaptureAudio;
    LPBITMAPINFO lpBitsInfoOut;    // Possibly compressed output format

    /* No special video format given -- use the default */
    if (lpcs->CompVars.hic == NULL)
	lpBitsInfoOut = lpcs->lpBitsInfo;
    else
	lpBitsInfoOut = lpcs->CompVars.lpbiOut;

    if (lpcs->hmmio == NULL)  // This can be called even though never opened
        return FALSE;

    if (fAbort)
        goto FileError;

    if (!lpcs->dwWaveBytes)
        fSound = FALSE;

    dwDataEnd = mmioSeek(lpcs->hmmio, 0, SEEK_CUR);

    /* Seek to beginning of file, so we can write the header. */
    mmioSeek(lpcs->hmmio, 0, SEEK_SET);

    DSTATUS(lpcs, "Writing AVI header");

    /* Create RIFF chunk */
    ckRiff.cksize = 0;
    ckRiff.fccType = formtypeAVI;
    if(mmioCreateChunk(lpcs->hmmio,&ckRiff,MMIO_CREATERIFF)) {
         goto FileError;
    }

    /* Create header list */
    ckList.cksize = 0;
    ckList.fccType = listtypeAVIHEADER;
    if(mmioCreateChunk(lpcs->hmmio,&ckList,MMIO_CREATELIST)) {
         goto FileError;
    }

    /* Create AVI header chunk */
    ck.cksize = sizeof(MainAVIHeader);
    ck.ckid = ckidAVIMAINHDR;
    if(mmioCreateChunk(lpcs->hmmio,&ck,0)) {
         goto FileError;
    }

    lpcs->dwAVIHdrPos = ck.dwDataOffset;

    /* Calculate AVI header info */
    _fmemset(&aviHdr, 0, sizeof(aviHdr));
    if (fSound && lpcs->dwVideoChunkCount) {
         /* HACK HACK */
         /* Set rate that was captured based on length of audio data */

         aviHdr.dwMicroSecPerFrame = (DWORD)
                ((double)lpcs->dwWaveBytes * 1000000. /
                ((double)lpcs->lpWaveFormat->nAvgBytesPerSec *
                lpcs->dwVideoChunkCount + 0.5));
    } else {
         aviHdr.dwMicroSecPerFrame = lpcs->sCapParms.dwRequestMicroSecPerFrame;
    }
    lpcs->dwActualMicroSecPerFrame = aviHdr.dwMicroSecPerFrame;

    aviHdr.dwMaxBytesPerSec = (DWORD) muldiv32 (lpBitsInfoOut->bmiHeader.biSizeImage,
                                      1000000,
                                      lpcs->sCapParms.dwRequestMicroSecPerFrame) +
                                      (fSound ? lpcs->lpWaveFormat->nAvgBytesPerSec : 0);
    aviHdr.dwPaddingGranularity = 0L;
    aviHdr.dwFlags = AVIF_WASCAPTUREFILE | AVIF_HASINDEX;
    aviHdr.dwStreams = fSound ? 2 : 1;
    aviHdr.dwTotalFrames = lpcs->dwVideoChunkCount;
    aviHdr.dwInitialFrames = 0L;
    aviHdr.dwSuggestedBufferSize = 0L;
    aviHdr.dwWidth = lpBitsInfoOut->bmiHeader.biWidth;
    aviHdr.dwHeight = lpBitsInfoOut->bmiHeader.biHeight;

//  The following were set for all versions before Chicago Beta2
//  They are now listed as reserved...
//    aviHdr.dwRate = 1000000L;
//    aviHdr.dwScale = aviHdr.dwMicroSecPerFrame;
//    aviHdr.dwStart = 0L;
//    aviHdr.dwLength = lpcs->dwVideoChunkCount;

    /* Write AVI header info */
    if(mmioWrite(lpcs->hmmio, (LPSTR)&aviHdr, sizeof(aviHdr)) !=
             sizeof(aviHdr)) {
         goto FileError;
    }

    if(mmioAscend(lpcs->hmmio, &ck, 0)) {
         goto FileError;
    }

    DSTATUS(lpcs, "Writing AVI Stream header");

    /* Create stream header list */
    ckStream.cksize = 0;
    ckStream.fccType = listtypeSTREAMHEADER;
    if(mmioCreateChunk(lpcs->hmmio,&ckStream,MMIO_CREATELIST)) {
         goto FileError;
    }

    _fmemset(&strhdr, 0, sizeof(strhdr));
    strhdr.fccType = streamtypeVIDEO;
    if (lpcs->CompVars.hic)
        strhdr.fccHandler = lpcs->CompVars.fccHandler;
    else
        strhdr.fccHandler = lpBitsInfoOut->bmiHeader.biCompression;

    // A bit of history...
    // In VFW 1.0, we set fccHandler to 0 for BI_RLE8 formats
    // as a kludge to make Mplayer and Videdit play the files.
    // Just prior to 1.1 release, we found this broke Premiere,
    // so now (after AVICAP beta is on Compuserve), we change the
    // fccHandler to "MRLE".  Just ask Todd...
    // And now, at RC1, we change it again to "RLE ", Just ask Todd...
    if (strhdr.fccHandler == BI_RLE8)
        strhdr.fccHandler = mmioFOURCC('R', 'L', 'E', ' ');

    strhdr.dwFlags = 0L;
    strhdr.wPriority = 0L;
    strhdr.wLanguage = 0L;
    strhdr.dwInitialFrames = 0L;
    strhdr.dwScale = aviHdr.dwMicroSecPerFrame;
    strhdr.dwRate = 1000000L;
    strhdr.dwStart = 0L;
    strhdr.dwLength = lpcs->dwVideoChunkCount;        /* Needs to get filled in! */
    strhdr.dwQuality = (DWORD) -1L;         /* !!! ICQUALITY_DEFAULT */
    strhdr.dwSampleSize = 0L;

    ck.ckid = ckidSTREAMHEADER;
    if(mmioCreateChunk(lpcs->hmmio,&ck,0)) {
         goto FileError;
    }

    /* Write stream header data */
    if(mmioWrite(lpcs->hmmio, (LPSTR)&strhdr, sizeof(strhdr)) != sizeof(strhdr)) {
         goto FileError;
    }

    if(mmioAscend(lpcs->hmmio, &ck, 0)) {
         goto FileError;
    }

    /*
    **  !!! dont write palette for full color?
    */
    if (lpBitsInfoOut->bmiHeader.biBitCount > 8)
        lpBitsInfoOut->bmiHeader.biClrUsed = 0;

    /* Create DIB header chunk */
    ck.cksize = lpBitsInfoOut->bmiHeader.biSize +
                           lpBitsInfoOut->bmiHeader.biClrUsed *
                           sizeof(RGBQUAD);
    ck.ckid = ckidSTREAMFORMAT;
    if(mmioCreateChunk(lpcs->hmmio,&ck,0)) {
         goto FileError;
    }

    /* Write DIB header data */
    if(mmioWrite(lpcs->hmmio, (LPSTR)&lpBitsInfoOut->bmiHeader,
                               lpBitsInfoOut->bmiHeader.biSize) !=
             (LONG) lpBitsInfoOut->bmiHeader.biSize) {
         goto FileError;
    }

    if (lpBitsInfoOut->bmiHeader.biClrUsed > 0) {
        /* Get Palette info */
        if(GetPaletteEntries(lpcs->hPalCurrent, 0,
                                (WORD) lpBitsInfoOut->bmiHeader.biClrUsed,
                                (LPPALETTEENTRY) argbq) !=
                    (WORD)lpBitsInfoOut->bmiHeader.biClrUsed) {
            goto FileError;
        }

        for(i = 0; i < (int) lpBitsInfoOut->bmiHeader.biClrUsed; i++)
            SWAP(argbq[i].rgbRed, argbq[i].rgbBlue);

        /* Write Palette Info */
        dw = sizeof(RGBQUAD) * lpBitsInfoOut->bmiHeader.biClrUsed;
        if (mmioWrite(lpcs->hmmio, (LPSTR)argbq, dw) != (long)dw) {
            goto FileError;
        }
    }

    if(mmioAscend(lpcs->hmmio, &ck, 0)) {
         goto FileError;
    }

    // ADD FOURCC stuff here!!! for Video stream

    /* Ascend out of stream header */
    if(mmioAscend(lpcs->hmmio, &ckStream, 0)) {
         goto FileError;
    }

    /* If sound is enabled, then write WAVE header */
    if(fSound) {

         /* Create stream header list */
         ckStream.cksize = 0;
         ckStream.fccType = listtypeSTREAMHEADER;
         if(mmioCreateChunk(lpcs->hmmio,&ckStream,MMIO_CREATELIST)) {
             goto FileError;
         }

         _fmemset(&strhdr, 0, sizeof(strhdr));
         strhdr.fccType = streamtypeAUDIO;
         strhdr.fccHandler = 0L;
         strhdr.dwFlags = 0L;
         strhdr.wPriority = 0L;
         strhdr.wLanguage = 0L;
         strhdr.dwInitialFrames = 0L;
         strhdr.dwScale = lpcs->lpWaveFormat->nBlockAlign;
         strhdr.dwRate = lpcs->lpWaveFormat->nAvgBytesPerSec;
         strhdr.dwStart = 0L;
         strhdr.dwLength =  lpcs->dwWaveBytes /
                        lpcs->lpWaveFormat->nBlockAlign;
         strhdr.dwQuality = (DWORD)-1L;    /* !!! ICQUALITY_DEFAULT */
         strhdr.dwSampleSize = lpcs->lpWaveFormat->nBlockAlign;

         ck.ckid = ckidSTREAMHEADER;
         if(mmioCreateChunk(lpcs->hmmio,&ck,0)) {
             goto FileError;
         }

         if(mmioWrite(lpcs->hmmio, (LPSTR)&strhdr, sizeof(strhdr)) != sizeof(strhdr)) {
             goto FileError;
         }

         if(mmioAscend(lpcs->hmmio, &ck, 0)) {
             goto FileError;
         }

         ck.cksize = (LONG) GetSizeOfWaveFormat ((LPWAVEFORMATEX) lpcs->lpWaveFormat);
         ck.ckid = ckidSTREAMFORMAT;
         if(mmioCreateChunk(lpcs->hmmio,&ck,0)) {
             goto FileError;
         }

         /* Write WAVE header info */
         if(mmioWrite(lpcs->hmmio, (LPSTR)lpcs->lpWaveFormat, ck.cksize) != (LONG) ck.cksize) {
             goto FileError;
         }

         if(mmioAscend(lpcs->hmmio, &ck, 0)) {
             goto FileError;
         }

         /* Ascend out of stream header */
         if(mmioAscend(lpcs->hmmio, &ckStream, 0)) {
             goto FileError;
         }

    }

    // ADD FOURCC stuff here!!! for entire file
    DSTATUS(lpcs, "Writing Info chunks");
    if (lpcs->lpInfoChunks) {
        DSTATUS(lpcs, "Writing Info chunks");
        if (mmioWrite (lpcs->hmmio, lpcs->lpInfoChunks, lpcs->cbInfoChunks) !=
                lpcs->cbInfoChunks)
            goto FileError;
    }

    /* ascend from the Header list */
    if(mmioAscend(lpcs->hmmio, &ckList, 0)) {
         goto FileError;
    }


    ck.ckid = ckidAVIPADDING;
    if(mmioCreateChunk(lpcs->hmmio,&ck,0)) {
         goto FileError;
    }

    mmioSeek(lpcs->hmmio, lpcs->dwAVIHdrSize - 3 * sizeof(DWORD), SEEK_SET);

    if(mmioAscend(lpcs->hmmio, &ck, 0)) {
         goto FileError;
    }

    DSTATUS(lpcs, "Writing Movie LIST");

    /* Start the movi list */
    ckList.cksize = 0;
    ckList.fccType = listtypeAVIMOVIE;
    if(mmioCreateChunk(lpcs->hmmio,&ckList,MMIO_CREATELIST)) {
         goto FileError;
    }

    // Force the chunk to end on the next word boundary
    mmioSeek(lpcs->hmmio, dwDataEnd + (dwDataEnd & 1L), SEEK_SET);

    /* Ascend out of the movi list and the RIFF chunk so that */
    /* the sizes can be fixed */
    mmioAscend(lpcs->hmmio, &ckList, 0);

    /*
    ** Now write index out!
    */
    DSTATUS(lpcs, "Writing Index...");
    WriteIndex(lpcs, fWroteJunkChunks);

    lpcs->fFileCaptured = TRUE;     // we got a good file, allow editing of it
    goto Success;

FileError:
    lpcs->fFileCaptured = fRet = FALSE;      // bogus file - no editing allowed

Success:
    DSTATUS(lpcs, "Freeing Index...");
    FiniIndex (lpcs);
    mmioAscend(lpcs->hmmio, &ckRiff, 0);

    mmioSeek(lpcs->hmmio, 0, SEEK_END);

    mmioFlush(lpcs->hmmio, 0);

    /* Close the file */
    mmioClose(lpcs->hmmio, 0);
    lpcs->hmmio = NULL;

    return fRet;
}


// ****************************************************************
// ******************** Audio Buffer Control **********************
// ****************************************************************

// Audio buffers are always allocated under the presumption that
// audio capture may be enabled at any time.
// AVIAudioInit must be matched with AVIAudioFini (both only called once)
// AVIAudioPrepare must be matched with AVIAudioUnPrepare
//      (which may be called multiple times to enable and disable audio)


// AVI AudioInit - Allocate and initialize buffers for audio capture.
//                 This routine is also used by MCI capture.
//                 Returns: 0 on success, otherwise an error code.

WORD AVIAudioInit (LPCAPSTREAM lpcs)
{
    int         i;
    LPVOID        p;

    if (lpcs->sCapParms.wNumAudioRequested == 0)
        lpcs->sCapParms.wNumAudioRequested = DEF_WAVE_BUFFERS;

    // Alloc the wave memory
    for(i = 0; i < (int)lpcs->sCapParms.wNumAudioRequested; i++) {

        p = AllocMem(sizeof(WAVEHDR) + lpcs->dwWaveSize, FALSE /* DOSMem */);

        if (p == NULL)
            break;

        lpcs->alpWaveHdr[i] = p;
        lpcs->alpWaveHdr[i]->lpData          = (LPBYTE)p
                                               + sizeof(WAVEHDR) + sizeof(RIFF);
        lpcs->alpWaveHdr[i]->dwBufferLength  = lpcs->dwWaveSize - sizeof(RIFF);
        lpcs->alpWaveHdr[i]->dwBytesRecorded = 0;
        lpcs->alpWaveHdr[i]->dwUser          = 0;
        lpcs->alpWaveHdr[i]->dwFlags         = 0;
        lpcs->alpWaveHdr[i]->dwLoops         = 0;

        /* Set Chunk ID, Size in buffer */
        p = (LPBYTE)p + sizeof(WAVEHDR);

        ((LPRIFF)p)->dwType = MAKEAVICKID(cktypeWAVEbytes, 1);
        ((LPRIFF)p)->dwSize = lpcs->dwWaveSize - sizeof(RIFF);
    }

    lpcs->iNumAudio = i;

    return ((lpcs->iNumAudio == 0) ? IDS_CAP_WAVE_ALLOC_ERROR : 0);
}


//
// AVI AudioFini    - UnPrepares headers and resets the wave device.
//                      This routine is also used by MCI capture.
//                      Returns: 0 on success, otherwise an error code.

WORD AVIAudioFini (LPCAPSTREAM lpcs)
{
    int i;

    /* free headers and data */
    for(i=0; i < MAX_WAVE_BUFFERS; i++) {
        if (lpcs->alpWaveHdr[i]) {
            FreeMem(lpcs->alpWaveHdr[i]);
            lpcs->alpWaveHdr[i] = NULL;
        }
    }

    return 0;
}


//
// AVI AudioPrepare - Opens the wave device and adds the buffers
//                    Prepares headers and adds buffers to the device
//                    This routine is also used by MCI capture.
//                    Returns: 0 on success, otherwise an error code.

WORD AVIAudioPrepare (LPCAPSTREAM lpcs, HWND hWndCallback)
{
    UINT        uiError;
    int i;

    /* See if we can open that format for input */

    uiError = waveInOpen((LPHWAVEIN)&lpcs->hWaveIn,
        (UINT)WAVE_MAPPER, lpcs->lpWaveFormat,
        (DWORD) hWndCallback, 0L,
        (hWndCallback ? CALLBACK_WINDOW : 0L));

    if (uiError != MMSYSERR_NOERROR)
        return IDS_CAP_WAVE_OPEN_ERROR;

    lpcs->fAudioYield = IsWaveInDeviceMapped(lpcs->hWaveIn);
    lpcs->fAudioBreak = FALSE;
    DPF("AVICap:    AudioYield = %d \n", lpcs->fAudioYield);

    for(i = 0; i < (int)lpcs->sCapParms.wNumAudioRequested; i++) {
        if (waveInPrepareHeader(lpcs->hWaveIn, lpcs->alpWaveHdr[i],
                sizeof(WAVEHDR)))
            return IDS_CAP_WAVE_ALLOC_ERROR;

        if (waveInAddBuffer(lpcs->hWaveIn, lpcs->alpWaveHdr[i],
                sizeof(WAVEHDR)))
            return IDS_CAP_WAVE_ALLOC_ERROR;
    }

    lpcs->iNextWave = 0;        // current wave
    lpcs->dwWaveBytes = 0L;     // number of wave bytes
    lpcs->dwWaveChunkCount = 0; // number of wave frames

    return 0;
}

//
// AVI AudioUnPrepare - UnPrepares headers and closes the wave device.
//                      This routine is also used by MCI capture.
//                      Returns: 0 on success, otherwise an error code.

WORD AVIAudioUnPrepare (LPCAPSTREAM lpcs)
{
    int i;

    if (lpcs->hWaveIn) {
        waveInReset(lpcs->hWaveIn);

        /* unprepare headers by unlocking them */
        for(i=0; i < lpcs->iNumAudio; i++) {
            if (lpcs->alpWaveHdr[i]) {
                if (lpcs->alpWaveHdr[i]->dwFlags & WHDR_PREPARED)
                    waveInUnprepareHeader(lpcs->hWaveIn, lpcs->alpWaveHdr[i],
                                sizeof(WAVEHDR));
            }
        }

        waveInClose(lpcs->hWaveIn);
        lpcs->hWaveIn = NULL;
    }
    return 0;
}

// ****************************************************************
// ******************** Video Buffer Control **********************
// ****************************************************************

// AVIVideoInit -  Allocates, and initialize buffers for video capture.
//                 This routine is also used by MCI capture.
//                 Returns: 0 on success, otherwise an error code.

WORD AVIVideoInit (LPCAPSTREAM lpcs)
{
    int         iMaxVideo;
    DWORD       dwFreeMem;
    DWORD       dwUserRequests;
    DWORD       dwAudioMem;
    int         i;
    LPVOID      p;

    lpcs->iNextVideo = 0;
    lpcs->dwVideoChunkCount = 0;
    lpcs->dwFramesDropped = 0;

    // When performing MCI step capture, buffer array is not used
    if (lpcs->sCapParms.fStepMCIDevice)
        return 0;

    // If the user hasn't specified the number of video buffers to use,
    // assume the minimum

    if (lpcs->sCapParms.wNumVideoRequested == 0)
        lpcs->sCapParms.wNumVideoRequested = MIN_VIDEO_BUFFERS;

    iMaxVideo = min (MAX_VIDEO_BUFFERS, lpcs->sCapParms.wNumVideoRequested);

    // Post VFW 1.1a, see if the driver can allocate memory
    if (videoStreamAllocHdrAndBuffer (lpcs->hVideoIn,
                (LPVIDEOHDR FAR *) &p, (DWORD) sizeof(VIDEOHDR) + lpcs->dwVideoSize)
                        == DV_ERR_OK) {
        lpcs-> fBuffersOnHardware = TRUE;
        videoStreamFreeHdrAndBuffer (lpcs->hVideoIn, (LPVIDEOHDR) p);
    }
    else {
        lpcs-> fBuffersOnHardware = FALSE;

        // How much actual free physical memory exists?
        dwFreeMem = GetFreePhysicalMemory();

        dwAudioMem = lpcs->dwWaveSize * lpcs->sCapParms.wNumAudioRequested;

#define FOREVER_FREE 32768L   // Always keep this free for swap space

        // How much memory will be used if we allocate per the request?
        dwUserRequests = dwAudioMem +
                     lpcs->dwVideoSize * iMaxVideo +
                     FOREVER_FREE;

        // If request is greater than available memory, force fewer buffers
        if (dwUserRequests > dwFreeMem) {
            if (dwFreeMem > dwAudioMem)
                dwFreeMem -= dwAudioMem;
            iMaxVideo = (int)(((dwFreeMem * 8) / 10) / lpcs->dwVideoSize);
            iMaxVideo = min (MAX_VIDEO_BUFFERS, iMaxVideo);
            dprintf("iMaxVideo = %d\n", iMaxVideo);
        }
    } // endif not allocating buffers from hardware

    // Set up the buffers presuming fixed size DIBs and Junk chunks
    // These will be modified later if the device provides compressed data

    for (i=0; i < iMaxVideo; i++) {

        if (lpcs-> fBuffersOnHardware)
            videoStreamAllocHdrAndBuffer (lpcs->hVideoIn,
                (LPVIDEOHDR FAR *) &p, sizeof(VIDEOHDR) + lpcs->dwVideoSize);
        else
            p = AllocMem(sizeof(VIDEOHDR) + lpcs->dwVideoSize, lpcs->sCapParms.fUsingDOSMemory /* DOSMem */);

        if (p == NULL)
            break;

        lpcs->alpVideoHdr[i] = p;
        lpcs->alpVideoHdr[i]->lpData          = (LPBYTE)p + sizeof(VIDEOHDR) + sizeof(RIFF);
        lpcs->alpVideoHdr[i]->dwBufferLength  = lpcs->lpBitsInfo->bmiHeader.biSizeImage;
        lpcs->alpVideoHdr[i]->dwBytesUsed     = 0;
        lpcs->alpVideoHdr[i]->dwTimeCaptured  = 0;
        lpcs->alpVideoHdr[i]->dwUser          = 0;
        // Buffers on hardware are marked prepared during allocation!
        if (!lpcs-> fBuffersOnHardware)
            lpcs->alpVideoHdr[i]->dwFlags     = 0;

        p = (LPBYTE)p + sizeof(VIDEOHDR);

        if (lpcs->lpBitsInfo->bmiHeader.biCompression == BI_RLE8)
             ((LPRIFF)p)->dwType = MAKEAVICKID(cktypeDIBcompressed, 0);
        else
             ((LPRIFF)p)->dwType = MAKEAVICKID(cktypeDIBbits, 0);
         ((LPRIFF)p)->dwSize = lpcs->lpBitsInfo->bmiHeader.biSizeImage;

         if(lpcs->dwVideoJunkSize) {
             p = ((BYTE huge *)p) + ((LPRIFF)p)->dwSize + sizeof(RIFF);

             ((LPRIFF)p)->dwType = ckidAVIPADDING;;
             ((LPRIFF)p)->dwSize = lpcs->dwVideoJunkSize;
         }
    }

    lpcs->iNumVideo = i;

    if (lpcs-> fBuffersOnHardware)
        dprintf("HARDWARE iNumVideo Allocated = %d \n", lpcs->iNumVideo);
    else if (lpcs->sCapParms.fUsingDOSMemory)
        dprintf("DOS iNumVideo Allocated = %d \n", lpcs->iNumVideo);
    else
        dprintf("HIGH iNumVideo Allocated = %d \n", lpcs->iNumVideo);

    return ((lpcs->iNumVideo == 0) ? IDS_CAP_VIDEO_ALLOC_ERROR : 0);
}

//
// AVIVideoPrepare -  Prepares headers and adds buffers to the device
//                    This routine is also used by MCI capture.
//                    Returns: 0 on success, otherwise an error code.
WORD AVIVideoPrepare (LPCAPSTREAM lpcs)
{
    int i;

    // When performing MCI step capture, buffer array is not used
    if (lpcs->sCapParms.fStepMCIDevice)
        return 0;

    // Open the video stream, setting the capture rate
    if (videoStreamInit(lpcs->hVideoIn,
                lpcs->sCapParms.dwRequestMicroSecPerFrame,
                0L, 0L, 0L )) {
        dprintf("cant open video device!\n");
        return IDS_CAP_VIDEO_OPEN_ERROR;
    }

    // Prepare (lock) the buffers, and give them to the device
    for (i=0; i < lpcs->iNumVideo; i++) {
        // If the buffers are on the hardware, don't Prepare them
        if (!lpcs-> fBuffersOnHardware) {
            if (videoStreamPrepareHeader (lpcs->hVideoIn,
                        lpcs->alpVideoHdr[i], sizeof(VIDEOHDR))) {
                lpcs->iNumVideo = i;
                dprintf("**** could only prepare %d Video!\n", lpcs->iNumVideo);
                break;
            }
        }

        if (videoStreamAddBuffer(lpcs->hVideoIn, lpcs->alpVideoHdr[i], sizeof(VIDEOHDR)))
             return IDS_CAP_VIDEO_ALLOC_ERROR;
    }
    return 0;
}

//
// AVI VideoUnPrepare - UnPrepares headers, frees memory, and
//                      resets the video in device.
//                      This routine is also used by MCI capture.
//                      Returns: 0 on success, otherwise an error code.

WORD AVIVideoUnPrepare (LPCAPSTREAM lpcs)
{
    int i;

    // When performing MCI step capture, buffer array is not used
    if (lpcs->sCapParms.fStepMCIDevice)
        return 0;

    /* Reset the buffers so they can be freed */
    if (lpcs->hVideoIn) {
        videoStreamReset(lpcs->hVideoIn);

        /* unprepare headers */
        /* Unlock and free headers and data */

        for(i = 0; i < MAX_VIDEO_BUFFERS; i++) {
            if (lpcs->alpVideoHdr[i]) {
                if (!lpcs-> fBuffersOnHardware) {
                    if (lpcs->alpVideoHdr[i]->dwFlags & VHDR_PREPARED)
                        videoStreamUnprepareHeader(lpcs->hVideoIn,
                            lpcs->alpVideoHdr[i],sizeof(VIDEOHDR));

                    FreeMem(lpcs->alpVideoHdr[i]);
                }
                else
                    videoStreamFreeHdrAndBuffer(lpcs->hVideoIn, lpcs->alpVideoHdr[i]);
                lpcs->alpVideoHdr[i] = NULL;
            }
        }
        // Shut down the video stream
        videoStreamFini(lpcs->hVideoIn);
    }
    return 0;
}

/*
 *  AVI Fini    - undo the mess that AVIInit did.
 *
 */
void AVIFini(LPCAPSTREAM lpcs)
{
    if (lpcs->lpDOSWriteBuffer) {
        FreeMem(lpcs->lpDOSWriteBuffer);
        lpcs->lpDOSWriteBuffer = NULL;
    }

    AVIVideoUnPrepare (lpcs);           // Free the video device and buffers

    AVIAudioUnPrepare (lpcs);           // Free the audio device
    AVIAudioFini (lpcs);                // Free the audio buffers
}

//
// AVI Init
//     This routine does all the non-File initalization for AVICapture.
//     Returns: 0 on success, Error string value on failure.
//

WORD AVIInit (LPCAPSTREAM lpcs)
{
    WORD         wError = 0;    // Success
    int          i;
    LPBITMAPINFO lpBitsInfoOut;    // Possibly compressed output format

    /* No special video format given -- use the default */
    if (lpcs->CompVars.hic == NULL)
	lpBitsInfoOut = lpcs->lpBitsInfo;
    else
	lpBitsInfoOut = lpcs->CompVars.lpbiOut;

    // -------------------------------------------------------
    // figure out buffer sizes
    // -------------------------------------------------------

    // Init all pointers to NULL
    for(i = 0; i < MAX_VIDEO_BUFFERS; i++)
        lpcs->alpVideoHdr[i] = NULL;

    for(i = 0; i < MAX_WAVE_BUFFERS; i++)
        lpcs->alpWaveHdr[i] = NULL;

    // .5 second of audio per buffer (or 10K, whichever is larger)
    if (lpcs->sCapParms.dwAudioBufferSize == 0)
        lpcs->dwWaveSize =  CalcWaveBufferSize (lpcs);
    else {
        if (!lpcs-> lpWaveFormat)
            lpcs->dwWaveSize = 0;
        else
            lpcs->dwWaveSize = lpcs->sCapParms.dwAudioBufferSize;
    }
    /* Set video buffer size to Image size
        (normally dx * dy * (depth / 8)) + sizeof(RIFF) */
    lpcs->dwVideoSize = lpcs->lpBitsInfo->bmiHeader.biSizeImage + sizeof(RIFF);
    lpcs->fVideoDataIsCompressed = (lpBitsInfoOut->bmiHeader.biCompression
                != BI_RGB);

    /* Pad out to multiple of lpcs->sCapParms.wChunkGranularity (2K) size */
    // Calc dwVideoJunkSize

    if (lpcs->dwVideoJunkSize = lpcs->sCapParms.wChunkGranularity - (lpcs->dwVideoSize % lpcs->sCapParms.wChunkGranularity)) {
         if (lpcs->dwVideoJunkSize < sizeof(RIFF))
             lpcs->dwVideoJunkSize += lpcs->sCapParms.wChunkGranularity;

         lpcs->dwVideoSize += lpcs->dwVideoJunkSize;

         lpcs->dwVideoJunkSize -= sizeof(RIFF);
    } else {
         lpcs->dwVideoJunkSize = 0L;
    }

    // -------------------------------------------------------
    //                    DOS copy buffer
    // -------------------------------------------------------

    lpcs->dwDOSBufferSize = max (lpcs->dwWaveSize, lpcs->dwVideoSize);

#if 0
    // Only get a DOS copy buffer if we're not trying to get DOS video buffers
    if (!lpcs->sCapParms.fUsingDOSMemory) {
        lpcs->lpDOSWriteBuffer = AllocDosMem(lpcs->dwDOSBufferSize);

        if (lpcs->lpDOSWriteBuffer) {
            dprintf("Allocated DOS write buffer (%ld bytes).\n", lpcs->dwDOSBufferSize);
        } else {
            dprintf("Unable to allocate DOS write buffer.\n");
        }
    }
#endif

    // -------------------------------------------------------
    //                    Init Sound
    // -------------------------------------------------------

    if (lpcs->sCapParms.fCaptureAudio) {
        if (wError = AVIAudioInit (lpcs)) {
            dprintf("can't init audio buffers!\n");
            goto AVIInitFailed;
        }
    }

    // -------------------------------------------------------
    //                    Init Video
    // -------------------------------------------------------

    if (wError = AVIVideoInit (lpcs)) {
        dprintf("AVIVideoInitFailed (no buffers alloc'd)!\n");
        goto AVIInitFailed;
    }

    // --------------------------------------------------------------
    //  Prepare audio buffers (lock em down) and give them to the device
    // --------------------------------------------------------------

    if (lpcs->sCapParms.fCaptureAudio) {
        if (wError = AVIAudioPrepare (lpcs, NULL)) {
            dprintf("can't prepare audio buffers!\n");
            goto AVIInitFailed;
        }
    }

    // --------------------------------------------------------------
    //  Prepare video buffers (lock em down) and give them to the device
    // --------------------------------------------------------------

    if (wError = AVIVideoPrepare (lpcs)) {
        dprintf("can't prepare video buffers!\n");
        goto AVIInitFailed;
    }

    // -------------------------------------------------------
    //   all done, return success
    // -------------------------------------------------------

    return (0);            // SUCCESS !

    // -------------------------------------------------------
    //   we got a error, return string ID of error message
    // -------------------------------------------------------
AVIInitFailed:
    AVIFini(lpcs);      // Shutdown everything
    return wError;
}

// Write data to the capture file
// Returns: TRUE on a successful write
BOOL NEAR PASCAL AVIWrite(LPCAPSTREAM lpcs, LPVOID p, DWORD dwSize)
{
    if (lpcs->lpDOSWriteBuffer) {
        MemCopy(lpcs->lpDOSWriteBuffer, p, dwSize);
        p = lpcs->lpDOSWriteBuffer;
    }

    return mmioWrite(lpcs->hmmio, p, (long)dwSize) == (long)dwSize;
}

//
// Writes dummy frames which on playback just repeat the previous frame
// nCount is a count of the number of frames to write
// Returns: TRUE on a successful write
BOOL AVIWriteDummyFrames (LPCAPSTREAM lpcs, int nCount)
{
    DWORD dwBytesToWrite;
    DWORD dwJunkSize;
    LPRIFF p;
    int j;

    p = (LPRIFF) lpcs->DropFrame;
    for (j = 0; j < nCount; j++) {
        // The index includes info on if this is a dummy chunk,
        // AND if this is the last dummy chunk in a sequence
        IndexVideo (lpcs, IS_DUMMY_CHUNK |
                ((j == nCount - 1) ? IS_LAST_DUMMY_CHUNK : 0), FALSE);
        if (lpcs->lpBitsInfo->bmiHeader.biCompression == BI_RLE8)
            p->dwType = MAKEAVICKID(cktypeDIBcompressed, 0);
        else
            p->dwType  = MAKEAVICKID(cktypeDIBbits, 0);
        p->dwSize  = 0;
        p++;
    }

    dwBytesToWrite = nCount * sizeof(RIFF);

    /* Pad out to multiple of lpcs->sCapParms.wChunkGranularity (2K) size */

    if (dwJunkSize = (dwBytesToWrite % lpcs->sCapParms.wChunkGranularity)) {
       dwJunkSize = lpcs->sCapParms.wChunkGranularity - dwJunkSize;
       if (dwJunkSize < sizeof(RIFF))
            dwJunkSize += lpcs->sCapParms.wChunkGranularity;

        dwBytesToWrite += dwJunkSize;

        dwJunkSize -= sizeof(RIFF);
    } else {
        dwJunkSize = 0L;
    }

    // Now create a new junk chunk at the end of the compressed data
    if(dwJunkSize) {
        p->dwType = ckidAVIPADDING;
        p->dwSize = dwJunkSize;
    }

    /* write out the dummy frames, and possibly the junk chunk */
    return (AVIWrite(lpcs, lpcs->DropFrame, dwBytesToWrite));
}

// Writes compressed or uncompressed frames to the AVI file
// returns TRUE if no error, FALSE if end of file.

BOOL AVIWriteVideoFrame (LPCAPSTREAM lpcs, LPVIDEOHDR lpVidHdr)
{
    DWORD dwBytesToWrite;
    DWORD dwJunkSize;
    LPVOID p;
    LPVOID lpData;

    // If the device compresses the data, calculate new junk chunk
    // and fix the RIFF header

    //
    // We are automatically compressing during capture, so
    // first compress the frame.
    //
    if (lpcs->CompVars.hic) {
        DWORD       dwBytesUsed = 0;	// don't force a data rate
        BOOL        fKeyFrame;

        lpData = ICSeqCompressFrame(&lpcs->CompVars, 0,
            lpVidHdr->lpData, &fKeyFrame, &dwBytesUsed);

        ((RIFF FAR*)lpData)[-1].dwType = MAKEAVICKID(cktypeDIBbits, 0);
        ((RIFF FAR*)lpData)[-1].dwSize = dwBytesUsed;

        if (fKeyFrame)
            lpVidHdr->dwFlags |= VHDR_KEYFRAME;
        else
            lpVidHdr->dwFlags &= ~VHDR_KEYFRAME;

        lpVidHdr->dwBytesUsed = dwBytesUsed;
    }
    else {
        lpData = lpVidHdr->lpData;
    }

    if (lpcs->fVideoDataIsCompressed) {       // ie. if not BI_RGB

        // change the dwSize field in the RIFF chunk
        *((LPDWORD)((BYTE _huge *)lpVidHdr->lpData - sizeof(DWORD)))
                = lpVidHdr->dwBytesUsed;

         // Make sure that the JUNK chunk starts on a WORD boundary
         if (lpVidHdr->dwBytesUsed & 1)
             ++lpVidHdr->dwBytesUsed;

        dwBytesToWrite = lpVidHdr->dwBytesUsed + sizeof(RIFF);

        /* Pad out to multiple of lpcs->sCapParms.wChunkGranularity (2K) size */

        if (dwJunkSize = (dwBytesToWrite % lpcs->sCapParms.wChunkGranularity)) {
             dwJunkSize = lpcs->sCapParms.wChunkGranularity - dwJunkSize;
             if (dwJunkSize < sizeof(RIFF))
                dwJunkSize += lpcs->sCapParms.wChunkGranularity;

            dwBytesToWrite += dwJunkSize;

             // Now create a new junk chunk at the end of the compressed data
             p = (BYTE huge *)lpVidHdr->lpData + lpVidHdr->dwBytesUsed;

             ((LPRIFF)p)->dwType = ckidAVIPADDING;
             ((LPRIFF)p)->dwSize = dwJunkSize - sizeof(RIFF);
        }
    } // endif compressed data
    else {
        dwBytesToWrite = lpcs->dwVideoSize;
    } // endif not compressed data

    /* write out the chunk, video data, and possibly the junk chunk */
    return (AVIWrite(lpcs, (LPBYTE)lpData - sizeof(RIFF), dwBytesToWrite));
}

//
// Maintains info chunks which are written to the AVI header
//
BOOL FAR PASCAL SetInfoChunk(LPCAPSTREAM lpcs, LPCAPINFOCHUNK lpcic)
{
    DWORD       ckid   = lpcic->fccInfoID;
    LPVOID      lpData = lpcic->lpData;
    LONG        cbData = lpcic->cbData;
    LPBYTE      lp;
    LPBYTE      lpw;
    LPBYTE      lpEnd;
    LPBYTE      lpNext;
    LONG        cbSizeThis;
    BOOL        fOK = FALSE;

    // Delete all info chunks?
    if (ckid == 0) {
        if (lpcs->lpInfoChunks) {
            GlobalFreePtr (lpcs->lpInfoChunks);
            lpcs->lpInfoChunks = NULL;
            lpcs->cbInfoChunks = 0;
        }
        return TRUE;
    }

    // Try removing an entry if it already exists...
    // Also used if lpData is NULL to just remove an entry
    lpw   = (LPBYTE)lpcs->lpInfoChunks;           // always points at fcc
    lpEnd = (LPBYTE)lpcs->lpInfoChunks + lpcs->cbInfoChunks;
    while (lpw < lpEnd) {
        cbSizeThis = ((LPDWORD)lpw)[1];
        cbSizeThis += cbSizeThis & 1;           // force WORD alignment
        lpNext = lpw + cbSizeThis + sizeof (DWORD) * 2;
        if ((*(LPDWORD) lpw) == ckid) {
            lpcs->cbInfoChunks -= cbSizeThis + sizeof (DWORD) * 2;
            if (lpNext <= lpEnd) {
                if (lpEnd - lpNext)
                    hmemcpy(lpw, lpNext, lpEnd - lpNext);
                if (lpcs->cbInfoChunks) {
	           lpcs->lpInfoChunks = (LPBYTE) GlobalReAllocPtr( // shrink it
                        lpcs->lpInfoChunks,
                        lpcs->cbInfoChunks,
                        GMEM_MOVEABLE);
                }
                else {
                    if (lpcs->lpInfoChunks)
                        GlobalFreePtr (lpcs->lpInfoChunks);
                    lpcs->lpInfoChunks = NULL;
                }
                fOK = TRUE;
            }
            break;
        }
        else
            lpw = lpNext;
    }

    if (lpData == NULL || cbData == 0)         // Only deleting, get out
        return fOK;

    // Add a new entry
    cbData += cbData & 1;               // force WORD alignment
    cbData += sizeof(DWORD) * 2;        // add sizeof 2 FOURCCs
    if (lpcs->lpInfoChunks) {
	lp = (LPBYTE) GlobalReAllocPtr(lpcs->lpInfoChunks, lpcs->cbInfoChunks + cbData, GMEM_MOVEABLE);
    } else {
	lp = (LPBYTE) GlobalAllocPtr(GMEM_MOVEABLE, cbData);
    }

    if (!lp)
	return FALSE;

    // build RIFF chunk in block
    ((DWORD FAR *) (lp + lpcs->cbInfoChunks))[0] = ckid;
    ((DWORD FAR *) (lp + lpcs->cbInfoChunks))[1] = lpcic->cbData;

    hmemcpy(lp + lpcs->cbInfoChunks + sizeof(DWORD) * 2,
	    lpData,
	    cbData - sizeof(DWORD) * 2);
    lpcs->lpInfoChunks = lp;
    lpcs->cbInfoChunks += cbData;

    return TRUE;
}


/*
 *  AVI Capture
 *      This is the main streaming capture loop for both audio and
 * video.  It will first init all buffers and drivers and then go into a
 * loop checking for buffers to be filled.  When a buffer is filled then
 * the data for it is written out.
 * Afterwards it cleans up after itself (frees buffers etc...)
 * Returns: 0 on success, else error code
 */
void FAR PASCAL _loadds AVICapture1(LPCAPSTREAM lpcs)
{
    BOOL        fOK = TRUE;
    BOOL        fT;
    BOOL        fVideoBuffersInDOSMem;
    BOOL        fStopping;         // True when finishing capture
    BOOL        fStopped;          // True if driver notified to stop
    DWORD       dw;
    char        ach[128];
    char        achMsg[128];
    WORD        w;
    WORD        wError;         // Error String ID
    DWORD       dwDriverDropCount;
    WORD        wSmartDrv;
    LPVIDEOHDR  lpVidHdr;
    LPWAVEHDR   lpWaveHdr;
    DWORD       dwTimeStarted;  // When did we start in milliseconds
    DWORD       dwTimeStopped;
    DWORD       dwTimeToStop;   // Lesser of MCI capture time or frame limit
    BOOL        fTryToPaint = FALSE;
    HDC         hdc;
    HPALETTE    hpalT;
    HCURSOR     hOldCursor;
    RECT        rcDrawRect;
    DWORD       dwStreamError;
    CAPINFOCHUNK cic;

    lpcs-> dwReturn = DV_ERR_OK;

    hOldCursor = SetCursor(lpcs->hWaitCursor);

    statusUpdateStatus(lpcs, IDS_CAP_BEGIN);  // Always the first message

    // If not 1 Meg. free, give it up!!!
    if (GetFreePhysicalMemory () < (1024L * 1024L)) {
        errorUpdateError (lpcs, IDS_CAP_OUTOFMEM);
        lpcs-> dwReturn = 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);
        SetWindowOrg(hdc, lpcs->ptScroll.x, lpcs->ptScroll.y);
        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->fCapturingToDisk) {
        dw = muldiv32(lpcs->sCapParms.dwIndexSize,
                lpcs->sCapParms.dwRequestMicroSecPerFrame,
                1000l);

        dwTimeToStop = min (dw, dwTimeToStop);
    }

    if (lpcs->sCapParms.fMCIControl) {
        fOK = FALSE;            // Assume the worst
        if (MCIDeviceOpen (lpcs)) {
            if (MCIDeviceSetPosition (lpcs, lpcs->sCapParms.dwMCIStartTime))
                fOK = TRUE;
        }
        if (!fOK) {
            errorUpdateError (lpcs, IDS_CAP_MCI_CONTROL_ERROR);
            statusUpdateStatus(lpcs, NULL);    // Clear status
            lpcs-> dwReturn = IDS_CAP_MCI_CONTROL_ERROR;
            goto EarlyExit;
        }
    }

    //
    // If we're compressing while capturing, warm up the compressor
    //
    if (lpcs->CompVars.hic) {
        if (ICSeqCompressFrameStart(&lpcs->CompVars, lpcs->lpBitsInfo) == NULL) {

	    // !!! We're in trouble here!
            dprintf("ICSeqCompressFrameStart failed !!!\n");
            lpcs-> dwReturn = IDS_CAP_COMPRESSOR_ERROR;
            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);

    // -------------------------------------------------------
    //  Open the output file
    // -------------------------------------------------------

    if (lpcs->fCapturingToDisk) {
        if (!AVIFileInit(lpcs)) {
            lpcs-> dwReturn = IDS_CAP_FILE_OPEN_ERROR;
            errorUpdateError (lpcs, IDS_CAP_FILE_OPEN_ERROR);
            goto EarlyExit;
        }
    }

    /* Make sure the parent has been repainted */
    UpdateWindow(lpcs->hwnd);

    //
    // call AVIInit() to get all the capture memory we will need
    //

    // Don't use DOS memory if capturing to Net
    fVideoBuffersInDOSMem = lpcs->sCapParms.fUsingDOSMemory;

    wError = AVIInit(lpcs);

    if (wError && fVideoBuffersInDOSMem) {
        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, NULL);    // Clear status
        lpcs-> dwReturn = wError;
        goto EarlyExit;
    }

    /* Click OK to capture string (must follow AVIInit) */
    LoadString(lpcs->hInst, IDS_CAP_SEQ_MSGSTART, ach, sizeof(ach));
    wsprintf(achMsg, ach, (LPSTR)lpcs->achFile);

    statusUpdateStatus(lpcs, NULL);

    // -------------------------------------------------------
    //   Ready to go, make the user click OK?
    // -------------------------------------------------------

    if (lpcs->sCapParms.fMakeUserHitOKToCapture && lpcs->fCapturingToDisk) {
	w = MessageBox(lpcs->hwnd, achMsg, "", MB_OKCANCEL | MB_ICONEXCLAMATION);
        if (w == IDCANCEL) {
            /* clean-up and get out */
            AVIFini(lpcs);
            AVIFileFini(lpcs, TRUE /* fWroteJunkChunks */, TRUE /* fAbort */);
            statusUpdateStatus(lpcs, NULL);    // Clear status
            goto EarlyExit;
        }
    } // endif forcing user to hit OK

    /* update the status, so the user knows how to stop */
    statusUpdateStatus(lpcs, IDS_CAP_SEQ_MSGSTOP);
    UpdateWindow(lpcs->hwnd);

    lpcs-> fCapturingNow = TRUE;

    GetAsyncKeyState(lpcs->sCapParms.vKeyAbort);
    GetAsyncKeyState(VK_ESCAPE);
    GetAsyncKeyState(VK_LBUTTON);
    GetAsyncKeyState(VK_RBUTTON);

    if (lpcs->sCapParms.fDisableWriteCache)
        wSmartDrv = SmartDrv(lpcs->achFile[0], (WORD)-1);  // turn all off....

    // Insert the digitization time
    cic.fccInfoID = mmioFOURCC ('I','D','I','T');
    time (&ltime);
    cic.lpData = (LPSTR) ctime(&ltime);
    cic.cbData  = 26;
    SetInfoChunk (lpcs, &cic);


    // -------------------------------------------------------
    //   Start MCI, Audio, and video streams
    // -------------------------------------------------------

    if (lpcs-> CallbackOnControl) {
        // Callback will preroll, then return on frame accurate postion
        // The 1 indicates recording is about to start
        // Callback can return FALSE to exit without capturing
        if (!((*(lpcs->CallbackOnControl)) (lpcs->hwnd, CONTROLCALLBACK_PREROLL ))) {
            /* clean-up and get out */
            AVIFini(lpcs);
            AVIFileFini(lpcs, TRUE /* fWroteJunkChunks */, TRUE /* fAbort */);
            statusUpdateStatus(lpcs, NULL);    // Clear status
            goto EarlyExit;
        }
    }

    if (lpcs->sCapParms.fMCIControl)
        MCIDevicePlay (lpcs);

    dwTimeStarted = timeGetTime();

    if(lpcs->sCapParms.fCaptureAudio)
        waveInStart(lpcs->hWaveIn);

    videoStreamStart(lpcs->hVideoIn);

    // -------------------------------------------------------
    //   MAIN CAPTURE LOOP
    // -------------------------------------------------------

    fOK=TRUE;
    fStopping = FALSE;    // TRUE when we need to stop
    fStopped = FALSE;     // TRUE if drivers notified we have stopped
    lpcs->dwTimeElapsedMS = 0;

    lpVidHdr = lpcs->alpVideoHdr[lpcs->iNextVideo];
    lpWaveHdr = lpcs->alpWaveHdr[lpcs->iNextWave];

    for (;;) {

        // The INTEL driver uses the GetError message to
        // process buffers, so call it often...
        videoStreamGetError (lpcs->hVideoIn, &dwStreamError, &dwDriverDropCount);

        // What time is it?
        lpcs->dwTimeElapsedMS = timeGetTime() - dwTimeStarted;

        // -------------------------------------------------------
        //        Is video buffer ready to be written?
        // -------------------------------------------------------
        if ((lpVidHdr->dwFlags & VHDR_DONE)) {
            if (lpVidHdr-> dwBytesUsed) {
                // Current time in milliseconds
                dw = muldiv32 ((lpcs->dwVideoChunkCount + 1),
                                lpcs->sCapParms.dwRequestMicroSecPerFrame, 1000);
                if (lpcs->CallbackOnVideoStream)
                    (*(lpcs->CallbackOnVideoStream)) (lpcs->hwnd, lpVidHdr);

                if (lpcs-> fCapturingToDisk) {
                    if (lpcs->dwVideoChunkCount &&
                                (dw < lpVidHdr->dwTimeCaptured)) {
                        // Has the capture device skipped frames?
                        // w = # of frames skipped
                        w = (WORD) muldiv32 ((lpVidHdr-> dwTimeCaptured - dw),
                                1000,
                                lpcs->sCapParms.dwRequestMicroSecPerFrame);
                        w = min (w, (sizeof (lpcs->DropFrame) / sizeof (RIFF) - sizeof (RIFF) ) );
                        lpcs->dwFramesDropped+= w;
                        fOK = AVIWriteDummyFrames (lpcs, w);

                        if (!fOK)
                            fStopping = TRUE;
                    } // end if writing dummy frames

                    if (!AVIWriteVideoFrame (lpcs, lpVidHdr)) {
                        fOK = FALSE;
                        fStopping = TRUE;
                        // "ERROR: Could not write to file."
                        errorUpdateError(lpcs, IDS_CAP_FILE_WRITE_ERROR);
                    }
                    else {
                        if (!IndexVideo(lpcs, lpVidHdr-> dwBytesUsed,
                                (BOOL) (lpVidHdr->dwFlags & VHDR_KEYFRAME)))
                            fStopping = TRUE;
                    }
                } // endif fCapturingToDisk
                // Warning: Kludge to create frame chunk count when net capture
                // follows.
                else
                    lpcs->dwVideoChunkCount++;

                // -------------------------------------------------------
                //         if we have *nothing* to do paint or show status.
                // -------------------------------------------------------
                w = (lpcs->iNextVideo + 1) % lpcs->iNumVideo;
                if (!(lpcs->alpVideoHdr[w]-> dwFlags & VHDR_DONE)) {
                    if (fTryToPaint && lpcs->dwVideoChunkCount &&
                                lpVidHdr-> dwFlags & VHDR_KEYFRAME) {
                        fTryToPaint = DrawDibDraw(lpcs->hdd, hdc,
                                0, 0,
                                rcDrawRect.right - rcDrawRect.left,
                                rcDrawRect.bottom - rcDrawRect.top,
                                /*lpcs->dxBits, lpcs->dyBits, */
                                (LPBITMAPINFOHEADER)lpcs->lpBitsInfo,
                                lpVidHdr-> lpData, 0, 0, -1, -1,
                                DDF_SAME_HDC | DDF_SAME_DIB | DDF_SAME_SIZE);
                    }
                }
                // if there is still more time, (or at least every 100 frames)
                // show status if we're not ending the capture
                if ((!fStopping) && (lpcs-> fCapturingToDisk) &&
                        ((lpcs->dwVideoChunkCount && (lpcs->dwVideoChunkCount % 100 == 0)) ||
                        (!(lpcs->alpVideoHdr[w]-> dwFlags & VHDR_DONE)) ) ) {

                    // "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
            } // endif any bytes used in the buffer

             /* return the emptied buffer to the que */
            lpVidHdr->dwFlags &= ~VHDR_DONE;
            if (videoStreamAddBuffer(lpcs->hVideoIn,
                        lpVidHdr, sizeof (VIDEOHDR))) {
                fOK = FALSE;
                fStopping = TRUE;
                // "ERROR: Could not re-add buffer."
                  errorUpdateError (lpcs, IDS_CAP_VIDEO_ADD_ERROR);
            }

            /* increment the next Video buffer pointer */
            if (++lpcs->iNextVideo >= lpcs->iNumVideo)
                lpcs->iNextVideo = 0;

            lpVidHdr = lpcs->alpVideoHdr[lpcs->iNextVideo];
        }

        if (lpcs-> CallbackOnYield) {
            // If the yield callback returns FALSE, abort
            if (!((*(lpcs->CallbackOnYield)) (lpcs->hwnd)))
                fStopping = TRUE;
        }

        // Don't do peekMessage yield for ACM
        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);
                }
            }
        }

        if (lpcs-> CallbackOnControl) {
            // Outside routine is handling when to stop
            // The CONTROLCALLBACK_CAPTURING indicates we're asking when to stop
            if (!((*(lpcs->CallbackOnControl)) (lpcs->hwnd, CONTROLCALLBACK_CAPTURING )))
                fStopping = TRUE;
        }

        // -------------------------------------------------------
        //        Is audio buffer ready to be written?
        // -------------------------------------------------------
        if (lpcs->sCapParms.fCaptureAudio) {
            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;

            w = lpcs->iNumAudio; // don't get stuck here forever...
            while (w && fOK && (lpWaveHdr-> dwFlags & WHDR_DONE)) {
                w--;
                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-> fCapturingToDisk) {
                        if(!AVIWrite (lpcs, lpWaveHdr-> lpData - sizeof(RIFF),
                                (lpWaveHdr-> dwBytesRecorded +
                                sizeof (RIFF) + 1) & ~1L)) {
                            fOK = FALSE;
                            fStopping = TRUE;
                            errorUpdateError (lpcs, IDS_CAP_FILE_WRITE_ERROR);
                         } else {
                            if (IndexAudio (lpcs, lpWaveHdr-> dwBytesRecorded))
                                lpcs->dwWaveBytes += lpWaveHdr-> dwBytesRecorded;
                            else
                                fStopping = TRUE;
                         }
                    } // 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 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

        // -------------------------------------------------------
        //        is there any reason to stop?
        // -------------------------------------------------------
        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 (lpcs->sCapParms.fAbortLeftMouse)
            if (GetAsyncKeyState(VK_LBUTTON) & 0x0001)
                fStopping = TRUE;      // User aborts
        if (lpcs->sCapParms.fAbortRightMouse)
            if (GetAsyncKeyState(VK_RBUTTON) & 0x0001)
                fStopping = TRUE;      // User aborts
        if (lpcs-> fAbortCapture || lpcs-> fStopCapture)
            fStopping = TRUE;          // Somebody above wants us to quit

        if (lpcs-> dwTimeElapsedMS > dwTimeToStop)
            fStopping = TRUE;      // all done

        // -------------------------------------------------------
        //        Quit only when we have stopped, and
        //      no more buffers are pending from any device.
        // -------------------------------------------------------
        if (fStopped) {
            if (!(lpVidHdr-> dwFlags & VHDR_DONE)) {
                if (lpcs->sCapParms.fCaptureAudio) {
                   if (!(lpWaveHdr-> dwFlags & WHDR_DONE))
                        break;
                }
                else
                    break;
            }
        }

        // -------------------------------------------------------
        //        Tell all the devices to stop
        // -------------------------------------------------------
        if (fStopping && !fStopped) {
            fStopped = TRUE;

            DSTATUS(lpcs, "Stopping....");

            if(lpcs->sCapParms.fCaptureAudio) {
                DSTATUS(lpcs, "Stopping Audio");
                waveInStop(lpcs->hWaveIn);
            }

            DSTATUS(lpcs, "Stopping Video");
            videoStreamStop(lpcs->hVideoIn);         // Stop everybody

            dwTimeStopped = timeGetTime ();

            if (lpcs->sCapParms.fMCIControl) {
                DSTATUS(lpcs, "Stopping MCI");
                MCIDevicePause (lpcs);
            }
            DSTATUS(lpcs, "Stopped");

            SetCursor(lpcs->hWaitCursor);  // Force cursor back to hourglass

        }


        if (fStopping) {
            // "Finished capture, now writing frame %ld"
            if (fOK) {
                statusUpdateStatus(lpcs, IDS_CAP_STAT_CAP_FINI, lpcs->dwVideoChunkCount);
            }
            else {               // Exit if problems
                statusUpdateStatus(lpcs, IDS_CAP_RECORDING_ERROR2);
                break;
            }
        }

    } // end of forever

    // -------------------------------------------------------
    //   END OF MAIN CAPTURE LOOP
    // -------------------------------------------------------

    if (lpcs->sCapParms.fDisableWriteCache)
        SmartDrv(lpcs->achFile[0], wSmartDrv);  // turn Smartdrive back on

    /* 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 */);

    // This is the corrected capture duration, based on audio samples
    lpcs->dwTimeElapsedMS = lpcs->dwActualMicroSecPerFrame *
                lpcs->dwVideoChunkCount / 1000;

    /* Notify if there was an error while recording */

    if(!fOK) {
        errorUpdateError (lpcs, IDS_CAP_RECORDING_ERROR);
    }


    if (lpcs-> fCapturingToDisk) {
        if (lpcs->dwVideoChunkCount)
            dw = muldiv32(lpcs->dwVideoChunkCount,1000000,lpcs-> dwTimeElapsedMS);
        else
            dw = 0;     // The muldiv32 doesn't give 0 if numerator is zero

        if(lpcs->sCapParms.fCaptureAudio) {
            // "Captured %d.%03d sec.  %ld frames (%ld dropped) (%d.%03d fps).  %ld audio bytes (%d.%03d sps)"
            statusUpdateStatus(lpcs, IDS_CAP_STAT_VIDEOAUDIO,
                  (WORD)(lpcs-> dwTimeElapsedMS/1000),
                  (WORD)(lpcs-> dwTimeElapsedMS%1000),
                  lpcs->dwVideoChunkCount,
                  lpcs->dwFramesDropped,
                  (WORD)(dw / 1000),
                  (WORD)(dw % 1000),
                  lpcs->dwWaveBytes,
                  (WORD) lpcs->lpWaveFormat->nSamplesPerSec / 1000,
                  (WORD) lpcs->lpWaveFormat->nSamplesPerSec % 1000);
        } else {
            // "Captured %d.%03d sec.  %ld frames (%ld dropped) (%d.%03d fps)."
            statusUpdateStatus(lpcs, IDS_CAP_STAT_VIDEOONLY,
                  (WORD)(lpcs-> dwTimeElapsedMS/1000),
                  (WORD)(lpcs-> dwTimeElapsedMS%1000),
                  lpcs->dwVideoChunkCount,
                  lpcs->dwFramesDropped,
                  (WORD)(dw / 1000),
                  (WORD)(dw % 1000));
        }
    } // endif capturing to disk (no warnings or errors if to net)

    // No frames captured, warn user that interrupts are probably not enabled.
    if (fOK && (lpcs->dwVideoChunkCount == 0)) {
        errorUpdateError (lpcs, IDS_CAP_NO_FRAME_CAP_ERROR);
    }
    // No audio captured, (but enabled), warn user audio card is hosed
    else if (fOK && lpcs->sCapParms.fCaptureAudio && (lpcs->dwWaveBytes == 0)) {
        errorUpdateError (lpcs, IDS_CAP_NO_AUDIO_CAP_ERROR);
    }
    // Audio underrun, inform user
    else if (fOK && lpcs->sCapParms.fCaptureAudio && lpcs->fAudioBreak) {
        errorUpdateError (lpcs, IDS_CAP_AUDIO_DROP_ERROR);
    }

    // If frames dropped, or changed capture rate, warn the user
    else if (fOK && lpcs->dwVideoChunkCount && lpcs->fCapturingToDisk) {

        // Warn user if dropped > 10% (default) of the frames
        if ((DWORD)100 * lpcs->dwFramesDropped / lpcs->dwVideoChunkCount >
                    lpcs-> sCapParms.wPercentDropForError) {

            // "%ld of %ld frames (%d.%03d\%) dropped during capture."
            errorUpdateError (lpcs, IDS_CAP_STAT_FRAMESDROPPED,
                  lpcs->dwFramesDropped,
                  lpcs->dwVideoChunkCount,
                  (WORD)(muldiv32(lpcs->dwFramesDropped,10000,lpcs->dwVideoChunkCount)/100),
                  (WORD)(muldiv32(lpcs->dwFramesDropped,10000,lpcs->dwVideoChunkCount)%100)
                  );
        }
    }

EarlyExit:

    //
    // If we were compressing while capturing, close it down
    //
    if (lpcs->CompVars.hic) {
        // Kludge, reset the lpBitsOut pointer
        if (lpcs->CompVars.lpBitsOut)
            ((LPBYTE) lpcs->CompVars.lpBitsOut) -= 8;
	ICSeqCompressFrameEnd(&lpcs->CompVars);
    }

    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);

    SetCursor(hOldCursor);

    lpcs->fCapFileExists = (lpcs-> dwReturn == DV_ERR_OK);
    lpcs->fCapturingNow = FALSE;

    statusUpdateStatus(lpcs, IDS_CAP_END);      // Always the last message

    return;
}


// Returns TRUE if the capture task was created, or
// capture completed OK.

BOOL AVICapture (LPCAPSTREAM lpcs)
{
    WORD w;
    CAPINFOCHUNK cic;
    char szSMPTE[40];

    if (lpcs-> fCapturingNow)
        return IDS_CAP_VIDEO_OPEN_ERROR;

    lpcs-> fStopCapture  = FALSE;
    lpcs-> fAbortCapture = FALSE;
    lpcs-> hTaskCapture  = NULL;
    lpcs-> dwReturn      = 0;

    // Clear any SMPTE info chunk
    cic.fccInfoID = mmioFOURCC ('I','S','M','T');
    cic.lpData = NULL;
    cic.cbData = 0;
    SetInfoChunk (lpcs, &cic);

#if 1
    // And get ready to write a SMPTE info chunk
    if (lpcs->sCapParms.fMCIControl) {
        // create SMPTE string
        TimeMSToSMPTE (lpcs->sCapParms.dwMCIStartTime, (LPSTR) szSMPTE);
        cic.lpData = szSMPTE;
        cic.cbData = lstrlen (szSMPTE) + 1;
        SetInfoChunk (lpcs, &cic);
    }
#endif

    // Use an MCI device to do step capture capture???
    if (lpcs->sCapParms.fStepMCIDevice && lpcs->sCapParms.fMCIControl) {
        if (lpcs->sCapParms.fYield) {
            w = (WORD) mmTaskCreate((LPTASKCALLBACK) MCIStepCapture,
                        &lpcs->hTaskCapture, (DWORD) lpcs);
            // if task creation failed, turn off the capturing flag
            if (w != 0)
                lpcs->fCapturingNow = FALSE;
            return ((BOOL) !w);
        }
        else  {
            MCIStepCapture (lpcs);
            return ((BOOL) !lpcs->dwReturn);
        }
    }

    // No MCI device, just a normal streaming capture
    else if (lpcs->sCapParms.fYield) {
        w = (WORD) mmTaskCreate((LPTASKCALLBACK) AVICapture1,
                &lpcs->hTaskCapture, (DWORD) lpcs);
        // if task creation failed, turn off the capturing flag
        if (w != 0)
            lpcs->fCapturingNow = FALSE;
        return ((BOOL) !w);
    }
    else  {
        AVICapture1 (lpcs);
        return ((BOOL) !lpcs->dwReturn);
    }
}