BMP file format

From Wikipedia, the free encyclopedia - View original article

Windows Bitmap
Filename extension.bmp
Internet media typeimage/bmp,[1]
image/x-bmp
Type code'BMP '
'BMPf'
'BMPp'
Uniform Type Identifier (UTI)com.microsoft.bmp
Type of formatRaster graphics
Open format?OSP for WMF
 
Jump to: navigation, search
Windows Bitmap
Filename extension.bmp
Internet media typeimage/bmp,[1]
image/x-bmp
Type code'BMP '
'BMPf'
'BMPp'
Uniform Type Identifier (UTI)com.microsoft.bmp
Type of formatRaster graphics
Open format?OSP for WMF

The BMP file format, also known as bitmap image file or device independent bitmap (DIB) file format or simply a bitmap, is a raster graphics image file format used to store bitmap digital images, independently of the display device (such as a graphics adapter), especially on Microsoft Windows[2] and OS/2[3] operating systems.

The BMP file format is capable of storing 2D digital images of arbitrary width, height, and resolution, both monochrome and color, in various color depths, and optionally with data compression, alpha channels, and color profiles. The Windows Metafile (WMF) specification covers the BMP file format.[4] Among others wingdi.h defines BMP constants and structures.

Device-independent bitmaps and the BMP file format[edit]

Microsoft has defined a particular representation of color bitmaps of different color depths, as an aid to exchanging bitmaps between devices and applications with a variety of internal representations. They called these device-independent bitmaps or DIBs, and the file format for them is called DIB file format or BMP image file format.

According to Microsoft support:[5]

A device-independent bitmap (DIB) is a format used to define device-independent bitmaps in various color resolutions. The main purpose of DIBs is to allow bitmaps to be moved from one device to another (hence, the device-independent part of the name). A DIB is an external format, in contrast to a device-dependent bitmap, which appears in the system as a bitmap object (created by an application...). A DIB is normally transported in metafiles (usually using the StretchDIBits() function), BMP files, and the Clipboard (CF_DIB data format).

Diag. 1 – The structure of the bitmap image file

The following sections discuss the data stored in the BMP file or DIB in detail. This is the standard BMP file format.[5] Some applications create bitmap image files which are not compliant with the current Microsoft documentation. Also, not all fields are used; a value of 0 will be found in these unused fields.

File structure[edit]

The bitmap image file consists of fixed-size structures (headers) as well as variable-size structures appearing in a predetermined sequence. Many different versions of some of these structures can appear in the file, due to the long evolution of this file format.

Referring to the diagram 1, the bitmap file is composed of structures in the following order:

Structure NameOptionalSizePurposeComments
Bitmap File HeaderNo14 BytesTo store general information about the Bitmap Image FileNot needed after the file is loaded in memory
DIB HeaderNoFixed-size
(however 7 different versions exist)
To store detailed information about the bitmap image and define the pixel formatImmediately follows the Bitmap File Header
Extra bit masksYes3 or 4 DWORDs[6]
(12 or 16 Bytes)
To define the pixel formatPresent only in case the DIB Header is the BITMAPINFOHEADER
Color TableSemi-optionalVariable-sizeTo define colors used by the bitmap image data (Pixel Array)Mandatory for color depths <= 8
Gap1YesVariable-sizeStructure alignmentAn artifact of the File Offset to PixelArray in the Bitmap File Header
Pixel ArrayNoVariable-sizeTo define the actual values of the pixelsThe pixel format is defined by the DIB Header or Extra bit masks. Each row in the Pixel Array is padded to a multiple of 4 bytes in size
Gap2YesVariable-sizeStructure alignmentAn artifact of the ICC Profile Data offset field in the DIB Header
ICC Color ProfileYesVariable-sizeTo define the color profile for color managementCan also contain a path to an external file containing the color profile. When loaded in memory as "non-packed DIB", it is located between the color table and gap1.[7]


DIBs in memory[edit]

