cimagebmp

Can't read and write bmp

Hy I wanted to read a bmp file into a struct and write it then back but the image is alway black the header is ok. but the pixels get wrong written. I compared the hex values and they are the same until the header is finished. The rest is different and way shorter.

typedef uint16_t ImageType;

typedef struct
{
    uint32_t size;
    uint16_t additionalFeature;
    uint16_t copy;
    uint32_t offset;

} ImageHeader;

typedef struct
{
    uint32_t headerSize;
    int width;
    int height;
    uint16_t colorSpaces;
    uint16_t bitsPerPixel;
    uint32_t compression;
    uint32_t size;
    int verticalResolution;
    int horizontalResolution;
    uint32_t totalColors;
    uint32_t importantColors;
} ImageMetadata;

typedef struct {
    uint8_t blue;
    uint8_t green;
    uint8_t red;
} ImageColors;

typedef struct {
    ImageType type;
    ImageHeader header;
    ImageMetadata metadata;
    ImageColors **pixels;
} Image;

Here is my image structure. At the moment it is only for a 24 bpp Image later on I want to change it. But my problem is that after I wrote the image it is not correctly displayed. The header Data are ok but the image is not correct.

Bmp image input output

the rows are correct only the column is some how duplicated and compressed.

My includes are:

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdbool.h>

This is how I read the pixels

void readImage(char *filename, Image *image)
{
    FILE *imageFile = fopen(filename, "rb");
    if (!imageFile)
    {
        perror("ReadImageFileException");
        fclose(imageFile);
        exit(EXIT_FAILURE);
    }

    fread(&(image->type), sizeof(ImageType), 1, imageFile);
    //validate for correct image type
    if (image->type != BMP_IMAGE_TYPE)
    {
        fprintf(stderr, "%hu", image->type);
        perror("ReadImageTypeException");
        fclose(imageFile);
        exit(EXIT_FAILURE);
    }

    fread(&(image->header), sizeof(ImageHeader), 1, imageFile);
    fread(&(image->metadata), sizeof(ImageMetadata), 1, imageFile);
    
    // Allocate space for the pixels.
    image->pixels = malloc( image->metadata.height * sizeof(ImageColors *) );
    for(int i = 0; i < image->metadata.height; i++){
        image->pixels[i] = malloc(image->metadata.width * sizeof(ImageColors));
    }
    
    // Read in each pixel
    for (int i = 0; i < image->metadata.height; i++){
        for(int j = 0; j < image->metadata.width; j++){
            ImageColors px;
            if( fread(&px, sizeof(ImageColors), 1, imageFile) < 1 ) {
                printf("Error while reading bmp pixel.\n");
                return;
            }

            image->pixels[i][j] = px;
        }
    }

    fclose(imageFile);
}

This is how I write them.

void writeImage(char *filename, Image *image)
{
    FILE *imageFile = fopen(filename, "wb+");
    if (!imageFile)
    {
        perror("WriteImageFileException");
        fclose(imageFile);
        exit(EXIT_FAILURE);
    }

    size_t typeWritten = fwrite(&(image->type), sizeof(image->type), 1, imageFile);
    if (typeWritten == 0)
    {
        perror("WriteImageTypeException");
        fclose(imageFile);
        exit(EXIT_FAILURE);
    }

    size_t headerWritten = fwrite(&(image->header), sizeof(image->header), 1, imageFile);
    if (headerWritten == 0)
    {
        perror("WriteImageHeaderException");
        fclose(imageFile);
        exit(EXIT_FAILURE);
    }

    size_t metadataWritten = fwrite(&(image->metadata), sizeof(image->metadata), 1, imageFile);
    if (metadataWritten == 0)
    {
        perror("WriteImageMetadataException");
        fclose(imageFile);
        exit(EXIT_FAILURE);
    }

    fseek(imageFile, image->header.offset, SEEK_SET);
    // Read in each pixel
    for (int i = 0; i < image->metadata.height; i++){
        for(int j = 0; j < image->metadata.width; j++){
            if( fwrite(&image->pixels[i][j], sizeof(ImageColors), 1, imageFile) < 1 ) {
                printf("Error while wr bmp pixel.\n");
                fclose(imageFile);
                exit(EXIT_FAILURE);
            }

        }
    }

    fclose(imageFile);
}

