IndexTableSegmentImpl (Media Authoring with Java API)
Date: 2016-02-05

tv.amwa.maj.io.mxf.impl

## Class IndexTableSegmentImpl

- java.lang.Object
- - tv.amwa.maj.io.mxf.impl.IndexTableSegmentImpl

- All Implemented Interfaces:
    Cloneable, MetadataObject, IndexTableSegment, MXFUnit

      @MediaClass(uuid1=218169857,
                  uuid2=272,
                  uuid3=256,
                  uuid4={6,14,43,52,2,6,1,1},
                  definedName="IndexTableSegment",
                  description="Index tables are represented as one or more index table segments.",
                  namespace="http://www.smpte-ra.org/rp210",
                  prefix="mxf",
                  symbol="IndexTableSegment")
      public class IndexTableSegmentImpl
      extends Object
      implements MetadataObject, IndexTableSegment, Cloneable

  Index tables are represented as index table segments, where a complete index table may comprise one or more index table segments.

  See Also:
    `IndexTable`

- - ### Field Summary

    - ### Fields inherited from interface tv.amwa.maj.io.mxf.IndexTableSegment

      `EDITUNITBYTECOUNT_DEFAULT, EXTSTARTOFFSET_DEFAULT, key, SLICECOUNT_DEFAULT, VBEBYTECOUNT_DEFAULT`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `IndexTableSegmentImpl()`
    `IndexTableSegmentImpl(Rational indexEditRate, long indexStartPosition, long indexDuration, int indexSID, int bodySID)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `IndexTableSegmentImpl` | `clone()` Creates a cloned copy of this index table segment.
    `static IndexTableSegment` | `createFromBuffer(ByteBuffer buffer)`
    `boolean` | `equals(Object o)`
    `int` | `getBodySID()` Returns the stream identifier of the indexed essence container.
    `DeltaEntry[]` | `getDeltaEntryArray()` Returns the array of delta entries for this index table segment that describe the layout of each element stored within an edit unit.
    `int` | `getEditUnitByteCount()` Returns the byte count of each and every edit unit in the indexed essence container, which is greater than zero when this is a fixed size for all edit units.
    `long` | `getExtStartOffset()` Get the external start offset property of this index table segment that the byte offset to the first essence data in a CBE (Constant Bytes per Element) essence stream.
    `long` | `getIndexDuration()` Returns the time duration of this table segment measured in number of edit units of the referenced package.
    `Rational` | `getIndexEditRate()` Returns the edit rate of the master track in the indexed essence container, measured in hertz.
    `IndexEntry[]` | `getIndexEntryArray()` Returns the array of index entries for this index table segment that describes the stream offset of each edit unit.
    `int` | `getIndexSID()` Returns the stream identifier for this index table.
    `long` | `getIndexStartPosition()` Returns the first editable unit indexed by this index table segment measured in file package edit units.
    `byte` | `getPosTableCount()` Returns the number of entries in the position offsets table per edit unit, minus one as only offsets are recorded in the array.
    `byte` | `getSliceCount()` Returns the number of slices used to group the elements within an edit unit, minus one as only slice offsets are recorded in an array.
    `UnitType` | `getUnitType()`
    `long` | `getVBEByteCount()` Get the VBE byte count value that gives the byte offset to the end of the final essence unit in a VBE (Variable Bytes per Element) essence stream.
    `int` | `hashCode()`
    `void` | `setBodySID(int bodySID)` Sets the stream identifier of the indexed essence container.
    `void` | `setDeltaEntries(int[] elementDeltas)` Sets the array of delta entries for this index table segment using element delta offsets only.
    `void` | `setDeltaEntryArray(DeltaEntry[] deltaEntryArray)` Sets the array of delta entries for this index table segment that describe the layout of each element stored within an edit unit.
    `void` | `setEditUnitByteCount(int editUnitByteCount)` Sets the byte count of each and every edit unit in the indexed essence container, which is greater than zero when this is a fixed size for all edit units.
    `void` | `setExtStartOffset(Long extStartOffset)` Sets the external start offset property of this index table segment that the byte offset to the first essence data in a CBE (Constant Bytes per Element) essence stream.
    `void` | `setIndexDuration(long indexDuration)` Sets the time duration of this table segment measured in number of edit units of the referenced package.
    `void` | `setIndexEditRate(Rational indexEditRate)` Sets the edit rate of the master track in the indexed essence container, measured in hertz.
    `void` | `setIndexEntryArray(IndexEntry[] indexEntryArray)` Sets the array of index entries for this index table segment that describes the stream offset of each edit unit.
    `void` | `setIndexSID(int indexSID)` Sets the stream identifier for this index table.
    `void` | `setIndexStartPosition(long indexStartPosition)` Sets the first editable unit indexed by this index table segment measured in file package edit units.
    `void` | `setPosTableCount(Byte posTableCount)` Sets the number of entries in the position offsets table per edit unit, minus one as only offsets are recorded in the array.
    `void` | `setSliceCount(byte sliceCount)` Sets the number of slices used to group the elements within an edit unit, minus one as only slice offsets are recorded in an array.
    `void` | `setVBEByteCount(Long vbeByteCount)` Sets the VBE byte count value that gives the byte offset to the end of the final essence unit in a VBE (Variable Bytes per Element) essence stream.
    `String` | `toString()`

    - ### Methods inherited from class java.lang.Object

      `getClass, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### IndexTableSegmentImpl

          public IndexTableSegmentImpl()

    - #### IndexTableSegmentImpl

          public IndexTableSegmentImpl(Rational indexEditRate,
                                       @PositionType
                                       long indexStartPosition,
                                       @LengthType
                                       long indexDuration,
                                       @UInt32
                                       int indexSID,
                                       @UInt32
                                       int bodySID)
                                throws NullPointerException,
                                       BadRateException,
                                       IllegalArgumentException

      Throws:
        `NullPointerException`
        `BadRateException`
        `IllegalArgumentException`

  - ### Method Detail

    - #### getIndexEditRate

          @MediaProperty(uuid1=87032838,
                         uuid2=0,
                         uuid3=0,
                         uuid4={6,14,43,52,1,1,1,5},
                         definedName="Index Edit Rate",
                         typeName="Rational",
                         optional=false,
                         uniqueIdentifier=false,
                         pid=16139,
                         symbol="IndexEditRate")
          public Rational getIndexEditRate()

      Description copied from interface: `IndexTableSegment`

      Returns the edit rate of the master track in the indexed essence container, measured in hertz. If the container has only one track, this is the edit rate of that track. If the essence container interleaves video and audio, it is standard practice to use the picture track to provide the index edit rate.

      Specified by:
        `getIndexEditRate` in interface `IndexTableSegment`
      Returns:
        Edit rate of the master track in the essence container, measured in hertz.

    - #### setIndexEditRate

          @MediaPropertySetter(value="Index Edit Rate")
          public void setIndexEditRate(Rational indexEditRate)
                                                                              throws NullPointerException,
                                                                                     BadRateException

      Description copied from interface: `IndexTableSegment`

      Sets the edit rate of the master track in the indexed essence container, measured in hertz. If the container has only one track, this is the edit rate of that track. If the essence container interleaves video and audio, it is standard practice to use the picture track to provide the index edit rate.

      Specified by:
        `setIndexEditRate` in interface `IndexTableSegment`
      Parameters:
        `indexEditRate` - Edit rate of the master track in the essence container, measured in hertz.
      Throws:
        `NullPointerException` - Cannot set the index edit rate with a `null` value.
        `BadRateException` - The given rate is not acceptable because it is negative or has a zero denominator.

    - #### getIndexStartPosition

          @MediaProperty(uuid1=117571843,
                         uuid2=266,
                         uuid3=0,
                         uuid4={6,14,43,52,1,1,1,5},
                         definedName="Index Start Position",
                         typeName="PositionType",
                         optional=false,
                         uniqueIdentifier=false,
                         pid=16140,
                         symbol="IndexStartPosition")
           @PositionType
          public long getIndexStartPosition()

      Description copied from interface: `IndexTableSegment`

      Returns the first editable unit indexed by this index table segment measured in file package edit units.

      Specified by:
        `getIndexStartPosition` in interface `IndexTableSegment`
      Returns:
        First editable unit indexed by this index table segment,

    - #### setIndexStartPosition

          @MediaPropertySetter(value="Index Start Position")
          public void setIndexStartPosition(@PositionType
                                                                                               long indexStartPosition)

      Description copied from interface: `IndexTableSegment`

      Sets the first editable unit indexed by this index table segment measured in file package edit units.

      Specified by:
        `setIndexStartPosition` in interface `IndexTableSegment`
      Parameters:
        `indexStartPosition` - First editable unit indexed by this index table segment.

    - #### getIndexDuration

          @MediaProperty(uuid1=117572097,
                         uuid2=258,
                         uuid3=0,
                         uuid4={6,14,43,52,1,1,1,5},
                         definedName="Index Duration",
                         typeName="LengthType",
                         optional=false,
                         uniqueIdentifier=false,
                         pid=16141,
                         symbol="IndexDuration")
           @LengthType
          public long getIndexDuration()

      Description copied from interface: `IndexTableSegment`

      Returns the time duration of this table segment measured in number of edit units of the referenced package.

      Specified by:
        `getIndexDuration` in interface `IndexTableSegment`
      Returns:
        Time duration of this table segment measured in number of edit units.

    - #### setIndexDuration

          @MediaPropertySetter(value="Index Duration")
          public void setIndexDuration(@LengthType
                                                                                    long indexDuration)

      Description copied from interface: `IndexTableSegment`

      Sets the time duration of this table segment measured in number of edit units of the referenced package.

      Specified by:
        `setIndexDuration` in interface `IndexTableSegment`
      Parameters:
        `indexDuration` - Time duration of this table segment measured in number of edit units.

    - #### getEditUnitByteCount

          @MediaProperty(uuid1=67502593,
                         uuid2=0,
                         uuid3=0,
                         uuid4={6,14,43,52,1,1,1,4},
                         definedName="Edit Unit Byte Count",
                         typeName="UInt32",
                         optional=false,
                         uniqueIdentifier=false,
                         pid=16133,
                         symbol="EditUnitByteCount")
           @UInt32
          public int getEditUnitByteCount()

      Description copied from interface: `IndexTableSegment`

      Returns the byte count of each and every edit unit in the indexed essence container, which is greater than zero when this is a fixed size for all edit units. The default value of 0 defines that the byte count for each edit unit may be variables and shall be looked up in the index entry array.

      Specified by:
        `getEditUnitByteCount` in interface `IndexTableSegment`
      Returns:
        Byte count of each and every edit unit in the essence container.
      See Also:
        `IndexTableSegment.EDITUNITBYTECOUNT_DEFAULT`

    - #### setEditUnitByteCount

          @MediaPropertySetter(value="Edit Unit Byte Count")
          public void setEditUnitByteCount(@UInt32
                                                                                              int editUnitByteCount)
                                                                                       throws IllegalArgumentException

      Description copied from interface: `IndexTableSegment`

      Sets the byte count of each and every edit unit in the indexed essence container, which is greater than zero when this is a fixed size for all edit units. The default value of 0 defines that the byte count for each edit unit may be variables and shall be looked up in the index entry array.

      Specified by:
        `setEditUnitByteCount` in interface `IndexTableSegment`
      Parameters:
        `editUnitByteCount` - Byte count of each and every edit unit in the essence container.
      Throws:
        `IllegalArgumentException` - The edit unit byte count cannot be a negative value.
      See Also:
        `IndexTableSegment.EDITUNITBYTECOUNT_DEFAULT`

    - #### getIndexSID

          @MediaProperty(uuid1=16974853,
                         uuid2=0,
                         uuid3=0,
                         uuid4={6,14,43,52,1,1,1,4},
                         definedName="IndexSID",
                         aliases={"Index Stream ID","IndexStreamID"},
                         typeName="UInt32",
                         optional=false,
                         uniqueIdentifier=false,
                         pid=16134,
                         symbol="IndexSID")
           @UInt32
          public int getIndexSID()

      Description copied from interface: `IndexTableSegment`

      Returns the stream identifier for this index table. A partition can only hold one index table. All index table segments within a partition and making up the same index table must have the same identifier. The identifier is unique within the scope of an MXF file.

      Specified by:
        `getIndexSID` in interface `IndexTableSegment`
      Returns:
        Stream identifier for this index table.

    - #### setIndexSID

          @MediaPropertySetter(value="IndexSID")
          public void setIndexSID(@UInt32
                                                                         int indexSID)
                                                                  throws IllegalArgumentException

      Description copied from interface: `IndexTableSegment`

      Sets the stream identifier for this index table. A partition can only hold one index table. All index table segments within a partition and making up the same index table must have the same identifier. The identifier is unique within the scope of an MXF file.

      Specified by:
        `setIndexSID` in interface `IndexTableSegment`
      Parameters:
        `indexSID` - Stream identifier for this index table.
      Throws:
        `IllegalArgumentException` - A stream identifier cannot be a negative value.

    - #### getBodySID

          @MediaProperty(uuid1=16974852,
                         uuid2=0,
                         uuid3=0,
                         uuid4={6,14,43,52,1,1,1,4},
                         definedName="BodySID",
                         aliases={"Essence Stream ID","EssenceStreamID"},
                         typeName="UInt32",
                         optional=false,
                         uniqueIdentifier=false,
                         pid=16135,
                         symbol="BodySID")
          public int getBodySID()

      Description copied from interface: `IndexTableSegment`

      Returns the stream identifier of the indexed essence container. The indexed container may be in the same partition as the index or a different one, but the identifier is always unique within the scope of an MXF file.

      Specified by:
        `getBodySID` in interface `IndexTableSegment`
      Returns:
        Stream identifier of the indexed essence container.

    - #### setBodySID

          @MediaPropertySetter(value="BodySID")
          public void setBodySID(@UInt32
                                                                       int bodySID)
                                                                throws IllegalArgumentException

      Description copied from interface: `IndexTableSegment`

      Sets the stream identifier of the indexed essence container. The indexed container may be in the same partition as the index or a different one, but the identifier is always unique within the scope of an MXF file.

      Specified by:
        `setBodySID` in interface `IndexTableSegment`
      Parameters:
        `bodySID` - Stream identifier of the indexed essence container.
      Throws:
        `IllegalArgumentException` - Cannot set the stream identifier to a negative value.

    - #### getSliceCount

          @MediaProperty(uuid1=67372033,
                         uuid2=256,
                         uuid3=0,
                         uuid4={6,14,43,52,1,1,1,4},
                         definedName="Slice Count",
                         typeName="UInt8",
                         optional=false,
                         uniqueIdentifier=false,
                         pid=16136,
                         symbol="SliceCount")
           @UInt8
          public byte getSliceCount()

      Description copied from interface: `IndexTableSegment`

      Returns the number of slices used to group the elements within an edit unit, minus one as only slice offsets are recorded in an array. A new slice is required after any variable bit rate element in an interleaved stream of essence and the offset to the essence is recorded in the edit unit's index entry.

      The default value for this property is 0.

      Note that the slice count is required to resolve bytes to slice offsets for an index entry.

      Specified by:
        `getSliceCount` in interface `IndexTableSegment`
      Returns:
        Number of slices used to group the elements within an edit unit, minus one.
      See Also:
        `IndexTableSegment.SLICECOUNT_DEFAULT`, `IndexEntry.getSliceOffset()`, `IndexEntry.resolveBytes(IndexTableSegment)`

    - #### setSliceCount

          @MediaPropertySetter(value="Slice Count")
          public void setSliceCount(@UInt8
                                                                              byte sliceCount)
                                                                       throws IllegalArgumentException

      Description copied from interface: `IndexTableSegment`

      Sets the number of slices used to group the elements within an edit unit, minus one as only slice offsets are recorded in an array. A new slice is required after any variable bit rate element in an interleaved stream of essence and the offset to the essence is recorded in the edit unit's index entry.

      The default value for this property is 0.

      Note that the slice count is required to resolve bytes to slice offsets for an index entry.

      Specified by:
        `setSliceCount` in interface `IndexTableSegment`
      Parameters:
        `sliceCount` - Number of slices used to group the elements within an edit unit, minus one.
      Throws:
        `IllegalArgumentException` - Cannot set the slice count to a negative value.
      See Also:
        `IndexTableSegment.SLICECOUNT_DEFAULT`, `IndexEntry.getSliceOffset()`, `IndexEntry.resolveBytes(IndexTableSegment)`

    - #### getPosTableCount

          @MediaProperty(uuid1=67372033,
                         uuid2=1792,
                         uuid3=0,
                         uuid4={6,14,43,52,1,1,1,5},
                         definedName="PosTableCount",
                         typeName="UInt8",
                         optional=true,
                         uniqueIdentifier=false,
                         pid=16142,
                         symbol="PosTableCount")
           @UInt8
          public byte getPosTableCount()
                                                                                                                                                                                                                                                                                                                                                                                        throws PropertyNotPresentException

      Description copied from interface: `IndexTableSegment`

      Returns the number of entries in the position offsets table per edit unit, minus one as only offsets are recorded in the array. Position table offsets record the temporal fractional offset from the edit unit of the indexes master track, normally the picture track, and the start of other interleaved elements, such as sound tracks. This is an optional property that is omitted when all elements are temporally aligned or streams are not interleaved.

      Note that the slice count is required to resolve bytes to slice offsets for an index entry.

      Specified by:
        `getPosTableCount` in interface `IndexTableSegment`
      Returns:
        Number of slices used to group the elements within an edit unit, minus one.
      Throws:
        `PropertyNotPresentException` - The optional position table count property is not present for this index table segment.
      See Also:
        `IndexEntry.getPosTable()`, `IndexEntry.resolveBytes(IndexTableSegment)`

    - #### setPosTableCount

          @MediaPropertySetter(value="PosTableCount")
          public void setPosTableCount(@UInt8
                                                                                   Byte posTableCount)
                                                                            throws IllegalArgumentException

      Description copied from interface: `IndexTableSegment`

      Sets the number of entries in the position offsets table per edit unit, minus one as only offsets are recorded in the array. Position table offsets record the temporal fractional offset from the edit unit of the indexes master track, normally the picture track, and the start of other interleaved elements, such as sound tracks. This is an optional property that is omitted when all elements are temporally aligned or streams are not interleaved.

      Note that the slice count is required to resolve bytes to slice offsets for an index entry.

      Specified by:
        `setPosTableCount` in interface `IndexTableSegment`
      Parameters:
        `posTableCount` - Number of slices used to group the elements within an edit unit, minus one.
      Throws:
        `IllegalArgumentException` - Cannot set the position table count to a negative value.
      See Also:
        `IndexEntry.getPosTable()`, `IndexEntry.resolveBytes(IndexTableSegment)`

    - #### getDeltaEntryArray

          @MediaProperty(uuid1=67372033,
                         uuid2=1536,
                         uuid3=0,
                         uuid4={6,14,43,52,1,1,1,5},
                         definedName="Delta Entry Array",
                         typeName="DeltaEntryArray",
                         optional=true,
                         uniqueIdentifier=false,
                         pid=16137,
                         symbol="DeltaEntryArray")
          public DeltaEntry[] getDeltaEntryArray()
                                                                                                                                                                                                                                                                                                                                                                                                          throws PropertyNotPresentException

      Description copied from interface: `IndexTableSegment`

      Returns the array of delta entries for this index table segment that describe the layout of each element stored within an edit unit. This is an optional property and, when omitted, indicates only one element per edit unit.

      Specified by:
        `getDeltaEntryArray` in interface `IndexTableSegment`
      Returns:
        Array of delta entries for this index table segment.
      Throws:
        `PropertyNotPresentException` - The optional delta entry array is not present for this index table segment.
      See Also:
        `IndexTableSegment.getSliceCount()`, `TypeDefinitions.DeltaEntry`, `TypeDefinitions.DeltaEntryArray`

    - #### setDeltaEntryArray

          @MediaPropertySetter(value="Delta Entry Array")
          public void setDeltaEntryArray(DeltaEntry[] deltaEntryArray)
                                                                                  throws NullPointerException

      Description copied from interface: `IndexTableSegment`

      Sets the array of delta entries for this index table segment that describe the layout of each element stored within an edit unit. Set this optional property to `null` to omit it, indicating that only one element exists per edit unit.

      Specified by:
        `setDeltaEntryArray` in interface `IndexTableSegment`
      Parameters:
        `deltaEntryArray` - Array of delta entries for this index table segment.
      Throws:
        `NullPointerException` - One or more of the given delta elements is `null`.
      See Also:
        `IndexTableSegment.setDeltaEntries(int[])`, `IndexTableSegment.setSliceCount(byte)`, `MXFFactory.makeDeltaEntry(byte, byte, int)`, `MXFFactory.makeDeltaEntry(int)`

    - #### setDeltaEntries

          public void setDeltaEntries(int[] elementDeltas)
                               throws NullPointerException,
                                      IllegalArgumentException

      Description copied from interface: `IndexTableSegment`

      Sets the array of delta entries for this index table segment using element delta offsets only. The delta entries describe the layout of each element stored within an edit unit. Default values are set for the position table index and slice components of each entry.

      Specified by:
        `setDeltaEntries` in interface `IndexTableSegment`
      Parameters:
        `elementDeltas` - List of element delta offsets for the elements stored within each frame.
      Throws:
        `NullPointerException` - Cannot set the element deltas using a `null` array.
        `IllegalArgumentException` - Offsets cannot be negative values.
      See Also:
        `IndexTableSegment.setDeltaEntryArray(DeltaEntry[])`

    - #### getIndexEntryArray

          @MediaProperty(uuid1=67372034,
                         uuid2=1280,
                         uuid3=0,
                         uuid4={6,14,43,52,1,1,1,5},
                         definedName="Index Entry Array",
                         typeName="IndexEntryArray",
                         optional=true,
                         uniqueIdentifier=false,
                         pid=16138,
                         symbol="IndexEntryArray")
          public IndexEntry[] getIndexEntryArray()
                                                                                                                                                                                                                                                                                                                                                                                                          throws PropertyNotPresentException

      Description copied from interface: `IndexTableSegment`

      Returns the array of index entries for this index table segment that describes the stream offset of each edit unit. The index entry array is required when variable bit rate coding is in use. This is an optional property that is omitted when each edit unit can be found using a multiple of the edit unit byte count.

      Specified by:
        `getIndexEntryArray` in interface `IndexTableSegment`
      Returns:
        Array of index entries for this index table segment.
      Throws:
        `PropertyNotPresentException` - The optional index entry array property is not present for this index table segment.
      See Also:
        `IndexTableSegment.getEditUnitByteCount()`, `IndexTableSegment.EDITUNITBYTECOUNT_DEFAULT`, `TypeDefinitions.IndexEntry`, `TypeDefinitions.IndexEntryArray`

    - #### setIndexEntryArray

          @MediaPropertySetter(value="Index Entry Array")
          public void setIndexEntryArray(IndexEntry[] indexEntryArray)
                                                                                  throws NullPointerException

      Description copied from interface: `IndexTableSegment`

      Sets the array of index entries for this index table segment that describes the stream offset of each edit unit. The index entry array is required when variable bit rate coding is in use. Set this optional property to `null` to omit it, which should be the case when each edit unit can be found using a multiple of the edit unit byte count.

      Specified by:
        `setIndexEntryArray` in interface `IndexTableSegment`
      Parameters:
        `indexEntryArray` - Array of index entries for this index table segment.
      Throws:
        `NullPointerException` - One or more of the given index entries in the given array is `null`.
      See Also:
        `IndexTableSegment.setEditUnitByteCount(int)`, `IndexTableSegment.EDITUNITBYTECOUNT_DEFAULT`

    - #### getExtStartOffset

          @MediaProperty(uuid1=67502596,
                         uuid2=0,
                         uuid3=0,
                         uuid4={6,14,43,52,1,1,1,10},
                         definedName="ExtStartOffset",
                         typeName="UInt64",
                         optional=true,
                         uniqueIdentifier=false,
                         pid=16143,
                         symbol="ExtStartOffset")
           @UInt64
          public long getExtStartOffset()
                                                                                                                                                                                                                                                                                                                                                                                           throws PropertyNotPresentException

      Description copied from interface: `IndexTableSegment`

      Get the external start offset property of this index table segment that the byte offset to the first essence data in a CBE (Constant Bytes per Element) essence stream. This is an optional property.

      Specified by:
        `getExtStartOffset` in interface `IndexTableSegment`
      Returns:
        External start offset of this index table segment.
      Throws:
        `PropertyNotPresentException`
      See Also:
        `IndexTableSegment.EXTSTARTOFFSET_DEFAULT`

    - #### setExtStartOffset

          @MediaPropertySetter(value="ExtStartOffset")
          public void setExtStartOffset(@UInt64
                                                                                     Long extStartOffset)
                                                                              throws IllegalArgumentException

      Description copied from interface: `IndexTableSegment`

      Sets the external start offset property of this index table segment that the byte offset to the first essence data in a CBE (Constant Bytes per Element) essence stream. Set this property to `null` to omit it.

      The default value for this property is 0L.

      Specified by:
        `setExtStartOffset` in interface `IndexTableSegment`
      Parameters:
        `extStartOffset` - External start offset of this index table segment.
      Throws:
        `IllegalArgumentException` - The external start offset property cannot be negative.
      See Also:
        `IndexTableSegment.EXTSTARTOFFSET_DEFAULT`

    - #### getVBEByteCount

          @MediaProperty(uuid1=67502597,
                         uuid2=0,
                         uuid3=0,
                         uuid4={6,14,43,52,1,1,1,10},
                         definedName="VBEByteCount",
                         typeName="UInt64",
                         optional=true,
                         uniqueIdentifier=false,
                         pid=16144,
                         symbol="VBEByteCount")
           @UInt64
          public long getVBEByteCount()
                                                                                                                                                                                                                                                                                                                                                                                     throws PropertyNotPresentException

      Description copied from interface: `IndexTableSegment`

      Get the VBE byte count value that gives the byte offset to the end of the final essence unit in a VBE (Variable Bytes per Element) essence stream. This value can be used to calculate the size of the final essence unit. This is an optional property.

      The default value for this property is 0L.

      Specified by:
        `getVBEByteCount` in interface `IndexTableSegment`
      Returns:
        VBE byte count for this index table segment.
      Throws:
        `PropertyNotPresentException` - The optional VBE byte count property is not present.
      See Also:
        `IndexTableSegment.VBEBYTECOUNT_DEFAULT`

    - #### setVBEByteCount

          @MediaPropertySetter(value="VBEByteCount")
          public void setVBEByteCount(@UInt64
                                                                                 Long vbeByteCount)
                                                                          throws IllegalArgumentException

      Description copied from interface: `IndexTableSegment`

      Sets the VBE byte count value that gives the byte offset to the end of the final essence unit in a VBE (Variable Bytes per Element) essence stream. This value can be used to calculate the size of the final essence unit. Set this optional property to `null` to omit it.

      The default value for this property is 0L.

      Specified by:
        `setVBEByteCount` in interface `IndexTableSegment`
      Parameters:
        `vbeByteCount` - VBE byte count for this index table segment.
      Throws:
        `IllegalArgumentException` - The VBE byte count property cannot be negative.
      See Also:
        `IndexTableSegment.VBEBYTECOUNT_DEFAULT`

    - #### createFromBuffer

          public static final IndexTableSegment createFromBuffer(ByteBuffer buffer)
                                                          throws NullPointerException,
                                                                 BufferUnderflowException

      Throws:
        `NullPointerException`
        `BufferUnderflowException`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### equals

          public boolean equals(Object o)

      Overrides:
        `equals` in class `Object`

    - #### getUnitType

          public UnitType getUnitType()

      Specified by:
        `getUnitType` in interface `MXFUnit`

    - #### clone

          public IndexTableSegmentImpl clone()

      Description copied from interface: `IndexTableSegment`

      Creates a cloned copy of this index table segment.

      Specified by:
        `clone` in interface `IndexTableSegment`
      Overrides:
        `clone` in class `Object`
      Returns:
        Cloned copy of this index table segment.

(c)2007-2016 Richard Cartwright, all rights reserved. Licensed under Apache 2 license and subject to the AMWA IPR policy.