Add blurring effect

css/_videolayout_default.scss

     overflow: hidden;
 }
 
+.video_blurred {
+    width: 100%;
+
+    &_container {
+        width: 100%;
+        height: 100%;
+        position: absolute;
+        top: 0;
+        left: 0;
+        overflow: hidden;
+        filter: blur(40px);
+    }
+}
+
 .videocontainer {
     position: relative;
     text-align: center;
     text-align: center;
 }
 
+#largeVideoWrapper {
+    box-shadow: 0 0 20px -2px #444;
+}
+
 #largeVideo,
 #largeVideoWrapper
 {

modules/UI/videolayout/VideoContainer.js

         if (aspectRatio <= 1) {
             const zoomRateHeight = videoSpaceHeight / videoHeight;
             const zoomRateWidth = videoSpaceWidth / videoWidth;
-            const maxZoomRate
-                = interfaceConfig.MAXIMUM_ZOOMING_COEFFICIENT || Infinity;
-            let zoomRate = Math.min(zoomRateWidth, maxZoomRate);
+            const zoomRate = Math.min(
+                zoomRateWidth,
+                zoomRateHeight,
+                interfaceConfig.MAXIMUM_ZOOMING_COEFFICIENT || Infinity);
 
-            zoomRate = Math.max(zoomRate, zoomRateHeight);
             availableWidth = videoWidth * zoomRate;
             availableHeight = videoHeight * zoomRate;
         } else if (availableHeight * aspectRatio < videoSpaceWidth) {
         return $('#largeVideo');
     }
 
+    get $videoBackground() {
+        return $('#largeVideoBackground');
+    }
+
     get id () {
         return getStreamOwnerId(this.stream);
     }
      */
     enableLocalConnectionProblemFilter (enable) {
         this.$video.toggleClass("videoProblemFilter", enable);
+        this.$videoBackground.toggleClass("videoProblemFilter", enable);
     }
 
     /**
             return;
         }
 
-        let [width, height]
+        this._hideVideoBackground();
+
+        let [ width, height ]
             = this.getVideoSize(containerWidth, containerHeight);
+
+        if (containerWidth > width) {
+            this._showVideoBackground();
+        }
+
         let { horizontalIndent, verticalIndent }
             = this.getVideoPosition(width, height,
             containerWidth, containerHeight);
         // detach old stream
         if (this.stream) {
             this.stream.detach(this.$video[0]);
+            this.stream.detach(this.$videoBackground[0]);
         }
 
         this.stream = stream;
         }
 
         stream.attach(this.$video[0]);
-        let flipX = stream.isLocal() && this.localFlipX;
+        stream.attach(this.$videoBackground[0]);
+
+        this._hideVideoBackground();
+
+        const flipX = stream.isLocal() && this.localFlipX;
+
         this.$video.css({
             transform: flipX ? 'scaleX(-1)' : 'none'
         });
+        this.$videoBackground.css({
+            transform: flipX ? 'scaleX(-1)' : 'none'
+        });
 
         // Reset the large video background depending on the stream.
         this.setLargeVideoBackground(this.avatarDisplayed);
         this.$video.css({
             transform: this.localFlipX ? 'scaleX(-1)' : 'none'
         });
+
+        this.$videoBackground.css({
+            transform: this.localFlipX ? 'scaleX(-1)' : 'none'
+        });
     }
 
+
     /**
      * Check if current video stream is screen sharing.
      * @returns {boolean}
      */
     showRemoteConnectionProblemIndicator (show) {
         this.$video.toggleClass("remoteVideoProblemFilter", show);
+        this.$videoBackground.toggleClass("remoteVideoProblemFilter", show);
+
         this.$avatar.toggleClass("remoteVideoProblemFilter", show);
     }
 
                 ? "#000" : interfaceConfig.DEFAULT_BACKGROUND);
     }
 
+    /**
+     * Sets the blur background to be invisible and pauses any playing video.
+     *
+     * @private
+     * @returns {void}
+     */
+    _hideVideoBackground() {
+        this.$videoBackground.css({ visibility: 'hidden' });
+        this.$videoBackground[0].pause();
+    }
+
     /**
      * Callback invoked when the video element changes dimensions.
      *
     _onResize() {
         this._resizeListeners.forEach(callback => callback());
     }
+
+    /**
+     * Sets the blur background to be visible and starts any loaded video.
+     *
+     * @private
+     * @returns {void}
+     */
+    _showVideoBackground() {
+        this.$videoBackground.css({ visibility: 'visible' });
+        this.$videoBackground[0].play();
+    }
 }

react/features/conference/components/Conference.web.js

             <div id = 'videoconference_page'>
                 <div id = 'videospace'>
                     <LargeVideo />
-
                     <Filmstrip />
                 </div>
 

react/features/large-video/components/LargeVideo.web.js

                         src = '' />
                 </div>
                 <span id = 'remoteConnectionMessage' />
+                <div className = 'video_blurred_container'>
+                    <video
+                        autoPlay = { true }
+                        className = 'video_blurred'
+                        id = 'largeVideoBackground'
+                        muted = 'true' />
+                </div>
                 <div id = 'largeVideoWrapper'>
                     <video
                         autoPlay = { true }