xref: /NW4C-1.3.3/sources/libraries/snd/snd_VoiceManager.cpp

/*---------------------------------------------------------------------------*
  Project:  NintendoWare
  File:     snd_VoiceManager.cpp

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

#include "precompiled.h"

#include <nw/snd/snd_VoiceManager.h>
#include <nw/snd/snd_DisposeCallbackManager.h>

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

/*---------------------------------------------------------------------------*
    Name:           GetInstance

    Description:    シングルトンのインスタンスを取得します

    Arguments:      なし

    Returns:        なし
 *---------------------------------------------------------------------------*/
VoiceManager& VoiceManager::GetInstance()
{
    static VoiceManager instance;
    return instance;
}


VoiceManager::VoiceManager()
: m_Initialized( false )
{
}

size_t VoiceManager::GetRequiredMemSize( int voiceCount )
{
    return sizeof( Voice ) * voiceCount;
}

void VoiceManager::Initialize( void* mem, size_t memSize )
{
    if ( m_Initialized ) return;

    int voiceCount = memSize / sizeof( Voice );

    u8* ptr = reinterpret_cast<u8*>( mem );
    // ボイスをリスト管理
    for ( int i = 0; i < voiceCount; i++ )
    {
        m_FreeVoiceList.PushBack( new( ptr )Voice() );
        ptr += sizeof( Voice );
    }
    NW_ASSERT( ptr <= reinterpret_cast<u8*>( mem ) + memSize );

    m_Initialized = true;
}

void VoiceManager::Finalize()
{
    if ( !m_Initialized ) return;

    StopAllVoices();

    // ボイスをリストから削除
    while ( ! m_FreeVoiceList.IsEmpty() )
    {
        Voice& voice = m_FreeVoiceList.GetFront();
        m_FreeVoiceList.PopFront();
        voice.~Voice(); // デストラクタ呼び出し
    }

    m_Initialized = false;
}

void VoiceManager::StopAllVoices()
{
    // 再生中のボイスを全てFree
    while ( ! m_PrioVoiceList.IsEmpty() )
    {
        Voice& voice = m_PrioVoiceList.GetFront();
        voice.Stop();
        if ( voice.m_Callback != NULL )
        {
            voice.m_Callback(
                &voice,
                Voice::CALLBACK_STATUS_CANCEL,
                voice.m_pCallbackData
            );
        }
        voice.Free();
    }
}

Voice* VoiceManager::AllocVoice(
    int voiceChannelCount,
    int priority,
    Voice::VoiceCallback callback,
    void* callbackData
)
{
    // ボイスが不足している場合にプライオリティが低いボイスを停止させる
    if ( m_FreeVoiceList.IsEmpty() )
    {
        if ( DropLowestPriorityVoice( priority ) == 0 ) return NULL;
    }

    // フリーリストから空きボイスを取得
    Voice& voice = m_FreeVoiceList.GetFront();

    if ( ! voice.Alloc( voiceChannelCount, priority, callback, callbackData ) )
    {
        return NULL;
    }

    // プライオリティを設定してボイスリストに追加
    voice.m_Priority = static_cast<u8>( priority );
    AppendVoiceList( &voice );

    return &voice;
}

void VoiceManager::FreeVoice( Voice* voice )
{
    NW_NULL_ASSERT( voice );

    RemoveVoiceList( voice );
}

void VoiceManager::UpdateAllVoices()
{
    // 波形の再生が完了したボイスを停止させる
    for ( VoiceList::Iterator itr = m_PrioVoiceList.GetBeginIter();
          itr != m_PrioVoiceList.GetEndIter();
        )
    {
        VoiceList::Iterator curItr = itr++;
        curItr->StopFinished();
    }

    // すべてのボイスのパラメータ計算
    for ( VoiceList::Iterator itr = m_PrioVoiceList.GetBeginIter();
          itr != m_PrioVoiceList.GetEndIter();
        )
    {
        VoiceList::Iterator curItr = itr++;
        curItr->Calc();
    }

    // すべてのボイスを更新
    for ( VoiceList::Iterator itr = m_PrioVoiceList.GetBeginIter();
          itr != m_PrioVoiceList.GetEndIter();
        )
    {
        VoiceList::Iterator curItr = itr++;
        curItr->Update();
    }
}

