Beispiel #1
0
            public Block(DspState dspState)
            {
                LoadNativeLibrary();

                native = vorbis_block_create();
                vorbis_block_init(dspState.native, native);
            }
Beispiel #2
0
        private void UpdateDspTab()
        {
            DspState        dsp     = _state.Dsp;
            List <RegEntry> entries = new List <RegEntry>();

            Action <int, string> addReg = (int i, string name) => {
                entries.Add(new RegEntry("$" + i.ToString("X2"), name, dsp.Regs[i], Format.X8));
            };

            addReg(0x0C, "Main Volume (MVOL) - Left");
            addReg(0x1C, "Main Volume (MVOL) - Right");
            addReg(0x2C, "Echo Volume (EVOL) - Left");
            addReg(0x3C, "Echo Volume (EVOL) - Right");

            addReg(0x4C, "Key On (KON)");
            addReg(0x5C, "Key Off (KOF)");

            addReg(0x7C, "Source End Block (ENDX)");
            addReg(0x0D, "Echo Feedback (EFB)");
            addReg(0x2D, "Pitch Modulation (PMON)");
            addReg(0x3D, "Noise Enable (NON)");
            addReg(0x4D, "Echo Enable (EON)");
            addReg(0x5D, "Source Directory (Offset) (DIR)");
            addReg(0x6D, "Echo Buffer (Offset) (ESA)");
            addReg(0x7D, "Echo Delay (EDL)");

            entries.Add(new RegEntry("$6C", "Flags (FLG)", null));
            entries.Add(new RegEntry("$6C.0-4", "Noise Clock", dsp.Regs[0x6C] & 0x1F, Format.X8));
            entries.Add(new RegEntry("$6C.5", "Echo Disabled", (dsp.Regs[0x6C] & 0x20) != 0));
            entries.Add(new RegEntry("$6C.6", "Mute", (dsp.Regs[0x6C] & 0x40) != 0));
            entries.Add(new RegEntry("$6C.7", "Reset", (dsp.Regs[0x6C] & 0x80) != 0));

            entries.Add(new RegEntry("$xF", "Coefficients", null));
            for (int i = 0; i < 8; i++)
            {
                addReg((i << 4) | 0x0F, "Coefficient " + i);
            }

            for (int i = 0; i < 8; i++)
            {
                entries.Add(new RegEntry("Voice #" + i.ToString(), "", null));

                int voice = i << 4;
                addReg(voice | 0x00, "Left Volume (VOL)");
                addReg(voice | 0x01, "Right Volume (VOL)");
                entries.Add(new RegEntry("$" + i + "2 + $" + i + "3", "Pitch (P)", dsp.Regs[voice | 0x02] | (dsp.Regs[voice | 0x03] << 8), Format.X16));
                addReg(voice | 0x04, "Source (SRCN)");
                addReg(voice | 0x05, "ADSR1");
                addReg(voice | 0x06, "ADSR2");
                addReg(voice | 0x07, "GAIN");
                addReg(voice | 0x08, "ENVX");
                addReg(voice | 0x09, "OUTX");
            }
            ctrlPropertyDsp.UpdateState(entries);
        }
