public void Convert(string inputFile, string outputFile)
        {
            using (var outputStream = File.Create(outputFile))
            {
                var channels = AudioSampleReader.ReadChannels(inputFile, out var waveFormat);

                var oggStream = new OggStream(StaticRandom.Rng.Next());

                // Build header
                var headerBuilder  = new HeaderPacketBuilder();
                var audioInfo      = VorbisInfo.InitVariableBitRate(channels.Count, waveFormat.SampleRate, 0.1f);
                var infoPacket     = headerBuilder.BuildInfoPacket(audioInfo);
                var commentsPacket = headerBuilder.BuildCommentsPacket(new Comments());
                var booksPacket    = headerBuilder.BuildBooksPacket(audioInfo);
                oggStream.PacketIn(infoPacket);
                oggStream.PacketIn(commentsPacket);
                oggStream.PacketIn(booksPacket);
                WriteHeader(oggStream, outputStream);

                // Store audio
                var processingState    = ProcessingState.Create(audioInfo);
                var normalizedChannels = Normalize(channels);
                processingState.WriteData(normalizedChannels, normalizedChannels[0].Length);
                processingState.WriteEndOfStream();
                WriteAudio(oggStream, outputStream, processingState);
            }
        }
Example #2
0
        public void Play(byte track, bool looping)
        {
            if (_noAudio == false)
            {
                trackid   = track.ToString("00");
                trackpath = string.Format("{0}/{1}/music/track{2}.ogg", qparam.globalbasedir, qparam.globalgameid, trackid);
#if DEBUG
                Console.WriteLine("DEBUG: track path:{0} ", trackpath);
#endif
                try
                {
                    _isLooping = looping;
                    if (oggStream != null)
                    {
                        oggStream.Stop();
                    }
                    oggStream          = new OggStream(trackpath, 3);
                    oggStream.IsLooped = looping;
                    oggStream.Play();
                    oggStream.Volume = _Volume;
                    _noPlayback      = false;
                }
                catch (Exception e)
                {
                    Console.WriteLine("Could not find or play {0}", trackpath);
                    _noPlayback = true;
                    //throw;
                }
            }
        }
Example #3
0
        private void PlatformInitialize(string fileName)
        {
            stream = new OggStream(fileName, OnFinishedPlaying);
            stream.Prepare();

            _duration = stream.GetLength();
        }
Example #4
0
        public void Register(string name)
        {
            var fileName = string.Format("{0}/{1}/{2}.ogg", _content.RootDirectory, _soundsDirectoryName, name);
            var stream   = new OggStream(fileName);

            _sounds.Add(name, new Sound(stream, SoundState.Stopped));
        }
    private static void InitOggStream(int sampleRate, int channels, out OggStream oggStream, out ProcessingState processingState)
    {
        // Stores all the static vorbis bitstream settings
        var info = VorbisInfo.InitVariableBitRate(channels, sampleRate, 0.5f);

        // set up our packet->stream encoder
        var serial = new Random().Next();

        oggStream = new OggStream(serial);

        // =========================================================
        // HEADER
        // =========================================================
        // Vorbis streams begin with three headers; the initial header (with
        // most of the codec setup parameters) which is mandated by the Ogg
        // bitstream spec.  The second header holds any comment fields.  The
        // third header holds the bitstream codebook.
        var comments = new Comments();

        comments.AddTag("ARTIST", "TTS");

        var infoPacket     = HeaderPacketBuilder.BuildInfoPacket(info);
        var commentsPacket = HeaderPacketBuilder.BuildCommentsPacket(comments);
        var booksPacket    = HeaderPacketBuilder.BuildBooksPacket(info);

        oggStream.PacketIn(infoPacket);
        oggStream.PacketIn(commentsPacket);
        oggStream.PacketIn(booksPacket);

        // =========================================================
        // BODY (Audio Data)
        // =========================================================
        processingState = ProcessingState.Create(info);
    }
