windows-nt-4.0/private/windows/media/avi/mciavi32/aviplay.c

/******************************************************************************

   Copyright (C) Microsoft Corporation 1985-1995. All rights reserved.

   Title:   aviplay.c - Code for actually playing AVI files, part of
	       AVI's background task.

*****************************************************************************/

#include "graphic.h"

#define AVIREADMANY             // read more than one record at a time

#ifdef _WIN32
//#define AVIREAD               // multi-threaded async read of file
#else
#undef AVIREAD
#endif

#ifdef AVIREAD
#include "aviread.h"
#endif

#define BOUND(x, low, high)     max(min(x, high), low)

#define ALIGNULONG(i)     ((i+3)&(~3))                  /* ULONG aligned ! */

#ifdef INTERVAL_TIMES
BOOL   fOneIntervalPerLine=FALSE;
#endif
//
// redefine StreamFromFOURCC to only handle 0-9 streams!
//
#undef StreamFromFOURCC
#define StreamFromFOURCC(fcc) (UINT)(HIBYTE(LOWORD(fcc)) - (BYTE)'0')

#ifdef DEBUG
static char szBadFrame[] = "Bad frame number";
static char szBadPos[]   = "Bad stream position";
#define AssertFrame(i)   AssertSz((long)(i) <= npMCI->lFrames && (long)(i) >= -(long)npMCI->wEarlyRecords, szBadFrame)
#define AssertPos(psi,i) AssertSz((long)(i) <= psi->lEnd && (long)(i) >= psi->lStart, szBadPos)
#else
#define AssertFrame(i)
#define AssertPos(psi,i)
#endif

#define WIDTHBYTES(i)     ((unsigned)((i+31)&(~31))/8)  /* ULONG aligned ! */
#define DIBWIDTHBYTES(bi) (DWORD)WIDTHBYTES((int)(bi).biWidth * (int)(bi).biBitCount)

LONG NEAR PASCAL WhatFrameIsItTimeFor(NPMCIGRAPHIC npMCI);
LONG NEAR PASCAL HowLongTill(NPMCIGRAPHIC npMCI);
BOOL NEAR PASCAL TimeToQuit(NPMCIGRAPHIC npMCI);
BOOL NEAR PASCAL WaitTillNextFrame(NPMCIGRAPHIC npMCI);

void NEAR PASCAL FindKeyFrame(NPMCIGRAPHIC npMCI, STREAMINFO *psi, LONG lPos);
LONG NEAR PASCAL FindPrevKeyFrame(NPMCIGRAPHIC npMCI, STREAMINFO *psi, LONG lPos);
LONG NEAR PASCAL FindNextKeyFrame(NPMCIGRAPHIC npMCI, STREAMINFO *psi, LONG lPos);

BOOL NEAR PASCAL CalculateTargetFrame(NPMCIGRAPHIC npMCI);
DWORD NEAR PASCAL CalculatePosition(NPMCIGRAPHIC npMCI);
BOOL NEAR PASCAL ReadRecord(NPMCIGRAPHIC npMCI);
BOOL NEAR PASCAL ReadNextVideoFrame(NPMCIGRAPHIC npMCI, STREAMINFO *psi);
STATICFN INLINE DWORD NEAR PASCAL ReadNextChunk(NPMCIGRAPHIC npMCI);

BOOL NEAR PASCAL ReadBuffer(NPMCIGRAPHIC npMCI, LONG off, LONG len);
BOOL NEAR PASCAL AllocateReadBuffer(NPMCIGRAPHIC npMCI);
BOOL NEAR PASCAL ResizeReadBuffer(NPMCIGRAPHIC npMCI, DWORD dwNewSize);
void NEAR PASCAL ReleaseReadBuffer(NPMCIGRAPHIC npMCI);

BOOL NEAR PASCAL ProcessPaletteChanges(NPMCIGRAPHIC npMCI, LONG lFrame);

STATICFN INLINE void DealWithOtherStreams(NPMCIGRAPHIC npMCI, LONG lFrame);
STATICFN INLINE BOOL NEAR PASCAL StreamRead(NPMCIGRAPHIC npMCI, STREAMINFO *psi, LONG lPos);

#ifdef _WIN32
#define AllocMem(dw) GlobalLock(GlobalAlloc(GMEM_MOVEABLE|GMEM_SHARE, (dw)))
#define FreeMem(lp) GlobalFreePtr(lp)
#else
static LPVOID AllocMem(DWORD dw);
#define FreeMem(lp) GlobalFree((HGLOBAL)SELECTOROF(lp))
#endif

INT     gwSkipTolerance = 4;
INT     gwHurryTolerance = 2;
INT     gwMaxSkipEver = 60;
#define YIELDEVERY      8

#ifdef DEBUG
#define WAITHISTOGRAM           /* Extra debugging information */
#define SHOWSKIPPED
//#define BEHINDHIST
#define DRAWTIMEHIST
#define READTIMEHIST
#define TIMEPLAY
#endif

#ifdef WAITHISTOGRAM
    UINT        wHist[100];
#endif

#define HIGHRESTIMER

#ifdef SHOWSKIPPED
#define NUMSKIPSSHOWN   25
    LONG        lSkipped[NUMSKIPSSHOWN];
    UINT        wSkipped = 0;
#endif
#ifdef BEHINDHIST
#define NUMBEHIND       50
#define BEHINDOFFSET    10
    WORD        wBehind[NUMBEHIND];
#endif
#ifdef DRAWTIMEHIST
#define NUMDRAWN        100
    DWORD       dwDrawTime[NUMDRAWN];
    UINT        wDrawn;
#endif
#ifdef READTIMEHIST
#define NUMREAD        100
    DWORD       dwReadTime[NUMREAD];
    UINT        wRead;
#endif

// If available, use a correctly functioning waveOutGetPosition
BOOL	gfUseGetPosition;
LONG	giGetPositionAdjust;

#ifdef AVIREAD
/*
 * the aviread object creates a worker thread to read the file
 * asynchronously. That thread calls this callback function
 * to actually read a buffer from the file. The 'instance data' DWORD in
 * this case is npMCI. see aviread.h for outline.
 */
BOOL mciaviReadBuffer(PBYTE pData, DWORD dwInstanceData, long lSize, long * lpNextSize)
{
    NPMCIGRAPHIC npMCI = (NPMCIGRAPHIC) dwInstanceData;
    DWORD size;
    DWORD UNALIGNED * lp;

    if(mmioRead(npMCI->hmmio, pData, lSize) != lSize) {
	return(FALSE);
    }

    /* we've read in the complete chunk, plus the FOURCC, size and formtype of
     * the next chunk. So the size of the next chunk is the last but one
     * DWORD in this buffer
     */
    lp = (DWORD UNALIGNED *) (pData + lSize - 2 * sizeof(DWORD));
    size = *lp;

    /* don't forget to add on the FOURCC and size dwords */
    *lpNextSize = size + 2 * sizeof(DWORD);

    return(TRUE);
}
#endif

//
// call this to find out the current position. This function
// should be safe to call from the user thread as well as from the
// worker thread

DWORD InternalGetPosition(NPMCIGRAPHIC npMCI, LPLONG lpl)
{
    LONG    l;

    l = npMCI->lCurrentFrame - npMCI->dwBufferedVideo;


    if ((npMCI->wTaskState == TASKCUEING) &&
       !(npMCI->dwFlags & MCIAVI_SEEKING) &&
       l < npMCI->lRealStart)
	l = npMCI->lRealStart;

    if (l < 0)
	l = 0;

    *lpl = l;

    return 0L;
}




STATICFN DWORD NEAR PASCAL PrepareToPlay(NPMCIGRAPHIC npMCI);
STATICFN DWORD NEAR PASCAL PrepareToPlay2(NPMCIGRAPHIC npMCI);
void  NEAR PASCAL CleanUpPlay(NPMCIGRAPHIC npMCI);
void  NEAR PASCAL CheckSignals(NPMCIGRAPHIC npMCI, LONG lFrame);

BOOL  NEAR PASCAL PlayNonInterleaved(NPMCIGRAPHIC npMCI);
BOOL  NEAR PASCAL PlayInterleaved(NPMCIGRAPHIC npMCI);
BOOL  NEAR PASCAL PlayAudioOnly(NPMCIGRAPHIC npMCI);
BOOL  NEAR PASCAL PlayNonIntFromCD(NPMCIGRAPHIC npMCI);
/***************************************************************************
 *
 * @doc INTERNAL MCIAVI
 *
 * @api UINT | mciaviPlayFile | Play an AVI file.
 *
 * @parm NPMCIGRAPHIC | npMCI | Pointer to instance data.
 *
 * @rdesc Notification code that should be returned.
 *
 ***************************************************************************/

