@aibee/owlly 1.0.25

package/src/owlly/element/gif-kit/GifFrame.ts

@@ -0,0 +1,207 @@
+/* eslint-disable */
+/*!
+ gifken
+ Copyright (c) 2013 aaharu
+ This software is released under the MIT License.
+ https://raw.github.com/aaharu/gifken/master/LICENSE
+
+ This product includes following software:
+ * jsgif
+ - Copyright (c) 2011 Shachaf Ben-Kiki
+ - https://github.com/shachaf/jsgif
+ - https://raw.github.com/shachaf/jsgif/master/LICENSE
+ */
+
+export class GifFrame {
+  public transparentFlag: boolean;
+  public delayCentiSeconds: number;
+  public transparentColorIndex: number;
+  public x: number;
+  public y: number;
+  public width: number;
+  public height: number;
+  public localTableSize: number;
+  public lzwCode: number;
+  public localColorTable: Uint8Array;
+  public compressedData: Uint8Array;
+  public pixelData: Uint8Array; // decompressed
+  public orgpixelData:any;
+
+  public pixels:Array<any>;
+
+  public static init(width: number, height: number): GifFrame {
+    const frame = new GifFrame();
+    frame.transparentFlag = false;
+    frame.delayCentiSeconds = 0;
+    frame.transparentColorIndex = 0;
+    frame.x = 0;
+    frame.y = 0;
+    frame.width = width || 1;
+    frame.height = height || 1;
+    frame.localTableSize = 0;
+    frame.lzwCode = 4; // ?
+    frame.pixelData = new Uint8Array(frame.width * frame.height);
+    return frame;
+  }
+
+  public decompress(): void {
+    // console.log('000000000000000',this.lzwCode,
+    // this.compressedData,
+    // this.width ,this.height);
+
+    // this.pixels = this.lzwDecode2(this.lzwCode,this.orgpixelData);
+    // console.log('this.pixels: ',this.width,this.height,this.pixels);
+    this.pixelData = this.lzwDecode(
+      this.lzwCode,
+      this.compressedData,
+      this.width * this.height
+    );
+
+
+  }
+
+  /*
+   ===begin jsgif===
+   */
+  private lzwDecode(
+    minCodeSize: number,
+    data: Uint8Array,
+    len: number
+  ): Uint8Array {
+    let pos = 0; // Maybe this streaming thing should be merged with the Stream?
+
+    const readCode = function (size: number): number {
+      let code = 0;
+      for (let i = 0; i < size; ++i) {
+        if (data[pos >> 3] & (1 << (pos & 7))) {
+          code |= 1 << i;
+        }
+        ++pos;
+      }
+      return code;
+    };
+
+    const output = new Uint8Array(len);
+
+    const clearCode = 1 << minCodeSize;
+    const eoiCode = clearCode + 1;
+
+    let codeSize = minCodeSize + 1;
+
+    let dict: number[][] = [];
+
+    const clear = (): void => {
+      dict = [];
+      codeSize = minCodeSize + 1;
+      for (let i = 0; i < clearCode; ++i) {
+        dict[i] = [i];
+      }
+      dict[clearCode] = [];
+    };
+
+    let code = 0;
+    let last: number;
+    let offset = 0;
+
+    while (true) {
+      last = code;
+      code = readCode(codeSize);
+
+      if (code === clearCode) {
+        clear();
+        continue;
+      }
+      if (code === eoiCode) break;
+
+      if (code < dict.length) {
+        if (last !== clearCode) {
+          dict.push(dict[last].concat(dict[code][0]));
+        }
+      } else {
+        if (code !== dict.length) throw new Error("Invalid LZW code.");
+        dict.push(dict[last].concat(dict[last][0]));
+      }
+      output.set(dict[code], offset);
+      offset += dict[code].length;
+
+      if (dict.length === 1 << codeSize && codeSize < 12) {
+        // 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.
+        codeSize++;
+      }
+    }
+
+    return output;
+  }
+  /*
+   ===end jsgif===
+   */
+  // private lzwDecode2(minCodeSize:number, data:any) {
+  //   // TODO: Now that the GIF parser is a bit different, maybe this should get an array of bytes instead of a String?
+  //   let pos = 0; // Maybe this streaming thing should be merged with the Stream?
+  //   let readCode = function (size:number) {
+  //       let code = 0;
+  //       for (let i = 0; i < size; i++) {
+  //           if (data.charCodeAt(pos >> 3) & (1 << (pos & 7))) {
+  //               code |= 1 << i;
+  //           }
+  //           pos++;
+  //       }
+  //       return code;
+  //   };
+
+  //   let output:Array<any> = [];
+
+  //   let clearCode = 1 << minCodeSize;
+  //   let eoiCode = clearCode + 1;
+
+  //   let codeSize = minCodeSize + 1;
+
+  //   let dict:Array<any> = [];
+
+  //   let clear = function () {
+  //       dict = [];
+  //       codeSize = minCodeSize + 1;
+  //       for (let i = 0; i < clearCode; i++) {
+  //           dict[i] = [i];
+  //       }
+  //       dict[clearCode] = [];
+  //       dict[eoiCode] = null;
+
+  //   };
+
+  //   let code:number;
+  //   let last:number;
+
+  //   code=0;
+
+  //   while (true) {
+  //       last = code;
+  //       code = readCode(codeSize);
+
+  //       if (code === clearCode) {
+  //           clear();
+  //           continue;
+  //       }
+  //       if (code === eoiCode) break;
+
+  //       if (code < dict.length) {
+  //           if (last !== clearCode) {
+  //               dict.push(dict[last].concat(dict[code][0]));
+  //           }
+  //       } else {
+  //           if (code !== dict.length) throw new Error('Invalid LZW code.');
+  //           dict.push(dict[last].concat(dict[last][0]));
+  //       }
+  //       output.push.apply(output, dict[code]);
+
+  //       if (dict.length === (1 << codeSize) && codeSize < 12) {
+  //           // 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.
+  //           codeSize++;
+  //       }
+  //   }
+
+  //   // I don't know if this is technically an error, but some GIFs do it.
+  //   //if (Math.ceil(pos / 8) !== data.length) throw new Error('Extraneous LZW bytes.');
+  //   return output;
+  // };
+}

