/src/FreeImage/Source/FreeImage/Conversion.cpp

https://bitbucket.org/cabalistic/ogredeps/ · C++ · 513 lines · 368 code · 85 blank · 60 comment · 120 complexity · 5c1a600f2e17c59771f2e394bb0851ff MD5 · raw file

  1. // ==========================================================
  2. // Bitmap conversion routines
  3. //
  4. // Design and implementation by
  5. // - Floris van den Berg (flvdberg@wxs.nl)
  6. // - Hervé Drolon (drolon@infonie.fr)
  7. // - Jani Kajala (janik@remedy.fi)
  8. // - Mihail Naydenov (mnaydenov@users.sourceforge.net)
  9. //
  10. // This file is part of FreeImage 3
  11. //
  12. // COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
  13. // OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
  14. // THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
  15. // OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
  16. // CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
  17. // THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
  18. // SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
  19. // PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
  20. // THIS DISCLAIMER.
  21. //
  22. // Use at your own risk!
  23. // ==========================================================
  24. #include "FreeImage.h"
  25. #include "Utilities.h"
  26. #include "Quantizers.h"
  27. // ----------------------------------------------------------
  28. #define CONVERT(from, to) case to : FreeImage_ConvertLine##from##To##to(bits, scanline, FreeImage_GetWidth(dib)); break;
  29. #define CONVERTWITHPALETTE(from, to) case to : FreeImage_ConvertLine##from##To##to(bits, scanline, FreeImage_GetWidth(dib), FreeImage_GetPalette(dib)); break;
  30. #define CONVERTTO16(from) \
  31. case 16 : \
  32. if ((red_mask == FI16_555_RED_MASK) && (green_mask == FI16_555_GREEN_MASK) && (blue_mask == FI16_555_BLUE_MASK)) { \
  33. FreeImage_ConvertLine##from##To16_555(bits, scanline, FreeImage_GetWidth(dib)); \
  34. } else { \
  35. FreeImage_ConvertLine##from##To16_565(bits, scanline, FreeImage_GetWidth(dib)); \
  36. } \
  37. break;
  38. #define CONVERTTO16WITHPALETTE(from) \
  39. case 16 : \
  40. if ((red_mask == FI16_555_RED_MASK) && (green_mask == FI16_555_GREEN_MASK) && (blue_mask == FI16_555_BLUE_MASK)) { \
  41. FreeImage_ConvertLine##from##To16_555(bits, scanline, FreeImage_GetWidth(dib), FreeImage_GetPalette(dib)); \
  42. } else { \
  43. FreeImage_ConvertLine##from##To16_565(bits, scanline, FreeImage_GetWidth(dib), FreeImage_GetPalette(dib)); \
  44. } \
  45. break;
  46. // ==========================================================
  47. // Utility functions declared in Utilities.h
  48. BOOL SwapRedBlue32(FIBITMAP* dib) {
  49. if(FreeImage_GetImageType(dib) != FIT_BITMAP) {
  50. return FALSE;
  51. }
  52. const unsigned bytesperpixel = FreeImage_GetBPP(dib) / 8;
  53. if(bytesperpixel > 4 || bytesperpixel < 3) {
  54. return FALSE;
  55. }
  56. const unsigned height = FreeImage_GetHeight(dib);
  57. const unsigned pitch = FreeImage_GetPitch(dib);
  58. const unsigned lineSize = FreeImage_GetLine(dib);
  59. BYTE* line = FreeImage_GetBits(dib);
  60. for(unsigned y = 0; y < height; ++y, line += pitch) {
  61. for(BYTE* pixel = line; pixel < line + lineSize ; pixel += bytesperpixel) {
  62. INPLACESWAP(pixel[0], pixel[2]);
  63. }
  64. }
  65. return TRUE;
  66. }
  67. // ----------------------------------------------------------
  68. static inline void
  69. assignRGB(WORD r, WORD g, WORD b, WORD* out) {
  70. out[0] = r;
  71. out[1] = g;
  72. out[2] = b;
  73. }
  74. static inline void
  75. assignRGB(BYTE r, BYTE g, BYTE b, BYTE* out) {
  76. out[FI_RGBA_RED] = r;
  77. out[FI_RGBA_GREEN] = g;
  78. out[FI_RGBA_BLUE] = b;
  79. }
  80. /**
  81. CMYK -> CMY -> RGB conversion from http://www.easyrgb.com/
  82. CMYK to CMY [0-1]: C,M,Y * (1 - K) + K
  83. CMY to RGB [0-1]: (1 - C,M,Y)
  84. => R,G,B = (1 - C,M,Y) * (1 - K)
  85. mapped to [0-MAX_VAL]:
  86. (MAX_VAL - C,M,Y) * (MAX_VAL - K) / MAX_VAL
  87. */
  88. template <class T>
  89. static inline void
  90. CMYKToRGB(T C, T M, T Y, T K, T* out) {
  91. unsigned max_val = std::numeric_limits<T>::max();
  92. unsigned r = (max_val - C) * (max_val - K) / max_val;
  93. unsigned g = (max_val - M) * (max_val - K) / max_val;
  94. unsigned b = (max_val - Y) * (max_val - K) / max_val;
  95. // clamp values to [0..max_val]
  96. T red = (T)CLAMP(r, (unsigned)0, max_val);
  97. T green = (T)CLAMP(g, (unsigned)0, max_val);
  98. T blue = (T)CLAMP(b, (unsigned)0, max_val);
  99. assignRGB(red, green, blue, out);
  100. }
  101. template <class T>
  102. static void
  103. _convertCMYKtoRGBA(unsigned width, unsigned height, BYTE* line_start, unsigned pitch, unsigned samplesperpixel) {
  104. const BOOL hasBlack = (samplesperpixel > 3) ? TRUE : FALSE;
  105. const T MAX_VAL = std::numeric_limits<T>::max();
  106. T K = 0;
  107. for(unsigned y = 0; y < height; y++) {
  108. T *line = (T*)line_start;
  109. for(unsigned x = 0; x < width; x++) {
  110. if(hasBlack) {
  111. K = line[FI_RGBA_ALPHA];
  112. line[FI_RGBA_ALPHA] = MAX_VAL; // TODO write the first extra channel as alpha!
  113. }
  114. CMYKToRGB<T>(line[0], line[1], line[2], K, line);
  115. line += samplesperpixel;
  116. }
  117. line_start += pitch;
  118. }
  119. }
  120. BOOL
  121. ConvertCMYKtoRGBA(FIBITMAP* dib) {
  122. if(!FreeImage_HasPixels(dib)) {
  123. return FALSE;
  124. }
  125. const FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(dib);
  126. const unsigned bytesperpixel = FreeImage_GetBPP(dib)/8;
  127. unsigned channelSize = 1;
  128. if (image_type == FIT_RGBA16 || image_type == FIT_RGB16) {
  129. channelSize = sizeof(WORD);
  130. } else if (!(image_type == FIT_BITMAP && (bytesperpixel > 2))) {
  131. return FALSE;
  132. }
  133. const unsigned width = FreeImage_GetWidth(dib);
  134. const unsigned height = FreeImage_GetHeight(dib);
  135. BYTE *line_start = FreeImage_GetScanLine(dib, 0);
  136. const unsigned pitch = FreeImage_GetPitch(dib);
  137. unsigned samplesperpixel = FreeImage_GetLine(dib) / width / channelSize;
  138. if(channelSize == sizeof(WORD)) {
  139. _convertCMYKtoRGBA<WORD>(width, height, line_start, pitch, samplesperpixel);
  140. } else {
  141. _convertCMYKtoRGBA<BYTE>(width, height, line_start, pitch, samplesperpixel);
  142. }
  143. return TRUE;
  144. }
  145. // ----------------------------------------------------------
  146. /**
  147. CIELab -> XYZ conversion from http://www.easyrgb.com/
  148. */
  149. static void
  150. CIELabToXYZ(float L, float a, float b, float *X, float *Y, float *Z) {
  151. float pow_3;
  152. // CIELab -> XYZ conversion
  153. // ------------------------
  154. float var_Y = (L + 16.F ) / 116.F;
  155. float var_X = a / 500.F + var_Y;
  156. float var_Z = var_Y - b / 200.F;
  157. pow_3 = powf(var_Y, 3);
  158. if(pow_3 > 0.008856F) {
  159. var_Y = pow_3;
  160. } else {
  161. var_Y = ( var_Y - 16.F / 116.F ) / 7.787F;
  162. }
  163. pow_3 = powf(var_X, 3);
  164. if(pow_3 > 0.008856F) {
  165. var_X = pow_3;
  166. } else {
  167. var_X = ( var_X - 16.F / 116.F ) / 7.787F;
  168. }
  169. pow_3 = powf(var_Z, 3);
  170. if(pow_3 > 0.008856F) {
  171. var_Z = pow_3;
  172. } else {
  173. var_Z = ( var_Z - 16.F / 116.F ) / 7.787F;
  174. }
  175. static const float ref_X = 95.047F;
  176. static const float ref_Y = 100.000F;
  177. static const float ref_Z = 108.883F;
  178. *X = ref_X * var_X; // ref_X = 95.047 (Observer= 2°, Illuminant= D65)
  179. *Y = ref_Y * var_Y; // ref_Y = 100.000
  180. *Z = ref_Z * var_Z; // ref_Z = 108.883
  181. }
  182. /**
  183. XYZ -> RGB conversion from http://www.easyrgb.com/
  184. */
  185. static void
  186. XYZToRGB(float X, float Y, float Z, float *R, float *G, float *B) {
  187. float var_X = X / 100; // X from 0 to 95.047 (Observer = 2°, Illuminant = D65)
  188. float var_Y = Y / 100; // Y from 0 to 100.000
  189. float var_Z = Z / 100; // Z from 0 to 108.883
  190. float var_R = var_X * 3.2406F + var_Y * -1.5372F + var_Z * -0.4986F;
  191. float var_G = var_X * -0.9689F + var_Y * 1.8758F + var_Z * 0.0415F;
  192. float var_B = var_X * 0.0557F + var_Y * -0.2040F + var_Z * 1.0570F;
  193. float exponent = 1.F / 2.4F;
  194. if(var_R > 0.0031308F) {
  195. var_R = 1.055F * powf(var_R, exponent) - 0.055F;
  196. } else {
  197. var_R = 12.92F * var_R;
  198. }
  199. if(var_G > 0.0031308F) {
  200. var_G = 1.055F * powf(var_G, exponent) - 0.055F;
  201. } else {
  202. var_G = 12.92F * var_G;
  203. }
  204. if(var_B > 0.0031308F) {
  205. var_B = 1.055F * powf(var_B, exponent) - 0.055F;
  206. } else {
  207. var_B = 12.92F * var_B;
  208. }
  209. *R = var_R;
  210. *G = var_G;
  211. *B = var_B;
  212. }
  213. template<class T>
  214. static void
  215. CIELabToRGB(float L, float a, float b, T *rgb) {
  216. float X, Y, Z;
  217. float R, G, B;
  218. const float max_val = std::numeric_limits<T>::max();
  219. CIELabToXYZ(L, a, b, &X, &Y, &Z);
  220. XYZToRGB(X, Y, Z, &R, &G, &B);
  221. // clamp values to [0..max_val]
  222. T red = (T)CLAMP(R * max_val, 0.0F, max_val);
  223. T green = (T)CLAMP(G * max_val, 0.0F, max_val);
  224. T blue = (T)CLAMP(B * max_val, 0.0F, max_val);
  225. assignRGB(red, green, blue, rgb);
  226. }
  227. template<class T>
  228. static void
  229. _convertLABtoRGB(unsigned width, unsigned height, BYTE* line_start, unsigned pitch, unsigned samplesperpixel) {
  230. const unsigned max_val = std::numeric_limits<T>::max();
  231. const float sL = 100.F / max_val;
  232. const float sa = 256.F / max_val;
  233. const float sb = 256.F / max_val;
  234. for(unsigned y = 0; y < height; y++) {
  235. T *line = (T*)line_start;
  236. for(unsigned x = 0; x < width; x++) {
  237. CIELabToRGB(line[0]* sL, line[1]* sa - 128.F, line[2]* sb - 128.F, line);
  238. line += samplesperpixel;
  239. }
  240. line_start += pitch;
  241. }
  242. }
  243. BOOL
  244. ConvertLABtoRGB(FIBITMAP* dib) {
  245. if(!FreeImage_HasPixels(dib)) {
  246. return FALSE;
  247. }
  248. const FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(dib);
  249. const unsigned bytesperpixel = FreeImage_GetBPP(dib) / 8;
  250. unsigned channelSize = 1;
  251. if (image_type == FIT_RGBA16 || image_type == FIT_RGB16) {
  252. channelSize = sizeof(WORD);
  253. } else if (!(image_type == FIT_BITMAP && (bytesperpixel > 2))) {
  254. return FALSE;
  255. }
  256. const unsigned width = FreeImage_GetWidth(dib);
  257. const unsigned height = FreeImage_GetHeight(dib);
  258. BYTE *line_start = FreeImage_GetScanLine(dib, 0);
  259. const unsigned pitch = FreeImage_GetPitch(dib);
  260. unsigned samplesperpixel = FreeImage_GetLine(dib) / width / channelSize;
  261. if(channelSize == 1) {
  262. _convertLABtoRGB<BYTE>(width, height, line_start, pitch, samplesperpixel);
  263. }
  264. else {
  265. _convertLABtoRGB<WORD>(width, height, line_start, pitch, samplesperpixel);
  266. }
  267. return TRUE;
  268. }
  269. // ----------------------------------------------------------
  270. FIBITMAP*
  271. RemoveAlphaChannel(FIBITMAP* src) {
  272. if(!FreeImage_HasPixels(src)) {
  273. return NULL;
  274. }
  275. const FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(src);
  276. switch(image_type) {
  277. case FIT_BITMAP:
  278. if(FreeImage_GetBPP(src) == 32) {
  279. // convert to 24-bit
  280. return FreeImage_ConvertTo24Bits(src);
  281. }
  282. break;
  283. case FIT_RGBA16:
  284. // convert to RGB16
  285. return FreeImage_ConvertToRGB16(src);
  286. case FIT_RGBAF:
  287. // convert to RGBF
  288. return FreeImage_ConvertToRGBF(src);
  289. default:
  290. // unsupported image type
  291. return NULL;
  292. }
  293. return NULL;
  294. }
  295. // ==========================================================
  296. FIBITMAP * DLL_CALLCONV
  297. FreeImage_ColorQuantize(FIBITMAP *dib, FREE_IMAGE_QUANTIZE quantize) {
  298. return FreeImage_ColorQuantizeEx(dib, quantize);
  299. }
  300. FIBITMAP * DLL_CALLCONV
  301. FreeImage_ColorQuantizeEx(FIBITMAP *dib, FREE_IMAGE_QUANTIZE quantize, int PaletteSize, int ReserveSize, RGBQUAD *ReservePalette) {
  302. if( PaletteSize < 2 ) PaletteSize = 2;
  303. if( PaletteSize > 256 ) PaletteSize = 256;
  304. if( ReserveSize < 0 ) ReserveSize = 0;
  305. if( ReserveSize > PaletteSize ) ReserveSize = PaletteSize;
  306. if (FreeImage_HasPixels(dib)) {
  307. if (FreeImage_GetBPP(dib) == 24) {
  308. switch(quantize) {
  309. case FIQ_WUQUANT :
  310. {
  311. try {
  312. WuQuantizer Q (dib);
  313. FIBITMAP *dst = Q.Quantize(PaletteSize, ReserveSize, ReservePalette);
  314. if(dst) {
  315. // copy metadata from src to dst
  316. FreeImage_CloneMetadata(dst, dib);
  317. }
  318. return dst;
  319. } catch (const char *) {
  320. return NULL;
  321. }
  322. }
  323. case FIQ_NNQUANT :
  324. {
  325. // sampling factor in range 1..30.
  326. // 1 => slower (but better), 30 => faster. Default value is 1
  327. const int sampling = 1;
  328. NNQuantizer Q(PaletteSize);
  329. FIBITMAP *dst = Q.Quantize(dib, ReserveSize, ReservePalette, sampling);
  330. if(dst) {
  331. // copy metadata from src to dst
  332. FreeImage_CloneMetadata(dst, dib);
  333. }
  334. return dst;
  335. }
  336. }
  337. }
  338. }
  339. return NULL;
  340. }
  341. // ==========================================================
  342. FIBITMAP * DLL_CALLCONV
  343. FreeImage_ConvertFromRawBits(BYTE *bits, int width, int height, int pitch, unsigned bpp, unsigned red_mask, unsigned green_mask, unsigned blue_mask, BOOL topdown) {
  344. FIBITMAP *dib = FreeImage_Allocate(width, height, bpp, red_mask, green_mask, blue_mask);
  345. if (dib != NULL) {
  346. if (topdown) {
  347. for (int i = height - 1; i >= 0; --i) {
  348. memcpy(FreeImage_GetScanLine(dib, i), bits, FreeImage_GetLine(dib));
  349. bits += pitch;
  350. }
  351. } else {
  352. for (int i = 0; i < height; ++i) {
  353. memcpy(FreeImage_GetScanLine(dib, i), bits, FreeImage_GetLine(dib));
  354. bits += pitch;
  355. }
  356. }
  357. }
  358. return dib;
  359. }
  360. void DLL_CALLCONV
  361. FreeImage_ConvertToRawBits(BYTE *bits, FIBITMAP *dib, int pitch, unsigned bpp, unsigned red_mask, unsigned green_mask, unsigned blue_mask, BOOL topdown) {
  362. if (FreeImage_HasPixels(dib) && (bits != NULL)) {
  363. for (unsigned i = 0; i < FreeImage_GetHeight(dib); ++i) {
  364. BYTE *scanline = FreeImage_GetScanLine(dib, topdown ? (FreeImage_GetHeight(dib) - i - 1) : i);
  365. if ((bpp == 16) && (FreeImage_GetBPP(dib) == 16)) {
  366. // convert 555 to 565 or vice versa
  367. if ((red_mask == FI16_555_RED_MASK) && (green_mask == FI16_555_GREEN_MASK) && (blue_mask == FI16_555_BLUE_MASK)) {
  368. if ((FreeImage_GetRedMask(dib) == FI16_565_RED_MASK) && (FreeImage_GetGreenMask(dib) == FI16_565_GREEN_MASK) && (FreeImage_GetBlueMask(dib) == FI16_565_BLUE_MASK)) {
  369. FreeImage_ConvertLine16_565_To16_555(bits, scanline, FreeImage_GetWidth(dib));
  370. } else {
  371. memcpy(bits, scanline, FreeImage_GetLine(dib));
  372. }
  373. } else {
  374. if ((FreeImage_GetRedMask(dib) == FI16_555_RED_MASK) && (FreeImage_GetGreenMask(dib) == FI16_555_GREEN_MASK) && (FreeImage_GetBlueMask(dib) == FI16_555_BLUE_MASK)) {
  375. FreeImage_ConvertLine16_555_To16_565(bits, scanline, FreeImage_GetWidth(dib));
  376. } else {
  377. memcpy(bits, scanline, FreeImage_GetLine(dib));
  378. }
  379. }
  380. } else if (FreeImage_GetBPP(dib) != bpp) {
  381. switch(FreeImage_GetBPP(dib)) {
  382. case 1 :
  383. switch(bpp) {
  384. CONVERT(1, 8)
  385. CONVERTTO16WITHPALETTE(1)
  386. CONVERTWITHPALETTE(1, 24)
  387. CONVERTWITHPALETTE(1, 32)
  388. }
  389. break;
  390. case 4 :
  391. switch(bpp) {
  392. CONVERT(4, 8)
  393. CONVERTTO16WITHPALETTE(4)
  394. CONVERTWITHPALETTE(4, 24)
  395. CONVERTWITHPALETTE(4, 32)
  396. }
  397. break;
  398. case 8 :
  399. switch(bpp) {
  400. CONVERTTO16WITHPALETTE(8)
  401. CONVERTWITHPALETTE(8, 24)
  402. CONVERTWITHPALETTE(8, 32)
  403. }
  404. break;
  405. case 24 :
  406. switch(bpp) {
  407. CONVERT(24, 8)
  408. CONVERTTO16(24)
  409. CONVERT(24, 32)
  410. }
  411. break;
  412. case 32 :
  413. switch(bpp) {
  414. CONVERT(32, 8)
  415. CONVERTTO16(32)
  416. CONVERT(32, 24)
  417. }
  418. break;
  419. }
  420. } else {
  421. memcpy(bits, scanline, FreeImage_GetLine(dib));
  422. }
  423. bits += pitch;
  424. }
  425. }
  426. }