haiku.git

/*
 * Copyright 2006, Haiku.
 *
 * Copyright (c) 2002-2004 Matthijs Hollemans
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Matthijs Hollemans
 */

#include "debug.h"
#include <MidiConsumer.h>
#include <MidiProducer.h>
#include <MidiRoster.h>
#include "MidiRosterLooper.h"
#include "protocol.h"

using namespace BPrivate;


BMidiRosterLooper::BMidiRosterLooper()
	: BLooper("MidiRosterLooper")
{
	fInitLock = -1;
	fRoster = NULL;
	fWatcher = NULL;
}


BMidiRosterLooper::~BMidiRosterLooper()
{
	StopWatching();

	if (fInitLock >= B_OK) {
		delete_sem(fInitLock); 
	}

	// At this point, our list may still contain endpoints with a 
	// zero reference count. These objects are proxies for remote 
	// endpoints, so we can safely delete them. If the list also 
	// contains endpoints with a non-zero refcount (which can be 
	// either remote or local), we will output a warning message.
	// 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) {
		BMidiEndpoint* endp = EndpointAt(t);
		if (endp->fRefCount > 0) {
			fprintf(
				stderr, "[midi] WARNING: Endpoint %" B_PRId32 " (%p) has "
				"not been Release()d properly (refcount = %" B_PRId32 ")\n",
				endp->ID(), endp, endp->fRefCount);
		} else {
			delete endp;
		}
	}
}


bool 
BMidiRosterLooper::Init(BMidiRoster* roster_)
{
	ASSERT(roster_ != NULL)

	fRoster = roster_;

	// We create a semaphore with a zero count. BMidiRoster's
	// MidiRoster() method will try to acquire this semaphore,
	// but blocks because the count is 0. When we receive the
	// "app registered" message in our MessageReceived() hook,
	// we release the semaphore and MidiRoster() will unblock.

	fInitLock = create_sem(0, "InitLock");

	if (fInitLock < B_OK) {
		WARN("Could not create semaphore")
		return false;
	}

	thread_id threadId = Run();

	if (threadId < B_OK) {
		WARN("Could not start looper thread") 
		return false;
	}

	return true;
}


BMidiEndpoint* 
BMidiRosterLooper::NextEndpoint(int32* id)
{
	ASSERT(id != NULL)

	for (int32 t = 0; t < CountEndpoints(); ++t) {
		BMidiEndpoint* endp = EndpointAt(t);
		if (endp->ID() > *id) {
			if (endp->IsRemote() && endp->IsRegistered()) {
				*id = endp->ID();
				return endp;
			}
		}
	}

	return NULL;
}


BMidiEndpoint* 
BMidiRosterLooper::FindEndpoint(int32 id)
{
	for (int32 t = 0; t < CountEndpoints(); ++t) {
		BMidiEndpoint* endp = EndpointAt(t);
		if (endp->ID() == id) {
			return endp;
		}
	} 

	return NULL;
}


void 
BMidiRosterLooper::AddEndpoint(BMidiEndpoint* endp)
{
	ASSERT(endp != NULL)
	ASSERT(!fEndpoints.HasItem(endp))

	// We store the endpoints sorted by ID, because that
	// simplifies the implementation of NextEndpoint().
	// Although the midi_server assigns IDs in ascending
	// order, we can't assume that the mNEW messages also
	// are delivered in this order (mostly they will be).

	int32 t;
	for (t = CountEndpoints(); t > 0; --t) {
		BMidiEndpoint* other = EndpointAt(t - 1);
		if (endp->ID() > other->ID()) {
			break;
		}	
	}
	fEndpoints.AddItem(endp, t);

	#ifdef DEBUG
	DumpEndpoints();
	#endif
}


void 
BMidiRosterLooper::RemoveEndpoint(BMidiEndpoint* endp)
{
	ASSERT(endp != NULL)
	ASSERT(fEndpoints.HasItem(endp))

	fEndpoints.RemoveItem(endp);

	if (endp->IsConsumer()) {
		DisconnectDeadConsumer((BMidiConsumer*) endp);
	} else {
		DisconnectDeadProducer((BMidiProducer*) endp);
	}
	
	#ifdef DEBUG
	DumpEndpoints();
	#endif
}


