home *** CD-ROM | disk | FTP | other *** search
/ Large Pack of OldSkool DOS MOD Trackers / ht12_m68k.lha / HivelyTracker / Replayer / src / hvl_replay.c < prev    next >
Encoding:
C/C++ Source or Header  |  2007-01-01  |  55.7 KB  |  1,978 lines
  1.  
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <stdlib.h>
  5. #include <math.h>
  6.  
  7. #include <exec/types.h>
  8.  
  9. #ifndef _AMIGAOS3_
  10. #include <exec/exectags.h>
  11. #endif
  12.  
  13. #include <proto/exec.h>
  14. #include <proto/dos.h>
  15.  
  16. #ifdef _AMIGAOS3_
  17. #include "os3_compat.h"
  18. #endif
  19.  
  20. #include "hvl_replay.h"
  21.  
  22. int32 stereopan_left[]  = { 128,  96,  64,  32,   0 };
  23. int32 stereopan_right[] = { 128, 160, 193, 225, 255 };
  24.  
  25. /*
  26. ** Waves
  27. */
  28. #define WHITENOISELEN (0x280*3)
  29.  
  30. #define WO_LOWPASSES   0
  31. #define WO_TRIANGLE_04 (WO_LOWPASSES+((0xfc+0xfc+0x80*0x1f+0x80+3*0x280)*31))
  32. #define WO_TRIANGLE_08 (WO_TRIANGLE_04+0x04)
  33. #define WO_TRIANGLE_10 (WO_TRIANGLE_08+0x08)
  34. #define WO_TRIANGLE_20 (WO_TRIANGLE_10+0x10)
  35. #define WO_TRIANGLE_40 (WO_TRIANGLE_20+0x20)
  36. #define WO_TRIANGLE_80 (WO_TRIANGLE_40+0x40)
  37. #define WO_SAWTOOTH_04 (WO_TRIANGLE_80+0x80)
  38. #define WO_SAWTOOTH_08 (WO_SAWTOOTH_04+0x04)
  39. #define WO_SAWTOOTH_10 (WO_SAWTOOTH_08+0x08)
  40. #define WO_SAWTOOTH_20 (WO_SAWTOOTH_10+0x10)
  41. #define WO_SAWTOOTH_40 (WO_SAWTOOTH_20+0x20)
  42. #define WO_SAWTOOTH_80 (WO_SAWTOOTH_40+0x40)
  43. #define WO_SQUARES     (WO_SAWTOOTH_80+0x80)
  44. #define WO_WHITENOISE  (WO_SQUARES+(0x80*0x20))
  45. #define WO_HIGHPASSES  (WO_WHITENOISE+WHITENOISELEN)
  46. #define WAVES_SIZE     (WO_HIGHPASSES+((0xfc+0xfc+0x80*0x1f+0x80+3*0x280)*31))
  47.  
  48. int8 waves[WAVES_SIZE];
  49. int16 waves2[WAVES_SIZE];
  50.  
  51. CONST int16 vib_tab[] =
  52. { 
  53.   0,24,49,74,97,120,141,161,180,197,212,224,235,244,250,253,255,
  54.   253,250,244,235,224,212,197,180,161,141,120,97,74,49,24,
  55.   0,-24,-49,-74,-97,-120,-141,-161,-180,-197,-212,-224,-235,-244,-250,-253,-255,
  56.   -253,-250,-244,-235,-224,-212,-197,-180,-161,-141,-120,-97,-74,-49,-24
  57. };
  58.  
  59. CONST uint16 period_tab[] =
  60. {
  61.   0x0000, 0x0D60, 0x0CA0, 0x0BE8, 0x0B40, 0x0A98, 0x0A00, 0x0970,
  62.   0x08E8, 0x0868, 0x07F0, 0x0780, 0x0714, 0x06B0, 0x0650, 0x05F4,
  63.   0x05A0, 0x054C, 0x0500, 0x04B8, 0x0474, 0x0434, 0x03F8, 0x03C0,
  64.   0x038A, 0x0358, 0x0328, 0x02FA, 0x02D0, 0x02A6, 0x0280, 0x025C,
  65.   0x023A, 0x021A, 0x01FC, 0x01E0, 0x01C5, 0x01AC, 0x0194, 0x017D,
  66.   0x0168, 0x0153, 0x0140, 0x012E, 0x011D, 0x010D, 0x00FE, 0x00F0,
  67.   0x00E2, 0x00D6, 0x00CA, 0x00BE, 0x00B4, 0x00AA, 0x00A0, 0x0097,
  68.   0x008F, 0x0087, 0x007F, 0x0078, 0x0071
  69. };
  70.  
  71. uint32 panning_left[256], panning_right[256];
  72.  
  73. static inline void clr_l( uint32 *src, uint32 longs)
  74. {
  75.   do {
  76.     *src++ = 0;
  77.     longs--;
  78.   } while (longs > 0);
  79. }
  80.  
  81. void hvl_GenPanningTables( void )
  82. {
  83.   uint32 i;
  84.   float64 aa, ab;
  85.  
  86.   // Sine based panning table
  87.   aa = (3.14159265f*2.0f)/4.0f;   // Quarter of the way through the sinewave == top peak
  88.   ab = 0.0f;                      // Start of the climb from zero
  89.  
  90.   for( i=0; i<256; i++ )
  91.   {
  92.     panning_left[i]  = (uint32)(sin(aa)*255.0f);
  93.     panning_right[i] = (uint32)(sin(ab)*255.0f);
  94.     
  95.     aa += (3.14159265*2.0f/4.0f)/256.0f;
  96.     ab += (3.14159265*2.0f/4.0f)/256.0f;
  97.   }
  98.   panning_left[255] = 0;
  99.   panning_right[0] = 0;
  100. }
  101.  
  102. void hvl_GenSawtooth( int8 *buf, uint32 len )
  103. {
  104.   uint32 i;
  105.   int32  val, add;
  106.   
  107.   add = 256 / (len-1);
  108.   val = -128;
  109.   
  110.   for( i=0; i<len; i++, val += add )
  111.     *buf++ = (int8)val;  
  112. }
  113.  
  114. void hvl_GenTriangle( int8 *buf, uint32 len )
  115. {
  116.   uint32 i;
  117.   int32  d2, d5, d1, d4;
  118.   int32  val;
  119.   int8   *buf2;
  120.   
  121.   d2  = len;
  122.   d5  = len >> 2;
  123.   d1  = 128/d5;
  124.   d4  = -(d2 >> 1);
  125.   val = 0;
  126.   
  127.   for( i=0; i<d5; i++ )
  128.   {
  129.     *buf++ = val;
  130.     val += d1;
  131.   }
  132.   *buf++ = 0x7f;
  133.  
  134.   if( d5 != 1 )
  135.   {
  136.     val = 128;
  137.     for( i=0; i<d5-1; i++ )
  138.     {
  139.       val -= d1;
  140.       *buf++ = val;
  141.     }
  142.   }
  143.   
  144.   buf2 = buf + d4;
  145.   for( i=0; i<d5*2; i++ )
  146.   {
  147.     int8 c;
  148.     
  149.     c = *buf2++;
  150.     if( c == 0x7f )
  151.       c = 0x80;
  152.     else
  153.       c = -c;
  154.     
  155.     *buf++ = c;
  156.   }
  157. }
  158.  
  159. void hvl_GenSquare( int8 *buf )
  160. {
  161.   uint32 i, j;
  162.   
  163.   for( i=1; i<=0x20; i++ )
  164.   {
  165.     for( j=0; j<(0x40-i)*2; j++ )
  166.       *buf++ = 0x80;
  167.     for( j=0; j<i*2; j++ )
  168.       *buf++ = 0x7f;
  169.   }
  170. }
  171.  
  172. static inline float64 clip( float64 x )
  173. {
  174.   if( x > 127.f )
  175.     x = 127.f;
  176.   else if( x < -128.f )
  177.     x = -128.f;
  178.   return x;
  179. }
  180.  
  181. void hvl_GenFilterWaves( int8 *buf, int8 *lowbuf, int8 *highbuf )
  182. {
  183.   static const uint16 lentab[45] = { 3, 7, 0xf, 0x1f, 0x3f, 0x7f, 3, 7, 0xf, 0x1f, 0x3f, 0x7f,
  184.     0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,
  185.     0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,
  186.     (0x280*3)-1 };
  187.  
  188.   float64 freq;
  189.   uint32  temp;
  190.   
  191.   for( temp=0, freq=8.f; temp<31; temp++, freq+=3.f )
  192.   {
  193.     uint32 wv;
  194.     int8   *a0 = buf;
  195.     
  196.     for( wv=0; wv<6+6+0x20+1; wv++ )
  197.     {
  198.       float64 fre, high, mid, low;
  199.       uint32  i;
  200.       
  201.       mid = 0.f;
  202.       low = 0.f;
  203.       fre = freq * 1.25f / 100.0f;
  204.       
  205.       for( i=0; i<=lentab[wv]; i++ )
  206.       {
  207.         high  = a0[i] - mid - low;
  208.         high  = clip( high );
  209.         mid  += high * fre;
  210.         mid   = clip( mid );
  211.         low  += mid * fre;
  212.         low   = clip( low );
  213.       }
  214.       
  215.       for( i=0; i<=lentab[wv]; i++ )
  216.       {
  217.         high  = a0[i] - mid - low;
  218.         high  = clip( high );
  219.         mid  += high * fre;
  220.         mid   = clip( mid );
  221.         low  += mid * fre;
  222.         low   = clip( low );
  223.         *lowbuf++  = (int8)low;
  224.         *highbuf++ = (int8)high;
  225.       }
  226.       
  227.       a0 += lentab[wv]+1;
  228.     }
  229.   }
  230. }
  231.  
  232. void hvl_GenWhiteNoise( int8 *buf, uint32 len )
  233. {
  234.   uint32 ays;
  235.  
  236.   ays = 0x41595321;
  237.  
  238.   do {
  239.     uint16 ax, bx;
  240.     int8 s;
  241.  
  242.     s = ays;
  243.  
  244.     if( ays & 0x100 )
  245.     {
  246.       s = 0x80;
  247.  
  248.       if( (LONG)(ays & 0xffff) >= 0 )
  249.         s = 0x7f;
  250.     }
  251.  
  252.     *buf++ = s;
  253.     len--;
  254.  
  255.     ays = (ays >> 5) | (ays << 27);
  256.     ays = (ays & 0xffffff00) | ((ays & 0xff) ^ 0x9a);
  257.     bx  = ays;
  258.     ays = (ays << 2) | (ays >> 30);
  259.     ax  = ays;
  260.     bx  += ax;
  261.     ax  ^= bx;
  262.     ays  = (ays & 0xffff0000) | ax;
  263.     ays  = (ays >> 3) | (ays << 29);
  264.   } while( len );
  265. }
  266.  
  267. void hvl_reset_some_stuff( struct hvl_tune *ht )
  268. {
  269.   uint32 i;
  270.  
  271.   for( i=0; i<MAX_CHANNELS; i++ )
  272.   {
  273.     ht->ht_Voices[i].vc_SamplePos=ht->ht_Voices[i].vc_Delta=ht->ht_Voices[i].vc_Track=ht->ht_Voices[i].vc_Transpose=ht->ht_Voices[i].vc_NextTrack = ht->ht_Voices[i].vc_NextTranspose = 0;
  274.     ht->ht_Voices[i].vc_ADSRVolume=ht->ht_Voices[i].vc_InstrPeriod=ht->ht_Voices[i].vc_TrackPeriod=ht->ht_Voices[i].vc_VibratoPeriod=ht->ht_Voices[i].vc_NoteMaxVolume=ht->ht_Voices[i].vc_PerfSubVolume=ht->ht_Voices[i].vc_TrackMasterVolume=0;
  275.     ht->ht_Voices[i].vc_NewWaveform=ht->ht_Voices[i].vc_Waveform=ht->ht_Voices[i].vc_PlantSquare=ht->ht_Voices[i].vc_PlantPeriod=ht->ht_Voices[i].vc_IgnoreSquare=0;
  276.     ht->ht_Voices[i].vc_TrackOn=ht->ht_Voices[i].vc_FixedNote=ht->ht_Voices[i].vc_VolumeSlideUp=ht->ht_Voices[i].vc_VolumeSlideDown=ht->ht_Voices[i].vc_HardCut=ht->ht_Voices[i].vc_HardCutRelease=ht->ht_Voices[i].vc_HardCutReleaseF=0;
  277.     ht->ht_Voices[i].vc_PeriodSlideSpeed=ht->ht_Voices[i].vc_PeriodSlidePeriod=ht->ht_Voices[i].vc_PeriodSlideLimit=ht->ht_Voices[i].vc_PeriodSlideOn=ht->ht_Voices[i].vc_PeriodSlideWithLimit=0;
  278.     ht->ht_Voices[i].vc_PeriodPerfSlideSpeed=ht->ht_Voices[i].vc_PeriodPerfSlidePeriod=ht->ht_Voices[i].vc_PeriodPerfSlideOn=ht->ht_Voices[i].vc_VibratoDelay=ht->ht_Voices[i].vc_VibratoCurrent=ht->ht_Voices[i].vc_VibratoDepth=ht->ht_Voices[i].vc_VibratoSpeed=0;
  279.     ht->ht_Voices[i].vc_SquareOn=ht->ht_Voices[i].vc_SquareInit=ht->ht_Voices[i].vc_SquareLowerLimit=ht->ht_Voices[i].vc_SquareUpperLimit=ht->ht_Voices[i].vc_SquarePos=ht->ht_Voices[i].vc_SquareSign=ht->ht_Voices[i].vc_SquareSlidingIn=ht->ht_Voices[i].vc_SquareReverse=0;
  280.     ht->ht_Voices[i].vc_FilterOn=ht->ht_Voices[i].vc_FilterInit=ht->ht_Voices[i].vc_FilterLowerLimit=ht->ht_Voices[i].vc_FilterUpperLimit=ht->ht_Voices[i].vc_FilterPos=ht->ht_Voices[i].vc_FilterSign=ht->ht_Voices[i].vc_FilterSpeed=ht->ht_Voices[i].vc_FilterSlidingIn=ht->ht_Voices[i].vc_IgnoreFilter=0;
  281.     ht->ht_Voices[i].vc_PerfCurrent=ht->ht_Voices[i].vc_PerfSpeed=ht->ht_Voices[i].vc_WaveLength=ht->ht_Voices[i].vc_NoteDelayOn=ht->ht_Voices[i].vc_NoteCutOn=0;
  282.     ht->ht_Voices[i].vc_AudioPeriod=ht->ht_Voices[i].vc_AudioVolume=ht->ht_Voices[i].vc_VoiceVolume=ht->ht_Voices[i].vc_VoicePeriod=ht->ht_Voices[i].vc_VoiceNum=ht->ht_Voices[i].vc_WNRandom=0;
  283.     ht->ht_Voices[i].vc_SquareWait=ht->ht_Voices[i].vc_FilterWait=ht->ht_Voices[i].vc_PerfWait=ht->ht_Voices[i].vc_NoteDelayWait=ht->ht_Voices[i].vc_NoteCutWait=0;
  284.     ht->ht_Voices[i].vc_PerfList=0;
  285.     ht->ht_Voices[i].vc_RingSamplePos=ht->ht_Voices[i].vc_RingDelta=ht->ht_Voices[i].vc_RingPlantPeriod=ht->ht_Voices[i].vc_RingAudioPeriod=ht->ht_Voices[i].vc_RingNewWaveform=ht->ht_Voices[i].vc_RingWaveform=ht->ht_Voices[i].vc_RingFixedPeriod=ht->ht_Voices[i].vc_RingBasePeriod=0;
  286.  
  287.     ht->ht_Voices[i].vc_RingMixSource = NULL;
  288.     ht->ht_Voices[i].vc_RingAudioSource = NULL;
  289.  
  290.     clr_l((ULONG *)&ht->ht_Voices[i].vc_SquareTempBuffer,0x80/4);
  291.     clr_l((ULONG *)&ht->ht_Voices[i].vc_ADSR,sizeof(struct hvl_envelope)/4);
  292.     clr_l((ULONG *)&ht->ht_Voices[i].vc_VoiceBuffer,0x281/4);
  293.     clr_l((ULONG *)&ht->ht_Voices[i].vc_RingVoiceBuffer,0x281/4);
  294.   }
  295.   
  296.   for( i=0; i<MAX_CHANNELS; i++ )
  297.   {
  298.     ht->ht_Voices[i].vc_WNRandom          = 0x280;
  299.     ht->ht_Voices[i].vc_VoiceNum          = i;
  300.     ht->ht_Voices[i].vc_TrackMasterVolume = 0x40;
  301.     ht->ht_Voices[i].vc_TrackOn           = 1;
  302.     ht->ht_Voices[i].vc_MixSource         = ht->ht_Voices[i].vc_VoiceBuffer;
  303.   }
  304. }
  305.  
  306. BOOL hvl_InitSubsong( struct hvl_tune *ht, uint32 nr )
  307. {
  308.   uint32 PosNr, i;
  309.  
  310.   if( nr > ht->ht_SubsongNr )
  311.     return FALSE;
  312.  
  313.   ht->ht_SongNum = nr;
  314.   
  315.   PosNr = 0;
  316.   if( nr ) PosNr = ht->ht_Subsongs[nr-1];
  317.   
  318.   ht->ht_PosNr          = PosNr;
  319.   ht->ht_PosJump        = 0;
  320.   ht->ht_PatternBreak   = 0;
  321.   ht->ht_NoteNr         = 0;
  322.   ht->ht_PosJumpNote    = 0;
  323.   ht->ht_Tempo          = 6;
  324.   ht->ht_StepWaitFrames    = 0;
  325.   ht->ht_GetNewPosition = 1;
  326.   ht->ht_SongEndReached = 0;
  327.   ht->ht_PlayingTime    = 0;
  328.   
  329.   for( i=0; i<MAX_CHANNELS; i+=4 )
  330.   {
  331.     ht->ht_Voices[i+0].vc_Pan          = ht->ht_defpanleft;
  332.     ht->ht_Voices[i+0].vc_PanMultLeft  = panning_left[ht->ht_defpanleft];
  333.     ht->ht_Voices[i+0].vc_PanMultRight = panning_right[ht->ht_defpanleft];
  334.     ht->ht_Voices[i+1].vc_Pan          = ht->ht_defpanright;
  335.     ht->ht_Voices[i+1].vc_PanMultLeft  = panning_left[ht->ht_defpanright];
  336.     ht->ht_Voices[i+1].vc_PanMultRight = panning_right[ht->ht_defpanright];
  337.     ht->ht_Voices[i+2].vc_Pan          = ht->ht_defpanright;
  338.     ht->ht_Voices[i+2].vc_PanMultLeft  = panning_left[ht->ht_defpanright];
  339.     ht->ht_Voices[i+2].vc_PanMultRight = panning_right[ht->ht_defpanright];
  340.     ht->ht_Voices[i+3].vc_Pan          = ht->ht_defpanleft;
  341.     ht->ht_Voices[i+3].vc_PanMultLeft  = panning_left[ht->ht_defpanleft];
  342.     ht->ht_Voices[i+3].vc_PanMultRight = panning_right[ht->ht_defpanleft];
  343.   }
  344.  
  345.   hvl_reset_some_stuff( ht );
  346.   
  347.   return TRUE;
  348. }
  349.  
  350. void hvl_InitReplayer( void )
  351. {
  352.   hvl_GenPanningTables();
  353.   hvl_GenSawtooth( &waves[WO_SAWTOOTH_04], 0x04 );
  354.   hvl_GenSawtooth( &waves[WO_SAWTOOTH_08], 0x08 );
  355.   hvl_GenSawtooth( &waves[WO_SAWTOOTH_10], 0x10 );
  356.   hvl_GenSawtooth( &waves[WO_SAWTOOTH_20], 0x20 );
  357.   hvl_GenSawtooth( &waves[WO_SAWTOOTH_40], 0x40 );
  358.   hvl_GenSawtooth( &waves[WO_SAWTOOTH_80], 0x80 );
  359.   hvl_GenTriangle( &waves[WO_TRIANGLE_04], 0x04 );
  360.   hvl_GenTriangle( &waves[WO_TRIANGLE_08], 0x08 );
  361.   hvl_GenTriangle( &waves[WO_TRIANGLE_10], 0x10 );
  362.   hvl_GenTriangle( &waves[WO_TRIANGLE_20], 0x20 );
  363.   hvl_GenTriangle( &waves[WO_TRIANGLE_40], 0x40 );
  364.   hvl_GenTriangle( &waves[WO_TRIANGLE_80], 0x80 );
  365.   hvl_GenSquare( &waves[WO_SQUARES] );
  366.   hvl_GenWhiteNoise( &waves[WO_WHITENOISE], WHITENOISELEN );
  367.   hvl_GenFilterWaves( &waves[WO_TRIANGLE_04], &waves[WO_LOWPASSES], &waves[WO_HIGHPASSES] );
  368. }
  369.  
  370. struct hvl_tune *hvl_load_ahx( uint8 *buf, uint32 buflen, uint32 defstereo, uint32 freq )
  371. {
  372.   uint8  *bptr;
  373.   TEXT   *nptr;
  374.   uint32  i, j, k, l, posn, insn, ssn, hs, trkn, trkl;
  375.   struct hvl_tune *ht;
  376.   struct  hvl_plsentry *ple;
  377.   int32 defgain[] = { 73, 74, 79, 86, 100 };
  378.   
  379.   posn = ((buf[6]&0x0f)<<8)|buf[7];
  380.   insn = buf[12];
  381.   ssn  = buf[13];
  382.   trkl = buf[10];
  383.   trkn = buf[11];
  384.  
  385.   hs  = sizeof( struct hvl_tune );
  386.   hs += sizeof( struct hvl_position ) * posn;
  387.   hs += sizeof( struct hvl_instrument ) * (insn+1);
  388.   hs += sizeof( uint16 ) * ssn;
  389.  
  390.   // Calculate the size of all instrument PList buffers
  391.   bptr = &buf[14];
  392.   bptr += ssn*2;    // Skip past the subsong list
  393.   bptr += posn*4*2; // Skip past the positions
  394.   bptr += trkn*trkl*3;
  395.   if((buf[6]&0x80)==0) bptr += trkl*3;
  396.   
  397.   // *NOW* we can finally calculate PList space
  398.   for( i=1; i<=insn; i++ )
  399.   {
  400.     hs += bptr[21] * sizeof( struct hvl_plsentry );
  401.     bptr += 22 + bptr[21]*4;
  402.   }
  403.  
  404.   ht = AllocVec( hs, MEMF_ANY );
  405.   if( !ht )
  406.   {
  407.     FreeVec( buf );
  408.     printf( "Out of memory!\n" );
  409.     return NULL;
  410.   }
  411.   
  412.   ht->ht_Frequency       = freq;
  413.   ht->ht_FreqF           = (float64)freq;
  414.   
  415.   ht->ht_Positions   = (struct hvl_position *)(&ht[1]);
  416.   ht->ht_Instruments = (struct hvl_instrument *)(&ht->ht_Positions[posn]);
  417.   ht->ht_Subsongs    = (uint16 *)(&ht->ht_Instruments[(insn+1)]);
  418.   ple                = (struct hvl_plsentry *)(&ht->ht_Subsongs[ssn]);
  419.  
  420.   ht->ht_WaveformTab[0]  = &waves[WO_TRIANGLE_04];
  421.   ht->ht_WaveformTab[1]  = &waves[WO_SAWTOOTH_04];
  422.   ht->ht_WaveformTab[3]  = &waves[WO_WHITENOISE];
  423.  
  424.   ht->ht_Channels        = 4;
  425.   ht->ht_PositionNr      = posn;
  426.   ht->ht_Restart         = (buf[8]<<8)|buf[9];
  427.   ht->ht_SpeedMultiplier = ((buf[6]>>5)&3)+1;
  428.   ht->ht_TrackLength     = trkl;
  429.   ht->ht_TrackNr         = trkn;
  430.   ht->ht_InstrumentNr    = insn;
  431.   ht->ht_SubsongNr       = ssn;
  432.   ht->ht_defstereo       = defstereo;
  433.   ht->ht_defpanleft      = stereopan_left[ht->ht_defstereo];
  434.   ht->ht_defpanright     = stereopan_right[ht->ht_defstereo];
  435.   ht->ht_mixgain         = (defgain[ht->ht_defstereo]*256)/100;
  436.   
  437.   if( ht->ht_Restart >= ht->ht_PositionNr )
  438.     ht->ht_Restart = ht->ht_PositionNr-1;
  439.  
  440.   // Do some validation  
  441.   if( ( ht->ht_PositionNr > 1000 ) ||
  442.       ( ht->ht_TrackLength > 64 ) ||
  443.       ( ht->ht_InstrumentNr > 64 ) )
  444.   {
  445.     printf( "%d,%d,%d\n", ht->ht_PositionNr,
  446.                           ht->ht_TrackLength,
  447.                           ht->ht_InstrumentNr );
  448.     FreeVec( ht );
  449.     FreeVec( buf );
  450.     printf( "Invalid file.\n" );
  451.     return NULL;
  452.   }
  453.  
  454.   strncpy( ht->ht_Name, (TEXT *)&buf[(buf[4]<<8)|buf[5]], 128 );
  455.   nptr = (TEXT *)&buf[((buf[4]<<8)|buf[5])+strlen( ht->ht_Name )+1];
  456.  
  457.   bptr = &buf[14];
  458.   
  459.   // Subsongs
  460.   for( i=0; i<ht->ht_SubsongNr; i++ )
  461.   {
  462.     ht->ht_Subsongs[i] = (bptr[0]<<8)|bptr[1];
  463.     bptr += 2;
  464.   }
  465.   
  466.   // Position list
  467.   for( i=0; i<ht->ht_PositionNr; i++ )
  468.   {
  469.     for( j=0; j<4; j++ )
  470.     {
  471.       ht->ht_Positions[i].pos_Track[j]     = *bptr++;
  472.       ht->ht_Positions[i].pos_Transpose[j] = *(int8 *)bptr++;
  473.     }
  474.   }
  475.   
  476.   // Tracks
  477.   for( i=0; i<=ht->ht_TrackNr; i++ )
  478.   {
  479.     if( ( ( buf[6]&0x80 ) == 0x80 ) && ( i == 0 ) )
  480.     {
  481.       for( j=0; j<ht->ht_TrackLength; j++ )
  482.       {
  483.         ht->ht_Tracks[i][j].stp_Note       = 0;
  484.         ht->ht_Tracks[i][j].stp_Instrument = 0;
  485.         ht->ht_Tracks[i][j].stp_FX         = 0;
  486.         ht->ht_Tracks[i][j].stp_FXParam    = 0;
  487.         ht->ht_Tracks[i][j].stp_FXb        = 0;
  488.         ht->ht_Tracks[i][j].stp_FXbParam   = 0;
  489.       }
  490.       continue;
  491.     }
  492.     
  493.     for( j=0; j<ht->ht_TrackLength; j++ )
  494.     {
  495.       ht->ht_Tracks[i][j].stp_Note       = (bptr[0]>>2)&0x3f;
  496.       ht->ht_Tracks[i][j].stp_Instrument = ((bptr[0]&0x3)<<4) | (bptr[1]>>4);
  497.       ht->ht_Tracks[i][j].stp_FX         = bptr[1]&0xf;
  498.       ht->ht_Tracks[i][j].stp_FXParam    = bptr[2];
  499.       ht->ht_Tracks[i][j].stp_FXb        = 0;
  500.       ht->ht_Tracks[i][j].stp_FXbParam   = 0;
  501.       bptr += 3;
  502.     }
  503.   }
  504.   
  505.   // Instruments
  506.   for( i=1; i<=ht->ht_InstrumentNr; i++ )
  507.   {
  508.     strncpy( ht->ht_Instruments[i].ins_Name, nptr, 128 );
  509.     nptr += strlen( nptr )+1;
  510.     
  511.     ht->ht_Instruments[i].ins_Volume      = bptr[0];
  512.     ht->ht_Instruments[i].ins_FilterSpeed = ((bptr[1]>>3)&0x1f)|((bptr[12]>>2)&0x20);
  513.     ht->ht_Instruments[i].ins_WaveLength  = bptr[1]&0x07;
  514.  
  515.     ht->ht_Instruments[i].ins_Envelope.aFrames = bptr[2];
  516.     ht->ht_Instruments[i].ins_Envelope.aVolume = bptr[3];
  517.     ht->ht_Instruments[i].ins_Envelope.dFrames = bptr[4];
  518.     ht->ht_Instruments[i].ins_Envelope.dVolume = bptr[5];
  519.     ht->ht_Instruments[i].ins_Envelope.sFrames = bptr[6];
  520.     ht->ht_Instruments[i].ins_Envelope.rFrames = bptr[7];
  521.     ht->ht_Instruments[i].ins_Envelope.rVolume = bptr[8];
  522.     
  523.     ht->ht_Instruments[i].ins_FilterLowerLimit     = bptr[12]&0x7f;
  524.     ht->ht_Instruments[i].ins_VibratoDelay         = bptr[13];
  525.     ht->ht_Instruments[i].ins_HardCutReleaseFrames = (bptr[14]>>4)&0x07;
  526.     ht->ht_Instruments[i].ins_HardCutRelease       = bptr[14]&0x80?1:0;
  527.     ht->ht_Instruments[i].ins_VibratoDepth         = bptr[14]&0x0f;
  528.     ht->ht_Instruments[i].ins_VibratoSpeed         = bptr[15];
  529.     ht->ht_Instruments[i].ins_SquareLowerLimit     = bptr[16];
  530.     ht->ht_Instruments[i].ins_SquareUpperLimit     = bptr[17];
  531.     ht->ht_Instruments[i].ins_SquareSpeed          = bptr[18];
  532.     ht->ht_Instruments[i].ins_FilterUpperLimit     = bptr[19]&0x3f;
  533.     ht->ht_Instruments[i].ins_PList.pls_Speed      = bptr[20];
  534.     ht->ht_Instruments[i].ins_PList.pls_Length     = bptr[21];
  535.     
  536.     ht->ht_Instruments[i].ins_PList.pls_Entries    = ple;
  537.     ple += bptr[21];
  538.     
  539.     bptr += 22;
  540.     for( j=0; j<ht->ht_Instruments[i].ins_PList.pls_Length; j++ )
  541.     {
  542.       k = (bptr[0]>>5)&7;
  543.       if( k == 6 ) k = 12;
  544.       if( k == 7 ) k = 15;
  545.       l = (bptr[0]>>2)&7;
  546.       if( l == 6 ) l = 12;
  547.       if( l == 7 ) l = 15;
  548.       ht->ht_Instruments[i].ins_PList.pls_Entries[j].ple_FX[1]      = k;
  549.       ht->ht_Instruments[i].ins_PList.pls_Entries[j].ple_FX[0]      = l;
  550.       ht->ht_Instruments[i].ins_PList.pls_Entries[j].ple_Waveform   = ((bptr[0]<<1)&6) | (bptr[1]>>7);
  551.       ht->ht_Instruments[i].ins_PList.pls_Entries[j].ple_Fixed      = (bptr[1]>>6)&1;
  552.       ht->ht_Instruments[i].ins_PList.pls_Entries[j].ple_Note       = bptr[1]&0x3f;
  553.       ht->ht_Instruments[i].ins_PList.pls_Entries[j].ple_FXParam[0] = bptr[2];
  554.       ht->ht_Instruments[i].ins_PList.pls_Entries[j].ple_FXParam[1] = bptr[3];
  555.       bptr += 4;
  556.     }
  557.   }
  558.   
  559.   hvl_InitSubsong( ht, 0 );
  560.   FreeVec( buf );
  561.   return ht;
  562. }
  563.  
  564. struct hvl_tune *hvl_LoadTune( TEXT *name, uint32 freq, uint32 defstereo )
  565. {
  566.   struct hvl_tune *ht;
  567.   uint8  *buf, *bptr;
  568.   TEXT   *nptr;
  569.   uint32  buflen, i, j, posn, insn, ssn, chnn, hs, trkl, trkn;
  570.   BPTR    lock, fh;
  571.   struct  FileInfoBlock *fib;
  572.   struct  hvl_plsentry *ple;
  573.  
  574.   fib = AllocDosObjectTags( DOS_FIB, TAG_DONE );
  575.   if( !fib )
  576.   {
  577.     printf( "Out of memory\n" );
  578.     return NULL;
  579.   }
  580.   
  581.   lock = Lock( name, ACCESS_READ );
  582.   if( !lock )
  583.   {
  584.     FreeDosObject( DOS_FIB, fib );
  585.     printf( "Unable to find '%s'\n", name );
  586.     return NULL;
  587.   }
  588.   
  589.   Examine( lock, fib );
  590.   if( !FIB_IS_FILE( fib ) )
  591.   {
  592.     UnLock( lock );
  593.     FreeDosObject( DOS_FIB, fib );
  594.     printf( "Bad file!\n" );
  595.     return NULL;
  596.   }
  597.   
  598.   buflen = fib->fib_Size;
  599.   buf = AllocVec( buflen, MEMF_ANY );
  600.   if( !buf )
  601.   {
  602.     UnLock( lock );
  603.     FreeDosObject( DOS_FIB, fib );
  604.     printf( "Out of memory!\n" );
  605.     return NULL;
  606.   }
  607.   
  608.   fh = OpenFromLock( lock );
  609.   if( !fh )
  610.   {
  611.     FreeVec( buf );
  612.     UnLock( lock );
  613.     FreeDosObject( DOS_FIB, fib );
  614.     printf( "Can't open file\n" );
  615.     return NULL;
  616.   }
  617.  
  618.   if( Read( fh, buf, buflen ) != buflen )
  619.   {
  620.     FreeVec( buf );
  621.     Close( fh );
  622.     FreeDosObject( DOS_FIB, fib );
  623.     printf( "Unable to read from file!\n" );
  624.     return NULL;
  625.   }
  626.   Close( fh );
  627.   FreeDosObject( DOS_FIB, fib );
  628.   
  629.   if( ( buf[0] == 'T' ) &&
  630.       ( buf[1] == 'H' ) &&
  631.       ( buf[2] == 'X' ) &&
  632.       ( buf[3] < 3 ) )
  633.     return hvl_load_ahx( buf, buflen, defstereo, freq );
  634.  
  635.   if( ( buf[0] != 'H' ) ||
  636.       ( buf[1] != 'V' ) ||
  637.       ( buf[2] != 'L' ) ||
  638.       ( buf[3] > 0 ) )
  639.   {
  640.     FreeVec( buf );
  641.     printf( "Invalid file.\n" );
  642.     return NULL;
  643.   }
  644.   
  645.   posn = ((buf[6]&0x0f)<<8)|buf[7];
  646.   insn = buf[12];
  647.   ssn  = buf[13];
  648.   chnn = (buf[8]>>2)+4;
  649.   trkl = buf[10];
  650.   trkn = buf[11];
  651.  
  652.   hs  = sizeof( struct hvl_tune );
  653.   hs += sizeof( struct hvl_position ) * posn;
  654.   hs += sizeof( struct hvl_instrument ) * (insn+1);
  655.   hs += sizeof( uint16 ) * ssn;
  656.  
  657.   // Calculate the size of all instrument PList buffers
  658.   bptr = &buf[16];
  659.   bptr += ssn*2;       // Skip past the subsong list
  660.   bptr += posn*chnn*2; // Skip past the positions
  661.   
  662.   // Skip past the tracks
  663.   i=(buf[6]&0x80)?1:0;
  664.   for( i=0; i<trkn; i++ )
  665.     for( j=0; j<trkl; j++ )
  666.     {
  667.       if( bptr[0] == 0x3f )
  668.       {
  669.         bptr++;
  670.         continue;
  671.       }
  672.       bptr += 5;
  673.     }
  674.   
  675.   // *NOW* we can finally calculate PList space
  676.   for( i=1; i<=insn; i++ )
  677.   {
  678.     hs += bptr[21] * sizeof( struct hvl_plsentry );
  679.     bptr += 22 + bptr[21]*5;
  680.   }
  681.   
  682.   ht = AllocVec( hs, MEMF_ANY );    
  683.   if( !ht )
  684.   {
  685.     FreeVec( buf );
  686.     printf( "Out of memory!\n" );
  687.     return NULL;
  688.   }
  689.   
  690.   ht->ht_Frequency       = freq;
  691.   ht->ht_FreqF           = (float64)freq;
  692.   
  693.   ht->ht_Positions       = (struct hvl_position *)(&ht[1]);
  694.   ht->ht_Instruments     = (struct hvl_instrument *)(&ht->ht_Positions[posn]);
  695.   ht->ht_Subsongs        = (uint16 *)(&ht->ht_Instruments[(insn+1)]);
  696.   ple                    = (struct hvl_plsentry *)(&ht->ht_Subsongs[ssn]);
  697.  
  698.   ht->ht_WaveformTab[0]  = &waves[WO_TRIANGLE_04];
  699.   ht->ht_WaveformTab[1]  = &waves[WO_SAWTOOTH_04];
  700.   ht->ht_WaveformTab[3]  = &waves[WO_WHITENOISE];
  701.  
  702.   ht->ht_PositionNr      = posn;
  703.   ht->ht_Channels        = (buf[8]>>2)+4;
  704.   ht->ht_Restart         = ((buf[8]&3)<<8)|buf[9];
  705.   ht->ht_SpeedMultiplier = ((buf[6]>>5)&3)+1;
  706.   ht->ht_TrackLength     = buf[10];
  707.   ht->ht_TrackNr         = buf[11];
  708.   ht->ht_InstrumentNr    = insn;
  709.   ht->ht_SubsongNr       = ssn;
  710.   ht->ht_mixgain         = (buf[14]<<8)/100;
  711.   ht->ht_defstereo       = buf[15];
  712.   ht->ht_defpanleft      = stereopan_left[ht->ht_defstereo];
  713.   ht->ht_defpanright     = stereopan_right[ht->ht_defstereo];
  714.   
  715.   if( ht->ht_Restart >= ht->ht_PositionNr )
  716.     ht->ht_Restart = ht->ht_PositionNr-1;
  717.  
  718.   // Do some validation  
  719.   if( ( ht->ht_PositionNr > 1000 ) ||
  720.       ( ht->ht_TrackLength > 64 ) ||
  721.       ( ht->ht_InstrumentNr > 64 ) )
  722.   {
  723.     printf( "%d,%d,%d\n", ht->ht_PositionNr,
  724.                           ht->ht_TrackLength,
  725.                           ht->ht_InstrumentNr );
  726.     FreeVec( ht );
  727.     FreeVec( buf );
  728.     printf( "Invalid file.\n" );
  729.     return NULL;
  730.   }
  731.  
  732.   strncpy( ht->ht_Name, (TEXT *)&buf[(buf[4]<<8)|buf[5]], 128 );
  733.   nptr = (TEXT *)&buf[((buf[4]<<8)|buf[5])+strlen( ht->ht_Name )+1];
  734.  
  735.   bptr = &buf[16];
  736.   
  737.   // Subsongs
  738.   for( i=0; i<ht->ht_SubsongNr; i++ )
  739.   {
  740.     ht->ht_Subsongs[i] = (bptr[0]<<8)|bptr[1];
  741.     bptr += 2;
  742.   }
  743.   
  744.   // Position list
  745.   for( i=0; i<ht->ht_PositionNr; i++ )
  746.   {
  747.     for( j=0; j<ht->ht_Channels; j++ )
  748.     {
  749.       ht->ht_Positions[i].pos_Track[j]     = *bptr++;
  750.       ht->ht_Positions[i].pos_Transpose[j] = *(int8 *)bptr++;
  751.     }
  752.   }
  753.   
  754.   // Tracks
  755.   for( i=0; i<=ht->ht_TrackNr; i++ )
  756.   {
  757.     if( ( ( buf[6]&0x80 ) == 0x80 ) && ( i == 0 ) )
  758.     {
  759.       for( j=0; j<ht->ht_TrackLength; j++ )
  760.       {
  761.         ht->ht_Tracks[i][j].stp_Note       = 0;
  762.         ht->ht_Tracks[i][j].stp_Instrument = 0;
  763.         ht->ht_Tracks[i][j].stp_FX         = 0;
  764.         ht->ht_Tracks[i][j].stp_FXParam    = 0;
  765.         ht->ht_Tracks[i][j].stp_FXb        = 0;
  766.         ht->ht_Tracks[i][j].stp_FXbParam   = 0;
  767.       }
  768.       continue;
  769.     }
  770.     
  771.     for( j=0; j<ht->ht_TrackLength; j++ )
  772.     {
  773.       if( bptr[0] == 0x3f )
  774.       {
  775.         ht->ht_Tracks[i][j].stp_Note       = 0;
  776.         ht->ht_Tracks[i][j].stp_Instrument = 0;
  777.         ht->ht_Tracks[i][j].stp_FX         = 0;
  778.         ht->ht_Tracks[i][j].stp_FXParam    = 0;
  779.         ht->ht_Tracks[i][j].stp_FXb        = 0;
  780.         ht->ht_Tracks[i][j].stp_FXbParam   = 0;
  781.         bptr++;
  782.         continue;
  783.       }
  784.       
  785.       ht->ht_Tracks[i][j].stp_Note       = bptr[0];
  786.       ht->ht_Tracks[i][j].stp_Instrument = bptr[1];
  787.       ht->ht_Tracks[i][j].stp_FX         = bptr[2]>>4;
  788.       ht->ht_Tracks[i][j].stp_FXParam    = bptr[3];
  789.       ht->ht_Tracks[i][j].stp_FXb        = bptr[2]&0xf;
  790.       ht->ht_Tracks[i][j].stp_FXbParam   = bptr[4];
  791.       bptr += 5;
  792.     }
  793.   }
  794.   
  795.   
  796.   // Instruments
  797.   for( i=1; i<=ht->ht_InstrumentNr; i++ )
  798.   {
  799.     strncpy( ht->ht_Instruments[i].ins_Name, nptr, 128 );
  800.     nptr += strlen( nptr )+1;
  801.     
  802.     ht->ht_Instruments[i].ins_Volume      = bptr[0];
  803.     ht->ht_Instruments[i].ins_FilterSpeed = ((bptr[1]>>3)&0x1f)|((bptr[12]>>2)&0x20);
  804.     ht->ht_Instruments[i].ins_WaveLength  = bptr[1]&0x07;
  805.  
  806.     ht->ht_Instruments[i].ins_Envelope.aFrames = bptr[2];
  807.     ht->ht_Instruments[i].ins_Envelope.aVolume = bptr[3];
  808.     ht->ht_Instruments[i].ins_Envelope.dFrames = bptr[4];
  809.     ht->ht_Instruments[i].ins_Envelope.dVolume = bptr[5];
  810.     ht->ht_Instruments[i].ins_Envelope.sFrames = bptr[6];
  811.     ht->ht_Instruments[i].ins_Envelope.rFrames = bptr[7];
  812.     ht->ht_Instruments[i].ins_Envelope.rVolume = bptr[8];
  813.     
  814.     ht->ht_Instruments[i].ins_FilterLowerLimit     = bptr[12]&0x7f;
  815.     ht->ht_Instruments[i].ins_VibratoDelay         = bptr[13];
  816.     ht->ht_Instruments[i].ins_HardCutReleaseFrames = (bptr[14]>>4)&0x07;
  817.     ht->ht_Instruments[i].ins_HardCutRelease       = bptr[14]&0x80?1:0;
  818.     ht->ht_Instruments[i].ins_VibratoDepth         = bptr[14]&0x0f;
  819.     ht->ht_Instruments[i].ins_VibratoSpeed         = bptr[15];
  820.     ht->ht_Instruments[i].ins_SquareLowerLimit     = bptr[16];
  821.     ht->ht_Instruments[i].ins_SquareUpperLimit     = bptr[17];
  822.     ht->ht_Instruments[i].ins_SquareSpeed          = bptr[18];
  823.     ht->ht_Instruments[i].ins_FilterUpperLimit     = bptr[19]&0x3f;
  824.     ht->ht_Instruments[i].ins_PList.pls_Speed      = bptr[20];
  825.     ht->ht_Instruments[i].ins_PList.pls_Length     = bptr[21];
  826.     
  827.     ht->ht_Instruments[i].ins_PList.pls_Entries    = ple;
  828.     ple += bptr[21];
  829.     
  830.     bptr += 22;
  831.     for( j=0; j<ht->ht_Instruments[i].ins_PList.pls_Length; j++ )
  832.     {
  833.       ht->ht_Instruments[i].ins_PList.pls_Entries[j].ple_FX[0] = bptr[0]&0xf;
  834.       ht->ht_Instruments[i].ins_PList.pls_Entries[j].ple_FX[1] = (bptr[1]>>3)&0xf;
  835.       ht->ht_Instruments[i].ins_PList.pls_Entries[j].ple_Waveform = bptr[1]&7;
  836.       ht->ht_Instruments[i].ins_PList.pls_Entries[j].ple_Fixed = (bptr[2]>>6)&1;
  837.       ht->ht_Instruments[i].ins_PList.pls_Entries[j].ple_Note  = bptr[2]&0x3f;
  838.       ht->ht_Instruments[i].ins_PList.pls_Entries[j].ple_FXParam[0] = bptr[3];
  839.       ht->ht_Instruments[i].ins_PList.pls_Entries[j].ple_FXParam[1] = bptr[4];
  840.       bptr += 5;
  841.     }
  842.   }
  843.   
  844.   hvl_InitSubsong( ht, 0 );
  845.   FreeVec( buf );
  846.   return ht;
  847. }
  848.  
  849. void hvl_FreeTune( struct hvl_tune *ht )
  850. {
  851.   if( !ht ) return;
  852.   FreeVec( ht );
  853. }
  854.  
  855. void hvl_process_stepfx_1( struct hvl_tune *ht, struct hvl_voice *voice, int32 FX, int32 FXParam )
  856. {
  857.   switch( FX )
  858.   {
  859.     case 0x0:  // Position Jump HI
  860.       if( ((FXParam&0x0f) > 0) && ((FXParam&0x0f) <= 9) )
  861.         ht->ht_PosJump = FXParam & 0xf;
  862.       break;
  863.  
  864.     case 0x5:  // Volume Slide + Tone Portamento
  865.     case 0xa:  // Volume Slide
  866.       voice->vc_VolumeSlideDown = FXParam & 0x0f;
  867.       voice->vc_VolumeSlideUp   = FXParam >> 4;
  868.       break;
  869.     
  870.     case 0x7:  // Panning
  871.       if( FXParam > 127 )
  872.         FXParam -= 256;
  873.       voice->vc_Pan          = (FXParam+128);
  874.       voice->vc_PanMultLeft  = panning_left[voice->vc_Pan];
  875.       voice->vc_PanMultRight = panning_right[voice->vc_Pan];
  876.       break;
  877.     
  878.     case 0xb: // Position jump
  879.       ht->ht_PosJump      = ht->ht_PosJump*100 + (FXParam & 0x0f) + (FXParam >> 4)*10;
  880.       ht->ht_PatternBreak = 1;
  881.       if( ht->ht_PosJump < ht->ht_PosNr )
  882.         ht->ht_SongEndReached = 1;
  883.       break;
  884.     
  885.     case 0xd: // Pattern break
  886.       ht->ht_PosJump      = ht->ht_PosNr+1;
  887.       ht->ht_PosJumpNote  = (FXParam & 0x0f) + (FXParam>>4)*10;
  888.       ht->ht_PatternBreak = 1;
  889.       if( ht->ht_PosJumpNote >  ht->ht_TrackLength )
  890.         ht->ht_PosJumpNote = 0;
  891.       break;
  892.     
  893.     case 0xe: // Extended commands
  894.       switch( FXParam >> 4 )
  895.       {
  896.         case 0xc: // Note cut
  897.           if( (FXParam & 0x0f) < ht->ht_Tempo )
  898.           {
  899.             voice->vc_NoteCutWait = FXParam & 0x0f;
  900.             if( voice->vc_NoteCutWait )
  901.             {
  902.               voice->vc_NoteCutOn      = 1;
  903.               voice->vc_HardCutRelease = 0;
  904.             }
  905.           }
  906.           break;
  907.         case 0xd: // Note delay
  908.           if( voice->vc_NoteDelayOn )
  909.           {
  910.             voice->vc_NoteDelayOn = 0;
  911.           } else {
  912.             if( (FXParam & 0x0f) < ht->ht_Tempo )
  913.             {
  914.               voice->vc_NoteDelayWait = FXParam & 0x0f;
  915.               if( voice->vc_NoteDelayWait )
  916.               {
  917.                 voice->vc_NoteDelayOn = 1;
  918.                 return;
  919.               }
  920.             }
  921.           }
  922.           break;
  923.       }
  924.       break;
  925.     
  926.     case 0xf: // Speed
  927.       ht->ht_Tempo = FXParam;
  928.       if( FXParam == 0 )
  929.         ht->ht_SongEndReached = 1;
  930.       break;
  931.   }  
  932. }
  933.  
  934. void hvl_process_stepfx_2( struct hvl_tune *ht, struct hvl_voice *voice, int32 FX, int32 FXParam, int32 *Note )
  935. {
  936.   switch( FX )
  937.   {
  938.     case 0x9: // Set squarewave offset
  939.       voice->vc_SquarePos    = FXParam >> (5 - voice->vc_WaveLength);
  940.       voice->vc_PlantSquare  = 1;
  941.       voice->vc_IgnoreSquare = 1;
  942.       break;
  943.     
  944.     case 0x5: // Tone portamento + volume slide
  945.     case 0x3: // Tone portamento
  946.       if( FXParam != 0 ) voice->vc_PeriodSlideSpeed = FXParam;
  947.       
  948.       if( *Note )
  949.       {
  950.         int32 new, diff;
  951.  
  952.         new   = period_tab[*Note];
  953.         diff  = period_tab[voice->vc_TrackPeriod];
  954.         diff -= new;
  955.         new   = diff + voice->vc_PeriodSlidePeriod;
  956.         
  957.         if( new )
  958.           voice->vc_PeriodSlideLimit = -diff;
  959.       }
  960.       voice->vc_PeriodSlideOn        = 1;
  961.       voice->vc_PeriodSlideWithLimit = 1;
  962.       *Note = 0;
  963.       break;      
  964.   } 
  965. }
  966.  
  967. void hvl_process_stepfx_3( struct hvl_tune *ht, struct hvl_voice *voice, int32 FX, int32 FXParam )
  968. {
  969.   int32 i;
  970.   
  971.   switch( FX )
  972.   {
  973.     case 0x01: // Portamento up (period slide down)
  974.       voice->vc_PeriodSlideSpeed     = -FXParam;
  975.       voice->vc_PeriodSlideOn        = 1;
  976.       voice->vc_PeriodSlideWithLimit = 0;
  977.       break;
  978.     case 0x02: // Portamento down
  979.       voice->vc_PeriodSlideSpeed     = FXParam;
  980.       voice->vc_PeriodSlideOn        = 1;
  981.       voice->vc_PeriodSlideWithLimit = 0;
  982.       break;
  983.     case 0x04: // Filter override
  984.       if( FXParam < 0x40 )
  985.       {
  986.         voice->vc_IgnoreFilter = FXParam;
  987.         break;
  988.       }
  989.       if( FXParam > 0x7f ) break;
  990.       voice->vc_FilterPos = FXParam - 0x40;
  991.       break;
  992.     case 0x0c: // Volume
  993.       FXParam &= 0xff;
  994.       if( FXParam <= 0x40 )
  995.       {
  996.         voice->vc_NoteMaxVolume = FXParam;
  997.         break;
  998.       }
  999.       
  1000.       FXParam -= 0x50;
  1001.       if( FXParam <= 0x40 )
  1002.       {
  1003.         for( i=0; i<ht->ht_Channels; i++ )
  1004.           ht->ht_Voices[i].vc_TrackMasterVolume = FXParam;
  1005.         break;
  1006.       }
  1007.       
  1008.       FXParam -= 0xa0-0x50;
  1009.       if( FXParam <= 0x40 )
  1010.         voice->vc_TrackMasterVolume = FXParam;
  1011.       break;
  1012.  
  1013.     case 0xe: // Extended commands;
  1014.       switch( FXParam >> 4 )
  1015.       {
  1016.         case 0x1: // Fineslide up
  1017.           voice->vc_PeriodSlidePeriod = -(FXParam & 0x0f);
  1018.           voice->vc_PlantPeriod = 1;
  1019.           break;
  1020.         
  1021.         case 0x2: // Fineslide down
  1022.           voice->vc_PeriodSlidePeriod = (FXParam & 0x0f);
  1023.           voice->vc_PlantPeriod = 1;
  1024.           break;
  1025.         
  1026.         case 0x4: // Vibrato control
  1027.           voice->vc_VibratoDepth = FXParam & 0x0f;
  1028.           break;
  1029.         
  1030.         case 0x0a: // Fine volume up
  1031.           voice->vc_NoteMaxVolume += FXParam & 0x0f;
  1032.           
  1033.           if( voice->vc_NoteMaxVolume > 0x40 )
  1034.             voice->vc_NoteMaxVolume = 0x40;
  1035.           break;
  1036.         
  1037.         case 0x0b: // Fine volume down
  1038.           voice->vc_NoteMaxVolume -= FXParam & 0x0f;
  1039.           
  1040.           if( voice->vc_NoteMaxVolume < 0 )
  1041.             voice->vc_NoteMaxVolume = 0;
  1042.           break;
  1043.       } 
  1044.       break;
  1045.   }
  1046. }
  1047.  
  1048. void hvl_process_step( struct hvl_tune *ht, struct hvl_voice *voice )
  1049. {
  1050.   int32  Note, Instr;
  1051.   struct hvl_step *Step;
  1052.   
  1053.   if( voice->vc_TrackOn == 0 )
  1054.     return;
  1055.   
  1056.   voice->vc_VolumeSlideUp = voice->vc_VolumeSlideDown = 0;
  1057.   
  1058.   Step = &ht->ht_Tracks[ht->ht_Positions[ht->ht_PosNr].pos_Track[voice->vc_VoiceNum]][ht->ht_NoteNr];
  1059.   
  1060.   Note    = Step->stp_Note;
  1061.   Instr   = Step->stp_Instrument;
  1062.  
  1063.   hvl_process_stepfx_1( ht, voice, Step->stp_FX&0xf,  Step->stp_FXParam );  
  1064.   hvl_process_stepfx_1( ht, voice, Step->stp_FXb&0xf, Step->stp_FXbParam );
  1065.   
  1066.   if( Instr )
  1067.   {
  1068.     struct hvl_instrument *Ins;
  1069.     int16  SquareLower, SquareUpper, d6, d3, d4;
  1070.     
  1071.     voice->vc_PeriodSlideSpeed = voice->vc_PeriodSlidePeriod = voice->vc_PeriodSlideLimit = 0;
  1072.  
  1073.     voice->vc_PerfSubVolume    = 0x40;
  1074.     voice->vc_ADSRVolume       = 0;
  1075.     voice->vc_Instrument       = Ins = &ht->ht_Instruments[Instr];
  1076.     voice->vc_SamplePos        = 0;
  1077.     
  1078.     voice->vc_ADSR.aFrames     = Ins->ins_Envelope.aFrames;
  1079.     voice->vc_ADSR.aVolume     = Ins->ins_Envelope.aVolume*256/voice->vc_ADSR.aFrames;
  1080.     voice->vc_ADSR.dFrames     = Ins->ins_Envelope.dFrames;
  1081.     voice->vc_ADSR.dVolume     = (Ins->ins_Envelope.dVolume-Ins->ins_Envelope.aVolume)*256/voice->vc_ADSR.dFrames;
  1082.     voice->vc_ADSR.sFrames     = Ins->ins_Envelope.sFrames;
  1083.     voice->vc_ADSR.rFrames     = Ins->ins_Envelope.rFrames;
  1084.     voice->vc_ADSR.rVolume     = (Ins->ins_Envelope.rVolume-Ins->ins_Envelope.dVolume)*256/voice->vc_ADSR.rFrames;
  1085.     
  1086.     voice->vc_WaveLength       = Ins->ins_WaveLength;
  1087.     voice->vc_NoteMaxVolume    = Ins->ins_Volume;
  1088.     
  1089.     voice->vc_VibratoCurrent   = 0;
  1090.     voice->vc_VibratoDelay     = Ins->ins_VibratoDelay;
  1091.     voice->vc_VibratoDepth     = Ins->ins_VibratoDepth;
  1092.     voice->vc_VibratoSpeed     = Ins->ins_VibratoSpeed;
  1093.     voice->vc_VibratoPeriod    = 0;
  1094.     
  1095.     voice->vc_HardCutRelease   = Ins->ins_HardCutRelease;
  1096.     voice->vc_HardCut          = Ins->ins_HardCutReleaseFrames;
  1097.     
  1098.     voice->vc_IgnoreSquare = voice->vc_SquareSlidingIn = 0;
  1099.     voice->vc_SquareWait   = voice->vc_SquareOn        = 0;
  1100.     
  1101.     SquareLower = Ins->ins_SquareLowerLimit >> (5 - voice->vc_WaveLength);
  1102.     SquareUpper = Ins->ins_SquareUpperLimit >> (5 - voice->vc_WaveLength);
  1103.     
  1104.     if( SquareUpper < SquareLower )
  1105.     {
  1106.       int16 t = SquareUpper;
  1107.       SquareUpper = SquareLower;
  1108.       SquareLower = t;
  1109.     }
  1110.     
  1111.     voice->vc_SquareUpperLimit = SquareUpper;
  1112.     voice->vc_SquareLowerLimit = SquareLower;
  1113.     
  1114.     voice->vc_IgnoreFilter    = voice->vc_FilterWait = voice->vc_FilterOn = 0;
  1115.     voice->vc_FilterSlidingIn = 0;
  1116.  
  1117.     d6 = Ins->ins_FilterSpeed;
  1118.     d3 = Ins->ins_FilterLowerLimit;
  1119.     d4 = Ins->ins_FilterUpperLimit;
  1120.     
  1121.     if( d3 & 0x80 ) d6 |= 0x20;
  1122.     if( d4 & 0x80 ) d6 |= 0x40;
  1123.     
  1124.     voice->vc_FilterSpeed = d6;
  1125.     d3 &= ~0x80;
  1126.     d4 &= ~0x80;
  1127.     
  1128.     if( d3 > d4 )
  1129.     {
  1130.       int16 t = d3;
  1131.       d3 = d4;
  1132.       d4 = t;
  1133.     }
  1134.     
  1135.     voice->vc_FilterUpperLimit = d4;
  1136.     voice->vc_FilterLowerLimit = d3;
  1137.     voice->vc_FilterPos        = 32;
  1138.     
  1139.     voice->vc_PerfWait  = voice->vc_PerfCurrent = 0;
  1140.     voice->vc_PerfSpeed = Ins->ins_PList.pls_Speed;
  1141.     voice->vc_PerfList  = &voice->vc_Instrument->ins_PList;
  1142.     
  1143.     voice->vc_RingMixSource   = NULL;   // No ring modulation
  1144.     voice->vc_RingSamplePos   = 0;
  1145.     voice->vc_RingPlantPeriod = 0;
  1146.     voice->vc_RingNewWaveform = 0;
  1147.   }
  1148.   
  1149.   voice->vc_PeriodSlideOn = 0;
  1150.   
  1151.   hvl_process_stepfx_2( ht, voice, Step->stp_FX&0xf,  Step->stp_FXParam,  &Note );  
  1152.   hvl_process_stepfx_2( ht, voice, Step->stp_FXb&0xf, Step->stp_FXbParam, &Note );
  1153.  
  1154.   if( Note )
  1155.   {
  1156.     voice->vc_TrackPeriod = Note;
  1157.     voice->vc_PlantPeriod = 1;
  1158.   }
  1159.   
  1160.   hvl_process_stepfx_3( ht, voice, Step->stp_FX&0xf,  Step->stp_FXParam );  
  1161.   hvl_process_stepfx_3( ht, voice, Step->stp_FXb&0xf, Step->stp_FXbParam );  
  1162. }
  1163.  
  1164. void hvl_plist_command_parse( struct hvl_tune *ht, struct hvl_voice *voice, int32 FX, int32 FXParam )
  1165. {
  1166.   switch( FX )
  1167.   {
  1168.     case 0:
  1169.       if( FXParam != 0 )
  1170.       {
  1171.         if( voice->vc_IgnoreFilter )
  1172.         {
  1173.           voice->vc_FilterPos    = voice->vc_IgnoreFilter;
  1174.           voice->vc_IgnoreFilter = 0;
  1175.         } else {
  1176.           voice->vc_FilterPos    = FXParam;
  1177.         }
  1178.         voice->vc_NewWaveform = 1;
  1179.       }
  1180.       break;
  1181.  
  1182.     case 1:
  1183.       voice->vc_PeriodPerfSlideSpeed = FXParam;
  1184.       voice->vc_PeriodPerfSlideOn    = 1;
  1185.       break;
  1186.  
  1187.     case 2:
  1188.       voice->vc_PeriodPerfSlideSpeed = -FXParam;
  1189.       voice->vc_PeriodPerfSlideOn    = 1;
  1190.       break;
  1191.     
  1192.     case 3:
  1193.       if( voice->vc_IgnoreSquare == 0 )
  1194.         voice->vc_SquarePos = FXParam >> (5-voice->vc_WaveLength);
  1195.       else
  1196.         voice->vc_IgnoreSquare = 0;
  1197.       break;
  1198.     
  1199.     case 4:
  1200.       if( FXParam == 0 )
  1201.       {
  1202.         voice->vc_SquareInit = (voice->vc_SquareOn ^= 1);
  1203.         voice->vc_SquareSign = 1;
  1204.       } else {
  1205.  
  1206.         if( FXParam & 0x0f )
  1207.         {
  1208.           voice->vc_SquareInit = (voice->vc_SquareOn ^= 1);
  1209.           voice->vc_SquareSign = 1;
  1210.           if(( FXParam & 0x0f ) == 0x0f )
  1211.             voice->vc_SquareSign = -1;
  1212.         }
  1213.         
  1214.         if( FXParam & 0xf0 )
  1215.         {
  1216.           voice->vc_FilterInit = (voice->vc_FilterOn ^= 1);
  1217.           voice->vc_FilterSign = 1;
  1218.           if(( FXParam & 0xf0 ) == 0xf0 )
  1219.             voice->vc_FilterSign = -1;
  1220.         }
  1221.       }
  1222.       break;
  1223.     
  1224.     case 5:
  1225.       voice->vc_PerfCurrent = FXParam;
  1226.       break;
  1227.     
  1228.     case 7:
  1229.       // Ring modulate with triangle
  1230.       if(( FXParam >= 1 ) && ( FXParam <= 0x3C ))
  1231.       {
  1232.         voice->vc_RingBasePeriod = FXParam;
  1233.         voice->vc_RingFixedPeriod = 1;
  1234.       } else if(( FXParam >= 0x81 ) && ( FXParam <= 0xBC )) {
  1235.         voice->vc_RingBasePeriod = FXParam-0x80;
  1236.         voice->vc_RingFixedPeriod = 0;
  1237.       } else {
  1238.         voice->vc_RingBasePeriod = 0;
  1239.         voice->vc_RingFixedPeriod = 0;
  1240.         voice->vc_RingNewWaveform = 0;
  1241.         voice->vc_RingAudioSource = NULL; // turn it off
  1242.         voice->vc_RingMixSource   = NULL;
  1243.         break;
  1244.       }    
  1245.       voice->vc_RingWaveform    = 0;
  1246.       voice->vc_RingNewWaveform = 1;
  1247.       voice->vc_RingPlantPeriod = 1;
  1248.       break;
  1249.     
  1250.     case 8:  // Ring modulate with sawtooth
  1251.       if(( FXParam >= 1 ) && ( FXParam <= 0x3C ))
  1252.       {
  1253.         voice->vc_RingBasePeriod = FXParam;
  1254.         voice->vc_RingFixedPeriod = 1;
  1255.       } else if(( FXParam >= 0x81 ) && ( FXParam <= 0xBC )) {
  1256.         voice->vc_RingBasePeriod = FXParam-0x80;
  1257.         voice->vc_RingFixedPeriod = 0;
  1258.       } else {
  1259.         voice->vc_RingBasePeriod = 0;
  1260.         voice->vc_RingFixedPeriod = 0;
  1261.         voice->vc_RingNewWaveform = 0;
  1262.         voice->vc_RingAudioSource = NULL;
  1263.         voice->vc_RingMixSource   = NULL;
  1264.         break;
  1265.       }
  1266.  
  1267.       voice->vc_RingWaveform    = 1;
  1268.       voice->vc_RingNewWaveform = 1;
  1269.       voice->vc_RingPlantPeriod = 1;
  1270.       break;
  1271.     
  1272.     case 12:
  1273.       if( FXParam <= 0x40 )
  1274.       {
  1275.         voice->vc_NoteMaxVolume = FXParam;
  1276.         break;
  1277.       }
  1278.       
  1279.       if( (FXParam -= 0x50) < 0 ) break;
  1280.  
  1281.       if( FXParam <= 0x40 )
  1282.       {
  1283.         voice->vc_PerfSubVolume = FXParam;
  1284.         break;
  1285.       }
  1286.       
  1287.       if( (FXParam -= 0xa0-0x50) < 0 ) break;
  1288.       
  1289.       if( FXParam <= 0x40 )
  1290.         voice->vc_TrackMasterVolume = FXParam;
  1291.       break;
  1292.     
  1293.     case 15:
  1294.       voice->vc_PerfSpeed = voice->vc_PerfWait = FXParam;
  1295.       break;
  1296.   } 
  1297. }
  1298.  
  1299. void hvl_process_frame( struct hvl_tune *ht, struct hvl_voice *voice )
  1300. {
  1301.   static CONST uint8 Offsets[] = {0x00,0x04,0x04+0x08,0x04+0x08+0x10,0x04+0x08+0x10+0x20,0x04+0x08+0x10+0x20+0x40};
  1302.  
  1303.   if( voice->vc_TrackOn == 0 )
  1304.     return;
  1305.  
  1306.   if( voice->vc_NoteDelayOn )
  1307.   {
  1308.     if( voice->vc_NoteDelayWait <= 0 )
  1309.       hvl_process_step( ht, voice );
  1310.     else
  1311.       voice->vc_NoteDelayWait--;
  1312.   }
  1313.   
  1314.   if( voice->vc_HardCut )
  1315.   {
  1316.     int32 nextinst;
  1317.     
  1318.     if( ht->ht_NoteNr+1 < ht->ht_TrackLength )
  1319.       nextinst = ht->ht_Tracks[voice->vc_Track][ht->ht_NoteNr+1].stp_Instrument;
  1320.     else
  1321.       nextinst = ht->ht_Tracks[voice->vc_NextTrack][0].stp_Instrument;
  1322.     
  1323.     if( nextinst )
  1324.     {
  1325.       int32 d1;
  1326.       
  1327.       d1 = ht->ht_Tempo - voice->vc_HardCut;
  1328.       
  1329.       if( d1 < 0 ) d1 = 0;
  1330.     
  1331.       if( !voice->vc_NoteCutOn )
  1332.       {
  1333.         voice->vc_NoteCutOn       = 1;
  1334.         voice->vc_NoteCutWait     = d1;
  1335.         voice->vc_HardCutReleaseF = -(d1-ht->ht_Tempo);
  1336.       } else {
  1337.         voice->vc_HardCut = 0;
  1338.       }
  1339.     }
  1340.   }
  1341.     
  1342.   if( voice->vc_NoteCutOn )
  1343.   {
  1344.     if( voice->vc_NoteCutWait <= 0 )
  1345.     {
  1346.       voice->vc_NoteCutOn = 0;
  1347.         
  1348.       if( voice->vc_HardCutRelease )
  1349.       {
  1350.         voice->vc_ADSR.rVolume = -(voice->vc_ADSRVolume - (voice->vc_Instrument->ins_Envelope.rVolume << 8)) / voice->vc_HardCutReleaseF;
  1351.         voice->vc_ADSR.rFrames = voice->vc_HardCutReleaseF;
  1352.         voice->vc_ADSR.aFrames = voice->vc_ADSR.dFrames = voice->vc_ADSR.sFrames = 0;
  1353.       } else {
  1354.         voice->vc_NoteMaxVolume = 0;
  1355.       }
  1356.     } else {
  1357.       voice->vc_NoteCutWait--;
  1358.     }
  1359.   }
  1360.     
  1361.   // ADSR envelope
  1362.   if( voice->vc_ADSR.aFrames )
  1363.   {
  1364.     voice->vc_ADSRVolume += voice->vc_ADSR.aVolume;
  1365.       
  1366.     if( --voice->vc_ADSR.aFrames <= 0 )
  1367.       voice->vc_ADSRVolume = voice->vc_Instrument->ins_Envelope.aVolume << 8;
  1368.  
  1369.   } else if( voice->vc_ADSR.dFrames ) {
  1370.     
  1371.     voice->vc_ADSRVolume += voice->vc_ADSR.dVolume;
  1372.       
  1373.     if( --voice->vc_ADSR.dFrames <= 0 )
  1374.       voice->vc_ADSRVolume = voice->vc_Instrument->ins_Envelope.dVolume << 8;
  1375.     
  1376.   } else if( voice->vc_ADSR.sFrames ) {
  1377.     
  1378.     voice->vc_ADSR.sFrames--;
  1379.     
  1380.   } else if( voice->vc_ADSR.rFrames ) {
  1381.     
  1382.     voice->vc_ADSRVolume += voice->vc_ADSR.rVolume;
  1383.     
  1384.     if( --voice->vc_ADSR.rFrames <= 0 )
  1385.       voice->vc_ADSRVolume = voice->vc_Instrument->ins_Envelope.rVolume << 8;
  1386.   }
  1387.  
  1388.   // VolumeSlide
  1389.   voice->vc_NoteMaxVolume = voice->vc_NoteMaxVolume + voice->vc_VolumeSlideUp - voice->vc_VolumeSlideDown;
  1390.  
  1391.   if( voice->vc_NoteMaxVolume < 0 )
  1392.     voice->vc_NoteMaxVolume = 0;
  1393.   else if( voice->vc_NoteMaxVolume > 0x40 )
  1394.     voice->vc_NoteMaxVolume = 0x40;
  1395.  
  1396.   // Portamento
  1397.   if( voice->vc_PeriodSlideOn )
  1398.   {
  1399.     if( voice->vc_PeriodSlideWithLimit )
  1400.     {
  1401.       int32  d0, d2;
  1402.       
  1403.       d0 = voice->vc_PeriodSlidePeriod - voice->vc_PeriodSlideLimit;
  1404.       d2 = voice->vc_PeriodSlideSpeed;
  1405.       
  1406.       if( d0 > 0 )
  1407.         d2 = -d2;
  1408.       
  1409.       if( d0 )
  1410.       {
  1411.         int32 d3;
  1412.          
  1413.         d3 = (d0 + d2) ^ d0;
  1414.         
  1415.         if( d3 >= 0 )
  1416.           d0 = voice->vc_PeriodSlidePeriod + d2;
  1417.         else
  1418.           d0 = voice->vc_PeriodSlideLimit;
  1419.         
  1420.         voice->vc_PeriodSlidePeriod = d0;
  1421.         voice->vc_PlantPeriod = 1;
  1422.       }
  1423.     } else {
  1424.       voice->vc_PeriodSlidePeriod += voice->vc_PeriodSlideSpeed;
  1425.       voice->vc_PlantPeriod = 1;
  1426.     }
  1427.   }
  1428.   
  1429.   // Vibrato
  1430.   if( voice->vc_VibratoDepth )
  1431.   {
  1432.     if( voice->vc_VibratoDelay <= 0 )
  1433.     {
  1434.       voice->vc_VibratoPeriod = (vib_tab[voice->vc_VibratoCurrent] * voice->vc_VibratoDepth) >> 7;
  1435.       voice->vc_PlantPeriod = 1;
  1436.       voice->vc_VibratoCurrent = (voice->vc_VibratoCurrent + voice->vc_VibratoSpeed) & 0x3f;
  1437.     } else {
  1438.       voice->vc_VibratoDelay--;
  1439.     }
  1440.   }
  1441.   
  1442.   // PList
  1443.   if( voice->vc_PerfList != 0 )
  1444.   {
  1445.     if( voice->vc_Instrument && voice->vc_PerfCurrent < voice->vc_Instrument->ins_PList.pls_Length )
  1446.     {
  1447.       if( --voice->vc_PerfWait <= 0 )
  1448.       {
  1449.         uint32 i;
  1450.         int32 cur;
  1451.         
  1452.         cur = voice->vc_PerfCurrent++;
  1453.         voice->vc_PerfWait = voice->vc_PerfSpeed;
  1454.         
  1455.         if( voice->vc_PerfList->pls_Entries[cur].ple_Waveform )
  1456.         {
  1457.           voice->vc_Waveform             = voice->vc_PerfList->pls_Entries[cur].ple_Waveform-1;
  1458.           voice->vc_NewWaveform          = 1;
  1459.           voice->vc_PeriodPerfSlideSpeed = voice->vc_PeriodPerfSlidePeriod = 0;
  1460.         }
  1461.         
  1462.         // Holdwave
  1463.         voice->vc_PeriodPerfSlideOn = 0;
  1464.         
  1465.         for( i=0; i<2; i++ )
  1466.           hvl_plist_command_parse( ht, voice, voice->vc_PerfList->pls_Entries[cur].ple_FX[i]&0xff, voice->vc_PerfList->pls_Entries[cur].ple_FXParam[i]&0xff );
  1467.         
  1468.         // GetNote
  1469.         if( voice->vc_PerfList->pls_Entries[cur].ple_Note )
  1470.         {
  1471.           voice->vc_InstrPeriod = voice->vc_PerfList->pls_Entries[cur].ple_Note;
  1472.           voice->vc_PlantPeriod = 1;
  1473.           voice->vc_FixedNote   = voice->vc_PerfList->pls_Entries[cur].ple_Fixed;
  1474.         }
  1475.       }
  1476.     } else {
  1477.       if( voice->vc_PerfWait )
  1478.         voice->vc_PerfWait--;
  1479.       else
  1480.         voice->vc_PeriodPerfSlideSpeed = 0;
  1481.     }
  1482.   }
  1483.   
  1484.   // PerfPortamento
  1485.   if( voice->vc_PeriodPerfSlideOn )
  1486.   {
  1487.     voice->vc_PeriodPerfSlidePeriod -= voice->vc_PeriodPerfSlideSpeed;
  1488.     
  1489.     if( voice->vc_PeriodPerfSlidePeriod )
  1490.       voice->vc_PlantPeriod = 1;
  1491.   }
  1492.   
  1493.   if( voice->vc_Waveform == 3-1 && voice->vc_SquareOn )
  1494.   {
  1495.     if( --voice->vc_SquareWait <= 0 )
  1496.     {
  1497.       int32 d1, d2, d3;
  1498.       
  1499.       d1 = voice->vc_SquareLowerLimit;
  1500.       d2 = voice->vc_SquareUpperLimit;
  1501.       d3 = voice->vc_SquarePos;
  1502.       
  1503.       if( voice->vc_SquareInit )
  1504.       {
  1505.         voice->vc_SquareInit = 0;
  1506.         
  1507.         if( d3 <= d1 )
  1508.         {
  1509.           voice->vc_SquareSlidingIn = 1;
  1510.           voice->vc_SquareSign = 1;
  1511.         } else if( d3 >= d2 ) {
  1512.           voice->vc_SquareSlidingIn = 1;
  1513.           voice->vc_SquareSign = -1;
  1514.         }
  1515.       }
  1516.       
  1517.       // NoSquareInit
  1518.       if( d1 == d3 || d2 == d3 )
  1519.       {
  1520.         if( voice->vc_SquareSlidingIn )
  1521.           voice->vc_SquareSlidingIn = 0;
  1522.         else
  1523.           voice->vc_SquareSign = -voice->vc_SquareSign;
  1524.       }
  1525.       
  1526.       d3 += voice->vc_SquareSign;
  1527.       voice->vc_SquarePos   = d3;
  1528.       voice->vc_PlantSquare = 1;
  1529.       voice->vc_SquareWait  = voice->vc_Instrument->ins_SquareSpeed;
  1530.     }
  1531.   }
  1532.   
  1533.   if( voice->vc_FilterOn && --voice->vc_FilterWait <= 0 )
  1534.   {
  1535.     uint32 i, FMax;
  1536.     int32 d1, d2, d3;
  1537.     
  1538.     d1 = voice->vc_FilterLowerLimit;
  1539.     d2 = voice->vc_FilterUpperLimit;
  1540.     d3 = voice->vc_FilterPos;
  1541.     
  1542.     if( voice->vc_FilterInit )
  1543.     {
  1544.       voice->vc_FilterInit = 0;
  1545.       if( d3 <= d1 )
  1546.       {
  1547.         voice->vc_FilterSlidingIn = 1;
  1548.         voice->vc_FilterSign      = 1;
  1549.       } else if( d3 >= d2 ) {
  1550.         voice->vc_FilterSlidingIn = 1;
  1551.         voice->vc_FilterSign      = -1;
  1552.       }
  1553.     }
  1554.     
  1555.     // NoFilterInit
  1556.     FMax = (voice->vc_FilterSpeed < 3) ? (5-voice->vc_FilterSpeed) : 1;
  1557.  
  1558.     for( i=0; i<FMax; i++ )
  1559.     {
  1560.       if( ( d1 == d3 ) || ( d2 == d3 ) )
  1561.       {
  1562.         if( voice->vc_FilterSlidingIn )
  1563.           voice->vc_FilterSlidingIn = 0;
  1564.         else
  1565.           voice->vc_FilterSign = -voice->vc_FilterSign;
  1566.       }
  1567.       d3 += voice->vc_FilterSign;
  1568.     }
  1569.     
  1570.     voice->vc_FilterPos   = d3;
  1571.     voice->vc_NewWaveform = 1;
  1572.     voice->vc_FilterWait  = voice->vc_FilterSpeed - 3;
  1573.     
  1574.     if( voice->vc_FilterWait < 1 )
  1575.       voice->vc_FilterWait = 1;
  1576.   }
  1577.  
  1578.   if( voice->vc_Waveform == 3-1 || voice->vc_PlantSquare )
  1579.   {
  1580.     // CalcSquare
  1581.     uint32  i;
  1582.     int32   Delta;
  1583.     int8   *SquarePtr;
  1584.     int32  X;
  1585.     
  1586.     SquarePtr = &waves[WO_SQUARES+(voice->vc_FilterPos-0x20)*(0xfc+0xfc+0x80*0x1f+0x80+0x280*3)];
  1587.     X = voice->vc_SquarePos << (5 - voice->vc_WaveLength);
  1588.     
  1589.     if( X > 0x20 )
  1590.     {
  1591.       X = 0x40 - X;
  1592.       voice->vc_SquareReverse = 1;
  1593.     }
  1594.     
  1595.     // OkDownSquare
  1596.     if( --X )
  1597.       SquarePtr += X << 7;
  1598.     
  1599.     Delta = 32 >> voice->vc_WaveLength;
  1600.     ht->ht_WaveformTab[2] = voice->vc_SquareTempBuffer;
  1601.     
  1602.     for( i=0; i<(1<<voice->vc_WaveLength)*4; i++ )
  1603.     {
  1604.       // THX.draft-hawk fucks this up, ATM
  1605.       if( SquarePtr >= &waves[WO_WHITENOISE] )
  1606.         SquarePtr = &waves[WO_SQUARES];
  1607.       if( SquarePtr < &waves[0] )
  1608.         SquarePtr = &waves[WO_WHITENOISE-1];
  1609.       if( i>=0x80 ) break;
  1610.       voice->vc_SquareTempBuffer[i] = *SquarePtr;
  1611.       SquarePtr += Delta;
  1612.     }
  1613.     
  1614.     voice->vc_NewWaveform = 1;
  1615.     voice->vc_Waveform    = 3-1;
  1616.     voice->vc_PlantSquare = 0;
  1617.   }
  1618.   
  1619.   if( voice->vc_Waveform == 4-1 )
  1620.     voice->vc_NewWaveform = 1;
  1621.   
  1622.   if( voice->vc_RingNewWaveform )
  1623.   {
  1624.     int8 *rasrc;
  1625.     
  1626.     if( voice->vc_RingWaveform > 1 ) voice->vc_RingWaveform = 1;
  1627.     
  1628.     rasrc = ht->ht_WaveformTab[voice->vc_RingWaveform];
  1629.     rasrc += Offsets[voice->vc_WaveLength];
  1630.     
  1631.     voice->vc_RingAudioSource = rasrc;
  1632.   }    
  1633.         
  1634.   
  1635.   if( voice->vc_NewWaveform )
  1636.   {
  1637.     int8 *AudioSource;
  1638.  
  1639.     AudioSource = ht->ht_WaveformTab[voice->vc_Waveform];
  1640.  
  1641.     if( voice->vc_Waveform != 3-1 )
  1642.       AudioSource += (voice->vc_FilterPos-0x20)*(0xfc+0xfc+0x80*0x1f+0x80+0x280*3);
  1643.  
  1644.     if( voice->vc_Waveform < 3-1)
  1645.     {
  1646.       // GetWLWaveformlor2
  1647.       AudioSource += Offsets[voice->vc_WaveLength];
  1648.     }
  1649.  
  1650.     if( voice->vc_Waveform == 4-1 )
  1651.     {
  1652.       // AddRandomMoving
  1653.       AudioSource += ( voice->vc_WNRandom & (2*0x280-1) ) & ~1;
  1654.       // GoOnRandom
  1655.       voice->vc_WNRandom += 2239384;
  1656.       voice->vc_WNRandom  = ((((voice->vc_WNRandom >> 8) | (voice->vc_WNRandom << 24)) + 782323) ^ 75) - 6735;
  1657.     }
  1658.  
  1659.     voice->vc_AudioSource = AudioSource;
  1660.   }
  1661.   
  1662.   // Ring modulation period calculation
  1663.   if( voice->vc_RingAudioSource )
  1664.   {
  1665.     voice->vc_RingAudioPeriod = voice->vc_RingBasePeriod;
  1666.   
  1667.     if( !(voice->vc_RingFixedPeriod) )
  1668.       voice->vc_RingAudioPeriod += voice->vc_Transpose + voice->vc_TrackPeriod - 1;
  1669.   
  1670.     if( voice->vc_RingAudioPeriod > 5*12 )
  1671.       voice->vc_RingAudioPeriod = 5*12;
  1672.   
  1673.     if( voice->vc_RingAudioPeriod < 0 )
  1674.       voice->vc_RingAudioPeriod = 0;
  1675.   
  1676.     voice->vc_RingAudioPeriod = period_tab[voice->vc_RingAudioPeriod];
  1677.  
  1678.     if( !(voice->vc_RingFixedPeriod) )
  1679.       voice->vc_RingAudioPeriod += voice->vc_PeriodSlidePeriod;
  1680.  
  1681.     voice->vc_RingAudioPeriod += voice->vc_PeriodPerfSlidePeriod + voice->vc_VibratoPeriod;
  1682.  
  1683.     if( voice->vc_RingAudioPeriod > 0x0d60 )
  1684.       voice->vc_RingAudioPeriod = 0x0d60;
  1685.  
  1686.     if( voice->vc_RingAudioPeriod < 0x0071 )
  1687.       voice->vc_RingAudioPeriod = 0x0071;
  1688.   }
  1689.   
  1690.   // Normal period calculation
  1691.   voice->vc_AudioPeriod = voice->vc_InstrPeriod;
  1692.   
  1693.   if( !(voice->vc_FixedNote) )
  1694.     voice->vc_AudioPeriod += voice->vc_Transpose + voice->vc_TrackPeriod - 1;
  1695.     
  1696.   if( voice->vc_AudioPeriod > 5*12 )
  1697.     voice->vc_AudioPeriod = 5*12;
  1698.   
  1699.   if( voice->vc_AudioPeriod < 0 )
  1700.     voice->vc_AudioPeriod = 0;
  1701.   
  1702.   voice->vc_AudioPeriod = period_tab[voice->vc_AudioPeriod];
  1703.   
  1704.   if( !(voice->vc_FixedNote) )
  1705.     voice->vc_AudioPeriod += voice->vc_PeriodSlidePeriod;
  1706.  
  1707.   voice->vc_AudioPeriod += voice->vc_PeriodPerfSlidePeriod + voice->vc_VibratoPeriod;    
  1708.  
  1709.   if( voice->vc_AudioPeriod > 0x0d60 )
  1710.     voice->vc_AudioPeriod = 0x0d60;
  1711.  
  1712.   if( voice->vc_AudioPeriod < 0x0071 )
  1713.     voice->vc_AudioPeriod = 0x0071;
  1714.   
  1715.   voice->vc_AudioVolume = (((((((voice->vc_ADSRVolume >> 8) * voice->vc_NoteMaxVolume) >> 6) * voice->vc_PerfSubVolume) >> 6) * voice->vc_TrackMasterVolume) >> 6);
  1716. }
  1717.  
  1718. void hvl_set_audio( struct hvl_voice *voice, float64 freqf )
  1719. {
  1720.  
  1721.   if( voice->vc_TrackOn == 0 )
  1722.   {
  1723.     voice->vc_VoiceVolume = 0;
  1724.     return;
  1725.   }
  1726.   
  1727.   voice->vc_VoiceVolume = voice->vc_AudioVolume;
  1728.   
  1729.   if( voice->vc_PlantPeriod )
  1730.   {
  1731.     float64 freq2;
  1732.     uint32  delta;
  1733.     
  1734.     voice->vc_PlantPeriod = 0;
  1735.     voice->vc_VoicePeriod = voice->vc_AudioPeriod;
  1736.     
  1737.     freq2 = Period2Freq( voice->vc_AudioPeriod );
  1738.     delta = (uint32)(freq2 / freqf);
  1739.  
  1740.     if( delta > (0x280<<16) ) delta -= (0x280<<16);
  1741.     if( delta == 0 ) delta = 1;
  1742.     voice->vc_Delta = delta;
  1743.   }
  1744.   
  1745.   if( voice->vc_NewWaveform )
  1746.   {
  1747.     int8 *src;
  1748.     
  1749.     src = voice->vc_AudioSource;
  1750.     
  1751.     if( voice->vc_Waveform == 4-1 )
  1752.     {
  1753.       CopyMem((void *)src, &voice->vc_VoiceBuffer[0], 0x280);
  1754.     } else {
  1755.       uint32 i, WaveLoops;
  1756.  
  1757.       WaveLoops = (1 << (5 - voice->vc_WaveLength)) * 5;
  1758.  
  1759.       for( i=0; i<WaveLoops; i++ )
  1760.         CopyMem((void *)src, &voice->vc_VoiceBuffer[i*4*(1<<voice->vc_WaveLength)], 4*(1<<voice->vc_WaveLength));
  1761.     }
  1762.  
  1763.     voice->vc_VoiceBuffer[0x280] = voice->vc_VoiceBuffer[0];
  1764.     voice->vc_MixSource          = voice->vc_VoiceBuffer;
  1765.   }
  1766.  
  1767.   /* Ring Modulation */
  1768.   if( voice->vc_RingPlantPeriod )
  1769.   {
  1770.     float64 freq2;
  1771.     uint32  delta;
  1772.     
  1773.     voice->vc_RingPlantPeriod = 0;
  1774.     freq2 = Period2Freq( voice->vc_RingAudioPeriod );
  1775.     delta = (uint32)(freq2 / freqf);
  1776.  
  1777.     if( delta > (0x280<<16) ) delta -= (0x280<<16);
  1778.     if( delta == 0 ) delta = 1;
  1779.     voice->vc_RingDelta = delta;
  1780.   }
  1781.   
  1782.   if( voice->vc_RingNewWaveform )
  1783.   {
  1784.     int8 *src;
  1785.     uint32 i, WaveLoops;
  1786.     
  1787.     src = voice->vc_RingAudioSource;
  1788.  
  1789.     WaveLoops = (1 << (5 - voice->vc_WaveLength)) * 5;
  1790.  
  1791.     for( i=0; i<WaveLoops; i++ )
  1792.       CopyMem((void *)src, &voice->vc_RingVoiceBuffer[i*4*(1<<voice->vc_WaveLength)], 4*(1<<voice->vc_WaveLength));
  1793.  
  1794.     voice->vc_RingVoiceBuffer[0x280] = voice->vc_RingVoiceBuffer[0];
  1795.     voice->vc_RingMixSource          = voice->vc_RingVoiceBuffer;
  1796.   }
  1797. }
  1798.  
  1799. void hvl_play_irq( struct hvl_tune *ht )
  1800. {
  1801.   uint32 i;
  1802.  
  1803.   if( ht->ht_StepWaitFrames <= 0 )
  1804.   {
  1805.     if( ht->ht_GetNewPosition )
  1806.     {
  1807.       int32 nextpos = (ht->ht_PosNr+1==ht->ht_PositionNr)?0:(ht->ht_PosNr+1);
  1808.  
  1809.       for( i=0; i<ht->ht_Channels; i++ )
  1810.       {
  1811.         ht->ht_Voices[i].vc_Track         = ht->ht_Positions[ht->ht_PosNr].pos_Track[i];
  1812.         ht->ht_Voices[i].vc_Transpose     = ht->ht_Positions[ht->ht_PosNr].pos_Transpose[i];
  1813.         ht->ht_Voices[i].vc_NextTrack     = ht->ht_Positions[nextpos].pos_Track[i];
  1814.         ht->ht_Voices[i].vc_NextTranspose = ht->ht_Positions[nextpos].pos_Transpose[i];
  1815.       }
  1816.       ht->ht_GetNewPosition = 0;
  1817.     }
  1818.     
  1819.     for( i=0; i<ht->ht_Channels; i++ )
  1820.       hvl_process_step( ht, &ht->ht_Voices[i] );
  1821.     
  1822.     ht->ht_StepWaitFrames = ht->ht_Tempo;
  1823.   }
  1824.   
  1825.   for( i=0; i<ht->ht_Channels; i++ )
  1826.     hvl_process_frame( ht, &ht->ht_Voices[i] );
  1827.  
  1828.   ht->ht_PlayingTime++;
  1829.   if( ht->ht_Tempo > 0 && --ht->ht_StepWaitFrames <= 0 )
  1830.   {
  1831.     if( !ht->ht_PatternBreak )
  1832.     {
  1833.       ht->ht_NoteNr++;
  1834.       if( ht->ht_NoteNr >= ht->ht_TrackLength )
  1835.       {
  1836.         ht->ht_PosJump      = ht->ht_PosNr+1;
  1837.         ht->ht_PosJumpNote  = 0;
  1838.         ht->ht_PatternBreak = 1;
  1839.       }
  1840.     }
  1841.     
  1842.     if( ht->ht_PatternBreak )
  1843.     {
  1844.       ht->ht_PatternBreak = 0;
  1845.       ht->ht_PosNr        = ht->ht_PosJump;
  1846.       ht->ht_NoteNr       = ht->ht_PosJumpNote;
  1847.       if( ht->ht_PosNr == ht->ht_PositionNr )
  1848.       {
  1849.         ht->ht_SongEndReached = 1;
  1850.         ht->ht_PosNr          = ht->ht_Restart;
  1851.       }
  1852.       ht->ht_PosJumpNote  = 0;
  1853.       ht->ht_PosJump      = 0;
  1854.  
  1855.       ht->ht_GetNewPosition = 1;
  1856.     }
  1857.   }
  1858.  
  1859.   for( i=0; i<ht->ht_Channels; i++ )
  1860.     hvl_set_audio( &ht->ht_Voices[i], ht->ht_Frequency );
  1861. }
  1862.  
  1863. void hvl_mixchunk( struct hvl_tune *ht, uint32 samples, int8 *buf1, int8 *buf2, int32 bufmod )
  1864. {
  1865.   int8   *src[MAX_CHANNELS];
  1866.   int8   *rsrc[MAX_CHANNELS];
  1867.   uint32  delta[MAX_CHANNELS];
  1868.   uint32  rdelta[MAX_CHANNELS];
  1869.   int32   vol[MAX_CHANNELS];
  1870.   uint32  pos[MAX_CHANNELS];
  1871.   uint32  rpos[MAX_CHANNELS];
  1872.   uint32  cnt;
  1873.   int32   panl[MAX_CHANNELS];
  1874.   int32   panr[MAX_CHANNELS];
  1875. //  uint32  vu[MAX_CHANNELS];
  1876.   int32   a=0, b=0, j;
  1877.   uint32  i, chans, loops;
  1878.   
  1879.   chans = ht->ht_Channels;
  1880.   for( i=0; i<chans; i++ )
  1881.   {
  1882.     delta[i] = ht->ht_Voices[i].vc_Delta;
  1883.     vol[i]   = ht->ht_Voices[i].vc_VoiceVolume;
  1884.     pos[i]   = ht->ht_Voices[i].vc_SamplePos;
  1885.     src[i]   = ht->ht_Voices[i].vc_MixSource;
  1886.     panl[i]  = ht->ht_Voices[i].vc_PanMultLeft;
  1887.     panr[i]  = ht->ht_Voices[i].vc_PanMultRight;
  1888.     
  1889.     /* Ring Modulation */
  1890.     rdelta[i]= ht->ht_Voices[i].vc_RingDelta;
  1891.     rpos[i]  = ht->ht_Voices[i].vc_RingSamplePos;
  1892.     rsrc[i]  = ht->ht_Voices[i].vc_RingMixSource;
  1893.     
  1894. //    vu[i] = 0;
  1895.   }
  1896.   
  1897.   do
  1898.   {
  1899.     loops = samples;
  1900.     for( i=0; i<chans; i++ )
  1901.     {
  1902.       if( pos[i] >= (0x280 << 16)) pos[i] -= 0x280<<16;
  1903.       if (delta[i]!=0) {
  1904.         cnt = ((0x280<<16) - pos[i] - 1) / delta[i] + 1;
  1905.         if( cnt < loops ) loops = cnt;
  1906.       
  1907.         if( rsrc[i] )
  1908.         {
  1909.           if( rpos[i] >= (0x280<<16)) rpos[i] -= 0x280<<16;
  1910.           cnt = ((0x280<<16) - rpos[i] - 1) / rdelta[i] + 1;
  1911.           if( cnt < loops ) loops = cnt;
  1912.         }
  1913.       }
  1914.     }
  1915.     
  1916.     samples -= loops;
  1917.     
  1918.     // Inner loop
  1919.     do
  1920.     {
  1921.       a=0;
  1922.       b=0;
  1923.       for( i=0; i<chans; i++ )
  1924.       {
  1925.         if( rsrc[i] )
  1926.         {
  1927.           /* Ring Modulation */
  1928.           j = ((src[i][pos[i]>>16]*rsrc[i][rpos[i]>>16])>>7)*vol[i];
  1929.           rpos[i] += rdelta[i];
  1930.         } else {
  1931.           j = src[i][pos[i]>>16]*vol[i];
  1932.         }
  1933.         
  1934. //        if( abs( j ) > vu[i] ) vu[i] = abs( j );
  1935.  
  1936.         a += (j * panl[i]) >> 7;
  1937.         b += (j * panr[i]) >> 7;
  1938.         pos[i] += delta[i];
  1939.       }
  1940.       
  1941.       a = (a*ht->ht_mixgain)>>8;
  1942.       b = (b*ht->ht_mixgain)>>8;
  1943.       
  1944.       *(int16 *)buf1 = a;
  1945.       *(int16 *)buf2 = b;
  1946.       
  1947.       loops--;
  1948.       
  1949.       buf1 += bufmod;
  1950.       buf2 += bufmod;
  1951.     } while( loops > 0 );
  1952.   } while( samples > 0 );
  1953.  
  1954.   for( i=0; i<chans; i++ )
  1955.   {
  1956.     ht->ht_Voices[i].vc_SamplePos = pos[i];
  1957.     ht->ht_Voices[i].vc_RingSamplePos = rpos[i];
  1958. //    ht->ht_Voices[i].vc_VUMeter = vu[i];
  1959.   }
  1960. }
  1961.  
  1962. void hvl_DecodeFrame( struct hvl_tune *ht, int8 *buf1, int8 *buf2, int32 bufmod )
  1963. {
  1964.   uint32 samples, loops;
  1965.   
  1966.   samples = ht->ht_Frequency/50/ht->ht_SpeedMultiplier;
  1967.   loops   = ht->ht_SpeedMultiplier*4;
  1968.   
  1969.   do
  1970.   {
  1971.     hvl_play_irq( ht );
  1972.     hvl_mixchunk( ht, samples, buf1, buf2, bufmod );
  1973.     buf1 += samples * 4;
  1974.     buf2 += samples * 4;
  1975.     loops--;
  1976.   } while( loops );
  1977. }
  1978.