Sign in to follow this  

what is wrong with this code?

Recommended Posts

CJWR    180
this code is from the book Tricks of the Windows Game Programming Gurus by Andre Lamothe. It is supposed to load a 24 bit image, convert it to 16 bit, and display it on the screen. However, all it does is display a black screen. :( i have the bitmap it is supposed to load, one bitmap24.bmp in the correct folder. so i think it is something with this code.
// DEMO7_11.CPP 16-bit bitmap loading demo

// INCLUDES ///////////////////////////////////////////////

#define WIN32_LEAN_AND_MEAN  // just say no to MFC

#define INITGUID

#include <windows.h>   // include important windows stuff
#include <windowsx.h> 
#include <mmsystem.h>
#include <iostream.h> // include important C/C++ stuff
#include <conio.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <string.h>
#include <stdarg.h>
#include <stdio.h> 
#include <math.h>
#include <io.h>
#include <fcntl.h>

#include <ddraw.h> // include directdraw

// DEFINES ////////////////////////////////////////////////

// defines for windows 

// default screen size
#define SCREEN_WIDTH    640  // size of screen
#define SCREEN_HEIGHT   480
#define SCREEN_BPP      16   // bits per pixel

#define BITMAP_ID            0x4D42 // universal id for a bitmap
#define MAX_COLORS_PALETTE   256

// TYPES //////////////////////////////////////////////////////

// basic unsigned types
typedef unsigned short USHORT;
typedef unsigned short WORD;
typedef unsigned char  UCHAR;
typedef unsigned char  BYTE;

// container structure for bitmaps .BMP file
typedef struct BITMAP_FILE_TAG
        BITMAPFILEHEADER bitmapfileheader;  // this contains the bitmapfile header
        BITMAPINFOHEADER bitmapinfoheader;  // this is all the info including the palette
        PALETTEENTRY     palette[256];      // we will store the palette here
        UCHAR            *buffer;           // this is a pointer to the data


// PROTOTYPES  //////////////////////////////////////////////

int Flip_Bitmap(UCHAR *image, int bytes_per_line, int height);

int Load_Bitmap_File(BITMAP_FILE_PTR bitmap, char *filename);

int Unload_Bitmap_File(BITMAP_FILE_PTR bitmap);

// MACROS /////////////////////////////////////////////////

// tests if a key is up or down
#define KEYDOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
#define KEYUP(vk_code)   ((GetAsyncKeyState(vk_code) & 0x8000) ? 0 : 1)

// initializes a direct draw struct
#define DDRAW_INIT_STRUCT(ddstruct) { memset(&ddstruct,0,sizeof(ddstruct)); ddstruct.dwSize=sizeof(ddstruct); }

// this builds a 16 bit color value in 5.5.5 format (1-bit alpha mode)
#define _RGB16BIT555(r,g,b) ((b%32) + ((g%32) << 5) + ((r%32) << 10))

// this builds a 16 bit color value in 5.6.5 format (green dominate mode)
#define _RGB16BIT565(r,g,b) ((b%32) + ((g%64) << 6) + ((r%32) << 11))

// this builds a 32 bit color value in A.8.8.8 format (8-bit alpha mode)
#define _RGB32BIT(a,r,g,b) ((b) + ((g) << 8) + ((r) << 16) + ((a) << 24))

// GLOBALS ////////////////////////////////////////////////

HWND      main_window_handle = NULL; // globally track main window
int       window_closed      = 0;    // tracks if window is closed
HINSTANCE hinstance_app      = NULL; // globally track hinstance

// directdraw stuff

LPDIRECTDRAW          lpdd         = NULL;   // dd object
LPDIRECTDRAW4         lpdd4        = NULL;   // dd4 object
LPDIRECTDRAWSURFACE4  lpddsprimary = NULL;   // dd primary surface
LPDIRECTDRAWSURFACE4  lpddsback    = NULL;   // dd back surface
LPDIRECTDRAWPALETTE   lpddpal      = NULL;   // a pointer to the created dd palette
LPDIRECTDRAWCLIPPER   lpddclipper  = NULL;   // dd clipper
PALETTEENTRY          palette[256];          // color palette
PALETTEENTRY          save_palette[256];     // used to save palettes
DDSURFACEDESC2        ddsd;                  // a direct draw surface description struct
DDBLTFX               ddbltfx;               // used to fill
DDSCAPS2              ddscaps;               // a direct draw surface capabilities struct
HRESULT               ddrval;                // result back from dd calls
DWORD                 start_clock_count = 0; // used for timing

BITMAP_FILE           bitmap;                // holds the bitmap

char buffer[80];                             // general printing buffer

// FUNCTIONS ////////////////////////////////////////////////

int Load_Bitmap_File(BITMAP_FILE_PTR bitmap, char *filename)
// this function opens a bitmap file and loads the data into bitmap

int file_handle,  // the file handle
    index;        // looping index

UCHAR   *temp_buffer = NULL; // used to convert 24 bit images to 16 bit
OFSTRUCT file_data;          // the file data information

// open the file if it exists
if ((file_handle = OpenFile(filename,&file_data,OF_READ))==-1)

// now load the bitmap file header
_lread(file_handle, &bitmap->bitmapfileheader,sizeof(BITMAPFILEHEADER));

// test if this is a bitmap file
if (bitmap->bitmapfileheader.bfType!=BITMAP_ID)
   // close the file

   // return error
   } // end if

// now we know this is a bitmap, so read in all the sections

// first the bitmap infoheader

// now load the bitmap file header
_lread(file_handle, &bitmap->bitmapinfoheader,sizeof(BITMAPINFOHEADER));

// now load the color palette if there is one
if (bitmap->bitmapinfoheader.biBitCount == 8)
   _lread(file_handle, &bitmap->palette,MAX_COLORS_PALETTE*sizeof(PALETTEENTRY));

   // now set all the flags in the palette correctly and fix the reversed 
   // BGR RGBQUAD data format
   for (index=0; index < MAX_COLORS_PALETTE; index++)
       // reverse the red and green fields
       int temp_color                = bitmap->palette[index].peRed;
       bitmap->palette[index].peRed  = bitmap->palette[index].peBlue;
       bitmap->palette[index].peBlue = temp_color;
       // always set the flags word to this
       bitmap->palette[index].peFlags = PC_NOCOLLAPSE;
       } // end for index

    } // end if

// finally the image data itself

// now read in the image, if the image is 8 or 16 bit then simply read it
// but if its 24 bit then read it into a temporary area and then convert
// it to a 16 bit image

if (bitmap->bitmapinfoheader.biBitCount==8 || bitmap->bitmapinfoheader.biBitCount==16 || 
   // delete the last image if there was one
   if (bitmap->buffer)

   // allocate the memory for the image
   if (!(bitmap->buffer = (UCHAR *)malloc(bitmap->bitmapinfoheader.biSizeImage)))
      // close the file

      // return error
      } // end if

   // now read it in

   } // end if
   // serious problem

   } // end else

#if 0
// write the file info out 
printf("\nfilename:%s \nsize=%d \nwidth=%d \nheight=%d \nbitsperpixel=%d \ncolors=%d \nimpcolors=%d",

// close the file

// flip the bitmap

// return success

} // end Load_Bitmap_File


int Unload_Bitmap_File(BITMAP_FILE_PTR bitmap)
// this function releases all memory associated with "bitmap"
if (bitmap->buffer)
   // release memory

   // reset pointer
   bitmap->buffer = NULL;

   } // end if

// return success

} // end Unload_Bitmap_File


int Flip_Bitmap(UCHAR *image, int bytes_per_line, int height)
// this function is used to flip bottom-up .BMP images

UCHAR *buffer; // used to perform the image processing
int index;     // looping index

// allocate the temporary buffer
if (!(buffer = (UCHAR *)malloc(bytes_per_line*height)))

// copy image to work area

// flip vertically
for (index=0; index < height; index++)
    memcpy(&image[((height-1) - index)*bytes_per_line],
           &buffer[index*bytes_per_line], bytes_per_line);

// release the memory

// return success

} // end Flip_Bitmap


						    UINT msg, 
                            WPARAM wparam, 
                            LPARAM lparam)
// this is the main message handler of the system
PAINTSTRUCT		ps;		// used in WM_PAINT
HDC				hdc;	// handle to a device context
char buffer[80];        // used to print strings

// what is the message 
	case WM_CREATE: 
		// do initialization stuff here
        // return success
		} break;
	case WM_PAINT: 
		// simply validate the window 
   	    hdc = BeginPaint(hwnd,&ps);	 
        // end painting

        // return success
   		} break;

	case WM_DESTROY: 

		// kill the application, this sends a WM_QUIT message 

        // return success
		} break;


    } // end switch

// process any messages that we didn't take care of 
return (DefWindowProc(hwnd, msg, wparam, lparam));

} // end WinProc


int Game_Main(void *parms = NULL, int num_parms = 0)
// this is the main loop of the game, do all your processing
// here

// make sure this isn't executed again
if (window_closed)

// for now test if user is hitting ESC and send WM_CLOSE
   window_closed = 1;
   } // end if

// do nothing -- look at pretty picture

// return success or failure or your own return code here

} // end Game_Main


int Game_Init(void *parms = NULL, int num_parms = 0)
// this is called once after the initial window is created and
// before the main event loop is entered, do all your initialization
// here

