Aren/haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

midi2 kit clean up: license header, code style

Browse Source 
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@17860 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Jérôme Duval 2006-06-16 15:38:29 +00:00
parent f8253e50bd
commit 60d1530802
13 changed files with 516 additions and 849 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
headers/os/midi2/MidiConsumer.h
View File

@ -31,8 +31,8 @@ private:
virtual void _Reserved7();
virtual void _Reserved8();
port_id port;
bigtime_t latency;
port_id fPort;
bigtime_t fLatency;
uint32 _reserved[2];
};
@ -106,10 +106,10 @@ private:
int32 EventThread();
bigtime_t timeout;
void* timeoutData;
int32 currentProducer;
thread_id thread;
bigtime_t fTimeout;
void* fTimeoutData;
int32 fCurrentProducer;
thread_id fThread;
uint32 _reserved[1];
};

16
headers/os/midi2/MidiEndpoint.h
View File

@ -66,14 +66,14 @@ private:
bool LockLooper() const;
void UnlockLooper() const;
int32 id;
BString name;
int32 refCount;
BMessage* properties;
bool isLocal;
bool isConsumer;
bool isRegistered;
bool isAlive;
int32 fId;
BString fName;
int32 fRefCount;
BMessage* fProperties;
bool fIsLocal;
bool fIsConsumer;
bool fIsRegistered;
bool fIsAlive;
uint32 _reserved[4];
};

7
headers/os/midi2/MidiProducer.h
View File

@ -2,11 +2,10 @@
#ifndef _MIDI_PRODUCER_H
#define _MIDI_PRODUCER_H
#include <List.h>
#include <Locker.h>
#include <MidiEndpoint.h>
class BList;
namespace BPrivate { class BMidiRosterLooper; }
class BMidiProducer : public BMidiEndpoint
@ -46,8 +45,8 @@ private:
bool LockProducer() const;
void UnlockProducer() const;
BList* connections;
BLocker* locker;
mutable BLocker fLocker;
BList fConnections;
uint32 _reserved[10];
};

4
headers/os/midi2/MidiRoster.h
View File

@ -75,8 +75,8 @@ private:
status_t SendRequest(BMessage*, BMessage*);
BPrivate::BMidiRosterLooper* looper;
BMessenger* server;
BPrivate::BMidiRosterLooper* fLooper;
BMessenger fServer;
uint32 _reserved[16];
};

3
src/kits/midi2/Jamfile
View File

@ -4,9 +4,7 @@ SetSubDirSupportedPlatformsBeOSCompatible ;
if $(TARGET_PLATFORM) != haiku {
UseHeaders [ FDirName $(HAIKU_TOP) headers os midi2 ] : true ;
# We need Errors.h also when not compiling for Haiku.
UseHeaders [ FDirName $(HAIKU_TOP) headers posix ] : true ;
# We need Errors.h also when not compiling for Haiku.
}
UsePrivateHeaders midi ;
@ -22,3 +20,4 @@ SharedLibrary libmidi2.so :
:
be
;

45
src/kits/midi2/MidiConsumer.cpp
View File

