include bamplay.e
include bobsmisc.e

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

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

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

integer delta_ticks

sequence midi_track
integer trackptr

--these are filled by calling next_midi_event()
integer midi_event_command
sequence midi_event_data
integer event_delta

integer last_command       last_command=0  --running mode support
integer stream_ran_out     stream_ran_out=false

--IBK file used for MIDI conversion
sequence instrument_bank   instrument_bank="gm.ibk"

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

function stream_one_byte()
  integer result
  if trackptr>length(midi_track) then
    stream_ran_out=true
    return 0
  end if
  result=midi_track[trackptr]
  trackptr+=1
  return(result)
end function

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

procedure rewind_one_byte()
  if trackptr<1 then
    stream_ran_out=true
    return
  end if
  trackptr-=1
end procedure

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

procedure reset_track_stream(sequence data)
  midi_track=data
  trackptr=1
  midi_event_command=0
  midi_event_data={}
  event_delta=0
  last_command=0
  stream_ran_out=false
end procedure

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

function next_midi_event()
  integer n

  integer delta
  integer command
  
  integer meta_command
  integer meta_length
  sequence meta_data
  
  integer want_data_bytes

  delta=0
 
  for i=1 to 4 do
    --read a byte
    n=stream_one_byte()
    --shift the current delta 7 bytes
    delta=delta * #80
    --or in the new value
    delta=or_bits(delta,and_bits(n,#7F))
    if and_bits(n,#80)=0 then
      --last bit is unset
      exit
    end if
  end for
  
  n=stream_one_byte()
  
  if and_bits(n,#80) then
    --command byte found
    command=n
    --store command for possible future running-modes
    last_command=command
  else
    --data byte found, assume running mode
    command=last_command  
    rewind_one_byte()
  end if

  event_delta=delta
  midi_event_command=command
  midi_event_data={}

  if command=#F0 then
    --found a SysEx (System Exclusive) command
    printf(stdout,"Found SysEx command ... ",{})
    while true do
      --get another byte
      n=stream_one_byte()
      if n=#F7 then
        --found EOX
        printf(stdout,"EOX\n",{})
        return true
      end if
      if stream_ran_out then
        --no more data, lets not keep looping!
        printf(stdout,"\nSysEx stream ended prematurely!\n",{})
        return true
      end if
    end while
  end if

  if command=#FF then
    --found a meta-command
    meta_command=stream_one_byte()
    meta_length=stream_one_byte()
    meta_data={}
    for i=1 to meta_length do
      meta_data &= stream_one_byte()
    end for
    if meta_command=#00 then
      --appearently this is only important for type2 asynchronous midi
      printf(stdout,"META: set track sequence number %d\n",{word_to_integer(meta_data)})
    elsif meta_command=#01 then
      printf(stdout,"META:Text: %s\n",{meta_data})
    elsif meta_command=#02 then
      printf(stdout,"META:Copyright: %s\n",{meta_data})
    elsif meta_command=#03 then
      printf(stdout,"META:Track name: %s\n",{meta_data})
    elsif meta_command=#04 then
      printf(stdout,"META:Instrument: %s\n",{meta_data})
    elsif meta_command=#05 then
      printf(stdout,"META:Lyric: %s\n",{meta_data})
    elsif meta_command=#06 then
      printf(stdout,"META:Marker: %s\n",{meta_data})
    elsif meta_command=#07 then
      printf(stdout,"META:Cue: %s\n",{meta_data})
    elsif meta_command>=#08 and meta_command<=#0F then
      printf(stdout,"META:Text Event %02x: %s\n",{meta_command,meta_data})
    elsif meta_command=#20 then
      printf(stdout,"META:Channel Prefix %02x\n",{word_to_integer(meta_data[3..4])})
    elsif meta_command=#21 then
      printf(stdout,"META:Cakewalk port assignment %02x\n",{word_to_integer(meta_data)})
    elsif meta_command=#2F then
      printf(stdout,"META:End-of-track\n",{})
    elsif meta_command=#51 then
      printf(stdout,"META:Set tempo = %d\n",{quad_to_integer(0 & meta_data)})
    elsif meta_command=#54 then
      printf(stdout,"META:SMPTE\n",{})
    elsif meta_command=#58 then
      printf(stdout,"META:Time Signature\n",{})
    elsif meta_command=#59 then
      printf(stdout,"META:Key Signature\n",{})
    elsif meta_command=#7F then
      printf(stdout,"META:Sequencer-specific\n",{})
    else
--      printf(stdout,"META:unknown %02x (",{meta_command})
--      for i=1 to small(length(meta_data),16) do
--        printf(stdout,"%02x",{meta_data[i]})
--        if i<small(length(meta_data),16) then
--          printf(stdout,",",{})
--        end if
--        printf(stdout,")\n",{})
--      end for
    end if
    --once we have done the meta, we need not seek the normal data
    return true
  end if

  --we must figure out how many data bytes we want, otherwise running-mode
  --will kill us :(
  if command>=#80 and command<=#BF then
    --OFF, ON, aftertouch, control change
    want_data_bytes=2
  elsif command>=#C0 and command<=#DF then
    --program patch change, chanel after-touch
    want_data_bytes=1
  elsif command>=#E0 and command<=#EF then
    --pitch-wheel
    want_data_bytes=2
  elsif command>=#F8 and command<=#FE then
    --real-time
    want_data_bytes=0
  end if

  --loop getting data bytes
  for i=1 to want_data_bytes do
    --get another byte
    n=stream_one_byte()

    if and_bits(n,#80) then
      --found a command, data reading is finished
      rewind_one_byte()
      return true  
    else
      --found data
      midi_event_data &= n
    end if
    
  end for
  
  return true
end function

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

function convert_midi_command(integer command,sequence data)
  sequence result
  integer low_nibble
  integer high_nibble
  sequence instrument
  
  result={}

  --split the nibbles
  low_nibble=and_bits(command,#0F)
  high_nibble=and_bits(command,#F0)

  --note! we are going to convert all 16 voices despite the fact that only 9 are supported.
  if high_nibble=#80 then
    --OFF
    result &= (#20+low_nibble)
  elsif high_nibble=#90 then
    --ON
    if data[2]=0 then
      --velocity zero, treat as note-OFF
      result &= (#20+low_nibble)
    elsif data[2]>=1 and data[2]<=127 then
      --legal velocity value
      --note ON
      result &= (#10+low_nibble)
      --frequency
      result &= data[1]
    end if
  elsif high_nibble=#A0 then
    --Aftertouch
    --unsupported
  elsif high_nibble=#B0 then
    --Control Change
    --unsupported
  elsif high_nibble=#C0 then
    --program patch change
    result &= (#30+low_nibble)
    instrument=read_ibk_instrument(instrument_bank,data[1])
    --append exactly 11 bytes of instrument data
    result &= overflowing_slice(instrument[1],1,11,0)
  elsif high_nibble=#D0 then
    --channel after-touch
    --unsupported
  elsif high_nibble=#E0 then
    --pitch-wheel
    --unsupported
  elsif high_nibble=#F0 then
    --real-time
    --unsupported (of course)
  end if

  return(result)  
end function

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

--converts a midi-track into BAM data
function parse_midi_track(sequence track)

  sequence bam_track

  integer bam_delta --8 ticks to the quarter-note

  bam_track={}
  
  reset_track_stream(track)

  while next_midi_event() do
    if stream_ran_out then
      exit
    end if

    --convert midi delta into bam delta
    bam_delta=floor((event_delta/delta_ticks)*8 +.5)

    --append bam delay (if neccisary)
    bam_track &= generate_bam_wait(bam_delta)

    --append bam command translated from midi_event_command and midi_event_data
    bam_track &= convert_midi_command(midi_event_command,midi_event_data)
    
  end while

--  printf(stdout,"%s\n",{sprint(bam_track)})
--  if wait_key() then end if

  printf(stdout,"finished track\n",{})
  return(bam_track)
end function

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

global procedure set_conversion_ibk(sequence filename)
  instrument_bank=filename
end procedure

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

global function load_midi_file(sequence filename)

  integer fh
  sequence buffer

  integer header_size
  integer midi_format
  integer track_count
  integer track_size
  
  sequence converted_tracks
  
  --init
  delta_ticks=0 
  converted_tracks={}

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

  if not file_exists(instrument_bank) then
    --instrument bank unavailable
    return false
  end if

  if not file_exists(filename) then
    --file does not exist
    return false
  end if

  fh=open(filename,"rb")

  --read the header
  if compare(get_bytes(fh,4),"MThd") then
    --header not found
    close(fh)
    return false
  end if

  header_size=quad_to_integer(get_bytes(fh,4))

  if header_size=0 then
    --sizeless header. corrupt
    close(fh)
    return false
  end if

  buffer=get_bytes(fh,header_size)
  
  if length(buffer)<header_size then
    --header ends prematurely
    close(fh)
    return false
  end if

  midi_format=buffer[2]

  if midi_format=0 then
    printf(stdout,"single-track\n",{})
  elsif midi_format=1 then
    printf(stdout,"multi-track synchronous\n",{})
  elsif midi_format=2 then
    printf(stdout,"multi-track asynchronous\n",{})
  else  
    printf(stdout,"unknown file format %d\n",{midi_format})
    close(fh)
    return false
  end if

  track_count=word_to_integer(buffer[3..4])  
  printf(stdout,"Track count = %d\n",{track_count})
  
  delta_ticks=word_to_integer(buffer[5..6])  
  printf(stdout,"delta_ticks = %d\n",{delta_ticks})

  --track reading loop
  for i=1 to track_count do
    
    if compare(get_bytes(fh,4),"MTrk") then
      --failed to find track header
      exit
    end if

    track_size=quad_to_integer(get_bytes(fh,4))
    
    printf(stdout,"found %d byte track\n",{track_size})

    converted_tracks=append(converted_tracks,cleanup_bam(parse_midi_track(get_bytes(fh,track_size))))
    
  end for

  --all finished!
  close(fh)

  --now we must merge the converted tracks
  
  --temporary
  for i=2 to length(converted_tracks) do
    converted_tracks[1]&=converted_tracks[i]
  end for

  --return dummy data for now  
  set_bam_data(converted_tracks[1])

  return true
  
end function

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

if load_midi_file("simon2.mid") then
  test_bam()
end if