Esempio n. 1
0
        protected override void SaveToStream(Stream stream)
        {
            base.SaveToStream(stream);

            stream.WriteOneByte((byte)SpecificationMethod);
            stream.WriteOneByte(Precedence);
            stream.WriteOneByte(ColorspaceApproximation);
            if (SpecificationMethod == SpecificationMethods.EnumeratedColorspace)
                stream.WriteBEUInt32((uint)EnumeratedColorspace);
            // TODO: Write Profile
        }
Esempio n. 2
0
        protected override void SaveToStream(Stream stream)
        {
            base.SaveToStream(stream);

            stream.WriteBEUInt32(_Height);
            stream.WriteBEUInt32(_Width);
            stream.WriteBEUInt16(_NumberOfComponents);
            stream.WriteOneByte(BitsPerComponent);
            stream.WriteOneByte(_CompressionType);
            stream.WriteOneByte(_IsUnknownColorspace);
            stream.WriteOneByte(_IsIntellectualProperty);
        }
Esempio n. 3
0
        protected override void SaveToStream(Stream stream)
        {
            base.SaveToStream(stream);

            stream.WriteBEUInt32(_Height);
            stream.WriteBEUInt32(_Width);
            stream.WriteBEUInt16(_NumberOfComponents);
            stream.WriteOneByte(BitsPerComponent);
            stream.WriteOneByte(_CompressionType);
            stream.WriteOneByte(_IsUnknownColorspace);
            stream.WriteOneByte(_IsIntellectualProperty);
        }
Esempio n. 4
0
 public static int WriteNullTerminatedUTF8String(this Stream stream, string text)
 {
     if (String.IsNullOrEmpty(text))
     {
         stream.WriteOneByte(0);
         return(1);
     }
     byte[] bytes = Encoding.UTF8.GetBytes(text);
     stream.Write(bytes, 0, bytes.Length);
     stream.WriteOneByte(0);
     return(bytes.Length + 1);
 }
        protected override void SaveToStream(Stream stream)
        {
            base.SaveToStream(stream);

            stream.WriteOneByte((byte)SpecificationMethod);
            stream.WriteOneByte(Precedence);
            stream.WriteOneByte(ColorspaceApproximation);
            if (SpecificationMethod == SpecificationMethods.EnumeratedColorspace)
            {
                stream.WriteBEUInt32((uint)EnumeratedColorspace);
            }
            // TODO: Write Profile
        }
Esempio n. 6
0
        protected override void SaveToStream(Stream stream)
        {
            base.SaveToStream(stream);

            stream.WriteOneByte(Version);
            stream.WriteBEUInt24(_Flags);
        }
Esempio n. 7
0
        protected override void SaveToStream(Stream stream)
        {
            base.SaveToStream(stream);

            stream.WriteOneByte(Version);
            stream.WriteBEUInt24(_Flags);
        }
