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/machine/processor.h>
  35
  36 #include "asndlib.h"
  37 #include "dsp_mixer.h"
  38
  39 #undef SND_BUFFERSIZE
  40
  41 #define MAX_SND_VOICES                  16
  42 #define SND_BUFFERSIZE                  (4096) // don´t modify this value
  43
  44 #define VOICE_UPDATEADD   256
  45 #define VOICE_UPDATE      128
  46 #define VOICE_VOLUPDATE    64
  47 #define VOICE_PAUSE        32
  48 #define VOICE_SETLOOP       4
  49
  50 typedef struct
  51 {
  52         void *out_buf;  // output buffer 4096 bytes aligned to 32
  53
  54         u32 delay_samples; // samples per delay to start (48000 == 1sec)
  55
  56         u32 flags;      // (step<<16) | (loop<<2) | (type & 3) used in DSP side
  57
  58         u32 start_addr; // internal addr counter
  59         u32 end_addr;   // end voice physical pointer(bytes without alignament, but remember it reads in blocks of 32 bytes (use padding to the end))
  60
  61         u32 freq;       // freq operation
  62
  63         s16 left, right; // internally used to store de last sample played
  64
  65         u32 counter;    // internally used to convert freq to 48000Hz samples
  66
  67         u16 volume_l,volume_r; // volume (from 0 to 256)
  68
  69         u32 start_addr2;        // initial voice2 physical pointer (bytes aligned  32 bytes) (to do a ring)
  70         u32 end_addr2;          // end voice2 physical pointer(bytes without alignament, but remember it reads in blocks of 32 bytes (use padding to the end))
  71
  72         u16 volume2_l,volume2_r; // volume (from 0 to 256) for voice 2
  73
  74         u32 backup_addr; // initial voice physical pointer backup (bytes aligned to 32 bytes): It is used for test pointers purpose
  75
  76         u32 tick_counter; // voice tick counter
  77
  78         ASNDVoiceCallback cb;
  79
  80         u32 _pad;
  81 } t_sound_data;
  82
  83 static dsptask_t dsp_task;
  84
  85 static vu32 time_of_process;
  86 static vu32 dsp_complete = 1;
  87 static vu32 dsp_task_starttime = 0;
  88 static vu32 curr_audio_buf = 0;
  89 static vu32 dsp_done = 0;
  90
  91 static vs32 snd_chan = 0;
  92 static vs32 global_pause = 1;
  93 static vu32 global_counter = 0;
  94
  95 static vu32 DSP_DI_HANDLER = 1;
  96 static void (*global_callback)()=NULL;
  97
  98 static u32 asnd_inited = 0;
  99 static t_sound_data sound_data[MAX_SND_VOICES];
 100
 101 static t_sound_data sound_data_dma ATTRIBUTE_ALIGN(32);
 102 static s16 audio_buf[2][SND_BUFFERSIZE] ATTRIBUTE_ALIGN(32);
 103
 104 extern u32 gettick();
 105
 106 static __inline__ char* snd_set0b( char *p, int n)
 107 {
 108         while(n>0) {*p++=0;n--;}
 109         return p;
 110 }
 111
 112 static __inline__ s32* snd_set0w( s32 *p, int n)
 113 {
 114         while(n>0) {*p++=0;n--;}
 115         return p;
 116 }
 117
 118 static void __dsp_initcallback(dsptask_t *task)
 119 {
 120         DSP_SendMailTo(0x0123); // command to fix the data operation
 121         while(DSP_CheckMailTo());
 122
 123         DSP_SendMailTo(MEM_VIRTUAL_TO_PHYSICAL((&sound_data_dma))); //send the data operation mem
 124         while(DSP_CheckMailTo());
 125
 126         dsp_complete=1;
 127         DSP_DI_HANDLER=0;
 128 }
 129
 130 static void __dsp_requestcallback(dsptask_t *task)
 131 {
 132         s32 n;
 133
 134         if(DSP_DI_HANDLER) return;
 135
 136         DCInvalidateRange(&sound_data_dma, sizeof(t_sound_data));
 137
 138         if(snd_chan>=MAX_SND_VOICES) {
 139                 if(!global_pause) global_counter++;
 140                 if(!dsp_complete) time_of_process = (gettick()-dsp_task_starttime)*1000/TB_TIMER_CLOCK;
 141
 142                 dsp_complete = 1;
 143                 return;
 144         }
 145
 146         sound_data_dma.freq=sound_data[snd_chan].freq;
 147         sound_data_dma.cb=sound_data[snd_chan].cb;
 148         if(sound_data[snd_chan].flags & VOICE_UPDATE) // new song
 149         {
 150                 sound_data[snd_chan].flags &=~(VOICE_UPDATE | VOICE_VOLUPDATE | VOICE_PAUSE | VOICE_UPDATEADD);
 151                 //sound_data[snd_chan].out_buf= (void *) MEM_VIRTUAL_TO_PHYSICAL((void *) audio_buf[curr_audio_buf]);
 152                 sound_data_dma=sound_data[snd_chan];
 153         }
 154         else
 155         {
 156
 157                 if(sound_data[snd_chan].flags & VOICE_VOLUPDATE)
 158                 {
 159                         sound_data[snd_chan].flags &=~VOICE_VOLUPDATE;
 160                         sound_data_dma.volume_l=sound_data_dma.volume2_l=sound_data[snd_chan].volume2_l;
 161                         sound_data_dma.volume_r=sound_data_dma.volume2_r=sound_data[snd_chan].volume2_r;
 162                 }
 163
 164
 165                 //if(mail==0xbebe0003) sound_data_dma.flags|=VOICE_SETCALLBACK;
 166
 167                 if(sound_data_dma.start_addr>=sound_data_dma.end_addr || !sound_data_dma.start_addr)
 168                 {
 169                         sound_data_dma.backup_addr=sound_data_dma.start_addr=sound_data_dma.start_addr2;
 170                         sound_data_dma.end_addr=sound_data_dma.end_addr2;
 171                         if(!(sound_data[snd_chan].flags & VOICE_SETLOOP)) {sound_data_dma.start_addr2=0;sound_data_dma.end_addr2=0;}
 172                         sound_data_dma.volume_l=sound_data_dma.volume2_l;
 173                         sound_data_dma.volume_r=sound_data_dma.volume2_r;
 174                 }
 175
 176                 if(sound_data[snd_chan].start_addr2 && (sound_data[snd_chan].flags & VOICE_UPDATEADD))
 177                 {
 178                         sound_data[snd_chan].flags &=~VOICE_UPDATEADD;
 179                         if(!sound_data[snd_chan].start_addr || !sound_data_dma.start_addr)
 180                         {
 181                                 sound_data_dma.backup_addr=sound_data_dma.start_addr=sound_data[snd_chan].start_addr2;
 182                                 sound_data_dma.end_addr=sound_data[snd_chan].end_addr2;
 183                                 sound_data_dma.start_addr2=sound_data[snd_chan].start_addr2;
 184                                 sound_data_dma.end_addr2=sound_data[snd_chan].end_addr2;
 185                                 if(!(sound_data[snd_chan].flags & VOICE_SETLOOP)) {sound_data_dma.start_addr2=0;sound_data_dma.end_addr2=0;}
 186                                 sound_data_dma.volume_l=sound_data[snd_chan].volume2_l;
 187                                 sound_data_dma.volume_r=sound_data[snd_chan].volume2_r;
 188                         }
 189                         else
 190                         {
 191                                 sound_data_dma.start_addr2=sound_data[snd_chan].start_addr2;
 192                                 sound_data_dma.end_addr2=sound_data[snd_chan].end_addr2;
 193                                 sound_data_dma.volume2_l=sound_data[snd_chan].volume2_l;
 194                                 sound_data_dma.volume2_r=sound_data[snd_chan].volume2_r;
 195                         }
 196
 197                 }
 198
 199                 if(!sound_data[snd_chan].cb && (!sound_data_dma.start_addr && !sound_data_dma.start_addr2)) sound_data[snd_chan].flags=0;
 200                 sound_data_dma.flags=sound_data[snd_chan].flags & ~(VOICE_UPDATE | VOICE_VOLUPDATE | VOICE_UPDATEADD);
 201                 sound_data[snd_chan]=sound_data_dma;
 202         }
 203
 204         if(sound_data[snd_chan].flags>>16)
 205         {
 206                 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++;
 207         }
 208
 209         snd_chan++;
 210
 211         if(!sound_data[snd_chan].cb && (!sound_data[snd_chan].start_addr && !sound_data[snd_chan].start_addr2)) sound_data[snd_chan].flags=0;
 212
 213         while(snd_chan<16 && !(sound_data[snd_chan].flags>>16)) snd_chan++;
 214
 215         if(snd_chan>=MAX_SND_VOICES)
 216         {
 217                 snd_chan++;
 218                 DCFlushRange(&sound_data_dma, sizeof(t_sound_data));
 219                 DSP_SendMailTo(0x666);
 220                 while(DSP_CheckMailTo());
 221                 return;
 222         }
 223
 224         sound_data_dma=sound_data[snd_chan];
 225
 226         DCFlushRange(&sound_data_dma, sizeof(t_sound_data));
 227         DSP_SendMailTo(0x222); // send the voice and mix the samples of the buffer
 228         while(DSP_CheckMailTo());
 229
 230         // callback strategy for next channel
 231         n=snd_chan+1;
 232
 233         while(n<16 && !(sound_data[n].flags>>16)) n++;
 234
 235         if(n<16)
 236         {
 237                 if(!sound_data[n].start_addr2 && (sound_data[n].flags>>16) && sound_data[n].cb) sound_data[n].cb(n);
 238
 239                 if(sound_data[snd_chan].flags & VOICE_VOLUPDATE)
 240                 {
 241                         sound_data[snd_chan].flags &=~VOICE_VOLUPDATE;
 242                 }
 243
 244                 if(sound_data[n].flags & VOICE_UPDATE) // new song
 245                 {
 246                         sound_data[n].flags &=~(VOICE_UPDATE | VOICE_VOLUPDATE | VOICE_PAUSE | VOICE_UPDATEADD);
 247                 }
 248
 249                 if(!sound_data[n].cb && (!sound_data[n].start_addr && !sound_data[n].start_addr2)) sound_data[n].flags=0;
 250         }
 251 }
 252
 253 static void __dsp_donecallback(dsptask_t *task)
 254 {
 255         dsp_done = 1;
 256 }
 257
 258 static void audio_dma_callback()
 259 {
 260         u32 n;
 261
 262         AUDIO_StopDMA();
 263         AUDIO_InitDMA((u32)audio_buf[curr_audio_buf],SND_BUFFERSIZE);
 264         if(DSP_DI_HANDLER || global_pause) {
 265                 snd_set0w((s32 *)audio_buf[curr_audio_buf],SND_BUFFERSIZE/4);
 266                 DCFlushRange(audio_buf[curr_audio_buf],SND_BUFFERSIZE);
 267         }
 268
 269         AUDIO_StartDMA();
 270
 271         if(DSP_DI_HANDLER || global_pause) return;
 272         if(dsp_complete==0) return;
 273
 274         curr_audio_buf ^= 1;
 275         dsp_complete = 0;
 276
 277         for(n=0;n<MAX_SND_VOICES;n++) sound_data[n].out_buf = (void *)MEM_VIRTUAL_TO_PHYSICAL((void *)audio_buf[curr_audio_buf]);
 278
 279         if(global_callback) global_callback();
 280
 281         snd_chan = 0;
 282         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);
 283
 284         if(sound_data[snd_chan].flags & VOICE_VOLUPDATE)
 285         {
 286                 sound_data[snd_chan].flags &=~VOICE_VOLUPDATE;
 287         }
 288
 289         if(sound_data[snd_chan].flags & VOICE_UPDATE) // new song
 290         {
 291                 sound_data[snd_chan].flags &=~(VOICE_UPDATE | VOICE_VOLUPDATE | VOICE_PAUSE | VOICE_UPDATEADD);
 292         }
 293         else
 294         {
 295
 296                 if(sound_data[snd_chan].start_addr>=sound_data[snd_chan].end_addr)
 297                 {
 298                         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;
 299                         sound_data[snd_chan].end_addr=sound_data[snd_chan].end_addr2;sound_data[snd_chan].end_addr2=0;
 300                         sound_data[snd_chan].volume_l=sound_data[snd_chan].volume2_l;
 301                         sound_data[snd_chan].volume_r=sound_data[snd_chan].volume2_r;
 302                 }
 303
 304                 if(sound_data[snd_chan].start_addr2 && (sound_data[snd_chan].flags & VOICE_UPDATEADD))
 305                 {
 306                         sound_data[snd_chan].flags &=~VOICE_UPDATEADD;
 307
 308                         if(!sound_data[snd_chan].start_addr)
 309                         {
 310                                 sound_data[snd_chan].backup_addr=sound_data[snd_chan].start_addr=sound_data[snd_chan].start_addr2;
 311                                 sound_data[snd_chan].end_addr=sound_data[snd_chan].end_addr2;
 312                                 if(!(sound_data[snd_chan].flags & VOICE_SETLOOP)) {sound_data[snd_chan].start_addr2=0;sound_data[snd_chan].end_addr2=0;}
 313                                 sound_data[snd_chan].volume_l=sound_data[snd_chan].volume2_l;
 314                                 sound_data[snd_chan].volume_r=sound_data[snd_chan].volume2_r;
 315                         }
 316
 317                 }
 318
 319         }
 320         if(!sound_data[snd_chan].cb && (!sound_data[snd_chan].start_addr && !sound_data[snd_chan].start_addr2)) sound_data[snd_chan].flags=0;
 321
 322         sound_data_dma=sound_data[snd_chan];
 323         DCFlushRange(&sound_data_dma, sizeof(t_sound_data));
 324
 325         dsp_task_starttime = gettick();
 326         DSP_SendMailTo(0x111); // send the first voice and clear the buffer
 327         while(DSP_CheckMailTo());
 328
 329         // callback strategy for next channel
 330         n=snd_chan+1;
 331
 332         while(n<16 && !(sound_data[n].flags>>16)) n++;
 333
 334         if(n<16)
 335         {
 336                 if(!sound_data[n].start_addr2 && (sound_data[n].flags>>16) && sound_data[n].cb) sound_data[n].cb(n);
 337
 338                 if(sound_data[n].flags & (VOICE_VOLUPDATE | VOICE_UPDATEADD))
 339                 {
 340                         sound_data[n].flags &=~(VOICE_VOLUPDATE | VOICE_UPDATEADD);
 341                 }
 342
 343                 if(sound_data[n].flags & VOICE_UPDATE) // new song
 344                 {
 345                         sound_data[n].flags &=~(VOICE_UPDATE | VOICE_VOLUPDATE| VOICE_PAUSE | VOICE_UPDATEADD);
 346                 }
 347
 348                 if(!sound_data[n].cb && (!sound_data[n].start_addr && !sound_data[n].start_addr2)) sound_data[n].flags=0;
 349         }
 350 }
 351
 352 void ASND_Init()
 353 {
 354         u32 i,level;
 355
 356         DSP_Init();
 357         AUDIO_Init(NULL);
 358         AUDIO_StopDMA(); // in case audio was previously inited and a DMA callback set
 359         AUDIO_SetDSPSampleRate(AI_SAMPLERATE_48KHZ);
 360
 361         _CPU_ISR_Disable(level);
 362         if(!asnd_inited) {
 363                 asnd_inited = 1;
 364                 global_pause = 1;
 365                 curr_audio_buf = 0;
 366                 DSP_DI_HANDLER = 1;
 367                 dsp_complete = 0;
 368                 dsp_done = 0;
 369
 370                 snd_set0w((s32*)audio_buf[0], SND_BUFFERSIZE>>2);
 371                 snd_set0w((s32*)audio_buf[1], SND_BUFFERSIZE>>2);
 372                 DCFlushRange(audio_buf[0],SND_BUFFERSIZE);
 373                 DCFlushRange(audio_buf[1],SND_BUFFERSIZE);
 374
 375                 for(i=0;i<MAX_SND_VOICES;i++)
 376                         snd_set0w((s32*)&sound_data[i],sizeof(t_sound_data)/4);
 377
 378                 dsp_task.prio = 255;
 379                 dsp_task.iram_maddr = (u16*)MEM_VIRTUAL_TO_PHYSICAL(dsp_mixer);
 380                 dsp_task.iram_len = size_dsp_mixer;
 381                 dsp_task.iram_addr = 0x0000;
 382                 dsp_task.init_vec = 0x10;
 383                 dsp_task.res_cb = NULL;
 384                 dsp_task.req_cb = __dsp_requestcallback;
 385                 dsp_task.init_cb =__dsp_initcallback;
 386                 dsp_task.done_cb =__dsp_donecallback;
 387                 DSP_AddTask(&dsp_task);
 388         }
 389         AUDIO_RegisterDMACallback(audio_dma_callback);
 390         AUDIO_InitDMA((u32)audio_buf[curr_audio_buf],SND_BUFFERSIZE);
 391         AUDIO_StartDMA();
 392         curr_audio_buf ^= 1;
 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 /*------------------------------------------------------------------------------------------------------------------------------------------------------*/
 796
 797 int ANote2Freq(int note, int freq_base,int note_base)
 798 {
 799         int n;
 800         static int one=1;
 801         static u32 tab_piano_frac[12];
 802
 803         if(one)
 804         {
 805                 float note=1.0f;
 806                 one=0;
 807                 for(n=0;n<12;n++) // table note
 808                 {
 809                         tab_piano_frac[n]=(u32)(10000.0f*note);
 810                         note*=1.0594386f;
 811                 }
 812         }
 813
 814         // obtiene octava 3 (notas 36 a 47)
 815
 816         n=(note/12)-(note_base/12);
 817         if(n>=0) freq_base<<=n;
 818         else freq_base>>= -n;
 819
 820
 821         if(freq_base<=0x1ffff) // Math precision
 822                 n=(s32) (((u32)freq_base)*tab_piano_frac[(note % 12)]/tab_piano_frac[(note_base % 12)]);
 823         else
 824                 n=(s32) (((u64)freq_base)*((u64) tab_piano_frac[(note % 12)])/((u64) tab_piano_frac[(note_base % 12)]));
 825
 826
 827         return n;
 828 }
 829
 830 // END
 831