Example #6
0
        public OggStream GetCue(string name, bool asyncPrecache = false)
        {
            OggStream oggStream = (OggStream)null;

            try
            {
                string str  = name.Replace(" ^ ", "\\");
                bool   flag = name.Contains("Ambience");
                oggStream = new OggStream(this.MusicAliases[str.ToLower(CultureInfo.InvariantCulture)], 6)
                {
                    Category = flag ? "Ambience" : "Music",
                    IsLooped = flag
                };
                oggStream.RealName = name;
                oggStream.Prepare(asyncPrecache);
                if (name.Contains("Gomez"))
                {
                    oggStream.LowPass = false;
                }
            }
            catch (Exception ex)
            {
                Logger.Log("SoundManager", LogSeverity.Error, ex.Message);
            }
            return(oggStream);
        }
 private static void WriteHeader(OggStream oggStream, Stream outputStream)
 {
     while (oggStream.PageOut(out var page, true))
     {
         outputStream.Write(page.Header, 0, page.Header.Length);
         outputStream.Write(page.Body, 0, page.Body.Length);
     }
 }
 private static void FlushPages(OggStream oggStream, Stream output, bool force)
 {
     while (oggStream.PageOut(out OggPage page, force))
     {
         output.Write(page.Header, 0, page.Header.Length);
         output.Write(page.Body, 0, page.Body.Length);
     }
 }
Example #9
0
 public static void StartStream(string file, float volume = 1.0f)
 {
     if (SoundManager.Disabled)
     {
         return;
     }
     stream = SoundManager.StartStream(file, volume);
 }
Example #10
0
        /// <summary>
        /// VorbisFileWriter that actually writes to a stream
        /// </summary>
        /// <param name="outStream">Stream to be written to</param>
        /// <param name="sampleRate">The sample rate to use</param>
        /// <param name="channels">The number of channels to use</param>
        /// <param name="quality">The base quality for Vorbis encoding</param>
        public VorbisFileWriter(Stream outStream, int sampleRate, int channels, float quality = 0.5f)
        {
            this.outStream = outStream;
            SampleRate     = sampleRate;
            Channels       = channels;

            if (!startBuffers.ContainsKey(sampleRate))
            {
                throw new InvalidOperationException($"Vorbis writer does not support {sampleRate} sample rate.");
            }

            // Stores all the static vorbis bitstream settings
            Console.WriteLine($"Initiating variable bit rate: {channels} channels, {sampleRate} sample rate, {quality} quality");
            var info = VorbisInfo.InitVariableBitRate(channels, sampleRate, quality);

            // set up our packet->stream encoder
            var serial = MainWindow.MainRandom.Next();

            oggStream = new OggStream(serial);

            // =========================================================
            // HEADER
            // =========================================================
            // Vorbis streams begin with three headers; the initial header (with
            // most of the codec setup parameters) which is mandated by the Ogg
            // bitstream spec.  The second header holds any comment fields.  The
            // third header holds the bitstream codebook.
            var headerBuilder = new HeaderPacketBuilder();

            var comments = new Comments();

            var infoPacket     = headerBuilder.BuildInfoPacket(info);
            var commentsPacket = headerBuilder.BuildCommentsPacket(comments);
            var booksPacket    = headerBuilder.BuildBooksPacket(info);

            oggStream.PacketIn(infoPacket);
            oggStream.PacketIn(commentsPacket);
            oggStream.PacketIn(booksPacket);

            // Flush to force audio data onto its own page per the spec
            FlushPages(oggStream, outStream, true);

            // =========================================================
            // BODY (Audio Data)
            // =========================================================
            processingState = ProcessingState.Create(info);

            // Append some zeros at the start so the result has the same length as the input
            int bufferSize = startBuffers[sampleRate];

            float[][] outSamples = new float[channels][];
            for (int ch = 0; ch < channels; ch++)
            {
                outSamples[ch] = new float[bufferSize];
            }

            processingState.WriteData(outSamples, bufferSize);
        }
