bfg-common 1.0.0

package/public/spice-console/application/clipboard/clipboarddataparser.js

@@ -0,0 +1,92 @@
+/*
+    Copyright (c) 2016 eyeOS
+
+    This file is part of Open365.
+
+    Open365 is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as
+    published by the Free Software Foundation, either version 3 of the
+    License, or (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+wdi.ClipboardDataParser = $.spcExtend(wdi.EventObject.prototype, {
+
+	fileReader: null,
+
+	init: function (params) {
+		this.fileReader = params["FileReader"] || FileReader;
+	},
+
+	parse: function parse(clipboardData, callback) {
+		var self = this;
+		// Prioritizes mime types that appear earlier in the list
+		var mimeTypes = ["image/png", "text/plain"];
+
+		function getItemAsPojo(item, callback) {
+			switch (item["kind"]) {
+				case "string":
+					return getItemStringAsPojo(item, callback);
+				case "file":
+					return getItemFileAsPojo(item, callback);
+			}
+		}
+
+		function getItemStringAsPojo(item, callback) {
+			var type = item.type;
+			item["getAsString"](function (str) {
+				return callback({
+					type: type,
+					blob: str
+				});
+			})
+		}
+
+		function getItemFileAsPojo(item, callback) {
+			var type = item["type"];
+			var blob = item["getAsFile"]();
+			var reader = new self.fileReader();
+			reader.addEventListener("loadend", function() {
+				return callback({
+					type: type,
+					blob: reader["result"]
+				})
+			});
+			reader.readAsArrayBuffer(blob);
+		}
+
+		var items = clipboardData["items"];
+
+		// If the browser implements the 'items' property of the clipboard event, use it. Supports pasting images.
+		// Docs: https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItemList
+		if (items) {
+			for (var i = 0; i < mimeTypes.length; i++) {
+				var type = mimeTypes[i];
+				for (var j = 0; j < items.length; j++) {
+					var item = items[j];
+					if (item["type"] == type) {
+						return getItemAsPojo(item, callback);
+					}
+				}
+			}
+		}
+		// If not, use old APIs or browser-specific hacks to get the data. This API does not allow pasting images directly.
+		else if (clipboardData.getData){
+			var type = "text/plain";
+			if( clipboardData.types.contains(type)) {
+				callback({
+					type: type,
+					blob: clipboardData.getData(type)
+				})
+			}
+		}
+	}
+});
+

package/public/spice-console/application/clipboard/local/localClipboard.js

@@ -0,0 +1,110 @@
+/*
+    Copyright (c) 2016 eyeOS
+
+    This file is part of Open365.
+
+    Open365 is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as
+    published by the Free Software Foundation, either version 3 of the
+    License, or (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+
+wdi.LocalClipboard = $.spcExtend(wdi.EventObject.prototype, {
+
+	init: function (c) {
+		this.clipboardContainer = $('<div style="position:absolute;top:-10000000px;"><textarea id="remoteClipboard" style="position:absolute;top:-10000000px;font-size: 20px;color:black;z-index: 100" rows="4" cols="50"></textarea></div>');
+		//this.clipboardContent = $('#remoteClipboard');
+		$('#vmw').prepend(this.clipboardContainer);
+
+		this.clientGui = c.clientGui;
+		this.eventHandlers = {
+			keydown: this.triggerCopyToClipboard.bind(this)
+		};
+
+		$(document).on(this.eventHandlers);
+
+		this.delayCopyEvents = {
+			mousedown: this.copyToClipboard.bind(this),
+			mouseup: this.copyToClipboard.bind(this),
+			keydown: this.copyToClipboard.bind(this),
+			keyup: this.copyToClipboard.bind(this)
+		};
+		$(document).on(this.delayCopyEvents);
+	},
+
+	updateClipboardBuffer: function (content) {
+		//this.clipboardContent.val(content);
+		$('#remoteClipboard').val(content);
+
+	},
+
+	triggerCopyToClipboard: function (e) {
+		function isMac () {
+			return navigator.appVersion.indexOf('Mac') != -1
+		}
+		function isCopyShortcutPressed(e) {
+			var ctrlKey = e.ctrlKey;
+			if(isMac()) {
+				ctrlKey = e.metaKey;
+			}
+			return e.keyCode === 67 && ctrlKey;
+		}
+
+		if(isCopyShortcutPressed(e)){
+			this.clipboardCopyDelay = Date.now() + 1000; //now + 1 seconds;
+			e.preventDefault();
+			this.copyToClipboard(e);
+		}
+	},
+
+	copyToClipboard: function (e) {
+		var self = this;
+
+		if (!this.clipboardCopyDelay || this.clipboardCopyDelay < Date.now()) {
+			//don't copy if this user action is later than the ctr+c plus some seconds.
+			return;
+		}
+
+		var callback = function callback(e) {
+			//self.clientGui.disableKeyboard();
+			//self.clipboardContent.focus();
+			$('#remoteClipboard').focus();
+
+			try {
+				var c = document.execCommand("copy");
+				$('#remoteClipboard').blur();
+				$('#inputmanager').focus()
+				//e.preventDefault();
+				//window.getSelection().removeAllRanges();
+				//self.clientGui.enableKeyboard();
+				console.log("Result executeCommand", e.type, "-----", c);
+			} catch (err) {
+				console.error(err);
+			}
+		};
+		callback(e);
+
+		//[0, 100, 200, 500, 1000].map(function(timeInS){
+		//	console.log("Setting timeout for", timeInS);
+		//	setTimeout(function(){
+		//		callback("" + timeInS);
+		//	}, timeInS);
+		//});
+	},
+
+	dispose: function () {
+		this.clipboardContainer.remove();
+		$(document).off(this.eventHandlers);
+		$(document).off(this.delayCopyEvents);
+	}
+
+});

package/public/spice-console/application/clipboard.js

@@ -0,0 +1,82 @@
+/*
+    Copyright (c) 2016 eyeOS
+
+    This file is part of Open365.
+
+    Open365 is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as
+    published by the Free Software Foundation, either version 3 of the
+    License, or (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+wdi.Clipboard = $.spcExtend(wdi.EventObject.prototype, {
+	_blob: null,
+    _type: null,
+
+    getSpiceType: function(mimetype) {
+        switch (mimetype) {
+            case "text/plain": return wdi.ClipBoardTypes.VD_AGENT_CLIPBOARD_UTF8_TEXT;
+            case "image/png": return wdi.ClipBoardTypes.VD_AGENT_CLIPBOARD_IMAGE_PNG;
+            default: throw new Error("Unsupported mime type " + mimetype);
+        }
+    },
+
+    getMimeType: function(spicetype) {
+        switch (spicetype) {
+            case wdi.ClipBoardTypes.VD_AGENT_CLIPBOARD_UTF8_TEXT: return "text/plain";
+            case wdi.ClipBoardTypes.VD_AGENT_CLIPBOARD_IMAGE_PNG: return "image/png";
+            default: throw new Error("Unsupported spice type " + spicetype);
+        }
+    },
+
+    createGrab: function() {
+        return {
+            type: wdi.AgentMessageTypes.VD_AGENT_CLIPBOARD_GRAB,
+            opaque: 0,
+            data: new wdi.VDAgentClipboardGrab({
+                types: [this.getSpiceType(this._type)]
+            })
+        };
+    },
+
+    createRequest: function(type) {
+        return {
+            type: wdi.AgentMessageTypes.VD_AGENT_CLIPBOARD_REQUEST,
+            opaque: 0,
+            data: new wdi.VDAgentClipboardRequest({
+                type: type
+            })
+        };
+    },
+
+    createContent: function() {
+        return {
+            type: wdi.AgentMessageTypes.VD_AGENT_CLIPBOARD,
+            opaque: 0,
+            data: new wdi.VDAgentClipboard({
+                type: this.getSpiceType(this._type),
+                data: this._blob
+            })
+        };
+    },
+
+    setContent: function (content) {
+        this._type = content.type;
+        this._blob = content.blob;
+    },
+
+    getContent: function () {
+        return {
+            blob: this._blob,
+            type: this._type
+        };
+    }
+});

package/public/spice-console/application/codec.js

@@ -0,0 +1,257 @@
+wdi.CodecH264 = {
+  video: {},
+  jmuxer: {},
+  loadedVideo: {},
+  queues: {},
+  isReady: {},
+
+  create: function (streamId) {
+    if (this.video[streamId]) return
+
+    const video = document.createElement('video')
+    video.id = `video${streamId}`
+    video.setAttribute('autoplay', '')
+
+    this.video[streamId] = video
+
+    this.jmuxer[streamId] = new JMuxer({
+      node: video,
+      mode: 'video',
+      flushingTime: 0,
+      fps: 60,
+      onReady: () => {
+        this.isReady[streamId] = true
+      },
+    })
+  },
+
+  addQueue: function (streamId, imageData) {
+    if (!this.queues[streamId]) this.queues[streamId] = []
+    this.queues[streamId].push(imageData)
+  },
+
+  resetQueues: function (streamId) {
+    this.queues[streamId] = []
+  },
+
+  feed: function (streamId, data) {
+    this._addListener(streamId)
+
+    if (this.queues[streamId]?.length) {
+      this.queues[streamId].forEach((queue) => {
+        this.jmuxer[streamId].feed({
+          video: queue,
+        })
+      })
+      this.resetQueues(streamId)
+    }
+
+    this.jmuxer[streamId].feed({
+      video: data,
+    })
+  },
+
+  destroy: function (streamId) {
+    this._removeListener(streamId)
+    this.video[streamId]?.remove()
+    this.video = {}
+    this.jmuxer = {}
+    this.loadedVideo = {}
+  },
+
+  _addListener: function (streamId) {
+    this.video[streamId]?.removeEventListener(
+      'loadedmetadata',
+      this.loadedVideo[streamId]
+    )
+    this.video[streamId].addEventListener(
+      'loadedmetadata',
+      this.loadedVideo[streamId]
+    )
+  },
+
+  _removeListener: function (streamId) {
+    this.video[streamId]?.removeEventListener(
+      'loadedmetadata',
+      this.loadedVideo[streamId]
+    )
+  },
+}
+
+wdi.CodecVp8 = {
+  decoders: {},
+
+  create: function (streamId) {
+    this.decoders[streamId] = new vp8_decoder_ctx()
+  },
+
+  destroy: function () {
+    this.decoders = {}
+  },
+
+  feed: function (streamId, imageData, context, box) {
+    const errorCode = vp8_dixie_decode_frame(
+      this.decoders[streamId],
+      imageData,
+      imageData.length
+    )
+    if (VPX_CODEC_OK === errorCode) {
+      this._I420toRGBA(this.decoders[streamId].ref_frames[0].img, context, box)
+    }
+  },
+
+  _I420toRGBA: function (vp8, context, box) {
+    const yuvwidth = vp8.w
+    const height = vp8.d_h
+    const width = vp8.d_w
+
+    let output = context.createImageData(width, height)
+    let outputData = output.data
+    let R, G, B
+
+    for (let h = 0; h < height; h++) {
+      for (let w = 0; w < width; w++) {
+        const Y = vp8.planes[0][vp8.planes_off[0] + 0 + w + yuvwidth * h]
+        const U =
+          vp8.planes[1][
+            vp8.planes_off[1] + 0 + (w >> 1) + (yuvwidth >> 1) * (h >> 1)
+          ]
+        const V =
+          vp8.planes[2][
+            vp8.planes_off[2] + 0 + (w >> 1) + (yuvwidth >> 1) * (h >> 1)
+          ]
+
+        R = Math.round(Y + 1.13983 * (V - 128))
+        G = Math.round(Y - 0.39465 * (U - 128) - 0.5806 * (V - 128))
+        B = Math.round(Y + 2.03211 * (U - 128))
+
+        outputData[0 + w * 4 + width * 4 * h] = R
+        outputData[1 + w * 4 + width * 4 * h] = G
+        outputData[2 + w * 4 + width * 4 * h] = B
+        outputData[3 + w * 4 + width * 4 * h] = 255
+      }
+    }
+
+    context.putImageData(output, box.x, box.y)
+  },
+}
+
+wdi.CodecH265 = {
+  queue: {},
+  configed: {},
+  isReady: {},
+  decoders: {},
+  pendingFrames: {},
+  underflow: {},
+  baseTime: {},
+
+  create: async function (streamId, context, box) {
+    const init = {
+      output: this._handleFrame.bind(this, streamId, context, box),
+      error: (e) => {
+        console.log(e)
+      },
+    }
+    const config = {
+      codec: wdi.SpiceVideoCodecValue[wdi.currentCodec],
+      codedWidth: 640,
+      codedHeight: 480,
+    }
+    const { supported } = await VideoDecoder.isConfigSupported(config)
+    // Проверяем поддерживает ли браузер VideoDecoder
+    if (supported) {
+      this.decoders[streamId] = new VideoDecoder(init)
+      this.decoders[streamId].configure(config)
+      this.isReady[streamId] = true
+    } else {
+      // Try another config.
+      console.log('not supported')
+    }
+  },
+
+  destroy: function () {
+    this.queue = {}
+    this.configed = {}
+    this.isReady = {}
+    this.decoders = {}
+    this.pendingFrames = {}
+    this.underflow = {}
+    this.baseTime = {}
+  },
+
+  addQueue: function (streamId, imageData) {
+    if (!this.queues[streamId]) this.queues[streamId] = []
+    this.queues[streamId].push(imageData)
+  },
+
+  resetQueues: function (streamId) {
+    this.queues[streamId] = []
+  },
+
+  setConfig: function (streamId, box) {
+    const config = {
+      codec: wdi.SpiceVideoCodecValue[wdi.currentCodec],
+      codedWidth: box.width,
+      codedHeight: box.height,
+    }
+    this.decoders[streamId].configure(config)
+    this.configed[streamId] = true
+  },
+
+  decode: function (streamId, imageData) {
+    if (this.queue[streamId]?.length) {
+      this.queue[streamId].forEach((data) => {
+        const chunk = new EncodedVideoChunk({
+          type: 'key',
+          data: data,
+          timestamp: performance.now(),
+        })
+        this.decoders[streamId].decode(chunk)
+      })
+      this.resetQueues(streamId)
+    }
+
+    const chunk = new EncodedVideoChunk({
+      type: 'key',
+      data: imageData,
+      timestamp: performance.now(),
+    })
+    this.decoders[streamId].decode(chunk)
+  },
+
+  _handleFrame: function (streamId, context, box, frame) {
+    if (!this.pendingFrames[streamId]) this.pendingFrames[streamId] = []
+    this.pendingFrames[streamId].push(frame)
+
+    if (this.underflow[streamId] === undefined) this.underflow[streamId] = true
+    if (this.underflow[streamId])
+      setTimeout(this._renderFrame.bind(this, streamId, context, box), 0)
+  },
+  _renderFrame: async function (streamId, context, box) {
+    this.underflow[streamId] = this.pendingFrames[streamId].length === 0
+    if (this.underflow[streamId]) return
+
+    const frame = this.pendingFrames[streamId].shift()
+
+    // Based on the frame's timestamp calculate how much of real time waiting
+    // is needed before showing the next frame.
+    const timeUntilNextFrame = this._calculateTimeUntilNextFrame(
+      frame.timestamp,
+      streamId
+    )
+    await new Promise((r) => {
+      setTimeout(r, timeUntilNextFrame)
+    })
+
+    context.drawImage(frame, box.x, box.y, box.width, box.height)
+    frame.close()
+
+    // Immediately schedule rendering of the next frame
+    setTimeout(this._renderFrame.bind(this, streamId, context, box), 0)
+  },
+  _calculateTimeUntilNextFrame: function (timestamp, streamId) {
+    if (!this.baseTime[streamId]) this.baseTime[streamId] = performance.now()
+    const mediaTime = performance.now() - this.baseTime[streamId]
+    return Math.max(0, timestamp / 1000 - mediaTime)
+  },
+}

package/public/spice-console/application/imagecache.js

@@ -0,0 +1,81 @@
+/*
+    Copyright (c) 2016 eyeOS
+
+    This file is part of Open365.
+
+    Open365 is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as
+    published by the Free Software Foundation, either version 3 of the
+    License, or (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+wdi.ImageCache = {
+	images: {},
+	cursor: {},
+	palettes: {},
+
+	dispose: function () {
+		wdi.Debug.log("Disposing ImageCache");
+		this.images = {};
+		this.cursor = {};
+		this.palettes = {};
+	},
+
+	getImageFrom: function(descriptor, cb) {
+	//see http://jsperf.com/todataurl-vs-getimagedata-to-base64/7
+		var cnv = wdi.GlobalPool.create('Canvas');
+		var imgData = this.images[descriptor.id.toString()];
+		cnv.width = imgData.width;
+		cnv.height = imgData.height;
+		cnv.getContext('2d').putImageData(imgData,0,0);
+		cb(cnv);
+	},
+
+	isImageInCache: function(descriptor) {
+		if(descriptor.id.toString() in this.images) {
+			return true;
+		}
+		return false;
+	},
+
+	delImage: function(id) {
+		delete this.images[id.toString()];
+	},
+
+	addImage: function(descriptor, canvas) {
+		if(canvas.getContext) {
+			this.images[descriptor.id.toString()] = canvas.getContext('2d').getImageData(0,0,2000, canvas.height);
+		} else {
+			this.images[descriptor.id.toString()] = canvas;
+		}
+
+	},
+
+	getCursorFrom: function(cursor) {
+		return this.cursor[cursor.header.unique.toString()];
+	},
+
+	addCursor: function(cursor, imageData) {
+		this.cursor[cursor.header.unique.toString()] = imageData;
+	},
+
+	getPalette: function(id) {
+		return this.palettes[id.toString()];
+	},
+
+	addPalette: function(id, palette) {
+		this.palettes[id.toString()] = palette;
+	},
+
+	clearPalettes: function() {
+		this.palettes = {};
+	}
+};