/*---------------------------------------------------------------------------*
  Project:  NintendoWare
  File:     snd_HardwareManagerAX.cppi

  Copyright (C)2009-2010 Nintendo Co., Ltd./HAL Laboratory, Inc.  All rights reserved.

  These coded instructions, statements, and computer programs contain
  proprietary information of Nintendo of America Inc. and/or Nintendo
  Company Ltd., and are protected by Federal copyright law.  They may
  not be disclosed to third parties or copied or duplicated in any form,
  in whole or in part, without the prior written consent of Nintendo.

  $Revision:$
 *---------------------------------------------------------------------------*/

#include "precompiled.h"

#include <nw/snd/snd_HardwareManager.h>

namespace nw {
namespace snd {
namespace internal {
namespace driver {

namespace
{
NN_ATTRIBUTE_ALIGN(32) u8 s_ZeroBuffer[ HardwareManager::ZERO_BUFFER_SIZE ];
const u16 AUX_RETURN_VOLUME_MAX = 0x8000;
}

//
// 関数
//
/*---------------------------------------------------------------------------*
    Name:           HardwareManager

    Description:    コンストラクタ

    Arguments:      なし

    Returns:        なし
 *---------------------------------------------------------------------------*/
HardwareManager::HardwareManager()
: m_IsInitialized( false ),
//  m_UpdateVoicePrioFlag( true ),
  m_pZeroBufferAddress( NULL ),
  m_OldAidCallback( NULL ),
  m_ResetReadyCounter( -1 ),
  m_OutputMode( OUTPUT_MODE_STEREO ),
  m_SrcType( SRC_TYPE_4TAP )
{
    m_MasterVolume.InitValue( 1.0f );
    m_VolumeForReset.InitValue( 1.0f );

    for ( int i=0; i<AUX_BUS_NUM; i++ )
    {
        m_AuxFadeVolume[ i ].InitValue( 1.0f );
        m_AuxUserVolume[ i ].InitValue( 1.0f );
        m_AuxCallback[ i ] = NULL;
        m_AuxCallbackContext[ i ] = NULL;
        m_EffectProcessTick[ i ] = 0;
    }
}

void* HardwareManager::GetZeroBufferAddress()
{
    NW_ASSERTMSG( m_pZeroBufferAddress, "Zero buffer is not created." );
    return m_pZeroBufferAddress;
}

void HardwareManager::Initialize()
{
    if ( m_IsInitialized ) return;

    // TODO: NW_ASSERTMSG( AI_CheckInit(), "not initialized AI\n" );

    // ゼロバッファ作成
    (void)std::memset( s_ZeroBuffer, 0, ZERO_BUFFER_SIZE );
    // TODO: DCFlushRange( s_ZeroBuffer, ZERO_BUFFER_SIZE );
    m_pZeroBufferAddress = s_ZeroBuffer;

    // AUXコールバック設定
    // 既に登録されているAUXコールバックを保存する
    AX_GetAuxACallback( &m_AuxCallback[ AUX_BUS_A ], &m_AuxCallbackContext[ AUX_BUS_A ] );
    AX_GetAuxBCallback( &m_AuxCallback[ AUX_BUS_B ], &m_AuxCallbackContext[ AUX_BUS_B ] );

    // AXコールバック設定(既に登録されているAXコールバックがあれば保存する)
    m_PreRegisteredCallback = AX_RegisterCallback( &AxCallbackFunc );

#if 0 // BIQUAD
    // biquadフィルタテーブル初期化
    (void)std::memset( sBiquadFilterCallbackTable, 0, sizeof( sBiquadFilterCallbackTable ) );
    SetBiquadFilterCallback( BIQUAD_FILTER_TYPE_LPF, &sBiquadFilterLpf );
    SetBiquadFilterCallback( BIQUAD_FILTER_TYPE_HPF, &sBiquadFilterHpf );
    SetBiquadFilterCallback( BIQUAD_FILTER_TYPE_BPF512, &sBiquadFilterBpf512 );
    SetBiquadFilterCallback( BIQUAD_FILTER_TYPE_BPF1024, &sBiquadFilterBpf1024 );
    SetBiquadFilterCallback( BIQUAD_FILTER_TYPE_BPF2048, &sBiquadFilterBpf2048 );
#endif

    m_IsInitialized = true;
    m_OutputMode    = OUTPUT_MODE_STEREO;
}

void HardwareManager::Finalize()
{
    if ( !m_IsInitialized ) return;

    // AXコールバックを元に戻す
    (void)AX_RegisterCallback( m_PreRegisteredCallback );

    // エフェクトクリア
    for ( int bus = AUX_BUS_A; bus < AUX_BUS_NUM; bus++ )
    {
        FinalizeEffect( static_cast<AuxBus>( bus ) );
    }

    // AXのコールバックを元に戻す
    AX_RegisterAuxACallback( m_AuxCallback[ AUX_BUS_A ], m_AuxCallbackContext[ AUX_BUS_A ] );
    AX_RegisterAuxBCallback( m_AuxCallback[ AUX_BUS_B ], m_AuxCallbackContext[ AUX_BUS_B ] );
    for ( int i=0; i<AUX_BUS_NUM; i++ )
    {
        m_AuxCallback[ i ] = NULL;
        m_AuxCallbackContext[ i ] = NULL;
    }

    // ゼロバッファへの参照をクリア
    m_pZeroBufferAddress = NULL;

    m_IsInitialized = false;
}

void HardwareManager::Update()
{
    // ClearEffect のフェード処理。フェードが完了したらエフェクトをクリア
    for ( int i=0; i<AUX_BUS_NUM; i++ )
    {
        bool updateFlag = false;
        if ( ! m_AuxUserVolume[ i ].IsFinished() )
        {
            m_AuxUserVolume[ i ].Update();
            updateFlag = true;
        }
        if ( ! m_AuxFadeVolume[ i ].IsFinished() )
        {
            m_AuxFadeVolume[ i ].Update();
            if ( m_AuxFadeVolume[ i ].IsFinished() )
            {
                FinalizeEffect( static_cast<AuxBus>( i ) );
            }
            updateFlag = true;
        }

        if ( updateFlag )
        {
            float returnVolumeFloat = 1.0f;
            returnVolumeFloat *= ut::Clamp( m_AuxUserVolume[ i ].GetValue(), 0.0f, 1.0f );
            returnVolumeFloat *= ut::Clamp( m_AuxFadeVolume[ i ].GetValue(), 0.0f, 1.0f );
            u16 returnVolume = static_cast<u16>( returnVolumeFloat * AUX_RETURN_VOLUME_MAX );
            switch ( i )
            {
            case AUX_BUS_A:
                AX_SetAuxAReturnVolume( returnVolume );
                break;
            case AUX_BUS_B:
                AX_SetAuxBReturnVolume( returnVolume );
                break;
            }
        }
    }

    // 音量のアップデート
    if ( ! m_MasterVolume.IsFinished() ) {
        m_MasterVolume.Update();
        VoiceManager::GetInstance().UpdateAllVoicesSync( Voice::UPDATE_VE );
    }

    if ( ! m_VolumeForReset.IsFinished() ) {
        m_VolumeForReset.Update();
        VoiceManager::GetInstance().UpdateAllVoicesSync( Voice::UPDATE_VE );
    }

    {
        f32 volume = 1.0f;
        volume *= m_VolumeForReset.GetValue();

        volume = ut::Clamp( volume, 0.0f, 1.0f );

        AX_SetMasterVolume( static_cast<u16>(volume * 0x8000) );
    }
}
    // RVL は計96ch中、マージン16だった

u32 HardwareManager::GetChannelCount() const
{
    return AX_GetMaxVoices();
}

/* ========================================================================
        リセット前準備
   ======================================================================== */

void HardwareManager::PrepareReset()
{
    if ( m_OldAidCallback != NULL ) return;

    m_VolumeForReset.SetTarget( 0.0f, 3 ); // ３オーディオフレームかけてフェードアウト
    m_ResetReadyCounter = -1;
    m_OldAidCallback = ::AI_RegisterDMACallback( AiDmaCallbackFunc );
}

void HardwareManager::AiDmaCallbackFunc()
{
    GetInstance().PrepareResetProc();
}

void HardwareManager::PrepareResetProc()
{
    static bool finishedFlag = false;
    m_OldAidCallback();

    if ( finishedFlag )
    {
        if ( m_ResetReadyCounter < 0 )
        {
            AX_SetMaxDspCycles( 0 );
            m_ResetReadyCounter = 6;
        }
    }
    else if ( m_VolumeForReset.GetValue() == 0.0f )
    {
        finishedFlag = true;
    }

    if ( m_ResetReadyCounter > 0 ) --m_ResetReadyCounter;
}

bool HardwareManager::IsResetReady() const
{
    return m_ResetReadyCounter == 0 ? true : false;
}

void HardwareManager::AxCallbackFunc()
{
    // ユーザーコールバックの呼び出し
    HardwareCallbackFunc();

    // もともと設定されていたコールバックの呼び出し
    AXUserCallback callback = GetInstance().m_PreRegisteredCallback;
    if ( callback != NULL )
    {
        callback();
    }
}

/*---------------------------------------------------------------------------*
    Name:           AxCallbackFunc

    Description:    AXコールバックに登録される関数

    Arguments:      なし

    Returns:        なし
 *---------------------------------------------------------------------------*/
void HardwareManager::HardwareCallbackFunc()
{
    for ( CallbackList::Iterator itr = GetInstance().m_CallbackList.GetBeginIter();
          itr != GetInstance().m_CallbackList.GetEndIter();
        )
    {
        CallbackList::Iterator curItr = itr++;
        curItr->callback();
    }
}

/*---------------------------------------------------------------------------*
    Name:           RegisterAxCallback

    Description:    AXコールバックの登録をリストに追加する

    Arguments:      node: AXコールバックリストのノード
                    callback: AXコールバック関数

    Returns:
 *---------------------------------------------------------------------------*/
void HardwareManager::RegisterCallback(
        CallbackListNode* node,
        HardwareCallback callback )
{
    node->callback = callback;
    m_CallbackList.PushBack( node );
}

/*---------------------------------------------------------------------------*
    Name:           UnregisterAxCallback

    Description:    AXコールバックの登録をリストから削除する

    Arguments:      node: AXコールバックリストのノード

    Returns:
 *---------------------------------------------------------------------------*/
void HardwareManager::UnregisterCallback( CallbackListNode* node )
{
    m_CallbackList.Erase( node );
}

} /* namespace nw::snd::internal::driver */
} /* namespace nw::snd::internal */
} /* namespace nw::snd */
} /* namespace nw */