Example #11
0
 public void CutOff()
 {
     if (this.currentCue != null)
     {
         this.currentCue.Stop();
         this.currentCue.Dispose();
     }
     this.currentCue = (OggStream)null;
 }
Example #12
0
        public override void Log(LogEvent eventType, OggStream stream)
        {
            var p = streamOffset[stream];

            switch (eventType)
            {
            case LogEvent.BeginPrepare:
                Write("(*", 7, p.Y);
                SetHOffset(stream, 9);
                break;

            case LogEvent.EndPrepare:
                Write(")", p.X, p.Y);
                SetHOffset(stream, p.X + 1);
                break;

            case LogEvent.Play:
                Write("{", p.X, p.Y);
                SetHOffset(stream, p.X + 1);
                break;

            case LogEvent.Stop:
                Write("}", p.X, p.Y);
                SetHOffset(stream, p.X + 1);
                break;

            case LogEvent.Pause:
                Write("[", p.X, p.Y);
                SetHOffset(stream, p.X + 1);
                break;

            case LogEvent.Resume:
                Write("]", p.X, p.Y);
                SetHOffset(stream, p.X + 1);
                break;

            case LogEvent.Empty:
                Write(new string(Enumerable.Repeat(' ', Console.BufferWidth - 6).ToArray()), 6, p.Y);
                SetHOffset(stream, 7);
                break;

            case LogEvent.NewPacket:
                Write(".", p.X, p.Y);
                SetHOffset(stream, p.X + 1);
                break;

            case LogEvent.LastPacket:
                Write("|", p.X, p.Y);
                SetHOffset(stream, p.X + 1);
                break;

            case LogEvent.BufferUnderrun:
                Write("!", p.X, p.Y);
                SetHOffset(stream, p.X + 1);
                break;
            }
        }
Example #13
0
 public void UpdatePrecache()
 {
     if (this.nextCuePrecached || this.strayCues.Count != 0 || OggStreamer.Instance.PendingPrecaches != 0)
     {
         return;
     }
     this.nextCue          = this.SoundManager.GetCue(this.Loop.Name, true);
     this.nextCuePrecached = true;
 }
Example #14
0
        public void SetMusic(string se, bool looping)
        {
            float volume = game.settings.musVolume;

            if (game.settings.mutedMusic)
            {
                volume = 0;
            }
            if (File.Exists(game.Content.RootDirectory + game.PathSeperator + "Music" + game.PathSeperator + se + ".ogg"))
            {
                if (currentMusic == se)
                {
                    return;
                }
                currentMusic = se;
                if (music != null)
                {
                    music.Stop();
                }
            }
            else
            {
                currentMusic = "";
                music.Stop();
                Console.WriteLine("PANIC: MUSIC FILE " + se + " NOT FOUND");
                return;
            }
            if (se != currentMusic || music == null)
            {
                if (music != null)
                {
                    music.Stop();
                    music.Dispose();
                    music = null;
                }
                music          = new OggStream(game.Content.RootDirectory + game.PathSeperator + "Music" + game.PathSeperator + se + ".ogg");
                music.IsLooped = looping;
                music.Volume   = volume;
                music.Play();
                currentMusic = se;
            }
            else
            {
                if (music.IsFinished())
                {
                    music.Stop();
                    music.Dispose();
                    music          = null;
                    music          = new OggStream(game.Content.RootDirectory + game.PathSeperator + "Music" + game.PathSeperator + se + ".ogg");
                    music.IsLooped = looping;
                    music.Volume   = volume;
                    music.Play();
                    currentMusic = se;
                }
            }
        }
Example #15
0
 private static void FlushPages(OggStream oggStream, Stream Output, bool Force)
 {
     while (oggStream.PageOut(out var page, Force))
     {
         //Console.WriteLine($"Writing page header with {page.Header.Length} bytes of data");
         Output.Write(page.Header, 0, page.Header.Length);
         //Console.WriteLine($"Writing page body with {page.Body.Length} bytes of data");
         Output.Write(page.Body, 0, page.Body.Length);
     }
 }