Beispiel #3
0
        private void DecodeInit()
        {
            convbuffer  = new byte[convsize]; // take 8k out of the data segment, not the stack
            SyncState   = new SyncState();    // sync and verify incoming physical bitstream
            StreamState = new StreamState();  // take physical pages, weld into a logical stream of packets
            Page        = new Page();         // one Ogg bitstream page.  Vorbis packets are inside
            Packet      = new Packet();       // one raw packet of data for decode

            Info     = new Info();            // struct that stores all the static vorbis bitstream settings
            Comment  = new Comment();         // struct that stores all the bitstream user comments
            DspState = new DspState();        // central working state for the packet->PCM decoder
            Block    = new Block(DspState);   // local working space for packet->PCM decode
            bytes    = 0;
        }
        Stream DecodeStream(Stream input, bool skipWavHeader)
        {
            int convsize = 4096 * 2;

            byte[] convbuffer = new byte[convsize]; // take 8k out of the data segment, not the stack

            TextWriter s_err  = new DebugWriter();
            Stream     output = new MemoryStream();

            if (!skipWavHeader)
            {
                output.Seek(HEADER_SIZE, SeekOrigin.Begin); // reserve place for WAV header
            }
            SyncState   oy = new SyncState();               // sync and verify incoming physical bitstream
            StreamState os = new StreamState();             // take physical pages, weld into a logical stream of packets
            Page        og = new Page();                    // one Ogg bitstream page.  Vorbis packets are inside
            Packet      op = new Packet();                  // one raw packet of data for decode

            Info     vi = new Info();                       // struct that stores all the static vorbis bitstream settings
            Comment  vc = new Comment();                    // struct that stores all the bitstream user comments
            DspState vd = new DspState();                   // central working state for the packet->PCM decoder
            Block    vb = new Block(vd);                    // local working space for packet->PCM decode

            byte[] buffer;
            int    bytes = 0;

            // Decode setup

            oy.init(); // Now we can read pages

            while (true)
            { // we repeat if the bitstream is chained
                int eos = 0;

                // grab some data at the head of the stream.  We want the first page
                // (which is guaranteed to be small and only contain the Vorbis
                // stream initial header) We need the first page to get the stream
                // serialno.

                // submit a 4k block to libvorbis' Ogg layer
                int index = oy.buffer(4096);
                buffer = oy.data;
                try
                {
                    bytes = input.Read(buffer, index, 4096);
                }
                catch (Exception e)
                {
                    s_err.WriteLine(e);
                }
                oy.wrote(bytes);

                // Get the first page.
                if (oy.pageout(og) != 1)
                {
                    // have we simply run out of data?  If so, we're done.
                    if (bytes < 4096)
                    {
                        break;
                    }

                    // error case.  Must not be Vorbis data
                    s_err.WriteLine("Input does not appear to be an Ogg bitstream.");
                }

                // Get the serial number and set up the rest of decode.
                // serialno first; use it to set up a logical stream
                os.init(og.serialno());

                // extract the initial header from the first page and verify that the
                // Ogg bitstream is in fact Vorbis data

                // I handle the initial header first instead of just having the code
                // read all three Vorbis headers at once because reading the initial
                // header is an easy way to identify a Vorbis bitstream and it's
                // useful to see that functionality seperated out.

                vi.init();
                vc.init();
                if (os.pagein(og) < 0)
                {
                    // error; stream version mismatch perhaps
                    s_err.WriteLine("Error reading first page of Ogg bitstream data.");
                }

                if (os.packetout(op) != 1)
                {
                    // no page? must not be vorbis
                    s_err.WriteLine("Error reading initial header packet.");
                }

                if (vi.synthesis_headerin(vc, op) < 0)
                {
                    // error case; not a vorbis header
                    s_err.WriteLine("This Ogg bitstream does not contain Vorbis audio data.");
                }

                // At this point, we're sure we're Vorbis.  We've set up the logical
                // (Ogg) bitstream decoder.  Get the comment and codebook headers and
                // set up the Vorbis decoder

                // The next two packets in order are the comment and codebook headers.
                // They're likely large and may span multiple pages.  Thus we reead
                // and submit data until we get our two pacakets, watching that no
                // pages are missing.  If a page is missing, error out; losing a
                // header page is the only place where missing data is fatal. */

                int i = 0;

                while (i < 2)
                {
                    while (i < 2)
                    {
                        int result = oy.pageout(og);
                        if (result == 0)
                        {
                            break;              // Need more data
                        }
                        // Don't complain about missing or corrupt data yet.  We'll
                        // catch it at the packet output phase

                        if (result == 1)
                        {
                            os.pagein(og); // we can ignore any errors here
                            // as they'll also become apparent
                            // at packetout
                            while (i < 2)
                            {
                                result = os.packetout(op);
                                if (result == 0)
                                {
                                    break;
                                }
                                if (result == -1)
                                {
                                    // Uh oh; data at some point was corrupted or missing!
                                    // We can't tolerate that in a header.  Die.
                                    s_err.WriteLine("Corrupt secondary header.  Exiting.");
                                }
                                vi.synthesis_headerin(vc, op);
                                i++;
                            }
                        }
                    }
                    // no harm in not checking before adding more
                    index  = oy.buffer(4096);
                    buffer = oy.data;
                    try
                    {
                        bytes = input.Read(buffer, index, 4096);
                    }
                    catch (Exception e)
                    {
                        s_err.WriteLine(e);
                    }
                    if (bytes == 0 && i < 2)
                    {
                        s_err.WriteLine("End of file before finding all Vorbis headers!");
                    }
                    oy.wrote(bytes);
                }

                // Throw the comments plus a few lines about the bitstream we're
                // decoding
                {
                    byte[][] ptr = vc.user_comments;
                    for (int j = 0; j < vc.user_comments.Length; j++)
                    {
                        if (ptr[j] == null)
                        {
                            break;
                        }
                        s_err.WriteLine(vc.getComment(j));
                    }
                    s_err.WriteLine("\nBitstream is " + vi.channels + " channel, " + vi.rate + "Hz");
                    s_err.WriteLine("Encoded by: " + vc.getVendor() + "\n");
                }

                convsize = 4096 / vi.channels;

                // OK, got and parsed all three headers. Initialize the Vorbis
                //  packet->PCM decoder.
                vd.synthesis_init(vi); // central decode state
                vb.init(vd);           // local state for most of the decode

                // so multiple block decodes can
                // proceed in parallel.  We could init
                // multiple vorbis_block structures
                // for vd here

                float[][][] _pcm   = new float[1][][];
                int[]       _index = new int[vi.channels];
                // The rest is just a straight decode loop until end of stream
                while (eos == 0)
                {
                    while (eos == 0)
                    {
                        int result = oy.pageout(og);
                        if (result == 0)
                        {
                            break;              // need more data
                        }
                        if (result == -1)
                        { // missing or corrupt data at this page position
                            s_err.WriteLine("Corrupt or missing data in bitstream; continuing...");
                        }
                        else
                        {
                            os.pagein(og); // can safely ignore errors at
                            // this point
                            while (true)
                            {
                                result = os.packetout(op);

                                if (result == 0)
                                {
                                    break;              // need more data
                                }
                                if (result == -1)
                                { // missing or corrupt data at this page position
                                  // no reason to complain; already complained above
                                }
                                else
                                {
                                    // we have a packet.  Decode it
                                    int samples;
                                    if (vb.synthesis(op) == 0)
                                    { // test for success!
                                        vd.synthesis_blockin(vb);
                                    }

                                    // **pcm is a multichannel float vector.  In stereo, for
                                    // example, pcm[0] is left, and pcm[1] is right.  samples is
                                    // the size of each channel.  Convert the float values
                                    // (-1.<=range<=1.) to whatever PCM format and write it out

                                    while ((samples = vd.synthesis_pcmout(_pcm, _index)) > 0)
                                    {
                                        float[][] pcm      = _pcm[0];
                                        bool      clipflag = false;
                                        int       bout     = (samples < convsize ? samples : convsize);

                                        // convert floats to 16 bit signed ints (host order) and
                                        // interleave
                                        for (i = 0; i < vi.channels; i++)
                                        {
                                            int ptr = i * 2;
                                            //int ptr=i;
                                            int mono = _index[i];
                                            for (int j = 0; j < bout; j++)
                                            {
                                                int val = (int)(pcm[i][mono + j] * 32767.0);
                                                //        short val=(short)(pcm[i][mono+j]*32767.);
                                                //        int val=(int)Math.round(pcm[i][mono+j]*32767.);
                                                // might as well guard against clipping
                                                if (val > 32767)
                                                {
                                                    val      = 32767;
                                                    clipflag = true;
                                                }
                                                if (val < -32768)
                                                {
                                                    val      = -32768;
                                                    clipflag = true;
                                                }
                                                if (val < 0)
                                                {
                                                    val = val | 0x8000;
                                                }
                                                convbuffer[ptr]     = (byte)(val);
                                                convbuffer[ptr + 1] = (byte)((uint)val >> 8);
                                                ptr += 2 * (vi.channels);
                                            }
                                        }

                                        if (clipflag)
                                        {
                                            //s_err.WriteLine("Clipping in frame "+vd.sequence);
                                        }

                                        output.Write(convbuffer, 0, 2 * vi.channels * bout);

                                        vd.synthesis_read(bout); // tell libvorbis how
                                        // many samples we
                                        // actually consumed
                                    }
                                }
                            }
                            if (og.eos() != 0)
                            {
                                eos = 1;
                            }
                        }
                    }
                    if (eos == 0)
                    {
                        index  = oy.buffer(4096);
                        buffer = oy.data;
                        try
                        {
                            bytes = input.Read(buffer, index, 4096);
                        }
                        catch (Exception e)
                        {
                            s_err.WriteLine(e);
                        }
                        oy.wrote(bytes);
                        if (bytes == 0)
                        {
                            eos = 1;
                        }
                    }
                }

                // clean up this logical bitstream; before exit we see if we're
                // followed by another [chained]

                os.clear();

                // ogg_page and ogg_packet structs always point to storage in
                // libvorbis.  They're never freed or manipulated directly

                vb.clear();
                vd.clear();
                vi.clear();  // must be called last
            }

            // OK, clean up the framer
            oy.clear();
            s_err.WriteLine("Done.");

            output.Seek(0, SeekOrigin.Begin);
            if (!skipWavHeader)
            {
                WriteHeader(output, (int)(output.Length - HEADER_SIZE), vi.rate, (ushort)16, (ushort)vi.channels);
                output.Seek(0, SeekOrigin.Begin);
            }
            return(output);
        }
