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

#include "AudioReader.h"

using std::swap;


AudioReader::AudioReader()
        : fFormat(),
          fOutOffset(0)
{
}


AudioReader::AudioReader(const media_format& format)
        : fFormat(format),
          fOutOffset(0)
{
}


AudioReader::~AudioReader()
{
}


status_t
AudioReader::InitCheck() const
{
        return B_OK;
}


void
AudioReader::SetFormat(const media_format& format)
{
        fFormat = format;
}


const media_format&
AudioReader::Format() const
{
        return fFormat;
}


void
AudioReader::SetOutOffset(int64 offset)
{
        fOutOffset = offset;
}


int64
AudioReader::OutOffset() const
{
        return fOutOffset;
}


int64
AudioReader::FrameForTime(bigtime_t time) const
{
        double frameRate = fFormat.u.raw_audio.frame_rate;
        return int64(double(time) * frameRate / 1000000.0);
}


bigtime_t
AudioReader::TimeForFrame(int64 frame) const
{
        double frameRate = fFormat.u.raw_audio.frame_rate;
        return bigtime_t(double(frame) * 1000000.0 / frameRate);
}


//! helper function for ReadSilence()
template<typename sample_t>
inline void
fill_buffer(void* buffer, int32 count, sample_t value)
{
        sample_t* buf = (sample_t*)buffer;
        sample_t* bufferEnd = buf + count;
        for (; buf < bufferEnd; buf++)
                *buf = value;
}


/*! Fills the supplied buffer with /frames/ frames of silence and returns a
        pointer to the frames after the filled range.
        /frames/ must be >= 0.*/
void*
AudioReader::ReadSilence(void* buffer, int64 frames) const
{
        void* bufferEnd = SkipFrames(buffer, frames);
        int32 sampleCount = frames * fFormat.u.raw_audio.channel_count;
        switch (fFormat.u.raw_audio.format) {
                case media_raw_audio_format::B_AUDIO_FLOAT:
                        fill_buffer(buffer, sampleCount, (float)0);
                        break;
                case media_raw_audio_format::B_AUDIO_INT:
                        fill_buffer(buffer, sampleCount, (int)0);
                        break;
                case media_raw_audio_format::B_AUDIO_SHORT:
                        fill_buffer(buffer, sampleCount, (short)0);
                        break;
                case media_raw_audio_format::B_AUDIO_UCHAR:
                        fill_buffer(buffer, sampleCount, (uchar)128);
                        break;
                case media_raw_audio_format::B_AUDIO_CHAR:
                        fill_buffer(buffer, sampleCount, (uchar)0);
                        break;
                default:
                        memset(buffer, 0, (char*)bufferEnd - (char*)buffer);
                        break;
        }
        return bufferEnd;
}


//! Returns a buffer pointer offset by /frames/ frames.
void*
AudioReader::SkipFrames(void* buffer, int64 frames) const
{
        int32 sampleSize = fFormat.u.raw_audio.format
                & media_raw_audio_format::B_AUDIO_SIZE_MASK;
        int32 frameSize = sampleSize * fFormat.u.raw_audio.channel_count;
        return (char*)buffer + frames * frameSize;
}


void
AudioReader::ReverseFrames(void* buffer, int64 frames) const
{
        int32 sampleSize = fFormat.u.raw_audio.format
                & media_raw_audio_format::B_AUDIO_SIZE_MASK;
        int32 frameSize = sampleSize * fFormat.u.raw_audio.channel_count;
        char* front = (char*)buffer;
        char* back = (char*)buffer + (frames - 1) * frameSize;
        while (front < back) {
                for (int32 i = 0; i < frameSize; i++)
                        swap(front[i], back[i]);
                front += frameSize;
                back -= frameSize;
        }
}