Example #16
0
        void PlatformDispose(bool disposing)
        {
            if (stream == null)
            {
                return;
            }

            stream.Dispose();
            stream = null;
        }
Example #17
0
        private void PlatformInitialize(string fileName)
        {
            // init OpenAL if need be
            OpenALSoundController.EnsureInitialized();

            stream = new OggStream(fileName, OnFinishedPlaying);
            stream.Prepare();

            _duration = stream.GetLength();
        }
Example #18
0
        private static void FlushPages(OggStream oggStream, Stream Output, bool Force)
        {
            OggPage page;

            while (oggStream.PageOut(out page, Force))
            {
                Output.Write(page.Header, 0, page.Header.Length);
                Output.Write(page.Body, 0, page.Body.Length);
            }
        }
Example #19
0
        public void Dispose()
        {
            if (_stream == null)
            {
                return;
            }

            Stop();
            _stream.Dispose();
            _stream = null;
        }
Example #20
0
 public ActiveAmbienceTrack(AmbienceTrack track, bool activeForDayPhase)
 {
     ServiceHelper.InjectServices((object)this);
     this.volume            = 0.0f;
     this.ActiveForDayPhase = activeForDayPhase;
     this.OnMuteStateChanged();
     this.Track      = track;
     this.cue        = this.SoundManager.GetCue(this.Track.Name, false);
     this.cue.Volume = this.volume;
     this.cue.Play();
 }
Example #21
0
        void PlatformDispose(bool disposing)
        {
            lock (_sourceMutex)
            {
                if (stream == null)
                {
                    return;
                }

                stream.Dispose();
                stream = null;
            }
        }
Example #22
0
        public override bool TryDecode(IList<Page> pages, IList<Packet> packets, out OggStream stream)
        {
            stream = null;
            //we need a minimum of free packets for id, comment and setup header
            if (packets.Count < 3)
                return false;

            if (!IsVorbisStream(packets[0], packets[1], packets[2]))
                return false;

            stream = Decode(pages, packets);
            return true;
        }
Example #23
0
 private void Play()
 {
     if (!this.nextCuePrecached)
     {
         this.nextCue = this.SoundManager.GetCue(this.Loop.Name, false);
     }
     this.nextCue.Volume = this.volume;
     this.nextCue.Play();
     if (this.currentCue != null)
     {
         this.strayCues.Add(this.currentCue);
     }
     this.currentCue       = this.nextCue;
     this.barsToCount      = this.Loop.Duration;
     this.nextCuePrecached = false;
 }
        private static void WriteAudio(
            OggStream oggStream,
            Stream outputStream,
            ProcessingState processingState)
        {
            while (!oggStream.Finished && processingState.PacketOut(out var packet))
            {
                oggStream.PacketIn(packet);

                while (!oggStream.Finished && oggStream.PageOut(out var page, false))
                {
                    outputStream.Write(page.Header, 0, page.Header.Length);
                    outputStream.Write(page.Body, 0, page.Body.Length);
                }
            }
        }
Example #25
0
        static void FadeVolume(List <OggStream> streams, bool @in, float duration, ConsoleLogger logger)
        {
            int index = 0;

            foreach (var stream in streams)
            {
                var from  = stream.Volume;
                var to    = @in ? 1f : 0;
                var speed = @in ? 1 - @from : @from;

                lock (volumeFades)
                {
                    CancellationTokenSource token;
                    bool found = volumeFades.TryGetValue(stream, out token);
                    if (found)
                    {
                        token.Cancel();
                        volumeFades.Remove(stream);
                    }
                }
                var sIdx = index++;
                logger.Write(@in ? "V" : "v", 4, 10 + sIdx);

                var cts = new CancellationTokenSource();
                lock (volumeFades) volumeFades.Add(stream, cts);

                var       sw = Stopwatch.StartNew();
                OggStream s  = stream;
                Task.Factory.StartNew(() =>
                {
                    float step;
                    do
                    {
                        step     = (float)Math.Min(sw.Elapsed.TotalSeconds / (duration * speed), 1);
                        s.Volume = (to - @from) * step + @from;
                        Thread.Sleep(1000 / 60);
                    } while (step < 1 && !cts.Token.IsCancellationRequested);
                    sw.Stop();

                    if (!cts.Token.IsCancellationRequested)
                    {
                        lock (volumeFades) volumeFades.Remove(s);
                        logger.Write(" ", 4, 10 + sIdx);
                    }
                }, cts.Token);
            }
        }
