"bass.dll" Aufnahme an beliebiger Stelle im Stream fortsetze

[Ducksoul]

Hallo mal wieder,

ich bräuchte mal wieder einen kleinen Denkanstoß. Momentan programmiere ich ein kleines Diktiergerät und benutze dazu die bass.dll.
Wenn jetzt der Nutzer etwas aufgenommen hat und merkt, dass er etwas ändern will, dann möchte ich, dass er an einer beliebigen Stelle die Aufnahme fortsetzen kann und der Rest der schon vorhandenen Aufnahme dann gelöscht/überschrieben wird.

Bis jetzt habe ich die Aufnahmemodi "Ans Ende anhängen" und "Aufnahme überschreiben". Aber in die Aufnahme noch etwas einfügen, bzw. das was ich oben erläutert habe ist mir bisher noch nicht gelungen. Zwar kann ich einfach einen Teil des Streams überschreiben, aber wenn zum Beispiel die neue Aufnahme kürzer ist als die zuvor aufgenommene, dann hört man ja am Ende noch was von der alten Aufnahme. Um das Problem nicht zu haben müsste also erstmal der Teil des Streams, ab dem ich neu aufnehmen möchte, gelöscht werden. (1.Problem)
Und um später noch Passagen einfügen zu können würde ich gerne den Teil des Streams ab dem die Passage eingeführt wird bis zum Ende des Streams in einen 2. Stream speichern, dann aus dem alten Stream löschen, die Passage aufnehmen und den kopierten Teil aus dem zweiten Stream danach wieder ans Ende ranhängen. (2.Problem)

Bis jetzt klappt das aber noch gar nicht. Hier mal der Code, den ich bisher habe:
(Der CopyFrom-Befehl erzeugt allerdings eine AV)

Delphi-Quellcode:

  // Aufnahme je nach Aufnahmemodus
      if OverwriteRadioButton.Checked = True
        then begin

           if WaveStream.Size > 0
            then begin
                // alte Aufnahme löschen
                BASS_StreamFree(chan);
                WaveStream.Clear;
             end;  // if
        end
      else if InsertRadioButton.Checked = True
              then begin
                  if WaveStream.Size = 0
                    then begin
                    end
                  else
                    begin
                      WaveStream.Position := ProgressBar.Position;
                      WaveStream.CopyFrom(BufStream, WaveStream.Position);
                    end;

              end
      else if EndRadioButton.Checked = True
              then begin
                WaveStream.Position := WaveStream.Size;
                ProgressBar.Position := ProgressBar.Max;
              end;  // if

[Ducksoul]

Aktualisierung:

Das Einfügen einer Passage habe ich jetzt alleine hinbekommen. Ich hatte copyfrom total falsch verstanden. Hier der aktualisierte Code bisher:

Delphi-Quellcode:

        // Aufnahme je nach Aufnahmemodus
      if OverwriteRadioButton.Checked = True
        then begin

           if WaveStream.Size > 0
            then begin
                // alte Aufnahme löschen
                BASS_StreamFree(chan);
                WaveStream.Clear;
             end;  // if
        end
      else if InsertRadioButton.Checked = True
              then begin
                  if WaveStream.Size = 0
                    then begin
                    end
                  else
                    begin
                      WaveStream.Position := ProgressBar.Position;
                      BufStream := TMemoryStream.Create;
                      BufStream.CopyFrom(WaveStream, WaveStream.Size-WaveStream.Position);
                      WaveStream.Position := ProgressBar.Position;

                    end;

und dann beim Beenden der Aufnahme:

Delphi-Quellcode:

      if InsertRadioButton.Checked = True
        then begin
          if WaveStream.Size = 0
            then begin
            end
          else
            begin
              WaveStream.CopyFrom(BufStream, 0);
              FreeAndNil(BufStream);
            end;
      end;

Ich muss jetzt noch rausfinden wie man Teile eines Streams löscht und schon hat sich der Thread von alleine erledigt ;)

MfG

[Ducksoul]

Delphi-Quellcode:

WaveStream.Position := ProgressBar.Position;
WaveStream.SetSize(WaveStream.Size-WaveStream.Position);

So habe ich jetzt das Löschen des alten Parts, welcher übersprochen werden soll bewerkstelligt.

Damit habe ich meinen eigenen Thread wohl selber beantwortet *gg*

