MSDN Documentation

Understanding Bitmaps in Windows Graphics

Bitmaps, also known as raster images, are fundamental to displaying graphical content in Windows. They represent an image as a grid of pixels, where each pixel has a specific color value. This section explores the core concepts of bitmaps within the Windows graphics subsystem.

What is a Bitmap?

A bitmap is a data structure that describes the properties of a rectangular grid of pixels. Each pixel in the grid is assigned a specific color. The number of bits used to represent each pixel determines the color depth of the bitmap, influencing the range of colors that can be displayed.

Bitmap Properties

Key properties of a bitmap include:

• Width and Height: The dimensions of the pixel grid in pixels.
• Color Depth: The number of bits per pixel (BPP). Common values include 1 BPP (monochrome), 4 BPP (16 colors), 8 BPP (256 colors), 16 BPP (65,536 colors), 24 BPP (16.7 million colors), and 32 BPP (which often includes an alpha channel for transparency).
• Color Format: How color information is encoded. This can vary, but common formats include RGB, BGR, and ARGB (with alpha).
• Scan Line: A horizontal row of pixels in the bitmap. The memory layout of a bitmap is often described in terms of scan lines, with padding sometimes used to ensure each scan line aligns to a specific byte boundary for performance reasons.

Bitmap Representation in Windows

In Windows, bitmaps are typically handled using structures like BITMAP and device-independent bitmaps (DIBs). DIBs are particularly important as they describe the pixel data independently of the output device, making them highly portable.

Device-Independent Bitmaps (DIBs)

DIBs are composed of two main parts:

1. Bitmap Information Header: This structure contains information about the bitmap's dimensions, color format, compression method, and more. Key headers include BITMAPCOREHEADER, BITMAPINFOHEADER, BITMAPV4HEADER, and BITMAPV5HEADER, with later versions offering more features like gamma correction and color masks.
2. Pixel Data: The actual array of color values for each pixel, organized row by row (scan lines). The order of scan lines can be from bottom to top or top to bottom, which is also specified in the header.

Working with Bitmaps

The Windows GDI (Graphics Device Interface) and GDI+ provide extensive functionality for creating, manipulating, and displaying bitmaps. This includes:

• Loading and saving bitmap files (e.g., BMP, JPG, PNG).
• Drawing and painting bitmaps onto surfaces.
• Performing transformations like scaling, rotation, and color adjustments.
• Managing transparency using alpha channels.

Example: Creating a Simple Bitmap (Conceptual)

While direct pixel manipulation can be complex, GDI functions simplify this. For instance, one might use:

// Conceptual example - actual API calls are more involved
HDC hdcScreen = GetDC(NULL); // Get screen DC
HDC hdcBitmap = CreateCompatibleDC(hdcScreen); // Create a memory DC

// Define bitmap dimensions and color depth
int width = 100;
int height = 50;
int bitsPerPixel = 24;

// Create a DIB section (a DIB that can be directly selected into a DC)
BITMAPINFO bmi;
bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmi.bmiHeader.biWidth = width;
bmi.bmiHeader.biHeight = height;
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = bitsPerPixel;
bmi.bmiHeader.biCompression = BI_RGB; // Uncompressed

// Create the bitmap buffer
BYTE* pBitmapBits = NULL;
HBITMAP hBitmap = CreateDIBSection(hdcScreen, &bmi, DIB_RGB_COLORS, (void**)&pBitmapBits, NULL, 0);

// Select the bitmap into the memory DC
HBITMAP hOldBitmap = (HBITMAP)SelectObject(hdcBitmap, hBitmap);

// Now, 'pBitmapBits' points to the raw pixel data.
// You can write color values to it directly:
// For example, to set the first pixel to red:
// if (pBitmapBits) {
//     pBitmapBits[0] = 0;     // Blue
//     pBitmapBits[1] = 0;     // Green
//     pBitmapBits[2] = 255;   // Red
// }

// Draw on the bitmap using GDI functions in hdcBitmap...

// Clean up
SelectObject(hdcBitmap, hOldBitmap); // Restore original bitmap in DC
DeleteObject(hBitmap);
DeleteDC(hdcBitmap);
ReleaseDC(NULL, hdcScreen);
            

Performance Considerations

Handling large bitmaps can be performance-intensive. Optimizations include using appropriate color depths, employing compression where suitable, and leveraging hardware acceleration through technologies like DirectX for complex graphical operations.

Understanding the underlying structure and manipulation techniques for bitmaps is crucial for developing efficient and visually rich Windows applications.