img_jpeg.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905
  1. /* JPEG: baseline and extended-sequential 8-bit Huffman JPEG.
  2. *
  3. * Progressive/arithmetic JPEG and CMYK are rejected with IMG_ERR_UNSUPPORTED.
  4. * Decoding uses full component planes (Y full size, chroma subsampled), which
  5. * keeps the code simple and still fits the viewer's arena for normal photos. */
  6. #include "img_internal.h"
  7. #ifdef IMG_HOST_DEBUG
  8. #include <stdio.h>
  9. #define DBG(...) fprintf(stderr, __VA_ARGS__)
  10. #else
  11. #define DBG(...) do { } while (0)
  12. #endif
  13. static const unsigned char zigzag[64] = {
  14. 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5,
  15. 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28,
  16. 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
  17. 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
  18. };
  19. #define CONST_BITS 13
  20. #define PASS1_BITS 2
  21. #define FIX_0_298631336 2446
  22. #define FIX_0_390180644 3196
  23. #define FIX_0_541196100 4433
  24. #define FIX_0_765366865 6270
  25. #define FIX_0_899976223 7373
  26. #define FIX_1_175875602 9633
  27. #define FIX_1_501321110 12299
  28. #define FIX_1_847759065 15137
  29. #define FIX_1_961570560 16069
  30. #define FIX_2_053119869 16819
  31. #define FIX_2_562915447 20995
  32. #define FIX_3_072711026 25172
  33. static int descale(int x, int n)
  34. {
  35. return (x + (1 << (n - 1))) >> n;
  36. }
  37. static void idct_block(const int *in, unsigned char *out)
  38. {
  39. int ws[64];
  40. int i, n;
  41. for (i = 0; i < 8; i++) {
  42. if (in[8 + i] == 0 && in[16 + i] == 0 && in[24 + i] == 0 &&
  43. in[32 + i] == 0 && in[40 + i] == 0 && in[48 + i] == 0 &&
  44. in[56 + i] == 0) {
  45. int dc = in[i] * (1 << PASS1_BITS);
  46. for (n = 0; n < 8; n++)
  47. ws[i + n * 8] = dc;
  48. continue;
  49. }
  50. {
  51. int z1, z2, z3, z4, z5;
  52. int tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13;
  53. z2 = in[16 + i];
  54. z3 = in[48 + i];
  55. z1 = (z2 + z3) * FIX_0_541196100;
  56. tmp2 = z1 + z3 * -FIX_1_847759065;
  57. tmp3 = z1 + z2 * FIX_0_765366865;
  58. z2 = in[i];
  59. z3 = in[32 + i];
  60. tmp0 = (z2 + z3) * (1 << CONST_BITS);
  61. tmp1 = (z2 - z3) * (1 << CONST_BITS);
  62. tmp10 = tmp0 + tmp3;
  63. tmp13 = tmp0 - tmp3;
  64. tmp11 = tmp1 + tmp2;
  65. tmp12 = tmp1 - tmp2;
  66. tmp0 = in[56 + i];
  67. tmp1 = in[40 + i];
  68. tmp2 = in[24 + i];
  69. tmp3 = in[8 + i];
  70. z1 = tmp0 + tmp3;
  71. z2 = tmp1 + tmp2;
  72. z3 = tmp0 + tmp2;
  73. z4 = tmp1 + tmp3;
  74. z5 = (z3 + z4) * FIX_1_175875602;
  75. tmp0 *= FIX_0_298631336;
  76. tmp1 *= FIX_2_053119869;
  77. tmp2 *= FIX_3_072711026;
  78. tmp3 *= FIX_1_501321110;
  79. z1 *= -FIX_0_899976223;
  80. z2 *= -FIX_2_562915447;
  81. z3 *= -FIX_1_961570560;
  82. z4 *= -FIX_0_390180644;
  83. z3 += z5;
  84. z4 += z5;
  85. tmp0 += z1 + z3;
  86. tmp1 += z2 + z4;
  87. tmp2 += z2 + z3;
  88. tmp3 += z1 + z4;
  89. ws[i + 0 * 8] = descale(tmp10 + tmp3, CONST_BITS - PASS1_BITS);
  90. ws[i + 7 * 8] = descale(tmp10 - tmp3, CONST_BITS - PASS1_BITS);
  91. ws[i + 1 * 8] = descale(tmp11 + tmp2, CONST_BITS - PASS1_BITS);
  92. ws[i + 6 * 8] = descale(tmp11 - tmp2, CONST_BITS - PASS1_BITS);
  93. ws[i + 2 * 8] = descale(tmp12 + tmp1, CONST_BITS - PASS1_BITS);
  94. ws[i + 5 * 8] = descale(tmp12 - tmp1, CONST_BITS - PASS1_BITS);
  95. ws[i + 3 * 8] = descale(tmp13 + tmp0, CONST_BITS - PASS1_BITS);
  96. ws[i + 4 * 8] = descale(tmp13 - tmp0, CONST_BITS - PASS1_BITS);
  97. }
  98. }
  99. for (i = 0; i < 8; i++) {
  100. int *w = ws + i * 8;
  101. if (w[1] == 0 && w[2] == 0 && w[3] == 0 && w[4] == 0 &&
  102. w[5] == 0 && w[6] == 0 && w[7] == 0) {
  103. int dc = descale(w[0], PASS1_BITS + 3) + 128;
  104. if (dc < 0) dc = 0;
  105. if (dc > 255) dc = 255;
  106. for (n = 0; n < 8; n++)
  107. out[i * 8 + n] = (unsigned char)dc;
  108. continue;
  109. }
  110. {
  111. int z1, z2, z3, z4, z5;
  112. int tmp0, tmp1, tmp2, tmp3, tmp10, tmp11, tmp12, tmp13;
  113. z2 = w[2];
  114. z3 = w[6];
  115. z1 = (z2 + z3) * FIX_0_541196100;
  116. tmp2 = z1 + z3 * -FIX_1_847759065;
  117. tmp3 = z1 + z2 * FIX_0_765366865;
  118. tmp0 = (w[0] + w[4]) * (1 << CONST_BITS);
  119. tmp1 = (w[0] - w[4]) * (1 << CONST_BITS);
  120. tmp10 = tmp0 + tmp3;
  121. tmp13 = tmp0 - tmp3;
  122. tmp11 = tmp1 + tmp2;
  123. tmp12 = tmp1 - tmp2;
  124. tmp0 = w[7];
  125. tmp1 = w[5];
  126. tmp2 = w[3];
  127. tmp3 = w[1];
  128. z1 = tmp0 + tmp3;
  129. z2 = tmp1 + tmp2;
  130. z3 = tmp0 + tmp2;
  131. z4 = tmp1 + tmp3;
  132. z5 = (z3 + z4) * FIX_1_175875602;
  133. tmp0 *= FIX_0_298631336;
  134. tmp1 *= FIX_2_053119869;
  135. tmp2 *= FIX_3_072711026;
  136. tmp3 *= FIX_1_501321110;
  137. z1 *= -FIX_0_899976223;
  138. z2 *= -FIX_2_562915447;
  139. z3 *= -FIX_1_961570560;
  140. z4 *= -FIX_0_390180644;
  141. z3 += z5;
  142. z4 += z5;
  143. tmp0 += z1 + z3;
  144. tmp1 += z2 + z4;
  145. tmp2 += z2 + z3;
  146. tmp3 += z1 + z4;
  147. #define PUT(idx, val) do { \
  148. int v = descale((val), CONST_BITS + PASS1_BITS + 3) + 128; \
  149. if (v < 0) v = 0; \
  150. if (v > 255) v = 255; \
  151. out[i * 8 + (idx)] = (unsigned char)v; \
  152. } while (0)
  153. PUT(0, tmp10 + tmp3);
  154. PUT(7, tmp10 - tmp3);
  155. PUT(1, tmp11 + tmp2);
  156. PUT(6, tmp11 - tmp2);
  157. PUT(2, tmp12 + tmp1);
  158. PUT(5, tmp12 - tmp1);
  159. PUT(3, tmp13 + tmp0);
  160. PUT(4, tmp13 - tmp0);
  161. #undef PUT
  162. }
  163. }
  164. }
  165. struct jpeg_huff {
  166. unsigned char bits[17];
  167. unsigned char vals[256];
  168. int mincode[17];
  169. int maxcode[18];
  170. int valptr[17];
  171. int total;
  172. };
  173. struct jpeg_comp {
  174. unsigned char id, h, v, tq;
  175. int td, ta;
  176. unsigned char *plane;
  177. unsigned int pw, ph;
  178. int dc;
  179. };
  180. struct jpeg {
  181. const unsigned char *d;
  182. unsigned int n, pos;
  183. unsigned int w, h;
  184. unsigned int ncomp;
  185. struct jpeg_comp comp[3];
  186. unsigned int max_h, max_v;
  187. unsigned int mcus_x, mcus_y;
  188. unsigned char qt[4][64]; /* zigzag order */
  189. struct jpeg_huff dc[4], ac[4];
  190. unsigned int restart;
  191. unsigned int rst_next;
  192. unsigned int bitbuf;
  193. int bitcnt;
  194. unsigned int marker;
  195. int eof;
  196. #ifdef IMG_HOST_DEBUG
  197. unsigned int dbg;
  198. #endif
  199. };
  200. static int jpeg_u8(struct jpeg *j, unsigned int *v)
  201. {
  202. if (j->pos >= j->n)
  203. return -1;
  204. *v = j->d[j->pos++];
  205. return 0;
  206. }
  207. static int jpeg_u16(struct jpeg *j, unsigned int *v)
  208. {
  209. unsigned int a, b;
  210. if (jpeg_u8(j, &a) || jpeg_u8(j, &b))
  211. return -1;
  212. *v = (a << 8) | b;
  213. return 0;
  214. }
  215. static int jpeg_marker(struct jpeg *j)
  216. {
  217. if (j->pos >= j->n || j->d[j->pos++] != 0xFF)
  218. return -1;
  219. while (j->pos < j->n && j->d[j->pos] == 0xFF)
  220. j->pos++;
  221. if (j->pos >= j->n)
  222. return -1;
  223. return (int)j->d[j->pos++];
  224. }
  225. static int huff_build(struct jpeg_huff *h, const unsigned int *counts,
  226. const unsigned char *vals)
  227. {
  228. int code = 0, k = 0, l, total = 0;
  229. for (l = 1; l <= 16; l++) {
  230. h->bits[l] = (unsigned char)counts[l - 1];
  231. total += (int)counts[l - 1];
  232. }
  233. h->total = 0;
  234. if (total > 256)
  235. return -1;
  236. for (l = 0; l < total; l++)
  237. h->vals[l] = vals[l];
  238. {
  239. int left = 1;
  240. for (l = 1; l <= 16; l++) {
  241. left <<= 1;
  242. left -= (int)counts[l - 1];
  243. if (left < 0)
  244. return -1;
  245. }
  246. }
  247. k = 0;
  248. for (l = 1; l <= 16; l++) {
  249. if (h->bits[l]) {
  250. h->valptr[l] = k;
  251. h->mincode[l] = code;
  252. code += h->bits[l];
  253. h->maxcode[l] = code - 1;
  254. k += h->bits[l];
  255. } else {
  256. h->valptr[l] = 0;
  257. h->mincode[l] = 0;
  258. h->maxcode[l] = -1;
  259. }
  260. code <<= 1;
  261. }
  262. h->maxcode[17] = 0x7FFFFFFF;
  263. h->total = total;
  264. return 0;
  265. }
  266. static int huff_decode(struct jpeg *j, const struct jpeg_huff *h)
  267. {
  268. int code = 0, l;
  269. if (h->total <= 0)
  270. return -1;
  271. for (l = 1; l <= 16; l++) {
  272. int b;
  273. if (j->bitcnt == 0) {
  274. unsigned int v;
  275. if (j->pos >= j->n)
  276. return -1;
  277. v = j->d[j->pos++];
  278. if (v == 0xFF) {
  279. unsigned int v2;
  280. if (j->pos >= j->n)
  281. return -1;
  282. v2 = j->d[j->pos++];
  283. if (v2 != 0x00) {
  284. j->marker = 0xFF00 | v2;
  285. return -1;
  286. }
  287. v = 0xFF;
  288. }
  289. j->bitbuf = v;
  290. j->bitcnt = 8;
  291. }
  292. b = (int)((j->bitbuf >> (j->bitcnt - 1)) & 1);
  293. j->bitcnt--;
  294. code = (code << 1) | b;
  295. if (h->maxcode[l] >= 0 && code >= h->mincode[l] &&
  296. code <= h->maxcode[l]) {
  297. int idx = h->valptr[l] + code - h->mincode[l];
  298. if (idx < 0 || idx >= h->total)
  299. return -1;
  300. return h->vals[idx];
  301. }
  302. }
  303. return -1;
  304. }
  305. static int jpeg_bits(struct jpeg *j, int n)
  306. {
  307. int v = 0;
  308. while (n--) {
  309. int b;
  310. if (j->bitcnt == 0) {
  311. unsigned int x;
  312. if (j->pos >= j->n)
  313. return -1;
  314. x = j->d[j->pos++];
  315. if (x == 0xFF) {
  316. unsigned int x2;
  317. if (j->pos >= j->n)
  318. return -1;
  319. x2 = j->d[j->pos++];
  320. if (x2 != 0x00) {
  321. j->marker = 0xFF00 | x2;
  322. return -1;
  323. }
  324. x = 0xFF;
  325. }
  326. j->bitbuf = x;
  327. j->bitcnt = 8;
  328. }
  329. b = (int)((j->bitbuf >> (j->bitcnt - 1)) & 1);
  330. j->bitcnt--;
  331. v = (v << 1) | b;
  332. }
  333. return v;
  334. }
  335. static int jpeg_extend(int v, int n)
  336. {
  337. if (n == 0)
  338. return 0;
  339. return (v < (1 << (n - 1))) ? v - (1 << n) + 1 : v;
  340. }
  341. static int jpeg_restart(struct jpeg *j)
  342. {
  343. j->bitcnt = 0;
  344. while (j->pos + 1 < j->n) {
  345. if (j->d[j->pos] == 0xFF && j->d[j->pos + 1] != 0x00) {
  346. unsigned int m = j->d[j->pos + 1];
  347. j->pos += 2;
  348. if (m == 0xD0 + (j->rst_next & 7)) {
  349. j->rst_next++;
  350. return 0;
  351. }
  352. return -1;
  353. }
  354. j->pos++;
  355. }
  356. return -1;
  357. }
  358. /* Bilinear chroma sample at a fixed-point position (16.16) in the component
  359. * plane. The half-sample offset keeps the chroma centred on its luma block. */
  360. static int jpeg_chroma(const struct jpeg_comp *c, int posx, int posy)
  361. {
  362. int x0, y0, x1, y1, fx, fy;
  363. int v00, v10, v01, v11;
  364. if (posx < 0) {
  365. x0 = x1 = 0;
  366. fx = 0;
  367. } else {
  368. x0 = posx >> 16;
  369. fx = posx & 65535;
  370. if (x0 >= (int)c->pw) {
  371. x0 = x1 = (int)c->pw - 1;
  372. fx = 0;
  373. } else {
  374. x1 = x0 + 1;
  375. if (x1 >= (int)c->pw)
  376. x1 = (int)c->pw - 1;
  377. }
  378. }
  379. if (posy < 0) {
  380. y0 = y1 = 0;
  381. fy = 0;
  382. } else {
  383. y0 = posy >> 16;
  384. fy = posy & 65535;
  385. if (y0 >= (int)c->ph) {
  386. y0 = y1 = (int)c->ph - 1;
  387. fy = 0;
  388. } else {
  389. y1 = y0 + 1;
  390. if (y1 >= (int)c->ph)
  391. y1 = (int)c->ph - 1;
  392. }
  393. }
  394. v00 = c->plane[y0 * c->pw + x0];
  395. v10 = c->plane[y0 * c->pw + x1];
  396. v01 = c->plane[y1 * c->pw + x0];
  397. v11 = c->plane[y1 * c->pw + x1];
  398. return ((v00 * (65536 - fx) + v10 * fx) >> 16) * (65536 - fy) / 65536 +
  399. ((v01 * (65536 - fx) + v11 * fx) >> 16) * fy / 65536;
  400. }
  401. static int jpeg_block(struct jpeg *j, struct jpeg_comp *c, int *blk)
  402. {
  403. const unsigned char *q = j->qt[c->tq];
  404. int k, t;
  405. for (k = 0; k < 64; k++)
  406. blk[k] = 0;
  407. t = huff_decode(j, &j->dc[c->td]);
  408. #ifdef IMG_HOST_DEBUG
  409. if (j->dbg < 4)
  410. DBG("jpeg block comp %u dc t=%d pos=%u bitcnt=%d\n",
  411. c->id, t, j->pos, j->bitcnt);
  412. j->dbg++;
  413. #endif
  414. if (t < 0 || t > 15)
  415. return -1;
  416. if (t) {
  417. int v = jpeg_bits(j, t);
  418. if (v < 0)
  419. return -1;
  420. c->dc += jpeg_extend(v, t);
  421. }
  422. blk[0] = c->dc * q[0];
  423. for (k = 1; k < 64; ) {
  424. int rs = huff_decode(j, &j->ac[c->ta]);
  425. int r, s;
  426. if (rs < 0)
  427. return -1;
  428. r = rs >> 4;
  429. s = rs & 15;
  430. if (s == 0) {
  431. if (r == 15) {
  432. k += 16;
  433. continue;
  434. }
  435. break;
  436. }
  437. k += r;
  438. if (k >= 64)
  439. return -1;
  440. {
  441. int v = jpeg_bits(j, s);
  442. if (v < 0)
  443. return -1;
  444. blk[zigzag[k]] = jpeg_extend(v, s) * q[k];
  445. }
  446. k++;
  447. }
  448. return 0;
  449. }
  450. static int jpeg_sof(struct jpeg *j, unsigned int marker)
  451. {
  452. unsigned int len, prec, i;
  453. if (jpeg_u16(j, &len) || len < 8)
  454. return -1;
  455. if (jpeg_u8(j, &prec) || prec != 8)
  456. return IMG_ERR_UNSUPPORTED;
  457. if (jpeg_u16(j, &j->h) || jpeg_u16(j, &j->w))
  458. return -1;
  459. if (j->w == 0 || j->h == 0 || j->w > 32768 || j->h > 32768)
  460. return IMG_ERR_TOOBIG;
  461. if (jpeg_u8(j, &j->ncomp) ||
  462. (j->ncomp != 1 && j->ncomp != 3))
  463. return IMG_ERR_UNSUPPORTED;
  464. if (len < 8 + j->ncomp * 3)
  465. return -1;
  466. if (marker == 0xC2 || marker == 0xC6 || marker == 0xCA ||
  467. marker == 0xCE)
  468. return IMG_ERR_UNSUPPORTED;
  469. j->max_h = j->max_v = 1;
  470. for (i = 0; i < j->ncomp; i++) {
  471. unsigned int id, hv, tq;
  472. if (jpeg_u8(j, &id) || jpeg_u8(j, &hv) || jpeg_u8(j, &tq))
  473. return -1;
  474. j->comp[i].id = (unsigned char)id;
  475. j->comp[i].h = (unsigned char)(hv >> 4);
  476. j->comp[i].v = (unsigned char)(hv & 15);
  477. j->comp[i].tq = (unsigned char)tq;
  478. if (j->comp[i].h == 0 || j->comp[i].v == 0 ||
  479. j->comp[i].h > 4 || j->comp[i].v > 4 || tq > 3)
  480. return IMG_ERR_UNSUPPORTED;
  481. if (j->comp[i].h > j->max_h)
  482. j->max_h = j->comp[i].h;
  483. if (j->comp[i].v > j->max_v)
  484. j->max_v = j->comp[i].v;
  485. }
  486. j->mcus_x = (j->w + 8 * j->max_h - 1) / (8 * j->max_h);
  487. j->mcus_y = (j->h + 8 * j->max_v - 1) / (8 * j->max_v);
  488. return 0;
  489. }
  490. int img_sniff_jpeg(const unsigned char *d, unsigned int n, struct img_info *out)
  491. {
  492. unsigned int pos = 2;
  493. if (n < 4 || d[0] != 0xFF || d[1] != 0xD8)
  494. return IMG_FMT_UNKNOWN;
  495. while (pos + 4 <= n) {
  496. unsigned int m;
  497. if (d[pos] != 0xFF) {
  498. pos++;
  499. continue;
  500. }
  501. while (pos < n && d[pos] == 0xFF)
  502. pos++;
  503. if (pos >= n)
  504. break;
  505. m = d[pos++];
  506. if (m == 0xD8 || m == 0xD9 || (m >= 0xD0 && m <= 0xD7))
  507. continue;
  508. if (pos + 2 > n)
  509. break;
  510. {
  511. unsigned int len = img_be16(d + pos);
  512. if (len < 2 || pos + len > n)
  513. break;
  514. if ((m >= 0xC0 && m <= 0xCF) && m != 0xC4 &&
  515. m != 0xC8 && m != 0xCC) {
  516. out->format = IMG_FMT_JPEG;
  517. out->height = img_be16(d + pos + 3);
  518. out->width = img_be16(d + pos + 5);
  519. out->has_alpha = 0;
  520. return IMG_FMT_JPEG;
  521. }
  522. pos += len;
  523. }
  524. }
  525. return IMG_FMT_UNKNOWN;
  526. }
  527. int img_decode_jpeg(const unsigned char *d, unsigned int n,
  528. const struct img_options *opt, struct img_mem *m,
  529. struct img_image *out)
  530. {
  531. struct jpeg *j;
  532. unsigned int mark, image_end, i;
  533. int rcode, sos = 0;
  534. mark = img_mem_mark(m);
  535. j = (struct jpeg *)img_mem_alloc(m, sizeof(*j), 16);
  536. if (!j)
  537. return IMG_ERR_NOMEM;
  538. for (i = 0; i < sizeof(*j); i++)
  539. ((unsigned char *)j)[i] = 0;
  540. j->d = d;
  541. j->n = n;
  542. j->pos = 2;
  543. j->rst_next = 0;
  544. while (j->pos < n) {
  545. int mk = jpeg_marker(j);
  546. DBG("jpeg: marker %02X at %u ncomp %u\n", mk, j->pos, j->ncomp);
  547. if (mk < 0) {
  548. img_mem_rewind(m, mark);
  549. return IMG_ERR_CORRUPT;
  550. }
  551. if (mk == 0xD9)
  552. break;
  553. if (mk == 0xDA) {
  554. unsigned int len, ns, k;
  555. if (jpeg_u16(j, &len) || len < 6)
  556. goto bad;
  557. if (jpeg_u8(j, &ns) || ns != j->ncomp)
  558. goto unsupported;
  559. for (k = 0; k < ns; k++) {
  560. unsigned int id, tabs, c;
  561. if (jpeg_u8(j, &id) || jpeg_u8(j, &tabs))
  562. goto bad;
  563. if ((tabs >> 4) > 3 || (tabs & 15) > 3)
  564. goto bad;
  565. for (c = 0; c < j->ncomp; c++)
  566. if (j->comp[c].id == id)
  567. break;
  568. if (c == j->ncomp)
  569. goto bad;
  570. j->comp[c].td = (int)(tabs >> 4);
  571. j->comp[c].ta = (int)(tabs & 15);
  572. }
  573. /* Ss, Se, Ah/Al follow the component list. */
  574. j->pos += 3;
  575. sos = 1;
  576. break;
  577. }
  578. if (mk == 0xC0 || mk == 0xC1) {
  579. rcode = jpeg_sof(j, (unsigned int)mk);
  580. if (rcode)
  581. goto fail;
  582. if (!img_size_ok(j->w, j->h, opt))
  583. goto too_big;
  584. continue;
  585. }
  586. if (mk == 0xC2 || mk == 0xC6 || mk == 0xCA || mk == 0xCE) {
  587. rcode = IMG_ERR_UNSUPPORTED;
  588. goto fail;
  589. }
  590. {
  591. unsigned int len, k;
  592. if (jpeg_u16(j, &len) || len < 2 || j->pos + len - 2 > n)
  593. goto bad;
  594. if (mk == 0xDB) { /* DQT */
  595. unsigned int end = j->pos + len - 2;
  596. while (j->pos < end) {
  597. unsigned int pqtq, pq, tq;
  598. if (jpeg_u8(j, &pqtq))
  599. goto bad;
  600. pq = pqtq >> 4;
  601. tq = pqtq & 15;
  602. if (pq > 1 || tq > 3)
  603. goto bad;
  604. for (k = 0; k < 64; k++) {
  605. unsigned int v;
  606. if (pq) {
  607. if (jpeg_u16(j, &v))
  608. goto bad;
  609. j->qt[tq][k] = (unsigned char)(v >> 8);
  610. } else {
  611. if (jpeg_u8(j, &v))
  612. goto bad;
  613. j->qt[tq][k] = (unsigned char)v;
  614. }
  615. }
  616. }
  617. } else if (mk == 0xC4) { /* DHT */
  618. unsigned int end = j->pos + len - 2;
  619. while (j->pos < end) {
  620. unsigned int tcth, tc, th;
  621. unsigned int counts[16], total = 0;
  622. if (jpeg_u8(j, &tcth))
  623. goto bad;
  624. tc = tcth >> 4;
  625. th = tcth & 15;
  626. if (tc > 1 || th > 3)
  627. goto bad;
  628. for (k = 0; k < 16; k++) {
  629. unsigned int v;
  630. if (jpeg_u8(j, &v))
  631. goto bad;
  632. counts[k] = v;
  633. total += v;
  634. }
  635. DBG("jpeg: dht tc=%u th=%u total=%u c=%u,%u,%u,%u pos=%u end=%u\n",
  636. tc, th, total, counts[0], counts[1],
  637. counts[2], counts[3], j->pos, end);
  638. {
  639. unsigned char vals[256];
  640. if (total > 256)
  641. goto bad;
  642. for (k = 0; k < total; k++) {
  643. unsigned int v;
  644. if (jpeg_u8(j, &v))
  645. goto bad;
  646. vals[k] = (unsigned char)v;
  647. }
  648. if (tc)
  649. huff_build(&j->ac[th], counts, vals);
  650. else
  651. huff_build(&j->dc[th], counts, vals);
  652. #ifdef IMG_HOST_DEBUG
  653. if (tc == 0 && th == 0) {
  654. int ll;
  655. for (ll = 1; ll <= 10; ll++)
  656. if (j->dc[0].bits[ll])
  657. DBG(" dc0 l=%d min=%d max=%d valptr=%d\n",
  658. ll, j->dc[0].mincode[ll],
  659. j->dc[0].maxcode[ll],
  660. j->dc[0].valptr[ll]);
  661. }
  662. #endif
  663. }
  664. }
  665. } else if (mk == 0xDD) { /* DRI */
  666. if (jpeg_u16(j, &j->restart))
  667. goto bad;
  668. j->rst_next = 0;
  669. } else {
  670. j->pos += len - 2;
  671. }
  672. }
  673. }
  674. if (!sos)
  675. goto bad;
  676. if (!img_size_ok(j->w, j->h, opt))
  677. goto too_big;
  678. rcode = img_alloc(m, j->w, j->h, IMG_FMT_JPEG, 0, out);
  679. if (rcode)
  680. goto fail;
  681. image_end = img_mem_mark(m);
  682. /* Allocate padded component planes. */
  683. for (i = 0; i < j->ncomp; i++) {
  684. struct jpeg_comp *c = &j->comp[i];
  685. c->pw = j->mcus_x * c->h * 8;
  686. c->ph = j->mcus_y * c->v * 8;
  687. c->plane = (unsigned char *)img_mem_alloc(m, c->pw * c->ph, 16);
  688. if (!c->plane) {
  689. rcode = IMG_ERR_NOMEM;
  690. img_mem_rewind(m, mark);
  691. goto fail;
  692. }
  693. c->dc = 0;
  694. }
  695. /* Entropy-coded scan. */
  696. {
  697. unsigned int mx, my, mcu = 0;
  698. for (my = 0; my < j->mcus_y; my++) {
  699. for (mx = 0; mx < j->mcus_x; mx++) {
  700. unsigned int ci;
  701. for (ci = 0; ci < j->ncomp; ci++) {
  702. struct jpeg_comp *c = &j->comp[ci];
  703. unsigned int by, bx;
  704. for (by = 0; by < c->v; by++) {
  705. for (bx = 0; bx < c->h; bx++) {
  706. int blk[64];
  707. unsigned char p[64];
  708. unsigned int xx, yy;
  709. if (jpeg_block(j, c, blk))
  710. goto entropy_bad;
  711. idct_block(blk, p);
  712. for (yy = 0; yy < 8; yy++)
  713. for (xx = 0; xx < 8; xx++) {
  714. unsigned int px = mx * c->h * 8 + bx * 8 + xx;
  715. unsigned int py = my * c->v * 8 + by * 8 + yy;
  716. c->plane[py * c->pw + px] = p[yy * 8 + xx];
  717. }
  718. }
  719. }
  720. }
  721. mcu++;
  722. if (j->restart && (mcu % j->restart) == 0 &&
  723. mcu < j->mcus_x * j->mcus_y) {
  724. for (ci = 0; ci < j->ncomp; ci++)
  725. j->comp[ci].dc = 0;
  726. if (jpeg_restart(j))
  727. goto entropy_bad;
  728. }
  729. }
  730. }
  731. }
  732. /* Convert planes to RGB565. */
  733. for (i = 0; i < j->h; i++) {
  734. unsigned int x;
  735. for (x = 0; x < j->w; x++) {
  736. struct jpeg_comp *y = &j->comp[0];
  737. unsigned int yy = y->plane[i * y->pw + x];
  738. unsigned int r, g, b;
  739. if (j->ncomp == 1) {
  740. r = g = b = yy;
  741. } else {
  742. struct jpeg_comp *cb = &j->comp[1];
  743. struct jpeg_comp *cr = &j->comp[2];
  744. unsigned int cstep_x, cstep_y, crstep_x, crstep_y;
  745. int cpos_x, cpos_y, crpos_x, crpos_y;
  746. int cbv, crv, yv;
  747. cstep_x = ((unsigned int)cb->h << 16) / j->max_h;
  748. cstep_y = ((unsigned int)cb->v << 16) / j->max_v;
  749. crstep_x = ((unsigned int)cr->h << 16) / j->max_h;
  750. crstep_y = ((unsigned int)cr->v << 16) / j->max_v;
  751. cpos_x = (int)(x * cstep_x) +
  752. (int)(((unsigned int)cb->h * 32768u) / j->max_h) -
  753. 32768;
  754. cpos_y = (int)(i * cstep_y) +
  755. (int)(((unsigned int)cb->v * 32768u) / j->max_v) -
  756. 32768;
  757. crpos_x = (int)(x * crstep_x) +
  758. (int)(((unsigned int)cr->h * 32768u) / j->max_h) -
  759. 32768;
  760. crpos_y = (int)(i * crstep_y) +
  761. (int)(((unsigned int)cr->v * 32768u) / j->max_v) -
  762. 32768;
  763. cbv = jpeg_chroma(cb, cpos_x, cpos_y) - 128;
  764. crv = jpeg_chroma(cr, crpos_x, crpos_y) - 128;
  765. yv = (int)yy;
  766. int rr = yv + ((91881 * crv) >> 16);
  767. int gg = yv - ((22554 * cbv + 46802 * crv) >> 16);
  768. int bb = yv + ((116130 * cbv) >> 16);
  769. if (rr < 0) rr = 0;
  770. if (gg < 0) gg = 0;
  771. if (bb < 0) bb = 0;
  772. if (rr > 255) rr = 255;
  773. if (gg > 255) gg = 255;
  774. if (bb > 255) bb = 255;
  775. r = (unsigned int)rr;
  776. g = (unsigned int)gg;
  777. b = (unsigned int)bb;
  778. }
  779. out->px[i * j->w + x] = img_rgb565(r, g, b);
  780. }
  781. }
  782. img_mem_rewind(m, image_end);
  783. return 0;
  784. entropy_bad:
  785. img_mem_rewind(m, mark);
  786. rcode = IMG_ERR_CORRUPT;
  787. goto fail;
  788. too_big:
  789. DBG("jpeg: too big %ux%u\n", j->w, j->h);
  790. rcode = IMG_ERR_TOOBIG;
  791. goto fail;
  792. unsupported:
  793. DBG("jpeg: unsupported\n");
  794. rcode = IMG_ERR_UNSUPPORTED;
  795. goto fail;
  796. bad:
  797. DBG("jpeg: bad at pos %u ncomp %u\n", j->pos, j->ncomp);
  798. rcode = IMG_ERR_CORRUPT;
  799. fail:
  800. img_mem_rewind(m, mark);
  801. return rcode;
  802. }