feat(virtual-background): Desktop share as virtual background

react/features/stream-effects/virtual-background/JitsiStreamBackgroundEffect.js

 // @flow
 
+import { VIRTUAL_BACKGROUND_TYPE } from '../../virtual-background/constants';
+
 import {
     CLEAR_TIMEOUT,
     TIMEOUT_TICK,
 export default class JitsiStreamBackgroundEffect {
     _model: Object;
     _options: Object;
+    _desktopShareDimensions: Object;
     _segmentationPixelCount: number;
     _inputVideoElement: HTMLVideoElement;
     _onMaskFrameTimer: Function;
     constructor(model: Object, options: Object) {
         this._options = options;
 
-        if (this._options.virtualBackground.backgroundType === 'image') {
+        if (this._options.virtualBackground.backgroundType === VIRTUAL_BACKGROUND_TYPE.IMAGE) {
             this._virtualImage = document.createElement('img');
             this._virtualImage.crossOrigin = 'anonymous';
             this._virtualImage.src = this._options.virtualBackground.virtualSource;
         }
-        if (this._options.virtualBackground.backgroundType === 'desktop-share') {
+        if (this._options.virtualBackground.backgroundType === VIRTUAL_BACKGROUND_TYPE.DESKTOP_SHARE) {
+            const desktopShareTrack = this._options?.virtualBackground?.virtualSource?.track;
+
             this._virtualVideo = document.createElement('video');
             this._virtualVideo.autoplay = true;
             this._virtualVideo.srcObject = this._options?.virtualBackground?.virtualSource?.stream;
+            this._desktopShareDimensions = desktopShareTrack.getSettings ? desktopShareTrack.getSettings()
+                : desktopShareTrack.getConstraints();
         }
         this._model = model;
-        this._options = options;
         this._segmentationPixelCount = this._options.width * this._options.height;
 
         // Bind event handler so it is only bound once for every instance.
         //
 
         // Smooth out the edges.
-        if (this._options.virtualBackground.backgroundType === 'image') {
+        if (this._options.virtualBackground.backgroundType === VIRTUAL_BACKGROUND_TYPE.IMAGE) {
             this._outputCanvasCtx.filter = 'blur(4px)';
         } else {
             this._outputCanvasCtx.filter = 'blur(8px)';
         //
 
         this._outputCanvasCtx.globalCompositeOperation = 'destination-over';
-        if (this._options.virtualBackground.backgroundType === 'image') {
+        if (this._options.virtualBackground.backgroundType === VIRTUAL_BACKGROUND_TYPE.IMAGE) {
             this._outputCanvasCtx.drawImage(
                 this._virtualImage,
                 0,
                 this._inputVideoElement.height
             );
         }
-        if (this._options.virtualBackground.backgroundType === 'desktop-share') {
+        if (this._options.virtualBackground.backgroundType === VIRTUAL_BACKGROUND_TYPE.DESKTOP_SHARE) {
             this._outputCanvasCtx.drawImage(
                 this._virtualVideo,
                 0,
                 0,
-                this._inputVideoElement.width,
-                this._inputVideoElement.height
+                this._desktopShareDimensions.width,
+                this._desktopShareDimensions.height
             );
         } else {
             this._outputCanvasCtx.filter = `blur(${this._options.virtualBackground.blurValue}px)`;

react/features/toolbox/components/web/Toolbox.js

 } from '../../../video-quality';
 import { VideoBackgroundButton } from '../../../virtual-background';
 import { toggleBackgroundEffect } from '../../../virtual-background/actions';
+import { VIRTUAL_BACKGROUND_TYPE } from '../../../virtual-background/constants';
 import { checkBlurSupport } from '../../../virtual-background/functions';
 import {
     setFullScreen,
      * @returns {void}
      */
     _onToolbarToggleScreenshare() {
-        if (this.props._backgroundType === 'desktop-share') {
+        if (this.props._backgroundType === VIRTUAL_BACKGROUND_TYPE.DESKTOP_SHARE) {
             const noneOptions = {
                 enabled: false,
-                backgroundType: 'none',
-                selectedThumbnail: 'none',
+                backgroundType: VIRTUAL_BACKGROUND_TYPE.NONE,
+                selectedThumbnail: VIRTUAL_BACKGROUND_TYPE.NONE,
                 backgroundEffectEnabled: false
             };
 

react/features/virtual-background/components/VirtualBackgroundDialog.js

 import { translate } from '../../base/i18n';
 import { Icon, IconCloseSmall, IconPlusCircle, IconShareDesktop } from '../../base/icons';
 import { createLocalTrack } from '../../base/lib-jitsi-meet/functions';
+import { VIDEO_TYPE } from '../../base/media';
 import { connect } from '../../base/redux';
 import { getLocalVideoTrack } from '../../base/tracks';
 import { toggleBackgroundEffect } from '../actions';
+import { VIRTUAL_BACKGROUND_TYPE } from '../constants';
 import { resizeImage, toDataURL } from '../functions';
 import logger from '../logger';
 
     const localImages = jitsiLocalStorage.getItem('virtualBackgrounds');
     const [ storedImages, setStoredImages ] = useState((localImages && JSON.parse(localImages)) || []);
     const [ loading, isloading ] = useState(false);
-    const [ activeDesktopVideo ] = useState(_virtualSource?.videoType === 'desktop' ? _virtualSource : null);
+    const [ activeDesktopVideo ] = useState(_virtualSource?.videoType === VIDEO_TYPE.DESKTOP ? _virtualSource : null);
 
     const deleteStoredImage = image => {
         setStoredImages(storedImages.filter(item => item !== image));
 
     const enableBlur = async (blurValue, selection) => {
         setOptions({
-            backgroundType: 'blur',
+            backgroundType: VIRTUAL_BACKGROUND_TYPE.BLUR,
             enabled: true,
             blurValue,
             selectedThumbnail: selection
     const shareDesktop = async selection => {
         const url = await createLocalTrack('desktop', '');
 
+        if (!url) {
+            throw new Error('Could not create desktop local track!');
+        }
         setOptions({
-            backgroundType: 'desktop-share',
+            backgroundType: VIRTUAL_BACKGROUND_TYPE.DESKTOP_SHARE,
             enabled: true,
             selectedThumbnail: selection,
             url
 
     const setUploadedImageBackground = async image => {
         setOptions({
-            backgroundType: 'image',
+            backgroundType: VIRTUAL_BACKGROUND_TYPE.IMAGE,
             enabled: true,
             url: image.src,
             selectedThumbnail: image.id
         const url = await toDataURL(image.src);
 
         setOptions({
-            backgroundType: 'image',
+            backgroundType: VIRTUAL_BACKGROUND_TYPE.IMAGE,
             enabled: true,
             url,
             selectedThumbnail: image.id
                 }
             ]);
             setOptions({
-                backgroundType: 'image',
+                backgroundType: VIRTUAL_BACKGROUND_TYPE.IMAGE,
                 enabled: true,
                 url,
                 selectedThumbnail: uuId

react/features/virtual-background/components/VirtualBackgroundPreview.js

 import React, { PureComponent } from 'react';
 
 import { translate } from '../../base/i18n';
+import { VIDEO_TYPE } from '../../base/media';
 import Video from '../../base/media/components/Video';
 import { connect, equals } from '../../base/redux';
 import { getCurrentCameraDeviceId } from '../../base/settings';
 import { createLocalTracksF } from '../../base/tracks/functions';
 import { toggleBackgroundEffect } from '../actions';
+import { VIRTUAL_BACKGROUND_TYPE } from '../constants';
 import { localTrackStopped } from '../functions';
 
 const videoClassName = 'video-preview-video';
             this._setTracks();
         }
         if (!equals(this.props.options, prevProps.options)) {
-            if (prevProps.options.backgroundType === 'desktop-share') {
+            if (prevProps.options.backgroundType === VIRTUAL_BACKGROUND_TYPE.DESKTOP_SHARE) {
                 prevProps.options.url.dispose();
             }
             this._applyBackgroundEffect();
         }
-        if (this.props.options.url?.videoType === 'desktop') {
+        if (this.props.options.url?.videoType === VIDEO_TYPE.DESKTOP) {
             localTrackStopped(this.props.dispatch, this.props.options.url, this.state.jitsiTrack);
         }
     }

react/features/virtual-background/constants.js

+/**
+ * An enumeration of the different virtual background types.
+ *
+ * @enum {string}
+ */
+export const VIRTUAL_BACKGROUND_TYPE = {
+    IMAGE: 'image',
+    DESKTOP_SHARE: 'desktop-share',
+    BLUR: 'blur',
+    NONE: 'none'
+};

react/features/virtual-background/middleware.js

 // @flow
 
+import { VIDEO_TYPE } from '../base/media';
 import { MiddlewareRegistry } from '../base/redux';
 import { getLocalVideoTrack } from '../base/tracks';
 
     const virtualSource = getState()['features/virtual-background'].virtualSource;
     const currentLocalTrack = getLocalVideoTrack(getState()['features/base/tracks']);
 
-    if (virtualSource?.videoType === 'desktop') {
+    if (virtualSource?.videoType === VIDEO_TYPE.DESKTOP && currentLocalTrack) {
         localTrackStopped(dispatch, virtualSource, currentLocalTrack.jitsiTrack);
     }
 

react/features/virtual-background/reducer.js

 import { PersistenceRegistry, ReducerRegistry } from '../base/redux';
 
 import { BACKGROUND_ENABLED, SET_VIRTUAL_BACKGROUND } from './actionTypes';
+import { VIRTUAL_BACKGROUND_TYPE } from './constants';
 
 const STORE_NAME = 'features/virtual-background';
 
     /**
      * Sets up the persistence of the feature {@code virtual-background}.
      */
-    PersistenceRegistry.register(STORE_NAME, state.backgroundType !== 'desktop-share');
+    PersistenceRegistry.register(STORE_NAME, state.backgroundType !== VIRTUAL_BACKGROUND_TYPE.DESKTOP_SHARE);
 
     switch (action.type) {
     case SET_VIRTUAL_BACKGROUND: {