A bitmap image file loaded into memory becomes a DIB data structure – an important component of the Windows GDI API. The in-memory DIB data structure is almost the same as the BMP file format, but it does not contain the 14-byte bitmap file header and begins with the DIB header. For DIBs loaded in memory, the color table can also consist of 16 bit entries, that constitute indexes to the currently realized palette[8] (an additional level of indirection), instead of explicit RGB color definitions. In all cases, the pixel array must begin at a memory address that is a multiple of 4 bytes. In non-packed DIBs loaded in memory, the optional color profile data should be located immediately after the color table and before the gap1 and pixel array[7] (unlike in diag. 1).

When the size of gap1 and gap2 is zero, the in-memory DIB data structure is customarily referred to as "packed DIB" and can be referred to by a single pointer pointing to the beginning of the DIB header. In all cases, the pixel array must begin at a memory address that is a multiple of 4 bytes. In some cases it may be necessary to adjust the number of entries in the color table in order to force the memory address of the pixel array to a multiple of 4 bytes.[8] For "packed DIBs" loaded in memory, the optional color profile data should immediately follow the pixel array, as depicted in diag. 1 (with gap1=0 and gap2=0).[7]
"Packed DIBs" are required by Windows clipboard API functions as well as by some Windows patterned brush and resource functions.[9]

Bitmap file header[edit]

This block of bytes is at the start of the file and is used to identify the file. A typical application reads this block first to ensure that the file is actually a BMP file and that it is not damaged. The first two bytes of the BMP file format are the character 'B' then the character 'M' in 1-byte ASCII encoding. All of the integer values are stored in little-endian format (i.e. least-significant byte first).

Offset#SizePurpose
02 bytesthe header field used to identify the BMP & DIB file is 0x42 0x4D in hexadecimal, same as BM in ASCII. The following entries are possible:
  • BM – Windows 3.1x, 95, NT, ... etc.
  • BA – OS/2 struct Bitmap Array
  • CI – OS/2 struct Color Icon
  • CP – OS/2 const Color Pointer
  • IC – OS/2 struct Icon
  • PT – OS/2 Pointer
24 bytesthe size of the BMP file in bytes
62 bytesreserved; actual value depends on the application that creates the image
82 bytesreserved; actual value depends on the application that creates the image
104 bytesthe offset, i.e. starting address, of the byte where the bitmap image data (pixel array) can be found.

The size value occupies 4 bytes by default. However, with the use of the 4 reserved bytes, this value can occupy 8 bytes (64 bits) while still conforming to the BMPfile header format.

DIB header (bitmap information header)[edit]

This block of bytes tells the application detailed information about the image, which will be used to display the image on the screen. The block also matches the header used internally by Windows and OS/2 and has several different variants. All of them contain a dword (32 bit) field, specifying their size, so that an application can easily determine which header is used in the image. The reason that there are different headers is that Microsoft extended the DIB format several times. The new extended headers can be used with some GDI functions instead of the older ones, providing more functionality. Since the GDI supports a function for loading bitmap files, typical Windows applications use that functionality. One consequence of this is that for such applications, the BMP formats that they support match the formats supported by the Windows version being run. See the table below for more information.

Windows and OS/2 Bitmap headers
SizeHeader NameOS supportFeaturesWritten by
12BITMAPCOREHEADER
OS21XBITMAPHEADER
Windows 2.0 or later
OS/2 1.x[3]
64OS22XBITMAPHEADEROS/2 BITMAPCOREHEADER2Adds halftoning. Adds RLE and Huffman 1D compression.
40BITMAPINFOHEADERWindows NT & 3.1x or later[2]Adds 16bpp and 32bpp formats. Adds RLE compression.
52BITMAPV2INFOHEADERUndocumented.Adds RGB bit masks.Adobe Photoshop
56BITMAPV3INFOHEADERNot officially documented, but I found this documentation on Adobe's forums, posted by an actual Adobe employee. https://forums.adobe.com/message/3272950#3272950Adds alpha channel bit mask.Adobe Photoshop
108BITMAPV4HEADERWindows NT 4.0 & 95 or laterAdds color space type and gamma correction
124BITMAPV5HEADERWindows NT 5.0 & 98 or laterAdds ICC color profiles
OffsetSizeOS/2 1.x BITMAPCOREHEADER[3]
144the size of this header (12 bytes)
182the bitmap width in pixels (unsigned 16bit)
202the bitmap height in pixels (unsigned 16bit)
222the number of color planes must be 1
242the number of bits per pixel
OS/2 1.x bitmaps are uncompressed and cannot be 16 or 32bpp.