UINT NEAR PASCAL mciaviPlayFile (NPMCIGRAPHIC npMCI, BOOL bSetEvent)
{
    BOOL        fContinue;
    DWORD       dwFlags = npMCI->dwFlags;

    BOOL (NEAR PASCAL *Play)(NPMCIGRAPHIC npMCI);

#ifdef WAITHISTOGRAM
    UINT        w;
#endif
#ifdef SHOWSKIPPED
    wSkipped = 0;
#endif
#ifdef WAITHISTOGRAM
    //for (w = 0; (int)w < (sizeof(wHist)/sizeof(wHist[0])); w++)
	//wHist[w] = 0;
    ZeroMemory(wHist, sizeof(wHist));
#endif
#ifdef BEHINDHIST
    //for (w = 0; w < NUMBEHIND; w++)
	//wBehind[w] = 0;
    ZeroMemory(wBehind, sizeof(wBehind));
#endif
#ifdef DRAWTIMEHIST
    wDrawn = 0;
    //for (w = 0; w < NUMDRAWN; w++)
	//dwDrawTime[w] = 0;
    ZeroMemory(dwDrawTime, sizeof(dwDrawTime));
#endif
#ifdef READTIMEHIST
    wRead = 0;
    //for (w = 0; w < NUMREAD; w++)
	//dwReadTime[w] = 0;
    ZeroMemory(dwReadTime, sizeof(dwReadTime));
#endif


#ifdef HIGHRESTIMER
    /* Figure out how much time each frame takes */
    /* Then set a high resolution timer, unless  */
    /* we are in the special "play every frame". */

    if (npMCI->dwSpeedFactor) {

        // Only if we are worried about timing each frame...
	// Set a timer resolution for a fraction of the frame rate
	// Initially we set the timer to 4ms.  This initial guess can
	// be overridden by a registry setting.
	// Note: there is no UI (yet?) for writing a value to the registry

        if ((npMCI->msPeriodResolution = mmGetProfileInt(szIni, TEXT("TimerResolution"), 4))
           && (0 == timeBeginPeriod(npMCI->msPeriodResolution))) {
	    // Timer successfully set
            DPF1(("Set timer resolution to %d milliseconds\n", npMCI->msPeriodResolution));
        } else {
            TIMECAPS tc;
            if ((timeGetDevCaps(&tc, sizeof(tc)) == 0)  &&
                (0 == timeBeginPeriod(tc.wPeriodMin))) {
                    npMCI->msPeriodResolution = tc.wPeriodMin;
                    DPF1(("Set timer resolution to the minimum of %d milliseconds\n", npMCI->msPeriodResolution));
            } else {
                // Reset, so we do not try and call timeEndPeriod
                // (note: the value may have been set by mmGetProfileInt)
    	        npMCI->msPeriodResolution = 0;
                DPF1(("NO high resolution timer set\n"));
            }
        }
    }
#endif


Repeat:


    // internal task state (used only by worker thread to
    // distinguish cueing/seeking/playing)
    npMCI->wTaskState = TASKSTARTING;


    TIMEZERO(timePlay);
    TIMEZERO(timePrepare);
    TIMEZERO(timeCleanup);
    TIMEZERO(timePaused);
    TIMEZERO(timeRead);
    TIMEZERO(timeWait);
    TIMEZERO(timeYield);
    TIMEZERO(timeVideo);
    TIMEZERO(timeOther);
    TIMEZERO(timeAudio);
    TIMEZERO(timeDraw);
    TIMEZERO(timeDecompress);

    TIMESTART(timePrepare);
    npMCI->dwTaskError = PrepareToPlay(npMCI);

    TIMEEND(timePrepare);

#ifdef INTERVAL_TIMES
    // interframe timing
    npMCI->nFrames = 0;
    npMCI->msFrameTotal = 0;
    npMCI->msSquares = 0;
    npMCI->msFrameMax = 0;
    npMCI->msFrameMin = 9999;
    npMCI->msReadMaxBytesPer = 0;
    npMCI->msReadMax = 0;
    npMCI->nReads = 0;
    npMCI->msReadTotal = 0;
    npMCI->msReadTimeuS = 0;

    {
        int i;
	PLONG pL;
        //for (i = 0; i < NBUCKETS; i++) {
        //    npMCI->buckets[i] = 0;
        //}
	ZeroMemory(npMCI->buckets, NBUCKETS*sizeof(LONG));
	pL = npMCI->paIntervals;
	if (pL) {
	    ZeroMemory(pL, (npMCI->cIntervals)*sizeof(LONG));
	}
    }
#endif


    //
    //  pick a play function.
    //
    switch (npMCI->wPlaybackAlg) {
	case MCIAVI_ALG_INTERLEAVED:
	    Play = PlayInterleaved;
	    break;

#ifdef USENONINTFROMCD	
	case MCIAVI_ALG_CDROM:
	    Play = PlayNonIntFromCD;
	    break;
#endif

	case MCIAVI_ALG_HARDDISK:
	    Play = PlayNonInterleaved;
	    break;

	case MCIAVI_ALG_AUDIOONLY:
	    Play = PlayAudioOnly;
	    break;

	default:
	    Assert(0);
	    return MCI_NOTIFY_ABORTED; //???
    }

    // bias lTo by dwBufferedVideo so we play to the right place
    npMCI->lTo += npMCI->dwBufferedVideo;

    npMCI->lFramePlayStart = npMCI->lRealStart;

    DPF(("Playing from %ld to %ld, starting at %ld.  Flags=%0.8x\n", npMCI->lFrom, npMCI->lTo, npMCI->lCurrentFrame, npMCI->dwFlags));

    // at this point we have detected any errors that we are going to detect
    // during startup. we can complete the synchronous portion of the command
    // if requested to do so
    if (bSetEvent) {
	bSetEvent = FALSE;
	TaskReturns(npMCI, npMCI->dwTaskError);
    }

    if (npMCI->dwTaskError != 0L)
	goto SKIP_PLAYING;



    /* We're done initializing; now we're warming up to play. */
    npMCI->wTaskState = TASKCUEING;

    TIMESTART(timePlay);

  try {
  // If the avi file is corrupt we want to try and catch errors without
  // aborting the application.  Hence we need this try/except clause at
  // this very high level.  It PROBABLY costs too much to set up the
  // exception handler every time we want to draw a single frame.

    /* Loop until things are done */
    while (1) {

	if (npMCI->dwFlags & MCIAVI_REVERSE) {
	    if (npMCI->lCurrentFrame < npMCI->lTo)
		break;
	} else {
	    if (npMCI->lCurrentFrame > npMCI->lTo)
		break;
	}

	if ((npMCI->wTaskState != TASKPLAYING) &&
		!(npMCI->dwFlags & MCIAVI_UPDATING)) {

	    TIMESTART(timeYield);
	    aviTaskCheckRequests(npMCI);
	    TIMEEND(timeYield);
	}

	fContinue = Play(npMCI);

	if (fContinue) fContinue = !TimeToQuit(npMCI);

	if (!fContinue)
	    break;

	//
	//  while playing we may need to update
	//
	//  always mark the movie as clean, even if a stream fails to update
	//  otherwise we will need to stop play and restart.
	//
	if (!(npMCI->dwFlags & MCIAVI_SEEKING) &&
	     (npMCI->dwFlags & MCIAVI_NEEDUPDATE)) {
	    DoStreamUpdate(npMCI, FALSE);

	    if (npMCI->dwFlags & MCIAVI_NEEDUPDATE) {
		DOUT("Update failed while playing, I dont care!\n");
		npMCI->dwFlags &= ~MCIAVI_NEEDUPDATE;   //!!! I dont care if it failed
	    }
	}

	/* Increment the frame number.  If we're done, don't increment
	** it an extra time, but just get out.
	*/
	if (npMCI->dwFlags & MCIAVI_REVERSE) {
	    if (npMCI->lCurrentFrame > npMCI->lTo)
		--npMCI->lCurrentFrame;
	    else
		break;
	} else {
	    if (npMCI->lCurrentFrame < npMCI->lTo)
		++npMCI->lCurrentFrame;
	    else {

		// need to ensure that we wait for audio to complete on the
		// last frame played
		if ((npMCI->lFrom != npMCI->lTo) &&
		    (npMCI->wTaskState == TASKPLAYING)) {

		    npMCI->lCurrentFrame++;
		    WaitTillNextFrame(npMCI);
		    npMCI->lCurrentFrame--;
		}

		break;
	    }
	}
    }
  } except (EXCEPTION_EXECUTE_HANDLER) {
      npMCI->dwTaskError = MCIERR_DRIVER_INTERNAL;
  }

    TIMEEND(timePlay);

    if (npMCI->lCurrentFrame != npMCI->lTo) {

	DPF(("Ended at %ld, not %ld (drawn = %ld).\n", npMCI->lCurrentFrame, npMCI->lTo, npMCI->lFrameDrawn));

	//
	// if we ended early lets set lCurrentFrame to the last frame
	// drawn to guarantee we can re-paint the frame, we dont
	// want to do this when we play to end because after playing
	// from A to B the current position *must* be B or preston will
	// enter a bug.
	//
	// but only set this if lFrameDraw is valid
	//

	if (npMCI->lFrameDrawn > (-(LONG)npMCI->wEarlyRecords))
	    npMCI->lCurrentFrame = npMCI->lFrameDrawn;
    }

SKIP_PLAYING:
    /* Flush any extra changes out to screen */

    DPF2(("Updating unfinished changes....\n"));

    // Make sure we really draw.... !!!do we need this?
    // npMCI->lRealStart = npMCI->lCurrentFrame;

    if (npMCI->hdc)
	DoStreamUpdate(npMCI, FALSE);

    npMCI->lTo -= npMCI->dwBufferedVideo;
    npMCI->lCurrentFrame -= npMCI->dwBufferedVideo;
    npMCI->dwBufferedVideo = 0;

    if (npMCI->lCurrentFrame < 0) {
	DPF2(("Adjusting position to be >= 0.\n"));
	npMCI->lCurrentFrame = 0;
    }

    if (npMCI->lTo < 0)
	npMCI->lTo = 0;

    /* Adjust position to be > start? */
    /* Adjust position to be > where it was when we began? */

    npMCI->dwTotalMSec += Now() - npMCI->dwMSecPlayStart;

    TIMESTART(timeCleanup);
    DPF(("Cleaning up the play\n"));
    CleanUpPlay(npMCI);
    TIMEEND(timeCleanup);

#ifdef AVIREAD
    /* shut down async reader */
    if (npMCI->hAviRd) {
	avird_endread(npMCI->hAviRd);
	npMCI->hAviRd = NULL;
    }
#endif

    /* If we're repeating, do it.  It sure would be nice if we could repeat
    ** without de-allocating and then re-allocating all of our buffers....
    */
    if (npMCI->dwTaskError == 0 && (!(npMCI->dwFlags & MCIAVI_STOP)) &&
		(npMCI->dwFlags & MCIAVI_REPEATING)) {
	npMCI->lFrom = npMCI->lRepeatFrom;

	//
	//  DrawEnd() likes to clear this flag so make sure it gets set
	//  in the repeat case.
	//
	if (dwFlags & MCIAVI_FULLSCREEN)
	    npMCI->dwFlags |= MCIAVI_FULLSCREEN;

	//
	// make sure we set the task state back before we repeat.
	// otherwise our code will think we are playing, for example.
	// if the audio code thinks we are playing and see's the wave buffers
	// are empty it will reset the wave device then restart it when
	// they get full again, this is bad if we are pre-rolling audio.
	//
	npMCI->wTaskState = TASKSTARTING;

	DPF((".........repeating\n"));
	goto Repeat;
    }

    /* Turn off flags only used during play. */
    npMCI->dwFlags &= ~(MCIAVI_STOP | MCIAVI_PAUSE | MCIAVI_SEEKING |
	    MCIAVI_REPEATING | MCIAVI_FULLSCREEN);

    if (npMCI->wTaskState == TASKPLAYING) {
	DWORD   dwCorrectTime;
	DWORD   dwFramesPlayed;

	dwFramesPlayed = (npMCI->dwFlags & MCIAVI_REVERSE) ?
	    npMCI->lFramePlayStart - npMCI->lCurrentFrame :
	    npMCI->lCurrentFrame - npMCI->lFramePlayStart;

	dwCorrectTime = muldiv32(dwFramesPlayed,
				muldiv32(npMCI->dwMicroSecPerFrame,
					1000L,
					(npMCI->dwSpeedFactor == 0 ?
						1000 : npMCI->dwSpeedFactor)),
				1000);

	if (dwCorrectTime != 0 && npMCI->dwTotalMSec != 0)
	    npMCI->dwSpeedPercentage = muldiv32(dwCorrectTime, 100,
						npMCI->dwTotalMSec);
	else
	    npMCI->dwSpeedPercentage = 100;

	if (dwFramesPlayed > 15) {
	    npMCI->lFramesPlayed      = (LONG)dwFramesPlayed;
	    npMCI->lFramesSeekedPast  = (LONG)npMCI->dwFramesSeekedPast;
	    npMCI->lSkippedFrames     = (LONG)npMCI->dwSkippedFrames;
	    npMCI->lAudioBreaks       = (LONG)npMCI->dwAudioBreaks;
	}

#ifdef DEBUG
	if (npMCI->dwFramesSeekedPast) {
	    DPF(("Didn't even read %ld frames.\n", npMCI->dwFramesSeekedPast));
	}
	if (npMCI->dwSkippedFrames && dwFramesPlayed > 0) {
	    DPF(("Skipped %ld of %ld frames. (%ld%%)\n",
			npMCI->dwSkippedFrames, dwFramesPlayed,
			npMCI->dwSkippedFrames*100/dwFramesPlayed));
	}
	if (npMCI->dwAudioBreaks) {
	    DPF(("Audio broke up %lu times.\n", npMCI->dwAudioBreaks));
	}
#ifndef TIMEPLAY
	DPF(("Played at %lu%% of correct speed.\n", npMCI->dwSpeedPercentage));
	DPF(("Correct time = %lu ms, Actual = %lu ms.\n",
				    dwCorrectTime, npMCI->dwTotalMSec));
#endif
#endif

    // don't print pages of crap when we've just stopped temporarily,
    // it gets on my nerves.
    if (! (npMCI->dwFlags & MCIAVI_UPDATING)) {
#ifdef DEBUG
        extern int giDebugLevel, giTimingLevel;
        int oldDebugLevel = giDebugLevel;
        giDebugLevel = max(giTimingLevel, oldDebugLevel);
#endif

#ifdef SHOWSKIPPED
	if (wSkipped) {
	    DPF(("Skipped: "));
	    for (w = 0; w < wSkipped; w++) {
		DPF(("!%ld ", lSkipped[w]));
	    }
	    DPF(("!\n"));
	}
#endif

#ifdef WAITHISTOGRAM
	if (npMCI->wPlaybackAlg == MCIAVI_ALG_INTERLEAVED) {
	    DPF(("Wait histogram: "));
	    for (w = 0; (int)w <= (int)npMCI->wABs; w++) {
		if (wHist[w]) {
		    DPF(("![%d]: %d  ",w,wHist[w]));
		}
	    }
	    DPF(("!\n"));
	}
#endif
#ifdef BEHINDHIST
	DPF(("Behind histogram: "));
	for (w = 0; w <= NUMBEHIND; w++) {
	    if (wBehind[w]) {
		DPF(("![%d]: %d  ",w - BEHINDOFFSET,wBehind[w]));
	    }
	}
	DPF(("!\n"));
#endif
#ifdef DRAWTIMEHIST
	DPF(("Draw times: "));
	for (w = 0; w < wDrawn; w++) {
	    DPF(("!%lu ", dwDrawTime[w]));
	}
	DPF(("!\n"));
#endif

#ifdef READTIMEHIST
	DPF(("Read times: "));
	for (w = 0; w < wRead; w++) {
	    DPF(("!%lu ", dwReadTime[w]));
	}
	DPF(("!\n"));
#endif

#ifdef TIMEPLAY
	#define SEC(time)    (UINT)(npMCI->time / 1000l) , (UINT)(npMCI->time % 1000l)
	#define SECX(time,t) SEC(time) , (npMCI->t ? (UINT)(npMCI->time * 100l / npMCI->t) : 0)

	DPF(("***********************************************************\r\n"));
	DPF(("    timePlay:         %3d.%03dsec\r\n",SEC(timePlay)));
	DPF(("     timeRead:        %3d.%03dsec (%d%%)\r\n",SECX(timeRead, timePlay)));
	DPF(("     timeWait:        %3d.%03dsec (%d%%)\r\n",SECX(timeWait, timePlay)));
	DPF(("     timeYield:       %3d.%03dsec (%d%%)\r\n",SECX(timeYield, timePlay)));
	DPF(("     timeVideo:       %3d.%03dsec (%d%%)\r\n",SECX(timeVideo, timePlay)));
	DPF(("      timeDraw:       %3d.%03dsec (%d%%)\r\n",SECX(timeDraw, timeVideo)));
	DPF(("      timeDecompress: %3d.%03dsec (%d%%)\r\n",SECX(timeDecompress, timeVideo)));
	DPF(("     timeAudio:       %3d.%03dsec (%d%%)\r\n",SECX(timeAudio, timePlay)));
	DPF(("     timeOther:       %3d.%03dsec (%d%%)\r\n",SECX(timeOther, timePlay)));
	DPF(("    timePaused:       %3d.%03dsec\r\n",SEC(timePaused)));
	DPF(("    timePrepare:      %3d.%03dsec\r\n",SEC(timePrepare)));
	DPF(("    timeCleanup:      %3d.%03dsec\r\n",SEC(timeCleanup)));
	DPF(("***********************************************************\r\n"));
#endif

#ifdef INTERVAL_TIMES
// frame interval timing

        if (npMCI->nFrames > 2) {
            int i;

            DPF(("-- %ld frames, ave interval %ld ms\r\n", npMCI->nFrames,
                npMCI->msFrameTotal/(npMCI->nFrames-1)));
            DPF(("-- min %ld ms, max %ld ms\r\n", npMCI->msFrameMin, npMCI->msFrameMax));
            DPF(("-- sd = sqrt(%ld)\r\n",
                        (npMCI->msSquares -
                          MulDiv(npMCI->msFrameTotal,
                                 npMCI->msFrameTotal,
                                 npMCI->nFrames-1)
                        ) / (npMCI->nFrames-2)
               ));
            for (i = 3; i < NBUCKETS-3; i++) {
                DPF(("%d ms:  %d\r\n", i * 10, npMCI->buckets[i]));
            }

	    DPF(("Actual intervals:\r\n"));
	    for (i = 1; i < min(npMCI->cIntervals,npMCI->nFrames); i++) {
		DPF(("!%3ld ", *(npMCI->paIntervals+i)));
                if ((fOneIntervalPerLine) || ((i % 20) == 0))
		    DPF(("!\n"));
	    }
	    DPF(("!\r\n"));
	}

	if (npMCI->nReads > 0) {
	    DPF(("-- %ld disk reads, ave %ld ms, max %ld ms\r\n",
		 npMCI->nReads,
		 npMCI->msReadTotal/(npMCI->nReads),
		 npMCI->msReadMax));
	}
#ifdef DEBUG
	giDebugLevel = oldDebugLevel;
#endif
#endif
    }


    }

#ifdef HIGHRESTIMER

    /* If we set a high resolution timer earlier... */
    if (npMCI->msPeriodResolution) {
	// Clear the timer resolution
	timeEndPeriod(npMCI->msPeriodResolution);
        DPF1(("Cleared the timer resolution from %d milliseconds\n", npMCI->msPeriodResolution));
        npMCI->msPeriodResolution = 0;
    }
#endif

    // if we are not stopping temporarily, then set task state to idle
    if (! (npMCI->dwFlags & MCIAVI_UPDATING)) {
	npMCI->wTaskState = TASKIDLE;
    }


    DPF(("mciaviPlayFile ending, dwTaskError==%d\n",npMCI->dwTaskError));
    if (npMCI->dwTaskError)
	return MCI_NOTIFY_FAILURE;

    if (npMCI->dwFlags & MCIAVI_REVERSE) {
	if (npMCI->lCurrentFrame <= npMCI->lTo)
	    return MCI_NOTIFY_SUCCESSFUL;
    } else {
	if (npMCI->lCurrentFrame >= npMCI->lTo)
	    return MCI_NOTIFY_SUCCESSFUL;
    }

    return MCI_NOTIFY_ABORTED;
}

static BOOL NEAR PASCAL RestartAVI(NPMCIGRAPHIC npMCI);
static BOOL NEAR PASCAL PauseAVI(NPMCIGRAPHIC npMCI);
static BOOL NEAR PASCAL BePaused(NPMCIGRAPHIC npMCI);

/******************************************************************************
 *****************************************************************************/

#ifdef DEBUG

INLINE void FillR(HDC hdc, LPRECT prc, DWORD rgb)
{
    SetBkColor(hdc,rgb);
    ExtTextOut(hdc,0,0,ETO_OPAQUE,prc,NULL,0,NULL);
}

void StatusBar(NPMCIGRAPHIC npMCI, int n, int dx, int max, int cur)
{
    HDC hdc;
    RECT rc;

    if (npMCI->dwFlags & MCIAVI_FULLSCREEN)
	return;

    if (cur > max)
	cur = max+1;

    if (cur < 0)
	cur = 0;

    /*
     * If the window is iconic, or there is no title bar, return
     * without painting the status bars.
     */

    if (!IsWindow(npMCI->hwndPlayback) || IsIconic(npMCI->hwndPlayback)) {
        return;
    }
    if (!(GetWindowLong((npMCI->hwndPlayback), GWL_STYLE) & WS_CAPTION)) {
        return;
    }

    hdc = GetWindowDC(npMCI->hwndPlayback);

    //
    //  show the amount of audio and how far behind we are
    //
    rc.left = 32;
    rc.top  = 4 + n*5;
    rc.bottom = rc.top + 4;

    rc.right = rc.left + cur * dx;

    FillR(hdc, &rc, RGB(255,255,0));

    rc.left = rc.right;
    rc.right = rc.left + (max - cur) * dx;

    FillR(hdc, &rc, RGB(255,0,0));

    ReleaseDC(npMCI->hwndPlayback, hdc);
}

#else

#define StatusBar(p,a,b,c,d)

#endif

/******************************************************************************
 *****************************************************************************/