Esempio n. 8
0
        public void Write(Stream stream, UInt16 programHeaderCount, UInt16 sectionHeaderCount)
        {
            E_PHNUM = programHeaderCount;
            E_SHNUM = sectionHeaderCount;

            // E_IDENT

            UInt16 headerLength = 0;

            // Index 0-3
            headerLength += stream.WriteAndCount(MAGIC);
            headerLength += stream.WriteOneByte((byte)EI_CLASS);
            headerLength += stream.WriteOneByte((byte)EI_DATA);
            headerLength += stream.WriteOneByte((byte)EI_VERSION);
            // Index 7-15 are padding
            headerLength += stream.WriteAndCount(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 });
            headerLength += stream.WriteOneByte((byte)16); // Size of this header, always 16 bytes

            headerLength += stream.WriteHalfWord((UInt16)E_TYPE);
            headerLength += stream.WriteHalfWord((UInt16)E_MACHINE);
            headerLength += stream.WriteWord((UInt32)E_VERSION);
            headerLength += stream.WriteAddress32(E_ENTRY);
            headerLength += stream.WriteOffset32(E_PHOFF);
            headerLength += stream.WriteOffset32(E_SHOFF);
            headerLength += stream.WriteAndCount(BitConverter.GetBytes(E_FLAGS));
            headerLength += stream.WriteHalfWord(E_EHSIZE); // Is this 0x34?
            headerLength += stream.WriteHalfWord(E_PHENTSIZE);
            headerLength += stream.WriteHalfWord(E_PHNUM);
            headerLength += stream.WriteHalfWord(E_SHENTSIZE);
            headerLength += stream.WriteHalfWord(E_SHNUM);
            headerLength += stream.WriteHalfWord(E_SHSTRNDX);

            if (E_EHSIZE != headerLength && E_EHSIZE != 64)
            {
                throw new InvalidOperationException("Miscalculation of E_EHSIZE");
            }

            // Pad out to program header start.
            while (E_PHOFF - headerLength > 0)
            {
                headerLength += stream.WriteOneByte(0);
            }
        }
        protected override void SaveToStream(Stream stream)
        {
            base.SaveToStream(stream);

            // TODO: Convert to byte[] and write all at once.
            foreach (ComponentBitsEntry entry in _Entries)
            {
                stream.WriteOneByte(entry.ComponentBits);
            }
        }
        protected override void SaveToStream(Stream stream)
        {
            if ((from entry in _Entries select Math.Max(entry.Time, entry.MoofOffset)).Max() > UInt32.MaxValue)
            {
                Version = 1;
            }
            else
            {
                Version = 0;
            }

            uint MaxTrafNumber = (from entry in _Entries select entry.TrafNumber).Max();

            if (MaxTrafNumber > 16777215)
            {
                SizeOfTrafNumber = 4;
            }
            else if (MaxTrafNumber > UInt16.MaxValue)
            {
                SizeOfTrafNumber = 3;
            }
            else if (MaxTrafNumber > Byte.MaxValue)
            {
                SizeOfTrafNumber = 2;
            }
            else
            {
                SizeOfTrafNumber = 1;
            }

            uint MaxTrunNumber = (from entry in _Entries select entry.TrunNumber).Max();

            if (MaxTrunNumber > 16777215)
            {
                SizeOfTrunNumber = 4;
            }
            else if (MaxTrunNumber > UInt16.MaxValue)
            {
                SizeOfTrunNumber = 3;
            }
            else if (MaxTrunNumber > Byte.MaxValue)
            {
                SizeOfTrunNumber = 2;
            }
            else
            {
                SizeOfTrunNumber = 1;
            }

            uint MaxSampleNumber = (from entry in _Entries select entry.SampleNumber).Max();

            if (MaxSampleNumber > 16777215)
            {
                SizeOfSampleNumber = 4;
            }
            else if (MaxSampleNumber > UInt16.MaxValue)
            {
                SizeOfSampleNumber = 3;
            }
            else if (MaxSampleNumber > Byte.MaxValue)
            {
                SizeOfSampleNumber = 2;
            }
            else
            {
                SizeOfSampleNumber = 1;
            }

            base.SaveToStream(stream);

            stream.WriteBEUInt32(TrackID);
            stream.Write(Reserved, 0, 3);
            stream.WriteOneByte(_SizeOf);

            stream.WriteBEUInt32((uint)_Entries.Count);
            foreach (var entry in _Entries)
            {
                if (Version == 0x01)
                {
                    stream.WriteBEUInt64(entry.Time);
                    stream.WriteBEUInt64(entry.MoofOffset);
                }
                else
                {
                    stream.WriteBEUInt32((uint)entry.Time);
                    stream.WriteBEUInt32((uint)entry.MoofOffset);
                }

                if (SizeOfTrafNumber == 1)
                {
                    stream.WriteOneByte((byte)entry.TrafNumber);
                }
                else if (SizeOfTrafNumber == 2)
                {
                    stream.WriteBEUInt16((ushort)entry.TrafNumber);
                }
                else if (SizeOfTrafNumber == 3)
                {
                    stream.WriteBEUInt24((uint)entry.TrafNumber);
                }
                else
                {
                    stream.WriteBEUInt32((uint)entry.TrafNumber);
                }

                if (SizeOfTrunNumber == 1)
                {
                    stream.WriteOneByte((byte)entry.TrunNumber);
                }
                else if (SizeOfTrunNumber == 2)
                {
                    stream.WriteBEUInt16((ushort)entry.TrunNumber);
                }
                else if (SizeOfTrunNumber == 3)
                {
                    stream.WriteBEUInt24((uint)entry.TrunNumber);
                }
                else
                {
                    stream.WriteBEUInt32((uint)entry.TrunNumber);
                }

                if (SizeOfSampleNumber == 1)
                {
                    stream.WriteOneByte((byte)entry.SampleNumber);
                }
                else if (SizeOfSampleNumber == 2)
                {
                    stream.WriteBEUInt16((ushort)entry.SampleNumber);
                }
                else if (SizeOfSampleNumber == 3)
                {
                    stream.WriteBEUInt24((uint)entry.SampleNumber);
                }
                else
                {
                    stream.WriteBEUInt32((uint)entry.SampleNumber);
                }
            }
        }