1 /*---------------------------------------------------------------------------*
2   Project:  NintendoWare
3   File:     snd_SoundArchivePlayer.cpp
4 
5   Copyright (C)2009-2010 Nintendo Co., Ltd./HAL Laboratory, Inc.  All rights reserved.
6 
7   These coded instructions, statements, and computer programs contain
8   proprietary information of Nintendo of America Inc. and/or Nintendo
9   Company Ltd., and are protected by Federal copyright law.  They may
10   not be disclosed to third parties or copied or duplicated in any form,
11   in whole or in part, without the prior written consent of Nintendo.
12 
13   $Revision: 27590 $
14  *---------------------------------------------------------------------------*/
15 
16 #include "precompiled.h"
17 
18 #include <nw/snd/snd_SoundArchivePlayer.h>
19 
20 #include <nw/snd/snd_SoundSystem.h>
21 #include <nw/snd/snd_SoundDataManager.h>
22 #include <nw/snd/snd_SoundPlayer.h>
23 #include <nw/snd/snd_SoundHandle.h>
24 #include <nw/snd/snd_SoundActor.h>
25 #include <nw/snd/snd_Bank.h>
26 #include <nw/snd/snd_SequenceSoundFileReader.h>
27 #include <nw/snd/snd_WaveSoundFileReader.h>
28 #include <nw/snd/snd_WaveArchiveFileReader.h>
29 #include <nw/snd/snd_WaveFileReader.h>
30 #include <nw/snd/snd_SoundArchiveLoader.h>
31 #include <nw/snd/snd_Debug.h>
32 #include <nw/snd/snd_Util.h>
33 #include <nw/snd/snd_PlayerHeap.h>
34 #include <nw/snd/snd_DriverCommandManager.h>
35 
36 namespace nw {
37 namespace snd {
38 
39 /*---------------------------------------------------------------------------*
40   Name:         SoundArchivePlayer
41 
42   Description:  コンストラクタ
43 
44   Arguments:    無し
45 
46   Returns:      無し
47  *---------------------------------------------------------------------------*/
SoundArchivePlayer()48 SoundArchivePlayer::SoundArchivePlayer()
49 : m_pSoundArchive( NULL ),
50   m_SequenceCallback( *this ),
51   m_WaveSoundCallback( *this ),
52   m_SequenceUserprocCallback( NULL ),
53   m_pSequenceUserprocCallbackArg( NULL ),
54   m_SoundPlayerCount( 0 ),
55   m_pSoundPlayers( NULL ),
56   m_MmlSequenceTrackAllocator( &m_MmlParser ),
57   m_pSetupBufferAddress( NULL ),
58   m_SetupBufferSize( 0 )
59 {
60 }
61 
62 /*---------------------------------------------------------------------------*
63   Name:         SoundArchivePlayer
64 
65   Description:  デストラクタ
66 
67   Arguments:    無し
68 
69   Returns:      無し
70  *---------------------------------------------------------------------------*/
~SoundArchivePlayer()71 SoundArchivePlayer::~SoundArchivePlayer()
72 {
73 }
74 
75 /*---------------------------------------------------------------------------*
76   Name:         IsAvailable
77 
78   Description:  サウンドアーカイブプレイヤーが利用可能かどうかを調べる
79 
80   Arguments:    無し
81 
82   Returns:      利用可能かどうかを返す
83  *---------------------------------------------------------------------------*/
IsAvailable() const84 bool SoundArchivePlayer::IsAvailable() const
85 {
86     if ( m_pSoundArchive == NULL ) return false;
87     if ( ! m_pSoundArchive->IsAvailable() ) return false;
88 
89     return true;
90 }
91 
92 /*---------------------------------------------------------------------------*
93   Name:         Initialize
94 
95   Description:  サウンドアーカイブ中のプレイヤー情報にしたがって
96                 プレイヤーをセットアップする
97 
98   Arguments:    arc - サウンドアーカイブ
99                 buffer - セットアップに使用するメモリ
100                 size - メモリサイズ
101                 aramBuffer - セットアップに使用するＡメモリ
102                 aramSize - メモリサイズ
103 
104   Returns:      セットアップに成功したらtrue
105  *---------------------------------------------------------------------------*/
Initialize(const SoundArchive * arc,const SoundDataManager * manager,void * buffer,u32 size,void * strmBuffer,u32 strmBufferSize)106 bool SoundArchivePlayer::Initialize(
107     const SoundArchive* arc,
108     const SoundDataManager* manager,
109     void*   buffer,
110     u32     size,
111     void*   strmBuffer,
112     u32     strmBufferSize
113 )
114 {
115     // サウンドシステムの初期化が必要
116     NW_ASSERT( SoundSystem::IsInitialized() );
117     if ( ! SoundSystem::IsInitialized() )
118     {
119         return false;
120     }
121 
122     NW_NULL_ASSERT( arc );
123     NW_NULL_ASSERT( manager );
124     NW_NULL_ASSERT( buffer );
125     NW_ALIGN32_ASSERT( buffer );
126 
127     if ( strmBufferSize > 0 ) {
128         NW_NULL_ASSERT( strmBuffer );
129         NW_ALIGN32_ASSERT( strmBuffer );
130 
131         if ( ! internal::Util::IsDeviceMemory(
132                     reinterpret_cast<uptr>(strmBuffer), strmBufferSize ) )
133         {
134             NW_ASSERTMSG( false,
135                     "strmBuffer, strmBuffer + strmBufferSize is not Device Memory.");
136             return false;
137         }
138     }
139     NW_ASSERT( strmBufferSize >= GetRequiredStreamBufferSize( arc ) );
140 
141     if ( ! SetupMram( arc, buffer, size ) ) {
142         return false;
143     }
144 
145     if ( ! SetupStreamBuffer( arc, strmBuffer, strmBufferSize ) ) {
146         return false;
147     }
148 
149     m_pSequenceTrackAllocator = &m_MmlSequenceTrackAllocator;
150     m_pSoundDataManager = manager;
151     return true;
152 }
153 
154 /*---------------------------------------------------------------------------*
155   Name:         Finalize
156 
157   Description:  サウンドアーカイブプレイヤーの機能を停止させる
158 
159   Arguments:    無し
160 
161   Returns:      無し
162  *---------------------------------------------------------------------------*/
Finalize()163 void SoundArchivePlayer::Finalize()
164 {
165     // 参照の破棄
166     m_pSoundArchive = NULL;
167     m_pSequenceTrackAllocator = NULL;
168 
169     // 全サウンドの停止
170     for ( SoundArchive::ItemId playerId = 0; playerId < m_SoundPlayerCount ; ++playerId )
171     {
172         m_pSoundPlayers[ playerId ].StopAllSound(0);
173     }
174 
175     // 停止完了待ち
176     internal::DriverCommandManager& cmdmgr = internal::DriverCommandManager::GetInstance();
177     u32 tag = cmdmgr.FlushCommand( true );
178     cmdmgr.WaitCommandReply( tag );
179 
180     // インスタンスの破棄
181     m_SoundPlayerCount = 0;
182     m_pSoundPlayers = NULL;
183 
184     m_StreamBufferPool.Finalize();
185 
186     if ( m_pSetupBufferAddress != NULL )
187     {
188         m_SequenceSoundInstanceManager.Destroy( m_pSetupBufferAddress, m_SetupBufferSize );
189         m_MmlSequenceTrackAllocator.Destroy( m_pSetupBufferAddress, m_SetupBufferSize );
190         m_WaveSoundInstanceManager.Destroy( m_pSetupBufferAddress, m_SetupBufferSize );
191         m_StreamSoundInstanceManager.Destroy( m_pSetupBufferAddress, m_SetupBufferSize );
192 
193         m_pSetupBufferAddress = NULL;
194         m_SetupBufferSize = 0;
195     }
196 }
197 
198 
199 /*---------------------------------------------------------------------------*
200   Name:         GetRequiredMemSize
201 
202   Description:  サウンドアーカイブプレイヤーで使用するメモリサイズを取得する
203 
204   Arguments:    arc - サウンドアーカイブ
205 
206   Returns:      無し
207  *---------------------------------------------------------------------------*/
GetRequiredMemSize(const SoundArchive * arc)208 size_t SoundArchivePlayer::GetRequiredMemSize( const SoundArchive* arc )
209 {
210     NW_NULL_ASSERT( arc );
211 
212     size_t size = 0;
213 
214     // SoundPlayer
215     {
216         u32 playerCount = arc->GetPlayerCount();
217         size += ut::RoundUp( playerCount * sizeof( SoundPlayer ), 4 );
218 
219         for ( u32 playerIndex = 0; playerIndex < playerCount; ++playerIndex )
220         {
221             SoundArchive::PlayerInfo playerInfo;
222             if ( ! arc->ReadPlayerInfo( internal::Util::GetMaskedItemId(
223                             playerIndex, internal::ItemType_Player ), &playerInfo ) )
224             {
225                 continue;
226             }
227 
228             if ( playerInfo.playerHeapSize > 0 )
229             {
230                 for ( int i = 0; i < playerInfo.playableSoundMax ; i++ )
231                 {
232                     size += ut::RoundUp( sizeof(internal::PlayerHeap), 4 );
233                     size = ut::RoundUp( size, 32 );
234                     size += ut::RoundUp( playerInfo.playerHeapSize, 4 );
235                 }
236             }
237         }
238     }
239 
240     SoundArchive::SoundArchivePlayerInfo soundArchivePlayerInfo;
241     if ( arc->ReadSoundArchivePlayerInfo( &soundArchivePlayerInfo ) )
242     {
243         // SequenceSound
244         size += ut::RoundUp(
245             m_SequenceSoundInstanceManager.GetRequiredMemSize(soundArchivePlayerInfo.sequenceSoundMax), 4 );
246 
247         // WaveSound
248         size += ut::RoundUp(
249             m_WaveSoundInstanceManager.GetRequiredMemSize(soundArchivePlayerInfo.waveSoundMax), 4 );
250 
251         // StreamSound
252         size += ut::RoundUp(
253             m_StreamSoundInstanceManager.GetRequiredMemSize(soundArchivePlayerInfo.streamSoundMax), 4 );
254 
255         // SequenceTrack
256         size += ut::RoundUp(
257                 soundArchivePlayerInfo.sequenceTrackMax *
258                 sizeof( internal::driver::MmlSequenceTrack ), 4 );
259 
260     }
261 
262     return size;
263 }
264 
265 /*---------------------------------------------------------------------------*
266   Name:         GetRequiredStreamBufferSize
267 
268   Description:  サウンドアーカイブプレイヤーで使用するＡメモリサイズを取得する
269 
270   Arguments:    arc - サウンドアーカイブ
271 
272   Returns:      無し
273  *---------------------------------------------------------------------------*/
GetRequiredStreamBufferSize(const nw::snd::SoundArchive * arc)274 size_t SoundArchivePlayer::GetRequiredStreamBufferSize(
275         const nw::snd::SoundArchive* arc )
276 {
277     NW_NULL_ASSERT( arc );
278 
279     int strmChannelCount = 0;
280 
281     SoundArchive::SoundArchivePlayerInfo soundArchivePlayerInfo;
282     if ( arc->ReadSoundArchivePlayerInfo( &soundArchivePlayerInfo ) )
283     {
284         strmChannelCount = soundArchivePlayerInfo.streamChannelMax;
285     }
286 
287     size_t memSize = static_cast<size_t>(
288         internal::driver::StreamSoundPlayer::DATA_BLOCK_SIZE_MAX
289         * DEFAULT_STREAM_BLOCK_COUNT
290         * strmChannelCount
291     );
292     return memSize;
293 }
294 
295 /*---------------------------------------------------------------------------*
296   Name:         SetupMram
297 
298   Description:  サウンドアーカイブ中のプレイヤー情報にしたがって
299                 プレイヤーをセットアップする
300 
301   Arguments:    arc - サウンドアーカイブ
302                 buffer - セットアップに使用するメモリ
303                 size - メモリサイズ
304 
305   Returns:      セットアップに成功したらtrue
306  *---------------------------------------------------------------------------*/
SetupMram(const SoundArchive * arc,void * buffer,unsigned long size)307 bool SoundArchivePlayer::SetupMram( const SoundArchive* arc, void* buffer, unsigned long size )
308 {
309     NW_ASSERT( size >= GetRequiredMemSize( arc ) );
310 
311     void* endp = static_cast<char*>(buffer) + size;
312 
313     void* buf = buffer;
314     if ( ! SetupSoundPlayer( arc, &buf, endp ) )
315     {
316         return false;
317     }
318 
319     SoundArchive::SoundArchivePlayerInfo soundArchivePlayerInfo;
320     if ( arc->ReadSoundArchivePlayerInfo( &soundArchivePlayerInfo ) )
321     {
322         if ( ! SetupSequenceSound( arc, soundArchivePlayerInfo.sequenceSoundMax, &buf, endp ) )
323         {
324             return false;
325         }
326 
327         if ( ! SetupWaveSound( arc, soundArchivePlayerInfo.waveSoundMax, &buf, endp ) )
328         {
329             return false;
330         }
331 
332         if ( ! SetupStreamSound( arc, soundArchivePlayerInfo.streamSoundMax, &buf, endp ) )
333         {
334             return false;
335         }
336 
337         if ( ! SetupSequenceTrack( arc, soundArchivePlayerInfo.sequenceTrackMax, &buf, endp ) )
338         {
339             return false;
340         }
341     }
342 
343     NW_ASSERT(
344             static_cast<char*>(buf) - static_cast<char*>(buffer) ==
345             static_cast<s32>( GetRequiredMemSize( arc ) ) );
346 
347     m_pSoundArchive = arc;
348     m_pSetupBufferAddress = buffer;
349     m_SetupBufferSize = size;
350 
351     return true;
352 }
353 
354 /*---------------------------------------------------------------------------*
355   Name:         CreatePlayerHeap
356 
357   Description:  プレイヤーヒープの作成
358 
359   Arguments:    heap - サウンドヒープ
360                 size - プレイヤーヒープサイズ
361 
362   Returns:      作成したプレイヤーヒープへのポインタ
363  *---------------------------------------------------------------------------*/
CreatePlayerHeap(void ** buffer,void * endp,size_t heapSize)364 internal::PlayerHeap* SoundArchivePlayer::CreatePlayerHeap(
365     void** buffer,
366     void* endp,
367     size_t heapSize
368 )
369 {
370     // プレイヤーヒープ構造体初期化
371     void* ep = ut::RoundUp( ut::AddOffsetToPtr( *buffer, sizeof(internal::PlayerHeap) ), 4 );
372     if ( ut::ComparePtr( ep, endp ) > 0 )
373     {
374         return NULL;
375     }
376     void* buf = *buffer;
377     *buffer = ep;
378 
379     internal::PlayerHeap* playerHeap = new ( buf ) internal::PlayerHeap();
380 
381     // プレイヤーヒープ構築
382     *buffer = ut::RoundUp( *buffer, 32 );
383     ep = ut::RoundUp( ut::AddOffsetToPtr( *buffer, heapSize ), 4 );
384     if ( ut::ComparePtr( ep, endp ) > 0 )
385     {
386         return NULL;
387     }
388     buf = *buffer;
389     *buffer = ep;
390 
391     bool result = playerHeap->Create( buf, heapSize );
392 
393     if ( ! result )
394     {
395         return NULL;
396     }
397 
398     return playerHeap;
399 }
400 
SetupSoundPlayer(const SoundArchive * arc,void ** buffer,void * endp)401 bool SoundArchivePlayer::SetupSoundPlayer(
402     const SoundArchive* arc,
403     void** buffer,
404     void* endp
405 )
406 {
407     u32 playerCount = arc->GetPlayerCount();
408     size_t requireSize = playerCount * sizeof( SoundPlayer );
409 
410     void* ep = ut::RoundUp( ut::AddOffsetToPtr( *buffer, requireSize ), 4 );
411     if ( ut::ComparePtr( ep, endp ) > 0 )
412     {
413         return false;
414     }
415     void* buf = *buffer;
416     *buffer = ep;
417 
418     // buf 上に SoundPlayer インスタンスを playerCount 個並べる
419     m_pSoundPlayers = reinterpret_cast<SoundPlayer*>( buf );
420     m_SoundPlayerCount = playerCount;
421 
422     u8* ptr = static_cast<u8*>( buf );
423     for ( u32 playerIndex = 0; playerIndex < playerCount;
424             ++playerIndex, ptr += sizeof( SoundPlayer ) )
425     {
426         SoundPlayer* player = new ( ptr ) SoundPlayer();
427 
428         SoundArchive::PlayerInfo playerInfo;
429         if ( ! arc->ReadPlayerInfo( internal::Util::GetMaskedItemId(
430                         playerIndex, internal::ItemType_Player ), &playerInfo ) )
431         {
432             continue;
433         }
434 
435         player->SetPlayableSoundCount( playerInfo.playableSoundMax );
436 
437         // プレイヤーヒープのセットアップ
438         if ( playerInfo.playerHeapSize > 0 )
439         {
440             for ( int i = 0; i < playerInfo.playableSoundMax ; i++ )
441             {
442                 internal::PlayerHeap* playerHeap = CreatePlayerHeap(
443                         buffer, endp, playerInfo.playerHeapSize );
444 
445                 NW_WARNING( playerHeap != NULL,
446                         "failed to create player heap. ( player id = %d )", playerIndex );
447                 if ( playerHeap == NULL )
448                 {
449                     return false;
450                 }
451                 player->detail_AppendPlayerHeap( playerHeap );
452             }
453 
454             // プレイヤーヒープを使用する場合、
455             // 用意されたプレイヤーヒープ数を超える同時再生数は指定できない
456             player->detail_SetPlayableSoundLimit( playerInfo.playableSoundMax );
457         }
458     }
459 
460     return true;
461 }
462 
463 /*---------------------------------------------------------------------------*
464   Name:         SetupSequenceSound
465 
466   Description:  シーケンスサウンドのセットアップ
467 
468   Arguments:    numSounds - 確保するシーケンスサウンドの数
469                 heap      - サウンドヒープ
470 
471   Returns:      成功したかどうか
472  *---------------------------------------------------------------------------*/
SetupSequenceSound(const SoundArchive *,int numSounds,void ** buffer,void * endp)473 bool SoundArchivePlayer::SetupSequenceSound(
474     const SoundArchive* /*arc*/,
475     int numSounds,
476     void** buffer,
477     void* endp
478 )
479 {
480     size_t requireSize = m_SequenceSoundInstanceManager.GetRequiredMemSize(numSounds);
481 
482     void* ep = ut::RoundUp( ut::AddOffsetToPtr( *buffer, requireSize ), 4 );
483     if ( ut::ComparePtr( ep, endp ) > 0 )
484     {
485         return false;
486     }
487 
488     unsigned long createNum = m_SequenceSoundInstanceManager.Create( *buffer, requireSize );
489     NW_ASSERT( createNum == numSounds );
490     *buffer = ep;
491 
492     return true;
493 }
494 
495 /*---------------------------------------------------------------------------*
496   Name:         SetupWaveSound
497 
498   Description:  ウェーブサウンドのセットアップ
499 
500   Arguments:    numSounds - 確保するウェーブサウンドの数
501                 heap      - サウンドヒープ
502 
503   Returns:      成功したかどうか
504  *---------------------------------------------------------------------------*/
SetupWaveSound(const SoundArchive *,int numSounds,void ** buffer,void * endp)505 bool SoundArchivePlayer::SetupWaveSound(
506     const SoundArchive* /*arc*/,
507     int numSounds,
508     void** buffer,
509     void* endp
510 )
511 {
512     size_t requireSize = m_WaveSoundInstanceManager.GetRequiredMemSize(numSounds);
513 
514     void* ep = ut::RoundUp( ut::AddOffsetToPtr( *buffer, requireSize ), 4 );
515     if ( ut::ComparePtr( ep, endp ) > 0 )
516     {
517         return false;
518     }
519 
520     unsigned long createNum = m_WaveSoundInstanceManager.Create( *buffer, requireSize );
521     NW_ASSERT( createNum == numSounds );
522     *buffer = ep;
523 
524     return true;
525 }
526 
527 /*---------------------------------------------------------------------------*
528   Name:         SetupStreamSound
529 
530   Description:  ストリームサウンドのセットアップ
531 
532   Arguments:    numSounds - 確保するストリームサウンドの数
533                 heap      - サウンドヒープ
534 
535   Returns:      成功したかどうか
536  *---------------------------------------------------------------------------*/
SetupStreamSound(const SoundArchive *,int numSounds,void ** buffer,void * endp)537 bool SoundArchivePlayer::SetupStreamSound(
538     const SoundArchive* /*arc*/,
539     int numSounds,
540     void** buffer,
541     void* endp
542 )
543 {
544     size_t requireSize = m_StreamSoundInstanceManager.GetRequiredMemSize(numSounds);
545 
546     void* ep = ut::RoundUp( ut::AddOffsetToPtr( *buffer, requireSize ), 4 );
547     if ( ut::ComparePtr( ep, endp ) > 0 )
548     {
549         return false;
550     }
551 
552     unsigned long createNum = m_StreamSoundInstanceManager.Create( *buffer, requireSize );
553     NW_ASSERT( createNum == numSounds );
554     *buffer = ep;
555 
556     return true;
557 }
558 
559 /*---------------------------------------------------------------------------*
560   Name:         SetupSequenceTrack
561 
562   Description:  シーケンスサウンドのセットアップ
563 
564   Arguments:    numSounds - 確保するシーケンスサウンドの数
565                 heap      - サウンドヒープ
566 
567   Returns:      成功したかどうか
568  *---------------------------------------------------------------------------*/
SetupSequenceTrack(const SoundArchive *,int numTracks,void ** buffer,void * endp)569 bool SoundArchivePlayer::SetupSequenceTrack(
570     const SoundArchive* /*arc*/,
571     int numTracks,
572     void** buffer,
573     void* endp
574 )
575 {
576     unsigned long requireSize = numTracks * sizeof( internal::driver::MmlSequenceTrack );
577 
578     void* ep = ut::RoundUp( ut::AddOffsetToPtr( *buffer, requireSize ), 4 );
579     if ( ut::ComparePtr( ep, endp ) > 0 )
580     {
581         return false;
582     }
583 
584     unsigned long createNum = m_MmlSequenceTrackAllocator.Create( *buffer, requireSize );
585     NW_ASSERT( createNum == numTracks );
586     *buffer = ep;
587 
588     return true;
589 }
590 
591 /*---------------------------------------------------------------------------*
592   Name:         SetupStreamBuffer
593 
594   Description:  ストリームチャンネルのセットアップ
595 
596   Arguments:    heap      - サウンドヒープ
597 
598   Returns:      成功したかどうか
599  *---------------------------------------------------------------------------*/
SetupStreamBuffer(const SoundArchive * arc,void * buffer,unsigned long size)600 bool SoundArchivePlayer::SetupStreamBuffer(
601     const SoundArchive* arc,
602     void* buffer,
603     unsigned long size
604 )
605 {
606     if ( size < GetRequiredStreamBufferSize( arc ) ) return false;
607 
608     int strmChannelCount = 0;
609 
610     SoundArchive::SoundArchivePlayerInfo soundArchivePlayerInfo;
611     if ( arc->ReadSoundArchivePlayerInfo( &soundArchivePlayerInfo ) )
612     {
613         strmChannelCount = soundArchivePlayerInfo.streamChannelMax;
614     }
615 
616     m_StreamBufferPool.Initialize( buffer, size, strmChannelCount );
617 
618     return true;
619 }
620 
621 /*---------------------------------------------------------------------------*
622   Name:         Update
623 
624   Description:  プレイヤーのフレーム処理を更新する
625 
626   Arguments:    None.
627 
628   Returns:      None.
629  *---------------------------------------------------------------------------*/
Update()630 void SoundArchivePlayer::Update()
631 {
632     for ( u32 playerIndex = 0;
633             playerIndex < m_SoundPlayerCount; ++playerIndex )
634     {
635         GetSoundPlayer( internal::Util::GetMaskedItemId(
636                     playerIndex, internal::ItemType_Player ) ).Update();
637     }
638 
639     m_SequenceSoundInstanceManager.SortPriorityList();
640     m_WaveSoundInstanceManager.SortPriorityList();
641     m_StreamSoundInstanceManager.SortPriorityList();
642 
643     internal::DriverCommandManager& cmdmgr = internal::DriverCommandManager::GetInstance();
644     cmdmgr.RecvCommandReply();
645     cmdmgr.FlushCommand( false );
646 }
647 
GetSoundArchive() const648 const SoundArchive& SoundArchivePlayer::GetSoundArchive() const
649 {
650     NW_ASSERTMSG( m_pSoundArchive != NULL, "Setup is not completed." );
651     return *m_pSoundArchive;
652 }
653 
GetSoundPlayer(SoundArchive::ItemId playerId)654 SoundPlayer& SoundArchivePlayer::GetSoundPlayer( SoundArchive::ItemId playerId )
655 {
656     u32 itemIndex = internal::Util::GetItemIndex( playerId );
657     NW_MINMAXLT_ASSERT( itemIndex, 0, m_SoundPlayerCount );
658     return m_pSoundPlayers[ itemIndex ];
659 }
660 
GetSoundPlayer(const char * pStr)661 SoundPlayer& SoundArchivePlayer::GetSoundPlayer( const char* pStr )
662 {
663     NW_NULL_ASSERT( m_pSoundArchive );
664 
665     SoundArchive::ItemId playerId = m_pSoundArchive->GetItemId( pStr );
666     NW_ASSERT( playerId != SoundArchive::INVALID_ID );
667     return GetSoundPlayer( playerId );
668 }
669 
670 
671 /*---------------------------------------------------------------------------*
672   Name:         AllocSound
673 
674   Description:  サウンドを取得する
675 
676   Arguments:    manager - サウンドインスタンスマネージャ
677                 soundId - サウンドID
678                 priority - プレイヤープライオリティ
679                 ambientPriority - アンビエントプライオリティ
680                 ambientArgInfo - アンビエント情報
681 
682   Returns:      サウンドへのポインタ。取得できなかったらNULL
683  *---------------------------------------------------------------------------*/
684 template< typename Sound, typename Player >
AllocSound(internal::SoundInstanceManager<Sound,Player> * manager,SoundArchive::ItemId soundId,int priority,int ambientPriority,internal::BasicSound::AmbientInfo * ambientArgInfo)685 Sound* SoundArchivePlayer::AllocSound(
686     internal::SoundInstanceManager< Sound,Player >* manager,
687     SoundArchive::ItemId soundId,
688     int priority,
689     int ambientPriority,
690     internal::BasicSound::AmbientInfo* ambientArgInfo
691 )
692 {
693     NW_NULL_ASSERT( manager );
694 
695     // サウンドの確保
696     Sound* sound = manager->Alloc( priority, ambientPriority );
697     if ( sound == NULL ) return NULL;
698 
699     // ID設定
700     sound->SetId( soundId );
701 
702     // アンビエント設定
703     if ( ambientArgInfo != NULL )
704     {
705         sound->SetAmbientInfo( *ambientArgInfo );
706     }
707 
708     return sound;
709 }
710 
711 const void*
detail_GetFileAddress(SoundArchive::FileId fileId) const712 SoundArchivePlayer::detail_GetFileAddress( SoundArchive::FileId fileId ) const
713 {
714     if ( m_pSoundDataManager == NULL ) return NULL;
715 
716     return m_pSoundDataManager->detail_GetFileAddress( fileId );
717 }
718 
detail_SetupSound(SoundHandle * handle,u32 soundId,bool holdFlag,const StartInfo * startInfo)719 SoundStartable::StartResult SoundArchivePlayer::detail_SetupSound(
720     SoundHandle* handle,
721     u32 soundId,
722     bool holdFlag,
723     const StartInfo* startInfo
724 )
725 {
726     return detail_SetupSoundImpl(
727         handle,
728         soundId,
729         NULL,
730         NULL,
731         holdFlag,
732         startInfo
733     );
734 }
735 
736 /*---------------------------------------------------------------------------*
737   Name:         detail_SetupSoundImpl
738 
739   Description:  再生の実装関数
740 
741   Arguments:    handle  - サウンドハンドル
742                 soundId - サウンドＩＤ
743                 ambientArgInfo - 外部パラメータ
744                 actor - サウンドアクター
745                 holdFlag - ホールドサウンドフラグ
746 
747   Returns:      結果コード
748  *---------------------------------------------------------------------------*/
detail_SetupSoundImpl(SoundHandle * handle,u32 soundId,internal::BasicSound::AmbientInfo * ambientArgInfo,SoundActor * actor,bool holdFlag,const StartInfo * startInfo)749 SoundStartable::StartResult SoundArchivePlayer::detail_SetupSoundImpl(
750     SoundHandle* handle,
751     u32 soundId,
752     internal::BasicSound::AmbientInfo* ambientArgInfo,
753     SoundActor* actor,
754     bool holdFlag,
755     const StartInfo* startInfo
756 )
757 {
758     NW_NULL_ASSERT( handle );
759 
760     if ( ! IsAvailable() )
761     {
762         SoundStartable::StartResult
763             result( SoundStartable::StartResult::START_ERR_NOT_AVAILABLE );
764         return result;
765     }
766 
767     // サウンドハンドルを古いサウンドから切断
768     if ( handle->IsAttachedSound() ) {
769         handle->DetachSound();
770     }
771 
772     // サウンドアーカイブからサウンド情報の取得
773     SoundArchive::SoundInfo soundInfo;
774     if ( ! m_pSoundArchive->ReadSoundInfo( soundId, &soundInfo ) )
775     {
776         SoundStartable::StartResult
777             result( SoundStartable::StartResult::START_ERR_INVALID_SOUNDID );
778         return result;
779     }
780 
781     // StartInfoの処理
782     SoundStartable::StartInfo::StartOffsetType startOffsetType =
783         SoundStartable::StartInfo::START_OFFSET_TYPE_MILLISEC;
784     int startOffset = 0;
785     int playerPriority = soundInfo.playerPriority;
786     SoundArchive::ItemId playerId = soundInfo.playerId;
787     int actorPlayerId = soundInfo.actorPlayerId;
788     const SoundStartable::StartInfo::SeqSoundInfo* seqInfo = NULL;
789     if ( startInfo != NULL )
790     {
791         if ( startInfo->enableFlag & StartInfo::ENABLE_START_OFFSET )
792         {
793             startOffsetType = startInfo->startOffsetType;
794             startOffset = startInfo->startOffset;
795         }
796         if ( startInfo->enableFlag & StartInfo::ENABLE_PLAYER_PRIORITY )
797         {
798             playerPriority = startInfo->playerPriority;
799         }
800         if ( startInfo->enableFlag & StartInfo::ENABLE_PLAYER_ID )
801         {
802             playerId = startInfo->playerId;
803         }
804         if ( startInfo->enableFlag & StartInfo::ENABLE_ACTOR_PLAYER_ID )
805         {
806             actorPlayerId = startInfo->actorPlayerId;
807         }
808         if ( startInfo->enableFlag & StartInfo::ENABLE_SEQ_SOUND_INFO )
809         {
810             seqInfo = &startInfo->seqSoundInfo;
811         }
812     }
813 
814     // プライオリティの計算
815     int priority = playerPriority;
816     if ( holdFlag ) --priority; // HoldSoundで再生するときは同プライオリティで先着優先
817 
818     int ambientPriority = 0;
819     if ( ambientArgInfo != NULL )
820     {
821         ambientPriority = internal::BasicSound::GetAmbientPriority( *ambientArgInfo, soundId );
822     }
823     int allocPriority = priority + ambientPriority;
824     allocPriority = ut::Clamp( allocPriority, internal::BasicSound::PRIORITY_MIN, internal::BasicSound::PRIORITY_MAX );
825 
826     // ExternalSoundPlayer
827     internal::ExternalSoundPlayer* extPlayer = NULL;
828     if ( actor != NULL ) {
829         extPlayer = actor->detail_GetActorPlayer( actorPlayerId );
830         if ( extPlayer == NULL )
831         {
832             NW_WARNING(
833                 false,
834                 "actorPlayerId(%d) is out of range. (0-%d)",
835                 actorPlayerId,
836                 SoundActor::ACTOR_PLAYER_COUNT-1
837             );
838             return StartResult::START_ERR_INVALID_PARAMETER;
839         }
840     }
841 
842     // プレイヤーの空きをチェック
843     SoundPlayer& player = GetSoundPlayer( playerId );
844     if ( ! player.detail_CanPlaySound( allocPriority ) ) {
845         return StartResult::START_ERR_LOW_PRIORITY;
846     }
847     if ( ( extPlayer != NULL ) && ( ! extPlayer->detail_CanPlaySound( allocPriority ) ) ) {
848         return StartResult::START_ERR_LOW_PRIORITY;
849     }
850 
851     // サウンドのアロケート
852     internal::BasicSound* sound = NULL;
853     internal::SequenceSound* seqSound = NULL;
854     internal::StreamSound* strmSound = NULL;
855     internal::WaveSound* waveSound = NULL;
856 
857     switch ( m_pSoundArchive->GetSoundType( soundId ) )
858     {
859     case SoundArchive::SOUND_TYPE_SEQ:
860         seqSound = AllocSound<internal::SequenceSound>(
861             &m_SequenceSoundInstanceManager,
862             soundId,
863             priority,
864             ambientPriority,
865             ambientArgInfo
866         );
867         if ( seqSound == NULL )
868         {
869             NW_WARNING(
870                 ! internal::Debug_GetWarningFlag( DEBUG_WARNING_NOT_ENOUGH_SEQSOUND ),
871                 "Failed to start sound (id:%d) for not enough SequenceSound instance.",
872                 soundId
873             );
874             SoundStartable::StartResult
875                 result( SoundStartable::StartResult::START_ERR_NOT_ENOUGH_INSTANCE );
876             return result;
877         }
878         sound = seqSound;
879         break;
880 
881     case SoundArchive::SOUND_TYPE_STRM:
882         strmSound = AllocSound<internal::StreamSound>(
883             &m_StreamSoundInstanceManager,
884             soundId,
885             priority,
886             ambientPriority,
887             ambientArgInfo
888         );
889         if ( strmSound == NULL )
890         {
891             NW_WARNING(
892                 ! internal::Debug_GetWarningFlag( DEBUG_WARNING_NOT_ENOUGH_STRMSOUND ),
893                 "Failed to start sound (id:%d) for not enough StreamSound instance.",
894                 soundId
895             );
896             SoundStartable::StartResult
897                 result( SoundStartable::StartResult::START_ERR_NOT_ENOUGH_INSTANCE );
898             return result;
899         }
900         sound = strmSound;
901         break;
902 
903     case SoundArchive::SOUND_TYPE_WAVE:
904         waveSound = AllocSound<internal::WaveSound>(
905             &m_WaveSoundInstanceManager,
906             soundId,
907             priority,
908             ambientPriority,
909             ambientArgInfo
910         );
911         if ( waveSound == NULL )
912         {
913             NW_WARNING(
914                 ! internal::Debug_GetWarningFlag( DEBUG_WARNING_NOT_ENOUGH_WAVESOUND ),
915                 "Failed to start sound (id:%d) for not enough WaveSound instance.",
916                 soundId
917             );
918             SoundStartable::StartResult
919                 result( SoundStartable::StartResult::START_ERR_NOT_ENOUGH_INSTANCE );
920             return result;
921         }
922         sound = waveSound;
923         break;
924 
925     default:
926         {
927             SoundStartable::StartResult
928                 result( SoundStartable::StartResult::START_ERR_INVALID_SOUNDID );
929             return result;
930         }
931     }
932 
933     // サウンドプレイヤーに登録
934     if ( ! player.detail_AppendSound( sound ) )
935     {
936         sound->Finalize();
937         SoundStartable::StartResult
938             result( SoundStartable::StartResult::START_ERR_UNKNOWN );
939         return result;
940     }
941 
942     // フロントバイパス設定
943     sound->SetFrontBypass( soundInfo.isFrontBypass );
944 
945     // サウンドのプリペア
946     switch ( m_pSoundArchive->GetSoundType( soundId ) )
947     {
948     case SoundArchive::SOUND_TYPE_SEQ:
949     {
950         NW_NULL_ASSERT( seqSound );
951 
952         // プレイヤーヒープの確保
953         (void)player.detail_AllocPlayerHeap( seqSound );
954 
955         // シーケンスサウンド情報の取得
956         SoundArchive::SequenceSoundInfo info;
957         if ( ! m_pSoundArchive->ReadSequenceSoundInfo( soundId, &info ) ) {
958             seqSound->Finalize();
959             SoundStartable::StartResult
960                 result( SoundStartable::StartResult::START_ERR_INVALID_SOUNDID );
961             return result;
962         }
963 
964         // バンクの上書き (必要であれば)
965         if ( seqInfo != NULL )
966         {
967             for ( int i = 0; i < SoundArchive::SEQ_BANK_MAX; i++ )
968             {
969                 SoundArchive::ItemId bankId = seqInfo->bankIds[ i ];
970                 if ( bankId != SoundArchive::INVALID_ID )
971                 {
972                     info.bankIds[ i ] = seqInfo->bankIds[ i ];
973                 }
974             }
975         }
976 
977         // シーケンスサウンドの準備
978         StartResult result = PrepareSeqImpl(
979             seqSound,
980             &soundInfo,
981             &info,
982             startOffsetType,
983             startOffset,
984             seqInfo
985         );
986         if ( ! result.IsSuccess() )
987         {
988             seqSound->Finalize();
989             return result;
990         }
991         break;
992     }
993 
994     case SoundArchive::SOUND_TYPE_STRM:
995     {
996         NW_NULL_ASSERT( strmSound );
997 
998         // ストリームサウンド情報の取得
999         SoundArchive::StreamSoundInfo info;
1000         if ( ! m_pSoundArchive->detail_ReadStreamSoundInfo( soundId, &info ) ) {
1001             strmSound->Finalize();
1002             SoundStartable::StartResult
1003                 result( SoundStartable::StartResult::START_ERR_INVALID_SOUNDID );
1004             return result;
1005         }
1006 
1007         // ストリームサウンドの準備
1008         StartResult result = PrepareStreamImpl(
1009             strmSound,
1010             &soundInfo,
1011             &info,
1012             startOffsetType,
1013             startOffset
1014         );
1015         if ( ! result.IsSuccess() )
1016         {
1017             strmSound->Finalize();
1018             return result;
1019         }
1020         break;
1021     }
1022 
1023     case SoundArchive::SOUND_TYPE_WAVE:
1024     {
1025         NW_NULL_ASSERT( waveSound );
1026 
1027         // ウェーブサウンド情報の取得
1028         SoundArchive::WaveSoundInfo info;
1029         if ( ! m_pSoundArchive->detail_ReadWaveSoundInfo( soundId, &info ) ) {
1030             waveSound->Finalize();
1031             SoundStartable::StartResult
1032                 result( SoundStartable::StartResult::START_ERR_INVALID_SOUNDID );
1033             return result;
1034         }
1035 
1036         // ウェーブサウンドの準備
1037         StartResult result = PrepareWaveSoundImpl(
1038             waveSound,
1039             &soundInfo,
1040             &info,
1041             startOffsetType,
1042             startOffset
1043         );
1044         if ( ! result.IsSuccess() )
1045         {
1046             waveSound->Finalize();
1047             return result;
1048         }
1049         break;
1050     }
1051 
1052     default:
1053         NW_ASSERT( false );
1054         sound->Finalize();
1055         {
1056             return StartResult::START_ERR_INVALID_SOUNDID;
1057         }
1058     }
1059 
1060     // 外部プレイヤーに登録
1061     if ( extPlayer != NULL )
1062     {
1063         if ( ! extPlayer->AppendSound( sound ) )
1064         {
1065             sound->Finalize();
1066             return StartResult::START_ERR_UNKNOWN;
1067         }
1068     }
1069 
1070     // アクターに登録
1071     if ( actor != NULL )
1072     {
1073         sound->AttachSoundActor( actor );
1074     }
1075 
1076     // プライオリティの再設定
1077     if ( holdFlag )
1078     {
1079         sound->SetPlayerPriority( playerPriority );
1080     }
1081 
1082     // サウンドハンドルを確保したサウンドと接続
1083     handle->detail_AttachSound( sound );
1084 
1085     SoundStartable::StartResult
1086         result( SoundStartable::StartResult::START_SUCCESS );
1087     return result;
1088 }
1089 
1090 /*---------------------------------------------------------------------------*
1091   Name:         PrepareSeqImpl
1092 
1093   Description:  シーケンスを再生
1094 
1095   Arguments:    playerId   - プレイヤー番号
1096                 playerPrio - プレイヤープライオリティ
1097                 info       - シーケンス情報構造体のポインタ
1098                 seqId      - シーケンス番号
1099 
1100   Returns:      成功したかどうか
1101  *---------------------------------------------------------------------------*/
PrepareSeqImpl(internal::SequenceSound * sound,const SoundArchive::SoundInfo * commonInfo,const SoundArchive::SequenceSoundInfo * info,SoundStartable::StartInfo::StartOffsetType startOffsetType,int startOffset,const StartInfo::SeqSoundInfo * externalSeqInfo)1102 SoundStartable::StartResult SoundArchivePlayer::PrepareSeqImpl(
1103     internal::SequenceSound* sound,
1104     const SoundArchive::SoundInfo* commonInfo,
1105     const SoundArchive::SequenceSoundInfo* info,
1106     SoundStartable::StartInfo::StartOffsetType startOffsetType,
1107     int startOffset,
1108     const StartInfo::SeqSoundInfo* externalSeqInfo
1109 )
1110 {
1111     NW_NULL_ASSERT( info );
1112 
1113     const internal::SequenceSoundFile* seqFile = NULL;
1114     io::FileStream* fileStream = NULL;
1115 
1116     u32 seqOffset = 0;
1117     u32 allocTrack = info->allocateTrackFlags;
1118 
1119     if ( externalSeqInfo != NULL )
1120     {
1121         if ( externalSeqInfo->seqDataAddress != NULL )
1122         {
1123             seqFile = reinterpret_cast<const internal::SequenceSoundFile*>(
1124                     externalSeqInfo->seqDataAddress );
1125             seqOffset = 0;
1126 
1127             internal::SequenceSoundFileReader seqFileReader( seqFile );
1128             if ( externalSeqInfo->startLocationLabel != NULL )
1129             {
1130                 bool result = seqFileReader.GetOffsetByLabel(
1131                         externalSeqInfo->startLocationLabel, &seqOffset );
1132                 if ( ! result )
1133                 {
1134                     SoundStartable::StartResult startResult(
1135                         SoundStartable::StartResult::START_ERR_INVALID_SEQ_START_LOCATION_LABEL);
1136                     return startResult;
1137                 }
1138             }
1139             seqOffset = internal::driver::MmlParser::ParseAllocTrack(
1140                     seqFileReader.GetSequenceData(),
1141                     seqOffset,
1142                     &allocTrack
1143                     );
1144         }
1145     }
1146 
1147     // 外部データが指定されていなかったら
1148     // サウンドアーカイブ中のシーケンスデータを使用する
1149     if ( seqFile == NULL )
1150     {
1151         seqFile = reinterpret_cast<const internal::SequenceSoundFile*> (
1152             m_pSoundDataManager->detail_GetFileAddress( commonInfo->fileId )
1153         );
1154         seqOffset = info->startOffset;
1155 
1156         if ( externalSeqInfo != NULL && externalSeqInfo->startLocationLabel != NULL )
1157         {
1158             // TODO: seqFile がロードされていなかったらどうなる？ 090730
1159             internal::SequenceSoundFileReader seqFileReader( seqFile );
1160             bool result = seqFileReader.GetOffsetByLabel(
1161                     externalSeqInfo->startLocationLabel, &seqOffset );
1162             if ( ! result )
1163             {
1164                 SoundStartable::StartResult startResult(
1165                     SoundStartable::StartResult::START_ERR_INVALID_SEQ_START_LOCATION_LABEL );
1166                 return startResult;
1167             }
1168         }
1169     }
1170 
1171     // データがロードされていないのでプレイヤーヒープにロードできるかを確認する
1172     if ( seqFile == NULL )
1173     {
1174         // プレイヤーヒープがあるか
1175         internal::PlayerHeap* pPlayerHeap = sound->GetPlayerHeap();
1176         if ( pPlayerHeap == NULL )
1177         {
1178             SoundStartable::StartResult result(
1179                     SoundStartable::StartResult::START_ERR_NOT_SEQ_LOADED );
1180             return result;
1181         }
1182 
1183         void* fileStreamBuffer = sound->GetFileStreamBuffer();
1184         NW_NULL_ASSERT( fileStreamBuffer );
1185         size_t fileStreamBufferSize = sound->GetFileStreamBufferSize();
1186 
1187         fileStream = const_cast<SoundArchive*>(m_pSoundArchive)->detail_OpenFileStream(
1188             commonInfo->fileId,
1189             fileStreamBuffer,
1190             fileStreamBufferSize
1191         );
1192         if ( fileStream == NULL )
1193         {
1194             SoundStartable::StartResult result(
1195                     SoundStartable::StartResult::START_ERR_CANNOT_OPEN_FILE );
1196             return result;
1197         }
1198 
1199         // プレイヤーヒープにデータをロードできるかどうか
1200         if ( pPlayerHeap->GetFreeSize() < fileStream->GetSize() )
1201         {
1202             fileStream->Close();
1203             SoundStartable::StartResult result(
1204                     SoundStartable::StartResult::START_ERR_NOT_ENOUGH_PLAYER_HEAP );
1205             return result;
1206         }
1207     }
1208 
1209     SoundArchive::ItemId bankIds[ SoundArchive::SEQ_BANK_MAX ];
1210     const void* bankFiles[ SoundArchive::SEQ_BANK_MAX ] = { NULL };
1211     if ( externalSeqInfo != NULL )
1212     {
1213         for ( int i = 0; i < SoundArchive::SEQ_BANK_MAX; i++ )
1214         {
1215             bankIds[ i ] = externalSeqInfo->bankIds[ i ];
1216         }
1217     }
1218     else
1219     {
1220         for ( int i = 0; i < SoundArchive::SEQ_BANK_MAX; i++ )
1221         {
1222             bankIds[ i ] = info->bankIds[ i ];
1223         }
1224     }
1225     // バンクがロード済みか？
1226     for ( int i = 0; i < SoundArchive::SEQ_BANK_MAX; i++ )
1227     {
1228         if ( bankIds[ i ] != SoundArchive::INVALID_ID )
1229         {
1230             SoundArchive::BankInfo bankInfo;
1231             bool isReadBank = GetSoundArchive().ReadBankInfo( bankIds[ i ], &bankInfo );
1232             NW_ASSERTMSG( isReadBank, "invalid bank id(%d)", bankIds[ i ] );
1233             const void* bankFile =
1234                 m_pSoundDataManager->detail_GetFileAddress( bankInfo.fileId );
1235             bankFiles[ i ] = bankFile;
1236             if ( bankFile == NULL )
1237             {
1238                 // return START_ERR_NOT_BANK_LOADED;    // TODO: 失敗とすべきか？
1239                                                         // 失敗とできるなら、スタート時のバンク切替で
1240                                                         // アドレスをセットできる。
1241                 SoundStartable::StartResult result(
1242                         SoundStartable::StartResult::START_ERR_NOT_BANK_LOADED );
1243                 return result;
1244             }
1245 
1246             // 波形アーカイブがロード済みか？ (MEMO: 不要かも)
1247             {
1248                 // TODO: bankFile を解析する
1249             }
1250         }
1251     }
1252 
1253     // プレイヤーのセットアップ
1254 #if 0
1255     internal::driver::SequenceSoundPlayer::SetupResult result =
1256         sound->Initialize(
1257             m_pSequenceTrackAllocator,
1258             allocTrack,
1259             &m_SequenceCallback,
1260             bankFiles
1261         );
1262     while ( result != internal::driver::SequenceSoundPlayer::SETUP_SUCCESS )
1263     {
1264         if ( result == internal::driver::SequenceSoundPlayer::SETUP_ERR_CANNOT_ALLOCATE_TRACK )
1265         {
1266             // トラックが足りない
1267             if ( m_SequenceSoundInstanceManager.GetActiveCount() == 1 )
1268             {
1269                 // ほかにサウンドを再生していないのにトラックが足りない
1270                 if ( fileStream != NULL )
1271                 {
1272                     fileStream->Close();
1273                 }
1274                 NW_WARNING(
1275                     ! internal::Debug_GetWarningFlag( DEBUG_WARNING_NOT_ENOUGH_SEQTRACK ),
1276                     "Failed to start sound (id:%d) for not enough SequenceTrack instance.",
1277                     sound->GetId()
1278                 );
1279                 SoundStartable::StartResult startResult(
1280                     SoundStartable::StartResult::START_ERR_NOT_ENOUGH_INSTANCE );
1281                 return startResult;
1282             }
1283 
1284             internal::SequenceSound* lowest = m_SequenceSoundInstanceManager.GetLowestPrioritySound();
1285             if ( sound == lowest )
1286             {
1287                 // 自分が一番プライオリティが低い
1288                 if ( fileStream != NULL )
1289                 {
1290                     fileStream->Close();
1291                 }
1292                 NW_WARNING(
1293                     ! internal::Debug_GetWarningFlag( DEBUG_WARNING_NOT_ENOUGH_SEQTRACK ),
1294                     "Failed to start sound (id:%d) for not enough SequenceTrack instance.",
1295                     sound->GetId()
1296                 );
1297                 SoundStartable::StartResult startResult(
1298                     SoundStartable::StartResult::START_ERR_NOT_ENOUGH_INSTANCE );
1299                 return startResult;
1300             }
1301 
1302             // もう一度 Setup
1303             NW_WARNING(
1304                 ! internal::Debug_GetWarningFlag( DEBUG_WARNING_NOT_ENOUGH_SEQTRACK ),
1305                 "Sound (id:%d) is stopped for not enough SequenceTrack instance.",
1306                 lowest->GetId()
1307             );
1308             lowest->Stop( 0 );
1309             result = sound->Initialize(
1310                 m_pSequenceTrackAllocator,
1311                 allocTrack,
1312                 &m_SequenceCallback,
1313                 bankFiles
1314             );
1315         }
1316         else
1317         {
1318             SoundStartable::StartResult startResult(
1319                 SoundStartable::StartResult::START_ERR_UNKNOWN );
1320             return startResult;
1321         }
1322     }
1323 #else
1324     // トラックが足りない時のケア無し
1325 
1326     sound->Setup(
1327         m_pSequenceTrackAllocator,
1328         allocTrack,
1329         &m_SequenceCallback,
1330         bankFiles,
1331         SoundArchive::SEQ_BANK_MAX
1332     );
1333 #endif
1334 
1335     // パラメータ設定
1336     UpdateCommonSoundParam( sound, commonInfo );
1337     sound->SetChannelPriority( info->channelPriority );
1338     sound->SetReleasePriorityFix( info->isReleasePriorityFix );
1339     sound->SetSequenceUserprocCallback(
1340             m_SequenceUserprocCallback, m_pSequenceUserprocCallbackArg );
1341 
1342     internal::driver::SequenceSoundPlayer::OffsetType seqOffsetType;
1343     switch ( startOffsetType )
1344     {
1345     case SoundStartable::StartInfo::START_OFFSET_TYPE_MILLISEC:
1346         seqOffsetType = internal::driver::SequenceSoundPlayer::OFFSET_TYPE_MILLISEC;
1347         break;
1348     case SoundStartable::StartInfo::START_OFFSET_TYPE_TICK:
1349         seqOffsetType = internal::driver::SequenceSoundPlayer::OFFSET_TYPE_TICK;
1350         break;
1351     case SoundStartable::StartInfo::START_OFFSET_TYPE_SAMPLE:
1352         seqOffsetType = internal::driver::SequenceSoundPlayer::OFFSET_TYPE_TICK;
1353         startOffset = 0;
1354         break;
1355     default:
1356         seqOffsetType = internal::driver::SequenceSoundPlayer::OFFSET_TYPE_TICK;
1357         startOffset = 0;
1358         break;
1359     }
1360 
1361     if ( seqFile != NULL )
1362     {
1363         // ロード済みのシーケンスデータを使ってプリペア
1364         internal::SequenceSoundFileReader seqFileReader( seqFile );
1365         sound->Prepare(
1366             seqFileReader.GetSequenceData(),
1367             static_cast<s32>( seqOffset ),
1368             seqOffsetType,
1369             startOffset
1370         );
1371     }
1372     else
1373     {
1374         // プレイヤーヒープにデータをロードしてプリペア
1375         sound->Prepare(
1376             fileStream,
1377             static_cast<s32>( seqOffset ),
1378             seqOffsetType,
1379             startOffset
1380         );
1381     }
1382 
1383     SoundStartable::StartResult startResult(
1384             SoundStartable::StartResult::START_SUCCESS );
1385     return startResult;
1386 }
1387 
1388 /*---------------------------------------------------------------------------*
1389   Name:         PrepareStreamImpl
1390 
1391   Description:  ストリームを再生
1392 
1393   Arguments:    playerId   - プレイヤー番号
1394                 playerPrio - プレイヤープライオリティ
1395                 info       - ストリームの情報
1396                 strmId     - ストリーム番号
1397 
1398   Returns:      成功したかどうか
1399  *---------------------------------------------------------------------------*/
PrepareStreamImpl(internal::StreamSound * sound,const SoundArchive::SoundInfo * commonInfo,const SoundArchive::StreamSoundInfo * info,SoundStartable::StartInfo::StartOffsetType startOffsetType,int startOffset)1400 SoundStartable::StartResult SoundArchivePlayer::PrepareStreamImpl(
1401     internal::StreamSound* sound,
1402     const SoundArchive::SoundInfo* commonInfo,
1403     const SoundArchive::StreamSoundInfo* info,
1404     SoundStartable::StartInfo::StartOffsetType startOffsetType,
1405     int startOffset
1406 )
1407 {
1408     // プレイヤーのセットアップ
1409 #if 0
1410     internal::driver::StreamSoundPlayer::SetupResult setupResult = sound->Initialize(
1411         &m_StreamBufferPool,
1412         info->allocChannelCount,
1413         info->allocTrackCount
1414     );
1415 
1416     while ( setupResult != internal::driver::StreamSoundPlayer::SETUP_SUCCESS )
1417     {
1418         if ( setupResult == internal::driver::StreamSoundPlayer::SETUP_ERR_CANNOT_ALLOCATE_BUFFER )
1419         {
1420             // バッファが足りない
1421             if ( m_StreamSoundInstanceManager.GetActiveCount() == 1 )
1422             {
1423                 // ほかにサウンドを再生していないのにバッファが足りない
1424                 NW_WARNING(
1425                     ! internal::Debug_GetWarningFlag( DEBUG_WARNING_NOT_ENOUGH_SEQTRACK ),
1426                     "Failed to start sound (id:%d) for not enough StrmChannel instance.",
1427                     sound->GetId()
1428                 );
1429                 SoundStartable::StartResult result(
1430                         SoundStartable::StartResult::START_ERR_NOT_ENOUGH_INSTANCE );
1431                 return result;
1432             }
1433 
1434             internal::StreamSound* lowest = m_StreamSoundInstanceManager.GetLowestPrioritySound();
1435             if ( sound == lowest )
1436             {
1437                 // 自分が一番プライオリティが低い
1438                 NW_WARNING(
1439                     ! internal::Debug_GetWarningFlag( DEBUG_WARNING_NOT_ENOUGH_SEQTRACK ),
1440                     "Failed to start sound (id:%d) for not enough StrmChannel instance.",
1441                     sound->GetId()
1442                 );
1443                 SoundStartable::StartResult result(
1444                         SoundStartable::StartResult::START_ERR_NOT_ENOUGH_INSTANCE );
1445                 return result;
1446             }
1447 
1448             // もう一度 Initialize
1449             NW_WARNING(
1450                 ! internal::Debug_GetWarningFlag( DEBUG_WARNING_NOT_ENOUGH_STRMCHANNEL ),
1451                 "Sound (id:%d) is stopped for not enough StrmChannel instance.",
1452                 lowest->GetId()
1453             );
1454             lowest->Stop( 0 );
1455             setupResult = sound->Initialize(
1456                 &m_StreamBufferPool,
1457                 info->allocChannelCount,
1458                 info->allocTrackCount
1459             );
1460         }
1461         else
1462         {
1463             SoundStartable::StartResult result(
1464                     SoundStartable::StartResult::START_ERR_UNKNOWN );
1465             return result;
1466         }
1467     }
1468 #else
1469     // 再生失敗時のケア無し
1470 
1471     sound->Setup(
1472         &m_StreamBufferPool,
1473         info->allocChannelCount,
1474         info->allocTrackCount
1475     );
1476 #endif
1477 
1478     // プリペア
1479     internal::driver::StreamSoundPlayer::StartOffsetType strmStartOffsetType;
1480     switch ( startOffsetType )
1481     {
1482     case SoundStartable::StartInfo::START_OFFSET_TYPE_MILLISEC:
1483         strmStartOffsetType = internal::driver::StreamSoundPlayer::START_OFFSET_TYPE_MILLISEC;
1484         break;
1485     case SoundStartable::StartInfo::START_OFFSET_TYPE_TICK:
1486         strmStartOffsetType = internal::driver::StreamSoundPlayer::START_OFFSET_TYPE_SAMPLE;
1487         startOffset = 0;
1488         break;
1489     case SoundStartable::StartInfo::START_OFFSET_TYPE_SAMPLE:
1490         strmStartOffsetType = internal::driver::StreamSoundPlayer::START_OFFSET_TYPE_SAMPLE;
1491         break;
1492     default:
1493         strmStartOffsetType = internal::driver::StreamSoundPlayer::START_OFFSET_TYPE_SAMPLE;
1494         startOffset = 0;
1495         break;
1496     }
1497 
1498     void* fileStreamBuffer = sound->GetFileStreamBuffer();
1499     NW_NULL_ASSERT( fileStreamBuffer );
1500     long fileStreamBufferSize = sound->GetFileStreamBufferSize();
1501     io::FileStream* fileStream =
1502         const_cast<SoundArchive*>(m_pSoundArchive)->detail_OpenFileStream(
1503         commonInfo->fileId,
1504         fileStreamBuffer,
1505         fileStreamBufferSize
1506     );
1507     if ( fileStream == NULL ) {
1508         SoundStartable::StartResult result(
1509                 SoundStartable::StartResult::START_ERR_CANNOT_OPEN_FILE );
1510         return result;
1511     }
1512 
1513     sound->Prepare(
1514         strmStartOffsetType,
1515         startOffset,
1516         fileStream
1517     );
1518 
1519     // パラメータ設定
1520     UpdateCommonSoundParam( sound, commonInfo );
1521 
1522     SoundStartable::StartResult startResult(
1523             SoundStartable::StartResult::START_SUCCESS );
1524     return startResult;
1525 }
1526 
1527 /*---------------------------------------------------------------------------*
1528   Name:         PrepareWaveSoundImpl
1529 
1530   Description:  ウェーブサウンドを再生
1531 
1532   Arguments:    playerId   - プレイヤー番号
1533                 bankId     - バンク番号
1534                 playerPrio - プレイヤープライオリティ
1535                 info       - シーケンス情報構造体のポインタ
1536                 seqId      - シーケンス番号
1537 
1538   Returns:      成功したかどうか
1539  *---------------------------------------------------------------------------*/
PrepareWaveSoundImpl(internal::WaveSound * sound,const SoundArchive::SoundInfo * commonInfo,const SoundArchive::WaveSoundInfo * info,SoundStartable::StartInfo::StartOffsetType startOffsetType,int startOffset)1540 SoundStartable::StartResult SoundArchivePlayer::PrepareWaveSoundImpl(
1541     internal::WaveSound* sound,
1542     const SoundArchive::SoundInfo* commonInfo,
1543     const SoundArchive::WaveSoundInfo* info,
1544     SoundStartable::StartInfo::StartOffsetType startOffsetType,
1545     int startOffset
1546 )
1547 {
1548     NW_NULL_ASSERT( info );
1549 
1550     // データの取得
1551     const void* wsdData = m_pSoundDataManager->detail_GetFileAddress( commonInfo->fileId );
1552     if ( wsdData == NULL ) {
1553         // return START_ERR_NOT_DATA_LOADED;
1554         // return START_ERR_NOT_WSD_LOADED;
1555         SoundStartable::StartResult result(
1556                 SoundStartable::StartResult::START_ERR_NOT_WSD_LOADED );
1557         return result;
1558     }
1559 
1560     internal::driver::WaveSoundPlayer::StartOffsetType wsdStartOffsetType;
1561     switch ( startOffsetType )
1562     {
1563     case SoundStartable::StartInfo::START_OFFSET_TYPE_MILLISEC:
1564         wsdStartOffsetType = internal::driver::WaveSoundPlayer::START_OFFSET_TYPE_MILLISEC;
1565         break;
1566     case SoundStartable::StartInfo::START_OFFSET_TYPE_TICK:
1567         wsdStartOffsetType = internal::driver::WaveSoundPlayer::START_OFFSET_TYPE_SAMPLE;
1568         startOffset = 0;
1569         break;
1570     case SoundStartable::StartInfo::START_OFFSET_TYPE_SAMPLE:
1571         wsdStartOffsetType = internal::driver::WaveSoundPlayer::START_OFFSET_TYPE_SAMPLE;
1572         break;
1573     default:
1574         wsdStartOffsetType = internal::driver::WaveSoundPlayer::START_OFFSET_TYPE_SAMPLE;
1575         startOffset = 0;
1576         break;
1577     }
1578 
1579     // プリペア
1580     sound->Prepare(
1581         wsdData,
1582         info->index,
1583         wsdStartOffsetType,
1584         startOffset,
1585         &m_WaveSoundCallback,
1586         commonInfo->fileId
1587     );
1588 
1589     // パラメータ設定
1590     UpdateCommonSoundParam( sound, commonInfo );
1591     sound->SetChannelPriority( info->channelPriority );
1592     sound->SetReleasePriorityFix( info->isReleasePriorityFix );
1593 
1594     SoundStartable::StartResult startResult(
1595             SoundStartable::StartResult::START_SUCCESS );
1596     return startResult;
1597 }
1598 
1599 /*---------------------------------------------------------------------------*
1600   Name:         UpdateCommonSoundParam
1601 
1602   Description:  サウンド共通パラメータの更新
1603 
1604   Arguments:    sound - 更新対象のサウンド
1605                 commonInfo - サウンド共通パラメータ
1606 
1607   Returns:      None.
1608   *---------------------------------------------------------------------------*/
UpdateCommonSoundParam(internal::BasicSound * sound,const SoundArchive::SoundInfo * commonInfo)1609 void SoundArchivePlayer::UpdateCommonSoundParam(
1610     internal::BasicSound* sound,
1611     const SoundArchive::SoundInfo* commonInfo
1612 )
1613 {
1614     NW_NULL_ASSERT(sound);
1615     NW_NULL_ASSERT(commonInfo);
1616 
1617     sound->SetInitialVolume( static_cast<float>( commonInfo->volume ) / 127.0f );
1618     sound->SetPanMode( commonInfo->panMode );
1619     sound->SetPanCurve( commonInfo->panCurve );
1620 }
1621 
1622 
1623 /*---------------------------------------------------------------------------*
1624   Name:         SetSequenceUserprocCallback
1625 
1626   Description:  シーケンスコマンド'userproc'で呼び出されるコールバックを登録する
1627 
1628   Arguments:    callback - コールバック
1629                 arg - コールバック引数
1630 
1631   Returns:
1632  *---------------------------------------------------------------------------*/
SetSequenceUserprocCallback(SequenceUserprocCallback callback,void * callbackArg)1633 void SoundArchivePlayer::SetSequenceUserprocCallback( SequenceUserprocCallback callback, void* callbackArg )
1634 {
1635     m_SequenceUserprocCallback = callback;
1636     m_pSequenceUserprocCallbackArg = callbackArg;
1637 }
1638 
1639 /*---------------------------------------------------------------------------*
1640   Name:         NoteOn
1641 
1642   Description:  シーケンスサウンドのノートオン処理
1643 
1644   Arguments:
1645 
1646   Returns:      None.
1647  *---------------------------------------------------------------------------*/
NoteOn(internal::driver::SequenceSoundPlayer * seqPlayer,u8 bankIndex,const internal::driver::NoteOnInfo & noteOnInfo)1648 internal::driver::Channel* SoundArchivePlayer::SequenceNoteOnCallback::NoteOn(
1649     internal::driver::SequenceSoundPlayer* seqPlayer,
1650     u8 bankIndex,
1651     const internal::driver::NoteOnInfo& noteOnInfo
1652 )
1653 {
1654     if ( ! m_pSoundArchivePlayer.IsAvailable() ) return NULL;
1655 
1656     const SoundArchive& sndArc = m_pSoundArchivePlayer.GetSoundArchive();
1657 
1658     // 当該ノートに該当する波形アーカイブ ID・波形アーカイブ内インデックス取得
1659     const void* bankFile = seqPlayer->GetBankFile( bankIndex );
1660     internal::driver::Bank bank;
1661     internal::driver::Channel* channel = bank.NoteOn(
1662         bankFile,
1663         noteOnInfo,
1664         sndArc,
1665         m_pSoundArchivePlayer
1666     );
1667 
1668     internal::driver::SoundThread::GetInstance().IncrNoteOnCount();
1669     return channel;
1670 }
1671 
1672 /* ========================================================================
1673         SoundArchivePlayer::WaveSoundCallback class
1674    ======================================================================== */
1675 
1676 /*---------------------------------------------------------------------------*
1677   Name:         GetWaveSoundData
1678 
1679   Description:  ウェーブサウンドの波形取得処理
1680 
1681   Arguments:
1682 
1683   Returns:      None.
1684  *---------------------------------------------------------------------------*/
GetWaveSoundData(internal::WaveSoundInfo * info,internal::WaveSoundNoteInfo * noteInfo,internal::WaveInfo * waveInfo,const void * waveSoundData,int index,int noteIndex,u32) const1685 bool SoundArchivePlayer::WaveSoundCallback::GetWaveSoundData(
1686     internal::WaveSoundInfo* info,
1687     internal::WaveSoundNoteInfo* noteInfo,
1688     internal::WaveInfo* waveInfo,
1689     const void* waveSoundData,      // メモリに展開されたウェーブサウンドセットファイル
1690     int index,      // ウェーブサウンドセットファイル内でのインデックス
1691     int noteIndex,  // 現状ではつねにゼロ
1692     u32 // userData // SoundArchivePlayer::PrepareWaveSoundImpl にて fileId が入るが、
1693                     // CTR では不要
1694 ) const
1695 {
1696     // const u32 fileID = userData;
1697 
1698     if ( ! m_pSoundArchivePlayer.IsAvailable() ) {
1699         return false;
1700     }
1701 
1702     // ウェーブサウンド情報および、ノート情報を取得
1703     {
1704         internal::WaveSoundFileReader reader( waveSoundData );
1705         if ( ! reader.ReadWaveSoundInfo( info, index ) )
1706         {
1707             return false;
1708         }
1709         if ( ! reader.ReadNoteInfo( noteInfo, index, noteIndex ) )
1710         {
1711             return false;
1712         }
1713     }
1714 
1715     // 波形アーカイブ取得
1716     const SoundArchive& sndArc = m_pSoundArchivePlayer.GetSoundArchive();
1717 #if 0 // 不要？ (Util::GetWaveFile で波形アーカイブのロード確認をしているので)
1718     {
1719         SoundArchive::WaveArchiveInfo warcInfo;
1720         if ( ! sndArc.ReadWaveArchiveInfo( noteInfo->waveArchiveId, &warcInfo ) )
1721         {
1722             return false;
1723         }
1724         const void* warcFile = m_pSoundArchivePlayer.detail_GetFileAddress( warcInfo.fileId );
1725         NW_WARNING( warcFile, "WSD failed - warc(%d) is not loaded", noteInfo->waveArchiveId );
1726         if ( warcFile == NULL )
1727         {
1728             return false;
1729         }
1730     }
1731 #endif
1732 
1733     // 波形ファイル取得
1734     const void* waveFile = internal::Util::GetWaveFile(
1735             noteInfo->waveArchiveId, noteInfo->waveIndex,
1736             sndArc, m_pSoundArchivePlayer );
1737     if ( waveFile == NULL )
1738     {
1739         return false;
1740     }
1741 
1742     // 波形ファイル情報取得
1743     {
1744         internal::WaveFileReader reader( waveFile );
1745         if ( ! reader.ReadWaveInfo( waveInfo ) )
1746         {
1747             return false;
1748         }
1749     }
1750 
1751     return true;
1752 }
1753 
1754 } // namespace nw::snd
1755 } // namespace nw
1756 
1757