1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#define _HEADER_SIZE 54 //Fileheader + infoheader
#define IDENTIFIER 0x424d //BM BitMap identifier
//Address Definitions
#define BF_TYPE 0x00
#define BF_SIZE 0x02
#define BF_OFF_BITS 0x0a
#define BI_SIZE 0x0e
#define BI_WIDTH 0x12
#define BI_HEIGHT 0x16
#define BI_BIT_COUNT 0x1c
#define BI_COMPRESSION 0x1e
#define BI_SIZE_IMAGE 0x22
#define BI_CLR_USED 0x2e
#define BI_CLR_IMPORTANT 0x32
#define CHAR_SIZE 10 //How many pixels should form one ASCII char?
const char map[] = {' ', '.', ',', '-', ':', ';', '!', '/','?' , '%', '$', '#'};
struct ascii_pixel
{
char i[3 * CHAR_SIZE][CHAR_SIZE]; //
char c;
};
//Routine for flipping bytes
uint32_t flip(unsigned char* _v, int _c);
//Calculate average
char avg(int argc, char *argv);
int main(int argc, char *argv[])
{
unsigned char fileheader[_HEADER_SIZE];
unsigned char *tables;
uint32_t **bitmap_buff;
uint32_t read_counter = 0;
uint16_t bfType = 0;
uint32_t bfSize = 0;
uint32_t bfOffBits = 0;
uint32_t biSize = 0;
int32_t biWidth = 0;
int32_t biHeight = 0;
uint16_t biBitCount = 0;
uint32_t biCompression = 0;
uint32_t biSizeImage = 0;
uint32_t biClrUsed = 0;
uint32_t biClrImportant = 0;
if(argc < 2)
{
printf("No input file specified. Abort.\n");
return 1;
}
printf("Opening %s\n", argv[1]);
FILE *bitmap;
bitmap = fopen(argv[1], "r");
if(bitmap==NULL)
{
printf("Error opening file. Abort.\n");
return 1;
}
size_t tt = fread((void*)&fileheader, sizeof(char), _HEADER_SIZE, bitmap);
read_counter += _HEADER_SIZE;
if(!tt)
{
printf("Error reading file. Abort.\n");
return 1;
}
//Copy file header
bfType = (uint16_t) flip(&fileheader[BF_TYPE], sizeof(bfType));
if(bfType != (uint16_t)IDENTIFIER)
{
printf("%s is not a valid Bitmap. Abort.\n", argv[1]);
fclose(bitmap);
return 1;
}
bfSize = (uint32_t) flip(&fileheader[BF_SIZE], sizeof(bfSize));
bfOffBits = *(uint32_t*) &fileheader[BF_OFF_BITS];
biSize = *(uint32_t*) &fileheader[BI_SIZE];
biWidth = *(int32_t*) &fileheader[BI_WIDTH];
biHeight = *(int32_t*) &fileheader[BI_HEIGHT];
biBitCount = *(uint16_t*) &fileheader[BI_BIT_COUNT];
biCompression = (uint32_t) flip(&fileheader[BI_COMPRESSION], sizeof(biCompression));
biSizeImage = *(uint32_t*) &fileheader[BI_SIZE_IMAGE];
biClrUsed = (uint32_t) flip(&fileheader[BI_CLR_USED], sizeof(biClrUsed));
biClrImportant = (uint32_t) flip(&fileheader[BI_CLR_IMPORTANT], sizeof(biClrImportant));
printf("Picture is %u x %u Pixels. Colordepth: %ubit. Size: %uB\n",biWidth, biHeight, biBitCount, biSizeImage);
if(biBitCount !=24)
{
printf("%ubit mode not supported.\n", biBitCount);
return 1;
}
if(biCompression != 0)
{
printf("Compression not supported.\n");
return 1;
}
//Read to start of Pixel block
//This block contains Colormasks and Colortables.
//Unused
uint32_t d = bfOffBits - read_counter;
tables = malloc(sizeof(char)* d);
fread(tables, sizeof(char), d, bitmap);
read_counter += d;
printf("Read to %x\n", read_counter);
uint32_t row_size = biWidth * 3; //One pixel is 3Byte, One line is multiple of 4Bytes
while(row_size%4)
row_size++;
printf("Set row reading size to %uB\n", row_size);
//If biHeight > 0 Data starts with last row!!
//Allocate 2D array
bitmap_buff = malloc(sizeof(*bitmap_buff) * biWidth);
for(int i = 0; i < biWidth; i++)
{
bitmap_buff[i] = malloc(sizeof(*bitmap_buff[i]) * biHeight);
}
for(int i = 0; i < biWidth; i++)
free(bitmap_buff[i]);
free(bitmap_buff);
fclose(bitmap);
return 0;
}
uint32_t flip(unsigned char* _v, int _c)
{
uint32_t ret = 0;
uint32_t counter = (_c-1) * 8;
for(int i = 0; i < _c; i++)
{
ret |= (uint32_t)(_v[i] << (counter));
counter -= 8;
}
return ret;
}//flip
char avg(int argc, char *argv)
{
char ret = 0;
uint64_t sum = 0;
for(int i = 0; i < argc; i++)
sum += (uint64_t)argv[i];
ret = (char)(sum / argc);
return ret;
}//flip
|