Versions after BITMAPCOREHEADER only add fields to the end of the header of the previous version. For example: BITMAPV2INFOHEADER adds fields to BITMAPINFOHEADER and BITMAPV3INFOHEADER adds fields to BITMAPV2INFOHEADER.

An integrated alpha channel has been introduced with the undocumented BITMAPV3INFOHEADER and with the documented BITMAPV4HEADER (since Windows 95) and is used within Windows XP logon and theme system as well as Microsoft Office (since v2000); it is supported by some image editing software, such as Adobe Photoshop since version 7 and Adobe Flash since version MX 2004 (then known as Macromedia Flash). It is also supported by GIMP, Google Chrome, Microsoft PowerPoint and Microsoft Word.

For compatibility reasons, most applications use the older DIB headers for saving files. With OS/2 not more supported after Windows 2000, for now the common Windows format is the BITMAPINFOHEADER header. See next table for its description. All values are stored as unsigned integers, unless explicitly noted.

OffsetSizeWindows BITMAPINFOHEADER[2]
144the size of this header (40 bytes)
184the bitmap width in pixels (signed integer)
 
224the bitmap height in pixels (signed integer)
 
262the number of color planes must be 1
282the number of bits per pixel, which is the color depth of the image. Typical values are 1, 4, 8, 16, 24 and 32.
304the compression method being used. See the next table for a list of possible values
344the image size. This is the size of the raw bitmap data; a dummy 0 can be given for BI_RGB bitmaps.
384the horizontal resolution of the image. (pixel per meter, signed integer)
424the vertical resolution of the image. (pixel per meter, signed integer)
464the number of colors in the color palette, or 0 to default to 2n
504the number of important colors used, or 0 when every color is important; generally ignored

An OS/2 2.x OS22XBITMAPHEADER aka BITMAPCOREHEADER2 contains 24 additional bytes not yet explained here.[3] The compression method (offset 30) can be:

ValueIdentified byCompression methodComments
0BI_RGBnoneMost common
1BI_RLE8RLE 8-bit/pixelCan be used only with 8-bit/pixel bitmaps
2BI_RLE4RLE 4-bit/pixelCan be used only with 4-bit/pixel bitmaps
3BI_BITFIELDSOS22XBITMAPHEADER: Huffman 1DBITMAPV2INFOHEADER: RGB bit field masks,
BITMAPV3INFOHEADER+: RGBA
4BI_JPEGOS22XBITMAPHEADER: RLE-24BITMAPV4INFOHEADER+: JPEG image for printing[10]
5BI_PNGBITMAPV4INFOHEADER+: PNG image for printing[10]
6BI_ALPHABITFIELDSRGBA bit field masksonly Windows CE 5.0 with .NET 4.0 or later
11BI_CMYKnoneonly Windows Metafile CMYK[4]
12BI_CMYKRLE8RLE-8only Windows Metafile CMYK
13BI_CMYKTLE4RLE-4only Windows Metafile CMYK

Color table[edit]

The color table (palette) occurs in the BMP image file directly after the BMP file header, the DIB header (and after optional three red, green and blue bitmasks if the BITMAPINFOHEADER header with BI_BITFIELDS option is used). Therefore, its offset is the size of the BITMAPFILEHEADER plus the size of the DIB header (plus optional 12 bytes for the three bit masks).
Note: On Windows CE the BITMAPINFOHEADER header can be used with the BI_ALPHABITFIELDS[6] option in the biCompression member.

The number of entries in the palette is either 2n or a smaller number specified in the header (in the OS/2 BITMAPCOREHEADER header format, only the full-size palette is supported).[3][5] In most cases, each entry in the color table occupies 4 bytes, in the order blue, green, red, 0x00 (see below for exceptions). This is indexed in the BITMAPINFOHEADER under the function biBitCount.

