static void test_midi_outfns(HWND hwnd)
{
HMIDIOUT hm;
MMRESULT rc;
UINT udev, ndevs = midiOutGetNumDevs();
rc = midiOutOpen(&hm, ndevs, 0, 0, CALLBACK_NULL);
ok(rc==MMSYSERR_BADDEVICEID, "midiOutOpen udev>max rc=%s\n", mmsys_error(rc));
if (!rc) {
rc = midiOutClose(hm);
ok(!rc, "midiOutClose rc=%s\n", mmsys_error(rc));
}
if (!ndevs) {
MIDIOUTCAPSA capsA;
skip("Found no MIDI out device\n");
rc = midiOutGetDevCapsA(MIDIMAPPER, &capsA, sizeof(capsA));
/* GetDevCaps and Open must return compatible results */
ok(rc==MMSYSERR_BADDEVICEID || broken(rc==MMSYSERR_NODRIVER /*nt,w2k*/), "midiOutGetDevCaps MAPPER with no MIDI rc=%s\n", mmsys_error(rc));
rc = midiOutOpen(&hm, MIDIMAPPER, 0, 0, CALLBACK_NULL);
if (rc==MIDIERR_INVALIDSETUP) todo_wine /* Wine without snd-seq */
ok(rc==MMSYSERR_BADDEVICEID || broken(rc==MMSYSERR_NODRIVER /*w2k*/), "midiOutOpen MAPPER with no MIDI rc=%s\n", mmsys_error(rc));
else
ok(rc==MMSYSERR_BADDEVICEID || broken(rc==MMSYSERR_NODRIVER /*w2k sound disabled*/),
"midiOutOpen MAPPER with no MIDI rc=%s\n", mmsys_error(rc));
if (!rc) {
rc = midiOutClose(hm);
ok(!rc, "midiOutClose rc=%s\n", mmsys_error(rc));
}
return;
}
trace("Found %d MIDI OUT devices\n", ndevs);
test_midi_mci(hwnd);
for (udev=0; udev < ndevs; udev++) {
MIDIOUTCAPSA capsA;
rc = midiOutGetDevCapsA(udev, &capsA, sizeof(capsA));
if (rc || strcmp(capsA.szPname, "Creative Sound Blaster MPU-401") != 0 || ! on_vmware()) {
trace("** Testing device %d\n", udev);
test_midiOut_device(udev, hwnd);
Sleep(800); /* Let the synth rest */
test_midiStream(udev, hwnd);
Sleep(800);
}
else
win_skip("Skipping this device on VMware, driver problem\n");
}
trace("** Testing MIDI mapper\n");
test_midiOut_device(MIDIMAPPER, hwnd);
Sleep(800);
test_midiStream(MIDIMAPPER, hwnd);
}
MMRESULT Midi_OutClose(MIDI *midi)
{
MMRESULT error = MMSYSERR_NOERROR;
if (midi->outPort == -1) {
return MMSYSERR_NOERROR;
}
if (midi->midiOut) {
#ifdef MIDI_THRU
if (midi->midiMasterIn) {
midiDisconnect((HMIDI) midi->midiMasterIn, midi->midiOut, NULL);
}
#endif
error = midiOutClose(midi->midiOut);
if (error != MMSYSERR_NOERROR) {
return error;
}
midi->midiOut = NULL;
}
if (midi->outEvent) {
CloseHandle(midi->outEvent);
midi->outEvent = NULL;
}
return error;
}
/**************************************************************************
* midiStreamClose [WINMM.@]
*/
MMRESULT WINAPI midiStreamClose(HMIDISTRM hMidiStrm)
{
WINE_MIDIStream* lpMidiStrm;
MMRESULT ret = 0;
TRACE("(%p)!\n", hMidiStrm);
if (!MMSYSTEM_GetMidiStream(hMidiStrm, &lpMidiStrm, NULL))
return MMSYSERR_INVALHANDLE;
midiStreamStop(hMidiStrm);
PostThreadMessageA(lpMidiStrm->dwThreadID, WM_QUIT, 0, 0);
CloseHandle(lpMidiStrm->hEvent);
if (lpMidiStrm->hThread) {
if (GetCurrentThreadId() != lpMidiStrm->dwThreadID)
WaitForSingleObject(lpMidiStrm->hThread, INFINITE);
else {
FIXME("leak from call within function callback\n");
ret = MMSYSERR_HANDLEBUSY; /* yet don't signal it to app */
}
CloseHandle(lpMidiStrm->hThread);
}
if(!ret)
HeapFree(GetProcessHeap(), 0, lpMidiStrm);
return midiOutClose((HMIDIOUT)hMidiStrm);
}
static void midirelease(COMMNG self) {
CMMIDI midi;
midi = (CMMIDI)(self + 1);
midiallnoteoff(midi);
if (midi->opened & CMMIDI_MIDIOUT) {
waitlastexclusiveout(midi);
midiOutReset(midi->out.win32.hmidiout);
midiOutClose(midi->out.win32.hmidiout);
}
if (midi->opened & CMMIDI_MIDIIN) {
if (midi->opened & CMMIDI_MIDIINSTART) {
midiInStop(midi->hmidiin);
midiInUnprepareHeader(midi->hmidiin,
&midi->hmidiinhdr, sizeof(MIDIHDR));
}
midiInReset(midi->hmidiin);
midiInClose(midi->hmidiin);
midiinhdlunreg(midi);
}
#if defined(VERMOUTH_LIB)
if (midi->opened & CMMIDI_VERMOUTH) {
midiout_destroy(midi->out.vermouth);
}
#endif
#if defined(MT32SOUND_DLL)
if (midi->opened & CMMIDI_MT32SOUND) {
mt32sound_close();
}
#endif
_MFREE(self);
}
static DWORD modClose(MIDIMAPDATA* mom)
{
UINT i;
DWORD ret = MMSYSERR_NOERROR;
if (MIDIMAP_IsBadData(mom)) return MMSYSERR_ERROR;
for (i = 0; i < 16; i++)
{
DWORD t;
if (mom->ChannelMap[i] && mom->ChannelMap[i]->loaded > 0)
{
t = midiOutClose(mom->ChannelMap[i]->hMidi);
if (t == MMSYSERR_NOERROR)
{
mom->ChannelMap[i]->loaded = 0;
mom->ChannelMap[i]->hMidi = 0;
}
else if (ret == MMSYSERR_NOERROR)
ret = t;
}
}
if (ret == MMSYSERR_NOERROR)
HeapFree(GetProcessHeap(), 0, mom);
return ret;
}
void GlobalCleanup()
{
int t;
stop_timer();
for (t=0;t<GLOBAL.objects;t++) objects[t]->session_stop();
while (GLOBAL.objects>0) free_object(0);
BreakDownCommPort();
// for (t=0;t<GLOBAL.objects;t++) free_object(0);
CloseHandle(TTY.ThreadExitEvent);
for (t=0;t<GLOBAL.midiports;t++)
if (MIDIPORTS[t].midiout) midiOutClose(MIDIPORTS[t].midiout);
if (CAPTFILE.filehandle!=0) CloseHandle(CAPTFILE.filehandle);
SDLNet_Quit();
SDL_Quit();
DeleteObject(DRAW.brush_blue);
DeleteObject(DRAW.pen_blue);
DeleteObject(DRAW.pen_white);
write_logfile("BrainBay normal shutdown.");
return;
}
void JackWinMMEDriver::CloseOutput(MidiSlot* slot)
{
MMRESULT res;
int retry = 0;
if (slot->fHandle == 0)
return;
HMIDIOUT handle = (HMIDIOUT)slot->fHandle;
res = midiOutReset(handle);
if (res != MMSYSERR_NOERROR)
jack_error("midiOutReset error");
midiOutUnprepareHeader(handle, slot->fHeader, sizeof(MIDIHDR));
do {
res = midiOutClose(handle);
if (res != MMSYSERR_NOERROR)
jack_error("midiOutClose error");
Sleep(10);
retry++;
} while ((res == MIDIERR_STILLPLAYING) && (retry < 10));
if (slot->fHeader) {
GlobalFreePtr(slot->fHeader);
}
}
void MIDIDevice::close()
{
MMRESULT res;
if (m_handle == NULL)
return;
res = midiOutClose(m_handle);
if (res == MIDIERR_STILLPLAYING)
{
qDebug() << QString("Unable to close %1: Buffer not empty")
.arg(m_name);
}
else if (res == MMSYSERR_INVALHANDLE)
{
qDebug() << QString("Unable to close %1: Invalid handle")
.arg(m_name);
}
else if (res == MMSYSERR_NOMEM)
{
qDebug() << QString("Unable t close %1: Out of memory")
.arg(m_name);
}
else
{
m_handle = NULL;
}
}
int midi_open_port(HMIDIOUT * midiout, int portnum)
{
if (midiout) midiOutClose(* midiout);
if (midiOutOpen(midiout,portnum-1,0,0,CALLBACK_NULL)==MMSYSERR_NOERROR)
return TRUE;
return FALSE;
}
void closeMidi(void)
{
if (device_flag == MMSYSERR_NOERROR) {
midiOutReset(device);
midiOutClose(device);
}
device_flag = -1000;
}
int midi_open_port(HMIDIOUT * midiout, int portnum)
{
if (midiout) midiOutClose(* midiout);
if (midiOutOpen(midiout,portnum-1,0,0,CALLBACK_NULL)==MMSYSERR_NOERROR)
return TRUE;
write_logfile("could not open midi port");
return FALSE;
}
void MidiDriver_WIN::close() {
if (!_isOpen)
return;
_isOpen = false;
MidiDriver_MPU401::close();
midiOutUnprepareHeader(_mo, &_streamHeader, sizeof(_streamHeader));
check_error(midiOutClose(_mo));
CloseHandle(_streamEvent);
}
void RtMidiOut :: closePort( void )
{
if ( connected_ ) {
WinMidiData *data = static_cast<WinMidiData *> (apiData_);
midiOutReset( data->outHandle );
midiOutClose( data->outHandle );
connected_ = false;
}
}
void MidiOutPort_visual::closeAll(void) {
for (int i=0; i<getNumPorts(); i++) {
if (openQ[i] == 1 && device[i] != NULL) {
midiOutReset(device[i]);
midiOutClose(device[i]);
openQ[i] = 0;
}
}
}
// -----------------------------------------------------------------------
// 撤収〜
// -----------------------------------------------------------------------
void MIDI_Cleanup(void) {
if (hOut) {
MIDI_Reset();
MIDI_Waitlastexclusiveout();
midiOutReset(hOut);
midiOutClose(hOut);
hOut = 0;
}
}
/* close the midi device. */
virtual void close()
{
unsigned long result;
/* Open the MIDI Mapper */
result = midiOutClose( mHandle );
if (result)
{
printf("There was an error closing MIDI Mapper!\r\n");
}
}
static void msw_close_midiout(void)
{
int i;
for (i = 0; i < msw_nmidiout; i++)
{
midiOutReset(hMidiOut[i]);
midiOutClose(hMidiOut[i]);
}
msw_nmidiout = 0;
}
/* midi_win32_exit:
*/
void midi_win32_exit(int input)
{
/* close midi stream and release device */
if (midi_device != NULL) {
midiOutReset(midi_device);
midiOutClose(midi_device);
midi_device = NULL;
}
}
JNIEXPORT void JNICALL Java_org_herac_tuxguitar_player_impl_midiport_winmm_MidiSystem_closePort(JNIEnv* env, jobject obj, jlong ptr)
{
midi_handle_t *handle = NULL;
memcpy(&handle, &ptr, sizeof(handle));
if(handle != NULL && handle->out != NULL){
midiOutClose(*handle->out);
free( handle->out );
handle->out = NULL;
}
}
void MIDIDeviceOutJack::close()
{
int result;
result = midiOutClose((HMIDIOUT)m_handle);
if (result != MMSYSERR_NOERROR)
error("MIDIDeviceOutJack::close", result);
m_handle = -1;
}
//***********************************************************************
void MidiNoteClose( void )
//***********************************************************************
{
if ( !hMidiOut )
return;
UINT wError;
wError = midiOutReset( hMidiOut );
wError = midiOutClose( hMidiOut );
hMidiOut = NULL;
}
static void DestroyOutputDevice(MFDevice *pDevice)
{
MFMidiPC_MidiOutputDevice *pDev = (MFMidiPC_MidiOutputDevice*)pDevice->pInternal;
if (pDev->hMidiOut)
{
MFDebug_Warn(1, MFStr("MIDI output device not closed: %s", pDevice->strings[MFDS_ID]));
midiOutReset(pDev->hMidiOut);
midiOutClose(pDev->hMidiOut);
}
MFHeap_Free(pDev);
}
MidiOutput::~MidiOutput()
{
stopBackgroundThread();
MidiOutHandle* const h = static_cast <MidiOutHandle*> (internal);
if (MidiOutHandle::activeHandles.contains (h) && --(h->refCount) == 0)
{
midiOutClose (h->handle);
MidiOutHandle::activeHandles.removeValue (h);
delete h;
}
}
void QMidiOut::disconnect()
{
if (!fConnected) {
return;
}
midiOutClose(fMidiPtrs->midiOutPtr);
delete fMidiPtrs;
fMidiPtrs = NULL;
fConnected = false;
qDebug() << "DC";
}
void Win32MidiOutputDevice::close()
{
qDebug() << Q_FUNC_INFO;
if (m_handle == NULL)
return;
MMRESULT result = midiOutClose(m_handle);
if (result != MMSYSERR_NOERROR)
qWarning() << Q_FUNC_INFO << "Unable to close MIDI output with id:" << m_id
<< "name:" << name() << ":" << result;
m_handle = NULL;
}
BOOL load_settings(void)
{
HANDLE hFile;
int t,x,c,f;
char settingsfilename[256],midipname[256],tempname[256];
strcpy(settingsfilename,GLOBAL.resourcepath);
strcat(settingsfilename,"brainbay.cfg");
write_logfile("load setting from: %s",settingsfilename);
hFile = CreateFile(settingsfilename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
if(hFile == INVALID_HANDLE_VALUE) return FALSE;
load_next_config_buffer(hFile);
load_property("samplingrate",P_INT,&PACKETSPERSECOND);
//load_property("com-port",P_INT,&TTY.PORT);
//load_property("baudrate",P_INT,&TTY.BAUDRATE);
//load_property("devicetype",P_INT,&TTY.devicetype);
load_property("dialoginterval",P_INT,&GLOBAL.dialog_interval);
load_property("drawinterval",P_INT,&GLOBAL.draw_interval);
load_property("startup",P_INT,&GLOBAL.startup);
load_property("autorun",P_INT,&GLOBAL.autorun);
load_property("configfile",P_STRING,GLOBAL.configfile);
load_property("use_cvcapture",P_INT,&GLOBAL.use_cv_capture);
load_property("midiports",P_INT,&x);
for (c=0;c<GLOBAL.midiports;c++) midiOutClose(MIDIPORTS[c].midiout);
for (t=1;t<=x;t++)
{
sprintf(midipname,"midiport%d",t);
load_property(midipname,P_STRING,tempname);
f=0;
for (c=0;c<GLOBAL.midiports;c++)
{
if (!strcmp(tempname,MIDIPORTS[c].portname))
{
write_logfile("open midi port: %s", tempname);
midi_open_port(&(MIDIPORTS[c].midiout),c);
f=1;
}
}
if (!f) {strcat (tempname," not found"); report_error (tempname); }
}
CloseHandle(hFile);
return(TRUE);
}
bool CMidiDevice::SetDevice (const char *pcszDevice_)
{
if (m_hMidiOut)
{
midiOutClose(m_hMidiOut);
m_hMidiOut = NULL;
}
// Open the supplied device number
if (*pcszDevice_)
midiOutOpen(&m_hMidiOut, atoi(pcszDevice_), 0, 0, CALLBACK_NULL);
return m_hMidiOut != NULL;
}
MF_API void MFMidi_CloseOutput(MFDevice *pDevice)
{
MFMidiPC_MidiOutputDevice *pMidi = (MFMidiPC_MidiOutputDevice*)pDevice->pInternal;
if (!pMidi->hMidiOut)
{
MFDebug_Warn(1, "Midi output device not opened!");
return;
}
midiOutReset(pMidi->hMidiOut);
midiOutClose(pMidi->hMidiOut);
pMidi->hMidiOut = NULL;
pDevice->state = MFDevState_Available;
}
void MidiOutPort_visual::close(void) {
if (getPort() == -1) {
return;
}
if (getPortStatus() == 1 && device[getPort()] != NULL) {
// The following function, midiOutClose, is not what I like.
// It will send note offs to any note which it thinks is
// on when the port is closed. Uncomment the line if
// you want this feature.
// midiOutReset(device[getPort()]);
midiOutClose(device[getPort()]);
setPortStatus(0);
}
}
void QMidi::closeMidiOut()
{
#if defined(Q_OS_WIN)
midiOutClose(midiOutPtr);
#elif defined(Q_OS_LINUX)
QStringList l = myOutDeviceId.split(":");
int client = l.at(0).toInt();
int port = l.at(1).toInt();
snd_seq_disconnect_from(midiOutPtr, 0, client,port);
#elif defined(Q_OS_HAIKU)
midiOutLocProd->Disconnect(midiOutConsumer);
midiOutConsumer->Release();
midiOutLocProd->Unregister();
midiOutLocProd->Release();
#endif
}
