/***********************************************************************
 * AUTHOR: Marcus Overhagen
 *   FILE: SoundFile.cpp
 *  DESCR: 
 ***********************************************************************/
#include <MediaFile.h>
#include <MediaTrack.h>
#include <SoundFile.h>
 
#include <string.h>
 
#include "MediaDebug.h"
 
/*************************************************************
 * public BSoundFile
 *************************************************************/
 
BSoundFile::BSoundFile()
{
	_init_raw_stats();
}
 
 
BSoundFile::BSoundFile(const entry_ref *ref,
					   uint32 open_mode)
{
	_init_raw_stats();
	SetTo(ref,open_mode);
}
 
/* virtual */ 
BSoundFile::~BSoundFile()
{
	delete fSoundFile;
	delete fMediaFile;
		// fMediaTrack will be deleted by the BMediaFile destructor
}
 
 
status_t
BSoundFile::InitCheck() const
{
	if (!fSoundFile) {
		return B_NO_INIT;
	}
	return fSoundFile->InitCheck();
}
 
 
status_t
BSoundFile::SetTo(const entry_ref *ref,
				  uint32 open_mode)
{
	if (fMediaTrack) {
		BMediaTrack * track = fMediaTrack;
		fMediaTrack = 0;
		fMediaFile->ReleaseTrack(track);
	}
	if (fMediaFile) {
		BMediaFile * file = fMediaFile;
		fMediaFile = 0;
		delete file;
	}		
	if (fSoundFile) {
		BFile * file = fSoundFile;
		fSoundFile = 0;
		delete file;
	}
	if (open_mode == B_READ_ONLY) {
		return _ref_to_file(ref);
	} else {
		UNIMPLEMENTED();
		return B_ERROR;
	}
}
 
 
int32
BSoundFile::FileFormat() const
{
	return fFileFormat;
}
 
 
int32
BSoundFile::SamplingRate() const
{
	return fSamplingRate;
}
 
 
int32
BSoundFile::CountChannels() const
{
	return fChannelCount;
}
 
 
int32
BSoundFile::SampleSize() const
{
	return fSampleSize;
}
 
 
int32
BSoundFile::ByteOrder() const
{
	return fByteOrder;
}
 
 
int32
BSoundFile::SampleFormat() const
{
	return fSampleFormat;
}
 
 
int32
BSoundFile::FrameSize() const
{
	return fSampleSize * fChannelCount;
}
 
 
off_t
BSoundFile::CountFrames() const
{
	return fFrameCount;
}
 
 
bool
BSoundFile::IsCompressed() const
{
	return fIsCompressed;
}
 
 
int32
BSoundFile::CompressionType() const
{
	return fCompressionType;
}
 
 
char *
BSoundFile::CompressionName() const
{
	return fCompressionName;
}
 
 
/* virtual */ int32
BSoundFile::SetFileFormat(int32 format)
{
	fFileFormat = format;
	return fFileFormat;
}
 
 
/* virtual */ int32
BSoundFile::SetSamplingRate(int32 fps)
{
	fSamplingRate = fps;
	return fSamplingRate;
}
 
 
/* virtual */ int32
BSoundFile::SetChannelCount(int32 spf)
{
	fChannelCount = spf;
	return fChannelCount;
}
 
 
/* virtual */ int32
BSoundFile::SetSampleSize(int32 bps)
{
	fSampleSize = bps;
	return fSampleSize;
}
 
 
/* virtual */ int32
BSoundFile::SetByteOrder(int32 bord)
{
	fByteOrder = bord;
	return fByteOrder;
}
 
 
/* virtual */ int32
BSoundFile::SetSampleFormat(int32 fmt)
{
	fSampleFormat = fmt;
	return fSampleFormat;
}
 
 
/* virtual */ int32
BSoundFile::SetCompressionType(int32 type)
{
	return 0;
}
 
 
/* virtual */ char *
BSoundFile::SetCompressionName(char *name)
{
	return NULL;
}
 
 
/* virtual */ bool
BSoundFile::SetIsCompressed(bool tf)
{
	return false;
}
 
 
/* virtual */ off_t
BSoundFile::SetDataLocation(off_t offset)
{
	UNIMPLEMENTED();
 
	return 0;
}
 
 
/* virtual */ off_t
BSoundFile::SetFrameCount(off_t count)
{
	fFrameCount = count;
	return fFrameCount;
}
 
 
size_t
BSoundFile::ReadFrames(char *buf,
					   size_t count)
{
	size_t frameRead = 0;
	int64 frames = count;
	while (count > 0) {
		status_t status = fMediaTrack->ReadFrames(
				reinterpret_cast<void *>(buf), &frames);
		count -= frames;
		frameRead += frames;
		buf += fSampleSize * fChannelCount * frames;
		if (status != B_OK) {
			if (frameRead > 0)
				break;
			return status;
		}
	}
	return frameRead;
}
 
 
size_t
BSoundFile::WriteFrames(char *buf,
						size_t count)
{
	return fMediaTrack->WriteFrames(
			reinterpret_cast<void *>(buf), count);
}
 
 
/* virtual */ off_t
BSoundFile::SeekToFrame(off_t n)
{
	int64 frames = n;
	status_t status = fMediaTrack->SeekToFrame(&frames);
 
	if (status != B_OK)
		return status;
 
	return frames;
}
 
 
off_t
BSoundFile::FrameIndex() const
{
	return fFrameIndex;
}
 
 
off_t
BSoundFile::FramesRemaining() const
{
	return fFrameCount - FrameIndex();
}
 
