# to_le wandelt einen Zahlwert (wert) in ein Folge von einer gegbenen (bytes) Bytes um.
# Z.B. wird mit to_le(0x1020,4) die Folge 0x20,0x10,0x00,0x00 von 4 Bytes erzeugt.

def to_le(wert, bytes=2)  # Wird kein zweiter Parameter angegeben, ist dieser automatisch 2
  res = 0.chr*bytes       # String vorbereiten
  bytes.times{|i|         # Bytes durchgehen
    res[i] = (wert & 0xff).chr    # Wert in 8-Bit-ASCII umwandeln (nicht zwingend ein Symbol!)
    wert >>=8             # Kurzform für:  wert = wert >> 8
  }
  return res              # Resultat der Funktion
end

duration = 2
 
format = 0x0001      # Siehe Dokumentation
channels = 1         # Mono
rate = 44100         # 44100Hz Samplingrate
bytes_per_second = rate*2
blockalign = 2
bitssample = 16
 
filesize = 44 + duration*bytes_per_second
 
wav = 0.chr*filesize                                                                                                                                                                                              
                                                                                                                                                                                                                  
wav[0..3] = "RIFF"                                                                                                                                                                                                
wav[4..7] = to_le(filesize-8, 4)                                                                                                                                                                                  
wav[8..11]="WAVE"                                                                                                                                                                                                 
                                                                                                                                                                                                                  
wav[12..15] = "fmt "                                                                                                                                                                                              
wav[16..19] = to_le(16,4)                                                                                                                                                                                         
wav[20..21] = to_le(format,2)                                                                                                                                                                                     
wav[22..23] = to_le(channels,2)                                                                                                                                                                                   
wav[24..27] = to_le(rate,4)                                                                                                                                                                                       
wav[28..31] = to_le(bytes_per_second,4)                                                                                                                                                                           
wav[32..33] = to_le(blockalign,2)                                                                                                                                                                                 
wav[34..35] = to_le(bitssample,2)                                                                                                                                                                                 
                                                                                                                                                                                                                  
wav[36..39] = "data"                                                                                                                                                                                              
wav[40..43] = to_le(filesize-44,4)                                                                                                                                                                                
                                                                                                                                                                                                                  
offset = 44                                                                                                                                                                                                       

# Samples durchzählen
# s ist die Sample Nummer
for s in 0...(duration*rate)
   # Entsprechende Zeit in Sekunden
   t = s.to_f/rate
   # Wert zum Zeitpunkt t
   v = Math.sin(t*440*2*Math::PI)*30000
   # Wert in die "WAV-Datei" schreiben
   wav[(s*2+offset)..(s*2+offset+1)] = to_le(v.to_i,2)
end

# Wav-Datei effektiv abspeichern
File.open("output.wav","w"){|o|
  o.write(wav)
}