The color table is a block of bytes (a table) listing the colors used by the image. Each pixel in an indexed color image is described by a number of bits (1, 4, or 8) which is an index of a single color described by this table. The purpose of the color palette in indexed color bitmaps is to inform the application about the actual color that each of these index values corresponds to. The purpose of the color table in non-indexed (non-palettized) bitmaps is to list the colors used by the bitmap for the purposes of optimization on devices with limited color display capability and to facilitate future conversion to different pixel formats and paletization.

The colors in the color table are usually specified in the 4-byte per entry RGBA32 format. The color table used with the OS/2 BITMAPCOREHEADER uses the 3-byte per entry RGB24 format.[3][5] For DIBs loaded in memory, the color table can optionally consist of 2-byte entries - these entries constitute indexes to the currently realized palette[8] instead of explicit RGB color definitions.

Microsoft does not disallow the presence of a valid alpha channel bit mask[11] in BITMAPV4HEADER and BITMAPV5HEADER for 1bpp, 4bpp and 8bpp indexed color images, which indicates that the color table entries can also specify an alpha component using the 8.8.8.[0-8].[0-8] format via the RGBQUAD.rgbReserved[12] member. However, some versions of Microsoft's documentation disallow this feature by stating that the RGBQUAD.rgbReserved member "must be zero".

As mentioned above, the color table is normally not used when the pixels are in the 16-bit per pixel (16bpp) format (and higher); there are normally no color table entries in those bitmap image files. However, the Microsoft documentation (on the MSDN web site as of Nov. 16, 2010[13]) specifies that for 16bpp (and higher), the color table can be present to store a list of colors intended for optimization on devices with limited color display capability, while it also specifies, that in such cases, no indexed palette entries are present in this Color Table. This may seem like a contradiction if no distinction is made between the mandatory palette entries and the optional color list.

Pixel storage[edit]

The bits representing the bitmap pixels are packed in rows. The size of each row is rounded up to a multiple of 4 bytes (a 32-bit DWORD) by padding.
For images with height > 1, multiple padded rows are stored consecutively, forming a Pixel Array.

The total number of bytes necessary to store one row of pixels can be calculated as:

\mbox{RowSize} = \left\lfloor\frac { \mbox{BitsPerPixel} \cdot \mbox{ImageWidth}+31  }{32}\right\rfloor \cdot 4,
ImageWidth is expressed in pixels.

The total amount of bytes necessary to store an array of pixels in an n bits per pixel (bpp) image, with 2n colors, can be calculated by accounting for the effect of rounding up the size of each row to a multiple of a 4 bytes, as follows:

\mbox{PixelArraySize} = \mbox{RowSize} \cdot \left | \mbox{ImageHeight} \right  \vert
ImageHeight is expressed in pixels. The absolute value is necessary because ImageHeight can be negative

Pixel array (bitmap data)[edit]

The pixel array is a block of 32-bit DWORDs, that describes the image pixel by pixel. Normally pixels are stored "upside-down" with respect to normal image raster scan order, starting in the lower left corner, going from left to right, and then row by row from the bottom to the top of the image.[5] Unless BITMAPCOREHEADER is used, uncompressed Windows bitmaps also can be stored from the top to bottom, when the Image Height value is negative.

In the original OS/2 DIB, the only four legal values of color depth were 1, 4, 8, and 24 bits per pixel (bpp).[5] Contemporary DIB Headers allow pixel formats with 1, 2, 4, 8, 16, 24 and 32 bits per pixel (bpp).[14] GDI+ also permits 64 bits per pixel.[15]

Padding bytes (not necessarily 0) must be appended to the end of the rows in order to bring up the length of the rows to a multiple of four bytes. When the pixel array is loaded into memory, each row must begin at a memory address that is a multiple of 4. This address/offset restriction is mandatory only for Pixel Arrays loaded in memory. For file storage purposes, only the size of each row must be a multiple of 4 bytes while the file offset can be arbitrary.[5] A 24-bit bitmap with Width=1, would have 3 bytes of data per row (blue, green, red) and 1 byte of padding, while Width=2 would have 2 bytes of padding, Width=3 would have 3 bytes of padding, and Width=4 would not have any padding at all.

Compression[edit]

Pixel format[edit]

