--A BAM player, callable by other programs

------------------------------------------------------------------------

include fmsynth.e

------------------------------------------------------------------------

constant false=0
constant true=1
constant stdout=1

------------------------------------------------------------------------

--prepare the card to play
if FM_SUPPORT=true then
  reset_fm()
  set_fm_melodic_mode()
end if

tick_rate(120) --this improves the timer resolution, therefore improving
               --sound quality, but has the downside of causing Windows
               --to suspend the program when it is not in the foreground

------------------------------------------------------------------------

--globals
global sequence BAM_DATA      BAM_DATA={}
integer  bam_pointer          bam_pointer=0
sequence bam_labels           bam_labels={}
sequence bam_loopcount        bam_loopcount={}
integer  bam_chorusmarker     bam_chorusmarker=0
integer  bam_delay            bam_delay=0
atom     bam_delay_start_time bam_delay_start_time=0

------------------------------------------------------------------------

--reset the currently loaded song to its beginning.
global procedure reset_bam()
  bam_pointer=1
  bam_labels=repeat(0,16) --labels set to zero are invalid
  bam_labels[1]=1         --the first label defaults to the beginning
  bam_loopcount=repeat(0,16)
  bam_chorusmarker=0      --if unset, the choursmarker is invalid
end procedure

------------------------------------------------------------------------

global procedure set_bam_data(sequence newbam)

  if FM_SUPPORT=false then
    --if FM is unavailable, fail
    return
  end if

  BAM_DATA=newbam

  reset_bam()
  
end procedure

------------------------------------------------------------------------

global function load_bam_file(sequence filename)
  sequence bam

  bam=get_whole_file(filename)
  if length(bam)<4 or compare(bam[1..4],"CBMF") then
    --bam data is invalid, return false (pre-existing song is NOT reset)
    return false
  end if
  
  --bam data is good, load and init
  set_bam_data(bam[5..length(bam)])
  return true

end function

------------------------------------------------------------------------

global procedure advance_bam()

  integer bamcommand
  integer voice
  integer frequency
  integer labelnum
  integer jumpval

  if sequence(BAM_DATA) and bam_pointer>0 then
  --BAM_DATA must be longer than zero and bam_pointer must be greater than zero

    if bam_delay then
      if bam_delay_start_time+(bam_delay/20)>=time() then
        --if the delay is not over yet, return to the caller
        return
      else
        --when the delay finishes, clear it
        bam_delay=0  
      end if
    end if

    --break the loop if we reach the end of the data
    if bam_pointer>length(BAM_DATA) then
      --interpret an end-of-data as a reset
      reset_bam()
      return
    end if

    bamcommand=BAM_DATA[bam_pointer]

    if bamcommand=0 then --stop song
      --in this implementation, we interpret stopsong as a reset
      reset_bam()
      return
    elsif bamcommand>=16 and bamcommand<=31 then --start note
      voice=bamcommand-16
      bam_pointer+=1
      --make sure the data hasnt run out
      if bam_pointer<=length(BAM_DATA) then
        frequency=BAM_DATA[bam_pointer]
        --only 0 to 127 are legal frequency values, but we dont bother
        --to check because fm_voice_on can safely ignore bad values
        fm_voice_on(voice,frequency)
      end if
    elsif bamcommand>=32 and bamcommand<=47 then --stop note
      voice=bamcommand-32
      fm_voice_off(voice)
    elsif bamcommand>=48 and bamcommand<=63 then --define instrument
      voice=bamcommand-48
      --read 11 data bytes to get the instrument
      if bam_pointer+11<=length(BAM_DATA) then
        --only do it if there is sufficient data
        set_fm_instrument(voice,BAM_DATA[bam_pointer+1..bam_pointer+11])
        bam_pointer+=11
      else
        --if data is insufficient, set bam_pointer to zero. it will be
        --incremented to 1 at the end of the function, ready to play from
        --the start
        bam_pointer=0  
      end if
    elsif bamcommand>=80 and bamcommand<=95 then --set label
      labelnum=bamcommand-80 +1 --adjust by 1 for euphoria array indexing
      bam_labels[labelnum]=bam_pointer
    elsif bamcommand>=96 and bamcommand<=111 then --jump
      labelnum=bamcommand-96 +1 --adjust by 1 for euphoria array indexing
      --read one byte to get the jump type
      bam_pointer+=1
      --make sure the data hasnt run out
      if bam_pointer<=length(BAM_DATA) then
        jumpval=BAM_DATA[bam_pointer]
        --only jump when the label has been set
        if bam_labels[labelnum] then
          if jumpval=0 then --zero loop
            --ignore zero-loop
          elsif jumpval >=1 and jumpval<=253 then --finite loop
            if bam_loopcount[labelnum]<jumpval then
              --increment loop counter
              bam_loopcount[labelnum]+=1
              --jump to label
              bam_pointer=bam_labels[labelnum]
            else
              --loop done. clear counter
              bam_loopcount[labelnum]=0
            end if
          elsif jumpval=254 then --infinite loop
            bam_pointer=bam_labels[labelnum]
          elsif jumpval=255 then --chorus loop
            if bam_chorusmarker>0 then
              --ignore chorus marker, already in chorus
            else  
              --remember current pointer
              bam_chorusmarker=bam_pointer
              --jump to chorus
              bam_pointer=bam_labels[labelnum]
            end if
          end if
        else
          --ignore attempt to jump to undefined label
        end if
      end if
    elsif bamcommand=112 then --end-of-chorus
      if bam_chorusmarker=0 then
        --ignore end-of-chorus when not in chorus mode
      else
        --return to wherever we called the chorus from
        bam_pointer=bam_chorusmarker
        --clear the chorus marker
        bam_chorusmarker=0
      end if
    elsif bamcommand>=128 and bamcommand<=255 then --wait
      bam_delay=bamcommand-127
      --approx .05 seconds per 1/32 note
      bam_delay_start_time=time()
    else
      --ignore unknown command
    end if
      
    --advance to the next command
    bam_pointer+=1

  end if--bam is good