Thank you already in advanced. I only included the Methods that are responsible for reading and writing the bmp because in the future I want to add some other features.

@tshiono Thank you I added you lines into it but if I compare the hex files I can see that the image still has some differences: enter image description here The output image looks still the same.

My Main function looks like this:

int main(int argc, char **argv) {
    int ch;
    char *inputFile = "sample.bmp";
    char *outputFile = "image-copy.bmp";
    Image image;
    
    // try to use port and password from parameter
    while ( (ch = getopt_long_only(argc, argv, "", long_options, NULL)) != -1 ) {
        switch (ch) {
            case 'i':
                inputFile = optarg;
                break;
            case 'o':
                outputFile = optarg;
                break;
            default:
                break;
        }
    }
    
    printf("input File: %s\n", inputFile);
    
    readImage(inputFile, &image);
    writeImage(outputFile, &image);
    return 0;
}
Solution

  • Thank you for the update.
    IMHO the bmp file format is stupidly designed which includes some pitfalls causing unexpected behaviors. You may have found if we put the 2-byte MagicNumber "BM" in the header struct, most compilers automatically put another 2 bytes for boundary alignment.

    Another pitfall is we need to keep the byte count of a row (line) to be the multiple of four for word alignment. Then the starting addresses of every row is located at the word boundary, although I'm not sure how much it makes the program run faster. Anyway if the byte count of the row is NOT the multiple of four (meaning the width is NOT the multiple of four), we need to put extra dummy bytes for the adjustment at the end of every row. Then would you please modify your reading/writing functions as:

    readImage:

    // Read in each pixel
    int padding = image->metadata.width % 4;                  // add this line
    for (int i = 0; i < image->metadata.height; i++){
        for(int j = 0; j < image->metadata.width; j++){
            ImageColors px;
            if( fread(&px, sizeof(ImageColors), 1, imageFile) < 1 ) {
                printf("Error while reading bmp pixel.\n");
                return;
            }
            image->pixels[i][j] = px;
        }
        for (int j = 0; j < padding; j++) getc(imageFile);    // add this line
    }

writeImage:

    // Read in each pixel
    int padding = image->metadata.width % 4;                  // add this line
    for (int i = 0; i < image->metadata.height; i++){
        for(int j = 0; j < image->metadata.width; j++){
            if( fwrite(&image->pixels[i][j], sizeof(ImageColors), 1, imageFile) < 1 ) {
                printf("Error while wr bmp pixel.\n");
                fclose(imageFile);
                exit(EXIT_FAILURE);
            }
        }
        for (int j = 0; j < padding; j++) putc(0, imageFile); // add this line
    }

    where the variable padding is the count of byte stuffing which can be calculated based on the value of width.

    [Update]
    Try to add the line:

        fseek(imageFile, image->header.offset, SEEK_SET);

    just before the line:

        // Read in each pixel

    in the readImage() as that in writeImage().

    [Explanation]
    There are several versions in bmp file format and they have different header size (which is yet another pitfall):

    version     header.offset (starting address of pixel data)
BMP v2       54
BMP v3      122
BMP v4      138

    While your definitions of structs are based on BMP v2, the provided bmp file is created in BMP v4. Then it causes the conflicts between header data and the position of the pixel data. That is why your file comparison shows the difference.

    The viewability of the collapsed image file will depend on the viewer software. In my environment there is no problem to view the images.

    Ideally we should prepare several types of header structs and use one of them depending on the version. Practically the extended area contains less significant data and we may skip them in most cases.