get in there

Author: OleStrohm

CMakeLists.txt

@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.8)
+project(ImageLoading)
+
+set(CMAKE_CXX_STANDARD 11)
+
+set(SOURCE_FILES main.cpp image.cpp image.h)
+add_executable(ImageLoading ${SOURCE_FILES})

image.cpp

@@ -0,0 +1,97 @@
+//
+// Created by Ole on 10.09.2017.
+//
+
+#include "image.h"
+
+unsigned char reversed(unsigned char value) {
+	unsigned char t = value;
+	for (int i = sizeof(value) * 8-1; i; i--)
+	{
+		value >>= 1;
+		t <<= 1;
+		t |= value & 1;
+	}
+	return t;
+}
+
+Image::Image(const std::string& path) {
+	init(path);
+}
+
+void Image::init(const std::string& path) {
+	std::ifstream stream(path, std::ifstream::in | std::ifstream::ate | std::ifstream::binary);
+	auto size = (unsigned int) stream.tellg();
+	if (!stream.good()) {
+		LOG("FAILED TO OPEN FILE: " << path);
+		size = 0;
+	}
+	stream.seekg(0, std::ifstream::beg);
+	
+	unsigned char data[size];
+	
+	unsigned int position = 0;
+	char in;
+	while (stream.get(in))
+		data[position++] = (unsigned char) in;
+	
+	loadChunks(data, size);
+	formatIHDR();
+	
+	stream.close();
+}
+
+void Image::formatIHDR() {
+	auto& data = chunks[0]->data;
+	
+	format.width = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | (data[3]);
+	format.height = (data[4] << 24) | (data[5] << 16) | (data[6] << 8) | (data[7]);
+	format.bitDepth = data[8];
+	format.colorType = data[9];
+	format.compressionMethod = data[10];
+	format.filterMethod = data[11];
+	format.interlaceMethod = data[12];
+}
+
+std::vector<unsigned char> Image::extractCompressedPixelData(const Chunk& chunk) {
+	std::vector<unsigned char> compressedData;
+	compressedData.reserve(chunk.length);
+	for(int i = 0; i < chunk.length; i++) {
+		compressedData.push_back(chunk.data[i]);
+	}
+	return compressedData;
+}
+
+void Image::loadChunks(const unsigned char* data, unsigned int size) {
+	unsigned int offset = 8;
+	while(offset < size) {
+		chunks.push_back(loadChunk(data, offset));
+	}
+}
+
+Chunk* Image::loadChunk(const unsigned char* data, unsigned int& offset) {
+	unsigned int chunkLength = (data[offset + 0] << 24) | (data[offset + 1] << 16) | (data[offset + 2] << 8) | (data[offset + 3]);
+	offset += 4;
+	
+	char s[5];
+	s[0] = data[offset + 0];
+	s[1] = data[offset + 1];
+	s[2] = data[offset + 2];
+	s[3] = data[offset + 3];
+	s[4] = 0;
+	std::string chunkType(s);
+	offset += 4;
+	
+	std::vector<unsigned char> chunkData;
+	chunkData.reserve(chunkLength);
+	
+	for (int p = 0; p < chunkLength; p++) {
+		chunkData.push_back(data[offset + p]);
+	}
+	offset += chunkLength;
+	
+	unsigned int chunkCRC = (data[offset + 0] << 24) | (data[offset + 1] << 16) | (data[offset + 2] << 8) | (data[offset + 3]);
+	offset += 4;
+	
+	return new Chunk(chunkLength, chunkType, chunkData, chunkCRC);
+}

image.h

@@ -0,0 +1,82 @@
+//
+// Created by Ole on 10.09.2017.
+//
+
+#pragma once
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <vector>
+#include <utility>
+#include <bitset>
+
+unsigned char reversed(unsigned char value);
+
+#define LOG(x) (std::cout << x << std::endl)
+#define LOGB(x) (std::cout << (std::bitset<8>)reversed(x) << std::endl)
+
+//unsigned int crc_table[256];
+//
+//void build_crc32() {
+//	for (unsigned int n = 0; n < 256; n++) {
+//		auto c      = n;
+//		for (unsigned int k = 0; k < 8; k++) {
+//			if (c & 1)
+//				c = (c >> 1) ^ 0xedb88320;
+//			else
+//				c = c >> 1;
+//		}
+//		crc_table[n] = c;
+//	}
+//}
+//
+//void getCRC() {
+//	LOG(crc_table[0]);
+//}
+
+struct Chunk {
+	unsigned int length;
+	std::string type;
+	std::vector<unsigned char> data;
+	unsigned int crc;
+	
+	Chunk(unsigned int length, std::string type, std::vector<unsigned char>& data, unsigned int crc)
+			: length(length), type(std::move(type)), data(data), crc(crc) {}
+};
+
+struct Format {
+	unsigned int width;
+	unsigned int height;
+	char bitDepth;
+	char colorType;
+	char compressionMethod;
+	char filterMethod;
+	char interlaceMethod;
+	
+	Format()
+			: width(0),height(0),bitDepth(0),colorType(0),compressionMethod(0),filterMethod(0),interlaceMethod(0) {}
+};
+
+class Image {
+public:
+	std::vector<Chunk*> chunks;
+private:
+	Format format;
+public:
+	Image(const std::string& path);
+	
+	void init(const std::string& path);
+	
+	void formatIHDR();
+	std::vector<unsigned char> extractCompressedPixelData(const Chunk& chunk);
+	void loadChunks(const unsigned char* data, unsigned int size);
+	
+	inline const Format& getFormat() const {
+		return format;
+	}
+private:
+	Chunk* loadChunk(const unsigned char* data, unsigned int& offset);
+};
+
+

main.cpp

@@ -0,0 +1,52 @@
+
+#include <cstring>
+#include "image.h"
+
+int main() {
+	{
+		uint32_t i=0x01020304;
+		char le[4]={4, 3, 2, 1};
+		char be[4]={1, 2, 3, 4};
+		if(memcmp(&i, le, 4)==0)
+			puts("Little endian");
+		else if(memcmp(&i, be, 4)==0)
+			puts("Big endian");
+		else
+			puts("Mixed endian");
+	}
+	
+	Image image("smile.png");
+	
+	Format format = image.getFormat();
+	LOG("bit depth: " << (int) format.bitDepth);
+	LOG("color type: " << (int) format.colorType);
+	LOG("compression method: " << (int) format.compressionMethod);
+	LOG("filter method: " << (int) format.filterMethod);
+	LOG("interlace method: " << (int) format.interlaceMethod);
+	LOG("");
+
+	int index = 0;
+	while(image.chunks[++index]->type != "IDAT");
+	Chunk pixelChunk = *image.chunks[index];
+	LOG(pixelChunk.type);
+	LOG(pixelChunk.length);
+	LOG("");
+
+	std::vector<unsigned char> compressedData = image.extractCompressedPixelData(*image.chunks[index]);
+	LOG("CMF:");
+	LOGB(compressedData[0] + (unsigned char) (8 <<4));
+	LOG("FLG:");
+	LOGB(compressedData[1]); // 16-bit sum is 14415 % 31 == 0
+	LOG("");
+	LOGB(compressedData[2]);
+	LOGB(compressedData[3]);
+	LOGB(compressedData[4]);
+	LOGB(compressedData[5]);
+	LOGB(compressedData[6]);
+	
+	
+
+	
+	
+	return 0;
+}