//------------------------------------------------------------------------------
//      Copyright (c) 2001-2002, Haiku
//
//      Permission is hereby granted, free of charge, to any person obtaining a
//      copy of this software and associated documentation files (the "Software"),
//      to deal in the Software without restriction, including without limitation
//      the rights to use, copy, modify, merge, publish, distribute, sublicense,
//      and/or sell copies of the Software, and to permit persons to whom the
//      Software is furnished to do so, subject to the following conditions:
//
//      The above copyright notice and this permission notice shall be included in
//      all copies or substantial portions of the Software.
//
//      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//      IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//      FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
//      AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//      LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
//      FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
//      DEALINGS IN THE SOFTWARE.
//
//      File Name:              GameSoundBuffer.h
//      Author:                 Christopher ML Zumwalt May (zummy@users.sf.net)
//      Description:    Interface to a single sound, managed by the GameSoundDevice.
//------------------------------------------------------------------------------


#include "GameSoundBuffer.h"

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

#include <MediaRoster.h>
#include <MediaAddOn.h>
#include <MediaTheme.h>
#include <TimeSource.h>
#include <BufferGroup.h>

#include "GameProducer.h"
#include "GameSoundDevice.h"
#include "StreamingGameSound.h"
#include "GSUtility.h"

// Sound Buffer Utility functions ----------------------------------------
template<typename T, int32 min, int32 middle, int32 max>
static inline void
ApplyMod(T* data, int64 index, float* pan)
{
        data[index * 2] = clamp<T, min, max>(float(data[index * 2] - middle)
                * pan[0] + middle);
        data[index * 2 + 1] = clamp<T, min, max>(float(data[index * 2 + 1] - middle)
                * pan[1] + middle);
}


// GameSoundBuffer -------------------------------------------------------
GameSoundBuffer::GameSoundBuffer(const gs_audio_format * format)
        :
        fLooping(false),
        fIsConnected(false),
        fIsPlaying(false),
        fGain(1.0),
        fPan(0.0),
        fPanLeft(1.0),
        fPanRight(1.0),
        fGainRamp(NULL),
        fPanRamp(NULL)
{
        fConnection = new Connection;
        fNode = new GameProducer(this, format);

        fFrameSize = get_sample_size(format->format) * format->channel_count;

        fFormat = *format;
}


// Play must stop before the distructor is called; otherwise, a fatal
// error occures if the playback is in a subclass.
GameSoundBuffer::~GameSoundBuffer()
{
        BMediaRoster* roster = BMediaRoster::Roster();

        if (fIsConnected) {
                // Ordinarily we'd stop *all* of the nodes in the chain at this point.
                // However, one of the nodes is the System Mixer, and stopping the Mixer
                // is a Bad Idea (tm). So, we just disconnect from it, and release our
                // references to the nodes that we're using.  We *are* supposed to do
                // that even for global nodes like the Mixer.
                roster->Disconnect(fConnection->producer.node, fConnection->source,
                        fConnection->consumer.node, fConnection->destination);

                roster->ReleaseNode(fConnection->producer);
                roster->ReleaseNode(fConnection->consumer);
        }

        delete fGainRamp;
        delete fPanRamp;

        delete fConnection;
        delete fNode;
}


const gs_audio_format &
GameSoundBuffer::Format() const
{
        return fFormat;
}


bool
GameSoundBuffer::IsLooping() const
{
        return fLooping;
}


void
GameSoundBuffer::SetLooping(bool looping)
{
        fLooping = looping;
}


float
GameSoundBuffer::Gain() const
{
        return fGain;
}


status_t
GameSoundBuffer::SetGain(float gain, bigtime_t duration)
{
        if (gain < 0.0 || gain > 1.0)
                return B_BAD_VALUE;

        delete fGainRamp;
        fGainRamp = NULL;

        if (duration > 100000)
                fGainRamp  = InitRamp(&fGain, gain, fFormat.frame_rate, duration);
        else
                fGain = gain;

        return B_OK;
}


float
GameSoundBuffer::Pan() const
{
        return fPan;
}


status_t
GameSoundBuffer::SetPan(float pan, bigtime_t duration)
{
        if (pan < -1.0 || pan > 1.0)
                return B_BAD_VALUE;

        delete fPanRamp;
        fPanRamp = NULL;

        if (duration < 100000) {
                fPan = pan;

                if (fPan < 0.0) {
                        fPanLeft = 1.0;
                        fPanRight = 1.0 + fPan;
                } else {
                        fPanRight = 1.0;
                        fPanLeft = 1.0 - fPan;
                }
        } else
                fPanRamp = InitRamp(&fPan, pan, fFormat.frame_rate, duration);

        return B_OK;
}


