Bitmap file image data offset producing different image - c++

Question

I just started creating a bitmap image file loader and just from the wiki, I concluded the offset from the beginning of the file to the image data was 50 bytes. Therefor, I set the data to 50. Here is the original image:
Now when I load the image with the following code:
std::fstream file;
file.open(fileName, std::fstream::binary | std::fstream::in);
if (file.fail()) std::cout << "Couldn't open: `" << fileName << "`\n";
GLchar * data;
file.seekg(0, file.end);
int length = file.tellg();
file.seekg(0, file.beg);
data = new GLchar[length];
file.read(data, length);
if(file)
std::cout << "all characters read successfully.\n";
else
std::cout << "error: only " << file.gcount() << " could be read";
GLchar sec = data[1];
std::cout << data[0] << data[1] << "= ";
switch (sec) {
case 'M':std::cout << "Windows 3.1x"; break;
case 'A':std::cout << "OS/2 struct bitmap array"; break;
case 'I':std::cout << "OS/2 struct color icon"; break;
case 'P':std::cout << "OS/2 const color pointer"; break;
case 'C':std::cout << "OS/2 struct icon"; break;
}
int headerOffset = 50;
std::cout << "\n\n~~ "<< *(GLuint *)&data[10];
width = *(GLuint *)&data[18];
height = *(GLuint *)&data[22];
int bpp = *(int *)&data[28];
int compressionMethod = *(int *)&data[30];
std::cout << "\nDimensions: " << width << "x" << height << "\n";
std::cout << "Bits per pixel: " << bpp;
std::cout << "\nCompression Method: " << compressionMethod << "\n";
//start of pixel array - 50
unsigned char *pixels = new unsigned char[width*height * 3];
file.seekg(headerOffset + 40);
file.read((char *)pixels, width*height*3);
unsigned char tmpRGB = 0; // Swap buffer
for (unsigned long i = 0; i < width * height * 3; i += 3)
{
tmpRGB = pixels[i];
pixels[i] = pixels[i + 2];
pixels[i + 2] = tmpRGB;
}
glGenTextures(1, &texture); // Generate a texture
glBindTexture(GL_TEXTURE_2D, texture); // Bind that texture temporarily
GLint mode = GL_RGB; // Set the mode
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, mode, width, height, 0, mode, GL_UNSIGNED_BYTE, pixels);
delete[] pixels;
delete[] data;
file.close();
std::cout << "\n\n\n";
This code is with the assumption that the offset to the image array is 50
With this assumption: Here is what the image produces-
Now, after some research I learned that
The offset, i.e. starting address, of the byte where the bitmap image data (pixel array) can be found. Has an offset of 10 into the file. So I then decided to change the
GLuint offset = 50;
to the following
GLuint offset = *(GLuint *)&data[10];
When I do this, however, the colors get switched to the wrong order. Here is an image:
Here is an explanation of the problem: The original image goes, from top to bottom, blue-green-red-white-gray. The first image I rendered adheres to this. The second one (the one that finds the offset from the code) doesn't. Can anyone explain why this happening?

Answer 1

Without looking at too much code, it seems that you did not take into account that the image is stored in Little Endian:
For 24-bit pixels, a pixel in memory looks like this: 0xBBGGRR, i.e., the mistake might be that you have written code assuming that a pixel
is written in Big endian, like this: 0xRRGGBB.
That means that, even though we think of a pixel as 3 bytes of RGB values (1B of Red, 1B of green and 1B of blue), the bytes are swapped in memory.
EDIT:
That explains why only the blues are swapped with reds, while greens and other colors stayed the same; because the colours that were not swapped have a simetrical hex value both in Big endian and Little endian notation.

Answer 2

This is the sample from when i was writing bitmap loader
cpp file
#include "BMP.h"
void LoadBMP(const std::string fn, std::vector<Color>& image, unsigned int &width, unsigned int &height)
{
std::ifstream fin(fn.c_str(), std::ios::binary);
char signature[2];
fin.read(signature, sizeof(signature));
if (signature[0] == 'B' && signature[1] == 'M') {
BMPFileHeader fileheader;
BMPInfoHeader infoheader;
fin.read((char*)&fileheader, sizeof(fileheader));
fin.read((char*)&infoheader, sizeof(infoheader));
width = infoheader.width;
height = infoheader.height;
fin.seekg(fileheader.offset, fin.beg);
int PaddingBytesPerRow = (4 - ((infoheader.width * 3) % 4)) % 4;
Pixels pxl;
int cc = 0;
image.resize(infoheader.width*infoheader.height);
for (unsigned int y = 0; y < infoheader.height; y++) {
for (unsigned int x = 0; x < infoheader.width; x++) {
fin.read((char*)&pxl, sizeof(pxl));
cc = x + ((infoheader.height - 1) - y) * infoheader.width;
image[cc].SetR(pxl.r);
image[cc].SetG(pxl.g);
image[cc].SetB(pxl.b);
}
fin.seekg(PaddingBytesPerRow, fin.cur);
}
}
fin.close();
}
h file
#pragma once
#include <string>
#include "Graphics.h" // color array
#include <fstream>
#include <vector>
struct BMPFileHeader
{
unsigned int size;
unsigned short reserved1, reserved2;
unsigned int offset;
};
struct BMPInfoHeader
{
unsigned int HeaderSize;
unsigned int width, height;
unsigned short planes;
unsigned short bits;
unsigned int compression;
unsigned int imagesize;
int xResolution, yResolution;
unsigned int nColors;
unsigned int importantColors;
};
struct Pixels {
unsigned char b, g, r;
};
void LoadBMP(const std::string fn,std::vector<Color>& image, unsigned int &width,unsigned int &height);
i used structures for bitmap so there will by no magic values and everything will be loaded from files into structures and then use those values calculating padding and pushing pixels into vector , i have tested this code and its working fine