In a bitmap image file on a disk or a bitmap image in memory, the pixels can be defined by a varying number of bits.

In order to resolve the ambiguity of which bits define which samples, the DIB Headers provide certain defaults as well as specific BITFIELDS which are bit masks that define the membership of particular group of bits in a pixel to a particular channel. The following diagram defines this mechanism:

The BITFIELDS mechanism depicted in RGBAX sample length notation

Diag. 2 – The BITFIELDS mechanism for a 32 bit pixel depicted in RGBAX sample length notation

The sample fields defined by the BITFIELDS bit masks have to be contiguous and non-overlapping but the order of the sample fields is arbitrary. The most ubiquitous field order is: Alpha, Blue, Green, Red (MSB to LSB). The red, green and blue bit masks are valid only when the Compression member of the DIB header is set to BI_BITFIELDS. The alpha bit mask is valid whenever it is present in the DIB header or when the Compression member of the DIB header is set to BI_ALPHABITFIELDS[6] (Windows CE only).

The BITFIELDS mechanism depicted in RGBAX sample length notation

Diag. 3 – The pixel format with an alpha channel in a 16 bit pixel (in RGBAX sample Length notation) actually generated by Adobe Photoshop[16]

All of the possible pixel formats in a DIB

RGB video subtypes[edit]

The BITFIELD mechanism described above allows for the definition of tens of thousands different pixel formats, however only several of them are used in practice,[16] all palettized formats RGB8, RGB4, and RGB1 (marked in yellow in the table above, dshow.h MEDIASUBTYPE names) and:

Uncompressed RGB Video Subtypes[17]
R.G.B.A.XRGB subtypeR.G.B.A.XARGB subtype
8.8.8.0.8RGB328.8.8.8.0ARGB32
10.10.10.2.0A2R10G10B10
8.8.8.0.0RGB2410.10.10.2.0A2B10G10R10
5.6.5.0.0RGB5654.4.4.4.0ARGB4444
5.5.5.0.1RGB5555.5.5.1.0ARGB1555
Bit fields for ten RGB bits[17]
Bit fieldOffsetBits A2R10G10B10Bits A2B10G10R10
Red36h00 00 F0 3FBE: 3FF000002029FF 03 00 00BE: 000003FF 0 9
Green3Ah00 FC 0F 00BE: 000FFC00101900 FC 0F 00BE: 000FFC001019
Blue3EhFF 03 00 00BE: 000003FF 0 900 00 F0 3FBE: 3FF000002029
Alpha42h00 00 00 C0BE: C0000000303100 00 00 C0BE: C00000003031


In version 2.1.4 FFmpeg supported (in its own terminology) the BMP pixel formats bgra, bgr24, rgb565le, rgb555le, rgb444le, rgb8, bgr8, rgb4_byte, bgr4_byte, gray, pal8, and monob; i.e., bgra was the only supported pixel format with transparency.[18]

Example 1 of a 2×2 pixel bitmap, with 24 bits/pixel encoding

Example 1[edit]

Following is an example of a 2×2 pixel, 24-bit bitmap (Windows DIB header BITMAPINFOHEADER) with pixel format RGB24.

OffsetSizeHex ValueValueDescription
BMP Header
0h242 4D"BM"ID field (42h, 4Dh)
2h446 00 00 0070 bytes (54+16)Size of the BMP file
6h200 00UnusedApplication specific
8h200 00UnusedApplication specific
Ah436 00 00 0054 bytes (14+40)Offset where the pixel array (bitmap data) can be found
DIB Header
Eh428 00 00 0040 bytesNumber of bytes in the DIB header (from this point)
12h402 00 00 002 pixels (left to right order)Width of the bitmap in pixels
16h402 00 00 002 pixels (bottom to top order)Height of the bitmap in pixels. Positive for bottom to top pixel order.
1Ah201 001 planeNumber of color planes being used
1Ch218 0024 bitsNumber of bits per pixel
1Eh400 00 00 000BI_RGB, no pixel array compression used
22h410 00 00 0016 bytesSize of the raw bitmap data (including padding)
26h413 0B 00 002835 pixels/meter horizontalPrint resolution of the image,
72 DPI × 39.3701 inches per meter yields 2834.6472
2Ah413 0B 00 002835 pixels/meter vertical
2Eh400 00 00 000 colorsNumber of colors in the palette
32h400 00 00 000 important colors0 means all colors are important
Start of pixel array (bitmap data)
36h300 00 FF0 0 255Red, Pixel (0,1)
39h3FF FF FF255 255 255White, Pixel (1,1)
3Ch200 000 0Padding for 4 byte alignment (could be a value other than zero)
3Eh3FF 00 00255 0 0Blue, Pixel (0,0)
41h300 FF 000 255 0Green, Pixel (1,0)
44h200 000 0Padding for 4 byte alignment (could be a value other than zero)