status_t
GameSoundBuffer::GetAttributes(gs_attribute * attributes,
        size_t attributeCount)
{
        for (size_t i = 0; i < attributeCount; i++) {
                switch (attributes[i].attribute) {
                        case B_GS_GAIN:
                                attributes[i].value = fGain;
                                if (fGainRamp)
                                        attributes[i].duration = fGainRamp->duration;
                                break;

                        case B_GS_PAN:
                                attributes[i].value = fPan;
                                if (fPanRamp)
                                        attributes[i].duration = fPanRamp->duration;
                                break;

                        case B_GS_LOOPING:
                                attributes[i].value = (fLooping) ? -1.0 : 0.0;
                                attributes[i].duration = bigtime_t(0);
                                break;

                        default:
                                attributes[i].value = 0.0;
                                attributes[i].duration = bigtime_t(0);
                                break;
                }
        }

        return B_OK;
}


status_t
GameSoundBuffer::SetAttributes(gs_attribute * attributes,
        size_t attributeCount)
{
        status_t error = B_OK;

        for (size_t i = 0; i < attributeCount; i++) {
                switch (attributes[i].attribute) {
                        case B_GS_GAIN:
                                error = SetGain(attributes[i].value, attributes[i].duration);
                                break;

                        case B_GS_PAN:
                                error = SetPan(attributes[i].value, attributes[i].duration);
                                break;

                        case B_GS_LOOPING:
                                fLooping = bool(attributes[i].value);
                                break;

                        default:
                                break;
                }
        }

        return error;
}


void
GameSoundBuffer::Play(void * data, int64 frames)
{
        // Mh... should we add some locking?
        if (!fIsPlaying)
                return;

        if (fFormat.channel_count == 2) {
                float pan[2];
                pan[0] = fPanRight * fGain;
                pan[1] = fPanLeft * fGain;

                FillBuffer(data, frames);

                switch (fFormat.format) {
                        case gs_audio_format::B_GS_U8:
                        {
                                for (int64 i = 0; i < frames; i++) {
                                        ApplyMod<uint8, 0, 128, UINT8_MAX>((uint8*)data, i, pan);
                                        UpdateMods();
                                }

                                break;
                        }

                        case gs_audio_format::B_GS_S16:
                        {
                                for (int64 i = 0; i < frames; i++) {
                                        ApplyMod<int16, INT16_MIN, 0, INT16_MAX>((int16*)data, i,
                                                pan);
                                        UpdateMods();
                                }

                                break;
                        }

                        case gs_audio_format::B_GS_S32:
                        {
                                for (int64 i = 0; i < frames; i++) {
                                        ApplyMod<int32, INT32_MIN, 0, INT32_MAX>((int32*)data, i,
                                                pan);
                                        UpdateMods();
                                }

                                break;
                        }

                        case gs_audio_format::B_GS_F:
                        {
                                for (int64 i = 0; i < frames; i++) {
                                        ApplyMod<float, -1, 0, 1>((float*)data, i, pan);
                                        UpdateMods();
                                }

                                break;
                        }
                }
        } else if (fFormat.channel_count == 1) {
                // FIXME the output should be stereo, and we could pan mono sounds
                // here. But currently the output has the same number of channels as
                // the sound and we can't do this.
                // FIXME also, we don't handle the gain here.
                FillBuffer(data, frames);
        } else
                debugger("Invalid number of channels.");

}


void
GameSoundBuffer::UpdateMods()
{
        // adjust the gain if needed
        if (fGainRamp) {
                if (ChangeRamp(fGainRamp)) {
                        delete fGainRamp;
                        fGainRamp = NULL;
                }
        }

        // adjust the ramp if needed
        if (fPanRamp) {
                if (ChangeRamp(fPanRamp)) {
                        delete fPanRamp;
                        fPanRamp = NULL;
                } else {
                        if (fPan < 0.0) {
                                fPanLeft = 1.0;
                                fPanRight = 1.0 + fPan;
                        } else {
                                fPanRight = 1.0;
                                fPanLeft = 1.0 - fPan;
                        }
                }
        }
}


void
GameSoundBuffer::Reset()
{
        fGain = 1.0;
        delete fGainRamp;
        fGainRamp = NULL;

        fPan = 0.0;
        fPanLeft = 1.0;
        fPanRight = 1.0;

        delete fPanRamp;
        fPanRamp = NULL;

        fLooping = false;
}


