haiku.git

/*
 * Copyright 2009-2012, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT license.
 */

/*
 * Copyright (c) 2002, 2003 Marcus Overhagen <Marcus@Overhagen.de>
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files or portions
 * thereof (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:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 *  * Redistributions in binary form must reproduce the above copyright notice
 *    in the  binary, as well as this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided with
 *    the distribution.
 *
 * 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.
 *
 */

#include <Controllable.h>

#include <string.h>

#include <OS.h>
#include <ParameterWeb.h>
#include <Roster.h>
#include <TimeSource.h>

#include <MediaDebug.h>
#include <DataExchange.h>
#include <Notifications.h>


namespace BPrivate { namespace media {

/*!	A helper class for the communication with the media server that
	takes care of large buffers that need an area.
*/
class ReceiveTransfer {
public:
	ReceiveTransfer(const area_request_data& request, const void* smallBuffer)
	{
		if (request.area == -1 && smallBuffer != NULL) {
			// small data transfer uses buffer in reply
			fArea = -1;
			fData = const_cast<void*>(smallBuffer);
				// The caller is actually responsible to enforce the const;
				// we don't touch the data.
		} else {
			// large data transfer, clone area
			fArea = clone_area("get parameter data clone", &fData,
				B_ANY_ADDRESS, B_READ_AREA | B_WRITE_AREA, request.area);
			if (fArea < B_OK) {
				ERROR("BControllabe: cloning area failed: %s\n",
					strerror(fArea));
				fData = NULL;
			}
		}
	}

	~ReceiveTransfer()
	{
		if (fArea >= B_OK)
			delete_area(fArea);
	}

	status_t InitCheck() const
	{
		return fData != NULL ? B_OK : fArea;
	}

	void* Data() const
	{
		return fData;
	}

private:
	area_id				fArea;
	void*				fData;
};

} // namespace media
} // namespace BPrivate

using BPrivate::media::ReceiveTransfer;


//	#pragma mark - protected


BControllable::~BControllable()
{
	CALLED();
	if (fSem > 0)
		delete_sem(fSem);

	delete fWeb;
}


//	#pragma mark - public


BParameterWeb*
BControllable::Web()
{
	CALLED();
	return fWeb;
}


bool
BControllable::LockParameterWeb()
{
	CALLED();
	if (fSem <= 0)
		return false;

	if (atomic_add(&fBen, 1) > 0) {
		status_t status;
		do {
			status = acquire_sem(fSem);
		} while (status == B_INTERRUPTED);

		return status == B_OK;
	}

	return true;
}


void
BControllable::UnlockParameterWeb()
{
	CALLED();
	if (fSem <= 0)
		return;

	if (atomic_add(&fBen, -1) > 1)
		release_sem(fSem);
}


//	#pragma mark - protected


BControllable::BControllable()
	: BMediaNode("this one is never called"),
	fWeb(NULL),
	fSem(create_sem(0, "BControllable lock")),
	fBen(0)
{
	CALLED();

	AddNodeKind(B_CONTROLLABLE);
}


status_t
BControllable::SetParameterWeb(BParameterWeb* web)
{
	CALLED();

	LockParameterWeb();
	BParameterWeb* old = fWeb;
	fWeb = web;

	if (fWeb != NULL) {
		// initialize BParameterWeb member variable
		fWeb->fNode = Node();
	}

	UnlockParameterWeb();

	if (old != web && web != NULL)
		BPrivate::media::notifications::WebChanged(Node());
	delete old;
	return B_OK;
}


status_t
BControllable::HandleMessage(int32 message, const void* data, size_t size)
{
	PRINT(4, "BControllable::HandleMessage %#lx, node %ld\n", message, ID());

	switch (message) {
		case CONTROLLABLE_GET_PARAMETER_DATA:
		{
			const controllable_get_parameter_data_request& request
				= *static_cast<const controllable_get_parameter_data_request*>(
					data);
			controllable_get_parameter_data_reply reply;

			ReceiveTransfer transfer(request, reply.raw_data);
			if (transfer.InitCheck() != B_OK) {
				request.SendReply(transfer.InitCheck(), &reply, sizeof(reply));
				return B_OK;
			}

			reply.size = request.request_size;
			status_t status = GetParameterValue(request.parameter_id,
				&reply.last_change, transfer.Data(), &reply.size);

			request.SendReply(status, &reply, sizeof(reply));
			return B_OK;
		}

		case CONTROLLABLE_SET_PARAMETER_DATA:
		{
			const controllable_set_parameter_data_request& request
				= *static_cast<const controllable_set_parameter_data_request*>(
					data);
			controllable_set_parameter_data_reply reply;

			ReceiveTransfer transfer(request, request.raw_data);
			if (transfer.InitCheck() != B_OK) {
				request.SendReply(transfer.InitCheck(), &reply, sizeof(reply));
				return B_OK;
			}

			// NOTE: This is not very fair, but the alternative
			// would have been to mess with friends classes and
			// member variables.
			bigtime_t perfTime = 0;
			if (request.when == -1)
				perfTime = TimeSource()->Now();
			else
				perfTime = request.when;

			SetParameterValue(request.parameter_id, perfTime,
				transfer.Data(), request.size);
			request.SendReply(B_OK, &reply, sizeof(reply));
			return B_OK;
		}

		case CONTROLLABLE_GET_PARAMETER_WEB:
		{
			const controllable_get_parameter_web_request& request
				= *static_cast<const controllable_get_parameter_web_request*>(
					data);
			controllable_get_parameter_web_reply reply;

			status_t status = B_OK;
			bool wasLocked = true;
			if (!LockParameterWeb()) {
				status = B_ERROR;
				wasLocked = false;
			}

			if (status == B_OK && fWeb != NULL) {
				if (fWeb->FlattenedSize() > request.max_size) {
					// parameter web too large
					reply.code = 0;
					reply.size = -1;
					status = B_OK;
				} else {
					ReceiveTransfer transfer(request, NULL);
					status = transfer.InitCheck();
					if (status == B_OK) {
						reply.code = fWeb->TypeCode();
						reply.size = fWeb->FlattenedSize();
						status = fWeb->Flatten(transfer.Data(), reply.size);
						if (status != B_OK) {
							ERROR("BControllable::HandleMessage "
								"CONTROLLABLE_GET_PARAMETER_WEB Flatten failed\n");
#if 0
						} else {
							printf("BControllable::HandleMessage CONTROLLABLE_GET_PARAMETER_WEB %ld bytes, 0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx\n",
								reply.size, ((uint32*)buffer)[0], ((uint32*)buffer)[1], ((uint32*)buffer)[2], ((uint32*)buffer)[3]);
#endif
						}
					}
				}
			} else {
				// no parameter web
				reply.code = 0;
				reply.size = 0;
			}
			if (wasLocked)
				UnlockParameterWeb();

			request.SendReply(status, &reply, sizeof(reply));
			return B_OK;
		}

		case CONTROLLABLE_START_CONTROL_PANEL:
		{
			const controllable_start_control_panel_request* request
				= static_cast<const controllable_start_control_panel_request*>(
					data);
			controllable_start_control_panel_reply reply;
			BMessenger targetMessenger;
			status_t status = StartControlPanel(&targetMessenger);
			if (status != B_OK) {
				ERROR("BControllable::HandleMessage "
					"CONTROLLABLE_START_CONTROL_PANEL failed\n");
			}
			reply.result = status;
			reply.team = targetMessenger.Team();
			request->SendReply(status, &reply, sizeof(reply));
			return B_OK;
		}

		default:
			return B_ERROR;
	}

	return B_OK;
}