0,0: blue FF0000 FF0,1: green 00FF00 FF0,2: red 00000FF FF0,3: white FFFFFF FF1,0: blue FF0000 7F, half transparent1,1: green 00FF00 7F, half transparent1,2: red 0000FF 7F, half transparent1,3: white FFFFFF 7F, half transparent
About this image
Example 2 of a 4×2 pixel bitmap, with 32 bits/pixel encoding

Example 2[edit]

Following is an example of a 4×2 pixel, 32-bit bitmap with opacity values in the alpha channel (Windows DIB Header BITMAPV4HEADER) with pixel format ARGB32.

OffsetSizeHex ValueValueDescription
BMP Header
0h242 4D"BM"Magic number (unsigned integer 66, 77)
2h49A 00 00 00154 bytes (122+32)Size of the BMP file
6h200 00UnusedApplication specific
8h200 00UnusedApplication specific
Ah47A 00 00 00122 bytes (14+108)Offset where the pixel array (bitmap data) can be found
DIB Header
Eh46C 00 00 00108 bytesNumber of bytes in the DIB header (from this point)
12h404 00 00 004 pixels (left to right order)Width of the bitmap in pixels
16h402 00 00 002 pixels (bottom to top order)Height of the bitmap in pixels
1Ah201 001 planeNumber of color planes being used
1Ch220 0032 bitsNumber of bits per pixel
1Eh403 00 00 003BI_BITFIELDS, no pixel array compression used
22h420 00 00 0032 bytesSize of the raw bitmap data (including padding)
26h413 0B 00 002835 pixels/meter horizontalPrint resolution of the image,
72 DPI × 39.3701 inches per meter yields 2834.6472
2Ah413 0B 00 002835 pixels/meter vertical
2Eh400 00 00 000 colorsNumber of colors in the palette
32h400 00 00 000 important colors0 means all colors are important
36h400 00 FF 0000FF0000 in big-endianRed channel bit mask (valid because BI_BITFIELDS is specified)
3Ah400 FF 00 000000FF00 in big-endianGreen channel bit mask (valid because BI_BITFIELDS is specified)
3Eh4FF 00 00 00000000FF in big-endianBlue channel bit mask (valid because BI_BITFIELDS is specified)
42h400 00 00 FFFF000000 in big-endianAlpha channel bit mask
46h420 6E 69 57little-endian "Win "LCS_WINDOWS_COLOR_SPACE
4Ah24h24* 00...00CIEXYZTRIPLE Color Space endpointsUnused for LCS "Win " or "sRGB"
6Eh400 00 00 000 Red GammaUnused for LCS "Win " or "sRGB"
72h400 00 00 000 Green GammaUnused for LCS "Win " or "sRGB"
76h400 00 00 000 Blue GammaUnused for LCS "Win " or "sRGB"
Start of the Pixel Array (the bitmap Data)
7Ah4FF 00 00 7F255 0 0 127Blue (Alpha: 127), Pixel (0,1)
7Eh400 FF 00 7F0 255 0 127Green (Alpha: 127), Pixel (1,1)
82h400 00 FF 7F0 0 255 127Red (Alpha: 127), Pixel (2,1)
86h4FF FF FF 7F255 255 255 127White (Alpha: 127), Pixel (3,1)
8Ah4FF 00 00 FF255 0 0 255Blue (Alpha: 255), Pixel (0,0)
8Eh400 FF 00 FF0 255 0 255Green (Alpha: 255), Pixel (1,0)
92h400 00 FF FF0 0 255 255Red (Alpha: 255), Pixel (2,0)
96h4FF FF FF FF255 255 255 255White (Alpha: 255), Pixel (3,0)

