code/Audio/Metadata/ID3/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.ID3
{
    public class V2
    {
        #region Classes

        public class BitFlags
        {
            public bool IsUnsynchronised { get; set; }
            public bool IsExtendedHeader { get; set; }
            public bool IsExperimentalIndicator { get; set; }
            public bool IsFooterPresent { get; set; }

            public BitFlags(byte flag)
            {
                this.SetValues(flag);
            }

            public void Clear()
            {
                this.IsUnsynchronised = false;
                this.IsExtendedHeader = false;
                this.IsExperimentalIndicator = false;
                this.IsFooterPresent = false;
            }

            public void Set(byte flag)
            {
                this.SetValues(flag);
            }

            public byte ToByte()
            {
                //   6543
                // %0abcd000 
                byte r = (byte)0;
                if (this.IsUnsynchronised) { r = Sylloge.Memory.SetBit(r, 6); }
                if (this.IsExtendedHeader) { r = Sylloge.Memory.SetBit(r, 5); }
                if (this.IsExperimentalIndicator) { r = Sylloge.Memory.SetBit(r, 4); }
                if (this.IsFooterPresent) { r = Sylloge.Memory.SetBit(r, 3); }
                return r;
            }

            private void SetValues(byte flag)
            {
                this.IsUnsynchronised = Sylloge.Memory.IsBitSet(flag, 7); // a
                this.IsExtendedHeader = Sylloge.Memory.IsBitSet(flag, 6); // b
                this.IsExperimentalIndicator = Sylloge.Memory.IsBitSet(flag, 5); // c
                this.IsFooterPresent = Sylloge.Memory.IsBitSet(flag, 4); // d
            }
        }

        public class ExtendedHeader
        {
            public int FlagCount { get; private set; }
            public int Size { get; private set; }
            private byte[] m_flags = null;

            public ExtendedHeader(byte[] exhdr)
            {
                if (exhdr == null) { throw new System.ArgumentNullException("exhdr"); }
                this.Size = ID3.Helper.FromSynchsafeInt(BitConverter.ToInt32(Sylloge.Memory.SwapByteOrder(exhdr, 0, 4), 0));
                this.FlagCount = (int)exhdr[4];
                int len = this.Size - 5;
                this.m_flags = new byte[len];
                System.Buffer.BlockCopy(exhdr, 5, this.m_flags, 0, len);
            }

            public byte[] ToBytes()
            {
                byte[] buf = new byte[this.Size];
                byte[] sz = Sylloge.Memory.SwapByteOrder(BitConverter.GetBytes(ID3.Helper.ToSynchsafeInt(this.Size)));
                System.Buffer.BlockCopy(sz, 0, buf, 0, 4);
                buf[4] = (byte)this.FlagCount;
                System.Buffer.BlockCopy(this.m_flags, 0, buf, 5, this.m_flags.Length);
                return buf;
            }
        }

        public class TagFooter
        {
            public const string ID = "3DI";
            public int VersionMajor { get; private set; }
            public int VersionMinor { get; private set; }
            public BitFlags Flags { get; private set; }
            public int Size { get; private set; }

            public TagFooter(byte[] ftr)
            {
                if (ftr == null) { throw new System.ArgumentNullException("ftr"); }
                if (ftr.Length != 10) { throw new System.ArgumentOutOfRangeException("ftr", "Data length must be 10 bytes"); }
                if (ID3.Helper.ISO.GetString(ftr, 0, 3) == TagFooter.ID) { // Its a valid tag, so continue
                    // ID3v2 version              $04 00 (byte 3-4, len=2)
                    this.VersionMajor = (int)ftr[3];
                    this.VersionMinor = (int)ftr[4];
                    if (this.VersionMajor <= 4 && this.VersionMinor < 255) {
                        //                         bit:76543210
                        // ID3v2 flags                %abcd0000
                        this.Flags = new BitFlags(ftr[5]);
                        /* The ID3v2 tag size is stored as a 32 bit synchsafe integer (section
                        6.2), making a total of 28 effective bits (representing up to 256MB).

                        The ID3v2 tag size is the sum of the byte length of the extended
                        header, the padding and the frames after unsynchronisation. If a
                        footer is present this equals to ('total size' - 20) bytes, otherwise
                        ('total size' - 10) bytes. */
                        this.Size = ID3.Helper.FromSynchsafeInt(BitConverter.ToInt32(Sylloge.Memory.SwapByteOrder(ftr, 6, 4), 0));
                        this.Size -= (this.Flags.IsFooterPresent ? 20 : 10);
                        // this.Size should always be -20 in this instance since we are in the footer
                    }
                }
            }

            public byte[] ToBytes()
            {
                byte[] buf = new byte[10];
                System.Buffer.BlockCopy(ID3.Helper.ISO.GetBytes(TagFooter.ID), 0, buf, 0, 3);
                buf[3] = (byte)this.VersionMajor;
                buf[4] = (byte)this.VersionMinor;
                buf[5] = this.Flags.ToByte();
                byte[] sz = BitConverter.GetBytes(ID3.Helper.ToSynchsafeInt(this.Size));
                System.Buffer.BlockCopy(sz, 0, buf, 6, 4);
                return buf;

            }
        }

        #endregion

        #region Local Attributes

        #region Header/Footer Info

        public BitFlags Flags { get; protected set; }
        public ExtendedHeader Extended { get; protected set; }
        public TagFooter Footer { get; protected set; }

        #endregion

        #region Frames

        public ID3.Frames.TextFrame Artist { get; protected set; }
        public ID3.Frames.TextFrame Album { get; protected set; }
        public ID3.Frames.TextFrame Genre { get; protected set; }
        public ID3.Frames.TextFrame Title { get; protected set; }
        public ID3.Frames.TextFrame Year { get; protected set; }
        public ID3.Frames.TextFrame AlbumArtist { get; protected set; }
        public ID3.Frames.TextFrame Composer { get; protected set; }
        public ID3.Frames.TextFrame Copyright { get; protected set; }
        public ID3.Frames.TextFrame DiscNumber { get; protected set; }
        public ID3.Frames.TextFrame EncodedBy { get; protected set; }
        public ID3.Frames.TextFrame OriginalArtist { get; protected set; }
        public ID3.Frames.TextFrame Publisher { get; protected set; }
        public ID3.Frames.TextFrame TrackNumber { get; protected set; }
        public List<ID3.Frames.AttachedPicture> Images { get; protected set; }
        public List<ID3.Frames.Comment> Comments { get; protected set; }
        public List<ID3.Frames.UserDefinedString> UserDefinedStrings { get; protected set; }
        public List<ID3.Frames.UserDefinedURL> UserDefinedUrls { get; protected set; }

        private List<ID3.Frame> m_unsupported;

        public ID3.Frame[] OtherFrames
        {
            get
            {
                return (this.m_unsupported != null ? this.m_unsupported.ToArray() : null);
            }
        }

        #endregion

        // these can be multiple values, but are here for simplicities sake

        public string Comment
        {
            get
            {
                if (this.Comments != null && this.Comments.Count > 0) { return this.Comments[0].Value;  }
                return string.Empty;
            }
        }
        public ID3.Frames.AttachedPicture Image
        {
            get { return ((this.Images != null && this.Images.Count > 0) ? this.Images[0] : null); }
        }
        public string URL
        {
            get { return ((this.UserDefinedUrls != null && this.UserDefinedUrls.Count > 0) ? this.UserDefinedUrls[0].Value : null); }
        }
        public string UserText
        {
            get { return ((this.UserDefinedStrings != null && this.UserDefinedStrings.Count > 0) ? this.UserDefinedStrings[0].Value : null); }
        }
        
        public byte[] Data { get; protected set; }
        public string File { get; protected set; }
        public bool IsValid { get; protected set; }
        public System.Version Version { get; protected set; }
        public int HeaderLength { get; protected set; }

        #endregion

        #region Methods

        public V2()
        {
            this.Version = new Version(2, 4, 0);
            this.Clear();
        }

        public void AddFrame(Sylloge.Audio.Metadata.ID3.Frame frame)
        {
            // DEV_NOTE: For more information on the tags, visit http://www.id3.org
            switch (frame.ID) {
                case ID3.Frame.Keys.AttachedPicture: // can be multiple
                    this.AddImage(Frames.AttachedPicture.Parse(frame));
                    break;
                case ID3.Frame.Keys.Comment: // can be multiple
                    this.AddComment(Frames.Comment.Parse(frame));
                    break;
                case ID3.Frame.Keys.UserDefinedString: // can be multiple
                    this.AddUserText(Frames.UserDefinedString.Parse(frame));
                    break;
                case ID3.Frame.Keys.UserDefinedURL: // can be multiple
                    this.AddURL(Frames.UserDefinedURL.Parse(frame));
                    break;
                case ID3.Frame.Keys.Album:
                    this.Album = new Frames.TextFrame(frame);
                    break;
                case ID3.Frame.Keys.Composer:
                    this.Composer = new Frames.TextFrame(frame);
                    break;
                case ID3.Frame.Keys.Genre:
                    this.Genre = new Frames.TextFrame(frame);
                    break;
                case ID3.Frame.Keys.CopyrightInfo:
                    this.Copyright = new Frames.TextFrame(frame);
                    break;
                case ID3.Frame.Keys.EncodedBy:
                    this.EncodedBy = new Frames.TextFrame(frame);
                    break;
                case ID3.Frame.Keys.TitleOfSong:
                    this.Title = new Frames.TextFrame(frame);
                    break;
                case ID3.Frame.Keys.OriginalArtist:
                    this.OriginalArtist = new Frames.TextFrame(frame);
                    break;
                case ID3.Frame.Keys.Artist:
                    this.Artist = new Frames.TextFrame(frame);
                    break;
                case ID3.Frame.Keys.AlbumArtist:
                    this.AlbumArtist = new Frames.TextFrame(frame);
                    break;
                case ID3.Frame.Keys.DiscNumber:
                    this.DiscNumber = new Frames.TextFrame(frame);
                    break;
                case ID3.Frame.Keys.Publisher:
                    this.Publisher = new Frames.TextFrame(frame);
                    break;
                case ID3.Frame.Keys.Track:
                    this.TrackNumber = new Frames.TextFrame(frame);
                    break;
                case ID3.Frame.Keys.Year:
                    this.Year = new Frames.TextFrame(frame);
                    break;
                default: // add tags as needed to incorperate
                    this.m_unsupported.Add(frame);
                    break; 
            }
        }

        private void AddComment(ID3.Frames.Comment comment)
        {
            if (comment == null) { throw new System.ArgumentNullException("comment"); }
            this.Comments.Add(comment);
        }

        private void AddComment(string comment)
        {
            if (comment == null) { throw new System.ArgumentNullException("comment"); }
            this.AddComment(new ID3.Frames.Comment(comment));
        }

        private void AddImage(ID3.Frames.AttachedPicture img)
        {
            if (img == null) { throw new System.ArgumentNullException("img"); }
            this.Images.Add(img);
        }

        private void AddImage(System.Drawing.Image img)
        {
            if (img == null) { throw new System.ArgumentNullException("img"); }
            this.Images.Add(new ID3.Frames.AttachedPicture(img));
        }

        private void AddURL(ID3.Frames.UserDefinedURL url)
        {
            if (url == null) { throw new System.ArgumentNullException("url"); }
            this.UserDefinedUrls.Add(url);
        }

        private void AddURL(string url)
        {
            if (url == null) { throw new System.ArgumentNullException("url"); }
            this.UserDefinedUrls.Add(new ID3.Frames.UserDefinedURL(url));
        }

        private void AddUserText(ID3.Frames.UserDefinedString txt)
        {
            if (txt == null) { throw new System.ArgumentNullException("txt"); }
            this.UserDefinedStrings.Add(txt);
        }

        private void AddUserText(string txt)
        {
            if (txt == null) { throw new System.ArgumentNullException("txt"); }
            this.UserDefinedStrings.Add(new ID3.Frames.UserDefinedString(txt));
        }

        public void Clear()
        {
            this.IsValid = false;
            if (this.Flags != null) { this.Flags.Clear(); }
            this.Flags = new BitFlags((byte)0);
            this.Extended = null;
            this.Footer = null;
            if (this.Images != null) { this.Images.Clear(); this.Images.TrimExcess(); }
            if (this.Comments != null) { this.Comments.Clear(); this.Comments.TrimExcess(); }
            if (this.UserDefinedStrings != null) { this.UserDefinedStrings.Clear(); this.UserDefinedStrings.TrimExcess(); }
            if (this.UserDefinedUrls != null) { this.UserDefinedUrls.Clear(); this.UserDefinedUrls.TrimExcess(); }
            if (this.m_unsupported != null) { this.m_unsupported.Clear(); this.m_unsupported.TrimExcess(); }
            this.Images = new List<ID3.Frames.AttachedPicture>();
            this.Comments = new List<ID3.Frames.Comment>();
            this.UserDefinedStrings = new List<ID3.Frames.UserDefinedString>();
            this.UserDefinedUrls = new List<ID3.Frames.UserDefinedURL>();
            this.Title = new Frames.TextFrame(Frame.Keys.TitleOfSong);
            this.Artist = new Frames.TextFrame(Frame.Keys.Artist);
            this.Album = new Frames.TextFrame(Frame.Keys.Album);
            this.Year = new Frames.TextFrame(Frame.Keys.Year);
            this.Genre = new Frames.TextFrame(Frame.Keys.Genre);
            this.Composer = new Frames.TextFrame(Frame.Keys.Composer);
            this.Copyright = new Frames.TextFrame(Frame.Keys.CopyrightInfo);
            this.EncodedBy = new Frames.TextFrame(Frame.Keys.EncodedBy);
            this.OriginalArtist = new Frames.TextFrame(Frame.Keys.OriginalArtist);
            this.AlbumArtist = new Frames.TextFrame(Frame.Keys.AlbumArtist);
            this.DiscNumber = new Frames.TextFrame(Frame.Keys.DiscNumber);
            this.Publisher = new Frames.TextFrame(Frame.Keys.Publisher);
            this.TrackNumber = new Frames.TextFrame(Frame.Keys.Track);
            this.m_unsupported = new List<ID3.Frame>();
        }

        public int CalculateHeaderSize()
        {
            byte[] d = this.GenerateAllTagBytes();
            return d.Length;
        }

        public byte[] CalculateDataBytes()
        {
            int hlen = 10;
            if (this.Flags.IsFooterPresent) { hlen = 20; }
            byte[] data = this.GenerateAllTagBytes();
            byte[] hdr = new byte[(hlen + data.Length)];
            byte[] sz = Sylloge.Memory.SwapByteOrder(BitConverter.GetBytes(ID3.Helper.ToSynchsafeInt(data.Length)), 0, 4);
            System.Buffer.BlockCopy(ID3.Helper.ISO.GetBytes("ID3"), 0, hdr, 0, 3);
            hdr[3] = Convert.ToByte(this.Version.Minor);
            hdr[4] = Convert.ToByte(this.Version.Build);
            hdr[5] = this.Flags.ToByte();
            // copy the size in the header (We don't count the 10 byte header for the size of the tag in bytes)
            System.Buffer.BlockCopy(sz, 0, hdr, 6, 4);
            // copy the data
            System.Buffer.BlockCopy(data, 0, hdr, 10, data.Length);
            return hdr;
        }

        public bool Save()
        {
            // DEV_NOTE: Be sure that if you added any extra processing in the
            // other functions to handle other tag types, if you wish to save
            // that data you need to also add the handling here and in GenerateTag(ID)
            try {
                byte[] hdr = this.CalculateDataBytes();
                // write it the file
                System.IO.FileStream fin = new System.IO.FileStream(this.File, System.IO.FileMode.Open, System.IO.FileAccess.ReadWrite, System.IO.FileShare.ReadWrite);
                int hlen = this.HeaderLength + (this.Flags.IsFooterPresent ? 20 : 10);
                byte[] mp3 = new byte[(fin.Length - hlen)];
                byte[] fdata = new byte[(hdr.Length + mp3.Length)];
                // read the file data (sans ID3v2 tag)
                fin.Seek(hlen, System.IO.SeekOrigin.Begin);
                fin.Read(mp3, 0, mp3.Length);
                // copy ID3v2 tag header w/ 10 byte header into the file data
                System.Buffer.BlockCopy(hdr, 0, fdata, 0, hdr.Length);
                // copy MP3 data into file data
                System.Buffer.BlockCopy(mp3, 0, fdata, hdr.Length, mp3.Length);
                fin.Seek(0, System.IO.SeekOrigin.Begin);
                fin.SetLength(0); fin.Flush();
                fin.Write(fdata, 0, fdata.Length);
                fin.Flush(); fin.Close();
                this.HeaderLength = hdr.Length - 10; // -10 for the tag header
                if (this.Flags.IsFooterPresent) { this.HeaderLength -= 10; }
                return true;
            } catch (Exception ex) {
                throw ex;
            }
        }

        public void SetFlags(BitFlags flags)
        {
            this.Flags = flags;
        }

        public void SetFile(string file)
        {
            this.File = file;
        }

        public void SetYear(DateTime d)
        {
            this.Year.SetValue(d.ToString("yyyy-MM-ddTHH:mm:ss"));
        }

        public void SetVersion(System.Version ver)
        {
            this.Version = ver;
        }

        public void SetVersion(string ver)
        {
            this.Version = System.Version.Parse(ver);
        }

        public override string ToString()
        {
            return this.Artist.Value + " - " + this.Title.Value;
        }

        #endregion

        #region Private Methods

        private byte[] GenerateAllTagBytes()
        {
            List<byte> data = new List<byte>();
            data.AddRange(this.Artist.GenerateTag());
            data.AddRange(this.Title.GenerateTag());
            data.AddRange(this.Album.GenerateTag());
            data.AddRange(this.DiscNumber.GenerateTag());
            data.AddRange(this.TrackNumber.GenerateTag());
            data.AddRange(this.Year.GenerateTag());
            data.AddRange(this.Genre.GenerateTag());
            data.AddRange(this.GenerateTagBytesFromAllComments());
            data.AddRange(this.Copyright.GenerateTag());
            data.AddRange(this.Composer.GenerateTag());
            data.AddRange(this.OriginalArtist.GenerateTag());
            data.AddRange(this.AlbumArtist.GenerateTag());
            data.AddRange(this.EncodedBy.GenerateTag());
            data.AddRange(this.Publisher.GenerateTag());
            data.AddRange(this.GenerateTagBytesFromAllUDT());
            data.AddRange(this.GenerateTagBytesFromAllUDURL());
            data.AddRange(this.GenerateTagBytesFromUnsupported());
            // DEV_NOTE: Be sure to copy any extra processed data here. Its good to try and keep imgs last in the tag
            data.AddRange(this.GenerateTagBytesFromAllImages());
            return data.ToArray();
        }

        private byte[] GenerateTagBytesFromAllImages()
        {
            List<byte> all = new List<byte>();
            foreach (ID3.Frames.AttachedPicture i in this.Images) {
                all.AddRange(i.GenerateTag());
            }
            return all.ToArray();
        }

        private byte[] GenerateTagBytesFromAllComments()
        {
            List<byte> all = new List<byte>();
            foreach (ID3.Frames.Comment c in this.Comments) {
                all.AddRange(c.GenerateTag());
            }
            return all.ToArray();
        }

        private byte[] GenerateTagBytesFromAllUDT()
        {
            List<byte> all = new List<byte>();
            foreach (ID3.Frames.UserDefinedString udt in this.UserDefinedStrings) {
                all.AddRange(udt.GenerateTag());
            }
            return all.ToArray();
        }

        private byte[] GenerateTagBytesFromAllUDURL()
        {
            List<byte> all = new List<byte>();
            foreach (ID3.Frames.UserDefinedURL url in this.UserDefinedUrls) {
                all.AddRange(url.GenerateTag());
            }
            return all.ToArray();
        }

        private byte[] GenerateTagBytesFromUnsupported()
        {
            List<byte> all = new List<byte>();
            foreach (ID3.Frame f in this.m_unsupported) {
                all.AddRange(f.GenerateTag());
            }
            return all.ToArray();
        }

        #endregion

        #region Static Methods

        public static Frame[] ReadHeaderInfo(byte[] data, bool unsynchronisation)
        {
            if (data == null) { throw new System.ArgumentNullException("data"); }
            Frame tag = null;
            List<Frame> frames = new List<Frame>();
            List<byte> dbuf = new List<byte>(data);
            byte[] buf = dbuf.ToArray();
            while (buf != null && buf.Length > 0) {
                tag = ID3.Frame.Parse(buf, unsynchronisation);
                if (tag != null) {
                    dbuf.RemoveRange(0, tag.FullFrameLength);
                    frames.Add(tag);
                } else {
                    if (buf.Length < 4) { break; }
                    bool is_pad = true;
                    for (int i = 0; i < 4; i++) {
                        if (buf[i] > 0) {
                            is_pad = false;
                            break;
                        }
                    }
                    if (is_pad) { break; }
                    dbuf.RemoveRange(0, 4);
                }
                buf = dbuf.ToArray();
            }
            return frames.ToArray();
        }

        public static V2 Parse(string file)
        {
            if (System.IO.File.Exists(file)) {
                V2 ret = new V2();
                ret.File = file;
                System.IO.FileStream fin = new System.IO.FileStream(file, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite);
                byte[] hdr_data = new byte[10];
                byte[] buf = null;
                fin.Read(hdr_data, 0, 10);
                // ID3v2/file identifier      "ID3" (byte 0-2, len=3)
                if (ID3.Helper.ISO.GetString(hdr_data, 0, 3) == "ID3") { // Its a valid tag, so continue
                    // ID3v2 version              $04 00 (byte 3-4, len=2)
                    // The first byte of ID3v2 version is its major version, while the second byte is its revision number
                    // DEV_NOTE, since we're using the .NET Version class, "major" == Version.Minor and "revision" == Version.Build
                    ret.Version = new Version(2, Convert.ToInt32(hdr_data[3]), Convert.ToInt32(hdr_data[4]));
                    /* DEV_NOTE: from the ID3 spec -
                      If software with ID3v2.4.0 and below support should encounter version five or
                      higher it should simply ignore the whole tag. Version or revision will never be $FF.
                     
                      the current version supported by Sylloge is 2.4.0, so we shall comply */
                    if (ret.Version.Minor <= 4 && ret.Version.Build < 255) {
                        //                         bit:76543210
                        // ID3v2 flags                %abcd0000
                        ret.Flags.Set(hdr_data[5]);
                        /* The ID3v2 tag size is stored as a 32 bit synchsafe integer (section
                        6.2), making a total of 28 effective bits (representing up to 256MB).

                        The ID3v2 tag size is the sum of the byte length of the extended
                        header, the padding and the frames after unsynchronisation. If a
                        footer is present this equals to ('total size' - 20) bytes, otherwise
                        ('total size' - 10) bytes. */
                        int tagsz = ID3.Helper.FromSynchsafeInt(BitConverter.ToInt32(Sylloge.Memory.SwapByteOrder(hdr_data, 6, 4), 0));
                        tagsz -= (ret.Flags.IsFooterPresent ? 20 : 10);
                        ret.HeaderLength = tagsz;
                        if (tagsz > 0) {
                            if (ret.Flags.IsExtendedHeader) {
                                byte[] exhdr = new byte[4];
                                fin.Read(exhdr, 0, 4);
                                int exsz = ID3.Helper.FromSynchsafeInt(BitConverter.ToInt32(Sylloge.Memory.SwapByteOrder(exhdr, 0, 4), 0));
                                exhdr = new byte[exsz];
                                fin.Position -= 4; // go back 4 bytes in the stream to re-read the entire header
                                fin.Read(exhdr, 0, exsz);
                                ret.Extended = new ExtendedHeader(exhdr);
                            }
                            buf = new byte[tagsz];
                            fin.Read(buf, 0, tagsz);
                            if (ret.Flags.IsFooterPresent) {
                                byte[] ftr = new byte[10];
                                fin.Read(ftr, 0, 10);
                                ret.Footer = new TagFooter(ftr);
                            }
                            ret.IsValid = true;
                        }
                    }
                }
                fin.Close();
                if (ret.IsValid) {
                    List<Frame> frames = new List<Frame>(V2.ReadHeaderInfo(buf, ret.Flags.IsUnsynchronised));
                    foreach (Frame f in frames) {
                        ret.AddFrame(f);
                    }
                }
                return ret;
            }
            return null;
        }

        public static bool TryParse(string file, out V2 v2)
        {
            try {
                v2 = V2.Parse(file);
                return true;
            }
            catch (Exception) { v2 = null; }
            return false;
        }

        #endregion
    }
}