Default to software codecs for vp9 (#300)

* Default to software codecs for vp9

* Spotless

@@ -27,7 +27,8 @@ import io.livekit.android.LiveKit
 import io.livekit.android.memory.CloseableManager
 import io.livekit.android.memory.CloseableManager
 import io.livekit.android.util.LKLog
 import io.livekit.android.util.LKLog
 import io.livekit.android.util.LoggingLevel
 import io.livekit.android.util.LoggingLevel
-import io.livekit.android.webrtc.SimulcastVideoEncoderFactoryWrapper
+import io.livekit.android.webrtc.CustomVideoDecoderFactory
+import io.livekit.android.webrtc.CustomVideoEncoderFactory
 import org.webrtc.*
 import org.webrtc.*
 import org.webrtc.audio.AudioDeviceModule
 import org.webrtc.audio.AudioDeviceModule
 import org.webrtc.audio.JavaAudioDeviceModule
 import org.webrtc.audio.JavaAudioDeviceModule
@@ -195,7 +196,7 @@ object RTCModule {
         videoEncoderFactoryOverride: VideoEncoderFactory?,
         videoEncoderFactoryOverride: VideoEncoderFactory?,
     ): VideoEncoderFactory {
     ): VideoEncoderFactory {
         return videoEncoderFactoryOverride ?: if (videoHwAccel) {
         return videoEncoderFactoryOverride ?: if (videoHwAccel) {
-            SimulcastVideoEncoderFactoryWrapper(
+            CustomVideoEncoderFactory(
                 eglContext,
                 eglContext,
                 enableIntelVp8Encoder = true,
                 enableIntelVp8Encoder = true,
                 enableH264HighProfile = false,
                 enableH264HighProfile = false,
@@ -218,7 +219,7 @@ object RTCModule {
         videoDecoderFactoryOverride: VideoDecoderFactory?,
         videoDecoderFactoryOverride: VideoDecoderFactory?,
     ): VideoDecoderFactory {
     ): VideoDecoderFactory {
         return videoDecoderFactoryOverride ?: if (videoHwAccel) {
         return videoDecoderFactoryOverride ?: if (videoHwAccel) {
-            WrappedVideoDecoderFactory(eglContext)
+            CustomVideoDecoderFactory(eglContext)
         } else {
         } else {
             SoftwareVideoDecoderFactory()
             SoftwareVideoDecoderFactory()
         }
         }

+/*
+ * Copyright 2023 LiveKit, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.livekit.android.webrtc
+
+import org.webrtc.EglBase
+import org.webrtc.SoftwareVideoDecoderFactory
+import org.webrtc.VideoCodecInfo
+import org.webrtc.VideoDecoder
+import org.webrtc.VideoDecoderFactory
+import org.webrtc.WrappedVideoDecoderFactory
+
+class CustomVideoDecoderFactory(
+    sharedContext: EglBase.Context?,
+    private var forceSWCodec: Boolean = false,
+    private var forceSWCodecs: List<String> = listOf("VP9"),
+) : VideoDecoderFactory {
+    private val softwareVideoDecoderFactory = SoftwareVideoDecoderFactory()
+    private val wrappedVideoDecoderFactory = WrappedVideoDecoderFactory(sharedContext)
+
+    fun setForceSWCodec(forceSWCodec: Boolean) {
+        this.forceSWCodec = forceSWCodec
+    }
+
+    fun setForceSWCodecList(forceSWCodecs: List<String>) {
+        this.forceSWCodecs = forceSWCodecs
+    }
+
+    override fun createDecoder(videoCodecInfo: VideoCodecInfo): VideoDecoder? {
+        if (forceSWCodec) {
+            return softwareVideoDecoderFactory.createDecoder(videoCodecInfo)
+        }
+        if (forceSWCodecs.isNotEmpty()) {
+            if (forceSWCodecs.contains(videoCodecInfo.name)) {
+                return softwareVideoDecoderFactory.createDecoder(videoCodecInfo)
+            }
+        }
+        return wrappedVideoDecoderFactory.createDecoder(videoCodecInfo)
+    }
+
+    override fun getSupportedCodecs(): Array<VideoCodecInfo> {
+        return if (forceSWCodec && forceSWCodecs.isEmpty()) {
+            softwareVideoDecoderFactory.supportedCodecs
+        } else {
+            wrappedVideoDecoderFactory.supportedCodecs
+        }
+    }
+}

+/*
+ * Copyright 2023 LiveKit, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.livekit.android.webrtc
+
+import org.webrtc.EglBase
+import org.webrtc.SoftwareVideoEncoderFactory
+import org.webrtc.VideoCodecInfo
+import org.webrtc.VideoEncoder
+import org.webrtc.VideoEncoderFactory
+
+class CustomVideoEncoderFactory(
+    sharedContext: EglBase.Context?,
+    enableIntelVp8Encoder: Boolean,
+    enableH264HighProfile: Boolean,
+    private var forceSWCodec: Boolean = false,
+    private var forceSWCodecs: List<String> = listOf("VP9"),
+) : VideoEncoderFactory {
+    private val softwareVideoEncoderFactory = SoftwareVideoEncoderFactory()
+    private val simulcastVideoEncoderFactoryWrapper: SimulcastVideoEncoderFactoryWrapper
+
+    init {
+        simulcastVideoEncoderFactoryWrapper =
+            SimulcastVideoEncoderFactoryWrapper(sharedContext, enableIntelVp8Encoder, enableH264HighProfile)
+    }
+
+    fun setForceSWCodec(forceSWCodec: Boolean) {
+        this.forceSWCodec = forceSWCodec
+    }
+
+    fun setForceSWCodecList(forceSWCodecs: List<String>) {
+        this.forceSWCodecs = forceSWCodecs
+    }
+
+    override fun createEncoder(videoCodecInfo: VideoCodecInfo): VideoEncoder? {
+        if (forceSWCodec) {
+            return softwareVideoEncoderFactory.createEncoder(videoCodecInfo)
+        }
+        if (forceSWCodecs.isNotEmpty()) {
+            if (forceSWCodecs.contains(videoCodecInfo.name)) {
+                return softwareVideoEncoderFactory.createEncoder(videoCodecInfo)
+            }
+        }
+        return simulcastVideoEncoderFactoryWrapper.createEncoder(videoCodecInfo)
+    }
+
+    override fun getSupportedCodecs(): Array<VideoCodecInfo> {
+        return if (forceSWCodec && forceSWCodecs.isEmpty()) {
+            softwareVideoEncoderFactory.supportedCodecs
+        } else {
+            simulcastVideoEncoderFactoryWrapper.supportedCodecs
+        }
+    }
+}