mmeq.pas

一套及时通讯的原码

         for i := 0 to TMMEQFilterList(Source).Count-1 do
         begin
            Filter := TMMEQFilter.Create;
            Filter.Assign(TMMEQFilterList(Source)[i]);
            AddObject(Filter);
         end;

      finally
         if (FEqualizer <> nil) then
             FEqualizer.FUpdating := False;

         EndUpdate;
      end;
   end
   else inherited assign(Source);
end;

{-- TMMEQFilterList -----------------------------------------------------------}
procedure TMMEQFilterList.DefineProperties(Filer: TFiler);
begin
   Filer.DefineBinaryProperty('ObjectContainer', ReadData, WriteData, True);
end;

{-- TMMEQFilterList -----------------------------------------------------------}
procedure TMMEQFilterList.ReadData(S: TStream);
Var
   pBuf: PChar;
   Kennung: Longint;
   ObjCount,
   Index: TOLSize;
   Destroy: Boolean;
   Value: Longint;

begin
   BeginUpdate;
   try
      FEqualizer.FUpdating := True;
      S.ReadBuffer(Kennung,sizeOf(STREAMKENNUNG));
      if (Kennung <> STREAMKENNUNG) then
         raise EStreamError.Create('Invalid Object stream');
      FreeAll;
      { load stream items }
      S.ReadBuffer(Destroy,SizeOf(Destroy));
      DestroyObjects := Destroy;

      { read string length }
      S.ReadBuffer(Value,SizeOf(Value));
      if Value > 0 then
      begin
         pBuf := StrAlloc(Value+1);
         try
            FillChar(pBuf^, Value+1, 0);
            S.ReadBuffer(pBuf^, Value);
            FEqualizer.Description := StrPas(pBuf);
         finally
            StrDispose(pBuf);
         end;
      end;

      S.ReadBuffer(Value,SizeOf(Value));
      FEqualizer.FFTLength := Value;

      S.ReadBuffer(ObjCount,SizeOf(Objcount));  { Read in Object count }
      if Capacity-Count < ObjCount then Capacity := Count+ObjCount;

      { Read in Object Count }
      for Index := 0 to ObjCount-1 do
          AddObject(ReadObjectFromStream(S));

   finally
      FEqualizer.FUpdating := False;
      EndUpdate;
   end;
end;

{-- TMMEQFilterList -----------------------------------------------------------}
procedure TMMEQFilterList.WriteData(S: TStream);
var
   Index,ObjCount: TOlSize;
   Destroy: Boolean;
   Value: Longint;

begin
   { Write list to Stream }
   S.WriteBuffer(STREAMKENNUNG,SizeOf(STREAMKENNUNG));
   Destroy := DestroyObjects;
   S.WriteBuffer(Destroy,SizeOf(Destroy));

   { write string length }
   Value := Length(FEqualizer.FDescription);
   S.WriteBuffer(Value, SizeOf(Value));
{$IFDEF WIN32}
   S.WriteBuffer(PChar(FEqualizer.FDescription)^, Length(FEqualizer.FDescription));
{$ELSE}
   S.WriteBuffer(FEqualizer.FDescription[1], Length(FEqaulizer.FDescription));
{$ENDIF}

   Value := FEqualizer.FFTLen;
   S.WriteBuffer(Value, SizeOf(Value));

   ObjCount := Count;
   S.WriteBuffer(ObjCount,SizeOf(ObjCount));
   for Index := 0 to Count-1 do
       WriteObjectToStream(Items[Index],S);
end;

{== TMMEqualizer ==============================================================}
constructor TMMEqualizer.Create(aOwner: TComponent);
begin
   inherited Create(aOwner);

   FFilters := TMMEQFilterList.Create;
   FFilters.OnChange := FiltersChanged;
   FFilters.FEqualizer := Self;

   FPFilter    := nil;
   FPTempFilter:= nil;
   FDescription:= 'Untitled';
   Ffs         := defRate;
   FWindow     := defWindow;
   FChannel    := defChannel;
   FEnabled    := defEnabled;
   FOpen       := False;
   FUpdating   := False;
   FSpectrum   := nil;
   FFTLen      := 8;
   FFTLength   := defFFTLen;

   ErrorCode := ComponentRegistered(InitCode, Self, ClassName);
   if (ErrorCode <> 0) then RegisterFailed(InitCode, Self , ClassName);
