getInfo() public method

public getInfo ( int link ) : Info
link int
return Info
コード例 #1
0
        /// <summary>
        /// Decodes the ogg-vorbis file
        /// </summary>
        /// <param name="input">Stream of the ogg-vorbis file</param>
        /// <returns>PCM-Wave version of the input</returns>
        public WaveFile Decode(Stream input)
        {
            MemoryStream output = new MemoryStream();
            WaveFile wf = new WaveFile();

            VorbisFile vf = new VorbisFile((FileStream)input, null, 0);
            Info inf = vf.getInfo(-1);

            wf.Channels = (short)inf.channels;
            wf.Frequency = inf.rate;
            wf.Bits = 16;

            Axiom.Core.LogManager.Instance.Write("SoundSystem: File is Ogg Vorbis "+inf.version.ToString()+" "+inf.rate.ToString()+"Hz, "+inf.channels.ToString()+" channels");

            int bufferlen = 4096;
            int result = 1;
            byte[] buffer = new byte[bufferlen];
            int[] section = new int[1];
            while(result != 0)
            {
                result = vf.read(buffer, bufferlen, 0, 2, 1, section);
                output.Write(buffer, 0, result);
            }

            output.Seek(0, SeekOrigin.Begin);
            wf.Data = output;

            return wf;
        }
コード例 #2
0
        /// <summary>Constructor - Supports opening an Ogg Vorbis file</summary>
        public OggVorbisFileReader(string oggFileName)
        {
            m_vorbisFile = new VorbisFile(oggFileName);
            Info[] info = m_vorbisFile.getInfo();

            // TODO: 8 bit is hard coded!! need to figure out how to calculate it, Ogg tags do not seem to contain it
            int bitsPerSample = 8;
            m_waveFormat = new WaveFormat(info[0].rate, bitsPerSample, info[0].channels);
        }
コード例 #3
0
        /// <summary>Supports opening an Ogg Vorbis file</summary>
        public OggFileReader(string oggFileName)
        {
            m_vorbisFile = new VorbisFile(oggFileName);
            info = m_vorbisFile.getInfo();

            // TODO: 8 is hard coded!! need to change it dynamically by reading tags
            waveFormat = new WaveFormat(info[0].rate, 8, info[0].channels);
            pcm_total = m_vorbisFile.pcm_total(-1);

            timeSpan = m_vorbisFile.time_total(-1); // Timespan in seconds
        }
コード例 #4
0
ファイル: OggFile.cs プロジェクト: CloneDeath/DragonOgg
        private TagLib.File m_TagLibFile; // TagLibSharp file object

        #endregion Fields

        #region Constructors

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="Filename">
        /// A <see cref="System.String"/> containing the path to the Ogg Vorbis file this instance represents
        /// </param>
        public OggFile(string Filename)
        {
            // Check that the file exists
            if (!(System.IO.File.Exists(Filename))) { throw new OggFileReadException("File not found", Filename); }
            // Load the relevant objects
            m_Filename = Filename;
            try
            {
                m_CSVorbisFile = new VorbisFile(m_Filename);
            }
            catch (Exception ex)
            {
                throw new OggFileReadException("Unable to open file for data reading\n" + ex.Message, Filename);
            }
            try
            {
                m_TagLibFile = TagLib.File.Create(m_Filename);
            }
            catch (TagLib.UnsupportedFormatException ex)
            {
                throw new OggFileReadException("Unsupported format (not an ogg?)\n" + ex.Message, Filename);
            }
            catch (TagLib.CorruptFileException ex)
            {
                throw new OggFileCorruptException(ex.Message, Filename, "Tags");
            }

            // Populate some other info shizzle and do a little bit of sanity checking
            m_Streams = m_CSVorbisFile.streams();
            if (m_Streams<=0) { throw new OggFileReadException("File doesn't contain any logical bitstreams", Filename); }
            // Assuming <0 is for whole file and >=0 is for specific logical bitstreams
            m_Bitrate = m_CSVorbisFile.bitrate(-1);
            m_LengthTime = (int)m_CSVorbisFile.time_total(-1);
            // Figure out the ALFormat of the stream
            m_Info = m_CSVorbisFile.getInfo();	// Get the info of the first stream, assuming all streams are the same? Dunno if this is safe tbh
            if (m_Info[0] == null) { throw new OggFileReadException("Unable to determine Format{FileInfo.Channels} for first bitstream", Filename); }
            if (m_TagLibFile.Properties.AudioBitrate==16) {
                m_Format = (m_Info[0].channels)==1 ? ALFormat.Mono16 : ALFormat.Stereo16; // This looks like a fudge, but I've seen it a couple of times (what about the other formats I wonder?)
            }
            else
            {
                m_Format = (m_Info[0].channels)==1 ? ALFormat.Mono8 : ALFormat.Stereo8;
            }

            // A grab our first instance of the file so we're ready to play
            m_CSVorbisFileInstance = m_CSVorbisFile.makeInstance();
        }
コード例 #5
0
ファイル: Sound.cs プロジェクト: wach78/Turbofest
        public void LoadOGG(SoundType sound)
        {
            // Dirty way of checking that we have ogg-dlls in exe path....
            if (!File.Exists("csogg.dll") || !File.Exists("csvorbis.dll"))
            {
                return; // return 0;
            }

            int ab = sound.Buffer;

            //#define ogg // or activate this, but this is just for this place/file... :D
            #if noogg
            #warning "Returning 0 on Ogg file, you need to define \"ogg\" in build constants, in project build property."
            return ; // quicker upstart
            #endif

            VorbisFile asd = new VorbisFile(sound.Filename);
            System.Diagnostics.Debug.WriteLine(sound.Filename);
            Info info = asd.getInfo(-1);
            //long samples = asd.pcm_total(-1);
            //int streams = asd.streams();
            //byte[] data3 = new byte[samples*streams];
            byte[] data2 = new byte[4096];
            Stream output2 = new MemoryStream();
            int readBytes = 0;

            while ((readBytes = asd.read(data2, data2.Length, 0 /*Bigendian*/, /*(info.rate < 44100 ? 2 : 2)*/ 2 /*1=byte, 2=16bit*/, 1/*signd*/, null)) > 0)
            {
                output2.Write(data2, 0, readBytes);
            }
            data2 = null;
            data2 = new byte[output2.Length];
            output2.Seek(0, SeekOrigin.Begin);
            output2.Read(data2, 0, data2.Length);
            output2.Close();
            //output2.Dispose();
            output2 = null;
            //
            #region csogg and stuff, commented
            // borrow from csogg and csvorbis...
            /*using (var input = new FileStream(filename, FileMode.Open, FileAccess.Read))
            {
                System.Diagnostics.Debug.WriteLine(filename);
                bool skipWavHeader = true;
                int HEADER_SIZE = 36;

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

                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)
                    {
                        System.Diagnostics.Debug.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
                        System.Diagnostics.Debug.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
                        System.Diagnostics.Debug.WriteLine("Error reading first page of Ogg bitstream data.");
                    }

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

                    if (vi.synthesis_headerin(vc, op) < 0)
                    {
                        // error case; not a vorbis header
                        System.Diagnostics.Debug.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.
                                        System.Diagnostics.Debug.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)
                        {
                            System.Diagnostics.Debug.WriteLine(e);
                        }
                        if (bytes == 0 && i < 2)
                        {
                            System.Diagnostics.Debug.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;
                            System.Diagnostics.Debug.WriteLine(vc.getComment(j));
                        }
                        System.Diagnostics.Debug.WriteLine("\nBitstream is " + vi.channels + " channel, " + vi.rate + "Hz");
                        System.Diagnostics.Debug.WriteLine("Encoded by: " + vc.getVendor() + "\n");
                    } // comment this on release...

                    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
                                System.Diagnostics.Debug.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)
                            {
                                System.Diagnostics.Debug.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();
                System.Diagnostics.Debug.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);
                }
                */
            #endregion
            //
            ALFormat alf = 0;
            if (/*vi*/info.channels == 1) // mono
            {
                alf = ALFormat.Mono16;
            }
            else if (/*vi*/info.channels == 2) // sterio
            {
                alf = ALFormat.Stereo16;
            }
            else if (alf == 0)
            {
                throw new Exception("Wrong number of channels in sound file.");
            }

            /*BinaryReader bw = new BinaryReader(output);
            byte[] data = bw.ReadBytes((int)output.Length);
            bw.Close();
            bw.Dispose();*/
            /*byte[] data = new byte[(int)output.Length];
            output.Read(data, 0, data.Length);
            output.Close();
            output.Dispose();*/
            AL.BufferData(ab, alf, data2, data2.Length, /*vi.rate*/ info.rate);
            //data = null;
            //}

            //return ab;
        }
コード例 #6
0
ファイル: Sound.cs プロジェクト: wach78/Turbofest
 /// <summary>
 /// Constructor for SoundType class
 /// </summary>
 /// <param name="FileName">String of the filepath</param>
 /// <param name="IsToBeStreaming">Is it to be streamed?</param>
 public SoundType(string FileName, bool IsToBeStreaming)
 {
     if (!System.IO.File.Exists(FileName))
     {
         throw new Exception("Missing sound file!");
     }
     File = FileName;
     Streaming = IsToBeStreaming;
     if (!Streaming)
     {
         BufferID = AL.GenBuffer();
     }
     else
     {
         BufferID = -1;
     }
     // This makes the program take some time to load...
     FileToBuffer = new VorbisFile(File);
     FileInfoVO = FileToBuffer.getInfo(-1);
     alf = 0;
     /*int asd = FileToBuffer.bitrate(-1);
     int asd2 = FileToBuffer.bitrate_instant();*/
     if (FileInfoVO.channels == 1) // mono
     {
         alf = ALFormat.Mono16;
     }
     else if (FileInfoVO.channels == 2) // sterio
     {
         alf = ALFormat.Stereo16;
     }
     else if (alf == 0)
     {
         throw new Exception("Wrong number of channels in sound file.");
     }
 }