Adds dominant speaker detection on p2p sessions.

Dominant speaker detection which is just based on current audio level of local or remote p2p track. The threshold value is the same used for talk while muted detection.

JitsiConference.js

 import * as MediaType from './service/RTC/MediaType';
 import ParticipantConnectionStatusHandler
     from './modules/connectivity/ParticipantConnectionStatus';
+import P2PDominantSpeakerDetection from './modules/P2PDominantSpeakerDetection';
 import RTC from './modules/RTC/RTC';
 import RTCBrowserType from './modules/RTC/RTCBrowserType';
 import * as RTCEvents from './service/RTC/RTCEvents';
     if ('channelLastN' in options.config) {
         this.setLastN(options.config.channelLastN);
     }
+
+    // creates dominant speaker detection that works only in p2p mode
+    this.p2pDominantSpeakerDetection = new P2PDominantSpeakerDetection(this);
 };
 
 /**

modules/P2PDominantSpeakerDetection.js

+import * as JitsiConferenceEvents from '../JitsiConferenceEvents';
+
+/**
+ * The value which we use to say, every sound over this threshold
+ * is talking on the mic.
+ * @type {number}
+ */
+const SPEECH_DETECT_THRESHOLD = 0.6;
+
+/**
+ * The <tt>P2PDominantSpeakerDetection</tt> is activated only when p2p is
+ * currently used.
+ * Listens for changes in the audio level changes of the local p2p audio track
+ * or remote p2p one and fires dominant speaker events to be able to use
+ * features depending on those events (speaker stats), to make them work without
+ * the video bridge.
+ */
+export default class P2PDominantSpeakerDetection {
+    /**
+     * Creates P2PDominantSpeakerDetection
+     * @param conference the JitsiConference instance that created us.
+     * @constructor
+     */
+    constructor(conference) {
+        this.conference = conference;
+
+        conference.addEventListener(
+            JitsiConferenceEvents.TRACK_AUDIO_LEVEL_CHANGED,
+            this._audioLevel.bind(this));
+
+        this.myUserID = this.conference.myUserId();
+    }
+
+    /**
+     * Receives audio level events for all streams in the conference.
+     *
+     * @param {String} id - The participant id
+     * @param {number} audioLevel - The audio level.
+     */
+    _audioLevel(id, audioLevel) {
+
+        // we do not process if p2p is not active
+        // or audio level is under certain threshold
+        // or if the audio level is for local audio track which is muted
+        if (!this.conference.isP2PActive()
+            || audioLevel <= SPEECH_DETECT_THRESHOLD
+            || (id === this.myUserID
+                    && this.conference.getLocalAudioTrack().isMuted())) {
+            return;
+        }
+
+        this.conference.eventEmitter.emit(
+            JitsiConferenceEvents.DOMINANT_SPEAKER_CHANGED,
+            id);
+    }
+}

modules/TalkMutedDetection.js

 import * as JitsiConferenceEvents from '../JitsiConferenceEvents';
 
 /**
- *
+ * The value which we use to say, every sound over this threshold
+ * is talking on the mic.
+ * @type {number}
+ */
+const SPEECH_DETECT_THRESHOLD = 0.6;
+
+/**
+ * Detect user trying to speek while is locally muted and fires an event.
  */
 export default class TalkMutedDetection {
     /**
     /**
      * Receives audio level events for all send and receive streams.
      *
-     * @param pc - WebRTC PeerConnection object of the
-     * @param ssrc - The synchronization source identifier (SSRC) of the
-     * endpoint/participant/stream being reported.
+     * @param {TraceablePeerConnection} pc - WebRTC PeerConnection object of the
+     * @param {number} ssrc - The synchronization source identifier (SSRC) of
+     * the endpoint/participant/stream being reported.
      * @param {number} audioLevel - The audio level of <tt>ssrc</tt>.
      * @param {boolean} isLocal - <tt>true</tt> if <tt>ssrc</tt> represents a
      * local/send stream or <tt>false</tt> for a remote/receive stream.
      */
-    _audioLevel(pc, ssrc, audioLevel, isLocal) {
+    _audioLevel(tpc, ssrc, audioLevel, isLocal) {
         // We are interested in the local audio stream only and if event is not
         // sent yet.
         if (!isLocal || !this.audioTrack || this._eventFired) {
             return;
         }
 
-        if (this.audioTrack.isMuted() && audioLevel > 0.6) {
+        if (this.audioTrack.isMuted()
+            && audioLevel > SPEECH_DETECT_THRESHOLD) {
             this._eventFired = true;
             this._callback();
         }