UnsynchByteVector() 공개 정적인 메소드

Unsynchronizes a ByteVector object by inserting empty bytes where necessary.
/// is . ///
public static UnsynchByteVector ( ByteVector data ) : void
data ByteVector /// A object to unsynchronize. ///
리턴 void
예제 #1
0
        public virtual ByteVector Render(byte version)
        {
            if (version < 4)
            {
                Flags &= ~(FrameFlags.DataLengthIndicator | FrameFlags.Unsynchronisation);
            }
            if (version < 3)
            {
                Flags &= ~(FrameFlags.Compression | FrameFlags.Encryption | FrameFlags.FileAlterPreservation | FrameFlags.GroupingIdentity | FrameFlags.ReadOnly | FrameFlags.TagAlterPreservation);
            }
            ByteVector field_data = RenderFields(version);

            if (field_data.Count == 0)
            {
                return(new ByteVector());
            }
            ByteVector front_data = new ByteVector();

            if ((Flags & (FrameFlags.Compression | FrameFlags.DataLengthIndicator)) != 0)
            {
                front_data.Add(ByteVector.FromUInt((uint)field_data.Count));
            }
            if ((Flags & FrameFlags.GroupingIdentity) != 0)
            {
                front_data.Add(group_id);
            }
            if ((Flags & FrameFlags.Encryption) != 0)
            {
                front_data.Add(encryption_id);
            }
            if ((Flags & FrameFlags.Compression) != 0)
            {
                throw new NotImplementedException("Compression not yet supported");
            }
            if ((Flags & FrameFlags.Encryption) != 0)
            {
                throw new NotImplementedException("Encryption not yet supported");
            }
            if ((Flags & FrameFlags.Unsynchronisation) != 0)
            {
                SynchData.UnsynchByteVector(field_data);
            }
            if (front_data.Count > 0)
            {
                field_data.Insert(0, front_data);
            }
            header.FrameSize = (uint)field_data.Count;
            ByteVector header_data = header.Render(version);

            header_data.Add(field_data);
            return(header_data);
        }
예제 #2
0
        public ByteVector Render()
        {
            bool has_footer          = (header.Flags & HeaderFlags.FooterPresent) != 0;
            bool unsynchAtFrameLevel = (header.Flags & HeaderFlags.Unsynchronisation) != 0 && Version >= 4;
            bool unsynchAtTagLevel   = (header.Flags & HeaderFlags.Unsynchronisation) != 0 && Version < 4;

            header.MajorVersion = has_footer?(byte)4:Version;
            ByteVector tag_data = new ByteVector();

            header.Flags &= ~HeaderFlags.ExtendedHeader;
            foreach (Frame frame in frame_list)
            {
                if (unsynchAtFrameLevel)
                {
                    frame.Flags |= FrameFlags.Unsynchronisation;
                }
                if ((frame.Flags & FrameFlags.TagAlterPreservation) != 0)
                {
                    continue;
                }
                try
                {
                    tag_data.Add(frame.Render(header.MajorVersion));
                }
                catch (NotImplementedException)
                {
                }
            }
            if (unsynchAtTagLevel)
            {
                SynchData.UnsynchByteVector(tag_data);
            }
            if (!has_footer)
            {
                tag_data.Add(new ByteVector((int)((tag_data.Count < header.TagSize)?(header.TagSize - tag_data.Count):1024)));
            }
            header.TagSize = (uint)tag_data.Count;
            tag_data.Insert(0, header.Render());
            if (has_footer)
            {
                tag_data.Add(new Footer(header).Render());
            }
            return(tag_data);
        }
예제 #3
0
        /// <summary>
        ///    Renders the current instance, encoded in a specified
        ///    ID3v2 version.
        /// </summary>
        /// <param name="version">
        ///    A <see cref="byte" /> value specifying the version of
        ///    ID3v2 to use when encoding the current instance.
        /// </param>
        /// <returns>
        ///    A <see cref="ByteVector" /> object containing the
        ///    rendered version of the current instance.
        /// </returns>
        /// <exception cref="NotImplementedException">
        ///    The current instance uses some feature that cannot be
        ///    implemented in the specified ID3v2 version, or uses a
        ///    feature, such as encryption or compression, which is not
        ///    yet implemented in the library.
        /// </exception>
        public virtual ByteVector Render(byte version)
        {
            // Remove flags that are not supported by older versions
            // of ID3v2.
            if (version < 4)
            {
                Flags &= ~(FrameFlags.DataLengthIndicator |
                           FrameFlags.Unsynchronisation);
            }

            if (version < 3)
            {
                Flags &= ~(FrameFlags.Compression |
                           FrameFlags.Encryption |
                           FrameFlags.FileAlterPreservation |
                           FrameFlags.GroupingIdentity |
                           FrameFlags.ReadOnly |
                           FrameFlags.TagAlterPreservation);
            }

            ByteVector field_data = RenderFields(version);

            // If we don't have any content, don't render anything.
            // This will cause the frame to not be rendered.
            if (field_data.Count == 0)
            {
                return(new ByteVector());
            }

            ByteVector front_data = new ByteVector();

            if ((Flags & (FrameFlags.Compression |
                          FrameFlags.DataLengthIndicator)) != 0)
            {
                front_data.Add(ByteVector.FromUInt((uint)
                                                   field_data.Count));
            }

            if ((Flags & FrameFlags.GroupingIdentity) != 0)
            {
                front_data.Add(group_id);
            }

            if ((Flags & FrameFlags.Encryption) != 0)
            {
                front_data.Add(encryption_id);
            }

            // FIXME: Implement compression.
            if ((Flags & FrameFlags.Compression) != 0)
            {
                throw new NotImplementedException("Compression not yet supported");
            }

            // FIXME: Implement encryption.
            if ((Flags & FrameFlags.Encryption) != 0)
            {
                throw new NotImplementedException("Encryption not yet supported");
            }

            if ((Flags & FrameFlags.Unsynchronisation) != 0)
            {
                SynchData.UnsynchByteVector(field_data);
            }

            if (front_data.Count > 0)
            {
                field_data.Insert(0, front_data);
            }

            header.FrameSize = (uint)field_data.Count;
            ByteVector header_data = header.Render(version);

            header_data.Add(field_data);

            return(header_data);
        }