feat: Add RTCRtpCapabilities interface.

CHANGELOG.md

@@ -1,6 +1,10 @@
 # Changelog
 
 --------------------------------------------
+[1.0.11] - 2023-01-30
+
+* Add RTCRtpCapabilities interface.
+
 [1.0.10] - 2022-11-12
 
 * Change MediaStream.clone to async.

lib/src/factory.dart

@@ -2,6 +2,7 @@ import 'media_recorder.dart';
 import 'media_stream.dart';
 import 'navigator.dart';
 import 'rtc_peerconnection.dart';
+import 'rtc_rtp_capabilities.dart';
 import 'rtc_video_renderer.dart';
 
 abstract class RTCFactory {
@@ -11,6 +12,10 @@ abstract class RTCFactory {
 
   Future<MediaStream> createLocalMediaStream(String label);
 
+  Future<RTCRtpCapabilities> getRtpSenderCapabilities(String kind);
+
+  Future<RTCRtpCapabilities> getRtpReceiverCapabilities(String kind);
+
   MediaRecorder mediaRecorder();
 
   VideoRenderer videoRenderer();

lib/src/rtc_rtp_capabilities.dart

@@ -0,0 +1,76 @@
+class RTCRtpCodecCapability {
+  RTCRtpCodecCapability(
+      {this.channels,
+      required this.clockRate,
+      required this.mimeType,
+      this.sdpFmtpLine});
+  factory RTCRtpCodecCapability.fromMap(Map<dynamic, dynamic> map) {
+    return RTCRtpCodecCapability(
+      channels: map['channels'],
+      clockRate: map['clockRate'],
+      mimeType: map['mimeType'],
+      sdpFmtpLine: map['sdpFmtpLine'],
+    );
+  }
+  num? channels;
+  num clockRate;
+  String mimeType;
+  String? sdpFmtpLine;
+  Map<String, dynamic> toMap() {
+    return {
+      if (channels != null) 'channels': channels,
+      'clockRate': clockRate,
+      'mimeType': mimeType,
+      if (sdpFmtpLine != null) 'sdpFmtpLine': sdpFmtpLine,
+    };
+  }
+}
+
+class RTCRtpHeaderExtensionCapability {
+  RTCRtpHeaderExtensionCapability(this.uri);
+  factory RTCRtpHeaderExtensionCapability.fromMap(Map<dynamic, dynamic> map) {
+    return RTCRtpHeaderExtensionCapability(map['uri']);
+  }
+  String uri;
+  Map<dynamic, dynamic> toMap() {
+    return {
+      'uri': uri,
+    };
+  }
+}
+
+class RTCRtpCapabilities {
+  RTCRtpCapabilities({this.codecs, this.headerExtensions, this.fecMechanisms});
+  factory RTCRtpCapabilities.fromMap(Map<dynamic, dynamic> map) {
+    var codecs = <RTCRtpCodecCapability>[];
+    dynamic codecsMap = map['codecs'];
+    codecsMap.forEach((params) {
+      codecs.add(RTCRtpCodecCapability.fromMap(params));
+    });
+    var headerExtensions = <RTCRtpHeaderExtensionCapability>[];
+    dynamic headerExtensionsMap = map['headerExtensions'];
+    headerExtensionsMap.forEach((params) {
+      headerExtensions.add(RTCRtpHeaderExtensionCapability.fromMap(params));
+    });
+    var fecMechanisms = <String>[];
+    dynamic fecMechanismsMap = map['fecMechanisms'];
+    fecMechanismsMap.forEach((params) {
+      fecMechanisms.add(params);
+    });
+    return RTCRtpCapabilities(
+        codecs: codecs,
+        headerExtensions: headerExtensions,
+        fecMechanisms: fecMechanisms);
+  }
+  List<RTCRtpCodecCapability>? codecs;
+  List<RTCRtpHeaderExtensionCapability>? headerExtensions;
+  List<String>? fecMechanisms;
+
+  Map<String, dynamic> toMap() {
+    return {
+      'codecs': codecs?.map((e) => e.toMap()).toList(),
+      'headerExtensions': headerExtensions?.map((e) => e.toMap()).toList(),
+      if (fecMechanisms != null) 'fecMechanisms': fecMechanisms,
+    };
+  }
+}

lib/src/rtc_rtp_parameters.dart

@@ -58,6 +58,7 @@ class RTCRtpEncoding {
     this.numTemporalLayers = 1,
     this.scaleResolutionDownBy = 1.0,
     this.ssrc,
+    this.scalabilityMode,
   });
 
   factory RTCRtpEncoding.fromMap(Map<dynamic, dynamic> map) => RTCRtpEncoding(
@@ -69,6 +70,7 @@ class RTCRtpEncoding {
         numTemporalLayers: map['numTemporalLayers'],
         scaleResolutionDownBy: map['scaleResolutionDownBy'],
         ssrc: map['ssrc'],
+        scalabilityMode: map['scalabilityMode'],
       );
 
   /// If non-null, this represents the RID that identifies this encoding layer.
@@ -101,6 +103,8 @@ class RTCRtpEncoding {
   /// Can't be changed between getParameters/setParameters.
   int? ssrc;
 
+  String? scalabilityMode;
+
   Map<String, dynamic> toMap() => {
         'active': active,
         if (rid != null) 'rid': rid,
@@ -110,6 +114,7 @@ class RTCRtpEncoding {
         if (numTemporalLayers != null) 'numTemporalLayers': numTemporalLayers,
         if (scaleResolutionDownBy != null)
           'scaleResolutionDownBy': scaleResolutionDownBy,
+        if (scalabilityMode != null) 'scalabilityMode': scalabilityMode,
         if (ssrc != null) 'ssrc': ssrc,
       };
 }

lib/src/rtc_rtp_transceiver.dart

@@ -2,6 +2,7 @@ import 'dart:async';
 
 import 'enums.dart';
 import 'media_stream.dart';
+import 'rtc_rtp_capabilities.dart';
 import 'rtc_rtp_parameters.dart';
 import 'rtc_rtp_receiver.dart';
 import 'rtc_rtp_sender.dart';
@@ -30,6 +31,8 @@ abstract class RTCRtpTransceiver {
 
   Future<TransceiverDirection> getDirection();
 
+  Future<void> setCodecPreferences(List<RTCRtpCodecCapability> codecs);
+
   String get mid;
 
   RTCRtpSender get sender;

lib/webrtc_interface.dart

@@ -12,6 +12,7 @@ export 'src/rtc_dtmf_sender.dart';
 export 'src/rtc_ice_candidate.dart';
 export 'src/rtc_peerconnection.dart';
 export 'src/rtc_rtcp_parameters.dart';
+export 'src/rtc_rtp_capabilities.dart';
 export 'src/rtc_rtp_parameters.dart';
 export 'src/rtc_rtp_receiver.dart';
 export 'src/rtc_rtp_sender.dart';

pubspec.yaml

@@ -1,6 +1,6 @@
 name: webrtc_interface
 description: WebRTC Interface for Dart-Web/Flutter.
-version: 1.0.10
+version: 1.0.11
 homepage: https://flutter-webrtc.org
 
 environment: