libasnd/asndlib.c

   1 /* ASNDLIB -> accelerated sound lib using the DSP
   2
   3 Copyright (c) 2008 Hermes <www.entuwii.net>
   4 All rights reserved.
   5
   6 Redistribution and use in source and binary forms, with or without modification, are
   7 permitted provided that the following conditions are met:
   8
   9 - Redistributions of source code must retain the above copyright notice, this list of
  10 conditions and the following disclaimer.
  11 - Redistributions in binary form must reproduce the above copyright notice, this list
  12 of conditions and the following disclaimer in the documentation and/or other
  13 materials provided with the distribution.
  14 - The names of the contributors may not be used to endorse or promote products derived
  15 from this software without specific prior written permission.
  16
  17 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
  18 EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  19 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
  20 THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  22 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  23 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  24 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
  25 THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26
  27 */
  28
  29 #include <stdio.h>
  30 #include <unistd.h>
  31
  32 #include <ogcsys.h>
  33 #include <gccore.h>
  34 #include <ogc/lwp_watchdog.h>
  35 #include <ogc/machine/processor.h>
  36
  37 #include "asndlib.h"
  38 #include "dsp_mixer.h"
  39
  40 #undef SND_BUFFERSIZE
  41
  42 #define MAX_SND_VOICES                  16
  43 #define SND_BUFFERSIZE                  (4096) // don't modify this value
  44
  45 #define VOICE_UPDATEADD   (1<<12)
  46 #define VOICE_UPDATE      (1<<11)
  47 #define VOICE_VOLUPDATE   (1<<10)
  48 #define VOICE_PAUSE       (1<<9)
  49 #define VOICE_SETLOOP     (1<<8)
  50
  51 typedef struct
  52 {
  53         void *out_buf;  // output buffer 4096 bytes aligned to 32
  54
  55         u32 delay_samples; // samples per delay to start (48000 == 1sec)
  56
  57         u32 flags;      // (step<<16) | (statuses<<8) | (type & 7) used in DSP side
  58
  59         u32 start_addr; // internal addr counter
  60         u32 end_addr;   // end voice physical pointer(bytes without alignament, but remember it reads in blocks of 32 bytes (use padding to the end))
  61
  62         u32 freq;       // freq operation
  63
  64         s16 left, right; // internally used to store de last sample played
  65
  66         u32 counter;    // internally used to convert freq to 48000Hz samples
  67
  68         u16 volume_l,volume_r; // volume (from 0 to 256)
  69
  70         u32 start_addr2;        // initial voice2 physical pointer (bytes aligned  32 bytes) (to do a ring)
  71         u32 end_addr2;          // end voice2 physical pointer(bytes without alignament, but remember it reads in blocks of 32 bytes (use padding to the end))
  72
  73         u16 volume2_l,volume2_r; // volume (from 0 to 256) for voice 2
  74
  75         u32 backup_addr; // initial voice physical pointer backup (bytes aligned to 32 bytes): It is used for test pointers purpose
  76
  77         u32 tick_counter; // voice tick counter
  78
  79         ASNDVoiceCallback cb;
  80
  81         u32 _pad;
  82 } t_sound_data;
  83
  84 static dsptask_t dsp_task;
  85
  86 static vu64 time_of_process;
  87 static vu32 dsp_complete = 1;
  88 static vu64 dsp_task_starttime = 0;
  89 static vu32 curr_audio_buf = 0;
  90 static vu32 dsp_done = 0;
  91
  92 static vs32 snd_chan = 0;
  93 static vs32 global_pause = 1;
  94 static vu32 global_counter = 0;
  95
  96 static vu32 DSP_DI_HANDLER = 1;
  97 static void (*global_callback)()=NULL;
  98
  99 static u32 asnd_inited = 0;
 100 static t_sound_data sound_data[MAX_SND_VOICES];
 101
 102 static t_sound_data sound_data_dma ATTRIBUTE_ALIGN(32);
 103 static s16 mute_buf[SND_BUFFERSIZE] ATTRIBUTE_ALIGN(32);
 104 static s16 audio_buf[2][SND_BUFFERSIZE] ATTRIBUTE_ALIGN(32);
 105
 106 extern u32 gettick();
 107
 108 static __inline__ char* snd_set0b( char *p, int n)
 109 {
 110         while(n>0) {*p++=0;n--;}
 111         return p;
 112 }
 113
 114 static __inline__ s32* snd_set0w( s32 *p, int n)
 115 {
 116         while(n>0) {*p++=0;n--;}
 117         return p;
 118 }
 119
 120 static void __dsp_initcallback(dsptask_t *task)
 121 {
 122         DSP_SendMailTo(0x0123); // command to fix the data operation
 123         while(DSP_CheckMailTo());
 124
 125         DSP_SendMailTo(MEM_VIRTUAL_TO_PHYSICAL((&sound_data_dma))); //send the data operation mem
 126         while(DSP_CheckMailTo());
 127
 128         dsp_complete=1;
 129         DSP_DI_HANDLER=0;
 130 }
 131
 132 static void __dsp_requestcallback(dsptask_t *task)
 133 {
 134         s32 n;
 135
 136         if(DSP_DI_HANDLER) return;
 137
 138         DCInvalidateRange(&sound_data_dma, sizeof(t_sound_data));
 139
 140         if(snd_chan>=MAX_SND_VOICES) {
 141                 if(!dsp_complete) time_of_process = (gettime() - dsp_task_starttime);
 142                 if(!global_pause) global_counter++;
 143
 144                 dsp_complete = 1;
 145                 return;
 146         }
 147
 148         sound_data_dma.freq=sound_data[snd_chan].freq;
 149         sound_data_dma.cb=sound_data[snd_chan].cb;
 150         if(sound_data[snd_chan].flags & VOICE_UPDATE) // new song
 151         {
 152                 sound_data[snd_chan].flags &=~(VOICE_UPDATE | VOICE_VOLUPDATE | VOICE_PAUSE | VOICE_UPDATEADD);
 153                 //sound_data[snd_chan].out_buf= (void *) MEM_VIRTUAL_TO_PHYSICAL((void *) audio_buf[curr_audio_buf]);
 154                 sound_data_dma=sound_data[snd_chan];
 155         }
 156         else
 157         {
 158
 159                 if(sound_data[snd_chan].flags & VOICE_VOLUPDATE)
 160                 {
 161                         sound_data[snd_chan].flags &=~VOICE_VOLUPDATE;
 162                         sound_data_dma.volume_l=sound_data_dma.volume2_l=sound_data[snd_chan].volume2_l;
 163                         sound_data_dma.volume_r=sound_data_dma.volume2_r=sound_data[snd_chan].volume2_r;
 164                 }
 165
 166
 167                 //if(mail==0xbebe0003) sound_data_dma.flags|=VOICE_SETCALLBACK;
 168
 169                 if(sound_data_dma.start_addr>=sound_data_dma.end_addr || !sound_data_dma.start_addr)
 170                 {
 171                         sound_data_dma.backup_addr=sound_data_dma.start_addr=sound_data_dma.start_addr2;
 172                         sound_data_dma.end_addr=sound_data_dma.end_addr2;
 173                         if(!(sound_data[snd_chan].flags & VOICE_SETLOOP)) {sound_data_dma.start_addr2=0;sound_data_dma.end_addr2=0;}
 174                         sound_data_dma.volume_l=sound_data_dma.volume2_l;
 175                         sound_data_dma.volume_r=sound_data_dma.volume2_r;
 176                 }
 177
 178                 if(sound_data[snd_chan].start_addr2 && (sound_data[snd_chan].flags & VOICE_UPDATEADD))
 179                 {
 180                         sound_data[snd_chan].flags &=~VOICE_UPDATEADD;
 181                         if(!sound_data[snd_chan].start_addr || !sound_data_dma.start_addr)
 182                         {
 183                                 sound_data_dma.backup_addr=sound_data_dma.start_addr=sound_data[snd_chan].start_addr2;
 184                                 sound_data_dma.end_addr=sound_data[snd_chan].end_addr2;
 185                                 sound_data_dma.start_addr2=sound_data[snd_chan].start_addr2;
 186                                 sound_data_dma.end_addr2=sound_data[snd_chan].end_addr2;
 187                                 if(!(sound_data[snd_chan].flags & VOICE_SETLOOP)) {sound_data_dma.start_addr2=0;sound_data_dma.end_addr2=0;}
 188                                 sound_data_dma.volume_l=sound_data[snd_chan].volume2_l;
 189                                 sound_data_dma.volume_r=sound_data[snd_chan].volume2_r;
 190                         }
 191                         else
 192                         {
 193                                 sound_data_dma.start_addr2=sound_data[snd_chan].start_addr2;
 194                                 sound_data_dma.end_addr2=sound_data[snd_chan].end_addr2;
 195                                 sound_data_dma.volume2_l=sound_data[snd_chan].volume2_l;
 196                                 sound_data_dma.volume2_r=sound_data[snd_chan].volume2_r;
 197                         }
 198
 199                 }
 200
 201                 if(!sound_data[snd_chan].cb && (!sound_data_dma.start_addr && !sound_data_dma.start_addr2)) sound_data[snd_chan].flags=0;
 202                 sound_data_dma.flags=sound_data[snd_chan].flags & ~(VOICE_UPDATE | VOICE_VOLUPDATE | VOICE_UPDATEADD);
 203                 sound_data[snd_chan]=sound_data_dma;
 204         }
 205
 206         if(sound_data[snd_chan].flags>>16)
 207         {
 208                 if(!sound_data[snd_chan].delay_samples && !(sound_data[snd_chan].flags & VOICE_PAUSE) && (sound_data_dma.start_addr || sound_data_dma.start_addr2)) sound_data[snd_chan].tick_counter++;
 209         }
 210
 211         snd_chan++;
 212
 213         if(!sound_data[snd_chan].cb && (!sound_data[snd_chan].start_addr && !sound_data[snd_chan].start_addr2)) sound_data[snd_chan].flags=0;
 214
 215         while(snd_chan<16 && !(sound_data[snd_chan].flags>>16)) snd_chan++;
 216
 217         if(snd_chan>=MAX_SND_VOICES)
 218         {
 219                 snd_chan++;
 220                 DCFlushRange(&sound_data_dma, sizeof(t_sound_data));
 221                 DSP_SendMailTo(0x666);
 222                 while(DSP_CheckMailTo());
 223                 return;
 224         }
 225
 226         sound_data_dma=sound_data[snd_chan];
 227
 228         DCFlushRange(&sound_data_dma, sizeof(t_sound_data));
 229         DSP_SendMailTo(0x222); // send the voice and mix the samples of the buffer
 230         while(DSP_CheckMailTo());
 231
 232         // callback strategy for next channel
 233         n=snd_chan+1;
 234
 235         while(n<16 && !(sound_data[n].flags>>16)) n++;
 236
 237         if(n<16)
 238         {
 239                 if(!sound_data[n].start_addr2 && (sound_data[n].flags>>16) && sound_data[n].cb) sound_data[n].cb(n);
 240
 241                 if(sound_data[snd_chan].flags & VOICE_VOLUPDATE)
 242                 {
 243                         sound_data[snd_chan].flags &=~VOICE_VOLUPDATE;
 244                 }
 245
 246                 if(sound_data[n].flags & VOICE_UPDATE) // new song
 247                 {
 248                         sound_data[n].flags &=~(VOICE_UPDATE | VOICE_VOLUPDATE | VOICE_PAUSE | VOICE_UPDATEADD);
 249                 }
 250
 251                 if(!sound_data[n].cb && (!sound_data[n].start_addr && !sound_data[n].start_addr2)) sound_data[n].flags=0;
 252         }
 253 }
 254
 255 static void __dsp_donecallback(dsptask_t *task)
 256 {
 257         dsp_done = 1;
 258 }
 259
 260 static void audio_dma_callback()
 261 {
 262         u32 n;
 263
 264         curr_audio_buf ^= 1;
 265
 266         if(DSP_DI_HANDLER || global_pause)
 267                 AUDIO_InitDMA((u32)mute_buf,SND_BUFFERSIZE);
 268         else
 269                 AUDIO_InitDMA((u32)audio_buf[curr_audio_buf],SND_BUFFERSIZE);
 270
 271         if(DSP_DI_HANDLER || global_pause) return;
 272         if(dsp_complete==0) return;
 273
 274         dsp_complete = 0;
 275
 276         for(n=0;n<MAX_SND_VOICES;n++) sound_data[n].out_buf = (void *)MEM_VIRTUAL_TO_PHYSICAL((void *)audio_buf[curr_audio_buf]);
 277
 278         if(global_callback) global_callback();
 279
 280         snd_chan = 0;
 281         if(!sound_data[snd_chan].start_addr2 && (sound_data[snd_chan].flags>>16) && sound_data[snd_chan].cb) sound_data[snd_chan].cb(snd_chan);
 282
 283         if(sound_data[snd_chan].flags & VOICE_VOLUPDATE)
 284         {
 285                 sound_data[snd_chan].flags &=~VOICE_VOLUPDATE;
 286         }
 287
 288         if(sound_data[snd_chan].flags & VOICE_UPDATE) // new song
 289         {
 290                 sound_data[snd_chan].flags &=~(VOICE_UPDATE | VOICE_VOLUPDATE | VOICE_PAUSE | VOICE_UPDATEADD);
 291         }
 292         else
 293         {
 294
 295                 if(sound_data[snd_chan].start_addr>=sound_data[snd_chan].end_addr)
 296                 {
 297                         sound_data[snd_chan].backup_addr=sound_data[snd_chan].start_addr=sound_data[snd_chan].start_addr2;sound_data[snd_chan].start_addr2=0;
 298                         sound_data[snd_chan].end_addr=sound_data[snd_chan].end_addr2;sound_data[snd_chan].end_addr2=0;
 299                         sound_data[snd_chan].volume_l=sound_data[snd_chan].volume2_l;
 300                         sound_data[snd_chan].volume_r=sound_data[snd_chan].volume2_r;
 301                 }
 302
 303                 if(sound_data[snd_chan].start_addr2 && (sound_data[snd_chan].flags & VOICE_UPDATEADD))
 304                 {
 305                         sound_data[snd_chan].flags &=~VOICE_UPDATEADD;
 306
 307                         if(!sound_data[snd_chan].start_addr)
 308                         {
 309                                 sound_data[snd_chan].backup_addr=sound_data[snd_chan].start_addr=sound_data[snd_chan].start_addr2;
 310                                 sound_data[snd_chan].end_addr=sound_data[snd_chan].end_addr2;
 311                                 if(!(sound_data[snd_chan].flags & VOICE_SETLOOP)) {sound_data[snd_chan].start_addr2=0;sound_data[snd_chan].end_addr2=0;}
 312                                 sound_data[snd_chan].volume_l=sound_data[snd_chan].volume2_l;
 313                                 sound_data[snd_chan].volume_r=sound_data[snd_chan].volume2_r;
 314                         }
 315
 316                 }
 317
 318         }
 319         if(!sound_data[snd_chan].cb && (!sound_data[snd_chan].start_addr && !sound_data[snd_chan].start_addr2)) sound_data[snd_chan].flags=0;
 320
 321         sound_data_dma=sound_data[snd_chan];
 322         DCFlushRange(&sound_data_dma, sizeof(t_sound_data));
 323
 324         dsp_task_starttime = gettime();
 325         DSP_SendMailTo(0x111); // send the first voice and clear the buffer
 326         while(DSP_CheckMailTo());
 327
 328         // callback strategy for next channel
 329         n=snd_chan+1;
 330
 331         while(n<16 && !(sound_data[n].flags>>16)) n++;
 332
 333         if(n<16)
 334         {
 335                 if(!sound_data[n].start_addr2 && (sound_data[n].flags>>16) && sound_data[n].cb) sound_data[n].cb(n);
 336
 337                 if(sound_data[n].flags & (VOICE_VOLUPDATE | VOICE_UPDATEADD))
 338                 {
 339                         sound_data[n].flags &=~(VOICE_VOLUPDATE | VOICE_UPDATEADD);
 340                 }
 341
 342                 if(sound_data[n].flags & VOICE_UPDATE) // new song
 343                 {
 344                         sound_data[n].flags &=~(VOICE_UPDATE | VOICE_VOLUPDATE| VOICE_PAUSE | VOICE_UPDATEADD);
 345                 }
 346
 347                 if(!sound_data[n].cb && (!sound_data[n].start_addr && !sound_data[n].start_addr2)) sound_data[n].flags=0;
 348         }
 349 }
 350
 351 void ASND_Init()
 352 {
 353         u32 i,level;
 354
 355         DSP_Init();
 356         AUDIO_Init(NULL);
 357         AUDIO_StopDMA(); // in case audio was previously inited and a DMA callback set
 358         AUDIO_SetDSPSampleRate(AI_SAMPLERATE_48KHZ);
 359
 360         _CPU_ISR_Disable(level);
 361         if(!asnd_inited) {
 362                 asnd_inited = 1;
 363                 global_pause = 1;
 364                 curr_audio_buf = 0;
 365                 DSP_DI_HANDLER = 1;
 366                 dsp_complete = 0;
 367                 dsp_done = 0;
 368
 369                 snd_set0w((s32*)mute_buf, SND_BUFFERSIZE>>2);
 370                 snd_set0w((s32*)audio_buf[0], SND_BUFFERSIZE>>2);
 371                 snd_set0w((s32*)audio_buf[1], SND_BUFFERSIZE>>2);
 372                 DCFlushRange(mute_buf,SND_BUFFERSIZE);
 373                 DCFlushRange(audio_buf[0],SND_BUFFERSIZE);
 374                 DCFlushRange(audio_buf[1],SND_BUFFERSIZE);
 375
 376                 for(i=0;i<MAX_SND_VOICES;i++)
 377                         snd_set0w((s32*)&sound_data[i],sizeof(t_sound_data)/4);
 378
 379                 dsp_task.prio = 255;
 380                 dsp_task.iram_maddr = (u16*)MEM_VIRTUAL_TO_PHYSICAL(dsp_mixer);
 381                 dsp_task.iram_len = dsp_mixer_size;
 382                 dsp_task.iram_addr = 0x0000;
 383                 dsp_task.init_vec = 0x10;
 384                 dsp_task.res_cb = NULL;
 385                 dsp_task.req_cb = __dsp_requestcallback;
 386                 dsp_task.init_cb =__dsp_initcallback;
 387                 dsp_task.done_cb =__dsp_donecallback;
 388                 DSP_AddTask(&dsp_task);
 389         }
 390         AUDIO_RegisterDMACallback(audio_dma_callback);
 391         AUDIO_InitDMA((u32)audio_buf[curr_audio_buf],SND_BUFFERSIZE);
 392         AUDIO_StartDMA();
 393
 394         _CPU_ISR_Restore(level);
 395 }
 396
 397 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 398
 399 void ASND_End()
 400 {
 401    if(asnd_inited) {
 402        AUDIO_StopDMA();
 403        DSP_DI_HANDLER=1;
 404        usleep(100);
 405        AUDIO_RegisterDMACallback(NULL);
 406        DSP_DI_HANDLER=1;
 407            dsp_done = 0;
 408            DSP_SendMailTo(0x999);
 409            while(DSP_CheckMailTo());
 410            while(!dsp_done);
 411            asnd_inited=0;
 412    }
 413 }
 414
 415 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 416
 417 s32 ASND_SetVoice(s32 voice, s32 format, s32 pitch,s32 delay, void *snd, s32 size_snd, s32 volume_l, s32 volume_r, ASNDVoiceCallback callback)
 418 {
 419         u32 level;
 420         u32 flag_h=0;
 421
 422         if(voice<0 || voice>=MAX_SND_VOICES) return SND_INVALID; // invalid voice
 423
 424         if(size_snd<=0 || snd==NULL) return SND_INVALID; // invalid voice
 425
 426         DCFlushRange(snd, size_snd);
 427
 428         if(pitch<1) pitch=1;
 429         if(pitch>MAX_PITCH) pitch=MAX_PITCH;
 430
 431         volume_l &=255;
 432         volume_r &=255;
 433
 434         delay=(u32) (48000LL*((u64) delay)/1000LL);
 435
 436         format&=7;
 437
 438         switch(format&3)
 439         {
 440         case 0:
 441                 flag_h=1<<16;break;
 442         case 1:
 443         case 2:
 444                 flag_h=2<<16;break;
 445         case 3:
 446                 flag_h=4<<16;break;
 447         }
 448
 449         format|= flag_h | VOICE_UPDATE;
 450
 451         _CPU_ISR_Disable(level);
 452
 453         sound_data[voice].left=0;
 454         sound_data[voice].right=0;
 455         sound_data[voice].counter=0;
 456
 457         sound_data[voice].freq=pitch;
 458
 459         sound_data[voice].delay_samples=delay;
 460
 461         sound_data[voice].volume_l= volume_l;
 462         sound_data[voice].volume_r= volume_r;
 463
 464         sound_data[voice].backup_addr=sound_data[voice].start_addr=MEM_VIRTUAL_TO_PHYSICAL(snd);
 465         sound_data[voice].end_addr=MEM_VIRTUAL_TO_PHYSICAL(snd)+(size_snd);
 466
 467         sound_data[voice].start_addr2=0;
 468         sound_data[voice].end_addr2=0;
 469
 470         sound_data[voice].volume2_l= volume_l;
 471         sound_data[voice].volume2_r= volume_r;
 472
 473         sound_data[voice].flags=format;
 474         sound_data[voice].tick_counter=0;
 475
 476         sound_data[voice].cb = callback;
 477         _CPU_ISR_Restore(level);
 478
 479         return SND_OK;
 480 }
 481
 482 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 483
 484 s32 ASND_SetInfiniteVoice(s32 voice, s32 format, s32 pitch,s32 delay, void *snd, s32 size_snd, s32 volume_l, s32 volume_r)
 485 {
 486         u32 level;
 487         u32 flag_h=0;
 488
 489         if(voice<0 || voice>=MAX_SND_VOICES) return SND_INVALID; // invalid voice
 490
 491         if(size_snd<=0 || snd==NULL) return SND_INVALID; // invalid voice
 492
 493         DCFlushRange(snd, size_snd);
 494
 495         if(pitch<1) pitch=1;
 496         if(pitch>MAX_PITCH) pitch=MAX_PITCH;
 497
 498         volume_l &=255;
 499         volume_r &=255;
 500
 501         delay=(u32) (48000LL*((u64) delay)/1000LL);
 502
 503         format&=7;
 504
 505         switch(format&3)
 506         {
 507         case 0:
 508                 flag_h=1<<16;break;
 509         case 1:
 510         case 2:
 511                 flag_h=2<<16;break;
 512         case 3:
 513                 flag_h=4<<16;break;
 514         }
 515
 516         format|= flag_h | VOICE_UPDATE | VOICE_SETLOOP;
 517
 518         _CPU_ISR_Disable(level);
 519
 520         sound_data[voice].left=0;
 521         sound_data[voice].right=0;
 522         sound_data[voice].counter=0;
 523
 524         sound_data[voice].freq=pitch;
 525
 526         sound_data[voice].delay_samples=delay;
 527
 528         sound_data[voice].volume_l= volume_l;
 529         sound_data[voice].volume_r= volume_r;
 530
 531         sound_data[voice].backup_addr=sound_data[voice].start_addr=MEM_VIRTUAL_TO_PHYSICAL(snd);
 532         sound_data[voice].end_addr=MEM_VIRTUAL_TO_PHYSICAL(snd)+(size_snd);
 533
 534         sound_data[voice].start_addr2=sound_data[voice].start_addr;
 535         sound_data[voice].end_addr2=sound_data[voice].end_addr;
 536
 537         sound_data[voice].volume2_l= volume_l;
 538         sound_data[voice].volume2_r= volume_r;
 539
 540         sound_data[voice].flags=format;
 541         sound_data[voice].tick_counter=0;
 542
 543         sound_data[voice].cb=NULL;
 544         _CPU_ISR_Restore(level);
 545
 546         return SND_OK;
 547 }
 548
 549 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 550
 551 s32 ASND_AddVoice(s32 voice, void *snd, s32 size_snd)
 552 {
 553         u32 level;
 554         s32 ret=SND_OK;
 555
 556         if(voice<0 || voice>=MAX_SND_VOICES) return SND_INVALID; // invalid voice
 557
 558         if(size_snd<=0 || snd==NULL) return SND_INVALID; // invalid voice
 559
 560         if((sound_data[voice].flags & (VOICE_UPDATE | VOICE_UPDATEADD)) || !(sound_data[voice].flags>>16)) return SND_INVALID; // busy or unused voice
 561
 562         DCFlushRange(snd, size_snd);
 563         _CPU_ISR_Disable(level);
 564
 565         if(sound_data[voice].start_addr2==0)
 566         {
 567
 568                 sound_data[voice].start_addr2=MEM_VIRTUAL_TO_PHYSICAL(snd);
 569                 sound_data[voice].end_addr2=MEM_VIRTUAL_TO_PHYSICAL(snd)+(size_snd);
 570
 571                 sound_data[voice].flags&=~VOICE_SETLOOP;
 572                 sound_data[voice].flags|=VOICE_UPDATEADD;
 573         } else ret=SND_BUSY;
 574
 575         _CPU_ISR_Restore(level);
 576
 577         return ret;
 578 }
 579
 580 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 581
 582 s32 ASND_TestVoiceBufferReady(s32 voice)
 583 {
 584         if(voice<0 || voice>=MAX_SND_VOICES) return 0; // invalid voice: not ready (of course XD)
 585         if(sound_data[voice].start_addr && sound_data[voice].start_addr2) return 0; // not ready
 586
 587         return 1; // ready
 588 }
 589
 590 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 591
 592 s32 ASND_TestPointer(s32 voice, void *pointer)
 593 {
 594         u32 level;
 595         u32 addr2=(u32) MEM_VIRTUAL_TO_PHYSICAL(pointer);
 596         int ret=SND_OK;
 597
 598         if(voice<0 || voice>=MAX_SND_VOICES) return SND_INVALID; // invalid voice
 599
 600         _CPU_ISR_Disable(level);
 601
 602         if(sound_data[voice].backup_addr==addr2 /*&& sound_data[voice].end_addr>(addr2)*/) ret=SND_BUSY;
 603         else
 604                 if(sound_data[voice].start_addr2==addr2 /*&& sound_data[voice].end_addr2>(addr2)*/) ret=SND_BUSY;
 605
 606         _CPU_ISR_Restore(level);
 607
 608         return ret;
 609 }
 610
 611 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 612
 613 s32 ASND_PauseVoice(s32 voice, s32 pause)
 614 {
 615         if(voice<0 || voice>=MAX_SND_VOICES) return SND_INVALID; // invalid voice
 616         if(pause) sound_data[voice].flags|=VOICE_PAUSE; else sound_data[voice].flags&=~VOICE_PAUSE;
 617
 618         return SND_OK;
 619 }
 620
 621 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 622
 623 s32 ASND_StopVoice(s32 voice)
 624 {
 625         u32 level;
 626
 627         if(voice<0 || voice>=MAX_SND_VOICES) return SND_INVALID; // invalid voice
 628
 629         _CPU_ISR_Disable(level);
 630
 631         sound_data[voice].backup_addr=sound_data[voice].start_addr=sound_data[voice].start_addr2=0;
 632         sound_data[voice].end_addr=sound_data[voice].end_addr2=0;
 633         sound_data[voice].flags=0;
 634
 635         _CPU_ISR_Restore(level);
 636
 637         return SND_OK;
 638 }
 639
 640 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 641
 642 s32 ASND_StatusVoice(s32 voice)
 643 {
 644         u32 level;
 645         s32 status=SND_WORKING;
 646
 647         if(voice<0 || voice>=MAX_SND_VOICES) return SND_INVALID; // invalid voice
 648
 649         _CPU_ISR_Disable(level);
 650         if(!(sound_data[voice].flags>>16)) status=SND_UNUSED;
 651         if(sound_data[voice].flags & VOICE_PAUSE) status=SND_WAITING;
 652         _CPU_ISR_Restore(level);
 653
 654         return status;
 655 }
 656
 657 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 658
 659 s32 ASND_ChangeVolumeVoice(s32 voice, s32 volume_l, s32 volume_r)
 660 {
 661         u32 level;
 662
 663         if(voice<0 || voice>=MAX_SND_VOICES) return SND_INVALID; // invalid voice
 664
 665         volume_l &=255;
 666         volume_r &=255;
 667
 668         _CPU_ISR_Disable(level);
 669         sound_data[voice].flags |=VOICE_VOLUPDATE;
 670         sound_data[voice].volume_l= sound_data[voice].volume2_l= volume_l;
 671         sound_data[voice].volume_r= sound_data[voice].volume2_r= volume_r;
 672         _CPU_ISR_Restore(level);
 673
 674         return SND_OK;
 675 }
 676
 677 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 678
 679 u32 ASND_GetTickCounterVoice(s32 voice)
 680 {
 681         if(voice<0 || voice>=MAX_SND_VOICES) return 0; // invalid voice
 682
 683         return (sound_data[voice].tick_counter * SND_BUFFERSIZE/4);
 684 }
 685
 686 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 687
 688 u32 ASND_GetTimerVoice(s32 voice)
 689 {
 690         if(voice<0 || voice>=MAX_SND_VOICES) return 0; // invalid voice
 691
 692         return (sound_data[voice].tick_counter * SND_BUFFERSIZE/4)/48;
 693 }
 694
 695 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 696
 697 void ASND_Pause(s32 pause)
 698 {
 699         global_pause=pause;
 700
 701 }
 702
 703 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 704
 705 s32 ASND_Is_Paused()
 706 {
 707         return global_pause;
 708 }
 709
 710 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 711
 712 u32 ASND_GetTime()
 713 {
 714         return (global_counter * SND_BUFFERSIZE/4)/48;
 715 }
 716
 717 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 718
 719 u32 ASND_GetSampleCounter()
 720 {
 721         return (global_counter * SND_BUFFERSIZE/4);
 722 }
 723
 724 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 725
 726 u32 ASND_GetSamplesPerTick()
 727 {
 728         return (SND_BUFFERSIZE/4);
 729 }
 730
 731 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 732
 733 void ASND_SetTime(u32 time)
 734 {
 735         global_counter=48*time;
 736 }
 737
 738 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 739
 740 void ASND_SetCallback(void (*callback)())
 741 {
 742         global_callback=callback;
 743 }
 744
 745 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 746
 747 s32 ASND_GetAudioRate()
 748 {
 749         return 48000;
 750 }
 751
 752 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 753
 754 s32 ASND_GetFirstUnusedVoice()
 755 {
 756
 757         s32 n;
 758
 759         for(n=1;n<MAX_SND_VOICES;n++)
 760                 if(!(sound_data[n].flags>>16)) return n;
 761
 762         if(!(sound_data[0].flags>>16)) return 0; // voice 0 is a special case
 763
 764         return SND_INVALID;  // all voices used
 765
 766 }
 767
 768 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 769
 770 s32 ASND_ChangePitchVoice(s32 voice, s32 pitch)
 771 {
 772         u32 level;
 773
 774         if(voice<0 || voice>=MAX_SND_VOICES) return SND_INVALID; // invalid voice
 775
 776         if(pitch<1) pitch=1;
 777         if(pitch>144000) pitch=144000;
 778
 779         _CPU_ISR_Disable(level);
 780         sound_data[voice].freq= pitch;
 781         _CPU_ISR_Restore(level);
 782
 783         return SND_OK;
 784 }
 785
 786 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 787
 788 u32 ASND_GetDSP_PercentUse()
 789 {
 790         return (time_of_process)*100/21333; // time_of_process = nanoseconds , 1024 samples= 21333 nanoseconds
 791 }
 792
 793 u32 ASND_GetDSP_ProcessTime()
 794 {
 795         u32 level,ret;
 796
 797         _CPU_ISR_Disable(level);
 798         ret = time_of_process;
 799         _CPU_ISR_Restore(level);
 800
 801         return ticks_to_nanosecs(ret);
 802 }
 803
 804 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 805
 806 int ANote2Freq(int note, int freq_base,int note_base)
 807 {
 808         int n;
 809         static int one=1;
 810         static u32 tab_piano_frac[12];
 811
 812         if(one)
 813         {
 814                 float note=1.0f;
 815                 one=0;
 816                 for(n=0;n<12;n++) // table note
 817                 {
 818                         tab_piano_frac[n]=(u32)(10000.0f*note);
 819                         note*=1.0594386f;
 820                 }
 821         }
 822
 823         // obtiene octava 3 (notas 36 a 47)
 824
 825         n=(note/12)-(note_base/12);
 826         if(n>=0) freq_base<<=n;
 827         else freq_base>>= -n;
 828
 829
 830         if(freq_base<=0x1ffff) // Math precision
 831                 n=(s32) (((u32)freq_base)*tab_piano_frac[(note % 12)]/tab_piano_frac[(note_base % 12)]);
 832         else
 833                 n=(s32) (((u64)freq_base)*((u64) tab_piano_frac[(note % 12)])/((u64) tab_piano_frac[(note_base % 12)]));
 834
 835
 836         return n;
 837 }
 838
 839 // END
 840