// first create base IDirectDraw interface
if (FAILED(DirectDrawCreate(NULL, &lpdd, NULL)))

// now query for IDirectDraw4
if (FAILED(lpdd->QueryInterface(IID_IDirectDraw4,
                               (LPVOID *)&lpdd4)))

// set cooperation to full screen
if (FAILED(lpdd4->SetCooperativeLevel(main_window_handle, 
                                      DDSCL_FULLSCREEN | DDSCL_ALLOWMODEX | 
                                      DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT)))

// set display mode to 640x480x8

// clear ddsd and set size

// enable valid fields
ddsd.dwFlags = DDSD_CAPS;

// request primary surface

// create the primary surface
if (FAILED(lpdd4->CreateSurface(&ddsd, &lpddsprimary, NULL)))

// load the 24-bit image
if (!Load_Bitmap_File(&bitmap,"bitmap24.bmp"))

// copy the bitmap image to the primary buffer line by line
// notice the 24 to 16 bit conversion pixel by pixel

// lock the primary surface

// get video pointer to primary surfce
USHORT *primary_buffer = (USHORT *)ddsd.lpSurface;       

// process each line and copy it into the primary buffer
for (int index_y = 0; index_y < SCREEN_HEIGHT; index_y++)
    for (int index_x = 0; index_x < SCREEN_WIDTH; index_x++)
        // get BGR values, note the scaling down of the channels, so that they
        // fit into the 5.6.5 format
        UCHAR blue  = (bitmap.buffer[index_y*SCREEN_WIDTH*3 + index_x*3 + 0]) >> 3,
              green = (bitmap.buffer[index_y*SCREEN_WIDTH*3 + index_x*3 + 1]) >> 3,
              red   = (bitmap.buffer[index_y*SCREEN_WIDTH*3 + index_x*3 + 2]) >> 3;

        // this builds a 16 bit color value in 5.6.5 format (green dominant mode)
        USHORT pixel = _RGB16BIT565(red,green,blue);

        // write the pixel
        primary_buffer[index_x + (index_y*ddsd.lPitch >> 1)] = pixel;

        } // end for index_x

    } // end for index_y

// now unlock the primary surface
if (FAILED(lpddsprimary->Unlock(NULL)))

// unload the bitmap file, we no longer need it

// return success or failure or your own return code here

} // end Game_Init


int Game_Shutdown(void *parms = NULL, int num_parms = 0)
// this is called after the game is exited and the main event
// loop while is exited, do all you cleanup and shutdown here

// first the palette
if (lpddpal)
   lpddpal = NULL;
   } // end if

// now the primary surface
if (lpddsprimary)
   lpddsprimary = NULL;
   } // end if

// now blow away the IDirectDraw4 interface
if (lpdd4)
   lpdd4 = NULL;
   } // end if

// return success or failure or your own return code here

} // end Game_Shutdown

// WINMAIN ////////////////////////////////////////////////

int WINAPI WinMain(	HINSTANCE hinstance,
					HINSTANCE hprevinstance,
					LPSTR lpcmdline,
					int ncmdshow)

WNDCLASSEX winclass; // this will hold the class we create
HWND	   hwnd;	 // generic window handle
MSG		   msg;		 // generic message
HDC        hdc;      // graphics device context

// first fill in the window class stucture
winclass.cbSize         = sizeof(WNDCLASSEX);			= CS_DBLCLKS | CS_OWNDC | 
                          CS_HREDRAW | CS_VREDRAW;
winclass.lpfnWndProc	= WindowProc;
winclass.cbClsExtra		= 0;
winclass.cbWndExtra		= 0;
winclass.hInstance		= hinstance;
winclass.hIcon			= LoadIcon(NULL, IDI_APPLICATION);
winclass.hCursor		= LoadCursor(NULL, IDC_ARROW); 
winclass.hbrBackground	= (HBRUSH)GetStockObject(BLACK_BRUSH);
winclass.lpszMenuName	= NULL;
winclass.lpszClassName	= WINDOW_CLASS_NAME;
winclass.hIconSm        = LoadIcon(NULL, IDI_APPLICATION);

// save hinstance in global
hinstance_app = hinstance;

// register the window class
if (!RegisterClassEx(&winclass))

// create the window
if (!(hwnd = CreateWindowEx(NULL,                  // extended style
                            WINDOW_CLASS_NAME,     // class
						    "DirectDraw 16-Bit Bitmap Loading", // title
						    WS_POPUP | WS_VISIBLE,
					 	    0,0,	  // initial x,y
						    SCREEN_WIDTH,SCREEN_HEIGHT,  // initial width, height
						    NULL,	  // handle to parent 
						    NULL,	  // handle to menu
						    hinstance,// instance of this application
						    NULL)))	// extra creation parms

