unit Wave;

interface

uses SysUtils, Types, Classes, math;

type
  TRIFFHeader = packed record
    ID : array[0..3] of Char;
    Length: DWORD;
    WaveID: array[0..3] of Char;
  end;
  TFormatHeader = packed record
    ID : array[0..3] of Char;
    Length : DWORD;
    FormatTag : WORD;
    Channels : WORD;
    SamplesPerSec : DWORD;
    AvgBytesPerSec: DWORD;
    BlockAlign : WORD;
    BitsPerSample : WORD;
  end;
  TDataHeader = packed record
    ID : array[0..3] of Char;
    Length: DWORD;
  end;
  TWaveHeader = packed record
    RIFF: TRIFFHeader;
    Format: TFormatHeader;
    Data: TDataHeader;
  end;
  TWaveSample = packed record
    Left: Smallint;
    Right: Smallint;
  end;
  TWaveContent = packed Array of TWaveSample;
//  TWaveContent = Array of SmallInt;

function LoadWAVEFile(FileName: String): TWaveContent;
procedure FadeWAVE(var WaveContent: TWaveContent; MilliSeconds: SmallInt);
function CountQuietSamples(WaveContent: TWaveContent; ThresHold: SmallInt): Integer;
procedure SaveWAVEFile(WaveContent: TWaveContent; FileName: String);

implementation

function LoadWAVEFile(FileName: String): TWaveContent;
var
  WaveHeader: TWaveHeader;
  FStream: TFileStream;
  WaveLength: Integer;
begin
  try
    if FileExists(FileName) then begin
      FStream := TFileStream.Create(FileName,fmOpenRead);
      FStream.Read(WaveHeader,SizeOf(TWaveHeader)); // Den kompletten Header auslesen
      WaveLength := WaveHeader.Data.Length * 8 div (WaveHeader.Format.BitsPerSample
                    * WaveHeader.Format.Channels); // Länge des Arrays berechnen...
      SetLength(Result, WaveLength);
      FStream.Read(Result[0], WaveLength * 4);
      // Die Größe ist 4x so groß wie die Länge, weil 2 Channels * 2 Bytes / Sample
    end;
  finally
    FStream.Free
  end;
end;

procedure SaveWAVEFile(WaveContent: TWaveContent; FileName: String);
var
  WaveHeader: TWaveHeader;
  FStream: TFileStream;
  WaveLength: Integer;
begin
  try
    FStream := TFileStream.Create(FileName, fmCreate);
    WaveLength := length(WaveContent);

    with WaveHeader do begin
      with RIFF do begin
        ID := 'RIFF';
        Length := 4 + WaveLength * 4 + SizeOf(TFormatHeader) + SizeOf(TDataHeader);
        WaveID := 'WAVE';
      end;
      with Format do begin
        ID := 'fmt ';
        Length := SizeOf(TFormatHeader)-8;
        FormatTag := $0001;
        Channels := 2;
        SamplesPerSec := 44100;
        AvgBytesPerSec := 176400;
        BlockAlign := 4;
        BitsPerSample := 16;
      end;
      with Data do begin
        ID := 'data';
        Length := WaveLength * 4;
      end;
    end;
//    WriteLn(WaveLength);
    FStream.Write(WaveHeader, SizeOf(TWaveHeader));
    FStream.Write(WaveContent[0], WaveLength * 4);
  finally
    FStream.Free;
  end;
end;

procedure FadeWAVE(var WaveContent: TWaveContent; MilliSeconds: SmallInt);
var
  Sample, Samples: Integer;
begin
  Samples := min(abs(Round(MilliSeconds * 44.1)),length(WaveContent)-1);
  // 1. Aus den Millisekunden wird die Anzahl der Samples gerechnet
  // 2. Die Maximale Dauer des Fades wird auf die Länge des Arrays gesetzt.
  if MilliSeconds > 0 then begin // Positiver Wert => FadeIn
    for Sample := 0 to Samples do begin
      WaveContent[Sample].Left  := Round(WaveContent[Sample].Left  * Sample / Samples);
      WaveContent[Sample].Right := Round(WaveContent[Sample].Right * Sample / Samples);
    end;
  end else begin // Negativer Wert => FadeOut
    for Sample := length(WaveContent) - Samples to length(WaveContent)- 1 do begin
      WaveContent[Sample].Left  := Round(WaveContent[Sample].Left * (length(WaveContent)
                                         - Sample) / Samples);
      WaveContent[Sample].Right := Round(WaveContent[Sample].Right * (length(WaveContent)
                                         - Sample) / Samples);
    end;
  end;
end;

end.