haiku/src/kits/media/MediaFiles.cpp

/*
 * Copyright 2002-2009, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Marcus Overhagen
 *		Jérôme Duval
 */


#include <MediaFiles.h>

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


const char BMediaFiles::B_SOUNDS[] = "Sounds";


BMediaFiles::BMediaFiles()
	:
	fTypeIndex(-1),
	fItemIndex(-1)
{

}


BMediaFiles::~BMediaFiles()
{
	_ClearTypes();
	_ClearItems();
}


status_t
BMediaFiles::RewindTypes()
{
	CALLED();

	_ClearTypes();

	server_get_media_types_request request;
	request.team = BPrivate::current_team();

	server_get_media_types_reply reply;
	status_t status = QueryServer(SERVER_GET_MEDIA_FILE_TYPES, &request,
		sizeof(request), &reply, sizeof(reply));
	if (status != B_OK) {
		ERROR("BMediaFiles::RewindTypes: failed to rewind types: %s\n",
			strerror(status));
		return status;
	}

	const char* types = (const char*)reply.address;
	for (int32 i = 0; i < reply.count; i++)
		fTypes.AddItem(new BString(types + i * B_MEDIA_NAME_LENGTH));

	delete_area(reply.area);

	fTypeIndex = 0;
	return B_OK;
}


status_t
BMediaFiles::GetNextType(BString* _type)
{
	CALLED();
	if (fTypeIndex < 0 || fTypeIndex >= fTypes.CountItems()) {
		_ClearTypes();
		fTypeIndex = -1;
		return B_BAD_INDEX;
	}

	*_type = *(BString*)fTypes.ItemAt(fTypeIndex);
	fTypeIndex++;

	return B_OK;
}


status_t
BMediaFiles::RewindRefs(const char* type)
{
	CALLED();

	_ClearItems();

	TRACE("BMediaFiles::RewindRefs: sending SERVER_GET_MEDIA_FILE_ITEMS for "
		"type %s\n", type);

	server_get_media_items_request request;
	request.team = BPrivate::current_team();
	strlcpy(request.type, type, B_MEDIA_NAME_LENGTH);

	server_get_media_items_reply reply;
	status_t status = QueryServer(SERVER_GET_MEDIA_FILE_ITEMS, &request,
		sizeof(request), &reply, sizeof(reply));
	if (status != B_OK) {
		ERROR("BMediaFiles::RewindRefs: failed to rewind refs: %s\n",
			strerror(status));
		return status;
	}

	const char* items = (const char*)reply.address;
	for (int32 i = 0; i < reply.count; i++) {
		fItems.AddItem(new BString(items + i * B_MEDIA_NAME_LENGTH,
			B_MEDIA_NAME_LENGTH));
	}

	delete_area(reply.area);

	fCurrentType = type;
	fItemIndex = 0;
	return B_OK;
}


status_t
BMediaFiles::GetNextRef(BString* _type, entry_ref* _ref)
{
	CALLED();
	if (fItemIndex < 0 || fItemIndex >= fItems.CountItems()) {
		_ClearItems();
		fItemIndex = -1;
		return B_BAD_INDEX;
	}

	*_type = *(BString*)fItems.ItemAt(fItemIndex);
	GetRefFor(fCurrentType.String(), _type->String(), _ref);

	fItemIndex++;
	return B_OK;
}


status_t
BMediaFiles::GetRefFor(const char* type, const char* item, entry_ref* _ref)
{
	CALLED();

	if (type == NULL || item == NULL || _ref == NULL)
		return B_BAD_VALUE;

	server_get_ref_for_request request;
	strlcpy(request.type, type, B_MEDIA_NAME_LENGTH);
	strlcpy(request.item, item, B_MEDIA_NAME_LENGTH);

	server_get_ref_for_reply reply;
	status_t status = QueryServer(SERVER_GET_REF_FOR, &request, sizeof(request),
		&reply, sizeof(reply));
	if (status != B_OK) {
		ERROR("BMediaFiles::GetRefFor: failed: %s\n", strerror(status));
		return status;
	}

	*_ref = reply.ref;
	return B_OK;
}


status_t
BMediaFiles::GetAudioGainFor(const char* type, const char* item, float* _gain)
{
	CALLED();

	if (type == NULL || item == NULL || _gain == NULL)
		return B_BAD_VALUE;

	server_get_item_audio_gain_request request;
	strlcpy(request.type, type, B_MEDIA_NAME_LENGTH);
	strlcpy(request.item, item, B_MEDIA_NAME_LENGTH);

	server_get_item_audio_gain_reply reply;
	status_t status = QueryServer(SERVER_GET_ITEM_AUDIO_GAIN, &request,
		sizeof(request), &reply, sizeof(reply));
	if (status != B_OK) {
		ERROR("BMediaFiles::GetRefFor: failed: %s\n", strerror(status));
		return status;
	}

	*_gain = reply.gain;
	return B_OK;
}


