Improve performance of Tiff decoders

IldarKhayrutdinov · IldarKhayrutdinov · commit 1b32629e30c1 · 2019-08-22T11:14:33.000+03:00
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero1TiffColor.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero1TiffColor.cs
@@ -33,17 +33,18 @@ public static void Decode<TPixel>(byte[] data, Buffer2D<TPixel> pixels, int left
 
             for (int y = top; y < top + height; y++)
             {
+                Span<TPixel> buffer = pixels.GetRowSpan(y);
                 for (int x = left; x < left + width; x += 8)
                 {
                     byte b = data[offset++];
                     int maxShift = Math.Min(left + width - x, 8);
 
-                    for (int shift = 0; shift < maxShift; shift++)
+                    for (int shift = 0, index = x; shift < maxShift; shift++, index++)
                     {
                         int bit = (b >> (7 - shift)) & 1;
                         byte intensity = (bit == 1) ? (byte)255 : (byte)0;
                         color.FromRgba32(new Rgba32(intensity, intensity, intensity, 255));
-                        pixels[x + shift, y] = color;
+                        buffer[index] = color;
                     }
                 }
             }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero4TiffColor.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero4TiffColor.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -33,17 +34,19 @@ public static void Decode<TPixel>(byte[] data, Buffer2D<TPixel> pixels, int left
 
             for (int y = top; y < top + height; y++)
             {
+                Span<TPixel> buffer = pixels.GetRowSpan(y);
+
                 for (int x = left; x < left + width - 1; x += 2)
                 {
                     byte byteData = data[offset++];
 
                     byte intensity1 = (byte)(((byteData & 0xF0) >> 4) * 17);
                     color.FromRgba32(new Rgba32(intensity1, intensity1, intensity1, 255));
-                    pixels[x, y] = color;
+                    buffer[x] = color;
 
                     byte intensity2 = (byte)((byteData & 0x0F) * 17);
                     color.FromRgba32(new Rgba32(intensity2, intensity2, intensity2, 255));
-                    pixels[x + 1, y] = color;
+                    buffer[x + 1] = color;
                 }
 
                 if (isOddWidth)
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero8TiffColor.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZero8TiffColor.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -32,11 +33,13 @@ public static void Decode<TPixel>(byte[] data, Buffer2D<TPixel> pixels, int left
 
             for (int y = top; y < top + height; y++)
             {
+                Span<TPixel> buffer = pixels.GetRowSpan(y);
+
                 for (int x = left; x < left + width; x++)
                 {
                     byte intensity = data[offset++];
                     color.FromRgba32(new Rgba32(intensity, intensity, intensity, 255));
-                    pixels[x, y] = color;
+                    buffer[x] = color;
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZeroTiffColor.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/BlackIsZeroTiffColor.cs
@@ -36,12 +36,14 @@ public static void Decode<TPixel>(byte[] data, uint[] bitsPerSample, Buffer2D<TP
 
             for (int y = top; y < top + height; y++)
             {
+                Span<TPixel> buffer = pixels.GetRowSpan(y);
+
                 for (int x = left; x < left + width; x++)
                 {
                     int value = bitReader.ReadBits(bitsPerSample[0]);
                     float intensity = ((float)value) / factor;
                     color.FromVector4(new Vector4(intensity, intensity, intensity, 1.0f));
-                    pixels[x, y] = color;
+                    buffer[x] = color;
                 }
 
                 bitReader.NextRow();
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/PaletteTiffColor.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/PaletteTiffColor.cs
@@ -37,10 +37,12 @@ public static void Decode<TPixel>(byte[] data, uint[] bitsPerSample, uint[] colo
 
             for (int y = top; y < top + height; y++)
             {
+                Span<TPixel> buffer = pixels.GetRowSpan(y);
+
                 for (int x = left; x < left + width; x++)
                 {
                     int index = bitReader.ReadBits(bitsPerSample[0]);
-                    pixels[x, y] = palette[index];
+                    buffer[x] = palette[index];
                 }
 
                 bitReader.NextRow();
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb888TiffColor.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/Rgb888TiffColor.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -32,13 +33,15 @@ public static void Decode<TPixel>(byte[] data, Buffer2D<TPixel> pixels, int left
 
             for (int y = top; y < top + height; y++)
             {
+                Span<TPixel> buffer = pixels.GetRowSpan(y);
+
                 for (int x = left; x < left + width; x++)
                 {
                     byte r = data[offset++];
                     byte g = data[offset++];
                     byte b = data[offset++];
                     color.FromRgba32(new Rgba32(r, g, b, 255));
-                    pixels[x, y] = color;
+                    buffer[x] = color;
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbPlanarTiffColor.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbPlanarTiffColor.cs
@@ -40,13 +40,16 @@ public static void Decode<TPixel>(byte[][] data, uint[] bitsPerSample, Buffer2D<
 
             for (int y = top; y < top + height; y++)
             {
+                Span<TPixel> buffer = pixels.GetRowSpan(y);
+
                 for (int x = left; x < left + width; x++)
                 {
                     float r = ((float)rBitReader.ReadBits(bitsPerSample[0])) / rFactor;
                     float g = ((float)gBitReader.ReadBits(bitsPerSample[1])) / gFactor;
                     float b = ((float)bBitReader.ReadBits(bitsPerSample[2])) / bFactor;
                     color.FromVector4(new Vector4(r, g, b, 1.0f));
-                    pixels[x, y] = color;
+
+                    buffer[x] = color;
                 }
 
                 rBitReader.NextRow();
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbTiffColor.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/RgbTiffColor.cs
@@ -38,13 +38,16 @@ public static void Decode<TPixel>(byte[] data, uint[] bitsPerSample, Buffer2D<TP
 
             for (int y = top; y < top + height; y++)
             {
+                Span<TPixel> buffer = pixels.GetRowSpan(y);
+
                 for (int x = left; x < left + width; x++)
                 {
                     float r = ((float)bitReader.ReadBits(bitsPerSample[0])) / rFactor;
                     float g = ((float)bitReader.ReadBits(bitsPerSample[1])) / gFactor;
                     float b = ((float)bitReader.ReadBits(bitsPerSample[2])) / bFactor;
                     color.FromVector4(new Vector4(r, g, b, 1.0f));
-                    pixels[x, y] = color;
+
+                    buffer[x] = color;
                 }
 
                 bitReader.NextRow();
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero1TiffColor.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero1TiffColor.cs
@@ -33,17 +33,20 @@ public static void Decode<TPixel>(byte[] data, Buffer2D<TPixel> pixels, int left
 
             for (int y = top; y < top + height; y++)
             {
+                Span<TPixel> buffer = pixels.GetRowSpan(y);
+
                 for (int x = left; x < left + width; x += 8)
                 {
                     byte b = data[offset++];
                     int maxShift = Math.Min(left + width - x, 8);
 
-                    for (int shift = 0; shift < maxShift; shift++)
+                    for (int shift = 0, index = x; shift < maxShift; shift++, index++)
                     {
                         int bit = (b >> (7 - shift)) & 1;
                         byte intensity = (bit == 1) ? (byte)0 : (byte)255;
                         color.FromRgba32(new Rgba32(intensity, intensity, intensity, 255));
-                        pixels[x + shift, y] = color;
+
+                        buffer[index] = color;
                     }
                 }
             }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero4TiffColor.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero4TiffColor.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -33,17 +34,19 @@ public static void Decode<TPixel>(byte[] data, Buffer2D<TPixel> pixels, int left
 
             for (int y = top; y < top + height; y++)
             {
+                Span<TPixel> buffer = pixels.GetRowSpan(y);
+
                 for (int x = left; x < left + width - 1; x += 2)
                 {
                     byte byteData = data[offset++];
 
                     byte intensity1 = (byte)((15 - ((byteData & 0xF0) >> 4)) * 17);
                     color.FromRgba32(new Rgba32(intensity1, intensity1, intensity1, 255));
-                    pixels[x, y] = color;
+                    buffer[x] = color;
 
                     byte intensity2 = (byte)((15 - (byteData & 0x0F)) * 17);
                     color.FromRgba32(new Rgba32(intensity2, intensity2, intensity2, 255));
-                    pixels[x + 1, y] = color;
+                    buffer[x + 1] = color;
                 }
 
                 if (isOddWidth)
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero8TiffColor.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZero8TiffColor.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
@@ -32,11 +33,13 @@ public static void Decode<TPixel>(byte[] data, Buffer2D<TPixel> pixels, int left
 
             for (int y = top; y < top + height; y++)
             {
+                Span<TPixel> buffer = pixels.GetRowSpan(y);
+
                 for (int x = left; x < left + width; x++)
                 {
                     byte intensity = (byte)(255 - data[offset++]);
                     color.FromRgba32(new Rgba32(intensity, intensity, intensity, 255));
-                    pixels[x, y] = color;
+                    buffer[x] = color;
                 }
             }
         }
diff --git a/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZeroTiffColor.cs b/src/ImageSharp/Formats/Tiff/PhotometricInterpretation/WhiteIsZeroTiffColor.cs
@@ -36,12 +36,14 @@ public static void Decode<TPixel>(byte[] data, uint[] bitsPerSample, Buffer2D<TP
 
             for (int y = top; y < top + height; y++)
             {
+                Span<TPixel> buffer = pixels.GetRowSpan(y);
+
                 for (int x = left; x < left + width; x++)
                 {
                     int value = bitReader.ReadBits(bitsPerSample[0]);
                     float intensity = 1.0f - (((float)value) / factor);
                     color.FromVector4(new Vector4(intensity, intensity, intensity, 1.0f));
-                    pixels[x, y] = color;
+                    buffer[x] = color;
                 }
 
                 bitReader.NextRow();

Original file line number	Diff line number	Diff line change
`@@ -33,17 +33,18 @@ public static void Decode<TPixel>(byte[] data, Buffer2D<TPixel> pixels, int left`
`33`	`33`
`34`	`34`	`for (int y = top; y < top + height; y++)`
`35`	`35`	`{`
	`36`	`+ Span<TPixel> buffer = pixels.GetRowSpan(y);`
`36`	`37`	`for (int x = left; x < left + width; x += 8)`
`37`	`38`	`{`
`38`	`39`	`byte b = data[offset++];`
`39`	`40`	`int maxShift = Math.Min(left + width - x, 8);`
`40`	`41`
`41`		`- for (int shift = 0; shift < maxShift; shift++)`
	`42`	`+ for (int shift = 0, index = x; shift < maxShift; shift++, index++)`
`42`	`43`	`{`
`43`	`44`	`int bit = (b >> (7 - shift)) & 1;`
`44`	`45`	`byte intensity = (bit == 1) ? (byte)255 : (byte)0;`
`45`	`46`	`color.FromRgba32(new Rgba32(intensity, intensity, intensity, 255));`
`46`		`- pixels[x + shift, y] = color;`
	`47`	`+ buffer[index] = color;`
`47`	`48`	`}`
`48`	`49`	`}`
`49`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`// Copyright (c) Six Labors and contributors.`
`2`	`2`	`// Licensed under the Apache License, Version 2.0.`
`3`	`3`
	`4`	`+using System;`
`4`	`5`	`using System.Runtime.CompilerServices;`
`5`	`6`	`using SixLabors.ImageSharp.Memory;`
`6`	`7`	`using SixLabors.ImageSharp.PixelFormats;`
`@@ -32,11 +33,13 @@ public static void Decode<TPixel>(byte[] data, Buffer2D<TPixel> pixels, int left`
`32`	`33`
`33`	`34`	`for (int y = top; y < top + height; y++)`
`34`	`35`	`{`
	`36`	`+ Span<TPixel> buffer = pixels.GetRowSpan(y);`
	`37`	`+`
`35`	`38`	`for (int x = left; x < left + width; x++)`
`36`	`39`	`{`
`37`	`40`	`byte intensity = data[offset++];`
`38`	`41`	`color.FromRgba32(new Rgba32(intensity, intensity, intensity, 255));`
`39`		`- pixels[x, y] = color;`
	`42`	`+ buffer[x] = color;`
`40`	`43`	`}`
`41`	`44`	`}`
`42`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,12 +36,14 @@ public static void Decode<TPixel>(byte[] data, uint[] bitsPerSample, Buffer2D<TP`
`36`	`36`
`37`	`37`	`for (int y = top; y < top + height; y++)`
`38`	`38`	`{`
	`39`	`+ Span<TPixel> buffer = pixels.GetRowSpan(y);`
	`40`	`+`
`39`	`41`	`for (int x = left; x < left + width; x++)`
`40`	`42`	`{`
`41`	`43`	`int value = bitReader.ReadBits(bitsPerSample[0]);`
`42`	`44`	`float intensity = ((float)value) / factor;`
`43`	`45`	`color.FromVector4(new Vector4(intensity, intensity, intensity, 1.0f));`
`44`		`- pixels[x, y] = color;`
	`46`	`+ buffer[x] = color;`
`45`	`47`	`}`
`46`	`48`
`47`	`49`	`bitReader.NextRow();`
Original file line number	Diff line number	Diff line change
`@@ -37,10 +37,12 @@ public static void Decode<TPixel>(byte[] data, uint[] bitsPerSample, uint[] colo`
`37`	`37`
`38`	`38`	`for (int y = top; y < top + height; y++)`
`39`	`39`	`{`
	`40`	`+ Span<TPixel> buffer = pixels.GetRowSpan(y);`
	`41`	`+`
`40`	`42`	`for (int x = left; x < left + width; x++)`
`41`	`43`	`{`
`42`	`44`	`int index = bitReader.ReadBits(bitsPerSample[0]);`
`43`		`- pixels[x, y] = palette[index];`
	`45`	`+ buffer[x] = palette[index];`
`44`	`46`	`}`
`45`	`47`
`46`	`48`	`bitReader.NextRow();`
Original file line number	Diff line number	Diff line change
`@@ -40,13 +40,16 @@ public static void Decode<TPixel>(byte[][] data, uint[] bitsPerSample, Buffer2D<`
`40`	`40`
`41`	`41`	`for (int y = top; y < top + height; y++)`
`42`	`42`	`{`
	`43`	`+ Span<TPixel> buffer = pixels.GetRowSpan(y);`
	`44`	`+`
`43`	`45`	`for (int x = left; x < left + width; x++)`
`44`	`46`	`{`
`45`	`47`	`float r = ((float)rBitReader.ReadBits(bitsPerSample[0])) / rFactor;`
`46`	`48`	`float g = ((float)gBitReader.ReadBits(bitsPerSample[1])) / gFactor;`
`47`	`49`	`float b = ((float)bBitReader.ReadBits(bitsPerSample[2])) / bFactor;`
`48`	`50`	`color.FromVector4(new Vector4(r, g, b, 1.0f));`
`49`		`- pixels[x, y] = color;`
	`51`	`+`
	`52`	`+ buffer[x] = color;`
`50`	`53`	`}`
`51`	`54`
`52`	`55`	`rBitReader.NextRow();`
Original file line number	Diff line number	Diff line change
`@@ -38,13 +38,16 @@ public static void Decode<TPixel>(byte[] data, uint[] bitsPerSample, Buffer2D<TP`
`38`	`38`
`39`	`39`	`for (int y = top; y < top + height; y++)`
`40`	`40`	`{`
	`41`	`+ Span<TPixel> buffer = pixels.GetRowSpan(y);`
	`42`	`+`
`41`	`43`	`for (int x = left; x < left + width; x++)`
`42`	`44`	`{`
`43`	`45`	`float r = ((float)bitReader.ReadBits(bitsPerSample[0])) / rFactor;`
`44`	`46`	`float g = ((float)bitReader.ReadBits(bitsPerSample[1])) / gFactor;`
`45`	`47`	`float b = ((float)bitReader.ReadBits(bitsPerSample[2])) / bFactor;`
`46`	`48`	`color.FromVector4(new Vector4(r, g, b, 1.0f));`
`47`		`- pixels[x, y] = color;`
	`49`	`+`
	`50`	`+ buffer[x] = color;`
`48`	`51`	`}`
`49`	`52`
`50`	`53`	`bitReader.NextRow();`
Original file line number	Diff line number	Diff line change
`@@ -33,17 +33,20 @@ public static void Decode<TPixel>(byte[] data, Buffer2D<TPixel> pixels, int left`
`33`	`33`
`34`	`34`	`for (int y = top; y < top + height; y++)`
`35`	`35`	`{`
	`36`	`+ Span<TPixel> buffer = pixels.GetRowSpan(y);`
	`37`	`+`
`36`	`38`	`for (int x = left; x < left + width; x += 8)`
`37`	`39`	`{`
`38`	`40`	`byte b = data[offset++];`
`39`	`41`	`int maxShift = Math.Min(left + width - x, 8);`
`40`	`42`
`41`		`- for (int shift = 0; shift < maxShift; shift++)`
	`43`	`+ for (int shift = 0, index = x; shift < maxShift; shift++, index++)`
`42`	`44`	`{`
`43`	`45`	`int bit = (b >> (7 - shift)) & 1;`
`44`	`46`	`byte intensity = (bit == 1) ? (byte)0 : (byte)255;`
`45`	`47`	`color.FromRgba32(new Rgba32(intensity, intensity, intensity, 255));`
`46`		`- pixels[x + shift, y] = color;`
	`48`	`+`
	`49`	`+ buffer[index] = color;`
`47`	`50`	`}`
`48`	`51`	`}`
`49`	`52`	`}`