clsFLACFile.cs

//
// Copyright (C) 2005 Marcel Joachim Kloubert
// 
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//

using System;
using System.IO;

namespace CSharp_ClassLib.FileTypes.FLAC
{       
        // Tools
        public sealed class Tools
        {
                public static System.UInt16 ToUInt16 (byte[] Bytes, int Start) { return (System.UInt16)(Bytes[Start] * 256 + (System.UInt16)Bytes[Start + 1]); }
                
                public static System.UInt32 ToUInt32 (byte[] Bytes, int Start, int Length)
                {
                        switch (Length)
                        {
                                case 1:
                                        return (System.UInt32)Bytes[Start];                             
                                case 2:
                                        return (System.UInt32)ToUInt16(Bytes, Start);                           
                                case 3:
                                        return (System.UInt16)(Bytes[Start] * 65536 + Bytes[Start + 1] * 256 + (System.UInt16)Bytes[Start + 2]);                                        
                                case 4:
                                        return ToUInt32(Bytes, Start);
                                        
                                default:
                                        throw ( new System.ArgumentException("Invalid length!", "Length") );
                        }                       
                }
                
                public static System.UInt32 ToUInt32 (byte[] Bytes, int Start) { return (System.UInt16)(Bytes[Start] * 16777216 + Bytes[Start + 1] * 65536 + Bytes[Start + 2] * 256 + (System.UInt16)Bytes[Start + 3]); }
        }
        
        // STREAM
        public class STREAM : System.Object
        {
                // stream marker ("fLaC")
                private byte[] m_bStreamMarker = { 0x66, 0x4C, 0x61, 0x43 };
                
                private System.IO.Stream m_oStream;
                private System.Collections.ArrayList m_oMetadataBlocks;
                
                public STREAM()
                {
                        this.Stream = null;
                        this.InitRest();
                        
                        return;
                }
                
                public STREAM (string Filename)
                {
                        this.Stream = new System.IO.FileStream(Filename, System.IO.FileMode.Open);
                        this.InitRest();
                        
                        return;
                }
                
                public STREAM(System.IO.Stream stream)
                {
                        this.Stream = stream;
                        this.InitRest();
                        
                        return;
                }
                
                public System.IO.Stream Stream
                {
                        set
                        {
                                int i = 0;
                                byte[] bBuffer;
                                
                                this.m_oMetadataBlocks = new System.Collections.ArrayList();
                                METADATA_BLOCK oMETADATA_BLOCK_TEMP;
                                
                                m_oStream = value;
                                
                                if (null == m_oStream)
                                        return;
                                
                                if (!value.CanRead)
                                        throw ( new System.Exception("Cannot read FLAC data!") );
                                
                                // get stream marker
                                try
                                {
                                        bBuffer = new byte[4];
                                        
                                        this.Stream.Read(bBuffer, 0, 4);
                                        
                                        if ( 4 != bBuffer.GetLength(0) )
                                                throw ( new System.Exception("Invalid stream marker!") );
                                        
                                        for (i = 0; i < 4; i++)
                                        {
                                                if (bBuffer[i] != StreamMarker[i])
                                                        throw ( new System.Exception("Invalid stream marker!") );
                                        }                                                                               
                                }
                                catch (Exception e) { throw ( new System.Exception("Cannot read FLAC stream marker! Reason: " + e.Message) ); }
                                
                                while ( true )
                                {
                                        oMETADATA_BLOCK_TEMP = new METADATA_BLOCK();
                                        
                                        // get metablock header
                                        try
                                        {
                                                bBuffer = new byte[4];                                  
                                                this.Stream.Read(bBuffer, 0, 4);                                        
                                                if ( 4 != bBuffer.GetLength(0) )
                                                        throw ( new System.Exception("Invalid metadata block header!") );
                                                
                                                oMETADATA_BLOCK_TEMP.Header.RawData = bBuffer;  
                                                
                                                bBuffer = new byte[oMETADATA_BLOCK_TEMP.Header.Length];
                                                this.Stream.Read(bBuffer, 0, (int)oMETADATA_BLOCK_TEMP.Header.Length);
                                                if ( oMETADATA_BLOCK_TEMP.Header.Length != bBuffer.GetLength(0) )
                                                        throw ( new System.Exception("Invalid metadata block data!") );
                                                
                                                switch (oMETADATA_BLOCK_TEMP.Header.Type)
                                                {
                                                        case METADATA_BLOCK_HEADER.BLOCK_TYPE.STREAMINFO:
                                                                // STREAMINFO
                                                                oMETADATA_BLOCK_TEMP.Data = new METADATA_BLOCK_STREAMINFO(bBuffer);
                                                                
                                                                Console.WriteLine("BlockLength: " + oMETADATA_BLOCK_TEMP.Header.Length.ToString());
                                                                Console.WriteLine("MinSampleSize: " + ((METADATA_BLOCK_STREAMINFO)oMETADATA_BLOCK_TEMP.Data).MinimumBlockSize.ToString());
                                                                Console.WriteLine("MaxSampleSize: " + ((METADATA_BLOCK_STREAMINFO)oMETADATA_BLOCK_TEMP.Data).MaximumBlockSize.ToString());
                                                                Console.WriteLine("MinFrameSize: " + ((METADATA_BLOCK_STREAMINFO)oMETADATA_BLOCK_TEMP.Data).MinimumFrameSize.ToString());
                                                                Console.WriteLine("MaxFrameSize: " + ((METADATA_BLOCK_STREAMINFO)oMETADATA_BLOCK_TEMP.Data).MaximumFrameSize.ToString());
                                                                
                                                                break;
                                                        
                                                        default:
                                                                // unknown
                                                                oMETADATA_BLOCK_TEMP.Data = new METADATA_BLOCK_DATA(bBuffer);
                                                                break;
                                                }
                                                
                                                // oMETADATA_BLOCK_TEMP.Header.RawData = bBuffer;                                       
                                        }
                                        catch (Exception e) { throw ( new System.Exception("Cannot read FLAC metadata block header! Reason: " + e.Message) ); }
                                        
                                        this.m_oMetadataBlocks.Add(oMETADATA_BLOCK_TEMP);                                       
                                        if (oMETADATA_BLOCK_TEMP.Header.IsLastBlock)
                                                break;
                                }                                                               
                        }
                        
                        get { return m_oStream; }
                }
                
                public byte[] StreamMarker { get { return m_bStreamMarker; } }
                
                public METADATA_BLOCK[] MetadataBlocks
                {
                        get
                        {
                                METADATA_BLOCK[] oBuffer = new METADATA_BLOCK[m_oMetadataBlocks.Count];
                                m_oMetadataBlocks.CopyTo(oBuffer);
                                
                                return oBuffer;
                        }
                }
                
                private void InitRest()
                {
                        m_oMetadataBlocks = new System.Collections.ArrayList();
                        return;
                }
        }       
        
        // METADATA_BLOCK
        public class METADATA_BLOCK : System.Object
        {
                private METADATA_BLOCK_HEADER m_oHeader;
                private METADATA_BLOCK_DATA m_oData;
                
                public METADATA_BLOCK()
                {
                        m_oHeader = new METADATA_BLOCK_HEADER();
                        m_oData = new METADATA_BLOCK_DATA( new byte[0] );
                        
                        return;
                }
                
                public METADATA_BLOCK_HEADER Header { get { return m_oHeader; } }
                
                public METADATA_BLOCK_DATA Data
                {
                        get { return m_oData; }
                        set { m_oData = value; }
                }
        }       
        
        // METADATA_BLOCK_HEADER
        public class METADATA_BLOCK_HEADER : System.Object
        {
                private bool m_boolIsLastBlock;
                private BLOCK_TYPE m_BLOCK_TYPE;
                private uint m_uiBlockLength;
                
