home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 1999 September (IDG) / Sep99.iso / Shareware World / Info / For Developers / PlayerPRO 5.2 Dev.Kit Mac / MADH Library 5.2 / MADLibrary Source / Interrupt.c < prev    next >
Encoding:
Text File  |  1999-06-14  |  37.7 KB  |  1,498 lines  |  [TEXT/CWIE]
  1. /********************                        ***********************/
  2. //
  3. //    Player PRO 5.0 - DRIVER SOURCE CODE -
  4. //
  5. //    Library Version 5.0
  6. //
  7. //    To use with MAD Library for Mac: Symantec, CodeWarrior and MPW
  8. //
  9. //    Antoine ROSSET
  10. //    16 Tranchees
  11. //    1206 GENEVA
  12. //    SWITZERLAND
  13. //
  14. //    COPYRIGHT ANTOINE ROSSET 1996, 1997, 1998
  15. //
  16. //    Thank you for your interest in PlayerPRO !
  17. //
  18. //    FAX:                (+41 22) 346 11 97
  19. //    PHONE:             (+41 79) 203 74 62
  20. //    Internet:     RossetAntoine@bluewin.ch
  21. //
  22. /********************                        ***********************/
  23.  
  24. #include "RDriver.h"
  25. #include "RDriverInt.h"
  26.  
  27. #ifdef _MIDIHARDWARE_
  28. #include "OMS.h"
  29.  
  30. extern short        gOutNodeRefNum, gOutputPortRefNum;
  31. #endif
  32.  
  33. void SampleMIDI( Channel *curVoice, short channel, short curN, MADDriverRec *intDriver);
  34. void ApplyFilters( MADDriverRec *intDriver);
  35. void ApplySurround( MADDriverRec *intDriver);
  36. void SendMIDIClock( MADDriverRec *intDriver, Byte MIDIByte);
  37.  
  38. /*long DoVolPanning( short whichChannel, Channel *ch, MADDriverRec *intDriver)    // MAX = 64
  39. {
  40.     // Compute Volume !
  41.     long pannValue;
  42.     long temp = ( (long) ch->vol * (long) ch->volEnv * (long) ch->volFade) /( 64L*32767L );
  43.     
  44.     if( !intDriver->Active[ ch->ID]) return 0;
  45.     
  46.     if( intDriver->curMusic != 0L) temp = (temp * (long) intDriver->curMusic->header->chanVol[ ch->ID]) / MAX_VOLUME;
  47.     else temp = 64;
  48.     
  49.     // Compute Panning
  50.     
  51.     if( whichChannel != 3)
  52.     {
  53.         pannValue = ch->pannEnv;
  54.         
  55.         if( whichChannel == 1) pannValue = MAX_PANNING - pannValue;
  56.         
  57.         temp = (temp * pannValue) / MAX_PANNING;
  58.     }
  59.     
  60.     // Vol Global
  61.     
  62.     temp = (temp * intDriver->VolGlobal) / (MAX_VOLUME + 20);
  63.     
  64.     if( temp > 64) temp = 64;
  65.     
  66.     return temp;
  67. }*/
  68.  
  69. long DoVolPanning256( short whichChannel, Channel *ch, MADDriverRec *intDriver)    // MAX = 256
  70. {
  71.     // Compute Volume !
  72.     long pannValue;
  73.     long temp = ( (long) ch->vol * (long) ch->volEnv * (long) ch->volFade) /( 16L*32767L );
  74.     
  75.     if( !intDriver->Active[ ch->ID]) return 0;
  76.     
  77.     if( intDriver->curMusic != 0L) temp = (temp * (long) intDriver->curMusic->header->chanVol[ ch->ID]) / MAX_VOLUME;
  78.     else temp = 256;
  79.     
  80.     // Compute Panning
  81.     
  82.     if( whichChannel != 3)
  83.     {
  84.         pannValue = ch->pannEnv;
  85.         
  86.         if( whichChannel == 1) pannValue = MAX_PANNING - pannValue;
  87.         
  88.         temp = (temp * pannValue) / MAX_PANNING;
  89.     }
  90.     
  91.     // Vol Global
  92.     
  93.     temp = (temp * intDriver->VolGlobal) / (MAX_VOLUME + 10);    // ICI !!! + 20);
  94.     
  95. //    if( temp > 256) temp = 256;
  96.     
  97.     return temp;
  98. }
  99.  
  100. void MADCleanDriver( MADDriverRec *intDriver)
  101. {
  102.     short        i, x;
  103.  
  104.     for( i = 0; i < MAXTRACK; i++)
  105.     {
  106.         intDriver->chan[i].ID        = i;
  107.         
  108.         intDriver->chan[i].begPtr     = 0L;
  109.         intDriver->chan[i].maxPtr     = 0L;
  110.         intDriver->chan[i].curPtr     = 0L;
  111.         intDriver->chan[i].sizePtr     = 0L;
  112.         
  113.         intDriver->chan[i].amp        = 8;
  114.  
  115.         intDriver->chan[i].loopBeg     = 0;
  116.         intDriver->chan[i].loopSize    = 0;
  117.         
  118.         intDriver->chan[i].ins         = 0;
  119.         intDriver->chan[i].insOld     = 0;
  120.  
  121.         intDriver->chan[i].fineTune = NOFINETUNE;
  122.  
  123.         intDriver->chan[i].note        = 0xFF;
  124.         intDriver->chan[i].noteOld    = 0xFF;
  125.         
  126.         intDriver->chan[i].period    = GetOldPeriod( 40, NOFINETUNE, intDriver);
  127.         intDriver->chan[i].periodOld= GetOldPeriod( 40, NOFINETUNE, intDriver);
  128.         
  129.         intDriver->chan[i].vol        = 64;
  130.         intDriver->chan[i].cmd        = 0;
  131.         intDriver->chan[i].arg        = 0;
  132.         
  133.         for( x = 0; x < MAX_ARP; x++) intDriver->chan[i].arp[ x] = 0;
  134.         intDriver->chan[i].arpindex = 0;
  135.         intDriver->chan[i].arpUse = false;
  136.         
  137.         intDriver->chan[i].viboffset    = 0;
  138.         intDriver->chan[i].vibdepth     = 0;
  139.         intDriver->chan[i].vibrate         = 0;
  140.         intDriver->chan[i].vibtype         = 0;
  141.         intDriver->chan[i].slide         = 0;
  142.         intDriver->chan[i].pitchgoal     = 0;
  143.         intDriver->chan[i].pitchrate     = 0;
  144.         intDriver->chan[i].volumerate     = 0;
  145.         intDriver->chan[i].samplePtr     = 0L;
  146.         intDriver->chan[i].volcmd        = 0L;
  147.         
  148.         for( x = 0; x < 16; x++) intDriver->chan[ i].oldArg[ x] = 0;
  149.         
  150.         intDriver->chan[i].oldVibdepth = 0;
  151.         intDriver->chan[i].oldVibrate = 0;
  152.         
  153.         intDriver->chan[i].KeyOn        = false;
  154.         intDriver->chan[i].a            = 0;
  155.         intDriver->chan[i].b            = 1;
  156.         intDriver->chan[i].p            = 0;
  157.         intDriver->chan[i].volEnv        = 64;
  158.         intDriver->chan[i].volFade        = 32767;
  159.         intDriver->chan[i].lAC            = 0;
  160.         
  161.         intDriver->chan[i].lastWordR        = 0;
  162.         intDriver->chan[i].lastWordL        = 0;
  163.         intDriver->chan[i].curLevelL        = 0;
  164.         intDriver->chan[i].curLevelR        = 0;
  165.         intDriver->chan[i].prevPtr        = 0;
  166.         intDriver->chan[i].prevVol0        = DoVolPanning256( 0, &intDriver->chan[i], intDriver);
  167.         intDriver->chan[i].prevVol1        = DoVolPanning256( 1, &intDriver->chan[i], intDriver);
  168.         
  169.         intDriver->chan[i].loopType    = eClassicLoop;
  170.         intDriver->chan[i].pingpong    = false;
  171.         intDriver->chan[i].PanningE8 = false;
  172.         intDriver->chan[i].PatternLoopE6 = 1;
  173.         intDriver->chan[i].PatternLoopE6Count = 0;
  174.         intDriver->chan[i].PatternLoopE6ID = 0;
  175.         intDriver->chan[i].trig             = 0;
  176.         intDriver->chan[i].preOff            = 0xFFFFFFFF;
  177.         intDriver->chan[i].preVal2        = 0;
  178.         intDriver->chan[i].preVal2R        = 0;
  179.         
  180.         intDriver->chan[i].spreVal2        = 0;
  181.         intDriver->chan[i].spreVal2R    = 0;
  182.         
  183.         intDriver->chan[i].preVal            = 0;
  184.         intDriver->chan[i].spreVal        = 0;
  185.         
  186.         intDriver->chan[i].LevelDirectionR = true;
  187.         intDriver->chan[i].LevelDirectionL = true;
  188.         
  189.         intDriver->chan[i].RemoverWorking        = false;
  190.         intDriver->chan[i].TICKREMOVESIZE        = 1;
  191.     }
  192.     
  193.     intDriver->PatDelay = 0;
  194.     intDriver->BufCounter = 0;    intDriver->BytesToGenerate = 0;
  195.     
  196.     for( i = 0; i < MAXTRACK; i++) intDriver->TrackLineReading[ i] = true;
  197. }
  198.  
  199. long Interpolate(long p,long p1,long p2,long v1,long v2)
  200. {
  201.     long dp,dv,di;
  202.  
  203.     if( p1 == p2) return v1;
  204.  
  205.     dv=v2-v1;
  206.     dp=p2-p1;
  207.     di=p-p1;
  208.  
  209.     return v1 + ((long)(di*dv) / dp);
  210. }
  211.  
  212. long InterpolateEnv(long p, EnvRec *a,EnvRec *b)
  213. {
  214.     if( p < a->pos) return a->val;
  215.     return(Interpolate(p,a->pos,b->pos,a->val,b->val));
  216. }
  217.  
  218. void ProcessFadeOut( Channel *ch, MADDriverRec *intDriver)
  219. {
  220.     if( intDriver->curMusic != 0L)
  221.     {
  222.         if( !ch->KeyOn)
  223.         {
  224.         //    Str32    str;
  225.             if( !(intDriver->curMusic->fid[ ch->ins].volType & EFON))
  226.             {
  227.                 if( intDriver->curMusic->fid[ ch->ins].volFade == 0) ch->volFade = 0;
  228.                 else ch->volFade -= intDriver->curMusic->fid[ ch->ins].volFade;
  229.                 
  230.             /*    if( ch->volFade > 0)
  231.                 {
  232.                 NumToString( ch->volFade, str);
  233.                 DebugStr( str);
  234.                 }*/
  235.                 
  236.                 if( ch->volFade < 0)
  237.                 {
  238.                     ch->volFade     = 0;
  239.                     ch->loopBeg     = 0;
  240.                     ch->loopSize     = 0;
  241.                 }
  242.             }
  243.         }
  244.     }
  245. }
  246.  
  247. void ProcessEnvelope( Channel *ch, MADDriverRec *intDriver)
  248. {
  249.     long        v;
  250.     InstrData    *curIns;
  251.     
  252.     ch->volEnv = 64;
  253.     if( ch->ins < 0) return;
  254.     if( ch->samplePtr != 0L) return;
  255.     curIns = &intDriver->curMusic->fid[ ch->ins];
  256.     if( curIns->volSize <= 0) return;
  257.     
  258.     if( curIns->volType & EFON)
  259.     {
  260.         //  active? -> copy variables
  261.         
  262.         Byte     a,b;
  263.         short    p;
  264.         
  265.         a=ch->a;
  266.         b=ch->b;
  267.         p=ch->p;
  268.         
  269.         if( curIns->volSize == 1)        // Just 1 point !
  270.         {
  271.             v = curIns->volEnv[a].val;
  272.             p = curIns->volEnv[a].pos;
  273.         }
  274.         else
  275.         {
  276.             v = InterpolateEnv( p, &curIns->volEnv[a], &curIns->volEnv[b]);
  277.  
  278.             if((curIns->volType & EFSUSTAIN) && ch->KeyOn && a==curIns->volSus && p==curIns->volEnv[a].pos){
  279.             }
  280.             else{
  281.                 p++;
  282.                 
  283.                 if(p >= curIns->volEnv[b].pos)
  284.                 {
  285.                     a=b; b++;
  286.                     
  287.                     if(curIns->volType & EFLOOP)
  288.                     {
  289.                         if(b > curIns->volEnd)
  290.                         {
  291.                             a=curIns->volBeg;
  292.                             b=a+1;
  293.                             p=curIns->volEnv[a].pos;
  294.                         }
  295.                     }
  296.                     else
  297.                     {
  298.                         if(b >= curIns->volSize)
  299.                         {
  300.                             b--;
  301.                             p--;
  302.                         }
  303.                     }
  304.                 }
  305.             }
  306.         }
  307.         
  308.         ch->a=a;
  309.         ch->b=b;
  310.         ch->p=p;
  311.         
  312.         ch->volEnv = v;
  313.     }
  314. }
  315.  
  316. void ProcessPanning( Channel *ch, MADDriverRec *intDriver)
  317. {
  318.     long        v;
  319.     InstrData    *curIns;
  320.     
  321.     ch->pannEnv = ch->pann;
  322.     if( ch->ins < 0) return;
  323.     if( ch->samplePtr != 0L) return;
  324.     curIns = &intDriver->curMusic->fid[ ch->ins];
  325.     if( curIns->pannSize <= 0) return;
  326.     
  327.     if( curIns->pannType & EFON)
  328.     {
  329.         //  active? -> copy variables
  330.         
  331.         Byte     aa,bb;
  332.         short    pp;
  333.         
  334.         aa = ch->aa;
  335.         bb = ch->bb;
  336.         pp = ch->pp;
  337.         
  338.         if( curIns->pannSize == 1)        // Just 1 point !
  339.         {
  340.             v = curIns->pannEnv[ aa].val;
  341.             pp = curIns->pannEnv[ aa].pos;
  342.         }
  343.         else
  344.         {
  345.             v = InterpolateEnv( pp, &curIns->pannEnv[ aa], &curIns->pannEnv[ bb]);
  346.  
  347.             pp++;
  348.             
  349.             if(pp >= curIns->pannEnv[bb].pos)
  350.             {
  351.                 aa=bb; bb++;
  352.                 
  353.                 if(curIns->pannType & EFLOOP)
  354.                 {
  355.                     if(bb > curIns->pannEnd)
  356.                     {
  357.                         aa=curIns->pannBeg;
  358.                         bb=aa+1;
  359.                         pp=curIns->pannEnv[aa].pos;
  360.                     }
  361.                 }
  362.                 else
  363.                 {
  364.                     if(bb >= curIns->pannSize)
  365.                     {
  366.                         bb--;
  367.                         pp--;
  368.                     }
  369.                 }
  370.             }
  371.         }
  372.         ch->aa=aa;
  373.         ch->bb=bb;
  374.         ch->pp=pp;
  375.         
  376.         ch->pannEnv = v;
  377.     }
  378. }
  379.  
  380. void StartEnvelope( Channel *ch)
  381. {
  382.     ch->p=0;
  383.     ch->a=0;
  384.     ch->b=1;
  385. }
  386.  
  387. void StartPanning( Channel *ch)
  388. {
  389.     ch->pp=0;
  390.     ch->aa=0;
  391.     ch->bb=1;
  392. }
  393.  
  394. long GetOld2Period( short note, long c2spd, MADDriverRec *intDriver)
  395. {
  396.     unsigned long     period, n,o;
  397.     
  398.     if( note == 0xFF) return 4242;
  399.     if( note == 0xFE) return 4242;
  400.     
  401. //if(!c2spd) DebugStr("\pNo c2spd");
  402.     if(!c2spd) return 4242;
  403.     
  404.   if( note < 0) note = 0;
  405.     
  406.     n = note%12;
  407.     o = note/12;
  408.     
  409.     period = (unsigned long) ((unsigned long) ( 8363UL * ((unsigned long) intDriver->lib->mytab[ n]) ) >> o ) / (unsigned long) c2spd;
  410.     
  411.     if( period == 0L) period = 7242;
  412.     
  413.     return period;
  414.  
  415. //    return( getlogperiod( note, c2spd));
  416.  
  417. //    period = GetFreq2( getlinearperiod( note, c2spd)) * AMIGA_CLOCKFREQ2;
  418. //    return( period);
  419. }
  420.  
  421. long getlinearperiod(short note,long fine, MADDriverRec *intDriver)
  422. {
  423. //    return((10L*12*16*4)-((long)note*16*4)-(fine/2)+64);
  424.     
  425.     return (10L*12L+1-note)*64L-(fine/2);
  426. }
  427.  
  428. #define LOGFAC 2*16
  429.  
  430. long logtab[]={
  431.     LOGFAC*907,LOGFAC*900,LOGFAC*894,LOGFAC*887,LOGFAC*881,LOGFAC*875,LOGFAC*868,LOGFAC*862,
  432.     LOGFAC*856,LOGFAC*850,LOGFAC*844,LOGFAC*838,LOGFAC*832,LOGFAC*826,LOGFAC*820,LOGFAC*814,
  433.     LOGFAC*808,LOGFAC*802,LOGFAC*796,LOGFAC*791,LOGFAC*785,LOGFAC*779,LOGFAC*774,LOGFAC*768,
  434.     LOGFAC*762,LOGFAC*757,LOGFAC*752,LOGFAC*746,LOGFAC*741,LOGFAC*736,LOGFAC*730,LOGFAC*725,
  435.     LOGFAC*720,LOGFAC*715,LOGFAC*709,LOGFAC*704,LOGFAC*699,LOGFAC*694,LOGFAC*689,LOGFAC*684,
  436.     LOGFAC*678,LOGFAC*675,LOGFAC*670,LOGFAC*665,LOGFAC*660,LOGFAC*655,LOGFAC*651,LOGFAC*646,
  437.     LOGFAC*640,LOGFAC*636,LOGFAC*632,LOGFAC*628,LOGFAC*623,LOGFAC*619,LOGFAC*614,LOGFAC*610,
  438.     LOGFAC*604,LOGFAC*601,LOGFAC*597,LOGFAC*592,LOGFAC*588,LOGFAC*584,LOGFAC*580,LOGFAC*575,
  439.     LOGFAC*570,LOGFAC*567,LOGFAC*563,LOGFAC*559,LOGFAC*555,LOGFAC*551,LOGFAC*547,LOGFAC*543,
  440.     LOGFAC*538,LOGFAC*535,LOGFAC*532,LOGFAC*528,LOGFAC*524,LOGFAC*520,LOGFAC*516,LOGFAC*513,
  441.     LOGFAC*508,LOGFAC*505,LOGFAC*502,LOGFAC*498,LOGFAC*494,LOGFAC*491,LOGFAC*487,LOGFAC*484,
  442.     LOGFAC*480,LOGFAC*477,LOGFAC*474,LOGFAC*470,LOGFAC*467,LOGFAC*463,LOGFAC*460,LOGFAC*457,
  443.     LOGFAC*453,LOGFAC*450,LOGFAC*447,LOGFAC*443,LOGFAC*440,LOGFAC*437,LOGFAC*434,LOGFAC*431
  444. };
  445.  
  446. long getlogperiod(short note,long fine, MADDriverRec *intDriver)
  447. {
  448.     Byte n,o;
  449.     short p1,p2;
  450.     long i;
  451.  
  452.     n = note%12;
  453.     o = note/12;
  454.     i = (n<<3)+(fine>>4);  /* n*8 + fine/16 */
  455.  
  456.     return logtab[ i];
  457. //    p1 = logtab[i];
  458. //    p2 = logtab[i+1];
  459.  
  460. //    return(Interpolate(fine>>4,0,15,p1,p2)>>o);
  461. }
  462.  
  463. long GetOldPeriod( short note, long c2spd, MADDriverRec *intDriver)
  464. {
  465. //    if( intDriver->XMLinear)
  466.     {
  467. //        return getlogperiod( note, 0, intDriver);
  468. //        return getlinearperiod( note, 0, intDriver);
  469.     }
  470.     
  471.     return( GetOld2Period( note, c2spd, intDriver));
  472. }
  473.  
  474. void ReadNote( Channel *curVoice, Cmd *theNoteCmd, MADDriverRec *intDriver)
  475. {
  476. Cmd            intCmd = *theNoteCmd;
  477.  
  478. /********************************************/
  479. /*        EXTRA small positionning          */
  480. /********************************************/
  481.  
  482. if( intCmd.cmd == 0x0E && (intCmd.arg >> 4) == 0x0D)
  483. {
  484.     if( intDriver->smallcounter == 0 && !curVoice->GEffect)
  485.     {
  486.         curVoice->GEffect     = true;
  487.         curVoice->GPat         = intDriver->Pat;
  488.         curVoice->GReader     = intDriver->PartitionReader;
  489.     }
  490.     
  491.     if( intDriver->smallcounter >= (intCmd.arg & 0x0F))
  492.     {
  493.         curVoice->GEffect = false;        // <- Continue - Play note NOW !
  494.     }
  495.     else return;                        // <- Do it later
  496. }
  497. else curVoice->GEffect = false;            // <- Continue
  498.  
  499. /********************************************/
  500. /* Play a sample sound in priority to music */
  501. /********************************************/
  502. if( curVoice->samplePtr != 0L) return;
  503.  
  504. /********************************************/
  505.  
  506. /********************************************/
  507. /*        Read command and compute it       */
  508. /********************************************/
  509. else if( intCmd.ins != 0 || (intCmd.note != 0xFF && intCmd.note != 0xFE))
  510. {
  511.     /********************************/
  512.     /* Prépare les notes manquantes */
  513.     /********************************/
  514.     
  515.     /********************************/
  516.     
  517.     if( intCmd.note == 0xFF)
  518.     {
  519.         if( intCmd.ins == curVoice->insOld)        // RESET ONLY VOLUME
  520.         {
  521.             if(intCmd.cmd != volumeE && intCmd.ins != 0 && curVoice->noteOld != 0xFF)
  522.             {
  523.                 short ins    = intCmd.ins - 1;
  524.                 if( ins >= MAXINSTRU) ins = MAXINSTRU-1;
  525.                 
  526.                 if( curVoice->samp < intDriver->curMusic->fid[ ins].numSamples)
  527.                 {
  528.                     sData    *curData;
  529.                     
  530.                     curData                        = intDriver->curMusic->sample[ intDriver->curMusic->fid[ ins].firstSample + curVoice->samp];
  531.                     
  532.                     curVoice->vol             = curData->vol;
  533.                     if( curVoice->vol > MAX_VOLUME) curVoice->vol = MAX_VOLUME;
  534.                   curVoice->volFade        = 32767;
  535.               }
  536.             }
  537.             else curVoice->volFade        = 32767;
  538.         }
  539.         else intCmd.note            = curVoice->noteOld;
  540.     }
  541.     else
  542.     {
  543.         curVoice->noteOld         = intCmd.note;
  544.         
  545.         if( intCmd.ins != 0)
  546.         {
  547.             short ins    = intCmd.ins - 1;
  548.             if( ins >= MAXINSTRU) ins = MAXINSTRU-1;
  549.             
  550.             if( curVoice->samp < intDriver->curMusic->fid[ ins].numSamples)
  551.             {
  552.                 sData    *curData;
  553.                 
  554.                 curData                        = intDriver->curMusic->sample[ intDriver->curMusic->fid[ ins].firstSample + curVoice->samp];
  555.                 curVoice->noteOld    = intCmd.note + curData->relNote;
  556.             }
  557.         }
  558.     }
  559.     /********************************/
  560.     
  561.     if( intCmd.ins == 0)         { intCmd.ins                    = curVoice->insOld;}
  562.     else                                         { curVoice->insOld         = intCmd.ins; }
  563.         
  564.     /********************************/
  565.     
  566.     if( intCmd.ins != 0 && (intCmd.note != 0xFF && intCmd.note != 0xFE))
  567.     {
  568.         sData    *curData;
  569.         short    ins, samp;
  570.         
  571.         /**** INSTRUMENT ****/
  572.         
  573.         ins                        = intCmd.ins - 1;        if( ins >= MAXINSTRU) ins = MAXINSTRU-1;
  574.         samp                    = intDriver->curMusic->fid[ ins].what[ intCmd.note];
  575.         
  576.         if( intDriver->DriverSettings.driverMode == MIDISoundDriver)
  577.         {
  578.             curVoice->ins            = ins;
  579.         }
  580.         
  581.         if( samp < intDriver->curMusic->fid[ ins].numSamples)
  582.         {
  583.             curData                        = intDriver->curMusic->sample[ intDriver->curMusic->fid[ ins].firstSample + samp];
  584.             curVoice->ins            = ins;
  585.             curVoice->amp            = curData->amp;
  586.             curVoice->stereo    = curData->stereo;
  587.             curVoice->samp        = samp;
  588.             curVoice->loopType= curData->loopType;
  589.             
  590.             /**** RESET NOTE ****/
  591.             if( intCmd.cmd != portamentoE && intCmd.cmd != portaslideE)
  592.             {
  593.                 curVoice->prevPtr        = 0L;
  594.                 curVoice->maxPtr         = curVoice->curPtr = curVoice->begPtr = curData->data;
  595.                 curVoice->maxPtr         += curData->size;
  596.                 curVoice->sizePtr        = curData->size;
  597.                 curVoice->lAC                = 0;
  598.                 curVoice->pingpong    = false;
  599.                 //intDriver->chan[i].PanningE8
  600.                 curVoice->preOff        = 0xFFFFFFFF;
  601.                 curVoice->preVal        = 0;
  602.                 curVoice->spreVal        = 0;
  603.                 curVoice->preVal2        = *curVoice->curPtr;
  604.                 if( curVoice->amp == 8) curVoice->preVal2R    = *(curVoice->curPtr+1);
  605.                 else curVoice->preVal2R    = *(curVoice->curPtr+2);
  606.                 curVoice->spreVal2    = *(short*) curVoice->curPtr;
  607.                 curVoice->spreVal2R    = *(short*) (curVoice->curPtr+2);
  608.                 
  609.                 if( curData->loopSize > 2)
  610.                 {
  611.                     curVoice->loopBeg     = curData->loopBeg;
  612.                     curVoice->loopSize    = curData->loopSize;
  613.                     curVoice->maxPtr     = (Ptr) ((long) curData->data + curData->loopBeg + curData->loopSize);
  614.                 }
  615.                 else
  616.                 {
  617.                     curVoice->loopBeg     = 0;
  618.                     curVoice->loopSize    = 0;
  619.                 }
  620.                 curVoice->viboffset        = 0;
  621.                 
  622.                 if(intCmd.cmd != panningE)
  623.                 {
  624.                     if( curVoice->PanningE8 == false)
  625.                     {
  626.                         curVoice->pann             = intDriver->curMusic->header->chanPan[ curVoice->ID];
  627.                         if( curVoice->pann > MAX_PANNING) curVoice->pann = MAX_PANNING;
  628.                     }
  629.                 }
  630.                 
  631.                 StartPanning( curVoice);
  632.             }
  633.             StartEnvelope( curVoice);
  634.             
  635.             if(intCmd.cmd != volumeE && theNoteCmd->ins != 0)
  636.             {
  637.                 curVoice->vol             = curData->vol;
  638.                 if( curVoice->vol > MAX_VOLUME) curVoice->vol = MAX_VOLUME;
  639.               curVoice->volFade        = 32767;
  640.             }
  641.             else curVoice->volFade        = 32767;
  642.             
  643.             intDriver->InstruTube[ ins]         = 64;
  644.             intDriver->InstruActif[ ins]         = curVoice->ID;
  645.         }
  646.     }
  647.     
  648.     if( intCmd.note != 0xFF && intCmd.note != 0xFE)
  649.     {
  650.         /**** NOTE & PERIOD ****/
  651.         
  652.         sData    *curData;
  653.         short    samp;
  654.  
  655.         samp                    = intDriver->curMusic->fid[ curVoice->ins].what[ intCmd.note];
  656.         if( samp < intDriver->curMusic->fid[ curVoice->ins].numSamples)
  657.         {
  658.             curData                    = intDriver->curMusic->sample[ intDriver->curMusic->fid[ curVoice->ins].firstSample + samp];
  659.             
  660.             curVoice->note            = intCmd.note + curData->relNote;
  661.             curVoice->fineTune        = curData->c2spd;
  662.             curVoice->KeyOn            = true;
  663.             
  664.             if( intCmd.cmd != portamentoE && intCmd.cmd != portaslideE)
  665.             {
  666.                 curVoice->period         = GetOldPeriod( curVoice->note, curVoice->fineTune, intDriver);
  667.                 curVoice->period = (curVoice->period * (long) intDriver->FreqExt) / 80L;
  668.                 curVoice->periodOld = curVoice->period;
  669.             }
  670.         }
  671.         
  672.         /***********************/
  673.         /* Pour le MIDI Driver */
  674.         /***********************/
  675.         if( intDriver->DriverSettings.driverMode == MIDISoundDriver)
  676.         {
  677.             if( intDriver->NoteOld[ curVoice->ID] != -1)
  678.             {
  679.                 NoteOff( intDriver->InstuNoOld[ curVoice->ID], intDriver->NoteOld[ curVoice->ID], intDriver->VelocityOld[ curVoice->ID], intDriver);
  680.                 intDriver->NoteOld[ curVoice->ID] = -1;
  681.             }
  682.             
  683.             SampleMIDI( curVoice, curVoice->ins, intCmd.note, intDriver);
  684.             
  685.             intDriver->InstuNoOld[ curVoice->ID]    = curVoice->ins;
  686.             intDriver->NoteOld[ curVoice->ID]        = intCmd.note;
  687.             intDriver->VelocityOld[ curVoice->ID]    = curVoice->vol;
  688.         }
  689.         /***********************/
  690.     }
  691. }
  692. else
  693. {
  694.     curVoice->note = 0xFF;
  695. }
  696.  
  697. /**************/
  698. /*   VOLUME   */
  699. /**************/
  700. if( intCmd.vol != 0xFF)
  701. {
  702.     if(intCmd.vol >= 0x10 && intCmd.vol <= 0x50)
  703.     {
  704.         curVoice->vol = intCmd.vol - 0x10;
  705.         if( curVoice->vol < MIN_VOLUME) curVoice->vol = MIN_VOLUME;
  706.         else if( curVoice->vol > MAX_VOLUME) curVoice->vol = MAX_VOLUME;
  707.  
  708.         curVoice->volcmd = 0;
  709.     }
  710.     else curVoice->volcmd = intCmd.vol;
  711. }
  712. else curVoice->volcmd = 0;
  713.  
  714. curVoice->cmd        = intCmd.cmd;
  715. curVoice->arg         = intCmd.arg;
  716.  
  717. SetUpCmdEffect( curVoice, intDriver);
  718. SetUpEffect( curVoice, intDriver);
  719.  
  720. if( intCmd.ins != 0 && intCmd.note != 0xFF) intDriver->Tube[ curVoice->ID] = curVoice->vol;
  721.  
  722.  
  723. /**************/
  724. /*   KEY OFF  */
  725. /**************/
  726. if( intCmd.note == 0xFE)
  727. {
  728.     curVoice->KeyOn    = false;
  729.     
  730.     if( intDriver->DriverSettings.driverMode == MIDISoundDriver)
  731.     {
  732.         if( intDriver->NoteOld[ curVoice->ID] != -1)
  733.             NoteOff( intDriver->InstuNoOld[ curVoice->ID], intDriver->NoteOld[ curVoice->ID], intDriver->VelocityOld[ curVoice->ID], intDriver);
  734.         intDriver->NoteOld[ curVoice->ID] = -1;
  735.     }
  736. }
  737. }
  738.  
  739. #if defined(powerc) || defined (__powerc)
  740. void ClearDouble( register double long *a, register long xx)
  741. {
  742.     while( xx-- > 0 ) *a++ = 0;
  743. }
  744.  
  745. #else
  746. void ClearDouble( register long *a, register long xx)
  747. {
  748.     xx *=2;
  749.     while( xx-- > 0 ) *a++ = 0;
  750. }
  751. #endif
  752.  
  753. void ComputeReverb8(  Byte *orgPtr,   Byte *destPtr,  long xx, long strength)
  754. {
  755.     long    temp1;
  756.     
  757.     while( xx-- > 0)
  758.     {
  759.         temp1 = (*destPtr) + ((strength * (*orgPtr++ - 0x80)) / 100L);        // - 0x80L
  760.         
  761.         if( temp1 > 0xFF) temp1 = 0xFF;    // overflow ?
  762.         else if( temp1 < 0 ) temp1 = 0;
  763.         
  764.         *(destPtr)++ = temp1;
  765.     }
  766. }
  767.  
  768. void ComputeReverb16( short *orgPtr, short *destPtr, long xx, long strength)
  769. {
  770.     long    temp1;
  771.     long    valP = 0x7FFFL, valN = -0x7FFFL;
  772.     
  773.     while( xx-- > 0)
  774.     {
  775.         temp1 = *destPtr + ((strength * (long) *orgPtr++) / 100L);
  776.         
  777.         if( temp1 > valP) temp1 = valP;    // overflow ?
  778.         else if( temp1 < valN ) temp1 = valN;
  779.         
  780.         *destPtr++ = temp1;
  781.     }
  782. }
  783.  
  784. void NoteAnalyse( MADDriverRec *intDriver)
  785. {
  786. long                    InterruptBufferSize, i, ASCBUFFERCopy;
  787. Ptr                        DataPtrCopy;
  788. long                    tVSYNC;
  789. Boolean                NoteReading;
  790. long                    *DASCopy;
  791. short                    *DASCopy8;
  792.  
  793.     if( intDriver->curMusic != 0L)
  794.     {
  795.         if( intDriver->curMusic->musicUnderModification)
  796.         {    // SILENCE
  797.             long Tracks;
  798.             
  799.     //        if( intDriver->curMusic->header->MAD != 'MADI') DebugStr("\pError in MADI");
  800.             
  801.             switch( intDriver->DriverSettings.outPutMode)
  802.             {
  803.                 case PolyPhonic:                    Tracks    = intDriver->DriverSettings.numChn;    break;
  804.                 default:                                    Tracks  = 2;    break;
  805.             }
  806.             
  807.             Tracks = 1;
  808.             
  809.             switch( intDriver->DriverSettings.outPutBits)
  810.             {
  811.                 case 8:
  812.                     for( i = 0; i < intDriver->ASCBUFFER*Tracks; i++) intDriver->IntDataPtr[ i] = 0x80;
  813.                 break;
  814.                 
  815.                 case 16:
  816.                     DASCopy8 = (short*) intDriver->IntDataPtr;
  817.                     for( i = 0; i < intDriver->ASCBUFFER*Tracks*2L; i++) DASCopy8[ i] = 0;
  818.                 break;
  819.             }
  820.             return;
  821.         }
  822.     }
  823.     
  824.     intDriver->BytesToRemoveAtEnd = 0;
  825.     
  826.     DataPtrCopy                    = intDriver->IntDataPtr;
  827.     DASCopy                            = intDriver->DASCBuffer;
  828.     DASCopy8                        = intDriver->DASCBuffer8;
  829.     ASCBUFFERCopy                = intDriver->ASCBUFFER;
  830.     InterruptBufferSize = intDriver->ASCBUFFER;
  831.     
  832.     while( InterruptBufferSize > 0)
  833.     {
  834.         /********************/
  835.         /* Sound Generating */
  836.         /********************/
  837.         
  838.         intDriver->ASCBUFFER = intDriver->BytesToGenerate - intDriver->BufCounter;
  839.         
  840.         if( intDriver->ASCBUFFER < 0) intDriver->ASCBUFFER = 0;
  841.         if( intDriver->ASCBUFFER > InterruptBufferSize) { intDriver->ASCBUFFER = InterruptBufferSize;    NoteReading = false;}
  842.         else NoteReading = true;
  843.         
  844.         if( intDriver->ASCBUFFER > 0)
  845.         {
  846.             GenerateSound( intDriver);
  847.             intDriver->BufCounter    += intDriver->ASCBUFFER;
  848.             InterruptBufferSize        -= intDriver->ASCBUFFER;
  849.         }
  850.         
  851.         /**************************/
  852.         /* Note & Effect Analyser */
  853.         /**************************/
  854.         
  855.         if( !NoteReading) InterruptBufferSize = -1;
  856.         else
  857.         {
  858.             NoteReading = false;
  859.             
  860.             /*********/
  861.             // GEffect : extrasmallpositionning
  862.             
  863.             if( intDriver->curMusic != 0L && intDriver->Reading)
  864.             {
  865.                 for( i = 0; i < intDriver->curMusic->header->numChn; i++)
  866.                 {
  867.                     if( intDriver->chan[ i].GEffect)        
  868.                     {
  869.                         ReadNote( &intDriver->chan[ i], GetMADCommand( intDriver->chan[ i].GReader, i, intDriver->curMusic->partition[ intDriver->chan[ i].GPat]), intDriver);
  870.                     }
  871.                 }
  872.             }
  873.             
  874.             /*********/
  875.             
  876.         //    intDriver->extrasmallcounter--;
  877.         //    if( intDriver->extrasmallcounter <= 0)
  878.             {
  879.             //    intDriver->extrasmallcounter = EXTRASMALLCOUNTER;
  880.                 
  881.                 intDriver->smallcounter++;
  882.                 if( intDriver->smallcounter >= intDriver->speed)
  883.                 {
  884.                     intDriver->smallcounter = 0;
  885.                     
  886.                     if( intDriver->PatDelay) intDriver->PatDelay--;
  887.                     
  888.                     if( intDriver->curMusic != 0L && intDriver->PatDelay == 0)
  889.                     {
  890.                         for( i = 0; i < intDriver->curMusic->header->numChn; i++)
  891.                         {
  892.                             CloseEffect( &intDriver->chan[ i], intDriver->smallcounter, intDriver);
  893.                             
  894.                             if( intDriver->Reading && intDriver->TrackLineReading[ i])
  895.                             {
  896.                                 ReadNote( &intDriver->chan[ i], GetMADCommand( intDriver->PartitionReader, i, intDriver->curMusic->partition[ intDriver->Pat]), intDriver);
  897.                             }
  898.                             
  899.                             ProcessEnvelope( &intDriver->chan[ i], intDriver);
  900.                             ProcessPanning( &intDriver->chan[ i], intDriver);
  901.                             ProcessFadeOut( &intDriver->chan[ i], intDriver);
  902.                         }
  903.                         
  904.                         if( intDriver->Reading)
  905.                         {
  906.                             if( intDriver->wasReading == false)
  907.                             {
  908.                                 #ifdef _MIDIHARDWARE_
  909.                                 if( intDriver->SendMIDIClockData) SendMIDIClock( intDriver, 0xFB);
  910.                                 #endif
  911.                                 intDriver->wasReading = true;
  912.                             }
  913.                             
  914.                             #ifdef _MIDIHARDWARE_
  915.                             if( intDriver->SendMIDIClockData) SendMIDIClock( intDriver, 0xF8);
  916.                             #endif
  917.                             
  918.                             for( i = 0; i < MAXTRACK; i++) intDriver->TrackLineReading[ i] = true;
  919.                             
  920.                             if( intDriver->PartitionReader == 0)
  921.                             {
  922.                                 for( i = 0; i < intDriver->curMusic->header->numChn; i++)
  923.                                 {
  924.                                     intDriver->chan[ i].PatternLoopE6 = 1;
  925.                                     intDriver->chan[ i].PatternLoopE6ID = intDriver->PL;
  926.                                 }
  927.                             }
  928.                             
  929.                             intDriver->PartitionReader++;
  930.                             if( intDriver->PartitionReader >= intDriver->curMusic->partition[ intDriver->Pat]->header.size)
  931.                             {
  932.                                 intDriver->PartitionReader = 0;
  933.                                 intDriver->endPattern = true;
  934.                                 
  935.                                 if( intDriver->JumpToNextPattern)
  936.                                 {
  937.                                     intDriver->PL++;
  938.                                     intDriver->Pat = intDriver->curMusic->header->oPointers[ intDriver->PL];
  939.                                     
  940.                                     if( intDriver->speed == 1 && intDriver->PL >= intDriver->curMusic->header->numPointers)
  941.                                     {
  942.                                         intDriver->PL = 0;
  943.                                         intDriver->Pat = intDriver->curMusic->header->oPointers[ intDriver->PL];
  944.                                         
  945.                                         MADCleanDriver( intDriver);
  946.                                         if( !intDriver->DriverSettings.repeatMusic) intDriver->Reading = false;
  947.                                         
  948.                                         tVSYNC         = intDriver->VSYNC;
  949.                                         tVSYNC         /= intDriver->finespeed;
  950.                                         tVSYNC         *= 80L;
  951.                                         tVSYNC         /= intDriver->VExt;
  952.                                         
  953.                                         intDriver->BytesToRemoveAtEnd = (InterruptBufferSize - tVSYNC) / intDriver->DriverSettings.oversampling;
  954.                                         if( intDriver->BytesToRemoveAtEnd < 0) intDriver->BytesToRemoveAtEnd = 0;
  955.                                     
  956.                                         intDriver->musicEnd = true;
  957.                                     }
  958.                                 }
  959.                             }
  960.                         }
  961.                         else
  962.                         {
  963.                             if( intDriver->wasReading == true)
  964.                             {
  965.                                 #ifdef _MIDIHARDWARE_
  966.                                 if( intDriver->SendMIDIClockData) SendMIDIClock( intDriver, 0xFC);
  967.                                 #endif
  968.                                 intDriver->wasReading = false;
  969.                             }
  970.                         }
  971.                     }
  972.                 }
  973.                 else
  974.                 {
  975.                     if( intDriver->curMusic != 0L)
  976.                     {
  977.                         for( i = 0 ; i < intDriver->DriverSettings.numChn; i++)
  978.                         {
  979.                             //    if( intDriver->Reading) 
  980.                                 {
  981.                                     DoVolCmd( &intDriver->chan[ i], intDriver->smallcounter, intDriver);
  982.                                     DoEffect( &intDriver->chan[ i], intDriver->smallcounter, intDriver);
  983.                                 }
  984.                                 ProcessEnvelope( &intDriver->chan[ i], intDriver);
  985.                                 ProcessPanning( &intDriver->chan[ i], intDriver);
  986.                                 ProcessFadeOut( &intDriver->chan[ i], intDriver);
  987.                         }
  988.                         
  989.                         if( intDriver->Reading)
  990.                         {
  991.                             if( intDriver->wasReading == false)
  992.                             {
  993.                                 #ifdef _MIDIHARDWARE_
  994.                                 if( intDriver->SendMIDIClockData)
  995.                                 {
  996.                                     if( intDriver->PartitionReader == 0 && intDriver->PL == 0) SendMIDIClock( intDriver, 0xFA);
  997.                                     else SendMIDIClock( intDriver, 0xFB);
  998.                                 }
  999.                                 #endif
  1000.                                 intDriver->wasReading = true;
  1001.                             }
  1002.                             
  1003.                             #ifdef _MIDIHARDWARE_
  1004.                             if( intDriver->SendMIDIClockData) SendMIDIClock( intDriver, 0xF8);
  1005.                             #endif
  1006.                             
  1007.                             if( intDriver->smallcounter == intDriver->speed - 1)
  1008.                             {
  1009.                                 if( intDriver->PL >= intDriver->curMusic->header->numPointers)
  1010.                                 {
  1011.                                     intDriver->PL = 0;
  1012.                                     intDriver->Pat = intDriver->curMusic->header->oPointers[ intDriver->PL];
  1013.                                     
  1014.                                     //MADCleanDriver( intDriver);
  1015.                                     if( !intDriver->DriverSettings.repeatMusic) intDriver->Reading = false;
  1016.                                     
  1017.                                     tVSYNC         = intDriver->VSYNC;
  1018.                                     tVSYNC         /= intDriver->finespeed;
  1019.                                     tVSYNC         *= 80L;
  1020.                                     tVSYNC         /= intDriver->VExt;
  1021.                                     
  1022.                                     intDriver->BytesToRemoveAtEnd = (InterruptBufferSize - tVSYNC) / intDriver->DriverSettings.oversampling;
  1023.                                     if( intDriver->BytesToRemoveAtEnd < 0) intDriver->BytesToRemoveAtEnd = 0;
  1024.                                     
  1025.                                     intDriver->musicEnd = true;
  1026.                                 }
  1027.                             }
  1028.                         }
  1029.                         else
  1030.                         {
  1031.                             if( intDriver->wasReading == true)
  1032.                             {
  1033.                                 #ifdef _MIDIHARDWARE_
  1034.                                 if( intDriver->SendMIDIClockData) SendMIDIClock( intDriver, 0xFC);
  1035.                                 #endif
  1036.                                 intDriver->wasReading = false;
  1037.                             }
  1038.                         }
  1039.                     }
  1040.                 }
  1041.             }
  1042.             tVSYNC         = intDriver->VSYNC;
  1043.             tVSYNC         /= intDriver->finespeed;
  1044.             
  1045.             tVSYNC         *= 80L;
  1046.             tVSYNC         /= intDriver->VExt;
  1047.             
  1048.             intDriver->BytesToGenerate += tVSYNC;
  1049.         }
  1050.     }
  1051.     
  1052.     intDriver->ASCBUFFER    = ASCBUFFERCopy;
  1053.     intDriver->IntDataPtr    = DataPtrCopy;
  1054.     intDriver->DASCBuffer    = DASCopy;
  1055.     intDriver->DASCBuffer8    = DASCopy8;
  1056.     
  1057.     if( intDriver->DriverSettings.MicroDelaySize)
  1058.     {
  1059.         switch( intDriver->DriverSettings.outPutBits)
  1060.         {
  1061.             case 16:
  1062.                 BlockMoveData( intDriver->DASCBuffer + intDriver->ASCBUFFER*2, intDriver->DASCBuffer, intDriver->MDelay*8L);
  1063.                 
  1064.                 #if defined (powerc)
  1065.                 ClearDouble( (long double*) (intDriver->DASCBuffer + intDriver->MDelay*2L), intDriver->ASCBUFFER);
  1066.                 #else
  1067.                 ClearDouble( (long*) (intDriver->DASCBuffer + intDriver->MDelay*2L), intDriver->ASCBUFFER);
  1068.                 #endif
  1069.             break;
  1070.             
  1071.             case 8:
  1072.                 if( intDriver->MDelay % 2 != 0)
  1073.                 {
  1074.                     BlockMoveData( intDriver->DASCBuffer8 + intDriver->ASCBUFFER*2, intDriver->DASCBuffer8, 1 + intDriver->MDelay*4L);
  1075.                     
  1076.                     #if defined (powerc)
  1077.                     ClearDouble( (long double*) (intDriver->DASCBuffer8 + intDriver->MDelay*2L), 1 + intDriver->ASCBUFFER/2);
  1078.                     #else
  1079.                     ClearDouble( (long*) (intDriver->DASCBuffer8 + intDriver->MDelay*2L), 1 + intDriver->ASCBUFFER/2);
  1080.                     #endif
  1081.                 }
  1082.                 else
  1083.                 {
  1084.                     BlockMoveData( intDriver->DASCBuffer8 + intDriver->ASCBUFFER*2, intDriver->DASCBuffer8, intDriver->MDelay*4L);
  1085.                 
  1086.                     #if defined (powerc)
  1087.                     ClearDouble( (long double*) (intDriver->DASCBuffer8 + intDriver->MDelay*2L), intDriver->ASCBUFFER/2);
  1088.                     #else
  1089.                     ClearDouble( (long*) (intDriver->DASCBuffer8 + intDriver->MDelay*2L), intDriver->ASCBUFFER/2);
  1090.                     #endif
  1091.                 }
  1092.             break;
  1093.         }
  1094.     }
  1095.     
  1096.     //if( intDriver->DriverSettings.antiAliasing) ApplyFilters( intDriver);
  1097.     if( intDriver->DriverSettings.surround) ApplySurround( intDriver);
  1098.     
  1099.     if( intDriver->DriverSettings.Reverb && intDriver->ASCBUFFER < intDriver->RDelay)
  1100.     {
  1101.         if( intDriver->DriverSettings.outPutMode == DeluxeStereoOutPut)
  1102.         {
  1103.             switch( intDriver->DriverSettings.outPutBits)
  1104.             {
  1105.                 case 8:
  1106.                     ComputeReverb8( (Byte*) intDriver->ReverbPtr, (Byte*) intDriver->IntDataPtr, intDriver->ASCBUFFER*2L, intDriver->DriverSettings.ReverbStrength);
  1107.                     BlockMoveData( intDriver->ReverbPtr + intDriver->ASCBUFFER*2L, intDriver->ReverbPtr, intDriver->RDelay*2L - intDriver->ASCBUFFER*2L);
  1108.                     BlockMoveData( intDriver->IntDataPtr, intDriver->ReverbPtr + intDriver->RDelay*2L - intDriver->ASCBUFFER*2L, intDriver->ASCBUFFER*2L);
  1109.                 break;
  1110.                 
  1111.                 case 16:
  1112.                     ComputeReverb16( (short*) intDriver->ReverbPtr, (short*) intDriver->IntDataPtr, intDriver->ASCBUFFER*2L, intDriver->DriverSettings.ReverbStrength);
  1113.                     BlockMoveData( intDriver->ReverbPtr + intDriver->ASCBUFFER*4, intDriver->ReverbPtr, (intDriver->RDelay - intDriver->ASCBUFFER)*4);
  1114.                     BlockMoveData( intDriver->IntDataPtr, intDriver->ReverbPtr + intDriver->RDelay*4 - intDriver->ASCBUFFER*4, intDriver->ASCBUFFER*4);
  1115.                 break;
  1116.             }
  1117.         }
  1118.     }
  1119.     
  1120.     if( intDriver->DriverSettings.oversampling > 1)
  1121.     {
  1122.         switch( intDriver->DriverSettings.outPutBits)
  1123.         {
  1124.                 case 8:
  1125.                 {
  1126.                     Byte        *tempPtr = (Byte*) intDriver->IntDataPtr, *intempPtr;
  1127.                     long        mul = intDriver->DriverSettings.oversampling;
  1128.                     long        x;
  1129.                     long        tempL, tempR;
  1130.                     
  1131.                     for( i = 0; i < intDriver->ASCBUFFER / mul; i++)
  1132.                     {
  1133.                         // LEFT & RIGHT
  1134.                         tempL = 0;    tempR = 0;    intempPtr = &tempPtr[ i*mul*2];
  1135.                         x = mul;
  1136.                         while( x-- > 0)    {        tempL += *(intempPtr++);    tempR += *(intempPtr++);    }
  1137.                         tempPtr[ i*2] = tempL / mul;
  1138.                         tempPtr[ i*2 + 1] = tempR / mul;
  1139.                     }
  1140.                 }
  1141.                 break;
  1142.                 
  1143.                 case 16:
  1144.                 {
  1145.                     short        *tempShort = (short*) intDriver->IntDataPtr, *intempShort;
  1146.                     long        mul = intDriver->DriverSettings.oversampling;
  1147.                     long        x, tempL, tempR;
  1148.                     
  1149.                     for( i = 0; i < intDriver->ASCBUFFER / mul; i++)
  1150.                     {
  1151.                         // LEFT & RIGHT
  1152.                     
  1153.                         tempL = 0;    tempR = 0;    intempShort = &tempShort[ i*mul*2];
  1154.                         x = mul;
  1155.                         while( x-- > 0) {    tempL += *(intempShort++);    tempR += *(intempShort++); }
  1156.                         tempShort[ i*2] = tempL / mul;
  1157.                         tempShort[ i*2 + 1] = tempR / mul;
  1158.                     }
  1159.                 }
  1160.                 break;
  1161.         }
  1162.     }
  1163. }
  1164.  
  1165. void Filter8Bit( register Byte *myPtr, MADDriverRec *intDriver)
  1166. {
  1167.     long    i;
  1168.  
  1169.     i = intDriver->ASCBUFFER-1;
  1170.     while( i-- > 0)
  1171.     {
  1172.         *myPtr -= ( *myPtr - *(myPtr + 1)) >> 1;
  1173.         myPtr++;
  1174.     }
  1175. }
  1176.  
  1177. void Filter8BitX( register Byte *myPtr, MADDriverRec *intDriver)
  1178. {
  1179.     long    i;
  1180.  
  1181.     i = intDriver->ASCBUFFER-1;
  1182.     while( i-- > 0)
  1183.     {
  1184.         *myPtr -= ( *myPtr - *(myPtr + 2)) >> 1;
  1185.         myPtr += 2;
  1186.     }
  1187. }
  1188.  
  1189. void Filter16BitX( register short *myPtr, MADDriverRec *intDriver)
  1190. {
  1191.     long    i;
  1192.  
  1193.     i = intDriver->ASCBUFFER-1;
  1194.     while( i-- > 0)
  1195.     {
  1196.         *myPtr -= ( *myPtr - *(myPtr + 2)) >> 1;
  1197.         myPtr += 2;
  1198.     }
  1199.     
  1200. /*    i = intDriver->ASCBUFFER-2;
  1201.     myPtr += 2;
  1202.     while( i-- > 0)
  1203.     {
  1204.         *myPtr -= ((*myPtr - *(myPtr + 2)) + (*myPtr - *(myPtr - 2))) >> 1;
  1205.         myPtr += 2;
  1206.     }    */
  1207. }
  1208.  
  1209. void ApplyFilters( MADDriverRec *intDriver)
  1210. {
  1211.     switch( intDriver->DriverSettings.outPutBits)
  1212.     {
  1213.         case 8:
  1214.             switch( intDriver->DriverSettings.outPutMode)
  1215.             {
  1216.             /*    case MonoOutPut:
  1217.                     Filter8Bit( (Byte*) intDriver->IntDataPtr, intDriver);
  1218.                 break;
  1219.                 
  1220.                 case StereoOutPut:
  1221.                     Filter8BitX( (Byte*) intDriver->IntDataPtr, intDriver);
  1222.                     Filter8BitX( (Byte*) intDriver->IntDataPtr + 1, intDriver);
  1223.                 break;
  1224.             */
  1225.                 case DeluxeStereoOutPut:
  1226.                     Filter8BitX( (Byte*) intDriver->IntDataPtr, intDriver);
  1227.                     Filter8BitX( (Byte*) intDriver->IntDataPtr + 1, intDriver);
  1228.                 break;
  1229.             }
  1230.         break;
  1231.         
  1232.         case 16:
  1233.             switch( intDriver->DriverSettings.outPutMode)
  1234.             {
  1235.             /*    case MonoOutPut:
  1236.                 break;
  1237.                 
  1238.                 case StereoOutPut:*/
  1239.                 case DeluxeStereoOutPut:
  1240.                 
  1241.             /*    {
  1242.                 short    i;
  1243.                     
  1244.                     for( i = 0; i < 10; i++)
  1245.                     {*/
  1246.                         Filter16BitX( ( short*) intDriver->IntDataPtr, intDriver);
  1247.                         Filter16BitX( ( short*) (intDriver->IntDataPtr) + 1, intDriver);
  1248.                 /*    }
  1249.                 }*/
  1250.                 break;
  1251.             }
  1252.         break;
  1253.     }
  1254. }
  1255.  
  1256. void ApplySurround( MADDriverRec *intDriver)
  1257. {
  1258.     switch( intDriver->DriverSettings.outPutBits)
  1259.     {
  1260.         case 8:
  1261.             switch( intDriver->DriverSettings.outPutMode)
  1262.             {
  1263.                 case DeluxeStereoOutPut:
  1264.                 {
  1265.                 long    i = intDriver->ASCBUFFER;
  1266.                 char    *data = (char*) intDriver->IntDataPtr;
  1267.                     
  1268.                     while( i-- > 0)
  1269.                     {
  1270.                         *data = -1-*data;
  1271.                         data += 2;
  1272.                     }
  1273.                 }
  1274.                 break;
  1275.             }
  1276.         break;
  1277.         
  1278.         case 16:
  1279.             switch( intDriver->DriverSettings.outPutMode)
  1280.             {
  1281.                 case DeluxeStereoOutPut:
  1282.                 {
  1283.                 long        i = intDriver->ASCBUFFER;
  1284.                 short        *data = (short*) intDriver->IntDataPtr;
  1285.                     
  1286.                     while( i-- > 0)
  1287.                     {
  1288.                         *data = -1-*data;
  1289.                         data += 2;
  1290.                     }
  1291.                 }
  1292.                 break;
  1293.             }
  1294.         break;
  1295.     }
  1296. }
  1297.  
  1298. void GenerateSound( MADDriverRec *intDriver)
  1299. {
  1300.     if( intDriver->DriverSettings.driverMode == MIDISoundDriver) return;
  1301.  
  1302.     switch( intDriver->DriverSettings.outPutBits)
  1303.     {
  1304.         case 8:
  1305.             switch( intDriver->DriverSettings.outPutMode)
  1306.             {
  1307.             /*    case MonoOutPut:
  1308.                     Play8Mono( intDriver);
  1309.                     intDriver->IntDataPtr    += intDriver->ASCBUFFER;
  1310.                 break;
  1311.                 
  1312.                 case StereoOutPut:
  1313.                     Play8Stereo( intDriver);
  1314.                     intDriver->IntDataPtr    += intDriver->ASCBUFFER*2L;
  1315.                 break;
  1316.                 */
  1317.                 case DeluxeStereoOutPut:
  1318.                     Play8StereoDelay( intDriver);
  1319.                     intDriver->IntDataPtr    += intDriver->ASCBUFFER*2L;
  1320.                     intDriver->DASCBuffer8    += intDriver->ASCBUFFER*2L;
  1321.                 break;
  1322.                 
  1323.                 case PolyPhonic:
  1324.             //    case MultiFiles:
  1325.                   Play8PolyPhonic( intDriver);
  1326.                     intDriver->IntDataPtr    += intDriver->ASCBUFFER * intDriver->DriverSettings.numChn;
  1327.                 break;
  1328.             }
  1329.         break;
  1330.         
  1331.         case 16:
  1332.             switch( intDriver->DriverSettings.outPutMode)
  1333.             {
  1334.             /*    case MonoOutPut:
  1335.                     Play16Mono( intDriver);
  1336.                     intDriver->IntDataPtr    += intDriver->ASCBUFFER*2L;
  1337.                 break;
  1338.                 
  1339.                 case StereoOutPut:
  1340.                     Play16Stereo( intDriver);
  1341.                     intDriver->IntDataPtr    += intDriver->ASCBUFFER*4L;
  1342.                 break;
  1343.                 */
  1344.                 case DeluxeStereoOutPut:
  1345.                     Play16StereoDelay( intDriver);
  1346.                     intDriver->IntDataPtr    += intDriver->ASCBUFFER*4L;
  1347.                     intDriver->DASCBuffer    += intDriver->ASCBUFFER*2L;
  1348.                 break;
  1349.                 
  1350.                 case PolyPhonic:
  1351.         //        case MultiFiles:
  1352.             //      Play16PolyPhonic( intDriver);
  1353.                     intDriver->IntDataPtr    += intDriver->ASCBUFFER * 2L * intDriver->DriverSettings.numChn;
  1354.                 break;
  1355.             }
  1356.         break;
  1357.     }
  1358. }
  1359.  
  1360. EXP Boolean DirectSave( Ptr myPtr, MADDriverSettings *driverType, MADDriverRec *intDriver)
  1361. {
  1362. Ptr                                    ptrCopy;
  1363. MADDriverSettings        driverCopy;
  1364.  
  1365.     if( intDriver == 0L) return false;    //intDriver = MADGetMADDriverPtr();
  1366.     if( !intDriver->Reading) return false;
  1367.     
  1368.     /*** Copy values ***/
  1369.     ptrCopy         = intDriver->IntDataPtr;
  1370.     if( driverType != 0L) driverCopy    = intDriver->DriverSettings;
  1371.     
  1372.     /*** Install New Values ***/
  1373.     
  1374.     intDriver->IntDataPtr         = myPtr;
  1375.     if( driverType != 0L) intDriver->DriverSettings    = *driverType;
  1376.     
  1377.     /***/            /***/
  1378.     /***/            /***/
  1379.     /***/            /***/
  1380.     
  1381.     NoteAnalyse( intDriver);
  1382.     
  1383.     /***/            /***/
  1384.     /***/            /***/
  1385.     /***/            /***/
  1386.     
  1387.     /*** Restore values ***/
  1388.     
  1389.     intDriver->IntDataPtr         = ptrCopy;
  1390.     if( driverType != 0L) intDriver->DriverSettings    = driverCopy;
  1391.     
  1392.     if( intDriver->musicEnd == true) return false;
  1393.     
  1394. /*    if( intDriver->curMusic != 0L)
  1395.     {
  1396.         if( intDriver->PL >= intDriver->curMusic->header->numPointers) return false;
  1397.     }*/
  1398.     
  1399.     return true;
  1400. }
  1401.  
  1402. #ifdef _MAC_H
  1403.  
  1404. Ptr GetMyDoubleBackProc()
  1405. {
  1406.     return (Ptr) MyDoubleBackProc;
  1407. }
  1408.  
  1409. pascal void MyDoubleBackProc(SndChannelPtr chan, SndDoubleBufferPtr doubleBuffer)
  1410. {
  1411.     Ptr                            myPtr;            
  1412.     MADDriverRec        *intDriver;
  1413.     
  1414.     intDriver = (MADDriverRec*) doubleBuffer->dbUserInfo[ 0];
  1415.     
  1416.     /********************/
  1417.     /**   Read Notes   **/
  1418.     /********************/
  1419.     
  1420.     myPtr = intDriver->IntDataPtr;
  1421.     intDriver->IntDataPtr = (char*) doubleBuffer->dbSoundData;
  1422.     
  1423.     NoteAnalyse( intDriver);
  1424.     
  1425.     intDriver->IntDataPtr        = myPtr;
  1426.     intDriver->OscilloWavePtr    = (char*) doubleBuffer->dbSoundData;
  1427.     
  1428.     doubleBuffer->dbNumFrames    = intDriver->ASCBUFFER / intDriver->DriverSettings.oversampling;
  1429.     doubleBuffer->dbFlags        |= dbBufferReady;
  1430. }
  1431. #endif
  1432.  
  1433. #ifdef _MIDIHARDWARE_
  1434. void NoteOff(short oldIns, short oldN, short oldV, MADDriverRec *intDriver)
  1435. {
  1436.     OMSMIDIPacket pack;
  1437.     
  1438.     if(    gOutNodeRefNum == -1) return;
  1439.     
  1440.     /*** Note - OFF ***/
  1441.  
  1442.     pack.flags    = 0;    //midiMsgType + midiTimeStampCurrent + midiNoCont;
  1443.     pack.len    = 3;
  1444.  
  1445.     pack.data[ 0] = 0x80 + oldIns;
  1446.     pack.data[ 1] = oldN + 12;
  1447.     
  1448.     if( oldV < 64) pack.data[ 2] = 63 + oldV;    
  1449.     else pack.data[ 2] = 127;
  1450.     
  1451.     #if defined(__MWERKS__)
  1452.     OMSWritePacket2( &pack, gOutNodeRefNum, gOutputPortRefNum);
  1453.     #endif
  1454. }
  1455.  
  1456. void AllNoteOff( MADDriverRec *intDriver)
  1457. {
  1458.     short         i;
  1459.     
  1460.     if( gOutNodeRefNum == -1) return;
  1461.     
  1462.     for( i = 0; i < MAXTRACK; i++)
  1463.     {
  1464.         if( intDriver->NoteOld[ i] != -1)
  1465.         {
  1466.             NoteOff( intDriver->InstuNoOld[ i], intDriver->NoteOld[ i], intDriver->VelocityOld[ i], intDriver);
  1467.             intDriver->NoteOld[ i] = -1;
  1468.         }
  1469.     }
  1470. }
  1471.  
  1472. void SampleMIDI( Channel *curVoice, short channel, short curN, MADDriverRec *intDriver)
  1473. {
  1474.     OMSMIDIPacket pack;
  1475.     
  1476.     if( gOutNodeRefNum == -1) return;
  1477.     
  1478.     /*** Note - ON ***/
  1479.     
  1480.     pack.flags    = 0;    //midiMsgType + midiTimeStampCurrent + midiNoCont;
  1481.     pack.len    = 3;
  1482.  
  1483.     pack.data[ 0] = 0x90 + channel;
  1484.     
  1485.     pack.data[ 1] = curN + 12;
  1486.     if( curVoice->vol < 64) pack.data[ 2] = 63 + curVoice->vol;    
  1487.     else pack.data[ 2] = 127;
  1488.     
  1489.     #if defined(__MWERKS__)
  1490.     OMSWritePacket2( &pack, gOutNodeRefNum, gOutputPortRefNum);
  1491.     #endif
  1492. }
  1493. #else
  1494. void SampleMIDI( Channel *curVoice, short channel, short curN, MADDriverRec *intDriver){};
  1495. void AllNoteOff( MADDriverRec *intDriver){};
  1496. void NoteOff(short oldIns, short oldN, short oldV, MADDriverRec *intDriver){};
  1497. #endif
  1498.