sdk-core v2026.11.05
PS2 SDK - core tier (build-critical EE/IOP modules)
Loading...
Searching...
No Matches
sdhd.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#ifdef _IOP
12#include "irx_imports.h"
13#else
14#include <stdint.h>
15typedef int8_t s8;
16typedef int16_t s16;
17typedef int32_t s32;
18typedef uint8_t u8;
19typedef uint16_t u16;
20typedef uint32_t u32;
21#endif
22#include <sdhd.h>
23
24#ifdef _IOP
25IRX_ID("Sound_Data_HD", 2, 2);
26#endif
27// Based on the module from SCE SDK 3.1.0.
28
29struct sceHardSynthVersionChunk_
30{
31 unsigned int Creator;
32 unsigned int Type;
33 unsigned int chunkSize;
34 u16 reserved;
35 u8 versionMajor;
36 u8 versionMinor;
37};
38
39typedef struct sceHardSynthVersionChunk_ sceHardSynthVersionChunk;
40typedef struct sceHardSynthVersionChunk_ sceSeqVersionChunk;
41
42typedef struct sceHardSynthHeaderChunk_
43{
44 unsigned int Creator;
45 unsigned int Type;
46 unsigned int chunkSize;
47 unsigned int headerSize;
48 unsigned int bodySize;
49 unsigned int programChunkAddr;
50 unsigned int sampleSetChunkAddr;
51 unsigned int sampleChunkAddr;
52 unsigned int vagInfoChunkAddr;
53 unsigned int seTimbreChunkAddr;
54} sceHardSynthHeaderChunk;
55
56typedef struct sceHardSynthProgramChunk_
57{
58 unsigned int Creator;
59 unsigned int Type;
60 unsigned int chunkSize;
61 unsigned int maxProgramNumber;
62 unsigned int programOffsetAddr[];
63} sceHardSynthProgramChunk;
64
65typedef struct sceHardSynthSampleSetChunk_
66{
67 unsigned int Creator;
68 unsigned int Type;
69 unsigned int chunkSize;
70 unsigned int maxSampleSetNumber;
71 unsigned int sampleSetOffsetAddr[];
72} sceHardSynthSampleSetChunk;
73
74typedef struct sceHardSynthSampleChunk_
75{
76 unsigned int Creator;
77 unsigned int Type;
78 unsigned int chunkSize;
79 unsigned int maxSampleNumber;
80 unsigned int sampleOffsetAddr[];
81} sceHardSynthSampleChunk;
82
83typedef struct sceHardSynthVagInfoChunk
84{
85 unsigned int Creator;
86 unsigned int Type;
87 unsigned int chunkSize;
88 unsigned int maxVagInfoNumber;
89 unsigned int vagInfoOffsetAddr[];
90} sceHardSynthVagInfoChunk;
91
92struct sdhd_info
93{
94 sceHardSynthVersionChunk *m_vers;
95 sceHardSynthHeaderChunk *m_head;
96 sceHardSynthProgramChunk *m_prog;
97 sceHardSynthSampleSetChunk *m_sset;
98 sceHardSynthSampleChunk *m_smpl;
99 sceHardSynthVagInfoChunk *m_vagi;
100};
101
102#ifdef _IOP
103extern struct irx_export_table _exp_sdhd;
104#endif
105
106static unsigned int do_get_vers_head_chunk(sceHardSynthVersionChunk *indata, struct sdhd_info *dinfo)
107{
108 dinfo->m_vers = 0;
109 dinfo->m_head = 0;
110 dinfo->m_prog = 0;
111 dinfo->m_sset = 0;
112 dinfo->m_smpl = 0;
113 dinfo->m_vagi = 0;
114 dinfo->m_vers = indata;
115 if ( indata->Creator != 0x53434549 || indata->Type != 0x56657273 )
116 {
117 dinfo->m_vers = 0;
118 return 0x8103000E;
119 }
120 if ( (indata->chunkSize & 0x80000000) )
121 {
122 dinfo->m_vers = 0;
123 return 0x8103002F;
124 }
125 dinfo->m_head = (sceHardSynthHeaderChunk *)((char *)indata + indata->chunkSize);
126 if ( dinfo->m_head->Creator != 0x53434549 || dinfo->m_head->Type != 0x48656164 )
127 {
128 dinfo->m_vers = 0;
129 dinfo->m_head = 0;
130 return 0x8103002F;
131 }
132 return 0;
133}
134
135static unsigned int do_get_prog_chunk(void *indata, struct sdhd_info *dinfo)
136{
137 if ( dinfo->m_head->programChunkAddr == 0xFFFFFFFF )
138 return 0x81039005;
139 if ( (dinfo->m_head->programChunkAddr & 0x80000000) )
140 return 0x8103002F;
141 dinfo->m_prog = (sceHardSynthProgramChunk *)((char *)indata + dinfo->m_head->programChunkAddr);
142 if ( dinfo->m_prog->Creator != 0x53434549 || dinfo->m_prog->Type != 0x50726F67 )
143 {
144 dinfo->m_prog = 0;
145 return 0x8103002F;
146 }
147 return 0;
148}
149
150static unsigned int do_get_sset_chunk(void *indata, struct sdhd_info *dinfo)
151{
152 if ( dinfo->m_head->sampleSetChunkAddr == 0xFFFFFFFF )
153 return 0x81039006;
154 if ( (dinfo->m_head->sampleSetChunkAddr & 0x80000000) )
155 return 0x8103002F;
156 dinfo->m_sset = (sceHardSynthSampleSetChunk *)((char *)indata + dinfo->m_head->sampleSetChunkAddr);
157 if ( dinfo->m_sset->Creator != 0x53434549 || dinfo->m_sset->Type != 0x53736574 )
158 {
159 dinfo->m_sset = 0;
160 return 0x8103002F;
161 }
162 return 0;
163}
164
165static unsigned int do_get_smpl_chunk(void *indata, struct sdhd_info *dinfo)
166{
167 if ( dinfo->m_head->sampleChunkAddr == 0xFFFFFFFF )
168 return 0x81039007;
169 if ( (dinfo->m_head->sampleChunkAddr & 0x80000000) )
170 return 0x8103002F;
171 dinfo->m_smpl = (sceHardSynthSampleChunk *)((char *)indata + dinfo->m_head->sampleChunkAddr);
172 if ( dinfo->m_smpl->Creator != 0x53434549 || dinfo->m_smpl->Type != 0x536D706C )
173 {
174 dinfo->m_smpl = 0;
175 return 0x8103002F;
176 }
177 return 0;
178}
179
180static unsigned int do_get_vagi_chunk(void *indata, struct sdhd_info *dinfo)
181{
182 if ( dinfo->m_head->vagInfoChunkAddr == 0xFFFFFFFF )
183 return 0x81039008;
184 if ( (dinfo->m_head->vagInfoChunkAddr & 0x80000000) )
185 return 0x8103002F;
186 dinfo->m_vagi = (sceHardSynthVagInfoChunk *)((char *)indata + dinfo->m_head->vagInfoChunkAddr);
187 if ( dinfo->m_vagi->Creator != 0x53434549 || dinfo->m_vagi->Type != 0x56616769 )
188 {
189 dinfo->m_vagi = 0;
190 return 0x8103002F;
191 }
192 return 0;
193}
194
195static void do_copy_to_sdhd_program_param(SceSdHdProgramParam *dst, const sceHardSynthProgramParam *src)
196{
197 dst->nSplit = src->nSplit;
198 dst->progAttr = src->progAttr;
199 dst->common.volume = src->progVolume;
200 dst->common.panpot = src->progPanpot;
201 dst->common.transpose = src->progTranspose;
202 dst->common.detune = src->progDetune;
203 dst->keyFollow.pan = src->keyFollowPan;
204 dst->keyFollow.panCenter = src->keyFollowPanCenter;
205 dst->LFO.wavePitch = src->progLfoWave;
206 dst->LFO.waveAmp = src->progLfoWave2;
207 dst->LFO.startPhasePitch = src->progLfoStartPhase;
208 dst->LFO.startPhaseAmp = src->progLfoStartPhase2;
209 dst->LFO.phaseRandomPitch = src->progLfoPhaseRandom;
210 dst->LFO.phaseRandomAmp = src->progLfoPhaseRandom2;
211 dst->LFO.cyclePitch = src->progLfoFreq;
212 dst->LFO.cycleAmp = src->progLfoFreq2;
213 dst->LFO.pitchDepthUp = src->progLfoPitchDepth;
214 dst->LFO.pitchDepthDown = src->progLfoPitchDepth2;
215 dst->LFO.midiPitchDepthUp = src->progLfoMidiPitchDepth;
216 dst->LFO.midiPitchDepthDown = src->progLfoMidiPitchDepth2;
217 dst->LFO.ampDepthUp = src->progLfoAmpDepth;
218 dst->LFO.ampDepthDown = src->progLfoAmpDepth2;
219 dst->LFO.midiAmpDepthUp = src->progLfoMidiAmpDepth;
220 dst->LFO.midiAmpDepthDown = src->progLfoMidiAmpDepth2;
221}
222
223static void do_copy_to_sdhd_split_block(SceSdHdSplitBlock *dst, const sceHardSynthSplitBlock *src)
224{
225 dst->sampleSetIndex = src->sampleSetIndex;
226 dst->splitNumber = src->splitNumber;
227 dst->range.low = src->splitRangeLow;
228 dst->range.crossFade = src->splitCrossFade;
229 dst->range.high = src->splitRangeHigh;
230 dst->bendRange.low = src->splitBendRangeLow;
231 dst->bendRange.high = src->splitBendRangeHigh;
232 dst->keyFollow.pitch = src->keyFollowPitch;
233 dst->keyFollow.pitchCenter = src->keyFollowPitchCenter;
234 dst->keyFollow.amp = src->keyFollowAmp;
235 dst->keyFollow.ampCenter = src->keyFollowAmpCenter;
236 dst->keyFollow.pan = src->keyFollowPan;
237 dst->keyFollow.panCenter = src->keyFollowPanCenter;
238 dst->common.volume = src->splitVolume;
239 dst->common.panpot = src->splitPanpot;
240 dst->common.transpose = src->splitTranspose;
241 dst->common.detune = src->splitDetune;
242}
243
244static void do_copy_to_sdhd_set_param(SceSdHdSampleSetParam *dst, const sceHardSynthSampleSetParam *src)
245{
246 dst->velCurve = src->velCurve;
247 dst->velLimitLow = src->velLimitLow;
248 dst->velLimitHigh = src->velLimitHigh;
249 dst->nSample = src->nSample;
250}
251
252static void do_copy_to_sdhd_sample_param(SceSdHdSampleParam *dst, const sceHardSynthSampleParam *src)
253{
254 dst->vagIndex = src->VagIndex;
255 dst->spuAttr = src->sampleSpuAttr;
256 dst->lfoAttr = src->sampleLfoAttr;
257 dst->velRange.low = src->velRangeLow;
258 dst->velRange.crossFade = src->velCrossFade;
259 dst->velRange.high = src->velRangeHigh;
260 dst->velFollow.pitch = src->velFollowPitch;
261 dst->velFollow.pitchCenter = src->velFollowPitchCenter;
262 dst->velFollow.pitchVelCurve = src->velFollowPitchVelCurve;
263 dst->velFollow.amp = src->velFollowAmp;
264 dst->velFollow.ampCenter = src->velFollowAmpCenter;
265 dst->velFollow.ampVelCurve = src->velFollowAmpVelCurve;
266 dst->common.baseNote = src->sampleBaseNote;
267 dst->common.detune = src->sampleDetune;
268 dst->common.panpot = src->samplePanpot;
269 dst->common.group = src->sampleGroup;
270 dst->common.priority = src->samplePriority;
271 dst->common.volume = src->sampleVolume;
272 dst->ADSR.ADSR1 = src->sampleAdsr1;
273 dst->ADSR.ADSR2 = src->sampleAdsr2;
274 dst->keyFollow.ar = src->keyFollowAr;
275 dst->keyFollow.arCenter = src->keyFollowArCenter;
276 dst->keyFollow.dr = src->keyFollowDr;
277 dst->keyFollow.drCenter = src->keyFollowDrCenter;
278 dst->keyFollow.sr = src->keyFollowSr;
279 dst->keyFollow.srCenter = src->keyFollowSrCenter;
280 dst->keyFollow.rr = src->keyFollowRr;
281 dst->keyFollow.rrCenter = src->keyFollowRrCenter;
282 dst->keyFollow.sl = src->keyFollowSl;
283 dst->keyFollow.slCenter = src->keyFollowSlCenter;
284 dst->LFO.pitchLFODelay = src->samplePitchLfoDelay;
285 dst->LFO.pitchLFOFade = src->samplePitchLfoFade;
286 dst->LFO.ampLFODelay = src->sampleAmpLfoDelay;
287 dst->LFO.ampLFOFade = src->sampleAmpLfoFade;
288}
289
290static void do_copy_to_sdhd_vag_info_param(SceSdHdVAGInfoParam *dst, unsigned int sz, const sceHardSynthVagParam *src)
291{
292 dst->vagOffsetAddr = src->vagOffsetAddr;
293 dst->vagSampleRate = src->vagSampleRate;
294 dst->vagSize = sz;
295 dst->vagAttribute = src->vagAttribute;
296}
297
298static unsigned int do_get_vag_size(sceHardSynthVersionChunk *indata, const unsigned int *vagoffsaddr)
299{
300 unsigned int i;
301 unsigned int bodySize;
302 const sceHardSynthVagParam *vagparam;
303 struct sdhd_info dinfo;
304
305 if ( do_get_vers_head_chunk(indata, &dinfo) || do_get_vagi_chunk(indata, &dinfo) )
306 return 0;
307 bodySize = dinfo.m_head->bodySize;
308 for ( i = 0; dinfo.m_vagi->maxVagInfoNumber >= i; i += 1 )
309 {
310 if ( dinfo.m_vagi->vagInfoOffsetAddr[i] != 0xFFFFFFFF )
311 {
312 vagparam = (sceHardSynthVagParam *)((char *)(dinfo.m_vagi) + dinfo.m_vagi->vagInfoOffsetAddr[i]);
313 if ( *vagoffsaddr < vagparam->vagOffsetAddr && vagparam->vagOffsetAddr < bodySize )
314 bodySize = vagparam->vagOffsetAddr;
315 }
316 }
317 return bodySize - *vagoffsaddr;
318}
319
320static unsigned int
321do_check_chunk_in_bounds(void *indata, const struct sdhd_info *dinfo, unsigned int hdrmagic, unsigned int idx)
322{
323 (void)indata;
324
325 switch ( hdrmagic )
326 {
327 case 0x536D706C:
328 {
329 if ( !dinfo->m_smpl )
330 return 0x8103002F;
331 if ( dinfo->m_smpl->maxSampleNumber < idx )
332 return 0x81039014;
333 if ( dinfo->m_smpl->sampleOffsetAddr[idx] == 0xFFFFFFFF )
334 return 0x81039015;
335 break;
336 }
337 case 0x53736574:
338 {
339 if ( !dinfo->m_sset )
340 return 0x8103002F;
341 if ( dinfo->m_sset->maxSampleSetNumber < idx )
342 return 0x81039012;
343 if ( dinfo->m_sset->sampleSetOffsetAddr[idx] == 0xFFFFFFFF )
344 return 0x81039012;
345 break;
346 }
347 case 0x56616769:
348 {
349 if ( !dinfo->m_vagi )
350 return 0x8103002F;
351 if ( dinfo->m_vagi->maxVagInfoNumber < idx )
352 return 0x81039016;
353 if ( dinfo->m_vagi->vagInfoOffsetAddr[idx] == 0xFFFFFFFF )
354 return 0x81039017;
355 break;
356 }
357 case 0x50726F67:
358 {
359 if ( !dinfo->m_prog )
360 return 0x8103002F;
361 if ( dinfo->m_prog->maxProgramNumber < idx )
362 return 0x81039010;
363 if ( dinfo->m_prog->programOffsetAddr[idx] == 0xFFFFFFFF )
364 return 0x81039011;
365 break;
366 }
367 default:
368 break;
369 }
370 return 0;
371}
372
373static int do_get_common_block_ptr_note(
374 void *buffer,
375 unsigned int programNumber,
376 unsigned int swcase,
377 unsigned int noteNumber,
378 unsigned int velocity,
379 unsigned int mode,
380 void **ptr)
381{
382 int idx1;
383 int i;
384 sceHardSynthSplitBlock *p_splitblock;
385 int j;
386 sceHardSynthProgramParam *p_programparam;
387 sceHardSynthSampleSetParam *p_samplesetparam;
388 sceHardSynthSampleParam *p_sampleparam;
389 sceHardSynthVagParam *p_vagparam;
390
391 idx1 = 0;
392 if (
393 sceSdHdGetProgramParamAddr(buffer, programNumber, &p_programparam) || p_programparam->splitBlockAddr == 0xFFFFFFFF )
394 {
395 return 0;
396 }
397 for ( i = 0; i < p_programparam->nSplit; i += 1 )
398 {
399 p_splitblock = (sceHardSynthSplitBlock *)((char *)p_programparam + p_programparam->splitBlockAddr
400 + p_programparam->sizeSplitBlock * i);
401 if ( noteNumber < (p_splitblock->splitRangeLow & 0x7Fu) || noteNumber > (p_splitblock->splitRangeHigh & 0x7Fu) )
402 {
403 continue;
404 }
405 switch ( swcase )
406 {
407 case 0:
408 idx1 += 1;
409 break;
410 case 1:
411 idx1 += 1;
412 *ptr = p_splitblock;
413 ptr = (void **)(((char *)ptr) + sizeof(void *));
414 break;
415 case 2:
416 idx1 += 1;
417 do_copy_to_sdhd_split_block((SceSdHdSplitBlock *)ptr, p_splitblock);
418 ptr = (void **)(((char *)ptr) + sizeof(SceSdHdSplitBlock));
419 break;
420 default:
421 if (
422 p_splitblock->sampleSetIndex == 0xFFFF
423 || sceSdHdGetSampleSetParamAddr(buffer, p_splitblock->sampleSetIndex, &p_samplesetparam) )
424 {
425 break;
426 }
427 switch ( swcase )
428 {
429 case 3:
430 idx1 += 1;
431 break;
432 case 4:
433 idx1 += 1;
434 *ptr = p_samplesetparam;
435 ptr = (void **)(((char *)ptr) + sizeof(void *));
436 break;
437 case 5:
438 idx1 += 1;
439 do_copy_to_sdhd_set_param((SceSdHdSampleSetParam *)ptr, p_samplesetparam);
440 ptr = (void **)(((char *)ptr) + sizeof(SceSdHdSampleSetParam));
441 break;
442 default:
443 switch ( mode )
444 {
445 case 0:
446 if ( velocity < p_samplesetparam->velLimitLow || velocity > p_samplesetparam->velLimitHigh )
447 {
448 break;
449 }
450 for ( j = 0; j < p_samplesetparam->nSample; j += 1 )
451 {
452 if (
453 p_samplesetparam->sampleIndex[j] != 0xFFFF
454 && !sceSdHdGetSampleParamAddr(buffer, p_samplesetparam->sampleIndex[j], &p_sampleparam)
455 && velocity >= (p_sampleparam->velRangeLow & 0x7Fu)
456 && (p_sampleparam->velRangeHigh & 0x7Fu) >= velocity )
457 {
458 switch ( swcase )
459 {
460 case 6:
461 idx1 += 1;
462 break;
463 case 7:
464 idx1 += 1;
465 *ptr = p_sampleparam;
466 ptr = (void **)(((char *)ptr) + sizeof(void *));
467 break;
468 case 8:
469 idx1 += 1;
470 do_copy_to_sdhd_sample_param((SceSdHdSampleParam *)ptr, p_sampleparam);
471 ptr = (void **)(((char *)ptr) + sizeof(SceSdHdSampleParam));
472 break;
473 default:
474 if (
475 p_sampleparam->VagIndex == 0xFFFF
476 || sceSdHdGetVAGInfoParamAddr(buffer, p_sampleparam->VagIndex, &p_vagparam) )
477 {
478 break;
479 }
480 switch ( swcase )
481 {
482 case 9:
483 idx1 += 1;
484 break;
485 case 10:
486 idx1 += 1;
487 *ptr = p_vagparam;
488 ptr = (void **)(((char *)ptr) + sizeof(void *));
489 break;
490 case 11:
491 idx1 += 1;
492 do_copy_to_sdhd_vag_info_param(
493 (SceSdHdVAGInfoParam *)ptr,
494 do_get_vag_size((sceHardSynthVersionChunk *)buffer, &p_vagparam->vagOffsetAddr),
495 p_vagparam);
496 ptr = (void **)(((char *)ptr) + sizeof(SceSdHdVAGInfoParam));
497 break;
498 default:
499 break;
500 }
501 break;
502 }
503 }
504 }
505 break;
506 case 1:
507 for ( j = 0; j < p_samplesetparam->nSample; j += 1 )
508 {
509 if (
510 p_samplesetparam->sampleIndex[j] != 0xFFFF
511 && !sceSdHdGetSampleParamAddr(buffer, p_samplesetparam->sampleIndex[j], &p_sampleparam)
512 && velocity >= (p_sampleparam->velRangeLow & 0x7Fu)
513 && (p_sampleparam->velRangeHigh & 0x7Fu) >= velocity )
514 {
515 switch ( swcase )
516 {
517 case 6:
518 idx1 += 1;
519 break;
520 case 7:
521 idx1 += 1;
522 *ptr = p_sampleparam;
523 ptr = (void **)(((char *)ptr) + sizeof(void *));
524 break;
525 case 8:
526 idx1 += 1;
527 do_copy_to_sdhd_sample_param((SceSdHdSampleParam *)ptr, p_sampleparam);
528 ptr = (void **)(((char *)ptr) + sizeof(SceSdHdSampleParam));
529 break;
530 default:
531 if (
532 p_sampleparam->VagIndex == 0xFFFF
533 || sceSdHdGetVAGInfoParamAddr(buffer, p_sampleparam->VagIndex, &p_vagparam) )
534 {
535 break;
536 }
537 switch ( swcase )
538 {
539 case 9:
540 idx1 += 1;
541 break;
542 case 10:
543 idx1 += 1;
544 *ptr = p_vagparam;
545 ptr = (void **)(((char *)ptr) + sizeof(void *));
546 break;
547 case 11:
548 idx1 += 1;
549 do_copy_to_sdhd_vag_info_param(
550 (SceSdHdVAGInfoParam *)ptr,
551 do_get_vag_size((sceHardSynthVersionChunk *)buffer, &p_vagparam->vagOffsetAddr),
552 p_vagparam);
553 ptr = (void **)(((char *)ptr) + sizeof(SceSdHdVAGInfoParam));
554 break;
555 default:
556 break;
557 }
558 break;
559 }
560 }
561 }
562 break;
563 default:
564 break;
565 }
566 break;
567 }
568 break;
569 }
570 }
571 return idx1;
572}
573
574static int do_get_common_block_ptr(
575 void *buffer,
576 unsigned int sampleSetNumber,
577 unsigned int swcase,
578 unsigned int velocity,
579 unsigned int mode,
580 void **param)
581{
582 int idx1;
583 int i;
584 sceHardSynthSampleSetParam *p_samplesetparam;
585 sceHardSynthSampleParam *p_sampleparam;
586 sceHardSynthVagParam *p_vagparam;
587
588 idx1 = 0;
589 if ( sceSdHdGetSampleSetParamAddr(buffer, sampleSetNumber, &p_samplesetparam) )
590 return 0;
591 switch ( mode )
592 {
593 case 0:
594 if ( velocity < p_samplesetparam->velLimitLow || velocity > p_samplesetparam->velLimitHigh )
595 return 0;
596 for ( i = 0; i < p_samplesetparam->nSample; i += 1 )
597 {
598 if (
599 p_samplesetparam->sampleIndex[i] != 0xFFFF
600 && !sceSdHdGetSampleParamAddr(buffer, p_samplesetparam->sampleIndex[i], &p_sampleparam)
601 && velocity >= (p_sampleparam->velRangeLow & 0x7Fu) && (p_sampleparam->velRangeHigh & 0x7Fu) >= velocity )
602 {
603 switch ( swcase )
604 {
605 case 6:
606 idx1 += 1;
607 break;
608 case 7:
609 idx1 += 1;
610 *param = p_sampleparam;
611 param = (void **)(((char *)param) + sizeof(void *));
612 break;
613 case 8:
614 idx1 += 1;
615 do_copy_to_sdhd_sample_param((SceSdHdSampleParam *)param, p_sampleparam);
616 param = (void **)(((char *)param) + sizeof(SceSdHdSampleParam));
617 break;
618 default:
619 if (
620 p_sampleparam->VagIndex == 0xFFFF
621 || sceSdHdGetVAGInfoParamAddr(buffer, p_sampleparam->VagIndex, &p_vagparam) )
622 {
623 break;
624 }
625 switch ( swcase )
626 {
627 case 9:
628 idx1 += 1;
629 break;
630 case 10:
631 idx1 += 1;
632 *param = p_vagparam;
633 param = (void **)(((char *)param) + sizeof(void *));
634 break;
635 case 11:
636 idx1 += 1;
637 do_copy_to_sdhd_vag_info_param(
638 (SceSdHdVAGInfoParam *)param,
639 do_get_vag_size((sceHardSynthVersionChunk *)buffer, &p_vagparam->vagOffsetAddr),
640 p_vagparam);
641 param = (void **)(((char *)param) + sizeof(SceSdHdVAGInfoParam));
642 break;
643 default:
644 break;
645 }
646 }
647 }
648 }
649 return idx1;
650 case 1:
651 for ( i = 0; i < p_samplesetparam->nSample; i += 1 )
652 {
653 if (
654 p_samplesetparam->sampleIndex[i] != 0xFFFF
655 && !sceSdHdGetSampleParamAddr(buffer, p_samplesetparam->sampleIndex[i], &p_sampleparam)
656 && velocity >= (p_sampleparam->velRangeLow & 0x7Fu) && (p_sampleparam->velRangeHigh & 0x7Fu) >= velocity )
657 {
658 switch ( swcase )
659 {
660 case 6:
661 idx1 += 1;
662 break;
663 case 7:
664 idx1 += 1;
665 *param = p_sampleparam;
666 param = (void **)(((char *)param) + sizeof(void *));
667 break;
668 case 8:
669 idx1 += 1;
670 do_copy_to_sdhd_sample_param((SceSdHdSampleParam *)param, p_sampleparam);
671 param = (void **)(((char *)param) + sizeof(SceSdHdSampleParam));
672 break;
673 default:
674 if (
675 p_sampleparam->VagIndex == 0xFFFF
676 || sceSdHdGetVAGInfoParamAddr(buffer, p_sampleparam->VagIndex, &p_vagparam) )
677 break;
678 switch ( swcase )
679 {
680 case 9:
681 idx1 += 1;
682 break;
683 case 10:
684 idx1 += 1;
685 *param = p_vagparam;
686 param = (void **)(((char *)param) + sizeof(void *));
687 break;
688 case 11:
689 idx1 += 1;
690 do_copy_to_sdhd_vag_info_param(
691 (SceSdHdVAGInfoParam *)param,
692 do_get_vag_size((sceHardSynthVersionChunk *)buffer, &p_vagparam->vagOffsetAddr),
693 p_vagparam);
694 param = (void **)(((char *)param) + sizeof(SceSdHdVAGInfoParam));
695 break;
696 default:
697 break;
698 }
699 break;
700 }
701 }
702 }
703 return idx1;
704 default:
705 return 0;
706 }
707}
708
709int sceSdHdGetMaxProgramNumber(void *buffer)
710{
711 int result;
712 struct sdhd_info dinfo;
713
714 result = (int)do_get_vers_head_chunk((sceHardSynthVersionChunk *)buffer, &dinfo);
715 if ( result )
716 return result;
717 result = (int)do_get_prog_chunk(buffer, &dinfo);
718 if ( result )
719 return result;
720 return (int)dinfo.m_prog->maxProgramNumber;
721}
722
723int sceSdHdGetMaxSampleSetNumber(void *buffer)
724{
725 int result;
726 struct sdhd_info dinfo;
727
728 result = (int)do_get_vers_head_chunk((sceHardSynthVersionChunk *)buffer, &dinfo);
729 if ( result )
730 return result;
731 result = (int)do_get_sset_chunk(buffer, &dinfo);
732 if ( result )
733 return result;
734 return (int)dinfo.m_sset->maxSampleSetNumber;
735}
736
737int sceSdHdGetMaxSampleNumber(void *buffer)
738{
739 int result;
740 struct sdhd_info dinfo;
741
742 result = (int)do_get_vers_head_chunk((sceHardSynthVersionChunk *)buffer, &dinfo);
743 if ( result )
744 return result;
745 result = (int)do_get_smpl_chunk(buffer, &dinfo);
746 if ( result )
747 return result;
748 return (int)dinfo.m_smpl->maxSampleNumber;
749}
750
751int sceSdHdGetMaxVAGInfoNumber(void *buffer)
752{
753 int result;
754 struct sdhd_info dinfo;
755
756 result = (int)do_get_vers_head_chunk((sceHardSynthVersionChunk *)buffer, &dinfo);
757 if ( result )
758 return result;
759 result = (int)do_get_vagi_chunk(buffer, &dinfo);
760 if ( result )
761 return result;
762 return (int)dinfo.m_vagi->maxVagInfoNumber;
763}
764
765int sceSdHdGetProgramParamAddr(void *buffer, unsigned int programNumber, sceHardSynthProgramParam **ptr)
766{
767 int result;
768 struct sdhd_info dinfo;
769
770 result = (int)do_get_vers_head_chunk((sceHardSynthVersionChunk *)buffer, &dinfo);
771 if ( result )
772 return result;
773 result = (int)do_get_prog_chunk(buffer, &dinfo);
774 if ( result )
775 return result;
776 result = (int)do_check_chunk_in_bounds(buffer, &dinfo, 0x50726F67u, programNumber);
777 if ( result )
778 return result;
779 *ptr = (sceHardSynthProgramParam *)((char *)dinfo.m_prog + dinfo.m_prog->programOffsetAddr[programNumber]);
780 return 0;
781}
782
783int sceSdHdGetProgramParam(void *buffer, unsigned int programNumber, SceSdHdProgramParam *param)
784{
785 int result;
786 sceHardSynthProgramParam *p_programparam;
787
788 result = sceSdHdGetProgramParamAddr(buffer, programNumber, &p_programparam);
789 if ( result )
790 return result;
791 do_copy_to_sdhd_program_param(param, p_programparam);
792 return 0;
793}
794
795int sceSdHdGetSplitBlockAddr(
796 void *buffer, unsigned int programNumber, unsigned int splitBlockNumber, sceHardSynthSplitBlock **theParamPtr)
797{
798 int result;
799 sceHardSynthProgramParam *p_programparam;
800
801 result = sceSdHdGetProgramParamAddr(buffer, programNumber, &p_programparam);
802 if ( result )
803 return result;
804 if ( p_programparam->splitBlockAddr == 0xFFFFFFFF )
805 return (int)0x81039009;
806 if ( (unsigned int)p_programparam->nSplit - 1 < splitBlockNumber )
807 return (int)0x81039018;
808 *theParamPtr = (sceHardSynthSplitBlock *)((char *)p_programparam + p_programparam->splitBlockAddr
809 + p_programparam->sizeSplitBlock * splitBlockNumber);
810 return 0;
811}
812
813int sceSdHdGetSplitBlock(
814 void *buffer, unsigned int programNumber, unsigned int splitBlockNumber, SceSdHdSplitBlock *param)
815{
816 int result;
817 sceHardSynthSplitBlock *p_splitblock;
818
819 result = sceSdHdGetSplitBlockAddr(buffer, programNumber, splitBlockNumber, &p_splitblock);
820 if ( result )
821 return result;
822 do_copy_to_sdhd_split_block(param, p_splitblock);
823 return 0;
824}
825
826int sceSdHdGetSampleSetParamAddr(void *buffer, unsigned int sampleSetNumber, sceHardSynthSampleSetParam **ptr)
827{
828 int result;
829 struct sdhd_info dinfo;
830
831 result = (int)do_get_vers_head_chunk((sceHardSynthVersionChunk *)buffer, &dinfo);
832 if ( result )
833 return result;
834 result = (int)do_get_sset_chunk(buffer, &dinfo);
835 if ( result )
836 return result;
837 result = (int)do_check_chunk_in_bounds(buffer, &dinfo, 0x53736574, sampleSetNumber);
838 if ( result )
839 return result;
840 *ptr = (sceHardSynthSampleSetParam *)((char *)dinfo.m_sset + dinfo.m_sset->sampleSetOffsetAddr[sampleSetNumber]);
841 return 0;
842}
843
844int sceSdHdGetSampleSetParam(void *buffer, unsigned int sampleSetNumber, SceSdHdSampleSetParam *param)
845{
846 int result;
847 sceHardSynthSampleSetParam *p_samplesetparam;
848
849 result = sceSdHdGetSampleSetParamAddr(buffer, sampleSetNumber, &p_samplesetparam);
850 if ( result )
851 return result;
852 do_copy_to_sdhd_set_param(param, p_samplesetparam);
853 return 0;
854}
855
856int sceSdHdGetSampleParamAddr(void *buffer, unsigned int sampleNumber, sceHardSynthSampleParam **ptr)
857{
858 int result;
859 struct sdhd_info dinfo;
860
861 result = (int)do_get_vers_head_chunk((sceHardSynthVersionChunk *)buffer, &dinfo);
862 if ( result )
863 return result;
864 result = (int)do_get_smpl_chunk(buffer, &dinfo);
865 if ( result )
866 return result;
867 result = (int)do_check_chunk_in_bounds(buffer, &dinfo, 0x536D706C, sampleNumber);
868 if ( result )
869 return result;
870 *ptr = (sceHardSynthSampleParam *)((char *)dinfo.m_smpl + dinfo.m_smpl->sampleOffsetAddr[sampleNumber]);
871 return 0;
872}
873
874int sceSdHdGetSampleParam(void *buffer, unsigned int sampleNumber, SceSdHdSampleParam *param)
875{
876 int result;
877 sceHardSynthSampleParam *p_sampleparam;
878
879 result = sceSdHdGetSampleParamAddr(buffer, sampleNumber, &p_sampleparam);
880 if ( result )
881 return result;
882 do_copy_to_sdhd_sample_param(param, p_sampleparam);
883 return 0;
884}
885
886int sceSdHdGetVAGInfoParamAddr(void *buffer, unsigned int vagInfoNumber, sceHardSynthVagParam **ptr)
887{
888 int result;
889 struct sdhd_info dinfo;
890
891 result = (int)do_get_vers_head_chunk((sceHardSynthVersionChunk *)buffer, &dinfo);
892 if ( result )
893 return result;
894 result = (int)do_get_vagi_chunk(buffer, &dinfo);
895 if ( result )
896 return result;
897 result = (int)do_check_chunk_in_bounds(buffer, &dinfo, 0x56616769, vagInfoNumber);
898 if ( result )
899 return result;
900 *ptr = (sceHardSynthVagParam *)((char *)dinfo.m_vagi + dinfo.m_vagi->vagInfoOffsetAddr[vagInfoNumber]);
901 return 0;
902}
903
904int sceSdHdGetVAGInfoParam(void *buffer, unsigned int vagInfoNumber, SceSdHdVAGInfoParam *param)
905{
906 int result;
907 sceHardSynthVagParam *p_vagparam;
908
909 result = sceSdHdGetVAGInfoParamAddr(buffer, vagInfoNumber, &p_vagparam);
910 if ( result )
911 return result;
912 do_copy_to_sdhd_vag_info_param(
913 param, do_get_vag_size((sceHardSynthVersionChunk *)buffer, &p_vagparam->vagOffsetAddr), p_vagparam);
914 return 0;
915}
916
917int sceSdHdCheckProgramNumber(void *buffer, unsigned int programNumber)
918{
919 int result;
920 struct sdhd_info dinfo;
921
922 result = (int)do_get_vers_head_chunk((sceHardSynthVersionChunk *)buffer, &dinfo);
923 if ( result )
924 return result;
925 result = (int)do_get_prog_chunk(buffer, &dinfo);
926 if ( result )
927 return result;
928 return (int)do_check_chunk_in_bounds(buffer, &dinfo, 0x50726F67, programNumber);
929}
930
931int sceSdHdGetSplitBlockCountByNote(void *buffer, unsigned int programNumber, unsigned int noteNumber)
932{
933 return do_get_common_block_ptr_note(buffer, programNumber, 0, noteNumber, 0, 0, 0);
934}
935
936int sceSdHdGetSplitBlockAddrByNote(
937 void *buffer, unsigned int programNumber, unsigned int noteNumber, sceHardSynthSplitBlock **ptr)
938{
939 return do_get_common_block_ptr_note(buffer, programNumber, 1, noteNumber, 0, 0, (void **)ptr);
940}
941
942int sceSdHdGetSplitBlockByNote(
943 void *buffer, unsigned int programNumber, unsigned int noteNumber, SceSdHdSplitBlock *param)
944{
945 return do_get_common_block_ptr_note(buffer, programNumber, 2, noteNumber, 0, 0, (void **)param);
946}
947
948int sceSdHdGetSampleSetParamCountByNote(void *buffer, unsigned int programNumber, unsigned int noteNumber)
949{
950 return do_get_common_block_ptr_note(buffer, programNumber, 3, noteNumber, 0, 0, 0);
951}
952
953int sceSdHdGetSampleSetParamAddrByNote(
954 void *buffer, unsigned int programNumber, unsigned int noteNumber, sceHardSynthSampleSetParam **ptr)
955{
956 return do_get_common_block_ptr_note(buffer, programNumber, 4, noteNumber, 0, 0, (void **)ptr);
957}
958
959int sceSdHdGetSampleSetParamByNote(
960 void *buffer, unsigned int programNumber, unsigned int noteNumber, SceSdHdSampleSetParam *param)
961{
962 return do_get_common_block_ptr_note(buffer, programNumber, 5, noteNumber, 0, 0, (void **)param);
963}
964
965int sceSdHdGetSampleParamCountByNoteVelocity(
966 void *buffer, unsigned int programNumber, unsigned int noteNumber, unsigned int velocity, unsigned int mode)
967{
968 return do_get_common_block_ptr_note(buffer, programNumber, 6, noteNumber, velocity, mode, 0);
969}
970
971int sceSdHdGetSampleParamAddrByNoteVelocity(
972 void *buffer,
973 unsigned int programNumber,
974 unsigned int noteNumber,
975 unsigned int velocity,
976 unsigned int mode,
977 sceHardSynthSampleParam **ptr)
978{
979 return do_get_common_block_ptr_note(buffer, programNumber, 7, noteNumber, velocity, mode, (void **)ptr);
980}
981
982int sceSdHdGetSampleParamByNoteVelocity(
983 void *buffer,
984 unsigned int programNumber,
985 unsigned int noteNumber,
986 unsigned int velocity,
987 unsigned int mode,
988 SceSdHdSampleParam *param)
989{
990 return do_get_common_block_ptr_note(buffer, programNumber, 8, noteNumber, velocity, mode, (void **)param);
991}
992
993int sceSdHdGetVAGInfoParamCountByNoteVelocity(
994 void *buffer, unsigned int programNumber, unsigned int noteNumber, unsigned int velocity, unsigned int mode)
995{
996 return do_get_common_block_ptr_note(buffer, programNumber, 9, noteNumber, velocity, mode, 0);
997}
998
999int sceSdHdGetVAGInfoParamAddrByNoteVelocity(
1000 void *buffer,
1001 unsigned int programNumber,
1002 unsigned int noteNumber,
1003 unsigned int velocity,
1004 unsigned int mode,
1005 sceHardSynthVagParam **ptr)
1006{
1007 return do_get_common_block_ptr_note(buffer, programNumber, 0xA, noteNumber, velocity, mode, (void **)ptr);
1008}
1009
1010int sceSdHdGetVAGInfoParamByNoteVelocity(
1011 void *buffer,
1012 unsigned int programNumber,
1013 unsigned int noteNumber,
1014 unsigned int velocity,
1015 unsigned int mode,
1016 SceSdHdVAGInfoParam *param)
1017{
1018 return do_get_common_block_ptr_note(buffer, programNumber, 0xB, noteNumber, velocity, mode, (void **)param);
1019}
1020
1021int sceSdHdGetSampleParamCountByVelocity(
1022 void *buffer, unsigned int sampleSetNumber, unsigned int velocity, unsigned int mode)
1023{
1024 return do_get_common_block_ptr(buffer, sampleSetNumber, 6, velocity, mode, 0);
1025}
1026
1027int sceSdHdGetSampleParamAddrByVelocity(
1028 void *buffer, unsigned int sampleSetNumber, unsigned int velocity, unsigned int mode, sceHardSynthSampleParam **ptr)
1029{
1030 return do_get_common_block_ptr(buffer, sampleSetNumber, 7, velocity, mode, (void **)ptr);
1031}
1032
1033int sceSdHdGetSampleParamByVelocity(
1034 void *buffer, unsigned int sampleSetNumber, unsigned int velocity, unsigned int mode, SceSdHdSampleParam *param)
1035{
1036 return do_get_common_block_ptr(buffer, sampleSetNumber, 8, velocity, mode, (void **)param);
1037}
1038
1039int sceSdHdGetVAGInfoParamCountByVelocity(
1040 void *buffer, unsigned int sampleSetNumber, unsigned int velocity, unsigned int mode)
1041{
1042 return do_get_common_block_ptr(buffer, sampleSetNumber, 9, velocity, mode, 0);
1043}
1044
1045int sceSdHdGetVAGInfoParamAddrByVelocity(
1046 void *buffer, unsigned int sampleSetNumber, unsigned int velocity, unsigned int mode, sceHardSynthVagParam **ptr)
1047{
1048 return do_get_common_block_ptr(buffer, sampleSetNumber, 0xA, velocity, mode, (void **)ptr);
1049}
1050
1051int sceSdHdGetVAGInfoParamByVelocity(
1052 void *buffer, unsigned int sampleSetNumber, unsigned int velocity, unsigned int mode, SceSdHdVAGInfoParam *param)
1053{
1054 return do_get_common_block_ptr(buffer, sampleSetNumber, 0xB, velocity, mode, (void **)param);
1055}
1056
1057int sceSdHdGetVAGInfoParamAddrBySampleNumber(void *buffer, unsigned int sampleNumber, sceHardSynthVagParam **ptr)
1058{
1059 int result;
1060 sceHardSynthSampleParam *p_sampleparam;
1061
1062 result = sceSdHdGetSampleParamAddr(buffer, sampleNumber, &p_sampleparam);
1063 if ( result )
1064 return result;
1065 if ( p_sampleparam->VagIndex == 0xFFFF )
1066 return (int)0x81039019;
1067 return sceSdHdGetVAGInfoParamAddr(buffer, p_sampleparam->VagIndex, ptr);
1068}
1069
1070int sceSdHdGetVAGInfoParamBySampleNumber(void *buffer, unsigned int sampleNumber, SceSdHdVAGInfoParam *param)
1071{
1072 int result;
1073 sceHardSynthVagParam *p_vagparam;
1074
1075 result = sceSdHdGetVAGInfoParamAddrBySampleNumber(buffer, sampleNumber, &p_vagparam);
1076 if ( result )
1077 return result;
1078 do_copy_to_sdhd_vag_info_param(
1079 param, do_get_vag_size((sceHardSynthVersionChunk *)buffer, &p_vagparam->vagOffsetAddr), p_vagparam);
1080 return 0;
1081}
1082
1083int sceSdHdGetSplitBlockNumberBySplitNumber(void *buffer, unsigned int programNumber, unsigned int splitNumber)
1084{
1085 int result;
1086 int i;
1087 sceHardSynthSplitBlock *splitblock;
1088 sceHardSynthProgramParam *p_programparam;
1089
1090 result = sceSdHdGetProgramParamAddr(buffer, programNumber, &p_programparam);
1091 if ( result )
1092 return result;
1093 if ( p_programparam->splitBlockAddr == 0xFFFFFFFF )
1094 return (int)0x81039009;
1095 splitblock = (sceHardSynthSplitBlock *)((char *)p_programparam + p_programparam->splitBlockAddr);
1096 for ( i = 0; i < p_programparam->nSplit; i += 1 )
1097 {
1098 if ( splitNumber == splitblock->splitNumber )
1099 return i;
1100 splitblock = (sceHardSynthSplitBlock *)((char *)splitblock + p_programparam->sizeSplitBlock);
1101 }
1102 return (int)0x81039020;
1103}
1104
1105int sceSdHdGetVAGSize(void *buffer, unsigned int vagInfoNumber)
1106{
1107 int result;
1108 sceHardSynthVagParam *p_vagparam;
1109
1110 result = sceSdHdGetVAGInfoParamAddr(buffer, vagInfoNumber, &p_vagparam);
1111 if ( result )
1112 return result;
1113 return (int)do_get_vag_size((sceHardSynthVersionChunk *)buffer, &p_vagparam->vagOffsetAddr);
1114}
1115
1116int sceSdHdGetSplitBlockCount(void *buffer, unsigned int programNumber)
1117{
1118 int result;
1119 sceHardSynthProgramParam *p_programparam;
1120
1121 result = sceSdHdGetProgramParamAddr(buffer, programNumber, &p_programparam);
1122 if ( result )
1123 return result;
1124 return p_programparam->nSplit;
1125}
1126
1127int sceSdHdGetMaxSplitBlockCount(void *buffer)
1128{
1129 int curminval;
1130 unsigned int retres;
1131 unsigned int i;
1132 unsigned int j;
1133 int curval1;
1134 int curval2;
1135 sceHardSynthProgramParam *p_programparam;
1136 sceHardSynthSplitBlock *p_splitblock;
1137
1138 curminval = 0;
1139 retres = (unsigned int)sceSdHdGetMaxProgramNumber(buffer);
1140 if ( (retres & 0x80000000) != 0 )
1141 return 0;
1142 for ( i = 0; i < retres; i += 1 )
1143 {
1144 if ( !sceSdHdGetProgramParamAddr(buffer, i, &p_programparam) )
1145 {
1146 for ( j = 0; j < p_programparam->nSplit; j += 1 )
1147 {
1148 if ( !sceSdHdGetSplitBlockAddr(buffer, i, j, &p_splitblock) )
1149 {
1150 curval1 = sceSdHdGetSplitBlockCountByNote(buffer, i, p_splitblock->splitRangeLow & 0x7F);
1151 curminval = (curminval < curval1) ? curval1 : curminval;
1152 curval2 = sceSdHdGetSplitBlockCountByNote(buffer, i, p_splitblock->splitRangeHigh & 0x7F);
1153 curminval = (curminval < curval2) ? curval2 : curminval;
1154 }
1155 }
1156 }
1157 }
1158 return curminval;
1159}
1160
1161int sceSdHdGetMaxSampleSetParamCount(void *buffer)
1162{
1163 int curminval;
1164 unsigned int retres;
1165 unsigned int i;
1166 unsigned int j;
1167 int curval1;
1168 int curval2;
1169 sceHardSynthProgramParam *p_programparam;
1170 sceHardSynthSplitBlock *p_splitblock;
1171
1172 curminval = 0;
1173 retres = (unsigned int)sceSdHdGetMaxProgramNumber(buffer);
1174 if ( (retres & 0x80000000) != 0 )
1175 return 0;
1176 for ( i = 0; i < retres; i += 1 )
1177 {
1178 if ( !sceSdHdGetProgramParamAddr(buffer, i, &p_programparam) )
1179 {
1180 for ( j = 0; j < p_programparam->nSplit; j += 1 )
1181 {
1182 if ( !sceSdHdGetSplitBlockAddr(buffer, i, j, &p_splitblock) )
1183 {
1184 curval1 = sceSdHdGetSampleSetParamCountByNote(buffer, i, p_splitblock->splitRangeLow & 0x7F);
1185 curminval = (curminval < curval1) ? curval1 : curminval;
1186 curval2 = sceSdHdGetSampleSetParamCountByNote(buffer, i, p_splitblock->splitRangeHigh & 0x7F);
1187 curminval = (curminval < curval2) ? curval2 : curminval;
1188 }
1189 }
1190 }
1191 }
1192 return curminval;
1193}
1194
1195int sceSdHdGetMaxSampleParamCount(void *buffer)
1196{
1197 int curminval;
1198 unsigned int retres;
1199 unsigned int i;
1200 unsigned int j;
1201 unsigned int k;
1202 int curval1;
1203 int curval2;
1204 int curval3;
1205 int curval4;
1206 sceHardSynthProgramParam *p_programparam;
1207 sceHardSynthSplitBlock *p_splitblock;
1208 sceHardSynthSampleSetParam *p_samplesetparam;
1209 sceHardSynthSampleParam *p_sampleparam;
1210
1211 curminval = 0;
1212 retres = (unsigned int)sceSdHdGetMaxProgramNumber(buffer);
1213 if ( (retres & 0x80000000) != 0 )
1214 return 0;
1215 for ( i = 0; i < retres; i += 1 )
1216 {
1217 if ( !sceSdHdGetProgramParamAddr(buffer, i, &p_programparam) )
1218 {
1219 for ( j = 0; j < p_programparam->nSplit; j += 1 )
1220 {
1221 if (
1222 !sceSdHdGetSplitBlockAddr(buffer, i, j, &p_splitblock)
1223 && !sceSdHdGetSampleSetParamAddr(buffer, p_splitblock->sampleSetIndex, &p_samplesetparam) )
1224 {
1225 for ( k = 0; k < p_samplesetparam->nSample; k += 1 )
1226 {
1227 if ( !sceSdHdGetSampleParamAddr(
1228 buffer,
1229 (unsigned int)sceSdHdGetSampleNumberBySampleIndex(buffer, p_splitblock->sampleSetIndex, k),
1230 &p_sampleparam) )
1231 {
1232 curval1 = sceSdHdGetSampleParamCountByNoteVelocity(
1233 buffer, i, p_splitblock->splitRangeLow & 0x7F, p_sampleparam->velRangeLow & 0x7F, 1u);
1234 curminval = (curminval < curval1) ? curval1 : curminval;
1235 curval2 = sceSdHdGetSampleParamCountByNoteVelocity(
1236 buffer, i, p_splitblock->splitRangeLow & 0x7F, p_sampleparam->velRangeHigh & 0x7F, 1u);
1237 curminval = (curminval < curval2) ? curval2 : curminval;
1238 curval3 = sceSdHdGetSampleParamCountByNoteVelocity(
1239 buffer, i, p_splitblock->splitRangeHigh & 0x7F, p_sampleparam->velRangeLow & 0x7F, 1u);
1240 curminval = (curminval < curval3) ? curval3 : curminval;
1241 curval4 = sceSdHdGetSampleParamCountByNoteVelocity(
1242 buffer, i, p_splitblock->splitRangeHigh & 0x7F, p_sampleparam->velRangeHigh & 0x7F, 1u);
1243 curminval = (curminval < curval4) ? curval4 : curminval;
1244 }
1245 }
1246 }
1247 }
1248 }
1249 }
1250 return curminval;
1251}
1252
1253int sceSdHdGetMaxVAGInfoParamCount(void *buffer)
1254{
1255 int curminval;
1256 unsigned int retres;
1257 unsigned int i;
1258 unsigned int j;
1259 unsigned int k;
1260 int curval1;
1261 int curval2;
1262 int curval3;
1263 int curval4;
1264 sceHardSynthProgramParam *p_programparam;
1265 sceHardSynthSplitBlock *p_splitblock;
1266 sceHardSynthSampleSetParam *p_samplesetparam;
1267 sceHardSynthSampleParam *p_sampleparam;
1268
1269 curminval = 0;
1270 retres = (unsigned int)sceSdHdGetMaxProgramNumber(buffer);
1271 if ( (retres & 0x80000000) != 0 )
1272 return 0;
1273 for ( i = 0; i < retres; i += 1 )
1274 {
1275 if ( !sceSdHdGetProgramParamAddr(buffer, i, &p_programparam) )
1276 {
1277 for ( j = 0; j < p_programparam->nSplit; j += 1 )
1278 {
1279 if (
1280 !sceSdHdGetSplitBlockAddr(buffer, i, j, &p_splitblock)
1281 && !sceSdHdGetSampleSetParamAddr(buffer, p_splitblock->sampleSetIndex, &p_samplesetparam) )
1282 {
1283 for ( k = 0; k < p_samplesetparam->nSample; k += 1 )
1284 {
1285 if ( !sceSdHdGetSampleParamAddr(
1286 buffer,
1287 (unsigned int)sceSdHdGetSampleNumberBySampleIndex(buffer, p_splitblock->sampleSetIndex, k),
1288 &p_sampleparam) )
1289 {
1290 curval1 = sceSdHdGetVAGInfoParamCountByNoteVelocity(
1291 buffer, i, p_splitblock->splitRangeLow & 0x7F, p_sampleparam->velRangeLow & 0x7F, 1u);
1292 curminval = (curminval < curval1) ? curval1 : curminval;
1293 curval2 = sceSdHdGetVAGInfoParamCountByNoteVelocity(
1294 buffer, i, p_splitblock->splitRangeLow & 0x7F, p_sampleparam->velRangeHigh & 0x7F, 1u);
1295 curminval = (curminval < curval2) ? curval2 : curminval;
1296 curval3 = sceSdHdGetVAGInfoParamCountByNoteVelocity(
1297 buffer, i, p_splitblock->splitRangeHigh & 0x7F, p_sampleparam->velRangeLow & 0x7F, 1u);
1298 curminval = (curminval < curval3) ? curval3 : curminval;
1299 curval4 = sceSdHdGetVAGInfoParamCountByNoteVelocity(
1300 buffer, i, p_splitblock->splitRangeHigh & 0x7F, p_sampleparam->velRangeHigh & 0x7F, 1u);
1301 curminval = (curminval < curval4) ? curval4 : curminval;
1302 }
1303 }
1304 }
1305 }
1306 }
1307 }
1308 return curminval;
1309}
1310
1311int sceSdHdModifyVelocity(unsigned int curveType, int velocity)
1312{
1313 switch ( curveType )
1314 {
1315 case 1u:
1316 return 128 - velocity;
1317 case 2u:
1318 velocity = velocity * velocity / 0x7F;
1319 return velocity ? velocity : 1;
1320 case 3u:
1321 velocity = velocity * velocity / 0x7F;
1322 velocity = velocity ? velocity : 1;
1323 return 128 - velocity;
1324 case 4u:
1325 velocity = (128 - velocity) * (128 - velocity);
1326 velocity = (velocity / 0x7F) & 0x3FFFFFF;
1327 velocity = velocity ? velocity : 1;
1328 return 128 - velocity;
1329 case 5u:
1330 velocity = 128 - velocity;
1331 velocity = velocity * velocity / 0x7F;
1332 return velocity ? velocity : 1;
1333 default:
1334 return velocity;
1335 }
1336}
1337
1338int sceSdHdModifyVelocityLFO(unsigned int curveType, int velocity, int center)
1339{
1340 int calc5;
1341 int calcb;
1342
1343 center = (center >= 0) ? ((center >= 128) ? 127 : center) : 0;
1344 velocity = (velocity >= 0) ? ((velocity >= 128) ? 127 : velocity) : 0;
1345 calc5 = 0;
1346 switch ( curveType )
1347 {
1348 case 0u:
1349 default:
1350 calc5 = (velocity - center) << 16;
1351 calc5 = (calc5 / 126) - (int)((unsigned int)calc5 >> 31);
1352 break;
1353 case 1u:
1354 calc5 = (center - velocity) << 16;
1355 calc5 = (calc5 / 126) - (int)((unsigned int)calc5 >> 31);
1356 break;
1357 case 2u:
1358 calc5 = ((velocity - 1) << 15) / 126 * (((velocity - 1) << 15) / 126)
1359 - ((center - 1) << 15) / 126 * (((center - 1) << 15) / 126);
1360 calc5 = (calc5 < 0) ? ((calc5 + 0x3FFF) >> 14) : (calc5 >> 14);
1361 break;
1362 case 3u:
1363 calc5 = ((velocity - 1) << 15) / 126 * (((velocity - 1) << 15) / 126) / -16384
1364 - ((center - 1) << 15) / 126 * (((center - 1) << 15) / 126) / -16384;
1365 break;
1366 case 4u:
1367 calc5 = (0x10000 - ((center - 1) << 15) / 126) * (0x10000 - ((center - 1) << 15) / 126) / 0x4000
1368 - (0x10000 - ((velocity - 1) << 15) / 126) * (0x10000 - ((velocity - 1) << 15) / 126) / 0x4000;
1369 break;
1370 case 5u:
1371 calc5 = (0x10000 - ((velocity - 1) << 15) / 126) * (0x10000 - ((velocity - 1) << 15) / 126) / 0x4000
1372 - (0x10000 - ((center - 1) << 15) / 126) * (0x10000 - ((center - 1) << 15) / 126) / 0x4000;
1373 break;
1374 case 6u:
1375 if ( velocity == center )
1376 break;
1377 calc5 = (center >= velocity) ? (center - 1) : (127 - center);
1378 calcb = (velocity - center) << 16;
1379 if ( !calc5 )
1380 __builtin_trap();
1381 if ( calc5 == -1 && (unsigned int)calcb == 0x80000000 )
1382 __builtin_trap();
1383 calc5 = calcb / calc5;
1384 break;
1385 case 7u:
1386 if ( velocity == center )
1387 break;
1388 calc5 = (center >= velocity) ? (center - 1) : (127 - center);
1389 calcb = (center - velocity) << 16;
1390 if ( !calc5 )
1391 __builtin_trap();
1392 if ( calc5 == -1 && (unsigned int)calcb == 0x80000000 )
1393 __builtin_trap();
1394 calc5 = calcb / calc5;
1395 break;
1396 case 8u:
1397 if ( velocity == center )
1398 break;
1399 calcb = (velocity - center) << 15;
1400 if ( center >= velocity )
1401 {
1402 if ( center == 1 )
1403 __builtin_trap();
1404 if ( !center && (unsigned int)calcb == 0x80000000 )
1405 __builtin_trap();
1406 calc5 = calcb / (center - 1) * (calcb / (center - 1)) / -16384;
1407 }
1408 else
1409 {
1410 calc5 = 127 - center;
1411 if ( 127 == center )
1412 __builtin_trap();
1413 if ( calc5 == -1 && (unsigned int)calcb == 0x80000000 )
1414 __builtin_trap();
1415 calc5 = calcb / calc5 * (calcb / calc5);
1416 calc5 = (calc5 < 0) ? ((calc5 + 0x3FFF) >> 14) : (calc5 >> 14);
1417 }
1418 break;
1419 case 9u:
1420 if ( velocity == center )
1421 break;
1422 calcb = (velocity - center) << 15;
1423 if ( center >= velocity )
1424 {
1425 if ( center == 1 )
1426 __builtin_trap();
1427 if ( !center && (unsigned int)calcb == 0x80000000 )
1428 __builtin_trap();
1429 calc5 = (calcb / (center - 1) + 0x8000) * (calcb / (center - 1) + 0x8000) / 0x4000 - 0x10000;
1430 }
1431 else
1432 {
1433 calc5 = 127 - center;
1434 if ( 127 == center )
1435 __builtin_trap();
1436 if ( calc5 == -1 && (unsigned int)calcb == 0x80000000 )
1437 __builtin_trap();
1438 calc5 = (0x8000 - calcb / calc5) * (0x8000 - calcb / calc5);
1439 calc5 = 0x10000 - ((calc5 < 0) ? ((calc5 + 0x3FFF) >> 14) : (calc5 >> 14));
1440 }
1441 break;
1442 }
1443 return (calc5 < -65536) ? -65536 : ((calc5 > 0xFFFF) ? 0xFFFF : calc5);
1444}
1445
1446int sceSdHdGetValidProgramNumberCount(void *buffer)
1447{
1448 int validcnt;
1449 int result;
1450 unsigned int i;
1451 struct sdhd_info dinfo;
1452
1453 validcnt = 0;
1454 result = (int)do_get_vers_head_chunk((sceHardSynthVersionChunk *)buffer, &dinfo);
1455 if ( result )
1456 return result;
1457 result = (int)do_get_prog_chunk(buffer, &dinfo);
1458 if ( result )
1459 return result;
1460 for ( i = 0; dinfo.m_prog->maxProgramNumber >= i; i += 1 )
1461 {
1462 if ( dinfo.m_prog->programOffsetAddr[i] != 0xFFFFFFFF )
1463 validcnt += 1;
1464 }
1465 return validcnt;
1466}
1467
1468int sceSdHdGetValidProgramNumber(void *buffer, unsigned int *ptr)
1469{
1470 int validcnt;
1471 int result;
1472 unsigned int i;
1473 struct sdhd_info dinfo;
1474
1475 validcnt = 0;
1476 result = (int)do_get_vers_head_chunk((sceHardSynthVersionChunk *)buffer, &dinfo);
1477 if ( result )
1478 return result;
1479 result = (int)do_get_prog_chunk(buffer, &dinfo);
1480 if ( result )
1481 return result;
1482 for ( i = 0; dinfo.m_prog->maxProgramNumber >= i; i += 1 )
1483 {
1484 if ( dinfo.m_prog->programOffsetAddr[i] != 0xFFFFFFFF )
1485 {
1486 ptr[validcnt] = i;
1487 validcnt += 1;
1488 }
1489 }
1490 return validcnt;
1491}
1492
1493int sceSdHdGetSampleNumberBySampleIndex(void *buffer, unsigned int sampleSetNumber, unsigned int sampleIndexNumber)
1494{
1495 int result;
1496 sceHardSynthSampleSetParam *p_samplesetparam;
1497
1498 result = sceSdHdGetSampleSetParamAddr(buffer, sampleSetNumber, &p_samplesetparam);
1499 if ( result )
1500 return result;
1501 return ((unsigned int)p_samplesetparam->nSample - 1 < sampleIndexNumber) ?
1502 0x9006 :
1503 p_samplesetparam->sampleIndex[sampleIndexNumber];
1504}
1505
1506#ifdef _IOP
1507int _start(int ac, char *av[], void *startaddr, ModuleInfo_t *mi)
1508{
1509 int regres;
1510 int state;
1511
1512 (void)av;
1513 (void)startaddr;
1514 if ( ac < 0 )
1515 {
1516 CpuSuspendIntr(&state);
1517 regres = ReleaseLibraryEntries(&_exp_sdhd);
1518 CpuResumeIntr(state);
1519 return (!regres) ? MODULE_NO_RESIDENT_END : MODULE_REMOVABLE_END;
1520 }
1521 CpuSuspendIntr(&state);
1522 regres = RegisterLibraryEntries(&_exp_sdhd);
1523 CpuResumeIntr(state);
1524 if ( regres )
1525 return MODULE_NO_RESIDENT_END;
1526#if 0
1527 return MODULE_REMOVABLE_END;
1528#else
1529 if ( mi && ((mi->newflags & 2) != 0) )
1530 mi->newflags |= 0x10;
1531 return MODULE_RESIDENT_END;
1532#endif
1533}
1534#endif
CpuResumeIntr
int CpuResumeIntr(int state)
Definition intrman.c:217
CpuSuspendIntr
int CpuSuspendIntr(int *state)
Definition intrman.c:195
ModuleInfo_t
struct _ModuleInfo ModuleInfo_t
_ModuleInfo::newflags
u16 newflags
Definition loadcore.h:37
irx_export_table
Definition irx.h:117
sceHardSynthHeaderChunk_
Definition sdhd.c:43
sceHardSynthProgramChunk_
Definition sdhd.c:57
sceHardSynthSampleChunk_
Definition sdhd.c:75
sceHardSynthSampleSetChunk_
Definition sdhd.c:66
sceHardSynthVersionChunk_
Definition sdhd.c:30
sdhd_info
Definition sdhd.c:93