/// <summary> /// Skip over any whitespace or any comments. /// </summary> public static void SkipWhitespaceAndComments(this BufferedReadStream stream) { bool isWhitespace; do { int val = stream.ReadByte(); // Comments start with '#' and end at the next new-line. if (val == 0x23) { int innerValue; do { innerValue = stream.ReadByte(); }while (innerValue != 0x0a); // Continue searching for whitespace. val = innerValue; } isWhitespace = val is 0x09 or 0x0a or 0x0d or 0x20; }while (isWhitespace); stream.Seek(-1, SeekOrigin.Current); }
public void BufferedStreamCanSkip(int bufferSize) { this.configuration.StreamProcessingBufferSize = bufferSize; using (MemoryStream stream = this.CreateTestStream(bufferSize * 4)) { byte[] expected = stream.ToArray(); using (var reader = new BufferedReadStream(this.configuration, stream)) { int skip = 1; int plusOne = 1; int skip2 = bufferSize; // Skip reader.Skip(skip); Assert.Equal(skip, reader.Position); Assert.Equal(stream.Position, reader.Position); // Read Assert.Equal(expected[skip], reader.ReadByte()); // Skip Again reader.Skip(skip2); // First Skip + First Read + Second Skip int position = skip + plusOne + skip2; Assert.Equal(position, reader.Position); Assert.Equal(stream.Position, reader.Position); Assert.Equal(expected[position], reader.ReadByte()); } } }
public void BufferedStreamCanSkip() { using (MemoryStream stream = this.CreateTestStream()) { byte[] expected = stream.ToArray(); using (var reader = new BufferedReadStream(stream)) { int skip = 50; int plusOne = 1; int skip2 = BufferedReadStream.BufferLength; // Skip reader.Skip(skip); Assert.Equal(skip, reader.Position); Assert.Equal(stream.Position, reader.Position); // Read Assert.Equal(expected[skip], reader.ReadByte()); // Skip Again reader.Skip(skip2); // First Skip + First Read + Second Skip int position = skip + plusOne + skip2; Assert.Equal(position, reader.Position); Assert.Equal(stream.Position, reader.Position); Assert.Equal(expected[position], reader.ReadByte()); } } }
/// <inheritdoc /> public IImageInfo Identify(BufferedReadStream stream, CancellationToken cancellationToken) { try { this.ReadLogicalScreenDescriptorAndGlobalColorTable(stream); // Loop though the respective gif parts and read the data. int nextFlag = stream.ReadByte(); while (nextFlag != GifConstants.Terminator) { if (nextFlag == GifConstants.ImageLabel) { this.ReadImageDescriptor(); } else if (nextFlag == GifConstants.ExtensionIntroducer) { switch (stream.ReadByte()) { case GifConstants.GraphicControlLabel: this.SkipBlock(); // Skip graphic control extension block break; case GifConstants.CommentLabel: this.ReadComments(); break; case GifConstants.ApplicationExtensionLabel: this.ReadApplicationExtension(); break; case GifConstants.PlainTextLabel: this.SkipBlock(); // Not supported by any known decoder. break; } } else if (nextFlag == GifConstants.EndIntroducer) { break; } nextFlag = stream.ReadByte(); if (nextFlag == -1) { break; } } } finally { this.globalColorTable?.Dispose(); } return(new ImageInfo( new PixelTypeInfo(this.logicalScreenDescriptor.BitsPerPixel), this.logicalScreenDescriptor.Width, this.logicalScreenDescriptor.Height, this.metadata)); }
PageHeader FindNextPageHeader() { var startPos = _nextPageOffset; var isResync = false; PageHeader hdr; while ((hdr = ReadPageHeader(startPos)) == null) { isResync = true; _wasteBits += 8; _stream.Position = ++startPos; var cnt = 0; do { var b = _stream.ReadByte(); if (b == 0x4f) { if (_stream.ReadByte() == 0x67) { if (_stream.ReadByte() == 0x67) { if (_stream.ReadByte() == 0x53) { // found it! startPos += cnt; break; } _stream.Seek(-1, SeekOrigin.Current); } _stream.Seek(-1, SeekOrigin.Current); } _stream.Seek(-1, SeekOrigin.Current); } else if (b == -1) { return(null); } _wasteBits += 8; } while (++cnt < 65536); // we will only search through 64KB of data to find the next sync marker. if it can't be found, we have a badly corrupted stream. if (cnt == 65536) { return(null); } } hdr.IsResync = isResync; _nextPageOffset = hdr.DataOffset; for (int i = 0; i < hdr.PacketSizes.Length; i++) { _nextPageOffset += hdr.PacketSizes[i]; } return(hdr); }
private unsafe bool FindNextPageHeader(out PageHeader header) { long startPos = _nextPageOffset; bool isResync = false; while (!ReadPageHeader(startPos, out header)) { isResync = true; _wasteBits += 8; _stream.Position = ++startPos; int count = 0; do { int b = _stream.ReadByte(); if (b == 0x4f) { if (_stream.ReadByte() == 0x67 && _stream.ReadByte() == 0x67 && _stream.ReadByte() == 0x53) { // found it! startPos += count; break; } else { _stream.Seek(-3, SeekOrigin.Current); } } else if (b == -1) { return(false); } _wasteBits += 8; } while (++count < 65536); // we will only search through 64KB of data to find the next sync marker. if it can't be found, we have a badly corrupted stream. if (count == 65536) { return(false); } } header.IsResync = isResync; _nextPageOffset = header.DataOffset; for (int i = 0; i < header.SegCount; i++) { _nextPageOffset += header.PacketSizes[i]; } return(true); }
public void BufferedStreamCanReadSubsequentSingleByteCorrectly() { using (MemoryStream stream = this.CreateTestStream()) { byte[] expected = stream.ToArray(); int i; using (var reader = new BufferedReadStream(stream)) { for (i = 0; i < expected.Length; i++) { Assert.Equal(expected[i], reader.ReadByte()); Assert.Equal(i + 1, reader.Position); if (i < BufferedReadStream.BufferLength) { Assert.Equal(stream.Position, BufferedReadStream.BufferLength); } else if (i >= BufferedReadStream.BufferLength && i < BufferedReadStream.BufferLength * 2) { // We should have advanced to the second chunk now. Assert.Equal(stream.Position, BufferedReadStream.BufferLength * 2); } else { // We should have advanced to the third chunk now. Assert.Equal(stream.Position, BufferedReadStream.BufferLength * 3); } } } Assert.Equal(i, stream.Position); } }
public void BufferedStreamCanReadSubsequentSingleByteCorrectly(int bufferSize) { this.configuration.StreamProcessingBufferSize = bufferSize; using (MemoryStream stream = this.CreateTestStream(bufferSize * 3)) { byte[] expected = stream.ToArray(); int i; using (var reader = new BufferedReadStream(this.configuration, stream)) { for (i = 0; i < expected.Length; i++) { Assert.Equal(expected[i], reader.ReadByte()); Assert.Equal(i + 1, reader.Position); if (i < bufferSize) { Assert.Equal(stream.Position, bufferSize); } else if (i >= bufferSize && i < bufferSize * 2) { // We should have advanced to the second chunk now. Assert.Equal(stream.Position, bufferSize * 2); } else { // We should have advanced to the third chunk now. Assert.Equal(stream.Position, bufferSize * 3); } } } Assert.Equal(i, stream.Position); } }
/// <summary> /// Finds the next file marker within the byte stream. /// </summary> /// <param name="marker">The buffer to read file markers to.</param> /// <param name="stream">The input stream.</param> /// <returns>The <see cref="JpegFileMarker"/></returns> public static JpegFileMarker FindNextFileMarker(byte[] marker, BufferedReadStream stream) { int value = stream.Read(marker, 0, 2); if (value == 0) { return new JpegFileMarker(JpegConstants.Markers.EOI, stream.Length - 2); } if (marker[0] == JpegConstants.Markers.XFF) { // According to Section B.1.1.2: // "Any marker may optionally be preceded by any number of fill bytes, which are bytes assigned code 0xFF." int m = marker[1]; while (m == JpegConstants.Markers.XFF) { int suffix = stream.ReadByte(); if (suffix == -1) { return new JpegFileMarker(JpegConstants.Markers.EOI, stream.Length - 2); } m = suffix; } return new JpegFileMarker((byte)m, stream.Position - 2); } return new JpegFileMarker(marker[1], stream.Position - 2, true); }
public PageHeader FindNextPageHeader() { long num = _nextPageOffset; bool isResync = false; PageHeader pageHeader; while ((pageHeader = ReadPageHeader(num)) == null) { isResync = true; _wasteBits += 8L; num = (_stream.Position = num + 1); int num3 = 0; do { switch (_stream.ReadByte()) { case 79: if (_stream.ReadByte() == 103 && _stream.ReadByte() == 103 && _stream.ReadByte() == 83) { num += num3; goto end_IL_0032; } _stream.Seek(-3L, SeekOrigin.Current); break; case -1: return(null); } _wasteBits += 8L; continue; end_IL_0032: break; }while (++num3 < 65536); if (num3 == 65536) { return(null); } } pageHeader.IsResync = isResync; _nextPageOffset = pageHeader.DataOffset; for (int i = 0; i < pageHeader.PacketSizes.Length; i++) { _nextPageOffset += pageHeader.PacketSizes[i]; } return(pageHeader); }
public int BufferedReadStreamReadByte() { int r = 0; BufferedReadStream reader = this.bufferedStream2; for (int i = 0; i < reader.Length; i++) { r += reader.ReadByte(); } return(r); }
public void BufferedStreamReadsCanReadAllAsSingleByteFromOrigin() { using (MemoryStream stream = this.CreateTestStream()) { byte[] expected = stream.ToArray(); using (var reader = new BufferedReadStream(stream)) { for (int i = 0; i < expected.Length; i++) { Assert.Equal(expected[i], reader.ReadByte()); } } } }
public void BufferedStreamReadsCanReadAllAsSingleByteFromOrigin(int bufferSize) { this.configuration.StreamProcessingBufferSize = bufferSize; using (MemoryStream stream = this.CreateTestStream(bufferSize * 3)) { byte[] expected = stream.ToArray(); using (var reader = new BufferedReadStream(this.configuration, stream)) { for (int i = 0; i < expected.Length; i++) { Assert.Equal(expected[i], reader.ReadByte()); } } } }
/// <summary> /// Read a decimal text value. /// </summary> /// <returns>The integer value of the decimal.</returns> public static int ReadDecimal(this BufferedReadStream stream) { int value = 0; while (true) { int current = stream.ReadByte() - 0x30; if ((uint)current > 9) { break; } value = (value * 10) + current; } return(value); }
public void BufferedStreamCanReadSingleByteFromOrigin() { using (MemoryStream stream = this.CreateTestStream()) { byte[] expected = stream.ToArray(); using (var reader = new BufferedReadStream(stream)) { Assert.Equal(expected[0], reader.ReadByte()); // We've read a whole chunk but increment by 1 in our reader. Assert.Equal(BufferedReadStream.BufferLength, stream.Position); Assert.Equal(1, reader.Position); } // Position of the stream should be reset on disposal. Assert.Equal(1, stream.Position); } }
public void BufferedStreamCanReadSingleByteFromOrigin(int bufferSize) { this.configuration.StreamProcessingBufferSize = bufferSize; using (MemoryStream stream = this.CreateTestStream(bufferSize * 3)) { byte[] expected = stream.ToArray(); using (var reader = new BufferedReadStream(this.configuration, stream)) { Assert.Equal(expected[0], reader.ReadByte()); // We've read a whole chunk but increment by 1 in our reader. Assert.True(stream.Position >= bufferSize); Assert.Equal(1, reader.Position); } // Position of the stream should be reset on disposal. Assert.Equal(1, stream.Position); } }
protected override int ReadNextByte() { if (_curOfs == _length) { if (_mergedPacket == null) { return(-1); } return(_mergedPacket.ReadNextByte()); } _stream.Seek(_curOfs + _offset, SeekOrigin.Begin); var b = _stream.ReadByte(); ++_curOfs; return(b); }
public void BufferedStreamCanReadSingleByteFromOffset() { using (MemoryStream stream = this.CreateTestStream()) { byte[] expected = stream.ToArray(); const int offset = 5; using (var reader = new BufferedReadStream(stream)) { reader.Position = offset; Assert.Equal(expected[offset], reader.ReadByte()); // We've read a whole chunk but increment by 1 in our reader. Assert.Equal(BufferedReadStream.BufferLength + offset, stream.Position); Assert.Equal(offset + 1, reader.Position); } Assert.Equal(offset + 1, stream.Position); } }
public void BufferedStreamReadsSmallStream() { // Create a stream smaller than the default buffer length using (MemoryStream stream = this.CreateTestStream(BufferedReadStream.BufferLength / 4)) { byte[] expected = stream.ToArray(); const int offset = 5; using (var reader = new BufferedReadStream(stream)) { reader.Position = offset; Assert.Equal(expected[offset], reader.ReadByte()); // We've read a whole length of the stream but increment by 1 in our reader. Assert.Equal(BufferedReadStream.BufferLength / 4, stream.Position); Assert.Equal(offset + 1, reader.Position); } Assert.Equal(offset + 1, stream.Position); } }
public void BufferedStreamCanReadSingleByteFromOffset(int bufferSize) { this.configuration.StreamProcessingBufferSize = bufferSize; using (MemoryStream stream = this.CreateTestStream(bufferSize * 3)) { byte[] expected = stream.ToArray(); int offset = expected.Length / 2; using (var reader = new BufferedReadStream(this.configuration, stream)) { reader.Position = offset; Assert.Equal(expected[offset], reader.ReadByte()); // We've read a whole chunk but increment by 1 in our reader. Assert.Equal(bufferSize + offset, stream.Position); Assert.Equal(offset + 1, reader.Position); } Assert.Equal(offset + 1, stream.Position); } }
public void BufferedStreamReadsSmallStream(int bufferSize) { this.configuration.StreamProcessingBufferSize = bufferSize; // Create a stream smaller than the default buffer length using (MemoryStream stream = this.CreateTestStream(Math.Max(1, bufferSize / 4))) { byte[] expected = stream.ToArray(); int offset = expected.Length / 2; using (var reader = new BufferedReadStream(this.configuration, stream)) { reader.Position = offset; Assert.Equal(expected[offset], reader.ReadByte()); // We've read a whole length of the stream but increment by 1 in our reader. Assert.Equal(Math.Max(1, bufferSize / 4), stream.Position); Assert.Equal(offset + 1, reader.Position); } Assert.Equal(offset + 1, stream.Position); } }
/// <inheritdoc /> public Image <TPixel> Decode <TPixel>(BufferedReadStream stream, CancellationToken cancellationToken) where TPixel : unmanaged, IPixel <TPixel> { Image <TPixel> image = null; ImageFrame <TPixel> previousFrame = null; try { this.ReadLogicalScreenDescriptorAndGlobalColorTable(stream); // Loop though the respective gif parts and read the data. int nextFlag = stream.ReadByte(); while (nextFlag != GifConstants.Terminator) { if (nextFlag == GifConstants.ImageLabel) { if (previousFrame != null && this.DecodingMode == FrameDecodingMode.First) { break; } this.ReadFrame(ref image, ref previousFrame); } else if (nextFlag == GifConstants.ExtensionIntroducer) { switch (stream.ReadByte()) { case GifConstants.GraphicControlLabel: this.ReadGraphicalControlExtension(); break; case GifConstants.CommentLabel: this.ReadComments(); break; case GifConstants.ApplicationExtensionLabel: this.ReadApplicationExtension(); break; case GifConstants.PlainTextLabel: this.SkipBlock(); // Not supported by any known decoder. break; } } else if (nextFlag == GifConstants.EndIntroducer) { break; } nextFlag = stream.ReadByte(); if (nextFlag == -1) { break; } } } finally { this.globalColorTable?.Dispose(); } return(image); }