EXRLoader.js 54 KB

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