package/src/owlly/element/gif-kit/GifImage.ts

@@ -0,0 +1,26 @@
+/* eslint-disable */
+/*!
+ gifken
+ Copyright (c) 2013 aaharu
+ This software is released under the MIT License.
+ https://raw.github.com/aaharu/gifken/master/LICENSE
+ */
+
+import { GifFrame } from './GifFrame';
+import { GifVersion } from './GifVersion';
+
+export interface GifImage {
+  colorResolution: number; // not supported
+  sortFlag: boolean; // not supported
+  bgColorIndex: number;
+  pixelAspectRatio: number; // not supported
+  frames: GifFrame[];
+  isLoop: boolean;
+  frameIndex1: number;
+  frameIndex2: number;
+  version: GifVersion;
+  width: number;
+  height: number;
+  globalColorTable: Uint8Array;
+  loopCount: number;
+}

package/src/owlly/element/gif-kit/GifParser.ts

@@ -0,0 +1,254 @@
+/* eslint-disable */
+/*!
+ gifken
+ Copyright (c) 2013 aaharu
+ This software is released under the MIT License.
+ https://raw.github.com/aaharu/gifken/master/LICENSE
+ */
+
+import { GifImage } from './GifImage';
+import { GifFrame } from './GifFrame';
+import { GifVersion } from './GifVersion';
+
+export class GifParser {
+  public static readHeader(gif: GifImage, data: DataView): number {
+    const version = String.fromCharCode(
+      data.getUint8(0),
+      data.getUint8(1),
+      data.getUint8(2),
+      data.getUint8(3),
+      data.getUint8(4),
+      data.getUint8(5)
+    );
+    if (version == GifVersion.GIF87a) {
+      gif.version = GifVersion.GIF87a;
+    } else {
+      gif.version = GifVersion.GIF89a;
+    }
+    gif.width = data.getUint16(6, true);
+    gif.height = data.getUint16(8, true);
+    const packed = data.getUint8(10);
+    // Global Color Table Flag(1 bit) Color Resolution(3 bits) Sort Flag(1 bit) Size of Global Color Table(3 bits)
+    const tableFlag = packed & 128;
+    let tableSize;
+    if (tableFlag !== 128) {
+      tableSize = 0;
+    } else {
+      tableSize = 1 << ((packed & 7) + 1);
+    }
+    gif.colorResolution = packed & 112;
+    gif.sortFlag = (packed & 8) === 8;
+    gif.bgColorIndex = data.getUint8(11);
+    gif.pixelAspectRatio = data.getUint8(12);
+    if (tableFlag !== 128) {
+      return 13;
+    }
+    gif.globalColorTable = new Uint8Array(data.buffer, 13, 3 * tableSize);
+    return 13 + 3 * tableSize;
+  }
+
+  public static readBlock(
+    gif: GifImage,
+    data: DataView,
+    offset: number
+  ): number {
+    const separator = data.getUint8(offset);
+    if (separator === 0x3b) {
+      return -1;
+    }
+    if (separator === 0x21) {
+      let frame: GifFrame;
+      // Extension block
+      const label = data.getUint8(offset + 1);
+      if (label === 0xf9) {
+        if (gif.frames[gif.frameIndex1] === undefined) {
+          frame = new GifFrame();
+          offset = this.readGraphicControlExtensionBlock(frame, data, offset);
+          gif.frames.push(frame);
+        } else {
+          frame = gif.frames[gif.frameIndex1];
+          offset = this.readGraphicControlExtensionBlock(frame, data, offset);
+        }
+        gif.frameIndex1 += 1;
+        return offset;
+      }
+      if (label === 0xfe) {
+        offset = this.readCommentExtensionBlock(data, offset);
+        return offset;
+      }
+      if (label === 0xff) {
+        offset = this.readApplicationExtensionBlock(gif, data, offset);
+        return offset;
+      }
+      if (label === 0x01) {
+        offset = this.readPlainTextExtensionBlock(data, offset);
+        return offset;
+      }
+    }
+    if (separator === 0x2c) {
+      let frame: GifFrame;
+      if (gif.frames[gif.frameIndex2] === undefined) {
+        frame = new GifFrame();
+        offset = this.readImageBlock(frame, data, offset);
+        gif.frames.push(frame);
+      } else {
+        frame = gif.frames[gif.frameIndex2];
+        offset = this.readImageBlock(frame, data, offset);
+      }
+      gif.frameIndex2 += 1;
+      return offset;
+    }
+
+    return -1;
+  }
+
+  public static readImageBlock(
+    frame: GifFrame,
+    data: DataView,
+    offset: number
+  ): number {
+    frame.x = data.getUint16(++offset, true);
+    offset += 2;
+    frame.y = data.getUint16(offset, true);
+    offset += 2;
+    frame.width = data.getUint16(offset, true);
+    offset += 2;
+    frame.height = data.getUint16(offset, true);
+    offset += 2;
+    const packed = data.getUint8(offset++);
+    const tableFlag = packed & 128;
+    if (tableFlag === 128) {
+      frame.localTableSize = 1 << ((packed & 7) + 1);
+      frame.localColorTable = new Uint8Array(
+        data.buffer,
+        offset,
+        3 * frame.localTableSize
+      );
+      offset += 3 * frame.localTableSize;
+    } else {
+      frame.localTableSize = 0;
+    }
+    frame.lzwCode = data.getUint8(offset++);
+
+
+    const dataList = new Array<Uint8Array>();
+    // let datastr = '';
+    let totalSize = 0;
+    while (true) {
+      const blockSize = data.getUint8(offset++);
+      totalSize += blockSize;
+      if (blockSize === 0) {
+        break;
+      }
+      // let s = '';
+      // let position2 = offset;
+      // for (let i = 0; i < blockSize; i++) {
+      //     s += String.fromCharCode(data.getUint8(position2++));
+      // }
+      // datastr = datastr + s;
+
+      dataList.push(
+        new Uint8Array(data.buffer.slice(offset, offset + blockSize))
+      );
+
+      offset += blockSize;
+    }
+
+    // frame.orgpixelData = datastr;
+
+    const bytes = new Uint8Array(totalSize);
+    bytes.set(dataList[0], 0);
+    let len = dataList[0].byteLength;
+    for (let i = 1, l = dataList.length; i < l; ++i) {
+      bytes.set(dataList[i], len);
+      len += dataList[i].byteLength;
+    }
+    frame.compressedData = bytes;
+    return offset;
+  }
+
+  public static readApplicationExtensionBlock(
+    gif: GifImage,
+    data: DataView,
+    offset: number
+  ): number {
+    offset += 2;
+    if (data.getUint8(offset++) !== 0x0b) {
+      throw new Error('faild: _readApplicationExtensionBlock');
+    }
+    const app = String.fromCharCode(
+      data.getUint8(offset++),
+      data.getUint8(offset++),
+      data.getUint8(offset++),
+      data.getUint8(offset++),
+      data.getUint8(offset++),
+      data.getUint8(offset++),
+      data.getUint8(offset++),
+      data.getUint8(offset++),
+      data.getUint8(offset++),
+      data.getUint8(offset++),
+      data.getUint8(offset++)
+    );
+    if (app === 'NETSCAPE2.0') {
+      gif.isLoop = true;
+      if (data.getUint8(offset++) !== 3) {
+        throw new Error('faild: _readApplicationExtensionBlock (NETSCAPE2.0)');
+      }
+      ++offset;
+      gif.loopCount = data.getUint16(offset, true);
+      offset += 2;
+    }
+    while (true) {
+      const blockSize = data.getUint8(offset++);
+      if (blockSize === 0) {
+        break;
+      }
+      offset += blockSize;
+    }
+    return offset;
+  }
+
+  public static readCommentExtensionBlock(
+    data: DataView,
+    offset: number
+  ): number {
+    // skip
+    offset += 2;
+    while (true) {
+      const blockSize = data.getUint8(offset++);
+      if (blockSize === 0) {
+        break;
+      }
+      offset += blockSize;
+    }
+    return offset;
+  }
+
+  public static readGraphicControlExtensionBlock(
+    frame: GifFrame,
+    data: DataView,
+    offset: number
+  ): number {
+    const packed = data.getUint8(offset + 3);
+    frame.transparentFlag = (packed & 1) === 1;
+    frame.delayCentiSeconds = data.getUint16(offset + 4, true);
+    frame.transparentColorIndex = data.getUint8(offset + 6);
+    return offset + 8;
+  }
+
+  public static readPlainTextExtensionBlock(
+    data: DataView,
+    offset: number
+  ): number {
+    // skip
+    offset += 2;
+    while (true) {
+      const blockSize = data.getUint8(offset++);
+      if (blockSize === 0) {
+        break;
+      }
+      offset += blockSize;
+    }
+    return offset;
+  }
+}

