public override bool Parse(QtParser parser) { uint maxUnparsedBytes = (uint)QtDetector.Configurable[QtDetector.ConfigurationKey.FileTypeMaxUnparsedBytes]; if (!base.Parse(parser) || parser.BytesRemaining > maxUnparsedBytes) { return(false); } Brand majorBrand = (Brand)parser.GetFourCC(Attribute.MajorBrand); parser.GetUInt(Attribute.MinorVersion, "{0:X8}"); // Gets the list of compatible brands StringBuilder sb = new StringBuilder(); List <Brand> compatibleBrands = new List <Brand>(); // Remaining data of the atom are the compatible brands while (parser.BytesRemaining >= 4) { uint compatibleBrand = parser.GetUInt(); if (compatibleBrand != 0) { if (sb.Length > 0) { sb.Append(", "); } // Add 4CC sb.Append(compatibleBrand.ToString4CC()); compatibleBrands.Add((Brand)compatibleBrand); } } // Create attribute with comma separated list of compatible brands parser.AddAttribute(new FormattedAttribute <Attribute, string>(Attribute.CompatibleBrands, sb.ToString())); _dataFormat = GetDataFormat((Brand)majorBrand); if (DataFormat == CodecID.Unknown) { // Scan compatible brands for known brand foreach (Brand brand in compatibleBrands) { _dataFormat = GetDataFormat(brand); if (DataFormat != CodecID.Unknown) { break; } } } // Unsupported formats, such as JPEG-2000, should be ignored parser.CheckAttribute(Attribute.MajorBrand, DataFormat != CodecID.Unknown); // We expect the major brand in the list of compatible brands parser.CheckAttribute(Attribute.CompatibleBrands, compatibleBrands.Contains(majorBrand), false); return(this.Valid); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } parser.GetUShort(Attribute.SubSequenceIdentifer); parser.GetByte(Attribute.LayerNumber); byte flags = parser.GetByte(); bool durationFlag = (flags & 0x80) == 0x80; bool avgRateFlag = (flags & 0x40) == 0x40; byte reserved = (byte)(flags & 0x3F); parser.AddAttribute(new FormattedAttribute <Attribute, bool>(Attribute.DurationFlag, durationFlag)); parser.AddAttribute(new FormattedAttribute <Attribute, bool>(Attribute.AvgRateFlag, avgRateFlag)); parser.AddAttribute(new FormattedAttribute <Attribute, byte>(Attribute.Reserved, reserved)); parser.CheckAttribute(Attribute.Reserved, reserved == 0, false); if (durationFlag) { parser.GetUInt(Attribute.Duration); } if (avgRateFlag) { parser.GetByte(Attribute.AccurateStatisticsFlag); parser.GetUShort(Attribute.AvgBitRate); parser.GetUShort(Attribute.AvgFrameRate); } parser.GetTable(Attribute.DependencyInfo, Attribute.NumReferences, NumberOfEntriesType.Byte, 32, () => new DependencyInfo(), parser.BytesRemaining); return(Valid); }
public override bool Parse(QtParser parser) { Matrix.Parse(parser); TypedValue = string.Format("({0}; {1}; {2}; {3}; {4}; {5}; {6}; {7}; {8})", Matrix.A, Matrix.B, Matrix.U, Matrix.C, Matrix.D, Matrix.V, Matrix.X, Matrix.Y, Matrix.W); return(Valid); }
public override bool Parse(QtParser parser) { short red = parser.GetShort(LAttribute.Red); short green = parser.GetShort(LAttribute.Green); short blue = parser.GetShort(LAttribute.Blue); TypedValue = string.Format("({0}, {1}, {2})", red, green, blue); return(Valid); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } parser.GetTable(Attribute.FeatureEntities, Attribute.NumberOfFeatureEntities, NumberOfEntriesType.UInt, 16, () => new FeatureEntity(), parser.BytesRemaining); return(Valid); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } parser.GetTable(Attribute.TimeToSampleTable, Attribute.NumberOfEntries, NumberOfEntriesType.UInt, 8, () => new TimeToSampleTableEntry(), parser.BytesRemaining); return(Valid); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } parser.CheckAttribute(Attribute.Size, Size == 8); return(this.Valid); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } short rollDistance = parser.GetShort(Attribute.RollDistance); parser.CheckAttribute(Attribute.RollDistance, rollDistance != 0, false); return(Valid); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } parser.GetInt(Attribute.Reserved); parser.GetShort(Attribute.Reserved); parser.GetShort(Attribute.DataReferenceIndex); return(this.Valid); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } parser.GetUInt(Attribute.GroupingType); parser.GetTable(Attribute.SampleToGroupTable, Attribute.EntryCount, NumberOfEntriesType.UInt, 8, () => new SampleToGroupEntry(), parser.BytesRemaining); return(Valid); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } parser.GetUInt(Attribute.Version, "{0:X8}"); // TODO: the sequence of descriptors is taken (mostly) from ffmpeg // TODO: verify that this is the actual sequence seen in (all) 3GPP files BaseDescriptor descriptor = ReadDescriptor(parser); if (descriptor.Tag == DescriptorClassTag.ES_DescrTag) { parser.GetUShort(); // ID parser.GetByte(); // priority } else { parser.GetUShort(); // ID } descriptor = ReadDescriptor(parser); if (descriptor.Tag == DescriptorClassTag.DecoderConfigDescrTag) { parser.GetByte(Attribute.ObjectTypeIndication); // 0x20 Visual ISO/IEC 14496-2 parser.GetByte(Attribute.StreamType); parser.GetThreeBytes(Attribute.BufferSizeDB); // 3 bytes parser.GetUInt(Attribute.MaxBitrate); parser.GetUInt(Attribute.AvgBitrate); descriptor = ReadDescriptor(parser); if ((parser.Position + descriptor.Length) > parser.Length) { return(false); } if (descriptor.Tag == DescriptorClassTag.DecSpecificInfoTag) { // Extra data can be empty (0 bytes) if (descriptor.Length > 0) { ExtraData = parser.GetDataPacket(parser.Position, descriptor.Length); } Attributes.Add(new FormattedAttribute <Attribute, long>(Attribute.DecSpecificInfoSize, descriptor.Length)); } parser.Position += Math.Min(descriptor.Length, parser.Length - parser.Position); } return(this.Valid); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } parser.GetTable(Attribute.EditListTable, Attribute.NumberOfEntries, NumberOfEntriesType.UInt, 12, () => new EditListTableEntry(), parser.BytesRemaining); // TODO add check: The last edit in a track should never be an empty edit // Empty edits have the media time set to -1 return(Valid); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } parser.GetUInt(Attribute.PreloadStartTime); parser.GetInt(Attribute.PreloadDuration); parser.GetFlags <Attribute, PreloadFlags>(Attribute.PreloadFlags, 4); parser.GetFlags <Attribute, DefaultHints>(Attribute.DefaultHints, 4); return(this.Valid); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } parser.GetByte(Attribute.LayerNumber); parser.GetByte(Attribute.AccurateStatisticsFlag); parser.GetUShort(Attribute.AvgBitRate); parser.GetUShort(Attribute.AvgFrameRate); return(Valid); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } const int EntrySize = 4; uint numberOfEntries = (uint)(parser.BytesRemaining / EntrySize); parser.AddAttribute(new FormattedAttribute <Attribute, uint>(Attribute.TableSize, numberOfEntries)); parser.GetTable(Attribute.TrackIDTable, Attribute.TableSize, numberOfEntries, EntrySize, () => new TrackID(), parser.BytesRemaining); return(Valid); }
/// <summary> /// Reads a MPEG-4 descriptor. /// </summary> /// <remarks>defined in ISO/IEC 14496-1 �2.2</remarks> private static BaseDescriptor ReadDescriptor(QtParser parser) { DescriptorClassTag tag = (DescriptorClassTag)parser.GetByte(); // Expandable length [see ISO/IEC 14496-1 �3.3] int count = 4; uint nextByte = parser.GetByte(); uint sizeOfInstance = (nextByte & 0x7F); while ((nextByte & 0x80) != 0 && --count > 0) { nextByte = parser.GetByte(); sizeOfInstance = (sizeOfInstance << 7) | (nextByte & 0x7F); } return(new BaseDescriptor(tag, sizeOfInstance)); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } ushort regionSize = parser.GetUShort(Attribute.RegionSize); parser.Parse(new RegionBounderyBox()); parser.CheckAttribute(Attribute.RegionSize, regionSize == parser.BytesRemaining); if (Valid) { parser.GetHexDump(Attribute.ClippingRegionData, regionSize); } return(Valid); }
public override bool Parse(QtParser parser) { uint flags = 0; for (int i = 0; i < _size; i++) { flags = (flags << 8) | parser.GetByte(); } foreach (TFlag flag in Enum.GetValues(typeof(TFlag))) { parser.AddAttribute(new FormattedAttribute <TFlag, bool>(flag, IsFlagSet(flags, flag))); } this.TypedValue = flags; return(this.Valid); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } uint uncompressedSize = parser.GetUInt(Attribute.UncompressedSize); // TODO: finish decompression method and parse the decompressed movie atom //byte[] compressedData = new byte[parser.BytesRemaining]; //parser.DataReader.Read(compressedData, 0, compressedData.Length); //DecompressZlib(compressedData, uncompressedSize); return(this.Valid); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } uint colorParameterType = parser.GetFourCC(Attribute.ColorParameterType); parser.CheckAttribute(Attribute.ColorParameterType, colorParameterType == "nclc".To4CC(), false); parser.GetUShort(Attribute.PrimariesIndex); parser.GetUShort(Attribute.TransferFunctionIndex); parser.GetUShort(Attribute.MatrixIndex); return(Valid); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } // Reserved (6x byte) for (int i = 0; i < 6; i++) { parser.GetByte(); } parser.GetUShort(Attribute.ReferenceIndex); parser.GetUShort(Attribute.PreDefined1); parser.GetUShort(Attribute.Reserved1); return(Valid); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } if (parser.BytesRemaining > 255) { Valid = false; string value = string.Format("{0} descriptor bytes found", parser.BytesRemaining); parser.AddAttribute(new FormattedAttribute <Attribute, string>(Attribute.Descriptor, value)); parser.GetDataPacket(parser.Position, (long)parser.BytesRemaining); parser.Position += (long)parser.BytesRemaining; } return(Valid); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } switch (_atomType) { case AtomType.ChunkOffset32Bit: parser.GetTable(Attribute.ChunkOffsetTable, Attribute.NumberOfEntries, NumberOfEntriesType.UInt, 4, () => new ChunkOffsetTableAttribute(AtomType.ChunkOffset32Bit), parser.BytesRemaining); break; case AtomType.ChunkOffset64Bit: parser.GetTable(Attribute.ChunkOffsetTable, Attribute.NumberOfEntries, NumberOfEntriesType.UInt, 8, () => new ChunkOffsetTableAttribute(AtomType.ChunkOffset64Bit), parser.BytesRemaining); break; } return(Valid); }
// See QuickTime File Format Specification, 2010-08-03, pg.1 private static void ParseTcmiAtom(QtParser parser, uint size) { long tcmiPosition = (parser.Position - 4); parser.AddAttribute(new FormattedAttribute <QtAtom.Attribute, uint>(QtAtom.Attribute.Size, size)); uint type = parser.GetFourCC(QtAtom.Attribute.Type); parser.CheckAttribute(QtAtom.Attribute.Type, type == Tcmi, false); parser.GetByte(QtAtom.Attribute.Version); parser.GetThreeBytes(QtAtom.Attribute.Flags); parser.GetUShort(Attribute.TextFont); parser.GetUShort(Attribute.TextFace); parser.GetUShort(Attribute.TextSize); parser.GetUShort(Attribute.TcmiReserved); parser.Parse(new Color(Attribute.TextColor)); parser.Parse(new Color(Attribute.BackgroundColor)); parser.GetPascalString(Attribute.FontName, 0); parser.CheckAttribute(QtAtom.Attribute.Size, size == (parser.Position - tcmiPosition), false); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } // TODO implement //for (i=0; i < sample_count; i++){ // unsigned int(16) dependency_count; // for (k=0; k < dependency_count; k++) // { // signed int(16) relative_sample_number; // } //} parser.Position += (long)parser.BytesRemaining; return(Valid); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } uint sampleSize = parser.GetUInt(Attribute.SampleSize); if (sampleSize == 0) // If the sample size is 0 than only read the number of samples in the track { parser.GetTable(Attribute.SampleSizeTable, Attribute.NumberOfEntries, NumberOfEntriesType.UInt, 4, () => new SampleSizeTableAttribute(), parser.BytesRemaining); } else { parser.GetUInt(Attribute.SampleCount); // Read the number on samples in the track } return(Valid); }
// for (i=0; i< numOfSequenceParameterSets; i++) { // unsigned int(16) sequenceParameterSetLength ; // bit(8*sequenceParameterSetLength) sequenceParameterSetNALUnit; // } // // for (i=0; i< numOfPictureParameterSets; i++) { // unsigned int(16) pictureParameterSetLength; // bit(8*pictureParameterSetLength) pictureParameterSetNALUnit; // } private static IDataPacket CreateNalUnit(QtParser parser, byte setCount, Attribute attribute) { long beginOffset = parser.Position; int totalSetLength = 0; for (int i = 0; i < setCount; i++) { ushort setLength = parser.GetUShort(); parser.Position += setLength; totalSetLength += setLength + sizeof(ushort); } if (totalSetLength > 0) { parser.Position = beginOffset; parser.GetHexDump <Attribute>(attribute, totalSetLength); return(parser.GetDataPacket(beginOffset, totalSetLength)); } return(null); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } int colorTableSeed = parser.GetInt(Attribute.ColorTableSeed); parser.CheckAttribute(Attribute.ColorTableSeed, colorTableSeed == 0); ushort colorTableFlags = parser.GetUShort(Attribute.ColorTableFlags); parser.CheckAttribute(Attribute.ColorTableFlags, colorTableFlags == 0x8000); uint colorTableSize = parser.GetUShort(Attribute.ColorTableSize); colorTableSize++; // The color table size is zero-relative; 0 means there is one color in the array parser.GetTable(Attribute.ColorArray, Attribute.ColorTableSize, colorTableSize, 8, () => new Color(), parser.BytesRemaining); return(Valid); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } if (!CheckComponentSubType(ComponentSubType.tmcd)) { Valid = false; return(Valid); } uint reserved = parser.GetUInt(); if (reserved == 0) { parser.AddAttribute(new FormattedAttribute <QtSampleDescriptionAtom.Attribute, int>(QtSampleDescriptionAtom.Attribute.Reserved, (int)reserved)); parser.GetShort(QtSampleDescriptionAtom.Attribute.Reserved); parser.GetShort(QtSampleDescriptionAtom.Attribute.DataReferenceIndex); reserved = parser.GetUInt(Attribute.Reserved1); parser.CheckAttribute(Attribute.Reserved1, reserved == 0, true); parser.Parse(new Flags()); parser.GetInt(Attribute.TimeScale); parser.GetInt(Attribute.FrameDuration); parser.GetByte(Attribute.NumberOfFrames); reserved = parser.GetThreeBytes(Attribute.Reserved2); parser.CheckAttribute(Attribute.Reserved2, reserved == 0, false); if (parser.BytesRemaining > 0) { parser.GetHexDump(QtAtom.Attribute.AdditionalData, (int)parser.BytesRemaining); } } else { ParseTcmiAtom(parser, reserved); } return(Valid); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } parser.GetDateTime(Attribute.CreationTime, "{0:F}"); parser.GetDateTime(Attribute.ModificationTime, "{0:F}"); TrackID = parser.GetUInt(Attribute.TrackID); parser.GetUInt(Attribute.Reserved1); parser.GetUInt(Attribute.Duration); parser.GetULong(Attribute.Reserved2); parser.GetShort(Attribute.Layer); parser.GetShort(Attribute.AlternateGroup); parser.GetFixed8_8(Attribute.Volume); parser.GetUShort(Attribute.Reserved3); parser.GetMatrix(Attribute.MatrixStructure); parser.GetFixed16_16(Attribute.TrackWidth); parser.GetFixed16_16(Attribute.TrackHeight); return(this.Valid); }