void VoiceManager::AppendVoiceList( Voice* voice )
{
    m_FreeVoiceList.Erase( voice );

    // プライオリティリストに挿入、同プライオリティは後着の音を後ろに繋ぐ
    // 逆順に探索したほうが、同プライオリティの場合に速い。
    VoiceList::ReverseIterator itr = m_PrioVoiceList.GetBeginReverseIter();
    while ( itr != m_PrioVoiceList.GetEndReverseIter() )
    {
        if ( itr->m_Priority <= voice->m_Priority )
        {
            break;
        }
        (void)++itr;
    }

    m_PrioVoiceList.Insert( itr.GetBase(), voice );
}
void VoiceManager::RemoveVoiceList( Voice* voice )
{
    m_PrioVoiceList.Erase( voice );
    m_FreeVoiceList.PushBack( voice );
}

void VoiceManager::ChangeVoicePriority( Voice* voice )
{
    RemoveVoiceList( voice );
    AppendVoiceList( voice );
    UpdateEachVoicePriority(
        m_PrioVoiceList.GetIteratorFromPointer( voice ),
        m_PrioVoiceList.GetEndIter()
    );
}

void VoiceManager::UpdateEachVoicePriority(
    const VoiceList::Iterator& beginItr,
    const VoiceList::Iterator& endItr
)
{
    // プライオリティリストの更新
    for ( VoiceList::Iterator itr = beginItr;
          itr != endItr;
          (void)++itr
        )
    {
        // RELEASEよりプライオリティが低いものは再設定しない。
        if ( itr->GetPriority() <= Voice::PRIORITY_RELEASE ) return;

        // NODROPは変更しない
        if ( itr->GetPriority() == Voice::PRIORITY_NODROP ) continue;

        itr->UpdateVoicesPriority();
    }
}

void VoiceManager::UpdateAllVoicesSync( u32 syncFlag )
{
    for ( VoiceList::Iterator itr = m_PrioVoiceList.GetBeginIter();
          itr != m_PrioVoiceList.GetEndIter();
        )
    {
        VoiceList::Iterator curItr = itr++;
        if ( curItr->m_IsActive ) curItr->m_SyncFlag |= syncFlag;
    }
}

int VoiceManager::DropLowestPriorityVoice( int priority )
{
    if ( m_PrioVoiceList.IsEmpty() ) return 0;

    Voice* dropVoice = &m_PrioVoiceList.GetFront();
    if ( dropVoice->GetPriority() > priority ) return 0;

    // もっとも優先度の低いボイスをDrop
    int dropCount = dropVoice->GetPhysicalVoiceCount();

    Voice::VoiceCallback callbackFunc = dropVoice->m_Callback;
    void* callbackData = dropVoice->m_pCallbackData;

    dropVoice->Stop();
    dropVoice->Free();

    if ( callbackFunc != NULL )
    {
        callbackFunc(
            dropVoice,
            Voice::CALLBACK_STATUS_DROP_VOICE,
            callbackData
        );
    }

    return dropCount;
}

int VoiceManager::GetVoiceCount() const
{
    SoundThreadLock lock;

    int voiceCount = 0;
    for (
        VoiceList::ConstIterator itr = m_PrioVoiceList.GetBeginIter();
        itr != m_PrioVoiceList.GetEndIter();
        (void)++itr
    )
    {
        voiceCount += itr->GetPhysicalVoiceCount();
    }

    return voiceCount;
}

unsigned long VoiceManager::GetActiveCount() const
{
    SoundThreadLock lock;

    return m_PrioVoiceList.GetSize();
}

unsigned long VoiceManager::GetFreeCount() const
{
    SoundThreadLock lock;

    return m_FreeVoiceList.GetSize();
}

const VoiceManager::VoiceList& VoiceManager::GetVoiceList() const
{
    return m_PrioVoiceList;
}

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