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: 28272 $
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 c->bankFiles
127 );
128 break;
129 }
130
131 case DRIVER_COMMAND_SEQ_SEQDATA:
132 {
133 DriverCommandSeqSetData* c = reinterpret_cast<DriverCommandSeqSetData*>(command);
134 c->player->SetSeqData(
135 c->seqBase,
136 c->seqOffset
137 );
138 break;
139 }
140
141 case DRIVER_COMMAND_SEQ_SKIP:
142 {
143 DriverCommandSeqSkip* c = reinterpret_cast<DriverCommandSeqSkip*>(command);
144 c->player->Skip(
145 driver::SequenceSoundPlayer::OffsetType(c->offsetType),
146 c->offset
147 );
148 break;
149 }
150
151 case DRIVER_COMMAND_SEQ_TEMPORATIO:
152 {
153 DriverCommandSeqTempoRatio* c = reinterpret_cast<DriverCommandSeqTempoRatio*>(command);
154 c->player->SetTempoRatio(
155 c->tempoRatio
156 );
157 break;
158 }
159
160 case DRIVER_COMMAND_SEQ_CHANNELPRIO:
161 {
162 DriverCommandSeqChannelPrio* c = reinterpret_cast<DriverCommandSeqChannelPrio*>(command);
163 c->player->SetChannelPriority(
164 c->priority
165 );
166 break;
167 }
168
169 case DRIVER_COMMAND_SEQ_PRIOFIX:
170 {
171 DriverCommandSeqPrioFix* c = reinterpret_cast<DriverCommandSeqPrioFix*>(command);
172 c->player->SetReleasePriorityFix(
173 c->priorityFix
174 );
175 break;
176 }
177
178 case DRIVER_COMMAND_SEQ_USERPROC:
179 {
180 DriverCommandSeqUserProc* c = reinterpret_cast<DriverCommandSeqUserProc*>(command);
181 c->player->SetSequenceUserprocCallback(
182 reinterpret_cast<SequenceUserprocCallback>(c->callback),
183 c->arg
184 );
185 break;
186 }
187
188 case DRIVER_COMMAND_SEQ_SETVAR:
189 {
190 DriverCommandSeqSetVar* c = reinterpret_cast<DriverCommandSeqSetVar*>(command);
191 c->player->SetLocalVariable(
192 c->varNo,
193 c->var
194 );
195 break;
196 }
197
198 case DRIVER_COMMAND_SEQ_SETGVAR:
199 {
200 DriverCommandSeqSetVar* c = reinterpret_cast<DriverCommandSeqSetVar*>(command);
201 driver::SequenceSoundPlayer::SetGlobalVariable(
202 c->varNo,
203 c->var
204 );
205 break;
206 }
207
208 case DRIVER_COMMAND_SEQ_SETTVAR:
209 {
210 DriverCommandSeqSetVar* c = reinterpret_cast<DriverCommandSeqSetVar*>(command);
211 driver::SequenceTrack* track = c->player->GetPlayerTrack( c->trackNo );
212 if ( track != NULL ) {
213 track->SetTrackVariable( c->varNo, c->var );
214 }
215 break;
216 }
217
218 case DRIVER_COMMAND_SEQTRACK_MUTE:
219 {
220 DriverCommandSeqTrackMute* c = reinterpret_cast<DriverCommandSeqTrackMute*>(command);
221 c->player->SetTrackMute(
222 c->trackBitFlag,
223 SeqMute(c->mute)
224 );
225 break;
226 }
227
228 case DRIVER_COMMAND_SEQTRACK_SILENCE:
229 {
230 DriverCommandSeqTrackSilence* c = reinterpret_cast<DriverCommandSeqTrackSilence*>(command);
231 c->player->SetTrackSilence(
232 c->trackBitFlag,
233 c->silenceFlag,
234 c->fadeFrames
235 );
236 break;
237 }
238
239 case DRIVER_COMMAND_SEQTRACK_VOLUME:
240 {
241 DriverCommandSeqTrackParam* c = reinterpret_cast<DriverCommandSeqTrackParam*>(command);
242 c->player->SetTrackVolume(
243 c->trackBitFlag,
244 c->value
245 );
246 break;
247 }
248
249 case DRIVER_COMMAND_SEQTRACK_PITCH:
250 {
251 DriverCommandSeqTrackParam* c = reinterpret_cast<DriverCommandSeqTrackParam*>(command);
252 c->player->SetTrackPitch(
253 c->trackBitFlag,
254 c->value
255 );
256 break;
257 }
258
259 case DRIVER_COMMAND_SEQTRACK_PAN:
260 {
261 DriverCommandSeqTrackParam* c = reinterpret_cast<DriverCommandSeqTrackParam*>(command);
262 c->player->SetTrackPan(
263 c->trackBitFlag,
264 c->value
265 );
266 break;
267 }
268
269 case DRIVER_COMMAND_SEQTRACK_SPAN:
270 {
271 DriverCommandSeqTrackParam* c = reinterpret_cast<DriverCommandSeqTrackParam*>(command);
272 c->player->SetTrackSurroundPan(
273 c->trackBitFlag,
274 c->value
275 );
276 break;
277 }
278
279 case DRIVER_COMMAND_SEQTRACK_LPF:
280 {
281 DriverCommandSeqTrackParam* c = reinterpret_cast<DriverCommandSeqTrackParam*>(command);
282 c->player->SetTrackLpfFreq(
283 c->trackBitFlag,
284 c->value
285 );
286 break;
287 }
288
289 case DRIVER_COMMAND_SEQTRACK_PANRANGE:
290 {
291 DriverCommandSeqTrackParam* c = reinterpret_cast<DriverCommandSeqTrackParam*>(command);
292 c->player->SetTrackPanRange(
293 c->trackBitFlag,
294 c->value
295 );
296 break;
297 }
298
299 case DRIVER_COMMAND_SEQTRACK_MODDEPTH:
300 {
301 DriverCommandSeqTrackParam* c = reinterpret_cast<DriverCommandSeqTrackParam*>(command);
302 c->player->SetTrackModDepth(
303 c->trackBitFlag,
304 c->value
305 );
306 break;
307 }
308
309 case DRIVER_COMMAND_SEQTRACK_MODSPEED:
310 {
311 DriverCommandSeqTrackParam* c = reinterpret_cast<DriverCommandSeqTrackParam*>(command);
312 c->player->SetTrackModSpeed(
313 c->trackBitFlag,
314 c->value
315 );
316 break;
317 }
318
319 case DRIVER_COMMAND_SEQTRACK_BIQUAD:
320 {
321 DriverCommandSeqTrackBiquad* c = reinterpret_cast<DriverCommandSeqTrackBiquad*>(command);
322 c->player->SetTrackBiquadFilter(
323 c->trackBitFlag,
324 c->type,
325 c->value
326 );
327 break;
328 }
329
330 case DRIVER_COMMAND_SEQTRACK_BANKINDEX:
331 {
332 DriverCommandSeqTrackBankIndex* c = reinterpret_cast<DriverCommandSeqTrackBankIndex*>(command);
333 c->player->SetTrackBankIndex(
334 c->trackBitFlag,
335 c->bankIndex
336 );
337 break;
338 }
339
340 case DRIVER_COMMAND_WAVESND_SETUP:
341 {
342 DriverCommandWaveSoundSetup* c = reinterpret_cast<DriverCommandWaveSoundSetup*>(command);
343 c->player->Prepare(
344 c->waveSoundBase,
345 c->waveSoundOffset,
346 driver::WaveSoundPlayer::StartOffsetType(c->startOffsetType),
347 c->offset,
348 reinterpret_cast<const driver::WaveSoundPlayer::WaveSoundCallback*>(c->callback),
349 c->callbackData
350 );
351 break;
352 }
353
354 case DRIVER_COMMAND_WAVESND_CHANNELPRIO:
355 {
356 DriverCommandWaveSoundChannelPrio* c = reinterpret_cast<DriverCommandWaveSoundChannelPrio*>(command);
357 c->player->SetChannelPriority(c->priority);
358 break;
359 }
360
361 case DRIVER_COMMAND_WAVESND_PRIOFIX:
362 {
363 DriverCommandWaveSoundPrioFix* c = reinterpret_cast<DriverCommandWaveSoundPrioFix*>(command);
364 c->player->SetReleasePriorityFix(c->priorityFix);
365 break;
366 }
367
368 case DRIVER_COMMAND_STRM_INIT:
369 {
370 DriverCommandStreamSoundInit* c = reinterpret_cast<DriverCommandStreamSoundInit*>(command);
371 c->player->Setup(
372 c->pBufferPool,
373 c->allocChannelCount,
374 c->allocTrackFlag
375 );
376 break;
377 }
378
379 case DRIVER_COMMAND_STRM_SETUP:
380 {
381 DriverCommandStreamSoundSetup* c = reinterpret_cast<DriverCommandStreamSoundSetup*>(command);
382 c->player->Prepare(
383 c->pFileStream,
384 driver::StreamSoundPlayer::StartOffsetType(c->startOffsetType),
385 c->offset
386 );
387 break;
388 }
389
390 case DRIVER_COMMAND_STRM_LOADHEADER:
391 {
392 DriverCommandStreamSoundLoadHeader* c = reinterpret_cast<DriverCommandStreamSoundLoadHeader*>(command);
393 c->player->LoadHeader(
394 c->streamInfo,
395 c->trackInfoArray,
396 c->dspAdpcmParam,
397 c->dspAdpcmLoopParam,
398 c->dataBlockOffset,
399 c->trackCount,
400 c->channelCount
401 );
402 break;
403 }
404
405 case DRIVER_COMMAND_STRM_LOADDATA:
406 {
407 DriverCommandStreamSoundLoadData* c = reinterpret_cast<DriverCommandStreamSoundLoadData*>(command);
408 c->player->LoadStreamData(
409 c->bufferBlockIndex,
410 c->dataBlockIndex,
411 c->blockSamples,
412 c->isDataLoopBlock,
413 c->lastBlockFlag
414 );
415 break;
416 }
417
418 case DRIVER_COMMAND_STRM_TRACK_VOLUME:
419 {
420 DriverCommandStreamSoundTrackParam* c = reinterpret_cast<DriverCommandStreamSoundTrackParam*>(command);
421 c->player->SetTrackVolume(
422 c->trackBitFlag,
423 c->value
424 );
425 break;
426 }
427
428 case DRIVER_COMMAND_STRM_TRACK_PAN:
429 {
430 DriverCommandStreamSoundTrackParam* c = reinterpret_cast<DriverCommandStreamSoundTrackParam*>(command);
431 c->player->SetTrackPan(
432 c->trackBitFlag,
433 c->value
434 );
435 break;
436 }
437
438 case DRIVER_COMMAND_STRM_TRACK_SPAN:
439 {
440 DriverCommandStreamSoundTrackParam* c = reinterpret_cast<DriverCommandStreamSoundTrackParam*>(command);
441 c->player->SetTrackSurroundPan(
442 c->trackBitFlag,
443 c->value
444 );
445 break;
446 }
447
448 case DRIVER_COMMAND_INVALIDATE_DATA:
449 {
450 DriverCommandInvalidateData* c = reinterpret_cast<DriverCommandInvalidateData*>(command);
451 driver::DisposeCallbackManager::GetInstance().Dispose(
452 c->mem,
453 c->size
454 );
455 break;
456 }
457
458 case DRIVER_COMMAND_REGIST_DISPOSE_CALLBACK:
459 {
460 DriverCommandDisposeCallback* c = reinterpret_cast<DriverCommandDisposeCallback*>(command);
461 driver::DisposeCallbackManager::GetInstance().RegisterDisposeCallback(
462 c->callback
463 );
464 break;
465 }
466
467 case DRIVER_COMMAND_UNREGIST_DISPOSE_CALLBACK:
468 {
469 DriverCommandDisposeCallback* c = reinterpret_cast<DriverCommandDisposeCallback*>(command);
470 driver::DisposeCallbackManager::GetInstance().UnregisterDisposeCallback(
471 c->callback
472 );
473 break;
474 }
475
476 case DRIVER_COMMAND_APPEND_EFFECT:
477 {
478 DriverCommandEffect* c = reinterpret_cast<DriverCommandEffect*>(command);
479 internal::driver::HardwareManager::GetInstance().AppendEffect(
480 c->bus,
481 c->effect
482 );
483 break;
484 }
485
486 case DRIVER_COMMAND_CLEAR_EFFECT:
487 {
488 DriverCommandEffect* c = reinterpret_cast<DriverCommandEffect*>(command);
489 internal::driver::HardwareManager::GetInstance().ClearEffect(
490 c->bus,
491 c->fadeTimes
492 );
493 break;
494 }
495
496 case DRIVER_COMMAND_DEBUG:
497 {
498 DriverCommandDebug* c = reinterpret_cast<DriverCommandDebug*>(command);
499 NN_LOG("[CMD] %s\n", c->str );
500 break;
501 }
502
503 case DRIVER_COMMAND_ALLVOICES_SYNC:
504 {
505 DriverCommandAllVoicesSync* c =
506 reinterpret_cast<DriverCommandAllVoicesSync*>(command);
507 driver::VoiceManager::GetInstance().UpdateAllVoicesSync( c->syncFlag );
508 break;
509 }
510
511 } // switch
512
513 command = command->next;
514
515 } // while
516 }
517
518 } // namespace nw::snd::internal
519 } // namespace nw::snd
520 } // namespace nw
521