EXRLoader.js 55 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039
  1. ( function () {
  2. /**
  3. * OpenEXR loader currently supports uncompressed, ZIP(S), RLE, PIZ and DWA/B compression.
  4. * Supports reading as UnsignedByte, HalfFloat and Float type data texture.
  5. *
  6. * Referred to the original Industrial Light & Magic OpenEXR implementation and the TinyEXR / Syoyo Fujita
  7. * implementation, so I have preserved their copyright notices.
  8. */
  9. // /*
  10. // Copyright (c) 2014 - 2017, Syoyo Fujita
  11. // All rights reserved.
  12. // Redistribution and use in source and binary forms, with or without
  13. // modification, are permitted provided that the following conditions are met:
  14. // * Redistributions of source code must retain the above copyright
  15. // notice, this list of conditions and the following disclaimer.
  16. // * Redistributions in binary form must reproduce the above copyright
  17. // notice, this list of conditions and the following disclaimer in the
  18. // documentation and/or other materials provided with the distribution.
  19. // * Neither the name of the Syoyo Fujita nor the
  20. // names of its contributors may be used to endorse or promote products
  21. // derived from this software without specific prior written permission.
  22. // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  23. // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  24. // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  25. // DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
  26. // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  27. // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28. // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  29. // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30. // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  31. // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32. // */
  33. // // TinyEXR contains some OpenEXR code, which is licensed under ------------
  34. // ///////////////////////////////////////////////////////////////////////////
  35. // //
  36. // // Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
  37. // // Digital Ltd. LLC
  38. // //
  39. // // All rights reserved.
  40. // //
  41. // // Redistribution and use in source and binary forms, with or without
  42. // // modification, are permitted provided that the following conditions are
  43. // // met:
  44. // // * Redistributions of source code must retain the above copyright
  45. // // notice, this list of conditions and the following disclaimer.
  46. // // * Redistributions in binary form must reproduce the above
  47. // // copyright notice, this list of conditions and the following disclaimer
  48. // // in the documentation and/or other materials provided with the
  49. // // distribution.
  50. // // * Neither the name of Industrial Light & Magic nor the names of
  51. // // its contributors may be used to endorse or promote products derived
  52. // // from this software without specific prior written permission.
  53. // //
  54. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  55. // // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  56. // // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  57. // // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  58. // // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  59. // // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  60. // // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  61. // // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  62. // // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  63. // // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  64. // // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  65. // //
  66. // ///////////////////////////////////////////////////////////////////////////
  67. // // End of OpenEXR license -------------------------------------------------
  68. class EXRLoader extends THREE.DataTextureLoader {
  69. constructor( manager ) {
  70. super( manager );
  71. this.type = THREE.HalfFloatType;
  72. }
  73. parse( buffer ) {
  74. const USHORT_RANGE = 1 << 16;
  75. const BITMAP_SIZE = USHORT_RANGE >> 3;
  76. const HUF_ENCBITS = 16; // literal (value) bit length
  77. const HUF_DECBITS = 14; // decoding bit size (>= 8)
  78. const HUF_ENCSIZE = ( 1 << HUF_ENCBITS ) + 1; // encoding table size
  79. const HUF_DECSIZE = 1 << HUF_DECBITS; // decoding table size
  80. const HUF_DECMASK = HUF_DECSIZE - 1;
  81. const NBITS = 16;
  82. const A_OFFSET = 1 << NBITS - 1;
  83. const MOD_MASK = ( 1 << NBITS ) - 1;
  84. const SHORT_ZEROCODE_RUN = 59;
  85. const LONG_ZEROCODE_RUN = 63;
  86. const SHORTEST_LONG_RUN = 2 + LONG_ZEROCODE_RUN - SHORT_ZEROCODE_RUN;
  87. const ULONG_SIZE = 8;
  88. const FLOAT32_SIZE = 4;
  89. const INT32_SIZE = 4;
  90. const INT16_SIZE = 2;
  91. const INT8_SIZE = 1;
  92. const STATIC_HUFFMAN = 0;
  93. const DEFLATE = 1;
  94. const UNKNOWN = 0;
  95. const LOSSY_DCT = 1;
  96. const RLE = 2;
  97. const logBase = Math.pow( 2.7182818, 2.2 );
  98. function reverseLutFromBitmap( bitmap, lut ) {
  99. let k = 0;
  100. for ( let i = 0; i < USHORT_RANGE; ++ i ) {
  101. if ( i == 0 || bitmap[ i >> 3 ] & 1 << ( i & 7 ) ) {
  102. lut[ k ++ ] = i;
  103. }
  104. }
  105. const n = k - 1;
  106. while ( k < USHORT_RANGE ) lut[ k ++ ] = 0;
  107. return n;
  108. }
  109. function hufClearDecTable( hdec ) {
  110. for ( let i = 0; i < HUF_DECSIZE; i ++ ) {
  111. hdec[ i ] = {};
  112. hdec[ i ].len = 0;
  113. hdec[ i ].lit = 0;
  114. hdec[ i ].p = null;
  115. }
  116. }
  117. const getBitsReturn = {
  118. l: 0,
  119. c: 0,
  120. lc: 0
  121. };
  122. function getBits( nBits, c, lc, uInt8Array, inOffset ) {
  123. while ( lc < nBits ) {
  124. c = c << 8 | parseUint8Array( uInt8Array, inOffset );
  125. lc += 8;
  126. }
  127. lc -= nBits;
  128. getBitsReturn.l = c >> lc & ( 1 << nBits ) - 1;
  129. getBitsReturn.c = c;
  130. getBitsReturn.lc = lc;
  131. }
  132. const hufTableBuffer = new Array( 59 );
  133. function hufCanonicalCodeTable( hcode ) {
  134. for ( let i = 0; i <= 58; ++ i ) hufTableBuffer[ i ] = 0;
  135. for ( let i = 0; i < HUF_ENCSIZE; ++ i ) hufTableBuffer[ hcode[ i ] ] += 1;
  136. let c = 0;
  137. for ( let i = 58; i > 0; -- i ) {
  138. const nc = c + hufTableBuffer[ i ] >> 1;
  139. hufTableBuffer[ i ] = c;
  140. c = nc;
  141. }
  142. for ( let i = 0; i < HUF_ENCSIZE; ++ i ) {
  143. const l = hcode[ i ];
  144. if ( l > 0 ) hcode[ i ] = l | hufTableBuffer[ l ] ++ << 6;
  145. }
  146. }
  147. function hufUnpackEncTable( uInt8Array, inOffset, ni, im, iM, hcode ) {
  148. const p = inOffset;
  149. let c = 0;
  150. let lc = 0;
  151. for ( ; im <= iM; im ++ ) {
  152. if ( p.value - inOffset.value > ni ) return false;
  153. getBits( 6, c, lc, uInt8Array, p );
  154. const l = getBitsReturn.l;
  155. c = getBitsReturn.c;
  156. lc = getBitsReturn.lc;
  157. hcode[ im ] = l;
  158. if ( l == LONG_ZEROCODE_RUN ) {
  159. if ( p.value - inOffset.value > ni ) {
  160. throw new Error( 'Something wrong with hufUnpackEncTable' );
  161. }
  162. getBits( 8, c, lc, uInt8Array, p );
  163. let zerun = getBitsReturn.l + SHORTEST_LONG_RUN;
  164. c = getBitsReturn.c;
  165. lc = getBitsReturn.lc;
  166. if ( im + zerun > iM + 1 ) {
  167. throw new Error( 'Something wrong with hufUnpackEncTable' );
  168. }
  169. while ( zerun -- ) hcode[ im ++ ] = 0;
  170. im --;
  171. } else if ( l >= SHORT_ZEROCODE_RUN ) {
  172. let zerun = l - SHORT_ZEROCODE_RUN + 2;
  173. if ( im + zerun > iM + 1 ) {
  174. throw new Error( 'Something wrong with hufUnpackEncTable' );
  175. }
  176. while ( zerun -- ) hcode[ im ++ ] = 0;
  177. im --;
  178. }
  179. }
  180. hufCanonicalCodeTable( hcode );
  181. }
  182. function hufLength( code ) {
  183. return code & 63;
  184. }
  185. function hufCode( code ) {
  186. return code >> 6;
  187. }
  188. function hufBuildDecTable( hcode, im, iM, hdecod ) {
  189. for ( ; im <= iM; im ++ ) {
  190. const c = hufCode( hcode[ im ] );
  191. const l = hufLength( hcode[ im ] );
  192. if ( c >> l ) {
  193. throw new Error( 'Invalid table entry' );
  194. }
  195. if ( l > HUF_DECBITS ) {
  196. const pl = hdecod[ c >> l - HUF_DECBITS ];
  197. if ( pl.len ) {
  198. throw new Error( 'Invalid table entry' );
  199. }
  200. pl.lit ++;
  201. if ( pl.p ) {
  202. const p = pl.p;
  203. pl.p = new Array( pl.lit );
  204. for ( let i = 0; i < pl.lit - 1; ++ i ) {
  205. pl.p[ i ] = p[ i ];
  206. }
  207. } else {
  208. pl.p = new Array( 1 );
  209. }
  210. pl.p[ pl.lit - 1 ] = im;
  211. } else if ( l ) {
  212. let plOffset = 0;
  213. for ( let i = 1 << HUF_DECBITS - l; i > 0; i -- ) {
  214. const pl = hdecod[ ( c << HUF_DECBITS - l ) + plOffset ];
  215. if ( pl.len || pl.p ) {
  216. throw new Error( 'Invalid table entry' );
  217. }
  218. pl.len = l;
  219. pl.lit = im;
  220. plOffset ++;
  221. }
  222. }
  223. }
  224. return true;
  225. }
  226. const getCharReturn = {
  227. c: 0,
  228. lc: 0
  229. };
  230. function getChar( c, lc, uInt8Array, inOffset ) {
  231. c = c << 8 | parseUint8Array( uInt8Array, inOffset );
  232. lc += 8;
  233. getCharReturn.c = c;
  234. getCharReturn.lc = lc;
  235. }
  236. const getCodeReturn = {
  237. c: 0,
  238. lc: 0
  239. };
  240. function getCode( po, rlc, c, lc, uInt8Array, inOffset, outBuffer, outBufferOffset, outBufferEndOffset ) {
  241. if ( po == rlc ) {
  242. if ( lc < 8 ) {
  243. getChar( c, lc, uInt8Array, inOffset );
  244. c = getCharReturn.c;
  245. lc = getCharReturn.lc;
  246. }
  247. lc -= 8;
  248. let cs = c >> lc;
  249. cs = new Uint8Array( [ cs ] )[ 0 ];
  250. if ( outBufferOffset.value + cs > outBufferEndOffset ) {
  251. return false;
  252. }
  253. const s = outBuffer[ outBufferOffset.value - 1 ];
  254. while ( cs -- > 0 ) {
  255. outBuffer[ outBufferOffset.value ++ ] = s;
  256. }
  257. } else if ( outBufferOffset.value < outBufferEndOffset ) {
  258. outBuffer[ outBufferOffset.value ++ ] = po;
  259. } else {
  260. return false;
  261. }
  262. getCodeReturn.c = c;
  263. getCodeReturn.lc = lc;
  264. }
  265. function UInt16( value ) {
  266. return value & 0xFFFF;
  267. }
  268. function Int16( value ) {
  269. const ref = UInt16( value );
  270. return ref > 0x7FFF ? ref - 0x10000 : ref;
  271. }
  272. const wdec14Return = {
  273. a: 0,
  274. b: 0
  275. };
  276. function wdec14( l, h ) {
  277. const ls = Int16( l );
  278. const hs = Int16( h );
  279. const hi = hs;
  280. const ai = ls + ( hi & 1 ) + ( hi >> 1 );
  281. const as = ai;
  282. const bs = ai - hi;
  283. wdec14Return.a = as;
  284. wdec14Return.b = bs;
  285. }
  286. function wdec16( l, h ) {
  287. const m = UInt16( l );
  288. const d = UInt16( h );
  289. const bb = m - ( d >> 1 ) & MOD_MASK;
  290. const aa = d + bb - A_OFFSET & MOD_MASK;
  291. wdec14Return.a = aa;
  292. wdec14Return.b = bb;
  293. }
  294. function wav2Decode( buffer, j, nx, ox, ny, oy, mx ) {
  295. const w14 = mx < 1 << 14;
  296. const n = nx > ny ? ny : nx;
  297. let p = 1;
  298. let p2;
  299. let py;
  300. while ( p <= n ) p <<= 1;
  301. p >>= 1;
  302. p2 = p;
  303. p >>= 1;
  304. while ( p >= 1 ) {
  305. py = 0;
  306. const ey = py + oy * ( ny - p2 );
  307. const oy1 = oy * p;
  308. const oy2 = oy * p2;
  309. const ox1 = ox * p;
  310. const ox2 = ox * p2;
  311. let i00, i01, i10, i11;
  312. for ( ; py <= ey; py += oy2 ) {
  313. let px = py;
  314. const ex = py + ox * ( nx - p2 );
  315. for ( ; px <= ex; px += ox2 ) {
  316. const p01 = px + ox1;
  317. const p10 = px + oy1;
  318. const p11 = p10 + ox1;
  319. if ( w14 ) {
  320. wdec14( buffer[ px + j ], buffer[ p10 + j ] );
  321. i00 = wdec14Return.a;
  322. i10 = wdec14Return.b;
  323. wdec14( buffer[ p01 + j ], buffer[ p11 + j ] );
  324. i01 = wdec14Return.a;
  325. i11 = wdec14Return.b;
  326. wdec14( i00, i01 );
  327. buffer[ px + j ] = wdec14Return.a;
  328. buffer[ p01 + j ] = wdec14Return.b;
  329. wdec14( i10, i11 );
  330. buffer[ p10 + j ] = wdec14Return.a;
  331. buffer[ p11 + j ] = wdec14Return.b;
  332. } else {
  333. wdec16( buffer[ px + j ], buffer[ p10 + j ] );
  334. i00 = wdec14Return.a;
  335. i10 = wdec14Return.b;
  336. wdec16( buffer[ p01 + j ], buffer[ p11 + j ] );
  337. i01 = wdec14Return.a;
  338. i11 = wdec14Return.b;
  339. wdec16( i00, i01 );
  340. buffer[ px + j ] = wdec14Return.a;
  341. buffer[ p01 + j ] = wdec14Return.b;
  342. wdec16( i10, i11 );
  343. buffer[ p10 + j ] = wdec14Return.a;
  344. buffer[ p11 + j ] = wdec14Return.b;
  345. }
  346. }
  347. if ( nx & p ) {
  348. const p10 = px + oy1;
  349. if ( w14 ) wdec14( buffer[ px + j ], buffer[ p10 + j ] ); else wdec16( buffer[ px + j ], buffer[ p10 + j ] );
  350. i00 = wdec14Return.a;
  351. buffer[ p10 + j ] = wdec14Return.b;
  352. buffer[ px + j ] = i00;
  353. }
  354. }
  355. if ( ny & p ) {
  356. let px = py;
  357. const ex = py + ox * ( nx - p2 );
  358. for ( ; px <= ex; px += ox2 ) {
  359. const p01 = px + ox1;
  360. if ( w14 ) wdec14( buffer[ px + j ], buffer[ p01 + j ] ); else wdec16( buffer[ px + j ], buffer[ p01 + j ] );
  361. i00 = wdec14Return.a;
  362. buffer[ p01 + j ] = wdec14Return.b;
  363. buffer[ px + j ] = i00;
  364. }
  365. }
  366. p2 = p;
  367. p >>= 1;
  368. }
  369. return py;
  370. }
  371. function hufDecode( encodingTable, decodingTable, uInt8Array, inOffset, ni, rlc, no, outBuffer, outOffset ) {
  372. let c = 0;
  373. let lc = 0;
  374. const outBufferEndOffset = no;
  375. const inOffsetEnd = Math.trunc( inOffset.value + ( ni + 7 ) / 8 );
  376. while ( inOffset.value < inOffsetEnd ) {
  377. getChar( c, lc, uInt8Array, inOffset );
  378. c = getCharReturn.c;
  379. lc = getCharReturn.lc;
  380. while ( lc >= HUF_DECBITS ) {
  381. const index = c >> lc - HUF_DECBITS & HUF_DECMASK;
  382. const pl = decodingTable[ index ];
  383. if ( pl.len ) {
  384. lc -= pl.len;
  385. getCode( pl.lit, rlc, c, lc, uInt8Array, inOffset, outBuffer, outOffset, outBufferEndOffset );
  386. c = getCodeReturn.c;
  387. lc = getCodeReturn.lc;
  388. } else {
  389. if ( ! pl.p ) {
  390. throw new Error( 'hufDecode issues' );
  391. }
  392. let j;
  393. for ( j = 0; j < pl.lit; j ++ ) {
  394. const l = hufLength( encodingTable[ pl.p[ j ] ] );
  395. while ( lc < l && inOffset.value < inOffsetEnd ) {
  396. getChar( c, lc, uInt8Array, inOffset );
  397. c = getCharReturn.c;
  398. lc = getCharReturn.lc;
  399. }
  400. if ( lc >= l ) {
  401. if ( hufCode( encodingTable[ pl.p[ j ] ] ) == ( c >> lc - l & ( 1 << l ) - 1 ) ) {
  402. lc -= l;
  403. getCode( pl.p[ j ], rlc, c, lc, uInt8Array, inOffset, outBuffer, outOffset, outBufferEndOffset );
  404. c = getCodeReturn.c;
  405. lc = getCodeReturn.lc;
  406. break;
  407. }
  408. }
  409. }
  410. if ( j == pl.lit ) {
  411. throw new Error( 'hufDecode issues' );
  412. }
  413. }
  414. }
  415. }
  416. const i = 8 - ni & 7;
  417. c >>= i;
  418. lc -= i;
  419. while ( lc > 0 ) {
  420. const pl = decodingTable[ c << HUF_DECBITS - lc & HUF_DECMASK ];
  421. if ( pl.len ) {
  422. lc -= pl.len;
  423. getCode( pl.lit, rlc, c, lc, uInt8Array, inOffset, outBuffer, outOffset, outBufferEndOffset );
  424. c = getCodeReturn.c;
  425. lc = getCodeReturn.lc;
  426. } else {
  427. throw new Error( 'hufDecode issues' );
  428. }
  429. }
  430. return true;
  431. }
  432. function hufUncompress( uInt8Array, inDataView, inOffset, nCompressed, outBuffer, nRaw ) {
  433. const outOffset = {
  434. value: 0
  435. };
  436. const initialInOffset = inOffset.value;
  437. const im = parseUint32( inDataView, inOffset );
  438. const iM = parseUint32( inDataView, inOffset );
  439. inOffset.value += 4;
  440. const nBits = parseUint32( inDataView, inOffset );
  441. inOffset.value += 4;
  442. if ( im < 0 || im >= HUF_ENCSIZE || iM < 0 || iM >= HUF_ENCSIZE ) {
  443. throw new Error( 'Something wrong with HUF_ENCSIZE' );
  444. }
  445. const freq = new Array( HUF_ENCSIZE );
  446. const hdec = new Array( HUF_DECSIZE );
  447. hufClearDecTable( hdec );
  448. const ni = nCompressed - ( inOffset.value - initialInOffset );
  449. hufUnpackEncTable( uInt8Array, inOffset, ni, im, iM, freq );
  450. if ( nBits > 8 * ( nCompressed - ( inOffset.value - initialInOffset ) ) ) {
  451. throw new Error( 'Something wrong with hufUncompress' );
  452. }
  453. hufBuildDecTable( freq, im, iM, hdec );
  454. hufDecode( freq, hdec, uInt8Array, inOffset, nBits, iM, nRaw, outBuffer, outOffset );
  455. }
  456. function applyLut( lut, data, nData ) {
  457. for ( let i = 0; i < nData; ++ i ) {
  458. data[ i ] = lut[ data[ i ] ];
  459. }
  460. }
  461. function predictor( source ) {
  462. for ( let t = 1; t < source.length; t ++ ) {
  463. const d = source[ t - 1 ] + source[ t ] - 128;
  464. source[ t ] = d;
  465. }
  466. }
  467. function interleaveScalar( source, out ) {
  468. let t1 = 0;
  469. let t2 = Math.floor( ( source.length + 1 ) / 2 );
  470. let s = 0;
  471. const stop = source.length - 1;
  472. while ( true ) {
  473. if ( s > stop ) break;
  474. out[ s ++ ] = source[ t1 ++ ];
  475. if ( s > stop ) break;
  476. out[ s ++ ] = source[ t2 ++ ];
  477. }
  478. }
  479. function decodeRunLength( source ) {
  480. let size = source.byteLength;
  481. const out = new Array();
  482. let p = 0;
  483. const reader = new DataView( source );
  484. while ( size > 0 ) {
  485. const l = reader.getInt8( p ++ );
  486. if ( l < 0 ) {
  487. const count = - l;
  488. size -= count + 1;
  489. for ( let i = 0; i < count; i ++ ) {
  490. out.push( reader.getUint8( p ++ ) );
  491. }
  492. } else {
  493. const count = l;
  494. size -= 2;
  495. const value = reader.getUint8( p ++ );
  496. for ( let i = 0; i < count + 1; i ++ ) {
  497. out.push( value );
  498. }
  499. }
  500. }
  501. return out;
  502. }
  503. function lossyDctDecode( cscSet, rowPtrs, channelData, acBuffer, dcBuffer, outBuffer ) {
  504. let dataView = new DataView( outBuffer.buffer );
  505. const width = channelData[ cscSet.idx[ 0 ] ].width;
  506. const height = channelData[ cscSet.idx[ 0 ] ].height;
  507. const numComp = 3;
  508. const numFullBlocksX = Math.floor( width / 8.0 );
  509. const numBlocksX = Math.ceil( width / 8.0 );
  510. const numBlocksY = Math.ceil( height / 8.0 );
  511. const leftoverX = width - ( numBlocksX - 1 ) * 8;
  512. const leftoverY = height - ( numBlocksY - 1 ) * 8;
  513. const currAcComp = {
  514. value: 0
  515. };
  516. const currDcComp = new Array( numComp );
  517. const dctData = new Array( numComp );
  518. const halfZigBlock = new Array( numComp );
  519. const rowBlock = new Array( numComp );
  520. const rowOffsets = new Array( numComp );
  521. for ( let comp = 0; comp < numComp; ++ comp ) {
  522. rowOffsets[ comp ] = rowPtrs[ cscSet.idx[ comp ] ];
  523. currDcComp[ comp ] = comp < 1 ? 0 : currDcComp[ comp - 1 ] + numBlocksX * numBlocksY;
  524. dctData[ comp ] = new Float32Array( 64 );
  525. halfZigBlock[ comp ] = new Uint16Array( 64 );
  526. rowBlock[ comp ] = new Uint16Array( numBlocksX * 64 );
  527. }
  528. for ( let blocky = 0; blocky < numBlocksY; ++ blocky ) {
  529. let maxY = 8;
  530. if ( blocky == numBlocksY - 1 ) maxY = leftoverY;
  531. let maxX = 8;
  532. for ( let blockx = 0; blockx < numBlocksX; ++ blockx ) {
  533. if ( blockx == numBlocksX - 1 ) maxX = leftoverX;
  534. for ( let comp = 0; comp < numComp; ++ comp ) {
  535. halfZigBlock[ comp ].fill( 0 );
  536. // set block DC component
  537. halfZigBlock[ comp ][ 0 ] = dcBuffer[ currDcComp[ comp ] ++ ];
  538. // set block AC components
  539. unRleAC( currAcComp, acBuffer, halfZigBlock[ comp ] );
  540. // UnZigZag block to float
  541. unZigZag( halfZigBlock[ comp ], dctData[ comp ] );
  542. // decode float dct
  543. dctInverse( dctData[ comp ] );
  544. }
  545. if ( numComp == 3 ) {
  546. csc709Inverse( dctData );
  547. }
  548. for ( let comp = 0; comp < numComp; ++ comp ) {
  549. convertToHalf( dctData[ comp ], rowBlock[ comp ], blockx * 64 );
  550. }
  551. } // blockx
  552. let offset = 0;
  553. for ( let comp = 0; comp < numComp; ++ comp ) {
  554. const type = channelData[ cscSet.idx[ comp ] ].type;
  555. for ( let y = 8 * blocky; y < 8 * blocky + maxY; ++ y ) {
  556. offset = rowOffsets[ comp ][ y ];
  557. for ( let blockx = 0; blockx < numFullBlocksX; ++ blockx ) {
  558. const src = blockx * 64 + ( y & 0x7 ) * 8;
  559. dataView.setUint16( offset + 0 * INT16_SIZE * type, rowBlock[ comp ][ src + 0 ], true );
  560. dataView.setUint16( offset + 1 * INT16_SIZE * type, rowBlock[ comp ][ src + 1 ], true );
  561. dataView.setUint16( offset + 2 * INT16_SIZE * type, rowBlock[ comp ][ src + 2 ], true );
  562. dataView.setUint16( offset + 3 * INT16_SIZE * type, rowBlock[ comp ][ src + 3 ], true );
  563. dataView.setUint16( offset + 4 * INT16_SIZE * type, rowBlock[ comp ][ src + 4 ], true );
  564. dataView.setUint16( offset + 5 * INT16_SIZE * type, rowBlock[ comp ][ src + 5 ], true );
  565. dataView.setUint16( offset + 6 * INT16_SIZE * type, rowBlock[ comp ][ src + 6 ], true );
  566. dataView.setUint16( offset + 7 * INT16_SIZE * type, rowBlock[ comp ][ src + 7 ], true );
  567. offset += 8 * INT16_SIZE * type;
  568. }
  569. }
  570. // handle partial X blocks
  571. if ( numFullBlocksX != numBlocksX ) {
  572. for ( let y = 8 * blocky; y < 8 * blocky + maxY; ++ y ) {
  573. const offset = rowOffsets[ comp ][ y ] + 8 * numFullBlocksX * INT16_SIZE * type;
  574. const src = numFullBlocksX * 64 + ( y & 0x7 ) * 8;
  575. for ( let x = 0; x < maxX; ++ x ) {
  576. dataView.setUint16( offset + x * INT16_SIZE * type, rowBlock[ comp ][ src + x ], true );
  577. }
  578. }
  579. }
  580. } // comp
  581. } // blocky
  582. const halfRow = new Uint16Array( width );
  583. dataView = new DataView( outBuffer.buffer );
  584. // convert channels back to float, if needed
  585. for ( let comp = 0; comp < numComp; ++ comp ) {
  586. channelData[ cscSet.idx[ comp ] ].decoded = true;
  587. const type = channelData[ cscSet.idx[ comp ] ].type;
  588. if ( channelData[ comp ].type != 2 ) continue;
  589. for ( let y = 0; y < height; ++ y ) {
  590. const offset = rowOffsets[ comp ][ y ];
  591. for ( let x = 0; x < width; ++ x ) {
  592. halfRow[ x ] = dataView.getUint16( offset + x * INT16_SIZE * type, true );
  593. }
  594. for ( let x = 0; x < width; ++ x ) {
  595. dataView.setFloat32( offset + x * INT16_SIZE * type, decodeFloat16( halfRow[ x ] ), true );
  596. }
  597. }
  598. }
  599. }
  600. function unRleAC( currAcComp, acBuffer, halfZigBlock ) {
  601. let acValue;
  602. let dctComp = 1;
  603. while ( dctComp < 64 ) {
  604. acValue = acBuffer[ currAcComp.value ];
  605. if ( acValue == 0xff00 ) {
  606. dctComp = 64;
  607. } else if ( acValue >> 8 == 0xff ) {
  608. dctComp += acValue & 0xff;
  609. } else {
  610. halfZigBlock[ dctComp ] = acValue;
  611. dctComp ++;
  612. }
  613. currAcComp.value ++;
  614. }
  615. }
  616. function unZigZag( src, dst ) {
  617. dst[ 0 ] = decodeFloat16( src[ 0 ] );
  618. dst[ 1 ] = decodeFloat16( src[ 1 ] );
  619. dst[ 2 ] = decodeFloat16( src[ 5 ] );
  620. dst[ 3 ] = decodeFloat16( src[ 6 ] );
  621. dst[ 4 ] = decodeFloat16( src[ 14 ] );
  622. dst[ 5 ] = decodeFloat16( src[ 15 ] );
  623. dst[ 6 ] = decodeFloat16( src[ 27 ] );
  624. dst[ 7 ] = decodeFloat16( src[ 28 ] );
  625. dst[ 8 ] = decodeFloat16( src[ 2 ] );
  626. dst[ 9 ] = decodeFloat16( src[ 4 ] );
  627. dst[ 10 ] = decodeFloat16( src[ 7 ] );
  628. dst[ 11 ] = decodeFloat16( src[ 13 ] );
  629. dst[ 12 ] = decodeFloat16( src[ 16 ] );
  630. dst[ 13 ] = decodeFloat16( src[ 26 ] );
  631. dst[ 14 ] = decodeFloat16( src[ 29 ] );
  632. dst[ 15 ] = decodeFloat16( src[ 42 ] );
  633. dst[ 16 ] = decodeFloat16( src[ 3 ] );
  634. dst[ 17 ] = decodeFloat16( src[ 8 ] );
  635. dst[ 18 ] = decodeFloat16( src[ 12 ] );
  636. dst[ 19 ] = decodeFloat16( src[ 17 ] );
  637. dst[ 20 ] = decodeFloat16( src[ 25 ] );
  638. dst[ 21 ] = decodeFloat16( src[ 30 ] );
  639. dst[ 22 ] = decodeFloat16( src[ 41 ] );
  640. dst[ 23 ] = decodeFloat16( src[ 43 ] );
  641. dst[ 24 ] = decodeFloat16( src[ 9 ] );
  642. dst[ 25 ] = decodeFloat16( src[ 11 ] );
  643. dst[ 26 ] = decodeFloat16( src[ 18 ] );
  644. dst[ 27 ] = decodeFloat16( src[ 24 ] );
  645. dst[ 28 ] = decodeFloat16( src[ 31 ] );
  646. dst[ 29 ] = decodeFloat16( src[ 40 ] );
  647. dst[ 30 ] = decodeFloat16( src[ 44 ] );
  648. dst[ 31 ] = decodeFloat16( src[ 53 ] );
  649. dst[ 32 ] = decodeFloat16( src[ 10 ] );
  650. dst[ 33 ] = decodeFloat16( src[ 19 ] );
  651. dst[ 34 ] = decodeFloat16( src[ 23 ] );
  652. dst[ 35 ] = decodeFloat16( src[ 32 ] );
  653. dst[ 36 ] = decodeFloat16( src[ 39 ] );
  654. dst[ 37 ] = decodeFloat16( src[ 45 ] );
  655. dst[ 38 ] = decodeFloat16( src[ 52 ] );
  656. dst[ 39 ] = decodeFloat16( src[ 54 ] );
  657. dst[ 40 ] = decodeFloat16( src[ 20 ] );
  658. dst[ 41 ] = decodeFloat16( src[ 22 ] );
  659. dst[ 42 ] = decodeFloat16( src[ 33 ] );
  660. dst[ 43 ] = decodeFloat16( src[ 38 ] );
  661. dst[ 44 ] = decodeFloat16( src[ 46 ] );
  662. dst[ 45 ] = decodeFloat16( src[ 51 ] );
  663. dst[ 46 ] = decodeFloat16( src[ 55 ] );
  664. dst[ 47 ] = decodeFloat16( src[ 60 ] );
  665. dst[ 48 ] = decodeFloat16( src[ 21 ] );
  666. dst[ 49 ] = decodeFloat16( src[ 34 ] );
  667. dst[ 50 ] = decodeFloat16( src[ 37 ] );
  668. dst[ 51 ] = decodeFloat16( src[ 47 ] );
  669. dst[ 52 ] = decodeFloat16( src[ 50 ] );
  670. dst[ 53 ] = decodeFloat16( src[ 56 ] );
  671. dst[ 54 ] = decodeFloat16( src[ 59 ] );
  672. dst[ 55 ] = decodeFloat16( src[ 61 ] );
  673. dst[ 56 ] = decodeFloat16( src[ 35 ] );
  674. dst[ 57 ] = decodeFloat16( src[ 36 ] );
  675. dst[ 58 ] = decodeFloat16( src[ 48 ] );
  676. dst[ 59 ] = decodeFloat16( src[ 49 ] );
  677. dst[ 60 ] = decodeFloat16( src[ 57 ] );
  678. dst[ 61 ] = decodeFloat16( src[ 58 ] );
  679. dst[ 62 ] = decodeFloat16( src[ 62 ] );
  680. dst[ 63 ] = decodeFloat16( src[ 63 ] );
  681. }
  682. function dctInverse( data ) {
  683. const a = 0.5 * Math.cos( 3.14159 / 4.0 );
  684. const b = 0.5 * Math.cos( 3.14159 / 16.0 );
  685. const c = 0.5 * Math.cos( 3.14159 / 8.0 );
  686. const d = 0.5 * Math.cos( 3.0 * 3.14159 / 16.0 );
  687. const e = 0.5 * Math.cos( 5.0 * 3.14159 / 16.0 );
  688. const f = 0.5 * Math.cos( 3.0 * 3.14159 / 8.0 );
  689. const g = 0.5 * Math.cos( 7.0 * 3.14159 / 16.0 );
  690. const alpha = new Array( 4 );
  691. const beta = new Array( 4 );
  692. const theta = new Array( 4 );
  693. const gamma = new Array( 4 );
  694. for ( let row = 0; row < 8; ++ row ) {
  695. const rowPtr = row * 8;
  696. alpha[ 0 ] = c * data[ rowPtr + 2 ];
  697. alpha[ 1 ] = f * data[ rowPtr + 2 ];
  698. alpha[ 2 ] = c * data[ rowPtr + 6 ];
  699. alpha[ 3 ] = f * data[ rowPtr + 6 ];
  700. beta[ 0 ] = b * data[ rowPtr + 1 ] + d * data[ rowPtr + 3 ] + e * data[ rowPtr + 5 ] + g * data[ rowPtr + 7 ];
  701. beta[ 1 ] = d * data[ rowPtr + 1 ] - g * data[ rowPtr + 3 ] - b * data[ rowPtr + 5 ] - e * data[ rowPtr + 7 ];
  702. beta[ 2 ] = e * data[ rowPtr + 1 ] - b * data[ rowPtr + 3 ] + g * data[ rowPtr + 5 ] + d * data[ rowPtr + 7 ];
  703. beta[ 3 ] = g * data[ rowPtr + 1 ] - e * data[ rowPtr + 3 ] + d * data[ rowPtr + 5 ] - b * data[ rowPtr + 7 ];
  704. theta[ 0 ] = a * ( data[ rowPtr + 0 ] + data[ rowPtr + 4 ] );
  705. theta[ 3 ] = a * ( data[ rowPtr + 0 ] - data[ rowPtr + 4 ] );
  706. theta[ 1 ] = alpha[ 0 ] + alpha[ 3 ];
  707. theta[ 2 ] = alpha[ 1 ] - alpha[ 2 ];
  708. gamma[ 0 ] = theta[ 0 ] + theta[ 1 ];
  709. gamma[ 1 ] = theta[ 3 ] + theta[ 2 ];
  710. gamma[ 2 ] = theta[ 3 ] - theta[ 2 ];
  711. gamma[ 3 ] = theta[ 0 ] - theta[ 1 ];
  712. data[ rowPtr + 0 ] = gamma[ 0 ] + beta[ 0 ];
  713. data[ rowPtr + 1 ] = gamma[ 1 ] + beta[ 1 ];
  714. data[ rowPtr + 2 ] = gamma[ 2 ] + beta[ 2 ];
  715. data[ rowPtr + 3 ] = gamma[ 3 ] + beta[ 3 ];
  716. data[ rowPtr + 4 ] = gamma[ 3 ] - beta[ 3 ];
  717. data[ rowPtr + 5 ] = gamma[ 2 ] - beta[ 2 ];
  718. data[ rowPtr + 6 ] = gamma[ 1 ] - beta[ 1 ];
  719. data[ rowPtr + 7 ] = gamma[ 0 ] - beta[ 0 ];
  720. }
  721. for ( let column = 0; column < 8; ++ column ) {
  722. alpha[ 0 ] = c * data[ 16 + column ];
  723. alpha[ 1 ] = f * data[ 16 + column ];
  724. alpha[ 2 ] = c * data[ 48 + column ];
  725. alpha[ 3 ] = f * data[ 48 + column ];
  726. beta[ 0 ] = b * data[ 8 + column ] + d * data[ 24 + column ] + e * data[ 40 + column ] + g * data[ 56 + column ];
  727. beta[ 1 ] = d * data[ 8 + column ] - g * data[ 24 + column ] - b * data[ 40 + column ] - e * data[ 56 + column ];
  728. beta[ 2 ] = e * data[ 8 + column ] - b * data[ 24 + column ] + g * data[ 40 + column ] + d * data[ 56 + column ];
  729. beta[ 3 ] = g * data[ 8 + column ] - e * data[ 24 + column ] + d * data[ 40 + column ] - b * data[ 56 + column ];
  730. theta[ 0 ] = a * ( data[ column ] + data[ 32 + column ] );
  731. theta[ 3 ] = a * ( data[ column ] - data[ 32 + column ] );
  732. theta[ 1 ] = alpha[ 0 ] + alpha[ 3 ];
  733. theta[ 2 ] = alpha[ 1 ] - alpha[ 2 ];
  734. gamma[ 0 ] = theta[ 0 ] + theta[ 1 ];
  735. gamma[ 1 ] = theta[ 3 ] + theta[ 2 ];
  736. gamma[ 2 ] = theta[ 3 ] - theta[ 2 ];
  737. gamma[ 3 ] = theta[ 0 ] - theta[ 1 ];
  738. data[ 0 + column ] = gamma[ 0 ] + beta[ 0 ];
  739. data[ 8 + column ] = gamma[ 1 ] + beta[ 1 ];
  740. data[ 16 + column ] = gamma[ 2 ] + beta[ 2 ];
  741. data[ 24 + column ] = gamma[ 3 ] + beta[ 3 ];
  742. data[ 32 + column ] = gamma[ 3 ] - beta[ 3 ];
  743. data[ 40 + column ] = gamma[ 2 ] - beta[ 2 ];
  744. data[ 48 + column ] = gamma[ 1 ] - beta[ 1 ];
  745. data[ 56 + column ] = gamma[ 0 ] - beta[ 0 ];
  746. }
  747. }
  748. function csc709Inverse( data ) {
  749. for ( let i = 0; i < 64; ++ i ) {
  750. const y = data[ 0 ][ i ];
  751. const cb = data[ 1 ][ i ];
  752. const cr = data[ 2 ][ i ];
  753. data[ 0 ][ i ] = y + 1.5747 * cr;
  754. data[ 1 ][ i ] = y - 0.1873 * cb - 0.4682 * cr;
  755. data[ 2 ][ i ] = y + 1.8556 * cb;
  756. }
  757. }
  758. function convertToHalf( src, dst, idx ) {
  759. for ( let i = 0; i < 64; ++ i ) {
  760. dst[ idx + i ] = THREE.DataUtils.toHalfFloat( toLinear( src[ i ] ) );
  761. }
  762. }
  763. function toLinear( float ) {
  764. if ( float <= 1 ) {
  765. return Math.sign( float ) * Math.pow( Math.abs( float ), 2.2 );
  766. } else {
  767. return Math.sign( float ) * Math.pow( logBase, Math.abs( float ) - 1.0 );
  768. }
  769. }
  770. function uncompressRAW( info ) {
  771. return new DataView( info.array.buffer, info.offset.value, info.size );
  772. }
  773. function uncompressRLE( info ) {
  774. const compressed = info.viewer.buffer.slice( info.offset.value, info.offset.value + info.size );
  775. const rawBuffer = new Uint8Array( decodeRunLength( compressed ) );
  776. const tmpBuffer = new Uint8Array( rawBuffer.length );
  777. predictor( rawBuffer ); // revert predictor
  778. interleaveScalar( rawBuffer, tmpBuffer ); // interleave pixels
  779. return new DataView( tmpBuffer.buffer );
  780. }
  781. function uncompressZIP( info ) {
  782. const compressed = info.array.slice( info.offset.value, info.offset.value + info.size );
  783. if ( typeof fflate === 'undefined' ) {
  784. console.error( 'THREE.EXRLoader: External library fflate.min.js required.' );
  785. }
  786. const rawBuffer = fflate.unzlibSync( compressed ); // eslint-disable-line no-undef
  787. const tmpBuffer = new Uint8Array( rawBuffer.length );
  788. predictor( rawBuffer ); // revert predictor
  789. interleaveScalar( rawBuffer, tmpBuffer ); // interleave pixels
  790. return new DataView( tmpBuffer.buffer );
  791. }
  792. function uncompressPIZ( info ) {
  793. const inDataView = info.viewer;
  794. const inOffset = {
  795. value: info.offset.value
  796. };
  797. const outBuffer = new Uint16Array( info.width * info.scanlineBlockSize * ( info.channels * info.type ) );
  798. const bitmap = new Uint8Array( BITMAP_SIZE );
  799. // Setup channel info
  800. let outBufferEnd = 0;
  801. const pizChannelData = new Array( info.channels );
  802. for ( let i = 0; i < info.channels; i ++ ) {
  803. pizChannelData[ i ] = {};
  804. pizChannelData[ i ][ 'start' ] = outBufferEnd;
  805. pizChannelData[ i ][ 'end' ] = pizChannelData[ i ][ 'start' ];
  806. pizChannelData[ i ][ 'nx' ] = info.width;
  807. pizChannelData[ i ][ 'ny' ] = info.lines;
  808. pizChannelData[ i ][ 'size' ] = info.type;
  809. outBufferEnd += pizChannelData[ i ].nx * pizChannelData[ i ].ny * pizChannelData[ i ].size;
  810. }
  811. // Read range compression data
  812. const minNonZero = parseUint16( inDataView, inOffset );
  813. const maxNonZero = parseUint16( inDataView, inOffset );
  814. if ( maxNonZero >= BITMAP_SIZE ) {
  815. throw new Error( 'Something is wrong with PIZ_COMPRESSION BITMAP_SIZE' );
  816. }
  817. if ( minNonZero <= maxNonZero ) {
  818. for ( let i = 0; i < maxNonZero - minNonZero + 1; i ++ ) {
  819. bitmap[ i + minNonZero ] = parseUint8( inDataView, inOffset );
  820. }
  821. }
  822. // Reverse LUT
  823. const lut = new Uint16Array( USHORT_RANGE );
  824. const maxValue = reverseLutFromBitmap( bitmap, lut );
  825. const length = parseUint32( inDataView, inOffset );
  826. // Huffman decoding
  827. hufUncompress( info.array, inDataView, inOffset, length, outBuffer, outBufferEnd );
  828. // Wavelet decoding
  829. for ( let i = 0; i < info.channels; ++ i ) {
  830. const cd = pizChannelData[ i ];
  831. for ( let j = 0; j < pizChannelData[ i ].size; ++ j ) {
  832. wav2Decode( outBuffer, cd.start + j, cd.nx, cd.size, cd.ny, cd.nx * cd.size, maxValue );
  833. }
  834. }
  835. // Expand the pixel data to their original range
  836. applyLut( lut, outBuffer, outBufferEnd );
  837. // Rearrange the pixel data into the format expected by the caller.
  838. let tmpOffset = 0;
  839. const tmpBuffer = new Uint8Array( outBuffer.buffer.byteLength );
  840. for ( let y = 0; y < info.lines; y ++ ) {
  841. for ( let c = 0; c < info.channels; c ++ ) {
  842. const cd = pizChannelData[ c ];
  843. const n = cd.nx * cd.size;
  844. const cp = new Uint8Array( outBuffer.buffer, cd.end * INT16_SIZE, n * INT16_SIZE );
  845. tmpBuffer.set( cp, tmpOffset );
  846. tmpOffset += n * INT16_SIZE;
  847. cd.end += n;
  848. }
  849. }
  850. return new DataView( tmpBuffer.buffer );
  851. }
  852. function uncompressPXR( info ) {
  853. const compressed = info.array.slice( info.offset.value, info.offset.value + info.size );
  854. if ( typeof fflate === 'undefined' ) {
  855. console.error( 'THREE.EXRLoader: External library fflate.min.js required.' );
  856. }
  857. const rawBuffer = fflate.unzlibSync( compressed ); // eslint-disable-line no-undef
  858. const sz = info.lines * info.channels * info.width;
  859. const tmpBuffer = info.type == 1 ? new Uint16Array( sz ) : new Uint32Array( sz );
  860. let tmpBufferEnd = 0;
  861. let writePtr = 0;
  862. const ptr = new Array( 4 );
  863. for ( let y = 0; y < info.lines; y ++ ) {
  864. for ( let c = 0; c < info.channels; c ++ ) {
  865. let pixel = 0;
  866. switch ( info.type ) {
  867. case 1:
  868. ptr[ 0 ] = tmpBufferEnd;
  869. ptr[ 1 ] = ptr[ 0 ] + info.width;
  870. tmpBufferEnd = ptr[ 1 ] + info.width;
  871. for ( let j = 0; j < info.width; ++ j ) {
  872. const diff = rawBuffer[ ptr[ 0 ] ++ ] << 8 | rawBuffer[ ptr[ 1 ] ++ ];
  873. pixel += diff;
  874. tmpBuffer[ writePtr ] = pixel;
  875. writePtr ++;
  876. }
  877. break;
  878. case 2:
  879. ptr[ 0 ] = tmpBufferEnd;
  880. ptr[ 1 ] = ptr[ 0 ] + info.width;
  881. ptr[ 2 ] = ptr[ 1 ] + info.width;
  882. tmpBufferEnd = ptr[ 2 ] + info.width;
  883. for ( let j = 0; j < info.width; ++ j ) {
  884. const diff = rawBuffer[ ptr[ 0 ] ++ ] << 24 | rawBuffer[ ptr[ 1 ] ++ ] << 16 | rawBuffer[ ptr[ 2 ] ++ ] << 8;
  885. pixel += diff;
  886. tmpBuffer[ writePtr ] = pixel;
  887. writePtr ++;
  888. }
  889. break;
  890. }
  891. }
  892. }
  893. return new DataView( tmpBuffer.buffer );
  894. }
  895. function uncompressDWA( info ) {
  896. const inDataView = info.viewer;
  897. const inOffset = {
  898. value: info.offset.value
  899. };
  900. const outBuffer = new Uint8Array( info.width * info.lines * ( info.channels * info.type * INT16_SIZE ) );
  901. // Read compression header information
  902. const dwaHeader = {
  903. version: parseInt64( inDataView, inOffset ),
  904. unknownUncompressedSize: parseInt64( inDataView, inOffset ),
  905. unknownCompressedSize: parseInt64( inDataView, inOffset ),
  906. acCompressedSize: parseInt64( inDataView, inOffset ),
  907. dcCompressedSize: parseInt64( inDataView, inOffset ),
  908. rleCompressedSize: parseInt64( inDataView, inOffset ),
  909. rleUncompressedSize: parseInt64( inDataView, inOffset ),
  910. rleRawSize: parseInt64( inDataView, inOffset ),
  911. totalAcUncompressedCount: parseInt64( inDataView, inOffset ),
  912. totalDcUncompressedCount: parseInt64( inDataView, inOffset ),
  913. acCompression: parseInt64( inDataView, inOffset )
  914. };
  915. if ( dwaHeader.version < 2 ) throw new Error( 'EXRLoader.parse: ' + EXRHeader.compression + ' version ' + dwaHeader.version + ' is unsupported' );
  916. // Read channel ruleset information
  917. const channelRules = new Array();
  918. let ruleSize = parseUint16( inDataView, inOffset ) - INT16_SIZE;
  919. while ( ruleSize > 0 ) {
  920. const name = parseNullTerminatedString( inDataView.buffer, inOffset );
  921. const value = parseUint8( inDataView, inOffset );
  922. const compression = value >> 2 & 3;
  923. const csc = ( value >> 4 ) - 1;
  924. const index = new Int8Array( [ csc ] )[ 0 ];
  925. const type = parseUint8( inDataView, inOffset );
  926. channelRules.push( {
  927. name: name,
  928. index: index,
  929. type: type,
  930. compression: compression
  931. } );
  932. ruleSize -= name.length + 3;
  933. }
  934. // Classify channels
  935. const channels = EXRHeader.channels;
  936. const channelData = new Array( info.channels );
  937. for ( let i = 0; i < info.channels; ++ i ) {
  938. const cd = channelData[ i ] = {};
  939. const channel = channels[ i ];
  940. cd.name = channel.name;
  941. cd.compression = UNKNOWN;
  942. cd.decoded = false;
  943. cd.type = channel.pixelType;
  944. cd.pLinear = channel.pLinear;
  945. cd.width = info.width;
  946. cd.height = info.lines;
  947. }
  948. const cscSet = {
  949. idx: new Array( 3 )
  950. };
  951. for ( let offset = 0; offset < info.channels; ++ offset ) {
  952. const cd = channelData[ offset ];
  953. for ( let i = 0; i < channelRules.length; ++ i ) {
  954. const rule = channelRules[ i ];
  955. if ( cd.name == rule.name ) {
  956. cd.compression = rule.compression;
  957. if ( rule.index >= 0 ) {
  958. cscSet.idx[ rule.index ] = offset;
  959. }
  960. cd.offset = offset;
  961. }
  962. }
  963. }
  964. let acBuffer, dcBuffer, rleBuffer;
  965. // Read DCT - AC component data
  966. if ( dwaHeader.acCompressedSize > 0 ) {
  967. switch ( dwaHeader.acCompression ) {
  968. case STATIC_HUFFMAN:
  969. acBuffer = new Uint16Array( dwaHeader.totalAcUncompressedCount );
  970. hufUncompress( info.array, inDataView, inOffset, dwaHeader.acCompressedSize, acBuffer, dwaHeader.totalAcUncompressedCount );
  971. break;
  972. case DEFLATE:
  973. const compressed = info.array.slice( inOffset.value, inOffset.value + dwaHeader.totalAcUncompressedCount );
  974. const data = fflate.unzlibSync( compressed ); // eslint-disable-line no-undef
  975. acBuffer = new Uint16Array( data.buffer );
  976. inOffset.value += dwaHeader.totalAcUncompressedCount;
  977. break;
  978. }
  979. }
  980. // Read DCT - DC component data
  981. if ( dwaHeader.dcCompressedSize > 0 ) {
  982. const zlibInfo = {
  983. array: info.array,
  984. offset: inOffset,
  985. size: dwaHeader.dcCompressedSize
  986. };
  987. dcBuffer = new Uint16Array( uncompressZIP( zlibInfo ).buffer );
  988. inOffset.value += dwaHeader.dcCompressedSize;
  989. }
  990. // Read RLE compressed data
  991. if ( dwaHeader.rleRawSize > 0 ) {
  992. const compressed = info.array.slice( inOffset.value, inOffset.value + dwaHeader.rleCompressedSize );
  993. const data = fflate.unzlibSync( compressed ); // eslint-disable-line no-undef
  994. rleBuffer = decodeRunLength( data.buffer );
  995. inOffset.value += dwaHeader.rleCompressedSize;
  996. }
  997. // Prepare outbuffer data offset
  998. let outBufferEnd = 0;
  999. const rowOffsets = new Array( channelData.length );
  1000. for ( let i = 0; i < rowOffsets.length; ++ i ) {
  1001. rowOffsets[ i ] = new Array();
  1002. }
  1003. for ( let y = 0; y < info.lines; ++ y ) {
  1004. for ( let chan = 0; chan < channelData.length; ++ chan ) {
  1005. rowOffsets[ chan ].push( outBufferEnd );
  1006. outBufferEnd += channelData[ chan ].width * info.type * INT16_SIZE;
  1007. }
  1008. }
  1009. // Lossy DCT decode RGB channels
  1010. lossyDctDecode( cscSet, rowOffsets, channelData, acBuffer, dcBuffer, outBuffer );
  1011. // Decode other channels
  1012. for ( let i = 0; i < channelData.length; ++ i ) {
  1013. const cd = channelData[ i ];
  1014. if ( cd.decoded ) continue;
  1015. switch ( cd.compression ) {
  1016. case RLE:
  1017. let row = 0;
  1018. let rleOffset = 0;
  1019. for ( let y = 0; y < info.lines; ++ y ) {
  1020. let rowOffsetBytes = rowOffsets[ i ][ row ];
  1021. for ( let x = 0; x < cd.width; ++ x ) {
  1022. for ( let byte = 0; byte < INT16_SIZE * cd.type; ++ byte ) {
  1023. outBuffer[ rowOffsetBytes ++ ] = rleBuffer[ rleOffset + byte * cd.width * cd.height ];
  1024. }
  1025. rleOffset ++;
  1026. }
  1027. row ++;
  1028. }
  1029. break;
  1030. case LOSSY_DCT: // skip
  1031. default:
  1032. throw new Error( 'EXRLoader.parse: unsupported channel compression' );
  1033. }
  1034. }
  1035. return new DataView( outBuffer.buffer );
  1036. }
  1037. function parseNullTerminatedString( buffer, offset ) {
  1038. const uintBuffer = new Uint8Array( buffer );
  1039. let endOffset = 0;
  1040. while ( uintBuffer[ offset.value + endOffset ] != 0 ) {
  1041. endOffset += 1;
  1042. }
  1043. const stringValue = new TextDecoder().decode( uintBuffer.slice( offset.value, offset.value + endOffset ) );
  1044. offset.value = offset.value + endOffset + 1;
  1045. return stringValue;
  1046. }
  1047. function parseFixedLengthString( buffer, offset, size ) {
  1048. const stringValue = new TextDecoder().decode( new Uint8Array( buffer ).slice( offset.value, offset.value + size ) );
  1049. offset.value = offset.value + size;
  1050. return stringValue;
  1051. }
  1052. function parseRational( dataView, offset ) {
  1053. const x = parseInt32( dataView, offset );
  1054. const y = parseUint32( dataView, offset );
  1055. return [ x, y ];
  1056. }
  1057. function parseTimecode( dataView, offset ) {
  1058. const x = parseUint32( dataView, offset );
  1059. const y = parseUint32( dataView, offset );
  1060. return [ x, y ];
  1061. }
  1062. function parseInt32( dataView, offset ) {
  1063. const Int32 = dataView.getInt32( offset.value, true );
  1064. offset.value = offset.value + INT32_SIZE;
  1065. return Int32;
  1066. }
  1067. function parseUint32( dataView, offset ) {
  1068. const Uint32 = dataView.getUint32( offset.value, true );
  1069. offset.value = offset.value + INT32_SIZE;
  1070. return Uint32;
  1071. }
  1072. function parseUint8Array( uInt8Array, offset ) {
  1073. const Uint8 = uInt8Array[ offset.value ];
  1074. offset.value = offset.value + INT8_SIZE;
  1075. return Uint8;
  1076. }
  1077. function parseUint8( dataView, offset ) {
  1078. const Uint8 = dataView.getUint8( offset.value );
  1079. offset.value = offset.value + INT8_SIZE;
  1080. return Uint8;
  1081. }
  1082. const parseInt64 = function ( dataView, offset ) {
  1083. const Int64 = Number( dataView.getBigInt64( offset.value, true ) );
  1084. offset.value += ULONG_SIZE;
  1085. return Int64;
  1086. };
  1087. function parseFloat32( dataView, offset ) {
  1088. const float = dataView.getFloat32( offset.value, true );
  1089. offset.value += FLOAT32_SIZE;
  1090. return float;
  1091. }
  1092. function decodeFloat32( dataView, offset ) {
  1093. return THREE.DataUtils.toHalfFloat( parseFloat32( dataView, offset ) );
  1094. }
  1095. // https://stackoverflow.com/questions/5678432/decompressing-half-precision-floats-in-javascript
  1096. function decodeFloat16( binary ) {
  1097. const exponent = ( binary & 0x7C00 ) >> 10,
  1098. fraction = binary & 0x03FF;
  1099. return ( binary >> 15 ? - 1 : 1 ) * ( exponent ? exponent === 0x1F ? fraction ? NaN : Infinity : Math.pow( 2, exponent - 15 ) * ( 1 + fraction / 0x400 ) : 6.103515625e-5 * ( fraction / 0x400 ) );
  1100. }
  1101. function parseUint16( dataView, offset ) {
  1102. const Uint16 = dataView.getUint16( offset.value, true );
  1103. offset.value += INT16_SIZE;
  1104. return Uint16;
  1105. }
  1106. function parseFloat16( buffer, offset ) {
  1107. return decodeFloat16( parseUint16( buffer, offset ) );
  1108. }
  1109. function parseChlist( dataView, buffer, offset, size ) {
  1110. const startOffset = offset.value;
  1111. const channels = [];
  1112. while ( offset.value < startOffset + size - 1 ) {
  1113. const name = parseNullTerminatedString( buffer, offset );
  1114. const pixelType = parseInt32( dataView, offset );
  1115. const pLinear = parseUint8( dataView, offset );
  1116. offset.value += 3; // reserved, three chars
  1117. const xSampling = parseInt32( dataView, offset );
  1118. const ySampling = parseInt32( dataView, offset );
  1119. channels.push( {
  1120. name: name,
  1121. pixelType: pixelType,
  1122. pLinear: pLinear,
  1123. xSampling: xSampling,
  1124. ySampling: ySampling
  1125. } );
  1126. }
  1127. offset.value += 1;
  1128. return channels;
  1129. }
  1130. function parseChromaticities( dataView, offset ) {
  1131. const redX = parseFloat32( dataView, offset );
  1132. const redY = parseFloat32( dataView, offset );
  1133. const greenX = parseFloat32( dataView, offset );
  1134. const greenY = parseFloat32( dataView, offset );
  1135. const blueX = parseFloat32( dataView, offset );
  1136. const blueY = parseFloat32( dataView, offset );
  1137. const whiteX = parseFloat32( dataView, offset );
  1138. const whiteY = parseFloat32( dataView, offset );
  1139. return {
  1140. redX: redX,
  1141. redY: redY,
  1142. greenX: greenX,
  1143. greenY: greenY,
  1144. blueX: blueX,
  1145. blueY: blueY,
  1146. whiteX: whiteX,
  1147. whiteY: whiteY
  1148. };
  1149. }
  1150. function parseCompression( dataView, offset ) {
  1151. const compressionCodes = [ 'NO_COMPRESSION', 'RLE_COMPRESSION', 'ZIPS_COMPRESSION', 'ZIP_COMPRESSION', 'PIZ_COMPRESSION', 'PXR24_COMPRESSION', 'B44_COMPRESSION', 'B44A_COMPRESSION', 'DWAA_COMPRESSION', 'DWAB_COMPRESSION' ];
  1152. const compression = parseUint8( dataView, offset );
  1153. return compressionCodes[ compression ];
  1154. }
  1155. function parseBox2i( dataView, offset ) {
  1156. const xMin = parseUint32( dataView, offset );
  1157. const yMin = parseUint32( dataView, offset );
  1158. const xMax = parseUint32( dataView, offset );
  1159. const yMax = parseUint32( dataView, offset );
  1160. return {
  1161. xMin: xMin,
  1162. yMin: yMin,
  1163. xMax: xMax,
  1164. yMax: yMax
  1165. };
  1166. }
  1167. function parseLineOrder( dataView, offset ) {
  1168. const lineOrders = [ 'INCREASING_Y' ];
  1169. const lineOrder = parseUint8( dataView, offset );
  1170. return lineOrders[ lineOrder ];
  1171. }
  1172. function parseV2f( dataView, offset ) {
  1173. const x = parseFloat32( dataView, offset );
  1174. const y = parseFloat32( dataView, offset );
  1175. return [ x, y ];
  1176. }
  1177. function parseV3f( dataView, offset ) {
  1178. const x = parseFloat32( dataView, offset );
  1179. const y = parseFloat32( dataView, offset );
  1180. const z = parseFloat32( dataView, offset );
  1181. return [ x, y, z ];
  1182. }
  1183. function parseValue( dataView, buffer, offset, type, size ) {
  1184. if ( type === 'string' || type === 'stringvector' || type === 'iccProfile' ) {
  1185. return parseFixedLengthString( buffer, offset, size );
  1186. } else if ( type === 'chlist' ) {
  1187. return parseChlist( dataView, buffer, offset, size );
  1188. } else if ( type === 'chromaticities' ) {
  1189. return parseChromaticities( dataView, offset );
  1190. } else if ( type === 'compression' ) {
  1191. return parseCompression( dataView, offset );
  1192. } else if ( type === 'box2i' ) {
  1193. return parseBox2i( dataView, offset );
  1194. } else if ( type === 'lineOrder' ) {
  1195. return parseLineOrder( dataView, offset );
  1196. } else if ( type === 'float' ) {
  1197. return parseFloat32( dataView, offset );
  1198. } else if ( type === 'v2f' ) {
  1199. return parseV2f( dataView, offset );
  1200. } else if ( type === 'v3f' ) {
  1201. return parseV3f( dataView, offset );
  1202. } else if ( type === 'int' ) {
  1203. return parseInt32( dataView, offset );
  1204. } else if ( type === 'rational' ) {
  1205. return parseRational( dataView, offset );
  1206. } else if ( type === 'timecode' ) {
  1207. return parseTimecode( dataView, offset );
  1208. } else if ( type === 'preview' ) {
  1209. offset.value += size;
  1210. return 'skipped';
  1211. } else {
  1212. offset.value += size;
  1213. return undefined;
  1214. }
  1215. }
  1216. function parseHeader( dataView, buffer, offset ) {
  1217. const EXRHeader = {};
  1218. if ( dataView.getUint32( 0, true ) != 20000630 ) {
  1219. // magic
  1220. throw new Error( 'THREE.EXRLoader: provided file doesn\'t appear to be in OpenEXR format.' );
  1221. }
  1222. EXRHeader.version = dataView.getUint8( 4 );
  1223. const spec = dataView.getUint8( 5 ); // fullMask
  1224. EXRHeader.spec = {
  1225. singleTile: !! ( spec & 2 ),
  1226. longName: !! ( spec & 4 ),
  1227. deepFormat: !! ( spec & 8 ),
  1228. multiPart: !! ( spec & 16 )
  1229. };
  1230. // start of header
  1231. offset.value = 8; // start at 8 - after pre-amble
  1232. let keepReading = true;
  1233. while ( keepReading ) {
  1234. const attributeName = parseNullTerminatedString( buffer, offset );
  1235. if ( attributeName == 0 ) {
  1236. keepReading = false;
  1237. } else {
  1238. const attributeType = parseNullTerminatedString( buffer, offset );
  1239. const attributeSize = parseUint32( dataView, offset );
  1240. const attributeValue = parseValue( dataView, buffer, offset, attributeType, attributeSize );
  1241. if ( attributeValue === undefined ) {
  1242. console.warn( `EXRLoader.parse: skipped unknown header attribute type \'${attributeType}\'.` );
  1243. } else {
  1244. EXRHeader[ attributeName ] = attributeValue;
  1245. }
  1246. }
  1247. }
  1248. if ( ( spec & ~ 0x04 ) != 0 ) {
  1249. // unsupported tiled, deep-image, multi-part
  1250. console.error( 'EXRHeader:', EXRHeader );
  1251. throw new Error( 'THREE.EXRLoader: provided file is currently unsupported.' );
  1252. }
  1253. return EXRHeader;
  1254. }
  1255. function setupDecoder( EXRHeader, dataView, uInt8Array, offset, outputType ) {
  1256. const EXRDecoder = {
  1257. size: 0,
  1258. viewer: dataView,
  1259. array: uInt8Array,
  1260. offset: offset,
  1261. width: EXRHeader.dataWindow.xMax - EXRHeader.dataWindow.xMin + 1,
  1262. height: EXRHeader.dataWindow.yMax - EXRHeader.dataWindow.yMin + 1,
  1263. channels: EXRHeader.channels.length,
  1264. bytesPerLine: null,
  1265. lines: null,
  1266. inputSize: null,
  1267. type: EXRHeader.channels[ 0 ].pixelType,
  1268. uncompress: null,
  1269. getter: null,
  1270. format: null,
  1271. encoding: null
  1272. };
  1273. switch ( EXRHeader.compression ) {
  1274. case 'NO_COMPRESSION':
  1275. EXRDecoder.lines = 1;
  1276. EXRDecoder.uncompress = uncompressRAW;
  1277. break;
  1278. case 'RLE_COMPRESSION':
  1279. EXRDecoder.lines = 1;
  1280. EXRDecoder.uncompress = uncompressRLE;
  1281. break;
  1282. case 'ZIPS_COMPRESSION':
  1283. EXRDecoder.lines = 1;
  1284. EXRDecoder.uncompress = uncompressZIP;
  1285. break;
  1286. case 'ZIP_COMPRESSION':
  1287. EXRDecoder.lines = 16;
  1288. EXRDecoder.uncompress = uncompressZIP;
  1289. break;
  1290. case 'PIZ_COMPRESSION':
  1291. EXRDecoder.lines = 32;
  1292. EXRDecoder.uncompress = uncompressPIZ;
  1293. break;
  1294. case 'PXR24_COMPRESSION':
  1295. EXRDecoder.lines = 16;
  1296. EXRDecoder.uncompress = uncompressPXR;
  1297. break;
  1298. case 'DWAA_COMPRESSION':
  1299. EXRDecoder.lines = 32;
  1300. EXRDecoder.uncompress = uncompressDWA;
  1301. break;
  1302. case 'DWAB_COMPRESSION':
  1303. EXRDecoder.lines = 256;
  1304. EXRDecoder.uncompress = uncompressDWA;
  1305. break;
  1306. default:
  1307. throw new Error( 'EXRLoader.parse: ' + EXRHeader.compression + ' is unsupported' );
  1308. }
  1309. EXRDecoder.scanlineBlockSize = EXRDecoder.lines;
  1310. if ( EXRDecoder.type == 1 ) {
  1311. // half
  1312. switch ( outputType ) {
  1313. case THREE.FloatType:
  1314. EXRDecoder.getter = parseFloat16;
  1315. EXRDecoder.inputSize = INT16_SIZE;
  1316. break;
  1317. case THREE.HalfFloatType:
  1318. EXRDecoder.getter = parseUint16;
  1319. EXRDecoder.inputSize = INT16_SIZE;
  1320. break;
  1321. }
  1322. } else if ( EXRDecoder.type == 2 ) {
  1323. // float
  1324. switch ( outputType ) {
  1325. case THREE.FloatType:
  1326. EXRDecoder.getter = parseFloat32;
  1327. EXRDecoder.inputSize = FLOAT32_SIZE;
  1328. break;
  1329. case THREE.HalfFloatType:
  1330. EXRDecoder.getter = decodeFloat32;
  1331. EXRDecoder.inputSize = FLOAT32_SIZE;
  1332. }
  1333. } else {
  1334. throw new Error( 'EXRLoader.parse: unsupported pixelType ' + EXRDecoder.type + ' for ' + EXRHeader.compression + '.' );
  1335. }
  1336. EXRDecoder.blockCount = ( EXRHeader.dataWindow.yMax + 1 ) / EXRDecoder.scanlineBlockSize;
  1337. for ( let i = 0; i < EXRDecoder.blockCount; i ++ ) parseInt64( dataView, offset ); // scanlineOffset
  1338. // we should be passed the scanline offset table, ready to start reading pixel data.
  1339. // RGB images will be converted to RGBA format, preventing software emulation in select devices.
  1340. EXRDecoder.outputChannels = EXRDecoder.channels == 3 ? 4 : EXRDecoder.channels;
  1341. const size = EXRDecoder.width * EXRDecoder.height * EXRDecoder.outputChannels;
  1342. switch ( outputType ) {
  1343. case THREE.FloatType:
  1344. EXRDecoder.byteArray = new Float32Array( size );
  1345. // Fill initially with 1s for the alpha value if the texture is not RGBA, RGB values will be overwritten
  1346. if ( EXRDecoder.channels < EXRDecoder.outputChannels ) EXRDecoder.byteArray.fill( 1, 0, size );
  1347. break;
  1348. case THREE.HalfFloatType:
  1349. EXRDecoder.byteArray = new Uint16Array( size );
  1350. if ( EXRDecoder.channels < EXRDecoder.outputChannels ) EXRDecoder.byteArray.fill( 0x3C00, 0, size ); // Uint16Array holds half float data, 0x3C00 is 1
  1351. break;
  1352. default:
  1353. console.error( 'THREE.EXRLoader: unsupported type: ', outputType );
  1354. break;
  1355. }
  1356. EXRDecoder.bytesPerLine = EXRDecoder.width * EXRDecoder.inputSize * EXRDecoder.channels;
  1357. if ( EXRDecoder.outputChannels == 4 ) {
  1358. EXRDecoder.format = THREE.RGBAFormat;
  1359. EXRDecoder.encoding = THREE.LinearEncoding;
  1360. } else {
  1361. EXRDecoder.format = THREE.RedFormat;
  1362. EXRDecoder.encoding = THREE.LinearEncoding;
  1363. }
  1364. return EXRDecoder;
  1365. }
  1366. // start parsing file [START]
  1367. const bufferDataView = new DataView( buffer );
  1368. const uInt8Array = new Uint8Array( buffer );
  1369. const offset = {
  1370. value: 0
  1371. };
  1372. // get header information and validate format.
  1373. const EXRHeader = parseHeader( bufferDataView, buffer, offset );
  1374. // get input compression information and prepare decoding.
  1375. const EXRDecoder = setupDecoder( EXRHeader, bufferDataView, uInt8Array, offset, this.type );
  1376. const tmpOffset = {
  1377. value: 0
  1378. };
  1379. const channelOffsets = {
  1380. R: 0,
  1381. G: 1,
  1382. B: 2,
  1383. A: 3,
  1384. Y: 0
  1385. };
  1386. for ( let scanlineBlockIdx = 0; scanlineBlockIdx < EXRDecoder.height / EXRDecoder.scanlineBlockSize; scanlineBlockIdx ++ ) {
  1387. const line = parseUint32( bufferDataView, offset ); // line_no
  1388. EXRDecoder.size = parseUint32( bufferDataView, offset ); // data_len
  1389. EXRDecoder.lines = line + EXRDecoder.scanlineBlockSize > EXRDecoder.height ? EXRDecoder.height - line : EXRDecoder.scanlineBlockSize;
  1390. const isCompressed = EXRDecoder.size < EXRDecoder.lines * EXRDecoder.bytesPerLine;
  1391. const viewer = isCompressed ? EXRDecoder.uncompress( EXRDecoder ) : uncompressRAW( EXRDecoder );
  1392. offset.value += EXRDecoder.size;
  1393. for ( let line_y = 0; line_y < EXRDecoder.scanlineBlockSize; line_y ++ ) {
  1394. const true_y = line_y + scanlineBlockIdx * EXRDecoder.scanlineBlockSize;
  1395. if ( true_y >= EXRDecoder.height ) break;
  1396. for ( let channelID = 0; channelID < EXRDecoder.channels; channelID ++ ) {
  1397. const cOff = channelOffsets[ EXRHeader.channels[ channelID ].name ];
  1398. for ( let x = 0; x < EXRDecoder.width; x ++ ) {
  1399. tmpOffset.value = ( line_y * ( EXRDecoder.channels * EXRDecoder.width ) + channelID * EXRDecoder.width + x ) * EXRDecoder.inputSize;
  1400. const outIndex = ( EXRDecoder.height - 1 - true_y ) * ( EXRDecoder.width * EXRDecoder.outputChannels ) + x * EXRDecoder.outputChannels + cOff;
  1401. EXRDecoder.byteArray[ outIndex ] = EXRDecoder.getter( viewer, tmpOffset );
  1402. }
  1403. }
  1404. }
  1405. }
  1406. return {
  1407. header: EXRHeader,
  1408. width: EXRDecoder.width,
  1409. height: EXRDecoder.height,
  1410. data: EXRDecoder.byteArray,
  1411. format: EXRDecoder.format,
  1412. encoding: EXRDecoder.encoding,
  1413. type: this.type
  1414. };
  1415. }
  1416. setDataType( value ) {
  1417. this.type = value;
  1418. return this;
  1419. }
  1420. load( url, onLoad, onProgress, onError ) {
  1421. function onLoadCallback( texture, texData ) {
  1422. texture.encoding = texData.encoding;
  1423. texture.minFilter = THREE.LinearFilter;
  1424. texture.magFilter = THREE.LinearFilter;
  1425. texture.generateMipmaps = false;
  1426. texture.flipY = false;
  1427. if ( onLoad ) onLoad( texture, texData );
  1428. }
  1429. return super.load( url, onLoadCallback, onProgress, onError );
  1430. }
  1431. }
  1432. THREE.EXRLoader = EXRLoader;
  1433. } )();