archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 7b07a90fc1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '7b07a90fc1'
${ noResults }
windows-server-2003/multimedia/media/mciseq/mcicmds.c

676 lines
25 KiB
Raw Blame History

/*---------------------------------------------------------------------------*/
/*
Copyright (c) 1985-1998 Microsoft Corporation
Title: mcicmds.c - Multimedia Systems Media Control Interface
Contains specific mci command implementations
Version: 1.00
Date: 7-MAR-1991
Author: Greg Simons
------------------------------------------------------------------------------
Change log:
DATE REV DESCRIPTION
----------- ----- -----------------------------------------------------------
7-MAR-1991 GregSi Original
*/
/*---------------------------------------------------------------------------*/
#define UNICODE
//MMSYSTEM
#define MMNOSOUND - Sound support
#define MMNOWAVE - Waveform support
#define MMNOAUX - Auxiliary output support
#define MMNOJOY - Joystick support
//MMDDK
#define NOWAVEDEV - Waveform support
#define NOAUXDEV - Auxiliary output support
#define NOJOYDEV - Joystick support
#include <windows.h>
#include <mmsystem.h>
#include <mmddk.h>
#include <string.h>
#include <wchar.h>
#include "mmsys.h"
#include "list.h"
#include "mciseq.h"
#ifdef WIN16
#define SZCODE char _based(_segname("_CODE"))
#else
#define WSZCODE WCHAR
#endif
PRIVATE WSZCODE aszAppName[] = L"mciseq.drv";
PRIVATE WSZCODE aszSystemIni[] = L"system.ini";
PRIVATE WSZCODE aszTrue[] = L"true";
PRIVATE WSZCODE aszNull[] = L"";
PRIVATE WSZCODE aszDisableWarning[] = L"disablewarning";
/*---------------------------------------------------------------------------*/
PUBLIC DWORD NEAR PASCAL msOpen(
pSeqStreamType FAR *lppStream,
MCIDEVICEID wDeviceID,
DWORD dwFlags,
LPMCI_OPEN_PARMS lpOpen)
{
DWORD dwReturn; // to be returned from this function
LPCWSTR lpstrFileName;
LPMMIOPROC pIOProc;
pSeqStreamType pStream;
if ((dwFlags & (MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == (MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID))
return MCIERR_FLAGS_NOT_COMPATIBLE;
if (!(dwFlags & (MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)))
return 0L;
if (dwFlags & MCI_OPEN_SHAREABLE)
return MCIERR_UNSUPPORTED_FUNCTION;
if (dwFlags & MCI_OPEN_ELEMENT)
pIOProc = NULL;
else
pIOProc = *(LPMMIOPROC *)(lpOpen + 1);
// open the "stream" (opens file, allocs data, creates streaming task,
// and calls mmseq (sequencer) to have it allocate sequence structure)
lpstrFileName = lpOpen->lpstrElementName;
// Does not support 'new'
if (lpstrFileName != NULL && *lpstrFileName == '\0')
return MCIERR_FILENAME_REQUIRED;
dwReturn = msOpenStream(&pStream, lpstrFileName, pIOProc);
if (!dwReturn) {
MIDISEQINFO seqInfo;
pStream->wDeviceID = wDeviceID;
pStream->wNotifyMsg = 0;
// set up to remember when seq calls back
// tell sequencer to prepare to play (actually parses whole file
// and creates tempo map [which allocs memory])
if (midiSeqMessage(pStream->hSeq, SEQ_SETUPTOPLAY, 0L, 0L) == MIDISEQERR_NOMEM)
return MCIERR_OUT_OF_MEMORY;
// get back file division type (ppqn, smpte, etc...)
midiSeqMessage(pStream->hSeq, SEQ_GETINFO, (DWORD_PTR)(LPMIDISEQINFO)&seqInfo, 0L);
pStream->fileDivType = seqInfo.wDivType;
// set stream display type default based on file div type
switch (pStream->fileDivType) {
case SEQ_DIV_PPQN:
pStream->userDisplayType = MCI_SEQ_FORMAT_SONGPTR;
break;
case SEQ_DIV_SMPTE_24:
pStream->userDisplayType = MCI_FORMAT_SMPTE_24;
break;
case SEQ_DIV_SMPTE_25:
pStream->userDisplayType = MCI_FORMAT_SMPTE_25;
break;
case SEQ_DIV_SMPTE_30:
pStream->userDisplayType = MCI_FORMAT_SMPTE_30;
break;
case SEQ_DIV_SMPTE_30DROP:
pStream->userDisplayType = MCI_FORMAT_SMPTE_30DROP;
break;
}
//Force a wait until stream is initialized.
do {
Yield();
midiSeqMessage(pStream->hSeq, SEQ_GETINFO, (DWORD_PTR)(LPMIDISEQINFO)&seqInfo, 0L);
} while ((!seqInfo.bReadyToPlay) && (seqInfo.tempoMapExists) && (seqInfo.bLegalFile));
// (if tempo map deleted, this is a sign that a tempo map alloc failed)
// important: check to see if tempo map allocation failed
// if so, close sequence and return failure
mciSetDriverData(wDeviceID, (DWORD_PTR)pStream);
// MCI bookkeeping -- must come before close below
if (!seqInfo.tempoMapExists) {
dwReturn = MCIERR_OUT_OF_MEMORY;
mciDriverEntry(wDeviceID, MCI_CLOSE_DRIVER, dwFlags & ~MCI_NOTIFY, (DWORD_PTR)lpOpen);
} else if (!seqInfo.bLegalFile) {
dwReturn = MCIERR_INVALID_FILE;
mciDriverEntry(wDeviceID, MCI_CLOSE_DRIVER, dwFlags & ~MCI_NOTIFY, (DWORD_PTR)lpOpen);
} else
*lppStream = pStream;
}
return dwReturn;
}
/*---------------------------------------------------------------------------*/
PUBLIC DWORD NEAR PASCAL msClose(
pSeqStreamType pStream,
MCIDEVICEID wDeviceID,
DWORD dwFlags)
{
dprintf2(("close"));
if (pStream) {
midiSeqMessage(pStream->hSeq, SEQ_STOP, 0L, 0L);
dprintf4(("calling endfilestream"));
midiSeqMessage(pStream->hSeq, SEQ_SETPORTOFF, FALSE, 0L);
dprintf4(("closed port"));
Notify(pStream, (dwFlags == MCI_NOTIFY) ? MCI_NOTIFY_SUPERSEDED : MCI_NOTIFY_ABORTED);
EndFileStream(pStream);
dprintf4(("back from endfilestream"));
}
return 0;
}
/*---------------------------------------------------------------------------*/
PRIVATE DWORD PASCAL NEAR OpenMidiPort(
pSeqStreamType pStream)
{
if ((pStream->wPortNum == MCI_SEQ_NONE) || (midiSeqMessage(pStream->hSeq, SEQ_QUERYHMIDI, 0L, 0L)))
return 0;
if (!midiOutGetNumDevs()) {
dprintf1(("OpenMidiPort - no MIDI ports present"));
return MCIERR_SEQ_NOMIDIPRESENT; // No midi ports present
}
switch ((UINT)midiSeqMessage(pStream->hSeq, SEQ_SETPORT, (DWORD)pStream->wPortNum, 0L)) {
case 0:
return 0;
case MMSYSERR_ALLOCATED:
return MCIERR_SEQ_PORT_INUSE;
case MMSYSERR_BADDEVICEID:
return MCIERR_SEQ_PORT_NONEXISTENT;
case MIDIERR_NODEVICE:
return MIDIERR_NODEVICE;
default:
return MCIERR_SEQ_NOMIDIPRESENT;
}
}
/*---------------------------------------------------------------------------*/
PUBLIC DWORD NEAR PASCAL msPlay(pSeqStreamType pStream, MCIDEVICEID wDeviceID,
DWORD dwFlags, LPMCI_PLAY_PARMS lpPlay)
{
MIDISEQINFO seqInfo;
DWORD dwPlayFrom;
DWORD dwPlayTo;
DWORD dwReturn;
if (0 != (dwReturn = OpenMidiPort(pStream)))
return dwReturn;
// get info to aid in possible time format conversions (from & to)
midiSeqMessage(pStream->hSeq, SEQ_GETINFO, (DWORD_PTR)(LPMIDISEQINFO)&seqInfo, 0L);
// convert "to," if any
if (MCI_TO & dwFlags) {
// is the user typing in what he believes to be the end?
if (lpPlay->dwTo == CnvtTimeFromSeq(pStream, seqInfo.dwLength, &seqInfo))
dwPlayTo = seqInfo.dwLength; // if so, let him have it
else
dwPlayTo = CnvtTimeToSeq(pStream, lpPlay->dwTo, &seqInfo);
} else
dwPlayTo = PLAYTOEND; // has no effect
// convert "from," if any
if (MCI_FROM & dwFlags)
dwPlayFrom = CnvtTimeToSeq(pStream, lpPlay->dwFrom, &seqInfo);
else
dwPlayFrom = 0;
// complain if input out of range
// "to" in range [0..length]
if ((MCI_TO & dwFlags) && (!RangeCheck(pStream, lpPlay->dwTo)))
dwReturn = MCIERR_OUTOFRANGE;
// "from" in range [0..length]
else if ((MCI_FROM & dwFlags) && (!RangeCheck(pStream, lpPlay->dwFrom)))
dwReturn = MCIERR_OUTOFRANGE;
// from before to (can't play backwards!)
else if ((MCI_FROM & dwFlags) && (MCI_TO & dwFlags) && (dwPlayFrom > dwPlayTo))
dwReturn = MCIERR_OUTOFRANGE;
// if from not specified, current pos implied -- don't play backwards
else if ((!(MCI_FROM & dwFlags)) && (MCI_TO & dwFlags) && (dwPlayTo < seqInfo.dwCurrentTick))
dwReturn = MCIERR_OUTOFRANGE;
else if (MCI_FROM & dwFlags)
if (midiSeqMessage(pStream->hSeq, SEQ_SYNCSEEKTICKS, dwPlayFrom, 0) != MIDISEQERR_NOERROR)
dwReturn = MCIERR_DEVICE_NOT_READY;
if (!dwReturn) {
if (0 != (dwReturn = (DWORD)midiSeqMessage(pStream->hSeq, SEQ_PLAY, dwPlayTo, 0L))) {
// handle possible timer error (possibly due to timer.dll not loading)
if (dwReturn == MIDISEQERR_TIMER)
dwReturn = MCIERR_SEQ_TIMER;
} else if ((dwFlags & MCI_WAIT)) {
// handle "Play Wait"
if (pStream->hNotifyCB)
if (pStream->wNotifyMsg == MCI_PLAY) {
if (dwPlayTo == PLAYTOEND)
dwPlayTo = seqInfo.dwLength;
Notify(pStream, ((dwFlags & MCI_FROM) || (pStream->dwNotifyOldTo != dwPlayTo)) ? MCI_NOTIFY_ABORTED : MCI_NOTIFY_SUPERSEDED);
} else if (pStream->wNotifyMsg == MCI_SEEK)
Notify(pStream, MCI_NOTIFY_SUPERSEDED);
do {
Yield();
midiSeqMessage(pStream->hSeq, SEQ_GETINFO, (DWORD_PTR)(LPMIDISEQINFO)&seqInfo, 0L);
} while ((seqInfo.bPlaying) && (!mciDriverYield(wDeviceID)));
}
}
if (dwReturn && !seqInfo.bPlaying)
midiSeqMessage(pStream->hSeq, SEQ_SETPORTOFF, FALSE, 0L);
return dwReturn;
}
/*---------------------------------------------------------------------------*/
PUBLIC DWORD NEAR PASCAL msSeek(
pSeqStreamType pStream,
MCIDEVICEID wDeviceID,
DWORD dwParam1,
LPMCI_SEEK_PARMS lpSeek)
{
DWORD dwFlags;
DWORD dwSeekTo;
MIDISEQINFO seqInfo;
dwFlags = dwParam1 & ~(MCI_WAIT | MCI_NOTIFY); // don't consider these here
if (!dwFlags)
return MCIERR_MISSING_PARAMETER;
if (dwFlags != (dwFlags & (MCI_TO | MCI_SEEK_TO_START | MCI_SEEK_TO_END)))
return MCIERR_UNRECOGNIZED_KEYWORD;
midiSeqMessage(pStream->hSeq, SEQ_GETINFO, (DWORD_PTR)(LPMIDISEQINFO)&seqInfo, 0L);
switch (dwFlags) {
case MCI_TO:
if (!RangeCheck(pStream, lpSeek->dwTo))
return MCIERR_OUTOFRANGE;
dwSeekTo = CnvtTimeToSeq(pStream, lpSeek->dwTo, &seqInfo);
break;
case MCI_SEEK_TO_START:
dwSeekTo = 0L;
break;
case MCI_SEEK_TO_END:
dwSeekTo = seqInfo.dwLength;
break;
default:
return MCIERR_FLAGS_NOT_COMPATIBLE;
}
// if playing, call self to pause 1st.
if (seqInfo.bPlaying)
mciDriverEntry(wDeviceID, MCI_PAUSE, dwFlags, (DWORD_PTR)lpSeek);
// set up to remember when seq calls back
if (midiSeqMessage(pStream->hSeq, SEQ_SEEKTICKS, dwSeekTo, 0) != MIDISEQERR_NOERROR)
return MCIERR_DEVICE_NOT_READY;
else if (dwParam1 & MCI_WAIT) {
if (pStream->hNotifyCB)
if (pStream->wNotifyMsg == MCI_SEEK)
Notify(pStream, (pStream->dwNotifyOldTo != lpSeek->dwTo) ? MCI_NOTIFY_ABORTED : MCI_NOTIFY_SUPERSEDED);
else if (pStream->wNotifyMsg == MCI_PLAY)
Notify(pStream, MCI_NOTIFY_SUPERSEDED);
do {
midiSeqMessage(pStream->hSeq, SEQ_GETINFO, (DWORD_PTR)(LPMIDISEQINFO)&seqInfo, 0L);
Yield();
} while ((seqInfo.bSeeking) && (!mciDriverYield(wDeviceID)));
}
return 0;
}
/*---------------------------------------------------------------------------*/
PUBLIC DWORD NEAR PASCAL msStatus(
pSeqStreamType pStream,
MCIDEVICEID wDeviceID,
DWORD dwFlags,
LPMCI_STATUS_PARMS lpStatus)
{
DWORD dwReturn;
MIDISEQINFO seqInfo;
DWORD dwStatusReturn = 0;
if (!(dwFlags & MCI_STATUS_ITEM))
return MCIERR_MISSING_PARAMETER;
if ((dwFlags & MCI_TRACK) && (!((lpStatus->dwItem) & (MCI_STATUS_POSITION | MCI_STATUS_LENGTH))))
return MCIERR_DUPLICATE_FLAGS;
dwReturn = 0;
midiSeqMessage(pStream->hSeq, SEQ_GETINFO, (DWORD_PTR)(LPMIDISEQINFO)&seqInfo, 0L);
switch (lpStatus->dwItem) {
UINT wThingsPerMin;
UINT wResource;
case MCI_STATUS_TIME_FORMAT:
wResource = (UINT)pStream->userDisplayType;
if (wResource == MCI_SEQ_FORMAT_SONGPTR)
dwStatusReturn = (DWORD)MAKEMCIRESOURCE(MCI_SEQ_FORMAT_SONGPTR, MCI_SEQ_FORMAT_SONGPTR_S);
else
dwStatusReturn = (DWORD)MAKEMCIRESOURCE(wResource, wResource + MCI_FORMAT_RETURN_BASE);
dwReturn = MCI_RESOURCE_RETURNED;
break;
case MCI_STATUS_POSITION:
if (dwFlags & MCI_TRACK) {
if ((lpStatus->dwTrack) != 1)
dwReturn = MCIERR_OUTOFRANGE;
else
dwStatusReturn = 0L; //beginning of track
} else if (dwFlags & MCI_STATUS_START)
dwStatusReturn = 0L; //beginning of track
else // normal status position request
dwStatusReturn = CnvtTimeFromSeq(pStream, seqInfo.dwCurrentTick, &seqInfo);
if (ColonizeOutput(pStream))
dwReturn = MCI_COLONIZED4_RETURN;
break;
case MCI_STATUS_LENGTH:
if (dwFlags & MCI_TRACK)
if ((lpStatus->dwTrack) != 1)
dwReturn = MCIERR_OUTOFRANGE;
dwStatusReturn = CnvtTimeFromSeq(pStream, seqInfo.dwLength, &seqInfo);
if (ColonizeOutput(pStream))
dwReturn = MCI_COLONIZED4_RETURN;
break;
case MCI_STATUS_READY:
dwReturn = MCI_RESOURCE_RETURNED;
if (seqInfo.bReadyToPlay)
dwStatusReturn = (DWORD)MAKEMCIRESOURCE(TRUE, MCI_TRUE);
else
dwStatusReturn = (DWORD)MAKEMCIRESOURCE(FALSE, MCI_FALSE);
break;
case MCI_STATUS_NUMBER_OF_TRACKS:
dwStatusReturn = 1;
break;
case MCI_STATUS_MODE:
dwReturn = MCI_RESOURCE_RETURNED;
if (seqInfo.bSeeking)
wResource = MCI_MODE_SEEK;
else if (seqInfo.bPlaying)
wResource = MCI_MODE_PLAY;
else if (pStream->bLastPaused)
wResource = MCI_MODE_PAUSE;
else
wResource = MCI_MODE_STOP;
dwStatusReturn = (DWORD)MAKEMCIRESOURCE(wResource, wResource);
break;
case MCI_STATUS_MEDIA_PRESENT:
dwReturn = MCI_RESOURCE_RETURNED;
dwStatusReturn = (DWORD)MAKEMCIRESOURCE(TRUE, MCI_TRUE);
break;
case MCI_SEQ_STATUS_DIVTYPE:
dwReturn = MCI_RESOURCE_RETURNED;
switch (seqInfo.wDivType) {
//NB: the MCI_SEQ_DIV... codes are string ids
case SEQ_DIV_PPQN:
wResource = MCI_SEQ_DIV_PPQN;
break;
case SEQ_DIV_SMPTE_24:
wResource = MCI_SEQ_DIV_SMPTE_24;
break;
case SEQ_DIV_SMPTE_25:
wResource = MCI_SEQ_DIV_SMPTE_25;
break;
case SEQ_DIV_SMPTE_30:
wResource = MCI_SEQ_DIV_SMPTE_30;
break;
case SEQ_DIV_SMPTE_30DROP:
wResource = MCI_SEQ_DIV_SMPTE_30DROP;
break;
}
dwStatusReturn = (DWORD)MAKEMCIRESOURCE(wResource, wResource);
break;
case MCI_SEQ_STATUS_TEMPO:
// tempo comes back in microseconds per tick -- convert to
// more human-readable form if smpte: fps else bpm
wThingsPerMin = (UINT)(USecPerMinute / ((DWORD)seqInfo.wResolution * (DWORD)seqInfo.dwTempo));
if (seqInfo.wDivType == SEQ_DIV_PPQN)
dwStatusReturn = (DWORD)wThingsPerMin;
else
dwStatusReturn = (DWORD)(wThingsPerMin / 60); // things per second
break;
case MCI_SEQ_STATUS_PORT:
switch (pStream->wPortNum) {
case (UINT)MIDI_MAPPER:
dwReturn = MCI_RESOURCE_RETURNED;
dwStatusReturn = (DWORD)MAKEMCIRESOURCE(MIDI_MAPPER, MIDIMAPPER_S);
break;
case MCI_SEQ_NONE:
dwReturn = MCI_RESOURCE_RETURNED;
dwStatusReturn = (DWORD)MAKEMCIRESOURCE(MCI_SEQ_NONE, MCI_SEQ_NONE_S);
break;
default:
dwStatusReturn = pStream->wPortNum;
break;
}
break;
case MCI_SEQ_STATUS_SLAVE:
dwReturn = MCI_RESOURCE_RETURNED;
switch(seqInfo.wInSync) {
case SEQ_SYNC_NOTHING:
dwStatusReturn = (DWORD)MAKEMCIRESOURCE(MCI_SEQ_NONE, MCI_SEQ_NONE_S);
break;
case SEQ_SYNC_FILE:
dwStatusReturn = (DWORD)MAKEMCIRESOURCE(MCI_SEQ_FILE, MCI_SEQ_FILE_S);
break;
case SEQ_SYNC_MIDI:
dwStatusReturn = (DWORD)MAKEMCIRESOURCE(MCI_SEQ_MIDI, MCI_SEQ_MIDI_S);
break;
case SEQ_SYNC_SMPTE:
dwStatusReturn = (DWORD)MAKEMCIRESOURCE(MCI_SEQ_SMPTE, MCI_SEQ_SMPTE_S);
break;
}
break;
case MCI_SEQ_STATUS_MASTER:
dwReturn = MCI_RESOURCE_RETURNED;
switch(seqInfo.wOutSync) {
case SEQ_SYNC_NOTHING:
dwStatusReturn = (DWORD)MAKEMCIRESOURCE(MCI_SEQ_NONE, MCI_SEQ_NONE_S);
break;
case SEQ_SYNC_MIDI:
dwStatusReturn = (DWORD)MAKEMCIRESOURCE(MCI_SEQ_MIDI, MCI_SEQ_MIDI_S);
break;
case SEQ_SYNC_SMPTE:
dwStatusReturn = (DWORD)MAKEMCIRESOURCE(MCI_SEQ_SMPTE, MCI_SEQ_SMPTE_S);
break;
}
break;
case MCI_SEQ_STATUS_OFFSET:
dwStatusReturn = seqInfo.mmSmpteOffset.u.smpte.hour + ((DWORD)seqInfo.mmSmpteOffset.u.smpte.min << 8) + ((DWORD)seqInfo.mmSmpteOffset.u.smpte.sec << 16) + ((DWORD)seqInfo.mmSmpteOffset.u.smpte.frame << 24);
dwReturn = MCI_COLONIZED4_RETURN;
break;
case MCI_STATUS_CURRENT_TRACK:
dwStatusReturn = 1;
break;
default:
dwReturn = MCIERR_UNSUPPORTED_FUNCTION;
break;
}
// Return the status value in the struct
lpStatus->dwReturn = dwStatusReturn;
return dwReturn;
}
/*---------------------------------------------------------------------------*/
PUBLIC DWORD NEAR PASCAL msGetDevCaps(
pSeqStreamType pStream,
MCIDEVICEID wDeviceID,
DWORD dwFlags,
LPMCI_GETDEVCAPS_PARMS lpCapParms)
{
if (!(dwFlags & MCI_GETDEVCAPS_ITEM)) {
dprintf1(("msGetDevCaps - no capability requested"));
return MCIERR_MISSING_PARAMETER;
}
switch (lpCapParms->dwItem) {
case MCI_GETDEVCAPS_HAS_AUDIO:
case MCI_GETDEVCAPS_COMPOUND_DEVICE:
case MCI_GETDEVCAPS_USES_FILES:
case MCI_GETDEVCAPS_CAN_PLAY:
if (midiOutGetNumDevs()) {
dprintf2(("msGetDevCaps - %d midi out port(s) found",
midiOutGetNumDevs()));
lpCapParms->dwReturn = (DWORD)MAKEMCIRESOURCE(TRUE, MCI_TRUE);
} else {
dprintf2(("msGetDevCaps - NO midi out ports found"));
lpCapParms->dwReturn = (DWORD)MAKEMCIRESOURCE(FALSE, MCI_FALSE);
}
break;
case MCI_GETDEVCAPS_CAN_EJECT:
case MCI_GETDEVCAPS_CAN_RECORD:
case MCI_GETDEVCAPS_HAS_VIDEO:
case MCI_GETDEVCAPS_CAN_SAVE:
lpCapParms->dwReturn = (DWORD)MAKEMCIRESOURCE(FALSE, MCI_FALSE);
break;
case MCI_GETDEVCAPS_DEVICE_TYPE:
lpCapParms->dwReturn = (DWORD)MAKEMCIRESOURCE(MCI_DEVTYPE_SEQUENCER, MCI_DEVTYPE_SEQUENCER);
break;
default:
return MCIERR_MISSING_PARAMETER;
}
return MCI_RESOURCE_RETURNED;
}
/*---------------------------------------------------------------------------*/
PUBLIC DWORD NEAR PASCAL msInfo(
pSeqStreamType pStream,
MCIDEVICEID wDeviceID,
DWORD dwFlags,
LPMCI_INFO_PARMS lpInfo)
{
UINT wReturnLength;
if (!lpInfo->lpstrReturn)
return MCIERR_PARAM_OVERFLOW;
dwFlags &= ~(MCI_NOTIFY | MCI_WAIT);
if (dwFlags != (dwFlags & (MCI_INFO_PRODUCT | MCI_INFO_FILE)))
return MCIERR_UNRECOGNIZED_KEYWORD;
wReturnLength = (UINT)lpInfo->dwRetSize;
*(lpInfo->lpstrReturn + wReturnLength - 1) = '\0';
switch (dwFlags) {
case MCI_INFO_PRODUCT:
LoadString(hInstance, MSEQ_PRODUCTNAME, lpInfo->lpstrReturn, wReturnLength);
break;
case MCI_INFO_FILE:
if (!pStream)
return MCIERR_UNSUPPORTED_FUNCTION;
else
wcsncpy(lpInfo->lpstrReturn, (LPWSTR)pStream->szFilename, wReturnLength);
break;
default:
return MCIERR_MISSING_PARAMETER;
}
if ( *(lpInfo->lpstrReturn + wReturnLength - 1) != '\0' ) {
return MCIERR_PARAM_OVERFLOW;
}
else {
lpInfo->dwRetSize = wcslen( lpInfo->lpstrReturn );
return 0;
}
}
/*---------------------------------------------------------------------------*/
PUBLIC DWORD NEAR PASCAL msSet(
pSeqStreamType pStream,
MCIDEVICEID wDeviceID,
DWORD dwFlags,
LPMCI_SEQ_SET_PARMS lpSetParms)
{
DWORD dwReturn;
dwFlags &= ~(MCI_NOTIFY | MCI_WAIT | MCI_SET_ON | MCI_SET_OFF);
if (dwFlags != (dwFlags & (MCI_SEQ_SET_TEMPO | MCI_SEQ_SET_PORT | MCI_SEQ_SET_SLAVE | MCI_SEQ_SET_MASTER | MCI_SEQ_SET_OFFSET | MCI_SET_AUDIO | MCI_SET_VIDEO | MCI_SET_DOOR_OPEN | MCI_SET_DOOR_CLOSED | MCI_SET_TIME_FORMAT)))
return MCIERR_UNRECOGNIZED_KEYWORD;
dwReturn = 0; // no error by default
switch (dwFlags) {
UINT wPort;
MMTIME mmOffset;
case MCI_SET_TIME_FORMAT:
switch ((UINT)lpSetParms->dwTimeFormat) {
case MCI_FORMAT_SMPTE_30DROP:
case MCI_FORMAT_SMPTE_30:
case MCI_FORMAT_SMPTE_25:
case MCI_FORMAT_SMPTE_24:
case MCI_FORMAT_MILLISECONDS:
pStream->userDisplayType = lpSetParms->dwTimeFormat;
break;
case MCI_SEQ_FORMAT_SONGPTR:
if (pStream->fileDivType == SEQ_DIV_PPQN)
pStream->userDisplayType = lpSetParms->dwTimeFormat;
else
dwReturn = MCIERR_SEQ_DIV_INCOMPATIBLE;
break;
default:
dwReturn = MCIERR_BAD_TIME_FORMAT;
break;
}
break;
case MCI_SEQ_SET_TEMPO:
dwReturn = (DWORD)midiSeqMessage(pStream->hSeq, SEQ_SETTEMPO, lpSetParms->dwTempo, 0L);
break;
case MCI_SEQ_SET_PORT:
wPort = (UINT)lpSetParms->dwPort; // else use # passed in
if (wPort == MCI_SEQ_NONE) {
midiSeqMessage(pStream->hSeq, SEQ_SETPORTOFF, TRUE, 0L);
pStream->wPortNum = MCI_SEQ_NONE; //store port num (so can return "none")
} else if (!midiOutGetNumDevs())
dwReturn = MCIERR_SEQ_NOMIDIPRESENT;
else if ((wPort != MIDI_MAPPER) && (wPort >= midiOutGetNumDevs()))
dwReturn = MCIERR_SEQ_PORT_NONEXISTENT;
else if (wPort != pStream->wPortNum) { // ignore if using wPort already
MIDISEQINFO seqInfo;
// it's 0, 1...., or MAPPER
pStream->wPortNum = wPort; //store port number
midiSeqMessage(pStream->hSeq, SEQ_GETINFO, (DWORD_PTR)(LPMIDISEQINFO)&seqInfo, 0L);
if (seqInfo.bPlaying) {
midiSeqMessage(pStream->hSeq, SEQ_SETPORTOFF, TRUE, 0L);
dwReturn = OpenMidiPort(pStream);
}
}
break;
case MCI_SEQ_SET_SLAVE:
switch (lpSetParms->dwSlave) {
case MCI_SEQ_SMPTE:
case MCI_SEQ_MIDI:
dwReturn = MCIERR_UNSUPPORTED_FUNCTION;
break;
case MCI_SEQ_NONE:
dwReturn = (DWORD)midiSeqMessage(pStream->hSeq, SEQ_SETSYNCSLAVE, SEQ_SYNC_NOTHING, 0L);
break;
case MCI_SEQ_FILE:
dwReturn = (DWORD)midiSeqMessage(pStream->hSeq, SEQ_SETSYNCSLAVE, SEQ_SYNC_FILE, 0L);
break;
}
break;
case MCI_SEQ_SET_MASTER:
switch (lpSetParms->dwMaster) {
case MCI_SEQ_SMPTE:
case MCI_SEQ_MIDI:
dwReturn = MCIERR_UNSUPPORTED_FUNCTION;
break;
case MCI_SEQ_NONE:
dwReturn = (DWORD)midiSeqMessage(pStream->hSeq, SEQ_SETSYNCMASTER, SEQ_SYNC_NOTHING, 0L);
break;
}
break;
case MCI_SEQ_SET_OFFSET:
mmOffset.u.smpte.hour = (BYTE)lpSetParms->dwOffset;
mmOffset.u.smpte.min = (BYTE)(lpSetParms->dwOffset >> 8);
mmOffset.u.smpte.sec = (BYTE)(lpSetParms->dwOffset >> 16);
mmOffset.u.smpte.frame = (BYTE)(lpSetParms->dwOffset >> 24);
if ((lpSetParms->dwOffset & 0x80808080) || // all positive
(mmOffset.u.smpte.hour > 23) ||
(mmOffset.u.smpte.min > 59) ||
(mmOffset.u.smpte.sec > 59) ||
(mmOffset.u.smpte.frame > 29)) // allow max for all fmts
dwReturn = MCIERR_OUTOFRANGE;
else
dwReturn = (DWORD)midiSeqMessage(pStream->hSeq, SEQ_SETSYNCSLAVE, SEQ_SYNC_OFFSET, (DWORD_PTR)(LPMMTIME)&mmOffset);
break;
case MCI_SET_AUDIO: //fall thru...
case MCI_SET_VIDEO:
case MCI_SET_DOOR_OPEN:
case MCI_SET_DOOR_CLOSED:
dwReturn = MCIERR_UNSUPPORTED_FUNCTION;
break;
default:
dwReturn = MCIERR_MISSING_PARAMETER;
}
return dwReturn;
}
/*---------------------------------------------------------------------------*/