SVC Codec support (#304)

* SDP munging

* track bitrates

* Switch to using android-jain-sip-ri for sdp munging

* Update protocol version

* add support for svc codec

* Backup codec support

* handle pong response

* multi codec publishing

* test for multicodec

* Add LiveKit.init convenience function for e2e testing

* spotless apply

@@ -29,7 +29,7 @@ jobs:
         path: ./client-sdk-android
         path: ./client-sdk-android
         submodules: recursive
         submodules: recursive
 
 
-    - name: set up JDK 12
+    - name: set up JDK 17
       uses: actions/setup-java@v3.12.0
       uses: actions/setup-java@v3.12.0
       with:
       with:
         java-version: '17'
         java-version: '17'

 <component name="ProjectDictionaryState">
 <component name="ProjectDictionaryState">
   <dictionary name="davidliu">
   <dictionary name="davidliu">
     <words>
     <words>
+      <w>bitrates</w>
       <w>capturer</w>
       <w>capturer</w>
+      <w>exts</w>
+      <w>msid</w>
     </words>
     </words>
   </dictionary>
   </dictionary>
 </component>
 </component>

@@ -21,4 +21,28 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 See the License for the specific language governing permissions and
 limitations under the License.
 limitations under the License.
 
 
-#####################################################################################
+#####################################################################################
+
+The following modifications follow MIT License from https://github.com/ggarber/sdpparser
+
+MIT License
+
+Copyright (c) 2023 Gustavo Garcia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

@@ -150,6 +150,8 @@ dependencies {
     implementation "androidx.core:core:${versions.androidx_core}"
     implementation "androidx.core:core:${versions.androidx_core}"
     implementation "com.google.protobuf:protobuf-javalite:${versions.protobuf}"
     implementation "com.google.protobuf:protobuf-javalite:${versions.protobuf}"
 
 
+    implementation 'javax.sip:android-jain-sip-ri:1.3.0-91'
+
     implementation "com.google.dagger:dagger:${versions.dagger}"
     implementation "com.google.dagger:dagger:${versions.dagger}"
     kapt "com.google.dagger:dagger-compiler:${versions.dagger}"
     kapt "com.google.dagger:dagger-compiler:${versions.dagger}"
 
 

@@ -19,6 +19,7 @@ package io.livekit.android
 import android.app.Application
 import android.app.Application
 import android.content.Context
 import android.content.Context
 import io.livekit.android.dagger.DaggerLiveKitComponent
 import io.livekit.android.dagger.DaggerLiveKitComponent
+import io.livekit.android.dagger.RTCModule
 import io.livekit.android.dagger.create
 import io.livekit.android.dagger.create
 import io.livekit.android.room.ProtocolVersion
 import io.livekit.android.room.ProtocolVersion
 import io.livekit.android.room.Room
 import io.livekit.android.room.Room
@@ -60,6 +61,16 @@ class LiveKit {
         var enableWebRTCLogging: Boolean = false
         var enableWebRTCLogging: Boolean = false
 
 
         /**
         /**
+         * Certain WebRTC classes need to be initialized prior to use.
+         *
+         * This does not need to be called under normal circumstances, as [LiveKit.create]
+         * will handle this for you.
+         */
+        fun init(appContext: Context) {
+            RTCModule.libWebrtcInitialization(appContext)
+        }
+
+        /**
          * Create a Room object.
          * Create a Room object.
          */
          */
         fun create(
         fun create(
@@ -93,6 +104,7 @@ class LiveKit {
                 room.videoTrackPublishDefaults = it
                 room.videoTrackPublishDefaults = it
             }
             }
             room.adaptiveStream = options.adaptiveStream
             room.adaptiveStream = options.adaptiveStream
+            room.dynacast = options.dynacast
 
 
             return room
             return room
         }
         }
@@ -110,7 +122,7 @@ class LiveKit {
             options: ConnectOptions = ConnectOptions(),
             options: ConnectOptions = ConnectOptions(),
             roomOptions: RoomOptions = RoomOptions(),
             roomOptions: RoomOptions = RoomOptions(),
             listener: RoomListener? = null,
             listener: RoomListener? = null,
-            overrides: LiveKitOverrides = LiveKitOverrides()
+            overrides: LiveKitOverrides = LiveKitOverrides(),
         ): Room {
         ): Room {
             val room = create(appContext, roomOptions, overrides)
             val room = create(appContext, roomOptions, overrides)
 
 

@@ -17,6 +17,7 @@
 package io.livekit.android.dagger
 package io.livekit.android.dagger
 
 
 import android.content.Context
 import android.content.Context
+import android.javax.sdp.SdpFactory
 import android.media.AudioAttributes
 import android.media.AudioAttributes
 import android.media.MediaRecorder
 import android.media.MediaRecorder
 import android.os.Build
 import android.os.Build
@@ -257,6 +258,9 @@ object RTCModule {
     @Provides
     @Provides
     @Named(InjectionNames.OPTIONS_VIDEO_HW_ACCEL)
     @Named(InjectionNames.OPTIONS_VIDEO_HW_ACCEL)
     fun videoHwAccel() = true
     fun videoHwAccel() = true
+
+    @Provides
+    fun sdpFactory() = SdpFactory.getInstance()
 }
 }
 
 
 /**
 /**

@@ -16,6 +16,8 @@
 
 
 package io.livekit.android.room
 package io.livekit.android.room
 
 
+import android.javax.sdp.MediaDescription
+import android.javax.sdp.SdpFactory
 import dagger.assisted.Assisted
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
 import dagger.assisted.AssistedInject
@@ -24,6 +26,12 @@ import io.livekit.android.room.util.*
 import io.livekit.android.util.Either
 import io.livekit.android.util.Either
 import io.livekit.android.util.LKLog
 import io.livekit.android.util.LKLog
 import io.livekit.android.util.debounce
 import io.livekit.android.util.debounce
+import io.livekit.android.webrtc.SdpExt
+import io.livekit.android.webrtc.SdpFmtp
+import io.livekit.android.webrtc.getExts
+import io.livekit.android.webrtc.getFmtps
+import io.livekit.android.webrtc.getMsid
+import io.livekit.android.webrtc.getRtps
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.SupervisorJob
@@ -33,6 +41,7 @@ import kotlinx.coroutines.sync.withLock
 import org.webrtc.*
 import org.webrtc.*
 import org.webrtc.PeerConnection.RTCConfiguration
 import org.webrtc.PeerConnection.RTCConfiguration
 import javax.inject.Named
 import javax.inject.Named
+import kotlin.math.roundToLong
 
 
 /**
 /**
  * @suppress
  * @suppress
@@ -40,12 +49,13 @@ import javax.inject.Named
 internal class PeerConnectionTransport
 internal class PeerConnectionTransport
 @AssistedInject
 @AssistedInject
 constructor(
 constructor(
-    @Assisted config: PeerConnection.RTCConfiguration,
+    @Assisted config: RTCConfiguration,
     @Assisted pcObserver: PeerConnection.Observer,
     @Assisted pcObserver: PeerConnection.Observer,
     @Assisted private val listener: Listener?,
     @Assisted private val listener: Listener?,
     @Named(InjectionNames.DISPATCHER_IO)
     @Named(InjectionNames.DISPATCHER_IO)
     private val ioDispatcher: CoroutineDispatcher,
     private val ioDispatcher: CoroutineDispatcher,
     connectionFactory: PeerConnectionFactory,
     connectionFactory: PeerConnectionFactory,
+    private val sdpFactory: SdpFactory,
 ) {
 ) {
     private val coroutineScope = CoroutineScope(ioDispatcher + SupervisorJob())
     private val coroutineScope = CoroutineScope(ioDispatcher + SupervisorJob())
     internal val peerConnection: PeerConnection = connectionFactory.createPeerConnection(
     internal val peerConnection: PeerConnection = connectionFactory.createPeerConnection(
@@ -59,6 +69,8 @@ constructor(
 
 
     private val mutex = Mutex()
     private val mutex = Mutex()
 
 
+    private var trackBitrates = mutableMapOf<TrackBitrateInfoKey, TrackBitrateInfo>()
+
     interface Listener {
     interface Listener {
         fun onOffer(sd: SessionDescription)
         fun onOffer(sd: SessionDescription)
     }
     }
@@ -139,9 +151,82 @@ constructor(
             }
             }
         }
         }
 
 
-        LKLog.v { "sdp offer = $sdpOffer, description: ${sdpOffer.description}, type: ${sdpOffer.type}" }
-        peerConnection.setLocalDescription(sdpOffer)
-        listener?.onOffer(sdpOffer)
+        // munge sdp
+        val sdpDescription = sdpFactory.createSessionDescription(sdpOffer.description)
+
+        val mediaDescs = sdpDescription.getMediaDescriptions(true)
+        for (mediaDesc in mediaDescs) {
+            if (mediaDesc !is MediaDescription) {
+                continue
+            }
+            if (mediaDesc.media.mediaType == "audio") {
+                // TODO
+            } else if (mediaDesc.media.mediaType == "video") {
+                ensureVideoDDExtensionForSVC(mediaDesc)
+                ensureCodecBitrates(mediaDesc, trackBitrates = trackBitrates)
+            }
+        }
+
+        val finalSdp = setMungedSdp(sdpOffer, sdpDescription.toString())
+        listener.onOffer(finalSdp)
+    }
+
+    private suspend fun setMungedSdp(sdp: SessionDescription, mungedDescription: String, remote: Boolean = false): SessionDescription {
+        val mungedSdp = SessionDescription(sdp.type, mungedDescription)
+
+        LKLog.v { "sdp type: ${sdp.type}\ndescription:\n${sdp.description}" }
+        LKLog.v { "munged sdp type: ${mungedSdp.type}\ndescription:\n${mungedSdp.description}" }
+        val mungedResult = if (remote) {
+            peerConnection.setRemoteDescription(mungedSdp)
+        } else {
+            peerConnection.setLocalDescription(mungedSdp)
+        }
+
+        val mungedErrorMessage = when (mungedResult) {
+            is Either.Left -> {
+                // munged sdp set successfully.
+                return mungedSdp
+            }
+
+            is Either.Right -> {
+                if (mungedResult.value.isNullOrBlank()) {
+                    "unknown sdp error"
+                } else {
+                    mungedResult.value
+                }
+            }
+        }
+
+        // munged sdp setting failed
+        LKLog.w {
+            "setting munged sdp for " +
+                "${if (remote) "remote" else "local"} description, " +
+                "${mungedSdp.type} type failed, falling back to unmodified."
+        }
+        LKLog.w { "error: $mungedErrorMessage" }
+
+        val result = if (remote) {
+            peerConnection.setRemoteDescription(sdp)
+        } else {
+            peerConnection.setLocalDescription(sdp)
+        }
+
+        if (result is Either.Right) {
+            val errorMessage = if (result.value.isNullOrBlank()) {
+                "unknown sdp error"
+            } else {
+                result.value
+            }
+
+            // sdp setting failed
+            LKLog.w {
+                "setting original sdp for " +
+                    "${if (remote) "remote" else "local"} description, " +
+                    "${sdp.type} type failed!"
+            }
+            LKLog.w { "error: $errorMessage" }
+        }
+        return sdp
     }
     }
 
 
     fun prepareForIceRestart() {
     fun prepareForIceRestart() {
@@ -156,12 +241,132 @@ constructor(
         peerConnection.setConfiguration(config)
         peerConnection.setConfiguration(config)
     }
     }
 
 
+    fun registerTrackBitrateInfo(cid: String, trackBitrateInfo: TrackBitrateInfo) {
+        trackBitrates[TrackBitrateInfoKey.Cid(cid)] = trackBitrateInfo
+    }
+
+    fun registerTrackBitrateInfo(transceiver: RtpTransceiver, trackBitrateInfo: TrackBitrateInfo) {
+        trackBitrates[TrackBitrateInfoKey.Transceiver(transceiver)] = trackBitrateInfo
+    }
+
     @AssistedFactory
     @AssistedFactory
     interface Factory {
     interface Factory {
         fun create(
         fun create(
-            config: PeerConnection.RTCConfiguration,
+            config: RTCConfiguration,
             pcObserver: PeerConnection.Observer,
             pcObserver: PeerConnection.Observer,
             listener: Listener?,
             listener: Listener?,
         ): PeerConnectionTransport
         ): PeerConnectionTransport
     }
     }
 }
 }
+
+private const val DD_EXTENSION_URI = "https://aomediacodec.github.io/av1-rtp-spec/#dependency-descriptor-rtp-header-extension"
+
+internal fun ensureVideoDDExtensionForSVC(mediaDesc: MediaDescription) {
+    val codec = mediaDesc.getRtps()
+        .firstOrNull()
+        ?.second
+        ?.codec ?: return
+    if (!isSVCCodec(codec)) {
+        return
+    }
+
+    var maxId = 0L
+
+    val ddFound = mediaDesc.getExts().any { (_, ext) ->
+        if (ext.uri == DD_EXTENSION_URI) {
+            return@any true
+        }
+        if (ext.value > maxId) {
+            maxId = ext.value
+        }
+        false
+    }
+
+    // Not found, add manually
+    if (!ddFound) {
+        mediaDesc.addAttribute(
+            SdpExt(
+                value = maxId + 1,
+                uri = DD_EXTENSION_URI,
+                config = null,
+                direction = null,
+                encryptUri = null,
+            ).toAttributeField(),
+        )
+    }
+}
+
+/* The svc codec (av1/vp9) would use a very low bitrate at the begining and
+increase slowly by the bandwidth estimator until it reach the target bitrate. The
+process commonly cost more than 10 seconds cause subscriber will get blur video at
+the first few seconds. So we use a 70% of target bitrate here as the start bitrate to
+eliminate this issue.
+*/
+private const val startBitrateForSVC = 0.7
+
+internal fun ensureCodecBitrates(
+    media: MediaDescription,
+    trackBitrates: Map<TrackBitrateInfoKey, TrackBitrateInfo>,
+) {
+    val msid = media.getMsid()?.value ?: return
+    for ((key, trackBr) in trackBitrates) {
+        if (key !is TrackBitrateInfoKey.Cid) {
+            continue
+        }
+
+        val (cid) = key
+        if (!msid.contains(cid)) {
+            continue
+        }
+
+        val (_, rtp) = media.getRtps()
+            .firstOrNull { (_, rtp) -> rtp.codec.equals(trackBr.codec, ignoreCase = true) }
+            ?: continue
+        val codecPayload = rtp.payload
+
+        val fmtps = media.getFmtps()
+        var fmtpFound = false
+        for ((attribute, fmtp) in fmtps) {
+            if (fmtp.payload == codecPayload) {
+                fmtpFound = true
+                var newFmtpConfig = fmtp.config
+                if (!fmtp.config.contains("x-google-start-bitrate")) {
+                    newFmtpConfig = "$newFmtpConfig;x-google-start-bitrate=${(trackBr.maxBitrate * startBitrateForSVC).roundToLong()}"
+                }
+                if (!fmtp.config.contains("x-google-max-bitrate")) {
+                    newFmtpConfig = "$newFmtpConfig;x-google-max-bitrate=${trackBr.maxBitrate}"
+                }
+                if (fmtp.config != newFmtpConfig) {
+                    attribute.value = "${fmtp.payload} $newFmtpConfig"
+                    break
+                }
+            }
+        }
+
+        if (!fmtpFound) {
+            media.addAttribute(
+                SdpFmtp(
+                    payload = codecPayload,
+                    config = "x-google-start-bitrate=${trackBr.maxBitrate * startBitrateForSVC};" +
+                        "x-google-max-bitrate=${trackBr.maxBitrate}",
+                ).toAttributeField(),
+            )
+        }
+    }
+}
+
+internal fun isSVCCodec(codec: String?): Boolean {
+    return codec != null &&
+        ("av1".equals(codec, ignoreCase = true) ||
+            "vp9".equals(codec, ignoreCase = true))
+}
+
+internal data class TrackBitrateInfo(
+    val codec: String,
+    val maxBitrate: Long,
+)
+
+sealed class TrackBitrateInfoKey {
+    data class Cid(val value: String) : TrackBitrateInfoKey()
+    data class Transceiver(val value: RtpTransceiver) : TrackBitrateInfoKey()
+}

@@ -43,6 +43,7 @@ import livekit.LivekitRtc.JoinResponse
 import livekit.LivekitRtc.ReconnectResponse
 import livekit.LivekitRtc.ReconnectResponse
 import org.webrtc.*
 import org.webrtc.*
 import org.webrtc.PeerConnection.RTCConfiguration
 import org.webrtc.PeerConnection.RTCConfiguration
+import org.webrtc.RtpTransceiver.RtpTransceiverInit
 import java.net.ConnectException
 import java.net.ConnectException
 import java.nio.ByteBuffer
 import java.nio.ByteBuffer
 import javax.inject.Inject
 import javax.inject.Inject
@@ -278,6 +279,13 @@ internal constructor(
         }
         }
     }
     }
 
 
