Thread: Why is file size of bmp always zero?

Apparently sig in your struct is being padded to 32 bits. So when you fread the struct the BM is going into sig and the first two bytes of filesize are going into the padding after sig, leaving only the last two bytes in the high-order bytes of filesize. Due to the litte-endian byte-order of the integer as stored in the bmp and the fact that your test bmps are (I'm guessing) less than 65536 bytes in size, you end up with a displayed value of 0.

There are two ways to correct this. You can instruct the compiler not to pad the structs with a pragma. This is implementation-specific, but you might try:

Code:

#pragma pack(1)

The (somewhat) more portable solution is to read each of the members separately with it's own fread. This is still not completely portable since if you're on a machine with the opposite endianness as the data in the BMP then you'll have to swap the bytes around too.

BTW. there's no need for rdbuffer. You can (if you go the pack-it-up-and-read-the-struct route) read it directly into header.

Originally Posted by Syscal

I've been looking into the file structure of BMP images and everything I'm reading says that the 4 bytes following the signature are designated as the filesize of the bmp file... It's always zero for me regardless of the BMP file. The signature is always correct though. What gives?

Code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <stdint.h>

#define BUF_SIZ 1024

typedef struct
{
    uint16_t sig;
    uint32_t filesize;
    uint16_t reserved1;
    uint16_t reserved2;
    uint32_t offset;

}BitMapFileHeader;

int main(int argc, char ** argv)
{

    FILE * rdfile;
    char rdbuffer[BUF_SIZ];
    size_t rdbytes;
    size_t filesize;
    BitMapFileHeader * header;

    if(!(rdfile = fopen("test.bmp", "r")))
    {

        fprintf(stderr, "Error opening file\n");
        exit(EXIT_FAILURE);

    }

    fseek(rdfile, 0, SEEK_END);
    filesize = ftell(rdfile);
    rewind(rdfile);

    //printf("Filesize: %u bytes\n", filesize);

    if((rdbytes = fread(rdbuffer, 1, BUF_SIZ, rdfile)))
    {

        header = (BitMapFileHeader *) rdbuffer;

        fprintf(stdout,
                "Signature: %c%c\n"
                "FileSize: %u\n"
                "Reserved1: %u\n"
                "Reserved2: %u\n"
                "Offset: %u\n\n\n",
                header->sig, (header->sig >> 8),
                header->filesize,
                header->reserved1,
                header->reserved2,
                header->offset);



    }
    else
    {

        fprintf(stderr, "fread:", strerror(errno));
        fclose(rdfile);
        exit(EXIT_FAILURE);

    }

#if 0
    while(rdbytes = fread(rdbuffer, 1, BUF_SIZ, rdfile))
    {

        fwrite(rdbuffer, 1, rdbytes, stdout);

    }
    if(rdbytes == 0)
    {

        fprintf(stderr, "fread:", strerror(errno));
        fclose(rdfile);
        exit(EXIT_FAILURE);
    }
#endif

    fclose(rdfile);

    return 0;
}

First of all, anytime you read a structure from a file in raw binary, you have to think about structure padding that may be added by the compiler. Most compilers provide some sort of means to override the defaults (ie: #pragma pack, et al) for such cases. Second, if you want your code to be portable, you should take into account endian issues (for the BMP format that means reversing bytes on big-endian machines). For both of the above problems you might consider just reading the file byte by byte to build up the data structures. Finally, open the file with a hex-editor while you work - makes debugging so much easier...

EDIT: Explained more clearly above.

Just remember that there is no pragma to fix endian issues (as Sebastiani pointed out in post #3).

Also, a packed structure is likely to have a run-time performance penalty (the padding holes were there to begin with to make it efficient, ergo removing the holes must be less efficient).
It's not likely to be an issue if you just read/write the struct, but if you start passing it around your entire program, there may be some cost.

So here's another question... Why aren't the other fields padded as well? sizeof(BitMapFileHeader) returns 16 (2 additional bytes from the padding of sig).

Additionally, fread on the header is producing the same problem:

Code:

if((rdbytes = fread(&bmpheader, 1, BMP_HDR_SIZ, rdfile)))
    {

        fprintf(stdout,
                "Signature: %c%c\n"
                "FileSize: %u\n"
                "Reserved1: %u\n"
                "Reserved2: %u\n"
                "Offset: %u\n\n\n",
                bmpheader.sig, (bmpheader.sig >> 8),
                bmpheader.filesize,
                bmpheader.reserved1,
                bmpheader.reserved2,
                bmpheader.offset);



    }

Edit: I suppose the post mentioned above was just saying that there was no need for the read buffer at all. Looks like #pragma pack(1) is the best way.