public static unsafe void Copy <T>(Span <T> source, Span <T> destination, int count) where T : struct { DebugGuard.MustBeLessThanOrEqualTo(count, source.Length, nameof(count)); DebugGuard.MustBeLessThanOrEqualTo(count, destination.Length, nameof(count)); ref byte srcRef = ref Unsafe.As <T, byte>(ref source.DangerousGetPinnableReference());
public BasicArrayBuffer(T[] array, int length, TestMemoryAllocator allocator) { this.allocator = allocator; DebugGuard.MustBeLessThanOrEqualTo(length, array.Length, nameof(length)); this.Array = array; this.Length = length; }
public static unsafe void Copy <T>(Span <T> source, Span <T> destination, int count) where T : struct { DebugGuard.MustBeLessThanOrEqualTo(count, source.Length, nameof(count)); DebugGuard.MustBeLessThanOrEqualTo(count, destination.Length, nameof(count)); ref byte srcRef = ref Unsafe.As <T, byte>(ref MemoryMarshal.GetReference(source));
public int ReadSignedValue(int nBits) { DebugGuard.MustBeGreaterThan(nBits, 0, nameof(nBits)); DebugGuard.MustBeLessThanOrEqualTo(nBits, 32, nameof(nBits)); int value = (int)this.ReadValue(nBits); return(this.ReadValue(1) != 0 ? -value : value); }
private static void WriteRun(ReadOnlySpan <byte> rowSpan, int start, int runLength, Span <byte> compressedRowSpan, int compressedRowPos) { DebugGuard.MustBeLessThanOrEqualTo(runLength, 127, nameof(runLength)); sbyte headerByte = (sbyte)(-runLength + 1); compressedRowSpan[compressedRowPos] = (byte)headerByte; compressedRowSpan[compressedRowPos + 1] = rowSpan[start]; }
private static void WriteLiteralRun(ReadOnlySpan <byte> rowSpan, int end, int literalRunLength, Span <byte> compressedRowSpan, int compressedRowPos) { DebugGuard.MustBeLessThanOrEqualTo(literalRunLength, 127, nameof(literalRunLength)); int literalRunStart = end - literalRunLength; sbyte runLength = (sbyte)(literalRunLength - 1); compressedRowSpan[compressedRowPos] = (byte)runLength; rowSpan.Slice(literalRunStart, literalRunLength).CopyTo(compressedRowSpan.Slice(compressedRowPos + 1)); }
public void MustBeLessThanOrEqualTo_IsGreater_ThrowsNoException() { var exception = Assert.Throws <ArgumentOutOfRangeException>(() => { DebugGuard.MustBeLessThanOrEqualTo(2, 1, "myParamName"); }); Assert.Equal("myParamName", exception.ParamName); Assert.True(exception.Message.Contains($"Value must be less than or equal to 1.")); }
public BufferArea(Buffer2D <T> destinationBuffer, Rectangle rectangle) { DebugGuard.MustBeGreaterThanOrEqualTo(rectangle.X, 0, nameof(rectangle)); DebugGuard.MustBeGreaterThanOrEqualTo(rectangle.Y, 0, nameof(rectangle)); DebugGuard.MustBeLessThanOrEqualTo(rectangle.Width, destinationBuffer.Width, nameof(rectangle)); DebugGuard.MustBeLessThanOrEqualTo(rectangle.Height, destinationBuffer.Height, nameof(rectangle)); this.DestinationBuffer = destinationBuffer; this.Rectangle = rectangle; }
/// <summary> /// Initializes a new instance of the <see cref="ArraySlice{T}"/> struct. /// </summary> /// <param name="data">The underlying data buffer.</param> /// <param name="start">The offset position in the underlying buffer this slice was created from.</param> /// <param name="length">The number of items in the slice.</param> public ArraySlice(T[] data, int start, int length) { DebugGuard.MustBeGreaterThanOrEqualTo(start, 0, nameof(start)); DebugGuard.MustBeLessThanOrEqualTo(length, data.Length, nameof(length)); DebugGuard.MustBeLessThanOrEqualTo(start + length, data.Length, nameof(this.data)); this.data = data; this.Start = start; this.Length = length; }
public Buffer2DRegion(Buffer2D <T> buffer, Rectangle rectangle) { DebugGuard.MustBeGreaterThanOrEqualTo(rectangle.X, 0, nameof(rectangle)); DebugGuard.MustBeGreaterThanOrEqualTo(rectangle.Y, 0, nameof(rectangle)); DebugGuard.MustBeLessThanOrEqualTo(rectangle.Width, buffer.Width, nameof(rectangle)); DebugGuard.MustBeLessThanOrEqualTo(rectangle.Height, buffer.Height, nameof(rectangle)); this.Buffer = buffer; this.Rectangle = rectangle; }
public BufferArea <T> GetSubArea(Rectangle rectangle) { DebugGuard.MustBeLessThanOrEqualTo(rectangle.Width, this.Rectangle.Width, nameof(rectangle)); DebugGuard.MustBeLessThanOrEqualTo(rectangle.Height, this.Rectangle.Height, nameof(rectangle)); int x = this.Rectangle.X + rectangle.X; int y = this.Rectangle.Y + rectangle.Y; rectangle = new Rectangle(x, y, rectangle.Width, rectangle.Height); return(new BufferArea <T>(this.DestinationBuffer, rectangle)); }
/// <summary> /// Decompresses image data into the supplied buffer. /// </summary> /// <param name="stream">The <see cref="Stream" /> to read image data from.</param> /// <param name="stripOffset">The strip offset of stream.</param> /// <param name="stripByteCount">The number of bytes to read from the input stream.</param> /// <param name="stripHeight">The height of the strip.</param> /// <param name="buffer">The output buffer for uncompressed data.</param> public void Decompress(BufferedReadStream stream, ulong stripOffset, ulong stripByteCount, int stripHeight, Span <byte> buffer) { DebugGuard.MustBeLessThanOrEqualTo(stripOffset, (ulong)long.MaxValue, nameof(stripOffset)); DebugGuard.MustBeLessThanOrEqualTo(stripByteCount, (ulong)long.MaxValue, nameof(stripByteCount)); stream.Seek((long)stripOffset, SeekOrigin.Begin); this.Decompress(stream, (int)stripByteCount, stripHeight, buffer); if ((long)stripOffset + (long)stripByteCount < stream.Position) { TiffThrowHelper.ThrowImageFormatException("Out of range when reading a strip."); } }
/// <summary> /// Gets the width of the image frame. /// </summary> /// <param name="exifProfile">The image frame exif profile.</param> /// <returns>The image width.</returns> private static int GetImageWidth(ExifProfile exifProfile) { IExifValue <Number> width = exifProfile.GetValue(ExifTag.ImageWidth); if (width == null) { TiffThrowHelper.ThrowImageFormatException("The TIFF image frame is missing the ImageWidth"); } DebugGuard.MustBeLessThanOrEqualTo((ulong)width.Value, (ulong)int.MaxValue, nameof(ExifTag.ImageWidth)); return((int)width.Value); }
public uint ReadValue(int nBits) { DebugGuard.MustBeGreaterThan(nBits, 0, nameof(nBits)); DebugGuard.MustBeLessThanOrEqualTo(nBits, 32, nameof(nBits)); uint v = 0; while (nBits-- > 0) { v |= (uint)this.GetBit(0x80) << nBits; } return(v); }
internal Enumerator(ArraySlice <T> slice) { DebugGuard.NotNull(slice.data, nameof(slice.data)); DebugGuard.MustBeGreaterThanOrEqualTo(slice.Start, 0, nameof(slice.Start)); DebugGuard.MustBeGreaterThanOrEqualTo(slice.Length, 0, nameof(slice.Length)); DebugGuard.MustBeLessThanOrEqualTo( slice.Start + slice.Length, slice.data.Length, nameof(slice.data.Length)); this.array = slice.data; this.start = slice.Start; this.end = slice.Start + slice.Length; this.current = slice.Start - 1; }
/// <summary> /// Calculates the size (in bytes) for a pixel buffer using the determined color format. /// </summary> /// <param name="width">The width for the desired pixel buffer.</param> /// <param name="height">The height for the desired pixel buffer.</param> /// <param name="plane">The index of the plane for planar image configuration (or zero for chunky).</param> /// <returns>The size (in bytes) of the required pixel buffer.</returns> private int CalculateStripBufferSize(int width, int height, int plane = -1) { DebugGuard.MustBeLessThanOrEqualTo(plane, 3, nameof(plane)); int bitsPerPixel = 0; if (this.PlanarConfiguration == TiffPlanarConfiguration.Chunky) { DebugGuard.IsTrue(plane == -1, "Expected Chunky planar."); bitsPerPixel = this.BitsPerPixel; } else { switch (plane) { case 0: bitsPerPixel = this.BitsPerSample.Channel0; break; case 1: bitsPerPixel = this.BitsPerSample.Channel1; break; case 2: bitsPerPixel = this.BitsPerSample.Channel2; break; default: TiffThrowHelper.ThrowNotSupported("More then 3 color channels are not supported"); break; } } int bytesPerRow = ((width * bitsPerPixel) + 7) / 8; return(bytesPerRow * height); }
public Span <float> ScanOddEven(float y, Span <ScanEdge> edges, Span <float> intersections) { DebugGuard.MustBeLessThanOrEqualTo(edges.Length, MaxEdges, "edges.Length"); int intersectionCounter = 0; int offset = 0; Span <int> active = this.ActiveEdges; for (int i = 0; i < active.Length; i++) { int flaggedIdx = active[i]; int edgeIdx = Strip(flaggedIdx); ref ScanEdge edge = ref edges[edgeIdx]; float x = edge.GetX(y); if (IsEntering(flaggedIdx)) { Emit(x, edge.EmitV0, intersections, ref intersectionCounter); } else if (IsLeaving(flaggedIdx)) { Emit(x, edge.EmitV1, intersections, ref intersectionCounter); offset++; // Do not offset: continue; } else { // Emit once: intersections[intersectionCounter++] = x; } // Unmask and offset: active[i - offset] = edgeIdx; }
public void Update(byte[] buffer, int offset, int count) { DebugGuard.NotNull(buffer, nameof(buffer)); DebugGuard.MustBeGreaterThanOrEqualTo(offset, 0, nameof(offset)); DebugGuard.MustBeGreaterThanOrEqualTo(count, 0, nameof(count)); DebugGuard.MustBeLessThan(offset, buffer.Length, nameof(offset)); DebugGuard.MustBeLessThanOrEqualTo(offset + count, buffer.Length, nameof(count)); // (By Per Bothner) uint s1 = this.checksum & 0xFFFF; uint s2 = this.checksum >> 16; while (count > 0) { // We can defer the modulo operation: // s1 maximally grows from 65521 to 65521 + 255 * 3800 // s2 maximally grows by 3800 * median(s1) = 2090079800 < 2^31 int n = 3800; if (n > count) { n = count; } count -= n; while (--n >= 0) { s1 = s1 + (uint)(buffer[offset++] & 0xff); s2 = s2 + s1; } s1 %= Base; s2 %= Base; } this.checksum = (s2 << 16) | s1; }
/// <summary> /// Initializes a new instance of the <see cref="BasicArrayBuffer{T}"/> class /// </summary> /// <param name="array">The array</param> /// <param name="length">The length of the buffer</param> public BasicArrayBuffer(T[] array, int length) { DebugGuard.MustBeLessThanOrEqualTo(length, array.Length, nameof(length)); this.Array = array; this.Length = length; }
public void MustBeLessThanOrEqualTo_IsLessOrEqual_ThrowsNoException(int value, int max) { DebugGuard.MustBeLessThanOrEqualTo(value, max, "myParamName"); }