MfG
Franz

[Ducksoul]

Hi, das Problem ist doch noch nicht gelöst :(

Wenn die Länge der zweiten Aufnahme größer ist als die des ursprünglich überschriebenen Streams, dann entsteht ein ganz hässliches Rauschen. Ich glaube dass das mit SetSize zusammenhängt.

Hier der jetzige Code:

Delphi-Quellcode:

        // Aufnahme je nach Aufnahmemodus
      if WaveStream.Size = 0 then
        begin
        end
      else
        begin
      if Rec_Passage.Checked = True then
        begin
          try
            WaveStream.Position := GetPos;
            BufStream := TMemoryStream.Create;
            BufStream.CopyFrom(WaveStream, WaveStream.Size-WaveStream.Position);
            WaveStream.Position := GetPos;
          except
            FreeAndNil(BufStream);
          end;
        end
      else
        begin
          try
            WaveStream.Position := GetPos;
            WaveStream.SetSize(BASS_ChannelGetLength(rchan)-WaveStream.Position);
          except
          end;
      end;  // if

und beim Beenden der Aufnahme:

      if Rec_Passage.Checked = True then
        begin
          try
            WaveStream.CopyFrom(BufStream, 0);
          finally
            FreeAndNil(BufStream);
          end;
      end;  // if

Rec_Passage soll eigentlich eine neue Passage einfügen und Rec_Overwrite soll ab der Position an der man sich befindet alles überschreiben.

Kann mir da vielleicht doch einer helfen?


Und bei den Moderatoren möchte ich mich ganz herzlich für die ganzen Doppelposts entschuldigen. Werde ab jetzt die Edit-Funktion nutzen.


Gruß,
Duck

[EWeiss]

Schau dir doch bei 3dLite den TStream Editor an denke das wird die unter umständen mehr helfen
Ohne kompletten Code was da nun passiert bei dir ist es schwer zu helfen.

gruss Emil

[Ducksoul]

Nabend,
falls du meintest ich soll auf 3dlite.com schauen, dann muss ich leider sagen, dass man auf der Site momentan nicht viel findet ;)

Desweiteren ist doch da der gesamte Code, welcher Relevant ist, da ich ja nur am Wavestream rumschnippel :p Das BASS_ChannelGetLength(rchan) muss btw durch ein Wavestream.Size ersetzt werden.

Hast du evtl. noch andere Vorschläge?


Viele Grüße,
Franz

[Wishmaster]

http://www.3delite.hu/Object%20Pasca...display3d.html

[Ducksoul]

Hm ne, das hat mir ausnahmsweise mal nicht geholfen..

Also momentan sieht es bei mir folgendermaßen aus:

Callback-Routine:

Delphi-Quellcode:

  (* Callback *)
  function RecordingCallback(Handle: HRECORD; buffer: Pointer; length, user: DWord): boolean; stdcall;
    begin
        // Kopiere neuen Bufferinhalt in den Memory Buffer
       Formular.WaveStream.Write(buffer^, length);
        // Weiteres Aufnehmen erlauben
       Result := True;

    end;  // function Callback

Start der Aufnahme:

Delphi-Quellcode:

  (* Aufnahme Start *)
  procedure TFormular.StartRecording;
    var
      vol: Float;
      i: Integer;
      Flag: DWord;
    begin

        // Aufnahme je nach Aufnahmemodus
      if WaveStream.Size = 0 then
        begin
        end
      else
        begin
      if Rec_Passage.Checked = True then
        begin
          try
            // ín aufgenommenen Stream eine Passage nach aktueller
            // Position einfügen
          except
          end;
        end
      else
        begin
            (*WaveStream.Position := GetPos;
            Edit1.Text := IntToStr(WaveStream.Position);
            BufStream := TMemoryStream.Create;
            BufStream.CopyFrom(WaveStream, WaveStream.Position);

            BASS_ChannelStop(chan);
            BASS_ChannelStop(rchan);
            BASS_StreamFree(chan);
            BASS_StreamFree(rchan);
            WaveStream := nil;
            WaveStream := TMemoryStream.Create;

            WaveStream.CopyFrom(BufStream, 0);
            FreeAndNil(BufStream);*)

            // alles nach aktueller Position löschen und dort Aufnahme
            // fortführen

          try
          except
          end;
      end;  // if
      end;

         // Header für WAV-File generieren
       with WaveHdr do
        begin
            riff := 'RIFF';
            len := 36;
            cWavFmt := 'WAVEfmt ';
            dwHdrLen := 16;
            wFormat := 1;
            wNumChannels := 2;
            dwSampleRate := 44100;
            wBlockAlign := 4;
            dwBytesPerSec := 176400;
            wBitsPerSample := 16;
            cData := 'data';
            dwDataLen := 0;
        end;  // with

         WaveStream.Write(WaveHdr, SizeOf(WAVHDR));
         i := 0;


        vol := RecordPegelBar.Position/100;
         while BASS_RecordSetInput(i, BASS_INPUT_OFF, vol)
          do i := i + 1;


          //             ---LoWord--  ----HiWord----
        Flag := MakeLong(c16BitAudio, cRecordingTime);
           // Aufnahmebeginn @ 44100hz 16-bit stereo
         rchan := BASS_RecordStart(cSamplerate,
                                  cNumChannels,
                                  Flag,
                                  @RecordingCallback,
                                  nil);

         if rchan = 0
          then begin
              MessageDlg('Aufnahme konnte nicht gestartet werden!',
                        mtError, [mbOk], 0);
              WaveStream.Clear;
           end;
    end;  // procedure StartRecording

Beenden der Aufnahme:

Delphi-Quellcode:

  (* Stop recording *)
  procedure TFormular.StopRecording;
    var
       i: integer;
    begin
       BASS_ChannelStop(rchan);

         // WAV-Header komplettieren
       WaveStream.Position := 4;
       i := WaveStream.Size - 8;
       WaveStream.Write(i, 4);
       i := i - $24;
       WaveStream.Position := 40;
       WaveStream.Write(i, 4);
       WaveStream.Position := 0;

      if Rec_Passage.Checked = True then
        begin
          try
          finally
          end;
      end;  // if

         // Stream für aufgenomme Daten kreieren
       chan := BASS_StreamCreateFile(True, WaveStream.Memory, 0, WaveStream.Size, 0);


       if chan <> 0
        then begin
          //???
         end
      else begin
          MessageDlg('Fehler beim Erstellen eines Streams aus der Aufnahme!',
                    mtError, [mbOk], 0);
        end;  // if
    end;  // procedure StopRecording

  (* RecordButtonClick || Start Aufnahme *)
  procedure TFormular.RecExecute(Sender: TObject);
    begin
      if BASS_ChannelIsActive(rchan) = BASS_Active_Stopped  then  // Aufnahme starten
        begin

          if BASS_ChannelIsActive(chan) <> BASS_Active_Stopped then
            begin
              BASS_ChannelStop(chan);
              //ProgressBar.Position := ProgressBar.Max;
              StartRecording;
            end
          else
          begin
            //ProgressBar.Position := ProgressBar.Max;
            StartRecording;
          end;  // if
          RecToggleStatus(8);

        end
      else if BASS_ChannelIsActive(rchan) = BASS_Active_Playing then  // Aufnahme beenden
        begin
          StopRecording;
          RecToggleStatus(3);
      end;
    end;  //procedure RecExecute

Es kann doch eigentlich nich so schwer sein beim Start der Aufnahme vom vorhandenen Stream alles aber der aktuellen Position des Streams zu löschen und dort die Aufnahme fortzuseten, oder doch?


MfG Ducksoul

[Ducksoul]

