/* * /// <summary> * /// Contains the children of the box. * /// </summary> * private BoxList children; */ #endregion #region Constructors /// <summary> /// Constructs and initializes a new instance of <see /// cref="IsoVisualSampleEntry" /> with a provided header and /// handler by reading the contents from a specified file. /// </summary> /// <param name="header"> /// A <see cref="BoxHeader" /> object containing the header /// to use for the new instance. /// </param> /// <param name="file"> /// A <see cref="TagLibSharp.File" /> object to read the contents /// of the box from. /// </param> /// <param name="handler"> /// A <see cref="IsoHandlerBox" /> object containing the /// handler that applies to the new instance. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="file" /> is <see langword="null" />. /// </exception> public IsoVisualSampleEntry(BoxHeader header, TagLibSharp.File file, IsoHandlerBox handler) : base(header, file, handler) { file.Seek(base.DataPosition + 16); width = file.ReadBlock(2).ToUShort(); height = file.ReadBlock(2).ToUShort(); /* * TODO: What are the children anyway? * children = LoadChildren (file); */ }
/// <summary> /// Searches for an audio header in a <see cref="TagLibSharp.File" /// /> starting at a specified position and searching through /// a specified number of bytes. /// </summary> /// <param name="header"> /// A <see cref="AudioHeader" /> object in which the found /// header will be stored. /// </param> /// <param name="file"> /// A <see cref="TagLibSharp.File" /> object to search. /// </param> /// <param name="position"> /// A <see cref="long" /> value specifying the seek position /// in <paramref name="file" /> at which to start searching. /// </param> /// <param name="length"> /// A <see cref="int" /> value specifying the maximum number /// of bytes to search before aborting. /// </param> /// <returns> /// A <see cref="bool" /> value indicating whether or not a /// header was found. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="file" /> is <see langword="null" />. /// </exception> public static bool Find(out AudioHeader header, TagLibSharp.File file, long position, int length) { if (file == null) { throw new ArgumentNullException("file"); } long end = position + length; header = AudioHeader.Unknown; file.Seek(position); ByteVector buffer = file.ReadBlock(3); if (buffer.Count < 3) { return(false); } do { file.Seek(position + 3); buffer = buffer.Mid(buffer.Count - 3); buffer.Add(file.ReadBlock( (int)File.BufferSize)); for (int i = 0; i < buffer.Count - 3 && (length < 0 || position + i < end); i++) { if (buffer [i] == 0xFF && buffer [i + 1] > 0xE0) { try { header = new AudioHeader( buffer.Mid(i, 4), file, position + i); return(true); } catch (CorruptFileException) { } } } position += File.BufferSize; } while (buffer.Count > 3 && (length < 0 || position < end)); return(false); }
/// <summary> /// Constructs and initializes a new instance of <see /// cref="IsoVisualSampleEntry" /> with a provided header and /// handler by reading the contents from a specified file. /// </summary> /// <param name="header"> /// A <see cref="BoxHeader" /> object containing the header /// to use for the new instance. /// </param> /// <param name="file"> /// A <see cref="TagLibSharp.File" /> object to read the contents /// of the box from. /// </param> /// <param name="handler"> /// A <see cref="IsoHandlerBox" /> object containing the /// handler that applies to the new instance. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="file" /> is <see langword="null" />. /// </exception> public IsoAudioSampleEntry(BoxHeader header, TagLibSharp.File file, IsoHandlerBox handler) : base(header, file, handler) { if (file == null) { throw new ArgumentNullException("file"); } file.Seek(base.DataPosition + 8); channel_count = file.ReadBlock(2).ToUShort(); sample_size = file.ReadBlock(2).ToUShort(); file.Seek(base.DataPosition + 16); sample_rate = file.ReadBlock(4).ToUInt(); children = LoadChildren(file); }
/// <summary> /// Looks for a tag starting at a specified position and moves /// the cursor to its start position. /// </summary> /// <param name="position"> /// A <see cref="long" /> value reference specifying at what /// position the potential tag starts. If a tag is found, /// this value will be updated to the position at which the /// found tag ends. /// </param> /// <returns> /// A <see cref="TagTypes" /> value specifying the /// type of tag found at the specified position, or <see /// cref="TagTypes.None" /> if no tag was found. /// </returns> private TagTypes ReadTagInfo(ref long position) { file.Seek(position); ByteVector data = file.ReadBlock(read_size); try { if (data.StartsWith(Footer.FileIdentifier)) { Footer footer = new Footer(data); position += footer.CompleteTagSize; return(TagTypes.Ape); } if (data.StartsWith(Header.FileIdentifier)) { Header header = new Header(data); position += header.CompleteTagSize; return(TagTypes.Id3v2); } } catch (CorruptFileException) { } return(TagTypes.None); }
/// <summary> /// Constructs and initializes a new instance of <see /// cref="BoxHeader" /> by reading it from a specified seek /// position in a specified file. /// </summary> /// <param name="file"> /// A <see cref="TagLibSharp.File" /> object to read the new /// instance from. /// </param> /// <param name="position"> /// A <see cref="long" /> value specifiying the seek position /// in <paramref name="file" /> at which to start reading. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="file" /> is <see langword="null" />. /// </exception> /// <exception cref="CorruptFileException"> /// There isn't enough data in the file to read the complete /// header. /// </exception> public BoxHeader(TagLibSharp.File file, long position) { if (file == null) { throw new ArgumentNullException("file"); } this.box = null; this.from_disk = true; this.position = position; file.Seek(position); ByteVector data = file.ReadBlock(32); int offset = 0; if (data.Count < 8 + offset) { throw new CorruptFileException( "Not enough data in box header."); } header_size = 8; box_size = data.Mid(offset, 4).ToUInt(); box_type = data.Mid(offset + 4, 4); // If the size is 1, that just tells us we have a // massive ULONG size waiting for us in the next 8 // bytes. if (box_size == 1) { if (data.Count < 8 + offset) { throw new CorruptFileException( "Not enough data in box header."); } header_size += 8; box_size = data.Mid(offset, 8).ToULong(); offset += 8; } // UUID has a special header with 16 extra bytes. if (box_type == Mpeg4.BoxType.Uuid) { if (data.Count < 16 + offset) { throw new CorruptFileException( "Not enough data in box header."); } header_size += 16; extended_type = data.Mid(offset, 16); } else { extended_type = null; } }
/// <summary> /// Looks for a tag ending at a specified position and moves /// the cursor to its start position. /// </summary> /// <param name="position"> /// A <see cref="long" /> value reference specifying at what /// position the potential tag ends. If a tag is found, /// this value will be updated to the position at which the /// found tag starts. /// </param> /// <returns> /// A <see cref="TagTypes" /> value specifying the /// type of tag found at the specified position, or <see /// cref="TagTypes.None" /> if no tag was found. /// </returns> private TagTypes ReadTagInfo(ref long position) { if (position - read_size < 0) { return(TagTypes.None); } file.Seek(position - read_size); ByteVector data = file.ReadBlock(read_size); try { int offset = (int)(data.Count - Footer.Size); if (data.ContainsAt(Footer.FileIdentifier, offset)) { Footer footer = new Footer( data.Mid(offset)); // If the complete tag size is zero or // the tag is a header, this indicates // some sort of corruption. if (footer.CompleteTagSize == 0 || (footer.Flags & FooterFlags.IsHeader) != 0) { return(TagTypes.None); } position -= footer.CompleteTagSize; return(TagTypes.Ape); } offset = (int)(data.Count - Id3v2.Footer.Size); if (data.ContainsAt(Id3v2.Footer.FileIdentifier, offset)) { Id3v2.Footer footer = new Id3v2.Footer( data.Mid(offset)); position -= footer.CompleteTagSize; return(TagTypes.Id3v2); } if (data.StartsWith( Id3v1.Tag.FileIdentifier)) { position -= Id3v1.Tag.Size; return(TagTypes.Id3v1); } } catch (CorruptFileException) { } return(TagTypes.None); }
/// <summary> /// Loads the data of the current instance from a specified /// file using the internal data position and size. /// </summary> /// <param name="file"> /// The <see cref="TagLibSharp.File" /> from which the current /// instance was read and from which to read the data. /// </param> /// <returns> /// A <see cref="ByteVector" /> object containing the data /// read from the file. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="file" /> is <see langword="null" />. /// </exception> protected ByteVector LoadData(TagLibSharp.File file) { if (file == null) { throw new ArgumentNullException("file"); } file.Seek(DataPosition); return(file.ReadBlock(DataSize)); }
/// <summary> /// Constructs and initializes a new instance of <see /// cref="IsoSampleEntry" /> with a provided header and /// handler by reading the contents from a specified file. /// </summary> /// <param name="header"> /// A <see cref="BoxHeader" /> object containing the header /// to use for the new instance. /// </param> /// <param name="file"> /// A <see cref="TagLibSharp.File" /> object to read the contents /// of the box from. /// </param> /// <param name="handler"> /// A <see cref="IsoHandlerBox" /> object containing the /// handler that applies to the new instance. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="file" /> is <see langword="null" />. /// </exception> public IsoSampleEntry(BoxHeader header, TagLibSharp.File file, IsoHandlerBox handler) : base(header, handler) { if (file == null) { throw new ArgumentNullException("file"); } file.Seek(base.DataPosition + 6); data_reference_index = file.ReadBlock(2).ToUShort(); }
/// <summary> /// Constructs and initializes a new instance of <see /// cref="IsoSampleDescriptionBox" /> with a provided header /// and handler by reading the contents from a specified /// file. /// </summary> /// <param name="header"> /// A <see cref="BoxHeader" /> object containing the header /// to use for the new instance. /// </param> /// <param name="file"> /// A <see cref="TagLibSharp.File" /> object to read the contents /// of the box from. /// </param> /// <param name="handler"> /// A <see cref="IsoHandlerBox" /> object containing the /// handler that applies to the new instance. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="file" /> is <see langword="null" />. /// </exception> public IsoSampleDescriptionBox(BoxHeader header, TagLibSharp.File file, IsoHandlerBox handler) : base(header, file, handler) { if (file == null) { throw new ArgumentNullException("file"); } entry_count = file.ReadBlock(4).ToUInt(); children = LoadChildren(file); }
/// <summary> /// Constructs and initializes a new instance of <see /// cref="IsoChunkOffsetBox" /> with a provided header and /// handler by reading the contents from a specified file. /// </summary> /// <param name="header"> /// A <see cref="BoxHeader" /> object containing the header /// to use for the new instance. /// </param> /// <param name="file"> /// A <see cref="TagLibSharp.File" /> object to read the contents /// of the box from. /// </param> /// <param name="handler"> /// A <see cref="IsoHandlerBox" /> object containing the /// handler that applies to the new instance. /// </param> public IsoChunkOffsetBox(BoxHeader header, TagLibSharp.File file, IsoHandlerBox handler) : base(header, file, handler) { ByteVector box_data = file.ReadBlock(DataSize); offsets = new uint [(int) box_data.Mid(0, 4).ToUInt()]; for (int i = 0; i < offsets.Length; i++) { offsets [i] = box_data.Mid(4 + i * 4, 4).ToUInt(); } }
/// <summary> /// Constructs and initializes a new instance of <see /// cref="FullBox" /> with a provided header and handler by /// reading the contents from a specified file. /// </summary> /// <param name="header"> /// A <see cref="BoxHeader" /> object containing the header /// to use for the new instance. /// </param> /// <param name="file"> /// A <see cref="TagLibSharp.File" /> object to read the contents /// of the box from. /// </param> /// <param name="handler"> /// A <see cref="IsoHandlerBox" /> object containing the /// handler that applies to the new instance. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="file" /> is <see langword="null" />. /// </exception> protected FullBox(BoxHeader header, TagLibSharp.File file, IsoHandlerBox handler) : base(header, handler) { if (file == null) { throw new ArgumentNullException("file"); } file.Seek(base.DataPosition); ByteVector header_data = file.ReadBlock(4); version = header_data [0]; flags = header_data.Mid(1, 3).ToUInt(); }
/// <summary> /// Constructs and initializes a new instance of <see /// cref="List" /> by reading the contents of a raw RIFF list /// from a specified position in a <see cref="TagLibSharp.File"/>. /// </summary> /// <param name="file"> /// A <see cref="TagLibSharp.File" /> object containing the file /// from which the contents of the new instance is to be /// read. /// </param> /// <param name="position"> /// A <see cref="long" /> value specify at what position to /// read the list. /// </param> /// <param name="length"> /// A <see cref="int" /> value specifying the number of bytes /// to read. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="file" /> is <see langword="null" />. /// </exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="position" /> is less than zero or greater /// than the size of the file. /// </exception> public List(TagLibSharp.File file, long position, int length) { if (file == null) { throw new ArgumentNullException("file"); } if (length < 0) { throw new ArgumentOutOfRangeException( "length"); } if (position < 0 || position > file.Length - length) { throw new ArgumentOutOfRangeException( "position"); } file.Seek(position); Parse(file.ReadBlock(length)); }
/// <summary> /// Constructs and initializes a new instance of <see /// cref="IsoHandlerBox" /> with a provided header and /// handler by reading the contents from a specified file. /// </summary> /// <param name="header"> /// A <see cref="BoxHeader" /> object containing the header /// to use for the new instance. /// </param> /// <param name="file"> /// A <see cref="TagLibSharp.File" /> object to read the contents /// of the box from. /// </param> /// <param name="handler"> /// A <see cref="IsoHandlerBox" /> object containing the /// handler that applies to the new instance. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="file" /> is <see langword="null" />. /// </exception> public IsoHandlerBox(BoxHeader header, TagLibSharp.File file, IsoHandlerBox handler) : base(header, file, handler) { if (file == null) { throw new System.ArgumentNullException("file"); } file.Seek(DataPosition + 4); ByteVector box_data = file.ReadBlock(DataSize - 4); handler_type = box_data.Mid(0, 4); int end = box_data.Find((byte)0, 16); if (end < 16) { end = box_data.Count; } name = box_data.ToString(StringType.UTF8, 16, end - 16); }
/// <summary> /// Constructs and initializes a new instance of <see /// cref="VideoHeader" /> by reading it from a specified /// location in a specified file. /// </summary> /// <param name="file"> /// A <see cref="TagLibSharp.File" /> object to read from. /// </param> /// <param name="position"> /// A <see cref="long" /> value indicating the position in /// <paramref name="file" /> at which the header begins. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="file" /> is <see langword="null" />. /// </exception> /// <exception cref="CorruptFileException"> /// Insufficient data could be read for the header. /// </exception> public VideoHeader(TagLibSharp.File file, long position) { if (file == null) { throw new ArgumentNullException("file"); } file.Seek(position); ByteVector data = file.ReadBlock(7); if (data.Count < 7) { throw new CorruptFileException( "Insufficient data in header."); } width = data.Mid(0, 2).ToUShort() >> 4; height = data.Mid(1, 2).ToUShort() & 0x0FFF; frame_rate_index = data [3] & 0x0F; bitrate = (int)((data.Mid(4, 3).ToUInt() >> 6) & 0x3FFFF); }
/// <summary> /// Constructs and initializes a new instance of <see /// cref="AudioHeader" /> by reading its contents from a /// <see cref="ByteVector" /> object and its Xing Header from /// the appropriate location in the specified file. /// </summary> /// <param name="data"> /// A <see cref="ByteVector" /> object containing the header /// to read. /// </param> /// <param name="file"> /// A <see cref="TagLibSharp.File" /> object to read the Xing /// header from. /// </param> /// <param name="position"> /// A <see cref="long" /> value indicating the position in /// <paramref name="file" /> at which the header begins. /// </param> /// <exception cref="CorruptFileException"> /// <paramref name="data" /> is less than 4 bytes long, /// does not begin with a MPEG audio synch, has a negative /// bitrate, or has a sample rate of zero. /// </exception> private AudioHeader(ByteVector data, TagLibSharp.File file, long position) { this.duration = TimeSpan.Zero; stream_length = 0; if (data.Count < 4) { throw new CorruptFileException( "Insufficient header length."); } if (data [0] != 0xFF) { throw new CorruptFileException( "First byte did not match MPEG synch."); } // Checking bits from high to low: // // First 3 bits MUST be set. Bits 4 and 5 can // be 00, 10, or 11 but not 01. One or more of // bits 6 and 7 must be set. Bit 8 can be // anything. if ((data [1] & 0xE6) <= 0xE0 || (data [1] & 0x18) == 0x08) { throw new CorruptFileException( "Second byte did not match MPEG synch."); } flags = data.ToUInt(); if (((flags >> 12) & 0x0F) == 0x0F) { throw new CorruptFileException( "Header uses invalid bitrate index."); } if (((flags >> 10) & 0x03) == 0x03) { throw new CorruptFileException( "Invalid sample rate."); } xing_header = XingHeader.Unknown; vbri_header = VBRIHeader.Unknown; // Check for a Xing header that will help us in // gathering information about a VBR stream. file.Seek(position + XingHeader.XingHeaderOffset( Version, ChannelMode)); ByteVector xing_data = file.ReadBlock(16); if (xing_data.Count == 16 && xing_data.StartsWith( XingHeader.FileIdentifier)) { xing_header = new XingHeader(xing_data); } if (xing_header.Present) { return; } // A Xing header could not be found, next chec for a // Fraunhofer VBRI header. file.Seek(position + VBRIHeader.VBRIHeaderOffset()); // Only get the first 24 bytes of the Header. // We're not interested in the TOC entries. ByteVector vbri_data = file.ReadBlock(24); if (vbri_data.Count == 24 && vbri_data.StartsWith(VBRIHeader.FileIdentifier)) { vbri_header = new VBRIHeader(vbri_data); } }
/// <summary> /// Constructs and initializes a new instance of <see /// cref="AppleAdditionalInfoBox" /> with a provided header /// and handler by reading the contents from a specified /// file. /// </summary> /// <param name="header"> /// A <see cref="BoxHeader" /> object containing the header /// to use for the new instance. /// </param> /// <param name="file"> /// A <see cref="TagLibSharp.File" /> object to read the contents /// of the box from. /// </param> /// <param name="handler"> /// A <see cref="IsoHandlerBox" /> object containing the /// handler that applies to the new instance. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="file" /> is <see langword="null" />. /// </exception> public AppleAdditionalInfoBox(BoxHeader header, TagLibSharp.File file, IsoHandlerBox handler) : base(header, file, handler) { Data = file.ReadBlock(DataSize); }
/// <summary> /// Constructs and initializes a new instance of <see /// cref="IsoMovieHeaderBox" /> with a provided header and /// handler by reading the contents from a specified file. /// </summary> /// <param name="header"> /// A <see cref="BoxHeader" /> object containing the header /// to use for the new instance. /// </param> /// <param name="file"> /// A <see cref="TagLibSharp.File" /> object to read the contents /// of the box from. /// </param> /// <param name="handler"> /// A <see cref="IsoHandlerBox" /> object containing the /// handler that applies to the new instance. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="file" /> is <see langword="null" />. /// </exception> public IsoMovieHeaderBox(BoxHeader header, TagLibSharp.File file, IsoHandlerBox handler) : base(header, file, handler) { if (file == null) { throw new ArgumentNullException("file"); } int bytes_remaining = DataSize; ByteVector data; if (Version == 1) { // Read version one (large integers). data = file.ReadBlock(Math.Min(28, bytes_remaining)); if (data.Count >= 8) { creation_time = data.Mid(0, 8).ToULong(); } if (data.Count >= 16) { modification_time = data.Mid(8, 8).ToULong(); } if (data.Count >= 20) { timescale = data.Mid(16, 4).ToUInt(); } if (data.Count >= 28) { duration = data.Mid(20, 8).ToULong(); } bytes_remaining -= 28; } else { // Read version zero (normal integers). data = file.ReadBlock(Math.Min(16, bytes_remaining)); if (data.Count >= 4) { creation_time = data.Mid(0, 4).ToUInt(); } if (data.Count >= 8) { modification_time = data.Mid(4, 4).ToUInt(); } if (data.Count >= 12) { timescale = data.Mid(8, 4).ToUInt(); } if (data.Count >= 16) { duration = data.Mid(12, 4).ToUInt(); } bytes_remaining -= 16; } data = file.ReadBlock(Math.Min(6, bytes_remaining)); if (data.Count >= 4) { rate = data.Mid(0, 4).ToUInt(); } if (data.Count >= 6) { volume = data.Mid(4, 2).ToUShort(); } file.Seek(file.Tell + 70); bytes_remaining -= 76; data = file.ReadBlock(Math.Min(4, bytes_remaining)); if (data.Count >= 4) { next_track_id = data.Mid(0, 4).ToUInt(); } }
/// <summary> /// Constructs and initializes a new instance of <see /// cref="AppleElementaryStreamDescriptor" /> with a provided /// header and handler by reading the contents from a /// specified file. /// </summary> /// <param name="header"> /// A <see cref="BoxHeader" /> object containing the header /// to use for the new instance. /// </param> /// <param name="file"> /// A <see cref="TagLibSharp.File" /> object to read the contents /// of the box from. /// </param> /// <param name="handler"> /// A <see cref="IsoHandlerBox" /> object containing the /// handler that applies to the new instance. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="file" /> is <see langword="null" />. /// </exception> /// <exception cref="CorruptFileException"> /// Valid data could not be read. /// </exception> public AppleElementaryStreamDescriptor(BoxHeader header, TagLibSharp.File file, IsoHandlerBox handler) : base(header, file, handler) { int offset = 0; ByteVector box_data = file.ReadBlock(DataSize); decoder_config = new ByteVector(); // Elementary Stream Descriptor Tag if (box_data [offset++] == 3) { // We have a descriptor tag. Check that it's at // least 20 long. if (ReadLength(box_data, ref offset) < 20) { throw new CorruptFileException( "Insufficient data present."); } es_id = box_data.Mid(offset, 2).ToUShort(); offset += 2; stream_priority = box_data [offset++]; } else { // The tag wasn't found, so the next two byte // are the ID, and after that, business as // usual. es_id = box_data.Mid(offset, 2).ToUShort(); offset += 2; } // Verify that the next data is the Decoder // Configuration Descriptor Tag and escape if it won't // work out. if (box_data [offset++] != 4) { throw new CorruptFileException( "Could not identify decoder configuration descriptor."); } // Check that it's at least 15 long. if (ReadLength(box_data, ref offset) < 15) { throw new CorruptFileException( "Could not read data. Too small."); } // Read a lot of good info. object_type_id = box_data [offset++]; stream_type = box_data [offset++]; buffer_size_db = box_data.Mid(offset, 3).ToUInt(); offset += 3; max_bitrate = box_data.Mid(offset, 4).ToUInt(); offset += 4; average_bitrate = box_data.Mid(offset, 4).ToUInt(); offset += 4; // Verify that the next data is the Decoder Specific // Descriptor Tag and escape if it won't work out. if (box_data [offset++] != 5) { throw new CorruptFileException( "Could not identify decoder specific descriptor."); } // The rest of the info is decoder specific. uint length = ReadLength(box_data, ref offset); decoder_config = box_data.Mid(offset, (int)length); }
/// <summary> /// Searches for an audio header in a <see cref="TagLibSharp.File" /// /> starting at a specified position and searching through /// a specified number of bytes. /// </summary> /// <param name="header"> /// A <see cref="AudioHeader" /> object in which the found /// header will be stored. /// </param> /// <param name="file"> /// A <see cref="TagLibSharp.File" /> object to search. /// </param> /// <param name="position"> /// A <see cref="long" /> value specifying the seek position /// in <paramref name="file" /> at which to start searching. /// </param> /// <param name="length"> /// A <see cref="int" /> value specifying the maximum number /// of bytes to search before aborting. /// </param> /// <returns> /// A <see cref="bool" /> value indicating whether or not a /// header was found. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="file" /> is <see langword="null" />. /// </exception> public static bool Find(out AudioHeader header, TagLibSharp.File file, long position, int length) { if (file == null) { throw new ArgumentNullException("file"); } long end = position + length; header = AudioHeader.Unknown; file.Seek(position); ByteVector buffer = file.ReadBlock(3); if (buffer.Count < 3) { return(false); } do { file.Seek(position + 3); buffer = buffer.Mid(buffer.Count - 3); buffer.Add(file.ReadBlock( (int)File.BufferSize)); for (int i = 0; i < buffer.Count - 3 && (length < 0 || position + i < end); i++) { if (buffer[i] == 0xFF && buffer[i + 1] >= 0xF0) // 0xFFF { try { BitStream bits = new BitStream(buffer.Mid(i, 7).Data); // 12 bits sync header bits.ReadInt32(12); // 1 bit mpeg 2/4 bits.ReadInt32(1); // 2 bits layer bits.ReadInt32(2); // 1 bit protection absent bits.ReadInt32(1); // 2 bits profile object type bits.ReadInt32(2); // 4 bits sampling frequency index int samplerateindex = bits.ReadInt32(4); if (samplerateindex >= sample_rates.Length) { return(false); } long samplerate = sample_rates[samplerateindex]; // 1 bit private bit bits.ReadInt32(1); // 3 bits channel configuration int channelconfigindex = bits.ReadInt32(3); if (channelconfigindex >= channels.Length) { return(false); } // 4 copyright bits bits.ReadInt32(4); // 13 bits frame length long framelength = bits.ReadInt32(13); // double check framelength if (framelength < 7) { return(false); } // 11 bits buffer fullness bits.ReadInt32(11); // 2 bits number of raw data blocks in frame int numberofframes = bits.ReadInt32(2) + 1; long numberofsamples = numberofframes * 1024; long bitrate = framelength * 8 * samplerate / numberofsamples; header = new AudioHeader(channels[channelconfigindex], (int)bitrate, (int)samplerate, (int)numberofsamples, numberofframes); return(true); } catch (CorruptFileException) { } } } position += File.BufferSize; } while (buffer.Count > 3 && (length < 0 || position < end)); return(false); }