From 4da1ebd55d05339d8ee79025e1dac51db30ee1d0 Mon Sep 17 00:00:00 2001 From: Olivia Date: Sat, 17 Dec 2016 20:27:01 +0100 Subject: [PATCH] Fixing missing parameter documentation warnings. --- src/ImageSharp/Drawing/DrawImage.cs | 2 +- src/ImageSharp/Drawing/Fill.cs | 1 + .../Drawing/Processors/FillShapeProcessor.cs | 1 + .../Formats/Jpg/Components/Block8x8F.cs | 70 +++++++++++++------ .../Formats/Jpg/Components/Bytes.cs | 4 ++ 5 files changed, 54 insertions(+), 24 deletions(-) diff --git a/src/ImageSharp/Drawing/DrawImage.cs b/src/ImageSharp/Drawing/DrawImage.cs index d29415d37..a192ea7b5 100644 --- a/src/ImageSharp/Drawing/DrawImage.cs +++ b/src/ImageSharp/Drawing/DrawImage.cs @@ -1,4 +1,4 @@ -// +// // Copyright (c) James Jackson-South and contributors. // Licensed under the Apache License, Version 2.0. // diff --git a/src/ImageSharp/Drawing/Fill.cs b/src/ImageSharp/Drawing/Fill.cs index 65b506f5e..4a96b20ac 100644 --- a/src/ImageSharp/Drawing/Fill.cs +++ b/src/ImageSharp/Drawing/Fill.cs @@ -56,6 +56,7 @@ namespace ImageSharp /// The source. /// The brush. /// The shape. + /// The graphics options. /// The Image public static Image Fill(this Image source, IBrush brush, IShape shape, GraphicsOptions options) where TColor : struct, IPackedPixel diff --git a/src/ImageSharp/Drawing/Processors/FillShapeProcessor.cs b/src/ImageSharp/Drawing/Processors/FillShapeProcessor.cs index 0dee0095e..3209ce9c5 100644 --- a/src/ImageSharp/Drawing/Processors/FillShapeProcessor.cs +++ b/src/ImageSharp/Drawing/Processors/FillShapeProcessor.cs @@ -35,6 +35,7 @@ namespace ImageSharp.Drawing.Processors /// /// The brush. /// The shape. + /// The graphics options. public FillShapeProcessor(IBrush brush, IShape shape, GraphicsOptions options) { this.poly = shape; diff --git a/src/ImageSharp/Formats/Jpg/Components/Block8x8F.cs b/src/ImageSharp/Formats/Jpg/Components/Block8x8F.cs index c27de4ca9..9c982e88b 100644 --- a/src/ImageSharp/Formats/Jpg/Components/Block8x8F.cs +++ b/src/ImageSharp/Formats/Jpg/Components/Block8x8F.cs @@ -85,6 +85,8 @@ namespace ImageSharp.Formats /// /// Load raw 32bit floating point data from source /// + /// block pointer + /// source [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe void LoadFrom(Block8x8F* blockPtr, MutableSpan source) { @@ -94,6 +96,8 @@ namespace ImageSharp.Formats /// /// Copy raw 32bit floating point data to dest /// + /// block pointer + /// destination [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe void CopyTo(Block8x8F* blockPtr, MutableSpan dest) { @@ -103,6 +107,7 @@ namespace ImageSharp.Formats /// /// Load raw 32bit floating point data from source /// + /// source [MethodImpl(MethodImplOptions.AggressiveInlining)] public unsafe void LoadFrom(MutableSpan source) { @@ -115,6 +120,7 @@ namespace ImageSharp.Formats /// /// Copy raw 32bit floating point data to dest /// + /// destination [MethodImpl(MethodImplOptions.AggressiveInlining)] public unsafe void CopyTo(MutableSpan dest) { @@ -127,6 +133,7 @@ namespace ImageSharp.Formats /// /// Copy raw 32bit floating point data to dest /// + /// destination [MethodImpl(MethodImplOptions.AggressiveInlining)] public unsafe void CopyTo(float[] dest) { @@ -161,17 +168,17 @@ namespace ImageSharp.Formats /// Apply floating point IDCT transformation into dest, using a temporary block 'temp' provided by the caller (optimization) /// /// Destination - /// Temporary block provided by the caller - public void TransformIDCTInto(ref Block8x8F dest, ref Block8x8F temp) + /// Temporary block provided by the caller + public void TransformIDCTInto(ref Block8x8F dest, ref Block8x8F tempBlockPtr) { - this.TransposeInto(ref temp); - temp.IDCT8x4_LeftPart(ref dest); - temp.IDCT8x4_RightPart(ref dest); + this.TransposeInto(ref tempBlockPtr); + tempBlockPtr.IDCT8x4_LeftPart(ref dest); + tempBlockPtr.IDCT8x4_RightPart(ref dest); - dest.TransposeInto(ref temp); + dest.TransposeInto(ref tempBlockPtr); - temp.IDCT8x4_LeftPart(ref dest); - temp.IDCT8x4_RightPart(ref dest); + tempBlockPtr.IDCT8x4_LeftPart(ref dest); + tempBlockPtr.IDCT8x4_RightPart(ref dest); dest.MultiplyAllInplace(C_0_125); } @@ -179,6 +186,8 @@ namespace ImageSharp.Formats /// /// Pointer-based "Indexer" (getter part) /// + /// block pointer + /// index [MethodImpl(MethodImplOptions.AggressiveInlining)] internal static unsafe float GetScalarAt(Block8x8F* blockPtr, int idx) { @@ -189,6 +198,9 @@ namespace ImageSharp.Formats /// /// Pointer-based "Indexer" (setter part) /// + /// block pointer + /// index + /// value [MethodImpl(MethodImplOptions.AggressiveInlining)] internal static unsafe void SetScalarAt(Block8x8F* blockPtr, int idx, float value) { @@ -196,11 +208,17 @@ namespace ImageSharp.Formats fp[idx] = value; } + /// + /// Un-zig + /// + /// block pointer + /// qt pointer + /// unzig pointer [MethodImpl(MethodImplOptions.AggressiveInlining)] - internal static unsafe void UnZig(Block8x8F* block, Block8x8F* qt, int* unzigPtr) + internal static unsafe void UnZig(Block8x8F* blockPtr, Block8x8F* qtPtr, int* unzigPtr) { - float* b = (float*)block; - float* qtp = (float*)qt; + float* b = (float*)blockPtr; + float* qtp = (float*)qtPtr; for (int zig = 0; zig < BlockF.BlockSize; zig++) { float* unzigPos = b + unzigPtr[zig]; @@ -213,6 +231,7 @@ namespace ImageSharp.Formats /// /// Copy raw 32bit floating point data to dest /// + /// destination internal unsafe void CopyTo(MutableSpan dest) { fixed (Vector4* ptr = &this.V0L) @@ -228,6 +247,7 @@ namespace ImageSharp.Formats /// /// Load raw 32bit floating point data from source /// + /// source internal unsafe void LoadFrom(MutableSpan source) { fixed (Vector4* ptr = &this.V0L) @@ -301,8 +321,9 @@ namespace ImageSharp.Formats /// Original source: /// https://github.com/norishigefukushima/dct_simd/blob/master/dct/dct8x8_simd.cpp#L261 /// + /// destination block pointer [MethodImpl(MethodImplOptions.AggressiveInlining)] - internal void IDCT8x4_RightPart(ref Block8x8F d) + internal void IDCT8x4_RightPart(ref Block8x8F destBlockPtr) { Vector4 my1 = this.V1R; Vector4 my7 = this.V7R; @@ -342,14 +363,14 @@ namespace ImageSharp.Formats my1 = mz1 + mz2; my2 = mz1 - mz2; - d.V0R = my0 + mb0; - d.V7R = my0 - mb0; - d.V1R = my1 + mb1; - d.V6R = my1 - mb1; - d.V2R = my2 + mb2; - d.V5R = my2 - mb2; - d.V3R = my3 + mb3; - d.V4R = my3 - mb3; + destBlockPtr.V0R = my0 + mb0; + destBlockPtr.V7R = my0 - mb0; + destBlockPtr.V1R = my1 + mb1; + destBlockPtr.V6R = my1 - mb1; + destBlockPtr.V2R = my2 + mb2; + destBlockPtr.V5R = my2 - mb2; + destBlockPtr.V3R = my3 + mb3; + destBlockPtr.V4R = my3 - mb3; } /// @@ -383,12 +404,15 @@ namespace ImageSharp.Formats /// /// Level shift by +128, clip to [0, 255], and write to buffer. /// + /// color buffer + /// stride offset + /// temp block pointer [MethodImpl(MethodImplOptions.AggressiveInlining)] - internal unsafe void CopyColorsTo(MutableSpan buffer, int stride, Block8x8F* temp) + internal unsafe void CopyColorsTo(MutableSpan buffer, int stride, Block8x8F* tempBlockPtr) { - this.TransformByteConvetibleColorValuesInto(ref *temp); + this.TransformByteConvetibleColorValuesInto(ref *tempBlockPtr); - float* src = (float*)temp; + float* src = (float*)tempBlockPtr; for (int i = 0; i < 8; i++) { buffer[0] = (byte)src[0]; diff --git a/src/ImageSharp/Formats/Jpg/Components/Bytes.cs b/src/ImageSharp/Formats/Jpg/Components/Bytes.cs index 796ef1804..312e690be 100644 --- a/src/ImageSharp/Formats/Jpg/Components/Bytes.cs +++ b/src/ImageSharp/Formats/Jpg/Components/Bytes.cs @@ -56,6 +56,8 @@ namespace ImageSharp.Formats /// /// ReadByteStuffedByte is like ReadByte but is for byte-stuffed Huffman data. /// + /// input stream + /// error code /// The internal byte ReadByteStuffedByte(Stream inputStream, out JpegDecoderCore.ErrorCodes errorCode) { @@ -112,6 +114,7 @@ namespace ImageSharp.Formats /// /// Returns the next byte, whether buffered or not buffered. It does not care about byte stuffing. /// + /// input stream /// The [MethodImpl(MethodImplOptions.AggressiveInlining)] internal byte ReadByte(Stream inputStream) @@ -131,6 +134,7 @@ namespace ImageSharp.Formats /// Fills up the bytes buffer from the underlying stream. /// It should only be called when there are no unread bytes in bytes. /// + /// input stream [MethodImpl(MethodImplOptions.AggressiveInlining)] internal void Fill(Stream inputStream) {