summaryrefslogtreecommitdiffstats
path: root/dom/media/webrtc/jsapi/RTCRtpTransceiver.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--dom/media/webrtc/jsapi/RTCRtpTransceiver.cpp1080
1 files changed, 1080 insertions, 0 deletions
diff --git a/dom/media/webrtc/jsapi/RTCRtpTransceiver.cpp b/dom/media/webrtc/jsapi/RTCRtpTransceiver.cpp
new file mode 100644
index 0000000000..bf4f74dd5d
--- /dev/null
+++ b/dom/media/webrtc/jsapi/RTCRtpTransceiver.cpp
@@ -0,0 +1,1080 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "jsapi/RTCRtpTransceiver.h"
+#include "mozilla/UniquePtr.h"
+#include <algorithm>
+#include <string>
+#include <vector>
+#include "libwebrtcglue/AudioConduit.h"
+#include "libwebrtcglue/VideoConduit.h"
+#include "MediaTrackGraph.h"
+#include "transportbridge/MediaPipeline.h"
+#include "transportbridge/MediaPipelineFilter.h"
+#include "jsep/JsepTrack.h"
+#include "sdp/SdpHelper.h"
+#include "MediaTrackGraphImpl.h"
+#include "transport/logging.h"
+#include "MediaEngine.h"
+#include "nsIPrincipal.h"
+#include "MediaSegment.h"
+#include "RemoteTrackSource.h"
+#include "libwebrtcglue/RtpRtcpConfig.h"
+#include "MediaTransportHandler.h"
+#include "mozilla/dom/RTCRtpReceiverBinding.h"
+#include "mozilla/dom/RTCRtpSenderBinding.h"
+#include "mozilla/dom/RTCRtpTransceiverBinding.h"
+#include "mozilla/dom/Promise.h"
+#include "RTCDtlsTransport.h"
+#include "RTCRtpReceiver.h"
+#include "RTCRtpSender.h"
+#include "RTCDTMFSender.h"
+#include "systemservices/MediaUtils.h"
+#include "libwebrtcglue/WebrtcCallWrapper.h"
+#include "libwebrtcglue/WebrtcGmpVideoCodec.h"
+#include "utils/PerformanceRecorder.h"
+
+namespace mozilla {
+
+using namespace dom;
+
+namespace {
+struct ConduitControlState : public AudioConduitControlInterface,
+ public VideoConduitControlInterface {
+ ConduitControlState(RTCRtpTransceiver* aTransceiver, RTCRtpSender* aSender,
+ RTCRtpReceiver* aReceiver)
+ : mTransceiver(new nsMainThreadPtrHolder<RTCRtpTransceiver>(
+ "ConduitControlState::mTransceiver", aTransceiver, false)),
+ mSender(new nsMainThreadPtrHolder<dom::RTCRtpSender>(
+ "ConduitControlState::mSender", aSender, false)),
+ mReceiver(new nsMainThreadPtrHolder<dom::RTCRtpReceiver>(
+ "ConduitControlState::mReceiver", aReceiver, false)) {}
+
+ const nsMainThreadPtrHandle<RTCRtpTransceiver> mTransceiver;
+ const nsMainThreadPtrHandle<RTCRtpSender> mSender;
+ const nsMainThreadPtrHandle<RTCRtpReceiver> mReceiver;
+
+ // MediaConduitControlInterface
+ AbstractCanonical<bool>* CanonicalReceiving() override {
+ return mReceiver->CanonicalReceiving();
+ }
+ AbstractCanonical<bool>* CanonicalTransmitting() override {
+ return mSender->CanonicalTransmitting();
+ }
+ AbstractCanonical<Ssrcs>* CanonicalLocalSsrcs() override {
+ return mSender->CanonicalSsrcs();
+ }
+ AbstractCanonical<std::string>* CanonicalLocalCname() override {
+ return mSender->CanonicalCname();
+ }
+ AbstractCanonical<std::string>* CanonicalMid() override {
+ return mTransceiver->CanonicalMid();
+ }
+ AbstractCanonical<Ssrc>* CanonicalRemoteSsrc() override {
+ return mReceiver->CanonicalSsrc();
+ }
+ AbstractCanonical<std::string>* CanonicalSyncGroup() override {
+ return mTransceiver->CanonicalSyncGroup();
+ }
+ AbstractCanonical<RtpExtList>* CanonicalLocalRecvRtpExtensions() override {
+ return mReceiver->CanonicalLocalRtpExtensions();
+ }
+ AbstractCanonical<RtpExtList>* CanonicalLocalSendRtpExtensions() override {
+ return mSender->CanonicalLocalRtpExtensions();
+ }
+
+ // AudioConduitControlInterface
+ AbstractCanonical<Maybe<AudioCodecConfig>>* CanonicalAudioSendCodec()
+ override {
+ return mSender->CanonicalAudioCodec();
+ }
+ AbstractCanonical<std::vector<AudioCodecConfig>>* CanonicalAudioRecvCodecs()
+ override {
+ return mReceiver->CanonicalAudioCodecs();
+ }
+ MediaEventSource<DtmfEvent>& OnDtmfEvent() override {
+ return mSender->GetDtmf()->OnDtmfEvent();
+ }
+
+ // VideoConduitControlInterface
+ AbstractCanonical<Ssrcs>* CanonicalLocalVideoRtxSsrcs() override {
+ return mSender->CanonicalVideoRtxSsrcs();
+ }
+ AbstractCanonical<Ssrc>* CanonicalRemoteVideoRtxSsrc() override {
+ return mReceiver->CanonicalVideoRtxSsrc();
+ }
+ AbstractCanonical<Maybe<VideoCodecConfig>>* CanonicalVideoSendCodec()
+ override {
+ return mSender->CanonicalVideoCodec();
+ }
+ AbstractCanonical<Maybe<RtpRtcpConfig>>* CanonicalVideoSendRtpRtcpConfig()
+ override {
+ return mSender->CanonicalVideoRtpRtcpConfig();
+ }
+ AbstractCanonical<std::vector<VideoCodecConfig>>* CanonicalVideoRecvCodecs()
+ override {
+ return mReceiver->CanonicalVideoCodecs();
+ }
+ AbstractCanonical<Maybe<RtpRtcpConfig>>* CanonicalVideoRecvRtpRtcpConfig()
+ override {
+ return mReceiver->CanonicalVideoRtpRtcpConfig();
+ }
+ AbstractCanonical<webrtc::VideoCodecMode>* CanonicalVideoCodecMode()
+ override {
+ return mSender->CanonicalVideoCodecMode();
+ }
+};
+} // namespace
+
+MOZ_MTLOG_MODULE("RTCRtpTransceiver")
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(RTCRtpTransceiver)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(RTCRtpTransceiver)
+ if (tmp->mHandlingUnlink) {
+ tmp->BreakCycles();
+ tmp->mHandlingUnlink = false;
+ }
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(RTCRtpTransceiver)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWindow, mPc, mSendTrack, mReceiver,
+ mSender, mDtlsTransport,
+ mLastStableDtlsTransport)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(RTCRtpTransceiver)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(RTCRtpTransceiver)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(RTCRtpTransceiver)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+#define INIT_CANONICAL(name, val) \
+ name(AbstractThread::MainThread(), val, \
+ "RTCRtpTransceiver::" #name " (Canonical)")
+
+RTCRtpTransceiver::RTCRtpTransceiver(
+ nsPIDOMWindowInner* aWindow, bool aPrivacyNeeded, PeerConnectionImpl* aPc,
+ MediaTransportHandler* aTransportHandler, JsepSession* aJsepSession,
+ const std::string& aTransceiverId, bool aIsVideo,
+ nsISerialEventTarget* aStsThread, dom::MediaStreamTrack* aSendTrack,
+ WebrtcCallWrapper* aCallWrapper, RTCStatsIdGenerator* aIdGenerator)
+ : mWindow(aWindow),
+ mPc(aPc),
+ mTransportHandler(aTransportHandler),
+ mTransceiverId(aTransceiverId),
+ mJsepTransceiver(*aJsepSession->GetTransceiver(mTransceiverId)),
+ mStsThread(aStsThread),
+ mCallWrapper(aCallWrapper),
+ mSendTrack(aSendTrack),
+ mIdGenerator(aIdGenerator),
+ mPrincipalPrivacy(aPrivacyNeeded ? PrincipalPrivacy::Private
+ : PrincipalPrivacy::NonPrivate),
+ mIsVideo(aIsVideo),
+ INIT_CANONICAL(mMid, std::string()),
+ INIT_CANONICAL(mSyncGroup, std::string()) {}
+
+#undef INIT_CANONICAL
+
+RTCRtpTransceiver::~RTCRtpTransceiver() = default;
+
+SdpDirectionAttribute::Direction ToSdpDirection(
+ RTCRtpTransceiverDirection aDirection) {
+ switch (aDirection) {
+ case dom::RTCRtpTransceiverDirection::Sendrecv:
+ return SdpDirectionAttribute::Direction::kSendrecv;
+ case dom::RTCRtpTransceiverDirection::Sendonly:
+ return SdpDirectionAttribute::Direction::kSendonly;
+ case dom::RTCRtpTransceiverDirection::Recvonly:
+ return SdpDirectionAttribute::Direction::kRecvonly;
+ case dom::RTCRtpTransceiverDirection::Inactive:
+ return SdpDirectionAttribute::Direction::kInactive;
+ case dom::RTCRtpTransceiverDirection::EndGuard_:;
+ }
+ MOZ_CRASH("Invalid transceiver direction!");
+}
+
+static uint32_t sRemoteSourceId = 0;
+
+// TODO(bug 1401592): Once we implement the sendEncodings stuff, there will
+// need to be validation code in here.
+void RTCRtpTransceiver::Init(const RTCRtpTransceiverInit& aInit,
+ ErrorResult& aRv) {
+ TrackingId trackingId(TrackingId::Source::RTCRtpReceiver, sRemoteSourceId++,
+ TrackingId::TrackAcrossProcesses::Yes);
+ if (IsVideo()) {
+ InitVideo(trackingId);
+ } else {
+ InitAudio();
+ }
+
+ if (!IsValid()) {
+ aRv = NS_ERROR_UNEXPECTED;
+ return;
+ }
+
+ mReceiver = new RTCRtpReceiver(mWindow, mPrincipalPrivacy, mPc,
+ mTransportHandler, mCallWrapper->mCallThread,
+ mStsThread, mConduit, this, trackingId);
+
+ mSender = new RTCRtpSender(mWindow, mPc, mTransportHandler,
+ mCallWrapper->mCallThread, mStsThread, mConduit,
+ mSendTrack, aInit.mSendEncodings, this);
+
+ if (mConduit) {
+ InitConduitControl();
+ }
+
+ mSender->SetStreamsImpl(aInit.mStreams);
+ mDirection = aInit.mDirection;
+}
+
+void RTCRtpTransceiver::SetDtlsTransport(dom::RTCDtlsTransport* aDtlsTransport,
+ bool aStable) {
+ mDtlsTransport = aDtlsTransport;
+ if (aStable) {
+ mLastStableDtlsTransport = mDtlsTransport;
+ }
+}
+
+void RTCRtpTransceiver::RollbackToStableDtlsTransport() {
+ mDtlsTransport = mLastStableDtlsTransport;
+}
+
+void RTCRtpTransceiver::InitAudio() {
+ mConduit = AudioSessionConduit::Create(mCallWrapper, mStsThread);
+
+ if (!mConduit) {
+ MOZ_MTLOG(ML_ERROR, mPc->GetHandle()
+ << "[" << mMid.Ref() << "]: " << __FUNCTION__
+ << ": Failed to create AudioSessionConduit");
+ // TODO(bug 1422897): We need a way to record this when it happens in the
+ // wild.
+ }
+}
+
+void RTCRtpTransceiver::InitVideo(const TrackingId& aRecvTrackingId) {
+ VideoSessionConduit::Options options;
+ options.mVideoLatencyTestEnable =
+ Preferences::GetBool("media.video.test_latency", false);
+ options.mMinBitrate = std::max(
+ 0,
+ Preferences::GetInt("media.peerconnection.video.min_bitrate", 0) * 1000);
+ options.mStartBitrate = std::max(
+ 0, Preferences::GetInt("media.peerconnection.video.start_bitrate", 0) *
+ 1000);
+ options.mPrefMaxBitrate = std::max(
+ 0,
+ Preferences::GetInt("media.peerconnection.video.max_bitrate", 0) * 1000);
+ if (options.mMinBitrate != 0 &&
+ options.mMinBitrate < kViEMinCodecBitrate_bps) {
+ options.mMinBitrate = kViEMinCodecBitrate_bps;
+ }
+ if (options.mStartBitrate < options.mMinBitrate) {
+ options.mStartBitrate = options.mMinBitrate;
+ }
+ if (options.mPrefMaxBitrate &&
+ options.mStartBitrate > options.mPrefMaxBitrate) {
+ options.mStartBitrate = options.mPrefMaxBitrate;
+ }
+ // XXX We'd love if this was a live param for testing adaptation/etc
+ // in automation
+ options.mMinBitrateEstimate =
+ std::max(0, Preferences::GetInt(
+ "media.peerconnection.video.min_bitrate_estimate", 0) *
+ 1000);
+ options.mSpatialLayers = std::max(
+ 1, Preferences::GetInt("media.peerconnection.video.svc.spatial", 0));
+ options.mTemporalLayers = std::max(
+ 1, Preferences::GetInt("media.peerconnection.video.svc.temporal", 0));
+ options.mDenoising =
+ Preferences::GetBool("media.peerconnection.video.denoising", false);
+ options.mLockScaling =
+ Preferences::GetBool("media.peerconnection.video.lock_scaling", false);
+
+ mConduit =
+ VideoSessionConduit::Create(mCallWrapper, mStsThread, std::move(options),
+ mPc->GetHandle(), aRecvTrackingId);
+
+ if (!mConduit) {
+ MOZ_MTLOG(ML_ERROR, mPc->GetHandle()
+ << "[" << mMid.Ref() << "]: " << __FUNCTION__
+ << ": Failed to create VideoSessionConduit");
+ // TODO(bug 1422897): We need a way to record this when it happens in the
+ // wild.
+ }
+}
+
+void RTCRtpTransceiver::InitConduitControl() {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(mConduit);
+ ConduitControlState control(this, mSender, mReceiver);
+ mCallWrapper->mCallThread->Dispatch(NS_NewRunnableFunction(
+ __func__, [conduit = mConduit, control = std::move(control)]() mutable {
+ conduit->AsVideoSessionConduit().apply(
+ [&](VideoSessionConduit* aConduit) {
+ aConduit->InitControl(&control);
+ });
+ conduit->AsAudioSessionConduit().apply(
+ [&](AudioSessionConduit* aConduit) {
+ aConduit->InitControl(&control);
+ });
+ }));
+}
+
+void RTCRtpTransceiver::Close() {
+ // Called via PCImpl::Close -> PCImpl::CloseInt -> PCImpl::ShutdownMedia ->
+ // PCMedia::SelfDestruct. Satisfies step 7 of
+ // https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnection-close
+ mShutdown = true;
+ if (mDtlsTransport) {
+ mDtlsTransport->UpdateState(TransportLayer::TS_CLOSED);
+ }
+ StopImpl();
+}
+
+void RTCRtpTransceiver::BreakCycles() {
+ mSender->BreakCycles();
+ mReceiver->BreakCycles();
+ mWindow = nullptr;
+ mSendTrack = nullptr;
+ mSender = nullptr;
+ mReceiver = nullptr;
+ mDtlsTransport = nullptr;
+ mLastStableDtlsTransport = nullptr;
+ mPc = nullptr;
+}
+
+// TODO: Only called from one place in PeerConnectionImpl, synchronously, when
+// the JSEP engine has successfully completed an offer/answer exchange. This is
+// a bit squirrely, since identity validation happens asynchronously in
+// PeerConnection.jsm. This probably needs to happen once all the "in parallel"
+// steps have succeeded, but before we queue the task for JS observable state
+// updates.
+nsresult RTCRtpTransceiver::UpdateTransport() {
+ if (!mHasTransport) {
+ return NS_OK;
+ }
+
+ mReceiver->UpdateTransport();
+ mSender->UpdateTransport();
+ return NS_OK;
+}
+
+nsresult RTCRtpTransceiver::UpdateConduit() {
+ if (mStopped) {
+ return NS_OK;
+ }
+
+ mReceiver->UpdateConduit();
+ mSender->MaybeUpdateConduit();
+
+ return NS_OK;
+}
+
+void RTCRtpTransceiver::UpdatePrincipalPrivacy(PrincipalPrivacy aPrivacy) {
+ if (mPrincipalPrivacy == aPrivacy) {
+ return;
+ }
+
+ mPrincipalPrivacy = aPrivacy;
+ mReceiver->UpdatePrincipalPrivacy(mPrincipalPrivacy);
+}
+
+void RTCRtpTransceiver::ResetSync() { mSyncGroup = std::string(); }
+
+// TODO: Only called from one place in PeerConnectionImpl, synchronously, when
+// the JSEP engine has successfully completed an offer/answer exchange. This is
+// a bit squirrely, since identity validation happens asynchronously in
+// PeerConnection.jsm. This probably needs to happen once all the "in parallel"
+// steps have succeeded, but before we queue the task for JS observable state
+// updates.
+nsresult RTCRtpTransceiver::SyncWithMatchingVideoConduits(
+ nsTArray<RefPtr<RTCRtpTransceiver>>& transceivers) {
+ if (mStopped) {
+ return NS_OK;
+ }
+
+ if (IsVideo()) {
+ MOZ_MTLOG(ML_ERROR, mPc->GetHandle()
+ << "[" << mMid.Ref() << "]: " << __FUNCTION__
+ << " called when transceiver is not "
+ "video! This should never happen.");
+ MOZ_CRASH();
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ std::set<std::string> myReceiveStreamIds;
+ myReceiveStreamIds.insert(mReceiver->GetStreamIds().begin(),
+ mReceiver->GetStreamIds().end());
+
+ for (RefPtr<RTCRtpTransceiver>& transceiver : transceivers) {
+ if (!transceiver->IsValid()) {
+ continue;
+ }
+
+ if (!transceiver->IsVideo()) {
+ // |this| is an audio transceiver, so we skip other audio transceivers
+ continue;
+ }
+
+ // Maybe could make this more efficient by cacheing this set, but probably
+ // not worth it.
+ for (const std::string& streamId :
+ transceiver->Receiver()->GetStreamIds()) {
+ if (myReceiveStreamIds.count(streamId)) {
+ // Ok, we have one video, one non-video - cross the streams!
+ mSyncGroup = streamId;
+ transceiver->mSyncGroup = streamId;
+
+ MOZ_MTLOG(ML_DEBUG, mPc->GetHandle()
+ << "[" << mMid.Ref() << "]: " << __FUNCTION__
+ << " Syncing " << mConduit.get() << " to "
+ << transceiver->mConduit.get());
+
+ // The sync code in call.cc only permits sync between audio stream and
+ // one video stream. They take the first match, so there's no point in
+ // continuing here. If we want to change the default, we should sort
+ // video streams here and only call SetSyncGroup on the chosen stream.
+ break;
+ }
+ }
+ }
+
+ return NS_OK;
+}
+
+bool RTCRtpTransceiver::ConduitHasPluginID(uint64_t aPluginID) {
+ return mConduit && mConduit->HasCodecPluginID(aPluginID);
+}
+
+void RTCRtpTransceiver::SyncFromJsep(const JsepSession& aSession) {
+ MOZ_MTLOG(ML_DEBUG, mPc->GetHandle()
+ << "[" << mMid.Ref() << "]: " << __FUNCTION__
+ << " Syncing from JSEP transceiver");
+ if (mShutdown) {
+ // Shutdown_m has already been called, probably due to pc.close(). Just
+ // nod and smile.
+ return;
+ }
+
+ mJsepTransceiver = *aSession.GetTransceiver(mTransceiverId);
+
+ // Transceivers can stop due to JSEP negotiation, so we need to check that
+ if (mJsepTransceiver.IsStopped()) {
+ StopImpl();
+ }
+
+ mReceiver->SyncFromJsep(mJsepTransceiver);
+ mSender->SyncFromJsep(mJsepTransceiver);
+
+ // mid from JSEP
+ if (mJsepTransceiver.IsAssociated()) {
+ mMid = mJsepTransceiver.GetMid();
+ } else {
+ mMid = std::string();
+ }
+
+ // currentDirection from JSEP, but not if "this transceiver has never been
+ // represented in an offer/answer exchange"
+ if (mJsepTransceiver.HasLevel() && mJsepTransceiver.IsNegotiated()) {
+ if (mJsepTransceiver.mRecvTrack.GetActive()) {
+ if (mJsepTransceiver.mSendTrack.GetActive()) {
+ mCurrentDirection.SetValue(dom::RTCRtpTransceiverDirection::Sendrecv);
+ mHasBeenUsedToSend = true;
+ } else {
+ mCurrentDirection.SetValue(dom::RTCRtpTransceiverDirection::Recvonly);
+ }
+ } else {
+ if (mJsepTransceiver.mSendTrack.GetActive()) {
+ mCurrentDirection.SetValue(dom::RTCRtpTransceiverDirection::Sendonly);
+ mHasBeenUsedToSend = true;
+ } else {
+ mCurrentDirection.SetValue(dom::RTCRtpTransceiverDirection::Inactive);
+ }
+ }
+ }
+
+ mShouldRemove = mJsepTransceiver.IsRemoved();
+ mHasTransport = mJsepTransceiver.HasLevel() && !mJsepTransceiver.IsStopped();
+}
+
+void RTCRtpTransceiver::SyncToJsep(JsepSession& aSession) const {
+ MOZ_MTLOG(ML_DEBUG, mPc->GetHandle()
+ << "[" << mMid.Ref() << "]: " << __FUNCTION__
+ << " Syncing to JSEP transceiver");
+
+ aSession.ApplyToTransceiver(
+ mTransceiverId, [this, self = RefPtr<const RTCRtpTransceiver>(this)](
+ JsepTransceiver& aTransceiver) {
+ mReceiver->SyncToJsep(aTransceiver);
+ mSender->SyncToJsep(aTransceiver);
+ aTransceiver.mJsDirection = ToSdpDirection(mDirection);
+ if (mStopped) {
+ aTransceiver.Stop();
+ }
+ });
+}
+
+void RTCRtpTransceiver::GetKind(nsAString& aKind) const {
+ // The transceiver kind of an RTCRtpTransceiver is defined by the kind of the
+ // associated RTCRtpReceiver's MediaStreamTrack object.
+ MOZ_ASSERT(mReceiver && mReceiver->Track());
+ mReceiver->Track()->GetKind(aKind);
+}
+
+void RTCRtpTransceiver::GetMid(nsAString& aMid) const {
+ if (!mMid.Ref().empty()) {
+ aMid = NS_ConvertUTF8toUTF16(mMid.Ref());
+ } else {
+ aMid.SetIsVoid(true);
+ }
+}
+
+std::string RTCRtpTransceiver::GetMidAscii() const {
+ if (mMid.Ref().empty()) {
+ return std::string();
+ }
+
+ return mMid.Ref();
+}
+
+void RTCRtpTransceiver::SetDirection(RTCRtpTransceiverDirection aDirection,
+ ErrorResult& aRv) {
+ if (mStopped) {
+ aRv.ThrowInvalidStateError("Transceiver is stopped!");
+ return;
+ }
+
+ if (aDirection == mDirection) {
+ return;
+ }
+
+ SetDirectionInternal(aDirection);
+
+ mPc->UpdateNegotiationNeeded();
+}
+
+void RTCRtpTransceiver::SetDirectionInternal(
+ RTCRtpTransceiverDirection aDirection) {
+ // We do not update the direction on the JsepTransceiver until sync
+ mDirection = aDirection;
+}
+
+bool RTCRtpTransceiver::ShouldRemove() const { return mShouldRemove; }
+
+bool RTCRtpTransceiver::CanSendDTMF() const {
+ // Spec says: "If connection's RTCPeerConnectionState is not "connected"
+ // return false." We don't support that right now. This is supposed to be
+ // true once ICE is complete, and _all_ DTLS handshakes are also complete. We
+ // don't really have access to the state of _all_ of our DTLS states either.
+ // Our pipeline _does_ know whether SRTP/SRTCP is ready, which happens
+ // immediately after our transport finishes DTLS (unless there was an error),
+ // so this is pretty close.
+ // TODO (bug 1265827): Base this on RTCPeerConnectionState instead.
+ // TODO (bug 1623193): Tighten this up
+ if (!IsSending() || !mSender->GetTrack()) {
+ return false;
+ }
+
+ // Ok, it looks like the connection is up and sending. Did we negotiate
+ // telephone-event?
+ const JsepTrackNegotiatedDetails* details =
+ mJsepTransceiver.mSendTrack.GetNegotiatedDetails();
+ if (NS_WARN_IF(!details || !details->GetEncodingCount())) {
+ // What?
+ return false;
+ }
+
+ for (size_t i = 0; i < details->GetEncodingCount(); ++i) {
+ const auto& encoding = details->GetEncoding(i);
+ for (const auto& codec : encoding.GetCodecs()) {
+ if (codec->mName == "telephone-event") {
+ return true;
+ }
+ }
+ }
+
+ return false;
+}
+
+JSObject* RTCRtpTransceiver::WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) {
+ return dom::RTCRtpTransceiver_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+nsPIDOMWindowInner* RTCRtpTransceiver::GetParentObject() const {
+ return mWindow;
+}
+
+static void JsepCodecDescToAudioCodecConfig(
+ const JsepAudioCodecDescription& aCodec, Maybe<AudioCodecConfig>* aConfig) {
+ uint16_t pt;
+
+ // TODO(bug 1761272): Getting the pt for a JsepAudioCodecDescription should be
+ // infallible.
+ if (NS_WARN_IF(!aCodec.GetPtAsInt(&pt))) {
+ MOZ_MTLOG(ML_ERROR, "Invalid payload type: " << aCodec.mDefaultPt);
+ MOZ_ASSERT(false);
+ return;
+ }
+
+ // libwebrtc crashes if we attempt to configure a mono recv codec
+ bool sendMono = aCodec.mForceMono && aCodec.mDirection == sdp::kSend;
+
+ *aConfig = Some(AudioCodecConfig(
+ pt, aCodec.mName, static_cast<int>(aCodec.mClock),
+ sendMono ? 1 : static_cast<int>(aCodec.mChannels), aCodec.mFECEnabled));
+ (*aConfig)->mMaxPlaybackRate = static_cast<int>(aCodec.mMaxPlaybackRate);
+ (*aConfig)->mDtmfEnabled = aCodec.mDtmfEnabled;
+ (*aConfig)->mDTXEnabled = aCodec.mDTXEnabled;
+ (*aConfig)->mMaxAverageBitrate = aCodec.mMaxAverageBitrate;
+ (*aConfig)->mFrameSizeMs = aCodec.mFrameSizeMs;
+ (*aConfig)->mMinFrameSizeMs = aCodec.mMinFrameSizeMs;
+ (*aConfig)->mMaxFrameSizeMs = aCodec.mMaxFrameSizeMs;
+ (*aConfig)->mCbrEnabled = aCodec.mCbrEnabled;
+}
+
+// TODO: This and the next function probably should move to JsepTransceiver
+Maybe<const std::vector<UniquePtr<JsepCodecDescription>>&>
+RTCRtpTransceiver::GetNegotiatedSendCodecs() const {
+ if (!mJsepTransceiver.mSendTrack.GetActive()) {
+ return Nothing();
+ }
+
+ const auto* details = mJsepTransceiver.mSendTrack.GetNegotiatedDetails();
+ if (!details) {
+ return Nothing();
+ }
+
+ if (details->GetEncodingCount() == 0) {
+ return Nothing();
+ }
+
+ return SomeRef(details->GetEncoding(0).GetCodecs());
+}
+
+Maybe<const std::vector<UniquePtr<JsepCodecDescription>>&>
+RTCRtpTransceiver::GetNegotiatedRecvCodecs() const {
+ if (!mJsepTransceiver.mRecvTrack.GetActive()) {
+ return Nothing();
+ }
+
+ const auto* details = mJsepTransceiver.mRecvTrack.GetNegotiatedDetails();
+ if (!details) {
+ return Nothing();
+ }
+
+ if (details->GetEncodingCount() == 0) {
+ return Nothing();
+ }
+
+ return SomeRef(details->GetEncoding(0).GetCodecs());
+}
+
+// TODO: Maybe move this someplace else?
+/*static*/
+void RTCRtpTransceiver::NegotiatedDetailsToAudioCodecConfigs(
+ const JsepTrackNegotiatedDetails& aDetails,
+ std::vector<AudioCodecConfig>* aConfigs) {
+ Maybe<AudioCodecConfig> telephoneEvent;
+
+ if (aDetails.GetEncodingCount()) {
+ for (const auto& codec : aDetails.GetEncoding(0).GetCodecs()) {
+ if (NS_WARN_IF(codec->Type() != SdpMediaSection::kAudio)) {
+ MOZ_ASSERT(false, "Codec is not audio! This is a JSEP bug.");
+ return;
+ }
+ Maybe<AudioCodecConfig> config;
+ const JsepAudioCodecDescription& audio =
+ static_cast<const JsepAudioCodecDescription&>(*codec);
+ JsepCodecDescToAudioCodecConfig(audio, &config);
+ if (config->mName == "telephone-event") {
+ telephoneEvent = std::move(config);
+ } else {
+ aConfigs->push_back(std::move(*config));
+ }
+ }
+ }
+
+ // Put telephone event at the back, because webrtc.org crashes if we don't
+ // If we need to do even more sorting, we should use std::sort.
+ if (telephoneEvent) {
+ aConfigs->push_back(std::move(*telephoneEvent));
+ }
+}
+
+auto RTCRtpTransceiver::GetActivePayloadTypes() const
+ -> RefPtr<ActivePayloadTypesPromise> {
+ if (!mConduit) {
+ return ActivePayloadTypesPromise::CreateAndResolve(PayloadTypes(),
+ __func__);
+ }
+
+ if (!mCallWrapper) {
+ return ActivePayloadTypesPromise::CreateAndResolve(PayloadTypes(),
+ __func__);
+ }
+
+ return InvokeAsync(mCallWrapper->mCallThread, __func__,
+ [conduit = mConduit]() {
+ PayloadTypes pts;
+ pts.mSendPayloadType = conduit->ActiveSendPayloadType();
+ pts.mRecvPayloadType = conduit->ActiveRecvPayloadType();
+ return ActivePayloadTypesPromise::CreateAndResolve(
+ std::move(pts), __func__);
+ });
+}
+
+static void JsepCodecDescToVideoCodecConfig(
+ const JsepVideoCodecDescription& aCodec, Maybe<VideoCodecConfig>* aConfig) {
+ uint16_t pt;
+
+ // TODO(bug 1761272): Getting the pt for a JsepVideoCodecDescription should be
+ // infallible.
+ if (NS_WARN_IF(!aCodec.GetPtAsInt(&pt))) {
+ MOZ_MTLOG(ML_ERROR, "Invalid payload type: " << aCodec.mDefaultPt);
+ MOZ_ASSERT(false);
+ return;
+ }
+
+ UniquePtr<VideoCodecConfigH264> h264Config;
+
+ if (aCodec.mName == "H264") {
+ h264Config = MakeUnique<VideoCodecConfigH264>();
+ size_t spropSize = sizeof(h264Config->sprop_parameter_sets);
+ strncpy(h264Config->sprop_parameter_sets,
+ aCodec.mSpropParameterSets.c_str(), spropSize);
+ h264Config->sprop_parameter_sets[spropSize - 1] = '\0';
+ h264Config->packetization_mode =
+ static_cast<int>(aCodec.mPacketizationMode);
+ h264Config->profile_level_id = static_cast<int>(aCodec.mProfileLevelId);
+ h264Config->tias_bw = 0; // TODO(bug 1403206)
+ }
+
+ *aConfig = Some(VideoCodecConfig(pt, aCodec.mName, aCodec.mConstraints,
+ h264Config.get()));
+
+ (*aConfig)->mAckFbTypes = aCodec.mAckFbTypes;
+ (*aConfig)->mNackFbTypes = aCodec.mNackFbTypes;
+ (*aConfig)->mCcmFbTypes = aCodec.mCcmFbTypes;
+ (*aConfig)->mRembFbSet = aCodec.RtcpFbRembIsSet();
+ (*aConfig)->mFECFbSet = aCodec.mFECEnabled;
+ (*aConfig)->mTransportCCFbSet = aCodec.RtcpFbTransportCCIsSet();
+ if (aCodec.mFECEnabled) {
+ uint16_t pt;
+ if (SdpHelper::GetPtAsInt(aCodec.mREDPayloadType, &pt)) {
+ (*aConfig)->mREDPayloadType = pt;
+ }
+ if (SdpHelper::GetPtAsInt(aCodec.mULPFECPayloadType, &pt)) {
+ (*aConfig)->mULPFECPayloadType = pt;
+ }
+ }
+ if (aCodec.mRtxEnabled) {
+ uint16_t pt;
+ if (SdpHelper::GetPtAsInt(aCodec.mRtxPayloadType, &pt)) {
+ (*aConfig)->mRTXPayloadType = pt;
+ }
+ }
+}
+
+// TODO: Maybe move this someplace else?
+/*static*/
+void RTCRtpTransceiver::NegotiatedDetailsToVideoCodecConfigs(
+ const JsepTrackNegotiatedDetails& aDetails,
+ std::vector<VideoCodecConfig>* aConfigs) {
+ if (aDetails.GetEncodingCount()) {
+ for (const auto& codec : aDetails.GetEncoding(0).GetCodecs()) {
+ if (NS_WARN_IF(codec->Type() != SdpMediaSection::kVideo)) {
+ MOZ_ASSERT(false, "Codec is not video! This is a JSEP bug.");
+ return;
+ }
+ Maybe<VideoCodecConfig> config;
+ const JsepVideoCodecDescription& video =
+ static_cast<const JsepVideoCodecDescription&>(*codec);
+
+ JsepCodecDescToVideoCodecConfig(video, &config);
+
+ config->mTias = aDetails.GetTias();
+
+ for (size_t i = 0; i < aDetails.GetEncodingCount(); ++i) {
+ const JsepTrackEncoding& jsepEncoding(aDetails.GetEncoding(i));
+ if (jsepEncoding.HasFormat(video.mDefaultPt)) {
+ VideoCodecConfig::Encoding encoding;
+ encoding.rid = jsepEncoding.mRid;
+ config->mEncodings.push_back(encoding);
+ }
+ }
+
+ aConfigs->push_back(std::move(*config));
+ }
+ }
+}
+
+void RTCRtpTransceiver::Stop(ErrorResult& aRv) {
+ if (mPc->IsClosed()) {
+ aRv.ThrowInvalidStateError("Peer connection is closed");
+ return;
+ }
+
+ StopImpl();
+ mPc->UpdateNegotiationNeeded();
+}
+
+void RTCRtpTransceiver::StopImpl() {
+ if (mStopped) {
+ return;
+ }
+
+ if (mCallWrapper) {
+ auto conduit = std::move(mConduit);
+ (conduit ? conduit->Shutdown()
+ : GenericPromise::CreateAndResolve(true, __func__))
+ ->Then(GetMainThreadSerialEventTarget(), __func__,
+ [sender = mSender, receiver = mReceiver]() mutable {
+ // Shutdown pipelines when conduits are guaranteed shut down,
+ // so that all packets sent from conduits can be delivered.
+ sender->Shutdown();
+ receiver->Shutdown();
+ });
+ mCallWrapper = nullptr;
+ }
+ mStopped = true;
+ mCurrentDirection.SetNull();
+
+ mSender->Stop();
+ mReceiver->Stop();
+
+ auto self = nsMainThreadPtrHandle<RTCRtpTransceiver>(
+ new nsMainThreadPtrHolder<RTCRtpTransceiver>(
+ "RTCRtpTransceiver::StopImpl::self", this, false));
+ mStsThread->Dispatch(NS_NewRunnableFunction(
+ __func__, [self] { self->mTransportHandler = nullptr; }));
+}
+
+bool RTCRtpTransceiver::IsVideo() const { return mIsVideo; }
+
+bool RTCRtpTransceiver::IsSending() const {
+ return mCurrentDirection == Nullable(RTCRtpTransceiverDirection::Sendonly) ||
+ mCurrentDirection == Nullable(RTCRtpTransceiverDirection::Sendrecv);
+}
+
+bool RTCRtpTransceiver::IsReceiving() const {
+ return mCurrentDirection == Nullable(RTCRtpTransceiverDirection::Recvonly) ||
+ mCurrentDirection == Nullable(RTCRtpTransceiverDirection::Sendrecv);
+}
+
+void RTCRtpTransceiver::ChainToDomPromiseWithCodecStats(
+ nsTArray<RefPtr<RTCStatsPromise>> aStats,
+ const RefPtr<dom::Promise>& aDomPromise) {
+ nsTArray<RTCCodecStats> codecStats =
+ mPc->GetCodecStats(mPc->GetTimestampMaker().GetNow().ToDom());
+
+ AutoTArray<
+ std::tuple<RTCRtpTransceiver*, RefPtr<RTCStatsPromise::AllPromiseType>>,
+ 1>
+ statsPromises;
+ statsPromises.AppendElement(std::make_tuple(
+ this, RTCStatsPromise::All(GetMainThreadSerialEventTarget(), aStats)));
+
+ ApplyCodecStats(std::move(codecStats), std::move(statsPromises))
+ ->Then(
+ GetMainThreadSerialEventTarget(), __func__,
+ [aDomPromise, window = mWindow,
+ idGen = mIdGenerator](UniquePtr<RTCStatsCollection> aStats) mutable {
+ // Rewrite ids and merge stats collections into the final report.
+ AutoTArray<UniquePtr<RTCStatsCollection>, 1> stats;
+ stats.AppendElement(std::move(aStats));
+
+ RTCStatsCollection opaqueStats;
+ idGen->RewriteIds(std::move(stats), &opaqueStats);
+
+ RefPtr<RTCStatsReport> report(new RTCStatsReport(window));
+ report->Incorporate(opaqueStats);
+
+ aDomPromise->MaybeResolve(std::move(report));
+ },
+ [aDomPromise](nsresult aError) {
+ aDomPromise->MaybeReject(NS_ERROR_FAILURE);
+ });
+}
+
+RefPtr<RTCStatsPromise> RTCRtpTransceiver::ApplyCodecStats(
+ nsTArray<RTCCodecStats> aCodecStats,
+ nsTArray<
+ std::tuple<RTCRtpTransceiver*, RefPtr<RTCStatsPromise::AllPromiseType>>>
+ aTransceiverStatsPromises) {
+ MOZ_ASSERT(NS_IsMainThread());
+ // The process here is roughly:
+ // - Gather all inputs to the codec filtering process, including:
+ // - Each transceiver's transportIds
+ // - Each transceiver's active payload types (resolved)
+ // - Each transceiver's resolved stats
+ //
+ // Waiting (async) for multiple promises of different types is not supported
+ // by the MozPromise API (bug 1752318), so we are a bit finicky here. We
+ // create media::Refcountables of the types we want to resolve, and let
+ // these be shared across Then-functions through RefPtrs.
+ //
+ // - For each active payload type in a transceiver:
+ // - Register the codec stats for this payload type and transport if we
+ // haven't already done so
+ // - If it was a send payload type, assign the codec stats id for this
+ // payload type and transport to the transceiver's outbound-rtp and
+ // remote-inbound-rtp stats as codecId
+ // - If it was a recv payload type, assign the codec stats id for this
+ // payload type and transport to the transceiver's inbound-rtp and
+ // remote-outbound-rtp stats as codecId
+ //
+ // - Flatten all transceiver stats collections into one, and set the
+ // registered codec stats on it
+
+ // Wrap codec stats in a Refcountable<> to allow sharing across promise
+ // handlers.
+ auto codecStats = MakeRefPtr<media::Refcountable<nsTArray<RTCCodecStats>>>();
+ *codecStats = std::move(aCodecStats);
+
+ struct IdComparator {
+ bool operator()(const RTCCodecStats& aA, const RTCCodecStats& aB) const {
+ return aA.mId.Value() < aB.mId.Value();
+ }
+ };
+
+ // Stores distinct codec stats by id; to avoid dupes within a transport.
+ auto finalCodecStats =
+ MakeRefPtr<media::Refcountable<std::set<RTCCodecStats, IdComparator>>>();
+
+ // All the transceiver rtp stream stats in a single array. These stats will,
+ // when resolved, contain codecIds.
+ nsTArray<RefPtr<RTCStatsPromise>> promises(
+ aTransceiverStatsPromises.Length());
+
+ for (const auto& [transceiver, allPromise] : aTransceiverStatsPromises) {
+ // Per transceiver, gather up what we need to assign codecId to this
+ // transceiver's rtp stream stats. Register codec stats while we're at it.
+ auto payloadTypes =
+ MakeRefPtr<media::Refcountable<RTCRtpTransceiver::PayloadTypes>>();
+ promises.AppendElement(
+ transceiver->GetActivePayloadTypes()
+ ->Then(
+ GetMainThreadSerialEventTarget(), __func__,
+ [payloadTypes, allPromise = allPromise](
+ RTCRtpTransceiver::PayloadTypes aPayloadTypes) {
+ // Forward active payload types to the next Then-handler.
+ *payloadTypes = std::move(aPayloadTypes);
+ return allPromise;
+ },
+ [] {
+ MOZ_CRASH("Unexpected reject");
+ return RTCStatsPromise::AllPromiseType::CreateAndReject(
+ NS_ERROR_UNEXPECTED, __func__);
+ })
+ ->Then(
+ GetMainThreadSerialEventTarget(), __func__,
+ [codecStats, finalCodecStats, payloadTypes,
+ transportId =
+ NS_ConvertASCIItoUTF16(transceiver->GetTransportId())](
+ nsTArray<UniquePtr<RTCStatsCollection>>
+ aTransceiverStats) mutable {
+ // We have all the data we need to register codec stats and
+ // assign codecIds for this transceiver's rtp stream stats.
+
+ auto report = MakeUnique<RTCStatsCollection>();
+ FlattenStats(std::move(aTransceiverStats), report.get());
+
+ // Find the codec stats we are looking for, based on the
+ // transportId and the active payload types.
+ Maybe<RTCCodecStats&> sendCodec;
+ Maybe<RTCCodecStats&> recvCodec;
+ for (auto& codec : *codecStats) {
+ if (payloadTypes->mSendPayloadType.isSome() ==
+ sendCodec.isSome() &&
+ payloadTypes->mRecvPayloadType.isSome() ==
+ recvCodec.isSome()) {
+ // We have found all the codec stats we were looking for.
+ break;
+ }
+ if (codec.mTransportId != transportId) {
+ continue;
+ }
+ if (payloadTypes->mSendPayloadType &&
+ *payloadTypes->mSendPayloadType ==
+ static_cast<int>(codec.mPayloadType) &&
+ (!codec.mCodecType.WasPassed() ||
+ codec.mCodecType.Value() == RTCCodecType::Encode)) {
+ MOZ_ASSERT(!sendCodec,
+ "At most one send codec stat per transceiver");
+ sendCodec = SomeRef(codec);
+ }
+ if (payloadTypes->mRecvPayloadType &&
+ *payloadTypes->mRecvPayloadType ==
+ static_cast<int>(codec.mPayloadType) &&
+ (!codec.mCodecType.WasPassed() ||
+ codec.mCodecType.Value() == RTCCodecType::Decode)) {
+ MOZ_ASSERT(!recvCodec,
+ "At most one recv codec stat per transceiver");
+ recvCodec = SomeRef(codec);
+ }
+ }
+
+ // Register and assign codecIds for the found codec stats.
+ if (sendCodec) {
+ finalCodecStats->insert(*sendCodec);
+ for (auto& stat : report->mOutboundRtpStreamStats) {
+ stat.mCodecId.Construct(sendCodec->mId.Value());
+ }
+ for (auto& stat : report->mRemoteInboundRtpStreamStats) {
+ stat.mCodecId.Construct(sendCodec->mId.Value());
+ }
+ }
+ if (recvCodec) {
+ finalCodecStats->insert(*recvCodec);
+ for (auto& stat : report->mInboundRtpStreamStats) {
+ stat.mCodecId.Construct(recvCodec->mId.Value());
+ }
+ for (auto& stat : report->mRemoteOutboundRtpStreamStats) {
+ stat.mCodecId.Construct(recvCodec->mId.Value());
+ }
+ }
+
+ return RTCStatsPromise::CreateAndResolve(std::move(report),
+ __func__);
+ },
+ [] {
+ MOZ_CRASH("Unexpected reject");
+ return RTCStatsPromise::CreateAndReject(NS_ERROR_UNEXPECTED,
+ __func__);
+ }));
+ }
+
+ return RTCStatsPromise::All(GetMainThreadSerialEventTarget(), promises)
+ ->Then(
+ GetMainThreadSerialEventTarget(), __func__,
+ [finalCodecStats = std::move(finalCodecStats)](
+ nsTArray<UniquePtr<RTCStatsCollection>> aStats) mutable {
+ auto finalStats = MakeUnique<RTCStatsCollection>();
+ FlattenStats(std::move(aStats), finalStats.get());
+ MOZ_ASSERT(finalStats->mCodecStats.IsEmpty());
+ if (!finalStats->mCodecStats.SetCapacity(finalCodecStats->size(),
+ fallible)) {
+ mozalloc_handle_oom(0);
+ }
+ while (!finalCodecStats->empty()) {
+ auto node = finalCodecStats->extract(finalCodecStats->begin());
+ if (!finalStats->mCodecStats.AppendElement(
+ std::move(node.value()), fallible)) {
+ mozalloc_handle_oom(0);
+ }
+ }
+ return RTCStatsPromise::CreateAndResolve(std::move(finalStats),
+ __func__);
+ },
+ [] {
+ MOZ_CRASH("Unexpected reject");
+ return RTCStatsPromise::CreateAndReject(NS_ERROR_UNEXPECTED,
+ __func__);
+ });
+}
+
+} // namespace mozilla