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
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
|
/*
Copyright 2012 Christian Henning
Use, modification and distribution are subject to the Boost Software License,
Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt).
*/
/*************************************************************************************************/
#ifndef BOOST_GIL_EXTENSION_IO_BMP_DETAIL_READER_BACKEND_HPP
#define BOOST_GIL_EXTENSION_IO_BMP_DETAIL_READER_BACKEND_HPP
////////////////////////////////////////////////////////////////////////////////////////
/// \file
/// \brief
/// \author Christian Henning \n
///
/// \date 2012 \n
///
////////////////////////////////////////////////////////////////////////////////////////
#include <boost/gil/extension/io/bmp/tags.hpp>
namespace boost { namespace gil {
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
#pragma warning(push)
#pragma warning(disable:4512) //assignment operator could not be generated
#endif
/// Color channel mask
struct bit_field
{
unsigned int mask; // Bit mask at corresponding position
unsigned int width; // Bit width of the mask
unsigned int shift; // Bit position from right to left
};
/// BMP color masks
struct color_mask
{
bit_field red; // Red bits
bit_field green; // Green bits
bit_field blue; // Blue bits
};
///
/// BMP Backend
///
template< typename Device >
struct reader_backend< Device
, bmp_tag
>
{
public:
typedef bmp_tag format_tag_t;
public:
reader_backend( const Device& io_dev
, const image_read_settings< bmp_tag >& settings
)
: _io_dev ( io_dev )
, _settings( settings )
, _info()
, _scanline_length( 0 )
, _palette()
{
read_header();
if( _settings._dim.x == 0 )
{
_settings._dim.x = _info._width;
}
if( _settings._dim.y == 0 )
{
_settings._dim.y = _info._height;
}
}
void read_header()
{
// the magic number used to identify the BMP file:
// 0x42 0x4D (ASCII code points for B and M)
if( _io_dev.read_uint16() == 0x424D )
{
io_error( "Wrong magic number for bmp file." );
}
// the size of the BMP file in bytes
_io_dev.read_uint32();
// reserved; actual value depends on the application that creates the image
_io_dev.read_uint16();
// reserved; actual value depends on the application that creates the image
_io_dev.read_uint16();
_info._offset = _io_dev.read_uint32();
// bitmap information
// the size of this header ( 40 bytes )
_info._header_size = _io_dev.read_uint32();
if( _info._header_size == bmp_header_size::_win32_info_size )
{
_info._width = _io_dev.read_uint32();
_info._height = _io_dev.read_uint32();
if (_info._height < 0)
{
_info._height = -_info._height;
_info._top_down = true;
}
// the number of color planes being used. Must be set to 1.
_io_dev.read_uint16();
_info._bits_per_pixel = _io_dev.read_uint16();
_info._compression = _io_dev.read_uint32();
_info._image_size = _io_dev.read_uint32();
_info._horizontal_resolution = _io_dev.read_uint32();
_info._vertical_resolution = _io_dev.read_uint32();
_info._num_colors = _io_dev.read_uint32();
_info._num_important_colors = _io_dev.read_uint32();
}
else if( _info._header_size == bmp_header_size::_os2_info_size )
{
_info._width = static_cast< bmp_image_width::type >( _io_dev.read_uint16() );
_info._height = static_cast< bmp_image_height::type >( _io_dev.read_uint16() );
// the number of color planes being used. Must be set to 1.
_io_dev.read_uint16();
_info._bits_per_pixel = _io_dev.read_uint16();
_info._compression = bmp_compression::_rgb;
// not used
_info._image_size = 0;
_info._horizontal_resolution = 0;
_info._vertical_resolution = 0;
_info._num_colors = 0;
_info._num_important_colors = 0;
}
else if (_info._header_size > bmp_header_size::_win32_info_size)
{
// could be v4 or v5
// see MSDN: Bitmap Header Types ( BITMAPV4HEADER or BITMAPV5HEADER )
_info._width = _io_dev.read_uint32();
_info._height = _io_dev.read_uint32();
// the number of color planes being used. Must be set to 1.
_io_dev.read_uint16();
_info._bits_per_pixel = _io_dev.read_uint16();
_info._compression = _io_dev.read_uint32();
_info._image_size = _io_dev.read_uint32();
_info._horizontal_resolution = _io_dev.read_uint32();
_info._vertical_resolution = _io_dev.read_uint32();
_info._num_colors = _io_dev.read_uint32();
_info._num_important_colors = _io_dev.read_uint32();
}
else
{
io_error( "Invalid BMP info header." );
}
_info._valid = true;
}
void read_palette()
{
int entries = this->_info._num_colors;
if( entries == 0 )
{
entries = 1u << this->_info._bits_per_pixel;
}
_palette.resize( entries, rgba8_pixel_t(0, 0, 0, 0));
for( int i = 0; i < entries; ++i )
{
get_color( _palette[i], blue_t() ) = _io_dev.read_uint8();
get_color( _palette[i], green_t() ) = _io_dev.read_uint8();
get_color( _palette[i], red_t() ) = _io_dev.read_uint8();
// there are 4 entries when windows header
// but 3 for os2 header
if( _info._header_size == bmp_header_size::_win32_info_size )
{
_io_dev.read_uint8();
}
} // for
}
/// Check if image is large enough.
void check_image_size( const point_t& img_dim )
{
if( _settings._dim.x > 0 )
{
if( img_dim.x < _settings._dim.x ) { io_error( "Supplied image is too small" ); }
}
else
{
if( img_dim.x < _info._width ) { io_error( "Supplied image is too small" ); }
}
if( _settings._dim.y > 0 )
{
if( img_dim.y < _settings._dim.y ) { io_error( "Supplied image is too small" ); }
}
else
{
if( img_dim.y < _info._height ) { io_error( "Supplied image is too small" ); }
}
}
public:
Device _io_dev;
image_read_settings< bmp_tag > _settings;
image_read_info< bmp_tag > _info;
std::size_t _scanline_length;
///@todo make it an image.
std::vector< rgba8_pixel_t > _palette;
color_mask _mask;
};
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
#pragma warning(pop)
#endif
} // namespace gil
} // namespace boost
#endif
|
