pngwutil.c 78 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781
  1. /* pngwutil.c - utilities to write a PNG file
  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. #ifdef PNG_WRITE_SUPPORTED
  14. #ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED
  15. /* Place a 32-bit number into a buffer in PNG byte order. We work
  16. * with unsigned numbers for convenience, although one supported
  17. * ancillary chunk uses signed (two's complement) numbers.
  18. */
  19. void PNGAPI
  20. png_save_uint_32(png_bytep buf, png_uint_32 i)
  21. {
  22. buf[0] = (png_byte)((i >> 24) & 0xffU);
  23. buf[1] = (png_byte)((i >> 16) & 0xffU);
  24. buf[2] = (png_byte)((i >> 8) & 0xffU);
  25. buf[3] = (png_byte)( i & 0xffU);
  26. }
  27. /* Place a 16-bit number into a buffer in PNG byte order.
  28. * The parameter is declared unsigned int, not png_uint_16,
  29. * just to avoid potential problems on pre-ANSI C compilers.
  30. */
  31. void PNGAPI
  32. png_save_uint_16(png_bytep buf, unsigned int i)
  33. {
  34. buf[0] = (png_byte)((i >> 8) & 0xffU);
  35. buf[1] = (png_byte)( i & 0xffU);
  36. }
  37. #endif
  38. /* Simple function to write the signature. If we have already written
  39. * the magic bytes of the signature, or more likely, the PNG stream is
  40. * being embedded into another stream and doesn't need its own signature,
  41. * we should call png_set_sig_bytes() to tell libpng how many of the
  42. * bytes have already been written.
  43. */
  44. void PNGAPI
  45. png_write_sig(png_structrp png_ptr)
  46. {
  47. png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
  48. #ifdef PNG_IO_STATE_SUPPORTED
  49. /* Inform the I/O callback that the signature is being written */
  50. png_ptr->io_state = PNG_IO_WRITING | PNG_IO_SIGNATURE;
  51. #endif
  52. /* Write the rest of the 8 byte signature */
  53. png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes],
  54. (size_t)(8 - png_ptr->sig_bytes));
  55. if (png_ptr->sig_bytes < 3)
  56. png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
  57. }
  58. /* Write the start of a PNG chunk. The type is the chunk type.
  59. * The total_length is the sum of the lengths of all the data you will be
  60. * passing in png_write_chunk_data().
  61. */
  62. static void
  63. png_write_chunk_header(png_structrp png_ptr, png_uint_32 chunk_name,
  64. png_uint_32 length)
  65. {
  66. png_byte buf[8];
  67. #if defined(PNG_DEBUG) && (PNG_DEBUG > 0)
  68. PNG_CSTRING_FROM_CHUNK(buf, chunk_name);
  69. png_debug2(0, "Writing %s chunk, length = %lu", buf, (unsigned long)length);
  70. #endif
  71. if (png_ptr == NULL)
  72. return;
  73. #ifdef PNG_IO_STATE_SUPPORTED
  74. /* Inform the I/O callback that the chunk header is being written.
  75. * PNG_IO_CHUNK_HDR requires a single I/O call.
  76. */
  77. png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_HDR;
  78. #endif
  79. /* Write the length and the chunk name */
  80. png_save_uint_32(buf, length);
  81. png_save_uint_32(buf + 4, chunk_name);
  82. png_write_data(png_ptr, buf, 8);
  83. /* Put the chunk name into png_ptr->chunk_name */
  84. png_ptr->chunk_name = chunk_name;
  85. /* Reset the crc and run it over the chunk name */
  86. png_reset_crc(png_ptr);
  87. png_calculate_crc(png_ptr, buf + 4, 4);
  88. #ifdef PNG_IO_STATE_SUPPORTED
  89. /* Inform the I/O callback that chunk data will (possibly) be written.
  90. * PNG_IO_CHUNK_DATA does NOT require a specific number of I/O calls.
  91. */
  92. png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_DATA;
  93. #endif
  94. }
  95. void PNGAPI
  96. png_write_chunk_start(png_structrp png_ptr, png_const_bytep chunk_string,
  97. png_uint_32 length)
  98. {
  99. png_write_chunk_header(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), length);
  100. }
  101. /* Write the data of a PNG chunk started with png_write_chunk_header().
  102. * Note that multiple calls to this function are allowed, and that the
  103. * sum of the lengths from these calls *must* add up to the total_length
  104. * given to png_write_chunk_header().
  105. */
  106. void PNGAPI
  107. png_write_chunk_data(png_structrp png_ptr, png_const_bytep data, size_t length)
  108. {
  109. /* Write the data, and run the CRC over it */
  110. if (png_ptr == NULL)
  111. return;
  112. if (data != NULL && length > 0)
  113. {
  114. png_write_data(png_ptr, data, length);
  115. /* Update the CRC after writing the data,
  116. * in case the user I/O routine alters it.
  117. */
  118. png_calculate_crc(png_ptr, data, length);
  119. }
  120. }
  121. /* Finish a chunk started with png_write_chunk_header(). */
  122. void PNGAPI
  123. png_write_chunk_end(png_structrp png_ptr)
  124. {
  125. png_byte buf[4];
  126. if (png_ptr == NULL) return;
  127. #ifdef PNG_IO_STATE_SUPPORTED
  128. /* Inform the I/O callback that the chunk CRC is being written.
  129. * PNG_IO_CHUNK_CRC requires a single I/O function call.
  130. */
  131. png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_CRC;
  132. #endif
  133. /* Write the crc in a single operation */
  134. png_save_uint_32(buf, png_ptr->crc);
  135. png_write_data(png_ptr, buf, 4);
  136. }
  137. /* Write a PNG chunk all at once. The type is an array of ASCII characters
  138. * representing the chunk name. The array must be at least 4 bytes in
  139. * length, and does not need to be null terminated. To be safe, pass the
  140. * pre-defined chunk names here, and if you need a new one, define it
  141. * where the others are defined. The length is the length of the data.
  142. * All the data must be present. If that is not possible, use the
  143. * png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end()
  144. * functions instead.
  145. */
  146. static void
  147. png_write_complete_chunk(png_structrp png_ptr, png_uint_32 chunk_name,
  148. png_const_bytep data, size_t length)
  149. {
  150. if (png_ptr == NULL)
  151. return;
  152. /* On 64-bit architectures 'length' may not fit in a png_uint_32. */
  153. if (length > PNG_UINT_31_MAX)
  154. png_error(png_ptr, "length exceeds PNG maximum");
  155. png_write_chunk_header(png_ptr, chunk_name, (png_uint_32)length);
  156. png_write_chunk_data(png_ptr, data, length);
  157. png_write_chunk_end(png_ptr);
  158. }
  159. /* This is the API that calls the internal function above. */
  160. void PNGAPI
  161. png_write_chunk(png_structrp png_ptr, png_const_bytep chunk_string,
  162. png_const_bytep data, size_t length)
  163. {
  164. png_write_complete_chunk(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), data,
  165. length);
  166. }
  167. /* This is used below to find the size of an image to pass to png_deflate_claim,
  168. * so it only needs to be accurate if the size is less than 16384 bytes (the
  169. * point at which a lower LZ window size can be used.)
  170. */
  171. static png_alloc_size_t
  172. png_image_size(png_structrp png_ptr)
  173. {
  174. /* Only return sizes up to the maximum of a png_uint_32; do this by limiting
  175. * the width and height used to 15 bits.
  176. */
  177. png_uint_32 h = png_ptr->height;
  178. if (png_ptr->rowbytes < 32768 && h < 32768)
  179. {
  180. if (png_ptr->interlaced != 0)
  181. {
  182. /* Interlacing makes the image larger because of the replication of
  183. * both the filter byte and the padding to a byte boundary.
  184. */
  185. png_uint_32 w = png_ptr->width;
  186. unsigned int pd = png_ptr->pixel_depth;
  187. png_alloc_size_t cb_base;
  188. int pass;
  189. for (cb_base=0, pass=0; pass<=6; ++pass)
  190. {
  191. png_uint_32 pw = PNG_PASS_COLS(w, pass);
  192. if (pw > 0)
  193. cb_base += (PNG_ROWBYTES(pd, pw)+1) * PNG_PASS_ROWS(h, pass);
  194. }
  195. return cb_base;
  196. }
  197. else
  198. return (png_ptr->rowbytes+1) * h;
  199. }
  200. else
  201. return 0xffffffffU;
  202. }
  203. #ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
  204. /* This is the code to hack the first two bytes of the deflate stream (the
  205. * deflate header) to correct the windowBits value to match the actual data
  206. * size. Note that the second argument is the *uncompressed* size but the
  207. * first argument is the *compressed* data (and it must be deflate
  208. * compressed.)
  209. */
  210. static void
  211. optimize_cmf(png_bytep data, png_alloc_size_t data_size)
  212. {
  213. /* Optimize the CMF field in the zlib stream. The resultant zlib stream is
  214. * still compliant to the stream specification.
  215. */
  216. if (data_size <= 16384) /* else windowBits must be 15 */
  217. {
  218. unsigned int z_cmf = data[0]; /* zlib compression method and flags */
  219. if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70)
  220. {
  221. unsigned int z_cinfo;
  222. unsigned int half_z_window_size;
  223. z_cinfo = z_cmf >> 4;
  224. half_z_window_size = 1U << (z_cinfo + 7);
  225. if (data_size <= half_z_window_size) /* else no change */
  226. {
  227. unsigned int tmp;
  228. do
  229. {
  230. half_z_window_size >>= 1;
  231. --z_cinfo;
  232. }
  233. while (z_cinfo > 0 && data_size <= half_z_window_size);
  234. z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4);
  235. data[0] = (png_byte)z_cmf;
  236. tmp = data[1] & 0xe0;
  237. tmp += 0x1f - ((z_cmf << 8) + tmp) % 0x1f;
  238. data[1] = (png_byte)tmp;
  239. }
  240. }
  241. }
  242. }
  243. #endif /* WRITE_OPTIMIZE_CMF */
  244. /* Initialize the compressor for the appropriate type of compression. */
  245. static int
  246. png_deflate_claim(png_structrp png_ptr, png_uint_32 owner,
  247. png_alloc_size_t data_size)
  248. {
  249. if (png_ptr->zowner != 0)
  250. {
  251. #if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED)
  252. char msg[64];
  253. PNG_STRING_FROM_CHUNK(msg, owner);
  254. msg[4] = ':';
  255. msg[5] = ' ';
  256. PNG_STRING_FROM_CHUNK(msg+6, png_ptr->zowner);
  257. /* So the message that results is "<chunk> using zstream"; this is an
  258. * internal error, but is very useful for debugging. i18n requirements
  259. * are minimal.
  260. */
  261. (void)png_safecat(msg, (sizeof msg), 10, " using zstream");
  262. #endif
  263. #if PNG_RELEASE_BUILD
  264. png_warning(png_ptr, msg);
  265. /* Attempt sane error recovery */
  266. if (png_ptr->zowner == png_IDAT) /* don't steal from IDAT */
  267. {
  268. png_ptr->zstream.msg = PNGZ_MSG_CAST("in use by IDAT");
  269. return Z_STREAM_ERROR;
  270. }
  271. png_ptr->zowner = 0;
  272. #else
  273. png_error(png_ptr, msg);
  274. #endif
  275. }
  276. {
  277. int level = png_ptr->zlib_level;
  278. int method = png_ptr->zlib_method;
  279. int windowBits = png_ptr->zlib_window_bits;
  280. int memLevel = png_ptr->zlib_mem_level;
  281. int strategy; /* set below */
  282. int ret; /* zlib return code */
  283. if (owner == png_IDAT)
  284. {
  285. if ((png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY) != 0)
  286. strategy = png_ptr->zlib_strategy;
  287. else if (png_ptr->do_filter != PNG_FILTER_NONE)
  288. strategy = PNG_Z_DEFAULT_STRATEGY;
  289. else
  290. strategy = PNG_Z_DEFAULT_NOFILTER_STRATEGY;
  291. }
  292. else
  293. {
  294. #ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
  295. level = png_ptr->zlib_text_level;
  296. method = png_ptr->zlib_text_method;
  297. windowBits = png_ptr->zlib_text_window_bits;
  298. memLevel = png_ptr->zlib_text_mem_level;
  299. strategy = png_ptr->zlib_text_strategy;
  300. #else
  301. /* If customization is not supported the values all come from the
  302. * IDAT values except for the strategy, which is fixed to the
  303. * default. (This is the pre-1.6.0 behavior too, although it was
  304. * implemented in a very different way.)
  305. */
  306. strategy = Z_DEFAULT_STRATEGY;
  307. #endif
  308. }
  309. /* Adjust 'windowBits' down if larger than 'data_size'; to stop this
  310. * happening just pass 32768 as the data_size parameter. Notice that zlib
  311. * requires an extra 262 bytes in the window in addition to the data to be
  312. * able to see the whole of the data, so if data_size+262 takes us to the
  313. * next windowBits size we need to fix up the value later. (Because even
  314. * though deflate needs the extra window, inflate does not!)
  315. */
  316. if (data_size <= 16384)
  317. {
  318. /* IMPLEMENTATION NOTE: this 'half_window_size' stuff is only here to
  319. * work round a Microsoft Visual C misbehavior which, contrary to C-90,
  320. * widens the result of the following shift to 64-bits if (and,
  321. * apparently, only if) it is used in a test.
  322. */
  323. unsigned int half_window_size = 1U << (windowBits-1);
  324. while (data_size + 262 <= half_window_size)
  325. {
  326. half_window_size >>= 1;
  327. --windowBits;
  328. }
  329. }
  330. /* Check against the previous initialized values, if any. */
  331. if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) != 0 &&
  332. (png_ptr->zlib_set_level != level ||
  333. png_ptr->zlib_set_method != method ||
  334. png_ptr->zlib_set_window_bits != windowBits ||
  335. png_ptr->zlib_set_mem_level != memLevel ||
  336. png_ptr->zlib_set_strategy != strategy))
  337. {
  338. if (deflateEnd(&png_ptr->zstream) != Z_OK)
  339. png_warning(png_ptr, "deflateEnd failed (ignored)");
  340. png_ptr->flags &= ~PNG_FLAG_ZSTREAM_INITIALIZED;
  341. }
  342. /* For safety clear out the input and output pointers (currently zlib
  343. * doesn't use them on Init, but it might in the future).
  344. */
  345. png_ptr->zstream.next_in = NULL;
  346. png_ptr->zstream.avail_in = 0;
  347. png_ptr->zstream.next_out = NULL;
  348. png_ptr->zstream.avail_out = 0;
  349. /* Now initialize if required, setting the new parameters, otherwise just
  350. * do a simple reset to the previous parameters.
  351. */
  352. if ((png_ptr->flags & PNG_FLAG_ZSTREAM_INITIALIZED) != 0)
  353. ret = deflateReset(&png_ptr->zstream);
  354. else
  355. {
  356. ret = deflateInit2(&png_ptr->zstream, level, method, windowBits,
  357. memLevel, strategy);
  358. if (ret == Z_OK)
  359. png_ptr->flags |= PNG_FLAG_ZSTREAM_INITIALIZED;
  360. }
  361. /* The return code is from either deflateReset or deflateInit2; they have
  362. * pretty much the same set of error codes.
  363. */
  364. if (ret == Z_OK)
  365. png_ptr->zowner = owner;
  366. else
  367. png_zstream_error(png_ptr, ret);
  368. return ret;
  369. }
  370. }
  371. /* Clean up (or trim) a linked list of compression buffers. */
  372. void /* PRIVATE */
  373. png_free_buffer_list(png_structrp png_ptr, png_compression_bufferp *listp)
  374. {
  375. png_compression_bufferp list = *listp;
  376. if (list != NULL)
  377. {
  378. *listp = NULL;
  379. do
  380. {
  381. png_compression_bufferp next = list->next;
  382. png_free(png_ptr, list);
  383. list = next;
  384. }
  385. while (list != NULL);
  386. }
  387. }
  388. #ifdef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED
  389. /* This pair of functions encapsulates the operation of (a) compressing a
  390. * text string, and (b) issuing it later as a series of chunk data writes.
  391. * The compression_state structure is shared context for these functions
  392. * set up by the caller to allow access to the relevant local variables.
  393. *
  394. * compression_buffer (new in 1.6.0) is just a linked list of zbuffer_size
  395. * temporary buffers. From 1.6.0 it is retained in png_struct so that it will
  396. * be correctly freed in the event of a write error (previous implementations
  397. * just leaked memory.)
  398. */
  399. typedef struct
  400. {
  401. png_const_bytep input; /* The uncompressed input data */
  402. png_alloc_size_t input_len; /* Its length */
  403. png_uint_32 output_len; /* Final compressed length */
  404. png_byte output[1024]; /* First block of output */
  405. } compression_state;
  406. static void
  407. png_text_compress_init(compression_state *comp, png_const_bytep input,
  408. png_alloc_size_t input_len)
  409. {
  410. comp->input = input;
  411. comp->input_len = input_len;
  412. comp->output_len = 0;
  413. }
  414. /* Compress the data in the compression state input */
  415. static int
  416. png_text_compress(png_structrp png_ptr, png_uint_32 chunk_name,
  417. compression_state *comp, png_uint_32 prefix_len)
  418. {
  419. int ret;
  420. /* To find the length of the output it is necessary to first compress the
  421. * input. The result is buffered rather than using the two-pass algorithm
  422. * that is used on the inflate side; deflate is assumed to be slower and a
  423. * PNG writer is assumed to have more memory available than a PNG reader.
  424. *
  425. * IMPLEMENTATION NOTE: the zlib API deflateBound() can be used to find an
  426. * upper limit on the output size, but it is always bigger than the input
  427. * size so it is likely to be more efficient to use this linked-list
  428. * approach.
  429. */
  430. ret = png_deflate_claim(png_ptr, chunk_name, comp->input_len);
  431. if (ret != Z_OK)
  432. return ret;
  433. /* Set up the compression buffers, we need a loop here to avoid overflowing a
  434. * uInt. Use ZLIB_IO_MAX to limit the input. The output is always limited
  435. * by the output buffer size, so there is no need to check that. Since this
  436. * is ANSI-C we know that an 'int', hence a uInt, is always at least 16 bits
  437. * in size.
  438. */
  439. {
  440. png_compression_bufferp *end = &png_ptr->zbuffer_list;
  441. png_alloc_size_t input_len = comp->input_len; /* may be zero! */
  442. png_uint_32 output_len;
  443. /* zlib updates these for us: */
  444. png_ptr->zstream.next_in = PNGZ_INPUT_CAST(comp->input);
  445. png_ptr->zstream.avail_in = 0; /* Set below */
  446. png_ptr->zstream.next_out = comp->output;
  447. png_ptr->zstream.avail_out = (sizeof comp->output);
  448. output_len = png_ptr->zstream.avail_out;
  449. do
  450. {
  451. uInt avail_in = ZLIB_IO_MAX;
  452. if (avail_in > input_len)
  453. avail_in = (uInt)input_len;
  454. input_len -= avail_in;
  455. png_ptr->zstream.avail_in = avail_in;
  456. if (png_ptr->zstream.avail_out == 0)
  457. {
  458. png_compression_buffer *next;
  459. /* Chunk data is limited to 2^31 bytes in length, so the prefix
  460. * length must be counted here.
  461. */
  462. if (output_len + prefix_len > PNG_UINT_31_MAX)
  463. {
  464. ret = Z_MEM_ERROR;
  465. break;
  466. }
  467. /* Need a new (malloc'ed) buffer, but there may be one present
  468. * already.
  469. */
  470. next = *end;
  471. if (next == NULL)
  472. {
  473. next = png_voidcast(png_compression_bufferp, png_malloc_base
  474. (png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr)));
  475. if (next == NULL)
  476. {
  477. ret = Z_MEM_ERROR;
  478. break;
  479. }
  480. /* Link in this buffer (so that it will be freed later) */
  481. next->next = NULL;
  482. *end = next;
  483. }
  484. png_ptr->zstream.next_out = next->output;
  485. png_ptr->zstream.avail_out = png_ptr->zbuffer_size;
  486. output_len += png_ptr->zstream.avail_out;
  487. /* Move 'end' to the next buffer pointer. */
  488. end = &next->next;
  489. }
  490. /* Compress the data */
  491. ret = deflate(&png_ptr->zstream,
  492. input_len > 0 ? Z_NO_FLUSH : Z_FINISH);
  493. /* Claw back input data that was not consumed (because avail_in is
  494. * reset above every time round the loop).
  495. */
  496. input_len += png_ptr->zstream.avail_in;
  497. png_ptr->zstream.avail_in = 0; /* safety */
  498. }
  499. while (ret == Z_OK);
  500. /* There may be some space left in the last output buffer. This needs to
  501. * be subtracted from output_len.
  502. */
  503. output_len -= png_ptr->zstream.avail_out;
  504. png_ptr->zstream.avail_out = 0; /* safety */
  505. comp->output_len = output_len;
  506. /* Now double check the output length, put in a custom message if it is
  507. * too long. Otherwise ensure the z_stream::msg pointer is set to
  508. * something.
  509. */
  510. if (output_len + prefix_len >= PNG_UINT_31_MAX)
  511. {
  512. png_ptr->zstream.msg = PNGZ_MSG_CAST("compressed data too long");
  513. ret = Z_MEM_ERROR;
  514. }
  515. else
  516. png_zstream_error(png_ptr, ret);
  517. /* Reset zlib for another zTXt/iTXt or image data */
  518. png_ptr->zowner = 0;
  519. /* The only success case is Z_STREAM_END, input_len must be 0; if not this
  520. * is an internal error.
  521. */
  522. if (ret == Z_STREAM_END && input_len == 0)
  523. {
  524. #ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
  525. /* Fix up the deflate header, if required */
  526. optimize_cmf(comp->output, comp->input_len);
  527. #endif
  528. /* But Z_OK is returned, not Z_STREAM_END; this allows the claim
  529. * function above to return Z_STREAM_END on an error (though it never
  530. * does in the current versions of zlib.)
  531. */
  532. return Z_OK;
  533. }
  534. else
  535. return ret;
  536. }
  537. }
  538. /* Ship the compressed text out via chunk writes */
  539. static void
  540. png_write_compressed_data_out(png_structrp png_ptr, compression_state *comp)
  541. {
  542. png_uint_32 output_len = comp->output_len;
  543. png_const_bytep output = comp->output;
  544. png_uint_32 avail = (sizeof comp->output);
  545. png_compression_buffer *next = png_ptr->zbuffer_list;
  546. for (;;)
  547. {
  548. if (avail > output_len)
  549. avail = output_len;
  550. png_write_chunk_data(png_ptr, output, avail);
  551. output_len -= avail;
  552. if (output_len == 0 || next == NULL)
  553. break;
  554. avail = png_ptr->zbuffer_size;
  555. output = next->output;
  556. next = next->next;
  557. }
  558. /* This is an internal error; 'next' must have been NULL! */
  559. if (output_len > 0)
  560. png_error(png_ptr, "error writing ancillary chunked compressed data");
  561. }
  562. #endif /* WRITE_COMPRESSED_TEXT */
  563. /* Write the IHDR chunk, and update the png_struct with the necessary
  564. * information. Note that the rest of this code depends upon this
  565. * information being correct.
  566. */
  567. void /* PRIVATE */
  568. png_write_IHDR(png_structrp png_ptr, png_uint_32 width, png_uint_32 height,
  569. int bit_depth, int color_type, int compression_type, int filter_type,
  570. int interlace_type)
  571. {
  572. png_byte buf[13]; /* Buffer to store the IHDR info */
  573. int is_invalid_depth;
  574. png_debug(1, "in png_write_IHDR");
  575. /* Check that we have valid input data from the application info */
  576. switch (color_type)
  577. {
  578. case PNG_COLOR_TYPE_GRAY:
  579. switch (bit_depth)
  580. {
  581. case 1:
  582. case 2:
  583. case 4:
  584. case 8:
  585. #ifdef PNG_WRITE_16BIT_SUPPORTED
  586. case 16:
  587. #endif
  588. png_ptr->channels = 1; break;
  589. default:
  590. png_error(png_ptr,
  591. "Invalid bit depth for grayscale image");
  592. }
  593. break;
  594. case PNG_COLOR_TYPE_RGB:
  595. is_invalid_depth = (bit_depth != 8);
  596. #ifdef PNG_WRITE_16BIT_SUPPORTED
  597. is_invalid_depth = (is_invalid_depth && bit_depth != 16);
  598. #endif
  599. if (is_invalid_depth)
  600. png_error(png_ptr, "Invalid bit depth for RGB image");
  601. png_ptr->channels = 3;
  602. break;
  603. case PNG_COLOR_TYPE_PALETTE:
  604. switch (bit_depth)
  605. {
  606. case 1:
  607. case 2:
  608. case 4:
  609. case 8:
  610. png_ptr->channels = 1;
  611. break;
  612. default:
  613. png_error(png_ptr, "Invalid bit depth for paletted image");
  614. }
  615. break;
  616. case PNG_COLOR_TYPE_GRAY_ALPHA:
  617. is_invalid_depth = (bit_depth != 8);
  618. #ifdef PNG_WRITE_16BIT_SUPPORTED
  619. is_invalid_depth = (is_invalid_depth && bit_depth != 16);
  620. #endif
  621. if (is_invalid_depth)
  622. png_error(png_ptr, "Invalid bit depth for grayscale+alpha image");
  623. png_ptr->channels = 2;
  624. break;
  625. case PNG_COLOR_TYPE_RGB_ALPHA:
  626. is_invalid_depth = (bit_depth != 8);
  627. #ifdef PNG_WRITE_16BIT_SUPPORTED
  628. is_invalid_depth = (is_invalid_depth && bit_depth != 16);
  629. #endif
  630. if (is_invalid_depth)
  631. png_error(png_ptr, "Invalid bit depth for RGBA image");
  632. png_ptr->channels = 4;
  633. break;
  634. default:
  635. png_error(png_ptr, "Invalid image color type specified");
  636. }
  637. if (compression_type != PNG_COMPRESSION_TYPE_BASE)
  638. {
  639. png_warning(png_ptr, "Invalid compression type specified");
  640. compression_type = PNG_COMPRESSION_TYPE_BASE;
  641. }
  642. /* Write filter_method 64 (intrapixel differencing) only if
  643. * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
  644. * 2. Libpng did not write a PNG signature (this filter_method is only
  645. * used in PNG datastreams that are embedded in MNG datastreams) and
  646. * 3. The application called png_permit_mng_features with a mask that
  647. * included PNG_FLAG_MNG_FILTER_64 and
  648. * 4. The filter_method is 64 and
  649. * 5. The color_type is RGB or RGBA
  650. */
  651. if (
  652. #ifdef PNG_MNG_FEATURES_SUPPORTED
  653. !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
  654. ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&
  655. (color_type == PNG_COLOR_TYPE_RGB ||
  656. color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
  657. (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) &&
  658. #endif
  659. filter_type != PNG_FILTER_TYPE_BASE)
  660. {
  661. png_warning(png_ptr, "Invalid filter type specified");
  662. filter_type = PNG_FILTER_TYPE_BASE;
  663. }
  664. #ifdef PNG_WRITE_INTERLACING_SUPPORTED
  665. if (interlace_type != PNG_INTERLACE_NONE &&
  666. interlace_type != PNG_INTERLACE_ADAM7)
  667. {
  668. png_warning(png_ptr, "Invalid interlace type specified");
  669. interlace_type = PNG_INTERLACE_ADAM7;
  670. }
  671. #else
  672. interlace_type=PNG_INTERLACE_NONE;
  673. #endif
  674. /* Save the relevant information */
  675. png_ptr->bit_depth = (png_byte)bit_depth;
  676. png_ptr->color_type = (png_byte)color_type;
  677. png_ptr->interlaced = (png_byte)interlace_type;
  678. #ifdef PNG_MNG_FEATURES_SUPPORTED
  679. png_ptr->filter_type = (png_byte)filter_type;
  680. #endif
  681. png_ptr->compression_type = (png_byte)compression_type;
  682. png_ptr->width = width;
  683. png_ptr->height = height;
  684. png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels);
  685. png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width);
  686. /* Set the usr info, so any transformations can modify it */
  687. png_ptr->usr_width = png_ptr->width;
  688. png_ptr->usr_bit_depth = png_ptr->bit_depth;
  689. png_ptr->usr_channels = png_ptr->channels;
  690. /* Pack the header information into the buffer */
  691. png_save_uint_32(buf, width);
  692. png_save_uint_32(buf + 4, height);
  693. buf[8] = (png_byte)bit_depth;
  694. buf[9] = (png_byte)color_type;
  695. buf[10] = (png_byte)compression_type;
  696. buf[11] = (png_byte)filter_type;
  697. buf[12] = (png_byte)interlace_type;
  698. /* Write the chunk */
  699. png_write_complete_chunk(png_ptr, png_IHDR, buf, 13);
  700. if ((png_ptr->do_filter) == PNG_NO_FILTERS)
  701. {
  702. if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||
  703. png_ptr->bit_depth < 8)
  704. png_ptr->do_filter = PNG_FILTER_NONE;
  705. else
  706. png_ptr->do_filter = PNG_ALL_FILTERS;
  707. }
  708. png_ptr->mode = PNG_HAVE_IHDR; /* not READY_FOR_ZTXT */
  709. }
  710. /* Write the palette. We are careful not to trust png_color to be in the
  711. * correct order for PNG, so people can redefine it to any convenient
  712. * structure.
  713. */
  714. void /* PRIVATE */
  715. png_write_PLTE(png_structrp png_ptr, png_const_colorp palette,
  716. png_uint_32 num_pal)
  717. {
  718. png_uint_32 max_palette_length, i;
  719. png_const_colorp pal_ptr;
  720. png_byte buf[3];
  721. png_debug(1, "in png_write_PLTE");
  722. max_palette_length = (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ?
  723. (1 << png_ptr->bit_depth) : PNG_MAX_PALETTE_LENGTH;
  724. if ((
  725. #ifdef PNG_MNG_FEATURES_SUPPORTED
  726. (png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) == 0 &&
  727. #endif
  728. num_pal == 0) || num_pal > max_palette_length)
  729. {
  730. if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
  731. {
  732. png_error(png_ptr, "Invalid number of colors in palette");
  733. }
  734. else
  735. {
  736. png_warning(png_ptr, "Invalid number of colors in palette");
  737. return;
  738. }
  739. }
  740. if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) == 0)
  741. {
  742. png_warning(png_ptr,
  743. "Ignoring request to write a PLTE chunk in grayscale PNG");
  744. return;
  745. }
  746. png_ptr->num_palette = (png_uint_16)num_pal;
  747. png_debug1(3, "num_palette = %d", png_ptr->num_palette);
  748. png_write_chunk_header(png_ptr, png_PLTE, (png_uint_32)(num_pal * 3));
  749. #ifdef PNG_POINTER_INDEXING_SUPPORTED
  750. for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++)
  751. {
  752. buf[0] = pal_ptr->red;
  753. buf[1] = pal_ptr->green;
  754. buf[2] = pal_ptr->blue;
  755. png_write_chunk_data(png_ptr, buf, 3);
  756. }
  757. #else
  758. /* This is a little slower but some buggy compilers need to do this
  759. * instead
  760. */
  761. pal_ptr=palette;
  762. for (i = 0; i < num_pal; i++)
  763. {
  764. buf[0] = pal_ptr[i].red;
  765. buf[1] = pal_ptr[i].green;
  766. buf[2] = pal_ptr[i].blue;
  767. png_write_chunk_data(png_ptr, buf, 3);
  768. }
  769. #endif
  770. png_write_chunk_end(png_ptr);
  771. png_ptr->mode |= PNG_HAVE_PLTE;
  772. }
  773. /* This is similar to png_text_compress, above, except that it does not require
  774. * all of the data at once and, instead of buffering the compressed result,
  775. * writes it as IDAT chunks. Unlike png_text_compress it *can* png_error out
  776. * because it calls the write interface. As a result it does its own error
  777. * reporting and does not return an error code. In the event of error it will
  778. * just call png_error. The input data length may exceed 32-bits. The 'flush'
  779. * parameter is exactly the same as that to deflate, with the following
  780. * meanings:
  781. *
  782. * Z_NO_FLUSH: normal incremental output of compressed data
  783. * Z_SYNC_FLUSH: do a SYNC_FLUSH, used by png_write_flush
  784. * Z_FINISH: this is the end of the input, do a Z_FINISH and clean up
  785. *
  786. * The routine manages the acquire and release of the png_ptr->zstream by
  787. * checking and (at the end) clearing png_ptr->zowner; it does some sanity
  788. * checks on the 'mode' flags while doing this.
  789. */
  790. void /* PRIVATE */
  791. png_compress_IDAT(png_structrp png_ptr, png_const_bytep input,
  792. png_alloc_size_t input_len, int flush)
  793. {
  794. if (png_ptr->zowner != png_IDAT)
  795. {
  796. /* First time. Ensure we have a temporary buffer for compression and
  797. * trim the buffer list if it has more than one entry to free memory.
  798. * If 'WRITE_COMPRESSED_TEXT' is not set the list will never have been
  799. * created at this point, but the check here is quick and safe.
  800. */
  801. if (png_ptr->zbuffer_list == NULL)
  802. {
  803. png_ptr->zbuffer_list = png_voidcast(png_compression_bufferp,
  804. png_malloc(png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr)));
  805. png_ptr->zbuffer_list->next = NULL;
  806. }
  807. else
  808. png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list->next);
  809. /* It is a terminal error if we can't claim the zstream. */
  810. if (png_deflate_claim(png_ptr, png_IDAT, png_image_size(png_ptr)) != Z_OK)
  811. png_error(png_ptr, png_ptr->zstream.msg);
  812. /* The output state is maintained in png_ptr->zstream, so it must be
  813. * initialized here after the claim.
  814. */
  815. png_ptr->zstream.next_out = png_ptr->zbuffer_list->output;
  816. png_ptr->zstream.avail_out = png_ptr->zbuffer_size;
  817. }
  818. /* Now loop reading and writing until all the input is consumed or an error
  819. * terminates the operation. The _out values are maintained across calls to
  820. * this function, but the input must be reset each time.
  821. */
  822. png_ptr->zstream.next_in = PNGZ_INPUT_CAST(input);
  823. png_ptr->zstream.avail_in = 0; /* set below */
  824. for (;;)
  825. {
  826. int ret;
  827. /* INPUT: from the row data */
  828. uInt avail = ZLIB_IO_MAX;
  829. if (avail > input_len)
  830. avail = (uInt)input_len; /* safe because of the check */
  831. png_ptr->zstream.avail_in = avail;
  832. input_len -= avail;
  833. ret = deflate(&png_ptr->zstream, input_len > 0 ? Z_NO_FLUSH : flush);
  834. /* Include as-yet unconsumed input */
  835. input_len += png_ptr->zstream.avail_in;
  836. png_ptr->zstream.avail_in = 0;
  837. /* OUTPUT: write complete IDAT chunks when avail_out drops to zero. Note
  838. * that these two zstream fields are preserved across the calls, therefore
  839. * there is no need to set these up on entry to the loop.
  840. */
  841. if (png_ptr->zstream.avail_out == 0)
  842. {
  843. png_bytep data = png_ptr->zbuffer_list->output;
  844. uInt size = png_ptr->zbuffer_size;
  845. /* Write an IDAT containing the data then reset the buffer. The
  846. * first IDAT may need deflate header optimization.
  847. */
  848. #ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
  849. if ((png_ptr->mode & PNG_HAVE_IDAT) == 0 &&
  850. png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)
  851. optimize_cmf(data, png_image_size(png_ptr));
  852. #endif
  853. if (size > 0)
  854. png_write_complete_chunk(png_ptr, png_IDAT, data, size);
  855. png_ptr->mode |= PNG_HAVE_IDAT;
  856. png_ptr->zstream.next_out = data;
  857. png_ptr->zstream.avail_out = size;
  858. /* For SYNC_FLUSH or FINISH it is essential to keep calling zlib with
  859. * the same flush parameter until it has finished output, for NO_FLUSH
  860. * it doesn't matter.
  861. */
  862. if (ret == Z_OK && flush != Z_NO_FLUSH)
  863. continue;
  864. }
  865. /* The order of these checks doesn't matter much; it just affects which
  866. * possible error might be detected if multiple things go wrong at once.
  867. */
  868. if (ret == Z_OK) /* most likely return code! */
  869. {
  870. /* If all the input has been consumed then just return. If Z_FINISH
  871. * was used as the flush parameter something has gone wrong if we get
  872. * here.
  873. */
  874. if (input_len == 0)
  875. {
  876. if (flush == Z_FINISH)
  877. png_error(png_ptr, "Z_OK on Z_FINISH with output space");
  878. return;
  879. }
  880. }
  881. else if (ret == Z_STREAM_END && flush == Z_FINISH)
  882. {
  883. /* This is the end of the IDAT data; any pending output must be
  884. * flushed. For small PNG files we may still be at the beginning.
  885. */
  886. png_bytep data = png_ptr->zbuffer_list->output;
  887. uInt size = png_ptr->zbuffer_size - png_ptr->zstream.avail_out;
  888. #ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
  889. if ((png_ptr->mode & PNG_HAVE_IDAT) == 0 &&
  890. png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)
  891. optimize_cmf(data, png_image_size(png_ptr));
  892. #endif
  893. if (size > 0)
  894. png_write_complete_chunk(png_ptr, png_IDAT, data, size);
  895. png_ptr->zstream.avail_out = 0;
  896. png_ptr->zstream.next_out = NULL;
  897. png_ptr->mode |= PNG_HAVE_IDAT | PNG_AFTER_IDAT;
  898. png_ptr->zowner = 0; /* Release the stream */
  899. return;
  900. }
  901. else
  902. {
  903. /* This is an error condition. */
  904. png_zstream_error(png_ptr, ret);
  905. png_error(png_ptr, png_ptr->zstream.msg);
  906. }
  907. }
  908. }
  909. /* Write an IEND chunk */
  910. void /* PRIVATE */
  911. png_write_IEND(png_structrp png_ptr)
  912. {
  913. png_debug(1, "in png_write_IEND");
  914. png_write_complete_chunk(png_ptr, png_IEND, NULL, 0);
  915. png_ptr->mode |= PNG_HAVE_IEND;
  916. }
  917. #ifdef PNG_WRITE_gAMA_SUPPORTED
  918. /* Write a gAMA chunk */
  919. void /* PRIVATE */
  920. png_write_gAMA_fixed(png_structrp png_ptr, png_fixed_point file_gamma)
  921. {
  922. png_byte buf[4];
  923. png_debug(1, "in png_write_gAMA");
  924. /* file_gamma is saved in 1/100,000ths */
  925. png_save_uint_32(buf, (png_uint_32)file_gamma);
  926. png_write_complete_chunk(png_ptr, png_gAMA, buf, 4);
  927. }
  928. #endif
  929. #ifdef PNG_WRITE_sRGB_SUPPORTED
  930. /* Write a sRGB chunk */
  931. void /* PRIVATE */
  932. png_write_sRGB(png_structrp png_ptr, int srgb_intent)
  933. {
  934. png_byte buf[1];
  935. png_debug(1, "in png_write_sRGB");
  936. if (srgb_intent >= PNG_sRGB_INTENT_LAST)
  937. png_warning(png_ptr,
  938. "Invalid sRGB rendering intent specified");
  939. buf[0]=(png_byte)srgb_intent;
  940. png_write_complete_chunk(png_ptr, png_sRGB, buf, 1);
  941. }
  942. #endif
  943. #ifdef PNG_WRITE_iCCP_SUPPORTED
  944. /* Write an iCCP chunk */
  945. void /* PRIVATE */
  946. png_write_iCCP(png_structrp png_ptr, png_const_charp name,
  947. png_const_bytep profile)
  948. {
  949. png_uint_32 name_len;
  950. png_uint_32 profile_len;
  951. png_byte new_name[81]; /* 1 byte for the compression byte */
  952. compression_state comp;
  953. png_uint_32 temp;
  954. png_debug(1, "in png_write_iCCP");
  955. /* These are all internal problems: the profile should have been checked
  956. * before when it was stored.
  957. */
  958. if (profile == NULL)
  959. png_error(png_ptr, "No profile for iCCP chunk"); /* internal error */
  960. profile_len = png_get_uint_32(profile);
  961. if (profile_len < 132)
  962. png_error(png_ptr, "ICC profile too short");
  963. temp = (png_uint_32) (*(profile+8));
  964. if (temp > 3 && (profile_len & 0x03))
  965. png_error(png_ptr, "ICC profile length invalid (not a multiple of 4)");
  966. {
  967. png_uint_32 embedded_profile_len = png_get_uint_32(profile);
  968. if (profile_len != embedded_profile_len)
  969. png_error(png_ptr, "Profile length does not match profile");
  970. }
  971. name_len = png_check_keyword(png_ptr, name, new_name);
  972. if (name_len == 0)
  973. png_error(png_ptr, "iCCP: invalid keyword");
  974. new_name[++name_len] = PNG_COMPRESSION_TYPE_BASE;
  975. /* Make sure we include the NULL after the name and the compression type */
  976. ++name_len;
  977. png_text_compress_init(&comp, profile, profile_len);
  978. /* Allow for keyword terminator and compression byte */
  979. if (png_text_compress(png_ptr, png_iCCP, &comp, name_len) != Z_OK)
  980. png_error(png_ptr, png_ptr->zstream.msg);
  981. png_write_chunk_header(png_ptr, png_iCCP, name_len + comp.output_len);
  982. png_write_chunk_data(png_ptr, new_name, name_len);
  983. png_write_compressed_data_out(png_ptr, &comp);
  984. png_write_chunk_end(png_ptr);
  985. }
  986. #endif
  987. #ifdef PNG_WRITE_sPLT_SUPPORTED
  988. /* Write a sPLT chunk */
  989. void /* PRIVATE */
  990. png_write_sPLT(png_structrp png_ptr, png_const_sPLT_tp spalette)
  991. {
  992. png_uint_32 name_len;
  993. png_byte new_name[80];
  994. png_byte entrybuf[10];
  995. size_t entry_size = (spalette->depth == 8 ? 6 : 10);
  996. size_t palette_size = entry_size * (size_t)spalette->nentries;
  997. png_sPLT_entryp ep;
  998. #ifndef PNG_POINTER_INDEXING_SUPPORTED
  999. int i;
  1000. #endif
  1001. png_debug(1, "in png_write_sPLT");
  1002. name_len = png_check_keyword(png_ptr, spalette->name, new_name);
  1003. if (name_len == 0)
  1004. png_error(png_ptr, "sPLT: invalid keyword");
  1005. /* Make sure we include the NULL after the name */
  1006. png_write_chunk_header(png_ptr, png_sPLT,
  1007. (png_uint_32)(name_len + 2 + palette_size));
  1008. png_write_chunk_data(png_ptr, (png_bytep)new_name, (size_t)(name_len + 1));
  1009. png_write_chunk_data(png_ptr, &spalette->depth, 1);
  1010. /* Loop through each palette entry, writing appropriately */
  1011. #ifdef PNG_POINTER_INDEXING_SUPPORTED
  1012. for (ep = spalette->entries; ep<spalette->entries + spalette->nentries; ep++)
  1013. {
  1014. if (spalette->depth == 8)
  1015. {
  1016. entrybuf[0] = (png_byte)ep->red;
  1017. entrybuf[1] = (png_byte)ep->green;
  1018. entrybuf[2] = (png_byte)ep->blue;
  1019. entrybuf[3] = (png_byte)ep->alpha;
  1020. png_save_uint_16(entrybuf + 4, ep->frequency);
  1021. }
  1022. else
  1023. {
  1024. png_save_uint_16(entrybuf + 0, ep->red);
  1025. png_save_uint_16(entrybuf + 2, ep->green);
  1026. png_save_uint_16(entrybuf + 4, ep->blue);
  1027. png_save_uint_16(entrybuf + 6, ep->alpha);
  1028. png_save_uint_16(entrybuf + 8, ep->frequency);
  1029. }
  1030. png_write_chunk_data(png_ptr, entrybuf, entry_size);
  1031. }
  1032. #else
  1033. ep=spalette->entries;
  1034. for (i = 0; i>spalette->nentries; i++)
  1035. {
  1036. if (spalette->depth == 8)
  1037. {
  1038. entrybuf[0] = (png_byte)ep[i].red;
  1039. entrybuf[1] = (png_byte)ep[i].green;
  1040. entrybuf[2] = (png_byte)ep[i].blue;
  1041. entrybuf[3] = (png_byte)ep[i].alpha;
  1042. png_save_uint_16(entrybuf + 4, ep[i].frequency);
  1043. }
  1044. else
  1045. {
  1046. png_save_uint_16(entrybuf + 0, ep[i].red);
  1047. png_save_uint_16(entrybuf + 2, ep[i].green);
  1048. png_save_uint_16(entrybuf + 4, ep[i].blue);
  1049. png_save_uint_16(entrybuf + 6, ep[i].alpha);
  1050. png_save_uint_16(entrybuf + 8, ep[i].frequency);
  1051. }
  1052. png_write_chunk_data(png_ptr, entrybuf, entry_size);
  1053. }
  1054. #endif
  1055. png_write_chunk_end(png_ptr);
  1056. }
  1057. #endif
  1058. #ifdef PNG_WRITE_sBIT_SUPPORTED
  1059. /* Write the sBIT chunk */
  1060. void /* PRIVATE */
  1061. png_write_sBIT(png_structrp png_ptr, png_const_color_8p sbit, int color_type)
  1062. {
  1063. png_byte buf[4];
  1064. size_t size;
  1065. png_debug(1, "in png_write_sBIT");
  1066. /* Make sure we don't depend upon the order of PNG_COLOR_8 */
  1067. if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
  1068. {
  1069. png_byte maxbits;
  1070. maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 :
  1071. png_ptr->usr_bit_depth);
  1072. if (sbit->red == 0 || sbit->red > maxbits ||
  1073. sbit->green == 0 || sbit->green > maxbits ||
  1074. sbit->blue == 0 || sbit->blue > maxbits)
  1075. {
  1076. png_warning(png_ptr, "Invalid sBIT depth specified");
  1077. return;
  1078. }
  1079. buf[0] = sbit->red;
  1080. buf[1] = sbit->green;
  1081. buf[2] = sbit->blue;
  1082. size = 3;
  1083. }
  1084. else
  1085. {
  1086. if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth)
  1087. {
  1088. png_warning(png_ptr, "Invalid sBIT depth specified");
  1089. return;
  1090. }
  1091. buf[0] = sbit->gray;
  1092. size = 1;
  1093. }
  1094. if ((color_type & PNG_COLOR_MASK_ALPHA) != 0)
  1095. {
  1096. if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth)
  1097. {
  1098. png_warning(png_ptr, "Invalid sBIT depth specified");
  1099. return;
  1100. }
  1101. buf[size++] = sbit->alpha;
  1102. }
  1103. png_write_complete_chunk(png_ptr, png_sBIT, buf, size);
  1104. }
  1105. #endif
  1106. #ifdef PNG_WRITE_cHRM_SUPPORTED
  1107. /* Write the cHRM chunk */
  1108. void /* PRIVATE */
  1109. png_write_cHRM_fixed(png_structrp png_ptr, const png_xy *xy)
  1110. {
  1111. png_byte buf[32];
  1112. png_debug(1, "in png_write_cHRM");
  1113. /* Each value is saved in 1/100,000ths */
  1114. png_save_int_32(buf, xy->whitex);
  1115. png_save_int_32(buf + 4, xy->whitey);
  1116. png_save_int_32(buf + 8, xy->redx);
  1117. png_save_int_32(buf + 12, xy->redy);
  1118. png_save_int_32(buf + 16, xy->greenx);
  1119. png_save_int_32(buf + 20, xy->greeny);
  1120. png_save_int_32(buf + 24, xy->bluex);
  1121. png_save_int_32(buf + 28, xy->bluey);
  1122. png_write_complete_chunk(png_ptr, png_cHRM, buf, 32);
  1123. }
  1124. #endif
  1125. #ifdef PNG_WRITE_tRNS_SUPPORTED
  1126. /* Write the tRNS chunk */
  1127. void /* PRIVATE */
  1128. png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha,
  1129. png_const_color_16p tran, int num_trans, int color_type)
  1130. {
  1131. png_byte buf[6];
  1132. png_debug(1, "in png_write_tRNS");
  1133. if (color_type == PNG_COLOR_TYPE_PALETTE)
  1134. {
  1135. if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette)
  1136. {
  1137. png_app_warning(png_ptr,
  1138. "Invalid number of transparent colors specified");
  1139. return;
  1140. }
  1141. /* Write the chunk out as it is */
  1142. png_write_complete_chunk(png_ptr, png_tRNS, trans_alpha,
  1143. (size_t)num_trans);
  1144. }
  1145. else if (color_type == PNG_COLOR_TYPE_GRAY)
  1146. {
  1147. /* One 16-bit value */
  1148. if (tran->gray >= (1 << png_ptr->bit_depth))
  1149. {
  1150. png_app_warning(png_ptr,
  1151. "Ignoring attempt to write tRNS chunk out-of-range for bit_depth");
  1152. return;
  1153. }
  1154. png_save_uint_16(buf, tran->gray);
  1155. png_write_complete_chunk(png_ptr, png_tRNS, buf, 2);
  1156. }
  1157. else if (color_type == PNG_COLOR_TYPE_RGB)
  1158. {
  1159. /* Three 16-bit values */
  1160. png_save_uint_16(buf, tran->red);
  1161. png_save_uint_16(buf + 2, tran->green);
  1162. png_save_uint_16(buf + 4, tran->blue);
  1163. #ifdef PNG_WRITE_16BIT_SUPPORTED
  1164. if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]) != 0)
  1165. #else
  1166. if ((buf[0] | buf[2] | buf[4]) != 0)
  1167. #endif
  1168. {
  1169. png_app_warning(png_ptr,
  1170. "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8");
  1171. return;
  1172. }
  1173. png_write_complete_chunk(png_ptr, png_tRNS, buf, 6);
  1174. }
  1175. else
  1176. {
  1177. png_app_warning(png_ptr, "Can't write tRNS with an alpha channel");
  1178. }
  1179. }
  1180. #endif
  1181. #ifdef PNG_WRITE_bKGD_SUPPORTED
  1182. /* Write the background chunk */
  1183. void /* PRIVATE */
  1184. png_write_bKGD(png_structrp png_ptr, png_const_color_16p back, int color_type)
  1185. {
  1186. png_byte buf[6];
  1187. png_debug(1, "in png_write_bKGD");
  1188. if (color_type == PNG_COLOR_TYPE_PALETTE)
  1189. {
  1190. if (
  1191. #ifdef PNG_MNG_FEATURES_SUPPORTED
  1192. (png_ptr->num_palette != 0 ||
  1193. (png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) == 0) &&
  1194. #endif
  1195. back->index >= png_ptr->num_palette)
  1196. {
  1197. png_warning(png_ptr, "Invalid background palette index");
  1198. return;
  1199. }
  1200. buf[0] = back->index;
  1201. png_write_complete_chunk(png_ptr, png_bKGD, buf, 1);
  1202. }
  1203. else if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
  1204. {
  1205. png_save_uint_16(buf, back->red);
  1206. png_save_uint_16(buf + 2, back->green);
  1207. png_save_uint_16(buf + 4, back->blue);
  1208. #ifdef PNG_WRITE_16BIT_SUPPORTED
  1209. if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]) != 0)
  1210. #else
  1211. if ((buf[0] | buf[2] | buf[4]) != 0)
  1212. #endif
  1213. {
  1214. png_warning(png_ptr,
  1215. "Ignoring attempt to write 16-bit bKGD chunk "
  1216. "when bit_depth is 8");
  1217. return;
  1218. }
  1219. png_write_complete_chunk(png_ptr, png_bKGD, buf, 6);
  1220. }
  1221. else
  1222. {
  1223. if (back->gray >= (1 << png_ptr->bit_depth))
  1224. {
  1225. png_warning(png_ptr,
  1226. "Ignoring attempt to write bKGD chunk out-of-range for bit_depth");
  1227. return;
  1228. }
  1229. png_save_uint_16(buf, back->gray);
  1230. png_write_complete_chunk(png_ptr, png_bKGD, buf, 2);
  1231. }
  1232. }
  1233. #endif
  1234. #ifdef PNG_WRITE_eXIf_SUPPORTED
  1235. /* Write the Exif data */
  1236. void /* PRIVATE */
  1237. png_write_eXIf(png_structrp png_ptr, png_bytep exif, int num_exif)
  1238. {
  1239. int i;
  1240. png_byte buf[1];
  1241. png_debug(1, "in png_write_eXIf");
  1242. png_write_chunk_header(png_ptr, png_eXIf, (png_uint_32)(num_exif));
  1243. for (i = 0; i < num_exif; i++)
  1244. {
  1245. buf[0] = exif[i];
  1246. png_write_chunk_data(png_ptr, buf, 1);
  1247. }
  1248. png_write_chunk_end(png_ptr);
  1249. }
  1250. #endif
  1251. #ifdef PNG_WRITE_hIST_SUPPORTED
  1252. /* Write the histogram */
  1253. void /* PRIVATE */
  1254. png_write_hIST(png_structrp png_ptr, png_const_uint_16p hist, int num_hist)
  1255. {
  1256. int i;
  1257. png_byte buf[3];
  1258. png_debug(1, "in png_write_hIST");
  1259. if (num_hist > (int)png_ptr->num_palette)
  1260. {
  1261. png_debug2(3, "num_hist = %d, num_palette = %d", num_hist,
  1262. png_ptr->num_palette);
  1263. png_warning(png_ptr, "Invalid number of histogram entries specified");
  1264. return;
  1265. }
  1266. png_write_chunk_header(png_ptr, png_hIST, (png_uint_32)(num_hist * 2));
  1267. for (i = 0; i < num_hist; i++)
  1268. {
  1269. png_save_uint_16(buf, hist[i]);
  1270. png_write_chunk_data(png_ptr, buf, 2);
  1271. }
  1272. png_write_chunk_end(png_ptr);
  1273. }
  1274. #endif
  1275. #ifdef PNG_WRITE_tEXt_SUPPORTED
  1276. /* Write a tEXt chunk */
  1277. void /* PRIVATE */
  1278. png_write_tEXt(png_structrp png_ptr, png_const_charp key, png_const_charp text,
  1279. size_t text_len)
  1280. {
  1281. png_uint_32 key_len;
  1282. png_byte new_key[80];
  1283. png_debug(1, "in png_write_tEXt");
  1284. key_len = png_check_keyword(png_ptr, key, new_key);
  1285. if (key_len == 0)
  1286. png_error(png_ptr, "tEXt: invalid keyword");
  1287. if (text == NULL || *text == '\0')
  1288. text_len = 0;
  1289. else
  1290. text_len = strlen(text);
  1291. if (text_len > PNG_UINT_31_MAX - (key_len+1))
  1292. png_error(png_ptr, "tEXt: text too long");
  1293. /* Make sure we include the 0 after the key */
  1294. png_write_chunk_header(png_ptr, png_tEXt,
  1295. (png_uint_32)/*checked above*/(key_len + text_len + 1));
  1296. /*
  1297. * We leave it to the application to meet PNG-1.0 requirements on the
  1298. * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of
  1299. * any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them.
  1300. * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
  1301. */
  1302. png_write_chunk_data(png_ptr, new_key, key_len + 1);
  1303. if (text_len != 0)
  1304. png_write_chunk_data(png_ptr, (png_const_bytep)text, text_len);
  1305. png_write_chunk_end(png_ptr);
  1306. }
  1307. #endif
  1308. #ifdef PNG_WRITE_zTXt_SUPPORTED
  1309. /* Write a compressed text chunk */
  1310. void /* PRIVATE */
  1311. png_write_zTXt(png_structrp png_ptr, png_const_charp key, png_const_charp text,
  1312. int compression)
  1313. {
  1314. png_uint_32 key_len;
  1315. png_byte new_key[81];
  1316. compression_state comp;
  1317. png_debug(1, "in png_write_zTXt");
  1318. if (compression == PNG_TEXT_COMPRESSION_NONE)
  1319. {
  1320. png_write_tEXt(png_ptr, key, text, 0);
  1321. return;
  1322. }
  1323. if (compression != PNG_TEXT_COMPRESSION_zTXt)
  1324. png_error(png_ptr, "zTXt: invalid compression type");
  1325. key_len = png_check_keyword(png_ptr, key, new_key);
  1326. if (key_len == 0)
  1327. png_error(png_ptr, "zTXt: invalid keyword");
  1328. /* Add the compression method and 1 for the keyword separator. */
  1329. new_key[++key_len] = PNG_COMPRESSION_TYPE_BASE;
  1330. ++key_len;
  1331. /* Compute the compressed data; do it now for the length */
  1332. png_text_compress_init(&comp, (png_const_bytep)text,
  1333. text == NULL ? 0 : strlen(text));
  1334. if (png_text_compress(png_ptr, png_zTXt, &comp, key_len) != Z_OK)
  1335. png_error(png_ptr, png_ptr->zstream.msg);
  1336. /* Write start of chunk */
  1337. png_write_chunk_header(png_ptr, png_zTXt, key_len + comp.output_len);
  1338. /* Write key */
  1339. png_write_chunk_data(png_ptr, new_key, key_len);
  1340. /* Write the compressed data */
  1341. png_write_compressed_data_out(png_ptr, &comp);
  1342. /* Close the chunk */
  1343. png_write_chunk_end(png_ptr);
  1344. }
  1345. #endif
  1346. #ifdef PNG_WRITE_iTXt_SUPPORTED
  1347. /* Write an iTXt chunk */
  1348. void /* PRIVATE */
  1349. png_write_iTXt(png_structrp png_ptr, int compression, png_const_charp key,
  1350. png_const_charp lang, png_const_charp lang_key, png_const_charp text)
  1351. {
  1352. png_uint_32 key_len, prefix_len;
  1353. size_t lang_len, lang_key_len;
  1354. png_byte new_key[82];
  1355. compression_state comp;
  1356. png_debug(1, "in png_write_iTXt");
  1357. key_len = png_check_keyword(png_ptr, key, new_key);
  1358. if (key_len == 0)
  1359. png_error(png_ptr, "iTXt: invalid keyword");
  1360. /* Set the compression flag */
  1361. switch (compression)
  1362. {
  1363. case PNG_ITXT_COMPRESSION_NONE:
  1364. case PNG_TEXT_COMPRESSION_NONE:
  1365. compression = new_key[++key_len] = 0; /* no compression */
  1366. break;
  1367. case PNG_TEXT_COMPRESSION_zTXt:
  1368. case PNG_ITXT_COMPRESSION_zTXt:
  1369. compression = new_key[++key_len] = 1; /* compressed */
  1370. break;
  1371. default:
  1372. png_error(png_ptr, "iTXt: invalid compression");
  1373. }
  1374. new_key[++key_len] = PNG_COMPRESSION_TYPE_BASE;
  1375. ++key_len; /* for the keywod separator */
  1376. /* We leave it to the application to meet PNG-1.0 requirements on the
  1377. * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of
  1378. * any non-Latin-1 characters except for NEWLINE. ISO PNG, however,
  1379. * specifies that the text is UTF-8 and this really doesn't require any
  1380. * checking.
  1381. *
  1382. * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
  1383. *
  1384. * TODO: validate the language tag correctly (see the spec.)
  1385. */
  1386. if (lang == NULL) lang = ""; /* empty language is valid */
  1387. lang_len = strlen(lang)+1;
  1388. if (lang_key == NULL) lang_key = ""; /* may be empty */
  1389. lang_key_len = strlen(lang_key)+1;
  1390. if (text == NULL) text = ""; /* may be empty */
  1391. prefix_len = key_len;
  1392. if (lang_len > PNG_UINT_31_MAX-prefix_len)
  1393. prefix_len = PNG_UINT_31_MAX;
  1394. else
  1395. prefix_len = (png_uint_32)(prefix_len + lang_len);
  1396. if (lang_key_len > PNG_UINT_31_MAX-prefix_len)
  1397. prefix_len = PNG_UINT_31_MAX;
  1398. else
  1399. prefix_len = (png_uint_32)(prefix_len + lang_key_len);
  1400. png_text_compress_init(&comp, (png_const_bytep)text, strlen(text));
  1401. if (compression != 0)
  1402. {
  1403. if (png_text_compress(png_ptr, png_iTXt, &comp, prefix_len) != Z_OK)
  1404. png_error(png_ptr, png_ptr->zstream.msg);
  1405. }
  1406. else
  1407. {
  1408. if (comp.input_len > PNG_UINT_31_MAX-prefix_len)
  1409. png_error(png_ptr, "iTXt: uncompressed text too long");
  1410. /* So the string will fit in a chunk: */
  1411. comp.output_len = (png_uint_32)/*SAFE*/comp.input_len;
  1412. }
  1413. png_write_chunk_header(png_ptr, png_iTXt, comp.output_len + prefix_len);
  1414. png_write_chunk_data(png_ptr, new_key, key_len);
  1415. png_write_chunk_data(png_ptr, (png_const_bytep)lang, lang_len);
  1416. png_write_chunk_data(png_ptr, (png_const_bytep)lang_key, lang_key_len);
  1417. if (compression != 0)
  1418. png_write_compressed_data_out(png_ptr, &comp);
  1419. else
  1420. png_write_chunk_data(png_ptr, (png_const_bytep)text, comp.output_len);
  1421. png_write_chunk_end(png_ptr);
  1422. }
  1423. #endif
  1424. #ifdef PNG_WRITE_oFFs_SUPPORTED
  1425. /* Write the oFFs chunk */
  1426. void /* PRIVATE */
  1427. png_write_oFFs(png_structrp png_ptr, png_int_32 x_offset, png_int_32 y_offset,
  1428. int unit_type)
  1429. {
  1430. png_byte buf[9];
  1431. png_debug(1, "in png_write_oFFs");
  1432. if (unit_type >= PNG_OFFSET_LAST)
  1433. png_warning(png_ptr, "Unrecognized unit type for oFFs chunk");
  1434. png_save_int_32(buf, x_offset);
  1435. png_save_int_32(buf + 4, y_offset);
  1436. buf[8] = (png_byte)unit_type;
  1437. png_write_complete_chunk(png_ptr, png_oFFs, buf, 9);
  1438. }
  1439. #endif
  1440. #ifdef PNG_WRITE_pCAL_SUPPORTED
  1441. /* Write the pCAL chunk (described in the PNG extensions document) */
  1442. void /* PRIVATE */
  1443. png_write_pCAL(png_structrp png_ptr, png_charp purpose, png_int_32 X0,
  1444. png_int_32 X1, int type, int nparams, png_const_charp units,
  1445. png_charpp params)
  1446. {
  1447. png_uint_32 purpose_len;
  1448. size_t units_len, total_len;
  1449. png_size_tp params_len;
  1450. png_byte buf[10];
  1451. png_byte new_purpose[80];
  1452. int i;
  1453. png_debug1(1, "in png_write_pCAL (%d parameters)", nparams);
  1454. if (type >= PNG_EQUATION_LAST)
  1455. png_error(png_ptr, "Unrecognized equation type for pCAL chunk");
  1456. purpose_len = png_check_keyword(png_ptr, purpose, new_purpose);
  1457. if (purpose_len == 0)
  1458. png_error(png_ptr, "pCAL: invalid keyword");
  1459. ++purpose_len; /* terminator */
  1460. png_debug1(3, "pCAL purpose length = %d", (int)purpose_len);
  1461. units_len = strlen(units) + (nparams == 0 ? 0 : 1);
  1462. png_debug1(3, "pCAL units length = %d", (int)units_len);
  1463. total_len = purpose_len + units_len + 10;
  1464. params_len = (png_size_tp)png_malloc(png_ptr,
  1465. (png_alloc_size_t)((png_alloc_size_t)nparams * (sizeof (size_t))));
  1466. /* Find the length of each parameter, making sure we don't count the
  1467. * null terminator for the last parameter.
  1468. */
  1469. for (i = 0; i < nparams; i++)
  1470. {
  1471. params_len[i] = strlen(params[i]) + (i == nparams - 1 ? 0 : 1);
  1472. png_debug2(3, "pCAL parameter %d length = %lu", i,
  1473. (unsigned long)params_len[i]);
  1474. total_len += params_len[i];
  1475. }
  1476. png_debug1(3, "pCAL total length = %d", (int)total_len);
  1477. png_write_chunk_header(png_ptr, png_pCAL, (png_uint_32)total_len);
  1478. png_write_chunk_data(png_ptr, new_purpose, purpose_len);
  1479. png_save_int_32(buf, X0);
  1480. png_save_int_32(buf + 4, X1);
  1481. buf[8] = (png_byte)type;
  1482. buf[9] = (png_byte)nparams;
  1483. png_write_chunk_data(png_ptr, buf, 10);
  1484. png_write_chunk_data(png_ptr, (png_const_bytep)units, (size_t)units_len);
  1485. for (i = 0; i < nparams; i++)
  1486. {
  1487. png_write_chunk_data(png_ptr, (png_const_bytep)params[i], params_len[i]);
  1488. }
  1489. png_free(png_ptr, params_len);
  1490. png_write_chunk_end(png_ptr);
  1491. }
  1492. #endif
  1493. #ifdef PNG_WRITE_sCAL_SUPPORTED
  1494. /* Write the sCAL chunk */
  1495. void /* PRIVATE */
  1496. png_write_sCAL_s(png_structrp png_ptr, int unit, png_const_charp width,
  1497. png_const_charp height)
  1498. {
  1499. png_byte buf[64];
  1500. size_t wlen, hlen, total_len;
  1501. png_debug(1, "in png_write_sCAL_s");
  1502. wlen = strlen(width);
  1503. hlen = strlen(height);
  1504. total_len = wlen + hlen + 2;
  1505. if (total_len > 64)
  1506. {
  1507. png_warning(png_ptr, "Can't write sCAL (buffer too small)");
  1508. return;
  1509. }
  1510. buf[0] = (png_byte)unit;
  1511. memcpy(buf + 1, width, wlen + 1); /* Append the '\0' here */
  1512. memcpy(buf + wlen + 2, height, hlen); /* Do NOT append the '\0' here */
  1513. png_debug1(3, "sCAL total length = %u", (unsigned int)total_len);
  1514. png_write_complete_chunk(png_ptr, png_sCAL, buf, total_len);
  1515. }
  1516. #endif
  1517. #ifdef PNG_WRITE_pHYs_SUPPORTED
  1518. /* Write the pHYs chunk */
  1519. void /* PRIVATE */
  1520. png_write_pHYs(png_structrp png_ptr, png_uint_32 x_pixels_per_unit,
  1521. png_uint_32 y_pixels_per_unit,
  1522. int unit_type)
  1523. {
  1524. png_byte buf[9];
  1525. png_debug(1, "in png_write_pHYs");
  1526. if (unit_type >= PNG_RESOLUTION_LAST)
  1527. png_warning(png_ptr, "Unrecognized unit type for pHYs chunk");
  1528. png_save_uint_32(buf, x_pixels_per_unit);
  1529. png_save_uint_32(buf + 4, y_pixels_per_unit);
  1530. buf[8] = (png_byte)unit_type;
  1531. png_write_complete_chunk(png_ptr, png_pHYs, buf, 9);
  1532. }
  1533. #endif
  1534. #ifdef PNG_WRITE_tIME_SUPPORTED
  1535. /* Write the tIME chunk. Use either png_convert_from_struct_tm()
  1536. * or png_convert_from_time_t(), or fill in the structure yourself.
  1537. */
  1538. void /* PRIVATE */
  1539. png_write_tIME(png_structrp png_ptr, png_const_timep mod_time)
  1540. {
  1541. png_byte buf[7];
  1542. png_debug(1, "in png_write_tIME");
  1543. if (mod_time->month > 12 || mod_time->month < 1 ||
  1544. mod_time->day > 31 || mod_time->day < 1 ||
  1545. mod_time->hour > 23 || mod_time->second > 60)
  1546. {
  1547. png_warning(png_ptr, "Invalid time specified for tIME chunk");
  1548. return;
  1549. }
  1550. png_save_uint_16(buf, mod_time->year);
  1551. buf[2] = mod_time->month;
  1552. buf[3] = mod_time->day;
  1553. buf[4] = mod_time->hour;
  1554. buf[5] = mod_time->minute;
  1555. buf[6] = mod_time->second;
  1556. png_write_complete_chunk(png_ptr, png_tIME, buf, 7);
  1557. }
  1558. #endif
  1559. /* Initializes the row writing capability of libpng */
  1560. void /* PRIVATE */
  1561. png_write_start_row(png_structrp png_ptr)
  1562. {
  1563. #ifdef PNG_WRITE_INTERLACING_SUPPORTED
  1564. /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
  1565. /* Start of interlace block */
  1566. static const png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
  1567. /* Offset to next interlace block */
  1568. static const png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
  1569. /* Start of interlace block in the y direction */
  1570. static const png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
  1571. /* Offset to next interlace block in the y direction */
  1572. static const png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
  1573. #endif
  1574. png_alloc_size_t buf_size;
  1575. int usr_pixel_depth;
  1576. #ifdef PNG_WRITE_FILTER_SUPPORTED
  1577. png_byte filters;
  1578. #endif
  1579. png_debug(1, "in png_write_start_row");
  1580. usr_pixel_depth = png_ptr->usr_channels * png_ptr->usr_bit_depth;
  1581. buf_size = PNG_ROWBYTES(usr_pixel_depth, png_ptr->width) + 1;
  1582. /* 1.5.6: added to allow checking in the row write code. */
  1583. png_ptr->transformed_pixel_depth = png_ptr->pixel_depth;
  1584. png_ptr->maximum_pixel_depth = (png_byte)usr_pixel_depth;
  1585. /* Set up row buffer */
  1586. png_ptr->row_buf = png_voidcast(png_bytep, png_malloc(png_ptr, buf_size));
  1587. png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;
  1588. #ifdef PNG_WRITE_FILTER_SUPPORTED
  1589. filters = png_ptr->do_filter;
  1590. if (png_ptr->height == 1)
  1591. filters &= 0xff & ~(PNG_FILTER_UP|PNG_FILTER_AVG|PNG_FILTER_PAETH);
  1592. if (png_ptr->width == 1)
  1593. filters &= 0xff & ~(PNG_FILTER_SUB|PNG_FILTER_AVG|PNG_FILTER_PAETH);
  1594. if (filters == 0)
  1595. filters = PNG_FILTER_NONE;
  1596. png_ptr->do_filter = filters;
  1597. if (((filters & (PNG_FILTER_SUB | PNG_FILTER_UP | PNG_FILTER_AVG |
  1598. PNG_FILTER_PAETH)) != 0) && png_ptr->try_row == NULL)
  1599. {
  1600. int num_filters = 0;
  1601. png_ptr->try_row = png_voidcast(png_bytep, png_malloc(png_ptr, buf_size));
  1602. if (filters & PNG_FILTER_SUB)
  1603. num_filters++;
  1604. if (filters & PNG_FILTER_UP)
  1605. num_filters++;
  1606. if (filters & PNG_FILTER_AVG)
  1607. num_filters++;
  1608. if (filters & PNG_FILTER_PAETH)
  1609. num_filters++;
  1610. if (num_filters > 1)
  1611. png_ptr->tst_row = png_voidcast(png_bytep, png_malloc(png_ptr,
  1612. buf_size));
  1613. }
  1614. /* We only need to keep the previous row if we are using one of the following
  1615. * filters.
  1616. */
  1617. if ((filters & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH)) != 0)
  1618. png_ptr->prev_row = png_voidcast(png_bytep,
  1619. png_calloc(png_ptr, buf_size));
  1620. #endif /* WRITE_FILTER */
  1621. #ifdef PNG_WRITE_INTERLACING_SUPPORTED
  1622. /* If interlaced, we need to set up width and height of pass */
  1623. if (png_ptr->interlaced != 0)
  1624. {
  1625. if ((png_ptr->transformations & PNG_INTERLACE) == 0)
  1626. {
  1627. png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
  1628. png_pass_ystart[0]) / png_pass_yinc[0];
  1629. png_ptr->usr_width = (png_ptr->width + png_pass_inc[0] - 1 -
  1630. png_pass_start[0]) / png_pass_inc[0];
  1631. }
  1632. else
  1633. {
  1634. png_ptr->num_rows = png_ptr->height;
  1635. png_ptr->usr_width = png_ptr->width;
  1636. }
  1637. }
  1638. else
  1639. #endif
  1640. {
  1641. png_ptr->num_rows = png_ptr->height;
  1642. png_ptr->usr_width = png_ptr->width;
  1643. }
  1644. }
  1645. /* Internal use only. Called when finished processing a row of data. */
  1646. void /* PRIVATE */
  1647. png_write_finish_row(png_structrp png_ptr)
  1648. {
  1649. #ifdef PNG_WRITE_INTERLACING_SUPPORTED
  1650. /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
  1651. /* Start of interlace block */
  1652. static const png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
  1653. /* Offset to next interlace block */
  1654. static const png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
  1655. /* Start of interlace block in the y direction */
  1656. static const png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
  1657. /* Offset to next interlace block in the y direction */
  1658. static const png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
  1659. #endif
  1660. png_debug(1, "in png_write_finish_row");
  1661. /* Next row */
  1662. png_ptr->row_number++;
  1663. /* See if we are done */
  1664. if (png_ptr->row_number < png_ptr->num_rows)
  1665. return;
  1666. #ifdef PNG_WRITE_INTERLACING_SUPPORTED
  1667. /* If interlaced, go to next pass */
  1668. if (png_ptr->interlaced != 0)
  1669. {
  1670. png_ptr->row_number = 0;
  1671. if ((png_ptr->transformations & PNG_INTERLACE) != 0)
  1672. {
  1673. png_ptr->pass++;
  1674. }
  1675. else
  1676. {
  1677. /* Loop until we find a non-zero width or height pass */
  1678. do
  1679. {
  1680. png_ptr->pass++;
  1681. if (png_ptr->pass >= 7)
  1682. break;
  1683. png_ptr->usr_width = (png_ptr->width +
  1684. png_pass_inc[png_ptr->pass] - 1 -
  1685. png_pass_start[png_ptr->pass]) /
  1686. png_pass_inc[png_ptr->pass];
  1687. png_ptr->num_rows = (png_ptr->height +
  1688. png_pass_yinc[png_ptr->pass] - 1 -
  1689. png_pass_ystart[png_ptr->pass]) /
  1690. png_pass_yinc[png_ptr->pass];
  1691. if ((png_ptr->transformations & PNG_INTERLACE) != 0)
  1692. break;
  1693. } while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0);
  1694. }
  1695. /* Reset the row above the image for the next pass */
  1696. if (png_ptr->pass < 7)
  1697. {
  1698. if (png_ptr->prev_row != NULL)
  1699. memset(png_ptr->prev_row, 0,
  1700. PNG_ROWBYTES(png_ptr->usr_channels *
  1701. png_ptr->usr_bit_depth, png_ptr->width) + 1);
  1702. return;
  1703. }
  1704. }
  1705. #endif
  1706. /* If we get here, we've just written the last row, so we need
  1707. to flush the compressor */
  1708. png_compress_IDAT(png_ptr, NULL, 0, Z_FINISH);
  1709. }
  1710. #ifdef PNG_WRITE_INTERLACING_SUPPORTED
  1711. /* Pick out the correct pixels for the interlace pass.
  1712. * The basic idea here is to go through the row with a source
  1713. * pointer and a destination pointer (sp and dp), and copy the
  1714. * correct pixels for the pass. As the row gets compacted,
  1715. * sp will always be >= dp, so we should never overwrite anything.
  1716. * See the default: case for the easiest code to understand.
  1717. */
  1718. void /* PRIVATE */
  1719. png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
  1720. {
  1721. /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
  1722. /* Start of interlace block */
  1723. static const png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
  1724. /* Offset to next interlace block */
  1725. static const png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
  1726. png_debug(1, "in png_do_write_interlace");
  1727. /* We don't have to do anything on the last pass (6) */
  1728. if (pass < 6)
  1729. {
  1730. /* Each pixel depth is handled separately */
  1731. switch (row_info->pixel_depth)
  1732. {
  1733. case 1:
  1734. {
  1735. png_bytep sp;
  1736. png_bytep dp;
  1737. unsigned int shift;
  1738. int d;
  1739. int value;
  1740. png_uint_32 i;
  1741. png_uint_32 row_width = row_info->width;
  1742. dp = row;
  1743. d = 0;
  1744. shift = 7;
  1745. for (i = png_pass_start[pass]; i < row_width;
  1746. i += png_pass_inc[pass])
  1747. {
  1748. sp = row + (size_t)(i >> 3);
  1749. value = (int)(*sp >> (7 - (int)(i & 0x07))) & 0x01;
  1750. d |= (value << shift);
  1751. if (shift == 0)
  1752. {
  1753. shift = 7;
  1754. *dp++ = (png_byte)d;
  1755. d = 0;
  1756. }
  1757. else
  1758. shift--;
  1759. }
  1760. if (shift != 7)
  1761. *dp = (png_byte)d;
  1762. break;
  1763. }
  1764. case 2:
  1765. {
  1766. png_bytep sp;
  1767. png_bytep dp;
  1768. unsigned int shift;
  1769. int d;
  1770. int value;
  1771. png_uint_32 i;
  1772. png_uint_32 row_width = row_info->width;
  1773. dp = row;
  1774. shift = 6;
  1775. d = 0;
  1776. for (i = png_pass_start[pass]; i < row_width;
  1777. i += png_pass_inc[pass])
  1778. {
  1779. sp = row + (size_t)(i >> 2);
  1780. value = (*sp >> ((3 - (int)(i & 0x03)) << 1)) & 0x03;
  1781. d |= (value << shift);
  1782. if (shift == 0)
  1783. {
  1784. shift = 6;
  1785. *dp++ = (png_byte)d;
  1786. d = 0;
  1787. }
  1788. else
  1789. shift -= 2;
  1790. }
  1791. if (shift != 6)
  1792. *dp = (png_byte)d;
  1793. break;
  1794. }
  1795. case 4:
  1796. {
  1797. png_bytep sp;
  1798. png_bytep dp;
  1799. unsigned int shift;
  1800. int d;
  1801. int value;
  1802. png_uint_32 i;
  1803. png_uint_32 row_width = row_info->width;
  1804. dp = row;
  1805. shift = 4;
  1806. d = 0;
  1807. for (i = png_pass_start[pass]; i < row_width;
  1808. i += png_pass_inc[pass])
  1809. {
  1810. sp = row + (size_t)(i >> 1);
  1811. value = (*sp >> ((1 - (int)(i & 0x01)) << 2)) & 0x0f;
  1812. d |= (value << shift);
  1813. if (shift == 0)
  1814. {
  1815. shift = 4;
  1816. *dp++ = (png_byte)d;
  1817. d = 0;
  1818. }
  1819. else
  1820. shift -= 4;
  1821. }
  1822. if (shift != 4)
  1823. *dp = (png_byte)d;
  1824. break;
  1825. }
  1826. default:
  1827. {
  1828. png_bytep sp;
  1829. png_bytep dp;
  1830. png_uint_32 i;
  1831. png_uint_32 row_width = row_info->width;
  1832. size_t pixel_bytes;
  1833. /* Start at the beginning */
  1834. dp = row;
  1835. /* Find out how many bytes each pixel takes up */
  1836. pixel_bytes = (row_info->pixel_depth >> 3);
  1837. /* Loop through the row, only looking at the pixels that matter */
  1838. for (i = png_pass_start[pass]; i < row_width;
  1839. i += png_pass_inc[pass])
  1840. {
  1841. /* Find out where the original pixel is */
  1842. sp = row + (size_t)i * pixel_bytes;
  1843. /* Move the pixel */
  1844. if (dp != sp)
  1845. memcpy(dp, sp, pixel_bytes);
  1846. /* Next pixel */
  1847. dp += pixel_bytes;
  1848. }
  1849. break;
  1850. }
  1851. }
  1852. /* Set new row width */
  1853. row_info->width = (row_info->width +
  1854. png_pass_inc[pass] - 1 -
  1855. png_pass_start[pass]) /
  1856. png_pass_inc[pass];
  1857. row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
  1858. row_info->width);
  1859. }
  1860. }
  1861. #endif
  1862. /* This filters the row, chooses which filter to use, if it has not already
  1863. * been specified by the application, and then writes the row out with the
  1864. * chosen filter.
  1865. */
  1866. static void /* PRIVATE */
  1867. png_write_filtered_row(png_structrp png_ptr, png_bytep filtered_row,
  1868. size_t row_bytes);
  1869. #ifdef PNG_WRITE_FILTER_SUPPORTED
  1870. static size_t /* PRIVATE */
  1871. png_setup_sub_row(png_structrp png_ptr, png_uint_32 bpp,
  1872. size_t row_bytes, size_t lmins)
  1873. {
  1874. png_bytep rp, dp, lp;
  1875. size_t i;
  1876. size_t sum = 0;
  1877. unsigned int v;
  1878. png_ptr->try_row[0] = PNG_FILTER_VALUE_SUB;
  1879. for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1; i < bpp;
  1880. i++, rp++, dp++)
  1881. {
  1882. v = *dp = *rp;
  1883. #ifdef PNG_USE_ABS
  1884. sum += 128 - abs((int)v - 128);
  1885. #else
  1886. sum += (v < 128) ? v : 256 - v;
  1887. #endif
  1888. }
  1889. for (lp = png_ptr->row_buf + 1; i < row_bytes;
  1890. i++, rp++, lp++, dp++)
  1891. {
  1892. v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
  1893. #ifdef PNG_USE_ABS
  1894. sum += 128 - abs((int)v - 128);
  1895. #else
  1896. sum += (v < 128) ? v : 256 - v;
  1897. #endif
  1898. if (sum > lmins) /* We are already worse, don't continue. */
  1899. break;
  1900. }
  1901. return (sum);
  1902. }
  1903. static void /* PRIVATE */
  1904. png_setup_sub_row_only(png_structrp png_ptr, png_uint_32 bpp,
  1905. size_t row_bytes)
  1906. {
  1907. png_bytep rp, dp, lp;
  1908. size_t i;
  1909. png_ptr->try_row[0] = PNG_FILTER_VALUE_SUB;
  1910. for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1; i < bpp;
  1911. i++, rp++, dp++)
  1912. {
  1913. *dp = *rp;
  1914. }
  1915. for (lp = png_ptr->row_buf + 1; i < row_bytes;
  1916. i++, rp++, lp++, dp++)
  1917. {
  1918. *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
  1919. }
  1920. }
  1921. static size_t /* PRIVATE */
  1922. png_setup_up_row(png_structrp png_ptr, size_t row_bytes, size_t lmins)
  1923. {
  1924. png_bytep rp, dp, pp;
  1925. size_t i;
  1926. size_t sum = 0;
  1927. unsigned int v;
  1928. png_ptr->try_row[0] = PNG_FILTER_VALUE_UP;
  1929. for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1,
  1930. pp = png_ptr->prev_row + 1; i < row_bytes;
  1931. i++, rp++, pp++, dp++)
  1932. {
  1933. v = *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);
  1934. #ifdef PNG_USE_ABS
  1935. sum += 128 - abs((int)v - 128);
  1936. #else
  1937. sum += (v < 128) ? v : 256 - v;
  1938. #endif
  1939. if (sum > lmins) /* We are already worse, don't continue. */
  1940. break;
  1941. }
  1942. return (sum);
  1943. }
  1944. static void /* PRIVATE */
  1945. png_setup_up_row_only(png_structrp png_ptr, size_t row_bytes)
  1946. {
  1947. png_bytep rp, dp, pp;
  1948. size_t i;
  1949. png_ptr->try_row[0] = PNG_FILTER_VALUE_UP;
  1950. for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1,
  1951. pp = png_ptr->prev_row + 1; i < row_bytes;
  1952. i++, rp++, pp++, dp++)
  1953. {
  1954. *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);
  1955. }
  1956. }
  1957. static size_t /* PRIVATE */
  1958. png_setup_avg_row(png_structrp png_ptr, png_uint_32 bpp,
  1959. size_t row_bytes, size_t lmins)
  1960. {
  1961. png_bytep rp, dp, pp, lp;
  1962. png_uint_32 i;
  1963. size_t sum = 0;
  1964. unsigned int v;
  1965. png_ptr->try_row[0] = PNG_FILTER_VALUE_AVG;
  1966. for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1,
  1967. pp = png_ptr->prev_row + 1; i < bpp; i++)
  1968. {
  1969. v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
  1970. #ifdef PNG_USE_ABS
  1971. sum += 128 - abs((int)v - 128);
  1972. #else
  1973. sum += (v < 128) ? v : 256 - v;
  1974. #endif
  1975. }
  1976. for (lp = png_ptr->row_buf + 1; i < row_bytes; i++)
  1977. {
  1978. v = *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2))
  1979. & 0xff);
  1980. #ifdef PNG_USE_ABS
  1981. sum += 128 - abs((int)v - 128);
  1982. #else
  1983. sum += (v < 128) ? v : 256 - v;
  1984. #endif
  1985. if (sum > lmins) /* We are already worse, don't continue. */
  1986. break;
  1987. }
  1988. return (sum);
  1989. }
  1990. static void /* PRIVATE */
  1991. png_setup_avg_row_only(png_structrp png_ptr, png_uint_32 bpp,
  1992. size_t row_bytes)
  1993. {
  1994. png_bytep rp, dp, pp, lp;
  1995. png_uint_32 i;
  1996. png_ptr->try_row[0] = PNG_FILTER_VALUE_AVG;
  1997. for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1,
  1998. pp = png_ptr->prev_row + 1; i < bpp; i++)
  1999. {
  2000. *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
  2001. }
  2002. for (lp = png_ptr->row_buf + 1; i < row_bytes; i++)
  2003. {
  2004. *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2))
  2005. & 0xff);
  2006. }
  2007. }
  2008. static size_t /* PRIVATE */
  2009. png_setup_paeth_row(png_structrp png_ptr, png_uint_32 bpp,
  2010. size_t row_bytes, size_t lmins)
  2011. {
  2012. png_bytep rp, dp, pp, cp, lp;
  2013. size_t i;
  2014. size_t sum = 0;
  2015. unsigned int v;
  2016. png_ptr->try_row[0] = PNG_FILTER_VALUE_PAETH;
  2017. for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1,
  2018. pp = png_ptr->prev_row + 1; i < bpp; i++)
  2019. {
  2020. v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
  2021. #ifdef PNG_USE_ABS
  2022. sum += 128 - abs((int)v - 128);
  2023. #else
  2024. sum += (v < 128) ? v : 256 - v;
  2025. #endif
  2026. }
  2027. for (lp = png_ptr->row_buf + 1, cp = png_ptr->prev_row + 1; i < row_bytes;
  2028. i++)
  2029. {
  2030. int a, b, c, pa, pb, pc, p;
  2031. b = *pp++;
  2032. c = *cp++;
  2033. a = *lp++;
  2034. p = b - c;
  2035. pc = a - c;
  2036. #ifdef PNG_USE_ABS
  2037. pa = abs(p);
  2038. pb = abs(pc);
  2039. pc = abs(p + pc);
  2040. #else
  2041. pa = p < 0 ? -p : p;
  2042. pb = pc < 0 ? -pc : pc;
  2043. pc = (p + pc) < 0 ? -(p + pc) : p + pc;
  2044. #endif
  2045. p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
  2046. v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
  2047. #ifdef PNG_USE_ABS
  2048. sum += 128 - abs((int)v - 128);
  2049. #else
  2050. sum += (v < 128) ? v : 256 - v;
  2051. #endif
  2052. if (sum > lmins) /* We are already worse, don't continue. */
  2053. break;
  2054. }
  2055. return (sum);
  2056. }
  2057. static void /* PRIVATE */
  2058. png_setup_paeth_row_only(png_structrp png_ptr, png_uint_32 bpp,
  2059. size_t row_bytes)
  2060. {
  2061. png_bytep rp, dp, pp, cp, lp;
  2062. size_t i;
  2063. png_ptr->try_row[0] = PNG_FILTER_VALUE_PAETH;
  2064. for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1,
  2065. pp = png_ptr->prev_row + 1; i < bpp; i++)
  2066. {
  2067. *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
  2068. }
  2069. for (lp = png_ptr->row_buf + 1, cp = png_ptr->prev_row + 1; i < row_bytes;
  2070. i++)
  2071. {
  2072. int a, b, c, pa, pb, pc, p;
  2073. b = *pp++;
  2074. c = *cp++;
  2075. a = *lp++;
  2076. p = b - c;
  2077. pc = a - c;
  2078. #ifdef PNG_USE_ABS
  2079. pa = abs(p);
  2080. pb = abs(pc);
  2081. pc = abs(p + pc);
  2082. #else
  2083. pa = p < 0 ? -p : p;
  2084. pb = pc < 0 ? -pc : pc;
  2085. pc = (p + pc) < 0 ? -(p + pc) : p + pc;
  2086. #endif
  2087. p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
  2088. *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
  2089. }
  2090. }
  2091. #endif /* WRITE_FILTER */
  2092. void /* PRIVATE */
  2093. png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
  2094. {
  2095. #ifndef PNG_WRITE_FILTER_SUPPORTED
  2096. png_write_filtered_row(png_ptr, png_ptr->row_buf, row_info->rowbytes+1);
  2097. #else
  2098. unsigned int filter_to_do = png_ptr->do_filter;
  2099. png_bytep row_buf;
  2100. png_bytep best_row;
  2101. png_uint_32 bpp;
  2102. size_t mins;
  2103. size_t row_bytes = row_info->rowbytes;
  2104. png_debug(1, "in png_write_find_filter");
  2105. /* Find out how many bytes offset each pixel is */
  2106. bpp = (row_info->pixel_depth + 7) >> 3;
  2107. row_buf = png_ptr->row_buf;
  2108. mins = PNG_SIZE_MAX - 256/* so we can detect potential overflow of the
  2109. running sum */;
  2110. /* The prediction method we use is to find which method provides the
  2111. * smallest value when summing the absolute values of the distances
  2112. * from zero, using anything >= 128 as negative numbers. This is known
  2113. * as the "minimum sum of absolute differences" heuristic. Other
  2114. * heuristics are the "weighted minimum sum of absolute differences"
  2115. * (experimental and can in theory improve compression), and the "zlib
  2116. * predictive" method (not implemented yet), which does test compressions
  2117. * of lines using different filter methods, and then chooses the
  2118. * (series of) filter(s) that give minimum compressed data size (VERY
  2119. * computationally expensive).
  2120. *
  2121. * GRR 980525: consider also
  2122. *
  2123. * (1) minimum sum of absolute differences from running average (i.e.,
  2124. * keep running sum of non-absolute differences & count of bytes)
  2125. * [track dispersion, too? restart average if dispersion too large?]
  2126. *
  2127. * (1b) minimum sum of absolute differences from sliding average, probably
  2128. * with window size <= deflate window (usually 32K)
  2129. *
  2130. * (2) minimum sum of squared differences from zero or running average
  2131. * (i.e., ~ root-mean-square approach)
  2132. */
  2133. /* We don't need to test the 'no filter' case if this is the only filter
  2134. * that has been chosen, as it doesn't actually do anything to the data.
  2135. */
  2136. best_row = png_ptr->row_buf;
  2137. if (PNG_SIZE_MAX/128 <= row_bytes)
  2138. {
  2139. /* Overflow can occur in the calculation, just select the lowest set
  2140. * filter.
  2141. */
  2142. filter_to_do &= 0U-filter_to_do;
  2143. }
  2144. else if ((filter_to_do & PNG_FILTER_NONE) != 0 &&
  2145. filter_to_do != PNG_FILTER_NONE)
  2146. {
  2147. /* Overflow not possible and multiple filters in the list, including the
  2148. * 'none' filter.
  2149. */
  2150. png_bytep rp;
  2151. size_t sum = 0;
  2152. size_t i;
  2153. unsigned int v;
  2154. {
  2155. for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++)
  2156. {
  2157. v = *rp;
  2158. #ifdef PNG_USE_ABS
  2159. sum += 128 - abs((int)v - 128);
  2160. #else
  2161. sum += (v < 128) ? v : 256 - v;
  2162. #endif
  2163. }
  2164. }
  2165. mins = sum;
  2166. }
  2167. /* Sub filter */
  2168. if (filter_to_do == PNG_FILTER_SUB)
  2169. /* It's the only filter so no testing is needed */
  2170. {
  2171. png_setup_sub_row_only(png_ptr, bpp, row_bytes);
  2172. best_row = png_ptr->try_row;
  2173. }
  2174. else if ((filter_to_do & PNG_FILTER_SUB) != 0)
  2175. {
  2176. size_t sum;
  2177. size_t lmins = mins;
  2178. sum = png_setup_sub_row(png_ptr, bpp, row_bytes, lmins);
  2179. if (sum < mins)
  2180. {
  2181. mins = sum;
  2182. best_row = png_ptr->try_row;
  2183. if (png_ptr->tst_row != NULL)
  2184. {
  2185. png_ptr->try_row = png_ptr->tst_row;
  2186. png_ptr->tst_row = best_row;
  2187. }
  2188. }
  2189. }
  2190. /* Up filter */
  2191. if (filter_to_do == PNG_FILTER_UP)
  2192. {
  2193. png_setup_up_row_only(png_ptr, row_bytes);
  2194. best_row = png_ptr->try_row;
  2195. }
  2196. else if ((filter_to_do & PNG_FILTER_UP) != 0)
  2197. {
  2198. size_t sum;
  2199. size_t lmins = mins;
  2200. sum = png_setup_up_row(png_ptr, row_bytes, lmins);
  2201. if (sum < mins)
  2202. {
  2203. mins = sum;
  2204. best_row = png_ptr->try_row;
  2205. if (png_ptr->tst_row != NULL)
  2206. {
  2207. png_ptr->try_row = png_ptr->tst_row;
  2208. png_ptr->tst_row = best_row;
  2209. }
  2210. }
  2211. }
  2212. /* Avg filter */
  2213. if (filter_to_do == PNG_FILTER_AVG)
  2214. {
  2215. png_setup_avg_row_only(png_ptr, bpp, row_bytes);
  2216. best_row = png_ptr->try_row;
  2217. }
  2218. else if ((filter_to_do & PNG_FILTER_AVG) != 0)
  2219. {
  2220. size_t sum;
  2221. size_t lmins = mins;
  2222. sum= png_setup_avg_row(png_ptr, bpp, row_bytes, lmins);
  2223. if (sum < mins)
  2224. {
  2225. mins = sum;
  2226. best_row = png_ptr->try_row;
  2227. if (png_ptr->tst_row != NULL)
  2228. {
  2229. png_ptr->try_row = png_ptr->tst_row;
  2230. png_ptr->tst_row = best_row;
  2231. }
  2232. }
  2233. }
  2234. /* Paeth filter */
  2235. if (filter_to_do == PNG_FILTER_PAETH)
  2236. {
  2237. png_setup_paeth_row_only(png_ptr, bpp, row_bytes);
  2238. best_row = png_ptr->try_row;
  2239. }
  2240. else if ((filter_to_do & PNG_FILTER_PAETH) != 0)
  2241. {
  2242. size_t sum;
  2243. size_t lmins = mins;
  2244. sum = png_setup_paeth_row(png_ptr, bpp, row_bytes, lmins);
  2245. if (sum < mins)
  2246. {
  2247. best_row = png_ptr->try_row;
  2248. if (png_ptr->tst_row != NULL)
  2249. {
  2250. png_ptr->try_row = png_ptr->tst_row;
  2251. png_ptr->tst_row = best_row;
  2252. }
  2253. }
  2254. }
  2255. /* Do the actual writing of the filtered row data from the chosen filter. */
  2256. png_write_filtered_row(png_ptr, best_row, row_info->rowbytes+1);
  2257. #endif /* WRITE_FILTER */
  2258. }
  2259. /* Do the actual writing of a previously filtered row. */
  2260. static void
  2261. png_write_filtered_row(png_structrp png_ptr, png_bytep filtered_row,
  2262. size_t full_row_length/*includes filter byte*/)
  2263. {
  2264. png_debug(1, "in png_write_filtered_row");
  2265. png_debug1(2, "filter = %d", filtered_row[0]);
  2266. png_compress_IDAT(png_ptr, filtered_row, full_row_length, Z_NO_FLUSH);
  2267. #ifdef PNG_WRITE_FILTER_SUPPORTED
  2268. /* Swap the current and previous rows */
  2269. if (png_ptr->prev_row != NULL)
  2270. {
  2271. png_bytep tptr;
  2272. tptr = png_ptr->prev_row;
  2273. png_ptr->prev_row = png_ptr->row_buf;
  2274. png_ptr->row_buf = tptr;
  2275. }
  2276. #endif /* WRITE_FILTER */
  2277. /* Finish row - updates counters and flushes zlib if last row */
  2278. png_write_finish_row(png_ptr);
  2279. #ifdef PNG_WRITE_FLUSH_SUPPORTED
  2280. png_ptr->flush_rows++;
  2281. if (png_ptr->flush_dist > 0 &&
  2282. png_ptr->flush_rows >= png_ptr->flush_dist)
  2283. {
  2284. png_write_flush(png_ptr);
  2285. }
  2286. #endif /* WRITE_FLUSH */
  2287. }
  2288. #endif /* WRITE */