/*
 * Copyright 2015, Dario Casalinuovo. All rights reserved.
 * Distributed under the terms of the MIT License.
 */
 
#include <SimpleMediaClient.h>
 
#include <MediaDebug.h>
 
 
BSimpleMediaClient::BSimpleMediaClient(const char* name,
	media_type type, media_client_kinds kinds)
	:
	BMediaClient(name, type, kinds),
	fNotifyHook(NULL),
	fNotifyCookie(NULL)
{
	CALLED();
}
 
 
BSimpleMediaClient::~BSimpleMediaClient()
{
	CALLED();
}
 
 
BSimpleMediaInput*
BSimpleMediaClient::BeginInput()
{
	CALLED();
 
	BSimpleMediaInput* input = new BSimpleMediaInput();
	RegisterInput(input);
	return input;
}
 
 
BSimpleMediaOutput*
BSimpleMediaClient::BeginOutput()
{
	CALLED();
 
	BSimpleMediaOutput* output = new BSimpleMediaOutput();
	RegisterOutput(output);
	return output;
}
 
 
void
BSimpleMediaClient::SetHook(notify_hook notifyHook, void* cookie)
{
	CALLED();
 
	fNotifyHook = notifyHook;
	fNotifyCookie = cookie;
}
 
 
void
BSimpleMediaClient::HandleStart(bigtime_t performanceTime)
{
	if (fNotifyHook != NULL) {
		(*fNotifyHook)(BSimpleMediaClient::fNotifyCookie,
			BSimpleMediaClient::B_WILL_START,
			performanceTime);
	}
}
 
 
void
BSimpleMediaClient::HandleStop(bigtime_t performanceTime)
{
	if (fNotifyHook != NULL) {
		(*fNotifyHook)(BSimpleMediaClient::fNotifyCookie,
			BSimpleMediaClient::B_WILL_STOP,
			performanceTime);
	}
}
 
 
void
BSimpleMediaClient::HandleSeek(bigtime_t mediaTime, bigtime_t performanceTime)
{
	if (fNotifyHook != NULL) {
		(*fNotifyHook)(BSimpleMediaClient::fNotifyCookie,
			BSimpleMediaClient::B_WILL_SEEK,
			performanceTime, mediaTime);
	}
}
 
 
status_t
BSimpleMediaClient::FormatSuggestion(media_type type, int32 quality,
	media_format* format)
{
	if (fNotifyHook != NULL) {
		status_t result = B_ERROR;
		(*fNotifyHook)(BSimpleMediaClient::fNotifyCookie,
			BSimpleMediaClient::B_FORMAT_SUGGESTION,
			type, quality, format, &result);
		return result;
	}
	return B_ERROR;
}
 
 
void BSimpleMediaClient::_ReservedSimpleMediaClient0() {}
void BSimpleMediaClient::_ReservedSimpleMediaClient1() {}
void BSimpleMediaClient::_ReservedSimpleMediaClient2() {}
void BSimpleMediaClient::_ReservedSimpleMediaClient3() {}
void BSimpleMediaClient::_ReservedSimpleMediaClient4() {}
void BSimpleMediaClient::_ReservedSimpleMediaClient5() {}
 
 
BSimpleMediaConnection::BSimpleMediaConnection(media_connection_kinds kinds)
	:
	BMediaConnection(kinds),
	fProcessHook(NULL),
	fNotifyHook(NULL),
	fBufferCookie(NULL)
{
}
 
 
BSimpleMediaConnection::~BSimpleMediaConnection()
{
	CALLED();
}
 
 
void
BSimpleMediaConnection::SetHooks(process_hook processHook,
	notify_hook notifyHook, void* cookie)
{
	CALLED();
 
	fProcessHook = processHook;
	fNotifyHook = notifyHook;
	fBufferCookie = cookie;
}
 
 
void*
BSimpleMediaConnection::Cookie() const
{
	CALLED();
 
	return fBufferCookie;
}
 
 
size_t
BSimpleMediaConnection::BufferSize() const
{
	return fBufferSize;
}
 
 
void
BSimpleMediaConnection::SetBufferSize(size_t bufferSize)
{
	fBufferSize = bufferSize;
}
 
 
void
BSimpleMediaConnection::SetAcceptedFormat(const media_format& format)
{
	CALLED();
 
	fAcceptedFormat = format;
}
 
 
const media_format&
BSimpleMediaConnection::AcceptedFormat() const
{
	CALLED();
 
	return fAcceptedFormat;
}
 
 
BSimpleMediaInput::BSimpleMediaInput()
	:
	BMediaConnection(B_MEDIA_INPUT),
	BSimpleMediaConnection(B_MEDIA_INPUT),
	BMediaInput()
{
}
 
 
BSimpleMediaInput::~BSimpleMediaInput()
{
	CALLED();
}
 
 
status_t
BSimpleMediaInput::AcceptFormat(media_format* format)
{
	CALLED();
 
	// TODO: Add hooks
 
	if (format_is_compatible(*format, AcceptedFormat()))
		return B_OK;
 
	*format = AcceptedFormat();
 
	return B_MEDIA_BAD_FORMAT;
}
 
 
void
BSimpleMediaInput::Connected(const media_format& format)
{
	if (fNotifyHook != NULL)
		(*fNotifyHook)(this, BSimpleMediaConnection::B_INPUT_CONNECTED);
 
	SetAcceptedFormat(format);
 
	BMediaInput::Connected(format);
}
 
 
void
BSimpleMediaInput::Disconnected()
{
	if (fNotifyHook != NULL)
		(*fNotifyHook)(this, BSimpleMediaConnection::B_INPUT_DISCONNECTED);
 
	BMediaInput::Disconnected();
}
 
 
void
BSimpleMediaInput::HandleBuffer(BBuffer* buffer)
{
	CALLED();
 
	if (fProcessHook != NULL)
		(*fProcessHook)(this, buffer);
}
 
 
BSimpleMediaOutput::BSimpleMediaOutput()
	:
	BMediaConnection(B_MEDIA_OUTPUT),
	BSimpleMediaConnection(B_MEDIA_OUTPUT),
	BMediaOutput()
{
}
 
 
BSimpleMediaOutput::~BSimpleMediaOutput()
{
	CALLED();
}
 
 
status_t
BSimpleMediaOutput::PrepareToConnect(media_format* format)
{
	// TODO: Add hooks
 
	if (!format_is_compatible(AcceptedFormat(), *format))
		return B_ERROR;
 
	return B_OK;
}
 
 
status_t
BSimpleMediaOutput::FormatProposal(media_format* format)
{
	if (fNotifyHook != NULL) {
		return (*fNotifyHook)(this,
			BSimpleMediaConnection::B_FORMAT_PROPOSAL, format);
	} else
		*format = AcceptedFormat();
 
	return B_OK;
}
 
 
void
BSimpleMediaOutput::Connected(const media_format& format)
{
	if (fNotifyHook != NULL)
		(*fNotifyHook)(this, BSimpleMediaConnection::B_OUTPUT_CONNECTED);
 
	SetAcceptedFormat(format);
 
	BMediaOutput::Connected(format);
}
 
 
void
BSimpleMediaOutput::Disconnected()
{
	if (fNotifyHook != NULL)
		(*fNotifyHook)(this, BSimpleMediaConnection::B_OUTPUT_DISCONNECTED);
 
	BMediaOutput::Disconnected();
}