code/Audio/Metadata/ID3/Frames/AttachedPicture.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.Frames
{
    public class AttachedPicture : TextFrame
    {
        public byte[] ImageData { get; private set; }
        public string MimeType { get; private set; }
        public Picture Type { get; private set; }

        public AttachedPicture()
            : base(ID3.Frame.Keys.AttachedPicture)
        {
            this.Initialize(0x00, string.Empty, string.Empty, Picture.Other, null);
        }

        public AttachedPicture(System.Drawing.Image img)
            : base(ID3.Frame.Keys.AttachedPicture)
        {
            this.Initialize(img, Picture.Other);
        }

        public AttachedPicture(System.Drawing.Image img, Picture type)
            : base(ID3.Frame.Keys.AttachedPicture)
        {
            this.Initialize(img, type);
        }

        public AttachedPicture(Frame other)
            : base(other)
        {
            if (other.ID != ID3.Frame.Keys.AttachedPicture) { throw new System.InvalidCastException("Frame ID must be equal to copy the data within it."); }
            AttachedPicture i = AttachedPicture.Parse(other);
            this.Description = i.Description;
            this.Encoding = i.Encoding;
            this.ImageData = i.ImageData;
            this.MimeType = i.MimeType;
            this.Type = i.Type;
            this.Value = i.Value;
        }

        public AttachedPicture(TextFrame other)
            : base(other)
        {
            if (other.ID != ID3.Frame.Keys.AttachedPicture) { throw new System.InvalidCastException("Frame ID must be equal to copy the data within it."); }
            this.ImageData = null;
            this.MimeType = string.Empty;
            this.Type = Picture.Other;
        }

        public AttachedPicture(AttachedPicture other)
            : base(other)
        {
            this.MimeType = other.MimeType;
            this.Type = other.Type;
            this.ImageData = other.ImageData;
        }

        private AttachedPicture(byte enc, string mime, byte pic, string desc, byte[] img)
            : base(ID3.Frame.Keys.AttachedPicture)
        {
            this.Initialize(enc, desc, mime, (Picture)pic, img);
        }

        private void Initialize(System.Drawing.Image img, Picture type)
        {
            this.Initialize(0x00, string.Empty, string.Empty);
            this.SetImage(img, type);
        }

        private void Initialize(byte enc, string desc, string mtype, Picture ptype, byte[] idata)
        {
            this.Initialize(enc, desc, string.Empty);
            this.MimeType = mtype;
            this.Type = ptype;
            this.ImageData = idata;
            this.GenerateTag();
        }

        // TODO: need to set the underlying member values for each "Frame" type

        public override byte[] GenerateTag()
        {
            /* <Header for 'Attached picture', ID: "APIC"> 
            Text encoding   $xx (1 byte)
            MIME type       <text string> (upto 0x00)
            Picture type    $xx (1 byte)
            Description     <text string according to encoding> (upto 0x00)
            Picture data    <binary data>
            */
            List<byte> ret = new List<byte>();
            System.Text.Encoding enc = ID3.Helper.GetEncoding(this.Encoding);
            ret.Add(this.Encoding);
            byte[] mt = ID3.Helper.ISO.GetBytes(this.MimeType);
            if (mt != null && mt.Length > 0) { ret.AddRange(mt); }
            ret.Add(0x00);
            ret.Add((byte)this.Type);
            mt = enc.GetBytes(this.Description);
            if (mt != null && mt.Length > 0) { ret.AddRange(mt); }
            ret.Add(0x00);
            if (this.ImageData != null) {
                byte[] idata = this.ImageData;
                if (this.Format.IsCompressed) {
                    idata = Frame.Compress(idata);
                }
                if (this.Format.IsEncrypted) {
                    idata = Frame.Encrypt(idata, this.Format.Encryption);
                }
                if (this.Format.IsUnsynchronised) {
                    idata = Frame.SyncData(idata);
                    this.Format.DataLengthInicator = this.ImageData.Length;
                }
                ret.AddRange(idata);
            }
            this.Data = ret.ToArray();
            return this.FullFrame;
        }

        public void SetImage(System.Drawing.Image img, Picture type)
        {
            if (img == null) { throw new System.ArgumentNullException("img"); }
            this.MimeType = Sylloge.Data.Imaging.GetMimeType(img);
            this.ImageData = Sylloge.Data.Imaging.ToByteArray(img, this.MimeType);
            this.Type = type;
            this.GenerateTag();
        }

        public System.Drawing.Image ToImage()
        {
            if (this.ImageData == null) { return null; }
            System.IO.MemoryStream st = new System.IO.MemoryStream(this.ImageData);
            System.Drawing.Image ret = null;
            try {
                ret = System.Drawing.Image.FromStream(st);
            } catch (Exception) {
                // TODO: this should only happen on an improperly parsed
                // image data (i.e. missed a bit flag or didn't uncompress)
                ret = null;
            }
            return ret;
        }

        public override string ToString()
        {
            return ((string.IsNullOrEmpty(this.Description)) ? this.MimeType : this.Description);
        }

        public static ID3.Frames.AttachedPicture Parse(ID3.Frame frame)
        {
            if (frame.ID != ID3.Frame.Keys.AttachedPicture) { throw new System.InvalidCastException("Frame ID must be equal to copy the data within it."); }
            AttachedPicture ret = new AttachedPicture();// (Image)frame;
            ret.Data = frame.Data;
            ret.Format = frame.Format;
            ret.Status = frame.Status;
            ret.Value = string.Empty;
            /* <Header for 'Attached picture', ID: "APIC"> 
            Text encoding   $xx (1 byte)
            MIME type       <text string> (upto 0x00)
            Picture type    $xx (1 byte)
            Description     <text string according to encoding> (upto 0x00, the terminating null char)
            Picture data    <binary data>
                        TE (        MIME TYPE       )    PT
            <header> 00 69 6D 61 67 65 2F 4A 50 47 00 03 00 <image>*/
            List<byte> bdata = new List<byte>(ret.Data);
            ret.Encoding = bdata[0]; bdata.RemoveAt(0);
            System.Text.Encoding enc = ID3.Helper.GetEncoding(ret.Encoding);
            ret.MimeType = ID3.Helper.ISO.GetString(bdata.ToArray());
            int idx = 0;
            for (; idx < ret.MimeType.Length; idx++) {
                if (ret.MimeType[idx] == '\0') { break; }
            }
            ret.MimeType = ret.MimeType.Substring(0, idx);
            bdata.RemoveRange(0, ret.MimeType.Length + 1);
            byte ptype = bdata[0]; bdata.RemoveAt(0); // get picture type
            if (!ID3.Helper.CheckPictureType(ptype)) { ptype = Frame.EOL; } // eol for pic type is 'Other'
            ret.Type = (Picture)ptype;
            ret.Description = string.Empty;
            if (bdata[0] != Frame.EOL) {
                ret.Description = enc.GetString(bdata.ToArray());
                for (idx = 0; idx < ret.Description.Length; idx++) {
                    if (ret.Description[idx] == '\0') { break; }
                }
                ret.Description = ret.Description.Substring(0, idx);
                int len = enc.GetByteCount(ret.Description);
                if ((len + 1) > bdata.Count) {
                    bdata.Clear();
                } else {
                    bdata.RemoveRange(0, len + 1);
                }
                if (enc.GetByteCount("A") > 1) {
                    // for multi-byte encodings
                    bdata.RemoveAt(0);
                }
            } else {
                bdata.RemoveAt(0);
            }
            // get the image byte data
            if (ret.Format.HasData) {
                byte[] d = null;
                if (ret.Format.IsUnsynchronised) {
                    d = Frame.UnsyncData(bdata.ToArray(), ret.Format.DataLengthInicator);
                }
                if (ret.Format.IsEncrypted) {
                    d = Frame.Decrypt(d, ret.Format.Encryption);
                }
                if (ret.Format.IsCompressed) {
                    d = Frame.Decompress(d);
                }
                ret.ImageData = d;
            } else {
                ret.ImageData = bdata.ToArray();
            }
            // retun the ID3 image
            return ret;
        }

        public static ID3.Frames.AttachedPicture Parse(byte[] data)
        {
            /* <Header for 'Attached picture', ID: "APIC"> 
            Text encoding   $xx (1 byte)
            MIME type       <text string> (upto 0x00)
            Picture type    $xx (1 byte)
            Description     <text string according to encoding> (upto 0x00, the terminating null char)
            Picture data    <binary data>
                        TE (        MIME TYPE       )    PT
            <header> 00 69 6D 61 67 65 2F 4A 50 47 00 03 00 <image>*/
            List<byte> bdata = new List<byte>(data);
            byte benc = bdata[0]; bdata.RemoveAt(0);
            System.Text.Encoding enc = ID3.Helper.GetEncoding(benc);
            string mtype = ID3.Helper.ISO.GetString(bdata.ToArray());
            int idx = 0;
            for (; idx < mtype.Length; idx++) { 
                if (mtype[idx] == '\0') { break; }
            }
            mtype = mtype.Substring(0, idx);
            bdata.RemoveRange(0, mtype.Length + 1);
            byte ptype = bdata[0]; bdata.RemoveAt(0); // get picture type
            if (!ID3.Helper.CheckPictureType(ptype)) { ptype = Frame.EOL; } // eol for pic type is 'Other'
            string desc = string.Empty;
            if (bdata[0] != Frame.EOL) {
                desc = enc.GetString(bdata.ToArray());
                for (idx = 0; idx < desc.Length; idx++) {
                    if (desc[idx] == '\0') { break; }
                }
                desc = desc.Substring(0, idx);
                int len = enc.GetByteCount(desc);
                if ((len + 1) > bdata.Count) {
                    bdata.Clear();
                } else {
                    bdata.RemoveRange(0, len + 1);
                }
            }
            bdata.RemoveAt(0);
            // get the image byte data
            byte[] idata = bdata.ToArray();
            // retun the ID3 image
            return (new ID3.Frames.AttachedPicture(benc, mtype, ptype, desc, idata));
        }

        public static bool TryParse(byte[] data, out ID3.Frames.AttachedPicture img)
        {
            try {
                img = AttachedPicture.Parse(data);
            } catch (Exception) {
                img = null;
            }
            return false;
        }
    }
}