mirror of
https://github.com/soukoku/ntwain.git
synced 2025-04-05 20:59:23 +08:00
334 lines
13 KiB
C#
334 lines
13 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Drawing;
|
|
using System.Drawing.Imaging;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
|
|
namespace NTwain.Interop
|
|
{
|
|
// this is a good read
|
|
// http://atlc.sourceforge.net/bmp.html
|
|
|
|
/// <summary>
|
|
/// Defines the dimensions and color information for a DIB.
|
|
/// </summary>
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
struct BITMAPINFO
|
|
{
|
|
/// <summary>
|
|
/// Structure that contains information about the dimensions of color format.
|
|
/// </summary>
|
|
public BITMAPINFOHEADER bmiHeader;
|
|
/// <summary>
|
|
/// This contains one of the following:
|
|
/// 1. An array of RGBQUAD. The elements of the array that make up the color table.
|
|
/// 2. An array of 16-bit unsigned integers that specifies indexes into the currently realized logical palette. This use of bmiColors is allowed for functions that use DIBs.
|
|
/// The number of entries in the array depends on the values of the biBitCount and biClrUsed members of the BITMAPINFOHEADER structure.
|
|
/// </summary>
|
|
public IntPtr bmiColors;
|
|
|
|
};
|
|
|
|
/// <summary>
|
|
/// Structure that contains information about the dimensions and color format of a DIB.
|
|
/// </summary>
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
struct BITMAPINFOHEADER
|
|
{
|
|
#region fields
|
|
/// <summary>
|
|
/// The number of bytes required by the structure.
|
|
/// </summary>
|
|
public uint biSize;
|
|
/// <summary>
|
|
/// The width of the bitmap, in pixels.
|
|
/// If Compression is JPEG or PNG, the Width member specifies the width of the decompressed
|
|
/// JPEG or PNG image file, respectively.
|
|
/// </summary>
|
|
public int biWidth;
|
|
/// <summary>
|
|
/// The height of the bitmap, in pixels. If Height is positive,
|
|
/// the bitmap is a bottom-up DIB and its origin is the lower-left corner.
|
|
/// If Height is negative, the bitmap is a top-down DIB and its origin is the upper-left corner.
|
|
/// If Height is negative, indicating a top-down DIB, Compression must be either RGB or BITFIELDS. Top-down DIBs cannot be compressed.
|
|
/// If Compression is JPEG or PNG, the Height member specifies the height of the decompressed JPEG or PNG image file, respectively.
|
|
/// </summary>
|
|
public int biHeight;
|
|
/// <summary>
|
|
/// The number of planes for the target device. This value must be set to 1.
|
|
/// </summary>
|
|
public ushort biPlanes;
|
|
/// <summary>
|
|
/// The number of bits-per-pixel. The BitCount member
|
|
/// determines the number of bits that define each pixel and the maximum number of colors in the bitmap.
|
|
/// </summary>
|
|
public ushort biBitCount;
|
|
/// <summary>
|
|
/// The type of compression for a compressed bottom-up bitmap (top-down DIBs cannot be compressed).
|
|
/// </summary>
|
|
public CompressionType biCompression;
|
|
/// <summary>
|
|
/// The size, in bytes, of the image. This may be set to zero for RGB bitmaps.
|
|
/// If Compression is JPEG or PNG, SizeImage indicates the size of the JPEG or PNG image buffer, respectively.
|
|
/// </summary>
|
|
public uint biSizeImage;
|
|
/// <summary>
|
|
/// The horizontal resolution, in pixels-per-meter, of the target device for the bitmap.
|
|
/// An application can use this value to select a bitmap from a resource group that
|
|
/// best matches the characteristics of the current device.
|
|
/// </summary>
|
|
public int biXPelsPerMeter;
|
|
/// <summary>
|
|
/// The vertical resolution, in pixels-per-meter, of the target device for the bitmap.
|
|
/// </summary>
|
|
public int biYPelsPerMeter;
|
|
/// <summary>
|
|
/// The number of color indexes in the color table that are actually used by the bitmap.
|
|
/// If this value is zero, the bitmap uses the maximum number of colors corresponding to
|
|
/// the value of the BitCount member for the compression mode specified by Compression.
|
|
/// </summary>
|
|
public uint biClrUsed;
|
|
/// <summary>
|
|
/// The number of color indexes that are required for displaying the bitmap.
|
|
/// If this value is zero, all colors are required.
|
|
/// </summary>
|
|
public uint biClrImportant;
|
|
#endregion
|
|
|
|
#region utilities
|
|
|
|
const double METER_INCH_RATIO = 39.3700787;
|
|
|
|
/// <summary>
|
|
/// Gets the horizontal dpi of the bitmap.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public float GetXDpi()
|
|
{
|
|
return (float)Math.Round(biXPelsPerMeter / METER_INCH_RATIO, 0);
|
|
}
|
|
/// <summary>
|
|
/// Gets the vertical dpi of the bitmap.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public float GetYDpi()
|
|
{
|
|
return (float)Math.Round(biYPelsPerMeter / METER_INCH_RATIO, 0);
|
|
}
|
|
/// <summary>
|
|
/// Gets the size of the structure.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public static uint GetByteSize()
|
|
{
|
|
return (uint)Marshal.SizeOf(typeof(BITMAPINFOHEADER));
|
|
}
|
|
/// <summary>
|
|
/// Checks to see if this structure contain valid data.
|
|
/// It also fills in any missing pieces if possible.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool Validate()
|
|
{
|
|
if (biHeight != 0 && biWidth != 0 && biBitCount != 0)
|
|
{
|
|
if (biSize == 0)
|
|
{
|
|
biSize = GetByteSize();
|
|
}
|
|
if (biClrUsed == 0)
|
|
{
|
|
switch (biBitCount)
|
|
{
|
|
case 1:
|
|
biClrUsed = 2;
|
|
break;
|
|
case 4:
|
|
biClrUsed = 16;
|
|
break;
|
|
case 8:
|
|
biClrUsed = 256;
|
|
break;
|
|
}
|
|
}
|
|
if (biSizeImage == 0)
|
|
{
|
|
biSizeImage = (uint)((((
|
|
biWidth * biBitCount) + 31) & ~31) >> 3) * (uint)Math.Abs(biHeight);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the pointer to scan0 given the header pointer.
|
|
/// </summary>
|
|
/// <param name="headerPtr">The header PTR.</param>
|
|
/// <returns></returns>
|
|
public IntPtr GetScan0(IntPtr headerPtr)
|
|
{
|
|
int p = (int)biClrUsed;
|
|
if ((p == 0) && (biBitCount <= 8))
|
|
{
|
|
p = 1 << biBitCount;
|
|
}
|
|
p = (p * 4) + (int)biSize + headerPtr.ToInt32();
|
|
return new IntPtr(p);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets whether the bitmap is bottom-up or top-down format.
|
|
/// </summary>
|
|
/// <value>
|
|
/// <c>true</c> if this instance is bottom up image; otherwise, <c>false</c>.
|
|
/// </value>
|
|
/// <returns></returns>
|
|
public bool IsBottomUpImage
|
|
{
|
|
get
|
|
{
|
|
return biHeight > 0;
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Gets the System.Drawing pixel format of current structure.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public PixelFormat GetDrawingPixelFormat()
|
|
{
|
|
switch (biBitCount)
|
|
{
|
|
case 1:
|
|
return PixelFormat.Format1bppIndexed;
|
|
case 4:
|
|
return PixelFormat.Format4bppIndexed;
|
|
case 8:
|
|
return PixelFormat.Format8bppIndexed;
|
|
case 16:
|
|
return PixelFormat.Format16bppRgb565;
|
|
case 24:
|
|
return PixelFormat.Format24bppRgb;
|
|
case 32:
|
|
return PixelFormat.Format32bppRgb;
|
|
case 48:
|
|
return PixelFormat.Format48bppRgb;
|
|
}
|
|
return PixelFormat.DontCare;
|
|
}
|
|
/// <summary>
|
|
/// Gets the color palette that's contained in the header.
|
|
/// Note not all images will have palette, so check if the return value
|
|
/// is null before using it.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public ColorPalette GetDrawingPalette(IntPtr headerPtr)
|
|
{
|
|
//if (format == PixelFormat.Format8bppIndexed)
|
|
//{
|
|
// // update color palette to grayscale version
|
|
// ColorPalette grayPallet = bitmap.Palette;
|
|
// for (int i = 0; i < grayPallet.Entries.Length; i++)
|
|
// {
|
|
// grayPallet.Entries[i] = Color.FromArgb(i, i, i);
|
|
// }
|
|
// bitmap.Palette = grayPallet; // this is what makes the gray pallet take effect
|
|
//}
|
|
|
|
if (biClrUsed > 0)
|
|
{
|
|
byte[] data = new byte[biClrUsed * 4];
|
|
Marshal.Copy(new IntPtr(headerPtr.ToInt32() + biSize), data, 0, data.Length);
|
|
var dummy = new System.Drawing.Bitmap(1, 1, GetDrawingPixelFormat());
|
|
ColorPalette pal = dummy.Palette;
|
|
dummy.Dispose();
|
|
int index = 0;
|
|
int setCount = data.Length / 4;
|
|
for (int i = 0; i < setCount; i++)
|
|
{
|
|
index = i * 4;
|
|
pal.Entries[i] = Color.FromArgb(data[index + 2], data[index + 1], data[index]);
|
|
}
|
|
return pal;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the stride size of this bitmap.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public int GetStride()
|
|
{
|
|
int bitsPerRow = (biBitCount * biWidth);
|
|
int strideTest = bitsPerRow / 8 + (bitsPerRow % 8 != 0 ? 1 : 0);
|
|
int overage = strideTest % 4;
|
|
if (overage > 0)
|
|
{
|
|
strideTest += (4 - overage);
|
|
}
|
|
return strideTest;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a <see cref="System.String" /> that represents this instance.
|
|
/// </summary>
|
|
/// <returns>
|
|
/// A <see cref="System.String" /> that represents this instance.
|
|
/// </returns>
|
|
public override string ToString()
|
|
{
|
|
return new StringBuilder().Append("BitmapInfoHeader:")
|
|
.Append("\r\n\tSize = " + biSize)
|
|
.Append("\r\n\tWidth = " + biWidth)
|
|
.Append("\r\n\tHeight = " + biHeight)
|
|
.Append("\r\n\tPlanes = " + biPlanes)
|
|
.Append("\r\n\tBitCount = " + biBitCount)
|
|
.Append("\r\n\tCompression = " + biCompression)
|
|
.Append("\r\n\tSizeImage = " + biSizeImage)
|
|
.Append("\r\n\tXPixelsPerMeter = " + biXPelsPerMeter)
|
|
.Append("\r\n\tYPixelsPerMeter = " + biYPelsPerMeter)
|
|
.Append("\r\n\tColorUsed = " + biClrUsed)
|
|
.Append("\r\n\tColorImportant = " + biClrImportant).ToString();
|
|
}
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Indicates the bitmap compression of <seealso cref="BITMAPINFOHEADER"/>.
|
|
/// </summary>
|
|
public enum CompressionType : uint
|
|
{
|
|
/// <summary>
|
|
/// An uncompressed format.
|
|
/// </summary>
|
|
BI_RGB = 0,
|
|
/// <summary>
|
|
/// A run-length encoded (RLE) format for bitmaps with 8 bpp. The compression format is a 2-byte format consisting of a count byte followed by a byte containing a color index. For more information, see Bitmap Compression.
|
|
/// </summary>
|
|
BI_RLE8 = 1,
|
|
/// <summary>
|
|
/// An RLE, format for bitmaps with 4 bpp. The compression format is a 2-byte format consisting of a count byte followed by two word-length color indexes. For more information, see Bitmap Compression.
|
|
/// </summary>
|
|
BI_RLE4 = 2,
|
|
/// <summary>
|
|
/// Specifies that the bitmap is not compressed and that the color table consists of three DWORD color masks that specify the red, green, and blue components of each pixel.
|
|
/// This is valid when used with 16- and 32-bpp bitmaps.
|
|
/// </summary>
|
|
BI_BITFIELDS = 3,
|
|
/// <summary>
|
|
/// Indicates that the image is a JPEG image.
|
|
/// </summary>
|
|
BI_JPEG = 4,
|
|
/// <summary>
|
|
/// Indicates that the image is a PNG image.
|
|
/// </summary>
|
|
BI_PNG = 5
|
|
}
|
|
};
|
|
|
|
}
|