IntRead() public static method

Read a n*8 bits integer value to memory in native endian.
public static IntRead ( IntPtr src, int n ) : uint
src System.IntPtr
n int
return uint
        //           /** Unpack a color value from memory
        //              @param color	The color is returned here
        //              @param pf		Pixelformat in which to read the color
        //              @param src		Source memory location
        //           */
        //          protected static void UnpackColor(ref System.Drawing.Color color, PixelFormat pf,  IntPtr src) {
        //              UnpackColor(color.r, color.g, color.b, color.a, pf, src);
        //          }

        /** Unpack a color value from memory
         * @param r,g,b,a	The color is returned here (as byte)
         * @param pf		Pixelformat in which to read the color
         * @param src		Source memory location
         * @remarks     This function returns the color components in 8 bit precision,
         *    this will lose precision when coming from A2R10G10B10 or floating
         *    point formats.
         */
        unsafe public static void UnpackColor(ref byte r, ref byte g, ref byte b, ref byte a,
                                              PixelFormat pf, byte *src)
        {
            PixelFormatDescription des = PixelConverter.GetDescriptionFor(pf);

            if ((des.flags & PixelFormatFlags.NativeEndian) != 0)
            {
                // Shortcut for integer formats unpacking
                uint value = Bitwise.IntRead(src, des.elemBytes);
                if ((des.flags & PixelFormatFlags.Luminance) != 0)
                {
                    // Luminance format -- only rbits used
                    r = g = b = (byte)Bitwise.FixedToFixed((value & des.rmask) >> des.rshift, des.rbits, 8);
                }
                else
                {
                    r = (byte)Bitwise.FixedToFixed((value & des.rmask) >> des.rshift, des.rbits, 8);
                    g = (byte)Bitwise.FixedToFixed((value & des.gmask) >> des.gshift, des.gbits, 8);
                    b = (byte)Bitwise.FixedToFixed((value & des.bmask) >> des.bshift, des.bbits, 8);
                }
                if ((des.flags & PixelFormatFlags.HasAlpha) != 0)
                {
                    a = (byte)Bitwise.FixedToFixed((value & des.amask) >> des.ashift, des.abits, 8);
                }
                else
                {
                    a = 255; // No alpha, default a component to full
                }
            }
            else
            {
                // Do the operation with the more generic floating point
                float rr, gg, bb, aa;
                UnpackColor(out rr, out gg, out bb, out aa, pf, src);
                r = Bitwise.FloatToByteFixed(rr);
                g = Bitwise.FloatToByteFixed(gg);
                b = Bitwise.FloatToByteFixed(bb);
                a = Bitwise.FloatToByteFixed(aa);
            }
        }
        unsafe public static void UnpackColor(out float r, out float g, out float b, out float a,
                                              PixelFormat pf, byte *src)
        {
            PixelFormatDescription des = PixelConverter.GetDescriptionFor(pf);

            if ((des.flags & PixelFormatFlags.NativeEndian) != 0)
            {
                // Shortcut for integer formats unpacking
                uint value = Bitwise.IntRead(src, des.elemBytes);
                if ((des.flags & PixelFormatFlags.Luminance) != 0)
                {
                    // Luminance format -- only rbits used
                    r = g = b = Bitwise.FixedToFloat(
                        (value & des.rmask) >> des.rshift, des.rbits);
                }
                else
                {
                    r = Bitwise.FixedToFloat((value & des.rmask) >> des.rshift, des.rbits);
                    g = Bitwise.FixedToFloat((value & des.gmask) >> des.gshift, des.gbits);
                    b = Bitwise.FixedToFloat((value & des.bmask) >> des.bshift, des.bbits);
                }
                if ((des.flags & PixelFormatFlags.HasAlpha) != 0)
                {
                    a = Bitwise.FixedToFloat((value & des.amask) >> des.ashift, des.abits);
                }
                else
                {
                    a = 1.0f; // No alpha, default a component to full
                }
            }
            else
            {
                switch (pf)
                {
                case PixelFormat.FLOAT32_R:
                    r = g = b = ((float *)src)[0];
                    a = 1.0f;
                    break;

                case PixelFormat.FLOAT32_RGB:
                    r = ((float *)src)[0];
                    g = ((float *)src)[1];
                    b = ((float *)src)[2];
                    a = 1.0f;
                    break;

                case PixelFormat.FLOAT32_RGBA:
                    r = ((float *)src)[0];
                    g = ((float *)src)[1];
                    b = ((float *)src)[2];
                    a = ((float *)src)[3];
                    break;

                case PixelFormat.FLOAT16_R:
                    r = g = b = Bitwise.HalfToFloat(((ushort *)src)[0]);
                    a = 1.0f;
                    break;

                case PixelFormat.FLOAT16_RGB:
                    r = Bitwise.HalfToFloat(((ushort *)src)[0]);
                    g = Bitwise.HalfToFloat(((ushort *)src)[1]);
                    b = Bitwise.HalfToFloat(((ushort *)src)[2]);
                    a = 1.0f;
                    break;

                case PixelFormat.FLOAT16_RGBA:
                    r = Bitwise.HalfToFloat(((ushort *)src)[0]);
                    g = Bitwise.HalfToFloat(((ushort *)src)[1]);
                    b = Bitwise.HalfToFloat(((ushort *)src)[2]);
                    a = Bitwise.HalfToFloat(((ushort *)src)[3]);
                    break;

                //                  case PixelFormat.SHORT_RGBA:
                //                      r = Bitwise.FixedToFloat(((ushort*)src)[0], 16);
                //                      g = Bitwise.FixedToFloat(((ushort*)src)[1], 16);
                //                      b = Bitwise.FixedToFloat(((ushort*)src)[2], 16);
                //                      a = Bitwise.FixedToFloat(((ushort*)src)[3], 16);
                //                      break;
                //                  case PixelFormat.BYTE_LA:
                //                      r = g = b = Bitwise.FixedToFloat(((byte*)src)[0], 8);
                //                      a = Bitwise.FixedToFloat(((byte*)src)[1], 8);
                //                      break;
                default:
                    // Not yet supported
                    throw new Exception("Unpack from " + pf + " not implemented, in PixelUtil.UnpackColor");
                }
            }
        }