Example #26
0
 public ActiveLoop(Loop loop, bool muted, bool activeForDayPhase, bool dontStart)
 {
     ServiceHelper.InjectServices((object)this);
     this.Muted             = muted;
     this.volume            = muted || !activeForDayPhase ? 0.0f : 1f;
     this.ActiveForDayPhase = activeForDayPhase;
     this.OnMuteStateChanged();
     this.Loop             = loop;
     this.nextCuePrecached = true;
     this.nextCue          = this.SoundManager.GetCue(loop.Name, false);
     this.barsBeforePlay   = (float)this.Loop.Delay;
     if (dontStart || this.Loop.Delay != 0)
     {
         return;
     }
     this.FirstPlay();
 }
Example #27
0
        private void ReleaseUnmanagedResources()
        {
            if (processingState != null && oggStream != null && outStream != null)
            {
                processingState.WriteEndOfStream();

                while (!oggStream.Finished && processingState.PacketOut(out var packet))
                {
                    oggStream.PacketIn(packet);

                    FlushPages(oggStream, outStream, false);
                }
                FlushPages(oggStream, outStream, true);
            }
            oggStream       = null;
            processingState = null;
        }
Example #28
0
        private void PlaySoundThread(string assetName, bool loop)
        {
            string fileName = this.GetAsset(assetName).fileName;
            string ext      = fileName.Substring(fileName.LastIndexOf(@".") + 1);

            if (ext == "wav")
            {
                int    channels, bits_per_sample, sample_rate;
                byte[] data = OpenTKUtils.LoadWave(fileName, out channels, out bits_per_sample, out sample_rate);

                int buffer = AL.GenBuffer();
                int source = AL.GenSource();
                AL.BufferData(buffer, OpenTKUtils.WaveFormat(channels, bits_per_sample), data, data.Length, sample_rate);

                AL.Source(source, ALSourcei.Buffer, buffer);
                AL.Source(source, ALSourceb.Looping, loop);


                AL.SourcePlay(source);

                int state;

                do
                {
                    Thread.Sleep(300);
                    AL.GetSource(source, ALGetSourcei.SourceState, out state);
                } while ((ALSourceState)state == ALSourceState.Playing);

                AL.SourceStop(source);
                AL.DeleteSource(source);
                AL.DeleteBuffer(buffer);
            }
            else if (ext == "ogg")
            {
                using (var streamer = new OggStreamer()) {
                    OggStream stream = new OggStream(fileName);
                    stream.Prepare();
                    stream.Play();
                }
            }
            else
            {
                throw new NotImplementedException($"Support for audio extension '{ext}' is not implemented.");
            }
        }
