示例#1
0
文件: File.cs 项目: juschubut/kenos
        /// <summary>
        ///    Gets a tag of a specified type from the current instance,
        ///    optionally creating a new tag if possible.
        /// </summary>
        /// <param name="type">
        ///    A <see cref="TagLib.TagTypes" /> value indicating the
        ///    type of tag to read.
        /// </param>
        /// <param name="create">
        ///    A <see cref="bool" /> value specifying whether or not to
        ///    try and create the tag if one is not found.
        /// </param>
        /// <returns>
        ///    A <see cref="Tag" /> object containing the tag that was
        ///    found in or added to the current instance. If no
        ///    matching tag was found and none was created, <see
        ///    langword="null" /> is returned.
        /// </returns>
        public override TagLib.Tag GetTag(TagTypes type, bool create)
        {
            TagLib.Tag tag = null;

            switch (type)
            {
            case TagTypes.Id3v2:
                if (id32_tag == null && create)
                {
                    id32_tag         = new Id3v2.Tag();
                    id32_tag.Version = 4;
                    id32_tag.Flags  |= Id3v2.HeaderFlags
                                       .FooterPresent;
                    this.tag.CopyTo(id32_tag, true);
                }

                tag = id32_tag;
                break;

            case TagTypes.RiffInfo:
                if (info_tag == null && create)
                {
                    info_tag = new InfoTag();
                    this.tag.CopyTo(info_tag, true);
                }

                tag = info_tag;
                break;

            case TagTypes.MovieId:
                if (mid_tag == null && create)
                {
                    mid_tag = new MovieIdTag();
                    this.tag.CopyTo(mid_tag, true);
                }

                tag = mid_tag;
                break;

            case TagTypes.DivX:
                if (divx_tag == null && create)
                {
                    divx_tag = new DivXTag();
                    this.tag.CopyTo(divx_tag, true);
                }

                tag = divx_tag;
                break;
            }

            this.tag.SetTags(id32_tag, info_tag, mid_tag, divx_tag);
            return(tag);
        }
示例#2
0
文件: File.cs 项目: juschubut/kenos
        /// <summary>
        ///    Removes a set of tag types from the current instance.
        /// </summary>
        /// <param name="types">
        ///    A bitwise combined <see cref="TagLib.TagTypes" /> value
        ///    containing tag types to be removed from the file.
        /// </param>
        /// <remarks>
        ///    In order to remove all tags from a file, pass <see
        ///    cref="TagTypes.AllTags" /> as <paramref name="types" />.
        /// </remarks>
        public override void RemoveTags(TagTypes types)
        {
            if ((types & TagLib.TagTypes.Id3v2) != TagLib.TagTypes.None)
            {
                id32_tag = null;
            }
            if ((types & TagLib.TagTypes.RiffInfo) != TagLib.TagTypes.None)
            {
                info_tag = null;
            }
            if ((types & TagLib.TagTypes.MovieId) != TagLib.TagTypes.None)
            {
                mid_tag = null;
            }
            if ((types & TagLib.TagTypes.DivX) != TagLib.TagTypes.None)
            {
                divx_tag = null;
            }

            tag.SetTags(id32_tag, info_tag, mid_tag, divx_tag);
        }
