BMP.cpp

#include "stdio.h"
#include "sys/stat.h"//required for setting file permissions
#include "fcntl.h"//required for setting create/readwrite/read only etc.
#include <cstring>
#include <stdlib.h>
#include <stdint.h>
#include <iostream>
using namespace std;
#include "BMP.h" ///// note for other viewers: doesn't have anything other than function prototypes


void saveBMP(const char *filepath, OGL_Surface *Surface, int bpp, uint8_t compression)
{
    if (bpp==32 || bpp==4){bpp=24;}//do not support 32bit
    if (bpp==3){bpp=24;}
    int palettecols =0;// (should be included as function arg)
    uint32_t imgbytes = (Surface->w*Surface->h*bpp)/8;
    int padding = (Surface->w*3)%4;
    if (padding != 0){padding=4-padding; imgbytes += Surface->h*padding;}
    uint32_t data = 0;

    int file = open(filepath, O_CREAT | O_RDWR, S_IRWXU);
    if (file < 0 ){perror("ERROR CREATING/OPENING BMP FILE");exit(1);}
    lseek(file, 0, SEEK_SET);

    /// file header (14 bytes)
    //BitMap declaraction
    write(file, "BM", 2);
    //complete file size in bytes. 14+40 + num bytes for image data  + (palette)
    if (bpp>8){data = imgbytes + 54;}
    else{data = imgbytes + 54 + palettecols*4;}
    write(file, &data, 4);
    //reserved nulls
    data=0;
    write(file, &data, 4);
    //offset to actual pixel data (again 14+40) + (palette)
    if (bpp>8){data=54;}
    else{data = 54 + palettecols*4;}
    write(file, &data, 4);

    /// file info (40 bytes)
    //size of info data
    data=40;
    write(file, &data, 4);
    //image width, height
    data=Surface->w;
    write(file, &data, 4);
    data=Surface->h;
    write(file, &data, 4);
    //must be set to 1
    data=1;
    write(file, &data, 2);
    //bits per pixel (MAX 24!)
    data= min(bpp,24);
    write(file, &data, 2);
    //compression, compression notes: http://netghost.narod.ru/gff/vendspec/micbmp/bmp.txt
    data=0;
    write(file, &data, 4);
    //image size in bytes
    data=imgbytes;
    write(file, &data, 4);
    //x,y pixels per meter (set to 0)
    data=0;
    write(file, &data, 4);
    write(file, &data, 4);

    /// palette (only for 1,4 and 8 bit images, 4 bytes per colour, min 8 bytes)
    //colours used (0=autodetect from bpp, for 8bpp or less palette will only use the amount of colours)
    write(file, &data, 4);
    //important colours (0=all are important)
    write(file, &data, 4);
    //palette (should be included as function arg)
    uint32_t *palette = NULL;
    uint8_t r,g,b;
    if (bpp<24){
        for (uint8_t i = 0; i<palettecols; i++){
            r=(palette[i]&0x000000FF);
            g=(palette[i]&0x0000FF00)>>8;
            b=(palette[i]&0x00FF0000)>>16;
            write(file, &b, 1);//b
            write(file, &g, 1);//g
            write(file, &r, 1);//r
            write(file, 0, 1);//null
        }
    }
    /// pixeldata
    uint8_t *buffer =  new uint8_t[imgbytes];
    memset(buffer, 0, imgbytes);
    int datawidth = (Surface->w*3)+padding;
    int pos = 0;
    int buf_pos = imgbytes-datawidth;
    for (uint32_t y = 0; y<Surface->h; y++){
        for (uint32_t x = 0; x<Surface->w; x++){
            buffer[buf_pos]  = Surface->PixData[pos];
            buffer[buf_pos+1]= Surface->PixData[pos+1];
            buffer[buf_pos+2]= Surface->PixData[pos+2];
            buf_pos+=3;
            pos+=Surface->bpp;
        }
        //return buffer to start of line then up one line
        buf_pos += padding;
        buf_pos -= datawidth+datawidth;
    }
    write(file, buffer, imgbytes);
    close(file);
    delete [] buffer;
}