                public enum BLOCK_TYPE : byte
                {
                        STREAMINFO = 0,
                        PADDING,
                        APPLICATION,
                        SEEKTABLE,
                        VORBIS_COMMENT,
                        CUESHEET,
                        INVALID = 127
                }
                
                
                public METADATA_BLOCK_HEADER()
                {
                        m_boolIsLastBlock = false;                                              
                        m_BLOCK_TYPE = BLOCK_TYPE.INVALID;
                        m_uiBlockLength = 0;
                        
                        return;
                }
                
                public byte[] RawData
                {
                        set
                        {
                                byte[] bBuffer = value;                                 
                                if ( 4 != bBuffer.GetLength(0) )
                                        throw ( new System.Exception("Invalid metadata block header!") );
                                
                                this.m_boolIsLastBlock = ( 1 == (byte)((byte)(bBuffer[0] << 7) >> 7) ) ? true : false;
                                this.m_BLOCK_TYPE = (BLOCK_TYPE)(byte)(bBuffer[0] >> 1);
                                this.m_uiBlockLength = Tools.ToUInt32(bBuffer, 1, 3);
                                
                                return;
                        }
                }
                
                public bool IsLastBlock { get { return this.m_boolIsLastBlock; } }
                public BLOCK_TYPE Type { get { return this.m_BLOCK_TYPE; } }
                public uint Length { get { return this.m_uiBlockLength; } }
        }       
        
        // METADATA_BLOCK_DATA
        public class METADATA_BLOCK_DATA : System.Object
        {
                public METADATA_BLOCK_DATA (byte[] Raw_Data)
                {
                        this.RawData = Raw_Data;
                        
                        return;
                }                               
                
                public byte[] RawData
                {
                        set
                        {
                                return;
                        }
                }                               
        }       
        
        // METADATA_BLOCK_STREAMINFO
        public class METADATA_BLOCK_STREAMINFO : METADATA_BLOCK_DATA
        {
                private ushort m_usMinimumSamples;
                private ushort m_usMaximumSamples;
                private uint m_uiMinimumFrameSize;
                private uint m_uiMaximumFrameSize;
                
                public METADATA_BLOCK_STREAMINFO (byte[] Raw_Data) : base(Raw_Data)
                {
                        m_usMinimumSamples = 0;
                        m_usMaximumSamples = 0;
                        m_uiMinimumFrameSize = 0;
                        m_uiMaximumFrameSize = 0;
                        
                        this.RawData = Raw_Data;
                        
                        return;
                }
                
                public ushort MinimumBlockSize { get { return this.m_usMinimumSamples; }        }
                public ushort MaximumBlockSize { get { return this.m_usMaximumSamples; }        }
                public uint MinimumFrameSize { get { return this.m_uiMinimumFrameSize; }        }
                public uint MaximumFrameSize { get { return this.m_uiMaximumFrameSize; }        }
                
                public bool IsFixedStream { get { return (this.MinimumBlockSize == this.MaximumBlockSize); } }
                
                public byte[] RawData
                {
                        set
                        {
                                System.UInt32 a = 0;
                                byte b = 0;
                                
                                byte[] bBuffer = value;
                                if ( 34 != bBuffer.GetLength(0) )
                                        throw ( new System.ArgumentException("Invalid metadata block data (wrong size)!", "value") );
                                
                                this.m_usMinimumSamples = Tools.ToUInt16(bBuffer, 0);
                                this.m_usMaximumSamples = Tools.ToUInt16(bBuffer, 2);
                                this.m_uiMinimumFrameSize = Tools.ToUInt32(bBuffer, 4, 3);
                                this.m_uiMaximumFrameSize = Tools.ToUInt32(bBuffer, 7, 3);
                                
                                a = (System.UInt32)Tools.ToUInt16(bBuffer, 10) * 256 + (System.UInt32)(byte)(bBuffer[12] >> 4);
                                b = (byte)(bBuffer[12] >> 4);
                                Console.WriteLine(a.ToString());
                                
                                return;
                        }
                }
        }       
}

---