Diffstat (limited to 'noncore/apps/opie-reader/Palm2QImage.cpp') (more/less context) (ignore whitespace changes)
-rw-r--r-- | noncore/apps/opie-reader/Palm2QImage.cpp | 134 |
1 files changed, 57 insertions, 77 deletions
diff --git a/noncore/apps/opie-reader/Palm2QImage.cpp b/noncore/apps/opie-reader/Palm2QImage.cpp index b0d4e00..c1b7b7a 100644 --- a/noncore/apps/opie-reader/Palm2QImage.cpp +++ b/noncore/apps/opie-reader/Palm2QImage.cpp | |||
@@ -1,31 +1,25 @@ | |||
1 | /* -*- mode: c; indent-tabs-mode: nil; -*- */ | 1 | /* -*- mode: c; indent-tabs-mode: nil; -*- */ |
2 | 2 | #include "useqpe.h" | |
3 | /* OPIE */ | ||
4 | #include <opie2/odebug.h> | ||
5 | |||
6 | /* QT */ | ||
7 | #include <qimage.h> | ||
8 | |||
9 | /* STD */ | ||
10 | #include <stdio.h> | 3 | #include <stdio.h> |
11 | #include <stdlib.h> | 4 | #include <stdlib.h> |
12 | #include <string.h> | 5 | #include <string.h> |
13 | #ifndef _WINDOWS | 6 | #ifndef _WINDOWS |
14 | #include <unistd.h> /* for link */ | 7 | #include <unistd.h> /* for link */ |
15 | #endif | 8 | #endif |
16 | #include <sys/types.h> | 9 | #include <sys/types.h> |
17 | #include <sys/stat.h> | 10 | #include <sys/stat.h> |
18 | #include <stdarg.h> | 11 | #include <stdarg.h> |
19 | 12 | ||
13 | #include <qimage.h> | ||
20 | 14 | ||
21 | /***********************************************************************/ | 15 | /***********************************************************************/ |
22 | /***********************************************************************/ | 16 | /***********************************************************************/ |
23 | /***** *****/ | 17 | /***** *****/ |
24 | /***** Code to decode the Palm image format to JPEG *****/ | 18 | /***** Code to decode the Palm image format to JPEG *****/ |
25 | /***** *****/ | 19 | /***** *****/ |
26 | /***********************************************************************/ | 20 | /***********************************************************************/ |
27 | /***********************************************************************/ | 21 | /***********************************************************************/ |
28 | 22 | ||
29 | #define READ_BIGENDIAN_SHORT(p) (((p)[0] << 8)|((p)[1])) | 23 | #define READ_BIGENDIAN_SHORT(p) (((p)[0] << 8)|((p)[1])) |
30 | #define READ_BIGENDIAN_LONG(p) (((p)[0] << 24)|((p)[1] << 16)|((p)[2] << 8)|((p)[3])) | 24 | #define READ_BIGENDIAN_LONG(p) (((p)[0] << 24)|((p)[1] << 16)|((p)[2] << 8)|((p)[3])) |
31 | 25 | ||
@@ -40,28 +34,28 @@ | |||
40 | #define PALM_COMPRESSION_PACKBITS 0x02 | 34 | #define PALM_COMPRESSION_PACKBITS 0x02 |
41 | #define PALM_COMPRESSION_NONE 0xFF | 35 | #define PALM_COMPRESSION_NONE 0xFF |
42 | 36 | ||
43 | #define PALM_COLORMAP_SIZE 232 | 37 | #define PALM_COLORMAP_SIZE 232 |
44 | 38 | ||
45 | typedef struct { | 39 | typedef struct { |
46 | unsigned char red; | 40 | unsigned char red; |
47 | unsigned char green; | 41 | unsigned char green; |
48 | unsigned char blue; | 42 | unsigned char blue; |
49 | } ColorMapEntry; | 43 | } ColorMapEntry; |
50 | 44 | ||
51 | static ColorMapEntry Palm8BitColormap[] = { | 45 | static ColorMapEntry Palm8BitColormap[] = { |
52 | { 255, 255, 255 }, { 255, 204, 255 }, { 255, 153, 255 }, { 255, 102, 255 }, | 46 | { 255, 255, 255 }, { 255, 204, 255 }, { 255, 153, 255 }, { 255, 102, 255 }, |
53 | { 255, 51, 255 }, { 255, 0, 255 }, { 255, 255, 204 }, { 255, 204, 204 }, | 47 | { 255, 51, 255 }, { 255, 0, 255 }, { 255, 255, 204 }, { 255, 204, 204 }, |
54 | { 255, 153, 204 }, { 255, 102, 204 }, { 255, 51, 204 }, { 255, 0, 204 }, | 48 | { 255, 153, 204 }, { 255, 102, 204 }, { 255, 51, 204 }, { 255, 0, 204 }, |
55 | { 255, 255, 153 }, { 255, 204, 153 }, { 255, 153, 153 }, { 255, 102, 153 }, | 49 | { 255, 255, 153 }, { 255, 204, 153 }, { 255, 153, 153 }, { 255, 102, 153 }, |
56 | { 255, 51, 153 }, { 255, 0, 153 }, { 204, 255, 255 }, { 204, 204, 255 }, | 50 | { 255, 51, 153 }, { 255, 0, 153 }, { 204, 255, 255 }, { 204, 204, 255 }, |
57 | { 204, 153, 255 }, { 204, 102, 255 }, { 204, 51, 255 }, { 204, 0, 255 }, | 51 | { 204, 153, 255 }, { 204, 102, 255 }, { 204, 51, 255 }, { 204, 0, 255 }, |
58 | { 204, 255, 204 }, { 204, 204, 204 }, { 204, 153, 204 }, { 204, 102, 204 }, | 52 | { 204, 255, 204 }, { 204, 204, 204 }, { 204, 153, 204 }, { 204, 102, 204 }, |
59 | { 204, 51, 204 }, { 204, 0, 204 }, { 204, 255, 153 }, { 204, 204, 153 }, | 53 | { 204, 51, 204 }, { 204, 0, 204 }, { 204, 255, 153 }, { 204, 204, 153 }, |
60 | { 204, 153, 153 }, { 204, 102, 153 }, { 204, 51, 153 }, { 204, 0, 153 }, | 54 | { 204, 153, 153 }, { 204, 102, 153 }, { 204, 51, 153 }, { 204, 0, 153 }, |
61 | { 153, 255, 255 }, { 153, 204, 255 }, { 153, 153, 255 }, { 153, 102, 255 }, | 55 | { 153, 255, 255 }, { 153, 204, 255 }, { 153, 153, 255 }, { 153, 102, 255 }, |
62 | { 153, 51, 255 }, { 153, 0, 255 }, { 153, 255, 204 }, { 153, 204, 204 }, | 56 | { 153, 51, 255 }, { 153, 0, 255 }, { 153, 255, 204 }, { 153, 204, 204 }, |
63 | { 153, 153, 204 }, { 153, 102, 204 }, { 153, 51, 204 }, { 153, 0, 204 }, | 57 | { 153, 153, 204 }, { 153, 102, 204 }, { 153, 51, 204 }, { 153, 0, 204 }, |
64 | { 153, 255, 153 }, { 153, 204, 153 }, { 153, 153, 153 }, { 153, 102, 153 }, | 58 | { 153, 255, 153 }, { 153, 204, 153 }, { 153, 153, 153 }, { 153, 102, 153 }, |
65 | { 153, 51, 153 }, { 153, 0, 153 }, { 102, 255, 255 }, { 102, 204, 255 }, | 59 | { 153, 51, 153 }, { 153, 0, 153 }, { 102, 255, 255 }, { 102, 204, 255 }, |
66 | { 102, 153, 255 }, { 102, 102, 255 }, { 102, 51, 255 }, { 102, 0, 255 }, | 60 | { 102, 153, 255 }, { 102, 102, 255 }, { 102, 51, 255 }, { 102, 0, 255 }, |
67 | { 102, 255, 204 }, { 102, 204, 204 }, { 102, 153, 204 }, { 102, 102, 204 }, | 61 | { 102, 255, 204 }, { 102, 204, 204 }, { 102, 153, 204 }, { 102, 102, 204 }, |
@@ -137,183 +131,169 @@ QImage* Palm2QImage | |||
137 | 131 | ||
138 | palmimage = image_bytes_in; | 132 | palmimage = image_bytes_in; |
139 | width = READ_BIGENDIAN_SHORT(palmimage + 0); | 133 | width = READ_BIGENDIAN_SHORT(palmimage + 0); |
140 | height = READ_BIGENDIAN_SHORT(palmimage + 2); | 134 | height = READ_BIGENDIAN_SHORT(palmimage + 2); |
141 | bytes_per_row = READ_BIGENDIAN_SHORT(palmimage + 4); | 135 | bytes_per_row = READ_BIGENDIAN_SHORT(palmimage + 4); |
142 | flags = READ_BIGENDIAN_SHORT(palmimage + 6); | 136 | flags = READ_BIGENDIAN_SHORT(palmimage + 6); |
143 | bits_per_pixel = palmimage[8]; | 137 | bits_per_pixel = palmimage[8]; |
144 | version = palmimage[9]; | 138 | version = palmimage[9]; |
145 | next_depth_offset = READ_BIGENDIAN_SHORT(palmimage + 10); | 139 | next_depth_offset = READ_BIGENDIAN_SHORT(palmimage + 10); |
146 | transparent_index = palmimage[12]; | 140 | transparent_index = palmimage[12]; |
147 | compression_type = palmimage[13]; | 141 | compression_type = palmimage[13]; |
148 | /* bytes 14 and 15 are reserved by Palm and always 0 */ | 142 | /* bytes 14 and 15 are reserved by Palm and always 0 */ |
149 | 143 | ||
150 | #if 0 | 144 | #if 0 |
151 | // odebug << "Palm image is " << width << "x" << height | 145 | // qDebug ("Palm image is %dx%d, %d bpp, version %d, flags 0x%x, compression %d", width, height, bits_per_pixel, version, flags, compression_type); |
152 | // << ", " << bits_per_pixel << " bpp, version " << version | ||
153 | // << ", flags 0x" << flags << ", compression " << compression_type << oendl; | ||
154 | #endif | 146 | #endif |
155 | 147 | ||
156 | if (compression_type == PALM_COMPRESSION_PACKBITS) { | 148 | if (compression_type == PALM_COMPRESSION_PACKBITS) { |
157 | // odebug << "Image uses packbits compression; not yet supported" << oendl; | 149 | // qDebug ("Image uses packbits compression; not yet supported"); |
158 | return NULL; | 150 | return NULL; |
159 | } else if ((compression_type != PALM_COMPRESSION_NONE) && | 151 | } else if ((compression_type != PALM_COMPRESSION_NONE) && |
160 | (compression_type != PALM_COMPRESSION_RLE) && | 152 | (compression_type != PALM_COMPRESSION_RLE) && |
161 | (compression_type != PALM_COMPRESSION_SCANLINE)) { | 153 | (compression_type != PALM_COMPRESSION_SCANLINE)) { |
162 | // odebug << "Image uses unknown compression, code 0x" << compression_type << oendl; | 154 | // qDebug ("Image uses unknown compression, code 0x%x", compression_type); |
163 | return NULL; | 155 | return NULL; |
164 | } | 156 | } |
165 | 157 | ||
166 | /* as of PalmOS 4.0, there are 6 different kinds of Palm pixmaps: | 158 | /* as of PalmOS 4.0, there are 6 different kinds of Palm pixmaps: |
167 | 159 | ||
168 | 1, 2, or 4 bit grayscale | 160 | 1, 2, or 4 bit grayscale |
169 | 8-bit StaticColor using the Palm standard colormap | 161 | 8-bit StaticColor using the Palm standard colormap |
170 | 8-bit PseudoColor using a user-specified colormap | 162 | 8-bit PseudoColor using a user-specified colormap |
171 | 16-bit DirectColor using 5 bits for red, 6 for green, and 5 for blue | 163 | 16-bit DirectColor using 5 bits for red, 6 for green, and 5 for blue |
172 | 164 | ||
173 | Each of these can be compressed with one of four compression schemes, | 165 | Each of these can be compressed with one of four compression schemes, |
174 | "RLE", "Scanline", "PackBits", or none. | 166 | "RLE", "Scanline", "PackBits", or none. |
175 | 167 | ||
176 | We begin by constructing the colormap. | 168 | We begin by constructing the colormap. |
177 | */ | 169 | */ |
178 | 170 | ||
179 | if (flags & PALM_HAS_COLORMAP_FLAG) { | 171 | if (flags & PALM_HAS_COLORMAP_FLAG) { |
180 | // odebug << "Palm images with custom colormaps are not currently supported." << oendl; | 172 | // qDebug("Palm images with custom colormaps are not currently supported.\n"); |
181 | return NULL; | 173 | return NULL; |
182 | } else if (bits_per_pixel == 1) { | 174 | } else if (bits_per_pixel == 1) { |
183 | colormap = Palm1BitColormap; | 175 | colormap = Palm1BitColormap; |
184 | imagedatastart = palmimage + 16; | 176 | imagedatastart = palmimage + 16; |
185 | } else if (bits_per_pixel == 2) { | 177 | } else if (bits_per_pixel == 2) { |
186 | colormap = Palm2BitColormap; | 178 | colormap = Palm2BitColormap; |
187 | imagedatastart = palmimage + 16; | 179 | imagedatastart = palmimage + 16; |
188 | } else if (bits_per_pixel == 4) { | 180 | } else if (bits_per_pixel == 4) { |
189 | colormap = Palm4BitColormap; | 181 | colormap = Palm4BitColormap; |
190 | imagedatastart = palmimage + 16; | 182 | imagedatastart = palmimage + 16; |
191 | } else if (bits_per_pixel == 8) { | 183 | } else if (bits_per_pixel == 8) { |
192 | colormap = Palm8BitColormap; | 184 | colormap = Palm8BitColormap; |
193 | imagedatastart = palmimage + 16; | 185 | imagedatastart = palmimage + 16; |
194 | } else if (bits_per_pixel == 16 && (flags & PALM_DIRECT_COLOR_FLAG)) { | 186 | } else if (bits_per_pixel == 16 && (flags & PALM_DIRECT_COLOR_FLAG)) { |
195 | colormap = NULL; | 187 | colormap = NULL; |
196 | palm_red_bits = palmimage[16]; | 188 | palm_red_bits = palmimage[16]; |
197 | palm_green_bits = palmimage[17]; | 189 | palm_green_bits = palmimage[17]; |
198 | palm_blue_bits = palmimage[18]; | 190 | palm_blue_bits = palmimage[18]; |
199 | // odebug << "Bits:" << palm_red_bits << ", " << palm_green_bits << ", " << palm_blue_bits << oendl; | 191 | // qDebug("Bits:%d, %d, %d", palm_red_bits, palm_green_bits, palm_blue_bits); |
200 | if (palm_blue_bits > 8 || palm_green_bits > 8 || palm_red_bits > 8) { | 192 | if (palm_blue_bits > 8 || palm_green_bits > 8 || palm_red_bits > 8) { |
201 | // odebug << "Can't handle this format DirectColor image -- too wide in some color (" | 193 | // qDebug("Can't handle this format DirectColor image -- too wide in some color (%d:%d:%d)\n", palm_red_bits, palm_green_bits, palm_blue_bits); |
202 | // << palm_red_bits << ":" << palm_green_bits << ":" << palm_blue_bits << oendl; | ||
203 | return NULL; | 194 | return NULL; |
204 | } | 195 | } |
205 | if (bits_per_pixel > (8 * sizeof(unsigned long))) { | 196 | if (bits_per_pixel > (8 * sizeof(unsigned long))) { |
206 | // odebug << "Can't handle this format DirectColor image -- too many bits per pixel (" | 197 | // qDebug ("Can't handle this format DirectColor image -- too many bits per pixel (%d)\n", bits_per_pixel); |
207 | // << bits_per_pixel << ")" << oendl; | ||
208 | return NULL; | 198 | return NULL; |
209 | } | 199 | } |
210 | imagedatastart = palmimage + 24; | 200 | imagedatastart = palmimage + 24; |
211 | } else { | 201 | } else { |
212 | // odebug << "Unknown bits-per-pixel of " << bits_per_pixel << " encountered" << oendl; | 202 | // qDebug("Unknown bits-per-pixel of %d encountered.\n", bits_per_pixel); |
213 | return NULL; | 203 | return NULL; |
214 | } | 204 | } |
215 | 205 | ||
216 | #ifndef USEQPE | 206 | #ifndef USEQPE |
217 | QImage* qimage = new QImage(width, height, 32); | 207 | QImage* qimage = new QImage(width, height, 32); |
218 | #else | 208 | #else |
219 | QImage* qimage = new QImage(width, height, 16); | 209 | QImage* qimage = new QImage(width, height, 16); |
220 | #endif | 210 | #endif |
221 | 211 | ||
222 | /* row by row, uncompress the Palm image and copy it to the JPEG buffer */ | 212 | /* row by row, uncompress the Palm image and copy it to the JPEG buffer */ |
223 | rowbuf = new unsigned char[bytes_per_row * width]; | 213 | rowbuf = new unsigned char[bytes_per_row * width]; |
224 | lastrow = new unsigned char[bytes_per_row * width]; | 214 | lastrow = new unsigned char[bytes_per_row * width]; |
225 | 215 | ||
226 | for (i=0, palm_ptr = imagedatastart , x_ptr = imagedata; i < height; ++i) { | 216 | for (i=0, palm_ptr = imagedatastart , x_ptr = imagedata; i < height; ++i) { |
227 | // odebug << "inval:" << inval << " palm_ptr:" << palm_ptr << " x_ptr:" << x_ptr | 217 | // qDebug("inval:%x palm_ptr:%x x_ptr:%x bpr:%x", inval, palm_ptr, x_ptr, bytes_per_row); |
228 | // << " bpr:" << bytes_per_row << oendl; | ||
229 | 218 | ||
230 | /* first, uncompress the Palm image */ | 219 | /* first, uncompress the Palm image */ |
231 | if ((flags & PALM_IS_COMPRESSED_FLAG) && (compression_type == PALM_COMPRESSION_RLE)) { | 220 | if ((flags & PALM_IS_COMPRESSED_FLAG) && (compression_type == PALM_COMPRESSION_RLE)) { |
232 | for (j = 0; j < bytes_per_row; ) { | 221 | for (j = 0; j < bytes_per_row; ) { |
233 | incount = *palm_ptr++; | 222 | incount = *palm_ptr++; |
234 | inval = *palm_ptr++; | 223 | inval = *palm_ptr++; |
235 | memset(rowbuf + j, inval, incount); | 224 | memset(rowbuf + j, inval, incount); |
236 | j += incount; | 225 | j += incount; |
237 | } | 226 | } |
238 | } else if ((flags & PALM_IS_COMPRESSED_FLAG) && (compression_type == PALM_COMPRESSION_SCANLINE)) { | 227 | } else if ((flags & PALM_IS_COMPRESSED_FLAG) && (compression_type == PALM_COMPRESSION_SCANLINE)) { |
239 | for (j = 0; j < bytes_per_row; j += 8) { | 228 | for (j = 0; j < bytes_per_row; j += 8) { |
240 | incount = *palm_ptr++; | 229 | incount = *palm_ptr++; |
241 | inval = ((bytes_per_row - j) < 8) ? (bytes_per_row - j) : 8; | 230 | inval = ((bytes_per_row - j) < 8) ? (bytes_per_row - j) : 8; |
242 | for (inbit = 0; inbit < inval; inbit += 1) { | 231 | for (inbit = 0; inbit < inval; inbit += 1) { |
243 | if (incount & (1 << (7 - inbit))) | 232 | if (incount & (1 << (7 - inbit))) |
244 | rowbuf[j + inbit] = *palm_ptr++; | 233 | rowbuf[j + inbit] = *palm_ptr++; |
245 | else | 234 | else |
246 | rowbuf[j + inbit] = lastrow[j + inbit]; | 235 | rowbuf[j + inbit] = lastrow[j + inbit]; |
247 | } | 236 | } |
248 | } | 237 | } |
249 | memcpy (lastrow, rowbuf, bytes_per_row); | 238 | memcpy (lastrow, rowbuf, bytes_per_row); |
250 | } else if (((flags & PALM_IS_COMPRESSED_FLAG) && | 239 | } else if (((flags & PALM_IS_COMPRESSED_FLAG) && |
251 | (compression_type == PALM_COMPRESSION_NONE)) || | 240 | (compression_type == PALM_COMPRESSION_NONE)) || |
252 | ((flags & PALM_IS_COMPRESSED_FLAG) == 0)) | 241 | ((flags & PALM_IS_COMPRESSED_FLAG) == 0)) |
253 | { | 242 | { |
254 | memcpy (rowbuf, palm_ptr, bytes_per_row); | 243 | memcpy (rowbuf, palm_ptr, bytes_per_row); |
255 | palm_ptr += bytes_per_row; | 244 | palm_ptr += bytes_per_row; |
256 | } | 245 | } |
257 | else { | 246 | else { |
258 | odebug << "Case 4" << oendl; | 247 | qDebug("Case 4"); |
259 | odebug << "Is compressed:" << (((flags & PALM_IS_COMPRESSED_FLAG) == 0) ? "false" : "true") << oendl; | 248 | qDebug("Is compressed:%s", ((flags & PALM_IS_COMPRESSED_FLAG) == 0) ? "false" : "true"); |
260 | odebug << "Has colourmap:" << (((flags & PALM_HAS_COLORMAP_FLAG) == 0) ? "false" : "true") << oendl; | 249 | qDebug("Has colourmap:%s", ((flags & PALM_HAS_COLORMAP_FLAG) == 0) ? "false" : "true"); |
261 | odebug << "Has transparency:" << (((flags & PALM_HAS_TRANSPARENCY_FLAG) == 0) ? "false" : "true") << oendl; | 250 | qDebug("Has transparency:%s", ((flags & PALM_HAS_TRANSPARENCY_FLAG) == 0) ? "false" : "true"); |
262 | odebug << "Direct colour:" << (((flags & PALM_DIRECT_COLOR_FLAG) == 0) ? "false" : "true") << oendl; | 251 | qDebug("Direct colour:%s", ((flags & PALM_DIRECT_COLOR_FLAG) == 0) ? "false" : "true"); |
263 | odebug << "four byte field:" << (((flags & PALM_4_BYTE_FIELD_FLAG) == 0) ? "false" : "true") << oendl; | 252 | qDebug("four byte field:%s", ((flags & PALM_4_BYTE_FIELD_FLAG) == 0) ? "false" : "true"); |
264 | memcpy (rowbuf, palm_ptr, bytes_per_row); | 253 | memcpy (rowbuf, palm_ptr, bytes_per_row); |
265 | palm_ptr += bytes_per_row; | 254 | palm_ptr += bytes_per_row; |
266 | } | 255 | } |
267 | /* next, write it to the GDK bitmap */ | 256 | /* next, write it to the GDK bitmap */ |
268 | if (colormap) { | 257 | if (colormap) { |
269 | mask = (1 << bits_per_pixel) - 1; | 258 | mask = (1 << bits_per_pixel) - 1; |
270 | for (inbit = 8 - bits_per_pixel, inbyte = rowbuf, j = 0; j < width; ++j) { | 259 | for (inbit = 8 - bits_per_pixel, inbyte = rowbuf, j = 0; j < width; ++j) { |
271 | inval = ((*inbyte) & (mask << inbit)) >> inbit; | 260 | inval = ((*inbyte) & (mask << inbit)) >> inbit; |
272 | /* correct for oddity of the 8-bit color Palm pixmap... */ | 261 | /* correct for oddity of the 8-bit color Palm pixmap... */ |
273 | if ((bits_per_pixel == 8) && (inval == 0xFF)) inval = 231; | 262 | if ((bits_per_pixel == 8) && (inval == 0xFF)) inval = 231; |
274 | /* now lookup the correct color and set the pixel in the GTK bitmap */ | 263 | /* now lookup the correct color and set the pixel in the GTK bitmap */ |
275 | QRgb colour = qRgb(colormap[inval].red, colormap[inval].green, colormap[inval].blue); | 264 | QRgb colour = qRgb(colormap[inval].red, colormap[inval].green, colormap[inval].blue); |
276 | qimage->setPixel(j, i, colour); | 265 | qimage->setPixel(j, i, colour); |
277 | if (!inbit) { | 266 | if (!inbit) { |
278 | ++inbyte; | 267 | ++inbyte; |
279 | inbit = 8 - bits_per_pixel; | 268 | inbit = 8 - bits_per_pixel; |
280 | } else { | 269 | } else { |
281 | inbit -= bits_per_pixel; | 270 | inbit -= bits_per_pixel; |
282 | } | 271 | } |
283 | } | 272 | } |
284 | } else if (!colormap && | 273 | } else if (!colormap && |
285 | bits_per_pixel == 16) { | 274 | bits_per_pixel == 16) { |
286 | for (inbyte = rowbuf, j = 0; j < width; ++j) { | 275 | for (inbyte = rowbuf, j = 0; j < width; ++j) { |
287 | inval = ((unsigned short)inbyte[0] << (unsigned short)8) | inbyte[1]; | 276 | inval = ((unsigned short)inbyte[0] << (unsigned short)8) | inbyte[1]; |
288 | 277 | ||
289 | /* | 278 | /* |
290 | odebug << "pixel is " << j << "," << i << " (" | 279 | qDebug ("pixel is %d,%d (%d:%d:%d)", |
291 | << (((inval >> (bits_per_pixel - palm_red_bits)) & ((1 << palm_red_bits) - 1)) << (8-palm_red_bits)) << ":" | 280 | j, i, |
292 | << (((inval >> palm_blue_bits) & ((1 << palm_green_bits) - 1)) << (8-palm_green_bits)) << ":" | 281 | ((inval >> (bits_per_pixel - palm_red_bits)) & ((1 << palm_red_bits) - 1)) << (8-palm_red_bits), |
293 | << (((inval >> 0) & ((1 << palm_blue_bits) - 1)) << (8-palm_blue_bits)) << ")" << oendl; | 282 | ((inval >> palm_blue_bits) & ((1 << palm_green_bits) - 1)) << (8-palm_green_bits), |
283 | ((inval >> 0) & ((1 << palm_blue_bits) - 1)) << (8-palm_blue_bits)); | ||
294 | */ | 284 | */ |
295 | QRgb colour = qRgb( | 285 | QRgb colour = qRgb( |
296 | ((inval >> (bits_per_pixel - palm_red_bits)) & ((1 << palm_red_bits) - 1)) << (8-palm_red_bits), | 286 | ((inval >> (bits_per_pixel - palm_red_bits)) & ((1 << palm_red_bits) - 1)) << (8-palm_red_bits), |
297 | ((inval >> palm_blue_bits) & ((1 << palm_green_bits) - 1)) << (8-palm_green_bits), | 287 | ((inval >> palm_blue_bits) & ((1 << palm_green_bits) - 1)) << (8-palm_green_bits), |
298 | ((inval >> 0) & ((1 << palm_blue_bits) - 1)) << (8-palm_blue_bits)); | 288 | ((inval >> 0) & ((1 << palm_blue_bits) - 1)) << (8-palm_blue_bits)); |
299 | qimage->setPixel(j, i, colour); | 289 | qimage->setPixel(j, i, colour); |
300 | inbyte += 2; | 290 | inbyte += 2; |
301 | } | 291 | } |
302 | } | 292 | } |
303 | } | 293 | } |
304 | 294 | ||
305 | delete [] rowbuf; | 295 | delete [] rowbuf; |
306 | delete [] lastrow; | 296 | delete [] lastrow; |
307 | 297 | ||
308 | return qimage; | 298 | return qimage; |
309 | } | 299 | } |
310 | |||
311 | QImage* hRule(int w, int h, unsigned char r, unsigned char g, unsigned char b) | ||
312 | { | ||
313 | // odebug << "hrule [" << w << ", " << h << "]" << oendl; | ||
314 | QPixmap* qimage = new QPixmap(w, h); | ||
315 | qimage->fill(QColor(r,g,b)); | ||
316 | QImage* ret = new QImage(qimage->convertToImage()); | ||
317 | delete qimage; | ||
318 | return ret; | ||
319 | } | ||