public IsoAudioSampleEntry(BoxHeader header, TagLib.File file, IsoHandlerBox handler) : base(header, file, handler)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
file.Seek(base.DataPosition + 8L);
this.channel_count = file.ReadBlock(2).ToUShort();
this.sample_size = file.ReadBlock(2).ToUShort();
file.Seek(base.DataPosition + 0x10L);
this.sample_rate = file.ReadBlock(4).ToUInt();
this.children = base.LoadChildren(file);
}
protected void Read(TagLib.File file)
{
if (file == null)
return;
try
{
file.Mode = FileAccessMode.Read;
}
catch (TagLibException)
{
return;
}
file.Seek(tagOffset);
header.SetData(file.ReadBlock((int)Id3v2Header.Size));
// if the tag size is 0, then this is an invalid tag (tags must contain
// at least one frame)
if (header.TagSize == 0)
return;
Parse(file.ReadBlock((int)header.TagSize));
}
public Page(TagLib.Ogg.File file, long position) : this(new PageHeader(file, position))
{
file.Seek(position + this.header.Size);
foreach (int num in this.header.PacketSizes)
{
this.packets.Add(file.ReadBlock(num));
}
}
protected ListTag (TagLib.File file, long position, int length)
{
if (file == null)
throw new System.ArgumentNullException ("file");
file.Seek (position);
fields = new List (file.ReadBlock (length));
}
public IsoSampleEntry(BoxHeader header, TagLib.File file, IsoHandlerBox handler) : base(header, handler)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
file.Seek(base.DataPosition + 6L);
this.data_reference_index = file.ReadBlock(2).ToUShort();
}
private AudioHeader(ByteVector data, TagLib.File file, long position)
{
this.duration = TimeSpan.Zero;
this.stream_length = 0L;
if (data.Count < 4)
{
throw new CorruptFileException("Insufficient header length.");
}
if (data[0] != 0xff)
{
throw new CorruptFileException("First byte did not match MPEG synch.");
}
if (((data[1] & 230) <= 0xe0) || ((data[1] & 0x18) == 8))
{
throw new CorruptFileException("Second byte did not match MPEG synch.");
}
this.flags = data.ToUInt();
if (((this.flags >> 12) & 15) == 15)
{
throw new CorruptFileException("Header uses invalid bitrate index.");
}
if (((this.flags >> 10) & 3) == 3)
{
throw new CorruptFileException("Invalid sample rate.");
}
this.xing_header = TagLib.Mpeg.XingHeader.Unknown;
this.vbri_header = TagLib.Mpeg.VBRIHeader.Unknown;
file.Seek(position + TagLib.Mpeg.XingHeader.XingHeaderOffset(this.Version, this.ChannelMode));
ByteVector vector = file.ReadBlock(0x10);
if ((vector.Count == 0x10) && vector.StartsWith(TagLib.Mpeg.XingHeader.FileIdentifier))
{
this.xing_header = new TagLib.Mpeg.XingHeader(vector);
}
if (!this.xing_header.Present)
{
file.Seek(position + TagLib.Mpeg.VBRIHeader.VBRIHeaderOffset());
ByteVector vector2 = file.ReadBlock(0x18);
if ((vector2.Count == 0x18) && vector2.StartsWith(TagLib.Mpeg.VBRIHeader.FileIdentifier))
{
this.vbri_header = new TagLib.Mpeg.VBRIHeader(vector2);
}
}
}
protected FullBox(BoxHeader header, TagLib.File file, IsoHandlerBox handler) : base(header, handler)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
file.Seek(base.DataPosition);
ByteVector vector = file.ReadBlock(4);
this.version = vector[0];
this.flags = vector.Mid(1, 3).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="TagLib.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, TagLib.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>
/// 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="TagLib.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, TagLib.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);
*/
}
protected Object(TagLib.Asf.File file, long position)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
if ((position < 0L) || (position > (file.Length - 0x18L)))
{
throw new ArgumentOutOfRangeException("position");
}
file.Seek(position);
this.id = file.ReadGuid();
this.size = file.ReadQWord();
}
/// <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="TagLib.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, TagLib.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);
}
public IsoHandlerBox(BoxHeader header, TagLib.File file, IsoHandlerBox handler) : base(header, file, handler)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
file.Seek(this.DataPosition + 4L);
ByteVector vector = file.ReadBlock(base.DataSize - 4);
this.handler_type = vector.Mid(0, 4);
int count = vector.Find(0, 0x10);
if (count < 0x10)
{
count = vector.Count;
}
this.name = vector.ToString(StringType.UTF8, 0x10, count - 0x10);
}
public PageHeader(TagLib.Ogg.File file, long position)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
if ((position < 0L) || (position > (file.Length - 0x1bL)))
{
throw new ArgumentOutOfRangeException("position");
}
file.Seek(position);
ByteVector vector = file.ReadBlock(0x1b);
if ((vector.Count < 0x1b) || !vector.StartsWith("OggS"))
{
throw new CorruptFileException("Error reading page header");
}
this.version = vector[4];
this.flags = (PageFlags) vector[5];
this.absolute_granular_position = vector.Mid(6, 8).ToULong(false);
this.stream_serial_number = vector.Mid(14, 4).ToUInt(false);
this.page_sequence_number = vector.Mid(0x12, 4).ToUInt(false);
int length = vector[0x1a];
ByteVector vector2 = file.ReadBlock(length);
if ((length < 1) || (vector2.Count != length))
{
throw new CorruptFileException("Incorrect number of page segments");
}
this.size = (uint) (0x1b + length);
this.packet_sizes = new List<int>();
int item = 0;
this.data_size = 0;
for (int i = 0; i < length; i++)
{
this.data_size += vector2[i];
item += vector2[i];
if (vector2[i] < 0xff)
{
this.packet_sizes.Add(item);
item = 0;
}
}
if (item > 0)
{
this.packet_sizes.Add(item);
}
}
public VideoHeader(TagLib.File file, long position)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
file.Seek(position);
ByteVector vector = file.ReadBlock(7);
if (vector.Count < 7)
{
throw new CorruptFileException("Insufficient data in header.");
}
this.width = vector.Mid(0, 2).ToUShort() >> 4;
this.height = vector.Mid(1, 2).ToUShort() & 0xfff;
this.frame_rate_index = vector[3] & 15;
this.bitrate = ((int) (vector.Mid(4, 3).ToUInt() >> 6)) & 0x3ffff;
}
public BoxHeader(TagLib.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 vector = file.ReadBlock(0x20);
int startIndex = 0;
if (vector.Count < (8 + startIndex))
{
throw new CorruptFileException("Not enough data in box header.");
}
this.header_size = 8;
this.box_size = vector.Mid(startIndex, 4).ToUInt();
this.box_type = vector.Mid(startIndex + 4, 4);
if (this.box_size == 1L)
{
if (vector.Count < (8 + startIndex))
{
throw new CorruptFileException("Not enough data in box header.");
}
this.header_size += 8;
this.box_size = vector.Mid(startIndex, 8).ToULong();
startIndex += 8;
}
if (this.box_type == TagLib.Mpeg4.BoxType.Uuid)
{
if (vector.Count < (0x10 + startIndex))
{
throw new CorruptFileException("Not enough data in box header.");
}
this.header_size += 0x10;
this.extended_type = vector.Mid(startIndex, 0x10);
}
else
{
this.extended_type = null;
}
}
public DivXTag(TagLib.Riff.File file, long position)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
file.Mode = TagLib.File.AccessMode.Read;
if ((position < 0L) || (position > (file.Length - 0x80L)))
{
throw new ArgumentOutOfRangeException("position");
}
file.Seek(position);
ByteVector data = file.ReadBlock(0x80);
if (!data.EndsWith(FileIdentifier))
{
throw new CorruptFileException("DivX tag data does not end with identifier.");
}
this.Parse(data);
}
/// <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="TagLib.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 langref="null" />.
/// </exception>
protected ByteVector LoadData (TagLib.File file)
{
if (file == null)
throw new ArgumentNullException ("file");
file.Seek (DataPosition);
return file.ReadBlock (DataSize);
}
public IsoVisualSampleEntry(BoxHeader header, TagLib.File file, IsoHandlerBox handler) : base(header, file, handler)
{
file.Seek(base.DataPosition + 0x10L);
this.width = file.ReadBlock(2).ToUShort();
this.height = file.ReadBlock(2).ToUShort();
}
/// <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="TagLib.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 (TagLib.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>
/// Searches for an audio header in a <see cref="TagLib.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="TagLib.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 langref="null" />.
/// </exception>
public static bool Find (out AudioHeader header,
TagLib.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="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="TagLib.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, TagLib.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.");
if (data [1] < 0xE0)
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>
/// Searches for an audio header in a <see cref="TagLib.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="TagLib.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,
TagLib.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;
}
public static bool Find(out AudioHeader header, TagLib.File file, long position, int length)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
long num = position + length;
header = Unknown;
file.Seek(position);
ByteVector vector = file.ReadBlock(3);
if (vector.Count >= 3)
{
do
{
file.Seek(position + 3L);
vector = vector.Mid(vector.Count - 3);
vector.Add(file.ReadBlock((int) TagLib.File.BufferSize));
for (int i = 0; (i < (vector.Count - 3)) && ((length < 0) || ((position + i) < num)); i++)
{
if ((vector[i] == 0xff) && (vector[i + 1] >= 240))
{
bool flag;
try
{
BitStream stream = new BitStream(vector.Mid(i, 7).Data);
stream.ReadInt32(12);
stream.ReadInt32(1);
stream.ReadInt32(2);
stream.ReadInt32(1);
stream.ReadInt32(2);
int index = stream.ReadInt32(4);
if (index >= sample_rates.Length)
{
return false;
}
long num4 = sample_rates[index];
stream.ReadInt32(1);
int num5 = stream.ReadInt32(3);
if (num5 >= channels.Length)
{
return false;
}
stream.ReadInt32(4);
long num6 = stream.ReadInt32(13);
if (num6 < 7L)
{
return false;
}
stream.ReadInt32(11);
int numberofframes = stream.ReadInt32(2) + 1;
long num8 = numberofframes * 0x400;
long num9 = ((num6 * 8L) * num4) / num8;
header = new AudioHeader(channels[num5], (int) num9, (int) num4, (int) num8, numberofframes);
flag = true;
}
catch (CorruptFileException)
{
}
return flag;
}
}
position += TagLib.File.BufferSize;
}
while ((vector.Count > 3) && ((length < 0) || (position < num)));
}
return false;
}
/// <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="TagLib.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, TagLib.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 ();
}
public static void OverwriteSequenceNumbers(TagLib.Ogg.File file, long position, IDictionary<uint, int> shiftTable)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
if (shiftTable == null)
{
throw new ArgumentNullException("shiftTable");
}
bool flag = true;
IEnumerator<KeyValuePair<uint, int>> enumerator = shiftTable.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
KeyValuePair<uint, int> current = enumerator.Current;
if (current.Value != 0)
{
flag = false;
goto Label_0065;
}
}
}
finally
{
if (enumerator == null)
{
}
enumerator.Dispose();
}
Label_0065:
if (flag)
{
return;
}
while (position < (file.Length - 0x1bL))
{
PageHeader header = new PageHeader(file, position);
int length = (int) (header.Size + header.DataSize);
if (shiftTable.ContainsKey(header.StreamSerialNumber) && (shiftTable[header.StreamSerialNumber] != 0))
{
file.Seek(position);
ByteVector vector = file.ReadBlock(length);
ByteVector data = ByteVector.FromUInt(header.PageSequenceNumber + ((uint) ((long) shiftTable[header.StreamSerialNumber])), false);
for (int i = 0x12; i < 0x16; i++)
{
vector[i] = data[i - 0x12];
}
for (int j = 0x16; j < 0x1a; j++)
{
vector[j] = 0;
}
data.Add(ByteVector.FromUInt(vector.Checksum, false));
file.Seek(position + 0x12L);
file.WriteBlock(data);
}
position += length;
}
}
/// <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="TagLib.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, TagLib.File file,
long position)
{
this.duration = TimeSpan.Zero;
stream_length = 0;
string error = GetHeaderError(data);
if (error != null) {
throw new CorruptFileException (error);
}
flags = data.ToUInt ();
xing_header = XingHeader.Unknown;
vbri_header = VBRIHeader.Unknown;
info_header = XingHeader.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)
{
if (xing_data.StartsWith(XingHeader.XingFileIdentifier))
{
xing_header = new XingHeader(xing_data);
if (xing_header.Present)
return;
}
if (xing_data.StartsWith(XingHeader.InfoFileIdentifier))
{
info_header = new XingHeader(xing_data);
if (info_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);
}
public IsoMovieHeaderBox(BoxHeader header, TagLib.File file, IsoHandlerBox handler) : base(header, file, handler)
{
ByteVector vector;
if (file == null)
{
throw new ArgumentNullException("file");
}
int dataSize = base.DataSize;
if (base.Version == 1)
{
vector = file.ReadBlock(Math.Min(0x1c, dataSize));
if (vector.Count >= 8)
{
this.creation_time = vector.Mid(0, 8).ToULong();
}
if (vector.Count >= 0x10)
{
this.modification_time = vector.Mid(8, 8).ToULong();
}
if (vector.Count >= 20)
{
this.timescale = vector.Mid(0x10, 4).ToUInt();
}
if (vector.Count >= 0x1c)
{
this.duration = vector.Mid(20, 8).ToULong();
}
dataSize -= 0x1c;
}
else
{
vector = file.ReadBlock(Math.Min(0x10, dataSize));
if (vector.Count >= 4)
{
this.creation_time = vector.Mid(0, 4).ToUInt();
}
if (vector.Count >= 8)
{
this.modification_time = vector.Mid(4, 4).ToUInt();
}
if (vector.Count >= 12)
{
this.timescale = vector.Mid(8, 4).ToUInt();
}
if (vector.Count >= 0x10)
{
this.duration = vector.Mid(12, 4).ToUInt();
}
dataSize -= 0x10;
}
vector = file.ReadBlock(Math.Min(6, dataSize));
if (vector.Count >= 4)
{
this.rate = vector.Mid(0, 4).ToUInt();
}
if (vector.Count >= 6)
{
this.volume = vector.Mid(4, 2).ToUShort();
}
file.Seek(file.Tell + 70L);
dataSize -= 0x4c;
vector = file.ReadBlock(Math.Min(4, dataSize));
if (vector.Count >= 4)
{
this.next_track_id = vector.Mid(0, 4).ToUInt();
}
}
/// <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="TagLib.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 langref="null" />.
/// </exception>
/// <exception cref="CorruptFileException">
/// Insufficient data could be read for the header.
/// </exception>
public VideoHeader (TagLib.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);
}
public static bool Find(out AudioHeader header, TagLib.File file, long position, int length)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
long num = position + length;
header = Unknown;
file.Seek(position);
ByteVector vector = file.ReadBlock(3);
if (vector.Count >= 3)
{
do
{
file.Seek(position + 3L);
vector = vector.Mid(vector.Count - 3);
vector.Add(file.ReadBlock((int) TagLib.File.BufferSize));
for (int i = 0; (i < (vector.Count - 3)) && ((length < 0) || ((position + i) < num)); i++)
{
if ((vector[i] == 0xff) && (vector[i + 1] > 0xe0))
{
try
{
header = new AudioHeader(vector.Mid(i, 4), file, position + i);
return true;
}
catch (CorruptFileException)
{
}
}
}
position += TagLib.File.BufferSize;
}
while ((vector.Count > 3) && ((length < 0) || (position < num)));
}
return false;
}