/*
 * Copyright 2001-2012 Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Christopher ML Zumwalt May (zummy@users.sf.net)
 */


#include <SimpleGameSound.h>

#include <Entry.h>
#include <MediaFile.h>
#include <MediaTrack.h>
#include <stdlib.h>
#include <string.h>

#include "GameSoundBuffer.h"
#include "GameSoundDefs.h"
#include "GameSoundDevice.h"
#include "GSUtility.h"


BSimpleGameSound::BSimpleGameSound(const entry_ref *inFile,
	BGameSoundDevice *device)
	:
	BGameSound(device)
{
	if (InitCheck() == B_OK)
		SetInitError(Init(inFile));
}


BSimpleGameSound::BSimpleGameSound(const char *inFile, BGameSoundDevice *device)
	:
	BGameSound(device)
{
	if (InitCheck() == B_OK) {
		entry_ref file;

		if (get_ref_for_path(inFile, &file) != B_OK)
			SetInitError(B_ENTRY_NOT_FOUND);
		else
			SetInitError(Init(&file));
	}
}


BSimpleGameSound::BSimpleGameSound(const void *inData, size_t inFrameCount,
	const gs_audio_format *format, BGameSoundDevice *device)
	:
	BGameSound(device)
{
	if (InitCheck() != B_OK)
		return;

	gs_audio_format actual = *format;
	if (actual.byte_order == 0)
		actual.byte_order = B_MEDIA_HOST_ENDIAN;

	size_t frameSize
		= get_sample_size(format->format) * format->channel_count;
	uchar * data = new uchar[inFrameCount * frameSize];
	memcpy(data, inData, inFrameCount * frameSize);

	SetInitError(Init(data, inFrameCount, &actual));
}


BSimpleGameSound::BSimpleGameSound(const BSimpleGameSound &other)
	:
	BGameSound(other)
{
	gs_audio_format format;
	void *data = NULL;

	status_t error = other.Device()->Buffer(other.ID(), &format, data);
	if (error != B_OK)
		SetInitError(error);

	Init(data, 0, &format);
	free(data);
}


BSimpleGameSound::~BSimpleGameSound()
{
}


BGameSound *
BSimpleGameSound::Clone() const
{
	gs_audio_format format;
	void *data = NULL;

	status_t error = Device()->Buffer(ID(), &format, data);
	if (error != B_OK)
		return NULL;

	BSimpleGameSound *clone = new BSimpleGameSound(data, 0, &format, Device());
	free(data);

	return clone;
}


/* virtual */ status_t
BSimpleGameSound::Perform(int32 selector, void * data)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::SetIsLooping(bool looping)
{
	gs_attribute attribute;

	attribute.attribute = B_GS_LOOPING;
	attribute.value = (looping) ? -1.0 : 0.0;
	attribute.duration = bigtime_t(0);
	attribute.flags = 0;

	return Device()->SetAttributes(ID(), &attribute, 1);
}


bool
BSimpleGameSound::IsLooping() const
{
	gs_attribute attribute;

	attribute.attribute = B_GS_LOOPING;
	attribute.flags = 0;

	if (Device()->GetAttributes(ID(), &attribute, 1) != B_OK)
		return false;

	return bool(attribute.value);
}


status_t
BSimpleGameSound::Init(const entry_ref* inFile)
{
	BMediaFile file(inFile);
	gs_audio_format gsformat;
	media_format mformat;
	int64 framesRead, framesTotal = 0;

	if (file.InitCheck() != B_OK)
		return file.InitCheck();

	BMediaTrack* audioStream = file.TrackAt(0);
	audioStream->EncodedFormat(&mformat);
	if (!mformat.IsAudio())
		return B_ERROR;

	int64 frames = audioStream->CountFrames();

	mformat.Clear();
	mformat.type = B_MEDIA_RAW_AUDIO;
//	mformat.u.raw_audio.byte_order
//		= (B_HOST_IS_BENDIAN) ? B_MEDIA_BIG_ENDIAN : B_MEDIA_LITTLE_ENDIAN;
	status_t error = audioStream->DecodedFormat(&mformat);
	if (error != B_OK)
		return error;

	memset(&gsformat, 0, sizeof(gs_audio_format));
	media_to_gs_format(&gsformat, &mformat.u.raw_audio);

	if (mformat.u.raw_audio.format == media_raw_audio_format::B_AUDIO_CHAR) {
		// The GameKit doesnt support this format so we will have to reformat
		// the data into something the GameKit does support.
		char * buffer = new char[gsformat.buffer_size];
		uchar * data = new uchar[frames * gsformat.channel_count];

		while (framesTotal < frames) {
			// read the next chunck from the stream
			memset(buffer, 0, gsformat.buffer_size);
			audioStream->ReadFrames(buffer, &framesRead);

			// refomat the buffer from
			int64 position = framesTotal * gsformat.channel_count;
			for (int32 i = 0; i < (int32)gsformat.buffer_size; i++)
				data[i + position] = buffer[i] + 128;

			framesTotal += framesRead;
		}
		delete [] buffer;

		gsformat.format = gs_audio_format::B_GS_U8;

		error = Init(data, frames, &gsformat);

		// free the buffers we no longer need
	} else {
		// We need to determine the size, in bytes, of a single sample.
		// At the same time, we will store the format of the audio buffer
		size_t frameSize
			= get_sample_size(gsformat.format) * gsformat.channel_count;
		char * data = new char[frames * frameSize];
		gsformat.buffer_size = frames * frameSize;

		while (framesTotal < frames) {
			char * position = &data[framesTotal * frameSize];
			audioStream->ReadFrames(position, &framesRead);

			framesTotal += framesRead;
		}

		error = Init(data, frames, &gsformat);
	}

	file.ReleaseTrack(audioStream);
	return error;
}


status_t
BSimpleGameSound::Init(const void* inData, int64 inFrameCount,
	const gs_audio_format* format)
{
	gs_id sound;

	status_t error
		= Device()->CreateBuffer(&sound, format, inData, inFrameCount);
	if (error != B_OK)
		return error;

	BGameSound::Init(sound);

	return B_OK;
}


/* unimplemented for protection of the user:
 *
 * BSimpleGameSound::BSimpleGameSound()
 * BSimpleGameSound &BSimpleGameSound::operator=(const BSimpleGameSound &)
 */


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_0(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_1(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_2(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_3(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_4(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_5(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_6(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_7(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_8(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_9(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_10(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_11(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_12(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_13(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_14(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_15(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_16(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_17(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_18(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_19(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_20(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_21(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_22(int32 arg, ...)
{
	return B_ERROR;
}


status_t
BSimpleGameSound::_Reserved_BSimpleGameSound_23(int32 arg, ...)
{
	return B_ERROR;
}