status_t
BMediaFiles::SetRefFor(const char* type, const char* item,
	const entry_ref& ref)
{
	CALLED();

	server_set_ref_for_request request;
	strlcpy(request.type, type, B_MEDIA_NAME_LENGTH);
	strlcpy(request.item, item, B_MEDIA_NAME_LENGTH);
	request.ref = ref;

	server_set_ref_for_reply reply;
	status_t status = QueryServer(SERVER_SET_REF_FOR, &request, sizeof(request),
		&reply, sizeof(reply));
	if (status != B_OK) {
		ERROR("BMediaFiles::SetRefFor: failed: %s\n", strerror(status));
		return status;
	}

	return B_OK;
}


status_t
BMediaFiles::SetAudioGainFor(const char* type, const char* item, float gain)
{
	CALLED();

	server_set_item_audio_gain_request request;
	strlcpy(request.type, type, B_MEDIA_NAME_LENGTH);
	strlcpy(request.item, item, B_MEDIA_NAME_LENGTH);
	request.gain = gain;

	server_set_item_audio_gain_reply reply;
	status_t status = QueryServer(SERVER_SET_ITEM_AUDIO_GAIN, &request,
		sizeof(request), &reply, sizeof(reply));
	if (status != B_OK) {
		ERROR("BMediaFiles::SetAudioGainFor: failed: %s\n", strerror(status));
		return status;
	}

	return B_OK;
}


status_t
BMediaFiles::RemoveRefFor(const char* type, const char* item,
	const entry_ref &ref)
{
	CALLED();

	server_invalidate_item_request request;
	strlcpy(request.type, type, B_MEDIA_NAME_LENGTH);
	strlcpy(request.item, item, B_MEDIA_NAME_LENGTH);

	server_invalidate_item_reply reply;
	status_t status = QueryServer(SERVER_INVALIDATE_MEDIA_ITEM, &request,
		sizeof(request), &reply, sizeof(reply));
	if (status != B_OK) {
		ERROR("BMediaFiles::RemoveRefFor: failed: %s\n", strerror(status));
		return status;
	}

	return B_OK;
}


status_t
BMediaFiles::RemoveItem(const char* type, const char* item)
{
	CALLED();

	server_remove_media_item_request request;
	strlcpy(request.type, type, B_MEDIA_NAME_LENGTH);
	strlcpy(request.item, item, B_MEDIA_NAME_LENGTH);

	server_remove_media_item_reply reply;
	status_t status = QueryServer(SERVER_REMOVE_MEDIA_ITEM, &request,
		sizeof(request), &reply, sizeof(reply));
	if (status != B_OK) {
		ERROR("BMediaFiles::RemoveItem: failed: %s\n", strerror(status));
		return status;
	}

	return B_OK;
}


// #pragma mark - private


void
BMediaFiles::_ClearTypes()
{
	for (int32 i = 0; i < fTypes.CountItems(); i++)
		delete (BString*)fTypes.ItemAt(i);

	fTypes.MakeEmpty();
}


void
BMediaFiles::_ClearItems()
{
	for (int32 i = 0; i < fItems.CountItems(); i++)
		delete (BString*)fItems.ItemAt(i);

	fItems.MakeEmpty();
}


// #pragma mark - FBC padding


status_t
BMediaFiles::_Reserved_MediaFiles_0(void*,...)
{
	// TODO: Someone didn't understand FBC
	return B_ERROR;
}


status_t BMediaFiles::_Reserved_MediaFiles_1(void*,...) { return B_ERROR; }
status_t BMediaFiles::_Reserved_MediaFiles_2(void*,...) { return B_ERROR; }
status_t BMediaFiles::_Reserved_MediaFiles_3(void*,...) { return B_ERROR; }
status_t BMediaFiles::_Reserved_MediaFiles_4(void*,...) { return B_ERROR; }
status_t BMediaFiles::_Reserved_MediaFiles_5(void*,...) { return B_ERROR; }
status_t BMediaFiles::_Reserved_MediaFiles_6(void*,...) { return B_ERROR; }
status_t BMediaFiles::_Reserved_MediaFiles_7(void*,...) { return B_ERROR; }