/*
 * Copyright 2008 Stephan Aßmus <superstippi@gmx.de>
 * All rights reserved. Distributed under the terms of the MIT licensce.
 */


#include "AudioChannelConverter.h"

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

using std::nothrow;


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


template<typename Type, typename BigType>
static void
convert(Type* inBuffer, Type* outBuffer, int32 inChannels, int32 outChannels,
        int32 frames)
{
        // TODO: more conversions!
        switch (inChannels) {
                case 0:
                        break;
                case 1:
                        switch (outChannels) {
                                case 2:
                                        for (int32 i = 0; i < frames; i++) {
                                                *outBuffer++ = *inBuffer;
                                                *outBuffer++ = *inBuffer++;
                                        }
                                        break;
                        }
                        break;
                case 2:
                        switch (outChannels) {
                                case 1:
                                        for (int32 i = 0; i < frames; i++) {
                                                *outBuffer++
                                                        = (Type)((BigType)inBuffer[0] + inBuffer[1]) / 2;
                                                inBuffer += 2;
                                        }
                                        break;
                        }
                        break;
                default:
                        switch (outChannels) {
                                case 2:
                                        for (int32 i = 0; i < frames; i++) {
                                                outBuffer[0] = inBuffer[0];
                                                outBuffer[1] = inBuffer[1];
                                                inBuffer += outChannels;
                                                outBuffer += 2;
                                        }
                                        break;
                        }
                        break;
        }
}


// #pragma mark -


AudioChannelConverter::AudioChannelConverter(AudioReader* source,
                const media_format& format)
        : AudioReader(format),
          fSource(source)
{
        // TODO: check the format and make sure everything matches
        // except for channel count
}


AudioChannelConverter::~AudioChannelConverter()
{
}


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


status_t
AudioChannelConverter::Read(void* outBuffer, int64 pos, int64 frames)
{
        TRACE("AudioChannelConverter::Read(%p, %lld, %lld)\n", outBuffer, pos, frames);
        status_t error = InitCheck();
        if (error != B_OK)
                return error;
        pos += fOutOffset;

        int32 inChannels = fSource->Format().u.raw_audio.channel_count;
        int32 outChannels = fFormat.u.raw_audio.channel_count;
        TRACE("   convert %ld -> %ld channels\n", inChannels, outChannels);

        int32 inSampleSize = fSource->Format().u.raw_audio.format
                & media_raw_audio_format::B_AUDIO_SIZE_MASK;
        int32 inFrameSize = inSampleSize * inChannels;
        uint8* inBuffer = new (nothrow) uint8[inFrameSize * frames];

        TRACE("   fSource->Read()\n");
        status_t ret = fSource->Read(inBuffer, pos, frames);
        if (ret != B_OK) {
                delete[] inBuffer;
                return ret;
        }

        // We know that both formats are the same except for channel count
        switch (fFormat.u.raw_audio.format) {
                case media_raw_audio_format::B_AUDIO_FLOAT:
                        convert<float, float>((float*)inBuffer, (float*)outBuffer,
                                inChannels, outChannels, frames);
                        break;
                case media_raw_audio_format::B_AUDIO_INT:
                        convert<int32, int64>((int32*)inBuffer, (int32*)outBuffer,
                                inChannels, outChannels, frames);
                        break;
                case media_raw_audio_format::B_AUDIO_SHORT:
                        convert<int16, int32>((int16*)inBuffer, (int16*)outBuffer,
                                inChannels, outChannels, frames);
                        break;
                case media_raw_audio_format::B_AUDIO_UCHAR:
                        convert<uint8, uint16>((uint8*)inBuffer, (uint8*)outBuffer,
                                inChannels, outChannels, frames);
                        break;
                case media_raw_audio_format::B_AUDIO_CHAR:
                        convert<int8, int16>((int8*)inBuffer, (int8*)outBuffer,
                                inChannels, outChannels, frames);
                        break;
        }

        delete[] inBuffer;

        TRACE("AudioChannelConverter::Read() done: %s\n", strerror(ret));
        return ret;
}


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


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