haiku.git

/* Copyright 2005-2009 SHINTA
 * Distributed under the terms of the MIT license
 */


#include <InterfaceDefs.h>
#include <MediaIO.h>

#include "APEReader.h"
#include "MACLib.h"


static const char*	kCopyrightString
	= "Copyright " B_UTF8_COPYRIGHT " 2005-2009 by SHINTA";


TAPEReader::TAPEReader()
	: SUPER()
{
	mDecodedData = NULL;
	mDecomp = NULL;
	Unset();
}


TAPEReader::~TAPEReader()
{
}


status_t
TAPEReader::AllocateCookie(int32 oStreamNumber, void** oCookie)
{
	*oCookie = NULL;
	return B_OK;
}


const char*
TAPEReader::Copyright()
{
	return kCopyrightString;
}


bigtime_t
TAPEReader::CurrentTime() const
{
	return mDecomp->GetInfo(APE_DECOMPRESS_CURRENT_MS)
		* static_cast<bigtime_t>(1000);
}


status_t
TAPEReader::FreeCookie(void* oCookie)
{
	return B_OK;
}


void
TAPEReader::GetFileFormatInfo(media_file_format* oMFF)
{
	oMFF->capabilities = media_file_format::B_READABLE
			| media_file_format::B_PERFECTLY_SEEKABLE
//			| media_file_format::B_IMPERFECTLY_SEEKABLE
			| media_file_format::B_KNOWS_RAW_AUDIO
			| media_file_format::B_KNOWS_ENCODED_AUDIO;
	oMFF->family = B_ANY_FORMAT_FAMILY;
	oMFF->version = MEDIA_FILE_FORMAT_VERSION;
	strlcpy(oMFF->mime_type, MIME_TYPE_APE, sizeof(oMFF->mime_type));
	strlcpy(oMFF->pretty_name, MIME_TYPE_APE_LONG_DESCRIPTION, sizeof(oMFF->pretty_name));
	strlcpy(oMFF->short_name, MIME_TYPE_APE_SHORT_DESCRIPTION, sizeof(oMFF->short_name));
	strlcpy(oMFF->file_extension, MIME_TYPE_APE_EXTENSION, sizeof(oMFF->file_extension));
}


status_t
TAPEReader::GetNextChunk(void* oCookie, const void** oChunkBuffer,
	size_t* oChunkSize, media_header* oMediaHeader)
{
	int64		aOutSize;

	// check whether song is finished or not
	if (mReadPosTotal - mReadPos + mPlayPos >= mDataSize)
		return B_ERROR;

	// reading data
	if (mPlayPos >= mReadPos )
		ReadBlocks();

	// passing data
	if (mReadPos-mPlayPos >= BUFFER_SIZE)
		aOutSize = BUFFER_SIZE;
	else
		aOutSize = mReadPos-mPlayPos;

	*oChunkBuffer = &mDecodedData[mPlayPos];
	mPlayPos += aOutSize;

	// passing info
	*oChunkSize = aOutSize;
	oMediaHeader->start_time = CurrentTime();
	oMediaHeader->file_pos = mPlayPos;
	return B_OK;
}


status_t
TAPEReader::GetStreamInfo(void* oCookie, int64* oFrameCount,
	bigtime_t* oDuration, media_format* oFormat, const void** oInfoBuffer,
	size_t* oInfoSize)
{
	if (LoadAPECheck() != B_OK)
		return LoadAPECheck();

	*oFrameCount = mDataSize / (mDecomp->GetInfo(APE_INFO_BITS_PER_SAMPLE) / 8
			* mDecomp->GetInfo(APE_INFO_CHANNELS));
	*oDuration = mDecomp->GetInfo(APE_INFO_LENGTH_MS)
		* static_cast<bigtime_t>(1000);
	// media_format
	oFormat->type = B_MEDIA_RAW_AUDIO;
	oFormat->u.raw_audio.frame_rate = mDecomp->GetInfo(APE_INFO_SAMPLE_RATE);
	oFormat->u.raw_audio.channel_count = mDecomp->GetInfo(APE_INFO_CHANNELS);
	if ( mDecomp->GetInfo(APE_INFO_BITS_PER_SAMPLE) == 16 )
		oFormat->u.raw_audio.format = media_raw_audio_format::B_AUDIO_SHORT;
	else
		oFormat->u.raw_audio.format = media_raw_audio_format::B_AUDIO_UCHAR;

	oFormat->u.raw_audio.byte_order = B_MEDIA_LITTLE_ENDIAN;
	oFormat->u.raw_audio.buffer_size = BUFFER_SIZE;
	oInfoBuffer = NULL;
	oInfoSize = NULL;
	return B_OK;
}


status_t
TAPEReader::LoadAPECheck() const
{
	return mLoadAPECheck;
}


