/*---------------------------------------------------------------------------*
  Project:  NintendoWare
  File:     snd_HardwareManager.h

  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: 25093 $
 *---------------------------------------------------------------------------*/

#ifndef NW_SND_HARDWARE_MANAGER_H_
#define NW_SND_HARDWARE_MANAGER_H_

#include <nw/ut/ut_LinkList.h>
#include <nw/snd/snd_Global.h>
#include <nw/snd/snd_MoveValue.h>
#include <nw/snd/snd_Util.h>
#include <nw/snd/snd_Macro.h>
#include <nw/snd/snd_FxBase.h>
#include <nw/snd/snd_BiquadFilterCallback.h>
#include <nw/snd/snd_BiquadFilterPresets.h>

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

class HardwareManager : public Util::Singleton<HardwareManager>
{
public:
    typedef void (*HardwareCallback)();

public:

    // 1 オーディオフレームあたり何ミリ秒か？
    static const u32 SOUND_FRAME_INTERVAL_MSEC = 5;     // 大体の数値

    // 何ボイスあるか？
    static const u32 SOUND_VOICE_COUNT = NN_SND_VOICE_NUM;
    
    // ------------------------------------------------------------------------
    // 初期化
    void Initialize();
    bool IsInitialized() { return m_IsInitialized != 0; }
    void Finalize();

    void Update();

    // ------------------------------------------------------------------------
    // 出力モード
    void SetOutputMode( OutputMode mode );
    OutputMode GetOutputMode() const { return m_OutputMode; }

    // ------------------------------------------------------------------------
    // エフェクト

    // エフェクト管理
    typedef ut::LinkList< FxBase, offsetof(FxBase, m_Link) > FxList;
    static const SampleFormat FX_SAMPLE_FORMAT = SAMPLE_FORMAT_PCM_S32;
    static const int FX_SAMPLE_RATE = 32728;

    // エフェクト登録、削除、削除確認
    bool AppendEffect( AuxBus bus, FxBase* pFx );
    void ClearEffect( AuxBus bus, int fadeTimes );
    bool IsFinishedClearEffect( AuxBus bus ) const
    {
        NW_MINMAXLT_ASSERT( bus, AUX_BUS_A, AUX_BUS_A + AUX_BUS_NUM );
        return m_AuxFadeVolume[ bus ].IsFinished();
    }

    // リターンボリューム
    void SetAuxReturnVolume( AuxBus bus, f32 volume, int fadeTimes )
    {
        NW_MINMAXLT_ASSERT( bus, AUX_BUS_A, AUX_BUS_A + AUX_BUS_NUM );
        m_AuxUserVolume[ bus ].SetTarget( volume, fadeTimes );
    }
    f32 GetAuxReturnVolume( AuxBus bus ) const
    {
        NW_MINMAXLT_ASSERT( bus, AUX_BUS_A, AUX_BUS_A + AUX_BUS_NUM );
        return m_AuxUserVolume[ bus ].GetValue();
    }

#ifdef NW_PLATFORM_CTR
    // エフェクト負荷計測
    nn::os::Tick GetEffectProcessTick( AuxBus bus ) const
    {
        return m_EffectProcessTick[ bus ];
    }
#endif


    // ------------------------------------------------------------------------
    f32 GetOutputVolume() const;

    // ------------------------------------------------------------------------
    // マスターボリューム
    void SetMasterVolume( float volume, int fadeTimes );
    f32 GetMasterVolume() const { return m_MasterVolume.GetValue(); }

    // ------------------------------------------------------------------------
    // SRC タイプ
    void SetSrcType( SrcType type );
    SrcType GetSrcType() const { return m_SrcType; }

    // ------------------------------------------------------------------------
    // Biquad フィルタ
    void SetBiquadFilterCallback( int type, const BiquadFilterCallback* cb );
    const BiquadFilterCallback* GetBiquadFilterCallback( int type )
    {
        NW_MINMAX_ASSERT( type, BIQUAD_FILTER_TYPE_NONE, BIQUAD_FILTER_TYPE_USER_MAX );
        return m_BiquadFilterCallbackTable[ type ];
    }

