|
| 1 | +// Generic functions |
| 2 | +/* eslint-disable */ |
| 3 | +var bitsToNum = function (ba) { |
| 4 | + return ba.reduce(function (s, n) { |
| 5 | + return s * 2 + n |
| 6 | + }, 0) |
| 7 | +} |
| 8 | + |
| 9 | +var byteToBitArr = function (bite) { |
| 10 | + var a = [] |
| 11 | + for (var i = 7; i >= 0; i--) { |
| 12 | + a.push(!!(bite & (1 << i))) |
| 13 | + } |
| 14 | + return a |
| 15 | +} |
| 16 | + |
| 17 | +// Stream |
| 18 | +/** |
| 19 | + * @constructor |
| 20 | + */ // Make compiler happy. |
| 21 | +var Stream = function (data) { |
| 22 | + this.data = data |
| 23 | + this.len = this.data.length |
| 24 | + this.pos = 0 |
| 25 | + |
| 26 | + this.readByte = function () { |
| 27 | + if (this.pos >= this.data.length) { |
| 28 | + throw new Error('Attempted to read past end of stream.') |
| 29 | + } |
| 30 | + return data.charCodeAt(this.pos++) & 0xff |
| 31 | + } |
| 32 | + |
| 33 | + this.readBytes = function (n) { |
| 34 | + var bytes = [] |
| 35 | + for (var i = 0; i < n; i++) { |
| 36 | + bytes.push(this.readByte()) |
| 37 | + } |
| 38 | + return bytes |
| 39 | + } |
| 40 | + |
| 41 | + this.read = function (n) { |
| 42 | + var s = '' |
| 43 | + for (var i = 0; i < n; i++) { |
| 44 | + s += String.fromCharCode(this.readByte()) |
| 45 | + } |
| 46 | + return s |
| 47 | + } |
| 48 | + |
| 49 | + this.readUnsigned = function () { |
| 50 | + // Little-endian. |
| 51 | + var a = this.readBytes(2) |
| 52 | + return (a[1] << 8) + a[0] |
| 53 | + } |
| 54 | +} |
| 55 | + |
| 56 | +var lzwDecode = function (minCodeSize, data) { |
| 57 | + // TODO: Now that the GIF parser is a bit different, maybe this should get an array of bytes instead of a String? |
| 58 | + var pos = 0 // Maybe this streaming thing should be merged with the Stream? |
| 59 | + |
| 60 | + var readCode = function (size) { |
| 61 | + var code = 0 |
| 62 | + for (var i = 0; i < size; i++) { |
| 63 | + if (data.charCodeAt(pos >> 3) & (1 << (pos & 7))) { |
| 64 | + code |= 1 << i |
| 65 | + } |
| 66 | + pos++ |
| 67 | + } |
| 68 | + return code |
| 69 | + } |
| 70 | + |
| 71 | + var output = [] |
| 72 | + |
| 73 | + var clearCode = 1 << minCodeSize |
| 74 | + var eoiCode = clearCode + 1 |
| 75 | + |
| 76 | + var codeSize = minCodeSize + 1 |
| 77 | + |
| 78 | + var dict = [] |
| 79 | + |
| 80 | + var clear = function () { |
| 81 | + dict = [] |
| 82 | + codeSize = minCodeSize + 1 |
| 83 | + for (var i = 0; i < clearCode; i++) { |
| 84 | + dict[i] = [i] |
| 85 | + } |
| 86 | + dict[clearCode] = [] |
| 87 | + dict[eoiCode] = null |
| 88 | + } |
| 89 | + |
| 90 | + var code |
| 91 | + var last |
| 92 | + |
| 93 | + while (true) { |
| 94 | + last = code |
| 95 | + code = readCode(codeSize) |
| 96 | + |
| 97 | + if (code === clearCode) { |
| 98 | + clear() |
| 99 | + continue |
| 100 | + } |
| 101 | + if (code === eoiCode) break |
| 102 | + |
| 103 | + if (code < dict.length) { |
| 104 | + if (last !== clearCode) { |
| 105 | + dict.push(dict[last].concat(dict[code][0])) |
| 106 | + } |
| 107 | + } else { |
| 108 | + if (code !== dict.length) throw new Error('Invalid LZW code.') |
| 109 | + dict.push(dict[last].concat(dict[last][0])) |
| 110 | + } |
| 111 | + output.push.apply(output, dict[code]) |
| 112 | + |
| 113 | + if (dict.length === 1 << codeSize && codeSize < 12) { |
| 114 | + // If we're at the last code and codeSize is 12, the next code will be a clearCode, and it'll be 12 bits long. |
| 115 | + codeSize++ |
| 116 | + } |
| 117 | + } |
| 118 | + |
| 119 | + // I don't know if this is technically an error, but some GIFs do it. |
| 120 | + //if (Math.ceil(pos / 8) !== data.length) throw new Error('Extraneous LZW bytes.'); |
| 121 | + return output |
| 122 | +} |
| 123 | + |
| 124 | +// The actual parsing; returns an object with properties. |
| 125 | +var parseGIF = function (st, handler) { |
| 126 | + handler || (handler = {}) |
| 127 | + |
| 128 | + // LZW (GIF-specific) |
| 129 | + var parseCT = function (entries) { |
| 130 | + // Each entry is 3 bytes, for RGB. |
| 131 | + var ct = [] |
| 132 | + for (var i = 0; i < entries; i++) { |
| 133 | + ct.push(st.readBytes(3)) |
| 134 | + } |
| 135 | + return ct |
| 136 | + } |
| 137 | + |
| 138 | + var readSubBlocks = function () { |
| 139 | + var size, data |
| 140 | + data = '' |
| 141 | + do { |
| 142 | + size = st.readByte() |
| 143 | + data += st.read(size) |
| 144 | + } while (size !== 0) |
| 145 | + return data |
| 146 | + } |
| 147 | + |
| 148 | + var parseHeader = function () { |
| 149 | + var hdr = {} |
| 150 | + hdr.sig = st.read(3) |
| 151 | + hdr.ver = st.read(3) |
| 152 | + if (hdr.sig !== 'GIF') throw new Error('Not a GIF file.') // XXX: This should probably be handled more nicely. |
| 153 | + |
| 154 | + hdr.width = st.readUnsigned() |
| 155 | + hdr.height = st.readUnsigned() |
| 156 | + |
| 157 | + var bits = byteToBitArr(st.readByte()) |
| 158 | + hdr.gctFlag = bits.shift() |
| 159 | + hdr.colorRes = bitsToNum(bits.splice(0, 3)) |
| 160 | + hdr.sorted = bits.shift() |
| 161 | + hdr.gctSize = bitsToNum(bits.splice(0, 3)) |
| 162 | + |
| 163 | + hdr.bgColor = st.readByte() |
| 164 | + hdr.pixelAspectRatio = st.readByte() // if not 0, aspectRatio = (pixelAspectRatio + 15) / 64 |
| 165 | + |
| 166 | + if (hdr.gctFlag) { |
| 167 | + hdr.gct = parseCT(1 << (hdr.gctSize + 1)) |
| 168 | + } |
| 169 | + handler.hdr && handler.hdr(hdr) |
| 170 | + } |
| 171 | + |
| 172 | + var parseExt = function (block) { |
| 173 | + var parseGCExt = function (block) { |
| 174 | + var blockSize = st.readByte() // Always 4 |
| 175 | + |
| 176 | + var bits = byteToBitArr(st.readByte()) |
| 177 | + block.reserved = bits.splice(0, 3) // Reserved; should be 000. |
| 178 | + block.disposalMethod = bitsToNum(bits.splice(0, 3)) |
| 179 | + block.userInput = bits.shift() |
| 180 | + block.transparencyGiven = bits.shift() |
| 181 | + |
| 182 | + block.delayTime = st.readUnsigned() |
| 183 | + |
| 184 | + block.transparencyIndex = st.readByte() |
| 185 | + |
| 186 | + block.terminator = st.readByte() |
| 187 | + |
| 188 | + handler.gce && handler.gce(block) |
| 189 | + } |
| 190 | + |
| 191 | + var parseComExt = function (block) { |
| 192 | + block.comment = readSubBlocks() |
| 193 | + handler.com && handler.com(block) |
| 194 | + } |
| 195 | + |
| 196 | + var parsePTExt = function (block) { |
| 197 | + // No one *ever* uses this. If you use it, deal with parsing it yourself. |
| 198 | + var blockSize = st.readByte() // Always 12 |
| 199 | + block.ptHeader = st.readBytes(12) |
| 200 | + block.ptData = readSubBlocks() |
| 201 | + handler.pte && handler.pte(block) |
| 202 | + } |
| 203 | + |
| 204 | + var parseAppExt = function (block) { |
| 205 | + var parseNetscapeExt = function (block) { |
| 206 | + var blockSize = st.readByte() // Always 3 |
| 207 | + block.unknown = st.readByte() // ??? Always 1? What is this? |
| 208 | + block.iterations = st.readUnsigned() |
| 209 | + block.terminator = st.readByte() |
| 210 | + handler.app && handler.app.NETSCAPE && handler.app.NETSCAPE(block) |
| 211 | + } |
| 212 | + |
| 213 | + var parseUnknownAppExt = function (block) { |
| 214 | + block.appData = readSubBlocks() |
| 215 | + // FIXME: This won't work if a handler wants to match on any identifier. |
| 216 | + handler.app && |
| 217 | + handler.app[block.identifier] && |
| 218 | + handler.app[block.identifier](block) |
| 219 | + } |
| 220 | + |
| 221 | + var blockSize = st.readByte() // Always 11 |
| 222 | + block.identifier = st.read(8) |
| 223 | + block.authCode = st.read(3) |
| 224 | + switch (block.identifier) { |
| 225 | + case 'NETSCAPE': |
| 226 | + parseNetscapeExt(block) |
| 227 | + break |
| 228 | + default: |
| 229 | + parseUnknownAppExt(block) |
| 230 | + break |
| 231 | + } |
| 232 | + } |
| 233 | + |
| 234 | + var parseUnknownExt = function (block) { |
| 235 | + block.data = readSubBlocks() |
| 236 | + handler.unknown && handler.unknown(block) |
| 237 | + } |
| 238 | + |
| 239 | + block.label = st.readByte() |
| 240 | + switch (block.label) { |
| 241 | + case 0xf9: |
| 242 | + block.extType = 'gce' |
| 243 | + parseGCExt(block) |
| 244 | + break |
| 245 | + case 0xfe: |
| 246 | + block.extType = 'com' |
| 247 | + parseComExt(block) |
| 248 | + break |
| 249 | + case 0x01: |
| 250 | + block.extType = 'pte' |
| 251 | + parsePTExt(block) |
| 252 | + break |
| 253 | + case 0xff: |
| 254 | + block.extType = 'app' |
| 255 | + parseAppExt(block) |
| 256 | + break |
| 257 | + default: |
| 258 | + block.extType = 'unknown' |
| 259 | + parseUnknownExt(block) |
| 260 | + break |
| 261 | + } |
| 262 | + } |
| 263 | + |
| 264 | + var parseImg = function (img) { |
| 265 | + var deinterlace = function (pixels, width) { |
| 266 | + // Of course this defeats the purpose of interlacing. And it's *probably* |
| 267 | + // the least efficient way it's ever been implemented. But nevertheless... |
| 268 | + |
| 269 | + var newPixels = new Array(pixels.length) |
| 270 | + var rows = pixels.length / width |
| 271 | + var cpRow = function (toRow, fromRow) { |
| 272 | + var fromPixels = pixels.slice(fromRow * width, (fromRow + 1) * width) |
| 273 | + newPixels.splice.apply( |
| 274 | + newPixels, |
| 275 | + [toRow * width, width].concat(fromPixels) |
| 276 | + ) |
| 277 | + } |
| 278 | + |
| 279 | + // See appendix E. |
| 280 | + var offsets = [0, 4, 2, 1] |
| 281 | + var steps = [8, 8, 4, 2] |
| 282 | + |
| 283 | + var fromRow = 0 |
| 284 | + for (var pass = 0; pass < 4; pass++) { |
| 285 | + for (var toRow = offsets[pass]; toRow < rows; toRow += steps[pass]) { |
| 286 | + cpRow(toRow, fromRow) |
| 287 | + fromRow++ |
| 288 | + } |
| 289 | + } |
| 290 | + |
| 291 | + return newPixels |
| 292 | + } |
| 293 | + |
| 294 | + img.leftPos = st.readUnsigned() |
| 295 | + img.topPos = st.readUnsigned() |
| 296 | + img.width = st.readUnsigned() |
| 297 | + img.height = st.readUnsigned() |
| 298 | + |
| 299 | + var bits = byteToBitArr(st.readByte()) |
| 300 | + img.lctFlag = bits.shift() |
| 301 | + img.interlaced = bits.shift() |
| 302 | + img.sorted = bits.shift() |
| 303 | + img.reserved = bits.splice(0, 2) |
| 304 | + img.lctSize = bitsToNum(bits.splice(0, 3)) |
| 305 | + |
| 306 | + if (img.lctFlag) { |
| 307 | + img.lct = parseCT(1 << (img.lctSize + 1)) |
| 308 | + } |
| 309 | + |
| 310 | + img.lzwMinCodeSize = st.readByte() |
| 311 | + |
| 312 | + var lzwData = readSubBlocks() |
| 313 | + |
| 314 | + img.pixels = lzwDecode(img.lzwMinCodeSize, lzwData) |
| 315 | + |
| 316 | + if (img.interlaced) { |
| 317 | + // Move |
| 318 | + img.pixels = deinterlace(img.pixels, img.width) |
| 319 | + } |
| 320 | + |
| 321 | + handler.img && handler.img(img) |
| 322 | + } |
| 323 | + |
| 324 | + var parseBlock = function () { |
| 325 | + var block = {} |
| 326 | + block.sentinel = st.readByte() |
| 327 | + |
| 328 | + switch ( |
| 329 | + String.fromCharCode(block.sentinel) // For ease of matching |
| 330 | + ) { |
| 331 | + case '!': |
| 332 | + block.type = 'ext' |
| 333 | + parseExt(block) |
| 334 | + break |
| 335 | + case ',': |
| 336 | + block.type = 'img' |
| 337 | + parseImg(block) |
| 338 | + break |
| 339 | + case ';': |
| 340 | + block.type = 'eof' |
| 341 | + handler.eof && handler.eof(block) |
| 342 | + break |
| 343 | + default: |
| 344 | + throw new Error('Unknown block: 0x' + block.sentinel.toString(16)) // TODO: Pad this with a 0. |
| 345 | + } |
| 346 | + |
| 347 | + if (block.type !== 'eof') setTimeout(parseBlock, 0) |
| 348 | + } |
| 349 | + |
| 350 | + var parse = function () { |
| 351 | + parseHeader() |
| 352 | + setTimeout(parseBlock, 0) |
| 353 | + } |
| 354 | + |
| 355 | + parse() |
| 356 | +} |
| 357 | + |
| 358 | +// BEGIN_NON_BOOKMARKLET_CODE |
| 359 | +if (typeof exports !== 'undefined') { |
| 360 | + exports.Stream = Stream |
| 361 | + exports.parseGIF = parseGIF |
| 362 | +} |
| 363 | +// export { parseGIF } |
| 364 | +// END_NON_BOOKMARKLET_CODE |
1 commit comments
vercel[bot] commentedon Aug 12, 2022
Successfully deployed to the following URLs:
dgiot-dashboard – ./
dgiot-dashboard.vercel.app
dgiot-dashboard-git-master-dgiot.vercel.app
dgiot-dashboard-dgiot.vercel.app