status_t
BControllable::BroadcastChangedParameter(int32 id)
{
	CALLED();
	return BPrivate::media::notifications::ParameterChanged(Node(), id);
}


status_t
BControllable::BroadcastNewParameterValue(bigtime_t when, int32 id,
	void* newValue, size_t valueSize)
{
	CALLED();
	return BPrivate::media::notifications::NewParameterValue(Node(), id, when,
		newValue, valueSize);
}


status_t
BControllable::StartControlPanel(BMessenger* _messenger)
{
	CALLED();

	int32 internalId;
	BMediaAddOn* addon = AddOn(&internalId);
	if (!addon) {
		ERROR("BControllable::StartControlPanel not instantiated per AddOn\n");
		return B_ERROR;
	}

	image_id imageID = addon->ImageID();
	image_info info;
	if (imageID <= 0 || get_image_info(imageID, &info) != B_OK) {
		ERROR("BControllable::StartControlPanel Error accessing image\n");
		return B_BAD_VALUE;
	}

	entry_ref ref;
	if (get_ref_for_path(info.name, &ref) != B_OK) {
		ERROR("BControllable::StartControlPanel Error getting ref\n");
		return B_BAD_VALUE;
	}

	// The first argument is "node=id" with id meaning the media_node_id
	char arg[32];
	snprintf(arg, sizeof(arg), "node=%d", (int)ID());

	team_id team;
	if (be_roster->Launch(&ref, 1, (const char* const*)&arg, &team) != B_OK) {
		ERROR("BControllable::StartControlPanel Error launching application\n");
		return B_BAD_VALUE;
	}
	printf("BControllable::StartControlPanel done with id: %" B_PRId32 "\n",
		team);

	if (_messenger)
		*_messenger = BMessenger(NULL, team);

	return B_OK;
}


status_t
BControllable::ApplyParameterData(const void* value, size_t size)
{
	UNIMPLEMENTED();

	return B_ERROR;
}


status_t
BControllable::MakeParameterData(const int32* controls, int32 count,
	void* buffer, size_t* ioSize)
{
	UNIMPLEMENTED();

	return B_ERROR;
}


//	#pragma mark - private


status_t BControllable::_Reserved_Controllable_0(void *) { return B_ERROR; }
status_t BControllable::_Reserved_Controllable_1(void *) { return B_ERROR; }
status_t BControllable::_Reserved_Controllable_2(void *) { return B_ERROR; }
status_t BControllable::_Reserved_Controllable_3(void *) { return B_ERROR; }
status_t BControllable::_Reserved_Controllable_4(void *) { return B_ERROR; }
status_t BControllable::_Reserved_Controllable_5(void *) { return B_ERROR; }
status_t BControllable::_Reserved_Controllable_6(void *) { return B_ERROR; }
status_t BControllable::_Reserved_Controllable_7(void *) { return B_ERROR; }
status_t BControllable::_Reserved_Controllable_8(void *) { return B_ERROR; }
status_t BControllable::_Reserved_Controllable_9(void *) { return B_ERROR; }
status_t BControllable::_Reserved_Controllable_10(void *) { return B_ERROR; }
status_t BControllable::_Reserved_Controllable_11(void *) { return B_ERROR; }
status_t BControllable::_Reserved_Controllable_12(void *) { return B_ERROR; }
status_t BControllable::_Reserved_Controllable_13(void *) { return B_ERROR; }
status_t BControllable::_Reserved_Controllable_14(void *) { return B_ERROR; }
status_t BControllable::_Reserved_Controllable_15(void *) { return B_ERROR; }