pngtrans.c 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864
  1. /* pngtrans.c - transforms the data in a row (used by both readers and writers)
  2. *
  3. * Copyright (c) 2018 Cosmin Truta
  4. * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
  5. * Copyright (c) 1996-1997 Andreas Dilger
  6. * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
  7. *
  8. * This code is released under the libpng license.
  9. * For conditions of distribution and use, see the disclaimer
  10. * and license in png.h
  11. */
  12. #include "pngpriv.h"
  13. #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  14. #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
  15. /* Turn on BGR-to-RGB mapping */
  16. void PNGAPI
  17. png_set_bgr(png_structrp png_ptr)
  18. {
  19. png_debug(1, "in png_set_bgr");
  20. if (png_ptr == NULL)
  21. return;
  22. png_ptr->transformations |= PNG_BGR;
  23. }
  24. #endif
  25. #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
  26. /* Turn on 16-bit byte swapping */
  27. void PNGAPI
  28. png_set_swap(png_structrp png_ptr)
  29. {
  30. png_debug(1, "in png_set_swap");
  31. if (png_ptr == NULL)
  32. return;
  33. if (png_ptr->bit_depth == 16)
  34. png_ptr->transformations |= PNG_SWAP_BYTES;
  35. }
  36. #endif
  37. #if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
  38. /* Turn on pixel packing */
  39. void PNGAPI
  40. png_set_packing(png_structrp png_ptr)
  41. {
  42. png_debug(1, "in png_set_packing");
  43. if (png_ptr == NULL)
  44. return;
  45. if (png_ptr->bit_depth < 8)
  46. {
  47. png_ptr->transformations |= PNG_PACK;
  48. # ifdef PNG_WRITE_SUPPORTED
  49. png_ptr->usr_bit_depth = 8;
  50. # endif
  51. }
  52. }
  53. #endif
  54. #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
  55. /* Turn on packed pixel swapping */
  56. void PNGAPI
  57. png_set_packswap(png_structrp png_ptr)
  58. {
  59. png_debug(1, "in png_set_packswap");
  60. if (png_ptr == NULL)
  61. return;
  62. if (png_ptr->bit_depth < 8)
  63. png_ptr->transformations |= PNG_PACKSWAP;
  64. }
  65. #endif
  66. #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
  67. void PNGAPI
  68. png_set_shift(png_structrp png_ptr, png_const_color_8p true_bits)
  69. {
  70. png_debug(1, "in png_set_shift");
  71. if (png_ptr == NULL)
  72. return;
  73. png_ptr->transformations |= PNG_SHIFT;
  74. png_ptr->shift = *true_bits;
  75. }
  76. #endif
  77. #if defined(PNG_READ_INTERLACING_SUPPORTED) || \
  78. defined(PNG_WRITE_INTERLACING_SUPPORTED)
  79. int PNGAPI
  80. png_set_interlace_handling(png_structrp png_ptr)
  81. {
  82. png_debug(1, "in png_set_interlace handling");
  83. if (png_ptr != 0 && png_ptr->interlaced != 0)
  84. {
  85. png_ptr->transformations |= PNG_INTERLACE;
  86. return (7);
  87. }
  88. return (1);
  89. }
  90. #endif
  91. #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
  92. /* Add a filler byte on read, or remove a filler or alpha byte on write.
  93. * The filler type has changed in v0.95 to allow future 2-byte fillers
  94. * for 48-bit input data, as well as to avoid problems with some compilers
  95. * that don't like bytes as parameters.
  96. */
  97. void PNGAPI
  98. png_set_filler(png_structrp png_ptr, png_uint_32 filler, int filler_loc)
  99. {
  100. png_debug(1, "in png_set_filler");
  101. if (png_ptr == NULL)
  102. return;
  103. /* In libpng 1.6 it is possible to determine whether this is a read or write
  104. * operation and therefore to do more checking here for a valid call.
  105. */
  106. if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
  107. {
  108. # ifdef PNG_READ_FILLER_SUPPORTED
  109. /* On read png_set_filler is always valid, regardless of the base PNG
  110. * format, because other transformations can give a format where the
  111. * filler code can execute (basically an 8 or 16-bit component RGB or G
  112. * format.)
  113. *
  114. * NOTE: usr_channels is not used by the read code! (This has led to
  115. * confusion in the past.) The filler is only used in the read code.
  116. */
  117. png_ptr->filler = (png_uint_16)filler;
  118. # else
  119. png_app_error(png_ptr, "png_set_filler not supported on read");
  120. PNG_UNUSED(filler) /* not used in the write case */
  121. return;
  122. # endif
  123. }
  124. else /* write */
  125. {
  126. # ifdef PNG_WRITE_FILLER_SUPPORTED
  127. /* On write the usr_channels parameter must be set correctly at the
  128. * start to record the number of channels in the app-supplied data.
  129. */
  130. switch (png_ptr->color_type)
  131. {
  132. case PNG_COLOR_TYPE_RGB:
  133. png_ptr->usr_channels = 4;
  134. break;
  135. case PNG_COLOR_TYPE_GRAY:
  136. if (png_ptr->bit_depth >= 8)
  137. {
  138. png_ptr->usr_channels = 2;
  139. break;
  140. }
  141. else
  142. {
  143. /* There simply isn't any code in libpng to strip out bits
  144. * from bytes when the components are less than a byte in
  145. * size!
  146. */
  147. png_app_error(png_ptr,
  148. "png_set_filler is invalid for"
  149. " low bit depth gray output");
  150. return;
  151. }
  152. default:
  153. png_app_error(png_ptr,
  154. "png_set_filler: inappropriate color type");
  155. return;
  156. }
  157. # else
  158. png_app_error(png_ptr, "png_set_filler not supported on write");
  159. return;
  160. # endif
  161. }
  162. /* Here on success - libpng supports the operation, set the transformation
  163. * and the flag to say where the filler channel is.
  164. */
  165. png_ptr->transformations |= PNG_FILLER;
  166. if (filler_loc == PNG_FILLER_AFTER)
  167. png_ptr->flags |= PNG_FLAG_FILLER_AFTER;
  168. else
  169. png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;
  170. }
  171. /* Added to libpng-1.2.7 */
  172. void PNGAPI
  173. png_set_add_alpha(png_structrp png_ptr, png_uint_32 filler, int filler_loc)
  174. {
  175. png_debug(1, "in png_set_add_alpha");
  176. if (png_ptr == NULL)
  177. return;
  178. png_set_filler(png_ptr, filler, filler_loc);
  179. /* The above may fail to do anything. */
  180. if ((png_ptr->transformations & PNG_FILLER) != 0)
  181. png_ptr->transformations |= PNG_ADD_ALPHA;
  182. }
  183. #endif
  184. #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
  185. defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
  186. void PNGAPI
  187. png_set_swap_alpha(png_structrp png_ptr)
  188. {
  189. png_debug(1, "in png_set_swap_alpha");
  190. if (png_ptr == NULL)
  191. return;
  192. png_ptr->transformations |= PNG_SWAP_ALPHA;
  193. }
  194. #endif
  195. #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
  196. defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
  197. void PNGAPI
  198. png_set_invert_alpha(png_structrp png_ptr)
  199. {
  200. png_debug(1, "in png_set_invert_alpha");
  201. if (png_ptr == NULL)
  202. return;
  203. png_ptr->transformations |= PNG_INVERT_ALPHA;
  204. }
  205. #endif
  206. #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
  207. void PNGAPI
  208. png_set_invert_mono(png_structrp png_ptr)
  209. {
  210. png_debug(1, "in png_set_invert_mono");
  211. if (png_ptr == NULL)
  212. return;
  213. png_ptr->transformations |= PNG_INVERT_MONO;
  214. }
  215. /* Invert monochrome grayscale data */
  216. void /* PRIVATE */
  217. png_do_invert(png_row_infop row_info, png_bytep row)
  218. {
  219. png_debug(1, "in png_do_invert");
  220. /* This test removed from libpng version 1.0.13 and 1.2.0:
  221. * if (row_info->bit_depth == 1 &&
  222. */
  223. if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
  224. {
  225. png_bytep rp = row;
  226. size_t i;
  227. size_t istop = row_info->rowbytes;
  228. for (i = 0; i < istop; i++)
  229. {
  230. *rp = (png_byte)(~(*rp));
  231. rp++;
  232. }
  233. }
  234. else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
  235. row_info->bit_depth == 8)
  236. {
  237. png_bytep rp = row;
  238. size_t i;
  239. size_t istop = row_info->rowbytes;
  240. for (i = 0; i < istop; i += 2)
  241. {
  242. *rp = (png_byte)(~(*rp));
  243. rp += 2;
  244. }
  245. }
  246. #ifdef PNG_16BIT_SUPPORTED
  247. else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
  248. row_info->bit_depth == 16)
  249. {
  250. png_bytep rp = row;
  251. size_t i;
  252. size_t istop = row_info->rowbytes;
  253. for (i = 0; i < istop; i += 4)
  254. {
  255. *rp = (png_byte)(~(*rp));
  256. *(rp + 1) = (png_byte)(~(*(rp + 1)));
  257. rp += 4;
  258. }
  259. }
  260. #endif
  261. }
  262. #endif
  263. #ifdef PNG_16BIT_SUPPORTED
  264. #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
  265. /* Swaps byte order on 16-bit depth images */
  266. void /* PRIVATE */
  267. png_do_swap(png_row_infop row_info, png_bytep row)
  268. {
  269. png_debug(1, "in png_do_swap");
  270. if (row_info->bit_depth == 16)
  271. {
  272. png_bytep rp = row;
  273. png_uint_32 i;
  274. png_uint_32 istop= row_info->width * row_info->channels;
  275. for (i = 0; i < istop; i++, rp += 2)
  276. {
  277. #ifdef PNG_BUILTIN_BSWAP16_SUPPORTED
  278. /* Feature added to libpng-1.6.11 for testing purposes, not
  279. * enabled by default.
  280. */
  281. *(png_uint_16*)rp = __builtin_bswap16(*(png_uint_16*)rp);
  282. #else
  283. png_byte t = *rp;
  284. *rp = *(rp + 1);
  285. *(rp + 1) = t;
  286. #endif
  287. }
  288. }
  289. }
  290. #endif
  291. #endif
  292. #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
  293. static const png_byte onebppswaptable[256] = {
  294. 0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0,
  295. 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
  296. 0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8,
  297. 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
  298. 0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4,
  299. 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
  300. 0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC,
  301. 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
  302. 0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2,
  303. 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
  304. 0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA,
  305. 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
  306. 0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6,
  307. 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
  308. 0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE,
  309. 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
  310. 0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1,
  311. 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
  312. 0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9,
  313. 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
  314. 0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5,
  315. 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
  316. 0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED,
  317. 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
  318. 0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3,
  319. 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
  320. 0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB,
  321. 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
  322. 0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7,
  323. 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
  324. 0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF,
  325. 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
  326. };
  327. static const png_byte twobppswaptable[256] = {
  328. 0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0,
  329. 0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0,
  330. 0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4,
  331. 0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4,
  332. 0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8,
  333. 0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8,
  334. 0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC,
  335. 0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC,
  336. 0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1,
  337. 0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1,
  338. 0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5,
  339. 0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5,
  340. 0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9,
  341. 0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9,
  342. 0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD,
  343. 0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD,
  344. 0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2,
  345. 0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2,
  346. 0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6,
  347. 0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6,
  348. 0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA,
  349. 0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA,
  350. 0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE,
  351. 0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE,
  352. 0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3,
  353. 0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3,
  354. 0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7,
  355. 0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7,
  356. 0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB,
  357. 0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB,
  358. 0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF,
  359. 0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF
  360. };
  361. static const png_byte fourbppswaptable[256] = {
  362. 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
  363. 0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,
  364. 0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71,
  365. 0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1,
  366. 0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72,
  367. 0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2,
  368. 0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73,
  369. 0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3,
  370. 0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74,
  371. 0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4,
  372. 0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75,
  373. 0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5,
  374. 0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76,
  375. 0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6,
  376. 0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77,
  377. 0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7,
  378. 0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78,
  379. 0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8,
  380. 0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79,
  381. 0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9,
  382. 0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A,
  383. 0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA,
  384. 0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B,
  385. 0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB,
  386. 0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C,
  387. 0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC,
  388. 0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D,
  389. 0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD,
  390. 0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E,
  391. 0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE,
  392. 0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F,
  393. 0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF
  394. };
  395. /* Swaps pixel packing order within bytes */
  396. void /* PRIVATE */
  397. png_do_packswap(png_row_infop row_info, png_bytep row)
  398. {
  399. png_debug(1, "in png_do_packswap");
  400. if (row_info->bit_depth < 8)
  401. {
  402. png_bytep rp;
  403. png_const_bytep end, table;
  404. end = row + row_info->rowbytes;
  405. if (row_info->bit_depth == 1)
  406. table = onebppswaptable;
  407. else if (row_info->bit_depth == 2)
  408. table = twobppswaptable;
  409. else if (row_info->bit_depth == 4)
  410. table = fourbppswaptable;
  411. else
  412. return;
  413. for (rp = row; rp < end; rp++)
  414. *rp = table[*rp];
  415. }
  416. }
  417. #endif /* PACKSWAP || WRITE_PACKSWAP */
  418. #if defined(PNG_WRITE_FILLER_SUPPORTED) || \
  419. defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
  420. /* Remove a channel - this used to be 'png_do_strip_filler' but it used a
  421. * somewhat weird combination of flags to determine what to do. All the calls
  422. * to png_do_strip_filler are changed in 1.5.2 to call this instead with the
  423. * correct arguments.
  424. *
  425. * The routine isn't general - the channel must be the channel at the start or
  426. * end (not in the middle) of each pixel.
  427. */
  428. void /* PRIVATE */
  429. png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start)
  430. {
  431. png_bytep sp = row; /* source pointer */
  432. png_bytep dp = row; /* destination pointer */
  433. png_bytep ep = row + row_info->rowbytes; /* One beyond end of row */
  434. /* At the start sp will point to the first byte to copy and dp to where
  435. * it is copied to. ep always points just beyond the end of the row, so
  436. * the loop simply copies (channels-1) channels until sp reaches ep.
  437. *
  438. * at_start: 0 -- convert AG, XG, ARGB, XRGB, AAGG, XXGG, etc.
  439. * nonzero -- convert GA, GX, RGBA, RGBX, GGAA, RRGGBBXX, etc.
  440. */
  441. /* GA, GX, XG cases */
  442. if (row_info->channels == 2)
  443. {
  444. if (row_info->bit_depth == 8)
  445. {
  446. if (at_start != 0) /* Skip initial filler */
  447. ++sp;
  448. else /* Skip initial channel and, for sp, the filler */
  449. {
  450. sp += 2; ++dp;
  451. }
  452. /* For a 1 pixel wide image there is nothing to do */
  453. while (sp < ep)
  454. {
  455. *dp++ = *sp; sp += 2;
  456. }
  457. row_info->pixel_depth = 8;
  458. }
  459. else if (row_info->bit_depth == 16)
  460. {
  461. if (at_start != 0) /* Skip initial filler */
  462. sp += 2;
  463. else /* Skip initial channel and, for sp, the filler */
  464. {
  465. sp += 4; dp += 2;
  466. }
  467. while (sp < ep)
  468. {
  469. *dp++ = *sp++; *dp++ = *sp; sp += 3;
  470. }
  471. row_info->pixel_depth = 16;
  472. }
  473. else
  474. return; /* bad bit depth */
  475. row_info->channels = 1;
  476. /* Finally fix the color type if it records an alpha channel */
  477. if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
  478. row_info->color_type = PNG_COLOR_TYPE_GRAY;
  479. }
  480. /* RGBA, RGBX, XRGB cases */
  481. else if (row_info->channels == 4)
  482. {
  483. if (row_info->bit_depth == 8)
  484. {
  485. if (at_start != 0) /* Skip initial filler */
  486. ++sp;
  487. else /* Skip initial channels and, for sp, the filler */
  488. {
  489. sp += 4; dp += 3;
  490. }
  491. /* Note that the loop adds 3 to dp and 4 to sp each time. */
  492. while (sp < ep)
  493. {
  494. *dp++ = *sp++; *dp++ = *sp++; *dp++ = *sp; sp += 2;
  495. }
  496. row_info->pixel_depth = 24;
  497. }
  498. else if (row_info->bit_depth == 16)
  499. {
  500. if (at_start != 0) /* Skip initial filler */
  501. sp += 2;
  502. else /* Skip initial channels and, for sp, the filler */
  503. {
  504. sp += 8; dp += 6;
  505. }
  506. while (sp < ep)
  507. {
  508. /* Copy 6 bytes, skip 2 */
  509. *dp++ = *sp++; *dp++ = *sp++;
  510. *dp++ = *sp++; *dp++ = *sp++;
  511. *dp++ = *sp++; *dp++ = *sp; sp += 3;
  512. }
  513. row_info->pixel_depth = 48;
  514. }
  515. else
  516. return; /* bad bit depth */
  517. row_info->channels = 3;
  518. /* Finally fix the color type if it records an alpha channel */
  519. if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
  520. row_info->color_type = PNG_COLOR_TYPE_RGB;
  521. }
  522. else
  523. return; /* The filler channel has gone already */
  524. /* Fix the rowbytes value. */
  525. row_info->rowbytes = (size_t)(dp-row);
  526. }
  527. #endif
  528. #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
  529. /* Swaps red and blue bytes within a pixel */
  530. void /* PRIVATE */
  531. png_do_bgr(png_row_infop row_info, png_bytep row)
  532. {
  533. png_debug(1, "in png_do_bgr");
  534. if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
  535. {
  536. png_uint_32 row_width = row_info->width;
  537. if (row_info->bit_depth == 8)
  538. {
  539. if (row_info->color_type == PNG_COLOR_TYPE_RGB)
  540. {
  541. png_bytep rp;
  542. png_uint_32 i;
  543. for (i = 0, rp = row; i < row_width; i++, rp += 3)
  544. {
  545. png_byte save = *rp;
  546. *rp = *(rp + 2);
  547. *(rp + 2) = save;
  548. }
  549. }
  550. else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
  551. {
  552. png_bytep rp;
  553. png_uint_32 i;
  554. for (i = 0, rp = row; i < row_width; i++, rp += 4)
  555. {
  556. png_byte save = *rp;
  557. *rp = *(rp + 2);
  558. *(rp + 2) = save;
  559. }
  560. }
  561. }
  562. #ifdef PNG_16BIT_SUPPORTED
  563. else if (row_info->bit_depth == 16)
  564. {
  565. if (row_info->color_type == PNG_COLOR_TYPE_RGB)
  566. {
  567. png_bytep rp;
  568. png_uint_32 i;
  569. for (i = 0, rp = row; i < row_width; i++, rp += 6)
  570. {
  571. png_byte save = *rp;
  572. *rp = *(rp + 4);
  573. *(rp + 4) = save;
  574. save = *(rp + 1);
  575. *(rp + 1) = *(rp + 5);
  576. *(rp + 5) = save;
  577. }
  578. }
  579. else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
  580. {
  581. png_bytep rp;
  582. png_uint_32 i;
  583. for (i = 0, rp = row; i < row_width; i++, rp += 8)
  584. {
  585. png_byte save = *rp;
  586. *rp = *(rp + 4);
  587. *(rp + 4) = save;
  588. save = *(rp + 1);
  589. *(rp + 1) = *(rp + 5);
  590. *(rp + 5) = save;
  591. }
  592. }
  593. }
  594. #endif
  595. }
  596. }
  597. #endif /* READ_BGR || WRITE_BGR */
  598. #if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \
  599. defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED)
  600. /* Added at libpng-1.5.10 */
  601. void /* PRIVATE */
  602. png_do_check_palette_indexes(png_structrp png_ptr, png_row_infop row_info)
  603. {
  604. if (png_ptr->num_palette < (1 << row_info->bit_depth) &&
  605. png_ptr->num_palette > 0) /* num_palette can be 0 in MNG files */
  606. {
  607. /* Calculations moved outside switch in an attempt to stop different
  608. * compiler warnings. 'padding' is in *bits* within the last byte, it is
  609. * an 'int' because pixel_depth becomes an 'int' in the expression below,
  610. * and this calculation is used because it avoids warnings that other
  611. * forms produced on either GCC or MSVC.
  612. */
  613. int padding = PNG_PADBITS(row_info->pixel_depth, row_info->width);
  614. png_bytep rp = png_ptr->row_buf + row_info->rowbytes - 1;
  615. switch (row_info->bit_depth)
  616. {
  617. case 1:
  618. {
  619. /* in this case, all bytes must be 0 so we don't need
  620. * to unpack the pixels except for the rightmost one.
  621. */
  622. for (; rp > png_ptr->row_buf; rp--)
  623. {
  624. if ((*rp >> padding) != 0)
  625. png_ptr->num_palette_max = 1;
  626. padding = 0;
  627. }
  628. break;
  629. }
  630. case 2:
  631. {
  632. for (; rp > png_ptr->row_buf; rp--)
  633. {
  634. int i = ((*rp >> padding) & 0x03);
  635. if (i > png_ptr->num_palette_max)
  636. png_ptr->num_palette_max = i;
  637. i = (((*rp >> padding) >> 2) & 0x03);
  638. if (i > png_ptr->num_palette_max)
  639. png_ptr->num_palette_max = i;
  640. i = (((*rp >> padding) >> 4) & 0x03);
  641. if (i > png_ptr->num_palette_max)
  642. png_ptr->num_palette_max = i;
  643. i = (((*rp >> padding) >> 6) & 0x03);
  644. if (i > png_ptr->num_palette_max)
  645. png_ptr->num_palette_max = i;
  646. padding = 0;
  647. }
  648. break;
  649. }
  650. case 4:
  651. {
  652. for (; rp > png_ptr->row_buf; rp--)
  653. {
  654. int i = ((*rp >> padding) & 0x0f);
  655. if (i > png_ptr->num_palette_max)
  656. png_ptr->num_palette_max = i;
  657. i = (((*rp >> padding) >> 4) & 0x0f);
  658. if (i > png_ptr->num_palette_max)
  659. png_ptr->num_palette_max = i;
  660. padding = 0;
  661. }
  662. break;
  663. }
  664. case 8:
  665. {
  666. for (; rp > png_ptr->row_buf; rp--)
  667. {
  668. if (*rp > png_ptr->num_palette_max)
  669. png_ptr->num_palette_max = (int) *rp;
  670. }
  671. break;
  672. }
  673. default:
  674. break;
  675. }
  676. }
  677. }
  678. #endif /* CHECK_FOR_INVALID_INDEX */
  679. #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
  680. defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
  681. #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
  682. void PNGAPI
  683. png_set_user_transform_info(png_structrp png_ptr, png_voidp
  684. user_transform_ptr, int user_transform_depth, int user_transform_channels)
  685. {
  686. png_debug(1, "in png_set_user_transform_info");
  687. if (png_ptr == NULL)
  688. return;
  689. #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
  690. if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
  691. (png_ptr->flags & PNG_FLAG_ROW_INIT) != 0)
  692. {
  693. png_app_error(png_ptr,
  694. "info change after png_start_read_image or png_read_update_info");
  695. return;
  696. }
  697. #endif
  698. png_ptr->user_transform_ptr = user_transform_ptr;
  699. png_ptr->user_transform_depth = (png_byte)user_transform_depth;
  700. png_ptr->user_transform_channels = (png_byte)user_transform_channels;
  701. }
  702. #endif
  703. /* This function returns a pointer to the user_transform_ptr associated with
  704. * the user transform functions. The application should free any memory
  705. * associated with this pointer before png_write_destroy and png_read_destroy
  706. * are called.
  707. */
  708. #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
  709. png_voidp PNGAPI
  710. png_get_user_transform_ptr(png_const_structrp png_ptr)
  711. {
  712. if (png_ptr == NULL)
  713. return (NULL);
  714. return png_ptr->user_transform_ptr;
  715. }
  716. #endif
  717. #ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED
  718. png_uint_32 PNGAPI
  719. png_get_current_row_number(png_const_structrp png_ptr)
  720. {
  721. /* See the comments in png.h - this is the sub-image row when reading an
  722. * interlaced image.
  723. */
  724. if (png_ptr != NULL)
  725. return png_ptr->row_number;
  726. return PNG_UINT_32_MAX; /* help the app not to fail silently */
  727. }
  728. png_byte PNGAPI
  729. png_get_current_pass_number(png_const_structrp png_ptr)
  730. {
  731. if (png_ptr != NULL)
  732. return png_ptr->pass;
  733. return 8; /* invalid */
  734. }
  735. #endif /* USER_TRANSFORM_INFO */
  736. #endif /* READ_USER_TRANSFORM || WRITE_USER_TRANSFORM */
  737. #endif /* READ || WRITE */