haiku.git

/*
 * Copyright 2009-2019, Haiku Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Jacob Secunda
 *		Marcus Overhagen
 *		Michael Lotz <mmlr@mlotz.ch>
 */

#include <Sound.h>

#include <new>
#include <string.h>

#include <File.h>
#include <MediaDebug.h>

#include "TrackReader.h"


BSound::BSound(void* data, size_t size, const media_raw_audio_format& format,
	bool freeWhenDone)
	:	fData(data),
		fDataSize(size),
		fFile(NULL),
		fRefCount(1),
		fStatus(B_NO_INIT),
		fFormat(format),
		fFreeWhenDone(freeWhenDone),
		fTrackReader(NULL)
{
	if (fData == NULL)
		return;

	fStatus = B_OK;
}


BSound::BSound(const entry_ref* soundFile, bool loadIntoMemory)
	:	fData(NULL),
		fDataSize(0),
		fFile(new(std::nothrow) BFile(soundFile, B_READ_ONLY)),
		fRefCount(1),
		fStatus(B_NO_INIT),
		fFreeWhenDone(false),
		fTrackReader(NULL)
{
	if (fFile == NULL) {
		fStatus = B_NO_MEMORY;
		return;
	}

	fStatus = fFile->InitCheck();
	if (fStatus != B_OK)
		return;

	memset(&fFormat, 0, sizeof(fFormat));
	fTrackReader = new(std::nothrow) BPrivate::BTrackReader(fFile, fFormat);
	if (fTrackReader == NULL) {
		fStatus = B_NO_MEMORY;
		return;
	}

	fStatus = fTrackReader->InitCheck();
	if (fStatus != B_OK)
		return;

	fFormat = fTrackReader->Format();
	fStatus = B_OK;
}


BSound::BSound(const media_raw_audio_format& format)
	:	fData(NULL),
		fDataSize(0),
		fFile(NULL),
		fRefCount(1),
		fStatus(B_ERROR),
		fFormat(format),
		fFreeWhenDone(false),
		fTrackReader(NULL)
{
	// unimplemented protected constructor
	UNIMPLEMENTED();
}


BSound::~BSound()
{
	delete fTrackReader;
	delete fFile;

	if (fFreeWhenDone)
		free(fData);
}


status_t
BSound::InitCheck()
{
	return fStatus;
}


BSound*
BSound::AcquireRef()
{
	atomic_add(&fRefCount, 1);
	return this;
}


bool
BSound::ReleaseRef()
{
	if (atomic_add(&fRefCount, -1) == 1) {
		delete this;
		return false;
	}

	// TODO: verify those returns
	return true;
}


int32
BSound::RefCount() const
{
	return fRefCount;
}


bigtime_t
BSound::Duration() const
{
	float frameRate = fFormat.frame_rate;

	if (frameRate == 0.0)
		return 0;

	uint32 bytesPerSample = fFormat.format &
		media_raw_audio_format::B_AUDIO_SIZE_MASK;
	int64 frameCount = Size() / (fFormat.channel_count * bytesPerSample);

	return (bigtime_t)ceil((1000000LL * frameCount) / frameRate);
}


const media_raw_audio_format&
BSound::Format() const
{
	return fFormat;
}


const void*
BSound::Data() const
{
	return fData;
}


off_t
BSound::Size() const
{
	if (fFile != NULL) {
		off_t result = 0;
		fFile->GetSize(&result);
		return result;
	}

	return fDataSize;
}


bool
BSound::GetDataAt(off_t offset, void* intoBuffer, size_t bufferSize,
	size_t* outUsed)
{
	if (intoBuffer == NULL)
		return false;

	if (fData != NULL) {
		size_t copySize = MIN(bufferSize, fDataSize - offset);
		memcpy(intoBuffer, (uint8*)fData + offset, copySize);
		if (outUsed != NULL)
			*outUsed = copySize;
		return true;
	}

	if (fTrackReader != NULL) {
		int32 frameSize = fTrackReader->FrameSize();
		int64 frameCount = fTrackReader->CountFrames();
		int64 startFrame = offset / frameSize;
		if (startFrame > frameCount)
			return false;

		if (fTrackReader->SeekToFrame(&startFrame) != B_OK)
			return false;

		off_t bufferOffset = offset - startFrame * frameSize;
		int64 directStartFrame = (offset + frameSize - 1) / frameSize;
		int64 directFrameCount = (offset + bufferSize - directStartFrame
			* frameSize) / frameSize;

		if (bufferOffset != 0) {
			int64 indirectFrameCount = directStartFrame - startFrame;
			size_t indirectSize = indirectFrameCount * frameSize;
			void* buffer = malloc(indirectSize);
			if (buffer == NULL)
				return false;

			if (fTrackReader->ReadFrames(buffer, indirectFrameCount) != B_OK) {
				free(buffer);
				return false;
			}

			memcpy(intoBuffer, (uint8*)buffer + bufferOffset,
				indirectSize - bufferOffset);
			if (outUsed != NULL)
				*outUsed = indirectSize - bufferOffset;

			free(buffer);
		} else if (outUsed != NULL)
			*outUsed = 0;

		if (fTrackReader->ReadFrames((uint8*)intoBuffer + bufferOffset,
			directFrameCount) != B_OK)
			return false;

		if (outUsed != NULL)
			*outUsed += directFrameCount * frameSize;

		return true;
	}

	return false;
}


status_t
BSound::BindTo(BSoundPlayer* player, const media_raw_audio_format& format)
{
	UNIMPLEMENTED();
	return B_ERROR;
}


status_t
BSound::UnbindFrom(BSoundPlayer* player)
{
	UNIMPLEMENTED();
	return B_ERROR;
}


status_t
BSound::Perform(int32 code, ...)
{
	UNIMPLEMENTED();
	return B_ERROR;
}


status_t BSound::_Reserved_Sound_0(void*) { return B_ERROR; }
status_t BSound::_Reserved_Sound_1(void*) { return B_ERROR; }
status_t BSound::_Reserved_Sound_2(void*) { return B_ERROR; }
status_t BSound::_Reserved_Sound_3(void*) { return B_ERROR; }
status_t BSound::_Reserved_Sound_4(void*) { return B_ERROR; }
status_t BSound::_Reserved_Sound_5(void*) { return B_ERROR; }