png.c 154 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147414841494150415141524153415441554156415741584159416041614162416341644165416641674168416941704171417241734174417541764177417841794180418141824183418441854186418741884189419041914192419341944195419641974198419942004201420242034204420542064207420842094210421142124213421442154216421742184219422042214222422342244225422642274228422942304231423242334234423542364237423842394240424142424243424442454246424742484249425042514252425342544255425642574258425942604261426242634264426542664267426842694270427142724273427442754276427742784279428042814282428342844285428642874288428942904291429242934294429542964297429842994300430143024303430443054306430743084309431043114312431343144315431643174318431943204321432243234324432543264327432843294330433143324333433443354336433743384339434043414342434343444345434643474348434943504351435243534354435543564357435843594360436143624363436443654366436743684369437043714372437343744375437643774378437943804381438243834384438543864387438843894390439143924393439443954396439743984399440044014402440344044405440644074408440944104411441244134414441544164417441844194420442144224423442444254426442744284429443044314432443344344435443644374438443944404441444244434444444544464447444844494450445144524453445444554456445744584459446044614462446344644465446644674468446944704471447244734474447544764477447844794480448144824483448444854486448744884489449044914492449344944495449644974498449945004501450245034504450545064507450845094510451145124513451445154516451745184519452045214522452345244525452645274528452945304531453245334534453545364537453845394540454145424543454445454546454745484549455045514552455345544555455645574558455945604561456245634564456545664567456845694570457145724573457445754576457745784579458045814582458345844585458645874588458945904591459245934594459545964597459845994600460146024603460446054606460746084609461046114612461346144615
  1. /* png.c - location for general purpose libpng functions
  2. *
  3. * Last changed in libpng 1.6.33 [September 28, 2017]
  4. * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson
  5. * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  6. * (Version 0.88 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. /* Generate a compiler error if there is an old png.h in the search path. */
  14. typedef png_libpng_version_1_6_34 Your_png_h_is_not_version_1_6_34;
  15. #ifdef __GNUC__
  16. /* The version tests may need to be added to, but the problem warning has
  17. * consistently been fixed in GCC versions which obtain wide-spread release.
  18. * The problem is that many versions of GCC rearrange comparison expressions in
  19. * the optimizer in such a way that the results of the comparison will change
  20. * if signed integer overflow occurs. Such comparisons are not permitted in
  21. * ANSI C90, however GCC isn't clever enough to work out that that do not occur
  22. * below in png_ascii_from_fp and png_muldiv, so it produces a warning with
  23. * -Wextra. Unfortunately this is highly dependent on the optimizer and the
  24. * machine architecture so the warning comes and goes unpredictably and is
  25. * impossible to "fix", even were that a good idea.
  26. */
  27. #if __GNUC__ == 7 && __GNUC_MINOR__ == 1
  28. #define GCC_STRICT_OVERFLOW 1
  29. #endif /* GNU 7.1.x */
  30. #endif /* GNU */
  31. #ifndef GCC_STRICT_OVERFLOW
  32. #define GCC_STRICT_OVERFLOW 0
  33. #endif
  34. /* Tells libpng that we have already handled the first "num_bytes" bytes
  35. * of the PNG file signature. If the PNG data is embedded into another
  36. * stream we can set num_bytes = 8 so that libpng will not attempt to read
  37. * or write any of the magic bytes before it starts on the IHDR.
  38. */
  39. #ifdef PNG_READ_SUPPORTED
  40. void PNGAPI
  41. png_set_sig_bytes(png_structrp png_ptr, int num_bytes)
  42. {
  43. unsigned int nb = (unsigned int)num_bytes;
  44. png_debug(1, "in png_set_sig_bytes");
  45. if (png_ptr == NULL)
  46. return;
  47. if (num_bytes < 0)
  48. nb = 0;
  49. if (nb > 8)
  50. png_error(png_ptr, "Too many bytes for PNG signature");
  51. png_ptr->sig_bytes = (png_byte)nb;
  52. }
  53. /* Checks whether the supplied bytes match the PNG signature. We allow
  54. * checking less than the full 8-byte signature so that those apps that
  55. * already read the first few bytes of a file to determine the file type
  56. * can simply check the remaining bytes for extra assurance. Returns
  57. * an integer less than, equal to, or greater than zero if sig is found,
  58. * respectively, to be less than, to match, or be greater than the correct
  59. * PNG signature (this is the same behavior as strcmp, memcmp, etc).
  60. */
  61. int PNGAPI
  62. png_sig_cmp(png_const_bytep sig, png_size_t start, png_size_t num_to_check)
  63. {
  64. png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
  65. if (num_to_check > 8)
  66. num_to_check = 8;
  67. else if (num_to_check < 1)
  68. return (-1);
  69. if (start > 7)
  70. return (-1);
  71. if (start + num_to_check > 8)
  72. num_to_check = 8 - start;
  73. return ((int)(memcmp(&sig[start], &png_signature[start], num_to_check)));
  74. }
  75. #endif /* READ */
  76. #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  77. /* Function to allocate memory for zlib */
  78. PNG_FUNCTION(voidpf /* PRIVATE */,
  79. png_zalloc,(voidpf png_ptr, uInt items, uInt size),PNG_ALLOCATED)
  80. {
  81. png_alloc_size_t num_bytes = size;
  82. if (png_ptr == NULL)
  83. return NULL;
  84. if (items >= (~(png_alloc_size_t)0)/size)
  85. {
  86. png_warning (png_voidcast(png_structrp, png_ptr),
  87. "Potential overflow in png_zalloc()");
  88. return NULL;
  89. }
  90. num_bytes *= items;
  91. return png_malloc_warn(png_voidcast(png_structrp, png_ptr), num_bytes);
  92. }
  93. /* Function to free memory for zlib */
  94. void /* PRIVATE */
  95. png_zfree(voidpf png_ptr, voidpf ptr)
  96. {
  97. png_free(png_voidcast(png_const_structrp,png_ptr), ptr);
  98. }
  99. /* Reset the CRC variable to 32 bits of 1's. Care must be taken
  100. * in case CRC is > 32 bits to leave the top bits 0.
  101. */
  102. void /* PRIVATE */
  103. png_reset_crc(png_structrp png_ptr)
  104. {
  105. /* The cast is safe because the crc is a 32-bit value. */
  106. png_ptr->crc = (png_uint_32)crc32(0, Z_NULL, 0);
  107. }
  108. /* Calculate the CRC over a section of data. We can only pass as
  109. * much data to this routine as the largest single buffer size. We
  110. * also check that this data will actually be used before going to the
  111. * trouble of calculating it.
  112. */
  113. void /* PRIVATE */
  114. png_calculate_crc(png_structrp png_ptr, png_const_bytep ptr, png_size_t length)
  115. {
  116. int need_crc = 1;
  117. if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name) != 0)
  118. {
  119. if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
  120. (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
  121. need_crc = 0;
  122. }
  123. else /* critical */
  124. {
  125. if ((png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) != 0)
  126. need_crc = 0;
  127. }
  128. /* 'uLong' is defined in zlib.h as unsigned long; this means that on some
  129. * systems it is a 64-bit value. crc32, however, returns 32 bits so the
  130. * following cast is safe. 'uInt' may be no more than 16 bits, so it is
  131. * necessary to perform a loop here.
  132. */
  133. if (need_crc != 0 && length > 0)
  134. {
  135. uLong crc = png_ptr->crc; /* Should never issue a warning */
  136. do
  137. {
  138. uInt safe_length = (uInt)length;
  139. #ifndef __COVERITY__
  140. if (safe_length == 0)
  141. safe_length = (uInt)-1; /* evil, but safe */
  142. #endif
  143. crc = crc32(crc, ptr, safe_length);
  144. /* The following should never issue compiler warnings; if they do the
  145. * target system has characteristics that will probably violate other
  146. * assumptions within the libpng code.
  147. */
  148. ptr += safe_length;
  149. length -= safe_length;
  150. }
  151. while (length > 0);
  152. /* And the following is always safe because the crc is only 32 bits. */
  153. png_ptr->crc = (png_uint_32)crc;
  154. }
  155. }
  156. /* Check a user supplied version number, called from both read and write
  157. * functions that create a png_struct.
  158. */
  159. int
  160. png_user_version_check(png_structrp png_ptr, png_const_charp user_png_ver)
  161. {
  162. /* Libpng versions 1.0.0 and later are binary compatible if the version
  163. * string matches through the second '.'; we must recompile any
  164. * applications that use any older library version.
  165. */
  166. if (user_png_ver != NULL)
  167. {
  168. int i = -1;
  169. int found_dots = 0;
  170. do
  171. {
  172. i++;
  173. if (user_png_ver[i] != PNG_LIBPNG_VER_STRING[i])
  174. png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
  175. if (user_png_ver[i] == '.')
  176. found_dots++;
  177. } while (found_dots < 2 && user_png_ver[i] != 0 &&
  178. PNG_LIBPNG_VER_STRING[i] != 0);
  179. }
  180. else
  181. png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
  182. if ((png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) != 0)
  183. {
  184. #ifdef PNG_WARNINGS_SUPPORTED
  185. size_t pos = 0;
  186. char m[128];
  187. pos = png_safecat(m, (sizeof m), pos,
  188. "Application built with libpng-");
  189. pos = png_safecat(m, (sizeof m), pos, user_png_ver);
  190. pos = png_safecat(m, (sizeof m), pos, " but running with ");
  191. pos = png_safecat(m, (sizeof m), pos, PNG_LIBPNG_VER_STRING);
  192. PNG_UNUSED(pos)
  193. png_warning(png_ptr, m);
  194. #endif
  195. #ifdef PNG_ERROR_NUMBERS_SUPPORTED
  196. png_ptr->flags = 0;
  197. #endif
  198. return 0;
  199. }
  200. /* Success return. */
  201. return 1;
  202. }
  203. /* Generic function to create a png_struct for either read or write - this
  204. * contains the common initialization.
  205. */
  206. PNG_FUNCTION(png_structp /* PRIVATE */,
  207. png_create_png_struct,(png_const_charp user_png_ver, png_voidp error_ptr,
  208. png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
  209. png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED)
  210. {
  211. png_struct create_struct;
  212. # ifdef PNG_SETJMP_SUPPORTED
  213. jmp_buf create_jmp_buf;
  214. # endif
  215. /* This temporary stack-allocated structure is used to provide a place to
  216. * build enough context to allow the user provided memory allocator (if any)
  217. * to be called.
  218. */
  219. memset(&create_struct, 0, (sizeof create_struct));
  220. /* Added at libpng-1.2.6 */
  221. # ifdef PNG_USER_LIMITS_SUPPORTED
  222. create_struct.user_width_max = PNG_USER_WIDTH_MAX;
  223. create_struct.user_height_max = PNG_USER_HEIGHT_MAX;
  224. # ifdef PNG_USER_CHUNK_CACHE_MAX
  225. /* Added at libpng-1.2.43 and 1.4.0 */
  226. create_struct.user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX;
  227. # endif
  228. # ifdef PNG_USER_CHUNK_MALLOC_MAX
  229. /* Added at libpng-1.2.43 and 1.4.1, required only for read but exists
  230. * in png_struct regardless.
  231. */
  232. create_struct.user_chunk_malloc_max = PNG_USER_CHUNK_MALLOC_MAX;
  233. # endif
  234. # endif
  235. /* The following two API calls simply set fields in png_struct, so it is safe
  236. * to do them now even though error handling is not yet set up.
  237. */
  238. # ifdef PNG_USER_MEM_SUPPORTED
  239. png_set_mem_fn(&create_struct, mem_ptr, malloc_fn, free_fn);
  240. # else
  241. PNG_UNUSED(mem_ptr)
  242. PNG_UNUSED(malloc_fn)
  243. PNG_UNUSED(free_fn)
  244. # endif
  245. /* (*error_fn) can return control to the caller after the error_ptr is set,
  246. * this will result in a memory leak unless the error_fn does something
  247. * extremely sophisticated. The design lacks merit but is implicit in the
  248. * API.
  249. */
  250. png_set_error_fn(&create_struct, error_ptr, error_fn, warn_fn);
  251. # ifdef PNG_SETJMP_SUPPORTED
  252. if (!setjmp(create_jmp_buf))
  253. # endif
  254. {
  255. # ifdef PNG_SETJMP_SUPPORTED
  256. /* Temporarily fake out the longjmp information until we have
  257. * successfully completed this function. This only works if we have
  258. * setjmp() support compiled in, but it is safe - this stuff should
  259. * never happen.
  260. */
  261. create_struct.jmp_buf_ptr = &create_jmp_buf;
  262. create_struct.jmp_buf_size = 0; /*stack allocation*/
  263. create_struct.longjmp_fn = longjmp;
  264. # endif
  265. /* Call the general version checker (shared with read and write code):
  266. */
  267. if (png_user_version_check(&create_struct, user_png_ver) != 0)
  268. {
  269. png_structrp png_ptr = png_voidcast(png_structrp,
  270. png_malloc_warn(&create_struct, (sizeof *png_ptr)));
  271. if (png_ptr != NULL)
  272. {
  273. /* png_ptr->zstream holds a back-pointer to the png_struct, so
  274. * this can only be done now:
  275. */
  276. create_struct.zstream.zalloc = png_zalloc;
  277. create_struct.zstream.zfree = png_zfree;
  278. create_struct.zstream.opaque = png_ptr;
  279. # ifdef PNG_SETJMP_SUPPORTED
  280. /* Eliminate the local error handling: */
  281. create_struct.jmp_buf_ptr = NULL;
  282. create_struct.jmp_buf_size = 0;
  283. create_struct.longjmp_fn = 0;
  284. # endif
  285. *png_ptr = create_struct;
  286. /* This is the successful return point */
  287. return png_ptr;
  288. }
  289. }
  290. }
  291. /* A longjmp because of a bug in the application storage allocator or a
  292. * simple failure to allocate the png_struct.
  293. */
  294. return NULL;
  295. }
  296. /* Allocate the memory for an info_struct for the application. */
  297. PNG_FUNCTION(png_infop,PNGAPI
  298. png_create_info_struct,(png_const_structrp png_ptr),PNG_ALLOCATED)
  299. {
  300. png_inforp info_ptr;
  301. png_debug(1, "in png_create_info_struct");
  302. if (png_ptr == NULL)
  303. return NULL;
  304. /* Use the internal API that does not (or at least should not) error out, so
  305. * that this call always returns ok. The application typically sets up the
  306. * error handling *after* creating the info_struct because this is the way it
  307. * has always been done in 'example.c'.
  308. */
  309. info_ptr = png_voidcast(png_inforp, png_malloc_base(png_ptr,
  310. (sizeof *info_ptr)));
  311. if (info_ptr != NULL)
  312. memset(info_ptr, 0, (sizeof *info_ptr));
  313. return info_ptr;
  314. }
  315. /* This function frees the memory associated with a single info struct.
  316. * Normally, one would use either png_destroy_read_struct() or
  317. * png_destroy_write_struct() to free an info struct, but this may be
  318. * useful for some applications. From libpng 1.6.0 this function is also used
  319. * internally to implement the png_info release part of the 'struct' destroy
  320. * APIs. This ensures that all possible approaches free the same data (all of
  321. * it).
  322. */
  323. void PNGAPI
  324. png_destroy_info_struct(png_const_structrp png_ptr, png_infopp info_ptr_ptr)
  325. {
  326. png_inforp info_ptr = NULL;
  327. png_debug(1, "in png_destroy_info_struct");
  328. if (png_ptr == NULL)
  329. return;
  330. if (info_ptr_ptr != NULL)
  331. info_ptr = *info_ptr_ptr;
  332. if (info_ptr != NULL)
  333. {
  334. /* Do this first in case of an error below; if the app implements its own
  335. * memory management this can lead to png_free calling png_error, which
  336. * will abort this routine and return control to the app error handler.
  337. * An infinite loop may result if it then tries to free the same info
  338. * ptr.
  339. */
  340. *info_ptr_ptr = NULL;
  341. png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
  342. memset(info_ptr, 0, (sizeof *info_ptr));
  343. png_free(png_ptr, info_ptr);
  344. }
  345. }
  346. /* Initialize the info structure. This is now an internal function (0.89)
  347. * and applications using it are urged to use png_create_info_struct()
  348. * instead. Use deprecated in 1.6.0, internal use removed (used internally it
  349. * is just a memset).
  350. *
  351. * NOTE: it is almost inconceivable that this API is used because it bypasses
  352. * the user-memory mechanism and the user error handling/warning mechanisms in
  353. * those cases where it does anything other than a memset.
  354. */
  355. PNG_FUNCTION(void,PNGAPI
  356. png_info_init_3,(png_infopp ptr_ptr, png_size_t png_info_struct_size),
  357. PNG_DEPRECATED)
  358. {
  359. png_inforp info_ptr = *ptr_ptr;
  360. png_debug(1, "in png_info_init_3");
  361. if (info_ptr == NULL)
  362. return;
  363. if ((sizeof (png_info)) > png_info_struct_size)
  364. {
  365. *ptr_ptr = NULL;
  366. /* The following line is why this API should not be used: */
  367. free(info_ptr);
  368. info_ptr = png_voidcast(png_inforp, png_malloc_base(NULL,
  369. (sizeof *info_ptr)));
  370. if (info_ptr == NULL)
  371. return;
  372. *ptr_ptr = info_ptr;
  373. }
  374. /* Set everything to 0 */
  375. memset(info_ptr, 0, (sizeof *info_ptr));
  376. }
  377. /* The following API is not called internally */
  378. void PNGAPI
  379. png_data_freer(png_const_structrp png_ptr, png_inforp info_ptr,
  380. int freer, png_uint_32 mask)
  381. {
  382. png_debug(1, "in png_data_freer");
  383. if (png_ptr == NULL || info_ptr == NULL)
  384. return;
  385. if (freer == PNG_DESTROY_WILL_FREE_DATA)
  386. info_ptr->free_me |= mask;
  387. else if (freer == PNG_USER_WILL_FREE_DATA)
  388. info_ptr->free_me &= ~mask;
  389. else
  390. png_error(png_ptr, "Unknown freer parameter in png_data_freer");
  391. }
  392. void PNGAPI
  393. png_free_data(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 mask,
  394. int num)
  395. {
  396. png_debug(1, "in png_free_data");
  397. if (png_ptr == NULL || info_ptr == NULL)
  398. return;
  399. #ifdef PNG_TEXT_SUPPORTED
  400. /* Free text item num or (if num == -1) all text items */
  401. if (info_ptr->text != NULL &&
  402. ((mask & PNG_FREE_TEXT) & info_ptr->free_me) != 0)
  403. {
  404. if (num != -1)
  405. {
  406. png_free(png_ptr, info_ptr->text[num].key);
  407. info_ptr->text[num].key = NULL;
  408. }
  409. else
  410. {
  411. int i;
  412. for (i = 0; i < info_ptr->num_text; i++)
  413. png_free(png_ptr, info_ptr->text[i].key);
  414. png_free(png_ptr, info_ptr->text);
  415. info_ptr->text = NULL;
  416. info_ptr->num_text = 0;
  417. info_ptr->max_text = 0;
  418. }
  419. }
  420. #endif
  421. #ifdef PNG_tRNS_SUPPORTED
  422. /* Free any tRNS entry */
  423. if (((mask & PNG_FREE_TRNS) & info_ptr->free_me) != 0)
  424. {
  425. info_ptr->valid &= ~PNG_INFO_tRNS;
  426. png_free(png_ptr, info_ptr->trans_alpha);
  427. info_ptr->trans_alpha = NULL;
  428. info_ptr->num_trans = 0;
  429. }
  430. #endif
  431. #ifdef PNG_sCAL_SUPPORTED
  432. /* Free any sCAL entry */
  433. if (((mask & PNG_FREE_SCAL) & info_ptr->free_me) != 0)
  434. {
  435. png_free(png_ptr, info_ptr->scal_s_width);
  436. png_free(png_ptr, info_ptr->scal_s_height);
  437. info_ptr->scal_s_width = NULL;
  438. info_ptr->scal_s_height = NULL;
  439. info_ptr->valid &= ~PNG_INFO_sCAL;
  440. }
  441. #endif
  442. #ifdef PNG_pCAL_SUPPORTED
  443. /* Free any pCAL entry */
  444. if (((mask & PNG_FREE_PCAL) & info_ptr->free_me) != 0)
  445. {
  446. png_free(png_ptr, info_ptr->pcal_purpose);
  447. png_free(png_ptr, info_ptr->pcal_units);
  448. info_ptr->pcal_purpose = NULL;
  449. info_ptr->pcal_units = NULL;
  450. if (info_ptr->pcal_params != NULL)
  451. {
  452. int i;
  453. for (i = 0; i < info_ptr->pcal_nparams; i++)
  454. png_free(png_ptr, info_ptr->pcal_params[i]);
  455. png_free(png_ptr, info_ptr->pcal_params);
  456. info_ptr->pcal_params = NULL;
  457. }
  458. info_ptr->valid &= ~PNG_INFO_pCAL;
  459. }
  460. #endif
  461. #ifdef PNG_iCCP_SUPPORTED
  462. /* Free any profile entry */
  463. if (((mask & PNG_FREE_ICCP) & info_ptr->free_me) != 0)
  464. {
  465. png_free(png_ptr, info_ptr->iccp_name);
  466. png_free(png_ptr, info_ptr->iccp_profile);
  467. info_ptr->iccp_name = NULL;
  468. info_ptr->iccp_profile = NULL;
  469. info_ptr->valid &= ~PNG_INFO_iCCP;
  470. }
  471. #endif
  472. #ifdef PNG_sPLT_SUPPORTED
  473. /* Free a given sPLT entry, or (if num == -1) all sPLT entries */
  474. if (info_ptr->splt_palettes != NULL &&
  475. ((mask & PNG_FREE_SPLT) & info_ptr->free_me) != 0)
  476. {
  477. if (num != -1)
  478. {
  479. png_free(png_ptr, info_ptr->splt_palettes[num].name);
  480. png_free(png_ptr, info_ptr->splt_palettes[num].entries);
  481. info_ptr->splt_palettes[num].name = NULL;
  482. info_ptr->splt_palettes[num].entries = NULL;
  483. }
  484. else
  485. {
  486. int i;
  487. for (i = 0; i < info_ptr->splt_palettes_num; i++)
  488. {
  489. png_free(png_ptr, info_ptr->splt_palettes[i].name);
  490. png_free(png_ptr, info_ptr->splt_palettes[i].entries);
  491. }
  492. png_free(png_ptr, info_ptr->splt_palettes);
  493. info_ptr->splt_palettes = NULL;
  494. info_ptr->splt_palettes_num = 0;
  495. info_ptr->valid &= ~PNG_INFO_sPLT;
  496. }
  497. }
  498. #endif
  499. #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
  500. if (info_ptr->unknown_chunks != NULL &&
  501. ((mask & PNG_FREE_UNKN) & info_ptr->free_me) != 0)
  502. {
  503. if (num != -1)
  504. {
  505. png_free(png_ptr, info_ptr->unknown_chunks[num].data);
  506. info_ptr->unknown_chunks[num].data = NULL;
  507. }
  508. else
  509. {
  510. int i;
  511. for (i = 0; i < info_ptr->unknown_chunks_num; i++)
  512. png_free(png_ptr, info_ptr->unknown_chunks[i].data);
  513. png_free(png_ptr, info_ptr->unknown_chunks);
  514. info_ptr->unknown_chunks = NULL;
  515. info_ptr->unknown_chunks_num = 0;
  516. }
  517. }
  518. #endif
  519. #ifdef PNG_eXIf_SUPPORTED
  520. /* Free any eXIf entry */
  521. if (((mask & PNG_FREE_EXIF) & info_ptr->free_me) != 0)
  522. {
  523. # ifdef PNG_READ_eXIf_SUPPORTED
  524. if (info_ptr->eXIf_buf)
  525. {
  526. png_free(png_ptr, info_ptr->eXIf_buf);
  527. info_ptr->eXIf_buf = NULL;
  528. }
  529. # endif
  530. if (info_ptr->exif)
  531. {
  532. png_free(png_ptr, info_ptr->exif);
  533. info_ptr->exif = NULL;
  534. }
  535. info_ptr->valid &= ~PNG_INFO_eXIf;
  536. }
  537. #endif
  538. #ifdef PNG_hIST_SUPPORTED
  539. /* Free any hIST entry */
  540. if (((mask & PNG_FREE_HIST) & info_ptr->free_me) != 0)
  541. {
  542. png_free(png_ptr, info_ptr->hist);
  543. info_ptr->hist = NULL;
  544. info_ptr->valid &= ~PNG_INFO_hIST;
  545. }
  546. #endif
  547. /* Free any PLTE entry that was internally allocated */
  548. if (((mask & PNG_FREE_PLTE) & info_ptr->free_me) != 0)
  549. {
  550. png_free(png_ptr, info_ptr->palette);
  551. info_ptr->palette = NULL;
  552. info_ptr->valid &= ~PNG_INFO_PLTE;
  553. info_ptr->num_palette = 0;
  554. }
  555. #ifdef PNG_INFO_IMAGE_SUPPORTED
  556. /* Free any image bits attached to the info structure */
  557. if (((mask & PNG_FREE_ROWS) & info_ptr->free_me) != 0)
  558. {
  559. if (info_ptr->row_pointers != NULL)
  560. {
  561. png_uint_32 row;
  562. for (row = 0; row < info_ptr->height; row++)
  563. png_free(png_ptr, info_ptr->row_pointers[row]);
  564. png_free(png_ptr, info_ptr->row_pointers);
  565. info_ptr->row_pointers = NULL;
  566. }
  567. info_ptr->valid &= ~PNG_INFO_IDAT;
  568. }
  569. #endif
  570. if (num != -1)
  571. mask &= ~PNG_FREE_MUL;
  572. info_ptr->free_me &= ~mask;
  573. }
  574. #endif /* READ || WRITE */
  575. /* This function returns a pointer to the io_ptr associated with the user
  576. * functions. The application should free any memory associated with this
  577. * pointer before png_write_destroy() or png_read_destroy() are called.
  578. */
  579. png_voidp PNGAPI
  580. png_get_io_ptr(png_const_structrp png_ptr)
  581. {
  582. if (png_ptr == NULL)
  583. return (NULL);
  584. return (png_ptr->io_ptr);
  585. }
  586. #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  587. # ifdef PNG_STDIO_SUPPORTED
  588. /* Initialize the default input/output functions for the PNG file. If you
  589. * use your own read or write routines, you can call either png_set_read_fn()
  590. * or png_set_write_fn() instead of png_init_io(). If you have defined
  591. * PNG_NO_STDIO or otherwise disabled PNG_STDIO_SUPPORTED, you must use a
  592. * function of your own because "FILE *" isn't necessarily available.
  593. */
  594. void PNGAPI
  595. png_init_io(png_structrp png_ptr, png_FILE_p fp)
  596. {
  597. png_debug(1, "in png_init_io");
  598. if (png_ptr == NULL)
  599. return;
  600. png_ptr->io_ptr = (png_voidp)fp;
  601. }
  602. # endif
  603. # ifdef PNG_SAVE_INT_32_SUPPORTED
  604. /* PNG signed integers are saved in 32-bit 2's complement format. ANSI C-90
  605. * defines a cast of a signed integer to an unsigned integer either to preserve
  606. * the value, if it is positive, or to calculate:
  607. *
  608. * (UNSIGNED_MAX+1) + integer
  609. *
  610. * Where UNSIGNED_MAX is the appropriate maximum unsigned value, so when the
  611. * negative integral value is added the result will be an unsigned value
  612. * correspnding to the 2's complement representation.
  613. */
  614. void PNGAPI
  615. png_save_int_32(png_bytep buf, png_int_32 i)
  616. {
  617. png_save_uint_32(buf, (png_uint_32)i);
  618. }
  619. # endif
  620. # ifdef PNG_TIME_RFC1123_SUPPORTED
  621. /* Convert the supplied time into an RFC 1123 string suitable for use in
  622. * a "Creation Time" or other text-based time string.
  623. */
  624. int PNGAPI
  625. png_convert_to_rfc1123_buffer(char out[29], png_const_timep ptime)
  626. {
  627. static PNG_CONST char short_months[12][4] =
  628. {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
  629. "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
  630. if (out == NULL)
  631. return 0;
  632. if (ptime->year > 9999 /* RFC1123 limitation */ ||
  633. ptime->month == 0 || ptime->month > 12 ||
  634. ptime->day == 0 || ptime->day > 31 ||
  635. ptime->hour > 23 || ptime->minute > 59 ||
  636. ptime->second > 60)
  637. return 0;
  638. {
  639. size_t pos = 0;
  640. char number_buf[5]; /* enough for a four-digit year */
  641. # define APPEND_STRING(string) pos = png_safecat(out, 29, pos, (string))
  642. # define APPEND_NUMBER(format, value)\
  643. APPEND_STRING(PNG_FORMAT_NUMBER(number_buf, format, (value)))
  644. # define APPEND(ch) if (pos < 28) out[pos++] = (ch)
  645. APPEND_NUMBER(PNG_NUMBER_FORMAT_u, (unsigned)ptime->day);
  646. APPEND(' ');
  647. APPEND_STRING(short_months[(ptime->month - 1)]);
  648. APPEND(' ');
  649. APPEND_NUMBER(PNG_NUMBER_FORMAT_u, ptime->year);
  650. APPEND(' ');
  651. APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->hour);
  652. APPEND(':');
  653. APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->minute);
  654. APPEND(':');
  655. APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->second);
  656. APPEND_STRING(" +0000"); /* This reliably terminates the buffer */
  657. PNG_UNUSED (pos)
  658. # undef APPEND
  659. # undef APPEND_NUMBER
  660. # undef APPEND_STRING
  661. }
  662. return 1;
  663. }
  664. # if PNG_LIBPNG_VER < 10700
  665. /* To do: remove the following from libpng-1.7 */
  666. /* Original API that uses a private buffer in png_struct.
  667. * Deprecated because it causes png_struct to carry a spurious temporary
  668. * buffer (png_struct::time_buffer), better to have the caller pass this in.
  669. */
  670. png_const_charp PNGAPI
  671. png_convert_to_rfc1123(png_structrp png_ptr, png_const_timep ptime)
  672. {
  673. if (png_ptr != NULL)
  674. {
  675. /* The only failure above if png_ptr != NULL is from an invalid ptime */
  676. if (png_convert_to_rfc1123_buffer(png_ptr->time_buffer, ptime) == 0)
  677. png_warning(png_ptr, "Ignoring invalid time value");
  678. else
  679. return png_ptr->time_buffer;
  680. }
  681. return NULL;
  682. }
  683. # endif /* LIBPNG_VER < 10700 */
  684. # endif /* TIME_RFC1123 */
  685. #endif /* READ || WRITE */
  686. png_const_charp PNGAPI
  687. png_get_copyright(png_const_structrp png_ptr)
  688. {
  689. PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */
  690. #ifdef PNG_STRING_COPYRIGHT
  691. return PNG_STRING_COPYRIGHT
  692. #else
  693. # ifdef __STDC__
  694. return PNG_STRING_NEWLINE \
  695. "libpng version 1.6.34 - September 29, 2017" PNG_STRING_NEWLINE \
  696. "Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson" \
  697. PNG_STRING_NEWLINE \
  698. "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
  699. "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \
  700. PNG_STRING_NEWLINE;
  701. # else
  702. return "libpng version 1.6.34 - September 29, 2017\
  703. Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson\
  704. Copyright (c) 1996-1997 Andreas Dilger\
  705. Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.";
  706. # endif
  707. #endif
  708. }
  709. /* The following return the library version as a short string in the
  710. * format 1.0.0 through 99.99.99zz. To get the version of *.h files
  711. * used with your application, print out PNG_LIBPNG_VER_STRING, which
  712. * is defined in png.h.
  713. * Note: now there is no difference between png_get_libpng_ver() and
  714. * png_get_header_ver(). Due to the version_nn_nn_nn typedef guard,
  715. * it is guaranteed that png.c uses the correct version of png.h.
  716. */
  717. png_const_charp PNGAPI
  718. png_get_libpng_ver(png_const_structrp png_ptr)
  719. {
  720. /* Version of *.c files used when building libpng */
  721. return png_get_header_ver(png_ptr);
  722. }
  723. png_const_charp PNGAPI
  724. png_get_header_ver(png_const_structrp png_ptr)
  725. {
  726. /* Version of *.h files used when building libpng */
  727. PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */
  728. return PNG_LIBPNG_VER_STRING;
  729. }
  730. png_const_charp PNGAPI
  731. png_get_header_version(png_const_structrp png_ptr)
  732. {
  733. /* Returns longer string containing both version and date */
  734. PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */
  735. #ifdef __STDC__
  736. return PNG_HEADER_VERSION_STRING
  737. # ifndef PNG_READ_SUPPORTED
  738. " (NO READ SUPPORT)"
  739. # endif
  740. PNG_STRING_NEWLINE;
  741. #else
  742. return PNG_HEADER_VERSION_STRING;
  743. #endif
  744. }
  745. #ifdef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED
  746. /* NOTE: this routine is not used internally! */
  747. /* Build a grayscale palette. Palette is assumed to be 1 << bit_depth
  748. * large of png_color. This lets grayscale images be treated as
  749. * paletted. Most useful for gamma correction and simplification
  750. * of code. This API is not used internally.
  751. */
  752. void PNGAPI
  753. png_build_grayscale_palette(int bit_depth, png_colorp palette)
  754. {
  755. int num_palette;
  756. int color_inc;
  757. int i;
  758. int v;
  759. png_debug(1, "in png_do_build_grayscale_palette");
  760. if (palette == NULL)
  761. return;
  762. switch (bit_depth)
  763. {
  764. case 1:
  765. num_palette = 2;
  766. color_inc = 0xff;
  767. break;
  768. case 2:
  769. num_palette = 4;
  770. color_inc = 0x55;
  771. break;
  772. case 4:
  773. num_palette = 16;
  774. color_inc = 0x11;
  775. break;
  776. case 8:
  777. num_palette = 256;
  778. color_inc = 1;
  779. break;
  780. default:
  781. num_palette = 0;
  782. color_inc = 0;
  783. break;
  784. }
  785. for (i = 0, v = 0; i < num_palette; i++, v += color_inc)
  786. {
  787. palette[i].red = (png_byte)(v & 0xff);
  788. palette[i].green = (png_byte)(v & 0xff);
  789. palette[i].blue = (png_byte)(v & 0xff);
  790. }
  791. }
  792. #endif
  793. #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
  794. int PNGAPI
  795. png_handle_as_unknown(png_const_structrp png_ptr, png_const_bytep chunk_name)
  796. {
  797. /* Check chunk_name and return "keep" value if it's on the list, else 0 */
  798. png_const_bytep p, p_end;
  799. if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list == 0)
  800. return PNG_HANDLE_CHUNK_AS_DEFAULT;
  801. p_end = png_ptr->chunk_list;
  802. p = p_end + png_ptr->num_chunk_list*5; /* beyond end */
  803. /* The code is the fifth byte after each four byte string. Historically this
  804. * code was always searched from the end of the list, this is no longer
  805. * necessary because the 'set' routine handles duplicate entries correcty.
  806. */
  807. do /* num_chunk_list > 0, so at least one */
  808. {
  809. p -= 5;
  810. if (memcmp(chunk_name, p, 4) == 0)
  811. return p[4];
  812. }
  813. while (p > p_end);
  814. /* This means that known chunks should be processed and unknown chunks should
  815. * be handled according to the value of png_ptr->unknown_default; this can be
  816. * confusing because, as a result, there are two levels of defaulting for
  817. * unknown chunks.
  818. */
  819. return PNG_HANDLE_CHUNK_AS_DEFAULT;
  820. }
  821. #if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) ||\
  822. defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED)
  823. int /* PRIVATE */
  824. png_chunk_unknown_handling(png_const_structrp png_ptr, png_uint_32 chunk_name)
  825. {
  826. png_byte chunk_string[5];
  827. PNG_CSTRING_FROM_CHUNK(chunk_string, chunk_name);
  828. return png_handle_as_unknown(png_ptr, chunk_string);
  829. }
  830. #endif /* READ_UNKNOWN_CHUNKS || HANDLE_AS_UNKNOWN */
  831. #endif /* SET_UNKNOWN_CHUNKS */
  832. #ifdef PNG_READ_SUPPORTED
  833. /* This function, added to libpng-1.0.6g, is untested. */
  834. int PNGAPI
  835. png_reset_zstream(png_structrp png_ptr)
  836. {
  837. if (png_ptr == NULL)
  838. return Z_STREAM_ERROR;
  839. /* WARNING: this resets the window bits to the maximum! */
  840. return (inflateReset(&png_ptr->zstream));
  841. }
  842. #endif /* READ */
  843. /* This function was added to libpng-1.0.7 */
  844. png_uint_32 PNGAPI
  845. png_access_version_number(void)
  846. {
  847. /* Version of *.c files used when building libpng */
  848. return((png_uint_32)PNG_LIBPNG_VER);
  849. }
  850. #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
  851. /* Ensure that png_ptr->zstream.msg holds some appropriate error message string.
  852. * If it doesn't 'ret' is used to set it to something appropriate, even in cases
  853. * like Z_OK or Z_STREAM_END where the error code is apparently a success code.
  854. */
  855. void /* PRIVATE */
  856. png_zstream_error(png_structrp png_ptr, int ret)
  857. {
  858. /* Translate 'ret' into an appropriate error string, priority is given to the
  859. * one in zstream if set. This always returns a string, even in cases like
  860. * Z_OK or Z_STREAM_END where the error code is a success code.
  861. */
  862. if (png_ptr->zstream.msg == NULL) switch (ret)
  863. {
  864. default:
  865. case Z_OK:
  866. png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected zlib return code");
  867. break;
  868. case Z_STREAM_END:
  869. /* Normal exit */
  870. png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected end of LZ stream");
  871. break;
  872. case Z_NEED_DICT:
  873. /* This means the deflate stream did not have a dictionary; this
  874. * indicates a bogus PNG.
  875. */
  876. png_ptr->zstream.msg = PNGZ_MSG_CAST("missing LZ dictionary");
  877. break;
  878. case Z_ERRNO:
  879. /* gz APIs only: should not happen */
  880. png_ptr->zstream.msg = PNGZ_MSG_CAST("zlib IO error");
  881. break;
  882. case Z_STREAM_ERROR:
  883. /* internal libpng error */
  884. png_ptr->zstream.msg = PNGZ_MSG_CAST("bad parameters to zlib");
  885. break;
  886. case Z_DATA_ERROR:
  887. png_ptr->zstream.msg = PNGZ_MSG_CAST("damaged LZ stream");
  888. break;
  889. case Z_MEM_ERROR:
  890. png_ptr->zstream.msg = PNGZ_MSG_CAST("insufficient memory");
  891. break;
  892. case Z_BUF_ERROR:
  893. /* End of input or output; not a problem if the caller is doing
  894. * incremental read or write.
  895. */
  896. png_ptr->zstream.msg = PNGZ_MSG_CAST("truncated");
  897. break;
  898. case Z_VERSION_ERROR:
  899. png_ptr->zstream.msg = PNGZ_MSG_CAST("unsupported zlib version");
  900. break;
  901. case PNG_UNEXPECTED_ZLIB_RETURN:
  902. /* Compile errors here mean that zlib now uses the value co-opted in
  903. * pngpriv.h for PNG_UNEXPECTED_ZLIB_RETURN; update the switch above
  904. * and change pngpriv.h. Note that this message is "... return",
  905. * whereas the default/Z_OK one is "... return code".
  906. */
  907. png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected zlib return");
  908. break;
  909. }
  910. }
  911. /* png_convert_size: a PNGAPI but no longer in png.h, so deleted
  912. * at libpng 1.5.5!
  913. */
  914. /* Added at libpng version 1.2.34 and 1.4.0 (moved from pngset.c) */
  915. #ifdef PNG_GAMMA_SUPPORTED /* always set if COLORSPACE */
  916. static int
  917. png_colorspace_check_gamma(png_const_structrp png_ptr,
  918. png_colorspacerp colorspace, png_fixed_point gAMA, int from)
  919. /* This is called to check a new gamma value against an existing one. The
  920. * routine returns false if the new gamma value should not be written.
  921. *
  922. * 'from' says where the new gamma value comes from:
  923. *
  924. * 0: the new gamma value is the libpng estimate for an ICC profile
  925. * 1: the new gamma value comes from a gAMA chunk
  926. * 2: the new gamma value comes from an sRGB chunk
  927. */
  928. {
  929. png_fixed_point gtest;
  930. if ((colorspace->flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 &&
  931. (png_muldiv(&gtest, colorspace->gamma, PNG_FP_1, gAMA) == 0 ||
  932. png_gamma_significant(gtest) != 0))
  933. {
  934. /* Either this is an sRGB image, in which case the calculated gamma
  935. * approximation should match, or this is an image with a profile and the
  936. * value libpng calculates for the gamma of the profile does not match the
  937. * value recorded in the file. The former, sRGB, case is an error, the
  938. * latter is just a warning.
  939. */
  940. if ((colorspace->flags & PNG_COLORSPACE_FROM_sRGB) != 0 || from == 2)
  941. {
  942. png_chunk_report(png_ptr, "gamma value does not match sRGB",
  943. PNG_CHUNK_ERROR);
  944. /* Do not overwrite an sRGB value */
  945. return from == 2;
  946. }
  947. else /* sRGB tag not involved */
  948. {
  949. png_chunk_report(png_ptr, "gamma value does not match libpng estimate",
  950. PNG_CHUNK_WARNING);
  951. return from == 1;
  952. }
  953. }
  954. return 1;
  955. }
  956. void /* PRIVATE */
  957. png_colorspace_set_gamma(png_const_structrp png_ptr,
  958. png_colorspacerp colorspace, png_fixed_point gAMA)
  959. {
  960. /* Changed in libpng-1.5.4 to limit the values to ensure overflow can't
  961. * occur. Since the fixed point representation is asymetrical it is
  962. * possible for 1/gamma to overflow the limit of 21474 and this means the
  963. * gamma value must be at least 5/100000 and hence at most 20000.0. For
  964. * safety the limits here are a little narrower. The values are 0.00016 to
  965. * 6250.0, which are truly ridiculous gamma values (and will produce
  966. * displays that are all black or all white.)
  967. *
  968. * In 1.6.0 this test replaces the ones in pngrutil.c, in the gAMA chunk
  969. * handling code, which only required the value to be >0.
  970. */
  971. png_const_charp errmsg;
  972. if (gAMA < 16 || gAMA > 625000000)
  973. errmsg = "gamma value out of range";
  974. # ifdef PNG_READ_gAMA_SUPPORTED
  975. /* Allow the application to set the gamma value more than once */
  976. else if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
  977. (colorspace->flags & PNG_COLORSPACE_FROM_gAMA) != 0)
  978. errmsg = "duplicate";
  979. # endif
  980. /* Do nothing if the colorspace is already invalid */
  981. else if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
  982. return;
  983. else
  984. {
  985. if (png_colorspace_check_gamma(png_ptr, colorspace, gAMA,
  986. 1/*from gAMA*/) != 0)
  987. {
  988. /* Store this gamma value. */
  989. colorspace->gamma = gAMA;
  990. colorspace->flags |=
  991. (PNG_COLORSPACE_HAVE_GAMMA | PNG_COLORSPACE_FROM_gAMA);
  992. }
  993. /* At present if the check_gamma test fails the gamma of the colorspace is
  994. * not updated however the colorspace is not invalidated. This
  995. * corresponds to the case where the existing gamma comes from an sRGB
  996. * chunk or profile. An error message has already been output.
  997. */
  998. return;
  999. }
  1000. /* Error exit - errmsg has been set. */
  1001. colorspace->flags |= PNG_COLORSPACE_INVALID;
  1002. png_chunk_report(png_ptr, errmsg, PNG_CHUNK_WRITE_ERROR);
  1003. }
  1004. void /* PRIVATE */
  1005. png_colorspace_sync_info(png_const_structrp png_ptr, png_inforp info_ptr)
  1006. {
  1007. if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) != 0)
  1008. {
  1009. /* Everything is invalid */
  1010. info_ptr->valid &= ~(PNG_INFO_gAMA|PNG_INFO_cHRM|PNG_INFO_sRGB|
  1011. PNG_INFO_iCCP);
  1012. # ifdef PNG_COLORSPACE_SUPPORTED
  1013. /* Clean up the iCCP profile now if it won't be used. */
  1014. png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, -1/*not used*/);
  1015. # else
  1016. PNG_UNUSED(png_ptr)
  1017. # endif
  1018. }
  1019. else
  1020. {
  1021. # ifdef PNG_COLORSPACE_SUPPORTED
  1022. /* Leave the INFO_iCCP flag set if the pngset.c code has already set
  1023. * it; this allows a PNG to contain a profile which matches sRGB and
  1024. * yet still have that profile retrievable by the application.
  1025. */
  1026. if ((info_ptr->colorspace.flags & PNG_COLORSPACE_MATCHES_sRGB) != 0)
  1027. info_ptr->valid |= PNG_INFO_sRGB;
  1028. else
  1029. info_ptr->valid &= ~PNG_INFO_sRGB;
  1030. if ((info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
  1031. info_ptr->valid |= PNG_INFO_cHRM;
  1032. else
  1033. info_ptr->valid &= ~PNG_INFO_cHRM;
  1034. # endif
  1035. if ((info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0)
  1036. info_ptr->valid |= PNG_INFO_gAMA;
  1037. else
  1038. info_ptr->valid &= ~PNG_INFO_gAMA;
  1039. }
  1040. }
  1041. #ifdef PNG_READ_SUPPORTED
  1042. void /* PRIVATE */
  1043. png_colorspace_sync(png_const_structrp png_ptr, png_inforp info_ptr)
  1044. {
  1045. if (info_ptr == NULL) /* reduce code size; check here not in the caller */
  1046. return;
  1047. info_ptr->colorspace = png_ptr->colorspace;
  1048. png_colorspace_sync_info(png_ptr, info_ptr);
  1049. }
  1050. #endif
  1051. #endif /* GAMMA */
  1052. #ifdef PNG_COLORSPACE_SUPPORTED
  1053. /* Added at libpng-1.5.5 to support read and write of true CIEXYZ values for
  1054. * cHRM, as opposed to using chromaticities. These internal APIs return
  1055. * non-zero on a parameter error. The X, Y and Z values are required to be
  1056. * positive and less than 1.0.
  1057. */
  1058. static int
  1059. png_xy_from_XYZ(png_xy *xy, const png_XYZ *XYZ)
  1060. {
  1061. png_int_32 d, dwhite, whiteX, whiteY;
  1062. d = XYZ->red_X + XYZ->red_Y + XYZ->red_Z;
  1063. if (png_muldiv(&xy->redx, XYZ->red_X, PNG_FP_1, d) == 0)
  1064. return 1;
  1065. if (png_muldiv(&xy->redy, XYZ->red_Y, PNG_FP_1, d) == 0)
  1066. return 1;
  1067. dwhite = d;
  1068. whiteX = XYZ->red_X;
  1069. whiteY = XYZ->red_Y;
  1070. d = XYZ->green_X + XYZ->green_Y + XYZ->green_Z;
  1071. if (png_muldiv(&xy->greenx, XYZ->green_X, PNG_FP_1, d) == 0)
  1072. return 1;
  1073. if (png_muldiv(&xy->greeny, XYZ->green_Y, PNG_FP_1, d) == 0)
  1074. return 1;
  1075. dwhite += d;
  1076. whiteX += XYZ->green_X;
  1077. whiteY += XYZ->green_Y;
  1078. d = XYZ->blue_X + XYZ->blue_Y + XYZ->blue_Z;
  1079. if (png_muldiv(&xy->bluex, XYZ->blue_X, PNG_FP_1, d) == 0)
  1080. return 1;
  1081. if (png_muldiv(&xy->bluey, XYZ->blue_Y, PNG_FP_1, d) == 0)
  1082. return 1;
  1083. dwhite += d;
  1084. whiteX += XYZ->blue_X;
  1085. whiteY += XYZ->blue_Y;
  1086. /* The reference white is simply the sum of the end-point (X,Y,Z) vectors,
  1087. * thus:
  1088. */
  1089. if (png_muldiv(&xy->whitex, whiteX, PNG_FP_1, dwhite) == 0)
  1090. return 1;
  1091. if (png_muldiv(&xy->whitey, whiteY, PNG_FP_1, dwhite) == 0)
  1092. return 1;
  1093. return 0;
  1094. }
  1095. static int
  1096. png_XYZ_from_xy(png_XYZ *XYZ, const png_xy *xy)
  1097. {
  1098. png_fixed_point red_inverse, green_inverse, blue_scale;
  1099. png_fixed_point left, right, denominator;
  1100. /* Check xy and, implicitly, z. Note that wide gamut color spaces typically
  1101. * have end points with 0 tristimulus values (these are impossible end
  1102. * points, but they are used to cover the possible colors). We check
  1103. * xy->whitey against 5, not 0, to avoid a possible integer overflow.
  1104. */
  1105. if (xy->redx < 0 || xy->redx > PNG_FP_1) return 1;
  1106. if (xy->redy < 0 || xy->redy > PNG_FP_1-xy->redx) return 1;
  1107. if (xy->greenx < 0 || xy->greenx > PNG_FP_1) return 1;
  1108. if (xy->greeny < 0 || xy->greeny > PNG_FP_1-xy->greenx) return 1;
  1109. if (xy->bluex < 0 || xy->bluex > PNG_FP_1) return 1;
  1110. if (xy->bluey < 0 || xy->bluey > PNG_FP_1-xy->bluex) return 1;
  1111. if (xy->whitex < 0 || xy->whitex > PNG_FP_1) return 1;
  1112. if (xy->whitey < 5 || xy->whitey > PNG_FP_1-xy->whitex) return 1;
  1113. /* The reverse calculation is more difficult because the original tristimulus
  1114. * value had 9 independent values (red,green,blue)x(X,Y,Z) however only 8
  1115. * derived values were recorded in the cHRM chunk;
  1116. * (red,green,blue,white)x(x,y). This loses one degree of freedom and
  1117. * therefore an arbitrary ninth value has to be introduced to undo the
  1118. * original transformations.
  1119. *
  1120. * Think of the original end-points as points in (X,Y,Z) space. The
  1121. * chromaticity values (c) have the property:
  1122. *
  1123. * C
  1124. * c = ---------
  1125. * X + Y + Z
  1126. *
  1127. * For each c (x,y,z) from the corresponding original C (X,Y,Z). Thus the
  1128. * three chromaticity values (x,y,z) for each end-point obey the
  1129. * relationship:
  1130. *
  1131. * x + y + z = 1
  1132. *
  1133. * This describes the plane in (X,Y,Z) space that intersects each axis at the
  1134. * value 1.0; call this the chromaticity plane. Thus the chromaticity
  1135. * calculation has scaled each end-point so that it is on the x+y+z=1 plane
  1136. * and chromaticity is the intersection of the vector from the origin to the
  1137. * (X,Y,Z) value with the chromaticity plane.
  1138. *
  1139. * To fully invert the chromaticity calculation we would need the three
  1140. * end-point scale factors, (red-scale, green-scale, blue-scale), but these
  1141. * were not recorded. Instead we calculated the reference white (X,Y,Z) and
  1142. * recorded the chromaticity of this. The reference white (X,Y,Z) would have
  1143. * given all three of the scale factors since:
  1144. *
  1145. * color-C = color-c * color-scale
  1146. * white-C = red-C + green-C + blue-C
  1147. * = red-c*red-scale + green-c*green-scale + blue-c*blue-scale
  1148. *
  1149. * But cHRM records only white-x and white-y, so we have lost the white scale
  1150. * factor:
  1151. *
  1152. * white-C = white-c*white-scale
  1153. *
  1154. * To handle this the inverse transformation makes an arbitrary assumption
  1155. * about white-scale:
  1156. *
  1157. * Assume: white-Y = 1.0
  1158. * Hence: white-scale = 1/white-y
  1159. * Or: red-Y + green-Y + blue-Y = 1.0
  1160. *
  1161. * Notice the last statement of the assumption gives an equation in three of
  1162. * the nine values we want to calculate. 8 more equations come from the
  1163. * above routine as summarised at the top above (the chromaticity
  1164. * calculation):
  1165. *
  1166. * Given: color-x = color-X / (color-X + color-Y + color-Z)
  1167. * Hence: (color-x - 1)*color-X + color.x*color-Y + color.x*color-Z = 0
  1168. *
  1169. * This is 9 simultaneous equations in the 9 variables "color-C" and can be
  1170. * solved by Cramer's rule. Cramer's rule requires calculating 10 9x9 matrix
  1171. * determinants, however this is not as bad as it seems because only 28 of
  1172. * the total of 90 terms in the various matrices are non-zero. Nevertheless
  1173. * Cramer's rule is notoriously numerically unstable because the determinant
  1174. * calculation involves the difference of large, but similar, numbers. It is
  1175. * difficult to be sure that the calculation is stable for real world values
  1176. * and it is certain that it becomes unstable where the end points are close
  1177. * together.
  1178. *
  1179. * So this code uses the perhaps slightly less optimal but more
  1180. * understandable and totally obvious approach of calculating color-scale.
  1181. *
  1182. * This algorithm depends on the precision in white-scale and that is
  1183. * (1/white-y), so we can immediately see that as white-y approaches 0 the
  1184. * accuracy inherent in the cHRM chunk drops off substantially.
  1185. *
  1186. * libpng arithmetic: a simple inversion of the above equations
  1187. * ------------------------------------------------------------
  1188. *
  1189. * white_scale = 1/white-y
  1190. * white-X = white-x * white-scale
  1191. * white-Y = 1.0
  1192. * white-Z = (1 - white-x - white-y) * white_scale
  1193. *
  1194. * white-C = red-C + green-C + blue-C
  1195. * = red-c*red-scale + green-c*green-scale + blue-c*blue-scale
  1196. *
  1197. * This gives us three equations in (red-scale,green-scale,blue-scale) where
  1198. * all the coefficients are now known:
  1199. *
  1200. * red-x*red-scale + green-x*green-scale + blue-x*blue-scale
  1201. * = white-x/white-y
  1202. * red-y*red-scale + green-y*green-scale + blue-y*blue-scale = 1
  1203. * red-z*red-scale + green-z*green-scale + blue-z*blue-scale
  1204. * = (1 - white-x - white-y)/white-y
  1205. *
  1206. * In the last equation color-z is (1 - color-x - color-y) so we can add all
  1207. * three equations together to get an alternative third:
  1208. *
  1209. * red-scale + green-scale + blue-scale = 1/white-y = white-scale
  1210. *
  1211. * So now we have a Cramer's rule solution where the determinants are just
  1212. * 3x3 - far more tractible. Unfortunately 3x3 determinants still involve
  1213. * multiplication of three coefficients so we can't guarantee to avoid
  1214. * overflow in the libpng fixed point representation. Using Cramer's rule in
  1215. * floating point is probably a good choice here, but it's not an option for
  1216. * fixed point. Instead proceed to simplify the first two equations by
  1217. * eliminating what is likely to be the largest value, blue-scale:
  1218. *
  1219. * blue-scale = white-scale - red-scale - green-scale
  1220. *
  1221. * Hence:
  1222. *
  1223. * (red-x - blue-x)*red-scale + (green-x - blue-x)*green-scale =
  1224. * (white-x - blue-x)*white-scale
  1225. *
  1226. * (red-y - blue-y)*red-scale + (green-y - blue-y)*green-scale =
  1227. * 1 - blue-y*white-scale
  1228. *
  1229. * And now we can trivially solve for (red-scale,green-scale):
  1230. *
  1231. * green-scale =
  1232. * (white-x - blue-x)*white-scale - (red-x - blue-x)*red-scale
  1233. * -----------------------------------------------------------
  1234. * green-x - blue-x
  1235. *
  1236. * red-scale =
  1237. * 1 - blue-y*white-scale - (green-y - blue-y) * green-scale
  1238. * ---------------------------------------------------------
  1239. * red-y - blue-y
  1240. *
  1241. * Hence:
  1242. *
  1243. * red-scale =
  1244. * ( (green-x - blue-x) * (white-y - blue-y) -
  1245. * (green-y - blue-y) * (white-x - blue-x) ) / white-y
  1246. * -------------------------------------------------------------------------
  1247. * (green-x - blue-x)*(red-y - blue-y)-(green-y - blue-y)*(red-x - blue-x)
  1248. *
  1249. * green-scale =
  1250. * ( (red-y - blue-y) * (white-x - blue-x) -
  1251. * (red-x - blue-x) * (white-y - blue-y) ) / white-y
  1252. * -------------------------------------------------------------------------
  1253. * (green-x - blue-x)*(red-y - blue-y)-(green-y - blue-y)*(red-x - blue-x)
  1254. *
  1255. * Accuracy:
  1256. * The input values have 5 decimal digits of accuracy. The values are all in
  1257. * the range 0 < value < 1, so simple products are in the same range but may
  1258. * need up to 10 decimal digits to preserve the original precision and avoid
  1259. * underflow. Because we are using a 32-bit signed representation we cannot
  1260. * match this; the best is a little over 9 decimal digits, less than 10.
  1261. *
  1262. * The approach used here is to preserve the maximum precision within the
  1263. * signed representation. Because the red-scale calculation above uses the
  1264. * difference between two products of values that must be in the range -1..+1
  1265. * it is sufficient to divide the product by 7; ceil(100,000/32767*2). The
  1266. * factor is irrelevant in the calculation because it is applied to both
  1267. * numerator and denominator.
  1268. *
  1269. * Note that the values of the differences of the products of the
  1270. * chromaticities in the above equations tend to be small, for example for
  1271. * the sRGB chromaticities they are:
  1272. *
  1273. * red numerator: -0.04751
  1274. * green numerator: -0.08788
  1275. * denominator: -0.2241 (without white-y multiplication)
  1276. *
  1277. * The resultant Y coefficients from the chromaticities of some widely used
  1278. * color space definitions are (to 15 decimal places):
  1279. *
  1280. * sRGB
  1281. * 0.212639005871510 0.715168678767756 0.072192315360734
  1282. * Kodak ProPhoto
  1283. * 0.288071128229293 0.711843217810102 0.000085653960605
  1284. * Adobe RGB
  1285. * 0.297344975250536 0.627363566255466 0.075291458493998
  1286. * Adobe Wide Gamut RGB
  1287. * 0.258728243040113 0.724682314948566 0.016589442011321
  1288. */
  1289. /* By the argument, above overflow should be impossible here. The return
  1290. * value of 2 indicates an internal error to the caller.
  1291. */
  1292. if (png_muldiv(&left, xy->greenx-xy->bluex, xy->redy - xy->bluey, 7) == 0)
  1293. return 2;
  1294. if (png_muldiv(&right, xy->greeny-xy->bluey, xy->redx - xy->bluex, 7) == 0)
  1295. return 2;
  1296. denominator = left - right;
  1297. /* Now find the red numerator. */
  1298. if (png_muldiv(&left, xy->greenx-xy->bluex, xy->whitey-xy->bluey, 7) == 0)
  1299. return 2;
  1300. if (png_muldiv(&right, xy->greeny-xy->bluey, xy->whitex-xy->bluex, 7) == 0)
  1301. return 2;
  1302. /* Overflow is possible here and it indicates an extreme set of PNG cHRM
  1303. * chunk values. This calculation actually returns the reciprocal of the
  1304. * scale value because this allows us to delay the multiplication of white-y
  1305. * into the denominator, which tends to produce a small number.
  1306. */
  1307. if (png_muldiv(&red_inverse, xy->whitey, denominator, left-right) == 0 ||
  1308. red_inverse <= xy->whitey /* r+g+b scales = white scale */)
  1309. return 1;
  1310. /* Similarly for green_inverse: */
  1311. if (png_muldiv(&left, xy->redy-xy->bluey, xy->whitex-xy->bluex, 7) == 0)
  1312. return 2;
  1313. if (png_muldiv(&right, xy->redx-xy->bluex, xy->whitey-xy->bluey, 7) == 0)
  1314. return 2;
  1315. if (png_muldiv(&green_inverse, xy->whitey, denominator, left-right) == 0 ||
  1316. green_inverse <= xy->whitey)
  1317. return 1;
  1318. /* And the blue scale, the checks above guarantee this can't overflow but it
  1319. * can still produce 0 for extreme cHRM values.
  1320. */
  1321. blue_scale = png_reciprocal(xy->whitey) - png_reciprocal(red_inverse) -
  1322. png_reciprocal(green_inverse);
  1323. if (blue_scale <= 0)
  1324. return 1;
  1325. /* And fill in the png_XYZ: */
  1326. if (png_muldiv(&XYZ->red_X, xy->redx, PNG_FP_1, red_inverse) == 0)
  1327. return 1;
  1328. if (png_muldiv(&XYZ->red_Y, xy->redy, PNG_FP_1, red_inverse) == 0)
  1329. return 1;
  1330. if (png_muldiv(&XYZ->red_Z, PNG_FP_1 - xy->redx - xy->redy, PNG_FP_1,
  1331. red_inverse) == 0)
  1332. return 1;
  1333. if (png_muldiv(&XYZ->green_X, xy->greenx, PNG_FP_1, green_inverse) == 0)
  1334. return 1;
  1335. if (png_muldiv(&XYZ->green_Y, xy->greeny, PNG_FP_1, green_inverse) == 0)
  1336. return 1;
  1337. if (png_muldiv(&XYZ->green_Z, PNG_FP_1 - xy->greenx - xy->greeny, PNG_FP_1,
  1338. green_inverse) == 0)
  1339. return 1;
  1340. if (png_muldiv(&XYZ->blue_X, xy->bluex, blue_scale, PNG_FP_1) == 0)
  1341. return 1;
  1342. if (png_muldiv(&XYZ->blue_Y, xy->bluey, blue_scale, PNG_FP_1) == 0)
  1343. return 1;
  1344. if (png_muldiv(&XYZ->blue_Z, PNG_FP_1 - xy->bluex - xy->bluey, blue_scale,
  1345. PNG_FP_1) == 0)
  1346. return 1;
  1347. return 0; /*success*/
  1348. }
  1349. static int
  1350. png_XYZ_normalize(png_XYZ *XYZ)
  1351. {
  1352. png_int_32 Y;
  1353. if (XYZ->red_Y < 0 || XYZ->green_Y < 0 || XYZ->blue_Y < 0 ||
  1354. XYZ->red_X < 0 || XYZ->green_X < 0 || XYZ->blue_X < 0 ||
  1355. XYZ->red_Z < 0 || XYZ->green_Z < 0 || XYZ->blue_Z < 0)
  1356. return 1;
  1357. /* Normalize by scaling so the sum of the end-point Y values is PNG_FP_1.
  1358. * IMPLEMENTATION NOTE: ANSI requires signed overflow not to occur, therefore
  1359. * relying on addition of two positive values producing a negative one is not
  1360. * safe.
  1361. */
  1362. Y = XYZ->red_Y;
  1363. if (0x7fffffff - Y < XYZ->green_X)
  1364. return 1;
  1365. Y += XYZ->green_Y;
  1366. if (0x7fffffff - Y < XYZ->blue_X)
  1367. return 1;
  1368. Y += XYZ->blue_Y;
  1369. if (Y != PNG_FP_1)
  1370. {
  1371. if (png_muldiv(&XYZ->red_X, XYZ->red_X, PNG_FP_1, Y) == 0)
  1372. return 1;
  1373. if (png_muldiv(&XYZ->red_Y, XYZ->red_Y, PNG_FP_1, Y) == 0)
  1374. return 1;
  1375. if (png_muldiv(&XYZ->red_Z, XYZ->red_Z, PNG_FP_1, Y) == 0)
  1376. return 1;
  1377. if (png_muldiv(&XYZ->green_X, XYZ->green_X, PNG_FP_1, Y) == 0)
  1378. return 1;
  1379. if (png_muldiv(&XYZ->green_Y, XYZ->green_Y, PNG_FP_1, Y) == 0)
  1380. return 1;
  1381. if (png_muldiv(&XYZ->green_Z, XYZ->green_Z, PNG_FP_1, Y) == 0)
  1382. return 1;
  1383. if (png_muldiv(&XYZ->blue_X, XYZ->blue_X, PNG_FP_1, Y) == 0)
  1384. return 1;
  1385. if (png_muldiv(&XYZ->blue_Y, XYZ->blue_Y, PNG_FP_1, Y) == 0)
  1386. return 1;
  1387. if (png_muldiv(&XYZ->blue_Z, XYZ->blue_Z, PNG_FP_1, Y) == 0)
  1388. return 1;
  1389. }
  1390. return 0;
  1391. }
  1392. static int
  1393. png_colorspace_endpoints_match(const png_xy *xy1, const png_xy *xy2, int delta)
  1394. {
  1395. /* Allow an error of +/-0.01 (absolute value) on each chromaticity */
  1396. if (PNG_OUT_OF_RANGE(xy1->whitex, xy2->whitex,delta) ||
  1397. PNG_OUT_OF_RANGE(xy1->whitey, xy2->whitey,delta) ||
  1398. PNG_OUT_OF_RANGE(xy1->redx, xy2->redx, delta) ||
  1399. PNG_OUT_OF_RANGE(xy1->redy, xy2->redy, delta) ||
  1400. PNG_OUT_OF_RANGE(xy1->greenx, xy2->greenx,delta) ||
  1401. PNG_OUT_OF_RANGE(xy1->greeny, xy2->greeny,delta) ||
  1402. PNG_OUT_OF_RANGE(xy1->bluex, xy2->bluex, delta) ||
  1403. PNG_OUT_OF_RANGE(xy1->bluey, xy2->bluey, delta))
  1404. return 0;
  1405. return 1;
  1406. }
  1407. /* Added in libpng-1.6.0, a different check for the validity of a set of cHRM
  1408. * chunk chromaticities. Earlier checks used to simply look for the overflow
  1409. * condition (where the determinant of the matrix to solve for XYZ ends up zero
  1410. * because the chromaticity values are not all distinct.) Despite this it is
  1411. * theoretically possible to produce chromaticities that are apparently valid
  1412. * but that rapidly degrade to invalid, potentially crashing, sets because of
  1413. * arithmetic inaccuracies when calculations are performed on them. The new
  1414. * check is to round-trip xy -> XYZ -> xy and then check that the result is
  1415. * within a small percentage of the original.
  1416. */
  1417. static int
  1418. png_colorspace_check_xy(png_XYZ *XYZ, const png_xy *xy)
  1419. {
  1420. int result;
  1421. png_xy xy_test;
  1422. /* As a side-effect this routine also returns the XYZ endpoints. */
  1423. result = png_XYZ_from_xy(XYZ, xy);
  1424. if (result != 0)
  1425. return result;
  1426. result = png_xy_from_XYZ(&xy_test, XYZ);
  1427. if (result != 0)
  1428. return result;
  1429. if (png_colorspace_endpoints_match(xy, &xy_test,
  1430. 5/*actually, the math is pretty accurate*/) != 0)
  1431. return 0;
  1432. /* Too much slip */
  1433. return 1;
  1434. }
  1435. /* This is the check going the other way. The XYZ is modified to normalize it
  1436. * (another side-effect) and the xy chromaticities are returned.
  1437. */
  1438. static int
  1439. png_colorspace_check_XYZ(png_xy *xy, png_XYZ *XYZ)
  1440. {
  1441. int result;
  1442. png_XYZ XYZtemp;
  1443. result = png_XYZ_normalize(XYZ);
  1444. if (result != 0)
  1445. return result;
  1446. result = png_xy_from_XYZ(xy, XYZ);
  1447. if (result != 0)
  1448. return result;
  1449. XYZtemp = *XYZ;
  1450. return png_colorspace_check_xy(&XYZtemp, xy);
  1451. }
  1452. /* Used to check for an endpoint match against sRGB */
  1453. static const png_xy sRGB_xy = /* From ITU-R BT.709-3 */
  1454. {
  1455. /* color x y */
  1456. /* red */ 64000, 33000,
  1457. /* green */ 30000, 60000,
  1458. /* blue */ 15000, 6000,
  1459. /* white */ 31270, 32900
  1460. };
  1461. static int
  1462. png_colorspace_set_xy_and_XYZ(png_const_structrp png_ptr,
  1463. png_colorspacerp colorspace, const png_xy *xy, const png_XYZ *XYZ,
  1464. int preferred)
  1465. {
  1466. if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
  1467. return 0;
  1468. /* The consistency check is performed on the chromaticities; this factors out
  1469. * variations because of the normalization (or not) of the end point Y
  1470. * values.
  1471. */
  1472. if (preferred < 2 &&
  1473. (colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
  1474. {
  1475. /* The end points must be reasonably close to any we already have. The
  1476. * following allows an error of up to +/-.001
  1477. */
  1478. if (png_colorspace_endpoints_match(xy, &colorspace->end_points_xy,
  1479. 100) == 0)
  1480. {
  1481. colorspace->flags |= PNG_COLORSPACE_INVALID;
  1482. png_benign_error(png_ptr, "inconsistent chromaticities");
  1483. return 0; /* failed */
  1484. }
  1485. /* Only overwrite with preferred values */
  1486. if (preferred == 0)
  1487. return 1; /* ok, but no change */
  1488. }
  1489. colorspace->end_points_xy = *xy;
  1490. colorspace->end_points_XYZ = *XYZ;
  1491. colorspace->flags |= PNG_COLORSPACE_HAVE_ENDPOINTS;
  1492. /* The end points are normally quoted to two decimal digits, so allow +/-0.01
  1493. * on this test.
  1494. */
  1495. if (png_colorspace_endpoints_match(xy, &sRGB_xy, 1000) != 0)
  1496. colorspace->flags |= PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB;
  1497. else
  1498. colorspace->flags &= PNG_COLORSPACE_CANCEL(
  1499. PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB);
  1500. return 2; /* ok and changed */
  1501. }
  1502. int /* PRIVATE */
  1503. png_colorspace_set_chromaticities(png_const_structrp png_ptr,
  1504. png_colorspacerp colorspace, const png_xy *xy, int preferred)
  1505. {
  1506. /* We must check the end points to ensure they are reasonable - in the past
  1507. * color management systems have crashed as a result of getting bogus
  1508. * colorant values, while this isn't the fault of libpng it is the
  1509. * responsibility of libpng because PNG carries the bomb and libpng is in a
  1510. * position to protect against it.
  1511. */
  1512. png_XYZ XYZ;
  1513. switch (png_colorspace_check_xy(&XYZ, xy))
  1514. {
  1515. case 0: /* success */
  1516. return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, xy, &XYZ,
  1517. preferred);
  1518. case 1:
  1519. /* We can't invert the chromaticities so we can't produce value XYZ
  1520. * values. Likely as not a color management system will fail too.
  1521. */
  1522. colorspace->flags |= PNG_COLORSPACE_INVALID;
  1523. png_benign_error(png_ptr, "invalid chromaticities");
  1524. break;
  1525. default:
  1526. /* libpng is broken; this should be a warning but if it happens we
  1527. * want error reports so for the moment it is an error.
  1528. */
  1529. colorspace->flags |= PNG_COLORSPACE_INVALID;
  1530. png_error(png_ptr, "internal error checking chromaticities");
  1531. }
  1532. return 0; /* failed */
  1533. }
  1534. int /* PRIVATE */
  1535. png_colorspace_set_endpoints(png_const_structrp png_ptr,
  1536. png_colorspacerp colorspace, const png_XYZ *XYZ_in, int preferred)
  1537. {
  1538. png_XYZ XYZ = *XYZ_in;
  1539. png_xy xy;
  1540. switch (png_colorspace_check_XYZ(&xy, &XYZ))
  1541. {
  1542. case 0:
  1543. return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, &xy, &XYZ,
  1544. preferred);
  1545. case 1:
  1546. /* End points are invalid. */
  1547. colorspace->flags |= PNG_COLORSPACE_INVALID;
  1548. png_benign_error(png_ptr, "invalid end points");
  1549. break;
  1550. default:
  1551. colorspace->flags |= PNG_COLORSPACE_INVALID;
  1552. png_error(png_ptr, "internal error checking chromaticities");
  1553. }
  1554. return 0; /* failed */
  1555. }
  1556. #if defined(PNG_sRGB_SUPPORTED) || defined(PNG_iCCP_SUPPORTED)
  1557. /* Error message generation */
  1558. static char
  1559. png_icc_tag_char(png_uint_32 byte)
  1560. {
  1561. byte &= 0xff;
  1562. if (byte >= 32 && byte <= 126)
  1563. return (char)byte;
  1564. else
  1565. return '?';
  1566. }
  1567. static void
  1568. png_icc_tag_name(char *name, png_uint_32 tag)
  1569. {
  1570. name[0] = '\'';
  1571. name[1] = png_icc_tag_char(tag >> 24);
  1572. name[2] = png_icc_tag_char(tag >> 16);
  1573. name[3] = png_icc_tag_char(tag >> 8);
  1574. name[4] = png_icc_tag_char(tag );
  1575. name[5] = '\'';
  1576. }
  1577. static int
  1578. is_ICC_signature_char(png_alloc_size_t it)
  1579. {
  1580. return it == 32 || (it >= 48 && it <= 57) || (it >= 65 && it <= 90) ||
  1581. (it >= 97 && it <= 122);
  1582. }
  1583. static int
  1584. is_ICC_signature(png_alloc_size_t it)
  1585. {
  1586. return is_ICC_signature_char(it >> 24) /* checks all the top bits */ &&
  1587. is_ICC_signature_char((it >> 16) & 0xff) &&
  1588. is_ICC_signature_char((it >> 8) & 0xff) &&
  1589. is_ICC_signature_char(it & 0xff);
  1590. }
  1591. static int
  1592. png_icc_profile_error(png_const_structrp png_ptr, png_colorspacerp colorspace,
  1593. png_const_charp name, png_alloc_size_t value, png_const_charp reason)
  1594. {
  1595. size_t pos;
  1596. char message[196]; /* see below for calculation */
  1597. if (colorspace != NULL)
  1598. colorspace->flags |= PNG_COLORSPACE_INVALID;
  1599. pos = png_safecat(message, (sizeof message), 0, "profile '"); /* 9 chars */
  1600. pos = png_safecat(message, pos+79, pos, name); /* Truncate to 79 chars */
  1601. pos = png_safecat(message, (sizeof message), pos, "': "); /* +2 = 90 */
  1602. if (is_ICC_signature(value) != 0)
  1603. {
  1604. /* So 'value' is at most 4 bytes and the following cast is safe */
  1605. png_icc_tag_name(message+pos, (png_uint_32)value);
  1606. pos += 6; /* total +8; less than the else clause */
  1607. message[pos++] = ':';
  1608. message[pos++] = ' ';
  1609. }
  1610. # ifdef PNG_WARNINGS_SUPPORTED
  1611. else
  1612. {
  1613. char number[PNG_NUMBER_BUFFER_SIZE]; /* +24 = 114*/
  1614. pos = png_safecat(message, (sizeof message), pos,
  1615. png_format_number(number, number+(sizeof number),
  1616. PNG_NUMBER_FORMAT_x, value));
  1617. pos = png_safecat(message, (sizeof message), pos, "h: "); /*+2 = 116*/
  1618. }
  1619. # endif
  1620. /* The 'reason' is an arbitrary message, allow +79 maximum 195 */
  1621. pos = png_safecat(message, (sizeof message), pos, reason);
  1622. PNG_UNUSED(pos)
  1623. /* This is recoverable, but make it unconditionally an app_error on write to
  1624. * avoid writing invalid ICC profiles into PNG files (i.e., we handle them
  1625. * on read, with a warning, but on write unless the app turns off
  1626. * application errors the PNG won't be written.)
  1627. */
  1628. png_chunk_report(png_ptr, message,
  1629. (colorspace != NULL) ? PNG_CHUNK_ERROR : PNG_CHUNK_WRITE_ERROR);
  1630. return 0;
  1631. }
  1632. #endif /* sRGB || iCCP */
  1633. #ifdef PNG_sRGB_SUPPORTED
  1634. int /* PRIVATE */
  1635. png_colorspace_set_sRGB(png_const_structrp png_ptr, png_colorspacerp colorspace,
  1636. int intent)
  1637. {
  1638. /* sRGB sets known gamma, end points and (from the chunk) intent. */
  1639. /* IMPORTANT: these are not necessarily the values found in an ICC profile
  1640. * because ICC profiles store values adapted to a D50 environment; it is
  1641. * expected that the ICC profile mediaWhitePointTag will be D50; see the
  1642. * checks and code elsewhere to understand this better.
  1643. *
  1644. * These XYZ values, which are accurate to 5dp, produce rgb to gray
  1645. * coefficients of (6968,23435,2366), which are reduced (because they add up
  1646. * to 32769 not 32768) to (6968,23434,2366). These are the values that
  1647. * libpng has traditionally used (and are the best values given the 15bit
  1648. * algorithm used by the rgb to gray code.)
  1649. */
  1650. static const png_XYZ sRGB_XYZ = /* D65 XYZ (*not* the D50 adapted values!) */
  1651. {
  1652. /* color X Y Z */
  1653. /* red */ 41239, 21264, 1933,
  1654. /* green */ 35758, 71517, 11919,
  1655. /* blue */ 18048, 7219, 95053
  1656. };
  1657. /* Do nothing if the colorspace is already invalidated. */
  1658. if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
  1659. return 0;
  1660. /* Check the intent, then check for existing settings. It is valid for the
  1661. * PNG file to have cHRM or gAMA chunks along with sRGB, but the values must
  1662. * be consistent with the correct values. If, however, this function is
  1663. * called below because an iCCP chunk matches sRGB then it is quite
  1664. * conceivable that an older app recorded incorrect gAMA and cHRM because of
  1665. * an incorrect calculation based on the values in the profile - this does
  1666. * *not* invalidate the profile (though it still produces an error, which can
  1667. * be ignored.)
  1668. */
  1669. if (intent < 0 || intent >= PNG_sRGB_INTENT_LAST)
  1670. return png_icc_profile_error(png_ptr, colorspace, "sRGB",
  1671. (png_alloc_size_t)intent, "invalid sRGB rendering intent");
  1672. if ((colorspace->flags & PNG_COLORSPACE_HAVE_INTENT) != 0 &&
  1673. colorspace->rendering_intent != intent)
  1674. return png_icc_profile_error(png_ptr, colorspace, "sRGB",
  1675. (png_alloc_size_t)intent, "inconsistent rendering intents");
  1676. if ((colorspace->flags & PNG_COLORSPACE_FROM_sRGB) != 0)
  1677. {
  1678. png_benign_error(png_ptr, "duplicate sRGB information ignored");
  1679. return 0;
  1680. }
  1681. /* If the standard sRGB cHRM chunk does not match the one from the PNG file
  1682. * warn but overwrite the value with the correct one.
  1683. */
  1684. if ((colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0 &&
  1685. !png_colorspace_endpoints_match(&sRGB_xy, &colorspace->end_points_xy,
  1686. 100))
  1687. png_chunk_report(png_ptr, "cHRM chunk does not match sRGB",
  1688. PNG_CHUNK_ERROR);
  1689. /* This check is just done for the error reporting - the routine always
  1690. * returns true when the 'from' argument corresponds to sRGB (2).
  1691. */
  1692. (void)png_colorspace_check_gamma(png_ptr, colorspace, PNG_GAMMA_sRGB_INVERSE,
  1693. 2/*from sRGB*/);
  1694. /* intent: bugs in GCC force 'int' to be used as the parameter type. */
  1695. colorspace->rendering_intent = (png_uint_16)intent;
  1696. colorspace->flags |= PNG_COLORSPACE_HAVE_INTENT;
  1697. /* endpoints */
  1698. colorspace->end_points_xy = sRGB_xy;
  1699. colorspace->end_points_XYZ = sRGB_XYZ;
  1700. colorspace->flags |=
  1701. (PNG_COLORSPACE_HAVE_ENDPOINTS|PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB);
  1702. /* gamma */
  1703. colorspace->gamma = PNG_GAMMA_sRGB_INVERSE;
  1704. colorspace->flags |= PNG_COLORSPACE_HAVE_GAMMA;
  1705. /* Finally record that we have an sRGB profile */
  1706. colorspace->flags |=
  1707. (PNG_COLORSPACE_MATCHES_sRGB|PNG_COLORSPACE_FROM_sRGB);
  1708. return 1; /* set */
  1709. }
  1710. #endif /* sRGB */
  1711. #ifdef PNG_iCCP_SUPPORTED
  1712. /* Encoded value of D50 as an ICC XYZNumber. From the ICC 2010 spec the value
  1713. * is XYZ(0.9642,1.0,0.8249), which scales to:
  1714. *
  1715. * (63189.8112, 65536, 54060.6464)
  1716. */
  1717. static const png_byte D50_nCIEXYZ[12] =
  1718. { 0x00, 0x00, 0xf6, 0xd6, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d };
  1719. static int /* bool */
  1720. icc_check_length(png_const_structrp png_ptr, png_colorspacerp colorspace,
  1721. png_const_charp name, png_uint_32 profile_length)
  1722. {
  1723. if (profile_length < 132)
  1724. return png_icc_profile_error(png_ptr, colorspace, name, profile_length,
  1725. "too short");
  1726. return 1;
  1727. }
  1728. #ifdef PNG_READ_iCCP_SUPPORTED
  1729. int /* PRIVATE */
  1730. png_icc_check_length(png_const_structrp png_ptr, png_colorspacerp colorspace,
  1731. png_const_charp name, png_uint_32 profile_length)
  1732. {
  1733. if (!icc_check_length(png_ptr, colorspace, name, profile_length))
  1734. return 0;
  1735. /* This needs to be here because the 'normal' check is in
  1736. * png_decompress_chunk, yet this happens after the attempt to
  1737. * png_malloc_base the required data. We only need this on read; on write
  1738. * the caller supplies the profile buffer so libpng doesn't allocate it. See
  1739. * the call to icc_check_length below (the write case).
  1740. */
  1741. # ifdef PNG_SET_USER_LIMITS_SUPPORTED
  1742. else if (png_ptr->user_chunk_malloc_max > 0 &&
  1743. png_ptr->user_chunk_malloc_max < profile_length)
  1744. return png_icc_profile_error(png_ptr, colorspace, name, profile_length,
  1745. "exceeds application limits");
  1746. # elif PNG_USER_CHUNK_MALLOC_MAX > 0
  1747. else if (PNG_USER_CHUNK_MALLOC_MAX < profile_length)
  1748. return png_icc_profile_error(png_ptr, colorspace, name, profile_length,
  1749. "exceeds libpng limits");
  1750. # else /* !SET_USER_LIMITS */
  1751. /* This will get compiled out on all 32-bit and better systems. */
  1752. else if (PNG_SIZE_MAX < profile_length)
  1753. return png_icc_profile_error(png_ptr, colorspace, name, profile_length,
  1754. "exceeds system limits");
  1755. # endif /* !SET_USER_LIMITS */
  1756. return 1;
  1757. }
  1758. #endif /* READ_iCCP */
  1759. int /* PRIVATE */
  1760. png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace,
  1761. png_const_charp name, png_uint_32 profile_length,
  1762. png_const_bytep profile/* first 132 bytes only */, int color_type)
  1763. {
  1764. png_uint_32 temp;
  1765. /* Length check; this cannot be ignored in this code because profile_length
  1766. * is used later to check the tag table, so even if the profile seems over
  1767. * long profile_length from the caller must be correct. The caller can fix
  1768. * this up on read or write by just passing in the profile header length.
  1769. */
  1770. temp = png_get_uint_32(profile);
  1771. if (temp != profile_length)
  1772. return png_icc_profile_error(png_ptr, colorspace, name, temp,
  1773. "length does not match profile");
  1774. temp = (png_uint_32) (*(profile+8));
  1775. if (temp > 3 && (profile_length & 3))
  1776. return png_icc_profile_error(png_ptr, colorspace, name, profile_length,
  1777. "invalid length");
  1778. temp = png_get_uint_32(profile+128); /* tag count: 12 bytes/tag */
  1779. if (temp > 357913930 || /* (2^32-4-132)/12: maximum possible tag count */
  1780. profile_length < 132+12*temp) /* truncated tag table */
  1781. return png_icc_profile_error(png_ptr, colorspace, name, temp,
  1782. "tag count too large");
  1783. /* The 'intent' must be valid or we can't store it, ICC limits the intent to
  1784. * 16 bits.
  1785. */
  1786. temp = png_get_uint_32(profile+64);
  1787. if (temp >= 0xffff) /* The ICC limit */
  1788. return png_icc_profile_error(png_ptr, colorspace, name, temp,
  1789. "invalid rendering intent");
  1790. /* This is just a warning because the profile may be valid in future
  1791. * versions.
  1792. */
  1793. if (temp >= PNG_sRGB_INTENT_LAST)
  1794. (void)png_icc_profile_error(png_ptr, NULL, name, temp,
  1795. "intent outside defined range");
  1796. /* At this point the tag table can't be checked because it hasn't necessarily
  1797. * been loaded; however, various header fields can be checked. These checks
  1798. * are for values permitted by the PNG spec in an ICC profile; the PNG spec
  1799. * restricts the profiles that can be passed in an iCCP chunk (they must be
  1800. * appropriate to processing PNG data!)
  1801. */
  1802. /* Data checks (could be skipped). These checks must be independent of the
  1803. * version number; however, the version number doesn't accomodate changes in
  1804. * the header fields (just the known tags and the interpretation of the
  1805. * data.)
  1806. */
  1807. temp = png_get_uint_32(profile+36); /* signature 'ascp' */
  1808. if (temp != 0x61637370)
  1809. return png_icc_profile_error(png_ptr, colorspace, name, temp,
  1810. "invalid signature");
  1811. /* Currently the PCS illuminant/adopted white point (the computational
  1812. * white point) are required to be D50,
  1813. * however the profile contains a record of the illuminant so perhaps ICC
  1814. * expects to be able to change this in the future (despite the rationale in
  1815. * the introduction for using a fixed PCS adopted white.) Consequently the
  1816. * following is just a warning.
  1817. */
  1818. if (memcmp(profile+68, D50_nCIEXYZ, 12) != 0)
  1819. (void)png_icc_profile_error(png_ptr, NULL, name, 0/*no tag value*/,
  1820. "PCS illuminant is not D50");
  1821. /* The PNG spec requires this:
  1822. * "If the iCCP chunk is present, the image samples conform to the colour
  1823. * space represented by the embedded ICC profile as defined by the
  1824. * International Color Consortium [ICC]. The colour space of the ICC profile
  1825. * shall be an RGB colour space for colour images (PNG colour types 2, 3, and
  1826. * 6), or a greyscale colour space for greyscale images (PNG colour types 0
  1827. * and 4)."
  1828. *
  1829. * This checking code ensures the embedded profile (on either read or write)
  1830. * conforms to the specification requirements. Notice that an ICC 'gray'
  1831. * color-space profile contains the information to transform the monochrome
  1832. * data to XYZ or L*a*b (according to which PCS the profile uses) and this
  1833. * should be used in preference to the standard libpng K channel replication
  1834. * into R, G and B channels.
  1835. *
  1836. * Previously it was suggested that an RGB profile on grayscale data could be
  1837. * handled. However it it is clear that using an RGB profile in this context
  1838. * must be an error - there is no specification of what it means. Thus it is
  1839. * almost certainly more correct to ignore the profile.
  1840. */
  1841. temp = png_get_uint_32(profile+16); /* data colour space field */
  1842. switch (temp)
  1843. {
  1844. case 0x52474220: /* 'RGB ' */
  1845. if ((color_type & PNG_COLOR_MASK_COLOR) == 0)
  1846. return png_icc_profile_error(png_ptr, colorspace, name, temp,
  1847. "RGB color space not permitted on grayscale PNG");
  1848. break;
  1849. case 0x47524159: /* 'GRAY' */
  1850. if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
  1851. return png_icc_profile_error(png_ptr, colorspace, name, temp,
  1852. "Gray color space not permitted on RGB PNG");
  1853. break;
  1854. default:
  1855. return png_icc_profile_error(png_ptr, colorspace, name, temp,
  1856. "invalid ICC profile color space");
  1857. }
  1858. /* It is up to the application to check that the profile class matches the
  1859. * application requirements; the spec provides no guidance, but it's pretty
  1860. * weird if the profile is not scanner ('scnr'), monitor ('mntr'), printer
  1861. * ('prtr') or 'spac' (for generic color spaces). Issue a warning in these
  1862. * cases. Issue an error for device link or abstract profiles - these don't
  1863. * contain the records necessary to transform the color-space to anything
  1864. * other than the target device (and not even that for an abstract profile).
  1865. * Profiles of these classes may not be embedded in images.
  1866. */
  1867. temp = png_get_uint_32(profile+12); /* profile/device class */
  1868. switch (temp)
  1869. {
  1870. case 0x73636e72: /* 'scnr' */
  1871. case 0x6d6e7472: /* 'mntr' */
  1872. case 0x70727472: /* 'prtr' */
  1873. case 0x73706163: /* 'spac' */
  1874. /* All supported */
  1875. break;
  1876. case 0x61627374: /* 'abst' */
  1877. /* May not be embedded in an image */
  1878. return png_icc_profile_error(png_ptr, colorspace, name, temp,
  1879. "invalid embedded Abstract ICC profile");
  1880. case 0x6c696e6b: /* 'link' */
  1881. /* DeviceLink profiles cannot be interpreted in a non-device specific
  1882. * fashion, if an app uses the AToB0Tag in the profile the results are
  1883. * undefined unless the result is sent to the intended device,
  1884. * therefore a DeviceLink profile should not be found embedded in a
  1885. * PNG.
  1886. */
  1887. return png_icc_profile_error(png_ptr, colorspace, name, temp,
  1888. "unexpected DeviceLink ICC profile class");
  1889. case 0x6e6d636c: /* 'nmcl' */
  1890. /* A NamedColor profile is also device specific, however it doesn't
  1891. * contain an AToB0 tag that is open to misinterpretation. Almost
  1892. * certainly it will fail the tests below.
  1893. */
  1894. (void)png_icc_profile_error(png_ptr, NULL, name, temp,
  1895. "unexpected NamedColor ICC profile class");
  1896. break;
  1897. default:
  1898. /* To allow for future enhancements to the profile accept unrecognized
  1899. * profile classes with a warning, these then hit the test below on the
  1900. * tag content to ensure they are backward compatible with one of the
  1901. * understood profiles.
  1902. */
  1903. (void)png_icc_profile_error(png_ptr, NULL, name, temp,
  1904. "unrecognized ICC profile class");
  1905. break;
  1906. }
  1907. /* For any profile other than a device link one the PCS must be encoded
  1908. * either in XYZ or Lab.
  1909. */
  1910. temp = png_get_uint_32(profile+20);
  1911. switch (temp)
  1912. {
  1913. case 0x58595a20: /* 'XYZ ' */
  1914. case 0x4c616220: /* 'Lab ' */
  1915. break;
  1916. default:
  1917. return png_icc_profile_error(png_ptr, colorspace, name, temp,
  1918. "unexpected ICC PCS encoding");
  1919. }
  1920. return 1;
  1921. }
  1922. int /* PRIVATE */
  1923. png_icc_check_tag_table(png_const_structrp png_ptr, png_colorspacerp colorspace,
  1924. png_const_charp name, png_uint_32 profile_length,
  1925. png_const_bytep profile /* header plus whole tag table */)
  1926. {
  1927. png_uint_32 tag_count = png_get_uint_32(profile+128);
  1928. png_uint_32 itag;
  1929. png_const_bytep tag = profile+132; /* The first tag */
  1930. /* First scan all the tags in the table and add bits to the icc_info value
  1931. * (temporarily in 'tags').
  1932. */
  1933. for (itag=0; itag < tag_count; ++itag, tag += 12)
  1934. {
  1935. png_uint_32 tag_id = png_get_uint_32(tag+0);
  1936. png_uint_32 tag_start = png_get_uint_32(tag+4); /* must be aligned */
  1937. png_uint_32 tag_length = png_get_uint_32(tag+8);/* not padded */
  1938. /* The ICC specification does not exclude zero length tags, therefore the
  1939. * start might actually be anywhere if there is no data, but this would be
  1940. * a clear abuse of the intent of the standard so the start is checked for
  1941. * being in range. All defined tag types have an 8 byte header - a 4 byte
  1942. * type signature then 0.
  1943. */
  1944. /* This is a hard error; potentially it can cause read outside the
  1945. * profile.
  1946. */
  1947. if (tag_start > profile_length || tag_length > profile_length - tag_start)
  1948. return png_icc_profile_error(png_ptr, colorspace, name, tag_id,
  1949. "ICC profile tag outside profile");
  1950. if ((tag_start & 3) != 0)
  1951. {
  1952. /* CNHP730S.icc shipped with Microsoft Windows 64 violates this; it is
  1953. * only a warning here because libpng does not care about the
  1954. * alignment.
  1955. */
  1956. (void)png_icc_profile_error(png_ptr, NULL, name, tag_id,
  1957. "ICC profile tag start not a multiple of 4");
  1958. }
  1959. }
  1960. return 1; /* success, maybe with warnings */
  1961. }
  1962. #ifdef PNG_sRGB_SUPPORTED
  1963. #if PNG_sRGB_PROFILE_CHECKS >= 0
  1964. /* Information about the known ICC sRGB profiles */
  1965. static const struct
  1966. {
  1967. png_uint_32 adler, crc, length;
  1968. png_uint_32 md5[4];
  1969. png_byte have_md5;
  1970. png_byte is_broken;
  1971. png_uint_16 intent;
  1972. # define PNG_MD5(a,b,c,d) { a, b, c, d }, (a!=0)||(b!=0)||(c!=0)||(d!=0)
  1973. # define PNG_ICC_CHECKSUM(adler, crc, md5, intent, broke, date, length, fname)\
  1974. { adler, crc, length, md5, broke, intent },
  1975. } png_sRGB_checks[] =
  1976. {
  1977. /* This data comes from contrib/tools/checksum-icc run on downloads of
  1978. * all four ICC sRGB profiles from www.color.org.
  1979. */
  1980. /* adler32, crc32, MD5[4], intent, date, length, file-name */
  1981. PNG_ICC_CHECKSUM(0x0a3fd9f6, 0x3b8772b9,
  1982. PNG_MD5(0x29f83dde, 0xaff255ae, 0x7842fae4, 0xca83390d), 0, 0,
  1983. "2009/03/27 21:36:31", 3048, "sRGB_IEC61966-2-1_black_scaled.icc")
  1984. /* ICC sRGB v2 perceptual no black-compensation: */
  1985. PNG_ICC_CHECKSUM(0x4909e5e1, 0x427ebb21,
  1986. PNG_MD5(0xc95bd637, 0xe95d8a3b, 0x0df38f99, 0xc1320389), 1, 0,
  1987. "2009/03/27 21:37:45", 3052, "sRGB_IEC61966-2-1_no_black_scaling.icc")
  1988. PNG_ICC_CHECKSUM(0xfd2144a1, 0x306fd8ae,
  1989. PNG_MD5(0xfc663378, 0x37e2886b, 0xfd72e983, 0x8228f1b8), 0, 0,
  1990. "2009/08/10 17:28:01", 60988, "sRGB_v4_ICC_preference_displayclass.icc")
  1991. /* ICC sRGB v4 perceptual */
  1992. PNG_ICC_CHECKSUM(0x209c35d2, 0xbbef7812,
  1993. PNG_MD5(0x34562abf, 0x994ccd06, 0x6d2c5721, 0xd0d68c5d), 0, 0,
  1994. "2007/07/25 00:05:37", 60960, "sRGB_v4_ICC_preference.icc")
  1995. /* The following profiles have no known MD5 checksum. If there is a match
  1996. * on the (empty) MD5 the other fields are used to attempt a match and
  1997. * a warning is produced. The first two of these profiles have a 'cprt' tag
  1998. * which suggests that they were also made by Hewlett Packard.
  1999. */
  2000. PNG_ICC_CHECKSUM(0xa054d762, 0x5d5129ce,
  2001. PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 1, 0,
  2002. "2004/07/21 18:57:42", 3024, "sRGB_IEC61966-2-1_noBPC.icc")
  2003. /* This is a 'mntr' (display) profile with a mediaWhitePointTag that does not
  2004. * match the D50 PCS illuminant in the header (it is in fact the D65 values,
  2005. * so the white point is recorded as the un-adapted value.) The profiles
  2006. * below only differ in one byte - the intent - and are basically the same as
  2007. * the previous profile except for the mediaWhitePointTag error and a missing
  2008. * chromaticAdaptationTag.
  2009. */
  2010. PNG_ICC_CHECKSUM(0xf784f3fb, 0x182ea552,
  2011. PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 0, 1/*broken*/,
  2012. "1998/02/09 06:49:00", 3144, "HP-Microsoft sRGB v2 perceptual")
  2013. PNG_ICC_CHECKSUM(0x0398f3fc, 0xf29e526d,
  2014. PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 1, 1/*broken*/,
  2015. "1998/02/09 06:49:00", 3144, "HP-Microsoft sRGB v2 media-relative")
  2016. };
  2017. static int
  2018. png_compare_ICC_profile_with_sRGB(png_const_structrp png_ptr,
  2019. png_const_bytep profile, uLong adler)
  2020. {
  2021. /* The quick check is to verify just the MD5 signature and trust the
  2022. * rest of the data. Because the profile has already been verified for
  2023. * correctness this is safe. png_colorspace_set_sRGB will check the 'intent'
  2024. * field too, so if the profile has been edited with an intent not defined
  2025. * by sRGB (but maybe defined by a later ICC specification) the read of
  2026. * the profile will fail at that point.
  2027. */
  2028. png_uint_32 length = 0;
  2029. png_uint_32 intent = 0x10000; /* invalid */
  2030. #if PNG_sRGB_PROFILE_CHECKS > 1
  2031. uLong crc = 0; /* the value for 0 length data */
  2032. #endif
  2033. unsigned int i;
  2034. #ifdef PNG_SET_OPTION_SUPPORTED
  2035. /* First see if PNG_SKIP_sRGB_CHECK_PROFILE has been set to "on" */
  2036. if (((png_ptr->options >> PNG_SKIP_sRGB_CHECK_PROFILE) & 3) ==
  2037. PNG_OPTION_ON)
  2038. return 0;
  2039. #endif
  2040. for (i=0; i < (sizeof png_sRGB_checks) / (sizeof png_sRGB_checks[0]); ++i)
  2041. {
  2042. if (png_get_uint_32(profile+84) == png_sRGB_checks[i].md5[0] &&
  2043. png_get_uint_32(profile+88) == png_sRGB_checks[i].md5[1] &&
  2044. png_get_uint_32(profile+92) == png_sRGB_checks[i].md5[2] &&
  2045. png_get_uint_32(profile+96) == png_sRGB_checks[i].md5[3])
  2046. {
  2047. /* This may be one of the old HP profiles without an MD5, in that
  2048. * case we can only use the length and Adler32 (note that these
  2049. * are not used by default if there is an MD5!)
  2050. */
  2051. # if PNG_sRGB_PROFILE_CHECKS == 0
  2052. if (png_sRGB_checks[i].have_md5 != 0)
  2053. return 1+png_sRGB_checks[i].is_broken;
  2054. # endif
  2055. /* Profile is unsigned or more checks have been configured in. */
  2056. if (length == 0)
  2057. {
  2058. length = png_get_uint_32(profile);
  2059. intent = png_get_uint_32(profile+64);
  2060. }
  2061. /* Length *and* intent must match */
  2062. if (length == (png_uint_32) png_sRGB_checks[i].length &&
  2063. intent == (png_uint_32) png_sRGB_checks[i].intent)
  2064. {
  2065. /* Now calculate the adler32 if not done already. */
  2066. if (adler == 0)
  2067. {
  2068. adler = adler32(0, NULL, 0);
  2069. adler = adler32(adler, profile, length);
  2070. }
  2071. if (adler == png_sRGB_checks[i].adler)
  2072. {
  2073. /* These basic checks suggest that the data has not been
  2074. * modified, but if the check level is more than 1 perform
  2075. * our own crc32 checksum on the data.
  2076. */
  2077. # if PNG_sRGB_PROFILE_CHECKS > 1
  2078. if (crc == 0)
  2079. {
  2080. crc = crc32(0, NULL, 0);
  2081. crc = crc32(crc, profile, length);
  2082. }
  2083. /* So this check must pass for the 'return' below to happen.
  2084. */
  2085. if (crc == png_sRGB_checks[i].crc)
  2086. # endif
  2087. {
  2088. if (png_sRGB_checks[i].is_broken != 0)
  2089. {
  2090. /* These profiles are known to have bad data that may cause
  2091. * problems if they are used, therefore attempt to
  2092. * discourage their use, skip the 'have_md5' warning below,
  2093. * which is made irrelevant by this error.
  2094. */
  2095. png_chunk_report(png_ptr, "known incorrect sRGB profile",
  2096. PNG_CHUNK_ERROR);
  2097. }
  2098. /* Warn that this being done; this isn't even an error since
  2099. * the profile is perfectly valid, but it would be nice if
  2100. * people used the up-to-date ones.
  2101. */
  2102. else if (png_sRGB_checks[i].have_md5 == 0)
  2103. {
  2104. png_chunk_report(png_ptr,
  2105. "out-of-date sRGB profile with no signature",
  2106. PNG_CHUNK_WARNING);
  2107. }
  2108. return 1+png_sRGB_checks[i].is_broken;
  2109. }
  2110. }
  2111. # if PNG_sRGB_PROFILE_CHECKS > 0
  2112. /* The signature matched, but the profile had been changed in some
  2113. * way. This probably indicates a data error or uninformed hacking.
  2114. * Fall through to "no match".
  2115. */
  2116. png_chunk_report(png_ptr,
  2117. "Not recognizing known sRGB profile that has been edited",
  2118. PNG_CHUNK_WARNING);
  2119. break;
  2120. # endif
  2121. }
  2122. }
  2123. }
  2124. return 0; /* no match */
  2125. }
  2126. void /* PRIVATE */
  2127. png_icc_set_sRGB(png_const_structrp png_ptr,
  2128. png_colorspacerp colorspace, png_const_bytep profile, uLong adler)
  2129. {
  2130. /* Is this profile one of the known ICC sRGB profiles? If it is, just set
  2131. * the sRGB information.
  2132. */
  2133. if (png_compare_ICC_profile_with_sRGB(png_ptr, profile, adler) != 0)
  2134. (void)png_colorspace_set_sRGB(png_ptr, colorspace,
  2135. (int)/*already checked*/png_get_uint_32(profile+64));
  2136. }
  2137. #endif /* PNG_sRGB_PROFILE_CHECKS >= 0 */
  2138. #endif /* sRGB */
  2139. int /* PRIVATE */
  2140. png_colorspace_set_ICC(png_const_structrp png_ptr, png_colorspacerp colorspace,
  2141. png_const_charp name, png_uint_32 profile_length, png_const_bytep profile,
  2142. int color_type)
  2143. {
  2144. if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
  2145. return 0;
  2146. if (icc_check_length(png_ptr, colorspace, name, profile_length) != 0 &&
  2147. png_icc_check_header(png_ptr, colorspace, name, profile_length, profile,
  2148. color_type) != 0 &&
  2149. png_icc_check_tag_table(png_ptr, colorspace, name, profile_length,
  2150. profile) != 0)
  2151. {
  2152. # if defined(PNG_sRGB_SUPPORTED) && PNG_sRGB_PROFILE_CHECKS >= 0
  2153. /* If no sRGB support, don't try storing sRGB information */
  2154. png_icc_set_sRGB(png_ptr, colorspace, profile, 0);
  2155. # endif
  2156. return 1;
  2157. }
  2158. /* Failure case */
  2159. return 0;
  2160. }
  2161. #endif /* iCCP */
  2162. #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
  2163. void /* PRIVATE */
  2164. png_colorspace_set_rgb_coefficients(png_structrp png_ptr)
  2165. {
  2166. /* Set the rgb_to_gray coefficients from the colorspace. */
  2167. if (png_ptr->rgb_to_gray_coefficients_set == 0 &&
  2168. (png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
  2169. {
  2170. /* png_set_background has not been called, get the coefficients from the Y
  2171. * values of the colorspace colorants.
  2172. */
  2173. png_fixed_point r = png_ptr->colorspace.end_points_XYZ.red_Y;
  2174. png_fixed_point g = png_ptr->colorspace.end_points_XYZ.green_Y;
  2175. png_fixed_point b = png_ptr->colorspace.end_points_XYZ.blue_Y;
  2176. png_fixed_point total = r+g+b;
  2177. if (total > 0 &&
  2178. r >= 0 && png_muldiv(&r, r, 32768, total) && r >= 0 && r <= 32768 &&
  2179. g >= 0 && png_muldiv(&g, g, 32768, total) && g >= 0 && g <= 32768 &&
  2180. b >= 0 && png_muldiv(&b, b, 32768, total) && b >= 0 && b <= 32768 &&
  2181. r+g+b <= 32769)
  2182. {
  2183. /* We allow 0 coefficients here. r+g+b may be 32769 if two or
  2184. * all of the coefficients were rounded up. Handle this by
  2185. * reducing the *largest* coefficient by 1; this matches the
  2186. * approach used for the default coefficients in pngrtran.c
  2187. */
  2188. int add = 0;
  2189. if (r+g+b > 32768)
  2190. add = -1;
  2191. else if (r+g+b < 32768)
  2192. add = 1;
  2193. if (add != 0)
  2194. {
  2195. if (g >= r && g >= b)
  2196. g += add;
  2197. else if (r >= g && r >= b)
  2198. r += add;
  2199. else
  2200. b += add;
  2201. }
  2202. /* Check for an internal error. */
  2203. if (r+g+b != 32768)
  2204. png_error(png_ptr,
  2205. "internal error handling cHRM coefficients");
  2206. else
  2207. {
  2208. png_ptr->rgb_to_gray_red_coeff = (png_uint_16)r;
  2209. png_ptr->rgb_to_gray_green_coeff = (png_uint_16)g;
  2210. }
  2211. }
  2212. /* This is a png_error at present even though it could be ignored -
  2213. * it should never happen, but it is important that if it does, the
  2214. * bug is fixed.
  2215. */
  2216. else
  2217. png_error(png_ptr, "internal error handling cHRM->XYZ");
  2218. }
  2219. }
  2220. #endif /* READ_RGB_TO_GRAY */
  2221. #endif /* COLORSPACE */
  2222. #ifdef __GNUC__
  2223. /* This exists solely to work round a warning from GNU C. */
  2224. static int /* PRIVATE */
  2225. png_gt(size_t a, size_t b)
  2226. {
  2227. return a > b;
  2228. }
  2229. #else
  2230. # define png_gt(a,b) ((a) > (b))
  2231. #endif
  2232. void /* PRIVATE */
  2233. png_check_IHDR(png_const_structrp png_ptr,
  2234. png_uint_32 width, png_uint_32 height, int bit_depth,
  2235. int color_type, int interlace_type, int compression_type,
  2236. int filter_type)
  2237. {
  2238. int error = 0;
  2239. /* Check for width and height valid values */
  2240. if (width == 0)
  2241. {
  2242. png_warning(png_ptr, "Image width is zero in IHDR");
  2243. error = 1;
  2244. }
  2245. if (width > PNG_UINT_31_MAX)
  2246. {
  2247. png_warning(png_ptr, "Invalid image width in IHDR");
  2248. error = 1;
  2249. }
  2250. if (png_gt(((width + 7) & (~7U)),
  2251. ((PNG_SIZE_MAX
  2252. - 48 /* big_row_buf hack */
  2253. - 1) /* filter byte */
  2254. / 8) /* 8-byte RGBA pixels */
  2255. - 1)) /* extra max_pixel_depth pad */
  2256. {
  2257. /* The size of the row must be within the limits of this architecture.
  2258. * Because the read code can perform arbitrary transformations the
  2259. * maximum size is checked here. Because the code in png_read_start_row
  2260. * adds extra space "for safety's sake" in several places a conservative
  2261. * limit is used here.
  2262. *
  2263. * NOTE: it would be far better to check the size that is actually used,
  2264. * but the effect in the real world is minor and the changes are more
  2265. * extensive, therefore much more dangerous and much more difficult to
  2266. * write in a way that avoids compiler warnings.
  2267. */
  2268. png_warning(png_ptr, "Image width is too large for this architecture");
  2269. error = 1;
  2270. }
  2271. #ifdef PNG_SET_USER_LIMITS_SUPPORTED
  2272. if (width > png_ptr->user_width_max)
  2273. #else
  2274. if (width > PNG_USER_WIDTH_MAX)
  2275. #endif
  2276. {
  2277. png_warning(png_ptr, "Image width exceeds user limit in IHDR");
  2278. error = 1;
  2279. }
  2280. if (height == 0)
  2281. {
  2282. png_warning(png_ptr, "Image height is zero in IHDR");
  2283. error = 1;
  2284. }
  2285. if (height > PNG_UINT_31_MAX)
  2286. {
  2287. png_warning(png_ptr, "Invalid image height in IHDR");
  2288. error = 1;
  2289. }
  2290. #ifdef PNG_SET_USER_LIMITS_SUPPORTED
  2291. if (height > png_ptr->user_height_max)
  2292. #else
  2293. if (height > PNG_USER_HEIGHT_MAX)
  2294. #endif
  2295. {
  2296. png_warning(png_ptr, "Image height exceeds user limit in IHDR");
  2297. error = 1;
  2298. }
  2299. /* Check other values */
  2300. if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 &&
  2301. bit_depth != 8 && bit_depth != 16)
  2302. {
  2303. png_warning(png_ptr, "Invalid bit depth in IHDR");
  2304. error = 1;
  2305. }
  2306. if (color_type < 0 || color_type == 1 ||
  2307. color_type == 5 || color_type > 6)
  2308. {
  2309. png_warning(png_ptr, "Invalid color type in IHDR");
  2310. error = 1;
  2311. }
  2312. if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) ||
  2313. ((color_type == PNG_COLOR_TYPE_RGB ||
  2314. color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
  2315. color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8))
  2316. {
  2317. png_warning(png_ptr, "Invalid color type/bit depth combination in IHDR");
  2318. error = 1;
  2319. }
  2320. if (interlace_type >= PNG_INTERLACE_LAST)
  2321. {
  2322. png_warning(png_ptr, "Unknown interlace method in IHDR");
  2323. error = 1;
  2324. }
  2325. if (compression_type != PNG_COMPRESSION_TYPE_BASE)
  2326. {
  2327. png_warning(png_ptr, "Unknown compression method in IHDR");
  2328. error = 1;
  2329. }
  2330. #ifdef PNG_MNG_FEATURES_SUPPORTED
  2331. /* Accept filter_method 64 (intrapixel differencing) only if
  2332. * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
  2333. * 2. Libpng did not read a PNG signature (this filter_method is only
  2334. * used in PNG datastreams that are embedded in MNG datastreams) and
  2335. * 3. The application called png_permit_mng_features with a mask that
  2336. * included PNG_FLAG_MNG_FILTER_64 and
  2337. * 4. The filter_method is 64 and
  2338. * 5. The color_type is RGB or RGBA
  2339. */
  2340. if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0 &&
  2341. png_ptr->mng_features_permitted != 0)
  2342. png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");
  2343. if (filter_type != PNG_FILTER_TYPE_BASE)
  2344. {
  2345. if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
  2346. (filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&
  2347. ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&
  2348. (color_type == PNG_COLOR_TYPE_RGB ||
  2349. color_type == PNG_COLOR_TYPE_RGB_ALPHA)))
  2350. {
  2351. png_warning(png_ptr, "Unknown filter method in IHDR");
  2352. error = 1;
  2353. }
  2354. if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0)
  2355. {
  2356. png_warning(png_ptr, "Invalid filter method in IHDR");
  2357. error = 1;
  2358. }
  2359. }
  2360. #else
  2361. if (filter_type != PNG_FILTER_TYPE_BASE)
  2362. {
  2363. png_warning(png_ptr, "Unknown filter method in IHDR");
  2364. error = 1;
  2365. }
  2366. #endif
  2367. if (error == 1)
  2368. png_error(png_ptr, "Invalid IHDR data");
  2369. }
  2370. #if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED)
  2371. /* ASCII to fp functions */
  2372. /* Check an ASCII formated floating point value, see the more detailed
  2373. * comments in pngpriv.h
  2374. */
  2375. /* The following is used internally to preserve the sticky flags */
  2376. #define png_fp_add(state, flags) ((state) |= (flags))
  2377. #define png_fp_set(state, value) ((state) = (value) | ((state) & PNG_FP_STICKY))
  2378. int /* PRIVATE */
  2379. png_check_fp_number(png_const_charp string, png_size_t size, int *statep,
  2380. png_size_tp whereami)
  2381. {
  2382. int state = *statep;
  2383. png_size_t i = *whereami;
  2384. while (i < size)
  2385. {
  2386. int type;
  2387. /* First find the type of the next character */
  2388. switch (string[i])
  2389. {
  2390. case 43: type = PNG_FP_SAW_SIGN; break;
  2391. case 45: type = PNG_FP_SAW_SIGN + PNG_FP_NEGATIVE; break;
  2392. case 46: type = PNG_FP_SAW_DOT; break;
  2393. case 48: type = PNG_FP_SAW_DIGIT; break;
  2394. case 49: case 50: case 51: case 52:
  2395. case 53: case 54: case 55: case 56:
  2396. case 57: type = PNG_FP_SAW_DIGIT + PNG_FP_NONZERO; break;
  2397. case 69:
  2398. case 101: type = PNG_FP_SAW_E; break;
  2399. default: goto PNG_FP_End;
  2400. }
  2401. /* Now deal with this type according to the current
  2402. * state, the type is arranged to not overlap the
  2403. * bits of the PNG_FP_STATE.
  2404. */
  2405. switch ((state & PNG_FP_STATE) + (type & PNG_FP_SAW_ANY))
  2406. {
  2407. case PNG_FP_INTEGER + PNG_FP_SAW_SIGN:
  2408. if ((state & PNG_FP_SAW_ANY) != 0)
  2409. goto PNG_FP_End; /* not a part of the number */
  2410. png_fp_add(state, type);
  2411. break;
  2412. case PNG_FP_INTEGER + PNG_FP_SAW_DOT:
  2413. /* Ok as trailer, ok as lead of fraction. */
  2414. if ((state & PNG_FP_SAW_DOT) != 0) /* two dots */
  2415. goto PNG_FP_End;
  2416. else if ((state & PNG_FP_SAW_DIGIT) != 0) /* trailing dot? */
  2417. png_fp_add(state, type);
  2418. else
  2419. png_fp_set(state, PNG_FP_FRACTION | type);
  2420. break;
  2421. case PNG_FP_INTEGER + PNG_FP_SAW_DIGIT:
  2422. if ((state & PNG_FP_SAW_DOT) != 0) /* delayed fraction */
  2423. png_fp_set(state, PNG_FP_FRACTION | PNG_FP_SAW_DOT);
  2424. png_fp_add(state, type | PNG_FP_WAS_VALID);
  2425. break;
  2426. case PNG_FP_INTEGER + PNG_FP_SAW_E:
  2427. if ((state & PNG_FP_SAW_DIGIT) == 0)
  2428. goto PNG_FP_End;
  2429. png_fp_set(state, PNG_FP_EXPONENT);
  2430. break;
  2431. /* case PNG_FP_FRACTION + PNG_FP_SAW_SIGN:
  2432. goto PNG_FP_End; ** no sign in fraction */
  2433. /* case PNG_FP_FRACTION + PNG_FP_SAW_DOT:
  2434. goto PNG_FP_End; ** Because SAW_DOT is always set */
  2435. case PNG_FP_FRACTION + PNG_FP_SAW_DIGIT:
  2436. png_fp_add(state, type | PNG_FP_WAS_VALID);
  2437. break;
  2438. case PNG_FP_FRACTION + PNG_FP_SAW_E:
  2439. /* This is correct because the trailing '.' on an
  2440. * integer is handled above - so we can only get here
  2441. * with the sequence ".E" (with no preceding digits).
  2442. */
  2443. if ((state & PNG_FP_SAW_DIGIT) == 0)
  2444. goto PNG_FP_End;
  2445. png_fp_set(state, PNG_FP_EXPONENT);
  2446. break;
  2447. case PNG_FP_EXPONENT + PNG_FP_SAW_SIGN:
  2448. if ((state & PNG_FP_SAW_ANY) != 0)
  2449. goto PNG_FP_End; /* not a part of the number */
  2450. png_fp_add(state, PNG_FP_SAW_SIGN);
  2451. break;
  2452. /* case PNG_FP_EXPONENT + PNG_FP_SAW_DOT:
  2453. goto PNG_FP_End; */
  2454. case PNG_FP_EXPONENT + PNG_FP_SAW_DIGIT:
  2455. png_fp_add(state, PNG_FP_SAW_DIGIT | PNG_FP_WAS_VALID);
  2456. break;
  2457. /* case PNG_FP_EXPONEXT + PNG_FP_SAW_E:
  2458. goto PNG_FP_End; */
  2459. default: goto PNG_FP_End; /* I.e. break 2 */
  2460. }
  2461. /* The character seems ok, continue. */
  2462. ++i;
  2463. }
  2464. PNG_FP_End:
  2465. /* Here at the end, update the state and return the correct
  2466. * return code.
  2467. */
  2468. *statep = state;
  2469. *whereami = i;
  2470. return (state & PNG_FP_SAW_DIGIT) != 0;
  2471. }
  2472. /* The same but for a complete string. */
  2473. int
  2474. png_check_fp_string(png_const_charp string, png_size_t size)
  2475. {
  2476. int state=0;
  2477. png_size_t char_index=0;
  2478. if (png_check_fp_number(string, size, &state, &char_index) != 0 &&
  2479. (char_index == size || string[char_index] == 0))
  2480. return state /* must be non-zero - see above */;
  2481. return 0; /* i.e. fail */
  2482. }
  2483. #endif /* pCAL || sCAL */
  2484. #ifdef PNG_sCAL_SUPPORTED
  2485. # ifdef PNG_FLOATING_POINT_SUPPORTED
  2486. /* Utility used below - a simple accurate power of ten from an integral
  2487. * exponent.
  2488. */
  2489. static double
  2490. png_pow10(int power)
  2491. {
  2492. int recip = 0;
  2493. double d = 1;
  2494. /* Handle negative exponent with a reciprocal at the end because
  2495. * 10 is exact whereas .1 is inexact in base 2
  2496. */
  2497. if (power < 0)
  2498. {
  2499. if (power < DBL_MIN_10_EXP) return 0;
  2500. recip = 1; power = -power;
  2501. }
  2502. if (power > 0)
  2503. {
  2504. /* Decompose power bitwise. */
  2505. double mult = 10;
  2506. do
  2507. {
  2508. if (power & 1) d *= mult;
  2509. mult *= mult;
  2510. power >>= 1;
  2511. }
  2512. while (power > 0);
  2513. if (recip != 0) d = 1/d;
  2514. }
  2515. /* else power is 0 and d is 1 */
  2516. return d;
  2517. }
  2518. /* Function to format a floating point value in ASCII with a given
  2519. * precision.
  2520. */
  2521. #if GCC_STRICT_OVERFLOW
  2522. #pragma GCC diagnostic push
  2523. /* The problem arises below with exp_b10, which can never overflow because it
  2524. * comes, originally, from frexp and is therefore limited to a range which is
  2525. * typically +/-710 (log2(DBL_MAX)/log2(DBL_MIN)).
  2526. */
  2527. #pragma GCC diagnostic warning "-Wstrict-overflow=2"
  2528. #endif /* GCC_STRICT_OVERFLOW */
  2529. void /* PRIVATE */
  2530. png_ascii_from_fp(png_const_structrp png_ptr, png_charp ascii, png_size_t size,
  2531. double fp, unsigned int precision)
  2532. {
  2533. /* We use standard functions from math.h, but not printf because
  2534. * that would require stdio. The caller must supply a buffer of
  2535. * sufficient size or we will png_error. The tests on size and
  2536. * the space in ascii[] consumed are indicated below.
  2537. */
  2538. if (precision < 1)
  2539. precision = DBL_DIG;
  2540. /* Enforce the limit of the implementation precision too. */
  2541. if (precision > DBL_DIG+1)
  2542. precision = DBL_DIG+1;
  2543. /* Basic sanity checks */
  2544. if (size >= precision+5) /* See the requirements below. */
  2545. {
  2546. if (fp < 0)
  2547. {
  2548. fp = -fp;
  2549. *ascii++ = 45; /* '-' PLUS 1 TOTAL 1 */
  2550. --size;
  2551. }
  2552. if (fp >= DBL_MIN && fp <= DBL_MAX)
  2553. {
  2554. int exp_b10; /* A base 10 exponent */
  2555. double base; /* 10^exp_b10 */
  2556. /* First extract a base 10 exponent of the number,
  2557. * the calculation below rounds down when converting
  2558. * from base 2 to base 10 (multiply by log10(2) -
  2559. * 0.3010, but 77/256 is 0.3008, so exp_b10 needs to
  2560. * be increased. Note that the arithmetic shift
  2561. * performs a floor() unlike C arithmetic - using a
  2562. * C multiply would break the following for negative
  2563. * exponents.
  2564. */
  2565. (void)frexp(fp, &exp_b10); /* exponent to base 2 */
  2566. exp_b10 = (exp_b10 * 77) >> 8; /* <= exponent to base 10 */
  2567. /* Avoid underflow here. */
  2568. base = png_pow10(exp_b10); /* May underflow */
  2569. while (base < DBL_MIN || base < fp)
  2570. {
  2571. /* And this may overflow. */
  2572. double test = png_pow10(exp_b10+1);
  2573. if (test <= DBL_MAX)
  2574. {
  2575. ++exp_b10; base = test;
  2576. }
  2577. else
  2578. break;
  2579. }
  2580. /* Normalize fp and correct exp_b10, after this fp is in the
  2581. * range [.1,1) and exp_b10 is both the exponent and the digit
  2582. * *before* which the decimal point should be inserted
  2583. * (starting with 0 for the first digit). Note that this
  2584. * works even if 10^exp_b10 is out of range because of the
  2585. * test on DBL_MAX above.
  2586. */
  2587. fp /= base;
  2588. while (fp >= 1)
  2589. {
  2590. fp /= 10; ++exp_b10;
  2591. }
  2592. /* Because of the code above fp may, at this point, be
  2593. * less than .1, this is ok because the code below can
  2594. * handle the leading zeros this generates, so no attempt
  2595. * is made to correct that here.
  2596. */
  2597. {
  2598. unsigned int czero, clead, cdigits;
  2599. char exponent[10];
  2600. /* Allow up to two leading zeros - this will not lengthen
  2601. * the number compared to using E-n.
  2602. */
  2603. if (exp_b10 < 0 && exp_b10 > -3) /* PLUS 3 TOTAL 4 */
  2604. {
  2605. czero = 0U-exp_b10; /* PLUS 2 digits: TOTAL 3 */
  2606. exp_b10 = 0; /* Dot added below before first output. */
  2607. }
  2608. else
  2609. czero = 0; /* No zeros to add */
  2610. /* Generate the digit list, stripping trailing zeros and
  2611. * inserting a '.' before a digit if the exponent is 0.
  2612. */
  2613. clead = czero; /* Count of leading zeros */
  2614. cdigits = 0; /* Count of digits in list. */
  2615. do
  2616. {
  2617. double d;
  2618. fp *= 10;
  2619. /* Use modf here, not floor and subtract, so that
  2620. * the separation is done in one step. At the end
  2621. * of the loop don't break the number into parts so
  2622. * that the final digit is rounded.
  2623. */
  2624. if (cdigits+czero+1 < precision+clead)
  2625. fp = modf(fp, &d);
  2626. else
  2627. {
  2628. d = floor(fp + .5);
  2629. if (d > 9)
  2630. {
  2631. /* Rounding up to 10, handle that here. */
  2632. if (czero > 0)
  2633. {
  2634. --czero; d = 1;
  2635. if (cdigits == 0) --clead;
  2636. }
  2637. else
  2638. {
  2639. while (cdigits > 0 && d > 9)
  2640. {
  2641. int ch = *--ascii;
  2642. if (exp_b10 != (-1))
  2643. ++exp_b10;
  2644. else if (ch == 46)
  2645. {
  2646. ch = *--ascii; ++size;
  2647. /* Advance exp_b10 to '1', so that the
  2648. * decimal point happens after the
  2649. * previous digit.
  2650. */
  2651. exp_b10 = 1;
  2652. }
  2653. --cdigits;
  2654. d = ch - 47; /* I.e. 1+(ch-48) */
  2655. }
  2656. /* Did we reach the beginning? If so adjust the
  2657. * exponent but take into account the leading
  2658. * decimal point.
  2659. */
  2660. if (d > 9) /* cdigits == 0 */
  2661. {
  2662. if (exp_b10 == (-1))
  2663. {
  2664. /* Leading decimal point (plus zeros?), if
  2665. * we lose the decimal point here it must
  2666. * be reentered below.
  2667. */
  2668. int ch = *--ascii;
  2669. if (ch == 46)
  2670. {
  2671. ++size; exp_b10 = 1;
  2672. }
  2673. /* Else lost a leading zero, so 'exp_b10' is
  2674. * still ok at (-1)
  2675. */
  2676. }
  2677. else
  2678. ++exp_b10;
  2679. /* In all cases we output a '1' */
  2680. d = 1;
  2681. }
  2682. }
  2683. }
  2684. fp = 0; /* Guarantees termination below. */
  2685. }
  2686. if (d == 0)
  2687. {
  2688. ++czero;
  2689. if (cdigits == 0) ++clead;
  2690. }
  2691. else
  2692. {
  2693. /* Included embedded zeros in the digit count. */
  2694. cdigits += czero - clead;
  2695. clead = 0;
  2696. while (czero > 0)
  2697. {
  2698. /* exp_b10 == (-1) means we just output the decimal
  2699. * place - after the DP don't adjust 'exp_b10' any
  2700. * more!
  2701. */
  2702. if (exp_b10 != (-1))
  2703. {
  2704. if (exp_b10 == 0)
  2705. {
  2706. *ascii++ = 46; --size;
  2707. }
  2708. /* PLUS 1: TOTAL 4 */
  2709. --exp_b10;
  2710. }
  2711. *ascii++ = 48; --czero;
  2712. }
  2713. if (exp_b10 != (-1))
  2714. {
  2715. if (exp_b10 == 0)
  2716. {
  2717. *ascii++ = 46; --size; /* counted above */
  2718. }
  2719. --exp_b10;
  2720. }
  2721. *ascii++ = (char)(48 + (int)d); ++cdigits;
  2722. }
  2723. }
  2724. while (cdigits+czero < precision+clead && fp > DBL_MIN);
  2725. /* The total output count (max) is now 4+precision */
  2726. /* Check for an exponent, if we don't need one we are
  2727. * done and just need to terminate the string. At
  2728. * this point exp_b10==(-1) is effectively a flag - it got
  2729. * to '-1' because of the decrement after outputting
  2730. * the decimal point above (the exponent required is
  2731. * *not* -1!)
  2732. */
  2733. if (exp_b10 >= (-1) && exp_b10 <= 2)
  2734. {
  2735. /* The following only happens if we didn't output the
  2736. * leading zeros above for negative exponent, so this
  2737. * doesn't add to the digit requirement. Note that the
  2738. * two zeros here can only be output if the two leading
  2739. * zeros were *not* output, so this doesn't increase
  2740. * the output count.
  2741. */
  2742. while (exp_b10-- > 0) *ascii++ = 48;
  2743. *ascii = 0;
  2744. /* Total buffer requirement (including the '\0') is
  2745. * 5+precision - see check at the start.
  2746. */
  2747. return;
  2748. }
  2749. /* Here if an exponent is required, adjust size for
  2750. * the digits we output but did not count. The total
  2751. * digit output here so far is at most 1+precision - no
  2752. * decimal point and no leading or trailing zeros have
  2753. * been output.
  2754. */
  2755. size -= cdigits;
  2756. *ascii++ = 69; --size; /* 'E': PLUS 1 TOTAL 2+precision */
  2757. /* The following use of an unsigned temporary avoids ambiguities in
  2758. * the signed arithmetic on exp_b10 and permits GCC at least to do
  2759. * better optimization.
  2760. */
  2761. {
  2762. unsigned int uexp_b10;
  2763. if (exp_b10 < 0)
  2764. {
  2765. *ascii++ = 45; --size; /* '-': PLUS 1 TOTAL 3+precision */
  2766. uexp_b10 = 0U-exp_b10;
  2767. }
  2768. else
  2769. uexp_b10 = 0U+exp_b10;
  2770. cdigits = 0;
  2771. while (uexp_b10 > 0)
  2772. {
  2773. exponent[cdigits++] = (char)(48 + uexp_b10 % 10);
  2774. uexp_b10 /= 10;
  2775. }
  2776. }
  2777. /* Need another size check here for the exponent digits, so
  2778. * this need not be considered above.
  2779. */
  2780. if (size > cdigits)
  2781. {
  2782. while (cdigits > 0) *ascii++ = exponent[--cdigits];
  2783. *ascii = 0;
  2784. return;
  2785. }
  2786. }
  2787. }
  2788. else if (!(fp >= DBL_MIN))
  2789. {
  2790. *ascii++ = 48; /* '0' */
  2791. *ascii = 0;
  2792. return;
  2793. }
  2794. else
  2795. {
  2796. *ascii++ = 105; /* 'i' */
  2797. *ascii++ = 110; /* 'n' */
  2798. *ascii++ = 102; /* 'f' */
  2799. *ascii = 0;
  2800. return;
  2801. }
  2802. }
  2803. /* Here on buffer too small. */
  2804. png_error(png_ptr, "ASCII conversion buffer too small");
  2805. }
  2806. #if GCC_STRICT_OVERFLOW
  2807. #pragma GCC diagnostic pop
  2808. #endif /* GCC_STRICT_OVERFLOW */
  2809. # endif /* FLOATING_POINT */
  2810. # ifdef PNG_FIXED_POINT_SUPPORTED
  2811. /* Function to format a fixed point value in ASCII.
  2812. */
  2813. void /* PRIVATE */
  2814. png_ascii_from_fixed(png_const_structrp png_ptr, png_charp ascii,
  2815. png_size_t size, png_fixed_point fp)
  2816. {
  2817. /* Require space for 10 decimal digits, a decimal point, a minus sign and a
  2818. * trailing \0, 13 characters:
  2819. */
  2820. if (size > 12)
  2821. {
  2822. png_uint_32 num;
  2823. /* Avoid overflow here on the minimum integer. */
  2824. if (fp < 0)
  2825. {
  2826. *ascii++ = 45; num = (png_uint_32)(-fp);
  2827. }
  2828. else
  2829. num = (png_uint_32)fp;
  2830. if (num <= 0x80000000) /* else overflowed */
  2831. {
  2832. unsigned int ndigits = 0, first = 16 /* flag value */;
  2833. char digits[10];
  2834. while (num)
  2835. {
  2836. /* Split the low digit off num: */
  2837. unsigned int tmp = num/10;
  2838. num -= tmp*10;
  2839. digits[ndigits++] = (char)(48 + num);
  2840. /* Record the first non-zero digit, note that this is a number
  2841. * starting at 1, it's not actually the array index.
  2842. */
  2843. if (first == 16 && num > 0)
  2844. first = ndigits;
  2845. num = tmp;
  2846. }
  2847. if (ndigits > 0)
  2848. {
  2849. while (ndigits > 5) *ascii++ = digits[--ndigits];
  2850. /* The remaining digits are fractional digits, ndigits is '5' or
  2851. * smaller at this point. It is certainly not zero. Check for a
  2852. * non-zero fractional digit:
  2853. */
  2854. if (first <= 5)
  2855. {
  2856. unsigned int i;
  2857. *ascii++ = 46; /* decimal point */
  2858. /* ndigits may be <5 for small numbers, output leading zeros
  2859. * then ndigits digits to first:
  2860. */
  2861. i = 5;
  2862. while (ndigits < i)
  2863. {
  2864. *ascii++ = 48; --i;
  2865. }
  2866. while (ndigits >= first) *ascii++ = digits[--ndigits];
  2867. /* Don't output the trailing zeros! */
  2868. }
  2869. }
  2870. else
  2871. *ascii++ = 48;
  2872. /* And null terminate the string: */
  2873. *ascii = 0;
  2874. return;
  2875. }
  2876. }
  2877. /* Here on buffer too small. */
  2878. png_error(png_ptr, "ASCII conversion buffer too small");
  2879. }
  2880. # endif /* FIXED_POINT */
  2881. #endif /* SCAL */
  2882. #if defined(PNG_FLOATING_POINT_SUPPORTED) && \
  2883. !defined(PNG_FIXED_POINT_MACRO_SUPPORTED) && \
  2884. (defined(PNG_gAMA_SUPPORTED) || defined(PNG_cHRM_SUPPORTED) || \
  2885. defined(PNG_sCAL_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) || \
  2886. defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)) || \
  2887. (defined(PNG_sCAL_SUPPORTED) && \
  2888. defined(PNG_FLOATING_ARITHMETIC_SUPPORTED))
  2889. png_fixed_point
  2890. png_fixed(png_const_structrp png_ptr, double fp, png_const_charp text)
  2891. {
  2892. double r = floor(100000 * fp + .5);
  2893. if (r > 2147483647. || r < -2147483648.)
  2894. png_fixed_error(png_ptr, text);
  2895. # ifndef PNG_ERROR_TEXT_SUPPORTED
  2896. PNG_UNUSED(text)
  2897. # endif
  2898. return (png_fixed_point)r;
  2899. }
  2900. #endif
  2901. #if defined(PNG_GAMMA_SUPPORTED) || defined(PNG_COLORSPACE_SUPPORTED) ||\
  2902. defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG_READ_pHYs_SUPPORTED)
  2903. /* muldiv functions */
  2904. /* This API takes signed arguments and rounds the result to the nearest
  2905. * integer (or, for a fixed point number - the standard argument - to
  2906. * the nearest .00001). Overflow and divide by zero are signalled in
  2907. * the result, a boolean - true on success, false on overflow.
  2908. */
  2909. #if GCC_STRICT_OVERFLOW /* from above */
  2910. /* It is not obvious which comparison below gets optimized in such a way that
  2911. * signed overflow would change the result; looking through the code does not
  2912. * reveal any tests which have the form GCC complains about, so presumably the
  2913. * optimizer is moving an add or subtract into the 'if' somewhere.
  2914. */
  2915. #pragma GCC diagnostic push
  2916. #pragma GCC diagnostic warning "-Wstrict-overflow=2"
  2917. #endif /* GCC_STRICT_OVERFLOW */
  2918. int
  2919. png_muldiv(png_fixed_point_p res, png_fixed_point a, png_int_32 times,
  2920. png_int_32 divisor)
  2921. {
  2922. /* Return a * times / divisor, rounded. */
  2923. if (divisor != 0)
  2924. {
  2925. if (a == 0 || times == 0)
  2926. {
  2927. *res = 0;
  2928. return 1;
  2929. }
  2930. else
  2931. {
  2932. #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
  2933. double r = a;
  2934. r *= times;
  2935. r /= divisor;
  2936. r = floor(r+.5);
  2937. /* A png_fixed_point is a 32-bit integer. */
  2938. if (r <= 2147483647. && r >= -2147483648.)
  2939. {
  2940. *res = (png_fixed_point)r;
  2941. return 1;
  2942. }
  2943. #else
  2944. int negative = 0;
  2945. png_uint_32 A, T, D;
  2946. png_uint_32 s16, s32, s00;
  2947. if (a < 0)
  2948. negative = 1, A = -a;
  2949. else
  2950. A = a;
  2951. if (times < 0)
  2952. negative = !negative, T = -times;
  2953. else
  2954. T = times;
  2955. if (divisor < 0)
  2956. negative = !negative, D = -divisor;
  2957. else
  2958. D = divisor;
  2959. /* Following can't overflow because the arguments only
  2960. * have 31 bits each, however the result may be 32 bits.
  2961. */
  2962. s16 = (A >> 16) * (T & 0xffff) +
  2963. (A & 0xffff) * (T >> 16);
  2964. /* Can't overflow because the a*times bit is only 30
  2965. * bits at most.
  2966. */
  2967. s32 = (A >> 16) * (T >> 16) + (s16 >> 16);
  2968. s00 = (A & 0xffff) * (T & 0xffff);
  2969. s16 = (s16 & 0xffff) << 16;
  2970. s00 += s16;
  2971. if (s00 < s16)
  2972. ++s32; /* carry */
  2973. if (s32 < D) /* else overflow */
  2974. {
  2975. /* s32.s00 is now the 64-bit product, do a standard
  2976. * division, we know that s32 < D, so the maximum
  2977. * required shift is 31.
  2978. */
  2979. int bitshift = 32;
  2980. png_fixed_point result = 0; /* NOTE: signed */
  2981. while (--bitshift >= 0)
  2982. {
  2983. png_uint_32 d32, d00;
  2984. if (bitshift > 0)
  2985. d32 = D >> (32-bitshift), d00 = D << bitshift;
  2986. else
  2987. d32 = 0, d00 = D;
  2988. if (s32 > d32)
  2989. {
  2990. if (s00 < d00) --s32; /* carry */
  2991. s32 -= d32, s00 -= d00, result += 1<<bitshift;
  2992. }
  2993. else
  2994. if (s32 == d32 && s00 >= d00)
  2995. s32 = 0, s00 -= d00, result += 1<<bitshift;
  2996. }
  2997. /* Handle the rounding. */
  2998. if (s00 >= (D >> 1))
  2999. ++result;
  3000. if (negative != 0)
  3001. result = -result;
  3002. /* Check for overflow. */
  3003. if ((negative != 0 && result <= 0) ||
  3004. (negative == 0 && result >= 0))
  3005. {
  3006. *res = result;
  3007. return 1;
  3008. }
  3009. }
  3010. #endif
  3011. }
  3012. }
  3013. return 0;
  3014. }
  3015. #if GCC_STRICT_OVERFLOW
  3016. #pragma GCC diagnostic pop
  3017. #endif /* GCC_STRICT_OVERFLOW */
  3018. #endif /* READ_GAMMA || INCH_CONVERSIONS */
  3019. #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED)
  3020. /* The following is for when the caller doesn't much care about the
  3021. * result.
  3022. */
  3023. png_fixed_point
  3024. png_muldiv_warn(png_const_structrp png_ptr, png_fixed_point a, png_int_32 times,
  3025. png_int_32 divisor)
  3026. {
  3027. png_fixed_point result;
  3028. if (png_muldiv(&result, a, times, divisor) != 0)
  3029. return result;
  3030. png_warning(png_ptr, "fixed point overflow ignored");
  3031. return 0;
  3032. }
  3033. #endif
  3034. #ifdef PNG_GAMMA_SUPPORTED /* more fixed point functions for gamma */
  3035. /* Calculate a reciprocal, return 0 on div-by-zero or overflow. */
  3036. png_fixed_point
  3037. png_reciprocal(png_fixed_point a)
  3038. {
  3039. #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
  3040. double r = floor(1E10/a+.5);
  3041. if (r <= 2147483647. && r >= -2147483648.)
  3042. return (png_fixed_point)r;
  3043. #else
  3044. png_fixed_point res;
  3045. if (png_muldiv(&res, 100000, 100000, a) != 0)
  3046. return res;
  3047. #endif
  3048. return 0; /* error/overflow */
  3049. }
  3050. /* This is the shared test on whether a gamma value is 'significant' - whether
  3051. * it is worth doing gamma correction.
  3052. */
  3053. int /* PRIVATE */
  3054. png_gamma_significant(png_fixed_point gamma_val)
  3055. {
  3056. return gamma_val < PNG_FP_1 - PNG_GAMMA_THRESHOLD_FIXED ||
  3057. gamma_val > PNG_FP_1 + PNG_GAMMA_THRESHOLD_FIXED;
  3058. }
  3059. #endif
  3060. #ifdef PNG_READ_GAMMA_SUPPORTED
  3061. #ifdef PNG_16BIT_SUPPORTED
  3062. /* A local convenience routine. */
  3063. static png_fixed_point
  3064. png_product2(png_fixed_point a, png_fixed_point b)
  3065. {
  3066. /* The required result is 1/a * 1/b; the following preserves accuracy. */
  3067. #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
  3068. double r = a * 1E-5;
  3069. r *= b;
  3070. r = floor(r+.5);
  3071. if (r <= 2147483647. && r >= -2147483648.)
  3072. return (png_fixed_point)r;
  3073. #else
  3074. png_fixed_point res;
  3075. if (png_muldiv(&res, a, b, 100000) != 0)
  3076. return res;
  3077. #endif
  3078. return 0; /* overflow */
  3079. }
  3080. #endif /* 16BIT */
  3081. /* The inverse of the above. */
  3082. png_fixed_point
  3083. png_reciprocal2(png_fixed_point a, png_fixed_point b)
  3084. {
  3085. /* The required result is 1/a * 1/b; the following preserves accuracy. */
  3086. #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
  3087. if (a != 0 && b != 0)
  3088. {
  3089. double r = 1E15/a;
  3090. r /= b;
  3091. r = floor(r+.5);
  3092. if (r <= 2147483647. && r >= -2147483648.)
  3093. return (png_fixed_point)r;
  3094. }
  3095. #else
  3096. /* This may overflow because the range of png_fixed_point isn't symmetric,
  3097. * but this API is only used for the product of file and screen gamma so it
  3098. * doesn't matter that the smallest number it can produce is 1/21474, not
  3099. * 1/100000
  3100. */
  3101. png_fixed_point res = png_product2(a, b);
  3102. if (res != 0)
  3103. return png_reciprocal(res);
  3104. #endif
  3105. return 0; /* overflow */
  3106. }
  3107. #endif /* READ_GAMMA */
  3108. #ifdef PNG_READ_GAMMA_SUPPORTED /* gamma table code */
  3109. #ifndef PNG_FLOATING_ARITHMETIC_SUPPORTED
  3110. /* Fixed point gamma.
  3111. *
  3112. * The code to calculate the tables used below can be found in the shell script
  3113. * contrib/tools/intgamma.sh
  3114. *
  3115. * To calculate gamma this code implements fast log() and exp() calls using only
  3116. * fixed point arithmetic. This code has sufficient precision for either 8-bit
  3117. * or 16-bit sample values.
  3118. *
  3119. * The tables used here were calculated using simple 'bc' programs, but C double
  3120. * precision floating point arithmetic would work fine.
  3121. *
  3122. * 8-bit log table
  3123. * This is a table of -log(value/255)/log(2) for 'value' in the range 128 to
  3124. * 255, so it's the base 2 logarithm of a normalized 8-bit floating point
  3125. * mantissa. The numbers are 32-bit fractions.
  3126. */
  3127. static const png_uint_32
  3128. png_8bit_l2[128] =
  3129. {
  3130. 4270715492U, 4222494797U, 4174646467U, 4127164793U, 4080044201U, 4033279239U,
  3131. 3986864580U, 3940795015U, 3895065449U, 3849670902U, 3804606499U, 3759867474U,
  3132. 3715449162U, 3671346997U, 3627556511U, 3584073329U, 3540893168U, 3498011834U,
  3133. 3455425220U, 3413129301U, 3371120137U, 3329393864U, 3287946700U, 3246774933U,
  3134. 3205874930U, 3165243125U, 3124876025U, 3084770202U, 3044922296U, 3005329011U,
  3135. 2965987113U, 2926893432U, 2888044853U, 2849438323U, 2811070844U, 2772939474U,
  3136. 2735041326U, 2697373562U, 2659933400U, 2622718104U, 2585724991U, 2548951424U,
  3137. 2512394810U, 2476052606U, 2439922311U, 2404001468U, 2368287663U, 2332778523U,
  3138. 2297471715U, 2262364947U, 2227455964U, 2192742551U, 2158222529U, 2123893754U,
  3139. 2089754119U, 2055801552U, 2022034013U, 1988449497U, 1955046031U, 1921821672U,
  3140. 1888774511U, 1855902668U, 1823204291U, 1790677560U, 1758320682U, 1726131893U,
  3141. 1694109454U, 1662251657U, 1630556815U, 1599023271U, 1567649391U, 1536433567U,
  3142. 1505374214U, 1474469770U, 1443718700U, 1413119487U, 1382670639U, 1352370686U,
  3143. 1322218179U, 1292211689U, 1262349810U, 1232631153U, 1203054352U, 1173618059U,
  3144. 1144320946U, 1115161701U, 1086139034U, 1057251672U, 1028498358U, 999877854U,
  3145. 971388940U, 943030410U, 914801076U, 886699767U, 858725327U, 830876614U,
  3146. 803152505U, 775551890U, 748073672U, 720716771U, 693480120U, 666362667U,
  3147. 639363374U, 612481215U, 585715177U, 559064263U, 532527486U, 506103872U,
  3148. 479792461U, 453592303U, 427502463U, 401522014U, 375650043U, 349885648U,
  3149. 324227938U, 298676034U, 273229066U, 247886176U, 222646516U, 197509248U,
  3150. 172473545U, 147538590U, 122703574U, 97967701U, 73330182U, 48790236U,
  3151. 24347096U, 0U
  3152. #if 0
  3153. /* The following are the values for 16-bit tables - these work fine for the
  3154. * 8-bit conversions but produce very slightly larger errors in the 16-bit
  3155. * log (about 1.2 as opposed to 0.7 absolute error in the final value). To
  3156. * use these all the shifts below must be adjusted appropriately.
  3157. */
  3158. 65166, 64430, 63700, 62976, 62257, 61543, 60835, 60132, 59434, 58741, 58054,
  3159. 57371, 56693, 56020, 55352, 54689, 54030, 53375, 52726, 52080, 51439, 50803,
  3160. 50170, 49542, 48918, 48298, 47682, 47070, 46462, 45858, 45257, 44661, 44068,
  3161. 43479, 42894, 42312, 41733, 41159, 40587, 40020, 39455, 38894, 38336, 37782,
  3162. 37230, 36682, 36137, 35595, 35057, 34521, 33988, 33459, 32932, 32408, 31887,
  3163. 31369, 30854, 30341, 29832, 29325, 28820, 28319, 27820, 27324, 26830, 26339,
  3164. 25850, 25364, 24880, 24399, 23920, 23444, 22970, 22499, 22029, 21562, 21098,
  3165. 20636, 20175, 19718, 19262, 18808, 18357, 17908, 17461, 17016, 16573, 16132,
  3166. 15694, 15257, 14822, 14390, 13959, 13530, 13103, 12678, 12255, 11834, 11415,
  3167. 10997, 10582, 10168, 9756, 9346, 8937, 8531, 8126, 7723, 7321, 6921, 6523,
  3168. 6127, 5732, 5339, 4947, 4557, 4169, 3782, 3397, 3014, 2632, 2251, 1872, 1495,
  3169. 1119, 744, 372
  3170. #endif
  3171. };
  3172. static png_int_32
  3173. png_log8bit(unsigned int x)
  3174. {
  3175. unsigned int lg2 = 0;
  3176. /* Each time 'x' is multiplied by 2, 1 must be subtracted off the final log,
  3177. * because the log is actually negate that means adding 1. The final
  3178. * returned value thus has the range 0 (for 255 input) to 7.994 (for 1
  3179. * input), return -1 for the overflow (log 0) case, - so the result is
  3180. * always at most 19 bits.
  3181. */
  3182. if ((x &= 0xff) == 0)
  3183. return -1;
  3184. if ((x & 0xf0) == 0)
  3185. lg2 = 4, x <<= 4;
  3186. if ((x & 0xc0) == 0)
  3187. lg2 += 2, x <<= 2;
  3188. if ((x & 0x80) == 0)
  3189. lg2 += 1, x <<= 1;
  3190. /* result is at most 19 bits, so this cast is safe: */
  3191. return (png_int_32)((lg2 << 16) + ((png_8bit_l2[x-128]+32768)>>16));
  3192. }
  3193. /* The above gives exact (to 16 binary places) log2 values for 8-bit images,
  3194. * for 16-bit images we use the most significant 8 bits of the 16-bit value to
  3195. * get an approximation then multiply the approximation by a correction factor
  3196. * determined by the remaining up to 8 bits. This requires an additional step
  3197. * in the 16-bit case.
  3198. *
  3199. * We want log2(value/65535), we have log2(v'/255), where:
  3200. *
  3201. * value = v' * 256 + v''
  3202. * = v' * f
  3203. *
  3204. * So f is value/v', which is equal to (256+v''/v') since v' is in the range 128
  3205. * to 255 and v'' is in the range 0 to 255 f will be in the range 256 to less
  3206. * than 258. The final factor also needs to correct for the fact that our 8-bit
  3207. * value is scaled by 255, whereas the 16-bit values must be scaled by 65535.
  3208. *
  3209. * This gives a final formula using a calculated value 'x' which is value/v' and
  3210. * scaling by 65536 to match the above table:
  3211. *
  3212. * log2(x/257) * 65536
  3213. *
  3214. * Since these numbers are so close to '1' we can use simple linear
  3215. * interpolation between the two end values 256/257 (result -368.61) and 258/257
  3216. * (result 367.179). The values used below are scaled by a further 64 to give
  3217. * 16-bit precision in the interpolation:
  3218. *
  3219. * Start (256): -23591
  3220. * Zero (257): 0
  3221. * End (258): 23499
  3222. */
  3223. #ifdef PNG_16BIT_SUPPORTED
  3224. static png_int_32
  3225. png_log16bit(png_uint_32 x)
  3226. {
  3227. unsigned int lg2 = 0;
  3228. /* As above, but now the input has 16 bits. */
  3229. if ((x &= 0xffff) == 0)
  3230. return -1;
  3231. if ((x & 0xff00) == 0)
  3232. lg2 = 8, x <<= 8;
  3233. if ((x & 0xf000) == 0)
  3234. lg2 += 4, x <<= 4;
  3235. if ((x & 0xc000) == 0)
  3236. lg2 += 2, x <<= 2;
  3237. if ((x & 0x8000) == 0)
  3238. lg2 += 1, x <<= 1;
  3239. /* Calculate the base logarithm from the top 8 bits as a 28-bit fractional
  3240. * value.
  3241. */
  3242. lg2 <<= 28;
  3243. lg2 += (png_8bit_l2[(x>>8)-128]+8) >> 4;
  3244. /* Now we need to interpolate the factor, this requires a division by the top
  3245. * 8 bits. Do this with maximum precision.
  3246. */
  3247. x = ((x << 16) + (x >> 9)) / (x >> 8);
  3248. /* Since we divided by the top 8 bits of 'x' there will be a '1' at 1<<24,
  3249. * the value at 1<<16 (ignoring this) will be 0 or 1; this gives us exactly
  3250. * 16 bits to interpolate to get the low bits of the result. Round the
  3251. * answer. Note that the end point values are scaled by 64 to retain overall
  3252. * precision and that 'lg2' is current scaled by an extra 12 bits, so adjust
  3253. * the overall scaling by 6-12. Round at every step.
  3254. */
  3255. x -= 1U << 24;
  3256. if (x <= 65536U) /* <= '257' */
  3257. lg2 += ((23591U * (65536U-x)) + (1U << (16+6-12-1))) >> (16+6-12);
  3258. else
  3259. lg2 -= ((23499U * (x-65536U)) + (1U << (16+6-12-1))) >> (16+6-12);
  3260. /* Safe, because the result can't have more than 20 bits: */
  3261. return (png_int_32)((lg2 + 2048) >> 12);
  3262. }
  3263. #endif /* 16BIT */
  3264. /* The 'exp()' case must invert the above, taking a 20-bit fixed point
  3265. * logarithmic value and returning a 16 or 8-bit number as appropriate. In
  3266. * each case only the low 16 bits are relevant - the fraction - since the
  3267. * integer bits (the top 4) simply determine a shift.
  3268. *
  3269. * The worst case is the 16-bit distinction between 65535 and 65534. This
  3270. * requires perhaps spurious accuracy in the decoding of the logarithm to
  3271. * distinguish log2(65535/65534.5) - 10^-5 or 17 bits. There is little chance
  3272. * of getting this accuracy in practice.
  3273. *
  3274. * To deal with this the following exp() function works out the exponent of the
  3275. * fractional part of the logarithm by using an accurate 32-bit value from the
  3276. * top four fractional bits then multiplying in the remaining bits.
  3277. */
  3278. static const png_uint_32
  3279. png_32bit_exp[16] =
  3280. {
  3281. /* NOTE: the first entry is deliberately set to the maximum 32-bit value. */
  3282. 4294967295U, 4112874773U, 3938502376U, 3771522796U, 3611622603U, 3458501653U,
  3283. 3311872529U, 3171459999U, 3037000500U, 2908241642U, 2784941738U, 2666869345U,
  3284. 2553802834U, 2445529972U, 2341847524U, 2242560872U
  3285. };
  3286. /* Adjustment table; provided to explain the numbers in the code below. */
  3287. #if 0
  3288. for (i=11;i>=0;--i){ print i, " ", (1 - e(-(2^i)/65536*l(2))) * 2^(32-i), "\n"}
  3289. 11 44937.64284865548751208448
  3290. 10 45180.98734845585101160448
  3291. 9 45303.31936980687359311872
  3292. 8 45364.65110595323018870784
  3293. 7 45395.35850361789624614912
  3294. 6 45410.72259715102037508096
  3295. 5 45418.40724413220722311168
  3296. 4 45422.25021786898173001728
  3297. 3 45424.17186732298419044352
  3298. 2 45425.13273269940811464704
  3299. 1 45425.61317555035558641664
  3300. 0 45425.85339951654943850496
  3301. #endif
  3302. static png_uint_32
  3303. png_exp(png_fixed_point x)
  3304. {
  3305. if (x > 0 && x <= 0xfffff) /* Else overflow or zero (underflow) */
  3306. {
  3307. /* Obtain a 4-bit approximation */
  3308. png_uint_32 e = png_32bit_exp[(x >> 12) & 0x0f];
  3309. /* Incorporate the low 12 bits - these decrease the returned value by
  3310. * multiplying by a number less than 1 if the bit is set. The multiplier
  3311. * is determined by the above table and the shift. Notice that the values
  3312. * converge on 45426 and this is used to allow linear interpolation of the
  3313. * low bits.
  3314. */
  3315. if (x & 0x800)
  3316. e -= (((e >> 16) * 44938U) + 16U) >> 5;
  3317. if (x & 0x400)
  3318. e -= (((e >> 16) * 45181U) + 32U) >> 6;
  3319. if (x & 0x200)
  3320. e -= (((e >> 16) * 45303U) + 64U) >> 7;
  3321. if (x & 0x100)
  3322. e -= (((e >> 16) * 45365U) + 128U) >> 8;
  3323. if (x & 0x080)
  3324. e -= (((e >> 16) * 45395U) + 256U) >> 9;
  3325. if (x & 0x040)
  3326. e -= (((e >> 16) * 45410U) + 512U) >> 10;
  3327. /* And handle the low 6 bits in a single block. */
  3328. e -= (((e >> 16) * 355U * (x & 0x3fU)) + 256U) >> 9;
  3329. /* Handle the upper bits of x. */
  3330. e >>= x >> 16;
  3331. return e;
  3332. }
  3333. /* Check for overflow */
  3334. if (x <= 0)
  3335. return png_32bit_exp[0];
  3336. /* Else underflow */
  3337. return 0;
  3338. }
  3339. static png_byte
  3340. png_exp8bit(png_fixed_point lg2)
  3341. {
  3342. /* Get a 32-bit value: */
  3343. png_uint_32 x = png_exp(lg2);
  3344. /* Convert the 32-bit value to 0..255 by multiplying by 256-1. Note that the
  3345. * second, rounding, step can't overflow because of the first, subtraction,
  3346. * step.
  3347. */
  3348. x -= x >> 8;
  3349. return (png_byte)(((x + 0x7fffffU) >> 24) & 0xff);
  3350. }
  3351. #ifdef PNG_16BIT_SUPPORTED
  3352. static png_uint_16
  3353. png_exp16bit(png_fixed_point lg2)
  3354. {
  3355. /* Get a 32-bit value: */
  3356. png_uint_32 x = png_exp(lg2);
  3357. /* Convert the 32-bit value to 0..65535 by multiplying by 65536-1: */
  3358. x -= x >> 16;
  3359. return (png_uint_16)((x + 32767U) >> 16);
  3360. }
  3361. #endif /* 16BIT */
  3362. #endif /* FLOATING_ARITHMETIC */
  3363. png_byte
  3364. png_gamma_8bit_correct(unsigned int value, png_fixed_point gamma_val)
  3365. {
  3366. if (value > 0 && value < 255)
  3367. {
  3368. # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
  3369. /* 'value' is unsigned, ANSI-C90 requires the compiler to correctly
  3370. * convert this to a floating point value. This includes values that
  3371. * would overflow if 'value' were to be converted to 'int'.
  3372. *
  3373. * Apparently GCC, however, does an intermediate conversion to (int)
  3374. * on some (ARM) but not all (x86) platforms, possibly because of
  3375. * hardware FP limitations. (E.g. if the hardware conversion always
  3376. * assumes the integer register contains a signed value.) This results
  3377. * in ANSI-C undefined behavior for large values.
  3378. *
  3379. * Other implementations on the same machine might actually be ANSI-C90
  3380. * conformant and therefore compile spurious extra code for the large
  3381. * values.
  3382. *
  3383. * We can be reasonably sure that an unsigned to float conversion
  3384. * won't be faster than an int to float one. Therefore this code
  3385. * assumes responsibility for the undefined behavior, which it knows
  3386. * can't happen because of the check above.
  3387. *
  3388. * Note the argument to this routine is an (unsigned int) because, on
  3389. * 16-bit platforms, it is assigned a value which might be out of
  3390. * range for an (int); that would result in undefined behavior in the
  3391. * caller if the *argument* ('value') were to be declared (int).
  3392. */
  3393. double r = floor(255*pow((int)/*SAFE*/value/255.,gamma_val*.00001)+.5);
  3394. return (png_byte)r;
  3395. # else
  3396. png_int_32 lg2 = png_log8bit(value);
  3397. png_fixed_point res;
  3398. if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1) != 0)
  3399. return png_exp8bit(res);
  3400. /* Overflow. */
  3401. value = 0;
  3402. # endif
  3403. }
  3404. return (png_byte)(value & 0xff);
  3405. }
  3406. #ifdef PNG_16BIT_SUPPORTED
  3407. png_uint_16
  3408. png_gamma_16bit_correct(unsigned int value, png_fixed_point gamma_val)
  3409. {
  3410. if (value > 0 && value < 65535)
  3411. {
  3412. # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
  3413. /* The same (unsigned int)->(double) constraints apply here as above,
  3414. * however in this case the (unsigned int) to (int) conversion can
  3415. * overflow on an ANSI-C90 compliant system so the cast needs to ensure
  3416. * that this is not possible.
  3417. */
  3418. double r = floor(65535*pow((png_int_32)value/65535.,
  3419. gamma_val*.00001)+.5);
  3420. return (png_uint_16)r;
  3421. # else
  3422. png_int_32 lg2 = png_log16bit(value);
  3423. png_fixed_point res;
  3424. if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1) != 0)
  3425. return png_exp16bit(res);
  3426. /* Overflow. */
  3427. value = 0;
  3428. # endif
  3429. }
  3430. return (png_uint_16)value;
  3431. }
  3432. #endif /* 16BIT */
  3433. /* This does the right thing based on the bit_depth field of the
  3434. * png_struct, interpreting values as 8-bit or 16-bit. While the result
  3435. * is nominally a 16-bit value if bit depth is 8 then the result is
  3436. * 8-bit (as are the arguments.)
  3437. */
  3438. png_uint_16 /* PRIVATE */
  3439. png_gamma_correct(png_structrp png_ptr, unsigned int value,
  3440. png_fixed_point gamma_val)
  3441. {
  3442. if (png_ptr->bit_depth == 8)
  3443. return png_gamma_8bit_correct(value, gamma_val);
  3444. #ifdef PNG_16BIT_SUPPORTED
  3445. else
  3446. return png_gamma_16bit_correct(value, gamma_val);
  3447. #else
  3448. /* should not reach this */
  3449. return 0;
  3450. #endif /* 16BIT */
  3451. }
  3452. #ifdef PNG_16BIT_SUPPORTED
  3453. /* Internal function to build a single 16-bit table - the table consists of
  3454. * 'num' 256 entry subtables, where 'num' is determined by 'shift' - the amount
  3455. * to shift the input values right (or 16-number_of_signifiant_bits).
  3456. *
  3457. * The caller is responsible for ensuring that the table gets cleaned up on
  3458. * png_error (i.e. if one of the mallocs below fails) - i.e. the *table argument
  3459. * should be somewhere that will be cleaned.
  3460. */
  3461. static void
  3462. png_build_16bit_table(png_structrp png_ptr, png_uint_16pp *ptable,
  3463. PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val)
  3464. {
  3465. /* Various values derived from 'shift': */
  3466. PNG_CONST unsigned int num = 1U << (8U - shift);
  3467. #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
  3468. /* CSE the division and work round wacky GCC warnings (see the comments
  3469. * in png_gamma_8bit_correct for where these come from.)
  3470. */
  3471. PNG_CONST double fmax = 1./(((png_int_32)1 << (16U - shift))-1);
  3472. #endif
  3473. PNG_CONST unsigned int max = (1U << (16U - shift))-1U;
  3474. PNG_CONST unsigned int max_by_2 = 1U << (15U-shift);
  3475. unsigned int i;
  3476. png_uint_16pp table = *ptable =
  3477. (png_uint_16pp)png_calloc(png_ptr, num * (sizeof (png_uint_16p)));
  3478. for (i = 0; i < num; i++)
  3479. {
  3480. png_uint_16p sub_table = table[i] =
  3481. (png_uint_16p)png_malloc(png_ptr, 256 * (sizeof (png_uint_16)));
  3482. /* The 'threshold' test is repeated here because it can arise for one of
  3483. * the 16-bit tables even if the others don't hit it.
  3484. */
  3485. if (png_gamma_significant(gamma_val) != 0)
  3486. {
  3487. /* The old code would overflow at the end and this would cause the
  3488. * 'pow' function to return a result >1, resulting in an
  3489. * arithmetic error. This code follows the spec exactly; ig is
  3490. * the recovered input sample, it always has 8-16 bits.
  3491. *
  3492. * We want input * 65535/max, rounded, the arithmetic fits in 32
  3493. * bits (unsigned) so long as max <= 32767.
  3494. */
  3495. unsigned int j;
  3496. for (j = 0; j < 256; j++)
  3497. {
  3498. png_uint_32 ig = (j << (8-shift)) + i;
  3499. # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
  3500. /* Inline the 'max' scaling operation: */
  3501. /* See png_gamma_8bit_correct for why the cast to (int) is
  3502. * required here.
  3503. */
  3504. double d = floor(65535.*pow(ig*fmax, gamma_val*.00001)+.5);
  3505. sub_table[j] = (png_uint_16)d;
  3506. # else
  3507. if (shift != 0)
  3508. ig = (ig * 65535U + max_by_2)/max;
  3509. sub_table[j] = png_gamma_16bit_correct(ig, gamma_val);
  3510. # endif
  3511. }
  3512. }
  3513. else
  3514. {
  3515. /* We must still build a table, but do it the fast way. */
  3516. unsigned int j;
  3517. for (j = 0; j < 256; j++)
  3518. {
  3519. png_uint_32 ig = (j << (8-shift)) + i;
  3520. if (shift != 0)
  3521. ig = (ig * 65535U + max_by_2)/max;
  3522. sub_table[j] = (png_uint_16)ig;
  3523. }
  3524. }
  3525. }
  3526. }
  3527. /* NOTE: this function expects the *inverse* of the overall gamma transformation
  3528. * required.
  3529. */
  3530. static void
  3531. png_build_16to8_table(png_structrp png_ptr, png_uint_16pp *ptable,
  3532. PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val)
  3533. {
  3534. PNG_CONST unsigned int num = 1U << (8U - shift);
  3535. PNG_CONST unsigned int max = (1U << (16U - shift))-1U;
  3536. unsigned int i;
  3537. png_uint_32 last;
  3538. png_uint_16pp table = *ptable =
  3539. (png_uint_16pp)png_calloc(png_ptr, num * (sizeof (png_uint_16p)));
  3540. /* 'num' is the number of tables and also the number of low bits of low
  3541. * bits of the input 16-bit value used to select a table. Each table is
  3542. * itself indexed by the high 8 bits of the value.
  3543. */
  3544. for (i = 0; i < num; i++)
  3545. table[i] = (png_uint_16p)png_malloc(png_ptr,
  3546. 256 * (sizeof (png_uint_16)));
  3547. /* 'gamma_val' is set to the reciprocal of the value calculated above, so
  3548. * pow(out,g) is an *input* value. 'last' is the last input value set.
  3549. *
  3550. * In the loop 'i' is used to find output values. Since the output is
  3551. * 8-bit there are only 256 possible values. The tables are set up to
  3552. * select the closest possible output value for each input by finding
  3553. * the input value at the boundary between each pair of output values
  3554. * and filling the table up to that boundary with the lower output
  3555. * value.
  3556. *
  3557. * The boundary values are 0.5,1.5..253.5,254.5. Since these are 9-bit
  3558. * values the code below uses a 16-bit value in i; the values start at
  3559. * 128.5 (for 0.5) and step by 257, for a total of 254 values (the last
  3560. * entries are filled with 255). Start i at 128 and fill all 'last'
  3561. * table entries <= 'max'
  3562. */
  3563. last = 0;
  3564. for (i = 0; i < 255; ++i) /* 8-bit output value */
  3565. {
  3566. /* Find the corresponding maximum input value */
  3567. png_uint_16 out = (png_uint_16)(i * 257U); /* 16-bit output value */
  3568. /* Find the boundary value in 16 bits: */
  3569. png_uint_32 bound = png_gamma_16bit_correct(out+128U, gamma_val);
  3570. /* Adjust (round) to (16-shift) bits: */
  3571. bound = (bound * max + 32768U)/65535U + 1U;
  3572. while (last < bound)
  3573. {
  3574. table[last & (0xffU >> shift)][last >> (8U - shift)] = out;
  3575. last++;
  3576. }
  3577. }
  3578. /* And fill in the final entries. */
  3579. while (last < (num << 8))
  3580. {
  3581. table[last & (0xff >> shift)][last >> (8U - shift)] = 65535U;
  3582. last++;
  3583. }
  3584. }
  3585. #endif /* 16BIT */
  3586. /* Build a single 8-bit table: same as the 16-bit case but much simpler (and
  3587. * typically much faster). Note that libpng currently does no sBIT processing
  3588. * (apparently contrary to the spec) so a 256-entry table is always generated.
  3589. */
  3590. static void
  3591. png_build_8bit_table(png_structrp png_ptr, png_bytepp ptable,
  3592. PNG_CONST png_fixed_point gamma_val)
  3593. {
  3594. unsigned int i;
  3595. png_bytep table = *ptable = (png_bytep)png_malloc(png_ptr, 256);
  3596. if (png_gamma_significant(gamma_val) != 0)
  3597. for (i=0; i<256; i++)
  3598. table[i] = png_gamma_8bit_correct(i, gamma_val);
  3599. else
  3600. for (i=0; i<256; ++i)
  3601. table[i] = (png_byte)(i & 0xff);
  3602. }
  3603. /* Used from png_read_destroy and below to release the memory used by the gamma
  3604. * tables.
  3605. */
  3606. void /* PRIVATE */
  3607. png_destroy_gamma_table(png_structrp png_ptr)
  3608. {
  3609. png_free(png_ptr, png_ptr->gamma_table);
  3610. png_ptr->gamma_table = NULL;
  3611. #ifdef PNG_16BIT_SUPPORTED
  3612. if (png_ptr->gamma_16_table != NULL)
  3613. {
  3614. int i;
  3615. int istop = (1 << (8 - png_ptr->gamma_shift));
  3616. for (i = 0; i < istop; i++)
  3617. {
  3618. png_free(png_ptr, png_ptr->gamma_16_table[i]);
  3619. }
  3620. png_free(png_ptr, png_ptr->gamma_16_table);
  3621. png_ptr->gamma_16_table = NULL;
  3622. }
  3623. #endif /* 16BIT */
  3624. #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
  3625. defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
  3626. defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
  3627. png_free(png_ptr, png_ptr->gamma_from_1);
  3628. png_ptr->gamma_from_1 = NULL;
  3629. png_free(png_ptr, png_ptr->gamma_to_1);
  3630. png_ptr->gamma_to_1 = NULL;
  3631. #ifdef PNG_16BIT_SUPPORTED
  3632. if (png_ptr->gamma_16_from_1 != NULL)
  3633. {
  3634. int i;
  3635. int istop = (1 << (8 - png_ptr->gamma_shift));
  3636. for (i = 0; i < istop; i++)
  3637. {
  3638. png_free(png_ptr, png_ptr->gamma_16_from_1[i]);
  3639. }
  3640. png_free(png_ptr, png_ptr->gamma_16_from_1);
  3641. png_ptr->gamma_16_from_1 = NULL;
  3642. }
  3643. if (png_ptr->gamma_16_to_1 != NULL)
  3644. {
  3645. int i;
  3646. int istop = (1 << (8 - png_ptr->gamma_shift));
  3647. for (i = 0; i < istop; i++)
  3648. {
  3649. png_free(png_ptr, png_ptr->gamma_16_to_1[i]);
  3650. }
  3651. png_free(png_ptr, png_ptr->gamma_16_to_1);
  3652. png_ptr->gamma_16_to_1 = NULL;
  3653. }
  3654. #endif /* 16BIT */
  3655. #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
  3656. }
  3657. /* We build the 8- or 16-bit gamma tables here. Note that for 16-bit
  3658. * tables, we don't make a full table if we are reducing to 8-bit in
  3659. * the future. Note also how the gamma_16 tables are segmented so that
  3660. * we don't need to allocate > 64K chunks for a full 16-bit table.
  3661. */
  3662. void /* PRIVATE */
  3663. png_build_gamma_table(png_structrp png_ptr, int bit_depth)
  3664. {
  3665. png_debug(1, "in png_build_gamma_table");
  3666. /* Remove any existing table; this copes with multiple calls to
  3667. * png_read_update_info. The warning is because building the gamma tables
  3668. * multiple times is a performance hit - it's harmless but the ability to
  3669. * call png_read_update_info() multiple times is new in 1.5.6 so it seems
  3670. * sensible to warn if the app introduces such a hit.
  3671. */
  3672. if (png_ptr->gamma_table != NULL || png_ptr->gamma_16_table != NULL)
  3673. {
  3674. png_warning(png_ptr, "gamma table being rebuilt");
  3675. png_destroy_gamma_table(png_ptr);
  3676. }
  3677. if (bit_depth <= 8)
  3678. {
  3679. png_build_8bit_table(png_ptr, &png_ptr->gamma_table,
  3680. png_ptr->screen_gamma > 0 ?
  3681. png_reciprocal2(png_ptr->colorspace.gamma,
  3682. png_ptr->screen_gamma) : PNG_FP_1);
  3683. #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
  3684. defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
  3685. defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
  3686. if ((png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) != 0)
  3687. {
  3688. png_build_8bit_table(png_ptr, &png_ptr->gamma_to_1,
  3689. png_reciprocal(png_ptr->colorspace.gamma));
  3690. png_build_8bit_table(png_ptr, &png_ptr->gamma_from_1,
  3691. png_ptr->screen_gamma > 0 ?
  3692. png_reciprocal(png_ptr->screen_gamma) :
  3693. png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */);
  3694. }
  3695. #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
  3696. }
  3697. #ifdef PNG_16BIT_SUPPORTED
  3698. else
  3699. {
  3700. png_byte shift, sig_bit;
  3701. if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
  3702. {
  3703. sig_bit = png_ptr->sig_bit.red;
  3704. if (png_ptr->sig_bit.green > sig_bit)
  3705. sig_bit = png_ptr->sig_bit.green;
  3706. if (png_ptr->sig_bit.blue > sig_bit)
  3707. sig_bit = png_ptr->sig_bit.blue;
  3708. }
  3709. else
  3710. sig_bit = png_ptr->sig_bit.gray;
  3711. /* 16-bit gamma code uses this equation:
  3712. *
  3713. * ov = table[(iv & 0xff) >> gamma_shift][iv >> 8]
  3714. *
  3715. * Where 'iv' is the input color value and 'ov' is the output value -
  3716. * pow(iv, gamma).
  3717. *
  3718. * Thus the gamma table consists of up to 256 256-entry tables. The table
  3719. * is selected by the (8-gamma_shift) most significant of the low 8 bits
  3720. * of the color value then indexed by the upper 8 bits:
  3721. *
  3722. * table[low bits][high 8 bits]
  3723. *
  3724. * So the table 'n' corresponds to all those 'iv' of:
  3725. *
  3726. * <all high 8-bit values><n << gamma_shift>..<(n+1 << gamma_shift)-1>
  3727. *
  3728. */
  3729. if (sig_bit > 0 && sig_bit < 16U)
  3730. /* shift == insignificant bits */
  3731. shift = (png_byte)((16U - sig_bit) & 0xff);
  3732. else
  3733. shift = 0; /* keep all 16 bits */
  3734. if ((png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8)) != 0)
  3735. {
  3736. /* PNG_MAX_GAMMA_8 is the number of bits to keep - effectively
  3737. * the significant bits in the *input* when the output will
  3738. * eventually be 8 bits. By default it is 11.
  3739. */
  3740. if (shift < (16U - PNG_MAX_GAMMA_8))
  3741. shift = (16U - PNG_MAX_GAMMA_8);
  3742. }
  3743. if (shift > 8U)
  3744. shift = 8U; /* Guarantees at least one table! */
  3745. png_ptr->gamma_shift = shift;
  3746. /* NOTE: prior to 1.5.4 this test used to include PNG_BACKGROUND (now
  3747. * PNG_COMPOSE). This effectively smashed the background calculation for
  3748. * 16-bit output because the 8-bit table assumes the result will be
  3749. * reduced to 8 bits.
  3750. */
  3751. if ((png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8)) != 0)
  3752. png_build_16to8_table(png_ptr, &png_ptr->gamma_16_table, shift,
  3753. png_ptr->screen_gamma > 0 ? png_product2(png_ptr->colorspace.gamma,
  3754. png_ptr->screen_gamma) : PNG_FP_1);
  3755. else
  3756. png_build_16bit_table(png_ptr, &png_ptr->gamma_16_table, shift,
  3757. png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->colorspace.gamma,
  3758. png_ptr->screen_gamma) : PNG_FP_1);
  3759. #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
  3760. defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
  3761. defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
  3762. if ((png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) != 0)
  3763. {
  3764. png_build_16bit_table(png_ptr, &png_ptr->gamma_16_to_1, shift,
  3765. png_reciprocal(png_ptr->colorspace.gamma));
  3766. /* Notice that the '16 from 1' table should be full precision, however
  3767. * the lookup on this table still uses gamma_shift, so it can't be.
  3768. * TODO: fix this.
  3769. */
  3770. png_build_16bit_table(png_ptr, &png_ptr->gamma_16_from_1, shift,
  3771. png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) :
  3772. png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */);
  3773. }
  3774. #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
  3775. }
  3776. #endif /* 16BIT */
  3777. }
  3778. #endif /* READ_GAMMA */
  3779. /* HARDWARE OR SOFTWARE OPTION SUPPORT */
  3780. #ifdef PNG_SET_OPTION_SUPPORTED
  3781. int PNGAPI
  3782. png_set_option(png_structrp png_ptr, int option, int onoff)
  3783. {
  3784. if (png_ptr != NULL && option >= 0 && option < PNG_OPTION_NEXT &&
  3785. (option & 1) == 0)
  3786. {
  3787. png_uint_32 mask = 3U << option;
  3788. png_uint_32 setting = (2U + (onoff != 0)) << option;
  3789. png_uint_32 current = png_ptr->options;
  3790. png_ptr->options = (png_uint_32)(((current & ~mask) | setting) & 0xff);
  3791. return (int)(current & mask) >> option;
  3792. }
  3793. return PNG_OPTION_INVALID;
  3794. }
  3795. #endif
  3796. /* sRGB support */
  3797. #if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
  3798. defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
  3799. /* sRGB conversion tables; these are machine generated with the code in
  3800. * contrib/tools/makesRGB.c. The actual sRGB transfer curve defined in the
  3801. * specification (see the article at https://en.wikipedia.org/wiki/SRGB)
  3802. * is used, not the gamma=1/2.2 approximation use elsewhere in libpng.
  3803. * The sRGB to linear table is exact (to the nearest 16-bit linear fraction).
  3804. * The inverse (linear to sRGB) table has accuracies as follows:
  3805. *
  3806. * For all possible (255*65535+1) input values:
  3807. *
  3808. * error: -0.515566 - 0.625971, 79441 (0.475369%) of readings inexact
  3809. *
  3810. * For the input values corresponding to the 65536 16-bit values:
  3811. *
  3812. * error: -0.513727 - 0.607759, 308 (0.469978%) of readings inexact
  3813. *
  3814. * In all cases the inexact readings are only off by one.
  3815. */
  3816. #ifdef PNG_SIMPLIFIED_READ_SUPPORTED
  3817. /* The convert-to-sRGB table is only currently required for read. */
  3818. const png_uint_16 png_sRGB_table[256] =
  3819. {
  3820. 0,20,40,60,80,99,119,139,
  3821. 159,179,199,219,241,264,288,313,
  3822. 340,367,396,427,458,491,526,562,
  3823. 599,637,677,718,761,805,851,898,
  3824. 947,997,1048,1101,1156,1212,1270,1330,
  3825. 1391,1453,1517,1583,1651,1720,1790,1863,
  3826. 1937,2013,2090,2170,2250,2333,2418,2504,
  3827. 2592,2681,2773,2866,2961,3058,3157,3258,
  3828. 3360,3464,3570,3678,3788,3900,4014,4129,
  3829. 4247,4366,4488,4611,4736,4864,4993,5124,
  3830. 5257,5392,5530,5669,5810,5953,6099,6246,
  3831. 6395,6547,6700,6856,7014,7174,7335,7500,
  3832. 7666,7834,8004,8177,8352,8528,8708,8889,
  3833. 9072,9258,9445,9635,9828,10022,10219,10417,
  3834. 10619,10822,11028,11235,11446,11658,11873,12090,
  3835. 12309,12530,12754,12980,13209,13440,13673,13909,
  3836. 14146,14387,14629,14874,15122,15371,15623,15878,
  3837. 16135,16394,16656,16920,17187,17456,17727,18001,
  3838. 18277,18556,18837,19121,19407,19696,19987,20281,
  3839. 20577,20876,21177,21481,21787,22096,22407,22721,
  3840. 23038,23357,23678,24002,24329,24658,24990,25325,
  3841. 25662,26001,26344,26688,27036,27386,27739,28094,
  3842. 28452,28813,29176,29542,29911,30282,30656,31033,
  3843. 31412,31794,32179,32567,32957,33350,33745,34143,
  3844. 34544,34948,35355,35764,36176,36591,37008,37429,
  3845. 37852,38278,38706,39138,39572,40009,40449,40891,
  3846. 41337,41785,42236,42690,43147,43606,44069,44534,
  3847. 45002,45473,45947,46423,46903,47385,47871,48359,
  3848. 48850,49344,49841,50341,50844,51349,51858,52369,
  3849. 52884,53401,53921,54445,54971,55500,56032,56567,
  3850. 57105,57646,58190,58737,59287,59840,60396,60955,
  3851. 61517,62082,62650,63221,63795,64372,64952,65535
  3852. };
  3853. #endif /* SIMPLIFIED_READ */
  3854. /* The base/delta tables are required for both read and write (but currently
  3855. * only the simplified versions.)
  3856. */
  3857. const png_uint_16 png_sRGB_base[512] =
  3858. {
  3859. 128,1782,3383,4644,5675,6564,7357,8074,
  3860. 8732,9346,9921,10463,10977,11466,11935,12384,
  3861. 12816,13233,13634,14024,14402,14769,15125,15473,
  3862. 15812,16142,16466,16781,17090,17393,17690,17981,
  3863. 18266,18546,18822,19093,19359,19621,19879,20133,
  3864. 20383,20630,20873,21113,21349,21583,21813,22041,
  3865. 22265,22487,22707,22923,23138,23350,23559,23767,
  3866. 23972,24175,24376,24575,24772,24967,25160,25352,
  3867. 25542,25730,25916,26101,26284,26465,26645,26823,
  3868. 27000,27176,27350,27523,27695,27865,28034,28201,
  3869. 28368,28533,28697,28860,29021,29182,29341,29500,
  3870. 29657,29813,29969,30123,30276,30429,30580,30730,
  3871. 30880,31028,31176,31323,31469,31614,31758,31902,
  3872. 32045,32186,32327,32468,32607,32746,32884,33021,
  3873. 33158,33294,33429,33564,33697,33831,33963,34095,
  3874. 34226,34357,34486,34616,34744,34873,35000,35127,
  3875. 35253,35379,35504,35629,35753,35876,35999,36122,
  3876. 36244,36365,36486,36606,36726,36845,36964,37083,
  3877. 37201,37318,37435,37551,37668,37783,37898,38013,
  3878. 38127,38241,38354,38467,38580,38692,38803,38915,
  3879. 39026,39136,39246,39356,39465,39574,39682,39790,
  3880. 39898,40005,40112,40219,40325,40431,40537,40642,
  3881. 40747,40851,40955,41059,41163,41266,41369,41471,
  3882. 41573,41675,41777,41878,41979,42079,42179,42279,
  3883. 42379,42478,42577,42676,42775,42873,42971,43068,
  3884. 43165,43262,43359,43456,43552,43648,43743,43839,
  3885. 43934,44028,44123,44217,44311,44405,44499,44592,
  3886. 44685,44778,44870,44962,45054,45146,45238,45329,
  3887. 45420,45511,45601,45692,45782,45872,45961,46051,
  3888. 46140,46229,46318,46406,46494,46583,46670,46758,
  3889. 46846,46933,47020,47107,47193,47280,47366,47452,
  3890. 47538,47623,47709,47794,47879,47964,48048,48133,
  3891. 48217,48301,48385,48468,48552,48635,48718,48801,
  3892. 48884,48966,49048,49131,49213,49294,49376,49458,
  3893. 49539,49620,49701,49782,49862,49943,50023,50103,
  3894. 50183,50263,50342,50422,50501,50580,50659,50738,
  3895. 50816,50895,50973,51051,51129,51207,51285,51362,
  3896. 51439,51517,51594,51671,51747,51824,51900,51977,
  3897. 52053,52129,52205,52280,52356,52432,52507,52582,
  3898. 52657,52732,52807,52881,52956,53030,53104,53178,
  3899. 53252,53326,53400,53473,53546,53620,53693,53766,
  3900. 53839,53911,53984,54056,54129,54201,54273,54345,
  3901. 54417,54489,54560,54632,54703,54774,54845,54916,
  3902. 54987,55058,55129,55199,55269,55340,55410,55480,
  3903. 55550,55620,55689,55759,55828,55898,55967,56036,
  3904. 56105,56174,56243,56311,56380,56448,56517,56585,
  3905. 56653,56721,56789,56857,56924,56992,57059,57127,
  3906. 57194,57261,57328,57395,57462,57529,57595,57662,
  3907. 57728,57795,57861,57927,57993,58059,58125,58191,
  3908. 58256,58322,58387,58453,58518,58583,58648,58713,
  3909. 58778,58843,58908,58972,59037,59101,59165,59230,
  3910. 59294,59358,59422,59486,59549,59613,59677,59740,
  3911. 59804,59867,59930,59993,60056,60119,60182,60245,
  3912. 60308,60370,60433,60495,60558,60620,60682,60744,
  3913. 60806,60868,60930,60992,61054,61115,61177,61238,
  3914. 61300,61361,61422,61483,61544,61605,61666,61727,
  3915. 61788,61848,61909,61969,62030,62090,62150,62211,
  3916. 62271,62331,62391,62450,62510,62570,62630,62689,
  3917. 62749,62808,62867,62927,62986,63045,63104,63163,
  3918. 63222,63281,63340,63398,63457,63515,63574,63632,
  3919. 63691,63749,63807,63865,63923,63981,64039,64097,
  3920. 64155,64212,64270,64328,64385,64443,64500,64557,
  3921. 64614,64672,64729,64786,64843,64900,64956,65013,
  3922. 65070,65126,65183,65239,65296,65352,65409,65465
  3923. };
  3924. const png_byte png_sRGB_delta[512] =
  3925. {
  3926. 207,201,158,129,113,100,90,82,77,72,68,64,61,59,56,54,
  3927. 52,50,49,47,46,45,43,42,41,40,39,39,38,37,36,36,
  3928. 35,34,34,33,33,32,32,31,31,30,30,30,29,29,28,28,
  3929. 28,27,27,27,27,26,26,26,25,25,25,25,24,24,24,24,
  3930. 23,23,23,23,23,22,22,22,22,22,22,21,21,21,21,21,
  3931. 21,20,20,20,20,20,20,20,20,19,19,19,19,19,19,19,
  3932. 19,18,18,18,18,18,18,18,18,18,18,17,17,17,17,17,
  3933. 17,17,17,17,17,17,16,16,16,16,16,16,16,16,16,16,
  3934. 16,16,16,16,15,15,15,15,15,15,15,15,15,15,15,15,
  3935. 15,15,15,15,14,14,14,14,14,14,14,14,14,14,14,14,
  3936. 14,14,14,14,14,14,14,13,13,13,13,13,13,13,13,13,
  3937. 13,13,13,13,13,13,13,13,13,13,13,13,13,13,12,12,
  3938. 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,
  3939. 12,12,12,12,12,12,12,12,12,12,12,12,11,11,11,11,
  3940. 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
  3941. 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,
  3942. 11,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
  3943. 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
  3944. 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
  3945. 10,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
  3946. 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
  3947. 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
  3948. 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
  3949. 9,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
  3950. 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
  3951. 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
  3952. 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
  3953. 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
  3954. 8,8,8,8,8,8,8,8,8,7,7,7,7,7,7,7,
  3955. 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
  3956. 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
  3957. 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
  3958. };
  3959. #endif /* SIMPLIFIED READ/WRITE sRGB support */
  3960. /* SIMPLIFIED READ/WRITE SUPPORT */
  3961. #if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
  3962. defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
  3963. static int
  3964. png_image_free_function(png_voidp argument)
  3965. {
  3966. png_imagep image = png_voidcast(png_imagep, argument);
  3967. png_controlp cp = image->opaque;
  3968. png_control c;
  3969. /* Double check that we have a png_ptr - it should be impossible to get here
  3970. * without one.
  3971. */
  3972. if (cp->png_ptr == NULL)
  3973. return 0;
  3974. /* First free any data held in the control structure. */
  3975. # ifdef PNG_STDIO_SUPPORTED
  3976. if (cp->owned_file != 0)
  3977. {
  3978. FILE *fp = png_voidcast(FILE*, cp->png_ptr->io_ptr);
  3979. cp->owned_file = 0;
  3980. /* Ignore errors here. */
  3981. if (fp != NULL)
  3982. {
  3983. cp->png_ptr->io_ptr = NULL;
  3984. (void)fclose(fp);
  3985. }
  3986. }
  3987. # endif
  3988. /* Copy the control structure so that the original, allocated, version can be
  3989. * safely freed. Notice that a png_error here stops the remainder of the
  3990. * cleanup, but this is probably fine because that would indicate bad memory
  3991. * problems anyway.
  3992. */
  3993. c = *cp;
  3994. image->opaque = &c;
  3995. png_free(c.png_ptr, cp);
  3996. /* Then the structures, calling the correct API. */
  3997. if (c.for_write != 0)
  3998. {
  3999. # ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
  4000. png_destroy_write_struct(&c.png_ptr, &c.info_ptr);
  4001. # else
  4002. png_error(c.png_ptr, "simplified write not supported");
  4003. # endif
  4004. }
  4005. else
  4006. {
  4007. # ifdef PNG_SIMPLIFIED_READ_SUPPORTED
  4008. png_destroy_read_struct(&c.png_ptr, &c.info_ptr, NULL);
  4009. # else
  4010. png_error(c.png_ptr, "simplified read not supported");
  4011. # endif
  4012. }
  4013. /* Success. */
  4014. return 1;
  4015. }
  4016. void PNGAPI
  4017. png_image_free(png_imagep image)
  4018. {
  4019. /* Safely call the real function, but only if doing so is safe at this point
  4020. * (if not inside an error handling context). Otherwise assume
  4021. * png_safe_execute will call this API after the return.
  4022. */
  4023. if (image != NULL && image->opaque != NULL &&
  4024. image->opaque->error_buf == NULL)
  4025. {
  4026. /* Ignore errors here: */
  4027. (void)png_safe_execute(image, png_image_free_function, image);
  4028. image->opaque = NULL;
  4029. }
  4030. }
  4031. int /* PRIVATE */
  4032. png_image_error(png_imagep image, png_const_charp error_message)
  4033. {
  4034. /* Utility to log an error. */
  4035. png_safecat(image->message, (sizeof image->message), 0, error_message);
  4036. image->warning_or_error |= PNG_IMAGE_ERROR;
  4037. png_image_free(image);
  4038. return 0;
  4039. }
  4040. #endif /* SIMPLIFIED READ/WRITE */
  4041. #endif /* READ || WRITE */