code/Audio/Metadata/APE/V2.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Sylloge.Audio.Metadata.APE
{
    public class V2
    {
        public class Tag
        {
            public enum ValueType
            {
                UTF8Text,
                Binary,
                ExternalStore,
                Reserved
            }

            public int Length { get; protected set; }
            public string Key { get; protected set; }
            public byte[] Flags { get; protected set; }
            public byte[] Data { get; protected set; }
            public bool HasHeader { get; protected set; }
            public bool HasFooter { get; protected set; }
            public bool IsFooter { get; protected set; }
            public ValueType DataType { get; protected set; }
            public bool ReadOnly { get; protected set; }

            public int TotalLength
            {
                get
                {
                    return this.Length + this.Key.Length + 1 + 8;
                }
            }

            public Tag()
            {
            }

            public static Tag Parse(byte[] data)
            {
                Tag ret = null;
                try {
                    ret = new Tag();
                    ret.Length = BitConverter.ToInt32(data, 0);
                    ret.Flags = new byte[4] { data[4], data[5], data[6], data[7] };
                    // Bit 31   0: Tag contains no header, 1: Tag contains a header
                    ret.HasHeader = Sylloge.Memory.IsBitSet(data[4], 7);
                    // Bit 30   0: Tag contains a footer, 1: Tag contains no footer
                    ret.HasFooter = Sylloge.Memory.IsBitSet(data[4], 6);
                    // Bit 29   0: This is the footer, not the header, 1: This is the header, not the footer
                    ret.IsFooter = Sylloge.Memory.IsBitSet(data[4], 5);
                    // Bit 28...3       Undefined, must be zero
                    /*
                    * Bit 2...1     0: Item contains text information coded in UTF-8
                    *               1: Item contains binary information*
                    *               2: Item is a locator of external stored information**
                    *               3: reserved
                    */
                    ret.DataType = ValueType.UTF8Text;
                    bool b1 = Sylloge.Memory.IsBitSet(data[7], 1);
                    bool b2 = Sylloge.Memory.IsBitSet(data[7], 2);
                    if (b1 || b2) {
                        if (b1 && b2) {
                            ret.DataType = ValueType.Reserved;
                        } else {
                            if (b1) {
                                ret.DataType = ValueType.Binary;
                            } else {
                                ret.DataType = ValueType.ExternalStore;
                            }
                        }
                    }
                    // Bit 0    0: Tag or Item is Read/Write, 1: Tag or Item is Read Only 
                    ret.ReadOnly = Sylloge.Memory.IsBitSet(data[7], 0);
                    int i = 8; List<byte> kd = new List<byte>();
                    for (; i < data.Length; i++) {
                        if (data[i] == 0x00) { break; }
                        kd.Add(data[i]);
                    }
                    ret.Key = System.Text.Encoding.ASCII.GetString(kd.ToArray());
                    ret.Data = new byte[ret.Length];
                    System.Buffer.BlockCopy(data, (i+1), ret.Data, 0, ret.Length);
                    /*
                    Size of the Item Value, Bits 0...7
                    Size of the Item Value, Bits 8...15
                    Size of the Item Value, Bits 16...23
                    Size of the Item Value, Bits 24...31
                        32 bits         Length len of the assigned value in bytes

                    Item Flags, Bits 0...7
                    Item Flags, Bits 8...15
                    Item Flags, Bits 16...23
                    Item Flags, Bits 24...31
                        32 bits         Item flags
                    Item Key    m bytes         Item key, can contain ASCII characters from 0x20 (Space) up to 0x7E (Tilde)
                    0x00        1byte   Item key terminator
                    Item Value  len bytes       Item value, can be binary data or UTF-8 string 
                     */
                } catch (Exception) {
                    ret = null;
                }
                return ret;
            }
        }

        public System.Version Version { get; protected set; }
        public bool IsValid { get; protected set; }
        public int Size { get; protected set; }
        public int TagCount { get; protected set; }
        public byte[] GlobalFlags { get; protected set; }
        public byte[] Data { get; protected set; }
        public List<Tag> Tags { get; protected set; }

        public V2()
        {
            this.Clear();
        }

        public void Clear()
        {
            if (this.Tags != null && this.Tags.Count > 0) { this.Tags.Clear(); this.Tags.TrimExcess(); }
            this.Tags = new List<Tag>();
            this.Version = new Version(2, 0, 0, 0);
            this.Size = 0;
            this.TagCount = 0;
            this.GlobalFlags = null;
            this.Data = null;
            this.IsValid = false;
        }

        public static V2 Parse(byte[] b)
        {
            if (b == null) { throw new System.ArgumentNullException("byte value cannot be null"); }
            System.Text.Encoding enc = System.Text.Encoding.UTF8;
            if (System.Text.Encoding.ASCII.GetString(b, 0, 8) != "APETAGEX") { throw new System.ArgumentException("No valid tag detected"); };
            try {
                char[] tc = new char[] { '\0', ' ' };
                V2 ret = V2.ParseHeader(b);
                ret.Data = b;
                ret.IsValid = true;
                List<byte> data = new List<byte>(b);
                data.RemoveRange(0, 32); // get rid of the header
                while (data.Count > 0) {
                    Tag t = Tag.Parse(data.ToArray());
                    if (t != null) {
                        data.RemoveRange(0, t.TotalLength);
                        ret.Tags.Add(t);
                    } else {
                        break;
                    }
                }
                return ret;
            } catch (Exception ex) {
                throw ex;
            }
        }

        private static V2 ParseHeader(byte[] b)
        {
            if (System.Text.Encoding.ASCII.GetString(b, 0, 8) == "APETAGEX") {
                V2 ret = new V2();
                List<byte> data = new List<byte>(b);
                //Preamble      64 bits         { 'A', 'P', 'E', 'T', 'A', 'G', 'E', 'X' }
                data.RemoveRange(0, 8);
                // Version 32 bits  1000 = Version 1.000 (old), 2000 = Version 2.000 (new)
                // Version Number, Bits 0...7
                // Version Number, Bits 8...15
                // Version Number, Bits 16...23
                // Version Number, Bits 24...31
                ret.Version = new Version(data[0], data[1], data[2], data[3]);
                data.RemoveRange(0, 4);
                // Size 32 bits         Tag size in bytes including footer and all tag items excluding the header to be as compatible as possible with APE Tags 1.000
                // Tag Size, Bits 0... 7
                // Tag Size, Bits 8...15
                // Tag Size, Bits 16...23
                // Tag Size, Bits 24...31
                ret.Size = BitConverter.ToInt32(data.ToArray(), 0);
                ret.Data = new byte[ret.Size];
                data.RemoveRange(0, 4);
                // Tag Count    32 bits         Number of items in the Tag (n)
                // Item Count, Bits 0... 7
                // Item Count, Bits 8...15
                // Item Count, Bits 16...23
                // Item Count, Bits 24...31
                ret.TagCount = BitConverter.ToInt32(data.ToArray(), 0);
                data.RemoveRange(0, 4);
                // Tag flags    32 bits Global flags of all items (there are also private flags for every item)
                // Tags Flags, Bits 0... 7
                // Tags Flags, Bits 8...15
                // Tags Flags, Bits 16...23
                // Tags Flags, Bits 24...31
                ret.GlobalFlags = new byte[4] { data[0], data[1], data[2], data[3] };
                data.RemoveRange(0, 4);
                // Reserved     64 bits         Must be zero
                long v = BitConverter.ToInt64(data.ToArray(), 0);
                if (v == 0) { return ret; }
            }
            return null;
        }

        public static V2 Parse(string file)
        {
            // no try catch here since we want the exception to propigate up
            if (System.IO.File.Exists(file)) {
                byte[] tag = new byte[128];
                byte[] tagp = new byte[227];
                System.IO.FileStream fin = new System.IO.FileStream(file, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite);
                long strt = -32; // 32 bytes for an APE header starting with "APETAGEX" (remember 32bits = 4bytes)
                fin.Seek(-355, System.IO.SeekOrigin.End);
                fin.Read(tagp, 0, 227); // read the "TAG+" first (doesn't matter if it exists since this advances the read stream)
                fin.Read(tag, 0, 128); // read the "TAG" next
                if (ID3.Helper.ISO.GetString(tag, 0, 3) == "TAG") { strt -= 128; }
                if (ID3.Helper.ISO.GetString(tagp, 0, 4) == "TAG+") { strt -= 227; }
                tag = new byte[32];
                fin.Seek(strt, System.IO.SeekOrigin.End);
                fin.Read(tag, 0, 32);
                V2 ret = V2.ParseHeader(tag);
                if (ret != null) {
                    strt = -(ret.Size + Math.Abs(strt));
                    fin.Seek(strt, System.IO.SeekOrigin.End);
                    fin.Read(ret.Data, 0, ret.Size);
                    ret.IsValid = true;
                    ret = V2.Parse(ret.Data);
                }
                fin.Close(); fin = null;
                return ret;
            }
            return null;
        }
    }
}