从像素数据的字节数组创建位图

Question

本题是关于如何读/写、分配和管理Bitmap的像素数据。

下面是如何为像素数据分配字节数组（托管内存）并使用它创建位图的示例：

Size size = new Size(800, 600);
PixelFormat pxFormat = PixelFormat.Format8bppIndexed;
//Get the stride, in this case it will have the same length of the width.
//Because the image Pixel format is 1 Byte/pixel.
//Usually stride = "ByterPerPixel"*Width

//但这并不总是正确的。 更多信息请参见 bobpowell。

int stride = GetStride(size.Width, pxFormat);
byte[] data = new byte[stride * size.Height];
GCHandle handle = GCHandle.Alloc(data, GCHandleType.Pinned);
Bitmap bmp = new Bitmap(size.Width, size.Height, stride,
             pxFormat, handle.AddrOfPinnedObject());

//After doing your stuff, free the Bitmap and unpin the array.
bmp.Dispose();
handle.Free();

public static int GetStride(int width, PixelFormat pxFormat)
{
    //float bitsPerPixel = System.Drawing.Image.GetPixelFormatSize(format);
    int bitsPerPixel = ((int)pxFormat >> 8) & 0xFF;
    //Number of bits used to store the image data per line (only the valid data)
    int validBitsPerLine = width * bitsPerPixel;
    //4 bytes for every int32 (32 bits)
    int stride = ((validBitsPerLine + 31) / 32) * 4;
    return stride;
}

我以为Bitmap会复制数组数据，但实际上它指向相同的数据。您是否可以看到：

Color c;
c = bmp.GetPixel(0, 0);
Console.WriteLine("Color before: " + c.ToString());
//Prints: Color before: Color [A=255, R=0, G=0, B=0]
data[0] = 255;
c = bmp.GetPixel(0, 0);
Console.WriteLine("Color after: " + c.ToString());
//Prints: Color after: Color [A=255, R=255, G=255, B=255]

问题：

1. 从 byte[] 数组（托管内存）创建位图并 free() GCHandle 是否安全？如果不安全，我需要保留一个固定数组，这对 GC/性能有多糟糕？

2. 更改数据是否安全（例如：data[0] = 255;）？

3. GC 可以更改 Scan0 的地址吗？我的意思是，我从锁定的位图中获取 Scan0，然后解锁它，一段时间后再次锁定它，Scan0 可以不同吗？

4. LockBits 方法中 ImageLockMode.UserInputBuffer 的用途是什么？很难找到这方面的信息！ MSDN没有解释清楚！

编辑1：一些后续

1. 您需要将其固定。它会减慢 GC 的速度吗？ 我在这里问过。这取决于图像的数量及其大小。没有人给我一个定量的答案。看来很难确定。 您还可以使用 Marshal 分配内存或使用位图分配的非托管内存。

2. 我使用两个线程做了很多测试。只要位图被锁定就可以了。如果位图被解锁，那么它就不安全！ 我有关直接读/写的相关帖子到扫描0。 Boing 的回答“我已经在上面解释了为什么你很幸运能够在锁之外使用 scan0。因为你使用原始的 bmp PixelFormat 并且 GDI 在这种情况下进行了优化，为你提供指针而不是副本。这个指针是有效的直到操作系统决定释放它。唯一有保证的时间是在 LockBits 和 UnLockBits 之间。”

3. 是的，这可能会发生，但是 GC 对大内存区域的处理有所不同，它移动/释放这个大对象的频率较低。因此 GC 移动这个数组可能需要一段时间。 来自 MSDN：“任何大于或等于 85,000 字节 的分配都会在大型对象堆 (LOH) 上进行”...“LOH 仅是在第 2 代收集期间收集”。 .NET 4.5 对 LOH 进行了改进。

4. 这个问题已由@Boing 回答。但我要承认。我没有完全理解它。因此，如果 Boing 或其他人可以请澄清，我会很高兴。顺便说一句，为什么我不能不加锁直接读/写Sca0？ =>您不应直接写入 Scan0，因为 Scan0 指向由非托管内存（GDI 内部）创建的位图数据的副本。解锁后，该内存可以重新分配给其他东西，不再确定Scan0是否会指向实际的Bitmap数据。这可以通过将 Scan0 锁定、解锁并在解锁的位图中进行一些旋转飞行来重现。一段时间后，Scan0 将指向无效区域，并且在尝试读/写其内存位置时会出现异常。

Answer 1

1. 如果您 marshal.copy 数据而不是设置 scan0 （直接或通过 BitMap() 的重载），那么它是安全的。您不想固定托管对象，这会限制垃圾收集器。
2. 如果你复制，绝对安全。
3. 输入数组是托管的，可以由 GC 移动，scan0 是一个非托管指针，如果数组移动，该指针就会过时。 Bitmap 对象本身是受管理的，但在 Windows 中通过句柄设置 scan0 指针。
4. ImageLockMode.UserInputBuffer 是？显然它可以传递给 LockBits，也许它告诉 Bitmap() 复制输入数组数据。

