1 /*---------------------------------------------------------------------------*
2 Project: NintendoWare
3 File: snd_DriverCommand.cpp
4
5 Copyright (C)2009-2011 Nintendo/HAL Laboratory, Inc. All rights reserved.
6
7 These coded instructions, statements, and computer programs contain proprietary
8 information of Nintendo and/or its licensed developers and are protected by
9 national and international copyright laws. They may not be disclosed to third
10 parties or copied or duplicated in any form, in whole or in part, without the
11 prior written consent of Nintendo.
12
13 The content herein is highly confidential and should be handled accordingly.
14
15 $Revision: 32385 $
16 *---------------------------------------------------------------------------*/
17
18 #include "precompiled.h"
19 #include <nw/snd/snd_DriverCommand.h>
20 #include <nw/snd/snd_VoiceManager.h>
21
22 namespace nw {
23 namespace snd {
24 namespace internal {
25
ProcessCommandList(DriverCommand * commandList)26 void DriverCommand::ProcessCommandList( DriverCommand* commandList )
27 {
28 DriverCommand* command = commandList;
29
30 while( command != NULL )
31 {
32 switch( command->id )
33 {
34 case DRIVER_COMMAND_DUMMY:
35 // do nothing
36 break;
37
38 case DRIVER_COMMAND_REPLY:
39 {
40 DriverCommandReply* c = reinterpret_cast<DriverCommandReply*>(command);
41 *(c->ptr) = true;
42 break;
43 }
44
45 case DRIVER_COMMAND_PLAYER_INIT:
46 {
47 DriverCommandPlayerInit* c = reinterpret_cast<DriverCommandPlayerInit*>(command);
48 c->player->Initialize();
49 *(c->availableFlagPtr) = true;
50 break;
51 }
52
53 case DRIVER_COMMAND_PLAYER_FINALIZE:
54 {
55 DriverCommandPlayer* c = reinterpret_cast<DriverCommandPlayer*>(command);
56 c->player->Finalize();
57 break;
58 }
59
60 case DRIVER_COMMAND_PLAYER_START:
61 {
62 DriverCommandPlayer* c = reinterpret_cast<DriverCommandPlayer*>(command);
63 c->player->Start();
64 break;
65 }
66
67 case DRIVER_COMMAND_PLAYER_STOP:
68 {
69 DriverCommandPlayer* c = reinterpret_cast<DriverCommandPlayer*>(command);
70 if ( c->flag ) {
71 c->player->SetVolume( 0.0f );
72 }
73 c->player->Stop();
74 break;
75 }
76
77 case DRIVER_COMMAND_PLAYER_PAUSE:
78 {
79 DriverCommandPlayer* c = reinterpret_cast<DriverCommandPlayer*>(command);
80 c->player->Pause( c->flag );
81 break;
82 }
83
84 case DRIVER_COMMAND_PLAYER_PANMODE:
85 {
86 DriverCommandPlayerPanParam* c = reinterpret_cast<DriverCommandPlayerPanParam*>(command);
87 c->player->SetPanMode( c->panMode );
88 break;
89 }
90
91 case DRIVER_COMMAND_PLAYER_PANCURVE:
92 {
93 DriverCommandPlayerPanParam* c = reinterpret_cast<DriverCommandPlayerPanParam*>(command);
94 c->player->SetPanCurve( c->panCurve );
95 break;
96 }
97
98 case DRIVER_COMMAND_PLAYER_FRONTBYPASS:
99 {
100 DriverCommandPlayer* c = reinterpret_cast<DriverCommandPlayer*>(command);
101 c->player->SetFrontBypass( c->flag );
102 break;
103 }
104
105 case DRIVER_COMMAND_PLAYER_PARAM:
106 {
107 DriverCommandPlayerParam* c = reinterpret_cast<DriverCommandPlayerParam*>(command);
108 c->player->SetVolume( c->volume );
109 c->player->SetPitch( c->pitch );
110 c->player->SetPan( c->pan );
111 c->player->SetSurroundPan( c->surroundPan );
112 c->player->SetLpfFreq( c->lpfFreq );
113 c->player->SetBiquadFilter( c->biquadFilterType, c->biquadFilterValue );
114 c->player->SetMainSend( c->mainSend );
115 for ( int i = 0 ; i < AUX_BUS_NUM ; i++ ) {
116 c->player->SetFxSend( AuxBus(i), c->fxSend[i] );
117 }
118 break;
119 }
120
121 case DRIVER_COMMAND_SEQ_INIT:
122 {
123 DriverCommandSeqInit* c = reinterpret_cast<DriverCommandSeqInit*>(command);
124 c->player->Setup(
125 c->trackAllocator,
126 c->allocTracks,
127 c->noteOnCallback
128 );
129 break;
130 }
131
132 case DRIVER_COMMAND_SEQ_SEQDATA:
133 {
134 DriverCommandSeqSetData* c = reinterpret_cast<DriverCommandSeqSetData*>(command);
135 c->player->SetSeqData(
136 c->seqBase,
137 c->seqOffset
138 );
139 break;
140 }
141
142 case DRIVER_COMMAND_SEQ_BANKDATA:
143 {
144 DriverCommandSeqSetBankData* c =
145 reinterpret_cast<DriverCommandSeqSetBankData*>(command);
146 c->player->SetBankData( c->bankFiles, SoundArchive::SEQ_BANK_MAX );
147 break;
148 }
149
150 case DRIVER_COMMAND_SEQ_SKIP:
151 {
152 DriverCommandSeqSkip* c = reinterpret_cast<DriverCommandSeqSkip*>(command);
153 c->player->Skip(
154 driver::SequenceSoundPlayer::OffsetType(c->offsetType),
155 c->offset
156 );
157 break;
158 }
159
160 case DRIVER_COMMAND_SEQ_TEMPORATIO:
161 {
162 DriverCommandSeqTempoRatio* c = reinterpret_cast<DriverCommandSeqTempoRatio*>(command);
163 c->player->SetTempoRatio(
164 c->tempoRatio
165 );
166 break;
167 }
168
169 case DRIVER_COMMAND_SEQ_CHANNELPRIO:
170 {
171 DriverCommandSeqChannelPrio* c = reinterpret_cast<DriverCommandSeqChannelPrio*>(command);
172 c->player->SetChannelPriority(
173 c->priority
174 );
175 break;
176 }
177
178 case DRIVER_COMMAND_SEQ_PRIOFIX:
179 {
180 DriverCommandSeqPrioFix* c = reinterpret_cast<DriverCommandSeqPrioFix*>(command);
181 c->player->SetReleasePriorityFix(
182 c->priorityFix
183 );
184 break;
185 }
186
187 case DRIVER_COMMAND_SEQ_USERPROC:
188 {
189 DriverCommandSeqUserProc* c = reinterpret_cast<DriverCommandSeqUserProc*>(command);
190 c->player->SetSequenceUserprocCallback(
191 reinterpret_cast<SequenceUserprocCallback>(c->callback),
192 c->arg
193 );
194 break;
195 }
196
197 case DRIVER_COMMAND_SEQ_SETVAR:
198 {
199 DriverCommandSeqSetVar* c = reinterpret_cast<DriverCommandSeqSetVar*>(command);
200 c->player->SetLocalVariable(
201 c->varNo,
202 c->var
203 );
204 break;
205 }
206
207 case DRIVER_COMMAND_SEQ_SETGVAR:
208 {
209 DriverCommandSeqSetVar* c = reinterpret_cast<DriverCommandSeqSetVar*>(command);
210 driver::SequenceSoundPlayer::SetGlobalVariable(
211 c->varNo,
212 c->var
213 );
214 break;
215 }
216
217 case DRIVER_COMMAND_SEQ_SETTVAR:
218 {
219 DriverCommandSeqSetVar* c = reinterpret_cast<DriverCommandSeqSetVar*>(command);
220 driver::SequenceTrack* track = c->player->GetPlayerTrack( c->trackNo );
221 if ( track != NULL ) {
222 track->SetTrackVariable( c->varNo, c->var );
223 }
224 break;
225 }
226
227 case DRIVER_COMMAND_SEQTRACK_MUTE:
228 {
229 DriverCommandSeqTrackMute* c = reinterpret_cast<DriverCommandSeqTrackMute*>(command);
230 c->player->SetTrackMute(
231 c->trackBitFlag,
232 SeqMute(c->mute)
233 );
234 break;
235 }
236
237 case DRIVER_COMMAND_SEQTRACK_SILENCE:
238 {
239 DriverCommandSeqTrackSilence* c = reinterpret_cast<DriverCommandSeqTrackSilence*>(command);
240 c->player->SetTrackSilence(
241 c->trackBitFlag,
242 c->silenceFlag,
243 c->fadeFrames
244 );
245 break;
246 }
247
248 case DRIVER_COMMAND_SEQTRACK_VOLUME:
249 {
250 DriverCommandSeqTrackParam* c = reinterpret_cast<DriverCommandSeqTrackParam*>(command);
251 c->player->SetTrackVolume(
252 c->trackBitFlag,
253 c->value
254 );
255 break;
256 }
257
258 case DRIVER_COMMAND_SEQTRACK_PITCH:
259 {
260 DriverCommandSeqTrackParam* c = reinterpret_cast<DriverCommandSeqTrackParam*>(command);
261 c->player->SetTrackPitch(
262 c->trackBitFlag,
263 c->value
264 );
265 break;
266 }
267
268 case DRIVER_COMMAND_SEQTRACK_PAN:
269 {
270 DriverCommandSeqTrackParam* c = reinterpret_cast<DriverCommandSeqTrackParam*>(command);
271 c->player->SetTrackPan(
272 c->trackBitFlag,
273 c->value
274 );
275 break;
276 }
277
278 case DRIVER_COMMAND_SEQTRACK_SPAN:
279 {
280 DriverCommandSeqTrackParam* c = reinterpret_cast<DriverCommandSeqTrackParam*>(command);
281 c->player->SetTrackSurroundPan(
282 c->trackBitFlag,
283 c->value
284 );
285 break;
286 }
287
288 case DRIVER_COMMAND_SEQTRACK_LPF:
289 {
290 DriverCommandSeqTrackParam* c = reinterpret_cast<DriverCommandSeqTrackParam*>(command);
291 c->player->SetTrackLpfFreq(
292 c->trackBitFlag,
293 c->value
294 );
295 break;
296 }
297
298 case DRIVER_COMMAND_SEQTRACK_PANRANGE:
299 {
300 DriverCommandSeqTrackParam* c = reinterpret_cast<DriverCommandSeqTrackParam*>(command);
301 c->player->SetTrackPanRange(
302 c->trackBitFlag,
303 c->value
304 );
305 break;
306 }
307
308 case DRIVER_COMMAND_SEQTRACK_MODDEPTH:
309 {
310 DriverCommandSeqTrackParam* c = reinterpret_cast<DriverCommandSeqTrackParam*>(command);
311 c->player->SetTrackModDepth(
312 c->trackBitFlag,
313 c->value
314 );
315 break;
316 }
317
318 case DRIVER_COMMAND_SEQTRACK_MODSPEED:
319 {
320 DriverCommandSeqTrackParam* c = reinterpret_cast<DriverCommandSeqTrackParam*>(command);
321 c->player->SetTrackModSpeed(
322 c->trackBitFlag,
323 c->value
324 );
325 break;
326 }
327
328 case DRIVER_COMMAND_SEQTRACK_BIQUAD:
329 {
330 DriverCommandSeqTrackBiquad* c = reinterpret_cast<DriverCommandSeqTrackBiquad*>(command);
331 c->player->SetTrackBiquadFilter(
332 c->trackBitFlag,
333 c->type,
334 c->value
335 );
336 break;
337 }
338
339 case DRIVER_COMMAND_SEQTRACK_BANKINDEX:
340 {
341 DriverCommandSeqTrackBankIndex* c = reinterpret_cast<DriverCommandSeqTrackBankIndex*>(command);
342 c->player->SetTrackBankIndex(
343 c->trackBitFlag,
344 c->bankIndex
345 );
346 break;
347 }
348
349 case DRIVER_COMMAND_WAVESND_SETUP:
350 {
351 DriverCommandWaveSoundSetup* c = reinterpret_cast<DriverCommandWaveSoundSetup*>(command);
352 c->player->Prepare(
353 c->wsdFile,
354 c->waveSoundOffset,
355 driver::WaveSoundPlayer::StartOffsetType(c->startOffsetType),
356 c->offset,
357 reinterpret_cast<const driver::WaveSoundPlayer::WaveSoundCallback*>(c->callback),
358 c->callbackData
359 );
360 break;
361 }
362
363 case DRIVER_COMMAND_WAVESND_CHANNELPRIO:
364 {
365 DriverCommandWaveSoundChannelPrio* c = reinterpret_cast<DriverCommandWaveSoundChannelPrio*>(command);
366 c->player->SetChannelPriority(c->priority);
367 break;
368 }
369
370 case DRIVER_COMMAND_WAVESND_PRIOFIX:
371 {
372 DriverCommandWaveSoundPrioFix* c = reinterpret_cast<DriverCommandWaveSoundPrioFix*>(command);
373 c->player->SetReleasePriorityFix(c->priorityFix);
374 break;
375 }
376
377 case DRIVER_COMMAND_STRM_INIT:
378 {
379 DriverCommandStreamSoundInit* c = reinterpret_cast<DriverCommandStreamSoundInit*>(command);
380 c->player->Setup(
381 c->pBufferPool,
382 c->allocChannelCount,
383 c->allocTrackFlag
384 );
385 break;
386 }
387
388 case DRIVER_COMMAND_STRM_SETUP:
389 {
390 DriverCommandStreamSoundSetup* c = reinterpret_cast<DriverCommandStreamSoundSetup*>(command);
391 c->player->Prepare(
392 c->pFileStream,
393 driver::StreamSoundPlayer::StartOffsetType(c->startOffsetType),
394 c->offset
395 );
396 break;
397 }
398
399 case DRIVER_COMMAND_STRM_LOADHEADER:
400 {
401 DriverCommandStreamSoundLoadHeader* c = reinterpret_cast<DriverCommandStreamSoundLoadHeader*>(command);
402 c->player->LoadHeader(
403 c->streamInfo,
404 c->trackInfoArray,
405 c->dspAdpcmParam,
406 c->dspAdpcmLoopParam,
407 c->dataBlockOffset,
408 c->trackCount,
409 c->channelCount
410 );
411 break;
412 }
413
414 case DRIVER_COMMAND_STRM_LOADDATA:
415 {
416 DriverCommandStreamSoundLoadData* c = reinterpret_cast<DriverCommandStreamSoundLoadData*>(command);
417 c->player->LoadStreamData(
418 c->bufferBlockIndex,
419 c->dataBlockIndex,
420 c->blockSamples,
421 c->isDataLoopBlock,
422 c->lastBlockFlag
423 );
424 break;
425 }
426
427 case DRIVER_COMMAND_STRM_TRACK_VOLUME:
428 {
429 DriverCommandStreamSoundTrackParam* c = reinterpret_cast<DriverCommandStreamSoundTrackParam*>(command);
430 c->player->SetTrackVolume(
431 c->trackBitFlag,
432 c->value
433 );
434 break;
435 }
436
437 case DRIVER_COMMAND_STRM_TRACK_PAN:
438 {
439 DriverCommandStreamSoundTrackParam* c = reinterpret_cast<DriverCommandStreamSoundTrackParam*>(command);
440 c->player->SetTrackPan(
441 c->trackBitFlag,
442 c->value
443 );
444 break;
445 }
446
447 case DRIVER_COMMAND_STRM_TRACK_SPAN:
448 {
449 DriverCommandStreamSoundTrackParam* c = reinterpret_cast<DriverCommandStreamSoundTrackParam*>(command);
450 c->player->SetTrackSurroundPan(
451 c->trackBitFlag,
452 c->value
453 );
454 break;
455 }
456
457 case DRIVER_COMMAND_INVALIDATE_DATA:
458 {
459 DriverCommandInvalidateData* c = reinterpret_cast<DriverCommandInvalidateData*>(command);
460 driver::DisposeCallbackManager::GetInstance().Dispose(
461 c->mem,
462 c->size
463 );
464 break;
465 }
466
467 case DRIVER_COMMAND_REGIST_DISPOSE_CALLBACK:
468 {
469 DriverCommandDisposeCallback* c = reinterpret_cast<DriverCommandDisposeCallback*>(command);
470 driver::DisposeCallbackManager::GetInstance().RegisterDisposeCallback(
471 c->callback
472 );
473 break;
474 }
475
476 case DRIVER_COMMAND_UNREGIST_DISPOSE_CALLBACK:
477 {
478 DriverCommandDisposeCallback* c = reinterpret_cast<DriverCommandDisposeCallback*>(command);
479 driver::DisposeCallbackManager::GetInstance().UnregisterDisposeCallback(
480 c->callback
481 );
482 break;
483 }
484
485 case DRIVER_COMMAND_APPEND_EFFECT:
486 {
487 DriverCommandEffect* c = reinterpret_cast<DriverCommandEffect*>(command);
488 internal::driver::HardwareManager::GetInstance().AppendEffect(
489 c->bus,
490 c->effect
491 );
492 break;
493 }
494
495 #ifdef NW_PLATFORM_CTR
496 case DRIVER_COMMAND_APPEND_EFFECT_SDK_DELAY:
497 {
498 DriverCommandEffectSdkDelay* c =
499 reinterpret_cast<DriverCommandEffectSdkDelay*>(command);
500 internal::driver::HardwareManager::GetInstance().AppendEffect(
501 c->bus,
502 c->effect
503 );
504 break;
505 }
506
507 case DRIVER_COMMAND_APPEND_EFFECT_SDK_REVERB:
508 {
509 DriverCommandEffectSdkReverb* c =
510 reinterpret_cast<DriverCommandEffectSdkReverb*>(command);
511 internal::driver::HardwareManager::GetInstance().AppendEffect(
512 c->bus,
513 c->effect
514 );
515 break;
516 }
517 #endif
518
519 case DRIVER_COMMAND_CLEAR_EFFECT:
520 {
521 DriverCommandEffect* c = reinterpret_cast<DriverCommandEffect*>(command);
522 internal::driver::HardwareManager::GetInstance().ClearEffect(
523 c->bus,
524 c->fadeTimes
525 );
526 break;
527 }
528
529 case DRIVER_COMMAND_DEBUG:
530 {
531 DriverCommandDebug* c = reinterpret_cast<DriverCommandDebug*>(command);
532 NN_LOG("[CMD] %s\n", c->str );
533 break;
534 }
535
536 case DRIVER_COMMAND_ALLVOICES_SYNC:
537 {
538 DriverCommandAllVoicesSync* c =
539 reinterpret_cast<DriverCommandAllVoicesSync*>(command);
540 driver::VoiceManager::GetInstance().UpdateAllVoicesSync( c->syncFlag );
541 break;
542 }
543
544 } // switch
545
546 command = command->next;
547
548 } // while
549 }
550
551 } // namespace nw::snd::internal
552 } // namespace nw::snd
553 } // namespace nw
554