/*************************************************************
 * private BSoundFile
 *************************************************************/
 
 
void BSoundFile::_ReservedSoundFile1() {}
void BSoundFile::_ReservedSoundFile2() {}
void BSoundFile::_ReservedSoundFile3() {}
 
void
BSoundFile::_init_raw_stats()
{
	fSoundFile = 0;
	fMediaFile = 0;
	fMediaTrack = 0;	
	fFileFormat = B_UNKNOWN_FILE;
	fSamplingRate = 44100;
	fChannelCount = 2;
	fSampleSize = 2;
	fByteOrder = B_BIG_ENDIAN;
	fSampleFormat = B_LINEAR_SAMPLES;
	fFrameCount = 0;
	fFrameIndex = 0;
	fIsCompressed = false;
	fCompressionType = -1;
	fCompressionName = NULL;
}
 
 
static int32
_ParseMimeType(char *mime_type)
{
	if (strcmp(mime_type, "audio/x-aiff") == 0)
		return B_AIFF_FILE;
	if (strcmp(mime_type, "audio/x-wav") == 0)
		return B_WAVE_FILE;
	return B_UNKNOWN_FILE;
}
 
 
status_t
BSoundFile::_ref_to_file(const entry_ref *ref)
{
	status_t status;
	BFile * file = new BFile(ref, B_READ_ONLY);
	status = file->InitCheck();
	if (status != B_OK) {
		fSoundFile = file;
		return status;
	}	
	BMediaFile * media = new BMediaFile(file);
	status = media->InitCheck();
	if (status != B_OK) {
		delete media;
		delete file;
		return status;
	}
	media_file_format mfi;
	media->GetFileFormatInfo(&mfi);
	switch (mfi.family) {
		case B_AIFF_FORMAT_FAMILY: fFileFormat = B_AIFF_FILE; break;
		case B_WAV_FORMAT_FAMILY:  fFileFormat = B_WAVE_FILE; break;
		default: fFileFormat = _ParseMimeType(mfi.mime_type); break;
	}
	int trackNum = 0;
	BMediaTrack * track = 0;
	media_format mf;
	while (trackNum < media->CountTracks()) {
		track = media->TrackAt(trackNum);
		status = track->DecodedFormat(&mf);
		if (status != B_OK) {
			media->ReleaseTrack(track);
			delete media;
			delete file;
			return status;
		}		
		if (mf.IsAudio()) {
			break;
		}
		media->ReleaseTrack(track);
		track = 0;
	}
	if (track == 0) {
		delete media;
		delete file;
		return B_ERROR;
	}
	media_raw_audio_format * raw = 0;
	if (mf.type == B_MEDIA_ENCODED_AUDIO) {
		raw = &mf.u.encoded_audio.output;
	}
	if (mf.type == B_MEDIA_RAW_AUDIO) {
		raw = &mf.u.raw_audio;
	}
 
	if (raw == NULL) {
		delete media;
		delete file;
		return B_ERROR;
	}
 
	fSamplingRate = (int)raw->frame_rate;
	fChannelCount = raw->channel_count;
	fSampleSize = raw->format & 0xf;
	fByteOrder = raw->byte_order;
	switch (raw->format) {
		case media_raw_audio_format::B_AUDIO_FLOAT: 
			fSampleFormat = B_FLOAT_SAMPLES;
			break;
		case media_raw_audio_format::B_AUDIO_INT:
		case media_raw_audio_format::B_AUDIO_SHORT: 
		case media_raw_audio_format::B_AUDIO_UCHAR:
		case media_raw_audio_format::B_AUDIO_CHAR:
			fSampleFormat = B_LINEAR_SAMPLES;
			break;
		default:
			fSampleFormat = B_UNDEFINED_SAMPLES;
	}
	fByteOffset = 0;
	fFrameCount = track->CountFrames();
	fFrameIndex = 0;
	if (mf.type == B_MEDIA_ENCODED_AUDIO) {
		fIsCompressed = true;
		fCompressionType = mf.u.encoded_audio.encoding;
	}
	fMediaFile = media;
	fMediaTrack = track;
	fSoundFile = file;
	return B_OK;
}