end procedure

------------------------------------------------------------------------

--accepts a delay number and returns it as a chain of BAM wait commands
global function generate_bam_wait(integer delay)
  sequence result
  result={}
  while delay>128 do
    result &= 255
    delay -= 128
  end while
  if delay then
    result &= (127+delay)
  end if
  return(result)
end function

------------------------------------------------------------------------

--optimizes delays, strips redundancys and unknown commands
global function cleanup_bam(sequence bam)
  sequence newbam
  integer bam_ptr
  integer bamcommand
  integer lastcommand
  integer gathered_waits
  
  newbam={}
  bam_ptr=1
  bamcommand=-1
  lastcommand=-1
  
  while bam_ptr<=length(bam) do
    bamcommand=bam[bam_ptr]

    if bamcommand=0 then --stop song
      --end-of-data is the same as stop-song so we dont need to keep this command.
      --break the loop. We can ignore any data that follows a stop-song
      exit
    elsif bamcommand>=16 and bamcommand<=31 then --start note
      if bamcommand=lastcommand then
        --a redundant start-note of the same voice cancels out the
        --data byte of the preceding start-note
        bam_ptr+=1
        newbam[length(newbam)]=bam[bam_ptr]
      else
        newbam &= bam[bam_ptr]
        --get the data byte too
        bam_ptr+=1
        newbam &= bam[bam_ptr]
      end if
    elsif bamcommand>=32 and bamcommand<=47 then --stop note
      if bamcommand=lastcommand then
        --redundant stop-notes of the same voice are ignored
      else  
        newbam &= bam[bam_ptr]
      end if
    elsif bamcommand>=48 and bamcommand<=63 then --define instrument
      if bamcommand=lastcommand then
        --a redundant define-instrument of the same voice should
        --overwrite the instrument data bytes from the preceding command
        newbam[length(newbam)-10..length(newbam)]=bam[bam_ptr+1..bam_ptr+11]
      else
        newbam &= bam[bam_ptr..bam_ptr+11]
      end if
      bam_ptr+=11
    elsif bamcommand>=80 and bamcommand<=95 then --set label
      --dont mess with it, just copy it.
      newbam &= bam[bam_ptr]
    elsif bamcommand>=96 and bamcommand<=111 then --jump
      --dont mess with it, just copy it.
      newbam &= bam[bam_ptr]
      --data byte too
      bam_ptr+=1
      newbam &= bam[bam_ptr]
    elsif bamcommand=112 then --end-of-chorus
      --dont mess with it, just copy it.
      newbam &= bam[bam_ptr]
    elsif bamcommand>=128 and bamcommand<=254 then --wait(except max wait)
      gathered_waits=0
      --read as many waits as possible
      for i=bam_ptr to length(bam) do
        if bam[i]>=128 and bam[i]<=255 then
          --found a wait, add it
          gathered_waits+=(bam[i]-127)
        else
          --not a wait, stop looking
          bam_ptr=i-1
          exit
        end if
      end for
      newbam &= generate_bam_wait(gathered_waits)
    elsif bamcommand=255 then --max wait
      --no need to be tricky, just copy it.
      newbam &= bam[bam_ptr]
    else
      --ignore unknown command
    end if
    
    lastcommand=bamcommand
    
    bam_ptr+=1
  end while
  
  return(newbam)  
end function

------------------------------------------------------------------------

--test-play music that has already been loaded with
--load_bam_file() or set_bam_data()
global procedure test_bam()
  
  integer vol,key

  --begin main loop
  while true do
    
    --read the keyboard
    key=get_key()
   
    --break the loop if any key is pressed
    if key>=0 then
      if key='-' then
        vol=large(get_fm_vol()-2,0)
        set_fm_vol(vol)
        printf(stdout,"volume down to %d\n",{vol})
      elsif key='+' then
        vol=small(get_fm_vol()+2,15)
        set_fm_vol(vol)
        printf(stdout,"volume up to %d\n",{vol})
      else  
        exit
      end if
    end if

    advance_bam()

  end while  

end procedure

------------------------------------------------------------------------

global function merge_bam(sequence bam1,sequence bam2,integer offset)
  sequence instruments
  instruments=repeat({},9)

  
  
  return({})
end function

------------------------------------------------------------------------