BOOL NEAR PASCAL PlayInterleaved(NPMCIGRAPHIC npMCI)
{
    LONG iFrame;
    LONG iKey;
    LONG iNextKey;
    LONG iPrevKey;
    BOOL fHurryUp=FALSE;
    int  iHurryUp=0;
    BOOL fPlayedAudio = FALSE;
    BOOL f;

    DPF2(("PlayInterleaved, npMCI=%8x\n",npMCI));

    /* If lCurrentFrame == lFrames, we're really at the end of
    ** the file, so there isn't another record to read.
    */
    if (npMCI->lCurrentFrame < npMCI->lFrames) {
	/* Read new record into buffer */

	DPF2(("Reading", iFrame = (LONG)timeGetTime()));
	TIMESTART(timeRead);
	f = ReadRecord(npMCI);
	TIMEEND(timeRead);
	DPF2((".done %ldms\n", (LONG)timeGetTime() - iFrame));

	if (!f) {
	    npMCI->dwTaskError = MCIERR_INVALID_FILE;
	    DPF(("Error reading frame #%ld\n", npMCI->lCurrentFrame));
	    return FALSE;
	}


	if (npMCI->hWave && npMCI->lCurrentFrame >= npMCI->lAudioStart) {
	    TIMESTART(timeAudio);
	    if (!PlayRecordAudio(npMCI, &fHurryUp, &fPlayedAudio)) {
		DPF(("Error playing frame #%ld audio\n", npMCI->lCurrentFrame));
		return FALSE;
	    }
	    TIMEEND(timeAudio);
	}
    }

    /* If we're at the right frame, and we haven't started yet,
    ** then begin play and start timing.
    */

    if ((npMCI->lCurrentFrame > npMCI->lRealStart + (LONG) npMCI->dwBufferedVideo) &&
			(npMCI->wTaskState != TASKPLAYING)) {

	if (!(npMCI->dwFlags & MCIAVI_PAUSE)) {
	    goto RestartPlay0;
	} else {
	    // We were paused already, and now we're restarting or pausing
	    // again... so we've already done the KeepFilling stuff to pre-fill
	    // our buffers. If we don't skip over the KeepFilling stuff we'll
	    // roll ahead.
	    PauseAVI(npMCI);
	    goto BePaused0;
        }
    }

    if (npMCI->wTaskState == TASKPLAYING) {
	if (npMCI->dwFlags & MCIAVI_PAUSE) {

	    PauseAVI(npMCI);

#ifndef _WIN32
// no way do we want to do this on NT.  If you get a slow disk, you will
// never get to pause because we can't get the stuff in fast enough to keep up
// !!! The above is not necessarily true

	    /* The line below says that if we're trying to pause,
	    ** but we're behind on our audio, we should keep playing
	    ** for a little bit so that our audio buffers get full.
	    ** This way we'll be all cued up when we RESUME and be less
	    ** likely to fall behind.
	    ** The jerky playback fix makes us use big buffers now so
	    ** the last buffer can never be totally filled, so it's OK
	    ** to stop after filling up (total - 1) buffers.
	    */
	    if (fPlayedAudio && npMCI->wABFull < npMCI->wABs - 1)
		goto KeepFilling;
#endif


BePaused0:
	    BePaused(npMCI);

RestartPlay0:
	    if (npMCI->dwFlags & MCIAVI_STOP)
		return FALSE;

	    if (TimeToQuit(npMCI))
		return FALSE;

	    RestartAVI(npMCI);
	}
    }

#ifndef _WIN32
KeepFilling:
#endif
    if (npMCI->lCurrentFrame > npMCI->lVideoStart &&
	npMCI->lCurrentFrame < npMCI->lFrames &&
	npMCI->wTaskState == TASKPLAYING) {

	iFrame = WhatFrameIsItTimeFor(npMCI);

	if (iFrame >= npMCI->lFrames)
	    goto dontskip;

	iHurryUp = (int)(iFrame - npMCI->lCurrentFrame);
	fHurryUp = iHurryUp > gwHurryTolerance;


	if (iHurryUp > 1 && npMCI->hpFrameIndex && (npMCI->dwOptionFlags & MCIAVIO_SKIPFRAMES)) {

	    //
	    //  WE ARE BEHIND!!! by one or more frames.
	    //
	    //  if we are late we can do one of the following:
	    //
	    //      dont draw frames but keep reading/decompressing them
	    //      (ie set fHurryUp)
	    //
	    //      skip ahead to a key frame.
	    //
	    // !!! If we're very close to the next key frame, be more
	    // willing to skip ahead....
	    //

	    if (iHurryUp > gwSkipTolerance) {

		iNextKey = FrameNextKey(iFrame);
		iPrevKey = FramePrevKey(iFrame);

		if (iPrevKey > npMCI->lCurrentFrame &&
		    iFrame - iPrevKey < gwHurryTolerance &&
		    iNextKey - iFrame > gwSkipTolerance) {

		    DPF2(("Skipping from %ld to PREV KEY %ld (time for %ld next key=%ld).\n", npMCI->lCurrentFrame, iPrevKey, iFrame, iNextKey));
		    iKey = iPrevKey;
		}
		// !!! We'll only skip if the key frame is at most as far
		// ahead as we are behind.....
		else if (iNextKey > npMCI->lCurrentFrame &&
		    iNextKey <= iFrame + gwSkipTolerance /*gwMaxSkipEver*/) {
		    DPF2(("Skipping from %ld to NEXT KEY %ld (time for %ld prev key=%ld).\n", npMCI->lCurrentFrame, iNextKey, iFrame, iPrevKey));
		    iKey = iNextKey;
		} else {
		    DPF2(("WANTED to skip from %ld to %ld (time for %ld)!\n", npMCI->lCurrentFrame,iNextKey,iFrame));
		    goto dontskip;
		}

		npMCI->lVideoStart = iKey;
		npMCI->dwSkippedFrames += iKey - npMCI->lCurrentFrame;
dontskip:
		fHurryUp = TRUE;
	    }
	    else {
		iKey = FrameNextKey(npMCI->lCurrentFrame);

		if (iKey - npMCI->lCurrentFrame > 0 &&
		    iKey - npMCI->lCurrentFrame <= gwHurryTolerance) {
		    DPF2(("Skipping from %ld to next key frame %ld (time for %ld).\n", npMCI->lCurrentFrame, iKey, iFrame));

		    npMCI->dwSkippedFrames += iKey - npMCI->lCurrentFrame;
		    npMCI->lVideoStart = iKey;
		    fHurryUp = TRUE;
		}
	    }
	}
    }

    if (npMCI->dwFlags & MCIAVI_WAVEPAUSED)
	fHurryUp = TRUE;

    /* If we've actually started timing:
    **  Check if we should send a signal.
    **  Check to see if we should break out of the loop.
    **  Wait until it's time for the next frame.
    */
    if (npMCI->wTaskState == TASKPLAYING &&
	npMCI->lCurrentFrame >= npMCI->lVideoStart) {

	if (npMCI->dwSignals)
	    CheckSignals(npMCI, npMCI->lCurrentFrame - npMCI->dwBufferedVideo);

#ifdef WAITHISTOGRAM
	/* Adjust to achieve proper tension. */
	if (fPlayedAudio) {
	    /* If we're playing, keep statistics about how we're doing. */
	    ++wHist[npMCI->wABFull];
	}
#endif

	if (!WaitTillNextFrame(npMCI))
	    return FALSE;
    }

    if (npMCI->lCurrentFrame >= npMCI->lVideoStart &&
	npMCI->lCurrentFrame < npMCI->lFrames) {

#ifdef SHOWSKIPPED
	if (fHurryUp && wSkipped < NUMSKIPSSHOWN) {
	    lSkipped[wSkipped++] = npMCI->lCurrentFrame;
	}
#endif
	/* hold critsec round all worker thread drawing */
	EnterHDCCrit(npMCI);
	TIMESTART(timeVideo);
	if (!DisplayVideoFrame(npMCI, fHurryUp)) {
	    npMCI->dwTaskError = MCIERR_AVI_DISPLAYERROR;
	    TIMEZERO(timeVideo);
	    LeaveHDCCrit(npMCI);
	    return FALSE;
	}

	TIMEEND(timeVideo);
	LeaveHDCCrit(npMCI);

#ifdef DRAWTIMEHIST
	if (!fHurryUp && (wDrawn < NUMDRAWN)) {
	    dwDrawTime[wDrawn++] = npMCI->dwLastDrawTime;
	}
#endif
    }

    StatusBar(npMCI, 0, 4, npMCI->wABs, npMCI->wABFull);
    StatusBar(npMCI, 1, 4, npMCI->wABs, npMCI->wABs - iHurryUp);

#ifdef AVIREAD
    if ((npMCI->hAviRd) && (npMCI->lpBuffer != NULL)) {
	/* finished with this buffer - put back on queue */
	avird_emptybuffer(npMCI->hAviRd, npMCI->lpBuffer);
	npMCI->lpBuffer = NULL;
    }
#endif

    DPF2(("PlayInterleaved...ENDING, npMCI=%8x, TaskState=%d\n", npMCI, npMCI->wTaskState));
    return TRUE;
}

/******************************************************************************
 *****************************************************************************/

BOOL NEAR PASCAL PlayNonInterleaved(NPMCIGRAPHIC npMCI)
{
    BOOL fHurryUp = FALSE;
    int  iHurryUp;
    LONG iFrame;
    LONG iKey;
    LONG iNextKey;
    LONG iPrevKey;

    DPF2(("PlayNonInterleaved, npMCI=%8x\n",npMCI));
    if (npMCI->hWave) {
	TIMESTART(timeAudio);
	KeepPlayingAudio(npMCI);
	TIMEEND(timeAudio);
    }

    if (npMCI->wTaskState == TASKPLAYING) {

	iFrame = WhatFrameIsItTimeFor(npMCI);

	if (iFrame >= npMCI->lFrames)
	    goto dontskip;

	if (npMCI->dwFlags & MCIAVI_REVERSE) {

	    /* Since we're going backwards, always skip to key frame. */
	    DPF3(("  Current = %ld, time for %ld.\n", npMCI->lCurrentFrame, iFrame));

	    iFrame = FramePrevKey(iFrame);

	    // !!! Send signals for skipped frames?
	    npMCI->dwFramesSeekedPast += npMCI->lCurrentFrame - iFrame;
	    npMCI->dwSkippedFrames += npMCI->lCurrentFrame - iFrame;
	    npMCI->lCurrentFrame = iFrame;
	} else if (npMCI->lCurrentFrame < npMCI->lFrames) {

#ifdef BEHINDHIST
	    {
	    int      iDelta;
	    iDelta = iFrame - npMCI->lCurrentFrame + BEHINDOFFSET;
	    iDelta = min(NUMBEHIND, max(0, iDelta));
	    wBehind[iDelta]++;
	    }
#endif
	    iHurryUp = (int)(iFrame - npMCI->lCurrentFrame);
	    fHurryUp = iHurryUp > gwHurryTolerance;

	    if (iHurryUp > 1 && npMCI->hpFrameIndex && (npMCI->dwOptionFlags & MCIAVIO_SKIPFRAMES)) {

		//
		//  WE ARE BEHIND!!! by one or more frames.
		//
		//  if we are late we can do one of the following:
		//
		//      dont draw frames but keep reading/decompressing them
		//      (ie set fHurryUp)
		//
		//      skip ahead to a key frame.
		//
		// !!! If we're very close to the next key frame, be more
		// willing to skip ahead....
		//

		if (iHurryUp > gwSkipTolerance) {

		    iNextKey = FrameNextKey(iFrame);
		    iPrevKey = FramePrevKey(iFrame);

		    if (iPrevKey > npMCI->lCurrentFrame &&
			iFrame - iPrevKey < gwHurryTolerance &&
			iNextKey - iFrame > gwSkipTolerance) {

			DPF2(("Skipping from %ld to PREV KEY %ld (time for %ld next key=%ld).\n", npMCI->lCurrentFrame, iPrevKey, iFrame, iNextKey));

			iKey = iPrevKey;
			fHurryUp = TRUE;
		    }
		    // !!! We'll only skip if the key frame is at most as far
		    // ahead as we are behind.....
		    else if (iNextKey > npMCI->lCurrentFrame &&
			iNextKey <= iFrame + gwSkipTolerance /*gwMaxSkipEver*/) {
			DPF2(("Skipping from %ld to NEXT KEY %ld (time for %ld prev key=%ld).\n", npMCI->lCurrentFrame, iNextKey, iFrame, iPrevKey));
			iKey = iNextKey;        // assume next key
			fHurryUp = FALSE;
		    } else {
			DPF2(("WANTED to skip from %ld to %ld (time for %ld)!\n", npMCI->lCurrentFrame,iNextKey,iFrame));
			goto dontskip;
		    }

		    npMCI->dwFramesSeekedPast += iKey - npMCI->lCurrentFrame;
		    npMCI->dwSkippedFrames += iKey - npMCI->lCurrentFrame;
		    npMCI->lCurrentFrame = iKey;
dontskip:
		    ;
		}
		else if (FramePrevKey(iFrame) == iFrame) {
		    DPF2(("Skipping from %ld to %ld (time for key frame).\n", npMCI->lCurrentFrame, iFrame));

		    iKey = iFrame;
		    npMCI->dwFramesSeekedPast += iKey - npMCI->lCurrentFrame;
		    npMCI->dwSkippedFrames += iKey - npMCI->lCurrentFrame;
		    npMCI->lCurrentFrame = iKey;

		    fHurryUp = FALSE;
		}
		else {
		    iKey = FrameNextKey(npMCI->lCurrentFrame);

		    if (iKey > npMCI->lCurrentFrame &&
			iKey - npMCI->lCurrentFrame <= gwHurryTolerance) {
			DPF2(("Skipping from %ld to next key frame %ld (time for %ld).\n", npMCI->lCurrentFrame, iKey, iFrame));

			npMCI->dwFramesSeekedPast += iKey - npMCI->lCurrentFrame;
			npMCI->dwSkippedFrames += iKey - npMCI->lCurrentFrame;
			npMCI->lCurrentFrame = iKey;

			fHurryUp = ((iKey - iFrame) > gwHurryTolerance);
		    }
		}
	    }

	    StatusBar(npMCI, 0, 4, npMCI->wABs, npMCI->wABFull);
	    StatusBar(npMCI, 1, 4, npMCI->wABs, npMCI->wABs - iHurryUp);
	}
    }

    // !!! Somewhere in here, read other streams.
    // Should this be before, or after, video?

    /* If lCurrentFrame == lFrames, we're really at the end of
    ** the file, so there isn't another record to read.
    */
    if (npMCI->lCurrentFrame < npMCI->lFrames) {
	/* Read new record into buffer */

	npMCI->dwLastReadTime = (DWORD)(-(LONG)timeGetTime());
	TIMESTART(timeRead);
	if (!ReadNextVideoFrame(npMCI, NULL)) {
	    npMCI->dwTaskError = MCIERR_INVALID_FILE;
	    DPF2(("Error reading frame #%ld\n", npMCI->lCurrentFrame));
	    return FALSE;
	}
	TIMEEND(timeRead);

	npMCI->dwLastReadTime += timeGetTime();
	npMCI->lLastRead = npMCI->lCurrentFrame;

#ifdef READTIMEHIST
	if (wRead < NUMREAD) {
	    dwReadTime[wRead++] = npMCI->dwLastReadTime;
    }
#endif
    }

    /* If we're at the right frame, and we haven't started yet,
    ** then begin play and start timing.
    */
    if ((((npMCI->lCurrentFrame > (npMCI->lRealStart +
					(LONG) npMCI->dwBufferedVideo)) &&
			(npMCI->lCurrentFrame < (npMCI->lTo))) ||
			(npMCI->dwFlags & MCIAVI_REVERSE)) &&
			(npMCI->wTaskState != TASKPLAYING) &&
			!(npMCI->dwFlags & MCIAVI_SEEKING)) {
	if (!(npMCI->dwFlags & MCIAVI_PAUSE)) {
	    goto RestartPlay;
	} else
	    goto PauseNow;
    }

    /* If we've actually started timing:
    **  Check if we should send a signal.
    **  Check to see if we should return FALSE out of the loop.
    **  Wait until it's time for the next frame.
    */
    if (npMCI->wTaskState == TASKPLAYING) {
	if (npMCI->dwFlags & MCIAVI_PAUSE) {
PauseNow:
	    PauseAVI(npMCI);

	    BePaused(npMCI);

RestartPlay:
	    if (TimeToQuit(npMCI))
		return FALSE;

	    RestartAVI(npMCI);
	}

	if (npMCI->dwSignals)
	    CheckSignals(npMCI, npMCI->lCurrentFrame - npMCI->dwBufferedVideo);

	if (npMCI->lCurrentFrame < npMCI->lFrames + (LONG) npMCI->dwBufferedVideo) {
	    while (1) {
		iFrame = WhatFrameIsItTimeFor(npMCI);

		TIMESTART(timeYield);
		aviTaskCheckRequests(npMCI);
		TIMEEND(timeYield);

		if (npMCI->dwFlags & MCIAVI_REVERSE) {
		    if (iFrame <= npMCI->lCurrentFrame)
			break;

		    if (npMCI->lCurrentFrame < npMCI->lTo)
			break;
		} else {
		    if (iFrame >= npMCI->lCurrentFrame)
			break;

		    if (npMCI->lCurrentFrame > npMCI->lTo)
			break;
		}

		if (npMCI->hWave) {
		    TIMESTART(timeAudio);
		    KeepPlayingAudio(npMCI);
		    TIMEEND(timeAudio);
		}

		DPF3(("Waiting:  Current = %ld, time for %ld.\n", npMCI->lCurrentFrame, iFrame));
		if (!(npMCI->dwFlags & MCIAVI_REVERSE)) {
		    WaitTillNextFrame(npMCI);
		}

		if (TimeToQuit(npMCI))
		    return FALSE;
	    }
	}

	if (TimeToQuit(npMCI))
	    return FALSE;
    }

    if (((npMCI->lCurrentFrame >= npMCI->lVideoStart) &&
	    (npMCI->lCurrentFrame < npMCI->lFrames)) ||
	(npMCI->dwFlags & MCIAVI_REVERSE)) {

	// Quick exit if we are being told to stop
	if (npMCI->dwFlags & MCIAVI_STOP) {
	    return(FALSE);
	}

	EnterHDCCrit(npMCI);
	TIMESTART(timeVideo);
	if (!DisplayVideoFrame(npMCI, fHurryUp)) {
	    npMCI->dwTaskError = MCIERR_AVI_DISPLAYERROR;
	    TIMEZERO(timeVideo);
	    LeaveHDCCrit(npMCI);
	    return FALSE;
	}
	
	TIMEEND(timeVideo);
	LeaveHDCCrit(npMCI);
#ifdef DRAWTIMEHIST
	if (!fHurryUp && (wDrawn < NUMDRAWN)) {
	    dwDrawTime[wDrawn++] = npMCI->dwLastDrawTime;
	}
#endif
    }

    //
    // now is a good time to deal with other streams
    //
    if (npMCI->nOtherStreams > 0 || npMCI->nVideoStreams > 1) {

	if (npMCI->wTaskState != TASKPLAYING)
	    iFrame = npMCI->lCurrentFrame;

	TIMESTART(timeOther);
	DealWithOtherStreams(npMCI, iFrame);
	TIMEEND(timeOther);
    }

    DPF2(("PlayNONInterleaved...ENDING, npMCI=%8x, TaskState=%d\n", npMCI, npMCI->wTaskState));
    return TRUE;
}

/******************************************************************************
 *****************************************************************************/

BOOL NEAR PASCAL PlayAudioOnly(NPMCIGRAPHIC npMCI)
{
    DPF2(("PlayAudioOnly, npMCI=%8x\n",npMCI));
    npMCI->lFrameDrawn = npMCI->lCurrentFrame;

    if (npMCI->hWave) {
	TIMESTART(timeAudio);
	KeepPlayingAudio(npMCI);
	TIMEEND(timeAudio);
    }

    /* If we're at the right frame, and we haven't started yet,
    ** then begin play and start timing.
    */
    if ((npMCI->wTaskState != TASKPLAYING) &&
			!(npMCI->dwFlags & MCIAVI_SEEKING)) {
	if (!(npMCI->dwFlags & MCIAVI_PAUSE)) {
	    goto RestartPlay;
	} else
	    goto PauseNow;
    }

    /* If we've actually started timing:
    **  Check if we should send a signal.
    **  Check to see if we should return FALSE out of the loop.
    **  Wait until it's time for the next frame.
    */
    if (npMCI->wTaskState == TASKPLAYING) {

	npMCI->lCurrentFrame = WhatFrameIsItTimeFor(npMCI);

	if (npMCI->dwFlags & MCIAVI_PAUSE) {
PauseNow:
	    PauseAVI(npMCI);

	    BePaused(npMCI);

RestartPlay:
	    if (TimeToQuit(npMCI))
		return FALSE;

	    RestartAVI(npMCI);
	}

	if (npMCI->dwSignals)
	    CheckSignals(npMCI, npMCI->lCurrentFrame - npMCI->dwBufferedVideo);

	//
	// dont yield if updating
	//
	if (!(npMCI->dwFlags & MCIAVI_UPDATING)) {
	    TIMESTART(timeYield);
	    aviTaskCheckRequests(npMCI);
	    TIMEEND(timeYield);
	}

	if (TimeToQuit(npMCI))
	    return FALSE;
    }

    return TRUE;
}

