img_pnm.c 4.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229
  1. /* PNM: P1/P2/P3 (ASCII) and P4/P5/P6 (binary), 8- or 16-bit samples. */
  2. #include "img_internal.h"
  3. struct pnm_reader {
  4. const unsigned char *d;
  5. unsigned int n, pos;
  6. };
  7. static int pnm_ws(struct pnm_reader *r)
  8. {
  9. for (;;) {
  10. while (r->pos < r->n) {
  11. unsigned char c = r->d[r->pos];
  12. if (c == ' ' || c == '\t' || c == '\r' || c == '\n' ||
  13. c == '\f' || c == '\v') {
  14. r->pos++;
  15. } else {
  16. break;
  17. }
  18. }
  19. if (r->pos < r->n && r->d[r->pos] == '#') {
  20. while (r->pos < r->n && r->d[r->pos] != '\n')
  21. r->pos++;
  22. continue;
  23. }
  24. return r->pos < r->n ? 0 : -1;
  25. }
  26. }
  27. static int pnm_uint(struct pnm_reader *r, unsigned int *out)
  28. {
  29. unsigned int v = 0;
  30. int any = 0;
  31. if (pnm_ws(r))
  32. return -1;
  33. while (r->pos < r->n) {
  34. unsigned char c = r->d[r->pos];
  35. if (c < '0' || c > '9')
  36. break;
  37. v = v * 10 + (c - '0');
  38. if (v > 0x7FFFFFFF)
  39. return -1;
  40. r->pos++;
  41. any = 1;
  42. }
  43. if (!any)
  44. return -1;
  45. *out = v;
  46. return 0;
  47. }
  48. static int pnm_header(const unsigned char *d, unsigned int n,
  49. unsigned int *kind, unsigned int *w, unsigned int *h,
  50. unsigned int *maxval, unsigned int *hdr_end)
  51. {
  52. struct pnm_reader r;
  53. if (n < 2 || d[0] != 'P' || d[1] < '1' || d[1] > '6')
  54. return -1;
  55. r.d = d;
  56. r.n = n;
  57. r.pos = 2;
  58. *kind = (unsigned int)(d[1] - '0');
  59. if (pnm_uint(&r, w) || pnm_uint(&r, h))
  60. return -1;
  61. if (*kind == 1 || *kind == 4) {
  62. *maxval = 1;
  63. } else if (pnm_uint(&r, maxval) || *maxval == 0 || *maxval > 65535) {
  64. return -1;
  65. }
  66. if (*w == 0 || *h == 0 || *w > 32768 || *h > 32768)
  67. return -1;
  68. /* Binary formats have exactly one whitespace byte after the header
  69. * (it may not be skipped like ASCII separators: a pixel may itself be
  70. * a whitespace value). */
  71. if (*kind >= 4) {
  72. unsigned char c;
  73. if (r.pos >= r.n)
  74. return -1;
  75. c = r.d[r.pos];
  76. if (c != ' ' && c != '\t' && c != '\r' && c != '\n' &&
  77. c != '\f' && c != '\v')
  78. return -1;
  79. r.pos++;
  80. if (c == '\r' && r.pos < r.n && r.d[r.pos] == '\n')
  81. r.pos++; /* tolerate CRLF */
  82. } else {
  83. if (pnm_ws(&r))
  84. return -1;
  85. }
  86. *hdr_end = r.pos;
  87. return 0;
  88. }
  89. int img_sniff_pnm(const unsigned char *d, unsigned int n, struct img_info *out)
  90. {
  91. unsigned int kind, w, h, mv, end;
  92. if (pnm_header(d, n, &kind, &w, &h, &mv, &end))
  93. return IMG_FMT_UNKNOWN;
  94. out->format = IMG_FMT_PNM;
  95. out->width = w;
  96. out->height = h;
  97. out->has_alpha = 0;
  98. return IMG_FMT_PNM;
  99. }
  100. static unsigned int pnm_scale(unsigned int v, unsigned int mv)
  101. {
  102. if (mv == 255)
  103. return v;
  104. if (mv == 1)
  105. return v ? 255 : 0;
  106. return (v * 255u + mv / 2) / mv;
  107. }
  108. static int pnm_ascii_sample(struct pnm_reader *r, unsigned int mv,
  109. unsigned int *out)
  110. {
  111. unsigned int v;
  112. if (pnm_uint(r, &v))
  113. return -1;
  114. if (v > mv)
  115. return -1;
  116. *out = pnm_scale(v, mv);
  117. return 0;
  118. }
  119. int img_decode_pnm(const unsigned char *d, unsigned int n,
  120. const struct img_options *opt, struct img_mem *m,
  121. struct img_image *out)
  122. {
  123. unsigned int kind, w, h, mv, end;
  124. struct pnm_reader r;
  125. unsigned int x, y;
  126. unsigned int maxv;
  127. int rcode;
  128. if (pnm_header(d, n, &kind, &w, &h, &mv, &end))
  129. return IMG_ERR_FORMAT;
  130. if (!img_size_ok(w, h, opt))
  131. return IMG_ERR_TOOBIG;
  132. r.d = d;
  133. r.n = n;
  134. r.pos = end;
  135. maxv = mv;
  136. rcode = img_alloc(m, w, h, IMG_FMT_PNM, 0, out);
  137. if (rcode)
  138. return rcode;
  139. if (kind == 4) {
  140. unsigned int stride = (w + 7) / 8;
  141. if (end > n || (unsigned long long)stride * h > n - end)
  142. return IMG_ERR_CORRUPT;
  143. for (y = 0; y < h; y++) {
  144. const unsigned char *row = d + end + y * stride;
  145. for (x = 0; x < w; x++) {
  146. unsigned int bit = (row[x / 8] >> (7 - (x & 7))) & 1;
  147. out->px[y * w + x] = bit ? 0 : 0xFFFF;
  148. }
  149. }
  150. return 0;
  151. }
  152. for (y = 0; y < h; y++) {
  153. for (x = 0; x < w; x++) {
  154. unsigned int rr, gg, bb;
  155. if (kind == 1) {
  156. if (pnm_ascii_sample(&r, 1, &rr))
  157. return IMG_ERR_CORRUPT;
  158. gg = bb = rr;
  159. } else if (kind == 2 || kind == 5) {
  160. if (kind == 2) {
  161. if (pnm_ascii_sample(&r, maxv, &rr))
  162. return IMG_ERR_CORRUPT;
  163. } else {
  164. if (maxv < 256) {
  165. if (r.pos >= n)
  166. return IMG_ERR_CORRUPT;
  167. rr = pnm_scale(d[r.pos++], maxv);
  168. } else {
  169. if (r.pos + 2 > n)
  170. return IMG_ERR_CORRUPT;
  171. rr = pnm_scale(img_be16(d + r.pos), maxv);
  172. r.pos += 2;
  173. }
  174. }
  175. gg = bb = rr;
  176. } else {
  177. if (kind == 3) {
  178. if (pnm_ascii_sample(&r, maxv, &rr) ||
  179. pnm_ascii_sample(&r, maxv, &gg) ||
  180. pnm_ascii_sample(&r, maxv, &bb))
  181. return IMG_ERR_CORRUPT;
  182. } else {
  183. unsigned int c[3], k;
  184. for (k = 0; k < 3; k++) {
  185. if (maxv < 256) {
  186. if (r.pos >= n)
  187. return IMG_ERR_CORRUPT;
  188. c[k] = pnm_scale(d[r.pos++], maxv);
  189. } else {
  190. if (r.pos + 2 > n)
  191. return IMG_ERR_CORRUPT;
  192. c[k] = pnm_scale(img_be16(d + r.pos), maxv);
  193. r.pos += 2;
  194. }
  195. }
  196. rr = c[0];
  197. gg = c[1];
  198. bb = c[2];
  199. }
  200. }
  201. out->px[y * w + x] = img_rgb565(rr, gg, bb);
  202. }
  203. }
  204. return 0;
  205. }