| /* eslint-disable */ |
| // gif.worker.js 0.2.0 - https://github.com/jnordberg/gif.js |
| (function e(t, n, r) { |
| function s(o, u) { |
| if (!n[o]) { |
| if (!t[o]) { |
| var a = typeof require == 'function' && require; |
| if (!u && a) return a(o, !0); |
| if (i) return i(o, !0); |
| var f = new Error("Cannot find module '" + o + "'"); |
| throw ((f.code = 'MODULE_NOT_FOUND'), f); |
| } |
| var l = (n[o] = { |
| exports: {}, |
| }); |
| t[o][0].call( |
| l.exports, |
| function (e) { |
| var n = t[o][1][e]; |
| return s(n ? n : e); |
| }, |
| l, |
| l.exports, |
| e, |
| t, |
| n, |
| r |
| ); |
| } |
| return n[o].exports; |
| } |
| var i = typeof require == 'function' && require; |
| for (var o = 0; o < r.length; o++) s(r[o]); |
| return s; |
| })( |
| { |
| 1: [ |
| function (require, module, exports) { |
| var NeuQuant = require('./TypedNeuQuant.js'); |
| var LZWEncoder = require('./LZWEncoder.js'); |
| |
| function ByteArray() { |
| this.page = -1; |
| this.pages = []; |
| this.newPage(); |
| } |
| ByteArray.pageSize = 4096; |
| ByteArray.charMap = {}; |
| for (var i = 0; i < 256; i++) |
| ByteArray.charMap[i] = String.fromCharCode(i); |
| ByteArray.prototype.newPage = function () { |
| this.pages[++this.page] = new Uint8Array(ByteArray.pageSize); |
| this.cursor = 0; |
| }; |
| ByteArray.prototype.getData = function () { |
| var rv = ''; |
| for (var p = 0; p < this.pages.length; p++) { |
| for (var i = 0; i < ByteArray.pageSize; i++) { |
| rv += ByteArray.charMap[this.pages[p][i]]; |
| } |
| } |
| return rv; |
| }; |
| ByteArray.prototype.writeByte = function (val) { |
| if (this.cursor >= ByteArray.pageSize) this.newPage(); |
| this.pages[this.page][this.cursor++] = val; |
| }; |
| ByteArray.prototype.writeUTFBytes = function (string) { |
| for (var l = string.length, i = 0; i < l; i++) |
| this.writeByte(string.charCodeAt(i)); |
| }; |
| ByteArray.prototype.writeBytes = function (array, offset, length) { |
| for (var l = length || array.length, i = offset || 0; i < l; i++) |
| this.writeByte(array[i]); |
| }; |
| |
| function GIFEncoder(width, height) { |
| this.width = ~~width; |
| this.height = ~~height; |
| this.transparent = null; |
| this.transIndex = 0; |
| this.repeat = -1; |
| this.delay = 0; |
| this.image = null; |
| this.pixels = null; |
| this.indexedPixels = null; |
| this.colorDepth = null; |
| this.colorTab = null; |
| this.neuQuant = null; |
| this.usedEntry = new Array(); |
| this.palSize = 7; |
| this.dispose = -1; |
| this.firstFrame = true; |
| this.sample = 10; |
| this.dither = false; |
| this.globalPalette = false; |
| this.out = new ByteArray(); |
| } |
| GIFEncoder.prototype.setDelay = function (milliseconds) { |
| this.delay = Math.round(milliseconds / 10); |
| }; |
| GIFEncoder.prototype.setFrameRate = function (fps) { |
| this.delay = Math.round(100 / fps); |
| }; |
| GIFEncoder.prototype.setDispose = function (disposalCode) { |
| if (disposalCode >= 0) this.dispose = disposalCode; |
| }; |
| GIFEncoder.prototype.setRepeat = function (repeat) { |
| this.repeat = repeat; |
| }; |
| GIFEncoder.prototype.setTransparent = function (color) { |
| this.transparent = color; |
| }; |
| GIFEncoder.prototype.addFrame = function (imageData) { |
| this.image = imageData; |
| this.colorTab = |
| this.globalPalette && this.globalPalette.slice |
| ? this.globalPalette |
| : null; |
| this.getImagePixels(); |
| this.analyzePixels(); |
| if (this.globalPalette === true) this.globalPalette = this.colorTab; |
| if (this.firstFrame) { |
| this.writeLSD(); |
| this.writePalette(); |
| if (this.repeat >= 0) { |
| this.writeNetscapeExt(); |
| } |
| } |
| this.writeGraphicCtrlExt(); |
| this.writeImageDesc(); |
| if (!this.firstFrame && !this.globalPalette) this.writePalette(); |
| this.writePixels(); |
| this.firstFrame = false; |
| }; |
| GIFEncoder.prototype.finish = function () { |
| this.out.writeByte(59); |
| }; |
| GIFEncoder.prototype.setQuality = function (quality) { |
| if (quality < 1) quality = 1; |
| this.sample = quality; |
| }; |
| GIFEncoder.prototype.setDither = function (dither) { |
| if (dither === true) dither = 'FloydSteinberg'; |
| this.dither = dither; |
| }; |
| GIFEncoder.prototype.setGlobalPalette = function (palette) { |
| this.globalPalette = palette; |
| }; |
| GIFEncoder.prototype.getGlobalPalette = function () { |
| return ( |
| (this.globalPalette && |
| this.globalPalette.slice && |
| this.globalPalette.slice(0)) || |
| this.globalPalette |
| ); |
| }; |
| GIFEncoder.prototype.writeHeader = function () { |
| this.out.writeUTFBytes('GIF89a'); |
| }; |
| GIFEncoder.prototype.analyzePixels = function () { |
| if (!this.colorTab) { |
| this.neuQuant = new NeuQuant(this.pixels, this.sample); |
| this.neuQuant.buildColormap(); |
| this.colorTab = this.neuQuant.getColormap(); |
| } |
| if (this.dither) { |
| this.ditherPixels( |
| this.dither.replace('-serpentine', ''), |
| this.dither.match(/-serpentine/) !== null |
| ); |
| } else { |
| this.indexPixels(); |
| } |
| this.pixels = null; |
| this.colorDepth = 8; |
| this.palSize = 7; |
| if (this.transparent !== null) { |
| this.transIndex = this.findClosest(this.transparent, true); |
| } |
| }; |
| GIFEncoder.prototype.indexPixels = function (imgq) { |
| var nPix = this.pixels.length / 3; |
| this.indexedPixels = new Uint8Array(nPix); |
| var k = 0; |
| for (var j = 0; j < nPix; j++) { |
| var index = this.findClosestRGB( |
| this.pixels[k++] & 255, |
| this.pixels[k++] & 255, |
| this.pixels[k++] & 255 |
| ); |
| this.usedEntry[index] = true; |
| this.indexedPixels[j] = index; |
| } |
| }; |
| GIFEncoder.prototype.ditherPixels = function (kernel, serpentine) { |
| var kernels = { |
| FalseFloydSteinberg: [ |
| [3 / 8, 1, 0], |
| [3 / 8, 0, 1], |
| [2 / 8, 1, 1], |
| ], |
| FloydSteinberg: [ |
| [7 / 16, 1, 0], |
| [3 / 16, -1, 1], |
| [5 / 16, 0, 1], |
| [1 / 16, 1, 1], |
| ], |
| Stucki: [ |
| [8 / 42, 1, 0], |
| [4 / 42, 2, 0], |
| [2 / 42, -2, 1], |
| [4 / 42, -1, 1], |
| [8 / 42, 0, 1], |
| [4 / 42, 1, 1], |
| [2 / 42, 2, 1], |
| [1 / 42, -2, 2], |
| [2 / 42, -1, 2], |
| [4 / 42, 0, 2], |
| [2 / 42, 1, 2], |
| [1 / 42, 2, 2], |
| ], |
| Atkinson: [ |
| [1 / 8, 1, 0], |
| [1 / 8, 2, 0], |
| [1 / 8, -1, 1], |
| [1 / 8, 0, 1], |
| [1 / 8, 1, 1], |
| [1 / 8, 0, 2], |
| ], |
| }; |
| if (!kernel || !kernels[kernel]) { |
| throw 'Unknown dithering kernel: ' + kernel; |
| } |
| var ds = kernels[kernel]; |
| var index = 0, |
| height = this.height, |
| width = this.width, |
| data = this.pixels; |
| var direction = serpentine ? -1 : 1; |
| this.indexedPixels = new Uint8Array(this.pixels.length / 3); |
| for (var y = 0; y < height; y++) { |
| if (serpentine) direction = direction * -1; |
| for ( |
| var x = direction == 1 ? 0 : width - 1, |
| xend = direction == 1 ? width : 0; |
| x !== xend; |
| x += direction |
| ) { |
| index = y * width + x; |
| var idx = index * 3; |
| var r1 = data[idx]; |
| var g1 = data[idx + 1]; |
| var b1 = data[idx + 2]; |
| idx = this.findClosestRGB(r1, g1, b1); |
| this.usedEntry[idx] = true; |
| this.indexedPixels[index] = idx; |
| idx *= 3; |
| var r2 = this.colorTab[idx]; |
| var g2 = this.colorTab[idx + 1]; |
| var b2 = this.colorTab[idx + 2]; |
| var er = r1 - r2; |
| var eg = g1 - g2; |
| var eb = b1 - b2; |
| for ( |
| var i = direction == 1 ? 0 : ds.length - 1, |
| end = direction == 1 ? ds.length : 0; |
| i !== end; |
| i += direction |
| ) { |
| var x1 = ds[i][1]; |
| var y1 = ds[i][2]; |
| if ( |
| x1 + x >= 0 && |
| x1 + x < width && |
| y1 + y >= 0 && |
| y1 + y < height |
| ) { |
| var d = ds[i][0]; |
| idx = index + x1 + y1 * width; |
| idx *= 3; |
| data[idx] = Math.max(0, Math.min(255, data[idx] + er * d)); |
| data[idx + 1] = Math.max( |
| 0, |
| Math.min(255, data[idx + 1] + eg * d) |
| ); |
| data[idx + 2] = Math.max( |
| 0, |
| Math.min(255, data[idx + 2] + eb * d) |
| ); |
| } |
| } |
| } |
| } |
| }; |
| GIFEncoder.prototype.findClosest = function (c, used) { |
| return this.findClosestRGB( |
| (c & 16711680) >> 16, |
| (c & 65280) >> 8, |
| c & 255, |
| used |
| ); |
| }; |
| GIFEncoder.prototype.findClosestRGB = function (r, g, b, used) { |
| if (this.colorTab === null) return -1; |
| if (this.neuQuant && !used) { |
| return this.neuQuant.lookupRGB(r, g, b); |
| } |
| var c = b | (g << 8) | (r << 16); |
| var minpos = 0; |
| var dmin = 256 * 256 * 256; |
| var len = this.colorTab.length; |
| for (var i = 0, index = 0; i < len; index++) { |
| var dr = r - (this.colorTab[i++] & 255); |
| var dg = g - (this.colorTab[i++] & 255); |
| var db = b - (this.colorTab[i++] & 255); |
| var d = dr * dr + dg * dg + db * db; |
| if ((!used || this.usedEntry[index]) && d < dmin) { |
| dmin = d; |
| minpos = index; |
| } |
| } |
| return minpos; |
| }; |
| GIFEncoder.prototype.getImagePixels = function () { |
| var w = this.width; |
| var h = this.height; |
| this.pixels = new Uint8Array(w * h * 3); |
| var data = this.image; |
| var srcPos = 0; |
| var count = 0; |
| for (var i = 0; i < h; i++) { |
| for (var j = 0; j < w; j++) { |
| this.pixels[count++] = data[srcPos++]; |
| this.pixels[count++] = data[srcPos++]; |
| this.pixels[count++] = data[srcPos++]; |
| srcPos++; |
| } |
| } |
| }; |
| GIFEncoder.prototype.writeGraphicCtrlExt = function () { |
| this.out.writeByte(33); |
| this.out.writeByte(249); |
| this.out.writeByte(4); |
| var transp, disp; |
| if (this.transparent === null) { |
| transp = 0; |
| disp = 0; |
| } else { |
| transp = 1; |
| disp = 2; |
| } |
| if (this.dispose >= 0) { |
| disp = dispose & 7; |
| } |
| disp <<= 2; |
| this.out.writeByte(0 | disp | 0 | transp); |
| this.writeShort(this.delay); |
| this.out.writeByte(this.transIndex); |
| this.out.writeByte(0); |
| }; |
| GIFEncoder.prototype.writeImageDesc = function () { |
| this.out.writeByte(44); |
| this.writeShort(0); |
| this.writeShort(0); |
| this.writeShort(this.width); |
| this.writeShort(this.height); |
| if (this.firstFrame || this.globalPalette) { |
| this.out.writeByte(0); |
| } else { |
| this.out.writeByte(128 | 0 | 0 | 0 | this.palSize); |
| } |
| }; |
| GIFEncoder.prototype.writeLSD = function () { |
| this.writeShort(this.width); |
| this.writeShort(this.height); |
| this.out.writeByte(128 | 112 | 0 | this.palSize); |
| this.out.writeByte(0); |
| this.out.writeByte(0); |
| }; |
| GIFEncoder.prototype.writeNetscapeExt = function () { |
| this.out.writeByte(33); |
| this.out.writeByte(255); |
| this.out.writeByte(11); |
| this.out.writeUTFBytes('NETSCAPE2.0'); |
| this.out.writeByte(3); |
| this.out.writeByte(1); |
| this.writeShort(this.repeat); |
| this.out.writeByte(0); |
| }; |
| GIFEncoder.prototype.writePalette = function () { |
| this.out.writeBytes(this.colorTab); |
| var n = 3 * 256 - this.colorTab.length; |
| for (var i = 0; i < n; i++) this.out.writeByte(0); |
| }; |
| GIFEncoder.prototype.writeShort = function (pValue) { |
| this.out.writeByte(pValue & 255); |
| this.out.writeByte((pValue >> 8) & 255); |
| }; |
| GIFEncoder.prototype.writePixels = function () { |
| var enc = new LZWEncoder( |
| this.width, |
| this.height, |
| this.indexedPixels, |
| this.colorDepth |
| ); |
| enc.encode(this.out); |
| }; |
| GIFEncoder.prototype.stream = function () { |
| return this.out; |
| }; |
| module.exports = GIFEncoder; |
| }, |
| { |
| './LZWEncoder.js': 2, |
| './TypedNeuQuant.js': 3, |
| }, |
| ], |
| 2: [ |
| function (require, module, exports) { |
| var EOF = -1; |
| var BITS = 12; |
| var HSIZE = 5003; |
| var masks = [ |
| 0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383, |
| 32767, 65535, |
| ]; |
| |
| function LZWEncoder(width, height, pixels, colorDepth) { |
| var initCodeSize = Math.max(2, colorDepth); |
| var accum = new Uint8Array(256); |
| var htab = new Int32Array(HSIZE); |
| var codetab = new Int32Array(HSIZE); |
| var cur_accum, |
| cur_bits = 0; |
| var a_count; |
| var free_ent = 0; |
| var maxcode; |
| var clear_flg = false; |
| var g_init_bits, ClearCode, EOFCode; |
| |
| function char_out(c, outs) { |
| accum[a_count++] = c; |
| if (a_count >= 254) flush_char(outs); |
| } |
| |
| function cl_block(outs) { |
| cl_hash(HSIZE); |
| free_ent = ClearCode + 2; |
| clear_flg = true; |
| output(ClearCode, outs); |
| } |
| |
| function cl_hash(hsize) { |
| for (var i = 0; i < hsize; ++i) htab[i] = -1; |
| } |
| |
| function compress(init_bits, outs) { |
| var fcode, c, i, ent, disp, hsize_reg, hshift; |
| g_init_bits = init_bits; |
| clear_flg = false; |
| n_bits = g_init_bits; |
| maxcode = MAXCODE(n_bits); |
| ClearCode = 1 << (init_bits - 1); |
| EOFCode = ClearCode + 1; |
| free_ent = ClearCode + 2; |
| a_count = 0; |
| ent = nextPixel(); |
| hshift = 0; |
| for (fcode = HSIZE; fcode < 65536; fcode *= 2) ++hshift; |
| hshift = 8 - hshift; |
| hsize_reg = HSIZE; |
| cl_hash(hsize_reg); |
| output(ClearCode, outs); |
| outer_loop: while ((c = nextPixel()) != EOF) { |
| fcode = (c << BITS) + ent; |
| i = (c << hshift) ^ ent; |
| if (htab[i] === fcode) { |
| ent = codetab[i]; |
| continue; |
| } else if (htab[i] >= 0) { |
| disp = hsize_reg - i; |
| if (i === 0) disp = 1; |
| do { |
| if ((i -= disp) < 0) i += hsize_reg; |
| if (htab[i] === fcode) { |
| ent = codetab[i]; |
| continue outer_loop; |
| } |
| } while (htab[i] >= 0); |
| } |
| output(ent, outs); |
| ent = c; |
| if (free_ent < 1 << BITS) { |
| codetab[i] = free_ent++; |
| htab[i] = fcode; |
| } else { |
| cl_block(outs); |
| } |
| } |
| output(ent, outs); |
| output(EOFCode, outs); |
| } |
| |
| function encode(outs) { |
| outs.writeByte(initCodeSize); |
| remaining = width * height; |
| curPixel = 0; |
| compress(initCodeSize + 1, outs); |
| outs.writeByte(0); |
| } |
| |
| function flush_char(outs) { |
| if (a_count > 0) { |
| outs.writeByte(a_count); |
| outs.writeBytes(accum, 0, a_count); |
| a_count = 0; |
| } |
| } |
| |
| function MAXCODE(n_bits) { |
| return (1 << n_bits) - 1; |
| } |
| |
| function nextPixel() { |
| if (remaining === 0) return EOF; |
| --remaining; |
| var pix = pixels[curPixel++]; |
| return pix & 255; |
| } |
| |
| function output(code, outs) { |
| cur_accum &= masks[cur_bits]; |
| if (cur_bits > 0) cur_accum |= code << cur_bits; |
| else cur_accum = code; |
| cur_bits += n_bits; |
| while (cur_bits >= 8) { |
| char_out(cur_accum & 255, outs); |
| cur_accum >>= 8; |
| cur_bits -= 8; |
| } |
| if (free_ent > maxcode || clear_flg) { |
| if (clear_flg) { |
| maxcode = MAXCODE((n_bits = g_init_bits)); |
| clear_flg = false; |
| } else { |
| ++n_bits; |
| if (n_bits == BITS) maxcode = 1 << BITS; |
| else maxcode = MAXCODE(n_bits); |
| } |
| } |
| if (code == EOFCode) { |
| while (cur_bits > 0) { |
| char_out(cur_accum & 255, outs); |
| cur_accum >>= 8; |
| cur_bits -= 8; |
| } |
| flush_char(outs); |
| } |
| } |
| this.encode = encode; |
| } |
| module.exports = LZWEncoder; |
| }, |
| {}, |
| ], |
| 3: [ |
| function (require, module, exports) { |
| var ncycles = 100; |
| var netsize = 256; |
| var maxnetpos = netsize - 1; |
| var netbiasshift = 4; |
| var intbiasshift = 16; |
| var intbias = 1 << intbiasshift; |
| var gammashift = 10; |
| var gamma = 1 << gammashift; |
| var betashift = 10; |
| var beta = intbias >> betashift; |
| var betagamma = intbias << (gammashift - betashift); |
| var initrad = netsize >> 3; |
| var radiusbiasshift = 6; |
| var radiusbias = 1 << radiusbiasshift; |
| var initradius = initrad * radiusbias; |
| var radiusdec = 30; |
| var alphabiasshift = 10; |
| var initalpha = 1 << alphabiasshift; |
| var alphadec; |
| var radbiasshift = 8; |
| var radbias = 1 << radbiasshift; |
| var alpharadbshift = alphabiasshift + radbiasshift; |
| var alpharadbias = 1 << alpharadbshift; |
| var prime1 = 499; |
| var prime2 = 491; |
| var prime3 = 487; |
| var prime4 = 503; |
| var minpicturebytes = 3 * prime4; |
| |
| function NeuQuant(pixels, samplefac) { |
| var network; |
| var netindex; |
| var bias; |
| var freq; |
| var radpower; |
| |
| function init() { |
| network = []; |
| netindex = new Int32Array(256); |
| bias = new Int32Array(netsize); |
| freq = new Int32Array(netsize); |
| radpower = new Int32Array(netsize >> 3); |
| var i, v; |
| for (i = 0; i < netsize; i++) { |
| v = (i << (netbiasshift + 8)) / netsize; |
| network[i] = new Float64Array([v, v, v, 0]); |
| freq[i] = intbias / netsize; |
| bias[i] = 0; |
| } |
| } |
| |
| function unbiasnet() { |
| for (var i = 0; i < netsize; i++) { |
| network[i][0] >>= netbiasshift; |
| network[i][1] >>= netbiasshift; |
| network[i][2] >>= netbiasshift; |
| network[i][3] = i; |
| } |
| } |
| |
| function altersingle(alpha, i, b, g, r) { |
| network[i][0] -= (alpha * (network[i][0] - b)) / initalpha; |
| network[i][1] -= (alpha * (network[i][1] - g)) / initalpha; |
| network[i][2] -= (alpha * (network[i][2] - r)) / initalpha; |
| } |
| |
| function alterneigh(radius, i, b, g, r) { |
| var lo = Math.abs(i - radius); |
| var hi = Math.min(i + radius, netsize); |
| var j = i + 1; |
| var k = i - 1; |
| var m = 1; |
| var p, a; |
| while (j < hi || k > lo) { |
| a = radpower[m++]; |
| if (j < hi) { |
| p = network[j++]; |
| p[0] -= (a * (p[0] - b)) / alpharadbias; |
| p[1] -= (a * (p[1] - g)) / alpharadbias; |
| p[2] -= (a * (p[2] - r)) / alpharadbias; |
| } |
| if (k > lo) { |
| p = network[k--]; |
| p[0] -= (a * (p[0] - b)) / alpharadbias; |
| p[1] -= (a * (p[1] - g)) / alpharadbias; |
| p[2] -= (a * (p[2] - r)) / alpharadbias; |
| } |
| } |
| } |
| |
| function contest(b, g, r) { |
| var bestd = ~(1 << 31); |
| var bestbiasd = bestd; |
| var bestpos = -1; |
| var bestbiaspos = bestpos; |
| var i, n, dist, biasdist, betafreq; |
| for (i = 0; i < netsize; i++) { |
| n = network[i]; |
| dist = |
| Math.abs(n[0] - b) + Math.abs(n[1] - g) + Math.abs(n[2] - r); |
| if (dist < bestd) { |
| bestd = dist; |
| bestpos = i; |
| } |
| biasdist = dist - (bias[i] >> (intbiasshift - netbiasshift)); |
| if (biasdist < bestbiasd) { |
| bestbiasd = biasdist; |
| bestbiaspos = i; |
| } |
| betafreq = freq[i] >> betashift; |
| freq[i] -= betafreq; |
| bias[i] += betafreq << gammashift; |
| } |
| freq[bestpos] += beta; |
| bias[bestpos] -= betagamma; |
| return bestbiaspos; |
| } |
| |
| function inxbuild() { |
| var i, |
| j, |
| p, |
| q, |
| smallpos, |
| smallval, |
| previouscol = 0, |
| startpos = 0; |
| for (i = 0; i < netsize; i++) { |
| p = network[i]; |
| smallpos = i; |
| smallval = p[1]; |
| for (j = i + 1; j < netsize; j++) { |
| q = network[j]; |
| if (q[1] < smallval) { |
| smallpos = j; |
| smallval = q[1]; |
| } |
| } |
| q = network[smallpos]; |
| if (i != smallpos) { |
| j = q[0]; |
| q[0] = p[0]; |
| p[0] = j; |
| j = q[1]; |
| q[1] = p[1]; |
| p[1] = j; |
| j = q[2]; |
| q[2] = p[2]; |
| p[2] = j; |
| j = q[3]; |
| q[3] = p[3]; |
| p[3] = j; |
| } |
| if (smallval != previouscol) { |
| netindex[previouscol] = (startpos + i) >> 1; |
| for (j = previouscol + 1; j < smallval; j++) netindex[j] = i; |
| previouscol = smallval; |
| startpos = i; |
| } |
| } |
| netindex[previouscol] = (startpos + maxnetpos) >> 1; |
| for (j = previouscol + 1; j < 256; j++) netindex[j] = maxnetpos; |
| } |
| |
| function inxsearch(b, g, r) { |
| var a, p, dist; |
| var bestd = 1e3; |
| var best = -1; |
| var i = netindex[g]; |
| var j = i - 1; |
| while (i < netsize || j >= 0) { |
| if (i < netsize) { |
| p = network[i]; |
| dist = p[1] - g; |
| if (dist >= bestd) i = netsize; |
| else { |
| i++; |
| if (dist < 0) dist = -dist; |
| a = p[0] - b; |
| if (a < 0) a = -a; |
| dist += a; |
| if (dist < bestd) { |
| a = p[2] - r; |
| if (a < 0) a = -a; |
| dist += a; |
| if (dist < bestd) { |
| bestd = dist; |
| best = p[3]; |
| } |
| } |
| } |
| } |
| if (j >= 0) { |
| p = network[j]; |
| dist = g - p[1]; |
| if (dist >= bestd) j = -1; |
| else { |
| j--; |
| if (dist < 0) dist = -dist; |
| a = p[0] - b; |
| if (a < 0) a = -a; |
| dist += a; |
| if (dist < bestd) { |
| a = p[2] - r; |
| if (a < 0) a = -a; |
| dist += a; |
| if (dist < bestd) { |
| bestd = dist; |
| best = p[3]; |
| } |
| } |
| } |
| } |
| } |
| return best; |
| } |
| |
| function learn() { |
| var i; |
| var lengthcount = pixels.length; |
| var alphadec = 30 + (samplefac - 1) / 3; |
| var samplepixels = lengthcount / (3 * samplefac); |
| var delta = ~~(samplepixels / ncycles); |
| var alpha = initalpha; |
| var radius = initradius; |
| var rad = radius >> radiusbiasshift; |
| if (rad <= 1) rad = 0; |
| for (i = 0; i < rad; i++) |
| radpower[i] = |
| alpha * (((rad * rad - i * i) * radbias) / (rad * rad)); |
| var step; |
| if (lengthcount < minpicturebytes) { |
| samplefac = 1; |
| step = 3; |
| } else if (lengthcount % prime1 !== 0) { |
| step = 3 * prime1; |
| } else if (lengthcount % prime2 !== 0) { |
| step = 3 * prime2; |
| } else if (lengthcount % prime3 !== 0) { |
| step = 3 * prime3; |
| } else { |
| step = 3 * prime4; |
| } |
| var b, g, r, j; |
| var pix = 0; |
| i = 0; |
| while (i < samplepixels) { |
| b = (pixels[pix] & 255) << netbiasshift; |
| g = (pixels[pix + 1] & 255) << netbiasshift; |
| r = (pixels[pix + 2] & 255) << netbiasshift; |
| j = contest(b, g, r); |
| altersingle(alpha, j, b, g, r); |
| if (rad !== 0) alterneigh(rad, j, b, g, r); |
| pix += step; |
| if (pix >= lengthcount) pix -= lengthcount; |
| i++; |
| if (delta === 0) delta = 1; |
| if (i % delta === 0) { |
| alpha -= alpha / alphadec; |
| radius -= radius / radiusdec; |
| rad = radius >> radiusbiasshift; |
| if (rad <= 1) rad = 0; |
| for (j = 0; j < rad; j++) |
| radpower[j] = |
| alpha * (((rad * rad - j * j) * radbias) / (rad * rad)); |
| } |
| } |
| } |
| |
| function buildColormap() { |
| init(); |
| learn(); |
| unbiasnet(); |
| inxbuild(); |
| } |
| this.buildColormap = buildColormap; |
| |
| function getColormap() { |
| var map = []; |
| var index = []; |
| for (var i = 0; i < netsize; i++) index[network[i][3]] = i; |
| var k = 0; |
| for (var l = 0; l < netsize; l++) { |
| var j = index[l]; |
| map[k++] = network[j][0]; |
| map[k++] = network[j][1]; |
| map[k++] = network[j][2]; |
| } |
| return map; |
| } |
| this.getColormap = getColormap; |
| this.lookupRGB = inxsearch; |
| } |
| module.exports = NeuQuant; |
| }, |
| {}, |
| ], |
| 4: [ |
| function (require, module, exports) { |
| var GIFEncoder, renderFrame; |
| GIFEncoder = require('./GIFEncoder.js'); |
| renderFrame = function (frame) { |
| var encoder, page, stream, transfer; |
| encoder = new GIFEncoder(frame.width, frame.height); |
| if (frame.index === 0) { |
| encoder.writeHeader(); |
| } else { |
| encoder.firstFrame = false; |
| } |
| encoder.setTransparent(frame.transparent); |
| encoder.setRepeat(frame.repeat); |
| encoder.setDelay(frame.delay); |
| encoder.setQuality(frame.quality); |
| encoder.setDither(frame.dither); |
| encoder.setGlobalPalette(frame.globalPalette); |
| encoder.addFrame(frame.data); |
| if (frame.last) { |
| encoder.finish(); |
| } |
| if (frame.globalPalette === true) { |
| frame.globalPalette = encoder.getGlobalPalette(); |
| } |
| stream = encoder.stream(); |
| frame.data = stream.pages; |
| frame.cursor = stream.cursor; |
| frame.pageSize = stream.constructor.pageSize; |
| if (frame.canTransfer) { |
| transfer = (function () { |
| var i, len, ref, results; |
| ref = frame.data; |
| results = []; |
| for (i = 0, len = ref.length; i < len; i++) { |
| page = ref[i]; |
| results.push(page.buffer); |
| } |
| return results; |
| })(); |
| return self.postMessage(frame, transfer); |
| } else { |
| return self.postMessage(frame); |
| } |
| }; |
| self.onmessage = function (event) { |
| return renderFrame(event.data); |
| }; |
| }, |
| { |
| './GIFEncoder.js': 1, |
| }, |
| ], |
| }, |
| {}, |
| [4] |
| ); |
| //# sourceMappingURL=gif.worker.js.map |
