public override bool Parse(QtParser parser)
{
if (!base.Parse(parser))
{
return(false);
}
if (HeaderName.IsFlagSet(AtomFlags.SizeAndType))
{
Size = parser.GetUInt(Attribute.Size);
uint type = parser.GetFourCC(Attribute.Type);
if (Size == 1)
{
// 64-bit size atom
Size = (long)parser.GetULong(Attribute.Size);
}
}
if (HeaderName.IsFlagSet(AtomFlags.VersionAndFlags))
{
parser.GetByte(Attribute.Version);
ParseFlags(parser);
}
return(Valid);
}
public bool ParseEnd(AsfParser parser, bool ignoreReadOverflow)
{
if (!ignoreReadOverflow && parser.ReadOverflow)
{
Valid = false;
return(false);
}
if (!HeaderName.IsFlagSet(ObjectFlags.ContainerObject))
{
// Objects extending beyond the end of the file are considered invalid
if (RelativeEndOffset > (ulong)parser.Length)
{
Valid = false;
return(false);
}
// Record unparsed bytes statistic
ulong endOffset = Math.Min(RelativeEndOffset, (ulong)parser.Length);
if ((ulong)parser.Position < endOffset)
{
UnparsedBytes = endOffset - (ulong)parser.Position;
parser.GetHexDump(Attribute.AdditionalData, (int)UnparsedBytes);
}
}
if (!ignoreReadOverflow && (!Valid || (ulong)parser.Position > RelativeEndOffset))
{
return(false);
}
return(base.ParseEnd(parser));
}
/// <summary>
/// Parse the AVIHeader.
/// </summary>
public override bool Parse(AviParser parser)
{
if (!base.Parse(parser))
{
return(false);
}
if (HeaderName.IsFlagSet(ChunkFlags.SizeAndType))
{
// Parse the type and size of the header.
parser.GetFourCC(Attribute.Type);
Size = (uint)parser.GetInt(Attribute.Size);
// 3GPP only
//if (_size == 1)
//{
// // 64-bit size chunk
// parser.GetULong(Attribute.Size);
//}
}
// 3GPP only
//if (HeaderName.IsFlagSet(ChunkFlags.VersionAndFlags))
//{
// parser.GetByte(Attribute.Version);
// ParseFlags(parser);
//}
return(this.Valid);
}
public override bool Parse(Mpeg4Parser parser)
{
if (!base.Parse(parser))
{
return(false);
}
if (HeaderName.IsFlagSet(HeaderFlags.StartCode))
{
StartCode = parser.GetStartCode(Attribute.StartCode, this is VopWithShortHeader);
}
return(this.Valid);
}
public override bool IsSuitableParent(AsfObject parent)
{
if (!parent.IsRoot)
{
// Should fit in parent object
if (Offset < parent.Offset || RelativeEndOffset > parent.RelativeEndOffset)
{
return(false);
}
}
// First object should not be unknown
if (IsUnknown && parent.IsRoot && !parent.HasChildren())
{
return(false);
}
// ASF object should have no duplicates in its parent if DuplicatesAllowed is false
if (!HeaderName.IsFlagSet(ObjectFlags.DuplicatesAllowed) && parent.HasChild(HeaderName))
{
// ASF object of partial files may end up in the root
// Therefore, duplicates are allowed, except for top-level atoms
if (!parent.IsRoot || HeaderName.IsTopLevel())
{
return(false);
}
}
// Header object is always the first object
if (HeaderName == AsfObjectName.HeaderObject && parent.HasChildren())
{
return(false);
}
// Object is allowed in its suitable parent (correct files)
if (HeaderName.GetSuitableParents().Contains(parent.HeaderName))
{
return(true);
}
// Object ends up in the root if no suitable parent was found (partial files)
if (!parent.IsRoot)
{
return(false);
}
return(true);
}
/// <summary>Parse the ASF object</summary>
public override bool Parse(AsfParser parser)
{
if (!base.Parse(parser))
{
return(false);
}
if (HeaderName.IsFlagSet(ObjectFlags.SizeAndType))
{
// Parse the type and size of the object.
parser.GetGuid(Attribute.Type);
Size = (ulong)parser.GetLong(Attribute.Size);
}
if (!HeaderName.IsFlagSet(ObjectFlags.Container) && Size > MaxUnparsedBytes)
{
return(false);
}
return(Valid);
}
public override bool ParseEnd(QtParser parser)
{
if (parser.ReadOverflow)
{
Valid = false;
return(false);
}
if (!HeaderName.IsFlagSet(AtomFlags.Container))
{
// Atoms extending beyond the end of the file are considered invalid
if (RelativeEndOffset > parser.Length)
{
Valid = false;
if (HeaderName == AtomName.MediaData)
{
// 'mdat' block may be truncated in the initial scan!
parser.Position = parser.Length;
return(base.ParseEnd(parser));
}
return(false);
}
// Record unparsed bytes statistic
long endOffset = Math.Min(RelativeEndOffset, parser.Length);
if (parser.Position < endOffset)
{
_unparsedBytes = endOffset - parser.Position;
parser.GetHexDump(Attribute.AdditionalData, (int)_unparsedBytes);
}
}
if (!Valid || (parser.Position > RelativeEndOffset))
{
return(false);
}
return(base.ParseEnd(parser));
}
public override bool ParseEnd(AviParser parser)
{
if (parser.ReadOverflow)
{
this.Valid = false;
return(false);
}
if (!HeaderName.IsFlagSet(ChunkFlags.ContainerChunk))
{
// Chunks extending beyond the end of the file are considered invalid
if (RelativeEndOffset > (ulong)parser.Length)
{
this.Valid = false;
return(false);
}
// Record unparsed bytes statistic
ulong endOffset = Math.Min(RelativeEndOffset, (ulong)parser.Length);
if ((ulong)parser.Position < endOffset)
{
UnparsedBytes = endOffset - (ulong)parser.Position;
if (!HeaderName.IsFlagSet(ChunkFlags.Container) && (UnparsedBytes > MaxUnparsedBytes))
{
return(false);
}
parser.GetHexDump(Attribute.AdditionalData, (int)UnparsedBytes);
}
}
if (!this.Valid || (ulong)parser.Position > RelativeEndOffset)
{
return(false);
}
return(base.ParseEnd(parser));
}
public override bool IsSuitableParent(QtAtom parent)
{
if (!parent.IsRoot)
{
// Should fit in parent atom (box)
if ((Offset < parent.Offset) || (RelativeEndOffset > parent.RelativeEndOffset))
{
return(false);
}
}
// First atom should not be unknown
if (IsUnknown && parent.IsRoot && !parent.HasChildren())
{
return(false);
}
// Atom should have no duplicates in its parent if DuplicatesAllowed is false
if (!HeaderName.IsFlagSet(AtomFlags.DuplicatesAllowed) && parent.HasChild(HeaderName))
{
// Atoms of partial files may end up in the root
// Therefore, duplicates are allowed, except for top-level atoms
if (!parent.IsRoot || HeaderName.IsTopLevel())
{
return(false);
}
}
// Atom is allowed in its suitable parent (correct files)
if (HeaderName.GetSuitableParents().Contains(parent.HeaderName))
{
return(true);
}
// Atom ends up in the root if no suitable parent was found (partial files)
if (!parent.IsRoot)
{
return(false);
}
// Atoms of partial files are allowed in the root if empty
if (!parent.HasChildren())
{
return(true);
}
// Root should not already contain top-level atoms (FileType, MediaData or Movie)
// Otherwise, the top-level parent of this atom should have been in the root as well
foreach (QtAtom atom in parent.Children)
{
if (atom.HeaderName.IsTopLevel())
{
return(false);
}
}
// Depth of this atom should be equal or lower than last child of the root
//if (!IsAtomTypeAllowedInRootAtThisPoint(parent, HeaderName))
//{
// return false;
//}
// Root should not contain only suitable ancestor of the atom
//if (false)
//{
// return false;
//}
// No 'higher atoms' than its suitable parent (siblings of an ancestor)
//if (false)
//{
// return false;
//}
return(true);
}