/******************************************************************************
 *****************************************************************************/

#ifdef USENONINTFROMCD	
#pragma message("PlayNonIntFromCD needs fixed?")

BOOL NEAR PASCAL PlayNonIntFromCD(NPMCIGRAPHIC npMCI)
{
    BOOL fHurryUp = FALSE;
    LONG lNewFrame;
    DWORD ckid;
    UINT wStream;

    DPF2(("PlayNonIntFromCD, npMCI=%8x\n",npMCI));
AnotherChunk:
    /* If lCurrentFrame == lFrames, we're really at the end of
    ** the file, so there isn't another record to read.
    */
    if (npMCI->lCurrentFrame < npMCI->lFrames) {
	/* Read new record into buffer */

	TIMESTART(timeRead);
	ckid = ReadNextChunk(npMCI);
	TIMEEND(timeRead);

	if (ckid == 0) {
	    npMCI->dwTaskError = MCIERR_INVALID_FILE;
	    DPF(("Error reading frame #%ld\n", npMCI->lCurrentFrame));
	    return FALSE;
	}

	npMCI->lLastRead = npMCI->lCurrentFrame;
	wStream = StreamFromFOURCC(ckid);

	if (wStream == (UINT) npMCI->nVideoStream) {
	    if (TWOCCFromFOURCC(ckid) == cktypePALchange) {
		npMCI->lp += 2 * sizeof(DWORD);
		ProcessPaletteChange(npMCI, npMCI->dwThisRecordSize -
							    2 * sizeof(DWORD));
		npMCI->lLastPaletteChange = npMCI->lCurrentFrame;
		goto AnotherChunk;
	    }
	} else if (wStream == (UINT) npMCI->nAudioStream) {
	    TIMESTART(timeAudio);
	    if (npMCI->hWave)
		HandleAudioChunk(npMCI);
	    TIMEEND(timeAudio);
	    goto AnotherChunk;
	} else {
	    goto AnotherChunk;
	}
    }

    if (npMCI->wTaskState == TASKPLAYING) {
	lNewFrame = WhatFrameIsItTimeFor(npMCI);

	DPF3(("  Current = %ld, time for %ld.\n", npMCI->lCurrentFrame, lNewFrame));
	if (npMCI->lCurrentFrame < lNewFrame) {
	    fHurryUp = TRUE;
	}
    }

    /* If we're at the right frame, and we haven't started yet,
    ** then begin play and start timing.
    */
    if ((npMCI->lCurrentFrame > npMCI->lRealStart + (LONG) npMCI->dwBufferedVideo) &&
			(npMCI->lCurrentFrame < npMCI->lTo) &&
			(npMCI->wTaskState != TASKPLAYING)) {

	if (!(npMCI->dwFlags & MCIAVI_PAUSE)) {
	    goto RestartPlay;
	} else
	    goto PauseNow;
    }

    /* If we've actually started timing:
    **  Check if we should send a signal.
    **  Check to see if we should return FALSE out of the loop.
    **  Wait until it's time for the next frame.
    */
    if (npMCI->wTaskState == TASKPLAYING) {
	if (npMCI->dwFlags & MCIAVI_PAUSE) {
PauseNow:
	    PauseAVI(npMCI);

	    BePaused(npMCI);

RestartPlay:
	    if (TimeToQuit(npMCI))
		return FALSE;

	    RestartAVI(npMCI);
	}

	if (npMCI->dwSignals)
	    CheckSignals(npMCI, npMCI->lCurrentFrame - npMCI->dwBufferedVideo);

WaitMore:              ///////WAITING//////////
	lNewFrame = WhatFrameIsItTimeFor(npMCI);

	TIMESTART(timeYield);
	aviTaskCheckRequests(npMCI);
	TIMEEND(timeYield);

	if (lNewFrame < npMCI->lCurrentFrame) {
	    DPF3(("Waiting:  Current = %ld, time for %ld.\n", npMCI->lCurrentFrame, lNewFrame));
	    WaitTillNextFrame(npMCI);
	    if (TimeToQuit(npMCI))
		return FALSE;
	    else
		goto WaitMore;
	}
    }

    if (npMCI->lCurrentFrame >= npMCI->lVideoStart) {
	TIMESTART(timeVideo);
	EnterHDCCrit(npMCI);
	if (!DisplayVideoFrame(npMCI, fHurryUp)) {
	    npMCI->dwTaskError = MCIERR_AVI_DISPLAYERROR;
	    TIMEZERO(timeVideo);
	    LeaveHDCCrit(npMCI);
	    return FALSE;
	}
	TIMEEND(timeVideo);
	LeaveHDCCrit(npMCI);
    }

    return TRUE;
}
#endif


/******************************************************************************
 *****************************************************************************/

STATICFN INLINE LONG waveTime(NPMCIGRAPHIC npMCI, LONG lTime)
{
	if (gfUseGetPosition && npMCI->wABFull > 0) {
	    MMTIME	mmtime;
            LONG        lTimeInc;
	
            mmtime.wType = TIME_SAMPLES;
	
            waveOutGetPosition(npMCI->hWave, &mmtime, sizeof(mmtime));
            if (mmtime.wType == TIME_SAMPLES)
		lTimeInc = muldiv32(mmtime.u.sample,
				  1000L, npMCI->pWF->nSamplesPerSec);
	    else if (mmtime.wType == TIME_BYTES)
		lTimeInc = muldiv32(mmtime.u.cb,
		                  1000L, npMCI->pWF->nAvgBytesPerSec);
	    else
		goto ack2;

            //DPF0(("lTime: %3d,  LastDraw: %4d,  lTimeInc: %5d ",
            //       lTime,        npMCI->dwLastDrawTime,        lTimeInc));
            lTime = lTimeInc + npMCI->dwLastDrawTime;
	    // !!! this is too accurate: adjust by 100ms to match old SB...
	    lTime = max(0, lTime - giGetPositionAdjust);
	} else {
ack2:
	lTime += muldiv32(npMCI->dwAudioPlayed,
			   1000L, npMCI->pWF->nAvgBytesPerSec);
        }
	return(lTime);
}


INLINE LONG GetVideoTime(NPMCIGRAPHIC npMCI)
{
    //
    //  NOTE we must grab dwTimingStart *before* calling
    //  timeGetTime() because dwTimingStart is changed in the wave
    //  callback and we dont want to have time go backward.
    //
    LONG lTime = (volatile DWORD)npMCI->dwTimingStart;   // grab this as one unit!

    lTime = (LONG)timeGetTime() - lTime
	+ npMCI->dwLastDrawTime
//      + npMCI->dwLastReadTime
	;

    Assert(lTime >= 0);

    if (npMCI->hWave) {

	if (npMCI->dwFlags & MCIAVI_WAVEPAUSED)	{
	    lTime = 0;
    }

	lTime = waveTime(npMCI, lTime);
    }
    return(lTime);
}

/* This function returns what frame we should be on. */
LONG NEAR PASCAL WhatFrameIsItTimeFor(NPMCIGRAPHIC npMCI)
{
    LONG        lTime;
    LONG        lFrame;

    // If timing is off, it's always just time to play the current frame.
    if (npMCI->dwPlayMicroSecPerFrame == 0)
	return npMCI->lCurrentFrame;

    //
    // if we have not started playing npMCI->dwTimingStart is bogus
    //
    Assert(npMCI->wTaskState == TASKPLAYING);
    AssertFrame(npMCI->lCurrentFrame - (LONG)npMCI->dwBufferedVideo);

    lTime = GetVideoTime(npMCI);

    /* Convert from MS to frames.... */
    //force round down - subtract half a frame
    lTime -= (npMCI->dwPlayMicroSecPerFrame / 2000);
    if (lTime < 0) {
	lTime = 0;
	lFrame = 0;
    } else {
	lFrame = muldiv32(lTime, 1000, npMCI->dwPlayMicroSecPerFrame);
    }

    if (npMCI->dwFlags & MCIAVI_REVERSE) {

	lFrame = npMCI->lFramePlayStart - lFrame;

	if (lFrame < npMCI->lTo)
	    lFrame = npMCI->lTo;
    }
    else {
	lFrame = lFrame + npMCI->lFramePlayStart + npMCI->dwBufferedVideo;

	if ((lFrame > npMCI->lTo) && (lFrame > npMCI->lCurrentFrame))
	    lFrame = npMCI->lTo;
    }




    if (lFrame > npMCI->lFrames + (LONG)npMCI->dwBufferedVideo || lFrame < 0) {
	DPF(("WhatFrameIsItTimeFor: bad frame %ld\n", lFrame));
	AssertSz(0, "bad frame in WhatFrameIsItTimeFor");
	lFrame = npMCI->lCurrentFrame;
    }

    return lFrame;
}

/******************************************************************************
 *****************************************************************************/

/* This function returns time to go until the target frame */
LONG NEAR PASCAL HowLongTill(NPMCIGRAPHIC npMCI)
{
    LONG        lTime;
    LONG        lTimeTarget;
    LONG        lFrameTarget = npMCI->lCurrentFrame;

    // If timing is off, it's always just time to play the current frame.
    if (npMCI->dwPlayMicroSecPerFrame == 0)
	return 0;

    //
    // if we have not started playing npMCI->dwTimingStart is bogus
    //
    Assert(npMCI->wTaskState == TASKPLAYING);

    // no longer valid because of last-frame-audio fix
    //AssertFrame(npMCI->lCurrentFrame - (LONG)npMCI->dwBufferedVideo);

    lTime = GetVideoTime(npMCI);

    if (npMCI->dwFlags & MCIAVI_REVERSE)
	lFrameTarget = npMCI->lFramePlayStart - lFrameTarget;
    else
	lFrameTarget -= npMCI->lFramePlayStart + npMCI->dwBufferedVideo;

    lTimeTarget = muldiv32(lFrameTarget, npMCI->dwPlayMicroSecPerFrame, 1000);

    //DPF0(("! >> %5d\n", lTimeTarget - lTime));
    return lTimeTarget - lTime;
}

/******************************************************************************
 *****************************************************************************/

static BOOL NEAR PASCAL PauseAVI(NPMCIGRAPHIC npMCI)
{
    DPF2(("PauseAVI\n"));
    if (npMCI->wTaskState == TASKPLAYING) {
	int stream;

	if (npMCI->hWave)
	    waveOutPause(npMCI->hWave);

	if (npMCI->hicDraw)
	    ICDrawStop(npMCI->hicDraw);

	for (stream = 0; stream < npMCI->streams; stream++) {
	    if (SI(stream)->hicDraw)
		ICDrawStop(SI(stream)->hicDraw);
	}

	npMCI->dwPauseTime = Now();
	npMCI->dwTotalMSec += npMCI->dwPauseTime - npMCI->dwMSecPlayStart;
    }

    if (npMCI->dwFlags & MCIAVI_WAITING) {
	// waiting for completion of a pause or cue request
	DPF3(("Releasing UI waiter\n"));
	SetEvent(npMCI->hEventAllDone);
	npMCI->dwFlags &= ~MCIAVI_WAITING;
    }

    // this flag is set to indicate that notify should be issued
    // when we reach a paused state (eg on Cue).
    if (npMCI->dwFlags & MCIAVI_CUEING) {
	/* If we're cueing, report that it was successful. */
	npMCI->dwFlags &= ~(MCIAVI_CUEING);
	GraphicDelayedNotify(npMCI, MCI_NOTIFY_SUCCESSFUL);
    }


    DPF2(("Pausing npMCI==%8x\n",npMCI));
    npMCI->wTaskState = TASKPAUSED;

    return TRUE;
}

/******************************************************************************
 *****************************************************************************/

static BOOL NEAR PASCAL BePaused(NPMCIGRAPHIC npMCI)
{
    DWORD dwObject;

    TIMEEND(timePlay);
    TIMESTART(timePaused);

    while (npMCI->dwFlags & MCIAVI_PAUSE) {

	if (npMCI->dwFlags & MCIAVI_STOP)
	    return FALSE;

	if (npMCI->dwFlags & MCIAVI_NEEDUPDATE) {
	    /* Since we're paused and we have nothing better
	    ** to do, update the screen.
	    */
	    DoStreamUpdate(npMCI, FALSE);
	}

	// block until told to do something else

	// need to handle send-messages to the ole windows -see mciaviTask()

    	do {
	    dwObject = MsgWaitForMultipleObjects(2, &npMCI->hEventSend,
			FALSE, INFINITE, QS_SENDMESSAGE);
	    if (dwObject == WAIT_OBJECT_0 + 2) {
		MSG msg;

		// just a single peekmessage with NOREMOVE will
		// process the inter-thread send and not affect the queue
		PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
	    }
	} while (dwObject == WAIT_OBJECT_0 + 2);

    	// find out what needed doing
	aviTaskCheckRequests(npMCI);

        if (npMCI->dwFlags & MCIAVI_WAITING) {
	    // waiting for completion of a pause or cue request
	    SetEvent(npMCI->hEventAllDone);
	    npMCI->dwFlags &= ~MCIAVI_WAITING;
	}

    }

    TIMEEND(timePaused);
    TIMESTART(timePlay);

    return TRUE;
}


/******************************************************************************
 *****************************************************************************/

static BOOL NEAR PASCAL RestartAVI(NPMCIGRAPHIC npMCI)
{
    int stream;

    Assert(npMCI->wTaskState != TASKPLAYING);

    /* Mark that play has actually begun */
    npMCI->wTaskState = TASKPLAYING;
    DPF(("Restart AVI, TaskState now TASKPLAYING, npMCI=%8x\n", npMCI));

#ifndef _WIN32
    TIMESTART(timeYield);
    aviTaskYield();
    aviTaskYield();
    aviTaskYield();
    TIMEEND(timeYield);
    DPF2(("Starting (done yielding)\n"));
#endif


    /* Reset clock and restart */

    if (npMCI->dwPauseTime == 0) {
	Assert(npMCI->dwTimingStart == 0);
    }

    npMCI->dwMSecPlayStart = Now(); // get the time we started playing

    //
    // if we were paused subtract off the time we spent paused from
    // the timing start
    //
    if (npMCI->dwPauseTime == 0)
	npMCI->dwTimingStart = npMCI->dwMSecPlayStart;
    else
	npMCI->dwTimingStart += (npMCI->dwMSecPlayStart - npMCI->dwPauseTime);

    if (npMCI->hWave)
	waveOutRestart(npMCI->hWave);

    if (npMCI->hicDraw)
	ICDrawStart(npMCI->hicDraw);

    for (stream = 0; stream < npMCI->streams; stream++) {
	if (SI(stream)->hicDraw)
	    ICDrawStart(SI(stream)->hicDraw);
    }

    DPF(("Returning from RestartAVI\n"));
    return TRUE;
}

