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