Создание WAV-файла

unit MMWaveUtils;
 
// Описание WAVE файла.
// 4 байт 'RIFF',
// 4 байт размер остальной части данных до конца файла,
// 4 байт 'WAVE' означает содержимое wave
// 4 байт 'fmt ' чанк формата данных, 4 байт размер блока fmt
// далее обязательные поля
//    wFormatTag: word; // 2 байт
//    nChannels: word; // 2 байт
//    nSamplesPerSec: dword; // 4 байт
//    nAvgBytesPerSec: dword; // 4 байт
//    nBlockAlign: word; // 2 байт
// в случае PCM далее 2 байт wBitsPerSample:word;
// 4 байт 'data' чанк данных,
// 4 байт размер данных.
// Все размеры указываются со следующего за размером байта.
 
interface
 
uses Windows, SysUtils, MMSystem;
 
const
  WF_NOERROR         = 0;
  WF_FILEOPENED      = 1;
  WF_FILENOTOPENED   = 2;
  WF_IOERROR         = 3;
 
// TRIFFhdr для чтения заголовка файла RIFF
type
  PRIFFhdr = ^TRIFFhdr;
  TRIFFhdr = packed record
    FileID: array [0..3] of char;
    BlockSize: dword;
    BlockID: array [0..3] of char;
  end;
 
// TChunk1 для чтения типа и размера чанка
type
  PChunk1 = ^TChunk1;
  TChunk1 = packed record
    ID: array [0..3] of char;
    BlockSize: dword;
  end;
 
// TMWaveHdr базовый заголовок WAVE файла.
// Использовать только для создания простого WAVE файла.
// Не следует использовать для чтения WAVE файлов.
type
  PMWaveHdr = ^TMWaveHdr;
  TMWaveHdr = packed record
    RIFF:array[0..3]of char;
    size1:dword;
    WAVE:array[0..3]of char;
    fmt:array[0..3]of char;
    size2:dword;
    wFormatTag:word;
    nChannels:word;
    nSamplesPerSec:dword;
    nAvgBytesPerSec:dword;
    nBlockAlign:word;
    wBitsPerSample:word;
    data:array[0..3]of char;
    size3:dword;
  end;
 
// TMMWaveFile класс для чтения и записи PCM WAVE файлов.
type
  TMMWaveFile = class
  protected
    FWaveFmt: TPCMWaveFormat;
    FFile: integer;
    FOpened: boolean;
    FBuf: pbytearray;
    FWrite: boolean;
    FDataSize: dword;
    FDataOffset: dword;
  public
    constructor Create;
    destructor Destroy; override;
    function  LoadFromFile(FileName:string): integer;
    function  CreateFile(FileName:string; SamplesPerSec: dword; BitsPerSample, Channels: word): integer;
    function  CloseFile: integer;
    function  ReadBlock(var Buffer; Count: dword): integer;
    function  WriteBlock(var Buffer; Count: dword): integer;
    function  SeekSample(Position: dword): dword;
    function  SeekByte(Offset, Origin: integer): integer;
    function  GetCurrentPosition: dword;
    property  GetDataOffset: dword read fDataOffset;
    property  WaveFormat: TPCMWaveFormat read fwavefmt;
    property  WaveOpened: boolean read fopened;
  end;
 
implementation
 
constructor TMMWaveFile.Create;
begin
  FFile:=0;
  FOpened:=false;
  FWrite:=false;
  FDataSize:=0;
end;
 
destructor TMMWaveFile.Destroy;
begin
  CloseFile;
  inherited;
end;
 
function  TMMWaveFile.LoadFromFile(FileName:string): integer;
var
  RIFFHdr1: TRIFFhdr;
  ch1: TChunk1;
  rb1: dword;
  pwf1: PPCMWaveFormat;
begin
  Result := WF_NOERROR;
  if FOpened then begin
    Result := WF_FILEOPENED;
    exit;
  end;
  FDataOffset := 0;
  FOpened := false;
  FWrite := false;
  FFile := FileOpen(FileName, FMOpenRead or FMShareDenyNone);
  if FFile < 0 then begin
    Result := WF_FILENOTOPENED;
    exit;
  end;
 
    // Добавлен поиск блока "data"
 
  FillChar(FWaveFmt, SizeOf(TPCMWaveFormat), 0);
  FillChar(RIFFHdr1, SizeOf(TRIFFhdr), 0);
  FillChar(ch1, SizeOf(TChunk1), 0);
  FileRead(FFile, RIFFHdr1, SizeOf(TRIFFhdr));
 
  if (RIFFHdr1.FileID = 'RIFF') and (RIFFHdr1.BlockID = 'WAVE') then begin
    repeat
      FillChar(ch1, SizeOf(TChunk1), 0);
      rb1 := FileRead(FFile, ch1, SizeOf(TChunk1));
      if (rb1 <> SizeOf(TChunk1)) then
        break;
 
      if (ch1.ID = 'fmt ') then begin
        GetMem(pwf1, ch1.BlockSize);
        FillChar(pwf1^, ch1.BlockSize, 0);
        rb1 := FileRead(FFile, pwf1^, ch1.BlockSize);
        if (pwf1^.wf.wFormatTag = 1) or (pwf1^.wf.wFormatTag = 3) then begin
          move(pwf1^, fWaveFmt, SizeOf(TPCMWaveFormat));
          FOpened:=true;
          FWrite:=false;
        end;
        FreeMem(pwf1);
      end else
      if (ch1.ID = 'data') then begin
        fDataOffset := GetCurrentPosition;
      end else begin
        rb1 := ch1.BlockSize;
        FileSeek(FFile, ch1.BlockSize, 1);
      end;
 
    until (ch1.ID = 'data') or (rb1 < ch1.BlockSize);
  end;
  // Здесь позиция в файле находится в начале блока данных либо в конце файла.
