/// <summary>
/// Reads a list of AUIDs and returns a MXFObject containing the AUIDs as children
/// </summary>
/// <param name="groupName">The name of the MXFObject acting as group container</param>
/// <param name="singleItem">The name of the single items</param>
public MXFObject ReadAUIDSet(string groupName, string singleItem)
{
UInt32 nofItems = this.ReadUInt32();
UInt32 objectSize = this.ReadUInt32(); // TODO useless size of objects, always 16 according to specs
MXFObject auidGroup = new MXFNamedObject(groupName, this.Position, objectSize);
if (nofItems < UInt32.MaxValue)
{
for (int n = 0; n < nofItems; n++)
{
MXFAUID auid = new MXFAUID(this, singleItem);
auidGroup.AddChild(auid);
}
}
return(auidGroup);
}
/// <summary>
/// Reads a list of keys
/// </summary>
/// <param name="categoryName"></param>
/// <param name="singleItem"></param>
public MXFObject ReadKeyList(string categoryName, string singleItem)
{
UInt32 nofItems = this.ReadD();
UInt32 objectSize = this.ReadD(); // useless size of objects, always 16 according to specs
MXFObject keylist = new MXFNamedObject(categoryName, this.Position, objectSize);
if (nofItems < UInt32.MaxValue)
{
for (int n = 0; n < nofItems; n++)
{
MXFRefKey key = new MXFRefKey(this, objectSize, singleItem);
keylist.AddChild(key);
}
}
return(keylist);
}
public MXFObject ReadReferenceSet <T>(string referringSetName, string singleItemName) where T : MXFObject
{
UInt32 nofItems = this.ReadUInt32();
UInt32 objectSize = this.ReadUInt32(); // useless size of objects, always 16 according to specs
MXFObject referenceSet = new MXFNamedObject(referringSetName, this.Position, objectSize);
// TODO what if this condition is not met? should we throw an exception?
if (nofItems < UInt32.MaxValue)
{
for (int n = 0; n < nofItems; n++)
{
var reference = new MXFReference <T>(this, singleItemName);
referenceSet.AddChild(reference);
}
}
return(referenceSet);
}
/// <summary>
/// Read partition tag list
/// </summary>
/// <param name="reader"></param>
/// <param name="categoryName"></param>
/// <returns></returns>
protected UInt32 ReadTagList(MXFReader reader, string categoryName)
{
UInt32 nofItems = reader.ReadD();
UInt32 objectSize = reader.ReadD(); // useless size of objects, always 16 according to specs
MXFObject keylist = new MXFNamedObject(categoryName, reader.Position);
if (nofItems > 0 && nofItems < UInt32.MaxValue)
{
m_PrimerKeys = new Dictionary <UInt16, MXFEntryPrimer>();
for (int n = 0; n < nofItems; n++)
{
MXFEntryPrimer entry = new MXFEntryPrimer(reader);
m_PrimerKeys.Add(entry.LocalTag, entry); // Add to our own internal list
keylist.AddChild(entry); // And add the entry as one of our children
}
}
this.AddChild(keylist);
return(nofItems);
}
/// <summary>
/// Partially Parse an MXF file, skip all data
/// </summary>
protected void ParsePartial(BackgroundWorker worker)
{
Stopwatch sw = Stopwatch.StartNew();
MXFKLVFactory klvFactory = new MXFKLVFactory();
MXFPartition currentPartition = null;
int previousPercentage = 0;
Dictionary <UInt16, MXFEntryPrimer> allPrimerKeys = null;
int[] counters = new int[Enum.GetNames(typeof(KeyType)).Length];
PartialSeekMode seekMode = PartialSeekMode.Unknown;
using (m_reader = new MXFReader(this.Filename))
{
this.Filesize = m_reader.Size;
MXFObject partitions = new MXFNamedObject("Partitions", 0);
this.AddChild(partitions);
// Start with trying to find the RIP
bool ripFound = ReadRIP(klvFactory);
if (ripFound)
{
seekMode = PartialSeekMode.UsingRIP;
}
m_reader.Seek(0); // Start at the beginning
// Start by reading the first partition
int partitionNumber = 0; // For easy partition identification
while (!m_reader.EOF && seekMode != PartialSeekMode.Backwards) // Eof and NOT searching backwards
{
MXFKLV klv = klvFactory.CreateObject(m_reader, currentPartition);
// Update overall counters
if (klv.Key.Type == KeyType.None)
{
counters[(int)klv.Key.Type]++;
}
if (klv.Key.Type == KeyType.Partition && seekMode == PartialSeekMode.Backwards)
{
if (this.Partitions.Exists(a => a.Offset == klv.Offset))
{
// A new partition has been found that we already found, quit the main loop
break;
}
}
// Process the new KLV
ProcessKLVObject(klv, partitions, ref currentPartition, ref partitionNumber, ref allPrimerKeys);
// If we found the second partition
long nextSeekPosition = klv.DataOffset + klv.Length;
if (partitionNumber >= 2) // Header fully read, now busy with the second partition
{
switch (seekMode)
{
case PartialSeekMode.UsingRIP: // And we already found the RIP
if (currentPartition.FirstSystemItem != null) // And we found the first system item
{
MXFEntryRIP ripEntry = this.RIP.GetPartition(partitionNumber);
if (ripEntry != null)
{
// Mark the current partition as not-completely read
currentPartition.IsLoaded = false;
// Start at the next partition
nextSeekPosition = (long)ripEntry.PartitionOffset;
}
}
break;
case PartialSeekMode.Backwards: // NO RIP, searching backwards
// Backwards, jump to the PREVIOUS partition
if (currentPartition.FirstSystemItem != null) // And we found the first system item
{
// Jump to the previous partition
if (currentPartition.PreviousPartition != 0)
{
// And we haven't found this partition yet
if (!this.Partitions.Exists(a => a.ThisPartition == currentPartition.PreviousPartition))
{
nextSeekPosition = (long)currentPartition.PreviousPartition; // Jump to previous
}
}
}
break;
case PartialSeekMode.Unknown: // No RIP....
// Hmmm, RIP is not found, check if we have a footer partition somewhere
MXFPartition part = this.Partitions.Where(a => a.FooterPartition != 0).FirstOrDefault();
if (part != null)
{
// If we are already at the footer, don't bother to seek
if (currentPartition.Offset != (long)part.FooterPartition)
{
nextSeekPosition = (long)part.FooterPartition; // Start at the footer
seekMode = PartialSeekMode.Backwards;
}
}
break;
}
}
// Next KLV please
m_reader.Seek(nextSeekPosition);
// Only report progress when the percentage has changed
int currentPercentage = (int)((m_reader.Position * 90) / m_reader.Size);
if (currentPercentage != previousPercentage)
{
worker.ReportProgress(currentPercentage, "Partial Parsing MXF file");
previousPercentage = currentPercentage;
}
}
}
// Progress should now be 90%
// Update all type descriptions
klvFactory.UpdateAllTypeDescriptions(allPrimerKeys);
Debug.WriteLine("Finished parsing file '{0}' in {1} ms", this.Filename, sw.ElapsedMilliseconds);
sw.Restart();
// Create a list with all UID keys
worker.ReportProgress(91, "Creating key list");
Dictionary <string, MXFObject> allKeys = new Dictionary <string, MXFObject>();
CreateKeyList(allKeys, this);
// Resolve the references
worker.ReportProgress(92, "Resolving references");
ResolveReferences(allKeys, this);
Debug.WriteLine("Finished resolving references in {0} ms", sw.ElapsedMilliseconds);
sw.Restart();
this.FlatList = new List <MXFObject>();
worker.ReportProgress(93, "Creating flat list");
this.AddToList(this.FlatList);
Debug.WriteLine("Flatlist created in {0} ms", sw.ElapsedMilliseconds);
sw.Restart();
// Create the logical tree
worker.ReportProgress(94, "Creating logical tree");
CreateLogicalTree();
Debug.WriteLine("Logical tree created in {0} ms", sw.ElapsedMilliseconds);
sw.Restart();
// And Execute FAST tests
this.ExecuteValidationTest(worker, false);
// Finished
worker.ReportProgress(100, "Finished");
}
/// <summary>
/// Fully Parse an MXF file
/// </summary>
protected void ParseFull(BackgroundWorker worker)
{
Stopwatch sw = Stopwatch.StartNew();
MXFKLVFactory klvFactory = new MXFKLVFactory();
MXFPartition currentPartition = null;
int previousPercentage = 0;
Dictionary <UInt16, MXFEntryPrimer> allPrimerKeys = null;
int[] counters = new int[Enum.GetNames(typeof(KeyType)).Length];
using (m_reader = new MXFReader(this.Filename))
{
this.Filesize = m_reader.Size;
MXFObject partitions = new MXFNamedObject("Partitions", 0);
this.AddChild(partitions);
int partitionNumber = 0; // For easy partition identification
while (!m_reader.EOF)
{
MXFKLV klv = klvFactory.CreateObject(m_reader, currentPartition);
// Update overall counters
if (klv.Key.Type == KeyType.None)
{
counters[(int)klv.Key.Type]++;
}
// Process the new KLV
ProcessKLVObject(klv, partitions, ref currentPartition, ref partitionNumber, ref allPrimerKeys);
// Next KLV please
m_reader.Seek(klv.DataOffset + klv.Length);
// Only report progress when the percentage has changed
int currentPercentage = (int)((m_reader.Position * 90) / m_reader.Size);
if (currentPercentage != previousPercentage)
{
worker.ReportProgress(currentPercentage, "Parsing MXF file");
previousPercentage = currentPercentage;
}
}
}
// Progress should now be 90%
// Update all type descriptions
klvFactory.UpdateAllTypeDescriptions(allPrimerKeys);
worker.ReportProgress(91, "Creating key list");
Debug.WriteLine("Finished parsing file '{0}' in {1} ms", this.Filename, sw.ElapsedMilliseconds);
sw.Restart();
// Create a list with all UID keys
Dictionary <string, MXFObject> allKeys = new Dictionary <string, MXFObject>();
CreateKeyList(allKeys, this);
worker.ReportProgress(92, "Creating resolving references");
// Resolve the references
ResolveReferences(allKeys, this);
Debug.WriteLine("Finished resolving references in {0} ms", sw.ElapsedMilliseconds);
sw.Restart();
worker.ReportProgress(93, "Resolving flatlist");
this.FlatList = new List <MXFObject>();
this.AddToList(this.FlatList);
Debug.WriteLine("Flatlist created in {0} ms", sw.ElapsedMilliseconds);
sw.Restart();
worker.ReportProgress(94, "Creating Logical tree");
// Create the logical tree
CreateLogicalTree();
Debug.WriteLine("Logical tree created in {0} ms", sw.ElapsedMilliseconds);
sw.Restart();
// And Execute ALL test
this.ExecuteValidationTest(worker, true);
// Finished
worker.ReportProgress(100, "Finished");
}
/// <summary>
/// Overridden method to process local tags
/// </summary>
/// <param name="localTag"></param>
protected override bool ParseLocalTag(MXFReader reader, MXFLocalTag localTag)
{
switch (localTag.Tag)
{
case 0x3F05: this.EditUnitByteCount = reader.ReadUInt32(); return(true);
case 0x3F06: this.IndexSID = reader.ReadUInt32(); return(true);
case 0x3F07: this.BodySID = reader.ReadUInt32(); return(true);
case 0x3F08: this.SliceCount = reader.ReadByte(); return(true);
case 0x3F0C: this.IndexStartPosition = reader.ReadUInt64(); return(true);
case 0x3F0D: this.IndexDuration = reader.ReadUInt64(); return(true);
case 0x3F0E: this.PosTableCount = reader.ReadByte(); return(true);
case 0x3F0F: this.ExtStartOffset = reader.ReadUInt64(); return(true);
case 0x3F10: this.VBEByteCount = reader.ReadUInt64(); return(true);
case 0x3F11: this.SingleIndexLocation = reader.ReadBool(); return(true);
case 0x3F12: this.SingleEssenceLocation = reader.ReadBool(); return(true);
case 0x3F13: this.ForwardIndexDirection = reader.ReadBool(); return(true);
case 0x3F0B: this.IndexEditRate = reader.ReadRational(); return(true);
case 0x3F0A: // Index entry array
{
UInt32 NbIndexEntries = reader.ReadUInt32();
UInt32 entryLength = reader.ReadUInt32();
if (NbIndexEntries > 0)
{
this.IndexEntries = new List <MXFEntryIndex>();
MXFObject indexCollection = new MXFNamedObject("IndexEntries", reader.Position, MXFObjectType.Index);
for (UInt64 i = 0; i < NbIndexEntries; i++)
{
long next = reader.Position + entryLength;
MXFEntryIndex newEntry = new MXFEntryIndex((ulong)this.IndexStartPosition + i, reader, this.SliceCount, this.PosTableCount, entryLength);
this.IndexEntries.Add(newEntry); // Also add this entry to the local list
// And to the child collection
indexCollection.AddChild(newEntry);
reader.Seek(next);
}
this.AddChild(indexCollection);
}
}
return(true);
case 0x3F09: // Delta entry array
{
UInt32 NbDeltaEntries = reader.ReadUInt32();
UInt32 entryLength = reader.ReadUInt32();
if (NbDeltaEntries > 0)
{
MXFObject deltaCollection = new MXFNamedObject("DeltaEntries", reader.Position, MXFObjectType.Index);
for (int i = 0; i < NbDeltaEntries; i++)
{
long next = reader.Position + entryLength;
deltaCollection.AddChild(new MXFEntryDelta(reader, entryLength));
reader.Seek(next);
}
this.AddChild(deltaCollection);
}
}
return(true);
}
return(base.ParseLocalTag(reader, localTag));
}
/// <summary>
/// Fully Parse an MXF file
/// </summary>
protected void ParseFull(BackgroundWorker worker)
{
Stopwatch sw = Stopwatch.StartNew();
MXFKLVFactory klvFactory = new MXFKLVFactory();
MXFPartition currentPartition = null;
int previousPercentage = 0;
Dictionary <UInt16, MXFEntryPrimer> allPrimerKeys = null;
//int[] counters = new int[Enum.GetNames(typeof(KeyType)).Length];
using (m_reader = new MXFReader(this.Filename))
{
this.Filesize = m_reader.Size;
MXFObject partitions = new MXFNamedObject("Partitions", 0);
this.AddChild(partitions);
int partitionNumber = 0; // For easy partition identification
while (!m_reader.EOF)
{
try
{
MXFKLV klv = klvFactory.CreateObject(m_reader, currentPartition);
//// Update overall counters
//if (klv.Key.Type == KeyType.None)
// counters[(int)klv.Key.Type]++;
// Process the new KLV
ProcessKLVObject(klv, partitions, ref currentPartition, ref partitionNumber, ref allPrimerKeys);
// Next KLV please
m_reader.Seek(klv.DataOffset + klv.Length);
}
catch (Exception e)
{
m_reader.SeekForNextPotentialKey();
}
// Only report progress when the percentage has changed
int currentPercentage = (int)((m_reader.Position * 90) / m_reader.Size);
if (currentPercentage != previousPercentage)
{
worker.ReportProgress(currentPercentage, "Parsing MXF file");
previousPercentage = currentPercentage;
}
}
}
Debug.WriteLine("Finished parsing file '{0}' in {1} ms", this.Filename, sw.ElapsedMilliseconds);
// Progress should now be 90%
DoPostWork(worker, sw, allPrimerKeys);
// And Execute ALL test
sw.Restart();
this.ExecuteValidationTest(worker, true);
Debug.WriteLine("Tests executed in {0} ms", sw.ElapsedMilliseconds);
// Finished
worker.ReportProgress(100, "Finished");
}