status_t
GameSoundBuffer::Connect(media_node * consumer)
{
        BMediaRoster* roster = BMediaRoster::Roster();
        status_t err = roster->RegisterNode(fNode);

        if (err != B_OK)
                return err;

        // make sure the Media Roster knows that we're using the node
        err = roster->GetNodeFor(fNode->Node().node, &fConnection->producer);

        if (err != B_OK)
                return err;

        // connect to the mixer
        fConnection->consumer = *consumer;

        // set the producer's time source to be the "default" time source, which
        // the Mixer uses too.
        err = roster->GetTimeSource(&fConnection->timeSource);
        if (err != B_OK)
                return err;

        err = roster->SetTimeSourceFor(fConnection->producer.node,
                fConnection->timeSource.node);
        if (err != B_OK)
                return err;
        // got the nodes; now we find the endpoints of the connection
        media_input mixerInput;
        media_output soundOutput;
        int32 count = 1;
        err = roster->GetFreeOutputsFor(fConnection->producer, &soundOutput, 1,
                &count);

        if (err != B_OK)
                return err;
        count = 1;
        err = roster->GetFreeInputsFor(fConnection->consumer, &mixerInput, 1,
                &count);
        if (err != B_OK)
                return err;

        // got the endpoints; now we connect it!
        media_format format;
        format.type = B_MEDIA_RAW_AUDIO;
        format.u.raw_audio = media_raw_audio_format::wildcard;
        err = roster->Connect(soundOutput.source, mixerInput.destination, &format,
                &soundOutput, &mixerInput);
        if (err != B_OK)
                return err;

        // the inputs and outputs might have been reassigned during the
        // nodes' negotiation of the Connect().  That's why we wait until
        // after Connect() finishes to save their contents.
        fConnection->format = format;
        fConnection->source = soundOutput.source;
        fConnection->destination = mixerInput.destination;

        fIsConnected = true;
        return B_OK;
}


status_t
GameSoundBuffer::StartPlaying()
{
        if (fIsPlaying)
                return EALREADY;

        BMediaRoster* roster = BMediaRoster::Roster();
        BTimeSource* source = roster->MakeTimeSourceFor(fConnection->producer);

        // make sure we give the producer enough time to run buffers through
        // the node chain, otherwise it'll start up already late
        bigtime_t latency = 0;
        status_t status = roster->GetLatencyFor(fConnection->producer, &latency);
        if (status == B_OK) {
                status = roster->StartNode(fConnection->producer,
                        source->Now() + latency);
        }
        source->Release();

        fIsPlaying = true;

        return status;
}


status_t
GameSoundBuffer::StopPlaying()
{
        if (!fIsPlaying)
                return EALREADY;

        BMediaRoster* roster = BMediaRoster::Roster();
        roster->StopNode(fConnection->producer, 0, true);
                // synchronous stop

        Reset();
        fIsPlaying = false;

        return B_OK;
}


bool
GameSoundBuffer::IsPlaying()
{
        return fIsPlaying;
}


// SimpleSoundBuffer ------------------------------------------------------
SimpleSoundBuffer::SimpleSoundBuffer(const gs_audio_format * format,
        const void * data, int64 frames)
        :
        GameSoundBuffer(format),
        fPosition(0)
{
        fBufferSize = frames * fFrameSize;
        fBuffer = (char*)data;
}


SimpleSoundBuffer::~SimpleSoundBuffer()
{
        delete [] fBuffer;
}


void
SimpleSoundBuffer::Reset()
{
        GameSoundBuffer::Reset();
        fPosition = 0;
}


void
SimpleSoundBuffer::FillBuffer(void * data, int64 frames)
{
        char * buffer = (char*)data;
        size_t bytes = fFrameSize * frames;

        if (fPosition + bytes >= fBufferSize) {
                if (fPosition < fBufferSize) {
                        // copy the remaining frames
                        size_t remainder = fBufferSize - fPosition;
                        memcpy(buffer, &fBuffer[fPosition], remainder);

                        bytes -= remainder;
                        buffer += remainder;
                }

                if (fLooping) {
                        // restart the sound from the beginning
                        memcpy(buffer, fBuffer, bytes);
                        fPosition = bytes;
                        bytes = 0;
                } else {
                        fPosition = fBufferSize;
                }

                if (bytes > 0) {
                        // Fill the rest with silence
                        int middle = 0;
                        if (fFormat.format == gs_audio_format::B_GS_U8)
                                middle = 128;
                        memset(buffer, middle, bytes);
                }
        } else {
                memcpy(buffer, &fBuffer[fPosition], bytes);
                fPosition += bytes;
        }
}


// StreamingSoundBuffer ------------------------------------------------------
StreamingSoundBuffer::StreamingSoundBuffer(const gs_audio_format * format,
        const void * streamHook, size_t inBufferFrameCount, size_t inBufferCount)
        :
        GameSoundBuffer(format),
        fStreamHook(const_cast<void *>(streamHook))
{
        if (inBufferFrameCount != 0 && inBufferCount  != 0) {
                BBufferGroup *bufferGroup
                        = new BBufferGroup(inBufferFrameCount * fFrameSize, inBufferCount);
                fNode->SetBufferGroup(fConnection->source, bufferGroup);
        }
}


StreamingSoundBuffer::~StreamingSoundBuffer()
{
}


void
StreamingSoundBuffer::FillBuffer(void * buffer, int64 frames)
{
        BStreamingGameSound* object = (BStreamingGameSound*)fStreamHook;

        size_t bytes = fFrameSize * frames;
        object->FillBuffer(buffer, bytes);
}