Note that the bitmap data starts with the lower left hand corner of the image.

Usage of BMP format[edit]

The simplicity of the BMP file format, and its widespread familiarity in Windows and elsewhere, as well as the fact that this format is relatively well documented and free of patents, makes it a very common format that image processing programs from many operating systems can read and write. ICO and CUR files contain bitmaps starting with a BITMAPINFOHEADER.

Many older graphical user interfaces used bitmaps in their built-in graphics subsystems;[19] for example, the Microsoft Windows and OS/2 platforms' GDI subsystem, where the specific format used is the Windows and OS/2 bitmap file format, usually named with the file extension of .BMP.[20]

While most BMP files have a relatively large file size due to lack of any compression (or generally low-ratio run-length encoding on palletized images), many BMP files can be considerably compressed with lossless data compression algorithms such as ZIP because they contain redundant data. Some formats, such as RAR, even include routines specifically targeted at efficient compression of such data.

Related formats[edit]

Main article: Image file formats

The X Window System uses a similar XBM format for black-and-white images, and XPM (pixelmap) for color images. There are also a variety of "raw" formats, which saves raw data with no other information. The Portable Pixmap (PPM) and Truevision TGA formats also exist, but are less often used – or only for special purposes; for example, TGA can contain transparency information. Other bitmap file formats are in existence.[21]

References[edit]

  1. ^ .bmp MIME type not registered at IANA
  2. ^ a b c James D. Murray, William vanRyper (1996-04). "Encyclopedia of Graphics File Formats, Second Edition". O'Reilly. bmp. ISBN 1-56592-161-5. Retrieved 2014-03-07. 
  3. ^ a b c d e f James D. Murray, William vanRyper (1996-04). "Encyclopedia of Graphics File Formats, Second Edition". O'Reilly. os2bmp. ISBN 1-56592-161-5. Retrieved 2014-03-07. 
  4. ^ a b "[MS-WMF]: Windows Metafile Format". MSDN. 2014-02-13. Retrieved 2014-03-12. 
  5. ^ a b c d e f g h i j "DIBs and Their Uses". Microsoft Help and Support. 2005-02-11. 
  6. ^ a b c MSDN - BITMAPINFOHEADER (Windows CE 5.0): BI_ALPHABITFIELDS in biCompression member
  7. ^ a b c MSDN Bitmap Header Types
  8. ^ a b c MSDN BITMAPINFO Structure
  9. ^ Feng Yuan - Windows graphics programming: Win32 GDI and DirectDraw: Packed Device-Independent Bitmap (CreateDIBPatternBrush, CreateDIBPatternBrushPt, FindResource, LoadResource, LockResource)
  10. ^ a b "JPEG and PNG Extensions for Specific Bitmap Functions and Structures". 
  11. ^ MSDN - BITMAPV4HEADER: The member bV4AlphaMask
  12. ^ MSDN - RGBQUAD: rgbReserved member
  13. ^ see note under biClrUsed MSDN BITMAPINFOHEADER
  14. ^ MSDN - BITMAPINFOHEADER: The member biBitCount
  15. ^ "Types of Bitmaps". MSDN. 2012-06-03. Retrieved 2014-03-16. 
  16. ^ a b c MSDN: Windows CE - BITMAPINFOHEADER Structure
  17. ^ a b "Uncompressed RGB Video Subtypes". dshow.h. MSDN. Retrieved 2014-03-11. 
  18. ^ "Image Formats". FFmpeg General Documentation. 2014. Retrieved 2014-02-23. 
  19. ^ Julian Smart, Stefan Csomor, and Kevin Hock (2006). Cross-Platform GUI Programming with Wxwidgets. Prentice Hall. ISBN 0-13-147381-6. 
  20. ^ "Bitmap Image File (BMP), Version 5". Digital Preservation. Library of Congress. 2014-01-08. Retrieved 2014-03-11. 
  21. ^ "List of bitmap file types". Search File-Extensions.org. 

External links[edit]