Publish MediaStream with WebTransport.

Author: jianjunz

src/sdk/base/publication.js

@@ -195,17 +195,29 @@ export class PublishOptions {
   // eslint-disable-next-line require-jsdoc
   constructor(audio, video, transport) {
     /**
-     * @member {?Array<Owt.Base.AudioEncodingParameters> | ?Array<RTCRtpEncodingParameters>} audio
+     * @member {?Array<Owt.Base.AudioEncodingParameters> |
+     * ?Array<RTCRtpEncodingParameters> | ?AudioEncoderConfig } audio
      * @instance
      * @memberof Owt.Base.PublishOptions
-     * @desc Parameters for audio RtpSender. Publishing with RTCRtpEncodingParameters is an experimental feature. It is subject to change.
+     * @desc Parameters for audio RtpSender when transport's type is 'webrtc' or
+     * configuration of audio encoder when transport's type is 'quic'.
+     * Publishing with RTCRtpEncodingParameters is an experimental feature. It
+     * is subject to change.
+     * @see {@link https://www.w3.org/TR/webrtc/#rtcrtpencodingparameters|RTCRtpEncodingParameters}
+     * @see {@link https://w3c.github.io/webcodecs/#dictdef-audioencoderconfig|AudioEncoderConfig}
      */
     this.audio = audio;
     /**
-     * @member {?Array<Owt.Base.VideoEncodingParameters> | ?Array<RTCRtpEncodingParameters>} video
+     * @member {?Array<Owt.Base.VideoEncodingParameters> |
+     * ?Array<RTCRtpEncodingParameters> | ?VideoEncoderConfig } video
      * @instance
      * @memberof Owt.Base.PublishOptions
-     * @desc Parameters for video RtpSender. Publishing with RTCRtpEncodingParameters is an experimental feature. It is subject to change.
+     * @desc Parameters for video RtpSender when transport's type is 'webrtc' or
+     * configuration of video encoder when transport's type is 'quic'.
+     * Publishing with RTCRtpEncodingParameters is an experimental feature. It
+     * is subject to change.
+     * @see {@link https://www.w3.org/TR/webrtc/#rtcrtpencodingparameters|RTCRtpEncodingParameters}
+     * @see {@link https://w3c.github.io/webcodecs/#dictdef-videoencoderconfig|VideoEncoderConfig}
      */
     this.video = video;
     /**

src/sdk/base/transport.js

@@ -29,7 +29,9 @@ export class TransportConstraints {
      * @member {Array.<Owt.Base.TransportType>} type
      * @instance
      * @memberof Owt.Base.TransportConstraints
-     * @desc Transport type for publication and subscription.
+     * @desc Transport type for publication and subscription. 'quic' is only
+     * supported in conference mode when WebTransport is supported by client and
+     * enabled at server side.
      */
     this.type = type;
     /**

src/sdk/conference/client.js

@@ -464,16 +464,16 @@ export const ConferenceClient = function(config, signalingImpl) {
    * @instance
    * @desc Publish a LocalStream to conference server. Other participants will be able to subscribe this stream when it is successfully published.
    * @param {Owt.Base.LocalStream} stream The stream to be published.
-   * @param {(Owt.Base.PublishOptions|RTCRtpTransceiver[])} options If options is a PublishOptions, the stream will be published as options specified. If options is a list of RTCRtpTransceivers, each track in the first argument must have a corresponding RTCRtpTransceiver here, and the track will be published with the RTCRtpTransceiver associated with it.
+   * @param {(Owt.Base.PublishOptions|RTCRtpTransceiver[])} options If options is a PublishOptions, the stream will be published as options specified. If options is a list of RTCRtpTransceivers, each track in the first argument must have a corresponding RTCRtpTransceiver here, and the track will be published with the RTCRtpTransceiver associated with it. If the type of transport is quic, PublishOptions.audio should be AudioEncoderConfig, and PublishOptions.video should be VideoEncoderConfig.
    * @param {string[]} videoCodecs Video codec names for publishing. Valid values are 'VP8', 'VP9' and 'H264'. This parameter only valid when the second argument is PublishOptions and options.video is RTCRtpEncodingParameters. Publishing with RTCRtpEncodingParameters is an experimental feature. This parameter is subject to change.
    * @return {Promise<Publication, Error>} Returned promise will be resolved with a newly created Publication once specific stream is successfully published, or rejected with a newly created Error if stream is invalid or options cannot be satisfied. Successfully published means PeerConnection is established and server is able to process media data.
    */
   this.publish = function(stream, options, videoCodecs) {
     if (!(stream instanceof StreamModule.LocalStream)) {
       return Promise.reject(new ConferenceError('Invalid stream.'));
     }
-    if (stream.source.data) {
-      return quicTransportChannel.publish(stream);
+    if (options?.transport?.type === 'quic') {
+      return quicTransportChannel.publish(stream, options, videoCodecs);
     }
     if (publishChannels.has(stream.mediaStream.id)) {
       return Promise.reject(new ConferenceError(
@@ -501,13 +501,16 @@ export const ConferenceClient = function(config, signalingImpl) {
             'Invalid source info. A remote stream is either a data stream or ' +
             'a media stream.'));
       }
+    }
+    if (options?.transport?.type === 'quic') {
       if (quicTransportChannel) {
-        return quicTransportChannel.subscribe(stream);
+        return quicTransportChannel.subscribe(stream, options);
       } else {
         return Promise.reject(new TypeError('WebTransport is not supported.'));
       }
+    } else {
+      return peerConnectionChannel.subscribe(stream, options);
     }
-    return peerConnectionChannel.subscribe(stream, options);
   };
 
   /**

src/sdk/conference/quicconnection.js

@@ -150,7 +150,7 @@ export class QuicConnection extends EventDispatcher {
     return quicStream;
   }
 
-  async publish(stream) {
+  async publish(stream, options) {
     // TODO: Avoid a stream to be published twice. The first 16 bit data send to
     // server must be it's publication ID.
     // TODO: Potential failure because of publication stream is created faster
@@ -161,12 +161,12 @@ export class QuicConnection extends EventDispatcher {
     await writer.ready;
     writer.write(this._uuidToUint8Array(publicationId));
     writer.releaseLock();
-    Logger.info('publish id');
     this._quicStreams.set(publicationId, quicStream);
     const publication = new Publication(publicationId, () => {
       this._signaling.sendSignalingMessage('unpublish', {id: publication})
           .catch((e) => {
-            Logger.warning('MCU returns negative ack for unpublishing, ' + e);
+            Logger.warning(
+                'Server returns negative ack for unpublishing, ' + e);
           });
     } /* TODO: getStats, mute, unmute is not implemented */);
     return publication;
@@ -196,7 +196,7 @@ export class QuicConnection extends EventDispatcher {
     return s;
   }
 
-  subscribe(stream) {
+  subscribe(stream, options) {
     const p = new Promise((resolve, reject) => {
       this._signaling
           .sendSignalingMessage('subscribe', {
@@ -231,10 +231,45 @@ export class QuicConnection extends EventDispatcher {
     });
   }
 
-  async _initiatePublication() {
+  async _initiatePublication(stream, options) {
+    const media = {tracks: []};
+    if (stream.source.audio) {
+      if (!options.audio) {
+        throw new TypeError(
+            'Options for audio is missing. Publish audio track with ' +
+            'WebTransport must have AudioEncoderConfig specified.');
+      }
+      const track = {
+        source: stream.id,
+        type: 'audio',
+        format: {
+          codec: options.audio.codec,
+          sampleRate: options.audio.sampleRate,
+          channelNum: options.audio.numberOfChannels,
+        },
+      };
+      media.tracks.push(track);
+    }
+    if (stream.source.video) {
+      if (!options.video) {
+        throw new TypeError(
+            'Options for audio is missing. Publish video track with ' +
+            'WebTransport must have VideoEncoderConfig specified.');
+      }
+      const track = {
+        source: stream.id,
+        type: 'video',
+        // TODO: convert from MIME type to the format required by server.
+        format: {
+          codec: 'h264',
+          profile: 'B',
+        },
+      };
+      media.tracks.push(track);
+    }
     const data = await this._signaling.sendSignalingMessage('publish', {
-      media: null,
-      data: true,
+      media: stream.source.data ? null : media,
+      data: stream.source.data,
       transport: {type: 'quic', id: this._transportId},
     });
     if (this._transportId !== data.transportId) {