Geant4 Cross Reference |
1 1 2 // G.Barrand: pure header version of fpng foun 2 // G.Barrand: pure header version of fpng found at https://github.com/richgel999/fpng 3 3 4 // fpng.cpp 1.0.6 - Fast 24/32bpp .PNG image w 4 // fpng.cpp 1.0.6 - Fast 24/32bpp .PNG image writer/reader. See unlicense at the end of this file. 5 // PNG's generated by this code have been test 5 // PNG's generated by this code have been tested to load successfully with stb_image.h, lodepng.cpp, wuffs, libpng, and pngcheck. 6 // 6 // 7 // Uses code from the simple PNG writer functi 7 // Uses code from the simple PNG writer function by Alex Evans, 2011. Released into the public domain: https://gist.github.com/908299 8 // Some low-level Deflate/Huffman functions de 8 // Some low-level Deflate/Huffman functions derived from the original 2011 Google Code version of miniz (public domain by R. Geldreich, Jr.): https://code.google.com/archive/p/miniz/ 9 // Low-level Huffman code size function: publi 9 // Low-level Huffman code size function: public domain, originally written by: Alistair Moffat, alistair@cs.mu.oz.au, Jyrki Katajainen, jyrki@diku.dk, November 1996. 10 // 10 // 11 11 12 #include <assert.h> 12 #include <assert.h> 13 #include <string.h> 13 #include <string.h> 14 #include <stdio.h> 14 #include <stdio.h> 15 15 16 namespace tools { 16 namespace tools { 17 namespace fpng 17 namespace fpng 18 { 18 { 19 static const int FPNG_FALSE = 0; 19 static const int FPNG_FALSE = 0; 20 static const uint8_t FPNG_FDEC_VERSION = 0; 20 static const uint8_t FPNG_FDEC_VERSION = 0; 21 static const uint32_t FPNG_MAX_SUPPORTED_DIM 21 static const uint32_t FPNG_MAX_SUPPORTED_DIM = 1 << 24; 22 22 23 template <typename S> static inline S maximu 23 template <typename S> static inline S maximum(S a, S b) { return (a > b) ? a : b; } 24 template <typename S> static inline S minimu 24 template <typename S> static inline S minimum(S a, S b) { return (a < b) ? a : b; } 25 25 26 // A good compiler should be able to optimiz 26 // A good compiler should be able to optimize these routines - hopefully. They are crucial for performance. 27 static inline uint32_t READ_LE32(const void* 27 static inline uint32_t READ_LE32(const void* p) 28 { 28 { 29 const uint8_t* pBytes = (const uint8_t*)p; 29 const uint8_t* pBytes = (const uint8_t*)p; 30 return ((uint32_t)pBytes[0]) | (((uint32_t 30 return ((uint32_t)pBytes[0]) | (((uint32_t)pBytes[1]) << 8U) | (((uint32_t)pBytes[2]) << 16U) | (((uint32_t)pBytes[3]) << 24U); 31 } 31 } 32 32 33 static inline uint32_t READ_BE32(const void* 33 static inline uint32_t READ_BE32(const void* p) 34 { 34 { 35 const uint8_t* pBytes = (const uint8_t*)p; 35 const uint8_t* pBytes = (const uint8_t*)p; 36 return ((uint32_t)pBytes[3]) | (((uint32_t 36 return ((uint32_t)pBytes[3]) | (((uint32_t)pBytes[2]) << 8U) | (((uint32_t)pBytes[1]) << 16U) | (((uint32_t)pBytes[0]) << 24U); 37 } 37 } 38 38 39 static inline void WRITE_LE32(const void* p, 39 static inline void WRITE_LE32(const void* p, uint32_t v) 40 { 40 { 41 uint8_t* pBytes = (uint8_t*)p; 41 uint8_t* pBytes = (uint8_t*)p; 42 pBytes[0] = (uint8_t)(v); 42 pBytes[0] = (uint8_t)(v); 43 pBytes[1] = (uint8_t)(v >> 8); 43 pBytes[1] = (uint8_t)(v >> 8); 44 pBytes[2] = (uint8_t)(v >> 16); 44 pBytes[2] = (uint8_t)(v >> 16); 45 pBytes[3] = (uint8_t)(v >> 24); 45 pBytes[3] = (uint8_t)(v >> 24); 46 } 46 } 47 47 48 static inline void WRITE_LE64(const void* p, 48 static inline void WRITE_LE64(const void* p, uint64_t v) 49 { 49 { 50 uint8_t* pBytes = (uint8_t*)p; 50 uint8_t* pBytes = (uint8_t*)p; 51 pBytes[0] = (uint8_t)(v); 51 pBytes[0] = (uint8_t)(v); 52 pBytes[1] = (uint8_t)(v >> 8); 52 pBytes[1] = (uint8_t)(v >> 8); 53 pBytes[2] = (uint8_t)(v >> 16); 53 pBytes[2] = (uint8_t)(v >> 16); 54 pBytes[3] = (uint8_t)(v >> 24); 54 pBytes[3] = (uint8_t)(v >> 24); 55 pBytes[4] = (uint8_t)(v >> 32); 55 pBytes[4] = (uint8_t)(v >> 32); 56 pBytes[5] = (uint8_t)(v >> 40); 56 pBytes[5] = (uint8_t)(v >> 40); 57 pBytes[6] = (uint8_t)(v >> 48); 57 pBytes[6] = (uint8_t)(v >> 48); 58 pBytes[7] = (uint8_t)(v >> 56); 58 pBytes[7] = (uint8_t)(v >> 56); 59 } 59 } 60 60 61 // Customized the very common case of readin 61 // Customized the very common case of reading a 24bpp pixel from memory 62 static inline uint32_t READ_RGB_PIXEL(const 62 static inline uint32_t READ_RGB_PIXEL(const void* p) 63 { 63 { 64 const uint8_t* pBytes = (const uint8_t*)p; 64 const uint8_t* pBytes = (const uint8_t*)p; 65 return ((uint32_t)pBytes[0]) | (((uint32_t 65 return ((uint32_t)pBytes[0]) | (((uint32_t)pBytes[1]) << 8U) | (((uint32_t)pBytes[2]) << 16U); 66 } 66 } 67 67 68 // See "Slicing by 4" CRC-32 algorithm here: 68 // See "Slicing by 4" CRC-32 algorithm here: 69 // https://create.stephan-brumme.com/crc32/ 69 // https://create.stephan-brumme.com/crc32/ 70 70 71 // Precomputed 4KB of CRC-32 tables 71 // Precomputed 4KB of CRC-32 tables 72 static const uint32_t g_crc32_4[4][256] = { 72 static const uint32_t g_crc32_4[4][256] = { 73 {00, 016701630226, 035603460454, 02310225067 73 {00, 016701630226, 035603460454, 023102250672, 0733342031, 016032572217, 035130722465, 023631112643, 01666704062, 017167134244, 034065364436, 022764554610, 01155446053, 017654276275, 034756026407, 022057616621, 03555610144, 015254020362, 036356270510, 020457440736, 03266552175, 015567362353, 036465132521, 020364702707, 02333114126, 014432724300, 037530574572, 021231344754, 02400256117, 014301466331, 037203636543, 021502006765, 74 07333420310, 011432210136, 032530040744, 024 74 07333420310, 011432210136, 032530040744, 024231670562, 07400762321, 011301152107, 032203302775, 024502532553, 06555324372, 010254514154, 033356744726, 025457174500, 06266066343, 010567656165, 033465406717, 025364236531, 04666230254, 012167400072, 031065650600, 027764060426, 04155172265, 012654742043, 031756512631, 027057322417, 05000534236, 013701304010, 030603154662, 026102764444, 05733676207, 013032046021, 030130216653, 026631426475, 75 016667040620, 0166670406, 023064420274, 0357 75 016667040620, 0166670406, 023064420274, 035765210052, 016154302611, 0655532437, 023757762245, 035056152063, 017001744642, 01700174464, 022602324216, 034103514030, 017732406673, 01033236455, 022131066227, 034630656001, 015332650764, 03433060542, 020531230330, 036230400116, 015401512755, 03300322573, 020202172301, 036503742127, 014554154706, 02255764520, 021357534352, 037456304174, 014267216737, 02566426511, 021464676363, 037365046145, 76 011554460530, 07255250716, 024357000164, 032 76 011554460530, 07255250716, 024357000164, 032456630342, 011267722501, 07566112727, 024464342155, 032365572373, 010332364552, 06433554774, 025531704106, 033230134320, 010401026563, 06300616745, 025202446137, 033503276311, 012001270474, 04700440652, 027602610020, 031103020206, 012732132445, 04033702663, 027131552011, 031630362237, 013667574416, 05166344630, 026064114042, 030765724264, 013154636427, 05655006601, 026757256073, 030056466255, 77 035556101440, 023257731666, 0355561014, 0164 77 035556101440, 023257731666, 0355561014, 016454351232, 035265243471, 023564473657, 0466623025, 016367013203, 034330605422, 022431035604, 01533265076, 017232455250, 034403547413, 022302377635, 01200127047, 017501717261, 036003711504, 020702121722, 03600371150, 015101541376, 036730453535, 020031263713, 03133033161, 015632603347, 037665015566, 021164625740, 02066475132, 014767245314, 037156357557, 021657567771, 02755737103, 014054107325, 78 032665521750, 024164311576, 07066141304, 011 78 032665521750, 024164311576, 07066141304, 011767771122, 032156663761, 024657053547, 07755203335, 011054433113, 033003225732, 025702415514, 06600645366, 010101075140, 033730167703, 025031757525, 06133507357, 010632337171, 031330331614, 027431501432, 04533751240, 012232161066, 031403073625, 027302643403, 04200413271, 012501223057, 030556435676, 026257205450, 05355055222, 013454665004, 030265777647, 026564147461, 05466317213, 013367527035, 79 023331141260, 035430771046, 016532521634, 02 79 023331141260, 035430771046, 016532521634, 0233311412, 023402203251, 035303433077, 016201663605, 0500053423, 022557645202, 034256075024, 017354225656, 01455415470, 022264507233, 034565337015, 017467167667, 01366757441, 020664751324, 036165161102, 015067331770, 03766501556, 020157413315, 036656223133, 015754073741, 03055643567, 021002055346, 037703665160, 014601435712, 02100205534, 021731317377, 037030527151, 014132777723, 02633147505, 80 024002561170, 032703351356, 011601101524, 07 80 024002561170, 032703351356, 011601101524, 07100731702, 024731623141, 032030013367, 011132243515, 07633473733, 025664265112, 033165455334, 010067605546, 06766035760, 025157127123, 033656717305, 010754547577, 06055377751, 027557371034, 031256541212, 012354711460, 04455121646, 027264033005, 031565603223, 012467453451, 04366263677, 026331475056, 030430245270, 013532015402, 05233625624, 026402737067, 030303107241, 013201357433, 05500567615, 81 }, { 00,03106630501,06215461202,05313251703, 81 }, { 00,03106630501,06215461202,05313251703,014433142404,017535772105,012626523606,011720313307,031066305010,032160535511,037273764212,034375154713,025455247414,026553477115,023640626616,020746016317,011260411121,012366221420,017075070323,014173640622,05653553525,06755363024,03446132727,0540702226,020206714131,023300124430,026013375333,025115545632,034635656535,037733066034,032420237737,031526407236, 82 022541022242,021447612743,024754443040,02765 82 022541022242,021447612743,024754443040,027652273541,036172160646,035074750347,030367501444,033261331145,013527327252,010421517753,015732746050,016634176551,07114265656,04012455357,01301604454,02207034155,033721433363,030627203662,035534052161,036432662460,027312571767,024214341266,021107110565,022001720064,02747736373,01641106672,04552357171,07454567470,016374674777,015272044276,010161215575,013067425074, 83 036036247405,035130477104,030223626607,03332 83 036036247405,035130477104,030223626607,033325016306,022405305001,021503535500,024610764203,027716154702,07050142415,04156772114,01245523617,02343313316,013463000011,010565630510,015676461213,016770251712,027256656524,024350066025,021043237726,022145407227,033665714120,030763124421,035470375322,036576545623,016230553534,015336363035,010025132736,013123702237,02603411130,01705221431,04416070332,07510640633, 84 014577265647,017471455346,012762604445,01166 84 014577265647,017471455346,012762604445,011664034144,0144327243,03042517742,06351746041,05257176540,025511160657,026417750356,023704501455,020602331154,031122022253,032024612752,037337443051,034231273550,05717674766,06611044267,03502215564,0404425065,011324736362,012222106663,017131357160,014037567461,034771571776,037677341277,032564110574,031462720075,020342433372,023244203673,026157052170,025051662471, 85 07340714113,04246124412,01155375311,02053545 85 07340714113,04246124412,01155375311,02053545610,013773656517,010675066016,015566237715,016460407214,036326411103,035220221402,030133070301,033035640600,022715553507,021613363006,024500132705,027406702204,016120305032,015026535533,010335764230,013233154731,02513247436,01415477137,04706626634,07600016335,027146000022,024040630523,021353461220,022255251721,033575142426,030473772127,035760523624,036666313325, 86 025601736351,026707106650,023414357153,02051 86 025601736351,026707106650,023414357153,020512567452,031232674755,032334044254,037027215557,034121425056,014667433341,017761203640,012472052143,011574662442,0254571745,03352341244,06041110547,05147720046,034461327270,037567517771,032674746072,031772176573,020052265674,023154455375,026247604476,025341034177,05407022260,06501612761,03612443062,0714273563,011034160664,012132750365,017221501466,014327331167, 87 031376553516,032270363017,037163132714,03406 87 031376553516,032270363017,037163132714,034065702215,025745411112,026643221413,023550070310,020456640611,0310656506,03216066007,06105237704,05003407205,014723714102,017625124403,012536375300,011430545601,020116142437,023010772136,026303523635,025205313334,034525000033,037423630532,032730461231,031636251730,011170247427,012076477126,017365626625,014263016324,05543305023,06445535522,03756764221,0650154720, 88 013637571754,010731341255,015422110556,01652 88 013637571754,010731341255,015422110556,016524720057,07204433350,04302203651,01011052152,02117662453,022651674744,021757044245,024444215546,027542425047,036262736340,035364106641,030077357142,033171567443,02457160675,01551750374,04642501477,07744331176,016064022271,015162612770,010271443073,013377273572,033431265665,030537455364,035624604467,036722034166,027002327261,024104517760,021217746063,022311176562, 89 }, { 00,0160465067,0341152156,0221537131,070 89 }, { 00,0160465067,0341152156,0221537131,0702324334,0662741353,0443276262,0523613205,01604650670,01764235617,01545702726,01425367741,01106574544,01066111523,01247426412,01327043475,03411521560,03571144507,03750473436,03630016451,03313605654,03273260633,03052757702,03132332765,02215371310,02375714377,02154223246,02034646221,02517055024,02477430043,02656107172,02736562115, 90 07023243340,07143626327,07362311216,07202774 90 07023243340,07143626327,07362311216,07202774271,07721167074,07641502013,07460035122,07500450145,06627413530,06747076557,06566541466,06406124401,06125737604,06045352663,06264665752,06304200735,04432762620,04552307647,04773630776,04613255711,04330446514,04250023573,04071514442,04111171425,05236132050,05356557037,05177060106,05017405161,05534216364,05454673303,05675344232,05715721255, 91 016046506700,016126163767,016307454656,01626 91 016046506700,016126163767,016307454656,016267031631,016744622434,016624247453,016405770562,016565315505,017642356170,017722733117,017503204026,017463661041,017140072244,017020417223,017201120312,017361545375,015457027260,015537442207,015716175336,015676510351,015355303154,015235766133,015014251002,015174634065,014253677410,014333212477,014112725546,014072340521,014551553724,014431136743,014610401672,014770064615, 92 011065745440,011105320427,011324617516,01124 92 011065745440,011105320427,011324617516,011244272571,011767461774,011607004713,011426533622,011546156645,010661115230,010701570257,010520047366,010440422301,010163231104,010003654163,010222363052,010342706035,012474264120,012514601147,012735336076,012655753011,012376140214,012216525273,012037012342,012157477325,013270434750,013310051737,013131566606,013051103661,013572710464,013412375403,013633642532,013753227555, 93 034115215600,034075670667,034254347756,03433 93 034115215600,034075670667,034254347756,034334722731,034617131534,034777554553,034556063462,034436406405,035711445070,035671020017,035450517126,035530172141,035013761344,035173304323,035352633212,035232256275,037504734360,037464351307,037645666236,037725203251,037206410054,037366075033,037147542102,037027127165,036300164510,036260501577,036041036446,036121453421,036402240624,036562625643,036743312772,036623777715, 94 033136056540,033056433527,033277104416,03331 94 033136056540,033056433527,033277104416,033317561471,033634372674,033754717613,033575220722,033415645745,032732606330,032652263357,032473754266,032513331201,032030522004,032150147063,032371470152,032211015135,030527577020,030447112047,030666425176,030706040111,030225653314,030345236373,030164701242,030004364225,031323327650,031243742637,031062275706,031102610761,031421003564,031541466503,031760151432,031600534455, 95 022153713100,022033376167,022212641056,02237 95 022153713100,022033376167,022212641056,022372224031,022651437234,022731052253,022510565362,022470100305,023757143770,023637526717,023416011626,023576474641,023055267444,023135602423,023314335512,023274750575,021542232460,021422657407,021603360536,021763705551,021240116754,021320573733,021101044602,021061421665,020346462210,020226007277,020007530346,020167155321,020444746124,020524323143,020705614072,020665271015, 96 025170550240,025010135227,025231402316,02535 96 025170550240,025010135227,025231402316,025351067371,025672674174,025712211113,025533726022,025453343045,024774300430,024614765457,024435252566,024555637501,024076024704,024116441763,024337176652,024257513635,026561071720,026401414747,026620123676,026740546611,026263355414,026303730473,026122207542,026042662525,027365621150,027205244137,027024773006,027144316061,027467505264,027507160203,027726457332,027646032355, 97 }, { 00,027057063545,025202344213,0225532775 97 }, { 00,027057063545,025202344213,02255327756,021730513527,06767570062,04532657734,023565634271,030555024357,017502047612,015757360144,032700303401,011265537670,036232554335,034067673463,013030610126,012006253637,035051230372,037204117424,010253174161,033736740310,014761723655,016534404103,031563467446,022553277560,05504214025,07751133773,020706150236,03263764047,024234707502,026061420254,01036443711, 98 024014527476,03043544133,01216663665,0262416 98 024014527476,03043544133,01216663665,026241600320,05724034151,022773057414,020526370342,07571313607,014541503721,033516560264,031743647532,016714624077,035271010206,012226073743,010073354015,037024337550,036012774241,011045717704,013210430052,034247453517,017722267766,030775204223,032520123575,015577140030,06547750116,021510733453,023745414305,04712477640,027277243431,0220220174,02075107622,025022164367, 99 023305054075,04352037530,06107310266,0211503 99 023305054075,04352037530,06107310266,021150373723,02435547552,025462524017,027637603741,0660660204,013650070322,034607013667,036452334131,011405357474,032160563605,015137500340,017362627416,030335644153,031303207642,016354264307,014101143451,033156120114,010433714365,037464777620,035631450176,012666433433,01656223515,026601240050,024454167706,03403104243,020166730032,07131753577,05364474221,022333417764, 100 07311573403,020346510146,022113637610,051446 100 07311573403,020346510146,022113637610,05144654355,026421060124,01476003461,03623324337,024674347672,037644557754,010613534211,012446613547,035411670002,016174044273,031123027736,033376300060,014321363525,015317720234,032340743771,030115464027,017142407562,034427233713,013470250256,011625177500,036672114045,025642704163,02615767426,0440440370,027417423635,04172217444,023125274101,021370153657,06327130312, 101 035526333073,012571350536,010724077260,03777 101 035526333073,012571350536,010724077260,037773014725,014216620554,033241643011,031014564747,016043507202,05073317324,022024374661,020271053137,07226030472,024743604603,03714667346,01541540410,026516523155,027520160644,0577103301,02722224457,025775247112,06210473363,021247410626,023012737170,04045754435,017075144513,030022127056,032277200700,015220263245,036745457034,011712434571,013547713227,034510770762, 102 011532614405,036565677140,034730550616,01376 102 011532614405,036565677140,034730550616,013767533353,030202307122,017255364467,015000043331,032057020674,021067630752,06030653217,04265574541,023232517004,0757323275,027700340730,025555067066,02502004523,03534447232,024563424777,026736703021,01761760564,022204154715,05253137250,07006210506,020051273043,033061463165,014036400420,016263727376,031234744633,012751170442,035706113107,037553234651,010504257314, 103 016623367006,031674304543,033421023215,01447 103 016623367006,031674304543,033421023215,014476040750,037113674521,010144617064,012311530732,035346553277,026376343351,01321320614,03174007142,024123064407,07446650676,020411633333,022644514465,05613577120,04625134631,023672157374,021427270422,06470213167,025115427316,02142444653,0317763105,027340700440,034370110566,013327173023,011172254775,036125237230,015440403041,032417460504,030642747252,017615724717, 104 032637640470,015660623135,017435504663,03046 104 032637640470,015660623135,017435504663,030462567326,013107353157,034150330412,036305017344,011352074601,02362664727,025335607262,027160520534,0137543071,023452377200,04405314745,06650033013,021607050556,020631413247,07666470702,05433757054,022464734511,01101100760,026156163225,024303244573,03354227036,010364437110,037333454455,035166773303,012131710646,031454124437,016403147172,014656260624,033601203361, 105 } }; 105 } }; 106 106 107 static uint32_t crc32_slice_by_4(const void* 107 static uint32_t crc32_slice_by_4(const void* pData, size_t data_len, uint32_t cur_crc32 = 0) 108 { 108 { 109 uint32_t crc = ~cur_crc32; 109 uint32_t crc = ~cur_crc32; 110 const uint32_t* pData32 = static_cast<cons 110 const uint32_t* pData32 = static_cast<const uint32_t*>(pData); 111 111 112 for (; data_len >= sizeof(uint32_t); ++pDa 112 for (; data_len >= sizeof(uint32_t); ++pData32, data_len -= 4) 113 { 113 { 114 uint32_t v = READ_LE32(pData32) ^ crc; 114 uint32_t v = READ_LE32(pData32) ^ crc; 115 crc = g_crc32_4[0][v >> 24] ^ g_crc32_4[ 115 crc = g_crc32_4[0][v >> 24] ^ g_crc32_4[1][(v >> 16) & 0xFF] ^ g_crc32_4[2][(v >> 8) & 0xFF] ^ g_crc32_4[3][v & 0xFF]; 116 } 116 } 117 117 118 for (const uint8_t* pData8 = reinterpret_c 118 for (const uint8_t* pData8 = reinterpret_cast<const uint8_t*>(pData32); data_len; --data_len) 119 crc = (crc >> 8) ^ g_crc32_4[0][(crc & 0 119 crc = (crc >> 8) ^ g_crc32_4[0][(crc & 0xFF) ^ *pData8++]; 120 120 121 return ~crc; 121 return ~crc; 122 } 122 } 123 123 124 inline uint32_t fpng_crc32(const void* pData 124 inline uint32_t fpng_crc32(const void* pData, size_t size, uint32_t prev_crc32) 125 { 125 { 126 return crc32_slice_by_4(pData, size, prev_ 126 return crc32_slice_by_4(pData, size, prev_crc32); 127 } 127 } 128 128 129 static uint32_t fpng_adler32_scalar(const ui 129 static uint32_t fpng_adler32_scalar(const uint8_t* ptr, size_t buf_len, uint32_t adler) 130 { 130 { 131 uint32_t i, s1 = (uint32_t)(adler & 0xffff 131 uint32_t i, s1 = (uint32_t)(adler & 0xffff), s2 = (uint32_t)(adler >> 16); uint32_t block_len = (uint32_t)(buf_len % 5552); 132 if (!ptr) return FPNG_ADLER32_INIT; 132 if (!ptr) return FPNG_ADLER32_INIT; 133 while (buf_len) { 133 while (buf_len) { 134 for (i = 0; i + 7 < block_len; i += 8, p 134 for (i = 0; i + 7 < block_len; i += 8, ptr += 8) { 135 s1 += ptr[0], s2 += s1; s1 += ptr[1], 135 s1 += ptr[0], s2 += s1; s1 += ptr[1], s2 += s1; s1 += ptr[2], s2 += s1; s1 += ptr[3], s2 += s1; 136 s1 += ptr[4], s2 += s1; s1 += ptr[5], 136 s1 += ptr[4], s2 += s1; s1 += ptr[5], s2 += s1; s1 += ptr[6], s2 += s1; s1 += ptr[7], s2 += s1; 137 } 137 } 138 for (; i < block_len; ++i) s1 += *ptr++, 138 for (; i < block_len; ++i) s1 += *ptr++, s2 += s1; 139 s1 %= 65521U, s2 %= 65521U; buf_len -= b 139 s1 %= 65521U, s2 %= 65521U; buf_len -= block_len; block_len = 5552; 140 } 140 } 141 return (s2 << 16) + s1; 141 return (s2 << 16) + s1; 142 } 142 } 143 143 144 inline uint32_t fpng_adler32(const void* pDa 144 inline uint32_t fpng_adler32(const void* pData, size_t size, uint32_t adler) 145 { 145 { 146 return fpng_adler32_scalar((const uint8_t* 146 return fpng_adler32_scalar((const uint8_t*)pData, size, adler); 147 } 147 } 148 148 149 // Ensure we've been configured for endianne 149 // Ensure we've been configured for endianness correctly. 150 static inline bool endian_check() 150 static inline bool endian_check() 151 { 151 { 152 uint32_t endian_check = 0; 152 uint32_t endian_check = 0; 153 WRITE_LE32(&endian_check, 0x1234ABCD); 153 WRITE_LE32(&endian_check, 0x1234ABCD); 154 const uint32_t first_byte = reinterpret_ca 154 const uint32_t first_byte = reinterpret_cast<const uint8_t*>(&endian_check)[0]; 155 return first_byte == 0xCD; 155 return first_byte == 0xCD; 156 } 156 } 157 157 158 static const uint16_t g_defl_len_sym[256] = 158 static const uint16_t g_defl_len_sym[256] = { 159 257,258,259,260,261,262,263,264,265,265,26 159 257,258,259,260,261,262,263,264,265,265,266,266,267,267,268,268,269,269,269,269,270,270,270,270,271,271,271,271,272,272,272,272, 160 273,273,273,273,273,273,273,273,274,274,27 160 273,273,273,273,273,273,273,273,274,274,274,274,274,274,274,274,275,275,275,275,275,275,275,275,276,276,276,276,276,276,276,276, 161 277,277,277,277,277,277,277,277,277,277,27 161 277,277,277,277,277,277,277,277,277,277,277,277,277,277,277,277,278,278,278,278,278,278,278,278,278,278,278,278,278,278,278,278, 162 279,279,279,279,279,279,279,279,279,279,27 162 279,279,279,279,279,279,279,279,279,279,279,279,279,279,279,279,280,280,280,280,280,280,280,280,280,280,280,280,280,280,280,280, 163 281,281,281,281,281,281,281,281,281,281,28 163 281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281,281, 164 282,282,282,282,282,282,282,282,282,282,28 164 282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282,282, 165 283,283,283,283,283,283,283,283,283,283,28 165 283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283,283, 166 284,284,284,284,284,284,284,284,284,284,28 166 284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,285 }; 167 167 168 static const uint8_t g_defl_len_extra[256] = 168 static const uint8_t g_defl_len_extra[256] = { 169 0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2,2, 169 0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3, 170 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4, 170 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4, 171 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, 171 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, 172 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, 172 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,0 }; 173 173 174 static const uint8_t g_defl_small_dist_sym[5 174 static const uint8_t g_defl_small_dist_sym[512] = { 175 0,1,2,3,4,4,5,5,6,6,6,6,7,7,7,7,8,8,8,8,8, 175 0,1,2,3,4,4,5,5,6,6,6,6,7,7,7,7,8,8,8,8,8,8,8,8,9,9,9,9,9,9,9,9,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,11,11,11,11,11,11, 176 11,11,11,11,11,11,11,11,11,11,12,12,12,12, 176 11,11,11,11,11,11,11,11,11,11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,13, 177 13,13,13,13,13,13,13,13,13,13,13,13,13,13, 177 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,14,14,14,14,14,14,14,14,14,14,14,14, 178 14,14,14,14,14,14,14,14,14,14,14,14,14,14, 178 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14, 179 14,14,14,14,14,14,14,14,14,15,15,15,15,15, 179 14,14,14,14,14,14,14,14,14,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15, 180 15,15,15,15,15,15,15,15,15,15,15,15,15,15, 180 15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,16,16,16,16,16,16,16,16,16,16,16,16,16, 181 16,16,16,16,16,16,16,16,16,16,16,16,16,16, 181 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16, 182 16,16,16,16,16,16,16,16,16,16,16,16,16,16, 182 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16, 183 16,16,16,16,16,16,16,16,16,16,16,16,16,16, 183 16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,17,17,17,17,17,17,17,17,17,17,17,17, 184 17,17,17,17,17,17,17,17,17,17,17,17,17,17, 184 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17, 185 17,17,17,17,17,17,17,17,17,17,17,17,17,17, 185 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17, 186 17,17,17,17,17,17,17,17,17,17,17,17,17,17, 186 17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17 }; 187 187 188 static const uint32_t g_bitmasks[17] = { 0x0 188 static const uint32_t g_bitmasks[17] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF }; 189 189 190 // Huffman tables generated by fpng_test -t 190 // Huffman tables generated by fpng_test -t @filelist.txt. Total alpha files : 1440, Total opaque files : 5627. 191 // Feel free to retrain the encoder on your 191 // Feel free to retrain the encoder on your opaque/alpha PNG files by setting FPNG_TRAIN_HUFFMAN_TABLES and running fpng_test with the -t option. 192 static const uint8_t g_dyn_huff_3[] = { 192 static const uint8_t g_dyn_huff_3[] = { 193 120, 1, 237, 195, 3, 176, 110, 89, 122, 128, 193 120, 1, 237, 195, 3, 176, 110, 89, 122, 128, 225, 247, 251, 214, 218, 248, 113, 124, 173, 190, 109, 12, 50, 201, 196, 182, 109, 219, 182, 109, 219, 182, 194 109, 219, 201, 36, 147, 153, 105, 235, 246, 194 109, 219, 201, 36, 147, 153, 105, 235, 246, 53, 142, 207, 143, 141, 181, 214, 151, 93, 117, 170, 78, 117, 117, 58, 206, 77, 210, 217, 169, 122 }; 195 const uint32_t DYN_HUFF_3_BITBUF = 30, DYN_H 195 const uint32_t DYN_HUFF_3_BITBUF = 30, DYN_HUFF_3_BITBUF_SIZE = 7; 196 static const struct { uint8_t m_code_size; u 196 static const struct { uint8_t m_code_size; uint16_t m_code; } g_dyn_huff_3_codes[288] = { 197 {2,0},{4,2},{4,10},{5,14},{5,30},{6,25},{6,5 197 {2,0},{4,2},{4,10},{5,14},{5,30},{6,25},{6,57},{6,5},{6,37},{7,3},{7,67},{7,35},{7,99},{8,11},{8,139},{8,75},{8,203},{8,43},{8,171},{8,107},{9,135},{9,391},{9,71},{9,327},{9,199},{9,455},{9,39},{9,295},{9,167},{9,423},{9,103},{10,183}, 198 {9,359},{10,695},{10,439},{10,951},{10,119}, 198 {9,359},{10,695},{10,439},{10,951},{10,119},{10,631},{10,375},{10,887},{10,247},{10,759},{10,503},{11,975},{11,1999},{11,47},{11,1071},{12,1199},{11,559},{12,3247},{12,687},{11,1583},{12,2735},{12,1711},{12,3759},{12,431},{12,2479},{12,1455},{12,3503},{12,943},{12,2991},{12,1967},{12,4015},{12,111}, 199 {12,2159},{12,1135},{12,3183},{12,623},{12,2 199 {12,2159},{12,1135},{12,3183},{12,623},{12,2671},{12,1647},{12,3695},{12,367},{12,2415},{12,1391},{12,3439},{12,879},{12,2927},{12,1903},{12,3951},{12,239},{12,2287},{12,1263},{12,3311},{12,751},{12,2799},{12,1775},{12,3823},{12,495},{12,2543},{12,1519},{12,3567},{12,1007},{12,3055},{12,2031},{12,4079},{12,31}, 200 {12,2079},{12,1055},{12,3103},{12,543},{12,2 200 {12,2079},{12,1055},{12,3103},{12,543},{12,2591},{12,1567},{12,3615},{12,287},{12,2335},{12,1311},{12,3359},{12,799},{12,2847},{12,1823},{12,3871},{12,159},{12,2207},{12,1183},{12,3231},{12,671},{12,2719},{12,1695},{12,3743},{12,415},{12,2463},{12,1439},{12,3487},{12,927},{12,2975},{12,1951},{12,3999},{12,95}, 201 {12,2143},{12,1119},{12,3167},{12,607},{12,2 201 {12,2143},{12,1119},{12,3167},{12,607},{12,2655},{12,1631},{12,3679},{12,351},{12,2399},{12,1375},{12,3423},{12,863},{12,2911},{12,1887},{12,3935},{12,223},{12,2271},{12,1247},{12,3295},{12,735},{12,2783},{12,1759},{12,3807},{12,479},{12,2527},{12,1503},{12,3551},{12,991},{12,3039},{12,2015},{12,4063},{12,63}, 202 {12,2111},{12,1087},{12,3135},{12,575},{12,2 202 {12,2111},{12,1087},{12,3135},{12,575},{12,2623},{12,1599},{12,3647},{12,319},{12,2367},{12,1343},{12,3391},{12,831},{12,2879},{12,1855},{12,3903},{12,191},{12,2239},{12,1215},{12,3263},{12,703},{12,2751},{12,1727},{12,3775},{12,447},{12,2495},{12,1471},{12,3519},{12,959},{12,3007},{12,1983},{12,4031},{12,127}, 203 {12,2175},{12,1151},{12,3199},{12,639},{12,2 203 {12,2175},{12,1151},{12,3199},{12,639},{12,2687},{12,1663},{12,3711},{12,383},{12,2431},{12,1407},{12,3455},{12,895},{12,2943},{11,303},{12,1919},{12,3967},{11,1327},{12,255},{11,815},{11,1839},{11,175},{10,1015},{10,15},{10,527},{10,271},{10,783},{10,143},{10,655},{10,399},{10,911},{10,79},{10,591}, 204 {9,231},{10,335},{9,487},{9,23},{9,279},{9,1 204 {9,231},{10,335},{9,487},{9,23},{9,279},{9,151},{9,407},{9,87},{9,343},{9,215},{9,471},{9,55},{8,235},{8,27},{8,155},{8,91},{8,219},{8,59},{8,187},{8,123},{7,19},{7,83},{7,51},{7,115},{6,21},{6,53},{6,13},{6,45},{5,1},{5,17},{5,9},{4,6}, 205 {12,2303},{6,29},{0,0},{0,0},{8,251},{0,0},{ 205 {12,2303},{6,29},{0,0},{0,0},{8,251},{0,0},{0,0},{8,7},{0,0},{10,847},{0,0},{10,207},{12,1279},{10,719},{12,3327},{12,767},{12,2815},{12,1791},{12,3839},{12,511},{12,2559},{12,1535},{9,311},{12,3583},{12,1023},{12,3071},{10,463},{12,2047},{6,61},{12,4095},{0,0},{0,0} 206 }; 206 }; 207 207 208 static const uint8_t g_dyn_huff_4[] = { 208 static const uint8_t g_dyn_huff_4[] = { 209 120, 1, 229, 196, 99, 180, 37, 103, 218, 128 209 120, 1, 229, 196, 99, 180, 37, 103, 218, 128, 225, 251, 121, 171, 106, 243, 216, 231, 180, 109, 196, 182, 51, 51, 73, 6, 201, 216, 182, 109, 219, 182, 210 17, 140, 98, 219, 102, 219, 60, 125, 172, 20 210 17, 140, 98, 219, 102, 219, 60, 125, 172, 205, 170, 122, 159, 111, 213, 143, 179, 214, 94, 189, 58, 153, 104, 166, 103, 190, 247, 199, 117 }; 211 const uint32_t DYN_HUFF_4_BITBUF = 1, DYN_HU 211 const uint32_t DYN_HUFF_4_BITBUF = 1, DYN_HUFF_4_BITBUF_SIZE = 2; 212 static const struct { uint8_t m_code_size; u 212 static const struct { uint8_t m_code_size; uint16_t m_code; } g_dyn_huff_4_codes[288] = { 213 {2,0},{4,2},{5,6},{6,30},{6,62},{6,1},{7,41} 213 {2,0},{4,2},{5,6},{6,30},{6,62},{6,1},{7,41},{7,105},{7,25},{7,89},{7,57},{7,121},{8,117},{8,245},{8,13},{8,141},{8,77},{8,205},{8,45},{8,173},{8,109},{8,237},{8,29},{8,157},{8,93},{8,221},{8,61},{9,83},{9,339},{9,211},{9,467},{9,51}, 214 {9,307},{9,179},{9,435},{9,115},{9,371},{9,2 214 {9,307},{9,179},{9,435},{9,115},{9,371},{9,243},{9,499},{9,11},{9,267},{9,139},{9,395},{9,75},{9,331},{9,203},{9,459},{9,43},{9,299},{10,7},{10,519},{10,263},{10,775},{10,135},{10,647},{10,391},{10,903},{10,71},{10,583},{10,327},{10,839},{10,199},{10,711},{10,455}, 215 {10,967},{10,39},{10,551},{10,295},{10,807}, 215 {10,967},{10,39},{10,551},{10,295},{10,807},{10,167},{10,679},{10,423},{10,935},{10,103},{10,615},{11,463},{11,1487},{11,975},{10,359},{10,871},{10,231},{11,1999},{11,47},{11,1071},{11,559},{10,743},{10,487},{11,1583},{11,303},{11,1327},{11,815},{11,1839},{11,175},{11,1199},{11,687},{11,1711}, 216 {11,431},{11,1455},{11,943},{11,1967},{11,11 216 {11,431},{11,1455},{11,943},{11,1967},{11,111},{11,1135},{11,623},{11,1647},{11,367},{11,1391},{11,879},{11,1903},{11,239},{11,1263},{11,751},{11,1775},{11,495},{11,1519},{11,1007},{11,2031},{11,31},{11,1055},{11,543},{11,1567},{11,287},{11,1311},{11,799},{11,1823},{11,159},{11,1183},{11,671},{11,1695}, 217 {11,415},{11,1439},{11,927},{11,1951},{11,95 217 {11,415},{11,1439},{11,927},{11,1951},{11,95},{11,1119},{11,607},{11,1631},{11,351},{11,1375},{11,863},{11,1887},{11,223},{11,1247},{11,735},{11,1759},{11,479},{11,1503},{11,991},{11,2015},{11,63},{11,1087},{11,575},{11,1599},{11,319},{11,1343},{11,831},{11,1855},{11,191},{11,1215},{11,703},{11,1727}, 218 {11,447},{11,1471},{11,959},{11,1983},{11,12 218 {11,447},{11,1471},{11,959},{11,1983},{11,127},{11,1151},{11,639},{11,1663},{11,383},{10,999},{10,23},{10,535},{10,279},{11,1407},{11,895},{11,1919},{11,255},{11,1279},{10,791},{10,151},{10,663},{10,407},{10,919},{10,87},{10,599},{10,343},{10,855},{10,215},{10,727},{10,471},{10,983},{10,55}, 219 {10,567},{10,311},{10,823},{10,183},{10,695} 219 {10,567},{10,311},{10,823},{10,183},{10,695},{10,439},{10,951},{10,119},{10,631},{10,375},{10,887},{10,247},{10,759},{10,503},{10,1015},{10,15},{10,527},{10,271},{10,783},{10,143},{10,655},{10,399},{9,171},{9,427},{9,107},{9,363},{9,235},{9,491},{9,27},{9,283},{9,155},{9,411}, 220 {9,91},{9,347},{9,219},{9,475},{9,59},{9,315 220 {9,91},{9,347},{9,219},{9,475},{9,59},{9,315},{9,187},{9,443},{8,189},{9,123},{8,125},{8,253},{8,3},{8,131},{8,67},{8,195},{8,35},{8,163},{8,99},{8,227},{8,19},{7,5},{7,69},{7,37},{7,101},{7,21},{7,85},{6,33},{6,17},{6,49},{5,22},{4,10}, 221 {12,2047},{0,0},{6,9},{0,0},{0,0},{0,0},{8,1 221 {12,2047},{0,0},{6,9},{0,0},{0,0},{0,0},{8,147},{0,0},{0,0},{7,53},{0,0},{9,379},{0,0},{9,251},{10,911},{10,79},{11,767},{10,591},{10,335},{10,847},{10,207},{10,719},{11,1791},{11,511},{9,507},{11,1535},{11,1023},{12,4095},{5,14},{0,0},{0,0},{0,0} 222 }; 222 }; 223 223 224 #define TOOLS_FPNG_PUT_BITS(bb, ll) do { uint3 224 #define TOOLS_FPNG_PUT_BITS(bb, ll) do { uint32_t b = bb, l = ll; assert(/*(l) >= 0 &&*/ (l) <= 16); assert((b) < (1ULL << (l))); bit_buf |= (((uint64_t)(b)) << bit_buf_size); bit_buf_size += (l); assert(bit_buf_size <= 64); } while(0) 225 #define TOOLS_FPNG_PUT_BITS_CZ(bb, ll) do { ui 225 #define TOOLS_FPNG_PUT_BITS_CZ(bb, ll) do { uint32_t b = bb, l = ll; assert((l) >= 1 && (l) <= 16); assert((b) < (1ULL << (l))); bit_buf |= (((uint64_t)(b)) << bit_buf_size); bit_buf_size += (l); assert(bit_buf_size <= 64); } while(0) 226 226 227 #define TOOLS_FPNG_PUT_BITS_FLUSH do { \ 227 #define TOOLS_FPNG_PUT_BITS_FLUSH do { \ 228 if ((dst_ofs + 8) > dst_buf_size) \ 228 if ((dst_ofs + 8) > dst_buf_size) \ 229 return 0; \ 229 return 0; \ 230 WRITE_LE64(pDst + dst_ofs, bit_buf); \ 230 WRITE_LE64(pDst + dst_ofs, bit_buf); \ 231 uint32_t bits_to_shift = bit_buf_size & ~7; 231 uint32_t bits_to_shift = bit_buf_size & ~7; \ 232 dst_ofs += (bits_to_shift >> 3); \ 232 dst_ofs += (bits_to_shift >> 3); \ 233 assert(bits_to_shift < 64); \ 233 assert(bits_to_shift < 64); \ 234 bit_buf = bit_buf >> bits_to_shift; \ 234 bit_buf = bit_buf >> bits_to_shift; \ 235 bit_buf_size -= bits_to_shift; \ 235 bit_buf_size -= bits_to_shift; \ 236 } while(0) 236 } while(0) 237 237 238 #define TOOLS_FPNG_PUT_BITS_FORCE_FLUSH do { \ 238 #define TOOLS_FPNG_PUT_BITS_FORCE_FLUSH do { \ 239 while (bit_buf_size > 0) \ 239 while (bit_buf_size > 0) \ 240 { \ 240 { \ 241 if ((dst_ofs + 1) > dst_buf_size) \ 241 if ((dst_ofs + 1) > dst_buf_size) \ 242 return 0; \ 242 return 0; \ 243 *(uint8_t*)(pDst + dst_ofs) = (uint8_t)bit 243 *(uint8_t*)(pDst + dst_ofs) = (uint8_t)bit_buf; \ 244 dst_ofs++; \ 244 dst_ofs++; \ 245 bit_buf >>= 8; \ 245 bit_buf >>= 8; \ 246 bit_buf_size -= 8; \ 246 bit_buf_size -= 8; \ 247 } \ 247 } \ 248 } while(0) 248 } while(0) 249 249 250 enum 250 enum 251 { 251 { 252 DEFL_MAX_HUFF_TABLES = 3, 252 DEFL_MAX_HUFF_TABLES = 3, 253 DEFL_MAX_HUFF_SYMBOLS = 288, 253 DEFL_MAX_HUFF_SYMBOLS = 288, 254 DEFL_MAX_HUFF_SYMBOLS_0 = 288, 254 DEFL_MAX_HUFF_SYMBOLS_0 = 288, 255 DEFL_MAX_HUFF_SYMBOLS_1 = 32, 255 DEFL_MAX_HUFF_SYMBOLS_1 = 32, 256 DEFL_MAX_HUFF_SYMBOLS_2 = 19, 256 DEFL_MAX_HUFF_SYMBOLS_2 = 19, 257 DEFL_LZ_DICT_SIZE = 32768, 257 DEFL_LZ_DICT_SIZE = 32768, 258 DEFL_LZ_DICT_SIZE_MASK = DEFL_LZ_DICT_SIZE 258 DEFL_LZ_DICT_SIZE_MASK = DEFL_LZ_DICT_SIZE - 1, 259 DEFL_MIN_MATCH_LEN = 3, 259 DEFL_MIN_MATCH_LEN = 3, 260 DEFL_MAX_MATCH_LEN = 258 260 DEFL_MAX_MATCH_LEN = 258 261 }; 261 }; 262 262 263 struct defl_huff 263 struct defl_huff 264 { 264 { 265 uint16_t m_huff_count[DEFL_MAX_HUFF_TABLES 265 uint16_t m_huff_count[DEFL_MAX_HUFF_TABLES][DEFL_MAX_HUFF_SYMBOLS]; 266 uint16_t m_huff_codes[DEFL_MAX_HUFF_TABLES 266 uint16_t m_huff_codes[DEFL_MAX_HUFF_TABLES][DEFL_MAX_HUFF_SYMBOLS]; 267 uint8_t m_huff_code_sizes[DEFL_MAX_HUFF_TA 267 uint8_t m_huff_code_sizes[DEFL_MAX_HUFF_TABLES][DEFL_MAX_HUFF_SYMBOLS]; 268 }; 268 }; 269 269 270 struct defl_sym_freq 270 struct defl_sym_freq 271 { 271 { 272 uint16_t m_key; 272 uint16_t m_key; 273 uint16_t m_sym_index; 273 uint16_t m_sym_index; 274 }; 274 }; 275 275 276 #define TOOLS_FPNG_DEFL_CLEAR_OBJ(obj) memset( 276 #define TOOLS_FPNG_DEFL_CLEAR_OBJ(obj) memset(&(obj), 0, sizeof(obj)) 277 277 278 static defl_sym_freq* defl_radix_sort_syms(u 278 static defl_sym_freq* defl_radix_sort_syms(uint32_t num_syms, defl_sym_freq* pSyms0, defl_sym_freq* pSyms1) 279 { 279 { 280 uint32_t total_passes = 2, pass_shift, pas 280 uint32_t total_passes = 2, pass_shift, pass, i, hist[256 * 2]; defl_sym_freq* pCur_syms = pSyms0, * pNew_syms = pSyms1; TOOLS_FPNG_DEFL_CLEAR_OBJ(hist); 281 for (i = 0; i < num_syms; i++) { uint32_t 281 for (i = 0; i < num_syms; i++) { uint32_t freq = pSyms0[i].m_key; hist[freq & 0xFF]++; hist[256 + ((freq >> 8) & 0xFF)]++; } 282 while ((total_passes > 1) && (num_syms == 282 while ((total_passes > 1) && (num_syms == hist[(total_passes - 1) * 256])) total_passes--; 283 for (pass_shift = 0, pass = 0; pass < tota 283 for (pass_shift = 0, pass = 0; pass < total_passes; pass++, pass_shift += 8) 284 { 284 { 285 const uint32_t* pHist = &hist[pass << 8] 285 const uint32_t* pHist = &hist[pass << 8]; 286 uint32_t offsets[256], cur_ofs = 0; 286 uint32_t offsets[256], cur_ofs = 0; 287 for (i = 0; i < 256; i++) { offsets[i] = 287 for (i = 0; i < 256; i++) { offsets[i] = cur_ofs; cur_ofs += pHist[i]; } 288 for (i = 0; i < num_syms; i++) pNew_syms 288 for (i = 0; i < num_syms; i++) pNew_syms[offsets[(pCur_syms[i].m_key >> pass_shift) & 0xFF]++] = pCur_syms[i]; 289 { defl_sym_freq* t = pCur_syms; pCur_sym 289 { defl_sym_freq* t = pCur_syms; pCur_syms = pNew_syms; pNew_syms = t; } 290 } 290 } 291 return pCur_syms; 291 return pCur_syms; 292 } 292 } 293 293 294 // defl_calculate_minimum_redundancy() origi 294 // defl_calculate_minimum_redundancy() originally written by: Alistair Moffat, alistair@cs.mu.oz.au, Jyrki Katajainen, jyrki@diku.dk, November 1996. 295 static void defl_calculate_minimum_redundanc 295 static void defl_calculate_minimum_redundancy(defl_sym_freq* A, int n) 296 { 296 { 297 int root, leaf, next, avbl, used, dpth; 297 int root, leaf, next, avbl, used, dpth; 298 if (n == 0) return; else if (n == 1) { A[0 298 if (n == 0) return; else if (n == 1) { A[0].m_key = 1; return; } 299 A[0].m_key += A[1].m_key; root = 0; leaf = 299 A[0].m_key += A[1].m_key; root = 0; leaf = 2; 300 for (next = 1; next < n - 1; next++) 300 for (next = 1; next < n - 1; next++) 301 { 301 { 302 if (leaf >= n || A[root].m_key < A[leaf] 302 if (leaf >= n || A[root].m_key < A[leaf].m_key) { A[next].m_key = A[root].m_key; A[root++].m_key = (uint16_t)next; } 303 else A[next].m_key = A[leaf++].m_key; 303 else A[next].m_key = A[leaf++].m_key; 304 if (leaf >= n || (root < next && A[root] 304 if (leaf >= n || (root < next && A[root].m_key < A[leaf].m_key)) { A[next].m_key = (uint16_t)(A[next].m_key + A[root].m_key); A[root++].m_key = (uint16_t)next; } 305 else A[next].m_key = (uint16_t)(A[next]. 305 else A[next].m_key = (uint16_t)(A[next].m_key + A[leaf++].m_key); 306 } 306 } 307 A[n - 2].m_key = 0; for (next = n - 3; nex 307 A[n - 2].m_key = 0; for (next = n - 3; next >= 0; next--) A[next].m_key = A[A[next].m_key].m_key + 1; 308 avbl = 1; used = dpth = 0; root = n - 2; n 308 avbl = 1; used = dpth = 0; root = n - 2; next = n - 1; 309 while (avbl > 0) 309 while (avbl > 0) 310 { 310 { 311 while (root >= 0 && (int)A[root].m_key = 311 while (root >= 0 && (int)A[root].m_key == dpth) { used++; root--; } 312 while (avbl > used) { A[next--].m_key = 312 while (avbl > used) { A[next--].m_key = (uint16_t)(dpth); avbl--; } 313 avbl = 2 * used; dpth++; used = 0; 313 avbl = 2 * used; dpth++; used = 0; 314 } 314 } 315 } 315 } 316 316 317 // Limits canonical Huffman code table's max 317 // Limits canonical Huffman code table's max code size. 318 enum { DEFL_MAX_SUPPORTED_HUFF_CODESIZE = 32 318 enum { DEFL_MAX_SUPPORTED_HUFF_CODESIZE = 32 }; 319 static void defl_huffman_enforce_max_code_si 319 static void defl_huffman_enforce_max_code_size(int* pNum_codes, int code_list_len, int max_code_size) 320 { 320 { 321 int i; uint32_t total = 0; if (code_list_l 321 int i; uint32_t total = 0; if (code_list_len <= 1) return; 322 for (i = max_code_size + 1; i <= DEFL_MAX_ 322 for (i = max_code_size + 1; i <= DEFL_MAX_SUPPORTED_HUFF_CODESIZE; i++) pNum_codes[max_code_size] += pNum_codes[i]; 323 for (i = max_code_size; i > 0; i--) total 323 for (i = max_code_size; i > 0; i--) total += (((uint32_t)pNum_codes[i]) << (max_code_size - i)); 324 while (total != (1UL << max_code_size)) 324 while (total != (1UL << max_code_size)) 325 { 325 { 326 pNum_codes[max_code_size]--; 326 pNum_codes[max_code_size]--; 327 for (i = max_code_size - 1; i > 0; i--) 327 for (i = max_code_size - 1; i > 0; i--) if (pNum_codes[i]) { pNum_codes[i]--; pNum_codes[i + 1] += 2; break; } 328 total--; 328 total--; 329 } 329 } 330 } 330 } 331 331 332 static void defl_optimize_huffman_table(defl 332 static void defl_optimize_huffman_table(defl_huff* d, int table_num, int table_len, int code_size_limit, int static_table) 333 { 333 { 334 int i, j, l, num_codes[1 + DEFL_MAX_SUPPOR 334 int i, j, l, num_codes[1 + DEFL_MAX_SUPPORTED_HUFF_CODESIZE]; uint32_t next_code[DEFL_MAX_SUPPORTED_HUFF_CODESIZE + 1]; TOOLS_FPNG_DEFL_CLEAR_OBJ(num_codes); 335 if (static_table) 335 if (static_table) 336 { 336 { 337 for (i = 0; i < table_len; i++) num_code 337 for (i = 0; i < table_len; i++) num_codes[d->m_huff_code_sizes[table_num][i]]++; 338 } 338 } 339 else 339 else 340 { 340 { 341 defl_sym_freq syms0[DEFL_MAX_HUFF_SYMBOL 341 defl_sym_freq syms0[DEFL_MAX_HUFF_SYMBOLS], syms1[DEFL_MAX_HUFF_SYMBOLS], * pSyms; 342 int num_used_syms = 0; 342 int num_used_syms = 0; 343 const uint16_t* pSym_count = &d->m_huff_ 343 const uint16_t* pSym_count = &d->m_huff_count[table_num][0]; 344 for (i = 0; i < table_len; i++) if (pSym 344 for (i = 0; i < table_len; i++) if (pSym_count[i]) { syms0[num_used_syms].m_key = (uint16_t)pSym_count[i]; syms0[num_used_syms++].m_sym_index = (uint16_t)i; } 345 345 346 pSyms = defl_radix_sort_syms(num_used_sy 346 pSyms = defl_radix_sort_syms(num_used_syms, syms0, syms1); defl_calculate_minimum_redundancy(pSyms, num_used_syms); 347 347 348 for (i = 0; i < num_used_syms; i++) num_ 348 for (i = 0; i < num_used_syms; i++) num_codes[pSyms[i].m_key]++; 349 349 350 defl_huffman_enforce_max_code_size(num_c 350 defl_huffman_enforce_max_code_size(num_codes, num_used_syms, code_size_limit); 351 351 352 TOOLS_FPNG_DEFL_CLEAR_OBJ(d->m_huff_code 352 TOOLS_FPNG_DEFL_CLEAR_OBJ(d->m_huff_code_sizes[table_num]); TOOLS_FPNG_DEFL_CLEAR_OBJ(d->m_huff_codes[table_num]); 353 for (i = 1, j = num_used_syms; i <= code 353 for (i = 1, j = num_used_syms; i <= code_size_limit; i++) 354 for (l = num_codes[i]; l > 0; l--) d-> 354 for (l = num_codes[i]; l > 0; l--) d->m_huff_code_sizes[table_num][pSyms[--j].m_sym_index] = (uint8_t)(i); 355 } 355 } 356 356 357 next_code[1] = 0; for (j = 0, i = 2; i <= 357 next_code[1] = 0; for (j = 0, i = 2; i <= code_size_limit; i++) next_code[i] = j = ((j + num_codes[i - 1]) << 1); 358 358 359 for (i = 0; i < table_len; i++) 359 for (i = 0; i < table_len; i++) 360 { 360 { 361 uint32_t rev_code = 0, code, code_size; 361 uint32_t rev_code = 0, code, code_size; if ((code_size = d->m_huff_code_sizes[table_num][i]) == 0) continue; 362 code = next_code[code_size]++; for (l = 362 code = next_code[code_size]++; for (l = code_size; l > 0; l--, code >>= 1) rev_code = (rev_code << 1) | (code & 1); 363 d->m_huff_codes[table_num][i] = (uint16_ 363 d->m_huff_codes[table_num][i] = (uint16_t)rev_code; 364 } 364 } 365 } 365 } 366 366 367 #define TOOLS_FPNG_DEFL_RLE_PREV_CODE_SIZE() { 367 #define TOOLS_FPNG_DEFL_RLE_PREV_CODE_SIZE() { if (rle_repeat_count) { \ 368 if (rle_repeat_count < 3) { \ 368 if (rle_repeat_count < 3) { \ 369 d->m_huff_count[2][prev_code_size] = (uint 369 d->m_huff_count[2][prev_code_size] = (uint16_t)(d->m_huff_count[2][prev_code_size] + rle_repeat_count); \ 370 while (rle_repeat_count--) packed_code_siz 370 while (rle_repeat_count--) packed_code_sizes[num_packed_code_sizes++] = prev_code_size; \ 371 } else { \ 371 } else { \ 372 d->m_huff_count[2][16] = (uint16_t)(d->m_h 372 d->m_huff_count[2][16] = (uint16_t)(d->m_huff_count[2][16] + 1); packed_code_sizes[num_packed_code_sizes++] = 16; packed_code_sizes[num_packed_code_sizes++] = (uint8_t)(rle_repeat_count - 3); \ 373 } rle_repeat_count = 0; } } 373 } rle_repeat_count = 0; } } 374 374 375 #define TOOLS_FPNG_DEFL_RLE_ZERO_CODE_SIZE() { 375 #define TOOLS_FPNG_DEFL_RLE_ZERO_CODE_SIZE() { if (rle_z_count) { \ 376 if (rle_z_count < 3) { \ 376 if (rle_z_count < 3) { \ 377 d->m_huff_count[2][0] = (uint16_t)(d->m_hu 377 d->m_huff_count[2][0] = (uint16_t)(d->m_huff_count[2][0] + rle_z_count); while (rle_z_count--) packed_code_sizes[num_packed_code_sizes++] = 0; \ 378 } else if (rle_z_count <= 10) { \ 378 } else if (rle_z_count <= 10) { \ 379 d->m_huff_count[2][17] = (uint16_t)(d->m_h 379 d->m_huff_count[2][17] = (uint16_t)(d->m_huff_count[2][17] + 1); packed_code_sizes[num_packed_code_sizes++] = 17; packed_code_sizes[num_packed_code_sizes++] = (uint8_t)(rle_z_count - 3); \ 380 } else { \ 380 } else { \ 381 d->m_huff_count[2][18] = (uint16_t)(d->m_h 381 d->m_huff_count[2][18] = (uint16_t)(d->m_huff_count[2][18] + 1); packed_code_sizes[num_packed_code_sizes++] = 18; packed_code_sizes[num_packed_code_sizes++] = (uint8_t)(rle_z_count - 11); \ 382 } rle_z_count = 0; } } 382 } rle_z_count = 0; } } 383 383 384 //G.Barrand: const in the below: 384 //G.Barrand: const in the below: 385 static const uint8_t g_defl_packed_code_size 385 static const uint8_t g_defl_packed_code_size_syms_swizzle[] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 }; 386 386 387 #define TOOLS_FPNG_DEFL_DYN_PUT_BITS(bb, ll) \ 387 #define TOOLS_FPNG_DEFL_DYN_PUT_BITS(bb, ll) \ 388 do { \ 388 do { \ 389 uint32_t b = (bb), l = (ll); \ 389 uint32_t b = (bb), l = (ll); \ 390 assert((l) >= 1 && (l) <= 16); assert((b) < 390 assert((l) >= 1 && (l) <= 16); assert((b) < (1ULL << (l))); \ 391 bit_buf |= (((uint64_t)(b)) << bit_buf_size) 391 bit_buf |= (((uint64_t)(b)) << bit_buf_size); bit_buf_size += (l); assert(bit_buf_size <= 64); \ 392 while (bit_buf_size >= 8) \ 392 while (bit_buf_size >= 8) \ 393 { \ 393 { \ 394 if ((dst_ofs + 1) > dst_buf_size) \ 394 if ((dst_ofs + 1) > dst_buf_size) \ 395 return false; \ 395 return false; \ 396 *(uint8_t*)(pDst + dst_ofs) = (uint8_t)bit 396 *(uint8_t*)(pDst + dst_ofs) = (uint8_t)bit_buf; \ 397 dst_ofs++; \ 397 dst_ofs++; \ 398 bit_buf >>= 8; \ 398 bit_buf >>= 8; \ 399 bit_buf_size -= 8; \ 399 bit_buf_size -= 8; \ 400 } \ 400 } \ 401 } while(0) 401 } while(0) 402 402 403 static bool defl_start_dynamic_block(defl_hu 403 static bool defl_start_dynamic_block(defl_huff* d, uint8_t* pDst, uint32_t& dst_ofs, uint32_t dst_buf_size, uint64_t& bit_buf, int& bit_buf_size) 404 { 404 { 405 int num_lit_codes, num_dist_codes, num_bit 405 int num_lit_codes, num_dist_codes, num_bit_lengths; uint32_t i, total_code_sizes_to_pack, num_packed_code_sizes, rle_z_count, rle_repeat_count, packed_code_sizes_index; 406 uint8_t code_sizes_to_pack[DEFL_MAX_HUFF_S 406 uint8_t code_sizes_to_pack[DEFL_MAX_HUFF_SYMBOLS_0 + DEFL_MAX_HUFF_SYMBOLS_1], packed_code_sizes[DEFL_MAX_HUFF_SYMBOLS_0 + DEFL_MAX_HUFF_SYMBOLS_1], prev_code_size = 0xFF; 407 407 408 d->m_huff_count[0][256] = 1; 408 d->m_huff_count[0][256] = 1; 409 409 410 defl_optimize_huffman_table(d, 0, DEFL_MAX 410 defl_optimize_huffman_table(d, 0, DEFL_MAX_HUFF_SYMBOLS_0, 12, FPNG_FALSE); 411 defl_optimize_huffman_table(d, 1, DEFL_MAX 411 defl_optimize_huffman_table(d, 1, DEFL_MAX_HUFF_SYMBOLS_1, 12, FPNG_FALSE); 412 412 413 for (num_lit_codes = 286; num_lit_codes > 413 for (num_lit_codes = 286; num_lit_codes > 257; num_lit_codes--) if (d->m_huff_code_sizes[0][num_lit_codes - 1]) break; 414 for (num_dist_codes = 30; num_dist_codes > 414 for (num_dist_codes = 30; num_dist_codes > 1; num_dist_codes--) if (d->m_huff_code_sizes[1][num_dist_codes - 1]) break; 415 415 416 memcpy(code_sizes_to_pack, &d->m_huff_code 416 memcpy(code_sizes_to_pack, &d->m_huff_code_sizes[0][0], num_lit_codes); 417 memcpy(code_sizes_to_pack + num_lit_codes, 417 memcpy(code_sizes_to_pack + num_lit_codes, &d->m_huff_code_sizes[1][0], num_dist_codes); 418 total_code_sizes_to_pack = num_lit_codes + 418 total_code_sizes_to_pack = num_lit_codes + num_dist_codes; num_packed_code_sizes = 0; rle_z_count = 0; rle_repeat_count = 0; 419 419 420 memset(&d->m_huff_count[2][0], 0, sizeof(d 420 memset(&d->m_huff_count[2][0], 0, sizeof(d->m_huff_count[2][0]) * DEFL_MAX_HUFF_SYMBOLS_2); 421 for (i = 0; i < total_code_sizes_to_pack; 421 for (i = 0; i < total_code_sizes_to_pack; i++) 422 { 422 { 423 uint8_t code_size = code_sizes_to_pack[i 423 uint8_t code_size = code_sizes_to_pack[i]; 424 if (!code_size) 424 if (!code_size) 425 { 425 { 426 TOOLS_FPNG_DEFL_RLE_PREV_CODE_SIZE(); 426 TOOLS_FPNG_DEFL_RLE_PREV_CODE_SIZE(); 427 if (++rle_z_count == 138) { TOOLS_FPNG 427 if (++rle_z_count == 138) { TOOLS_FPNG_DEFL_RLE_ZERO_CODE_SIZE(); } 428 } 428 } 429 else 429 else 430 { 430 { 431 TOOLS_FPNG_DEFL_RLE_ZERO_CODE_SIZE(); 431 TOOLS_FPNG_DEFL_RLE_ZERO_CODE_SIZE(); 432 if (code_size != prev_code_size) 432 if (code_size != prev_code_size) 433 { 433 { 434 TOOLS_FPNG_DEFL_RLE_PREV_CODE_SIZE() 434 TOOLS_FPNG_DEFL_RLE_PREV_CODE_SIZE(); 435 d->m_huff_count[2][code_size] = (uin 435 d->m_huff_count[2][code_size] = (uint16_t)(d->m_huff_count[2][code_size] + 1); packed_code_sizes[num_packed_code_sizes++] = code_size; 436 } 436 } 437 else if (++rle_repeat_count == 6) 437 else if (++rle_repeat_count == 6) 438 { 438 { 439 TOOLS_FPNG_DEFL_RLE_PREV_CODE_SIZE() 439 TOOLS_FPNG_DEFL_RLE_PREV_CODE_SIZE(); 440 } 440 } 441 } 441 } 442 prev_code_size = code_size; 442 prev_code_size = code_size; 443 } 443 } 444 if (rle_repeat_count) { TOOLS_FPNG_DEFL_RL 444 if (rle_repeat_count) { TOOLS_FPNG_DEFL_RLE_PREV_CODE_SIZE(); } 445 else { TOOLS_FPNG_DEFL_RLE_ZERO_CODE_SIZE( 445 else { TOOLS_FPNG_DEFL_RLE_ZERO_CODE_SIZE(); } 446 446 447 defl_optimize_huffman_table(d, 2, DEFL_MAX 447 defl_optimize_huffman_table(d, 2, DEFL_MAX_HUFF_SYMBOLS_2, 7, FPNG_FALSE); 448 448 449 // max of 2+5+5+4+18*3+(288+32)*7=2310 bit 449 // max of 2+5+5+4+18*3+(288+32)*7=2310 bits 450 TOOLS_FPNG_DEFL_DYN_PUT_BITS(2, 2); 450 TOOLS_FPNG_DEFL_DYN_PUT_BITS(2, 2); 451 451 452 TOOLS_FPNG_DEFL_DYN_PUT_BITS(num_lit_codes 452 TOOLS_FPNG_DEFL_DYN_PUT_BITS(num_lit_codes - 257, 5); 453 TOOLS_FPNG_DEFL_DYN_PUT_BITS(num_dist_code 453 TOOLS_FPNG_DEFL_DYN_PUT_BITS(num_dist_codes - 1, 5); 454 454 455 for (num_bit_lengths = 18; num_bit_lengths 455 for (num_bit_lengths = 18; num_bit_lengths >= 0; num_bit_lengths--) if (d->m_huff_code_sizes[2][g_defl_packed_code_size_syms_swizzle[num_bit_lengths]]) break; 456 num_bit_lengths = maximum<int>(4, (num_bit 456 num_bit_lengths = maximum<int>(4, (num_bit_lengths + 1)); TOOLS_FPNG_DEFL_DYN_PUT_BITS(num_bit_lengths - 4, 4); 457 for (i = 0; (int)i < num_bit_lengths; i++) 457 for (i = 0; (int)i < num_bit_lengths; i++) TOOLS_FPNG_DEFL_DYN_PUT_BITS(d->m_huff_code_sizes[2][g_defl_packed_code_size_syms_swizzle[i]], 3); 458 458 459 for (packed_code_sizes_index = 0; packed_c 459 for (packed_code_sizes_index = 0; packed_code_sizes_index < num_packed_code_sizes; ) 460 { 460 { 461 uint32_t code = packed_code_sizes[packed 461 uint32_t code = packed_code_sizes[packed_code_sizes_index++]; assert(code < DEFL_MAX_HUFF_SYMBOLS_2); 462 TOOLS_FPNG_DEFL_DYN_PUT_BITS(d->m_huff_c 462 TOOLS_FPNG_DEFL_DYN_PUT_BITS(d->m_huff_codes[2][code], d->m_huff_code_sizes[2][code]); 463 if (code >= 16) TOOLS_FPNG_DEFL_DYN_PUT_ 463 if (code >= 16) TOOLS_FPNG_DEFL_DYN_PUT_BITS(packed_code_sizes[packed_code_sizes_index++], "\02\03\07"[code - 16]); 464 } 464 } 465 465 466 return true; 466 return true; 467 } 467 } 468 468 469 static uint32_t write_raw_block(const uint8_ 469 static uint32_t write_raw_block(const uint8_t* pSrc, uint32_t src_len, uint8_t* pDst, uint32_t dst_buf_size) 470 { 470 { 471 if (dst_buf_size < 2) 471 if (dst_buf_size < 2) 472 return 0; 472 return 0; 473 473 474 pDst[0] = 0x78; 474 pDst[0] = 0x78; 475 pDst[1] = 0x01; 475 pDst[1] = 0x01; 476 476 477 uint32_t dst_ofs = 2; 477 uint32_t dst_ofs = 2; 478 478 479 uint32_t src_ofs = 0; 479 uint32_t src_ofs = 0; 480 while (src_ofs < src_len) 480 while (src_ofs < src_len) 481 { 481 { 482 const uint32_t src_remaining = src_len - 482 const uint32_t src_remaining = src_len - src_ofs; 483 const uint32_t block_size = minimum<uint 483 const uint32_t block_size = minimum<uint32_t>(UINT16_MAX, src_remaining); 484 const bool final_block = (block_size == 484 const bool final_block = (block_size == src_remaining); 485 485 486 if ((dst_ofs + 5 + block_size) > dst_buf 486 if ((dst_ofs + 5 + block_size) > dst_buf_size) 487 return 0; 487 return 0; 488 488 489 pDst[dst_ofs + 0] = final_block ? 1 : 0; 489 pDst[dst_ofs + 0] = final_block ? 1 : 0; 490 490 491 pDst[dst_ofs + 1] = block_size & 0xFF; 491 pDst[dst_ofs + 1] = block_size & 0xFF; 492 pDst[dst_ofs + 2] = (block_size >> 8) & 492 pDst[dst_ofs + 2] = (block_size >> 8) & 0xFF; 493 493 494 pDst[dst_ofs + 3] = (~block_size) & 0xFF 494 pDst[dst_ofs + 3] = (~block_size) & 0xFF; 495 pDst[dst_ofs + 4] = ((~block_size) >> 8) 495 pDst[dst_ofs + 4] = ((~block_size) >> 8) & 0xFF; 496 496 497 memcpy(pDst + dst_ofs + 5, pSrc + src_of 497 memcpy(pDst + dst_ofs + 5, pSrc + src_ofs, block_size); 498 498 499 src_ofs += block_size; 499 src_ofs += block_size; 500 dst_ofs += 5 + block_size; 500 dst_ofs += 5 + block_size; 501 } 501 } 502 502 503 uint32_t src_adler32 = fpng_adler32(pSrc, 503 uint32_t src_adler32 = fpng_adler32(pSrc, src_len, FPNG_ADLER32_INIT); 504 504 505 for (uint32_t i = 0; i < 4; i++) 505 for (uint32_t i = 0; i < 4; i++) 506 { 506 { 507 if (dst_ofs + 1 > dst_buf_size) 507 if (dst_ofs + 1 > dst_buf_size) 508 return 0; 508 return 0; 509 509 510 pDst[dst_ofs] = (uint8_t)(src_adler32 >> 510 pDst[dst_ofs] = (uint8_t)(src_adler32 >> 24); 511 dst_ofs++; 511 dst_ofs++; 512 512 513 src_adler32 <<= 8; 513 src_adler32 <<= 8; 514 } 514 } 515 515 516 return dst_ofs; 516 return dst_ofs; 517 } 517 } 518 518 519 static void adjust_freq32(uint32_t num_freq, 519 static void adjust_freq32(uint32_t num_freq, uint32_t* pFreq, uint16_t* pFreq16) 520 { 520 { 521 uint32_t total_freq = 0; 521 uint32_t total_freq = 0; 522 for (uint32_t i = 0; i < num_freq; i++) 522 for (uint32_t i = 0; i < num_freq; i++) 523 total_freq += pFreq[i]; 523 total_freq += pFreq[i]; 524 524 525 if (!total_freq) 525 if (!total_freq) 526 { 526 { 527 memset(pFreq16, 0, num_freq * sizeof(uin 527 memset(pFreq16, 0, num_freq * sizeof(uint16_t)); 528 return; 528 return; 529 } 529 } 530 530 531 uint32_t total_freq16 = 0; 531 uint32_t total_freq16 = 0; 532 for (uint32_t i = 0; i < num_freq; i++) 532 for (uint32_t i = 0; i < num_freq; i++) 533 { 533 { 534 uint64_t f = pFreq[i]; 534 uint64_t f = pFreq[i]; 535 if (!f) 535 if (!f) 536 { 536 { 537 pFreq16[i] = 0; 537 pFreq16[i] = 0; 538 continue; 538 continue; 539 } 539 } 540 540 541 pFreq16[i] = (uint16_t)maximum<uint32_t> 541 pFreq16[i] = (uint16_t)maximum<uint32_t>(1, (uint32_t)((f * UINT16_MAX) / total_freq)); 542 542 543 total_freq16 += pFreq16[i]; 543 total_freq16 += pFreq16[i]; 544 } 544 } 545 545 546 while (total_freq16 > UINT16_MAX) 546 while (total_freq16 > UINT16_MAX) 547 { 547 { 548 total_freq16 = 0; 548 total_freq16 = 0; 549 for (uint32_t i = 0; i < num_freq; i++) 549 for (uint32_t i = 0; i < num_freq; i++) 550 { 550 { 551 if (pFreq[i]) 551 if (pFreq[i]) 552 { 552 { 553 pFreq[i] = maximum<uint32_t>(1, pFre 553 pFreq[i] = maximum<uint32_t>(1, pFreq[i] >> 1); 554 total_freq16 += pFreq[i]; 554 total_freq16 += pFreq[i]; 555 } 555 } 556 } 556 } 557 } 557 } 558 } 558 } 559 559 560 static uint32_t pixel_deflate_dyn_3_rle( 560 static uint32_t pixel_deflate_dyn_3_rle( 561 const uint8_t* pImg, uint32_t w, uint32_t 561 const uint8_t* pImg, uint32_t w, uint32_t h, 562 uint8_t* pDst, uint32_t dst_buf_size) 562 uint8_t* pDst, uint32_t dst_buf_size) 563 { 563 { 564 const uint32_t bpl = 1 + w * 3; 564 const uint32_t bpl = 1 + w * 3; 565 565 566 uint64_t bit_buf = 0; 566 uint64_t bit_buf = 0; 567 int bit_buf_size = 0; 567 int bit_buf_size = 0; 568 568 569 uint32_t dst_ofs = 0; 569 uint32_t dst_ofs = 0; 570 570 571 // zlib header 571 // zlib header 572 TOOLS_FPNG_PUT_BITS(0x78, 8); 572 TOOLS_FPNG_PUT_BITS(0x78, 8); 573 TOOLS_FPNG_PUT_BITS(0x01, 8); 573 TOOLS_FPNG_PUT_BITS(0x01, 8); 574 574 575 // write BFINAL bit 575 // write BFINAL bit 576 TOOLS_FPNG_PUT_BITS(1, 1); 576 TOOLS_FPNG_PUT_BITS(1, 1); 577 577 578 std::vector<uint32_t> codes((w + 1) * h); 578 std::vector<uint32_t> codes((w + 1) * h); 579 uint32_t* pDst_codes = codes.data(); 579 uint32_t* pDst_codes = codes.data(); 580 580 581 uint32_t lit_freq[DEFL_MAX_HUFF_SYMBOLS_0] 581 uint32_t lit_freq[DEFL_MAX_HUFF_SYMBOLS_0]; 582 memset(lit_freq, 0, sizeof(lit_freq)); 582 memset(lit_freq, 0, sizeof(lit_freq)); 583 583 584 const uint8_t* pSrc = pImg; 584 const uint8_t* pSrc = pImg; 585 uint32_t src_ofs = 0; 585 uint32_t src_ofs = 0; 586 586 587 uint32_t src_adler32 = fpng_adler32(pImg, 587 uint32_t src_adler32 = fpng_adler32(pImg, bpl * h, FPNG_ADLER32_INIT); 588 588 589 const uint32_t dist_sym = g_defl_small_dis 589 const uint32_t dist_sym = g_defl_small_dist_sym[3 - 1]; 590 590 591 for (uint32_t y = 0; y < h; y++) 591 for (uint32_t y = 0; y < h; y++) 592 { 592 { 593 const uint32_t end_src_ofs = src_ofs + b 593 const uint32_t end_src_ofs = src_ofs + bpl; 594 594 595 const uint32_t filter_lit = pSrc[src_ofs 595 const uint32_t filter_lit = pSrc[src_ofs++]; 596 *pDst_codes++ = 1 | (filter_lit << 8); 596 *pDst_codes++ = 1 | (filter_lit << 8); 597 lit_freq[filter_lit]++; 597 lit_freq[filter_lit]++; 598 598 599 uint32_t prev_lits; 599 uint32_t prev_lits; 600 600 601 { 601 { 602 uint32_t lits = READ_RGB_PIXEL(pSrc + 602 uint32_t lits = READ_RGB_PIXEL(pSrc + src_ofs); 603 603 604 *pDst_codes++ = lits << 8; 604 *pDst_codes++ = lits << 8; 605 605 606 lit_freq[lits & 0xFF]++; 606 lit_freq[lits & 0xFF]++; 607 lit_freq[(lits >> 8) & 0xFF]++; 607 lit_freq[(lits >> 8) & 0xFF]++; 608 lit_freq[lits >> 16]++; 608 lit_freq[lits >> 16]++; 609 609 610 src_ofs += 3; 610 src_ofs += 3; 611 611 612 prev_lits = lits; 612 prev_lits = lits; 613 } 613 } 614 614 615 while (src_ofs < end_src_ofs) 615 while (src_ofs < end_src_ofs) 616 { 616 { 617 uint32_t lits = READ_RGB_PIXEL(pSrc + 617 uint32_t lits = READ_RGB_PIXEL(pSrc + src_ofs); 618 618 619 if (lits == prev_lits) 619 if (lits == prev_lits) 620 { 620 { 621 uint32_t match_len = 3; 621 uint32_t match_len = 3; 622 uint32_t max_match_len = minimum<int 622 uint32_t max_match_len = minimum<int>(255, (int)(end_src_ofs - src_ofs)); 623 623 624 while (match_len < max_match_len) 624 while (match_len < max_match_len) 625 { 625 { 626 if (READ_RGB_PIXEL(pSrc + src_ofs 626 if (READ_RGB_PIXEL(pSrc + src_ofs + match_len) != lits) 627 break; 627 break; 628 match_len += 3; 628 match_len += 3; 629 } 629 } 630 630 631 *pDst_codes++ = match_len - 1; 631 *pDst_codes++ = match_len - 1; 632 632 633 uint32_t adj_match_len = match_len - 633 uint32_t adj_match_len = match_len - 3; 634 634 635 lit_freq[g_defl_len_sym[adj_match_le 635 lit_freq[g_defl_len_sym[adj_match_len]]++; 636 636 637 src_ofs += match_len; 637 src_ofs += match_len; 638 } 638 } 639 else 639 else 640 { 640 { 641 *pDst_codes++ = lits << 8; 641 *pDst_codes++ = lits << 8; 642 642 643 lit_freq[lits & 0xFF]++; 643 lit_freq[lits & 0xFF]++; 644 lit_freq[(lits >> 8) & 0xFF]++; 644 lit_freq[(lits >> 8) & 0xFF]++; 645 lit_freq[lits >> 16]++; 645 lit_freq[lits >> 16]++; 646 646 647 prev_lits = lits; 647 prev_lits = lits; 648 648 649 src_ofs += 3; 649 src_ofs += 3; 650 } 650 } 651 651 652 } // while (src_ofs < end_src_ofs) 652 } // while (src_ofs < end_src_ofs) 653 653 654 } // y 654 } // y 655 655 656 assert(src_ofs == h * bpl); 656 assert(src_ofs == h * bpl); 657 const uint32_t total_codes = (uint32_t)(pD 657 const uint32_t total_codes = (uint32_t)(pDst_codes - codes.data()); 658 assert(total_codes <= codes.size()); 658 assert(total_codes <= codes.size()); 659 659 660 defl_huff dh; 660 defl_huff dh; 661 661 662 lit_freq[256] = 1; 662 lit_freq[256] = 1; 663 663 664 adjust_freq32(DEFL_MAX_HUFF_SYMBOLS_0, lit 664 adjust_freq32(DEFL_MAX_HUFF_SYMBOLS_0, lit_freq, &dh.m_huff_count[0][0]); 665 665 666 memset(&dh.m_huff_count[1][0], 0, sizeof(d 666 memset(&dh.m_huff_count[1][0], 0, sizeof(dh.m_huff_count[1][0]) * DEFL_MAX_HUFF_SYMBOLS_1); 667 dh.m_huff_count[1][dist_sym] = 1; 667 dh.m_huff_count[1][dist_sym] = 1; 668 dh.m_huff_count[1][dist_sym + 1] = 1; // t 668 dh.m_huff_count[1][dist_sym + 1] = 1; // to workaround a bug in wuffs decoder 669 669 670 if (!defl_start_dynamic_block(&dh, pDst, d 670 if (!defl_start_dynamic_block(&dh, pDst, dst_ofs, dst_buf_size, bit_buf, bit_buf_size)) 671 return 0; 671 return 0; 672 672 673 assert(bit_buf_size <= 7); 673 assert(bit_buf_size <= 7); 674 assert(dh.m_huff_codes[1][dist_sym] == 0 & 674 assert(dh.m_huff_codes[1][dist_sym] == 0 && dh.m_huff_code_sizes[1][dist_sym] == 1); 675 675 676 for (uint32_t i = 0; i < total_codes; i++) 676 for (uint32_t i = 0; i < total_codes; i++) 677 { 677 { 678 uint32_t c = codes[i]; 678 uint32_t c = codes[i]; 679 679 680 uint32_t c_type = c & 0xFF; 680 uint32_t c_type = c & 0xFF; 681 if (c_type == 0) 681 if (c_type == 0) 682 { 682 { 683 uint32_t lits = c >> 8; 683 uint32_t lits = c >> 8; 684 684 685 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes 685 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes[0][lits & 0xFF], dh.m_huff_code_sizes[0][lits & 0xFF]); 686 lits >>= 8; 686 lits >>= 8; 687 687 688 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes 688 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes[0][lits & 0xFF], dh.m_huff_code_sizes[0][lits & 0xFF]); 689 lits >>= 8; 689 lits >>= 8; 690 690 691 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes 691 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes[0][lits], dh.m_huff_code_sizes[0][lits]); 692 } 692 } 693 else if (c_type == 1) 693 else if (c_type == 1) 694 { 694 { 695 uint32_t lit = c >> 8; 695 uint32_t lit = c >> 8; 696 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes 696 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes[0][lit], dh.m_huff_code_sizes[0][lit]); 697 } 697 } 698 else 698 else 699 { 699 { 700 uint32_t match_len = c_type + 1; 700 uint32_t match_len = c_type + 1; 701 701 702 uint32_t adj_match_len = match_len - 3 702 uint32_t adj_match_len = match_len - 3; 703 703 704 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes 704 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes[0][g_defl_len_sym[adj_match_len]], dh.m_huff_code_sizes[0][g_defl_len_sym[adj_match_len]]); 705 TOOLS_FPNG_PUT_BITS(adj_match_len & g_ 705 TOOLS_FPNG_PUT_BITS(adj_match_len & g_bitmasks[g_defl_len_extra[adj_match_len]], g_defl_len_extra[adj_match_len] + 1); // up to 6 bits, +1 for the match distance Huff code which is always 0 706 706 707 // no need to write the distance code, 707 // no need to write the distance code, it's always 0 708 //TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_cod 708 //TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes[1][dist_sym], dh.m_huff_code_sizes[1][dist_sym]); 709 } 709 } 710 710 711 // up to 55 bits 711 // up to 55 bits 712 TOOLS_FPNG_PUT_BITS_FLUSH; 712 TOOLS_FPNG_PUT_BITS_FLUSH; 713 } 713 } 714 714 715 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes[0][ 715 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes[0][256], dh.m_huff_code_sizes[0][256]); 716 716 717 TOOLS_FPNG_PUT_BITS_FORCE_FLUSH; 717 TOOLS_FPNG_PUT_BITS_FORCE_FLUSH; 718 718 719 // Write zlib adler32 719 // Write zlib adler32 720 for (uint32_t i = 0; i < 4; i++) 720 for (uint32_t i = 0; i < 4; i++) 721 { 721 { 722 if ((dst_ofs + 1) > dst_buf_size) 722 if ((dst_ofs + 1) > dst_buf_size) 723 return 0; 723 return 0; 724 *(uint8_t*)(pDst + dst_ofs) = (uint8_t)( 724 *(uint8_t*)(pDst + dst_ofs) = (uint8_t)(src_adler32 >> 24); 725 dst_ofs++; 725 dst_ofs++; 726 726 727 src_adler32 <<= 8; 727 src_adler32 <<= 8; 728 } 728 } 729 729 730 return dst_ofs; 730 return dst_ofs; 731 } 731 } 732 732 733 static uint32_t pixel_deflate_dyn_3_rle_one_ 733 static uint32_t pixel_deflate_dyn_3_rle_one_pass( 734 const uint8_t* pImg, uint32_t w, uint32_t 734 const uint8_t* pImg, uint32_t w, uint32_t h, 735 uint8_t* pDst, uint32_t dst_buf_size) 735 uint8_t* pDst, uint32_t dst_buf_size) 736 { 736 { 737 const uint32_t bpl = 1 + w * 3; 737 const uint32_t bpl = 1 + w * 3; 738 738 739 if (dst_buf_size < sizeof(g_dyn_huff_3)) 739 if (dst_buf_size < sizeof(g_dyn_huff_3)) 740 return false; 740 return false; 741 memcpy(pDst, g_dyn_huff_3, sizeof(g_dyn_hu 741 memcpy(pDst, g_dyn_huff_3, sizeof(g_dyn_huff_3)); 742 uint32_t dst_ofs = sizeof(g_dyn_huff_3); 742 uint32_t dst_ofs = sizeof(g_dyn_huff_3); 743 743 744 uint64_t bit_buf = DYN_HUFF_3_BITBUF; 744 uint64_t bit_buf = DYN_HUFF_3_BITBUF; 745 int bit_buf_size = DYN_HUFF_3_BITBUF_SIZE; 745 int bit_buf_size = DYN_HUFF_3_BITBUF_SIZE; 746 746 747 const uint8_t* pSrc = pImg; 747 const uint8_t* pSrc = pImg; 748 uint32_t src_ofs = 0; 748 uint32_t src_ofs = 0; 749 749 750 uint32_t src_adler32 = fpng_adler32(pImg, 750 uint32_t src_adler32 = fpng_adler32(pImg, bpl * h, FPNG_ADLER32_INIT); 751 751 752 for (uint32_t y = 0; y < h; y++) 752 for (uint32_t y = 0; y < h; y++) 753 { 753 { 754 const uint32_t end_src_ofs = src_ofs + b 754 const uint32_t end_src_ofs = src_ofs + bpl; 755 755 756 const uint32_t filter_lit = pSrc[src_ofs 756 const uint32_t filter_lit = pSrc[src_ofs++]; 757 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_3_code 757 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_3_codes[filter_lit].m_code, g_dyn_huff_3_codes[filter_lit].m_code_size); 758 758 759 uint32_t prev_lits; 759 uint32_t prev_lits; 760 760 761 { 761 { 762 uint32_t lits = READ_RGB_PIXEL(pSrc + 762 uint32_t lits = READ_RGB_PIXEL(pSrc + src_ofs); 763 763 764 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_3_co 764 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_3_codes[lits & 0xFF].m_code, g_dyn_huff_3_codes[lits & 0xFF].m_code_size); 765 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_3_co 765 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_3_codes[(lits >> 8) & 0xFF].m_code, g_dyn_huff_3_codes[(lits >> 8) & 0xFF].m_code_size); 766 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_3_co 766 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_3_codes[(lits >> 16)].m_code, g_dyn_huff_3_codes[(lits >> 16)].m_code_size); 767 767 768 src_ofs += 3; 768 src_ofs += 3; 769 769 770 prev_lits = lits; 770 prev_lits = lits; 771 } 771 } 772 772 773 TOOLS_FPNG_PUT_BITS_FLUSH; 773 TOOLS_FPNG_PUT_BITS_FLUSH; 774 774 775 while (src_ofs < end_src_ofs) 775 while (src_ofs < end_src_ofs) 776 { 776 { 777 uint32_t lits = READ_RGB_PIXEL(pSrc + 777 uint32_t lits = READ_RGB_PIXEL(pSrc + src_ofs); 778 778 779 if (lits == prev_lits) 779 if (lits == prev_lits) 780 { 780 { 781 uint32_t match_len = 3; 781 uint32_t match_len = 3; 782 uint32_t max_match_len = minimum<int 782 uint32_t max_match_len = minimum<int>(255, (int)(end_src_ofs - src_ofs)); 783 783 784 while (match_len < max_match_len) 784 while (match_len < max_match_len) 785 { 785 { 786 if (READ_RGB_PIXEL(pSrc + src_ofs 786 if (READ_RGB_PIXEL(pSrc + src_ofs + match_len) != lits) 787 break; 787 break; 788 match_len += 3; 788 match_len += 3; 789 } 789 } 790 790 791 uint32_t adj_match_len = match_len - 791 uint32_t adj_match_len = match_len - 3; 792 792 793 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_3_ 793 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_3_codes[g_defl_len_sym[adj_match_len]].m_code, g_dyn_huff_3_codes[g_defl_len_sym[adj_match_len]].m_code_size); 794 TOOLS_FPNG_PUT_BITS(adj_match_len & 794 TOOLS_FPNG_PUT_BITS(adj_match_len & g_bitmasks[g_defl_len_extra[adj_match_len]], g_defl_len_extra[adj_match_len] + 1); // up to 6 bits, +1 for the match distance Huff code which is always 0 795 795 796 src_ofs += match_len; 796 src_ofs += match_len; 797 } 797 } 798 else 798 else 799 { 799 { 800 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_3_ 800 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_3_codes[lits & 0xFF].m_code, g_dyn_huff_3_codes[lits & 0xFF].m_code_size); 801 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_3_ 801 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_3_codes[(lits >> 8) & 0xFF].m_code, g_dyn_huff_3_codes[(lits >> 8) & 0xFF].m_code_size); 802 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_3_ 802 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_3_codes[(lits >> 16)].m_code, g_dyn_huff_3_codes[(lits >> 16)].m_code_size); 803 803 804 prev_lits = lits; 804 prev_lits = lits; 805 805 806 src_ofs += 3; 806 src_ofs += 3; 807 } 807 } 808 808 809 TOOLS_FPNG_PUT_BITS_FLUSH; 809 TOOLS_FPNG_PUT_BITS_FLUSH; 810 810 811 } // while (src_ofs < end_src_ofs) 811 } // while (src_ofs < end_src_ofs) 812 812 813 } // y 813 } // y 814 814 815 assert(src_ofs == h * bpl); 815 assert(src_ofs == h * bpl); 816 816 817 assert(bit_buf_size <= 7); 817 assert(bit_buf_size <= 7); 818 818 819 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_3_codes[ 819 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_3_codes[256].m_code, g_dyn_huff_3_codes[256].m_code_size); 820 820 821 TOOLS_FPNG_PUT_BITS_FORCE_FLUSH; 821 TOOLS_FPNG_PUT_BITS_FORCE_FLUSH; 822 822 823 // Write zlib adler32 823 // Write zlib adler32 824 for (uint32_t i = 0; i < 4; i++) 824 for (uint32_t i = 0; i < 4; i++) 825 { 825 { 826 if ((dst_ofs + 1) > dst_buf_size) 826 if ((dst_ofs + 1) > dst_buf_size) 827 return 0; 827 return 0; 828 *(uint8_t*)(pDst + dst_ofs) = (uint8_t)( 828 *(uint8_t*)(pDst + dst_ofs) = (uint8_t)(src_adler32 >> 24); 829 dst_ofs++; 829 dst_ofs++; 830 830 831 src_adler32 <<= 8; 831 src_adler32 <<= 8; 832 } 832 } 833 833 834 return dst_ofs; 834 return dst_ofs; 835 } 835 } 836 836 837 static uint32_t pixel_deflate_dyn_4_rle( 837 static uint32_t pixel_deflate_dyn_4_rle( 838 const uint8_t* pImg, uint32_t w, uint32_t 838 const uint8_t* pImg, uint32_t w, uint32_t h, 839 uint8_t* pDst, uint32_t dst_buf_size) 839 uint8_t* pDst, uint32_t dst_buf_size) 840 { 840 { 841 const uint32_t bpl = 1 + w * 4; 841 const uint32_t bpl = 1 + w * 4; 842 842 843 uint64_t bit_buf = 0; 843 uint64_t bit_buf = 0; 844 int bit_buf_size = 0; 844 int bit_buf_size = 0; 845 845 846 uint32_t dst_ofs = 0; 846 uint32_t dst_ofs = 0; 847 847 848 // zlib header 848 // zlib header 849 TOOLS_FPNG_PUT_BITS(0x78, 8); 849 TOOLS_FPNG_PUT_BITS(0x78, 8); 850 TOOLS_FPNG_PUT_BITS(0x01, 8); 850 TOOLS_FPNG_PUT_BITS(0x01, 8); 851 851 852 // write BFINAL bit 852 // write BFINAL bit 853 TOOLS_FPNG_PUT_BITS(1, 1); 853 TOOLS_FPNG_PUT_BITS(1, 1); 854 854 855 std::vector<uint64_t> codes; 855 std::vector<uint64_t> codes; 856 codes.resize((w + 1) * h); 856 codes.resize((w + 1) * h); 857 uint64_t* pDst_codes = codes.data(); 857 uint64_t* pDst_codes = codes.data(); 858 858 859 uint32_t lit_freq[DEFL_MAX_HUFF_SYMBOLS_0] 859 uint32_t lit_freq[DEFL_MAX_HUFF_SYMBOLS_0]; 860 memset(lit_freq, 0, sizeof(lit_freq)); 860 memset(lit_freq, 0, sizeof(lit_freq)); 861 861 862 const uint8_t* pSrc = pImg; 862 const uint8_t* pSrc = pImg; 863 uint32_t src_ofs = 0; 863 uint32_t src_ofs = 0; 864 864 865 uint32_t src_adler32 = fpng_adler32(pImg, 865 uint32_t src_adler32 = fpng_adler32(pImg, bpl * h, FPNG_ADLER32_INIT); 866 866 867 const uint32_t dist_sym = g_defl_small_dis 867 const uint32_t dist_sym = g_defl_small_dist_sym[4 - 1]; 868 868 869 for (uint32_t y = 0; y < h; y++) 869 for (uint32_t y = 0; y < h; y++) 870 { 870 { 871 const uint32_t end_src_ofs = src_ofs + b 871 const uint32_t end_src_ofs = src_ofs + bpl; 872 872 873 const uint32_t filter_lit = pSrc[src_ofs 873 const uint32_t filter_lit = pSrc[src_ofs++]; 874 *pDst_codes++ = 1 | (filter_lit << 8); 874 *pDst_codes++ = 1 | (filter_lit << 8); 875 lit_freq[filter_lit]++; 875 lit_freq[filter_lit]++; 876 876 877 uint32_t prev_lits; 877 uint32_t prev_lits; 878 { 878 { 879 uint32_t lits = READ_LE32(pSrc + src_o 879 uint32_t lits = READ_LE32(pSrc + src_ofs); 880 880 881 *pDst_codes++ = (uint64_t)lits << 8; 881 *pDst_codes++ = (uint64_t)lits << 8; 882 882 883 lit_freq[lits & 0xFF]++; 883 lit_freq[lits & 0xFF]++; 884 lit_freq[(lits >> 8) & 0xFF]++; 884 lit_freq[(lits >> 8) & 0xFF]++; 885 lit_freq[(lits >> 16) & 0xFF]++; 885 lit_freq[(lits >> 16) & 0xFF]++; 886 lit_freq[lits >> 24]++; 886 lit_freq[lits >> 24]++; 887 887 888 src_ofs += 4; 888 src_ofs += 4; 889 889 890 prev_lits = lits; 890 prev_lits = lits; 891 } 891 } 892 892 893 while (src_ofs < end_src_ofs) 893 while (src_ofs < end_src_ofs) 894 { 894 { 895 uint32_t lits = READ_LE32(pSrc + src_o 895 uint32_t lits = READ_LE32(pSrc + src_ofs); 896 896 897 if (lits == prev_lits) 897 if (lits == prev_lits) 898 { 898 { 899 uint32_t match_len = 4; 899 uint32_t match_len = 4; 900 uint32_t max_match_len = minimum<int 900 uint32_t max_match_len = minimum<int>(252, (int)(end_src_ofs - src_ofs)); 901 901 902 while (match_len < max_match_len) 902 while (match_len < max_match_len) 903 { 903 { 904 if (READ_LE32(pSrc + src_ofs + mat 904 if (READ_LE32(pSrc + src_ofs + match_len) != lits) 905 break; 905 break; 906 match_len += 4; 906 match_len += 4; 907 } 907 } 908 908 909 *pDst_codes++ = match_len - 1; 909 *pDst_codes++ = match_len - 1; 910 910 911 uint32_t adj_match_len = match_len - 911 uint32_t adj_match_len = match_len - 3; 912 912 913 lit_freq[g_defl_len_sym[adj_match_le 913 lit_freq[g_defl_len_sym[adj_match_len]]++; 914 914 915 src_ofs += match_len; 915 src_ofs += match_len; 916 } 916 } 917 else 917 else 918 { 918 { 919 *pDst_codes++ = (uint64_t)lits << 8; 919 *pDst_codes++ = (uint64_t)lits << 8; 920 920 921 lit_freq[lits & 0xFF]++; 921 lit_freq[lits & 0xFF]++; 922 lit_freq[(lits >> 8) & 0xFF]++; 922 lit_freq[(lits >> 8) & 0xFF]++; 923 lit_freq[(lits >> 16) & 0xFF]++; 923 lit_freq[(lits >> 16) & 0xFF]++; 924 lit_freq[lits >> 24]++; 924 lit_freq[lits >> 24]++; 925 925 926 prev_lits = lits; 926 prev_lits = lits; 927 927 928 src_ofs += 4; 928 src_ofs += 4; 929 } 929 } 930 930 931 } // while (src_ofs < end_src_ofs) 931 } // while (src_ofs < end_src_ofs) 932 932 933 } // y 933 } // y 934 934 935 assert(src_ofs == h * bpl); 935 assert(src_ofs == h * bpl); 936 const uint32_t total_codes = (uint32_t)(pD 936 const uint32_t total_codes = (uint32_t)(pDst_codes - codes.data()); 937 assert(total_codes <= codes.size()); 937 assert(total_codes <= codes.size()); 938 938 939 defl_huff dh; 939 defl_huff dh; 940 940 941 lit_freq[256] = 1; 941 lit_freq[256] = 1; 942 942 943 adjust_freq32(DEFL_MAX_HUFF_SYMBOLS_0, lit 943 adjust_freq32(DEFL_MAX_HUFF_SYMBOLS_0, lit_freq, &dh.m_huff_count[0][0]); 944 944 945 memset(&dh.m_huff_count[1][0], 0, sizeof(d 945 memset(&dh.m_huff_count[1][0], 0, sizeof(dh.m_huff_count[1][0]) * DEFL_MAX_HUFF_SYMBOLS_1); 946 dh.m_huff_count[1][dist_sym] = 1; 946 dh.m_huff_count[1][dist_sym] = 1; 947 dh.m_huff_count[1][dist_sym + 1] = 1; // t 947 dh.m_huff_count[1][dist_sym + 1] = 1; // to workaround a bug in wuffs decoder 948 948 949 if (!defl_start_dynamic_block(&dh, pDst, d 949 if (!defl_start_dynamic_block(&dh, pDst, dst_ofs, dst_buf_size, bit_buf, bit_buf_size)) 950 return 0; 950 return 0; 951 951 952 assert(bit_buf_size <= 7); 952 assert(bit_buf_size <= 7); 953 assert(dh.m_huff_codes[1][dist_sym] == 0 & 953 assert(dh.m_huff_codes[1][dist_sym] == 0 && dh.m_huff_code_sizes[1][dist_sym] == 1); 954 954 955 for (uint32_t i = 0; i < total_codes; i++) 955 for (uint32_t i = 0; i < total_codes; i++) 956 { 956 { 957 uint64_t c = codes[i]; 957 uint64_t c = codes[i]; 958 958 959 uint32_t c_type = (uint32_t)(c & 0xFF); 959 uint32_t c_type = (uint32_t)(c & 0xFF); 960 if (c_type == 0) 960 if (c_type == 0) 961 { 961 { 962 uint32_t lits = (uint32_t)(c >> 8); 962 uint32_t lits = (uint32_t)(c >> 8); 963 963 964 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes 964 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes[0][lits & 0xFF], dh.m_huff_code_sizes[0][lits & 0xFF]); 965 lits >>= 8; 965 lits >>= 8; 966 966 967 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes 967 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes[0][lits & 0xFF], dh.m_huff_code_sizes[0][lits & 0xFF]); 968 lits >>= 8; 968 lits >>= 8; 969 969 970 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes 970 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes[0][lits & 0xFF], dh.m_huff_code_sizes[0][lits & 0xFF]); 971 lits >>= 8; 971 lits >>= 8; 972 972 973 if (bit_buf_size >= 49) 973 if (bit_buf_size >= 49) 974 { 974 { 975 TOOLS_FPNG_PUT_BITS_FLUSH; 975 TOOLS_FPNG_PUT_BITS_FLUSH; 976 } 976 } 977 977 978 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes 978 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes[0][lits], dh.m_huff_code_sizes[0][lits]); 979 } 979 } 980 else if (c_type == 1) 980 else if (c_type == 1) 981 { 981 { 982 uint32_t lit = (uint32_t)(c >> 8); 982 uint32_t lit = (uint32_t)(c >> 8); 983 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes 983 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes[0][lit], dh.m_huff_code_sizes[0][lit]); 984 } 984 } 985 else 985 else 986 { 986 { 987 uint32_t match_len = c_type + 1; 987 uint32_t match_len = c_type + 1; 988 988 989 uint32_t adj_match_len = match_len - 3 989 uint32_t adj_match_len = match_len - 3; 990 990 991 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes 991 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes[0][g_defl_len_sym[adj_match_len]], dh.m_huff_code_sizes[0][g_defl_len_sym[adj_match_len]]); 992 TOOLS_FPNG_PUT_BITS(adj_match_len & g_ 992 TOOLS_FPNG_PUT_BITS(adj_match_len & g_bitmasks[g_defl_len_extra[adj_match_len]], g_defl_len_extra[adj_match_len] + 1); // up to 6 bits, +1 for the match distance Huff code which is always 0 993 993 994 // no need to write the distance code, 994 // no need to write the distance code, it's always 0 995 } 995 } 996 996 997 // up to 55 bits 997 // up to 55 bits 998 TOOLS_FPNG_PUT_BITS_FLUSH; 998 TOOLS_FPNG_PUT_BITS_FLUSH; 999 } 999 } 1000 1000 1001 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes[0] 1001 TOOLS_FPNG_PUT_BITS_CZ(dh.m_huff_codes[0][256], dh.m_huff_code_sizes[0][256]); 1002 1002 1003 TOOLS_FPNG_PUT_BITS_FORCE_FLUSH; 1003 TOOLS_FPNG_PUT_BITS_FORCE_FLUSH; 1004 1004 1005 // Write zlib adler32 1005 // Write zlib adler32 1006 for (uint32_t i = 0; i < 4; i++) 1006 for (uint32_t i = 0; i < 4; i++) 1007 { 1007 { 1008 if ((dst_ofs + 1) > dst_buf_size) 1008 if ((dst_ofs + 1) > dst_buf_size) 1009 return 0; 1009 return 0; 1010 *(uint8_t*)(pDst + dst_ofs) = (uint8_t) 1010 *(uint8_t*)(pDst + dst_ofs) = (uint8_t)(src_adler32 >> 24); 1011 dst_ofs++; 1011 dst_ofs++; 1012 1012 1013 src_adler32 <<= 8; 1013 src_adler32 <<= 8; 1014 } 1014 } 1015 1015 1016 return dst_ofs; 1016 return dst_ofs; 1017 } 1017 } 1018 1018 1019 static uint32_t pixel_deflate_dyn_4_rle_one 1019 static uint32_t pixel_deflate_dyn_4_rle_one_pass( 1020 const uint8_t* pImg, uint32_t w, uint32_t 1020 const uint8_t* pImg, uint32_t w, uint32_t h, 1021 uint8_t* pDst, uint32_t dst_buf_size) 1021 uint8_t* pDst, uint32_t dst_buf_size) 1022 { 1022 { 1023 const uint32_t bpl = 1 + w * 4; 1023 const uint32_t bpl = 1 + w * 4; 1024 1024 1025 if (dst_buf_size < sizeof(g_dyn_huff_4)) 1025 if (dst_buf_size < sizeof(g_dyn_huff_4)) 1026 return false; 1026 return false; 1027 memcpy(pDst, g_dyn_huff_4, sizeof(g_dyn_h 1027 memcpy(pDst, g_dyn_huff_4, sizeof(g_dyn_huff_4)); 1028 uint32_t dst_ofs = sizeof(g_dyn_huff_4); 1028 uint32_t dst_ofs = sizeof(g_dyn_huff_4); 1029 1029 1030 uint64_t bit_buf = DYN_HUFF_4_BITBUF; 1030 uint64_t bit_buf = DYN_HUFF_4_BITBUF; 1031 int bit_buf_size = DYN_HUFF_4_BITBUF_SIZE 1031 int bit_buf_size = DYN_HUFF_4_BITBUF_SIZE; 1032 1032 1033 const uint8_t* pSrc = pImg; 1033 const uint8_t* pSrc = pImg; 1034 uint32_t src_ofs = 0; 1034 uint32_t src_ofs = 0; 1035 1035 1036 uint32_t src_adler32 = fpng_adler32(pImg, 1036 uint32_t src_adler32 = fpng_adler32(pImg, bpl * h, FPNG_ADLER32_INIT); 1037 1037 1038 for (uint32_t y = 0; y < h; y++) 1038 for (uint32_t y = 0; y < h; y++) 1039 { 1039 { 1040 const uint32_t end_src_ofs = src_ofs + 1040 const uint32_t end_src_ofs = src_ofs + bpl; 1041 1041 1042 const uint32_t filter_lit = pSrc[src_of 1042 const uint32_t filter_lit = pSrc[src_ofs++]; 1043 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_4_cod 1043 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_4_codes[filter_lit].m_code, g_dyn_huff_4_codes[filter_lit].m_code_size); 1044 1044 1045 TOOLS_FPNG_PUT_BITS_FLUSH; 1045 TOOLS_FPNG_PUT_BITS_FLUSH; 1046 1046 1047 uint32_t prev_lits; 1047 uint32_t prev_lits; 1048 { 1048 { 1049 uint32_t lits = READ_LE32(pSrc + src_ 1049 uint32_t lits = READ_LE32(pSrc + src_ofs); 1050 1050 1051 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_4_c 1051 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_4_codes[lits & 0xFF].m_code, g_dyn_huff_4_codes[lits & 0xFF].m_code_size); 1052 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_4_c 1052 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_4_codes[(lits >> 8) & 0xFF].m_code, g_dyn_huff_4_codes[(lits >> 8) & 0xFF].m_code_size); 1053 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_4_c 1053 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_4_codes[(lits >> 16) & 0xFF].m_code, g_dyn_huff_4_codes[(lits >> 16) & 0xFF].m_code_size); 1054 1054 1055 if (bit_buf_size >= 49) 1055 if (bit_buf_size >= 49) 1056 { 1056 { 1057 TOOLS_FPNG_PUT_BITS_FLUSH; 1057 TOOLS_FPNG_PUT_BITS_FLUSH; 1058 } 1058 } 1059 1059 1060 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_4_c 1060 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_4_codes[(lits >> 24)].m_code, g_dyn_huff_4_codes[(lits >> 24)].m_code_size); 1061 1061 1062 src_ofs += 4; 1062 src_ofs += 4; 1063 1063 1064 prev_lits = lits; 1064 prev_lits = lits; 1065 } 1065 } 1066 1066 1067 TOOLS_FPNG_PUT_BITS_FLUSH; 1067 TOOLS_FPNG_PUT_BITS_FLUSH; 1068 1068 1069 while (src_ofs < end_src_ofs) 1069 while (src_ofs < end_src_ofs) 1070 { 1070 { 1071 uint32_t lits = READ_LE32(pSrc + src_ 1071 uint32_t lits = READ_LE32(pSrc + src_ofs); 1072 1072 1073 if (lits == prev_lits) 1073 if (lits == prev_lits) 1074 { 1074 { 1075 uint32_t match_len = 4; 1075 uint32_t match_len = 4; 1076 uint32_t max_match_len = minimum<in 1076 uint32_t max_match_len = minimum<int>(252, (int)(end_src_ofs - src_ofs)); 1077 1077 1078 while (match_len < max_match_len) 1078 while (match_len < max_match_len) 1079 { 1079 { 1080 if (READ_LE32(pSrc + src_ofs + ma 1080 if (READ_LE32(pSrc + src_ofs + match_len) != lits) 1081 break; 1081 break; 1082 match_len += 4; 1082 match_len += 4; 1083 } 1083 } 1084 1084 1085 uint32_t adj_match_len = match_len 1085 uint32_t adj_match_len = match_len - 3; 1086 1086 1087 const uint32_t match_code_bits = g_ 1087 const uint32_t match_code_bits = g_dyn_huff_4_codes[g_defl_len_sym[adj_match_len]].m_code_size; 1088 const uint32_t len_extra_bits = g_d 1088 const uint32_t len_extra_bits = g_defl_len_extra[adj_match_len]; 1089 1089 1090 if (match_len == 4) 1090 if (match_len == 4) 1091 { 1091 { 1092 // This check is optional - see i 1092 // This check is optional - see if just encoding 4 literals would be cheaper than using a short match. 1093 uint32_t lit_bits = g_dyn_huff_4_ 1093 uint32_t lit_bits = g_dyn_huff_4_codes[lits & 0xFF].m_code_size + g_dyn_huff_4_codes[(lits >> 8) & 0xFF].m_code_size + 1094 g_dyn_huff_4_codes[(lits >> 16) 1094 g_dyn_huff_4_codes[(lits >> 16) & 0xFF].m_code_size + g_dyn_huff_4_codes[(lits >> 24)].m_code_size; 1095 1095 1096 if ((match_code_bits + len_extra_ 1096 if ((match_code_bits + len_extra_bits + 1) > lit_bits) 1097 goto do_literals; 1097 goto do_literals; 1098 } 1098 } 1099 1099 1100 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_4 1100 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_4_codes[g_defl_len_sym[adj_match_len]].m_code, match_code_bits); 1101 TOOLS_FPNG_PUT_BITS(adj_match_len & 1101 TOOLS_FPNG_PUT_BITS(adj_match_len & g_bitmasks[g_defl_len_extra[adj_match_len]], len_extra_bits + 1); // up to 6 bits, +1 for the match distance Huff code which is always 0 1102 1102 1103 src_ofs += match_len; 1103 src_ofs += match_len; 1104 } 1104 } 1105 else 1105 else 1106 { 1106 { 1107 do_literals: 1107 do_literals: 1108 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_4 1108 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_4_codes[lits & 0xFF].m_code, g_dyn_huff_4_codes[lits & 0xFF].m_code_size); 1109 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_4 1109 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_4_codes[(lits >> 8) & 0xFF].m_code, g_dyn_huff_4_codes[(lits >> 8) & 0xFF].m_code_size); 1110 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_4 1110 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_4_codes[(lits >> 16) & 0xFF].m_code, g_dyn_huff_4_codes[(lits >> 16) & 0xFF].m_code_size); 1111 1111 1112 if (bit_buf_size >= 49) 1112 if (bit_buf_size >= 49) 1113 { 1113 { 1114 TOOLS_FPNG_PUT_BITS_FLUSH; 1114 TOOLS_FPNG_PUT_BITS_FLUSH; 1115 } 1115 } 1116 1116 1117 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_4 1117 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_4_codes[(lits >> 24)].m_code, g_dyn_huff_4_codes[(lits >> 24)].m_code_size); 1118 1118 1119 src_ofs += 4; 1119 src_ofs += 4; 1120 1120 1121 prev_lits = lits; 1121 prev_lits = lits; 1122 } 1122 } 1123 1123 1124 TOOLS_FPNG_PUT_BITS_FLUSH; 1124 TOOLS_FPNG_PUT_BITS_FLUSH; 1125 1125 1126 } // while (src_ofs < end_src_ofs) 1126 } // while (src_ofs < end_src_ofs) 1127 1127 1128 } // y 1128 } // y 1129 1129 1130 assert(src_ofs == h * bpl); 1130 assert(src_ofs == h * bpl); 1131 1131 1132 assert(bit_buf_size <= 7); 1132 assert(bit_buf_size <= 7); 1133 1133 1134 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_4_codes 1134 TOOLS_FPNG_PUT_BITS_CZ(g_dyn_huff_4_codes[256].m_code, g_dyn_huff_4_codes[256].m_code_size); 1135 1135 1136 TOOLS_FPNG_PUT_BITS_FORCE_FLUSH; 1136 TOOLS_FPNG_PUT_BITS_FORCE_FLUSH; 1137 1137 1138 // Write zlib adler32 1138 // Write zlib adler32 1139 for (uint32_t i = 0; i < 4; i++) 1139 for (uint32_t i = 0; i < 4; i++) 1140 { 1140 { 1141 if ((dst_ofs + 1) > dst_buf_size) 1141 if ((dst_ofs + 1) > dst_buf_size) 1142 return 0; 1142 return 0; 1143 *(uint8_t*)(pDst + dst_ofs) = (uint8_t) 1143 *(uint8_t*)(pDst + dst_ofs) = (uint8_t)(src_adler32 >> 24); 1144 dst_ofs++; 1144 dst_ofs++; 1145 1145 1146 src_adler32 <<= 8; 1146 src_adler32 <<= 8; 1147 } 1147 } 1148 1148 1149 return dst_ofs; 1149 return dst_ofs; 1150 } 1150 } 1151 1151 1152 static void vector_append(std::vector<uint8 1152 static void vector_append(std::vector<uint8_t>& buf, const void* pData, size_t len) 1153 { 1153 { 1154 if (len) 1154 if (len) 1155 { 1155 { 1156 size_t l = buf.size(); 1156 size_t l = buf.size(); 1157 buf.resize(l + len); 1157 buf.resize(l + len); 1158 memcpy(buf.data() + l, pData, len); 1158 memcpy(buf.data() + l, pData, len); 1159 } 1159 } 1160 } 1160 } 1161 1161 1162 static void apply_filter(uint32_t filter, i 1162 static void apply_filter(uint32_t filter, int w, int h, uint32_t num_chans, uint32_t bpl, const uint8_t* pSrc, const uint8_t* pPrev_src, uint8_t* pDst) 1163 { 1163 { 1164 (void)h; 1164 (void)h; 1165 1165 1166 switch (filter) 1166 switch (filter) 1167 { 1167 { 1168 case 0: 1168 case 0: 1169 { 1169 { 1170 *pDst++ = 0; 1170 *pDst++ = 0; 1171 1171 1172 memcpy(pDst, pSrc, bpl); 1172 memcpy(pDst, pSrc, bpl); 1173 break; 1173 break; 1174 } 1174 } 1175 case 2: 1175 case 2: 1176 { 1176 { 1177 assert(pPrev_src); 1177 assert(pPrev_src); 1178 1178 1179 // Previous scanline 1179 // Previous scanline 1180 *pDst++ = 2; 1180 *pDst++ = 2; 1181 1181 1182 { 1182 { 1183 if (num_chans == 3) 1183 if (num_chans == 3) 1184 { 1184 { 1185 for (uint32_t x = 0; x < (uint32_t) 1185 for (uint32_t x = 0; x < (uint32_t)w; x++) 1186 { 1186 { 1187 pDst[0] = (uint8_t)(pSrc[0] - pPr 1187 pDst[0] = (uint8_t)(pSrc[0] - pPrev_src[0]); 1188 pDst[1] = (uint8_t)(pSrc[1] - pPr 1188 pDst[1] = (uint8_t)(pSrc[1] - pPrev_src[1]); 1189 pDst[2] = (uint8_t)(pSrc[2] - pPr 1189 pDst[2] = (uint8_t)(pSrc[2] - pPrev_src[2]); 1190 1190 1191 pSrc += 3; 1191 pSrc += 3; 1192 pPrev_src += 3; 1192 pPrev_src += 3; 1193 pDst += 3; 1193 pDst += 3; 1194 } 1194 } 1195 } 1195 } 1196 else 1196 else 1197 { 1197 { 1198 for (uint32_t x = 0; x < (uint32_t) 1198 for (uint32_t x = 0; x < (uint32_t)w; x++) 1199 { 1199 { 1200 pDst[0] = (uint8_t)(pSrc[0] - pPr 1200 pDst[0] = (uint8_t)(pSrc[0] - pPrev_src[0]); 1201 pDst[1] = (uint8_t)(pSrc[1] - pPr 1201 pDst[1] = (uint8_t)(pSrc[1] - pPrev_src[1]); 1202 pDst[2] = (uint8_t)(pSrc[2] - pPr 1202 pDst[2] = (uint8_t)(pSrc[2] - pPrev_src[2]); 1203 pDst[3] = (uint8_t)(pSrc[3] - pPr 1203 pDst[3] = (uint8_t)(pSrc[3] - pPrev_src[3]); 1204 1204 1205 pSrc += 4; 1205 pSrc += 4; 1206 pPrev_src += 4; 1206 pPrev_src += 4; 1207 pDst += 4; 1207 pDst += 4; 1208 } 1208 } 1209 } 1209 } 1210 } 1210 } 1211 1211 1212 break; 1212 break; 1213 } 1213 } 1214 default: 1214 default: 1215 assert(0); 1215 assert(0); 1216 break; 1216 break; 1217 } 1217 } 1218 } 1218 } 1219 1219 1220 inline bool fpng_encode_image_to_memory(con 1220 inline bool fpng_encode_image_to_memory(const void* pImage, uint32_t w, uint32_t h, uint32_t num_chans, std::vector<uint8_t>& out_buf, uint32_t flags) 1221 { 1221 { 1222 if (!endian_check()) 1222 if (!endian_check()) 1223 { 1223 { 1224 assert(0); 1224 assert(0); 1225 return false; 1225 return false; 1226 } 1226 } 1227 1227 1228 if ((w < 1) || (h < 1) || (w * (uint64_t) 1228 if ((w < 1) || (h < 1) || (w * (uint64_t)h > UINT32_MAX) || (w > FPNG_MAX_SUPPORTED_DIM) || (h > FPNG_MAX_SUPPORTED_DIM)) 1229 { 1229 { 1230 assert(0); 1230 assert(0); 1231 return false; 1231 return false; 1232 } 1232 } 1233 1233 1234 if ((num_chans != 3) && (num_chans != 4)) 1234 if ((num_chans != 3) && (num_chans != 4)) 1235 { 1235 { 1236 assert(0); 1236 assert(0); 1237 return false; 1237 return false; 1238 } 1238 } 1239 1239 1240 int i, bpl = w * num_chans; 1240 int i, bpl = w * num_chans; 1241 uint32_t y; 1241 uint32_t y; 1242 1242 1243 std::vector<uint8_t> temp_buf; 1243 std::vector<uint8_t> temp_buf; 1244 temp_buf.resize((bpl + 1) * h + 7); 1244 temp_buf.resize((bpl + 1) * h + 7); 1245 uint32_t temp_buf_ofs = 0; 1245 uint32_t temp_buf_ofs = 0; 1246 1246 1247 for (y = 0; y < h; ++y) 1247 for (y = 0; y < h; ++y) 1248 { 1248 { 1249 const uint8_t* pSrc = (uint8_t*)pImage 1249 const uint8_t* pSrc = (uint8_t*)pImage + y * bpl; 1250 const uint8_t* pPrev_src = y ? ((uint8_ 1250 const uint8_t* pPrev_src = y ? ((uint8_t*)pImage + (y - 1) * bpl) : NULL/*nullptr*/; 1251 1251 1252 uint8_t* pDst = &temp_buf[temp_buf_ofs] 1252 uint8_t* pDst = &temp_buf[temp_buf_ofs]; 1253 1253 1254 apply_filter(y ? 2 : 0, w, h, num_chans 1254 apply_filter(y ? 2 : 0, w, h, num_chans, bpl, pSrc, pPrev_src, pDst); 1255 1255 1256 temp_buf_ofs += 1 + bpl; 1256 temp_buf_ofs += 1 + bpl; 1257 } 1257 } 1258 1258 1259 const uint32_t PNG_HEADER_SIZE = 58; 1259 const uint32_t PNG_HEADER_SIZE = 58; 1260 1260 1261 uint32_t out_ofs = PNG_HEADER_SIZE; 1261 uint32_t out_ofs = PNG_HEADER_SIZE; 1262 1262 1263 out_buf.resize((out_ofs + (bpl + 1) * h + 1263 out_buf.resize((out_ofs + (bpl + 1) * h + 7) & ~7); 1264 1264 1265 uint32_t defl_size = 0; 1265 uint32_t defl_size = 0; 1266 if ((flags & FPNG_FORCE_UNCOMPRESSED) == 1266 if ((flags & FPNG_FORCE_UNCOMPRESSED) == 0) 1267 { 1267 { 1268 if (num_chans == 3) 1268 if (num_chans == 3) 1269 { 1269 { 1270 if (flags & FPNG_ENCODE_SLOWER) 1270 if (flags & FPNG_ENCODE_SLOWER) 1271 defl_size = pixel_deflate_dyn_3_rle 1271 defl_size = pixel_deflate_dyn_3_rle(temp_buf.data(), w, h, &out_buf[out_ofs], (uint32_t)out_buf.size() - out_ofs); 1272 else 1272 else 1273 defl_size = pixel_deflate_dyn_3_rle 1273 defl_size = pixel_deflate_dyn_3_rle_one_pass(temp_buf.data(), w, h, &out_buf[out_ofs], (uint32_t)out_buf.size() - out_ofs); 1274 } 1274 } 1275 else 1275 else 1276 { 1276 { 1277 if (flags & FPNG_ENCODE_SLOWER) 1277 if (flags & FPNG_ENCODE_SLOWER) 1278 defl_size = pixel_deflate_dyn_4_rle 1278 defl_size = pixel_deflate_dyn_4_rle(temp_buf.data(), w, h, &out_buf[out_ofs], (uint32_t)out_buf.size() - out_ofs); 1279 else 1279 else 1280 defl_size = pixel_deflate_dyn_4_rle 1280 defl_size = pixel_deflate_dyn_4_rle_one_pass(temp_buf.data(), w, h, &out_buf[out_ofs], (uint32_t)out_buf.size() - out_ofs); 1281 } 1281 } 1282 } 1282 } 1283 1283 1284 uint32_t zlib_size = defl_size; 1284 uint32_t zlib_size = defl_size; 1285 1285 1286 if (!defl_size) 1286 if (!defl_size) 1287 { 1287 { 1288 // Dynamic block failed to compress - f 1288 // Dynamic block failed to compress - fall back to uncompressed blocks, filter 0. 1289 1289 1290 temp_buf_ofs = 0; 1290 temp_buf_ofs = 0; 1291 1291 1292 for (y = 0; y < h; ++y) 1292 for (y = 0; y < h; ++y) 1293 { 1293 { 1294 const uint8_t* pSrc = (uint8_t*)pImag 1294 const uint8_t* pSrc = (uint8_t*)pImage + y * bpl; 1295 1295 1296 uint8_t* pDst = &temp_buf[temp_buf_of 1296 uint8_t* pDst = &temp_buf[temp_buf_ofs]; 1297 1297 1298 apply_filter(0, w, h, num_chans, bpl, 1298 apply_filter(0, w, h, num_chans, bpl, pSrc, NULL/*nullptr*/, pDst); 1299 1299 1300 temp_buf_ofs += 1 + bpl; 1300 temp_buf_ofs += 1 + bpl; 1301 } 1301 } 1302 1302 1303 assert(temp_buf_ofs <= temp_buf.size()) 1303 assert(temp_buf_ofs <= temp_buf.size()); 1304 1304 1305 out_buf.resize(out_ofs + 6 + temp_buf_o 1305 out_buf.resize(out_ofs + 6 + temp_buf_ofs + ((temp_buf_ofs + 65534) / 65535) * 5); 1306 1306 1307 uint32_t raw_size = write_raw_block(tem 1307 uint32_t raw_size = write_raw_block(temp_buf.data(), (uint32_t)temp_buf_ofs, out_buf.data() + out_ofs, (uint32_t)out_buf.size() - out_ofs); 1308 if (!raw_size) 1308 if (!raw_size) 1309 { 1309 { 1310 // Somehow we miscomputed the size of 1310 // Somehow we miscomputed the size of the output buffer. 1311 assert(0); 1311 assert(0); 1312 return false; 1312 return false; 1313 } 1313 } 1314 1314 1315 zlib_size = raw_size; 1315 zlib_size = raw_size; 1316 } 1316 } 1317 1317 1318 assert((out_ofs + zlib_size) <= out_buf.s 1318 assert((out_ofs + zlib_size) <= out_buf.size()); 1319 1319 1320 out_buf.resize(out_ofs + zlib_size); 1320 out_buf.resize(out_ofs + zlib_size); 1321 1321 1322 const uint32_t idat_len = (uint32_t)out_b 1322 const uint32_t idat_len = (uint32_t)out_buf.size() - PNG_HEADER_SIZE; 1323 1323 1324 // Write real PNG header, fdEC chunk, and 1324 // Write real PNG header, fdEC chunk, and the beginning of the IDAT chunk 1325 { 1325 { 1326 static const uint8_t s_color_type[] = { 1326 static const uint8_t s_color_type[] = { 0x00, 0x00, 0x04, 0x02, 0x06 }; 1327 1327 1328 uint8_t pnghdr[58] = { 1328 uint8_t pnghdr[58] = { 1329 0x89,0x50,0x4e,0x47,0x0d,0x0a,0x1a,0x 1329 0x89,0x50,0x4e,0x47,0x0d,0x0a,0x1a,0x0a, // PNG sig 1330 0x00,0x00,0x00,0x0d, 'I','H','D','R', 1330 0x00,0x00,0x00,0x0d, 'I','H','D','R', // IHDR chunk len, type 1331 0,0,(uint8_t)(w >> 8),(uint8_t)w, / 1331 0,0,(uint8_t)(w >> 8),(uint8_t)w, // width 1332 0,0,(uint8_t)(h >> 8),(uint8_t)h, // 1332 0,0,(uint8_t)(h >> 8),(uint8_t)h, // height 1333 8, //bit_depth 1333 8, //bit_depth 1334 s_color_type[num_chans], // color_typ 1334 s_color_type[num_chans], // color_type 1335 0, // compression 1335 0, // compression 1336 0, // filter 1336 0, // filter 1337 0, // interlace 1337 0, // interlace 1338 0, 0, 0, 0, // IHDR crc32 1338 0, 0, 0, 0, // IHDR crc32 1339 0, 0, 0, 5, 'f', 'd', 'E', 'C', 82, 3 1339 0, 0, 0, 5, 'f', 'd', 'E', 'C', 82, 36, 147, 227, FPNG_FDEC_VERSION, 0xE5, 0xAB, 0x62, 0x99, // our custom private, ancillary, do not copy, fdEC chunk 1340 (uint8_t)(idat_len >> 24),(uint8_t)(i 1340 (uint8_t)(idat_len >> 24),(uint8_t)(idat_len >> 16),(uint8_t)(idat_len >> 8),(uint8_t)idat_len, 'I','D','A','T' // IDATA chunk len, type 1341 }; 1341 }; 1342 1342 1343 // Compute IHDR CRC32 1343 // Compute IHDR CRC32 1344 uint32_t c = (uint32_t)fpng_crc32(pnghd 1344 uint32_t c = (uint32_t)fpng_crc32(pnghdr + 12, 17, FPNG_CRC32_INIT); 1345 for (i = 0; i < 4; ++i, c <<= 8) 1345 for (i = 0; i < 4; ++i, c <<= 8) 1346 ((uint8_t*)(pnghdr + 29))[i] = (uint8 1346 ((uint8_t*)(pnghdr + 29))[i] = (uint8_t)(c >> 24); 1347 1347 1348 memcpy(out_buf.data(), pnghdr, PNG_HEAD 1348 memcpy(out_buf.data(), pnghdr, PNG_HEADER_SIZE); 1349 } 1349 } 1350 1350 1351 // Write IDAT chunk's CRC32 and a 0 lengt 1351 // Write IDAT chunk's CRC32 and a 0 length IEND chunk 1352 vector_append(out_buf, "\0\0\0\0\0\0\0\0\ 1352 vector_append(out_buf, "\0\0\0\0\0\0\0\0\x49\x45\x4e\x44\xae\x42\x60\x82", 16); // IDAT CRC32, followed by the IEND chunk 1353 1353 1354 // Compute IDAT crc32 1354 // Compute IDAT crc32 1355 uint32_t c = (uint32_t)fpng_crc32(out_buf 1355 uint32_t c = (uint32_t)fpng_crc32(out_buf.data() + PNG_HEADER_SIZE - 4, idat_len + 4, FPNG_CRC32_INIT); 1356 1356 1357 for (i = 0; i < 4; ++i, c <<= 8) 1357 for (i = 0; i < 4; ++i, c <<= 8) 1358 (out_buf.data() + out_buf.size() - 16)[ 1358 (out_buf.data() + out_buf.size() - 16)[i] = (uint8_t)(c >> 24); 1359 1359 1360 return true; 1360 return true; 1361 } 1361 } 1362 1362 1363 inline bool fpng_encode_image_to_file(const 1363 inline bool fpng_encode_image_to_file(const char* pFilename, const void* pImage, uint32_t w, uint32_t h, uint32_t num_chans, uint32_t flags) 1364 { 1364 { 1365 std::vector<uint8_t> out_buf; 1365 std::vector<uint8_t> out_buf; 1366 if (!fpng_encode_image_to_memory(pImage, 1366 if (!fpng_encode_image_to_memory(pImage, w, h, num_chans, out_buf, flags)) 1367 return false; 1367 return false; 1368 1368 1369 FILE* pFile = fopen(pFilename 1369 FILE* pFile = fopen(pFilename, "wb"); 1370 if (!pFile) return false; 1370 if (!pFile) return false; 1371 1371 1372 if (fwrite(out_buf.data(), 1, out_buf.siz 1372 if (fwrite(out_buf.data(), 1, out_buf.size(), pFile) != out_buf.size()) 1373 { 1373 { 1374 fclose(pFile); 1374 fclose(pFile); 1375 return false; 1375 return false; 1376 } 1376 } 1377 1377 1378 return (fclose(pFile) != EOF); 1378 return (fclose(pFile) != EOF); 1379 } 1379 } 1380 1380 1381 // Decompression 1381 // Decompression 1382 1382 1383 const uint32_t FPNG_DECODER_TABLE_BITS = 12 1383 const uint32_t FPNG_DECODER_TABLE_BITS = 12; 1384 const uint32_t FPNG_DECODER_TABLE_SIZE = 1 1384 const uint32_t FPNG_DECODER_TABLE_SIZE = 1 << FPNG_DECODER_TABLE_BITS; 1385 1385 1386 static bool build_decoder_table(uint32_t nu 1386 static bool build_decoder_table(uint32_t num_syms, uint8_t* pCode_sizes, uint32_t* pTable) 1387 { 1387 { 1388 uint32_t num_codes[16]; 1388 uint32_t num_codes[16]; 1389 1389 1390 memset(num_codes, 0, sizeof(num_codes)); 1390 memset(num_codes, 0, sizeof(num_codes)); 1391 for (uint32_t i = 0; i < num_syms; i++) 1391 for (uint32_t i = 0; i < num_syms; i++) 1392 { 1392 { 1393 assert(uint32_t(pCode_sizes[i]) < 1393 assert(uint32_t(pCode_sizes[i]) <= FPNG_DECODER_TABLE_SIZE); //G.Barrand: uint32_t cast. 1394 num_codes[pCode_sizes[i]]++; 1394 num_codes[pCode_sizes[i]]++; 1395 } 1395 } 1396 1396 1397 uint32_t next_code[17]; 1397 uint32_t next_code[17]; 1398 next_code[0] = next_code[1] = 0; 1398 next_code[0] = next_code[1] = 0; 1399 uint32_t total = 0; 1399 uint32_t total = 0; 1400 for (uint32_t i = 1; i <= 15; i++) 1400 for (uint32_t i = 1; i <= 15; i++) 1401 next_code[i + 1] = (uint32_t)(total = ( 1401 next_code[i + 1] = (uint32_t)(total = ((total + ((uint32_t)num_codes[i])) << 1)); 1402 1402 1403 if (total != 0x10000) 1403 if (total != 0x10000) 1404 { 1404 { 1405 uint32_t j = 0; 1405 uint32_t j = 0; 1406 1406 1407 for (uint32_t i = 15; i != 0; i--) 1407 for (uint32_t i = 15; i != 0; i--) 1408 if ((j += num_codes[i]) > 1) 1408 if ((j += num_codes[i]) > 1) 1409 return false; 1409 return false; 1410 1410 1411 if (j != 1) 1411 if (j != 1) 1412 return false; 1412 return false; 1413 } 1413 } 1414 1414 1415 uint32_t rev_codes[DEFL_MAX_HUFF_SYMBOLS] 1415 uint32_t rev_codes[DEFL_MAX_HUFF_SYMBOLS]; 1416 1416 1417 for (uint32_t i = 0; i < num_syms; i++) 1417 for (uint32_t i = 0; i < num_syms; i++) 1418 rev_codes[i] = next_code[pCode_sizes[i] 1418 rev_codes[i] = next_code[pCode_sizes[i]]++; 1419 1419 1420 memset(pTable, 0, sizeof(uint32_t) * FPNG 1420 memset(pTable, 0, sizeof(uint32_t) * FPNG_DECODER_TABLE_SIZE); 1421 1421 1422 for (uint32_t i = 0; i < num_syms; i++) 1422 for (uint32_t i = 0; i < num_syms; i++) 1423 { 1423 { 1424 const uint32_t code_size = pCode_sizes[ 1424 const uint32_t code_size = pCode_sizes[i]; 1425 if (!code_size) 1425 if (!code_size) 1426 continue; 1426 continue; 1427 1427 1428 uint32_t old_code = rev_codes[i], new_c 1428 uint32_t old_code = rev_codes[i], new_code = 0; 1429 for (uint32_t j = code_size; j != 0; j- 1429 for (uint32_t j = code_size; j != 0; j--) 1430 { 1430 { 1431 new_code = (new_code << 1) | (old_cod 1431 new_code = (new_code << 1) | (old_code & 1); 1432 old_code >>= 1; 1432 old_code >>= 1; 1433 } 1433 } 1434 1434 1435 uint32_t j = 1 << code_size; 1435 uint32_t j = 1 << code_size; 1436 1436 1437 while (new_code < FPNG_DECODER_TABLE_SI 1437 while (new_code < FPNG_DECODER_TABLE_SIZE) 1438 { 1438 { 1439 pTable[new_code] = i | (code_size << 1439 pTable[new_code] = i | (code_size << 9); 1440 new_code += j; 1440 new_code += j; 1441 } 1441 } 1442 } 1442 } 1443 1443 1444 return true; 1444 return true; 1445 } 1445 } 1446 1446 1447 static const uint16_t g_run_len3_to_4[259] 1447 static const uint16_t g_run_len3_to_4[259] = 1448 { 1448 { 1449 0, 1449 0, 1450 0, 0, 4, 0, 0, 8, 0, 0, 12, 0, 0, 16, 0, 1450 0, 0, 4, 0, 0, 8, 0, 0, 12, 0, 0, 16, 0, 0, 20, 0, 0, 24, 0, 0, 28, 0, 0, 1451 32, 0, 0, 36, 0, 0, 40, 0, 0, 44, 0, 0, 4 1451 32, 0, 0, 36, 0, 0, 40, 0, 0, 44, 0, 0, 48, 0, 0, 52, 0, 0, 56, 0, 0, 1452 60, 0, 0, 64, 0, 0, 68, 0, 0, 72, 0, 0, 7 1452 60, 0, 0, 64, 0, 0, 68, 0, 0, 72, 0, 0, 76, 0, 0, 80, 0, 0, 84, 0, 0, 1453 88, 0, 0, 92, 0, 0, 96, 0, 0, 100, 0, 0, 1453 88, 0, 0, 92, 0, 0, 96, 0, 0, 100, 0, 0, 104, 0, 0, 108, 0, 0, 112, 0, 0, 1454 116, 0, 0, 120, 0, 0, 124, 0, 0, 128, 0, 1454 116, 0, 0, 120, 0, 0, 124, 0, 0, 128, 0, 0, 132, 0, 0, 136, 0, 0, 140, 0, 0, 1455 144, 0, 0, 148, 0, 0, 152, 0, 0, 156, 0, 1455 144, 0, 0, 148, 0, 0, 152, 0, 0, 156, 0, 0, 160, 0, 0, 164, 0, 0, 168, 0, 0, 1456 172, 0, 0, 176, 0, 0, 180, 0, 0, 184, 0, 1456 172, 0, 0, 176, 0, 0, 180, 0, 0, 184, 0, 0, 188, 0, 0, 192, 0, 0, 196, 0, 0, 1457 200, 0, 0, 204, 0, 0, 208, 0, 0, 212, 0, 1457 200, 0, 0, 204, 0, 0, 208, 0, 0, 212, 0, 0, 216, 0, 0, 220, 0, 0, 224, 0, 0, 1458 228, 0, 0, 232, 0, 0, 236, 0, 0, 240, 0, 1458 228, 0, 0, 232, 0, 0, 236, 0, 0, 240, 0, 0, 244, 0, 0, 248, 0, 0, 252, 0, 0, 1459 256, 0, 0, 260, 0, 0, 264, 0, 0, 268, 0, 1459 256, 0, 0, 260, 0, 0, 264, 0, 0, 268, 0, 0, 272, 0, 0, 276, 0, 0, 280, 0, 0, 1460 284, 0, 0, 288, 0, 0, 292, 0, 0, 296, 0, 1460 284, 0, 0, 288, 0, 0, 292, 0, 0, 296, 0, 0, 300, 0, 0, 304, 0, 0, 308, 0, 0, 1461 312, 0, 0, 316, 0, 0, 320, 0, 0, 324, 0, 1461 312, 0, 0, 316, 0, 0, 320, 0, 0, 324, 0, 0, 328, 0, 0, 332, 0, 0, 336, 0, 0, 1462 340, 0, 0, 1462 340, 0, 0, 1463 344, 1463 344, 1464 }; 1464 }; 1465 1465 1466 static const int s_length_extra[] = { 0,0,0 1466 static const int s_length_extra[] = { 0,0,0,0, 0,0,0,0, 1,1,1,1, 2,2,2,2, 3,3,3,3, 4,4,4,4, 5,5,5,5, 0, 0,0 }; 1467 static const int s_length_range[] = { 3,4,5 1467 static const int s_length_range[] = { 3,4,5,6, 7,8,9,10, 11,13,15,17, 19,23,27,31, 35,43,51,59, 67,83,99,115, 131,163,195,227, 258, 0,0 }; 1468 1468 1469 #define TOOLS_FPNG_ENSURE_32BITS() do { \ 1469 #define TOOLS_FPNG_ENSURE_32BITS() do { \ 1470 if (bit_buf_size < 32) { \ 1470 if (bit_buf_size < 32) { \ 1471 if ((src_ofs + 4) > src_len) return false 1471 if ((src_ofs + 4) > src_len) return false; \ 1472 bit_buf |= ((uint64_t)READ_LE32(pSrc + sr 1472 bit_buf |= ((uint64_t)READ_LE32(pSrc + src_ofs)) << bit_buf_size; \ 1473 src_ofs += 4; bit_buf_size += 32; } \ 1473 src_ofs += 4; bit_buf_size += 32; } \ 1474 } while(0) 1474 } while(0) 1475 1475 1476 #define TOOLS_FPNG_GET_BITS(b, ll) do { \ 1476 #define TOOLS_FPNG_GET_BITS(b, ll) do { \ 1477 uint32_t l = ll; assert(l && (l <= 32)); \ 1477 uint32_t l = ll; assert(l && (l <= 32)); \ 1478 b = (uint32_t)(bit_buf & g_bitmasks[l]); \ 1478 b = (uint32_t)(bit_buf & g_bitmasks[l]); \ 1479 bit_buf >>= l; \ 1479 bit_buf >>= l; \ 1480 bit_buf_size -= l; \ 1480 bit_buf_size -= l; \ 1481 TOOLS_FPNG_ENSURE_32BITS(); \ 1481 TOOLS_FPNG_ENSURE_32BITS(); \ 1482 } while(0) 1482 } while(0) 1483 1483 1484 #define TOOLS_FPNG_SKIP_BITS(ll) do { \ 1484 #define TOOLS_FPNG_SKIP_BITS(ll) do { \ 1485 uint32_t l = ll; assert(l <= 32); \ 1485 uint32_t l = ll; assert(l <= 32); \ 1486 bit_buf >>= l; \ 1486 bit_buf >>= l; \ 1487 bit_buf_size -= l; \ 1487 bit_buf_size -= l; \ 1488 TOOLS_FPNG_ENSURE_32BITS(); \ 1488 TOOLS_FPNG_ENSURE_32BITS(); \ 1489 } while(0) 1489 } while(0) 1490 1490 1491 #define TOOLS_FPNG_GET_BITS_NE(b, ll) do { \ 1491 #define TOOLS_FPNG_GET_BITS_NE(b, ll) do { \ 1492 uint32_t l = ll; assert(l && (l <= 32) && ( 1492 uint32_t l = ll; assert(l && (l <= 32) && (bit_buf_size >= l)); \ 1493 b = (uint32_t)(bit_buf & g_bitmasks[l]); \ 1493 b = (uint32_t)(bit_buf & g_bitmasks[l]); \ 1494 bit_buf >>= l; \ 1494 bit_buf >>= l; \ 1495 bit_buf_size -= l; \ 1495 bit_buf_size -= l; \ 1496 } while(0) 1496 } while(0) 1497 1497 1498 #define TOOLS_FPNG_SKIP_BITS_NE(ll) do { \ 1498 #define TOOLS_FPNG_SKIP_BITS_NE(ll) do { \ 1499 uint32_t l = ll; assert(l <= 32 && (bit_buf 1499 uint32_t l = ll; assert(l <= 32 && (bit_buf_size >= l)); \ 1500 bit_buf >>= l; \ 1500 bit_buf >>= l; \ 1501 bit_buf_size -= l; \ 1501 bit_buf_size -= l; \ 1502 } while(0) 1502 } while(0) 1503 1503 1504 static bool prepare_dynamic_block( 1504 static bool prepare_dynamic_block( 1505 const uint8_t* pSrc, uint32_t src_len, ui 1505 const uint8_t* pSrc, uint32_t src_len, uint32_t& src_ofs, 1506 uint32_t& bit_buf_size, uint64_t& bit_buf 1506 uint32_t& bit_buf_size, uint64_t& bit_buf, 1507 uint32_t* pLit_table, uint32_t num_chans) 1507 uint32_t* pLit_table, uint32_t num_chans) 1508 { 1508 { 1509 static const uint8_t s_bit_length_order[] 1509 static const uint8_t s_bit_length_order[] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 }; 1510 1510 1511 uint32_t num_lit_codes, num_dist_codes, n 1511 uint32_t num_lit_codes, num_dist_codes, num_clen_codes; 1512 1512 1513 TOOLS_FPNG_GET_BITS(num_lit_codes, 5); 1513 TOOLS_FPNG_GET_BITS(num_lit_codes, 5); 1514 num_lit_codes += 257; 1514 num_lit_codes += 257; 1515 1515 1516 TOOLS_FPNG_GET_BITS(num_dist_codes, 5); 1516 TOOLS_FPNG_GET_BITS(num_dist_codes, 5); 1517 num_dist_codes += 1; 1517 num_dist_codes += 1; 1518 1518 1519 uint32_t total_codes = num_lit_codes + nu 1519 uint32_t total_codes = num_lit_codes + num_dist_codes; 1520 if (total_codes > (DEFL_MAX_HUFF_SYMBOLS_ 1520 if (total_codes > (DEFL_MAX_HUFF_SYMBOLS_0 + DEFL_MAX_HUFF_SYMBOLS_1)) 1521 return false; 1521 return false; 1522 1522 1523 uint8_t code_sizes[DEFL_MAX_HUFF_SYMBOLS_ 1523 uint8_t code_sizes[DEFL_MAX_HUFF_SYMBOLS_0 + DEFL_MAX_HUFF_SYMBOLS_1]; 1524 memset(code_sizes, 0, sizeof(code_sizes)) 1524 memset(code_sizes, 0, sizeof(code_sizes)); 1525 1525 1526 TOOLS_FPNG_GET_BITS(num_clen_codes, 4); 1526 TOOLS_FPNG_GET_BITS(num_clen_codes, 4); 1527 num_clen_codes += 4; 1527 num_clen_codes += 4; 1528 1528 1529 uint8_t clen_codesizes[DEFL_MAX_HUFF_SYMB 1529 uint8_t clen_codesizes[DEFL_MAX_HUFF_SYMBOLS_2]; 1530 memset(clen_codesizes, 0, sizeof(clen_cod 1530 memset(clen_codesizes, 0, sizeof(clen_codesizes)); 1531 1531 1532 for (uint32_t i = 0; i < num_clen_codes; 1532 for (uint32_t i = 0; i < num_clen_codes; i++) 1533 { 1533 { 1534 uint32_t len = 0; 1534 uint32_t len = 0; 1535 TOOLS_FPNG_GET_BITS(len, 3); 1535 TOOLS_FPNG_GET_BITS(len, 3); 1536 clen_codesizes[s_bit_length_order[i]] = 1536 clen_codesizes[s_bit_length_order[i]] = (uint8_t)len; 1537 } 1537 } 1538 1538 1539 uint32_t clen_table[FPNG_DECODER_TABLE_SI 1539 uint32_t clen_table[FPNG_DECODER_TABLE_SIZE]; 1540 if (!build_decoder_table(DEFL_MAX_HUFF_SY 1540 if (!build_decoder_table(DEFL_MAX_HUFF_SYMBOLS_2, clen_codesizes, clen_table)) 1541 return false; 1541 return false; 1542 1542 1543 uint32_t min_code_size = 15; 1543 uint32_t min_code_size = 15; 1544 1544 1545 for (uint32_t cur_code = 0; cur_code < to 1545 for (uint32_t cur_code = 0; cur_code < total_codes; ) 1546 { 1546 { 1547 uint32_t sym = clen_table[bit_buf & (FP 1547 uint32_t sym = clen_table[bit_buf & (FPNG_DECODER_TABLE_SIZE - 1)]; 1548 uint32_t sym_len = sym >> 9; 1548 uint32_t sym_len = sym >> 9; 1549 if (!sym_len) 1549 if (!sym_len) 1550 return false; 1550 return false; 1551 TOOLS_FPNG_SKIP_BITS(sym_len); 1551 TOOLS_FPNG_SKIP_BITS(sym_len); 1552 sym &= 511; 1552 sym &= 511; 1553 1553 1554 if (sym <= 15) 1554 if (sym <= 15) 1555 { 1555 { 1556 // Can't be a fpng Huffman table 1556 // Can't be a fpng Huffman table 1557 if (sym > FPNG_DECODER_TABLE_BITS) 1557 if (sym > FPNG_DECODER_TABLE_BITS) 1558 return false; 1558 return false; 1559 1559 1560 if (sym) 1560 if (sym) 1561 min_code_size = minimum(min_code_si 1561 min_code_size = minimum(min_code_size, sym); 1562 1562 1563 code_sizes[cur_code++] = (uint8_t)sym 1563 code_sizes[cur_code++] = (uint8_t)sym; 1564 continue; 1564 continue; 1565 } 1565 } 1566 1566 1567 uint32_t rep_len = 0, rep_code_size = 0 1567 uint32_t rep_len = 0, rep_code_size = 0; 1568 1568 1569 switch (sym) 1569 switch (sym) 1570 { 1570 { 1571 case 16: 1571 case 16: 1572 { 1572 { 1573 TOOLS_FPNG_GET_BITS(rep_len, 2); 1573 TOOLS_FPNG_GET_BITS(rep_len, 2); 1574 rep_len += 3; 1574 rep_len += 3; 1575 if (!cur_code) 1575 if (!cur_code) 1576 return false; 1576 return false; 1577 rep_code_size = code_sizes[cur_code - 1577 rep_code_size = code_sizes[cur_code - 1]; 1578 break; 1578 break; 1579 } 1579 } 1580 case 17: 1580 case 17: 1581 { 1581 { 1582 TOOLS_FPNG_GET_BITS(rep_len, 3); 1582 TOOLS_FPNG_GET_BITS(rep_len, 3); 1583 rep_len += 3; 1583 rep_len += 3; 1584 rep_code_size = 0; 1584 rep_code_size = 0; 1585 break; 1585 break; 1586 } 1586 } 1587 case 18: 1587 case 18: 1588 { 1588 { 1589 TOOLS_FPNG_GET_BITS(rep_len, 7); 1589 TOOLS_FPNG_GET_BITS(rep_len, 7); 1590 rep_len += 11; 1590 rep_len += 11; 1591 rep_code_size = 0; 1591 rep_code_size = 0; 1592 break; 1592 break; 1593 } 1593 } 1594 } 1594 } 1595 1595 1596 if ((cur_code + rep_len) > total_codes) 1596 if ((cur_code + rep_len) > total_codes) 1597 return false; 1597 return false; 1598 1598 1599 for (; rep_len; rep_len--) 1599 for (; rep_len; rep_len--) 1600 code_sizes[cur_code++] = (uint8_t)rep 1600 code_sizes[cur_code++] = (uint8_t)rep_code_size; 1601 } 1601 } 1602 1602 1603 uint8_t lit_codesizes[DEFL_MAX_HUFF_SYMBO 1603 uint8_t lit_codesizes[DEFL_MAX_HUFF_SYMBOLS_0]; 1604 1604 1605 memcpy(lit_codesizes, code_sizes, num_lit 1605 memcpy(lit_codesizes, code_sizes, num_lit_codes); 1606 memset(lit_codesizes + num_lit_codes, 0, 1606 memset(lit_codesizes + num_lit_codes, 0, DEFL_MAX_HUFF_SYMBOLS_0 - num_lit_codes); 1607 1607 1608 uint32_t total_valid_distcodes = 0; 1608 uint32_t total_valid_distcodes = 0; 1609 for (uint32_t i = 0; i < num_dist_codes; 1609 for (uint32_t i = 0; i < num_dist_codes; i++) 1610 total_valid_distcodes += (code_sizes[nu 1610 total_valid_distcodes += (code_sizes[num_lit_codes + i] == 1); 1611 1611 1612 // 1 or 2 because the first version of FP 1612 // 1 or 2 because the first version of FPNG only issued 1 valid distance code, but that upset wuffs. So we let 1 or 2 through. 1613 if ((total_valid_distcodes < 1) || (total 1613 if ((total_valid_distcodes < 1) || (total_valid_distcodes > 2)) 1614 return false; 1614 return false; 1615 1615 1616 if (code_sizes[num_lit_codes + (num_chans 1616 if (code_sizes[num_lit_codes + (num_chans - 1)] != 1) 1617 return false; 1617 return false; 1618 1618 1619 if (total_valid_distcodes == 2) 1619 if (total_valid_distcodes == 2) 1620 { 1620 { 1621 // If there are two valid distance code 1621 // If there are two valid distance codes, make sure the first is 1 bit. 1622 if (code_sizes[num_lit_codes + num_chan 1622 if (code_sizes[num_lit_codes + num_chans] != 1) 1623 return false; 1623 return false; 1624 } 1624 } 1625 1625 1626 if (!build_decoder_table(num_lit_codes, l 1626 if (!build_decoder_table(num_lit_codes, lit_codesizes, pLit_table)) 1627 return false; 1627 return false; 1628 1628 1629 // Add next symbol to decoder table, when 1629 // Add next symbol to decoder table, when it fits 1630 for (uint32_t i = 0; i < FPNG_DECODER_TAB 1630 for (uint32_t i = 0; i < FPNG_DECODER_TABLE_SIZE; i++) 1631 { 1631 { 1632 uint32_t sym = pLit_table[i] & 511; 1632 uint32_t sym = pLit_table[i] & 511; 1633 if (sym >= 256) 1633 if (sym >= 256) 1634 continue; 1634 continue; 1635 1635 1636 uint32_t sym_bits = (pLit_table[i] >> 9 1636 uint32_t sym_bits = (pLit_table[i] >> 9) & 15; 1637 if (!sym_bits) 1637 if (!sym_bits) 1638 continue; 1638 continue; 1639 assert(sym_bits <= FPNG_DECODER_TABLE_B 1639 assert(sym_bits <= FPNG_DECODER_TABLE_BITS); 1640 1640 1641 uint32_t bits_left = FPNG_DECODER_TABLE 1641 uint32_t bits_left = FPNG_DECODER_TABLE_BITS - sym_bits; 1642 if (bits_left < min_code_size) 1642 if (bits_left < min_code_size) 1643 continue; 1643 continue; 1644 1644 1645 uint32_t next_bits = i >> sym_bits; 1645 uint32_t next_bits = i >> sym_bits; 1646 uint32_t next_sym = pLit_table[next_bit 1646 uint32_t next_sym = pLit_table[next_bits] & 511; 1647 uint32_t next_sym_bits = (pLit_table[ne 1647 uint32_t next_sym_bits = (pLit_table[next_bits] >> 9) & 15; 1648 if ((!next_sym_bits) || (bits_left < ne 1648 if ((!next_sym_bits) || (bits_left < next_sym_bits)) 1649 continue; 1649 continue; 1650 1650 1651 pLit_table[i] |= (next_sym << 16) | (ne 1651 pLit_table[i] |= (next_sym << 16) | (next_sym_bits << (16 + 9)); 1652 } 1652 } 1653 1653 1654 return true; 1654 return true; 1655 } 1655 } 1656 1656 1657 static bool fpng_pixel_zlib_raw_decompress( 1657 static bool fpng_pixel_zlib_raw_decompress( 1658 const uint8_t* pSrc, uint32_t src_len, ui 1658 const uint8_t* pSrc, uint32_t src_len, uint32_t zlib_len, 1659 uint8_t* pDst, uint32_t w, uint32_t h, 1659 uint8_t* pDst, uint32_t w, uint32_t h, 1660 uint32_t src_chans, uint32_t dst_chans) 1660 uint32_t src_chans, uint32_t dst_chans) 1661 { 1661 { 1662 assert((src_chans == 3) || (src_chans == 1662 assert((src_chans == 3) || (src_chans == 4)); 1663 assert((dst_chans == 3) || (dst_chans == 1663 assert((dst_chans == 3) || (dst_chans == 4)); 1664 1664 1665 const uint32_t src_bpl = w * src_chans; 1665 const uint32_t src_bpl = w * src_chans; 1666 const uint32_t dst_bpl = w * dst_chans; 1666 const uint32_t dst_bpl = w * dst_chans; 1667 const uint32_t dst_len = dst_bpl * h; 1667 const uint32_t dst_len = dst_bpl * h; 1668 1668 1669 uint32_t src_ofs = 2; 1669 uint32_t src_ofs = 2; 1670 uint32_t dst_ofs = 0; 1670 uint32_t dst_ofs = 0; 1671 uint32_t raster_ofs = 0; 1671 uint32_t raster_ofs = 0; 1672 uint32_t comp_ofs = 0; 1672 uint32_t comp_ofs = 0; 1673 1673 1674 for (; ; ) 1674 for (; ; ) 1675 { 1675 { 1676 if ((src_ofs + 1) > src_len) 1676 if ((src_ofs + 1) > src_len) 1677 return false; 1677 return false; 1678 1678 1679 const bool bfinal = (pSrc[src_ofs] & 1) 1679 const bool bfinal = (pSrc[src_ofs] & 1) != 0; 1680 const uint32_t btype = (pSrc[src_ofs] > 1680 const uint32_t btype = (pSrc[src_ofs] >> 1) & 3; 1681 if (btype != 0) 1681 if (btype != 0) 1682 return false; 1682 return false; 1683 1683 1684 src_ofs++; 1684 src_ofs++; 1685 1685 1686 if ((src_ofs + 4) > src_len) 1686 if ((src_ofs + 4) > src_len) 1687 return false; 1687 return false; 1688 uint32_t len = pSrc[src_ofs + 0] | (pSr 1688 uint32_t len = pSrc[src_ofs + 0] | (pSrc[src_ofs + 1] << 8); 1689 uint32_t nlen = pSrc[src_ofs + 2] | (pS 1689 uint32_t nlen = pSrc[src_ofs + 2] | (pSrc[src_ofs + 3] << 8); 1690 src_ofs += 4; 1690 src_ofs += 4; 1691 1691 1692 if (len != (~nlen & 0xFFFF)) 1692 if (len != (~nlen & 0xFFFF)) 1693 return false; 1693 return false; 1694 1694 1695 if ((src_ofs + len) > src_len) 1695 if ((src_ofs + len) > src_len) 1696 return false; 1696 return false; 1697 1697 1698 // Raw blocks are a relatively uncommon 1698 // Raw blocks are a relatively uncommon case so this isn't well optimized. 1699 // Supports 3->4 and 4->3 byte/pixel co 1699 // Supports 3->4 and 4->3 byte/pixel conversion. 1700 for (uint32_t i = 0; i < len; i++) 1700 for (uint32_t i = 0; i < len; i++) 1701 { 1701 { 1702 uint32_t c = pSrc[src_ofs + i]; 1702 uint32_t c = pSrc[src_ofs + i]; 1703 1703 1704 if (!raster_ofs) 1704 if (!raster_ofs) 1705 { 1705 { 1706 // Check filter type 1706 // Check filter type 1707 if (c != 0) 1707 if (c != 0) 1708 return false; 1708 return false; 1709 1709 1710 assert(!comp_ofs); 1710 assert(!comp_ofs); 1711 } 1711 } 1712 else 1712 else 1713 { 1713 { 1714 if (comp_ofs < dst_chans) 1714 if (comp_ofs < dst_chans) 1715 { 1715 { 1716 if (dst_ofs == dst_len) 1716 if (dst_ofs == dst_len) 1717 return false; 1717 return false; 1718 1718 1719 pDst[dst_ofs++] = (uint8_t)c; 1719 pDst[dst_ofs++] = (uint8_t)c; 1720 } 1720 } 1721 1721 1722 if (++comp_ofs == src_chans) 1722 if (++comp_ofs == src_chans) 1723 { 1723 { 1724 if (dst_chans > src_chans) 1724 if (dst_chans > src_chans) 1725 { 1725 { 1726 if (dst_ofs == dst_len) 1726 if (dst_ofs == dst_len) 1727 return false; 1727 return false; 1728 1728 1729 pDst[dst_ofs++] = (uint8_t)0xFF 1729 pDst[dst_ofs++] = (uint8_t)0xFF; 1730 } 1730 } 1731 1731 1732 comp_ofs = 0; 1732 comp_ofs = 0; 1733 } 1733 } 1734 } 1734 } 1735 1735 1736 if (++raster_ofs == (src_bpl + 1)) 1736 if (++raster_ofs == (src_bpl + 1)) 1737 { 1737 { 1738 assert(!comp_ofs); 1738 assert(!comp_ofs); 1739 raster_ofs = 0; 1739 raster_ofs = 0; 1740 } 1740 } 1741 } 1741 } 1742 1742 1743 src_ofs += len; 1743 src_ofs += len; 1744 1744 1745 if (bfinal) 1745 if (bfinal) 1746 break; 1746 break; 1747 } 1747 } 1748 1748 1749 if (comp_ofs != 0) 1749 if (comp_ofs != 0) 1750 return false; 1750 return false; 1751 1751 1752 // Check for zlib adler32 1752 // Check for zlib adler32 1753 if ((src_ofs + 4) != zlib_len) 1753 if ((src_ofs + 4) != zlib_len) 1754 return false; 1754 return false; 1755 1755 1756 return (dst_ofs == dst_len); 1756 return (dst_ofs == dst_len); 1757 } 1757 } 1758 1758 1759 template<uint32_t dst_comps> 1759 template<uint32_t dst_comps> 1760 static bool fpng_pixel_zlib_decompress_3( 1760 static bool fpng_pixel_zlib_decompress_3( 1761 const uint8_t* pSrc, uint32_t src_len, ui 1761 const uint8_t* pSrc, uint32_t src_len, uint32_t zlib_len, 1762 uint8_t* pDst, uint32_t w, uint32_t h) 1762 uint8_t* pDst, uint32_t w, uint32_t h) 1763 { 1763 { 1764 assert(src_len >= (zlib_len + 4)); 1764 assert(src_len >= (zlib_len + 4)); 1765 1765 1766 const uint32_t dst_bpl = w * dst_comps; 1766 const uint32_t dst_bpl = w * dst_comps; 1767 //const uint32_t dst_len = dst_bpl * h; 1767 //const uint32_t dst_len = dst_bpl * h; 1768 1768 1769 if (zlib_len < 7) 1769 if (zlib_len < 7) 1770 return false; 1770 return false; 1771 1771 1772 // check zlib header 1772 // check zlib header 1773 if ((pSrc[0] != 0x78) || (pSrc[1] != 0x01 1773 if ((pSrc[0] != 0x78) || (pSrc[1] != 0x01)) 1774 return false; 1774 return false; 1775 1775 1776 uint32_t src_ofs = 2; 1776 uint32_t src_ofs = 2; 1777 1777 1778 if ((pSrc[src_ofs] & 6) == 0) 1778 if ((pSrc[src_ofs] & 6) == 0) 1779 return fpng_pixel_zlib_raw_decompress(p 1779 return fpng_pixel_zlib_raw_decompress(pSrc, src_len, zlib_len, pDst, w, h, 3, dst_comps); 1780 1780 1781 if ((src_ofs + 4) > src_len) 1781 if ((src_ofs + 4) > src_len) 1782 return false; 1782 return false; 1783 uint64_t bit_buf = READ_LE32(pSrc + src_o 1783 uint64_t bit_buf = READ_LE32(pSrc + src_ofs); 1784 src_ofs += 4; 1784 src_ofs += 4; 1785 1785 1786 uint32_t bit_buf_size = 32; 1786 uint32_t bit_buf_size = 32; 1787 1787 1788 uint32_t bfinal, btype; 1788 uint32_t bfinal, btype; 1789 TOOLS_FPNG_GET_BITS(bfinal, 1); 1789 TOOLS_FPNG_GET_BITS(bfinal, 1); 1790 TOOLS_FPNG_GET_BITS(btype, 2); 1790 TOOLS_FPNG_GET_BITS(btype, 2); 1791 1791 1792 // Must be the final block or it's not va 1792 // Must be the final block or it's not valid, and type=2 (dynamic) 1793 if ((bfinal != 1) || (btype != 2)) 1793 if ((bfinal != 1) || (btype != 2)) 1794 return false; 1794 return false; 1795 1795 1796 uint32_t lit_table[FPNG_DECODER_TABLE_SIZ 1796 uint32_t lit_table[FPNG_DECODER_TABLE_SIZE]; 1797 if (!prepare_dynamic_block(pSrc, src_len, 1797 if (!prepare_dynamic_block(pSrc, src_len, src_ofs, bit_buf_size, bit_buf, lit_table, 3)) 1798 return false; 1798 return false; 1799 1799 1800 const uint8_t* pPrev_scanline = NULL/*nul 1800 const uint8_t* pPrev_scanline = NULL/*nullptr*/; 1801 uint8_t* pCur_scanline = pDst; 1801 uint8_t* pCur_scanline = pDst; 1802 1802 1803 for (uint32_t y = 0; y < h; y++) 1803 for (uint32_t y = 0; y < h; y++) 1804 { 1804 { 1805 // At start of PNG scanline, so read th 1805 // At start of PNG scanline, so read the filter literal 1806 assert(bit_buf_size >= FPNG_DECODER_TAB 1806 assert(bit_buf_size >= FPNG_DECODER_TABLE_BITS); 1807 uint32_t filter = lit_table[bit_buf & ( 1807 uint32_t filter = lit_table[bit_buf & (FPNG_DECODER_TABLE_SIZE - 1)]; 1808 uint32_t filter_len = (filter >> 9) & 1 1808 uint32_t filter_len = (filter >> 9) & 15; 1809 if (!filter_len) 1809 if (!filter_len) 1810 return false; 1810 return false; 1811 TOOLS_FPNG_SKIP_BITS(filter_len); 1811 TOOLS_FPNG_SKIP_BITS(filter_len); 1812 filter &= 511; 1812 filter &= 511; 1813 1813 1814 uint32_t expected_filter = (y ? 2 : 0); 1814 uint32_t expected_filter = (y ? 2 : 0); 1815 if (filter != expected_filter) 1815 if (filter != expected_filter) 1816 return false; 1816 return false; 1817 1817 1818 uint32_t x_ofs = 0; 1818 uint32_t x_ofs = 0; 1819 uint8_t prev_delta_r = 0, prev_delta_g 1819 uint8_t prev_delta_r = 0, prev_delta_g = 0, prev_delta_b = 0; 1820 do 1820 do 1821 { 1821 { 1822 assert(bit_buf_size >= FPNG_DECODER_T 1822 assert(bit_buf_size >= FPNG_DECODER_TABLE_BITS); 1823 uint32_t lit0_tab = lit_table[bit_buf 1823 uint32_t lit0_tab = lit_table[bit_buf & (FPNG_DECODER_TABLE_SIZE - 1)]; 1824 1824 1825 uint32_t lit0 = lit0_tab; 1825 uint32_t lit0 = lit0_tab; 1826 uint32_t lit0_len = (lit0_tab >> 9) & 1826 uint32_t lit0_len = (lit0_tab >> 9) & 15; 1827 if (!lit0_len) 1827 if (!lit0_len) 1828 return false; 1828 return false; 1829 TOOLS_FPNG_SKIP_BITS(lit0_len); 1829 TOOLS_FPNG_SKIP_BITS(lit0_len); 1830 1830 1831 if (lit0 & 256) 1831 if (lit0 & 256) 1832 { 1832 { 1833 lit0 &= 511; 1833 lit0 &= 511; 1834 1834 1835 // Can't be EOB - we still have mor 1835 // Can't be EOB - we still have more pixels to decompress. 1836 if (lit0 == 256) 1836 if (lit0 == 256) 1837 return false; 1837 return false; 1838 1838 1839 // Must be an RLE match against the 1839 // Must be an RLE match against the previous pixel. 1840 uint32_t run_len = s_length_range[l 1840 uint32_t run_len = s_length_range[lit0 - 257]; 1841 if (lit0 >= 265) 1841 if (lit0 >= 265) 1842 { 1842 { 1843 uint32_t e; 1843 uint32_t e; 1844 TOOLS_FPNG_GET_BITS_NE(e, s_lengt 1844 TOOLS_FPNG_GET_BITS_NE(e, s_length_extra[lit0 - 257]); 1845 1845 1846 run_len += e; 1846 run_len += e; 1847 } 1847 } 1848 1848 1849 // Skip match distance - it's alway 1849 // Skip match distance - it's always the same (3) 1850 TOOLS_FPNG_SKIP_BITS_NE(1); 1850 TOOLS_FPNG_SKIP_BITS_NE(1); 1851 1851 1852 // Matches must always be a multipl 1852 // Matches must always be a multiple of 3/4 bytes 1853 assert((run_len % 3) == 0); 1853 assert((run_len % 3) == 0); 1854 1854 1855 if (dst_comps == 4) 1855 if (dst_comps == 4) 1856 { 1856 { 1857 const uint32_t x_ofs_end = x_ofs 1857 const uint32_t x_ofs_end = x_ofs + g_run_len3_to_4[run_len]; 1858 1858 1859 // Check for valid run lengths 1859 // Check for valid run lengths 1860 if (x_ofs == x_ofs_end) 1860 if (x_ofs == x_ofs_end) 1861 return false; 1861 return false; 1862 1862 1863 // Matches cannot cross scanlines 1863 // Matches cannot cross scanlines. 1864 if (x_ofs_end > dst_bpl) 1864 if (x_ofs_end > dst_bpl) 1865 return false; 1865 return false; 1866 1866 1867 if (pPrev_scanline) 1867 if (pPrev_scanline) 1868 { 1868 { 1869 if ((prev_delta_r | prev_delta_ 1869 if ((prev_delta_r | prev_delta_g | prev_delta_b) == 0) 1870 { 1870 { 1871 memcpy(pCur_scanline + x_ofs, 1871 memcpy(pCur_scanline + x_ofs, pPrev_scanline + x_ofs, x_ofs_end - x_ofs); 1872 x_ofs = x_ofs_end; 1872 x_ofs = x_ofs_end; 1873 } 1873 } 1874 else 1874 else 1875 { 1875 { 1876 do 1876 do 1877 { 1877 { 1878 pCur_scanline[x_ofs] = (uin 1878 pCur_scanline[x_ofs] = (uint8_t)(pPrev_scanline[x_ofs] + prev_delta_r); 1879 pCur_scanline[x_ofs + 1] = 1879 pCur_scanline[x_ofs + 1] = (uint8_t)(pPrev_scanline[x_ofs + 1] + prev_delta_g); 1880 pCur_scanline[x_ofs + 2] = 1880 pCur_scanline[x_ofs + 2] = (uint8_t)(pPrev_scanline[x_ofs + 2] + prev_delta_b); 1881 pCur_scanline[x_ofs + 3] = 1881 pCur_scanline[x_ofs + 3] = 0xFF; 1882 x_ofs += 4; 1882 x_ofs += 4; 1883 } while (x_ofs < x_ofs_end); 1883 } while (x_ofs < x_ofs_end); 1884 } 1884 } 1885 } 1885 } 1886 else 1886 else 1887 { 1887 { 1888 do 1888 do 1889 { 1889 { 1890 pCur_scanline[x_ofs] = prev_d 1890 pCur_scanline[x_ofs] = prev_delta_r; 1891 pCur_scanline[x_ofs + 1] = pr 1891 pCur_scanline[x_ofs + 1] = prev_delta_g; 1892 pCur_scanline[x_ofs + 2] = pr 1892 pCur_scanline[x_ofs + 2] = prev_delta_b; 1893 pCur_scanline[x_ofs + 3] = 0x 1893 pCur_scanline[x_ofs + 3] = 0xFF; 1894 x_ofs += 4; 1894 x_ofs += 4; 1895 } while (x_ofs < x_ofs_end); 1895 } while (x_ofs < x_ofs_end); 1896 } 1896 } 1897 } 1897 } 1898 else 1898 else 1899 { 1899 { 1900 // Check for valid run lengths 1900 // Check for valid run lengths 1901 if (!g_run_len3_to_4[run_len]) 1901 if (!g_run_len3_to_4[run_len]) 1902 return false; 1902 return false; 1903 1903 1904 const uint32_t x_ofs_end = x_ofs 1904 const uint32_t x_ofs_end = x_ofs + run_len; 1905 1905 1906 // Matches cannot cross scanlines 1906 // Matches cannot cross scanlines. 1907 if (x_ofs_end > dst_bpl) 1907 if (x_ofs_end > dst_bpl) 1908 return false; 1908 return false; 1909 1909 1910 if (pPrev_scanline) 1910 if (pPrev_scanline) 1911 { 1911 { 1912 if ((prev_delta_r | prev_delta_ 1912 if ((prev_delta_r | prev_delta_g | prev_delta_b) == 0) 1913 { 1913 { 1914 memcpy(pCur_scanline + x_ofs, 1914 memcpy(pCur_scanline + x_ofs, pPrev_scanline + x_ofs, run_len); 1915 x_ofs = x_ofs_end; 1915 x_ofs = x_ofs_end; 1916 } 1916 } 1917 else 1917 else 1918 { 1918 { 1919 do 1919 do 1920 { 1920 { 1921 pCur_scanline[x_ofs] = (uin 1921 pCur_scanline[x_ofs] = (uint8_t)(pPrev_scanline[x_ofs] + prev_delta_r); 1922 pCur_scanline[x_ofs + 1] = 1922 pCur_scanline[x_ofs + 1] = (uint8_t)(pPrev_scanline[x_ofs + 1] + prev_delta_g); 1923 pCur_scanline[x_ofs + 2] = 1923 pCur_scanline[x_ofs + 2] = (uint8_t)(pPrev_scanline[x_ofs + 2] + prev_delta_b); 1924 x_ofs += 3; 1924 x_ofs += 3; 1925 } while (x_ofs < x_ofs_end); 1925 } while (x_ofs < x_ofs_end); 1926 } 1926 } 1927 } 1927 } 1928 else 1928 else 1929 { 1929 { 1930 do 1930 do 1931 { 1931 { 1932 pCur_scanline[x_ofs] = prev_d 1932 pCur_scanline[x_ofs] = prev_delta_r; 1933 pCur_scanline[x_ofs + 1] = pr 1933 pCur_scanline[x_ofs + 1] = prev_delta_g; 1934 pCur_scanline[x_ofs + 2] = pr 1934 pCur_scanline[x_ofs + 2] = prev_delta_b; 1935 x_ofs += 3; 1935 x_ofs += 3; 1936 } while (x_ofs < x_ofs_end); 1936 } while (x_ofs < x_ofs_end); 1937 } 1937 } 1938 } 1938 } 1939 } 1939 } 1940 else 1940 else 1941 { 1941 { 1942 uint32_t lit1, lit2; 1942 uint32_t lit1, lit2; 1943 1943 1944 uint32_t lit1_spec_len = (lit0_tab 1944 uint32_t lit1_spec_len = (lit0_tab >> (16 + 9)); 1945 uint32_t lit2_len; 1945 uint32_t lit2_len; 1946 if (lit1_spec_len) 1946 if (lit1_spec_len) 1947 { 1947 { 1948 lit1 = (lit0_tab >> 16) & 511; 1948 lit1 = (lit0_tab >> 16) & 511; 1949 TOOLS_FPNG_SKIP_BITS_NE(lit1_spec 1949 TOOLS_FPNG_SKIP_BITS_NE(lit1_spec_len); 1950 1950 1951 assert(bit_buf_size >= FPNG_DECOD 1951 assert(bit_buf_size >= FPNG_DECODER_TABLE_BITS); 1952 lit2 = lit_table[bit_buf & (FPNG_ 1952 lit2 = lit_table[bit_buf & (FPNG_DECODER_TABLE_SIZE - 1)]; 1953 lit2_len = (lit2 >> 9) & 15; 1953 lit2_len = (lit2 >> 9) & 15; 1954 if (!lit2_len) 1954 if (!lit2_len) 1955 return false; 1955 return false; 1956 } 1956 } 1957 else 1957 else 1958 { 1958 { 1959 assert(bit_buf_size >= FPNG_DECOD 1959 assert(bit_buf_size >= FPNG_DECODER_TABLE_BITS); 1960 lit1 = lit_table[bit_buf & (FPNG_ 1960 lit1 = lit_table[bit_buf & (FPNG_DECODER_TABLE_SIZE - 1)]; 1961 uint32_t lit1_len = (lit1 >> 9) & 1961 uint32_t lit1_len = (lit1 >> 9) & 15; 1962 if (!lit1_len) 1962 if (!lit1_len) 1963 return false; 1963 return false; 1964 TOOLS_FPNG_SKIP_BITS_NE(lit1_len) 1964 TOOLS_FPNG_SKIP_BITS_NE(lit1_len); 1965 1965 1966 lit2_len = (lit1 >> (16 + 9)); 1966 lit2_len = (lit1 >> (16 + 9)); 1967 if (lit2_len) 1967 if (lit2_len) 1968 lit2 = lit1 >> 16; 1968 lit2 = lit1 >> 16; 1969 else 1969 else 1970 { 1970 { 1971 assert(bit_buf_size >= FPNG_DEC 1971 assert(bit_buf_size >= FPNG_DECODER_TABLE_BITS); 1972 lit2 = lit_table[bit_buf & (FPN 1972 lit2 = lit_table[bit_buf & (FPNG_DECODER_TABLE_SIZE - 1)]; 1973 lit2_len = (lit2 >> 9) & 15; 1973 lit2_len = (lit2 >> 9) & 15; 1974 if (!lit2_len) 1974 if (!lit2_len) 1975 return false; 1975 return false; 1976 } 1976 } 1977 } 1977 } 1978 1978 1979 TOOLS_FPNG_SKIP_BITS(lit2_len); 1979 TOOLS_FPNG_SKIP_BITS(lit2_len); 1980 1980 1981 // Check for matches 1981 // Check for matches 1982 if ((lit1 | lit2) & 256) 1982 if ((lit1 | lit2) & 256) 1983 return false; 1983 return false; 1984 1984 1985 if (dst_comps == 4) 1985 if (dst_comps == 4) 1986 { 1986 { 1987 if (pPrev_scanline) 1987 if (pPrev_scanline) 1988 { 1988 { 1989 pCur_scanline[x_ofs] = (uint8_t 1989 pCur_scanline[x_ofs] = (uint8_t)(pPrev_scanline[x_ofs] + lit0); 1990 pCur_scanline[x_ofs + 1] = (uin 1990 pCur_scanline[x_ofs + 1] = (uint8_t)(pPrev_scanline[x_ofs + 1] + lit1); 1991 pCur_scanline[x_ofs + 2] = (uin 1991 pCur_scanline[x_ofs + 2] = (uint8_t)(pPrev_scanline[x_ofs + 2] + lit2); 1992 pCur_scanline[x_ofs + 3] = 0xFF 1992 pCur_scanline[x_ofs + 3] = 0xFF; 1993 } 1993 } 1994 else 1994 else 1995 { 1995 { 1996 pCur_scanline[x_ofs] = (uint8_t 1996 pCur_scanline[x_ofs] = (uint8_t)lit0; 1997 pCur_scanline[x_ofs + 1] = (uin 1997 pCur_scanline[x_ofs + 1] = (uint8_t)lit1; 1998 pCur_scanline[x_ofs + 2] = (uin 1998 pCur_scanline[x_ofs + 2] = (uint8_t)lit2; 1999 pCur_scanline[x_ofs + 3] = 0xFF 1999 pCur_scanline[x_ofs + 3] = 0xFF; 2000 } 2000 } 2001 x_ofs += 4; 2001 x_ofs += 4; 2002 } 2002 } 2003 else 2003 else 2004 { 2004 { 2005 if (pPrev_scanline) 2005 if (pPrev_scanline) 2006 { 2006 { 2007 pCur_scanline[x_ofs] = (uint8_t 2007 pCur_scanline[x_ofs] = (uint8_t)(pPrev_scanline[x_ofs] + lit0); 2008 pCur_scanline[x_ofs + 1] = (uin 2008 pCur_scanline[x_ofs + 1] = (uint8_t)(pPrev_scanline[x_ofs + 1] + lit1); 2009 pCur_scanline[x_ofs + 2] = (uin 2009 pCur_scanline[x_ofs + 2] = (uint8_t)(pPrev_scanline[x_ofs + 2] + lit2); 2010 } 2010 } 2011 else 2011 else 2012 { 2012 { 2013 pCur_scanline[x_ofs] = (uint8_t 2013 pCur_scanline[x_ofs] = (uint8_t)lit0; 2014 pCur_scanline[x_ofs + 1] = (uin 2014 pCur_scanline[x_ofs + 1] = (uint8_t)lit1; 2015 pCur_scanline[x_ofs + 2] = (uin 2015 pCur_scanline[x_ofs + 2] = (uint8_t)lit2; 2016 } 2016 } 2017 x_ofs += 3; 2017 x_ofs += 3; 2018 } 2018 } 2019 2019 2020 prev_delta_r = (uint8_t)lit0; 2020 prev_delta_r = (uint8_t)lit0; 2021 prev_delta_g = (uint8_t)lit1; 2021 prev_delta_g = (uint8_t)lit1; 2022 prev_delta_b = (uint8_t)lit2; 2022 prev_delta_b = (uint8_t)lit2; 2023 2023 2024 // See if we can decode one more pi 2024 // See if we can decode one more pixel. 2025 uint32_t spec_next_len0_len = lit2 2025 uint32_t spec_next_len0_len = lit2 >> (16 + 9); 2026 if ((spec_next_len0_len) && (x_ofs 2026 if ((spec_next_len0_len) && (x_ofs < dst_bpl)) 2027 { 2027 { 2028 lit0 = (lit2 >> 16) & 511; 2028 lit0 = (lit2 >> 16) & 511; 2029 if (lit0 < 256) 2029 if (lit0 < 256) 2030 { 2030 { 2031 TOOLS_FPNG_SKIP_BITS_NE(spec_ne 2031 TOOLS_FPNG_SKIP_BITS_NE(spec_next_len0_len); 2032 2032 2033 assert(bit_buf_size >= FPNG_DEC 2033 assert(bit_buf_size >= FPNG_DECODER_TABLE_BITS); 2034 lit1 = lit_table[bit_buf & (FPN 2034 lit1 = lit_table[bit_buf & (FPNG_DECODER_TABLE_SIZE - 1)]; 2035 uint32_t lit1_len = (lit1 >> 9) 2035 uint32_t lit1_len = (lit1 >> 9) & 15; 2036 if (!lit1_len) 2036 if (!lit1_len) 2037 return false; 2037 return false; 2038 TOOLS_FPNG_SKIP_BITS(lit1_len); 2038 TOOLS_FPNG_SKIP_BITS(lit1_len); 2039 2039 2040 lit2_len = (lit1 >> (16 + 9)); 2040 lit2_len = (lit1 >> (16 + 9)); 2041 if (lit2_len) 2041 if (lit2_len) 2042 lit2 = lit1 >> 16; 2042 lit2 = lit1 >> 16; 2043 else 2043 else 2044 { 2044 { 2045 assert(bit_buf_size >= FPNG_D 2045 assert(bit_buf_size >= FPNG_DECODER_TABLE_BITS); 2046 lit2 = lit_table[bit_buf & (F 2046 lit2 = lit_table[bit_buf & (FPNG_DECODER_TABLE_SIZE - 1)]; 2047 lit2_len = (lit2 >> 9) & 15; 2047 lit2_len = (lit2 >> 9) & 15; 2048 if (!lit2_len) 2048 if (!lit2_len) 2049 return false; 2049 return false; 2050 } 2050 } 2051 2051 2052 TOOLS_FPNG_SKIP_BITS_NE(lit2_le 2052 TOOLS_FPNG_SKIP_BITS_NE(lit2_len); 2053 2053 2054 // Check for matches 2054 // Check for matches 2055 if ((lit1 | lit2) & 256) 2055 if ((lit1 | lit2) & 256) 2056 return false; 2056 return false; 2057 2057 2058 if (dst_comps == 4) 2058 if (dst_comps == 4) 2059 { 2059 { 2060 if (pPrev_scanline) 2060 if (pPrev_scanline) 2061 { 2061 { 2062 pCur_scanline[x_ofs] = (uin 2062 pCur_scanline[x_ofs] = (uint8_t)(pPrev_scanline[x_ofs] + lit0); 2063 pCur_scanline[x_ofs + 1] = 2063 pCur_scanline[x_ofs + 1] = (uint8_t)(pPrev_scanline[x_ofs + 1] + lit1); 2064 pCur_scanline[x_ofs + 2] = 2064 pCur_scanline[x_ofs + 2] = (uint8_t)(pPrev_scanline[x_ofs + 2] + lit2); 2065 pCur_scanline[x_ofs + 3] = 2065 pCur_scanline[x_ofs + 3] = 0xFF; 2066 } 2066 } 2067 else 2067 else 2068 { 2068 { 2069 pCur_scanline[x_ofs] = (uin 2069 pCur_scanline[x_ofs] = (uint8_t)lit0; 2070 pCur_scanline[x_ofs + 1] = 2070 pCur_scanline[x_ofs + 1] = (uint8_t)lit1; 2071 pCur_scanline[x_ofs + 2] = 2071 pCur_scanline[x_ofs + 2] = (uint8_t)lit2; 2072 pCur_scanline[x_ofs + 3] = 2072 pCur_scanline[x_ofs + 3] = 0xFF; 2073 } 2073 } 2074 x_ofs += 4; 2074 x_ofs += 4; 2075 } 2075 } 2076 else 2076 else 2077 { 2077 { 2078 if (pPrev_scanline) 2078 if (pPrev_scanline) 2079 { 2079 { 2080 pCur_scanline[x_ofs] = (uin 2080 pCur_scanline[x_ofs] = (uint8_t)(pPrev_scanline[x_ofs] + lit0); 2081 pCur_scanline[x_ofs + 1] = 2081 pCur_scanline[x_ofs + 1] = (uint8_t)(pPrev_scanline[x_ofs + 1] + lit1); 2082 pCur_scanline[x_ofs + 2] = 2082 pCur_scanline[x_ofs + 2] = (uint8_t)(pPrev_scanline[x_ofs + 2] + lit2); 2083 } 2083 } 2084 else 2084 else 2085 { 2085 { 2086 pCur_scanline[x_ofs] = (uin 2086 pCur_scanline[x_ofs] = (uint8_t)lit0; 2087 pCur_scanline[x_ofs + 1] = 2087 pCur_scanline[x_ofs + 1] = (uint8_t)lit1; 2088 pCur_scanline[x_ofs + 2] = 2088 pCur_scanline[x_ofs + 2] = (uint8_t)lit2; 2089 } 2089 } 2090 x_ofs += 3; 2090 x_ofs += 3; 2091 } 2091 } 2092 2092 2093 prev_delta_r = (uint8_t)lit0; 2093 prev_delta_r = (uint8_t)lit0; 2094 prev_delta_g = (uint8_t)lit1; 2094 prev_delta_g = (uint8_t)lit1; 2095 prev_delta_b = (uint8_t)lit2; 2095 prev_delta_b = (uint8_t)lit2; 2096 2096 2097 } // if (lit0 < 256) 2097 } // if (lit0 < 256) 2098 2098 2099 } // if ((spec_next_len0_len) && (x 2099 } // if ((spec_next_len0_len) && (x_ofs < bpl)) 2100 } 2100 } 2101 2101 2102 } while (x_ofs < dst_bpl); 2102 } while (x_ofs < dst_bpl); 2103 2103 2104 pPrev_scanline = pCur_scanline; 2104 pPrev_scanline = pCur_scanline; 2105 pCur_scanline += dst_bpl; 2105 pCur_scanline += dst_bpl; 2106 2106 2107 } // y 2107 } // y 2108 2108 2109 // The last symbol should be EOB 2109 // The last symbol should be EOB 2110 assert(bit_buf_size >= FPNG_DECODER_TABLE 2110 assert(bit_buf_size >= FPNG_DECODER_TABLE_BITS); 2111 uint32_t lit0 = lit_table[bit_buf & (FPNG 2111 uint32_t lit0 = lit_table[bit_buf & (FPNG_DECODER_TABLE_SIZE - 1)]; 2112 uint32_t lit0_len = (lit0 >> 9) & 15; 2112 uint32_t lit0_len = (lit0 >> 9) & 15; 2113 if (!lit0_len) 2113 if (!lit0_len) 2114 return false; 2114 return false; 2115 lit0 &= 511; 2115 lit0 &= 511; 2116 if (lit0 != 256) 2116 if (lit0 != 256) 2117 return false; 2117 return false; 2118 2118 2119 bit_buf_size -= lit0_len; 2119 bit_buf_size -= lit0_len; 2120 bit_buf >>= lit0_len; 2120 bit_buf >>= lit0_len; 2121 2121 2122 uint32_t align_bits = bit_buf_size & 7; 2122 uint32_t align_bits = bit_buf_size & 7; 2123 bit_buf_size -= align_bits; 2123 bit_buf_size -= align_bits; 2124 bit_buf >>= align_bits; 2124 bit_buf >>= align_bits; 2125 2125 2126 if (src_ofs < (bit_buf_size >> 3)) 2126 if (src_ofs < (bit_buf_size >> 3)) 2127 return false; 2127 return false; 2128 src_ofs -= (bit_buf_size >> 3); 2128 src_ofs -= (bit_buf_size >> 3); 2129 2129 2130 // We should be at the very end, because 2130 // We should be at the very end, because the bit buf reads ahead 32-bits (which contains the zlib adler32). 2131 if ((src_ofs + 4) != zlib_len) 2131 if ((src_ofs + 4) != zlib_len) 2132 return false; 2132 return false; 2133 2133 2134 return true; 2134 return true; 2135 } 2135 } 2136 2136 2137 template<uint32_t dst_comps> 2137 template<uint32_t dst_comps> 2138 static bool fpng_pixel_zlib_decompress_4( 2138 static bool fpng_pixel_zlib_decompress_4( 2139 const uint8_t* pSrc, uint32_t src_len, ui 2139 const uint8_t* pSrc, uint32_t src_len, uint32_t zlib_len, 2140 uint8_t* pDst, uint32_t w, uint32_t h) 2140 uint8_t* pDst, uint32_t w, uint32_t h) 2141 { 2141 { 2142 assert(src_len >= (zlib_len + 4)); 2142 assert(src_len >= (zlib_len + 4)); 2143 2143 2144 const uint32_t dst_bpl = w * dst_comps; 2144 const uint32_t dst_bpl = w * dst_comps; 2145 //const uint32_t dst_len = dst_bpl * h; 2145 //const uint32_t dst_len = dst_bpl * h; 2146 2146 2147 if (zlib_len < 7) 2147 if (zlib_len < 7) 2148 return false; 2148 return false; 2149 2149 2150 // check zlib header 2150 // check zlib header 2151 if ((pSrc[0] != 0x78) || (pSrc[1] != 0x01 2151 if ((pSrc[0] != 0x78) || (pSrc[1] != 0x01)) 2152 return false; 2152 return false; 2153 2153 2154 uint32_t src_ofs = 2; 2154 uint32_t src_ofs = 2; 2155 2155 2156 if ((pSrc[src_ofs] & 6) == 0) 2156 if ((pSrc[src_ofs] & 6) == 0) 2157 return fpng_pixel_zlib_raw_decompress(p 2157 return fpng_pixel_zlib_raw_decompress(pSrc, src_len, zlib_len, pDst, w, h, 4, dst_comps); 2158 2158 2159 if ((src_ofs + 4) > src_len) 2159 if ((src_ofs + 4) > src_len) 2160 return false; 2160 return false; 2161 uint64_t bit_buf = READ_LE32(pSrc + src_o 2161 uint64_t bit_buf = READ_LE32(pSrc + src_ofs); 2162 src_ofs += 4; 2162 src_ofs += 4; 2163 2163 2164 uint32_t bit_buf_size = 32; 2164 uint32_t bit_buf_size = 32; 2165 2165 2166 uint32_t bfinal, btype; 2166 uint32_t bfinal, btype; 2167 TOOLS_FPNG_GET_BITS(bfinal, 1); 2167 TOOLS_FPNG_GET_BITS(bfinal, 1); 2168 TOOLS_FPNG_GET_BITS(btype, 2); 2168 TOOLS_FPNG_GET_BITS(btype, 2); 2169 2169 2170 // Must be the final block or it's not va 2170 // Must be the final block or it's not valid, and type=2 (dynamic) 2171 if ((bfinal != 1) || (btype != 2)) 2171 if ((bfinal != 1) || (btype != 2)) 2172 return false; 2172 return false; 2173 2173 2174 uint32_t lit_table[FPNG_DECODER_TABLE_SIZ 2174 uint32_t lit_table[FPNG_DECODER_TABLE_SIZE]; 2175 if (!prepare_dynamic_block(pSrc, src_len, 2175 if (!prepare_dynamic_block(pSrc, src_len, src_ofs, bit_buf_size, bit_buf, lit_table, 4)) 2176 return false; 2176 return false; 2177 2177 2178 const uint8_t* pPrev_scanline = NULL/*nul 2178 const uint8_t* pPrev_scanline = NULL/*nullptr*/; 2179 uint8_t* pCur_scanline = pDst; 2179 uint8_t* pCur_scanline = pDst; 2180 2180 2181 for (uint32_t y = 0; y < h; y++) 2181 for (uint32_t y = 0; y < h; y++) 2182 { 2182 { 2183 // At start of PNG scanline, so read th 2183 // At start of PNG scanline, so read the filter literal 2184 assert(bit_buf_size >= FPNG_DECODER_TAB 2184 assert(bit_buf_size >= FPNG_DECODER_TABLE_BITS); 2185 uint32_t filter = lit_table[bit_buf & ( 2185 uint32_t filter = lit_table[bit_buf & (FPNG_DECODER_TABLE_SIZE - 1)]; 2186 uint32_t filter_len = (filter >> 9) & 1 2186 uint32_t filter_len = (filter >> 9) & 15; 2187 if (!filter_len) 2187 if (!filter_len) 2188 return false; 2188 return false; 2189 TOOLS_FPNG_SKIP_BITS(filter_len); 2189 TOOLS_FPNG_SKIP_BITS(filter_len); 2190 filter &= 511; 2190 filter &= 511; 2191 2191 2192 uint32_t expected_filter = (y ? 2 : 0); 2192 uint32_t expected_filter = (y ? 2 : 0); 2193 if (filter != expected_filter) 2193 if (filter != expected_filter) 2194 return false; 2194 return false; 2195 2195 2196 uint32_t x_ofs = 0; 2196 uint32_t x_ofs = 0; 2197 uint8_t prev_delta_r = 0, prev_delta_g 2197 uint8_t prev_delta_r = 0, prev_delta_g = 0, prev_delta_b = 0, prev_delta_a = 0; 2198 do 2198 do 2199 { 2199 { 2200 assert(bit_buf_size >= FPNG_DECODER_T 2200 assert(bit_buf_size >= FPNG_DECODER_TABLE_BITS); 2201 uint32_t lit0_tab = lit_table[bit_buf 2201 uint32_t lit0_tab = lit_table[bit_buf & (FPNG_DECODER_TABLE_SIZE - 1)]; 2202 2202 2203 uint32_t lit0 = lit0_tab; 2203 uint32_t lit0 = lit0_tab; 2204 uint32_t lit0_len = (lit0_tab >> 9) & 2204 uint32_t lit0_len = (lit0_tab >> 9) & 15; 2205 if (!lit0_len) 2205 if (!lit0_len) 2206 return false; 2206 return false; 2207 TOOLS_FPNG_SKIP_BITS(lit0_len); 2207 TOOLS_FPNG_SKIP_BITS(lit0_len); 2208 2208 2209 if (lit0 & 256) 2209 if (lit0 & 256) 2210 { 2210 { 2211 lit0 &= 511; 2211 lit0 &= 511; 2212 2212 2213 // Can't be EOB - we still have mor 2213 // Can't be EOB - we still have more pixels to decompress. 2214 if (lit0 == 256) 2214 if (lit0 == 256) 2215 return false; 2215 return false; 2216 2216 2217 // Must be an RLE match against the 2217 // Must be an RLE match against the previous pixel. 2218 uint32_t run_len = s_length_range[l 2218 uint32_t run_len = s_length_range[lit0 - 257]; 2219 if (lit0 >= 265) 2219 if (lit0 >= 265) 2220 { 2220 { 2221 uint32_t e; 2221 uint32_t e; 2222 TOOLS_FPNG_GET_BITS_NE(e, s_lengt 2222 TOOLS_FPNG_GET_BITS_NE(e, s_length_extra[lit0 - 257]); 2223 2223 2224 run_len += e; 2224 run_len += e; 2225 } 2225 } 2226 2226 2227 // Skip match distance - it's alway 2227 // Skip match distance - it's always the same (4) 2228 TOOLS_FPNG_SKIP_BITS_NE(1); 2228 TOOLS_FPNG_SKIP_BITS_NE(1); 2229 2229 2230 // Matches must always be a multipl 2230 // Matches must always be a multiple of 3/4 bytes 2231 if (run_len & 3) 2231 if (run_len & 3) 2232 return false; 2232 return false; 2233 2233 2234 if (dst_comps == 3) 2234 if (dst_comps == 3) 2235 { 2235 { 2236 const uint32_t run_len3 = (run_le 2236 const uint32_t run_len3 = (run_len >> 2) * 3; 2237 const uint32_t x_ofs_end = x_ofs 2237 const uint32_t x_ofs_end = x_ofs + run_len3; 2238 2238 2239 // Matches cannot cross scanlines 2239 // Matches cannot cross scanlines. 2240 if (x_ofs_end > dst_bpl) 2240 if (x_ofs_end > dst_bpl) 2241 return false; 2241 return false; 2242 2242 2243 if (pPrev_scanline) 2243 if (pPrev_scanline) 2244 { 2244 { 2245 if ((prev_delta_r | prev_delta_ 2245 if ((prev_delta_r | prev_delta_g | prev_delta_b | prev_delta_a) == 0) 2246 { 2246 { 2247 memcpy(pCur_scanline + x_ofs, 2247 memcpy(pCur_scanline + x_ofs, pPrev_scanline + x_ofs, run_len3); 2248 x_ofs = x_ofs_end; 2248 x_ofs = x_ofs_end; 2249 } 2249 } 2250 else 2250 else 2251 { 2251 { 2252 do 2252 do 2253 { 2253 { 2254 pCur_scanline[x_ofs] = (uin 2254 pCur_scanline[x_ofs] = (uint8_t)(pPrev_scanline[x_ofs] + prev_delta_r); 2255 pCur_scanline[x_ofs + 1] = 2255 pCur_scanline[x_ofs + 1] = (uint8_t)(pPrev_scanline[x_ofs + 1] + prev_delta_g); 2256 pCur_scanline[x_ofs + 2] = 2256 pCur_scanline[x_ofs + 2] = (uint8_t)(pPrev_scanline[x_ofs + 2] + prev_delta_b); 2257 x_ofs += 3; 2257 x_ofs += 3; 2258 } while (x_ofs < x_ofs_end); 2258 } while (x_ofs < x_ofs_end); 2259 } 2259 } 2260 } 2260 } 2261 else 2261 else 2262 { 2262 { 2263 do 2263 do 2264 { 2264 { 2265 pCur_scanline[x_ofs] = prev_d 2265 pCur_scanline[x_ofs] = prev_delta_r; 2266 pCur_scanline[x_ofs + 1] = pr 2266 pCur_scanline[x_ofs + 1] = prev_delta_g; 2267 pCur_scanline[x_ofs + 2] = pr 2267 pCur_scanline[x_ofs + 2] = prev_delta_b; 2268 x_ofs += 3; 2268 x_ofs += 3; 2269 } while (x_ofs < x_ofs_end); 2269 } while (x_ofs < x_ofs_end); 2270 } 2270 } 2271 } 2271 } 2272 else 2272 else 2273 { 2273 { 2274 const uint32_t x_ofs_end = x_ofs 2274 const uint32_t x_ofs_end = x_ofs + run_len; 2275 2275 2276 // Matches cannot cross scanlines 2276 // Matches cannot cross scanlines. 2277 if (x_ofs_end > dst_bpl) 2277 if (x_ofs_end > dst_bpl) 2278 return false; 2278 return false; 2279 2279 2280 if (pPrev_scanline) 2280 if (pPrev_scanline) 2281 { 2281 { 2282 if ((prev_delta_r | prev_delta_ 2282 if ((prev_delta_r | prev_delta_g | prev_delta_b | prev_delta_a) == 0) 2283 { 2283 { 2284 memcpy(pCur_scanline + x_ofs, 2284 memcpy(pCur_scanline + x_ofs, pPrev_scanline + x_ofs, run_len); 2285 x_ofs = x_ofs_end; 2285 x_ofs = x_ofs_end; 2286 } 2286 } 2287 else 2287 else 2288 { 2288 { 2289 do 2289 do 2290 { 2290 { 2291 pCur_scanline[x_ofs] = (uin 2291 pCur_scanline[x_ofs] = (uint8_t)(pPrev_scanline[x_ofs] + prev_delta_r); 2292 pCur_scanline[x_ofs + 1] = 2292 pCur_scanline[x_ofs + 1] = (uint8_t)(pPrev_scanline[x_ofs + 1] + prev_delta_g); 2293 pCur_scanline[x_ofs + 2] = 2293 pCur_scanline[x_ofs + 2] = (uint8_t)(pPrev_scanline[x_ofs + 2] + prev_delta_b); 2294 pCur_scanline[x_ofs + 3] = 2294 pCur_scanline[x_ofs + 3] = (uint8_t)(pPrev_scanline[x_ofs + 3] + prev_delta_a); 2295 x_ofs += 4; 2295 x_ofs += 4; 2296 } while (x_ofs < x_ofs_end); 2296 } while (x_ofs < x_ofs_end); 2297 } 2297 } 2298 } 2298 } 2299 else 2299 else 2300 { 2300 { 2301 do 2301 do 2302 { 2302 { 2303 pCur_scanline[x_ofs] = prev_d 2303 pCur_scanline[x_ofs] = prev_delta_r; 2304 pCur_scanline[x_ofs + 1] = pr 2304 pCur_scanline[x_ofs + 1] = prev_delta_g; 2305 pCur_scanline[x_ofs + 2] = pr 2305 pCur_scanline[x_ofs + 2] = prev_delta_b; 2306 pCur_scanline[x_ofs + 3] = pr 2306 pCur_scanline[x_ofs + 3] = prev_delta_a; 2307 x_ofs += 4; 2307 x_ofs += 4; 2308 } while (x_ofs < x_ofs_end); 2308 } while (x_ofs < x_ofs_end); 2309 } 2309 } 2310 } 2310 } 2311 } 2311 } 2312 else 2312 else 2313 { 2313 { 2314 uint32_t lit1, lit2; 2314 uint32_t lit1, lit2; 2315 2315 2316 uint32_t lit1_spec_len = (lit0_tab 2316 uint32_t lit1_spec_len = (lit0_tab >> (16 + 9)); 2317 uint32_t lit2_len; 2317 uint32_t lit2_len; 2318 if (lit1_spec_len) 2318 if (lit1_spec_len) 2319 { 2319 { 2320 lit1 = (lit0_tab >> 16) & 511; 2320 lit1 = (lit0_tab >> 16) & 511; 2321 TOOLS_FPNG_SKIP_BITS_NE(lit1_spec 2321 TOOLS_FPNG_SKIP_BITS_NE(lit1_spec_len); 2322 2322 2323 assert(bit_buf_size >= FPNG_DECOD 2323 assert(bit_buf_size >= FPNG_DECODER_TABLE_BITS); 2324 lit2 = lit_table[bit_buf & (FPNG_ 2324 lit2 = lit_table[bit_buf & (FPNG_DECODER_TABLE_SIZE - 1)]; 2325 lit2_len = (lit2 >> 9) & 15; 2325 lit2_len = (lit2 >> 9) & 15; 2326 if (!lit2_len) 2326 if (!lit2_len) 2327 return false; 2327 return false; 2328 } 2328 } 2329 else 2329 else 2330 { 2330 { 2331 assert(bit_buf_size >= FPNG_DECOD 2331 assert(bit_buf_size >= FPNG_DECODER_TABLE_BITS); 2332 lit1 = lit_table[bit_buf & (FPNG_ 2332 lit1 = lit_table[bit_buf & (FPNG_DECODER_TABLE_SIZE - 1)]; 2333 uint32_t lit1_len = (lit1 >> 9) & 2333 uint32_t lit1_len = (lit1 >> 9) & 15; 2334 if (!lit1_len) 2334 if (!lit1_len) 2335 return false; 2335 return false; 2336 TOOLS_FPNG_SKIP_BITS_NE(lit1_len) 2336 TOOLS_FPNG_SKIP_BITS_NE(lit1_len); 2337 2337 2338 lit2_len = (lit1 >> (16 + 9)); 2338 lit2_len = (lit1 >> (16 + 9)); 2339 if (lit2_len) 2339 if (lit2_len) 2340 lit2 = lit1 >> 16; 2340 lit2 = lit1 >> 16; 2341 else 2341 else 2342 { 2342 { 2343 assert(bit_buf_size >= FPNG_DEC 2343 assert(bit_buf_size >= FPNG_DECODER_TABLE_BITS); 2344 lit2 = lit_table[bit_buf & (FPN 2344 lit2 = lit_table[bit_buf & (FPNG_DECODER_TABLE_SIZE - 1)]; 2345 lit2_len = (lit2 >> 9) & 15; 2345 lit2_len = (lit2 >> 9) & 15; 2346 if (!lit2_len) 2346 if (!lit2_len) 2347 return false; 2347 return false; 2348 } 2348 } 2349 } 2349 } 2350 2350 2351 uint32_t lit3; 2351 uint32_t lit3; 2352 uint32_t lit3_len = lit2 >> (16 + 9 2352 uint32_t lit3_len = lit2 >> (16 + 9); 2353 2353 2354 if (lit3_len) 2354 if (lit3_len) 2355 { 2355 { 2356 lit3 = (lit2 >> 16); 2356 lit3 = (lit2 >> 16); 2357 TOOLS_FPNG_SKIP_BITS(lit2_len + l 2357 TOOLS_FPNG_SKIP_BITS(lit2_len + lit3_len); 2358 } 2358 } 2359 else 2359 else 2360 { 2360 { 2361 TOOLS_FPNG_SKIP_BITS(lit2_len); 2361 TOOLS_FPNG_SKIP_BITS(lit2_len); 2362 2362 2363 assert(bit_buf_size >= FPNG_DECOD 2363 assert(bit_buf_size >= FPNG_DECODER_TABLE_BITS); 2364 lit3 = lit_table[bit_buf & (FPNG_ 2364 lit3 = lit_table[bit_buf & (FPNG_DECODER_TABLE_SIZE - 1)]; 2365 lit3_len = (lit3 >> 9) & 15; 2365 lit3_len = (lit3 >> 9) & 15; 2366 if (!lit3_len) 2366 if (!lit3_len) 2367 return false; 2367 return false; 2368 2368 2369 TOOLS_FPNG_SKIP_BITS_NE(lit3_len) 2369 TOOLS_FPNG_SKIP_BITS_NE(lit3_len); 2370 } 2370 } 2371 2371 2372 // Check for matches 2372 // Check for matches 2373 if ((lit1 | lit2 | lit3) & 256) 2373 if ((lit1 | lit2 | lit3) & 256) 2374 return false; 2374 return false; 2375 2375 2376 if (dst_comps == 3) 2376 if (dst_comps == 3) 2377 { 2377 { 2378 if (pPrev_scanline) 2378 if (pPrev_scanline) 2379 { 2379 { 2380 pCur_scanline[x_ofs] = (uint8_t 2380 pCur_scanline[x_ofs] = (uint8_t)(pPrev_scanline[x_ofs] + lit0); 2381 pCur_scanline[x_ofs + 1] = (uin 2381 pCur_scanline[x_ofs + 1] = (uint8_t)(pPrev_scanline[x_ofs + 1] + lit1); 2382 pCur_scanline[x_ofs + 2] = (uin 2382 pCur_scanline[x_ofs + 2] = (uint8_t)(pPrev_scanline[x_ofs + 2] + lit2); 2383 } 2383 } 2384 else 2384 else 2385 { 2385 { 2386 pCur_scanline[x_ofs] = (uint8_t 2386 pCur_scanline[x_ofs] = (uint8_t)lit0; 2387 pCur_scanline[x_ofs + 1] = (uin 2387 pCur_scanline[x_ofs + 1] = (uint8_t)lit1; 2388 pCur_scanline[x_ofs + 2] = (uin 2388 pCur_scanline[x_ofs + 2] = (uint8_t)lit2; 2389 } 2389 } 2390 2390 2391 x_ofs += 3; 2391 x_ofs += 3; 2392 } 2392 } 2393 else 2393 else 2394 { 2394 { 2395 if (pPrev_scanline) 2395 if (pPrev_scanline) 2396 { 2396 { 2397 pCur_scanline[x_ofs] = (uint8_t 2397 pCur_scanline[x_ofs] = (uint8_t)(pPrev_scanline[x_ofs] + lit0); 2398 pCur_scanline[x_ofs + 1] = (uin 2398 pCur_scanline[x_ofs + 1] = (uint8_t)(pPrev_scanline[x_ofs + 1] + lit1); 2399 pCur_scanline[x_ofs + 2] = (uin 2399 pCur_scanline[x_ofs + 2] = (uint8_t)(pPrev_scanline[x_ofs + 2] + lit2); 2400 pCur_scanline[x_ofs + 3] = (uin 2400 pCur_scanline[x_ofs + 3] = (uint8_t)(pPrev_scanline[x_ofs + 3] + lit3); 2401 } 2401 } 2402 else 2402 else 2403 { 2403 { 2404 pCur_scanline[x_ofs] = (uint8_t 2404 pCur_scanline[x_ofs] = (uint8_t)lit0; 2405 pCur_scanline[x_ofs + 1] = (uin 2405 pCur_scanline[x_ofs + 1] = (uint8_t)lit1; 2406 pCur_scanline[x_ofs + 2] = (uin 2406 pCur_scanline[x_ofs + 2] = (uint8_t)lit2; 2407 pCur_scanline[x_ofs + 3] = (uin 2407 pCur_scanline[x_ofs + 3] = (uint8_t)lit3; 2408 } 2408 } 2409 2409 2410 x_ofs += 4; 2410 x_ofs += 4; 2411 } 2411 } 2412 2412 2413 prev_delta_r = (uint8_t)lit0; 2413 prev_delta_r = (uint8_t)lit0; 2414 prev_delta_g = (uint8_t)lit1; 2414 prev_delta_g = (uint8_t)lit1; 2415 prev_delta_b = (uint8_t)lit2; 2415 prev_delta_b = (uint8_t)lit2; 2416 prev_delta_a = (uint8_t)lit3; 2416 prev_delta_a = (uint8_t)lit3; 2417 } 2417 } 2418 2418 2419 } while (x_ofs < dst_bpl); 2419 } while (x_ofs < dst_bpl); 2420 2420 2421 pPrev_scanline = pCur_scanline; 2421 pPrev_scanline = pCur_scanline; 2422 pCur_scanline += dst_bpl; 2422 pCur_scanline += dst_bpl; 2423 } // y 2423 } // y 2424 2424 2425 // The last symbol should be EOB 2425 // The last symbol should be EOB 2426 assert(bit_buf_size >= FPNG_DECODER_TABLE 2426 assert(bit_buf_size >= FPNG_DECODER_TABLE_BITS); 2427 uint32_t lit0 = lit_table[bit_buf & (FPNG 2427 uint32_t lit0 = lit_table[bit_buf & (FPNG_DECODER_TABLE_SIZE - 1)]; 2428 uint32_t lit0_len = (lit0 >> 9) & 15; 2428 uint32_t lit0_len = (lit0 >> 9) & 15; 2429 if (!lit0_len) 2429 if (!lit0_len) 2430 return false; 2430 return false; 2431 lit0 &= 511; 2431 lit0 &= 511; 2432 if (lit0 != 256) 2432 if (lit0 != 256) 2433 return false; 2433 return false; 2434 2434 2435 bit_buf_size -= lit0_len; 2435 bit_buf_size -= lit0_len; 2436 bit_buf >>= lit0_len; 2436 bit_buf >>= lit0_len; 2437 2437 2438 uint32_t align_bits = bit_buf_size & 7; 2438 uint32_t align_bits = bit_buf_size & 7; 2439 bit_buf_size -= align_bits; 2439 bit_buf_size -= align_bits; 2440 bit_buf >>= align_bits; 2440 bit_buf >>= align_bits; 2441 2441 2442 if (src_ofs < (bit_buf_size >> 3)) 2442 if (src_ofs < (bit_buf_size >> 3)) 2443 return false; 2443 return false; 2444 src_ofs -= (bit_buf_size >> 3); 2444 src_ofs -= (bit_buf_size >> 3); 2445 2445 2446 // We should be at the very end, because 2446 // We should be at the very end, because the bit buf reads ahead 32-bits (which contains the zlib adler32). 2447 if ((src_ofs + 4) != zlib_len) 2447 if ((src_ofs + 4) != zlib_len) 2448 return false; 2448 return false; 2449 2449 2450 return true; 2450 return true; 2451 } 2451 } 2452 2452 2453 #pragma pack(push) 2453 #pragma pack(push) 2454 #pragma pack(1) 2454 #pragma pack(1) 2455 struct png_chunk_prefix 2455 struct png_chunk_prefix 2456 { 2456 { 2457 uint32_t m_length; 2457 uint32_t m_length; 2458 uint8_t m_type[4]; 2458 uint8_t m_type[4]; 2459 }; 2459 }; 2460 struct png_ihdr 2460 struct png_ihdr 2461 { 2461 { 2462 png_chunk_prefix m_prefix; 2462 png_chunk_prefix m_prefix; 2463 uint32_t m_width; 2463 uint32_t m_width; 2464 uint32_t m_height; 2464 uint32_t m_height; 2465 uint8_t m_bitdepth; 2465 uint8_t m_bitdepth; 2466 uint8_t m_color_type; 2466 uint8_t m_color_type; 2467 uint8_t m_comp_method; 2467 uint8_t m_comp_method; 2468 uint8_t m_filter_method; 2468 uint8_t m_filter_method; 2469 uint8_t m_interlace_method; 2469 uint8_t m_interlace_method; 2470 uint32_t m_crc32; 2470 uint32_t m_crc32; 2471 }; 2471 }; 2472 const uint32_t IHDR_EXPECTED_LENGTH = 13; 2472 const uint32_t IHDR_EXPECTED_LENGTH = 13; 2473 struct png_iend 2473 struct png_iend 2474 { 2474 { 2475 png_chunk_prefix m_prefix; 2475 png_chunk_prefix m_prefix; 2476 uint32_t m_crc32; 2476 uint32_t m_crc32; 2477 }; 2477 }; 2478 #pragma pack(pop) 2478 #pragma pack(pop) 2479 2479 2480 static int fpng_get_info_internal(const voi 2480 static int fpng_get_info_internal(const void* pImage, uint32_t image_size, uint32_t& width, uint32_t& height, uint32_t& channels_in_file, uint32_t &idat_ofs, uint32_t &idat_len) 2481 { 2481 { 2482 static const uint8_t s_png_sig[8] = { 137 2482 static const uint8_t s_png_sig[8] = { 137, 80, 78, 71, 13, 10, 26, 10 }; 2483 2483 2484 if (!endian_check()) 2484 if (!endian_check()) 2485 { 2485 { 2486 assert(0); 2486 assert(0); 2487 return false; 2487 return false; 2488 } 2488 } 2489 2489 2490 width = 0; 2490 width = 0; 2491 height = 0; 2491 height = 0; 2492 channels_in_file = 0; 2492 channels_in_file = 0; 2493 idat_ofs = 0, idat_len = 0; 2493 idat_ofs = 0, idat_len = 0; 2494 2494 2495 // Ensure the file has at least a minimum 2495 // Ensure the file has at least a minimum possible size 2496 if (image_size < (sizeof(s_png_sig) + siz 2496 if (image_size < (sizeof(s_png_sig) + sizeof(png_ihdr) + sizeof(png_chunk_prefix) + 1 + sizeof(uint32_t) + sizeof(png_iend))) 2497 return FPNG_DECODE_FAILED_NOT_PNG; 2497 return FPNG_DECODE_FAILED_NOT_PNG; 2498 2498 2499 if (memcmp(pImage, s_png_sig, 8) != 0) 2499 if (memcmp(pImage, s_png_sig, 8) != 0) 2500 return FPNG_DECODE_FAILED_NOT_PNG; 2500 return FPNG_DECODE_FAILED_NOT_PNG; 2501 2501 2502 const uint8_t* pImage_u8 = static_cast<co 2502 const uint8_t* pImage_u8 = static_cast<const uint8_t*>(pImage) + 8; 2503 2503 2504 const png_ihdr& ihdr = *reinterpret_cast< 2504 const png_ihdr& ihdr = *reinterpret_cast<const png_ihdr*>(pImage_u8); 2505 pImage_u8 += sizeof(png_ihdr); 2505 pImage_u8 += sizeof(png_ihdr); 2506 2506 2507 if (READ_BE32(&ihdr.m_prefix.m_length) != 2507 if (READ_BE32(&ihdr.m_prefix.m_length) != IHDR_EXPECTED_LENGTH) 2508 return FPNG_DECODE_FAILED_NOT_PNG; 2508 return FPNG_DECODE_FAILED_NOT_PNG; 2509 2509 2510 if (fpng_crc32(ihdr.m_prefix.m_type, 4 + 2510 if (fpng_crc32(ihdr.m_prefix.m_type, 4 + IHDR_EXPECTED_LENGTH, FPNG_CRC32_INIT) != READ_BE32(&ihdr.m_crc32)) 2511 return FPNG_DECODE_FAILED_HEADER_CRC32; 2511 return FPNG_DECODE_FAILED_HEADER_CRC32; 2512 2512 2513 width = READ_BE32(&ihdr.m_width); 2513 width = READ_BE32(&ihdr.m_width); 2514 height = READ_BE32(&ihdr.m_height); 2514 height = READ_BE32(&ihdr.m_height); 2515 2515 2516 if (!width || !height || (width > FPNG_MA 2516 if (!width || !height || (width > FPNG_MAX_SUPPORTED_DIM) || (height > FPNG_MAX_SUPPORTED_DIM)) 2517 return FPNG_DECODE_FAILED_INVALID_DIMEN 2517 return FPNG_DECODE_FAILED_INVALID_DIMENSIONS; 2518 2518 2519 uint64_t total_pixels = (uint64_t)width * 2519 uint64_t total_pixels = (uint64_t)width * height; 2520 if (total_pixels > (1 << 30)) 2520 if (total_pixels > (1 << 30)) 2521 return FPNG_DECODE_FAILED_INVALID_DIMEN 2521 return FPNG_DECODE_FAILED_INVALID_DIMENSIONS; 2522 2522 2523 if ((ihdr.m_comp_method) || (ihdr.m_filte 2523 if ((ihdr.m_comp_method) || (ihdr.m_filter_method) || (ihdr.m_interlace_method) || (ihdr.m_bitdepth != 8)) 2524 return FPNG_DECODE_NOT_FPNG; 2524 return FPNG_DECODE_NOT_FPNG; 2525 2525 2526 if (ihdr.m_color_type == 2) 2526 if (ihdr.m_color_type == 2) 2527 channels_in_file = 3; 2527 channels_in_file = 3; 2528 else if (ihdr.m_color_type == 6) 2528 else if (ihdr.m_color_type == 6) 2529 channels_in_file = 4; 2529 channels_in_file = 4; 2530 2530 2531 if (!channels_in_file) 2531 if (!channels_in_file) 2532 return FPNG_DECODE_NOT_FPNG; 2532 return FPNG_DECODE_NOT_FPNG; 2533 2533 2534 // Scan all the chunks. Look for one IDAT 2534 // Scan all the chunks. Look for one IDAT, IEND, and our custom fdEC chunk that indicates the file was compressed by us. Skip any ancillary chunks. 2535 bool found_fdec_chunk = false; 2535 bool found_fdec_chunk = false; 2536 2536 2537 for (; ; ) 2537 for (; ; ) 2538 { 2538 { 2539 const size_t src_ofs = pImage_u8 - stat 2539 const size_t src_ofs = pImage_u8 - static_cast<const uint8_t*>(pImage); 2540 if (src_ofs >= image_size) 2540 if (src_ofs >= image_size) 2541 return FPNG_DECODE_FAILED_CHUNK_PARSI 2541 return FPNG_DECODE_FAILED_CHUNK_PARSING; 2542 2542 2543 const uint32_t bytes_remaining = image_ 2543 const uint32_t bytes_remaining = image_size - (uint32_t)src_ofs; 2544 if (bytes_remaining < sizeof(uint32_t) 2544 if (bytes_remaining < sizeof(uint32_t) * 3) 2545 return FPNG_DECODE_FAILED_CHUNK_PARSI 2545 return FPNG_DECODE_FAILED_CHUNK_PARSING; 2546 2546 2547 const png_chunk_prefix* pChunk = reinte 2547 const png_chunk_prefix* pChunk = reinterpret_cast<const png_chunk_prefix*>(pImage_u8); 2548 2548 2549 const uint32_t chunk_len = READ_BE32(&p 2549 const uint32_t chunk_len = READ_BE32(&pChunk->m_length); 2550 if ((src_ofs + sizeof(uint32_t) + chunk 2550 if ((src_ofs + sizeof(uint32_t) + chunk_len + sizeof(uint32_t)) > image_size) 2551 return FPNG_DECODE_FAILED_CHUNK_PARSI 2551 return FPNG_DECODE_FAILED_CHUNK_PARSING; 2552 2552 2553 for (uint32_t i = 0; i < 4; i++) 2553 for (uint32_t i = 0; i < 4; i++) 2554 { 2554 { 2555 const uint8_t c = pChunk->m_type[i]; 2555 const uint8_t c = pChunk->m_type[i]; 2556 const bool is_upper = (c >= 65) && (c 2556 const bool is_upper = (c >= 65) && (c <= 90), is_lower = (c >= 97) && (c <= 122); 2557 if ((!is_upper) && (!is_lower)) 2557 if ((!is_upper) && (!is_lower)) 2558 return FPNG_DECODE_FAILED_CHUNK_PAR 2558 return FPNG_DECODE_FAILED_CHUNK_PARSING; 2559 } 2559 } 2560 2560 2561 char chunk_type[5] = { (char)pChunk->m_ 2561 char chunk_type[5] = { (char)pChunk->m_type[0], (char)pChunk->m_type[1], (char)pChunk->m_type[2], (char)pChunk->m_type[3], 0 }; 2562 const bool is_idat = strcmp(chunk_type, 2562 const bool is_idat = strcmp(chunk_type, "IDAT") == 0; 2563 2563 2564 const uint8_t* pChunk_data = pImage_u8 2564 const uint8_t* pChunk_data = pImage_u8 + sizeof(uint32_t) * 2; 2565 2565 2566 if (strcmp(chunk_type, "IEND") == 0) 2566 if (strcmp(chunk_type, "IEND") == 0) 2567 break; 2567 break; 2568 else if (is_idat) 2568 else if (is_idat) 2569 { 2569 { 2570 // If there were multiple IDAT's, or 2570 // If there were multiple IDAT's, or we didn't find the fdEC chunk, then it's not FPNG. 2571 if ((idat_ofs) || (!found_fdec_chunk) 2571 if ((idat_ofs) || (!found_fdec_chunk)) 2572 return FPNG_DECODE_NOT_FPNG; 2572 return FPNG_DECODE_NOT_FPNG; 2573 2573 2574 idat_ofs = (uint32_t)src_ofs; 2574 idat_ofs = (uint32_t)src_ofs; 2575 idat_len = chunk_len; 2575 idat_len = chunk_len; 2576 2576 2577 // Sanity check the IDAT chunk length 2577 // Sanity check the IDAT chunk length 2578 if (idat_len < 7) 2578 if (idat_len < 7) 2579 return FPNG_DECODE_FAILED_INVALID_I 2579 return FPNG_DECODE_FAILED_INVALID_IDAT; 2580 } 2580 } 2581 else if (strcmp(chunk_type, "fdEC") == 2581 else if (strcmp(chunk_type, "fdEC") == 0) 2582 { 2582 { 2583 if (found_fdec_chunk) 2583 if (found_fdec_chunk) 2584 return FPNG_DECODE_NOT_FPNG; 2584 return FPNG_DECODE_NOT_FPNG; 2585 2585 2586 // We've got our fdEC chunk. Now make 2586 // We've got our fdEC chunk. Now make sure it's big enough and check its contents. 2587 if (chunk_len != 5) 2587 if (chunk_len != 5) 2588 return FPNG_DECODE_NOT_FPNG; 2588 return FPNG_DECODE_NOT_FPNG; 2589 2589 2590 // Check fdEC chunk sig 2590 // Check fdEC chunk sig 2591 if ((pChunk_data[0] != 82) || (pChunk 2591 if ((pChunk_data[0] != 82) || (pChunk_data[1] != 36) || (pChunk_data[2] != 147) || (pChunk_data[3] != 227)) 2592 return FPNG_DECODE_NOT_FPNG; 2592 return FPNG_DECODE_NOT_FPNG; 2593 2593 2594 // Check fdEC version 2594 // Check fdEC version 2595 if (pChunk_data[4] != FPNG_FDEC_VERSI 2595 if (pChunk_data[4] != FPNG_FDEC_VERSION) 2596 return FPNG_DECODE_NOT_FPNG; 2596 return FPNG_DECODE_NOT_FPNG; 2597 2597 2598 found_fdec_chunk = true; 2598 found_fdec_chunk = true; 2599 } 2599 } 2600 else 2600 else 2601 { 2601 { 2602 // Bail if it's a critical chunk - ca 2602 // Bail if it's a critical chunk - can't be FPNG 2603 if ((chunk_type[0] & 32) == 0) 2603 if ((chunk_type[0] & 32) == 0) 2604 return FPNG_DECODE_NOT_FPNG; 2604 return FPNG_DECODE_NOT_FPNG; 2605 2605 2606 // ancillary chunk - skip it 2606 // ancillary chunk - skip it 2607 } 2607 } 2608 2608 2609 pImage_u8 += sizeof(png_chunk_prefix) + 2609 pImage_u8 += sizeof(png_chunk_prefix) + chunk_len + sizeof(uint32_t); 2610 } 2610 } 2611 2611 2612 if ((!found_fdec_chunk) || (!idat_ofs)) 2612 if ((!found_fdec_chunk) || (!idat_ofs)) 2613 return FPNG_DECODE_NOT_FPNG; 2613 return FPNG_DECODE_NOT_FPNG; 2614 2614 2615 return FPNG_DECODE_SUCCESS; 2615 return FPNG_DECODE_SUCCESS; 2616 } 2616 } 2617 2617 2618 inline int fpng_get_info(const void* pImage 2618 inline int fpng_get_info(const void* pImage, uint32_t image_size, uint32_t& width, uint32_t& height, uint32_t& channels_in_file) 2619 { 2619 { 2620 uint32_t idat_ofs = 0, idat_len = 0; 2620 uint32_t idat_ofs = 0, idat_len = 0; 2621 return fpng_get_info_internal(pImage, ima 2621 return fpng_get_info_internal(pImage, image_size, width, height, channels_in_file, idat_ofs, idat_len); 2622 } 2622 } 2623 2623 2624 inline int fpng_decode_memory(const void *p 2624 inline int fpng_decode_memory(const void *pImage, uint32_t image_size, std::vector<uint8_t> &out, uint32_t& width, uint32_t& height, uint32_t &channels_in_file, uint32_t desired_channels) 2625 { 2625 { 2626 out.resize(0); 2626 out.resize(0); 2627 width = 0; 2627 width = 0; 2628 height = 0; 2628 height = 0; 2629 channels_in_file = 0; 2629 channels_in_file = 0; 2630 2630 2631 if ((!pImage) || (!image_size) || ((desir 2631 if ((!pImage) || (!image_size) || ((desired_channels != 3) && (desired_channels != 4))) 2632 { 2632 { 2633 assert(0); 2633 assert(0); 2634 return FPNG_DECODE_INVALID_ARG; 2634 return FPNG_DECODE_INVALID_ARG; 2635 } 2635 } 2636 2636 2637 uint32_t idat_ofs = 0, idat_len = 0; 2637 uint32_t idat_ofs = 0, idat_len = 0; 2638 int status = fpng_get_info_internal(pImag 2638 int status = fpng_get_info_internal(pImage, image_size, width, height, channels_in_file, idat_ofs, idat_len); 2639 if (status) 2639 if (status) 2640 return status; 2640 return status; 2641 2641 2642 const uint64_t mem_needed = (uint64_t)wid 2642 const uint64_t mem_needed = (uint64_t)width * height * desired_channels; 2643 if (mem_needed > UINT32_MAX) 2643 if (mem_needed > UINT32_MAX) 2644 return FPNG_DECODE_FAILED_DIMENSIONS_TO 2644 return FPNG_DECODE_FAILED_DIMENSIONS_TOO_LARGE; 2645 2645 2646 // On 32-bit systems do a quick sanity ch 2646 // On 32-bit systems do a quick sanity check before we try to resize the output buffer. 2647 if ((sizeof(size_t) == sizeof(uint32_t)) 2647 if ((sizeof(size_t) == sizeof(uint32_t)) && (mem_needed >= 0x80000000)) 2648 return FPNG_DECODE_FAILED_DIMENSIONS_TO 2648 return FPNG_DECODE_FAILED_DIMENSIONS_TOO_LARGE; 2649 2649 2650 out.resize(mem_needed); 2650 out.resize(mem_needed); 2651 2651 2652 const uint8_t* pIDAT_data = static_cast<c 2652 const uint8_t* pIDAT_data = static_cast<const uint8_t*>(pImage) + idat_ofs + sizeof(uint32_t) * 2; 2653 const uint32_t src_len = image_size - (id 2653 const uint32_t src_len = image_size - (idat_ofs + sizeof(uint32_t) * 2); 2654 2654 2655 bool decomp_status; 2655 bool decomp_status; 2656 if (desired_channels == 3) 2656 if (desired_channels == 3) 2657 { 2657 { 2658 if (channels_in_file == 3) 2658 if (channels_in_file == 3) 2659 decomp_status = fpng_pixel_zlib_decom 2659 decomp_status = fpng_pixel_zlib_decompress_3<3>(pIDAT_data, src_len, idat_len, out.data(), width, height); 2660 else 2660 else 2661 decomp_status = fpng_pixel_zlib_decom 2661 decomp_status = fpng_pixel_zlib_decompress_4<3>(pIDAT_data, src_len, idat_len, out.data(), width, height); 2662 } 2662 } 2663 else 2663 else 2664 { 2664 { 2665 if (channels_in_file == 3) 2665 if (channels_in_file == 3) 2666 decomp_status = fpng_pixel_zlib_decom 2666 decomp_status = fpng_pixel_zlib_decompress_3<4>(pIDAT_data, src_len, idat_len, out.data(), width, height); 2667 else 2667 else 2668 decomp_status = fpng_pixel_zlib_decom 2668 decomp_status = fpng_pixel_zlib_decompress_4<4>(pIDAT_data, src_len, idat_len, out.data(), width, height); 2669 } 2669 } 2670 if (!decomp_status) 2670 if (!decomp_status) 2671 { 2671 { 2672 // Something went wrong. Either the fil 2672 // Something went wrong. Either the file data was corrupted, or it doesn't conform to one of our zlib/Deflate constraints. 2673 // The conservative thing to do is indi 2673 // The conservative thing to do is indicate it wasn't written by us, and let the general purpose PNG decoder handle it. 2674 return FPNG_DECODE_NOT_FPNG; 2674 return FPNG_DECODE_NOT_FPNG; 2675 } 2675 } 2676 2676 2677 return FPNG_DECODE_SUCCESS; 2677 return FPNG_DECODE_SUCCESS; 2678 } 2678 } 2679 2679 2680 inline int fpng_decode_file(const char* pFi 2680 inline int fpng_decode_file(const char* pFilename, std::vector<uint8_t>& out, uint32_t& width, uint32_t& height, uint32_t& channels_in_file, uint32_t desired_channels) 2681 { 2681 { 2682 FILE* pFile = fopen(pFilename 2682 FILE* pFile = fopen(pFilename, "rb"); 2683 if (!pFile) return FPNG_DECOD 2683 if (!pFile) return FPNG_DECODE_FILE_OPEN_FAILED; 2684 2684 2685 if (fseek(pFile, 0, SEEK_END) != 0) 2685 if (fseek(pFile, 0, SEEK_END) != 0) 2686 { 2686 { 2687 fclose(pFile); 2687 fclose(pFile); 2688 return FPNG_DECODE_FILE_SEEK_FAILED; 2688 return FPNG_DECODE_FILE_SEEK_FAILED; 2689 } 2689 } 2690 2690 2691 #ifdef _MSC_VER 2691 #ifdef _MSC_VER 2692 int64_t filesize = _ftelli64(pFile); 2692 int64_t filesize = _ftelli64(pFile); 2693 #else 2693 #else 2694 int64_t filesize = ftello(pFile); 2694 int64_t filesize = ftello(pFile); 2695 #endif 2695 #endif 2696 2696 2697 if (fseek(pFile, 0, SEEK_SET) != 0) 2697 if (fseek(pFile, 0, SEEK_SET) != 0) 2698 { 2698 { 2699 fclose(pFile); 2699 fclose(pFile); 2700 return FPNG_DECODE_FILE_SEEK_FAILED; 2700 return FPNG_DECODE_FILE_SEEK_FAILED; 2701 } 2701 } 2702 2702 2703 if ( (filesize < 0) || (filesize > UINT32 2703 if ( (filesize < 0) || (filesize > UINT32_MAX) || ( (sizeof(size_t) == sizeof(uint32_t)) && (filesize > 0x70000000) ) ) 2704 { 2704 { 2705 fclose(pFile); 2705 fclose(pFile); 2706 return FPNG_DECODE_FILE_TOO_LARGE; 2706 return FPNG_DECODE_FILE_TOO_LARGE; 2707 } 2707 } 2708 2708 2709 std::vector<uint8_t> buf((size_t)filesize 2709 std::vector<uint8_t> buf((size_t)filesize); 2710 if (fread(buf.data(), 1, buf.size(), pFil 2710 if (fread(buf.data(), 1, buf.size(), pFile) != buf.size()) 2711 { 2711 { 2712 fclose(pFile); 2712 fclose(pFile); 2713 return FPNG_DECODE_FILE_READ_FAILED; 2713 return FPNG_DECODE_FILE_READ_FAILED; 2714 } 2714 } 2715 2715 2716 fclose(pFile); 2716 fclose(pFile); 2717 2717 2718 return fpng_decode_memory(buf.data(), (ui 2718 return fpng_decode_memory(buf.data(), (uint32_t)buf.size(), out, width, height, channels_in_file, desired_channels); 2719 } 2719 } 2720 2720 2721 #undef TOOLS_FPNG_PUT_BITS 2721 #undef TOOLS_FPNG_PUT_BITS 2722 #undef TOOLS_FPNG_PUT_BITS_CZ 2722 #undef TOOLS_FPNG_PUT_BITS_CZ 2723 #undef TOOLS_FPNG_PUT_BITS_FLUSH 2723 #undef TOOLS_FPNG_PUT_BITS_FLUSH 2724 #undef TOOLS_FPNG_PUT_BITS_FORCE_FLUSH 2724 #undef TOOLS_FPNG_PUT_BITS_FORCE_FLUSH 2725 #undef TOOLS_FPNG_DEFL_CLEAR_OBJ 2725 #undef TOOLS_FPNG_DEFL_CLEAR_OBJ 2726 #undef TOOLS_FPNG_DEFL_RLE_PREV_CODE_SIZE 2726 #undef TOOLS_FPNG_DEFL_RLE_PREV_CODE_SIZE 2727 #undef TOOLS_FPNG_DEFL_RLE_ZERO_CODE_SIZE 2727 #undef TOOLS_FPNG_DEFL_RLE_ZERO_CODE_SIZE 2728 #undef TOOLS_FPNG_DEFL_DYN_PUT_BITS 2728 #undef TOOLS_FPNG_DEFL_DYN_PUT_BITS 2729 #undef TOOLS_FPNG_ENSURE_32BITS 2729 #undef TOOLS_FPNG_ENSURE_32BITS 2730 #undef TOOLS_FPNG_GET_BITS 2730 #undef TOOLS_FPNG_GET_BITS 2731 #undef TOOLS_FPNG_SKIP_BITS 2731 #undef TOOLS_FPNG_SKIP_BITS 2732 #undef TOOLS_FPNG_GET_BITS_NE 2732 #undef TOOLS_FPNG_GET_BITS_NE 2733 #undef TOOLS_FPNG_SKIP_BITS_NE 2733 #undef TOOLS_FPNG_SKIP_BITS_NE 2734 2734 2735 } // namespace fpng 2735 } // namespace fpng 2736 } // namespace tools 2736 } // namespace tools 2737 2737 2738 /* 2738 /* 2739 This is free and unencumbered software rele 2739 This is free and unencumbered software released into the public domain. 2740 2740 2741 Anyone is free to copy, modify, publish, us 2741 Anyone is free to copy, modify, publish, use, compile, sell, or 2742 distribute this software, either in source 2742 distribute this software, either in source code form or as a compiled 2743 binary, for any purpose, commercial or non- 2743 binary, for any purpose, commercial or non-commercial, and by any 2744 means. 2744 means. 2745 2745 2746 In jurisdictions that recognize copyright l 2746 In jurisdictions that recognize copyright laws, the author or authors 2747 of this software dedicate any and all copyr 2747 of this software dedicate any and all copyright interest in the 2748 software to the public domain. We make this 2748 software to the public domain. We make this dedication for the benefit 2749 of the public at large and to the detriment 2749 of the public at large and to the detriment of our heirs and 2750 successors. We intend this dedication to be 2750 successors. We intend this dedication to be an overt act of 2751 relinquishment in perpetuity of all present 2751 relinquishment in perpetuity of all present and future rights to this 2752 software under copyright law. 2752 software under copyright law. 2753 2753 2754 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT W 2754 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 2755 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMIT 2755 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 2756 MERCHANTABILITY, FITNESS FOR A PARTICULAR P 2756 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 2757 IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR 2757 IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR 2758 OTHER LIABILITY, WHETHER IN AN ACTION OF CO 2758 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 2759 ARISING FROM, OUT OF OR IN CONNECTION WITH 2759 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 2760 OTHER DEALINGS IN THE SOFTWARE. 2760 OTHER DEALINGS IN THE SOFTWARE. 2761 2761 2762 For more information, please refer to <http 2762 For more information, please refer to <http://unlicense.org/> 2763 2763 2764 Richard Geldreich, Jr. 2764 Richard Geldreich, Jr. 2765 12/30/2021 2765 12/30/2021 2766 */ 2766 */ 2767 2767