private void ParseBoxHeaders(long start, long end, List<BoxHeader> parents)
 {
     BoxHeader header;
     for (long i = start; i < end; i += header.TotalBoxSize)
     {
         header = new BoxHeader(this.file, i);
         if ((this.moov_tree == null) && (header.BoxType == BoxType.Moov))
         {
             List<BoxHeader> list = AddParent(parents, header);
             this.moov_tree = list.ToArray();
             this.ParseBoxHeaders(header.HeaderSize + i, header.TotalBoxSize + i, list);
         }
         else if (((header.BoxType == BoxType.Mdia) || (header.BoxType == BoxType.Minf)) || ((header.BoxType == BoxType.Stbl) || (header.BoxType == BoxType.Trak)))
         {
             this.ParseBoxHeaders(header.HeaderSize + i, header.TotalBoxSize + i, AddParent(parents, header));
         }
         else if ((this.udta_tree == null) && (header.BoxType == BoxType.Udta))
         {
             this.udta_tree = AddParent(parents, header).ToArray();
         }
         else if (header.BoxType == BoxType.Mdat)
         {
             this.mdat_start = i;
             this.mdat_end = i + header.TotalBoxSize;
         }
         if (header.TotalBoxSize == 0)
         {
             break;
         }
     }
 }

 /// <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="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 AppleAdditionalInfoBox(BoxHeader header, TagLib.File file, IsoHandlerBox handler)
     : base(header, file, handler)
 {
     // We do not care what is in this custom data section
     // see: https://developer.apple.com/library/mac/#documentation/QuickTime/QTFF/QTFFChap2/qtff2.html
     Data = file.ReadBlock(DataSize > 0 ? DataSize : 0); ;
 }

 public AppleItemListBox(BoxHeader header, TagLib.File file, IsoHandlerBox handler) : base(header, handler)
 {
     if (file == null)
     {
         throw new ArgumentNullException("file");
     }
     this.children = base.LoadChildren(file);
 }

 public UnknownBox(BoxHeader header, TagLib.File file, IsoHandlerBox handler) : base(header, handler)
 {
     if (file == null)
     {
         throw new ArgumentNullException("file");
     }
     this.data = base.LoadData(file);
 }

 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();
 }

 public IsoSampleDescriptionBox(BoxHeader header, TagLib.File file, IsoHandlerBox handler) : base(header, file, handler)
 {
     if (file == null)
     {
         throw new ArgumentNullException("file");
     }
     this.entry_count = file.ReadBlock(4).ToUInt();
     this.children = base.LoadChildren(file);
 }

 public IsoChunkOffsetBox(BoxHeader header, TagLib.File file, IsoHandlerBox handler) : base(header, file, handler)
 {
     ByteVector vector = file.ReadBlock(base.DataSize);
     this.offsets = new uint[vector.Mid(0, 4).ToUInt()];
     for (int i = 0; i < this.offsets.Length; i++)
     {
         this.offsets[i] = vector.Mid(4 + (i * 4), 4).ToUInt();
     }
 }

        /// <summary>
        ///    Constructs and initializes a new instance of <see
        ///    cref="IsoSampleTableBox" /> 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 IsoSampleTableBox(BoxHeader header, TagLib.File file,
            IsoHandlerBox handler)
            : base(header, handler)
        {
            if (file == null)
                throw new ArgumentNullException ("file");

            children = LoadChildren (file);
        }

 private static List<BoxHeader> AddParent(List<BoxHeader> parents, BoxHeader current)
 {
     List<BoxHeader> list = new List<BoxHeader>();
     if (parents != null)
     {
         list.AddRange(parents);
     }
     list.Add(current);
     return list;
 }

 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 ();
        }

 public FileParser(TagLib.File file)
 {
     if (file == null)
     {
         throw new ArgumentNullException("file");
     }
     this.file = file;
     this.first_header = new BoxHeader(file, 0L);
     if (this.first_header.BoxType != "ftyp")
     {
         throw new CorruptFileException("File does not start with 'ftyp' box.");
     }
 }

		/// <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="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>
		public IsoChunkOffsetBox (BoxHeader header, TagLib.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 ();
		}

 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);
 }

		/*
		/// <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);
			*/
		}

        /// <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 AppleElementaryStreamDescriptor(BoxHeader header, TagLib.File file, IsoHandlerBox handler) : base(header, file, handler)
 {
     int offset = 0;
     ByteVector data = file.ReadBlock(base.DataSize);
     this.decoder_config = new ByteVector();
     if (data[offset++] == 3)
     {
         if (ReadLength(data, ref offset) < 20)
         {
             throw new CorruptFileException("Insufficient data present.");
         }
         this.es_id = data.Mid(offset, 2).ToUShort();
         offset += 2;
         this.stream_priority = data[offset++];
     }
     else
     {
         this.es_id = data.Mid(offset, 2).ToUShort();
         offset += 2;
     }
     if (data[offset++] != 4)
     {
         throw new CorruptFileException("Could not identify decoder configuration descriptor.");
     }
     if (ReadLength(data, ref offset) < 15)
     {
         throw new CorruptFileException("Could not read data. Too small.");
     }
     this.object_type_id = data[offset++];
     this.stream_type = data[offset++];
     this.buffer_size_db = data.Mid(offset, 3).ToUInt();
     offset += 3;
     this.max_bitrate = data.Mid(offset, 4).ToUInt();
     offset += 4;
     this.average_bitrate = data.Mid(offset, 4).ToUInt();
     offset += 4;
     if (data[offset++] != 5)
     {
         throw new CorruptFileException("Could not identify decoder specific descriptor.");
     }
     uint num2 = ReadLength(data, ref offset);
     this.decoder_config = data.Mid(offset, (int) num2);
 }

 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();
     }
 }

 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();
 }