]> Creatis software - clitk.git/blob - utilities/CxImage/ximainfo.cpp
Correct bug to compute 2NotIn1
[clitk.git] / utilities / CxImage / ximainfo.cpp
1 // ximainfo.cpp : main attributes\r
2 /* 03/10/2004 v1.00 - Davide Pizzolato - www.xdp.it\r
3  * CxImage version 6.0.0 02/Feb/2008\r
4  */\r
5 \r
6 #include "ximage.h"\r
7 \r
8 ////////////////////////////////////////////////////////////////////////////////\r
9 /**\r
10  * \return the color used for transparency, and/or for background color\r
11  */\r
12 RGBQUAD CxImage::GetTransColor()\r
13 {\r
14         if (head.biBitCount<24 && info.nBkgndIndex>=0) return GetPaletteColor((BYTE)info.nBkgndIndex);\r
15         return info.nBkgndColor;\r
16 }\r
17 ////////////////////////////////////////////////////////////////////////////////\r
18 /**\r
19  * Gets the index used for transparency. Returns -1 for no transparancy.\r
20  */\r
21 long CxImage::GetTransIndex() const\r
22 {\r
23         return info.nBkgndIndex;\r
24 }\r
25 ////////////////////////////////////////////////////////////////////////////////\r
26 /**\r
27  * Sets the index used for transparency with 1, 4 and 8 bpp images. Set to -1 to remove the effect.\r
28  */\r
29 void CxImage::SetTransIndex(long idx)\r
30 {\r
31         if (idx<(long)head.biClrUsed)\r
32                 info.nBkgndIndex = idx;\r
33         else \r
34                 info.nBkgndIndex = 0;\r
35 }\r
36 ////////////////////////////////////////////////////////////////////////////////\r
37 /**\r
38  * Sets the color used for transparency with 24 bpp images.\r
39  * You must call SetTransIndex(0) to enable the effect, SetTransIndex(-1) to disable it.\r
40  */\r
41 void CxImage::SetTransColor(RGBQUAD rgb)\r
42 {\r
43         rgb.rgbReserved=0;\r
44         info.nBkgndColor = rgb;\r
45 }\r
46 ////////////////////////////////////////////////////////////////////////////////\r
47 bool CxImage::IsTransparent() const\r
48 {\r
49         return info.nBkgndIndex>=0; // <vho>\r
50 }\r
51 ////////////////////////////////////////////////////////////////////////////////\r
52 /**\r
53  * Returns true if the image has 256 colors or less.\r
54  */\r
55 bool CxImage::IsIndexed() const\r
56 {\r
57         return head.biClrUsed!=0;\r
58 }\r
59 ////////////////////////////////////////////////////////////////////////////////\r
60 /**\r
61  * \return 1 = indexed, 2 = RGB, 4 = RGBA\r
62  */\r
63 BYTE CxImage::GetColorType()\r
64 {\r
65         BYTE b = (BYTE)((head.biBitCount>8) ? 2 /*COLORTYPE_COLOR*/ : 1 /*COLORTYPE_PALETTE*/);\r
66 #if CXIMAGE_SUPPORT_ALPHA\r
67         if (AlphaIsValid()) b = 4 /*COLORTYPE_ALPHA*/;\r
68 #endif //CXIMAGE_SUPPORT_ALPHA\r
69         return b;\r
70 }\r
71 ////////////////////////////////////////////////////////////////////////////////\r
72 /**\r
73  * \return Resolution for TIFF, JPEG, PNG and BMP formats.\r
74  */\r
75 long CxImage::GetXDPI() const\r
76 {\r
77         return info.xDPI;\r
78 }\r
79 ////////////////////////////////////////////////////////////////////////////////\r
80 /**\r
81  * \return Resolution for TIFF, JPEG, PNG and BMP formats.\r
82  */\r
83 long CxImage::GetYDPI() const\r
84 {\r
85         return info.yDPI;\r
86 }\r
87 ////////////////////////////////////////////////////////////////////////////////\r
88 /**\r
89  * Set resolution for TIFF, JPEG, PNG and BMP formats.\r
90  */\r
91 void CxImage::SetXDPI(long dpi)\r
92 {\r
93         if (dpi<=0) dpi = CXIMAGE_DEFAULT_DPI;\r
94         info.xDPI = dpi;\r
95         head.biXPelsPerMeter = (long) floor(dpi * 10000.0 / 254.0 + 0.5);\r
96         if (pDib) ((BITMAPINFOHEADER*)pDib)->biXPelsPerMeter = head.biXPelsPerMeter;\r
97 }\r
98 ////////////////////////////////////////////////////////////////////////////////\r
99 /**\r
100  * Set resolution for TIFF, JPEG, PNG and BMP formats.\r
101  */\r
102 void CxImage::SetYDPI(long dpi)\r
103 {\r
104         if (dpi<=0) dpi = CXIMAGE_DEFAULT_DPI;\r
105         info.yDPI = dpi;\r
106         head.biYPelsPerMeter = (long) floor(dpi * 10000.0 / 254.0 + 0.5);\r
107         if (pDib) ((BITMAPINFOHEADER*)pDib)->biYPelsPerMeter = head.biYPelsPerMeter;\r
108 }\r
109 ////////////////////////////////////////////////////////////////////////////////\r
110 /**\r
111  * \sa SetFlags\r
112  */\r
113 DWORD CxImage::GetFlags() const\r
114 {\r
115         return info.dwFlags;\r
116 }\r
117 ////////////////////////////////////////////////////////////////////////////////\r
118 /**\r
119  * Image flags, for future use\r
120  * \param flags\r
121  *  - 0x??00000 = reserved for 16 bit, CMYK, multilayer\r
122  *  - 0x00??0000 = blend modes\r
123  *  - 0x0000???? = layer id or user flags\r
124  *\r
125  * \param bLockReservedFlags protects the "reserved" and "blend modes" flags \r
126  */\r
127 void CxImage::SetFlags(DWORD flags, bool bLockReservedFlags)\r
128 {\r
129         if (bLockReservedFlags) info.dwFlags = flags & 0x0000ffff;\r
130         else info.dwFlags = flags;\r
131 }\r
132 ////////////////////////////////////////////////////////////////////////////////\r
133 /**\r
134  * \sa SetCodecOption\r
135  */\r
136 DWORD CxImage::GetCodecOption(DWORD imagetype)\r
137 {\r
138         imagetype = GetTypeIndexFromId(imagetype);\r
139         if (imagetype==0){\r
140                 imagetype = GetTypeIndexFromId(GetType());\r
141         }\r
142         return info.dwCodecOpt[imagetype];\r
143 }\r
144 ////////////////////////////////////////////////////////////////////////////////\r
145 /**\r
146  * Encode option for GIF, TIF and JPG.\r
147  * - GIF : 0 = LZW (default), 1 = none, 2 = RLE.\r
148  * - TIF : 0 = automatic (default), or a valid compression code as defined in "tiff.h" (COMPRESSION_NONE = 1, COMPRESSION_CCITTRLE = 2, ...)\r
149  * - JPG : valid values stored in enum CODEC_OPTION ( ENCODE_BASELINE = 0x01, ENCODE_PROGRESSIVE = 0x10, ...)\r
150  * - RAW : valid values stored in enum CODEC_OPTION ( DECODE_QUALITY_LIN = 0x00, DECODE_QUALITY_VNG = 0x01, ...)\r
151  *\r
152  * \return true if everything is ok\r
153  */\r
154 bool CxImage::SetCodecOption(DWORD opt, DWORD imagetype)\r
155 {\r
156         imagetype = GetTypeIndexFromId(imagetype);\r
157         if (imagetype==0){\r
158                 imagetype = GetTypeIndexFromId(GetType());\r
159         }\r
160         info.dwCodecOpt[imagetype] = opt;\r
161         return true;\r
162 }\r
163 ////////////////////////////////////////////////////////////////////////////////\r
164 /**\r
165  * \return internal hDib object..\r
166  */\r
167 void* CxImage::GetDIB() const\r
168 {\r
169         return pDib;\r
170 }\r
171 ////////////////////////////////////////////////////////////////////////////////\r
172 DWORD CxImage::GetHeight() const\r
173 {\r
174         return head.biHeight;\r
175 }\r
176 ////////////////////////////////////////////////////////////////////////////////\r
177 DWORD CxImage::GetWidth() const\r
178 {\r
179         return head.biWidth;\r
180 }\r
181 ////////////////////////////////////////////////////////////////////////////////\r
182 /**\r
183  * \return DWORD aligned width of the image.\r
184  */\r
185 DWORD CxImage::GetEffWidth() const\r
186 {\r
187         return info.dwEffWidth;\r
188 }\r
189 ////////////////////////////////////////////////////////////////////////////////\r
190 /**\r
191  * \return 2, 16, 256; 0 for RGB images.\r
192  */\r
193 DWORD CxImage::GetNumColors() const\r
194 {\r
195         return head.biClrUsed;\r
196 }\r
197 ////////////////////////////////////////////////////////////////////////////////\r
198 /**\r
199  * \return: 1, 4, 8, 24.\r
200  */\r
201 WORD CxImage::GetBpp() const\r
202 {\r
203         return head.biBitCount;\r
204 }\r
205 ////////////////////////////////////////////////////////////////////////////////\r
206 /**\r
207  * \return original image format\r
208  * \sa ENUM_CXIMAGE_FORMATS.\r
209  */\r
210 DWORD CxImage::GetType() const\r
211 {\r
212         return info.dwType;\r
213 }\r
214 ////////////////////////////////////////////////////////////////////////////////\r
215 /**\r
216  * change image format identifier\r
217  * \sa ENUM_CXIMAGE_FORMATS.\r
218  */\r
219 bool CxImage::SetType(DWORD type)\r
220 {\r
221         switch (type){\r
222 #if CXIMAGE_SUPPORT_BMP\r
223         case CXIMAGE_FORMAT_BMP:\r
224 #endif\r
225 #if CXIMAGE_SUPPORT_GIF\r
226         case CXIMAGE_FORMAT_GIF:\r
227 #endif\r
228 #if CXIMAGE_SUPPORT_JPG\r
229         case CXIMAGE_FORMAT_JPG:\r
230 #endif\r
231 #if CXIMAGE_SUPPORT_PNG\r
232         case CXIMAGE_FORMAT_PNG:\r
233 #endif\r
234 #if CXIMAGE_SUPPORT_MNG\r
235         case CXIMAGE_FORMAT_MNG:\r
236 #endif\r
237 #if CXIMAGE_SUPPORT_ICO\r
238         case CXIMAGE_FORMAT_ICO:\r
239 #endif\r
240 #if CXIMAGE_SUPPORT_TIF\r
241         case CXIMAGE_FORMAT_TIF:\r
242 #endif\r
243 #if CXIMAGE_SUPPORT_TGA\r
244         case CXIMAGE_FORMAT_TGA:\r
245 #endif\r
246 #if CXIMAGE_SUPPORT_PCX\r
247         case CXIMAGE_FORMAT_PCX:\r
248 #endif\r
249 #if CXIMAGE_SUPPORT_WBMP\r
250         case CXIMAGE_FORMAT_WBMP:\r
251 #endif\r
252 #if CXIMAGE_SUPPORT_WMF\r
253         case CXIMAGE_FORMAT_WMF:\r
254 #endif\r
255 #if CXIMAGE_SUPPORT_JBG\r
256         case CXIMAGE_FORMAT_JBG:\r
257 #endif\r
258 #if CXIMAGE_SUPPORT_JP2\r
259         case CXIMAGE_FORMAT_JP2:\r
260 #endif\r
261 #if CXIMAGE_SUPPORT_JPC\r
262         case CXIMAGE_FORMAT_JPC:\r
263 #endif\r
264 #if CXIMAGE_SUPPORT_PGX\r
265         case CXIMAGE_FORMAT_PGX:\r
266 #endif\r
267 #if CXIMAGE_SUPPORT_PNM\r
268         case CXIMAGE_FORMAT_PNM:\r
269 #endif\r
270 #if CXIMAGE_SUPPORT_RAS\r
271         case CXIMAGE_FORMAT_RAS:\r
272 #endif\r
273 #if CXIMAGE_SUPPORT_SKA\r
274         case CXIMAGE_FORMAT_SKA:\r
275 #endif\r
276 #if CXIMAGE_SUPPORT_RAW\r
277         case CXIMAGE_FORMAT_RAW:\r
278 #endif\r
279                 info.dwType = type;\r
280                 return true;\r
281         }\r
282         info.dwType = CXIMAGE_FORMAT_UNKNOWN;\r
283         return false;\r
284 }\r
285 ////////////////////////////////////////////////////////////////////////////////\r
286 DWORD CxImage::GetNumTypes()\r
287 {\r
288         return CMAX_IMAGE_FORMATS-1;\r
289 }\r
290 ////////////////////////////////////////////////////////////////////////////////\r
291 DWORD CxImage::GetTypeIdFromName(const TCHAR* ext)\r
292 {\r
293 #if CXIMAGE_SUPPORT_BMP\r
294         if (_tcsnicmp(ext,_T("bmp"),3)==0 )             return CXIMAGE_FORMAT_BMP;\r
295 #endif\r
296 #if CXIMAGE_SUPPORT_JPG\r
297         if (_tcsnicmp(ext,_T("jpg"),3)==0 ||\r
298                 _tcsnicmp(ext,_T("jpe"),3)==0 ||\r
299                 _tcsnicmp(ext,_T("jfi"),3)==0 )         return CXIMAGE_FORMAT_JPG;\r
300 #endif\r
301 #if CXIMAGE_SUPPORT_GIF\r
302         if (_tcsnicmp(ext,_T("gif"),3)==0 )             return CXIMAGE_FORMAT_GIF;\r
303 #endif\r
304 #if CXIMAGE_SUPPORT_PNG\r
305         if (_tcsnicmp(ext,_T("png"),3)==0 )             return CXIMAGE_FORMAT_PNG;\r
306 #endif\r
307 #if CXIMAGE_SUPPORT_ICO\r
308         if (_tcsnicmp(ext,_T("ico"),3)==0 ||\r
309                 _tcsnicmp(ext,_T("cur"),3)==0 )         return CXIMAGE_FORMAT_ICO;\r
310 #endif\r
311 #if CXIMAGE_SUPPORT_TIF\r
312         if (_tcsnicmp(ext,_T("tif"),3)==0 )             return CXIMAGE_FORMAT_TIF;\r
313 #endif\r
314 #if CXIMAGE_SUPPORT_TGA\r
315         if (_tcsnicmp(ext,_T("tga"),3)==0 )             return CXIMAGE_FORMAT_TGA;\r
316 #endif\r
317 #if CXIMAGE_SUPPORT_PCX\r
318         if (_tcsnicmp(ext,_T("pcx"),3)==0 )             return CXIMAGE_FORMAT_PCX;\r
319 #endif\r
320 #if CXIMAGE_SUPPORT_WBMP\r
321         if (_tcsnicmp(ext,_T("wbm"),3)==0 )             return CXIMAGE_FORMAT_WBMP;\r
322 #endif\r
323 #if CXIMAGE_SUPPORT_WMF\r
324         if (_tcsnicmp(ext,_T("wmf"),3)==0 ||\r
325                 _tcsnicmp(ext,_T("emf"),3)==0 )         return CXIMAGE_FORMAT_WMF;\r
326 #endif\r
327 #if CXIMAGE_SUPPORT_JP2\r
328         if (_tcsnicmp(ext,_T("jp2"),3)==0 ||\r
329                 _tcsnicmp(ext,_T("j2k"),3)==0 )         return CXIMAGE_FORMAT_JP2;\r
330 #endif\r
331 #if CXIMAGE_SUPPORT_JPC\r
332         if (_tcsnicmp(ext,_T("jpc"),3)==0 ||\r
333                 _tcsnicmp(ext,_T("j2c"),3)==0 )         return CXIMAGE_FORMAT_JPC;\r
334 #endif\r
335 #if CXIMAGE_SUPPORT_PGX\r
336         if (_tcsnicmp(ext,_T("pgx"),3)==0 )             return CXIMAGE_FORMAT_PGX;\r
337 #endif\r
338 #if CXIMAGE_SUPPORT_RAS\r
339         if (_tcsnicmp(ext,_T("ras"),3)==0 )             return CXIMAGE_FORMAT_RAS;\r
340 #endif\r
341 #if CXIMAGE_SUPPORT_PNM\r
342         if (_tcsnicmp(ext,_T("pnm"),3)==0 ||\r
343                 _tcsnicmp(ext,_T("pgm"),3)==0 ||\r
344                 _tcsnicmp(ext,_T("ppm"),3)==0 )         return CXIMAGE_FORMAT_PNM;\r
345 #endif\r
346 #if CXIMAGE_SUPPORT_JBG\r
347         if (_tcsnicmp(ext,_T("jbg"),3)==0 )             return CXIMAGE_FORMAT_JBG;\r
348 #endif\r
349 #if CXIMAGE_SUPPORT_MNG\r
350         if (_tcsnicmp(ext,_T("mng"),3)==0 ||\r
351                 _tcsnicmp(ext,_T("jng"),3)==0 )         return CXIMAGE_FORMAT_MNG;\r
352 #endif\r
353 #if CXIMAGE_SUPPORT_SKA\r
354         if (_tcsnicmp(ext,_T("ska"),3)==0 )             return CXIMAGE_FORMAT_SKA;\r
355 #endif\r
356 #if CXIMAGE_SUPPORT_RAW\r
357         if (_tcsnicmp(ext,_T("nef"),3)==0 ||\r
358                 _tcsnicmp(ext,_T("crw"),3)==0 ||\r
359                 _tcsnicmp(ext,_T("cr2"),3)==0 ||\r
360                 _tcsnicmp(ext,_T("dng"),3)==0 ||\r
361                 _tcsnicmp(ext,_T("arw"),3)==0 ||\r
362                 _tcsnicmp(ext,_T("erf"),3)==0 ||\r
363                 _tcsnicmp(ext,_T("3fr"),3)==0 ||\r
364                 _tcsnicmp(ext,_T("dcr"),3)==0 ||\r
365                 _tcsnicmp(ext,_T("raw"),3)==0 ||\r
366                 _tcsnicmp(ext,_T("x3f"),3)==0 ||\r
367                 _tcsnicmp(ext,_T("mef"),3)==0 ||\r
368                 _tcsnicmp(ext,_T("raf"),3)==0 ||\r
369                 _tcsnicmp(ext,_T("mrw"),3)==0 ||\r
370                 _tcsnicmp(ext,_T("pef"),3)==0 ||\r
371                 _tcsnicmp(ext,_T("sr2"),3)==0 ||\r
372                 _tcsnicmp(ext,_T("orf"),3)==0 )         return CXIMAGE_FORMAT_RAW;\r
373 #endif\r
374 \r
375         return CXIMAGE_FORMAT_UNKNOWN;\r
376 }\r
377 ////////////////////////////////////////////////////////////////////////////////\r
378 DWORD CxImage::GetTypeIdFromIndex(const DWORD index)\r
379 {\r
380         DWORD n;\r
381 \r
382         n=0; if (index == n) return CXIMAGE_FORMAT_UNKNOWN;\r
383 #if CXIMAGE_SUPPORT_BMP\r
384         n++; if (index == n) return CXIMAGE_FORMAT_BMP;\r
385 #endif\r
386 #if CXIMAGE_SUPPORT_GIF\r
387         n++; if (index == n) return CXIMAGE_FORMAT_GIF;\r
388 #endif\r
389 #if CXIMAGE_SUPPORT_JPG\r
390         n++; if (index == n) return CXIMAGE_FORMAT_JPG;\r
391 #endif\r
392 #if CXIMAGE_SUPPORT_PNG\r
393         n++; if (index == n) return CXIMAGE_FORMAT_PNG;\r
394 #endif\r
395 #if CXIMAGE_SUPPORT_ICO\r
396         n++; if (index == n) return CXIMAGE_FORMAT_ICO;\r
397 #endif\r
398 #if CXIMAGE_SUPPORT_TIF\r
399         n++; if (index == n) return CXIMAGE_FORMAT_TIF;\r
400 #endif\r
401 #if CXIMAGE_SUPPORT_TGA\r
402         n++; if (index == n) return CXIMAGE_FORMAT_TGA;\r
403 #endif\r
404 #if CXIMAGE_SUPPORT_PCX\r
405         n++; if (index == n) return CXIMAGE_FORMAT_PCX;\r
406 #endif\r
407 #if CXIMAGE_SUPPORT_WBMP\r
408         n++; if (index == n) return CXIMAGE_FORMAT_WBMP;\r
409 #endif\r
410 #if CXIMAGE_SUPPORT_WMF\r
411         n++; if (index == n) return CXIMAGE_FORMAT_WMF;\r
412 #endif\r
413 #if CXIMAGE_SUPPORT_JP2\r
414         n++; if (index == n) return CXIMAGE_FORMAT_JP2;\r
415 #endif\r
416 #if CXIMAGE_SUPPORT_JPC\r
417         n++; if (index == n) return CXIMAGE_FORMAT_JPC;\r
418 #endif\r
419 #if CXIMAGE_SUPPORT_PGX\r
420         n++; if (index == n) return CXIMAGE_FORMAT_PGX;\r
421 #endif\r
422 #if CXIMAGE_SUPPORT_PNM\r
423         n++; if (index == n) return CXIMAGE_FORMAT_PNM;\r
424 #endif\r
425 #if CXIMAGE_SUPPORT_RAS\r
426         n++; if (index == n) return CXIMAGE_FORMAT_RAS;\r
427 #endif\r
428 #if CXIMAGE_SUPPORT_JBG\r
429         n++; if (index == n) return CXIMAGE_FORMAT_JBG;\r
430 #endif\r
431 #if CXIMAGE_SUPPORT_MNG\r
432         n++; if (index == n) return CXIMAGE_FORMAT_MNG;\r
433 #endif\r
434 #if CXIMAGE_SUPPORT_SKA\r
435         n++; if (index == n) return CXIMAGE_FORMAT_SKA;\r
436 #endif\r
437 #if CXIMAGE_SUPPORT_RAW\r
438         n++; if (index == n) return CXIMAGE_FORMAT_RAW;\r
439 #endif\r
440 \r
441         return CXIMAGE_FORMAT_UNKNOWN;\r
442 }\r
443 ////////////////////////////////////////////////////////////////////////////////\r
444 DWORD CxImage::GetTypeIndexFromId(const DWORD id)\r
445 {\r
446         DWORD n;\r
447 \r
448         n=0; if (id == CXIMAGE_FORMAT_UNKNOWN) return n;\r
449 #if CXIMAGE_SUPPORT_BMP\r
450         n++; if (id == CXIMAGE_FORMAT_BMP) return n;\r
451 #endif\r
452 #if CXIMAGE_SUPPORT_GIF\r
453         n++; if (id == CXIMAGE_FORMAT_GIF) return n;\r
454 #endif\r
455 #if CXIMAGE_SUPPORT_JPG\r
456         n++; if (id == CXIMAGE_FORMAT_JPG) return n;\r
457 #endif\r
458 #if CXIMAGE_SUPPORT_PNG\r
459         n++; if (id == CXIMAGE_FORMAT_PNG) return n;\r
460 #endif\r
461 #if CXIMAGE_SUPPORT_ICO\r
462         n++; if (id == CXIMAGE_FORMAT_ICO) return n;\r
463 #endif\r
464 #if CXIMAGE_SUPPORT_TIF\r
465         n++; if (id == CXIMAGE_FORMAT_TIF) return n;\r
466 #endif\r
467 #if CXIMAGE_SUPPORT_TGA\r
468         n++; if (id == CXIMAGE_FORMAT_TGA) return n;\r
469 #endif\r
470 #if CXIMAGE_SUPPORT_PCX\r
471         n++; if (id == CXIMAGE_FORMAT_PCX) return n;\r
472 #endif\r
473 #if CXIMAGE_SUPPORT_WBMP\r
474         n++; if (id == CXIMAGE_FORMAT_WBMP) return n;\r
475 #endif\r
476 #if CXIMAGE_SUPPORT_WMF\r
477         n++; if (id == CXIMAGE_FORMAT_WMF) return n;\r
478 #endif\r
479 #if CXIMAGE_SUPPORT_JP2\r
480         n++; if (id == CXIMAGE_FORMAT_JP2) return n;\r
481 #endif\r
482 #if CXIMAGE_SUPPORT_JPC\r
483         n++; if (id == CXIMAGE_FORMAT_JPC) return n;\r
484 #endif\r
485 #if CXIMAGE_SUPPORT_PGX\r
486         n++; if (id == CXIMAGE_FORMAT_PGX) return n;\r
487 #endif\r
488 #if CXIMAGE_SUPPORT_PNM\r
489         n++; if (id == CXIMAGE_FORMAT_PNM) return n;\r
490 #endif\r
491 #if CXIMAGE_SUPPORT_RAS\r
492         n++; if (id == CXIMAGE_FORMAT_RAS) return n;\r
493 #endif\r
494 #if CXIMAGE_SUPPORT_JBG\r
495         n++; if (id == CXIMAGE_FORMAT_JBG) return n;\r
496 #endif\r
497 #if CXIMAGE_SUPPORT_MNG\r
498         n++; if (id == CXIMAGE_FORMAT_MNG) return n;\r
499 #endif\r
500 #if CXIMAGE_SUPPORT_SKA\r
501         n++; if (id == CXIMAGE_FORMAT_SKA) return n;\r
502 #endif\r
503 #if CXIMAGE_SUPPORT_RAW\r
504         n++; if (id == CXIMAGE_FORMAT_RAW) return n;\r
505 #endif\r
506 \r
507         return 0;\r
508 }\r
509 ////////////////////////////////////////////////////////////////////////////////\r
510 /**\r
511  * \return current frame delay in milliseconds. Only for GIF and MNG formats.\r
512  */\r
513 DWORD CxImage::GetFrameDelay() const\r
514 {\r
515         return info.dwFrameDelay;\r
516 }\r
517 ////////////////////////////////////////////////////////////////////////////////\r
518 /**\r
519  * Sets current frame delay. Only for GIF format.\r
520  * \param d = delay in milliseconds\r
521  */\r
522 void CxImage::SetFrameDelay(DWORD d)\r
523 {\r
524         info.dwFrameDelay=d;\r
525 }\r
526 ////////////////////////////////////////////////////////////////////////////////\r
527 void CxImage::GetOffset(long *x,long *y)\r
528 {\r
529         *x=info.xOffset;\r
530         *y=info.yOffset;\r
531 }\r
532 ////////////////////////////////////////////////////////////////////////////////\r
533 void CxImage::SetOffset(long x,long y)\r
534 {\r
535         info.xOffset=x;\r
536         info.yOffset=y;\r
537 }\r
538 ////////////////////////////////////////////////////////////////////////////////\r
539 /**\r
540  * \sa SetJpegQuality, GetJpegQualityF\r
541  * \author [DP]; changes [Stefan Schürmans]\r
542  */\r
543 BYTE CxImage::GetJpegQuality() const\r
544 {\r
545         return (BYTE)(info.fQuality + 0.5f);\r
546 }\r
547 ////////////////////////////////////////////////////////////////////////////////\r
548 /**\r
549  * \sa SetJpegQuality, GetJpegQuality\r
550  * \author [Stefan Schürmans]\r
551  */\r
552 float CxImage::GetJpegQualityF() const\r
553 {\r
554         return info.fQuality;\r
555 }\r
556 ////////////////////////////////////////////////////////////////////////////////\r
557 /**\r
558  * quality level for JPEG and JPEG2000\r
559  * \param q: can be from 0 to 100\r
560  * \author [DP]; changes [Stefan Schürmans]\r
561  */\r
562 void CxImage::SetJpegQuality(BYTE q){\r
563         info.fQuality = (float)q;\r
564 }\r
565 ////////////////////////////////////////////////////////////////////////////////\r
566 /**\r
567  * quality level for JPEG and JPEG2000\r
568  * necessary for JPEG2000 when quality is between 0.0 and 1.0\r
569  * \param q: can be from 0.0 to 100.0\r
570  * \author [Stefan Schürmans]\r
571  */\r
572 void CxImage::SetJpegQualityF(float q){\r
573         if (q>0) info.fQuality = q;\r
574         else  info.fQuality = 0.0f;\r
575 }\r
576 ////////////////////////////////////////////////////////////////////////////////\r
577 /**\r
578  * \sa SetJpegScale\r
579  */\r
580 BYTE CxImage::GetJpegScale() const\r
581 {\r
582         return info.nJpegScale;\r
583 }\r
584 ////////////////////////////////////////////////////////////////////////////////\r
585 /**\r
586  * scaling down during JPEG decoding valid numbers are 1, 2, 4, 8\r
587  * \author [ignacio]\r
588  */\r
589 void CxImage::SetJpegScale(BYTE q){\r
590         info.nJpegScale = q;\r
591 }\r
592 ////////////////////////////////////////////////////////////////////////////////\r
593 /**\r
594  * Used to monitor the slow loops.\r
595  * \return value is from 0 to 100.\r
596  * \sa SetProgress\r
597  */\r
598 long CxImage::GetProgress() const\r
599 {\r
600         return info.nProgress;\r
601 }\r
602 ////////////////////////////////////////////////////////////////////////////////\r
603 /**\r
604  * \return the escape code.\r
605  * \sa SetEscape\r
606  */\r
607 long CxImage::GetEscape() const\r
608 {\r
609         return info.nEscape;\r
610 }\r
611 ////////////////////////////////////////////////////////////////////////////////\r
612 /**\r
613  * Forces the value of the internal progress variable.\r
614  * \param p should be from 0 to 100.\r
615  * \sa GetProgress\r
616  */\r
617 void CxImage::SetProgress(long p)\r
618 {\r
619         info.nProgress = p;\r
620 }\r
621 ////////////////////////////////////////////////////////////////////////////////\r
622 /**\r
623  * Used to quit the slow loops or the codecs.\r
624  * - SetEscape(-1) before Decode forces the function to exit, right after  \r
625  *   the image width and height are available ( for bmp, jpg, gif, tif )\r
626  */\r
627 void CxImage::SetEscape(long i)\r
628 {\r
629         info.nEscape = i;\r
630 }\r
631 ////////////////////////////////////////////////////////////////////////////////\r
632 /**\r
633  * Checks if the image is correctly initializated.\r
634  */\r
635 bool CxImage::IsValid() const\r
636 {\r
637         return pDib!=0;\r
638 }\r
639 ////////////////////////////////////////////////////////////////////////////////\r
640 /**\r
641  * True if the image is enabled for painting.\r
642  */\r
643 bool CxImage::IsEnabled() const\r
644 {\r
645         return info.bEnabled;\r
646 }\r
647 ////////////////////////////////////////////////////////////////////////////////\r
648 /**\r
649  * Enables/disables the image.\r
650  */\r
651 void CxImage::Enable(bool enable)\r
652 {\r
653         info.bEnabled=enable;\r
654 }\r
655 ////////////////////////////////////////////////////////////////////////////////\r
656 /**\r
657  * This function must be used after a Decode() / Load() call.\r
658  * Use the sequence SetFrame(-1); Load(...); GetNumFrames();\r
659  * to get the number of images without loading the first image.\r
660  * \return the number of images in the file.\r
661  */\r
662 long CxImage::GetNumFrames() const\r
663 {\r
664         return info.nNumFrames;\r
665 }\r
666 ////////////////////////////////////////////////////////////////////////////////\r
667 /**\r
668  * \return the current selected image (zero-based index).\r
669  */\r
670 long CxImage::GetFrame() const\r
671 {\r
672         return info.nFrame;\r
673 }\r
674 ////////////////////////////////////////////////////////////////////////////////\r
675 /**\r
676  * Sets the image number that the next Decode() / Load() call will load\r
677  */\r
678 void CxImage::SetFrame(long nFrame){\r
679         info.nFrame=nFrame;\r
680 }\r
681 ////////////////////////////////////////////////////////////////////////////////\r
682 /**\r
683  * Sets the method for drawing the frame related to others\r
684  * \sa GetDisposalMethod\r
685  */\r
686 void CxImage::SetDisposalMethod(BYTE dm)\r
687 {       info.dispmeth=dm; }\r
688 ////////////////////////////////////////////////////////////////////////////////\r
689 /**\r
690  * Gets the method for drawing the frame related to others\r
691  * Values :    0 -   No disposal specified. The decoder is\r
692  *                   not required to take any action.\r
693  *             1 -   Do not dispose. The graphic is to be left\r
694  *                   in place.\r
695  *             2 -   Restore to background color. The area used by the\r
696  *                   graphic must be restored to the background color.\r
697  *             3 -   Restore to previous. The decoder is required to\r
698  *                   restore the area overwritten by the graphic with\r
699  *                   what was there prior to rendering the graphic.\r
700  *             4-7 -    To be defined.\r
701  */\r
702 BYTE CxImage::GetDisposalMethod() const\r
703 {       return info.dispmeth; }\r
704 ////////////////////////////////////////////////////////////////////////////////\r
705 bool CxImage::GetRetreiveAllFrames() const\r
706 {       return info.bGetAllFrames; }\r
707 ////////////////////////////////////////////////////////////////////////////////\r
708 void CxImage::SetRetreiveAllFrames(bool flag)\r
709 {       info.bGetAllFrames = flag; }\r
710 ////////////////////////////////////////////////////////////////////////////////\r
711 CxImage * CxImage::GetFrame(long nFrame) const\r
712 {\r
713         if ( ppFrames == NULL) return NULL;\r
714         if ( info.nNumFrames == 0) return NULL;\r
715         if ( nFrame >= info.nNumFrames ) return NULL;\r
716         if ( nFrame < 0) nFrame = info.nNumFrames - 1;\r
717         return ppFrames[nFrame];\r
718 }\r
719 ////////////////////////////////////////////////////////////////////////////////\r
720 short CxImage::ntohs(const short word)\r
721 {\r
722         if (info.bLittleEndianHost) return word;\r
723         return ( (word & 0xff) << 8 ) | ( (word >> 8) & 0xff );\r
724 }\r
725 ////////////////////////////////////////////////////////////////////////////////\r
726 long CxImage::ntohl(const long dword)\r
727 {\r
728         if (info.bLittleEndianHost) return dword;\r
729         return  ((dword & 0xff) << 24 ) | ((dword & 0xff00) << 8 ) |\r
730                         ((dword >> 8) & 0xff00) | ((dword >> 24) & 0xff);\r
731 }\r
732 ////////////////////////////////////////////////////////////////////////////////\r
733 void CxImage::bihtoh(BITMAPINFOHEADER* bih)\r
734 {\r
735         bih->biSize = ntohl(bih->biSize);\r
736         bih->biWidth = ntohl(bih->biWidth);\r
737         bih->biHeight = ntohl(bih->biHeight);\r
738         bih->biPlanes = ntohs(bih->biPlanes);\r
739         bih->biBitCount = ntohs(bih->biBitCount);\r
740         bih->biCompression = ntohl(bih->biCompression);\r
741         bih->biSizeImage = ntohl(bih->biSizeImage);\r
742         bih->biXPelsPerMeter = ntohl(bih->biXPelsPerMeter);\r
743         bih->biYPelsPerMeter = ntohl(bih->biYPelsPerMeter);\r
744         bih->biClrUsed = ntohl(bih->biClrUsed);\r
745         bih->biClrImportant = ntohl(bih->biClrImportant);\r
746 }\r
747 ////////////////////////////////////////////////////////////////////////////////\r
748 /**\r
749  * Returns the last reported error.\r
750  */\r
751 const char* CxImage::GetLastError()\r
752 {\r
753         return info.szLastError;\r
754 }\r
755 ////////////////////////////////////////////////////////////////////////////////\r
756 DWORD CxImage::DumpSize()\r
757 {\r
758         DWORD n;\r
759         n = sizeof(BITMAPINFOHEADER) + sizeof(CXIMAGEINFO) + GetSize();\r
760 \r
761         if (pAlpha){\r
762                 n += 1 + head.biWidth * head.biHeight;\r
763         } else n++;\r
764 \r
765         if (pSelection){\r
766                 n += 1 + head.biWidth * head.biHeight;\r
767         } else n++;\r
768 \r
769         if (ppLayers){\r
770                 for (long m=0; m<GetNumLayers(); m++){\r
771                         if (GetLayer(m)){\r
772                                 n += 1 + GetLayer(m)->DumpSize();\r
773                         }\r
774                 }\r
775         } else n++;\r
776 \r
777         if (ppFrames){\r
778                 for (long m=0; m<GetNumFrames(); m++){\r
779                         if (GetFrame(m)){\r
780                                 n += 1 + GetFrame(m)->DumpSize();\r
781                         }\r
782                 }\r
783         } else n++;\r
784 \r
785         return n;\r
786 }\r
787 ////////////////////////////////////////////////////////////////////////////////\r
788 DWORD CxImage::Dump(BYTE * dst)\r
789 {\r
790         if (!dst) return 0;\r
791 \r
792         memcpy(dst,&head,sizeof(BITMAPINFOHEADER));\r
793         dst += sizeof(BITMAPINFOHEADER);\r
794 \r
795         memcpy(dst,&info,sizeof(CXIMAGEINFO));\r
796         dst += sizeof(CXIMAGEINFO);\r
797 \r
798         memcpy(dst,pDib,GetSize());\r
799         dst += GetSize();\r
800 \r
801         if (pAlpha){\r
802                 memset(dst++, 1, 1);\r
803                 memcpy(dst,pAlpha,head.biWidth * head.biHeight);\r
804                 dst += head.biWidth * head.biHeight;\r
805         } else {\r
806                 memset(dst++, 0, 1);\r
807         }\r
808 \r
809         if (pSelection){\r
810                 memset(dst++, 1, 1);\r
811                 memcpy(dst,pSelection,head.biWidth * head.biHeight);\r
812                 dst += head.biWidth * head.biHeight;\r
813         } else {\r
814                 memset(dst++, 0, 1);\r
815         }\r
816 \r
817         if (ppLayers){\r
818                 memset(dst++, 1, 1);\r
819                 for (long m=0; m<GetNumLayers(); m++){\r
820                         if (GetLayer(m)){\r
821                                 dst += GetLayer(m)->Dump(dst);\r
822                         }\r
823                 }\r
824         } else {\r
825                 memset(dst++, 0, 1);\r
826         }\r
827 \r
828         if (ppFrames){\r
829                 memset(dst++, 1, 1);\r
830                 for (long m=0; m<GetNumFrames(); m++){\r
831                         if (GetFrame(m)){\r
832                                 dst += GetFrame(m)->Dump(dst);\r
833                         }\r
834                 }\r
835         } else {\r
836                 memset(dst++, 0, 1);\r
837         }\r
838 \r
839         return DumpSize();\r
840 }\r
841 ////////////////////////////////////////////////////////////////////////////////\r
842 DWORD CxImage::UnDump(const BYTE * src)\r
843 {\r
844         if (!src)\r
845                 return 0;\r
846         if (!Destroy())\r
847                 return 0;\r
848         if (!DestroyFrames())\r
849                 return 0;\r
850 \r
851         DWORD n = 0;\r
852 \r
853         memcpy(&head,src,sizeof(BITMAPINFOHEADER));\r
854         n += sizeof(BITMAPINFOHEADER);\r
855 \r
856         memcpy(&info,&src[n],sizeof(CXIMAGEINFO));\r
857         n += sizeof(CXIMAGEINFO);\r
858 \r
859         if (!Create(head.biWidth, head.biHeight, head.biBitCount, info.dwType))\r
860                 return 0;\r
861 \r
862         memcpy(pDib,&src[n],GetSize());\r
863         n += GetSize();\r
864 \r
865         if (src[n++]){\r
866                 if (AlphaCreate()){\r
867                         memcpy(pAlpha, &src[n], head.biWidth * head.biHeight);\r
868                 }\r
869                 n += head.biWidth * head.biHeight;\r
870         }\r
871 \r
872         if (src[n++]){\r
873                 RECT box = info.rSelectionBox;\r
874                 if (SelectionCreate()){\r
875                         info.rSelectionBox = box;\r
876                         memcpy(pSelection, &src[n], head.biWidth * head.biHeight);\r
877                 }\r
878                 n += head.biWidth * head.biHeight;\r
879         }\r
880 \r
881         if (src[n++]){\r
882                 ppLayers = new CxImage*[info.nNumLayers];\r
883                 for (long m=0; m<GetNumLayers(); m++){\r
884                         ppLayers[m] = new CxImage();\r
885                         n += ppLayers[m]->UnDump(&src[n]);\r
886                 }\r
887         }\r
888 \r
889         if (src[n++]){\r
890                 ppFrames = new CxImage*[info.nNumFrames];\r
891                 for (long m=0; m<GetNumFrames(); m++){\r
892                         ppFrames[m] = new CxImage();\r
893                         n += ppFrames[m]->UnDump(&src[n]);\r
894                 }\r
895         }\r
896 \r
897         return n;\r
898 }\r
899 ////////////////////////////////////////////////////////////////////////////////\r
900 /**\r
901  * \return A.BBCCCDDDD\r
902  *  - A = main version\r
903  *  - BB = main revision\r
904  *  - CCC = minor revision (letter)\r
905  *  - DDDD = experimental revision\r
906  */\r
907 const float CxImage::GetVersionNumber()\r
908 {\r
909         return 6.000000015f;\r
910 }\r
911 ////////////////////////////////////////////////////////////////////////////////\r
912 const TCHAR* CxImage::GetVersion()\r
913 {\r
914         static const TCHAR CxImageVersion[] = _T("CxImage 6.0.0");\r
915         return (CxImageVersion);\r
916 }\r
917 ////////////////////////////////////////////////////////////////////////////////\r