Audio noise cancellation optionns, video capture resolution control

@@ -11,7 +11,7 @@ buildscript {
 
 
     }
     }
     dependencies {
     dependencies {
-        classpath 'com.android.tools.build:gradle:7.0.0-beta02'
+        classpath 'com.android.tools.build:gradle:7.0.0-beta03'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
         classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
         classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
         classpath "org.jetbrains.dokka:dokka-gradle-plugin:$dokka_version"
         classpath "org.jetbrains.dokka:dokka-gradle-plugin:$dokka_version"

@@ -22,7 +22,6 @@ constructor(
 ) {
 ) {
     val peerConnection: PeerConnection = connectionFactory.createPeerConnection(
     val peerConnection: PeerConnection = connectionFactory.createPeerConnection(
         config,
         config,
-        RTCEngine.CONN_CONSTRAINTS,
         listener
         listener
     ) ?: throw IllegalStateException("peer connection creation failed?")
     ) ?: throw IllegalStateException("peer connection creation failed?")
     val pendingCandidates = mutableListOf<IceCandidate>()
     val pendingCandidates = mutableListOf<IceCandidate>()

@@ -225,6 +225,7 @@ constructor(
         val rtcConfig = PeerConnection.RTCConfiguration(iceServers).apply {
         val rtcConfig = PeerConnection.RTCConfiguration(iceServers).apply {
             sdpSemantics = PeerConnection.SdpSemantics.UNIFIED_PLAN
             sdpSemantics = PeerConnection.SdpSemantics.UNIFIED_PLAN
             continualGatheringPolicy = PeerConnection.ContinualGatheringPolicy.GATHER_CONTINUALLY
             continualGatheringPolicy = PeerConnection.ContinualGatheringPolicy.GATHER_CONTINUALLY
+            enableDtlsSrtp = true
         }
         }
 
 
         publisher = pctFactory.create(rtcConfig, publisherObserver)
         publisher = pctFactory.create(rtcConfig, publisherObserver)

@@ -33,19 +33,30 @@ internal constructor(
         get() = tracks.values.toList()
         get() = tracks.values.toList()
 
 
     fun createAudioTrack(
     fun createAudioTrack(
-        audioConstraints: MediaConstraints = MediaConstraints(),
-        name: String = ""
-    ) = LocalAudioTrack.createTrack(peerConnectionFactory, audioConstraints, name)
+        name: String = "",
+        options: LocalAudioTrackOptions = LocalAudioTrackOptions(),
+    ): LocalAudioTrack {
+        val audioConstraints = MediaConstraints()
+        val items = listOf(
+            MediaConstraints.KeyValuePair("googEchoCancellation", options.echoCancellation.toString()),
+            MediaConstraints.KeyValuePair("googAutoGainControl", options.autoGainControl.toString()),
+            MediaConstraints.KeyValuePair("googHighpassFilter", options.highPassFilter.toString()),
+            MediaConstraints.KeyValuePair("googNoiseSuppression", options.noiseSuppression.toString()),
+            MediaConstraints.KeyValuePair("googTypingNoiseDetection", options.typingNoiseDetection.toString()),
+        )
+//        audioConstraints.optional.addAll(items)
+        return LocalAudioTrack.createTrack(peerConnectionFactory, audioConstraints, name)
+    }
 
 
     fun createVideoTrack(
     fun createVideoTrack(
-        isScreencast: Boolean = false,
         name: String = "",
         name: String = "",
+        options: LocalVideoTrackOptions = LocalVideoTrackOptions(),
     ): LocalVideoTrack {
     ): LocalVideoTrack {
         return LocalVideoTrack.createTrack(
         return LocalVideoTrack.createTrack(
             peerConnectionFactory,
             peerConnectionFactory,
             context,
             context,
-            isScreencast,
             name,
             name,
+            options,
             eglBase
             eglBase
         )
         )
     }
     }

-package io.livekit.android.room.track
-
-class AudioOptions {
-}

@@ -5,5 +5,4 @@ import org.webrtc.AudioTrack
 
 
 open class AudioTrack(name: String, override val rtcTrack: AudioTrack) :
 open class AudioTrack(name: String, override val rtcTrack: AudioTrack) :
     Track(name, Kind.AUDIO, rtcTrack) {
     Track(name, Kind.AUDIO, rtcTrack) {
-
 }
 }

@@ -11,7 +11,6 @@ import java.util.*
  */
  */
 class LocalAudioTrack(
 class LocalAudioTrack(
     name: String,
     name: String,
-    audioOptions: AudioOptions? = null,
     mediaTrack: org.webrtc.AudioTrack
     mediaTrack: org.webrtc.AudioTrack
 ) : AudioTrack(name, mediaTrack) {
 ) : AudioTrack(name, mediaTrack) {
     var enabled: Boolean
     var enabled: Boolean
@@ -20,16 +19,12 @@ class LocalAudioTrack(
             rtcTrack.setEnabled(value)
             rtcTrack.setEnabled(value)
         }
         }
 
 
-    var audioOptions = audioOptions
-        private set
-
     companion object {
     companion object {
         internal fun createTrack(
         internal fun createTrack(
             factory: PeerConnectionFactory,
             factory: PeerConnectionFactory,
             audioConstraints: MediaConstraints = MediaConstraints(),
             audioConstraints: MediaConstraints = MediaConstraints(),
             name: String = ""
             name: String = ""
         ): LocalAudioTrack {
         ): LocalAudioTrack {
-
             val audioSource = factory.createAudioSource(audioConstraints)
             val audioSource = factory.createAudioSource(audioConstraints)
             val rtcAudioTrack =
             val rtcAudioTrack =
                 factory.createAudioTrack(UUID.randomUUID().toString(), audioSource)
                 factory.createAudioTrack(UUID.randomUUID().toString(), audioSource)

+package io.livekit.android.room.track
+
+class LocalAudioTrackOptions(
+    var noiseSuppression: Boolean = true,
+    var echoCancellation: Boolean = true,
+    var autoGainControl: Boolean = true,
+    var highPassFilter: Boolean = true,
+    var typingNoiseDetection: Boolean = true,
+)

@@ -14,10 +14,11 @@ class LocalVideoTrack(
     private val capturer: VideoCapturer,
     private val capturer: VideoCapturer,
     private val source: VideoSource,
     private val source: VideoSource,
     name: String,
     name: String,
+    private val options: LocalVideoTrackOptions,
     rtcTrack: org.webrtc.VideoTrack
     rtcTrack: org.webrtc.VideoTrack
 ) : VideoTrack(name, rtcTrack) {
 ) : VideoTrack(name, rtcTrack) {
     fun startCapture() {
     fun startCapture() {
-        capturer.startCapture(400, 400, 30)
+        capturer.startCapture(options.captureParams.width, options.captureParams.height, options.captureParams.maxFps)
     }
     }
 
 
     override fun stop() {
     override fun stop() {
@@ -29,12 +30,12 @@ class LocalVideoTrack(
         internal fun createTrack(
         internal fun createTrack(
             peerConnectionFactory: PeerConnectionFactory,
             peerConnectionFactory: PeerConnectionFactory,
             context: Context,
             context: Context,
-            isScreencast: Boolean,
             name: String,
             name: String,
+            options: LocalVideoTrackOptions,
             rootEglBase: EglBase,
             rootEglBase: EglBase,
         ): LocalVideoTrack {
         ): LocalVideoTrack {
-            val source = peerConnectionFactory.createVideoSource(isScreencast)
-            val capturer = createVideoCapturer(context) ?: TODO()
+            val source = peerConnectionFactory.createVideoSource(options.isScreencast)
+            val capturer = createVideoCapturer(context, options.position) ?: TODO()
             capturer.initialize(
             capturer.initialize(
                 SurfaceTextureHelper.create("VideoCaptureThread", rootEglBase.eglBaseContext),
                 SurfaceTextureHelper.create("VideoCaptureThread", rootEglBase.eglBaseContext),
                 context,
                 context,
@@ -45,16 +46,17 @@ class LocalVideoTrack(
             return LocalVideoTrack(
             return LocalVideoTrack(
                 capturer = capturer,
                 capturer = capturer,
                 source = source,
                 source = source,
+                options = options,
                 name = name,
                 name = name,
                 rtcTrack = track,
                 rtcTrack = track,
             )
             )
         }
         }
 
 
-        private fun createVideoCapturer(context: Context): VideoCapturer? {
+        private fun createVideoCapturer(context: Context, position: CameraPosition): VideoCapturer? {
             val videoCapturer: VideoCapturer? = if (Camera2Enumerator.isSupported(context)) {
             val videoCapturer: VideoCapturer? = if (Camera2Enumerator.isSupported(context)) {
-                createCameraCapturer(Camera2Enumerator(context))
+                createCameraCapturer(Camera2Enumerator(context), position)
             } else {
             } else {
-                createCameraCapturer(Camera1Enumerator(true))
+                createCameraCapturer(Camera1Enumerator(true), position)
             }
             }
             if (videoCapturer == null) {
             if (videoCapturer == null) {
                 Timber.d { "Failed to open camera" }
                 Timber.d { "Failed to open camera" }
@@ -63,24 +65,18 @@ class LocalVideoTrack(
             return videoCapturer
             return videoCapturer
         }
         }
 
 
-        private fun createCameraCapturer(enumerator: CameraEnumerator): VideoCapturer? {
+        private fun createCameraCapturer(enumerator: CameraEnumerator, position: CameraPosition): VideoCapturer? {
             val deviceNames = enumerator.deviceNames
             val deviceNames = enumerator.deviceNames
 
 
-            // First, try to find front facing camera
             for (deviceName in deviceNames) {
             for (deviceName in deviceNames) {
-                if (enumerator.isFrontFacing(deviceName)) {
+                if (enumerator.isFrontFacing(deviceName) && position == CameraPosition.FRONT) {
                     Timber.v { "Creating front facing camera capturer." }
                     Timber.v { "Creating front facing camera capturer." }
                     val videoCapturer = enumerator.createCapturer(deviceName, null)
                     val videoCapturer = enumerator.createCapturer(deviceName, null)
                     if (videoCapturer != null) {
                     if (videoCapturer != null) {
                         return videoCapturer
                         return videoCapturer
                     }
                     }
-                }
-            }
-
-            // Front facing camera not found, try something else
-            for (deviceName in deviceNames) {
-                if (!enumerator.isFrontFacing(deviceName)) {
-                    Timber.v { "Creating other camera capturer." }
+                } else if (enumerator.isBackFacing(deviceName) && position == CameraPosition.BACK) {
+                    Timber.v { "Creating back facing camera capturer." }
                     val videoCapturer = enumerator.createCapturer(deviceName, null)
                     val videoCapturer = enumerator.createCapturer(deviceName, null)
                     if (videoCapturer != null) {
                     if (videoCapturer != null) {
                         return videoCapturer
                         return videoCapturer

+package io.livekit.android.room.track
+
+class LocalVideoTrackOptions(
+    var isScreencast: Boolean = false,
+    var position: CameraPosition = CameraPosition.FRONT,
+    var captureParams: VideoCaptureParameter = VideoPreset.QHD.capture
+)
+
+class VideoCaptureParameter(
+    val width: Int,
+    val height: Int,
+    val maxFps: Int,
+)
+
+class VideoEncoding(
+    val maxBitrate: Int,
+    val maxFps: Int,
+)
+
+enum class CameraPosition {
+    FRONT,
+    BACK
+}
+
+/**
+ * Video presets along with suggested bitrates
+ */
+enum class VideoPreset(
+    val capture: VideoCaptureParameter,
+    val encoding: VideoEncoding,
+) {
+    QVGA(
+        VideoCaptureParameter(320, 240, 15),
+        VideoEncoding(100_000, 15),
+    ),
+    VGA(
+        VideoCaptureParameter(640, 360, 30),
+        VideoEncoding(400_000, 30),
+    ),
+    QHD(
+        VideoCaptureParameter(960, 540, 30),
+        VideoEncoding(700_000, 30),
+    ),
+    HD(
+        VideoCaptureParameter(1280, 720, 30),
+        VideoEncoding(2_000_000, 30),
+    ),
+    FHD(
+        VideoCaptureParameter(1920, 1080, 30),
+        VideoEncoding(4_000_000, 30),
+    )
+
+}