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

tv.amwa.maj.io.mxf.impl

## Class MXFFileImpl

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

- All Implemented Interfaces:
    Cloneable, MXFFile

      public class MXFFileImpl
      extends Object
      implements MXFFile, Cloneable

  Description of an MXF file.

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `MXFFileImpl()`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `BodyPartition` | `addBodyPartition(boolean closed, boolean complete, long initialDataSize, int bodySID, int indexSID, UL... containerFormats)`
    `FooterPartition` | `addFooterPartition(boolean complete, long initialSize, int indexSID, UL... containerFormats)`
    `HeaderPartition` | `addHeaderPartition(boolean closed, boolean complete, long initialDataSize, int bodySID, int indexSID, UL... containerFormats)`
    `long` | `align(boolean forceBER4, int kagSize)`
    `long` | `align(boolean forceBER4, int kagSize, int minSize)`
    `long` | `align(int kagSize)`
    `long` | `align(int kagSize, int minSize)`
    `boolean` | `atEOF()` Determine if the internal file pointer at the end of the file?
    `boolean` | `buildPartitionsBackwards(PartitionPack headerPartitionPack)`
    `boolean` | `buildPartitionsTable()` Build a partition table from this MXF file containing all the byte offsets of all the partitions in this MXF file.
    `boolean` | `buildRIP()`
    `void` | `clearRIP()`
    `MXFFile` | `clone()` Returns a cloned copy of the MXF file representation.
    `boolean` | `close()` Close this MXF file, preventing further access and releasing any associated resources.
    `int` | `countPartitions()` Count the number of partitions in this file.
    `int` | `fillerSize(boolean forceeBER4, long fillPosition, int kagSize)`
    `int` | `fillerSize(boolean forceeBER4, long fillPosition, int kagSize, int minSize)`
    `int` | `fillerSize(long fillPosition, int kagSize)`
    `int` | `fillerSize(long fillPosition, int kagSize, int minSize)`
    `void` | `finalize()`
    `byte[]` | `getDigestValue()`
    `long` | `getFileSize()`
    `FooterPartition` | `getFooterPartition()` Get access to the footer partition of this file.
    `HeaderPartition` | `getHeaderPartition()` Get access to the header partition of this file.
    `String` | `getName()`
    `Partition` | `getNextPartition(Partition current)`
    `Partition` | `getPartitionAt(int index)` Returns the partition at the given index in the partition table.
    `RandomIndexPack` | `getRandomIndexPack()` Returns the random index pack from the end of the file, or `null` if the file does not have a random index pack.
    `boolean` | `getRIP(long maxScan)`
    `int` | `getRunInSize()` Returns the length of any run in found in the file.
    `boolean` | `hasRunIn()` Determines whether this file has an optional run-in.
    `boolean` | `isBlockAligned()`
    `boolean` | `isOpen()` Determines if this MXF file is open and therefore and ready to be read and written to.
    `boolean` | `lock()`
    `boolean` | `lockForward()`
    `static void` | `main(String[] args)` Temporary application to test the reading of MXF files with MAJ.
    `boolean` | `open(String fileName)`
    `boolean` | `open(String fileName, boolean readOnly)` Open the MXF file with the given name for read-only or read-write as required.
    `boolean` | `openMemory()`
    `boolean` | `openMemory(ByteBuffer buffer, long offset)`
    `boolean` | `openNew(String fileName)`
    `int` | `read(byte[] buffer)`
    `ByteBuffer` | `read(int size)`
    `long` | `readBER()`
    `PartitionImpl` | `readFooterPartition()`
    `PartitionImpl` | `readFooterPartition(long maxScan)`
    `UL` | `readKey()`
    `KLVObject` | `readKLV()`
    `PartitionImpl` | `readMasterPartition()`
    `PartitionImpl` | `readMasterPartition(long maxScan)`
    `MetadataObject` | `readObject()`
    `MetadataObject` | `readObject(Primer primer)`
    `Partition` | `readPartition()`
    `static Preface` | `readPrefaceFromMXF(String fileName)` Reads an MXF file specified by filename and returns the preface object as stored in the header of the file.
    `boolean` | `readRIP()`
    `boolean` | `readRunIn()` Read the internal pointer passed any run-in to the beginning of the header partition.
    `boolean` | `reWritePartition(PartitionImpl partition)`
    `boolean` | `reWritePartition(PartitionImpl partition, Primer primer)`
    `boolean` | `reWritePartitionWithIndex(PartitionImpl partition, ByteBuffer indexData)`
    `boolean` | `reWritePartitionWithIndex(PartitionImpl partition, ByteBuffer indexData, Primer primer)`
    `boolean` | `scanRIP()`
    `boolean` | `scanRIP(long maxScan)`
    `int` | `seek(long position)`
    `int` | `seekEnd()`
    `void` | `setBlockAlign(int size)`
    `void` | `setBlockAlign(int size, int essenceOffset, int indexOffset)`
    `void` | `setFileKAG(int kag)`
    `void` | `setFileMXFByteLevelVersion(short major, short minor)`
    `void` | `setFileOperationalPattern(UL operationalPattern)`
    `void` | `setMemoryBuffer(ByteBuffer buffer, int offset)`
    `void` | `startDigest(String digestType)`
    `long` | `tell()`
    `void` | `unlock()`
    `void` | `updatePackSizes()`
    `int` | `write(byte[] buffer)`
    `int` | `write(ByteBuffer data)`
    `int` | `writeBER(long length)`
    `int` | `writeBER(long length, int size)`
    `void` | `writePartition(PartitionImpl partition)`
    `void` | `writePartition(PartitionImpl partition, boolean includeMetadata)`
    `void` | `writePartition(PartitionImpl partition, boolean includeMetadata, Primer primer, int padding, int minPartitionSize)`
    `void` | `writePartition(PartitionImpl partition, int padding, int minPartitionSize)`
    `void` | `writePartition(PartitionImpl partition, Primer primer)`
    `void` | `writePartition(PartitionImpl partition, Primer primer, int padding, int minPartitionSize)`
    `void` | `writePartitionPack(PartitionImpl partition)`
    `void` | `writePartitionPack(PartitionImpl partition, Primer primer)`
    `void` | `writePartitionWithIndex(PartitionImpl partition, ByteBuffer indexData)`
    `void` | `writePartitionWithIndex(PartitionImpl partition, ByteBuffer indexData, boolean includeMetadata)`
    `void` | `writePartitionWithIndex(PartitionImpl partition, ByteBuffer indexData, boolean includeMetadata, Primer primer, int padding, int minPartitionSize)`
    `void` | `writePartitionWithIndex(PartitionImpl partition, ByteBuffer indexData, int padding, int minPartitionSize)`
    `void` | `writePartitionWithIndex(PartitionImpl partition, ByteBuffer indexData, Primer primer)`
    `void` | `writePartitionWithIndex(PartitionImpl partition, ByteBuffer indexData, Primer primer, int padding, int minPartitionSize)`
    `boolean` | `writeRIP()`

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

      `equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### MXFFileImpl

          public MXFFileImpl()

  - ### Method Detail

    - #### getRunInSize

          @UInt32
          public int getRunInSize()

      Description copied from interface: `MXFFile`

      Returns the length of any run in found in the file. A run-in is optional in an MXF file.

      Specified by:
        `getRunInSize` in interface `MXFFile`
      Returns:
        Length of any run in found in the file.
      See Also:
        `MXFFile.hasRunIn()`, `MXFFile.readRunIn()`

    - #### hasRunIn

          public boolean hasRunIn()

      Description copied from interface: `MXFFile`

      Determines whether this file has an optional run-in.

      Specified by:
        `hasRunIn` in interface `MXFFile`
      Returns:
        Does this file have an optional run-in?
      See Also:
        `MXFFile.getRunInSize()`, `MXFFile.readRunIn()`

    - #### open

          public boolean open(String fileName,
                              boolean readOnly)
                       throws IOException

      Description copied from interface: `MXFFile`

      Open the MXF file with the given name for read-only or read-write as required.

      Specified by:
        `open` in interface `MXFFile`
      Parameters:
        `fileName` - Name of the file to open.
        `readOnly` - Open the file read-only? Set to `true` for read-only and `false` for read-write.
      Returns:
        Was the file successfully opened and the beginning of the header partition found?
      Throws:
        `IOException` - A problem occurred when trying to open the specified file.
      See Also:
        `MXFFactory.readPartitions(String)`

    - #### open

          public boolean open(String fileName)
                       throws IOException

      Throws:
        `IOException`

    - #### openNew

          public boolean openNew(String fileName)
                          throws IOException

      Throws:
        `IOException`

    - #### openMemory

          public boolean openMemory(ByteBuffer buffer,
                                    @MXFPosition
                                    long offset)

    - #### openMemory

          public boolean openMemory()

    - #### close

          public boolean close()

      Description copied from interface: `MXFFile`

      Close this MXF file, preventing further access and releasing any associated resources. Applications should close MXF files as soon as they are finished reading or writing them.

      Specified by:
        `close` in interface `MXFFile`
      Returns:
        Was the file successfully closed?

    - #### finalize

          public void finalize()
                        throws Throwable

      Overrides:
        `finalize` in class `Object`
      Throws:
        `Throwable`

    - #### readRunIn

          public boolean readRunIn()
                            throws IOException

      Description copied from interface: `MXFFile`

      Read the internal pointer passed any run-in to the beginning of the header partition.

      Specified by:
        `readRunIn` in interface `MXFFile`
      Returns:
        Is the position of the MXF file set at the beginning of the header partition, just beyond the run-in.
      Throws:
        `IOException` - Problem reading the underlying MXF file.
      See Also:
        `MXFFile.getRunInSize()`, `MXFFile.hasRunIn()`

    - #### readRIP

          public boolean readRIP()
                          throws IOException

      Throws:
        `IOException`

    - #### getRandomIndexPack

          public RandomIndexPack getRandomIndexPack()

      Description copied from interface: `MXFFile`

      Returns the random index pack from the end of the file, or `null` if the file does not have a random index pack.

      Specified by:
        `getRandomIndexPack` in interface `MXFFile`
      Returns:
        Random index pack from the end of the file if it exists, otherwise `null`.

    - #### clearRIP

          public void clearRIP()

    - #### buildPartitionsTable

          public boolean buildPartitionsTable()
                                       throws IOException,
                                              EndOfDataException

      Description copied from interface: `MXFFile`

      Build a partition table from this MXF file containing all the byte offsets of all the partitions in this MXF file. It is necessary to call this method before calling any of the other methods that reference partitions.

      Specified by:
        `buildPartitionsTable` in interface `MXFFile`
      Returns:
        Successful creation of the partition table.
      Throws:
        `IOException` - Problem occurred when trying to read the file.
        `EndOfDataException` - Unexpectedly reached the end of the file, for example when reading through a partition table.

    - #### buildPartitionsBackwards

          public boolean buildPartitionsBackwards(PartitionPack headerPartitionPack)
                                           throws EndOfDataException

      Throws:
        `EndOfDataException`

    - #### countPartitions

          public int countPartitions()

      Description copied from interface: `MXFFile`

      Count the number of partitions in this file. A value of zero may indicate that the partitions table still needs to be built with `MXFFile.buildPartitionsTable()`.

      Specified by:
        `countPartitions` in interface `MXFFile`
      Returns:
        Number of partitions in the file.
      See Also:
        `MXFFile.getPartitionAt(int)`, `MXFFile.buildPartitionsTable()`

    - #### addHeaderPartition

          public HeaderPartition addHeaderPartition(boolean closed,
                                                    boolean complete,
                                                    long initialDataSize,
                                                    int bodySID,
                                                    int indexSID,
                                                    UL... containerFormats)

      Specified by:
        `addHeaderPartition` in interface `MXFFile`

    - #### setFileOperationalPattern

          public void setFileOperationalPattern(UL operationalPattern)
                                         throws NullPointerException

      Specified by:
        `setFileOperationalPattern` in interface `MXFFile`
      Throws:
        `NullPointerException`

    - #### setFileKAG

          public void setFileKAG(@UInt32
                                 int kag)
                          throws IllegalArgumentException

      Specified by:
        `setFileKAG` in interface `MXFFile`
      Throws:
        `IllegalArgumentException`

    - #### setFileMXFByteLevelVersion

          public void setFileMXFByteLevelVersion(@UInt16
                                                 short major,
                                                 @UInt16
                                                 short minor)
                                          throws IllegalArgumentException

      Specified by:
        `setFileMXFByteLevelVersion` in interface `MXFFile`
      Throws:
        `IllegalArgumentException`

    - #### addFooterPartition

          public FooterPartition addFooterPartition(boolean complete,
                                                    long initialSize,
                                                    int indexSID,
                                                    UL... containerFormats)

      Specified by:
        `addFooterPartition` in interface `MXFFile`

    - #### addBodyPartition

          public BodyPartition addBodyPartition(boolean closed,
                                                boolean complete,
                                                long initialDataSize,
                                                int bodySID,
                                                int indexSID,
                                                UL... containerFormats)

      Specified by:
        `addBodyPartition` in interface `MXFFile`

    - #### getPartitionAt

          public Partition getPartitionAt(int index)
                                   throws IndexOutOfBoundsException

      Description copied from interface: `MXFFile`

      Returns the partition at the given index in the partition table. The partitions are ordered in the sequence they occur in the file, with the partition at index zero being the header partition.

      Specified by:
        `getPartitionAt` in interface `MXFFile`
      Parameters:
        `index` - Index of the partition table to retrieve.
      Returns:
        Partition at the given index in the index table.
      Throws:
        `IndexOutOfBoundsException` - No parition at the given index, or the partition table has not yet been built with `MXFFile.buildPartitionsTable()`.
      See Also:
        `MXFFile.buildPartitionsTable()`

    - #### getNextPartition

          public Partition getNextPartition(Partition current)

    - #### updatePackSizes

          public void updatePackSizes()

      Specified by:
        `updatePackSizes` in interface `MXFFile`

    - #### getHeaderPartition

          public HeaderPartition getHeaderPartition()

      Description copied from interface: `MXFFile`

      Get access to the header partition of this file. Ensure that the partition table has been built first with `MXFFile.buildPartitionsTable()`.

      Specified by:
        `getHeaderPartition` in interface `MXFFile`
      Returns:
        Header partition of the file, or `null` if the file is invalid or the partitions table has not yet been built.
      See Also:
        `MXFFile.getHeaderPartition()`, `MXFFile.buildPartitionsTable()`

    - #### getFooterPartition

          public FooterPartition getFooterPartition()

      Description copied from interface: `MXFFile`

      Get access to the footer partition of this file. Ensure that the partition table has been built first with `MXFFile.buildPartitionsTable()` or a `null` may be returned unexpectedly.

      Specified by:
        `getFooterPartition` in interface `MXFFile`
      Returns:
        Footer partition of the file or `null` if a footer partition is not found.
      See Also:
        `MXFFile.getFooterPartition()`, `MXFFile.buildPartitionsTable()`

    - #### scanRIP

          public boolean scanRIP(@MXFLength
                                 long maxScan)

    - #### scanRIP

          public boolean scanRIP()

    - #### buildRIP

          public boolean buildRIP()

      Specified by:
        `buildRIP` in interface `MXFFile`

    - #### getRIP

          public boolean getRIP(@MXFLength
                                long maxScan)

    - #### readMasterPartition

          public PartitionImpl readMasterPartition(@Int64
                                                   long maxScan)

    - #### readMasterPartition

          public PartitionImpl readMasterPartition()

    - #### readFooterPartition

          public PartitionImpl readFooterPartition(@MXFLength
                                                   long maxScan)

    - #### readFooterPartition

          public PartitionImpl readFooterPartition()

    - #### tell

          @MXFPosition
          public long tell()

    - #### seek

          public int seek(@MXFPosition
                          long position)

    - #### seekEnd

          public int seekEnd()

    - #### atEOF

          public boolean atEOF()

      Description copied from interface: `MXFFile`

      Determine if the internal file pointer at the end of the file?

      Specified by:
        `atEOF` in interface `MXFFile`
      Returns:
        Is the internal file pointer at the end of the file?

    - #### read

          public ByteBuffer read(int size)
                          throws IllegalArgumentException

      Throws:
        `IllegalArgumentException`

    - #### read

          public int read(byte[] buffer)

    - #### readObject

          public MetadataObject readObject()
                                    throws BadParameterException

      Throws:
        `BadParameterException`

    - #### readObject

          public MetadataObject readObject(Primer primer)

    - #### readPartition

          public Partition readPartition()
                                  throws EndOfDataException

      Throws:
        `EndOfDataException`

    - #### readKLV

          public KLVObject readKLV()

    - #### writePartitionPack

          public void writePartitionPack(PartitionImpl partition,
                                         Primer primer)

    - #### writePartitionPack

          public void writePartitionPack(PartitionImpl partition)

    - #### writePartition

          public void writePartition(PartitionImpl partition,
                                     @UInt32
                                     int padding,
                                     @UInt32
                                     int minPartitionSize)

    - #### writePartition

          public void writePartition(PartitionImpl partition)

    - #### writePartitionWithIndex

          public void writePartitionWithIndex(PartitionImpl partition,
                                              ByteBuffer indexData,
                                              @UInt32
                                              int padding,
                                              @UInt32
                                              int minPartitionSize)

    - #### writePartitionWithIndex

          public void writePartitionWithIndex(PartitionImpl partition,
                                              ByteBuffer indexData)

    - #### writePartition

          public void writePartition(PartitionImpl partition,
                                     Primer primer,
                                     @UInt32
                                     int padding,
                                     @UInt32
                                     int minPartitionSize)

    - #### writePartition

          public void writePartition(PartitionImpl partition,
                                     Primer primer)

    - #### writePartitionWithIndex

          public void writePartitionWithIndex(PartitionImpl partition,
                                              ByteBuffer indexData,
                                              Primer primer,
                                              @UInt32
                                              int padding,
                                              @UInt32
                                              int minPartitionSize)

    - #### writePartitionWithIndex

          public void writePartitionWithIndex(PartitionImpl partition,
                                              ByteBuffer indexData,
                                              Primer primer)

    - #### writePartition

          public void writePartition(PartitionImpl partition,
                                     boolean includeMetadata,
                                     Primer primer,
                                     @UInt32
                                     int padding,
                                     @UInt32
                                     int minPartitionSize)

    - #### writePartition

          public void writePartition(PartitionImpl partition,
                                     boolean includeMetadata)

    - #### writePartitionWithIndex

          public void writePartitionWithIndex(PartitionImpl partition,
                                              ByteBuffer indexData,
                                              boolean includeMetadata,
                                              Primer primer,
                                              @UInt32
                                              int padding,
                                              @UInt32
                                              int minPartitionSize)

    - #### writePartitionWithIndex

          public void writePartitionWithIndex(PartitionImpl partition,
                                              ByteBuffer indexData,
                                              boolean includeMetadata)

    - #### reWritePartition

          public boolean reWritePartition(PartitionImpl partition,
                                          Primer primer)

    - #### reWritePartition

          public boolean reWritePartition(PartitionImpl partition)

    - #### reWritePartitionWithIndex

          public boolean reWritePartitionWithIndex(PartitionImpl partition,
                                                   ByteBuffer indexData,
                                                   Primer primer)

    - #### reWritePartitionWithIndex

          public boolean reWritePartitionWithIndex(PartitionImpl partition,
                                                   ByteBuffer indexData)

    - #### writeRIP

          public boolean writeRIP()
                           throws IOException

      Specified by:
        `writeRIP` in interface `MXFFile`
      Throws:
        `IOException`

    - #### fillerSize

          @UInt32
          public int fillerSize(@UInt64
                                        long fillPosition,
                                        @UInt32
                                        int kagSize,
                                        @UInt32
                                        int minSize)

    - #### fillerSize

          @UInt32
          public int fillerSize(@UInt64
                                        long fillPosition,
                                        @UInt32
                                        int kagSize)

    - #### fillerSize

          @UInt32
          public int fillerSize(boolean forceeBER4,
                                        @UInt64
                                        long fillPosition,
                                        @UInt32
                                        int kagSize,
                                        @UInt32
                                        int minSize)

    - #### fillerSize

          @UInt32
          public int fillerSize(boolean forceeBER4,
                                        @UInt64
                                        long fillPosition,
                                        @UInt32
                                        int kagSize)

    - #### align

          @UInt64
          public long align(@UInt32
                                    int kagSize,
                                    @UInt32
                                    int minSize)

    - #### align

          @UInt64
          public long align(@UInt32
                                    int kagSize)

    - #### align

          @UInt64
          public long align(boolean forceBER4,
                                    @UInt32
                                    int kagSize,
                                    @UInt32
                                    int minSize)

    - #### align

          @UInt64
          public long align(boolean forceBER4,
                                    @UInt32
                                    int kagSize)

    - #### readKey

          public UL readKey()

    - #### readBER

          @MXFLength
          public long readBER()

    - #### writeBER

          @UInt32
          public int writeBER(@UInt64
                                      long length,
                                      @UInt32
                                      int size)
                               throws IOException

      Throws:
        `IOException`

    - #### writeBER

          @UInt32
          public int writeBER(@UInt64
                                      long length)
                               throws IOException

      Throws:
        `IOException`

    - #### write

          public int write(byte[] buffer)

    - #### write

          public int write(ByteBuffer data)
                    throws NullPointerException,
                           IOException

      Throws:
        `NullPointerException`
        `IOException`

    - #### setMemoryBuffer

          public void setMemoryBuffer(ByteBuffer buffer,
                                      @UInt32
                                      int offset)

    - #### setBlockAlign

          public void setBlockAlign(@UInt32
                                    int size,
                                    @Int32
                                    int essenceOffset,
                                    @Int32
                                    int indexOffset)

    - #### setBlockAlign

          public void setBlockAlign(@UInt32
                                    int size)

    - #### isBlockAligned

          public boolean isBlockAligned()

    - #### isOpen

          public boolean isOpen()

      Description copied from interface: `MXFFile`

      Determines if this MXF file is open and therefore and ready to be read and written to.

      Specified by:
        `isOpen` in interface `MXFFile`
      Returns:
        Is this MXF file open?
      See Also:
        `MXFFile.close()`

    - #### getName

          public String getName()

    - #### lock

          public boolean lock()

      Specified by:
        `lock` in interface `MXFFile`

    - #### lockForward

          public boolean lockForward()

      Specified by:
        `lockForward` in interface `MXFFile`

    - #### unlock

          public void unlock()

      Specified by:
        `unlock` in interface `MXFFile`

    - #### startDigest

          public void startDigest(String digestType)
                           throws NoSuchAlgorithmException

      Specified by:
        `startDigest` in interface `MXFFile`
      Throws:
        `NoSuchAlgorithmException`

    - #### getDigestValue

          public byte[] getDigestValue()

      Specified by:
        `getDigestValue` in interface `MXFFile`

    - #### getFileSize

          public long getFileSize()
                           throws IOException

      Specified by:
        `getFileSize` in interface `MXFFile`
      Throws:
        `IOException`

    - #### clone

          public MXFFile clone()

      Description copied from interface: `MXFFile`

      Returns a cloned copy of the MXF file representation. Note that the MXF file itself is not copied.

      Specified by:
        `clone` in interface `MXFFile`
      Overrides:
        `clone` in class `Object`
      Returns:
        Cloned copy of the MXF file representation.

    - #### readPrefaceFromMXF

          public static final Preface readPrefaceFromMXF(String fileName)
                                                  throws Exception

      Reads an MXF file specified by filename and returns the preface object as stored in the header of the file.

      Errors from reading the file are currently directed to the system error stream.

      Warning: This code has yet to be fully tested and you use it at your own risk!

      Parameters:
        `fileName` - Name of the MXF file to read.
      Returns:
        Preface from the header of the file.
      Throws:
        `Exception` - Any exception thrown when reading the MXF file.
      See Also:
        `main(String[])`

    - #### main

          public static final void main(String[] args)

      Temporary application to test the reading of MXF files with MAJ. Use with caution! The application reads an MXF file, reports any warnings encountered when reading the file, reports the time taken to initialize and read the file and then dumps the preface as AAF XML (SMPTE registered data XML).

      The first argument is an MXF filename. Following arguments provide the name of classes that should be ignored during parsing. This provides a means to read a file with bad data by listing classes to be skipped.

      Example usage:

           java -classpath maj.jar tv.amwa.maj.io.mxf.MXFFile MyFile.mxf

      Parameters:
        `args` - First argument is the filename of an MXF to read. The following arguments provide names of classes to be ignored.
      See Also:
        `readPrefaceFromMXF(String)`

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