Pourquoi BitmapSource.Create lance-t-il une ArgumentException?

Question

Je suis en train d'obtenir un bitmap créé à partir des données brutes à afficher dans WPF, à l'aide d'une image et un 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; 

Cependant l'appel à BitmapSource.Create lance un ArgumentException, en disant « valeur ne tomber dans la fourchette attendue ". N'est-ce pas le moyen de le faire? Est-ce que je ne fais pas cet appel correctement?

Answer 1

Votre foulée est incorrecte. Stride est le nombre d'octets alloués pour une ligne de balayage du bitmap . Ainsi, utilisez ce qui suit:

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

et remplacer le dernier paramètre (actuellement 0) avec stride tel que défini ci-dessus.

Voici une explication de la formule mystérieuse de foulée:

Fait: Scanlines doivent être alignés sur les limites 32 bits (reference).

La formule naïve pour le nombre d'octets par ligne de balayage serait:

(width * bpp)/8 

Mais cela pourrait ne pas nous donner une image bitmap aligné sur une limite de 32 bits et (largeur * BPP) pourrait ne pas même avoir été divisible par 8.

alors, ce que nous faisons est que nous forcer notre bitmap d'avoir au moins 32 bits dans une rangée (nous supposons que width > 0):

width * bpp + 31 

et nous dire que nous ne nous soucions pas les bits de poids faible (bits 0 à -4) parce que nous essayons d'aligner sur les limites 32 bits:

(width * bpp + 31) & ~31 

puis diviser par 8 pour revenir à octets:

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

Le rembourrage peut être calculée par

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

La formule naïve serait

stride - ((width * bpp)/8) 

Mais width * bpp peut ne pas s'aligner sur une limite d'octet et, dans le cas contraire, cette formule surpasserait le remplissage par un octet. (Pensez à un bitmap de 1 pixel en utilisant 1 bpp. La foulée est 4 et la formule naïve dirait que le padding est 4 mais en réalité il est 3.) Donc, nous ajoutons un peu pour couvrir le cas que width * bpp n'est pas un octet limite, puis nous obtenons la formule correcte donnée ci-dessus.