Beispiel #5
0
        static byte[] convbuffer = new byte[convsize]; // take 8k out of the data segment, not the stack

        #endregion Fields

        #region Methods

        public static void main(String[] arg)
        {
            //Stream output = File.OpenWrite("output.bin");
            var Name = "Output.ogg";
            var OutputBuffer = new MemoryStream();
            Stream input = null;
            //java.io.InputStream input=System.In;
            if (arg.Length > 0)
            {
                try
                {
                    Name = arg[0];
                    input = File.OpenRead(arg[0]);
                }
                catch (Exception e)
                {
                    Console.Error.WriteLine(e);
                }
            }
            else
            {
                throw (new NotImplementedException("aaaa"));
            }

            if (input == null) throw (new NotImplementedException("bbb"));

            var SyncState = new SyncState(); // sync and verify incoming physical bitstream
            var StreamState = new StreamState(); // take physical pages, weld into a logical stream of packets
            var Page = new Page(); // one Ogg bitstream page.  Vorbis packets are inside
            var Packet = new Packet(); // one raw packet of data for decode

            var Info = new Info(); // struct that stores all the static vorbis bitstream settings
            var Comment = new Comment(); // struct that stores all the bitstream user comments
            var DspState = new DspState(); // central working state for the packet->PCM decoder
            var Block = new Block(DspState); // local working space for packet->PCM decode

            byte[] buffer;
            int bytes = 0;

            // Decode setup

            SyncState.Init(); // Now we can read pages

            // we repeat if the bitstream is chained
            while (true)
            {
                int eos = 0;

                // grab some data at the head of the stream.  We want the first page
                // (which is guaranteed to be small and only contain the Vorbis
                // stream initial header) We need the first page to get the stream
                // serialno.

                // submit a 4k block to libvorbis' Ogg layer
                int index = SyncState.Buffer(4096);
                buffer = SyncState.Data;
                try
                {
                    bytes = input.Read(buffer, index, 4096);
                }
                catch (Exception e)
                {
                    Console.Error.WriteLine(e);
                    return;
                }
                SyncState.wrote(bytes);

                // Get the first page.
                int _result = SyncState.PageOut(Page);
                if (_result != 1)
                {
                    // have we simply run out of data?  If so, we're done.
                    if (bytes < 4096) break;

                    Console.WriteLine(bytes + "; " + _result);
                    //File.WriteAllBytes();
                    // error case.  Must not be Vorbis data
                    Console.Error.WriteLine("Input does not appear to be an Ogg bitstream.");
                    return;
                }

                // Get the serial number and set up the rest of decode.
                // serialno first; use it to set up a logical stream
                StreamState.Init(Page.serialno());

                // extract the initial header from the first page and verify that the
                // Ogg bitstream is in fact Vorbis data

                // I handle the initial header first instead of just having the code
                // read all three Vorbis headers at once because reading the initial
                // header is an easy way to identify a Vorbis bitstream and it's
                // useful to see that functionality seperated out.

                Info.init();
                Comment.init();
                if (StreamState.pagein(Page) < 0)
                {
                    // error; stream version mismatch perhaps
                    throw (new Exception("Error reading first page of Ogg bitstream data."));
                }

                if (StreamState.PacketOut(Packet) != 1)
                {
                    // no page? must not be vorbis
                    throw (new Exception("Error reading initial header packet."));
                }

                if (Info.synthesis_headerin(Comment, Packet) < 0)
                {
                    // error case; not a vorbis header
                    throw (new Exception("This Ogg bitstream does not contain Vorbis audio data."));
                }

                // At this point, we're sure we're Vorbis.  We've set up the logical
                // (Ogg) bitstream decoder.  Get the comment and codebook headers and
                // set up the Vorbis decoder

                // The next two packets in order are the comment and codebook headers.
                // They're likely large and may span multiple pages.  Thus we reead
                // and submit data until we get our two pacakets, watching that no
                // pages are missing.  If a page is missing, error out; losing a
                // header page is the only place where missing data is fatal. */

                int i = 0;
                while (i < 2)
                {
                    while (i < 2)
                    {

                        int result = SyncState.PageOut(Page);
                        if (result == 0)
                            break; // Need more data
                        // Don't complain about missing or corrupt data yet.  We'll
                        // catch it at the packet output phase

                        if (result == 1)
                        {
                            StreamState.pagein(Page); // we can ignore any errors here
                            // as they'll also become apparent
                            // at packetout
                            while (i < 2)
                            {
                                result = StreamState.PacketOut(Packet);
                                if (result == 0)
                                    break;
                                if (result == -1)
                                {
                                    // Uh oh; data at some point was corrupted or missing!
                                    // We can't tolerate that in a header.  Die.
                                    throw(new Exception("Corrupt secondary header.  Exiting."));
                                }
                                Info.synthesis_headerin(Comment, Packet);
                                i++;
                            }
                        }
                    }
                    // no harm in not checking before adding more
                    index = SyncState.Buffer(4096);
                    buffer = SyncState.Data;
                    try
                    {
                        bytes = input.Read(buffer, index, 4096);
                    }
                    catch (Exception e)
                    {
                        throw(new Exception("Exception", e));
                    }
                    if (bytes == 0 && i < 2)
                    {
                        throw(new Exception("End of file before finding all Vorbis headers!"));
                    }
                    SyncState.wrote(bytes);
                }

                // Throw the comments plus a few lines about the bitstream we're
                // decoding
                {
                    byte[][] ptr = Comment.user_comments;
                    for (int j = 0; j < ptr.Length; j++)
                    {
                        if (ptr[j] == null)
                            break;
                        Console.Error.WriteLine(Util.InternalEncoding.GetString(ptr[j], 0, ptr[j].Length - 1));
                    }
                    Console.Error.WriteLine("\nBitstream is {0} channel, {1}Hz", Info.channels, Info.rate);
                    Console.Error.WriteLine(
                        "Encoded by: {0}\n",
                        Util.InternalEncoding.GetString(Comment.vendor, 0, Comment.vendor.Length - 1));
                }

                convsize = 4096 / Info.channels;

                // OK, got and parsed all three headers. Initialize the Vorbis
                //  packet->PCM decoder.
                DspState.synthesis_init(Info); // central decode state
                Block.init(DspState); // local state for most of the decode
                // so multiple block decodes can
                // proceed in parallel.  We could init
                // multiple vorbis_block structures
                // for vd here

                float[][][] _pcm = new float[1][][];
                int[] _index = new int[Info.channels];
                // The rest is just a straight decode loop until end of stream
                while (eos == 0)
                {
                    while (eos == 0)
                    {

                        int result = SyncState.PageOut(Page);
                        if (result == 0)
                            break; // need more data
                        if (result == -1)
                        { // missing or corrupt data at this page position
                            Console.Error.WriteLine("Corrupt or missing data in bitstream; continuing...");
                        }
                        else
                        {
                            StreamState.pagein(Page); // can safely ignore errors at
                            // this point
                            while (true)
                            {
                                result = StreamState.PacketOut(Packet);

                                if (result == 0)
                                    break; // need more data
                                if (result == -1)
                                { // missing or corrupt data at this page position
                                    // no reason to complain; already complained above
                                }
                                else
                                {
                                    // we have a packet.  Decode it
                                    int samples;
                                    if (Block.synthesis(Packet) == 0)
                                    { // test for success!
                                        DspState.synthesis_blockin(Block);
                                    }

                                    // **pcm is a multichannel float vector.  In stereo, for
                                    // example, pcm[0] is left, and pcm[1] is right.  samples is
                                    // the size of each channel.  Convert the float values
                                    // (-1.<=range<=1.) to whatever PCM format and write it out

                                    while ((samples = DspState.synthesis_pcmout(_pcm, _index)) > 0)
                                    {
                                        float[][] pcm = _pcm[0];
                                        int bout = (samples < convsize ? samples : convsize);

                                        // convert floats to 16 bit signed ints (host order) and
                                        // interleave
                                        for (i = 0; i < Info.channels; i++)
                                        {
                                            int ptr = i * 2;
                                            //int ptr=i;
                                            int mono = _index[i];
                                            for (int j = 0; j < bout; j++)
                                            {
                                                int val = (int)(pcm[i][mono + j] * 32767.0);
                                                //		      short val=(short)(pcm[i][mono+j]*32767.);
                                                //		      int val=(int)Math.round(pcm[i][mono+j]*32767.);
                                                // might as well guard against clipping
                                                if (val > 32767)
                                                {
                                                    val = 32767;
                                                }
                                                if (val < -32768)
                                                {
                                                    val = -32768;
                                                }
                                                if (val < 0)
                                                    val = val | 0x8000;
                                                convbuffer[ptr] = (byte)(val);
                                                convbuffer[ptr + 1] = (byte)(((uint)val) >> 8);
                                                ptr += 2 * (Info.channels);
                                            }
                                        }

                                        //                  System.out.write(convbuffer, 0, 2*vi.channels*bout);
                                        //throw(new NotImplementedException("ccccccccc"));
                                        OutputBuffer.Write(convbuffer, 0, 2 * Info.channels * bout);

                                        // tell libvorbis how
                                        // many samples we
                                        // actually consumed
                                        DspState.synthesis_read(bout);
                                    }
                                }
                            }
                            if (Page.eos() != 0)
                                eos = 1;
                        }
                    }
                    if (eos == 0)
                    {
                        index = SyncState.Buffer(4096);
                        buffer = SyncState.Data;
                        try
                        {
                            bytes = input.Read(buffer, index, 4096);
                        }
                        catch (Exception e)
                        {
                            throw(new Exception("Exception", e));
                        }
                        SyncState.wrote(bytes);
                        if (bytes == 0) eos = 1;
                    }
                }

                // clean up this logical bitstream; before exit we see if we're
                // followed by another [chained]

                StreamState.Clear();

                // ogg_page and ogg_packet structs always point to storage in
                // libvorbis.  They're never freed or manipulated directly

                Block.clear();
                DspState.clear();
                Info.Clear(); // must be called last
            }

            // OK, clean up the framer
            SyncState.Clear();

            var WaveStream = new WaveStream();
            using (var WaveOutputStream = File.OpenWrite(Name + ".wav"))
            {
                OutputBuffer.Position = 0;
                WaveStream.WriteWave(WaveOutputStream, () =>
                {
                    OutputBuffer.CopyTo(WaveOutputStream);
                }, NumberOfChannels: 1, SampleRate: 44100);
            }

            Console.Error.WriteLine("Done.");
        }
        public AudioSample OggToWav(Stream ogg, float volume, float pitch)
        {
            AudioSample  sample = new AudioSample();
            TextWriter   s_err  = new StringWriter();
            Stream       input  = null;
            MemoryStream output = null;

            input  = ogg;
            output = new MemoryStream();

            SyncState   oy = new SyncState();
            StreamState os = new StreamState();
            Page        og = new Page();
            Packet      op = new Packet();

            Info     vi = new Info();
            Comment  vc = new Comment();
            DspState vd = new DspState();
            Block    vb = new Block(vd);

            byte[] buffer;
            int    bytes = 0;

            oy.init();
            while (true)
            {
                int eos   = 0;
                int index = oy.buffer(4096);
                buffer = oy.data;
                try
                {
                    bytes = input.Read(buffer, index, 4096);
                }
                catch (Exception e)
                {
                    s_err.WriteLine(e);
                }
                oy.wrote(bytes);
                if (oy.pageout(og) != 1)
                {
                    if (bytes < 4096)
                    {
                        break;
                    }
                    s_err.WriteLine("Input does not appear to be an Ogg bitstream.");
                }
                os.init(og.serialno());
                vi.init();
                vc.init();
                if (os.pagein(og) < 0)
                {
                    s_err.WriteLine("Error reading first page of Ogg bitstream data.");
                }

                if (os.packetout(op) != 1)
                {
                    s_err.WriteLine("Error reading initial header packet.");
                }

                if (vi.synthesis_headerin(vc, op) < 0)
                {
                    s_err.WriteLine("This Ogg bitstream does not contain Vorbis audio data.");
                }

                int i = 0;
                while (i < 2)
                {
                    while (i < 2)
                    {
                        int result = oy.pageout(og);
                        if (result == 0)
                        {
                            break;
                        }
                        if (result == 1)
                        {
                            os.pagein(og);
                            while (i < 2)
                            {
                                result = os.packetout(op);
                                if (result == 0)
                                {
                                    break;
                                }
                                vi.synthesis_headerin(vc, op);
                                i++;
                            }
                        }
                    }
                    index  = oy.buffer(4096);
                    buffer = oy.data;
                    try
                    {
                        bytes = input.Read(buffer, index, 4096);
                    }
                    catch (Exception e)
                    {
                        s_err.WriteLine(e);
                    }
                    oy.wrote(bytes);
                }
                sample.Channels = vi.channels;
                sample.Rate     = (int)((float)vi.rate * pitch);
                convsize        = 4096 / vi.channels;
                vd.synthesis_init(vi);
                vb.init(vd);
                float[][][] _pcm   = new float[1][][];
                int[]       _index = new int[vi.channels];
                while (eos == 0)
                {
                    while (eos == 0)
                    {
                        int result = oy.pageout(og);
                        if (result == 0)
                        {
                            break;
                        }
                        if (result != -1)
                        {
                            os.pagein(og);
                            while (true)
                            {
                                result = os.packetout(op);
                                if (result == 0)
                                {
                                    break;
                                }
                                if (result != -1)
                                {
                                    int samples;
                                    if (vb.synthesis(op) == 0)
                                    {
                                        vd.synthesis_blockin(vb);
                                    }
                                    while ((samples = vd.synthesis_pcmout(_pcm, _index)) > 0)
                                    {
                                        float[][] pcm  = _pcm[0];
                                        int       bout = (samples < convsize ? samples : convsize);
                                        for (i = 0; i < vi.channels; i++)
                                        {
                                            int ptr  = i * 2;
                                            int mono = _index[i];
                                            for (int j = 0; j < bout; j++)
                                            {
                                                int val = (int)(pcm[i][mono + j] * 32767.0);
                                                if (val > 32767)
                                                {
                                                    val = 32767;
                                                }
                                                if (val < -32768)
                                                {
                                                    val = -32768;
                                                }
                                                val = (int)((float)val * volume);
                                                if (val < 0)
                                                {
                                                    val = val | 0x8000;
                                                }
                                                convbuffer[ptr]     = (byte)(val);
                                                convbuffer[ptr + 1] = (byte)((uint)val >> 8);
                                                ptr += 2 * (vi.channels);
                                            }
                                        }
                                        output.Write(convbuffer, 0, 2 * vi.channels * bout);
                                        vd.synthesis_read(bout);
                                    }
                                }
                            }
                            if (og.eos() != 0)
                            {
                                eos = 1;
                            }
                        }
                    }
                    if (eos == 0)
                    {
                        index  = oy.buffer(4096);
                        buffer = oy.data;
                        try
                        {
                            bytes = input.Read(buffer, index, 4096);
                        }
                        catch (Exception e)
                        {
                            s_err.WriteLine(e);
                        }
                        oy.wrote(bytes);
                        if (bytes == 0)
                        {
                            eos = 1;
                        }
                    }
                }
                os.clear();
                vb.clear();
                vd.clear();
                vi.clear();
                break;
            }

            oy.clear();
            input.Close();
            sample.Pcm = output.ToArray();
            return(sample);
        }
Beispiel #7
0
        static byte[] convbuffer = new byte[convsize];         // take 8k out of the data segment, not the stack

        public static void main(String[] arg)
        {
            //Stream output = File.OpenWrite("output.bin");
            var    Name         = "Output.ogg";
            var    OutputBuffer = new MemoryStream();
            Stream input        = null;

            //java.io.InputStream input=System.In;
            if (arg.Length > 0)
            {
                try
                {
                    Name  = arg[0];
                    input = File.OpenRead(arg[0]);
                }
                catch (Exception e)
                {
                    Console.Error.WriteLine(e);
                }
            }
            else
            {
                throw (new NotImplementedException("aaaa"));
            }

            if (input == null)
            {
                throw (new NotImplementedException("bbb"));
            }

            var SyncState   = new SyncState();   // sync and verify incoming physical bitstream
            var StreamState = new StreamState(); // take physical pages, weld into a logical stream of packets
            var Page        = new Page();        // one Ogg bitstream page.  Vorbis packets are inside
            var Packet      = new Packet();      // one raw packet of data for decode

            var Info     = new Info();           // struct that stores all the static vorbis bitstream settings
            var Comment  = new Comment();        // struct that stores all the bitstream user comments
            var DspState = new DspState();       // central working state for the packet->PCM decoder
            var Block    = new Block(DspState);  // local working space for packet->PCM decode

            byte[] buffer;
            int    bytes = 0;

            // Decode setup

            SyncState.Init();             // Now we can read pages

            // we repeat if the bitstream is chained
            while (true)
            {
                int eos = 0;

                // grab some data at the head of the stream.  We want the first page
                // (which is guaranteed to be small and only contain the Vorbis
                // stream initial header) We need the first page to get the stream
                // serialno.

                // submit a 4k block to libvorbis' Ogg layer
                int index = SyncState.Buffer(4096);
                buffer = SyncState.Data;
                try
                {
                    bytes = input.Read(buffer, index, 4096);
                }
                catch (Exception e)
                {
                    Console.Error.WriteLine(e);
                    return;
                }
                SyncState.wrote(bytes);

                // Get the first page.
                int _result = SyncState.PageOut(Page);
                if (_result != 1)
                {
                    // have we simply run out of data?  If so, we're done.
                    if (bytes < 4096)
                    {
                        break;
                    }

                    Console.WriteLine(bytes + "; " + _result);
                    //File.WriteAllBytes();
                    // error case.  Must not be Vorbis data
                    Console.Error.WriteLine("Input does not appear to be an Ogg bitstream.");
                    return;
                }

                // Get the serial number and set up the rest of decode.
                // serialno first; use it to set up a logical stream
                StreamState.Init(Page.serialno());

                // extract the initial header from the first page and verify that the
                // Ogg bitstream is in fact Vorbis data

                // I handle the initial header first instead of just having the code
                // read all three Vorbis headers at once because reading the initial
                // header is an easy way to identify a Vorbis bitstream and it's
                // useful to see that functionality seperated out.

                Info.init();
                Comment.init();
                if (StreamState.pagein(Page) < 0)
                {
                    // error; stream version mismatch perhaps
                    throw (new Exception("Error reading first page of Ogg bitstream data."));
                }

                if (StreamState.PacketOut(Packet) != 1)
                {
                    // no page? must not be vorbis
                    throw (new Exception("Error reading initial header packet."));
                }

                if (Info.synthesis_headerin(Comment, Packet) < 0)
                {
                    // error case; not a vorbis header
                    throw (new Exception("This Ogg bitstream does not contain Vorbis audio data."));
                }

                // At this point, we're sure we're Vorbis.  We've set up the logical
                // (Ogg) bitstream decoder.  Get the comment and codebook headers and
                // set up the Vorbis decoder

                // The next two packets in order are the comment and codebook headers.
                // They're likely large and may span multiple pages.  Thus we reead
                // and submit data until we get our two pacakets, watching that no
                // pages are missing.  If a page is missing, error out; losing a
                // header page is the only place where missing data is fatal. */

                int i = 0;
                while (i < 2)
                {
                    while (i < 2)
                    {
                        int result = SyncState.PageOut(Page);
                        if (result == 0)
                        {
                            break;                             // Need more data
                        }
                        // Don't complain about missing or corrupt data yet.  We'll
                        // catch it at the packet output phase

                        if (result == 1)
                        {
                            StreamState.pagein(Page);                             // we can ignore any errors here
                            // as they'll also become apparent
                            // at packetout
                            while (i < 2)
                            {
                                result = StreamState.PacketOut(Packet);
                                if (result == 0)
                                {
                                    break;
                                }
                                if (result == -1)
                                {
                                    // Uh oh; data at some point was corrupted or missing!
                                    // We can't tolerate that in a header.  Die.
                                    throw(new Exception("Corrupt secondary header.  Exiting."));
                                }
                                Info.synthesis_headerin(Comment, Packet);
                                i++;
                            }
                        }
                    }
                    // no harm in not checking before adding more
                    index  = SyncState.Buffer(4096);
                    buffer = SyncState.Data;
                    try
                    {
                        bytes = input.Read(buffer, index, 4096);
                    }
                    catch (Exception e)
                    {
                        throw(new Exception("Exception", e));
                    }
                    if (bytes == 0 && i < 2)
                    {
                        throw(new Exception("End of file before finding all Vorbis headers!"));
                    }
                    SyncState.wrote(bytes);
                }

                // Throw the comments plus a few lines about the bitstream we're
                // decoding
                {
                    byte[][] ptr = Comment.user_comments;
                    for (int j = 0; j < ptr.Length; j++)
                    {
                        if (ptr[j] == null)
                        {
                            break;
                        }
                        Console.Error.WriteLine(Util.InternalEncoding.GetString(ptr[j], 0, ptr[j].Length - 1));
                    }
                    Console.Error.WriteLine("\nBitstream is {0} channel, {1}Hz", Info.channels, Info.rate);
                    Console.Error.WriteLine(
                        "Encoded by: {0}\n",
                        Util.InternalEncoding.GetString(Comment.vendor, 0, Comment.vendor.Length - 1));
                }

                convsize = 4096 / Info.channels;

                // OK, got and parsed all three headers. Initialize the Vorbis
                //  packet->PCM decoder.
                DspState.synthesis_init(Info);        // central decode state
                Block.init(DspState);                 // local state for most of the decode
                // so multiple block decodes can
                // proceed in parallel.  We could init
                // multiple vorbis_block structures
                // for vd here

                float[][][] _pcm   = new float[1][][];
                int[]       _index = new int[Info.channels];
                // The rest is just a straight decode loop until end of stream
                while (eos == 0)
                {
                    while (eos == 0)
                    {
                        int result = SyncState.PageOut(Page);
                        if (result == 0)
                        {
                            break;                             // need more data
                        }
                        if (result == -1)
                        {                         // missing or corrupt data at this page position
                            Console.Error.WriteLine("Corrupt or missing data in bitstream; continuing...");
                        }
                        else
                        {
                            StreamState.pagein(Page);                             // can safely ignore errors at
                            // this point
                            while (true)
                            {
                                result = StreamState.PacketOut(Packet);

                                if (result == 0)
                                {
                                    break;                                     // need more data
                                }
                                if (result == -1)
                                {                                 // missing or corrupt data at this page position
                                    // no reason to complain; already complained above
                                }
                                else
                                {
                                    // we have a packet.  Decode it
                                    int samples;
                                    if (Block.synthesis(Packet) == 0)
                                    {                                     // test for success!
                                        DspState.synthesis_blockin(Block);
                                    }

                                    // **pcm is a multichannel float vector.  In stereo, for
                                    // example, pcm[0] is left, and pcm[1] is right.  samples is
                                    // the size of each channel.  Convert the float values
                                    // (-1.<=range<=1.) to whatever PCM format and write it out

                                    while ((samples = DspState.synthesis_pcmout(_pcm, _index)) > 0)
                                    {
                                        float[][] pcm  = _pcm[0];
                                        int       bout = (samples < convsize ? samples : convsize);

                                        // convert floats to 16 bit signed ints (host order) and
                                        // interleave
                                        for (i = 0; i < Info.channels; i++)
                                        {
                                            int ptr = i * 2;
                                            //int ptr=i;
                                            int mono = _index[i];
                                            for (int j = 0; j < bout; j++)
                                            {
                                                int val = (int)(pcm[i][mono + j] * 32767.0);
                                                //		      short val=(short)(pcm[i][mono+j]*32767.);
                                                //		      int val=(int)Math.round(pcm[i][mono+j]*32767.);
                                                // might as well guard against clipping
                                                if (val > 32767)
                                                {
                                                    val = 32767;
                                                }
                                                if (val < -32768)
                                                {
                                                    val = -32768;
                                                }
                                                if (val < 0)
                                                {
                                                    val = val | 0x8000;
                                                }
                                                convbuffer[ptr]     = (byte)(val);
                                                convbuffer[ptr + 1] = (byte)(((uint)val) >> 8);
                                                ptr += 2 * (Info.channels);
                                            }
                                        }

                                        //                  System.out.write(convbuffer, 0, 2*vi.channels*bout);
                                        //throw(new NotImplementedException("ccccccccc"));
                                        OutputBuffer.Write(convbuffer, 0, 2 * Info.channels * bout);

                                        // tell libvorbis how
                                        // many samples we
                                        // actually consumed
                                        DspState.synthesis_read(bout);
                                    }
                                }
                            }
                            if (Page.eos() != 0)
                            {
                                eos = 1;
                            }
                        }
                    }
                    if (eos == 0)
                    {
                        index  = SyncState.Buffer(4096);
                        buffer = SyncState.Data;
                        try
                        {
                            bytes = input.Read(buffer, index, 4096);
                        }
                        catch (Exception e)
                        {
                            throw(new Exception("Exception", e));
                        }
                        SyncState.wrote(bytes);
                        if (bytes == 0)
                        {
                            eos = 1;
                        }
                    }
                }

                // clean up this logical bitstream; before exit we see if we're
                // followed by another [chained]

                StreamState.Clear();

                // ogg_page and ogg_packet structs always point to storage in
                // libvorbis.  They're never freed or manipulated directly

                Block.clear();
                DspState.clear();
                Info.Clear();                 // must be called last
            }

            // OK, clean up the framer
            SyncState.Clear();

            var WaveStream = new WaveStream();

            using (var WaveOutputStream = File.OpenWrite(Name + ".wav"))
            {
                OutputBuffer.Position = 0;
                WaveStream.WriteWave(WaveOutputStream, () =>
                {
                    OutputBuffer.CopyTo(WaveOutputStream);
                }, NumberOfChannels: 1, SampleRate: 44100);
            }

            Console.Error.WriteLine("Done.");
        }