@novnc/novnc 1.0.0 → 1.2.0

package/lib/decoders/tight.js

@@ -0,0 +1,350 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var Log = _interopRequireWildcard(require("../util/logging.js"));
+
+var _inflator = _interopRequireDefault(require("../inflator.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var TightDecoder = /*#__PURE__*/function () {
+  function TightDecoder() {
+    _classCallCheck(this, TightDecoder);
+
+    this._ctl = null;
+    this._filter = null;
+    this._numColors = 0;
+    this._palette = new Uint8Array(1024); // 256 * 4 (max palette size * max bytes-per-pixel)
+
+    this._len = 0;
+    this._zlibs = [];
+
+    for (var i = 0; i < 4; i++) {
+      this._zlibs[i] = new _inflator.default();
+    }
+  }
+
+  _createClass(TightDecoder, [{
+    key: "decodeRect",
+    value: function decodeRect(x, y, width, height, sock, display, depth) {
+      if (this._ctl === null) {
+        if (sock.rQwait("TIGHT compression-control", 1)) {
+          return false;
+        }
+
+        this._ctl = sock.rQshift8(); // Reset streams if the server requests it
+
+        for (var i = 0; i < 4; i++) {
+          if (this._ctl >> i & 1) {
+            this._zlibs[i].reset();
+
+            Log.Info("Reset zlib stream " + i);
+          }
+        } // Figure out filter
+
+
+        this._ctl = this._ctl >> 4;
+      }
+
+      var ret;
+
+      if (this._ctl === 0x08) {
+        ret = this._fillRect(x, y, width, height, sock, display, depth);
+      } else if (this._ctl === 0x09) {
+        ret = this._jpegRect(x, y, width, height, sock, display, depth);
+      } else if (this._ctl === 0x0A) {
+        ret = this._pngRect(x, y, width, height, sock, display, depth);
+      } else if ((this._ctl & 0x80) == 0) {
+        ret = this._basicRect(this._ctl, x, y, width, height, sock, display, depth);
+      } else {
+        throw new Error("Illegal tight compression received (ctl: " + this._ctl + ")");
+      }
+
+      if (ret) {
+        this._ctl = null;
+      }
+
+      return ret;
+    }
+  }, {
+    key: "_fillRect",
+    value: function _fillRect(x, y, width, height, sock, display, depth) {
+      if (sock.rQwait("TIGHT", 3)) {
+        return false;
+      }
+
+      var rQi = sock.rQi;
+      var rQ = sock.rQ;
+      display.fillRect(x, y, width, height, [rQ[rQi + 2], rQ[rQi + 1], rQ[rQi]], false);
+      sock.rQskipBytes(3);
+      return true;
+    }
+  }, {
+    key: "_jpegRect",
+    value: function _jpegRect(x, y, width, height, sock, display, depth) {
+      var data = this._readData(sock);
+
+      if (data === null) {
+        return false;
+      }
+
+      display.imageRect(x, y, width, height, "image/jpeg", data);
+      return true;
+    }
+  }, {
+    key: "_pngRect",
+    value: function _pngRect(x, y, width, height, sock, display, depth) {
+      throw new Error("PNG received in standard Tight rect");
+    }
+  }, {
+    key: "_basicRect",
+    value: function _basicRect(ctl, x, y, width, height, sock, display, depth) {
+      if (this._filter === null) {
+        if (ctl & 0x4) {
+          if (sock.rQwait("TIGHT", 1)) {
+            return false;
+          }
+
+          this._filter = sock.rQshift8();
+        } else {
+          // Implicit CopyFilter
+          this._filter = 0;
+        }
+      }
+
+      var streamId = ctl & 0x3;
+      var ret;
+
+      switch (this._filter) {
+        case 0:
+          // CopyFilter
+          ret = this._copyFilter(streamId, x, y, width, height, sock, display, depth);
+          break;
+
+        case 1:
+          // PaletteFilter
+          ret = this._paletteFilter(streamId, x, y, width, height, sock, display, depth);
+          break;
+
+        case 2:
+          // GradientFilter
+          ret = this._gradientFilter(streamId, x, y, width, height, sock, display, depth);
+          break;
+
+        default:
+          throw new Error("Illegal tight filter received (ctl: " + this._filter + ")");
+      }
+
+      if (ret) {
+        this._filter = null;
+      }
+
+      return ret;
+    }
+  }, {
+    key: "_copyFilter",
+    value: function _copyFilter(streamId, x, y, width, height, sock, display, depth) {
+      var uncompressedSize = width * height * 3;
+      var data;
+
+      if (uncompressedSize < 12) {
+        if (sock.rQwait("TIGHT", uncompressedSize)) {
+          return false;
+        }
+
+        data = sock.rQshiftBytes(uncompressedSize);
+      } else {
+        data = this._readData(sock);
+
+        if (data === null) {
+          return false;
+        }
+
+        this._zlibs[streamId].setInput(data);
+
+        data = this._zlibs[streamId].inflate(uncompressedSize);
+
+        this._zlibs[streamId].setInput(null);
+      }
+
+      display.blitRgbImage(x, y, width, height, data, 0, false);
+      return true;
+    }
+  }, {
+    key: "_paletteFilter",
+    value: function _paletteFilter(streamId, x, y, width, height, sock, display, depth) {
+      if (this._numColors === 0) {
+        if (sock.rQwait("TIGHT palette", 1)) {
+          return false;
+        }
+
+        var numColors = sock.rQpeek8() + 1;
+        var paletteSize = numColors * 3;
+
+        if (sock.rQwait("TIGHT palette", 1 + paletteSize)) {
+          return false;
+        }
+
+        this._numColors = numColors;
+        sock.rQskipBytes(1);
+        sock.rQshiftTo(this._palette, paletteSize);
+      }
+
+      var bpp = this._numColors <= 2 ? 1 : 8;
+      var rowSize = Math.floor((width * bpp + 7) / 8);
+      var uncompressedSize = rowSize * height;
+      var data;
+
+      if (uncompressedSize < 12) {
+        if (sock.rQwait("TIGHT", uncompressedSize)) {
+          return false;
+        }
+
+        data = sock.rQshiftBytes(uncompressedSize);
+      } else {
+        data = this._readData(sock);
+
+        if (data === null) {
+          return false;
+        }
+
+        this._zlibs[streamId].setInput(data);
+
+        data = this._zlibs[streamId].inflate(uncompressedSize);
+
+        this._zlibs[streamId].setInput(null);
+      } // Convert indexed (palette based) image data to RGB
+
+
+      if (this._numColors == 2) {
+        this._monoRect(x, y, width, height, data, this._palette, display);
+      } else {
+        this._paletteRect(x, y, width, height, data, this._palette, display);
+      }
+
+      this._numColors = 0;
+      return true;
+    }
+  }, {
+    key: "_monoRect",
+    value: function _monoRect(x, y, width, height, data, palette, display) {
+      // Convert indexed (palette based) image data to RGB
+      // TODO: reduce number of calculations inside loop
+      var dest = this._getScratchBuffer(width * height * 4);
+
+      var w = Math.floor((width + 7) / 8);
+      var w1 = Math.floor(width / 8);
+
+      for (var _y = 0; _y < height; _y++) {
+        var dp = void 0,
+            sp = void 0,
+            _x = void 0;
+
+        for (_x = 0; _x < w1; _x++) {
+          for (var b = 7; b >= 0; b--) {
+            dp = (_y * width + _x * 8 + 7 - b) * 4;
+            sp = (data[_y * w + _x] >> b & 1) * 3;
+            dest[dp] = palette[sp];
+            dest[dp + 1] = palette[sp + 1];
+            dest[dp + 2] = palette[sp + 2];
+            dest[dp + 3] = 255;
+          }
+        }
+
+        for (var _b = 7; _b >= 8 - width % 8; _b--) {
+          dp = (_y * width + _x * 8 + 7 - _b) * 4;
+          sp = (data[_y * w + _x] >> _b & 1) * 3;
+          dest[dp] = palette[sp];
+          dest[dp + 1] = palette[sp + 1];
+          dest[dp + 2] = palette[sp + 2];
+          dest[dp + 3] = 255;
+        }
+      }
+
+      display.blitRgbxImage(x, y, width, height, dest, 0, false);
+    }
+  }, {
+    key: "_paletteRect",
+    value: function _paletteRect(x, y, width, height, data, palette, display) {
+      // Convert indexed (palette based) image data to RGB
+      var dest = this._getScratchBuffer(width * height * 4);
+
+      var total = width * height * 4;
+
+      for (var i = 0, j = 0; i < total; i += 4, j++) {
+        var sp = data[j] * 3;
+        dest[i] = palette[sp];
+        dest[i + 1] = palette[sp + 1];
+        dest[i + 2] = palette[sp + 2];
+        dest[i + 3] = 255;
+      }
+
+      display.blitRgbxImage(x, y, width, height, dest, 0, false);
+    }
+  }, {
+    key: "_gradientFilter",
+    value: function _gradientFilter(streamId, x, y, width, height, sock, display, depth) {
+      throw new Error("Gradient filter not implemented");
+    }
+  }, {
+    key: "_readData",
+    value: function _readData(sock) {
+      if (this._len === 0) {
+        if (sock.rQwait("TIGHT", 3)) {
+          return null;
+        }
+
+        var byte;
+        byte = sock.rQshift8();
+        this._len = byte & 0x7f;
+
+        if (byte & 0x80) {
+          byte = sock.rQshift8();
+          this._len |= (byte & 0x7f) << 7;
+
+          if (byte & 0x80) {
+            byte = sock.rQshift8();
+            this._len |= byte << 14;
+          }
+        }
+      }
+
+      if (sock.rQwait("TIGHT", this._len)) {
+        return null;
+      }
+
+      var data = sock.rQshiftBytes(this._len);
+      this._len = 0;
+      return data;
+    }
+  }, {
+    key: "_getScratchBuffer",
+    value: function _getScratchBuffer(size) {
+      if (!this._scratchBuffer || this._scratchBuffer.length < size) {
+        this._scratchBuffer = new Uint8Array(size);
+      }
+
+      return this._scratchBuffer;
+    }
+  }]);
+
+  return TightDecoder;
+}();
+
+exports.default = TightDecoder;

package/lib/decoders/tightpng.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _tight = _interopRequireDefault(require("./tight.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _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, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var TightPNGDecoder = /*#__PURE__*/function (_TightDecoder) {
+  _inherits(TightPNGDecoder, _TightDecoder);
+
+  var _super = _createSuper(TightPNGDecoder);
+
+  function TightPNGDecoder() {
+    _classCallCheck(this, TightPNGDecoder);
+
+    return _super.apply(this, arguments);
+  }
+
+  _createClass(TightPNGDecoder, [{
+    key: "_pngRect",
+    value: function _pngRect(x, y, width, height, sock, display, depth) {
+      var data = this._readData(sock);
+
+      if (data === null) {
+        return false;
+      }
+
+      display.imageRect(x, y, width, height, "image/png", data);
+      return true;
+    }
+  }, {
+    key: "_basicRect",
+    value: function _basicRect(ctl, x, y, width, height, sock, display, depth) {
+      throw new Error("BasicCompression received in TightPNG rect");
+    }
+  }]);
+
+  return TightPNGDecoder;
+}(_tight.default);
+
+exports.default = TightPNGDecoder;

package/lib/deflator.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _deflate2 = require("../lib/vendor/pako/lib/zlib/deflate.js");
+
+var _zstream = _interopRequireDefault(require("../lib/vendor/pako/lib/zlib/zstream.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: 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, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var Deflator = /*#__PURE__*/function () {
+  function Deflator() {
+    _classCallCheck(this, Deflator);
+
+    this.strm = new _zstream.default();
+    this.chunkSize = 1024 * 10 * 10;
+    this.outputBuffer = new Uint8Array(this.chunkSize);
+    this.windowBits = 5;
+    (0, _deflate2.deflateInit)(this.strm, this.windowBits);
+  }
+
+  _createClass(Deflator, [{
+    key: "deflate",
+    value: function deflate(inData) {
+      /* eslint-disable camelcase */
+      this.strm.input = inData;
+      this.strm.avail_in = this.strm.input.length;
+      this.strm.next_in = 0;
+      this.strm.output = this.outputBuffer;
+      this.strm.avail_out = this.chunkSize;
+      this.strm.next_out = 0;
+      /* eslint-enable camelcase */
+
+      var lastRet = (0, _deflate2.deflate)(this.strm, _deflate2.Z_FULL_FLUSH);
+      var outData = new Uint8Array(this.strm.output.buffer, 0, this.strm.next_out);
+
+      if (lastRet < 0) {
+        throw new Error("zlib deflate failed");
+      }
+
+      if (this.strm.avail_in > 0) {
+        // Read chunks until done
+        var chunks = [outData];
+        var totalLen = outData.length;
+
+        do {
+          /* eslint-disable camelcase */
+          this.strm.output = new Uint8Array(this.chunkSize);
+          this.strm.next_out = 0;
+          this.strm.avail_out = this.chunkSize;
+          /* eslint-enable camelcase */
+
+          lastRet = (0, _deflate2.deflate)(this.strm, _deflate2.Z_FULL_FLUSH);
+
+          if (lastRet < 0) {
+            throw new Error("zlib deflate failed");
+          }
+
+          var chunk = new Uint8Array(this.strm.output.buffer, 0, this.strm.next_out);
+          totalLen += chunk.length;
+          chunks.push(chunk);
+        } while (this.strm.avail_in > 0); // Combine chunks into a single data
+
+
+        var newData = new Uint8Array(totalLen);
+        var offset = 0;
+
+        for (var i = 0; i < chunks.length; i++) {
+          newData.set(chunks[i], offset);
+          offset += chunks[i].length;
+        }
+
+        outData = newData;
+      }
+      /* eslint-disable camelcase */
+
+
+      this.strm.input = null;
+      this.strm.avail_in = 0;
+      this.strm.next_in = 0;
+      /* eslint-enable camelcase */
+
+      return outData;
+    }
+  }]);
+
+  return Deflator;
+}();
+
+exports.default = Deflator;