Help with Bitmap decoder

I've been working on a bitmap decoder, but my algorithm for processing the pixel data doesn't seem to be quite right:

    public IntPtr ReadPixels(Stream fs, int offset, int width, int height, int bpp)
    {
        IntPtr bBits;

        int pixelCount = bpp * width * height;
        int Row = 0;
        decimal value = ((bpp*width)/32)/4;
        int RowSize = (int)Math.Ceiling(value);
        int ArraySize = RowSize * Math.Abs(height);
        int Col = 0;
        Byte[] BMPData = new Byte[ArraySize];

        BinaryReader r = new BinaryReader(fs);
   开发者_StackOverflow     r.BaseStream.Seek(offset, SeekOrigin.Begin);

        while (Row < height)
        {
            Byte ReadByte;

            if (!(Col >= RowSize))
            {                       
                ReadByte = r.ReadByte();
                BMPData[(Row * RowSize) + Col] = ReadByte;
                Col += 1;                    
            }

            if (Col >= RowSize)
            {
                Col = 0;
                Row += 1;
            }
        }

        bBits = System.Runtime.InteropServices.Marshal.AllocHGlobal(BMPData.Length);
        System.Runtime.InteropServices.Marshal.Copy(BMPData, 0, bBits, BMPData.Length);

        return bBits;
}

I can process only monochrome bitmaps and on some, parts of the bitmap is processed fine. None are compressed and they are rendered upside down and flipped around. I really could do with some help on this one.

    decimal value = ((bpp*width)/32)/4;
    int RowSize = (int)Math.Ceiling(value);

That isn't correct. Your RowSize variable is actually called "stride". You compute it like this:

    int bytes = (width * bitsPerPixel + 7) / 8;
    int stride = 4 * ((bytes + 3) / 4);

You are ignoring the stride.

Image rows can be padded to the left with additional Bytes to make their size divide by a number such as (1 = no padding, 2, 4, 8 = default for many images, 16, ...).

Also, images can be a rectangle region within a larger image, making the "padding" between lines in the smaller image even larger (since the stride is the larger image's stride). - In this case the image can also have an offset for its start point within the buffer.

Better practice is:

// Overload this method 3 time for different bit per SUB-pixel values (8, 16, or 32)
// = (byte, int, float)
// SUB-pixel != pixel (= 1 3 or 4 sub-pixels (grey or RGB or BGR or BGRA or RGBA or ARGB or ABGR)
unsafe
{
    byte[] buffer = image.Buffer;
    int stride = image.buffer.Length / image.PixelHeight;
    // or int stride = image.LineSize; (or something like that)

    fixed (float* regionStart = (float*)(void*)buffer) // or byte* or int* depending on datatype
    {
        for (int y = 0; y < height; y++) // height in pixels
        {
            // float* and float or byte* and byte or int* and int
            float* currentPos
                = regionStart + offset / SizeOf(float) + stride / SizeOf(float) * y;

            for (int x = 0; x < width; x++) // width in pixels
            {
                for (int chan = 0; chan < channel; chan++) // 1, 3 or 4 channels
                {
                    // DO NOT USE DECIMAL - you want accurate image values
                    // with best performance - primative types
                    // not a .NET complex type used for nice looking values for users e.g. 12.34
                    // instead use actual sub pixel type (float/int/byte) or double instead!
                    var currentValue = value;

                    currentPos++;
                }
            }
        }
    }
}

I find something I don't understand:

decimal value = ((bpp*width)/32)/4;
int RowSize = (int)Math.Ceiling(value);

RowSize, in my opinion, should be (bpp*width) / 8 + (bpp%8==0?0:1)