?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Assorted whitespace cleanup and typo fixes.
[haiku.git] / src / build / libbe / interface / Bitmap.cpp
blob3f8bb0fea5ec620325bcc7cba7e903d08dfd3bbd
1 /*
2 * Copyright 2001-2008, Haiku Inc.
3 * Distributed under the terms of the MIT License.
4 *
5 * Authors:
6 * Ingo Weinhold (bonefish@users.sf.net)
7 * DarkWyrm <bpmagic@columbus.rr.com>
8 * Stephan Aßmus <superstippi@gmx.de>
9 */
10
11 /*! BBitmap objects represent off-screen windows that contain bitmap data. */
12
13 #include <algorithm>
14 #include <limits.h>
15 #include <new>
16 #include <stdio.h>
17 #include <stdlib.h>
18
19 #include <Bitmap.h>
20 #include <GraphicsDefs.h>
21 #include <Locker.h>
22 #include <Message.h>
23
24
25 // structures defining the pixel layout
26
27 struct rgb32_pixel {
28 uint8 blue;
29 uint8 green;
30 uint8 red;
31 uint8 alpha;
32 };
33
34 struct rgb32_big_pixel {
35 uint8 red;
36 uint8 green;
37 uint8 blue;
38 uint8 alpha;
39 };
40
41 struct rgb24_pixel {
42 uint8 blue;
43 uint8 green;
44 uint8 red;
45 };
46
47 struct rgb24_big_pixel {
48 uint8 red;
49 uint8 green;
50 uint8 blue;
51 };
52
53 struct rgb16_pixel {
54 uint8 gb; // G[2:0],B[4:0]
55 uint8 rg; // 16: R[4:0],G[5:3]
56 // 15: -[0],R[4:0],G[4:3]
57 };
58
59 struct rgb16_big_pixel {
60 uint8 rg; // 16: R[4:0],G[5:3]
61 // 15: -[0],R[4:0],G[4:3]
62 uint8 gb; // G[2:0],B[4:0]
63 };
64
65 // types defining what is needed to store a color value
66
67 struct rgb_color_value {
68 uint8 red;
69 uint8 green;
70 uint8 blue;
71 uint8 alpha;
72 };
73
74 typedef uint8 gray_color_value;
75
76 // TODO: system palette -- hard-coded for now, when the app server is ready
77 // we should use system_colors() or BScreen::ColorMap().
78 const rgb_color kSystemPalette[] = {
79 { 0, 0, 0, 255 }, { 8, 8, 8, 255 }, { 16, 16, 16, 255 },
80 { 24, 24, 24, 255 }, { 32, 32, 32, 255 }, { 40, 40, 40, 255 },
81 { 48, 48, 48, 255 }, { 56, 56, 56, 255 }, { 64, 64, 64, 255 },
82 { 72, 72, 72, 255 }, { 80, 80, 80, 255 }, { 88, 88, 88, 255 },
83 { 96, 96, 96, 255 }, { 104, 104, 104, 255 }, { 112, 112, 112, 255 },
84 { 120, 120, 120, 255 }, { 128, 128, 128, 255 }, { 136, 136, 136, 255 },
85 { 144, 144, 144, 255 }, { 152, 152, 152, 255 }, { 160, 160, 160, 255 },
86 { 168, 168, 168, 255 }, { 176, 176, 176, 255 }, { 184, 184, 184, 255 },
87 { 192, 192, 192, 255 }, { 200, 200, 200, 255 }, { 208, 208, 208, 255 },
88 { 216, 216, 216, 255 }, { 224, 224, 224, 255 }, { 232, 232, 232, 255 },
89 { 240, 240, 240, 255 }, { 248, 248, 248, 255 }, { 0, 0, 255, 255 },
90 { 0, 0, 229, 255 }, { 0, 0, 204, 255 }, { 0, 0, 179, 255 },
91 { 0, 0, 154, 255 }, { 0, 0, 129, 255 }, { 0, 0, 105, 255 },
92 { 0, 0, 80, 255 }, { 0, 0, 55, 255 }, { 0, 0, 30, 255 },
93 { 255, 0, 0, 255 }, { 228, 0, 0, 255 }, { 203, 0, 0, 255 },
94 { 178, 0, 0, 255 }, { 153, 0, 0, 255 }, { 128, 0, 0, 255 },
95 { 105, 0, 0, 255 }, { 80, 0, 0, 255 }, { 55, 0, 0, 255 },
96 { 30, 0, 0, 255 }, { 0, 255, 0, 255 }, { 0, 228, 0, 255 },
97 { 0, 203, 0, 255 }, { 0, 178, 0, 255 }, { 0, 153, 0, 255 },
98 { 0, 128, 0, 255 }, { 0, 105, 0, 255 }, { 0, 80, 0, 255 },
99 { 0, 55, 0, 255 }, { 0, 30, 0, 255 }, { 0, 152, 51, 255 },
100 { 255, 255, 255, 255 }, { 203, 255, 255, 255 }, { 203, 255, 203, 255 },
101 { 203, 255, 152, 255 }, { 203, 255, 102, 255 }, { 203, 255, 51, 255 },
102 { 203, 255, 0, 255 }, { 152, 255, 255, 255 }, { 152, 255, 203, 255 },
103 { 152, 255, 152, 255 }, { 152, 255, 102, 255 }, { 152, 255, 51, 255 },
104 { 152, 255, 0, 255 }, { 102, 255, 255, 255 }, { 102, 255, 203, 255 },
105 { 102, 255, 152, 255 }, { 102, 255, 102, 255 }, { 102, 255, 51, 255 },
106 { 102, 255, 0, 255 }, { 51, 255, 255, 255 }, { 51, 255, 203, 255 },
107 { 51, 255, 152, 255 }, { 51, 255, 102, 255 }, { 51, 255, 51, 255 },
108 { 51, 255, 0, 255 }, { 255, 152, 255, 255 }, { 255, 152, 203, 255 },
109 { 255, 152, 152, 255 }, { 255, 152, 102, 255 }, { 255, 152, 51, 255 },
110 { 255, 152, 0, 255 }, { 0, 102, 255, 255 }, { 0, 102, 203, 255 },
111 { 203, 203, 255, 255 }, { 203, 203, 203, 255 }, { 203, 203, 152, 255 },
112 { 203, 203, 102, 255 }, { 203, 203, 51, 255 }, { 203, 203, 0, 255 },
113 { 152, 203, 255, 255 }, { 152, 203, 203, 255 }, { 152, 203, 152, 255 },
114 { 152, 203, 102, 255 }, { 152, 203, 51, 255 }, { 152, 203, 0, 255 },
115 { 102, 203, 255, 255 }, { 102, 203, 203, 255 }, { 102, 203, 152, 255 },
116 { 102, 203, 102, 255 }, { 102, 203, 51, 255 }, { 102, 203, 0, 255 },
117 { 51, 203, 255, 255 }, { 51, 203, 203, 255 }, { 51, 203, 152, 255 },
118 { 51, 203, 102, 255 }, { 51, 203, 51, 255 }, { 51, 203, 0, 255 },
119 { 255, 102, 255, 255 }, { 255, 102, 203, 255 }, { 255, 102, 152, 255 },
120 { 255, 102, 102, 255 }, { 255, 102, 51, 255 }, { 255, 102, 0, 255 },
121 { 0, 102, 152, 255 }, { 0, 102, 102, 255 }, { 203, 152, 255, 255 },
122 { 203, 152, 203, 255 }, { 203, 152, 152, 255 }, { 203, 152, 102, 255 },
123 { 203, 152, 51, 255 }, { 203, 152, 0, 255 }, { 152, 152, 255, 255 },
124 { 152, 152, 203, 255 }, { 152, 152, 152, 255 }, { 152, 152, 102, 255 },
125 { 152, 152, 51, 255 }, { 152, 152, 0, 255 }, { 102, 152, 255, 255 },
126 { 102, 152, 203, 255 }, { 102, 152, 152, 255 }, { 102, 152, 102, 255 },
127 { 102, 152, 51, 255 }, { 102, 152, 0, 255 }, { 51, 152, 255, 255 },
128 { 51, 152, 203, 255 }, { 51, 152, 152, 255 }, { 51, 152, 102, 255 },
129 { 51, 152, 51, 255 }, { 51, 152, 0, 255 }, { 230, 134, 0, 255 },
130 { 255, 51, 203, 255 }, { 255, 51, 152, 255 }, { 255, 51, 102, 255 },
131 { 255, 51, 51, 255 }, { 255, 51, 0, 255 }, { 0, 102, 51, 255 },
132 { 0, 102, 0, 255 }, { 203, 102, 255, 255 }, { 203, 102, 203, 255 },
133 { 203, 102, 152, 255 }, { 203, 102, 102, 255 }, { 203, 102, 51, 255 },
134 { 203, 102, 0, 255 }, { 152, 102, 255, 255 }, { 152, 102, 203, 255 },
135 { 152, 102, 152, 255 }, { 152, 102, 102, 255 }, { 152, 102, 51, 255 },
136 { 152, 102, 0, 255 }, { 102, 102, 255, 255 }, { 102, 102, 203, 255 },
137 { 102, 102, 152, 255 }, { 102, 102, 102, 255 }, { 102, 102, 51, 255 },
138 { 102, 102, 0, 255 }, { 51, 102, 255, 255 }, { 51, 102, 203, 255 },
139 { 51, 102, 152, 255 }, { 51, 102, 102, 255 }, { 51, 102, 51, 255 },
140 { 51, 102, 0, 255 }, { 255, 0, 255, 255 }, { 255, 0, 203, 255 },
141 { 255, 0, 152, 255 }, { 255, 0, 102, 255 }, { 255, 0, 51, 255 },
142 { 255, 175, 19, 255 }, { 0, 51, 255, 255 }, { 0, 51, 203, 255 },
143 { 203, 51, 255, 255 }, { 203, 51, 203, 255 }, { 203, 51, 152, 255 },
144 { 203, 51, 102, 255 }, { 203, 51, 51, 255 }, { 203, 51, 0, 255 },
145 { 152, 51, 255, 255 }, { 152, 51, 203, 255 }, { 152, 51, 152, 255 },
146 { 152, 51, 102, 255 }, { 152, 51, 51, 255 }, { 152, 51, 0, 255 },
147 { 102, 51, 255, 255 }, { 102, 51, 203, 255 }, { 102, 51, 152, 255 },
148 { 102, 51, 102, 255 }, { 102, 51, 51, 255 }, { 102, 51, 0, 255 },
149 { 51, 51, 255, 255 }, { 51, 51, 203, 255 }, { 51, 51, 152, 255 },
150 { 51, 51, 102, 255 }, { 51, 51, 51, 255 }, { 51, 51, 0, 255 },
151 { 255, 203, 102, 255 }, { 255, 203, 152, 255 }, { 255, 203, 203, 255 },
152 { 255, 203, 255, 255 }, { 0, 51, 152, 255 }, { 0, 51, 102, 255 },
153 { 0, 51, 51, 255 }, { 0, 51, 0, 255 }, { 203, 0, 255, 255 },
154 { 203, 0, 203, 255 }, { 203, 0, 152, 255 }, { 203, 0, 102, 255 },
155 { 203, 0, 51, 255 }, { 255, 227, 70, 255 }, { 152, 0, 255, 255 },
156 { 152, 0, 203, 255 }, { 152, 0, 152, 255 }, { 152, 0, 102, 255 },
157 { 152, 0, 51, 255 }, { 152, 0, 0, 255 }, { 102, 0, 255, 255 },
158 { 102, 0, 203, 255 }, { 102, 0, 152, 255 }, { 102, 0, 102, 255 },
159 { 102, 0, 51, 255 }, { 102, 0, 0, 255 }, { 51, 0, 255, 255 },
160 { 51, 0, 203, 255 }, { 51, 0, 152, 255 }, { 51, 0, 102, 255 },
161 { 51, 0, 51, 255 }, { 51, 0, 0, 255 }, { 255, 203, 51, 255 },
162 { 255, 203, 0, 255 }, { 255, 255, 0, 255 }, { 255, 255, 51, 255 },
163 { 255, 255, 102, 255 }, { 255, 255, 152, 255 }, { 255, 255, 203, 255 },
164 { 255, 255, 255, 0 } // B_TRANSPARENT_MAGIC_CMAP8
165 };
166
167
168 /*! \brief Returns the number of bytes per row needed to store the actual
169 bitmap data (not including any padding) given a color space and a
170 row width.
171 \param colorSpace The color space.
172 \param width The width.
173 \return The number of bytes per row needed to store data for a row, or
174 0, if the color space is not supported.
175 */
176 static inline int32
177 get_raw_bytes_per_row(color_space colorSpace, int32 width)
178 {
179 int32 bpr = 0;
180 switch (colorSpace) {
181 // supported
182 case B_RGB32: case B_RGBA32:
183 case B_RGB32_BIG: case B_RGBA32_BIG:
184 case B_UVL32: case B_UVLA32:
185 case B_LAB32: case B_LABA32:
186 case B_HSI32: case B_HSIA32:
187 case B_HSV32: case B_HSVA32:
188 case B_HLS32: case B_HLSA32:
189 case B_CMY32: case B_CMYA32: case B_CMYK32:
190 bpr = 4 * width;
191 break;
192 case B_RGB24: case B_RGB24_BIG:
193 case B_UVL24: case B_LAB24: case B_HSI24:
194 case B_HSV24: case B_HLS24: case B_CMY24:
195 bpr = 3 * width;
196 break;
197 case B_RGB16: case B_RGB15: case B_RGBA15:
198 case B_RGB16_BIG: case B_RGB15_BIG: case B_RGBA15_BIG:
199 bpr = 2 * width;
200 break;
201 case B_CMAP8: case B_GRAY8:
202 bpr = width;
203 break;
204 case B_GRAY1:
205 bpr = (width + 7) / 8;
206 break;
207 case B_YCbCr422: case B_YUV422:
208 bpr = (width + 3) / 4 * 8;
209 break;
210 case B_YCbCr411: case B_YUV411:
211 bpr = (width + 3) / 4 * 6;
212 break;
213 case B_YCbCr444: case B_YUV444:
214 bpr = (width + 3) / 4 * 12;
215 break;
216 case B_YCbCr420: case B_YUV420:
217 bpr = (width + 3) / 4 * 6;
218 break;
219 case B_YUV9:
220 bpr = (width + 15) / 16 * 18;
221 // unsupported
222 case B_NO_COLOR_SPACE:
223 case B_YUV12:
224 break;
225 }
226 return bpr;
227 }
228
229
230 /*! \brief Returns the number of bytes per row needed to store the bitmap
231 data (including any padding) given a color space and a row width.
232 \param colorSpace The color space.
233 \param width The width.
234 \return The number of bytes per row needed to store data for a row, or
235 0, if the color space is not supported.
236 */
237 static inline int32
238 get_bytes_per_row(color_space colorSpace, int32 width)
239 {
240 int32 bpr = get_raw_bytes_per_row(colorSpace, width);
241 // align to int32
242 bpr = (bpr + 3) & 0x7ffffffc;
243 return bpr;
244 }
245
246
247 /*! \brief Returns the brightness of an RGB 24 color.
248 \param red Value of the red component.
249 \param green Value of the green component.
250 \param blue Value of the blue component.
251 \return The brightness for the supplied RGB color as a value between 0
252 and 255.
253 */
254 static inline uint8
255 brightness_for(uint8 red, uint8 green, uint8 blue)
256 {
257 // brightness = 0.301 * red + 0.586 * green + 0.113 * blue
258 // we use for performance reasons:
259 // brightness = (308 * red + 600 * green + 116 * blue) / 1024
260 return uint8((308 * red + 600 * green + 116 * blue) / 1024);
261 }
262
263
264 /*! \brief Returns the "distance" between two RGB colors.
265
266 This functions defines an metric on the RGB color space. The distance
267 between two colors is 0, if and only if the colors are equal.
268
269 \param red1 Red component of the first color.
270 \param green1 Green component of the first color.
271 \param blue1 Blue component of the first color.
272 \param red2 Red component of the second color.
273 \param green2 Green component of the second color.
274 \param blue2 Blue component of the second color.
275 \return The distance between the given colors.
276 */
277 static inline unsigned
278 color_distance(uint8 red1, uint8 green1, uint8 blue1, uint8 red2, uint8 green2,
279 uint8 blue2)
280 {
281 // euklidian distance (its square actually)
282 int rd = (int)red1 - (int)red2;
283 int gd = (int)green1 - (int)green2;
284 int bd = (int)blue1 - (int)blue2;
285 // return rd * rd + gd * gd + bd * bd;
286
287 // distance according to psycho-visual tests
288 int rmean = ((int)red1 + (int)red2) / 2;
289 return (((512 + rmean) * rd * rd) >> 8) + 4 * gd * gd
290 + (((767 - rmean) * bd * bd) >> 8);
291 }
292
293
294 static inline int32
295 bit_mask(int32 bit)
296 {
297 return 1 << bit;
298 }
299
300
301 static inline int32
302 inverse_bit_mask(int32 bit)
303 {
304 return ~bit_mask(bit);
305 }
306
307
308 // #pragma mark - PaletteConverter
309
310
311 namespace BPrivate {
312
313 /*! \brief Helper class for conversion between RGB and palette colors.
314 */
315 class PaletteConverter {
316 public:
317 PaletteConverter();
318 PaletteConverter(const rgb_color *palette);
319 PaletteConverter(const color_map *colorMap);
320 ~PaletteConverter();
321
322 status_t SetTo(const rgb_color *palette);
323 status_t SetTo(const color_map *colorMap);
324 status_t InitCheck() const;
325
326 inline uint8 IndexForRGB15(uint16 rgb) const;
327 inline uint8 IndexForRGB15(uint8 red, uint8 green, uint8 blue) const;
328 inline uint8 IndexForRGB16(uint16 rgb) const;
329 inline uint8 IndexForRGB16(uint8 red, uint8 green, uint8 blue) const;
330 inline uint8 IndexForRGB24(uint32 rgb) const;
331 inline uint8 IndexForRGB24(uint8 red, uint8 green, uint8 blue) const;
332 inline uint8 IndexForGray(uint8 gray) const;
333
334 inline const rgb_color &RGBColorForIndex(uint8 index) const;
335 inline uint16 RGB15ColorForIndex(uint8 index) const;
336 inline uint16 RGB16ColorForIndex(uint8 index) const;
337 inline uint32 RGB24ColorForIndex(uint8 index) const;
338 inline void RGB24ColorForIndex(uint8 index, uint8 &red, uint8 &green,
339 uint8 &blue, uint8 &alpha) const;
340 inline uint8 GrayColorForIndex(uint8 index) const;
341
342 private:
343 const color_map *fColorMap;
344 color_map *fOwnColorMap;
345 status_t fCStatus;
346 };
347
348 } // namespace BPrivate
349
350 using BPrivate::PaletteConverter;
351 using namespace std;
352
353
354 /*! \brief Creates an uninitialized PaletteConverter.
355 */
356 PaletteConverter::PaletteConverter()
357 : fColorMap(NULL),
358 fOwnColorMap(NULL),
359 fCStatus(B_NO_INIT)
360 {
361 }
362
363
364 /*! \brief Creates a PaletteConverter and initializes it to the supplied
365 palette.
366 \param palette The palette being a 256 entry rgb_color array.
367 */
368 PaletteConverter::PaletteConverter(const rgb_color *palette)
369 : fColorMap(NULL),
370 fOwnColorMap(NULL),
371 fCStatus(B_NO_INIT)
372 {
373 SetTo(palette);
374 }
375
376
377 /*! \brief Creates a PaletteConverter and initializes it to the supplied
378 color map.
379 \param colorMap The completely initialized color map.
380 */
381 PaletteConverter::PaletteConverter(const color_map *colorMap)
382 : fColorMap(NULL),
383 fOwnColorMap(NULL),
384 fCStatus(B_NO_INIT)
385 {
386 SetTo(colorMap);
387 }
388
389
390 /*! \brief Frees all resources associated with this object.
391 */
392 PaletteConverter::~PaletteConverter()
393 {
394 delete fOwnColorMap;
395 }
396
397
398 /*! \brief Initializes the converter to the supplied palette.
399 \param palette The palette being a 256 entry rgb_color array.
400 \return \c B_OK, if everything went fine, an error code otherwise.
401 */
402 status_t
403 PaletteConverter::SetTo(const rgb_color *palette)
404 {
405 // cleanup
406 SetTo((const color_map*)NULL);
407 status_t error = (palette ? B_OK : B_BAD_VALUE);
408 // alloc color map
409 if (error == B_OK) {
410 fOwnColorMap = new(nothrow) color_map;
411 if (fOwnColorMap == NULL)
412 error = B_NO_MEMORY;
413 }
414 // init color map
415 if (error == B_OK) {
416 fColorMap = fOwnColorMap;
417 // init color list
418 memcpy(fOwnColorMap->color_list, palette, sizeof(rgb_color) * 256);
419 // init index map
420 for (int32 color = 0; color < 32768; color++) {
421 // get components
422 uint8 red = (color & 0x7c00) >> 7;
423 uint8 green = (color & 0x3e0) >> 2;
424 uint8 blue = (color & 0x1f) << 3;
425 red |= red >> 5;
426 green |= green >> 5;
427 blue |= blue >> 5;
428 // find closest color
429 uint8 closestIndex = 0;
430 unsigned closestDistance = UINT_MAX;
431 for (int32 i = 0; i < 256; i++) {
432 const rgb_color &c = fOwnColorMap->color_list[i];
433 unsigned distance = color_distance(red, green, blue,
434 c.red, c.green, c.blue);
435 if (distance < closestDistance) {
436 closestIndex = i;
437 closestDistance = distance;
438 }
439 }
440 fOwnColorMap->index_map[color] = closestIndex;
441 }
442 // no need to init inversion map
443 }
444 fCStatus = error;
445 return error;
446 }
447
448
449 /*! \brief Initializes the converter to the supplied color map.
450 \param colorMap The completely initialized color map.
451 \return \c B_OK, if everything went fine, an error code otherwise.
452 */
453 status_t
454 PaletteConverter::SetTo(const color_map *colorMap)
455 {
456 // cleanup
457 if (fOwnColorMap) {
458 delete fOwnColorMap;
459 fOwnColorMap = NULL;
460 }
461 // set
462 fColorMap = colorMap;
463 fCStatus = fColorMap ? B_OK : B_BAD_VALUE;
464 return fCStatus;
465 }
466
467
468 /*! \brief Returns the result of the last initialization via constructor or
469 SetTo().
470 \return \c B_OK, if the converter is properly initialized, an error code
471 otherwise.
472 */
473 status_t
474 PaletteConverter::InitCheck() const
475 {
476 return fCStatus;
477 }
478
479
480 /*! \brief Returns the palette color index closest to a given RGB 15 color.
481
482 The object must be properly initialized.
483
484 \param rgb The RGB 15 color value (R[14:10]G[9:5]B[4:0]).
485 \return The palette color index for the supplied color.
486 */
487 inline uint8
488 PaletteConverter::IndexForRGB15(uint16 rgb) const
489 {
490 return fColorMap->index_map[rgb];
491 }
492
493
494 /*! \brief Returns the palette color index closest to a given RGB 15 color.
495
496 The object must be properly initialized.
497
498 \param red Red component of the color (R[4:0]).
499 \param green Green component of the color (G[4:0]).
500 \param blue Blue component of the color (B[4:0]).
501 \return The palette color index for the supplied color.
502 */
503 inline uint8
504 PaletteConverter::IndexForRGB15(uint8 red, uint8 green, uint8 blue) const
505 {
506 // the 5 least significant bits are used
507 return fColorMap->index_map[(red << 10) | (green << 5) | blue];
508 }
509
510
511 /*! \brief Returns the palette color index closest to a given RGB 16 color.
512
513 The object must be properly initialized.
514
515 \param rgb The RGB 16 color value (R[15:11]G[10:5]B[4:0]).
516 \return The palette color index for the supplied color.
517 */
518 inline uint8
519 PaletteConverter::IndexForRGB16(uint16 rgb) const
520 {
521 return fColorMap->index_map[((rgb >> 1) & 0x7fe0) | (rgb & 0x1f)];
522 }
523
524
525 /*! \brief Returns the palette color index closest to a given RGB 16 color.
526
527 The object must be properly initialized.
528
529 \param red Red component of the color (R[4:0]).
530 \param green Green component of the color (G[5:0]).
531 \param blue Blue component of the color (B[4:0]).
532 \return The palette color index for the supplied color.
533 */
534 inline uint8
535 PaletteConverter::IndexForRGB16(uint8 red, uint8 green, uint8 blue) const
536 {
537 // the 5 (for red, blue) / 6 (for green) least significant bits are used
538 return fColorMap->index_map[(red << 10) | ((green & 0x3e) << 4) | blue];
539 }
540
541
542 /*! \brief Returns the palette color index closest to a given RGB 32 color.
543
544 The object must be properly initialized.
545
546 \param rgb The RGB 32 color value (R[31:24]G[23:16]B[15:8]).
547 \return The palette color index for the supplied color.
548 */
549 inline uint8
550 PaletteConverter::IndexForRGB24(uint32 rgb) const
551 {
552 return fColorMap->index_map[((rgb & 0xf8000000) >> 17)
553 | ((rgb & 0xf80000) >> 14) | ((rgb & 0xf800) >> 11)];
554 }
555
556
557 /*! \brief Returns the palette color index closest to a given RGB 24 color.
558
559 The object must be properly initialized.
560
561 \param red Red component of the color.
562 \param green Green component of the color.
563 \param blue Blue component of the color.
564 \return The palette color index for the supplied color.
565 */
566 inline uint8
567 PaletteConverter::IndexForRGB24(uint8 red, uint8 green, uint8 blue) const
568 {
569 return fColorMap->index_map[((red & 0xf8) << 7) | ((green & 0xf8) << 2)
570 | (blue >> 3)];
571 }
572
573
574 /*! \brief Returns the palette color index closest to a given Gray 8 color.
575
576 The object must be properly initialized.
577
578 \param gray The Gray 8 color value.
579 \return The palette color index for the supplied color.
580 */
581 inline uint8
582 PaletteConverter::IndexForGray(uint8 gray) const
583 {
584 return IndexForRGB24(gray, gray, gray);
585 }
586
587
588 /*! \brief Returns the RGB color for a given palette color index.
589
590 The object must be properly initialized.
591
592 \param index The palette color index.
593 \return The color for the supplied palette color index.
594 */
595 inline const rgb_color &
596 PaletteConverter::RGBColorForIndex(uint8 index) const
597 {
598 return fColorMap->color_list[index];
599 }
600
601
602 /*! \brief Returns the RGB 15 color for a given palette color index.
603
604 The object must be properly initialized.
605
606 \param index The palette color index.
607 \return The color for the supplied palette color index
608 (R[14:10]G[9:5]B[4:0]).
609 */
610 inline uint16
611 PaletteConverter::RGB15ColorForIndex(uint8 index) const
612 {
613 const rgb_color &color = fColorMap->color_list[index];
614 return ((color.red & 0xf8) << 7) | ((color.green & 0xf8) << 2)
615 | (color.blue >> 3);
616 }
617
618
619 /*! \brief Returns the RGB 16 color for a given palette color index.
620
621 The object must be properly initialized.
622
623 \param index The palette color index.
624 \return The color for the supplied palette color index
625 (R[15:11]G[10:5]B[4:0]).
626 */
627 inline uint16
628 PaletteConverter::RGB16ColorForIndex(uint8 index) const
629 {
630 const rgb_color &color = fColorMap->color_list[index];
631 return ((color.red & 0xf8) << 8) | ((color.green & 0xfc) << 3)
632 | (color.blue >> 3);
633 }
634
635
636 /*! \brief Returns the RGB 24 color for a given palette color index.
637
638 The object must be properly initialized.
639
640 \param index The palette color index.
641 \return The color for the supplied palette color index
642 (R[31:24]G[23:16]B[15:8]).
643 */
644 inline uint32
645 PaletteConverter::RGB24ColorForIndex(uint8 index) const
646 {
647 const rgb_color &color = fColorMap->color_list[index];
648 return (color.blue << 24) | (color.red << 8) | (color.green << 16)
649 | color.alpha;
650 }
651
652
653 /*! \brief Returns the RGB 24 color for a given palette color index.
654
655 The object must be properly initialized.
656
657 \param index The palette color index.
658 \param red Reference to the variable the red component shall be stored
659 into.
660 \param green Reference to the variable the green component shall be stored
661 into.
662 \param blue Reference to the variable the blue component shall be stored
663 into.
664 */
665 inline void
666 PaletteConverter::RGB24ColorForIndex(uint8 index, uint8 &red, uint8 &green,
667 uint8 &blue, uint8 &alpha) const
668 {
669 const rgb_color &color = fColorMap->color_list[index];
670 red = color.red;
671 green = color.green;
672 blue = color.blue;
673 alpha = color.alpha;
674 }
675
676
677 /*! \brief Returns the Gray 8 color for a given palette color index.
678
679 The object must be properly initialized.
680
681 \param index The palette color index.
682 \return The color for the supplied palette color index.
683 */
684 inline uint8
685 PaletteConverter::GrayColorForIndex(uint8 index) const
686 {
687 const rgb_color &color = fColorMap->color_list[index];
688 return brightness_for(color.red, color.green, color.blue);
689 }
690
691 // TODO: Remove these and palette_converter() when BScreen is available.
692 static BLocker gPaletteConverterLock;
693 static PaletteConverter gPaletteConverter;
694
695
696 /*! \brief Returns a PaletteConverter using the system color palette.
697 \return A PaletteConverter.
698 */
699 static const PaletteConverter*
700 palette_converter()
701 {
702 if (gPaletteConverterLock.Lock()) {
703 if (gPaletteConverter.InitCheck() != B_OK)
704 gPaletteConverter.SetTo(kSystemPalette);
705 gPaletteConverterLock.Unlock();
706 }
707 return &gPaletteConverter;
708 }
709
710
711 // #pragma mark - Reader classes
712
713
714 // BaseReader
715 template<typename _PixelType>
716 struct BaseReader {
717 typedef _PixelType pixel_t;
718
719 BaseReader(const void *data) : pixels((const pixel_t*)data) {}
720
721 inline void SetTo(const void *data) { pixels = (const pixel_t*)data; }
722
723 inline void NextRow(int32 skip)
724 {
725 pixels = (const pixel_t*)((const char*)pixels + skip);
726 }
727
728 const pixel_t *pixels;
729 };
730
731 // RGB24Reader
732 template<typename _PixelType>
733 struct RGB24Reader : public BaseReader<_PixelType> {
734 typedef rgb_color_value preferred_color_value_t;
735 typedef _PixelType pixel_t;
736
737 RGB24Reader(const void *data) : BaseReader<_PixelType>(data) {}
738
739 inline void Read(rgb_color_value &color)
740 {
741 const pixel_t &pixel = *BaseReader<_PixelType>::pixels;
742 color.red = pixel.red;
743 color.green = pixel.green;
744 color.blue = pixel.blue;
745 color.alpha = 255;
746 BaseReader<_PixelType>::pixels++;
747 }
748
749 inline void Read(gray_color_value &gray)
750 {
751 rgb_color_value color;
752 Read(color);
753 gray = brightness_for(color.red, color.green, color.blue);
754 }
755 };
756
757 // RGB16Reader
758 template<typename _PixelType>
759 struct RGB16Reader : public BaseReader<_PixelType> {
760 typedef rgb_color_value preferred_color_value_t;
761 typedef _PixelType pixel_t;
762
763 RGB16Reader(const void *data) : BaseReader<_PixelType>(data) {}
764
765 inline void Read(rgb_color_value &color)
766 {
767 // rg: R[4:0],G[5:3]
768 // gb: G[2:0],B[4:0]
769 const pixel_t &pixel = *BaseReader<_PixelType>::pixels;
770 color.red = pixel.rg & 0xf8;
771 color.green = ((pixel.rg & 0x07) << 5) & ((pixel.gb & 0xe0) >> 3);
772 color.blue = (pixel.gb & 0x1f) << 3;
773 color.red |= color.red >> 5;
774 color.green |= color.green >> 6;
775 color.blue |= color.blue >> 5;
776 color.alpha = 255;
777 BaseReader<_PixelType>::pixels++;
778 }
779
780 inline void Read(gray_color_value &gray)
781 {
782 rgb_color_value color;
783 Read(color);
784 gray = brightness_for(color.red, color.green, color.blue);
785 }
786 };
787
788 // RGB15Reader
789 template<typename _PixelType>
790 struct RGB15Reader : public BaseReader<_PixelType> {
791 typedef rgb_color_value preferred_color_value_t;
792 typedef _PixelType pixel_t;
793
794 RGB15Reader(const void *data) : BaseReader<_PixelType>(data) {}
795
796 inline void Read(rgb_color_value &color)
797 {
798 // rg: -[0],R[4:0],G[4:3]
799 // gb: G[2:0],B[4:0]
800 const pixel_t &pixel = *BaseReader<_PixelType>::pixels;
801 color.red = (pixel.rg & 0x7c) << 1;
802 color.green = ((pixel.rg & 0x03) << 6) & ((pixel.gb & 0xe0) >> 2);
803 color.blue = (pixel.gb & 0x1f) << 3;
804 color.red |= color.red >> 5;
805 color.green |= color.green >> 5;
806 color.blue |= color.blue >> 5;
807 color.alpha = 255;
808 BaseReader<_PixelType>::pixels++;
809 }
810
811 inline void Read(gray_color_value &gray)
812 {
813 rgb_color_value color;
814 Read(color);
815 gray = brightness_for(color.red, color.green, color.blue);
816 }
817 };
818
819 // CMAP8Reader
820 struct CMAP8Reader : public BaseReader<uint8> {
821 typedef rgb_color_value preferred_color_value_t;
822
823 CMAP8Reader(const void *data, const PaletteConverter &converter)
824 : BaseReader<uint8>(data), converter(converter) {}
825
826 inline void Read(rgb_color_value &color)
827 {
828 converter.RGB24ColorForIndex(*BaseReader<uint8>::pixels, color.red, color.green,
829 color.blue, color.alpha);
830 BaseReader<uint8>::pixels++;
831 }
832
833 inline void Read(gray_color_value &gray)
834 {
835 gray = converter.GrayColorForIndex(*BaseReader<uint8>::pixels);
836 BaseReader<uint8>::pixels++;
837 }
838
839 const PaletteConverter &converter;
840 };
841
842 // Gray8Reader
843 struct Gray8Reader : public BaseReader<uint8> {
844 typedef gray_color_value preferred_color_value_t;
845
846 Gray8Reader(const void *data) : BaseReader<uint8>(data) {}
847
848 inline void Read(rgb_color_value &color)
849 {
850 color.red = color.green = color.blue = *BaseReader<uint8>::pixels;
851 color.alpha = 255;
852 BaseReader<uint8>::pixels++;
853 }
854
855 inline void Read(gray_color_value &gray)
856 {
857 gray = *BaseReader<uint8>::pixels;
858 BaseReader<uint8>::pixels++;
859 }
860 };
861
862 // Gray1Reader
863 struct Gray1Reader : public BaseReader<uint8> {
864 typedef gray_color_value preferred_color_value_t;
865
866 Gray1Reader(const void *data) : BaseReader<uint8>(data), bit(7) {}
867
868 inline void SetTo(const void *data)
869 {
870 pixels = (const pixel_t*)data;
871 bit = 7;
872 }
873
874 inline void NextRow(int32 skip)
875 {
876 if (bit == 7)
877 pixels = (const pixel_t*)((const char*)pixels + skip);
878 else {
879 pixels = (const pixel_t*)((const char*)pixels + skip + 1);
880 bit = 7;
881 }
882 }
883
884 inline void Read(rgb_color_value &color)
885 {
886 if (*pixels & bit_mask(bit))
887 color.red = color.green = color.blue = 255;
888 else
889 color.red = color.green = color.blue = 0;
890 color.alpha = 255;
891 bit--;
892 if (bit == -1) {
893 pixels++;
894 bit = 7;
895 }
896 }
897
898 inline void Read(gray_color_value &gray)
899 {
900 if (*pixels & bit_mask(bit))
901 gray = 255;
902 else
903 gray = 0;
904 bit--;
905 if (bit == -1) {
906 pixels++;
907 bit = 7;
908 }
909 }
910
911 int32 bit;
912 };
913
914
915 // #pragma mark - Writer classes
916
917
918 // BaseWriter
919 template<typename _PixelType>
920 struct BaseWriter {
921 typedef _PixelType pixel_t;
922
923 BaseWriter(void *data) : pixels((pixel_t*)data) {}
924
925 inline void SetTo(void *data) { pixels = (pixel_t*)data; }
926
927 pixel_t *pixels;
928 };
929
930
931 // RGB32Writer
932 template<typename _PixelType>
933 struct RGB32Writer : public BaseWriter<_PixelType> {
934 typedef rgb_color_value preferred_color_value_t;
935 typedef _PixelType pixel_t;
936
937 RGB32Writer(void *data) : BaseWriter<_PixelType>(data) {}
938
939 inline void Write(const rgb_color_value &color)
940 {
941 pixel_t &pixel = *BaseWriter<_PixelType>::pixels;
942 pixel.red = color.red;
943 pixel.green = color.green;
944 pixel.blue = color.blue;
945 pixel.alpha = color.alpha;
946 BaseWriter<_PixelType>::pixels++;
947 }
948
949 inline void Write(const gray_color_value &gray)
950 {
951 pixel_t &pixel = *BaseWriter<_PixelType>::pixels;
952 pixel.red = gray;
953 pixel.green = gray;
954 pixel.blue = gray;
955 pixel.alpha = 255;
956 BaseWriter<_PixelType>::pixels++;
957 }
958 };
959
960 // RGB24Writer
961 template<typename _PixelType>
962 struct RGB24Writer : public BaseWriter<_PixelType> {
963 typedef rgb_color_value preferred_color_value_t;
964 typedef _PixelType pixel_t;
965
966 RGB24Writer(void *data) : BaseWriter<_PixelType>(data) {}
967
968 inline void Write(const rgb_color_value &color)
969 {
970 pixel_t &pixel = *BaseWriter<_PixelType>::pixels;
971 pixel.red = color.red;
972 pixel.green = color.green;
973 pixel.blue = color.blue;
974 BaseWriter<_PixelType>::pixels++;
975 }
976
977 inline void Write(const gray_color_value &gray)
978 {
979 pixel_t &pixel = *BaseWriter<_PixelType>::pixels;
980 pixel.red = gray;
981 pixel.green = gray;
982 pixel.blue = gray;
983 BaseWriter<_PixelType>::pixels++;
984 }
985 };
986
987 // RGB16Writer
988 template<typename _PixelType>
989 struct RGB16Writer : public BaseWriter<_PixelType> {
990 typedef rgb_color_value preferred_color_value_t;
991 typedef _PixelType pixel_t;
992
993 RGB16Writer(void *data) : BaseWriter<_PixelType>(data) {}
994
995 inline void Write(const rgb_color_value &color)
996 {
997 // rg: R[4:0],G[5:3]
998 // gb: G[2:0],B[4:0]
999 pixel_t &pixel = *BaseWriter<_PixelType>::pixels;
1000 pixel.rg = (color.red & 0xf8) | (color.green >> 5);
1001 pixel.gb = ((color.green & 0x1c) << 3) | (color.blue >> 3);
1002 BaseWriter<_PixelType>::pixels++;
1003 }
1004
1005 inline void Write(const gray_color_value &gray)
1006 {
1007 pixel_t &pixel = *BaseWriter<_PixelType>::pixels;
1008 pixel.rg = (gray & 0xf8) | (gray >> 5);
1009 pixel.gb = ((gray & 0x1c) << 3) | (gray >> 3);
1010 BaseWriter<_PixelType>::pixels++;
1011 }
1012 };
1013
1014 // RGB15Writer
1015 template<typename _PixelType>
1016 struct RGB15Writer : public BaseWriter<_PixelType> {
1017 typedef rgb_color_value preferred_color_value_t;
1018 typedef _PixelType pixel_t;
1019
1020 RGB15Writer(void *data) : BaseWriter<_PixelType>(data) {}
1021
1022 inline void Write(const rgb_color_value &color)
1023 {
1024 // rg: -[0],R[4:0],G[4:3]
1025 // gb: G[2:0],B[4:0]
1026 pixel_t &pixel = *BaseWriter<_PixelType>::pixels;
1027 pixel.rg = ((color.red & 0xf8) >> 1) | (color.green >> 6);
1028 pixel.gb = ((color.green & 0x38) << 2) | (color.blue >> 3);
1029 BaseWriter<_PixelType>::pixels++;
1030 }
1031
1032 inline void Write(const gray_color_value &gray)
1033 {
1034 pixel_t &pixel = *BaseWriter<_PixelType>::pixels;
1035 pixel.rg = ((gray & 0xf8) >> 1) | (gray >> 6);
1036 pixel.gb = ((gray & 0x38) << 2) | (gray >> 3);
1037 BaseWriter<_PixelType>::pixels++;
1038 }
1039 };
1040
1041 // CMAP8Writer
1042 struct CMAP8Writer : public BaseWriter<uint8> {
1043 typedef rgb_color_value preferred_color_value_t;
1044
1045 CMAP8Writer(void *data, const PaletteConverter &converter)
1046 : BaseWriter<uint8>(data), converter(converter) {}
1047
1048 inline void Write(const rgb_color_value &color)
1049 {
1050 *pixels = converter.IndexForRGB24(color.red, color.green, color.blue);
1051 pixels++;
1052 }
1053
1054 inline void Write(const gray_color_value &gray)
1055 {
1056 *pixels = converter.IndexForGray(gray);
1057 pixels++;
1058 }
1059
1060 const PaletteConverter &converter;
1061 };
1062
1063 // Gray8Writer
1064 struct Gray8Writer : public BaseWriter<uint8> {
1065 typedef gray_color_value preferred_color_value_t;
1066
1067 Gray8Writer(void *data) : BaseWriter<uint8>(data) {}
1068
1069 inline void Write(const rgb_color_value &color)
1070 {
1071 *pixels = brightness_for(color.red, color.green, color.blue);
1072 pixels++;
1073 }
1074
1075 inline void Write(const gray_color_value &gray)
1076 {
1077 *pixels = gray;
1078 pixels++;
1079 }
1080 };
1081
1082 // Gray1Writer
1083 struct Gray1Writer : public BaseWriter<uint8> {
1084 typedef gray_color_value preferred_color_value_t;
1085
1086 Gray1Writer(void *data) : BaseWriter<uint8>(data), bit(7) {}
1087
1088 inline void SetTo(void *data) { pixels = (pixel_t*)data; bit = 7; }
1089
1090 inline void Write(const gray_color_value &gray)
1091 {
1092 *pixels = (*pixels & inverse_bit_mask(bit))
1093 | (gray & 0x80) >> (7 - bit);
1094 bit--;
1095 if (bit == -1) {
1096 pixels++;
1097 bit = 7;
1098 }
1099 }
1100
1101 inline void Write(const rgb_color_value &color)
1102 {
1103 Write(brightness_for(color.red, color.green, color.blue));
1104 }
1105
1106 int32 bit;
1107 };
1108
1109
1110 // set_bits_worker
1111 /*! \brief Worker function that reads bitmap data from one buffer and writes
1112 it (converted) to another one.
1113 \param Reader The pixel reader class.
1114 \param Writer The pixel writer class.
1115 \param color_value_t The color value type used to transport a pixel from
1116 the reader to the writer.
1117 \param inData A pointer to the buffer to be read.
1118 \param inLength The length (in bytes) of the "in" buffer.
1119 \param inBPR The number of bytes per row in the "in" buffer.
1120 \param inRowSkip The number of bytes per row in the "in" buffer serving as
1121 padding.
1122 \param outData A pointer to the buffer to be written to.
1123 \param outLength The length (in bytes) of the "out" buffer.
1124 \param outOffset The offset (in bytes) relative to \a outData from which
1125 the function shall start writing.
1126 \param outBPR The number of bytes per row in the "out" buffer.
1127 \param rawOutBPR The number of bytes per row in the "out" buffer actually
1128 containing bitmap data (i.e. not including the padding).
1129 \param _reader A reader object. The pointer to the data doesn't need to
1130 be initialized.
1131 \param _writer A writer object. The pointer to the data doesn't need to
1132 be initialized.
1133 \return \c B_OK, if everything went fine, an error code otherwise.
1134 */
1135 template<typename Reader, typename Writer, typename color_value_t>
1136 static
1137 status_t
1138 set_bits_worker(const void *inData, int32 inLength, int32 inBPR,
1139 int32 inRowSkip, void *outData, int32 outLength,
1140 int32 outOffset, int32 outBPR, int32 rawOutBPR,
1141 Reader _reader, Writer _writer)
1142 {
1143 status_t error = B_OK;
1144 Reader reader(_reader);
1145 Writer writer(_writer);
1146 reader.SetTo(inData);
1147 writer.SetTo((char*)outData + outOffset);
1148 const char *inEnd = (const char*)inData + inLength
1149 - sizeof(typename Reader::pixel_t);
1150 const char *inLastRow = (const char*)inData + inLength
1151 - (inBPR - inRowSkip);
1152 const char *outEnd = (const char*)outData + outLength
1153 - sizeof(typename Writer::pixel_t);
1154 char *outRow = (char*)outData + outOffset - outOffset % outBPR;
1155 const char *outRowEnd = outRow + rawOutBPR - sizeof(typename Writer::pixel_t);
1156 while ((const char*)reader.pixels <= inEnd
1157 && (const char*)writer.pixels <= outEnd) {
1158 // process one row
1159 if ((const char*)reader.pixels <= inLastRow) {
1160 // at least a complete row left
1161 while ((const char*)writer.pixels <= outRowEnd) {
1162 color_value_t color;
1163 reader.Read(color);
1164 writer.Write(color);
1165 }
1166 } else {
1167 // no complete row left
1168 // but maybe the complete end of the first row
1169 while ((const char*)reader.pixels <= inEnd
1170 && (const char*)writer.pixels <= outRowEnd) {
1171 color_value_t color;
1172 reader.Read(color);
1173 writer.Write(color);
1174 }
1175 }
1176 // must be here, not in the if-branch (end of first row)
1177 outRow += outBPR;
1178 outRowEnd += outBPR;
1179 reader.NextRow(inRowSkip);
1180 writer.SetTo(outRow);
1181 }
1182 return error;
1183 }
1184
1185 // set_bits_worker_gray1
1186 /*! \brief Worker function that reads bitmap data from one buffer and writes
1187 it (converted) to another one, which uses color space \c B_GRAY1.
1188 \param Reader The pixel reader class.
1189 \param Writer The pixel writer class.
1190 \param color_value_t The color value type used to transport a pixel from
1191 the reader to the writer.
1192 \param inData A pointer to the buffer to be read.
1193 \param inLength The length (in bytes) of the "in" buffer.
1194 \param inBPR The number of bytes per row in the "in" buffer.
1195 \param inRowSkip The number of bytes per row in the "in" buffer serving as
1196 padding.
1197 \param outData A pointer to the buffer to be written to.
1198 \param outLength The length (in bytes) of the "out" buffer.
1199 \param outOffset The offset (in bytes) relative to \a outData from which
1200 the function shall start writing.
1201 \param outBPR The number of bytes per row in the "out" buffer.
1202 \param width The number of pixels per row in "in" and "out" data.
1203 \param _reader A reader object. The pointer to the data doesn't need to
1204 be initialized.
1205 \param _writer A writer object. The pointer to the data doesn't need to
1206 be initialized.
1207 \return \c B_OK, if everything went fine, an error code otherwise.
1208 */
1209 template<typename Reader, typename Writer, typename color_value_t>
1210 static
1211 status_t
1212 set_bits_worker_gray1(const void *inData, int32 inLength, int32 inBPR,
1213 int32 inRowSkip, void *outData, int32 outLength,
1214 int32 outOffset, int32 outBPR, int32 width,
1215 Reader _reader, Writer _writer)
1216 {
1217 status_t error = B_OK;
1218 Reader reader(_reader);
1219 Writer writer(_writer);
1220 reader.SetTo(inData);
1221 writer.SetTo((char*)outData + outOffset);
1222 const char *inEnd = (const char*)inData + inLength
1223 - sizeof(typename Reader::pixel_t);
1224 const char *inLastRow = (const char*)inData + inLength
1225 - (inBPR - inRowSkip);
1226 const char *outEnd = (const char*)outData + outLength - outBPR;
1227 char *outRow = (char*)outData + outOffset - outOffset % outBPR;
1228 int32 x = max((int32)0,
1229 width - (int32)((char*)outData + outOffset - outRow) * 8) - 1;
1230 while ((const char*)reader.pixels <= inEnd
1231 && (const char*)writer.pixels <= outEnd) {
1232 // process one row
1233 if ((const char*)reader.pixels <= inLastRow) {
1234 // at least a complete row left
1235 while (x >= 0) {
1236 color_value_t color;
1237 reader.Read(color);
1238 writer.Write(color);
1239 x--;
1240 }
1241 } else {
1242 // no complete row left
1243 // but maybe the complete end of the first row
1244 while ((const char*)reader.pixels <= inEnd && x >= 0) {
1245 color_value_t color;
1246 reader.Read(color);
1247 writer.Write(color);
1248 x--;
1249 }
1250 }
1251 // must be here, not in the if-branch (end of first row)
1252 x = width - 1;
1253 outRow += outBPR;
1254 reader.NextRow(inRowSkip);
1255 writer.SetTo(outRow);
1256 }
1257 return error;
1258 }
1259
1260 // set_bits
1261 /*! \brief Helper function that reads bitmap data from one buffer and writes
1262 it (converted) to another one.
1263 \param Reader The pixel reader class.
1264 \param inData A pointer to the buffer to be read.
1265 \param inLength The length (in bytes) of the "in" buffer.
1266 \param inBPR The number of bytes per row in the "in" buffer.
1267 \param inRowSkip The number of bytes per row in the "in" buffer serving as
1268 padding.
1269 \param outData A pointer to the buffer to be written to.
1270 \param outLength The length (in bytes) of the "out" buffer.
1271 \param outOffset The offset (in bytes) relative to \a outData from which
1272 the function shall start writing.
1273 \param outBPR The number of bytes per row in the "out" buffer.
1274 \param rawOutBPR The number of bytes per row in the "out" buffer actually
1275 containing bitmap data (i.e. not including the padding).
1276 \param outColorSpace Color space of the target buffer.
1277 \param width The number of pixels per row in "in" and "out" data.
1278 \param reader A reader object. The pointer to the data doesn't need to
1279 be initialized.
1280 \param paletteConverter Reference to a PaletteConverter to be used, if
1281 a conversion from or to \c B_CMAP8 has to be done.
1282 \return \c B_OK, if everything went fine, an error code otherwise.
1283 */
1284 template<typename Reader>
1285 static
1286 status_t
1287 set_bits(const void *inData, int32 inLength, int32 inBPR, int32 inRowSkip,
1288 void *outData, int32 outLength, int32 outOffset, int32 outBPR,
1289 int32 rawOutBPR, color_space outColorSpace, int32 width,
1290 Reader reader, const PaletteConverter &paletteConverter)
1291 {
1292 status_t error = B_OK;
1293 switch (outColorSpace) {
1294 // supported
1295 case B_RGB32: case B_RGBA32:
1296 {
1297 typedef RGB32Writer<rgb32_pixel> Writer;
1298 typedef typename Reader::preferred_color_value_t color_value_t;
1299 error = set_bits_worker<Reader, Writer, color_value_t>(
1300 inData, inLength, inBPR, inRowSkip, outData, outLength,
1301 outOffset, outBPR, rawOutBPR, reader, Writer(outData));
1302 break;
1303 }
1304 case B_RGB32_BIG: case B_RGBA32_BIG:
1305 {
1306 typedef RGB32Writer<rgb32_big_pixel> Writer;
1307 typedef typename Reader::preferred_color_value_t color_value_t;
1308 error = set_bits_worker<Reader, Writer, color_value_t>(
1309 inData, inLength, inBPR, inRowSkip, outData, outLength,
1310 outOffset, outBPR, rawOutBPR, reader, Writer(outData));
1311 break;
1312 }
1313 case B_RGB24:
1314 {
1315 typedef RGB24Writer<rgb24_pixel> Writer;
1316 typedef typename Reader::preferred_color_value_t color_value_t;
1317 error = set_bits_worker<Reader, Writer, color_value_t>(
1318 inData, inLength, inBPR, inRowSkip, outData, outLength,
1319 outOffset, outBPR, rawOutBPR, reader, Writer(outData));
1320 break;
1321 }
1322 case B_RGB24_BIG:
1323 {
1324 typedef RGB24Writer<rgb24_big_pixel> Writer;
1325 typedef typename Reader::preferred_color_value_t color_value_t;
1326 error = set_bits_worker<Reader, Writer, color_value_t>(
1327 inData, inLength, inBPR, inRowSkip, outData, outLength,
1328 outOffset, outBPR, rawOutBPR, reader, Writer(outData));
1329 break;
1330 }
1331 case B_RGB16:
1332 {
1333 typedef RGB16Writer<rgb16_pixel> Writer;
1334 typedef typename Reader::preferred_color_value_t color_value_t;
1335 error = set_bits_worker<Reader, Writer, color_value_t>(
1336 inData, inLength, inBPR, inRowSkip, outData, outLength,
1337 outOffset, outBPR, rawOutBPR, reader, Writer(outData));
1338 break;
1339 }
1340 case B_RGB16_BIG:
1341 {
1342 typedef RGB16Writer<rgb16_big_pixel> Writer;
1343 typedef typename Reader::preferred_color_value_t color_value_t;
1344 error = set_bits_worker<Reader, Writer, color_value_t>(
1345 inData, inLength, inBPR, inRowSkip, outData, outLength,
1346 outOffset, outBPR, rawOutBPR, reader, Writer(outData));
1347 break;
1348 }
1349 case B_RGB15: case B_RGBA15:
1350 {
1351 typedef RGB15Writer<rgb16_pixel> Writer;
1352 typedef typename Reader::preferred_color_value_t color_value_t;
1353 error = set_bits_worker<Reader, Writer, color_value_t>(
1354 inData, inLength, inBPR, inRowSkip, outData, outLength,
1355 outOffset, outBPR, rawOutBPR, reader, Writer(outData));
1356 break;
1357 }
1358 case B_RGB15_BIG: case B_RGBA15_BIG:
1359 {
1360 typedef RGB15Writer<rgb16_big_pixel> Writer;
1361 typedef typename Reader::preferred_color_value_t color_value_t;
1362 error = set_bits_worker<Reader, Writer, color_value_t>(
1363 inData, inLength, inBPR, inRowSkip, outData, outLength,
1364 outOffset, outBPR, rawOutBPR, reader, Writer(outData));
1365 break;
1366 }
1367 case B_CMAP8:
1368 {
1369 typedef CMAP8Writer Writer;
1370 typedef typename Reader::preferred_color_value_t color_value_t;
1371 error = set_bits_worker<Reader, Writer, color_value_t>(
1372 inData, inLength, inBPR, inRowSkip, outData, outLength,
1373 outOffset, outBPR, rawOutBPR, reader,
1374 Writer(outData, paletteConverter));
1375 break;
1376 }
1377 case B_GRAY8:
1378 {
1379 typedef Gray8Writer Writer;
1380 typedef gray_color_value color_value_t;
1381 error = set_bits_worker<Reader, Writer, color_value_t>(
1382 inData, inLength, inBPR, inRowSkip, outData, outLength,
1383 outOffset, outBPR, rawOutBPR, reader, Writer(outData));
1384 break;
1385 }
1386 case B_GRAY1:
1387 {
1388 typedef Gray1Writer Writer;
1389 typedef gray_color_value color_value_t;
1390 error = set_bits_worker_gray1<Reader, Writer, color_value_t>(
1391 inData, inLength, inBPR, inRowSkip, outData, outLength,
1392 outOffset, outBPR, width, reader, Writer(outData));
1393 break;
1394 }
1395 // unsupported
1396 case B_NO_COLOR_SPACE:
1397 case B_YUV9: case B_YUV12:
1398 case B_UVL32: case B_UVLA32:
1399 case B_LAB32: case B_LABA32:
1400 case B_HSI32: case B_HSIA32:
1401 case B_HSV32: case B_HSVA32:
1402 case B_HLS32: case B_HLSA32:
1403 case B_CMY32: case B_CMYA32: case B_CMYK32:
1404 case B_UVL24: case B_LAB24: case B_HSI24:
1405 case B_HSV24: case B_HLS24: case B_CMY24:
1406 case B_YCbCr422: case B_YUV422:
1407 case B_YCbCr411: case B_YUV411:
1408 case B_YCbCr444: case B_YUV444:
1409 case B_YCbCr420: case B_YUV420:
1410 default:
1411 error = B_BAD_VALUE;
1412 break;
1413 }
1414 return error;
1415 }
1416
1417
1418 // #pragma mark - Bitmap
1419
1420
1421 /*! \brief Creates and initializes a BBitmap.
1422 \param bounds The bitmap dimensions.
1423 \param flags Creation flags.
1424 \param colorSpace The bitmap's color space.
1425 \param bytesPerRow The number of bytes per row the bitmap should use.
1426 \c B_ANY_BYTES_PER_ROW to let the constructor choose an appropriate
1427 value.
1428 \param screenID ???
1429 */
1430 BBitmap::BBitmap(BRect bounds, uint32 flags, color_space colorSpace,
1431 int32 bytesPerRow, screen_id screenID)
1432 : fBasePtr(NULL),
1433 fSize(0),
1434 fColorSpace(B_NO_COLOR_SPACE),
1435 fBounds(0, 0, -1, -1),
1436 fBytesPerRow(0),
1437 fServerToken(-1),
1438 fToken(-1),
1439 fArea(-1),
1440 fOrigArea(-1),
1441 fFlags(0),
1442 fInitError(B_NO_INIT)
1443 {
1444 InitObject(bounds, colorSpace, flags, bytesPerRow, screenID);
1445 }
1446
1447
1448 /*! \brief Creates and initializes a BBitmap.
1449 \param bounds The bitmap dimensions.
1450 \param colorSpace The bitmap's color space.
1451 \param acceptsViews \c true, if the bitmap shall accept BViews, i.e. if
1452 it shall be possible to attach BView to the bitmap and draw into
1453 it.
1454 \param needsContiguous If \c true a physically contiguous chunk of memory
1455 will be allocated.
1456 */
1457 BBitmap::BBitmap(BRect bounds, color_space colorSpace, bool acceptsViews,
1458 bool needsContiguous)
1459 : fBasePtr(NULL),
1460 fSize(0),
1461 fColorSpace(B_NO_COLOR_SPACE),
1462 fBounds(0, 0, -1, -1),
1463 fBytesPerRow(0),
1464 fServerToken(-1),
1465 fToken(-1),
1466 fArea(-1),
1467 fOrigArea(-1),
1468 fFlags(0),
1469 fInitError(B_NO_INIT)
1470 {
1471 int32 flags = (acceptsViews ? B_BITMAP_ACCEPTS_VIEWS : 0)
1472 | (needsContiguous ? B_BITMAP_IS_CONTIGUOUS : 0);
1473 InitObject(bounds, colorSpace, flags, B_ANY_BYTES_PER_ROW,
1474 B_MAIN_SCREEN_ID);
1475
1476 }
1477
1478
1479 /*! \brief Creates a BBitmap as a clone of another bitmap.
1480 \param source The source bitmap.
1481 \param acceptsViews \c true, if the bitmap shall accept BViews, i.e. if
1482 it shall be possible to attach BView to the bitmap and draw into
1483 it.
1484 \param needsContiguous If \c true a physically contiguous chunk of memory
1485 will be allocated.
1486 */
1487 BBitmap::BBitmap(const BBitmap *source, bool acceptsViews,
1488 bool needsContiguous)
1489 : fBasePtr(NULL),
1490 fSize(0),
1491 fColorSpace(B_NO_COLOR_SPACE),
1492 fBounds(0, 0, -1, -1),
1493 fBytesPerRow(0),
1494 fServerToken(-1),
1495 fToken(-1),
1496 fArea(-1),
1497 fOrigArea(-1),
1498 fFlags(0),
1499 fInitError(B_NO_INIT)
1500 {
1501 if (source && source->IsValid()) {
1502 int32 flags = (acceptsViews ? B_BITMAP_ACCEPTS_VIEWS : 0)
1503 | (needsContiguous ? B_BITMAP_IS_CONTIGUOUS : 0);
1504 InitObject(source->Bounds(), source->ColorSpace(), flags,
1505 source->BytesPerRow(), B_MAIN_SCREEN_ID);
1506 if (InitCheck() == B_OK)
1507 memcpy(Bits(), source->Bits(), BytesPerRow());
1508 }
1509 }
1510
1511
1512 /*! \brief Frees all resources associated with this object. */
1513 BBitmap::~BBitmap()
1514 {
1515 CleanUp();
1516 }
1517
1518
1519 /*! \brief Unarchives a bitmap from a BMessage.
1520 \param data The archive.
1521 */
1522 BBitmap::BBitmap(BMessage *data)
1523 : BArchivable(data),
1524 fBasePtr(NULL),
1525 fSize(0),
1526 fColorSpace(B_NO_COLOR_SPACE),
1527 fBounds(0, 0, -1, -1),
1528 fBytesPerRow(0),
1529 fServerToken(-1),
1530 fToken(-1),
1531 fArea(-1),
1532 fOrigArea(-1),
1533 fFlags(0),
1534 fInitError(B_NO_INIT)
1535 {
1536 BRect bounds;
1537 data->FindRect("_frame", &bounds);
1538
1539 color_space cspace;
1540 data->FindInt32("_cspace", (int32 *)&cspace);
1541
1542 int32 flags = 0;
1543 data->FindInt32("_bmflags", &flags);
1544
1545 int32 rowbytes = 0;
1546 data->FindInt32("_rowbytes", &rowbytes);
1547
1548 flags |= B_BITMAP_NO_SERVER_LINK;
1549 flags &= ~B_BITMAP_ACCEPTS_VIEWS;
1550 InitObject(bounds, cspace, flags, rowbytes, B_MAIN_SCREEN_ID);
1551
1552 if (data->HasData("_data", B_RAW_TYPE) && InitCheck() == B_OK) {
1553 ssize_t size = 0;
1554 const void *buffer;
1555 if (data->FindData("_data", B_RAW_TYPE, &buffer, &size) == B_OK)
1556 memcpy(fBasePtr, buffer, size);
1557 }
1558
1559 if (fFlags & B_BITMAP_ACCEPTS_VIEWS) {
1560 // BArchivable *obj;
1561 // BMessage message;
1562 // int i = 0;
1563 //
1564 // while (data->FindMessage("_view", i++, &message) == B_OK) {
1565 // obj = instantiate_object(&message);
1566 // BView *view = dynamic_cast<BView *>(obj);
1567 //
1568 // if (view)
1569 // AddChild(view);
1570 // }
1571 }
1572 }
1573
1574
1575 /*! \brief Instantiates a BBitmap from an archive.
1576 \param data The archive.
1577 \return A bitmap reconstructed from the archive or \c NULL, if an error
1578 occured.
1579 */
1580 BArchivable *
1581 BBitmap::Instantiate(BMessage *data)
1582 {
1583 if (validate_instantiation(data, "BBitmap"))
1584 return new BBitmap(data);
1585
1586 return NULL;
1587 }
1588
1589
1590 /*! \brief Archives the BBitmap object.
1591 \param data The archive.
1592 \param deep \c true, if child object shall be archived as well, \c false
1593 otherwise.
1594 \return \c B_OK, if everything went fine, an error code otherwise.
1595 */
1596 status_t
1597 BBitmap::Archive(BMessage *data, bool deep) const
1598 {
1599 BArchivable::Archive(data, deep);
1600
1601 data->AddRect("_frame", fBounds);
1602 data->AddInt32("_cspace", (int32)fColorSpace);
1603 data->AddInt32("_bmflags", fFlags);
1604 data->AddInt32("_rowbytes", fBytesPerRow);
1605
1606 if (deep) {
1607 if (fFlags & B_BITMAP_ACCEPTS_VIEWS) {
1608 // BMessage views;
1609 // for (int32 i = 0; i < CountChildren(); i++) {
1610 // if (ChildAt(i)->Archive(&views, deep))
1611 // data->AddMessage("_views", &views);
1612 // }
1613 }
1614 // Note: R5 does not archive the data if B_BITMAP_IS_CONTIGNUOUS is
1615 // true and it does save all formats as B_RAW_TYPE and it does save
1616 // the data even if B_BITMAP_ACCEPTS_VIEWS is set (as opposed to
1617 // the BeBook)
1618
1619 data->AddData("_data", B_RAW_TYPE, fBasePtr, fSize);
1620 }
1621
1622 return B_OK;
1623 }
1624
1625
1626 /*! \brief Returns the result from the construction.
1627 \return \c B_OK, if the object is properly initialized, an error code
1628 otherwise.
1629 */
1630 status_t
1631 BBitmap::InitCheck() const
1632 {
1633 return fInitError;
1634 }
1635
1636
1637 /*! \brief Returns whether or not the BBitmap object is valid.
1638 \return \c true, if the object is properly initialized, \c false otherwise.
1639 */
1640 bool
1641 BBitmap::IsValid() const
1642 {
1643 return (InitCheck() == B_OK);
1644 }
1645
1646
1647 status_t
1648 BBitmap::LockBits(uint32 *state)
1649 {
1650 return B_ERROR;
1651 }
1652
1653
1654 void
1655 BBitmap::UnlockBits()
1656 {
1657 }
1658
1659
1660 /*! \brief Returns the ID of the area the bitmap data reside in.
1661 \return The ID of the area the bitmap data reside in.
1662 */
1663 area_id
1664 BBitmap::Area() const
1665 {
1666 return fArea;
1667 }
1668
1669
1670 /*! \brief Returns the pointer to the bitmap data.
1671 \return The pointer to the bitmap data.
1672 */
1673 void *
1674 BBitmap::Bits() const
1675 {
1676 return fBasePtr;
1677 }
1678
1679
1680 /*! \brief Returns the size of the bitmap data.
1681 \return The size of the bitmap data.
1682 */
1683 int32
1684 BBitmap::BitsLength() const
1685 {
1686 return fSize;
1687 }
1688
1689
1690 /*! \brief Returns the number of bytes used to store a row of bitmap data.
1691 \return The number of bytes used to store a row of bitmap data.
1692 */
1693 int32
1694 BBitmap::BytesPerRow() const
1695 {
1696 return fBytesPerRow;
1697 }
1698
1699
1700 /*! \brief Returns the bitmap's color space.
1701 \return The bitmap's color space.
1702 */
1703 color_space
1704 BBitmap::ColorSpace() const
1705 {
1706 return fColorSpace;
1707 }
1708
1709
1710 /*! \brief Returns the bitmap's dimensions.
1711 \return The bitmap's dimensions.
1712 */
1713 BRect
1714 BBitmap::Bounds() const
1715 {
1716 return fBounds;
1717 }
1718
1719
1720 /*! \brief Assigns data to the bitmap.
1721
1722 Data are directly written into the bitmap's data buffer, being converted
1723 beforehand, if necessary. Some conversions work rather unintuitively:
1724 - \c B_RGB32: The source buffer is supposed to contain \c B_RGB24_BIG
1725 data without padding at the end of the rows.
1726 - \c B_RGB32: The source buffer is supposed to contain \c B_CMAP8
1727 data without padding at the end of the rows.
1728 - other color spaces: The source buffer is supposed to contain data
1729 according to the specified color space being rowwise padded to int32.
1730
1731 The currently supported source/target color spaces are
1732 \c B_RGB{32,24,16,15}[_BIG], \c B_CMAP8 and \c B_GRAY{8,1}.
1733
1734 \note As this methods is apparently a bit strange to use, OBOS introduces
1735 ImportBits() methods, which are recommended to be used instead.
1736
1737 \param data The data to be copied.
1738 \param length The length in bytes of the data to be copied.
1739 \param offset The offset (in bytes) relative to beginning of the bitmap
1740 data specifying the position at which the source data shall be
1741 written.
1742 \param colorSpace Color space of the source data.
1743 */
1744 void
1745 BBitmap::SetBits(const void *data, int32 length, int32 offset,
1746 color_space colorSpace)
1747 {
1748 status_t error = (InitCheck() == B_OK ? B_OK : B_NO_INIT);
1749 // check params
1750 if (error == B_OK && (data == NULL || offset > fSize || length < 0))
1751 error = B_BAD_VALUE;
1752 int32 width = 0;
1753 if (error == B_OK)
1754 width = fBounds.IntegerWidth() + 1;
1755 int32 inBPR = -1;
1756 // tweaks to mimic R5 behavior
1757 if (error == B_OK) {
1758 // B_RGB32 means actually unpadded B_RGB24_BIG
1759 if (colorSpace == B_RGB32) {
1760 colorSpace = B_RGB24_BIG;
1761 inBPR = width * 3;
1762 // If in color space is B_CMAP8, but the bitmap's is another one,
1763 // ignore source data row padding.
1764 } else if (colorSpace == B_CMAP8 && fColorSpace != B_CMAP8)
1765 inBPR = width;
1766
1767 // call the sane method, which does the actual work
1768 error = ImportBits(data, length, inBPR, offset, colorSpace);
1769 }
1770 }
1771
1772
1773 /*! \brief Assigns data to the bitmap.
1774
1775 Data are directly written into the bitmap's data buffer, being converted
1776 beforehand, if necessary. Unlike for SetBits(), the meaning of
1777 \a colorSpace is exactly the expected one here, i.e. the source buffer
1778 is supposed to contain data of that color space. \a bpr specifies how
1779 many bytes the source contains per row. \c B_ANY_BYTES_PER_ROW can be
1780 supplied, if standard padding to int32 is used.
1781
1782 The currently supported source/target color spaces are
1783 \c B_RGB{32,24,16,15}[_BIG], \c B_CMAP8 and \c B_GRAY{8,1}.
1784
1785 \param data The data to be copied.
1786 \param length The length in bytes of the data to be copied.
1787 \param bpr The number of bytes per row in the source data.
1788 \param offset The offset (in bytes) relative to beginning of the bitmap
1789 data specifying the position at which the source data shall be
1790 written.
1791 \param colorSpace Color space of the source data.
1792 \return
1793 - \c B_OK: Everything went fine.
1794 - \c B_BAD_VALUE: \c NULL \a data, invalid \a bpr or \a offset, or
1795 unsupported \a colorSpace.
1796 */
1797 status_t
1798 BBitmap::ImportBits(const void *data, int32 length, int32 bpr, int32 offset,
1799 color_space colorSpace)
1800 {
1801 status_t error = (InitCheck() == B_OK ? B_OK : B_NO_INIT);
1802 // check params
1803 if (error == B_OK && (data == NULL || offset > fSize || length < 0))
1804 error = B_BAD_VALUE;
1805 // get BPR
1806 int32 width = 0;
1807 int32 inRowSkip = 0;
1808 if (error == B_OK) {
1809 width = fBounds.IntegerWidth() + 1;
1810 if (bpr < 0)
1811 bpr = get_bytes_per_row(colorSpace, width);
1812 inRowSkip = bpr - get_raw_bytes_per_row(colorSpace, width);
1813 if (inRowSkip < 0)
1814 error = B_BAD_VALUE;
1815 }
1816 if (error != B_OK) {
1817 // catch error case
1818 } else if (colorSpace == fColorSpace && bpr == fBytesPerRow) {
1819 length = min(length, fSize - offset);
1820 memcpy((char*)fBasePtr + offset, data, length);
1821 } else {
1822 // TODO: Retrieve color map from BScreen, when available:
1823 // PaletteConverter paletteConverter(BScreen().ColorMap());
1824 const PaletteConverter &paletteConverter = *palette_converter();
1825 int32 rawOutBPR = get_raw_bytes_per_row(fColorSpace, width);
1826 switch (colorSpace) {
1827 // supported
1828 case B_RGB32: case B_RGBA32:
1829 {
1830 typedef RGB24Reader<rgb32_pixel> Reader;
1831 error = set_bits<Reader>(data, length, bpr, inRowSkip,
1832 fBasePtr, fSize, offset, fBytesPerRow, rawOutBPR,
1833 fColorSpace, width, Reader(data), paletteConverter);
1834 break;
1835 }
1836 case B_RGB32_BIG: case B_RGBA32_BIG:
1837 {
1838 typedef RGB24Reader<rgb32_big_pixel> Reader;
1839 error = set_bits<Reader>(data, length, bpr, inRowSkip,
1840 fBasePtr, fSize, offset, fBytesPerRow, rawOutBPR,
1841 fColorSpace, width, Reader(data), paletteConverter);
1842 break;
1843 }
1844 case B_RGB24:
1845 {
1846 typedef RGB24Reader<rgb24_pixel> Reader;
1847 error = set_bits<Reader>(data, length, bpr, inRowSkip,
1848 fBasePtr, fSize, offset, fBytesPerRow, rawOutBPR,
1849 fColorSpace, width, Reader(data), paletteConverter);
1850 break;
1851 }
1852 case B_RGB24_BIG:
1853 {
1854 typedef RGB24Reader<rgb24_big_pixel> Reader;
1855 error = set_bits<Reader>(data, length, bpr, inRowSkip,
1856 fBasePtr, fSize, offset, fBytesPerRow, rawOutBPR,
1857 fColorSpace, width, Reader(data), paletteConverter);
1858 break;
1859 }
1860 case B_RGB16:
1861 {
1862 typedef RGB16Reader<rgb16_pixel> Reader;
1863 error = set_bits<Reader>(data, length, bpr, inRowSkip,
1864 fBasePtr, fSize, offset, fBytesPerRow, rawOutBPR,
1865 fColorSpace, width, Reader(data), paletteConverter);
1866 break;
1867 }
1868 case B_RGB16_BIG:
1869 {
1870 typedef RGB16Reader<rgb16_big_pixel> Reader;
1871 error = set_bits<Reader>(data, length, bpr, inRowSkip,
1872 fBasePtr, fSize, offset, fBytesPerRow, rawOutBPR,
1873 fColorSpace, width, Reader(data), paletteConverter);
1874 break;
1875 }
1876 case B_RGB15: case B_RGBA15:
1877 {
1878 typedef RGB15Reader<rgb16_pixel> Reader;
1879 error = set_bits<Reader>(data, length, bpr, inRowSkip,
1880 fBasePtr, fSize, offset, fBytesPerRow, rawOutBPR,
1881 fColorSpace, width, Reader(data), paletteConverter);
1882 break;
1883 }
1884 case B_RGB15_BIG: case B_RGBA15_BIG:
1885 {
1886 typedef RGB15Reader<rgb16_big_pixel> Reader;
1887 error = set_bits<Reader>(data, length, bpr, inRowSkip,
1888 fBasePtr, fSize, offset, fBytesPerRow, rawOutBPR,
1889 fColorSpace, width, Reader(data), paletteConverter);
1890 break;
1891 }
1892 case B_CMAP8:
1893 {
1894 typedef CMAP8Reader Reader;
1895 error = set_bits<Reader>(data, length, bpr, inRowSkip,
1896 fBasePtr, fSize, offset, fBytesPerRow, rawOutBPR,
1897 fColorSpace, width, Reader(data, paletteConverter),
1898 paletteConverter);
1899 break;
1900 }
1901 case B_GRAY8:
1902 {
1903 typedef Gray8Reader Reader;
1904 error = set_bits<Reader>(data, length, bpr, inRowSkip,
1905 fBasePtr, fSize, offset, fBytesPerRow, rawOutBPR,
1906 fColorSpace, width, Reader(data), paletteConverter);
1907 break;
1908 }
1909 case B_GRAY1:
1910 {
1911 typedef Gray1Reader Reader;
1912 error = set_bits<Reader>(data, length, bpr, inRowSkip,
1913 fBasePtr, fSize, offset, fBytesPerRow, rawOutBPR,
1914 fColorSpace, width, Reader(data), paletteConverter);
1915 break;
1916 }
1917 // unsupported
1918 case B_NO_COLOR_SPACE:
1919 case B_YUV9: case B_YUV12:
1920 case B_UVL32: case B_UVLA32:
1921 case B_LAB32: case B_LABA32:
1922 case B_HSI32: case B_HSIA32:
1923 case B_HSV32: case B_HSVA32:
1924 case B_HLS32: case B_HLSA32:
1925 case B_CMY32: case B_CMYA32: case B_CMYK32:
1926 case B_UVL24: case B_LAB24: case B_HSI24:
1927 case B_HSV24: case B_HLS24: case B_CMY24:
1928 case B_YCbCr422: case B_YUV422:
1929 case B_YCbCr411: case B_YUV411:
1930 case B_YCbCr444: case B_YUV444:
1931 case B_YCbCr420: case B_YUV420:
1932 default:
1933 error = B_BAD_VALUE;
1934 break;
1935 }
1936 }
1937 return error;
1938 }
1939
1940
1941 /*! \briefly Assigns another bitmap's data to this bitmap.
1942
1943 The supplied bitmap must have the exactly same dimensions as this bitmap.
1944 Its data are converted to the color space of this bitmap.
1945
1946 The currently supported source/target color spaces are
1947 \c B_RGB{32,24,16,15}[_BIG], \c B_CMAP8 and \c B_GRAY{8,1}.
1948
1949 \param bitmap The source bitmap.
1950 \return
1951 - \c B_OK: Everything went fine.
1952 - \c B_BAD_VALUE: \c NULL \a bitmap, or \a bitmap has other dimensions,
1953 or the conversion from or to one of the color spaces is not supported.
1954 */
1955 status_t
1956 BBitmap::ImportBits(const BBitmap *bitmap)
1957 {
1958 status_t error = (InitCheck() == B_OK ? B_OK : B_NO_INIT);
1959 // check param
1960 if (error == B_OK && bitmap == NULL)
1961 error = B_BAD_VALUE;
1962 if (error == B_OK && bitmap->InitCheck() != B_OK)
1963 error = B_BAD_VALUE;
1964 if (error == B_OK && bitmap->Bounds() != fBounds)
1965 error = B_BAD_VALUE;
1966 // set bits
1967 if (error == B_OK) {
1968 error = ImportBits(bitmap->Bits(), bitmap->BitsLength(),
1969 bitmap->BytesPerRow(), 0, bitmap->ColorSpace());
1970 }
1971 return error;
1972 }
1973
1974
1975 status_t
1976 BBitmap::GetOverlayRestrictions(overlay_restrictions *restrictions) const
1977 {
1978 // TODO: Implement
1979 return B_ERROR;
1980 }
1981
1982
1983 status_t
1984 BBitmap::Perform(perform_code d, void *arg)
1985 {
1986 return BArchivable::Perform(d, arg);
1987 }
1988
1989
1990 // FBC
1991 void BBitmap::_ReservedBitmap1() {}
1992 void BBitmap::_ReservedBitmap2() {}
1993 void BBitmap::_ReservedBitmap3() {}
1994
1995
1996 /*! \brief Privatized copy constructor to prevent usage.
1997 */
1998 BBitmap::BBitmap(const BBitmap &)
1999 {
2000 }
2001
2002
2003 /*! \brief Privatized assignment operator to prevent usage.
2004 */
2005 BBitmap &
2006 BBitmap::operator=(const BBitmap &)
2007 {
2008 return *this;
2009 }
2010
2011
2012 char *
2013 BBitmap::get_shared_pointer() const
2014 {
2015 return NULL; // not implemented
2016 }
2017
2018
2019 int32
2020 BBitmap::get_server_token() const
2021 {
2022 return fServerToken;
2023 }
2024
2025
2026 /*! \brief Initializes the bitmap.
2027 \param bounds The bitmap dimensions.
2028 \param colorSpace The bitmap's color space.
2029 \param flags Creation flags.
2030 \param bytesPerRow The number of bytes per row the bitmap should use.
2031 \c B_ANY_BYTES_PER_ROW to let the constructor choose an appropriate
2032 value.
2033 \param screenID ???
2034 */
2035 void
2036 BBitmap::InitObject(BRect bounds, color_space colorSpace, uint32 flags,
2037 int32 bytesPerRow, screen_id screenID)
2038 {
2039 //printf("BBitmap::InitObject(bounds: BRect(%.1f, %.1f, %.1f, %.1f), format: %ld, flags: %ld, bpr: %ld\n",
2040 // bounds.left, bounds.top, bounds.right, bounds.bottom, colorSpace, flags, bytesPerRow);
2041
2042 // TODO: Hanlde setting up the offscreen window if we're such a bitmap!
2043
2044 // TODO: Should we handle rounding of the "bounds" here? How does R5 behave?
2045
2046 status_t error = B_OK;
2047
2048 //#ifdef RUN_WITHOUT_APP_SERVER
2049 flags |= B_BITMAP_NO_SERVER_LINK;
2050 //#endif // RUN_WITHOUT_APP_SERVER
2051 flags &= ~B_BITMAP_ACCEPTS_VIEWS;
2052
2053 CleanUp();
2054
2055 // check params
2056 if (!bounds.IsValid() || !bitmaps_support_space(colorSpace, NULL))
2057 error = B_BAD_VALUE;
2058 if (error == B_OK) {
2059 int32 bpr = get_bytes_per_row(colorSpace, bounds.IntegerWidth() + 1);
2060 if (bytesPerRow < 0)
2061 bytesPerRow = bpr;
2062 else if (bytesPerRow < bpr)
2063 // NOTE: How does R5 behave?
2064 error = B_BAD_VALUE;
2065 }
2066 // allocate the bitmap buffer
2067 if (error == B_OK) {
2068 // NOTE: Maybe the code would look more robust if the
2069 // "size" was not calculated here when we ask the server
2070 // to allocate the bitmap. -Stephan
2071 int32 size = bytesPerRow * (bounds.IntegerHeight() + 1);
2072
2073 if (flags & B_BITMAP_NO_SERVER_LINK) {
2074 fBasePtr = malloc(size);
2075 if (fBasePtr) {
2076 fSize = size;
2077 fColorSpace = colorSpace;
2078 fBounds = bounds;
2079 fBytesPerRow = bytesPerRow;
2080 fFlags = flags;
2081 } else
2082 error = B_NO_MEMORY;
2083 } else {
2084 // // Ask the server (via our owning application) to create a bitmap.
2085 // BPrivate::AppServerLink link;
2086 //
2087 // // Attach Data:
2088 // // 1) BRect bounds
2089 // // 2) color_space space
2090 // // 3) int32 bitmap_flags
2091 // // 4) int32 bytes_per_row
2092 // // 5) int32 screen_id::id
2093 // link.StartMessage(AS_CREATE_BITMAP);
2094 // link.Attach<BRect>(bounds);
2095 // link.Attach<color_space>(colorSpace);
2096 // link.Attach<int32>((int32)flags);
2097 // link.Attach<int32>(bytesPerRow);
2098 // link.Attach<int32>(screenID.id);
2099 //
2100 // // Reply Code: SERVER_TRUE
2101 // // Reply Data:
2102 // // 1) int32 server token
2103 // // 2) area_id id of the area in which the bitmap data resides
2104 // // 3) int32 area pointer offset used to calculate fBasePtr
2105 //
2106 // // alternatively, if something went wrong
2107 // // Reply Code: SERVER_FALSE
2108 // // Reply Data:
2109 // // None
2110 // int32 code = SERVER_FALSE;
2111 // error = link.FlushWithReply(code);
2112 //
2113 // if (error >= B_OK) {
2114 // // *communication* with server successful
2115 // if (code == SERVER_TRUE) {
2116 // // server side success
2117 // // Get token
2118 // area_id bmparea;
2119 // int32 areaoffset;
2120 //
2121 // link.Read<int32>(&fServerToken);
2122 // link.Read<area_id>(&bmparea);
2123 // link.Read<int32>(&areaoffset);
2124 //
2125 // // Get the area in which the data resides
2126 // fArea = clone_area("shared bitmap area",
2127 // (void**)&fBasePtr,
2128 // B_ANY_ADDRESS,
2129 // B_READ_AREA | B_WRITE_AREA,
2130 // bmparea);
2131 //
2132 // // Jump to the location in the area
2133 // fBasePtr = (int8*)fBasePtr + areaoffset;
2134 //
2135 // fSize = size;
2136 // fColorSpace = colorSpace;
2137 // fBounds = bounds;
2138 // fBytesPerRow = bytesPerRow;
2139 // fFlags = flags;
2140 // } else {
2141 // // server side error, we assume:
2142 // error = B_NO_MEMORY;
2143 // }
2144 // }
2145 // // NOTE: not "else" to handle B_NO_MEMORY on server side!
2146 // if (error < B_OK) {
2147 // fBasePtr = NULL;
2148 // fServerToken = -1;
2149 // fArea = -1;
2150 // // NOTE: why not "0" in case of error?
2151 // fFlags = flags;
2152 // }
2153 }
2154 // fWindow = NULL;
2155 fToken = -1;
2156 fOrigArea = -1;
2157 }
2158
2159 fInitError = error;
2160 // TODO: on success, handle clearing to white if the flags say so. Needs to be
2161 // dependent on color space.
2162
2163 if (fInitError == B_OK) {
2164 if (flags & B_BITMAP_ACCEPTS_VIEWS) {
2165 // fWindow = new BWindow(Bounds(), fServerToken);
2166 // // A BWindow starts life locked and is unlocked
2167 // // in Show(), but this window is never shown and
2168 // // it's message loop is never started.
2169 // fWindow->Unlock();
2170 }
2171 }
2172 }
2173
2174
2175 /*! \brief Cleans up any memory allocated by the bitmap or
2176 informs the server to do so.
2177 */
2178 void
2179 BBitmap::CleanUp()
2180 {
2181 if (fBasePtr) {
2182 if (fFlags & B_BITMAP_NO_SERVER_LINK) {
2183 free(fBasePtr);
2184 } else {
2185 // BPrivate::AppServerLink link;
2186 // // AS_DELETE_BITMAP:
2187 // // Attached Data:
2188 // // 1) int32 server token
2189 //
2190 // // Reply Code: SERVER_TRUE if successful,
2191 // // SERVER_FALSE if the buffer was already deleted
2192 // // Reply Data: none
2193 // // status_t freestat;
2194 // int32 code = SERVER_FALSE;
2195 // link.StartMessage(AS_DELETE_BITMAP);
2196 // link.Attach<int32>(fServerToken);
2197 // link.FlushWithReply(code);
2198 // if (code == SERVER_FALSE) {
2199 // // TODO: Find out if "SERVER_FALSE if the buffer
2200 // // was already deleted" is true. If not, maybe we
2201 // // need to take additional action.
2202 // }
2203 // fArea = -1;
2204 // fServerToken = -1;
2205 }
2206 fBasePtr = NULL;
2207 }
2208 }
2209
2210
2211 void
2212 BBitmap::AssertPtr()
2213 {
2214 }
2215
Clone of Haiku svn repository