void 
BMidiRosterLooper::StartWatching(const BMessenger* watcher_)
{
	ASSERT(watcher_ != NULL)

	StopWatching();
	fWatcher = new BMessenger(*watcher_);

	AllEndpoints();
	AllConnections();
}


void 
BMidiRosterLooper::StopWatching()
{
	delete fWatcher;
	fWatcher = NULL;
}


void 
BMidiRosterLooper::MessageReceived(BMessage* msg)
{
	#ifdef DEBUG
	printf("IN "); msg->PrintToStream();
	#endif

	switch (msg->what) {
		case MSG_APP_REGISTERED:         OnAppRegistered(msg);         break;
		case MSG_ENDPOINT_CREATED:       OnEndpointCreated(msg);       break;
		case MSG_ENDPOINT_DELETED:       OnEndpointDeleted(msg);       break;
		case MSG_ENDPOINT_CHANGED:       OnEndpointChanged(msg);       break;
		case MSG_ENDPOINTS_CONNECTED:    OnConnectedDisconnected(msg); break;
		case MSG_ENDPOINTS_DISCONNECTED: OnConnectedDisconnected(msg); break;

		default: super::MessageReceived(msg); break;
	}	
}


void 
BMidiRosterLooper::OnAppRegistered(BMessage* msg)
{
	release_sem(fInitLock);
}


void 
BMidiRosterLooper::OnEndpointCreated(BMessage* msg)
{
	int32 id;
	bool isRegistered;
	BString name;
	BMessage properties;
	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) {
			int32 port;
			bigtime_t latency;

			if ((msg->FindInt32("midi:port", &port) == B_OK)
				&&  (msg->FindInt64("midi:latency", &latency) == B_OK)) {
				BMidiConsumer* cons = new BMidiConsumer();
				cons->fName          = name;
				cons->fId            = id;
				cons->fIsRegistered  = isRegistered;
				cons->fPort          = port;
				cons->fLatency       = latency;
				*(cons->fProperties) = properties;
				AddEndpoint(cons);
				return;
			}
		} else { // producer
			BMidiProducer* prod = new BMidiProducer();
			prod->fName          = name;
			prod->fId            = id;
			prod->fIsRegistered  = isRegistered;
			*(prod->fProperties) = properties;
			AddEndpoint(prod);
			return;
		}
	}

	WARN("Could not create proxy for remote endpoint")
}


void 
BMidiRosterLooper::OnEndpointDeleted(BMessage* msg)
{
	int32 id;
	if (msg->FindInt32("midi:id", &id) == B_OK) {
		BMidiEndpoint* endp = FindEndpoint(id);
		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 (fWatcher != NULL) {
					BMessage notify;
					notify.AddInt32("be:op", B_MIDI_UNREGISTERED);
					ChangeEvent(&notify, endp);
				}
			}

			// If the proxy object for this endpoint is no 
			// longer being used, we can delete it. However, 
			// if the refcount is not zero, we must defer 
			// destruction until the client Release()'s the 
			// object. We clear the "isRegistered" flag to
			// let the client know the object is now invalid.

			if (endp->fRefCount == 0) {
				delete endp;
			} else { // still being used
				endp->fIsRegistered = false;
				endp->fIsAlive = false;
			}

			return;
		}
	}

	WARN("Could not delete proxy for remote endpoint")
}


void 
BMidiRosterLooper::OnEndpointChanged(BMessage* msg)
{
	int32 id;
	if (msg->FindInt32("midi:id", &id) == B_OK) {
		BMidiEndpoint* endp = FindEndpoint(id);
		if ((endp != NULL) && endp->IsRemote()) {
			ChangeRegistered(msg, endp);
			ChangeName(msg, endp);
			ChangeProperties(msg, endp);
			ChangeLatency(msg, endp);

			#ifdef DEBUG
			DumpEndpoints();
			#endif

			return;
		}
	}

	WARN("Could not change endpoint attributes")
}