@ -1,62 +1,44 @@
/*
* Copyright (c) 2002-2003 Matthijs Hollemans
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
* Copyright 2002-2006, Haiku.
* Distributed under the terms of the MIT License.
*
* Authors:
* Matthijs Hollemans
*/
#include "debug.h"
#include "MidiConsumer.h"
#include <MidiConsumer.h>
#include "protocol.h"
//------------------------------------------------------------------------------
bigtime_t BMidiConsumer::Latency() const
bigtime_t
BMidiConsumer::Latency() const
{
bigtime_t res = 0LL;
if (LockLooper())
{
res = latency;
if (LockLooper()) {
res = fLatency;
UnlockLooper();
}
return res;
}
//------------------------------------------------------------------------------
BMidiConsumer::BMidiConsumer(const char* name)
: BMidiEndpoint(name)
{
isConsumer = true;
latency = 0LL;
port = 0;
fIsConsumer = true;
fLatency = 0LL;
fPort = 0;
}
//------------------------------------------------------------------------------
BMidiConsumer::~BMidiConsumer()
{
// Do nothing.
}
//------------------------------------------------------------------------------
void BMidiConsumer::_Reserved1() { }
void BMidiConsumer::_Reserved2() { }
@ -67,4 +49,3 @@ void BMidiConsumer::_Reserved6() { }
void BMidiConsumer::_Reserved7() { }
void BMidiConsumer::_Reserved8() { }
//------------------------------------------------------------------------------

80
src/kits/midi2/MidiEndpoint.cpp
View File

@ -1,28 +1,14 @@
/*
* Copyright (c) 2002-2003 Matthijs Hollemans
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
* Copyright 2002-2006, Haiku.
* Distributed under the terms of the MIT License.
*
* Authors:
* Matthijs Hollemans
*/
#include "debug.h"
#include "MidiEndpoint.h"
#include "MidiRoster.h"
#include <MidiEndpoint.h>
#include <MidiRoster.h>
#include "MidiRosterLooper.h"
#include "protocol.h"
@ -37,7 +23,7 @@ BMidiEndpoint::Name() const
// e.g. to allocate more space. That's why we lock here too.
if (LockLooper()) {
str = name.String();
str = fName.String();
UnlockLooper();
}
@ -59,13 +45,13 @@ BMidiEndpoint::SetName(const char* newName)
if (!IsValid())
return;
if (name != newName) {
if (fName != newName) {
BMessage msg;
msg.AddString("midi:name", newName);
if (SendChangeRequest(&msg) == B_OK) {
if (LockLooper()) {
name.SetTo(newName);
fName.SetTo(newName);
UnlockLooper();
}
}
@ -76,35 +62,35 @@ BMidiEndpoint::SetName(const char* newName)
int32
BMidiEndpoint::ID() const
{
return id;
return fId;
}
bool
BMidiEndpoint::IsProducer() const
{
return !isConsumer;
return !fIsConsumer;
}
bool
BMidiEndpoint::IsConsumer() const
{
return isConsumer;
return fIsConsumer;
}
bool
BMidiEndpoint::IsRemote() const
{
return !isLocal;
return !fIsLocal;
}
bool
BMidiEndpoint::IsLocal() const
{
return isLocal;
return fIsLocal;
}
@ -129,7 +115,7 @@ BMidiEndpoint::IsValid() const
status_t
BMidiEndpoint::Release()
{
int32 old = atomic_add(&refCount, -1);
int32 old = atomic_add(&fRefCount, -1);
TRACE(("BMidiEndpoint::Release refCount is now %ld", old - 1))
@ -140,7 +126,7 @@ BMidiEndpoint::Release()
// If we are a proxy for a remote endpoint, we must only be
// deleted if that remote endpoint no longer exists.
if (IsLocal() || !isAlive)
if (IsLocal() || !fIsAlive)
delete this;
} else if (old <= 0) {
debugger("too many calls to Release()");
@ -156,7 +142,7 @@ BMidiEndpoint::Acquire()
#ifdef DEBUG
int32 old =
#endif
atomic_add(&refCount, 1);
atomic_add(&fRefCount, 1);
TRACE(("BMidiEndpoint::Acquire refCount is now %ld", old + 1))
@ -182,7 +168,7 @@ BMidiEndpoint::SetProperties(const BMessage* properties_)
status_t err = SendChangeRequest(&msg);
if (err == B_OK) {
if (LockLooper()) {
*properties = *properties_;
*fProperties = *properties_;
UnlockLooper();
}
}
@ -201,7 +187,7 @@ BMidiEndpoint::GetProperties(BMessage* _properties) const
}
if (LockLooper()) {
*_properties = *properties;
*_properties = *fProperties;
UnlockLooper();
}
@ -250,15 +236,15 @@ BMidiEndpoint::BMidiEndpoint(const char* name_)
TRACE(("BMidiEndpoint::BMidiEndpoint"))
if (name_ != NULL)
name.SetTo(name_);
fName.SetTo(name_);
id = 0;
refCount = 0;
isLocal = false;
isRegistered = false;
isAlive = true;
fId = 0;
fRefCount = 0;
fIsLocal = false;
fIsRegistered = false;
fIsAlive = true;
properties = new BMessage;
fProperties = new BMessage;
}
@ -266,13 +252,13 @@ BMidiEndpoint::~BMidiEndpoint()
{
TRACE(("BMidiEndpoint::~BMidiEndpoint (%p)", this))
if (refCount > 0) {
if (fRefCount > 0) {
debugger(
"you should use Release() to dispose of endpoints; "
"do not \"delete\" them or allocate them on the stack!");
}
delete properties;
delete fProperties;
}
//------------------------------------------------------------------------------
@ -297,7 +283,7 @@ BMidiEndpoint::SendRegisterRequest(bool registered)
status_t err = SendChangeRequest(&msg);
if (err == B_OK) {
if (LockLooper()) {
isRegistered = registered;
fIsRegistered = registered;
UnlockLooper();
}
}
@ -333,20 +319,20 @@ BMidiEndpoint::IsRegistered() const
// No need to protect this with a lock, because reading
// and writing a bool is always an atomic operation.
return isRegistered;
return fIsRegistered;
}
bool
BMidiEndpoint::LockLooper() const
{
return BMidiRoster::MidiRoster()->looper->Lock();
return BMidiRoster::MidiRoster()->fLooper->Lock();
}
void
BMidiEndpoint::UnlockLooper() const
{
BMidiRoster::MidiRoster()->looper->Unlock();
BMidiRoster::MidiRoster()->fLooper->Unlock();
}

251
src/kits/midi2/MidiLocalConsumer.cpp
View File

@ -1,60 +1,44 @@
/*
* Copyright (c) 2002-2003 Matthijs Hollemans
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
* Copyright 2002-2006, Haiku.
* Distributed under the terms of the MIT License.
*
* Authors:
* Matthijs Hollemans
*/
#include <stdlib.h>
#include "debug.h"
#include "MidiConsumer.h"
#include "MidiRoster.h"
#include <MidiConsumer.h>
#include <MidiRoster.h>
#include "protocol.h"
//------------------------------------------------------------------------------
int32 _midi_event_thread(void* data)
int32
_midi_event_thread(void* data)
{
return ((BMidiLocalConsumer*) data)->EventThread();
}
//------------------------------------------------------------------------------
BMidiLocalConsumer::BMidiLocalConsumer(const char* name)
: BMidiConsumer(name)
{
TRACE(("BMidiLocalConsumer::BMidiLocalConsumer"))
isLocal = true;
refCount = 1;
timeout = (bigtime_t) -1;
timeoutData = NULL;
fIsLocal = true;
fRefCount = 1;
fTimeout = (bigtime_t) -1;
fTimeoutData = NULL;
port = create_port(1, "MidiEventPort");
thread = spawn_thread(
fPort = create_port(1, "MidiEventPort");
fThread = spawn_thread(
_midi_event_thread, "MidiEventThread", B_REAL_TIME_PRIORITY, this);
resume_thread(thread);
resume_thread(fThread);
BMidiRoster::MidiRoster()->CreateLocal(this);
}
//------------------------------------------------------------------------------
BMidiLocalConsumer::~BMidiLocalConsumer()
{
@ -62,147 +46,119 @@ BMidiLocalConsumer::~BMidiLocalConsumer()
BMidiRoster::MidiRoster()->DeleteLocal(this);
delete_port(port);
delete_port(fPort);
status_t result;
wait_for_thread(thread, &result);
wait_for_thread(fThread, &result);
}
//------------------------------------------------------------------------------
void BMidiLocalConsumer::SetLatency(bigtime_t latency_)
void
BMidiLocalConsumer::SetLatency(bigtime_t latency_)
{
if (latency_ < 0)
{
if (latency_ < 0) {
WARN("SetLatency() does not accept negative values");
return;
}
else if (!IsValid())
{
} else if (!IsValid()) {
return;
}
else if (latency != latency_)
{
} else if (fLatency != latency_) {
BMessage msg;
msg.AddInt64("midi:latency", latency_);
if (SendChangeRequest(&msg) == B_OK)
{
if (LockLooper())
{
latency = latency_;
if (SendChangeRequest(&msg) == B_OK) {
if (LockLooper()) {
fLatency = latency_;
UnlockLooper();
}
}
}
}
//------------------------------------------------------------------------------
int32 BMidiLocalConsumer::GetProducerID(void)
int32
BMidiLocalConsumer::GetProducerID(void)
{
return currentProducer;
return fCurrentProducer;
}
//------------------------------------------------------------------------------
void BMidiLocalConsumer::SetTimeout(bigtime_t when, void* data)
void
BMidiLocalConsumer::SetTimeout(bigtime_t when, void* data)
{
timeout = when;
timeoutData = data;
fTimeout = when;
fTimeoutData = data;
}
//------------------------------------------------------------------------------
void BMidiLocalConsumer::Timeout(void* data)
void
BMidiLocalConsumer::Timeout(void* data)
{
// Do nothing.
}
//------------------------------------------------------------------------------
void BMidiLocalConsumer::Data(
uchar* data, size_t length, bool atomic, bigtime_t time)
void
BMidiLocalConsumer::Data(uchar* data, size_t length, bool atomic, bigtime_t time)
{
if (atomic)
{
switch (data[0] & 0xF0)
{
if (atomic) {
switch (data[0] & 0xF0) {
case B_NOTE_OFF:
{
if (length == 3)
{
NoteOff(data[0] & 0x0F, data[1], data[2], time);
}
break;
}
case B_NOTE_ON:
{
if (length == 3)
{
NoteOn(data[0] & 0x0F, data[1], data[2], time);
}
break;
}
case B_KEY_PRESSURE:
{
if (length == 3)
{
KeyPressure(data[0] & 0x0F, data[1], data[2], time);
}
break;
}
case B_CONTROL_CHANGE:
{
if (length == 3)
{
ControlChange(data[0] & 0x0F, data[1], data[2], time);
}
break;
}
case B_PROGRAM_CHANGE:
{
if (length == 2)
{
ProgramChange(data[0] & 0x0F, data[1], time);
}
break;
}
case B_CHANNEL_PRESSURE:
{
if (length == 2)
{
ChannelPressure(data[0] & 0x0F, data[1], time);
}
break;
}
case B_PITCH_BEND:
{
if (length == 3)
{
PitchBend(data[0] & 0x0F, data[1], data[2], time);
}
break;
}
case 0xF0:
{
switch (data[0])
{
switch (data[0]) {
case B_SYS_EX_START:
{
if (data[length - 1] == B_SYS_EX_END)
{
if (data[length - 1] == B_SYS_EX_END) {
SystemExclusive(data + 1, length - 2, time);
}
else // sysex-end is not required
{
} else { // sysex-end is not required
SystemExclusive(data + 1, length - 1, time);
}
break;
@ -211,8 +167,7 @@ void BMidiLocalConsumer::Data(
case B_TUNE_REQUEST:
case B_SYS_EX_END:
{
if (length == 1)
{
if (length == 1) {
SystemCommon(data[0], 0, 0, time);
}
break;
@ -222,8 +177,7 @@ void BMidiLocalConsumer::Data(
case B_MIDI_TIME_CODE:
case B_SONG_SELECT:
{
if (length == 2)
{
if (length == 2) {
SystemCommon(data[0], data[1], 0, time);
}
break;
@ -231,8 +185,7 @@ void BMidiLocalConsumer::Data(
case B_SONG_POSITION:
{
if (length == 3)
{
if (length == 3) {
SystemCommon(data[0], data[1], data[2], time);
}
break;
@ -244,8 +197,7 @@ void BMidiLocalConsumer::Data(
case B_STOP:
case B_ACTIVE_SENSING:
{
if (length == 1)
{
if (length == 1) {
SystemRealTime(data[0], time);
}
break;
@ -253,13 +205,10 @@ void BMidiLocalConsumer::Data(
case B_SYSTEM_RESET:
{
if (length == 1)
{
if (length == 1) {
SystemRealTime(data[0], time);
}
else if ((length == 6) && (data[1] == 0x51)
&& (data[2] == 0x03))
{
} else if ((length == 6) && (data[1] == 0x51)
&& (data[2] == 0x03)) {
int32 tempo =
(data[3] << 16) | (data[4] << 8) | data[5];
@ -273,100 +222,91 @@ void BMidiLocalConsumer::Data(
}
}
//------------------------------------------------------------------------------
void BMidiLocalConsumer::NoteOff(
uchar channel, uchar note, uchar velocity, bigtime_t time)
void
BMidiLocalConsumer::NoteOff(uchar channel, uchar note, uchar velocity, bigtime_t time)
{
// Do nothing.
}
//------------------------------------------------------------------------------
void BMidiLocalConsumer::NoteOn(
uchar channel, uchar note, uchar velocity, bigtime_t time)
void
BMidiLocalConsumer::NoteOn(uchar channel, uchar note, uchar velocity, bigtime_t time)
{
// Do nothing.
}
//------------------------------------------------------------------------------
void BMidiLocalConsumer::KeyPressure(
uchar channel, uchar note, uchar pressure, bigtime_t time)
void
BMidiLocalConsumer::KeyPressure(uchar channel, uchar note, uchar pressure, bigtime_t time)
{
// Do nothing.
}
//------------------------------------------------------------------------------
void BMidiLocalConsumer::ControlChange(
uchar channel, uchar controlNumber, uchar controlValue, bigtime_t time)
void
BMidiLocalConsumer::ControlChange(uchar channel, uchar controlNumber, uchar controlValue, bigtime_t time)
{
// Do nothing.
}
//------------------------------------------------------------------------------
void BMidiLocalConsumer::ProgramChange(
uchar channel, uchar programNumber, bigtime_t time)
void
BMidiLocalConsumer::ProgramChange(uchar channel, uchar programNumber, bigtime_t time)
{
// Do nothing.
}
//------------------------------------------------------------------------------
void BMidiLocalConsumer::ChannelPressure(
uchar channel, uchar pressure, bigtime_t time)
void BMidiLocalConsumer::ChannelPressure(uchar channel, uchar pressure, bigtime_t time)
{
// Do nothing.
}
//------------------------------------------------------------------------------
void BMidiLocalConsumer::PitchBend(
uchar channel, uchar lsb, uchar msb, bigtime_t time)
void
BMidiLocalConsumer::PitchBend(uchar channel, uchar lsb, uchar msb, bigtime_t time)
{
// Do nothing.
}
//------------------------------------------------------------------------------
void BMidiLocalConsumer::SystemExclusive(
void
BMidiLocalConsumer::SystemExclusive(
void* data, size_t length, bigtime_t time)
{
// Do nothing.
}
//------------------------------------------------------------------------------
void BMidiLocalConsumer::SystemCommon(
void
BMidiLocalConsumer::SystemCommon(
uchar statusByte, uchar data1, uchar data2, bigtime_t time)
{
// Do nothing.
}
//------------------------------------------------------------------------------
void BMidiLocalConsumer::SystemRealTime(uchar statusByte, bigtime_t time)
void
BMidiLocalConsumer::SystemRealTime(uchar statusByte, bigtime_t time)
{
// Do nothing.
}
//------------------------------------------------------------------------------
void BMidiLocalConsumer::TempoChange(int32 beatsPerMinute, bigtime_t time)
void
BMidiLocalConsumer::TempoChange(int32 beatsPerMinute, bigtime_t time)
{
// Do nothing.
}
//------------------------------------------------------------------------------
void BMidiLocalConsumer::AllNotesOff(bool justChannel, bigtime_t time)
void
BMidiLocalConsumer::AllNotesOff(bool justChannel, bigtime_t time)
{
// Do nothing.
}
//------------------------------------------------------------------------------
void BMidiLocalConsumer::_Reserved1() { }
void BMidiLocalConsumer::_Reserved2() { }
@ -377,61 +317,53 @@ void BMidiLocalConsumer::_Reserved6() { }
void BMidiLocalConsumer::_Reserved7() { }
void BMidiLocalConsumer::_Reserved8() { }
//------------------------------------------------------------------------------
int32 BMidiLocalConsumer::EventThread()
int32
BMidiLocalConsumer::EventThread()
{
int32 msg_code;
ssize_t msg_size;
ssize_t buf_size = 100;
uint8* buffer = (uint8*) malloc(buf_size);
while (true)
{
if (timeout == (bigtime_t) -1)
{
msg_size = port_buffer_size(port);
}
else // have timeout
{
msg_size = port_buffer_size_etc(port, B_ABSOLUTE_TIMEOUT, timeout);
if (msg_size == B_TIMED_OUT)
{
Timeout(timeoutData);
timeout = (bigtime_t) -1;
timeoutData = NULL;
while (true) {
if (fTimeout == (bigtime_t) -1) {
msg_size = port_buffer_size(fPort);
} else { // have timeout
msg_size = port_buffer_size_etc(fPort, B_ABSOLUTE_TIMEOUT, fTimeout);
if (msg_size == B_TIMED_OUT) {
Timeout(fTimeoutData);
fTimeout = (bigtime_t) -1;
fTimeoutData = NULL;
continue;
}
}
if (msg_size < 0) { break; } // error reading port
if (msg_size < 0)
break; // error reading port
if (msg_size > buf_size)
{
if (msg_size > buf_size) {
buffer = (uint8*) realloc(buffer, msg_size);
buf_size = msg_size;
}
read_port(port, &msg_code, buffer, msg_size);
read_port(fPort, &msg_code, buffer, msg_size);
if (msg_size > 20) // minimum valid size
{
if (msg_size > 20) { // minimum valid size
#ifdef DEBUG
printf("*** received: ");
for (int32 t = 0; t < msg_size; ++t)
{
for (int32 t = 0; t < msg_size; ++t) {
printf("%02X, ", ((uint8*) buffer)[t]);
}
printf("\n");
#endif
currentProducer = *((uint32*) (buffer + 0));
fCurrentProducer = *((uint32*) (buffer + 0));
int32 targetId = *((uint32*) (buffer + 4));
bigtime_t time = *((bigtime_t*) (buffer + 8));
bool atomic = *((bool*) (buffer + 16));
if (targetId == id) // only if we are the destination
{
if (targetId == fId) { // only if we are the destination
Data((uchar*) (buffer + 20), msg_size - 20, atomic, time);
}
}
@ -441,4 +373,3 @@ int32 BMidiLocalConsumer::EventThread()
return 0;
}
//------------------------------------------------------------------------------

40
src/kits/midi2/MidiLocalProducer.cpp
View File

@ -1,31 +1,17 @@
/*
* Copyright (c) 2002-2004 Matthijs Hollemans
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
* Copyright 2002-2006, Haiku.
* Distributed under the terms of the MIT License.
*
* Authors:
* Matthijs Hollemans
*/
#include <stdlib.h>
#include "debug.h"
#include "MidiConsumer.h"
#include "MidiProducer.h"
#include "MidiRoster.h"
#include <MidiConsumer.h>
#include <MidiProducer.h>
#include <MidiRoster.h>
#include "protocol.h"
@ -34,8 +20,8 @@ BMidiLocalProducer::BMidiLocalProducer(const char* name)
{
TRACE(("BMidiLocalProducer::BMidiLocalProducer"))
isLocal = true;
refCount = 1;
fIsLocal = true;
fRefCount = 1;
BMidiRoster::MidiRoster()->CreateLocal(this);
}
@ -298,7 +284,7 @@ BMidiLocalProducer::SprayEvent(const void* data, size_t length,
uint8* buffer = (uint8*)malloc(buf_size);
if (buffer != NULL) {
*((uint32*) (buffer + 0)) = id;
*((uint32*) (buffer + 0)) = fId;
*((bigtime_t*) (buffer + 8)) = time;
*((uint32*) (buffer + 16)) = 0;
*((bool*) (buffer + 16)) = atomic;
@ -315,7 +301,7 @@ BMidiLocalProducer::SprayEvent(const void* data, size_t length,
for (int32 t = 0; t < CountConsumers(); ++t) {
BMidiConsumer* cons = ConsumerAt(t);
*((uint32*) (buffer + 4)) = cons->id;
*((uint32*) (buffer + 4)) = cons->fId;
#ifdef DEBUG
printf("*** spraying: ");
@ -326,7 +312,7 @@ BMidiLocalProducer::SprayEvent(const void* data, size_t length,
printf("\n");
#endif
write_port(cons->port, 0, buffer, buf_size);
write_port(cons->fPort, 0, buffer, buf_size);
}
free(buffer);

186
src/kits/midi2/MidiProducer.cpp
View File

@ -1,81 +1,55 @@
/*
* Copyright (c) 2002-2003 Matthijs Hollemans
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
* Copyright 2002-2006, Haiku.
* Distributed under the terms of the MIT License.
*
* Authors:
* Matthijs Hollemans
*/
#include "debug.h"
#include "MidiConsumer.h"
#include "MidiProducer.h"
#include "MidiRoster.h"
#include <MidiConsumer.h>
#include <MidiProducer.h>
#include <MidiRoster.h>
#include "MidiRosterLooper.h"
#include "protocol.h"
//------------------------------------------------------------------------------
status_t BMidiProducer::Connect(BMidiConsumer* cons)
status_t
BMidiProducer::Connect(BMidiConsumer* cons)
{
if (cons == NULL)
{
if (cons == NULL) {
WARN("Connect() does not accept a NULL consumer")
return B_BAD_VALUE;
}
else if (!IsValid() || !cons->IsValid())
{
if (!IsValid() || !cons->IsValid()) {
return B_ERROR;
}
else
{
return SendConnectRequest(cons, true);
}
return SendConnectRequest(cons, true);
}
//------------------------------------------------------------------------------
status_t BMidiProducer::Disconnect(BMidiConsumer* cons)
status_t
BMidiProducer::Disconnect(BMidiConsumer* cons)
{
if (cons == NULL)
{
if (cons == NULL) {
WARN("Disconnect() does not accept a NULL consumer")
return B_BAD_VALUE;
}
else if (!IsValid() || !cons->IsValid())
{
}
if (!IsValid() || !cons->IsValid()) {
return B_ERROR;
}
else
{
return SendConnectRequest(cons, false);
}
return SendConnectRequest(cons, false);
}
//------------------------------------------------------------------------------
bool BMidiProducer::IsConnected(BMidiConsumer* cons) const
bool
BMidiProducer::IsConnected(BMidiConsumer* cons) const
{
bool isConnected = false;
if (cons != NULL)
{
if (LockProducer())
{
isConnected = connections->HasItem(cons);
if (cons != NULL) {
if (LockProducer()) {
isConnected = fConnections.HasItem(cons);
UnlockProducer();
}
}
@ -83,16 +57,14 @@ bool BMidiProducer::IsConnected(BMidiConsumer* cons) const
return isConnected;
}
//------------------------------------------------------------------------------
BList* BMidiProducer::Connections() const
BList*
BMidiProducer::Connections() const
{
BList* list = new BList();
if (LockProducer())
{
for (int32 t = 0; t < CountConsumers(); ++t)
{
if (LockProducer()) {
for (int32 t = 0; t < CountConsumers(); ++t) {
BMidiConsumer* cons = ConsumerAt(t);
cons->Acquire();
list->AddItem(cons);
@ -104,25 +76,20 @@ BList* BMidiProducer::Connections() const
return list;
}
//------------------------------------------------------------------------------
BMidiProducer::BMidiProducer(const char* name)
: BMidiEndpoint(name)
: BMidiEndpoint(name),
fLocker("MidiProducerLock"),
fConnections()
{
isConsumer = false;
connections = new BList;
locker = new BLocker("MidiProducerLock");
fIsConsumer = false;
}
//------------------------------------------------------------------------------
BMidiProducer::~BMidiProducer()
{
delete connections;
delete locker;
}
//------------------------------------------------------------------------------
void BMidiProducer::_Reserved1() { }
void BMidiProducer::_Reserved2() { }
@ -133,21 +100,18 @@ void BMidiProducer::_Reserved6() { }
void BMidiProducer::_Reserved7() { }
void BMidiProducer::_Reserved8() { }
//------------------------------------------------------------------------------
status_t BMidiProducer::SendConnectRequest(
status_t
BMidiProducer::SendConnectRequest(
BMidiConsumer* cons, bool mustConnect)
{
ASSERT(cons != NULL)
BMessage msg, reply;
if (mustConnect)
{
if (mustConnect) {
msg.what = MSG_CONNECT_ENDPOINTS;
}
else
{
} else {
msg.what = MSG_DISCONNECT_ENDPOINTS;
}
@ -155,24 +119,20 @@ status_t BMidiProducer::SendConnectRequest(
msg.AddInt32("midi:consumer", cons->ID());
status_t err = BMidiRoster::MidiRoster()->SendRequest(&msg, &reply);
if (err != B_OK) { return err; }
if (err != B_OK)
return err;
status_t res;
if (reply.FindInt32("midi:result", &res) == B_OK)
{
if (res == B_OK)
{
if (mustConnect)
{
if (reply.FindInt32("midi:result", &res) == B_OK) {
if (res == B_OK) {
if (mustConnect) {
ConnectionMade(cons);
}
else
{
} else {
ConnectionBroken(cons);
}
#ifdef DEBUG
BMidiRoster::MidiRoster()->looper->DumpEndpoints();
BMidiRoster::MidiRoster()->fLooper->DumpEndpoints();
#endif
}
@ -182,77 +142,71 @@ status_t BMidiProducer::SendConnectRequest(
return B_ERROR;
}
//------------------------------------------------------------------------------
void BMidiProducer::ConnectionMade(BMidiConsumer* cons)
void
BMidiProducer::ConnectionMade(BMidiConsumer* consumer)
{
ASSERT(cons != NULL)
ASSERT(consumer != NULL)
if (LockProducer())
{
ASSERT(!connections->HasItem(cons))
if (LockProducer()) {
ASSERT(!fConnections.HasItem(consumer))
connections->AddItem(cons);
fConnections.AddItem(consumer);
UnlockProducer();
}
if (IsLocal())
{
((BMidiLocalProducer*) this)->Connected(cons);
if (IsLocal()) {
((BMidiLocalProducer*) this)->Connected(consumer);
}
}
//------------------------------------------------------------------------------
bool BMidiProducer::ConnectionBroken(BMidiConsumer* cons)
bool
BMidiProducer::ConnectionBroken(BMidiConsumer* consumer)
{
ASSERT(cons != NULL)
ASSERT(consumer != NULL)
bool wasConnected = false;
if (LockProducer())
{
wasConnected = connections->RemoveItem(cons);
if (LockProducer()) {
wasConnected = fConnections.RemoveItem(consumer);
UnlockProducer();
}
if (wasConnected && IsLocal())
{
((BMidiLocalProducer*) this)->Disconnected(cons);
if (wasConnected && IsLocal()) {
((BMidiLocalProducer*) this)->Disconnected(consumer);
}
return wasConnected;
}
//------------------------------------------------------------------------------
int32 BMidiProducer::CountConsumers() const
int32
BMidiProducer::CountConsumers() const
{
return connections->CountItems();
return fConnections.CountItems();
}
//------------------------------------------------------------------------------
BMidiConsumer* BMidiProducer::ConsumerAt(int32 index) const
BMidiConsumer*
BMidiProducer::ConsumerAt(int32 index) const
{
ASSERT(connections != NULL)
ASSERT(index >= 0 && index < CountConsumers())
return (BMidiConsumer*) connections->ItemAt(index);
return (BMidiConsumer*) fConnections.ItemAt(index);
}
//------------------------------------------------------------------------------
bool BMidiProducer::LockProducer() const
bool
BMidiProducer::LockProducer() const
{
return locker->Lock();
return fLocker.Lock();
}
//------------------------------------------------------------------------------
void BMidiProducer::UnlockProducer() const
void
BMidiProducer::UnlockProducer() const
{
locker->Unlock();
fLocker.Unlock();
}
//------------------------------------------------------------------------------

244
src/kits/midi2/MidiRoster.cpp
View File

@ -1,28 +1,14 @@
/*
* Copyright (c) 2002-2004 Matthijs Hollemans
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
* Copyright 2002-2006, Haiku.
* Distributed under the terms of the MIT License.
*
* Authors:
* Matthijs Hollemans
*/
#include "debug.h"
#include "MidiConsumer.h"
#include "MidiRoster.h"
#include <MidiConsumer.h>
#include <MidiRoster.h>
#include "MidiRosterLooper.h"
#include "protocol.h"
@ -60,20 +46,17 @@ namespace BPrivate
midi_roster_killer;
}
//------------------------------------------------------------------------------
BMidiEndpoint* BMidiRoster::NextEndpoint(int32* id)
BMidiEndpoint*
BMidiRoster::NextEndpoint(int32* id)
{
BMidiEndpoint* endp = NULL;
if (id != NULL)
{
BMidiRosterLooper* looper = MidiRoster()->looper;
if (looper->Lock())
{
if (id != NULL) {
BMidiRosterLooper* looper = MidiRoster()->fLooper;
if (looper->Lock()) {
endp = looper->NextEndpoint(id);
if (endp != NULL)
{
if (endp != NULL) {
endp->Acquire();
}
looper->Unlock();
@ -83,69 +66,55 @@ BMidiEndpoint* BMidiRoster::NextEndpoint(int32* id)
return endp;
}
//------------------------------------------------------------------------------
BMidiProducer* BMidiRoster::NextProducer(int32* id)
BMidiProducer*
BMidiRoster::NextProducer(int32* id)
{
BMidiEndpoint* endp;
while ((endp = NextEndpoint(id)) != NULL)
{
if (endp->IsProducer())
{
while ((endp = NextEndpoint(id)) != NULL) {
if (endp->IsProducer()) {
return (BMidiProducer*) endp;
}
else
{
endp->Release();
}
endp->Release();
}
return NULL;
}
//------------------------------------------------------------------------------
BMidiConsumer* BMidiRoster::NextConsumer(int32* id)
BMidiConsumer*
BMidiRoster::NextConsumer(int32* id)
{
BMidiEndpoint* endp;
while ((endp = NextEndpoint(id)) != NULL)
{
if (endp->IsConsumer())
{
while ((endp = NextEndpoint(id)) != NULL) {
if (endp->IsConsumer()) {
return (BMidiConsumer*) endp;
}
else
{
endp->Release();
}
endp->Release();
}
return NULL;
}
//------------------------------------------------------------------------------
BMidiEndpoint* BMidiRoster::FindEndpoint(int32 id, bool localOnly)
BMidiEndpoint*
BMidiRoster::FindEndpoint(int32 id, bool localOnly)
{
BMidiEndpoint* endp = NULL;
BMidiRosterLooper* looper = MidiRoster()->looper;
if (looper->Lock())
{
BMidiRosterLooper* looper = MidiRoster()->fLooper;
if (looper->Lock()) {
endp = looper->FindEndpoint(id);
if ((endp != NULL) && endp->IsRemote())
{
if (localOnly || !endp->IsRegistered())
{
if ((endp != NULL) && endp->IsRemote()) {
if (localOnly || !endp->IsRegistered()) {
endp = NULL;
}
}
if (endp != NULL)
{
if (endp != NULL) {
endp->Acquire();
}
@ -155,14 +124,13 @@ BMidiEndpoint* BMidiRoster::FindEndpoint(int32 id, bool localOnly)
return endp;
}
//------------------------------------------------------------------------------
BMidiProducer* BMidiRoster::FindProducer(int32 id, bool localOnly)
BMidiProducer*
BMidiRoster::FindProducer(int32 id, bool localOnly)
{
BMidiEndpoint* endp = FindEndpoint(id, localOnly);
if ((endp != NULL) && !endp->IsProducer())
{
if ((endp != NULL) && !endp->IsProducer()) {
endp->Release();
endp = NULL;
}
@ -170,14 +138,13 @@ BMidiProducer* BMidiRoster::FindProducer(int32 id, bool localOnly)
return (BMidiProducer*) endp;
}
//------------------------------------------------------------------------------
BMidiConsumer* BMidiRoster::FindConsumer(int32 id, bool localOnly)
BMidiConsumer*
BMidiRoster::FindConsumer(int32 id, bool localOnly)
{
BMidiEndpoint* endp = FindEndpoint(id, localOnly);
if ((endp != NULL) && !endp->IsConsumer())
{
if ((endp != NULL) && !endp->IsConsumer()) {
endp->Release();
endp = NULL;
}
@ -185,76 +152,68 @@ BMidiConsumer* BMidiRoster::FindConsumer(int32 id, bool localOnly)
return (BMidiConsumer*) endp;
}
//------------------------------------------------------------------------------
void BMidiRoster::StartWatching(const BMessenger* msngr)
void
BMidiRoster::StartWatching(const BMessenger* msngr)
{
if (msngr == NULL)
{
if (msngr == NULL) {
WARN("StartWatching does not accept a NULL messenger")
}
else
{
BMidiRosterLooper* looper = MidiRoster()->looper;
if (looper->Lock())
{
} else {
BMidiRosterLooper* looper = MidiRoster()->fLooper;
if (looper->Lock()) {
looper->StartWatching(msngr);
looper->Unlock();
}
}
}
//------------------------------------------------------------------------------
void BMidiRoster::StopWatching()
void
BMidiRoster::StopWatching()
{
BMidiRosterLooper* looper = MidiRoster()->looper;
if (looper->Lock())
{
BMidiRosterLooper* looper = MidiRoster()->fLooper;
if (looper->Lock()) {
looper->StopWatching();
looper->Unlock();
}
}
//------------------------------------------------------------------------------
status_t BMidiRoster::Register(BMidiEndpoint* endp)
status_t
BMidiRoster::Register(BMidiEndpoint* endp)
{
if (endp != NULL)
{
if (endp != NULL) {
return endp->Register();
}
return B_BAD_VALUE;
}
//------------------------------------------------------------------------------
status_t BMidiRoster::Unregister(BMidiEndpoint* endp)
status_t
BMidiRoster::Unregister(BMidiEndpoint* endp)
{
if (endp != NULL)
{
if (endp != NULL) {
return endp->Unregister();
}
return B_BAD_VALUE;
}
//------------------------------------------------------------------------------
BMidiRoster* BMidiRoster::MidiRoster()
BMidiRoster*
BMidiRoster::MidiRoster()
{
if (roster == NULL)
{
if (roster == NULL) {
new BMidiRoster();
}
return roster;
}
//------------------------------------------------------------------------------
BMidiRoster::BMidiRoster()
: fServer(MIDI_SERVER_SIGNATURE)
{
TRACE(("BMidiRoster::BMidiRoster"))
@ -265,17 +224,16 @@ BMidiRoster::BMidiRoster()
roster = this;
server = new BMessenger(MIDI_SERVER_SIGNATURE);
looper = new BMidiRosterLooper();
fLooper = new BMidiRosterLooper();
if (!looper->Init(this)) { return; }
if (!fLooper->Init(this))
return;
BMessage msg;
msg.what = MSG_REGISTER_APP;
msg.AddMessenger("midi:messenger", BMessenger(looper));
msg.AddMessenger("midi:messenger", BMessenger(fLooper));
if (server->SendMessage(&msg, looper, TIMEOUT) != B_OK)
{
if (fServer.SendMessage(&msg, fLooper, TIMEOUT) != B_OK) {
WARN("Cannot send request to midi_server");
return;
}
@ -286,25 +244,20 @@ BMidiRoster::BMidiRoster()
// will bump the semaphore count, and our acquire_sem()
// can grab the semaphore safely (without blocking).
acquire_sem(looper->initLock);
acquire_sem(fLooper->fInitLock);
}
//------------------------------------------------------------------------------
BMidiRoster::~BMidiRoster()
{
TRACE(("BMidiRoster::~BMidiRoster"))
if (looper != NULL)
{
looper->Lock();
looper->Quit();
if (fLooper != NULL) {
fLooper->Lock();
fLooper->Quit();
}
delete server;
}
//------------------------------------------------------------------------------
void BMidiRoster::_Reserved1() { }
void BMidiRoster::_Reserved2() { }
@ -315,9 +268,9 @@ void BMidiRoster::_Reserved6() { }
void BMidiRoster::_Reserved7() { }
void BMidiRoster::_Reserved8() { }
//------------------------------------------------------------------------------
void BMidiRoster::CreateLocal(BMidiEndpoint* endp)
void
BMidiRoster::CreateLocal(BMidiEndpoint* endp)
{
ASSERT(endp != NULL)
@ -328,35 +281,29 @@ void BMidiRoster::CreateLocal(BMidiEndpoint* endp)
BMessage msg;
msg.what = MSG_CREATE_ENDPOINT;
msg.AddBool("midi:consumer", endp->isConsumer);
msg.AddBool("midi:registered", endp->isRegistered);
msg.AddBool("midi:consumer", endp->fIsConsumer);
msg.AddBool("midi:registered", endp->fIsRegistered);
msg.AddString("midi:name", endp->Name());
msg.AddMessage("midi:properties", endp->properties);
msg.AddMessage("midi:properties", endp->fProperties);
if (endp->IsConsumer())
{
if (endp->IsConsumer()) {
BMidiConsumer* consumer = (BMidiConsumer*) endp;
msg.AddInt32("midi:port", consumer->port);
msg.AddInt64("midi:latency", consumer->latency);
msg.AddInt32("midi:port", consumer->fPort);
msg.AddInt64("midi:latency", consumer->fLatency);
}
BMessage reply;
if (SendRequest(&msg, &reply) == B_OK)
{
if (SendRequest(&msg, &reply) == B_OK) {
status_t res;
if (reply.FindInt32("midi:result", &res) == B_OK)
{
if (res == B_OK)
{
if (reply.FindInt32("midi:result", &res) == B_OK) {
if (res == B_OK) {
int32 id;
if (reply.FindInt32("midi:id", &id) == B_OK)
{
endp->id = id;
if (reply.FindInt32("midi:id", &id) == B_OK) {
endp->fId = id;
if (looper->Lock())
{
looper->AddEndpoint(endp);
looper->Unlock();
if (fLooper->Lock()) {
fLooper->AddEndpoint(endp);
fLooper->Unlock();
}
}
}
@ -374,9 +321,9 @@ void BMidiRoster::CreateLocal(BMidiEndpoint* endp)
// trip an assertion, so you can't delete these endpoints.)
}
//------------------------------------------------------------------------------
void BMidiRoster::DeleteLocal(BMidiEndpoint* endp)
void
BMidiRoster::DeleteLocal(BMidiEndpoint* endp)
{
ASSERT(endp != NULL)
@ -389,40 +336,36 @@ void BMidiRoster::DeleteLocal(BMidiEndpoint* endp)
// a reply from the server. If something went wrong, the
// object will be destroyed regardless.
server->SendMessage(&msg, (BHandler*) NULL, TIMEOUT);
fServer.SendMessage(&msg, (BHandler*) NULL, TIMEOUT);
// If the endpoint was successfully created, we must remove
// it from the list of endpoints. If creation failed, then
// we didn't put the endpoint on that list. If the endpoint
// was connected to anything, we must also disconnect it.
if (endp->ID() > 0)
{
if (looper->Lock())
{
looper->RemoveEndpoint(endp);
looper->Unlock();
if (endp->ID() > 0) {
if (fLooper->Lock()) {
fLooper->RemoveEndpoint(endp);
fLooper->Unlock();
}
}
}
//------------------------------------------------------------------------------
status_t BMidiRoster::SendRequest(BMessage* msg, BMessage* reply)
status_t
BMidiRoster::SendRequest(BMessage* msg, BMessage* reply)
{
ASSERT(msg != NULL)
ASSERT(reply != NULL)
status_t err = server->SendMessage(msg, reply, TIMEOUT, TIMEOUT);
status_t err = fServer.SendMessage(msg, reply, TIMEOUT, TIMEOUT);
if (err != B_OK)
{
if (err != B_OK) {
WARN("Cannot send request to midi_server");
}
#ifdef DEBUG
if (err == B_OK)
{
if (err == B_OK) {
printf("REPLY "); reply->PrintToStream();
}
#endif
@ -430,4 +373,3 @@ status_t BMidiRoster::SendRequest(BMessage* msg, BMessage* reply)
return err;
}
//------------------------------------------------------------------------------

445
src/kits/midi2/MidiRosterLooper.cpp
View File

@ -1,53 +1,36 @@
/*
* Copyright (c) 2002-2004 Matthijs Hollemans
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
* Copyright 2002-2006, Haiku.
* Distributed under the terms of the MIT License.
*
* Authors:
* Matthijs Hollemans
*/
#include "debug.h"
#include "MidiConsumer.h"
#include "MidiProducer.h"
#include "MidiRoster.h"
#include <MidiConsumer.h>
#include <MidiProducer.h>
#include <MidiRoster.h>
#include "MidiRosterLooper.h"
#include "protocol.h"
using namespace BPrivate;
//------------------------------------------------------------------------------
BMidiRosterLooper::BMidiRosterLooper()
: BLooper("MidiRosterLooper")
{
initLock = -1;
roster = NULL;
watcher = NULL;
fInitLock = -1;
fRoster = NULL;
fWatcher = NULL;
}
//------------------------------------------------------------------------------
BMidiRosterLooper::~BMidiRosterLooper()
{
StopWatching();
if (initLock >= B_OK)
{
delete_sem(initLock);
if (fInitLock >= B_OK) {
delete_sem(fInitLock);
}
// At this point, our list may still contain endpoints with a
@ -58,30 +41,26 @@ BMidiRosterLooper::~BMidiRosterLooper()
// It would have been better to jump into the debugger, but I
// did not want to risk breaking any (misbehaving) old apps.
for (int32 t = 0; t < CountEndpoints(); ++t)
{
for (int32 t = 0; t < CountEndpoints(); ++t) {
BMidiEndpoint* endp = EndpointAt(t);
if (endp->refCount > 0)
{
if (endp->fRefCount > 0) {
fprintf(
stderr, "[midi] WARNING: Endpoint %ld (%p) has "
"not been Release()d properly (refcount = %ld)\n",
endp->ID(), endp, endp->refCount);
}
else
{
endp->ID(), endp, endp->fRefCount);
} else {
delete endp;
}
}
}
//------------------------------------------------------------------------------
bool BMidiRosterLooper::Init(BMidiRoster* roster_)
bool
BMidiRosterLooper::Init(BMidiRoster* roster_)
{
ASSERT(roster_ != NULL)
roster = roster_;
fRoster = roster_;
// We create a semaphore with a zero count. BMidiRoster's
// MidiRoster() method will try to acquire this semaphore,
@ -89,18 +68,16 @@ bool BMidiRosterLooper::Init(BMidiRoster* roster_)
// "app registered" message in our MessageReceived() hook,
// we release the semaphore and MidiRoster() will unblock.
initLock = create_sem(0, "InitLock");
fInitLock = create_sem(0, "InitLock");
if (initLock < B_OK)
{
if (fInitLock < B_OK) {
WARN("Could not create semaphore")
return false;
}
thread_id threadId = Run();
if (threadId < B_OK)
{
if (threadId < B_OK) {
WARN("Could not start looper thread")
return false;
}
@ -108,19 +85,16 @@ bool BMidiRosterLooper::Init(BMidiRoster* roster_)
return true;
}
//------------------------------------------------------------------------------
BMidiEndpoint* BMidiRosterLooper::NextEndpoint(int32* id)
BMidiEndpoint*
BMidiRosterLooper::NextEndpoint(int32* id)
{
ASSERT(id != NULL)
for (int32 t = 0; t < CountEndpoints(); ++t)
{
for (int32 t = 0; t < CountEndpoints(); ++t) {
BMidiEndpoint* endp = EndpointAt(t);
if (endp->ID() > *id)
{
if (endp->IsRemote() && endp->IsRegistered())
{
if (endp->ID() > *id) {
if (endp->IsRemote() && endp->IsRegistered()) {
*id = endp->ID();
return endp;
}
@ -130,15 +104,13 @@ BMidiEndpoint* BMidiRosterLooper::NextEndpoint(int32* id)
return NULL;
}
//------------------------------------------------------------------------------
BMidiEndpoint* BMidiRosterLooper::FindEndpoint(int32 id)
BMidiEndpoint*
BMidiRosterLooper::FindEndpoint(int32 id)
{
for (int32 t = 0; t < CountEndpoints(); ++t)
{
for (int32 t = 0; t < CountEndpoints(); ++t) {
BMidiEndpoint* endp = EndpointAt(t);
if (endp->ID() == id)
{
if (endp->ID() == id) {
return endp;
}
}
@ -146,12 +118,12 @@ BMidiEndpoint* BMidiRosterLooper::FindEndpoint(int32 id)
return NULL;
}
//------------------------------------------------------------------------------
void BMidiRosterLooper::AddEndpoint(BMidiEndpoint* endp)
void
BMidiRosterLooper::AddEndpoint(BMidiEndpoint* endp)
{
ASSERT(endp != NULL)
ASSERT(!endpoints.HasItem(endp))
ASSERT(!fEndpoints.HasItem(endp))
// We store the endpoints sorted by ID, because that
// simplifies the implementation of NextEndpoint().
@ -160,36 +132,31 @@ void BMidiRosterLooper::AddEndpoint(BMidiEndpoint* endp)
// are delivered in this order (mostly they will be).
int32 t;
for (t = CountEndpoints(); t > 0; --t)
{
for (t = CountEndpoints(); t > 0; --t) {
BMidiEndpoint* other = EndpointAt(t - 1);
if (endp->ID() > other->ID())
{
if (endp->ID() > other->ID()) {
break;
}
}
endpoints.AddItem(endp, t);
fEndpoints.AddItem(endp, t);
#ifdef DEBUG
DumpEndpoints();
#endif
}
//------------------------------------------------------------------------------
void BMidiRosterLooper::RemoveEndpoint(BMidiEndpoint* endp)
void
BMidiRosterLooper::RemoveEndpoint(BMidiEndpoint* endp)
{
ASSERT(endp != NULL)
ASSERT(endpoints.HasItem(endp))
ASSERT(fEndpoints.HasItem(endp))
endpoints.RemoveItem(endp);
fEndpoints.RemoveItem(endp);
if (endp->IsConsumer())
{
if (endp->IsConsumer()) {
DisconnectDeadConsumer((BMidiConsumer*) endp);
}
else
{
} else {
DisconnectDeadProducer((BMidiProducer*) endp);
}
@ -198,37 +165,36 @@ void BMidiRosterLooper::RemoveEndpoint(BMidiEndpoint* endp)
#endif
}
//------------------------------------------------------------------------------
void BMidiRosterLooper::StartWatching(const BMessenger* watcher_)
void
BMidiRosterLooper::StartWatching(const BMessenger* watcher_)
{
ASSERT(watcher_ != NULL)
StopWatching();
watcher = new BMessenger(*watcher_);
fWatcher = new BMessenger(*watcher_);
AllEndpoints();
AllConnections();
}
//------------------------------------------------------------------------------
void BMidiRosterLooper::StopWatching()
void
BMidiRosterLooper::StopWatching()
{
delete watcher;
watcher = NULL;
delete fWatcher;
fWatcher = NULL;
}
//------------------------------------------------------------------------------
void BMidiRosterLooper::MessageReceived(BMessage* msg)
void
BMidiRosterLooper::MessageReceived(BMessage* msg)
{
#ifdef DEBUG
printf("IN "); msg->PrintToStream();
#endif
switch (msg->what)
{
switch (msg->what) {
case MSG_APP_REGISTERED: OnAppRegistered(msg); break;
case MSG_ENDPOINT_CREATED: OnEndpointCreated(msg); break;
case MSG_ENDPOINT_DELETED: OnEndpointDeleted(msg); break;
@ -240,16 +206,16 @@ void BMidiRosterLooper::MessageReceived(BMessage* msg)
}
}
//------------------------------------------------------------------------------
void BMidiRosterLooper::OnAppRegistered(BMessage* msg)
void
BMidiRosterLooper::OnAppRegistered(BMessage* msg)
{
release_sem(initLock);
release_sem(fInitLock);
}
//------------------------------------------------------------------------------
void BMidiRosterLooper::OnEndpointCreated(BMessage* msg)
void
BMidiRosterLooper::OnEndpointCreated(BMessage* msg)
{
int32 id;
bool isRegistered;
@ -258,37 +224,32 @@ void BMidiRosterLooper::OnEndpointCreated(BMessage* msg)
bool isConsumer;
if ((msg->FindInt32("midi:id", &id) == B_OK)
&& (msg->FindBool("midi:registered", &isRegistered) == B_OK)
&& (msg->FindString("midi:name", &name) == B_OK)
&& (msg->FindMessage("midi:properties", &properties) == B_OK)
&& (msg->FindBool("midi:consumer", &isConsumer) == B_OK))
{
if (isConsumer)
{
&& (msg->FindBool("midi:registered", &isRegistered) == B_OK)
&& (msg->FindString("midi:name", &name) == B_OK)
&& (msg->FindMessage("midi:properties", &properties) == B_OK)
&& (msg->FindBool("midi:consumer", &isConsumer) == B_OK)) {
if (isConsumer) {
int32 port;
bigtime_t latency;
if ((msg->FindInt32("midi:port", &port) == B_OK)
&& (msg->FindInt64("midi:latency", &latency) == B_OK))
{
&& (msg->FindInt64("midi:latency", &latency) == B_OK)) {
BMidiConsumer* cons = new BMidiConsumer();
cons->name = name;
cons->id = id;
cons->isRegistered = isRegistered;
cons->port = port;
cons->latency = latency;
*(cons->properties) = properties;
cons->fName = name;
cons->fId = id;
cons->fIsRegistered = isRegistered;
cons->fPort = port;
cons->fLatency = latency;
*(cons->fProperties) = properties;
AddEndpoint(cons);
return;
}
}
else // producer
{
} else { // producer
BMidiProducer* prod = new BMidiProducer();
prod->name = name;
prod->id = id;
prod->isRegistered = isRegistered;
*(prod->properties) = properties;
prod->fName = name;
prod->fId = id;
prod->fIsRegistered = isRegistered;
*(prod->fProperties) = properties;
AddEndpoint(prod);
return;
}
@ -297,26 +258,22 @@ void BMidiRosterLooper::OnEndpointCreated(BMessage* msg)
WARN("Could not create proxy for remote endpoint")
}
//------------------------------------------------------------------------------
void BMidiRosterLooper::OnEndpointDeleted(BMessage* msg)
void
BMidiRosterLooper::OnEndpointDeleted(BMessage* msg)
{
int32 id;
if (msg->FindInt32("midi:id", &id) == B_OK)
{
if (msg->FindInt32("midi:id", &id) == B_OK) {
BMidiEndpoint* endp = FindEndpoint(id);
if (endp != NULL)
{
if (endp != NULL) {
RemoveEndpoint(endp);
// If the client is watching, and the endpoint is
// registered remote, we need to let it know that
// the endpoint is now unregistered.
if (endp->IsRemote() && endp->IsRegistered())
{
if (watcher != NULL)
{
if (endp->IsRemote() && endp->IsRegistered()) {
if (fWatcher != NULL) {
BMessage notify;
notify.AddInt32("be:op", B_MIDI_UNREGISTERED);
ChangeEvent(&notify, endp);
@ -330,14 +287,11 @@ void BMidiRosterLooper::OnEndpointDeleted(BMessage* msg)
// object. We clear the "isRegistered" flag to
// let the client know the object is now invalid.
if (endp->refCount == 0)
{
if (endp->fRefCount == 0) {
delete endp;
}
else // still being used
{
endp->isRegistered = false;
endp->isAlive = false;
} else { // still being used
endp->fIsRegistered = false;
endp->fIsAlive = false;
}
return;
@ -347,16 +301,14 @@ void BMidiRosterLooper::OnEndpointDeleted(BMessage* msg)
WARN("Could not delete proxy for remote endpoint")
}
//------------------------------------------------------------------------------
void BMidiRosterLooper::OnEndpointChanged(BMessage* msg)
void
BMidiRosterLooper::OnEndpointChanged(BMessage* msg)
{
int32 id;
if (msg->FindInt32("midi:id", &id) == B_OK)
{
if (msg->FindInt32("midi:id", &id) == B_OK) {
BMidiEndpoint* endp = FindEndpoint(id);
if ((endp != NULL) && endp->IsRemote())
{
if ((endp != NULL) && endp->IsRemote()) {
ChangeRegistered(msg, endp);
ChangeName(msg, endp);
ChangeProperties(msg, endp);
@ -373,37 +325,30 @@ void BMidiRosterLooper::OnEndpointChanged(BMessage* msg)
WARN("Could not change endpoint attributes")
}
//------------------------------------------------------------------------------
void BMidiRosterLooper::OnConnectedDisconnected(BMessage* msg)
void
BMidiRosterLooper::OnConnectedDisconnected(BMessage* msg)
{
int32 prodId, consId;
if ((msg->FindInt32("midi:producer", &prodId) == B_OK)
&& (msg->FindInt32("midi:consumer", &consId) == B_OK))
{
&& (msg->FindInt32("midi:consumer", &consId) == B_OK)) {
BMidiEndpoint* endp1 = FindEndpoint(prodId);
BMidiEndpoint* endp2 = FindEndpoint(consId);
if ((endp1 != NULL) && endp1->IsProducer())
{
if ((endp2 != NULL) && endp2->IsConsumer())
{
if ((endp1 != NULL) && endp1->IsProducer()) {
if ((endp2 != NULL) && endp2->IsConsumer()) {
BMidiProducer* prod = (BMidiProducer*) endp1;
BMidiConsumer* cons = (BMidiConsumer*) endp2;
bool mustConnect = (msg->what == MSG_ENDPOINTS_CONNECTED);
if (mustConnect)
{
if (mustConnect) {
prod->ConnectionMade(cons);
}
else
{
} else {
prod->ConnectionBroken(cons);
}
if (watcher != NULL)
{
if (fWatcher != NULL) {
ConnectionEvent(prod, cons, mustConnect);
}
@ -419,29 +364,23 @@ void BMidiRosterLooper::OnConnectedDisconnected(BMessage* msg)
WARN("Could not connect/disconnect endpoints")
}
//------------------------------------------------------------------------------
void BMidiRosterLooper::ChangeRegistered(BMessage* msg, BMidiEndpoint* endp)
void
BMidiRosterLooper::ChangeRegistered(BMessage* msg, BMidiEndpoint* endp)
{
ASSERT(msg != NULL)
ASSERT(endp != NULL)
bool isRegistered;
if (msg->FindBool("midi:registered", &isRegistered) == B_OK)
{
if (endp->isRegistered != isRegistered)
{
endp->isRegistered = isRegistered;
if (msg->FindBool("midi:registered", &isRegistered) == B_OK) {
if (endp->fIsRegistered != isRegistered) {
endp->fIsRegistered = isRegistered;
if (watcher != NULL)
{
if (fWatcher != NULL) {
BMessage notify;
if (isRegistered)
{
if (isRegistered) {
notify.AddInt32("be:op", B_MIDI_REGISTERED);
}
else
{
} else {
notify.AddInt32("be:op", B_MIDI_UNREGISTERED);
}
ChangeEvent(&notify, endp);
@ -450,22 +389,19 @@ void BMidiRosterLooper::ChangeRegistered(BMessage* msg, BMidiEndpoint* endp)
}
}
//------------------------------------------------------------------------------
void BMidiRosterLooper::ChangeName(BMessage* msg, BMidiEndpoint* endp)
void
BMidiRosterLooper::ChangeName(BMessage* msg, BMidiEndpoint* endp)
{
ASSERT(msg != NULL)
ASSERT(endp != NULL)
BString name;
if (msg->FindString("midi:name", &name) == B_OK)
{
if (endp->name != name)
{
endp->name = name;
if (msg->FindString("midi:name", &name) == B_OK) {
if (endp->fName != name) {
endp->fName = name;
if ((watcher != NULL) && endp->IsRegistered())
{
if ((fWatcher != NULL) && endp->IsRegistered()) {
BMessage notify;
notify.AddInt32("be:op", B_MIDI_CHANGED_NAME);
notify.AddString("be:name", name);
@ -475,20 +411,18 @@ void BMidiRosterLooper::ChangeName(BMessage* msg, BMidiEndpoint* endp)
}
}
//------------------------------------------------------------------------------
void BMidiRosterLooper::ChangeProperties(BMessage* msg, BMidiEndpoint* endp)
void
BMidiRosterLooper::ChangeProperties(BMessage* msg, BMidiEndpoint* endp)
{
ASSERT(msg != NULL)
ASSERT(endp != NULL)
BMessage properties;
if (msg->FindMessage("midi:properties", &properties) == B_OK)
{
*(endp->properties) = properties;
if (msg->FindMessage("midi:properties", &properties) == B_OK) {
*(endp->fProperties) = properties;
if ((watcher != NULL) && endp->IsRegistered())
{
if ((fWatcher != NULL) && endp->IsRegistered()) {
BMessage notify;
notify.AddInt32("be:op", B_MIDI_CHANGED_PROPERTIES);
notify.AddMessage("be:properties", &properties);
@ -497,25 +431,21 @@ void BMidiRosterLooper::ChangeProperties(BMessage* msg, BMidiEndpoint* endp)
}
}
//------------------------------------------------------------------------------
void BMidiRosterLooper::ChangeLatency(BMessage* msg, BMidiEndpoint* endp)
void
BMidiRosterLooper::ChangeLatency(BMessage* msg, BMidiEndpoint* endp)
{
ASSERT(msg != NULL)
ASSERT(endp != NULL)
bigtime_t latency;
if (msg->FindInt64("midi:latency", &latency) == B_OK)
{
if (endp->IsConsumer())
{
if (msg->FindInt64("midi:latency", &latency) == B_OK) {
if (endp->IsConsumer()) {
BMidiConsumer* cons = (BMidiConsumer*) endp;
if (cons->latency != latency)
{
cons->latency = latency;
if (cons->fLatency != latency) {
cons->fLatency = latency;
if ((watcher != NULL) && cons->IsRegistered())
{
if ((fWatcher != NULL) && cons->IsRegistered()) {
BMessage notify;
notify.AddInt32("be:op", B_MIDI_CHANGED_LATENCY);
notify.AddInt64("be:latency", latency);
@ -526,16 +456,14 @@ void BMidiRosterLooper::ChangeLatency(BMessage* msg, BMidiEndpoint* endp)
}
}
//------------------------------------------------------------------------------
void BMidiRosterLooper::AllEndpoints()
void
BMidiRosterLooper::AllEndpoints()
{
BMessage notify;
for (int32 t = 0; t < CountEndpoints(); ++t)
{
for (int32 t = 0; t < CountEndpoints(); ++t) {
BMidiEndpoint* endp = EndpointAt(t);
if (endp->IsRemote() && endp->IsRegistered())
{
if (endp->IsRemote() && endp->IsRegistered()) {
notify.MakeEmpty();
notify.AddInt32("be:op", B_MIDI_REGISTERED);
ChangeEvent(&notify, endp);
@ -543,22 +471,17 @@ void BMidiRosterLooper::AllEndpoints()
}
}
//------------------------------------------------------------------------------
void BMidiRosterLooper::AllConnections()
void
BMidiRosterLooper::AllConnections()
{
for (int32 t = 0; t < CountEndpoints(); ++t)
{
for (int32 t = 0; t < CountEndpoints(); ++t) {
BMidiEndpoint* endp = EndpointAt(t);
if (endp->IsRemote() && endp->IsRegistered())
{
if (endp->IsProducer())
{
if (endp->IsRemote() && endp->IsRegistered()) {
if (endp->IsProducer()) {
BMidiProducer* prod = (BMidiProducer*) endp;
if (prod->LockProducer())
{
for (int32 k = 0; k < prod->CountConsumers(); ++k)
{
if (prod->LockProducer()) {
for (int32 k = 0; k < prod->CountConsumers(); ++k) {
ConnectionEvent(prod, prod->ConsumerAt(k), true);
}
prod->UnlockProducer();
@ -568,35 +491,32 @@ void BMidiRosterLooper::AllConnections()
}
}
//------------------------------------------------------------------------------
void BMidiRosterLooper::ChangeEvent(BMessage* msg, BMidiEndpoint* endp)
void
BMidiRosterLooper::ChangeEvent(BMessage* msg, BMidiEndpoint* endp)
{
ASSERT(watcher != NULL)
ASSERT(fWatcher != NULL)
ASSERT(msg != NULL)
ASSERT(endp != NULL)
msg->what = B_MIDI_EVENT;
msg->AddInt32("be:id", endp->ID());
if (endp->IsConsumer())
{
if (endp->IsConsumer()) {
msg->AddString("be:type", "consumer");
}
else
{
} else {
msg->AddString("be:type", "producer");
}
watcher->SendMessage(msg);
fWatcher->SendMessage(msg);
}
//------------------------------------------------------------------------------
void BMidiRosterLooper::ConnectionEvent(
void
BMidiRosterLooper::ConnectionEvent(
BMidiProducer* prod, BMidiConsumer* cons, bool mustConnect)
{
ASSERT(watcher != NULL)
ASSERT(fWatcher != NULL)
ASSERT(prod != NULL)
ASSERT(cons != NULL)
@ -605,21 +525,18 @@ void BMidiRosterLooper::ConnectionEvent(
notify.AddInt32("be:producer", prod->ID());
notify.AddInt32("be:consumer", cons->ID());
if (mustConnect)
{
if (mustConnect) {
notify.AddInt32("be:op", B_MIDI_CONNECTED);
}
else
{
} else {
notify.AddInt32("be:op", B_MIDI_DISCONNECTED);
}
watcher->SendMessage(&notify);
fWatcher->SendMessage(&notify);
}
//------------------------------------------------------------------------------
void BMidiRosterLooper::DisconnectDeadConsumer(BMidiConsumer* cons)
void
BMidiRosterLooper::DisconnectDeadConsumer(BMidiConsumer* cons)
{
ASSERT(cons != NULL)
@ -627,16 +544,12 @@ void BMidiRosterLooper::DisconnectDeadConsumer(BMidiConsumer* cons)
// of connected consumers, we let ConnectionBroken() tell
// us whether the consumer really was connected.
for (int32 t = 0; t < CountEndpoints(); ++t)
{
for (int32 t = 0; t < CountEndpoints(); ++t) {
BMidiEndpoint* endp = EndpointAt(t);
if (endp->IsProducer())
{
if (endp->IsProducer()) {
BMidiProducer* prod = (BMidiProducer*) endp;
if (prod->ConnectionBroken(cons))
{
if (cons->IsRemote() && (watcher != NULL))
{
if (prod->ConnectionBroken(cons)) {
if (cons->IsRemote() && (fWatcher != NULL)) {
ConnectionEvent(prod, cons, false);
}
}
@ -644,9 +557,9 @@ void BMidiRosterLooper::DisconnectDeadConsumer(BMidiConsumer* cons)
}
}
//------------------------------------------------------------------------------
void BMidiRosterLooper::DisconnectDeadProducer(BMidiProducer* prod)
void
BMidiRosterLooper::DisconnectDeadProducer(BMidiProducer* prod)
{
ASSERT(prod != NULL)
@ -654,42 +567,38 @@ void BMidiRosterLooper::DisconnectDeadProducer(BMidiProducer* prod)
// the producer's list of connections, because when this
// function is called, we're destroying the object.
if (prod->IsRemote() && (watcher != NULL))
{
for (int32 t = 0; t < prod->CountConsumers(); ++t)
{
if (prod->IsRemote() && (fWatcher != NULL)) {
for (int32 t = 0; t < prod->CountConsumers(); ++t) {
ConnectionEvent(prod, prod->ConsumerAt(t), false);
}
}
}
//------------------------------------------------------------------------------
int32 BMidiRosterLooper::CountEndpoints()
int32
BMidiRosterLooper::CountEndpoints()
{
return endpoints.CountItems();
return fEndpoints.CountItems();
}
//------------------------------------------------------------------------------
BMidiEndpoint* BMidiRosterLooper::EndpointAt(int32 index)
BMidiEndpoint*
BMidiRosterLooper::EndpointAt(int32 index)
{
ASSERT(index >= 0 && index < CountEndpoints())
return (BMidiEndpoint*) endpoints.ItemAt(index);
return (BMidiEndpoint*) fEndpoints.ItemAt(index);
}
//------------------------------------------------------------------------------
#ifdef DEBUG
void BMidiRosterLooper::DumpEndpoints()
void
BMidiRosterLooper::DumpEndpoints()
{
if (Lock())
{
if (Lock()) {
printf("*** START DumpEndpoints\n");
for (int32 t = 0; t < CountEndpoints(); ++t)
{
for (int32 t = 0; t < CountEndpoints(); ++t) {
BMidiEndpoint* endp = EndpointAt(t);
printf("\tendpoint %ld (%p):\n", t, endp);
@ -700,25 +609,20 @@ void BMidiRosterLooper::DumpEndpoints()
endp->IsConsumer() ? "consumer" : "producer",
endp->IsRegistered() ? "registered" : "unregistered",
endp->IsLocal() ? "local" : "remote",
endp->IsValid() ? "valid" : "invalid", endp->refCount);
endp->IsValid() ? "valid" : "invalid", endp->fRefCount);
printf("\t\tproperties: ");
endp->properties->PrintToStream();
endp->fProperties->PrintToStream();
if (endp->IsConsumer())
{
if (endp->IsConsumer()) {
BMidiConsumer* cons = (BMidiConsumer*) endp;
printf("\t\tport %ld, latency %Ld\n",
cons->port, cons->latency);
}
else
{
cons->fPort, cons->fLatency);
} else {
BMidiProducer* prod = (BMidiProducer*) endp;
if (prod->LockProducer())
{
if (prod->LockProducer()) {
printf("\t\tconnections:\n");
for (int32 k = 0; k < prod->CountConsumers(); ++k)
{
for (int32 k = 0; k < prod->CountConsumers(); ++k) {
BMidiConsumer* cons = prod->ConsumerAt(k);
printf("\t\t\tid %ld (%p)\n", cons->ID(), cons);
}
@ -733,4 +637,3 @@ void BMidiRosterLooper::DumpEndpoints()
}
#endif
//------------------------------------------------------------------------------

32
src/kits/midi2/MidiRosterLooper.h
View File

@ -1,23 +1,9 @@
/*
* Copyright (c) 2002-2004 Matthijs Hollemans
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
* Copyright 2002-2006, Haiku.
* Distributed under the terms of the MIT License.
*
* Authors:
* Matthijs Hollemans
*/
#ifndef MIDI_ROSTER_LOOPER_H
@ -122,17 +108,17 @@ private:
int32 CountEndpoints();
BMidiEndpoint* EndpointAt(int32 index);
BMidiRoster* roster;
BMidiRoster* fRoster;
// Makes sure BMidiRoster::MidiRoster() does not return
// until confirmation from the midi_server is received.
sem_id initLock;
sem_id fInitLock;
// The object we send B_MIDI_EVENT notifications to.
BMessenger* watcher;
BMessenger* fWatcher;
// All the endpoints in the system, local and remote.
BList endpoints;
BList fEndpoints;
#ifdef DEBUG
void DumpEndpoints();