Keiner ne Idee? :(

[riko.delphipraxis]

Hallo,

das sollte ja nicht so schwer sein...

RecPos := ** Position wo weiter aufgenommen werden soll **
// Zwischenspeicher anlegen
BufStream := TMemoryStream.Create;
BufStream.SetSize(RecPos);
// Wavedaten in Zwischenspeicher kopieren
Move(WaveStream.Memory^,BufStream.Memory^,RecPos);
// WaveStream abschneiden
WaveStream.SetSize(RecPos);
// Wavedaten rückkopieren
Move(BufStream.Memory^,WaveStream.Memory^,RecPos);
BufStream.Free;
// Position setzen
WaveStream.Position:=RecPos;

** weiter aufnehmen...

Habs jetzt zwar nicht ausprobiert, aber sollte eigentlich funktionieren...

Anmerkung: :warn:
Beim Start der Aufnahme schreibst du anscheinend immer wieder an die aktuelle Position den Wave-Header...

[Ducksoul]

So sieht die abgeänderte Version aus. Jetzt wird der Header nicht jedes mal neu geschrieben. Das war mir heute morgen schon aufgefallen, aber das abzuändern hatte leider nichts gebracht.
Das Problem mit dem Rauschen besteht aber leider immernoch, komischerweise nicht immer, sondern nur manchmal.

Kann es sein, dass aus mir unbekannten Gründen der Stream manchmal vorhandene Daten überschreibt und daher das Rauschen entsteht? Da ich keine Ahnung habe woran das Verhalten überhaupt liegen kann, weiß ich nichmal wie ich das Problem angehen kann :(

Delphi-Quellcode:

  (* Aufnahme Start *)
  procedure TFormular.StartRecording;
    var
      vol: Float;
      i, RecPos: Integer;
      Flag: DWord;
    begin

      if WaveStream.Size = 0 then
        begin
         // Header für WAV-File generieren
       with WaveHdr do
        begin
            riff := 'RIFF';
            len := 36;
            cWavFmt := 'WAVEfmt ';
            dwHdrLen := 16;
            wFormat := 1;
            wNumChannels := 2;
            dwSampleRate := 44100;
            wBlockAlign := 4;
            dwBytesPerSec := 176400;
            wBitsPerSample := 16;
            cData := 'data';
            dwDataLen := 0;
        end;  // with

         WaveStream.Write(WaveHdr, SizeOf(WAVHDR));
         i := 0;
        end
      else
        begin
          if Rec_Overwrite.Checked = True then
            begin
                // hier ab aktueller Position Aufnahme fortsetzen
              (*WaveStream.Seek(GetPos, soFromBeginning);

              if WaveStream.Position < SizeOf(WaveHDR) then
                WaveStream.Seek(SizeOf(WaveHDR)+1, soFromBeginning);

              WaveStream.SetSize(WaveStream.Position);
              WaveStream.Seek(0, soFromEnd);
              Edit1.Text := IntToStr(WaveStream.Size); *)

              RecPos := GetPos;
                // Zwischenspeicher anlegen
              BufStream := TMemoryStream.Create;
              BufStream.SetSize(RecPos);
                // Wavedaten in Zwischenspeicher kopieren
              Move(WaveStream.Memory^,BufStream.Memory^,RecPos);
                // WaveStream abschneiden
              WaveStream.SetSize(RecPos);
                // Wavedaten rückkopieren
              Move(BufStream.Memory^,WaveStream.Memory^,RecPos);
              BufStream.Free;
                // Position setzen
              WaveStream.Position := RecPos;
            end;  // if

          if Rec_Passage.Checked = True then
            begin
                // hier an aktueller Position Passage einfügend
            end;  // if
        end;  // if


        vol := RecordPegelBar.Position/100;
         while BASS_RecordSetInput(i, BASS_INPUT_OFF, vol)
          do i := i + 1;


          //             ---LoWord--  ----HiWord----
        Flag := MakeLong(c16BitAudio, cRecordingTime);
           // Aufnahmebeginn @ 44100hz 16-bit stereo
         rchan := BASS_RecordStart(cSamplerate,
                                  cNumChannels,
                                  Flag,
                                  @RecordingCallback,
                                  nil);

         if rchan = 0
          then begin
              MessageDlg('Aufnahme konnte nicht gestartet werden!',
                        mtError, [mbOk], 0);
              WaveStream.Clear;
           end;
    end;  // procedure StartRecording

Danke trotzdem,
Duck

[riko.delphipraxis]

Wann rauscht was wo? :gruebel:

[omata]

Wegen Nicht-Beachtung gelöscht.

[riko.delphipraxis]

Wenn du was in deinen Wave-Stream einfügen willst nimmst du für diesen Modus am einfachsten einen neuen Stream in der Callback-Funktion.

Etwa so, ohne Funktionsgarantie...
Einfügeposition merken
InsertStream anlegen und in Callback verwenden
nach Aufnahmeende Zwischenspeicher anlegen
WaveStream bis zur Einfügeposition in Zwischenspeicher schreiben
InsertStream in Zwischenspeicher anhängen
Rest des Wavestreams in Zwischenspeicher anhängen
WaveStream Größe neu setzen
Zwischenspeicher in Wavestream rückkopieren
Länge im Wavehader anpassen

function RecordingCallback....

if Rec_Passage.Checked then
Formular.InsertStream.Write(buffer^, length)
else Formular.WaveStream.Write(buffer^, length);
...


procedure TFormular.StartRecording;
...
if Rec_Passage.Checked then
InsertPos := GetPos;
InsertStream := TMemoryStream.Create;
end if;
...


procedure TFormular.StopRecording;
...
if Rec_Passage.Checked then
begin
BufStream := TMemoryStream.Create;
BufStream.Write(WaveStream.Memory^,InsertPos);
BufStream.Write(InsertStream.Memory^,InsertStream. Size);
BufStream.Write(PByteArray(WaveStream.Memory)^[InsertPos],WaveStream.Size-InsertPos);
WaveStream.SetSize(BufStream.Size);
Move(BufStream.Memory^,WaveStream.Memory^,BufStrea m.Size);
BufStream.Free;
InsertStream.Free;
end;

// WAV-Header komplettieren
WaveStream.Position := 4;
i := WaveStream.Size - 8;
....


So ähnlich muss das klappen ohne das was rauscht...

Und ich geh jetzt auf den Federnball...

[Ducksoul]

Guten Morgen,

also mein Code sieht nun wie folgt aus, aber das Rauschen besteht immernoch. Aber mir ist eingefallen woran es eventuell liegen könnte:

(* Angenommen ich nehme was auf, dann wird am Ende ja der Waveheader komplettiert. Nehme ich was neues auf, dann wird die vorige Datei mit kompletten Waveheader genommen und der Waveheader am Ende nochmal komplettiert und so weiter und sofort. Könnte das die Ursache sein? *)

Edit: Ich habe es jetzt so gelöst, dass der WaveStream ohne komplettierten Header in einen Zwischenspeicher BufStream2 gespeichert wird und beim Zusammenführen dann aus diesem gelesen wird und nicht aus dem WaveStream mit komplettierten Header.(siehe Code) Das Problem besteht trotzdem noch...

Wenn ja fragt sich dann nur noch, wie ich den Waveheader dann jedesmal zurückkomplettiere, um es mal so auszudrücken ^^

Delphi-Quellcode:

(******************************************************************************)
(*                             CallBack-Routine                               *)
(******************************************************************************)
  (* Callback WaveStream *)
  function RecordingCallback(Handle: HRECORD; buffer: Pointer; length, user: DWord): boolean; stdcall;
    begin
        // Kopiere neuen Bufferinhalt in den Memory Buffer
       Formular.WaveStream.Write(buffer^, length);
        // Weiteres Aufnehmen erlauben
       Result := True;

    end;  // function Callback

  (* Callback InsertStream *)
  function RecordingInsertCallback(Handle: HRECORD; buffer: Pointer; length, user: DWord): boolean; stdcall;
    begin
        // Kopiere neuen Bufferinhalt in den Memory Buffer
       Formular.InsertStream.Write(buffer^, length);
        // Weiteres Aufnehmen erlauben
       Result := True;

    end;


(******************************************************************************)
(*                          Start und Stop Aufnahme                           *)
(******************************************************************************)
  (* Aufnahme Start *)
  procedure TFormular.StartRecording;
    var
      vol: Float;
      i: Integer;
      Flag: DWord;
    begin
      InsertRec := False;

      vol := RecordPegelBar.Position/100;
      while BASS_RecordSetInput(i, BASS_INPUT_OFF, vol)
        do i := i + 1;

      if WaveStream.Size = 0 then
        begin
           // Header für WAV-File generieren

           with WaveHdr do
            begin
                riff := 'RIFF';
                len := 36;
                cWavFmt := 'WAVEfmt ';
                dwHdrLen := 16;
                wFormat := 1;
                wNumChannels := 2;
                dwSampleRate := 44100;
                wBlockAlign := 4;
                dwBytesPerSec := 176400;
                wBitsPerSample := 16;
                cData := 'data';
                dwDataLen := 0;
            end;  // with

           WaveStream.Write(WaveHdr, SizeOf(WAVHDR));
           i := 0;

            //             ---LoWord--  ----HiWord----
          Flag := MakeLong(c16BitAudio, cRecordingTime);
           // Aufnahmebeginn @ 44100hz 16-bit stereo
           rchan := BASS_RecordStart(cSamplerate,
                                    cNumChannels,
                                    Flag,
                                    @RecordingCallback,
                                    nil);
        end
      else
        begin
          InsertRec := True;

          if Rec_Overwrite.Checked = True then
            begin
              try
                InsertPos := GetPos;
                InsertStream := TMemoryStream.Create;

                  //             ---LoWord--  ----HiWord----
                Flag := MakeLong(c16BitAudio, cRecordingTime);
                   // Aufnahmebeginn @ 44100hz 16-bit stereo
                 rchan := BASS_RecordStart(cSamplerate,
                                          cNumChannels,
                                          Flag,
                                          @RecordingInsertCallback,
                                          nil);
              except
                InsertStream.Free;
              end;  // try
            end;  // if

          if Rec_Passage.Checked = True then
            begin
                // hier an aktueller Position Passage einfügen
            end;  // if
        end;  // if

         if rchan = 0
          then begin
              MessageDlg('Aufnahme konnte nicht gestartet werden!',
                        mtError, [mbOk], 0);
              WaveStream.Clear;
           end;
    end;  // procedure StartRecording

  (* Stop recording *)
  procedure TFormular.StopRecording;
    var
       i: integer;
    begin
       BASS_ChannelStop(rchan);

      if InsertRec = True then
        begin
          if Rec_Overwrite.Checked = True then
            begin
                // hier Streams zusammenfügen /nach aktueller Posi fortfahren
              try
                BufStream := TMemoryStream.Create;
                BufStream2.Seek(0, soFromBeginning);
                BufStream.Write(BufStream2.Memory^, InsertPos);
                BufStream.Write(InsertStream.Memory^, InsertStream.Size);
                //BufStream.Write(PByteArray(WaveStream.Memory)^[InsertPos],WaveStream.Size-InsertPos);
                WaveStream.SetSize(BufStream.Size);
                Move(BufStream.Memory^, WaveStream.Memory^, BufStream.Size);
              finally
                FreeAndNil(BufStream);
                FreeAndNil(BufStream2);
                FreeAndNil(InsertStream);
              end;  // try
          end;  // if

          if Rec_Passage.Checked = True then
            begin
                // hier BufStream nach neuer Passage anfügen
          end;  // if
      end;  // if

      try
        BufStream2 := TMemoryStream.Create;
        BufStream2.CopyFrom(WaveStream, 0);
      except
        FreeAndNil(BufStream2);
      end;  // try

         // WAV-Header komplettieren
       WaveStream.Position := 4;
       i := WaveStream.Size - 8;
       WaveStream.Write(i, 4);
       i := i - $24;
       WaveStream.Position := 40;
       WaveStream.Write(i, 4);
       WaveStream.Position := 0;

         // Stream für aufgenomme Daten kreieren
       chan := BASS_StreamCreateFile(True, WaveStream.Memory, 0, WaveStream.Size, 0);


       if chan <> 0
        then begin
          //???
         end
      else begin
          MessageDlg('Fehler beim Erstellen eines Streams aus der Aufnahme!',
                    mtError, [mbOk], 0);
        end;  // if
    end;  // procedure StopRecording

Edit2:
An folgenden Sachen liegt es denk ich mal nich, aber der Vollständigkeit halber will ich sie trotzdem ma noch reinstellen.

Delphi-Quellcode:

  (* Update der Progressbar *)
  procedure TFormular.RecordTimerTimer(Sender: TObject);
    var t, t2: integer;
    begin
      ProgressBar.OnChange := nil;
      ProgressBar.Position := Round((BASS_ChannelGetPosition(chan, BASS_POS_BYTE) / BASS_ChannelGetLength(chan, BASS_POS_BYTE)) * 100);
      ProgressBar.OnChange := ProgressBarChange;

      if (chan <> 0) then
        begin
          t := Round(BASS_ChannelBytes2Seconds(chan,
                    BASS_ChannelGetPosition(chan, BASS_POS_BYTE)));
          t2 := Round(BASS_ChannelBytes2Seconds(chan,
                    BASS_ChannelGetLength(chan, BASS_POS_BYTE)));
        progresstimeLabel.Caption := Format('%.2d:%.2d',[t Div 60, t Mod 60]);
        completetimeLabel.Caption := Format('%.2d:%.2d',[t2 Div 60, t2 Mod 60]);
        end;

    end;  // procedure RecordTimerTimer

  (* Position via ProgressBar ändern *)
  procedure TFormular.ProgressBarChange(Sender: TObject);
  var Bool: Boolean;
  begin
    Bool := BASS_ChannelIsActive(chan) = BASS_ACTIVE_Playing;

    if Bool then BASS_ChannelPause(chan);

    BASS_ChannelSetPosition(chan, ProgressBar.Position
    * BASS_ChannelGetLength(chan, BASS_POS_BYTE) div 100, BASS_POS_BYTE);

    if Bool then BASS_ChannelPlay(chan, False);

  end;  // procedure ProgressBarChange

  (* Position des Chans ermitteln *)
  function TFormular.GetPos: Integer;
    begin
      Result := Round((ProgressBar.Position
                      * BASS_ChannelGetLength(chan, BASS_POS_BYTE)) / 100);
    end;  // function GetPos

[riko.delphipraxis]

Der Sinn von BufStream2 erschliesst sich mir nicht... :gruebel:

Wenn du der Meinung bist das dein "rauschen" an der Aufnahme mit dem Wavestream liegt, wieso nimmst du dann nicht einen Stream zum "recorden" und den anderen für dein Ergebnis.

So hast du nur eine Callback und immer einen leeren Stream zum aufnehmen.Bei Aufnahmeende kannst du mit den Recordingdaten machen was du willst...anhängen, einfügen, ...

Und danach korrigierst du den Waveheader im Ergebnis-Stream.
:hi:

[Ducksoul]

Also das mit dem BufStream2 war nur ein Test in meiner Not. Inzwischen habe ich das auch schon wieder geändert.

Ob das Rauschen am WaveStream liegt weiß ich nich genau, da ich den Fehler nicht eingrenzen kann, aber das muss es ja sein. Ich hoffe, dass dein Tipp mich jetzt weiterbringt, aber große Hoffnung hab ich nicht mehr.

Und morgen muss ich eigentlich fertig werden mit dem Projekt... Oh man... ^^

MfG

[Ducksoul]

Nabend,
ich muss mich leider nochmal melden. Ich weiß einfach nicht woran der Fehler liegen kann. Falls interesse besteht würde ich auch mal den kompletten Source an jemanden schicken, falls das einer mal testen möchte... Das Programm muss diese Woche fertig werden und ich bekomm einfach den Fehler nicht in den Griff....

Hier der aktuelle Code:

Delphi-Quellcode:

  (* Callback RecStream *)
  function RecordingCallback(Handle: HRECORD; buffer: Pointer; length, user: DWord): boolean; stdcall;
    begin
        // Kopiere neuen Bufferinhalt in den Memory Buffer
      Formular.RecStream.Write(buffer^, length);
        // Weiteres Aufnehmen erlauben
      Result := True;
    end;  // function Callback WaveStream
(******************************************************************************)

  (* Aufnahme Beginnen *)
  procedure TFormular.StartRecording;
    var
      i: Integer;
      Flag: DWord;
    begin
      InsertPos := Round((ProgressBar.Position
                      * BASS_ChannelGetLength(chan, BASS_POS_BYTE)) / 100);;

      RecStream := TMemoryStream.Create;
          //             ---LoWord--  ----HiWord----
      Flag := MakeLong(c16BitAudio, cRecordingTime);
          // Aufnahmebeginn @ 44100hz 16-bit stereo
      rchan := BASS_RecordStart(cSamplerate,
                                cNumChannels,
                                Flag,
                                @RecordingCallback,
                                nil);


        // Prüfen, ob Aufnahme erfolgreich gestartet
      if rchan = 0
        then begin
          MessageDlg('Aufnahme konnte nicht gestartet werden!',
                      mtError, [mbOk], 0);
          RecStream.Clear;
      end;  // if rchan = 0
    end;  // procedure StartRecording
(******************************************************************************)

  (* Aufnahme Beenden *)
  procedure TFormular.StopRecording;
    var
       i: integer;
       HeaderStream, InsertBufStream: TMemoryStream;
    begin
          // Aufnahmekanal stoppen
      BASS_ChannelStop(rchan);
      try
              // Header für WAV-File generieren
          with WaveHdr do
            begin
              wNumChannels := 1;
              wBitsPerSample := 16;
              wBlockAlign := wNumChannels * (wBitsPerSample div 8);
              dwSampleRate := 44100;
              dwBytesPerSec := dwSampleRate * wBlockAlign;
              riff := 'RIFF';
              len := 36;
              cWavFmt := 'WAVEfmt ';
              dwHdrLen := 16;
              wFormat := 1;
              cData := 'data';
              dwDataLen := 0;
            end;  // with

              // Header in Aufnahmestream schreiben
          HeaderStream := TMemoryStream.Create;
          HeaderStream.Write(WaveHdr, SizeOf(WAVHDR));
          i := 0;

          if WaveStream.Size = 0 then
            begin
                  // Aufnahme ohne Header zwischenspeichern
              BufStream := TMemoryStream.Create;
              RecStream.Seek(0, soFromBeginning);
              BufStream.Write(RecStream.Memory^, RecStream.Size);

              WaveStream.Write(HeaderStream.Memory^, HeaderStream.Size);
              WaveStream.Write(RecStream.Memory^, RecStream.Size);
            end
          else
            begin
              InsertBufStream := TMemoryStream.Create;
              BufStream.Seek(0, soFromBeginning);
              InsertBufStream.Write(HeaderStream.Memory^, HeaderStream.Size);
              InsertBufStream.Write(BufStream.Memory^, InsertPos-HeaderStream.Size);
              InsertBufStream.Write(RecStream.Memory^, RecStream.Size);
              WaveStream.SetSize(InsertBufStream.Size);
              Move(InsertBufStream.Memory^, WaveStream.Memory^
                    , InsertBufStream.Size);

              Edit1.Text := IntToStr(InsertPos);

              BufStream.SetSize(InsertBufStream.Size - HeaderStream.Size);
              InsertBufStream.Seek(HeaderStream.Size, soFromBeginning);
              BufStream.Write(InsertBufStream.Memory^, InsertBufStream.Size - HeaderStream.Size);

              InsertBufStream.Free;
            end;

          (*    if Rec_Overwrite.Checked = True then
                begin
                    // hier Streams zusammenfügen /nach aktueller Posi fortfahren
                  try
                    BufStream := TMemoryStream.Create;
                    BufStream.CopyFrom(WaveStream, InsertPos);
                    BufStream.CopyFrom(RecStream,0);
                    WaveStream.Position := 0;
                    WaveStream.CopyFrom(BufStream, 0);
                  finally
                    FreeAndNil(BufStream);
                  end;  // try
              end;  // if Rec_Overwrite.Checked *)
        finally
          RecStream.Free;
          HeaderStream.Free;
        end;

          (*if Rec_Passage.Checked = True then
            begin
                // hier BufStream nach neuer Passage anfügen
              try
                BufStream := TMemoryStream.Create;
                BufStream.Write(WaveStream.Memory^, InsertPos);
                BufStream.Write(InsertStream.Memory^, InsertStream.Size);
                BufStream.Write(PByteArray(WaveStream.Memory)^[InsertPos],WaveStream.Size-InsertPos);
                WaveStream.SetSize(BufStream.Size);
                Move(BufStream.Memory^, WaveStream.Memory^, BufStream.Size);
              finally
                FreeAndNil(BufStream);
                FreeAndNil(InsertStream);
              end;  // try
          end;  // if Rec_Passage.Checked
      end;  // if InsertRec *)

          // WAV-Header komplettieren
      WaveStream.Position := 4;
      i := WaveStream.Size - 8;
      WaveStream.Write(i, 4);
      i := i - $24;
      WaveStream.Position := 40;
      WaveStream.Write(i, 4);
      WaveStream.Position := 0;

          // Wiedergabestream kreieren
      chan := BASS_StreamCreateFile(True, WaveStream.Memory, 0, WaveStream.Size, 0);

          // Prüfen, ob Wiedergabestream erfolgreich erstellt
      if chan = 0
        then
          MessageDlg('Fehler beim Erstellen eines Streams aus der Aufnahme!',
                      mtError, [mbOk], 0);
    end;  // procedure StopRecording

Viele Grüße

[Ducksoul]

Also kann mir keiner mit dem Problem helfen, oder zumindest ahnen woran der Fehler jetzt liegt?