Bmp.c

Go to the documentation of this file.

// Adapted https://github.com/vallentin/LoadBMP
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "errors.h"
 
#define RGB_COLOR_LENGTH  3
#define FILE_HEADER_LENGTH 14
#define INFO_HEADER_LENGTH 40
#define PAD_LENGTH 3
 
struct Bmp {
    unsigned int width;     
    unsigned int height;    
    unsigned long length;   
    unsigned char *reds;    
    unsigned char *greens;  
    unsigned char *blues;   
};
 
struct Bmp *Bmp_destruct(struct Bmp *this) 
{
    if (0 != this) {
        free(this->reds);
        free(this->greens);
        free(this->blues);
        free(this);
    }
 
    return 0;
}
 
unsigned int Bmp_getWidth(struct Bmp *this)
{
    return this->width;
}
 
unsigned int Bmp_getHeight(struct Bmp *this)
{
    return this->height;
}
 
unsigned long Bmp_getLength(struct Bmp *this)
{
    return this->length;
}
 
void Bmp_getPixelOfRaster(struct Bmp *this, int horizontal, int vertical, unsigned char *red, unsigned char *green, unsigned char *blue, int *error) 
{
    unsigned long offset = this->width * vertical + horizontal;
    
    *red = this->reds[offset];
    *green = this->greens[offset];
    *blue = this->blues[offset];
}
 
void Bmp_getPixelOfLine(struct Bmp *this, int index, unsigned char *red, unsigned char *green, unsigned char *blue, int *error)
{
    *red = this->reds[index];
    *green = this->greens[index];
    *blue = this->blues[index];
}
 
struct Bmp *Bmp_readFile(const char *filename, int *error) 
{
    FILE *file = fopen(filename, "rb");
 
    if (!file) 
    {
        *error = ERROR_IN_FILE;
        return 0;
    }
 
    unsigned char fileHeader[FILE_HEADER_LENGTH];
    unsigned char infoHeader[INFO_HEADER_LENGTH];
    unsigned char pad[PAD_LENGTH];
    unsigned int width = 0;
    unsigned int height = 0;
    unsigned long length = 0;
    unsigned char *reds = 0;
    unsigned char *greens = 0;
    unsigned char *blues = 0;
    unsigned int x = 0;
    unsigned int y = 0;
    unsigned int i = 0;
    unsigned int padding = 0;
 
    memset(fileHeader, 0, sizeof(fileHeader));
    memset(infoHeader, 0, sizeof(infoHeader));
 
    if (fread(fileHeader, sizeof(fileHeader), 1, file) == 0)
    {
        // invalid file format
        fclose(file);
 
        *error = ERROR_IN_FILE;
        return 0;
    }
 
    if (fread(infoHeader, sizeof(infoHeader), 1, file) == 0)
    {
        // invalid file format
        fclose(file);
 
        *error = ERROR_IN_FILE;
        return 0;
    }
 
    if ((fileHeader[0] != 'B') || (fileHeader[1] != 'M'))
    {
        // invalid signatue
        fclose(file);
 
        *error = ERROR_IN_FILE;
        return 0;
    }
 
    if ((infoHeader[14] != 24) && (infoHeader[14] != 32))
    {
        // invalid bits per pixel
        fclose(file);
 
        *error = ERROR_IN_FILE;
        return 0;
    }
 
    width = (infoHeader[4] + (infoHeader[5] << 8) + (infoHeader[6] << 16) + (infoHeader[7] << 24));
    height = (infoHeader[8] + (infoHeader[9] << 8) + (infoHeader[10] << 16) + (infoHeader[11] << 24));
 