end;

{-- TMMEqualizer --------------------------------------------------------------}
destructor TMMEqualizer.Destroy;
begin
   Close;

   SetSpectrum(nil);

   FFilters.Free;

   inherited Destroy;
end;

{-- TMMEqualizer --------------------------------------------------------------}
procedure TMMEqualizer.Notification(aComponent: TComponent; Operation: TOperation);
begin
   inherited Notification(aComponent, Operation);

   if (Operation = opRemove) then
   begin
      if (aComponent = FSpectrum) then
          FSpectrum := nil;
   end;
end;

{-- TMMEqualizer --------------------------------------------------------------}
procedure TMMEqualizer.PcmOverflow;
begin
   if assigned(FOnPcmOverflow) then FOnPcmOverflow(Self);
end;

{-- TMMEqualizer --------------------------------------------------------------}
procedure TMMEqualizer.SetPWaveFormat(aValue: PWaveFormatEx);
begin
   if (aValue <> nil) then
   begin
      if not (csDesigning in ComponentState) then
         if not pcmIsValidFormat(aValue) or (aValue^.wBitsPerSample = 8) then
            raise EMMEqualizerError.Create(LoadResStr(IDS_INVALIDFORMAT));

      SampleRate := aValue^.nSamplesPerSec;
   end;

   inherited SetPWaveFormat(aValue);
end;

{-- TMMEqualizer --------------------------------------------------------------}
procedure TMMEqualizer.SaveToRegIniFile(Ini: TRegIniFile; Section: string);
var
   i: integer;
begin
   if (Ini <> nil) then
   begin
      with Ini do
      begin
         WriteInteger(Section, 'FFTLen', FFTLength);
         WriteInteger(Section, 'Samplerate', Samplerate);
         WriteInteger(Section, 'Window', Ord(Window));

         WriteInteger(Section, 'Bands', Filters.Count);
         for i := 0 to Filters.Count-1 do
         with Filters[i] do
         begin
            WriteString(Section, 'Band'+IntToStr(i)+' f1', FloatToStr(f1));
            WriteString(Section, 'Band'+IntToStr(i)+' f2', FloatToStr(f2));
            WriteString(Section, 'Band'+IntToStr(i)+' Gain', FloatToStr(Gain));
            WriteBool(Section, 'Band'+IntToStr(i)+' Enabled', Enabled);
         end;
      end;
   end;
end;

{-- TMMEqualizer --------------------------------------------------------------}
procedure TMMEqualizer.SaveToIniFileEx(Ini: TIniFile; Section: string);
var
   i: integer;
begin
   if (Ini <> nil) then
   begin
      with Ini do
      begin
         WriteInteger(Section, 'FFTLen', FFTLength);
         WriteInteger(Section, 'Samplerate', Samplerate);
         WriteInteger(Section, 'Window', Ord(Window));

         WriteInteger(Section, 'Bands', Filters.Count);
         for i := 0 to Filters.Count-1 do
         with Filters[i] do
         begin
            WriteString(Section, 'Band'+IntToStr(i)+' f1', FloatToStr(f1));
            WriteString(Section, 'Band'+IntToStr(i)+' f2', FloatToStr(f2));
            WriteString(Section, 'Band'+IntToStr(i)+' Gain', FloatToStr(Gain));
            WriteBool(Section, 'Band'+IntToStr(i)+' Enabled', Enabled);
         end;
      end;
   end;
end;

{-- TMMEqualizer --------------------------------------------------------------}
procedure TMMEqualizer.ReadFromRegIniFile(Ini: TRegIniFile; Section: string);
var
   Cnt, i: integer;
   f1,f2,Gain: Float;
   Enabl: Boolean;