从数组创建灰度位图的示例代码：

    var b = new Bitmap(Width, Height, PixelFormat.Format8bppIndexed);

    ColorPalette ncp = b.Palette;
    for (int i = 0; i < 256; i++)
        ncp.Entries[i] = Color.FromArgb(255, i, i, i);
    b.Palette = ncp;

    var BoundsRect = new Rectangle(0, 0, Width, Height);
    BitmapData bmpData = b.LockBits(BoundsRect,
                                    ImageLockMode.WriteOnly,
                                    b.PixelFormat);

    IntPtr ptr = bmpData.Scan0;

    int bytes = bmpData.Stride*b.Height;
    var rgbValues = new byte[bytes];

    // fill in rgbValues, e.g. with a for loop over an input array

    Marshal.Copy(rgbValues, 0, ptr, bytes);
    b.UnlockBits(bmpData);
    return b;

Answer 2

关于您的问题 4：ImageLockMode.UserInputBuffer 可以让您控制可引用到 BitmapData 的大量内存的分配过程。代码>对象。

如果您选择自己创建 BitmapData 对象，则可以避免使用 Marshall.Copy。然后，您必须将此标志与另一个 ImageLockMode 结合使用。

请注意，这是一件复杂的事情，特别是关于 Stride
和像素格式。

下面是一个示例，它将在一个镜头中将 24bbp 缓冲区的内容读取到位图上，然后在另一个镜头中将其读回到另一个 48bbp 缓冲区中。

Size size = Image.Size;
Bitmap bitmap = Image;
// myPrewrittenBuff is allocated just like myReadingBuffer below (skipped for space sake)
// But with two differences: the buff would be byte [] (not ushort[]) and the Stride == 3 * size.Width (not 6 * ...) because we build a 24bpp not 48bpp
BitmapData writerBuff= bm.LockBits(new Rectangle(0, 0, size.Width, size.Height), ImageLockMode.UserInputBuffer | ImageLockMode.WriteOnly, PixelFormat.Format24bppRgb, myPrewrittenBuff);
// note here writerBuff and myPrewrittenBuff are the same reference
bitmap.UnlockBits(writerBuff);
// done. bitmap updated , no marshal needed to copy myPrewrittenBuff 

// Now lets read back the bitmap into another format...
BitmapData myReadingBuffer = new BitmapData();
ushort[] buff = new ushort[(3 * size.Width) * size.Height]; // ;Marshal.AllocHGlobal() if you want
GCHandle handle= GCHandle.Alloc(buff, GCHandleType.Pinned);
myReadingBuffer.Scan0 = Marshal.UnsafeAddrOfPinnedArrayElement(buff, 0);
myReadingBuffer.Height = size.Height;
myReadingBuffer.Width = size.Width;
myReadingBuffer.PixelFormat = PixelFormat.Format48bppRgb;
myReadingBuffer.Stride = 6 * size.Width;
// now read into that buff
BitmapData result = bitmap.LockBits(new Rectangle(0, 0, size.Width, size.Height), ImageLockMode.UserInputBuffer | ImageLockMode.ReadOnly, PixelFormat.Format48bppRgb, myReadingBuffer);
if (object.ReferenceEquals(result, myReadingBuffer)) {
    // Note: we pass here
    // and buff is filled
}
bitmap.UnlockBits(result);
handle.Free();
// use buff at will...

如果您使用 ILSpy，您会看到此方法链接到 GDI+ 这些方法帮助更完整。

您可以通过使用自己的内存方案来提高性能，但是
请注意，Stride 可能需要进行一些调整才能获得最佳效果
性能。

然后，您将能够疯狂地分配巨大虚拟内存映射scan0并非常有效地进行blit它们。
请注意，固定大型数组（尤其是少数数组）不会成为 GC 的负担，并且允许您以完全安全的方式操作字节/短数组（如果您寻求速度，则不安全）

Answer 3

我不确定你这样做是否有原因。也许有。看来您已经走得很远了，因此您可能会尝试做一些比问题标题所暗示的更高级的事情...

但是，从字节数组创建位图的传统方法是：

using (MemoryStream stream = new MemoryStream(byteArray))
{
     Bitmap bmp = new Bitmap(stream);
     // use bmp here....
}

Answer 4

这是我编写的示例代码，用于将像素字节数组转换为 8 位灰度图像（bmp）
该方法接受像素数组、图像宽度和高度作为参数
//

public Bitmap Convert2Bitmap(byte[] DATA, int width, int height)
{
    Bitmap Bm = new Bitmap(width,height,PixelFormat.Format24bppRgb);
    var b = new Bitmap(width, height, PixelFormat.Format8bppIndexed);
    ColorPalette ncp = b.Palette;
    for (int i = 0; i < 256; i++)
        ncp.Entries[i] = Color.FromArgb(255, i, i, i);
    b.Palette = ncp;
    for (int y = 0; y < height; y++)
    {
        for (int x = 0; x < width; x++)
        {
            int Value = DATA[x + (y * width)];
            Color C = ncp.Entries[Value];
            Bm.SetPixel(x,y,C);
        }
    }
   return Bm;
}