/*
 * Copyright (c) 1999-2000, Eric Moon.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions, and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


// AudioAdapterNode.cpp

#include "AudioAdapterNode.h"
#include "AudioAdapterParams.h"

#include "SoundUtils.h"

#include <cstdio>
#include <cstring>

// -------------------------------------------------------- //
// ctor/dtor
// -------------------------------------------------------- //

_AudioAdapterNode::~_AudioAdapterNode() {}

_AudioAdapterNode::_AudioAdapterNode(
        const char*                                                                     name,
        IAudioOpFactory*                                                opFactory,
        BMediaAddOn*                                                            addOn) :
        
        BMediaNode(name),
        AudioFilterNode(name, opFactory, addOn) {
        
//      PRINT((
//              "\n"
//              "--*-- _AudioAdapterNode() [%s] --*--\n\n",
//              __BUILD_DATE__));
}

// -------------------------------------------------------- //
// AudioFilterNode
// -------------------------------------------------------- //

status_t _AudioAdapterNode::getRequiredInputFormat(
        media_format&                                                           ioFormat) {
                
        status_t err = getPreferredInputFormat(ioFormat);
        if(err < B_OK)
                return err;

        // 16sep99: input byte-swapping now supported           
        ioFormat.u.raw_audio.byte_order = media_raw_audio_format::wildcard.byte_order;
                
//      ioFormat.u.raw_audio.format = media_raw_audio_format::wildcard.format;
//      ioFormat.u.raw_audio.channel_count = media_raw_audio_format::wildcard.channel_count;
        _AudioAdapterParams* p = dynamic_cast<_AudioAdapterParams*>(parameterSet());
        ASSERT(p);
        
//      media_raw_audio_format& w = media_raw_audio_format::wildcard;
        
        // copy user preferences
        ioFormat.u.raw_audio.format = p->inputFormat.format;
        ioFormat.u.raw_audio.channel_count = p->inputFormat.channel_count;


        // don't require a buffer size until format & channel_count are known [16sep99]
        ioFormat.u.raw_audio.buffer_size = media_raw_audio_format::wildcard.buffer_size;

        if(output().destination == media_destination::null) {
                // frame rate isn't constrained yet
                ioFormat.u.raw_audio.frame_rate = media_raw_audio_format::wildcard.frame_rate;
        }
                                
        return B_OK;
}

// +++++ 17sep99: use parameter data!

status_t _AudioAdapterNode::getPreferredInputFormat(
        media_format&                                                           ioFormat) {

        status_t err = _inherited::getPreferredInputFormat(ioFormat);
        if(err < B_OK)
                return err;
                
        _AudioAdapterParams* p = dynamic_cast<_AudioAdapterParams*>(parameterSet());
        ASSERT(p);
        
        media_raw_audio_format& f = ioFormat.u.raw_audio;
        const media_raw_audio_format& w = media_raw_audio_format::wildcard;
        
        // copy user preferences
        if(p->inputFormat.format != w.format)
                f.format = p->inputFormat.format;
        if(p->inputFormat.channel_count != w.channel_count)
                f.channel_count = p->inputFormat.channel_count;
        
//      // if one end is connected, prefer not to do channel conversions [15sep99]
//      if(output().destination != media_destination::null)
//              ioFormat.u.raw_audio.channel_count = output().format.u.raw_audio.channel_count; 

        // if output connected, constrain:
        //   buffer_size
        //   frame_rate
        if(output().destination != media_destination::null) {
                // if the user doesn't care, default to the output's frame format
                if(f.format == w.format)
                        f.format = output().format.u.raw_audio.format;
                if(f.channel_count == w.channel_count)
                        f.channel_count = output().format.u.raw_audio.channel_count;

                f.buffer_size =
                        bytes_per_frame(f) *
                                frames_per_buffer(output().format.u.raw_audio);
                f.frame_rate = output().format.u.raw_audio.frame_rate;          
        }

        return B_OK;
}
        
status_t _AudioAdapterNode::getRequiredOutputFormat(
        media_format&                                                           ioFormat) {
                
        status_t err = getPreferredOutputFormat(ioFormat);
        if(err < B_OK)
                return err;
                
        ioFormat.u.raw_audio.format = media_raw_audio_format::wildcard.format;
        ioFormat.u.raw_audio.channel_count = media_raw_audio_format::wildcard.channel_count;

        _AudioAdapterParams* p = dynamic_cast<_AudioAdapterParams*>(parameterSet());
        ASSERT(p);
        
//      media_raw_audio_format& w = media_raw_audio_format::wildcard;
        
        // copy user preferences
        ioFormat.u.raw_audio.format = p->outputFormat.format;
        ioFormat.u.raw_audio.channel_count = p->outputFormat.channel_count;

        // don't require a buffer size until format & channel_count are known [16sep99]
        ioFormat.u.raw_audio.buffer_size = media_raw_audio_format::wildcard.buffer_size;
                
        if(input().source == media_source::null) {
                // frame rate isn't constrained yet
                ioFormat.u.raw_audio.frame_rate = media_raw_audio_format::wildcard.frame_rate;
        }
                
        return B_OK;
}
        
// +++++ 17sep99: use parameter data!

status_t _AudioAdapterNode::getPreferredOutputFormat(
        media_format&                                                           ioFormat) {

        status_t err = _inherited::getPreferredOutputFormat(ioFormat);
        if(err < B_OK)
                return err;

        _AudioAdapterParams* p = dynamic_cast<_AudioAdapterParams*>(parameterSet());
        ASSERT(p);
        
        const media_raw_audio_format& w = media_raw_audio_format::wildcard;
        
        // copy user preferences
        if(p->outputFormat.format != w.format)
                ioFormat.u.raw_audio.format = p->outputFormat.format;
        if(p->outputFormat.channel_count != w.channel_count)
                ioFormat.u.raw_audio.channel_count = p->outputFormat.channel_count;

////    // if one end is connected, prefer not to do channel conversions [15sep99]
////    if(input().source != media_source::null)
////            ioFormat.u.raw_audio.channel_count = input().format.u.raw_audio.channel_count;
                
        // if input connected, constrain:
        //   buffer_size
        //   frame_rate
        if(input().source != media_source::null) {              
                // if the user doesn't care, default to the input's frame format
                if(ioFormat.u.raw_audio.format == w.format)
                        ioFormat.u.raw_audio.format = input().format.u.raw_audio.format;
                if(ioFormat.u.raw_audio.channel_count == w.channel_count)
                        ioFormat.u.raw_audio.channel_count = input().format.u.raw_audio.channel_count;

                ioFormat.u.raw_audio.buffer_size =
                        bytes_per_frame(ioFormat.u.raw_audio) *
                                frames_per_buffer(input().format.u.raw_audio);
                PRINT(("##### preferred output buffer_size: %ld (%" B_PRIxSIZE ")\n", ioFormat.u.raw_audio.buffer_size, ioFormat.u.raw_audio.buffer_size));
                ioFormat.u.raw_audio.frame_rate = input().format.u.raw_audio.frame_rate;

        }


        return B_OK;
}
        
status_t _AudioAdapterNode::validateProposedInputFormat(
        const media_format&                                     preferredFormat,
        media_format&                                                           ioProposedFormat) {
                
        status_t err = _inherited::validateProposedInputFormat(
                preferredFormat, ioProposedFormat);
                
        const media_raw_audio_format& w = media_raw_audio_format::wildcard;
                
        if(output().destination != media_destination::null) {

                // an output connection exists; constrain the input format
                
                // is there enough information to suggest a buffer size?
                if(
                        ioProposedFormat.u.raw_audio.format != w.format &&
                        ioProposedFormat.u.raw_audio.channel_count != w.channel_count) {
                                        
                        size_t target_buffer_size = 
                                bytes_per_frame(ioProposedFormat.u.raw_audio) *
                                        frames_per_buffer(output().format.u.raw_audio);
        
                        if(ioProposedFormat.u.raw_audio.buffer_size != target_buffer_size) {
                                if(ioProposedFormat.u.raw_audio.buffer_size != w.buffer_size)
                                        err = B_MEDIA_BAD_FORMAT;

                                ioProposedFormat.u.raw_audio.buffer_size = target_buffer_size;
                        }
                }
                        
                // require output frame rate
                if(ioProposedFormat.u.raw_audio.frame_rate != output().format.u.raw_audio.frame_rate) {
                        if(ioProposedFormat.u.raw_audio.frame_rate != w.frame_rate)
                                err = B_MEDIA_BAD_FORMAT;

                        ioProposedFormat.u.raw_audio.frame_rate = output().format.u.raw_audio.frame_rate;
                }
        }
                
        char fmt_string[256];
        string_for_format(ioProposedFormat, fmt_string, 255);
                PRINT((
                "### _AudioAdapterNode::validateProposedInputFormat():\n"
                "    %s\n", fmt_string));
        return err;
}

status_t _AudioAdapterNode::validateProposedOutputFormat(
        const media_format&                                     preferredFormat,
        media_format&                                                           ioProposedFormat) {
                
        status_t err = _inherited::validateProposedOutputFormat(
                preferredFormat, ioProposedFormat);
                
        const media_raw_audio_format& w = media_raw_audio_format::wildcard;
                
        if(input().source != media_source::null) {

                // an input connection exists; constrain the output format

                // is there enough information to suggest a buffer size?
                if(
                        ioProposedFormat.u.raw_audio.format != w.format &&
                        ioProposedFormat.u.raw_audio.channel_count != w.channel_count) {
                                        
                        size_t target_buffer_size = 
                                bytes_per_frame(ioProposedFormat.u.raw_audio) *
                                        frames_per_buffer(input().format.u.raw_audio);

                        if(ioProposedFormat.u.raw_audio.buffer_size != target_buffer_size) {
                                if(ioProposedFormat.u.raw_audio.buffer_size != w.buffer_size)
                                        err = B_MEDIA_BAD_FORMAT;

                                ioProposedFormat.u.raw_audio.buffer_size = target_buffer_size;
                        }
                }
                
                // require same frame rate as input
                if(ioProposedFormat.u.raw_audio.frame_rate != input().format.u.raw_audio.frame_rate) {
                        if(ioProposedFormat.u.raw_audio.frame_rate != w.frame_rate)
                                err = B_MEDIA_BAD_FORMAT;

                        ioProposedFormat.u.raw_audio.frame_rate = input().format.u.raw_audio.frame_rate;
                }
        }
        
        char fmt_string[256];
        string_for_format(ioProposedFormat, fmt_string, 255);
        PRINT((
                "### _AudioAdapterNode::validateProposedOutputFormat():\n"
                "    %s\n", fmt_string));
        return err;
}

void 
_AudioAdapterNode::SetParameterValue(int32 id, bigtime_t changeTime, const void *value, size_t size)
{
        switch(id) {
        case _AudioAdapterParams::P_INPUT_FORMAT:
                if(input().source != media_source::null) {
                        media_multi_audio_format f = input().format.u.raw_audio;
                        if(size != 4)
                                return;
                        f.format = *(uint32*)value;
                        _attemptInputFormatChange(f);
                        return;
                }
                break;
        case _AudioAdapterParams::P_INPUT_CHANNEL_COUNT:
                if(input().source != media_source::null) {
                        media_multi_audio_format f = input().format.u.raw_audio;
                        if(size != 4)
                                return;
                        f.channel_count = *(uint32*)value;
                        _attemptInputFormatChange(f);
                        return;
                }
                break;
        case _AudioAdapterParams::P_OUTPUT_FORMAT:
                if(output().source != media_source::null) {
                        media_multi_audio_format f = output().format.u.raw_audio;
                        if(size != 4)
                                return;
                        f.format = *(uint32*)value;
                        _attemptOutputFormatChange(f);
                        return;
                }
                break;
        case _AudioAdapterParams::P_OUTPUT_CHANNEL_COUNT:
                if(output().source != media_source::null) {
                        media_multi_audio_format f = output().format.u.raw_audio;
                        if(size != 4)
                                return;
                        f.channel_count = *(uint32*)value;
                        _attemptOutputFormatChange(f);
                        return;
                }
                break;
        }
                
        return _inherited::SetParameterValue(id, changeTime, value, size);
}


// -------------------------------------------------------- //
// BBufferProducer/Consumer
// -------------------------------------------------------- //

status_t _AudioAdapterNode::Connected(
        const media_source&                                     source,
        const media_destination&                destination,
        const media_format&                                     format,
        media_input*                                                            outInput) {

        status_t err = _inherited::Connected(
                source, destination, format, outInput);
        
        if(err == B_OK) {
                _AudioAdapterParams* p = dynamic_cast<_AudioAdapterParams*>(parameterSet());
                ASSERT(p);      
                p->inputFormat = format.u.raw_audio;

                _broadcastInputFormatParams();
        }
        
        return err;
}       

void _AudioAdapterNode::Connect(
        status_t                                                                                status,
        const media_source&                                     source,
        const media_destination&                destination,
        const media_format&                                     format,
        char*                                                                                           ioName) {

        if(status == B_OK) {
                _AudioAdapterParams* p = dynamic_cast<_AudioAdapterParams*>(parameterSet());
                ASSERT(p);
                p->outputFormat = format.u.raw_audio;

                _broadcastOutputFormatParams();
        }       
        
        _inherited::Connect(
                status, source, destination, format, ioName);
}
                

void _AudioAdapterNode::_attemptInputFormatChange(
        const media_multi_audio_format& format) {
        // +++++
        
        char fmtString[256];
        media_format f;
        f.type = B_MEDIA_RAW_AUDIO;
        f.u.raw_audio = format;
        string_for_format(f, fmtString, 256);
        PRINT((
                "_AudioAdapterNode::attemptInputFormatChange():\n  '%s'\n",
                fmtString));
                


        // +++++ reject attempt: broadcast params for current format
        _broadcastInputFormatParams();
}

void _AudioAdapterNode::_attemptOutputFormatChange(
        const media_multi_audio_format& format) {

        // +++++
        char fmtString[256];
        media_format f;
        f.type = B_MEDIA_RAW_AUDIO;
        f.u.raw_audio = format;
        string_for_format(f, fmtString, 256);
        PRINT((
                "_AudioAdapterNode::attemptOutputFormatChange():\n  '%s'\n",
                fmtString));
        
        media_destination dest = output().destination;
        if(dest == media_destination::null) {
        PRINT((
                "! output not connected!\n"));
                return;
        }

        _AudioAdapterParams* p = dynamic_cast<_AudioAdapterParams*>(parameterSet());
        ASSERT(p);
        status_t err;
        
        // disallow wildcards
        if(format.format == media_raw_audio_format::wildcard.format ||
                format.channel_count == media_raw_audio_format::wildcard.channel_count) {
                PRINT((
                        "! wildcards not allowed\n"));
                goto broadcast;
        }

        err = prepareFormatChange(f);
        if(err < B_OK)
        {
                PRINT((
                        "! format not supported\n"));
                goto broadcast;
        }

        err = ProposeFormatChange(&f, dest);
        if(err < B_OK)
        {
                PRINT((
                        "! format rejected\n"));
                goto broadcast;
        }

        err = ChangeFormat(
                output().source,
                dest,
                &f);
                
        if(err < B_OK) {
                PRINT(("! ChangeFormat(): %s\n", strerror(err)));
                goto broadcast;
        }

        // store new format
        p->outputFormat = format;
        
        // inform AudioFilterNode of format change
        doFormatChange(f);

broadcast:
        _broadcastOutputFormatParams();
} 


void 
_AudioAdapterNode::_broadcastInputFormatParams()
{
        PRINT(("_AudioAdapterNode::_broadcastInputFormatParams()\n"));
        BroadcastNewParameterValue(
                0LL,
                _AudioAdapterParams::P_INPUT_FORMAT,
                (void*)&input().format.u.raw_audio.format,
                4);
        BroadcastNewParameterValue(
                0LL,
                _AudioAdapterParams::P_INPUT_CHANNEL_COUNT,
                (void*)&input().format.u.raw_audio.channel_count,
                4);
//      BroadcastChangedParameter(_AudioAdapterParams::P_INPUT_FORMAT);
//      BroadcastChangedParameter(_AudioAdapterParams::P_INPUT_CHANNEL_COUNT);
}

void 
_AudioAdapterNode::_broadcastOutputFormatParams()
{
        PRINT(("_AudioAdapterNode::_broadcastOutputFormatParams()\n"));
        
        BroadcastNewParameterValue(
                0LL,
                _AudioAdapterParams::P_OUTPUT_FORMAT,
                (void*)&output().format.u.raw_audio.format,
                4);
        BroadcastNewParameterValue(
                0LL,
                _AudioAdapterParams::P_OUTPUT_CHANNEL_COUNT,
                (void*)&output().format.u.raw_audio.channel_count,
                4);
//      BroadcastChangedParameter(_AudioAdapterParams::P_OUTPUT_FORMAT);
//      BroadcastChangedParameter(_AudioAdapterParams::P_OUTPUT_CHANNEL_COUNT);
}



// END -- AudioAdapterNode.cpp --