Example #29
0
        public override void Log(LogEvent eventType, OggStream stream)
        {
            switch (eventType)
            {
            //case LogEvent.BeginPrepare:
            //    Write("(*", 7, p.Y);
            //    SetHOffset(stream, 9);
            //    break;
            //case LogEvent.EndPrepare:
            //    Write(")", p.X, p.Y);
            //    SetHOffset(stream, p.X + 1);
            //    break;
            case LogEvent.Play:
                Utility.Log.Info("Playing music stream.");
                break;

            case LogEvent.Stop:
                Utility.Log.Info("Stopping music stream.");
                break;

            case LogEvent.Pause:
                Utility.Log.Info("Pausing music stream.");
                break;

            case LogEvent.Resume:
                Utility.Log.Info("Resuming music stream.");
                break;
            //case LogEvent.Empty:
            //    Write(new string(Enumerable.Repeat(' ', Console.BufferWidth - 6).ToArray()), 6, p.Y);
            //    SetHOffset(stream, 7);
            //    break;
            //case LogEvent.NewPacket:
            //    Write(".", p.X, p.Y);
            //    SetHOffset(stream, p.X + 1);
            //    break;
            //case LogEvent.LastPacket:
            //    Write("|", p.X, p.Y);
            //    SetHOffset(stream, p.X + 1);
            //    break;

            case LogEvent.BufferUnderrun:
                Utility.Log.Warning("Music stream buffer underrun detected.");
                break;
            }
        }
Example #30
0
 public void Dispose()
 {
     if (this.currentCue != null)
     {
         this.currentCue.Stop();
         this.currentCue.Dispose();
         this.currentCue = (OggStream)null;
     }
     this.nextCue.Stop();
     this.nextCue.Dispose();
     this.nextCue = (OggStream)null;
     foreach (OggStream oggStream in this.strayCues)
     {
         oggStream.Stop();
         oggStream.Dispose();
     }
     this.strayCues.Clear();
     this.CycleLink = (Action)null;
 }
Example #31
0
        public MusicManager()
        {
            AudioManager.Initialize();
            this.ambient = new OggStream("data/music/ambient1.ogg");
            //this.Piano = new SimpleInstrument("data/music/Piano.pp.C4_2.ogg", 261.6);
            this.Piano = new Piano();
            //this.Violin = new SRInstrument("data/music/ViolinGis3-loop.ogg", "data/music/ViolinGis3-decay.ogg", 207.7);
            //this.Strings = new SimpleInstrument("data/music/StringsC5.ogg", 523.3);
            //this.Strings = new SRInstrument("data/music/StringsC5-sustain.ogg", "data/music/StringsC5-decay.ogg", 523.3);

            string filename = "data/music/DarkAndLight.bmc";

            //Console.WriteLine("Parsing " + filename);
            this.composition = new BranchingMusicalComposition(filename);

            this.ambient.IsLooped = true;
            this.ambient.Prepare();

            this.Parameters = MusicParameters.Default;
        }
Example #32
0
 public override bool TryDecode(IList<Page> pages, IList<Packet> packets, out OggStream stream)
 {
     stream = new UnknownStream(pages, packets);
     return true;
 }
Example #33
0
 internal bool AddStream(OggStream stream)
 {
     lock (iterationMutex)
         return streams.Add(stream);
 }
Example #34
0
 internal bool RemoveStream(OggStream stream)
 {
     lock (iterationMutex)
         return streams.Remove(stream);
 }
