fix(codec-selection): Include visitor codecs.

Include visitor codecs published by Jicofo while calculating the intersection set for the conference.

JitsiConference.js

             }
         });
 
+        // Handle changes to aggregate list of visitor codecs.
+        let publishedCodecs = this.properties['visitor-codecs']?.split(',');
+
+        if (publishedCodecs?.length) {
+            publishedCodecs = publishedCodecs.filter(codec => typeof codec === 'string'
+                && codec.trim().length
+                && Object.values(CodecMimeType).find(val => val === codec));
+        }
+
+        if (this._visitorCodecs !== publishedCodecs) {
+            this._visitorCodecs = publishedCodecs;
+            this.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_VISITOR_CODECS_CHANGED, this._visitorCodecs);
+        }
+
         const oldValue = this._hasVisitors;
 
         this._hasVisitors = this.properties['visitor-count'] > 0;

JitsiConferenceEvents.spec.ts

         CONFERENCE_JOINED,
         CONFERENCE_LEFT,
         CONFERENCE_UNIQUE_ID_SET,
+        CONFERENCE_VISITOR_CODECS_CHANGED,
         CONNECTION_ESTABLISHED,
         CONNECTION_INTERRUPTED,
         CONNECTION_RESTORED,
         expect( CONFERENCE_JOINED ).toBe( 'conference.joined' );
         expect( CONFERENCE_LEFT ).toBe( 'conference.left' );
         expect( CONFERENCE_UNIQUE_ID_SET ).toBe( 'conference.unique_id_set' );
+        expect( CONFERENCE_VISITOR_CODECS_CHANGED ).toBe( 'conference.visitor_codecs_changed' );
         expect( CONNECTION_ESTABLISHED ).toBe( 'conference.connectionEstablished' );
         expect( CONNECTION_INTERRUPTED ).toBe( 'conference.connectionInterrupted' );
         expect( CONNECTION_RESTORED ).toBe( 'conference.connectionRestored' );

JitsiConferenceEvents.ts

      */
     CONFERENCE_UNIQUE_ID_SET = 'conference.unique_id_set',
 
+    /**
+     * Indicates that the aggregate set of codecs supported by the visitors has changed.
+     */
+    CONFERENCE_VISITOR_CODECS_CHANGED = 'conference.visitor_codecs_changed',
+
     /**
      * Indicates that the connection to the conference has been established
      * XXX This is currently fired when the *ICE* connection enters 'connected'
 export const CONFERENCE_JOINED = JitsiConferenceEvents.CONFERENCE_JOINED;
 export const CONFERENCE_LEFT = JitsiConferenceEvents.CONFERENCE_LEFT;
 export const CONFERENCE_UNIQUE_ID_SET = JitsiConferenceEvents.CONFERENCE_UNIQUE_ID_SET;
+export const CONFERENCE_VISITOR_CODECS_CHANGED = JitsiConferenceEvents.CONFERENCE_VISITOR_CODECS_CHANGED;
 export const CONNECTION_ESTABLISHED = JitsiConferenceEvents.CONNECTION_ESTABLISHED;
 export const CONNECTION_INTERRUPTED = JitsiConferenceEvents.CONNECTION_INTERRUPTED;
 export const CONNECTION_RESTORED = JitsiConferenceEvents.CONNECTION_RESTORED;

modules/RTC/CodecSelection.js

         this.conference = conference;
         this.options = options;
         this.codecPreferenceOrder = {};
+        this.visitorCodecs = [];
 
         for (const connectionType of Object.keys(options)) {
             // eslint-disable-next-line prefer-const
         this.conference.on(
             JitsiConferenceEvents._MEDIA_SESSION_STARTED,
             session => this._selectPreferredCodec(session));
+        this.conference.on(
+            JitsiConferenceEvents.CONFERENCE_VISITOR_CODECS_CHANGED,
+            codecList => this._updateVisitorCodecs(codecList));
         this.conference.on(
             JitsiConferenceEvents.USER_JOINED,
             () => this._selectPreferredCodec());
             return [];
         });
 
+        // Include the visitor codecs.
+        this.visitorCodecs.length && remoteCodecsPerParticipant.push(this.visitorCodecs);
+
         const selectedCodecOrder = localPreferredCodecOrder.reduce((acc, localCodec) => {
             let codecNotSupportedByRemote = false;
 
         }
     }
 
+    /**
+     * Updates the aggregate list of the codecs supported by all the visitors in the call and calculates the
+     * selected codec if needed.
+     * @param {Array} codecList - visitor codecs.
+     * @returns {void}
+     */
+    _updateVisitorCodecs(codecList) {
+        if (this.visitorCodecs === codecList) {
+            return;
+        }
+
+        this.visitorCodecs = codecList;
+        this._selectPreferredCodec();
+    }
+
     /**
      * Returns the current codec preference order for the given connection type.
      *