plugins/spunull/spunull.c

   1 /////////////////////////////////////////////////////////
   2 // main emu calls:
   3 // 0. Get type/name/version
   4 // 1. Init
   5 // 2. SetCallbacks
   6 // 3. SetConfigFile
   7 // 4. Open
   8 // 5. Dma/register/xa calls...
   9 // 6. Close
  10 // 7. Shutdown
  11 /////////////////////////////////////////////////////////
  12
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include "register.h"
  17 #include "../../include/psemu_plugin_defs.h"
  18 // some ms windows compatibility define
  19 #undef CALLBACK
  20 #define CALLBACK
  21
  22 ////////////////////////////////////////////////////////////////////////
  23
  24 ////////////////////////////////////////////////////////////////////////
  25
  26 const unsigned char version  = 1;
  27 const unsigned char revision = 1;
  28 const unsigned char build    = 1;
  29 static char * libraryName    = "Pete's Null Audio Driver";
  30 static char * libraryInfo    = "Pete's Null Audio Driver V1.1\nCoded by Pete Bernert\n";
  31
  32 ////////////////////////////////////////////////////////////////////////
  33
  34 unsigned short  regArea[10000];                        // psx buffer
  35 unsigned short  spuMem[256*1024];
  36 unsigned char * spuMemC;
  37 unsigned char * pSpuIrq=0;
  38
  39 unsigned short spuCtrl, spuStat, spuIrq=0;             // some vars to store psx reg infos
  40 unsigned long  spuAddr=0xffffffff;                     // address into spu mem
  41 char *         pConfigFile=0;
  42
  43 ////////////////////////////////////////////////////////////////////////
  44
  45 ////////////////////////////////////////////////////////////////////////
  46
  47 void (CALLBACK *irqCallback)(void)=0;                   // func of main emu, called on spu irq
  48 void (CALLBACK *cddavCallback)(short, short)=0;
  49
  50 ////////////////////////////////////////////////////////////////////////
  51 // CODE AREA
  52 ////////////////////////////////////////////////////////////////////////
  53
  54 void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val, unsigned int cycles)
  55 {
  56  unsigned long r=reg&0xfff;
  57  regArea[(r-0xc00)>>1] = val;
  58
  59  if(r>=0x0c00 && r<0x0d80)
  60   {
  61    //int ch=(r>>4)-0xc0;
  62    switch(r&0x0f)
  63     {
  64      //------------------------------------------------// l volume
  65      case 0:
  66        //SetVolumeL(ch,val);
  67        return;
  68      //------------------------------------------------// r volume
  69      case 2:
  70        //SetVolumeR(ch,val);
  71        return;
  72      //------------------------------------------------// pitch
  73      case 4:
  74        //SetPitch(ch,val);
  75        return;
  76      //------------------------------------------------// start
  77      case 6:
  78        //s_chan[ch].pStart=spuMemC+((unsigned long) val<<3);
  79        return;
  80      //------------------------------------------------// adsr level
  81      case 8:
  82        return;
  83      //------------------------------------------------// adsr rate
  84      case 10:
  85       return;
  86      //------------------------------------------------// adsr volume
  87      case 12:
  88        return;
  89      //------------------------------------------------// loop adr
  90      case 14:
  91        return;
  92      //------------------------------------------------//
  93     }
  94    return;
  95   }
  96
  97  switch(r)
  98    {
  99     //-------------------------------------------------//
 100     case H_SPUaddr:
 101         spuAddr = (unsigned long) val<<3;
 102         return;
 103     //-------------------------------------------------//
 104     case H_SPUdata:
 105         spuMem[spuAddr>>1] = val;
 106         spuAddr+=2;
 107         if(spuAddr>0x7ffff) spuAddr=0;
 108         return;
 109     //-------------------------------------------------//
 110     case H_SPUctrl:
 111         spuCtrl=val;
 112         return;
 113     //-------------------------------------------------//
 114     case H_SPUstat:
 115         spuStat=val & 0xf800;
 116         return;
 117     //-------------------------------------------------//
 118     case H_SPUirqAddr:
 119         spuIrq = val;
 120         pSpuIrq=spuMemC+((unsigned long) val<<3);
 121         return;
 122     //-------------------------------------------------//
 123     case H_SPUon1:
 124         //SoundOn(0,16,val);
 125         return;
 126     //-------------------------------------------------//
 127     case H_SPUon2:
 128         //SoundOn(16,24,val);
 129         return;
 130     //-------------------------------------------------//
 131     case H_SPUoff1:
 132         //SoundOff(0,16,val);
 133         return;
 134     //-------------------------------------------------//
 135     case H_SPUoff2:
 136         //SoundOff(16,24,val);
 137         return;
 138     //-------------------------------------------------//
 139     case H_CDLeft:
 140         if(cddavCallback) cddavCallback(0,val);
 141         return;
 142     case H_CDRight:
 143         if(cddavCallback) cddavCallback(1,val);
 144         return;
 145     //-------------------------------------------------//
 146     case H_FMod1:
 147         //FModOn(0,16,val);
 148         return;
 149     //-------------------------------------------------//
 150     case H_FMod2:
 151         //FModOn(16,24,val);
 152         return;
 153     //-------------------------------------------------//
 154     case H_Noise1:
 155         //NoiseOn(0,16,val);
 156         return;
 157     //-------------------------------------------------//
 158     case H_Noise2:
 159         //NoiseOn(16,24,val);
 160         return;
 161     //-------------------------------------------------//
 162     case H_RVBon1:
 163         //ReverbOn(0,16,val);
 164         return;
 165     //-------------------------------------------------//
 166     case H_RVBon2:
 167         //ReverbOn(16,24,val);
 168         return;
 169     //-------------------------------------------------//
 170     case H_Reverb:
 171         return;
 172    }
 173 }
 174
 175 ////////////////////////////////////////////////////////////////////////\r
 176
 177 unsigned short CALLBACK SPUreadRegister(unsigned long reg, unsigned int cycles)
 178 {
 179  unsigned long r=reg&0xfff;
 180
 181  if(r>=0x0c00 && r<0x0d80)
 182   {
 183    switch(r&0x0f)
 184     {
 185      case 12:                                          // adsr vol
 186       {
 187        //int ch=(r>>4)-0xc0;
 188        static unsigned short adsr_dummy_vol=0;
 189        adsr_dummy_vol=!adsr_dummy_vol;
 190        return adsr_dummy_vol;
 191       }
 192
 193      case 14:                                          // return curr loop adr
 194       {
 195        //int ch=(r>>4)-0xc0;
 196        return 0;
 197       }
 198     }
 199   }
 200
 201  switch(r)
 202   {
 203     case H_SPUctrl:
 204         return spuCtrl;
 205
 206     case H_SPUstat:
 207         return spuStat;
 208
 209     case H_SPUaddr:
 210         return (unsigned short)(spuAddr>>3);
 211
 212     case H_SPUdata:
 213       {
 214        unsigned short s=spuMem[spuAddr>>1];
 215        spuAddr+=2;
 216        if(spuAddr>0x7ffff) spuAddr=0;
 217        return s;
 218       }
 219
 220     case H_SPUirqAddr:
 221         return spuIrq;
 222   }
 223  return regArea[(r-0xc00)>>1];
 224 }
 225
 226 ////////////////////////////////////////////////////////////////////////
 227
 228 unsigned short CALLBACK SPUreadDMA(void)
 229 {
 230  unsigned short s=spuMem[spuAddr>>1];
 231  spuAddr+=2;
 232  if(spuAddr>0x7ffff) spuAddr=0;
 233  return s;
 234 }
 235
 236 ////////////////////////////////////////////////////////////////////////
 237
 238 void CALLBACK SPUwriteDMA(unsigned short val)
 239 {
 240  spuMem[spuAddr>>1] = val;                             // spu addr got by writeregister\r
 241  spuAddr+=2;                                           // inc spu addr
 242  if(spuAddr>0x7ffff) spuAddr=0;                        // wrap
 243 }
 244
 245 ////////////////////////////////////////////////////////////////////////
 246
 247 void CALLBACK SPUwriteDMAMem(unsigned short * pusPSXMem,int iSize,unsigned int cycles)
 248 {
 249  int i;
 250  for(i=0;i<iSize;i++)
 251   {
 252    spuMem[spuAddr>>1] = *pusPSXMem++;                  // spu addr got by writeregister\r
 253    spuAddr+=2;                                         // inc spu addr
 254    if(spuAddr>0x7ffff) spuAddr=0;                      // wrap
 255   }
 256 }
 257
 258 ////////////////////////////////////////////////////////////////////////
 259
 260 void CALLBACK SPUreadDMAMem(unsigned short * pusPSXMem,int iSize,unsigned int cycles)
 261 {
 262  int i;
 263  for(i=0;i<iSize;i++)
 264   {
 265    *pusPSXMem++=spuMem[spuAddr>>1];                    // spu addr got by writeregister
 266    spuAddr+=2;                                         // inc spu addr
 267    if(spuAddr>0x7ffff) spuAddr=0;                      // wrap
 268   }
 269 }
 270
 271 ////////////////////////////////////////////////////////////////////////
 272 // XA AUDIO
 273 ////////////////////////////////////////////////////////////////////////
 274
 275 void CALLBACK SPUplayADPCMchannel(xa_decode_t *xap, unsigned int cycles, int is_start)
 276 {
 277 }
 278
 279 void CALLBACK SPUsetCDvol(unsigned char ll, unsigned char lr,
 280   unsigned char rl, unsigned char rr, unsigned int cycle)
 281 {
 282 }
 283
 284 ////////////////////////////////////////////////////////////////////////
 285
 286 ////////////////////////////////////////////////////////////////////////
 287 // INIT/EXIT STUFF
 288 ////////////////////////////////////////////////////////////////////////
 289
 290 long CALLBACK SPUinit(void)
 291 {
 292  spuMemC=(unsigned char *)spuMem;                      // just small setup
 293  return 0;
 294 }
 295
 296 ////////////////////////////////////////////////////////////////////////
 297
 298 int bSPUIsOpen=0;
 299
 300 long CALLBACK SPUopen(void)
 301 {
 302  if(bSPUIsOpen) return 0;
 303
 304  bSPUIsOpen=1;
 305
 306  //if(pConfigFile) ReadConfigFile(pConfigFile);
 307
 308  return PSE_SPU_ERR_SUCCESS;
 309 }
 310
 311 ////////////////////////////////////////////////////////////////////////
 312
 313 void SPUsetConfigFile(char * pCfg)
 314 {
 315  pConfigFile=pCfg;
 316 }
 317
 318 ////////////////////////////////////////////////////////////////////////
 319
 320 long CALLBACK SPUclose(void)
 321 {
 322  if(!bSPUIsOpen) return 0;
 323  bSPUIsOpen=0;
 324  return 0;
 325 }
 326
 327 ////////////////////////////////////////////////////////////////////////
 328
 329 long CALLBACK SPUshutdown(void)
 330 {
 331  return 0;
 332 }
 333
 334 void CALLBACK SPUconfigure(void)
 335 {
 336 }
 337
 338 ////////////////////////////////////////////////////////////////////////
 339 // MISC STUFF
 340 ////////////////////////////////////////////////////////////////////////
 341
 342 long CALLBACK SPUtest(void)
 343 {
 344  return 0;
 345 }
 346
 347 void SPUasync(unsigned int cycle, unsigned int flags)
 348 {
 349 }
 350
 351 int SPUplayCDDAchannel(short *pcm, int nbytes, unsigned int cycle, int is_start)
 352 {
 353  return -1;
 354 }
 355
 356 ////////////////////////////////////////////////////////////////////////
 357 // this functions will be called once,
 358 // passes a callback that should be called on SPU-IRQ
 359
 360 void CALLBACK SPUregisterCallback(void (CALLBACK *callback)(void))
 361 {
 362  irqCallback = callback;
 363 }
 364
 365 void CALLBACK SPUregisterCDDAVolume(void (CALLBACK *CDDAVcallback)(short, short))
 366 {
 367  cddavCallback = CDDAVcallback;
 368 }
 369
 370 ////////////////////////////////////////////////////////////////////////\r
 371
 372 char * CALLBACK PSEgetLibName(void)
 373 {
 374  return libraryName;
 375 }
 376
 377 ////////////////////////////////////////////////////////////////////////
 378
 379 unsigned long CALLBACK PSEgetLibType(void)
 380 {
 381  return  PSE_LT_SPU;
 382 }
 383
 384 ////////////////////////////////////////////////////////////////////////\r
 385
 386 unsigned long CALLBACK PSEgetLibVersion(void)\r
 387 {
 388  return version<<16|revision<<8|build;
 389 }
 390
 391
 392 char * SPUgetLibInfos(void)
 393 {
 394  return libraryInfo;
 395 }
 396
 397 ////////////////////////////////////////////////////////////////////////\r
 398
 399 typedef struct
 400 {
 401  unsigned long Future[256];
 402
 403 } SPUNULLFreeze_t;
 404
 405 ////////////////////////////////////////////////////////////////////////\r
 406
 407 long DoFreeze(int ulFreezeMode, SPUFreeze_t * pF, unsigned short **ram,
 408  void * pF2, unsigned int cycles)
 409 {
 410  int i;
 411
 412  if (ram)
 413   *ram = spuMem;
 414  if(!pF) return 0;
 415
 416  if(ulFreezeMode)
 417   {
 418    if(ulFreezeMode==1)
 419     memset(pF,0,sizeof(SPUFreeze_t)+sizeof(SPUNULLFreeze_t));
 420
 421    strcpy(pF->PluginName, "PBNUL");
 422    pF->PluginVersion = 1;
 423    pF->Size = sizeof(SPUFreeze_t)+sizeof(SPUNULLFreeze_t);
 424
 425    if(ulFreezeMode==2) return 1;
 426
 427    memcpy(pF->SPUPorts, regArea, 0x200);
 428    return 1;
 429   }
 430
 431  if(ulFreezeMode!=0) return 0;
 432
 433  memcpy(regArea, pF->SPUPorts, 0x200);
 434
 435  for(i=0;i<0x100;i++)
 436   {
 437    if(i!=H_SPUon1-0xc00 && i!=H_SPUon2-0xc00)
 438     SPUwriteRegister(0x1f801c00+i*2,regArea[i],cycles);
 439   }
 440  SPUwriteRegister(H_SPUon1,regArea[(H_SPUon1-0xc00)/2],cycles);
 441  SPUwriteRegister(H_SPUon2,regArea[(H_SPUon2-0xc00)/2],cycles);
 442
 443  return 1;
 444 }
 445
 446 void CALLBACK SPUregisterScheduleCb(void (CALLBACK *callback)(unsigned int))
 447 {
 448 }