typedef struct _MOD
{
   const SAMPLE_HEADER **sample;  // Pointer to table of samples in ROM
   const u8 **pattern;            // Pointer to table of pointers to patterns
   const u8 *order;               // Array of pattern numbers to play

   const u8 *rowPtr;              // Current position in current pattern, for quick access

   u8 state;                      // MOD_STATE enum, defined below (stopped/playing/paused)

   u8 speed;
   u8 tick;                       // When this gets to speed, process a new row and reset it to 0

   u8 curRow;                     // When this gets to 64, move to the next order and reset to 0

   u8 orderCount;
   u8 curOrder;                   // When this gets to orderCount, stop the song

   u8 pad[2];

   MOD_CHANNEL channel[4];        // MOD_CHANNEL struct, defined below

} MOD;

typedef enum _MOD_STATE
{
   MOD_STATE_STOP,
   MOD_STATE_PLAY,
   MOD_STATE_PAUSE,

} MOD_STATE;

typedef struct _MOD_CHANNEL
{
   u32 frequency;   // Current frequency of note being played, in Hz

   u8 sample;       // Last sample used on this channel
   u8 vol;          // Current volume

   u8 pad[2];       // Align to 4 bytes

} MOD_CHANNEL;

void MODUpdate()
{
   if(++mod.tick >= mod.speed)
   {
      mod.tick = 0;

      if(++mod.curRow >= 64)
      {
         mod.curRow = 0;

         if(++mod.curOrder >= mod.orderCount)
         {
            mod.state = MOD_STATE_STOP;
            return;
         }
         else
         {
            mod.rowPtr = mod.pattern[mod.order[mod.curOrder]]];
         }
      }

      MODProcessRow();
   }
   else
   {
      // We'll update the non row-tick effects here later
   }
}

   // Constants used
#define MOD_NO_SAMPLE 31   // MOD uses 0 as no-sample, but our converter subtracts 1 from the 
                           // numbers so we don't have to compensate for the unused sample 0
#define MOD_NO_NOTE   63   // From the example converter (valid notes are 0-59, so anything 
                           // above that would work)

void MODProcessRow()
{
   s32 curChannel;

   for(curChannel = 0; curChannel < mod.channelCount; curChannel++)
   {
      u8 note, sample, effect, param;

         // Read in the pattern data, advancing rowPtr to the next channel in the process
      note   = *mod.rowPtr++;
      sample = *mod.rowPtr++;
      effect = *mod.rowPtr++;
      param  = *mod.rowPtr++;

         // Use sample memory if no sample, or set sample memory if there is one
      if(sample == MOD_NO_SAMPLE)
      {
         sample = mod.channel[curChannel].sample;
      }
      else
      {
            // Set sample memory
         mod.channel[curChannel].sample = sample;
            // Another tricky thing to know about MOD: Volume is only set when 
            // specifying new samples, NOT when playing notes, and it is set even 
            // when there is a sample, but no note specified (although the sample 
            // playing doesn't change in that case)
         mod.channel[curChannel].vol = mod.sample[sample].vol;
         sndChannel[curChannel].vol = mod.channel[curChannel].vol;
      }

         // See if there's any note to play
      if(note != MOD_NO_NOTE)
      {
         MODPlayNote(curChannel, note, sample, effect, param);
      }
   }
}

void MODPlayNote(u32 channelIdx, u32 note, u32 sampleIdx, u32 effect, u32 param)
{
   SOUND_CHANNEL *sndChn;
   MOD_CHANNEL *modChn;
   SAMPLE_HEADER *sample;
   u8 finetune;

      // Here's that special case that they didn't specify a sample before playing a note
   if(sampleIdx == MOD_NO_SAMPLE)
   {
      return;
   }

      // These make things less cumbersome
   sndChn = &sndChannel[channelIdx];
   modChn = &mod.channel[channelIdx];
   sample = &mod.sample[sampleIdx];

      // 60 notes total, and one full set of notes for each finetune level
   modChn->frequency = freqTable[sample->finetune*60 + note];

      // Set up the mixer channel
   sndChn->data       = sample->sndData;
   sndChn->pos        = 0;
   sndChn->inc        = modChn->frequency * sndVars.rcpMixFreq >> 16;      // Explained below
   // Next member is volume, but skip setting it because it doesn't change unless a 
   // new sample was specified, in which case it was already set back in MODProcessRow
   sndChn->end        = sample->sndData + (sample->loopLength != 0 ? 
                                           sample->loopStart + sample->loopLength : 
                                           sample->length);
   sndChn->loopLength = sample->loopLength;
}