| /* -*- tab-width: 8; c-basic-offset: 4 -*- */ |
| |
| /* |
| * Sample MIDI Wine Driver for Linux |
| * |
| * Copyright 1994 Martin Ayotte |
| */ |
| |
| /* |
| * Eric POUECH : 98/7 changes for making this MIDI driver work on OSS |
| * current support is limited to MIDI ports of OSS systems |
| */ |
| |
| #include <errno.h> |
| #include <string.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <unistd.h> |
| #include <fcntl.h> |
| #include <sys/ioctl.h> |
| #include "windows.h" |
| #include "ldt.h" |
| #include "multimedia.h" |
| #include "user.h" |
| #include "driver.h" |
| #include "mmsystem.h" |
| #include "xmalloc.h" |
| #include "debug.h" |
| #include "callback.h" |
| #include "options.h" |
| |
| static LINUX_MIDIIN MidiInDev [MAX_MIDIINDRV ]; |
| static LINUX_MIDIOUT MidiOutDev[MAX_MIDIOUTDRV]; |
| static LINUX_MCIMIDI MCIMidiDev[MAX_MCIMIDIDRV]; |
| |
| /* this is the total number of MIDI out devices found */ |
| int MODM_NUMDEVS = 0; |
| /* this is the number of FM synthetizers (index from 0 to |
| NUMFMSYNTHDEVS - 1) */ |
| int MODM_NUMFMSYNTHDEVS = 0; |
| /* this is the number of Midi ports (index from NUMFMSYNTHDEVS to |
| NUMFMSYNTHDEVS + NUMMIDIDEVS - 1) */ |
| int MODM_NUMMIDIDEVS = 0; |
| |
| /* this is the total number of MIDI out devices found */ |
| int MIDM_NUMDEVS = 0; |
| |
| #ifdef HAVE_OSS |
| static int midiSeqFD = -1; |
| static int numOpenMidiSeq = 0; |
| static UINT32 midiInTimerID = 0; |
| static int numStartedMidiIn = 0; |
| #endif /* HAVE_OSS */ |
| |
| /* this structure holds pointers with information for each MIDI |
| * out device found. |
| */ |
| LPMIDIOUTCAPS16 midiOutDevices[MAX_MIDIOUTDRV]; |
| |
| /* this structure holds pointers with information for each MIDI |
| * in device found. |
| */ |
| LPMIDIINCAPS16 midiInDevices [MAX_MIDIINDRV]; |
| |
| /* |
| * FIXME : all tests on device ID for midXXX and modYYY are made against |
| * MAX_MIDIxxDRV (when they are made) but should be done against the actual |
| * number of midi devices found... |
| * check also when HAVE_OSS is defined that midiDesc is not NULL |
| */ |
| |
| /************************************************************************** |
| * MIDI_NotifyClient [internal] |
| */ |
| static DWORD MIDI_NotifyClient(UINT16 wDevID, WORD wMsg, |
| DWORD dwParam1, DWORD dwParam2) |
| { |
| DWORD dwCallBack; |
| UINT16 uFlags; |
| HANDLE16 hDev; |
| DWORD dwInstance; |
| |
| TRACE(midi,"wDevID = %04X wMsg = %d dwParm1 = %04lX dwParam2 = %04lX\n", |
| wDevID, wMsg, dwParam1, dwParam2); |
| |
| switch (wMsg) { |
| case MOM_OPEN: |
| case MOM_CLOSE: |
| case MOM_DONE: |
| if (wDevID > MAX_MIDIOUTDRV) |
| return MCIERR_INTERNAL; |
| |
| dwCallBack = MidiOutDev[wDevID].midiDesc->dwCallback; |
| uFlags = MidiOutDev[wDevID].wFlags; |
| hDev = MidiOutDev[wDevID].midiDesc->hMidi; |
| dwInstance = MidiOutDev[wDevID].midiDesc->dwInstance; |
| break; |
| |
| case MIM_OPEN: |
| case MIM_CLOSE: |
| case MIM_DATA: |
| case MIM_ERROR: |
| if (wDevID > MAX_MIDIINDRV) |
| return MCIERR_INTERNAL; |
| |
| dwCallBack = MidiInDev[wDevID].midiDesc->dwCallback; |
| uFlags = MidiInDev[wDevID].wFlags; |
| hDev = MidiInDev[wDevID].midiDesc->hMidi; |
| dwInstance = MidiInDev[wDevID].midiDesc->dwInstance; |
| break; |
| default: |
| WARN(midi, "Unsupported MSW-MIDI message %u\n", wMsg); |
| return MCIERR_INTERNAL; |
| } |
| |
| return DriverCallback(dwCallBack, uFlags, hDev, wMsg, dwInstance, dwParam1, dwParam2) ? |
| 0 : MCIERR_INTERNAL; |
| } |
| |
| /************************************************************************** |
| * MIDI_ReadByte [internal] |
| */ |
| static DWORD MIDI_ReadByte(UINT16 wDevID, BYTE *lpbyt) |
| { |
| if (lpbyt != NULL) { |
| if (mmioRead32(MCIMidiDev[wDevID].hFile, (HPSTR)lpbyt, |
| (long) sizeof(BYTE)) == (long) sizeof(BYTE)) { |
| return 0; |
| } |
| } |
| WARN(midi, "error reading wDevID=%04X\n", wDevID); |
| return MCIERR_INTERNAL; |
| |
| } |
| |
| /************************************************************************** |
| * MIDI_ReadWord [internal] |
| */ |
| static DWORD MIDI_ReadWord(UINT16 wDevID, LPWORD lpw) |
| { |
| BYTE hibyte, lobyte; |
| |
| if (lpw != NULL) { |
| if (MIDI_ReadByte(wDevID, &hibyte) == 0) { |
| if (MIDI_ReadByte(wDevID, &lobyte) == 0) { |
| *lpw = ((WORD)hibyte << 8) + lobyte; |
| return 0; |
| } |
| } |
| } |
| WARN(midi, "error reading wDevID=%04X\n", wDevID); |
| return MCIERR_INTERNAL; |
| } |
| |
| /************************************************************************** |
| * MIDI_ReadLong [internal] |
| */ |
| static DWORD MIDI_ReadLong(UINT16 wDevID, LPDWORD lpdw) |
| { |
| WORD hiword, loword; |
| |
| if (lpdw != NULL) { |
| if (MIDI_ReadWord(wDevID, &hiword) == 0) { |
| if (MIDI_ReadWord(wDevID, &loword) == 0) { |
| *lpdw = MAKELONG(loword, hiword); |
| return 0; |
| } |
| } |
| } |
| WARN(midi, "error reading wDevID=%04X\n", wDevID); |
| return MCIERR_INTERNAL; |
| } |
| |
| /************************************************************************** |
| * MIDI_ReadVaryLen [internal] |
| */ |
| static DWORD MIDI_ReadVaryLen(UINT16 wDevID, LPDWORD lpdw) |
| { |
| BYTE byte; |
| DWORD value; |
| |
| if (lpdw == NULL) return MCIERR_INTERNAL; |
| if (MIDI_ReadByte(wDevID, &byte) != 0) { |
| WARN(midi, "error reading wDevID=%04X\n", wDevID); |
| return MCIERR_INTERNAL; |
| } |
| value = (DWORD)(byte & 0x7F); |
| while (byte & 0x80) { |
| if (MIDI_ReadByte(wDevID, &byte) != 0) { |
| WARN(midi, "error reading wDevID=%04X\n", wDevID); |
| return MCIERR_INTERNAL; |
| } |
| value = (value << 7) + (byte & 0x7F); |
| } |
| *lpdw = value; |
| /* |
| TRACE(midi, "val=%08lX \n", value); |
| */ |
| return 0; |
| } |
| |
| /************************************************************************** |
| * MIDI_ReadMThd [internal] |
| */ |
| static DWORD MIDI_ReadMThd(UINT16 wDevID, DWORD dwOffset) |
| { |
| DWORD toberead; |
| FOURCC fourcc; |
| |
| TRACE(midi, "(%04X, %08lX);\n", wDevID, dwOffset); |
| if (mmioSeek32(MCIMidiDev[wDevID].hFile, dwOffset, SEEK_SET) != dwOffset) { |
| WARN(midi, "can't seek at %08lX begin of 'MThd' \n", dwOffset); |
| return MCIERR_INTERNAL; |
| } |
| if (mmioRead32(MCIMidiDev[wDevID].hFile, (HPSTR)&fourcc, |
| (long) sizeof(FOURCC)) != (long) sizeof(FOURCC)) |
| return MCIERR_INTERNAL; |
| if (MIDI_ReadLong(wDevID, &toberead) != 0) |
| return MCIERR_INTERNAL; |
| if (MIDI_ReadWord(wDevID, &MCIMidiDev[wDevID].wFormat) != 0) |
| return MCIERR_INTERNAL; |
| if (MIDI_ReadWord(wDevID, &MCIMidiDev[wDevID].nTracks) != 0) |
| return MCIERR_INTERNAL; |
| if (MIDI_ReadWord(wDevID, &MCIMidiDev[wDevID].nTempo) != 0) |
| return MCIERR_INTERNAL; |
| TRACE(midi, "toberead=%08lX, wFormat=%04X nTracks=%04X nTempo=%04X\n", |
| toberead, MCIMidiDev[wDevID].wFormat, |
| MCIMidiDev[wDevID].nTracks, |
| MCIMidiDev[wDevID].nTempo); |
| toberead -= 3 * sizeof(WORD); |
| /* |
| ntrks = read16bit (); |
| Mf_division = division = read16bit (); |
| */ |
| return 0; |
| } |
| |
| static DWORD MIDI_ReadMTrk(UINT16 wDevID, DWORD dwOffset) |
| { |
| DWORD toberead; |
| FOURCC fourcc; |
| |
| if (mmioSeek32(MCIMidiDev[wDevID].hFile, dwOffset, SEEK_SET) != dwOffset) { |
| WARN(midi, "can't seek at %08lX begin of 'MThd' \n", dwOffset); |
| } |
| if (mmioRead32(MCIMidiDev[wDevID].hFile, (HPSTR)&fourcc, |
| (long) sizeof(FOURCC)) != (long) sizeof(FOURCC)) { |
| return MCIERR_INTERNAL; |
| } |
| if (MIDI_ReadLong(wDevID, &toberead) != 0) { |
| return MCIERR_INTERNAL; |
| } |
| TRACE(midi, "toberead=%08lX\n", toberead); |
| toberead -= 3 * sizeof(WORD); |
| MCIMidiDev[wDevID].dwTotalLen = toberead; |
| return 0; |
| } |
| |
| /************************************************************************** |
| * MIDI_mciOpen [internal] |
| */ |
| static DWORD MIDI_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS16 lpParms) |
| { |
| MIDIOPENDESC MidiDesc; |
| DWORD dwRet; |
| DWORD dwOffset; |
| LPSTR lpstrElementName; |
| char str[128]; |
| |
| TRACE(midi, "(%08lX, %p)\n", dwFlags, lpParms); |
| if (lpParms == NULL) return MCIERR_INTERNAL; |
| |
| if (MCIMidiDev[wDevID].nUseCount > 0) { |
| /* The driver already open on this channel */ |
| /* If the driver was opened shareable before and this open specifies */ |
| /* shareable then increment the use count */ |
| if (MCIMidiDev[wDevID].fShareable && (dwFlags & MCI_OPEN_SHAREABLE)) |
| ++MCIMidiDev[wDevID].nUseCount; |
| else |
| return MCIERR_MUST_USE_SHAREABLE; |
| } else { |
| MCIMidiDev[wDevID].nUseCount = 1; |
| MCIMidiDev[wDevID].fShareable = dwFlags & MCI_OPEN_SHAREABLE; |
| MCIMidiDev[wDevID].hMidiHdr = USER_HEAP_ALLOC(sizeof(MIDIHDR)); |
| } |
| |
| TRACE(midi, "wDevID=%04X\n", wDevID); |
| /* lpParms->wDeviceID = wDevID;*/ |
| TRACE(midi, "lpParms->wDevID=%04X\n", lpParms->wDeviceID); |
| TRACE(midi, "before OPEN_ELEMENT\n"); |
| if (dwFlags & MCI_OPEN_ELEMENT) { |
| lpstrElementName = (LPSTR)PTR_SEG_TO_LIN(lpParms->lpstrElementName); |
| TRACE(midi, "MCI_OPEN_ELEMENT '%s' !\n", lpstrElementName); |
| if (strlen(lpstrElementName) > 0) { |
| strcpy(str, lpstrElementName); |
| CharUpper32A(str); |
| MCIMidiDev[wDevID].hFile = mmioOpen16(str, NULL, |
| MMIO_ALLOCBUF | MMIO_READWRITE | MMIO_EXCLUSIVE); |
| if (MCIMidiDev[wDevID].hFile == 0) { |
| WARN(midi, "can't find file='%s' !\n", str); |
| return MCIERR_FILE_NOT_FOUND; |
| } |
| } else |
| MCIMidiDev[wDevID].hFile = 0; |
| } |
| TRACE(midi, "hFile=%u\n", MCIMidiDev[wDevID].hFile); |
| memcpy(&MCIMidiDev[wDevID].openParms, lpParms, sizeof(MCI_OPEN_PARMS16)); |
| MCIMidiDev[wDevID].wNotifyDeviceID = lpParms->wDeviceID; |
| MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP; |
| MCIMidiDev[wDevID].dwBeginData = 0; |
| MCIMidiDev[wDevID].dwTotalLen = 0; |
| MidiDesc.hMidi = 0; |
| if (MCIMidiDev[wDevID].hFile != 0) { |
| MMCKINFO ckMainRIFF; |
| if (mmioDescend(MCIMidiDev[wDevID].hFile, &ckMainRIFF, NULL, 0) != 0) { |
| return MCIERR_INTERNAL; |
| } |
| TRACE(midi,"ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n", |
| (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType, |
| ckMainRIFF.cksize); |
| dwOffset = 0; |
| if (ckMainRIFF.ckid == mmioFOURCC('R', 'M', 'I', 'D')) { |
| TRACE(midi, "is a 'RMID' file \n"); |
| dwOffset = ckMainRIFF.dwDataOffset; |
| } |
| if (ckMainRIFF.ckid != mmioFOURCC('M', 'T', 'h', 'd')) { |
| WARN(midi, "unknown format !\n"); |
| return MCIERR_INTERNAL; |
| } |
| if (MIDI_ReadMThd(wDevID, dwOffset) != 0) { |
| WARN(midi, "can't read 'MThd' header \n"); |
| return MCIERR_INTERNAL; |
| } |
| dwOffset = mmioSeek32(MCIMidiDev[wDevID].hFile, 0, SEEK_CUR); |
| if (MIDI_ReadMTrk(wDevID, dwOffset) != 0) { |
| WARN(midi, "can't read 'MTrk' header \n"); |
| return MCIERR_INTERNAL; |
| } |
| dwOffset = mmioSeek32(MCIMidiDev[wDevID].hFile, 0, SEEK_CUR); |
| MCIMidiDev[wDevID].dwBeginData = dwOffset; |
| TRACE(midi, "Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n", |
| (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType, |
| ckMainRIFF.cksize); |
| } |
| |
| dwRet = modMessage(wDevID, MODM_OPEN, 0, (DWORD)&MidiDesc, CALLBACK_NULL); |
| /* dwRet = midMessage(wDevID, MIDM_OPEN, 0, (DWORD)&MidiDesc, CALLBACK_NULL);*/ |
| |
| return 0; |
| } |
| |
| /************************************************************************** |
| * MIDI_mciStop [internal] |
| */ |
| static DWORD MIDI_mciStop(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms) |
| { |
| TRACE(midi, "(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms); |
| if (lpParms == NULL) return MCIERR_INTERNAL; |
| MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP; |
| TRACE(midi, "MCIMidiDev[wDevID].dwStatus=%p %d\n", |
| &MCIMidiDev[wDevID].dwStatus, MCIMidiDev[wDevID].dwStatus); |
| return 0; |
| } |
| |
| /************************************************************************** |
| * MIDI_mciClose [internal] |
| */ |
| static DWORD MIDI_mciClose(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms) |
| { |
| DWORD dwRet; |
| |
| TRACE(midi, "(%04X, %08lX, %p);\n", wDevID, dwParam, lpParms); |
| if (MCIMidiDev[wDevID].dwStatus != MCI_MODE_STOP) { |
| MIDI_mciStop(wDevID, MCI_WAIT, lpParms); |
| } |
| MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP; |
| MCIMidiDev[wDevID].nUseCount--; |
| if (MCIMidiDev[wDevID].nUseCount == 0) { |
| if (MCIMidiDev[wDevID].hFile != 0) { |
| mmioClose32(MCIMidiDev[wDevID].hFile, 0); |
| MCIMidiDev[wDevID].hFile = 0; |
| TRACE(midi, "hFile closed !\n"); |
| } |
| USER_HEAP_FREE(MCIMidiDev[wDevID].hMidiHdr); |
| dwRet = modMessage(wDevID, MODM_CLOSE, 0, 0L, 0L); |
| if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL; |
| /* |
| dwRet = midMessage(wDevID, MIDM_CLOSE, 0, 0L, 0L); |
| if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL; |
| */ |
| } |
| return 0; |
| } |
| |
| /************************************************************************** |
| * MIDI_mciPlay [internal] |
| */ |
| static DWORD MIDI_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms) |
| { |
| int count,start,end; |
| LPMIDIHDR lpMidiHdr; |
| DWORD dwData,dwRet; |
| LPWORD ptr; |
| |
| TRACE(midi, "(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms); |
| if (MCIMidiDev[wDevID].hFile == 0) { |
| WARN(midi, "can't find file='%08lx' !\n", |
| (DWORD)MCIMidiDev[wDevID].openParms.lpstrElementName); |
| return MCIERR_FILE_NOT_FOUND; |
| } |
| start = 1; end = 99999; |
| if (dwFlags & MCI_FROM) { |
| start = lpParms->dwFrom; |
| TRACE(midi, "MCI_FROM=%d \n", start); |
| } |
| if (dwFlags & MCI_TO) { |
| end = lpParms->dwTo; |
| TRACE(midi, "MCI_TO=%d \n", end); |
| } |
| #if 0 |
| if (dwFlags & MCI_NOTIFY) { |
| TRACE(midi, "MCI_NOTIFY %08lX !\n", lpParms->dwCallback); |
| switch(fork()) { |
| case -1: |
| WARN(midi, "Can't 'fork' process !\n"); |
| break; |
| case 0: |
| TRACE(midi, "process started ! play in background ...\n"); |
| break; |
| default: |
| TRACE(midi, "process started ! return to caller...\n"); |
| return 0; |
| } |
| } |
| #endif |
| |
| lpMidiHdr = USER_HEAP_LIN_ADDR(MCIMidiDev[wDevID].hMidiHdr); |
| |
| lpMidiHdr->lpData = (LPSTR)xmalloc(1200); |
| if (lpMidiHdr->lpData == NULL) return MCIERR_INTERNAL; |
| lpMidiHdr->dwBufferLength = 1024; |
| lpMidiHdr->dwUser = 0L; |
| lpMidiHdr->dwFlags = 0L; |
| dwRet = modMessage(wDevID, MODM_PREPARE, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR)); |
| |
| /* TRACE(midi, "after MODM_PREPARE \n"); */ |
| |
| MCIMidiDev[wDevID].dwStatus = MCI_MODE_PLAY; |
| while(MCIMidiDev[wDevID].dwStatus != MCI_MODE_STOP) { |
| TRACE(midi, "MCIMidiDev[wDevID].dwStatus=%p %d\n", |
| &MCIMidiDev[wDevID].dwStatus, MCIMidiDev[wDevID].dwStatus); |
| |
| ptr = (LPWORD)lpMidiHdr->lpData; |
| for (count = 0; count < lpMidiHdr->dwBufferLength; count++) { |
| if (MIDI_ReadVaryLen(wDevID, &dwData) != 0) break; |
| *ptr = LOWORD(dwData); |
| } |
| /* |
| count = mmioRead32(MCIMidiDev[wDevID].hFile, lpMidiHdr->lpData, lpMidiHdr->dwBufferLength); |
| */ |
| TRACE(midi, "after read count = %d\n",count); |
| |
| if (count < 1) break; |
| lpMidiHdr->dwBytesRecorded = count; |
| TRACE(midi, "before MODM_LONGDATA lpMidiHdr=%p dwBytesRecorded=%lu\n", |
| lpMidiHdr, lpMidiHdr->dwBytesRecorded); |
| dwRet = modMessage(wDevID, MODM_LONGDATA, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR)); |
| if (dwRet != MMSYSERR_NOERROR) { |
| switch (dwRet) { |
| case MMSYSERR_NOTENABLED: |
| return MCIERR_DEVICE_NOT_READY; |
| |
| case MIDIERR_NODEVICE: |
| return MCIERR_INVALID_DEVICE_ID; |
| |
| case MIDIERR_UNPREPARED: |
| return MCIERR_DRIVER_INTERNAL; |
| |
| case MIDIERR_STILLPLAYING: |
| return MCIERR_SEQ_PORT_INUSE; |
| |
| case MMSYSERR_INVALPARAM: |
| return MCIERR_CANNOT_LOAD_DRIVER; |
| |
| default: |
| return MCIERR_DRIVER; |
| } |
| } |
| } |
| dwRet = modMessage(wDevID, MODM_UNPREPARE, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR)); |
| if (lpMidiHdr->lpData != NULL) { |
| free(lpMidiHdr->lpData); |
| lpMidiHdr->lpData = NULL; |
| } |
| MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP; |
| if (dwFlags & MCI_NOTIFY) { |
| TRACE(midi, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); |
| mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), |
| MCIMidiDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); |
| } |
| return 0; |
| } |
| |
| /************************************************************************** |
| * MIDI_mciRecord [internal] |
| */ |
| static DWORD MIDI_mciRecord(UINT16 wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpParms) |
| { |
| int start, end; |
| LPMIDIHDR lpMidiHdr; |
| DWORD dwRet; |
| |
| TRACE(midi, "(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms); |
| if (MCIMidiDev[wDevID].hFile == 0) { |
| WARN(midi, "can't find file='%08lx' !\n", |
| (DWORD)MCIMidiDev[wDevID].openParms.lpstrElementName); |
| return MCIERR_FILE_NOT_FOUND; |
| } |
| start = 1; end = 99999; |
| if (dwFlags & MCI_FROM) { |
| start = lpParms->dwFrom; |
| TRACE(midi, "MCI_FROM=%d \n", start); |
| } |
| if (dwFlags & MCI_TO) { |
| end = lpParms->dwTo; |
| TRACE(midi, "MCI_TO=%d \n", end); |
| } |
| lpMidiHdr = USER_HEAP_LIN_ADDR(MCIMidiDev[wDevID].hMidiHdr); |
| lpMidiHdr->lpData = (LPSTR) xmalloc(1200); |
| lpMidiHdr->dwBufferLength = 1024; |
| lpMidiHdr->dwUser = 0L; |
| lpMidiHdr->dwFlags = 0L; |
| dwRet = midMessage(wDevID, MIDM_PREPARE, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR)); |
| TRACE(midi, "after MIDM_PREPARE \n"); |
| MCIMidiDev[wDevID].dwStatus = MCI_MODE_RECORD; |
| while(MCIMidiDev[wDevID].dwStatus != MCI_MODE_STOP) { |
| TRACE(midi, "MCIMidiDev[wDevID].dwStatus=%p %d\n", |
| &MCIMidiDev[wDevID].dwStatus, MCIMidiDev[wDevID].dwStatus); |
| lpMidiHdr->dwBytesRecorded = 0; |
| dwRet = midMessage(wDevID, MIDM_START, 0, 0L, 0L); |
| TRACE(midi, "after MIDM_START lpMidiHdr=%p dwBytesRecorded=%lu\n", |
| lpMidiHdr, lpMidiHdr->dwBytesRecorded); |
| if (lpMidiHdr->dwBytesRecorded == 0) break; |
| } |
| TRACE(midi, "before MIDM_UNPREPARE \n"); |
| dwRet = midMessage(wDevID, MIDM_UNPREPARE, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR)); |
| TRACE(midi, "after MIDM_UNPREPARE \n"); |
| if (lpMidiHdr->lpData != NULL) { |
| free(lpMidiHdr->lpData); |
| lpMidiHdr->lpData = NULL; |
| } |
| MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP; |
| if (dwFlags & MCI_NOTIFY) { |
| TRACE(midi, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); |
| mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), |
| MCIMidiDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); |
| } |
| return 0; |
| } |
| |
| /************************************************************************** |
| * MIDI_mciPause [internal] |
| */ |
| static DWORD MIDI_mciPause(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms) |
| { |
| TRACE(midi, "(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms); |
| if (lpParms == NULL) return MCIERR_INTERNAL; |
| return 0; |
| } |
| |
| /************************************************************************** |
| * MIDI_mciResume [internal] |
| */ |
| static DWORD MIDI_mciResume(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms) |
| { |
| TRACE(midi, "(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms); |
| if (lpParms == NULL) return MCIERR_INTERNAL; |
| return 0; |
| } |
| |
| /************************************************************************** |
| * MIDI_mciSet [internal] |
| */ |
| static DWORD MIDI_mciSet(UINT16 wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms) |
| { |
| TRACE(midi, "(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms); |
| if (lpParms == NULL) return MCIERR_INTERNAL; |
| TRACE(midi, "dwTimeFormat=%08lX\n", lpParms->dwTimeFormat); |
| TRACE(midi, "dwAudio=%08lX\n", lpParms->dwAudio); |
| if (dwFlags & MCI_SET_TIME_FORMAT) { |
| switch (lpParms->dwTimeFormat) { |
| case MCI_FORMAT_MILLISECONDS: |
| TRACE(midi, "MCI_FORMAT_MILLISECONDS !\n"); |
| break; |
| case MCI_FORMAT_BYTES: |
| TRACE(midi, "MCI_FORMAT_BYTES !\n"); |
| break; |
| case MCI_FORMAT_SAMPLES: |
| TRACE(midi, "MCI_FORMAT_SAMPLES !\n"); |
| break; |
| default: |
| WARN(midi, "bad time format !\n"); |
| return MCIERR_BAD_TIME_FORMAT; |
| } |
| } |
| if (dwFlags & MCI_SET_VIDEO) return MCIERR_UNSUPPORTED_FUNCTION; |
| if (dwFlags & MCI_SET_DOOR_OPEN) return MCIERR_UNSUPPORTED_FUNCTION; |
| if (dwFlags & MCI_SET_DOOR_CLOSED) return MCIERR_UNSUPPORTED_FUNCTION; |
| if (dwFlags & MCI_SET_AUDIO) |
| TRACE(midi, "MCI_SET_AUDIO !\n"); |
| if (dwFlags && MCI_SET_ON) { |
| TRACE(midi, "MCI_SET_ON !\n"); |
| if (dwFlags && MCI_SET_AUDIO_LEFT) |
| TRACE(midi, "MCI_SET_AUDIO_LEFT !\n"); |
| if (dwFlags && MCI_SET_AUDIO_RIGHT) |
| TRACE(midi, "MCI_SET_AUDIO_RIGHT !\n"); |
| } |
| if (dwFlags & MCI_SET_OFF) |
| TRACE(midi, "MCI_SET_OFF !\n"); |
| if (dwFlags & MCI_SEQ_SET_MASTER) |
| TRACE(midi, "MCI_SEQ_SET_MASTER !\n"); |
| if (dwFlags & MCI_SEQ_SET_SLAVE) |
| TRACE(midi, "MCI_SEQ_SET_SLAVE !\n"); |
| if (dwFlags & MCI_SEQ_SET_OFFSET) |
| TRACE(midi, "MCI_SEQ_SET_OFFSET !\n"); |
| if (dwFlags & MCI_SEQ_SET_PORT) |
| TRACE(midi, "MCI_SEQ_SET_PORT !\n"); |
| if (dwFlags & MCI_SEQ_SET_TEMPO) |
| TRACE(midi, "MCI_SEQ_SET_TEMPO !\n"); |
| return 0; |
| } |
| |
| /************************************************************************** |
| * MIDI_mciStatus [internal] |
| */ |
| static DWORD MIDI_mciStatus(UINT16 wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms) |
| { |
| TRACE(midi, "(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms); |
| if (lpParms == NULL) return MCIERR_INTERNAL; |
| if (dwFlags & MCI_STATUS_ITEM) { |
| switch(lpParms->dwItem) { |
| case MCI_STATUS_CURRENT_TRACK: |
| lpParms->dwReturn = 1; |
| break; |
| case MCI_STATUS_LENGTH: |
| lpParms->dwReturn = 5555; |
| if (dwFlags & MCI_TRACK) { |
| lpParms->dwTrack = 1; |
| lpParms->dwReturn = 2222; |
| } |
| break; |
| case MCI_STATUS_MODE: |
| lpParms->dwReturn = MCI_MODE_STOP; |
| break; |
| case MCI_STATUS_MEDIA_PRESENT: |
| TRACE(midi, "MCI_STATUS_MEDIA_PRESENT !\n"); |
| lpParms->dwReturn = TRUE; |
| break; |
| case MCI_STATUS_NUMBER_OF_TRACKS: |
| lpParms->dwReturn = 1; |
| break; |
| case MCI_STATUS_POSITION: |
| lpParms->dwReturn = 3333; |
| if (dwFlags & MCI_STATUS_START) |
| lpParms->dwItem = 1; |
| if (dwFlags & MCI_TRACK) { |
| lpParms->dwTrack = 1; |
| lpParms->dwReturn = 777; |
| } |
| break; |
| case MCI_STATUS_READY: |
| TRACE(midi, "MCI_STATUS_READY !\n"); |
| lpParms->dwReturn = TRUE; |
| break; |
| case MCI_STATUS_TIME_FORMAT: |
| TRACE(midi, "MCI_STATUS_TIME_FORMAT !\n"); |
| lpParms->dwReturn = MCI_FORMAT_MILLISECONDS; |
| break; |
| case MCI_SEQ_STATUS_DIVTYPE: |
| TRACE(midi, "MCI_SEQ_STATUS_DIVTYPE !\n"); |
| lpParms->dwReturn = 0; |
| break; |
| case MCI_SEQ_STATUS_MASTER: |
| TRACE(midi, "MCI_SEQ_STATUS_MASTER !\n"); |
| lpParms->dwReturn = 0; |
| break; |
| case MCI_SEQ_STATUS_SLAVE: |
| TRACE(midi, "MCI_SEQ_STATUS_SLAVE !\n"); |
| lpParms->dwReturn = 0; |
| break; |
| case MCI_SEQ_STATUS_OFFSET: |
| TRACE(midi, "MCI_SEQ_STATUS_OFFSET !\n"); |
| lpParms->dwReturn = 0; |
| break; |
| case MCI_SEQ_STATUS_PORT: |
| TRACE(midi, "MCI_SEQ_STATUS_PORT !\n"); |
| lpParms->dwReturn = 0; |
| break; |
| case MCI_SEQ_STATUS_TEMPO: |
| TRACE(midi, "MCI_SEQ_STATUS_TEMPO !\n"); |
| lpParms->dwReturn = 0; |
| break; |
| default: |
| WARN(midi, "unknowm command %08lX !\n", lpParms->dwItem); |
| return MCIERR_UNRECOGNIZED_COMMAND; |
| } |
| } |
| if (dwFlags & MCI_NOTIFY) { |
| TRACE(midi, "MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); |
| mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), |
| MCIMidiDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); |
| } |
| return 0; |
| } |
| |
| /************************************************************************** |
| * MIDI_mciGetDevCaps [internal] |
| */ |
| static DWORD MIDI_mciGetDevCaps(UINT16 wDevID, DWORD dwFlags, |
| LPMCI_GETDEVCAPS_PARMS lpParms) |
| { |
| TRACE(midi, "(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms); |
| if (lpParms == NULL) return MCIERR_INTERNAL; |
| if (dwFlags & MCI_GETDEVCAPS_ITEM) { |
| switch(lpParms->dwItem) { |
| case MCI_GETDEVCAPS_CAN_RECORD: |
| lpParms->dwReturn = TRUE; |
| break; |
| case MCI_GETDEVCAPS_HAS_AUDIO: |
| lpParms->dwReturn = TRUE; |
| break; |
| case MCI_GETDEVCAPS_HAS_VIDEO: |
| lpParms->dwReturn = FALSE; |
| break; |
| case MCI_GETDEVCAPS_DEVICE_TYPE: |
| lpParms->dwReturn = MCI_DEVTYPE_SEQUENCER; |
| break; |
| case MCI_GETDEVCAPS_USES_FILES: |
| lpParms->dwReturn = TRUE; |
| break; |
| case MCI_GETDEVCAPS_COMPOUND_DEVICE: |
| lpParms->dwReturn = TRUE; |
| break; |
| case MCI_GETDEVCAPS_CAN_EJECT: |
| lpParms->dwReturn = FALSE; |
| break; |
| case MCI_GETDEVCAPS_CAN_PLAY: |
| lpParms->dwReturn = TRUE; |
| break; |
| case MCI_GETDEVCAPS_CAN_SAVE: |
| lpParms->dwReturn = FALSE; |
| break; |
| default: |
| return MCIERR_UNRECOGNIZED_COMMAND; |
| } |
| } |
| return 0; |
| } |
| |
| /************************************************************************** |
| * MIDI_mciInfo [internal] |
| */ |
| static DWORD MIDI_mciInfo(UINT16 wDevID, DWORD dwFlags, LPMCI_INFO_PARMS16 lpParms) |
| { |
| TRACE(midi, "(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms); |
| if (lpParms == NULL) return MCIERR_INTERNAL; |
| lpParms->lpstrReturn = NULL; |
| switch(dwFlags) { |
| case MCI_INFO_PRODUCT: |
| lpParms->lpstrReturn = "Linux Sound System 0.5"; |
| break; |
| case MCI_INFO_FILE: |
| lpParms->lpstrReturn = "FileName"; |
| break; |
| default: |
| return MCIERR_UNRECOGNIZED_COMMAND; |
| } |
| if (lpParms->lpstrReturn != NULL) |
| lpParms->dwRetSize = strlen(lpParms->lpstrReturn); |
| else |
| lpParms->dwRetSize = 0; |
| return 0; |
| } |
| |
| /*-----------------------------------------------------------------------*/ |
| |
| #ifdef HAVE_OSS |
| /************************************************************************** |
| * midiOpenSeq [internal] |
| */ |
| static int midiOpenSeq(void) |
| { |
| if (numOpenMidiSeq == 0) { |
| midiSeqFD = open(MIDI_SEQ, O_RDWR, 0); |
| if (midiSeqFD == -1) { |
| ERR(midi, "can't open '%s' ! (%d)\n", MIDI_SEQ, errno); |
| return -1; |
| } |
| if (fcntl(midiSeqFD, F_SETFL, O_NONBLOCK) < 0) { |
| WARN(midi, "can't set sequencer fd to non blocking (%d)\n", errno); |
| close(midiSeqFD); |
| midiSeqFD = -1; |
| return -1; |
| } |
| ioctl(midiSeqFD, SNDCTL_SEQ_RESET); |
| } |
| numOpenMidiSeq++; |
| return 0; |
| } |
| |
| /************************************************************************** |
| * midiCloseSeq [internal] |
| */ |
| static int midiCloseSeq(void) |
| { |
| if (--numOpenMidiSeq == 0) { |
| close(midiSeqFD); |
| midiSeqFD = -1; |
| } |
| return 0; |
| } |
| |
| /* FIXME: this is a bad idea, it's even not static... */ |
| SEQ_DEFINEBUF(1024); |
| |
| /* FIXME: this is not reentrant, not static - because of global variable |
| * _seqbuf and al. */ |
| /************************************************************************** |
| * seqbuf_dump [internal] |
| */ |
| void seqbuf_dump(void) |
| { |
| if (_seqbufptr) { |
| if (write(midiSeqFD, _seqbuf, _seqbufptr) == -1) { |
| WARN(midi, "Can't write data to sequencer (%d/%d)!\n", |
| midiSeqFD, errno); |
| } |
| /* FIXME: |
| * in any case buffer is lost so that if many errors occur the buffer |
| * will not overrun |
| */ |
| _seqbufptr = 0; |
| } |
| } |
| #endif /* HAVE_OSS */ |
| |
| #ifdef HAVE_OSS |
| |
| static void midReceiveChar(WORD wDevID, unsigned char value, DWORD dwTime) |
| { |
| DWORD toSend = 0; |
| |
| TRACE(midi, "Adding %02xh to %d[%d]\n", |
| value, wDevID, MidiInDev[wDevID].incLen); |
| |
| if (wDevID >= MAX_MIDIINDRV) { |
| WARN(midi, "bad devID\n"); |
| return; |
| } |
| if (MidiInDev[wDevID].state == 0) { |
| TRACE(midi, "input not started, thrown away\n"); |
| return; |
| } |
| |
| if (MidiInDev[wDevID].state & 2) { /* system exclusive */ |
| LPMIDIHDR ptr = MidiInDev[wDevID].lpQueueHdr; |
| WORD sbfb = FALSE; |
| |
| if (ptr) { |
| ((LPSTR)(ptr->reserved))[ptr->dwBytesRecorded++] = value; |
| if (ptr->dwBytesRecorded == ptr->dwBufferLength) { |
| sbfb = TRUE; |
| } |
| } |
| if (value == 0xF7) { /* then end */ |
| MidiInDev[wDevID].state &= ~2; |
| sbfb = TRUE; |
| } |
| if (sbfb && ptr != NULL) { |
| ptr = MidiInDev[wDevID].lpQueueHdr; |
| ptr->dwFlags &= ~MHDR_INQUEUE; |
| ptr->dwFlags |= MHDR_DONE; |
| MidiInDev[wDevID].lpQueueHdr = (LPMIDIHDR)ptr->lpNext; |
| if (MIDI_NotifyClient(wDevID, MIM_LONGDATA, (DWORD)ptr, dwTime) != MMSYSERR_NOERROR) { |
| WARN(midi, "Couldn't notify client\n"); |
| } |
| } |
| return; |
| } |
| |
| #define IS_CMD(_x) (((_x) & 0x80) == 0x80) |
| #define IS_SYS_CMD(_x) (((_x) & 0xF0) == 0xF0) |
| |
| if (!IS_CMD(value) && MidiInDev[wDevID].incLen == 0) { /* try to reuse old cmd */ |
| if (IS_CMD(MidiInDev[wDevID].incPrev) && !IS_SYS_CMD(MidiInDev[wDevID].incPrev)) { |
| MidiInDev[wDevID].incoming[0] = MidiInDev[wDevID].incPrev; |
| MidiInDev[wDevID].incLen = 1; |
| TRACE(midi, "Reusing old command %02xh\n", MidiInDev[wDevID].incPrev); |
| } else { |
| FIXME(midi, "error for midi-in, should generate MIM_ERROR notification:" |
| " prev=%02Xh, incLen=%02Xh\n", |
| MidiInDev[wDevID].incPrev, MidiInDev[wDevID].incLen); |
| return; |
| } |
| } |
| MidiInDev[wDevID].incoming[(int)(MidiInDev[wDevID].incLen++)] = value; |
| if (MidiInDev[wDevID].incLen == 1 && !IS_SYS_CMD(MidiInDev[wDevID].incoming[0])) { |
| /* store new cmd, just in case */ |
| MidiInDev[wDevID].incPrev = MidiInDev[wDevID].incoming[0]; |
| } |
| |
| #undef IS_CMD(_x) |
| #undef IS_SYS_CMD(_x) |
| |
| switch (MidiInDev[wDevID].incoming[0] & 0xF0) { |
| case MIDI_NOTEOFF: |
| case MIDI_NOTEON: |
| case MIDI_KEY_PRESSURE: |
| case MIDI_CTL_CHANGE: |
| case MIDI_PITCH_BEND: |
| if (MidiInDev[wDevID].incLen == 3) { |
| toSend = (MidiInDev[wDevID].incoming[2] << 16) | |
| (MidiInDev[wDevID].incoming[1] << 8) | |
| (MidiInDev[wDevID].incoming[0] << 0); |
| } |
| break; |
| case MIDI_PGM_CHANGE: |
| case MIDI_CHN_PRESSURE: |
| if (MidiInDev[wDevID].incLen == 2) { |
| toSend = (MidiInDev[wDevID].incoming[1] << 8) | |
| (MidiInDev[wDevID].incoming[0] << 0); |
| } |
| break; |
| case MIDI_SYSTEM_PREFIX: |
| if (MidiInDev[wDevID].incoming[0] == 0xF0) { |
| MidiInDev[wDevID].state |= 2; |
| MidiInDev[wDevID].incLen = 0; |
| } else { |
| if (MidiInDev[wDevID].incLen == 1) { |
| toSend = (MidiInDev[wDevID].incoming[0] << 0); |
| } |
| } |
| break; |
| default: |
| WARN(midi, "This shouldn't happen (%02X)\n", MidiInDev[wDevID].incoming[0]); |
| } |
| if (toSend != 0) { |
| TRACE(midi, "Sending event %08lx\n", toSend); |
| MidiInDev[wDevID].incLen = 0; |
| dwTime -= MidiInDev[wDevID].startTime; |
| if (MIDI_NotifyClient(wDevID, MIM_DATA, toSend, dwTime) != MMSYSERR_NOERROR) { |
| WARN(midi, "Couldn't notify client\n"); |
| } |
| } |
| } |
| |
| static VOID midTimeCallback(HWND32 hwnd, UINT32 msg, UINT32 id, DWORD dwTime) |
| { |
| unsigned char buffer[256]; |
| int len, idx; |
| |
| TRACE(midi, "(%04X, %d, %d, %lu)\n", hwnd, msg, id, dwTime); |
| |
| len = read(midiSeqFD, buffer, sizeof(buffer)); |
| |
| if ((len % 4) != 0) { |
| WARN(midi, "bad length %d (%d)\n", len, errno); |
| return; |
| } |
| |
| for (idx = 0; idx < len; ) { |
| if (buffer[idx] & 0x80) { |
| TRACE(midi, |
| "reading<8> %02x %02x %02x %02x %02x %02x %02x %02x\n", |
| buffer[idx + 0], buffer[idx + 1], |
| buffer[idx + 2], buffer[idx + 3], |
| buffer[idx + 4], buffer[idx + 5], |
| buffer[idx + 6], buffer[idx + 7]); |
| idx += 8; |
| } else { |
| switch (buffer[idx + 0]) { |
| case SEQ_WAIT: |
| case SEQ_ECHO: |
| break; |
| case SEQ_MIDIPUTC: |
| midReceiveChar(buffer[idx + 2], buffer[idx + 1], dwTime); |
| break; |
| default: |
| TRACE(midi, "Unsupported event %d\n", buffer[idx + 0]); |
| break; |
| } |
| idx += 4; |
| } |
| } |
| } |
| #endif /* HAVE_OSS */ |
| |
| /************************************************************************** |
| * midGetDevCaps [internal] |
| */ |
| static DWORD midGetDevCaps(WORD wDevID, LPMIDIINCAPS16 lpCaps, DWORD dwSize) |
| { |
| LPMIDIINCAPS16 tmplpCaps; |
| |
| TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpCaps, dwSize); |
| |
| if (wDevID >= MIDM_NUMDEVS) { |
| return MMSYSERR_BADDEVICEID; |
| } |
| if (lpCaps == NULL) { |
| return MMSYSERR_INVALPARAM; |
| } |
| |
| tmplpCaps = midiInDevices[wDevID]; |
| lpCaps->wMid = tmplpCaps->wMid; |
| lpCaps->wPid = tmplpCaps->wPid; |
| lpCaps->vDriverVersion = tmplpCaps->vDriverVersion; |
| strcpy(lpCaps->szPname, tmplpCaps->szPname); |
| if (dwSize == sizeof(MIDIINCAPS16)) { |
| /* we should run win 95, so make use of dwSupport */ |
| lpCaps->dwSupport = tmplpCaps->dwSupport; |
| } else if (dwSize != sizeof(MIDIINCAPS16) - sizeof(DWORD)) { |
| TRACE(midi, "bad size for lpCaps\n"); |
| return MMSYSERR_INVALPARAM; |
| } |
| |
| return MMSYSERR_NOERROR; |
| } |
| |
| /************************************************************************** |
| * midOpen [internal] |
| */ |
| static DWORD midOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags) |
| { |
| TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpDesc, dwFlags); |
| |
| if (lpDesc == NULL) { |
| WARN(midi, "Invalid Parameter !\n"); |
| return MMSYSERR_INVALPARAM; |
| } |
| /* FIXME : |
| * how to check that content of lpDesc is correct ? |
| */ |
| if (wDevID >= MAX_MIDIINDRV) { |
| WARN(midi,"wDevID too large (%u) !\n", wDevID); |
| return MMSYSERR_BADDEVICEID; |
| } |
| if (MidiInDev[wDevID].midiDesc != 0) { |
| WARN(midi, "device already open !\n"); |
| return MMSYSERR_ALLOCATED; |
| } |
| if ((dwFlags & ~CALLBACK_TYPEMASK) != 0) { |
| FIXME(midi, "No support for MIDI_IO_STATUS in dwFlags\n"); |
| return MMSYSERR_INVALFLAG; |
| } |
| |
| #ifdef HAVE_OSS |
| if (midiOpenSeq() < 0) { |
| return MMSYSERR_ERROR; |
| } |
| |
| if (numStartedMidiIn++ == 0) { |
| midiInTimerID = SetTimer32(0, 0, 250, midTimeCallback); |
| if (!midiInTimerID) { |
| numStartedMidiIn = 0; |
| WARN(midi, "Couldn't start timer for midi-in\n"); |
| midiCloseSeq(); |
| return MMSYSERR_ERROR; |
| } |
| TRACE(midi, "Starting timer (%u) for midi-in\n", midiInTimerID); |
| } |
| #else /* HAVE_OSS */ |
| { |
| int midi = open(MIDI_DEV, O_WRONLY, 0); |
| |
| MidiInDev[wDevID].unixdev = 0; |
| if (midi == -1) { |
| WARN(midi,"can't open '%s' (%d)!\n", MIDI_DEV, errno); |
| return MMSYSERR_ALLOCATED; |
| } |
| MidiInDev[wDevID].unixdev = midi; |
| } |
| #endif /* HAVE_OSS */ |
| |
| MidiInDev[wDevID].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK); |
| switch(MidiInDev[wDevID].wFlags) { |
| case DCB_NULL: |
| TRACE(midi,"CALLBACK_NULL !\n"); |
| break; |
| case DCB_WINDOW: |
| TRACE(midi, "CALLBACK_WINDOW !\n"); |
| break; |
| case DCB_TASK: |
| TRACE(midi, "CALLBACK_TASK !\n"); |
| break; |
| case DCB_FUNCTION: |
| TRACE(midi, "CALLBACK_FUNCTION (%08lX)!\n", lpDesc->dwCallback); |
| break; |
| } |
| MidiInDev[wDevID].lpQueueHdr = NULL; |
| MidiInDev[wDevID].dwTotalPlayed = 0; |
| MidiInDev[wDevID].bufsize = 0x3FFF; |
| MidiInDev[wDevID].midiDesc = lpDesc; |
| MidiInDev[wDevID].state = 0; |
| #ifdef HAVE_OSS |
| MidiInDev[wDevID].incLen = 0; |
| MidiInDev[wDevID].startTime = 0; |
| #endif /* HAVE_OSS */ |
| if (MIDI_NotifyClient(wDevID, MIM_OPEN, 0L, 0L) != MMSYSERR_NOERROR) { |
| WARN(midi,"can't notify client !\n"); |
| return MMSYSERR_INVALPARAM; |
| } |
| return MMSYSERR_NOERROR; |
| } |
| |
| /************************************************************************** |
| * midClose [internal] |
| */ |
| static DWORD midClose(WORD wDevID) |
| { |
| int ret = MMSYSERR_NOERROR; |
| |
| TRACE(midi, "(%04X);\n", wDevID); |
| |
| if (wDevID >= MAX_MIDIINDRV) { |
| WARN(midi,"wDevID too bif (%u) !\n", wDevID); |
| return MMSYSERR_BADDEVICEID; |
| } |
| if (MidiInDev[wDevID].midiDesc == 0) { |
| WARN(midi, "device not opened !\n"); |
| return MMSYSERR_ERROR; |
| } |
| if (MidiInDev[wDevID].lpQueueHdr != 0) { |
| return MIDIERR_STILLPLAYING; |
| } |
| |
| #ifdef HAVE_OSS |
| if (midiSeqFD == -1) { |
| WARN(midi,"ooops !\n"); |
| return MMSYSERR_ERROR; |
| } |
| if (--numStartedMidiIn == 0) { |
| TRACE(midi, "Stopping timer for midi-in\n"); |
| if (!KillTimer32(0, midiInTimerID)) { |
| WARN(midi, "Couldn't stop timer for midi-in\n"); |
| } |
| midiInTimerID = 0; |
| } |
| midiCloseSeq(); |
| #else /* HAVE_OSS */ |
| if (MidiInDev[wDevID].unixdev == 0) { |
| WARN(midi,"ooops !\n"); |
| return MMSYSERR_ERROR; |
| } |
| close(MidiInDev[wDevID].unixdev); |
| MidiInDev[wDevID].unixdev = 0; |
| #endif /* HAVE_OSS */ |
| MidiInDev[wDevID].bufsize = 0; |
| if (MIDI_NotifyClient(wDevID, MIM_CLOSE, 0L, 0L) != MMSYSERR_NOERROR) { |
| WARN(midi,"can't notify client !\n"); |
| ret = MMSYSERR_INVALPARAM; |
| } |
| MidiInDev[wDevID].midiDesc = 0; |
| return ret; |
| } |
| |
| /************************************************************************** |
| * midAddBuffer [internal] |
| */ |
| static DWORD midAddBuffer(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize) |
| { |
| TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize); |
| |
| if (lpMidiHdr == NULL) return MMSYSERR_INVALPARAM; |
| if (sizeof(MIDIHDR) != dwSize) return MMSYSERR_INVALPARAM; |
| if (lpMidiHdr->dwBufferLength == 0) return MMSYSERR_INVALPARAM; |
| if (lpMidiHdr->dwFlags & MHDR_INQUEUE) return MIDIERR_STILLPLAYING; |
| if (!(lpMidiHdr->dwFlags & MHDR_PREPARED)) return MIDIERR_UNPREPARED; |
| |
| if (MidiInDev[wDevID].lpQueueHdr == 0) { |
| MidiInDev[wDevID].lpQueueHdr = lpMidiHdr; |
| } else { |
| LPMIDIHDR ptr; |
| |
| for (ptr = MidiInDev[wDevID].lpQueueHdr; |
| ptr->lpNext != 0; |
| ptr = (LPMIDIHDR)ptr->lpNext); |
| ptr->lpNext = (struct midihdr_tag*)lpMidiHdr; |
| } |
| return MMSYSERR_NOERROR; |
| } |
| |
| /************************************************************************** |
| * midPrepare [internal] |
| */ |
| static DWORD midPrepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize) |
| { |
| TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize); |
| |
| if (dwSize != sizeof(MIDIHDR) || lpMidiHdr == 0 || |
| lpMidiHdr->lpData == 0 || lpMidiHdr->dwFlags != 0 || |
| lpMidiHdr->dwBufferLength >= 0x10000ul) |
| return MMSYSERR_INVALPARAM; |
| |
| lpMidiHdr->lpNext = 0; |
| lpMidiHdr->dwFlags |= MHDR_PREPARED; |
| lpMidiHdr->dwBytesRecorded = 0; |
| |
| return MMSYSERR_NOERROR; |
| } |
| |
| /************************************************************************** |
| * midUnprepare [internal] |
| */ |
| static DWORD midUnprepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize) |
| { |
| TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize); |
| |
| if (dwSize != sizeof(MIDIHDR) || lpMidiHdr == 0 || |
| lpMidiHdr->lpData == 0 || lpMidiHdr->dwBufferLength >= 0x10000ul) |
| return MMSYSERR_INVALPARAM; |
| |
| if (!(lpMidiHdr->dwFlags & MHDR_PREPARED)) return MIDIERR_UNPREPARED; |
| if (lpMidiHdr->dwFlags & MHDR_INQUEUE) return MIDIERR_STILLPLAYING; |
| |
| lpMidiHdr->dwFlags &= ~MHDR_PREPARED; |
| |
| return MMSYSERR_NOERROR; |
| } |
| |
| /************************************************************************** |
| * midReset [internal] |
| */ |
| static DWORD midReset(WORD wDevID) |
| { |
| DWORD dwTime = GetTickCount(); |
| |
| TRACE(midi, "(%04X);\n", wDevID); |
| |
| while (MidiInDev[wDevID].lpQueueHdr) { |
| MidiInDev[wDevID].lpQueueHdr->dwFlags &= ~MHDR_INQUEUE; |
| MidiInDev[wDevID].lpQueueHdr->dwFlags |= MHDR_DONE; |
| if (MIDI_NotifyClient(wDevID, MIM_LONGDATA, |
| (DWORD)MidiInDev[wDevID].lpQueueHdr, dwTime) != MMSYSERR_NOERROR) { |
| WARN(midi, "Couldn't notify client\n"); |
| } |
| MidiInDev[wDevID].lpQueueHdr = (LPMIDIHDR)MidiInDev[wDevID].lpQueueHdr->lpNext; |
| } |
| |
| return MMSYSERR_NOERROR; |
| } |
| |
| |
| /************************************************************************** |
| * midStart [internal] |
| */ |
| static DWORD midStart(WORD wDevID) |
| { |
| TRACE(midi, "(%04X);\n", wDevID); |
| |
| /* FIXME : should test value of wDevID */ |
| |
| #ifdef HAVE_OSS |
| MidiInDev[wDevID].state = 1; |
| MidiInDev[wDevID].startTime = GetTickCount(); |
| return MMSYSERR_NOERROR; |
| #else |
| return MMSYSERR_NOTENABLED; |
| #endif /* HAVE_OSS */ |
| } |
| |
| /************************************************************************** |
| * midStop [internal] |
| */ |
| static DWORD midStop(WORD wDevID) |
| { |
| TRACE(midi, "(%04X);\n", wDevID); |
| |
| /* FIXME : should test value of wDevID */ |
| |
| #ifdef HAVE_OSS |
| MidiInDev[wDevID].state = 0; |
| return MMSYSERR_NOERROR; |
| #else /* HAVE_OSS */ |
| return MMSYSERR_NOTENABLED; |
| #endif /* HAVE_OSS */ |
| } |
| |
| /************************************************************************** |
| * midMessage [sample driver] |
| */ |
| DWORD WINAPI midMessage(WORD wDevID, WORD wMsg, DWORD dwUser, |
| DWORD dwParam1, DWORD dwParam2) |
| { |
| TRACE(midi, "(%04X, %04X, %08lX, %08lX, %08lX);\n", |
| wDevID, wMsg, dwUser, dwParam1, dwParam2); |
| switch(wMsg) { |
| case MIDM_OPEN: |
| return midOpen(wDevID,(LPMIDIOPENDESC)dwParam1, dwParam2); |
| case MIDM_CLOSE: |
| return midClose(wDevID); |
| case MIDM_ADDBUFFER: |
| return midAddBuffer(wDevID,(LPMIDIHDR)dwParam1, dwParam2); |
| case MIDM_PREPARE: |
| return midPrepare(wDevID,(LPMIDIHDR)dwParam1, dwParam2); |
| case MIDM_UNPREPARE: |
| return midUnprepare(wDevID,(LPMIDIHDR)dwParam1, dwParam2); |
| case MIDM_GETDEVCAPS: |
| return midGetDevCaps(wDevID,(LPMIDIINCAPS16)dwParam1,dwParam2); |
| case MIDM_GETNUMDEVS: |
| return MIDM_NUMDEVS; |
| case MIDM_RESET: |
| return midReset(wDevID); |
| case MIDM_START: |
| return midStart(wDevID); |
| case MIDM_STOP: |
| return midStop(wDevID); |
| default: |
| TRACE(midi, "Unsupported message\n"); |
| } |
| return MMSYSERR_NOTSUPPORTED; |
| } |
| |
| /*-----------------------------------------------------------------------*/ |
| |
| #ifdef HAVE_OSS |
| |
| typedef struct sVoice { |
| int note; /* 0 means not used */ |
| int channel; |
| unsigned cntMark : 30, |
| status : 2; |
| #define sVS_UNUSED 0 |
| #define sVS_PLAYING 1 |
| #define sVS_SUSTAINED 2 |
| } sVoice; |
| |
| typedef struct sChannel { |
| int program; |
| |
| int bender; |
| int benderRange; |
| /* controlers */ |
| int bank; /* CTL_BANK_SELECT */ |
| int volume; /* CTL_MAIN_VOLUME */ |
| int balance; /* CTL_BALANCE */ |
| int expression; /* CTL_EXPRESSION */ |
| int sustain; /* CTL_SUSTAIN */ |
| |
| unsigned char nrgPmtMSB; /* Non register Parameters */ |
| unsigned char nrgPmtLSB; |
| unsigned char regPmtMSB; /* Non register Parameters */ |
| unsigned char regPmtLSB; |
| } sChannel; |
| |
| typedef struct sFMextra { |
| unsigned counter; |
| int drumSetMask; |
| sChannel channel[16]; /* MIDI has only 16 channels */ |
| sVoice voice[1]; /* dyn allocated according to sound card */ |
| /* do not append fields below voice[1] since the size of this structure |
| * depends on the number of available voices on the FM synth... |
| */ |
| } sFMextra; |
| |
| extern unsigned char midiFMInstrumentPatches[16 * 128]; |
| extern unsigned char midiFMDrumsPatches [16 * 128]; |
| |
| /************************************************************************** |
| * modFMLoad [internal] |
| */ |
| static int modFMLoad(int dev) |
| { |
| int i; |
| struct sbi_instrument sbi; |
| |
| sbi.device = dev; |
| sbi.key = FM_PATCH; |
| |
| memset(sbi.operators + 16, 0, 16); |
| for (i = 0; i < 128; i++) { |
| sbi.channel = i; |
| memcpy(sbi.operators, midiFMInstrumentPatches + i * 16, 16); |
| |
| if (write(midiSeqFD, (char*)&sbi, sizeof(sbi)) == -1) { |
| WARN(midi, "Couldn't write patch for instrument %d (%d)!\n", sbi.channel, errno); |
| return -1; |
| } |
| } |
| for (i = 0; i < 128; i++) { |
| sbi.channel = 128 + i; |
| memcpy(sbi.operators, midiFMDrumsPatches + i * 16, 16); |
| |
| if (write(midiSeqFD, (char*)&sbi, sizeof(sbi)) == -1) { |
| WARN(midi, "Couldn't write patch for drum %d (%d)!\n", sbi.channel, errno); |
| return -1; |
| } |
| } |
| return 0; |
| } |
| |
| /************************************************************************** |
| * modFMReset [internal] |
| */ |
| static void modFMReset(WORD wDevID) |
| { |
| sFMextra* extra = (sFMextra*)MidiOutDev[wDevID].lpExtra; |
| sVoice* voice = extra->voice; |
| sChannel* channel = extra->channel; |
| int i; |
| |
| for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) { |
| if (voice[i].status != sVS_UNUSED) { |
| SEQ_STOP_NOTE(wDevID, i, voice[i].note, 64); |
| } |
| SEQ_KEY_PRESSURE(wDevID, i, 127, 0); |
| SEQ_CONTROL(wDevID, i, SEQ_VOLMODE, VOL_METHOD_LINEAR); |
| voice[i].note = 0; |
| voice[i].channel = -1; |
| voice[i].cntMark = 0; |
| voice[i].status = sVS_UNUSED; |
| } |
| for (i = 0; i < 16; i++) { |
| channel[i].program = 0; |
| channel[i].bender = 8192; |
| channel[i].benderRange = 2; |
| channel[i].bank = 0; |
| channel[i].volume = 127; |
| channel[i].balance = 64; |
| channel[i].expression = 0; |
| channel[i].sustain = 0; |
| } |
| extra->counter = 0; |
| extra->drumSetMask = 1 << 9; /* channel 10 is normally drums, sometimes 16 also */ |
| SEQ_DUMPBUF(); |
| } |
| |
| #define IS_DRUM_CHANNEL(_xtra, _chn) ((_xtra)->drumSetMask & (1 << (_chn))) |
| |
| #endif /* HAVE_OSS */ |
| |
| /************************************************************************** |
| * modGetDevCaps [internal] |
| */ |
| static DWORD modGetDevCaps(WORD wDevID, LPMIDIOUTCAPS16 lpCaps, |
| DWORD dwSize) |
| { |
| TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpCaps, dwSize); |
| if (wDevID == (WORD) MIDI_MAPPER) { |
| lpCaps->wMid = 0x00FF; /* Manufac ID */ |
| lpCaps->wPid = 0x0001; /* Product ID */ |
| lpCaps->vDriverVersion = 0x001; /* Product Version */ |
| strcpy(lpCaps->szPname, "MIDI Mapper (not functional yet)"); |
| /* FIXME Does it make any difference ? */ |
| lpCaps->wTechnology = MOD_FMSYNTH; |
| lpCaps->wVoices = 14; /* FIXME */ |
| lpCaps->wNotes = 14; /* FIXME */ |
| /* FIXME Does it make any difference ? */ |
| lpCaps->dwSupport = MIDICAPS_VOLUME|MIDICAPS_LRVOLUME; |
| } else { |
| LPMIDIOUTCAPS16 tmplpCaps; |
| |
| if (wDevID >= MODM_NUMDEVS) { |
| TRACE(midi, "MAX_MIDIOUTDRV reached !\n"); |
| return MMSYSERR_BADDEVICEID; |
| } |
| /* FIXME There is a way to do it so easily, but I'm too |
| * sleepy to think and I want to test |
| */ |
| |
| tmplpCaps = midiOutDevices[wDevID]; |
| lpCaps->wMid = tmplpCaps->wMid; |
| lpCaps->wPid = tmplpCaps->wPid; |
| lpCaps->vDriverVersion = tmplpCaps->vDriverVersion; |
| strcpy(lpCaps->szPname, tmplpCaps->szPname); |
| lpCaps->wTechnology = tmplpCaps->wTechnology; |
| lpCaps->wVoices = tmplpCaps->wVoices; |
| lpCaps->wNotes = tmplpCaps->wNotes; |
| lpCaps->dwSupport = tmplpCaps->dwSupport; |
| } |
| return MMSYSERR_NOERROR; |
| } |
| |
| /************************************************************************** |
| * modOpen [internal] |
| */ |
| static DWORD modOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags) |
| { |
| TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpDesc, dwFlags); |
| if (lpDesc == NULL) { |
| WARN(midi, "Invalid Parameter !\n"); |
| return MMSYSERR_INVALPARAM; |
| } |
| if (wDevID >= MAX_MIDIOUTDRV) { |
| TRACE(midi,"MAX_MIDIOUTDRV reached !\n"); |
| return MMSYSERR_BADDEVICEID; |
| } |
| if (MidiOutDev[wDevID].midiDesc != 0) { |
| WARN(midi, "device already open !\n"); |
| return MMSYSERR_ALLOCATED; |
| } |
| if ((dwFlags & ~CALLBACK_TYPEMASK) != 0) { |
| WARN(midi, "bad dwFlags\n"); |
| return MMSYSERR_INVALFLAG; |
| } |
| |
| #ifdef HAVE_OSS |
| MidiOutDev[wDevID].lpExtra = 0; |
| |
| switch (midiOutDevices[wDevID]->wTechnology) { |
| case MOD_FMSYNTH: |
| { |
| void* extra = xmalloc(sizeof(struct sFMextra) + |
| sizeof(struct sVoice) * |
| (midiOutDevices[wDevID]->wVoices - 1)); |
| |
| if (extra == 0) { |
| WARN(midi, "can't alloc extra data !\n"); |
| return MMSYSERR_NOMEM; |
| } |
| MidiOutDev[wDevID].lpExtra = extra; |
| if (midiOpenSeq() < 0) { |
| MidiOutDev[wDevID].lpExtra = 0; |
| free(extra); |
| return MMSYSERR_ERROR; |
| } |
| if (modFMLoad(wDevID) < 0) { |
| midiCloseSeq(); |
| MidiOutDev[wDevID].lpExtra = 0; |
| free(extra); |
| return MMSYSERR_ERROR; |
| } |
| modFMReset(wDevID); |
| } |
| break; |
| case MOD_MIDIPORT: |
| if (midiOpenSeq() < 0) { |
| return MMSYSERR_ALLOCATED; |
| } |
| break; |
| default: |
| WARN(midi,"Technology not supported (yet) %d !\n", |
| midiOutDevices[wDevID]->wTechnology); |
| return MMSYSERR_NOTENABLED; |
| } |
| #else /* HAVE_OSS */ |
| { |
| int midi = open (MIDI_DEV, O_WRONLY, 0); |
| MidiOutDev[wDevID].unixdev = 0; |
| if (midi == -1) { |
| WARN(midi, "can't open !\n"); |
| return MMSYSERR_ALLOCATED; |
| } |
| MidiOutDev[wDevID].unixdev = midi; |
| } |
| #endif /* HAVE_OSS */ |
| |
| MidiOutDev[wDevID].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK); |
| switch(MidiOutDev[wDevID].wFlags) { |
| case DCB_NULL: |
| TRACE(midi,"CALLBACK_NULL !\n"); |
| break; |
| case DCB_WINDOW: |
| TRACE(midi, "CALLBACK_WINDOW !\n"); |
| break; |
| case DCB_TASK: |
| TRACE(midi, "CALLBACK_TASK !\n"); |
| break; |
| case DCB_FUNCTION: |
| TRACE(midi, "CALLBACK_FUNCTION !\n"); |
| break; |
| } |
| MidiOutDev[wDevID].lpQueueHdr = NULL; |
| MidiOutDev[wDevID].dwTotalPlayed = 0; |
| MidiOutDev[wDevID].bufsize = 0x3FFF; |
| MidiOutDev[wDevID].midiDesc = lpDesc; |
| |
| if (MIDI_NotifyClient(wDevID, MOM_OPEN, 0L, 0L) != MMSYSERR_NOERROR) { |
| WARN(midi,"can't notify client !\n"); |
| return MMSYSERR_INVALPARAM; |
| } |
| TRACE(midi, "Succesful !\n"); |
| return MMSYSERR_NOERROR; |
| } |
| |
| |
| /************************************************************************** |
| * modClose [internal] |
| */ |
| static DWORD modClose(WORD wDevID) |
| { |
| int ret = MMSYSERR_NOERROR; |
| |
| TRACE(midi, "(%04X);\n", wDevID); |
| |
| if (MidiOutDev[wDevID].midiDesc == 0) { |
| WARN(midi, "device not opened !\n"); |
| return MMSYSERR_ERROR; |
| } |
| /* FIXME: should test that no pending buffer is still in the queue for |
| * playing */ |
| |
| #ifdef HAVE_OSS |
| if (midiSeqFD == -1) { |
| WARN(midi,"can't close !\n"); |
| return MMSYSERR_ERROR; |
| } |
| |
| switch (midiOutDevices[wDevID]->wTechnology) { |
| case MOD_FMSYNTH: |
| case MOD_MIDIPORT: |
| midiCloseSeq(); |
| break; |
| default: |
| WARN(midi,"Technology not supported (yet) %d !\n", |
| midiOutDevices[wDevID]->wTechnology); |
| return MMSYSERR_NOTENABLED; |
| } |
| |
| if (MidiOutDev[wDevID].lpExtra != 0) { |
| free(MidiOutDev[wDevID].lpExtra); |
| MidiOutDev[wDevID].lpExtra = 0; |
| } |
| #else |
| if (MidiOutDev[wDevID].unixdev == 0) { |
| WARN(midi,"can't close !\n"); |
| return MMSYSERR_NOTENABLED; |
| } |
| close(MidiOutDev[wDevID].unixdev); |
| MidiOutDev[wDevID].unixdev = 0; |
| #endif /* HAVE_OSS */ |
| |
| MidiOutDev[wDevID].bufsize = 0; |
| if (MIDI_NotifyClient(wDevID, MOM_CLOSE, 0L, 0L) != MMSYSERR_NOERROR) { |
| WARN(midi,"can't notify client !\n"); |
| ret = MMSYSERR_INVALPARAM; |
| } |
| MidiOutDev[wDevID].midiDesc = 0; |
| return ret; |
| } |
| |
| /************************************************************************** |
| * modData [internal] |
| */ |
| static DWORD modData(WORD wDevID, DWORD dwParam) |
| { |
| WORD evt = LOBYTE(LOWORD(dwParam)); |
| WORD d1 = HIBYTE(LOWORD(dwParam)); |
| WORD d2 = LOBYTE(HIWORD(dwParam)); |
| |
| TRACE(midi, "(%04X, %08lX);\n", wDevID, dwParam); |
| |
| #ifdef HAVE_OSS |
| if (midiSeqFD == -1) { |
| WARN(midi,"can't play !\n"); |
| return MIDIERR_NODEVICE; |
| } |
| switch (midiOutDevices[wDevID]->wTechnology) { |
| case MOD_FMSYNTH: |
| /* FIXME: |
| * - chorus depth controller is not used |
| */ |
| { |
| sFMextra* extra = (sFMextra*)MidiOutDev[wDevID].lpExtra; |
| sVoice* voice = extra->voice; |
| sChannel* channel = extra->channel; |
| int chn = (evt & 0x0F); |
| int i, nv; |
| |
| switch (evt & 0xF0) { |
| case MIDI_NOTEOFF: |
| for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) { |
| /* don't stop sustained notes */ |
| if (voice[i].status == sVS_PLAYING && voice[i].channel == chn && voice[i].note == d1) { |
| voice[i].status = sVS_UNUSED; |
| SEQ_STOP_NOTE(wDevID, i, d1, d2); |
| } |
| } |
| break; |
| case MIDI_NOTEON: |
| if (d2 == 0) { /* note off if velocity == 0 */ |
| for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) { |
| /* don't stop sustained notes */ |
| if (voice[i].status == sVS_PLAYING && voice[i].channel == chn && voice[i].note == d1) { |
| voice[i].status = sVS_UNUSED; |
| SEQ_STOP_NOTE(wDevID, i, d1, 64); |
| } |
| } |
| break; |
| } |
| /* finding out in this order : |
| * - an empty voice |
| * - if replaying the same note on the same channel |
| * - the older voice (LRU) |
| */ |
| for (i = nv = 0; i < midiOutDevices[wDevID]->wVoices; i++) { |
| if (voice[i].status == sVS_UNUSED || |
| (voice[i].note == d1 && voice[i].channel == chn)) { |
| nv = i; |
| break; |
| } |
| if (voice[i].cntMark < voice[0].cntMark) { |
| nv = i; |
| } |
| } |
| TRACE(midi, |
| "playing on voice=%d, pgm=%d, pan=0x%02X, vol=0x%02X, " |
| "bender=0x%02X, note=0x%02X, vel=0x%02X\n", |
| nv, channel[chn].program, |
| channel[chn].balance, |
| channel[chn].volume, |
| channel[chn].bender, d1, d2); |
| |
| SEQ_SET_PATCH(wDevID, nv, IS_DRUM_CHANNEL(extra, chn) ? |
| (128 + d1) : channel[chn].program); |
| SEQ_BENDER_RANGE(wDevID, nv, channel[chn].benderRange * 100); |
| SEQ_BENDER(wDevID, nv, channel[chn].bender); |
| SEQ_CONTROL(wDevID, nv, CTL_PAN, channel[chn].balance); |
| SEQ_CONTROL(wDevID, nv, CTL_EXPRESSION, channel[chn].expression); |
| #if 0 |
| /* FIXME: does not really seem to work on my SB card and |
| * screws everything up... so lay it down |
| */ |
| SEQ_CONTROL(wDevID, nv, CTL_MAIN_VOLUME, channel[chn].volume); |
| #endif |
| SEQ_START_NOTE(wDevID, nv, d1, d2); |
| voice[nv].status = channel[chn].sustain ? sVS_SUSTAINED : sVS_PLAYING; |
| voice[nv].note = d1; |
| voice[nv].channel = chn; |
| voice[nv].cntMark = extra->counter++; |
| break; |
| case MIDI_KEY_PRESSURE: |
| for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) { |
| if (voice[i].status != sVS_UNUSED && voice[i].channel == chn && voice[i].note == d1) { |
| SEQ_KEY_PRESSURE(wDevID, i, d1, d2); |
| } |
| } |
| break; |
| case MIDI_CTL_CHANGE: |
| switch (d1) { |
| case CTL_BANK_SELECT: channel[chn].bank = d2; break; |
| case CTL_MAIN_VOLUME: channel[chn].volume = d2; break; |
| case CTL_PAN: channel[chn].balance = d2; break; |
| case CTL_EXPRESSION: channel[chn].expression = d2; break; |
| case CTL_SUSTAIN: channel[chn].sustain = d2; |
| if (d2) { |
| for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) { |
| if (voice[i].status == sVS_PLAYING && voice[i].channel == chn) { |
| voice[i].status = sVS_SUSTAINED; |
| } |
| } |
| } else { |
| for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) { |
| if (voice[i].status == sVS_SUSTAINED && voice[i].channel == chn) { |
| voice[i].status = sVS_UNUSED; |
| SEQ_STOP_NOTE(wDevID, i, voice[i].note, 64); |
| } |
| } |
| } |
| break; |
| case CTL_NONREG_PARM_NUM_LSB: channel[chn].nrgPmtLSB = d2; break; |
| case CTL_NONREG_PARM_NUM_MSB: channel[chn].nrgPmtMSB = d2; break; |
| case CTL_REGIST_PARM_NUM_LSB: channel[chn].regPmtLSB = d2; break; |
| case CTL_REGIST_PARM_NUM_MSB: channel[chn].regPmtMSB = d2; break; |
| |
| case CTL_DATA_ENTRY: |
| switch ((channel[chn].regPmtMSB << 8) | channel[chn].regPmtLSB) { |
| case 0x0000: |
| if (channel[chn].benderRange != d2) { |
| channel[chn].benderRange = d2; |
| for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) { |
| if (voice[i].channel == chn) { |
| SEQ_BENDER_RANGE(wDevID, i, channel[chn].benderRange); |
| } |
| } |
| } |
| break; |
| |
| case 0x7F7F: |
| channel[chn].benderRange = 2; |
| for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) { |
| if (voice[i].channel == chn) { |
| SEQ_BENDER_RANGE(wDevID, i, channel[chn].benderRange); |
| } |
| } |
| break; |
| default: |
| TRACE(midi, "Data entry: regPmt=0x%02x%02x, nrgPmt=0x%02x%02x with %x\n", |
| channel[chn].regPmtMSB, channel[chn].regPmtLSB, |
| channel[chn].nrgPmtMSB, channel[chn].nrgPmtLSB, |
| d2); |
| break; |
| } |
| break; |
| |
| case 0x78: /* all sounds off */ |
| for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) { |
| if (voice[i].status != sVS_UNUSED && voice[i].channel == chn) { |
| voice[i].status = sVS_UNUSED; |
| SEQ_STOP_NOTE(wDevID, i, voice[i].note, 0); |
| } |
| } |
| break; |
| case 0x7B: /* all notes off */ |
| for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) { |
| if (voice[i].status == sVS_PLAYING && voice[i].channel == chn) { |
| voice[i].status = sVS_UNUSED; |
| SEQ_STOP_NOTE(wDevID, i, voice[i].note, 0); |
| } |
| } |
| break; |
| default: |
| TRACE(midi, "Dropping MIDI control event 0x%02x(%02x) on channel %d\n", |
| d1, d2, chn); |
| break; |
| } |
| break; |
| case MIDI_PGM_CHANGE: |
| channel[chn].program = d1; |
| break; |
| case MIDI_CHN_PRESSURE: |
| for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) { |
| if (voice[i].status != sVS_UNUSED && voice[i].channel == chn) { |
| SEQ_KEY_PRESSURE(wDevID, i, voice[i].note, d1); |
| } |
| } |
| break; |
| case MIDI_PITCH_BEND: |
| channel[chn].bender = (d2 << 7) + d1; |
| for (i = 0; i < midiOutDevices[wDevID]->wVoices; i++) { |
| if (voice[i].channel == chn) { |
| SEQ_BENDER(wDevID, i, channel[chn].bender); |
| } |
| } |
| break; |
| case MIDI_SYSTEM_PREFIX: |
| switch (evt & 0x0F) { |
| case 0x0F: /* Reset */ |
| modFMReset(wDevID); |
| break; |
| default: |
| WARN(midi, |
| "Unsupported (yet) system event %02x\n", |
| evt & 0x0F); |
| } |
| break; |
| default: |
| WARN(midi, "Internal error, shouldn't happen\n"); |
| return MMSYSERR_NOTENABLED; |
| } |
| } |
| break; |
| case MOD_MIDIPORT: |
| { |
| int dev = wDevID - MODM_NUMFMSYNTHDEVS; |
| if (dev < 0) { |
| WARN(midi, "Internal error on devID (%u) !\n", wDevID); |
| return MIDIERR_NODEVICE; |
| } |
| |
| switch (evt & 0xF0) { |
| case MIDI_NOTEOFF: |
| case MIDI_NOTEON: |
| case MIDI_KEY_PRESSURE: |
| case MIDI_CTL_CHANGE: |
| case MIDI_PITCH_BEND: |
| SEQ_MIDIOUT(dev, evt); |
| SEQ_MIDIOUT(dev, d1); |
| SEQ_MIDIOUT(dev, d2); |
| break; |
| case MIDI_PGM_CHANGE: |
| case MIDI_CHN_PRESSURE: |
| SEQ_MIDIOUT(dev, evt); |
| SEQ_MIDIOUT(dev, d1); |
| break; |
| case MIDI_SYSTEM_PREFIX: |
| switch (evt & 0x0F) { |
| case 0x00: /* System Exclusive, don't do it on modData, |
| * should require modLongData*/ |
| case 0x01: /* Undefined */ |
| case 0x04: /* Undefined. */ |
| case 0x05: /* Undefined. */ |
| case 0x07: /* End of Exclusive. */ |
| case 0x09: /* Undefined. */ |
| case 0x0D: /* Undefined. */ |
| break; |
| case 0x06: /* Tune Request */ |
| case 0x08: /* Timing Clock. */ |
| case 0x0A: /* Start. */ |
| case 0x0B: /* Continue */ |
| case 0x0C: /* Stop */ |
| case 0x0E: /* Active Sensing. */ |
| SEQ_MIDIOUT(dev, evt); |
| break; |
| case 0x0F: /* Reset */ |
| /* SEQ_MIDIOUT(dev, evt); |
| this other way may be better */ |
| SEQ_MIDIOUT(dev, MIDI_SYSTEM_PREFIX); |
| SEQ_MIDIOUT(dev, 0x7e); |
| SEQ_MIDIOUT(dev, 0x7f); |
| SEQ_MIDIOUT(dev, 0x09); |
| SEQ_MIDIOUT(dev, 0x01); |
| SEQ_MIDIOUT(dev, 0xf7); |
| break; |
| case 0x03: /* Song Select. */ |
| SEQ_MIDIOUT(dev, evt); |
| SEQ_MIDIOUT(dev, d1); |
| case 0x02: /* Song Position Pointer. */ |
| SEQ_MIDIOUT(dev, evt); |
| SEQ_MIDIOUT(dev, d1); |
| SEQ_MIDIOUT(dev, d2); |
| } |
| break; |
| } |
| } |
| break; |
| default: |
| WARN(midi, "Technology not supported (yet) %d !\n", |
| midiOutDevices[wDevID]->wTechnology); |
| return MMSYSERR_NOTENABLED; |
| } |
| |
| SEQ_DUMPBUF(); |
| TRACE(midi, "done\n"); |
| #else |
| if (MidiOutDev[wDevID].unixdev == 0) { |
| WARN(midi,"can't play !\n"); |
| return MIDIERR_NODEVICE; |
| } |
| { |
| WORD event = LOWORD(dwParam); |
| if (write (MidiOutDev[wDevID].unixdev, |
| &event, sizeof(event)) != sizeof(WORD)) { |
| WARN(midi, "error writting unixdev !\n"); |
| } |
| } |
| #endif /* HAVE_OSS */ |
| return MMSYSERR_NOERROR; |
| } |
| |
| /************************************************************************** |
| * modLongData [internal] |
| */ |
| static DWORD modLongData(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize) |
| { |
| int count; |
| |
| TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize); |
| |
| #ifdef HAVE_OSS |
| if (midiSeqFD == -1) { |
| WARN(midi,"can't play !\n"); |
| return MIDIERR_NODEVICE; |
| } |
| #else /* HAVE_OSS */ |
| if (MidiOutDev[wDevID].unixdev == 0) { |
| WARN(midi,"can't play !\n"); |
| return MIDIERR_NODEVICE; |
| } |
| #endif /* HAVE_OSS */ |
| |
| if (lpMidiHdr->lpData == NULL) |
| return MIDIERR_UNPREPARED; |
| if (!(lpMidiHdr->dwFlags & MHDR_PREPARED)) |
| return MIDIERR_UNPREPARED; |
| if (lpMidiHdr->dwFlags & MHDR_INQUEUE) |
| return MIDIERR_STILLPLAYING; |
| lpMidiHdr->dwFlags &= ~MHDR_DONE; |
| lpMidiHdr->dwFlags |= MHDR_INQUEUE; |
| TRACE(midi, "dwBytesRecorded %lu !\n", lpMidiHdr->dwBytesRecorded); |
| TRACE(midi, " %02X %02X %02X %02X\n", |
| ((LPBYTE)(lpMidiHdr->reserved))[0], |
| ((LPBYTE)(lpMidiHdr->reserved))[1], |
| ((LPBYTE)(lpMidiHdr->reserved))[2], |
| ((LPBYTE)(lpMidiHdr->reserved))[3]); |
| #ifdef HAVE_OSS |
| switch (midiOutDevices[wDevID]->wTechnology) { |
| case MOD_FMSYNTH: |
| /* FIXME: I don't think there is much to do here */ |
| break; |
| case MOD_MIDIPORT: |
| if (((LPBYTE)lpMidiHdr->reserved)[0] != 0xF0) { |
| /* Send end of System Exclusive */ |
| SEQ_MIDIOUT(wDevID - MODM_NUMFMSYNTHDEVS, 0xF0); |
| TRACE(midi, "Adding missing 0xF0 marker at the begining of " |
| "system exclusive byte stream\n"); |
| } |
| for (count = 0; count < lpMidiHdr->dwBytesRecorded; count++) { |
| SEQ_MIDIOUT(wDevID - MODM_NUMFMSYNTHDEVS, |
| ((LPBYTE)lpMidiHdr->reserved)[count]); |
| } |
| if (((LPBYTE)lpMidiHdr->reserved)[count - 1] != 0xF7) { |
| /* Send end of System Exclusive */ |
| SEQ_MIDIOUT(wDevID - MODM_NUMFMSYNTHDEVS, 0xF7); |
| TRACE(midi, "Adding missing 0xF7 marker at the end of " |
| "system exclusive byte stream\n"); |
| } |
| SEQ_DUMPBUF(); |
| break; |
| default: |
| WARN(midi, "Technology not supported (yet) %d !\n", |
| midiOutDevices[wDevID]->wTechnology); |
| return MMSYSERR_NOTENABLED; |
| } |
| #else /* HAVE_OSS */ |
| { |
| LPWORD ptr = (LPWORD)lpMidiHdr->reserved; |
| int en; |
| |
| for (count = 0; count < lpMidiHdr->dwBytesRecorded; count++) { |
| if (write(MidiOutDev[wDevID].unixdev, |
| ptr, sizeof(WORD)) != sizeof(WORD)) |
| break; |
| ptr++; |
| } |
| |
| en = errno; |
| TRACE(midi, "after write count = %d\n",count); |
| if (count != lpMidiHdr->dwBytesRecorded) { |
| WARN(midi, "error writting unixdev #%d ! (%d != %ld)\n", |
| MidiOutDev[wDevID].unixdev, count, |
| lpMidiHdr->dwBytesRecorded); |
| TRACE(midi, "\terrno = %d error = %s\n",en,strerror(en)); |
| return MMSYSERR_NOTENABLED; |
| } |
| } |
| #endif /* HAVE_OSS */ |
| |
| lpMidiHdr->dwFlags &= ~MHDR_INQUEUE; |
| lpMidiHdr->dwFlags |= MHDR_DONE; |
| if (MIDI_NotifyClient(wDevID, MOM_DONE, (DWORD)lpMidiHdr, 0L) != MMSYSERR_NOERROR) { |
| WARN(midi,"can't notify client !\n"); |
| return MMSYSERR_INVALPARAM; |
| } |
| return MMSYSERR_NOERROR; |
| } |
| |
| /************************************************************************** |
| * modPrepare [internal] |
| */ |
| static DWORD modPrepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize) |
| { |
| TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize); |
| |
| #ifdef HAVE_OSS |
| if (midiSeqFD == -1) { |
| WARN(midi,"can't prepare !\n"); |
| return MMSYSERR_NOTENABLED; |
| } |
| #else /* HAVE_OSS */ |
| if (MidiOutDev[wDevID].unixdev == 0) { |
| WARN(midi,"can't prepare !\n"); |
| return MMSYSERR_NOTENABLED; |
| } |
| #endif /* HAVE_OSS */ |
| if (dwSize != sizeof(MIDIHDR) || lpMidiHdr == 0 || |
| lpMidiHdr->lpData == 0 || lpMidiHdr->dwFlags != 0 || |
| lpMidiHdr->dwBufferLength >= 0x10000ul) |
| return MMSYSERR_INVALPARAM; |
| |
| lpMidiHdr->lpNext = 0; |
| lpMidiHdr->dwFlags |= MHDR_PREPARED; |
| lpMidiHdr->dwFlags &= ~MHDR_DONE; |
| return MMSYSERR_NOERROR; |
| } |
| |
| /************************************************************************** |
| * modUnprepare [internal] |
| */ |
| static DWORD modUnprepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize) |
| { |
| TRACE(midi, "(%04X, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize); |
| #ifdef HAVE_OSS |
| if (midiSeqFD == -1) { |
| WARN(midi,"can't unprepare !\n"); |
| return MMSYSERR_NOTENABLED; |
| } |
| #else /* HAVE_OSS */ |
| if (MidiOutDev[wDevID].unixdev == 0) { |
| WARN(midi,"can't unprepare !\n"); |
| return MMSYSERR_NOTENABLED; |
| } |
| #endif /* HAVE_OSS */ |
| if (dwSize != sizeof(MIDIHDR) || lpMidiHdr == 0) |
| return MMSYSERR_INVALPARAM; |
| if (lpMidiHdr->dwFlags & MHDR_INQUEUE) |
| return MIDIERR_STILLPLAYING; |
| lpMidiHdr->dwFlags &= ~MHDR_PREPARED; |
| return MMSYSERR_NOERROR; |
| } |
| |
| /************************************************************************** |
| * modReset [internal] |
| */ |
| static DWORD modReset(WORD wDevID) |
| { |
| TRACE(midi, "(%04X);\n", wDevID); |
| /* FIXME: this function should : |
| * turn off every note, remove sustain on all channels |
| * remove any pending buffers |
| */ |
| return MMSYSERR_NOTENABLED; |
| } |
| |
| /************************************************************************** |
| * modMessage [sample driver] |
| */ |
| DWORD WINAPI modMessage(WORD wDevID, WORD wMsg, DWORD dwUser, |
| DWORD dwParam1, DWORD dwParam2) |
| { |
| TRACE(midi, "(%04X, %04X, %08lX, %08lX, %08lX);\n", |
| wDevID, wMsg, dwUser, dwParam1, dwParam2); |
| switch(wMsg) { |
| case MODM_OPEN: |
| return modOpen(wDevID, (LPMIDIOPENDESC)dwParam1, dwParam2); |
| case MODM_CLOSE: |
| return modClose(wDevID); |
| case MODM_DATA: |
| return modData(wDevID, dwParam1); |
| case MODM_LONGDATA: |
| return modLongData(wDevID, (LPMIDIHDR)dwParam1, dwParam2); |
| case MODM_PREPARE: |
| return modPrepare(wDevID, (LPMIDIHDR)dwParam1, dwParam2); |
| case MODM_UNPREPARE: |
| return modUnprepare(wDevID, (LPMIDIHDR)dwParam1, dwParam2); |
| case MODM_GETDEVCAPS: |
| return modGetDevCaps(wDevID,(LPMIDIOUTCAPS16)dwParam1,dwParam2); |
| case MODM_GETNUMDEVS: |
| return MODM_NUMDEVS; |
| case MODM_GETVOLUME: |
| return 0; |
| case MODM_SETVOLUME: |
| return 0; |
| case MODM_RESET: |
| return modReset(wDevID); |
| default: |
| TRACE(midi, "Unsupported message\n"); |
| } |
| return MMSYSERR_NOTSUPPORTED; |
| } |
| |
| /************************************************************************** |
| * MIDI_DriverProc [sample driver] |
| */ |
| LONG MIDI_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg, |
| DWORD dwParam1, DWORD dwParam2) |
| { |
| switch(wMsg) { |
| case DRV_LOAD: |
| return 1; |
| case DRV_FREE: |
| return 1; |
| case DRV_OPEN: |
| return 1; |
| case DRV_CLOSE: |
| return 1; |
| case DRV_ENABLE: |
| return 1; |
| case DRV_DISABLE: |
| return 1; |
| case DRV_QUERYCONFIGURE: |
| return 1; |
| case DRV_CONFIGURE: |
| MessageBox16(0, "Sample Midi Linux Driver !", |
| "MMLinux Driver", MB_OK); |
| return 1; |
| case DRV_INSTALL: |
| return DRVCNF_RESTART; |
| case DRV_REMOVE: |
| return DRVCNF_RESTART; |
| case MCI_OPEN_DRIVER: |
| case MCI_OPEN: |
| return MIDI_mciOpen(dwDevID, dwParam1, (LPMCI_OPEN_PARMS16)PTR_SEG_TO_LIN(dwParam2)); |
| case MCI_CLOSE_DRIVER: |
| case MCI_CLOSE: |
| return MIDI_mciClose(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2)); |
| case MCI_PLAY: |
| return MIDI_mciPlay(dwDevID, dwParam1, (LPMCI_PLAY_PARMS)PTR_SEG_TO_LIN(dwParam2)); |
| case MCI_RECORD: |
| return MIDI_mciRecord(dwDevID, dwParam1, (LPMCI_RECORD_PARMS)PTR_SEG_TO_LIN(dwParam2)); |
| case MCI_STOP: |
| return MIDI_mciStop(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2)); |
| case MCI_SET: |
| return MIDI_mciSet(dwDevID, dwParam1, (LPMCI_SET_PARMS)PTR_SEG_TO_LIN(dwParam2)); |
| case MCI_PAUSE: |
| return MIDI_mciPause(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2)); |
| case MCI_RESUME: |
| return MIDI_mciResume(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2)); |
| case MCI_STATUS: |
| return MIDI_mciStatus(dwDevID, dwParam1, (LPMCI_STATUS_PARMS)PTR_SEG_TO_LIN(dwParam2)); |
| case MCI_GETDEVCAPS: |
| return MIDI_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)PTR_SEG_TO_LIN(dwParam2)); |
| case MCI_INFO: |
| return MIDI_mciInfo(dwDevID, dwParam1, (LPMCI_INFO_PARMS16)PTR_SEG_TO_LIN(dwParam2)); |
| default: |
| return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2); |
| } |
| } |
| /*-----------------------------------------------------------------------*/ |