/* This function sets up things that will be needed to play.
**
** Returns zero if no error, otherwise an MCI error code.
**
** Note: Even if this function returns an error, CleanUpPlay()
** will still be called, so we don't have to cleanup here.
*/
STATICFN DWORD NEAR PASCAL PrepareToPlay(NPMCIGRAPHIC npMCI)
{
    BOOL        fCDFile;
    BOOL        fNetFile;
    BOOL        fHardFile;

    Assert(npMCI->wTaskState != TASKPLAYING);

    //
    // lets choose the play back method:
    //
    //      playing reverse: (random access!)
    //          use MCIAVI_ALG_HARDDISK always (random access mode)
    //
    //      audio is preloaded: (will never happen?)
    //          on a CD-ROM   use MCIAVI_ALG_INTERLEAVED
    //          on a HARDDISK use MCIAVI_ALG_HARDDISK
    //          on a NET      use MCIAVI_ALG_HARDDISK
    //
    //      file is interleaved:
    //          on a CD-ROM   use MCIAVI_ALG_INTERLEAVED
    //          on a HARDDISK use MCIAVI_ALG_HARDDISK
    //          on a NET      use MCIAVI_ALG_HARDDISK
    //
    //      file is not interleaved:
    //          on a CD-ROM   use MCIAVI_ALG_CDROM
    //          on a HARDDISK use MCIAVI_ALG_HARDDISK
    //          on a NET      use MCIAVI_ALG_HARDDISK
    //

    fCDFile   = npMCI->uDriveType == DRIVE_CDROM;
    fNetFile  = npMCI->uDriveType == DRIVE_REMOTE;
    fHardFile = !fCDFile && !fNetFile;

    if (npMCI->nVideoStreams == 0 && npMCI->nOtherStreams == 0) {
	npMCI->wPlaybackAlg = MCIAVI_ALG_AUDIOONLY;
    } else if (npMCI->dwFlags & MCIAVI_REVERSE || npMCI->pf) {
        // avifile-handled files are always played as non-interleaved
        // though audio buffering might be different
	npMCI->wPlaybackAlg = MCIAVI_ALG_HARDDISK;
    }
    else if (npMCI->dwFlags & MCIAVI_NOTINTERLEAVED) {
#if 0
	if (fCDFile)
	    npMCI->wPlaybackAlg = MCIAVI_ALG_CDROM;
	else
#endif
	if (fNetFile)
	    npMCI->wPlaybackAlg = MCIAVI_ALG_HARDDISK;
	else
	    npMCI->wPlaybackAlg = MCIAVI_ALG_HARDDISK;
    }
    else {
	if (fCDFile)
	    npMCI->wPlaybackAlg = MCIAVI_ALG_INTERLEAVED;
#if 0
	else if (fNetFile)
	    npMCI->wPlaybackAlg = MCIAVI_ALG_HARDDISK;
	else
	    npMCI->wPlaybackAlg = MCIAVI_ALG_HARDDISK;
#else
	else if (fNetFile)
	    npMCI->wPlaybackAlg = MCIAVI_ALG_INTERLEAVED;
	else
	    npMCI->wPlaybackAlg = MCIAVI_ALG_INTERLEAVED;
#endif
    }

    // Interleaved playback doesn't work well at very low speeds!
    if ((npMCI->dwSpeedFactor < 100) &&
	(npMCI->wPlaybackAlg != MCIAVI_ALG_HARDDISK) &&
	(npMCI->wPlaybackAlg != MCIAVI_ALG_AUDIOONLY)) {
	DPF(("Was going to play interleaved, but speed < 10%% of normal...\n"));
	npMCI->wPlaybackAlg = MCIAVI_ALG_HARDDISK;
    }

#if 0
//
// sigh! we need to always have the index read now, so we do it in
// aviopen
//
    /* Be sure the index has been read, if we need it. */

    if (npMCI->hpFrameIndex == NULL)
	if (npMCI->wPlaybackAlg != MCIAVI_ALG_INTERLEAVED || npMCI->lFrom > 0)
	ReadIndex(npMCI);
#endif

#ifdef DEBUG
    switch (npMCI->wPlaybackAlg) {
	case MCIAVI_ALG_INTERLEAVED:
	    Assert(!(npMCI->dwFlags & MCIAVI_NOTINTERLEAVED));
	    DPF(("playing a interleaved file\n"));
	    break;

	case MCIAVI_ALG_CDROM:
	    Assert(npMCI->dwFlags & MCIAVI_NOTINTERLEAVED);
	    DPF(("playing a non interleaved file from CD-ROM\n"));
	    break;

	case MCIAVI_ALG_HARDDISK:
	    if (npMCI->dwFlags & MCIAVI_NOTINTERLEAVED)
		DPF(("random access play (non-interleaved file)\n"));
	    else
		DPF(("random access play (interleaved file)\n"));
	    break;

	case MCIAVI_ALG_AUDIOONLY:
	    Assert(npMCI->nAudioStreams);
	    DPF(("audio-only!\n"));
	    break;

	default:
	    Assert(0);
	    break;
    }
#endif

#if 0
    //
    // set a MMIO buffer if we are playing interleaved off a non cd-rom
    //
    if (npMCI->hmmio && fNetFile && npMCI->wPlaybackAlg == MCIAVI_ALG_INTERLEAVED) {

	#define BUFFER_SIZE (32l*1024)

	if (npMCI->lpMMIOBuffer == NULL) {

	    DPF(("Using %u byte MMIO buffer...\n", BUFFER_SIZE));

	    npMCI->lpMMIOBuffer = AllocMem(BUFFER_SIZE);

	    mmioSetBuffer(npMCI->hmmio, npMCI->lpMMIOBuffer, BUFFER_SIZE, 0);
	}

	//!!! should we do this for a seek?
	//!!! should we free this in CleanUpPlay?
    }
    else {
	if (npMCI->lpMMIOBuffer != NULL)
	    FreeMem(npMCI->lpMMIOBuffer);

	npMCI->lpMMIOBuffer = NULL;

	if (npMCI->hmmio)
	    mmioSetBuffer(npMCI->hmmio, NULL, 0, 0);
    }
#endif

    // !!!!
#ifdef DEBUG
    gwHurryTolerance = mmGetProfileInt(szIni, TEXT("Hurry"), 2);
    gwSkipTolerance = mmGetProfileInt(szIni, TEXT("Skip"), gwHurryTolerance * 2);
    gwMaxSkipEver = mmGetProfileInt(szIni, TEXT("MaxSkip"), max(60, gwSkipTolerance * 10));

#endif

    gfUseGetPosition = DEFAULTUSEGETPOSITION;	// !!! Detect WSS 1.0, 2.0?
    gfUseGetPosition = mmGetProfileInt(szIni, TEXT("GetPosition"), gfUseGetPosition);
    giGetPositionAdjust = mmGetProfileInt(szIni, TEXT("GetPositionAdjust"), 100);

#ifdef DEBUG
    if (gfUseGetPosition) {
	DPF2(("Using waveOutGetPosition adjusted by %dms instead of done bits...\n", giGetPositionAdjust));
    } else {
	DPF2(("NOT using waveOutGetPosition\n"));
    }
#endif

    Assert(npMCI->lTo <= npMCI->lFrames);
    Assert(npMCI->lFrom >= 0);

    /* Clear out variables, so we'll know what needs to be released. */
    /* Access to these variables should only ever be on the task thread */
    npMCI->hWave = NULL;
    npMCI->lpAudio = NULL;
    npMCI->lpBuffer = NULL;
    npMCI->dwBufferSize = 0L;
    npMCI->wABFull = 0;

    npMCI->dwSkippedFrames = 0L;
    npMCI->dwFramesSeekedPast = 0L;
    npMCI->dwAudioBreaks = 0L;

    npMCI->dwTotalMSec = 0;
    npMCI->dwLastDrawTime = 0;
    npMCI->dwLastReadTime = 0;
    npMCI->dwBufferedVideo = 0;
    npMCI->dwPauseTime = 0;
    npMCI->dwTimingStart = 0;

    /* Figure out how fast we're playing.... */
    if (npMCI->dwSpeedFactor)
	npMCI->dwPlayMicroSecPerFrame = muldiv32(npMCI->dwMicroSecPerFrame,
						 1000L,
						 npMCI->dwSpeedFactor);
    else
	npMCI->dwPlayMicroSecPerFrame = 0; // Special "play every frame" mode

    /* If we're already at the end, and we're going to repeat from the
    ** start of the file, just repeat now.
    */
    if ((npMCI->lFrom == npMCI->lTo) &&
		(npMCI->dwFlags & MCIAVI_REPEATING) &&
		(npMCI->lFrom != npMCI->lRepeatFrom)) {
	DPF(("Repeating from beginning before we've even started....\n"));
	npMCI->lFrom = npMCI->lRepeatFrom;
    }

    if (npMCI->lFrom == npMCI->lTo) {
	npMCI->dwFlags |= MCIAVI_SEEKING;
	npMCI->dwFlags &= ~(MCIAVI_REVERSE | MCIAVI_REPEATING);
    }

    if (npMCI->dwFlags & MCIAVI_SEEKING)
	goto PlayWithoutWave;

    if (npMCI->hicDraw) {
	ICGetBuffersWanted(npMCI->hicDraw, &npMCI->dwBufferedVideo);
    }
#ifdef DEBUG
    npMCI->dwBufferedVideo = mmGetProfileInt(szIni, TEXT("Buffer"), (int) npMCI->dwBufferedVideo);
#endif
    if (npMCI->dwFlags & MCIAVI_REVERSE) {
	npMCI->dwBufferedVideo = 0;
    }

    if (npMCI->dwBufferedVideo) {
	DPF(("Buffering %lu frames of video ahead....\n", npMCI->dwBufferedVideo));
    }

    //
    //  now initialize the audio stream
    //


    /* Open up our wave output device, if appropriate.
     * Appropriate means that there are audio streams,
     * 		that we are not muted,
     *		that the user has not turned sound off
     *		that we have not had the wave device stolen
     *		and that the wave stream is ok
     */
    if ((npMCI->nAudioStreams > 0)
      	&& (npMCI->dwFlags & MCIAVI_PLAYAUDIO)
      	&& !(npMCI->dwFlags & MCIAVI_LOSEAUDIO)
      	&& !(npMCI->dwOptionFlags & MCIAVIO_NOSOUND)
      	&& (npMCI->dwPlayMicroSecPerFrame != 0)) {

	npMCI->dwTaskError = SetUpAudio(npMCI, TRUE);

	if ((npMCI->dwTaskError == MCIERR_OUT_OF_MEMORY) &&
	    (npMCI->wPlaybackAlg != MCIAVI_ALG_AUDIOONLY)) {
	    DPF(("Not enough memory to play audio; continuing onward....\n"));
	    CleanUpAudio(npMCI);
	    npMCI->dwTaskError = 0;
	}

	if (npMCI->dwTaskError == MCIERR_WAVE_OUTPUTSINUSE) {
#ifdef STEALWAVE
	    //
	    //  we did not get a wave device, time to go steal one.
	    //
	    //  only do this if we got a real play command
	    //  from the user, and not a internal play command
	    //  (like when repeating or restarting)
	    //
	    //  MCIAVI_NEEDTOSHOW is set when the play command
	    //  came in through graphic.c (ie from the outside world)
	    //
	    if (npMCI->dwFlags & MCIAVI_NEEDTOSHOW) {
		if (StealWaveDevice(npMCI))
		    // Some other AVI task was prepared to release the
		    // wave device that they were holding.  This gives us
		    // a second chance to set up for playing audio.
		    npMCI->dwTaskError = SetUpAudio(npMCI, TRUE);
	    }
#endif // STEALWAVE

	    if (npMCI->dwTaskError == MCIERR_WAVE_OUTPUTSINUSE) {
		//
		// even though we did not steal the wave device we still
		// want it if it becomes available
		//
		npMCI->dwFlags |= MCIAVI_LOSTAUDIO;     // we want it
	    }
	}

	/*
	 * We will fail to play even without a wave device available
	 * in the following circumstances:
	 *
	 * 1: Playback algorithm is audio only
	 * 2: Wave failure is not ...OUTPUTSINUSE or ...OUTPUTSUNSUITABLE
	 *
	 * In all other cases we continue and play without wave
	 */

	if (npMCI->dwTaskError) {
	    if ( ((npMCI->dwTaskError != MCIERR_WAVE_OUTPUTSINUSE) &&
		    (npMCI->dwTaskError != MCIERR_WAVE_OUTPUTSUNSUITABLE))
               || (npMCI->wPlaybackAlg == MCIAVI_ALG_AUDIOONLY)
	       )
	    {
		// Must call CleanUpAudio(npMCI) to release buffers
		return npMCI->dwTaskError;
	    }

	    // Reset the error and continue
	    npMCI->dwTaskError = 0;
	}

    } else {
	DPF2(("Playing silently, nAudioStreams=%d, PlayAudio=%x\n",
		npMCI->nAudioStreams, npMCI->dwFlags & MCIAVI_PLAYAUDIO));
	// Was someone stealing our wave device?
        npMCI->dwFlags &= ~MCIAVI_LOSEAUDIO;  // OK - reset the flag
    }

PlayWithoutWave:
    return(PrepareToPlay2(npMCI));
}

INLINE STATICFN DWORD NEAR PASCAL PrepareToPlay2(NPMCIGRAPHIC npMCI)
{
    int         stream;
    UINT        w;
    DWORD       dwPosition;

    if (npMCI->dwFlags & MCIAVI_NEEDTOSHOW) {
	ShowStage(npMCI);
    }
    /* Get and prepare the DC we're going to be playing into */

    // must hold the critsec when getting dc to avoid
    // interaction with window thread calling DeviceRealize

    EnterHDCCrit(npMCI);

    if (npMCI->hdc == NULL) {
	npMCI->hdc = GetDC(npMCI->hwndPlayback);    // Shouldn't use cached DC!

	if (npMCI->hdc == NULL) {
	    LeaveHDCCrit(npMCI);
	    return MCIERR_DRIVER_INTERNAL;
	}

	npMCI->dwFlags |= MCIAVI_RELEASEDC;
    }

    if (npMCI->dwFlags & MCIAVI_SEEKING) {
	//
	// audio only
	//
	if (npMCI->nVideoStreams == 0 && npMCI->nOtherStreams == 0) {
	    npMCI->lCurrentFrame = npMCI->lFrom;
	    LeaveHDCCrit(npMCI);
	    return 0;
	}
    }

    /* Start up the external decompressor, if any */
    /* !!!We should check these for errors */

    if (!DrawBegin(npMCI, NULL)) {
	LeaveHDCCrit(npMCI);
	return npMCI->dwTaskError ? npMCI->dwTaskError : MCIERR_DRIVER_INTERNAL;
    }


    if (!(npMCI->dwFlags & MCIAVI_SEEKING)) {
	PrepareDC(npMCI);
    }
    // critsec just held around getting and preparing dc - look at
    // InternalRealize to see the function we are protecting against.
    LeaveHDCCrit(npMCI);

    /*
    **  what if selecting the palette causes palette changes? we should
    **  yield and let the palette changes happen.
    */

    if (npMCI->hicDraw && !(npMCI->dwFlags & MCIAVI_SEEKING) &&
		(npMCI->dwBufferedVideo > 0)) {
	ICDrawFlush(npMCI->hicDraw);
	npMCI->lFrameDrawn = (- (LONG) npMCI->wEarlyRecords) - 1;
    }

    if (npMCI->dwFlags & MCIAVI_FULLSCREEN) {
	/* Clear out key state flags:
	** We watch for escape, space, and the left button.
	** Unfortunately, we must look for LBUTTON and RBUTTON in case
	** the user has switched mouse buttons.  In that instance, the
	** UI might believe that the Left mouse button is physically the
	** right-hand one, but GetAsyncKeyState looks at the physical
	** left-hand mouse button.
	*/
	GetAsyncKeyState(VK_ESCAPE);
	GetAsyncKeyState(VK_SPACE);
	GetAsyncKeyState(VK_LBUTTON);
	GetAsyncKeyState(VK_RBUTTON);
    }

    /* Figure out where in the file to start playing from */
    CalculateTargetFrame(npMCI);

    // !!! ACK: We're starting from after where we planned to finish....
    if ((npMCI->dwFlags & MCIAVI_REVERSE) &&
	(npMCI->lCurrentFrame <= npMCI->lTo)) {
	npMCI->dwFlags |= MCIAVI_SEEKING;
    }

    // !!! This should be in CalcTarget
    if (npMCI->dwFlags & MCIAVI_SEEKING)
	npMCI->lTo = npMCI->lRealStart;

    //
    // start all the streams
    //
    for (stream = 0; stream < npMCI->streams; stream++) {

	STREAMINFO *psi = SI(stream);

#ifdef USEAVIFILE
	if (!(npMCI->dwFlags & MCIAVI_SEEKING)) {
	    if (SI(stream)->ps) {
		AVIStreamBeginStreaming(SI(stream)->ps,
			MovieToStream(SI(stream), npMCI->lFrom),
			MovieToStream(SI(stream), npMCI->lTo),
			npMCI->dwPlayMicroSecPerFrame); // !!!
	    }
	}
#endif

	//
	// NOTE DrawBegin() handled the default draw guy
	//
	if (psi->hicDraw && psi->hicDraw != npMCI->hicDraw) {

	    DWORD   dw;

	    dw = ICDrawBegin(psi->hicDraw,
		(npMCI->dwFlags & MCIAVI_FULLSCREEN) ?
			ICDRAW_FULLSCREEN : ICDRAW_HDC,

		npMCI->hpal,           // palette to draw with
		npMCI->hwndPlayback,   // window to draw to
		npMCI->hdc,            // HDC to draw to

		RCX(psi->rcDest),
		RCY(psi->rcDest),
		RCW(psi->rcDest),
		RCH(psi->rcDest),

		SI(stream)->lpFormat,

		RCX(psi->rcSource),
		RCY(psi->rcSource),
		RCW(psi->rcSource),
		RCH(psi->rcSource),

		muldiv32(psi->sh.dwRate, npMCI->dwSpeedFactor, 1000),
		psi->sh.dwScale);

	    if ((LONG)dw < 0) {
		// !!! Error checking?
		DPF(("Draw handler failed ICDrawBegin() (err = %ld)\n", dw));
	    }

	    //
	    // tell the draw handler the play range
	    //
	    ICDrawStartPlay(psi->hicDraw,psi->lPlayFrom, psi->lPlayTo);
	}
    }

    //
    // tell the draw handler the play range
    //
    if (npMCI->hicDraw) {
	ICDrawStartPlay(npMCI->hicDraw,npMCI->lRealStart,npMCI->lTo);
    }

    //
    //  seek to the right place in the file.
    //
    dwPosition = CalculatePosition(npMCI);

    if (dwPosition == 0) {
	return MCIERR_DRIVER_INTERNAL;
    }

#ifdef AVIREADMANY
    //
    //  see if we want to try to read two records at a shot, this
    //  should cut down the time spent in DOS doing reads.
    //
    //  we only can do this if we have a index, and the buffer
    //  sizes are "small enough"
    //
    //  if reading 2 buffers works good how about 3? 4?
    //
    //  this helps on CD's and Networks but makes things slower
    //  on KenO's hard disk, so dont do hard disks.
    //
    //  default is read many when coming from a Network, this is
    //  better than the old mmioSetBuffer() we used to do.
    //
    if (npMCI->uDriveType == DRIVE_REMOTE)
	npMCI->fReadMany = TRUE;
    else
	npMCI->fReadMany = FALSE;

    if (npMCI->wPlaybackAlg == MCIAVI_ALG_INTERLEAVED &&
	npMCI->dwSuggestedBufferSize <= 30*1024 &&
	mmGetProfileInt(szIni, TEXT("ReadMany"), npMCI->fReadMany) &&
	npMCI->hpFrameIndex) {

	npMCI->dwBufferSize = npMCI->dwSuggestedBufferSize * 2;
	npMCI->fReadMany = TRUE;
    }
    else {
	npMCI->fReadMany = FALSE;
    }

    if (npMCI->fReadMany) {
	DPF(("MCIAVI: reading two records at once (%ld bytes).\n", npMCI->dwBufferSize));
	npMCI->lLastRead = npMCI->lCurrentFrame - 2;
    }
#endif

    AllocateReadBuffer(npMCI);

    // look for palette changes between the last place we read and where
    // we're starting....
    ProcessPaletteChanges(npMCI, npMCI->lVideoStart);

    if (npMCI->hmmio) {
	/* Seek to the start of frame we're playing from */
	mmioSeek(npMCI->hmmio, dwPosition, SEEK_SET);
    }

#ifdef AVIREAD
    /* start the async read object if we are using interleaved
     * and therefore consecutive reads
     */
    if (npMCI->wPlaybackAlg == MCIAVI_ALG_INTERLEAVED) {

	/* start async reader  - allocates itself new buffers */
	npMCI->hAviRd = avird_startread(mciaviReadBuffer, (DWORD) npMCI,
					npMCI->dwNextRecordSize,
					npMCI->lCurrentFrame,
					min(npMCI->lTo+1, npMCI->lFrames));

	if (!npMCI->hAviRd) {
	    DPF(("async read failed - reading synchronously\n"));
	    ResizeReadBuffer(npMCI, npMCI->dwNextRecordSize);
	}

    } else {
	npMCI->hAviRd = NULL;
    }

    if (!npMCI->hAviRd)
#endif
    {
	if (!npMCI->lpBuffer) {
	    return MCIERR_OUT_OF_MEMORY;
	}
    }

    if (npMCI->hWave) {
	TIMESTART(timeAudio);
	if (npMCI->wPlaybackAlg == MCIAVI_ALG_HARDDISK ||
	    npMCI->wPlaybackAlg == MCIAVI_ALG_AUDIOONLY) {
	    /* Load audio into our buffers */
	    for (w = 0; w < npMCI->wABs; w++)
		KeepPlayingAudio(npMCI);
	} else if (npMCI->wPlaybackAlg == MCIAVI_ALG_CDROM) {
	    //!!!!
	    npMCI->wPlaybackAlg = MCIAVI_ALG_HARDDISK;
	}
	TIMEEND(timeAudio);
    }

    return 0L;          /* Success! */
}

