public void Store(BinaryWriter bw, uint[] colorPalette)
{
// Must maintain order for file writing
bw.Write(biSize);
bw.Write(biWidth);
bw.Write(biHeight);
bw.Write(biPlanes);
bw.Write(biBitCount);
bw.Write(biCompression);
bw.Write(biSizeImage);
bw.Write(biXPelsPerMeter);
bw.Write(biYPelsPerMeter);
bw.Write(biClrUsed);
bw.Write(biClrImportant);
// write color palette if 8 bpp or less
if (biBitCount <= 8)
{
if (colorPalette == null)
{
throw new ArgumentNullException("bpp is 8 or less, color palette is required");
}
uint paletteCount = BITMAPFILEHEADER.CalcPaletteSize(biBitCount) / 4;
if (colorPalette.Length < paletteCount)
{
throw new ArgumentException(string.Format("bpp is 8 or less, color palette must contain {0} colors", paletteCount));
}
foreach (uint color in colorPalette)
{
bw.Write(color);
}
}
}
private static BitmapFrame CreateBitmapVersionOne(byte[] bitmapVersionOneBytes,
BITMAPINFOHEADER bitmapVersionOneHeader)
{
var fileHeaderSize = Marshal.SizeOf(typeof (BITMAPFILEHEADER));
var infoHeaderSize = bitmapVersionOneHeader.biSize;
var fileSize = fileHeaderSize + bitmapVersionOneHeader.biSize + bitmapVersionOneHeader.biSizeImage;
var fileHeader = new BITMAPFILEHEADER
{
bfType = BITMAPFILEHEADER.BM,
bfSize = fileSize,
bfReserved1 = 0,
bfReserved2 = 0,
bfOffBits = fileHeaderSize + infoHeaderSize + bitmapVersionOneHeader.biClrUsed*4
};
var fileHeaderBytes = GeneralApi.StructureToByteArray(fileHeader);
var bitmapStream = new MemoryStream();
bitmapStream.Write(fileHeaderBytes, 0, fileHeaderSize);
bitmapStream.Write(bitmapVersionOneBytes, 0, bitmapVersionOneBytes.Length);
bitmapStream.Seek(0, SeekOrigin.Begin);
var bitmap = BitmapFrame.Create(bitmapStream);
return bitmap;
}
public async Task <Bitmap> GetBitmapAsync(ResourceLanguage language)
{
using (var mem = new MemoryStream())
{
var buffer = await GetBytesAsync(language).ConfigureAwait(false);
using (var dibMem = new MemoryStream(buffer))
{
var header = await dibMem.ReadStructAsync <BITMAPINFOHEADER>(BitmapInfoHeaderSize).ConfigureAwait(false);
var fileHeader = new BITMAPFILEHEADER()
{
Tag = 19778,
Size = (BitmapFileHeaderSize + buffer.Length).ToUInt32(),
Reserved1 = 0,
Reserved2 = 0,
BitmapOffset = (BitmapFileHeaderSize.ToUInt32() + header.biSize)
};
await mem.WriteStructAsync <BITMAPFILEHEADER>(fileHeader).ConfigureAwait(false);
await mem.WriteBytesAsync(buffer).ConfigureAwait(false);
}
mem.Seek(0, SeekOrigin.Begin);
using (var bitmap = (Bitmap)System.Drawing.Image.FromStream(mem))
{
var result = new Bitmap(bitmap);
return(result);
}
}
}
public static void ReadBitmapFile(string StrFileName, BITMAPFILEHEADER BmFileHeader, BITMAPINFO BmInfo, byte[] BtArPixelData)
{
if (StrFileName.Length <= 0)
{
//MessageBox.Show("please select a file");
return;
}
//'Open the bmp file in Binary format
//FileOpen(1, StrFileName, OpenMode.Binary)
//'Get the header structures
//'UPGRADE_WARNING: Get was upgraded to FileGet and has a new behavior. Click for more: 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="vbup1041"'
//FileGet(1, BmFileHeader, 1)
//'UPGRADE_WARNING: Get was upgraded to FileGet and has a new behavior. Click for more: 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="vbup1041"'
//FileGet(1, BmInfo.bmiHeader)
//If BmInfo.bmiHeader.biBitCount = 8 Then
// 'UPGRADE_WARNING: Get was upgraded to FileGet and has a new behavior. Click for more: 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="vbup1041"'
// FileGet(1, BmInfo.bmiColors)
//End If
//If BmInfo.bmiHeader.biCompression = 1 Then
// ReDim BtArPixelData(BmInfo.bmiHeader.biSizeImage)
//Else
// ReDim BtArPixelData(BmFileHeader.bfSize - BmFileHeader.bfOffBits)
//End If
//'UPGRADE_WARNING: Get was upgraded to FileGet and has a new behavior. Click for more: 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="vbup1041"'
//FileGet(1, BtArPixelData)
//FileClose(1)
}
public void LoadImageFile(string fileName)
{
try {
using (BinaryReader bin = new BinaryReader(File.Open(fileName, FileMode.Open))) {
// Cargamos la informacion de la cabecera en la estructura.
fileHeader = ByteArrayToStructure <BITMAPFILEHEADER>(bin.ReadBytes(14));
imageHeader = ByteArrayToStructure <BITMAPINFOHEADER>(bin.ReadBytes(40));
// Verificamos que tenga el formato con el que vamos a trabajar.
if (fileHeader.bfType == 0x4D42 && imageHeader.biCompression == 0 && (imageHeader.biBitCount == 1 || imageHeader.biBitCount == 4 || imageHeader.biBitCount == 8 || imageHeader.biBitCount == 24))
{
imageData = new byte[imageHeader.biSizeImage];
if (imageHeader.biBitCount != 24)
{
imageHeader.biClrUsed = (uint)(0x1 << imageHeader.biBitCount);
}
bin.BaseStream.Seek(imageHeader.biSize + 14, SeekOrigin.Begin);
colorTable = bin.ReadBytes((int)imageHeader.biClrUsed * 4);
bin.BaseStream.Seek(fileHeader.bOffBits, SeekOrigin.Begin);
imageData = bin.ReadBytes((int)imageHeader.biSizeImage);
imagePatch = fileName;
}
bin.Dispose();
bin.Close();
}
} catch (Exception _Exception) {
// Error
MessageBox.Show(_Exception.ToString(), "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
/// <summary>
/// Creates a BitmapFrame from a buffer containing a DIB.
/// </summary>
public static BitmapFrame CreateBitmapFrameFromDibBytes(byte[] dibBuffer)
{
BITMAPINFOHEADER infoHeader = BinaryStructConverter.FromByteArray <BITMAPINFOHEADER>(dibBuffer);
int fileHeaderSize = Marshal.SizeOf(typeof(BITMAPFILEHEADER));
int infoHeaderSize = infoHeader.biSize;
int fileSize = fileHeaderSize + infoHeader.biSize + infoHeader.biSizeImage;
BITMAPFILEHEADER fileHeader = new BITMAPFILEHEADER
{
bfType = BITMAPFILEHEADER.BM,
bfSize = fileSize,
bfReserved1 = 0,
bfReserved2 = 0,
bfOffBits = fileHeaderSize + infoHeaderSize + infoHeader.biClrUsed * 4
};
byte[] fileHeaderBytes = BinaryStructConverter.ToByteArray(fileHeader);
MemoryStream msBitmap = new MemoryStream();
msBitmap.Write(fileHeaderBytes, 0, fileHeaderSize);
msBitmap.Write(dibBuffer, 0, dibBuffer.Length);
msBitmap.Seek(0, SeekOrigin.Begin);
return(BitmapFrame.Create(msBitmap));
}
public static Stream GetBitmapStream(IntPtr data)
{
var infoHeader = (BITMAPINFOHEADER)Marshal.PtrToStructure(data, typeof(BITMAPINFOHEADER));
if (infoHeader.Validate())
{
var fileHeaderSize = Marshal.SizeOf(typeof(BITMAPFILEHEADER));
var fileHeader = new BITMAPFILEHEADER();
fileHeader.bfType = 0x4D42; // "BM"
fileHeader.bfOffBits = (uint)fileHeaderSize +
infoHeader.biSize +
(infoHeader.biClrUsed * 4);
fileHeader.bfSize = fileHeader.bfOffBits + infoHeader.biSizeImage;
var dataCopy = new byte[fileHeader.bfSize];
// write file header
IntPtr tempPtr = Marshal.AllocHGlobal(fileHeaderSize);
Marshal.StructureToPtr(fileHeader, tempPtr, true);
Marshal.Copy(tempPtr, dataCopy, 0, fileHeaderSize);
Marshal.FreeHGlobal(tempPtr);
// write image
Marshal.Copy(data, dataCopy, fileHeaderSize, (int)fileHeader.bfSize - fileHeaderSize);
return(new MemoryStream(dataCopy));
}
return(null);
}
public void LoadClipObject(ClipObject clipObject)
{
var ms = (MemoryStream) new DataObjectConverter().GetClipObjectData(clipObject);
byte[] dibBuffer = new byte[ms.Length];
ms.Read(dibBuffer, 0, dibBuffer.Length);
BITMAPINFOHEADER infoHeader =
BinaryStructConverter.FromByteArray <BITMAPINFOHEADER>(dibBuffer);
int fileHeaderSize = Marshal.SizeOf(typeof(BITMAPFILEHEADER));
int infoHeaderSize = infoHeader.biSize;
int fileSize = fileHeaderSize + infoHeader.biSize + infoHeader.biSizeImage;
BITMAPFILEHEADER fileHeader = new BITMAPFILEHEADER();
fileHeader.bfType = BITMAPFILEHEADER.BM;
fileHeader.bfSize = fileSize;
fileHeader.bfReserved1 = 0;
fileHeader.bfReserved2 = 0;
fileHeader.bfOffBits = fileHeaderSize + infoHeaderSize + infoHeader.biClrUsed * 4;
byte[] fileHeaderBytes =
BinaryStructConverter.ToByteArray <BITMAPFILEHEADER>(fileHeader);
MemoryStream msBitmap = new MemoryStream();
msBitmap.Write(fileHeaderBytes, 0, fileHeaderSize);
msBitmap.Write(dibBuffer, 0, dibBuffer.Length);
msBitmap.Seek(0, SeekOrigin.Begin);
_image.Source = BitmapFrame.Create(msBitmap);
}
public static BitmapFrame BitmapFrameFromClipboardDib()
{
MemoryStream ms = Clipboard.GetData("DeviceIndependentBitmap") as MemoryStream;
if (ms != null)
{
byte[] dibBuffer = new byte[ms.Length];
ms.Read(dibBuffer, 0, dibBuffer.Length);
BITMAPINFOHEADER infoHeader =
BinaryStructConverter.FromByteArray <BITMAPINFOHEADER>(dibBuffer);
int fileHeaderSize = Marshal.SizeOf(typeof(BITMAPFILEHEADER));
int infoHeaderSize = infoHeader.biSize;
int fileSize = fileHeaderSize + infoHeader.biSize + infoHeader.biSizeImage;
BITMAPFILEHEADER fileHeader = new BITMAPFILEHEADER();
fileHeader.bfType = BITMAPFILEHEADER.BM;
fileHeader.bfSize = fileSize;
fileHeader.bfReserved1 = 0;
fileHeader.bfReserved2 = 0;
fileHeader.bfOffBits = fileHeaderSize + infoHeaderSize + infoHeader.biClrUsed * 4;
byte[] fileHeaderBytes =
BinaryStructConverter.ToByteArray <BITMAPFILEHEADER>(fileHeader);
MemoryStream msBitmap = new MemoryStream();
msBitmap.Write(fileHeaderBytes, 0, fileHeaderSize);
msBitmap.Write(dibBuffer, 0, dibBuffer.Length);
msBitmap.Seek(0, SeekOrigin.Begin);
return(BitmapFrame.Create(msBitmap));
}
return(null);
}
public static BitmapSource ClipboardDibToBitmapSource()
{
var ms = System.Windows.Clipboard.GetData("DeviceIndependentBitmap") as MemoryStream;
if (ms == null)
{
return(null);
}
var dibBuffer = new byte[ms.Length];
ms.Read(dibBuffer, 0, dibBuffer.Length);
var infoHeader = BinaryStructConverter.FromByteArray <BITMAPINFOHEADER>(dibBuffer);
var fileHeaderSize = Marshal.SizeOf(typeof(BITMAPFILEHEADER));
var infoHeaderSize = infoHeader.biSize;
var fileSize = fileHeaderSize + infoHeader.biSize + infoHeader.biSizeImage;
var fileHeader = new BITMAPFILEHEADER
{
bfType = BITMAPFILEHEADER.BM,
bfSize = fileSize,
bfReserved1 = 0,
bfReserved2 = 0,
bfOffBits = fileHeaderSize + infoHeaderSize + infoHeader.biClrUsed * 4
};
var fileHeaderBytes = BinaryStructConverter.ToByteArray(fileHeader);
var msBitmap = new MemoryStream();
msBitmap.Write(fileHeaderBytes, 0, fileHeaderSize);
msBitmap.Write(dibBuffer, 0, dibBuffer.Length);
msBitmap.Seek(0, SeekOrigin.Begin);
return(BitmapFrame.Create(msBitmap)); // frees stream when rendered
}
static BitmapFrame CreateBitmapVersionOne(byte[] bitmapVersionOneBytes, BITMAPINFOHEADER bitmapVersionOneHeader)
{
var fileHeaderSize = Marshal.SizeOf(typeof(BITMAPFILEHEADER));
var infoHeaderSize = bitmapVersionOneHeader.biSize;
var fileSize = fileHeaderSize + bitmapVersionOneHeader.biSize + bitmapVersionOneHeader.biSizeImage;
var fileHeader = new BITMAPFILEHEADER();
fileHeader.bfType = BITMAPFILEHEADER.BM;
fileHeader.bfSize = fileSize;
fileHeader.bfReserved1 = 0;
fileHeader.bfReserved2 = 0;
fileHeader.bfOffBits = fileHeaderSize + infoHeaderSize + bitmapVersionOneHeader.biClrUsed * 4;
var fileHeaderBytes = GeneralApi.StructureToByteArray(fileHeader);
var bitmapStream = new MemoryStream();
bitmapStream.Write(fileHeaderBytes, 0, fileHeaderSize);
bitmapStream.Write(bitmapVersionOneBytes, 0, bitmapVersionOneBytes.Length);
bitmapStream.Seek(0, SeekOrigin.Begin);
var bitmap = BitmapFrame.Create(bitmapStream);
return(bitmap);
}
public static MemoryStream GetConvertedBytes(ref MemoryStream ms)
{
if (ms == null)
{
return(null);
}
byte[] dibBuffer = new byte[ms.Length];
ms.Read(dibBuffer, 0, dibBuffer.Length);
BITMAPV5HEADER infoHeader = BinaryStructConverter.FromByteArray <BITMAPV5HEADER>(dibBuffer);
int fileHeaderSize = Marshal.SizeOf(typeof(BITMAPFILEHEADER));
int infoHeaderSize = infoHeader.bV5Size;
int fileSize = fileHeaderSize + infoHeader.bV5Size + infoHeader.bV5SizeImage;
BITMAPFILEHEADER fileHeader = new BITMAPFILEHEADER();
fileHeader.bfType = BITMAPFILEHEADER.BM;
fileHeader.bfSize = fileSize;
fileHeader.bfReserved1 = 0;
fileHeader.bfReserved2 = 0;
fileHeader.bfOffBits = fileHeaderSize + infoHeaderSize + infoHeader.bV5ClrUsed * 4;
byte[] fileHeaderBytes = BinaryStructConverter.ToByteArray <BITMAPFILEHEADER>(fileHeader);
MemoryStream msBitmap = new MemoryStream();
msBitmap.Write(fileHeaderBytes, 0, fileHeaderSize);
msBitmap.Write(dibBuffer, 0, dibBuffer.Length);
msBitmap.Seek(0, SeekOrigin.Begin);
return(msBitmap);
}
/// <summary>
/// Get .NET 'Bitmap' object from memory DIB via stream constructor.
/// This should work for most DIBs.
/// </summary>
/// <param name="dibPtr">Pointer to memory DIB, starting with BITMAPINFOHEADER.</param>
public static Bitmap WithStream(IntPtr dibPtr)
{
BITMAPFILEHEADER fh = new BITMAPFILEHEADER();
Type bmiTyp = typeof(BITMAPINFOHEADER);
BITMAPINFOHEADER bmi = (BITMAPINFOHEADER)Marshal.PtrToStructure(dibPtr, bmiTyp);
if (bmi.biSizeImage == 0)
{
bmi.biSizeImage = ((((bmi.biWidth * bmi.biBitCount) + 31) & ~31) >> 3) * Math.Abs(bmi.biHeight);
}
if ((bmi.biClrUsed == 0) && (bmi.biBitCount < 16))
{
bmi.biClrUsed = 1 << bmi.biBitCount;
}
int fhSize = Marshal.SizeOf(typeof(BITMAPFILEHEADER));
int dibSize = bmi.biSize + (bmi.biClrUsed * 4) + bmi.biSizeImage; // info + rgb + pixels
fh.Type = new Char[] { 'B', 'M' }; // "BM"
fh.Size = fhSize + dibSize; // final file size
fh.OffBits = fhSize + bmi.biSize + (bmi.biClrUsed * 4); // offset to pixels
byte[] data = new byte[fh.Size]; // file-sized byte[]
RawSerializeInto(fh, data); // serialize BITMAPFILEHEADER into byte[]
Marshal.Copy(dibPtr, data, fhSize, dibSize); // mem-copy DIB into byte[]
MemoryStream stream = new MemoryStream(data); // file-sized stream
Bitmap tmp = new Bitmap(stream); // 'tmp' is wired to stream (unfortunately)
Bitmap result = new Bitmap(tmp); // 'result' is a copy (stand-alone)
tmp.Dispose(); tmp = null;
stream.Close(); stream = null; data = null;
return(result);
}
// parses a BITMAPFILEHEADER and BITMAPINFOHEADER to get
// the offset of the image bits, the size of the image and
// if it's a transparent bitmap.
private static void GetBitmapInfo(byte[] data, out uint BitsOffset, out uint ImageSize, out bool IsTransparent)
{
BitsOffset = 0;
ImageSize = 0;
IsTransparent = false;
using (BinaryReader reader = new BinaryReader(new MemoryStream(data)))
{
BITMAPFILEHEADER fileHeader = new BITMAPFILEHEADER();
BITMAPINFOHEADER infoHeader = new BITMAPINFOHEADER();
if (!fileHeader.Read(reader))
{
return;
}
if (!infoHeader.Read(reader))
{
return;
}
BitsOffset = fileHeader.bfOffBits;
ImageSize = (uint)(System.Math.Abs(infoHeader.biWidth) * System.Math.Abs(infoHeader.biHeight));
IsTransparent = infoHeader.IsTransparent;
}
}
/// <summary>
/// Gets the bitmap source from clipboard asynchronous.
/// </summary>
/// <returns>Task<System.Object>.</returns>
public Task <object> GetBitmapSourceFromClipboardAsync()
{
if (System.Windows.Clipboard.GetData("DeviceIndependentBitmap") is MemoryStream iMemoryStream)
{
byte[] dibBuffer = new byte[Convert.ToInt32(iMemoryStream.Length - 1) + 1];
iMemoryStream.Read(dibBuffer, 0, dibBuffer.Length);
BITMAPINFOHEADER iInfoHeader = BinaryStructConverter.FromByteArray <BITMAPINFOHEADER>(dibBuffer);
int fileHeaderSize = Marshal.SizeOf(typeof(BITMAPFILEHEADER));
int infoHeaderSize = iInfoHeader.biSize;
int fileSize = fileHeaderSize + iInfoHeader.biSize + iInfoHeader.biSizeImage;
BITMAPFILEHEADER iFileHeader = new BITMAPFILEHEADER
{
bfType = BITMAPFILEHEADER.BM,
bfSize = fileSize,
bfReserved1 = 0,
bfReserved2 = 0,
bfOffBits = fileHeaderSize + infoHeaderSize + iInfoHeader.biClrUsed * 4
};
byte[] fileHeaderBytes = BinaryStructConverter.ToByteArray <BITMAPFILEHEADER>(iFileHeader);
MemoryStream iBitmapStream = new MemoryStream();
iBitmapStream.Write(fileHeaderBytes, 0, fileHeaderSize);
iBitmapStream.Write(dibBuffer, 0, dibBuffer.Length);
iBitmapStream.Seek(0, SeekOrigin.Begin);
return(Task.FromResult <object>(BitmapFrame.Create(iBitmapStream)));
}
return(Task.FromResult <object>(null));
}
public static byte[] GetByteArray(Bitmap image)
{
IntPtr hbmOld;
IntPtr hBitmap;
IntPtr hDC;
// create infoheader
BITMAPINFOHEADER bih = new BITMAPINFOHEADER(1, image.Height, image.Width);
// set black and white for 1 bit color palette
// create fileheader and get data size
uint sizeOfImageData;
BITMAPFILEHEADER bfh = new BITMAPFILEHEADER(bih, out sizeOfImageData);
// create device context in memory
hDC = Win32.CreateCompatibleDC(IntPtr.Zero);
// create a 1 bpp DIB
IntPtr pBits = IntPtr.Zero;
hBitmap = Win32.CreateDIBSection(hDC, ref bih, 1, ref pBits, IntPtr.Zero, 0);
// selet DIB into device context
hbmOld = Win32.SelectObject(hDC, hBitmap);
using (Graphics g = Graphics.FromHdc(hDC))
{
g.DrawImage(image, 0, 0);
}
byte[] imageData = new byte[sizeOfImageData];
byte[] fileData;
using (MemoryStream ms = new MemoryStream((int)bfh.bfSize))
{
using (BinaryWriter w = new BinaryWriter(ms))
{
bfh.Store(w);
// store bitmapinfoheader with 1 bpp color palette for black and white
bih.Store(w, new uint[] { (uint)0x0, (uint)0xffffff });
// copy image data into imageData buffer
Marshal.Copy(pBits, imageData, 0, imageData.Length);
// write imageData to stream
w.Write(imageData);
w.Close();
}
fileData = ms.GetBuffer();
ms.Close();
}
// select old object
if (hbmOld != IntPtr.Zero)
{
Win32.SelectObject(hDC, hbmOld);
}
// delete memory bitmap
if (hBitmap != IntPtr.Zero)
{
Win32.DeleteObject(hBitmap);
}
// delete memory device context
if (hDC != IntPtr.Zero)
{
Win32.DeleteDC(hDC);
}
return(fileData);
}
/*******************************************
* 函数名称：GetBitmap
* 函数功能：将传进来的数据保存为图片
* 函数入参：buffer---图片数据
* nWidth---图片的宽度
* nHeight---图片的高度
* 函数出参：无
* 函数返回：无
*********************************************/
public static void GetBitmap(byte[] buffer, int nWidth, int nHeight, ref MemoryStream ms)
{
int ColorIndex = 0;
ushort m_nBitCount = 8;
int m_nColorTableEntries = 256;
byte[] ResBuf = new byte[nWidth * nHeight];
try
{
BITMAPFILEHEADER BmpHeader = new BITMAPFILEHEADER();
BITMAPINFOHEADER BmpInfoHeader = new BITMAPINFOHEADER();
MASK[] ColorMask = new MASK[m_nColorTableEntries];
//图片头信息
BmpInfoHeader.biSize = Marshal.SizeOf(BmpInfoHeader);
BmpInfoHeader.biWidth = nWidth;
BmpInfoHeader.biHeight = nHeight;
BmpInfoHeader.biPlanes = 1;
BmpInfoHeader.biBitCount = m_nBitCount;
BmpInfoHeader.biCompression = 0;
BmpInfoHeader.biSizeImage = 0;
BmpInfoHeader.biXPelsPerMeter = 0;
BmpInfoHeader.biYPelsPerMeter = 0;
BmpInfoHeader.biClrUsed = m_nColorTableEntries;
BmpInfoHeader.biClrImportant = m_nColorTableEntries;
//文件头信息
BmpHeader.bfType = 0x4D42;
BmpHeader.bfOffBits = 14 + Marshal.SizeOf(BmpInfoHeader) + BmpInfoHeader.biClrUsed * 4;
BmpHeader.bfSize = BmpHeader.bfOffBits + ((((BmpInfoHeader.biWidth * BmpInfoHeader.biBitCount + 31) / 32) * 4) * BmpInfoHeader.biHeight);
BmpHeader.bfReserved1 = 0;
BmpHeader.bfReserved2 = 0;
ms.Write(StructToBytes(BmpHeader, 14), 0, 14);
ms.Write(StructToBytes(BmpInfoHeader, Marshal.SizeOf(BmpInfoHeader)), 0, Marshal.SizeOf(BmpInfoHeader));
//调试板信息
for (ColorIndex = 0; ColorIndex < m_nColorTableEntries; ColorIndex++)
{
ColorMask[ColorIndex].redmask = (byte)ColorIndex;
ColorMask[ColorIndex].greenmask = (byte)ColorIndex;
ColorMask[ColorIndex].bluemask = (byte)ColorIndex;
ColorMask[ColorIndex].rgbReserved = 0;
ms.Write(StructToBytes(ColorMask[ColorIndex], Marshal.SizeOf(ColorMask[ColorIndex])), 0, Marshal.SizeOf(ColorMask[ColorIndex]));
}
//图片旋转，解决指纹图片倒立的问题
RotatePic(buffer, nWidth, nHeight, ref ResBuf);
ms.Write(ResBuf, 0, nWidth * nHeight);
}
catch
{
// ZKCE.SysException.ZKCELogger logger = new ZKCE.SysException.ZKCELogger(ex);
// logger.Append();
}
}
/*******************************************
* �������ƣ�GetBitmap
* �������ܣ��������������ݱ���ΪͼƬ
* ������Σ�buffer---ͼƬ����
* nWidth---ͼƬ�Ŀ��
* nHeight---ͼƬ�ĸ߶�
* ����������
* �������أ���
*********************************************/
public static void GetBitmap(byte[] buffer, int nWidth, int nHeight, ref MemoryStream ms)
{
int ColorIndex = 0;
ushort m_nBitCount = 8;
int m_nColorTableEntries = 256;
byte[] ResBuf = new byte[nWidth * nHeight];
try
{
BITMAPFILEHEADER BmpHeader = new BITMAPFILEHEADER();
BITMAPINFOHEADER BmpInfoHeader = new BITMAPINFOHEADER();
MASK[] ColorMask = new MASK[m_nColorTableEntries];
//ͼƬͷ��Ϣ
BmpInfoHeader.biSize = Marshal.SizeOf(BmpInfoHeader);
BmpInfoHeader.biWidth = nWidth;
BmpInfoHeader.biHeight = nHeight;
BmpInfoHeader.biPlanes = 1;
BmpInfoHeader.biBitCount = m_nBitCount;
BmpInfoHeader.biCompression = 0;
BmpInfoHeader.biSizeImage = 0;
BmpInfoHeader.biXPelsPerMeter = 0;
BmpInfoHeader.biYPelsPerMeter = 0;
BmpInfoHeader.biClrUsed = m_nColorTableEntries;
BmpInfoHeader.biClrImportant = m_nColorTableEntries;
//�ļ�ͷ��Ϣ
BmpHeader.bfType = 0x4D42;
BmpHeader.bfOffBits = 14 + Marshal.SizeOf(BmpInfoHeader) + BmpInfoHeader.biClrUsed * 4;
BmpHeader.bfSize = BmpHeader.bfOffBits + ((((BmpInfoHeader.biWidth * BmpInfoHeader.biBitCount + 31) / 32) * 4) * BmpInfoHeader.biHeight);
BmpHeader.bfReserved1 = 0;
BmpHeader.bfReserved2 = 0;
ms.Write(StructToBytes(BmpHeader, 14), 0, 14);
ms.Write(StructToBytes(BmpInfoHeader, Marshal.SizeOf(BmpInfoHeader)), 0, Marshal.SizeOf(BmpInfoHeader));
//������Ϣ
for (ColorIndex = 0; ColorIndex < m_nColorTableEntries; ColorIndex++)
{
ColorMask[ColorIndex].redmask = (byte)ColorIndex;
ColorMask[ColorIndex].greenmask = (byte)ColorIndex;
ColorMask[ColorIndex].bluemask = (byte)ColorIndex;
ColorMask[ColorIndex].rgbReserved = 0;
ms.Write(StructToBytes(ColorMask[ColorIndex], Marshal.SizeOf(ColorMask[ColorIndex])), 0, Marshal.SizeOf(ColorMask[ColorIndex]));
}
//ͼƬ��ת�����ָ��ͼƬ����������
RotatePic(buffer, nWidth, nHeight, ref ResBuf);
ms.Write(ResBuf, 0, nWidth * nHeight);
}
catch (Exception ex)
{
// ZKCE.SysException.ZKCELogger logger = new ZKCE.SysException.ZKCELogger(ex);
// logger.Append();
}
}
private static byte[] GetControlBitmapArray(Control control)
{
control.Capture = true;
IntPtr hWnd = GetCapture();
control.Capture = false;
IntPtr hDC = GetDC(hWnd);
IntPtr hMemoryDC = CreateCompatibleDC(hDC);
BITMAPINFOHEADER bih = new BITMAPINFOHEADER();
bih.biSize = Marshal.SizeOf(bih);
bih.biBitCount = 24;
bih.biClrUsed = 0;
bih.biClrImportant = 0;
bih.biCompression = 0;
bih.biHeight = control.Height;
bih.biWidth = control.Width;
bih.biPlanes = 1;
int cb = (int)(bih.biHeight * bih.biWidth * bih.biBitCount / 8);
bih.biSizeImage = cb;
bih.biXPelsPerMeter = PelsPerMeter;
bih.biYPelsPerMeter = PelsPerMeter;
IntPtr pBits = IntPtr.Zero;
IntPtr pBIH = LocalAlloc(GPTR, bih.biSize);
Marshal.StructureToPtr(bih, pBIH, false);
IntPtr hBitmap = CreateDIBSection(hDC, pBIH, 0, ref pBits, IntPtr.Zero, 0);
BITMAPINFOHEADER bihMem = (BITMAPINFOHEADER)Marshal.PtrToStructure(pBIH, typeof(BITMAPINFOHEADER));
IntPtr hPreviousBitmap = SelectObject(hMemoryDC, hBitmap);
BitBlt(hMemoryDC, 0, 0, bih.biWidth, bih.biHeight, hDC, 0, 0, SRCCOPY);
byte[] bits = new byte[cb];
Marshal.Copy(pBits, bits, 0, cb);
BITMAPFILEHEADER bfh = new BITMAPFILEHEADER();
bfh.bfSize = (uint)cb + 0x36;
bfh.bfType = 0x4d42;
bfh.bfOffBits = 0x36;
int headerSize = 14;
byte[] header = new byte[headerSize];
BitConverter.GetBytes(bfh.bfType).CopyTo(header, 0);
BitConverter.GetBytes(bfh.bfSize).CopyTo(header, 2);
BitConverter.GetBytes(bfh.bfOffBits).CopyTo(header, 10);
byte[] data = new byte[cb + bfh.bfOffBits];
header.CopyTo(data, 0);
header = new byte[Marshal.SizeOf(bih)];
IntPtr pHeader = LocalAlloc(GPTR, Marshal.SizeOf(bih));
Marshal.StructureToPtr(bihMem, pHeader, false);
Marshal.Copy(pHeader, header, 0, Marshal.SizeOf(bih));
LocalFree(pHeader);
header.CopyTo(data, headerSize);
bits.CopyTo(data, (int)bfh.bfOffBits);
DeleteObject(SelectObject(hMemoryDC, hPreviousBitmap));
DeleteDC(hMemoryDC);
ReleaseDC(hDC);
return data;
}
private static BITMAPFILEHEADER createFileHeader(ref BITMAPINFOHEADER info)
{
BITMAPFILEHEADER header = new BITMAPFILEHEADER();
header.bfType = BFTYPE_BMP;
int headerSize = Marshal.SizeOf(header) + Marshal.SizeOf(info);
header.bfSize = (uint) headerSize + info.biSizeImage;
header.bfOffBits = (uint) headerSize;
return header;
}
private static BITMAPFILEHEADER createFileHeader(ref BITMAPINFOHEADER info)
{
BITMAPFILEHEADER header = new BITMAPFILEHEADER();
header.bfType = BFTYPE_BMP;
int headerSize = Marshal.SizeOf(header) + Marshal.SizeOf(info);
header.bfSize = (uint)headerSize + info.biSizeImage;
header.bfOffBits = (uint)headerSize;
return(header);
}
//构建BMP位图文件头
static void ContructBhh(int nWidth, int nHeight, ref BITMAPFILEHEADER bhh)
{
//int widthStep = (((nWidth * 24) + 31) & (~31)) / 8 ; //每行实际占用的大小（每行都被填充到一个4字节边界）
//bhh.bfSize = (DWORD)sizeof(BITMAPFILEHEADER) + (DWORD)sizeof(BITMAPINFOHEADER) + widthStep * nHeight;
bhh.bfType = 0x4d42;
bhh.bfReserved1 = 0;
bhh.bfReserved2 = 0;
//bhh.bfOffBits = (int)sizeof(BITMAPFILEHEADER) + (int)sizeof(BITMAPINFOHEADER);
bhh.bfOffBits = System.Runtime.InteropServices.Marshal.SizeOf(new BITMAPFILEHEADER()) +
System.Runtime.InteropServices.Marshal.SizeOf(new BITMAPINFOHEADER());
}
public static unsafe bool Load(IVideoProvider v, Stream s)
{
var bf = BITMAPFILEHEADER.FromStream(s);
var bi = BITMAPINFOHEADER.FromStream(s);
if (bf.bfType != 0x4d42 ||
bf.bfOffBits != bf.bfSize + bi.biSize ||
bi.biPlanes != 1 ||
bi.biBitCount != 32 ||
bi.biCompression != BitmapCompressionMode.BI_RGB)
{
return(false);
}
int inW = bi.biWidth;
int inH = bi.biHeight;
byte[] src = new byte[inW * inH * 4];
s.Read(src, 0, src.Length);
if (v is LoadedBMP)
{
var l = v as LoadedBMP;
l.BufferWidth = inW;
l.BufferHeight = inH;
l.VideoBuffer = new int[inW * inH];
}
int[] dst = v.GetVideoBuffer();
fixed(byte *srcp = src)
fixed(int *dstp = dst)
{
using (new SimpleTime("Blit"))
{
Blit(new BMP
{
Data = (int *)srcp,
Width = inW,
Height = inH
},
new BMP
{
Data = dstp,
Width = v.BufferWidth,
Height = v.BufferHeight,
});
}
}
return(true);
}
/// <summary>
/// Get .NET 'Bitmap' object from memory DIB via stream constructor.
/// This should work for most DIBs.
/// </summary>
/// <param name="dibPtr">Pointer to memory DIB, starting with BITMAPINFOHEADER.</param>
public static Bitmap WithStream(IntPtr dibPtr)
{
BITMAPFILEHEADER fh = new BITMAPFILEHEADER();
Type bmiTyp = typeof(BITMAPINFOHEADER);
BITMAPINFOHEADER bmi = (BITMAPINFOHEADER)Marshal.PtrToStructure(dibPtr, bmiTyp);
float resolutionX = bmi.biXPelsPerMeter * 0.0254f;
float resolutionY = bmi.biYPelsPerMeter * 0.0254f;
if (bmi.biSizeImage == 0)
{
bmi.biSizeImage = ((((bmi.biWidth * bmi.biBitCount) + 31) & ~31) >> 3) * Math.Abs(bmi.biHeight);
}
if ((bmi.biClrUsed == 0) && (bmi.biBitCount < 16))
{
bmi.biClrUsed = 1 << bmi.biBitCount;
}
int fhSize = Marshal.SizeOf(typeof(BITMAPFILEHEADER));
int dibSize = bmi.biSize + (bmi.biClrUsed * 4) + bmi.biSizeImage; // info + rgb + pixels
fh.Type = new Char[] { 'B', 'M' }; // "BM"
fh.bfSize = fhSize + dibSize; // final file size
fh.bfOffBits = fhSize + bmi.biSize + (bmi.biClrUsed * 4); // offset to pixels
byte[] data = new byte[fh.bfSize]; // file-sized byte[]
RawSerializeInto(fh, data); // serialize BITMAPFILEHEADER into byte[]
Marshal.Copy(dibPtr, data, fhSize, dibSize); // mem-copy DIB into byte[]
Bitmap tmp = null;
MemoryStream stream = null;
try
{
stream = new MemoryStream(data);
stream.Position = 0;
tmp = new Bitmap(stream); // 'tmp' is wired to stream (unfortunately)
}
catch { }
finally
{
if (stream != null)
{
stream.Close();
stream = null;
}
data = null;
}
tmp = new Bitmap(tmp);
tmp.SetResolution(resolutionX, resolutionY);
return(tmp);
}
private BITMAPFILEHEADER ReadFileHeader_UseBinaryReader( ) //使用BinaryReader进行读
{
BinaryReader br = new BinaryReader(stream);
BITMAPFILEHEADER x = new BITMAPFILEHEADER();
x.bfType = br.ReadInt16();
x.bfSize = br.ReadInt32();
x.bfReserved1 = br.ReadInt16();
x.bfReserved2 = br.ReadInt16();
x.bfOffBits = br.ReadInt32();
return(x);
}
private BITMAPFILEHEADER ReadFileHeader( ) //直接读到内存数组中
{
BITMAPFILEHEADER x = new BITMAPFILEHEADER();
int c = Marshal.SizeOf(x);
byte [] buffer = new byte[c];
stream.Read(buffer, 0, c);
unsafe
{
fixed(byte *p = buffer)
{
x = *((BITMAPFILEHEADER *)p);
}
}
return(x);
}
// Must be an "Embedded Resource"
// throws away the header and returns the byte array -
public static byte[] LoadBMPResource(string filename)
{
var assembly = Assembly.GetExecutingAssembly();
var resourceName = $"MeadowInvaders.{filename}";
using (Stream stream = assembly.GetManifestResourceStream(resourceName))
{
using (BinaryReader reader = new BinaryReader(stream))
{
var fh = new BITMAPFILEHEADER()
{
bfType = reader.ReadUInt16(),
bfSize = reader.ReadUInt32(),
bfReserved1 = reader.ReadUInt16(),
bfReserved2 = reader.ReadUInt16(),
bfOffBits = reader.ReadUInt32()
};
var ih = new BITMAPINFOHEADER()
{
biSize = reader.ReadUInt32(),
biWidth = reader.ReadInt32(),
biHeight = reader.ReadInt32(),
biPlanes = reader.ReadUInt16(),
biBitCount = reader.ReadUInt16(),
biCompression = (BitmapCompressionMode)reader.ReadUInt32(),
biSizeImage = reader.ReadUInt32(),
biXPelsPerMeter = reader.ReadInt32(),
biYPelsPerMeter = reader.ReadInt32(),
biClrUsed = reader.ReadUInt32(),
biClrImportant = reader.ReadUInt32()
};
if (ih.biCompression != BitmapCompressionMode.BI_RGB)
{
Console.WriteLine($"WARN not RGB {ih.biCompression}");
}
Console.WriteLine($"{ih.biWidth} x {ih.biHeight} {ih.biBitCount} bits {ih.biSizeImage} bytes: start {fh.bfOffBits}");
stream.Position = 0;
var header = reader.ReadBytes((int)fh.bfOffBits);
return(reader.ReadBytes(ih.biWidth / 8 * ih.biHeight));
}
}
}
public static unsafe void Save(IVideoProvider v, Stream s, int w, int h)
{
var bf = new BITMAPFILEHEADER();
var bi = new BITMAPINFOHEADER();
bf.bfType = 0x4d42;
bf.bfOffBits = bf.bfSize + bi.biSize;
bi.biPlanes = 1;
bi.biBitCount = 32; // xrgb
bi.biCompression = BitmapCompressionMode.BI_RGB;
bi.biSizeImage = (uint)(w * h * 4);
bi.biWidth = w;
bi.biHeight = h;
byte[] bfb = GetBytes(bf);
byte[] bib = GetBytes(bi);
s.Write(bfb, 0, bfb.Length);
s.Write(bib, 0, bib.Length);
int[] src = v.GetVideoBuffer();
byte[] dst = new byte[4 * w * h];
fixed(int *srcp = src)
fixed(byte *dstp = dst)
{
using (new SimpleTime("Blit"))
{
Blit(new BMP
{
Data = srcp,
Width = v.BufferWidth,
Height = v.BufferHeight
},
new BMP
{
Data = (int *)dstp,
Width = w,
Height = h,
});
}
}
s.Write(dst, 0, dst.Length);
}
public static Bitmap CreateDIB(int x, int y)
{
//Set up a BitmapHeader
Int32 Depth = DetermineColorDepth.getdepth();
BITMAPINFOHEADER bmpInfo = new BITMAPINFOHEADER((short) Depth, x, y);
BITMAPFILEHEADER bmpFile = new BITMAPFILEHEADER(bmpInfo);
byte[] buffer = new byte[bmpFile.bfSize];
MemoryStream m = new MemoryStream(buffer);
using (BinaryWriter writer = new BinaryWriter(m))
{
bmpFile.Store(writer);
bmpInfo.Store(writer, false);
m.Seek(0, SeekOrigin.Begin);
return new Bitmap(m);
}
}
public static void saveBitmapFile(string filename, BITMAPFILEHEADER BmFileHeader, BITMAPINFO BmInfo, byte[] pixeldata)
{
if (filename.Length <= 0)
{
//MessageBox.Show("select a file");
return;
}
// FileSystem.FileOpen(1, filename, OpenMode.Binary,OpenAccess.Default,OpenShare.Default,1000000 );
// //UPGRADE_WARNING: Put was upgraded to FilePut and has a new behavior. Click for more: 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="vbup1041"'
// FileSystem.FilePut(1, BmFileHeader, 1);
// //UPGRADE_WARNING: Put was upgraded to FilePut and has a new behavior. Click for more: 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="vbup1041"'
// FileSystem.FilePut(1, BmInfo, -1);
// //write the pixel data
// //UPGRADE_WARNING: Put was upgraded to FilePut and has a new behavior. Click for more: 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="vbup1041"'
// FileSystem.FilePut(1, pixeldata, -1);
// FileSystem.FileClose(1);
}
private void ReadAndShowBitmap(Graphics graph)
{
stream = new FileStream(fileName, FileMode.Open, FileAccess.Read);
BITMAPFILEHEADER fileHeader = ReadFileHeader_UseBinaryReader(); //文件头
//BITMAPFILEHEADER fileHeader = ReadFileHeader(); //文件头
BITMAPINFOHEADER bmpInfo = ReadInfo(); //信息头
if (bmpInfo.biBitCount != 24)
{
MessageBox.Show("本程序只能处理24位位图");
stream.Close();
return;
}
int w = bmpInfo.biWidth;
int h = bmpInfo.biHeight;
stream.Seek(fileHeader.bfOffBits, SeekOrigin.Begin); //略去一些字节，定位到图像数据处
int LineSize = w * 3;
if (LineSize % 4 != 0)
{
LineSize += 4 - (LineSize % 4); //每个图像点占3个字节。若一行不是4的倍数,则补齐
}
for (int i = 1; i <= h; i++) //各行
{
for (int j = 1; j <= w; j++) //各点
{
RGBTRIPLE point = ReadPixel();
Color color = Color.FromArgb(point.rgbtRed, point.rgbtGreen, point.rgbtBlue);
graph.DrawLine(new Pen(color, 1), j, h - i, j, h - i + 1); //注意图像的坐标上下是反的,另外，线的长度为1，才能画出点来
}
if (w * 3 % 4 != 0) //每行不是4的倍数,略出空字节
{
//stream.Seek( fileHeader.bfOffBits + LineSize * i, SeekOrigin.Begin );
stream.Seek(4 - w * 3 % 4, SeekOrigin.Current);
}
}
stream.Close();
}
public static bool SaveImageToFile(string filePath)
{
MemoryStream ms = GetImageData();
if (ms != null)
{
byte[] dibBuffer = new byte[ms.Length];
ms.Read(dibBuffer, 0, dibBuffer.Length);
BITMAPINFOHEADER infoHeader =
BinaryStructConverter.FromByteArray <BITMAPINFOHEADER>(dibBuffer);
int fileHeaderSize = Marshal.SizeOf(typeof(BITMAPFILEHEADER));
int infoHeaderSize = infoHeader.biSize;
int fileSize = fileHeaderSize + infoHeader.biSize + infoHeader.biSizeImage;
BITMAPFILEHEADER fileHeader = new BITMAPFILEHEADER();
fileHeader.bfType = BITMAPFILEHEADER.BM;
fileHeader.bfSize = fileSize;
fileHeader.bfReserved1 = 0;
fileHeader.bfReserved2 = 0;
fileHeader.bfOffBits = fileHeaderSize + infoHeaderSize + infoHeader.biClrUsed * 4;
byte[] fileHeaderBytes =
BinaryStructConverter.ToByteArray <BITMAPFILEHEADER>(fileHeader);
MemoryStream msBitmap = new MemoryStream();
msBitmap.Write(fileHeaderBytes, 0, fileHeaderSize);
msBitmap.Write(dibBuffer, 0, dibBuffer.Length);
msBitmap.Seek(0, SeekOrigin.Begin);
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
BitmapEncoder encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(msBitmap));
encoder.Save(fileStream);
}
return(true);
}
return(false);
}
public BitmapFrame GetImageFromClipboard()
{
if (!Clipboard.ContainsImage())
{
return(null);
}
MemoryStream ms = Clipboard.GetData("DeviceIndependentBitmap") as MemoryStream;
if (ms == null)
{
return(null);
}
byte[] dibBuffer = new byte[ms.Length];
ms.Read(dibBuffer, 0, dibBuffer.Length);
BITMAPINFOHEADER infoHeader = BinaryStructConverter.FromByteArray <BITMAPINFOHEADER>(dibBuffer);
int fileHeaderSize = Marshal.SizeOf(typeof(BITMAPFILEHEADER));
int infoHeaderSize = infoHeader.biSize;
int fileSize = fileHeaderSize + infoHeader.biSize + infoHeader.biSizeImage;
BITMAPFILEHEADER fileHeader = new BITMAPFILEHEADER
{
bfType = BITMAPFILEHEADER.BM,
bfSize = fileSize,
bfReserved1 = 0,
bfReserved2 = 0,
bfOffBits = fileHeaderSize + infoHeaderSize + (infoHeader.biClrUsed * 4),
};
byte[] fileHeaderBytes = BinaryStructConverter.ToByteArray <BITMAPFILEHEADER>(fileHeader);
using (MemoryStream msBitmap = new MemoryStream())
{
msBitmap.Write(fileHeaderBytes, 0, fileHeaderSize);
msBitmap.Write(dibBuffer, 0, dibBuffer.Length);
msBitmap.Seek(0, SeekOrigin.Begin);
return(BitmapFrame.Create(msBitmap, BitmapCreateOptions.None, BitmapCacheOption.OnLoad));
}
}
public Bitmap GetBitmap(IntPtr adibPtr)
{
IntPtr dibPtr;
BITMAPFILEHEADER fh = new BITMAPFILEHEADER();
dibPtr = GlobalLock(adibPtr);
Type bmiTyp = typeof(BITMAPINFOHEADER);
BITMAPINFOHEADER bmi = (BITMAPINFOHEADER)Marshal.PtrToStructure(dibPtr, bmiTyp);
if (bmi.biSizeImage == 0)
{
bmi.biSizeImage = ((((bmi.biWidth * bmi.biBitCount) + 31) & ~31) >> 3) * Math.Abs(bmi.biHeight);
}
if ((bmi.biClrUsed == 0) && (bmi.biBitCount < 16))
{
bmi.biClrUsed = 1 << bmi.biBitCount;
}
int fhSize = Marshal.SizeOf(typeof(BITMAPFILEHEADER));
int dibSize = bmi.biSize + (bmi.biClrUsed * 4) + bmi.biSizeImage;
fh.Type = new Char[] { 'B', 'M' };
fh.Size = fhSize + dibSize;
fh.OffBits = fhSize + bmi.biSize + (bmi.biClrUsed * 4);
byte[] data = new byte[fh.Size];
RawSerializeInto(fh, data);
Marshal.Copy(dibPtr, data, fhSize, dibSize);
MemoryStream stream = new MemoryStream(data);
Bitmap tmp = new Bitmap(stream);
Bitmap result = new Bitmap(tmp);
tmp.Dispose();
tmp = null;
stream.Close();
stream = null;
data = null;
GlobalFree(adibPtr);
return(result);
}
public static MemoryStream GetConvertedBytes(ref MemoryStream ms)
{
if(ms==null)return null;
byte[] dibBuffer=new byte[ms.Length];
ms.Read(dibBuffer,0,dibBuffer.Length);
BITMAPV5HEADER infoHeader=BinaryStructConverter.FromByteArray<BITMAPV5HEADER>(dibBuffer);
int fileHeaderSize=Marshal.SizeOf(typeof(BITMAPFILEHEADER));
int infoHeaderSize=infoHeader.bV5Size;
int fileSize=fileHeaderSize+infoHeader.bV5Size+infoHeader.bV5SizeImage;
BITMAPFILEHEADER fileHeader=new BITMAPFILEHEADER();
fileHeader.bfType=BITMAPFILEHEADER.BM;
fileHeader.bfSize=fileSize;
fileHeader.bfReserved1=0;
fileHeader.bfReserved2=0;
fileHeader.bfOffBits=fileHeaderSize+infoHeaderSize+infoHeader.bV5ClrUsed*4;
byte[] fileHeaderBytes=BinaryStructConverter.ToByteArray<BITMAPFILEHEADER>(fileHeader);
MemoryStream msBitmap=new MemoryStream();
msBitmap.Write(fileHeaderBytes,0,fileHeaderSize);
msBitmap.Write(dibBuffer,0,dibBuffer.Length);
msBitmap.Seek(0,SeekOrigin.Begin);
return msBitmap;
}
public void Save(string fileName)
{
var infoHeaderSize = Marshal.SizeOf(typeof(BITMAPINFOHEADER));
var fileHeaderSize = Marshal.SizeOf(typeof(BITMAPFILEHEADER));
var offBits = infoHeaderSize + fileHeaderSize;
BITMAPINFOHEADER infoHeader = new BITMAPINFOHEADER
{
biSize = (uint)infoHeaderSize,
biBitCount = 32,
biClrImportant = 0,
biClrUsed = 0,
biCompression = 0,
biHeight = -Height,
biWidth = Width,
biPlanes = 1,
biSizeImage = (uint)(Width * Height * 4)
};
BITMAPFILEHEADER fileHeader = new BITMAPFILEHEADER
{
bfType = 'B' + ('M' << 8),
bfOffBits = (uint)offBits,
bfSize = (uint)(offBits + infoHeader.biSizeImage)
};
using (var writer = new BinaryWriter(File.Open(fileName, FileMode.Create)))
{
writer.Write(GetBytes(fileHeader));
writer.Write(GetBytes(infoHeader));
foreach (var color in data)
{
writer.Write(color.B);
writer.Write(color.G);
writer.Write(color.R);
writer.Write(color.A);
}
}
}
/// <summary>
/// Get .NET 'Bitmap' object from memory DIB via stream constructor.
/// This should work for most DIBs.
/// </summary>
/// <param name="a_platform">Our operating system</param>
/// <param name="a_intptrNative">The pointer to something (presumably a BITMAP or a TIFF image)</param>
/// <returns>C# Bitmap of image</returns>
private Bitmap NativeToBitmap(Platform a_platform, IntPtr a_intptrNative)
{
ushort u16Magic;
IntPtr intptrNative;
// We need the first two bytes to decide if we have a DIB or a TIFF. Don't
// forget to lock the silly thing...
intptrNative = DsmMemLock(a_intptrNative);
u16Magic = (ushort)Marshal.PtrToStructure(intptrNative, typeof(ushort));
// Windows uses a DIB, the first usigned short is 40...
if (u16Magic == 40)
{
byte[] bBitmap;
BITMAPFILEHEADER bitmapfileheader;
BITMAPINFOHEADER bitmapinfoheader;
// Our incoming DIB is a bitmap info header...
bitmapinfoheader = (BITMAPINFOHEADER)Marshal.PtrToStructure(intptrNative, typeof(BITMAPINFOHEADER));
// Build our file header...
bitmapfileheader = new BITMAPFILEHEADER();
bitmapfileheader.bfType = 0x4D42; // "BM"
bitmapfileheader.bfSize
= (uint)Marshal.SizeOf(typeof(BITMAPFILEHEADER)) +
bitmapinfoheader.biSize +
(bitmapinfoheader.biClrUsed * 4) +
bitmapinfoheader.biSizeImage;
bitmapfileheader.bfOffBits
= (uint)Marshal.SizeOf(typeof(BITMAPFILEHEADER)) +
bitmapinfoheader.biSize +
(bitmapinfoheader.biClrUsed * 4);
// Copy the file header into our byte array...
IntPtr intptr = Marshal.AllocHGlobal(Marshal.SizeOf(bitmapfileheader));
Marshal.StructureToPtr(bitmapfileheader, intptr, true);
bBitmap = new byte[bitmapfileheader.bfSize];
Marshal.Copy(intptr, bBitmap, 0, Marshal.SizeOf(bitmapfileheader));
Marshal.FreeHGlobal(intptr);
intptr = IntPtr.Zero;
// Copy the rest of the DIB into our byte array......
Marshal.Copy(intptrNative, bBitmap, Marshal.SizeOf(typeof(BITMAPFILEHEADER)), (int)bitmapfileheader.bfSize - Marshal.SizeOf(typeof(BITMAPFILEHEADER)));
// Now we can turn the in-memory bitmap file into a Bitmap object...
MemoryStream memorystream = new MemoryStream(bBitmap);
// Unfortunately the stream has to be kept with the bitmap...
Bitmap bitmapStream = new Bitmap(memorystream);
// So we make a copy (ick)...
Bitmap bitmap = new Bitmap(bitmapStream);
// Cleanup...
//bitmapStream.Dispose();
//memorystream.Close();
bitmapStream = null;
memorystream = null;
bBitmap = null;
// Return our bitmap...
DsmMemUnlock(a_intptrNative);
return (bitmap);
}
// Linux and Mac OS X use TIFF. We'll handle a simple Intel TIFF ("II")...
else if (u16Magic == 0x4949)
{
int iTiffSize;
ulong u64;
ulong u64Pointer;
ulong u64TiffHeaderSize;
ulong u64TiffTagSize;
byte[] abTiff;
TIFFHEADER tiffheader;
TIFFTAG tifftag;
// Init stuff...
tiffheader = new TIFFHEADER();
tifftag = new TIFFTAG();
u64TiffHeaderSize = (ulong)Marshal.SizeOf(tiffheader);
u64TiffTagSize = (ulong)Marshal.SizeOf(tifftag);
// Find the size of the image so we can turn it into a memory stream...
iTiffSize = 0;
tiffheader = (TIFFHEADER)Marshal.PtrToStructure(intptrNative, typeof(TIFFHEADER));
for (u64 = 0; u64 < 999; u64++)
{
u64Pointer = (ulong)intptrNative + u64TiffHeaderSize + (u64TiffTagSize * u64);
tifftag = (TIFFTAG)Marshal.PtrToStructure((IntPtr)u64Pointer, typeof(TIFFTAG));
// StripOffsets...
if (tifftag.u16Tag == 273)
{
iTiffSize += (int)tifftag.u32Value;
}
// StripByteCounts...
if (tifftag.u16Tag == 279)
{
iTiffSize += (int)tifftag.u32Value;
}
}
// No joy...
if (iTiffSize == 0)
{
DsmMemUnlock(a_intptrNative);
return (null);
}
// Copy the data to our byte array...
abTiff = new byte[iTiffSize];
Marshal.Copy(intptrNative, abTiff, 0, iTiffSize);
// Move the image into a memory stream...
MemoryStream memorystream = new MemoryStream(abTiff);
// Turn the memory stream into an in-memory TIFF image...
Image imageTiff = Image.FromStream(memorystream);
// Convert the in-memory tiff to a Bitmap object...
Bitmap bitmap = new Bitmap(imageTiff);
// Cleanup...
abTiff = null;
memorystream = null;
imageTiff = null;
// Return our bitmap...
DsmMemUnlock(a_intptrNative);
return (bitmap);
}
// Uh-oh...
DsmMemUnlock(a_intptrNative);
return (null);
}
// parses a BITMAPFILEHEADER and BITMAPINFOHEADER to get
// the offset of the image bits, the size of the image and
// if it's a transparent bitmap.
private static void GetBitmapInfo(byte[] data, out uint BitsOffset, out uint ImageSize, out bool IsTransparent)
{
BitsOffset = 0;
ImageSize = 0;
IsTransparent = false;
using(BinaryReader reader = new BinaryReader(new MemoryStream(data)))
{
BITMAPFILEHEADER fileHeader = new BITMAPFILEHEADER();
BITMAPINFOHEADER infoHeader = new BITMAPINFOHEADER();
if(!fileHeader.Read(reader))
return;
if(!infoHeader.Read(reader))
return;
BitsOffset = fileHeader.bfOffBits;
ImageSize = (uint)(System.Math.Abs(infoHeader.biWidth) * System.Math.Abs(infoHeader.biHeight));
IsTransparent = infoHeader.IsTransparent;
}
}
private ImageSource ImageFromClipboardDib()
{
MemoryStream ms = Clipboard.GetData("DeviceIndependentBitmap") as MemoryStream;
if (ms != null)
{
byte[] dibBuffer = new byte[ms.Length];
ms.Read(dibBuffer, 0, dibBuffer.Length);
BITMAPINFOHEADER infoHeader =
BinaryStructConverter.FromByteArray<BITMAPINFOHEADER>(dibBuffer);
int fileHeaderSize = Marshal.SizeOf(typeof(BITMAPFILEHEADER));
int infoHeaderSize = infoHeader.biSize;
int fileSize = fileHeaderSize + infoHeader.biSize + infoHeader.biSizeImage;
BITMAPFILEHEADER fileHeader = new BITMAPFILEHEADER();
fileHeader.bfType = BITMAPFILEHEADER.BM;
fileHeader.bfSize = fileSize;
fileHeader.bfReserved1 = 0;
fileHeader.bfReserved2 = 0;
fileHeader.bfOffBits = fileHeaderSize + infoHeaderSize + infoHeader.biClrUsed * 4;
byte[] fileHeaderBytes =
BinaryStructConverter.ToByteArray<BITMAPFILEHEADER>(fileHeader);
MemoryStream msBitmap = new MemoryStream();
msBitmap.Write(fileHeaderBytes, 0, fileHeaderSize);
msBitmap.Write(dibBuffer, 0, dibBuffer.Length);
msBitmap.Seek(0, SeekOrigin.Begin);
return BitmapFrame.Create(msBitmap);
}
return null;
}
protected override ClipboardItem CreateNew(ClipboardSnapshot snapshot)
#endif
{
try
{
if (snapshot.HasFormat(KnownClipboardFormats.CF_DIBV5))
//device independent bitmap (with transparency - yay!)
{
IntPtr pointer = IntPtr.Zero;
try
{
pointer = snapshot.FetchDataPointer(KnownClipboardFormats.CF_DIBV5);
var infoHeader =
(BITMAPV5HEADER)Marshal.PtrToStructure(pointer, typeof(BITMAPV5HEADER));
using (
var bitmap = new Bitmap((int)infoHeader.bV5Width, (int)infoHeader.bV5Height,
(int)(infoHeader.bV5SizeImage / infoHeader.bV5Height),
PixelFormat.Format32bppArgb,
new IntPtr(pointer.ToInt64() + infoHeader.bV5Size)))
{
var bitmapSource = new RenderTargetBitmap((int)infoHeader.bV5Width,
(int)infoHeader.bV5Height,
96, 96, PixelFormats.Pbgra32);
var visual = new DrawingVisual();
var drawingContext = visual.RenderOpen();
drawingContext.DrawImage(CreateBitmapSourceFromBitmap(bitmap),
new Rect(0, 0, (int)infoHeader.bV5Width,
(int)infoHeader.bV5Height));
drawingContext.Close();
bitmapSource.Render(visual);
var result = new ClipboardImage();
result.Image = bitmapSource;
return result;
}
}
finally
{
if (pointer != IntPtr.Zero)
{
Marshal.FreeHGlobal(pointer);
}
}
}
}
catch (ArgumentException)
{
//this dibv5 format was faulty. let's roll back to normal dib.
}
//TODO: do we need the below or don't we? will the above work for all formats?
if (snapshot.HasFormat(KnownClipboardFormats.CF_DIB)) //device independent bitmap
{
byte[] buffer = snapshot.FetchData(KnownClipboardFormats.CF_DIB);
var infoHeader =
ApiHelper.ByteArrayToStructure<BITMAPINFOHEADER>(buffer);
int fileHeaderSize = Marshal.SizeOf(typeof(BITMAPFILEHEADER));
int infoHeaderSize = infoHeader.biSize;
int fileSize = fileHeaderSize + infoHeader.biSize + infoHeader.biSizeImage;
var fileHeader = new BITMAPFILEHEADER();
fileHeader.bfType = BITMAPFILEHEADER.BM;
fileHeader.bfSize = fileSize;
fileHeader.bfReserved1 = 0;
fileHeader.bfReserved2 = 0;
fileHeader.bfOffBits = fileHeaderSize + infoHeaderSize + infoHeader.biClrUsed * 4;
byte[] fileHeaderBytes =
ApiHelper.StructureToByteArray(fileHeader);
var bitmapStream = new MemoryStream();
bitmapStream.Write(fileHeaderBytes, 0, fileHeaderSize);
bitmapStream.Write(buffer, 0, buffer.Length);
bitmapStream.Seek(0, SeekOrigin.Begin);
BitmapFrame bitmap = BitmapFrame.Create(bitmapStream);
var result = new ClipboardImage();
result.Image = bitmap;
return result;
}
if(snapshot.HasFormat(KnownClipboardFormats.CF_ENHMETAFILE))
{
byte[] buffer = snapshot.FetchData(KnownClipboardFormats.CF_ENHMETAFILE);
using (var memoryStream = new MemoryStream(buffer))
{
using(var metafile = new Metafile(memoryStream))
{
using (var bitmap = new Bitmap(metafile.Width, metafile.Height))
{
using (var graphics = Graphics.FromImage(bitmap))
{
graphics.DrawImage(metafile, 0, 0);
var result = new ClipboardImage();
result.Image = CreateBitmapSourceFromBitmap(bitmap);
return result;
}
}
}
}
}
var formatResult = string.Empty;
foreach (var format in snapshot.FormatPriorities)
{
formatResult += format + ", ";
}
if (!string.IsNullOrEmpty(formatResult))
{
formatResult = formatResult.Substring(0, formatResult.Length - 2);
}
throw new InvalidOperationException("None of the image formats from " + ClipboardSource.ApplicationNameFromWindowHandle(snapshot.OutsideClipboardOwnerHandle) + " were known (" + formatResult + ")");
}
// [i] 撮影位置[ms]
//=========================================================================
/// <summary>
/// 動画の指定されたフレームのBMPストリームを作成
/// </summary>
/// <remarks>
/// </remarks>
/// <history>2010/01/24 新規作成</history>
//=========================================================================
public unsafe MemoryStream GetFrameImage(
long pos )
{
try
{
long width;
long height;
long bufSize = 0;
//-------------------------
// 指定位置までシーク
//-------------------------
Guid TIME_FORMAT_MEDIA_TIME = new Guid("7b785574-8c82-11cf-bc0c-00aa00ac74f6");
mMediaSeek.SetTimeFormat( ref TIME_FORMAT_MEDIA_TIME );
long posMicroSec = pos * 1000 * 1000 * 10; // per 0.1microsec
int Result = 0;
Result = mMediaSeek.SetPositions(
ref posMicroSec ,
DirectShow.AM_SEEKING_AbsolutePositioning,
IntPtr.Zero,
DirectShow.AM_SEEKING_NoPositioning );
if( Result != DirectShow.S_OK )
throw new RenderFailedException();
//--------------------------
// フレームイメージ取り込み
//--------------------------
mBasicVideo.get_VideoWidth(out width);
mBasicVideo.get_VideoHeight(out height);
if( width <= 0 || height <= 0 )
throw new RenderFailedException();
mBasicVideo.GetCurrentImage(ref bufSize, IntPtr.Zero);
if( bufSize <= 0 )
throw new RenderFailedException();
using( UnmanageMemory bmpMem = new UnmanageMemory( (int)bufSize ) )
{
mBasicVideo.GetCurrentImage( ref bufSize, bmpMem.GetAddress() );
//------------------------------------------------
// BMPファイルイメージをメモリストリームへ書き出し
//------------------------------------------------
BITMAPFILEHEADER bmphdr = new BITMAPFILEHEADER();
BITMAPINFOHEADER bmpinfo = new BITMAPINFOHEADER();
MemoryStream fs = new MemoryStream( (int)bufSize );
bmphdr.bfType = ('M' << 8) | 'B';
bmphdr.bfSize = (uint)(Marshal.SizeOf(bmphdr) + Marshal.SizeOf(bmpinfo) + bufSize);
bmphdr.bfOffBits = (uint)(Marshal.SizeOf(bmphdr) + Marshal.SizeOf(bmpinfo));
bmpinfo.biSize = (uint)(Marshal.SizeOf(bmpinfo));
bmpinfo.biWidth = (int)width;
bmpinfo.biHeight = (int)height;
bmpinfo.biPlanes = 1;
bmpinfo.biBitCount = 32;
StructToBytesHelper bmphdrBytes = new StructToBytesHelper( bmphdr );
StructToBytesHelper bmpinfoBytes = new StructToBytesHelper( bmpinfo );
fs.Write( bmphdrBytes.GetBytes() , 0, bmphdrBytes.Size );
fs.Write( bmpinfoBytes.GetBytes(), 0, bmpinfoBytes.Size );
fs.Write( bmpMem.GetBytes(), 0, (int)bufSize );
return fs;
}
}
catch(Exception ex)
{
throw new RenderFailedException();
}
}
private byte[] GetBitmapFileHeader(int imgWidth, int imgHeight, System.Drawing.Imaging.ColorPalette colorPalette = null)
{
var rgbSize = Marshal.SizeOf(typeof(RGBQUAD));
//height is < 0 since image is flipped
var bmpInfoHeader = new BITMAPINFOHEADER(imgWidth, -imgHeight, (uint)(imgHeight * imgWidth));
var headerSize = Marshal.SizeOf(bmpInfoHeader) + Marshal.SizeOf(typeof(BITMAPFILEHEADER)) + rgbSize * 256;
var bmpFileHeader = new BITMAPFILEHEADER((uint)(imgWidth * imgHeight + headerSize), (uint)headerSize);
List<byte> palette = new List<byte>(256);
//if palete is not provided
if (colorPalette == null)
{
//fill palette with shades of gray
for (int i = 0; i < 256; i++)
{
palette.AddRange(RlViewer.Behaviors.Converters.StructIO.WriteStruct<RGBQUAD>(new RGBQUAD((byte)i, (byte)i, (byte)i)));
}
}
else
{
for (int i = 0; i < 256; i++)
{
var color = colorPalette.Entries[i];
palette.AddRange(RlViewer.Behaviors.Converters.StructIO.WriteStruct<RGBQUAD>(new RGBQUAD((byte)color.R, (byte)color.G, (byte)color.B)));
}
}
List<byte> bmpHeader = new List<byte>();
bmpHeader.AddRange(RlViewer.Behaviors.Converters.StructIO.WriteStruct<BITMAPFILEHEADER>(bmpFileHeader));
bmpHeader.AddRange(RlViewer.Behaviors.Converters.StructIO.WriteStruct<BITMAPINFOHEADER>(bmpInfoHeader));
bmpHeader.AddRange(palette);
return bmpHeader.ToArray();
}
