haiku.git

/*
 * Copyright 2000-2006 Ingo Weinhold <ingo_weinhold@gmx.de>
 * All rights reserved. Distributed under the terms of the MIT licensce.
 */


#include "AudioResampler.h"

#include <stdio.h>

#include "SampleBuffer.h"


//#define TRACE_AUDIO_RESAMPLER
#ifdef TRACE_AUDIO_RESAMPLER
#	define TRACE(x...)	printf(x)
#else
#	define TRACE(x...)
#endif


//! Calculates the greatest common divider of /a/ and /b/.
template<typename T> inline
T
gcd(T a, T b)
{
	while (b != 0) {
		T r = a % b;
		a = b;
		b = r;
	}
	return a;
}


template<typename Buffer>
static void
resample_linear(void* _inBuffer, void* _outBuffer, uint32 channelCount,
	double inFrameRate, double outFrameRate, int32 frames)
{
	typedef double sample_t;
	Buffer inBuffer(_inBuffer);
	Buffer outFrameBuf(_outBuffer);
	for (sample_t outFrame = 0; outFrame < frames; outFrame++) {
		// time of the out sample
		sample_t outTime = outFrame / outFrameRate;
		// first in frame
		int64 inFrame = int64(outTime * inFrameRate);
		// time of the first and the second in frame
		sample_t inTime1 = (sample_t)inFrame / inFrameRate;
		sample_t inTime2 = (sample_t)(inFrame + 1) / inFrameRate;
		// differences between the out frame time and the in frame times
		sample_t timeDiff1 = outTime - inTime1;
		sample_t timeDiff2 = inTime2 - outTime;
		sample_t timeDiff = timeDiff1 + timeDiff2;
		// pointer to the first and second in frame
		Buffer inFrameBuf1 = inBuffer + inFrame * channelCount;
		Buffer inFrameBuf2 = inFrameBuf1 + channelCount;
		for (uint32 c = 0; c < channelCount;
			 c++, inFrameBuf1++, inFrameBuf2++, outFrameBuf++) {
			// sum weighted according to the distance to the respective other
			// in frame
			outFrameBuf.WriteSample((timeDiff2 * inFrameBuf1.ReadSample()
				+ timeDiff1 * inFrameBuf2.ReadSample()) / timeDiff);
		}
	}
}


// #pragma mark -


AudioResampler::AudioResampler()
	:
	AudioReader(),
	fSource(NULL),
	fTimeScale(1.0),
	fInOffset(0)
{
}


AudioResampler::AudioResampler(AudioReader* source, float frameRate,
		float timeScale)
	:
	AudioReader(),
	fSource(NULL),
	fTimeScale(timeScale),
	fInOffset(0)
{
	SetSource(source);
	if (fSource)
		fFormat.u.raw_audio.frame_rate = frameRate;
}


AudioResampler::~AudioResampler()
{
}


bigtime_t
AudioResampler::InitialLatency() const
{
	return fSource->InitialLatency();
}


status_t
AudioResampler::Read(void* buffer, int64 pos, int64 frames)
{
	TRACE("AudioResampler::Read(%p, %lld, %lld)\n", buffer, pos, frames);

	status_t error = InitCheck();
	if (error != B_OK) {
		TRACE("AudioResampler::Read() done1\n");
		return error;
	}
	// calculate position and frames in the source data
	int64 sourcePos = ConvertToSource(pos);
	int64 sourceFrames = ConvertToSource(pos + frames) - sourcePos;
	// check the frame counts
	if (sourceFrames == frames) {
		TRACE("AudioResampler::Read() done2\n");
		return fSource->Read(buffer, sourcePos, sourceFrames);
	}
	if (sourceFrames == 0) {
		ReadSilence(buffer, frames);
		TRACE("AudioResampler::Read() done3\n");
		return B_OK;
	}
	// check, if playing backwards
	bool backward = false;
	if (sourceFrames < 0) {
		sourceFrames = -sourceFrames;
		sourcePos -= sourceFrames;
		backward = true;
	}

	// we need at least two frames to interpolate
	sourceFrames += 2;
	int32 sampleSize = media_raw_audio_format::B_AUDIO_SIZE_MASK;
	uint32 channelCount = fFormat.u.raw_audio.channel_count;
	char* inBuffer = new char[sourceFrames * channelCount * sampleSize];
	error = fSource->Read(inBuffer, sourcePos, sourceFrames);
	if (error != B_OK) {
		TRACE("AudioResampler::_ReadLinear() done4\n");
		return error;
	}
	double inFrameRate = fSource->Format().u.raw_audio.frame_rate;
	double outFrameRate = (double)fFormat.u.raw_audio.frame_rate
		/ (double)fTimeScale;
	// choose the sample buffer to be used
	switch (fFormat.u.raw_audio.format) {
		case media_raw_audio_format::B_AUDIO_FLOAT:
			resample_linear< FloatSampleBuffer<double> >(inBuffer, buffer,
				channelCount, inFrameRate, outFrameRate, (int32)frames);
			break;
		case media_raw_audio_format::B_AUDIO_INT:
			resample_linear< IntSampleBuffer<double> >(inBuffer, buffer,
				channelCount, inFrameRate, outFrameRate, (int32)frames);
			break;
		case media_raw_audio_format::B_AUDIO_SHORT:
			resample_linear< ShortSampleBuffer<double> >(inBuffer, buffer,
				channelCount, inFrameRate, outFrameRate, (int32)frames);
			break;
		case media_raw_audio_format::B_AUDIO_UCHAR:
			resample_linear< UCharSampleBuffer<double> >(inBuffer, buffer,
				channelCount, inFrameRate, outFrameRate, (int32)frames);
			break;
		case media_raw_audio_format::B_AUDIO_CHAR:
			resample_linear< CharSampleBuffer<double> >(inBuffer, buffer,
				channelCount, inFrameRate, outFrameRate, (int32)frames);
			break;
	}
	// reverse the frame order if reading backwards
	if (backward)
		ReverseFrames(buffer, frames);
	delete[] inBuffer;
	TRACE("AudioResampler::Read() done\n");
	return B_OK;
}


status_t
AudioResampler::InitCheck() const
{
	status_t error = AudioReader::InitCheck();
	if (error == B_OK && !fSource)
		error = B_NO_INIT;
	return error;
}


void
AudioResampler::SetSource(AudioReader* source)
{
	if (!source) {
		TRACE("AudioResampler::SetSource() - NULL source\n");
		return;
	}

	if (source->Format().type != B_MEDIA_RAW_AUDIO) {
		TRACE("AudioResampler::SetSource() - not B_MEDIA_RAW_AUDIO\n");
		return;
	}

	uint32 hostByteOrder
		= (B_HOST_IS_BENDIAN) ? B_MEDIA_BIG_ENDIAN : B_MEDIA_LITTLE_ENDIAN;
	if (source->Format().u.raw_audio.byte_order != hostByteOrder) {
		TRACE("AudioResampler::SetSource() - not host byte order\n");
		return;
	}

	float frameRate = FrameRate();
		// don't overwrite previous audio frame rate
	fSource = source;
	fFormat = source->Format();
	fFormat.u.raw_audio.frame_rate = frameRate;
}


void
AudioResampler::SetFrameRate(float frameRate)
{
	fFormat.u.raw_audio.frame_rate = frameRate;
}


void
AudioResampler::SetTimeScale(float timeScale)
{
	fTimeScale = timeScale;
}


AudioReader*
AudioResampler::Source() const
{
	return fSource;
}


float
AudioResampler::FrameRate() const
{
	return fFormat.u.raw_audio.frame_rate;
}


float
AudioResampler::TimeScale() const
{
	return fTimeScale;
}


void
AudioResampler::SetInOffset(int64 offset)
{
	fInOffset = offset;
}


int64
AudioResampler::InOffset() const
{
	return fInOffset;
}


int64
AudioResampler::ConvertFromSource(int64 pos) const
{
	double inFrameRate = fSource->Format().u.raw_audio.frame_rate;
	double outFrameRate = fFormat.u.raw_audio.frame_rate;
	return (int64)((double)(pos - fInOffset) * outFrameRate / inFrameRate
		/ (double)fTimeScale) - fOutOffset;
}


int64
AudioResampler::ConvertToSource(int64 pos) const
{
	double inFrameRate = fSource->Format().u.raw_audio.frame_rate;
	double outFrameRate = fFormat.u.raw_audio.frame_rate;
	return (int64)((double)(pos + fOutOffset) * inFrameRate / outFrameRate
		* (double)fTimeScale) + fInOffset;
}