able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/multimedia/media/avi/mciavi.16/aviplay.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

3321 lines
90 KiB
C
Raw Blame History

/******************************************************************************
Copyright (C) Microsoft Corporation 1985-1991. 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 ! */
//
// 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);
BOOL NEAR PASCAL TimeToQuit(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);
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);
void DealWithOtherStreams(NPMCIGRAPHIC npMCI, LONG lFrame);
BOOL NEAR PASCAL StreamRead(NPMCIGRAPHIC npMCI, STREAMINFO *psi, LONG lPos);
static LPVOID AllocMem(DWORD dw);
#ifndef WIN32
#define FreeMem(lp) GlobalFree((HGLOBAL)SELECTOROF(lp))
#else
#define FreeMem(lp) GlobalFreePtr(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
#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
#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
DWORD NEAR PASCAL PrepareToPlay(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 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;
#endif
#ifdef BEHINDHIST
for (w = 0; w < NUMBEHIND; w++)
wBehind[w] = 0;
#endif
#ifdef DRAWTIMEHIST
wDrawn = 0;
for (w = 0; w < NUMDRAWN; w++)
dwDrawTime[w] = 0;
#endif
#ifdef READTIMEHIST
wRead = 0;
for (w = 0; w < NUMREAD; w++)
dwReadTime[w] = 0;
#endif
Repeat:
Assert(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);
//
// pick a play function.
//
switch (npMCI->wPlaybackAlg) {
case MCIAVI_ALG_INTERLEAVED:
Play = PlayInterleaved;
break;
case MCIAVI_ALG_CDROM:
Play = PlayNonIntFromCD;
break;
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.\n", npMCI->lFrom, npMCI->lTo, npMCI->lCurrentFrame));
if (npMCI->dwTaskError != 0L)
goto SKIP_PLAYING;
/* We're done initializing; now we're warming up to play. */
npMCI->wTaskState = TASKCUEING;
TIMESTART(timePlay);
/* 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);
aviTaskYield();
TIMEEND(timeYield);
}
fContinue = Play(npMCI);
if (!fContinue)
break;
if (TimeToQuit(npMCI))
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
break;
}
}
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 guarentee 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);
// !!! should we set npMCI->lCurrentFrame = npMCI->lFrameDrawn?
///!!!npMCI->lCurrentFrame = npMCI->lFrameDrawn;
// !!! Should we update npMCI->lFrom to be npMCI->lCurrentFrame,
// to make that the default location play will start from next?
//SKIP_PLAYING:
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);
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;
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
#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
}
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;
}
BOOL NEAR PASCAL RestartAVI(NPMCIGRAPHIC npMCI);
BOOL NEAR PASCAL PauseAVI(NPMCIGRAPHIC npMCI);
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;
hdc = GetWindowDC(npMCI->hwnd);
//
// 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->hwnd, 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;
BOOL NEAR PASCAL WaitTillNextFrame(NPMCIGRAPHIC 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;
}
#ifdef JUMPINTERLEAVED
if (npMCI->hWave && npMCI->wABFull == 0 &&
npMCI->wTaskState == TASKPLAYING &&
(npMCI->dwOptionFlags & MCIAVIO_SKIPFRAMES)) {
LONG lTemp;
// !!! figure out how far ahead to skip!
PauseAVI(npMCI);
npMCI->lFrom = npMCI->lCurrentFrame;
npMCI->lFrom += npMCI->wABs;
npMCI->lFrom += (((Now() - npMCI->dwTimingStart) * 1000L)
- npMCI->dwNextFrameMicroSec) /
npMCI->dwPlayMicroSecPerFrame;
lTemp = FindNextKeyFrame(npMCI, npMCI->lFrom);
if (lTemp >= npMCI->lFrom)
npMCI->lFrom = lTemp;
if (npMCI->lFrom > npMCI->lFrames - 1)
npMCI->lFrom = npMCI->lFrames - 1;
DPF2(("Interleaved: jumping from %ld to %ld\n", npMCI->lCurrentFrame, npMCI->lFrom));
CalculateTargetFrame(npMCI);
return TRUE;
}
#endif
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
goto PauseNow0;
}
if (npMCI->wTaskState == TASKPLAYING) {
if (npMCI->dwFlags & MCIAVI_PAUSE) {
PauseNow0:
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 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.
** Unfortunately, the current code causes the code
** above to get called over and over, which is bad.
*/
if (fPlayedAudio && npMCI->wABFull < npMCI->wABs)
goto KeepFilling;
#endif
BePaused(npMCI);
RestartPlay0:
if (npMCI->dwFlags & MCIAVI_STOP)
return FALSE;
RestartAVI(npMCI);
}
}
KeepFilling:
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 > gwSkipTolerance && !npMCI->hpFrameIndex)
// DPF("We should read the index?\n");
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 */
EnterCrit(npMCI);
TIMESTART(timeVideo);
if (!DisplayVideoFrame(npMCI, fHurryUp)) {
LeaveCrit(npMCI);
npMCI->dwTaskError = MCIERR_AVI_DISPLAYERROR;
return FALSE;
}
TIMEEND(timeVideo);
LeaveCrit(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
return TRUE;
}
/******************************************************************************
*****************************************************************************/
BOOL NEAR PASCAL PlayNonInterleaved(NPMCIGRAPHIC npMCI)
{
BOOL fHurryUp = FALSE;
int iHurryUp;
LONG iFrame;
LONG iKey;
LONG iNextKey;
LONG iPrevKey;
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);
aviTaskYield();
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 (TimeToQuit(npMCI))
return FALSE;
}
}
if (TimeToQuit(npMCI))
return FALSE;
}
if (((npMCI->lCurrentFrame >= npMCI->lVideoStart) &&
(npMCI->lCurrentFrame < npMCI->lFrames)) ||
(npMCI->dwFlags & MCIAVI_REVERSE)) {
EnterCrit(npMCI);
TIMESTART(timeVideo);
if (!DisplayVideoFrame(npMCI, fHurryUp)) {
npMCI->dwTaskError = MCIERR_AVI_DISPLAYERROR;
LeaveCrit(npMCI);
return FALSE;
}
TIMEEND(timeVideo);
LeaveCrit(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);
}
return TRUE;
}
/******************************************************************************
*****************************************************************************/
BOOL NEAR PASCAL PlayAudioOnly(NPMCIGRAPHIC 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);
aviTaskYield();
TIMEEND(timeYield);
}
if (TimeToQuit(npMCI))
return FALSE;
}
return TRUE;
}
/******************************************************************************
*****************************************************************************/
#pragma message("PlayNonIntFromCD needs fixed?")
BOOL NEAR PASCAL PlayNonIntFromCD(NPMCIGRAPHIC npMCI)
{
BOOL fHurryUp = FALSE;
LONG lNewFrame;
DWORD ckid;
UINT wStream;
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:
lNewFrame = WhatFrameIsItTimeFor(npMCI);
TIMESTART(timeYield);
aviTaskYield();
TIMEEND(timeYield);
if (lNewFrame < npMCI->lCurrentFrame) {
DPF3(("Waiting: Current = %ld, time for %ld.\n", npMCI->lCurrentFrame, lNewFrame));
if (TimeToQuit(npMCI))
return FALSE;
else
goto WaitMore;
}
}
if (npMCI->lCurrentFrame >= npMCI->lVideoStart) {
TIMESTART(timeVideo);
EnterCrit(npMCI);
if (!DisplayVideoFrame(npMCI, fHurryUp)) {
npMCI->dwTaskError = MCIERR_AVI_DISPLAYERROR;
LeaveCrit(npMCI);
return FALSE;
}
TIMEEND(timeVideo);
LeaveCrit(npMCI);
}
return TRUE;
}
/******************************************************************************
*****************************************************************************/
/* 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);
//
// 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.
//
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 += muldiv32(npMCI->dwAudioPlayed,
1000L, npMCI->pWF->nAvgBytesPerSec);
}
/* Convert from MS to frames.... */
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;
}
/******************************************************************************
*****************************************************************************/
BOOL NEAR PASCAL PauseAVI(NPMCIGRAPHIC npMCI)
{
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_CUEING) {
/* If we're cueing, report that it was successful. */
npMCI->dwFlags &= ~(MCIAVI_CUEING);
GraphicDelayedNotify(npMCI, MCI_NOTIFY_SUCCESSFUL);
}
DPF2(("MCIAVI: Pausing\n"));
npMCI->wTaskState = TASKPAUSED;
return TRUE;
}
/******************************************************************************
*****************************************************************************/
BOOL NEAR PASCAL BePaused(NPMCIGRAPHIC npMCI)
{
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);
}
mmTaskBlock(npMCI->hTask);
}
TIMEEND(timePaused);
TIMESTART(timePlay);
return TRUE;
}
/******************************************************************************
*****************************************************************************/
BOOL NEAR PASCAL RestartAVI(NPMCIGRAPHIC npMCI)
{
int stream;
Assert(npMCI->wTaskState != TASKPLAYING);
/* Mark that play has actually begun */
npMCI->wTaskState = TASKPLAYING;
DPF(("MCIAVI: Starting\n"));
TIMESTART(timeYield);
aviTaskYield();
aviTaskYield();
aviTaskYield();
TIMEEND(timeYield);
DPF2(("MCIAVI: Starting (done yielding)\n"));
/* 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);
}
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.
*/
DWORD NEAR PASCAL PrepareToPlay(NPMCIGRAPHIC npMCI)
{
UINT w;
DWORD dwPosition;
int stream;
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) {
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 of 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
// !!!!
gwHurryTolerance = GetProfileInt(TEXT("MCIAVI"), TEXT("Hurry"), 2);
gwSkipTolerance = GetProfileInt(TEXT("MCIAVI"), TEXT("Skip"), gwHurryTolerance * 2);
gwMaxSkipEver = GetProfileInt(TEXT("MCIAVI"), TEXT("MaxSkip"), max(60, gwSkipTolerance * 10));
Assert(npMCI->lTo <= npMCI->lFrames);
Assert(npMCI->lFrom >= 0);
/* Clear out variables, so we'll know what needs to be released. */
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);
}
if (npMCI->dwFlags & MCIAVI_SEEKING)
goto PlayWithoutWave;
if (npMCI->hicDraw) {
ICGetBuffersWanted(npMCI->hicDraw, &npMCI->dwBufferedVideo);
}
#ifdef DEBUG
npMCI->dwBufferedVideo = GetProfileInt(TEXT("MCIAVI"), 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. */
if ((npMCI->nAudioStreams > 0)
&& (npMCI->dwFlags & MCIAVI_PLAYAUDIO)
&& (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) {
//
// we cant get the 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))
npMCI->dwTaskError = SetUpAudio(npMCI, TRUE);
}
}
if (npMCI->dwTaskError == MCIERR_WAVE_OUTPUTSINUSE) {
//
// even though we did not steal the wave device we still
// want it.
//
npMCI->dwFlags |= MCIAVI_LOSTAUDIO; // we want it
}
if (((npMCI->dwTaskError == MCIERR_WAVE_OUTPUTSINUSE) ||
(npMCI->dwTaskError == MCIERR_WAVE_OUTPUTSUNSUITABLE)) &&
(npMCI->wPlaybackAlg != MCIAVI_ALG_AUDIOONLY))
npMCI->dwTaskError = 0;
if (npMCI->dwTaskError)
return npMCI->dwTaskError;
}
PlayWithoutWave:
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
EnterCrit(npMCI);
if (npMCI->hdc == NULL) {
npMCI->hdc = GetDC(npMCI->hwnd); // Shouldn't use cached DC!
npMCI->dwFlags |= MCIAVI_RELEASEDC;
}
if (npMCI->hdc == NULL) {
LeaveCrit(npMCI);
return MCIERR_DRIVER_INTERNAL;
}
if (npMCI->dwFlags & MCIAVI_SEEKING) {
//
// audio only
//
if (npMCI->nVideoStreams == 0 && npMCI->nOtherStreams == 0) {
npMCI->lCurrentFrame = npMCI->lFrom;
LeaveCrit(npMCI);
return 0;
}
}
/* Start up the external decompressor, if any */
/* !!!We should check these for errors */
if (!DrawBegin(npMCI, NULL)) {
LeaveCrit(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
// devicerealize to see the function we are protecting against.
LeaveCrit(npMCI);
/*
** what if selecting the palette causes palette changes? we should
** yield and let the palette changes happen.
*/
//aviTaskYield(); ????????
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.
*/
GetAsyncKeyState(VK_ESCAPE);
GetAsyncKeyState(VK_SPACE);
GetAsyncKeyState(VK_LBUTTON);
}
/* 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);
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); // !!!
}
}
//
// 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->hwnd, // 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 &&
GetProfileInt(TEXT("MCIAVI"), 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?
}
if (!(npMCI->dwFlags & MCIAVI_SEEKING)) {
if (SI(stream)->ps) {
AVIStreamEndStreaming(SI(stream)->ps);
}
}
}
/* Clean up and close our wave output device. */
if (npMCI->hWave) {
Assert(!(npMCI->dwFlags & MCIAVI_LOSTAUDIO));
CleanUpAudio(npMCI);
//
// if we are not being forced to give up the audio try to
// give it to someone.
//
if (!(npMCI->dwFlags & MCIAVI_NEEDTOSHOW) &&
!(npMCI->dwFlags & MCIAVI_UPDATING))
GiveWaveDevice(npMCI);
}
else {
//
// done playing, we dont want a wave device any more
//
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 app thread)
EnterCrit(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
UnprepareDC(npMCI);
if (npMCI->dwFlags & MCIAVI_ANIMATEPALETTE)
RealizePalette(npMCI->hdc);
#endif
if (npMCI->dwFlags & MCIAVI_RELEASEDC) {
ReleaseDC(npMCI->hwnd, npMCI->hdc);
npMCI->hdc = NULL;
npMCI->dwFlags &= ~MCIAVI_RELEASEDC;
}
}
LeaveCrit(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 DEBUG
int iWait = 0;
StatusBar(npMCI,2,1,100,iWait);
#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 */
if ((npMCI->lCurrentFrame % YIELDEVERY) == 0) {
TIMESTART(timeYield);
aviTaskYield();
TIMEEND(timeYield);
}
if (npMCI->dwFlags & MCIAVI_WAVEPAUSED)
return TRUE;
if (TimeToQuit(npMCI))
return FALSE;
Assert(npMCI->wTaskState == TASKPLAYING);
AssertFrame(npMCI->lCurrentFrame - (LONG)npMCI->dwBufferedVideo);
Assert(npMCI->lCurrentFrame <= npMCI->lTo);
Assert(!(npMCI->dwFlags & MCIAVI_REVERSE));
while (WhatFrameIsItTimeFor(npMCI) < npMCI->lCurrentFrame) {
DPF2(("Waiting for %ld, time for %ld\n", npMCI->lCurrentFrame, WhatFrameIsItTimeFor(npMCI)));
StatusBar(npMCI,2,1,100,++iWait);
TIMESTART(timeWait);
aviTaskYield();
TIMEEND(timeWait);
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;
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;
//
// 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.
//
/* 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.
*
***************************************************************************/
void DealWithOtherStreams(NPMCIGRAPHIC npMCI, LONG lFrame)
{
int i;
STREAMINFO *psi;
LONG lPos;
LONG err;
for (i=0; i<npMCI->streams; i++) {
psi = SI(i);
if (!(psi->dwFlags & STREAM_ENABLED))
continue;
if (i == npMCI->nVideoStream)
continue;
if (i == npMCI->nAudioStream)
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;
}
//
// 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
//
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;
}
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;
DWORD dw;
if (!(npMCI->dwFlags & MCIAVI_ANIMATEPALETTE))
return TRUE;
psi = npMCI->psiVideo;
Assert(psi);
#ifdef USEAVIFILE
if (psi->ps) {
//
// we are in the palette range nohting 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)
{
LPDWORD 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 = (LPDWORD)(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;
}
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;
}
BOOL NEAR PASCAL StreamRead(NPMCIGRAPHIC npMCI, STREAMINFO *psi, LONG lPos)
{
LONG lSize;
Assert(psi);
Assert(psi->ps);
//
// if we are before the start or after the end, read nothing.
//
if (lPos < psi->lStart || lPos >= psi->lEnd) {
lSize = 0;
goto done;
}
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;
}
}
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 wiht 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 wiht 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)) {
UINT u;
u = GetAsyncKeyState(VK_ESCAPE) |
GetAsyncKeyState(VK_SPACE) |
GetAsyncKeyState(VK_LBUTTON);
if (u & 1) {
/* Break out of play loop */
npMCI->dwFlags |= MCIAVI_STOP;
}
}
if (npMCI->dwFlags & MCIAVI_STOP)
return TRUE;
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(("MCIAVI: 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);
if (mmioRead(npMCI->hmmio, npMCI->lp, len) != len) {
npMCI->dwTaskError = MCIERR_FILE_READ;
return FALSE;
}
return TRUE;
}
/***************************************************************************
*
* @doc INTERNAL MCIAVI
*
* @api LPVOID | AllocMem | try to allocate DOS memory (< 1Mb)
*
* @parm DWORD | dw | size in bytes
*
***************************************************************************/
static LPVOID AllocMem(DWORD dw)
{
#ifndef WIN32
/* 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
#endif
{
DPF(("unable to get %ld bytes of DOS memory\n", dw));
return GlobalLock(GlobalAlloc(GMEM_MOVEABLE|GMEM_SHARE, dw));
}
}
Reference in a new issue View git blame Copy permalink