// save main window handle
main_window_handle = hwnd;

// initialize game here

// enter main event loop
    // test if there is a message in queue, if so get it
	if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
	   // test if this is a quit
       if (msg.message == WM_QUIT)
	   // translate any accelerator keys

	   // send the message to the window proc
	   } // end if
       // main game processing goes here
	} // end while

// closedown game here

// return to Windows like this

} // end WinMain


if anyone knows what is wrong with it, i'd be very greatful.

Share this post

Link to post
Share on other sites
furby100    102
Just by looking I can tell that there are a fair few things wrong with that code (lying comments for one thing).

Add checks to the function calls and find out which part of the program is failing.

Share this post

Link to post
Share on other sites
Drakkcon    612
I just wrote a bitmap loader here. Now, I could be wrong, but it looks like you're loading the bitmap pallette. The pallette is only used for 8-bit bitmaps, and so you'd be misusing a lot of the file data. I could totally be wrong though because I only briefly skimmed over your code.

Edit: oops, I'm wrong. Stupid me. It only loads the pallette if necessary.

Share this post

Link to post
Share on other sites
CJWR    180
Original post by Drakkcon
Well, if you want to take the easy way out you could get a graphics editor that writes 16-bit bitmaps :)

i still don't know how to load them. 8 bit i sort of understand, but 16bit has me stumped :(

but what graphic editers can create 16 bit bitmaps? i've yet to find one.

Share this post

Link to post
Share on other sites
Kristafarii    172
I don't know if this has anything to do with it but I remember when I used the code from this book to load 8 bit bitmaps there were 2 things that had me stumped.

1. make sure the dimensions of the bitmap are powers of 2 and possible must be square eg 256 x 256 etc.

2. This loader doesn't like images saved as bmp from photoshop - probably a dodgy setting but I couldn't figure it out. If you are using photoshop then copy the image into Paint and then save it.

Share this post

Link to post
Share on other sites
CJWR    180
1: i've never had any problems using his code to load images even if they weren't square, at least for 8bit ones.

2: i thought it might be something of that sort and resaved it using paint. heck, i even created my own 640 by 480 24bit image to make sure that wasn't the problem.

i tried using this code to load an 8bit image, it did load a little while and displayed on the screen 3 images of it side by side before crashing. if that helps anyone trying to help me with what the problem may be.

Share this post

Link to post
Share on other sites
werekarg    193
basically, there is one problem with the bitmap loader: the struct alignment. that loader makes the assumption that the structs are aligned to byte, but it's not the case. modify your code Load_Bitmap_File function with:

//_lread(file_handle, &bitmap->bitmapfileheader,sizeof(BITMAPFILEHEADER));

_lread(file_handle, &bitmap->bitmapfileheader.bfType,sizeof(WORD));
_lread(file_handle, &bitmap->bitmapfileheader.bfSize,sizeof(DWORD));
_lread(file_handle, &bitmap->bitmapfileheader.bfReserved1,sizeof(WORD));
_lread(file_handle, &bitmap->bitmapfileheader.bfReserved2,sizeof(WORD));
_lread(file_handle, &bitmap->bitmapfileheader.bfOffBits,sizeof(DWORD));


//_lread(file_handle, &bitmap->bitmapinfoheader,sizeof(BITMAPINFOHEADER));

_lread(file_handle, &bitmap->bitmapinfoheader.biSize,sizeof(DWORD));
_lread(file_handle, &bitmap->bitmapinfoheader.biWidth,sizeof(LONG));
_lread(file_handle, &bitmap->bitmapinfoheader.biHeight,sizeof(LONG));
_lread(file_handle, &bitmap->bitmapinfoheader.biPlanes,sizeof(WORD));
_lread(file_handle, &bitmap->bitmapinfoheader.biBitCount,sizeof(WORD));
_lread(file_handle, &bitmap->bitmapinfoheader.biCompression,sizeof(DWORD));
_lread(file_handle, &bitmap->bitmapinfoheader.biSizeImage,sizeof(DWORD));
_lread(file_handle, &bitmap->bitmapinfoheader.biXPelsPerMeter,sizeof(LONG));
_lread(file_handle, &bitmap->bitmapinfoheader.biYPelsPerMeter,sizeof(LONG));
_lread(file_handle, &bitmap->bitmapinfoheader.biClrUsed,sizeof(DWORD));
_lread(file_handle, &bitmap->bitmapinfoheader.biClrImportant,sizeof(DWORD));

also, it may also be a problem with the directx initialization&stuff. i replaced the directdraw4 with directdraw7 stuff and made some other modifications, my copy of your code works. if the above loader fixes do not solve your problem, private message me with an email address and i'll sent you the source.

Share this post

Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this