begin
   if (Ini <> nil) then
   begin
      with Ini do
      begin
         i := ReadInteger(Section, 'FFTLen', -1);
         if (i > 0) then
         begin
            Filters.BeginUpdate;
            try
               FUpdating := True;

               Filters.FreeAll;

               FFTLength   := ReadInteger(Section, 'FFTLen', defFFTLen);
               Samplerate  := ReadInteger(Section, 'Samplerate', defRate);
               Window      := TMMFFTWindow(ReadInteger(Section, 'Window', Ord(defWindow)));
               Description := Section;

               Cnt := ReadInteger(Section, 'Bands', 0);

               for i := 0 to Cnt-1 do
               begin
                  f1   := StrToFloat(CheckFloat(ReadString(Section, 'Band'+IntToStr(i)+' f1', '0')));
                  f2   := StrToFloat(CheckFloat(ReadString(Section, 'Band'+IntToStr(i)+' f2', '0')));
                  Gain := StrToFloat(CheckFloat(ReadString(Section, 'Band'+IntToStr(i)+' Gain', '0')));
                  Enabl:= ReadBool(Section, 'Band'+IntToStr(i)+' Enabled', True);

                  Filters.AddObject(TMMEQFilter.CreateEx(f1,f2,Gain));
                  Filters[i].Enabled := Enabl;
               end;

            finally
               FUpdating := False;
               Filters.EndUpdate;
            end;
         end;
      end;
   end;
end;

{-- TMMEqualizer --------------------------------------------------------------}
procedure TMMEqualizer.ReadFromIniFileEx(Ini: TIniFile; Section: string);
var
   Cnt, i: integer;
   f1,f2,Gain: Float;
   Enabl: Boolean;

begin
   if (Ini <> nil) then
   begin
      with Ini do
      begin
         i := ReadInteger(Section, 'FFTLen', -1);
         if (i > 0) then
         begin
            Filters.BeginUpdate;
            try
               FUpdating := True;

               Filters.FreeAll;

               FFTLength   := ReadInteger(Section, 'FFTLen', defFFTLen);
               Samplerate  := ReadInteger(Section, 'Samplerate', defRate);
               Window      := TMMFFTWindow(ReadInteger(Section, 'Window', Ord(defWindow)));
               Description := Section;

               Cnt := ReadInteger(Section, 'Bands', 0);

               for i := 0 to Cnt-1 do
               begin
                  f1   := StrToFloat(CheckFloat(ReadString(Section, 'Band'+IntToStr(i)+' f1', '0')));
                  f2   := StrToFloat(CheckFloat(ReadString(Section, 'Band'+IntToStr(i)+' f2', '0')));
                  Gain := StrToFloat(CheckFloat(ReadString(Section, 'Band'+IntToStr(i)+' Gain', '0')));
                  Enabl:= ReadBool(Section, 'Band'+IntToStr(i)+' Enabled', True);

                  Filters.AddObject(TMMEQFilter.CreateEx(f1,f2,Gain));
                  Filters[i].Enabled := Enabl;
               end;

            finally
               FUpdating := False;
               Filters.EndUpdate;
            end;
         end;
      end;
   end;
end;

{-- TMMEqualizer --------------------------------------------------------------}
procedure TMMEqualizer.SaveToIniFile(IniFile: TFileName; Section: string);
var
   Ini: TIniFile;
begin
   if (IniFile <> '') then
   begin
      Ini := TIniFile.Create(IniFile);
      try
         Section := 'EQ.'+Section;
         SaveToIniFileEx(Ini, Section);
      finally
         Ini.Free;
      end;
   end;
end;

{-- TMMEqualizer --------------------------------------------------------------}
procedure TMMEqualizer.ReadFromIniFile(IniFile: TFileName; Section: string);
var
   Ini: TInifile;
begin
   if (IniFile <> '') then
   begin
      Ini := TIniFile.Create(IniFile);
      try
         Section := 'EQ.'+Section;
         ReadFromIniFileEx(Ini,Section);
      finally
         Ini.Free;
      end;
   end;
end;

{-- TMMEqualizer --------------------------------------------------------------}
procedure TMMEqualizer.SetFilters(aValue: TMMEQFilterList);
begin
   if (aValue <> FFilters) then FFilters.Assign(aValue);
end;

{-- TMMEqualizer --------------------------------------------------------------}
procedure TMMEqualizer.FilterChanged(Sender: TObject);
begin
   { setup one equalizer band with the params }
   if not FUpdating then