/******************************************************************************
 *****************************************************************************/

void NEAR PASCAL CleanUpPlay(NPMCIGRAPHIC npMCI)
{
    int stream;

    if (npMCI->wTaskState == TASKPLAYING) {
	if (npMCI->hicDraw) {
	    ICDrawStop(npMCI->hicDraw);
	    ICDrawStopPlay(npMCI->hicDraw);
	}

	for (stream = 0; stream < npMCI->streams; stream++) {
	    if (SI(stream)->hicDraw) {
		ICDrawStop(SI(stream)->hicDraw);
		ICDrawStopPlay(SI(stream)->hicDraw);
	    }
	}

	if (npMCI->hWave) {
	    waveOutRestart(npMCI->hWave); // some wave devices need this
	    waveOutReset(npMCI->hWave);
	}
    } else if (npMCI->wTaskState == TASKCUEING) {
	if (npMCI->hicDraw) {
	    /* Kick the device in the head to make sure it draws when we seek. */
	    ICDrawRenderBuffer(npMCI->hicDraw);
	}
    }

    if (!(npMCI->dwFlags & MCIAVI_SEEKING) &&
		(npMCI->dwBufferedVideo > 0)) {
	ICDrawFlush(npMCI->hicDraw);
	npMCI->lFrameDrawn = (- (LONG) npMCI->wEarlyRecords) - 1;
    }

    /* end drawing this will leave fullscreen mode etc. */
    DrawEnd(npMCI);

    for (stream = 0; stream < npMCI->streams; stream++) {
	if (SI(stream)->hicDraw) {
	    DWORD   dw;
	    dw = ICDrawEnd(SI(stream)->hicDraw);
	    // !!! Error checking?
	}
#ifdef USEAVIFILE
	if (!(npMCI->dwFlags & MCIAVI_SEEKING)) {
	    if (SI(stream)->ps) {
		AVIStreamEndStreaming(SI(stream)->ps);
	    }
	}
#endif
    }

    /* Clean up and close our wave output device. */
    if (npMCI->hWave) {

	Assert(!(npMCI->dwFlags & MCIAVI_LOSTAUDIO));
	// We should never hold the
	// wave device AND have MCIAVI_LOSTAUDIO turned on.

	CleanUpAudio(npMCI);

#ifdef STEALWAVE
	//
	// if we are not being forced to give up the audio try to
	// give it to someone.	Unless we are repeating.  In which
	// case someone might steal it from us, but we do not want
	// to waste time looking for another user.  We have it; we
	// will keep it until forced to release it.
	//
	if (!(npMCI->dwFlags & MCIAVI_NEEDTOSHOW) &&
	    !(npMCI->dwFlags & MCIAVI_REPEATING)  &&
	    !(npMCI->dwFlags & MCIAVI_UPDATING))
	    GiveWaveDevice(npMCI);
	else {
	    DPF2(("Not giving the wave device away, flags=%x\n",npMCI->dwFlags));
	}
#endif
    } else {
	//
	//  done playing, we dont want a wave device any more
	//  LATER: do we really want to turn this flag off if we are
	//  repeating?  Today it is benign as the flag will be turned
	//  back on again when the video restarts.  It will then try and
	//  open the audio, fail because it is in use, and turn on LOSTAUDIO.
	//  It would be more efficient to rely on the wave device being
	//  returned to us and not try to reopen it.
	//
	npMCI->dwFlags &= ~MCIAVI_LOSTAUDIO;
    }

    /* Release the DC we played into. */

    // worker thread must hold critsec round all access to hdc
    // (can be used by DeviceRealize on winproc thread)
    EnterHDCCrit(npMCI);

    if (npMCI->hdc) {
	//
	// we MUST call this otherwise our palette will stay selected
	// as the foreground palette and it may get deleted (ie by
	// DrawDibBegin) while still the foreground palette and GDI
	// get's real pissed about this.
	//
	UnprepareDC(npMCI);
#if 0
	if (npMCI->dwFlags & MCIAVI_ANIMATEPALETTE)
	    RealizePalette(npMCI->hdc);
#endif
	if (npMCI->dwFlags & MCIAVI_RELEASEDC) {
	    ReleaseDC(npMCI->hwndPlayback, npMCI->hdc);
	    HDCCritCheckIn(npMCI);
	    npMCI->hdc = NULL;
	    npMCI->dwFlags &= ~MCIAVI_RELEASEDC;
	}
    }
    LeaveHDCCrit(npMCI);

#ifdef AVIREAD
    /* shut down async reader */
    if (npMCI->hAviRd) {
	avird_endread(npMCI->hAviRd);
	npMCI->hAviRd = NULL;
    } else
#endif
    {
	/* we weren't using async reader - so release the buffer we
	 * allocated
	 */
	ReleaseReadBuffer(npMCI);
    }

}

/******************************************************************************
 *****************************************************************************/

// !!! Should this take a "how many frames to check for" parameter,
// in case we need to check for signals on several frames at once?

void NEAR PASCAL CheckSignals(NPMCIGRAPHIC npMCI, LONG lFrame)
{
    LONG        lTemp;

    lTemp = npMCI->signal.dwPeriod == 0 ? lFrame :
			(((lFrame - npMCI->signal.dwPosition) %
					    npMCI->signal.dwPeriod) +
				npMCI->signal.dwPosition);

    if ((DWORD) lTemp == npMCI->signal.dwPosition) {
	/* Send the signal in the right time format */
	SEND_DGVSIGNAL(npMCI->dwSignalFlags,
			    npMCI->signal.dwCallback,
			    0,
			    (HANDLE) npMCI->wDevID,
			    npMCI->signal.dwUserParm,
			    ConvertFromFrames(npMCI, lFrame));
	// !!! Needs to use time format at time of signal command!
    }
}

/******************************************************************************
 *****************************************************************************/

BOOL NEAR PASCAL WaitTillNextFrame(NPMCIGRAPHIC npMCI)
{
#ifdef _WIN32
    LONG WaitForFrame;
#endif
    LONG  lMaxWait;
#ifdef DEBUG
    int iWait = 0;
    StatusBar(npMCI,2,1,4,iWait); // we should not wait more than 4 times...
#endif

    /* Here we wait for a while if we're ahead
     *   of schedule (so that we can yield nicely instead of blocking
     *   in the driver, for instance, and also so that we'll work off
     *   faster devices.)
     */

    /* Always yield at least once in a while  (every 8 frames ~ 1/2 sec)*/
    if ((npMCI->lCurrentFrame % YIELDEVERY) == 0) {
	TIMESTART(timeYield);
	aviTaskCheckRequests(npMCI);
	TIMEEND(timeYield);
    }

    if (npMCI->dwFlags & MCIAVI_WAVEPAUSED)
	return TRUE;

    if (TimeToQuit(npMCI))
	return FALSE;

    Assert(npMCI->wTaskState == TASKPLAYING);

    // with the change to play the last frame of audio, these two asserts
    // are no longer valid. We will wait until it's time for frame lTo+1
    // and stop then (before attempting to read or draw it).
    //AssertFrame(npMCI->lCurrentFrame - (LONG)npMCI->dwBufferedVideo);
    //Assert(npMCI->lCurrentFrame <= npMCI->lTo);

    Assert(!(npMCI->dwFlags & MCIAVI_REVERSE));

    /* The maximum wait time is 95% of the correct frame rate, or 100ms
     * (to cope with a very slow frame rate)
     */
    lMaxWait = min(100, muldiv32(npMCI->dwMicroSecPerFrame,
			950L,
			(npMCI->dwSpeedFactor == 0 ?
				1000 : npMCI->dwSpeedFactor)));

    if (HowLongTill(npMCI) > 0) {

	while ((WaitForFrame=HowLongTill(npMCI)) > 0) {
		     ///////WAITING//////////
	    StatusBar(npMCI,2,1,4,++iWait);

	    // use sleep regardless of accuracy as polling hurts on NT
	    if (npMCI->msPeriodResolution > 0) {

		// NOTE:  There are no fudge factors in here.  This code
		// needs to be tuned to allow for the overhead of calculating
		// the wait time, for the overhead of the timer, etc.

		// Don't wait for more than one frame time at a time....
		if (WaitForFrame > lMaxWait) {
		    WaitForFrame = lMaxWait;
		}

		DPF2(("Sleeping for %d milliseconds\n", WaitForFrame));
		TIMESTART(timeWait);
		Sleep(WaitForFrame);
		TIMEEND(timeWait);
	    } else {
		Sleep(0);
	    }

	    // check if anything interesting has happened
	    TIMESTART(timeYield);
	    aviTaskCheckRequests(npMCI);
	    TIMEEND(timeYield);
	    if (TimeToQuit(npMCI)) {
		return FALSE;
	    }
	}
    } else {
	// force some cpu idle time at least every 1/2 second, to ensure
	// that other processes do get some time (eg for 16-bit hook procs).
	/* Always yield at least once in a while  (every 8 frames ~ 1/2 sec)*/
	if ((npMCI->lCurrentFrame % YIELDEVERY) == 0) {

	    TIMESTART(timeWait);
	    Sleep(1);
	    TIMEEND(timeWait);

	    TIMESTART(timeYield);
	    aviTaskCheckRequests(npMCI);
	    TIMEEND(timeYield);

	    if (TimeToQuit(npMCI)) {
		return FALSE;
	    }
	}
    }

    return TRUE;
}

/* Idea: this should go from the current frame to the frame
** we actually have to be at to start playing from.
**
** If fPlaying is set, that means we're really going to play.
**
** When this finishes:
**      lAudioStart is set to the first frame with meaningful audio info
**      lVideoStart is the first frame with meaningful video info
**      lRealStart is the first frame that's 'real', namely
**              the original value of lCurrentFrame.  If the
**              SEEK EXACT flag is not set, then lRealStart may
**              actually not be what lCurrentFrame was, indicating
**              that play may start from somewhere else.
**      lCurrentFrame gets set to the first frame we have to read from.
**
** !!! This also needs to look for "palette key frames" or something.
*/
BOOL NEAR PASCAL CalculateTargetFrame(NPMCIGRAPHIC npMCI)
{
    int         i;
    LONG        lVideoPlace;
    BOOL        fForceBeginning = FALSE;
    int		lMovieStart=0xffffffff;	    // Max UINT (or -1 when signed)
    int		lStreamStart;

    npMCI->lCurrentFrame = npMCI->lFrom;
    npMCI->lRealStart = npMCI->lFrom;

    //
    //  walk all streams and figure out where to start
    //
    for (i=0; i<npMCI->streams; i++) {

	STREAMINFO *psi = SI(i);

	if (!(psi->dwFlags & STREAM_ENABLED))
	    continue;

	if (psi->dwFlags & STREAM_ERROR)
	    continue;

	if (psi->dwFlags & STREAM_AUDIO)
	    continue;

	//
	// map from movie time to stream time.
	//
	psi->lPlayFrom = MovieToStream(psi, npMCI->lFrom);
	psi->lPlayTo   = MovieToStream(psi, npMCI->lTo);

	psi->dwFlags &= ~STREAM_ACTIVE;

	//
	// is this stream part of play?
	//
	if (psi->lPlayFrom < psi->lStart && psi->lPlayTo < psi->lStart)
	    continue;

	if (psi->lPlayFrom >= psi->lEnd && psi->lPlayTo >= psi->lEnd)
	    continue;

	psi->dwFlags |= STREAM_ACTIVE;

	psi->lPlayFrom  = BOUND(psi->lPlayFrom,psi->lStart,psi->lEnd);
	psi->lPlayTo    = BOUND(psi->lPlayTo,  psi->lStart,psi->lEnd);
	psi->lPlayStart = FindPrevKeyFrame(npMCI,psi,psi->lPlayFrom);

	//
	// if the main frame is invalid invalidate the stream too.
	//
	if (npMCI->lFrameDrawn <= (-(LONG)npMCI->wEarlyRecords)) {
	    psi->lFrameDrawn = -4242;
	}

	//
	//  if we have a drawn frame use it!
	//
	if ((psi->lFrameDrawn  > psi->lPlayStart) &&
	    (psi->lFrameDrawn <= psi->lPlayFrom))
	    psi->lPlayStart = npMCI->lFrameDrawn + 1;

	lStreamStart = StreamToMovie(psi, (DWORD)psi->lPlayStart);
	if ((DWORD)lMovieStart > (DWORD)lStreamStart) {
	    (DWORD)lMovieStart = (DWORD)lStreamStart;
	}

	//
	//  if seek exactly is off start play at the key frame
	//
	if (!(npMCI->dwOptionFlags & MCIAVIO_SEEKEXACT)) {

	    if (psi->lPlayFrom == psi->lPlayTo)
		 psi->lPlayTo = psi->lPlayStart;

	    psi->lPlayFrom = psi->lPlayStart;

	    //!!! is this right for reverse?

	    if (StreamToMovie(psi, psi->lPlayFrom) < npMCI->lFrom) {
//              npMCI->lRealStart = StreamToMovie(psi, psi->lPlayFrom);
//              npMCI->lFrom = npMCI->lRealStart;
	    }
	}

//      if (StreamToMovie(psi, psi->lPlayStart) < npMCI->lCurrentFrame)
//          npMCI->lCurrentFrame = StreamToMovie(psi, psi->lPlayStart);

	DPF(("CalculateTargetFrame:  Stream #%d: from:%ld, to:%ld, start:%ld\n", i, psi->lPlayFrom, psi->lPlayTo, psi->lPlayStart));
    }

    //
    // we are done with now special case the video and audio streams.
    // note: if lMovieStart has NOT been altered above then it will be -1
    //
    if (npMCI->lFrom < lMovieStart) {
	npMCI->lFrom = lMovieStart;
    }

    /* If we're starting from the beginning, don't force the index
    ** to be read, but use it if we've already read it.
    */
    if (npMCI->lFrom == 0 && npMCI->hpFrameIndex == NULL)
	goto ForceBeginning;

    if (!npMCI->pbiFormat) {
	npMCI->lVideoStart = npMCI->lFrom;

	if (npMCI->lVideoStart >= npMCI->lFrames)
	    npMCI->lVideoStart = npMCI->lFrames - 1;

	lVideoPlace = npMCI->lVideoStart;
    } else
    if (npMCI->dwFlags & MCIAVI_HASINDEX) {

	if (npMCI->hpFrameIndex == NULL)
	    goto ForceBeginning;

	//
	// get nearest key frame
	//
	npMCI->lVideoStart = FramePrevKey(npMCI->lFrom);

	if (npMCI->lVideoStart) {
	    lVideoPlace = npMCI->lVideoStart;
	} else {
	    /* Didn't find a key frame--retreat to the beginning. */
	    npMCI->lVideoStart = -(LONG)npMCI->wEarlyVideo;
	    lVideoPlace = 0;
	}

	if ((npMCI->lFrameDrawn > npMCI->lVideoStart) &&
		(npMCI->lFrameDrawn <= npMCI->lFrom)) {
	    npMCI->lVideoStart = npMCI->lFrameDrawn + 1;
	    if (npMCI->lVideoStart >= npMCI->lFrames)
		npMCI->lVideoStart = npMCI->lFrames - 1;
	    lVideoPlace = npMCI->lFrameDrawn;
	}
    } else {
	/* Always go back to frame 0 */
ForceBeginning:
	npMCI->lVideoStart = - (LONG) npMCI->wEarlyVideo;
	lVideoPlace = 0;
	fForceBeginning = TRUE;
    }

    if (!(npMCI->dwOptionFlags & MCIAVIO_SEEKEXACT)) {
	npMCI->lRealStart = lVideoPlace;
    }

    if (npMCI->hWave) {
	npMCI->lAudioStart = npMCI->lRealStart - (LONG) npMCI->wEarlyAudio;
    }

    if (npMCI->hWave && (npMCI->wPlaybackAlg == MCIAVI_ALG_INTERLEAVED))
	npMCI->lCurrentFrame = min(npMCI->lAudioStart, npMCI->lVideoStart);
    else
	npMCI->lCurrentFrame = npMCI->lVideoStart;

    if (npMCI->lRealStart < npMCI->lCurrentFrame)
	npMCI->lCurrentFrame = npMCI->lRealStart;

    if (fForceBeginning) {
	if (npMCI->wPlaybackAlg == MCIAVI_ALG_INTERLEAVED)
	    npMCI->lCurrentFrame = - (LONG) npMCI->wEarlyRecords;
	else
	    npMCI->lCurrentFrame = - (LONG) npMCI->wEarlyVideo;
    }

    if (npMCI->hWave) {
	LONG l;

	/* Figure out what sample of audio we should be starting at */

	//
	//  convert frame number to block
	//
	npMCI->dwAudioPos = MovieToStream(npMCI->psiAudio, npMCI->lRealStart);

	//
	// now convert block to byte position
	//
	npMCI->dwAudioPos = npMCI->dwAudioPos * npMCI->pWF->nBlockAlign;

	Assert(npMCI->dwAudioPos % npMCI->pWF->nBlockAlign == 0);

	if (npMCI->dwAudioPos > npMCI->dwAudioLength)
	    npMCI->dwAudioPos = npMCI->dwAudioLength;

	npMCI->dwAudioPlayed = 0L;

	//
	//  convert the audio start back to a frame number.
	//  and posibly readjust the video start time.
	//
	l = npMCI->lRealStart - StreamToMovie(npMCI->psiAudio,
		npMCI->dwAudioPos/npMCI->pWF->nBlockAlign);

	if (l < 0)
	    DPF(("Audio will be ahead of the video by %ld frames\n", -l));
	else if (l > 0)
	    DPF(("Audio will be behind the video by %ld frames\n", l));
    }

#ifdef DEBUG
    Assert(npMCI->lCurrentFrame < npMCI->lFrames);
    if (npMCI->wPlaybackAlg == MCIAVI_ALG_INTERLEAVED) {
	Assert(npMCI->lCurrentFrame >= - (LONG) npMCI->wEarlyRecords);
    }
    if (npMCI->hWave) {
	Assert(npMCI->lAudioStart <= npMCI->lFrames);
    }
    Assert(npMCI->lVideoStart < npMCI->lFrames);
#endif

    return TRUE;
}