示例#3
0
文件: File.cs 项目: juschubut/kenos
        /// <summary>
        ///    Reads the contents of the current instance determining
        ///    the size of the riff data, the area the tagging is in,
        ///    and optionally reading in the tags and media properties.
        /// </summary>
        /// <param name="read_tags">
        ///    If <see langword="true" />, any tags found will be read
        ///    into the current instance.
        /// </param>
        /// <param name="style">
        ///    A <see cref="ReadStyle"/> value specifying how the media
        ///    data is to be read into the current instance.
        /// </param>
        /// <param name="riff_size">
        ///    A <see cref="uint"/> value reference to be filled with
        ///    the size of the RIFF data as read from the file.
        /// </param>
        /// <param name="tag_start">
        ///    A <see cref="long" /> value reference to be filled with
        ///    the absolute seek position at which the tagging data
        ///    starts.
        /// </param>
        /// <param name="tag_end">
        ///    A <see cref="long" /> value reference to be filled with
        ///    the absolute seek position at which the tagging data
        ///    ends.
        /// </param>
        /// <exception cref="CorruptFileException">
        ///    The file does not begin with <see cref="FileIdentifier"
        ///    />.
        /// </exception>
        private void Read(bool read_tags, ReadStyle style,
                          out uint riff_size, out long tag_start,
                          out long tag_end)
        {
            Seek(0);
            if (ReadBlock(4) != FileIdentifier)
            {
                throw new CorruptFileException(
                          "File does not begin with RIFF identifier");
            }

            riff_size = ReadBlock(4).ToUInt(false);
            ByteVector stream_format = ReadBlock(4);

            tag_start = -1;
            tag_end   = -1;

            long     position = 12;
            long     length   = Length;
            uint     size     = 0;
            TimeSpan duration = TimeSpan.Zero;

            ICodec [] codecs = new ICodec [0];

            // Read until there are less than 8 bytes to read.
            do
            {
                bool tag_found = false;

                Seek(position);
                string fourcc = ReadBlock(4).ToString(StringType.UTF8);
                size = ReadBlock(4).ToUInt(false);

                switch (fourcc)
                {
                // "fmt " is used by Wave files to hold the
                // WaveFormatEx structure.
                case "fmt ":
                    if (style == ReadStyle.None ||
                        stream_format != "WAVE")
                    {
                        break;
                    }

                    Seek(position + 8);
                    codecs = new ICodec [] {
                        new WaveFormatEx(ReadBlock(18), 0)
                    };
                    break;

                // "data" contains the audio data for wave
                // files. It's contents represent the invariant
                // portion of the file and is used to determine
                // the duration of a file. It should always
                // appear after "fmt ".
                case "data":
                    if (stream_format != "WAVE")
                    {
                        break;
                    }

                    InvariantStartPosition = position;
                    InvariantEndPosition   = position + size;

                    if (style == ReadStyle.None ||
                        codecs.Length != 1 ||
                        !(codecs [0] is WaveFormatEx))
                    {
                        break;
                    }

                    duration += TimeSpan.FromSeconds(
                        (double)size / (double)
                        ((WaveFormatEx)codecs [0])
                        .AverageBytesPerSecond);

                    break;

                // Lists are used to store a variety of data
                // collections. Read the type and act on it.
                case "LIST":
                {
                    switch (ReadBlock(4).ToString(StringType.UTF8))
                    {
                    // "hdlr" is used by AVI files to hold
                    // a media header and BitmapInfoHeader
                    // and WaveFormatEx structures.
                    case "hdrl":
                        if (style == ReadStyle.None ||
                            stream_format != "AVI ")
                        {
                            continue;
                        }

                        AviHeaderList header_list =
                            new AviHeaderList(this,
                                              position + 12,
                                              (int)(size - 4));
                        duration = header_list.Header.Duration;
                        codecs   = header_list.Codecs;
                        break;

                    // "INFO" is a tagging format handled by
                    // the InfoTag class.
                    case "INFO":
                        if (read_tags && info_tag == null)
                        {
                            info_tag = new InfoTag(
                                this,
                                position + 12,
                                (int)(size - 4));
                        }

                        tag_found = true;
                        break;

                    // "MID " is a tagging format handled by
                    // the MovieIdTag class.
                    case "MID ":
                        if (read_tags && mid_tag == null)
                        {
                            mid_tag = new MovieIdTag(
                                this,
                                position + 12,
                                (int)(size - 4));
                        }

                        tag_found = true;
                        break;

                    // "movi" contains the media data for
                    // and AVI and its contents represent
                    // the invariant portion of the file.
                    case "movi":
                        if (stream_format != "AVI ")
                        {
                            break;
                        }

                        InvariantStartPosition = position;
                        InvariantEndPosition   = position + size;
                        break;
                    }
                    break;
                }

                // "ID32" is a custom box for this format that
                // contains an ID3v2 tag.
                case "ID32":
                    if (read_tags && id32_tag == null)
                    {
                        id32_tag = new Id3v2.Tag(this,
                                                 position + 8);
                    }

                    tag_found = true;
                    break;

                // "IDVX" is used by DivX and holds an ID3v1-
                // style tag.
                case "IDVX":
                    if (read_tags && divx_tag == null)
                    {
                        divx_tag = new DivXTag(this,
                                               position + 8);
                    }

                    tag_found = true;
                    break;

                // "JUNK" is a padding element that could be
                // associated with tag data.
                case "JUNK":
                    if (tag_end == position)
                    {
                        tag_end = position + 8 + size;
                    }
                    break;
                }

                // Determine the region of the file that
                // contains tags.
                if (tag_found)
                {
                    if (tag_start == -1)
                    {
                        tag_start = position;
                        tag_end   = position + 8 + size;
                    }
                    else if (tag_end == position)
                    {
                        tag_end = position + 8 + size;
                    }
                }

                // Move to the next item.
            } while ((position += 8 + size) + 8 < length);

            // If we're reading properties, and one were found,
            // throw an exception. Otherwise, create the Properties
            // object.
            if (style != ReadStyle.None)
            {
                if (codecs.Length == 0)
                {
                    throw new UnsupportedFormatException(
                              "Unsupported RIFF type.");
                }

                properties = new Properties(duration, codecs);
            }

            // If we're reading tags, update the combined tag.
            if (read_tags)
            {
                tag.SetTags(id32_tag, info_tag, mid_tag, divx_tag);
            }
        }