end;
 
function  TMMWaveFile.CreateFile(FileName:string; SamplesPerSec: dword; BitsPerSample, Channels: word): integer;
var
  FWaveHdr: TMWaveHdr;
begin
  Result := WF_NOERROR;
  if FOpened then begin
    Result := WF_FILEOPENED;
    exit;
  end;
 
  FOpened := false;
  FDataSize := 0;
  FFile := FileCreate(FileName);
  if FFile < 0 then begin
    Result := WF_FILENOTOPENED;
    exit;
  end;
  FillChar(fWaveFmt, sizeof(TPCMWaveFormat), 0);
  fWaveFmt.wf.nChannels := Channels;
  fWaveFmt.wf.nSamplesPerSec := SamplesPerSec;
  fWaveFmt.wBitsPerSample := BitsPerSample;
 
  FillChar(fwavehdr, sizeof(tmwavehdr), 0);
  FWaveHdr.RIFF:='RIFF';
  FWaveHdr.WAVE:='WAVE';
  FWaveHdr.fmt :='fmt ';
  FWaveHdr.data:='data';
 
  if SizeOf(TMWaveHdr) = FileWrite(FFile, FWaveHdr, SizeOf(TMWaveHdr)) then begin
    FOpened := true;
    FWrite := true;
  end else begin
    FileClose(FFile);
    FFile := 0;
    FillChar(fWaveFmt, SizeOf(TPCMWaveFormat), 0);
    Result := WF_IOERROR;
  end;
end;
 
function  TMMWaveFile.CloseFile: integer;
var
  FWaveHdr: TMWaveHdr;
begin
  Result := WF_NOERROR;
  if not FOpened then begin
    Result := WF_FILENOTOPENED;
    exit;
  end;
  if FOpened and FWrite then begin
    FWaveHdr.RIFF            := 'RIFF';
    FWaveHdr.size1           := fDataSize+sizeof(tmwavehdr)-8;
    FWaveHdr.WAVE            := 'WAVE';
    FWaveHdr.fmt             := 'fmt ';
    FWaveHdr.size2           := 16;
    FWaveHdr.wFormatTag      := WAVE_FORMAT_PCM; // = 1;
    FWaveHdr.nChannels       := fWaveFmt.wf.nChannels;
    FWaveHdr.nSamplesPerSec  := fWaveFmt.wf.nSamplesPerSec;
    FWaveHdr.nAvgBytesPerSec := (fWaveFmt.wf.nSamplesPerSec * fWaveFmt.wf.nChannels * fWaveFmt.wBitsPerSample) div 8;
    FWaveHdr.nBlockAlign     := (fWaveFmt.wf.nChannels * fWaveFmt.wBitsPerSample) div 8;
    FWaveHdr.wBitsPerSample  := fWaveFmt.wBitsPerSample;
    FWaveHdr.data            := 'data';
    FWaveHdr.size3           := fdatasize;
    FileSeek(FFile, 0, 0);
    if SizeOf(TMWaveHdr) <> FileWrite(FFile, FWaveHdr, SizeOf(TMWaveHdr)) then
      Result := WF_IOERROR;
    FWrite := false;
  end;
  FOpened := false;
  FileClose(FFile);
  FFile := 0;
end;
 
function  TMMWaveFile.ReadBlock(var Buffer; Count: dword):integer;
begin
  result := 0;
  if FOpened and (not FWrite) then
    Result := FileRead(FFile, Buffer, Count);
end;
 
function  TMMWaveFile.WriteBlock(var Buffer; Count: dword):integer;
begin
  result := 0;
  if FOpened and FWrite and (Count > 0) then begin
    Result := FileWrite(FFile, Buffer, Count);
    FDataSize := FDataSize + Count;
  end;
end;
 
function  TMMWaveFile.SeekSample(Position: dword): dword;
begin
  Result := 0;
  if FOpened and (not FWrite) then begin
    Result := FileSeek(FFile, FDataOffset + FWaveFmt.wf.nBlockAlign*Position, 0);
    Result := (Result - FDataOffset) div FWaveFmt.wf.nBlockAlign;
  end;
end;
 
function  TMMWaveFile.SeekByte(Offset, Origin: integer): integer;
begin
  Result := FileSeek(FFile, Offset, Origin);
end;
 
function  TMMWaveFile.GetCurrentPosition: dword;
begin
  Result := FileSeek(ffile, 0, 1);
end;
 
end.