    if ((width > 0) && (height > 0))
    {
        length = width * height;
 
        reds = (unsigned char*)malloc(length);
 
        if (!reds) 
        {
            fclose(file);
            *error = ERROR_NO_MEMORY;
            return 0;
        }
 
        greens = (unsigned char*)malloc(length);
 
        if (!greens) 
        {
            fclose(file);
            *error = ERROR_NO_MEMORY;
            return 0;
        }
 
        blues = (unsigned char*)malloc(length);
 
        if (!blues) 
        {
            fclose(file);
            *error = ERROR_NO_MEMORY;
            return 0;
        }
 
        for (y = (height - 1); y != -1; y--)
        {
            for (x = 0; x < width; x++)
            {
                i = x + y * width;
 
                // BGR -> RGB
 
                if (fread(blues + i, 1, 1, file) == 0)
                {
                    // invalid file format
                    free(reds);
                    free(blues);
                    free(greens);
                    fclose(file);
 
                    *error = ERROR_IN_FILE;
                    return 0;
                }
 
                if (fread(greens + i, 1, 1, file) == 0)
                {
                    // invalid file format
                    free(reds);
                    free(blues);
                    free(greens);
                    fclose(file);
 
                    *error = ERROR_IN_FILE;
                    return 0;
                }
 
                if (fread(reds + i, 1, 1, file) == 0)
                {
                    // invalid file format
                    free(reds);
                    free(blues);
                    free(greens);
                    fclose(file);
 
                    *error = ERROR_IN_FILE;
                    return 0;
                }
            }
 
            padding = ((4 - (width * 3) % 4) % 4);
 
            if (fread(pad, 1, padding, file) != padding)
            {
                // invalid file format
                free(reds);
                free(blues);
                free(greens);
                fclose(file);
 
                *error = ERROR_IN_FILE;
                return 0;
            }
        }
    }
 
    fclose(file);
 
    struct Bmp * this = malloc(sizeof(struct Bmp));
 
    if (!this) {
        *error = ERROR_NO_MEMORY;
        return 0;
    }
 
    this->width = width;
    this->height = height;
    this->length = length;
    this->reds = reds;
    this->greens = greens;
    this->blues = blues;
 
    return this;
}
 
void Bmp_writeFile(struct Bmp *this, const char *filename, int *error) 
{
    FILE *file = fopen(filename, "wb");
 
    if (!file) 
    {
        *error = ERROR_IN_FILE;
        return;
    }
 
    unsigned char fileHeader[FILE_HEADER_LENGTH] = { 'B', 'M', 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 0 };
    unsigned char infoHeader[INFO_HEADER_LENGTH] = { 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 24, 0 };
    const unsigned char pad[PAD_LENGTH] = { 0, 0, 0 };
 
    const unsigned int size = (FILE_HEADER_LENGTH + INFO_HEADER_LENGTH) + this->width * this->height * RGB_COLOR_LENGTH; // 3 as the BMP format uses 3 channels (red, green, blue and NO alpha)
 
    unsigned int x = 0;
    unsigned int y = 0;
    unsigned int i = 0;
    unsigned int padding = 0;
 
    fileHeader[2] = (unsigned char)(size);
    fileHeader[3] = (unsigned char)(size >> 8);
    fileHeader[4] = (unsigned char)(size >> 16);
    fileHeader[5] = (unsigned char)(size >> 24);
 
    infoHeader[4] = (unsigned char)(this->width);
    infoHeader[5] = (unsigned char)(this->width >> 8);
    infoHeader[6] = (unsigned char)(this->width >> 16);
    infoHeader[7] = (unsigned char)(this->width >> 24);
 
    infoHeader[8] = (unsigned char)(this->height);
    infoHeader[9] = (unsigned char)(this->height >> 8);
    infoHeader[10] = (unsigned char)(this->height >> 16);
    infoHeader[11] = (unsigned char)(this->height >> 24);
 
    if (fwrite(fileHeader, FILE_HEADER_LENGTH, 1, file) == 0)
    {
        fclose(file);
 
        *error = ERROR_IN_FILE;
        return;
    }
 
    if (fwrite(infoHeader, INFO_HEADER_LENGTH, 1, file) == 0)
    {
        fclose(file);
 
        *error = ERROR_IN_FILE;
        return;
    }
 
    for (y = (this->height - 1); y != -1; y--)
    {
        for (x = 0; x < this->width; x++)
        {
            i = (x + y * this->width) * RGB_COLOR_LENGTH;
 
            // RGB -> BGR
 
            if (fwrite(&this->blues[i], 1, 1, file) == 0)
            {
                fclose(file);
                *error = ERROR_IN_FILE;
                return;
            }
 
            if (fwrite(&this->greens[i], 1, 1, file) == 0)
            {
                fclose(file);
                *error = ERROR_IN_FILE;
                return;
            }
 
            if (fwrite(&this->reds[i], 1, 1, file) == 0)
            {
                fclose(file);
                *error = ERROR_IN_FILE;
                return;
            }
        }
 
        padding = ((4 - (this->width * 3) % 4) % 4);
 
        if (fwrite(pad, 1, padding, file) != padding)
        {
            fclose(file);
            *error = ERROR_IN_FILE;
            return;
        }
    }
 
    fclose(file);
}