/// <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);
}
