Implement basic bilinear resizing

Author: UnknownShadow200

MCGalaxy/util/Imaging/ImageDecoder.cs

@@ -30,12 +30,58 @@ public sealed class SimpleBitmap //: IBitmap2D
         public void AllocatePixels() {
             pixels = new Pixel[Width * Height];
         }
+        
+        public SimpleBitmap ResizeBilinear(int dstWidth, int dstHeight) {
+            SimpleBitmap dst = new SimpleBitmap();
+            dst.Width  = dstWidth;
+            dst.Height = dstHeight;
+            dst.AllocatePixels();
+            
+            float scaleX = (float)Width  / dstWidth;
+            float scaleY = (float)Height / dstHeight;
+            
+            int maxX = Width  - 1;
+            int maxY = Height - 1;
+            
+            Pixel[] pixels = this.pixels;
+            int stride = this.Width;
+            int dstI = 0;
+            
+            for (int y = 0; y < dstHeight; y++)
+            {
+                float sy = (y + 0.5f) * scaleY;
+                int  sy0 = (int)sy; if (sy0 >= maxY) sy0 = maxY;
+                int  sy1 = sy0 + 1; if (sy1 >= maxY) sy1 = maxY;
+                float dy = sy - sy0;
+                
+                for (int x = 0; x < dstWidth; x++)
+                {
+                    float sx = (x + 0.5f) * scaleX;
+                    int  sx0 = (int)sx; if (sx0 >= maxX) sx0 = maxX;
+                    int  sx1 = sx0 + 1; if (sx1 >= maxX) sx1 = maxX;
+                    float dx = sx - sx0;
+                    
+                    Pixel p00 = pixels[sy0 * stride + sx0];
+                    Pixel p10 = pixels[sy0 * stride + sx1];
+                    Pixel p01 = pixels[sy1 * stride + sx0];
+                    Pixel p11 = pixels[sy1 * stride + sx1];
+                    
+                    Pixel p;
+                    p.R = (byte)((p00.R * (1-dx) * (1-dy)) + (p10.R * dx * (1-dy)) + (p01.R * (1-dx) * dy) + (p11.R * dx * dy));
+                    p.G = (byte)((p00.G * (1-dx) * (1-dy)) + (p10.G * dx * (1-dy)) + (p01.G * (1-dx) * dy) + (p11.G * dx * dy));
+                    p.B = (byte)((p00.B * (1-dx) * (1-dy)) + (p10.B * dx * (1-dy)) + (p01.B * (1-dx) * dy) + (p11.B * dx * dy));
+                    p.A = (byte)((p00.A * (1-dx) * (1-dy)) + (p10.A * dx * (1-dy)) + (p01.A * (1-dx) * dy) + (p11.A * dx * dy));
+                    dst.pixels[dstI++] = p;
+                }
+            }
+            return dst;
+        }
     }
 
     public abstract class ImageDecoder
     {
         protected byte[] buf_data;
-        protected int buf_offset, buf_length;       
+        protected int buf_offset, buf_length;
 
         /// <summary> Attempts to advance next read offset by 'amount', then returns current read offset </summary>
         protected int AdvanceOffset(int amount) {

MCGalaxy/util/Imaging/JpegDecoder.cs

@@ -382,10 +382,12 @@ void DecodeMCUs(byte[] src, SimpleBitmap bmp) {
             }
         }
 
-        static byte ByteClamp(float v) {
-            if (v < 0) return 0;
-            if (v > 255) return 255;
-            return (byte)v;
+        static byte ByteClamp(float value) {
+            int n = (int)value;
+            
+            if (n <   0) return   0;
+            if (n > 255) return 255;
+            return (byte)n;
         }
 
         void DecodeBlock(JpegComponent comp, byte[] src, int* block) {