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