Fixing declarations

Author: LuisAlfredo92

src/ImageSharp/Formats/Qoi/QoiDecoderCore.cs

@@ -56,6 +56,9 @@ public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken
             VerticalResolution = this.header.Height,
             ResolutionUnits = PixelResolutionUnit.AspectRatio
         };
+        QoiMetadata qoiMetadata = metadata.GetQoiMetadata();
+        qoiMetadata.Channels = this.header.Channels;
+        qoiMetadata.ColorSpace = this.header.ColorSpace;
         Image<TPixel> image = new(this.configuration, (int)this.header.Width, (int)this.header.Height, metadata);
         Buffer2D<TPixel> pixels = image.GetRootFramePixelBuffer();
 
@@ -112,8 +115,8 @@ private void ProcessHeader(BufferedReadStream stream)
         }
 
         // These numbers are in Big Endian so we have to reverse them to get the real number
-        uint width = BinaryPrimitives.ReadUInt32BigEndian(widthBytes),
-            height = BinaryPrimitives.ReadUInt32BigEndian(heightBytes);
+        uint width = BinaryPrimitives.ReadUInt32BigEndian(widthBytes);
+        uint height = BinaryPrimitives.ReadUInt32BigEndian(heightBytes);
         if (width == 0 || height == 0)
         {
             throw new InvalidImageContentException(
@@ -126,8 +129,6 @@ private void ProcessHeader(BufferedReadStream stream)
             ThrowInvalidImageContentException();
         }
 
-        PixelTypeInfo pixelType = new(8 * channels);
-
         int colorSpace = stream.ReadByte();
         if (colorSpace is -1 or (not 0 and not 1))
         {
@@ -201,9 +202,9 @@ private void ProcessPixels<TPixel>(BufferedReadStream stream, Buffer2D<TPixel> p
 
                             // Get one pixel from the difference (-2..1) of the previous pixel
                             case QoiChunk.QoiOpDiff:
-                                byte redDifference = (byte)((operationByte & 0b00110000) >> 4),
-                                    greenDifference = (byte)((operationByte & 0b00001100) >> 2),
-                                    blueDifference = (byte)(operationByte & 0b00000011);
+                                byte redDifference = (byte)((operationByte & 0b00110000) >> 4);
+                                byte greenDifference = (byte)((operationByte & 0b00001100) >> 2);
+                                byte blueDifference = (byte)(operationByte & 0b00000011);
                                 readPixel = previousPixel with
                                 {
                                     R = (byte)Numerics.Modulo256(previousPixel.R + (redDifference - 2)),
@@ -218,13 +219,13 @@ private void ProcessPixels<TPixel>(BufferedReadStream stream, Buffer2D<TPixel> p
                             // Get green difference in 6 bits and red and blue differences
                             // depending on the green one
                             case QoiChunk.QoiOpLuma:
-                                byte diffGreen = (byte)(operationByte & 0b00111111),
-                                    currentGreen = (byte)Numerics.Modulo256(previousPixel.G + (diffGreen - 32)),
-                                    nextByte = (byte)stream.ReadByte(),
-                                    diffRedDG = (byte)(nextByte >> 4),
-                                    diffBlueDG = (byte)(nextByte & 0b00001111),
-                                    currentRed = (byte)Numerics.Modulo256(diffRedDG - 8 + (diffGreen - 32) + previousPixel.R),
-                                    currentBlue = (byte)Numerics.Modulo256(diffBlueDG - 8 + (diffGreen - 32) + previousPixel.B);
+                                byte diffGreen = (byte)(operationByte & 0b00111111);
+                                byte currentGreen = (byte)Numerics.Modulo256(previousPixel.G + (diffGreen - 32));
+                                byte nextByte = (byte)stream.ReadByte();
+                                byte diffRedDG = (byte)(nextByte >> 4);
+                                byte diffBlueDG = (byte)(nextByte & 0b00001111);
+                                byte currentRed = (byte)Numerics.Modulo256(diffRedDG - 8 + (diffGreen - 32) + previousPixel.R);
+                                byte currentBlue = (byte)Numerics.Modulo256(diffBlueDG - 8 + (diffGreen - 32) + previousPixel.B);
                                 readPixel = previousPixel with { R = currentRed, B = currentBlue, G = currentGreen };
                                 pixel.FromRgba32(readPixel);
                                 pixelArrayPosition = GetArrayPosition(readPixel);

src/ImageSharp/Formats/Qoi/QoiEncoderCore.cs

@@ -141,9 +141,9 @@ private void WritePixels<TPixel>(Image<TPixel> image, Stream stream)
                     // Since it wasn't found on the previously seen pixels, we save it
                     previouslySeenPixels[pixelArrayPosition] = currentRgba32;
 
-                    sbyte diffRed = (sbyte)(currentRgba32.R - previousPixel.R),
-                        diffGreen = (sbyte)(currentRgba32.G - previousPixel.G),
-                        diffBlue = (sbyte)(currentRgba32.B - previousPixel.B);
+                    sbyte diffRed = (sbyte)(currentRgba32.R - previousPixel.R);
+                    sbyte diffGreen = (sbyte)(currentRgba32.G - previousPixel.G);
+                    sbyte diffBlue = (sbyte)(currentRgba32.B - previousPixel.B);
 
                     // If so, we do a QOI_OP_DIFF
                     if (diffRed is >= -2 and <= 1 &&
@@ -152,27 +152,27 @@ private void WritePixels<TPixel>(Image<TPixel> image, Stream stream)
                         currentRgba32.A == previousPixel.A)
                     {
                         // Bottom limit is -2, so we add 2 to make it equal to 0
-                        byte dr = (byte)(diffRed + 2),
-                            dg = (byte)(diffGreen + 2),
-                            db = (byte)(diffBlue + 2),
-                            valueToWrite = (byte)((byte)QoiChunk.QoiOpDiff | (dr << 4) | (dg << 2) | db);
+                        byte dr = (byte)(diffRed + 2);
+                        byte dg = (byte)(diffGreen + 2);
+                        byte db = (byte)(diffBlue + 2);
+                        byte valueToWrite = (byte)((byte)QoiChunk.QoiOpDiff | (dr << 4) | (dg << 2) | db);
                         stream.WriteByte(valueToWrite);
                     }
                     else
                     {
                         // else, we check if the green difference is less than -32..31 and the rest -8..7
                         // If so, we do a QOI_OP_LUMA
-                        sbyte diffRedGreen = (sbyte)(diffRed - diffGreen),
-                            diffBlueGreen = (sbyte)(diffBlue - diffGreen);
+                        sbyte diffRedGreen = (sbyte)(diffRed - diffGreen);
+                        sbyte diffBlueGreen = (sbyte)(diffBlue - diffGreen);
                         if (diffGreen is >= -32 and <= 31 &&
                             diffRedGreen is >= -8 and <= 7 &&
                             diffBlueGreen is >= -8 and <= 7 &&
                             currentRgba32.A == previousPixel.A)
                         {
-                            byte dr_dg = (byte)(diffRedGreen + 8),
-                                db_dg = (byte)(diffBlueGreen + 8),
-                                byteToWrite1 = (byte)((byte)QoiChunk.QoiOpLuma | (diffGreen + 32)),
-                                byteToWrite2 = (byte)((dr_dg << 4) | db_dg);
+                            byte dr_dg = (byte)(diffRedGreen + 8);
+                            byte db_dg = (byte)(diffBlueGreen + 8);
+                            byte byteToWrite1 = (byte)((byte)QoiChunk.QoiOpLuma | (diffGreen + 32));
+                            byte byteToWrite2 = (byte)((dr_dg << 4) | db_dg);
                             stream.WriteByte(byteToWrite1);
                             stream.WriteByte(byteToWrite2);
                         }