protected ExtensionFrame(byte extensionId)
 {
     _extensionId = extensionId;
     _flags = FrameFlags.ExtensionFrame;
     _receiveState = ExtensionFrameState.PayloadLength;
     _sendCompleted = true;
 }

        public bool Read(byte[] buffer, ref int offset, ref int bytesTransferred)
        {
            while (bytesTransferred > 0)
            {
                switch (_receiveState)
                {
                    case ExtensionFrameState.Flags:
                        Flags = (FrameFlags) buffer[offset];
                        _receiveState = ExtensionFrameState.ExtensionId;
                        ++offset;
                        --bytesTransferred;
                        break;
                    case ExtensionFrameState.ExtensionId:
                        var extensionId = buffer[offset];
                        ++offset;
                        --bytesTransferred;
                        _receiveState = ExtensionFrameState.Payload;
                        _receiveFrame = (ExtensionFrame) _extensionFactory(extensionId);
                        break;

                    case ExtensionFrameState.Payload:
                        var isCompleted = _receiveFrame.Read(buffer, ref offset, ref bytesTransferred);
                        if (isCompleted)
                        {
                            _frameReceived(_receiveFrame);
                            _receiveState = ExtensionFrameState.Flags;
                        }

                        return isCompleted;
                }
            }

            return false;
        }

 /// <summary>
 /// create new PositionSynchronised frame
 /// </summary>
 /// <param name="Flags">Flags of frame</param>
 /// <param name="TimeStamp">TimeStamp to use for frame</param>
 /// <param name="Position">Position of frame</param>
 public PositionSynchronisedFrame(FrameFlags Flags, TimeStamps TimeStamp,
     long Position)
     : base("POSS", Flags)
 {
     this.TimeStamp = TimeStamp;
     _Position = Position;
 }

 /// <summary>
 /// Create new AttachedPicture frame
 /// </summary>
 /// <param name="Flags">Flags of frame</param>
 /// <param name="Description">Description of picture</param>
 /// <param name="TextEncoding">TextEncoding use for texts</param>
 /// <param name="MIMEType">MimeType of picture</param>
 /// <param name="PictureType">Picture type</param>
 /// <param name="Data">Data Contain picture</param>
 public AttachedPictureFrame(FrameFlags Flags, string Description,
     TextEncodings TextEncoding, string MIMEType, PictureTypes PictureType,
     MemoryStream Data)
     : base("APIC", Flags, Description, MIMEType, TextEncoding, Data)
 {
     _PictureType = PictureType;
 }

 private void DecodeFlags(byte[] flags)
 {
     Flag = new FrameFlags();
     Flag.TagAlterPreservation = (flags[0] & 0x80) == 0x80;
     Flag.FileAlterPreservation = (flags[0] & 0x40) == 0x40;
     Flag.ReadOnly = (flags[0] & 0x20) == 0x20;
     Flag.Compression = (flags[1] & 0x80) == 0x80;
     Flag.Encryption = (flags[1] & 0x40) == 0x40;
     Flag.GroupingIdentify = (flags[1] & 0x20) == 0x20;
 }

        /// <summary>
        /// New LinkedFrame from specific information
        /// </summary>
        /// <param name="Flags">Frame Flags</param>
        /// <param name="FrameIdentifier">FrameIdentifier of frame that linked</param>
        /// <param name="URL">URL address of Linked Frame</param>
        /// <param name="AdditionalData">Additional data of Linked Frame</param>
        public LinkFrame(FrameFlags Flags, string FrameIdentifier,
            string URL, string AdditionalData)
            : base("LINK", Flags)
        {
            this.URL = URL;
            _AdditionalData = AdditionalData;

            // Check if FrameIdentifier is valid
            ValidatingFrameID(FrameIdentifier, ValidatingErrorTypes.Exception);

            _FrameIdentifier = FrameIdentifier;
        }

        public FrameHeader(ByteVector data, byte version)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            this.flags = FrameFlags.None;
            this.frame_size = 0;
            if ((version < 2) || (version > 4))
            {
                throw new CorruptFileException("Unsupported tag version.");
            }
            if (data.Count < ((version != 2) ? 4 : 3))
            {
                throw new CorruptFileException("Data must contain at least a frame ID.");
            }
            switch (version)
            {
                case 2:
                    this.frame_id = ConvertId(data.Mid(0, 3), version, false);
                    if (data.Count >= 6)
                    {
                        this.frame_size = data.Mid(3, 3).ToUInt();
                        return;
                    }
                    return;

                case 3:
                    this.frame_id = ConvertId(data.Mid(0, 4), version, false);
                    if (data.Count >= 10)
                    {
                        this.frame_size = data.Mid(4, 4).ToUInt();
                        this.flags = (FrameFlags) ((ushort) ((((data[8] << 7) & 0x7000) | ((data[9] >> 4) & 12)) | ((data[9] << 1) & 0x40)));
                        return;
                    }
                    return;

                case 4:
                    this.frame_id = new ReadOnlyByteVector(data.Mid(0, 4));
                    if (data.Count >= 10)
                    {
                        this.frame_size = SynchData.ToUInt(data.Mid(4, 4));
                        this.flags = (FrameFlags) data.Mid(8, 2).ToUShort();
                        return;
                    }
                    return;
            }
            throw new CorruptFileException("Unsupported tag version.");
        }

        private string _ErrorMessage; // Contain Error Message if occur

        /// <summary>
        /// Create a new Frame class
        /// </summary>
        /// <param name="FrameID">4 Characters tag identifier</param>
        /// <param name="Flag">Frame Falgs</param>
        protected Frame(string FrameID, FrameFlags Flags)
        {
            // All FrameID letters must be capital
            FrameID = FrameID.ToUpper();

            if (!ValidatingFrameID(FrameID, ValidatingErrorTypes.Exception))
            {
                _MustDrop = true;
                return;
            }

            _FrameFlags = Flags;
            _FrameID = FrameID;
            _MustDrop = false;
            _IsLinked = false;
        }

        /// <summary>
        /// New SynchronisedText
        /// </summary>
        /// <param name="FrameID">FrameID</param>
        /// <param name="Flags">Frame Flag</param>
        /// <param name="Data">FileStream contain current frame data</param>
        internal SynchronisedText(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
            : base(FrameID, Flags)
        {
            _Syllables = new FramesCollection<Syllable>();

            TextEncoding = (TextEncodings)Data.ReadByte();
            if (!IsValidEnumValue(TextEncoding, ValidatingErrorTypes.ID3Error))
                return;

            Length--;

            _Language = new Language(Data);
            Length -= 3;

            _TimeStamp = (TimeStamps)Data.ReadByte();
            if (!IsValidEnumValue(_TimeStamp, ValidatingErrorTypes.ID3Error))
                return;

            Length--;

            _ContentType = (ContentTypes)Data.ReadByte();
            if (!IsValidEnumValue(_ContentType, ValidatingErrorTypes.Nothing))
                _ContentType = ContentTypes.Other;
            Length--;

            // use Text variable for descriptor property
            ContentDescriptor = Data.ReadText(Length, TextEncoding, ref Length, true);

            string tempText;
            uint tempTime;
            while (Length > 5)
            {
                tempText = Data.ReadText(Length, TextEncoding, ref Length, true);
                tempTime = Data.ReadUInt(4);

                _Syllables.Add(new Syllable(tempTime, tempText));

                Length -= 4;
            }
        }

        /*
         * 
         *      %0abc 0000 %0h00 kmnp
         *      
         *      a = Tag Alter Preservartion
         *      b = File Alter Preservation
         *      c = Read Only
         *      h = Grouping Identity
         *      k = Compression
         *      m = Encryption
         *      n = Unsynchronisation
         *      p = Data Length Indicator
         */

        private void DecodeFlags(byte[] flags)
        {
            Flag = new FrameFlags();

            var isTagAlterPreservation = (flags[0] & 0x40) == 0x40;
            var isFileAlterPreservation = (flags[0] & 0x20) == 0x20;
            var isReadOnly = (flags[0] & 0x10) == 0x10;
            var isGroupingIdentity = (flags[1] & 0x40) == 0x40;
            var isCompression = (flags[1] & 0x08) == 0x08;
            var isEncryption = (flags[1] & 0x04) == 0x04;
            var isUnsync = (flags[1] & 0x02) == 0x02;
            var isDataLengthIndicator = (flags[1] & 0x01) == 0x01;

            Flag.TagAlterPreservation = isTagAlterPreservation;
            Flag.FileAlterPreservation = isFileAlterPreservation;
            Flag.ReadOnly = isReadOnly;
            Flag.GroupingIdentify = isGroupingIdentity;
            Flag.Compression = isCompression;
            Flag.Encryption = isEncryption;
            Flag.Unsynchronisation = isUnsync;
            Flag.DataLengthIndicator = isDataLengthIndicator;
        }

        /// <summary>
        /// Create new reveb frame
        /// </summary>
        /// <param name="FrameID">FrameID</param>
        /// <param name="Flags">Flags of frame</param>
        /// <param name="Data">Data for frame to read from</param>
        /// <param name="Length">Maximum length of frame</param>
        internal ReverbFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
            : base(FrameID, Flags)
        {
            if (Length != 12)
            {
                //RaiseErrorEvent(new ID3Error(208, ID3Versions.ID3v2, _FrameID,
                //"Reveb frame is not in correct length. it will drop", ErrorType.Error));
                _MustDrop = true;
                return;
            }

            _ReverbLeft = Convert.ToInt32(Data.ReadUInt(2));
            _ReverbRight = Convert.ToInt32(Data.ReadUInt(2));
            _ReverbBouncesLeft = Data.ReadByte();
            _ReverbBouncesRight = Data.ReadByte();
            _ReverbFeedbackLeftToLeft = Data.ReadByte();
            _ReverbFeedbackLeftToRight = Data.ReadByte();
            _ReverbFeedbackRightToRight = Data.ReadByte();
            _ReverbFeedbackRightToLeft = Data.ReadByte();
            _PremixLeftToRight = Data.ReadByte();
            _PremixRightToLeft = Data.ReadByte();
        }

        protected uint _MilisecondBetweenRef; // 3 Bytes

        #endregion Fields

        #region Constructors

        /// <summary>
        /// Create new MpegLocationLookupTable
        /// </summary>
        /// <param name="FrameID">FrameID</param>
        /// <param name="Flags">Flags for this frame</param>
        /// <param name="Data">FileStream to read data from</param>
        internal MpegLocationLookupTable(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
            : base(FrameID, Flags)
        {
            _FrameBetweenRef = Data.ReadUInt(2);
            _ByteBetweenRef = Data.ReadUInt(3);
            _ByteBetweenRef = Data.ReadUInt(3);
            _BitsForByteDeviation = Data.ReadByte();
            _BitsForMilisecondDeviation = Data.ReadByte();
            Length -= 10;
            int Sum = _BitsForByteDeviation + _BitsForMilisecondDeviation;

            ////BitForByteDev + BitForMilisecondDev must be multiple of four
            //if (Sum % 4 != 0)
            //{
            //    RaiseErrorEvent(new ID3Error(208, ID3Versions.ID3v2, _FrameID,
            //        "Error in MpegLocationLookupTable, it's not standard. it will drop", ErrorType.Error));
            //    _MustDrop = true;
            //    return;
            //}

            //if (Sum > 32 || Sum % 8 != 0)
            //{
            //    RaiseErrorEvent(new ID3Error(208, ID3Versions.ID3v2, _FrameID,
            //        "this program can't process MpegLocation Table", ErrorType.Error));
            //    _MustDrop = true;
            //    return;
            //}

            uint Temp;
            Sum /= 8;
            while (Length >= Sum)
            {
                Temp = Data.ReadUInt(Sum);

                Length -= Sum;
            }
        }

 /// <summary>
 /// Create new PlayCounter
 /// </summary>
 /// <param name="FrameID">4 Characters tag identifier</param>
 /// <param name="Flags">2 Bytes flags identifier</param>
 /// <param name="Data">Contain Data for this frame</param>
 internal PlayCounterFrame(string FrameID, FrameFlags Flags, FileStream Data, int Length)
     : base(FrameID, Flags)
 {
     byte[] Long = new byte[8];
     byte[] Buf = new byte[Length];
     // Less than 4 Characters
     Data.Read(Buf, 0, Length);
     Buf.CopyTo(Long, 8 - Buf.Length);
     Array.Reverse(Long);
     _Counter = BitConverter.ToInt64(Long, 0);
 }

        public TextWithLanguageFrame(string FrameID, FrameFlags Flags, string Text,
            string Description, TextEncodings TextEncoding, string Lang)
            : base(FrameID, Flags)
        {
            if (FrameID != "USLT" && FrameID != "COMM")
                throw (new ArgumentException(FrameID + " is not valid Frame for TextWithLanguageFrame"));

            Language = new Language(Lang);
            this.Text = Text;
            this.Description = "";
            this.TextEncoding = TextEncoding;
        }

        private string _Text; // Contain text

        #endregion Fields

        #region Constructors

        protected TextOnlyFrame(string FrameID, FrameFlags Flags)
            : base(FrameID, Flags)
        {
        }

        /// <summary>
        /// Create new TextFrame Class
        /// </summary>
        /// <param name="FrameID">4 Characters frame identifier</param>
        /// <param name="Flags">Flag of frame</param>
        /// <param name="Data">FileStream to read frame data from</param>
        /// <param name="Length">Maximum length of frame</param>
        internal TextFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
            : base(FrameID, Flags)
        {
            // If it was URL frame the TextEncoding is ascii and must not read
            if (IsUrl)
                TextEncoding = TextEncodings.Ascii;
            else
            {
                TextEncoding = (TextEncodings)Data.ReadByte();
                Length--;
                if (!IsValidEnumValue(TextEncoding, ValidatingErrorTypes.ID3Error))
                    return;
            }

            Text = Data.ReadText(Length, _TextEncoding);
        }

 protected TermOfUseFrame(string FrameID, FrameFlags Flags)
     : base(FrameID, Flags)
 {
 }

        /// <summary>
        /// Create new RaltiveVolumeFrame
        /// </summary>
        /// <param name="FrameID">4 Characters tag identifier</param>
        /// <param name="Flags">2 Bytes flags identifier</param>
        /// <param name="Data">Contain Data for this frame</param>
        /// <param name="Lenght">Length to read from FileStream</param>
        internal RelativeVolumeFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
            : base(FrameID, Flags)
        {
            _Descriptors = new uint[12];

            _IncDec = Data.ReadByte(); // Read Increment Decrement Byte

            _BitForVolumeDescription = Data.ReadByte(); // Read Volume Description Length
            Length -= 2;

            if (_BitForVolumeDescription == 0)
            {
                ErrorOccur("BitForVolumeDescription of Relative volume information frame can't be zero", true);
                return;
            }

            if (_BitForVolumeDescription / 8 > 4 ||
                _BitForVolumeDescription % 8 != 0)
            {
                ErrorOccur("This program don't support " + _BitForVolumeDescription.ToString() +
                    " Bits of description for Relative Volume information", true);
                return;
            }

            int DesLen = _BitForVolumeDescription / 8; // Length of each volume descriptor
            int Counter = 0;
            while (CanContinue(Length, DesLen, 2))
            {
                _Descriptors[Counter++] = Data.ReadUInt(DesLen);
                _Descriptors[Counter++] = Data.ReadUInt(DesLen);
                Length -= 2;
            }
        }

        /// <summary>
        /// Create new OwnershipFrame
        /// </summary>
        /// <param name="FrameID">4 Characters tag identifier</param>
        /// <param name="Flags">2 Bytes flags identifier</param>
        /// <param name="Data">Contain Data for this frame</param>
        internal OwnershipFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
            : base(FrameID, Flags)
        {
            TextEncoding = (TextEncodings)Data.ReadByte();
            Length--;
            if (!IsValidEnumValue(TextEncoding, ValidatingErrorTypes.ID3Error))
                return;

            _Price = new Price(Data, Length);
            Length -= _Price.Length;
            if (!_Price.IsValid)
            {
                ErrorOccur("Price is not valid value. ownership frame will not read", true);
                return;
            }

            if (Length >= 8)
            {
                _DateOfPurch = new SDate(Data);
                Length -= 8;
            }
            else
            {
                ErrorOccur("Date is not valid for this frame", true);
                return;
            }

            Seller = Data.ReadText(Length, TextEncoding);
        }

 /// <summary>
 /// New PopulariMeter frame from specific information
 /// </summary>
 /// <param name="Flags">Frame Flags</param>
 /// <param name="EMail">Email of user</param>
 /// <param name="Rating">User Rated value</param>
 /// <param name="Counter">How many times user listened to audio</param>
 public PopularimeterFrame(FrameFlags Flags, string EMail,
     byte Rating, long Counter)
     : base("POPM", Flags)
 {
     base.Text = EMail;
     _Rating = Rating;
     _Counter = Counter;
 }