/******************************************************************************
 *****************************************************************************/

void ReturnToOriginalPalette(NPMCIGRAPHIC npMCI)
{
    if (npMCI->bih.biClrUsed) {
	hmemcpy(npMCI->argb, npMCI->argbOriginal,
		npMCI->bih.biClrUsed * sizeof(RGBQUAD));

	if (npMCI->pbiFormat->biBitCount == 8) {
	    hmemcpy((LPBYTE) npMCI->pbiFormat + npMCI->pbiFormat->biSize,
		    (LPBYTE) npMCI->argb,
		    sizeof(RGBQUAD) * npMCI->pbiFormat->biClrUsed);
	}

	npMCI->dwFlags |= MCIAVI_PALCHANGED;
	npMCI->lLastPaletteChange = 0;
    }
}


/* Returns the position in the file where the frame referenced
** by lCurrentFrame is.
**
**  input   npMCI->lCurrentFrame
**
**  output  npMCI->dwNextRecordSize set correctly
**          npMCI->lLastRead set correctly
**          returns offset to read from
**
** If there's an error, returns zero.
*/
DWORD NEAR PASCAL CalculatePosition(NPMCIGRAPHIC npMCI)
{
    DWORD       dwPosition;

    AssertFrame(npMCI->lCurrentFrame);

    if (npMCI->pf || npMCI->nVideoStreams == 0)
	return 1;

    if (npMCI->lCurrentFrame + npMCI->wEarlyRecords == 0) {
ForceBeginning:
	npMCI->lCurrentFrame = - (LONG)npMCI->wEarlyRecords;
//!!!BeforeBeginning:
	dwPosition = npMCI->dwFirstRecordPosition;
	npMCI->dwNextRecordSize = npMCI->dwFirstRecordSize;
	npMCI->dwNextRecordType = npMCI->dwFirstRecordType;
    } else if (npMCI->dwFlags & MCIAVI_HASINDEX) {
	if (npMCI->hpFrameIndex == NULL)
	    goto ForceBeginning;

	dwPosition = FrameOffset(npMCI->lCurrentFrame);
	npMCI->dwNextRecordSize = FrameLength(npMCI->lCurrentFrame) + 8;
	npMCI->dwNextRecordType = 0;
    } else {
	goto ForceBeginning;
    }

    npMCI->lLastRead = npMCI->lCurrentFrame - 1;

    DPF3(("Frame %ld: Seeking to position %lX\n", npMCI->lCurrentFrame, dwPosition));

    DPF3(("CalculatePosition: next record = %lu bytes.\n", npMCI->dwNextRecordSize));

    mmioSeek(npMCI->hmmio, dwPosition, SEEK_SET);

    return dwPosition;
}

/***************************************************************************
 *
 ***************************************************************************/

BOOL NEAR PASCAL ReadIndexChunk(NPMCIGRAPHIC npMCI, LONG iIndex)
{
    Assert(iIndex >= 0 && iIndex < (LONG)npMCI->macIndex);

    return ReadBuffer(npMCI, (LONG)IndexOffset(iIndex), (LONG)IndexLength(iIndex) + 8);
}

/***************************************************************************
 *
 * @doc INTERNAL MCIAVI
 *
 * @api void | DealWithOtherStreams | does what is says
 *
 *  this function is called inside of the non-interlaved play loop.
 *  it's mission is to catch the "other" streams up to the current time.
 *
 *  right now all we do is go to key frames, we should fix this
 *
 * @parm NPMCIGRAPHIC | npMCI | pointer to instance data block.
 *
 ***************************************************************************/

STATICFN INLINE void DealWithOtherStreams(NPMCIGRAPHIC npMCI, LONG lFrame)
{
    int i;
    STREAMINFO *psi;
    LONG lPos;
    LONG err;

    for (i=0; i<npMCI->streams; i++) {

	// If this is the active audio or video stream, then ignore it
	if ((i == npMCI->nVideoStream)
	    || (i == npMCI->nAudioStream))
	    continue;

	psi = SI(i);

	if (!(psi->dwFlags & STREAM_ENABLED))
	    continue;

	if (psi->hicDraw == NULL)
	    continue;

	lPos = MovieToStream(psi, lFrame);

	if (lPos < psi->lPlayStart || lPos > psi->lPlayTo) {
	    DPF2(("OtherStream(%d): out of range lPos = %ld [%ld, %ld]\n", i, lPos, psi->lPlayStart, psi->lPlayTo));
	    continue;
	}

	//
	// we have the right thing drawn now
	//
	// !!!we should not always go to a key frame.
	//
	//
	if (psi->lFrameDrawn >= psi->lLastKey &&
	    psi->lFrameDrawn <= lPos &&
	    lPos < psi->lNextKey) {
	    DPF2(("OtherStream(%d) lPos = %ld, lFrameDrawn=%ld, NextKey=%ld\n", i, lPos, psi->lFrameDrawn, psi->lNextKey));
	    continue;
	}

	FindKeyFrame(npMCI, psi, lPos);

	DPF2(("OtherStream(%d): pos=%ld (prev key=%ld, next key=%ld)\n",i,lPos,psi->lLastKey,psi->lNextKey));

	lPos = psi->lLastKey;

	if (!StreamRead(npMCI, psi, lPos)) {
	    DPF2(("StreamRead failed\n"));
	    continue;
	} else {
	    DPF2(("Read stream, ThisRecordSize==%d, biSizeImage==%d\n",
		npMCI->dwThisRecordSize, 0));
	}

	//
	//  now draw the data.
	//
	err = (LONG)ICDraw(psi->hicDraw, 0L, psi->lpFormat,
		npMCI->lpBuffer,npMCI->dwThisRecordSize,
		psi->lLastKey - psi->lPlayFrom);

	if (err >= 0) {
	    psi->dwFlags &= ~STREAM_NEEDUPDATE;
	    psi->lFrameDrawn = lPos;
	}
	else {
	    DPF2(("Draw failed!\n"));
	}
    }
}

/***************************************************************************
 *
 * FindKeyFrame
 *
 *  given a stream position, find the previous and next key frame
 *  cacheing the last ones found to make it sort of fast.
 *
 ***************************************************************************/

void NEAR PASCAL FindKeyFrame(NPMCIGRAPHIC npMCI, STREAMINFO *psi, LONG lPos)
{
    if (psi == NULL)
	psi = npMCI->psiVideo;

    Assert(psi);
//  AssertPos(psi, lPos);

    //
    //  if we are in the current key range return it.
    //
    if (psi->lLastKey <= lPos && lPos < psi->lNextKey)
	return;

    if (lPos < psi->lStart || lPos >= psi->lEnd)
	return;

    //
    //  otherwise query from the stream
    //
#ifdef USEAVIFILE
    if (psi->ps) {
	if (lPos == psi->lNextKey)
	    psi->lLastKey = psi->lNextKey;
	else
	    psi->lLastKey = AVIStreamFindSample(psi->ps, lPos, FIND_KEY|FIND_PREV);

	psi->lNextKey = AVIStreamFindSample(psi->ps, lPos+1, FIND_KEY|FIND_NEXT);

	if (psi->lLastKey == -1)
	    ; // psi->lLastKey = psi->lStart;

	if (psi->lNextKey == -1)
	    psi->lNextKey = psi->lEnd+1;
    }
#endif
    else if (psi->dwFlags & STREAM_VIDEO) {
	//
	// for a video stream either read our index or assume no key frames.
	//
	if (npMCI->hpFrameIndex && psi == npMCI->psiVideo) {
	    psi->lLastKey = FramePrevKey(lPos);
	    psi->lNextKey = FrameNextKey(lPos);
	}
	else {
	    psi->lLastKey = psi->lStart;
	    psi->lNextKey = psi->lEnd+1;
	}
    }
    else {
	//
	// for a non-video stream assume all key frames
	//
	psi->lLastKey = lPos;
	psi->lNextKey = lPos+1;
    }

    return;
}

/***************************************************************************
 ***************************************************************************/

LONG NEAR PASCAL FindPrevKeyFrame(NPMCIGRAPHIC npMCI, STREAMINFO *psi, LONG lPos)
{
    FindKeyFrame(npMCI, psi, lPos);
    return psi->lLastKey;
}

/***************************************************************************
 ***************************************************************************/

LONG NEAR PASCAL FindNextKeyFrame(NPMCIGRAPHIC npMCI, STREAMINFO *psi, LONG lPos)
{
    FindKeyFrame(npMCI, psi, lPos);
    return psi->lNextKey;
}

/***************************************************************************
 ***************************************************************************/

BOOL NEAR PASCAL ProcessPaletteChanges(NPMCIGRAPHIC npMCI, LONG lFrame)
{
    LONG        iPalette;
    LONG        iFrame;
    STREAMINFO *psi;

    if (!(npMCI->dwFlags & MCIAVI_ANIMATEPALETTE))
	return TRUE;

    psi = npMCI->psiVideo;
    Assert(psi);

#ifdef USEAVIFILE
    if (psi->ps) {

	DWORD       dw;
	//
	//  we are in the palette range nothing to do.
	//
	if (npMCI->lLastPaletteChange <= lFrame &&
	    npMCI->lNextPaletteChange >  lFrame) {

	    return TRUE;
	}

	dw = psi->cbFormat;

	//!!! should be psi->lpFormat
	if (AVIStreamReadFormat(psi->ps, lFrame, npMCI->pbiFormat, &dw) != 0) {
	    DOUT("Unable to read Stream format\n");
	    return FALSE;
	}

	npMCI->lLastPaletteChange = lFrame;
	npMCI->lNextPaletteChange = AVIStreamFindSample(psi->ps, lFrame+1, FIND_NEXT|FIND_FORMAT);

	if (npMCI->lNextPaletteChange == -1)
	    npMCI->lNextPaletteChange = npMCI->lFrames+2;

	npMCI->dwFlags |= MCIAVI_PALCHANGED;
	return TRUE;
    }
#endif

    DPF2(("Looking for palette changes at %ld, last=%ld\n", lFrame, npMCI->lLastPaletteChange));

    if (lFrame < npMCI->lLastPaletteChange) {
	ReturnToOriginalPalette(npMCI);
    }

    /* If there's no index, assume we're starting from the beginning
    ** and thus we don't have to worry about palette changes.
    */
    if (npMCI->hpFrameIndex == NULL)
	return TRUE;

    //
    // walk from the last palette change to the current frame, and apply any
    // palette changes we find.
    //
    for (iFrame = npMCI->lLastPaletteChange,
	 iPalette = FramePalette(iFrame);
	 iFrame <= lFrame;
	 iFrame++) {

	if (iPalette != FramePalette(iFrame)) {

	    iPalette = FramePalette(iFrame);

	    /* We've found a palette change we need to deal with */
	    DPF2(("Processing palette change at frame %ld.\n", iFrame));

	    Assert(iPalette >= 0 && iPalette < (LONG)npMCI->macIndex);

	    if (!ReadIndexChunk(npMCI, iPalette))
		    return FALSE;

	    npMCI->lp += 2 * sizeof(DWORD);
	    ProcessPaletteChange(npMCI, IndexLength(iPalette));

	    npMCI->lLastPaletteChange = iFrame;
	}
    }

    return TRUE;
}

BOOL NEAR PASCAL ReadRecord(NPMCIGRAPHIC npMCI)
{
    DWORD UNALIGNED FAR * pdw;

    AssertFrame(npMCI->lCurrentFrame);

#ifdef AVIREADMANY
    if (npMCI->fReadMany) {
	//
	//  either read two records or return the one we read last time.
	//
	Assert(npMCI->hpFrameIndex);
	Assert(npMCI->lCurrentFrame - npMCI->lLastRead > 0);
	Assert(npMCI->lCurrentFrame - npMCI->lLastRead <= 2);

	if (npMCI->lLastRead == npMCI->lCurrentFrame-1) {
	    //
	    //  return the second half of the buffer.
	    //
	    npMCI->lp = npMCI->lpBuffer + (UINT)npMCI->dwThisRecordSize;
	    npMCI->dwThisRecordSize = npMCI->dwNextRecordSize;
	}
	else {
	    //
	    //  read in two buffers, and return the first one
	    //
	    //  figure out how much to read by looking at the index
	    //  we dont have to worry about the last frame because
	    //  the dummy index entry on the end is 0 in length.
	    //
	    npMCI->dwThisRecordSize = FrameLength(npMCI->lCurrentFrame) + 8;
	    npMCI->dwNextRecordSize = FrameLength(npMCI->lCurrentFrame+1) + 8;

	    if (!ReadBuffer(npMCI, -1,
		npMCI->dwThisRecordSize + npMCI->dwNextRecordSize))
		return FALSE;

	    npMCI->lLastRead = npMCI->lCurrentFrame;
	    npMCI->lp = npMCI->lpBuffer;
	    npMCI->dwThisRecordSize -= npMCI->dwNextRecordSize;
	}

#ifdef DEBUG
	pdw = (LPDWORD)(npMCI->lp + npMCI->dwThisRecordSize - 3 * sizeof(DWORD));

	if (npMCI->lCurrentFrame < npMCI->lFrames - 1) {
	    Assert(pdw[0] == FOURCC_LIST);
	    Assert(pdw[2] == listtypeAVIRECORD);
	}
#endif
	return TRUE;
    }
    else
#endif

#ifdef AVIREAD
    if (npMCI->hAviRd) {
	/* async reader is going - get the next buffer from him */
	npMCI->lpBuffer = avird_getnextbuffer(npMCI->hAviRd, &dwThisBuffer);
	npMCI->dwThisRecordSize = npMCI->dwNextRecordSize;

	if ((dwThisBuffer == 0) || (npMCI->lpBuffer == NULL)) {
	    npMCI->dwTaskError = MCIERR_FILE_READ;
	    return FALSE;
	}

    } else
#endif
    {
	if (!ReadBuffer(npMCI, -1, (LONG)npMCI->dwNextRecordSize))
	    return FALSE;
    }

    pdw = (DWORD UNALIGNED FAR *)(npMCI->lp + npMCI->dwThisRecordSize - 3 * sizeof(DWORD));

    npMCI->dwNextRecordType = pdw[0];
    npMCI->dwNextRecordSize = pdw[1] + 2 * sizeof(DWORD);

#ifdef DEBUG
    if (npMCI->lCurrentFrame < npMCI->lFrames - 1) {
	Assert(pdw[0] == FOURCC_LIST);
	Assert(pdw[2] == listtypeAVIRECORD);
    }
#endif

    return TRUE;
}

