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   256
  46 #define VOICE_UPDATE      128
  47 #define VOICE_VOLUPDATE    64
  48 #define VOICE_PAUSE        32
  49 #define VOICE_SETLOOP       4
  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) | (loop<<2) | (type & 3) 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 = size_dsp_mixer;
 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&=3;
 437
 438         switch(format)
 439         {
 440         case 0:
 441                 flag_h=1<<16;break;
 442         case 1:
 443                 flag_h=2<<16;break;
 444         case 2:
 445                 flag_h=2<<16;break;
 446         case 3:
 447                 flag_h=4<<16;break;
 448         }
 449
 450         format|= flag_h | VOICE_UPDATE;
 451
 452         _CPU_ISR_Disable(level);
 453
 454         sound_data[voice].left=0;
 455         sound_data[voice].right=0;
 456         sound_data[voice].counter=0;
 457
 458         sound_data[voice].freq=pitch;
 459
 460         sound_data[voice].delay_samples=delay;
 461
 462         sound_data[voice].volume_l= volume_l;
 463         sound_data[voice].volume_r= volume_r;
 464
 465         sound_data[voice].backup_addr=sound_data[voice].start_addr=MEM_VIRTUAL_TO_PHYSICAL(snd);
 466         sound_data[voice].end_addr=MEM_VIRTUAL_TO_PHYSICAL(snd)+(size_snd);
 467
 468         sound_data[voice].start_addr2=0;
 469         sound_data[voice].end_addr2=0;
 470
 471         sound_data[voice].volume2_l= volume_l;
 472         sound_data[voice].volume2_r= volume_r;
 473
 474         sound_data[voice].flags=format;
 475         sound_data[voice].tick_counter=0;
 476
 477         sound_data[voice].cb = callback;
 478         _CPU_ISR_Restore(level);
 479
 480         return SND_OK;
 481 }
 482
 483 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 484
 485 s32 ASND_SetInfiniteVoice(s32 voice, s32 format, s32 pitch,s32 delay, void *snd, s32 size_snd, s32 volume_l, s32 volume_r)
 486 {
 487         u32 level;
 488         u32 flag_h=0;
 489
 490         if(voice<0 || voice>=MAX_SND_VOICES) return SND_INVALID; // invalid voice
 491
 492         if(size_snd<=0 || snd==NULL) return SND_INVALID; // invalid voice
 493
 494         DCFlushRange(snd, size_snd);
 495
 496         if(pitch<1) pitch=1;
 497         if(pitch>MAX_PITCH) pitch=MAX_PITCH;
 498
 499         volume_l &=255;
 500         volume_r &=255;
 501
 502         delay=(u32) (48000LL*((u64) delay)/1000LL);
 503
 504         format&=3;
 505
 506         switch(format)
 507         {
 508         case 0:
 509                 flag_h=1<<16;break;
 510         case 1:
 511                 flag_h=2<<16;break;
 512         case 2:
 513                 flag_h=2<<16;break;
 514         case 3:
 515                 flag_h=4<<16;break;
 516         }
 517
 518         format|= flag_h | VOICE_UPDATE | VOICE_SETLOOP;
 519
 520         _CPU_ISR_Disable(level);
 521
 522         sound_data[voice].left=0;
 523         sound_data[voice].right=0;
 524         sound_data[voice].counter=0;
 525
 526         sound_data[voice].freq=pitch;
 527
 528         sound_data[voice].delay_samples=delay;
 529
 530         sound_data[voice].volume_l= volume_l;
 531         sound_data[voice].volume_r= volume_r;
 532
 533         sound_data[voice].backup_addr=sound_data[voice].start_addr=MEM_VIRTUAL_TO_PHYSICAL(snd);
 534         sound_data[voice].end_addr=MEM_VIRTUAL_TO_PHYSICAL(snd)+(size_snd);
 535
 536         sound_data[voice].start_addr2=sound_data[voice].start_addr;
 537         sound_data[voice].end_addr2=sound_data[voice].end_addr;
 538
 539         sound_data[voice].volume2_l= volume_l;
 540         sound_data[voice].volume2_r= volume_r;
 541
 542         sound_data[voice].flags=format;
 543         sound_data[voice].tick_counter=0;
 544
 545         sound_data[voice].cb=NULL;
 546         _CPU_ISR_Restore(level);
 547
 548         return SND_OK;
 549 }
 550
 551 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 552
 553 s32 ASND_AddVoice(s32 voice, void *snd, s32 size_snd)
 554 {
 555         u32 level;
 556         s32 ret=SND_OK;
 557
 558         if(voice<0 || voice>=MAX_SND_VOICES) return SND_INVALID; // invalid voice
 559
 560         if(size_snd<=0 || snd==NULL) return SND_INVALID; // invalid voice
 561
 562         if((sound_data[voice].flags & (VOICE_UPDATE | VOICE_UPDATEADD)) || !(sound_data[voice].flags>>16)) return SND_INVALID; // busy or unused voice
 563
 564         DCFlushRange(snd, size_snd);
 565         _CPU_ISR_Disable(level);
 566
 567         if(sound_data[voice].start_addr2==0)
 568         {
 569
 570                 sound_data[voice].start_addr2=MEM_VIRTUAL_TO_PHYSICAL(snd);
 571                 sound_data[voice].end_addr2=MEM_VIRTUAL_TO_PHYSICAL(snd)+(size_snd);
 572
 573                 sound_data[voice].flags&=~VOICE_SETLOOP;
 574                 sound_data[voice].flags|=VOICE_UPDATEADD;
 575         } else ret=SND_BUSY;
 576
 577         _CPU_ISR_Restore(level);
 578
 579         return ret;
 580 }
 581
 582 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 583
 584 s32 ASND_TestVoiceBufferReady(s32 voice)
 585 {
 586         if(voice<0 || voice>=MAX_SND_VOICES) return 0; // invalid voice: not ready (of course XD)
 587         if(sound_data[voice].start_addr && sound_data[voice].start_addr2) return 0; // not ready
 588
 589         return 1; // ready
 590 }
 591
 592 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 593
 594 s32 ASND_TestPointer(s32 voice, void *pointer)
 595 {
 596         u32 level;
 597         u32 addr2=(u32) MEM_VIRTUAL_TO_PHYSICAL(pointer);
 598         int ret=SND_OK;
 599
 600         if(voice<0 || voice>=MAX_SND_VOICES) return SND_INVALID; // invalid voice
 601
 602         _CPU_ISR_Disable(level);
 603
 604         if(sound_data[voice].backup_addr==addr2 /*&& sound_data[voice].end_addr>(addr2)*/) ret=SND_BUSY;
 605         else
 606                 if(sound_data[voice].start_addr2==addr2 /*&& sound_data[voice].end_addr2>(addr2)*/) ret=SND_BUSY;
 607
 608         _CPU_ISR_Restore(level);
 609
 610         return ret;
 611 }
 612
 613 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 614
 615 s32 ASND_PauseVoice(s32 voice, s32 pause)
 616 {
 617         if(voice<0 || voice>=MAX_SND_VOICES) return SND_INVALID; // invalid voice
 618         if(pause) sound_data[voice].flags|=VOICE_PAUSE; else sound_data[voice].flags&=~VOICE_PAUSE;
 619
 620         return SND_OK;
 621 }
 622
 623 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 624
 625 s32 ASND_StopVoice(s32 voice)
 626 {
 627         u32 level;
 628
 629         if(voice<0 || voice>=MAX_SND_VOICES) return SND_INVALID; // invalid voice
 630
 631         _CPU_ISR_Disable(level);
 632
 633         sound_data[voice].backup_addr=sound_data[voice].start_addr=sound_data[voice].start_addr2=0;
 634         sound_data[voice].end_addr=sound_data[voice].end_addr2=0;
 635         sound_data[voice].flags=0;
 636
 637         _CPU_ISR_Restore(level);
 638
 639         return SND_OK;
 640 }
 641
 642 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 643
 644 s32 ASND_StatusVoice(s32 voice)
 645 {
 646         u32 level;
 647         s32 status=SND_WORKING;
 648
 649         if(voice<0 || voice>=MAX_SND_VOICES) return SND_INVALID; // invalid voice
 650
 651         _CPU_ISR_Disable(level);
 652         if(!(sound_data[voice].flags>>16)) status=SND_UNUSED;
 653         if(sound_data[voice].flags & VOICE_PAUSE) status=SND_WAITING;
 654         _CPU_ISR_Restore(level);
 655
 656         return status;
 657 }
 658
 659 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 660
 661 s32 ASND_ChangeVolumeVoice(s32 voice, s32 volume_l, s32 volume_r)
 662 {
 663         u32 level;
 664
 665         if(voice<0 || voice>=MAX_SND_VOICES) return SND_INVALID; // invalid voice
 666
 667         volume_l &=255;
 668         volume_r &=255;
 669
 670         _CPU_ISR_Disable(level);
 671         sound_data[voice].flags |=VOICE_VOLUPDATE;
 672         sound_data[voice].volume_l= sound_data[voice].volume2_l= volume_l;
 673         sound_data[voice].volume_r= sound_data[voice].volume2_r= volume_r;
 674         _CPU_ISR_Restore(level);
 675
 676         return SND_OK;
 677 }
 678
 679 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 680
 681 u32 ASND_GetTickCounterVoice(s32 voice)
 682 {
 683         if(voice<0 || voice>=MAX_SND_VOICES) return 0; // invalid voice
 684
 685         return (sound_data[voice].tick_counter * SND_BUFFERSIZE/4);
 686 }
 687
 688 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 689
 690 u32 ASND_GetTimerVoice(s32 voice)
 691 {
 692         if(voice<0 || voice>=MAX_SND_VOICES) return 0; // invalid voice
 693
 694         return (sound_data[voice].tick_counter * SND_BUFFERSIZE/4)/48;
 695 }
 696
 697 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 698
 699 void ASND_Pause(s32 pause)
 700 {
 701         global_pause=pause;
 702
 703 }
 704
 705 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 706
 707 s32 ASND_Is_Paused()
 708 {
 709         return global_pause;
 710 }
 711
 712 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 713
 714 u32 ASND_GetTime()
 715 {
 716         return (global_counter * SND_BUFFERSIZE/4)/48;
 717 }
 718
 719 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 720
 721 u32 ASND_GetSampleCounter()
 722 {
 723         return (global_counter * SND_BUFFERSIZE/4);
 724 }
 725
 726 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 727
 728 u32 ASND_GetSamplesPerTick()
 729 {
 730         return (SND_BUFFERSIZE/4);
 731 }
 732
 733 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 734
 735 void ASND_SetTime(u32 time)
 736 {
 737         global_counter=48*time;
 738 }
 739
 740 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 741
 742 void ASND_SetCallback(void (*callback)())
 743 {
 744         global_callback=callback;
 745 }
 746
 747 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 748
 749 s32 ASND_GetAudioRate()
 750 {
 751         return 48000;
 752 }
 753
 754 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 755
 756 s32 ASND_GetFirstUnusedVoice()
 757 {
 758
 759         s32 n;
 760
 761         for(n=1;n<MAX_SND_VOICES;n++)
 762                 if(!(sound_data[n].flags>>16)) return n;
 763
 764         if(!(sound_data[0].flags>>16)) return 0; // voice 0 is a special case
 765
 766         return SND_INVALID;  // all voices used
 767
 768 }
 769
 770 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 771
 772 s32 ASND_ChangePitchVoice(s32 voice, s32 pitch)
 773 {
 774         u32 level;
 775
 776         if(voice<0 || voice>=MAX_SND_VOICES) return SND_INVALID; // invalid voice
 777
 778         if(pitch<1) pitch=1;
 779         if(pitch>144000) pitch=144000;
 780
 781         _CPU_ISR_Disable(level);
 782         sound_data[voice].freq= pitch;
 783         _CPU_ISR_Restore(level);
 784
 785         return SND_OK;
 786 }
 787
 788 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 789
 790 u32 ASND_GetDSP_PercentUse()
 791 {
 792         return (time_of_process)*100/21333; // time_of_process = nanoseconds , 1024 samples= 21333 nanoseconds
 793 }
 794
 795 u32 ASND_GetDSP_ProcessTime()
 796 {
 797         u32 level,ret;
 798
 799         _CPU_ISR_Disable(level);
 800         ret = time_of_process;
 801         _CPU_ISR_Restore(level);
 802
 803         return ticks_to_nanosecs(ret);
 804 }
 805
 806 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 807
 808 int ANote2Freq(int note, int freq_base,int note_base)
 809 {
 810         int n;
 811         static int one=1;
 812         static u32 tab_piano_frac[12];
 813
 814         if(one)
 815         {
 816                 float note=1.0f;
 817                 one=0;
 818                 for(n=0;n<12;n++) // table note
 819                 {
 820                         tab_piano_frac[n]=(u32)(10000.0f*note);
 821                         note*=1.0594386f;
 822                 }
 823         }
 824
 825         // obtiene octava 3 (notas 36 a 47)
 826
 827         n=(note/12)-(note_base/12);
 828         if(n>=0) freq_base<<=n;
 829         else freq_base>>= -n;
 830
 831
 832         if(freq_base<=0x1ffff) // Math precision
 833                 n=(s32) (((u32)freq_base)*tab_piano_frac[(note % 12)]/tab_piano_frac[(note_base % 12)]);
 834         else
 835                 n=(s32) (((u64)freq_base)*((u64) tab_piano_frac[(note % 12)])/((u64) tab_piano_frac[(note_base % 12)]));
 836
 837
 838         return n;
 839 }
 840
 841 // END
 842