| /* 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 |
