img_bmp.c 8.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355
  1. /* BMP: Windows/OS2 bitmaps. 1/4/8/16/24/32 bpp, BI_RGB, BI_BITFIELDS,
  2. * BI_RLE8/BI_RLE4, top-down and bottom-up rows. */
  3. #include "img_internal.h"
  4. static int bmp_info(const unsigned char *d, unsigned int n,
  5. unsigned int *w, unsigned int *h, unsigned int *bpp,
  6. unsigned int *comp, unsigned int *dib, int *topdown,
  7. unsigned int *off, unsigned int *colors)
  8. {
  9. unsigned int height;
  10. if (n < 26 || d[0] != 'B' || d[1] != 'M')
  11. return -1;
  12. *off = img_le32(d + 10);
  13. *dib = img_le32(d + 14);
  14. if (*dib < 12 || 14u + *dib > n)
  15. return -1;
  16. if (*dib == 12) {
  17. if (n < 26)
  18. return -1;
  19. *w = img_le16(d + 18);
  20. height = img_le16(d + 20);
  21. *bpp = img_le16(d + 24);
  22. *comp = 0;
  23. *colors = 0;
  24. } else {
  25. if (n < 34)
  26. return -1;
  27. *w = img_le32(d + 18);
  28. height = img_le32(d + 22);
  29. *bpp = img_le16(d + 28);
  30. *comp = img_le32(d + 30);
  31. *colors = img_le32(d + 46);
  32. }
  33. *topdown = ((int)height < 0);
  34. *h = *topdown ? (unsigned int)(-(int)height) : height;
  35. if (*w == 0 || *w > 32768 || *h == 0 || *h > 32768)
  36. return -1;
  37. if (*bpp != 1 && *bpp != 4 && *bpp != 8 && *bpp != 16 &&
  38. *bpp != 24 && *bpp != 32)
  39. return -1;
  40. if (*comp != 0 && *comp != 1 && *comp != 2 && *comp != 3 &&
  41. *comp != 6)
  42. return -1;
  43. return 0;
  44. }
  45. int img_sniff_bmp(const unsigned char *d, unsigned int n, struct img_info *out)
  46. {
  47. unsigned int w, h, bpp, comp, dib, off, colors;
  48. int topdown;
  49. if (bmp_info(d, n, &w, &h, &bpp, &comp, &dib, &topdown, &off,
  50. &colors) != 0)
  51. return IMG_FMT_UNKNOWN;
  52. (void)topdown;
  53. out->format = IMG_FMT_BMP;
  54. out->width = w;
  55. out->height = h;
  56. out->has_alpha = 0;
  57. if (bpp == 32) {
  58. unsigned int amask = 0;
  59. if (dib >= 108 && n >= 14 + 108)
  60. amask = img_le32(d + 14 + 66);
  61. else if (comp == 6 && dib == 40) {
  62. if (n >= 14 + 40 + 16)
  63. amask = img_le32(d + 14 + 40 + 12);
  64. }
  65. out->has_alpha = amask != 0;
  66. }
  67. return IMG_FMT_BMP;
  68. }
  69. static unsigned int mask_shift(unsigned int mask)
  70. {
  71. unsigned int s = 0;
  72. if (!mask)
  73. return 0;
  74. while (!(mask & 1)) {
  75. mask >>= 1;
  76. s++;
  77. }
  78. return s;
  79. }
  80. static unsigned int mask_max(unsigned int mask)
  81. {
  82. unsigned int s = mask_shift(mask);
  83. return mask >> s;
  84. }
  85. static unsigned int mask_scale(unsigned int v, unsigned int mask)
  86. {
  87. unsigned int max = mask_max(mask);
  88. unsigned int val;
  89. if (!mask || !max)
  90. return 0;
  91. val = (v & mask) >> mask_shift(mask);
  92. if (max == 255)
  93. return val;
  94. return (val * 255u + max / 2) / max;
  95. }
  96. static void put565(struct img_image *im, unsigned int x, unsigned int y,
  97. unsigned int r, unsigned int g, unsigned int b,
  98. unsigned int a)
  99. {
  100. unsigned int i;
  101. if (x >= im->w || y >= im->h)
  102. return;
  103. i = y * im->w + x;
  104. im->px[i] = img_rgb565(r, g, b);
  105. if (im->alpha)
  106. im->alpha[i] = (unsigned char)a;
  107. }
  108. int img_decode_bmp(const unsigned char *d, unsigned int n,
  109. const struct img_options *opt, struct img_mem *m,
  110. struct img_image *out)
  111. {
  112. unsigned int w, h, bpp, comp, dib, off, colors;
  113. unsigned int stride, pal_off, pal_entries, pal_size = 4;
  114. unsigned int rmask = 0, gmask = 0, bmask = 0, amask = 0;
  115. unsigned int i, x, y;
  116. int topdown, alpha;
  117. unsigned char pal[256][3];
  118. unsigned int pal_a[256];
  119. int r;
  120. if (bmp_info(d, n, &w, &h, &bpp, &comp, &dib, &topdown, &off,
  121. &colors) != 0)
  122. return IMG_ERR_FORMAT;
  123. if (!img_size_ok(w, h, opt))
  124. return IMG_ERR_TOOBIG;
  125. if (dib == 12)
  126. pal_size = 3;
  127. if (bpp == 16) {
  128. if ((comp == 3 || comp == 6)) {
  129. unsigned int mo = 14 + dib;
  130. if (dib == 40)
  131. mo = 14 + 40;
  132. else if (dib >= 108)
  133. mo = 14 + 40; /* masks live in the DIB */
  134. if (mo + 12 > n)
  135. return IMG_ERR_CORRUPT;
  136. rmask = img_le32(d + mo);
  137. gmask = img_le32(d + mo + 4);
  138. bmask = img_le32(d + mo + 8);
  139. if (comp == 6 || (dib >= 52 && mo + 16 <= n))
  140. amask = img_le32(d + mo + 12);
  141. } else {
  142. rmask = 0x7C00;
  143. gmask = 0x03E0;
  144. bmask = 0x001F;
  145. }
  146. } else if (bpp == 32) {
  147. if (dib >= 108) {
  148. rmask = img_le32(d + 14 + 40);
  149. gmask = img_le32(d + 14 + 44);
  150. bmask = img_le32(d + 14 + 48);
  151. amask = img_le32(d + 14 + 56);
  152. } else if (comp == 3 || comp == 6) {
  153. unsigned int mo = 14 + dib;
  154. if (mo + 12 > n)
  155. return IMG_ERR_CORRUPT;
  156. rmask = img_le32(d + mo);
  157. gmask = img_le32(d + mo + 4);
  158. bmask = img_le32(d + mo + 8);
  159. if (comp == 6 && mo + 16 <= n)
  160. amask = img_le32(d + mo + 12);
  161. }
  162. if (!rmask && !gmask && !bmask) {
  163. rmask = 0x00FF0000;
  164. gmask = 0x0000FF00;
  165. bmask = 0x000000FF;
  166. }
  167. }
  168. alpha = (bpp == 32 && amask != 0);
  169. pal_off = 14 + dib;
  170. pal_entries = 0;
  171. if (bpp <= 8) {
  172. pal_entries = colors ? colors : (1u << bpp);
  173. if (pal_entries > 256)
  174. pal_entries = 256;
  175. if (pal_off + pal_entries * pal_size > n)
  176. return IMG_ERR_CORRUPT;
  177. for (i = 0; i < pal_entries; i++) {
  178. const unsigned char *p = d + pal_off + i * pal_size;
  179. pal[i][0] = p[2];
  180. pal[i][1] = p[1];
  181. pal[i][2] = p[0];
  182. pal_a[i] = 255;
  183. }
  184. }
  185. r = img_alloc(m, w, h, IMG_FMT_BMP, alpha, out);
  186. if (r)
  187. return r;
  188. if (comp == 1 || comp == 2) {
  189. unsigned int px = 0, py = 0;
  190. unsigned int pos = off;
  191. if (bpp != 8 && bpp != 4)
  192. return IMG_ERR_UNSUPPORTED;
  193. if (topdown)
  194. return IMG_ERR_UNSUPPORTED;
  195. while (pos + 1 < n) {
  196. unsigned int a = d[pos++], b = d[pos++];
  197. if (a == 0) {
  198. if (b == 0) {
  199. px = 0;
  200. py++;
  201. continue;
  202. }
  203. if (b == 1)
  204. break;
  205. if (b == 2) {
  206. if (pos + 2 > n)
  207. return IMG_ERR_CORRUPT;
  208. px += d[pos++];
  209. py += d[pos++];
  210. continue;
  211. }
  212. /* absolute mode */
  213. {
  214. unsigned int cnt = b;
  215. unsigned int k;
  216. if (bpp == 8) {
  217. if (pos + cnt > n)
  218. return IMG_ERR_CORRUPT;
  219. for (k = 0; k < cnt; k++) {
  220. unsigned int idx = d[pos++];
  221. if (idx < pal_entries)
  222. put565(out, px + k,
  223. h - 1 - py,
  224. pal[idx][0],
  225. pal[idx][1],
  226. pal[idx][2],
  227. pal_a[idx]);
  228. }
  229. if ((cnt & 1) && pos < n)
  230. pos++;
  231. } else {
  232. unsigned int bytes = (cnt + 1) / 2;
  233. if (pos + bytes > n)
  234. return IMG_ERR_CORRUPT;
  235. for (k = 0; k < cnt; k++) {
  236. unsigned int idx = (k & 1) ?
  237. (d[pos + k / 2] & 15) :
  238. (d[pos + k / 2] >> 4);
  239. if (idx < pal_entries)
  240. put565(out, px + k,
  241. h - 1 - py,
  242. pal[idx][0],
  243. pal[idx][1],
  244. pal[idx][2],
  245. pal_a[idx]);
  246. }
  247. pos += bytes;
  248. if (bytes & 1)
  249. pos++;
  250. }
  251. px += cnt;
  252. }
  253. continue;
  254. }
  255. /* encoded run */
  256. {
  257. unsigned int k;
  258. for (k = 0; k < a; k++) {
  259. unsigned int idx = b;
  260. if (bpp == 4)
  261. idx = (k & 1) ? (b & 15) : (b >> 4);
  262. if (idx < pal_entries)
  263. put565(out, px + k,
  264. h - 1 - py,
  265. pal[idx][0],
  266. pal[idx][1],
  267. pal[idx][2],
  268. pal_a[idx]);
  269. }
  270. px += a;
  271. }
  272. }
  273. return 0;
  274. }
  275. stride = ((w * bpp + 31u) / 32u) * 4u;
  276. if (off > n || stride > n - off ||
  277. (unsigned long long)stride * h > (unsigned long long)(n - off))
  278. return IMG_ERR_CORRUPT;
  279. for (y = 0; y < h; y++) {
  280. const unsigned char *row = d + off + (topdown ? y : (h - 1 - y)) * stride;
  281. for (x = 0; x < w; x++) {
  282. unsigned int rr, gg, bb, aa = 255;
  283. if (bpp <= 8) {
  284. unsigned int idx;
  285. if (bpp == 8)
  286. idx = row[x];
  287. else if (bpp == 4)
  288. idx = (row[x / 2] >> ((x & 1) ? 0 : 4)) & 15;
  289. else
  290. idx = (row[x / 8] >> (7 - (x & 7))) & 1;
  291. if (idx >= pal_entries)
  292. idx = 0;
  293. rr = pal[idx][0];
  294. gg = pal[idx][1];
  295. bb = pal[idx][2];
  296. aa = pal_a[idx];
  297. } else if (bpp == 16) {
  298. unsigned int v = img_le16(row + x * 2);
  299. rr = mask_scale(v, rmask);
  300. gg = mask_scale(v, gmask);
  301. bb = mask_scale(v, bmask);
  302. if (amask)
  303. aa = mask_scale(v, amask);
  304. } else if (bpp == 24) {
  305. const unsigned char *p = row + x * 3;
  306. bb = p[0];
  307. gg = p[1];
  308. rr = p[2];
  309. } else {
  310. unsigned int v = img_le32(row + x * 4);
  311. if (rmask) {
  312. rr = mask_scale(v, rmask);
  313. gg = mask_scale(v, gmask);
  314. bb = mask_scale(v, bmask);
  315. } else {
  316. bb = v & 255;
  317. gg = (v >> 8) & 255;
  318. rr = (v >> 16) & 255;
  319. }
  320. if (alpha)
  321. aa = mask_scale(v, amask);
  322. }
  323. put565(out, x, y, rr, gg, bb, aa);
  324. }
  325. }
  326. return 0;
  327. }