Logo Search packages:      
Sourcecode: taglib-sharp version File versions  Download package

AppleElementaryStreamDescriptor.cs

//
// AppleElementaryStreamDescriptor.cs: Provides an implementation of an Apple
// ItemListBox.
//
// Author:
//   Brian Nickel (brian.nickel@gmail.com)
//
// Copyright (C) 2006-2007 Brian Nickel
// 
// This library is free software; you can redistribute it and/or modify
// it  under the terms of the GNU Lesser General Public License version
// 2.1 as published by the Free Software Foundation.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
// USA
//

using System;

namespace TagLib.Mpeg4 {
      /// <summary>
      ///    This class extends <see cref="FullBox" /> to provide an
      ///    implementation of an Apple ElementaryStreamDescriptor.
      /// </summary>
      /// <remarks>
      ///    This box may appear as a child of a <see
      ///    cref="IsoAudioSampleEntry" /> and provided further information
      ///    about an audio stream.
      /// </remarks>
00037       public class AppleElementaryStreamDescriptor : FullBox
      {
            #region Private Fields
            
            /// <summary>
            ///    Contains the stream ID.
            /// </summary>
00044             private ushort es_id;
            
            /// <summary>
            ///    Contains the stream priority.
            /// </summary>
00049             private byte stream_priority;
            
            /// <summary>
            ///    Contains the object type ID.
            /// </summary>
00054             private byte object_type_id;
            
            /// <summary>
            ///    Contains the stream type.
            /// </summary>
00059             private byte stream_type;
            
            /// <summary>
            ///    Contains the bugger size.
            /// </summary>
00064             private uint buffer_size_db;
            
            /// <summary>
            ///    Contains the maximum bitrate.
            /// </summary>
00069             private uint max_bitrate;
            
            /// <summary>
            ///    Contains the average bitrate.
            /// </summary>
00074             private uint average_bitrate;
            
            /// <summary>
            ///    Contains the decoder config.
            /// </summary>
00079             private ByteVector decoder_config;
            
            #endregion
            
            
            
            #region Constructors
            
            /// <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="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>
            /// <exception cref="CorruptFileException">
            ///    Valid data could not be read.
            /// </exception>
00111             public AppleElementaryStreamDescriptor (BoxHeader header,
                                                    TagLib.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);
            }
            
            #endregion
            
            
            
            #region Public Properties
            
            /// <summary>
            ///    Gets the ID of the stream described by the current
            ///    instance.
            /// </summary>
            /// <value>
            ///    A <see cref="ushort" /> value containing the ID of the
            ///    stream described by the current instance.
            /// </value>
00186             public ushort StreamId {
                  get {return es_id;}
            }
            
            /// <summary>
            ///    Gets the priority of the stream described by the current
            ///    instance.
            /// </summary>
            /// <value>
            ///    A <see cref="byte" /> value containing the priority of
            ///    the stream described by the current instance.
            /// </value>
00198             public byte StreamPriority {
                  get {return stream_priority;}
            }
            
            /// <summary>
            ///    Gets the object type ID of the stream described by the
            ///    current instance.
            /// </summary>
            /// <value>
            ///    A <see cref="byte" /> value containing the object type ID
            ///    of the stream described by the current instance.
            /// </value>
00210             public byte ObjectTypeId {
                  get {return object_type_id;}
            }
            
            /// <summary>
            ///    Gets the type the stream described by the current
            ///    instance.
            /// </summary>
            /// <value>
            ///    A <see cref="byte" /> value containing the type the
            ///    stream described by the current instance.
            /// </value>
00222             public byte StreamType {
                  get {return stream_type;}
            }
            
            /// <summary>
            ///    Gets the buffer size DB value the stream described by the
            ///    current instance.
            /// </summary>
            /// <value>
            ///    A <see cref="uint" /> value containing the buffer size DB
            ///    value the stream described by the current instance.
            /// </value>
00234             public uint BufferSizeDB {
                  get {return buffer_size_db;}
            }
            
            /// <summary>
            ///    Gets the maximum bitrate the stream described by the
            ///    current instance.
            /// </summary>
            /// <value>
            ///    A <see cref="uint" /> value containing the maximum
            ///    bitrate the stream described by the current instance.
            /// </value>
00246             public uint MaximumBitrate {
                  get {return max_bitrate / 1000;}
            }
            
            /// <summary>
            ///    Gets the maximum average the stream described by the
            ///    current instance.
            /// </summary>
            /// <value>
            ///    A <see cref="uint" /> value containing the average
            ///    bitrate the stream described by the current instance.
            /// </value>
00258             public uint AverageBitrate {
                  get {return average_bitrate / 1000;}
            }
            
            /// <summary>
            ///    Gets the decoder config data of stream described by the
            ///    current instance.
            /// </summary>
            /// <value>
            ///    A <see cref="ByteVector" /> object containing the decoder
            ///    config data of the stream described by the current
            ///    instance.
            /// </value>
00271             public ByteVector DecoderConfig {
                  get {return decoder_config;}
            }
            
            #endregion
            
            
            
            #region Private Methods
            
            /// <summary>
            ///    Reads a section length and updates the offset to the end
            ///    of of the length block.
            /// </summary>
            /// <param name="data">
            ///    A <see cref="ByteVector" /> object to read from.
            /// </param>
            /// <param name="offset">
            ///    A <see cref="int" /> value reference specifying the
            ///    offset at which to read. This value gets updated to the
            ///    position following the size data.
            /// </param>
            /// <returns>
            ///    A <see cref="uint" /> value containing the length that
            ///    was read.
            /// </returns>
00297             private static uint ReadLength (ByteVector data, ref int offset)
            {
                  byte b;
                  int end = offset + 4;
                  uint length = 0;
                  
                  do {
                        b = data [offset ++];
                        length = (uint) (length << 7) |
                              (uint) (b & 0x7f);
                  } while ((b & 0x80) != 0 && offset <= end);
                  
                  return length;
            }
            
            #endregion
      }
}

Generated by  Doxygen 1.6.0   Back to index