Warum BitmapSource.Create ein Argument werfen?

Question

Ich versuche, eine Bitmap aus Rohdaten erstellt zu bekommen in WPF zu zeigen, indem sie ein Bild mit und ein Bitmapsource:

Int32[] data = new Int32[RenderHeight * RenderWidth];

for (Int32 i = 0; i < RenderHeight; i++)
{
    for (Int32 j = 0; j < RenderWidth; j++)
    {
        Int32 index = j + (i * RenderHeight);

        if (i + j % 2 == 0)
            data[index] = 0xFF0000;
        else
            data[index] = 0x00FF00;
    }
}

BitmapSource source = BitmapSource.Create(RenderWidth, RenderHeight, 96.0, 96.0, PixelFormats.Bgr32, null, data, 0);

RenderImage.Source = source;

Doch der Aufruf von BitmapSource.Create wirft ein Argument und sagte: „Wert nicht innerhalb des erwarteten Bereichs fällt“. Ist dies nicht der richtige Weg, dies zu tun? Bin ich nicht diesen Ruf richtig zu machen?

Answer 1

Ihr Schritt ist falsch. Stride wird die Anzahl der Bytes, die für eine Abtastzeile der zugewiesenen Bitmap. So verwenden Sie die folgende:

int stride = ((RenderWidth * 32 + 31) & ~31) / 8;

und ersetzen Sie den letzten Parameter (derzeit 0) mit stride wie vorstehend definiert ist.

Hier ist eine Erklärung für die geheimnisvolle Schritt Formel:

Fact: Scanlines muss auf 32-Bit-Grenzen ausgerichtet werden ( Referenz ) .

Die naive Formel für die Anzahl der Bytes pro Bildzeile wäre:

(width * bpp) / 8

Aber das könnte uns nicht eine Bitmap gibt an einer Grenze 32-Bit ausgerichtet und (Breite * bpp) vielleicht nicht einmal durch 8 teilbar gewesen sein.

Also, was wir tun, ist, dass wir unsere Bitmap zwingen, zumindest zu haben 32 Bits in einer Reihe (wir nehmen an, dass width > 0):

width * bpp + 31

und dann sagen wir, dass wir nicht über die niederwertigen Bits (Bits 0--4) ist es egal, weil wir align auf 32-Bit-Grenzen versuchen:

(width * bpp + 31) & ~31

und dann Division durch 8 bis Bytes zurück zu bekommen:

((width * bpp + 31) & ~31) / 8

Die Polsterung kann durch berechnet werden

int padding = stride - (((width * bpp) + 7) / 8)

Die naive Formel wäre

stride - ((width * bpp) / 8)

Aber width * bpp möglicherweise nicht auf einer Byte-Grenze ausgerichtet und wenn es nicht diese Formel würde über die Polsterung durch einen Byte zählen. (Denken Sie an einem 1 Pixel breit 1 bpp Bitmap verwendet wird. Der Schritt ist 4 und die naive Formel würde sagen, dass die Polsterung 4 ist, aber in Wirklichkeit ist es 3.) Also haben wir ein wenig hinzuzufügen, den Fall zu decken, dass width * bpp nicht a Byte-Grenze und wir bekommen dann die richtige Formel oben.