Beispiel #1
0
        /// <summary>
        /// Check if the RIP is present and valid
        /// </summary>
        /// <param name="this.File"></param>
        /// <param name="results"></param>
        public override void OnExecuteTest(ref List <MXFValidationResult> results)
        {
            MXFValidationResult valResult = new MXFValidationResult("Random Index Pack Test");

            results.Add(valResult);
            valResult.Category = "Random Index Pack";

            Stopwatch sw = Stopwatch.StartNew();

            if (this.File.RIP == null)
            {
                valResult.SetError(string.Format("Error! No RIP found."));
                return;
            }

            if (this.File.RIPEntryCount != this.File.PartitionCount)
            {
                valResult.SetError(string.Format("Error! Number of RIP entries is not equal to the number of partitions ({0} vs {1}).", this.File.RIPEntryCount, this.File.PartitionCount));
                return;
            }

            int ripErrorCount = 0;

            for (int n = 0; n < this.File.RIPEntryCount; n++)
            {
                MXFEntryRIP rip = this.File.RIP.Children[n] as MXFEntryRIP;
                if (rip != null)
                {
                    MXFPartition part = this.File.Partitions.Where(a => (ulong)a.Offset == rip.PartitionOffset).FirstOrDefault();
                    if (part == null)
                    {
                        ripErrorCount++;
                        valResult.AddError(string.Format("Error! RIP entry {0} not pointing to a valid partion.", n));
                        return;
                    }
                }
            }
            if (ripErrorCount > 0)
            {
                valResult.SetError(string.Format("Error! {0} RIP entries are not pointing to a valid partion.", ripErrorCount));
                return;
            }

            valResult.SetSuccess("Random Index Pack (RIP) is valid.");

            LogInfo("Validation completed in {0} msec", sw.ElapsedMilliseconds);
        }
Beispiel #2
0
        /// <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");
        }