PS2SDK
PS2 Homebrew Libraries
Loading...
Searching...
No Matches
rsd_com.c
1/*
2# _____ ___ ____ ___ ____
3# ____| | ____| | | |____|
4# | ___| |____ ___| ____| | \ PS2DEV Open Source Project.
5#-----------------------------------------------------------------------
6# Copyright ps2dev - http://www.ps2dev.org
7# Licenced under Academic Free License version 2.0
8# Review ps2sdk README & LICENSE files for further details.
9*/
10
11#include "rs_i.h"
12
13static int ret = 0;
14static int gMultiVoiceNum = 0;
15#ifndef LIB_OSD_100
16static volatile int g_AutoDmaIntrCount = 0;
17static int g_AutoDmaInProcessing = 0;
18#endif
19
20SpuStEnv *gStPtr;
21int gStThid;
22static char seq_table[3520]; // sizeof(libsnd2_sequence_struct_t) * 20
23static SpuVoiceAttr s_attr;
24static SpuCommonAttr c_attr;
25static char spu_malloc_rec[1032]; // sizeof(libspu2_malloc_t) * 129
26static SpuReverbAttr r_attr;
27static int gRpcArg[384];
28static char status[24];
29SpuStEnv gStBuff;
30
31#ifndef LIB_OSD_100
32static u8 *g_AutoDmaBuf;
33static int g_AutoDmaBufSize;
34#endif
35
36#ifndef LIB_OSD_100
37static void AutoDmaStatusCB(void)
38{
39 if ( g_AutoDmaIntrCount < 4 && g_AutoDmaIntrCount >= 0 )
40 g_AutoDmaIntrCount += 1;
41}
42
43#ifdef LIB_OSD_110
44static void AutoDmaClearBuffer(void)
45{
46 SpuSetTransferStartAddr(0x4800u);
47 SpuWrite0(0x800u);
48 SpuIsTransferCompleted(1);
49}
50#endif
51#endif
52
53void sce_spu2_loop(void *userdata)
54{
55 SifRpcDataQueue_t qd;
56 SifRpcServerData_t sd;
57
58 (void)userdata;
59
60 CpuEnableIntr();
61 EnableIntr(IOP_IRQ_DMA_SPU);
62 EnableIntr(IOP_IRQ_DMA_SPU2);
63 EnableIntr(IOP_IRQ_SPU);
64 sceSifSetRpcQueue(&qd, GetThreadId());
65 sceSifRegisterRpc(&sd, sce_SPU_DEV, (SifRpcFunc_t)spuFunc, gRpcArg, 0, 0, &qd);
66 sceSifRpcLoop(&qd);
67}
68
69int AutoDmaWaitForCompletion(unsigned int played_size, int start_wait_count)
70{
71 for ( ; start_wait_count <= 949999; start_wait_count += 1 )
72 {
73 unsigned int v3;
74 unsigned int v4;
75
76 v3 = SpuAutoDMAGetStatus();
77 if ( (((v3 >> 24)) & 0xFF) == 1 )
78 v4 = (v3 & 0xFFFFFF) - (u32)g_AutoDmaBuf - g_AutoDmaBufSize / 2;
79 else
80 v4 = (v3 & 0xFFFFFF) - (u32)g_AutoDmaBuf;
81 if ( v4 >= played_size )
82 break;
83 __asm__ __volatile__("" : "+g"(start_wait_count) : :);
84 }
85 return start_wait_count;
86}
87
88void *spuFunc(unsigned int command, void *data, int size)
89{
90 (void)size;
91
92 switch ( command )
93 {
94 case 0x0001:
95 SpuInit();
96 break;
97 case 0x0002:
98 ret = SpuSetCore(*((u32 *)data + 1));
99 break;
100 case 0x0005:
101 SpuSetKey(*((u32 *)data + 1), *((u32 *)data + 2));
102 break;
103 case 0x0006:
104 ret = SpuSetReverb(*((u32 *)data + 1));
105 break;
106 case 0x0007:
107 ret = SpuClearReverbWorkArea(*((u32 *)data + 1));
108 break;
109 case 0x0008:
110 SpuSetReverbEndAddr(*((u32 *)data + 1));
111 break;
112 case 0x000A:
113 SpuSetReverbModeDepth(*((u16 *)data + 2), *((u16 *)data + 4));
114 break;
115 case 0x000B:
116 ret = SpuSetReverbVoice(*((u32 *)data + 1), *((u32 *)data + 2));
117 break;
118 case 0x000C:
119 ret = SpuSetIRQ(*((u32 *)data + 1));
120 break;
121 case 0x000D:
122 ret = SpuSetIRQAddr(*((u32 *)data + 1));
123 break;
124 case 0x000E:
125 ret = SpuSetTransferMode(*((u32 *)data + 1));
126 break;
127 case 0x0010:
128 ret = SpuSetTransferStartAddr(*((u32 *)data + 1));
129 break;
130 case 0x0011:
131 ret = SpuWrite(*((u8 **)data + 1), *((u32 *)data + 2));
132 break;
133 case 0x0012:
134 ret = SpuWrite0(*((u32 *)data + 1));
135 break;
136 case 0x0013:
137 ret = SpuIsTransferCompleted(*((u32 *)data + 1));
138 break;
139 case 0x0017:
140 ret = SpuGetReverbEndAddr();
141 break;
142 case 0x0018:
143 ret = SpuWritePartly(*((u8 **)data + 1), *((u32 *)data + 2));
144 break;
145 case 0x0019:
146 SpuInitHot();
147 break;
148 case 0x001A:
149 ret = SpuIsReverbWorkAreaReserved(*((u32 *)data + 1));
150 break;
151 case 0x001B:
152 ret = SpuMallocWithStartAddr(*((u32 *)data + 1), *((u32 *)data + 2));
153 break;
154 case 0x001C:
155 ret = SpuRead(*((u8 **)data + 1), *((u32 *)data + 2));
156 break;
157 case 0x001D:
158 ret = SpuReadDecodedData(*((SpuDecodedData **)data + 1), *((u32 *)data + 2));
159 break;
160 case 0x001E:
161 ret = SpuReserveReverbWorkArea(*((u32 *)data + 1));
162 break;
163 case 0x0020:
164 ret = SpuSetMute(*((u32 *)data + 1));
165 break;
166 case 0x0021:
167 ret = SpuSetNoiseClock(*((u32 *)data + 1));
168 break;
169 case 0x0022:
170 ret = SpuSetNoiseVoice(*((u32 *)data + 1), *((u32 *)data + 2));
171 break;
172 case 0x0023:
173 ret = SpuSetPitchLFOVoice(*((u32 *)data + 1), *((u32 *)data + 2));
174 break;
175 case 0x0024:
176 ret = SpuStGetStatus();
177 break;
178 case 0x0025:
179 ret = SpuStGetVoiceStatus();
180 break;
181 case 0x0100:
182 ret = SpuInitMalloc(*((u32 *)data + 1), spu_malloc_rec);
183 break;
184 case 0x0101:
185 ret = SpuMalloc(*((u32 *)data + 1));
186 break;
187 case 0x0200:
188 {
189 gStPtr = SpuStInit(*((u32 *)data + 1));
190 ret = (int)&gStBuff;
191 SpuStSetPreparationFinishedCallback(spustCB_preparation_finished);
192 SpuStSetTransferFinishedCallback(spustCB_transfer_finished);
193 SpuStSetStreamFinishedCallback(spustCB_stream_finished);
194 break;
195 }
196 case 0x0201:
197 ret = SpuStQuit();
198 break;
199 case 0x0202:
200 {
201 memcpy(gStPtr, &gStBuff, sizeof(SpuStEnv));
202 ret = SpuStTransfer(*((u32 *)data + 1), *((u32 *)data + 2));
203 break;
204 }
205 case 0x0203:
206 ret = SpuStSetCore(*((u32 *)data + 1));
207 break;
208 case 0x100C:
209 ret = SpuGetIRQAddr();
210 break;
211 case 0x1010:
212 ret = SpuFlush(*((u32 *)data + 1));
213 break;
214 case 0x1011:
215 SpuFree(*((u32 *)data + 1));
216 break;
217 case 0x1013:
218 ret = SpuGetIRQ();
219 break;
220 case 0x1014:
221 ret = SpuGetMute();
222 break;
223 case 0x1015:
224 ret = SpuGetNoiseClock();
225 break;
226 case 0x1016:
227 ret = SpuGetNoiseVoice();
228 break;
229 case 0x1017:
230 ret = SpuGetPitchLFOVoice();
231 break;
232 case 0x1018:
233 ret = SpuGetReverb();
234 break;
235 case 0x1019:
236 ret = SpuGetReverbVoice();
237 break;
238 case 0x101A:
239 ret = SpuGetTransferMode();
240 break;
241 case 0x101B:
242 ret = SpuGetTransferStartAddr();
243 break;
244 case 0x101C:
245 ret = SpuGetKeyStatus(*((u32 *)data + 1));
246 break;
247 case 0x1020:
248 {
249#ifdef LIB_OSD_100
250 ret = SpuAutoDMAWrite(*((u8 **)data + 1), *((u32 *)data + 2), *((u32 *)data + 3));
251#else
252 if ( g_AutoDmaInProcessing )
253 {
254 ret = 0;
255 }
256 else
257 {
258 u32 *v7;
259 int ii;
260 int jj;
261 int kk;
262
263#ifdef LIB_OSD_110
264 AutoDmaClearBuffer();
265#endif
266 SpuAutoDMASetCallback(AutoDmaStatusCB);
267 g_AutoDmaBuf = (u8 *)*((u32 *)data + 1);
268 g_AutoDmaBufSize = *((u32 *)data + 2);
269 v7 = (u32 *)(g_AutoDmaBuf + 0x3000);
270 memset((void *)g_AutoDmaBuf, 0, 0x3000);
271 for ( ii = 0; ii < 512; ii += 128 )
272 {
273 for ( jj = 0; jj < 128; jj += 1 )
274 {
275 v7[jj] = v7[jj] / 512 * (jj + ii);
276 }
277 for ( kk = 0; kk < 128; kk += 1 )
278 {
279 v7[kk] = v7[kk] / 512 * (kk + ii);
280 }
281 }
282 g_AutoDmaIntrCount = 10;
283 ret = SpuAutoDMAWrite(*((u8 **)data + 1), *((u32 *)data + 2), *((u32 *)data + 3));
284 g_AutoDmaInProcessing = 1;
285 }
286#endif
287 break;
288 }
289 case 0x1021:
290 {
291#ifdef LIB_OSD_100
292 SpuAutoDMAStop();
293#else
294 int n;
295 u32 *v3;
296 void *v4;
297 int v5;
298 int v11;
299 int j;
300 int k;
301 int m;
302#ifndef LIB_OSD_110
303 u32 *v12;
304 int v19;
305 int v20;
306 size_t sizea;
307#endif
308
309 if ( g_AutoDmaInProcessing )
310 {
311 v11 = SpuAutoDMAGetStatus();
312 if ( v11 >> 24 == 1 )
313 v5 = (v11 & 0xFFFFFF) - (u32)g_AutoDmaBuf - g_AutoDmaBufSize / 2;
314 else
315 v5 = (v11 & 0xFFFFFF) - (u32)g_AutoDmaBuf;
316#ifdef LIB_OSD_110
317 if ( v5 > 0xbfff )
318#else
319 if ( v5 >= 0x6000 )
320#endif
321 {
322 while ( v5 <= 0xefff )
323 {
324 v5 = SpuAutoDMAGetStatus();
325 if ( v5 >> 24 == 1 )
326 v5 = (v5 & 0xFFFFFF) - (u32)g_AutoDmaBuf - g_AutoDmaBufSize / 2;
327 else
328 v5 = (v5 & 0xFFFFFF) - (u32)g_AutoDmaBuf;
329 }
330#ifndef LIB_OSD_110
331 v19 = 0;
332 v20 = 0x1c00;
333 sizea = 0x2000;
334 g_AutoDmaIntrCount = 0;
335#endif
336 if ( v11 >> 24 == 1 )
337 {
338 v3 = (u32 *)g_AutoDmaBuf;
339 v4 = (void *)(g_AutoDmaBufSize / 2 + g_AutoDmaBuf);
340 }
341 else
342 {
343 v3 = (u32 *)(g_AutoDmaBufSize / 2 + g_AutoDmaBuf);
344 v4 = (void *)g_AutoDmaBuf;
345 }
346 }
347 else
348 {
349#ifndef LIB_OSD_110
350 v19 = ((v5 + 1023) / 1024) << 10;
351 v20 = 0x2000 - ((v19 + ((((v5 + 1023) / 1024) & 0x200000) != 0 ? 0x3FF : 0)) >> 10 << 7);
352 sizea = 0;
353 g_AutoDmaIntrCount = 0;
354#endif
355 if ( v11 >> 24 == 1 )
356 {
357 v3 = (u32 *)(g_AutoDmaBufSize / 2 + g_AutoDmaBuf);
358 v4 = (void *)g_AutoDmaBuf;
359 }
360 else
361 {
362 v3 = (u32 *)g_AutoDmaBuf;
363 v4 = (void *)(g_AutoDmaBufSize / 2 + g_AutoDmaBuf);
364 }
365 }
366#ifdef LIB_OSD_110
367 for ( j = 0; j < 0x2000; j += 128 )
368 {
369 for ( k = 0; k < 128; k += 1 )
370 {
371 v3[k] = v3[k] / 0x2000 * (0x2000 - j - k);
372 }
373 for ( m = 0; m < 128; m += 1 )
374 {
375 v3[m] = v3[m] / 0x2000 * (0x2000 - j - m);
376 }
377 }
378 memset(v4, 0, g_AutoDmaBufSize / 2);
379 g_AutoDmaIntrCount = 0;
380 for ( n = 0; g_AutoDmaIntrCount < 2 && n <= 949999; n += 1 )
381 {
382 __asm__ __volatile__("" : "+g"(n) : :);
383 }
384#else
385 v12 = &v3[v19 / 4];
386 for ( j = 0; j < v20; j += 128 )
387 {
388 for ( k = 0; k < 128; k += 1 )
389 {
390 if ( !v20 )
391 __builtin_trap();
392 if ( v20 == -1 && *v12 == 0x80000000 )
393 __builtin_trap();
394 v12[k] = v12[k] / v20 * (v20 - k - j);
395 }
396 for ( m = 0; m < 128; m += 1 )
397 {
398 if ( !v20 )
399 __builtin_trap();
400 if ( v20 == -1 && *v12 == 0x80000000 )
401 __builtin_trap();
402 v12[m] = v12[m] / v20 * (v20 - m - j);
403 }
404 }
405 if ( sizea )
406 memset(v12, 0, sizea);
407 if ( v5 >= 0x6000 )
408 {
409 n = 0;
410 for ( ; g_AutoDmaIntrCount <= 0 && n <= 949999; n += 1 )
411 {
412 __asm__ __volatile__("" : "+g"(n) : :);
413 }
414 memset(v4, 0, g_AutoDmaBufSize / 2);
415 for ( ; g_AutoDmaIntrCount < 2 && n <= 949999; n += 1 )
416 {
417 __asm__ __volatile__("" : "+g"(n) : :);
418 }
419 }
420 else
421 {
422 n = AutoDmaWaitForCompletion(0xF000u, 0);
423 memset(v4, 0, g_AutoDmaBufSize / 2);
424 for ( ; g_AutoDmaIntrCount <= 0 && n <= 949999; n += 1 )
425 {
426 __asm__ __volatile__("" : "+g"(n) : :);
427 }
428 }
429 memset(v3, 0, g_AutoDmaBufSize / 2);
430 AutoDmaWaitForCompletion(0x4001 - sizea, n);
431#endif
432 SpuAutoDMAStop();
433#ifdef LIB_OSD_110
434 AutoDmaClearBuffer();
435#endif
436 g_AutoDmaInProcessing = 0;
437 }
438#endif
439 break;
440 }
441 case 0x1022:
442 ret = SpuAutoDMAGetStatus();
443 break;
444 case 0x1023:
445 SpuSetAutoDMAAttr(*((u16 *)data + 2), *((u16 *)data + 4), *((u16 *)data + 6), *((u16 *)data + 8));
446 break;
447 case 0x1024:
448 SpuSetSerialInAttr(*((u16 *)data + 2), *((u16 *)data + 4));
449 break;
450 case 0x1030:
451 gMultiVoiceNum = *((u32 *)data + 1);
452 break;
453 case 0x1031:
454 SpuSetDigitalOut(*((u32 *)data + 1));
455 break;
456 case 0x4001:
457 ret = SsBlockVoiceAllocation();
458 break;
459 case 0x4002:
460 SsEnd();
461 break;
462 case 0x4003:
463 SsChannelMute(*((u16 *)data + 2), *((u16 *)data + 4), *((u32 *)data + 3));
464 break;
465 case 0x4004:
466 ret = SsGetActualProgFromProg(*((u16 *)data + 2), *((u16 *)data + 4));
467 break;
468 case 0x4005:
469 ret = SsGetChannelMute(*((u16 *)data + 2), *((u16 *)data + 4));
470 break;
471 case 0x4006:
472 ret = (int)SsGetCurrentPoint(*((u16 *)data + 2), *((u16 *)data + 4));
473 break;
474 case 0x4007:
475 ret = SsGetVoiceMask();
476 break;
477 case 0x4008:
478 SsInit();
479 break;
480 case 0x4009:
481 ret = SsIsEos(*((u16 *)data + 2), *((u16 *)data + 4));
482 break;
483 case 0x400A:
484 SsAllocateVoices(*((u8 *)data + 4), *((u8 *)data + 8));
485 break;
486 case 0x4010:
487 SsPitchCorrect(*((u16 *)data + 2));
488 break;
489 case 0x4011:
490 ret = (u16)SsPitchFromNote(*((u16 *)data + 2), *((u16 *)data + 4), *((u8 *)data + 12), *((u8 *)data + 16));
491 break;
492 case 0x4012:
493 SsPlayBack(*((u16 *)data + 2), *((u16 *)data + 4), *((u16 *)data + 6));
494 break;
495 case 0x4013:
496 SsQueueKeyOn(*((u32 *)data + 1));
497 break;
498 case 0x4014:
499 SsQueueReverb(*((u32 *)data + 1), *((u32 *)data + 2));
500 break;
501 case 0x4015:
502 SsQuit();
503 break;
504 case 0x4017:
505 SsSetTableSize(seq_table, *((u16 *)data + 4), *((u16 *)data + 6));
506 break;
507 case 0x4018:
508 SsSetTickMode(*((u32 *)data + 1));
509 break;
510 case 0x4019:
511 SsSepClose(*((u16 *)data + 2));
512 break;
513 case 0x4020:
514 ret = SsSepOpen((unsigned int *)data + 1, *((u16 *)data + 4), *((u16 *)data + 6));
515 break;
516 case 0x4021:
517 SsSepPause(*((u16 *)data + 2), *((u16 *)data + 4));
518 break;
519 case 0x4022:
520 SsSepPlay(*((u16 *)data + 2), *((u16 *)data + 4), *((u8 *)data + 12), *((u16 *)data + 8));
521 break;
522 case 0x4023:
523 SsSepReplay(*((u16 *)data + 2), *((u16 *)data + 4));
524 break;
525 case 0x4024:
526 SsSepSetAccelerando(*((u16 *)data + 2), *((u16 *)data + 4), *((u32 *)data + 3), *((u32 *)data + 4));
527 break;
528 case 0x4025:
529 SsSepSetCrescendo(*((u16 *)data + 2), *((u16 *)data + 4), *((u16 *)data + 6), *((u32 *)data + 4));
530 break;
531 case 0x4026:
532 SsSepSetDecrescendo(*((u16 *)data + 2), *((u16 *)data + 4), *((u16 *)data + 6), *((u32 *)data + 4));
533 break;
534 case 0x4027:
535 SsSepSetRitardando(*((u16 *)data + 2), *((u16 *)data + 4), *((u32 *)data + 3), *((u32 *)data + 4));
536 break;
537 case 0x4028:
538 SsSepSetVol(*((u16 *)data + 2), *((u16 *)data + 4), *((u16 *)data + 6), *((u16 *)data + 8));
539 break;
540 case 0x4029:
541 SsSepStop(*((u16 *)data + 2), *((u16 *)data + 4));
542 break;
543 case 0x4030:
544 SsSeqGetVol(*((u16 *)data + 2), *((u16 *)data + 4), (s16 *)data + 6, (s16 *)data + 8);
545 break;
546 case 0x4031:
547 ret = SsSeqOpen(*((unsigned int **)data + 1), *((u16 *)data + 4));
548 break;
549 case 0x4032:
550 SsSeqPause(*((u16 *)data + 2));
551 break;
552 case 0x4033:
553 SsSeqPlayPtoP(
554 *((u16 *)data + 2),
555 *((u16 *)data + 4),
556 *((u8 **)data + 3),
557 *((u8 **)data + 4),
558 *((u8 *)data + 20),
559 *((u16 *)data + 12));
560 break;
561 case 0x4034:
562 SsSeqReplay(*((u16 *)data + 2));
563 break;
564 case 0x4035:
565 SsSeqSetAccelerando(*((u16 *)data + 2), *((u32 *)data + 2), *((u32 *)data + 3));
566 break;
567 case 0x4036:
568 SsSeqSetCrescendo(*((u16 *)data + 2), *((u16 *)data + 4), *((u32 *)data + 3));
569 break;
570 case 0x4037:
571 SsSeqSetDecrescendo(*((u16 *)data + 2), *((u16 *)data + 4), *((u32 *)data + 3));
572 break;
573 case 0x4038:
574 SsSeqSetRitardando(*((u16 *)data + 2), *((u32 *)data + 2), *((u32 *)data + 3));
575 break;
576 case 0x4039:
577 SsSeqSetNext(*((u16 *)data + 2), *((u16 *)data + 4));
578 break;
579 case 0x4040:
580 SsSeqCalledTbyT();
581 break;
582 case 0x4041:
583 SsSeqClose(*((u16 *)data + 2));
584 break;
585 case 0x4042:
586 SsSeqPlay(*((u16 *)data + 2), *((u8 *)data + 8), *((u16 *)data + 6));
587 break;
588 case 0x4043:
589 SsSeqSetVol(*((u16 *)data + 2), *((u16 *)data + 4), *((u16 *)data + 6));
590 break;
591 case 0x4044:
592 SsSeqSkip(*((u16 *)data + 2), *((u16 *)data + 4), *((u8 *)data + 12), *((u16 *)data + 8));
593 break;
594 case 0x4045:
595 SsSeqStop(*((u16 *)data + 2));
596 break;
597 case 0x4046:
598 SsSetAutoKeyOffMode(*((u16 *)data + 2));
599 break;
600 case 0x4047:
601 SsSetCurrentPoint(*((u16 *)data + 2), *((u16 *)data + 4), *((u8 **)data + 3));
602 break;
603 case 0x4048:
604 SsSetLoop(*((u16 *)data + 2), *((u16 *)data + 4), *((u16 *)data + 6));
605 break;
606 case 0x4049:
607 SsSetMono();
608 break;
609 case 0x404A:
610 SsSetMVol(*((u16 *)data + 2), *((u16 *)data + 4));
611 break;
612 case 0x4050:
613 SsSetNext(*((u16 *)data + 2), *((u16 *)data + 4), *((u16 *)data + 6), *((u16 *)data + 8));
614 break;
615 case 0x4051:
616 ret = SsSetReservedVoice(*((u8 *)data + 4));
617 break;
618 case 0x4052:
619 SsSetStereo();
620 break;
621 case 0x4053:
622 SsSetTempo(*((u16 *)data + 2), *((u16 *)data + 4), *((u16 *)data + 6));
623 break;
624 case 0x4054:
625 SsSetVoiceMask(*((u32 *)data + 1));
626 break;
627 case 0x4055:
628 SsStart();
629 break;
630 case 0x4056:
631 SsStart2();
632 break;
633 case 0x4057:
634 ret = SsUnBlockVoiceAllocation();
635 break;
636 case 0x4058:
637 SsUtFlush();
638 break;
639 case 0x4059:
640 ret = SsUtGetVagAddr(*((u16 *)data + 2), *((u16 *)data + 4));
641 break;
642 case 0x4060:
643 ret = SsUtGetVagAddrFromTone(*((u16 *)data + 2), *((u16 *)data + 4), *((u16 *)data + 6));
644 break;
645 case 0x4061:
646 ret = SsUtGetVBaddrInSB(*((u16 *)data + 2));
647 break;
648 case 0x4062:
649 SsVabClose(*((u16 *)data + 2));
650 break;
651 case 0x4063:
652 ret = SsVabOpenHead(*((u8 **)data + 1), *((u16 *)data + 4));
653 break;
654 case 0x4064:
655 ret = SsVabTransBodyPartly(*((u8 **)data + 1), *((u32 *)data + 2), *((u16 *)data + 6));
656 break;
657 case 0x4065:
658 ret = SsVabTransCompleted(*((u16 *)data + 2));
659 break;
660 case 0x4066:
661 SsVabTransBody(*((u8 **)data + 1), *((u16 *)data + 4));
662 break;
663 case 0x4067:
664 ret = SsVoiceCheck(*((u32 *)data + 1), *((u32 *)data + 2), *((u16 *)data + 6));
665 break;
666 case 0x4068:
667 ret = SsVoKeyOff(*((u32 *)data + 1), *((u32 *)data + 2));
668 break;
669 case 0x4069:
670 ret = SsVoKeyOn(*((u32 *)data + 1), *((u32 *)data + 2), *((u16 *)data + 6), *((u16 *)data + 8));
671 break;
672 case 0x4070:
673 ret = SsVabOpenHeadSticky(*((u8 **)data + 1), *((u16 *)data + 4), *((u32 *)data + 3));
674 break;
675#if 0
676 case 0x5001:
677 StInit();
678 break;
679 case 0x5002:
680 StQuit();
681 break;
682 case 0x5003:
683 StCalledVSync();
684 break;
685 case 0x5005:
686 ret = (s16)StVabOpen(*((s16 **)data + 1), *((u32 *)data + 2), *((u32 *)data + 3));
687 break;
688 case 0x5006:
689 ret = (s16)StVabOpenFakeBody(*((u32 *)data + 1), *((u32 *)data + 2));
690 break;
691 case 0x5007:
692 StVabOpenCompleted();
693 break;
694 case 0x5008:
695 ret = (s16)StVabClose(*((u16 *)data + 2));
696 break;
697 case 0x5009:
698 ret = (s16)StBgmOpen(*((u16 *)data + 2), *((u32 *)data + 2));
699 break;
700 case 0x500A:
701 StSetTickMode(*((u16 *)data + 2));
702 break;
703 case 0x500B:
704 ret = (s16)StBgmClose(*((u16 *)data + 2));
705 break;
706 case 0x500C:
707 StSetReverbType(*((u16 *)data + 2), *((u16 *)data + 4));
708 break;
709 case 0x500D:
710 StSetReverbDepth(*((u16 *)data + 2), *((u16 *)data + 4), *((u16 *)data + 6));
711 break;
712 case 0x500E:
713 StSetReverbDelaytime(*((u16 *)data + 2), *((u16 *)data + 4));
714 break;
715 case 0x500F:
716 StSetReverbFeedback(*((u16 *)data + 2), *((u16 *)data + 4));
717 break;
718 case 0x5010:
719 ret = StGetSlotStatus(*((u16 *)data + 2));
720 break;
721 case 0x5011:
722 StSetSbClear(*((u32 *)data + 1));
723 break;
724 case 0x5012:
725 StSetMasterVol(*((u16 *)data + 2), *((u16 *)data + 4), *((u16 *)data + 6));
726 break;
727 case 0x5013:
728 ret = (s16)StSetBgmVol(*((u16 *)data + 2), *((u16 *)data + 4));
729 break;
730 case 0x5014:
731 StBgmPlay(*((u16 *)data + 2));
732 break;
733 case 0x5015:
734 StBgmStop(*((u16 *)data + 2), *((u16 *)data + 4), *((u32 *)data + 3));
735 break;
736 case 0x5016:
737 StSetBgmTempo(*((u16 *)data + 2), *((u16 *)data + 4));
738 break;
739 case 0x5017:
740 ret = (s16)StGetBgmTempo(*((u16 *)data + 2));
741 break;
742 case 0x5018:
743 ret = (s16)StGetBgmStatus();
744 break;
745 case 0x5019:
746 ret = (s16)StGetBgmChStatus();
747 break;
748 case 0x501A:
749 ret = (s16)StDmaWrite(*((s16 **)data + 1), *((u32 *)data + 2), *((u32 *)data + 3));
750 break;
751 case 0x501B:
752 ret = (s16)StDmaRead(*((u32 *)data + 1), *((u8 **)data + 2), *((u32 *)data + 3));
753 break;
754 case 0x5100:
755 ret = SetTimer(&common);
756 break;
757 case 0x5101:
758 ret = ReleaseTimer();
759 break;
760 case 0x5200:
761 ret = StSePlay(*((u16 *)data + 2), *((u16 *)data + 4));
762 break;
763 case 0x5201:
764 ret = StSetSeVol(*((u16 *)data + 2), *((u16 *)data + 4));
765 break;
766#endif
767 case 0x6128:
768 {
769 SpuGetCommonAttr(&c_attr);
770 return &c_attr;
771 }
772 case 0x6240:
773 {
774 s_attr.voice = *((u32 *)data + 2);
775 SpuGetVoiceAttr(&s_attr);
776 return &s_attr;
777 }
778 case 0x6314:
779 {
780 SpuGetReverbModeParam(&r_attr);
781 return &r_attr;
782 }
783 case 0x6418:
784 {
785 SpuGetAllKeysStatus(status);
786 return status;
787 }
788 case 0x7128:
789 SpuSetCommonAttr((SpuCommonAttr *)data);
790 break;
791 case 0x7240:
792 SpuSetVoiceAttr((SpuVoiceAttr *)data);
793 break;
794 case 0x7314:
795 SpuSetReverbModeParam((SpuReverbAttr *)data);
796 break;
797 case 0x7440:
798 SpuSetKeyOnWithAttr((SpuVoiceAttr *)data);
799 break;
800 case 0x7508:
801 SpuSetEnv((const SpuEnv *)data);
802 break;
803 case 0x7600:
804 {
805 int i;
806
807 for ( i = 0; i < gMultiVoiceNum; i += 1 )
808 SpuSetVoiceAttr((SpuVoiceAttr *)data + i);
809 break;
810 }
811 case 0x8100:
812 SpuSetTransferCallback(DMA1CallBackProc);
813 break;
814 case 0x8200:
815 SpuSetIRQCallback(IRQCallBackProc);
816 break;
817 case 0x8600:
818 SpuAutoDMASetCallback(DMA0CallBackProc);
819 break;
820 case 0xE621:
821 {
822 iop_thread_t param;
823
824 param.attr = TH_C;
825 param.thread = sce_spust_loop;
826 param.priority = 34;
827#ifdef LIB_OSD_100
828 param.stacksize = 2048;
829#else
830 param.stacksize = 4096;
831#endif
832 param.option = 0;
833 gStThid = CreateThread(&param);
834 StartThread(gStThid, 0);
835 break;
836 }
837 }
838
839 return &ret;
840}
CpuEnableIntr
int CpuEnableIntr()
Definition intrman.c:250
EnableIntr
int EnableIntr(int irq)
Definition intrman.c:346
t_SifRpcDataQueue
Definition sifrpc-common.h:154
t_SifRpcServerData
Definition sifrpc-common.h:99
SpuCommonAttr_
Definition libspu2.h:298
SpuDecodedData_
Definition libspu2.h:283
SpuEnv_
Definition libspu2.h:311
SpuReverbAttr_
Definition libspu2.h:274
SpuStEnv_
Definition libspu2.h:328
SpuVoiceAttr_
Definition libspu2.h:242
_iop_thread
Definition thbase.h:40