Changing BPP in XImage

12-20-2010

Registered User

20, 0

Join Date: Dec 2010

Last Activity: 28 October 2011, 3:00 AM EDT

Posts: 20

Thanks Given: 0

Thanked 0 Times in 0 Posts

Changing BPP in XImage

im trying to take a 24 BPP screen cap and save it to bitmap, but seems like it XImage is always 32 BPP, the value 0x00FFFFFF supposed to be 24 !

whenever i change bmpInfoHeader.biBitCount to 24, the image gets messed up..

here is the code im using

Code:

typedef struct tagBITMAPFILEHEADER {
	WORD    bfType;
	DWORD   bfSize;
	WORD    bfReserved1;
	WORD    bfReserved2;
	DWORD   bfOffBits;
} BITMAPFILEHEADER;

typedef struct tagBITMAPINFOHEADER{
	DWORD  biSize;
	LONG   biWidth;
	LONG   biHeight;
	WORD   biPlanes;
	WORD   biBitCount;
	DWORD  biCompression;
	DWORD  biSizeImage;
	LONG   biXPelsPerMeter;
	LONG   biYPelsPerMeter;
	DWORD  biClrUsed;
	DWORD  biClrImportant;
} BITMAPINFOHEADER;

void saveXImageToBitmap(XImage *pImage)
{
	BITMAPFILEHEADER bmpFileHeader;
	BITMAPINFOHEADER bmpInfoHeader;
	FILE *fp;
	static int cnt = 0;
	int dummy;
	char filePath[255];

	memset(&bmpFileHeader, 0, sizeof(BITMAPFILEHEADER));
	memset(&bmpInfoHeader, 0, sizeof(BITMAPINFOHEADER));
	bmpFileHeader.bfType = 0x4D42;
	bmpFileHeader.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + pImage->width*pImage->height*4;
	bmpFileHeader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
	bmpFileHeader.bfReserved1 = 0;
	bmpFileHeader.bfReserved2 = 0;

	bmpInfoHeader.biSize = sizeof(BITMAPINFOHEADER);
	bmpInfoHeader.biWidth = pImage->width;
	bmpInfoHeader.biHeight = pImage->height;
	bmpInfoHeader.biPlanes = 1;
	bmpInfoHeader.biBitCount = 32;
	dummy = (pImage->width * 3) % 4;
	if((4-dummy)==4)
		dummy=0;
	else
		dummy=4-dummy;
	bmpInfoHeader.biSizeImage = ((pImage->width*3)+dummy)*pImage->height;
	bmpInfoHeader.biCompression = 0;
	bmpInfoHeader.biXPelsPerMeter = 0;
	bmpInfoHeader.biYPelsPerMeter = 0;
	bmpInfoHeader.biClrUsed = 0;
	bmpInfoHeader.biClrImportant = 0;

	sprintf(filePath, "bitmap%d.bmp", cnt++);
	fp = fopen(filePath,"wb");

	if(fp == NULL)
		return;

	fwrite(&bmpFileHeader, sizeof(bmpFileHeader), 1, fp);
	fwrite(&bmpInfoHeader, sizeof(bmpInfoHeader), 1, fp);
	fwrite(pImage->data, 4*pImage->width*pImage->height, 1, fp);
	fclose(fp);
}

void screen()
{
    unsigned int height, width;
    unsigned int unused;
    int unused_int;
    Display *dpy = XOpenDisplay(NULL);
    Window root = DefaultRootWindow(dpy);
    XGetGeometry(dpy, root, (Window *) &unused, &unused_int, &unused_int, &width, &height, &unused, &unused);
    XImage *img=XGetImage(dpy, root, 0, 0, width, height, 0x00ffffff, ZPixmap);
    SaveXImageToBitmap(img);
    XDestroyImage(img);
    XCloseDisplay(dpy);
}

thanks..

JonhyM

View Public Profile for JonhyM

Find all posts by JonhyM

12-20-2010

Registered User

23,310, 4,623

Join Date: Aug 2005

Last Activity: 7 July 2020, 11:47 AM EDT

Location: Saskatchewan

Posts: 23,310

Thanks Given: 1,331

Thanked 4,623 Times in 4,217 Posts

Quote:

Originally Posted by JonhyM

Changing the header doesn't change the data. 0x00ffffff is 32-bit, count the bytes, so if you still write it raw you're still writing 32-bit data. Instead of writing 0x00ffffff for every pixel, you should be skipping one byte and writing 0xffffff.

Which is going to be a fair bit more complicated: It'll mean doing pointer arithmetic to read the data you want.

Code:

enum
{
        // Adjust these to match what your data actually is
        R_32 = 0,
        G_32 = 1,
        B_32 = 2,
        A_32 = 3,

        R_24 = 0,
        G_24 = 1,
        B_24 = 2,
};

const unsigned char *raw=(const unsigned char *)rawdata;
unsigned char *lineout=malloc(width * 3);
for(y=0; y<height; y++)
{
        const unsigned char *line=raw + (width * y);
        unsigned char *ptr=lineout;
        int x;

        printf("pixel 0,%d = {%02x %02x %02x %02x}\n", y, line[0], line[1], line[2], line[3]);


        for(x=0; x<width; x++)
        {
                ptr[R_24]=line[R_32];
                ptr[G_24]=line[G_32];
                ptr[B_24]=line[B_32];
                line += 4;
                ptr += 3;
        }

        write(lineout, 3, width, outfile);
}

free(lineout);

Try making an ximage file with a known pixel value at 0,0 so you can see exactly what colors are what offsets.

This is very exact and tedious and will probably break if you compile it on a different architecture. I used sdl to make xtopng because it's already written all this junk for you.