    // ------------------------------------------------------------------------
    // リセット前準備
    void PrepareReset();
    bool IsResetReady() const;

    u32 GetChannelCount() const;

    HardwareManager();

private:
    static const u8 AUX_CALLBACK_WAIT_FRAME = 2;
#ifdef NW_PLATFORM_CTRWIN
    static const u16 AUX_RETURN_VOLUME_MAX = 0x8000;
    static void AuxCallbackFunc( void* data, void* context );
    typedef void (*AuxCallback)(void *data, void *context);
#else
    static const f32 AUX_RETURN_VOLUME_MAX = 1.0f;
    static void AuxCallbackFunc( nn::snd::AuxBusData* data, s32 sampleLength, uptr userData );
    typedef void (*AuxCallback)( nn::snd::AuxBusData* data, s32 sampleLength, uptr userData );
#endif
    static const BiquadFilterLpf        BIQUAD_FILTER_LPF;
    static const BiquadFilterHpf        BIQUAD_FILTER_HPF;
    static const BiquadFilterBpf512     BIQUAD_FILTER_BPF_512;
    static const BiquadFilterBpf1024    BIQUAD_FILTER_BPF_1024;
    static const BiquadFilterBpf2048    BIQUAD_FILTER_BPF_2048;

    void FinalizeEffect( AuxBus bus );
    FxList& GetEffectList( AuxBus bus )
    {
        NW_MINMAXLT_ASSERT( bus, AUX_BUS_A, AUX_BUS_A + AUX_BUS_NUM );
        return m_FxList[ bus ];
    }

    bool                m_IsInitialized;

    OutputMode          m_OutputMode;
    SrcType             m_SrcType;

    MoveValue<f32,int>  m_MasterVolume;
    MoveValue<f32,int>  m_VolumeForReset;
    MoveValue<f32,int>  m_AuxFadeVolume[ AUX_BUS_NUM ];
    MoveValue<f32,int>  m_AuxUserVolume[ AUX_BUS_NUM ];
    FxList              m_FxList[ AUX_BUS_NUM ];
    AuxCallback         m_AuxCallback[ AUX_BUS_NUM ];    // Initialize 前の登録 CB

    const BiquadFilterCallback* m_BiquadFilterCallbackTable[BIQUAD_FILTER_TYPE_USER_MAX+1];

#ifdef NW_PLATFORM_CTRWIN
    void*               m_AuxCallbackContext[ AUX_BUS_NUM ];
    OSTick              m_EffectProcessTick[ AUX_BUS_NUM ];
#else
    uptr                m_AuxCallbackContext[ AUX_BUS_NUM ];
    nn::os::Tick        m_EffectProcessTick[ AUX_BUS_NUM ];
#endif

    // コールバック登録後、バッファがクリアになるまで待つ
    // (AUX_CALLBACK_WAIT_FRAME [=2] フレーム)
    u8 m_AuxCallbackWaitCounter[ AUX_BUS_NUM ];

#ifdef NW_PLATFORM_CTRWIN
public:
    struct CallbackListNode
    {
        ut::LinkListNode link;
        HardwareCallback callback;
    };

    typedef ut::LinkList< CallbackListNode, offsetof(CallbackListNode,link)> CallbackList;

//
// プラットフォーム固有のもの
//
public:
    static void AxCallbackFunc();
    static const int ZERO_BUFFER_SIZE = 256;

    // ------------------------------------------------------------------------
    // 定期的なコールバック設定 (3msec[等] ごとに呼ばれる)
    void RegisterCallback( CallbackListNode* node, HardwareCallback callback );
    void UnregisterCallback( CallbackListNode* node );

    void* GetZeroBufferAddress();

private:
    static void HardwareCallbackFunc();
    static void AiDmaCallbackFunc();    // for PrepareReset
    void PrepareResetProc();            // for PrepareReset

    CallbackList            m_CallbackList;

    AXUserCallback          m_PreRegisteredCallback;
    void*                   m_pZeroBufferAddress;
    AIDCallback             m_OldAidCallback;
    vs32                    m_ResetReadyCounter;
#endif // NW_PLATFORM_CTRWIN
    
};

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


#endif /* NW_SND_HARDWARE_MANAGER_H_ */