How do I get a byte array to a picturebox.image?

' Source: 
' http://www.taotekaching.com/post/2009/01/08/Device-Independent-Bitmaps-C-and-Meae282acc2a6REDUX!.aspx 
 
Imports System
Imports System.Drawing.Imaging
Imports System.Runtime.InteropServices
Imports System.IO
 
Public Class DIBConverter
 
    ' our BITMAPINFOHEADER struct, as per gdi 
    ' use LayoutKind to make sure data is marshalled as we've laid it out 
    <StructLayout(LayoutKind.Sequential)> _
    Public Structure BITMAPINFOHEADER
        Public biSize As UInteger
        Public biWidth As Integer
        Public biHeight As Integer
        Public biPlanes As UShort
        Public biBitCount As UShort
        Public biCompression As UInteger
        Public biSizeImage As UInteger
        Public biXPelsPerMeter As Integer
        Public biYPelsPerMeter As Integer
        Public biClrUsed As UInteger
        Public biClrImportant As UInteger
    End Structure
 
    Public Shared Function BitmapFromDIB(ByVal dib As MemoryStream) As Bitmap
        ' get byte array of device independent bitmap 
        Dim dibBytes As Byte() = dib.ToArray()
 
        ' get the handle for the byte array and "pin" that memory (i.e. prevent 
        ' garbage collector from gobbling it up right away)... 
        Dim hdl As GCHandle = GCHandle.Alloc(dibBytes, GCHandleType.Pinned)
 
        ' marshal our data into a BITMAPINFOHEADER struct per Win32 
        ' definition of BITMAPINFOHEADER 
        Dim dibHdr As BITMAPINFOHEADER = DirectCast(Marshal.PtrToStructure(hdl.AddrOfPinnedObject(), GetType(BITMAPINFOHEADER)), BITMAPINFOHEADER)
        Dim is555 As Boolean = True
 
        Dim bmp As Bitmap = Nothing
 
        If dibHdr.biBitCount = 8 Then
            ' set our pointer to end of BITMAPINFOHEADER 
            Dim jumpTo As Int64 = hdl.AddrOfPinnedObject().ToInt64() + dibHdr.biSize
            bmp = New Bitmap(dibHdr.biWidth, dibHdr.biHeight, PixelFormat.Format8bppIndexed)
            bmp.SetResolution((100.0F * CSng(dibHdr.biXPelsPerMeter)) / 2.54F, (100.0F * CSng(dibHdr.biYPelsPerMeter)) / 2.54F)
 
            ' set the colors in our palette 
            Dim palette As ColorPalette = bmp.Palette
            Dim ptr As IntPtr = IntPtr.Zero
            Dim colors As Integer = CInt((dibBytes.Length - (bmp.Width * bmp.Height) - dibHdr.biSize))
            For i As Integer = 0 To 255
                ptr = New IntPtr(jumpTo)
                Dim bmiColor As UInteger = CUInt(Marshal.ReadInt32(ptr))
                Dim r As Integer = CInt(((bmiColor And &HFF0000) >> 16)), g As Integer = CInt(((bmiColor And &HFF00) >> 8)), b As Integer = CInt(((bmiColor And &HFF)))
                palette.Entries(i) = Color.FromArgb(r, g, b)
                jumpTo += 4
            Next
            bmp.Palette = palette
 
            ' now write the remaining bmp data to our bitmap 
            Dim _8bd As BitmapData = bmp.LockBits(New Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.[WriteOnly], PixelFormat.Format8bppIndexed)
            jumpTo -= hdl.AddrOfPinnedObject().ToInt64()
            Marshal.Copy(dibBytes, CInt(jumpTo), _8bd.Scan0, _8bd.Stride * _8bd.Height)
            bmp.UnlockBits(_8bd)
        ElseIf (dibHdr.biBitCount = 16) AndAlso (dibHdr.biCompression = 3) Then
            Dim jumpTo As Int64 = dibHdr.biClrUsed * CUInt(4) + dibHdr.biSize
            Dim ptr As New IntPtr(hdl.AddrOfPinnedObject().ToInt64() + jumpTo)
            Dim redMask As UShort = CUShort(Marshal.ReadInt16(ptr))
            ptr = New IntPtr(ptr.ToInt64() + (2 * Marshal.SizeOf(GetType(UInt16))))
            Dim greenMask As UShort = CUShort(Marshal.ReadInt16(ptr))
            ptr = New IntPtr(ptr.ToInt64() + (2 * Marshal.SizeOf(GetType(UInt16))))
            Dim blueMask As UShort = CUShort(Marshal.ReadInt16(ptr))
 
            is555 = ((redMask = &H7C00) AndAlso (greenMask = &H3E0) AndAlso (blueMask = &H1F))
        End If
 
        ' go ahead and release the "pin" from our handle on that memory 
        hdl.Free()
 
        ' If the target device does not have one plane, or we're working with a bitmap other 
        ' than a non-compressed (BI_RGB) bitmap, we're not gonna work woith it 
        If dibHdr.biPlanes <> 1 OrElse (dibHdr.biCompression <> 0 AndAlso dibHdr.biCompression <> 3) Then
            Return Nothing
        End If
 
        If bmp Is Nothing Then
            ' we need to know beforehand the pixel-depth of our bitmap 
            Dim fmt As PixelFormat = PixelFormat.Format24bppRgb
 
            Select Case dibHdr.biBitCount
                Case 32
                    fmt = PixelFormat.Format32bppRgb
                    Exit Select
                Case 24
                    fmt = PixelFormat.Format24bppRgb
                    Exit Select
                Case 16
                    fmt = IIf(is555, PixelFormat.Format16bppRgb555, PixelFormat.Format16bppRgb565)
                    Exit Select
                Case Else
                    Return Nothing
            End Select
 
            ' prepare for our output bitmap 
            bmp = New Bitmap(dibHdr.biWidth, dibHdr.biHeight, fmt)
 
            ' load our "empty" bitmap into memory and lock it for 
            ' writing in the format we specified 
            Dim bd As BitmapData = bmp.LockBits(New Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.[WriteOnly], fmt)
 
            ' marshal our device independent bitmap data over to our output bitmap 
            Marshal.Copy(dibBytes, Marshal.SizeOf(dibHdr), bd.Scan0, bd.Stride * bd.Height)
 
            ' we're done marshalling, so release our bitmapdata lock 
 
            bmp.UnlockBits(bd)
        End If
 
        If dibHdr.biHeight > 0 Then
            ' DIB data is upside-down for some reason, so flip it 
            bmp.RotateFlip(RotateFlipType.RotateNoneFlipY)
        End If
 
        ' return our bitmap 
        Return bmp
    End Function
End Class

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129: