create-jsview 2.1.367-test.0 → 2.1.428

package/template-vue-vite/dist-test-jsview-chunk/js/GifData.e5dd9fac.js

@@ -0,0 +1,429 @@
+class LoopToolBase {
+  constructor() {
+    this.mFrameIndex = -1;
+    this.mTotalFrameNum = -1;
+    this.mNextFrameIndex = -1;
+    this.mValide = false;
+  }
+  getNextIndex(curIndex) {
+    return -1;
+  }
+  hasNext() {
+    return this.mNextFrameIndex != -1;
+  }
+  next() {
+    this.mFrameIndex = this.mNextFrameIndex;
+    this.mNextFrameIndex = this.getNextIndex(this.mFrameIndex);
+    return this.mFrameIndex;
+  }
+  setApicInfo(frameNum, loopNum) {
+    this.mTotalFrameNum = frameNum;
+    this.mLoopNum = loopNum;
+  }
+}
+const LoopType = {
+  LOOP_DEFAULT: 0,
+  LOOP_INFINITE: 1,
+  LOOP_FINITE: 2,
+  LOOP_PART: 3,
+  LOOP_SINGLE: 4
+};
+const ApicEndState = {
+  HIDE: 1,
+  LAST_FRAME: 2
+};
+class PartLoopTool extends LoopToolBase {
+  constructor(info_list) {
+    super();
+    this.mLoopPeriod = 0;
+    this.mCurLoopStartFrame = 0;
+    this.mCurLoopEndFrame = 0;
+    this.mCurLoopNum = 0;
+    this.mCurLoopCount = 0;
+    if (info_list == null) {
+      console.error("PartLoopTool info is null.");
+      return;
+    }
+    this.mLoopInfo = info_list;
+  }
+  getNextIndex(curIndex) {
+    if (!this.mValid) {
+      return -1;
+    }
+    let next_index = -1;
+    let loop_period_num = this.mLoopInfo.length;
+    if (this.mLoopPeriod < loop_period_num) {
+      if (curIndex < this.mCurLoopEndFrame) {
+        next_index = curIndex + 1;
+      } else {
+        if (this.mCurLoopNum <= 0) {
+          next_index = this.mCurLoopStartFrame;
+        } else {
+          this.mCurLoopCount++;
+          if (this.mCurLoopCount >= this.mCurLoopNum) {
+            this.mLoopPeriod++;
+            if (this.mLoopPeriod < loop_period_num) {
+              this.mValid = this.updateLoop();
+              if (this.mValid) {
+                this.mCurLoopCount = 0;
+                next_index = this.mCurLoopStartFrame;
+              }
+            }
+          } else {
+            next_index = this.mCurLoopStartFrame;
+          }
+        }
+      }
+    }
+    return next_index;
+  }
+  updateLoop() {
+    let loop = this.mLoopInfo[this.mLoopPeriod];
+    this.mCurLoopNum = loop[0];
+    this.mCurLoopStartFrame = loop[1];
+    this.mCurLoopEndFrame = loop[2];
+    if (isNaN(this.mCurLoopNum) || isNaN(this.mCurLoopStartFrame) || isNaN(this.mCurLoopEndFrame) || this.mCurLoopStartFrame >= this.mTotalFrameNum || this.mCurLoopEndFrame >= this.mTotalFrameNum || this.mCurLoopStartFrame >= this.mCurLoopEndFrame) {
+      console.error("data error, frame number out of size.", this.mLoopInfo);
+      return false;
+    } else {
+      return true;
+    }
+  }
+  setApicInfo(frameNum, loopNum) {
+    this.mTotalFrameNum = frameNum;
+    this.mValid = this.updateLoop();
+    if (!this.mValid) {
+      console.log("PartLoopTool init loop info error." + this.mLoopInfo.toString());
+    } else {
+      this.mNextFrameIndex = this.mCurLoopStartFrame;
+    }
+  }
+}
+class NormalLoopTool extends LoopToolBase {
+  constructor(loop_type, loop_num) {
+    super();
+    this.mLoopType = loop_type;
+    this.mLoopNum = loop_num;
+    this.mLoopCount = 0;
+  }
+  getNextIndex(curFrame) {
+    if (!this.mValid) {
+      return -1;
+    }
+    let next_index = -1;
+    switch (this.mLoopType) {
+      case LoopType.LOOP_DEFAULT:
+        if (this.mLoopNum <= 0) {
+          next_index = (curFrame + 1) % this.mTotalFrameNum;
+        } else {
+          if (curFrame == this.mTotalFrameNum - 1) {
+            this.mLoopCount++;
+          }
+          next_index = this.mLoopCount >= this.mLoopNum ? -1 : (curFrame + 1) % this.mTotalFrameNum;
+        }
+        break;
+      case LoopType.LOOP_INFINITE:
+        next_index = (curFrame + 1) % this.mTotalFrameNum;
+        break;
+      case LoopType.LOOP_FINITE:
+        if (curFrame == this.mTotalFrameNum - 1) {
+          this.mLoopCount++;
+        }
+        next_index = this.mLoopCount >= this.mLoopNum ? -1 : (curFrame + 1) % this.mTotalFrameNum;
+        break;
+    }
+    return next_index;
+  }
+  setApicInfo(frameNum, loopNum) {
+    this.mTotalFrameNum = frameNum;
+    this.mLoopNum = this.mLoopType == LoopType.LOOP_DEFAULT ? loopNum : this.mLoopNum;
+    this.mNextFrameIndex = 0;
+    this.mValid = true;
+  }
+}
+class SingleLoopTool extends LoopToolBase {
+  constructor(index) {
+    super();
+    this.mTargetIndex = index;
+  }
+  getNextIndex(curIndex) {
+    return -1;
+  }
+  setApicInfo(frame_num, loop_num) {
+    this.mTotalFrameNum = frame_num;
+    this.mNextFrameIndex = this.mTargetIndex;
+  }
+}
+class Viewer {
+  constructor(apic_data, canvas, listener) {
+    this._ApicData = apic_data;
+    this._Canvas = canvas;
+    this._Context = this._Canvas.getContext("2d");
+    this._Listener = listener;
+    this._TimeoutId = -1;
+    this._EndState = ApicEndState.LAST_FRAME;
+  }
+  _createLoopTool(loop_type, loop_info) {
+    let loop_num = null;
+    switch (loop_type) {
+      case LoopType.LOOP_DEFAULT:
+      case LoopType.LOOP_INFINITE:
+      case LoopType.LOOP_FINITE:
+        loop_num = loop_type == LoopType.LOOP_DEFAULT ? this._ApicData.LoopCount : loop_info[0][0];
+        this._LoopTool = new NormalLoopTool(
+          loop_type,
+          loop_num
+        );
+        break;
+      case LoopType.LOOP_PART:
+        this._LoopTool = new PartLoopTool(
+          loop_info,
+          this._ApicData.FrameCount
+        );
+        break;
+      case LoopType.LOOP_SINGLE:
+        this._LoopTool = new SingleLoopTool(loop_info[0][1]);
+        break;
+      default:
+        this._LoopTool = new NormalLoopTool(
+          LoopType.LOOP_DEFAULT,
+          -1
+        );
+    }
+    this._LoopTool.setApicInfo(this._ApicData.FrameCount, this._ApicData.LoopCount);
+  }
+  stop() {
+    clearTimeout(this._TimeoutId);
+    if (this._Listener?.onend) {
+      this._Listener.onend();
+    }
+  }
+  play(loopType, loopInfo, endState = ApicEndState.LAST_FRAME) {
+    this._EndState = endState;
+    let lInfo;
+    if (loopInfo instanceof Array) {
+      lInfo = loopInfo;
+    } else if (!isNaN(loopInfo)) {
+      lInfo = [[loopInfo, 0, 0]];
+    } else {
+      lInfo = [[0, 0, 0]];
+    }
+    this._createLoopTool(loopType, lInfo);
+    clearTimeout(this._TimeoutId);
+    this.renderLoop();
+    if (this._Listener?.onstart) {
+      this._Listener.onstart();
+    }
+  }
+  renderLoop() {
+    if (this._LoopTool.hasNext()) {
+      let duration = this.renderFrame(this._LoopTool.next());
+      this._TimeoutId = setTimeout(() => {
+        this.renderLoop();
+      }, duration);
+    } else {
+      console.log("loop finished");
+      if (this._EndState == ApicEndState.HIDE) {
+        this._Context.clearRect(0, 0, this._Canvas.width, this._Canvas.height);
+      }
+      if (this._Listener?.onend) {
+        this._Listener.onend();
+      }
+    }
+  }
+  renderFrame(frame_index) {
+    return this._ApicData.toImage(frame_index, this._Canvas, this._Context);
+  }
+}
+class ApicDataBase {
+  constructor(arrayBuffer) {
+    this.LoopCount = 0;
+    this.FrameCount = 0;
+    this.Width = 0;
+    this.Height = 0;
+    this._Canvas = window.originDocument.createElement("canvas");
+    this._Context = this._Canvas.getContext("2d");
+    this._DecodedData = null;
+    this.decode(arrayBuffer);
+  }
+  decode(arrayBuffer) {
+    console.log("decode need override ", arrayBuffer);
+  }
+  toImage(frameIndex, canvas, canvasCtx) {
+    console.log("toImage need override ", frameIndex, canvas, canvasCtx);
+  }
+}
+class WebpData extends ApicDataBase {
+  decode(array_buffer) {
+    let webp_data = new Uint8Array(array_buffer);
+    let webp_decoder = new window.WebPDecoder();
+    let image_data = window.WebPRiffParser(webp_data, 0);
+    let blend = false;
+    let header = image_data["header"] ? image_data["header"] : null;
+    let frames = image_data["frames"] ? image_data["frames"] : null;
+    if (header) {
+      this.LoopCount = header["loop_count"];
+      header["loop_counter"] = header["loop_count"];
+      this._Canvas.height = header["canvas_height"];
+      this._Canvas.width = header["canvas_width"];
+      this.Width = header["canvas_width"];
+      this.Height = header["canvas_height"];
+      for (let f = 0; f < frames.length; f++) {
+        if (frames[f]["blend"] === 0) {
+          blend = true;
+          break;
+        }
+      }
+    }
+    this.FrameCount = frames.length;
+    for (let f = 0; f < frames.length; f++) {
+      let height = [0];
+      let width = [0];
+      let frame = frames[f];
+      let rgba = webp_decoder.WebPDecodeRGBA(
+        webp_data,
+        frame["src_off"],
+        frame["src_size"],
+        width,
+        height
+      );
+      frame["rgba"] = rgba;
+      frame["imgwidth"] = width[0];
+      frame["imgheight"] = height[0];
+      let oldimagedata = [];
+      if (!header) {
+        this._Canvas.height = height[0];
+        this._Canvas.width = width[0];
+      } else {
+        if (blend) {
+          let oldimagedata_ = this._Context.getImageData(
+            frame["offset_x"],
+            frame["offset_y"],
+            width[0],
+            height[0]
+          );
+          for (let i = 0; i < width[0] * height[0] * 4; i++) {
+            oldimagedata[i] = oldimagedata_.data[i];
+          }
+        }
+      }
+      let imagedata = this._Context.createImageData(width[0], height[0]);
+      if (frames.length === 1 && typeof frame["blend"] === "undefined" || frame["blend"] === 1) {
+        for (let i = 0; i < width[0] * height[0] * 4; i++)
+          imagedata.data[i] = rgba[i];
+      } else {
+        for (let i = 0; i < width[0] * height[0] * 4; i += 4) {
+          if (rgba[i + 3] > 0) {
+            imagedata.data[i + 3] = rgba[i + 3];
+            imagedata.data[i] = rgba[i];
+            imagedata.data[i + 1] = rgba[i + 1];
+            imagedata.data[i + 2] = rgba[i + 2];
+          } else {
+            imagedata.data[i + 3] = oldimagedata[i + 3];
+            imagedata.data[i] = oldimagedata[i];
+            imagedata.data[i + 1] = oldimagedata[i + 1];
+            imagedata.data[i + 2] = oldimagedata[i + 2];
+          }
+        }
+      }
+      if (frames.length === 1) {
+        this._Context.putImageData(imagedata, 0, 0);
+      } else {
+        this._Context.putImageData(
+          imagedata,
+          frame["offset_x"],
+          frame["offset_y"]
+        );
+      }
+      frame["frameData"] = frame["rgba"] ? header ? this._Context.getImageData(
+        0,
+        0,
+        header["canvas_width"],
+        header["canvas_height"]
+      ).data : rgba : null;
+      if (frame["dispose"] === 1) {
+        this._Context.clearRect(
+          frame["offset_x"],
+          frame["offset_y"],
+          width[0],
+          height[0]
+        );
+      }
+    }
+    this._DecodedData = image_data;
+  }
+  toImage(frame_index, canvas, canvas_ctx) {
+    let frame = this._DecodedData["frames"][frame_index];
+    let width = this._DecodedData["header"] ? this._DecodedData["header"]["canvas_width"] : frame["imgwidth"];
+    let height = this._DecodedData["header"] ? this._DecodedData["header"]["canvas_height"] : frame["imgheight"];
+    canvas.width = width;
+    canvas.height = height;
+    let image_data = canvas_ctx.createImageData(width, height);
+    let frame_data = frame["frameData"];
+    image_data.data.set(frame_data);
+    canvas_ctx.putImageData(image_data, 0, 0);
+    return frame["duration"];
+  }
+}
+class GifData extends ApicDataBase {
+  decode(array_buffer) {
+    const gif = window.ApicTools.parseGIF(array_buffer);
+    this._DecodedData = window.ApicTools.decompressFrames(gif, true);
+    this.LoopCount = 0;
+    this.FrameCount = this._DecodedData.length;
+    this.Width = this._DecodedData[0].dims.width;
+    this.Height = this._DecodedData[0].dims.height;
+    for (let i = 0; i < this._DecodedData.length; i++) {
+      let frame = this._DecodedData[i];
+      if (frame["dims"]["width"] !== this.Width || frame["dims"]["height"] !== this.Height) {
+        let pre_frame_data = this._DecodedData[i - 1]["frameData"];
+        let left = frame["dims"]["left"];
+        let top = frame["dims"]["top"];
+        let width = frame["dims"]["width"];
+        let height = frame["dims"]["height"];
+        let patch_data = frame["patch"];
+        let image_data = new Uint8ClampedArray(this.Width * this.Height * 4);
+        for (let x = 0; x < this.Width; x++) {
+          for (let y = 0; y < this.Height; y++) {
+            let patch_x = x - left;
+            let patch_y = y - top;
+            let pixel_index = y * this.Width + x;
+            let patch_pixel_index = patch_y * width + patch_x;
+            if (x >= left && x < left + width && y >= top && y < top + height && patch_data[patch_pixel_index * 4 + 3] > 0) {
+              image_data[pixel_index * 4] = patch_data[patch_pixel_index * 4];
+              image_data[pixel_index * 4 + 1] = patch_data[patch_pixel_index * 4 + 1];
+              image_data[pixel_index * 4 + 2] = patch_data[patch_pixel_index * 4 + 2];
+              image_data[pixel_index * 4 + 3] = patch_data[patch_pixel_index * 4 + 3];
+            } else {
+              image_data[pixel_index * 4] = pre_frame_data[pixel_index * 4];
+              image_data[pixel_index * 4 + 1] = pre_frame_data[pixel_index * 4 + 1];
+              image_data[pixel_index * 4 + 2] = pre_frame_data[pixel_index * 4 + 2];
+              image_data[pixel_index * 4 + 3] = pre_frame_data[pixel_index * 4 + 3];
+            }
+          }
+        }
+        frame["frameData"] = image_data;
+      } else {
+        frame["frameData"] = frame["patch"];
+      }
+    }
+  }
+  toImage(frame_index, canvas, canvas_ctx) {
+    canvas.width = this.Width;
+    canvas.height = this.Height;
+    let frame = this._DecodedData[frame_index];
+    let image_data = canvas_ctx.createImageData(this.Width, this.Height);
+    image_data.data.set(frame["frameData"]);
+    canvas_ctx.putImageData(image_data, 0, 0);
+    return frame["delay"];
+  }
+}
+export {
+  GifData as G,
+  LoopType as L,
+  Viewer as V,
+  WebpData as W
+};
+//# sourceMappingURL=http://localhost:57245/map/GifData.e5dd9fac.js.map
+
+/*jsvmd5:93d3941c7cace7cf0a63b19ac1591b31*/