void loadBMP(const char *filepath, OGL_Surface *Surface)
{

    char BMP[3]= {0,0};
    int dataoffset=0;
    int imgbytes=0;
    int compression=0;
    char bpp= 0;
    int file = open(filepath, O_RDONLY, S_IRWXU);
    if (file < 0 ){perror("ERROR LOADING BMP FILE");exit(1);}

    /// file header
    //BitMap declaraction
    lseek(file, 0, SEEK_SET);
    read(file, BMP, 2);
    if (BMP[0] != 'B' || BMP[1] != 'M'){printf("UNSUPPORTED FILE TYPE (not BMP)");exit(1);}
    //skip file size, 4
    //skip reserved nulls, 4
    //offset to actual pixel data
    lseek(file, 10, SEEK_SET);
    read(file, &dataoffset, 4);
    //skip headersize, 4
    //width & height
    lseek(file, 18, SEEK_SET);
    read(file, &Surface->w, 4);
    read(file, &Surface->h, 4);
    //skip "planes", 2
    //bits per pixel
    lseek(file, 28, SEEK_SET);
    read(file, &bpp, 2);
    //compression
    read(file, &compression, 4);
    if (compression != 0){printf("FILE USING UNSUPPORTED COMPRESSION");exit(1);}
    //size of image data in bytes
    read(file, &imgbytes, 4);
    //skip hres, 4
    //skip vres, 4

    /// palette (only for 1,4 and 8 bit images)
    uint32_t *palette;
    if (bpp<24){
        //colours used
        lseek(file, 46, SEEK_SET);
        int palettecols;
        read(file, &palettecols, 4);
        //skip important colours, 4
        if (palettecols != 0){
            palette = new uint32_t[palettecols];
            memset(palette, 0, palettecols*4);
        }
        for (int i = 0; i<palettecols; i++){
            read(file, &palette[i], 4);
        }
    }

    /// pixeldata
    lseek(file, dataoffset, SEEK_SET);
    uint8_t *buffer =  new uint8_t[imgbytes];
    memset(buffer, 0, imgbytes);
    read(file, buffer, imgbytes);
    close(file);

    /// convert data to rgb format
    if (Surface->PixData != NULL){delete [] Surface->PixData;}
    Surface->PixData = new uint8_t[Surface->w*Surface->h*Surface->bpp];
    memset(Surface->PixData, 255, Surface->w*Surface->h*Surface->bpp);
    int padding = (Surface->w*3)%4;
    if (padding != 0){padding=4-padding;}
    int datawidth = (Surface->w*3)+padding;
    int pos = 0;
    int buf_pos = imgbytes-datawidth;
    for (uint32_t y = 0; y<Surface->h; y++){
        for (uint32_t x = 0; x<Surface->w; x++){
            Surface->PixData[pos]  = buffer[buf_pos];
            Surface->PixData[pos+1]= buffer[buf_pos+1];
            Surface->PixData[pos+2]= buffer[buf_pos+2];
            //if supporting alpha, set 255,0,255 to transparent
            if(Surface->bpp==4 && buffer[buf_pos] == 255 && buffer[buf_pos+1] == 0 && buffer[buf_pos+2] == 255){Surface->PixData[pos+3]= 0;}
            buf_pos+=3;
            pos+=Surface->bpp;
        }
        //return buffer to start of line then up one line
        buf_pos += padding;
        buf_pos -= datawidth+datawidth;
    }
    delete [] buffer;
}

void loadBMP(const char *filepath, OGL_Texture *Texture)
{
    OGL_Surface *Surface = new OGL_Surface;
    Surface->Create_Surface(1,1,4);
    loadBMP(filepath, Surface);
    Texture->gen_texture(Surface->w, Surface->h, Surface->PixData);
    delete Surface;
}