forgeplus-react/node_modules/@novnc/novnc/lib/decoders/jpeg.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;
function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
/*
 * noVNC: HTML5 VNC client
 * Copyright (C) 2019 The noVNC Authors
 * Licensed under MPL 2.0 (see LICENSE.txt)
 *
 * See README.md for usage and integration instructions.
 *
 */
var JPEGDecoder = /*#__PURE__*/function () {
  function JPEGDecoder() {
    _classCallCheck(this, JPEGDecoder);
    // RealVNC will reuse the quantization tables
    // and Huffman tables, so we need to cache them.
    this._quantTables = [];
    this._huffmanTables = [];
    this._cachedQuantTables = [];
    this._cachedHuffmanTables = [];
    this._jpegLength = 0;
    this._segments = [];
  }
  _createClass(JPEGDecoder, [{
    key: "decodeRect",
    value: function decodeRect(x, y, width, height, sock, display, depth) {
      // A rect of JPEG encodings is simply a JPEG file
      if (!this._parseJPEG(sock.rQslice(0))) {
        return false;
      }
      var data = sock.rQshiftBytes(this._jpegLength);
      if (this._quantTables.length != 0 && this._huffmanTables.length != 0) {
        // If there are quantization tables and Huffman tables in the JPEG
        // image, we can directly render it.
        display.imageRect(x, y, width, height, "image/jpeg", data);
        return true;
      } else {
        // Otherwise we need to insert cached tables.
        var sofIndex = this._segments.findIndex(function (x) {
          return x[1] == 0xC0 || x[1] == 0xC2;
        });
        if (sofIndex == -1) {
          throw new Error("Illegal JPEG image without SOF");
        }
        var segments = this._segments.slice(0, sofIndex);
        segments = segments.concat(this._quantTables.length ? this._quantTables : this._cachedQuantTables);
        segments.push(this._segments[sofIndex]);
        segments = segments.concat(this._huffmanTables.length ? this._huffmanTables : this._cachedHuffmanTables, this._segments.slice(sofIndex + 1));
        var length = 0;
        for (var i = 0; i < segments.length; i++) {
          length += segments[i].length;
        }
        var _data = new Uint8Array(length);
        length = 0;
        for (var _i = 0; _i < segments.length; _i++) {
          _data.set(segments[_i], length);
          length += segments[_i].length;
        }
        display.imageRect(x, y, width, height, "image/jpeg", _data);
        return true;
      }
    }
  }, {
    key: "_parseJPEG",
    value: function _parseJPEG(buffer) {
      if (this._quantTables.length != 0) {
        this._cachedQuantTables = this._quantTables;
      }
      if (this._huffmanTables.length != 0) {
        this._cachedHuffmanTables = this._huffmanTables;
      }
      this._quantTables = [];
      this._huffmanTables = [];
      this._segments = [];
      var i = 0;
      var bufferLength = buffer.length;
      while (true) {
        var j = i;
        if (j + 2 > bufferLength) {
          return false;
        }
        if (buffer[j] != 0xFF) {
          throw new Error("Illegal JPEG marker received (byte: " + buffer[j] + ")");
        }
        var type = buffer[j + 1];
        j += 2;
        if (type == 0xD9) {
          this._jpegLength = j;
          this._segments.push(buffer.slice(i, j));
          return true;
        } else if (type == 0xDA) {
          // start of scan
          var hasFoundEndOfScan = false;
          for (var k = j + 3; k + 1 < bufferLength; k++) {
            if (buffer[k] == 0xFF && buffer[k + 1] != 0x00 && !(buffer[k + 1] >= 0xD0 && buffer[k + 1] <= 0xD7)) {
              j = k;
              hasFoundEndOfScan = true;
              break;
            }
          }
          if (!hasFoundEndOfScan) {
            return false;
          }
          this._segments.push(buffer.slice(i, j));
          i = j;
          continue;
        } else if (type >= 0xD0 && type < 0xD9 || type == 0x01) {
          // No length after marker
          this._segments.push(buffer.slice(i, j));
          i = j;
          continue;
        }
        if (j + 2 > bufferLength) {
          return false;
        }
        var length = (buffer[j] << 8) + buffer[j + 1] - 2;
        if (length < 0) {
          throw new Error("Illegal JPEG length received (length: " + length + ")");
        }
        j += 2;
        if (j + length > bufferLength) {
          return false;
        }
        j += length;
        var segment = buffer.slice(i, j);
        if (type == 0xC4) {
          // Huffman tables
          this._huffmanTables.push(segment);
        } else if (type == 0xDB) {
          // Quantization tables
          this._quantTables.push(segment);
        }
        this._segments.push(segment);
        i = j;
      }
    }
  }]);
  return JPEGDecoder;
}();
exports["default"] = JPEGDecoder;