mirror of https://github.com/SixLabors/ImageSharp
James Jackson-South
8 years ago
committed by
GitHub
GitHub
29 changed files with 439 additions and 1333 deletions
@ -1,177 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Diagnostics; |
|||
using System.Runtime.CompilerServices; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Gif |
|||
{ |
|||
/// <summary>
|
|||
/// Represents a byte of data in a GIF data stream which contains a number
|
|||
/// of data items.
|
|||
/// </summary>
|
|||
internal readonly struct PackedField : IEquatable<PackedField> |
|||
{ |
|||
/// <summary>
|
|||
/// The individual bits representing the packed byte.
|
|||
/// </summary>
|
|||
private static readonly bool[] Bits = new bool[8]; |
|||
|
|||
/// <summary>
|
|||
/// Gets the byte which represents the data items held in this instance.
|
|||
/// </summary>
|
|||
public byte Byte |
|||
{ |
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
get |
|||
{ |
|||
int returnValue = 0; |
|||
int bitShift = 7; |
|||
foreach (bool bit in Bits) |
|||
{ |
|||
int bitValue; |
|||
if (bit) |
|||
{ |
|||
bitValue = 1 << bitShift; |
|||
} |
|||
else |
|||
{ |
|||
bitValue = 0; |
|||
} |
|||
|
|||
returnValue |= bitValue; |
|||
bitShift--; |
|||
} |
|||
|
|||
return Convert.ToByte(returnValue & 0xFF); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns a new <see cref="PackedField"/> with the bits in the packed fields to
|
|||
/// the corresponding bits from the supplied byte.
|
|||
/// </summary>
|
|||
/// <param name="value">The value to pack.</param>
|
|||
/// <returns>The <see cref="PackedField"/></returns>
|
|||
public static PackedField FromInt(byte value) |
|||
{ |
|||
PackedField packed = default; |
|||
packed.SetBits(0, 8, value); |
|||
return packed; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sets the specified bit within the packed fields to the supplied
|
|||
/// value.
|
|||
/// </summary>
|
|||
/// <param name="index">
|
|||
/// The zero-based index within the packed fields of the bit to set.
|
|||
/// </param>
|
|||
/// <param name="valueToSet">
|
|||
/// The value to set the bit to.
|
|||
/// </param>
|
|||
public void SetBit(int index, bool valueToSet) |
|||
{ |
|||
DebugGuard.MustBeBetweenOrEqualTo(index, 0, 7, nameof(index)); |
|||
Bits[index] = valueToSet; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sets the specified bits within the packed fields to the supplied
|
|||
/// value.
|
|||
/// </summary>
|
|||
/// <param name="startIndex">The zero-based index within the packed fields of the first bit to set.</param>
|
|||
/// <param name="length">The number of bits to set.</param>
|
|||
/// <param name="valueToSet">The value to set the bits to.</param>
|
|||
public void SetBits(int startIndex, int length, int valueToSet) |
|||
{ |
|||
DebugGuard.MustBeBetweenOrEqualTo(startIndex, 0, 7, nameof(startIndex)); |
|||
DebugCheckLength(startIndex, length); |
|||
|
|||
int bitShift = length - 1; |
|||
for (int i = startIndex; i < startIndex + length; i++) |
|||
{ |
|||
int bitValueIfSet = 1 << bitShift; |
|||
int bitValue = valueToSet & bitValueIfSet; |
|||
int bitIsSet = bitValue >> bitShift; |
|||
Bits[i] = bitIsSet == 1; |
|||
bitShift--; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the value of the specified bit within the byte.
|
|||
/// </summary>
|
|||
/// <param name="index">The zero-based index of the bit to get.</param>
|
|||
/// <returns>
|
|||
/// The value of the specified bit within the byte.
|
|||
/// </returns>
|
|||
public bool GetBit(int index) |
|||
{ |
|||
DebugGuard.MustBeBetweenOrEqualTo(index, 0, 7, nameof(index)); |
|||
return Bits[index]; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the value of the specified bits within the byte.
|
|||
/// </summary>
|
|||
/// <param name="startIndex">The zero-based index of the first bit to get.</param>
|
|||
/// <param name="length">The number of bits to get.</param>
|
|||
/// <returns>
|
|||
/// The value of the specified bits within the byte.
|
|||
/// </returns>
|
|||
public int GetBits(int startIndex, int length) |
|||
{ |
|||
DebugGuard.MustBeBetweenOrEqualTo(startIndex, 1, 8, nameof(startIndex)); |
|||
DebugCheckLength(startIndex, length); |
|||
|
|||
int returnValue = 0; |
|||
int bitShift = length - 1; |
|||
for (int i = startIndex; i < startIndex + length; i++) |
|||
{ |
|||
int bitValue = (Bits[i] ? 1 : 0) << bitShift; |
|||
returnValue += bitValue; |
|||
bitShift--; |
|||
} |
|||
|
|||
return returnValue; |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public override bool Equals(object obj) |
|||
{ |
|||
return obj is PackedField other && this.Equals(other); |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public bool Equals(PackedField other) |
|||
{ |
|||
return this.Byte.Equals(other.Byte); |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public override string ToString() |
|||
{ |
|||
return $"PackedField [ Byte={this.Byte} ]"; |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public override int GetHashCode() |
|||
{ |
|||
return this.Byte.GetHashCode(); |
|||
} |
|||
|
|||
[Conditional("DEBUG")] |
|||
private static void DebugCheckLength(int startIndex, int length) |
|||
{ |
|||
if (length < 1 || startIndex + length > 8) |
|||
{ |
|||
string message = "Length must be greater than zero and the sum of length and start index must be less than 8. " |
|||
+ $"Supplied length: {length}. Supplied start index: {startIndex}"; |
|||
|
|||
throw new ArgumentOutOfRangeException(nameof(length), message); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,106 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Runtime.CompilerServices; |
|||
using System.Runtime.InteropServices; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Gif |
|||
{ |
|||
/// <summary>
|
|||
/// The Graphic Control Extension contains parameters used when
|
|||
/// processing a graphic rendering block.
|
|||
/// </summary>
|
|||
[StructLayout(LayoutKind.Sequential, Pack = 1)] |
|||
internal readonly struct GifGraphicControlExtension : IGifExtension |
|||
{ |
|||
public GifGraphicControlExtension( |
|||
byte packed, |
|||
ushort delayTime, |
|||
byte transparencyIndex) |
|||
{ |
|||
this.BlockSize = 4; |
|||
this.Packed = packed; |
|||
this.DelayTime = delayTime; |
|||
this.TransparencyIndex = transparencyIndex; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the size of the block.
|
|||
/// </summary>
|
|||
public byte BlockSize { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the packed disposalMethod and transparencyFlag value.
|
|||
/// </summary>
|
|||
public byte Packed { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the delay time in of hundredths (1/100) of a second
|
|||
/// to wait before continuing with the processing of the Data Stream.
|
|||
/// The clock starts ticking immediately after the graphic is rendered.
|
|||
/// </summary>
|
|||
public ushort DelayTime { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the transparency index.
|
|||
/// The Transparency Index is such that when encountered, the corresponding pixel
|
|||
/// of the display device is not modified and processing goes on to the next pixel.
|
|||
/// </summary>
|
|||
public byte TransparencyIndex { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the disposal method which indicates the way in which the
|
|||
/// graphic is to be treated after being displayed.
|
|||
/// </summary>
|
|||
public DisposalMethod DisposalMethod => (DisposalMethod)((this.Packed & 0x1C) >> 2); |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whether transparency flag is to be set.
|
|||
/// This indicates whether a transparency index is given in the Transparent Index field.
|
|||
/// </summary>
|
|||
public bool TransparencyFlag => (this.Packed & 0x01) == 1; |
|||
|
|||
byte IGifExtension.Label => GifConstants.GraphicControlLabel; |
|||
|
|||
public int WriteTo(Span<byte> buffer) |
|||
{ |
|||
ref GifGraphicControlExtension dest = ref Unsafe.As<byte, GifGraphicControlExtension>(ref MemoryMarshal.GetReference(buffer)); |
|||
|
|||
dest = this; |
|||
|
|||
return 5; |
|||
} |
|||
|
|||
public static GifGraphicControlExtension Parse(ReadOnlySpan<byte> buffer) |
|||
{ |
|||
return MemoryMarshal.Cast<byte, GifGraphicControlExtension>(buffer)[0]; |
|||
} |
|||
|
|||
public static byte GetPackedValue(DisposalMethod disposalMethod, bool userInputFlag = false, bool transparencyFlag = false) |
|||
{ |
|||
/* |
|||
Reserved | 3 Bits |
|||
Disposal Method | 3 Bits |
|||
User Input Flag | 1 Bit |
|||
Transparent Color Flag | 1 Bit |
|||
*/ |
|||
|
|||
byte value = 0; |
|||
|
|||
value |= (byte)((int)disposalMethod << 2); |
|||
|
|||
if (userInputFlag) |
|||
{ |
|||
value |= 1 << 1; |
|||
} |
|||
|
|||
if (transparencyFlag) |
|||
{ |
|||
value |= 1; |
|||
} |
|||
|
|||
return value; |
|||
} |
|||
} |
|||
} |
|||
@ -1,94 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Buffers.Binary; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Gif |
|||
{ |
|||
/// <summary>
|
|||
/// The Graphic Control Extension contains parameters used when
|
|||
/// processing a graphic rendering block.
|
|||
/// </summary>
|
|||
internal readonly struct GifGraphicsControlExtension |
|||
{ |
|||
public const int Size = 8; |
|||
|
|||
public GifGraphicsControlExtension( |
|||
DisposalMethod disposalMethod, |
|||
bool transparencyFlag, |
|||
ushort delayTime, |
|||
byte transparencyIndex) |
|||
{ |
|||
this.DisposalMethod = disposalMethod; |
|||
this.TransparencyFlag = transparencyFlag; |
|||
this.DelayTime = delayTime; |
|||
this.TransparencyIndex = transparencyIndex; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the disposal method which indicates the way in which the
|
|||
/// graphic is to be treated after being displayed.
|
|||
/// </summary>
|
|||
public DisposalMethod DisposalMethod { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whether transparency flag is to be set.
|
|||
/// This indicates whether a transparency index is given in the Transparent Index field.
|
|||
/// (This field is the least significant bit of the byte.)
|
|||
/// </summary>
|
|||
public bool TransparencyFlag { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the delay time.
|
|||
/// If not 0, this field specifies the number of hundredths (1/100) of a second to
|
|||
/// wait before continuing with the processing of the Data Stream.
|
|||
/// The clock starts ticking immediately after the graphic is rendered.
|
|||
/// </summary>
|
|||
public ushort DelayTime { get; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the transparency index.
|
|||
/// The Transparency Index is such that when encountered, the corresponding pixel
|
|||
/// of the display device is not modified and processing goes on to the next pixel.
|
|||
/// </summary>
|
|||
public byte TransparencyIndex { get; } |
|||
|
|||
public byte PackField() |
|||
{ |
|||
PackedField field = default; |
|||
|
|||
field.SetBits(3, 3, (int)this.DisposalMethod); // 1-3 : Reserved, 4-6 : Disposal
|
|||
|
|||
// TODO: Allow this as an option.
|
|||
field.SetBit(6, false); // 7 : User input - 0 = none
|
|||
field.SetBit(7, this.TransparencyFlag); // 8: Has transparent.
|
|||
|
|||
return field.Byte; |
|||
} |
|||
|
|||
public void WriteTo(Span<byte> buffer) |
|||
{ |
|||
buffer[0] = GifConstants.ExtensionIntroducer; |
|||
buffer[1] = GifConstants.GraphicControlLabel; |
|||
buffer[2] = 4; // Block Size
|
|||
buffer[3] = this.PackField(); // Packed Field
|
|||
BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(4, 2), this.DelayTime); // Delay Time
|
|||
buffer[6] = this.TransparencyIndex; |
|||
buffer[7] = GifConstants.Terminator; |
|||
} |
|||
|
|||
public static GifGraphicsControlExtension Parse(ReadOnlySpan<byte> buffer) |
|||
{ |
|||
// We've already read the Extension Introducer introducer & Graphic Control Label
|
|||
// Start from the block size (0)
|
|||
byte packed = buffer[1]; |
|||
|
|||
return new GifGraphicsControlExtension( |
|||
disposalMethod: (DisposalMethod)((packed & 0x1C) >> 2), |
|||
delayTime: BinaryPrimitives.ReadUInt16LittleEndian(buffer.Slice(2, 2)), |
|||
transparencyIndex: buffer[4], |
|||
transparencyFlag: (packed & 0x01) == 1); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,22 @@ |
|||
using System; |
|||
|
|||
namespace SixLabors.ImageSharp.Formats.Gif |
|||
{ |
|||
/// <summary>
|
|||
/// A base interface for GIF extensions.
|
|||
/// </summary>
|
|||
public interface IGifExtension |
|||
{ |
|||
/// <summary>
|
|||
/// Gets the label identifying the extensions.
|
|||
/// </summary>
|
|||
byte Label { get; } |
|||
|
|||
/// <summary>
|
|||
/// Writes the extension data to the buffer.
|
|||
/// </summary>
|
|||
/// <param name="buffer">The buffer to write the extension to.</param>
|
|||
/// <returns>The number of bytes written to the buffer.</returns>
|
|||
int WriteTo(Span<byte> buffer); |
|||
} |
|||
} |
|||
@ -1,364 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Buffers.Binary; |
|||
using System.IO; |
|||
using System.Text; |
|||
|
|||
namespace SixLabors.ImageSharp.IO |
|||
{ |
|||
/// <summary>
|
|||
/// Equivalent of <see cref="BinaryReader"/>, but with either endianness.
|
|||
/// No data is buffered in the reader; the client may seek within the stream at will.
|
|||
/// </summary>
|
|||
internal class EndianBinaryReader : IDisposable |
|||
{ |
|||
/// <summary>
|
|||
/// Buffer used for temporary storage before conversion into primitives
|
|||
/// </summary>
|
|||
private readonly byte[] storageBuffer = new byte[16]; |
|||
|
|||
/// <summary>
|
|||
/// Whether or not this reader has been disposed yet.
|
|||
/// </summary>
|
|||
private bool disposed; |
|||
|
|||
/// <summary>
|
|||
/// The endianness used to read data
|
|||
/// </summary>
|
|||
private readonly Endianness endianness; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="EndianBinaryReader"/> class.
|
|||
/// Constructs a new binary reader with the given bit converter, reading
|
|||
/// to the given stream, using the given encoding.
|
|||
/// </summary>
|
|||
/// <param name="endianness">Endianness to use when reading data</param>
|
|||
/// <param name="stream">Stream to read data from</param>
|
|||
public EndianBinaryReader(Endianness endianness, Stream stream) |
|||
{ |
|||
Guard.NotNull(stream, nameof(stream)); |
|||
Guard.IsTrue(stream.CanRead, nameof(stream), "Stream isn't readable"); |
|||
|
|||
this.BaseStream = stream; |
|||
this.endianness = endianness; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the underlying stream of the EndianBinaryReader.
|
|||
/// </summary>
|
|||
public Stream BaseStream { get; } |
|||
|
|||
/// <summary>
|
|||
/// Closes the reader, including the underlying stream.
|
|||
/// </summary>
|
|||
public void Close() |
|||
{ |
|||
this.Dispose(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Seeks within the stream.
|
|||
/// </summary>
|
|||
/// <param name="offset">Offset to seek to.</param>
|
|||
/// <param name="origin">Origin of seek operation.</param>
|
|||
public void Seek(int offset, SeekOrigin origin) |
|||
{ |
|||
this.CheckDisposed(); |
|||
this.BaseStream.Seek(offset, origin); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reads a single byte from the stream.
|
|||
/// </summary>
|
|||
/// <returns>The byte read</returns>
|
|||
public byte ReadByte() |
|||
{ |
|||
this.ReadInternal(this.storageBuffer, 1); |
|||
return this.storageBuffer[0]; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reads a single signed byte from the stream.
|
|||
/// </summary>
|
|||
/// <returns>The byte read</returns>
|
|||
public sbyte ReadSByte() |
|||
{ |
|||
this.ReadInternal(this.storageBuffer, 1); |
|||
return unchecked((sbyte)this.storageBuffer[0]); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reads a boolean from the stream. 1 byte is read.
|
|||
/// </summary>
|
|||
/// <returns>The boolean read</returns>
|
|||
public bool ReadBoolean() |
|||
{ |
|||
this.ReadInternal(this.storageBuffer, 1); |
|||
|
|||
return this.storageBuffer[0] != 0; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reads a 16-bit signed integer from the stream, using the bit converter
|
|||
/// for this reader. 2 bytes are read.
|
|||
/// </summary>
|
|||
/// <returns>The 16-bit integer read</returns>
|
|||
public short ReadInt16() |
|||
{ |
|||
this.ReadInternal(this.storageBuffer, 2); |
|||
|
|||
return (this.endianness == Endianness.BigEndian) |
|||
? BinaryPrimitives.ReadInt16BigEndian(this.storageBuffer) |
|||
: BinaryPrimitives.ReadInt16LittleEndian(this.storageBuffer); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reads a 32-bit signed integer from the stream, using the bit converter
|
|||
/// for this reader. 4 bytes are read.
|
|||
/// </summary>
|
|||
/// <returns>The 32-bit integer read</returns>
|
|||
public int ReadInt32() |
|||
{ |
|||
this.ReadInternal(this.storageBuffer, 4); |
|||
|
|||
return (this.endianness == Endianness.BigEndian) |
|||
? BinaryPrimitives.ReadInt32BigEndian(this.storageBuffer) |
|||
: BinaryPrimitives.ReadInt32LittleEndian(this.storageBuffer); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reads a 64-bit signed integer from the stream, using the bit converter
|
|||
/// for this reader. 8 bytes are read.
|
|||
/// </summary>
|
|||
/// <returns>The 64-bit integer read</returns>
|
|||
public long ReadInt64() |
|||
{ |
|||
this.ReadInternal(this.storageBuffer, 8); |
|||
|
|||
return (this.endianness == Endianness.BigEndian) |
|||
? BinaryPrimitives.ReadInt64BigEndian(this.storageBuffer) |
|||
: BinaryPrimitives.ReadInt64LittleEndian(this.storageBuffer); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reads a 16-bit unsigned integer from the stream, using the bit converter
|
|||
/// for this reader. 2 bytes are read.
|
|||
/// </summary>
|
|||
/// <returns>The 16-bit unsigned integer read</returns>
|
|||
public ushort ReadUInt16() |
|||
{ |
|||
this.ReadInternal(this.storageBuffer, 2); |
|||
|
|||
return (this.endianness == Endianness.BigEndian) |
|||
? BinaryPrimitives.ReadUInt16BigEndian(this.storageBuffer) |
|||
: BinaryPrimitives.ReadUInt16LittleEndian(this.storageBuffer); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reads a 32-bit unsigned integer from the stream, using the bit converter
|
|||
/// for this reader. 4 bytes are read.
|
|||
/// </summary>
|
|||
/// <returns>The 32-bit unsigned integer read</returns>
|
|||
public uint ReadUInt32() |
|||
{ |
|||
this.ReadInternal(this.storageBuffer, 4); |
|||
|
|||
return (this.endianness == Endianness.BigEndian) |
|||
? BinaryPrimitives.ReadUInt32BigEndian(this.storageBuffer) |
|||
: BinaryPrimitives.ReadUInt32LittleEndian(this.storageBuffer); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reads a 64-bit unsigned integer from the stream, using the bit converter
|
|||
/// for this reader. 8 bytes are read.
|
|||
/// </summary>
|
|||
/// <returns>The 64-bit unsigned integer read</returns>
|
|||
public ulong ReadUInt64() |
|||
{ |
|||
this.ReadInternal(this.storageBuffer, 8); |
|||
|
|||
return (this.endianness == Endianness.BigEndian) |
|||
? BinaryPrimitives.ReadUInt64BigEndian(this.storageBuffer) |
|||
: BinaryPrimitives.ReadUInt64LittleEndian(this.storageBuffer); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reads a single-precision floating-point value from the stream, using the bit converter
|
|||
/// for this reader. 4 bytes are read.
|
|||
/// </summary>
|
|||
/// <returns>The floating point value read</returns>
|
|||
public unsafe float ReadSingle() |
|||
{ |
|||
int intValue = this.ReadInt32(); |
|||
|
|||
return *((float*)&intValue); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reads a double-precision floating-point value from the stream, using the bit converter
|
|||
/// for this reader. 8 bytes are read.
|
|||
/// </summary>
|
|||
/// <returns>The floating point value read</returns>
|
|||
public unsafe double ReadDouble() |
|||
{ |
|||
long value = this.ReadInt64(); |
|||
|
|||
return *((double*)&value); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reads the specified number of bytes into the given buffer, starting at
|
|||
/// the given index.
|
|||
/// </summary>
|
|||
/// <param name="buffer">The buffer to copy data into</param>
|
|||
/// <param name="index">The first index to copy data into</param>
|
|||
/// <param name="count">The number of bytes to read</param>
|
|||
/// <returns>The number of bytes actually read. This will only be less than
|
|||
/// the requested number of bytes if the end of the stream is reached.
|
|||
/// </returns>
|
|||
public int Read(byte[] buffer, int index, int count) |
|||
{ |
|||
this.CheckDisposed(); |
|||
|
|||
Guard.NotNull(this.storageBuffer, nameof(this.storageBuffer)); |
|||
Guard.MustBeGreaterThanOrEqualTo(index, 0, nameof(index)); |
|||
Guard.MustBeGreaterThanOrEqualTo(count, 0, nameof(count)); |
|||
Guard.IsFalse(count + index > buffer.Length, nameof(buffer.Length), "Not enough space in buffer for specified number of bytes starting at specified index."); |
|||
|
|||
int read = 0; |
|||
while (count > 0) |
|||
{ |
|||
int block = this.BaseStream.Read(buffer, index, count); |
|||
if (block == 0) |
|||
{ |
|||
return read; |
|||
} |
|||
|
|||
index += block; |
|||
read += block; |
|||
count -= block; |
|||
} |
|||
|
|||
return read; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reads the specified number of bytes, returning them in a new byte array.
|
|||
/// If not enough bytes are available before the end of the stream, this
|
|||
/// method will return what is available.
|
|||
/// </summary>
|
|||
/// <param name="count">The number of bytes to read</param>
|
|||
/// <returns>The bytes read</returns>
|
|||
public byte[] ReadBytes(int count) |
|||
{ |
|||
this.CheckDisposed(); |
|||
Guard.MustBeGreaterThanOrEqualTo(count, 0, nameof(count)); |
|||
|
|||
byte[] ret = new byte[count]; |
|||
int index = 0; |
|||
while (index < count) |
|||
{ |
|||
int read = this.BaseStream.Read(ret, index, count - index); |
|||
|
|||
// Stream has finished half way through. That's fine, return what we've got.
|
|||
if (read == 0) |
|||
{ |
|||
byte[] copy = new byte[index]; |
|||
Buffer.BlockCopy(ret, 0, copy, 0, index); |
|||
return copy; |
|||
} |
|||
|
|||
index += read; |
|||
} |
|||
|
|||
return ret; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reads the specified number of bytes, returning them in a new byte array.
|
|||
/// If not enough bytes are available before the end of the stream, this
|
|||
/// method will throw an IOException.
|
|||
/// </summary>
|
|||
/// <param name="count">The number of bytes to read</param>
|
|||
/// <returns>The bytes read</returns>
|
|||
public byte[] ReadBytesOrThrow(int count) |
|||
{ |
|||
byte[] ret = new byte[count]; |
|||
this.ReadInternal(ret, count); |
|||
return ret; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Disposes of the underlying stream.
|
|||
/// </summary>
|
|||
public void Dispose() |
|||
{ |
|||
if (!this.disposed) |
|||
{ |
|||
this.disposed = true; |
|||
((IDisposable)this.BaseStream).Dispose(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Checks whether or not the reader has been disposed, throwing an exception if so.
|
|||
/// </summary>
|
|||
private void CheckDisposed() |
|||
{ |
|||
if (this.disposed) |
|||
{ |
|||
throw new ObjectDisposedException(nameof(EndianBinaryReader)); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reads the given number of bytes from the stream, throwing an exception
|
|||
/// if they can't all be read.
|
|||
/// </summary>
|
|||
/// <param name="data">Buffer to read into</param>
|
|||
/// <param name="size">Number of bytes to read</param>
|
|||
private void ReadInternal(byte[] data, int size) |
|||
{ |
|||
this.CheckDisposed(); |
|||
int index = 0; |
|||
while (index < size) |
|||
{ |
|||
int read = this.BaseStream.Read(data, index, size - index); |
|||
if (read == 0) |
|||
{ |
|||
throw new EndOfStreamException($"End of stream reached with {size - index} byte{(size - index == 1 ? "s" : string.Empty)} left to read."); |
|||
} |
|||
|
|||
index += read; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reads the given number of bytes from the stream if possible, returning
|
|||
/// the number of bytes actually read, which may be less than requested if
|
|||
/// (and only if) the end of the stream is reached.
|
|||
/// </summary>
|
|||
/// <param name="data">Buffer to read into</param>
|
|||
/// <param name="size">Number of bytes to read</param>
|
|||
/// <returns>Number of bytes actually read</returns>
|
|||
private int TryReadInternal(byte[] data, int size) |
|||
{ |
|||
this.CheckDisposed(); |
|||
int index = 0; |
|||
while (index < size) |
|||
{ |
|||
int read = this.BaseStream.Read(data, index, size - index); |
|||
if (read == 0) |
|||
{ |
|||
return index; |
|||
} |
|||
|
|||
index += read; |
|||
} |
|||
|
|||
return index; |
|||
} |
|||
} |
|||
} |
|||
@ -1,303 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Buffers.Binary; |
|||
using System.IO; |
|||
|
|||
namespace SixLabors.ImageSharp.IO |
|||
{ |
|||
/// <summary>
|
|||
/// Equivalent of <see cref="BinaryWriter"/>, but with either endianness
|
|||
/// </summary>
|
|||
internal class EndianBinaryWriter : IDisposable |
|||
{ |
|||
/// <summary>
|
|||
/// Buffer used for temporary storage during conversion from primitives
|
|||
/// </summary>
|
|||
private readonly byte[] buffer = new byte[16]; |
|||
|
|||
/// <summary>
|
|||
/// The endianness used to write the data
|
|||
/// </summary>
|
|||
private readonly Endianness endianness; |
|||
|
|||
/// <summary>
|
|||
/// Whether or not this writer has been disposed yet.
|
|||
/// </summary>
|
|||
private bool disposed; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="EndianBinaryWriter"/> class
|
|||
/// with the given bit converter, writing to the given stream, using the given encoding.
|
|||
/// </summary>
|
|||
/// <param name="endianness">Endianness to use when writing data</param>
|
|||
/// <param name="stream">Stream to write data to</param>
|
|||
public EndianBinaryWriter(Endianness endianness, Stream stream) |
|||
{ |
|||
Guard.NotNull(stream, nameof(stream)); |
|||
Guard.IsTrue(stream.CanWrite, nameof(stream), "Stream isn't writable"); |
|||
|
|||
this.BaseStream = stream; |
|||
this.endianness = endianness; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the underlying stream of the EndianBinaryWriter.
|
|||
/// </summary>
|
|||
public Stream BaseStream { get; } |
|||
|
|||
/// <summary>
|
|||
/// Closes the writer, including the underlying stream.
|
|||
/// </summary>
|
|||
public void Close() |
|||
{ |
|||
this.Dispose(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Flushes the underlying stream.
|
|||
/// </summary>
|
|||
public void Flush() |
|||
{ |
|||
this.CheckDisposed(); |
|||
this.BaseStream.Flush(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Seeks within the stream.
|
|||
/// </summary>
|
|||
/// <param name="offset">Offset to seek to.</param>
|
|||
/// <param name="origin">Origin of seek operation.</param>
|
|||
public void Seek(int offset, SeekOrigin origin) |
|||
{ |
|||
this.CheckDisposed(); |
|||
this.BaseStream.Seek(offset, origin); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes a boolean value to the stream. 1 byte is written.
|
|||
/// </summary>
|
|||
/// <param name="value">The value to write</param>
|
|||
public void Write(bool value) |
|||
{ |
|||
this.buffer[0] = value ? (byte)1 : (byte)0; |
|||
|
|||
this.WriteInternal(this.buffer, 1); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes a 16-bit signed integer to the stream, using the bit converter
|
|||
/// for this writer. 2 bytes are written.
|
|||
/// </summary>
|
|||
/// <param name="value">The value to write</param>
|
|||
public void Write(short value) |
|||
{ |
|||
if (this.endianness == Endianness.BigEndian) |
|||
{ |
|||
BinaryPrimitives.WriteInt16BigEndian(this.buffer, value); |
|||
} |
|||
else |
|||
{ |
|||
BinaryPrimitives.WriteInt16LittleEndian(this.buffer, value); |
|||
} |
|||
|
|||
this.WriteInternal(this.buffer, 2); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes a 32-bit signed integer to the stream, using the bit converter
|
|||
/// for this writer. 4 bytes are written.
|
|||
/// </summary>
|
|||
/// <param name="value">The value to write</param>
|
|||
public void Write(int value) |
|||
{ |
|||
if (this.endianness == Endianness.BigEndian) |
|||
{ |
|||
BinaryPrimitives.WriteInt32BigEndian(this.buffer, value); |
|||
} |
|||
else |
|||
{ |
|||
BinaryPrimitives.WriteInt32LittleEndian(this.buffer, value); |
|||
} |
|||
|
|||
this.WriteInternal(this.buffer, 4); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes a 64-bit signed integer to the stream, using the bit converter
|
|||
/// for this writer. 8 bytes are written.
|
|||
/// </summary>
|
|||
/// <param name="value">The value to write</param>
|
|||
public void Write(long value) |
|||
{ |
|||
if (this.endianness == Endianness.BigEndian) |
|||
{ |
|||
BinaryPrimitives.WriteInt64BigEndian(this.buffer, value); |
|||
} |
|||
else |
|||
{ |
|||
BinaryPrimitives.WriteInt64LittleEndian(this.buffer, value); |
|||
} |
|||
|
|||
this.WriteInternal(this.buffer, 8); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes a 16-bit unsigned integer to the stream, using the bit converter
|
|||
/// for this writer. 2 bytes are written.
|
|||
/// </summary>
|
|||
/// <param name="value">The value to write</param>
|
|||
public void Write(ushort value) |
|||
{ |
|||
if (this.endianness == Endianness.BigEndian) |
|||
{ |
|||
BinaryPrimitives.WriteUInt16BigEndian(this.buffer, value); |
|||
} |
|||
else |
|||
{ |
|||
BinaryPrimitives.WriteUInt16LittleEndian(this.buffer, value); |
|||
} |
|||
|
|||
this.WriteInternal(this.buffer, 2); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes a 32-bit unsigned integer to the stream, using the bit converter
|
|||
/// for this writer. 4 bytes are written.
|
|||
/// </summary>
|
|||
/// <param name="value">The value to write</param>
|
|||
public void Write(uint value) |
|||
{ |
|||
if (this.endianness == Endianness.BigEndian) |
|||
{ |
|||
BinaryPrimitives.WriteUInt32BigEndian(this.buffer, value); |
|||
} |
|||
else |
|||
{ |
|||
BinaryPrimitives.WriteUInt32LittleEndian(this.buffer, value); |
|||
} |
|||
|
|||
this.WriteInternal(this.buffer, 4); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes a 64-bit unsigned integer to the stream, using the bit converter
|
|||
/// for this writer. 8 bytes are written.
|
|||
/// </summary>
|
|||
/// <param name="value">The value to write</param>
|
|||
public void Write(ulong value) |
|||
{ |
|||
if (this.endianness == Endianness.BigEndian) |
|||
{ |
|||
BinaryPrimitives.WriteUInt64BigEndian(this.buffer, value); |
|||
} |
|||
else |
|||
{ |
|||
BinaryPrimitives.WriteUInt64LittleEndian(this.buffer, value); |
|||
} |
|||
|
|||
this.WriteInternal(this.buffer, 8); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes a single-precision floating-point value to the stream, using the bit converter
|
|||
/// for this writer. 4 bytes are written.
|
|||
/// </summary>
|
|||
/// <param name="value">The value to write</param>
|
|||
public unsafe void Write(float value) |
|||
{ |
|||
this.Write(*((int*)&value)); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes a double-precision floating-point value to the stream, using the bit converter
|
|||
/// for this writer. 8 bytes are written.
|
|||
/// </summary>
|
|||
/// <param name="value">The value to write</param>
|
|||
public unsafe void Write(double value) |
|||
{ |
|||
this.Write(*((long*)&value)); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes a signed byte to the stream.
|
|||
/// </summary>
|
|||
/// <param name="value">The value to write</param>
|
|||
public void Write(byte value) |
|||
{ |
|||
this.buffer[0] = value; |
|||
this.WriteInternal(this.buffer, 1); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes an unsigned byte to the stream.
|
|||
/// </summary>
|
|||
/// <param name="value">The value to write</param>
|
|||
public void Write(sbyte value) |
|||
{ |
|||
this.buffer[0] = unchecked((byte)value); |
|||
this.WriteInternal(this.buffer, 1); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes an array of bytes to the stream.
|
|||
/// </summary>
|
|||
/// <param name="value">The values to write</param>
|
|||
/// <exception cref="ArgumentNullException">value is null</exception>
|
|||
public void Write(byte[] value) |
|||
{ |
|||
Guard.NotNull(value, nameof(value)); |
|||
this.WriteInternal(value, value.Length); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes a portion of an array of bytes to the stream.
|
|||
/// </summary>
|
|||
/// <param name="value">An array containing the bytes to write</param>
|
|||
/// <param name="offset">The index of the first byte to write within the array</param>
|
|||
/// <param name="count">The number of bytes to write</param>
|
|||
/// <exception cref="ArgumentNullException">value is null</exception>
|
|||
public void Write(byte[] value, int offset, int count) |
|||
{ |
|||
this.CheckDisposed(); |
|||
this.BaseStream.Write(value, offset, count); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Disposes of the underlying stream.
|
|||
/// </summary>
|
|||
public void Dispose() |
|||
{ |
|||
if (!this.disposed) |
|||
{ |
|||
this.Flush(); |
|||
this.disposed = true; |
|||
((IDisposable)this.BaseStream).Dispose(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Checks whether or not the writer has been disposed, throwing an exception if so.
|
|||
/// </summary>
|
|||
private void CheckDisposed() |
|||
{ |
|||
if (this.disposed) |
|||
{ |
|||
throw new ObjectDisposedException(nameof(EndianBinaryWriter)); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes the specified number of bytes from the start of the given byte array,
|
|||
/// after checking whether or not the writer has been disposed.
|
|||
/// </summary>
|
|||
/// <param name="bytes">The array of bytes to write from</param>
|
|||
/// <param name="length">The number of bytes to write</param>
|
|||
private void WriteInternal(byte[] bytes, int length) |
|||
{ |
|||
this.CheckDisposed(); |
|||
this.BaseStream.Write(bytes, 0, length); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,21 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using SixLabors.ImageSharp.Formats.Gif; |
|||
|
|||
using Xunit; |
|||
|
|||
namespace SixLabors.ImageSharp.Tests.Formats.Gif |
|||
{ |
|||
public class GifGraphicControlExtensionTests |
|||
{ |
|||
[Fact] |
|||
public void TestPackedValue() |
|||
{ |
|||
Assert.Equal(0, GifGraphicControlExtension.GetPackedValue(DisposalMethod.Unspecified, false, false)); |
|||
Assert.Equal(11, GifGraphicControlExtension.GetPackedValue(DisposalMethod.RestoreToBackground, true, true)); |
|||
Assert.Equal(4, GifGraphicControlExtension.GetPackedValue(DisposalMethod.NotDispose, false, false)); |
|||
Assert.Equal(14, GifGraphicControlExtension.GetPackedValue(DisposalMethod.RestoreToPrevious, true, false)); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,24 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using SixLabors.ImageSharp.Formats.Gif; |
|||
|
|||
using Xunit; |
|||
|
|||
namespace SixLabors.ImageSharp.Tests.Formats.Gif |
|||
{ |
|||
public class GifImageDescriptorTests |
|||
{ |
|||
[Fact] |
|||
public void TestPackedValue() |
|||
{ |
|||
Assert.Equal(128, GifImageDescriptor.GetPackedValue(true, false, false, 1)); // localColorTable
|
|||
Assert.Equal(64, GifImageDescriptor.GetPackedValue(false, true, false, 1)); // interfaceFlag
|
|||
Assert.Equal(32, GifImageDescriptor.GetPackedValue(false, false, true, 1)); // sortFlag
|
|||
Assert.Equal(224, GifImageDescriptor.GetPackedValue(true, true, true, 1)); // all
|
|||
Assert.Equal(7, GifImageDescriptor.GetPackedValue(false, false, false, 8)); |
|||
Assert.Equal(227, GifImageDescriptor.GetPackedValue(true, true, true, 4)); |
|||
Assert.Equal(231, GifImageDescriptor.GetPackedValue(true, true, true, 8)); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,23 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using SixLabors.ImageSharp.Formats.Gif; |
|||
|
|||
using Xunit; |
|||
|
|||
namespace SixLabors.ImageSharp.Tests.Formats.Gif |
|||
{ |
|||
public class GifLogicalScreenDescriptorTests |
|||
{ |
|||
[Fact] |
|||
public void TestPackedValue() |
|||
{ |
|||
Assert.Equal(0, GifLogicalScreenDescriptor.GetPackedValue(false, 0, false, 0)); |
|||
Assert.Equal(128, GifLogicalScreenDescriptor.GetPackedValue(true, 0, false, 0)); // globalColorTableFlag
|
|||
Assert.Equal(8, GifLogicalScreenDescriptor.GetPackedValue(false, 0, true, 0)); // sortFlag
|
|||
Assert.Equal(48, GifLogicalScreenDescriptor.GetPackedValue(false, 3, false, 0)); |
|||
Assert.Equal(155, GifLogicalScreenDescriptor.GetPackedValue(true, 1, true, 3)); |
|||
Assert.Equal(55, GifLogicalScreenDescriptor.GetPackedValue(false, 3, false, 7)); |
|||
} |
|||
} |
|||
} |
|||
@ -1,97 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.IO; |
|||
using SixLabors.ImageSharp.IO; |
|||
using Xunit; |
|||
|
|||
namespace SixLabors.ImageSharp.Tests.IO |
|||
{ |
|||
public class EndianBinaryReaderWriterTests |
|||
{ |
|||
[Fact] |
|||
public void RoundtripSingles() |
|||
{ |
|||
foreach ((Endianness endianness, byte[] bytes) in new[] { |
|||
(Endianness.BigEndian, new byte[] { 64, 73, 15, 219 }), |
|||
(Endianness.LittleEndian, new byte[] { 219, 15, 73, 64 }) |
|||
}) |
|||
{ |
|||
var stream = new MemoryStream(); |
|||
|
|||
using (var writer = new EndianBinaryWriter(endianness, stream)) |
|||
{ |
|||
writer.Write((float)Math.PI); |
|||
|
|||
Assert.Equal(bytes, stream.ToArray()); |
|||
} |
|||
} |
|||
} |
|||
|
|||
[Fact] |
|||
public void RoundtripDoubles() |
|||
{ |
|||
foreach ((Endianness endianness, byte[] bytes) in new[] { |
|||
(Endianness.BigEndian, new byte[] { 64, 9, 33, 251, 84, 68, 45, 24 }), |
|||
(Endianness.LittleEndian, new byte[] { 24, 45, 68, 84, 251, 33, 9, 64 }) |
|||
}) |
|||
{ |
|||
var stream = new MemoryStream(); |
|||
|
|||
using (var writer = new EndianBinaryWriter(endianness, stream)) |
|||
{ |
|||
writer.Write(Math.PI); |
|||
|
|||
Assert.Equal(bytes, stream.ToArray()); |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Ensures that the data written through a binary writer can be read back through the reader
|
|||
/// </summary>
|
|||
[Fact] |
|||
public void RoundtripValues() |
|||
{ |
|||
foreach (Endianness endianness in new[] { Endianness.BigEndian, Endianness.LittleEndian }) |
|||
{ |
|||
var stream = new MemoryStream(); |
|||
|
|||
var writer = new EndianBinaryWriter(endianness, stream); |
|||
|
|||
writer.Write(true); // Bool
|
|||
writer.Write((byte)1); // Byte
|
|||
writer.Write((short)1); // Int16
|
|||
writer.Write(1); // Int32
|
|||
writer.Write(1L); // Int64
|
|||
writer.Write(1f); // Single
|
|||
writer.Write(1d); // Double
|
|||
writer.Write((sbyte)1); // SByte
|
|||
writer.Write((ushort)1); // UInt16
|
|||
writer.Write((uint)1); // UInt32
|
|||
writer.Write(1UL); // ULong
|
|||
|
|||
Assert.Equal(43, stream.Length); |
|||
|
|||
stream.Position = 0; |
|||
|
|||
var reader = new EndianBinaryReader(endianness, stream); |
|||
|
|||
Assert.True(reader.ReadBoolean()); // Bool
|
|||
Assert.Equal((byte)1, reader.ReadByte()); // Byte
|
|||
Assert.Equal((short)1, reader.ReadInt16()); // Int16
|
|||
Assert.Equal(1, reader.ReadInt32()); // Int32
|
|||
Assert.Equal(1L, reader.ReadInt64()); // Int64
|
|||
Assert.Equal(1f, reader.ReadSingle()); // Single
|
|||
Assert.Equal(1d, reader.ReadDouble()); // Double
|
|||
Assert.Equal((sbyte)1, reader.ReadSByte()); // SByte
|
|||
Assert.Equal((ushort)1, reader.ReadUInt16()); // UInt16
|
|||
Assert.Equal((uint)1, reader.ReadUInt32()); // UInt32
|
|||
Assert.Equal(1UL, reader.ReadUInt64()); // ULong
|
|||
|
|||
stream.Dispose(); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
Loading…
Reference in new issue