status_t
TAPEReader::ReadBlocks()
{
	int aBlocksRead;
	int aRetVal = 0;

	aRetVal = mDecomp->GetData(reinterpret_cast<char*>(mDecodedData),
		BLOCK_COUNT, &aBlocksRead);
	if (aRetVal != ERROR_SUCCESS)
		return B_ERROR;

	mPlayPos = 0;
	mReadPos = aBlocksRead*mDecomp->GetInfo(APE_INFO_BLOCK_ALIGN);
	mReadPosTotal += mReadPos;
	return B_OK;
}


status_t
TAPEReader::FindKeyFrame(void* cookie, uint32 flags, int64* frame,
	bigtime_t* time)
{
	if (flags & B_MEDIA_SEEK_TO_FRAME) {
		*time = *frame * 1000 /  mDecomp->GetInfo(APE_DECOMPRESS_TOTAL_BLOCKS)
			* mDecomp->GetInfo(APE_DECOMPRESS_LENGTH_MS);
		printf("FindKeyFrame for frame %lld: %lld\n", *frame, *time);
	} else if (flags & B_MEDIA_SEEK_TO_TIME) {
		*frame = (*time) / 1000 * mDecomp->GetInfo(APE_DECOMPRESS_TOTAL_BLOCKS)
			/ mDecomp->GetInfo(APE_DECOMPRESS_LENGTH_MS);
		printf("FindKeyFrame for time %lld: %lld\n", *time, *frame);
	} else
		return B_ERROR;

	return B_OK;
}


status_t
TAPEReader::Seek(void *cookie, uint32 flags, int64 *frame, bigtime_t *time)
{
	int32 aNewBlock;

	if (flags & B_MEDIA_SEEK_TO_FRAME) {
		printf("Seek to frame %lld\n", *frame);
		aNewBlock = *frame;
	} else if (flags & B_MEDIA_SEEK_TO_TIME) {
		printf("Seek for time %lld\n", *time);
		aNewBlock = (*time) / 1000 * mDecomp->GetInfo(APE_DECOMPRESS_TOTAL_BLOCKS)
			/ mDecomp->GetInfo(APE_DECOMPRESS_LENGTH_MS);
	} else
		return B_ERROR;

	int64 aNewTime = aNewBlock * mDecomp->GetInfo(APE_INFO_BLOCK_ALIGN);
	if (mReadPosTotal - mReadPos < aNewTime && mReadPosTotal > aNewTime) {
		// Requested seek frame is already in the current buffer, no need to
		// actually seek, just set the play position
		mPlayPos = aNewTime - mReadPosTotal + mReadPos;
	} else {
		mReadPosTotal = aNewBlock * mDecomp->GetInfo(APE_INFO_BLOCK_ALIGN);
		mDecomp->Seek(aNewBlock);
		ReadBlocks();
	}
	return B_OK;
}


status_t
TAPEReader::Sniff(int32* oStreamCount)
{
	Unset();
	// prepare about file
	mSrcPIO = dynamic_cast<BPositionIO*>(Source());
	if (mSrcPIO == NULL)
		return B_ERROR;

	BMediaIO* mediaIO = dynamic_cast<BMediaIO*>(Source());
	if (mediaIO != NULL) {
		int32 flags = 0;
		mediaIO->GetFlags(&flags);
		// This plugin doesn't support streamed data.
		// The APEHeader::FindDescriptor function always
		// analyze the whole file to find the APE_DESCRIPTOR.
		if ((flags & B_MEDIA_STREAMING) == true)
			return B_ERROR;
	}

	int nFunctionRetVal = ERROR_SUCCESS;
	mPositionBridgeIO.SetPositionIO(mSrcPIO);

	mDecomp = CreateIAPEDecompressEx(&mPositionBridgeIO, &nFunctionRetVal);
	if (mDecomp == NULL || nFunctionRetVal != ERROR_SUCCESS)
		return B_ERROR;

	// prepare about data
	mDataSize = static_cast<int64>(mDecomp->GetInfo(APE_DECOMPRESS_TOTAL_BLOCKS))
			*mDecomp->GetInfo(APE_INFO_BLOCK_ALIGN);
	mDecodedData = new char [max_c(BUFFER_SIZE*mDecomp->GetInfo(APE_INFO_CHANNELS),
			BLOCK_COUNT*mDecomp->GetInfo(APE_INFO_BLOCK_ALIGN))];
	mLoadAPECheck = B_OK;
	*oStreamCount = 1;
	return B_OK;
}


void
TAPEReader::Unset()
{
	mLoadAPECheck = B_NO_INIT;
	// about file
	mPositionBridgeIO.SetPositionIO(NULL);
	mSrcPIO = NULL;
	delete mDecomp;
	// about data
	mDataSize = 0;
	mReadPos = 0;
	mReadPosTotal = 0;
	mPlayPos = 0;
	delete [] mDecodedData;
}


TAPEReaderPlugin::TAPEReaderPlugin()
{
}


TAPEReaderPlugin::~TAPEReaderPlugin()
{
}


Reader*
TAPEReaderPlugin::NewReader()
{
	return new TAPEReader();
}


MediaPlugin*
instantiate_plugin()
{
	return new TAPEReaderPlugin();
}