+    internal fun createSenderTransceiver(
+        rtcTrack: MediaStreamTrack,
+        transInit: RtpTransceiverInit,
+    ): RtpTransceiver? {
+        return publisher.peerConnection.addTransceiver(rtcTrack, transInit)
+    }
+
     fun updateSubscriptionPermissions(
     fun updateSubscriptionPermissions(
         allParticipants: Boolean,
         allParticipants: Boolean,
         participantTrackPermissions: List<ParticipantTrackPermission>,
         participantTrackPermissions: List<ParticipantTrackPermission>,

@@ -152,8 +152,15 @@ constructor(
      * significantly reducing publishing CPU and bandwidth usage.
      * significantly reducing publishing CPU and bandwidth usage.
      *
      *
      * Defaults to false.
      * Defaults to false.
+     *
+     * Will be enabled if SVC codecs (i.e. VP9/AV1) are used. Multi-codec simulcast
+     * requires dynacast.
      */
      */
-    var dynacast: Boolean = false
+    var dynacast: Boolean
+        get() = localParticipant.dynacast
+        set(value) {
+            localParticipant.dynacast = value
+        }
 
 
     /**
     /**
      * Default options to use when creating an audio track.
      * Default options to use when creating an audio track.
@@ -175,7 +182,7 @@ constructor(
      */
      */
     var videoTrackPublishDefaults: VideoTrackPublishDefaults by defaultsManager::videoTrackPublishDefaults
     var videoTrackPublishDefaults: VideoTrackPublishDefaults by defaultsManager::videoTrackPublishDefaults
 
 
-    val localParticipant: LocalParticipant = localParticipantFactory.create(dynacast = dynacast).apply {
+    val localParticipant: LocalParticipant = localParticipantFactory.create(dynacast = false).apply {
         internalListener = this@Room
         internalListener = this@Room
     }
     }
 
 

@@ -34,7 +34,6 @@ import kotlinx.serialization.decodeFromString
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.Json
 import livekit.LivekitModels
 import livekit.LivekitModels
-import livekit.LivekitModels.Encryption
 import livekit.LivekitRtc
 import livekit.LivekitRtc
 import livekit.LivekitRtc.JoinResponse
 import livekit.LivekitRtc.JoinResponse
 import livekit.LivekitRtc.ReconnectResponse
 import livekit.LivekitRtc.ReconnectResponse
@@ -95,6 +94,7 @@ constructor(
     private var pongJob: Job? = null
     private var pongJob: Job? = null
     private var pingTimeoutDurationMillis: Long = 0
     private var pingTimeoutDurationMillis: Long = 0
     private var pingIntervalDurationMillis: Long = 0
     private var pingIntervalDurationMillis: Long = 0
+    private var rtt: Long = 0
 
 
     var connectionState: ConnectionState = ConnectionState.DISCONNECTED
     var connectionState: ConnectionState = ConnectionState.DISCONNECTED
 
 
@@ -491,6 +491,28 @@ constructor(
         sendRequest(request)
         sendRequest(request)
     }
     }
 
 
+    fun sendPing(): Long {
+        val time = Date().time
+        sendRequest(
+            with(LivekitRtc.SignalRequest.newBuilder()) {
+                ping = time
+                build()
+            },
+        )
+        sendRequest(
+            with(LivekitRtc.SignalRequest.newBuilder()) {
+                pingReq = with(LivekitRtc.Ping.newBuilder()) {
+                    rtt = this@SignalClient.rtt
+                    timestamp = time
+                    build()
+                }
+                build()
+            },
+        )
+
+        return time
+    }
+
     private fun sendRequest(request: LivekitRtc.SignalRequest) {
     private fun sendRequest(request: LivekitRtc.SignalRequest) {
         val skipQueue = skipQueueTypes.contains(request.messageCase)
         val skipQueue = skipQueueTypes.contains(request.messageCase)
 
 
@@ -647,7 +669,8 @@ constructor(
             }
             }
 
 
             LivekitRtc.SignalResponse.MessageCase.PONG_RESP -> {
             LivekitRtc.SignalResponse.MessageCase.PONG_RESP -> {
-                // TODO
+                rtt = Date().time - response.pongResp.lastPingTimestamp
+                resetPingTimeout()
             }
             }
 
 
             LivekitRtc.SignalResponse.MessageCase.RECONNECT -> {
             LivekitRtc.SignalResponse.MessageCase.RECONNECT -> {
@@ -671,13 +694,7 @@ constructor(
             pingJob = coroutineScope.launch {
             pingJob = coroutineScope.launch {
                 while (true) {
                 while (true) {
                     delay(pingIntervalDurationMillis)
                     delay(pingIntervalDurationMillis)
-
-                    val pingTimestamp = Date().time
-                    val pingRequest = LivekitRtc.SignalRequest.newBuilder()
-                        .setPing(pingTimestamp)
-                        .build()
-                    LKLog.v { "Sending ping: $pingTimestamp" }
-                    sendRequest(pingRequest)
+                    val pingTimestamp = sendPing()
                     startPingTimeout(pingTimestamp)
                     startPingTimeout(pingTimestamp)
                 }
                 }
             }
             }

@@ -29,15 +29,21 @@ import io.livekit.android.events.ParticipantEvent
 import io.livekit.android.room.ConnectionState
 import io.livekit.android.room.ConnectionState
 import io.livekit.android.room.DefaultsManager
 import io.livekit.android.room.DefaultsManager
 import io.livekit.android.room.RTCEngine
 import io.livekit.android.room.RTCEngine
+import io.livekit.android.room.TrackBitrateInfo
+import io.livekit.android.room.isSVCCodec
 import io.livekit.android.room.track.*
 import io.livekit.android.room.track.*
 import io.livekit.android.room.util.EncodingUtils
 import io.livekit.android.room.util.EncodingUtils
 import io.livekit.android.util.LKLog
 import io.livekit.android.util.LKLog
 import io.livekit.android.webrtc.createStatsGetter
 import io.livekit.android.webrtc.createStatsGetter
+import io.livekit.android.webrtc.sortVideoCodecPreferences
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.launch
 import livekit.LivekitModels
 import livekit.LivekitModels
 import livekit.LivekitRtc
 import livekit.LivekitRtc
+import livekit.LivekitRtc.AddTrackRequest
+import livekit.LivekitRtc.SimulcastCodec
 import org.webrtc.*
 import org.webrtc.*
-import org.webrtc.RtpCapabilities.CodecCapability
+import org.webrtc.RtpTransceiver.RtpTransceiverInit
 import javax.inject.Named
 import javax.inject.Named
 import kotlin.math.max
 import kotlin.math.max
 
 
@@ -45,7 +51,7 @@ class LocalParticipant
 @AssistedInject
 @AssistedInject
 internal constructor(
 internal constructor(
     @Assisted
     @Assisted
-    private val dynacast: Boolean,
+    internal var dynacast: Boolean,
     internal val engine: RTCEngine,
     internal val engine: RTCEngine,
     private val peerConnectionFactory: PeerConnectionFactory,
     private val peerConnectionFactory: PeerConnectionFactory,
     private val context: Context,
     private val context: Context,
@@ -180,7 +186,6 @@ internal constructor(
         source: Track.Source,
         source: Track.Source,
         enabled: Boolean,
         enabled: Boolean,
         mediaProjectionPermissionResultData: Intent? = null,
         mediaProjectionPermissionResultData: Intent? = null,
-
     ) {
     ) {
         val pub = getTrackPublication(source)
         val pub = getTrackPublication(source)
         if (enabled) {
         if (enabled) {
@@ -267,9 +272,23 @@ internal constructor(
         options: VideoTrackPublishOptions = VideoTrackPublishOptions(null, videoTrackPublishDefaults),
         options: VideoTrackPublishOptions = VideoTrackPublishOptions(null, videoTrackPublishDefaults),
         publishListener: PublishListener? = null,
         publishListener: PublishListener? = null,
     ) {
     ) {
+        val isSVC = isSVCCodec(options.videoCodec)
+
+        @Suppress("NAME_SHADOWING") var options = options
+        if (isSVC) {
+            dynacast = true
+
+            // Ensure backup codec and scalability for svc codecs.
+            if (options.backupCodec == null) {
+                options = options.copy(backupCodec = BackupVideoCodec())
+            }
+            if (options.scalabilityMode == null) {
+                options = options.copy(scalabilityMode = "L3T3_KEY")
+            }
+        }
         val encodings = computeVideoEncodings(track.dimensions, options)
         val encodings = computeVideoEncodings(track.dimensions, options)
         val videoLayers =
         val videoLayers =
-            EncodingUtils.videoLayersFromEncodings(track.dimensions.width, track.dimensions.height, encodings)
+            EncodingUtils.videoLayersFromEncodings(track.dimensions.width, track.dimensions.height, encodings, isSVC)
 
 
         publishTrackImpl(
         publishTrackImpl(
             track = track,
             track = track,
@@ -283,6 +302,24 @@ internal constructor(
                     LivekitModels.TrackSource.CAMERA
                     LivekitModels.TrackSource.CAMERA
                 }
                 }
                 addAllLayers(videoLayers)
                 addAllLayers(videoLayers)
+
+                addSimulcastCodecs(
+                    with(SimulcastCodec.newBuilder()) {
+                        codec = options.videoCodec
+                        cid = track.rtcTrack.id()
+                        build()
+                    },
+                )
+                // set up backup codec
+                if (options.backupCodec?.codec != null && options.videoCodec != options.backupCodec?.codec) {
+                    addSimulcastCodecs(
+                        with(SimulcastCodec.newBuilder()) {
+                            codec = options.backupCodec!!.codec
+                            cid = ""
+                            build()
+                        },
+                    )
+                }
             },
             },
             encodings = encodings,
             encodings = encodings,
             publishListener = publishListener,
             publishListener = publishListener,
@@ -295,17 +332,21 @@ internal constructor(
     private suspend fun publishTrackImpl(
     private suspend fun publishTrackImpl(
         track: Track,
         track: Track,
         options: TrackPublishOptions,
         options: TrackPublishOptions,
-        requestConfig: LivekitRtc.AddTrackRequest.Builder.() -> Unit,
+        requestConfig: AddTrackRequest.Builder.() -> Unit,
         encodings: List<RtpParameters.Encoding> = emptyList(),
         encodings: List<RtpParameters.Encoding> = emptyList(),
         publishListener: PublishListener? = null,
         publishListener: PublishListener? = null,
     ): Boolean {
     ): Boolean {
+        @Suppress("NAME_SHADOWING") var options = options
+
+        @Suppress("NAME_SHADOWING") var encodings = encodings
+
         if (localTrackPublications.any { it.track == track }) {
         if (localTrackPublications.any { it.track == track }) {
             publishListener?.onPublishFailure(TrackException.PublishException("Track has already been published"))
             publishListener?.onPublishFailure(TrackException.PublishException("Track has already been published"))
             return false
             return false
         }
         }
 
 
         val cid = track.rtcTrack.id()
         val cid = track.rtcTrack.id()
-        val builder = LivekitRtc.AddTrackRequest.newBuilder().apply {
+        val builder = AddTrackRequest.newBuilder().apply {
             this.requestConfig()
             this.requestConfig()
         }
         }
         val trackInfo = engine.addTrack(
         val trackInfo = engine.addTrack(
@@ -314,12 +355,30 @@ internal constructor(
             kind = track.kind.toProto(),
             kind = track.kind.toProto(),
             builder = builder,
             builder = builder,
         )
         )
-        val transInit = RtpTransceiver.RtpTransceiverInit(
+
+        if (options is VideoTrackPublishOptions) {
+            // server might not support the codec the client has requested, in that case, fallback
+            // to a supported codec
+            val primaryCodecMime = trackInfo.codecsList.firstOrNull()?.mimeType
+
+            if (primaryCodecMime != null) {
+                val updatedCodec = primaryCodecMime.mimeTypeToVideoCodec()
+                if (updatedCodec != options.videoCodec) {
+                    LKLog.d { "falling back to server selected codec: $updatedCodec" }
+                }
+                options = options.copy(videoCodec = updatedCodec)
+
+                // recompute encodings since bitrates/etc could have changed
+                encodings = computeVideoEncodings((track as LocalVideoTrack).dimensions, options)
+            }
+        }
+
+        val transInit = RtpTransceiverInit(
             RtpTransceiver.RtpTransceiverDirection.SEND_ONLY,
             RtpTransceiver.RtpTransceiverDirection.SEND_ONLY,
             listOf(this.sid),
             listOf(this.sid),
             encodings,
             encodings,
         )
         )
-        val transceiver = engine.publisher.peerConnection.addTransceiver(track.rtcTrack, transInit)
+        val transceiver = engine.createSenderTransceiver(track.rtcTrack, transInit)
 
 
         when (track) {
         when (track) {
             is LocalVideoTrack -> track.transceiver = transceiver
             is LocalVideoTrack -> track.transceiver = transceiver
@@ -336,43 +395,23 @@ internal constructor(
 
 
         track.statsGetter = createStatsGetter(engine.publisher.peerConnection, transceiver.sender)
         track.statsGetter = createStatsGetter(engine.publisher.peerConnection, transceiver.sender)
 
 
-        if (options is VideoTrackPublishOptions && options.videoCodec != null) {
-            val targetCodec = options.videoCodec.lowercase()
-            val capabilities = capabilitiesGetter(MediaStreamTrack.MediaType.MEDIA_TYPE_VIDEO)
-            LKLog.v { "capabilities:" }
-            capabilities.codecs.forEach { codec ->
-                LKLog.v { "codec: ${codec.name}, ${codec.kind}, ${codec.mimeType}, ${codec.parameters}, ${codec.preferredPayloadType}" }
+        // Handle trackBitrates
+        if (encodings.isNotEmpty()) {
+            if (options is VideoTrackPublishOptions && isSVCCodec(options.videoCodec) && encodings.firstOrNull()?.maxBitrateBps != null) {
+                engine.publisher.registerTrackBitrateInfo(
+                    cid = cid,
+                    TrackBitrateInfo(
+                        codec = options.videoCodec,
+                        maxBitrate = (encodings.first().maxBitrateBps?.div(1000) ?: 0).toLong(),
+                    ),
+                )
             }
             }
+        }
 
 
-            val matched = mutableListOf<CodecCapability>()
-            val partialMatched = mutableListOf<CodecCapability>()
-            val unmatched = mutableListOf<CodecCapability>()
-
-            for (codec in capabilities.codecs) {
-                val mimeType = codec.mimeType.lowercase()
-                if (mimeType == "audio/opus") {
-                    matched.add(codec)
-                    continue
-                }
-
-                if (mimeType != "video/$targetCodec") {
-                    unmatched.add(codec)
-                    continue
-                }
-                // for h264 codecs that have sdpFmtpLine available, use only if the
-                // profile-level-id is 42e01f for cross-browser compatibility
-                if (targetCodec == "h264") {
-                    if (codec.parameters["profile-level-id"] == "42e01f") {
-                        matched.add(codec)
-                    } else {
-                        partialMatched.add(codec)
-                    }
-                    continue
-                } else {
-                    matched.add(codec)
-                }
-            }
-            transceiver.setCodecPreferences(matched.plus(partialMatched).plus(unmatched))
+        // Set preferred video codec order
+        if (options is VideoTrackPublishOptions) {
+            transceiver.sortVideoCodecPreferences(options.videoCodec, capabilitiesGetter)
+            (track as LocalVideoTrack).codec = options.videoCodec
         }
         }
 
 
         val publication = LocalTrackPublication(
         val publication = LocalTrackPublication(
@@ -397,6 +436,7 @@ internal constructor(
         val (width, height) = dimensions
         val (width, height) = dimensions
         var encoding = options.videoEncoding
         var encoding = options.videoEncoding
         val simulcast = options.simulcast
         val simulcast = options.simulcast
+        val scalabilityMode = options.scalabilityMode
 
 
         if ((encoding == null && !simulcast) || width == 0 || height == 0) {
         if ((encoding == null && !simulcast) || width == 0 || height == 0) {
             return emptyList()
             return emptyList()
@@ -408,7 +448,13 @@ internal constructor(
         }
         }
 
 
         val encodings = mutableListOf<RtpParameters.Encoding>()
         val encodings = mutableListOf<RtpParameters.Encoding>()
-        if (simulcast) {
+
+        if (scalabilityMode != null && isSVCCodec(options.videoCodec)) {
+            val rtpEncoding = encoding.toRtpEncoding()
+            rtpEncoding.scalabilityMode = scalabilityMode
+            encodings.add(rtpEncoding)
+            return encodings
+        } else if (simulcast) {
             val presets = EncodingUtils.presetsForResolution(width, height)
             val presets = EncodingUtils.presetsForResolution(width, height)
             val midPreset = presets[1]
             val midPreset = presets[1]
             val lowPreset = presets[0]
             val lowPreset = presets[0]
@@ -454,6 +500,27 @@ internal constructor(
         return encodings
         return encodings
     }
     }
 
 
+    private fun computeTrackBackupOptionsAndEncodings(
+        track: LocalVideoTrack,
+        videoCodec: VideoCodec,
+        options: VideoTrackPublishOptions,
+    ): Pair<VideoTrackPublishOptions, List<RtpParameters.Encoding>>? {
+        if (!options.hasBackupCodec()) {
+            return null
+        }
+
+        if (videoCodec.codecName != options.backupCodec?.codec) {
+            LKLog.w { "Server requested different codec than specified backup. server: $videoCodec, specified: ${options.backupCodec?.codec}" }
+        }
+
+        val backupOptions = options.copy(
+            videoCodec = videoCodec.codecName,
+            videoEncoding = options.backupCodec!!.encoding,
+        )
+        val backupEncodings = computeVideoEncodings(track.dimensions, backupOptions)
+        return backupOptions to backupEncodings
+    }
+
     /**
     /**
      * Control who can subscribe to LocalParticipant's published tracks.
      * Control who can subscribe to LocalParticipant's published tracks.
      *
      *
@@ -590,30 +657,87 @@ internal constructor(
         }
         }
 
 
         val trackSid = subscribedQualityUpdate.trackSid
         val trackSid = subscribedQualityUpdate.trackSid
+        val subscribedCodecs = subscribedQualityUpdate.subscribedCodecsList
         val qualities = subscribedQualityUpdate.subscribedQualitiesList
         val qualities = subscribedQualityUpdate.subscribedQualitiesList
-        val pub = tracks[trackSid] ?: return
+        val pub = tracks[trackSid] as? LocalTrackPublication ?: return
         val track = pub.track as? LocalVideoTrack ?: return
         val track = pub.track as? LocalVideoTrack ?: return
-
-        val sender = track.transceiver?.sender ?: return
-        val parameters = sender.parameters ?: return
-        val encodings = parameters.encodings ?: return
-
-        var hasChanged = false
-        for (quality in qualities) {
-            val rid = EncodingUtils.ridForVideoQuality(quality.quality) ?: continue
-            val encoding = encodings.firstOrNull { it.rid == rid }
-                // use low quality layer settings for non-simulcasted streams
-                ?: encodings.takeIf { it.size == 1 && quality.quality == LivekitModels.VideoQuality.LOW }?.first()
-                ?: continue
-            if (encoding.active != quality.enabled) {
-                hasChanged = true
-                encoding.active = quality.enabled
-                LKLog.v { "setting layer ${quality.quality} to ${quality.enabled}" }
+        val options = pub.options as? VideoTrackPublishOptions ?: return
+
+        if (subscribedCodecs.isNotEmpty()) {
+            val newCodecs = track.setPublishingCodecs(subscribedCodecs)
+            for (codec in newCodecs) {
+                if (isBackupCodec(codec.codecName)) {
+                    LKLog.d { "publish $codec for $trackSid" }
+                    publishAdditionalCodecForTrack(track, codec, options)
+                }
             }
             }
         }
         }
+        if (qualities.isNotEmpty()) {
+            track.setPublishingLayers(qualities)
+        }
+    }
 
 
-        if (hasChanged) {
-            sender.parameters = parameters
+    private fun publishAdditionalCodecForTrack(track: LocalVideoTrack, codec: VideoCodec, options: VideoTrackPublishOptions) {
+        val existingPublication = tracks[track.sid] ?: run {
+            LKLog.w { "attempting to publish additional codec for non-published track?!" }
+            return
+        }
+
+        val result = computeTrackBackupOptionsAndEncodings(track, codec, options) ?: run {
+            LKLog.i { "backup codec has been disabled, ignoring request to add additional codec for track" }
+            return
+        }
+        val (newOptions, newEncodings) = result
+        val simulcastTrack = track.addSimulcastTrack(codec, newEncodings)
+
+        val transceiverInit = RtpTransceiverInit(
+            RtpTransceiver.RtpTransceiverDirection.SEND_ONLY,
+            listOf(this.sid),
+            newEncodings,
+        )
+
+        scope.launch {
+            val transceiver = engine.createSenderTransceiver(track.rtcTrack, transceiverInit)
+            if (transceiver == null) {
+                LKLog.w { "couldn't create new transceiver! $codec" }
+                return@launch
+            }
+            transceiver.sortVideoCodecPreferences(newOptions.videoCodec, capabilitiesGetter)
+            simulcastTrack.sender = transceiver.sender
+
+            val trackRequest = AddTrackRequest.newBuilder().apply {
+                cid = transceiver.sender.id()
+                sid = existingPublication.sid
+                type = track.kind.toProto()
+                muted = !track.enabled
+                source = existingPublication.source.toProto()
+                addSimulcastCodecs(
+                    with(SimulcastCodec.newBuilder()) {
+                        this@with.codec = codec.codecName
+                        this@with.cid = transceiver.sender.id()
+                        build()
+                    },
+                )
+                addAllLayers(
+                    EncodingUtils.videoLayersFromEncodings(
+                        track.dimensions.width,
+                        track.dimensions.height,
+                        newEncodings,
+                        isSVCCodec(codec.codecName),
+                    ),
+                )
+            }
+
+            val trackInfo = engine.addTrack(
+                cid = simulcastTrack.rtcTrack.id(),
+                name = existingPublication.name,
+                kind = existingPublication.kind.toProto(),
+                builder = trackRequest,
+            )
+
+            engine.negotiatePublisher()
+
+            LKLog.d { "published $codec for track ${track.sid}, $trackInfo" }
         }
         }
     }
     }
 
 
@@ -713,21 +837,37 @@ abstract class BaseVideoTrackPublishOptions {
 
 
     /**
     /**
      * The video codec to use if available.
      * The video codec to use if available.
+     *
+     * Defaults to VP8.
+     *
+     * @see [VideoCodec]
      */
      */
-    abstract val videoCodec: String?
+    abstract val videoCodec: String
+
+    /**
+     * scalability mode for svc codecs, defaults to 'L3T3'.
+     * for svc codecs, simulcast is disabled.
+     */
+    abstract val scalabilityMode: String?
+
+    abstract val backupCodec: BackupVideoCodec?
 }
 }
 
 
 data class VideoTrackPublishDefaults(
 data class VideoTrackPublishDefaults(
     override val videoEncoding: VideoEncoding? = null,
     override val videoEncoding: VideoEncoding? = null,
     override val simulcast: Boolean = true,
     override val simulcast: Boolean = true,
-    override val videoCodec: String? = null,
+    override val videoCodec: String = VideoCodec.VP8.codecName,
+    override val scalabilityMode: String? = null,
+    override val backupCodec: BackupVideoCodec? = null,
 ) : BaseVideoTrackPublishOptions()
 ) : BaseVideoTrackPublishOptions()
 
 
 data class VideoTrackPublishOptions(
 data class VideoTrackPublishOptions(
     override val name: String? = null,
     override val name: String? = null,
     override val videoEncoding: VideoEncoding? = null,
     override val videoEncoding: VideoEncoding? = null,
     override val simulcast: Boolean = true,
     override val simulcast: Boolean = true,
-    override val videoCodec: String? = null,
+    override val videoCodec: String = VideoCodec.VP8.codecName,
+    override val scalabilityMode: String? = null,
+    override val backupCodec: BackupVideoCodec? = null,
 ) : BaseVideoTrackPublishOptions(), TrackPublishOptions {
 ) : BaseVideoTrackPublishOptions(), TrackPublishOptions {
     constructor(
     constructor(
         name: String? = null,
         name: String? = null,
@@ -737,9 +877,28 @@ data class VideoTrackPublishOptions(
         base.videoEncoding,
         base.videoEncoding,
         base.simulcast,
         base.simulcast,
         base.videoCodec,
         base.videoCodec,
+        base.scalabilityMode,
+        base.backupCodec,
     )
     )
+
+    fun createBackupOptions(): VideoTrackPublishOptions? {
+        return if (hasBackupCodec()) {
+            copy(
+                videoCodec = backupCodec!!.codec,
+                videoEncoding = backupCodec.encoding,
+            )
+        } else {
+            null
+        }
+    }
 }
 }
 
 
+data class BackupVideoCodec(
+    val codec: String = "vp8",
+    val encoding: VideoEncoding? = null,
+    val simulcast: Boolean = true,
+)
+
 abstract class BaseAudioTrackPublishOptions {
 abstract class BaseAudioTrackPublishOptions {
     abstract val audioBitrate: Int?
     abstract val audioBitrate: Int?
 
 
@@ -813,14 +972,9 @@ data class ParticipantTrackPermission(
     }
     }
 }
 }
 
 
-sealed class PublishRecord() {
-    data class AudioTrackPublishRecord(
-        val track: LocalAudioTrack,
-        val options: AudioTrackPublishOptions,
-    )
-
-    data class VideoTrackPublishRecord(
-        val track: LocalVideoTrack,
-        val options: VideoTrackPublishOptions,
-    )
+internal fun VideoTrackPublishOptions.hasBackupCodec(): Boolean {
+    return backupCodec?.codec != null && videoCodec != backupCodec.codec
 }
 }
+
+private val backupCodecs = listOf(VideoCodec.VP8.codecName, VideoCodec.H264.codecName)
+private fun isBackupCodec(codecName: String) = backupCodecs.contains(codecName)

@@ -173,6 +173,8 @@ open class Participant(
         get() = participantInfo != null
         get() = participantInfo != null
 
 
     /**
     /**
+     * Maps track sids to their track publications.
+     *
      * Changes can be observed by using [io.livekit.android.util.flow]
      * Changes can be observed by using [io.livekit.android.util.flow]
      */
      */
     @FlowObservable
     @FlowObservable

+/*
+ * 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.room.participant
+
+fun String.mimeTypeToVideoCodec(): String {
+    return split("/")[1].lowercase()
+}

@@ -26,16 +26,33 @@ import dagger.assisted.AssistedInject
 import io.livekit.android.memory.CloseableManager
 import io.livekit.android.memory.CloseableManager
 import io.livekit.android.memory.SurfaceTextureHelperCloser
 import io.livekit.android.memory.SurfaceTextureHelperCloser
 import io.livekit.android.room.DefaultsManager
 import io.livekit.android.room.DefaultsManager
-import io.livekit.android.room.track.video.*
+import io.livekit.android.room.track.video.CameraCapturerUtils
 import io.livekit.android.room.track.video.CameraCapturerUtils.createCameraEnumerator
 import io.livekit.android.room.track.video.CameraCapturerUtils.createCameraEnumerator
 import io.livekit.android.room.track.video.CameraCapturerUtils.findCamera
 import io.livekit.android.room.track.video.CameraCapturerUtils.findCamera
 import io.livekit.android.room.track.video.CameraCapturerUtils.getCameraPosition
 import io.livekit.android.room.track.video.CameraCapturerUtils.getCameraPosition
+import io.livekit.android.room.track.video.CameraCapturerWithSize
+import io.livekit.android.room.track.video.VideoCapturerWithSize
+import io.livekit.android.room.util.EncodingUtils
 import io.livekit.android.util.FlowObservable
 import io.livekit.android.util.FlowObservable
 import io.livekit.android.util.LKLog
 import io.livekit.android.util.LKLog
 import io.livekit.android.util.flowDelegate
 import io.livekit.android.util.flowDelegate
-import org.webrtc.*
+import livekit.LivekitModels
+import livekit.LivekitModels.VideoQuality
+import livekit.LivekitRtc
+import livekit.LivekitRtc.SubscribedCodec
+import org.webrtc.CameraVideoCapturer
 import org.webrtc.CameraVideoCapturer.CameraEventsHandler
 import org.webrtc.CameraVideoCapturer.CameraEventsHandler
-import java.util.*
+import org.webrtc.EglBase
+import org.webrtc.MediaStreamTrack
+import org.webrtc.PeerConnectionFactory
+import org.webrtc.RtpParameters
+import org.webrtc.RtpSender
+import org.webrtc.RtpTransceiver
+import org.webrtc.SurfaceTextureHelper
+import org.webrtc.VideoCapturer
+import org.webrtc.VideoProcessor
+import org.webrtc.VideoSource
+import java.util.UUID
 
 
 /**
 /**
  * A representation of a local video track (generally input coming from camera or screen).
  * A representation of a local video track (generally input coming from camera or screen).
@@ -60,6 +77,10 @@ constructor(
     override var rtcTrack: org.webrtc.VideoTrack = rtcTrack
     override var rtcTrack: org.webrtc.VideoTrack = rtcTrack
         internal set
         internal set
 
 
+    internal var codec: String? = null
+    private var subscribedCodecs: List<SubscribedCodec>? = null
+    private val simulcastCodecs = mutableMapOf<VideoCodec, SimulcastTrackInfo>()
+
     @FlowObservable
     @FlowObservable
     @get:FlowObservable
     @get:FlowObservable
     var options: LocalVideoTrackOptions by flowDelegate(options)
     var options: LocalVideoTrackOptions by flowDelegate(options)
@@ -69,7 +90,7 @@ constructor(
             (capturer as? VideoCapturerWithSize)?.let { capturerWithSize ->
             (capturer as? VideoCapturerWithSize)?.let { capturerWithSize ->
                 val size = capturerWithSize.findCaptureFormat(
                 val size = capturerWithSize.findCaptureFormat(
                     options.captureParams.width,
                     options.captureParams.width,
-                    options.captureParams.height
+                    options.captureParams.height,
                 )
                 )
                 return Dimensions(size.width, size.height)
                 return Dimensions(size.width, size.height)
             }
             }
@@ -86,7 +107,7 @@ constructor(
         capturer.startCapture(
         capturer.startCapture(
             options.captureParams.width,
             options.captureParams.width,
             options.captureParams.height,
             options.captureParams.height,
-            options.captureParams.maxFps
+            options.captureParams.maxFps,
         )
         )
     }
     }
 
 
@@ -140,7 +161,7 @@ constructor(
         fun updateCameraOptions() {
         fun updateCameraOptions() {
             val newOptions = options.copy(
             val newOptions = options.copy(
                 deviceId = targetDeviceId,
                 deviceId = targetDeviceId,
-                position = enumerator.getCameraPosition(targetDeviceId)
+                position = enumerator.getCameraPosition(targetDeviceId),
             )
             )
             options = newOptions
             options = newOptions
         }
         }
@@ -150,30 +171,32 @@ constructor(
                 // For cameras we control, wait until the first frame to ensure everything is okay.
                 // For cameras we control, wait until the first frame to ensure everything is okay.
                 if (cameraCapturer is CameraCapturerWithSize) {
                 if (cameraCapturer is CameraCapturerWithSize) {
                     cameraCapturer.cameraEventsDispatchHandler
                     cameraCapturer.cameraEventsDispatchHandler
-                        .registerHandler(object : CameraEventsHandler {
-                            override fun onFirstFrameAvailable() {
-                                updateCameraOptions()
-                                cameraCapturer.cameraEventsDispatchHandler.unregisterHandler(this)
-                            }
-
-                            override fun onCameraError(p0: String?) {
-                                cameraCapturer.cameraEventsDispatchHandler.unregisterHandler(this)
-                            }
-
-                            override fun onCameraDisconnected() {
-                                cameraCapturer.cameraEventsDispatchHandler.unregisterHandler(this)
-                            }
-
-                            override fun onCameraFreezed(p0: String?) {
-                            }
-
-                            override fun onCameraOpening(p0: String?) {
-                            }
-
-                            override fun onCameraClosed() {
-                                cameraCapturer.cameraEventsDispatchHandler.unregisterHandler(this)
-                            }
-                        })
+                        .registerHandler(
+                            object : CameraEventsHandler {
+                                override fun onFirstFrameAvailable() {
+                                    updateCameraOptions()
+                                    cameraCapturer.cameraEventsDispatchHandler.unregisterHandler(this)
+                                }
+
+                                override fun onCameraError(p0: String?) {
+                                    cameraCapturer.cameraEventsDispatchHandler.unregisterHandler(this)
+                                }
+
+                                override fun onCameraDisconnected() {
+                                    cameraCapturer.cameraEventsDispatchHandler.unregisterHandler(this)
+                                }
+
+                                override fun onCameraFreezed(p0: String?) {
+                                }
+
+                                override fun onCameraOpening(p0: String?) {
+                                }
+
+                                override fun onCameraClosed() {
+                                    cameraCapturer.cameraEventsDispatchHandler.unregisterHandler(this)
+                                }
+                            },
+                        )
                 } else {
                 } else {
                     updateCameraOptions()
                     updateCameraOptions()
                 }
                 }
@@ -216,7 +239,7 @@ constructor(
             name,
             name,
             options,
             options,
             eglBase,
             eglBase,
-            trackFactory
+            trackFactory,
         )
         )
 
 
         // migrate video sinks to the new track
         // migrate video sinks to the new track
@@ -233,6 +256,122 @@ constructor(
         sender?.setTrack(newTrack.rtcTrack, true)
         sender?.setTrack(newTrack.rtcTrack, true)
     }
     }
 
 
+    internal fun setPublishingLayers(
+        qualities: List<LivekitRtc.SubscribedQuality>,
+    ) {
+        val sender = transceiver?.sender ?: return
+
+        setPublishingLayersForSender(sender, qualities)
+    }
+
+    private fun setPublishingLayersForSender(
+        sender: RtpSender,
+        qualities: List<LivekitRtc.SubscribedQuality>,
+    ) {
+        val parameters = sender.parameters ?: return
+        val encodings = parameters.encodings ?: return
+        var hasChanged = false
+
+        if (encodings.firstOrNull()?.scalabilityMode != null) {
+            val encoding = encodings.first()
+            var maxQuality = VideoQuality.OFF
+            for (quality in qualities) {
+                if (quality.enabled && (maxQuality == VideoQuality.OFF || quality.quality.number > maxQuality.number)) {
+                    maxQuality = quality.quality
+                }
+            }
+
+            if (maxQuality == VideoQuality.OFF) {
+                if (encoding.active) {
+                    LKLog.v { "setting svc track to disabled" }
+                    encoding.active = false
+                    hasChanged = true
+                }
+            } else if (!encoding.active) {
+                LKLog.v { "setting svc track to enabled" }
+                encoding.active = true
+                hasChanged = true
+            }
+        } else {
+            // simulcast dynacast encodings
+            for (quality in qualities) {
+                val rid = EncodingUtils.ridForVideoQuality(quality.quality) ?: continue
+                val encoding = encodings.firstOrNull { it.rid == rid }
+                    // use low quality layer settings for non-simulcasted streams
+                    ?: encodings.takeIf { it.size == 1 && quality.quality == LivekitModels.VideoQuality.LOW }?.first()
+                    ?: continue
+                if (encoding.active != quality.enabled) {
+                    hasChanged = true
+                    encoding.active = quality.enabled
+                    LKLog.v { "setting layer ${quality.quality} to ${quality.enabled}" }
+                }
+            }
+        }
+
+        if (hasChanged) {
+            // This refeshes the native code with the new information
+            sender.parameters = sender.parameters
+        }
+    }
+
+    fun setPublishingCodecs(codecs: List<SubscribedCodec>): List<VideoCodec> {
+        LKLog.v { "setting publishing codecs: $codecs" }
+
+        // only enable simulcast codec for preferred codec set
+        if (this.codec == null && codecs.isNotEmpty()) {
+            setPublishingLayers(codecs.first().qualitiesList)
+            return emptyList()
+        }
+
+        this.subscribedCodecs = codecs
+
+        val newCodecs = mutableListOf<VideoCodec>()
+
+        for (codec in codecs) {
+            if (this.codec == codec.codec) {
+                setPublishingLayers(codec.qualitiesList)
+            } else {
+                val videoCodec = try {
+                    VideoCodec.fromCodecName(codec.codec)
+                } catch (e: Exception) {
+                    LKLog.w { "unknown publishing codec ${codec.codec}!" }
+                    continue
+                }
+
+                LKLog.d { "try setPublishingCodec for ${codec.codec}" }
+                val simulcastInfo = this.simulcastCodecs[videoCodec]
+                if (simulcastInfo?.sender == null) {
+                    for (q in codec.qualitiesList) {
+                        if (q.enabled) {
+                            newCodecs.add(videoCodec)
+                            break
+                        }
+                    }
+                } else {
+                    LKLog.d { "try setPublishingLayersForSender ${codec.codec}" }
+                    setPublishingLayersForSender(
+                        simulcastInfo.sender!!,
+                        codec.qualitiesList,
+                    )
+                }
+            }
+        }
+        return newCodecs
+    }
+
+    internal fun addSimulcastTrack(codec: VideoCodec, encodings: List<RtpParameters.Encoding>): SimulcastTrackInfo {
+        if (this.simulcastCodecs.containsKey(codec)) {
+            throw IllegalStateException("$codec already added!")
+        }
+        val simulcastTrackInfo = SimulcastTrackInfo(
+            codec = codec.codecName,
+            rtcTrack = rtcTrack,
+            encodings = encodings,
+        )
+        simulcastCodecs[codec] = simulcastTrackInfo
+        return simulcastTrackInfo
+    }
+
     @AssistedFactory
     @AssistedFactory
     interface Factory {
     interface Factory {
         fun create(
         fun create(
@@ -262,7 +401,7 @@ constructor(
             capturer.initialize(
             capturer.initialize(
                 surfaceTextureHelper,
                 surfaceTextureHelper,
                 context,
                 context,
-                source.capturerObserver
+                source.capturerObserver,
             )
             )
             val rtcTrack = peerConnectionFactory.createVideoTrack(UUID.randomUUID().toString(), source)
             val rtcTrack = peerConnectionFactory.createVideoTrack(UUID.randomUUID().toString(), source)
 
 
@@ -271,12 +410,12 @@ constructor(
                 source = source,
                 source = source,
                 options = options,
                 options = options,
                 name = name,
                 name = name,
-                rtcTrack = rtcTrack
+                rtcTrack = rtcTrack,
             )
             )
 
 
             track.closeableManager.registerResource(
             track.closeableManager.registerResource(
                 rtcTrack,
                 rtcTrack,
-                SurfaceTextureHelperCloser(surfaceTextureHelper)
+                SurfaceTextureHelperCloser(surfaceTextureHelper),
             )
             )
             return track
             return track
         }
         }
@@ -303,7 +442,7 @@ constructor(
             capturer.initialize(
             capturer.initialize(
                 surfaceTextureHelper,
                 surfaceTextureHelper,
                 context,
                 context,
-                source.capturerObserver
+                source.capturerObserver,
             )
             )
             val rtcTrack = peerConnectionFactory.createVideoTrack(UUID.randomUUID().toString(), source)
             val rtcTrack = peerConnectionFactory.createVideoTrack(UUID.randomUUID().toString(), source)
 
 
@@ -312,15 +451,22 @@ constructor(
                 source = source,
                 source = source,
                 options = newOptions,
                 options = newOptions,
                 name = name,
                 name = name,
-                rtcTrack = rtcTrack
+                rtcTrack = rtcTrack,
             )
             )
 
 
             track.closeableManager.registerResource(
             track.closeableManager.registerResource(
                 rtcTrack,
                 rtcTrack,
-                SurfaceTextureHelperCloser(surfaceTextureHelper)
+                SurfaceTextureHelperCloser(surfaceTextureHelper),
             )
             )
 
 
             return track
             return track
         }
         }
     }
     }
 }
 }
+
+internal data class SimulcastTrackInfo(
+    var codec: String,
+    var rtcTrack: MediaStreamTrack,
+    var sender: RtpSender? = null,
+    var encodings: List<RtpParameters.Encoding>? = null,
+)

@@ -63,6 +63,14 @@ data class VideoEncoding(
 enum class VideoCodec(val codecName: String) {
 enum class VideoCodec(val codecName: String) {
     VP8("vp8"),
     VP8("vp8"),
     H264("h264"),
     H264("h264"),
+    VP9("vp9"),
+    AV1("av1");
+
+    companion object {
+        fun fromCodecName(codecName: String): VideoCodec {
+            return VideoCodec.values().first { it.codecName.equals(codecName, ignoreCase = true) }
+        }
+    }
 }
 }
 
 
 enum class CameraPosition {
 enum class CameraPosition {

+/*
+ * 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.room.track.video
+
+data class ScalabilityMode(val spatial: Int, val temporal: Int, val suffix: String) {
+    companion object {
+        private val REGEX = """L(\d)T(\d)(h|_KEY|_KEY_SHIFT)?""".toRegex()
+        fun parseFromString(mode: String): ScalabilityMode {
+            val match = REGEX.matchEntire(mode) ?: throw IllegalArgumentException("can't parse scalability mode: $mode")
+            val (spatial, temporal, suffix) = match.destructured
+
+            return ScalabilityMode(spatial.toInt(), temporal.toInt(), suffix)
+        }
+    }
+}

@@ -72,7 +72,7 @@ open class CoroutineSdpObserver : SdpObserver {
         setOutcome = Either.Right(message)
         setOutcome = Either.Right(message)
     }
     }
 
 
-    suspend fun awaitCreate() = suspendCoroutine<Either<SessionDescription, String?>> { cont ->
+    suspend fun awaitCreate() = suspendCoroutine { cont ->
         val curOutcome = createOutcome
         val curOutcome = createOutcome
         if (curOutcome != null) {
         if (curOutcome != null) {
             cont.resume(curOutcome)
             cont.resume(curOutcome)
@@ -81,7 +81,7 @@ open class CoroutineSdpObserver : SdpObserver {
         }
         }
     }
     }
 
 
-    suspend fun awaitSet() = suspendCoroutine<Either<Unit, String?>> { cont ->
+    suspend fun awaitSet() = suspendCoroutine { cont ->
         val curOutcome = setOutcome
         val curOutcome = setOutcome
         if (curOutcome != null) {
         if (curOutcome != null) {
             cont.resume(curOutcome)
             cont.resume(curOutcome)

@@ -20,11 +20,15 @@ import io.livekit.android.room.track.VideoEncoding
 import io.livekit.android.room.track.VideoPreset
 import io.livekit.android.room.track.VideoPreset
 import io.livekit.android.room.track.VideoPreset169
 import io.livekit.android.room.track.VideoPreset169
 import io.livekit.android.room.track.VideoPreset43
 import io.livekit.android.room.track.VideoPreset43
+import io.livekit.android.room.track.video.ScalabilityMode
 import livekit.LivekitModels
 import livekit.LivekitModels
 import org.webrtc.RtpParameters
 import org.webrtc.RtpParameters
 import kotlin.math.abs
 import kotlin.math.abs
+import kotlin.math.ceil
 import kotlin.math.max
 import kotlin.math.max
 import kotlin.math.min
 import kotlin.math.min
+import kotlin.math.pow
+import kotlin.math.roundToInt
 
 
 internal object EncodingUtils {
 internal object EncodingUtils {
 
 
@@ -83,6 +87,7 @@ internal object EncodingUtils {
         trackWidth: Int,
         trackWidth: Int,
         trackHeight: Int,
         trackHeight: Int,
         encodings: List<RtpParameters.Encoding>,
         encodings: List<RtpParameters.Encoding>,
+        isSVC: Boolean,
     ): List<LivekitModels.VideoLayer> {
     ): List<LivekitModels.VideoLayer> {
         return if (encodings.isEmpty()) {
         return if (encodings.isEmpty()) {
             listOf(
             listOf(
@@ -94,6 +99,19 @@ internal object EncodingUtils {
                     ssrc = 0
                     ssrc = 0
                 }.build(),
                 }.build(),
             )
             )
+        } else if (isSVC) {
+            val encodingSM = encodings.first().scalabilityMode!!
+            val scalabilityMode = ScalabilityMode.parseFromString(encodingSM)
+            val maxBitrate = encodings.first().maxBitrateBps ?: 0
+            (0 until scalabilityMode.spatial).map { index ->
+                LivekitModels.VideoLayer.newBuilder().apply {
+                    width = ceil(trackWidth / (2f.pow(index))).roundToInt()
+                    height = ceil(trackHeight / (2f.pow(index))).roundToInt()
+                    quality = LivekitModels.VideoQuality.forNumber(LivekitModels.VideoQuality.HIGH.number - index)
+                    bitrate = ceil(maxBitrate / 3f.pow(index)).roundToInt()
+                    ssrc = 0
+                }.build()
+            }
         } else {
         } else {
             encodings.map { encoding ->
             encodings.map { encoding ->
                 val scaleDownBy = encoding.scaleResolutionDownBy ?: 1.0
                 val scaleDownBy = encoding.scaleResolutionDownBy ?: 1.0

@@ -17,6 +17,6 @@
 package io.livekit.android.util
 package io.livekit.android.util
 
 
 sealed class Either<out A, out B> {
 sealed class Either<out A, out B> {
-    class Left<A>(val value: A) : Either<A, Nothing>()
-    class Right<B>(val value: B) : Either<Nothing, B>()
+    class Left<out A>(val value: A) : Either<A, Nothing>()
+    class Right<out B>(val value: B) : Either<Nothing, B>()
 }
 }

@@ -23,7 +23,7 @@ import org.webrtc.VideoDecoder
 import org.webrtc.VideoDecoderFactory
 import org.webrtc.VideoDecoderFactory
 import org.webrtc.WrappedVideoDecoderFactory
 import org.webrtc.WrappedVideoDecoderFactory
 
 
-class CustomVideoDecoderFactory(
+open class CustomVideoDecoderFactory(
     sharedContext: EglBase.Context?,
     sharedContext: EglBase.Context?,
     private var forceSWCodec: Boolean = false,
     private var forceSWCodec: Boolean = false,
     private var forceSWCodecs: List<String> = listOf("VP9"),
     private var forceSWCodecs: List<String> = listOf("VP9"),

@@ -22,7 +22,7 @@ import org.webrtc.VideoCodecInfo
 import org.webrtc.VideoEncoder
 import org.webrtc.VideoEncoder
 import org.webrtc.VideoEncoderFactory
 import org.webrtc.VideoEncoderFactory
 
 
-class CustomVideoEncoderFactory(
+open class CustomVideoEncoderFactory(
     sharedContext: EglBase.Context?,
     sharedContext: EglBase.Context?,
     enableIntelVp8Encoder: Boolean,
     enableIntelVp8Encoder: Boolean,
     enableH264HighProfile: Boolean,
     enableH264HighProfile: Boolean,

+/*
+ * 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 android.gov.nist.javax.sdp.fields.AttributeField
+import android.javax.sdp.MediaDescription
+import io.livekit.android.util.LKLog
+
+data class SdpRtp(val payload: Long, val codec: String, val rate: Long?, val encoding: String?)
+
+fun MediaDescription.getRtps(): List<Pair<AttributeField, SdpRtp>> {
+    return getAttributes(true)
+        .filterIsInstance<AttributeField>()
+        .filter { it.attribute.name == "rtpmap" }
+        .mapNotNull {
+            val rtp = tryParseRtp(it.value)
+            if (rtp == null) {
+                LKLog.w { "could not parse rtpmap: ${it.encode()}" }
+                return@mapNotNull null
+            }
+            it to rtp
+        }
+}
+
+private val RTP = """(\d*) ([\w\-.]*)(?:\s*/(\d*)(?:\s*/(\S*))?)?""".toRegex()
+fun tryParseRtp(string: String): SdpRtp? {
+    val match = RTP.matchEntire(string) ?: return null
+    val (payload, codec, rate, encoding) = match.destructured
+    return SdpRtp(payload.toLong(), codec, toOptionalLong(rate), toOptionalString(encoding))
+}
+
+data class SdpMsid(
+    /** holds the msid-id (and msid-appdata if available) */
+    val value: String,
+)
+
+fun MediaDescription.getMsid(): SdpMsid? {
+    val attribute = getAttribute("msid") ?: return null
+    return SdpMsid(attribute)
+}
+
+data class SdpFmtp(val payload: Long, val config: String) {
+    fun toAttributeField(): AttributeField {
+        return AttributeField().apply {
+            name = "fmtp"
+            value = "$payload $config"
+        }
+    }
+}
+
+fun MediaDescription.getFmtps(): List<Pair<AttributeField, SdpFmtp>> {
+    return getAttributes(true)
+        .filterIsInstance<AttributeField>()
+        .filter { it.attribute.name == "fmtp" }
+        .mapNotNull {
+            val fmtp = tryParseFmtp(it.value)
+            if (fmtp == null) {
+                LKLog.w { "could not parse fmtp: ${it.encode()}" }
+                return@mapNotNull null
+            }
+            it to fmtp
+        }
+}
+
+private val FMTP = """(\d*) ([\S| ]*)""".toRegex()
+fun tryParseFmtp(string: String): SdpFmtp? {
+    val match = FMTP.matchEntire(string) ?: return null
+    val (payload, config) = match.destructured
+    return SdpFmtp(payload.toLong(), config)
+}
+
+data class SdpExt(val value: Long, val direction: String?, val encryptUri: String?, val uri: String, val config: String?) {
+    fun toAttributeField(): AttributeField {
+        return AttributeField().apply {
+            name = "extmap"
+            value = buildString {
+                append(this@SdpExt.value)
+                if (direction != null) {
+                    append(" $direction")
+                }
+                if (encryptUri != null) {
+                    append(" $encryptUri")
+                }
+                append(" $uri")
+                if (config != null) {
+                    append(" $config")
+                }
+            }
+        }
+    }
+}
+
+fun MediaDescription.getExts(): List<Pair<AttributeField, SdpExt>> {
+    return getAttributes(true)
+        .filterIsInstance<AttributeField>()
+        .filter { it.attribute.name == "extmap" }
+        .mapNotNull {
+            val ext = tryParseExt(it.value)
+            if (ext == null) {
+                LKLog.w { "could not parse extmap: ${it.encode()}" }
+                return@mapNotNull null
+            }
+            it to ext
+        }
+}
+
+private val EXT = """(\d+)(?:/(\w+))?(?: (urn:ietf:params:rtp-hdrext:encrypt))? (\S*)(?: (\S*))?""".toRegex()
+fun tryParseExt(string: String): SdpExt? {
+    val match = EXT.matchEntire(string) ?: return null
+    val (value, direction, encryptUri, uri, config) = match.destructured
+    return SdpExt(value.toLong(), toOptionalString(direction), toOptionalString(encryptUri), uri, toOptionalString(config))
+}
+
+fun toOptionalLong(str: String): Long? = if (str.isEmpty()) null else str.toLong()
+fun toOptionalString(str: String): String? = str.ifEmpty { null }

+/*
+ * 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 io.livekit.android.dagger.CapabilitiesGetter
+import io.livekit.android.util.LKLog
+import org.webrtc.MediaStreamTrack
+import org.webrtc.RtpCapabilities
+import org.webrtc.RtpTransceiver
+
+internal fun RtpTransceiver.sortVideoCodecPreferences(targetCodec: String, capabilitiesGetter: CapabilitiesGetter) {
+    val capabilities = capabilitiesGetter(MediaStreamTrack.MediaType.MEDIA_TYPE_VIDEO)
+    LKLog.v { "capabilities:" }
+    capabilities.codecs.forEach { codec ->
+        LKLog.v { "codec: ${codec.name}, ${codec.kind}, ${codec.mimeType}, ${codec.parameters}, ${codec.preferredPayloadType}" }
+    }
+
+    val matched = mutableListOf<RtpCapabilities.CodecCapability>()
+    val partialMatched = mutableListOf<RtpCapabilities.CodecCapability>()
+    val unmatched = mutableListOf<RtpCapabilities.CodecCapability>()
+
+    for (codec in capabilities.codecs) {
+        val mimeType = codec.mimeType.lowercase()
+        if (mimeType == "audio/opus") {
+            matched.add(codec)
+            continue
+        }
+
+        if (mimeType != "video/$targetCodec") {
+            unmatched.add(codec)
+            continue
+        }
+        // for h264 codecs that have sdpFmtpLine available, use only if the
+        // profile-level-id is 42e01f for cross-browser compatibility
+        if (targetCodec == "h264") {
+            if (codec.parameters["profile-level-id"] == "42e01f") {
+                matched.add(codec)
+            } else {
+                partialMatched.add(codec)
+            }
+            continue
+        } else {
+            matched.add(codec)
+        }
+    }
+    setCodecPreferences(matched.plus(partialMatched).plus(unmatched))
+}

@@ -18,9 +18,10 @@ package io.livekit.android.mock
 
 
 import org.webrtc.VideoSink
 import org.webrtc.VideoSink
 import org.webrtc.VideoTrack
 import org.webrtc.VideoTrack
+import java.util.UUID
 
 
 class MockVideoStreamTrack(
 class MockVideoStreamTrack(
-    val id: String = "id",
+    val id: String = UUID.randomUUID().toString(),
     val kind: String = VIDEO_TRACK_KIND,
     val kind: String = VIDEO_TRACK_KIND,
     var enabled: Boolean = true,
     var enabled: Boolean = true,
     var state: State = State.LIVE,
     var state: State = State.LIVE,

@@ -23,6 +23,7 @@ import livekit.LivekitRtc
 import okhttp3.Request
 import okhttp3.Request
 import okhttp3.WebSocket
 import okhttp3.WebSocket
 import okhttp3.WebSocketListener
 import okhttp3.WebSocketListener
+import okio.ByteString
 
 
 class MockWebSocketFactory : WebSocket.Factory {
 class MockWebSocketFactory : WebSocket.Factory {
     /**
     /**
@@ -67,4 +68,8 @@ class MockWebSocketFactory : WebSocket.Factory {
     }
     }
 
 
     var onOpen: ((MockWebSocketFactory) -> Unit)? = null
     var onOpen: ((MockWebSocketFactory) -> Unit)? = null
+
+    fun receiveMessage(byteString: ByteString) {
+        listener.onMessage(ws, byteString)
+    }
 }
 }

@@ -17,6 +17,7 @@
 package io.livekit.android.mock.dagger
 package io.livekit.android.mock.dagger
 
 
 import android.content.Context
 import android.content.Context
+import android.javax.sdp.SdpFactory
 import dagger.Module
 import dagger.Module
 import dagger.Provides
 import dagger.Provides
 import io.livekit.android.dagger.CapabilitiesGetter
 import io.livekit.android.dagger.CapabilitiesGetter
@@ -59,4 +60,7 @@ object TestRTCModule {
     @Provides
     @Provides
     @Named(InjectionNames.OPTIONS_VIDEO_HW_ACCEL)
     @Named(InjectionNames.OPTIONS_VIDEO_HW_ACCEL)
     fun videoHwAccel() = true
     fun videoHwAccel() = true
+
+    @Provides
+    fun sdpFactory() = SdpFactory.getInstance()
 }
 }

+/*
+ * 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.room
+
+import android.javax.sdp.MediaDescription
+import android.javax.sdp.SdpFactory
+import io.livekit.android.webrtc.JainSdpUtilsTest
+import io.livekit.android.webrtc.getExts
+import io.livekit.android.webrtc.getFmtps
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class SdpMungingTest {
+
+    @Test
+    fun ensureVideoDDExtensionForSVCTest() {
+        val sdp = SdpFactory.getInstance().createSessionDescription(NO_DD_DESCRIPTION)
+        val mediaDescription = sdp.getMediaDescriptions(true).filterIsInstance<MediaDescription>()[1]
+
+        ensureVideoDDExtensionForSVC(mediaDescription)
+
+        val exts = mediaDescription.getExts()
+
+        assertEquals(12, exts.size)
+
+        val ddExtPair = exts.find { it.second.value == 12L }
+
+        assertNotNull(ddExtPair)
+        val (_, ext) = ddExtPair!!
+
+        assertEquals(12, ext.value)
+        assertNull(ext.direction)
+        assertNull(ext.encryptUri)
+        assertEquals("https://aomediacodec.github.io/av1-rtp-spec/#dependency-descriptor-rtp-header-extension", ext.uri)
+        assertNull(ext.config)
+    }
+
+    @Test
+    fun ensureCodecBitratesTest() {
+        val sdp = SdpFactory.getInstance().createSessionDescription(JainSdpUtilsTest.DESCRIPTION)
+        val mediaDescription = sdp.getMediaDescriptions(true).filterIsInstance<MediaDescription>()[1]
+
+        ensureCodecBitrates(
+            mediaDescription,
+            mapOf(
+                TrackBitrateInfoKey.Cid("PA_Qwqk4y9fcD3G") to
+                    TrackBitrateInfo(
+                        "VP9",
+                        1000000L,
+                    ),
+            ),
+        )
+
+        val (_, vp9fmtp) = mediaDescription.getFmtps()
+            .filter { (_, fmtp) -> fmtp.payload == 98L }
+            .first()
+
+        assertEquals("profile-id=0;x-google-start-bitrate=700000;x-google-max-bitrate=1000000", vp9fmtp.config)
+    }
+
+    companion object {
+        const val NO_DD_DESCRIPTION = "v=0\n" +
+            "o=- 3682890773448528616 3 IN IP4 127.0.0.1\n" +
+            "s=-\n" +
+            "t=0 0\n" +
+            "a=group:BUNDLE 0 1\n" +
+            "a=extmap-allow-mixed\n" +
+            "a=msid-semantic: WMS PA_Qwqk4y9fcD3G\n" +
+            "m=application 24436 UDP/DTLS/SCTP webrtc-datachannel\n" +
+            "c=IN IP4 45.76.222.83\n" +
+            "a=candidate:1660983843 1 udp 2122194687 192.168.0.22 37324 typ host generation 0 network-id 5 network-cost 10\n" +
+            "a=candidate:901011812 1 udp 2122262783 2400:4050:28c2:200:9ce6:9cff:fe22:a74d 48779 typ host generation 0 network-id 6 network-cost 10\n" +
+            "a=candidate:3061937641 1 udp 1685987071 123.222.220.24 37324 typ srflx raddr 192.168.0.22 rport 37324 generation 0 network-id 5 network-cost 10\n" +
+            "a=candidate:689824452 1 tcp 1518083839 10.244.232.137 9 typ host tcptype active generation 0 network-id 3 network-cost 900\n" +
+            "a=candidate:2149072150 1 tcp 1518151935 2407:5300:1029:7a1f:96b6:6f1e:ec66:64d8 9 typ host tcptype active generation 0 network-id 4 network-cost 900\n" +
+            "a=candidate:3396018872 1 udp 41820671 45.76.222.83 24436 typ relay raddr 123.222.220.24 rport 37324 generation 0 network-id 5 network-cost 10\n" +
+            "a=ice-ufrag:+2SN\n" +
+            "a=ice-pwd:cdmp3JptAqdOA9VRHrNsdKE9\n" +
+            "a=ice-options:trickle renomination\n" +
+            "a=fingerprint:sha-256 44:C7:59:DD:54:91:AC:EA:93:07:8E:4F:78:C5:A6:9B:FB:C3:16:2B:95:1C:9E:DB:3B:AE:8A:E5:76:37:6F:A2\n" +
+            "a=setup:actpass\n" +
+            "a=mid:0\n" +
+            "a=sctp-port:5000\n" +
+            "a=max-message-size:262144\n" +
+            "m=video 9 UDP/TLS/RTP/SAVPF 96 97 127 103 104 105 39 40 98 99 106 107 108\n" +
+            "c=IN IP4 0.0.0.0\n" +
+            "a=rtcp:9 IN IP4 0.0.0.0\n" +
+            "a=ice-ufrag:+2SN\n" +
+            "a=ice-pwd:cdmp3JptAqdOA9VRHrNsdKE9\n" +
+            "a=ice-options:trickle renomination\n" +
+            "a=fingerprint:sha-256 44:C7:59:DD:54:91:AC:EA:93:07:8E:4F:78:C5:A6:9B:FB:C3:16:2B:95:1C:9E:DB:3B:AE:8A:E5:76:37:6F:A2\n" +
+            "a=setup:actpass\n" +
+            "a=mid:1\n" +
+            "a=extmap:1 urn:ietf:params:rtp-hdrext:toffset\n" +
+            "a=extmap:2 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time\n" +
+            "a=extmap:3 urn:3gpp:video-orientation\n" +
+            "a=extmap:4 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01\n" +
+            "a=extmap:5 http://www.webrtc.org/experiments/rtp-hdrext/playout-delay\n" +
+            "a=extmap:6 http://www.webrtc.org/experiments/rtp-hdrext/video-content-type\n" +
+            "a=extmap:7 http://www.webrtc.org/experiments/rtp-hdrext/video-timing\n" +
+            "a=extmap:8 http://www.webrtc.org/experiments/rtp-hdrext/color-space\n" +
+            "a=extmap:9 urn:ietf:params:rtp-hdrext:sdes:mid\n" +
+            "a=extmap:10 urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id\n" +
+            "a=extmap:11 urn:ietf:params:rtp-hdrext:sdes:repaired-rtp-stream-id\n" +
+            "a=sendonly\n" +
+            "a=msid:PA_Qwqk4y9fcD3G 42dd9185-4ea2-4bf1-b964-1dc0eb739c6c\n" +
+            "a=rtcp-mux\n" +
+            "a=rtcp-rsize\n" +
+            "a=rtpmap:98 VP9/90000\n" +
+            "a=rtcp-fb:98 goog-remb\n" +
+            "a=rtcp-fb:98 transport-cc\n" +
+            "a=rtcp-fb:98 ccm fir\n" +
+            "a=rtcp-fb:98 nack\n" +
+            "a=rtcp-fb:98 nack pli\n" +
+            "a=fmtp:98 profile-id=0\n" +
+            "a=rtpmap:96 VP8/90000\n" +
+            "a=rtcp-fb:96 goog-remb\n" +
+            "a=rtcp-fb:96 transport-cc\n" +
+            "a=rtcp-fb:96 ccm fir\n" +
+            "a=rtcp-fb:96 nack\n" +
+            "a=rtcp-fb:96 nack pli\n" +
+            "a=rtpmap:97 rtx/90000\n" +
+            "a=fmtp:97 apt=96\n" +
+            "a=rtpmap:127 H264/90000\n" +
+            "a=rtcp-fb:127 goog-remb\n" +
+            "a=rtcp-fb:127 transport-cc\n" +
+            "a=rtcp-fb:127 ccm fir\n" +
+            "a=rtcp-fb:127 nack\n" +
+            "a=rtcp-fb:127 nack pli\n" +
+            "a=fmtp:127 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f\n" +
+            "a=rtpmap:103 rtx/90000\n" +
+            "a=fmtp:103 apt=127\n" +
+            "a=rtpmap:104 H265/90000\n" +
+            "a=rtcp-fb:104 goog-remb\n" +
+            "a=rtcp-fb:104 transport-cc\n" +
+            "a=rtcp-fb:104 ccm fir\n" +
+            "a=rtcp-fb:104 nack\n" +
+            "a=rtcp-fb:104 nack pli\n" +
+            "a=rtpmap:105 rtx/90000\n" +
+            "a=fmtp:105 apt=104\n" +
+            "a=rtpmap:39 AV1/90000\n" +
+            "a=rtcp-fb:39 goog-remb\n" +
+            "a=rtcp-fb:39 transport-cc\n" +
+            "a=rtcp-fb:39 ccm fir\n" +
+            "a=rtcp-fb:39 nack\n" +
+            "a=rtcp-fb:39 nack pli\n" +
+            "a=rtpmap:40 rtx/90000\n" +
+            "a=fmtp:40 apt=39\n" +
+            "a=rtpmap:99 rtx/90000\n" +
+            "a=fmtp:99 apt=98\n" +
+            "a=rtpmap:106 red/90000\n" +
+            "a=rtpmap:107 rtx/90000\n" +
+            "a=fmtp:107 apt=106\n" +
+            "a=rtpmap:108 ulpfec/90000\n" +
+            "a=rid:h send\n" +
+            "a=rid:q send\n" +
+            "a=simulcast:send h;q"
+    }
+}

@@ -23,6 +23,7 @@ import io.livekit.android.events.ParticipantEvent
 import io.livekit.android.events.RoomEvent
 import io.livekit.android.events.RoomEvent
 import io.livekit.android.mock.MockAudioStreamTrack
 import io.livekit.android.mock.MockAudioStreamTrack
 import io.livekit.android.mock.MockEglBase
 import io.livekit.android.mock.MockEglBase
+import io.livekit.android.mock.MockPeerConnection
 import io.livekit.android.mock.MockVideoCapturer
 import io.livekit.android.mock.MockVideoCapturer
 import io.livekit.android.mock.MockVideoStreamTrack
 import io.livekit.android.mock.MockVideoStreamTrack
 import io.livekit.android.room.DefaultsManager
 import io.livekit.android.room.DefaultsManager
@@ -31,10 +32,14 @@ import io.livekit.android.room.track.LocalAudioTrack
 import io.livekit.android.room.track.LocalVideoTrack
 import io.livekit.android.room.track.LocalVideoTrack
 import io.livekit.android.room.track.LocalVideoTrackOptions
 import io.livekit.android.room.track.LocalVideoTrackOptions
 import io.livekit.android.room.track.VideoCaptureParameter
 import io.livekit.android.room.track.VideoCaptureParameter
+import io.livekit.android.room.track.VideoCodec
 import io.livekit.android.util.toOkioByteString
 import io.livekit.android.util.toOkioByteString
 import io.livekit.android.util.toPBByteString
 import io.livekit.android.util.toPBByteString
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.ExperimentalCoroutinesApi
+import livekit.LivekitModels
 import livekit.LivekitRtc
 import livekit.LivekitRtc
+import livekit.LivekitRtc.SubscribedCodec
+import livekit.LivekitRtc.SubscribedQuality
 import org.junit.Assert.*
 import org.junit.Assert.*
 import org.junit.Test
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runner.RunWith
@@ -200,4 +205,108 @@ class LocalParticipantMockE2ETest : MockE2ETest() {
             },
             },
         )
         )
     }
     }
+
+    @Test
+    fun publishSvcCodec() = runTest {
+        room.videoTrackPublishDefaults = room.videoTrackPublishDefaults.copy(
+            videoCodec = VideoCodec.VP9.codecName,
+            scalabilityMode = "L3T3",
+            backupCodec = BackupVideoCodec(codec = VideoCodec.VP8.codecName),
+        )
+
+        connect()
+        wsFactory.ws.clearRequests()
+        room.localParticipant.publishVideoTrack(track = createLocalTrack())
+
+        // Expect add track request to contain both primary and backup
+        assertEquals(1, wsFactory.ws.sentRequests.size)
+
+        val requestString = wsFactory.ws.sentRequests[0]
+        val signalRequest = LivekitRtc.SignalRequest.newBuilder()
+            .mergeFrom(requestString.toPBByteString())
+            .build()
+        assertTrue(signalRequest.hasAddTrack())
+
+        val addTrackRequest = signalRequest.addTrack
+        assertEquals(2, addTrackRequest.simulcastCodecsList.size)
+
+        val vp9Codec = addTrackRequest.simulcastCodecsList[0]
+        assertEquals("vp9", vp9Codec.codec)
+
+        val vp8Codec = addTrackRequest.simulcastCodecsList[1]
+        assertEquals("vp8", vp8Codec.codec)
+
+        val publisherConn = component.rtcEngine().publisher.peerConnection as MockPeerConnection
+
+        assertEquals(1, publisherConn.transceivers.size)
+        Mockito.verify(publisherConn.transceivers.first()).setCodecPreferences(
+            argThat { codecs ->
+                val preferredCodec = codecs.first()
+                return@argThat preferredCodec.name.lowercase() == "vp9"
+            },
+        )
+
+        // Ensure the newly subscribed vp8 codec gets added as a new transceiver.
+        wsFactory.receiveMessage(
+            with(LivekitRtc.SignalResponse.newBuilder()) {
+                subscribedQualityUpdate = with(LivekitRtc.SubscribedQualityUpdate.newBuilder()) {
+                    trackSid = room.localParticipant.videoTracks.first().first.sid
+                    addAllSubscribedCodecs(
+                        listOf(
+                            with(SubscribedCodec.newBuilder()) {
+                                codec = "vp9"
+                                addAllQualities(
+                                    listOf(
+                                        SubscribedQuality.newBuilder()
+                                            .setQuality(LivekitModels.VideoQuality.HIGH)
+                                            .setEnabled(true)
+                                            .build(),
+                                        SubscribedQuality.newBuilder()
+                                            .setQuality(LivekitModels.VideoQuality.MEDIUM)
+                                            .setEnabled(true)
+                                            .build(),
+                                        SubscribedQuality.newBuilder()
+                                            .setQuality(LivekitModels.VideoQuality.LOW)
+                                            .setEnabled(true)
+                                            .build(),
+                                    ),
+                                )
+                                build()
+                            },
+                            with(SubscribedCodec.newBuilder()) {
+                                codec = "vp8"
+                                addAllQualities(
+                                    listOf(
+                                        SubscribedQuality.newBuilder()
+                                            .setQuality(LivekitModels.VideoQuality.HIGH)
+                                            .setEnabled(true)
+                                            .build(),
+                                        SubscribedQuality.newBuilder()
+                                            .setQuality(LivekitModels.VideoQuality.MEDIUM)
+                                            .setEnabled(true)
+                                            .build(),
+                                        SubscribedQuality.newBuilder()
+                                            .setQuality(LivekitModels.VideoQuality.LOW)
+                                            .setEnabled(true)
+                                            .build(),
+                                    ),
+                                )
+                                build()
+                            },
+                        ),
+                    )
+                    build()
+                }
+                build().toOkioByteString()
+            },
+        )
+
+        assertEquals(2, publisherConn.transceivers.size)
+        Mockito.verify(publisherConn.transceivers.last()).setCodecPreferences(
+            argThat { codecs ->
+                val preferredCodec = codecs.first()
+                return@argThat preferredCodec.name.lowercase() == "vp8"
+            },
+        )
+    }
 }
 }

+/*
+ * 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.room.track.video
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class ScalabilityModeTest {
+
+    @Test
+    fun testL1T3() {
+        val mode = ScalabilityMode.parseFromString("L1T3")
+
+        assertEquals(1, mode.spatial)
+        assertEquals(3, mode.temporal)
+        assertEquals("", mode.suffix)
+    }
+
+    @Test
+    fun testL3T3_KEY() {
+        val mode = ScalabilityMode.parseFromString("L3T3_KEY")
+
+        assertEquals(3, mode.spatial)
+        assertEquals(3, mode.temporal)
+        assertEquals("_KEY", mode.suffix)
+    }
+}

+/*
+ * 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 android.javax.sdp.MediaDescription
+import android.javax.sdp.SdpFactory
+import android.javax.sdp.SessionDescription
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class JainSdpUtilsTest {
+
+    private val sdpFactory = SdpFactory.getInstance()
+    private fun createSessionDescription(): SessionDescription {
+        return sdpFactory.createSessionDescription(DESCRIPTION)
+    }
+
+    @Test
+    fun getRtpAttributes() {
+        val sdp = createSessionDescription()
+        val mediaDescriptions = sdp.getMediaDescriptions(true)
+            .filterIsInstance<MediaDescription>()
+        val mediaDesc = mediaDescriptions[1]
+        val rtps = mediaDesc.getRtps()
+        assertEquals(13, rtps.size)
+
+        val (_, vp8Rtp) = rtps[0]
+
+        assertEquals(96, vp8Rtp.payload)
+        assertEquals("VP8", vp8Rtp.codec)
+        assertEquals(90000L, vp8Rtp.rate)
+        assertNull(vp8Rtp.encoding)
+    }
+
+    @Test
+    fun getExtmapAttributes() {
+        val sdp = createSessionDescription()
+        val mediaDescriptions = sdp.getMediaDescriptions(true)
+            .filterIsInstance<MediaDescription>()
+        val mediaDesc = mediaDescriptions[1]
+        val exts = mediaDesc.getExts()
+
+        assertEquals(12, exts.size)
+
+        val (_, ext) = exts[0]
+        assertEquals(1, ext.value)
+        assertNull(ext.direction)
+        assertNull(ext.encryptUri)
+        assertEquals("urn:ietf:params:rtp-hdrext:toffset", ext.uri)
+        assertNull(ext.config)
+    }
+
+    @Test
+    fun getMsid() {
+        val sdp = createSessionDescription()
+        val mediaDescriptions = sdp.getMediaDescriptions(true)
+            .filterIsInstance<MediaDescription>()
+        val mediaDesc = mediaDescriptions[1]
+
+        val msid = mediaDesc.getMsid()
+        assertNotNull(msid)
+        assertEquals("PA_Qwqk4y9fcD3G 42dd9185-4ea2-4bf1-b964-1dc0eb739c6c", msid!!.value)
+    }
+
+    @Test
+    fun getFmtps() {
+        val sdp = createSessionDescription()
+        val mediaDescriptions = sdp.getMediaDescriptions(true)
+            .filterIsInstance<MediaDescription>()
+        val mediaDesc = mediaDescriptions[1]
+
+        val fmtps = mediaDesc.getFmtps()
+            .filter { (_, fmtp) -> fmtp.payload == 97L }
+        assertEquals(1, fmtps.size)
+
+        val (_, fmtp) = fmtps[0]
+        assertEquals("apt=96", fmtp.config)
+    }
+
+    companion object {
+        const val DESCRIPTION = "v=0\n" +
+            "o=- 3682890773448528616 3 IN IP4 127.0.0.1\n" +
+            "s=-\n" +
+            "t=0 0\n" +
+            "a=group:BUNDLE 0 1\n" +
+            "a=extmap-allow-mixed\n" +
+            "a=msid-semantic: WMS PA_Qwqk4y9fcD3G\n" +
+            "m=application 24436 UDP/DTLS/SCTP webrtc-datachannel\n" +
+            "c=IN IP4 45.76.222.83\n" +
+            "a=candidate:1660983843 1 udp 2122194687 192.168.0.22 37324 typ host generation 0 network-id 5 network-cost 10\n" +
+            "a=candidate:901011812 1 udp 2122262783 2400:4050:28c2:200:9ce6:9cff:fe22:a74d 48779 typ host generation 0 network-id 6 network-cost 10\n" +
+            "a=candidate:3061937641 1 udp 1685987071 123.222.220.24 37324 typ srflx raddr 192.168.0.22 rport 37324 generation 0 network-id 5 network-cost 10\n" +
+            "a=candidate:689824452 1 tcp 1518083839 10.244.232.137 9 typ host tcptype active generation 0 network-id 3 network-cost 900\n" +
+            "a=candidate:2149072150 1 tcp 1518151935 2407:5300:1029:7a1f:96b6:6f1e:ec66:64d8 9 typ host tcptype active generation 0 network-id 4 network-cost 900\n" +
+            "a=candidate:3396018872 1 udp 41820671 45.76.222.83 24436 typ relay raddr 123.222.220.24 rport 37324 generation 0 network-id 5 network-cost 10\n" +
+            "a=ice-ufrag:+2SN\n" +
+            "a=ice-pwd:cdmp3JptAqdOA9VRHrNsdKE9\n" +
+            "a=ice-options:trickle renomination\n" +
+            "a=fingerprint:sha-256 44:C7:59:DD:54:91:AC:EA:93:07:8E:4F:78:C5:A6:9B:FB:C3:16:2B:95:1C:9E:DB:3B:AE:8A:E5:76:37:6F:A2\n" +
+            "a=setup:actpass\n" +
+            "a=mid:0\n" +
+            "a=sctp-port:5000\n" +
+            "a=max-message-size:262144\n" +
+            "m=video 9 UDP/TLS/RTP/SAVPF 96 97 127 103 104 105 39 40 98 99 106 107 108\n" +
+            "c=IN IP4 0.0.0.0\n" +
+            "a=rtcp:9 IN IP4 0.0.0.0\n" +
+            "a=ice-ufrag:+2SN\n" +
+            "a=ice-pwd:cdmp3JptAqdOA9VRHrNsdKE9\n" +
+            "a=ice-options:trickle renomination\n" +
+            "a=fingerprint:sha-256 44:C7:59:DD:54:91:AC:EA:93:07:8E:4F:78:C5:A6:9B:FB:C3:16:2B:95:1C:9E:DB:3B:AE:8A:E5:76:37:6F:A2\n" +
+            "a=setup:actpass\n" +
+            "a=mid:1\n" +
+            "a=extmap:1 urn:ietf:params:rtp-hdrext:toffset\n" +
+            "a=extmap:2 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time\n" +
+            "a=extmap:3 urn:3gpp:video-orientation\n" +
+            "a=extmap:4 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01\n" +
+            "a=extmap:5 http://www.webrtc.org/experiments/rtp-hdrext/playout-delay\n" +
+            "a=extmap:6 http://www.webrtc.org/experiments/rtp-hdrext/video-content-type\n" +
+            "a=extmap:7 http://www.webrtc.org/experiments/rtp-hdrext/video-timing\n" +
+            "a=extmap:8 http://www.webrtc.org/experiments/rtp-hdrext/color-space\n" +
+            "a=extmap:9 urn:ietf:params:rtp-hdrext:sdes:mid\n" +
+            "a=extmap:10 urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id\n" +
+            "a=extmap:11 urn:ietf:params:rtp-hdrext:sdes:repaired-rtp-stream-id\n" +
+            "a=extmap:12 https://aomediacodec.github.io/av1-rtp-spec/#dependency-descriptor-rtp-header-extension\n" +
+            "a=sendonly\n" +
+            "a=msid:PA_Qwqk4y9fcD3G 42dd9185-4ea2-4bf1-b964-1dc0eb739c6c\n" +
+            "a=rtcp-mux\n" +
+            "a=rtcp-rsize\n" +
+            "a=rtpmap:96 VP8/90000\n" +
+            "a=rtcp-fb:96 goog-remb\n" +
+            "a=rtcp-fb:96 transport-cc\n" +
+            "a=rtcp-fb:96 ccm fir\n" +
+            "a=rtcp-fb:96 nack\n" +
+            "a=rtcp-fb:96 nack pli\n" +
+            "a=rtpmap:97 rtx/90000\n" +
+            "a=fmtp:97 apt=96\n" +
+            "a=rtpmap:127 H264/90000\n" +
+            "a=rtcp-fb:127 goog-remb\n" +
+            "a=rtcp-fb:127 transport-cc\n" +
+            "a=rtcp-fb:127 ccm fir\n" +
+            "a=rtcp-fb:127 nack\n" +
+            "a=rtcp-fb:127 nack pli\n" +
+            "a=fmtp:127 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f\n" +
+            "a=rtpmap:103 rtx/90000\n" +
+            "a=fmtp:103 apt=127\n" +
+            "a=rtpmap:104 H265/90000\n" +
+            "a=rtcp-fb:104 goog-remb\n" +
+            "a=rtcp-fb:104 transport-cc\n" +
+            "a=rtcp-fb:104 ccm fir\n" +
+            "a=rtcp-fb:104 nack\n" +
+            "a=rtcp-fb:104 nack pli\n" +
+            "a=rtpmap:105 rtx/90000\n" +
+            "a=fmtp:105 apt=104\n" +
+            "a=rtpmap:39 AV1/90000\n" +
+            "a=rtcp-fb:39 goog-remb\n" +
+            "a=rtcp-fb:39 transport-cc\n" +
+            "a=rtcp-fb:39 ccm fir\n" +
+            "a=rtcp-fb:39 nack\n" +
+            "a=rtcp-fb:39 nack pli\n" +
+            "a=rtpmap:40 rtx/90000\n" +
+            "a=fmtp:40 apt=39\n" +
+            "a=rtpmap:98 VP9/90000\n" +
+            "a=rtcp-fb:98 goog-remb\n" +
+            "a=rtcp-fb:98 transport-cc\n" +
+            "a=rtcp-fb:98 ccm fir\n" +
+            "a=rtcp-fb:98 nack\n" +
+            "a=rtcp-fb:98 nack pli\n" +
+            "a=fmtp:98 profile-id=0\n" +
+            "a=rtpmap:99 rtx/90000\n" +
+            "a=fmtp:99 apt=98\n" +
+            "a=rtpmap:106 red/90000\n" +
+            "a=rtpmap:107 rtx/90000\n" +
+            "a=fmtp:107 apt=106\n" +
+            "a=rtpmap:108 ulpfec/90000\n" +
+            "a=rid:h send\n" +
+            "a=rid:q send\n" +
+            "a=simulcast:send h;q"
+    }
+}

@@ -63,6 +63,18 @@ class MockPeerConnectionFactory : PeerConnectionFactory(1L) {
                     kind = MediaStreamTrack.MediaType.MEDIA_TYPE_VIDEO
                     kind = MediaStreamTrack.MediaType.MEDIA_TYPE_VIDEO
                     parameters = mapOf("profile-level-id" to "42e01f")
                     parameters = mapOf("profile-level-id" to "42e01f")
                 },
                 },
+                RtpCapabilities.CodecCapability().apply {
+                    name = "AV1"
+                    mimeType = "video/AV1"
+                    kind = MediaStreamTrack.MediaType.MEDIA_TYPE_VIDEO
+                    parameters = emptyMap()
+                },
+                RtpCapabilities.CodecCapability().apply {
+                    name = "VP9"
+                    mimeType = "video/VP9"
+                    kind = MediaStreamTrack.MediaType.MEDIA_TYPE_VIDEO
+                    parameters = mapOf("profile-id" to "0")
+                },
             ),
             ),
             emptyList(),
             emptyList(),
         )
         )

--Subproject commit 519c96683da8b98f214d42810c1608ddb794cf2e
++Subproject commit a187ed4f546b4f6881313ec4813268d53cb070f8