archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
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.
6 Commits
1 Branch
0 Tags
3.8 GiB
 
 
 
 
 
 
Tree: daad8a087a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'daad8a087a'
${ noResults }
windows-xp/Source/XPSP1/NT/shell/osshell/control/midi/midimap.c

3260 lines
120 KiB
Raw Blame History

/*
* MIDIMAP.C
*
* Copyright (C) 1990 Microsoft Corporation. All rights reserved.
*
* File I/O support routines for MIDI mapper and control panel.
*
* History:
*
* gregsi 30-Apr-91 midimap.ini -> midimap.cfg
* t-mikemc 27-Sep-90 mapKeyMapInSetup, mapPatchMapInSetup, mapExists,
* and mapGetUsageCount now all return DWORDS.
* mapGetSize can return an error now.
* t-mikemc 24-Sep-90 Added count to MMTABLE data structure. Made
* deleting setups and patchmaps update usage count
* of patchmaps and keymaps, respectively.
* t-mikemc 23-Sep-90 Finally got that wNameID taken out of memory
* data structures.
* t-mikemc 22-Sep-90 Made MmaperrWriteSetup look for invalid port ID's
* and write "invalid" device names correctly.
* t-mikemc 21-Sep-90 Mucked about with the mapEnumerate function to
* allow for enumeration of ports accessed by a setup.
* t-mikemc 31-Jul-90 Added volume mapping and mapGetUsageCount API.
* t-mikemc 15-Jul-90 Slew-o-changes! Munged Write/Read/Enum/Delete
* API's together into single functions. Finished
* up work on 'use-count' for patch and key maps.
* Commented and generally cleaned up lots-o-code.
* t-mikemc 05-Jul-90 Added mapPatchMapInSetup and mapKeyMapInSetup
* functions.
* t-mikemc 13-Jun-90 Removed wSize element from setup data structure.
* Setups now read in size of each referenced
* patchmap.
* t-mikemc 20-May-90 Added DWORD dwFlags to all internal file data
* structures.
* t-mikemc 11-May-90 Changed enumeration functions so they send
* name and description.
* t-mikemc 19-Apr-90 Changed routines to use binary file format.
* t-mikemc 17-Apr-90 Created.
*/
// Please note that the use of "goto" statements in this module isn't
// disgusting.
//
// brucemo
// Well it disgusts me. I put readability before writeability.
// The compiler generates no less than 17 messages saying that a
// variable may be used before initialised, and that means that
// either the thing is full of bugs (so Dijkstra was right) or
// else it's having a tough time following the flow of the logic.
// Me too.
// For good measure, the optimisation in compilers is almost always
// inhibited by goto.
// LaurieGr
#include <windows.h>
#include <string.h>
#define MMNOMCI
#define MMNOJOY
#define MMNOSOUND
#define MMNOWAVE
#include <mmsystem.h>
#if defined(WIN32)
#include <port1632.h>
#endif //WIN32
#include "hack.h"
#include "midimap.h"
#include "midi.h"
#include "extern.h"
/*-=-=-=-=- Global Definitions -=-=-=-=-*/
#define MM_VERSION 1 // mapfile version number
#define MM_NUMSETUP 100 // number of setups
#define MM_NUMPATCH 100 // number of patchmaps
#define MM_NUMKEY 100 // number of keymaps
#define MAP_FOPEN 1 // open file
#define MAP_FCREATE 2 // create/open file
#define MAP_FCLOSE 3 // close file
#define MAKEID(id) ((LPSTR) (LONG) (id))
#define LSB 1 // LSB for usage byte
#define MSB 128 // MSB for usage byte
#define MAX_UNIQUENAME 32 // max length of unique name
/*-=-=-=-=- Internal Data Structures -=-=-=-=-*/
#pragma pack(1)
// Internal file data structures
typedef struct midimapkey_tag {
WORD wUsing; // number of patchmaps using this
BYTE bKMap[MIDIPATCHSIZE]; // translate table for key map
DWORD dwFlags; // flags
} MMKEY;
typedef MMKEY UNALIGNED FAR *LPMMKEY;
typedef struct midimappatch_tag {
WORD wUsing; // number of setups using this
BYTE bVMax; // max volume scalar
WORD wPMap[MIDIPATCHSIZE]; // lobyte=xlat table, hibyte=volume // a PATCHARRAY?
DWORD dwSize; // size of patchmap
WORD idxKMapNames[MIDIPATCHSIZE]; // keymap name table indexes // a KEYARRAY?
DWORD dwFlags; // flags
} MMPATCH;
typedef MMPATCH UNALIGNED FAR *LPMMPATCH;
typedef struct midimapchannel_tag {
WORD wChannel; // port channel of device
BYTE szDevice[MAXPNAMELEN]; // device name
WORD idxPMapName; // patchmap name table index
DWORD dwFlags; // flags
} MMCHANNEL;
typedef MMCHANNEL UNALIGNED FAR *LPMMCHANNEL;
typedef struct midimapsetup_tag {
MMCHANNEL chMap[16]; // array of channel maps
DWORD dwFlags; // flags
} MMSETUP;
typedef MMSETUP UNALIGNED FAR *LPMMSETUP;
typedef struct midimaptableentry_tag {
BYTE szName[MMAP_MAXNAME]; // name of map
BYTE szDesc[MMAP_MAXDESC]; // description of map
WORD idxEntry; // index of this entry in table
DWORD doData; // file offset of data structure
} MMTABLEENTRY;
typedef MMTABLEENTRY UNALIGNED FAR *LPMMTABLEENTRY;
typedef struct midimaptableheader_tag {
WORD wEntrys; // number of entries in table
WORD wUsed; // number of entries being used
} MMTABLEHEADER;
typedef MMTABLEHEADER UNALIGNED FAR *LPMMTABLEHEADER;
typedef struct midimapheader_tag {
WORD wVersion; // version number of file
DWORD dwGarbage; // garbage collection bytes
WORD idxCurSetup; // current setup table index
WORD oSetup; // setup table offset
WORD oPatch; // patchmap table offset
WORD oKey; // keymap table offset
} MMHEADER;
// Internal memory data structures.
typedef struct midimaptable_tag {
WORD wCount; // times this table has been opened
MMTABLEHEADER mmHeader; // header for this table
HANDLE hEntrys; // handle to array of entrys
} MMTABLE;
typedef MMTABLE UNALIGNED FAR *LPMMTABLE;
typedef struct uniquemap_tag {
BYTE szName[MAX_UNIQUENAME];// unique map or port name
DWORD dwOffset; // offset from base or device ID
HANDLE hNext; // next one
} UNIQUEMAP;
typedef UNIQUEMAP UNALIGNED FAR *LPUNIQUEMAP;
#pragma pack()
/*-=-=-=-=- Function Prototypes -=-=-=-=-*/
#define STATIC /**/
STATIC MMAPERR NEAR PASCAL MmaperrAddMap(UINT, LPVOID, LPDWORD);
STATIC MMAPERR NEAR PASCAL MmaperrChangeUsing(UINT, UINT, int);
STATIC MMAPERR NEAR PASCAL MmaperrEnumPorts(ENUMPROC, UINT, HWND, LPSTR);
STATIC MMAPERR NEAR PASCAL MmaperrFileAccess(int, int);
STATIC VOID NEAR PASCAL VFreeUniqueList(LPHANDLE);
STATIC VOID NEAR PASCAL VFreeTable(UINT);
STATIC MMAPERR NEAR PASCAL MmaperrGarbage(UINT);
STATIC DWORD NEAR PASCAL DwGetMapSize(UINT, LPSTR);
STATIC DWORD NEAR PASCAL DwGetSetupSize(LPSTR);
STATIC LPMMTABLEENTRY NEAR PASCAL LpGetTableEntry(HANDLE, LPSTR);
STATIC LPSTR NEAR PASCAL LszGetUniqueAtOffset (DWORD, HANDLE);
STATIC DWORD NEAR PASCAL LiNotUnique(LPSTR, LPHANDLE, DWORD);
STATIC MMAPERR NEAR PASCAL MmaperrReadKeymap (LPSTR, LPMIDIKEYMAP);
STATIC DWORD NEAR PASCAL DwReadPatchmap(LPSTR, LPMIDIPATCHMAP, BOOL);
STATIC MMAPERR NEAR PASCAL MmaperrReadSetup(LPSTR, LPMIDIMAP);
STATIC MMAPERR NEAR PASCAL MmaperrReadTable(UINT);
STATIC MMAPERR NEAR PASCAL MmaperrWriteKeymap(LPMIDIKEYMAP);
STATIC MMAPERR NEAR PASCAL MmaperrWritePatchmap(PATCHMAP FAR*);
STATIC MMAPERR NEAR PASCAL MmaperrWriteSetup (SETUP FAR*);
STATIC MMAPERR NEAR PASCAL MmaperrWriteTabEntry(UINT,
UINT, LPMMTABLEENTRY);
STATIC MMAPERR NEAR PASCAL MmaperrWriteTabHeader(UINT, LPMMTABLEHEADER);
/*-=-=-=-=- Global Constants -=-=-=-=-*/
TCHAR RegEntry[] =
TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion\\Midimap");
TCHAR RegCurrent[] = TEXT("Mapping Name");
/*-=-=-=-=- Global Variables -=-=-=-=-*/
char aszMapperPath[MAXPATHLEN+1]; // A Path Buffer to mapper file (real or temp)
static HANDLE hPortList, // Unique port names list.
hPatchList, // Unique patchmaps list.
hKeyList; // Unique keymaps list.
static HANDLE hSetupTable, // Setup table handle.
hPatchTable, // Patch table handle.
hKeyTable; // Key table handle.
static HFILE iFile = HFILE_ERROR; // File handle.
static UINT ucFileOpen; // times the (.CFG?) file has been opened
static BOOL fEditing;
// - - - - - - - - -
void FAR PASCAL mapConnect(LPSTR lpszTmpPath)
{
// mapFileVersion will force the mapper to open the file
// so we can change the filename from under it anyway
lstrcpy(aszMapperPath,lpszTmpPath);
fEditing = TRUE;
}
void FAR PASCAL mapDisconnect(void)
{
// We can't leave the temporary file open. Otherwise someone
// might reference it after the applet disconnects.
if (iFile != HFILE_ERROR)
{
ucFileOpen = 1; // Force it to close
(VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
}
fEditing = FALSE;
}
/*
* @doc INTERNAL
*
* @api int | mapFileVersion | This function obtains the version number of the
* user's midi data file.
*
* @rdesc Returns a DWORD, the high word of which is an error code. If the
* error code is MMAPERR_SUCCESS, the low word contains the version
* number.
*/
DWORD FAR PASCAL mapFileVersion (void)
{
MMHEADER mmHeader;
DWORD dwRet;
MMAPERR mmaperr;
// This kludge is here in case MMSYSTEM crashes inside one of the
// midimap functions that has the file open. In this case, iFile
// will be non-null and the cpl applet will think there is no
// midimap.cfg file.
hPortList = NULL;
hPatchList = NULL;
hKeyList = NULL;
hSetupTable = NULL;
hPatchTable = NULL;
hKeyTable = NULL;
iFile = HFILE_ERROR;
ucFileOpen = 0;
mmaperr = MmaperrFileAccess(MAP_FOPEN,OF_READ);
if (mmaperr != MMAPERR_SUCCESS)
return MAKELONG(0, mmaperr);
dwRet = ( _lread(iFile, (LPSTR)&mmHeader,sizeof(MMHEADER))
!= sizeof(MMHEADER)
)
? MAKELONG(0, MMAPERR_READ)
: MAKELONG(mmHeader.wVersion, MMAPERR_SUCCESS);
(VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return dwRet;
} /* mapFileVersion */
// - - - - - - - - -
/*
* @doc INTERNAL
*
* @api BOOL | mapInitMapFile | This function initializes the user's
* midi data file. It creates a file in the user's windows directory,
* and fills it with the necessary header information. If the file
* exists, it will be truncated to zero length first.
*
* @rdesc Returns non-zero if successful, otherwise zero.
*/
// Issues:
//
// 1. Need to install "DeleteFile" code.
MMAPERR FAR PASCAL mapInitMapFile (void)
{
SETUP setup;
MMHEADER mmHeader;
MMTABLEHEADER mmtHeader;
MMTABLEENTRY mmtEntry;
MMAPERR mmaperr;
WORD wNum ;
if ((mmaperr = MmaperrFileAccess(MAP_FCREATE,
0)) != MMAPERR_SUCCESS)
return mmaperr;
mmHeader.wVersion = MM_VERSION;
mmHeader.dwGarbage = 0L;
mmHeader.idxCurSetup = 0; // Set later in mapSetCurrentSetup
mmHeader.oSetup = (wNum = sizeof(MMHEADER));
mmHeader.oPatch = ( wNum += sizeof(MMTABLEHEADER) + MM_NUMSETUP*sizeof(MMTABLEENTRY) );
mmHeader.oKey = (wNum += sizeof(MMTABLEHEADER) + MM_NUMPATCH*sizeof(MMTABLEENTRY) );
if (_lwrite(iFile, (LPSTR)&mmHeader, sizeof(MMHEADER))
!= sizeof(MMHEADER)
) {
mmaperr = MMAPERR_WRITE;
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
exit01: // Delete file here.
return mmaperr;
}
_fmemset(&mmtEntry, 0, sizeof(MMTABLEENTRY));
mmtHeader.wUsed = 0;
{ UINT i;
for (i = 0; i < 3; i++) {
switch (i) {
case 0:
mmtHeader.wEntrys = MM_NUMSETUP;
break;
case 1:
mmtHeader.wEntrys = MM_NUMPATCH;
break;
case 2:
mmtHeader.wEntrys = MM_NUMKEY;
break;
}
if (_lwrite(iFile, (LPSTR)&mmtHeader, sizeof(MMTABLEHEADER))
!= sizeof(MMTABLEHEADER)
) {
mmaperr = MMAPERR_WRITE;
goto exit00;
}
for (wNum = mmtHeader.wEntrys; wNum ; wNum --)
if (_lwrite(iFile, (LPSTR)&mmtEntry,
sizeof(MMTABLEENTRY)) !=
sizeof(MMTABLEENTRY)) {
mmaperr = MMAPERR_WRITE;
goto exit00;
}
}
}
_fmemset(&setup, 0, sizeof(SETUP));
LoadString( hLibInst
, IDS_VANILLANAME
, setup.aszSetupName
, sizeof(setup.aszSetupName)
);
LoadString( hLibInst
, IDS_VANILLADESC
, setup.aszSetupDescription
, sizeof(setup.aszSetupDescription)
);
{ UINT wChan;
for (wChan = 0; wChan < 16; wChan++) {
setup.channels[wChan].wDeviceID = MMAP_ID_NOPORT;
setup.channels[wChan].wChannel = (WORD)wChan;
}
}
if ((mmaperr = MmaperrWriteSetup(&setup)) != MMAPERR_SUCCESS)
goto exit00;
if ((mmaperr = mapSetCurrentSetup(MAKEID(1))) != MMAPERR_SUCCESS)
goto exit00;
if ((mmaperr = MmaperrFileAccess(MAP_FCLOSE, 0)) != MMAPERR_SUCCESS)
goto exit01; // 01, not 00.
return MMAPERR_SUCCESS;
} /* mapInitMapFile */
// - - - - - - - - -
/*
* @doc INTERNAL
*
* @api UINT | mapSetCurrentSetup | This function sets the name of the current
* setup.
*
* @parm LPSTR | lpSetupName | Specifies the name of a setup which you
* want to be the current setup.
*
* @rdesc The return value is currently undefined.
*/
// Issues:
//
// 1. None.
MMAPERR FAR PASCAL mapSetCurrentSetup (LPSTR lpSetupName)
{
LPMMTABLEENTRY lpmmEntry;
MMHEADER mmHeader;
MMAPERR mmaperr;
HKEY hKey;
LONG lRet;
/*
** See if the information is stored in the registry.
** If so write the stuff there. Otherwise fall thru and try to
** write the stuff into the mapper file.
*/
lRet = RegOpenKey( HKEY_LOCAL_MACHINE, RegEntry, &hKey );
if ( lRet == ERROR_SUCCESS ) {
lRet = RegSetValueEx( hKey, RegCurrent, 0L, REG_SZ,
(LPBYTE)lpSetupName,
sizeof(TCHAR) * (1 + lstrlen(lpSetupName)));
RegCloseKey( hKey );
if ( lRet == ERROR_SUCCESS) {
return MMAPERR_SUCCESS;
}
}
if ((mmaperr = MmaperrFileAccess(MAP_FOPEN,
OF_READWRITE)) != MMAPERR_SUCCESS)
return mmaperr;
if ((mmaperr = MmaperrReadTable(MMAP_SETUP)) != MMAPERR_SUCCESS) {
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return mmaperr;
}
lpmmEntry = LpGetTableEntry(hSetupTable,
lpSetupName);
if (_llseek(iFile, 0L, 0) == -1L) {
mmaperr = MMAPERR_READ;
exit01: VFreeTable(MMAP_SETUP);
goto exit00;
}
if (_lread(iFile, (LPSTR)&mmHeader,
sizeof(MMHEADER)) != sizeof(MMHEADER)) {
mmaperr = MMAPERR_READ;
goto exit01;
}
mmHeader.idxCurSetup = lpmmEntry->idxEntry;
if (_llseek(iFile, 0L, 0) == -1L) {
mmaperr = MMAPERR_WRITE;
goto exit01;
}
if (_lwrite(iFile, (LPSTR)&mmHeader,
sizeof(MMHEADER)) != sizeof(MMHEADER)) {
mmaperr = MMAPERR_WRITE;
goto exit01;
}
VFreeTable(MMAP_SETUP);
if ((mmaperr = MmaperrFileAccess(MAP_FCLOSE, 0)) != MMAPERR_SUCCESS)
return mmaperr;
return MMAPERR_SUCCESS;
} /* mapSetCurrentSetup */
// - - - - - - - - -
/*
* @doc INTERNAL
*
* @api LPSTR | mapGetCurrentSetup | This function retrieves the name of the
* current setup.
*
* @parm LPSTR | lpBuf | Specifies a buffer into which the current setup
* name will be copied.
*
* @parm UINT | wSize | Specifies the size in bytes of <p lpBuf>.
*
* @rdesc Returns an MMAP error, or zero on success.
*
* @comm You should make sure that the supplied buffer and size are at
* least MMAP_MAXNAME characters (defined in MMSYSTEM.H).
*/
// Issues:
//
// 1. None.
MMAPERR FAR PASCAL mapGetCurrentSetup(
LPSTR lpBuf,
UINT uSize)
{
LPMMTABLEENTRY lpmmEntry;
MMHEADER mmHeader;
MMAPERR mmaperr;
LPSTR lpEntryName;
LPSTR lp;
HKEY hKey;
LONG lRet;
/*
** See if the information is stored in the registry.
** If so read the stuff from there. Otherwise fall thru and try to
** get the stuff from the mapper file.
*/
lRet = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
RegEntry,
0L,
KEY_QUERY_VALUE,
&hKey );
if (lRet == ERROR_SUCCESS) {
DWORD dwType, dwLen;
dwLen = uSize;
lRet = RegQueryValueEx( hKey, RegCurrent, 0L, &dwType,
(LPBYTE)lpBuf, &dwLen );
RegCloseKey( hKey );
if ( lRet == ERROR_SUCCESS) {
return MMAPERR_SUCCESS;
}
}
/* attempt to open file, read setup table */
mmaperr = MmaperrFileAccess(MAP_FOPEN, OF_READ);
if (mmaperr != MMAPERR_SUCCESS)
return mmaperr;
mmaperr = MmaperrReadTable(MMAP_SETUP);
if (mmaperr != MMAPERR_SUCCESS) {
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return mmaperr;
}
// read the file header
if (_llseek(iFile, 0L, 0) == -1L) {
mmaperr = MMAPERR_READ;
exit01: VFreeTable(MMAP_SETUP);
goto exit00;
}
if (_lread(iFile, (LPSTR)&mmHeader, sizeof(MMHEADER))
!= sizeof(MMHEADER)
) {
mmaperr = MMAPERR_READ;
goto exit01;
}
lpmmEntry = LpGetTableEntry(hSetupTable, MAKEID(mmHeader.idxCurSetup)); // Always succeed.
// lstrncmp (lpBuf, lpmmEntry->szName, uSize - 1);
for (lp = lpBuf, lpEntryName = (LPSTR)(lpmmEntry->szName); --uSize; )
*lp++ = *lpEntryName++;
*lp = '\0';
// free table, close file and leave
VFreeTable(MMAP_SETUP);
(VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return MMAPERR_SUCCESS;
} /* mapGetCurrentSetup */
// - - - - - - - - -
MMAPERR FAR PASCAL mapReadSetup(
LPSTR lszSetupName,
SETUP FAR* lpSetup)
{
LPMMCHANNEL lpmmChan;
LPMMTABLEENTRY lpmmEntry;
MMSETUP mmSetup;
MMAPERR mmaperr;
UINT wNumDevs;
BOOL fNoPort;
int i;
UINT wDev;
// open file, read in pertinent tables
mmaperr = MmaperrFileAccess(MAP_FOPEN, OF_READ);
if (mmaperr != MMAPERR_SUCCESS) {
return mmaperr;
}
fNoPort = FALSE;
mmaperr = MmaperrReadTable(MMAP_SETUP | MMAP_PATCH | MMAP_KEY);
if (mmaperr != MMAPERR_SUCCESS) {
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return mmaperr;
}
lpmmEntry = LpGetTableEntry(hSetupTable, lszSetupName);
if (lpmmEntry == NULL) {
mmaperr = MMAPERR_INVALIDSETUP;
exit01: VFreeTable(MMAP_SETUP | MMAP_PATCH | MMAP_KEY);
goto exit00;
}
// read in setup data from file
if (_llseek(iFile, lpmmEntry->doData, 0) == -1L) {
mmaperr = MMAPERR_READ;
goto exit01;
}
if (_lread(iFile, (LPSTR)&mmSetup, sizeof(MMSETUP)) != sizeof(MMSETUP)){
mmaperr = MMAPERR_READ;
goto exit01;
}
// copy over setup name, description, and flags
lstrcpy(lpSetup->aszSetupName, (LPCSTR)(lpmmEntry->szName));
lstrcpy(lpSetup->aszSetupDescription, (LPCSTR)(lpmmEntry->szDesc));
lpSetup->dFlags = mmSetup.dwFlags;
// grab the number of devices in the current environment
wNumDevs = midiOutGetNumDevs();
// set up a couple of optimization-pointers
lpmmChan = (LPMMCHANNEL)(mmSetup.chMap); // MIPS silliness
for (i = 0; i < 16; i++, lpmmChan++) {
// convert device name to device ID. If device name doesn't
// exist in the current environment, set ID to MMAP_ID_NOPORT
if (!*lpmmChan->szDevice)
wDev = wNumDevs;
else
for (wDev = 0; wDev < wNumDevs; wDev++) {
MIDIOUTCAPS moCaps;
midiOutGetDevCaps(wDev, &moCaps, sizeof(MIDIOUTCAPS));
if (!lstrcmpi( moCaps.szPname
, (LPCSTR)(lpmmChan->szDevice)))
break;
}
// copy over channel and flag info
lpSetup->channels[i].wChannel = lpmmChan->wChannel;
lpSetup->channels[i].dFlags = lpmmChan->dwFlags;
if (wDev < wNumDevs)
lpSetup->channels[i].wDeviceID = (WORD)wDev;
else {
lpSetup->channels[i].wDeviceID = MMAP_ID_NOPORT;
// this error code only if there was a port
// name but it does not exist on the current system.
if (*lpmmChan->szDevice)
fNoPort = TRUE;
}
// if channel has no patchmap then on to next channel
if (!lpmmChan->idxPMapName) {
lstrcpy(lpSetup->channels[i].aszPatchName, szNone);
continue;
}
lpmmEntry = LpGetTableEntry(hPatchTable, MAKEID(lpmmChan->idxPMapName));
lstrcpy( lpSetup->channels[i].aszPatchName
, (LPCSTR)(lpmmEntry->szName));
}
VFreeTable(MMAP_SETUP | MMAP_PATCH | MMAP_KEY);
MmaperrFileAccess(MAP_FCLOSE, 0);
if (fNoPort)
return MMAPERR_INVALIDPORT;
return MMAPERR_SUCCESS;
}
MMAPERR FAR PASCAL mapReadPatchMap(
LPSTR lszPatchMapName,
PATCHMAP FAR* lpPatch)
{
LPMMTABLEENTRY lpmmEntry;
MMPATCH mmPatch;
UNALIGNED WORD *lpwKey;
MMAPERR mmaperr;
int i;
// open file, read in pertinent tables
mmaperr = MmaperrFileAccess(MAP_FOPEN,OF_READ);
if (mmaperr != MMAPERR_SUCCESS)
return mmaperr;
mmaperr = MmaperrReadTable(MMAP_PATCH | MMAP_KEY);
if (mmaperr != MMAPERR_SUCCESS) {
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return mmaperr;
}
lpmmEntry = LpGetTableEntry(hPatchTable, lszPatchMapName);
if (lpmmEntry == NULL) {
mmaperr = MMAPERR_INVALIDPATCH;
exit01: VFreeTable(MMAP_PATCH | MMAP_KEY);
goto exit00;
}
// read in patch data from file
if (_llseek(iFile, lpmmEntry->doData, 0) == -1L) {
mmaperr = MMAPERR_READ;
goto exit01;
}
if ( _lread(iFile, (LPSTR)&mmPatch, sizeof(MMPATCH))
!= sizeof(MMPATCH)
) {
mmaperr = MMAPERR_READ;
goto exit01;
}
// copy data from file structure to memory structure
lstrcpy(lpPatch->aszPatchMapName, (LPCSTR)(lpmmEntry->szName));
lstrcpy(lpPatch->aszPatchMapDescription, (LPCSTR)(lpmmEntry->szDesc));
// set up an optimization pointer
lpwKey = mmPatch.idxKMapNames;
for (i = 0; i < MIDIPATCHSIZE; i++, lpwKey++) {
lpPatch->keymaps[i].bVolume = HIBYTE(mmPatch.wPMap[i]);
lpPatch->keymaps[i].bDestination = LOBYTE(mmPatch.wPMap[i]);
if (!*lpwKey) {
lstrcpy(lpPatch->keymaps[i].aszKeyMapName, szNone);
continue;
}
lpmmEntry = LpGetTableEntry(hKeyTable, MAKEID(*lpwKey));
lstrcpy( lpPatch->keymaps[i].aszKeyMapName
, (LPCSTR)(lpmmEntry->szName));
}
// free table, close file and leave
VFreeTable(MMAP_PATCH | MMAP_KEY);
(VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return MMAPERR_SUCCESS;
}
// - - - - - - - - -
/* @doc INTERNAL
*
* @api DWORD | mapRead | Read a map specified by <p lpName> into a buffer
* specified by <p lpvBuf>. This includes any patchmaps or keymaps
* that the map may contain.
*
* @parm UINT | wFlag | Specifies the type of map to be read into memory.
* It may be any of the following:
*
* @flag MMAP_SETUP | Read a setup.
* @flag MMAP_PATCH | Read a patchmap.
* @flag MMAP_KEY | Read a keymap.
*
* @parm LPSTR | lpName | Specifies the name of the map of which you
* want read into memory.
*
* @rdesc Returns an MMAP error code, or zero on success.
*/
// Issues:
//
// 1. None.
MMAPERR FAR PASCAL mapRead(
UINT uFlag,
LPSTR lpName,
LPVOID lpvBuf)
{
switch (uFlag) {
DWORD dwRet;
case MMAP_SETUP:
return MmaperrReadSetup(lpName, (LPMIDIMAP)lpvBuf);
case MMAP_PATCH:
dwRet = DwReadPatchmap(lpName,(LPMIDIPATCHMAP)lpvBuf, FALSE);
if (dwRet < MMAPERR_MAXERROR)
return LOWORD(dwRet);
return MMAPERR_SUCCESS;
case MMAP_KEY:
return MmaperrReadKeymap(lpName, (LPMIDIKEYMAP)lpvBuf);
}
} /* mapRead */
// - - - - - - - - -
// MmaperrReadSetup
//
// Read a setup into a buffer. This includes any patchmaps or keymaps
// that the setup may contain.
//
// NOTE: This function will return MMAPERR_INVALIDPORT if the setup to
// be read accesses ports that are not available on the system. That is,
// if it accesses ports not listed as a 'midix=xxx.drv' entry under the
// [drivers] section in system.ini. The entire setup WILL BE read into
// memory but the uDeviceID for the channels with inaccessible ports will
// be set to MMAP_ID_NOPORT. This error also has NO EFFECT on the
// active/inactive status of any such channels.
//
// Issues:
//
// 1. There's a comment about something breaking a segment
// boundary in here, but if it does break the segment boundary
// the way it's dealt with it looks like it will wipe out.
//
// 2. Freeing the "hKeyList" chain may be unnecessary if the
// patch map read routine cleans up after itself properly.
STATIC MMAPERR NEAR PASCAL MmaperrReadSetup(
LPSTR lpName,
LPMIDIMAP lpmMap)
{
LPMIDICHANNELMAP lpChan;
LPMMCHANNEL lpmmChan;
LPMIDIPATCHMAP lpPatch;
LPMMTABLEENTRY lpmmEntry;
MMSETUP mmSetup;
MIDIOUTCAPS moCaps;
MMAPERR mmaperr;
DWORD dwOffset;
UINT wNumDevs;
BOOL fNoPort;
int i;
UINT wDev;
// open file, read in pertinent tables
mmaperr = MmaperrFileAccess(MAP_FOPEN, OF_READ);
if (mmaperr != MMAPERR_SUCCESS)
return mmaperr;
fNoPort = FALSE;
mmaperr = MmaperrReadTable(MMAP_SETUP | MMAP_PATCH | MMAP_KEY);
if (mmaperr != MMAPERR_SUCCESS) {
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return mmaperr;
}
dwOffset = sizeof(MIDIMAP);
lpmmEntry = LpGetTableEntry(hSetupTable, lpName);
if (lpmmEntry == NULL) {
mmaperr = MMAPERR_INVALIDSETUP;
exit01: VFreeTable(MMAP_SETUP | MMAP_PATCH | MMAP_KEY);
goto exit00;
}
// read in setup data from file
if (_llseek(iFile, lpmmEntry->doData, 0) == -1L) {
mmaperr = MMAPERR_READ;
goto exit01;
}
if (_lread(iFile, (LPSTR)&mmSetup, sizeof(MMSETUP)) != sizeof(MMSETUP)){
mmaperr = MMAPERR_READ;
goto exit01;
}
// copy over setup name, description, and flags
lstrcpy(lpmMap->szName, (LPCSTR)(lpmmEntry->szName));
lstrcpy(lpmMap->szDesc, (LPCSTR)(lpmmEntry->szDesc));
lpmMap->dwFlags = mmSetup.dwFlags;
// grab the number of devices in the current environment
wNumDevs = midiOutGetNumDevs();
// set up a couple of optimization-pointers
lpChan = lpmMap->chMap;
lpmmChan = (LPMMCHANNEL)(mmSetup.chMap); // MIPS silliness
for (i = 0; i < 16; i++, lpChan++, lpmmChan++) {
// convert device name to device ID. If device name doesn't
// exist in the current environment, set ID to MMAP_ID_NOPORT
if (!*lpmmChan->szDevice)
wDev = wNumDevs;
else
for (wDev = 0; wDev < wNumDevs; wDev++) {
midiOutGetDevCaps(wDev, &moCaps, sizeof(MIDIOUTCAPS));
if (!lstrcmpi(moCaps.szPname,
(LPCSTR)(lpmmChan->szDevice)))
break;
}
// copy over channel and flag info
lpChan->wChannel = lpmmChan->wChannel;
lpChan->dwFlags = lpmmChan->dwFlags;
if (wDev < wNumDevs)
lpChan->wDeviceID = (WORD)wDev;
else {
lpChan->wDeviceID = MMAP_ID_NOPORT;
// this error code only if there was a port
// name but it does not exist on the current system.
if (*lpmmChan->szDevice)
fNoPort = TRUE;
}
// if channel has no patchmap then on to next channel
if (!lpmmChan->idxPMapName)
continue;
// channel has a patchmap - if its not unique, point offset
// to first occurance, otherwise offset = dwOffset.
// assuming this patchmap ID is valid!
lpmmEntry = LpGetTableEntry(hPatchTable,
MAKEID(lpmmChan->idxPMapName));
lpChan->oPMap = LiNotUnique( (LPSTR)(lpmmEntry->szName)
, &hPatchList
, dwOffset
);
if (lpChan->oPMap == -1L) {
mmaperr = MMAPERR_MEMORY;
exit02: VFreeUniqueList(&hPatchList);
VFreeUniqueList(&hKeyList);
goto exit01;
} else if (!lpChan->oPMap) {
DWORD dwRet;
lpChan->oPMap = dwOffset;
// setup patchmap pointer; could break segment bounds
lpPatch = (LPMIDIPATCHMAP)((LPSTR)lpmMap + dwOffset);
// read in patchmap (this also updates global offset)
dwRet = DwReadPatchmap(0L, lpPatch, TRUE);
if (dwRet < MMAPERR_MAXERROR) {
mmaperr = LOWORD(dwRet);
goto exit02;
}
dwOffset += dwRet;
}
}
VFreeUniqueList(&hPatchList);
VFreeUniqueList(&hKeyList);
VFreeTable(MMAP_SETUP | MMAP_PATCH | MMAP_KEY);
(VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
if (fNoPort)
return MMAPERR_INVALIDPORT;
return MMAPERR_SUCCESS;
} /* MmaperrReadSetup */
// - - - - - - - - -
// DwReadPatchmap
//
// Read a patchmap into a buffer. This includes any keymaps the patchmap
// may contain.
//
// Remarks:
//
// 1. Use of "fInSetup" flag is very bogus, may cause problems, is
// probably wrong.
STATIC DWORD NEAR PASCAL DwReadPatchmap(
LPSTR lpName,
LPMIDIPATCHMAP lpPatch,
BOOL fInSetup)
{
LPMMTABLEENTRY lpmmEntry;
LPMIDIKEYMAP lpKey;
MMPATCH mmPatch;
UNALIGNED WORD *lpwKey;
MMAPERR mmaperr;
DWORD dwOffset;
int i;
// open file, read in pertinent tables
mmaperr = MmaperrFileAccess(MAP_FOPEN,OF_READ);
if (mmaperr != MMAPERR_SUCCESS)
return MAKELONG(mmaperr, 0);
mmaperr = MmaperrReadTable(MMAP_PATCH |MMAP_KEY);
if (mmaperr != MMAPERR_SUCCESS) {
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return MAKELONG(mmaperr, 0);
}
// save global offset then initialize it to patch size
dwOffset = sizeof(MIDIPATCHMAP);
lpmmEntry = LpGetTableEntry(hPatchTable, lpName);
if (lpmmEntry == NULL) {
mmaperr = MMAPERR_INVALIDPATCH;
exit01: VFreeTable(MMAP_PATCH | MMAP_KEY);
goto exit00;
}
// read in patch data from file
if (_llseek(iFile, lpmmEntry->doData, 0) == -1L) {
mmaperr = MMAPERR_READ;
goto exit01;
}
if (_lread(iFile, (LPSTR)&mmPatch,sizeof(MMPATCH)) != sizeof(MMPATCH)) {
mmaperr = MMAPERR_READ;
goto exit01;
}
// copy data from file structure to memory structure
lstrcpy(lpPatch->szName, (LPCSTR)(lpmmEntry->szName));
lstrcpy(lpPatch->szDesc, (LPCSTR)(lpmmEntry->szDesc));
_fmemcpy((LPSTR)lpPatch->wPMap, (LPSTR)mmPatch.wPMap, MIDIPATCHSIZE * sizeof(WORD));
_fmemset((LPSTR)lpPatch->okMaps, 0, MIDIPATCHSIZE * sizeof(DWORD));
lpPatch->dwFlags = mmPatch.dwFlags;
lpPatch->bVMax = mmPatch.bVMax;
// set up an optimization pointer
lpwKey = mmPatch.idxKMapNames;
for (i = 0; i < MIDIPATCHSIZE; i++, lpwKey++) {
// if no keymap for this patch then continue
if (!*lpwKey)
continue;
// patch has a keymap - if its unique point offset to
// to first occurance, otherwise offset = dwOffset.
// assuming this keymap ID is valid!
lpmmEntry = LpGetTableEntry(hKeyTable, MAKEID(*lpwKey));
lpPatch->okMaps[i] = LiNotUnique( (LPSTR)(lpmmEntry->szName)
, &hKeyList, dwOffset);
if (lpPatch->okMaps[i] == -1L) {
mmaperr = MMAPERR_MEMORY;
goto exit01;
} else if (!lpPatch->okMaps[i]) {
lpPatch->okMaps[i] = dwOffset;
// set the keymap pointer; could break segment bounds
lpKey = (LPMIDIKEYMAP)((LPSTR)lpPatch + dwOffset);
// read in the keymap, update global offset
mmaperr = MmaperrReadKeymap(0L, lpKey);
if (mmaperr != MMAPERR_SUCCESS) {
VFreeUniqueList(&hKeyList);
goto exit01;
}
dwOffset += sizeof(MIDIKEYMAP);
}
}
if (!fInSetup) {
// if we're not called from ReadSetup, free the unique
// keymap name list.
VFreeUniqueList(&hKeyList);
}
// free table, close file and leave
VFreeTable(MMAP_PATCH | MMAP_KEY);
(VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return dwOffset;
} /* DwReadPatchmap */
// - - - - - - - - -
// MmaperrReadKeymap
//
// Read a keymap into a buffer.
//
// Remarks:
//
// 1. None.
STATIC MMAPERR NEAR PASCAL MmaperrReadKeymap(
LPSTR lpName,
LPMIDIKEYMAP lpKey)
{
LPMMTABLEENTRY lpmmEntry;
MMKEY mmKey;
MMAPERR mmaperr;
// open file, read in pertinent tables
mmaperr = MmaperrFileAccess(MAP_FOPEN, OF_READ);
if (mmaperr != MMAPERR_SUCCESS)
return mmaperr;
mmaperr = MmaperrReadTable(MMAP_KEY);
if (mmaperr != MMAPERR_SUCCESS) {
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return mmaperr;
}
// assuming keymap exists
lpmmEntry = LpGetTableEntry(hKeyTable, lpName);
// read in key data from file
if (_llseek(iFile, lpmmEntry->doData, 0) == -1L) {
mmaperr = MMAPERR_READ;
exit01: VFreeTable(MMAP_KEY);
goto exit00;
}
if (_lread(iFile, (LPSTR)&mmKey, sizeof(mmKey)) != sizeof(mmKey)) {
mmaperr = MMAPERR_READ;
goto exit01;
}
// copy data from file structure to memory structure
lstrcpy(lpKey->szName, (LPCSTR)(lpmmEntry->szName));
lstrcpy(lpKey->szDesc, (LPCSTR)(lpmmEntry->szDesc));
_fmemcpy(lpKey->bKMap, (LPCSTR)(mmKey.bKMap), MIDIPATCHSIZE * sizeof(BYTE));
lpKey->dwFlags = mmKey.dwFlags;
// free table, close file and leave
VFreeTable(MMAP_KEY);
(VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return MMAPERR_SUCCESS;
} /* MmaperrReadKeymap */
// - - - - - - - - -
/* @doc INTERNAL
*
* @api DWORD | mapWrite | Write a map specified by <p lpvMap> to the
* midi data file.
*
* @parm UINT | uFlag | Specifies the type of map to write.
* It may be any of the following:
*
* @flag MMAP_SETUP | Write a setup.
* @flag MMAP_PATCH | Write a patchmap.
* @flag MMAP_KEY | Write a keymap.
*
* @parm LPVOID | lpvMap | Specifies the map to write to the midi data file.
*
* @rdesc Returns non-zero if it could do the write, zero if it failed.
*/
// Remarks:
//
// 1. None.
MMAPERR FAR PASCAL mapWrite(
UINT uFlag,
LPVOID lpvMap)
{
switch (uFlag) {
case MMAP_SETUP :
return MmaperrWriteSetup((SETUP FAR*)lpvMap);
case MMAP_PATCH :
return MmaperrWritePatchmap((PATCHMAP FAR*)lpvMap);
case MMAP_KEY :
return MmaperrWriteKeymap((LPMIDIKEYMAP)lpvMap);
}
} /* mapWrite */
// - - - - - - - - -
// MmaperrWriteSetup
//
// Write a setup to the midi data file.
STATIC MMAPERR NEAR PASCAL MmaperrWriteSetup(SETUP FAR* lpSetup)
{
HANDLE hPatchUsage;
LPMMTABLE lpmmTable;
LPMMTABLEENTRY lpmmEntry;
LPMMCHANNEL lpmmChan;
LPBYTE lpbPatchUsage = NULL; // Kill spurious use before set diagnostic
MMSETUP mmOldSetup;
MMSETUP mmSetup;
MIDIOUTCAPS moCaps;
MMAPERR mmaperr;
DWORD doData;
UINT wNumDevs;
UINT wOldDevs;
UINT uSize;
BOOL fExists;
UINT uIndex;
UINT wDev;
// open file, read in pertinent tables
mmaperr = MmaperrFileAccess(MAP_FOPEN, OF_READWRITE);
if (mmaperr != MMAPERR_SUCCESS)
return mmaperr;
mmaperr = MmaperrReadTable(MMAP_SETUP | MMAP_PATCH);
if (mmaperr != MMAPERR_SUCCESS) {
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return mmaperr;
}
// check to see if setup name already exists
fExists = FALSE;
lpmmEntry = LpGetTableEntry(hSetupTable, lpSetup->aszSetupName);
if (lpmmEntry != NULL) {
// setup name exists. if the description has changed, we
// have to re-write the table entry with new description
if (lstrcmpi((LPCSTR)(lpmmEntry->szDesc)
, lpSetup->aszSetupDescription)) {
lstrcpy( (LPSTR)(lpmmEntry->szDesc)
, lpSetup->aszSetupDescription);
mmaperr = MmaperrWriteTabEntry(MMAP_SETUP, 0, lpmmEntry);
if (mmaperr != MMAPERR_SUCCESS) {
exit01: VFreeTable(MMAP_SETUP | MMAP_PATCH);
goto exit00;
}
}
doData = lpmmEntry->doData;
fExists = TRUE;
}
// name non-existent, so add a new table entry
else if ((mmaperr = MmaperrAddMap(MMAP_SETUP, (LPVOID)lpSetup, &doData))
!= MMAPERR_SUCCESS
)
goto exit01;
// zero-out the new setup data structure
_fmemset((LPSTR)&mmSetup, 0, sizeof(MMSETUP));
// obtain the number of entrys in the patch table
lpmmTable = (LPMMTABLE)GlobalLock(hPatchTable);
uSize = lpmmTable->mmHeader.wEntrys;
GlobalUnlock(hPatchTable);
// if there are any patchmaps
hPatchUsage = NULL;
if (uSize) {
// Create table which is 'number-of-patchmaps' in length
hPatchUsage = GlobalAlloc(GHND, (LONG)uSize);
if (hPatchUsage == NULL) {
mmaperr = MMAPERR_MEMORY;
goto exit01;
}
lpbPatchUsage = (LPBYTE)GlobalLock(hPatchUsage);
// if this is not a new map
if (fExists) {
// read in old setup data from file
if (_llseek(iFile, doData, 0) == -1L) {
mmaperr = MMAPERR_READ;
exit02: if (hPatchUsage != NULL) {
GlobalUnlock(hPatchUsage);
GlobalFree(hPatchUsage);
}
goto exit01;
}
if ( _lread(iFile, (LPSTR)&mmOldSetup,sizeof(MMSETUP))
!= sizeof(MMSETUP)
) {
mmaperr = MMAPERR_READ;
goto exit02;
}
// set LSB of usage table indices where old setup
// referenced any respective patchmaps
for (uIndex = 0; uIndex < 16; uIndex++)
{
UINT u;
u = mmOldSetup.chMap[uIndex].idxPMapName;
if (u)
lpbPatchUsage[u - 1] = LSB;
}
}
}
// get the number of devices
wNumDevs = wOldDevs = midiOutGetNumDevs();
// enumerate any invalid ports from old setup this is not a new map
if (fExists) {
uIndex = 0;
lpmmChan = (LPMMCHANNEL)(mmOldSetup.chMap); // MIPS silliness
} else {
uIndex = 16;
lpmmChan = 0; // wasn't set. LKG
}
for (; uIndex < 16; uIndex++, lpmmChan++) {
// find out if the port is in the current environment
wDev = *lpmmChan->szDevice ? 0 : wNumDevs;
for (; wDev < wNumDevs; wDev++) {
midiOutGetDevCaps(wDev, &moCaps, sizeof(MIDIOUTCAPS));
if (!lstrcmpi(moCaps.szPname, (LPCSTR)(lpmmChan->szDevice)))
break;
}
// if not, add the unique port name to the invalid port list
if (wDev == wNumDevs) {
DWORD dwUniqueRet;
// unique-list entry will save this offset
dwUniqueRet = LiNotUnique( (LPSTR)(lpmmChan->szDevice)
, &hPortList
, (DWORD)wOldDevs);
if (dwUniqueRet == -1L) {
mmaperr = MMAPERR_MEMORY;
exit03: VFreeUniqueList(&hPortList);
goto exit02;
} else if (!dwUniqueRet)
wOldDevs++;
}
}
// copy over the data for each channel
lpmmChan = (LPMMCHANNEL)(mmSetup.chMap); // MIPS silliness
for (uIndex = 0; uIndex < 16; uIndex++, lpmmChan++) {
// convert the device ID to a device name.
if (lpSetup->channels[uIndex].wDeviceID == MMAP_ID_NOPORT)
*lpmmChan->szDevice = 0;
else if (lpSetup->channels[uIndex].wDeviceID >= wNumDevs)
lstrcpy( (LPSTR)(lpmmChan->szDevice)
, LszGetUniqueAtOffset( (DWORD)lpSetup->channels[uIndex].wDeviceID
, hPortList
)
);
else {
midiOutGetDevCaps( lpSetup->channels[uIndex].wDeviceID
, &moCaps
, sizeof(MIDIOUTCAPS)
);
lstrcpy((LPSTR)(lpmmChan->szDevice), moCaps.szPname);
}
// copy over channel number and flags.
lpmmChan->wChannel = lpSetup->channels[uIndex].wChannel;
lpmmChan->dwFlags = lpSetup->channels[uIndex].dFlags;
if (lpmmChan->dwFlags & MMAP_PATCHMAP) {
// do I want a uniqueness-check in here?
// get the table entry
lpmmEntry = LpGetTableEntry(hPatchTable,
lpSetup->channels[uIndex].aszPatchName);
// set patch name table entry index
lpmmChan->idxPMapName = lpmmEntry->idxEntry;
// set MSB at current table index where
// this setup references a patchmap
if (uSize)
lpbPatchUsage[lpmmChan->idxPMapName - 1] |= MSB;
}
// not needed if MMAP_PATCHMAP isn't there, seems clean though
else
lpmmChan->idxPMapName = 0;
}
// if there are any patchmaps
if (uSize) {
// Check for differences in patchmap referencing. Compare
// what patchmaps are now being used to what patchmaps were
// being used before. Change the using count accordingly.
for (uIndex = 0; uIndex < uSize; uIndex++, lpbPatchUsage++)
if ((*lpbPatchUsage & MSB) &&
(!(*lpbPatchUsage & LSB))) {
mmaperr = MmaperrChangeUsing(MMAP_PATCH,uIndex + 1, 1);
if (mmaperr != MMAPERR_SUCCESS)
goto exit03;
} else if (! (*lpbPatchUsage & MSB)
&& (*lpbPatchUsage & LSB)
)
mmaperr = MmaperrChangeUsing(MMAP_PATCH,uIndex + 1, -1);
if (mmaperr != MMAPERR_SUCCESS)
goto exit03;
// nuke the usage table
GlobalUnlock(hPatchUsage);
GlobalFree(hPatchUsage);
hPatchUsage = NULL;
}
// copy over the setup flags.
mmSetup.dwFlags = lpSetup->dFlags;
// write the setup
if (_llseek(iFile, doData, 0) == -1L) {
mmaperr = MMAPERR_WRITE;
goto exit03;
}
if ( _lwrite(iFile, (LPSTR)&mmSetup, sizeof(MMSETUP))
!= sizeof(MMSETUP)
) {
mmaperr = MMAPERR_WRITE;
goto exit03;
}
// free the unique invalid port name list
VFreeUniqueList(&hPortList);
// free tables, close file and leave
VFreeTable(MMAP_SETUP | MMAP_PATCH);
mmaperr = MmaperrFileAccess(MAP_FCLOSE, 0);
if (mmaperr != MMAPERR_SUCCESS)
return mmaperr;
return MMAPERR_SUCCESS;
} /* MmaperrWriteSetup */
// - - - - - - - - -
// MmaperrWritePatchmap
//
// Write a patchmap to the midi data file.
STATIC MMAPERR NEAR PASCAL MmaperrWritePatchmap(
PATCHMAP FAR* lpPatch)
{
KEYMAP FAR* keymap;
HANDLE hKeyUsage;
LPMMTABLE lpmmTable;
LPMMTABLEENTRY lpmmEntry;
MMPATCH mmOldPatch;
MMPATCH mmPatch;
UNALIGNED WORD *lpidxNames;
LPBYTE lpbKeyUsage = NULL; // Kill spurious use before set diagnostic
DWORD doData;
DWORD dwOffset;
UINT uSize = 0;
BOOL fExists = FALSE;
MMAPERR mmaperr;
UINT uIndex;
// open file, read in pertinent tables
mmaperr = MmaperrFileAccess(MAP_FOPEN, OF_READWRITE);
if (mmaperr != MMAPERR_SUCCESS)
return mmaperr;
mmaperr = MmaperrReadTable(MMAP_PATCH | MMAP_KEY);
if (mmaperr != MMAPERR_SUCCESS) {
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return mmaperr;
}
// check to see if patch name already exists
lpmmEntry = LpGetTableEntry(hPatchTable, lpPatch->aszPatchMapName);
if (lpmmEntry != NULL) {
// patch name exists. if the description has changed, we
// have to re-write the table entry with new description
if (lstrcmpi( (LPSTR)(lpmmEntry->szDesc)
, lpPatch->aszPatchMapDescription)) {
lstrcpy( (LPSTR)(lpmmEntry->szDesc)
, lpPatch->aszPatchMapDescription);
mmaperr = MmaperrWriteTabEntry(MMAP_PATCH, 0, lpmmEntry);
if (mmaperr != MMAPERR_SUCCESS) {
exit01: VFreeTable(MMAP_PATCH | MMAP_KEY);
goto exit00;
}
}
doData = lpmmEntry->doData;
fExists = TRUE;
}
// name is non-existent, so add a new table entry
else {
mmaperr = MmaperrAddMap(MMAP_PATCH,lpPatch, &doData);
if (mmaperr != MMAPERR_SUCCESS)
goto exit01;
}
// zero-out the patch data structure.
_fmemset((LPSTR)&mmPatch, 0, sizeof(MMPATCH));
// obtain the number of entrys in the key table
lpmmTable = (LPMMTABLE)GlobalLock(hKeyTable);
uSize = lpmmTable->mmHeader.wEntrys;
GlobalUnlock(hKeyTable);
// Create table which is 'number-of-keymaps' in length
hKeyUsage = NULL;
if (uSize) {
hKeyUsage = GlobalAlloc(GHND, (LONG)uSize);
if (hKeyUsage == NULL) {
mmaperr = MMAPERR_MEMORY;
goto exit01;
}
lpbKeyUsage = (LPBYTE)GlobalLock(hKeyUsage);
}
// if not a new patchmap, we need old usage count
if (fExists) {
// read in old patch data from file
if (_llseek(iFile, doData, 0) == -1L) {
mmaperr = MMAPERR_READ;
exit02: if (hKeyUsage != NULL) {
GlobalUnlock(hKeyUsage);
GlobalFree(hKeyUsage);
}
goto exit01;
}
if ( _lread(iFile, (LPSTR)&mmOldPatch, sizeof(MMPATCH))
!= sizeof(MMPATCH)
) {
mmaperr = MMAPERR_READ;
goto exit02;
}
mmPatch.wUsing = mmOldPatch.wUsing;
// if there are keymaps and map is not new, set LSB
// of usage table indices where old patchmap referenced
// any respective keymaps
if (uSize) {
lpidxNames = mmOldPatch.idxKMapNames;
for (uIndex = 0; uIndex < MIDIPATCHSIZE; uIndex++, lpidxNames++)
if (*lpidxNames)
lpbKeyUsage[*lpidxNames - 1] = LSB;
}
}
dwOffset = sizeof(MIDIPATCHMAP);
// set max volume scalar to minimum value
mmPatch.bVMax = 1;
// copy over data for each patch entry
keymap = lpPatch->keymaps;
lpidxNames = mmPatch.idxKMapNames;
for (uIndex = 0; uIndex < MIDIPATCHSIZE; uIndex++, keymap++, lpidxNames++) {
DWORD dwUniqueRet;
mmPatch.wPMap[uIndex] = ((WORD)keymap->bVolume << 8) | keymap->bDestination;
// if the current volume is greater than the max volume
// then set max volume to it
if (keymap->bVolume > mmPatch.bVMax)
mmPatch.bVMax = keymap->bVolume;
// if patch has no keymap, zero out keymap table entry
// index in file data structure and continue
if (!lstrcmpi(keymap->aszKeyMapName, szNone)) {
*lpidxNames = 0;
continue;
}
// get the table entry
lpmmEntry = LpGetTableEntry(hKeyTable, keymap->aszKeyMapName);
// set keymap table entry index in file data structure
*lpidxNames = lpmmEntry->idxEntry;
// if keymap is unique, add size to global offset
dwUniqueRet = LiNotUnique(keymap->aszKeyMapName, &hKeyList, dwOffset);
if (dwUniqueRet == -1L) {
mmaperr = MMAPERR_MEMORY;
exit03: VFreeUniqueList(&hKeyList);
goto exit02;
} else if (!dwUniqueRet) {
DWORD dwSize;
dwSize = DwGetMapSize(MMAP_KEY,keymap->aszKeyMapName);
if (dwSize < MMAPERR_MAXERROR) {
mmaperr = LOWORD(dwSize);
goto exit03;
}
dwOffset += dwSize;
// set MSB at current usage table index where
// this patchmap references a keymap
if (uSize)
lpbKeyUsage[*lpidxNames - 1] |= MSB;
}
}
// if there are any keymaps
if (uSize) {
// Check for differences in keymap referencing. Compare
// what keymaps are now being used to what keymaps were being
// used before. Change the using count accordingly.
for (uIndex = 0; uIndex < uSize; uIndex++, lpbKeyUsage++)
if ((*lpbKeyUsage & MSB) && (!(*lpbKeyUsage & LSB))) {
mmaperr = MmaperrChangeUsing(MMAP_KEY,uIndex + 1, 1);
if (mmaperr != MMAPERR_SUCCESS)
goto exit03;
} else if (! (*lpbKeyUsage & MSB) &&
(*lpbKeyUsage & LSB))
mmaperr = MmaperrChangeUsing(MMAP_KEY, uIndex + 1, -1);
if (mmaperr != MMAPERR_SUCCESS)
goto exit03;
// nuke the usage table
GlobalUnlock(hKeyUsage);
GlobalFree(hKeyUsage);
hKeyUsage = NULL;
}
// set patch size to global offset.
mmPatch.dwSize = dwOffset;
// write the patchmap
if (_llseek(iFile, doData, 0) == -1L) {
mmaperr = MMAPERR_WRITE;
goto exit03;
}
if ( _lwrite(iFile, (LPSTR)&mmPatch,sizeof(MMPATCH))
!= sizeof(MMPATCH)
) {
mmaperr = MMAPERR_WRITE;
goto exit03;
}
// free the unique keymap name list
VFreeUniqueList(&hKeyList);
// free tables, close file and leave
VFreeTable(MMAP_PATCH | MMAP_KEY);
mmaperr = MmaperrFileAccess(MAP_FCLOSE, 0);
if (mmaperr != MMAPERR_SUCCESS)
return mmaperr;
return MMAPERR_SUCCESS;
} /* MmaperrWritePatchmap */
// - - - - - - - - -
// MmaperrWriteKeymap
//
// Write a keymap to the midi data file.
//
// 1. If this routine fails it will corrupt the database.
STATIC MMAPERR NEAR PASCAL MmaperrWriteKeymap (LPMIDIKEYMAP lpKey)
{
LPMMTABLEENTRY lpmmEntry;
MMKEY mmOldKey;
MMKEY mmKey;
MMAPERR mmaperr;
DWORD doData;
BOOL fExists;
mmaperr = MmaperrFileAccess(MAP_FOPEN, OF_READWRITE);
if (mmaperr != MMAPERR_SUCCESS)
return mmaperr;
mmaperr = MmaperrReadTable(MMAP_KEY);
if (mmaperr != MMAPERR_SUCCESS) {
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return mmaperr;
}
lpmmEntry = LpGetTableEntry(hKeyTable, lpKey->szName);
if (lpmmEntry != NULL) {
if (lstrcmpi((LPSTR)(lpmmEntry->szDesc), lpKey->szDesc)) {
lstrcpy((LPSTR)(lpmmEntry->szDesc), lpKey->szDesc);
mmaperr = MmaperrWriteTabEntry(MMAP_KEY, 0, lpmmEntry);
if (mmaperr != MMAPERR_SUCCESS) {
exit01: VFreeTable(MMAP_KEY);
goto exit00;
}
}
doData = lpmmEntry->doData;
fExists = TRUE;
} else {
mmaperr = MmaperrAddMap(MMAP_KEY, (LPVOID)lpKey, &doData);
if (mmaperr != MMAPERR_SUCCESS)
goto exit01;
mmKey.wUsing = 0;
fExists = FALSE;
}
// zero-out the keymap data structure
_fmemset((LPSTR)&mmKey, 0, sizeof(MMKEY));
// if not a new keymap, get old usage count
if (fExists) {
if ( _llseek(iFile, doData, 0) == -1L) {
mmaperr = MMAPERR_READ;
goto exit01;
}
if ( _lread(iFile, (LPSTR)&mmOldKey, sizeof(MMKEY))
!= sizeof(MMKEY)
) {
mmaperr = MMAPERR_READ;
goto exit01;
}
mmKey.wUsing = mmOldKey.wUsing;
}
// copy over flags and keymap data
mmKey.dwFlags = lpKey->dwFlags;
_fmemcpy( (LPSTR)(mmKey.bKMap)
, lpKey->bKMap
, MIDIPATCHSIZE * sizeof(BYTE));
if (_llseek(iFile, doData, 0) == -1L) {
mmaperr = MMAPERR_WRITE;
goto exit01;
}
if (_lwrite(iFile, (LPSTR)&mmKey, sizeof(MMKEY)) != sizeof(MMKEY)) {
mmaperr = MMAPERR_WRITE;
goto exit01;
}
VFreeTable(MMAP_KEY);
mmaperr = MmaperrFileAccess(MAP_FCLOSE, 0);
if (mmaperr != MMAPERR_SUCCESS)
return mmaperr;
return MMAPERR_SUCCESS;
} /* MmaperrWriteKeymap */
// - - - - - - - - -
// MmaperrAddMap
//
// Generic add map routine.
// Add a map table entry, increment table use count.
//
// Issues:
//
// 1. None.
STATIC MMAPERR NEAR PASCAL MmaperrAddMap(
UINT uFlag,
LPVOID lpvMap,
LPDWORD lpdoData)
{
HANDLE hTable;
LPMMTABLE lpmmTable;
LPMMTABLEENTRY lpmmEntry;
LPSTR lpName;
LPSTR lpDesc;
MMTABLEENTRY mmEntry;
MMAPERR mmaperr;
DWORD doData;
WORD wEntry;
WORD wEntrys;
switch (uFlag) {
case MMAP_SETUP :
hTable = hSetupTable;
lpName = ((SETUP FAR*)lpvMap)->aszSetupName;
lpDesc = ((SETUP FAR*)lpvMap)->aszSetupDescription;
break;
case MMAP_PATCH :
hTable = hPatchTable;
lpName = ((PATCHMAP FAR*)lpvMap)->aszPatchMapName;
lpDesc = ((PATCHMAP FAR*)lpvMap)->aszPatchMapDescription;
break;
case MMAP_KEY :
hTable = hKeyTable;
lpName = ((LPMIDIKEYMAP)lpvMap)->szName;
lpDesc = ((LPMIDIKEYMAP)lpvMap)->szDesc;
break;
default:lpDesc = NULL; // Kill spurious use before set diagnostic
lpName = NULL; // Kill spurious use before set diagnostic
hTable = NULL; // Kill spurious use before set diagnostic
}
lpmmTable = (LPMMTABLE)GlobalLock(hTable);
wEntrys = lpmmTable->mmHeader.wEntrys;
lpmmEntry = (LPMMTABLEENTRY)GlobalLock(lpmmTable->hEntrys);
for (wEntry = 0; wEntry < wEntrys; wEntry++, lpmmEntry++)
if (!*lpmmEntry->szName)
break;
GlobalUnlock(lpmmTable->hEntrys);
if (wEntry == wEntrys) {
// Filled table;
mmaperr = MMAPERR_FULL;
goto exit00;
}
_fmemset(&mmEntry, 0, sizeof(MMTABLEENTRY));
lstrcpy((LPSTR)(mmEntry.szName), lpName);
lstrcpy((LPSTR)(mmEntry.szDesc), lpDesc);
mmEntry.idxEntry = wEntry + 1;
doData = mmEntry.doData = _llseek(iFile, 0L, 2);
if (doData == -1L) {
mmaperr = MMAPERR_WRITE;
exit00: GlobalUnlock(hTable);
return mmaperr;
}
mmaperr = MmaperrWriteTabEntry(uFlag, 0, &mmEntry);
if (mmaperr != MMAPERR_SUCCESS)
goto exit00;
lpmmTable->mmHeader.wUsed++;
mmaperr = MmaperrWriteTabHeader( uFlag
, (LPMMTABLEHEADER)(&lpmmTable->mmHeader));
if (mmaperr != MMAPERR_SUCCESS)
goto exit00;
GlobalUnlock(hTable);
*lpdoData = doData;
return MMAPERR_SUCCESS;
} /* MmaperrAddMap */
// - - - - - - - - -
/*
* @doc INTERNAL
*
* @api DWORD | mapGetSize | This function retrieves the size in bytes
* that will be required to read an entire map into memory. This
* includes the size of any patchmaps and keymaps that the map may
* contain.
*
* @parm UINT | uFlag | Specifies the type of map of which to get the size.
* It may be any of the following:
*
* @flag MMAP_SETUP | Get the size of a setup.
* @flag MMAP_PATCH | Get the size of a patchmap.
* @flag MMAP_KEY | Get the size of a keymap.
*
* @parm LPSTR | lpName | Specifies the name of the map of which you
* want to get the size.
*
* @rdesc An MMAP error code, or the size in bytes required to read in the
* map specified by <p lpName>. If the return value is greater than
* MMAPERR_MAXERROR then the return value is a size and not an error.
*/
//
// This function returns either an error code or the size of the thing.
// The way you tell the difference is to guess. The best way to guess
// is to compare the return value against MMAPERR_MAXERROR, and if it is
// greater than or equal to that value you've got a size, not an error.
//
// Issues:
//
// 1. None.
DWORD FAR PASCAL mapGetSize(
UINT uFlag,
LPSTR lpName)
{
switch (uFlag) {
case MMAP_SETUP :
return DwGetSetupSize(lpName);
case MMAP_PATCH :
case MMAP_KEY :
return DwGetMapSize(uFlag, lpName);
}
} /* mapGetSize */
// - - - - - - - - -
// DwGetSetupSize
//
// Get the size of a setup.
//
// This function returns either an error code or the size of the thing.
// The way you tell the difference is to guess. The best way to guess
// is to compare the return value against MMAPERR_MAXERROR, and if it is
// greater than or equal to that value you've got a size, not an error.
//
// Issues:
//
// 1. None.
STATIC DWORD NEAR PASCAL DwGetSetupSize(
LPSTR lpName)
{
LPMMTABLEENTRY lpmmEntry;
LPMMCHANNEL lpmmChan;
MMAPERR mmaperr;
MMSETUP mmSetup;
DWORD dwRet;
DWORD dwOffset;
int i;
mmaperr = MmaperrFileAccess(MAP_FOPEN,OF_READ);
if (mmaperr != MMAPERR_SUCCESS)
return (DWORD)mmaperr;
mmaperr = MmaperrReadTable(MMAP_SETUP | MMAP_PATCH);
if (mmaperr != MMAPERR_SUCCESS) {
dwRet = (DWORD)mmaperr;
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return dwRet;
}
// if name isn't in the file, get outta here
lpmmEntry = LpGetTableEntry(hSetupTable, lpName);
if (lpmmEntry == NULL) {
dwRet = (DWORD)MMAPERR_INVALIDSETUP;
exit01: VFreeTable(MMAP_SETUP | MMAP_PATCH);
goto exit00;
}
// intialize offset
dwOffset = sizeof(MIDIMAP);
// read in the setup data
if (_llseek(iFile, lpmmEntry->doData, 0) == -1L) {
dwRet = (DWORD)MMAPERR_READ;
goto exit01;
}
if (_lread(iFile, (LPSTR)&mmSetup,
sizeof(MMSETUP)) != sizeof(MMSETUP)) {
dwRet = (DWORD)MMAPERR_READ;
goto exit01;
}
lpmmChan = (LPMMCHANNEL)(mmSetup.chMap); // MIPS silliness
for (i = 0; i < 16; i++, lpmmChan++) {
DWORD dwUniqueRet;
// if no patchmap then continue
if (!lpmmChan->idxPMapName)
continue;
// assuming patchmap actually exists here
lpmmEntry = LpGetTableEntry(hPatchTable,
MAKEID(lpmmChan->idxPMapName));
// if patchmap is unique, add size to global offset
dwUniqueRet = LiNotUnique( (LPSTR)(lpmmEntry->szName)
, &hPatchList
, dwOffset);
if (dwUniqueRet == -1L) {
dwRet = (DWORD)MMAPERR_MEMORY;
goto exit01;
} else if (!dwUniqueRet) {
dwRet = DwGetMapSize(MMAP_PATCH,NULL);
if (dwRet < MMAPERR_MAXERROR) {
VFreeUniqueList(&hPatchList);
goto exit01;
}
dwOffset += dwRet;
}
}
// free the unique patchmap list
VFreeUniqueList(&hPatchList);
VFreeTable(MMAP_SETUP | MMAP_PATCH);
(VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return (dwOffset < (DWORD)MMAPERR_MAXERROR) ? (DWORD)MMAPERR_INVALIDSETUP : dwOffset;
} /* DwGetSetupSize */
// - - - - - - - - -
// DwGetMapSize
//
// Get the size of a patchmap or keymap.
//
// This function returns either an error code or the size of the thing.
// The way you tell the difference is to guess. The best way to guess
// is to compare the return value against MMAPERR_MAXERROR, and if it is
// greater than or equal to that value you've got a size, not an error.
//
// Remarks:
//
// 1. None.
STATIC DWORD NEAR PASCAL DwGetMapSize(
UINT uFlag,
LPSTR lpName)
{
LPMMTABLEENTRY lpmmEntry;
LPHANDLE lphTable;
MMPATCH mmPatch;
MMAPERR mmaperr;
DWORD dwRet;
mmaperr = MmaperrFileAccess(MAP_FOPEN, OF_READ);
if (mmaperr != MMAPERR_SUCCESS)
return (DWORD)mmaperr;
mmaperr = MmaperrReadTable(uFlag);
if (mmaperr != MMAPERR_SUCCESS) {
dwRet = (DWORD)mmaperr;
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return dwRet;
}
lphTable = (uFlag == MMAP_PATCH) ? &hPatchTable : &hKeyTable;
lpmmEntry = LpGetTableEntry(*lphTable, lpName);
if (lpmmEntry == NULL) {
dwRet = (uFlag == MMAP_PATCH)
? (DWORD)MMAPERR_INVALIDPATCH
: (DWORD)MMAPERR_INVALIDKEY;
VFreeTable(uFlag);
goto exit00;
}
switch (uFlag) {
case MMAP_PATCH :
// patchmaps have the size stored in the file.
if (_llseek(iFile, lpmmEntry->doData, 0) == -1L) {
dwRet = (DWORD)MMAPERR_READ;
break;
}
if ( _lread(iFile, (LPSTR)&mmPatch, sizeof(MMPATCH))
!= sizeof(MMPATCH)
) {
dwRet = (DWORD)MMAPERR_READ;
break;
}
dwRet = mmPatch.dwSize;
if (dwRet < (DWORD)MMAPERR_MAXERROR)
dwRet = MMAPERR_INVALIDPATCH;
break;
case MMAP_KEY:
// keymaps are all the same size.
dwRet = sizeof(MIDIKEYMAP);
break;
default: dwRet = (DWORD)MMAPERR_READ;
}
VFreeTable(uFlag);
(VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return dwRet;
} /* DwGetMapSize */
// - - - - - - - - -
/*
* @doc INTERNAL
*
* @api DWORD | mapDelete | This function deletes a map from the midi
* data file.
*
* @parm UINT | uFlag | Specifies the type of map to be deleted.
* It may be any of the following:
*
* @flag MMAP_SETUP | Delete a setup.
* @flag MMAP_PATCH | Delete a patchmap.
* @flag MMAP_KEY | Delete a keymap.
*
* @parm LPSTR | lpName | Specifies the name of the map to be deleted.
*
* @rdesc Returns a MMAP error code or zero on success.
*/
// Issues:
//
// 1. If this function fails it will corrupt the database.
MMAPERR FAR PASCAL mapDelete(
UINT uFlag,
LPSTR lpName)
{
HANDLE hUsage;
LPMMCHANNEL lpmmChan = NULL; // Kill spurious use before set diag
LPMMTABLE lpmmTable;
LPMMTABLEHEADER lpmmHeader;
LPMMTABLEENTRY lpmmEntry;
LPHANDLE lphTable;
LPHANDLE lphUsageTable;
UNALIGNED WORD *lpidxNames = NULL; // Kill spurious use before set diagnostic
LPBYTE lpbUsage;
MMSETUP mmSetup;
MMPATCH mmPatch;
MMAPERR mmaperr;
UINT uGarbage; // size of thing getting deleted
UINT uSize;
UINT uIdx; // index of deleted entry in table
UINT uUsageFlag = 0; // SETUP or PATCH => same as uFlag, else 0
UINT uNumPos; // # of positions; setup=16, patch=128
int idxEntry; // table index
UINT uIndex;
// grab the appropriate table, structure size and usage info
switch (uFlag) {
case MMAP_SETUP:
lphTable = &hSetupTable;
uGarbage = sizeof(MIDIMAP);
lphUsageTable = &hPatchTable;
uUsageFlag = MMAP_PATCH;
uNumPos = 16;
break;
case MMAP_PATCH:
lphTable = &hPatchTable;
lphUsageTable = &hKeyTable;
uUsageFlag = MMAP_KEY;
uGarbage = sizeof(MIDIPATCHMAP);
uNumPos = MIDIPATCHSIZE;
break;
case MMAP_KEY:
lphTable = &hKeyTable;
uGarbage = sizeof(MIDIKEYMAP);
uNumPos = 0; // Kill spurious diagnostic
lphUsageTable = NULL; // Kill spurious diagnostic
break;
default:uGarbage = 0;
lphTable = NULL; // kill spurious use before set diagnostic
lphUsageTable = NULL; // Kill spurious diagnostic
uNumPos = 0; // kill spurious use before set diagnostic
}
// open file, read in appropriate table(s)
mmaperr = MmaperrFileAccess(MAP_FOPEN, OF_READWRITE);
if (mmaperr != MMAPERR_SUCCESS)
return mmaperr;
mmaperr = MmaperrReadTable(uFlag |uUsageFlag);
if (mmaperr != MMAPERR_SUCCESS) {
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return mmaperr;
}
lpmmEntry = LpGetTableEntry(*lphTable, lpName);
if (lpmmEntry == NULL) {
switch (uFlag) {
case MMAP_SETUP:
mmaperr = MMAPERR_INVALIDSETUP;
break;
case MMAP_PATCH:
mmaperr = MMAPERR_INVALIDPATCH;
break;
case MMAP_KEY:
mmaperr = MMAPERR_INVALIDKEY;
break;
}
exit01: VFreeTable(uFlag | uUsageFlag);
goto exit00;
}
// save the table index
idxEntry = lpmmEntry->idxEntry;
if (uUsageFlag) {
// obtain the number of entrys in the usage table
lpmmTable = (LPMMTABLE)GlobalLock(*lphUsageTable);
uSize = lpmmTable->mmHeader.wEntrys;
GlobalUnlock(*lphUsageTable);
// read in setup or patchmap, set optimization pointer
if (_llseek(iFile, lpmmEntry->doData, 0) == -1L) {
mmaperr = MMAPERR_READ;
goto exit01;
}
if (uUsageFlag == MMAP_PATCH) {
if (_lread(iFile, (LPSTR)&mmSetup,
sizeof(MMSETUP)) != sizeof(MMSETUP)) {
mmaperr = MMAPERR_READ;
goto exit01;
}
lpmmChan =(LPMMCHANNEL)(mmSetup.chMap); // MIPS silliness
} else {
if (_lread(iFile, (LPSTR)&mmPatch,
sizeof(MMPATCH)) != sizeof(MMPATCH)) {
mmaperr = MMAPERR_READ;
goto exit01;
}
lpidxNames = mmPatch.idxKMapNames;
}
// create table which is 'number-of-maps' in length
if (uSize) {
hUsage = GlobalAlloc(GHND, (LONG)uSize);
if (hUsage == NULL) {
mmaperr = MMAPERR_MEMORY;
goto exit01;
}
lpbUsage = (LPBYTE)GlobalLock(hUsage);
// set flags in table saying which patchmaps or
// keymaps this setup or patchmap references,
// respectively
for (uIndex = 0; uIndex < uNumPos; uIndex++) {
if (uUsageFlag == MMAP_PATCH) {
uIdx = lpmmChan->idxPMapName;
lpmmChan++;
} else {
uIdx = *lpidxNames;
lpidxNames++;
}
if (uIdx)
lpbUsage[uIdx - 1] = 1;
}
// go through table and decrement usage count
// of any entrys that are non zero
for (uIndex = 0; uIndex < uSize; uIndex++, lpbUsage++) {
if (!*lpbUsage)
continue;
mmaperr = MmaperrChangeUsing(uUsageFlag,uIndex + 1, -1);
// uIndex + -1, 1)
if (mmaperr != MMAPERR_SUCCESS) {
GlobalUnlock(hUsage);
GlobalFree(hUsage);
goto exit01;
}
}
GlobalUnlock(hUsage);
GlobalFree(hUsage);
}
}
_fmemset((LPSTR)(lpmmEntry->szName), 0L, MMAP_MAXNAME);
_fmemset((LPSTR)(lpmmEntry->szDesc), 0L, MMAP_MAXDESC);
lpmmEntry->doData = 0L;
lpmmEntry->idxEntry = 0L;
mmaperr = MmaperrWriteTabEntry(uFlag, idxEntry, lpmmEntry);
if (mmaperr != MMAPERR_SUCCESS)
goto exit01; // Yes, 01, not 02.
lpmmTable = (LPMMTABLE)GlobalLock(*lphTable);
lpmmHeader = (LPMMTABLEHEADER)(&lpmmTable->mmHeader);
lpmmHeader->wUsed--;
mmaperr = MmaperrWriteTabHeader(uFlag,lpmmHeader);
if (mmaperr != MMAPERR_SUCCESS) {
GlobalUnlock(*lphTable);
goto exit01; // Yes, 01, not 02.
}
GlobalUnlock(*lphTable);
mmaperr = MmaperrGarbage(uGarbage);
if (mmaperr != MMAPERR_SUCCESS)
goto exit01; // Yes, 01, not 02.
VFreeTable(uFlag | uUsageFlag);
mmaperr = MmaperrFileAccess(MAP_FCLOSE, 0);
if (mmaperr != MMAPERR_SUCCESS)
return mmaperr;
return MMAPERR_SUCCESS;
} /* mapDelete */
// - - - - - - - - -
/*
* @doc INTERNAL
*
* @api DWORD | mapEnumerate | This function enumerates the names and
* descriptions of all the maps of the specified type found in the
* midi data file, or the names and device id's of the ports a setup
* accesses.
*
* @parm UINT | uFlag | Specifies the type of enumerate to be performed. It
* may be any one of the following values:
*
* @flag MMAP_SETUP | Enumerate setup names.
* @flag MMAP_PATCH | Enumerate patchmap names.
* @flag MMAP_KEY | Enumerate keymap names.
* @flag MMAP_PORTS | Enumerate ports in a setup.
*
* @parm ENUMPROC | lpfnCallback | Specifies the procedure-instance address of
* the callback function to be called with the name of each map.
*
* @parm DWORD | dwUser | If <p uFlag> is <f MMAP_SETUP>, <f MMAP_PATCH>, or
* <f MMAP_KEY>, this parameter specifies a user variable that will be
* passed to the callback function along with the name of each map. If
* <p uFlag> is <f MMAP_PORTS>, this parameter specifies a far pointer
* to a setup name.
*
* @rdesc Returns a MMAP error code or zero on success.
*
* @comm <p lpfnCallBack> must be obtained using the <f MakeProcInstance>
* call, must use the pascal calling convention, must be declared FAR,
* and must be under the EXPORTS section in your applications .DEF file.
*
* @cb BOOL FAR PASCAL | EnumerateCallback | The callback function for
* <f mapEnumerate>.
*
* @parm LPSTR | lpName | If <p uFlag> is <f MMAP_SETUP>, <f MMAP_PATCH>, or
* <f MMAP_KEY>, this parameter specifies the name of a map of that type.
* If <p uFlag> is <f MMAP_PORTS>, this parameter is a number in the
* range of 1 to 16 which specifies the channel on which the supplied
* port <p lpDesc> is mapped.
*
* @parm LPSTR | lpDesc | If <p uFlag> is <f MMAP_SETUP>, <f MMAP_PATCH>, or
* <f MMAP_KEY>, this parameter specifies the description of the map in
* the <p lpName> parameter. If <p uFlag> is <f MMAP_PORTS>, this
* parameter specifies the name of a port accessed by the setup.
*
* @parm DWORD | dwUser | If <p uFlag> is <f MMAP_SETUP>, <f MMAP_PATCH>, or
* <f MMAP_KEY>, this parameter specifies a user variable. If <p uFlag>
* is <f MMAP_PORTS>, this parameter specifies the device ID of the
* supplied port <p lpDesc>. In this case, if the port is not available
* in the current environment, the device ID is equal to the constant
* MMAP_ID_NOPORT.
*
* @rdesc It should return non-zero as long as it wants to continue being
* called with successive map or port names. <f mapEnumerate> will stop
* enumerating when the callback function returns zero.
*/
// Issues:
//
// 1. It regards elements with a zero first byte as "not counting"
// in the count of elements in a table. If this is a bad
// assertion, this routine has a bug.
MMAPERR FAR PASCAL mapEnumerate ( UINT uFlag
, ENUMPROC lpfnCallback
, UINT uCase // passed to lpfnCallback
, HWND hCombo // passed to lpfnCallback
, LPSTR lpSetupName // passed to lpfnCallback
)
{
LPHANDLE lphTable;
LPMMTABLE lpmmTable;
LPMMTABLEENTRY lpmmEntry;
UINT wEnum;
UINT wUsed;
MMAPERR mmaperr;
switch (uFlag) {
case MMAP_SETUP :
lphTable = &hSetupTable;
break;
case MMAP_PATCH :
lphTable = &hPatchTable;
break;
case MMAP_KEY :
lphTable = &hKeyTable;
break;
case MMAP_PORTS :
return MmaperrEnumPorts(lpfnCallback, uCase, hCombo, lpSetupName);
default: lphTable = NULL; // kill spurious use before set diagnostic
}
mmaperr = MmaperrReadTable(uFlag);
if (mmaperr != MMAPERR_SUCCESS)
return mmaperr;
lpmmTable = (LPMMTABLE)GlobalLock(*lphTable);
lpmmEntry = (LPMMTABLEENTRY)GlobalLock(lpmmTable->hEntrys);
wUsed = lpmmTable->mmHeader.wUsed;
for (wEnum = 0; wEnum < wUsed; lpmmEntry++) {
if (!*lpmmEntry->szName)
continue;
if (!(*lpfnCallback)( (LPSTR)lpmmEntry->szName
, (LPSTR)lpmmEntry->szDesc
, uCase
, hCombo
, lpSetupName
)
)
break;
wEnum++;
}
GlobalUnlock(lpmmTable->hEntrys);
GlobalUnlock(*lphTable);
VFreeTable(uFlag);
return MMAPERR_SUCCESS;
} /* mapEnumerate */
// - - - - - - - - -
// MmaperrEnumPorts
//
// Enumerate the ports in a setup.
//
// Side-effects:
//
// 1. None.
//
// Remarks:
//
// 1. If the enumeration function fails, this function won't
// let you know.
STATIC MMAPERR NEAR PASCAL MmaperrEnumPorts(
ENUMPROC lpfnCallback,
UINT uCase, // unused
HWND hCombo, // unused
LPSTR lpSetupName)
{
LPMMTABLEENTRY lpmmEntry;
LPMMCHANNEL lpmmChan;
MIDIOUTCAPS moCaps;
MMSETUP mmSetup;
MMAPERR mmaperr;
UINT wNumDevs;
UINT uDeviceID;
int i;
// open file, read in setup table
mmaperr = MmaperrFileAccess(MAP_FOPEN, OF_READ);
if (mmaperr != MMAPERR_SUCCESS)
return mmaperr;
mmaperr = MmaperrReadTable(MMAP_SETUP);
if (mmaperr != MMAPERR_SUCCESS) {
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return mmaperr;
}
// assuming setup actually exists
lpmmEntry = LpGetTableEntry(hSetupTable, lpSetupName);
if (lpmmEntry == NULL) {
mmaperr = MMAPERR_INVALIDSETUP;
exit01: VFreeTable(MMAP_SETUP);
goto exit00;
}
// read in setup data from file
if (_llseek(iFile, lpmmEntry->doData, 0) == -1L) {
mmaperr = MMAPERR_READ;
goto exit01;
}
if (_lread(iFile, (LPSTR)&mmSetup, sizeof(MMSETUP)) != sizeof(MMSETUP)) {
mmaperr = MMAPERR_READ;
goto exit01;
}
// grab the number of devices in the current environment
wNumDevs = midiOutGetNumDevs();
// set an optimization-pointer
lpmmChan = (LPMMCHANNEL)(mmSetup.chMap); // MIPS silliness
for (i = 0; i < 16; i++, lpmmChan++) {
// if no device name, then nothing to enumerate
if (!*lpmmChan->szDevice)
continue;
// convert device name to device ID. If device name doesn't
// exist in the current environment, set ID to MMAP_ID_NOPORT
for (uDeviceID = 0; uDeviceID < wNumDevs; uDeviceID++) {
midiOutGetDevCaps(uDeviceID, &moCaps, sizeof(MIDIOUTCAPS));
if (!lstrcmpi( moCaps.szPname
, (LPCSTR)(lpmmChan->szDevice)))
break;
}
if (uDeviceID == wNumDevs)
uDeviceID = MMAP_ID_NOPORT;
if (!(*lpfnCallback)( (LPSTR)(DWORD)i + 1
, (LPSTR)(lpmmChan->szDevice)
, uCase // garbage parameter
, hCombo // garbage parameter
, (LPSTR)uDeviceID
)
)
break;
}
// free table, close file and leave
VFreeTable(MMAP_SETUP);
(VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return MMAPERR_SUCCESS;
} /* MmaperrEnumPorts */
// - - - - - - - - -
/*
* @doc INTERNAL
*
* @api DWORD | mapGetUsageCount | Get the usage count for a patchmap or
* keymap.
*
* @parm UINT | uFlag | Specifies the type of map to get the usage count for.
* It may be any one of the following values:
*
* @flag MMAP_PATCH | Get the usage count for a patchmap.
* @flag MMAP_KEY | Get the usage count for a keymap.
*
* @parm LPSTR | lpName | Specifies the name of the map to get the usage
* count for.
*
* @rdesc Returns a MMAP error code, or the usage count for the map
* specified by <p lpName> in the high-order word.
*
* @comm Usage counts are used in order to determine whether it is okay to
* delete a patchmap or keymap. If a setup accesses a patchmap, the
* usage count for that patchmap will be 1, and hence it should not be
* deleted. The same is true for patchmaps accessing keymaps. The
* mapDelete function does not look for or care about this number, so
* it is up to YOU to determine whether a patchmap or keymap has a zero
* usage count before calling mapDelete.
*/
// Side-effects:
//
// 1. None.
DWORD FAR PASCAL mapGetUsageCount(
UINT uFlag,
LPSTR lpName)
{
LPMMTABLEENTRY lpmmEntry;
MMPATCH mmPatch;
MMKEY mmKey;
MMAPERR mmaperr;
DWORD dwRet;
mmaperr = MmaperrFileAccess(MAP_FOPEN, OF_READ);
if (mmaperr != MMAPERR_SUCCESS)
return MAKELONG(mmaperr, 0);
mmaperr = MmaperrReadTable(uFlag);
if (mmaperr != MMAPERR_SUCCESS) {
dwRet = MAKELONG(mmaperr, 0);
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return dwRet;
}
switch (uFlag) {
case MMAP_PATCH:
lpmmEntry = LpGetTableEntry(hPatchTable, lpName);
if (lpmmEntry != NULL) {
if (_llseek(iFile, lpmmEntry->doData, 0) == -1L) {
dwRet = MAKELONG(MMAPERR_READ, 0);
exit01: VFreeTable(uFlag);
goto exit00;
}
if ( _lread(iFile, (LPSTR)&mmPatch, sizeof(MMPATCH))
!= sizeof(MMPATCH)
) {
dwRet = MAKELONG(MMAPERR_READ, 0);
goto exit01;
}
dwRet = MAKELONG(MMAPERR_SUCCESS, mmPatch.wUsing);
exit02: VFreeTable(uFlag);
(VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return dwRet;
} else {
dwRet = MAKELONG(MMAPERR_INVALIDPATCH, 0);
goto exit01;
}
break; // This "break" is actually unreachable.
case MMAP_KEY:
lpmmEntry = LpGetTableEntry(hKeyTable, lpName);
if (lpmmEntry != NULL) {
if (_llseek(iFile, lpmmEntry->doData, 0) == -1L) {
dwRet = MAKELONG(MMAPERR_READ, 0);
goto exit01;
}
if (_lread(iFile, (LPSTR)&mmKey, sizeof(MMKEY))
!= sizeof(MMKEY)
) {
dwRet = MAKELONG(MMAPERR_READ, 0);
goto exit01;
}
dwRet = MAKELONG (MMAPERR_SUCCESS, mmKey.wUsing);
goto exit02;
} else {
dwRet = MAKELONG(MMAPERR_INVALIDPATCH, 0);
goto exit01;
}
break; // This "break" is actually unreachable.
}
} /* mapGetUsageCount */
// - - - - - - - - -
/*
* @doc INTERNAL
*
* @api DWORD | mapPatchMapInSetup | Determine if a patchmap is used within a
* setup.
*
* @parm LPSTR | lpPatchName | Specifies the name of the patchmap.
*
* @parm LPSTR | lpSetupName | Specifies the name of the setup.
*
* @rdesc Returns a MMAP error code, or non-zero in the high-order word if the
* given patchmap is used within the given setup.
*
* @xref mapKeyMapInSetup
*/
// Side-effects:
//
// 1. None.
DWORD FAR PASCAL mapPatchMapInSetup(
LPSTR lpPatchName,
LPSTR lpSetupName)
{
LPMMTABLEENTRY lpmmEntry;
LPMMCHANNEL lpmmChan;
MMSETUP mmSetup;
DWORD dwRet;
MMAPERR mmaperr;
int i;
mmaperr = MmaperrFileAccess(MAP_FOPEN, OF_READ);
if (mmaperr != MMAPERR_SUCCESS)
return MAKELONG(mmaperr, 0);
mmaperr = MmaperrReadTable(MMAP_SETUP | MMAP_PATCH);
if (mmaperr != MMAPERR_SUCCESS) {
dwRet = MAKELONG(mmaperr, 0);
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return dwRet;
}
lpmmEntry = LpGetTableEntry(hSetupTable, lpSetupName);
if (lpmmEntry == NULL) {
dwRet = MAKELONG(MMAPERR_INVALIDSETUP, 0);
exit01: VFreeTable(MMAP_SETUP | MMAP_PATCH);
goto exit00;
}
if (_llseek(iFile, lpmmEntry->doData, 0) == -1L) {
dwRet = MAKELONG(MMAPERR_READ, 0);
goto exit01;
}
if (_lread(iFile, (LPSTR)&mmSetup, sizeof(MMSETUP)) != sizeof(MMSETUP)){
dwRet = MAKELONG(MMAPERR_READ, 0);
goto exit01;
}
lpmmChan = (LPMMCHANNEL)(mmSetup.chMap); // MIPS silliness
for (i = 0; i < 16; i++, lpmmChan++) {
if (!lpmmChan->idxPMapName)
continue;
lpmmEntry = LpGetTableEntry(hPatchTable,
MAKEID(lpmmChan->idxPMapName));
if (!lstrcmpi(lpPatchName, (LPCSTR)(lpmmEntry->szName)))
break;
}
VFreeTable(MMAP_SETUP | MMAP_PATCH);
(VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return MAKELONG(MMAPERR_SUCCESS, (i < 16) ? 1 : 0);
} /* mapPatchMapInSetup */
// - - - - - - - - -
/*
* @doc INTERNAL
*
* @api DWORD | mapKeyMapInSetup | Determine if a keymap is used within a
* setup.
*
* @parm LPSTR | lpKeyName | Specifies the name of the keymap.
*
* @parm LPSTR | lpSetupName | Specifies the name of the setup.
*
* @rdesc Returns a MMAP error code, or non-zero in the high-order word
* if the given keymap is used within the given patchmap.
*
* @xref mapPatchMapInSetup
*/
DWORD FAR PASCAL mapKeyMapInSetup(
LPSTR lpKeyName,
LPSTR lpSetupName)
{
LPMMTABLEENTRY lpmmEntry;
LPMMCHANNEL lpmmChan;
MMSETUP mmSetup;
MMPATCH mmPatch;
UNALIGNED WORD *lpidxKMap;
DWORD dwRet;
MMAPERR mmaperr;
int i;
int j;
mmaperr = MmaperrFileAccess(MAP_FOPEN, OF_READ);
if (mmaperr != MMAPERR_SUCCESS)
return MAKELONG(mmaperr, 0);
mmaperr = MmaperrReadTable(MMAP_SETUP | MMAP_PATCH | MMAP_KEY);
if (mmaperr != MMAPERR_SUCCESS) {
dwRet = MAKELONG(mmaperr, 0);
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return dwRet;
}
if ((lpmmEntry = LpGetTableEntry(hSetupTable, lpSetupName)) == NULL) {
dwRet = MAKELONG(MMAPERR_INVALIDSETUP, 0);
exit01: VFreeTable(MMAP_SETUP | MMAP_PATCH | MMAP_KEY);
goto exit00;
}
if (_llseek(iFile, lpmmEntry->doData, 0) == -1L) {
dwRet = MAKELONG(MMAPERR_READ, 0);
goto exit01;
}
if (_lread(iFile, (LPSTR)&mmSetup, sizeof(MMSETUP)) != sizeof(MMSETUP)){
dwRet = MAKELONG(MMAPERR_READ, 0);
goto exit01;
}
lpmmChan = (LPMMCHANNEL)(mmSetup.chMap); // MIPS silliness
dwRet = MAKELONG(MMAPERR_SUCCESS, 0);
for (i = 0; i < 16; i++, lpmmChan++) {
DWORD dwUniqueRet;
if (!lpmmChan->idxPMapName)
continue;
lpmmEntry = LpGetTableEntry(hPatchTable,
MAKEID(lpmmChan->idxPMapName));
dwUniqueRet = LiNotUnique( (LPSTR)(lpmmEntry->szName)
, &hPatchList
, 0L);
// 0L in the "dwOffset" field because it's never used.
if (dwUniqueRet == -1L) {
dwRet = MAKELONG(MMAPERR_MEMORY, 0);
exit02: VFreeUniqueList(&hPatchList);
goto exit01;
} else if (dwUniqueRet)
continue;
if (_llseek(iFile, lpmmEntry->doData, 0) == -1L) {
dwRet = MAKELONG(MMAPERR_READ, 0);
goto exit02;
}
if ( _lread(iFile, (LPSTR)&mmPatch, sizeof(MMPATCH))
!= sizeof(MMPATCH)
) {
dwRet = MAKELONG(MMAPERR_READ, 0);
goto exit02;
}
lpidxKMap = mmPatch.idxKMapNames;
for (j = 0; j < MIDIPATCHSIZE; j++, lpidxKMap++) {
if (!*lpidxKMap)
continue;
lpmmEntry = LpGetTableEntry(hKeyTable,
MAKEID(*lpidxKMap));
if (!lstrcmpi(lpKeyName, (LPCSTR)(lpmmEntry->szName))) {
dwRet = MAKELONG(MMAPERR_SUCCESS, 1);
break;
}
}
if (j < MIDIPATCHSIZE)
break;
}
VFreeUniqueList(&hPatchList);
// free tables, close file and leave
VFreeTable(MMAP_SETUP | MMAP_PATCH | MMAP_KEY);
(VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return dwRet;
} /* mapKeyMapInSetup */
// - - - - - - - - -
/*
* @doc INTERNAL
*
* @api DWORD | mapExists | Deterine if a map exists by the given name.
*
* @parm UINT | uFlag | Specifies the type of map of which existence is
* to be determined. It may be any of the following:
*
* @flag MMAP_SETUP | Determine if a setup exists.
* @flag MMAP_PATCH | Determine if a patchmap exists.
* @flag MMAP_KEY | Determine if a keymap exists.
*
* @parm LPSTR | lpName | Specifies the name of the map.
*
* @rdesc Returns a MMAP error code in the low word. The the call succeeds,
* returns non-zero in the high-order word if a map exists by the given
* name.
*/
// Side-effects:
//
// 1. None.
DWORD FAR PASCAL mapExists(
UINT uFlag,
LPSTR lpName)
{
LPHANDLE lphTable;
LPMMTABLEENTRY lpmmEntry;
MMAPERR mmaperr;
switch (uFlag) {
case MMAP_SETUP:
lphTable = &hSetupTable;
break;
case MMAP_PATCH:
lphTable = &hPatchTable;
break;
case MMAP_KEY:
lphTable = &hKeyTable;
break;
default:lphTable = NULL; // kill spurious use before sete diagnostic
}
if ((mmaperr = MmaperrReadTable(uFlag)) != MMAPERR_SUCCESS)
return MAKELONG(mmaperr, 0);
lpmmEntry = LpGetTableEntry(*lphTable, lpName);
VFreeTable(uFlag);
return MAKELONG(MMAPERR_SUCCESS, (lpmmEntry != NULL) ? 1 : 0);
} /* mapExists */
// - - - - - - - - -
// LiNotUnique
//
// Return 0L if the supplied name is unique, and in this case add it to
// the end of the list with the offset given in parm 3.
//
// Return -1 if the GlobalAlloc fails so that the unique name
// cannot be added.
//
// Otherwise return an offset from the base of the current setup
// or patchmap where the map exists, or the channel number which
// accesses the invalid port.
//
// Uniqueness is determined by the presence of the name on its respective
// list; hPatchList for patchmap names; hKeyList for keymap names;
// hPortList for port names. It's up to the caller to give us the
// right list to search.
//
STATIC DWORD NEAR PASCAL LiNotUnique(
LPSTR lpName,
LPHANDLE lphList,
DWORD dwOffset)
{
LPUNIQUEMAP lpumEntry = NULL; //; kill spurious use before set diag
HANDLE hCur;
HANDLE hPrev = NULL;
for (hCur = *lphList; hCur;) {
lpumEntry = (LPUNIQUEMAP)GlobalLock(hCur);
if (!lstrcmpi((LPCSTR)(lpumEntry->szName), lpName)) {
DWORD liRet;
liRet = lpumEntry->dwOffset;
GlobalUnlock(hCur);
return liRet;
}
hPrev = hCur;
hCur = lpumEntry->hNext;
if (hCur != NULL) {
GlobalUnlock(hPrev);
}
}
hCur = GlobalAlloc(GHND, (DWORD)sizeof(UNIQUEMAP));
if (hCur == NULL) {
if (hPrev != NULL) {
GlobalUnlock(hPrev);
}
return (DWORD)-1L;
}
if (hPrev != NULL) {
lpumEntry->hNext = hCur;
GlobalUnlock(hPrev);
} else
*lphList = hCur;
lpumEntry = (LPUNIQUEMAP)GlobalLock(hCur);
lstrcpy((LPSTR)(lpumEntry->szName), lpName);
lpumEntry->dwOffset = dwOffset;
lpumEntry->hNext = NULL;
GlobalUnlock(hCur);
return 0L;
} /* LiNotUnique */
// - - - - - - - - -
// LszGetUniqueAtOffset
//
// Return a unique name given an offset.
//
// Remarks:
//
// 1. I don't think this can fail, although there's a weird case
// if you run out of list. In this case you get an empty string.
// I'm not sure if this is bad or not.
STATIC LPSTR NEAR PASCAL LszGetUniqueAtOffset(
DWORD dwOffset,
HANDLE hList)
{
static char szUnique[MAX_UNIQUENAME];
*szUnique = 0;
while (hList) {
HANDLE hNext;
LPUNIQUEMAP lpumEntry;
lpumEntry = (LPUNIQUEMAP)GlobalLock(hList);
if (dwOffset == lpumEntry->dwOffset) {
lstrcpy(szUnique, (LPCSTR)(lpumEntry->szName));
GlobalUnlock(hList);
break;
}
hNext = lpumEntry->hNext;
GlobalUnlock(hList);
hList = hNext;
}
return (LPSTR)szUnique;
} /* LszGetUniqueAtOffset */
// - - - - - - - - -
//
// VFreeUniqueList
//
// Free up the memory associated with a unique name list.
//
// Side-effects:
//
// 1. None.
STATIC VOID NEAR PASCAL VFreeUniqueList(
LPHANDLE lphList)
{
// there was a code generation compiler bug
// it thought that hPrev and *lphList were synonyms. Worrying!!
HANDLE hPrev;
HANDLE hList;
hList = *lphList;
*lphList = NULL;
for (; hList != NULL; ) {
LPUNIQUEMAP lpumEntry;
hPrev = hList;
lpumEntry = (LPUNIQUEMAP)GlobalLock(hPrev);
hList = lpumEntry->hNext;
GlobalUnlock(hPrev);
GlobalFree(hPrev);
}
} /* VFreeUniqueList */
// - - - - - - - - -
// MmaperrChangeUsing
//
// Change the usage count of a patchmap or keymap.
//
// Side-effects:
//
// 1. None.
STATIC MMAPERR NEAR PASCAL MmaperrChangeUsing(
UINT uFlag,
UINT uIdx,
int iVal)
{
HANDLE hTable;
LPMMTABLEENTRY lpmmEntry;
MMPATCH mmPatch;
MMAPERR mmaperr;
MMKEY mmKey;
if ((mmaperr = MmaperrFileAccess(MAP_FOPEN,
OF_READWRITE)) != MMAPERR_SUCCESS)
return mmaperr;
if ((mmaperr = MmaperrReadTable(uFlag)) != MMAPERR_SUCCESS) {
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return mmaperr;
}
hTable = (uFlag == MMAP_PATCH) ? hPatchTable : hKeyTable;
lpmmEntry = LpGetTableEntry(hTable, // No error return
MAKEID(uIdx)); // is possible.
if (_llseek(iFile, lpmmEntry->doData, 0) == -1L) {
mmaperr = MMAPERR_READ;
exit01: VFreeTable(uFlag);
goto exit00;
}
switch (uFlag) {
case MMAP_PATCH:
if ( _lread(iFile, (LPSTR)&mmPatch, sizeof(MMPATCH))
!= sizeof(MMPATCH)
) {
mmaperr = MMAPERR_READ;
goto exit01;
}
mmPatch.wUsing += (WORD)iVal;
if (_llseek(iFile, lpmmEntry->doData, 0) == -1L) {
mmaperr = MMAPERR_WRITE;
goto exit01;
}
if ( _lwrite(iFile, (LPSTR)&mmPatch, sizeof(MMPATCH))
!= sizeof(MMPATCH)
) {
mmaperr = MMAPERR_WRITE;
goto exit01;
}
break;
case MMAP_KEY:
if (_lread(iFile, (LPSTR)&mmKey, sizeof(MMKEY)) != sizeof(MMKEY)) {
mmaperr = MMAPERR_READ;
goto exit01;
}
mmKey.wUsing += (WORD)iVal;
if (_llseek(iFile, lpmmEntry->doData, 0) == -1L) {
mmaperr = MMAPERR_WRITE;
goto exit01;
}
if (_lwrite(iFile, (LPSTR)&mmKey, sizeof(MMKEY)) != sizeof(MMKEY)) {
mmaperr = MMAPERR_WRITE;
goto exit01;
}
break;
}
VFreeTable(uFlag);
if ((mmaperr = MmaperrFileAccess(MAP_FCLOSE, 0)) != MMAPERR_SUCCESS)
return mmaperr;
return MMAPERR_SUCCESS;
} /* MmaperrChangeUsing */
// - - - - - - - - -
//
// MmaperrReadTable
//
// Read in table(s) of names/descriptions from the midimap file.
//
// Returns boolean.
//
// Side-effects:
//
// 1. None anymore.
STATIC MMAPERR NEAR PASCAL MmaperrReadTable(
UINT APIn)
{
MMHEADER mmHeader;
LPMMTABLE lpmmTable;
LPMMTABLEENTRY lpmmEntry;
LPHANDLE lpTable;
MMAPERR mmaperr;
UINT oPos;
UINT uTableSize;
UINT mmap;
UINT mmapCompleted;
mmaperr = MmaperrFileAccess(MAP_FOPEN, OF_READ);
if (mmaperr != MMAPERR_SUCCESS)
return mmaperr;
if (_llseek(iFile, 0L, 0) == -1L) {
mmaperr = MMAPERR_READ;
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return mmaperr;
}
if (_lread(iFile, (LPSTR)&mmHeader, sizeof(MMHEADER)) != sizeof(MMHEADER)) {
mmaperr = MMAPERR_READ;
goto exit00;
}
mmapCompleted = 0;
for (mmap = 1; mmap < 5; mmap <<= 1) {
if (!(APIn & mmap))
continue;
switch (mmap) {
default:
continue;
case MMAP_SETUP:
lpTable = &hSetupTable;
oPos = mmHeader.oSetup;
break;
case MMAP_PATCH:
lpTable = &hPatchTable;
oPos = mmHeader.oPatch;
break;
case MMAP_KEY:
lpTable = &hKeyTable;
oPos = mmHeader.oKey;
break;
}
if (*lpTable)
lpmmTable = (LPMMTABLE)GlobalLock(*lpTable);
else {
*lpTable = GlobalAlloc(GHND, (DWORD)sizeof(MMTABLE));
if (*lpTable == NULL) {
mmaperr = MMAPERR_MEMORY;
exit01: VFreeTable(mmapCompleted);
goto exit00;
}
lpmmTable = (LPMMTABLE)GlobalLock(*lpTable);
if (_llseek(iFile, (LONG)oPos, 0) == -1L) {
mmaperr = MMAPERR_READ;
exit02: GlobalUnlock(*lpTable);
GlobalFree(*lpTable);
*lpTable = NULL;
goto exit01;
}
if ( _lread(iFile, (LPSTR)&lpmmTable->mmHeader,sizeof(MMTABLEHEADER))
!= sizeof(MMTABLEHEADER)
) {
mmaperr = MMAPERR_READ;
goto exit02;
}
uTableSize = lpmmTable->mmHeader.wEntrys *
sizeof(MMTABLEENTRY);
lpmmTable->hEntrys = GlobalAlloc( GHND
, (DWORD)uTableSize
);
if (lpmmTable->hEntrys == NULL) {
mmaperr = MMAPERR_MEMORY;
goto exit02;
}
lpmmEntry = (LPMMTABLEENTRY)GlobalLock(
lpmmTable->hEntrys);
if ( _lread(iFile, (LPSTR)lpmmEntry, uTableSize)
!= uTableSize
) {
mmaperr = MMAPERR_READ;
/*exit03:*/ GlobalUnlock(lpmmTable->hEntrys);
GlobalFree(lpmmTable->hEntrys);
goto exit02;
}
GlobalUnlock(lpmmTable->hEntrys);
}
lpmmTable->wCount++;
GlobalUnlock(*lpTable);
mmapCompleted |= mmap;
}
(VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return MMAPERR_SUCCESS;
} /* MmaperrReadTable */
// - - - - - - - - -
//
// VFreeTable
//
// Free a table (or tables) from memory.
//
// Side-effects:
//
// 1. None.
STATIC VOID NEAR PASCAL VFreeTable(
UINT APIn)
{
LPMMTABLE lpmmTable;
LPHANDLE lpTable;
UINT mmap;
for (mmap = 1; mmap < 5; mmap <<= 1) {
if (!(APIn & mmap))
continue;
switch (mmap) {
default:
continue;
case MMAP_SETUP:
lpTable = &hSetupTable;
break;
case MMAP_PATCH:
lpTable = &hPatchTable;
break;
case MMAP_KEY:
lpTable = &hKeyTable;
break;
}
if (!*lpTable)
continue;
lpmmTable = (LPMMTABLE)GlobalLock(*lpTable);
if (--lpmmTable->wCount) {
GlobalUnlock(*lpTable);
continue;
}
GlobalFree(lpmmTable->hEntrys);
GlobalUnlock(*lpTable);
GlobalFree(*lpTable);
*lpTable = NULL;
}
} /* VFreeTable */
// - - - - - - - - -
//
// LpGetTableEntry
//
// Given a name or index, return a table entry. If lpName is NULL, it
// assumes you have already called this and simply returns whatever
// happens to be in the local static mmEntry.
//
// Side-effects:
//
// 1. None.
//
// Remarks:
//
// 1. This can't return an error if "lpName" is NULL, or if the
// HIWORD of it is zero.
STATIC LPMMTABLEENTRY NEAR PASCAL LpGetTableEntry(
HANDLE hTable,
LPSTR lpName // Name or index
)
{
static MMTABLEENTRY mmEntry;
LPMMTABLE lpmmTable;
LPMMTABLEENTRY lpmmEntry;
UINT wNum ;
UINT wUsed;
if (lpName == NULL) {
return &mmEntry;
}
lpmmTable = (LPMMTABLE)GlobalLock(hTable);
lpmmEntry = (LPMMTABLEENTRY)GlobalLock(lpmmTable->hEntrys);
wNum = 0;
if (!HIWORD(lpName)) {
lpmmEntry += LOWORD ((LONG_PTR)lpName) - 1;
wUsed = 1;
} else {
/* search through storage handled by lpmmTable->hEntrys for lpName */
/* set wNum to its number and lpmmEntry to the entry */
wUsed = lpmmTable->mmHeader.wUsed;
for (; wNum < wUsed; lpmmEntry++) {
if (!*lpmmEntry->szName) {
continue;
}
if (!lstrcmpi((LPCSTR)(lpmmEntry->szName), lpName))
break;
wNum++;
}
}
if (wNum < wUsed)
mmEntry = *lpmmEntry;
GlobalUnlock(lpmmTable->hEntrys);
GlobalUnlock(hTable);
if (wNum == wUsed)
return NULL;
return (LPMMTABLEENTRY)&mmEntry;
} /* LpGetTableEntry */
// - - - - - - - - -
/*
* @doc INTERNAL
*
* @api MMAPERR | MmaperrWriteTabEntry | Write a table entry to disk.
*
* uIdx may be a table entry index (1 ... n) or it may be zero if
* you want to use lpmmEntry->idxEntry as the index.
*/
// Side-effects of failure:
//
// 1. If the "close" fails something bad has happened to the file.
//
// Remarks:
//
// 1. This function used to modify the in-memory table first, then
// go on to tackle the on-disk entry. It now does this in
// reverse order in order to avoid a situation where the
// in-memory table is changed but the disk representation isn't.
STATIC MMAPERR NEAR PASCAL MmaperrWriteTabEntry(
UINT uFlag,
UINT uIdx,
LPMMTABLEENTRY lpmmEntry)
{
HANDLE hTable;
LPMMTABLE lpmmTable;
LPMMTABLEENTRY lpmmOldEntry;
MMHEADER mmHeader;
UNALIGNED WORD *lpoTable;
MMAPERR mmaperr;
switch (uFlag) {
case MMAP_SETUP:
lpoTable = &mmHeader.oSetup;
hTable = hSetupTable;
break;
case MMAP_PATCH:
lpoTable = &mmHeader.oPatch;
hTable = hPatchTable;
break;
case MMAP_KEY:
lpoTable = &mmHeader.oKey;
hTable = hKeyTable;
break;
default:hTable = NULL; // Kill spurious use before set diag
lpoTable = NULL; // Kill spurious use before set diag
}
if (!uIdx)
uIdx = lpmmEntry->idxEntry;
uIdx--;
mmaperr = MmaperrFileAccess(MAP_FOPEN, OF_READWRITE);
if (mmaperr != MMAPERR_SUCCESS)
return mmaperr;
if (_llseek(iFile, 0L, 0) == -1L) {
mmaperr = MMAPERR_READ;
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
exit01: return mmaperr;
}
if ( _lread(iFile, (LPSTR)&mmHeader, sizeof(MMHEADER))
!= sizeof(MMHEADER)
) {
mmaperr = MMAPERR_READ;
goto exit00; // 00, not 01.
}
if (_llseek( iFile
, (LONG) ( *lpoTable
+ sizeof(MMTABLEHEADER)
+ uIdx * sizeof(MMTABLEENTRY)
)
, 0
) == -1L
) {
mmaperr = MMAPERR_WRITE;
goto exit00; // 00, not 01.
}
if ( _lwrite(iFile, (LPSTR)lpmmEntry, sizeof(MMTABLEENTRY))
!= sizeof(MMTABLEENTRY)
) {
mmaperr = MMAPERR_WRITE;
goto exit00; // 00, not 01.
}
mmaperr = MmaperrFileAccess(MAP_FCLOSE, 0);
if (mmaperr != MMAPERR_SUCCESS)
goto exit01;
// if the table is in memory, modify the in-memory table entry
if (hTable) {
lpmmTable = (LPMMTABLE)GlobalLock(hTable);
lpmmOldEntry = (LPMMTABLEENTRY)GlobalLock(lpmmTable->hEntrys);
lpmmOldEntry += uIdx;
*lpmmOldEntry = *lpmmEntry;
GlobalUnlock(lpmmTable->hEntrys);
GlobalUnlock(hTable);
}
return MMAPERR_SUCCESS;
} /* MmaperrWriteTabEntry */
// - - - - - - - - -
// MmaperrWriteTabHeader
//
// Write a table header.
//
// Side-effects of failure:
//
// 1. If the "close" fails something bad has happened to the file.
STATIC MMAPERR NEAR PASCAL MmaperrWriteTabHeader(
UINT uFlag,
LPMMTABLEHEADER lpmmHeader)
{
MMHEADER mmHeader;
UNALIGNED WORD *lpoTable;
MMAPERR mmaperr;
switch (uFlag) {
case MMAP_SETUP:
lpoTable = &mmHeader.oSetup;
break;
case MMAP_PATCH:
lpoTable = &mmHeader.oPatch;
break;
case MMAP_KEY:
lpoTable = &mmHeader.oKey;
break;
default:lpoTable = NULL; // Kill spurious use before set diagnostic
}
mmaperr = MmaperrFileAccess(MAP_FOPEN, OF_READWRITE);
if (mmaperr != MMAPERR_SUCCESS)
return mmaperr;
if (_llseek(iFile, 0L, 0) == -1L) {
mmaperr = MMAPERR_READ;
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return mmaperr;
}
if (_lread(iFile, (LPSTR)&mmHeader, sizeof(MMHEADER)) != sizeof(MMHEADER))
{
mmaperr = MMAPERR_READ;
goto exit00;
}
if (_llseek(iFile, (LONG)*lpoTable, 0) == -1L) {
mmaperr = MMAPERR_WRITE;
goto exit00;
}
if ( _lwrite(iFile, (LPSTR)lpmmHeader, sizeof(MMTABLEHEADER))
!= sizeof(MMTABLEHEADER)
) {
mmaperr = MMAPERR_WRITE;
goto exit00;
}
return MmaperrFileAccess(MAP_FCLOSE, 0);
} /* MmaperrWriteTabHeader */
// MmaperrGarbage
//
// Increase the garbage-byte count.
//
// Side-effects:
//
// 1. None.
STATIC MMAPERR NEAR PASCAL MmaperrGarbage(
UINT uBytes)
{
MMHEADER mmHeader;
MMAPERR mmaperr;
mmaperr = MmaperrFileAccess(MAP_FOPEN, OF_READWRITE);
if (mmaperr != MMAPERR_SUCCESS)
return mmaperr;
if (_llseek(iFile, 0L, 0) == -1L) {
mmaperr = MMAPERR_READ;
exit00: (VOID)MmaperrFileAccess(MAP_FCLOSE, 0);
return mmaperr;
}
if (_lread(iFile, (LPSTR)&mmHeader, sizeof(MMHEADER)) != sizeof(MMHEADER)) {
mmaperr = MMAPERR_READ;
goto exit00;
}
mmHeader.dwGarbage += uBytes;
if (_llseek(iFile, 0L, 0) == -1L) {
mmaperr = MMAPERR_WRITE;
goto exit00;
}
if (_lwrite(iFile, (LPSTR)&mmHeader, sizeof(MMHEADER)) != sizeof(MMHEADER)) {
mmaperr = MMAPERR_WRITE;
goto exit00;
}
return MmaperrFileAccess(MAP_FCLOSE, 0);
} /* MmaperrGarbage */
// - - - - - - - - -
//
// MmaperrFileAccess
//
// Control the global file descriptor.
//
// Returns TRUE on success, FALSE on error.
//
// Remarks:
//
// 1. Opens/closes file potentially.
// 2. Modifies "iFile".
// 3. Modifies "ucFileOpen".
MMAPERR NEAR PASCAL MmaperrFileAccess(
int iFunc, /* MAP_FOPEN, MAP_FCREATE or MAP_FCLOSE */
int iMode)
{
OFSTRUCT of;
if (!fEditing)
{
char szMapCfg[MMAP_MAXCFGNAME];
GetSystemDirectory(aszMapperPath, sizeof(aszMapperPath));
LoadString(hLibInst,IDS_MIDIMAPCFG,szMapCfg,MMAP_MAXCFGNAME);
lstrcat(aszMapperPath, szMapCfg);
}
switch (iFunc) {
case MAP_FOPEN :
if (iFile != HFILE_ERROR) {
ucFileOpen++;
break;
}
iFile = OpenFile(aszMapperPath, &of, iMode);
if (iFile == HFILE_ERROR) {
if (of.nErrCode == 0x05)
return MMAPERR_OPEN_READONLY;
else
return MMAPERR_OPEN;
}
ucFileOpen++;
break;
case MAP_FCREATE :
iFile = OpenFile(aszMapperPath, &of,iMode|OF_CREATE|OF_READWRITE);
if (iFile == HFILE_ERROR)
return MMAPERR_CREATE;
ucFileOpen++;
break;
case MAP_FCLOSE :
if (!--ucFileOpen) {
_lclose(iFile);
iFile = HFILE_ERROR;
}
break;
}
return MMAPERR_SUCCESS;
} /* MmaperrFileAccess */
// - - - - - - - - -