Laden...

C# WavStreams mergen: Auf einen geschlossenen Datenstrom kann nicht zugegriffen werden.

Erstellt von filmee24 vor 9 Jahren Letzter Beitrag vor 9 Jahren 3.961 Views
F
filmee24 Themenstarter:in
51 Beiträge seit 2011
vor 9 Jahren
C# WavStreams mergen: Auf einen geschlossenen Datenstrom kann nicht zugegriffen werden.

hallo

ich möchte 2 wav streams verbinden und dieses neue stream dann abspielen

mein code:


using System.IO;

namespace Lib.Util.Audio.TTS
{
    public class WaveIO
    {
        public int length;
        public short  channels;
        public int samplerate;
        public int DataLength;
        public short BitsPerSample;

        private  void WaveHeaderIN(Stream spath)
        {
            Stream fs = spath;
         
            var br = new BinaryReader(fs);
            length = (int)fs.Length - 8;
            fs.Position = 22;
            channels = br.ReadInt16();
            fs.Position = 24;
            samplerate = br.ReadInt32();
            fs.Position = 34;

            BitsPerSample = br.ReadInt16();
            DataLength = (int)fs.Length - 44;
            br.Close ();
            fs.Close();

        }
  
        private  void WaveHeaderOUT(Stream sPath)
        {
            Stream fs = sPath;

            BinaryWriter bw = new BinaryWriter(fs);
            fs.Position = 0;
            bw.Write(new char[4] { 'R', 'I', 'F', 'F' });
       
            bw.Write(length);
          
            bw.Write(new char[] {'W','A','V','E','f','m','t',' '});
          
            bw.Write((int)16);
  
            bw.Write((short)1);
            bw.Write(channels);
        
            bw.Write(samplerate );
       
            bw.Write((int)(samplerate * ((BitsPerSample * channels) / 8)));
        
            bw.Write((short )((BitsPerSample * channels) / 8));
       
            bw.Write(BitsPerSample);
      
            bw.Write(new char[4] {'d','a','t','a'});
            bw.Write(DataLength);
        }
        public void Merge(Stream[] files, Stream outfile)
        {
            var wa_IN = new WaveIO();
            var wa_out = new WaveIO {DataLength = 0, length = 0};


            //Gather header data
            foreach (Stream path in files)
            {
                wa_IN.WaveHeaderIN(@path);
                wa_out.DataLength += wa_IN.DataLength;
                wa_out.length += wa_IN.length;

            }

            //Recontruct new header
            wa_out.BitsPerSample = wa_IN.BitsPerSample;
            wa_out.channels = wa_IN.channels;
            wa_out.samplerate = wa_IN.samplerate;
            wa_out.WaveHeaderOUT(@outfile);

            foreach (var fs in files)
            {
                byte[] arrfile = new byte[fs.Length - 44];
                fs.Position = 44;
                fs.Read(arrfile, 0, arrfile.Length);

                BinaryWriter bw = new BinaryWriter(@outfile);
                bw.Write(arrfile);
            }
        }

       
    }
}


using System.Collections.Generic;
using System.IO;
using Lib.Util.Binary;

namespace Lib.Util.Audio.TTS
{
    public class TTSAudioFile
    {

        internal Dictionary<string, Stream> Data;

        public TTSAudioFile()
        {
            Data = new Dictionary<string, Stream>();
        }

        public static TTSAudioFile Load(Stream f)
        {
            var ret = new TTSAudioFile();
            var br = new Reader(f);

            int length = br.ReadInt32();

            for (var i = 0; i < length; i++)
            {
                ret.Data.Add(br.ReadString(), br.ReadStream());
            }

            return ret;
        }

        public void Save(Stream s)
        {
            var bw = new Writer(s);

            bw.Write(Data.Count);

            foreach (var ks in Data)
            {
                bw.Write(ks.Key);
                bw.Write(ks.Value);
            }
        }


        public void Add(string s, FileStream fileStream)
        {
            Data.Add(s, fileStream);
        }

        public Stream Get(string p)
        {
            return Data[p];
        }
    }
}

var w = new WaveIO();
            var s = new MemoryStream();
            w.Merge(new[] {file.Get("a"), file.Get("b")}, s);

            var player = new SoundPlayer(s);

            player.Play();

wenn ich ein stream von den 2 abspielen lasse geht es, aber es mergt nicht. es kommt der fehler: > Fehlermeldung:

Auf einen geschlossenen Datenstrom kann nicht zugegriffen werden.

bei:


foreach (var fs in files)
            {
                byte[] arrfile = new byte[fs.Length - 44];

ich bin auf eure hifle angewiesen

vielen dank

C. Anders

2.207 Beiträge seit 2011
vor 9 Jahren

Hallo filmee24,

ich hab mir deinen Code nicht komplett angeschaut, weil du ihn einfach komplett hier eingefügt hast. Man hat dann wenig Lust das komplett durchzusehen. Bitte poste nur (und ausschliesslich) den Teil, der Fehler schmeisst.

[Hinweis] Wie poste ich richtig? Punkt 5.

Die Fehlermeldung ist recht eindeutig und danach kann man auch suchen und wird auch hier im Forum fündig.

MemoryStream und Serialisieren

Bei solchen Stream-Sachen arbeite immer mit Usings. Das macht a) den Code übersichtlicher und b) weisst du besser wo etwas geclosed und disposed wird. Und dann sollten solche Sachen schon auffallen respektive gar nicht mehr passieren.

Gruss

Coffeebean