code/Audio/Metadata/ID3/V1.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 V1
    {
        #region dev notes

        /* Tag info
        ID3v1 Tag information
        Last 128 bytes of MP3 file
        first 3 bytes MUST be 'TAG' for it to be valid
        Length(bytes)  Position(bytes)   Description
        3              (0-2)             Tag identification. Must contain 'TAG' if tag exists and is correct.
        30             (3-32)            Title
        30             (33-62)           Artist
        30             (63-92)           Album
        4              (93-96)           Year
        30             (97-126)          Comment
        1              (127)             Genre
          
        DEV_NOTE: The 'TAG' portion of the ID3v1 tag is read in ANSI.
        */

        #endregion

        #region Extended V1 (TAG+) Header Class
        
        public class TagPlus
        {
            public enum SpeedDesignator
            {
                Unset = 0,
                Slow,
                Medium,
                Fast,
                Hardcore
            }

            public string ExtendedTitle { get; set; }
            public string ExtendedArtist { get; set; }
            public string ExtendedAlbum { get; set; }
            public SpeedDesignator Speed { get; set; }
            public string Genre { get; set; }
            public string StartTime { get; set; }
            public string EndTime { get; set; }
            public byte[] Data { get; protected set; }
            public bool IsValid { get; protected set; }

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

            public void Clear()
            {
                this.ExtendedTitle = string.Empty;
                this.ExtendedArtist = string.Empty;
                this.ExtendedAlbum = string.Empty;
                this.Speed = SpeedDesignator.Unset;
                this.Genre = string.Empty;
                this.StartTime = string.Empty;
                this.EndTime = string.Empty;
            }

            public static TagPlus Parse(byte[] b)
            {
                if (b == null) { throw new System.ArgumentNullException("byte value cannot be null"); }
                if (b.Length != 227) { throw new System.ArgumentOutOfRangeException("ID3v1 extende tag length must be 227 bytes"); }
                System.Text.Encoding enc = ID3.Helper.ISO;
                if (enc.GetString(b, 0, 4) != "TAG+") { throw new System.ArgumentException("ID3v1 extended tag must begin with 'TAG+'"); };
                try {
                    char[] tc = new char[] { '\0', ' ' };
                    TagPlus ret = new TagPlus();
                    /*
                    Note: The extended tag is 227 bytes long, and placed before the ID3v1 tag.
                    Field       Length  Description
                    header      4       "TAG+"
                    title       60      60 characters of the title
                    artist      60      60 characters of the artist name
                    album       60      60 characters of the album name
                    speed       1       0=unset, 1=slow, 2= medium, 3=fast, 4=hardcore
                    genre       30      A free-text field for the genre
                    start-time  6       the start of the music as mmm:ss
                    end-time    6       the end of the music as mmm:ss
                     */
                    ret.ExtendedTitle = enc.GetString(b, 4, 60).TrimEnd(tc); // 4+60
                    ret.ExtendedArtist = enc.GetString(b, 64, 60).TrimEnd(tc); // 64+60
                    ret.ExtendedAlbum = enc.GetString(b, 124, 60).TrimEnd(tc); // 124+60
                    ret.Speed = (SpeedDesignator)b[184]; // 184+1
                    ret.Genre = enc.GetString(b, 185, 30).TrimEnd(tc); // 185+30
                    ret.StartTime = enc.GetString(b, 215, 6).TrimEnd(tc); // 215+6
                    ret.EndTime = enc.GetString(b, 221, 6).TrimEnd(tc); // 221+6
                    ret.Data = b;
                    ret.IsValid = true;
                    return ret;
                } catch (Exception ex) {
                    throw ex;
                }
            }
        }

        #endregion

        #region ID3 Tag Values

        public string Artist { get; set; }
        public string Album { get; set; }
        public string Title { get; set; }
        public string Comment { get; set; }
        public string File { get; protected set; }
        public ID3.Genre Genre { get; set; }
        public bool IsValid { get; protected set; }
        public int Track { get; set; }
        public string Year { get; protected set; }
        public System.Version Version { get; protected set; }
        public byte[] Data { get; protected set; }
        public TagPlus Extended { get; protected set; }

        #endregion

        #region Methods

        public V1()
        {
            this.Clear();
            this.Version = new Version(1, 0, 0);
        }

        public void Clear()
        {
            this.IsValid = false;
            this.Title = string.Empty;
            this.Artist = string.Empty;
            this.Album = string.Empty;
            this.Year = "1970";
            this.Comment = string.Empty;
            this.Genre = ID3.Genre.Other;
            this.Track = 0;
            this.Extended = new TagPlus();
        }

        public bool Save()
        {
            if (!System.IO.File.Exists(this.File)) { return false; }
            try {
                /*
                 * Last 128 bytes of MP3 file
                first 3 bytes MUST be 'TAG' for it to be valid
                Length(bytes)  Position(bytes)   Description
                3              (0-2)             Tag identification. Must contain 'TAG' if tag exists and is correct.
                30             (3-32)            Title
                30             (33-62)           Artist
                30             (63-92)           Album
                4              (93-96)           Year
                30*            (97-126)*         Comment
                1*             (125)*            0-Byte pad for track (if present)
                1*             (126)*            Track
                1              (127)             Genre 
                
                Note that per ID3v1.1, if byte 125 is a binary 0, then byte 126 is the
                track number. 
                 */
                System.Text.Encoding enc = ID3.Helper.ISO;
                byte[] tdata = new byte[128];
                Sylloge.Memory.Copy(enc.GetBytes("TAG"), 0, tdata, 0, 3);
                Sylloge.Memory.Copy(enc.GetBytes(this.Title), 0, tdata, 3, 30);
                Sylloge.Memory.Copy(enc.GetBytes(this.Artist), 0, tdata, 33, 30);
                Sylloge.Memory.Copy(enc.GetBytes(this.Album), 0, tdata, 63, 30);
                Sylloge.Memory.Copy(enc.GetBytes(this.Year), 0, tdata, 93, 4);
                if (this.Track > 0) {
                    Sylloge.Memory.Copy(enc.GetBytes(this.Comment), 0, tdata, 97, 28);
                    tdata[125] = 0x00;
                    tdata[126] = (byte)this.Track;
                } else {
                    Sylloge.Memory.Copy(enc.GetBytes(this.Comment), 0, tdata, 97, 30);
                }
                tdata[127] = (byte)this.Genre;
                try {
                    byte[] dval = new byte[128];
                    System.IO.FileStream fin = new System.IO.FileStream(this.File, System.IO.FileMode.Open, System.IO.FileAccess.ReadWrite, System.IO.FileShare.ReadWrite);
                    fin.Seek(-128, System.IO.SeekOrigin.End);
                    fin.Read(dval, 0, 128);
                    if (enc.GetString(dval, 0, 3) == "TAG") {
                        // There is a valid tag so we need to overwrite it
                        fin.Seek(-128, System.IO.SeekOrigin.End);
                        fin.SetLength(fin.Length - 128);
                    }
                    fin.Seek(0, System.IO.SeekOrigin.End); // Go to the end of the file
                    fin.Write(tdata, 0, 128);
                    fin.Close();
                    this.Data = tdata;
                    return true;
                } catch (Exception ex) {
                    throw ex;
                }
            } catch (Exception ex) {
                throw ex;
            }
        }

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

        public void SetYear(DateTime d)
        {
            this.Year = d.ToString("yyyy");
        }

        public void SetYear(string d)
        {
            if (!string.IsNullOrEmpty(d)) {
                if (!Sylloge.Extensions.TypeExtensions.IsNumeric(d)) { throw new System.ArgumentException("Year must be a numeric value"); }
                if (d.Length > 4) { throw new System.ArgumentOutOfRangeException("Year cannot be more than 4 digits"); }
            }
            this.Year = d;
        }

        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 + " - " + this.Title;
        }

        #endregion

        #region Static Methods

        public static V1 Parse(byte[] b)
        {
            if (b == null) { throw new System.ArgumentNullException("byte value cannot be null"); }
            if (b.Length != 128) { throw new System.ArgumentOutOfRangeException("ID3v1 byte tag length must be 128 bytes"); }
            System.Text.Encoding enc = ID3.Helper.ISO;
            if (enc.GetString(b, 0, 3) != "TAG") { throw new System.ArgumentException("ID3v1 tag must begin with 'TAG'"); };
            try {
                char[] tc = new char[] { '\0', ' ' };
                V1 ret = new V1();
                /*
                 * Last 128 bytes of MP3 file
                first 3 bytes MUST be 'TAG' for it to be valid
                Length(bytes)  Position(bytes)   Description
                3              (0-2)             Tag identification. Must contain 'TAG' if tag exists and is correct.
                30             (3-32)            Title
                30             (33-62)           Artist
                30             (63-92)           Album
                4              (93-96)           Year
                30*            (97-126)*         Comment
                1*             (125)*            0-Byte pad for track (if present)
                1*             (126)*            Track
                1              (127)             Genre 
                
                Note that per ID3v1.1, if byte 125 is a binary 0, then byte 126 is the
                track number. 
                 */
                ret.Title = enc.GetString(b, 3, 30).TrimEnd(tc); // 3-32
                ret.Artist = enc.GetString(b, 33, 30).TrimEnd(tc); // 33-62
                ret.Album = enc.GetString(b, 63, 30).TrimEnd(tc); // 63-92
                ret.Year = enc.GetString(b, 93, 4).TrimEnd(tc); ; // 93-96
                if (b[125] == 0x00) { // 97-124 (track present)
                    // doesn't have a full comment, so set track accordingly (if set)
                    ret.Comment = enc.GetString(b, 97, 28).TrimEnd(tc); // 28
                    ret.Track = (int)b[126];
                } else { // 97-126 (no track present)
                    ret.Comment = enc.GetString(b, 97, 30).TrimEnd(tc);
                    ret.Track = 0;
                }
                ret.Genre = (ID3.Genre)b[127];
                ret.Data = b;
                ret.IsValid = true;
                return ret;
            } catch (Exception ex) {
                throw ex;
            }
        }

        public static V1 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);
                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
                fin.Close(); fin = null;
                if (ID3.Helper.ISO.GetString(tag, 0, 3) == "TAG") {
                    // Its a valid tag, so continue
                    V1 ret = V1.Parse(tag);
                    ret.File = file;
                    if (ID3.Helper.ISO.GetString(tagp, 0, 4) == "TAG+") {
                        ret.Extended = TagPlus.Parse(tagp);
                    }
                    return ret;
                }
            }
            return null;
        }

        public static bool TryParse(byte[] b, out V1 v1)
        {
            try {
                v1 = V1.Parse(b);
                return true;
            } catch (Exception) {
                v1 = null;
            }
            return false;
        }

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

        public static bool Save(string fileName, string title, string artist, string album, string year, string comment, int track, ID3.Genre genre)
        {
            V1 tag = new V1();
            tag.File = fileName;
            tag.IsValid = true;
            tag.Title = title;
            tag.Artist = artist;
            tag.Album = album;
            tag.Year = year;
            tag.Comment = comment;
            tag.Track = track;
            tag.Genre = genre;
            return tag.Save();
        }

        #endregion
    }
}