STATICFN INLINE DWORD NEAR PASCAL ReadNextChunk(NPMCIGRAPHIC npMCI)
{
    LPDWORD pdw;
    DWORD dw;

ReadAgain:
    dw = npMCI->dwNextRecordType;

    if (!ReadBuffer(npMCI, -1, (LONG)npMCI->dwNextRecordSize))
	return 0;

    pdw = (LPDWORD)(npMCI->lp + npMCI->dwNextRecordSize - 2 * sizeof(DWORD));

    if (dw == FOURCC_LIST)
	pdw--;

    npMCI->dwNextRecordType = pdw[0];
    npMCI->dwNextRecordSize = pdw[1] + 2 * sizeof(DWORD);

    if (dw == ckidAVIPADDING)
	goto ReadAgain;

    return dw;
}

STATICFN INLINE BOOL NEAR PASCAL StreamRead(NPMCIGRAPHIC npMCI, STREAMINFO *psi, LONG lPos)
{
    LONG  lSize;

    Assert(psi);
#ifdef USEAVIFILE
    Assert(psi->ps);
#endif

    //
    // if we are before the start or after the end, read nothing.
    //
    if (lPos < psi->lStart || lPos >= psi->lEnd) {
	lSize = 0;
	goto done;
    }

#ifdef USEAVIFILE
    if (AVIStreamRead(psi->ps, lPos, 1,
	(LPSTR)npMCI->lpBuffer,npMCI->dwBufferSize,&lSize, NULL) != 0) {

	//
	// the read failed try incressing the buffer size
	//
	AVIStreamRead(psi->ps, lPos, 1, NULL, 0, &lSize, NULL);

	if (lSize > (LONG) (npMCI->dwBufferSize)) {

	    DPF2(("ReadStream: Enlarging buffer....\n"));

	    if (!ResizeReadBuffer(npMCI, lSize)) {
		DPF(("Failed to increase buffer size!\n"));
		npMCI->dwTaskError = MCIERR_OUT_OF_MEMORY;
		return FALSE;
	    }
	}

	if (AVIStreamRead(psi->ps, lPos, 1,
		(LPSTR)npMCI->lpBuffer,npMCI->dwBufferSize,&lSize,NULL) != 0) {
	    npMCI->dwTaskError = MCIERR_FILE_READ;
	    return FALSE;
	}
    }
#endif

done:
    npMCI->lp = npMCI->lpBuffer;
    npMCI->dwThisRecordSize = lSize;
    return TRUE;
}

BOOL NEAR PASCAL ReadNextVideoFrame(NPMCIGRAPHIC npMCI, STREAMINFO *psi)
{
    MMCKINFO    ck;

    if (psi == NULL)
	psi = npMCI->psiVideo;

    Assert(psi);
    AssertFrame(npMCI->lCurrentFrame);

#ifdef USEAVIFILE
    if (psi->ps) {
	LONG        lSize;
	LONG        lPos;

	//
	// map from movie time into this stream.
	//
	lPos = MovieToStream(psi, npMCI->lCurrentFrame);

	//
	// if we are before the start or after the end, read nothing.
	//
	if (lPos <  (LONG)psi->sh.dwStart ||
	    lPos >= (LONG)psi->sh.dwStart+(LONG)psi->sh.dwLength) {
	    lSize = 0;
	    goto done;
	}

	//
	// if this frame has a new palette then deal with it
	//
	if (npMCI->dwFlags & MCIAVI_ANIMATEPALETTE) {
	    ProcessPaletteChanges(npMCI, lPos);
	}

	if (AVIStreamRead(psi->ps, lPos, 1,
		      (LPSTR) npMCI->lpBuffer + 2 * sizeof(DWORD),
		      npMCI->dwBufferSize - 2 * sizeof(DWORD),
		      &lSize, NULL) != 0) {
	    //
	    // the read failed try incressing the buffer size
	    //
	    AVIStreamRead(psi->ps, lPos, 1, NULL, 0, &lSize, NULL);

	    if (lSize > (LONG) (npMCI->dwBufferSize - 2 * sizeof(DWORD))) {

		DPF2(("ReadNextVideoFrame: Enlarging buffer....\n"));

		if (!ResizeReadBuffer(npMCI, lSize + 2 * sizeof(DWORD))) {
		    DPF(("Failed to increase buffer size!\n"));
		    npMCI->dwTaskError = MCIERR_OUT_OF_MEMORY;
		    return FALSE;
		}
	    }

	    if (AVIStreamRead(psi->ps, lPos, 1,
		      (LPSTR) npMCI->lpBuffer + 2 * sizeof(DWORD),
		      npMCI->dwBufferSize - 2 * sizeof(DWORD),
		      &lSize, NULL) != 0) {
		return FALSE;
	    }
	}

done:
	((DWORD FAR *)npMCI->lpBuffer)[0] = MAKEAVICKID(cktypeDIBbits,
							npMCI->nVideoStream);
	((DWORD FAR *)npMCI->lpBuffer)[1] = lSize;

	npMCI->lp = npMCI->lpBuffer;

	npMCI->dwThisRecordSize = lSize + 2 * sizeof(DWORD);

	return TRUE;
    }
#endif
    //
    // if we are not reading the "next" frame then figure out where it is.
    //
    if (npMCI->lLastRead != npMCI->lCurrentFrame-1)
	CalculatePosition(npMCI);

    //
    // dwNextRecordSize is the size to read
    // and we are seeked to the right place.
    //
    if (npMCI->hpFrameIndex) {

	//
	// if this frame has a new palette then deal with it
	//
	if (npMCI->dwFlags & MCIAVI_ANIMATEPALETTE) {
	     if (FramePalette(npMCI->lCurrentFrame) !=
		 FramePalette(npMCI->lLastPaletteChange))

		ProcessPaletteChanges(npMCI, npMCI->lCurrentFrame);
	}

	//
	// now just go read the frame from the disk.
	//
	// if interleaved add 8 to skip the 'REC'!!!!
	//
	return ReadBuffer(npMCI,
	    (LONG)FrameOffset(npMCI->lCurrentFrame),
	    (LONG)FrameLength(npMCI->lCurrentFrame) + 8);
    } else {
ReadAgainNoIndex:
	for (;;) {
	    if (mmioDescend(npMCI->hmmio, &ck, NULL, 0) != 0) {
		DPF(("Unable to descend!\n"));
		npMCI->dwTaskError = MCIERR_INVALID_FILE;
		return FALSE;
	    }

	    /* If it's a list, stay descended in it. */
	    /* Hack: we never ascend.            */
	    if (ck.ckid == FOURCC_LIST)
		continue;

#ifdef ALPHAFILES
	    /* Skip wave bytes, since they've been preloaded. */
	    if (npMCI->dwFlags & MCIAVI_USINGALPHAFORMAT) {
		if ((ck.ckid != ckidAVIPADDING) &&
			(ck.ckid != ckidOLDPADDING) &&
			(ck.ckid != ckidWAVEbytes))
		    break;
	    } else
#endif
	    {
		if (StreamFromFOURCC(ck.ckid) == (WORD)npMCI->nVideoStream)
		    break;
	    }

	    mmioAscend(npMCI->hmmio, &ck, 0);
	}

	if (ck.cksize + 2 * sizeof(DWORD) > npMCI->dwBufferSize) {
	    if (!ResizeReadBuffer(npMCI, ck.cksize + 2 * sizeof(DWORD))) {
		DPF(("ReadNextVideoFrame: Failed to increase buffer size!\n"));
		npMCI->dwTaskError = MCIERR_OUT_OF_MEMORY;
		return FALSE;
	    }
	}

	*((LPMMCKINFO) npMCI->lpBuffer) = ck;
	if (mmioRead(npMCI->hmmio, npMCI->lpBuffer + 2 * sizeof(DWORD),
			    ck.cksize) != (LONG) ck.cksize) {
	    npMCI->dwTaskError = MCIERR_INVALID_FILE;
	    return FALSE;
	}

	mmioAscend(npMCI->hmmio, &ck, 0);
	npMCI->lp = npMCI->lpBuffer;

	npMCI->dwThisRecordSize = ck.cksize + 2 * sizeof(DWORD);

	if (TWOCCFromFOURCC(ck.ckid) == cktypePALchange) {
	    npMCI->lp += 2 * sizeof(DWORD);
	    ProcessPaletteChange(npMCI, ck.cksize);
	    npMCI->lLastPaletteChange = npMCI->lCurrentFrame;
	    goto ReadAgainNoIndex;
	}
    }

    return TRUE;
}

BOOL NEAR PASCAL TimeToQuit(NPMCIGRAPHIC npMCI)
{
    /* If we're using DisplayDib, give the user a chance to break. */

    if ((npMCI->dwFlags & MCIAVI_FULLSCREEN) &&
		!(npMCI->dwFlags & MCIAVI_NOBREAK) &&
		(npMCI->wTaskState == TASKPLAYING)) {

	// Check each of the "stop" events
	if (1 & GetAsyncKeyState(VK_LBUTTON)) {
	    npMCI->dwFlags |= MCIAVI_STOP;
	}
	else if
	      (1 & GetAsyncKeyState(VK_RBUTTON)) {
	    npMCI->dwFlags |= MCIAVI_STOP;
	}
	else if
	      (1 & GetAsyncKeyState(VK_ESCAPE)) {
	    npMCI->dwFlags |= MCIAVI_STOP;
	}
	else if
	      (1 & GetAsyncKeyState(VK_SPACE)) {
	    npMCI->dwFlags |= MCIAVI_STOP;
	}
    }

    // this will be set by aviTaskCheckRequests if there is
    // a request that we need to stop to handle
    if (npMCI->dwFlags & MCIAVI_STOP)
	return TRUE;

#ifdef _WIN32
    if (TestNTFlags(npMCI, NTF_RETRYAUDIO)) {
	ResetNTFlags(npMCI, NTF_RETRYAUDIO);
	/*
	 * IF we get access to the wave device, set the flag that
	 * will cause the play to be restarted, then abort this play.
	 */
	SetUpAudio(npMCI, TRUE);
	if (npMCI->hWave) {
	     SetNTFlags(npMCI, NTF_RESTARTFORAUDIO);
	     return(TRUE);
	}
    }
#endif
    return FALSE;
}

/***************************************************************************
 *
 * @doc INTERNAL MCIAVI
 *
 * @api BOOL | AllocateReadBuffer | Allocates buffers needed to read
 *      disk information in to.  The amount of memory to allocate
 *      is in npMCI->dwBufferSize.
 *
 * @parm NPMCIGRAPHIC | npMCI | pointer to instance data block.
 *
 * @rdesc TRUE means OK, otherwise unable to allocate memory.
 *
 ***************************************************************************/
BOOL NEAR PASCAL AllocateReadBuffer(NPMCIGRAPHIC npMCI)
{
    if (npMCI->dwBufferSize == 0)
	npMCI->dwBufferSize = npMCI->dwSuggestedBufferSize;

    if (npMCI->dwBufferSize <= 8 * sizeof(DWORD))
    {
	if (npMCI->dwBytesPerSec > 0 &&
	    npMCI->dwBytesPerSec < 600l*1024 &&
	    npMCI->dwMicroSecPerFrame > 0)

	    npMCI->dwBufferSize = (muldiv32(npMCI->dwBytesPerSec,
			npMCI->dwMicroSecPerFrame,1000000L) + 2047) & ~2047;
	else
	    npMCI->dwBufferSize = 10*1024;

	npMCI->dwSuggestedBufferSize = npMCI->dwBufferSize;
    }

    DPF3(("allocating %lu byte read buffer.\n", npMCI->dwBufferSize));

    if (npMCI->lpBuffer) {
	DPF(("Already have buffer in AllocateReadBuffer!\n"));
	return ResizeReadBuffer(npMCI, npMCI->dwBufferSize);
    }

    //!!! we dont need DOS memory when we have a MMIO buffer!
    //!!! we dont need DOS memory when we are using AVIFile???

    if (npMCI->lpMMIOBuffer != NULL || npMCI->pf)
	npMCI->lpBuffer = GlobalAllocPtr(GHND | GMEM_SHARE, npMCI->dwBufferSize);
    else
	npMCI->lpBuffer = AllocMem(npMCI->dwBufferSize);

    return npMCI->lpBuffer != NULL;
}

/***************************************************************************
 *
 * @doc INTERNAL MCIAVI
 *
 * @api BOOL | ResizeReadBuffer | Enlarges buffer needed to read
 *      disk information in to.
 *
 * @parm NPMCIGRAPHIC | npMCI | pointer to instance data block.
 *
 * @parm DWORD | dwNewSize | new amount of memory to allocate
 *
 * @rdesc TRUE means OK, otherwise unable to allocate memory.
 *
 ***************************************************************************/
BOOL NEAR PASCAL ResizeReadBuffer(NPMCIGRAPHIC npMCI, DWORD dwNewSize)
{
    if (dwNewSize > npMCI->dwSuggestedBufferSize && !npMCI->fReadMany)
	npMCI->dwSuggestedBufferSize = dwNewSize;

    if (dwNewSize <= npMCI->dwBufferSize)
	return TRUE;

    DPF(("Increasing buffer size to %ld (was %ld).\n", dwNewSize, npMCI->dwBufferSize));

    ReleaseReadBuffer(npMCI);
    npMCI->dwBufferSize = dwNewSize;
    return AllocateReadBuffer(npMCI);
}

/***************************************************************************
 *
 * @doc INTERNAL MCIAVI
 *
 * @api void | ReleaseReadBuffer | Releases read buffer.
 *
 * @parm NPMCIGRAPHIC | npMCI | pointer to instance data block.
 *
 ***************************************************************************/
void NEAR PASCAL ReleaseReadBuffer(NPMCIGRAPHIC npMCI)
{
    if (npMCI->lpBuffer) {
	DPF3(("Releasing read buffer.\n"));

	GlobalFreePtr(npMCI->lpBuffer);

	npMCI->lpBuffer = NULL;
	npMCI->dwBufferSize = 0L;
	npMCI->fReadMany = FALSE;
    }
}

/***************************************************************************
 *
 * @doc INTERNAL MCIAVI
 *
 * @api BOOL | ReadBuffer
 *
 ***************************************************************************/

BOOL NEAR PASCAL ReadBuffer(NPMCIGRAPHIC npMCI, LONG off, LONG len)
{
    npMCI->lp = npMCI->lpBuffer;
    npMCI->dwThisRecordSize = len;

    if (len == 0) {
	((DWORD FAR *)npMCI->lpBuffer)[0] = 0; //!!!lpIndexEntry->ckid;
	((DWORD FAR *)npMCI->lpBuffer)[1] = 0;
	npMCI->dwThisRecordSize = 8;
	return TRUE;
    }

    if (len > (LONG)npMCI->dwBufferSize) {
	if (!ResizeReadBuffer(npMCI, len)) {
	    DPF(("Failed to increase buffer size!\n"));
	    npMCI->dwTaskError = MCIERR_OUT_OF_MEMORY;
	    return FALSE;
	}

	npMCI->lp = npMCI->lpBuffer;
    }

    if (off >= 0)
	DPF2(("ReadBuffer %ld bytes at %ld\n", len, off));
    else
	DPF2(("ReadBuffer %ld bytes\n", len));

    if (off >= 0)
	mmioSeek(npMCI->hmmio, off, SEEK_SET);

#ifdef INTERVAL_TIMES
{
    LONG    lReadStart = -(LONG)timeGetTime();
#endif

    if (mmioRead(npMCI->hmmio, npMCI->lp, len) != len) {
	npMCI->dwTaskError = MCIERR_FILE_READ;
	return FALSE;
    }

#ifdef INTERVAL_TIMES
    lReadStart += timeGetTime();
    npMCI->nReads++;
    npMCI->msReadTotal += lReadStart;
    if (lReadStart > npMCI->msReadMax) {
	npMCI->msReadMax = lReadStart;
    }
}
#endif
    return TRUE;
}

/***************************************************************************
 *
 * @doc INTERNAL MCIAVI
 *
 * @api LPVOID | AllocMem | try to allocate DOS memory (< 1Mb)
 *
 * @parm DWORD | dw | size in bytes
 *
 ***************************************************************************/

#ifndef _WIN32
static LPVOID AllocMem(DWORD dw)
{
    /* Memory allocation internal routines */

    extern DWORD FAR PASCAL GlobalDosAlloc(DWORD);

    LPVOID p;

    if (p = (LPVOID)MAKELONG(0, LOWORD(GlobalDosAlloc(dw))))
	{
	DPF(("Got %ld bytes DOS memory\n", dw));
	GlobalReAlloc((HANDLE)HIWORD((DWORD)p), 0, GMEM_MODIFY|GMEM_SHARE);
	return p;
	}
    else
    {
	DPF(("unable to get %ld bytes of DOS memory\n", dw));
	return GlobalLock(GlobalAlloc(GMEM_MOVEABLE|GMEM_SHARE, dw));
    }
}
#endif