package/src/owlly/element/gif-kit/GifPresenter.ts

@@ -0,0 +1,46 @@
+/* eslint-disable */
+/*!
+ gifken
+ Copyright (c) 2013 aaharu
+ This software is released under the MIT License.
+ https://raw.github.com/aaharu/gifken/master/LICENSE
+ */
+
+// @ts-ignore
+// import { isBrowser, isWebWorker } from "browser-or-node";
+
+export class GifPresenter {
+  /**
+   * Convert Gif to Blob.
+   *
+   * @return {Blob} BLOB
+   */
+  public static writeToBlob(bytes: Uint8Array[]): Blob {
+    // if (isBrowser || isWebWorker || typeof Blob === "function") {
+    if (typeof Blob === "function") {
+      return new Blob(bytes, { type: "image/gif" });
+    }
+    throw new Error("writeToBlob is browser-only function");
+  }
+
+  /**
+   * Convert Gif to Data-URL string.
+   *
+   * @return {string} Data-URL string
+   */
+  public static writeToDataUrl(bytes: Uint8Array[]): string {
+    // if (isBrowser || isWebWorker) {
+      let str = "";
+      bytes.forEach((buffer): void => {
+        const codes: number[] = [];
+        for (let i = 0, l = buffer.byteLength; i < l; ++i) {
+          codes.push(buffer[i]);
+        }
+        str += String.fromCharCode.apply(null, codes);
+      });
+      return "data:image/gif;base64," + btoa(str);
+//     }
+//     const bytes2 = bytes.toString();
+//    return "data:image/gif;base64," + Buffer.from(bytes2).toString("base64");
+  }
+}

package/src/owlly/element/gif-kit/GifVersion.ts

@@ -0,0 +1,12 @@
+/* eslint-disable */
+/*!
+ gifken
+ Copyright (c) 2013 aaharu
+ This software is released under the MIT License.
+ https://raw.github.com/aaharu/gifken/master/LICENSE
+ */
+
+export enum GifVersion {
+    GIF89a = 'GIF89a',
+    GIF87a = 'GIF87a',
+  }