Example #1
0
    /// <inheritdoc/>
    public unsafe override BitmapSource Read(byte *data, int dataLength, BitmapReaderFlags rFlags)
    {
        BITMAP_READ_DETAILS info;
        uint bcrFlags = (uint)rFlags;

        BitmapCore.ReadHeader(data, dataLength, out info, bcrFlags);
        return(BitmapWpfInternal.Read(ref info, data + info.imgDataOffset, bcrFlags));
    }
Example #2
0
    /// <summary>
    /// Read a bitmap from a byte array.
    /// </summary>
    public static TBitmap FromBytes(byte[] data, BitmapReaderFlags pFlags)
    {
        var impl = new TSelf();

        return(impl.Read(data, pFlags));
    }
Example #3
0
    /// <summary>
    /// Read a bitmap from a data stream (such as a web request, or a filestream).
    /// </summary>
    public static TBitmap FromStream(Stream stream, BitmapReaderFlags pFlags)
    {
        var impl = new TSelf();

        return(impl.Read(stream, pFlags));
    }
Example #4
0
 /// <inheritdoc/>
 public abstract unsafe TBitmap Read(byte *data, int dataLength, BitmapReaderFlags rFlags);
Example #5
0
 /// <inheritdoc/>
 public unsafe TBitmap Read(byte[] data, BitmapReaderFlags pFlags)
 {
     fixed(byte *ptr = data)
     return(Read(ptr, data.Length, pFlags));
 }
Example #6
0
 /// <inheritdoc/>
 public TBitmap Read(Stream stream, BitmapReaderFlags pFlags) => Read(StructUtil.ReadBytes(stream), pFlags);
Example #7
0
    /// <inheritdoc/>
    public override unsafe Bitmap Read(byte *data, int dataLength, BitmapReaderFlags rFlags)
    {
        uint bcrFlags = (uint)rFlags;

        BITMAP_READ_DETAILS info;

        BitmapCore.ReadHeader(data, dataLength, out info, bcrFlags);

        byte *pixels = data + info.imgDataOffset;

        // we do this parsing here since BitmapCore has no references to System.Drawing
        if (info.compression == BitmapCompressionMode.BI_PNG || info.compression == BitmapCompressionMode.BI_JPEG)
        {
            return(new Bitmap(new PointerStream(pixels, info.imgDataSize)));
        }

        // defaults
        PixelFormat           gdiFmt  = PixelFormat.Format32bppArgb;
        BitmapCorePixelFormat coreFmt = BitmapCorePixelFormat.Bgra32;

        var formatbgra32 = (rFlags & BitmapReaderFlags.ForceFormatBGRA32) > 0;

        if (!formatbgra32 && info.imgSourceFmt != null)
        {
            var origFmt = info.imgSourceFmt;
            if (origFmt == BitmapCorePixelFormat.Rgb24)
            {
                // we need BitmapCore to reverse the pixel order for GDI
                coreFmt = BitmapCorePixelFormat.Bgr24;
                gdiFmt  = PixelFormat.Format24bppRgb;
            }
            else
            {
                var pxarr = Formats.Where(f => f.coreFmt == origFmt).ToArray();
                if (pxarr.Length > 0)
                {
                    var px = pxarr.First();
                    gdiFmt  = px.gdiFmt;
                    coreFmt = px.coreFmt;
                }
            }
        }

        Bitmap bitmap = new Bitmap(info.imgWidth, info.imgHeight, gdiFmt);
        var    dlock  = bitmap.LockBits(new Rectangle(0, 0, info.imgWidth, info.imgHeight), ImageLockMode.ReadWrite, gdiFmt);
        var    buf    = (byte *)dlock.Scan0;

        BitmapCore.ReadPixels(ref info, coreFmt, pixels, buf, bcrFlags);
        bitmap.UnlockBits(dlock);

        // update bitmap color palette
        var gdipPalette = bitmap.Palette;

        if (info.imgColorTable != null && gdipPalette?.Entries != null && gdipPalette.Entries.Length > 0)
        {
            for (int i = 0; i < info.imgColorTable.Length && i < gdipPalette.Entries.Length; i++)
            {
                var quad = info.imgColorTable[i];
                gdipPalette.Entries[i] = Color.FromArgb(0xFF, quad.rgbRed, quad.rgbGreen, quad.rgbBlue);
            }
            bitmap.Palette = gdipPalette;
        }

        return(bitmap);
    }