code/Audio/Metadata/ID3/ID3Helper.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 static class Helper
    {
        private static System.Text.Encoding m_iso;
        private static System.Text.Encoding m_utf16;
        private static System.Text.Encoding m_utf16be;
        private static System.Text.Encoding m_utf8;

        static Helper()
        {
            Helper.m_iso = System.Text.Encoding.GetEncoding(28591); // 28591 - iso-8859-1 - Western European (ISO)
            Helper.m_utf16 = new UnicodeEncoding(false, true); // little-endian
            Helper.m_utf16be = new UnicodeEncoding(true, false);
            Helper.m_utf8 = System.Text.Encoding.GetEncoding(65001); // 65001 - utf-8 - Unicode (UTF-8)
        }

        public static System.Text.Encoding ISO { get { return Helper.m_iso; } }
        public static System.Text.Encoding UTF16 { get { return Helper.m_utf16; } }
        public static System.Text.Encoding UTF16BE { get { return Helper.m_utf16be; } }
        public static System.Text.Encoding UTF8 { get { return Helper.m_utf8; } }

        public static bool CheckPictureType(byte pbyte)
        {
            Array ptypes = Enum.GetValues(typeof(ID3.Picture));
            return pbyte <= (byte)ptypes.GetValue(ptypes.Length - 1);
        }

        public static System.Text.Encoding GetEncoding(byte ebyte)
        {
            switch (ebyte) {
                case 0x00: return Helper.ISO;
                case 0x01: return Helper.UTF16;
                case 0x02: return Helper.UTF16BE;
                case 0x03: return Helper.UTF8;
                default: break;
            }
            return ID3.Helper.ISO;
        }

        public static string EnumToString(ID3.Picture type)
        {
            switch (type) {
                case Picture.FileIcon:
                    return "32x32 pixels 'file icon' (PNG only)";
                case Picture.OtherFileIcon:
                    return "Other file icon";
                case Picture.Cover_Front:
                    return "Cover (front)";
                case Picture.Cover_Back:
                    return "Cover (back)";
                case Picture.Leaflet_Page:
                    return "Leaflet page";
                case Picture.Media:
                    return "Media (e.g. lable side of CD)";
                case Picture.Lead_Artist:
                    return "Lead artist/lead performer/soloist";
                case Picture.Artist_Performer:
                    return "Artist/performer";
                case Picture.Band_Orchestra:
                    return "Band/Orchestra";
                case Picture.Lyricist:
                    return "Lyricist/text writer";
                case Picture.Recording_Location:
                    return "Recording Location";
                case Picture.During_Recording:
                    return "During recording";
                case Picture.During_Performance:
                    return "During performance";
                case Picture.Movie_Screen_Capture:
                    return "Movie/video screen capture";
                case Picture.A_Bright_Coloured_Fish:
                    return "A bright coloured fish"; // Seriously ... this is in the ID3v2 spec??!??
                case Picture.Band_Logotype:
                    return "Band/artist logotype";
                case Picture.Publisher_Logotype:
                    return "Publisher/Studio logotype";
                default: break;
            }
            return Enum.GetName(typeof(Picture), type);
        }

        public static string EnumToString(ID3.Genre value)
        {
            // Becuase the built in Enum.GetName will return a literal string representation
            // of the enum name (i.e. RAndB instead of R&B), we need to convert the ones with
            // spaces and special characters in the name to make them user friendly readable
            switch (value) {
                case Genre.Classic_Rock:
                    return "Classic Rock";
                case Genre.Hip_Hop:
                    return "Hip-Hop";
                case Genre.New_Age:
                    return "New Age";
                case Genre.RAndB:
                    return "R&B";
                case Genre.Death_Metal:
                    return "Death Metal";
                case Genre.Euro_Techno:
                    return "Euro-Techno";
                case Genre.Trip_Hop:
                    return "Trip-Hop";
                case Genre.Jazz_Funk:
                    return "Jazz+Funk";
                case Genre.Sound_Clip:
                    return "Sound Clip";
                case Genre.Instrumental_Pop:
                    return "Instrumental Pop";
                case Genre.Instrumental_Rock:
                    return "Instrumental Rock";
                case Genre.Techno_Industrial:
                    return "Techno-Industrial";
                case Genre.Pop_Folk:
                    return "Pop-Folk";
                case Genre.Southern_Rock:
                    return "Southern Rock";
                case Genre.Top_40:
                    return "Top 40";
                case Genre.Christian_Rap:
                    return "Christian Rap";
                case Genre.Pop_Funk:
                    return "Pop/Funk";
                case Genre.Native_American:
                    return "Native American";
                case Genre.New_Wave:
                    return "New Wave";
                case Genre.Lo_Fi:
                    return "Lo-Fi";
                case Genre.Acid_Punk:
                    return "Acid Punk";
                case Genre.Acid_Jazz:
                    return "Acid Jazz";
                case Genre.Rock_And_Roll:
                    return "Rock & Roll";
                case Genre.Hard_Rock:
                    return "Hard Rock";
                case Genre.Folk_Rock:
                    return "Folk-Rock";
                case Genre.National_Folk:
                    return "National Folk";
                case Genre.Fast_Fusion:
                    return "Fast Fusion";
                case Genre.Gothic_Rock:
                    return "Gothic Rock";
                case Genre.Progressive_Rock:
                    return "Progressive Rock";
                case Genre.Psychedelic_Rock:
                    return "Psychedelic Rock";
                case Genre.Symphonic_Rock:
                    return "Symphonic Rock";
                case Genre.Slow_Rock:
                    return "Slow Rock";
                case Genre.Big_Band:
                    return "Big Band";
                case Genre.Easy_Listening:
                    return "Easy Listening";
                case Genre.Chamber_Music:
                    return "Chamber Music";
                case Genre.Booty_Bass:
                    return "Booty Bass";
                case Genre.Porn_Groove:
                    return "Porn Groove";
                case Genre.Slow_Jam:
                    return "Slow Jam";
                case Genre.Power_Ballad:
                    return "Power Ballad";
                case Genre.Rhythmic_Soul:
                    return "Rhythmic Soul";
                case Genre.Punk_Rock:
                    return "Punk Rock";
                case Genre.Drum_Solo:
                    return "Drum Solo";
                case Genre.A_capella:
                    return "A capella";
                case Genre.Euro_House:
                    return "Euro-House";
                case Genre.Dance_Hall:
                    return "Dance Hall";
                case Genre.Goa_Trance:
                    return "Goa Trance";
                case Genre.Drum_Bass:
                    return "Drum & Bass";
                case Genre.Club_House:
                    return "Club-House";
                case Genre.Hardcore_Techno:
                    return "Hardcore Techno";
                case Genre.Afro_punk:
                    return "Afro-punk";
                case Genre.Polsk_Punk:
                    return "Polsk Punk";
                case Genre.Christian_Gangsta_Rap:
                    return "Christian Gangsta Rap";
                case Genre.Heavy_Metal:
                    return "Heavy Metal";
                case Genre.Black_Metal:
                    return "Black Metal";
                case Genre.Contemporary_Christian:
                    return "Contemporary Christian";
                case Genre.Christian_Rock:
                    return "Christian Rock";
                case Genre.Thrash_Metal:
                    return "Thrash Metal";
                case Genre.Art_Rock:
                    return "Art Rock";
                case Genre.Big_Beat:
                    return "Big Beat";
                case Genre.Industro_Goth:
                    return "Industro-Goth";
                case Genre.Jam_Band:
                    return "Jam Band";
                case Genre.Math_Rock:
                    return "Math Rock";
                case Genre.New_Romantic:
                    return "New Romantic";
                case Genre.Nu_Breakz:
                    return "Nu-Breakz";
                case Genre.Post_Punk:
                    return "Post-Punk";
                case Genre.Post_Rock:
                    return "Post-Rock";
                case Genre.Space_Rock:
                    return "Space Rock";
                case Genre.Trop_Rock:
                    return "Trop Rock";
                case Genre.World_Music:
                    return "World Music";
                case Genre.Audio_Theatre:
                    return "Audio Theatre";
                case Genre.Neue_Deutsche_Welle:
                    return "Neue Deutsche Welle";
                case Genre.Indie_Rock:
                    return "Indie Rock";
                case Genre.G_Funk:
                    return "G-Funk";
                case Genre.Garage_Rock:
                    return "Garage Rock";
                default: break;
            }
            return Enum.GetName(typeof(Genre), value);
        }

        public static Sylloge.Audio.Metadata.ID3.Genre ParseGenre(string type)
        {
            if (type == null) { throw new ArgumentNullException("type"); }
            string f = type.ToLower();
            int c = Enum.GetValues(typeof(ID3.Genre)).Length;
            for (int i = 0; i < c; i++) {
                if (f == Helper.EnumToString((ID3.Genre)i).ToLower()) {
                    return ((ID3.Genre)i);
                }
            }
            return Genre.Other;
        }

        public static int ToSynchsafeInt(int ival)
        {
            int ret = 0;
            int mask = 0x7F;
            while ((mask ^ 0x7FFFFFFF) > 0) {
                ret = ival & ~mask;
                ret <<= 1;
                ret |= ival & mask;
                mask = ((mask + 1) << 8) - 1;
                ival = ret;
            }
            return ret;
        }

        public static int FromSynchsafeInt(int syncint)
        {
            int ret = 0;
            int mask = 0x7F000000;
            while (mask > 0) {
                ret >>= 1;
                ret |= syncint & mask;
                mask >>= 8;
            }
            return ret;
        }
    }
}