Example #35
0
        public bool TryReadPacket(out Packet packet)
        {
            //Trace.WriteLine ("Entering", "TryReadPacket");
            //Trace.Indent();

            packet = null;

            int lastSegment = 0;
            OggPage page, firstPage;
            OggStream ostream;
            if (!this.continuation)
            {
                //Trace.WriteLine ("Not a continuation, reading page", "TryReadPacket");

                firstPage = page = ReadPage();
                if (page == null)
                {
                    //Trace.Unindent();
                    //Trace.WriteLine ("Exiting (no packet)", "TryReadPacket");
                    return false;
                }

                if (!this.oggStreams.TryGetValue (page.StreamIndex, out ostream))
                {
                    //Trace.WriteLine ("New ogg stream: " + page.StreamIndex, "TryReadPacket");
                    this.oggStreams[page.StreamIndex] = ostream = new OggStream (ReadPage);
                }

                //Trace.WriteLine (String.Format("SI: {0}; G: {1:N0}; S: {2:N0}; SL: {3:N0}", page.StreamIndex, page.GranuleNumber, page.SequenceNumber, page.Segments.Length));

                ostream.Enqueue (page);
            }
            else
            {
                //Trace.WriteLine ("Continuing on page from " + this.lastStreamIndex, "TryReadPacket");

                ostream = this.oggStreams[this.lastStreamIndex];
                if ((firstPage = page = ostream.Peek()) == null && (firstPage = page = ReadPage()) == null)
                {
                    //Trace.Unindent();
                    //Trace.WriteLine ("Exiting (no page)", "TryReadPacket");
                    return false;
                }

                lastSegment = ostream.LastSegment;
                //Trace.WriteLine (this.lastStreamIndex + " Last segment: " + lastSegment, "TryReadPacket");
            }

            List<byte[]> segments = new List<byte[]>();

            int packetLength = 0;
            bool packetEndFound = false;
            while (!packetEndFound)
            {
                int i;
                for (i = lastSegment; i < page.Segments.Length; ++i)
                {
                    int length = page.Segments[i].Length;
                    packetLength += length;
                    segments.Add (page.Segments[i]);

                    //Trace.WriteLine (String.Format ("Segment {0:N0}, length: {1}", i, length), "TryReadPacket");
                    if (length < 255)
                    {
                        packetEndFound = true;
                        i++;
                        break;
                    }
                }

                if (!packetEndFound)
                {
                    //Trace.WriteLine ("Reached end of page, continuing with another", "TryReadPacket");
                    ostream.Dequeue(); // used up whole last page

                    OggPage nextPage;
                    while (true)
                    {
                        if ((nextPage = ostream.Peek()) == null && (nextPage = ReadPage()) == null)
                        {
                            this.continuation = true; // Let's try this stream again next call.
                            this.lastStreamIndex = page.StreamIndex;
                            ostream.Enqueue (page);
                            //Trace.Unindent();
                            //Trace.WriteLine ("Exiting (no page to continue with)", "TryReadPacket");
                            return false;
                        }

                        if (nextPage.StreamIndex != page.StreamIndex)
                        {
                            OggStream nextStream;
                            if (!this.oggStreams.TryGetValue (page.StreamIndex, out nextStream))
                            {
                                //Trace.WriteLine ("New ogg stream: " + page.StreamIndex, "TryReadPacket");
                                this.oggStreams[page.StreamIndex] = nextStream = new OggStream (ReadPage);
                            }

                            nextStream.Enqueue (page);
                        }
                        else
                        {
                            ostream.Enqueue (page);
                            break;
                        }
                    }

                    page = nextPage;
                    lastSegment = 0;
                }
                else
                {
                    ostream.PacketCount++;

                    if (i != page.Segments.Length)
                    {
                        //Trace.WriteLine ("Not done with this page yet (" + i + "/" + page.Segments.Length + ")", "TryReadPacket");
                        this.continuation = true;
                        this.lastStreamIndex = page.StreamIndex;
                        ostream.LastSegment = i;
                    }
                    else
                    {
                        //Trace.WriteLine ("Finished packet", "TryReadPacket");
                        ostream.Dequeue();
                        this.continuation = false;
                    }
                }
            }

            byte[] pdata = AssemblePacket (segments);
            packet = new OggPacket (page.StreamIndex, ostream.PacketCount - 1, firstPage.GranuleNumber, pdata);

            //Trace.Unindent();
            //Trace.WriteLine ("Exiting", "TryReadPacket");

            return true;
        }
Example #36
0
        public bool FillBuffer(OggStream stream, int bufferId)
        {
            int readSamples;
            lock (readMutex)
            {
                readSamples = stream.Reader.ReadSamples(readSampleBuffer, 0, BufferSize);
                CastBuffer(readSampleBuffer, castBuffer, readSamples);
            }
            AL.BufferData(bufferId, stream.Reader.Channels == 1 ? ALFormat.Mono16 : ALFormat.Stereo16, castBuffer,
                readSamples * sizeof (short), stream.Reader.SampleRate);
            ALHelper.Check();

            return readSamples != BufferSize;
        }