void 
BMidiRosterLooper::OnConnectedDisconnected(BMessage* msg)
{
	int32 prodId, consId;
	if ((msg->FindInt32("midi:producer", &prodId) == 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()) {
				BMidiProducer* prod = (BMidiProducer*) endp1;
				BMidiConsumer* cons = (BMidiConsumer*) endp2;

				bool mustConnect = (msg->what == MSG_ENDPOINTS_CONNECTED);

				if (mustConnect) {
					prod->ConnectionMade(cons);
				} else {
					prod->ConnectionBroken(cons);
				}

				if (fWatcher != NULL) {
					ConnectionEvent(prod, cons, mustConnect);
				}

				#ifdef DEBUG
				DumpEndpoints();
				#endif

				return;
			}
		}
	}

	WARN("Could not connect/disconnect endpoints")
}


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->fIsRegistered != isRegistered) {
			endp->fIsRegistered = isRegistered;

			if (fWatcher != NULL) {
				BMessage notify;
				if (isRegistered) {
					notify.AddInt32("be:op", B_MIDI_REGISTERED);
				} else {
					notify.AddInt32("be:op", B_MIDI_UNREGISTERED);
				}
				ChangeEvent(&notify, 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->fName != name) {
			endp->fName = name;

			if ((fWatcher != NULL) && endp->IsRegistered()) {
				BMessage notify;
				notify.AddInt32("be:op", B_MIDI_CHANGED_NAME);
				notify.AddString("be:name", name);
				ChangeEvent(&notify, 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->fProperties) = properties;

		if ((fWatcher != NULL) && endp->IsRegistered()) {
			BMessage notify;
			notify.AddInt32("be:op", B_MIDI_CHANGED_PROPERTIES);
			notify.AddMessage("be:properties", &properties);
			ChangeEvent(&notify, 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()) {
			BMidiConsumer* cons = (BMidiConsumer*) endp;
			if (cons->fLatency != latency) {
				cons->fLatency = latency;

				if ((fWatcher != NULL) && cons->IsRegistered()) {
					BMessage notify;
					notify.AddInt32("be:op", B_MIDI_CHANGED_LATENCY);
					notify.AddInt64("be:latency", latency);
					ChangeEvent(&notify, endp);
				}
			}
		}
	}
}


void 
BMidiRosterLooper::AllEndpoints()
{
	BMessage notify;
	for (int32 t = 0; t < CountEndpoints(); ++t) {
		BMidiEndpoint* endp = EndpointAt(t);
		if (endp->IsRemote() && endp->IsRegistered()) {
			notify.MakeEmpty();
			notify.AddInt32("be:op", B_MIDI_REGISTERED);
			ChangeEvent(&notify, endp);
		}
	}
}


void 
BMidiRosterLooper::AllConnections()
{
	for (int32 t = 0; t < CountEndpoints(); ++t) {
		BMidiEndpoint* endp = EndpointAt(t);
		if (endp->IsRemote() && endp->IsRegistered()) {
			if (endp->IsProducer()) {
				BMidiProducer* prod = (BMidiProducer*) endp;
				if (prod->LockProducer()) {
					for (int32 k = 0; k < prod->CountConsumers(); ++k) {
						ConnectionEvent(prod, prod->ConsumerAt(k), true);
					}
					prod->UnlockProducer();
				}
			}
		}
	}
}


void 
BMidiRosterLooper::ChangeEvent(BMessage* msg, BMidiEndpoint* endp)
{
	ASSERT(fWatcher != NULL)
	ASSERT(msg != NULL)
	ASSERT(endp != NULL)

	msg->what = B_MIDI_EVENT;
	msg->AddInt32("be:id", endp->ID());

	if (endp->IsConsumer()) {
		msg->AddString("be:type", "consumer");
	} else {
		msg->AddString("be:type", "producer");
	}

	fWatcher->SendMessage(msg);
}


void 
BMidiRosterLooper::ConnectionEvent(
	BMidiProducer* prod, BMidiConsumer* cons, bool mustConnect)
{
	ASSERT(fWatcher != NULL)
	ASSERT(prod != NULL)
	ASSERT(cons != NULL)

	BMessage notify;
	notify.what = B_MIDI_EVENT;
	notify.AddInt32("be:producer", prod->ID());
	notify.AddInt32("be:consumer", cons->ID());

	if (mustConnect) {
		notify.AddInt32("be:op", B_MIDI_CONNECTED);
	} else {
		notify.AddInt32("be:op", B_MIDI_DISCONNECTED);
	}

	fWatcher->SendMessage(&notify);
}


void 
BMidiRosterLooper::DisconnectDeadConsumer(BMidiConsumer* cons)
{
	ASSERT(cons != NULL)

	// Note: Rather than looping through each producer's list
	// of connected consumers, we let ConnectionBroken() tell
	// us whether the consumer really was connected.

	for (int32 t = 0; t < CountEndpoints(); ++t) {
		BMidiEndpoint* endp = EndpointAt(t);
		if (endp->IsProducer()) {
			BMidiProducer* prod = (BMidiProducer*) endp;
			if (prod->ConnectionBroken(cons)) {
				if (cons->IsRemote() && (fWatcher != NULL)) {
					ConnectionEvent(prod, cons, false);
				}
			}
		}
	}
}


void 
BMidiRosterLooper::DisconnectDeadProducer(BMidiProducer* prod)
{
	ASSERT(prod != NULL)

	// We don't need to lock or remove the consumers from
	// the producer's list of connections, because when this
	// function is called, we're destroying the object.

	if (prod->IsRemote() && (fWatcher != NULL)) {
		for (int32 t = 0; t < prod->CountConsumers(); ++t) {
			ConnectionEvent(prod, prod->ConsumerAt(t), false);
		}
	}
}


int32 
BMidiRosterLooper::CountEndpoints()
{
	return fEndpoints.CountItems();
}


BMidiEndpoint* 
BMidiRosterLooper::EndpointAt(int32 index)
{
	ASSERT(index >= 0 && index < CountEndpoints())

	return (BMidiEndpoint*) fEndpoints.ItemAt(index);
}


#ifdef DEBUG
void 
BMidiRosterLooper::DumpEndpoints()
{
	if (Lock()) {
		printf("*** START DumpEndpoints\n");

		for (int32 t = 0; t < CountEndpoints(); ++t) {
			BMidiEndpoint* endp = EndpointAt(t);

			printf("\tendpoint %" B_PRId32 " (%p):\n", t, endp);

			printf(
				"\t\tid %" B_PRId32 ", name '%s', %s, %s, %s, %s, refcount %"
				B_PRId32 "\n", endp->ID(), endp->Name(),
				endp->IsConsumer() ? "consumer" : "producer", 
				endp->IsRegistered() ? "registered" : "unregistered", 
				endp->IsLocal() ? "local" : "remote", 
				endp->IsValid() ? "valid" : "invalid", endp->fRefCount);

			printf("\t\tproperties: "); 
			endp->fProperties->PrintToStream();

			if (endp->IsConsumer()) {
				BMidiConsumer* cons = (BMidiConsumer*) endp;
				printf("\t\tport %" B_PRId32 ", latency %" B_PRIdBIGTIME "\n",
						cons->fPort, cons->fLatency);
			} else {
				BMidiProducer* prod = (BMidiProducer*) endp;
				if (prod->LockProducer()) {
					printf("\t\tconnections:\n");
					for (int32 k = 0; k < prod->CountConsumers(); ++k) {
						BMidiConsumer* cons = prod->ConsumerAt(k);
						printf("\t\t\tid %" B_PRId32 " (%p)\n", cons->ID(),
							cons);
					}
					prod->UnlockProducer();
				}
			}
		}

		printf("*** END DumpEndpoints\n");
		Unlock();
	}
}
#endif