summaryrefslogtreecommitdiffstats
path: root/media/webrtc/signaling/src
diff options
context:
space:
mode:
Diffstat (limited to 'media/webrtc/signaling/src')
-rw-r--r--media/webrtc/signaling/src/common/CommonTypes.h63
-rw-r--r--media/webrtc/signaling/src/common/EncodingConstraints.h58
-rwxr-xr-xmedia/webrtc/signaling/src/common/MediaEngineWrapper.h39
-rw-r--r--media/webrtc/signaling/src/common/NullDeleter.h16
-rw-r--r--media/webrtc/signaling/src/common/NullTransport.h44
-rw-r--r--media/webrtc/signaling/src/common/PtrVector.h43
-rw-r--r--media/webrtc/signaling/src/common/Wrapper.h175
-rw-r--r--media/webrtc/signaling/src/common/YuvStamper.cpp469
-rw-r--r--media/webrtc/signaling/src/common/YuvStamper.h83
-rw-r--r--media/webrtc/signaling/src/common/browser_logging/CSFLog.cpp103
-rw-r--r--media/webrtc/signaling/src/common/browser_logging/CSFLog.h50
-rw-r--r--media/webrtc/signaling/src/common/browser_logging/WebRtcLog.cpp258
-rw-r--r--media/webrtc/signaling/src/common/browser_logging/WebRtcLog.h16
-rw-r--r--media/webrtc/signaling/src/common/csf_common.h79
-rw-r--r--media/webrtc/signaling/src/common/time_profiling/timecard.c125
-rw-r--r--media/webrtc/signaling/src/common/time_profiling/timecard.h81
-rw-r--r--media/webrtc/signaling/src/jsep/JsepCodecDescription.h780
-rw-r--r--media/webrtc/signaling/src/jsep/JsepSession.h243
-rw-r--r--media/webrtc/signaling/src/jsep/JsepSessionImpl.cpp2497
-rw-r--r--media/webrtc/signaling/src/jsep/JsepSessionImpl.h352
-rw-r--r--media/webrtc/signaling/src/jsep/JsepTrack.cpp531
-rw-r--r--media/webrtc/signaling/src/jsep/JsepTrack.h292
-rw-r--r--media/webrtc/signaling/src/jsep/JsepTrackEncoding.h60
-rw-r--r--media/webrtc/signaling/src/jsep/JsepTransport.h116
-rwxr-xr-xmedia/webrtc/signaling/src/media-conduit/AudioConduit.cpp1134
-rwxr-xr-xmedia/webrtc/signaling/src/media-conduit/AudioConduit.h304
-rwxr-xr-xmedia/webrtc/signaling/src/media-conduit/CodecConfig.h166
-rw-r--r--media/webrtc/signaling/src/media-conduit/CodecStatistics.cpp183
-rw-r--r--media/webrtc/signaling/src/media-conduit/CodecStatistics.h111
-rw-r--r--media/webrtc/signaling/src/media-conduit/GmpVideoCodec.cpp18
-rw-r--r--media/webrtc/signaling/src/media-conduit/GmpVideoCodec.h19
-rw-r--r--media/webrtc/signaling/src/media-conduit/MediaCodecVideoCodec.cpp31
-rw-r--r--media/webrtc/signaling/src/media-conduit/MediaCodecVideoCodec.h31
-rwxr-xr-xmedia/webrtc/signaling/src/media-conduit/MediaConduitErrors.h48
-rwxr-xr-xmedia/webrtc/signaling/src/media-conduit/MediaConduitInterface.h495
-rw-r--r--media/webrtc/signaling/src/media-conduit/OMXVideoCodec.cpp30
-rw-r--r--media/webrtc/signaling/src/media-conduit/OMXVideoCodec.h32
-rw-r--r--media/webrtc/signaling/src/media-conduit/RunningStat.h66
-rwxr-xr-xmedia/webrtc/signaling/src/media-conduit/VideoConduit.cpp2129
-rwxr-xr-xmedia/webrtc/signaling/src/media-conduit/VideoConduit.h429
-rwxr-xr-xmedia/webrtc/signaling/src/media-conduit/VideoTypes.h62
-rw-r--r--media/webrtc/signaling/src/media-conduit/WebrtcGmpVideoCodec.cpp965
-rw-r--r--media/webrtc/signaling/src/media-conduit/WebrtcGmpVideoCodec.h528
-rw-r--r--media/webrtc/signaling/src/media-conduit/WebrtcMediaCodecVP8VideoCodec.cpp1004
-rw-r--r--media/webrtc/signaling/src/media-conduit/WebrtcMediaCodecVP8VideoCodec.h114
-rw-r--r--media/webrtc/signaling/src/media-conduit/WebrtcOMXH264VideoCodec.cpp1253
-rw-r--r--media/webrtc/signaling/src/media-conduit/WebrtcOMXH264VideoCodec.h108
-rw-r--r--media/webrtc/signaling/src/media/CSFAudioControlWrapper.cpp149
-rw-r--r--media/webrtc/signaling/src/media/CSFAudioControlWrapper.h42
-rw-r--r--media/webrtc/signaling/src/media/CSFAudioTermination.h117
-rw-r--r--media/webrtc/signaling/src/media/CSFMediaProvider.h54
-rw-r--r--media/webrtc/signaling/src/media/CSFMediaTermination.h55
-rw-r--r--media/webrtc/signaling/src/media/CSFToneDefinitions.h137
-rw-r--r--media/webrtc/signaling/src/media/CSFVideoCallMediaControl.h28
-rw-r--r--media/webrtc/signaling/src/media/CSFVideoControlWrapper.h48
-rw-r--r--media/webrtc/signaling/src/media/CSFVideoTermination.h36
-rw-r--r--media/webrtc/signaling/src/media/cip_mmgr_mediadefinitions.h125
-rw-r--r--media/webrtc/signaling/src/mediapipeline/MediaPipeline.cpp2377
-rw-r--r--media/webrtc/signaling/src/mediapipeline/MediaPipeline.h479
-rw-r--r--media/webrtc/signaling/src/mediapipeline/MediaPipelineFilter.cpp97
-rw-r--r--media/webrtc/signaling/src/mediapipeline/MediaPipelineFilter.h86
-rw-r--r--media/webrtc/signaling/src/mediapipeline/SrtpFlow.cpp251
-rw-r--r--media/webrtc/signaling/src/mediapipeline/SrtpFlow.h68
-rw-r--r--media/webrtc/signaling/src/peerconnection/MediaPipelineFactory.cpp1076
-rw-r--r--media/webrtc/signaling/src/peerconnection/MediaPipelineFactory.h82
-rw-r--r--media/webrtc/signaling/src/peerconnection/MediaStreamList.cpp104
-rw-r--r--media/webrtc/signaling/src/peerconnection/MediaStreamList.h54
-rw-r--r--media/webrtc/signaling/src/peerconnection/PeerConnectionCtx.cpp452
-rw-r--r--media/webrtc/signaling/src/peerconnection/PeerConnectionCtx.h109
-rw-r--r--media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.cpp4176
-rw-r--r--media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.h894
-rw-r--r--media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.cpp1672
-rw-r--r--media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.h586
-rw-r--r--media/webrtc/signaling/src/peerconnection/WebrtcGlobalChild.h40
-rw-r--r--media/webrtc/signaling/src/peerconnection/WebrtcGlobalInformation.cpp1241
-rw-r--r--media/webrtc/signaling/src/peerconnection/WebrtcGlobalInformation.h56
-rw-r--r--media/webrtc/signaling/src/peerconnection/WebrtcGlobalParent.h53
-rw-r--r--media/webrtc/signaling/src/sdp/Sdp.h195
-rw-r--r--media/webrtc/signaling/src/sdp/SdpAttribute.cpp1674
-rw-r--r--media/webrtc/signaling/src/sdp/SdpAttribute.h1788
-rw-r--r--media/webrtc/signaling/src/sdp/SdpAttributeList.h94
-rw-r--r--media/webrtc/signaling/src/sdp/SdpEnum.h70
-rw-r--r--media/webrtc/signaling/src/sdp/SdpErrorHolder.h50
-rw-r--r--media/webrtc/signaling/src/sdp/SdpHelper.cpp811
-rw-r--r--media/webrtc/signaling/src/sdp/SdpHelper.h131
-rw-r--r--media/webrtc/signaling/src/sdp/SdpMediaSection.cpp196
-rw-r--r--media/webrtc/signaling/src/sdp/SdpMediaSection.h361
-rw-r--r--media/webrtc/signaling/src/sdp/SipccSdp.cpp180
-rw-r--r--media/webrtc/signaling/src/sdp/SipccSdp.h88
-rw-r--r--media/webrtc/signaling/src/sdp/SipccSdpAttributeList.cpp1413
-rw-r--r--media/webrtc/signaling/src/sdp/SipccSdpAttributeList.h147
-rw-r--r--media/webrtc/signaling/src/sdp/SipccSdpMediaSection.cpp423
-rw-r--r--media/webrtc/signaling/src/sdp/SipccSdpMediaSection.h102
-rw-r--r--media/webrtc/signaling/src/sdp/SipccSdpParser.cpp83
-rw-r--r--media/webrtc/signaling/src/sdp/SipccSdpParser.h35
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/ccsdp.h207
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/ccsdp_rtcp_fb.h63
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/cpr_darwin_types.h68
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/cpr_linux_types.h82
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/cpr_string.c272
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/cpr_string.h139
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/cpr_strings.h22
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/cpr_types.h126
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/cpr_win_types.h71
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/sdp.h1794
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/sdp_access.c2083
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/sdp_attr.c5120
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/sdp_attr_access.c6372
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/sdp_base64.c403
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/sdp_base64.h42
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/sdp_config.c241
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/sdp_main.c1342
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/sdp_os_defs.h27
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/sdp_private.h364
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/sdp_services_unix.c41
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/sdp_services_win32.c40
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/sdp_token.c1812
-rw-r--r--media/webrtc/signaling/src/sdp/sipcc/sdp_utils.c781
118 files changed, 59930 insertions, 0 deletions
diff --git a/media/webrtc/signaling/src/common/CommonTypes.h b/media/webrtc/signaling/src/common/CommonTypes.h
new file mode 100644
index 000000000..96f1f3423
--- /dev/null
+++ b/media/webrtc/signaling/src/common/CommonTypes.h
@@ -0,0 +1,63 @@
+/* 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/. */
+
+#pragma once
+
+
+#include <string>
+
+namespace csf
+{
+
+namespace ProviderStateEnum
+{
+ enum ProviderState
+ {
+ Ready,
+ Registering,
+ AwaitingIpAddress,
+ FetchingDeviceConfig,
+ Idle,
+ RecoveryPending,
+ Connected
+ };
+ const std::string toString(ProviderState);
+}
+namespace LoginErrorStatusEnum
+{
+ enum LoginErrorStatus {
+ Ok, // No Error
+ Unknown, // Unknown Error
+ NoCallManagerConfigured, // No Primary or Backup Call Manager
+ NoDevicesFound, // No devices
+ NoCsfDevicesFound, // Devices but none of type CSF
+ PhoneConfigGenError, // Could not generate phone config
+ SipProfileGenError, // Could not build SIP profile
+ ConfigNotSet, // Config not set before calling login()
+ CreateConfigProviderFailed, // Could not create ConfigProvider
+ CreateSoftPhoneProviderFailed, // Could not create SoftPhoneProvider
+ MissingUsername, // Username argument missing,
+ ManualLogout, // logout() has been called
+ LoggedInElseWhere, // Another process has the mutex indicating it is logged in
+ AuthenticationFailure, // Authentication failure (probably bad password, but best not to say for sure)
+ CtiCouldNotConnect, // Could not connect to CTI service
+ InvalidServerSearchList
+ };
+ const std::string toString(LoginErrorStatus);
+}
+
+namespace ErrorCodeEnum
+{
+ enum ErrorCode
+ {
+ Ok,
+ Unknown,
+ InvalidState,
+ InvalidArgument
+ };
+ const std::string toString(ErrorCode);
+}
+
+} // namespace csf
+
diff --git a/media/webrtc/signaling/src/common/EncodingConstraints.h b/media/webrtc/signaling/src/common/EncodingConstraints.h
new file mode 100644
index 000000000..efba7c51c
--- /dev/null
+++ b/media/webrtc/signaling/src/common/EncodingConstraints.h
@@ -0,0 +1,58 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef _ENCODING_CONSTRAINTS_H_
+#define _ENCODING_CONSTRAINTS_H_
+
+#include <algorithm>
+
+namespace mozilla
+{
+class EncodingConstraints
+{
+public:
+ EncodingConstraints() :
+ maxWidth(0),
+ maxHeight(0),
+ maxFps(0),
+ maxFs(0),
+ maxBr(0),
+ maxPps(0),
+ maxMbps(0),
+ maxCpb(0),
+ maxDpb(0),
+ scaleDownBy(1.0)
+ {}
+
+ bool operator==(const EncodingConstraints& constraints) const
+ {
+ return
+ maxWidth == constraints.maxWidth &&
+ maxHeight == constraints.maxHeight &&
+ maxFps == constraints.maxFps &&
+ maxFs == constraints.maxFs &&
+ maxBr == constraints.maxBr &&
+ maxPps == constraints.maxPps &&
+ maxMbps == constraints.maxMbps &&
+ maxCpb == constraints.maxCpb &&
+ maxDpb == constraints.maxDpb &&
+ scaleDownBy == constraints.scaleDownBy;
+ }
+
+ uint32_t maxWidth;
+ uint32_t maxHeight;
+ uint32_t maxFps;
+ uint32_t maxFs;
+ uint32_t maxBr;
+ uint32_t maxPps;
+ uint32_t maxMbps; // macroblocks per second
+ uint32_t maxCpb; // coded picture buffer size
+ uint32_t maxDpb; // decoded picture buffer size
+ double scaleDownBy; // To preserve resolution
+};
+} // namespace mozilla
+
+#endif // _ENCODING_CONSTRAINTS_H_
diff --git a/media/webrtc/signaling/src/common/MediaEngineWrapper.h b/media/webrtc/signaling/src/common/MediaEngineWrapper.h
new file mode 100755
index 000000000..f9b1a3415
--- /dev/null
+++ b/media/webrtc/signaling/src/common/MediaEngineWrapper.h
@@ -0,0 +1,39 @@
+/* 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/. */
+
+#ifndef MEDIA_ENGINE_WRAPPER_H_
+#define MEDIA_ENGINE_WRAPPER_H_
+
+#include <mozilla/Scoped.h>
+
+
+
+namespace mozilla
+{
+/**
+ * A Custom scoped template to release a resoure of Type T
+ * with a function of Type F
+ * ScopedCustomReleasePtr<webrtc::VoENetwork> ptr =
+ * webrtc::VoENetwork->GetInterface(voiceEngine);
+ *
+ */
+template<typename T>
+struct ScopedCustomReleaseTraits0
+{
+ typedef T* type;
+ static T* empty() { return nullptr; }
+ static void release(T* ptr)
+ {
+ if(ptr)
+ {
+ (ptr)->Release();
+ }
+ }
+};
+
+SCOPED_TEMPLATE(ScopedCustomReleasePtr, ScopedCustomReleaseTraits0)
+}//namespace
+
+
+#endif
diff --git a/media/webrtc/signaling/src/common/NullDeleter.h b/media/webrtc/signaling/src/common/NullDeleter.h
new file mode 100644
index 000000000..9b4628390
--- /dev/null
+++ b/media/webrtc/signaling/src/common/NullDeleter.h
@@ -0,0 +1,16 @@
+/* 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/. */
+
+#pragma once
+
+/*
+ * Helper class to allow smart pointers to stack objects to be constructed for ease of unit testing.
+ * Recycled here to help expose a shared_ptr interface to objects which are really raw pointers.
+ */
+struct null_deleter
+{
+ void operator()(void const *) const
+ {
+ }
+};
diff --git a/media/webrtc/signaling/src/common/NullTransport.h b/media/webrtc/signaling/src/common/NullTransport.h
new file mode 100644
index 000000000..bce793304
--- /dev/null
+++ b/media/webrtc/signaling/src/common/NullTransport.h
@@ -0,0 +1,44 @@
+/* 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/. */
+
+
+#ifndef NULL_TRANSPORT_H_
+#define NULL_TRANSPORT_H_
+
+#include "mozilla/Attributes.h"
+
+#include "webrtc/common_types.h"
+
+namespace mozilla {
+
+/**
+ * NullTransport is registered as ExternalTransport to throw away data
+ */
+class NullTransport : public webrtc::Transport
+{
+public:
+ virtual int SendPacket(int channel, const void *data, size_t len)
+ {
+ (void) channel; (void) data;
+ return len;
+ }
+
+ virtual int SendRTCPPacket(int channel, const void *data, size_t len)
+ {
+ (void) channel; (void) data;
+ return len;
+ }
+
+ NullTransport() {}
+
+ virtual ~NullTransport() {}
+
+private:
+ NullTransport(const NullTransport& other) = delete;
+ void operator=(const NullTransport& other) = delete;
+};
+
+} // end namespace
+
+#endif
diff --git a/media/webrtc/signaling/src/common/PtrVector.h b/media/webrtc/signaling/src/common/PtrVector.h
new file mode 100644
index 000000000..68c760472
--- /dev/null
+++ b/media/webrtc/signaling/src/common/PtrVector.h
@@ -0,0 +1,43 @@
+/* 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/. */
+
+#ifndef PtrVector_h
+#define PtrVector_h
+
+#include <mozilla/Move.h>
+#include <vector>
+
+namespace mozilla
+{
+
+// Trivial wrapper class around a vector of ptrs.
+// TODO: Remove this once our buildconfig allows us to put unique_ptr in stl
+// containers, and just use std::vector<unique_ptr<T>> instead.
+template <class T> class PtrVector
+{
+public:
+ PtrVector() = default;
+ PtrVector(const PtrVector&) = delete;
+ PtrVector(PtrVector&& aOther)
+ : values(Move(aOther.values))
+ {}
+ PtrVector& operator=(const PtrVector&) = delete;
+ PtrVector& operator=(PtrVector&& aOther)
+ {
+ Swap(values, aOther.values);
+ return *this;
+ }
+
+ ~PtrVector()
+ {
+ for (T* value : values) { delete value; }
+ }
+
+ std::vector<T*> values;
+};
+
+} // namespace mozilla
+
+#endif // PtrVector_h
+
diff --git a/media/webrtc/signaling/src/common/Wrapper.h b/media/webrtc/signaling/src/common/Wrapper.h
new file mode 100644
index 000000000..a88cbd4bf
--- /dev/null
+++ b/media/webrtc/signaling/src/common/Wrapper.h
@@ -0,0 +1,175 @@
+/* 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/. */
+
+#pragma once
+
+/*
+ * Wrapper - Helper class for wrapper objects.
+ *
+ * This helps to construct a shared_ptr object which wraps access to an underlying handle.
+ * (The handle could be a pointer to some low-level type, a conventional C handle, an int ID, a GUID, etc.)
+ *
+ * Usage:
+ * To obtain a FooPtr from a foo_handle_t, call FooPtr Foo::wrap(foo_handle_t);
+ *
+ * To implement Foo using Wrapper, Foo needs to include this macro in its class definition:
+ * CSF_DECLARE_WRAP(Foo, foo_handle_t);
+ * It also needs to include this in the cpp file, to provide the wrap() implementation and define the static Wrapper.
+ * CSF_IMPLEMENT_WRAP(Foo, foo_handle_t);
+ * These are all declared in common/Wrapper.h - Foo.h needs to include this too.
+ * The client needs to declare Foo(foo_handle_t) as private, and provide a suitable implementation, as well as
+ * implementing wrappers for any other functions to be exposed.
+ * The client needs to implement ~Foo() to perform any cleanup as usual.
+ *
+ * wrap() will always return the same FooPtr for a given foo_handle_t, it will not construct additional objects
+ * if a suitable one already exists.
+ * changeHandle() is used in rare cases where the underlying handle is changed, but the wrapper object is intended
+ * to remain. This is the case for the "fake" CC_DPCall generated on CC_DPLine::CreateCall(), where
+ * the correct IDPCall* is provided later.
+ * reset() is a cleanup step to wipe the handle map and allow memory to be reclaimed.
+ *
+ * Future enhancements:
+ * - For now, objects remain in the map forever. Better would be to add a releaseHandle() function which would
+ * allow the map to be emptied as underlying handles expired. While we can't force the client to give up its
+ * shared_ptr<Foo> objects, we can remove our own copy, for instance on a call ended event.
+ */
+
+#include <map>
+#include "prlock.h"
+#include "mozilla/Assertions.h"
+
+/*
+ * Wrapper has its own autolock class because the instances are declared
+ * statically and mozilla::Mutex will not work properly when instantiated
+ * in a static constructor.
+ */
+
+class LockNSPR {
+public:
+ LockNSPR() : lock_(nullptr) {
+ lock_ = PR_NewLock();
+ MOZ_ASSERT(lock_);
+ }
+ ~LockNSPR() {
+ PR_DestroyLock(lock_);
+ }
+
+ void Acquire() {
+ PR_Lock(lock_);
+ }
+
+ void Release() {
+ PR_Unlock(lock_);
+ }
+
+private:
+ PRLock *lock_;
+};
+
+class AutoLockNSPR {
+public:
+ explicit AutoLockNSPR(LockNSPR& lock) : lock_(lock) {
+ lock_.Acquire();
+ }
+ ~AutoLockNSPR() {
+ lock_.Release();
+ }
+
+private:
+ LockNSPR& lock_;
+};
+
+template <class T>
+class Wrapper
+{
+private:
+ typedef std::map<typename T::Handle, typename T::Ptr> HandleMapType;
+ HandleMapType handleMap;
+ LockNSPR handleMapMutex;
+
+public:
+ Wrapper() {}
+
+ typename T::Ptr wrap(typename T::Handle handle)
+ {
+ AutoLockNSPR lock(handleMapMutex);
+ typename HandleMapType::iterator it = handleMap.find(handle);
+ if(it != handleMap.end())
+ {
+ return it->second;
+ }
+ else
+ {
+ typename T::Ptr p(new T(handle));
+ handleMap[handle] = p;
+ return p;
+ }
+ }
+
+ bool changeHandle(typename T::Handle oldHandle, typename T::Handle newHandle)
+ {
+ AutoLockNSPR lock(handleMapMutex);
+ typename HandleMapType::iterator it = handleMap.find(oldHandle);
+ if(it != handleMap.end())
+ {
+ typename T::Ptr p = it->second;
+ handleMap.erase(it);
+ handleMap[newHandle] = p;
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ bool release(typename T::Handle handle)
+ {
+ AutoLockNSPR lock(handleMapMutex);
+ typename HandleMapType::iterator it = handleMap.find(handle);
+ if(it != handleMap.end())
+ {
+ handleMap.erase(it);
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ void reset()
+ {
+ AutoLockNSPR lock(handleMapMutex);
+ handleMap.clear();
+ }
+};
+
+#define CSF_DECLARE_WRAP(classname, handletype) \
+ public: \
+ static classname ## Ptr wrap(handletype handle); \
+ static void reset(); \
+ static void release(handletype handle); \
+ private: \
+ friend class Wrapper<classname>; \
+ typedef classname ## Ptr Ptr; \
+ typedef handletype Handle; \
+ static Wrapper<classname>& getWrapper() { \
+ static Wrapper<classname> wrapper; \
+ return wrapper; \
+ }
+
+#define CSF_IMPLEMENT_WRAP(classname, handletype) \
+ classname ## Ptr classname::wrap(handletype handle) \
+ { \
+ return getWrapper().wrap(handle); \
+ } \
+ void classname::reset() \
+ { \
+ getWrapper().reset(); \
+ } \
+ void classname::release(handletype handle) \
+ { \
+ getWrapper().release(handle); \
+ }
diff --git a/media/webrtc/signaling/src/common/YuvStamper.cpp b/media/webrtc/signaling/src/common/YuvStamper.cpp
new file mode 100644
index 000000000..892b640bf
--- /dev/null
+++ b/media/webrtc/signaling/src/common/YuvStamper.cpp
@@ -0,0 +1,469 @@
+/* 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/. */
+
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#elif defined XP_WIN
+#include <winsock2.h>
+#endif
+#include <string.h>
+
+#include "nspr.h"
+#include "YuvStamper.h"
+#include "mozilla/Sprintf.h"
+
+typedef uint32_t UINT4; //Needed for r_crc32() call
+extern "C" {
+#include "r_crc32.h"
+}
+
+namespace mozilla {
+
+#define ON_5 0x20
+#define ON_4 0x10
+#define ON_3 0x08
+#define ON_2 0x04
+#define ON_1 0x02
+#define ON_0 0x01
+
+/*
+ 0, 0, 1, 1, 0, 0,
+ 0, 1, 0, 0, 1, 0,
+ 1, 0, 0, 0, 0, 1,
+ 1, 0, 0, 0, 0, 1,
+ 1, 0, 0, 0, 0, 1,
+ 0, 1, 0, 0, 1, 0,
+ 0, 0, 1, 1, 0, 0
+*/
+static unsigned char DIGIT_0 [] =
+ { ON_3 | ON_2,
+ ON_4 | ON_1,
+ ON_5 | ON_0,
+ ON_5 | ON_0,
+ ON_5 | ON_0,
+ ON_4 | ON_1,
+ ON_3 | ON_2
+ };
+
+/*
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 0, 1, 0, 0,
+*/
+static unsigned char DIGIT_1 [] =
+ { ON_2,
+ ON_2,
+ ON_2,
+ ON_2,
+ ON_2,
+ ON_2,
+ ON_2
+ };
+
+/*
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1,
+ 0, 0, 0, 0, 0, 1,
+ 0, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 1,
+*/
+static unsigned char DIGIT_2 [] =
+ { ON_5 | ON_4 | ON_3 | ON_2 | ON_1,
+ ON_0,
+ ON_0,
+ ON_4 | ON_3 | ON_2 | ON_1,
+ ON_5,
+ ON_5,
+ ON_4 | ON_3 | ON_2 | ON_1 | ON_0,
+ };
+
+/*
+ 1, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1,
+ 0, 0, 0, 0, 0, 1,
+ 0, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 1,
+ 0, 0, 0, 0, 0, 1,
+ 1, 1, 1, 1, 1, 0,
+*/
+static unsigned char DIGIT_3 [] =
+ { ON_5 | ON_4 | ON_3 | ON_2 | ON_1,
+ ON_0,
+ ON_0,
+ ON_4 | ON_3 | ON_2 | ON_1 | ON_0,
+ ON_0,
+ ON_0,
+ ON_5 | ON_4 | ON_3 | ON_2 | ON_1,
+ };
+
+/*
+ 0, 1, 0, 0, 0, 1,
+ 0, 1, 0, 0, 0, 1,
+ 0, 1, 0, 0, 0, 1,
+ 0, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 1,
+ 0, 0, 0, 0, 0, 1,
+ 0, 0, 0, 0, 0, 1
+*/
+static unsigned char DIGIT_4 [] =
+ { ON_4 | ON_0,
+ ON_4 | ON_0,
+ ON_4 | ON_0,
+ ON_4 | ON_3 | ON_2 | ON_1 | ON_0,
+ ON_0,
+ ON_0,
+ ON_0,
+ };
+
+/*
+ 0, 1, 1, 1, 1, 1,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 0, 1, 1, 1, 1, 0,
+ 0, 0, 0, 0, 0, 1,
+ 0, 0, 0, 0, 0, 1,
+ 1, 1, 1, 1, 1, 0,
+*/
+static unsigned char DIGIT_5 [] =
+ { ON_4 | ON_3 | ON_2 | ON_1 | ON_0,
+ ON_5,
+ ON_5,
+ ON_4 | ON_3 | ON_2 | ON_1,
+ ON_0,
+ ON_0,
+ ON_5 | ON_4 | ON_3 | ON_2 | ON_1,
+ };
+
+/*
+ 0, 1, 1, 1, 1, 1,
+ 1, 0, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0,
+ 1, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0, 1,
+ 1, 0, 0, 0, 0, 1,
+ 0, 1, 1, 1, 1, 0,
+*/
+static unsigned char DIGIT_6 [] =
+ { ON_4 | ON_3 | ON_2 | ON_1 | ON_0,
+ ON_5,
+ ON_5,
+ ON_4 | ON_3 | ON_2 | ON_1,
+ ON_5 | ON_0,
+ ON_5 | ON_0,
+ ON_4 | ON_3 | ON_2 | ON_1,
+ };
+
+/*
+ 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 1,
+ 0, 0, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0, 0,
+ 0, 0, 1, 0, 0, 0,
+ 0, 1, 0, 0, 0, 0,
+ 1, 0, 0, 0, 0, 0
+*/
+static unsigned char DIGIT_7 [] =
+ { ON_5 | ON_4 | ON_3 | ON_2 | ON_1 | ON_0,
+ ON_0,
+ ON_1,
+ ON_2,
+ ON_3,
+ ON_4,
+ ON_5
+ };
+
+/*
+ 0, 1, 1, 1, 1, 1,
+ 1, 0, 0, 0, 0, 1,
+ 1, 0, 0, 0, 0, 1,
+ 0, 1, 1, 1, 1, 0,
+ 1, 0, 0, 0, 0, 1,
+ 1, 0, 0, 0, 0, 1,
+ 0, 1, 1, 1, 1, 0
+*/
+static unsigned char DIGIT_8 [] =
+ { ON_4 | ON_3 | ON_2 | ON_1,
+ ON_5 | ON_0,
+ ON_5 | ON_0,
+ ON_4 | ON_3 | ON_2 | ON_1,
+ ON_5 | ON_0,
+ ON_5 | ON_0,
+ ON_4 | ON_3 | ON_2 | ON_1,
+ };
+
+/*
+ 0, 1, 1, 1, 1, 1,
+ 1, 0, 0, 0, 0, 1,
+ 1, 0, 0, 0, 0, 1,
+ 0, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 1,
+ 0, 0, 0, 0, 0, 1,
+ 0, 1, 1, 1, 1, 0
+*/
+static unsigned char DIGIT_9 [] =
+ { ON_4 | ON_3 | ON_2 | ON_1 | ON_0,
+ ON_5 | ON_0,
+ ON_5 | ON_0,
+ ON_4 | ON_3 | ON_2 | ON_1 | ON_0,
+ ON_0,
+ ON_0,
+ ON_4 | ON_3 | ON_2 | ON_1,
+ };
+
+static unsigned char *DIGITS[] = {
+ DIGIT_0,
+ DIGIT_1,
+ DIGIT_2,
+ DIGIT_3,
+ DIGIT_4,
+ DIGIT_5,
+ DIGIT_6,
+ DIGIT_7,
+ DIGIT_8,
+ DIGIT_9
+};
+
+ YuvStamper::YuvStamper(unsigned char* pYData,
+ uint32_t width,
+ uint32_t height,
+ uint32_t stride,
+ uint32_t x,
+ uint32_t y,
+ unsigned char symbol_width,
+ unsigned char symbol_height):
+ pYData(pYData), mStride(stride),
+ mWidth(width), mHeight(height),
+ mSymbolWidth(symbol_width), mSymbolHeight(symbol_height),
+ mCursor(x, y) {}
+
+ bool YuvStamper::Encode(uint32_t width, uint32_t height, uint32_t stride,
+ unsigned char* pYData, unsigned char* pMsg, size_t msg_len,
+ uint32_t x, uint32_t y)
+ {
+ YuvStamper stamper(pYData, width, height, stride,
+ x, y, sBitSize, sBitSize);
+
+ // Reserve space for a checksum.
+ if (stamper.Capacity() < 8 * (msg_len + sizeof(uint32_t)))
+ {
+ return false;
+ }
+
+ bool ok = false;
+ uint32_t crc;
+ unsigned char* pCrc = reinterpret_cast<unsigned char*>(&crc);
+ r_crc32(reinterpret_cast<char*>(pMsg), (int)msg_len, &crc);
+ crc = htonl(crc);
+
+ while (msg_len-- > 0) {
+ if (!stamper.Write8(*pMsg++)) {
+ return false;
+ }
+ }
+
+ // Add checksum after the message.
+ ok = stamper.Write8(*pCrc++) &&
+ stamper.Write8(*pCrc++) &&
+ stamper.Write8(*pCrc++) &&
+ stamper.Write8(*pCrc++);
+
+ return ok;
+ }
+
+ bool YuvStamper::Decode(uint32_t width, uint32_t height, uint32_t stride,
+ unsigned char* pYData, unsigned char* pMsg, size_t msg_len,
+ uint32_t x, uint32_t y)
+ {
+ YuvStamper stamper(pYData, width, height, stride,
+ x, y, sBitSize, sBitSize);
+
+ unsigned char* ptr = pMsg;
+ size_t len = msg_len;
+ uint32_t crc, msg_crc;
+ unsigned char* pCrc = reinterpret_cast<unsigned char*>(&crc);
+
+ // Account for space reserved for the checksum
+ if (stamper.Capacity() < 8 * (len + sizeof(uint32_t))) {
+ return false;
+ }
+
+ while (len-- > 0) {
+ if(!stamper.Read8(*ptr++)) {
+ return false;
+ }
+ }
+
+ if (!(stamper.Read8(*pCrc++) &&
+ stamper.Read8(*pCrc++) &&
+ stamper.Read8(*pCrc++) &&
+ stamper.Read8(*pCrc++))) {
+ return false;
+ }
+
+ r_crc32(reinterpret_cast<char*>(pMsg), (int)msg_len, &msg_crc);
+ return crc == htonl(msg_crc);
+ }
+
+ inline uint32_t YuvStamper::Capacity()
+ {
+ // Enforce at least a symbol width and height offset from outer edges.
+ if (mCursor.y + mSymbolHeight > mHeight) {
+ return 0;
+ }
+
+ if (mCursor.x + mSymbolWidth > mWidth && !AdvanceCursor()) {
+ return 0;
+ }
+
+ // Normalize frame integral to mSymbolWidth x mSymbolHeight
+ uint32_t width = mWidth / mSymbolWidth;
+ uint32_t height = mHeight / mSymbolHeight;
+ uint32_t x = mCursor.x / mSymbolWidth;
+ uint32_t y = mCursor.y / mSymbolHeight;
+
+ return (width * height - width * y)- x;
+ }
+
+ bool YuvStamper::Write8(unsigned char value)
+ {
+ // Encode MSB to LSB.
+ unsigned char mask = 0x80;
+ while (mask) {
+ if (!WriteBit(!!(value & mask))) {
+ return false;
+ }
+ mask >>= 1;
+ }
+ return true;
+ }
+
+ bool YuvStamper::WriteBit(bool one)
+ {
+ // A bit is mapped to a mSymbolWidth x mSymbolHeight square of luma data points.
+ // Don't use ternary op.: https://bugzilla.mozilla.org/show_bug.cgi?id=1001708
+ unsigned char value;
+ if (one)
+ value = sYOn;
+ else
+ value = sYOff;
+
+ for (uint32_t y = 0; y < mSymbolHeight; y++) {
+ for (uint32_t x = 0; x < mSymbolWidth; x++) {
+ *(pYData + (mCursor.x + x) + ((mCursor.y + y) * mStride)) = value;
+ }
+ }
+
+ return AdvanceCursor();
+ }
+
+ bool YuvStamper::AdvanceCursor()
+ {
+ mCursor.x += mSymbolWidth;
+ if (mCursor.x + mSymbolWidth > mWidth) {
+ // move to the start of the next row if possible.
+ mCursor.y += mSymbolHeight;
+ if (mCursor.y + mSymbolHeight > mHeight) {
+ // end of frame, do not advance
+ mCursor.y -= mSymbolHeight;
+ mCursor.x -= mSymbolWidth;
+ return false;
+ } else {
+ mCursor.x = 0;
+ }
+ }
+
+ return true;
+ }
+
+ bool YuvStamper::Read8(unsigned char &value)
+ {
+ unsigned char octet = 0;
+ unsigned char bit = 0;
+
+ for (int i = 8; i > 0; --i) {
+ if (!ReadBit(bit)) {
+ return false;
+ }
+ octet <<= 1;
+ octet |= bit;
+ }
+
+ value = octet;
+ return true;
+ }
+
+ bool YuvStamper::ReadBit(unsigned char &bit)
+ {
+ uint32_t sum = 0;
+ for (uint32_t y = 0; y < mSymbolHeight; y++) {
+ for (uint32_t x = 0; x < mSymbolWidth; x++) {
+ sum += *(pYData + mStride * (mCursor.y + y) + mCursor.x + x);
+ }
+ }
+
+ // apply threshold to collected bit square
+ bit = (sum > (sBitThreshold * mSymbolWidth * mSymbolHeight)) ? 1 : 0;
+ return AdvanceCursor();
+ }
+
+ bool YuvStamper::WriteDigits(uint32_t value)
+ {
+ char buf[20];
+ SprintfLiteral(buf, "%.5u", value);
+ size_t size = strlen(buf);
+
+ if (Capacity() < size) {
+ return false;
+ }
+
+ for (size_t i=0; i < size; ++i) {
+ if (!WriteDigit(buf[i] - '0'))
+ return false;
+ if (!AdvanceCursor()) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ bool YuvStamper::WriteDigit(unsigned char digit) {
+ if (digit > sizeof(DIGITS)/sizeof(DIGITS[0]))
+ return false;
+
+ unsigned char *dig = DIGITS[digit];
+ for (uint32_t row = 0; row < sDigitHeight; ++row) {
+ unsigned char mask = 0x01 << (sDigitWidth - 1);
+ for (uint32_t col = 0; col < sDigitWidth; ++col, mask >>= 1) {
+ if (dig[row] & mask) {
+ for (uint32_t xx=0; xx < sPixelSize; ++xx) {
+ for (uint32_t yy=0; yy < sPixelSize; ++yy) {
+ WritePixel(pYData,
+ mCursor.x + (col * sPixelSize) + xx,
+ mCursor.y + (row * sPixelSize) + yy);
+ }
+ }
+ }
+ }
+ }
+
+ return true;
+ }
+
+ void YuvStamper::WritePixel(unsigned char *data, uint32_t x, uint32_t y) {
+ unsigned char *ptr = &data[y * mStride + x];
+ // Don't use ternary op.: https://bugzilla.mozilla.org/show_bug.cgi?id=1001708
+ if (*ptr > sLumaThreshold)
+ *ptr = sLumaMin;
+ else
+ *ptr = sLumaMax;
+ }
+
+} // namespace mozilla.
diff --git a/media/webrtc/signaling/src/common/YuvStamper.h b/media/webrtc/signaling/src/common/YuvStamper.h
new file mode 100644
index 000000000..fb2d6e466
--- /dev/null
+++ b/media/webrtc/signaling/src/common/YuvStamper.h
@@ -0,0 +1,83 @@
+/* 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/. */
+
+#ifndef YUV_STAMPER_H_
+#define YUV_STAMPER_H_
+
+#include "nptypes.h"
+
+namespace mozilla {
+
+class
+YuvStamper {
+public:
+ bool WriteDigits(uint32_t value);
+
+ template<typename T>
+ static bool Write(uint32_t width, uint32_t height, uint32_t stride,
+ unsigned char *pYData, const T& value,
+ uint32_t x=0, uint32_t y=0)
+ {
+ YuvStamper stamper(pYData, width, height, stride,
+ x, y,
+ (sDigitWidth + sInterDigit) * sPixelSize,
+ (sDigitHeight + sInterLine) * sPixelSize);
+ return stamper.WriteDigits(value);
+ }
+
+ static bool Encode(uint32_t width, uint32_t height, uint32_t stride,
+ unsigned char* pYData, unsigned char* pMsg, size_t msg_len,
+ uint32_t x = 0, uint32_t y = 0);
+
+ static bool Decode(uint32_t width, uint32_t height, uint32_t stride,
+ unsigned char* pYData, unsigned char* pMsg, size_t msg_len,
+ uint32_t x = 0, uint32_t y = 0);
+
+ private:
+ YuvStamper(unsigned char* pYData,
+ uint32_t width, uint32_t height, uint32_t stride,
+ uint32_t x, uint32_t y,
+ unsigned char symbol_width, unsigned char symbol_height);
+
+ bool WriteDigit(unsigned char digit);
+ void WritePixel(unsigned char* data, uint32_t x, uint32_t y);
+ uint32_t Capacity();
+ bool AdvanceCursor();
+ bool WriteBit(bool one);
+ bool Write8(unsigned char value);
+ bool ReadBit(unsigned char &value);
+ bool Read8(unsigned char &bit);
+
+ const static unsigned char sPixelSize = 3;
+ const static unsigned char sDigitWidth = 6;
+ const static unsigned char sDigitHeight = 7;
+ const static unsigned char sInterDigit = 1;
+ const static unsigned char sInterLine = 1;
+ const static uint32_t sBitSize = 4;
+ const static uint32_t sBitThreshold = 60;
+ const static unsigned char sYOn = 0x80;
+ const static unsigned char sYOff = 0;
+ const static unsigned char sLumaThreshold = 96;
+ const static unsigned char sLumaMin = 16;
+ const static unsigned char sLumaMax = 235;
+
+ unsigned char* pYData;
+ uint32_t mStride;
+ uint32_t mWidth;
+ uint32_t mHeight;
+ unsigned char mSymbolWidth;
+ unsigned char mSymbolHeight;
+
+ struct Cursor {
+ Cursor(uint32_t x, uint32_t y):
+ x(x), y(y) {}
+ uint32_t x;
+ uint32_t y;
+ } mCursor;
+};
+
+}
+
+#endif
+
diff --git a/media/webrtc/signaling/src/common/browser_logging/CSFLog.cpp b/media/webrtc/signaling/src/common/browser_logging/CSFLog.cpp
new file mode 100644
index 000000000..3d7e2d6dc
--- /dev/null
+++ b/media/webrtc/signaling/src/common/browser_logging/CSFLog.cpp
@@ -0,0 +1,103 @@
+/* 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 <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include "CSFLog.h"
+#include "base/basictypes.h"
+
+#include <map>
+#include "prrwlock.h"
+#include "prthread.h"
+#include "nsThreadUtils.h"
+
+#include "mozilla/Logging.h"
+#include "mozilla/Sprintf.h"
+
+static PRLogModuleInfo *gLogModuleInfo = nullptr;
+
+PRLogModuleInfo *GetSignalingLogInfo()
+{
+ if (gLogModuleInfo == nullptr)
+ gLogModuleInfo = PR_NewLogModule("signaling");
+
+ return gLogModuleInfo;
+}
+
+static PRLogModuleInfo *gWebRTCLogModuleInfo = nullptr;
+
+PRLogModuleInfo *GetWebRTCLogInfo()
+{
+ if (gWebRTCLogModuleInfo == nullptr)
+ gWebRTCLogModuleInfo = PR_NewLogModule("webrtc_trace");
+
+ return gWebRTCLogModuleInfo;
+}
+
+
+void CSFLogV(CSFLogLevel priority, const char* sourceFile, int sourceLine, const char* tag , const char* format, va_list args)
+{
+#ifdef STDOUT_LOGGING
+ printf("%s\n:",tag);
+ vprintf(format, args);
+#else
+
+ mozilla::LogLevel level = static_cast<mozilla::LogLevel>(priority);
+
+ GetSignalingLogInfo();
+
+ // Skip doing any of this work if we're not logging the indicated level...
+ if (!MOZ_LOG_TEST(gLogModuleInfo,level)) {
+ return;
+ }
+
+ // Trim the path component from the filename
+ const char *lastSlash = sourceFile;
+ while (*sourceFile) {
+ if (*sourceFile == '/' || *sourceFile == '\\') {
+ lastSlash = sourceFile;
+ }
+ sourceFile++;
+ }
+ sourceFile = lastSlash;
+ if (*sourceFile == '/' || *sourceFile == '\\') {
+ sourceFile++;
+ }
+
+#define MAX_MESSAGE_LENGTH 1024
+ char message[MAX_MESSAGE_LENGTH];
+
+ const char *threadName = NULL;
+
+ // Check if we're the main thread...
+ if (NS_IsMainThread()) {
+ threadName = "main";
+ } else {
+ threadName = PR_GetThreadName(PR_GetCurrentThread());
+ }
+
+ // If we can't find it anywhere, use a blank string
+ if (!threadName) {
+ threadName = "";
+ }
+
+ VsprintfLiteral(message, format, args);
+ MOZ_LOG(gLogModuleInfo, level, ("[%s|%s] %s:%d: %s",
+ threadName, tag, sourceFile, sourceLine,
+ message));
+#endif
+
+}
+
+void CSFLog( CSFLogLevel priority, const char* sourceFile, int sourceLine, const char* tag , const char* format, ...)
+{
+ va_list ap;
+ va_start(ap, format);
+
+ CSFLogV(priority, sourceFile, sourceLine, tag, format, ap);
+ va_end(ap);
+}
+
diff --git a/media/webrtc/signaling/src/common/browser_logging/CSFLog.h b/media/webrtc/signaling/src/common/browser_logging/CSFLog.h
new file mode 100644
index 000000000..a20157992
--- /dev/null
+++ b/media/webrtc/signaling/src/common/browser_logging/CSFLog.h
@@ -0,0 +1,50 @@
+/* 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/. */
+
+#ifndef CSFLOG_H
+#define CSFLOG_H
+
+#include <stdarg.h>
+
+struct PRLogModuleInfo;
+
+typedef enum{
+ CSF_LOG_ERROR = 1,
+ CSF_LOG_WARNING,
+ CSF_LOG_INFO,
+ CSF_LOG_DEBUG,
+ CSF_LOG_VERBOSE,
+} CSFLogLevel;
+
+#define CSFLogError(tag , format, ...) CSFLog( CSF_LOG_ERROR, __FILE__ , __LINE__ , tag , format , ## __VA_ARGS__ )
+#define CSFLogErrorV(tag , format, va_list_arg) CSFLogV(CSF_LOG_ERROR, __FILE__ , __LINE__ , tag , format , va_list_arg )
+#define CSFLogWarn(tag , format, ...) CSFLog( CSF_LOG_WARNING, __FILE__ , __LINE__ , tag , format , ## __VA_ARGS__ )
+#define CSFLogWarnV(tag , format, va_list_arg) CSFLogV(CSF_LOG_WARNING, __FILE__ , __LINE__ , tag , format , va_list_arg )
+#define CSFLogInfo(tag , format, ...) CSFLog( CSF_LOG_INFO, __FILE__ , __LINE__ , tag , format , ## __VA_ARGS__ )
+#define CSFLogInfoV(tag , format, va_list_arg) CSFLogV(CSF_LOG_INFO, __FILE__ , __LINE__ , tag , format , va_list_arg )
+#define CSFLogDebug(tag , format, ...) CSFLog(CSF_LOG_DEBUG, __FILE__ , __LINE__ , tag , format , ## __VA_ARGS__ )
+#define CSFLogDebugV(tag , format, va_list_arg) CSFLogV(CSF_LOG_DEBUG, __FILE__ , __LINE__ , tag , format , va_list_arg )
+#define CSFLogVerbose(tag , format, ...) CSFLog(CSF_LOG_VERBOSE, __FILE__ , __LINE__ , tag , format , ## __VA_ARGS__ )
+#define CSFLogVerboseV(tag , format, va_list_arg) CSFLogV(CSF_LOG_VERBOSE, __FILE__ , __LINE__ , tag , format , va_list_arg )
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+void CSFLog( CSFLogLevel priority, const char* sourceFile, int sourceLine, const char* tag , const char* format, ...)
+#ifdef __GNUC__
+ __attribute__ ((format (printf, 5, 6)))
+#endif
+;
+
+void CSFLogV( CSFLogLevel priority, const char* sourceFile, int sourceLine, const char* tag , const char* format, va_list args);
+
+struct PRLogModuleInfo *GetSignalingLogInfo();
+struct PRLogModuleInfo *GetWebRTCLogInfo();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/media/webrtc/signaling/src/common/browser_logging/WebRtcLog.cpp b/media/webrtc/signaling/src/common/browser_logging/WebRtcLog.cpp
new file mode 100644
index 000000000..875e0ed2c
--- /dev/null
+++ b/media/webrtc/signaling/src/common/browser_logging/WebRtcLog.cpp
@@ -0,0 +1,258 @@
+/* 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 "WebRtcLog.h"
+
+#include "mozilla/Logging.h"
+#include "prenv.h"
+#include "webrtc/system_wrappers/interface/trace.h"
+
+#include "nscore.h"
+#ifdef MOZILLA_INTERNAL_API
+#include "nsString.h"
+#include "nsXULAppAPI.h"
+#include "mozilla/Preferences.h"
+#else
+#include "nsStringAPI.h"
+#endif
+
+#include "nsIFile.h"
+#include "nsDirectoryServiceUtils.h"
+#include "nsDirectoryServiceDefs.h"
+
+using mozilla::LogLevel;
+
+static int gWebRtcTraceLoggingOn = 0;
+
+
+#if defined(ANDROID)
+static const char *default_tmp_dir = "/dev/null";
+static const char *default_log_name = "nspr";
+#else // Assume a POSIX environment
+NS_NAMED_LITERAL_CSTRING(default_log_name, "WebRTC.log");
+#endif
+
+static PRLogModuleInfo* GetWebRtcTraceLog()
+{
+ static PRLogModuleInfo *sLog;
+ if (!sLog) {
+ sLog = PR_NewLogModule("webrtc_trace");
+ }
+ return sLog;
+}
+
+static PRLogModuleInfo* GetWebRtcAECLog()
+{
+ static PRLogModuleInfo *sLog;
+ if (!sLog) {
+ sLog = PR_NewLogModule("AEC");
+ }
+ return sLog;
+}
+
+class WebRtcTraceCallback: public webrtc::TraceCallback
+{
+public:
+ void Print(webrtc::TraceLevel level, const char* message, int length)
+ {
+ PRLogModuleInfo *log = GetWebRtcTraceLog();
+ MOZ_LOG(log, LogLevel::Debug, ("%s", message));
+ }
+};
+
+static WebRtcTraceCallback gWebRtcCallback;
+
+#ifdef MOZILLA_INTERNAL_API
+void GetWebRtcLogPrefs(uint32_t *aTraceMask, nsACString* aLogFile, nsACString *aAECLogDir, bool *aMultiLog)
+{
+ *aMultiLog = mozilla::Preferences::GetBool("media.webrtc.debug.multi_log");
+ *aTraceMask = mozilla::Preferences::GetUint("media.webrtc.debug.trace_mask");
+ mozilla::Preferences::GetCString("media.webrtc.debug.log_file", aLogFile);
+ mozilla::Preferences::GetCString("media.webrtc.debug.aec_log_dir", aAECLogDir);
+ webrtc::Trace::set_aec_debug_size(mozilla::Preferences::GetUint("media.webrtc.debug.aec_dump_max_size"));
+}
+#endif
+
+void CheckOverrides(uint32_t *aTraceMask, nsACString *aLogFile, bool *aMultiLog)
+{
+ if (!aTraceMask || !aLogFile || !aMultiLog) {
+ return;
+ }
+
+ // Override or fill in attributes from the environment if possible.
+
+ PRLogModuleInfo *log_info = GetWebRtcTraceLog();
+ /* When webrtc_trace:x is not part of the NSPR_LOG_MODULES var the structure returned from
+ the GetWebRTCLogInfo call will be non-null and show a level of 0. This cannot
+ be reliably used to turn off the trace and override a log level from about:config as
+ there is no way to differentiate between NSPR_LOG_MODULES=webrtc_trace:0 and the complete
+ absense of the webrtc_trace in the environment string at all.
+ */
+ if (log_info && (log_info->level != 0)) {
+ *aTraceMask = log_info->level;
+ }
+
+ log_info = GetWebRtcAECLog();
+ if (log_info && (log_info->level != 0)) {
+ webrtc::Trace::set_aec_debug(true);
+ }
+
+ const char *file_name = PR_GetEnv("WEBRTC_TRACE_FILE");
+ if (file_name) {
+ aLogFile->Assign(file_name);
+ }
+}
+
+void ConfigWebRtcLog(uint32_t trace_mask, nsCString &aLogFile, nsCString &aAECLogDir, bool multi_log)
+{
+ if (gWebRtcTraceLoggingOn) {
+ return;
+ }
+
+#if defined(ANDROID)
+ // Special case: use callback to pipe to NSPR logging.
+ aLogFile.Assign(default_log_name);
+#else
+
+ webrtc::Trace::set_level_filter(trace_mask);
+
+ if (trace_mask != 0) {
+ if (aLogFile.EqualsLiteral("nspr")) {
+ webrtc::Trace::SetTraceCallback(&gWebRtcCallback);
+ } else {
+ webrtc::Trace::SetTraceFile(aLogFile.get(), multi_log);
+ }
+ }
+
+ if (aLogFile.IsEmpty()) {
+ nsCOMPtr<nsIFile> tempDir;
+ nsresult rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(tempDir));
+ if (NS_SUCCEEDED(rv)) {
+ tempDir->AppendNative(default_log_name);
+ tempDir->GetNativePath(aLogFile);
+ }
+ }
+#endif
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ if (XRE_IsParentProcess()) {
+ // Capture the final choice for the trace setting.
+ mozilla::Preferences::SetCString("media.webrtc.debug.log_file", aLogFile);
+ }
+#endif
+ return;
+}
+
+void StartWebRtcLog(uint32_t log_level)
+{
+ if (gWebRtcTraceLoggingOn && log_level != 0) {
+ return;
+ }
+
+ if (log_level == 0) {
+ if (gWebRtcTraceLoggingOn) {
+ gWebRtcTraceLoggingOn = false;
+ webrtc::Trace::set_level_filter(webrtc::kTraceNone);
+ }
+ return;
+ }
+
+ uint32_t trace_mask = 0;
+ bool multi_log = false;
+ nsAutoCString log_file;
+ nsAutoCString aec_log_dir;
+
+#ifdef MOZILLA_INTERNAL_API
+ GetWebRtcLogPrefs(&trace_mask, &log_file, &aec_log_dir, &multi_log);
+#endif
+ CheckOverrides(&trace_mask, &log_file, &multi_log);
+
+ if (trace_mask == 0) {
+ trace_mask = log_level;
+ }
+
+ ConfigWebRtcLog(trace_mask, log_file, aec_log_dir, multi_log);
+ return;
+
+}
+
+void EnableWebRtcLog()
+{
+ if (gWebRtcTraceLoggingOn) {
+ return;
+ }
+
+ uint32_t trace_mask = 0;
+ bool multi_log = false;
+ nsAutoCString log_file;
+ nsAutoCString aec_log_dir;
+
+#ifdef MOZILLA_INTERNAL_API
+ GetWebRtcLogPrefs(&trace_mask, &log_file, &aec_log_dir, &multi_log);
+#endif
+ CheckOverrides(&trace_mask, &log_file, &multi_log);
+ ConfigWebRtcLog(trace_mask, log_file, aec_log_dir, multi_log);
+ return;
+}
+
+void StopWebRtcLog()
+{
+ // TODO(NG) strip/fix gWebRtcTraceLoggingOn which is never set to true
+ webrtc::Trace::set_level_filter(webrtc::kTraceNone);
+ webrtc::Trace::SetTraceCallback(nullptr);
+ webrtc::Trace::SetTraceFile(nullptr);
+}
+
+void ConfigAecLog(nsCString &aAECLogDir) {
+ if (webrtc::Trace::aec_debug()) {
+ return;
+ }
+#if defined(ANDROID)
+ // For AEC, do not use a default value: force the user to specify a directory.
+ if (aAECLogDir.IsEmpty()) {
+ aAECLogDir.Assign(default_tmp_dir);
+ }
+#else
+ if (aAECLogDir.IsEmpty()) {
+ nsCOMPtr<nsIFile> tempDir;
+ nsresult rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(tempDir));
+ if (NS_SUCCEEDED(rv)) {
+ if (aAECLogDir.IsEmpty()) {
+ tempDir->GetNativePath(aAECLogDir);
+ }
+ }
+ }
+#endif
+ webrtc::Trace::set_aec_debug_filename(aAECLogDir.get());
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ if (XRE_IsParentProcess()) {
+ // Capture the final choice for the aec_log_dir setting.
+ mozilla::Preferences::SetCString("media.webrtc.debug.aec_log_dir", aAECLogDir);
+ }
+#endif
+}
+
+void StartAecLog()
+{
+ if (webrtc::Trace::aec_debug()) {
+ return;
+ }
+ uint32_t trace_mask = 0;
+ bool multi_log = false;
+ nsAutoCString log_file;
+ nsAutoCString aec_log_dir;
+
+#ifdef MOZILLA_INTERNAL_API
+ GetWebRtcLogPrefs(&trace_mask, &log_file, &aec_log_dir, &multi_log);
+#endif
+ CheckOverrides(&trace_mask, &log_file, &multi_log);
+ ConfigAecLog(aec_log_dir);
+
+ webrtc::Trace::set_aec_debug(true);
+}
+
+void StopAecLog()
+{
+ webrtc::Trace::set_aec_debug(false);
+}
diff --git a/media/webrtc/signaling/src/common/browser_logging/WebRtcLog.h b/media/webrtc/signaling/src/common/browser_logging/WebRtcLog.h
new file mode 100644
index 000000000..58a824bee
--- /dev/null
+++ b/media/webrtc/signaling/src/common/browser_logging/WebRtcLog.h
@@ -0,0 +1,16 @@
+/* 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/. */
+
+#ifndef WEBRTCLOG_H_
+#define WEBRTCLOG_H_
+
+#include "webrtc/common_types.h"
+
+void StartAecLog();
+void StopAecLog();
+void StartWebRtcLog(uint32_t log_level = webrtc::kTraceDefault);
+void EnableWebRtcLog();
+void StopWebRtcLog();
+
+#endif
diff --git a/media/webrtc/signaling/src/common/csf_common.h b/media/webrtc/signaling/src/common/csf_common.h
new file mode 100644
index 000000000..f46abf69e
--- /dev/null
+++ b/media/webrtc/signaling/src/common/csf_common.h
@@ -0,0 +1,79 @@
+/* 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/. */
+
+#ifndef _CSF_COMMON_E58E5677_950A_424c_B6C2_CA180092E6A2_H
+#define _CSF_COMMON_E58E5677_950A_424c_B6C2_CA180092E6A2_H
+
+#include <assert.h>
+#include <memory>
+#include <vector>
+#include <stdlib.h>
+
+/*
+
+This header file defines:
+
+csf_countof
+csf_sprintf
+csf_vsprintf
+
+*/
+
+/*
+ General security tip: Ensure that "format" is never a user-defined string. Format should ALWAYS be something that's built into your code, not
+ user supplied. For example: never write:
+
+ csf_sprintf(buffer, csf_countof(buffer), pUserSuppliedString);
+
+ Instead write:
+
+ csf_sprintf(buffer, csf_countof(buffer), "%s", pUserSuppliedString);
+
+*/
+
+#ifdef WIN32
+ #if !defined(_countof)
+ #if !defined(__cplusplus)
+ #define _countof(_Array) (sizeof(_Array) / sizeof(_Array[0]))
+ #else
+ extern "C++"
+ {
+ template <typename _CountofType, size_t _SizeOfArray>
+ char (*_csf_countof_helper(_CountofType (&_Array)[_SizeOfArray]))[_SizeOfArray];
+ #define _countof(_Array) sizeof(*_csf_countof_helper(_Array))
+ }
+ #endif
+ #endif
+#else
+ #define _countof(_Array) (sizeof(_Array) / sizeof(_Array[0]))
+#endif
+//csf_countof
+
+#define csf_countof(anArray) _countof(anArray)
+
+//csf_sprintf
+
+#ifdef _WIN32
+ //Unlike snprintf, sprintf_s guarantees that the buffer will be null-terminated (unless the buffer size is zero).
+ #define csf_sprintf(/* char* */ buffer, /* size_t */ sizeOfBufferInCharsInclNullTerm, /* const char * */ format, ...)\
+ _snprintf_s (buffer, sizeOfBufferInCharsInclNullTerm, _TRUNCATE, format, __VA_ARGS__)
+#else
+ #define csf_sprintf(/* char */ buffer, /* size_t */ sizeOfBufferInCharsInclNullTerm, /* const char * */ format, ...)\
+ snprintf (buffer, sizeOfBufferInCharsInclNullTerm, format, __VA_ARGS__);\
+ buffer[sizeOfBufferInCharsInclNullTerm-1] = '\0'
+#endif
+
+//csf_vsprintf
+
+#ifdef _WIN32
+ #define csf_vsprintf(/* char* */ buffer, /* size_t */ sizeOfBufferInCharsInclNullTerm, /* const char * */ format, /* va_list */ vaList)\
+ vsnprintf_s (buffer, sizeOfBufferInCharsInclNullTerm, _TRUNCATE, format, vaList);\
+ buffer[sizeOfBufferInCharsInclNullTerm-1] = '\0'
+#else
+ #define csf_vsprintf(/* char */ buffer, /* size_t */ sizeOfBufferInCharsInclNullTerm, /* const char * */ format, /* va_list */ vaList)\
+ vsprintf (buffer, format, vaList);\
+ buffer[sizeOfBufferInCharsInclNullTerm-1] = '\0'
+#endif
+
+#endif
diff --git a/media/webrtc/signaling/src/common/time_profiling/timecard.c b/media/webrtc/signaling/src/common/time_profiling/timecard.c
new file mode 100644
index 000000000..e56377534
--- /dev/null
+++ b/media/webrtc/signaling/src/common/time_profiling/timecard.c
@@ -0,0 +1,125 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 <stdio.h>
+#include "timecard.h"
+#include "mozilla/mozalloc.h"
+
+Timecard *
+create_timecard()
+{
+ Timecard *tc = moz_xcalloc(1,sizeof(Timecard));
+ tc->entries_allocated = TIMECARD_INITIAL_TABLE_SIZE;
+ tc->entries = moz_xcalloc(tc->entries_allocated, sizeof(TimecardEntry));
+ tc->start_time = PR_Now();
+ return tc;
+}
+
+void
+destroy_timecard(Timecard *tc)
+{
+ free(tc->entries);
+ free(tc);
+}
+
+void
+stamp_timecard(Timecard *tc,
+ const char *event,
+ const char *file,
+ unsigned int line,
+ const char *function)
+{
+ TimecardEntry *entry = NULL;
+
+ /* Trim the path component from the filename */
+ const char *last_slash = file;
+ while (*file) {
+ if (*file == '/' || *file == '\\') {
+ last_slash = file;
+ }
+ file++;
+ }
+ file = last_slash;
+ if (*file == '/' || *file == '\\') {
+ file++;
+ }
+
+ /* Ensure there is enough space left in the entries list */
+ if (tc->curr_entry == tc->entries_allocated) {
+ tc->entries_allocated *= 2;
+ tc->entries = moz_xrealloc(tc->entries,
+ tc->entries_allocated * sizeof(TimecardEntry));
+ }
+
+ /* Record the data into the timecard entry */
+ entry = &tc->entries[tc->curr_entry];
+ entry->timestamp = PR_Now();
+ entry->event = event;
+ entry->file = file;
+ entry->line = line;
+ entry->function = function;
+ tc->curr_entry++;
+}
+
+void
+print_timecard(Timecard *tc)
+{
+ size_t i;
+ TimecardEntry *entry;
+ size_t event_width = 5;
+ size_t file_width = 4;
+ size_t function_width = 8;
+ size_t line_width;
+ PRTime offset, delta;
+
+ for (i = 0; i < tc->curr_entry; i++) {
+ entry = &tc->entries[i];
+ if (strlen(entry->event) > event_width) {
+ event_width = strlen(entry->event);
+ }
+ if (strlen(entry->file) > file_width) {
+ file_width = strlen(entry->file);
+ }
+ if (strlen(entry->function) > function_width) {
+ function_width = strlen(entry->function);
+ }
+ }
+
+ printf("\nTimecard created %4ld.%6.6ld\n\n",
+ (long)(tc->start_time / PR_USEC_PER_SEC),
+ (long)(tc->start_time % PR_USEC_PER_SEC));
+
+ line_width = 1 + 11 + 11 + event_width + file_width + 6 +
+ function_width + (4 * 3);
+
+ printf(" %-11s | %-11s | %-*s | %-*s | %-*s\n",
+ "Timestamp", "Delta",
+ (int)event_width, "Event",
+ (int)file_width + 6, "File",
+ (int)function_width, "Function");
+
+ for (i = 0; i <= line_width; i++) {
+ printf("=");
+ }
+ printf("\n");
+
+ for (i = 0; i < tc->curr_entry; i++) {
+ entry = &tc->entries[i];
+ offset = entry->timestamp - tc->start_time;
+ if (i > 0) {
+ delta = entry->timestamp - tc->entries[i-1].timestamp;
+ } else {
+ delta = entry->timestamp - tc->start_time;
+ }
+ printf(" %4ld.%6.6ld | %4ld.%6.6ld | %-*s | %*s:%-5d | %-*s\n",
+ (long)(offset / PR_USEC_PER_SEC), (long)(offset % PR_USEC_PER_SEC),
+ (long)(delta / PR_USEC_PER_SEC), (long)(delta % PR_USEC_PER_SEC),
+ (int)event_width, entry->event,
+ (int)file_width, entry->file, entry->line,
+ (int)function_width, entry->function);
+ }
+ printf("\n");
+}
diff --git a/media/webrtc/signaling/src/common/time_profiling/timecard.h b/media/webrtc/signaling/src/common/time_profiling/timecard.h
new file mode 100644
index 000000000..ca53b8dfe
--- /dev/null
+++ b/media/webrtc/signaling/src/common/time_profiling/timecard.h
@@ -0,0 +1,81 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef timecard_h__
+#define timecard_h__
+
+#include <stdlib.h>
+#include "prtime.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define STAMP_TIMECARD(card,event) \
+ do { \
+ if (card) { \
+ stamp_timecard((card), (event), __FILE__, __LINE__, __FUNCTION__); \
+ } \
+ } while (0)
+
+#define TIMECARD_INITIAL_TABLE_SIZE 16
+
+/*
+ * The "const char *" members of this structure point to static strings.
+ * We do not own them, and should not attempt to deallocate them.
+ */
+
+typedef struct {
+ PRTime timestamp;
+ const char *event;
+ const char *file;
+ unsigned int line;
+ const char *function;
+} TimecardEntry;
+
+typedef struct Timecard {
+ size_t curr_entry;
+ size_t entries_allocated;
+ TimecardEntry *entries;
+ PRTime start_time;
+} Timecard;
+
+/**
+ * Creates a new Timecard structure for tracking events.
+ */
+Timecard *
+create_timecard();
+
+/**
+ * Frees the memory associated with a timecard. After returning, the
+ * timecard pointed to by tc is no longer valid.
+ */
+void
+destroy_timecard(Timecard *tc);
+
+/**
+ * Records a new event in the indicated timecard. This should not be
+ * called directly; code should instead use the STAMP_TIMECARD macro,
+ * above.
+ */
+void
+stamp_timecard(Timecard *tc,
+ const char *event,
+ const char *file,
+ unsigned int line,
+ const char *function);
+
+/**
+ * Formats and outputs the contents of a timecard onto stdout.
+ */
+void
+print_timecard(Timecard *tc);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/media/webrtc/signaling/src/jsep/JsepCodecDescription.h b/media/webrtc/signaling/src/jsep/JsepCodecDescription.h
new file mode 100644
index 000000000..6ae5c9380
--- /dev/null
+++ b/media/webrtc/signaling/src/jsep/JsepCodecDescription.h
@@ -0,0 +1,780 @@
+/* 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/. */
+
+#ifndef _JSEPCODECDESCRIPTION_H_
+#define _JSEPCODECDESCRIPTION_H_
+
+#include <string>
+#include "signaling/src/sdp/SdpMediaSection.h"
+#include "signaling/src/sdp/SdpHelper.h"
+#include "nsCRT.h"
+
+namespace mozilla {
+
+#define JSEP_CODEC_CLONE(T) \
+ virtual JsepCodecDescription* Clone() const override \
+ { \
+ return new T(*this); \
+ }
+
+// A single entry in our list of known codecs.
+class JsepCodecDescription {
+ public:
+ JsepCodecDescription(mozilla::SdpMediaSection::MediaType type,
+ const std::string& defaultPt,
+ const std::string& name,
+ uint32_t clock,
+ uint32_t channels,
+ bool enabled)
+ : mType(type),
+ mDefaultPt(defaultPt),
+ mName(name),
+ mClock(clock),
+ mChannels(channels),
+ mEnabled(enabled),
+ mStronglyPreferred(false),
+ mDirection(sdp::kSend)
+ {
+ }
+ virtual ~JsepCodecDescription() {}
+
+ virtual JsepCodecDescription* Clone() const = 0;
+
+ bool
+ GetPtAsInt(uint16_t* ptOutparam) const
+ {
+ return SdpHelper::GetPtAsInt(mDefaultPt, ptOutparam);
+ }
+
+ virtual bool
+ Matches(const std::string& fmt, const SdpMediaSection& remoteMsection) const
+ {
+ // note: fmt here is remote fmt (to go with remoteMsection)
+ if (mType != remoteMsection.GetMediaType()) {
+ return false;
+ }
+
+ const SdpRtpmapAttributeList::Rtpmap* entry(remoteMsection.FindRtpmap(fmt));
+
+ if (entry) {
+ if (!nsCRT::strcasecmp(mName.c_str(), entry->name.c_str())
+ && (mClock == entry->clock)
+ && (mChannels == entry->channels)) {
+ return ParametersMatch(fmt, remoteMsection);
+ }
+ } else if (!fmt.compare("9") && mName == "G722") {
+ return true;
+ } else if (!fmt.compare("0") && mName == "PCMU") {
+ return true;
+ } else if (!fmt.compare("8") && mName == "PCMA") {
+ return true;
+ }
+ return false;
+ }
+
+ virtual bool
+ ParametersMatch(const std::string& fmt,
+ const SdpMediaSection& remoteMsection) const
+ {
+ return true;
+ }
+
+ virtual bool
+ Negotiate(const std::string& pt, const SdpMediaSection& remoteMsection)
+ {
+ mDefaultPt = pt;
+ return true;
+ }
+
+ virtual void
+ AddToMediaSection(SdpMediaSection& msection) const
+ {
+ if (mEnabled && msection.GetMediaType() == mType) {
+ // Both send and recv codec will have the same pt, so don't add twice
+ if (!msection.HasFormat(mDefaultPt)) {
+ if (mType == SdpMediaSection::kApplication) {
+ // Hack: using mChannels for number of streams
+ msection.AddDataChannel(mDefaultPt, mName, mChannels);
+ } else {
+ msection.AddCodec(mDefaultPt, mName, mClock, mChannels);
+ }
+ }
+
+ AddParametersToMSection(msection);
+ }
+ }
+
+ virtual void AddParametersToMSection(SdpMediaSection& msection) const {}
+
+ mozilla::SdpMediaSection::MediaType mType;
+ std::string mDefaultPt;
+ std::string mName;
+ uint32_t mClock;
+ uint32_t mChannels;
+ bool mEnabled;
+ bool mStronglyPreferred;
+ sdp::Direction mDirection;
+ // Will hold constraints from both fmtp and rid
+ EncodingConstraints mConstraints;
+};
+
+class JsepAudioCodecDescription : public JsepCodecDescription {
+ public:
+ JsepAudioCodecDescription(const std::string& defaultPt,
+ const std::string& name,
+ uint32_t clock,
+ uint32_t channels,
+ uint32_t packetSize,
+ uint32_t bitRate,
+ bool enabled = true)
+ : JsepCodecDescription(mozilla::SdpMediaSection::kAudio, defaultPt, name,
+ clock, channels, enabled),
+ mPacketSize(packetSize),
+ mBitrate(bitRate),
+ mMaxPlaybackRate(0),
+ mForceMono(false),
+ mFECEnabled(false),
+ mDtmfEnabled(false)
+ {
+ }
+
+ JSEP_CODEC_CLONE(JsepAudioCodecDescription)
+
+ SdpFmtpAttributeList::OpusParameters
+ GetOpusParameters(const std::string& pt,
+ const SdpMediaSection& msection) const
+ {
+ // Will contain defaults if nothing else
+ SdpFmtpAttributeList::OpusParameters result;
+ auto* params = msection.FindFmtp(pt);
+
+ if (params && params->codec_type == SdpRtpmapAttributeList::kOpus) {
+ result =
+ static_cast<const SdpFmtpAttributeList::OpusParameters&>(*params);
+ }
+
+ return result;
+ }
+
+ SdpFmtpAttributeList::TelephoneEventParameters
+ GetTelephoneEventParameters(const std::string& pt,
+ const SdpMediaSection& msection) const
+ {
+ // Will contain defaults if nothing else
+ SdpFmtpAttributeList::TelephoneEventParameters result;
+ auto* params = msection.FindFmtp(pt);
+
+ if (params && params->codec_type == SdpRtpmapAttributeList::kTelephoneEvent) {
+ result =
+ static_cast<const SdpFmtpAttributeList::TelephoneEventParameters&>
+ (*params);
+ }
+
+ return result;
+ }
+
+ void
+ AddParametersToMSection(SdpMediaSection& msection) const override
+ {
+ if (mDirection == sdp::kSend) {
+ return;
+ }
+
+ if (mName == "opus") {
+ SdpFmtpAttributeList::OpusParameters opusParams(
+ GetOpusParameters(mDefaultPt, msection));
+ if (mMaxPlaybackRate) {
+ opusParams.maxplaybackrate = mMaxPlaybackRate;
+ }
+ if (mChannels == 2 && !mForceMono) {
+ // We prefer to receive stereo, if available.
+ opusParams.stereo = 1;
+ }
+ opusParams.useInBandFec = mFECEnabled ? 1 : 0;
+ msection.SetFmtp(SdpFmtpAttributeList::Fmtp(mDefaultPt, opusParams));
+ } else if (mName == "telephone-event") {
+ // add the default dtmf tones
+ SdpFmtpAttributeList::TelephoneEventParameters teParams(
+ GetTelephoneEventParameters(mDefaultPt, msection));
+ msection.SetFmtp(SdpFmtpAttributeList::Fmtp(mDefaultPt, teParams));
+ }
+ }
+
+ bool
+ Negotiate(const std::string& pt,
+ const SdpMediaSection& remoteMsection) override
+ {
+ JsepCodecDescription::Negotiate(pt, remoteMsection);
+ if (mName == "opus" && mDirection == sdp::kSend) {
+ SdpFmtpAttributeList::OpusParameters opusParams(
+ GetOpusParameters(mDefaultPt, remoteMsection));
+
+ mMaxPlaybackRate = opusParams.maxplaybackrate;
+ mForceMono = !opusParams.stereo;
+ // draft-ietf-rtcweb-fec-03.txt section 4.2 says support for FEC
+ // at the received side is declarative and can be negotiated
+ // separately for either media direction.
+ mFECEnabled = opusParams.useInBandFec;
+ }
+
+ return true;
+ }
+
+ uint32_t mPacketSize;
+ uint32_t mBitrate;
+ uint32_t mMaxPlaybackRate;
+ bool mForceMono;
+ bool mFECEnabled;
+ bool mDtmfEnabled;
+};
+
+class JsepVideoCodecDescription : public JsepCodecDescription {
+ public:
+ JsepVideoCodecDescription(const std::string& defaultPt,
+ const std::string& name,
+ uint32_t clock,
+ bool enabled = true)
+ : JsepCodecDescription(mozilla::SdpMediaSection::kVideo, defaultPt, name,
+ clock, 0, enabled),
+ mTmmbrEnabled(false),
+ mRembEnabled(false),
+ mFECEnabled(false),
+ mPacketizationMode(0)
+ {
+ // Add supported rtcp-fb types
+ mNackFbTypes.push_back("");
+ mNackFbTypes.push_back(SdpRtcpFbAttributeList::pli);
+ mCcmFbTypes.push_back(SdpRtcpFbAttributeList::fir);
+ }
+
+ virtual void
+ EnableTmmbr() {
+ // EnableTmmbr can be called multiple times due to multiple calls to
+ // PeerConnectionImpl::ConfigureJsepSessionCodecs
+ if (!mTmmbrEnabled) {
+ mTmmbrEnabled = true;
+ mCcmFbTypes.push_back(SdpRtcpFbAttributeList::tmmbr);
+ }
+ }
+
+ virtual void
+ EnableRemb() {
+ // EnableRemb can be called multiple times due to multiple calls to
+ // PeerConnectionImpl::ConfigureJsepSessionCodecs
+ if (!mRembEnabled) {
+ mRembEnabled = true;
+ mOtherFbTypes.push_back({ "", SdpRtcpFbAttributeList::kRemb, "", ""});
+ }
+ }
+
+ virtual void
+ EnableFec() {
+ // Enabling FEC for video works a little differently than enabling
+ // REMB or TMMBR. Support for FEC is indicated by the presence of
+ // particular codes (red and ulpfec) instead of using rtcpfb
+ // attributes on a given codec. There is no rtcpfb to push for FEC
+ // as can be seen above when REMB or TMMBR are enabled.
+ mFECEnabled = true;
+ }
+
+ void
+ AddParametersToMSection(SdpMediaSection& msection) const override
+ {
+ AddFmtpsToMSection(msection);
+ AddRtcpFbsToMSection(msection);
+ }
+
+ void
+ AddFmtpsToMSection(SdpMediaSection& msection) const
+ {
+ if (mName == "H264") {
+ SdpFmtpAttributeList::H264Parameters h264Params(
+ GetH264Parameters(mDefaultPt, msection));
+
+ if (mDirection == sdp::kSend) {
+ if (!h264Params.level_asymmetry_allowed) {
+ // First time the fmtp has been set; set just in case this is for a
+ // sendonly m-line, since even though we aren't receiving the level
+ // negotiation still needs to happen (sigh).
+ h264Params.profile_level_id = mProfileLevelId;
+ }
+ } else {
+ // Parameters that only apply to what we receive
+ h264Params.max_mbps = mConstraints.maxMbps;
+ h264Params.max_fs = mConstraints.maxFs;
+ h264Params.max_cpb = mConstraints.maxCpb;
+ h264Params.max_dpb = mConstraints.maxDpb;
+ h264Params.max_br = mConstraints.maxBr;
+ strncpy(h264Params.sprop_parameter_sets,
+ mSpropParameterSets.c_str(),
+ sizeof(h264Params.sprop_parameter_sets) - 1);
+ h264Params.profile_level_id = mProfileLevelId;
+ }
+
+ // Parameters that apply to both the send and recv directions
+ h264Params.packetization_mode = mPacketizationMode;
+ // Hard-coded, may need to change someday?
+ h264Params.level_asymmetry_allowed = true;
+
+ msection.SetFmtp(SdpFmtpAttributeList::Fmtp(mDefaultPt, h264Params));
+ } else if (mName == "red") {
+ SdpFmtpAttributeList::RedParameters redParams(
+ GetRedParameters(mDefaultPt, msection));
+ redParams.encodings = mRedundantEncodings;
+ msection.SetFmtp(SdpFmtpAttributeList::Fmtp(mDefaultPt, redParams));
+ } else if (mName == "VP8" || mName == "VP9") {
+ if (mDirection == sdp::kRecv) {
+ // VP8 and VP9 share the same SDP parameters thus far
+ SdpFmtpAttributeList::VP8Parameters vp8Params(
+ GetVP8Parameters(mDefaultPt, msection));
+
+ vp8Params.max_fs = mConstraints.maxFs;
+ vp8Params.max_fr = mConstraints.maxFps;
+ msection.SetFmtp(SdpFmtpAttributeList::Fmtp(mDefaultPt, vp8Params));
+ }
+ }
+ }
+
+ void
+ AddRtcpFbsToMSection(SdpMediaSection& msection) const
+ {
+ SdpRtcpFbAttributeList rtcpfbs(msection.GetRtcpFbs());
+ for (const auto& rtcpfb : rtcpfbs.mFeedbacks) {
+ if (rtcpfb.pt == mDefaultPt) {
+ // Already set by the codec for the other direction.
+ return;
+ }
+ }
+
+ for (const std::string& type : mAckFbTypes) {
+ rtcpfbs.PushEntry(mDefaultPt, SdpRtcpFbAttributeList::kAck, type);
+ }
+ for (const std::string& type : mNackFbTypes) {
+ rtcpfbs.PushEntry(mDefaultPt, SdpRtcpFbAttributeList::kNack, type);
+ }
+ for (const std::string& type : mCcmFbTypes) {
+ rtcpfbs.PushEntry(mDefaultPt, SdpRtcpFbAttributeList::kCcm, type);
+ }
+ for (const auto& fb : mOtherFbTypes) {
+ rtcpfbs.PushEntry(mDefaultPt, fb.type, fb.parameter, fb.extra);
+ }
+
+ msection.SetRtcpFbs(rtcpfbs);
+ }
+
+ SdpFmtpAttributeList::H264Parameters
+ GetH264Parameters(const std::string& pt,
+ const SdpMediaSection& msection) const
+ {
+ // Will contain defaults if nothing else
+ SdpFmtpAttributeList::H264Parameters result;
+ auto* params = msection.FindFmtp(pt);
+
+ if (params && params->codec_type == SdpRtpmapAttributeList::kH264) {
+ result =
+ static_cast<const SdpFmtpAttributeList::H264Parameters&>(*params);
+ }
+
+ return result;
+ }
+
+ SdpFmtpAttributeList::RedParameters
+ GetRedParameters(const std::string& pt,
+ const SdpMediaSection& msection) const
+ {
+ SdpFmtpAttributeList::RedParameters result;
+ auto* params = msection.FindFmtp(pt);
+
+ if (params && params->codec_type == SdpRtpmapAttributeList::kRed) {
+ result =
+ static_cast<const SdpFmtpAttributeList::RedParameters&>(*params);
+ }
+
+ return result;
+ }
+
+ SdpFmtpAttributeList::VP8Parameters
+ GetVP8Parameters(const std::string& pt,
+ const SdpMediaSection& msection) const
+ {
+ SdpRtpmapAttributeList::CodecType expectedType(
+ mName == "VP8" ?
+ SdpRtpmapAttributeList::kVP8 :
+ SdpRtpmapAttributeList::kVP9);
+
+ // Will contain defaults if nothing else
+ SdpFmtpAttributeList::VP8Parameters result(expectedType);
+ auto* params = msection.FindFmtp(pt);
+
+ if (params && params->codec_type == expectedType) {
+ result =
+ static_cast<const SdpFmtpAttributeList::VP8Parameters&>(*params);
+ }
+
+ return result;
+ }
+
+ void
+ NegotiateRtcpFb(const SdpMediaSection& remoteMsection,
+ SdpRtcpFbAttributeList::Type type,
+ std::vector<std::string>* supportedTypes)
+ {
+ std::vector<std::string> temp;
+ for (auto& subType : *supportedTypes) {
+ if (remoteMsection.HasRtcpFb(mDefaultPt, type, subType)) {
+ temp.push_back(subType);
+ }
+ }
+ *supportedTypes = temp;
+ }
+
+ void
+ NegotiateRtcpFb(const SdpMediaSection& remoteMsection,
+ std::vector<SdpRtcpFbAttributeList::Feedback>* supportedFbs) {
+ std::vector<SdpRtcpFbAttributeList::Feedback> temp;
+ for (auto& fb : *supportedFbs) {
+ if (remoteMsection.HasRtcpFb(mDefaultPt, fb.type, fb.parameter)) {
+ temp.push_back(fb);
+ }
+ }
+ *supportedFbs = temp;
+ }
+
+ void
+ NegotiateRtcpFb(const SdpMediaSection& remote)
+ {
+ // Removes rtcp-fb types that the other side doesn't support
+ NegotiateRtcpFb(remote, SdpRtcpFbAttributeList::kAck, &mAckFbTypes);
+ NegotiateRtcpFb(remote, SdpRtcpFbAttributeList::kNack, &mNackFbTypes);
+ NegotiateRtcpFb(remote, SdpRtcpFbAttributeList::kCcm, &mCcmFbTypes);
+ NegotiateRtcpFb(remote, &mOtherFbTypes);
+ }
+
+ virtual bool
+ Negotiate(const std::string& pt,
+ const SdpMediaSection& remoteMsection) override
+ {
+ JsepCodecDescription::Negotiate(pt, remoteMsection);
+ if (mName == "H264") {
+ SdpFmtpAttributeList::H264Parameters h264Params(
+ GetH264Parameters(mDefaultPt, remoteMsection));
+
+ // Level is negotiated symmetrically if level asymmetry is disallowed
+ if (!h264Params.level_asymmetry_allowed) {
+ SetSaneH264Level(std::min(GetSaneH264Level(h264Params.profile_level_id),
+ GetSaneH264Level(mProfileLevelId)),
+ &mProfileLevelId);
+ }
+
+ if (mDirection == sdp::kSend) {
+ // Remote values of these apply only to the send codec.
+ mConstraints.maxFs = h264Params.max_fs;
+ mConstraints.maxMbps = h264Params.max_mbps;
+ mConstraints.maxCpb = h264Params.max_cpb;
+ mConstraints.maxDpb = h264Params.max_dpb;
+ mConstraints.maxBr = h264Params.max_br;
+ mSpropParameterSets = h264Params.sprop_parameter_sets;
+ // Only do this if we didn't symmetrically negotiate above
+ if (h264Params.level_asymmetry_allowed) {
+ SetSaneH264Level(GetSaneH264Level(h264Params.profile_level_id),
+ &mProfileLevelId);
+ }
+ } else {
+ // TODO(bug 1143709): max-recv-level support
+ }
+ } else if (mName == "red") {
+ SdpFmtpAttributeList::RedParameters redParams(
+ GetRedParameters(mDefaultPt, remoteMsection));
+ mRedundantEncodings = redParams.encodings;
+ } else if (mName == "VP8" || mName == "VP9") {
+ if (mDirection == sdp::kSend) {
+ SdpFmtpAttributeList::VP8Parameters vp8Params(
+ GetVP8Parameters(mDefaultPt, remoteMsection));
+
+ mConstraints.maxFs = vp8Params.max_fs;
+ mConstraints.maxFps = vp8Params.max_fr;
+ }
+ }
+
+ NegotiateRtcpFb(remoteMsection);
+ return true;
+ }
+
+ // Maps the not-so-sane encoding of H264 level into something that is
+ // ordered in the way one would expect
+ // 1b is 0xAB, everything else is the level left-shifted one half-byte
+ // (eg; 1.0 is 0xA0, 1.1 is 0xB0, 3.1 is 0x1F0)
+ static uint32_t
+ GetSaneH264Level(uint32_t profileLevelId)
+ {
+ uint32_t profileIdc = (profileLevelId >> 16);
+
+ if (profileIdc == 0x42 || profileIdc == 0x4D || profileIdc == 0x58) {
+ if ((profileLevelId & 0x10FF) == 0x100B) {
+ // Level 1b
+ return 0xAB;
+ }
+ }
+
+ uint32_t level = profileLevelId & 0xFF;
+
+ if (level == 0x09) {
+ // Another way to encode level 1b
+ return 0xAB;
+ }
+
+ return level << 4;
+ }
+
+ static void
+ SetSaneH264Level(uint32_t level, uint32_t* profileLevelId)
+ {
+ uint32_t profileIdc = (*profileLevelId >> 16);
+ uint32_t levelMask = 0xFF;
+
+ if (profileIdc == 0x42 || profileIdc == 0x4d || profileIdc == 0x58) {
+ levelMask = 0x10FF;
+ if (level == 0xAB) {
+ // Level 1b
+ level = 0x100B;
+ } else {
+ // Not 1b, just shift
+ level = level >> 4;
+ }
+ } else if (level == 0xAB) {
+ // Another way to encode 1b
+ level = 0x09;
+ } else {
+ // Not 1b, just shift
+ level = level >> 4;
+ }
+
+ *profileLevelId = (*profileLevelId & ~levelMask) | level;
+ }
+
+ enum Subprofile {
+ kH264ConstrainedBaseline,
+ kH264Baseline,
+ kH264Main,
+ kH264Extended,
+ kH264High,
+ kH264High10,
+ kH264High42,
+ kH264High44,
+ kH264High10I,
+ kH264High42I,
+ kH264High44I,
+ kH264CALVC44,
+ kH264UnknownSubprofile
+ };
+
+ static Subprofile
+ GetSubprofile(uint32_t profileLevelId)
+ {
+ // Based on Table 5 from RFC 6184:
+ // Profile profile_idc profile-iop
+ // (hexadecimal) (binary)
+
+ // CB 42 (B) x1xx0000
+ // same as: 4D (M) 1xxx0000
+ // same as: 58 (E) 11xx0000
+ // B 42 (B) x0xx0000
+ // same as: 58 (E) 10xx0000
+ // M 4D (M) 0x0x0000
+ // E 58 00xx0000
+ // H 64 00000000
+ // H10 6E 00000000
+ // H42 7A 00000000
+ // H44 F4 00000000
+ // H10I 6E 00010000
+ // H42I 7A 00010000
+ // H44I F4 00010000
+ // C44I 2C 00010000
+
+ if ((profileLevelId & 0xFF4F00) == 0x424000) {
+ // 01001111 (mask, 0x4F)
+ // x1xx0000 (from table)
+ // 01000000 (expected value, 0x40)
+ return kH264ConstrainedBaseline;
+ }
+
+ if ((profileLevelId & 0xFF8F00) == 0x4D8000) {
+ // 10001111 (mask, 0x8F)
+ // 1xxx0000 (from table)
+ // 10000000 (expected value, 0x80)
+ return kH264ConstrainedBaseline;
+ }
+
+ if ((profileLevelId & 0xFFCF00) == 0x58C000) {
+ // 11001111 (mask, 0xCF)
+ // 11xx0000 (from table)
+ // 11000000 (expected value, 0xC0)
+ return kH264ConstrainedBaseline;
+ }
+
+ if ((profileLevelId & 0xFF4F00) == 0x420000) {
+ // 01001111 (mask, 0x4F)
+ // x0xx0000 (from table)
+ // 00000000 (expected value)
+ return kH264Baseline;
+ }
+
+ if ((profileLevelId & 0xFFCF00) == 0x588000) {
+ // 11001111 (mask, 0xCF)
+ // 10xx0000 (from table)
+ // 10000000 (expected value, 0x80)
+ return kH264Baseline;
+ }
+
+ if ((profileLevelId & 0xFFAF00) == 0x4D0000) {
+ // 10101111 (mask, 0xAF)
+ // 0x0x0000 (from table)
+ // 00000000 (expected value)
+ return kH264Main;
+ }
+
+ if ((profileLevelId & 0xFF0000) == 0x580000) {
+ // 11001111 (mask, 0xCF)
+ // 00xx0000 (from table)
+ // 00000000 (expected value)
+ return kH264Extended;
+ }
+
+ if ((profileLevelId & 0xFFFF00) == 0x640000) {
+ return kH264High;
+ }
+
+ if ((profileLevelId & 0xFFFF00) == 0x6E0000) {
+ return kH264High10;
+ }
+
+ if ((profileLevelId & 0xFFFF00) == 0x7A0000) {
+ return kH264High42;
+ }
+
+ if ((profileLevelId & 0xFFFF00) == 0xF40000) {
+ return kH264High44;
+ }
+
+ if ((profileLevelId & 0xFFFF00) == 0x6E1000) {
+ return kH264High10I;
+ }
+
+ if ((profileLevelId & 0xFFFF00) == 0x7A1000) {
+ return kH264High42I;
+ }
+
+ if ((profileLevelId & 0xFFFF00) == 0xF41000) {
+ return kH264High44I;
+ }
+
+ if ((profileLevelId & 0xFFFF00) == 0x2C1000) {
+ return kH264CALVC44;
+ }
+
+ return kH264UnknownSubprofile;
+ }
+
+ virtual bool
+ ParametersMatch(const std::string& fmt,
+ const SdpMediaSection& remoteMsection) const override
+ {
+ if (mName == "H264") {
+ SdpFmtpAttributeList::H264Parameters h264Params(
+ GetH264Parameters(fmt, remoteMsection));
+
+ if (h264Params.packetization_mode != mPacketizationMode) {
+ return false;
+ }
+
+ if (GetSubprofile(h264Params.profile_level_id) !=
+ GetSubprofile(mProfileLevelId)) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ virtual bool
+ RtcpFbRembIsSet() const
+ {
+ for (const auto& fb : mOtherFbTypes) {
+ if (fb.type == SdpRtcpFbAttributeList::kRemb) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ virtual void
+ UpdateRedundantEncodings(std::vector<JsepCodecDescription*> codecs)
+ {
+ for (const auto codec : codecs) {
+ if (codec->mType == SdpMediaSection::kVideo &&
+ codec->mEnabled &&
+ codec->mName != "red") {
+ uint8_t pt = (uint8_t)strtoul(codec->mDefaultPt.c_str(), nullptr, 10);
+ // returns 0 if failed to convert, and since zero could
+ // be valid, check the defaultPt for 0
+ if (pt == 0 && codec->mDefaultPt != "0") {
+ continue;
+ }
+ mRedundantEncodings.push_back(pt);
+ }
+ }
+ }
+
+ JSEP_CODEC_CLONE(JsepVideoCodecDescription)
+
+ std::vector<std::string> mAckFbTypes;
+ std::vector<std::string> mNackFbTypes;
+ std::vector<std::string> mCcmFbTypes;
+ std::vector<SdpRtcpFbAttributeList::Feedback> mOtherFbTypes;
+ bool mTmmbrEnabled;
+ bool mRembEnabled;
+ bool mFECEnabled;
+ std::vector<uint8_t> mRedundantEncodings;
+
+ // H264-specific stuff
+ uint32_t mProfileLevelId;
+ uint32_t mPacketizationMode;
+ std::string mSpropParameterSets;
+};
+
+class JsepApplicationCodecDescription : public JsepCodecDescription {
+ public:
+ JsepApplicationCodecDescription(const std::string& defaultPt,
+ const std::string& name,
+ uint16_t channels,
+ bool enabled = true)
+ : JsepCodecDescription(mozilla::SdpMediaSection::kApplication, defaultPt,
+ name, 0, channels, enabled)
+ {
+ }
+
+ JSEP_CODEC_CLONE(JsepApplicationCodecDescription)
+
+ // Override, uses sctpmap instead of rtpmap
+ virtual bool
+ Matches(const std::string& fmt,
+ const SdpMediaSection& remoteMsection) const override
+ {
+ if (mType != remoteMsection.GetMediaType()) {
+ return false;
+ }
+
+ const SdpSctpmapAttributeList::Sctpmap* entry(
+ remoteMsection.FindSctpmap(fmt));
+
+ if (entry && !nsCRT::strcasecmp(mName.c_str(), entry->name.c_str())) {
+ return true;
+ }
+ return false;
+ }
+};
+
+} // namespace mozilla
+
+#endif
diff --git a/media/webrtc/signaling/src/jsep/JsepSession.h b/media/webrtc/signaling/src/jsep/JsepSession.h
new file mode 100644
index 000000000..29bcbde05
--- /dev/null
+++ b/media/webrtc/signaling/src/jsep/JsepSession.h
@@ -0,0 +1,243 @@
+/* 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/. */
+
+#ifndef _JSEPSESSION_H_
+#define _JSEPSESSION_H_
+
+#include <string>
+#include <vector>
+#include "mozilla/Maybe.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/UniquePtr.h"
+#include "nsError.h"
+
+#include "signaling/src/jsep/JsepTransport.h"
+#include "signaling/src/sdp/Sdp.h"
+
+#include "JsepTrack.h"
+
+namespace mozilla {
+
+// Forward declarations
+class JsepCodecDescription;
+class JsepTrack;
+
+enum JsepSignalingState {
+ kJsepStateStable,
+ kJsepStateHaveLocalOffer,
+ kJsepStateHaveRemoteOffer,
+ kJsepStateHaveLocalPranswer,
+ kJsepStateHaveRemotePranswer,
+ kJsepStateClosed
+};
+
+enum JsepSdpType {
+ kJsepSdpOffer,
+ kJsepSdpAnswer,
+ kJsepSdpPranswer,
+ kJsepSdpRollback
+};
+
+struct JsepOAOptions {};
+struct JsepOfferOptions : public JsepOAOptions {
+ Maybe<size_t> mOfferToReceiveAudio;
+ Maybe<size_t> mOfferToReceiveVideo;
+ Maybe<bool> mDontOfferDataChannel;
+ Maybe<bool> mIceRestart; // currently ignored by JsepSession
+};
+struct JsepAnswerOptions : public JsepOAOptions {};
+
+enum JsepBundlePolicy {
+ kBundleBalanced,
+ kBundleMaxCompat,
+ kBundleMaxBundle
+};
+
+class JsepSession
+{
+public:
+ explicit JsepSession(const std::string& name)
+ : mName(name), mState(kJsepStateStable), mNegotiations(0)
+ {
+ }
+ virtual ~JsepSession() {}
+
+ virtual nsresult Init() = 0;
+
+ // Accessors for basic properties.
+ virtual const std::string&
+ GetName() const
+ {
+ return mName;
+ }
+ virtual JsepSignalingState
+ GetState() const
+ {
+ return mState;
+ }
+ virtual uint32_t
+ GetNegotiations() const
+ {
+ return mNegotiations;
+ }
+
+ // Set up the ICE And DTLS data.
+ virtual nsresult SetIceCredentials(const std::string& ufrag,
+ const std::string& pwd) = 0;
+ virtual const std::string& GetUfrag() const = 0;
+ virtual const std::string& GetPwd() const = 0;
+ virtual nsresult SetBundlePolicy(JsepBundlePolicy policy) = 0;
+ virtual bool RemoteIsIceLite() const = 0;
+ virtual bool RemoteIceIsRestarting() const = 0;
+ virtual std::vector<std::string> GetIceOptions() const = 0;
+
+ virtual nsresult AddDtlsFingerprint(const std::string& algorithm,
+ const std::vector<uint8_t>& value) = 0;
+
+ virtual nsresult AddAudioRtpExtension(const std::string& extensionName,
+ SdpDirectionAttribute::Direction direction) = 0;
+ virtual nsresult AddVideoRtpExtension(const std::string& extensionName,
+ SdpDirectionAttribute::Direction direction) = 0;
+
+ // Kinda gross to be locking down the data structure type like this, but
+ // returning by value is problematic due to the lack of stl move semantics in
+ // our build config, since we can't use UniquePtr in the container. The
+ // alternative is writing a raft of accessor functions that allow arbitrary
+ // manipulation (which will be unwieldy), or allowing functors to be injected
+ // that manipulate the data structure (still pretty unwieldy).
+ virtual std::vector<JsepCodecDescription*>& Codecs() = 0;
+
+ template <class UnaryFunction>
+ void ForEachCodec(UnaryFunction& function)
+ {
+ std::for_each(Codecs().begin(), Codecs().end(), function);
+ for (RefPtr<JsepTrack>& track : GetLocalTracks()) {
+ track->ForEachCodec(function);
+ }
+ for (RefPtr<JsepTrack>& track : GetRemoteTracks()) {
+ track->ForEachCodec(function);
+ }
+ }
+
+ template <class BinaryPredicate>
+ void SortCodecs(BinaryPredicate& sorter)
+ {
+ std::stable_sort(Codecs().begin(), Codecs().end(), sorter);
+ for (RefPtr<JsepTrack>& track : GetLocalTracks()) {
+ track->SortCodecs(sorter);
+ }
+ for (RefPtr<JsepTrack>& track : GetRemoteTracks()) {
+ track->SortCodecs(sorter);
+ }
+ }
+
+ // Manage tracks. We take shared ownership of any track.
+ virtual nsresult AddTrack(const RefPtr<JsepTrack>& track) = 0;
+ virtual nsresult RemoveTrack(const std::string& streamId,
+ const std::string& trackId) = 0;
+ virtual nsresult ReplaceTrack(const std::string& oldStreamId,
+ const std::string& oldTrackId,
+ const std::string& newStreamId,
+ const std::string& newTrackId) = 0;
+ virtual nsresult SetParameters(
+ const std::string& streamId,
+ const std::string& trackId,
+ const std::vector<JsepTrack::JsConstraints>& constraints) = 0;
+
+ virtual nsresult GetParameters(
+ const std::string& streamId,
+ const std::string& trackId,
+ std::vector<JsepTrack::JsConstraints>* outConstraints) = 0;
+
+ virtual std::vector<RefPtr<JsepTrack>> GetLocalTracks() const = 0;
+
+ virtual std::vector<RefPtr<JsepTrack>> GetRemoteTracks() const = 0;
+
+ virtual std::vector<RefPtr<JsepTrack>> GetRemoteTracksAdded() const = 0;
+
+ virtual std::vector<RefPtr<JsepTrack>> GetRemoteTracksRemoved() const = 0;
+
+ // Access the negotiated track pairs.
+ virtual std::vector<JsepTrackPair> GetNegotiatedTrackPairs() const = 0;
+
+ // Access transports.
+ virtual std::vector<RefPtr<JsepTransport>> GetTransports() const = 0;
+
+ // Basic JSEP operations.
+ virtual nsresult CreateOffer(const JsepOfferOptions& options,
+ std::string* offer) = 0;
+ virtual nsresult CreateAnswer(const JsepAnswerOptions& options,
+ std::string* answer) = 0;
+ virtual std::string GetLocalDescription() const = 0;
+ virtual std::string GetRemoteDescription() const = 0;
+ virtual nsresult SetLocalDescription(JsepSdpType type,
+ const std::string& sdp) = 0;
+ virtual nsresult SetRemoteDescription(JsepSdpType type,
+ const std::string& sdp) = 0;
+ virtual nsresult AddRemoteIceCandidate(const std::string& candidate,
+ const std::string& mid,
+ uint16_t level) = 0;
+ virtual nsresult AddLocalIceCandidate(const std::string& candidate,
+ uint16_t level,
+ std::string* mid,
+ bool* skipped) = 0;
+ virtual nsresult UpdateDefaultCandidate(
+ const std::string& defaultCandidateAddr,
+ uint16_t defaultCandidatePort,
+ const std::string& defaultRtcpCandidateAddr,
+ uint16_t defaultRtcpCandidatePort,
+ uint16_t level) = 0;
+ virtual nsresult EndOfLocalCandidates(uint16_t level) = 0;
+ virtual nsresult Close() = 0;
+
+ // ICE controlling or controlled
+ virtual bool IsIceControlling() const = 0;
+
+ virtual const std::string
+ GetLastError() const
+ {
+ return "Error";
+ }
+
+ static const char*
+ GetStateStr(JsepSignalingState state)
+ {
+ static const char* states[] = { "stable", "have-local-offer",
+ "have-remote-offer", "have-local-pranswer",
+ "have-remote-pranswer", "closed" };
+
+ return states[state];
+ }
+
+ virtual bool AllLocalTracksAreAssigned() const = 0;
+
+ void
+ CountTracks(uint16_t (&receiving)[SdpMediaSection::kMediaTypes],
+ uint16_t (&sending)[SdpMediaSection::kMediaTypes]) const
+ {
+ auto trackPairs = GetNegotiatedTrackPairs();
+
+ memset(receiving, 0, sizeof(receiving));
+ memset(sending, 0, sizeof(sending));
+
+ for (auto& pair : trackPairs) {
+ if (pair.mReceiving) {
+ receiving[pair.mReceiving->GetMediaType()]++;
+ }
+
+ if (pair.mSending) {
+ sending[pair.mSending->GetMediaType()]++;
+ }
+ }
+ }
+
+protected:
+ const std::string mName;
+ JsepSignalingState mState;
+ uint32_t mNegotiations;
+};
+
+} // namespace mozilla
+
+#endif
diff --git a/media/webrtc/signaling/src/jsep/JsepSessionImpl.cpp b/media/webrtc/signaling/src/jsep/JsepSessionImpl.cpp
new file mode 100644
index 000000000..f5015dda2
--- /dev/null
+++ b/media/webrtc/signaling/src/jsep/JsepSessionImpl.cpp
@@ -0,0 +1,2497 @@
+/* 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 "logging.h"
+
+#include "signaling/src/jsep/JsepSessionImpl.h"
+#include <string>
+#include <set>
+#include <bitset>
+#include <stdlib.h>
+
+#include "nspr.h"
+#include "nss.h"
+#include "pk11pub.h"
+#include "nsDebug.h"
+
+#include <mozilla/Move.h>
+#include <mozilla/UniquePtr.h>
+
+#include "signaling/src/jsep/JsepTrack.h"
+#include "signaling/src/jsep/JsepTrack.h"
+#include "signaling/src/jsep/JsepTransport.h"
+#include "signaling/src/sdp/Sdp.h"
+#include "signaling/src/sdp/SipccSdp.h"
+#include "signaling/src/sdp/SipccSdpParser.h"
+#include "mozilla/net/DataChannelProtocol.h"
+
+namespace mozilla {
+
+MOZ_MTLOG_MODULE("jsep")
+
+#define JSEP_SET_ERROR(error) \
+ do { \
+ std::ostringstream os; \
+ os << error; \
+ mLastError = os.str(); \
+ MOZ_MTLOG(ML_ERROR, mLastError); \
+ } while (0);
+
+static std::bitset<128> GetForbiddenSdpPayloadTypes() {
+ std::bitset<128> forbidden(0);
+ forbidden[1] = true;
+ forbidden[2] = true;
+ forbidden[19] = true;
+ for (uint16_t i = 64; i < 96; ++i) {
+ forbidden[i] = true;
+ }
+ return forbidden;
+}
+
+nsresult
+JsepSessionImpl::Init()
+{
+ mLastError.clear();
+
+ MOZ_ASSERT(!mSessionId, "Init called more than once");
+
+ nsresult rv = SetupIds();
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ SetupDefaultCodecs();
+ SetupDefaultRtpExtensions();
+
+ return NS_OK;
+}
+
+// Helper function to find the track for a given m= section.
+template <class T>
+typename std::vector<T>::iterator
+FindTrackByLevel(std::vector<T>& tracks, size_t level)
+{
+ for (auto t = tracks.begin(); t != tracks.end(); ++t) {
+ if (t->mAssignedMLine.isSome() &&
+ (*t->mAssignedMLine == level)) {
+ return t;
+ }
+ }
+
+ return tracks.end();
+}
+
+template <class T>
+typename std::vector<T>::iterator
+FindTrackByIds(std::vector<T>& tracks,
+ const std::string& streamId,
+ const std::string& trackId)
+{
+ for (auto t = tracks.begin(); t != tracks.end(); ++t) {
+ if (t->mTrack->GetStreamId() == streamId &&
+ (t->mTrack->GetTrackId() == trackId)) {
+ return t;
+ }
+ }
+
+ return tracks.end();
+}
+
+template <class T>
+typename std::vector<T>::iterator
+FindUnassignedTrackByType(std::vector<T>& tracks,
+ SdpMediaSection::MediaType type)
+{
+ for (auto t = tracks.begin(); t != tracks.end(); ++t) {
+ if (!t->mAssignedMLine.isSome() &&
+ (t->mTrack->GetMediaType() == type)) {
+ return t;
+ }
+ }
+
+ return tracks.end();
+}
+
+nsresult
+JsepSessionImpl::AddTrack(const RefPtr<JsepTrack>& track)
+{
+ mLastError.clear();
+ MOZ_ASSERT(track->GetDirection() == sdp::kSend);
+
+ if (track->GetMediaType() != SdpMediaSection::kApplication) {
+ track->SetCNAME(mCNAME);
+
+ if (track->GetSsrcs().empty()) {
+ uint32_t ssrc;
+ nsresult rv = CreateSsrc(&ssrc);
+ NS_ENSURE_SUCCESS(rv, rv);
+ track->AddSsrc(ssrc);
+ }
+ }
+
+ track->PopulateCodecs(mSupportedCodecs.values);
+
+ JsepSendingTrack strack;
+ strack.mTrack = track;
+
+ mLocalTracks.push_back(strack);
+
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::RemoveTrack(const std::string& streamId,
+ const std::string& trackId)
+{
+ if (mState != kJsepStateStable) {
+ JSEP_SET_ERROR("Removing tracks outside of stable is unsupported.");
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ auto track = FindTrackByIds(mLocalTracks, streamId, trackId);
+
+ if (track == mLocalTracks.end()) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ mLocalTracks.erase(track);
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::SetIceCredentials(const std::string& ufrag,
+ const std::string& pwd)
+{
+ mLastError.clear();
+ mIceUfrag = ufrag;
+ mIcePwd = pwd;
+
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::SetBundlePolicy(JsepBundlePolicy policy)
+{
+ mLastError.clear();
+ if (mCurrentLocalDescription) {
+ JSEP_SET_ERROR("Changing the bundle policy is only supported before the "
+ "first SetLocalDescription.");
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ mBundlePolicy = policy;
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::AddDtlsFingerprint(const std::string& algorithm,
+ const std::vector<uint8_t>& value)
+{
+ mLastError.clear();
+ JsepDtlsFingerprint fp;
+
+ fp.mAlgorithm = algorithm;
+ fp.mValue = value;
+
+ mDtlsFingerprints.push_back(fp);
+
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::AddRtpExtension(std::vector<SdpExtmapAttributeList::Extmap>& extensions,
+ const std::string& extensionName,
+ SdpDirectionAttribute::Direction direction)
+{
+ mLastError.clear();
+
+ if (extensions.size() + 1 > UINT16_MAX) {
+ JSEP_SET_ERROR("Too many rtp extensions have been added");
+ return NS_ERROR_FAILURE;
+ }
+
+ SdpExtmapAttributeList::Extmap extmap =
+ { static_cast<uint16_t>(extensions.size() + 1),
+ direction,
+ direction != SdpDirectionAttribute::kSendrecv, // do we want to specify direction?
+ extensionName,
+ "" };
+
+ extensions.push_back(extmap);
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::AddAudioRtpExtension(const std::string& extensionName,
+ SdpDirectionAttribute::Direction direction)
+{
+ return AddRtpExtension(mAudioRtpExtensions, extensionName, direction);
+}
+
+nsresult
+JsepSessionImpl::AddVideoRtpExtension(const std::string& extensionName,
+ SdpDirectionAttribute::Direction direction)
+{
+ return AddRtpExtension(mVideoRtpExtensions, extensionName, direction);
+}
+
+template<class T>
+std::vector<RefPtr<JsepTrack>>
+GetTracks(const std::vector<T>& wrappedTracks)
+{
+ std::vector<RefPtr<JsepTrack>> result;
+ for (auto i = wrappedTracks.begin(); i != wrappedTracks.end(); ++i) {
+ result.push_back(i->mTrack);
+ }
+ return result;
+}
+
+nsresult
+JsepSessionImpl::ReplaceTrack(const std::string& oldStreamId,
+ const std::string& oldTrackId,
+ const std::string& newStreamId,
+ const std::string& newTrackId)
+{
+ auto it = FindTrackByIds(mLocalTracks, oldStreamId, oldTrackId);
+
+ if (it == mLocalTracks.end()) {
+ JSEP_SET_ERROR("Track " << oldStreamId << "/" << oldTrackId
+ << " was never added.");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ if (FindTrackByIds(mLocalTracks, newStreamId, newTrackId) !=
+ mLocalTracks.end()) {
+ JSEP_SET_ERROR("Track " << newStreamId << "/" << newTrackId
+ << " was already added.");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ it->mTrack->SetStreamId(newStreamId);
+ it->mTrack->SetTrackId(newTrackId);
+
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::SetParameters(const std::string& streamId,
+ const std::string& trackId,
+ const std::vector<JsepTrack::JsConstraints>& constraints)
+{
+ auto it = FindTrackByIds(mLocalTracks, streamId, trackId);
+
+ if (it == mLocalTracks.end()) {
+ JSEP_SET_ERROR("Track " << streamId << "/" << trackId << " was never added.");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ // Add RtpStreamId Extmap
+ // SdpDirectionAttribute::Direction is a bitmask
+ SdpDirectionAttribute::Direction addVideoExt = SdpDirectionAttribute::kInactive;
+ for (auto constraintEntry: constraints) {
+ if (constraintEntry.rid != "") {
+ if (it->mTrack->GetMediaType() == SdpMediaSection::kVideo) {
+ addVideoExt = static_cast<SdpDirectionAttribute::Direction>(addVideoExt
+ | it->mTrack->GetDirection());
+ }
+ }
+ }
+ if (addVideoExt != SdpDirectionAttribute::kInactive) {
+ AddVideoRtpExtension("urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id", addVideoExt);
+ }
+
+ it->mTrack->SetJsConstraints(constraints);
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::GetParameters(const std::string& streamId,
+ const std::string& trackId,
+ std::vector<JsepTrack::JsConstraints>* outConstraints)
+{
+ auto it = FindTrackByIds(mLocalTracks, streamId, trackId);
+
+ if (it == mLocalTracks.end()) {
+ JSEP_SET_ERROR("Track " << streamId << "/" << trackId << " was never added.");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ it->mTrack->GetJsConstraints(outConstraints);
+ return NS_OK;
+}
+
+std::vector<RefPtr<JsepTrack>>
+JsepSessionImpl::GetLocalTracks() const
+{
+ return GetTracks(mLocalTracks);
+}
+
+std::vector<RefPtr<JsepTrack>>
+JsepSessionImpl::GetRemoteTracks() const
+{
+ return GetTracks(mRemoteTracks);
+}
+
+std::vector<RefPtr<JsepTrack>>
+JsepSessionImpl::GetRemoteTracksAdded() const
+{
+ return GetTracks(mRemoteTracksAdded);
+}
+
+std::vector<RefPtr<JsepTrack>>
+JsepSessionImpl::GetRemoteTracksRemoved() const
+{
+ return GetTracks(mRemoteTracksRemoved);
+}
+
+nsresult
+JsepSessionImpl::SetupOfferMSections(const JsepOfferOptions& options, Sdp* sdp)
+{
+ // First audio, then video, then datachannel, for interop
+ // TODO(bug 1121756): We need to group these by stream-id, _then_ by media
+ // type, according to the spec. However, this is not going to interop with
+ // older versions of Firefox if a video-only stream is added before an
+ // audio-only stream.
+ // We should probably wait until 38 is ESR before trying to do this.
+ nsresult rv = SetupOfferMSectionsByType(
+ SdpMediaSection::kAudio, options.mOfferToReceiveAudio, sdp);
+
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = SetupOfferMSectionsByType(
+ SdpMediaSection::kVideo, options.mOfferToReceiveVideo, sdp);
+
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!(options.mDontOfferDataChannel.isSome() &&
+ *options.mDontOfferDataChannel)) {
+ rv = SetupOfferMSectionsByType(
+ SdpMediaSection::kApplication, Maybe<size_t>(), sdp);
+
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ if (!sdp->GetMediaSectionCount()) {
+ JSEP_SET_ERROR("Cannot create an offer with no local tracks, "
+ "no offerToReceiveAudio/Video, and no DataChannel.");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::SetupOfferMSectionsByType(SdpMediaSection::MediaType mediatype,
+ Maybe<size_t> offerToReceiveMaybe,
+ Sdp* sdp)
+{
+ // Convert the Maybe into a size_t*, since that is more readable, especially
+ // when using it as an in/out param.
+ size_t offerToReceiveCount;
+ size_t* offerToReceiveCountPtr = nullptr;
+
+ if (offerToReceiveMaybe) {
+ offerToReceiveCount = *offerToReceiveMaybe;
+ offerToReceiveCountPtr = &offerToReceiveCount;
+ }
+
+ // Make sure every local track has an m-section
+ nsresult rv = BindLocalTracks(mediatype, sdp);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Make sure that m-sections that previously had a remote track have the
+ // recv bit set. Only matters for renegotiation.
+ rv = BindRemoteTracks(mediatype, sdp, offerToReceiveCountPtr);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // If we need more recv sections, start setting the recv bit on other
+ // msections. If not, disable msections that have no tracks.
+ rv = SetRecvAsNeededOrDisable(mediatype,
+ sdp,
+ offerToReceiveCountPtr);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // If we still don't have enough recv m-sections, add some.
+ if (offerToReceiveCountPtr && *offerToReceiveCountPtr) {
+ rv = AddRecvonlyMsections(mediatype, *offerToReceiveCountPtr, sdp);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::BindLocalTracks(SdpMediaSection::MediaType mediatype, Sdp* sdp)
+{
+ for (JsepSendingTrack& track : mLocalTracks) {
+ if (mediatype != track.mTrack->GetMediaType()) {
+ continue;
+ }
+
+ SdpMediaSection* msection;
+ if (track.mAssignedMLine.isSome()) {
+ msection = &sdp->GetMediaSection(*track.mAssignedMLine);
+ } else {
+ nsresult rv = GetFreeMsectionForSend(track.mTrack->GetMediaType(),
+ sdp,
+ &msection);
+ NS_ENSURE_SUCCESS(rv, rv);
+ track.mAssignedMLine = Some(msection->GetLevel());
+ }
+
+ track.mTrack->AddToOffer(msection);
+ }
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::BindRemoteTracks(SdpMediaSection::MediaType mediatype,
+ Sdp* sdp,
+ size_t* offerToReceive)
+{
+ for (JsepReceivingTrack& track : mRemoteTracks) {
+ if (mediatype != track.mTrack->GetMediaType()) {
+ continue;
+ }
+
+ if (!track.mAssignedMLine.isSome()) {
+ MOZ_ASSERT(false);
+ continue;
+ }
+
+ auto& msection = sdp->GetMediaSection(*track.mAssignedMLine);
+
+ if (mSdpHelper.MsectionIsDisabled(msection)) {
+ // TODO(bug 1095226) Content probably disabled this? Should we allow
+ // content to do this?
+ continue;
+ }
+
+ track.mTrack->AddToOffer(&msection);
+
+ if (offerToReceive && *offerToReceive) {
+ --(*offerToReceive);
+ }
+ }
+
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::SetRecvAsNeededOrDisable(SdpMediaSection::MediaType mediatype,
+ Sdp* sdp,
+ size_t* offerToRecv)
+{
+ for (size_t i = 0; i < sdp->GetMediaSectionCount(); ++i) {
+ auto& msection = sdp->GetMediaSection(i);
+
+ if (mSdpHelper.MsectionIsDisabled(msection) ||
+ msection.GetMediaType() != mediatype ||
+ msection.IsReceiving()) {
+ continue;
+ }
+
+ if (offerToRecv) {
+ if (*offerToRecv) {
+ SetupOfferToReceiveMsection(&msection);
+ --(*offerToRecv);
+ continue;
+ }
+ } else if (msection.IsSending()) {
+ SetupOfferToReceiveMsection(&msection);
+ continue;
+ }
+
+ if (!msection.IsSending()) {
+ // Unused m-section, and no reason to offer to recv on it
+ mSdpHelper.DisableMsection(sdp, &msection);
+ }
+ }
+
+ return NS_OK;
+}
+
+void
+JsepSessionImpl::SetupOfferToReceiveMsection(SdpMediaSection* offer)
+{
+ // Create a dummy recv track, and have it add codecs, set direction, etc.
+ RefPtr<JsepTrack> dummy = new JsepTrack(offer->GetMediaType(),
+ "",
+ "",
+ sdp::kRecv);
+ dummy->PopulateCodecs(mSupportedCodecs.values);
+ dummy->AddToOffer(offer);
+}
+
+nsresult
+JsepSessionImpl::AddRecvonlyMsections(SdpMediaSection::MediaType mediatype,
+ size_t count,
+ Sdp* sdp)
+{
+ while (count--) {
+ nsresult rv = CreateOfferMSection(
+ mediatype,
+ mSdpHelper.GetProtocolForMediaType(mediatype),
+ SdpDirectionAttribute::kRecvonly,
+ sdp);
+
+ NS_ENSURE_SUCCESS(rv, rv);
+ SetupOfferToReceiveMsection(
+ &sdp->GetMediaSection(sdp->GetMediaSectionCount() - 1));
+ }
+ return NS_OK;
+}
+
+// This function creates a skeleton SDP based on the old descriptions
+// (ie; all m-sections are inactive).
+nsresult
+JsepSessionImpl::AddReofferMsections(const Sdp& oldLocalSdp,
+ const Sdp& oldAnswer,
+ Sdp* newSdp)
+{
+ nsresult rv;
+
+ for (size_t i = 0; i < oldLocalSdp.GetMediaSectionCount(); ++i) {
+ // We do not set the direction in this function (or disable when previously
+ // disabled), that happens in |SetupOfferMSectionsByType|
+ rv = CreateOfferMSection(oldLocalSdp.GetMediaSection(i).GetMediaType(),
+ oldLocalSdp.GetMediaSection(i).GetProtocol(),
+ SdpDirectionAttribute::kInactive,
+ newSdp);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = mSdpHelper.CopyStickyParams(oldAnswer.GetMediaSection(i),
+ &newSdp->GetMediaSection(i));
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ return NS_OK;
+}
+
+void
+JsepSessionImpl::SetupBundle(Sdp* sdp) const
+{
+ std::vector<std::string> mids;
+ std::set<SdpMediaSection::MediaType> observedTypes;
+
+ // This has the effect of changing the bundle level if the first m-section
+ // goes from disabled to enabled. This is kinda inefficient.
+
+ for (size_t i = 0; i < sdp->GetMediaSectionCount(); ++i) {
+ auto& attrs = sdp->GetMediaSection(i).GetAttributeList();
+ if (attrs.HasAttribute(SdpAttribute::kMidAttribute)) {
+ bool useBundleOnly = false;
+ switch (mBundlePolicy) {
+ case kBundleMaxCompat:
+ // We don't use bundle-only for max-compat
+ break;
+ case kBundleBalanced:
+ // balanced means we use bundle-only on everything but the first
+ // m-section of a given type
+ if (observedTypes.count(sdp->GetMediaSection(i).GetMediaType())) {
+ useBundleOnly = true;
+ }
+ observedTypes.insert(sdp->GetMediaSection(i).GetMediaType());
+ break;
+ case kBundleMaxBundle:
+ // max-bundle means we use bundle-only on everything but the first
+ // m-section
+ useBundleOnly = !mids.empty();
+ break;
+ }
+
+ if (useBundleOnly) {
+ attrs.SetAttribute(
+ new SdpFlagAttribute(SdpAttribute::kBundleOnlyAttribute));
+ }
+
+ mids.push_back(attrs.GetMid());
+ }
+ }
+
+ if (mids.size() > 1) {
+ UniquePtr<SdpGroupAttributeList> groupAttr(new SdpGroupAttributeList);
+ groupAttr->PushEntry(SdpGroupAttributeList::kBundle, mids);
+ sdp->GetAttributeList().SetAttribute(groupAttr.release());
+ }
+}
+
+nsresult
+JsepSessionImpl::GetRemoteIds(const Sdp& sdp,
+ const SdpMediaSection& msection,
+ std::string* streamId,
+ std::string* trackId)
+{
+ nsresult rv = mSdpHelper.GetIdsFromMsid(sdp, msection, streamId, trackId);
+ if (rv == NS_ERROR_NOT_AVAILABLE) {
+ *streamId = mDefaultRemoteStreamId;
+
+ if (!mDefaultRemoteTrackIdsByLevel.count(msection.GetLevel())) {
+ // Generate random track ids.
+ if (!mUuidGen->Generate(trackId)) {
+ JSEP_SET_ERROR("Failed to generate UUID for JsepTrack");
+ return NS_ERROR_FAILURE;
+ }
+
+ mDefaultRemoteTrackIdsByLevel[msection.GetLevel()] = *trackId;
+ } else {
+ *trackId = mDefaultRemoteTrackIdsByLevel[msection.GetLevel()];
+ }
+ return NS_OK;
+ }
+
+ if (NS_SUCCEEDED(rv)) {
+ // If, for whatever reason, the other end renegotiates with an msid where
+ // there wasn't one before, don't allow the old default to pop up again
+ // later.
+ mDefaultRemoteTrackIdsByLevel.erase(msection.GetLevel());
+ }
+
+ return rv;
+}
+
+nsresult
+JsepSessionImpl::CreateOffer(const JsepOfferOptions& options,
+ std::string* offer)
+{
+ mLastError.clear();
+
+ if (mState != kJsepStateStable) {
+ JSEP_SET_ERROR("Cannot create offer in state " << GetStateStr(mState));
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ // Undo track assignments from a previous call to CreateOffer
+ // (ie; if the track has not been negotiated yet, it doesn't necessarily need
+ // to stay in the same m-section that it was in)
+ for (JsepSendingTrack& trackWrapper : mLocalTracks) {
+ if (!trackWrapper.mTrack->GetNegotiatedDetails()) {
+ trackWrapper.mAssignedMLine.reset();
+ }
+ }
+
+ UniquePtr<Sdp> sdp;
+
+ // Make the basic SDP that is common to offer/answer.
+ nsresult rv = CreateGenericSDP(&sdp);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (mCurrentLocalDescription) {
+ rv = AddReofferMsections(*mCurrentLocalDescription,
+ *GetAnswer(),
+ sdp.get());
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ // Ensure that we have all the m-sections we need, and disable extras
+ rv = SetupOfferMSections(options, sdp.get());
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ SetupBundle(sdp.get());
+
+ if (mCurrentLocalDescription) {
+ rv = CopyPreviousTransportParams(*GetAnswer(),
+ *mCurrentLocalDescription,
+ *sdp,
+ sdp.get());
+ NS_ENSURE_SUCCESS(rv,rv);
+ }
+
+ *offer = sdp->ToString();
+ mGeneratedLocalDescription = Move(sdp);
+ ++mSessionVersion;
+
+ return NS_OK;
+}
+
+std::string
+JsepSessionImpl::GetLocalDescription() const
+{
+ std::ostringstream os;
+ mozilla::Sdp* sdp = GetParsedLocalDescription();
+ if (sdp) {
+ sdp->Serialize(os);
+ }
+ return os.str();
+}
+
+std::string
+JsepSessionImpl::GetRemoteDescription() const
+{
+ std::ostringstream os;
+ mozilla::Sdp* sdp = GetParsedRemoteDescription();
+ if (sdp) {
+ sdp->Serialize(os);
+ }
+ return os.str();
+}
+
+void
+JsepSessionImpl::AddExtmap(SdpMediaSection* msection) const
+{
+ const auto* extensions = GetRtpExtensions(msection->GetMediaType());
+
+ if (extensions && !extensions->empty()) {
+ SdpExtmapAttributeList* extmap = new SdpExtmapAttributeList;
+ extmap->mExtmaps = *extensions;
+ msection->GetAttributeList().SetAttribute(extmap);
+ }
+}
+
+void
+JsepSessionImpl::AddMid(const std::string& mid,
+ SdpMediaSection* msection) const
+{
+ msection->GetAttributeList().SetAttribute(new SdpStringAttribute(
+ SdpAttribute::kMidAttribute, mid));
+}
+
+const std::vector<SdpExtmapAttributeList::Extmap>*
+JsepSessionImpl::GetRtpExtensions(SdpMediaSection::MediaType type) const
+{
+ switch (type) {
+ case SdpMediaSection::kAudio:
+ return &mAudioRtpExtensions;
+ case SdpMediaSection::kVideo:
+ return &mVideoRtpExtensions;
+ default:
+ return nullptr;
+ }
+}
+
+void
+JsepSessionImpl::AddCommonExtmaps(const SdpMediaSection& remoteMsection,
+ SdpMediaSection* msection)
+{
+ auto* ourExtensions = GetRtpExtensions(remoteMsection.GetMediaType());
+
+ if (ourExtensions) {
+ mSdpHelper.AddCommonExtmaps(remoteMsection, *ourExtensions, msection);
+ }
+}
+
+nsresult
+JsepSessionImpl::CreateAnswer(const JsepAnswerOptions& options,
+ std::string* answer)
+{
+ mLastError.clear();
+
+ if (mState != kJsepStateHaveRemoteOffer) {
+ JSEP_SET_ERROR("Cannot create answer in state " << GetStateStr(mState));
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ // This is the heart of the negotiation code. Depressing that it's
+ // so bad.
+ //
+ // Here's the current algorithm:
+ // 1. Walk through all the m-lines on the other side.
+ // 2. For each m-line, walk through all of our local tracks
+ // in sequence and see if any are unassigned. If so, assign
+ // them and mark it sendrecv, otherwise it's recvonly.
+ // 3. Just replicate their media attributes.
+ // 4. Profit.
+ UniquePtr<Sdp> sdp;
+
+ // Make the basic SDP that is common to offer/answer.
+ nsresult rv = CreateGenericSDP(&sdp);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ const Sdp& offer = *mPendingRemoteDescription;
+
+ // Copy the bundle groups into our answer
+ UniquePtr<SdpGroupAttributeList> groupAttr(new SdpGroupAttributeList);
+ mSdpHelper.GetBundleGroups(offer, &groupAttr->mGroups);
+ sdp->GetAttributeList().SetAttribute(groupAttr.release());
+
+ // Disable send for local tracks if the offer no longer allows it
+ // (i.e., the m-section is recvonly, inactive or disabled)
+ for (JsepSendingTrack& trackWrapper : mLocalTracks) {
+ if (!trackWrapper.mAssignedMLine.isSome()) {
+ continue;
+ }
+
+ // Get rid of all m-line assignments that have not been negotiated
+ if (!trackWrapper.mTrack->GetNegotiatedDetails()) {
+ trackWrapper.mAssignedMLine.reset();
+ continue;
+ }
+
+ if (!offer.GetMediaSection(*trackWrapper.mAssignedMLine).IsReceiving()) {
+ trackWrapper.mAssignedMLine.reset();
+ }
+ }
+
+ size_t numMsections = offer.GetMediaSectionCount();
+
+ for (size_t i = 0; i < numMsections; ++i) {
+ const SdpMediaSection& remoteMsection = offer.GetMediaSection(i);
+ rv = CreateAnswerMSection(options, i, remoteMsection, sdp.get());
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ if (mCurrentLocalDescription) {
+ // per discussion with bwc, 3rd parm here should be offer, not *sdp. (mjf)
+ rv = CopyPreviousTransportParams(*GetAnswer(),
+ *mCurrentRemoteDescription,
+ offer,
+ sdp.get());
+ NS_ENSURE_SUCCESS(rv,rv);
+ }
+
+ *answer = sdp->ToString();
+ mGeneratedLocalDescription = Move(sdp);
+ ++mSessionVersion;
+
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::CreateOfferMSection(SdpMediaSection::MediaType mediatype,
+ SdpMediaSection::Protocol proto,
+ SdpDirectionAttribute::Direction dir,
+ Sdp* sdp)
+{
+ SdpMediaSection* msection =
+ &sdp->AddMediaSection(mediatype, dir, 0, proto, sdp::kIPv4, "0.0.0.0");
+
+ return EnableOfferMsection(msection);
+}
+
+nsresult
+JsepSessionImpl::GetFreeMsectionForSend(
+ SdpMediaSection::MediaType type,
+ Sdp* sdp,
+ SdpMediaSection** msectionOut)
+{
+ for (size_t i = 0; i < sdp->GetMediaSectionCount(); ++i) {
+ SdpMediaSection& msection = sdp->GetMediaSection(i);
+ // draft-ietf-rtcweb-jsep-08 says we should reclaim disabled m-sections
+ // regardless of media type. This breaks some pretty fundamental rules of
+ // SDP offer/answer, so we probably should not do it.
+ if (msection.GetMediaType() != type) {
+ continue;
+ }
+
+ if (FindTrackByLevel(mLocalTracks, i) != mLocalTracks.end()) {
+ // Not free
+ continue;
+ }
+
+ if (mSdpHelper.MsectionIsDisabled(msection)) {
+ // Was disabled; revive
+ nsresult rv = EnableOfferMsection(&msection);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ *msectionOut = &msection;
+ return NS_OK;
+ }
+
+ // Ok, no pre-existing m-section. Make a new one.
+ nsresult rv = CreateOfferMSection(type,
+ mSdpHelper.GetProtocolForMediaType(type),
+ SdpDirectionAttribute::kInactive,
+ sdp);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ *msectionOut = &sdp->GetMediaSection(sdp->GetMediaSectionCount() - 1);
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::CreateAnswerMSection(const JsepAnswerOptions& options,
+ size_t mlineIndex,
+ const SdpMediaSection& remoteMsection,
+ Sdp* sdp)
+{
+ SdpMediaSection& msection =
+ sdp->AddMediaSection(remoteMsection.GetMediaType(),
+ SdpDirectionAttribute::kInactive,
+ 9,
+ remoteMsection.GetProtocol(),
+ sdp::kIPv4,
+ "0.0.0.0");
+
+ nsresult rv = mSdpHelper.CopyStickyParams(remoteMsection, &msection);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (mSdpHelper.MsectionIsDisabled(remoteMsection)) {
+ mSdpHelper.DisableMsection(sdp, &msection);
+ return NS_OK;
+ }
+
+ SdpSetupAttribute::Role role;
+ rv = DetermineAnswererSetupRole(remoteMsection, &role);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = AddTransportAttributes(&msection, role);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = SetRecvonlySsrc(&msection);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Only attempt to match up local tracks if the offerer has elected to
+ // receive traffic.
+ if (remoteMsection.IsReceiving()) {
+ rv = BindMatchingLocalTrackToAnswer(&msection);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ if (remoteMsection.IsSending()) {
+ BindMatchingRemoteTrackToAnswer(&msection);
+ }
+
+ if (!msection.IsReceiving() && !msection.IsSending()) {
+ mSdpHelper.DisableMsection(sdp, &msection);
+ return NS_OK;
+ }
+
+ // Add extmap attributes.
+ AddCommonExtmaps(remoteMsection, &msection);
+
+ if (msection.GetFormats().empty()) {
+ // Could not negotiate anything. Disable m-section.
+ mSdpHelper.DisableMsection(sdp, &msection);
+ }
+
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::SetRecvonlySsrc(SdpMediaSection* msection)
+{
+ // If previous m-sections are disabled, we do not call this function for them
+ while (mRecvonlySsrcs.size() <= msection->GetLevel()) {
+ uint32_t ssrc;
+ nsresult rv = CreateSsrc(&ssrc);
+ NS_ENSURE_SUCCESS(rv, rv);
+ mRecvonlySsrcs.push_back(ssrc);
+ }
+
+ std::vector<uint32_t> ssrcs;
+ ssrcs.push_back(mRecvonlySsrcs[msection->GetLevel()]);
+ msection->SetSsrcs(ssrcs, mCNAME);
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::BindMatchingLocalTrackToAnswer(SdpMediaSection* msection)
+{
+ auto track = FindTrackByLevel(mLocalTracks, msection->GetLevel());
+
+ if (track == mLocalTracks.end()) {
+ track = FindUnassignedTrackByType(mLocalTracks, msection->GetMediaType());
+ }
+
+ if (track == mLocalTracks.end() &&
+ msection->GetMediaType() == SdpMediaSection::kApplication) {
+ // If we are offered datachannel, we need to play along even if no track
+ // for it has been added yet.
+ std::string streamId;
+ std::string trackId;
+
+ if (!mUuidGen->Generate(&streamId) || !mUuidGen->Generate(&trackId)) {
+ JSEP_SET_ERROR("Failed to generate UUIDs for datachannel track");
+ return NS_ERROR_FAILURE;
+ }
+
+ AddTrack(RefPtr<JsepTrack>(
+ new JsepTrack(SdpMediaSection::kApplication, streamId, trackId)));
+ track = FindUnassignedTrackByType(mLocalTracks, msection->GetMediaType());
+ MOZ_ASSERT(track != mLocalTracks.end());
+ }
+
+ if (track != mLocalTracks.end()) {
+ track->mAssignedMLine = Some(msection->GetLevel());
+ track->mTrack->AddToAnswer(
+ mPendingRemoteDescription->GetMediaSection(msection->GetLevel()),
+ msection);
+ }
+
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::BindMatchingRemoteTrackToAnswer(SdpMediaSection* msection)
+{
+ auto it = FindTrackByLevel(mRemoteTracks, msection->GetLevel());
+ if (it == mRemoteTracks.end()) {
+ MOZ_ASSERT(false);
+ JSEP_SET_ERROR("Failed to find remote track for local answer m-section");
+ return NS_ERROR_FAILURE;
+ }
+
+ it->mTrack->AddToAnswer(
+ mPendingRemoteDescription->GetMediaSection(msection->GetLevel()),
+ msection);
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::DetermineAnswererSetupRole(
+ const SdpMediaSection& remoteMsection,
+ SdpSetupAttribute::Role* rolep)
+{
+ // Determine the role.
+ // RFC 5763 says:
+ //
+ // The endpoint MUST use the setup attribute defined in [RFC4145].
+ // The endpoint that is the offerer MUST use the setup attribute
+ // value of setup:actpass and be prepared to receive a client_hello
+ // before it receives the answer. The answerer MUST use either a
+ // setup attribute value of setup:active or setup:passive. Note that
+ // if the answerer uses setup:passive, then the DTLS handshake will
+ // not begin until the answerer is received, which adds additional
+ // latency. setup:active allows the answer and the DTLS handshake to
+ // occur in parallel. Thus, setup:active is RECOMMENDED. Whichever
+ // party is active MUST initiate a DTLS handshake by sending a
+ // ClientHello over each flow (host/port quartet).
+ //
+ // We default to assuming that the offerer is passive and we are active.
+ SdpSetupAttribute::Role role = SdpSetupAttribute::kActive;
+
+ if (remoteMsection.GetAttributeList().HasAttribute(
+ SdpAttribute::kSetupAttribute)) {
+ switch (remoteMsection.GetAttributeList().GetSetup().mRole) {
+ case SdpSetupAttribute::kActive:
+ role = SdpSetupAttribute::kPassive;
+ break;
+ case SdpSetupAttribute::kPassive:
+ case SdpSetupAttribute::kActpass:
+ role = SdpSetupAttribute::kActive;
+ break;
+ case SdpSetupAttribute::kHoldconn:
+ // This should have been caught by ParseSdp
+ MOZ_ASSERT(false);
+ JSEP_SET_ERROR("The other side used an illegal setup attribute"
+ " (\"holdconn\").");
+ return NS_ERROR_INVALID_ARG;
+ }
+ }
+
+ *rolep = role;
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::SetLocalDescription(JsepSdpType type, const std::string& sdp)
+{
+ mLastError.clear();
+
+ MOZ_MTLOG(ML_DEBUG, "SetLocalDescription type=" << type << "\nSDP=\n"
+ << sdp);
+
+ if (type == kJsepSdpRollback) {
+ if (mState != kJsepStateHaveLocalOffer) {
+ JSEP_SET_ERROR("Cannot rollback local description in "
+ << GetStateStr(mState));
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ mPendingLocalDescription.reset();
+ SetState(kJsepStateStable);
+ mTransports = mOldTransports;
+ mOldTransports.clear();
+ return NS_OK;
+ }
+
+ switch (mState) {
+ case kJsepStateStable:
+ if (type != kJsepSdpOffer) {
+ JSEP_SET_ERROR("Cannot set local answer in state "
+ << GetStateStr(mState));
+ return NS_ERROR_UNEXPECTED;
+ }
+ mIsOfferer = true;
+ break;
+ case kJsepStateHaveRemoteOffer:
+ if (type != kJsepSdpAnswer && type != kJsepSdpPranswer) {
+ JSEP_SET_ERROR("Cannot set local offer in state "
+ << GetStateStr(mState));
+ return NS_ERROR_UNEXPECTED;
+ }
+ break;
+ default:
+ JSEP_SET_ERROR("Cannot set local offer or answer in state "
+ << GetStateStr(mState));
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ UniquePtr<Sdp> parsed;
+ nsresult rv = ParseSdp(sdp, &parsed);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Check that content hasn't done anything unsupported with the SDP
+ rv = ValidateLocalDescription(*parsed);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Create transport objects.
+ mOldTransports = mTransports; // Save in case we need to rollback
+ mTransports.clear();
+ for (size_t t = 0; t < parsed->GetMediaSectionCount(); ++t) {
+ mTransports.push_back(RefPtr<JsepTransport>(new JsepTransport));
+ InitTransport(parsed->GetMediaSection(t), mTransports[t].get());
+ }
+
+ switch (type) {
+ case kJsepSdpOffer:
+ rv = SetLocalDescriptionOffer(Move(parsed));
+ break;
+ case kJsepSdpAnswer:
+ case kJsepSdpPranswer:
+ rv = SetLocalDescriptionAnswer(type, Move(parsed));
+ break;
+ case kJsepSdpRollback:
+ MOZ_CRASH(); // Handled above
+ }
+
+ return rv;
+}
+
+nsresult
+JsepSessionImpl::SetLocalDescriptionOffer(UniquePtr<Sdp> offer)
+{
+ MOZ_ASSERT(mState == kJsepStateStable);
+ mPendingLocalDescription = Move(offer);
+ SetState(kJsepStateHaveLocalOffer);
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::SetLocalDescriptionAnswer(JsepSdpType type,
+ UniquePtr<Sdp> answer)
+{
+ MOZ_ASSERT(mState == kJsepStateHaveRemoteOffer);
+ mPendingLocalDescription = Move(answer);
+
+ nsresult rv = ValidateAnswer(*mPendingRemoteDescription,
+ *mPendingLocalDescription);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = HandleNegotiatedSession(mPendingLocalDescription,
+ mPendingRemoteDescription);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ mCurrentRemoteDescription = Move(mPendingRemoteDescription);
+ mCurrentLocalDescription = Move(mPendingLocalDescription);
+ mWasOffererLastTime = mIsOfferer;
+
+ SetState(kJsepStateStable);
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::SetRemoteDescription(JsepSdpType type, const std::string& sdp)
+{
+ mLastError.clear();
+ mRemoteTracksAdded.clear();
+ mRemoteTracksRemoved.clear();
+
+ MOZ_MTLOG(ML_DEBUG, "SetRemoteDescription type=" << type << "\nSDP=\n"
+ << sdp);
+
+ if (type == kJsepSdpRollback) {
+ if (mState != kJsepStateHaveRemoteOffer) {
+ JSEP_SET_ERROR("Cannot rollback remote description in "
+ << GetStateStr(mState));
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ mPendingRemoteDescription.reset();
+ SetState(kJsepStateStable);
+
+ // Update the remote tracks to what they were before the SetRemote
+ return SetRemoteTracksFromDescription(mCurrentRemoteDescription.get());
+ }
+
+ switch (mState) {
+ case kJsepStateStable:
+ if (type != kJsepSdpOffer) {
+ JSEP_SET_ERROR("Cannot set remote answer in state "
+ << GetStateStr(mState));
+ return NS_ERROR_UNEXPECTED;
+ }
+ mIsOfferer = false;
+ break;
+ case kJsepStateHaveLocalOffer:
+ case kJsepStateHaveRemotePranswer:
+ if (type != kJsepSdpAnswer && type != kJsepSdpPranswer) {
+ JSEP_SET_ERROR("Cannot set remote offer in state "
+ << GetStateStr(mState));
+ return NS_ERROR_UNEXPECTED;
+ }
+ break;
+ default:
+ JSEP_SET_ERROR("Cannot set remote offer or answer in current state "
+ << GetStateStr(mState));
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ // Parse.
+ UniquePtr<Sdp> parsed;
+ nsresult rv = ParseSdp(sdp, &parsed);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = ValidateRemoteDescription(*parsed);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ bool iceLite =
+ parsed->GetAttributeList().HasAttribute(SdpAttribute::kIceLiteAttribute);
+
+ // check for mismatch ufrag/pwd indicating ice restart
+ // can't just check the first one because it might be disabled
+ bool iceRestarting = false;
+ if (mCurrentRemoteDescription.get()) {
+ for (size_t i = 0;
+ !iceRestarting &&
+ i < mCurrentRemoteDescription->GetMediaSectionCount();
+ ++i) {
+
+ const SdpMediaSection& newMsection = parsed->GetMediaSection(i);
+ const SdpMediaSection& oldMsection =
+ mCurrentRemoteDescription->GetMediaSection(i);
+
+ if (mSdpHelper.MsectionIsDisabled(newMsection) ||
+ mSdpHelper.MsectionIsDisabled(oldMsection)) {
+ continue;
+ }
+
+ iceRestarting = mSdpHelper.IceCredentialsDiffer(newMsection, oldMsection);
+ }
+ }
+
+ std::vector<std::string> iceOptions;
+ if (parsed->GetAttributeList().HasAttribute(
+ SdpAttribute::kIceOptionsAttribute)) {
+ iceOptions = parsed->GetAttributeList().GetIceOptions().mValues;
+ }
+
+ switch (type) {
+ case kJsepSdpOffer:
+ rv = SetRemoteDescriptionOffer(Move(parsed));
+ break;
+ case kJsepSdpAnswer:
+ case kJsepSdpPranswer:
+ rv = SetRemoteDescriptionAnswer(type, Move(parsed));
+ break;
+ case kJsepSdpRollback:
+ MOZ_CRASH(); // Handled above
+ }
+
+ if (NS_SUCCEEDED(rv)) {
+ mRemoteIsIceLite = iceLite;
+ mIceOptions = iceOptions;
+ mRemoteIceIsRestarting = iceRestarting;
+ }
+
+ return rv;
+}
+
+nsresult
+JsepSessionImpl::HandleNegotiatedSession(const UniquePtr<Sdp>& local,
+ const UniquePtr<Sdp>& remote)
+{
+ bool remoteIceLite =
+ remote->GetAttributeList().HasAttribute(SdpAttribute::kIceLiteAttribute);
+
+ mIceControlling = remoteIceLite || mIsOfferer;
+
+ const Sdp& answer = mIsOfferer ? *remote : *local;
+
+ SdpHelper::BundledMids bundledMids;
+ nsresult rv = mSdpHelper.GetBundledMids(answer, &bundledMids);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (mTransports.size() < local->GetMediaSectionCount()) {
+ JSEP_SET_ERROR("Fewer transports set up than m-lines");
+ MOZ_ASSERT(false);
+ return NS_ERROR_FAILURE;
+ }
+
+ for (JsepSendingTrack& trackWrapper : mLocalTracks) {
+ trackWrapper.mTrack->ClearNegotiatedDetails();
+ }
+
+ for (JsepReceivingTrack& trackWrapper : mRemoteTracks) {
+ trackWrapper.mTrack->ClearNegotiatedDetails();
+ }
+
+ std::vector<JsepTrackPair> trackPairs;
+
+ // Now walk through the m-sections, make sure they match, and create
+ // track pairs that describe the media to be set up.
+ for (size_t i = 0; i < local->GetMediaSectionCount(); ++i) {
+ // Skip disabled m-sections.
+ if (answer.GetMediaSection(i).GetPort() == 0) {
+ mTransports[i]->Close();
+ continue;
+ }
+
+ // The transport details are not necessarily on the m-section we're
+ // currently processing.
+ size_t transportLevel = i;
+ bool usingBundle = false;
+ {
+ const SdpMediaSection& answerMsection(answer.GetMediaSection(i));
+ if (answerMsection.GetAttributeList().HasAttribute(
+ SdpAttribute::kMidAttribute)) {
+ if (bundledMids.count(answerMsection.GetAttributeList().GetMid())) {
+ const SdpMediaSection* masterBundleMsection =
+ bundledMids[answerMsection.GetAttributeList().GetMid()];
+ transportLevel = masterBundleMsection->GetLevel();
+ usingBundle = true;
+ if (i != transportLevel) {
+ mTransports[i]->Close();
+ }
+ }
+ }
+ }
+
+ RefPtr<JsepTransport> transport = mTransports[transportLevel];
+
+ rv = FinalizeTransport(
+ remote->GetMediaSection(transportLevel).GetAttributeList(),
+ answer.GetMediaSection(transportLevel).GetAttributeList(),
+ transport);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ JsepTrackPair trackPair;
+ rv = MakeNegotiatedTrackPair(remote->GetMediaSection(i),
+ local->GetMediaSection(i),
+ transport,
+ usingBundle,
+ transportLevel,
+ &trackPair);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ trackPairs.push_back(trackPair);
+ }
+
+ JsepTrack::SetUniquePayloadTypes(GetTracks(mRemoteTracks));
+
+ // Ouch, this probably needs some dirty bit instead of just clearing
+ // stuff for renegotiation.
+ mNegotiatedTrackPairs = trackPairs;
+
+ mGeneratedLocalDescription.reset();
+
+ mNegotiations++;
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::MakeNegotiatedTrackPair(const SdpMediaSection& remote,
+ const SdpMediaSection& local,
+ const RefPtr<JsepTransport>& transport,
+ bool usingBundle,
+ size_t transportLevel,
+ JsepTrackPair* trackPairOut)
+{
+ MOZ_ASSERT(transport->mComponents);
+ const SdpMediaSection& answer = mIsOfferer ? remote : local;
+
+ bool sending;
+ bool receiving;
+
+ if (mIsOfferer) {
+ receiving = answer.IsSending();
+ sending = answer.IsReceiving();
+ } else {
+ sending = answer.IsSending();
+ receiving = answer.IsReceiving();
+ }
+
+ MOZ_MTLOG(ML_DEBUG, "Negotiated m= line"
+ << " index=" << local.GetLevel()
+ << " type=" << local.GetMediaType()
+ << " sending=" << sending
+ << " receiving=" << receiving);
+
+ trackPairOut->mLevel = local.GetLevel();
+
+ MOZ_ASSERT(mRecvonlySsrcs.size() > local.GetLevel(),
+ "Failed to set the default ssrc for an active m-section");
+ trackPairOut->mRecvonlySsrc = mRecvonlySsrcs[local.GetLevel()];
+
+ if (usingBundle) {
+ trackPairOut->mBundleLevel = Some(transportLevel);
+ }
+
+ auto sendTrack = FindTrackByLevel(mLocalTracks, local.GetLevel());
+ if (sendTrack != mLocalTracks.end()) {
+ sendTrack->mTrack->Negotiate(answer, remote);
+ sendTrack->mTrack->SetActive(sending);
+ trackPairOut->mSending = sendTrack->mTrack;
+ } else if (sending) {
+ JSEP_SET_ERROR("Failed to find local track for level " <<
+ local.GetLevel()
+ << " in local SDP. This should never happen.");
+ NS_ASSERTION(false, "Failed to find local track for level");
+ return NS_ERROR_FAILURE;
+ }
+
+ auto recvTrack = FindTrackByLevel(mRemoteTracks, local.GetLevel());
+ if (recvTrack != mRemoteTracks.end()) {
+ recvTrack->mTrack->Negotiate(answer, remote);
+ recvTrack->mTrack->SetActive(receiving);
+ trackPairOut->mReceiving = recvTrack->mTrack;
+
+ if (receiving &&
+ trackPairOut->mBundleLevel.isSome() &&
+ recvTrack->mTrack->GetSsrcs().empty() &&
+ recvTrack->mTrack->GetMediaType() != SdpMediaSection::kApplication) {
+ MOZ_MTLOG(ML_ERROR, "Bundled m-section has no ssrc attributes. "
+ "This may cause media packets to be dropped.");
+ }
+ } else if (receiving) {
+ JSEP_SET_ERROR("Failed to find remote track for level "
+ << local.GetLevel()
+ << " in remote SDP. This should never happen.");
+ NS_ASSERTION(false, "Failed to find remote track for level");
+ return NS_ERROR_FAILURE;
+ }
+
+ trackPairOut->mRtpTransport = transport;
+
+ if (transport->mComponents == 2) {
+ // RTCP MUX or not.
+ // TODO(bug 1095743): verify that the PTs are consistent with mux.
+ MOZ_MTLOG(ML_DEBUG, "RTCP-MUX is off");
+ trackPairOut->mRtcpTransport = transport;
+ }
+
+ return NS_OK;
+}
+
+void
+JsepSessionImpl::InitTransport(const SdpMediaSection& msection,
+ JsepTransport* transport)
+{
+ if (mSdpHelper.MsectionIsDisabled(msection)) {
+ transport->Close();
+ return;
+ }
+
+ if (mSdpHelper.HasRtcp(msection.GetProtocol())) {
+ transport->mComponents = 2;
+ } else {
+ transport->mComponents = 1;
+ }
+
+ if (msection.GetAttributeList().HasAttribute(SdpAttribute::kMidAttribute)) {
+ transport->mTransportId = msection.GetAttributeList().GetMid();
+ } else {
+ std::ostringstream os;
+ os << "level_" << msection.GetLevel() << "(no mid)";
+ transport->mTransportId = os.str();
+ }
+}
+
+nsresult
+JsepSessionImpl::FinalizeTransport(const SdpAttributeList& remote,
+ const SdpAttributeList& answer,
+ const RefPtr<JsepTransport>& transport)
+{
+ UniquePtr<JsepIceTransport> ice = MakeUnique<JsepIceTransport>();
+
+ // We do sanity-checking for these in ParseSdp
+ ice->mUfrag = remote.GetIceUfrag();
+ ice->mPwd = remote.GetIcePwd();
+ if (remote.HasAttribute(SdpAttribute::kCandidateAttribute)) {
+ ice->mCandidates = remote.GetCandidate();
+ }
+
+ // RFC 5763 says:
+ //
+ // The endpoint MUST use the setup attribute defined in [RFC4145].
+ // The endpoint that is the offerer MUST use the setup attribute
+ // value of setup:actpass and be prepared to receive a client_hello
+ // before it receives the answer. The answerer MUST use either a
+ // setup attribute value of setup:active or setup:passive. Note that
+ // if the answerer uses setup:passive, then the DTLS handshake will
+ // not begin until the answerer is received, which adds additional
+ // latency. setup:active allows the answer and the DTLS handshake to
+ // occur in parallel. Thus, setup:active is RECOMMENDED. Whichever
+ // party is active MUST initiate a DTLS handshake by sending a
+ // ClientHello over each flow (host/port quartet).
+ UniquePtr<JsepDtlsTransport> dtls = MakeUnique<JsepDtlsTransport>();
+ dtls->mFingerprints = remote.GetFingerprint();
+ if (!answer.HasAttribute(mozilla::SdpAttribute::kSetupAttribute)) {
+ dtls->mRole = mIsOfferer ? JsepDtlsTransport::kJsepDtlsServer
+ : JsepDtlsTransport::kJsepDtlsClient;
+ } else {
+ if (mIsOfferer) {
+ dtls->mRole = (answer.GetSetup().mRole == SdpSetupAttribute::kActive)
+ ? JsepDtlsTransport::kJsepDtlsServer
+ : JsepDtlsTransport::kJsepDtlsClient;
+ } else {
+ dtls->mRole = (answer.GetSetup().mRole == SdpSetupAttribute::kActive)
+ ? JsepDtlsTransport::kJsepDtlsClient
+ : JsepDtlsTransport::kJsepDtlsServer;
+ }
+ }
+
+ transport->mIce = Move(ice);
+ transport->mDtls = Move(dtls);
+
+ if (answer.HasAttribute(SdpAttribute::kRtcpMuxAttribute)) {
+ transport->mComponents = 1;
+ }
+
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::AddTransportAttributes(SdpMediaSection* msection,
+ SdpSetupAttribute::Role dtlsRole)
+{
+ if (mIceUfrag.empty() || mIcePwd.empty()) {
+ JSEP_SET_ERROR("Missing ICE ufrag or password");
+ return NS_ERROR_FAILURE;
+ }
+
+ SdpAttributeList& attrList = msection->GetAttributeList();
+ attrList.SetAttribute(
+ new SdpStringAttribute(SdpAttribute::kIceUfragAttribute, mIceUfrag));
+ attrList.SetAttribute(
+ new SdpStringAttribute(SdpAttribute::kIcePwdAttribute, mIcePwd));
+
+ msection->GetAttributeList().SetAttribute(new SdpSetupAttribute(dtlsRole));
+
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::CopyPreviousTransportParams(const Sdp& oldAnswer,
+ const Sdp& offerersPreviousSdp,
+ const Sdp& newOffer,
+ Sdp* newLocal)
+{
+ for (size_t i = 0; i < oldAnswer.GetMediaSectionCount(); ++i) {
+ if (!mSdpHelper.MsectionIsDisabled(newLocal->GetMediaSection(i)) &&
+ mSdpHelper.AreOldTransportParamsValid(oldAnswer,
+ offerersPreviousSdp,
+ newOffer,
+ i) &&
+ !mRemoteIceIsRestarting
+ ) {
+ // If newLocal is an offer, this will be the number of components we used
+ // last time, and if it is an answer, this will be the number of
+ // components we've decided we're using now.
+ size_t numComponents = mTransports[i]->mComponents;
+ nsresult rv = mSdpHelper.CopyTransportParams(
+ numComponents,
+ mCurrentLocalDescription->GetMediaSection(i),
+ &newLocal->GetMediaSection(i));
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ }
+
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::ParseSdp(const std::string& sdp, UniquePtr<Sdp>* parsedp)
+{
+ UniquePtr<Sdp> parsed = mParser.Parse(sdp);
+ if (!parsed) {
+ std::string error = "Failed to parse SDP: ";
+ mSdpHelper.appendSdpParseErrors(mParser.GetParseErrors(), &error);
+ JSEP_SET_ERROR(error);
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ // Verify that the JSEP rules for all SDP are followed
+ if (!parsed->GetMediaSectionCount()) {
+ JSEP_SET_ERROR("Description has no media sections");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ std::set<std::string> trackIds;
+
+ for (size_t i = 0; i < parsed->GetMediaSectionCount(); ++i) {
+ if (mSdpHelper.MsectionIsDisabled(parsed->GetMediaSection(i))) {
+ // Disabled, let this stuff slide.
+ continue;
+ }
+
+ const SdpMediaSection& msection(parsed->GetMediaSection(i));
+ auto& mediaAttrs = msection.GetAttributeList();
+
+ if (mediaAttrs.GetIceUfrag().empty()) {
+ JSEP_SET_ERROR("Invalid description, no ice-ufrag attribute");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ if (mediaAttrs.GetIcePwd().empty()) {
+ JSEP_SET_ERROR("Invalid description, no ice-pwd attribute");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ if (!mediaAttrs.HasAttribute(SdpAttribute::kFingerprintAttribute)) {
+ JSEP_SET_ERROR("Invalid description, no fingerprint attribute");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ const SdpFingerprintAttributeList& fingerprints(
+ mediaAttrs.GetFingerprint());
+ if (fingerprints.mFingerprints.empty()) {
+ JSEP_SET_ERROR("Invalid description, no supported fingerprint algorithms "
+ "present");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ if (mediaAttrs.HasAttribute(SdpAttribute::kSetupAttribute) &&
+ mediaAttrs.GetSetup().mRole == SdpSetupAttribute::kHoldconn) {
+ JSEP_SET_ERROR("Description has illegal setup attribute "
+ "\"holdconn\" at level "
+ << i);
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ auto& formats = parsed->GetMediaSection(i).GetFormats();
+ for (auto f = formats.begin(); f != formats.end(); ++f) {
+ uint16_t pt;
+ if (!SdpHelper::GetPtAsInt(*f, &pt)) {
+ JSEP_SET_ERROR("Payload type \""
+ << *f << "\" is not a 16-bit unsigned int at level "
+ << i);
+ return NS_ERROR_INVALID_ARG;
+ }
+ }
+
+ std::string streamId;
+ std::string trackId;
+ nsresult rv = mSdpHelper.GetIdsFromMsid(*parsed,
+ parsed->GetMediaSection(i),
+ &streamId,
+ &trackId);
+
+ if (NS_SUCCEEDED(rv)) {
+ if (trackIds.count(trackId)) {
+ JSEP_SET_ERROR("track id:" << trackId
+ << " appears in more than one m-section at level " << i);
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ trackIds.insert(trackId);
+ } else if (rv != NS_ERROR_NOT_AVAILABLE) {
+ // Error has already been set
+ return rv;
+ }
+
+ static const std::bitset<128> forbidden = GetForbiddenSdpPayloadTypes();
+ if (msection.GetMediaType() == SdpMediaSection::kAudio ||
+ msection.GetMediaType() == SdpMediaSection::kVideo) {
+ // Sanity-check that payload type can work with RTP
+ for (const std::string& fmt : msection.GetFormats()) {
+ uint16_t payloadType;
+ // TODO (bug 1204099): Make this check for reserved ranges.
+ if (!SdpHelper::GetPtAsInt(fmt, &payloadType) || payloadType > 127) {
+ JSEP_SET_ERROR("audio/video payload type is too large: " << fmt);
+ return NS_ERROR_INVALID_ARG;
+ }
+ if (forbidden.test(payloadType)) {
+ JSEP_SET_ERROR("Illegal audio/video payload type: " << fmt);
+ return NS_ERROR_INVALID_ARG;
+ }
+ }
+ }
+ }
+
+ *parsedp = Move(parsed);
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::SetRemoteDescriptionOffer(UniquePtr<Sdp> offer)
+{
+ MOZ_ASSERT(mState == kJsepStateStable);
+
+ // TODO(bug 1095780): Note that we create remote tracks even when
+ // They contain only codecs we can't negotiate or other craziness.
+ nsresult rv = SetRemoteTracksFromDescription(offer.get());
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ mPendingRemoteDescription = Move(offer);
+
+ SetState(kJsepStateHaveRemoteOffer);
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::SetRemoteDescriptionAnswer(JsepSdpType type,
+ UniquePtr<Sdp> answer)
+{
+ MOZ_ASSERT(mState == kJsepStateHaveLocalOffer ||
+ mState == kJsepStateHaveRemotePranswer);
+
+ mPendingRemoteDescription = Move(answer);
+
+ nsresult rv = ValidateAnswer(*mPendingLocalDescription,
+ *mPendingRemoteDescription);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // TODO(bug 1095780): Note that this creates remote tracks even if
+ // we offered sendonly and other side offered sendrecv or recvonly.
+ rv = SetRemoteTracksFromDescription(mPendingRemoteDescription.get());
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = HandleNegotiatedSession(mPendingLocalDescription,
+ mPendingRemoteDescription);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ mCurrentRemoteDescription = Move(mPendingRemoteDescription);
+ mCurrentLocalDescription = Move(mPendingLocalDescription);
+ mWasOffererLastTime = mIsOfferer;
+
+ SetState(kJsepStateStable);
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::SetRemoteTracksFromDescription(const Sdp* remoteDescription)
+{
+ // Unassign all remote tracks
+ for (auto i = mRemoteTracks.begin(); i != mRemoteTracks.end(); ++i) {
+ i->mAssignedMLine.reset();
+ }
+
+ // This will not exist if we're rolling back the first remote description
+ if (remoteDescription) {
+ size_t numMlines = remoteDescription->GetMediaSectionCount();
+ nsresult rv;
+
+ // Iterate over the sdp, re-assigning or creating remote tracks as we go
+ for (size_t i = 0; i < numMlines; ++i) {
+ const SdpMediaSection& msection = remoteDescription->GetMediaSection(i);
+
+ if (mSdpHelper.MsectionIsDisabled(msection) || !msection.IsSending()) {
+ continue;
+ }
+
+ std::vector<JsepReceivingTrack>::iterator track;
+
+ if (msection.GetMediaType() == SdpMediaSection::kApplication) {
+ // Datachannel doesn't have msid, just search by type
+ track = FindUnassignedTrackByType(mRemoteTracks,
+ msection.GetMediaType());
+ } else {
+ std::string streamId;
+ std::string trackId;
+ rv = GetRemoteIds(*remoteDescription, msection, &streamId, &trackId);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ track = FindTrackByIds(mRemoteTracks, streamId, trackId);
+ }
+
+ if (track == mRemoteTracks.end()) {
+ RefPtr<JsepTrack> track;
+ rv = CreateReceivingTrack(i, *remoteDescription, msection, &track);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ JsepReceivingTrack rtrack;
+ rtrack.mTrack = track;
+ rtrack.mAssignedMLine = Some(i);
+ mRemoteTracks.push_back(rtrack);
+ mRemoteTracksAdded.push_back(rtrack);
+ } else {
+ track->mAssignedMLine = Some(i);
+ }
+ }
+ }
+
+ // Remove any unassigned remote track ids
+ for (size_t i = 0; i < mRemoteTracks.size();) {
+ if (!mRemoteTracks[i].mAssignedMLine.isSome()) {
+ mRemoteTracksRemoved.push_back(mRemoteTracks[i]);
+ mRemoteTracks.erase(mRemoteTracks.begin() + i);
+ } else {
+ ++i;
+ }
+ }
+
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::ValidateLocalDescription(const Sdp& description)
+{
+ // TODO(bug 1095226): Better checking.
+ if (!mGeneratedLocalDescription) {
+ JSEP_SET_ERROR("Calling SetLocal without first calling CreateOffer/Answer"
+ " is not supported.");
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ if (description.GetMediaSectionCount() !=
+ mGeneratedLocalDescription->GetMediaSectionCount()) {
+ JSEP_SET_ERROR("Changing the number of m-sections is not allowed");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ for (size_t i = 0; i < description.GetMediaSectionCount(); ++i) {
+ auto& origMsection = mGeneratedLocalDescription->GetMediaSection(i);
+ auto& finalMsection = description.GetMediaSection(i);
+ if (origMsection.GetMediaType() != finalMsection.GetMediaType()) {
+ JSEP_SET_ERROR("Changing the media-type of m-sections is not allowed");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ // These will be present in reoffer
+ if (!mCurrentLocalDescription) {
+ if (finalMsection.GetAttributeList().HasAttribute(
+ SdpAttribute::kCandidateAttribute)) {
+ JSEP_SET_ERROR("Adding your own candidate attributes is not supported");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ if (finalMsection.GetAttributeList().HasAttribute(
+ SdpAttribute::kEndOfCandidatesAttribute)) {
+ JSEP_SET_ERROR("Why are you trying to set a=end-of-candidates?");
+ return NS_ERROR_INVALID_ARG;
+ }
+ }
+
+ // TODO(bug 1095218): Check msid
+ // TODO(bug 1095226): Check ice-ufrag and ice-pwd
+ // TODO(bug 1095226): Check fingerprints
+ // TODO(bug 1095226): Check payload types (at least ensure that payload
+ // types we don't actually support weren't added)
+ // TODO(bug 1095226): Check ice-options?
+ }
+
+ if (description.GetAttributeList().HasAttribute(
+ SdpAttribute::kIceLiteAttribute)) {
+ JSEP_SET_ERROR("Running ICE in lite mode is unsupported");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::ValidateRemoteDescription(const Sdp& description)
+{
+ if (!mCurrentRemoteDescription || !mCurrentLocalDescription) {
+ // Not renegotiation; checks for whether a remote answer are consistent
+ // with our offer are handled in ValidateAnswer()
+ return NS_OK;
+ }
+
+ if (mCurrentRemoteDescription->GetMediaSectionCount() >
+ description.GetMediaSectionCount()) {
+ JSEP_SET_ERROR("New remote description has fewer m-sections than the "
+ "previous remote description.");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ // These are solely to check that bundle is valid
+ SdpHelper::BundledMids bundledMids;
+ nsresult rv = GetNegotiatedBundledMids(&bundledMids);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ SdpHelper::BundledMids newBundledMids;
+ rv = mSdpHelper.GetBundledMids(description, &newBundledMids);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // check for partial ice restart, which is not supported
+ Maybe<bool> iceCredsDiffer;
+ for (size_t i = 0;
+ i < mCurrentRemoteDescription->GetMediaSectionCount();
+ ++i) {
+
+ const SdpMediaSection& newMsection = description.GetMediaSection(i);
+ const SdpMediaSection& oldMsection =
+ mCurrentRemoteDescription->GetMediaSection(i);
+
+ if (mSdpHelper.MsectionIsDisabled(newMsection) ||
+ mSdpHelper.MsectionIsDisabled(oldMsection)) {
+ continue;
+ }
+
+ if (oldMsection.GetMediaType() != newMsection.GetMediaType()) {
+ JSEP_SET_ERROR("Remote description changes the media type of m-line "
+ << i);
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ bool differ = mSdpHelper.IceCredentialsDiffer(newMsection, oldMsection);
+ // Detect whether all the creds are the same or all are different
+ if (!iceCredsDiffer.isSome()) {
+ // for the first msection capture whether creds are different or same
+ iceCredsDiffer = mozilla::Some(differ);
+ } else if (iceCredsDiffer.isSome() && *iceCredsDiffer != differ) {
+ // subsequent msections must match the first sections
+ JSEP_SET_ERROR("Partial ICE restart is unsupported at this time "
+ "(new remote description changes either the ice-ufrag "
+ "or ice-pwd on fewer than all msections)");
+ return NS_ERROR_INVALID_ARG;
+ }
+ }
+
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::ValidateAnswer(const Sdp& offer, const Sdp& answer)
+{
+ if (offer.GetMediaSectionCount() != answer.GetMediaSectionCount()) {
+ JSEP_SET_ERROR("Offer and answer have different number of m-lines "
+ << "(" << offer.GetMediaSectionCount() << " vs "
+ << answer.GetMediaSectionCount() << ")");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ for (size_t i = 0; i < offer.GetMediaSectionCount(); ++i) {
+ const SdpMediaSection& offerMsection = offer.GetMediaSection(i);
+ const SdpMediaSection& answerMsection = answer.GetMediaSection(i);
+
+ if (offerMsection.GetMediaType() != answerMsection.GetMediaType()) {
+ JSEP_SET_ERROR(
+ "Answer and offer have different media types at m-line " << i);
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ if (!offerMsection.IsSending() && answerMsection.IsReceiving()) {
+ JSEP_SET_ERROR("Answer tried to set recv when offer did not set send");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ if (!offerMsection.IsReceiving() && answerMsection.IsSending()) {
+ JSEP_SET_ERROR("Answer tried to set send when offer did not set recv");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ const SdpAttributeList& answerAttrs(answerMsection.GetAttributeList());
+ const SdpAttributeList& offerAttrs(offerMsection.GetAttributeList());
+ if (answerAttrs.HasAttribute(SdpAttribute::kMidAttribute) &&
+ offerAttrs.HasAttribute(SdpAttribute::kMidAttribute) &&
+ offerAttrs.GetMid() != answerAttrs.GetMid()) {
+ JSEP_SET_ERROR("Answer changes mid for level, was \'"
+ << offerMsection.GetAttributeList().GetMid()
+ << "\', now \'"
+ << answerMsection.GetAttributeList().GetMid() << "\'");
+ return NS_ERROR_INVALID_ARG;
+ }
+ }
+
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::CreateReceivingTrack(size_t mline,
+ const Sdp& sdp,
+ const SdpMediaSection& msection,
+ RefPtr<JsepTrack>* track)
+{
+ std::string streamId;
+ std::string trackId;
+
+ nsresult rv = GetRemoteIds(sdp, msection, &streamId, &trackId);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ *track = new JsepTrack(msection.GetMediaType(),
+ streamId,
+ trackId,
+ sdp::kRecv);
+
+ (*track)->SetCNAME(mSdpHelper.GetCNAME(msection));
+ (*track)->PopulateCodecs(mSupportedCodecs.values);
+
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::CreateGenericSDP(UniquePtr<Sdp>* sdpp)
+{
+ // draft-ietf-rtcweb-jsep-08 Section 5.2.1:
+ // o The second SDP line MUST be an "o=" line, as specified in
+ // [RFC4566], Section 5.2. The value of the <username> field SHOULD
+ // be "-". The value of the <sess-id> field SHOULD be a
+ // cryptographically random number. To ensure uniqueness, this
+ // number SHOULD be at least 64 bits long. The value of the <sess-
+ // version> field SHOULD be zero. The value of the <nettype>
+ // <addrtype> <unicast-address> tuple SHOULD be set to a non-
+ // meaningful address, such as IN IP4 0.0.0.0, to prevent leaking the
+ // local address in this field. As mentioned in [RFC4566], the
+ // entire o= line needs to be unique, but selecting a random number
+ // for <sess-id> is sufficient to accomplish this.
+
+ auto origin =
+ SdpOrigin("mozilla...THIS_IS_SDPARTA-" MOZ_APP_UA_VERSION,
+ mSessionId,
+ mSessionVersion,
+ sdp::kIPv4,
+ "0.0.0.0");
+
+ UniquePtr<Sdp> sdp = MakeUnique<SipccSdp>(origin);
+
+ if (mDtlsFingerprints.empty()) {
+ JSEP_SET_ERROR("Missing DTLS fingerprint");
+ return NS_ERROR_FAILURE;
+ }
+
+ UniquePtr<SdpFingerprintAttributeList> fpl =
+ MakeUnique<SdpFingerprintAttributeList>();
+ for (auto fp = mDtlsFingerprints.begin(); fp != mDtlsFingerprints.end();
+ ++fp) {
+ fpl->PushEntry(fp->mAlgorithm, fp->mValue);
+ }
+ sdp->GetAttributeList().SetAttribute(fpl.release());
+
+ auto* iceOpts = new SdpOptionsAttribute(SdpAttribute::kIceOptionsAttribute);
+ iceOpts->PushEntry("trickle");
+ sdp->GetAttributeList().SetAttribute(iceOpts);
+
+ // This assumes content doesn't add a bunch of msid attributes with a
+ // different semantic in mind.
+ std::vector<std::string> msids;
+ msids.push_back("*");
+ mSdpHelper.SetupMsidSemantic(msids, sdp.get());
+
+ *sdpp = Move(sdp);
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::SetupIds()
+{
+ SECStatus rv = PK11_GenerateRandom(
+ reinterpret_cast<unsigned char*>(&mSessionId), sizeof(mSessionId));
+ // RFC 3264 says that session-ids MUST be representable as a _signed_
+ // 64 bit number, meaning the MSB cannot be set.
+ mSessionId = mSessionId >> 1;
+ if (rv != SECSuccess) {
+ JSEP_SET_ERROR("Failed to generate session id: " << rv);
+ return NS_ERROR_FAILURE;
+ }
+
+ if (!mUuidGen->Generate(&mDefaultRemoteStreamId)) {
+ JSEP_SET_ERROR("Failed to generate default uuid for streams");
+ return NS_ERROR_FAILURE;
+ }
+
+ if (!mUuidGen->Generate(&mCNAME)) {
+ JSEP_SET_ERROR("Failed to generate CNAME");
+ return NS_ERROR_FAILURE;
+ }
+
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::CreateSsrc(uint32_t* ssrc)
+{
+ do {
+ SECStatus rv = PK11_GenerateRandom(
+ reinterpret_cast<unsigned char*>(ssrc), sizeof(uint32_t));
+ if (rv != SECSuccess) {
+ JSEP_SET_ERROR("Failed to generate SSRC, error=" << rv);
+ return NS_ERROR_FAILURE;
+ }
+ } while (mSsrcs.count(*ssrc));
+ mSsrcs.insert(*ssrc);
+
+ return NS_OK;
+}
+
+void
+JsepSessionImpl::SetupDefaultCodecs()
+{
+ // Supported audio codecs.
+ // Per jmspeex on IRC:
+ // For 32KHz sampling, 28 is ok, 32 is good, 40 should be really good
+ // quality. Note that 1-2Kbps will be wasted on a stereo Opus channel
+ // with mono input compared to configuring it for mono.
+ // If we reduce bitrate enough Opus will low-pass us; 16000 will kill a
+ // 9KHz tone. This should be adaptive when we're at the low-end of video
+ // bandwidth (say <100Kbps), and if we're audio-only, down to 8 or
+ // 12Kbps.
+ mSupportedCodecs.values.push_back(new JsepAudioCodecDescription(
+ "109",
+ "opus",
+ 48000,
+ 2,
+ 960,
+#ifdef WEBRTC_GONK
+ // TODO Move this elsewhere to be adaptive to rate - Bug 1207925
+ 16000 // B2G uses lower capture sampling rate
+#else
+ 40000
+#endif
+ ));
+
+ mSupportedCodecs.values.push_back(new JsepAudioCodecDescription(
+ "9",
+ "G722",
+ 8000,
+ 1,
+ 320,
+ 64000));
+
+ // packet size and bitrate values below copied from sipcc.
+ // May need reevaluation from a media expert.
+ mSupportedCodecs.values.push_back(
+ new JsepAudioCodecDescription("0",
+ "PCMU",
+ 8000,
+ 1,
+ 8000 / 50, // frequency / 50
+ 8 * 8000 * 1 // 8 * frequency * channels
+ ));
+
+ mSupportedCodecs.values.push_back(
+ new JsepAudioCodecDescription("8",
+ "PCMA",
+ 8000,
+ 1,
+ 8000 / 50, // frequency / 50
+ 8 * 8000 * 1 // 8 * frequency * channels
+ ));
+
+ // note: because telephone-event is effectively a marker codec that indicates
+ // that dtmf rtp packets may be passed, the packetSize and bitRate fields
+ // don't make sense here. For now, use zero. (mjf)
+ mSupportedCodecs.values.push_back(
+ new JsepAudioCodecDescription("101",
+ "telephone-event",
+ 8000,
+ 1,
+ 0, // packetSize doesn't make sense here
+ 0 // bitRate doesn't make sense here
+ ));
+
+ // Supported video codecs.
+ // Note: order here implies priority for building offers!
+ JsepVideoCodecDescription* vp8 = new JsepVideoCodecDescription(
+ "120",
+ "VP8",
+ 90000
+ );
+ // Defaults for mandatory params
+ vp8->mConstraints.maxFs = 12288; // Enough for 2048x1536
+ vp8->mConstraints.maxFps = 60;
+ mSupportedCodecs.values.push_back(vp8);
+
+ JsepVideoCodecDescription* vp9 = new JsepVideoCodecDescription(
+ "121",
+ "VP9",
+ 90000
+ );
+ // Defaults for mandatory params
+ vp9->mConstraints.maxFs = 12288; // Enough for 2048x1536
+ vp9->mConstraints.maxFps = 60;
+ mSupportedCodecs.values.push_back(vp9);
+
+ JsepVideoCodecDescription* h264_1 = new JsepVideoCodecDescription(
+ "126",
+ "H264",
+ 90000
+ );
+ h264_1->mPacketizationMode = 1;
+ // Defaults for mandatory params
+ h264_1->mProfileLevelId = 0x42E00D;
+ mSupportedCodecs.values.push_back(h264_1);
+
+ JsepVideoCodecDescription* h264_0 = new JsepVideoCodecDescription(
+ "97",
+ "H264",
+ 90000
+ );
+ h264_0->mPacketizationMode = 0;
+ // Defaults for mandatory params
+ h264_0->mProfileLevelId = 0x42E00D;
+ mSupportedCodecs.values.push_back(h264_0);
+
+ JsepVideoCodecDescription* red = new JsepVideoCodecDescription(
+ "122", // payload type
+ "red", // codec name
+ 90000 // clock rate (match other video codecs)
+ );
+ mSupportedCodecs.values.push_back(red);
+
+ JsepVideoCodecDescription* ulpfec = new JsepVideoCodecDescription(
+ "123", // payload type
+ "ulpfec", // codec name
+ 90000 // clock rate (match other video codecs)
+ );
+ mSupportedCodecs.values.push_back(ulpfec);
+
+ mSupportedCodecs.values.push_back(new JsepApplicationCodecDescription(
+ "5000",
+ "webrtc-datachannel",
+ WEBRTC_DATACHANNEL_STREAMS_DEFAULT
+ ));
+
+ // Update the redundant encodings for the RED codec with the supported
+ // codecs. Note: only uses the video codecs.
+ red->UpdateRedundantEncodings(mSupportedCodecs.values);
+}
+
+void
+JsepSessionImpl::SetupDefaultRtpExtensions()
+{
+ AddAudioRtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level",
+ SdpDirectionAttribute::Direction::kSendonly);
+}
+
+void
+JsepSessionImpl::SetState(JsepSignalingState state)
+{
+ if (state == mState)
+ return;
+
+ MOZ_MTLOG(ML_NOTICE, "[" << mName << "]: " <<
+ GetStateStr(mState) << " -> " << GetStateStr(state));
+ mState = state;
+}
+
+nsresult
+JsepSessionImpl::AddRemoteIceCandidate(const std::string& candidate,
+ const std::string& mid,
+ uint16_t level)
+{
+ mLastError.clear();
+
+ mozilla::Sdp* sdp = GetParsedRemoteDescription();
+
+ if (!sdp) {
+ JSEP_SET_ERROR("Cannot add ICE candidate in state " << GetStateStr(mState));
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ return mSdpHelper.AddCandidateToSdp(sdp, candidate, mid, level);
+}
+
+nsresult
+JsepSessionImpl::AddLocalIceCandidate(const std::string& candidate,
+ uint16_t level,
+ std::string* mid,
+ bool* skipped)
+{
+ mLastError.clear();
+
+ mozilla::Sdp* sdp = GetParsedLocalDescription();
+
+ if (!sdp) {
+ JSEP_SET_ERROR("Cannot add ICE candidate in state " << GetStateStr(mState));
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ if (sdp->GetMediaSectionCount() <= level) {
+ // mainly here to make some testing less complicated, but also just in case
+ *skipped = true;
+ return NS_OK;
+ }
+
+ if (mState == kJsepStateStable) {
+ const Sdp* answer(GetAnswer());
+ if (mSdpHelper.IsBundleSlave(*answer, level)) {
+ // We do not add candidate attributes to bundled m-sections unless they
+ // are the "master" bundle m-section.
+ *skipped = true;
+ return NS_OK;
+ }
+ }
+
+ nsresult rv = mSdpHelper.GetMidFromLevel(*sdp, level, mid);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ *skipped = false;
+
+ return mSdpHelper.AddCandidateToSdp(sdp, candidate, *mid, level);
+}
+
+nsresult
+JsepSessionImpl::UpdateDefaultCandidate(
+ const std::string& defaultCandidateAddr,
+ uint16_t defaultCandidatePort,
+ const std::string& defaultRtcpCandidateAddr,
+ uint16_t defaultRtcpCandidatePort,
+ uint16_t level)
+{
+ mLastError.clear();
+
+ mozilla::Sdp* sdp = GetParsedLocalDescription();
+
+ if (!sdp) {
+ JSEP_SET_ERROR("Cannot add ICE candidate in state " << GetStateStr(mState));
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ if (level >= sdp->GetMediaSectionCount()) {
+ return NS_OK;
+ }
+
+ std::string defaultRtcpCandidateAddrCopy(defaultRtcpCandidateAddr);
+ if (mState == kJsepStateStable && mTransports[level]->mComponents == 1) {
+ // We know we're doing rtcp-mux by now. Don't create an rtcp attr.
+ defaultRtcpCandidateAddrCopy = "";
+ defaultRtcpCandidatePort = 0;
+ }
+
+ // If offer/answer isn't done, it is too early to tell whether these defaults
+ // need to be applied to other m-sections.
+ SdpHelper::BundledMids bundledMids;
+ if (mState == kJsepStateStable) {
+ nsresult rv = GetNegotiatedBundledMids(&bundledMids);
+ if (NS_FAILED(rv)) {
+ MOZ_ASSERT(false);
+ mLastError += " (This should have been caught sooner!)";
+ return NS_ERROR_FAILURE;
+ }
+ }
+
+ mSdpHelper.SetDefaultAddresses(
+ defaultCandidateAddr,
+ defaultCandidatePort,
+ defaultRtcpCandidateAddrCopy,
+ defaultRtcpCandidatePort,
+ sdp,
+ level,
+ bundledMids);
+
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::EndOfLocalCandidates(uint16_t level)
+{
+ mLastError.clear();
+
+ mozilla::Sdp* sdp = GetParsedLocalDescription();
+
+ if (!sdp) {
+ JSEP_SET_ERROR("Cannot mark end of local ICE candidates in state "
+ << GetStateStr(mState));
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ if (level >= sdp->GetMediaSectionCount()) {
+ return NS_OK;
+ }
+
+ // If offer/answer isn't done, it is too early to tell whether this update
+ // needs to be applied to other m-sections.
+ SdpHelper::BundledMids bundledMids;
+ if (mState == kJsepStateStable) {
+ nsresult rv = GetNegotiatedBundledMids(&bundledMids);
+ if (NS_FAILED(rv)) {
+ MOZ_ASSERT(false);
+ mLastError += " (This should have been caught sooner!)";
+ return NS_ERROR_FAILURE;
+ }
+ }
+
+ mSdpHelper.SetIceGatheringComplete(sdp,
+ level,
+ bundledMids);
+
+ return NS_OK;
+}
+
+nsresult
+JsepSessionImpl::GetNegotiatedBundledMids(SdpHelper::BundledMids* bundledMids)
+{
+ const Sdp* answerSdp = GetAnswer();
+
+ if (!answerSdp) {
+ return NS_OK;
+ }
+
+ return mSdpHelper.GetBundledMids(*answerSdp, bundledMids);
+}
+
+nsresult
+JsepSessionImpl::EnableOfferMsection(SdpMediaSection* msection)
+{
+ // We assert here because adding rtcp-mux to a non-disabled m-section that
+ // did not already have rtcp-mux can cause problems.
+ MOZ_ASSERT(mSdpHelper.MsectionIsDisabled(*msection));
+
+ msection->SetPort(9);
+
+ // We don't do this in AddTransportAttributes because that is also used for
+ // making answers, and we don't want to unconditionally set rtcp-mux there.
+ if (mSdpHelper.HasRtcp(msection->GetProtocol())) {
+ // Set RTCP-MUX.
+ msection->GetAttributeList().SetAttribute(
+ new SdpFlagAttribute(SdpAttribute::kRtcpMuxAttribute));
+ }
+
+ nsresult rv = AddTransportAttributes(msection, SdpSetupAttribute::kActpass);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = SetRecvonlySsrc(msection);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ AddExtmap(msection);
+
+ std::ostringstream osMid;
+ osMid << "sdparta_" << msection->GetLevel();
+ AddMid(osMid.str(), msection);
+
+ return NS_OK;
+}
+
+mozilla::Sdp*
+JsepSessionImpl::GetParsedLocalDescription() const
+{
+ if (mPendingLocalDescription) {
+ return mPendingLocalDescription.get();
+ } else if (mCurrentLocalDescription) {
+ return mCurrentLocalDescription.get();
+ }
+
+ return nullptr;
+}
+
+mozilla::Sdp*
+JsepSessionImpl::GetParsedRemoteDescription() const
+{
+ if (mPendingRemoteDescription) {
+ return mPendingRemoteDescription.get();
+ } else if (mCurrentRemoteDescription) {
+ return mCurrentRemoteDescription.get();
+ }
+
+ return nullptr;
+}
+
+const Sdp*
+JsepSessionImpl::GetAnswer() const
+{
+ return mWasOffererLastTime ? mCurrentRemoteDescription.get()
+ : mCurrentLocalDescription.get();
+}
+
+nsresult
+JsepSessionImpl::Close()
+{
+ mLastError.clear();
+ SetState(kJsepStateClosed);
+ return NS_OK;
+}
+
+const std::string
+JsepSessionImpl::GetLastError() const
+{
+ return mLastError;
+}
+
+bool
+JsepSessionImpl::AllLocalTracksAreAssigned() const
+{
+ for (auto i = mLocalTracks.begin(); i != mLocalTracks.end(); ++i) {
+ if (!i->mAssignedMLine.isSome()) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+} // namespace mozilla
diff --git a/media/webrtc/signaling/src/jsep/JsepSessionImpl.h b/media/webrtc/signaling/src/jsep/JsepSessionImpl.h
new file mode 100644
index 000000000..00c07d25e
--- /dev/null
+++ b/media/webrtc/signaling/src/jsep/JsepSessionImpl.h
@@ -0,0 +1,352 @@
+/* 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/. */
+
+#ifndef _JSEPSESSIONIMPL_H_
+#define _JSEPSESSIONIMPL_H_
+
+#include <set>
+#include <string>
+#include <vector>
+
+#include "signaling/src/jsep/JsepCodecDescription.h"
+#include "signaling/src/jsep/JsepTrack.h"
+#include "signaling/src/jsep/JsepSession.h"
+#include "signaling/src/jsep/JsepTrack.h"
+#include "signaling/src/sdp/SipccSdpParser.h"
+#include "signaling/src/sdp/SdpHelper.h"
+#include "signaling/src/common/PtrVector.h"
+
+namespace mozilla {
+
+class JsepUuidGenerator
+{
+public:
+ virtual ~JsepUuidGenerator() {}
+ virtual bool Generate(std::string* id) = 0;
+};
+
+class JsepSessionImpl : public JsepSession
+{
+public:
+ JsepSessionImpl(const std::string& name, UniquePtr<JsepUuidGenerator> uuidgen)
+ : JsepSession(name),
+ mIsOfferer(false),
+ mWasOffererLastTime(false),
+ mIceControlling(false),
+ mRemoteIsIceLite(false),
+ mRemoteIceIsRestarting(false),
+ mBundlePolicy(kBundleBalanced),
+ mSessionId(0),
+ mSessionVersion(0),
+ mUuidGen(Move(uuidgen)),
+ mSdpHelper(&mLastError)
+ {
+ }
+
+ // Implement JsepSession methods.
+ virtual nsresult Init() override;
+
+ virtual nsresult AddTrack(const RefPtr<JsepTrack>& track) override;
+
+ virtual nsresult RemoveTrack(const std::string& streamId,
+ const std::string& trackId) override;
+
+ virtual nsresult SetIceCredentials(const std::string& ufrag,
+ const std::string& pwd) override;
+ virtual const std::string& GetUfrag() const override { return mIceUfrag; }
+ virtual const std::string& GetPwd() const override { return mIcePwd; }
+ nsresult SetBundlePolicy(JsepBundlePolicy policy) override;
+
+ virtual bool
+ RemoteIsIceLite() const override
+ {
+ return mRemoteIsIceLite;
+ }
+
+ virtual bool
+ RemoteIceIsRestarting() const override
+ {
+ return mRemoteIceIsRestarting;
+ }
+
+ virtual std::vector<std::string>
+ GetIceOptions() const override
+ {
+ return mIceOptions;
+ }
+
+ virtual nsresult AddDtlsFingerprint(const std::string& algorithm,
+ const std::vector<uint8_t>& value) override;
+
+ nsresult AddRtpExtension(std::vector<SdpExtmapAttributeList::Extmap>& extensions,
+ const std::string& extensionName,
+ SdpDirectionAttribute::Direction direction);
+ virtual nsresult AddAudioRtpExtension(
+ const std::string& extensionName,
+ SdpDirectionAttribute::Direction direction =
+ SdpDirectionAttribute::Direction::kSendrecv) override;
+
+ virtual nsresult AddVideoRtpExtension(
+ const std::string& extensionName,
+ SdpDirectionAttribute::Direction direction =
+ SdpDirectionAttribute::Direction::kSendrecv) override;
+
+ virtual std::vector<JsepCodecDescription*>&
+ Codecs() override
+ {
+ return mSupportedCodecs.values;
+ }
+
+ virtual nsresult ReplaceTrack(const std::string& oldStreamId,
+ const std::string& oldTrackId,
+ const std::string& newStreamId,
+ const std::string& newTrackId) override;
+
+ virtual nsresult SetParameters(
+ const std::string& streamId,
+ const std::string& trackId,
+ const std::vector<JsepTrack::JsConstraints>& constraints) override;
+
+ virtual nsresult GetParameters(
+ const std::string& streamId,
+ const std::string& trackId,
+ std::vector<JsepTrack::JsConstraints>* outConstraints) override;
+
+ virtual std::vector<RefPtr<JsepTrack>> GetLocalTracks() const override;
+
+ virtual std::vector<RefPtr<JsepTrack>> GetRemoteTracks() const override;
+
+ virtual std::vector<RefPtr<JsepTrack>>
+ GetRemoteTracksAdded() const override;
+
+ virtual std::vector<RefPtr<JsepTrack>>
+ GetRemoteTracksRemoved() const override;
+
+ virtual nsresult CreateOffer(const JsepOfferOptions& options,
+ std::string* offer) override;
+
+ virtual nsresult CreateAnswer(const JsepAnswerOptions& options,
+ std::string* answer) override;
+
+ virtual std::string GetLocalDescription() const override;
+
+ virtual std::string GetRemoteDescription() const override;
+
+ virtual nsresult SetLocalDescription(JsepSdpType type,
+ const std::string& sdp) override;
+
+ virtual nsresult SetRemoteDescription(JsepSdpType type,
+ const std::string& sdp) override;
+
+ virtual nsresult AddRemoteIceCandidate(const std::string& candidate,
+ const std::string& mid,
+ uint16_t level) override;
+
+ virtual nsresult AddLocalIceCandidate(const std::string& candidate,
+ uint16_t level,
+ std::string* mid,
+ bool* skipped) override;
+
+ virtual nsresult UpdateDefaultCandidate(
+ const std::string& defaultCandidateAddr,
+ uint16_t defaultCandidatePort,
+ const std::string& defaultRtcpCandidateAddr,
+ uint16_t defaultRtcpCandidatePort,
+ uint16_t level) override;
+
+ virtual nsresult EndOfLocalCandidates(uint16_t level) override;
+
+ virtual nsresult Close() override;
+
+ virtual const std::string GetLastError() const override;
+
+ virtual bool
+ IsIceControlling() const override
+ {
+ return mIceControlling;
+ }
+
+ virtual bool
+ IsOfferer() const
+ {
+ return mIsOfferer;
+ }
+
+ // Access transports.
+ virtual std::vector<RefPtr<JsepTransport>>
+ GetTransports() const override
+ {
+ return mTransports;
+ }
+
+ virtual std::vector<JsepTrackPair>
+ GetNegotiatedTrackPairs() const override
+ {
+ return mNegotiatedTrackPairs;
+ }
+
+ virtual bool AllLocalTracksAreAssigned() const override;
+
+private:
+ struct JsepDtlsFingerprint {
+ std::string mAlgorithm;
+ std::vector<uint8_t> mValue;
+ };
+
+ struct JsepSendingTrack {
+ RefPtr<JsepTrack> mTrack;
+ Maybe<size_t> mAssignedMLine;
+ };
+
+ struct JsepReceivingTrack {
+ RefPtr<JsepTrack> mTrack;
+ Maybe<size_t> mAssignedMLine;
+ };
+
+ // Non-const so it can set mLastError
+ nsresult CreateGenericSDP(UniquePtr<Sdp>* sdp);
+ void AddExtmap(SdpMediaSection* msection) const;
+ void AddMid(const std::string& mid, SdpMediaSection* msection) const;
+ const std::vector<SdpExtmapAttributeList::Extmap>* GetRtpExtensions(
+ SdpMediaSection::MediaType type) const;
+
+ void AddCommonExtmaps(const SdpMediaSection& remoteMsection,
+ SdpMediaSection* msection);
+ nsresult SetupIds();
+ nsresult CreateSsrc(uint32_t* ssrc);
+ void SetupDefaultCodecs();
+ void SetupDefaultRtpExtensions();
+ void SetState(JsepSignalingState state);
+ // Non-const so it can set mLastError
+ nsresult ParseSdp(const std::string& sdp, UniquePtr<Sdp>* parsedp);
+ nsresult SetLocalDescriptionOffer(UniquePtr<Sdp> offer);
+ nsresult SetLocalDescriptionAnswer(JsepSdpType type, UniquePtr<Sdp> answer);
+ nsresult SetRemoteDescriptionOffer(UniquePtr<Sdp> offer);
+ nsresult SetRemoteDescriptionAnswer(JsepSdpType type, UniquePtr<Sdp> answer);
+ nsresult ValidateLocalDescription(const Sdp& description);
+ nsresult ValidateRemoteDescription(const Sdp& description);
+ nsresult ValidateAnswer(const Sdp& offer, const Sdp& answer);
+ nsresult SetRemoteTracksFromDescription(const Sdp* remoteDescription);
+ // Non-const because we use our Uuid generator
+ nsresult CreateReceivingTrack(size_t mline,
+ const Sdp& sdp,
+ const SdpMediaSection& msection,
+ RefPtr<JsepTrack>* track);
+ nsresult HandleNegotiatedSession(const UniquePtr<Sdp>& local,
+ const UniquePtr<Sdp>& remote);
+ nsresult AddTransportAttributes(SdpMediaSection* msection,
+ SdpSetupAttribute::Role dtlsRole);
+ nsresult CopyPreviousTransportParams(const Sdp& oldAnswer,
+ const Sdp& offerersPreviousSdp,
+ const Sdp& newOffer,
+ Sdp* newLocal);
+ nsresult SetupOfferMSections(const JsepOfferOptions& options, Sdp* sdp);
+ // Non-const so it can assign m-line index to tracks
+ nsresult SetupOfferMSectionsByType(SdpMediaSection::MediaType type,
+ Maybe<size_t> offerToReceive,
+ Sdp* sdp);
+ nsresult BindLocalTracks(SdpMediaSection::MediaType mediatype,
+ Sdp* sdp);
+ nsresult BindRemoteTracks(SdpMediaSection::MediaType mediatype,
+ Sdp* sdp,
+ size_t* offerToReceive);
+ nsresult SetRecvAsNeededOrDisable(SdpMediaSection::MediaType mediatype,
+ Sdp* sdp,
+ size_t* offerToRecv);
+ void SetupOfferToReceiveMsection(SdpMediaSection* offer);
+ nsresult AddRecvonlyMsections(SdpMediaSection::MediaType mediatype,
+ size_t count,
+ Sdp* sdp);
+ nsresult AddReofferMsections(const Sdp& oldLocalSdp,
+ const Sdp& oldAnswer,
+ Sdp* newSdp);
+ void SetupBundle(Sdp* sdp) const;
+ nsresult GetRemoteIds(const Sdp& sdp,
+ const SdpMediaSection& msection,
+ std::string* streamId,
+ std::string* trackId);
+ nsresult CreateOfferMSection(SdpMediaSection::MediaType type,
+ SdpMediaSection::Protocol proto,
+ SdpDirectionAttribute::Direction direction,
+ Sdp* sdp);
+ nsresult GetFreeMsectionForSend(SdpMediaSection::MediaType type,
+ Sdp* sdp,
+ SdpMediaSection** msection);
+ nsresult CreateAnswerMSection(const JsepAnswerOptions& options,
+ size_t mlineIndex,
+ const SdpMediaSection& remoteMsection,
+ Sdp* sdp);
+ nsresult SetRecvonlySsrc(SdpMediaSection* msection);
+ nsresult BindMatchingLocalTrackToAnswer(SdpMediaSection* msection);
+ nsresult BindMatchingRemoteTrackToAnswer(SdpMediaSection* msection);
+ nsresult DetermineAnswererSetupRole(const SdpMediaSection& remoteMsection,
+ SdpSetupAttribute::Role* rolep);
+ nsresult MakeNegotiatedTrackPair(const SdpMediaSection& remote,
+ const SdpMediaSection& local,
+ const RefPtr<JsepTransport>& transport,
+ bool usingBundle,
+ size_t transportLevel,
+ JsepTrackPair* trackPairOut);
+ void InitTransport(const SdpMediaSection& msection, JsepTransport* transport);
+
+ nsresult FinalizeTransport(const SdpAttributeList& remote,
+ const SdpAttributeList& answer,
+ const RefPtr<JsepTransport>& transport);
+
+ nsresult GetNegotiatedBundledMids(SdpHelper::BundledMids* bundledMids);
+
+ nsresult EnableOfferMsection(SdpMediaSection* msection);
+
+ mozilla::Sdp* GetParsedLocalDescription() const;
+ mozilla::Sdp* GetParsedRemoteDescription() const;
+ const Sdp* GetAnswer() const;
+
+ std::vector<JsepSendingTrack> mLocalTracks;
+ std::vector<JsepReceivingTrack> mRemoteTracks;
+ // By the most recent SetRemoteDescription
+ std::vector<JsepReceivingTrack> mRemoteTracksAdded;
+ std::vector<JsepReceivingTrack> mRemoteTracksRemoved;
+ std::vector<RefPtr<JsepTransport> > mTransports;
+ // So we can rollback
+ std::vector<RefPtr<JsepTransport> > mOldTransports;
+ std::vector<JsepTrackPair> mNegotiatedTrackPairs;
+
+ bool mIsOfferer;
+ bool mWasOffererLastTime;
+ bool mIceControlling;
+ std::string mIceUfrag;
+ std::string mIcePwd;
+ bool mRemoteIsIceLite;
+ bool mRemoteIceIsRestarting;
+ std::vector<std::string> mIceOptions;
+ JsepBundlePolicy mBundlePolicy;
+ std::vector<JsepDtlsFingerprint> mDtlsFingerprints;
+ uint64_t mSessionId;
+ uint64_t mSessionVersion;
+ std::vector<SdpExtmapAttributeList::Extmap> mAudioRtpExtensions;
+ std::vector<SdpExtmapAttributeList::Extmap> mVideoRtpExtensions;
+ UniquePtr<JsepUuidGenerator> mUuidGen;
+ std::string mDefaultRemoteStreamId;
+ std::map<size_t, std::string> mDefaultRemoteTrackIdsByLevel;
+ std::string mCNAME;
+ // Used to prevent duplicate local SSRCs. Not used to prevent local/remote or
+ // remote-only duplication, which will be important for EKT but not now.
+ std::set<uint32_t> mSsrcs;
+ // When an m-section doesn't have a local track, it still needs an ssrc, which
+ // is stored here.
+ std::vector<uint32_t> mRecvonlySsrcs;
+ UniquePtr<Sdp> mGeneratedLocalDescription; // Created but not set.
+ UniquePtr<Sdp> mCurrentLocalDescription;
+ UniquePtr<Sdp> mCurrentRemoteDescription;
+ UniquePtr<Sdp> mPendingLocalDescription;
+ UniquePtr<Sdp> mPendingRemoteDescription;
+ PtrVector<JsepCodecDescription> mSupportedCodecs;
+ std::string mLastError;
+ SipccSdpParser mParser;
+ SdpHelper mSdpHelper;
+};
+
+} // namespace mozilla
+
+#endif
diff --git a/media/webrtc/signaling/src/jsep/JsepTrack.cpp b/media/webrtc/signaling/src/jsep/JsepTrack.cpp
new file mode 100644
index 000000000..1b045d8ec
--- /dev/null
+++ b/media/webrtc/signaling/src/jsep/JsepTrack.cpp
@@ -0,0 +1,531 @@
+/* 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 "signaling/src/jsep/JsepTrack.h"
+#include "signaling/src/jsep/JsepCodecDescription.h"
+#include "signaling/src/jsep/JsepTrackEncoding.h"
+
+#include <algorithm>
+
+namespace mozilla
+{
+void
+JsepTrack::GetNegotiatedPayloadTypes(std::vector<uint16_t>* payloadTypes)
+{
+ if (!mNegotiatedDetails) {
+ return;
+ }
+
+ for (const auto* encoding : mNegotiatedDetails->mEncodings.values) {
+ GetPayloadTypes(encoding->GetCodecs(), payloadTypes);
+ }
+
+ // Prune out dupes
+ std::sort(payloadTypes->begin(), payloadTypes->end());
+ auto newEnd = std::unique(payloadTypes->begin(), payloadTypes->end());
+ payloadTypes->erase(newEnd, payloadTypes->end());
+}
+
+/* static */
+void
+JsepTrack::GetPayloadTypes(
+ const std::vector<JsepCodecDescription*>& codecs,
+ std::vector<uint16_t>* payloadTypes)
+{
+ for (JsepCodecDescription* codec : codecs) {
+ uint16_t pt;
+ if (!codec->GetPtAsInt(&pt)) {
+ MOZ_ASSERT(false);
+ continue;
+ }
+ payloadTypes->push_back(pt);
+ }
+}
+
+void
+JsepTrack::EnsureNoDuplicatePayloadTypes(
+ std::vector<JsepCodecDescription*>* codecs)
+{
+ std::set<uint16_t> uniquePayloadTypes;
+
+ for (JsepCodecDescription* codec : *codecs) {
+ // We assume there are no dupes in negotiated codecs; unnegotiated codecs
+ // need to change if there is a clash.
+ if (!codec->mEnabled) {
+ continue;
+ }
+
+ // Disable, and only re-enable if we can ensure it has a unique pt.
+ codec->mEnabled = false;
+
+ uint16_t currentPt;
+ if (!codec->GetPtAsInt(&currentPt)) {
+ MOZ_ASSERT(false);
+ continue;
+ }
+
+ if (!uniquePayloadTypes.count(currentPt)) {
+ codec->mEnabled = true;
+ uniquePayloadTypes.insert(currentPt);
+ continue;
+ }
+
+ // |codec| cannot use its current payload type. Try to find another.
+ for (uint16_t freePt = 96; freePt <= 127; ++freePt) {
+ // Not super efficient, but readability is probably more important.
+ if (!uniquePayloadTypes.count(freePt)) {
+ uniquePayloadTypes.insert(freePt);
+ codec->mEnabled = true;
+ std::ostringstream os;
+ os << freePt;
+ codec->mDefaultPt = os.str();
+ break;
+ }
+ }
+ }
+}
+
+void
+JsepTrack::PopulateCodecs(const std::vector<JsepCodecDescription*>& prototype)
+{
+ for (const JsepCodecDescription* prototypeCodec : prototype) {
+ if (prototypeCodec->mType == mType) {
+ mPrototypeCodecs.values.push_back(prototypeCodec->Clone());
+ mPrototypeCodecs.values.back()->mDirection = mDirection;
+ }
+ }
+
+ EnsureNoDuplicatePayloadTypes(&mPrototypeCodecs.values);
+}
+
+void
+JsepTrack::AddToOffer(SdpMediaSection* offer) const
+{
+ AddToMsection(mPrototypeCodecs.values, offer);
+ if (mDirection == sdp::kSend) {
+ AddToMsection(mJsEncodeConstraints, sdp::kSend, offer);
+ }
+}
+
+void
+JsepTrack::AddToAnswer(const SdpMediaSection& offer,
+ SdpMediaSection* answer) const
+{
+ // We do not modify mPrototypeCodecs here, since we're only creating an
+ // answer. Once offer/answer concludes, we will update mPrototypeCodecs.
+ PtrVector<JsepCodecDescription> codecs;
+ codecs.values = GetCodecClones();
+ NegotiateCodecs(offer, &codecs.values);
+ if (codecs.values.empty()) {
+ return;
+ }
+
+ AddToMsection(codecs.values, answer);
+
+ if (mDirection == sdp::kSend) {
+ std::vector<JsConstraints> constraints;
+ std::vector<SdpRidAttributeList::Rid> rids;
+ GetRids(offer, sdp::kRecv, &rids);
+ NegotiateRids(rids, &constraints);
+ AddToMsection(constraints, sdp::kSend, answer);
+ }
+}
+
+void
+JsepTrack::AddToMsection(const std::vector<JsepCodecDescription*>& codecs,
+ SdpMediaSection* msection) const
+{
+ MOZ_ASSERT(msection->GetMediaType() == mType);
+ MOZ_ASSERT(!codecs.empty());
+
+ for (const JsepCodecDescription* codec : codecs) {
+ codec->AddToMediaSection(*msection);
+ }
+
+ if (mDirection == sdp::kSend) {
+ if (msection->GetMediaType() != SdpMediaSection::kApplication) {
+ msection->SetSsrcs(mSsrcs, mCNAME);
+ msection->AddMsid(mStreamId, mTrackId);
+ }
+ msection->SetSending(true);
+ } else {
+ msection->SetReceiving(true);
+ }
+}
+
+// Updates the |id| values in |constraintsList| with the rid values in |rids|,
+// where necessary.
+void
+JsepTrack::NegotiateRids(const std::vector<SdpRidAttributeList::Rid>& rids,
+ std::vector<JsConstraints>* constraintsList) const
+{
+ for (const SdpRidAttributeList::Rid& rid : rids) {
+ if (!FindConstraints(rid.id, *constraintsList)) {
+ // Pair up the first JsConstraints with an empty id, if it exists.
+ JsConstraints* constraints = FindConstraints("", *constraintsList);
+ if (constraints) {
+ constraints->rid = rid.id;
+ }
+ }
+ }
+}
+
+/* static */
+void
+JsepTrack::AddToMsection(const std::vector<JsConstraints>& constraintsList,
+ sdp::Direction direction,
+ SdpMediaSection* msection)
+{
+ UniquePtr<SdpSimulcastAttribute> simulcast(new SdpSimulcastAttribute);
+ UniquePtr<SdpRidAttributeList> rids(new SdpRidAttributeList);
+ for (const JsConstraints& constraints : constraintsList) {
+ if (!constraints.rid.empty()) {
+ SdpRidAttributeList::Rid rid;
+ rid.id = constraints.rid;
+ rid.direction = direction;
+ rids->mRids.push_back(rid);
+
+ SdpSimulcastAttribute::Version version;
+ version.choices.push_back(constraints.rid);
+ if (direction == sdp::kSend) {
+ simulcast->sendVersions.push_back(version);
+ } else {
+ simulcast->recvVersions.push_back(version);
+ }
+ }
+ }
+
+ if (!rids->mRids.empty()) {
+ msection->GetAttributeList().SetAttribute(simulcast.release());
+ msection->GetAttributeList().SetAttribute(rids.release());
+ }
+}
+
+void
+JsepTrack::GetRids(const SdpMediaSection& msection,
+ sdp::Direction direction,
+ std::vector<SdpRidAttributeList::Rid>* rids) const
+{
+ rids->clear();
+ if (!msection.GetAttributeList().HasAttribute(
+ SdpAttribute::kSimulcastAttribute)) {
+ return;
+ }
+
+ const SdpSimulcastAttribute& simulcast(
+ msection.GetAttributeList().GetSimulcast());
+
+ const SdpSimulcastAttribute::Versions* versions = nullptr;
+ switch (direction) {
+ case sdp::kSend:
+ versions = &simulcast.sendVersions;
+ break;
+ case sdp::kRecv:
+ versions = &simulcast.recvVersions;
+ break;
+ }
+
+ if (!versions->IsSet()) {
+ return;
+ }
+
+ if (versions->type != SdpSimulcastAttribute::Versions::kRid) {
+ // No support for PT-based simulcast, yet.
+ return;
+ }
+
+ for (const SdpSimulcastAttribute::Version& version : *versions) {
+ if (!version.choices.empty()) {
+ // We validate that rids are present (and sane) elsewhere.
+ rids->push_back(*msection.FindRid(version.choices[0]));
+ }
+ }
+}
+
+JsepTrack::JsConstraints*
+JsepTrack::FindConstraints(const std::string& id,
+ std::vector<JsConstraints>& constraintsList) const
+{
+ for (JsConstraints& constraints : constraintsList) {
+ if (constraints.rid == id) {
+ return &constraints;
+ }
+ }
+ return nullptr;
+}
+
+void
+JsepTrack::CreateEncodings(
+ const SdpMediaSection& remote,
+ const std::vector<JsepCodecDescription*>& negotiatedCodecs,
+ JsepTrackNegotiatedDetails* negotiatedDetails)
+{
+ std::vector<SdpRidAttributeList::Rid> rids;
+ GetRids(remote, sdp::kRecv, &rids); // Get rids we will send
+ NegotiateRids(rids, &mJsEncodeConstraints);
+ if (rids.empty()) {
+ // Add dummy value with an empty id to make sure we get a single unicast
+ // stream.
+ rids.push_back(SdpRidAttributeList::Rid());
+ }
+
+ // For each rid in the remote, make sure we have an encoding, and configure
+ // that encoding appropriately.
+ for (size_t i = 0; i < rids.size(); ++i) {
+ if (i == negotiatedDetails->mEncodings.values.size()) {
+ negotiatedDetails->mEncodings.values.push_back(new JsepTrackEncoding);
+ }
+
+ JsepTrackEncoding* encoding = negotiatedDetails->mEncodings.values[i];
+
+ for (const JsepCodecDescription* codec : negotiatedCodecs) {
+ if (rids[i].HasFormat(codec->mDefaultPt)) {
+ encoding->AddCodec(*codec);
+ }
+ }
+
+ encoding->mRid = rids[i].id;
+ // If we end up supporting params for rid, we would handle that here.
+
+ // Incorporate the corresponding JS encoding constraints, if they exist
+ for (const JsConstraints& jsConstraints : mJsEncodeConstraints) {
+ if (jsConstraints.rid == rids[i].id) {
+ encoding->mConstraints = jsConstraints.constraints;
+ }
+ }
+
+ encoding->UpdateMaxBitrate(remote);
+ }
+}
+
+std::vector<JsepCodecDescription*>
+JsepTrack::GetCodecClones() const
+{
+ std::vector<JsepCodecDescription*> clones;
+ for (const JsepCodecDescription* codec : mPrototypeCodecs.values) {
+ clones.push_back(codec->Clone());
+ }
+ return clones;
+}
+
+static bool
+CompareCodec(const JsepCodecDescription* lhs, const JsepCodecDescription* rhs)
+{
+ return lhs->mStronglyPreferred && !rhs->mStronglyPreferred;
+}
+
+void
+JsepTrack::NegotiateCodecs(
+ const SdpMediaSection& remote,
+ std::vector<JsepCodecDescription*>* codecs,
+ std::map<std::string, std::string>* formatChanges) const
+{
+ PtrVector<JsepCodecDescription> unnegotiatedCodecs;
+ std::swap(unnegotiatedCodecs.values, *codecs);
+
+ // Outer loop establishes the remote side's preference
+ for (const std::string& fmt : remote.GetFormats()) {
+ for (size_t i = 0; i < unnegotiatedCodecs.values.size(); ++i) {
+ JsepCodecDescription* codec = unnegotiatedCodecs.values[i];
+ if (!codec || !codec->mEnabled || !codec->Matches(fmt, remote)) {
+ continue;
+ }
+
+ std::string originalFormat = codec->mDefaultPt;
+ if(codec->Negotiate(fmt, remote)) {
+ codecs->push_back(codec);
+ unnegotiatedCodecs.values[i] = nullptr;
+ if (formatChanges) {
+ (*formatChanges)[originalFormat] = codec->mDefaultPt;
+ }
+ break;
+ }
+ }
+ }
+
+ // Find the (potential) red codec and ulpfec codec or telephone-event
+ JsepVideoCodecDescription* red = nullptr;
+ JsepVideoCodecDescription* ulpfec = nullptr;
+ JsepAudioCodecDescription* dtmf = nullptr;
+ // We can safely cast here since JsepTrack has a MediaType and only codecs
+ // that match that MediaType (kAudio or kVideo) are added.
+ for (auto codec : *codecs) {
+ if (codec->mName == "red") {
+ red = static_cast<JsepVideoCodecDescription*>(codec);
+ }
+ else if (codec->mName == "ulpfec") {
+ ulpfec = static_cast<JsepVideoCodecDescription*>(codec);
+ }
+ else if (codec->mName == "telephone-event") {
+ dtmf = static_cast<JsepAudioCodecDescription*>(codec);
+ }
+ }
+ // if we have a red codec remove redundant encodings that don't exist
+ if (red) {
+ // Since we could have an externally specified redundant endcodings
+ // list, we shouldn't simply rebuild the redundant encodings list
+ // based on the current list of codecs.
+ std::vector<uint8_t> unnegotiatedEncodings;
+ std::swap(unnegotiatedEncodings, red->mRedundantEncodings);
+ for (auto redundantPt : unnegotiatedEncodings) {
+ std::string pt = std::to_string(redundantPt);
+ for (auto codec : *codecs) {
+ if (pt == codec->mDefaultPt) {
+ red->mRedundantEncodings.push_back(redundantPt);
+ break;
+ }
+ }
+ }
+ }
+ // Video FEC is indicated by the existence of the red and ulpfec
+ // codecs and not an attribute on the particular video codec (like in
+ // a rtcpfb attr). If we see both red and ulpfec codecs, we enable FEC
+ // on all the other codecs.
+ if (red && ulpfec) {
+ for (auto codec : *codecs) {
+ if (codec->mName != "red" && codec->mName != "ulpfec") {
+ JsepVideoCodecDescription* videoCodec =
+ static_cast<JsepVideoCodecDescription*>(codec);
+ videoCodec->EnableFec();
+ }
+ }
+ }
+
+ // Dtmf support is indicated by the existence of the telephone-event
+ // codec, and not an attribute on the particular audio codec (like in a
+ // rtcpfb attr). If we see the telephone-event codec, we enabled dtmf
+ // support on all the other audio codecs.
+ if (dtmf) {
+ for (auto codec : *codecs) {
+ JsepAudioCodecDescription* audioCodec =
+ static_cast<JsepAudioCodecDescription*>(codec);
+ audioCodec->mDtmfEnabled = true;
+ }
+ }
+
+ // Make sure strongly preferred codecs are up front, overriding the remote
+ // side's preference.
+ std::stable_sort(codecs->begin(), codecs->end(), CompareCodec);
+
+ // TODO(bug 814227): Remove this once we're ready to put multiple codecs in an
+ // answer. For now, remove all but the first codec unless the red codec
+ // exists, and then we include the others per RFC 5109, section 14.2.
+ // Note: now allows keeping the telephone-event codec, if it appears, as the
+ // last codec in the list.
+ if (!codecs->empty() && !red) {
+ int newSize = dtmf ? 2 : 1;
+ for (size_t i = 1; i < codecs->size(); ++i) {
+ if (!dtmf || dtmf != (*codecs)[i]) {
+ delete (*codecs)[i];
+ (*codecs)[i] = nullptr;
+ }
+ }
+ if (dtmf) {
+ (*codecs)[newSize-1] = dtmf;
+ }
+ codecs->resize(newSize);
+ }
+}
+
+void
+JsepTrack::Negotiate(const SdpMediaSection& answer,
+ const SdpMediaSection& remote)
+{
+ PtrVector<JsepCodecDescription> negotiatedCodecs;
+ negotiatedCodecs.values = GetCodecClones();
+
+ std::map<std::string, std::string> formatChanges;
+ NegotiateCodecs(remote,
+ &negotiatedCodecs.values,
+ &formatChanges);
+
+ // Use |formatChanges| to update mPrototypeCodecs
+ size_t insertPos = 0;
+ for (size_t i = 0; i < mPrototypeCodecs.values.size(); ++i) {
+ if (formatChanges.count(mPrototypeCodecs.values[i]->mDefaultPt)) {
+ // Update the payload type to what was negotiated
+ mPrototypeCodecs.values[i]->mDefaultPt =
+ formatChanges[mPrototypeCodecs.values[i]->mDefaultPt];
+ // Move this negotiated codec up front
+ std::swap(mPrototypeCodecs.values[insertPos],
+ mPrototypeCodecs.values[i]);
+ ++insertPos;
+ }
+ }
+
+ EnsureNoDuplicatePayloadTypes(&mPrototypeCodecs.values);
+
+ UniquePtr<JsepTrackNegotiatedDetails> negotiatedDetails =
+ MakeUnique<JsepTrackNegotiatedDetails>();
+
+ CreateEncodings(remote, negotiatedCodecs.values, negotiatedDetails.get());
+
+ if (answer.GetAttributeList().HasAttribute(SdpAttribute::kExtmapAttribute)) {
+ for (auto& extmapAttr : answer.GetAttributeList().GetExtmap().mExtmaps) {
+ negotiatedDetails->mExtmap[extmapAttr.extensionname] = extmapAttr;
+ }
+ }
+
+ if (mDirection == sdp::kRecv) {
+ mSsrcs.clear();
+ if (remote.GetAttributeList().HasAttribute(SdpAttribute::kSsrcAttribute)) {
+ for (auto& ssrcAttr : remote.GetAttributeList().GetSsrc().mSsrcs) {
+ AddSsrc(ssrcAttr.ssrc);
+ }
+ }
+ }
+
+ mNegotiatedDetails = Move(negotiatedDetails);
+}
+
+// When doing bundle, if all else fails we can try to figure out which m-line a
+// given RTP packet belongs to by looking at the payload type field. This only
+// works, however, if that payload type appeared in only one m-section.
+// We figure that out here.
+/* static */
+void
+JsepTrack::SetUniquePayloadTypes(const std::vector<RefPtr<JsepTrack>>& tracks)
+{
+ // Maps to track details if no other track contains the payload type,
+ // otherwise maps to nullptr.
+ std::map<uint16_t, JsepTrackNegotiatedDetails*> payloadTypeToDetailsMap;
+
+ for (const RefPtr<JsepTrack>& track : tracks) {
+ if (track->GetMediaType() == SdpMediaSection::kApplication) {
+ continue;
+ }
+
+ auto* details = track->GetNegotiatedDetails();
+ if (!details) {
+ // Can happen if negotiation fails on a track
+ continue;
+ }
+
+ std::vector<uint16_t> payloadTypesForTrack;
+ track->GetNegotiatedPayloadTypes(&payloadTypesForTrack);
+
+ for (uint16_t pt : payloadTypesForTrack) {
+ if (payloadTypeToDetailsMap.count(pt)) {
+ // Found in more than one track, not unique
+ payloadTypeToDetailsMap[pt] = nullptr;
+ } else {
+ payloadTypeToDetailsMap[pt] = details;
+ }
+ }
+ }
+
+ for (auto ptAndDetails : payloadTypeToDetailsMap) {
+ uint16_t uniquePt = ptAndDetails.first;
+ MOZ_ASSERT(uniquePt <= UINT8_MAX);
+ auto trackDetails = ptAndDetails.second;
+
+ if (trackDetails) {
+ trackDetails->mUniquePayloadTypes.push_back(
+ static_cast<uint8_t>(uniquePt));
+ }
+ }
+}
+
+} // namespace mozilla
+
diff --git a/media/webrtc/signaling/src/jsep/JsepTrack.h b/media/webrtc/signaling/src/jsep/JsepTrack.h
new file mode 100644
index 000000000..5aa37404f
--- /dev/null
+++ b/media/webrtc/signaling/src/jsep/JsepTrack.h
@@ -0,0 +1,292 @@
+/* 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/. */
+
+#ifndef _JSEPTRACK_H_
+#define _JSEPTRACK_H_
+
+#include <algorithm>
+#include <string>
+#include <map>
+#include <set>
+
+#include <mozilla/RefPtr.h>
+#include <mozilla/UniquePtr.h>
+#include <mozilla/Maybe.h>
+#include "nsISupportsImpl.h"
+#include "nsError.h"
+
+#include "signaling/src/jsep/JsepTransport.h"
+#include "signaling/src/jsep/JsepTrackEncoding.h"
+#include "signaling/src/sdp/Sdp.h"
+#include "signaling/src/sdp/SdpAttribute.h"
+#include "signaling/src/sdp/SdpMediaSection.h"
+#include "signaling/src/common/PtrVector.h"
+
+namespace mozilla {
+
+class JsepTrackNegotiatedDetails
+{
+public:
+ size_t
+ GetEncodingCount() const
+ {
+ return mEncodings.values.size();
+ }
+
+ const JsepTrackEncoding&
+ GetEncoding(size_t index) const
+ {
+ MOZ_RELEASE_ASSERT(index < mEncodings.values.size());
+ return *mEncodings.values[index];
+ }
+
+ const SdpExtmapAttributeList::Extmap*
+ GetExt(const std::string& ext_name) const
+ {
+ auto it = mExtmap.find(ext_name);
+ if (it != mExtmap.end()) {
+ return &it->second;
+ }
+ return nullptr;
+ }
+
+ std::vector<uint8_t> GetUniquePayloadTypes() const
+ {
+ return mUniquePayloadTypes;
+ }
+
+private:
+ friend class JsepTrack;
+
+ std::map<std::string, SdpExtmapAttributeList::Extmap> mExtmap;
+ std::vector<uint8_t> mUniquePayloadTypes;
+ PtrVector<JsepTrackEncoding> mEncodings;
+};
+
+class JsepTrack
+{
+public:
+ JsepTrack(mozilla::SdpMediaSection::MediaType type,
+ const std::string& streamid,
+ const std::string& trackid,
+ sdp::Direction direction = sdp::kSend)
+ : mType(type),
+ mStreamId(streamid),
+ mTrackId(trackid),
+ mDirection(direction),
+ mActive(false)
+ {}
+
+ virtual mozilla::SdpMediaSection::MediaType
+ GetMediaType() const
+ {
+ return mType;
+ }
+
+ virtual const std::string&
+ GetStreamId() const
+ {
+ return mStreamId;
+ }
+
+ virtual void
+ SetStreamId(const std::string& id)
+ {
+ mStreamId = id;
+ }
+
+ virtual const std::string&
+ GetTrackId() const
+ {
+ return mTrackId;
+ }
+
+ virtual void
+ SetTrackId(const std::string& id)
+ {
+ mTrackId = id;
+ }
+
+ virtual const std::string&
+ GetCNAME() const
+ {
+ return mCNAME;
+ }
+
+ virtual void
+ SetCNAME(const std::string& cname)
+ {
+ mCNAME = cname;
+ }
+
+ virtual sdp::Direction
+ GetDirection() const
+ {
+ return mDirection;
+ }
+
+ virtual const std::vector<uint32_t>&
+ GetSsrcs() const
+ {
+ return mSsrcs;
+ }
+
+ virtual void
+ AddSsrc(uint32_t ssrc)
+ {
+ mSsrcs.push_back(ssrc);
+ }
+
+ bool
+ GetActive() const
+ {
+ return mActive;
+ }
+
+ void
+ SetActive(bool active)
+ {
+ mActive = active;
+ }
+
+ virtual void PopulateCodecs(
+ const std::vector<JsepCodecDescription*>& prototype);
+
+ template <class UnaryFunction>
+ void ForEachCodec(UnaryFunction func)
+ {
+ std::for_each(mPrototypeCodecs.values.begin(),
+ mPrototypeCodecs.values.end(), func);
+ }
+
+ template <class BinaryPredicate>
+ void SortCodecs(BinaryPredicate sorter)
+ {
+ std::stable_sort(mPrototypeCodecs.values.begin(),
+ mPrototypeCodecs.values.end(), sorter);
+ }
+
+ virtual void AddToOffer(SdpMediaSection* offer) const;
+ virtual void AddToAnswer(const SdpMediaSection& offer,
+ SdpMediaSection* answer) const;
+ virtual void Negotiate(const SdpMediaSection& answer,
+ const SdpMediaSection& remote);
+ static void SetUniquePayloadTypes(
+ const std::vector<RefPtr<JsepTrack>>& tracks);
+ virtual void GetNegotiatedPayloadTypes(std::vector<uint16_t>* payloadTypes);
+
+ // This will be set when negotiation is carried out.
+ virtual const JsepTrackNegotiatedDetails*
+ GetNegotiatedDetails() const
+ {
+ if (mNegotiatedDetails) {
+ return mNegotiatedDetails.get();
+ }
+ return nullptr;
+ }
+
+ virtual JsepTrackNegotiatedDetails*
+ GetNegotiatedDetails()
+ {
+ if (mNegotiatedDetails) {
+ return mNegotiatedDetails.get();
+ }
+ return nullptr;
+ }
+
+ virtual void
+ ClearNegotiatedDetails()
+ {
+ mNegotiatedDetails.reset();
+ }
+
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(JsepTrack);
+
+ struct JsConstraints
+ {
+ std::string rid;
+ EncodingConstraints constraints;
+ };
+
+ void SetJsConstraints(const std::vector<JsConstraints>& constraintsList)
+ {
+ mJsEncodeConstraints = constraintsList;
+ }
+
+ void GetJsConstraints(std::vector<JsConstraints>* outConstraintsList) const
+ {
+ MOZ_ASSERT(outConstraintsList);
+ *outConstraintsList = mJsEncodeConstraints;
+ }
+
+ static void AddToMsection(const std::vector<JsConstraints>& constraintsList,
+ sdp::Direction direction,
+ SdpMediaSection* msection);
+
+protected:
+ virtual ~JsepTrack() {}
+
+private:
+ std::vector<JsepCodecDescription*> GetCodecClones() const;
+ static void EnsureNoDuplicatePayloadTypes(
+ std::vector<JsepCodecDescription*>* codecs);
+ static void GetPayloadTypes(
+ const std::vector<JsepCodecDescription*>& codecs,
+ std::vector<uint16_t>* pts);
+ static void EnsurePayloadTypeIsUnique(std::set<uint16_t>* uniquePayloadTypes,
+ JsepCodecDescription* codec);
+ void AddToMsection(const std::vector<JsepCodecDescription*>& codecs,
+ SdpMediaSection* msection) const;
+ void GetRids(const SdpMediaSection& msection,
+ sdp::Direction direction,
+ std::vector<SdpRidAttributeList::Rid>* rids) const;
+ void CreateEncodings(
+ const SdpMediaSection& remote,
+ const std::vector<JsepCodecDescription*>& negotiatedCodecs,
+ JsepTrackNegotiatedDetails* details);
+
+ // |formatChanges| is set on completion of offer/answer, and records how the
+ // formats in |codecs| were changed, which is used by |Negotiate| to update
+ // |mPrototypeCodecs|.
+ virtual void NegotiateCodecs(
+ const SdpMediaSection& remote,
+ std::vector<JsepCodecDescription*>* codecs,
+ std::map<std::string, std::string>* formatChanges = nullptr) const;
+
+ JsConstraints* FindConstraints(
+ const std::string& rid,
+ std::vector<JsConstraints>& constraintsList) const;
+ void NegotiateRids(const std::vector<SdpRidAttributeList::Rid>& rids,
+ std::vector<JsConstraints>* constraints) const;
+
+ const mozilla::SdpMediaSection::MediaType mType;
+ std::string mStreamId;
+ std::string mTrackId;
+ std::string mCNAME;
+ const sdp::Direction mDirection;
+ PtrVector<JsepCodecDescription> mPrototypeCodecs;
+ // Holds encoding params/constraints from JS. Simulcast happens when there are
+ // multiple of these. If there are none, we assume unconstrained unicast with
+ // no rid.
+ std::vector<JsConstraints> mJsEncodeConstraints;
+ UniquePtr<JsepTrackNegotiatedDetails> mNegotiatedDetails;
+ std::vector<uint32_t> mSsrcs;
+ bool mActive;
+};
+
+// Need a better name for this.
+struct JsepTrackPair {
+ size_t mLevel;
+ // Is this track pair sharing a transport with another?
+ Maybe<size_t> mBundleLevel;
+ uint32_t mRecvonlySsrc;
+ RefPtr<JsepTrack> mSending;
+ RefPtr<JsepTrack> mReceiving;
+ RefPtr<JsepTransport> mRtpTransport;
+ RefPtr<JsepTransport> mRtcpTransport;
+};
+
+} // namespace mozilla
+
+#endif
diff --git a/media/webrtc/signaling/src/jsep/JsepTrackEncoding.h b/media/webrtc/signaling/src/jsep/JsepTrackEncoding.h
new file mode 100644
index 000000000..b59b672e4
--- /dev/null
+++ b/media/webrtc/signaling/src/jsep/JsepTrackEncoding.h
@@ -0,0 +1,60 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef _JESPTRACKENCODING_H_
+#define _JESPTRACKENCODING_H_
+
+#include "signaling/src/jsep/JsepCodecDescription.h"
+#include "signaling/src/common/EncodingConstraints.h"
+#include "signaling/src/common/PtrVector.h"
+
+namespace mozilla {
+// Represents a single encoding of a media track. When simulcast is used, there
+// may be multiple. Each encoding may have some constraints (imposed by JS), and
+// may be able to use any one of multiple codecs (JsepCodecDescription) at any
+// given time.
+class JsepTrackEncoding
+{
+public:
+ const std::vector<JsepCodecDescription*>& GetCodecs() const
+ {
+ return mCodecs.values;
+ }
+
+ void AddCodec(const JsepCodecDescription& codec)
+ {
+ mCodecs.values.push_back(codec.Clone());
+ }
+
+ bool HasFormat(const std::string& format) const
+ {
+ for (const JsepCodecDescription* codec : mCodecs.values) {
+ if (codec->mDefaultPt == format) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ void UpdateMaxBitrate(const SdpMediaSection& remote)
+ {
+ uint32_t tias = remote.GetBandwidth("TIAS");
+ // select minimum of the two which is not zero
+ mConstraints.maxBr = std::min(tias ? tias : mConstraints.maxBr,
+ mConstraints.maxBr ? mConstraints.maxBr :
+ tias);
+ // TODO add support for b=AS if TIAS is not set (bug 976521)
+ }
+
+ EncodingConstraints mConstraints;
+ std::string mRid;
+
+private:
+ PtrVector<JsepCodecDescription> mCodecs;
+};
+}
+
+#endif // _JESPTRACKENCODING_H_
diff --git a/media/webrtc/signaling/src/jsep/JsepTransport.h b/media/webrtc/signaling/src/jsep/JsepTransport.h
new file mode 100644
index 000000000..3b0d38ad6
--- /dev/null
+++ b/media/webrtc/signaling/src/jsep/JsepTransport.h
@@ -0,0 +1,116 @@
+/* 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/. */
+
+#ifndef _JSEPTRANSPORT_H_
+#define _JSEPTRANSPORT_H_
+
+#include <string>
+#include <vector>
+
+#include <mozilla/RefPtr.h>
+#include <mozilla/UniquePtr.h>
+#include "nsISupportsImpl.h"
+
+#include "signaling/src/sdp/SdpAttribute.h"
+
+namespace mozilla {
+
+class JsepDtlsTransport
+{
+public:
+ JsepDtlsTransport() : mRole(kJsepDtlsInvalidRole) {}
+
+ virtual ~JsepDtlsTransport() {}
+
+ enum Role {
+ kJsepDtlsClient,
+ kJsepDtlsServer,
+ kJsepDtlsInvalidRole
+ };
+
+ virtual const SdpFingerprintAttributeList&
+ GetFingerprints() const
+ {
+ return mFingerprints;
+ }
+
+ virtual Role
+ GetRole() const
+ {
+ return mRole;
+ }
+
+private:
+ friend class JsepSessionImpl;
+
+ SdpFingerprintAttributeList mFingerprints;
+ Role mRole;
+};
+
+class JsepIceTransport
+{
+public:
+ JsepIceTransport() {}
+
+ virtual ~JsepIceTransport() {}
+
+ const std::string&
+ GetUfrag() const
+ {
+ return mUfrag;
+ }
+ const std::string&
+ GetPassword() const
+ {
+ return mPwd;
+ }
+ const std::vector<std::string>&
+ GetCandidates() const
+ {
+ return mCandidates;
+ }
+
+private:
+ friend class JsepSessionImpl;
+
+ std::string mUfrag;
+ std::string mPwd;
+ std::vector<std::string> mCandidates;
+};
+
+class JsepTransport
+{
+public:
+ JsepTransport()
+ : mComponents(0)
+ {
+ }
+
+ void Close()
+ {
+ mComponents = 0;
+ mTransportId.clear();
+ mIce.reset();
+ mDtls.reset();
+ }
+
+ // Unique identifier for this transport within this call. Group?
+ std::string mTransportId;
+
+ // ICE stuff.
+ UniquePtr<JsepIceTransport> mIce;
+ UniquePtr<JsepDtlsTransport> mDtls;
+
+ // Number of required components.
+ size_t mComponents;
+
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(JsepTransport);
+
+protected:
+ ~JsepTransport() {}
+};
+
+} // namespace mozilla
+
+#endif
diff --git a/media/webrtc/signaling/src/media-conduit/AudioConduit.cpp b/media/webrtc/signaling/src/media-conduit/AudioConduit.cpp
new file mode 100755
index 000000000..2c57431e7
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/AudioConduit.cpp
@@ -0,0 +1,1134 @@
+/* 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 "CSFLog.h"
+#include "nspr.h"
+
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#elif defined XP_WIN
+#include <winsock2.h>
+#endif
+
+#include "AudioConduit.h"
+#include "nsCOMPtr.h"
+#include "mozilla/Services.h"
+#include "nsServiceManagerUtils.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsThreadUtils.h"
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+#include "Latency.h"
+#include "mozilla/Telemetry.h"
+#endif
+
+#include "webrtc/common.h"
+#include "webrtc/modules/audio_processing/include/audio_processing.h"
+#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
+#include "webrtc/voice_engine/include/voe_dtmf.h"
+#include "webrtc/voice_engine/include/voe_errors.h"
+#include "webrtc/voice_engine/voice_engine_impl.h"
+#include "webrtc/system_wrappers/interface/clock.h"
+
+#ifdef MOZ_WIDGET_ANDROID
+#include "AndroidJNIWrapper.h"
+#endif
+
+namespace mozilla {
+
+static const char* logTag ="WebrtcAudioSessionConduit";
+
+// 32 bytes is what WebRTC CodecInst expects
+const unsigned int WebrtcAudioConduit::CODEC_PLNAME_SIZE = 32;
+
+/**
+ * Factory Method for AudioConduit
+ */
+RefPtr<AudioSessionConduit> AudioSessionConduit::Create()
+{
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+ NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
+
+ WebrtcAudioConduit* obj = new WebrtcAudioConduit();
+ if(obj->Init() != kMediaConduitNoError)
+ {
+ CSFLogError(logTag, "%s AudioConduit Init Failed ", __FUNCTION__);
+ delete obj;
+ return nullptr;
+ }
+ CSFLogDebug(logTag, "%s Successfully created AudioConduit ", __FUNCTION__);
+ return obj;
+}
+
+/**
+ * Destruction defines for our super-classes
+ */
+WebrtcAudioConduit::~WebrtcAudioConduit()
+{
+ NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
+
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+ for(std::vector<AudioCodecConfig*>::size_type i=0;i < mRecvCodecList.size();i++)
+ {
+ delete mRecvCodecList[i];
+ }
+
+ // The first one of a pair to be deleted shuts down media for both
+ if(mPtrVoEXmedia)
+ {
+ mPtrVoEXmedia->SetExternalRecordingStatus(false);
+ mPtrVoEXmedia->SetExternalPlayoutStatus(false);
+ }
+
+ //Deal with the transport
+ if(mPtrVoENetwork)
+ {
+ mPtrVoENetwork->DeRegisterExternalTransport(mChannel);
+ }
+
+ if(mPtrVoEBase)
+ {
+ mPtrVoEBase->StopPlayout(mChannel);
+ mPtrVoEBase->StopSend(mChannel);
+ mPtrVoEBase->StopReceive(mChannel);
+ mPtrVoEBase->DeleteChannel(mChannel);
+ mPtrVoEBase->Terminate();
+ }
+
+ // We shouldn't delete the VoiceEngine until all these are released!
+ // And we can't use a Scoped ptr, since the order is arbitrary
+ mPtrVoENetwork = nullptr;
+ mPtrVoEBase = nullptr;
+ mPtrVoECodec = nullptr;
+ mPtrVoEXmedia = nullptr;
+ mPtrVoEProcessing = nullptr;
+ mPtrVoEVideoSync = nullptr;
+ mPtrVoERTP_RTCP = nullptr;
+ mPtrRTP = nullptr;
+
+ if(mVoiceEngine)
+ {
+ webrtc::VoiceEngine::Delete(mVoiceEngine);
+ }
+}
+
+bool WebrtcAudioConduit::SetLocalSSRC(unsigned int ssrc)
+{
+ unsigned int oldSsrc;
+ if (!GetLocalSSRC(&oldSsrc)) {
+ MOZ_ASSERT(false, "GetLocalSSRC failed");
+ return false;
+ }
+
+ if (oldSsrc == ssrc) {
+ return true;
+ }
+
+ bool wasTransmitting = mEngineTransmitting;
+ if (StopTransmitting() != kMediaConduitNoError) {
+ return false;
+ }
+
+ if (mPtrRTP->SetLocalSSRC(mChannel, ssrc)) {
+ return false;
+ }
+
+ if (wasTransmitting) {
+ if (StartTransmitting() != kMediaConduitNoError) {
+ return false;
+ }
+ }
+ return true;
+}
+
+bool WebrtcAudioConduit::GetLocalSSRC(unsigned int* ssrc) {
+ return !mPtrRTP->GetLocalSSRC(mChannel, *ssrc);
+}
+
+bool WebrtcAudioConduit::GetRemoteSSRC(unsigned int* ssrc) {
+ return !mPtrRTP->GetRemoteSSRC(mChannel, *ssrc);
+}
+
+bool WebrtcAudioConduit::SetLocalCNAME(const char* cname)
+{
+ char temp[256];
+ strncpy(temp, cname, sizeof(temp) - 1);
+ temp[sizeof(temp) - 1] = 0;
+ return !mPtrRTP->SetRTCP_CNAME(mChannel, temp);
+}
+
+bool WebrtcAudioConduit::GetAVStats(int32_t* jitterBufferDelayMs,
+ int32_t* playoutBufferDelayMs,
+ int32_t* avSyncOffsetMs) {
+ return !mPtrVoEVideoSync->GetDelayEstimate(mChannel,
+ jitterBufferDelayMs,
+ playoutBufferDelayMs,
+ avSyncOffsetMs);
+}
+
+bool WebrtcAudioConduit::GetRTPStats(unsigned int* jitterMs,
+ unsigned int* cumulativeLost) {
+ unsigned int maxJitterMs = 0;
+ unsigned int discardedPackets;
+ *jitterMs = 0;
+ *cumulativeLost = 0;
+ return !mPtrRTP->GetRTPStatistics(mChannel, *jitterMs, maxJitterMs,
+ discardedPackets, *cumulativeLost);
+}
+
+DOMHighResTimeStamp
+NTPtoDOMHighResTimeStamp(uint32_t ntpHigh, uint32_t ntpLow) {
+ return (uint32_t(ntpHigh - webrtc::kNtpJan1970) +
+ double(ntpLow) / webrtc::kMagicNtpFractionalUnit) * 1000;
+}
+
+bool WebrtcAudioConduit::GetRTCPReceiverReport(DOMHighResTimeStamp* timestamp,
+ uint32_t* jitterMs,
+ uint32_t* packetsReceived,
+ uint64_t* bytesReceived,
+ uint32_t* cumulativeLost,
+ int32_t* rttMs) {
+ uint32_t ntpHigh, ntpLow;
+ uint16_t fractionLost;
+ bool result = !mPtrRTP->GetRemoteRTCPReceiverInfo(mChannel, ntpHigh, ntpLow,
+ *packetsReceived,
+ *bytesReceived,
+ *jitterMs,
+ fractionLost,
+ *cumulativeLost,
+ *rttMs);
+ if (result) {
+ *timestamp = NTPtoDOMHighResTimeStamp(ntpHigh, ntpLow);
+ }
+ return result;
+}
+
+bool WebrtcAudioConduit::GetRTCPSenderReport(DOMHighResTimeStamp* timestamp,
+ unsigned int* packetsSent,
+ uint64_t* bytesSent) {
+ webrtc::RTCPSenderInfo senderInfo;
+ webrtc::RtpRtcp * rtpRtcpModule;
+ webrtc::RtpReceiver * rtp_receiver;
+ bool result =
+ !mPtrVoEVideoSync->GetRtpRtcp(mChannel,&rtpRtcpModule,&rtp_receiver) &&
+ !rtpRtcpModule->RemoteRTCPStat(&senderInfo);
+ if (result){
+ *timestamp = NTPtoDOMHighResTimeStamp(senderInfo.NTPseconds,
+ senderInfo.NTPfraction);
+ *packetsSent = senderInfo.sendPacketCount;
+ *bytesSent = senderInfo.sendOctetCount;
+ }
+ return result;
+ }
+
+bool WebrtcAudioConduit::SetDtmfPayloadType(unsigned char type) {
+ CSFLogInfo(logTag, "%s : setting dtmf payload %d", __FUNCTION__, (int)type);
+
+ ScopedCustomReleasePtr<webrtc::VoEDtmf> mPtrVoEDtmf;
+ mPtrVoEDtmf = webrtc::VoEDtmf::GetInterface(mVoiceEngine);
+ if (!mPtrVoEDtmf) {
+ CSFLogError(logTag, "%s Unable to initialize VoEDtmf", __FUNCTION__);
+ return false;
+ }
+
+ int result = mPtrVoEDtmf->SetSendTelephoneEventPayloadType(mChannel, type);
+ if (result == -1) {
+ CSFLogError(logTag, "%s Failed call to SetSendTelephoneEventPayloadType",
+ __FUNCTION__);
+ }
+ return result != -1;
+}
+
+bool WebrtcAudioConduit::InsertDTMFTone(int channel, int eventCode,
+ bool outOfBand, int lengthMs,
+ int attenuationDb) {
+ NS_ASSERTION(!NS_IsMainThread(), "Do not call on main thread");
+
+ if (!mVoiceEngine || !mDtmfEnabled) {
+ return false;
+ }
+
+ webrtc::VoiceEngineImpl* s = static_cast<webrtc::VoiceEngineImpl*>(mVoiceEngine);
+ int result = s->SendTelephoneEvent(channel, eventCode, outOfBand, lengthMs, attenuationDb);
+ return result != -1;
+}
+
+/*
+ * WebRTCAudioConduit Implementation
+ */
+MediaConduitErrorCode WebrtcAudioConduit::Init()
+{
+ CSFLogDebug(logTag, "%s this=%p", __FUNCTION__, this);
+
+#ifdef MOZ_WIDGET_ANDROID
+ jobject context = jsjni_GetGlobalContextRef();
+ // get the JVM
+ JavaVM *jvm = jsjni_GetVM();
+
+ if (webrtc::VoiceEngine::SetAndroidObjects(jvm, (void*)context) != 0) {
+ CSFLogError(logTag, "%s Unable to set Android objects", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+#endif
+
+ // Per WebRTC APIs below function calls return nullptr on failure
+ if(!(mVoiceEngine = webrtc::VoiceEngine::Create()))
+ {
+ CSFLogError(logTag, "%s Unable to create voice engine", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+
+ if(!(mPtrVoEBase = VoEBase::GetInterface(mVoiceEngine)))
+ {
+ CSFLogError(logTag, "%s Unable to initialize VoEBase", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+
+ if(!(mPtrVoENetwork = VoENetwork::GetInterface(mVoiceEngine)))
+ {
+ CSFLogError(logTag, "%s Unable to initialize VoENetwork", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+
+ if(!(mPtrVoECodec = VoECodec::GetInterface(mVoiceEngine)))
+ {
+ CSFLogError(logTag, "%s Unable to initialize VoEBCodec", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+
+ if(!(mPtrVoEProcessing = VoEAudioProcessing::GetInterface(mVoiceEngine)))
+ {
+ CSFLogError(logTag, "%s Unable to initialize VoEProcessing", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+ if(!(mPtrVoEXmedia = VoEExternalMedia::GetInterface(mVoiceEngine)))
+ {
+ CSFLogError(logTag, "%s Unable to initialize VoEExternalMedia", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+ if(!(mPtrVoERTP_RTCP = VoERTP_RTCP::GetInterface(mVoiceEngine)))
+ {
+ CSFLogError(logTag, "%s Unable to initialize VoERTP_RTCP", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+
+ if(!(mPtrVoEVideoSync = VoEVideoSync::GetInterface(mVoiceEngine)))
+ {
+ CSFLogError(logTag, "%s Unable to initialize VoEVideoSync", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+ if (!(mPtrRTP = webrtc::VoERTP_RTCP::GetInterface(mVoiceEngine)))
+ {
+ CSFLogError(logTag, "%s Unable to get audio RTP/RTCP interface ",
+ __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+
+ // init the engine with our audio device layer
+ if(mPtrVoEBase->Init() == -1)
+ {
+ CSFLogError(logTag, "%s VoiceEngine Base Not Initialized", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+
+ if( (mChannel = mPtrVoEBase->CreateChannel()) == -1)
+ {
+ CSFLogError(logTag, "%s VoiceEngine Channel creation failed",__FUNCTION__);
+ return kMediaConduitChannelError;
+ }
+
+ CSFLogDebug(logTag, "%s Channel Created %d ",__FUNCTION__, mChannel);
+
+ if(mPtrVoENetwork->RegisterExternalTransport(mChannel, *this) == -1)
+ {
+ CSFLogError(logTag, "%s VoiceEngine, External Transport Failed",__FUNCTION__);
+ return kMediaConduitTransportRegistrationFail;
+ }
+
+ if(mPtrVoEXmedia->SetExternalRecordingStatus(true) == -1)
+ {
+ CSFLogError(logTag, "%s SetExternalRecordingStatus Failed %d",__FUNCTION__,
+ mPtrVoEBase->LastError());
+ return kMediaConduitExternalPlayoutError;
+ }
+
+ if(mPtrVoEXmedia->SetExternalPlayoutStatus(true) == -1)
+ {
+ CSFLogError(logTag, "%s SetExternalPlayoutStatus Failed %d ",__FUNCTION__,
+ mPtrVoEBase->LastError());
+ return kMediaConduitExternalRecordingError;
+ }
+
+ CSFLogDebug(logTag , "%s AudioSessionConduit Initialization Done (%p)",__FUNCTION__, this);
+ return kMediaConduitNoError;
+}
+
+// AudioSessionConduit Implementation
+MediaConduitErrorCode
+WebrtcAudioConduit::SetTransmitterTransport(RefPtr<TransportInterface> aTransport)
+{
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+
+ ReentrantMonitorAutoEnter enter(mTransportMonitor);
+ // set the transport
+ mTransmitterTransport = aTransport;
+ return kMediaConduitNoError;
+}
+
+MediaConduitErrorCode
+WebrtcAudioConduit::SetReceiverTransport(RefPtr<TransportInterface> aTransport)
+{
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+
+ ReentrantMonitorAutoEnter enter(mTransportMonitor);
+ // set the transport
+ mReceiverTransport = aTransport;
+ return kMediaConduitNoError;
+}
+
+MediaConduitErrorCode
+WebrtcAudioConduit::ConfigureSendMediaCodec(const AudioCodecConfig* codecConfig)
+{
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+ MediaConduitErrorCode condError = kMediaConduitNoError;
+ int error = 0;//webrtc engine errors
+ webrtc::CodecInst cinst;
+
+ {
+ //validate codec param
+ if((condError = ValidateCodecConfig(codecConfig, true)) != kMediaConduitNoError)
+ {
+ return condError;
+ }
+ }
+
+ condError = StopTransmitting();
+ if (condError != kMediaConduitNoError) {
+ return condError;
+ }
+
+ if(!CodecConfigToWebRTCCodec(codecConfig,cinst))
+ {
+ CSFLogError(logTag,"%s CodecConfig to WebRTC Codec Failed ",__FUNCTION__);
+ return kMediaConduitMalformedArgument;
+ }
+
+ if(mPtrVoECodec->SetSendCodec(mChannel, cinst) == -1)
+ {
+ error = mPtrVoEBase->LastError();
+ CSFLogError(logTag, "%s SetSendCodec - Invalid Codec %d ",__FUNCTION__,
+ error);
+
+ if(error == VE_CANNOT_SET_SEND_CODEC || error == VE_CODEC_ERROR)
+ {
+ CSFLogError(logTag, "%s Invalid Send Codec", __FUNCTION__);
+ return kMediaConduitInvalidSendCodec;
+ }
+ CSFLogError(logTag, "%s SetSendCodec Failed %d ", __FUNCTION__,
+ mPtrVoEBase->LastError());
+ return kMediaConduitUnknownError;
+ }
+
+ // This must be called after SetSendCodec
+ if (mPtrVoECodec->SetFECStatus(mChannel, codecConfig->mFECEnabled) == -1) {
+ CSFLogError(logTag, "%s SetFECStatus Failed %d ", __FUNCTION__,
+ mPtrVoEBase->LastError());
+ return kMediaConduitFECStatusError;
+ }
+
+ mDtmfEnabled = codecConfig->mDtmfEnabled;
+
+ if (codecConfig->mName == "opus" && codecConfig->mMaxPlaybackRate) {
+ if (mPtrVoECodec->SetOpusMaxPlaybackRate(
+ mChannel,
+ codecConfig->mMaxPlaybackRate) == -1) {
+ CSFLogError(logTag, "%s SetOpusMaxPlaybackRate Failed %d ", __FUNCTION__,
+ mPtrVoEBase->LastError());
+ return kMediaConduitUnknownError;
+ }
+ }
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ // TEMPORARY - see bug 694814 comment 2
+ nsresult rv;
+ nsCOMPtr<nsIPrefService> prefs = do_GetService("@mozilla.org/preferences-service;1", &rv);
+ if (NS_SUCCEEDED(rv)) {
+ nsCOMPtr<nsIPrefBranch> branch = do_QueryInterface(prefs);
+
+ if (branch) {
+ branch->GetIntPref("media.peerconnection.capture_delay", &mCaptureDelay);
+ }
+ }
+#endif
+
+ condError = StartTransmitting();
+ if (condError != kMediaConduitNoError) {
+ return condError;
+ }
+
+ {
+ MutexAutoLock lock(mCodecMutex);
+
+ //Copy the applied config for future reference.
+ mCurSendCodecConfig = new AudioCodecConfig(codecConfig->mType,
+ codecConfig->mName,
+ codecConfig->mFreq,
+ codecConfig->mPacSize,
+ codecConfig->mChannels,
+ codecConfig->mRate,
+ codecConfig->mFECEnabled);
+ }
+ return kMediaConduitNoError;
+}
+
+MediaConduitErrorCode
+WebrtcAudioConduit::ConfigureRecvMediaCodecs(
+ const std::vector<AudioCodecConfig*>& codecConfigList)
+{
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+ MediaConduitErrorCode condError = kMediaConduitNoError;
+ int error = 0; //webrtc engine errors
+ bool success = false;
+
+ // Are we receiving already? If so, stop receiving and playout
+ // since we can't apply new recv codec when the engine is playing.
+ condError = StopReceiving();
+ if (condError != kMediaConduitNoError) {
+ return condError;
+ }
+
+ if(codecConfigList.empty())
+ {
+ CSFLogError(logTag, "%s Zero number of codecs to configure", __FUNCTION__);
+ return kMediaConduitMalformedArgument;
+ }
+
+ // Try Applying the codecs in the list.
+ // We succeed if at least one codec was applied and reception was
+ // started successfully.
+ for(std::vector<AudioCodecConfig*>::size_type i=0 ;i<codecConfigList.size();i++)
+ {
+ //if the codec param is invalid or diplicate, return error
+ if((condError = ValidateCodecConfig(codecConfigList[i],false)) != kMediaConduitNoError)
+ {
+ return condError;
+ }
+
+ webrtc::CodecInst cinst;
+ if(!CodecConfigToWebRTCCodec(codecConfigList[i],cinst))
+ {
+ CSFLogError(logTag,"%s CodecConfig to WebRTC Codec Failed ",__FUNCTION__);
+ continue;
+ }
+
+ if(mPtrVoECodec->SetRecPayloadType(mChannel,cinst) == -1)
+ {
+ error = mPtrVoEBase->LastError();
+ CSFLogError(logTag, "%s SetRecvCodec Failed %d ",__FUNCTION__, error);
+ continue;
+ } else {
+ CSFLogDebug(logTag, "%s Successfully Set RecvCodec %s", __FUNCTION__,
+ codecConfigList[i]->mName.c_str());
+ //copy this to local database
+ if(CopyCodecToDB(codecConfigList[i]))
+ {
+ success = true;
+ } else {
+ CSFLogError(logTag,"%s Unable to updated Codec Database", __FUNCTION__);
+ return kMediaConduitUnknownError;
+ }
+
+ }
+
+ } //end for
+
+ if(!success)
+ {
+ CSFLogError(logTag, "%s Setting Receive Codec Failed ", __FUNCTION__);
+ return kMediaConduitInvalidReceiveCodec;
+ }
+
+ //If we are here, atleast one codec should have been set
+ condError = StartReceiving();
+ if (condError != kMediaConduitNoError) {
+ return condError;
+ }
+
+ DumpCodecDB();
+ return kMediaConduitNoError;
+}
+MediaConduitErrorCode
+WebrtcAudioConduit::EnableAudioLevelExtension(bool enabled, uint8_t id)
+{
+ CSFLogDebug(logTag, "%s %d %d ", __FUNCTION__, enabled, id);
+
+ if (mPtrVoERTP_RTCP->SetSendAudioLevelIndicationStatus(mChannel, enabled, id) == -1)
+ {
+ CSFLogError(logTag, "%s SetSendAudioLevelIndicationStatus Failed", __FUNCTION__);
+ return kMediaConduitUnknownError;
+ }
+
+ return kMediaConduitNoError;
+}
+
+MediaConduitErrorCode
+WebrtcAudioConduit::SendAudioFrame(const int16_t audio_data[],
+ int32_t lengthSamples,
+ int32_t samplingFreqHz,
+ int32_t capture_delay)
+{
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+ // Following checks need to be performed
+ // 1. Non null audio buffer pointer,
+ // 2. invalid sampling frequency - less than 0 or unsupported ones
+ // 3. Appropriate Sample Length for 10 ms audio-frame. This represents
+ // block size the VoiceEngine feeds into encoder for passed in audio-frame
+ // Ex: for 16000 sampling rate , valid block-length is 160
+ // Similarly for 32000 sampling rate, valid block length is 320
+ // We do the check by the verify modular operator below to be zero
+
+ if(!audio_data || (lengthSamples <= 0) ||
+ (IsSamplingFreqSupported(samplingFreqHz) == false) ||
+ ((lengthSamples % (samplingFreqHz / 100) != 0)) )
+ {
+ CSFLogError(logTag, "%s Invalid Parameters ",__FUNCTION__);
+ MOZ_ASSERT(PR_FALSE);
+ return kMediaConduitMalformedArgument;
+ }
+
+ //validate capture time
+ if(capture_delay < 0 )
+ {
+ CSFLogError(logTag,"%s Invalid Capture Delay ", __FUNCTION__);
+ MOZ_ASSERT(PR_FALSE);
+ return kMediaConduitMalformedArgument;
+ }
+
+ // if transmission is not started .. conduit cannot insert frames
+ if(!mEngineTransmitting)
+ {
+ CSFLogError(logTag, "%s Engine not transmitting ", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ if (MOZ_LOG_TEST(GetLatencyLog(), LogLevel::Debug)) {
+ struct Processing insert = { TimeStamp::Now(), 0 };
+ mProcessing.AppendElement(insert);
+ }
+#endif
+
+ capture_delay = mCaptureDelay;
+ //Insert the samples
+ if(mPtrVoEXmedia->ExternalRecordingInsertData(audio_data,
+ lengthSamples,
+ samplingFreqHz,
+ capture_delay) == -1)
+ {
+ int error = mPtrVoEBase->LastError();
+ CSFLogError(logTag, "%s Inserting audio data Failed %d", __FUNCTION__, error);
+ if(error == VE_RUNTIME_REC_ERROR)
+ {
+ return kMediaConduitRecordingError;
+ }
+ return kMediaConduitUnknownError;
+ }
+ // we should be good here
+ return kMediaConduitNoError;
+}
+
+MediaConduitErrorCode
+WebrtcAudioConduit::GetAudioFrame(int16_t speechData[],
+ int32_t samplingFreqHz,
+ int32_t capture_delay,
+ int& lengthSamples)
+{
+
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+ unsigned int numSamples = 0;
+
+ //validate params
+ if(!speechData )
+ {
+ CSFLogError(logTag,"%s Null Audio Buffer Pointer", __FUNCTION__);
+ MOZ_ASSERT(PR_FALSE);
+ return kMediaConduitMalformedArgument;
+ }
+
+ // Validate sample length
+ if((numSamples = GetNum10msSamplesForFrequency(samplingFreqHz)) == 0 )
+ {
+ CSFLogError(logTag,"%s Invalid Sampling Frequency ", __FUNCTION__);
+ MOZ_ASSERT(PR_FALSE);
+ return kMediaConduitMalformedArgument;
+ }
+
+ //validate capture time
+ if(capture_delay < 0 )
+ {
+ CSFLogError(logTag,"%s Invalid Capture Delay ", __FUNCTION__);
+ MOZ_ASSERT(PR_FALSE);
+ return kMediaConduitMalformedArgument;
+ }
+
+ //Conduit should have reception enabled before we ask for decoded
+ // samples
+ if(!mEngineReceiving)
+ {
+ CSFLogError(logTag, "%s Engine not Receiving ", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+
+
+ lengthSamples = 0; //output paramter
+
+ if(mPtrVoEXmedia->ExternalPlayoutGetData( speechData,
+ samplingFreqHz,
+ capture_delay,
+ lengthSamples) == -1)
+ {
+ int error = mPtrVoEBase->LastError();
+ CSFLogError(logTag, "%s Getting audio data Failed %d", __FUNCTION__, error);
+ if(error == VE_RUNTIME_PLAY_ERROR)
+ {
+ return kMediaConduitPlayoutError;
+ }
+ return kMediaConduitUnknownError;
+ }
+
+ // Not #ifdef DEBUG or on a log module so we can use it for about:webrtc/etc
+ mSamples += lengthSamples;
+ if (mSamples >= mLastSyncLog + samplingFreqHz) {
+ int jitter_buffer_delay_ms;
+ int playout_buffer_delay_ms;
+ int avsync_offset_ms;
+ if (GetAVStats(&jitter_buffer_delay_ms,
+ &playout_buffer_delay_ms,
+ &avsync_offset_ms)) {
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ if (avsync_offset_ms < 0) {
+ Telemetry::Accumulate(Telemetry::WEBRTC_AVSYNC_WHEN_VIDEO_LAGS_AUDIO_MS,
+ -avsync_offset_ms);
+ } else {
+ Telemetry::Accumulate(Telemetry::WEBRTC_AVSYNC_WHEN_AUDIO_LAGS_VIDEO_MS,
+ avsync_offset_ms);
+ }
+#endif
+ CSFLogError(logTag,
+ "A/V sync: sync delta: %dms, audio jitter delay %dms, playout delay %dms",
+ avsync_offset_ms, jitter_buffer_delay_ms, playout_buffer_delay_ms);
+ } else {
+ CSFLogError(logTag, "A/V sync: GetAVStats failed");
+ }
+ mLastSyncLog = mSamples;
+ }
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ if (MOZ_LOG_TEST(GetLatencyLog(), LogLevel::Debug)) {
+ if (mProcessing.Length() > 0) {
+ unsigned int now;
+ mPtrVoEVideoSync->GetPlayoutTimestamp(mChannel, now);
+ if (static_cast<uint32_t>(now) != mLastTimestamp) {
+ mLastTimestamp = static_cast<uint32_t>(now);
+ // Find the block that includes this timestamp in the network input
+ while (mProcessing.Length() > 0) {
+ // FIX! assumes 20ms @ 48000Hz
+ // FIX handle wrap-around
+ if (mProcessing[0].mRTPTimeStamp + 20*(48000/1000) >= now) {
+ TimeDuration t = TimeStamp::Now() - mProcessing[0].mTimeStamp;
+ // Wrap-around?
+ int64_t delta = t.ToMilliseconds() + (now - mProcessing[0].mRTPTimeStamp)/(48000/1000);
+ LogTime(AsyncLatencyLogger::AudioRecvRTP, ((uint64_t) this), delta);
+ break;
+ }
+ mProcessing.RemoveElementAt(0);
+ }
+ }
+ }
+ }
+#endif
+ CSFLogDebug(logTag,"%s GetAudioFrame:Got samples: length %d ",__FUNCTION__,
+ lengthSamples);
+ return kMediaConduitNoError;
+}
+
+// Transport Layer Callbacks
+MediaConduitErrorCode
+WebrtcAudioConduit::ReceivedRTPPacket(const void *data, int len)
+{
+ CSFLogDebug(logTag, "%s : channel %d", __FUNCTION__, mChannel);
+
+ if(mEngineReceiving)
+ {
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ if (MOZ_LOG_TEST(GetLatencyLog(), LogLevel::Debug)) {
+ // timestamp is at 32 bits in ([1])
+ struct Processing insert = { TimeStamp::Now(),
+ ntohl(static_cast<const uint32_t *>(data)[1]) };
+ mProcessing.AppendElement(insert);
+ }
+#endif
+
+ // XXX we need to get passed the time the packet was received
+ if(mPtrVoENetwork->ReceivedRTPPacket(mChannel, data, len) == -1)
+ {
+ int error = mPtrVoEBase->LastError();
+ CSFLogError(logTag, "%s RTP Processing Error %d", __FUNCTION__, error);
+ if(error == VE_RTP_RTCP_MODULE_ERROR)
+ {
+ return kMediaConduitRTPRTCPModuleError;
+ }
+ return kMediaConduitUnknownError;
+ }
+ } else {
+ CSFLogError(logTag, "Error: %s when not receiving", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+
+ return kMediaConduitNoError;
+}
+
+MediaConduitErrorCode
+WebrtcAudioConduit::ReceivedRTCPPacket(const void *data, int len)
+{
+ CSFLogDebug(logTag, "%s : channel %d",__FUNCTION__, mChannel);
+
+ if(mPtrVoENetwork->ReceivedRTCPPacket(mChannel, data, len) == -1)
+ {
+ int error = mPtrVoEBase->LastError();
+ CSFLogError(logTag, "%s RTCP Processing Error %d", __FUNCTION__, error);
+ if(error == VE_RTP_RTCP_MODULE_ERROR)
+ {
+ return kMediaConduitRTPRTCPModuleError;
+ }
+ return kMediaConduitUnknownError;
+ }
+ return kMediaConduitNoError;
+}
+
+MediaConduitErrorCode
+WebrtcAudioConduit::StopTransmitting()
+{
+ if(mEngineTransmitting)
+ {
+ CSFLogDebug(logTag, "%s Engine Already Sending. Attemping to Stop ", __FUNCTION__);
+ if(mPtrVoEBase->StopSend(mChannel) == -1)
+ {
+ CSFLogError(logTag, "%s StopSend() Failed %d ", __FUNCTION__,
+ mPtrVoEBase->LastError());
+ return kMediaConduitUnknownError;
+ }
+ mEngineTransmitting = false;
+ }
+
+ return kMediaConduitNoError;
+}
+
+MediaConduitErrorCode
+WebrtcAudioConduit::StartTransmitting()
+{
+ if (!mEngineTransmitting) {
+ //Let's Send Transport State-machine on the Engine
+ if(mPtrVoEBase->StartSend(mChannel) == -1)
+ {
+ int error = mPtrVoEBase->LastError();
+ CSFLogError(logTag, "%s StartSend failed %d", __FUNCTION__, error);
+ return kMediaConduitUnknownError;
+ }
+ mEngineTransmitting = true;
+ }
+
+ return kMediaConduitNoError;
+}
+
+MediaConduitErrorCode
+WebrtcAudioConduit::StopReceiving()
+{
+ if(mEngineReceiving)
+ {
+ CSFLogDebug(logTag, "%s Engine Already Receiving. Attemping to Stop ", __FUNCTION__);
+ // AudioEngine doesn't fail fatally on stopping reception. Ref:voe_errors.h.
+ // hence we need not be strict in failing here on errors
+ mPtrVoEBase->StopReceive(mChannel);
+ CSFLogDebug(logTag, "%s Attemping to Stop playout ", __FUNCTION__);
+ if(mPtrVoEBase->StopPlayout(mChannel) == -1)
+ {
+ if( mPtrVoEBase->LastError() == VE_CANNOT_STOP_PLAYOUT)
+ {
+ CSFLogDebug(logTag, "%s Stop-Playout Failed %d", __FUNCTION__, mPtrVoEBase->LastError());
+ return kMediaConduitPlayoutError;
+ }
+ }
+ mEngineReceiving = false;
+ }
+
+ return kMediaConduitNoError;
+}
+
+MediaConduitErrorCode
+WebrtcAudioConduit::StartReceiving()
+{
+ if (!mEngineReceiving) {
+ if(mPtrVoEBase->StartReceive(mChannel) == -1)
+ {
+ int error = mPtrVoEBase->LastError();
+ CSFLogError(logTag , "%s StartReceive Failed %d ",__FUNCTION__, error);
+ if(error == VE_RECV_SOCKET_ERROR)
+ {
+ return kMediaConduitSocketError;
+ }
+ return kMediaConduitUnknownError;
+ }
+
+
+ if(mPtrVoEBase->StartPlayout(mChannel) == -1)
+ {
+ CSFLogError(logTag, "%s Starting playout Failed", __FUNCTION__);
+ return kMediaConduitPlayoutError;
+ }
+ mEngineReceiving = true;
+ }
+
+ return kMediaConduitNoError;
+}
+
+//WebRTC::RTP Callback Implementation
+// Called on AudioGUM or MSG thread
+int WebrtcAudioConduit::SendPacket(int channel, const void* data, size_t len)
+{
+ CSFLogDebug(logTag, "%s : channel %d", __FUNCTION__, channel);
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ if (MOZ_LOG_TEST(GetLatencyLog(), LogLevel::Debug)) {
+ if (mProcessing.Length() > 0) {
+ TimeStamp started = mProcessing[0].mTimeStamp;
+ mProcessing.RemoveElementAt(0);
+ mProcessing.RemoveElementAt(0); // 20ms packetization! Could automate this by watching sizes
+ TimeDuration t = TimeStamp::Now() - started;
+ int64_t delta = t.ToMilliseconds();
+ LogTime(AsyncLatencyLogger::AudioSendRTP, ((uint64_t) this), delta);
+ }
+ }
+#endif
+ ReentrantMonitorAutoEnter enter(mTransportMonitor);
+ if(mTransmitterTransport &&
+ (mTransmitterTransport->SendRtpPacket(data, len) == NS_OK))
+ {
+ CSFLogDebug(logTag, "%s Sent RTP Packet ", __FUNCTION__);
+ return len;
+ } else {
+ CSFLogError(logTag, "%s RTP Packet Send Failed ", __FUNCTION__);
+ return -1;
+ }
+}
+
+// Called on WebRTC Process thread and perhaps others
+int WebrtcAudioConduit::SendRTCPPacket(int channel, const void* data, size_t len)
+{
+ CSFLogDebug(logTag, "%s : channel %d , len %lu, first rtcp = %u ",
+ __FUNCTION__,
+ channel,
+ (unsigned long) len,
+ static_cast<unsigned>(((uint8_t *) data)[1]));
+
+ // We come here if we have only one pipeline/conduit setup,
+ // such as for unidirectional streams.
+ // We also end up here if we are receiving
+ ReentrantMonitorAutoEnter enter(mTransportMonitor);
+ if(mReceiverTransport &&
+ mReceiverTransport->SendRtcpPacket(data, len) == NS_OK)
+ {
+ // Might be a sender report, might be a receiver report, we don't know.
+ CSFLogDebug(logTag, "%s Sent RTCP Packet ", __FUNCTION__);
+ return len;
+ } else if(mTransmitterTransport &&
+ (mTransmitterTransport->SendRtcpPacket(data, len) == NS_OK)) {
+ CSFLogDebug(logTag, "%s Sent RTCP Packet (sender report) ", __FUNCTION__);
+ return len;
+ } else {
+ CSFLogError(logTag, "%s RTCP Packet Send Failed ", __FUNCTION__);
+ return -1;
+ }
+}
+
+/**
+ * Converts between CodecConfig to WebRTC Codec Structure.
+ */
+
+bool
+WebrtcAudioConduit::CodecConfigToWebRTCCodec(const AudioCodecConfig* codecInfo,
+ webrtc::CodecInst& cinst)
+ {
+ const unsigned int plNameLength = codecInfo->mName.length();
+ memset(&cinst, 0, sizeof(webrtc::CodecInst));
+ if(sizeof(cinst.plname) < plNameLength+1)
+ {
+ CSFLogError(logTag, "%s Payload name buffer capacity mismatch ",
+ __FUNCTION__);
+ return false;
+ }
+ memcpy(cinst.plname, codecInfo->mName.c_str(), plNameLength);
+ cinst.plname[plNameLength]='\0';
+ cinst.pltype = codecInfo->mType;
+ cinst.rate = codecInfo->mRate;
+ cinst.pacsize = codecInfo->mPacSize;
+ cinst.plfreq = codecInfo->mFreq;
+ if (codecInfo->mName == "G722") {
+ // Compensate for G.722 spec error in RFC 1890
+ cinst.plfreq = 16000;
+ }
+ cinst.channels = codecInfo->mChannels;
+ return true;
+ }
+
+/**
+ * Supported Sampling Frequncies.
+ */
+bool
+WebrtcAudioConduit::IsSamplingFreqSupported(int freq) const
+{
+ if(GetNum10msSamplesForFrequency(freq))
+ {
+ return true;
+ } else {
+ return false;
+ }
+}
+
+/* Return block-length of 10 ms audio frame in number of samples */
+unsigned int
+WebrtcAudioConduit::GetNum10msSamplesForFrequency(int samplingFreqHz) const
+{
+ switch(samplingFreqHz)
+ {
+ case 16000: return 160; //160 samples
+ case 32000: return 320; //320 samples
+ case 44100: return 441; //441 samples
+ case 48000: return 480; //480 samples
+ default: return 0; // invalid or unsupported
+ }
+}
+
+//Copy the codec passed into Conduit's database
+bool
+WebrtcAudioConduit::CopyCodecToDB(const AudioCodecConfig* codecInfo)
+{
+
+ AudioCodecConfig* cdcConfig = new AudioCodecConfig(codecInfo->mType,
+ codecInfo->mName,
+ codecInfo->mFreq,
+ codecInfo->mPacSize,
+ codecInfo->mChannels,
+ codecInfo->mRate,
+ codecInfo->mFECEnabled);
+ mRecvCodecList.push_back(cdcConfig);
+ return true;
+}
+
+/**
+ * Checks if 2 codec structs are same
+ */
+bool
+WebrtcAudioConduit::CheckCodecsForMatch(const AudioCodecConfig* curCodecConfig,
+ const AudioCodecConfig* codecInfo) const
+{
+ if(!curCodecConfig)
+ {
+ return false;
+ }
+
+ if(curCodecConfig->mType == codecInfo->mType &&
+ (curCodecConfig->mName.compare(codecInfo->mName) == 0) &&
+ curCodecConfig->mFreq == codecInfo->mFreq &&
+ curCodecConfig->mPacSize == codecInfo->mPacSize &&
+ curCodecConfig->mChannels == codecInfo->mChannels &&
+ curCodecConfig->mRate == codecInfo->mRate)
+ {
+ return true;
+ }
+
+ return false;
+}
+
+/**
+ * Checks if the codec is already in Conduit's database
+ */
+bool
+WebrtcAudioConduit::CheckCodecForMatch(const AudioCodecConfig* codecInfo) const
+{
+ //the db should have atleast one codec
+ for(std::vector<AudioCodecConfig*>::size_type i=0;i < mRecvCodecList.size();i++)
+ {
+ if(CheckCodecsForMatch(mRecvCodecList[i],codecInfo))
+ {
+ //match
+ return true;
+ }
+ }
+ //no match or empty local db
+ return false;
+}
+
+
+/**
+ * Perform validation on the codecConfig to be applied.
+ * Verifies if the codec is already applied.
+ */
+MediaConduitErrorCode
+WebrtcAudioConduit::ValidateCodecConfig(const AudioCodecConfig* codecInfo,
+ bool send)
+{
+ bool codecAppliedAlready = false;
+
+ if(!codecInfo)
+ {
+ CSFLogError(logTag, "%s Null CodecConfig ", __FUNCTION__);
+ return kMediaConduitMalformedArgument;
+ }
+
+ if((codecInfo->mName.empty()) ||
+ (codecInfo->mName.length() >= CODEC_PLNAME_SIZE))
+ {
+ CSFLogError(logTag, "%s Invalid Payload Name Length ", __FUNCTION__);
+ return kMediaConduitMalformedArgument;
+ }
+
+ //Only mono or stereo channels supported
+ if( (codecInfo->mChannels != 1) && (codecInfo->mChannels != 2))
+ {
+ CSFLogError(logTag, "%s Channel Unsupported ", __FUNCTION__);
+ return kMediaConduitMalformedArgument;
+ }
+
+ //check if we have the same codec already applied
+ if(send)
+ {
+ MutexAutoLock lock(mCodecMutex);
+
+ codecAppliedAlready = CheckCodecsForMatch(mCurSendCodecConfig,codecInfo);
+ } else {
+ codecAppliedAlready = CheckCodecForMatch(codecInfo);
+ }
+
+ if(codecAppliedAlready)
+ {
+ CSFLogDebug(logTag, "%s Codec %s Already Applied ", __FUNCTION__, codecInfo->mName.c_str());
+ }
+ return kMediaConduitNoError;
+}
+
+void
+WebrtcAudioConduit::DumpCodecDB() const
+ {
+ for(std::vector<AudioCodecConfig*>::size_type i=0;i < mRecvCodecList.size();i++)
+ {
+ CSFLogDebug(logTag,"Payload Name: %s", mRecvCodecList[i]->mName.c_str());
+ CSFLogDebug(logTag,"Payload Type: %d", mRecvCodecList[i]->mType);
+ CSFLogDebug(logTag,"Payload Frequency: %d", mRecvCodecList[i]->mFreq);
+ CSFLogDebug(logTag,"Payload PacketSize: %d", mRecvCodecList[i]->mPacSize);
+ CSFLogDebug(logTag,"Payload Channels: %d", mRecvCodecList[i]->mChannels);
+ CSFLogDebug(logTag,"Payload Sampling Rate: %d", mRecvCodecList[i]->mRate);
+ }
+ }
+}// end namespace
diff --git a/media/webrtc/signaling/src/media-conduit/AudioConduit.h b/media/webrtc/signaling/src/media-conduit/AudioConduit.h
new file mode 100755
index 000000000..228736dcc
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/AudioConduit.h
@@ -0,0 +1,304 @@
+/* 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/. */
+
+
+#ifndef AUDIO_SESSION_H_
+#define AUDIO_SESSION_H_
+
+#include "mozilla/Attributes.h"
+#include "mozilla/TimeStamp.h"
+#include "nsTArray.h"
+
+#include "MediaConduitInterface.h"
+#include "MediaEngineWrapper.h"
+
+// Audio Engine Includes
+#include "webrtc/common_types.h"
+#include "webrtc/voice_engine/include/voe_base.h"
+#include "webrtc/voice_engine/include/voe_volume_control.h"
+#include "webrtc/voice_engine/include/voe_codec.h"
+#include "webrtc/voice_engine/include/voe_file.h"
+#include "webrtc/voice_engine/include/voe_network.h"
+#include "webrtc/voice_engine/include/voe_external_media.h"
+#include "webrtc/voice_engine/include/voe_audio_processing.h"
+#include "webrtc/voice_engine/include/voe_video_sync.h"
+#include "webrtc/voice_engine/include/voe_rtp_rtcp.h"
+//Some WebRTC types for short notations
+ using webrtc::VoEBase;
+ using webrtc::VoENetwork;
+ using webrtc::VoECodec;
+ using webrtc::VoEExternalMedia;
+ using webrtc::VoEAudioProcessing;
+ using webrtc::VoEVideoSync;
+ using webrtc::VoERTP_RTCP;
+/** This file hosts several structures identifying different aspects
+ * of a RTP Session.
+ */
+namespace mozilla {
+// Helper function
+
+DOMHighResTimeStamp
+NTPtoDOMHighResTimeStamp(uint32_t ntpHigh, uint32_t ntpLow);
+
+/**
+ * Concrete class for Audio session. Hooks up
+ * - media-source and target to external transport
+ */
+class WebrtcAudioConduit:public AudioSessionConduit
+ ,public webrtc::Transport
+{
+public:
+ //VoiceEngine defined constant for Payload Name Size.
+ static const unsigned int CODEC_PLNAME_SIZE;
+
+ /**
+ * APIs used by the registered external transport to this Conduit to
+ * feed in received RTP Frames to the VoiceEngine for decoding
+ */
+ virtual MediaConduitErrorCode ReceivedRTPPacket(const void *data, int len) override;
+
+ /**
+ * APIs used by the registered external transport to this Conduit to
+ * feed in received RTCP Frames to the VoiceEngine for decoding
+ */
+ virtual MediaConduitErrorCode ReceivedRTCPPacket(const void *data, int len) override;
+
+ virtual MediaConduitErrorCode StopTransmitting() override;
+ virtual MediaConduitErrorCode StartTransmitting() override;
+ virtual MediaConduitErrorCode StopReceiving() override;
+ virtual MediaConduitErrorCode StartReceiving() override;
+
+ /**
+ * Function to configure send codec for the audio session
+ * @param sendSessionConfig: CodecConfiguration
+ * @result: On Success, the audio engine is configured with passed in codec for send
+ * On failure, audio engine transmit functionality is disabled.
+ * NOTE: This API can be invoked multiple time. Invoking this API may involve restarting
+ * transmission sub-system on the engine.
+ */
+ virtual MediaConduitErrorCode ConfigureSendMediaCodec(const AudioCodecConfig* codecConfig) override;
+ /**
+ * Function to configure list of receive codecs for the audio session
+ * @param sendSessionConfig: CodecConfiguration
+ * @result: On Success, the audio engine is configured with passed in codec for send
+ * Also the playout is enabled.
+ * On failure, audio engine transmit functionality is disabled.
+ * NOTE: This API can be invoked multiple time. Invoking this API may involve restarting
+ * transmission sub-system on the engine.
+ */
+ virtual MediaConduitErrorCode ConfigureRecvMediaCodecs(
+ const std::vector<AudioCodecConfig* >& codecConfigList) override;
+ /**
+ * Function to enable the audio level extension
+ * @param enabled: enable extension
+ */
+ virtual MediaConduitErrorCode EnableAudioLevelExtension(bool enabled, uint8_t id) override;
+
+ /**
+ * Register External Transport to this Conduit. RTP and RTCP frames from the VoiceEngine
+ * shall be passed to the registered transport for transporting externally.
+ */
+ virtual MediaConduitErrorCode SetTransmitterTransport(RefPtr<TransportInterface> aTransport) override;
+
+ virtual MediaConduitErrorCode SetReceiverTransport(RefPtr<TransportInterface> aTransport) override;
+
+ /**
+ * Function to deliver externally captured audio sample for encoding and transport
+ * @param audioData [in]: Pointer to array containing a frame of audio
+ * @param lengthSamples [in]: Length of audio frame in samples in multiple of 10 milliseconds
+ * Ex: Frame length is 160, 320, 440 for 16, 32, 44 kHz sampling rates
+ respectively.
+ audioData[] should be of lengthSamples in size
+ say, for 16kz sampling rate, audioData[] should contain 160
+ samples of 16-bits each for a 10m audio frame.
+ * @param samplingFreqHz [in]: Frequency/rate of the sampling in Hz ( 16000, 32000 ...)
+ * @param capture_delay [in]: Approx Delay from recording until it is delivered to VoiceEngine
+ in milliseconds.
+ * NOTE: ConfigureSendMediaCodec() SHOULD be called before this function can be invoked
+ * This ensures the inserted audio-samples can be transmitted by the conduit
+ *
+ */
+ virtual MediaConduitErrorCode SendAudioFrame(const int16_t speechData[],
+ int32_t lengthSamples,
+ int32_t samplingFreqHz,
+ int32_t capture_time) override;
+
+ /**
+ * Function to grab a decoded audio-sample from the media engine for rendering
+ * / playoutof length 10 milliseconds.
+ *
+ * @param speechData [in]: Pointer to a array to which a 10ms frame of audio will be copied
+ * @param samplingFreqHz [in]: Frequency of the sampling for playback in Hertz (16000, 32000,..)
+ * @param capture_delay [in]: Estimated Time between reading of the samples to rendering/playback
+ * @param lengthSamples [out]: Will contain length of the audio frame in samples at return.
+ Ex: A value of 160 implies 160 samples each of 16-bits was copied
+ into speechData
+ * NOTE: This function should be invoked every 10 milliseconds for the best
+ * peformance
+ * NOTE: ConfigureRecvMediaCodec() SHOULD be called before this function can be invoked
+ * This ensures the decoded samples are ready for reading and playout is enabled.
+ *
+ */
+ virtual MediaConduitErrorCode GetAudioFrame(int16_t speechData[],
+ int32_t samplingFreqHz,
+ int32_t capture_delay,
+ int& lengthSamples) override;
+
+
+ /**
+ * Webrtc transport implementation to send and receive RTP packet.
+ * AudioConduit registers itself as ExternalTransport to the VoiceEngine
+ */
+ virtual int SendPacket(int channel, const void *data, size_t len) override;
+
+ /**
+ * Webrtc transport implementation to send and receive RTCP packet.
+ * AudioConduit registers itself as ExternalTransport to the VoiceEngine
+ */
+ virtual int SendRTCPPacket(int channel, const void *data, size_t len) override;
+
+
+ virtual uint64_t CodecPluginID() override { return 0; }
+
+ WebrtcAudioConduit():
+ mVoiceEngine(nullptr),
+ mTransportMonitor("WebrtcAudioConduit"),
+ mTransmitterTransport(nullptr),
+ mReceiverTransport(nullptr),
+ mEngineTransmitting(false),
+ mEngineReceiving(false),
+ mChannel(-1),
+ mDtmfEnabled(false),
+ mCodecMutex("AudioConduit codec db"),
+ mCaptureDelay(150),
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ mLastTimestamp(0),
+#endif // MOZILLA_INTERNAL_API
+ mSamples(0),
+ mLastSyncLog(0)
+ {
+ }
+
+ virtual ~WebrtcAudioConduit();
+
+ MediaConduitErrorCode Init();
+
+ int GetChannel() { return mChannel; }
+ webrtc::VoiceEngine* GetVoiceEngine() { return mVoiceEngine; }
+ bool SetLocalSSRC(unsigned int ssrc) override;
+ bool GetLocalSSRC(unsigned int* ssrc) override;
+ bool GetRemoteSSRC(unsigned int* ssrc) override;
+ bool SetLocalCNAME(const char* cname) override;
+ bool GetVideoEncoderStats(double* framerateMean,
+ double* framerateStdDev,
+ double* bitrateMean,
+ double* bitrateStdDev,
+ uint32_t* droppedFrames) override
+ {
+ return false;
+ }
+ bool GetVideoDecoderStats(double* framerateMean,
+ double* framerateStdDev,
+ double* bitrateMean,
+ double* bitrateStdDev,
+ uint32_t* discardedPackets) override
+ {
+ return false;
+ }
+ bool GetAVStats(int32_t* jitterBufferDelayMs,
+ int32_t* playoutBufferDelayMs,
+ int32_t* avSyncOffsetMs) override;
+ bool GetRTPStats(unsigned int* jitterMs, unsigned int* cumulativeLost) override;
+ bool GetRTCPReceiverReport(DOMHighResTimeStamp* timestamp,
+ uint32_t* jitterMs,
+ uint32_t* packetsReceived,
+ uint64_t* bytesReceived,
+ uint32_t *cumulativeLost,
+ int32_t* rttMs) override;
+ bool GetRTCPSenderReport(DOMHighResTimeStamp* timestamp,
+ unsigned int* packetsSent,
+ uint64_t* bytesSent) override;
+
+ bool SetDtmfPayloadType(unsigned char type) override;
+
+ bool InsertDTMFTone(int channel, int eventCode, bool outOfBand,
+ int lengthMs, int attenuationDb) override;
+
+private:
+ WebrtcAudioConduit(const WebrtcAudioConduit& other) = delete;
+ void operator=(const WebrtcAudioConduit& other) = delete;
+
+ //Local database of currently applied receive codecs
+ typedef std::vector<AudioCodecConfig* > RecvCodecList;
+
+ //Function to convert between WebRTC and Conduit codec structures
+ bool CodecConfigToWebRTCCodec(const AudioCodecConfig* codecInfo,
+ webrtc::CodecInst& cinst);
+
+ //Checks if given sampling frequency is supported
+ bool IsSamplingFreqSupported(int freq) const;
+
+ //Generate block size in sample lenght for a given sampling frequency
+ unsigned int GetNum10msSamplesForFrequency(int samplingFreqHz) const;
+
+ // Function to copy a codec structure to Conduit's database
+ bool CopyCodecToDB(const AudioCodecConfig* codecInfo);
+
+ // Functions to verify if the codec passed is already in
+ // conduits database
+ bool CheckCodecForMatch(const AudioCodecConfig* codecInfo) const;
+ bool CheckCodecsForMatch(const AudioCodecConfig* curCodecConfig,
+ const AudioCodecConfig* codecInfo) const;
+ //Checks the codec to be applied
+ MediaConduitErrorCode ValidateCodecConfig(const AudioCodecConfig* codecInfo, bool send);
+
+ //Utility function to dump recv codec database
+ void DumpCodecDB() const;
+
+ webrtc::VoiceEngine* mVoiceEngine;
+ mozilla::ReentrantMonitor mTransportMonitor;
+ RefPtr<TransportInterface> mTransmitterTransport;
+ RefPtr<TransportInterface> mReceiverTransport;
+ ScopedCustomReleasePtr<webrtc::VoENetwork> mPtrVoENetwork;
+ ScopedCustomReleasePtr<webrtc::VoEBase> mPtrVoEBase;
+ ScopedCustomReleasePtr<webrtc::VoECodec> mPtrVoECodec;
+ ScopedCustomReleasePtr<webrtc::VoEExternalMedia> mPtrVoEXmedia;
+ ScopedCustomReleasePtr<webrtc::VoEAudioProcessing> mPtrVoEProcessing;
+ ScopedCustomReleasePtr<webrtc::VoEVideoSync> mPtrVoEVideoSync;
+ ScopedCustomReleasePtr<webrtc::VoERTP_RTCP> mPtrVoERTP_RTCP;
+ ScopedCustomReleasePtr<webrtc::VoERTP_RTCP> mPtrRTP;
+ //engine states of our interets
+ mozilla::Atomic<bool> mEngineTransmitting; // If true => VoiceEngine Send-subsystem is up
+ mozilla::Atomic<bool> mEngineReceiving; // If true => VoiceEngine Receive-subsystem is up
+ // and playout is enabled
+ // Keep track of each inserted RTP block and the time it was inserted
+ // so we can estimate the clock time for a specific TimeStamp coming out
+ // (for when we send data to MediaStreamTracks). Blocks are aged out as needed.
+ struct Processing {
+ TimeStamp mTimeStamp;
+ uint32_t mRTPTimeStamp; // RTP timestamps received
+ };
+ AutoTArray<Processing,8> mProcessing;
+
+ int mChannel;
+ bool mDtmfEnabled;
+ RecvCodecList mRecvCodecList;
+
+ Mutex mCodecMutex; // protects mCurSendCodecConfig
+ nsAutoPtr<AudioCodecConfig> mCurSendCodecConfig;
+
+ // Current "capture" delay (really output plus input delay)
+ int32_t mCaptureDelay;
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ uint32_t mLastTimestamp;
+#endif // MOZILLA_INTERNAL_API
+
+ uint32_t mSamples;
+ uint32_t mLastSyncLog;
+};
+
+} // end namespace
+
+#endif
diff --git a/media/webrtc/signaling/src/media-conduit/CodecConfig.h b/media/webrtc/signaling/src/media-conduit/CodecConfig.h
new file mode 100755
index 000000000..308c97948
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/CodecConfig.h
@@ -0,0 +1,166 @@
+
+/* 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/. */
+
+#ifndef CODEC_CONFIG_H_
+#define CODEC_CONFIG_H_
+
+#include <string>
+#include <vector>
+
+#include "signaling/src/common/EncodingConstraints.h"
+
+namespace mozilla {
+
+/**
+ * Minimalistic Audio Codec Config Params
+ */
+struct AudioCodecConfig
+{
+ /*
+ * The data-types for these properties mimic the
+ * corresponding webrtc::CodecInst data-types.
+ */
+ int mType;
+ std::string mName;
+ int mFreq;
+ int mPacSize;
+ int mChannels;
+ int mRate;
+
+ bool mFECEnabled;
+ bool mDtmfEnabled;
+
+ // OPUS-specific
+ int mMaxPlaybackRate;
+
+ /* Default constructor is not provided since as a consumer, we
+ * can't decide the default configuration for the codec
+ */
+ explicit AudioCodecConfig(int type, std::string name,
+ int freq, int pacSize,
+ int channels, int rate, bool FECEnabled)
+ : mType(type),
+ mName(name),
+ mFreq(freq),
+ mPacSize(pacSize),
+ mChannels(channels),
+ mRate(rate),
+ mFECEnabled(FECEnabled),
+ mDtmfEnabled(false),
+ mMaxPlaybackRate(0)
+ {
+ }
+};
+
+/*
+ * Minimalistic video codec configuration
+ * More to be added later depending on the use-case
+ */
+
+#define MAX_SPROP_LEN 128
+
+// used for holding SDP negotiation results
+struct VideoCodecConfigH264
+{
+ char sprop_parameter_sets[MAX_SPROP_LEN];
+ int packetization_mode;
+ int profile_level_id;
+ int tias_bw;
+};
+
+
+// class so the std::strings can get freed more easily/reliably
+class VideoCodecConfig
+{
+public:
+ /*
+ * The data-types for these properties mimic the
+ * corresponding webrtc::VideoCodec data-types.
+ */
+ int mType; // payload type
+ std::string mName;
+
+ std::vector<std::string> mAckFbTypes;
+ std::vector<std::string> mNackFbTypes;
+ std::vector<std::string> mCcmFbTypes;
+ // Don't pass mOtherFbTypes from JsepVideoCodecDescription because we'd have
+ // to drag SdpRtcpFbAttributeList::Feedback along too.
+ bool mRembFbSet;
+ bool mFECFbSet;
+
+ EncodingConstraints mEncodingConstraints;
+ struct SimulcastEncoding {
+ std::string rid;
+ EncodingConstraints constraints;
+ };
+ std::vector<SimulcastEncoding> mSimulcastEncodings;
+ std::string mSpropParameterSets;
+ uint8_t mProfile;
+ uint8_t mConstraints;
+ uint8_t mLevel;
+ uint8_t mPacketizationMode;
+ // TODO: add external negotiated SPS/PPS
+
+ VideoCodecConfig(int type,
+ std::string name,
+ const EncodingConstraints& constraints,
+ const struct VideoCodecConfigH264 *h264 = nullptr) :
+ mType(type),
+ mName(name),
+ mFECFbSet(false),
+ mEncodingConstraints(constraints),
+ mProfile(0x42),
+ mConstraints(0xE0),
+ mLevel(0x0C),
+ mPacketizationMode(1)
+ {
+ if (h264) {
+ mProfile = (h264->profile_level_id & 0x00FF0000) >> 16;
+ mConstraints = (h264->profile_level_id & 0x0000FF00) >> 8;
+ mLevel = (h264->profile_level_id & 0x000000FF);
+ mPacketizationMode = h264->packetization_mode;
+ mSpropParameterSets = h264->sprop_parameter_sets;
+ }
+ }
+
+ // Nothing seems to use this right now. Do we intend to support this
+ // someday?
+ bool RtcpFbAckIsSet(const std::string& type) const
+ {
+ for (auto i = mAckFbTypes.begin(); i != mAckFbTypes.end(); ++i) {
+ if (*i == type) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ bool RtcpFbNackIsSet(const std::string& type) const
+ {
+ for (auto i = mNackFbTypes.begin(); i != mNackFbTypes.end(); ++i) {
+ if (*i == type) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ bool RtcpFbCcmIsSet(const std::string& type) const
+ {
+ for (auto i = mCcmFbTypes.begin(); i != mCcmFbTypes.end(); ++i) {
+ if (*i == type) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ bool RtcpFbRembIsSet() const { return mRembFbSet; }
+
+ bool RtcpFbFECIsSet() const { return mFECFbSet; }
+
+};
+}
+#endif
diff --git a/media/webrtc/signaling/src/media-conduit/CodecStatistics.cpp b/media/webrtc/signaling/src/media-conduit/CodecStatistics.cpp
new file mode 100644
index 000000000..eb03c0bf8
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/CodecStatistics.cpp
@@ -0,0 +1,183 @@
+/* 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 "CodecStatistics.h"
+
+#include "CSFLog.h"
+#include "mozilla/Telemetry.h"
+
+using namespace mozilla;
+using namespace webrtc;
+
+// use the same tag as VideoConduit
+static const char* logTag ="WebrtcVideoSessionConduit";
+
+VideoCodecStatistics::VideoCodecStatistics(int channel,
+ ViECodec* codec) :
+ mChannel(channel),
+ mSentRawFrames(0),
+ mPtrViECodec(codec),
+ mEncoderDroppedFrames(0),
+ mDecoderDiscardedPackets(0),
+ mRegisteredEncode(false),
+ mRegisteredDecode(false),
+ mReceiveState(kReceiveStateInitial)
+#ifdef MOZILLA_INTERNAL_API
+ , mRecoveredBeforeLoss(0)
+ , mRecoveredLosses(0)
+#endif
+{
+ MOZ_ASSERT(mPtrViECodec);
+}
+
+VideoCodecStatistics::~VideoCodecStatistics()
+{
+ if (mRegisteredEncode) {
+ mPtrViECodec->DeregisterEncoderObserver(mChannel);
+ }
+ if (mRegisteredDecode) {
+ mPtrViECodec->DeregisterDecoderObserver(mChannel);
+ }
+}
+
+void VideoCodecStatistics::Register(bool encoder)
+{
+ if (encoder && !mRegisteredEncode) {
+ mPtrViECodec->RegisterEncoderObserver(mChannel, *this);
+ mRegisteredEncode = true;
+ } else if (!encoder && !mRegisteredDecode) {
+ mPtrViECodec->RegisterDecoderObserver(mChannel, *this);
+ mRegisteredDecode = true;
+ }
+}
+
+void VideoCodecStatistics::OutgoingRate(const int video_channel,
+ const uint32_t framerate,
+ const uint32_t bitrate)
+{
+ unsigned int keyFrames, deltaFrames;
+ mPtrViECodec->GetSendCodecStatistics(video_channel, keyFrames, deltaFrames);
+ uint32_t dropped = mSentRawFrames - (keyFrames + deltaFrames);
+ CSFLogDebug(logTag,
+ "encoder statistics - framerate: %u, bitrate: %u, dropped frames: %u",
+ framerate, bitrate, dropped);
+ mEncoderBitRate.Push(bitrate);
+ mEncoderFps.Push(framerate);
+ mEncoderDroppedFrames += dropped;
+}
+
+void VideoCodecStatistics::IncomingCodecChanged(const int video_channel,
+ const VideoCodec& video_codec)
+{
+ CSFLogDebug(logTag,
+ "channel %d change codec to \"%s\" ",
+ video_channel, video_codec.plName);
+}
+
+void VideoCodecStatistics::IncomingRate(const int video_channel,
+ const unsigned int framerate,
+ const unsigned int bitrate)
+{
+ unsigned int discarded = mPtrViECodec->GetDiscardedPackets(video_channel);
+ CSFLogDebug(logTag,
+ "decoder statistics - framerate: %u, bitrate: %u, discarded packets %u",
+ framerate, bitrate, discarded);
+ mDecoderBitRate.Push(bitrate);
+ mDecoderFps.Push(framerate);
+ mDecoderDiscardedPackets += discarded;
+}
+
+void VideoCodecStatistics::ReceiveStateChange(const int aChannel,
+ VideoReceiveState aState)
+{
+ CSFLogDebug(logTag,"New state for %d: %d (was %d)", aChannel, aState, mReceiveState);
+#ifdef MOZILLA_INTERNAL_API
+ if (mFirstDecodeTime.IsNull()) {
+ mFirstDecodeTime = TimeStamp::Now();
+ }
+ /*
+ * Invalid transitions:
+ * WaitingKey -> PreemptiveNACK
+ * DecodingWithErrors -> PreemptiveNACK
+ */
+
+ switch (mReceiveState) {
+ case kReceiveStateNormal:
+ case kReceiveStateInitial:
+ // in a normal state
+ if (aState != kReceiveStateNormal && aState != kReceiveStateInitial) {
+ // no longer in a normal state
+ if (aState != kReceiveStatePreemptiveNACK) {
+ mReceiveFailureTime = TimeStamp::Now();
+ }
+ } // else Normal<->Initial transition
+ break;
+ default:
+ // not in a normal state
+ if (aState == kReceiveStateNormal || aState == kReceiveStateInitial) {
+
+ if (mReceiveState == kReceiveStatePreemptiveNACK) {
+ mRecoveredBeforeLoss++;
+ CSFLogError(logTag, "Video error avoided by NACK recovery");
+ } else if (!mReceiveFailureTime.IsNull()) { // safety
+ TimeDuration timeDelta = TimeStamp::Now() - mReceiveFailureTime;
+ CSFLogError(logTag, "Video error duration: %u ms",
+ static_cast<uint32_t>(timeDelta.ToMilliseconds()));
+ Telemetry::Accumulate(Telemetry::WEBRTC_VIDEO_ERROR_RECOVERY_MS,
+ static_cast<uint32_t>(timeDelta.ToMilliseconds()));
+
+ mRecoveredLosses++; // to calculate losses per minute
+ mTotalLossTime += timeDelta; // To calculate % time in recovery
+ }
+ } // else non-Normal to different non-normal transition
+ break;
+ }
+
+#endif
+
+ mReceiveState = aState;
+}
+
+void VideoCodecStatistics::EndOfCallStats()
+{
+#ifdef MOZILLA_INTERNAL_API
+ if (!mFirstDecodeTime.IsNull()) {
+ TimeDuration callDelta = TimeStamp::Now() - mFirstDecodeTime;
+ if (callDelta.ToSeconds() != 0) {
+ uint32_t recovered_per_min = mRecoveredBeforeLoss/(callDelta.ToSeconds()/60);
+ CSFLogError(logTag, "Video recovery before error per min %u", recovered_per_min);
+ Telemetry::Accumulate(Telemetry::WEBRTC_VIDEO_RECOVERY_BEFORE_ERROR_PER_MIN,
+ recovered_per_min);
+ uint32_t err_per_min = mRecoveredLosses/(callDelta.ToSeconds()/60);
+ CSFLogError(logTag, "Video recovery after error per min %u", err_per_min);
+ Telemetry::Accumulate(Telemetry::WEBRTC_VIDEO_RECOVERY_AFTER_ERROR_PER_MIN,
+ err_per_min);
+ float percent = (mTotalLossTime.ToSeconds()*100)/callDelta.ToSeconds();
+ CSFLogError(logTag, "Video error time percentage %f%%", percent);
+ Telemetry::Accumulate(Telemetry::WEBRTC_VIDEO_DECODE_ERROR_TIME_PERMILLE,
+ static_cast<uint32_t>(percent*10));
+ }
+ }
+#endif
+}
+
+void VideoCodecStatistics::SentFrame()
+{
+ mSentRawFrames++;
+}
+
+void VideoCodecStatistics::Dump()
+{
+ Dump(mEncoderBitRate, "encoder bitrate");
+ Dump(mEncoderFps, "encoder fps");
+ Dump(mDecoderBitRate, "decoder bitrate");
+ Dump(mDecoderFps, "decoder fps");
+}
+
+void VideoCodecStatistics::Dump(RunningStat& s, const char *name)
+{
+ CSFLogDebug(logTag,
+ "%s, mean: %f, variance: %f, standard deviation: %f",
+ name, s.Mean(), s.Variance(), s.StandardDeviation());
+}
diff --git a/media/webrtc/signaling/src/media-conduit/CodecStatistics.h b/media/webrtc/signaling/src/media-conduit/CodecStatistics.h
new file mode 100644
index 000000000..ab81a6f33
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/CodecStatistics.h
@@ -0,0 +1,111 @@
+/* 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/. */
+#ifndef CODEC_STATISTICS_H_
+#define CODEC_STATISTICS_H_
+#include <math.h>
+
+#include "nsTArray.h"
+#include "nsISupportsImpl.h"
+#include "mozilla/TimeStamp.h"
+#include "webrtc/common_types.h"
+#include "webrtc/video_engine/include/vie_codec.h"
+#include "MediaEngineWrapper.h"
+#include "RunningStat.h"
+
+namespace mozilla {
+
+// Statistics-gathering observer for Video Encoder and Decoder
+
+class VideoCodecStatistics : public webrtc::ViEEncoderObserver
+ , public webrtc::ViEDecoderObserver
+{
+public:
+ VideoCodecStatistics(int channel, webrtc::ViECodec* vieCodec);
+ ~VideoCodecStatistics();
+ void Register(bool encoder);
+
+ void SentFrame();
+ virtual void OutgoingRate(const int video_channel,
+ const unsigned int framerate, const unsigned int bitrate) override;
+
+ virtual void IncomingCodecChanged(const int video_channel,
+ const webrtc::VideoCodec& video_codec) override;
+
+ virtual void IncomingRate(const int video_channel,
+ const unsigned int framerate,
+ const unsigned int bitrate) override;
+
+ void ReceiveStateChange(const int video_channel, webrtc::VideoReceiveState state) override;
+
+ void EndOfCallStats();
+
+ virtual void RequestNewKeyFrame(const int video_channel) override {};
+
+ virtual void SuspendChange(int video_channel, bool is_suspended) override {};
+ virtual void DecoderTiming(int decode_ms,
+ int max_decode_ms,
+ int current_delay_ms,
+ int target_delay_ms,
+ int jitter_buffer_ms,
+ int min_playout_delay_ms,
+ int render_delay_ms) override {}
+
+ bool GetEncoderStats(double* framerateMean,
+ double* framerateStdDev,
+ double* bitrateMean,
+ double* bitrateStdDev,
+ uint32_t* droppedFrames)
+ {
+ *framerateMean = mEncoderFps.Mean();
+ *framerateStdDev = mEncoderFps.StandardDeviation();
+ *bitrateMean = mEncoderBitRate.Mean();
+ *bitrateStdDev = mEncoderBitRate.StandardDeviation();
+ *droppedFrames = mEncoderDroppedFrames;
+ return true;
+ }
+
+ bool GetDecoderStats(double* framerateMean,
+ double* framerateStdDev,
+ double* bitrateMean,
+ double* bitrateStdDev,
+ uint32_t* discardedPackets)
+ {
+ *framerateMean = mDecoderFps.Mean();
+ *framerateStdDev = mDecoderFps.StandardDeviation();
+ *bitrateMean = mDecoderBitRate.Mean();
+ *bitrateStdDev = mDecoderBitRate.StandardDeviation();
+ *discardedPackets = mDecoderDiscardedPackets;
+ return true;
+ }
+
+ void Dump();
+private:
+ void Dump(RunningStat& s, const char *name);
+
+ int mChannel;
+ uint32_t mSentRawFrames;
+ ScopedCustomReleasePtr<webrtc::ViECodec> mPtrViECodec; // back-pointer
+
+ RunningStat mEncoderBitRate;
+ RunningStat mEncoderFps;
+ uint32_t mEncoderDroppedFrames;
+ RunningStat mDecoderBitRate;
+ RunningStat mDecoderFps;
+ uint32_t mDecoderDiscardedPackets;
+ bool mRegisteredEncode;
+ bool mRegisteredDecode;
+
+ webrtc::VideoReceiveState mReceiveState;
+#ifdef MOZILLA_INTERNAL_API
+ TimeStamp mFirstDecodeTime;
+ TimeStamp mReceiveFailureTime;
+ TimeDuration mTotalLossTime;
+ uint32_t mRecoveredBeforeLoss;
+ uint32_t mRecoveredLosses;
+#endif
+};
+
+}
+
+#endif //CODEC_STATISTICS_H_
diff --git a/media/webrtc/signaling/src/media-conduit/GmpVideoCodec.cpp b/media/webrtc/signaling/src/media-conduit/GmpVideoCodec.cpp
new file mode 100644
index 000000000..0c4d81e44
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/GmpVideoCodec.cpp
@@ -0,0 +1,18 @@
+/* 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 "WebrtcGmpVideoCodec.h"
+#include "GmpVideoCodec.h"
+
+namespace mozilla {
+
+VideoEncoder* GmpVideoCodec::CreateEncoder() {
+ return static_cast<VideoEncoder*>(new WebrtcVideoEncoderProxy());
+}
+
+VideoDecoder* GmpVideoCodec::CreateDecoder() {
+ return static_cast<VideoDecoder*>(new WebrtcVideoDecoderProxy());
+}
+
+}
diff --git a/media/webrtc/signaling/src/media-conduit/GmpVideoCodec.h b/media/webrtc/signaling/src/media-conduit/GmpVideoCodec.h
new file mode 100644
index 000000000..340150409
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/GmpVideoCodec.h
@@ -0,0 +1,19 @@
+/* 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/. */
+
+#ifndef GMPVIDEOCODEC_H_
+#define GMPVIDEOCODEC_H_
+
+#include "MediaConduitInterface.h"
+
+namespace mozilla {
+class GmpVideoCodec {
+ public:
+ static VideoEncoder* CreateEncoder();
+ static VideoDecoder* CreateDecoder();
+};
+
+}
+
+#endif
diff --git a/media/webrtc/signaling/src/media-conduit/MediaCodecVideoCodec.cpp b/media/webrtc/signaling/src/media-conduit/MediaCodecVideoCodec.cpp
new file mode 100644
index 000000000..0c6c2fdde
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/MediaCodecVideoCodec.cpp
@@ -0,0 +1,31 @@
+/* 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 "CSFLog.h"
+#include "nspr.h"
+
+#include "WebrtcMediaCodecVP8VideoCodec.h"
+#include "MediaCodecVideoCodec.h"
+
+namespace mozilla {
+
+static const char* logTag ="MediaCodecVideoCodec";
+
+VideoEncoder* MediaCodecVideoCodec::CreateEncoder(CodecType aCodecType) {
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+ if (aCodecType == CODEC_VP8) {
+ return new WebrtcMediaCodecVP8VideoEncoder();
+ }
+ return nullptr;
+}
+
+VideoDecoder* MediaCodecVideoCodec::CreateDecoder(CodecType aCodecType) {
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+ if (aCodecType == CODEC_VP8) {
+ return new WebrtcMediaCodecVP8VideoDecoder();
+ }
+ return nullptr;
+}
+
+}
diff --git a/media/webrtc/signaling/src/media-conduit/MediaCodecVideoCodec.h b/media/webrtc/signaling/src/media-conduit/MediaCodecVideoCodec.h
new file mode 100644
index 000000000..50dde8211
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/MediaCodecVideoCodec.h
@@ -0,0 +1,31 @@
+/* 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/. */
+
+#ifndef MediaCodecVideoCodec_h__
+#define MediaCodecVideoCodec_h__
+
+#include "MediaConduitInterface.h"
+
+namespace mozilla {
+class MediaCodecVideoCodec {
+ public:
+ enum CodecType {
+ CODEC_VP8,
+ };
+ /**
+ * Create encoder object for codec type |aCodecType|. Return |nullptr| when
+ * failed.
+ */
+ static VideoEncoder* CreateEncoder(CodecType aCodecType);
+
+ /**
+ * Create decoder object for codec type |aCodecType|. Return |nullptr| when
+ * failed.
+ */
+ static VideoDecoder* CreateDecoder(CodecType aCodecType);
+};
+
+}
+
+#endif // MediaCodecVideoCodec_h__
diff --git a/media/webrtc/signaling/src/media-conduit/MediaConduitErrors.h b/media/webrtc/signaling/src/media-conduit/MediaConduitErrors.h
new file mode 100755
index 000000000..3709d59a0
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/MediaConduitErrors.h
@@ -0,0 +1,48 @@
+/* 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/. */
+
+
+#ifndef MEDIA_SESSION_ERRORS_H_
+#define MEDIA_SESSION_ERRORS_H_
+
+namespace mozilla
+{
+enum MediaConduitErrorCode
+{
+kMediaConduitNoError = 0, // 0 for Success,greater than 0 imples error
+kMediaConduitSessionNotInited = 10100, // Session not initialized.10100 serves as
+ // base for the conduit errors
+kMediaConduitMalformedArgument, // Malformed input to Conduit API
+kMediaConduitCaptureError, // WebRTC capture APIs failed
+kMediaConduitInvalidSendCodec, // Wrong Send codec
+kMediaConduitInvalidReceiveCodec, // Wrong Recv Codec
+kMediaConduitCodecInUse, // Already applied Codec
+kMediaConduitInvalidRenderer, // Null or Wrong Renderer object
+kMediaConduitRendererFail, // Add Render called multiple times
+kMediaConduitSendingAlready, // Engine already trasmitting
+kMediaConduitReceivingAlready, // Engine already receiving
+kMediaConduitTransportRegistrationFail,// Null or wrong transport interface
+kMediaConduitInvalidTransport, // Null or wrong transport interface
+kMediaConduitChannelError, // Configuration Error
+kMediaConduitSocketError, // Media Engine transport socket error
+kMediaConduitRTPRTCPModuleError, // Couldn't start RTP/RTCP processing
+kMediaConduitRTPProcessingFailed, // Processing incoming RTP frame failed
+kMediaConduitUnknownError, // More information can be found in logs
+kMediaConduitExternalRecordingError, // Couldn't start external recording
+kMediaConduitRecordingError, // Runtime recording error
+kMediaConduitExternalPlayoutError, // Couldn't start external playout
+kMediaConduitPlayoutError, // Runtime playout error
+kMediaConduitMTUError, // Can't set MTU
+kMediaConduitRTCPStatusError, // Can't set RTCP mode
+kMediaConduitKeyFrameRequestError, // Can't set KeyFrameRequest mode
+kMediaConduitNACKStatusError, // Can't set NACK mode
+kMediaConduitTMMBRStatusError, // Can't set TMMBR mode
+kMediaConduitFECStatusError, // Can't set FEC mode
+kMediaConduitHybridNACKFECStatusError // Can't set Hybrid NACK / FEC mode
+};
+
+}
+
+#endif
+
diff --git a/media/webrtc/signaling/src/media-conduit/MediaConduitInterface.h b/media/webrtc/signaling/src/media-conduit/MediaConduitInterface.h
new file mode 100755
index 000000000..05c34fea0
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/MediaConduitInterface.h
@@ -0,0 +1,495 @@
+/* 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/. */
+
+#ifndef MEDIA_CONDUIT_ABSTRACTION_
+#define MEDIA_CONDUIT_ABSTRACTION_
+
+#include "nsISupportsImpl.h"
+#include "nsXPCOM.h"
+#include "nsDOMNavigationTiming.h"
+#include "mozilla/RefPtr.h"
+#include "CodecConfig.h"
+#include "VideoTypes.h"
+#include "MediaConduitErrors.h"
+
+#include "ImageContainer.h"
+
+#include "webrtc/common_types.h"
+namespace webrtc {
+class I420VideoFrame;
+}
+
+#include <vector>
+
+namespace mozilla {
+/**
+ * Abstract Interface for transporting RTP packets - audio/vidoeo
+ * The consumers of this interface are responsible for passing in
+ * the RTPfied media packets
+ */
+class TransportInterface
+{
+protected:
+ virtual ~TransportInterface() {}
+
+public:
+ /**
+ * RTP Transport Function to be implemented by concrete transport implementation
+ * @param data : RTP Packet (audio/video) to be transported
+ * @param len : Length of the media packet
+ * @result : NS_OK on success, NS_ERROR_FAILURE otherwise
+ */
+ virtual nsresult SendRtpPacket(const void* data, int len) = 0;
+
+ /**
+ * RTCP Transport Function to be implemented by concrete transport implementation
+ * @param data : RTCP Packet to be transported
+ * @param len : Length of the RTCP packet
+ * @result : NS_OK on success, NS_ERROR_FAILURE otherwise
+ */
+ virtual nsresult SendRtcpPacket(const void* data, int len) = 0;
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(TransportInterface)
+};
+
+/**
+ * This class wraps image object for VideoRenderer::RenderVideoFrame()
+ * callback implementation to use for rendering.
+ */
+class ImageHandle
+{
+public:
+ explicit ImageHandle(layers::Image* image) : mImage(image) {}
+
+ const RefPtr<layers::Image>& GetImage() const { return mImage; }
+
+private:
+ RefPtr<layers::Image> mImage;
+};
+
+/**
+ * 1. Abstract renderer for video data
+ * 2. This class acts as abstract interface between the video-engine and
+ * video-engine agnostic renderer implementation.
+ * 3. Concrete implementation of this interface is responsible for
+ * processing and/or rendering the obtained raw video frame to appropriate
+ * output , say, <video>
+ */
+class VideoRenderer
+{
+protected:
+ virtual ~VideoRenderer() {}
+
+public:
+ /**
+ * Callback Function reportng any change in the video-frame dimensions
+ * @param width: current width of the video @ decoder
+ * @param height: current height of the video @ decoder
+ * @param number_of_streams: number of participating video streams
+ */
+ virtual void FrameSizeChange(unsigned int width,
+ unsigned int height,
+ unsigned int number_of_streams) = 0;
+
+ /**
+ * Callback Function reporting decoded I420 frame for processing.
+ * @param buffer: pointer to decoded video frame
+ * @param buffer_size: size of the decoded frame
+ * @param time_stamp: Decoder timestamp, typically 90KHz as per RTP
+ * @render_time: Wall-clock time at the decoder for synchronization
+ * purposes in milliseconds
+ * @handle: opaque handle for image object of decoded video frame.
+ * NOTE: If decoded video frame is passed through buffer , it is the
+ * responsibility of the concrete implementations of this class to own copy
+ * of the frame if needed for time longer than scope of this callback.
+ * Such implementations should be quick in processing the frames and return
+ * immediately.
+ * On the other hand, if decoded video frame is passed through handle, the
+ * implementations should keep a reference to the (ref-counted) image object
+ * inside until it's no longer needed.
+ */
+ virtual void RenderVideoFrame(const unsigned char* buffer,
+ size_t buffer_size,
+ uint32_t time_stamp,
+ int64_t render_time,
+ const ImageHandle& handle) = 0;
+ virtual void RenderVideoFrame(const unsigned char* buffer,
+ size_t buffer_size,
+ uint32_t y_stride,
+ uint32_t cbcr_stride,
+ uint32_t time_stamp,
+ int64_t render_time,
+ const ImageHandle& handle) = 0;
+
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(VideoRenderer)
+};
+
+
+/**
+ * Generic Interface for representing Audio/Video Session
+ * MediaSession conduit is identified by 2 main components
+ * 1. Attached Transport Interface for inbound and outbound RTP transport
+ * 2. Attached Renderer Interface for rendering media data off the network
+ * This class hides specifics of Media-Engine implementation from the consumers
+ * of this interface.
+ * Also provides codec configuration API for the media sent and recevied
+ */
+class MediaSessionConduit
+{
+protected:
+ virtual ~MediaSessionConduit() {}
+
+public:
+ enum Type { AUDIO, VIDEO } ;
+
+ virtual Type type() const = 0;
+
+ /**
+ * Function triggered on Incoming RTP packet from the remote
+ * endpoint by the transport implementation.
+ * @param data : RTP Packet (audio/video) to be processed
+ * @param len : Length of the media packet
+ * Obtained packets are passed to the Media-Engine for further
+ * processing , say, decoding
+ */
+ virtual MediaConduitErrorCode ReceivedRTPPacket(const void *data, int len) = 0;
+
+ /**
+ * Function triggered on Incoming RTCP packet from the remote
+ * endpoint by the transport implementation.
+ * @param data : RTCP Packet (audio/video) to be processed
+ * @param len : Length of the media packet
+ * Obtained packets are passed to the Media-Engine for further
+ * processing , say, decoding
+ */
+ virtual MediaConduitErrorCode ReceivedRTCPPacket(const void *data, int len) = 0;
+
+ virtual MediaConduitErrorCode StopTransmitting() = 0;
+ virtual MediaConduitErrorCode StartTransmitting() = 0;
+ virtual MediaConduitErrorCode StopReceiving() = 0;
+ virtual MediaConduitErrorCode StartReceiving() = 0;
+
+
+ /**
+ * Function to attach transmitter transport end-point of the Media conduit.
+ * @param aTransport: Reference to the concrete teansport implementation
+ * When nullptr, unsets the transmitter transport endpoint.
+ * Note: Multiple invocations of this call , replaces existing transport with
+ * with the new one.
+ * Note: This transport is used for RTP, and RTCP if no receiver transport is
+ * set. In the future, we should ensure that RTCP sender reports use this
+ * regardless of whether the receiver transport is set.
+ */
+ virtual MediaConduitErrorCode SetTransmitterTransport(RefPtr<TransportInterface> aTransport) = 0;
+
+ /**
+ * Function to attach receiver transport end-point of the Media conduit.
+ * @param aTransport: Reference to the concrete teansport implementation
+ * When nullptr, unsets the receiver transport endpoint.
+ * Note: Multiple invocations of this call , replaces existing transport with
+ * with the new one.
+ * Note: This transport is used for RTCP.
+ * Note: In the future, we should avoid using this for RTCP sender reports.
+ */
+ virtual MediaConduitErrorCode SetReceiverTransport(RefPtr<TransportInterface> aTransport) = 0;
+
+ virtual bool SetLocalSSRC(unsigned int ssrc) = 0;
+ virtual bool GetLocalSSRC(unsigned int* ssrc) = 0;
+ virtual bool GetRemoteSSRC(unsigned int* ssrc) = 0;
+ virtual bool SetLocalCNAME(const char* cname) = 0;
+
+ /**
+ * Functions returning stats needed by w3c stats model.
+ */
+ virtual bool GetVideoEncoderStats(double* framerateMean,
+ double* framerateStdDev,
+ double* bitrateMean,
+ double* bitrateStdDev,
+ uint32_t* droppedFrames) = 0;
+ virtual bool GetVideoDecoderStats(double* framerateMean,
+ double* framerateStdDev,
+ double* bitrateMean,
+ double* bitrateStdDev,
+ uint32_t* discardedPackets) = 0;
+ virtual bool GetAVStats(int32_t* jitterBufferDelayMs,
+ int32_t* playoutBufferDelayMs,
+ int32_t* avSyncOffsetMs) = 0;
+ virtual bool GetRTPStats(unsigned int* jitterMs,
+ unsigned int* cumulativeLost) = 0;
+ virtual bool GetRTCPReceiverReport(DOMHighResTimeStamp* timestamp,
+ uint32_t* jitterMs,
+ uint32_t* packetsReceived,
+ uint64_t* bytesReceived,
+ uint32_t* cumulativeLost,
+ int32_t* rttMs) = 0;
+ virtual bool GetRTCPSenderReport(DOMHighResTimeStamp* timestamp,
+ unsigned int* packetsSent,
+ uint64_t* bytesSent) = 0;
+
+ virtual uint64_t CodecPluginID() = 0;
+
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MediaSessionConduit)
+
+};
+
+// Abstract base classes for external encoder/decoder.
+class CodecPluginID
+{
+public:
+ virtual ~CodecPluginID() {}
+
+ virtual uint64_t PluginID() const = 0;
+};
+
+class VideoEncoder : public CodecPluginID
+{
+public:
+ virtual ~VideoEncoder() {}
+};
+
+class VideoDecoder : public CodecPluginID
+{
+public:
+ virtual ~VideoDecoder() {}
+};
+
+/**
+ * MediaSessionConduit for video
+ * Refer to the comments on MediaSessionConduit above for overall
+ * information
+ */
+class VideoSessionConduit : public MediaSessionConduit
+{
+public:
+ /**
+ * Factory function to create and initialize a Video Conduit Session
+ * return: Concrete VideoSessionConduitObject or nullptr in the case
+ * of failure
+ */
+ static RefPtr<VideoSessionConduit> Create();
+
+ enum FrameRequestType
+ {
+ FrameRequestNone,
+ FrameRequestFir,
+ FrameRequestPli,
+ FrameRequestUnknown
+ };
+
+ VideoSessionConduit() : mFrameRequestMethod(FrameRequestNone),
+ mUsingNackBasic(false),
+ mUsingTmmbr(false),
+ mUsingFEC(false) {}
+
+ virtual ~VideoSessionConduit() {}
+
+ virtual Type type() const { return VIDEO; }
+
+ /**
+ * Function to attach Renderer end-point of the Media-Video conduit.
+ * @param aRenderer : Reference to the concrete Video renderer implementation
+ * Note: Multiple invocations of this API shall remove an existing renderer
+ * and attaches the new to the Conduit.
+ */
+ virtual MediaConduitErrorCode AttachRenderer(RefPtr<VideoRenderer> aRenderer) = 0;
+ virtual void DetachRenderer() = 0;
+
+ /**
+ * Function to deliver a capture video frame for encoding and transport
+ * @param video_frame: pointer to captured video-frame.
+ * @param video_frame_length: size of the frame
+ * @param width, height: dimensions of the frame
+ * @param video_type: Type of the video frame - I420, RAW
+ * @param captured_time: timestamp when the frame was captured.
+ * if 0 timestamp is automatcally generated
+ * NOTE: ConfigureSendMediaCodec() MUST be called before this function can be invoked
+ * This ensures the inserted video-frames can be transmitted by the conduit
+ */
+ virtual MediaConduitErrorCode SendVideoFrame(unsigned char* video_frame,
+ unsigned int video_frame_length,
+ unsigned short width,
+ unsigned short height,
+ VideoType video_type,
+ uint64_t capture_time) = 0;
+ virtual MediaConduitErrorCode SendVideoFrame(webrtc::I420VideoFrame& frame) = 0;
+
+ virtual MediaConduitErrorCode ConfigureCodecMode(webrtc::VideoCodecMode) = 0;
+ /**
+ * Function to configure send codec for the video session
+ * @param sendSessionConfig: CodecConfiguration
+ * @result: On Success, the video engine is configured with passed in codec for send
+ * On failure, video engine transmit functionality is disabled.
+ * NOTE: This API can be invoked multiple time. Invoking this API may involve restarting
+ * transmission sub-system on the engine
+ *
+ */
+ virtual MediaConduitErrorCode ConfigureSendMediaCodec(const VideoCodecConfig* sendSessionConfig) = 0;
+
+ /**
+ * Function to configurelist of receive codecs for the video session
+ * @param sendSessionConfig: CodecConfiguration
+ * NOTE: This API can be invoked multiple time. Invoking this API may involve restarting
+ * reception sub-system on the engine
+ *
+ */
+ virtual MediaConduitErrorCode ConfigureRecvMediaCodecs(
+ const std::vector<VideoCodecConfig* >& recvCodecConfigList) = 0;
+
+ /**
+ * Set an external encoder
+ * @param encoder
+ * @result: on success, we will use the specified encoder
+ */
+ virtual MediaConduitErrorCode SetExternalSendCodec(VideoCodecConfig* config,
+ VideoEncoder* encoder) = 0;
+
+ /**
+ * Set an external decoder
+ * @param decoder
+ * @result: on success, we will use the specified decoder
+ */
+ virtual MediaConduitErrorCode SetExternalRecvCodec(VideoCodecConfig* config,
+ VideoDecoder* decoder) = 0;
+
+ /**
+ * Function to enable the RTP Stream ID (RID) extension
+ * @param enabled: enable extension
+ * @param id: id to be used for this rtp header extension
+ * NOTE: See VideoConduit for more information
+ */
+ virtual MediaConduitErrorCode EnableRTPStreamIdExtension(bool enabled, uint8_t id) = 0;
+
+ /**
+ * These methods allow unit tests to double-check that the
+ * max-fs and max-fr related settings are as expected.
+ */
+ virtual unsigned short SendingWidth() = 0;
+
+ virtual unsigned short SendingHeight() = 0;
+
+ virtual unsigned int SendingMaxFs() = 0;
+
+ virtual unsigned int SendingMaxFr() = 0;
+
+ /**
+ * These methods allow unit tests to double-check that the
+ * rtcp-fb settings are as expected.
+ */
+ FrameRequestType FrameRequestMethod() const {
+ return mFrameRequestMethod;
+ }
+
+ bool UsingNackBasic() const {
+ return mUsingNackBasic;
+ }
+
+ bool UsingTmmbr() const {
+ return mUsingTmmbr;
+ }
+
+ bool UsingFEC() const {
+ return mUsingFEC;
+ }
+
+ protected:
+ /* RTCP feedback settings, for unit testing purposes */
+ FrameRequestType mFrameRequestMethod;
+ bool mUsingNackBasic;
+ bool mUsingTmmbr;
+ bool mUsingFEC;
+};
+
+/**
+ * MediaSessionConduit for audio
+ * Refer to the comments on MediaSessionConduit above for overall
+ * information
+ */
+class AudioSessionConduit : public MediaSessionConduit
+{
+public:
+
+ /**
+ * Factory function to create and initialize an Audio Conduit Session
+ * return: Concrete AudioSessionConduitObject or nullptr in the case
+ * of failure
+ */
+ static RefPtr<AudioSessionConduit> Create();
+
+ virtual ~AudioSessionConduit() {}
+
+ virtual Type type() const { return AUDIO; }
+
+
+ /**
+ * Function to deliver externally captured audio sample for encoding and transport
+ * @param audioData [in]: Pointer to array containing a frame of audio
+ * @param lengthSamples [in]: Length of audio frame in samples in multiple of 10 milliseconds
+ * Ex: Frame length is 160, 320, 440 for 16, 32, 44 kHz sampling rates
+ respectively.
+ audioData[] is lengthSamples in size
+ say, for 16kz sampling rate, audioData[] should contain 160
+ samples of 16-bits each for a 10m audio frame.
+ * @param samplingFreqHz [in]: Frequency/rate of the sampling in Hz ( 16000, 32000 ...)
+ * @param capture_delay [in]: Approx Delay from recording until it is delivered to VoiceEngine
+ in milliseconds.
+ * NOTE: ConfigureSendMediaCodec() SHOULD be called before this function can be invoked
+ * This ensures the inserted audio-samples can be transmitted by the conduit
+ *
+ */
+ virtual MediaConduitErrorCode SendAudioFrame(const int16_t audioData[],
+ int32_t lengthSamples,
+ int32_t samplingFreqHz,
+ int32_t capture_delay) = 0;
+
+ /**
+ * Function to grab a decoded audio-sample from the media engine for rendering
+ * / playoutof length 10 milliseconds.
+ *
+ * @param speechData [in]: Pointer to a array to which a 10ms frame of audio will be copied
+ * @param samplingFreqHz [in]: Frequency of the sampling for playback in Hertz (16000, 32000,..)
+ * @param capture_delay [in]: Estimated Time between reading of the samples to rendering/playback
+ * @param lengthSamples [out]: Will contain length of the audio frame in samples at return.
+ Ex: A value of 160 implies 160 samples each of 16-bits was copied
+ into speechData
+ * NOTE: This function should be invoked every 10 milliseconds for the best
+ * peformance
+ * NOTE: ConfigureRecvMediaCodec() SHOULD be called before this function can be invoked
+ * This ensures the decoded samples are ready for reading.
+ *
+ */
+ virtual MediaConduitErrorCode GetAudioFrame(int16_t speechData[],
+ int32_t samplingFreqHz,
+ int32_t capture_delay,
+ int& lengthSamples) = 0;
+
+ /**
+ * Function to configure send codec for the audio session
+ * @param sendSessionConfig: CodecConfiguration
+ * NOTE: See VideoConduit for more information
+ */
+
+ virtual MediaConduitErrorCode ConfigureSendMediaCodec(const AudioCodecConfig* sendCodecConfig) = 0;
+
+ /**
+ * Function to configure list of receive codecs for the audio session
+ * @param sendSessionConfig: CodecConfiguration
+ * NOTE: See VideoConduit for more information
+ */
+ virtual MediaConduitErrorCode ConfigureRecvMediaCodecs(
+ const std::vector<AudioCodecConfig* >& recvCodecConfigList) = 0;
+ /**
+ * Function to enable the audio level extension
+ * @param enabled: enable extension
+ * @param id: id to be used for this rtp header extension
+ * NOTE: See AudioConduit for more information
+ */
+ virtual MediaConduitErrorCode EnableAudioLevelExtension(bool enabled, uint8_t id) = 0;
+
+ virtual bool SetDtmfPayloadType(unsigned char type) = 0;
+
+ virtual bool InsertDTMFTone(int channel, int eventCode, bool outOfBand,
+ int lengthMs, int attenuationDb) = 0;
+
+};
+}
+#endif
diff --git a/media/webrtc/signaling/src/media-conduit/OMXVideoCodec.cpp b/media/webrtc/signaling/src/media-conduit/OMXVideoCodec.cpp
new file mode 100644
index 000000000..d46398402
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/OMXVideoCodec.cpp
@@ -0,0 +1,30 @@
+/* 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 "OMXVideoCodec.h"
+
+#ifdef WEBRTC_GONK
+#include "WebrtcOMXH264VideoCodec.h"
+#endif
+
+namespace mozilla {
+
+VideoEncoder*
+OMXVideoCodec::CreateEncoder(CodecType aCodecType)
+{
+ if (aCodecType == CODEC_H264) {
+ return new WebrtcOMXH264VideoEncoder();
+ }
+ return nullptr;
+}
+
+VideoDecoder*
+OMXVideoCodec::CreateDecoder(CodecType aCodecType) {
+ if (aCodecType == CODEC_H264) {
+ return new WebrtcOMXH264VideoDecoder();
+ }
+ return nullptr;
+}
+
+}
diff --git a/media/webrtc/signaling/src/media-conduit/OMXVideoCodec.h b/media/webrtc/signaling/src/media-conduit/OMXVideoCodec.h
new file mode 100644
index 000000000..51df50263
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/OMXVideoCodec.h
@@ -0,0 +1,32 @@
+/* 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/. */
+
+#ifndef OMX_VIDEO_CODEC_H_
+#define OMX_VIDEO_CODEC_H_
+
+#include "MediaConduitInterface.h"
+
+namespace mozilla {
+class OMXVideoCodec {
+ public:
+ enum CodecType {
+ CODEC_H264,
+ };
+
+ /**
+ * Create encoder object for codec type |aCodecType|. Return |nullptr| when
+ * failed.
+ */
+ static VideoEncoder* CreateEncoder(CodecType aCodecType);
+
+ /**
+ * Create decoder object for codec type |aCodecType|. Return |nullptr| when
+ * failed.
+ */
+ static VideoDecoder* CreateDecoder(CodecType aCodecType);
+};
+
+}
+
+#endif // OMX_VIDEO_CODEC_H_
diff --git a/media/webrtc/signaling/src/media-conduit/RunningStat.h b/media/webrtc/signaling/src/media-conduit/RunningStat.h
new file mode 100644
index 000000000..1d0cdbeca
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/RunningStat.h
@@ -0,0 +1,66 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+/* Adapted from "Accurately computing running variance - John D. Cook"
+ http://www.johndcook.com/standard_deviation.html */
+
+#ifndef RUNNING_STAT_H_
+#define RUNNING_STAT_H_
+#include <math.h>
+
+namespace mozilla {
+
+class RunningStat
+{
+public:
+ RunningStat() : mN(0) {}
+
+ void Clear()
+ {
+ mN = 0;
+ }
+
+ void Push(double x)
+ {
+ mN++;
+
+ // See Knuth TAOCP vol 2, 3rd edition, page 232
+ if (mN == 1)
+ {
+ mOldM = mNewM = x;
+ mOldS = 0.0;
+ } else {
+ mNewM = mOldM + (x - mOldM) / mN;
+ mNewS = mOldS + (x - mOldM) * (x - mNewM);
+
+ // set up for next iteration
+ mOldM = mNewM;
+ mOldS = mNewS;
+ }
+ }
+
+ int NumDataValues() const
+ {
+ return mN;
+ }
+
+ double Mean() const
+ {
+ return (mN > 0) ? mNewM : 0.0;
+ }
+
+ double Variance() const
+ {
+ return (mN > 1) ? mNewS / (mN - 1) : 0.0;
+ }
+
+ double StandardDeviation() const
+ {
+ return sqrt(Variance());
+ }
+
+private:
+ int mN;
+ double mOldM, mNewM, mOldS, mNewS;
+};
+}
+#endif //RUNNING_STAT_H_
diff --git a/media/webrtc/signaling/src/media-conduit/VideoConduit.cpp b/media/webrtc/signaling/src/media-conduit/VideoConduit.cpp
new file mode 100755
index 000000000..3f0445122
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/VideoConduit.cpp
@@ -0,0 +1,2129 @@
+/* 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 "CSFLog.h"
+#include "nspr.h"
+#include "plstr.h"
+
+#include "VideoConduit.h"
+#include "AudioConduit.h"
+#include "nsThreadUtils.h"
+#include "LoadManager.h"
+#include "YuvStamper.h"
+#include "nsServiceManagerUtils.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "mozilla/media/MediaUtils.h"
+#include "mozilla/TemplateLib.h"
+
+#include "webrtc/common_types.h"
+#include "webrtc/common_video/interface/native_handle.h"
+#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
+#include "webrtc/video_engine/include/vie_errors.h"
+#include "webrtc/video_engine/vie_defines.h"
+
+#include "mozilla/Unused.h"
+
+#ifdef MOZ_WIDGET_ANDROID
+#include "AndroidJNIWrapper.h"
+#endif
+
+// for ntohs
+#ifdef _MSC_VER
+#include "Winsock2.h"
+#else
+#include <netinet/in.h>
+#endif
+
+#include <algorithm>
+#include <math.h>
+
+#define DEFAULT_VIDEO_MAX_FRAMERATE 30
+#define INVALID_RTP_PAYLOAD 255 //valid payload types are 0 to 127
+
+namespace mozilla {
+
+static const char* logTag ="WebrtcVideoSessionConduit";
+
+// 32 bytes is what WebRTC CodecInst expects
+const unsigned int WebrtcVideoConduit::CODEC_PLNAME_SIZE = 32;
+
+/**
+ * Factory Method for VideoConduit
+ */
+RefPtr<VideoSessionConduit>
+VideoSessionConduit::Create()
+{
+ NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+
+ WebrtcVideoConduit* obj = new WebrtcVideoConduit();
+ if(obj->Init() != kMediaConduitNoError)
+ {
+ CSFLogError(logTag, "%s VideoConduit Init Failed ", __FUNCTION__);
+ delete obj;
+ return nullptr;
+ }
+ CSFLogDebug(logTag, "%s Successfully created VideoConduit ", __FUNCTION__);
+ return obj;
+}
+
+WebrtcVideoConduit::WebrtcVideoConduit():
+ mVideoEngine(nullptr),
+ mTransportMonitor("WebrtcVideoConduit"),
+ mTransmitterTransport(nullptr),
+ mReceiverTransport(nullptr),
+ mRenderer(nullptr),
+ mPtrExtCapture(nullptr),
+ mEngineTransmitting(false),
+ mEngineReceiving(false),
+ mChannel(-1),
+ mCapId(-1),
+ mCodecMutex("VideoConduit codec db"),
+ mInReconfig(false),
+ mLastWidth(0), // forces a check for reconfig at start
+ mLastHeight(0),
+ mSendingWidth(0),
+ mSendingHeight(0),
+ mReceivingWidth(0),
+ mReceivingHeight(0),
+ mSendingFramerate(DEFAULT_VIDEO_MAX_FRAMERATE),
+ mLastFramerateTenths(DEFAULT_VIDEO_MAX_FRAMERATE*10),
+ mNumReceivingStreams(1),
+ mVideoLatencyTestEnable(false),
+ mVideoLatencyAvg(0),
+ mMinBitrate(0),
+ mStartBitrate(0),
+ mMaxBitrate(0),
+ mMinBitrateEstimate(0),
+ mRtpStreamIdEnabled(false),
+ mRtpStreamIdExtId(0),
+ mCodecMode(webrtc::kRealtimeVideo)
+{}
+
+WebrtcVideoConduit::~WebrtcVideoConduit()
+{
+ NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+
+ // Release AudioConduit first by dropping reference on MainThread, where it expects to be
+ SyncTo(nullptr);
+ Destroy();
+}
+
+bool WebrtcVideoConduit::SetLocalSSRC(unsigned int ssrc)
+{
+ unsigned int oldSsrc;
+ if (!GetLocalSSRC(&oldSsrc)) {
+ MOZ_ASSERT(false, "GetLocalSSRC failed");
+ return false;
+ }
+
+ if (oldSsrc == ssrc) {
+ return true;
+ }
+
+ bool wasTransmitting = mEngineTransmitting;
+ if (StopTransmitting() != kMediaConduitNoError) {
+ return false;
+ }
+
+ if (mPtrRTP->SetLocalSSRC(mChannel, ssrc)) {
+ return false;
+ }
+
+ if (wasTransmitting) {
+ if (StartTransmitting() != kMediaConduitNoError) {
+ return false;
+ }
+ }
+ return true;
+}
+
+bool WebrtcVideoConduit::GetLocalSSRC(unsigned int* ssrc)
+{
+ return !mPtrRTP->GetLocalSSRC(mChannel, *ssrc);
+}
+
+bool WebrtcVideoConduit::GetRemoteSSRC(unsigned int* ssrc)
+{
+ return !mPtrRTP->GetRemoteSSRC(mChannel, *ssrc);
+}
+
+bool WebrtcVideoConduit::SetLocalCNAME(const char* cname)
+{
+ char temp[256];
+ strncpy(temp, cname, sizeof(temp) - 1);
+ temp[sizeof(temp) - 1] = 0;
+ return !mPtrRTP->SetRTCPCName(mChannel, temp);
+}
+
+bool WebrtcVideoConduit::GetVideoEncoderStats(double* framerateMean,
+ double* framerateStdDev,
+ double* bitrateMean,
+ double* bitrateStdDev,
+ uint32_t* droppedFrames)
+{
+ if (!mEngineTransmitting) {
+ return false;
+ }
+ MOZ_ASSERT(mVideoCodecStat);
+ mVideoCodecStat->GetEncoderStats(framerateMean, framerateStdDev,
+ bitrateMean, bitrateStdDev,
+ droppedFrames);
+
+ // See if we need to adjust bandwidth.
+ // Avoid changing bandwidth constantly; use hysteresis.
+
+ // Note: mLastFramerate is a relaxed Atomic because we're setting it here, and
+ // reading it on whatever thread calls DeliverFrame/SendVideoFrame. Alternately
+ // we could use a lock. Note that we don't change it often, and read it once per frame.
+ // We scale by *10 because mozilla::Atomic<> doesn't do 'double' or 'float'.
+ double framerate = mLastFramerateTenths/10.0; // fetch once
+ if (std::abs(*framerateMean - framerate)/framerate > 0.1 &&
+ *framerateMean >= 0.5) {
+ // unchanged resolution, but adjust bandwidth limits to match camera fps
+ CSFLogDebug(logTag, "Encoder frame rate changed from %f to %f",
+ (mLastFramerateTenths/10.0), *framerateMean);
+ MutexAutoLock lock(mCodecMutex);
+ mLastFramerateTenths = *framerateMean * 10;
+ SelectSendResolution(mSendingWidth, mSendingHeight, nullptr);
+ }
+ return true;
+}
+
+bool WebrtcVideoConduit::GetVideoDecoderStats(double* framerateMean,
+ double* framerateStdDev,
+ double* bitrateMean,
+ double* bitrateStdDev,
+ uint32_t* discardedPackets)
+{
+ if (!mEngineReceiving) {
+ return false;
+ }
+ MOZ_ASSERT(mVideoCodecStat);
+ mVideoCodecStat->GetDecoderStats(framerateMean, framerateStdDev,
+ bitrateMean, bitrateStdDev,
+ discardedPackets);
+ return true;
+}
+
+bool WebrtcVideoConduit::GetAVStats(int32_t* jitterBufferDelayMs,
+ int32_t* playoutBufferDelayMs,
+ int32_t* avSyncOffsetMs) {
+ return false;
+}
+
+bool WebrtcVideoConduit::GetRTPStats(unsigned int* jitterMs,
+ unsigned int* cumulativeLost) {
+ unsigned short fractionLost;
+ unsigned extendedMax;
+ int64_t rttMs;
+ // GetReceivedRTCPStatistics is a poorly named GetRTPStatistics variant
+ return !mPtrRTP->GetReceivedRTCPStatistics(mChannel, fractionLost,
+ *cumulativeLost,
+ extendedMax,
+ *jitterMs,
+ rttMs);
+}
+
+bool WebrtcVideoConduit::GetRTCPReceiverReport(DOMHighResTimeStamp* timestamp,
+ uint32_t* jitterMs,
+ uint32_t* packetsReceived,
+ uint64_t* bytesReceived,
+ uint32_t* cumulativeLost,
+ int32_t* rttMs) {
+ uint32_t ntpHigh, ntpLow;
+ uint16_t fractionLost;
+ bool result = !mPtrRTP->GetRemoteRTCPReceiverInfo(mChannel, ntpHigh, ntpLow,
+ *packetsReceived,
+ *bytesReceived,
+ jitterMs,
+ &fractionLost,
+ cumulativeLost,
+ rttMs);
+ if (result) {
+ *timestamp = NTPtoDOMHighResTimeStamp(ntpHigh, ntpLow);
+ }
+ return result;
+}
+
+bool WebrtcVideoConduit::GetRTCPSenderReport(DOMHighResTimeStamp* timestamp,
+ unsigned int* packetsSent,
+ uint64_t* bytesSent) {
+ struct webrtc::SenderInfo senderInfo;
+ bool result = !mPtrRTP->GetRemoteRTCPSenderInfo(mChannel, &senderInfo);
+ if (result) {
+ *timestamp = NTPtoDOMHighResTimeStamp(senderInfo.NTP_timestamp_high,
+ senderInfo.NTP_timestamp_low);
+ *packetsSent = senderInfo.sender_packet_count;
+ *bytesSent = senderInfo.sender_octet_count;
+ }
+ return result;
+}
+
+MediaConduitErrorCode
+WebrtcVideoConduit::InitMain()
+{
+#if defined(MOZILLA_INTERNAL_API)
+ // already know we must be on MainThread barring unit test weirdness
+ MOZ_ASSERT(NS_IsMainThread());
+
+ nsresult rv;
+ nsCOMPtr<nsIPrefService> prefs = do_GetService("@mozilla.org/preferences-service;1", &rv);
+ if (!NS_WARN_IF(NS_FAILED(rv)))
+ {
+ nsCOMPtr<nsIPrefBranch> branch = do_QueryInterface(prefs);
+
+ if (branch)
+ {
+ int32_t temp;
+ Unused << NS_WARN_IF(NS_FAILED(branch->GetBoolPref("media.video.test_latency", &mVideoLatencyTestEnable)));
+ if (!NS_WARN_IF(NS_FAILED(branch->GetIntPref("media.peerconnection.video.min_bitrate", &temp))))
+ {
+ if (temp >= 0) {
+ mMinBitrate = temp;
+ }
+ }
+ if (!NS_WARN_IF(NS_FAILED(branch->GetIntPref("media.peerconnection.video.start_bitrate", &temp))))
+ {
+ if (temp >= 0) {
+ mStartBitrate = temp;
+ }
+ }
+ if (!NS_WARN_IF(NS_FAILED(branch->GetIntPref("media.peerconnection.video.max_bitrate", &temp))))
+ {
+ if (temp >= 0) {
+ mMaxBitrate = temp;
+ }
+ }
+ if (mMinBitrate != 0 && mMinBitrate < webrtc::kViEMinCodecBitrate) {
+ mMinBitrate = webrtc::kViEMinCodecBitrate;
+ }
+ if (mStartBitrate < mMinBitrate) {
+ mStartBitrate = mMinBitrate;
+ }
+ if (mStartBitrate > mMaxBitrate) {
+ mStartBitrate = mMaxBitrate;
+ }
+ if (!NS_WARN_IF(NS_FAILED(branch->GetIntPref("media.peerconnection.video.min_bitrate_estimate", &temp))))
+ {
+ if (temp >= 0) {
+ mMinBitrateEstimate = temp;
+ }
+ }
+ bool use_loadmanager = false;
+ if (!NS_WARN_IF(NS_FAILED(branch->GetBoolPref("media.navigator.load_adapt", &use_loadmanager))))
+ {
+ if (use_loadmanager) {
+ mLoadManager = LoadManagerBuild();
+ }
+ }
+ }
+ }
+
+#ifdef MOZ_WIDGET_ANDROID
+ // get the JVM
+ JavaVM *jvm = jsjni_GetVM();
+
+ if (webrtc::VideoEngine::SetAndroidObjects(jvm) != 0) {
+ CSFLogError(logTag, "%s: could not set Android objects", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+#endif
+#endif
+ return kMediaConduitNoError;
+}
+
+/**
+ * Performs initialization of the MANDATORY components of the Video Engine
+ */
+MediaConduitErrorCode
+WebrtcVideoConduit::Init()
+{
+ CSFLogDebug(logTag, "%s this=%p", __FUNCTION__, this);
+ MediaConduitErrorCode result;
+ // Run code that must run on MainThread first
+ MOZ_ASSERT(NS_IsMainThread());
+ result = InitMain();
+ if (result != kMediaConduitNoError) {
+ return result;
+ }
+
+ // Per WebRTC APIs below function calls return nullptr on failure
+ mVideoEngine = webrtc::VideoEngine::Create();
+ if(!mVideoEngine)
+ {
+ CSFLogError(logTag, "%s Unable to create video engine ", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+
+ if( !(mPtrViEBase = ViEBase::GetInterface(mVideoEngine)))
+ {
+ CSFLogError(logTag, "%s Unable to get video base interface ", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+
+ if( !(mPtrViECapture = ViECapture::GetInterface(mVideoEngine)))
+ {
+ CSFLogError(logTag, "%s Unable to get video capture interface", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+
+ if( !(mPtrViECodec = ViECodec::GetInterface(mVideoEngine)))
+ {
+ CSFLogError(logTag, "%s Unable to get video codec interface ", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+
+ if( !(mPtrViENetwork = ViENetwork::GetInterface(mVideoEngine)))
+ {
+ CSFLogError(logTag, "%s Unable to get video network interface ", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+
+ if( !(mPtrViERender = ViERender::GetInterface(mVideoEngine)))
+ {
+ CSFLogError(logTag, "%s Unable to get video render interface ", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+
+ mPtrExtCodec = webrtc::ViEExternalCodec::GetInterface(mVideoEngine);
+ if (!mPtrExtCodec) {
+ CSFLogError(logTag, "%s Unable to get external codec interface: %d ",
+ __FUNCTION__,mPtrViEBase->LastError());
+ return kMediaConduitSessionNotInited;
+ }
+
+ if( !(mPtrRTP = webrtc::ViERTP_RTCP::GetInterface(mVideoEngine)))
+ {
+ CSFLogError(logTag, "%s Unable to get video RTCP interface ", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+
+ if ( !(mPtrExtCodec = webrtc::ViEExternalCodec::GetInterface(mVideoEngine)))
+ {
+ CSFLogError(logTag, "%s Unable to get external codec interface %d ",
+ __FUNCTION__, mPtrViEBase->LastError());
+ return kMediaConduitSessionNotInited;
+ }
+
+ CSFLogDebug(logTag, "%s Engine Created: Init'ng the interfaces ",__FUNCTION__);
+
+ if(mPtrViEBase->Init() == -1)
+ {
+ CSFLogError(logTag, " %s Video Engine Init Failed %d ",__FUNCTION__,
+ mPtrViEBase->LastError());
+ return kMediaConduitSessionNotInited;
+ }
+
+ if(mPtrViEBase->CreateChannel(mChannel) == -1)
+ {
+ CSFLogError(logTag, " %s Channel creation Failed %d ",__FUNCTION__,
+ mPtrViEBase->LastError());
+ return kMediaConduitChannelError;
+ }
+
+ if(mPtrViENetwork->RegisterSendTransport(mChannel, *this) == -1)
+ {
+ CSFLogError(logTag, "%s ViENetwork Failed %d ", __FUNCTION__,
+ mPtrViEBase->LastError());
+ return kMediaConduitTransportRegistrationFail;
+ }
+
+ if(mPtrViECapture->AllocateExternalCaptureDevice(mCapId,
+ mPtrExtCapture) == -1)
+ {
+ CSFLogError(logTag, "%s Unable to Allocate capture module: %d ",
+ __FUNCTION__, mPtrViEBase->LastError());
+ return kMediaConduitCaptureError;
+ }
+
+ if(mPtrViECapture->ConnectCaptureDevice(mCapId,mChannel) == -1)
+ {
+ CSFLogError(logTag, "%s Unable to Connect capture module: %d ",
+ __FUNCTION__,mPtrViEBase->LastError());
+ return kMediaConduitCaptureError;
+ }
+ // Set up some parameters, per juberti. Set MTU.
+ if(mPtrViENetwork->SetMTU(mChannel, 1200) != 0)
+ {
+ CSFLogError(logTag, "%s MTU Failed %d ", __FUNCTION__,
+ mPtrViEBase->LastError());
+ return kMediaConduitMTUError;
+ }
+ // Turn on RTCP and loss feedback reporting.
+ if(mPtrRTP->SetRTCPStatus(mChannel, webrtc::kRtcpCompound_RFC4585) != 0)
+ {
+ CSFLogError(logTag, "%s RTCPStatus Failed %d ", __FUNCTION__,
+ mPtrViEBase->LastError());
+ return kMediaConduitRTCPStatusError;
+ }
+
+ if (mPtrViERender->AddRenderer(mChannel,
+ webrtc::kVideoI420,
+ (webrtc::ExternalRenderer*) this) == -1) {
+ CSFLogError(logTag, "%s Failed to added external renderer ", __FUNCTION__);
+ return kMediaConduitInvalidRenderer;
+ }
+
+ if (mLoadManager) {
+ mPtrViEBase->RegisterCpuOveruseObserver(mChannel, mLoadManager);
+ mPtrViEBase->SetLoadManager(mLoadManager);
+ }
+
+ CSFLogError(logTag, "%s Initialization Done", __FUNCTION__);
+ return kMediaConduitNoError;
+}
+
+void
+WebrtcVideoConduit::Destroy()
+{
+ // The first one of a pair to be deleted shuts down media for both
+ //Deal with External Capturer
+ if(mPtrViECapture)
+ {
+ mPtrViECapture->DisconnectCaptureDevice(mCapId);
+ mPtrViECapture->ReleaseCaptureDevice(mCapId);
+ mPtrExtCapture = nullptr;
+ }
+
+ if (mPtrExtCodec) {
+ mPtrExtCodec->Release();
+ mPtrExtCodec = NULL;
+ }
+
+ //Deal with External Renderer
+ if(mPtrViERender)
+ {
+ if(mRenderer) {
+ mPtrViERender->StopRender(mChannel);
+ }
+ mPtrViERender->RemoveRenderer(mChannel);
+ }
+
+ //Deal with the transport
+ if(mPtrViENetwork)
+ {
+ mPtrViENetwork->DeregisterSendTransport(mChannel);
+ }
+
+ if(mPtrViEBase)
+ {
+ mPtrViEBase->StopSend(mChannel);
+ mPtrViEBase->StopReceive(mChannel);
+ mPtrViEBase->DeleteChannel(mChannel);
+ }
+
+ // mVideoCodecStat has a back-ptr to mPtrViECodec that must be released first
+ if (mVideoCodecStat) {
+ mVideoCodecStat->EndOfCallStats();
+ }
+ mVideoCodecStat = nullptr;
+ // We can't delete the VideoEngine until all these are released!
+ // And we can't use a Scoped ptr, since the order is arbitrary
+ mPtrViEBase = nullptr;
+ mPtrViECapture = nullptr;
+ mPtrViECodec = nullptr;
+ mPtrViENetwork = nullptr;
+ mPtrViERender = nullptr;
+ mPtrRTP = nullptr;
+ mPtrExtCodec = nullptr;
+
+ // only one opener can call Delete. Have it be the last to close.
+ if(mVideoEngine)
+ {
+ webrtc::VideoEngine::Delete(mVideoEngine);
+ }
+}
+
+void
+WebrtcVideoConduit::SyncTo(WebrtcAudioConduit *aConduit)
+{
+ CSFLogDebug(logTag, "%s Synced to %p", __FUNCTION__, aConduit);
+
+ // SyncTo(value) syncs to the AudioConduit, and if already synced replaces
+ // the current sync target. SyncTo(nullptr) cancels any existing sync and
+ // releases the strong ref to AudioConduit.
+ if (aConduit) {
+ mPtrViEBase->SetVoiceEngine(aConduit->GetVoiceEngine());
+ mPtrViEBase->ConnectAudioChannel(mChannel, aConduit->GetChannel());
+ // NOTE: this means the VideoConduit will keep the AudioConduit alive!
+ } else {
+ mPtrViEBase->DisconnectAudioChannel(mChannel);
+ mPtrViEBase->SetVoiceEngine(nullptr);
+ }
+
+ mSyncedTo = aConduit;
+}
+
+MediaConduitErrorCode
+WebrtcVideoConduit::AttachRenderer(RefPtr<VideoRenderer> aVideoRenderer)
+{
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+
+ //null renderer
+ if(!aVideoRenderer)
+ {
+ CSFLogError(logTag, "%s NULL Renderer", __FUNCTION__);
+ MOZ_ASSERT(false);
+ return kMediaConduitInvalidRenderer;
+ }
+
+ // This function is called only from main, so we only need to protect against
+ // modifying mRenderer while any webrtc.org code is trying to use it.
+ bool wasRendering;
+ {
+ ReentrantMonitorAutoEnter enter(mTransportMonitor);
+ wasRendering = !!mRenderer;
+ mRenderer = aVideoRenderer;
+ // Make sure the renderer knows the resolution
+ mRenderer->FrameSizeChange(mReceivingWidth,
+ mReceivingHeight,
+ mNumReceivingStreams);
+ }
+
+ if (!wasRendering) {
+ if(mPtrViERender->StartRender(mChannel) == -1)
+ {
+ CSFLogError(logTag, "%s Starting the Renderer Failed %d ", __FUNCTION__,
+ mPtrViEBase->LastError());
+ ReentrantMonitorAutoEnter enter(mTransportMonitor);
+ mRenderer = nullptr;
+ return kMediaConduitRendererFail;
+ }
+ }
+
+ return kMediaConduitNoError;
+}
+
+void
+WebrtcVideoConduit::DetachRenderer()
+{
+ {
+ ReentrantMonitorAutoEnter enter(mTransportMonitor);
+ if(mRenderer)
+ {
+ mRenderer = nullptr;
+ }
+ }
+
+ mPtrViERender->StopRender(mChannel);
+}
+
+MediaConduitErrorCode
+WebrtcVideoConduit::SetTransmitterTransport(RefPtr<TransportInterface> aTransport)
+{
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+
+ ReentrantMonitorAutoEnter enter(mTransportMonitor);
+ // set the transport
+ mTransmitterTransport = aTransport;
+ return kMediaConduitNoError;
+}
+
+MediaConduitErrorCode
+WebrtcVideoConduit::SetReceiverTransport(RefPtr<TransportInterface> aTransport)
+{
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+
+ ReentrantMonitorAutoEnter enter(mTransportMonitor);
+ // set the transport
+ mReceiverTransport = aTransport;
+ return kMediaConduitNoError;
+}
+MediaConduitErrorCode
+WebrtcVideoConduit::ConfigureCodecMode(webrtc::VideoCodecMode mode)
+{
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+ mCodecMode = mode;
+ return kMediaConduitNoError;
+}
+/**
+ * Note: Setting the send-codec on the Video Engine will restart the encoder,
+ * sets up new SSRC and reset RTP_RTCP module with the new codec setting.
+ *
+ * Note: this is called from MainThread, and the codec settings are read on
+ * videoframe delivery threads (i.e in SendVideoFrame(). With
+ * renegotiation/reconfiguration, this now needs a lock! Alternatively
+ * changes could be queued until the next frame is delivered using an
+ * Atomic pointer and swaps.
+ */
+MediaConduitErrorCode
+WebrtcVideoConduit::ConfigureSendMediaCodec(const VideoCodecConfig* codecConfig)
+{
+ CSFLogDebug(logTag, "%s for %s", __FUNCTION__, codecConfig ? codecConfig->mName.c_str() : "<null>");
+ bool codecFound = false;
+ MediaConduitErrorCode condError = kMediaConduitNoError;
+ int error = 0; //webrtc engine errors
+ webrtc::VideoCodec video_codec;
+ std::string payloadName;
+
+ memset(&video_codec, 0, sizeof(video_codec));
+
+ {
+ //validate basic params
+ if((condError = ValidateCodecConfig(codecConfig,true)) != kMediaConduitNoError)
+ {
+ return condError;
+ }
+ }
+
+ condError = StopTransmitting();
+ if (condError != kMediaConduitNoError) {
+ return condError;
+ }
+
+ if (mRtpStreamIdEnabled) {
+ video_codec.ridId = mRtpStreamIdExtId;
+ }
+ if (mExternalSendCodec &&
+ codecConfig->mType == mExternalSendCodec->mType) {
+ CSFLogError(logTag, "%s Configuring External H264 Send Codec", __FUNCTION__);
+
+ // width/height will be overridden on the first frame
+ video_codec.width = 320;
+ video_codec.height = 240;
+#ifdef MOZ_WEBRTC_OMX
+ if (codecConfig->mType == webrtc::kVideoCodecH264) {
+ video_codec.resolution_divisor = 16;
+ } else {
+ video_codec.resolution_divisor = 1; // We could try using it to handle odd resolutions
+ }
+#else
+ video_codec.resolution_divisor = 1; // We could try using it to handle odd resolutions
+#endif
+ video_codec.qpMax = 56;
+ video_codec.numberOfSimulcastStreams = 1;
+ video_codec.simulcastStream[0].jsScaleDownBy =
+ codecConfig->mEncodingConstraints.scaleDownBy;
+ video_codec.mode = mCodecMode;
+
+ codecFound = true;
+ } else {
+ // we should be good here to set the new codec.
+ for(int idx=0; idx < mPtrViECodec->NumberOfCodecs(); idx++)
+ {
+ if(0 == mPtrViECodec->GetCodec(idx, video_codec))
+ {
+ payloadName = video_codec.plName;
+ if(codecConfig->mName.compare(payloadName) == 0)
+ {
+ // Note: side-effect of this is that video_codec is filled in
+ // by GetCodec()
+ codecFound = true;
+ break;
+ }
+ }
+ }//for
+ }
+
+ if(codecFound == false)
+ {
+ CSFLogError(logTag, "%s Codec Mismatch ", __FUNCTION__);
+ return kMediaConduitInvalidSendCodec;
+ }
+ // Note: only for overriding parameters from GetCodec()!
+ CodecConfigToWebRTCCodec(codecConfig, video_codec);
+ if (mSendingWidth != 0) {
+ // We're already in a call and are reconfiguring (perhaps due to
+ // ReplaceTrack). Set to match the last frame we sent.
+
+ // We could also set mLastWidth to 0, to force immediate reconfig -
+ // more expensive, but perhaps less risk of missing something. Really
+ // on ReplaceTrack we should just call ConfigureCodecMode(), and if the
+ // mode changed, we re-configure.
+ // Do this after CodecConfigToWebRTCCodec() to avoid messing up simulcast
+ video_codec.width = mSendingWidth;
+ video_codec.height = mSendingHeight;
+ video_codec.maxFramerate = mSendingFramerate;
+ } else {
+ mSendingWidth = 0;
+ mSendingHeight = 0;
+ mSendingFramerate = video_codec.maxFramerate;
+ }
+
+ video_codec.mode = mCodecMode;
+
+ if(mPtrViECodec->SetSendCodec(mChannel, video_codec) == -1)
+ {
+ error = mPtrViEBase->LastError();
+ if(error == kViECodecInvalidCodec)
+ {
+ CSFLogError(logTag, "%s Invalid Send Codec", __FUNCTION__);
+ return kMediaConduitInvalidSendCodec;
+ }
+ CSFLogError(logTag, "%s SetSendCodec Failed %d ", __FUNCTION__,
+ mPtrViEBase->LastError());
+ return kMediaConduitUnknownError;
+ }
+
+ if (mMinBitrateEstimate != 0) {
+ mPtrViENetwork->SetBitrateConfig(mChannel,
+ mMinBitrateEstimate,
+ std::max(video_codec.startBitrate,
+ mMinBitrateEstimate),
+ std::max(video_codec.maxBitrate,
+ mMinBitrateEstimate));
+ }
+
+ if (!mVideoCodecStat) {
+ mVideoCodecStat = new VideoCodecStatistics(mChannel, mPtrViECodec);
+ }
+ mVideoCodecStat->Register(true);
+
+ // See Bug 1297058, enabling FEC when NACK is set on H.264 is problematic
+ bool use_fec = codecConfig->RtcpFbFECIsSet();
+ if ((mExternalSendCodec && codecConfig->mType == mExternalSendCodec->mType)
+ || codecConfig->mType == webrtc::kVideoCodecH264) {
+ if(codecConfig->RtcpFbNackIsSet("")) {
+ use_fec = false;
+ }
+ }
+
+ if (use_fec)
+ {
+ uint8_t payload_type_red = INVALID_RTP_PAYLOAD;
+ uint8_t payload_type_ulpfec = INVALID_RTP_PAYLOAD;
+ if (!DetermineREDAndULPFECPayloadTypes(payload_type_red, payload_type_ulpfec)) {
+ CSFLogError(logTag, "%s Unable to set FEC status: could not determine"
+ "payload type: red %u ulpfec %u",
+ __FUNCTION__, payload_type_red, payload_type_ulpfec);
+ return kMediaConduitFECStatusError;
+ }
+
+ if(codecConfig->RtcpFbNackIsSet("")) {
+ CSFLogDebug(logTag, "Enabling NACK/FEC (send) for video stream\n");
+ if (mPtrRTP->SetHybridNACKFECStatus(mChannel, true,
+ payload_type_red,
+ payload_type_ulpfec) != 0) {
+ CSFLogError(logTag, "%s SetHybridNACKFECStatus Failed %d ",
+ __FUNCTION__, mPtrViEBase->LastError());
+ return kMediaConduitHybridNACKFECStatusError;
+ }
+ } else {
+ CSFLogDebug(logTag, "Enabling FEC (send) for video stream\n");
+ if (mPtrRTP->SetFECStatus(mChannel, true,
+ payload_type_red, payload_type_ulpfec) != 0)
+ {
+ CSFLogError(logTag, "%s SetFECStatus Failed %d ", __FUNCTION__,
+ mPtrViEBase->LastError());
+ return kMediaConduitFECStatusError;
+ }
+ }
+ } else if(codecConfig->RtcpFbNackIsSet("")) {
+ CSFLogDebug(logTag, "Enabling NACK (send) for video stream\n");
+ if (mPtrRTP->SetNACKStatus(mChannel, true) != 0)
+ {
+ CSFLogError(logTag, "%s NACKStatus Failed %d ", __FUNCTION__,
+ mPtrViEBase->LastError());
+ return kMediaConduitNACKStatusError;
+ }
+ }
+
+ {
+ MutexAutoLock lock(mCodecMutex);
+
+ //Copy the applied config for future reference.
+ mCurSendCodecConfig = new VideoCodecConfig(*codecConfig);
+ }
+
+ bool remb_requested = codecConfig->RtcpFbRembIsSet();
+ mPtrRTP->SetRembStatus(mChannel, true, remb_requested);
+
+ return kMediaConduitNoError;
+}
+
+MediaConduitErrorCode
+WebrtcVideoConduit::ConfigureRecvMediaCodecs(
+ const std::vector<VideoCodecConfig* >& codecConfigList)
+{
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+ MediaConduitErrorCode condError = kMediaConduitNoError;
+ bool success = false;
+ std::string payloadName;
+
+ condError = StopReceiving();
+ if (condError != kMediaConduitNoError) {
+ return condError;
+ }
+
+ if(codecConfigList.empty())
+ {
+ CSFLogError(logTag, "%s Zero number of codecs to configure", __FUNCTION__);
+ return kMediaConduitMalformedArgument;
+ }
+
+ webrtc::ViEKeyFrameRequestMethod kf_request = webrtc::kViEKeyFrameRequestNone;
+ bool use_nack_basic = false;
+ bool use_tmmbr = false;
+ bool use_remb = false;
+ bool use_fec = false;
+
+ //Try Applying the codecs in the list
+ // we treat as success if atleast one codec was applied and reception was
+ // started successfully.
+ for(std::vector<VideoCodecConfig*>::size_type i=0;i < codecConfigList.size();i++)
+ {
+ //if the codec param is invalid or diplicate, return error
+ if((condError = ValidateCodecConfig(codecConfigList[i],false)) != kMediaConduitNoError)
+ {
+ return condError;
+ }
+
+ // Check for the keyframe request type: PLI is preferred
+ // over FIR, and FIR is preferred over none.
+ if (codecConfigList[i]->RtcpFbNackIsSet("pli"))
+ {
+ kf_request = webrtc::kViEKeyFrameRequestPliRtcp;
+ } else if(kf_request == webrtc::kViEKeyFrameRequestNone &&
+ codecConfigList[i]->RtcpFbCcmIsSet("fir"))
+ {
+ kf_request = webrtc::kViEKeyFrameRequestFirRtcp;
+ }
+
+ // Check whether NACK is requested
+ if(codecConfigList[i]->RtcpFbNackIsSet(""))
+ {
+ use_nack_basic = true;
+ }
+
+ // Check whether TMMBR is requested
+ if (codecConfigList[i]->RtcpFbCcmIsSet("tmmbr")) {
+ use_tmmbr = true;
+ }
+
+ // Check whether REMB is requested
+ if (codecConfigList[i]->RtcpFbRembIsSet()) {
+ use_remb = true;
+ }
+
+ // Check whether FEC is requested
+ if (codecConfigList[i]->RtcpFbFECIsSet()) {
+ use_fec = true;
+ }
+
+ webrtc::VideoCodec video_codec;
+
+ memset(&video_codec, 0, sizeof(webrtc::VideoCodec));
+
+ if (mExternalRecvCodec &&
+ codecConfigList[i]->mType == mExternalRecvCodec->mType) {
+ CSFLogError(logTag, "%s Configuring External H264 Receive Codec", __FUNCTION__);
+
+ // XXX Do we need a separate setting for receive maxbitrate? Is it
+ // different for hardware codecs? For now assume symmetry.
+ CodecConfigToWebRTCCodec(codecConfigList[i], video_codec);
+
+ // values SetReceiveCodec() cares about are name, type, maxbitrate
+ if(mPtrViECodec->SetReceiveCodec(mChannel,video_codec) == -1)
+ {
+ CSFLogError(logTag, "%s Invalid Receive Codec %d ", __FUNCTION__,
+ mPtrViEBase->LastError());
+ } else {
+ CSFLogError(logTag, "%s Successfully Set the codec %s", __FUNCTION__,
+ codecConfigList[i]->mName.c_str());
+ success = true;
+ }
+ } else {
+ //Retrieve pre-populated codec structure for our codec.
+ for(int idx=0; idx < mPtrViECodec->NumberOfCodecs(); idx++)
+ {
+ if(mPtrViECodec->GetCodec(idx, video_codec) == 0)
+ {
+ payloadName = video_codec.plName;
+ if(codecConfigList[i]->mName.compare(payloadName) == 0)
+ {
+ CodecConfigToWebRTCCodec(codecConfigList[i], video_codec);
+ if(mPtrViECodec->SetReceiveCodec(mChannel,video_codec) == -1)
+ {
+ CSFLogError(logTag, "%s Invalid Receive Codec %d ", __FUNCTION__,
+ mPtrViEBase->LastError());
+ } else {
+ CSFLogError(logTag, "%s Successfully Set the codec %s", __FUNCTION__,
+ codecConfigList[i]->mName.c_str());
+ success = true;
+ }
+ break; //we found a match
+ }
+ }
+ }//end for codeclist
+ }
+ }//end for
+
+ if(!success)
+ {
+ CSFLogError(logTag, "%s Setting Receive Codec Failed ", __FUNCTION__);
+ return kMediaConduitInvalidReceiveCodec;
+ }
+
+ if (!mVideoCodecStat) {
+ mVideoCodecStat = new VideoCodecStatistics(mChannel, mPtrViECodec);
+ }
+ mVideoCodecStat->Register(false);
+
+ // XXX Currently, we gather up all of the feedback types that the remote
+ // party indicated it supports for all video codecs and configure the entire
+ // conduit based on those capabilities. This is technically out of spec,
+ // as these values should be configured on a per-codec basis. However,
+ // the video engine only provides this API on a per-conduit basis, so that's
+ // how we have to do it. The approach of considering the remote capablities
+ // for the entire conduit to be a union of all remote codec capabilities
+ // (rather than the more conservative approach of using an intersection)
+ // is made to provide as many feedback mechanisms as are likely to be
+ // processed by the remote party (and should be relatively safe, since the
+ // remote party is required to ignore feedback types that it does not
+ // understand).
+ //
+ // Note that our configuration uses this union of remote capabilites as
+ // input to the configuration. It is not isomorphic to the configuration.
+ // For example, it only makes sense to have one frame request mechanism
+ // active at a time; so, if the remote party indicates more than one
+ // supported mechanism, we're only configuring the one we most prefer.
+ //
+ // See http://code.google.com/p/webrtc/issues/detail?id=2331
+
+ if (kf_request != webrtc::kViEKeyFrameRequestNone)
+ {
+ CSFLogDebug(logTag, "Enabling %s frame requests for video stream\n",
+ (kf_request == webrtc::kViEKeyFrameRequestPliRtcp ?
+ "PLI" : "FIR"));
+ if(mPtrRTP->SetKeyFrameRequestMethod(mChannel, kf_request) != 0)
+ {
+ CSFLogError(logTag, "%s KeyFrameRequest Failed %d ", __FUNCTION__,
+ mPtrViEBase->LastError());
+ return kMediaConduitKeyFrameRequestError;
+ }
+ }
+
+ switch (kf_request) {
+ case webrtc::kViEKeyFrameRequestNone:
+ mFrameRequestMethod = FrameRequestNone;
+ break;
+ case webrtc::kViEKeyFrameRequestPliRtcp:
+ mFrameRequestMethod = FrameRequestPli;
+ break;
+ case webrtc::kViEKeyFrameRequestFirRtcp:
+ mFrameRequestMethod = FrameRequestFir;
+ break;
+ default:
+ MOZ_ASSERT(false);
+ mFrameRequestMethod = FrameRequestUnknown;
+ }
+
+ if (use_fec)
+ {
+ uint8_t payload_type_red = INVALID_RTP_PAYLOAD;
+ uint8_t payload_type_ulpfec = INVALID_RTP_PAYLOAD;
+ if (!DetermineREDAndULPFECPayloadTypes(payload_type_red, payload_type_ulpfec)) {
+ CSFLogError(logTag, "%s Unable to set FEC status: could not determine"
+ "payload type: red %u ulpfec %u",
+ __FUNCTION__, payload_type_red, payload_type_ulpfec);
+ return kMediaConduitFECStatusError;
+ }
+
+ // We also need to call SetReceiveCodec for RED and ULPFEC codecs
+ for(int idx=0; idx < mPtrViECodec->NumberOfCodecs(); idx++) {
+ webrtc::VideoCodec video_codec;
+ if(mPtrViECodec->GetCodec(idx, video_codec) == 0) {
+ payloadName = video_codec.plName;
+ if(video_codec.codecType == webrtc::VideoCodecType::kVideoCodecRED ||
+ video_codec.codecType == webrtc::VideoCodecType::kVideoCodecULPFEC) {
+ if(mPtrViECodec->SetReceiveCodec(mChannel,video_codec) == -1) {
+ CSFLogError(logTag, "%s Invalid Receive Codec %d ", __FUNCTION__,
+ mPtrViEBase->LastError());
+ } else {
+ CSFLogDebug(logTag, "%s Successfully Set the codec %s", __FUNCTION__,
+ video_codec.plName);
+ }
+ }
+ }
+ }
+
+ if (use_nack_basic) {
+ CSFLogDebug(logTag, "Enabling NACK/FEC (recv) for video stream\n");
+ if (mPtrRTP->SetHybridNACKFECStatus(mChannel, true,
+ payload_type_red,
+ payload_type_ulpfec) != 0) {
+ CSFLogError(logTag, "%s SetHybridNACKFECStatus Failed %d ",
+ __FUNCTION__, mPtrViEBase->LastError());
+ return kMediaConduitNACKStatusError;
+ }
+ } else {
+ CSFLogDebug(logTag, "Enabling FEC (recv) for video stream\n");
+ if (mPtrRTP->SetFECStatus(mChannel, true,
+ payload_type_red, payload_type_ulpfec) != 0)
+ {
+ CSFLogError(logTag, "%s SetFECStatus Failed %d ", __FUNCTION__,
+ mPtrViEBase->LastError());
+ return kMediaConduitNACKStatusError;
+ }
+ }
+ } else if(use_nack_basic) {
+ CSFLogDebug(logTag, "Enabling NACK (recv) for video stream\n");
+ if (mPtrRTP->SetNACKStatus(mChannel, true) != 0)
+ {
+ CSFLogError(logTag, "%s NACKStatus Failed %d ", __FUNCTION__,
+ mPtrViEBase->LastError());
+ return kMediaConduitNACKStatusError;
+ }
+ }
+ mUsingNackBasic = use_nack_basic;
+ mUsingFEC = use_fec;
+
+ if (use_tmmbr) {
+ CSFLogDebug(logTag, "Enabling TMMBR for video stream");
+ if (mPtrRTP->SetTMMBRStatus(mChannel, true) != 0) {
+ CSFLogError(logTag, "%s SetTMMBRStatus Failed %d ", __FUNCTION__,
+ mPtrViEBase->LastError());
+ return kMediaConduitTMMBRStatusError;
+ }
+ }
+ mUsingTmmbr = use_tmmbr;
+
+ condError = StartReceiving();
+ if (condError != kMediaConduitNoError) {
+ return condError;
+ }
+
+ // by now we should be successfully started the reception
+ CSFLogDebug(logTag, "REMB enabled for video stream %s",
+ (use_remb ? "yes" : "no"));
+ mPtrRTP->SetRembStatus(mChannel, use_remb, true);
+ return kMediaConduitNoError;
+}
+
+template<typename T>
+T MinIgnoreZero(const T& a, const T& b)
+{
+ return std::min(a? a:b, b? b:a);
+}
+
+struct ResolutionAndBitrateLimits {
+ uint32_t resolution_in_mb;
+ uint16_t min_bitrate;
+ uint16_t start_bitrate;
+ uint16_t max_bitrate;
+};
+
+#define MB_OF(w,h) ((unsigned int)((((w+15)>>4))*((unsigned int)((h+15)>>4))))
+
+// For now, try to set the max rates well above the knee in the curve.
+// Chosen somewhat arbitrarily; it's hard to find good data oriented for
+// realtime interactive/talking-head recording. These rates assume
+// 30fps.
+
+// XXX Populate this based on a pref (which we should consider sorting because
+// people won't assume they need to).
+static ResolutionAndBitrateLimits kResolutionAndBitrateLimits[] = {
+ {MB_OF(1920, 1200), 1500, 2000, 10000}, // >HD (3K, 4K, etc)
+ {MB_OF(1280, 720), 1200, 1500, 5000}, // HD ~1080-1200
+ {MB_OF(800, 480), 600, 800, 2500}, // HD ~720
+ {tl::Max<MB_OF(400, 240), MB_OF(352, 288)>::value, 200, 300, 1300}, // VGA, WVGA
+ {MB_OF(176, 144), 100, 150, 500}, // WQVGA, CIF
+ {0 , 40, 80, 250} // QCIF and below
+};
+
+void
+WebrtcVideoConduit::SelectBitrates(unsigned short width,
+ unsigned short height,
+ unsigned int cap,
+ mozilla::Atomic<int32_t, mozilla::Relaxed>& aLastFramerateTenths,
+ unsigned int& out_min,
+ unsigned int& out_start,
+ unsigned int& out_max)
+{
+ // max bandwidth should be proportional (not linearly!) to resolution, and
+ // proportional (perhaps linearly, or close) to current frame rate.
+ unsigned int fs = MB_OF(width, height);
+
+ for (ResolutionAndBitrateLimits resAndLimits : kResolutionAndBitrateLimits) {
+ if (fs > resAndLimits.resolution_in_mb &&
+ // pick the highest range where at least start rate is within cap
+ // (or if we're at the end of the array).
+ (!cap || resAndLimits.start_bitrate <= cap ||
+ resAndLimits.resolution_in_mb == 0)) {
+ out_min = MinIgnoreZero((unsigned int)resAndLimits.min_bitrate, cap);
+ out_start = MinIgnoreZero((unsigned int)resAndLimits.start_bitrate, cap);
+ out_max = MinIgnoreZero((unsigned int)resAndLimits.max_bitrate, cap);
+ break;
+ }
+ }
+
+ // mLastFramerateTenths is an atomic, and scaled by *10
+ double framerate = std::min((aLastFramerateTenths/10.),60.0);
+ MOZ_ASSERT(framerate > 0);
+ // Now linear reduction/increase based on fps (max 60fps i.e. doubling)
+ if (framerate >= 10) {
+ out_min = out_min * (framerate/30);
+ out_start = out_start * (framerate/30);
+ out_max = std::max((unsigned int)(out_max * (framerate/30)), cap);
+ } else {
+ // At low framerates, don't reduce bandwidth as much - cut slope to 1/2.
+ // Mostly this would be ultra-low-light situations/mobile or screensharing.
+ out_min = out_min * ((10-(framerate/2))/30);
+ out_start = out_start * ((10-(framerate/2))/30);
+ out_max = std::max((unsigned int)(out_max * ((10-(framerate/2))/30)), cap);
+ }
+
+ if (mMinBitrate && mMinBitrate > out_min) {
+ out_min = mMinBitrate;
+ }
+ // If we try to set a minimum bitrate that is too low, ViE will reject it.
+ out_min = std::max((unsigned int) webrtc::kViEMinCodecBitrate,
+ out_min);
+ if (mStartBitrate && mStartBitrate > out_start) {
+ out_start = mStartBitrate;
+ }
+ out_start = std::max(out_start, out_min);
+
+ // Note: mMaxBitrate is the max transport bitrate - it applies to a
+ // single codec encoding, but should also apply to the sum of all
+ // simulcast layers in this encoding!
+ // So sum(layers.maxBitrate) <= mMaxBitrate
+ if (mMaxBitrate && mMaxBitrate > out_max) {
+ out_max = mMaxBitrate;
+ }
+}
+
+static void ConstrainPreservingAspectRatioExact(uint32_t max_fs,
+ unsigned short* width,
+ unsigned short* height)
+{
+ // We could try to pick a better starting divisor, but it won't make any real
+ // performance difference.
+ for (size_t d = 1; d < std::min(*width, *height); ++d) {
+ if ((*width % d) || (*height % d)) {
+ continue; // Not divisible
+ }
+
+ if (((*width) * (*height))/(d*d) <= max_fs) {
+ *width /= d;
+ *height /= d;
+ return;
+ }
+ }
+
+ *width = 0;
+ *height = 0;
+}
+
+static void ConstrainPreservingAspectRatio(uint16_t max_width,
+ uint16_t max_height,
+ unsigned short* width,
+ unsigned short* height)
+{
+ if (((*width) <= max_width) && ((*height) <= max_height)) {
+ return;
+ }
+
+ if ((*width) * max_height > max_width * (*height))
+ {
+ (*height) = max_width * (*height) / (*width);
+ (*width) = max_width;
+ }
+ else
+ {
+ (*width) = max_height * (*width) / (*height);
+ (*height) = max_height;
+ }
+}
+
+// XXX we need to figure out how to feed back changes in preferred capture
+// resolution to the getUserMedia source.
+// Returns boolean if we've submitted an async change (and took ownership
+// of *frame's data)
+bool
+WebrtcVideoConduit::SelectSendResolution(unsigned short width,
+ unsigned short height,
+ webrtc::I420VideoFrame *frame) // may be null
+{
+ mCodecMutex.AssertCurrentThreadOwns();
+ // XXX This will do bandwidth-resolution adaptation as well - bug 877954
+
+ mLastWidth = width;
+ mLastHeight = height;
+ // Enforce constraints
+ if (mCurSendCodecConfig) {
+ uint16_t max_width = mCurSendCodecConfig->mEncodingConstraints.maxWidth;
+ uint16_t max_height = mCurSendCodecConfig->mEncodingConstraints.maxHeight;
+ if (max_width || max_height) {
+ max_width = max_width ? max_width : UINT16_MAX;
+ max_height = max_height ? max_height : UINT16_MAX;
+ ConstrainPreservingAspectRatio(max_width, max_height, &width, &height);
+ }
+
+ // Limit resolution to max-fs while keeping same aspect ratio as the
+ // incoming image.
+ if (mCurSendCodecConfig->mEncodingConstraints.maxFs)
+ {
+ uint32_t max_fs = mCurSendCodecConfig->mEncodingConstraints.maxFs;
+ unsigned int cur_fs, mb_width, mb_height, mb_max;
+
+ // Could we make this simpler by picking the larger of width and height,
+ // calculating a max for just that value based on the scale parameter,
+ // and then let ConstrainPreservingAspectRatio do the rest?
+ mb_width = (width + 15) >> 4;
+ mb_height = (height + 15) >> 4;
+
+ cur_fs = mb_width * mb_height;
+
+ // Limit resolution to max_fs, but don't scale up.
+ if (cur_fs > max_fs)
+ {
+ double scale_ratio;
+
+ scale_ratio = sqrt((double) max_fs / (double) cur_fs);
+
+ mb_width = mb_width * scale_ratio;
+ mb_height = mb_height * scale_ratio;
+
+ // Adjust mb_width and mb_height if they were truncated to zero.
+ if (mb_width == 0) {
+ mb_width = 1;
+ mb_height = std::min(mb_height, max_fs);
+ }
+ if (mb_height == 0) {
+ mb_height = 1;
+ mb_width = std::min(mb_width, max_fs);
+ }
+ }
+
+ // Limit width/height seperately to limit effect of extreme aspect ratios.
+ mb_max = (unsigned) sqrt(8 * (double) max_fs);
+
+ max_width = 16 * std::min(mb_width, mb_max);
+ max_height = 16 * std::min(mb_height, mb_max);
+ ConstrainPreservingAspectRatio(max_width, max_height, &width, &height);
+ }
+ }
+
+
+ // Adapt to getUserMedia resolution changes
+ // check if we need to reconfigure the sending resolution.
+ bool changed = false;
+ if (mSendingWidth != width || mSendingHeight != height)
+ {
+ CSFLogDebug(logTag, "%s: resolution changing to %ux%u (from %ux%u)",
+ __FUNCTION__, width, height, mSendingWidth, mSendingHeight);
+ // This will avoid us continually retrying this operation if it fails.
+ // If the resolution changes, we'll try again. In the meantime, we'll
+ // keep using the old size in the encoder.
+ mSendingWidth = width;
+ mSendingHeight = height;
+ changed = true;
+ }
+
+ // uses mSendingWidth/Height
+ unsigned int framerate = SelectSendFrameRate(mSendingFramerate);
+ if (mSendingFramerate != framerate) {
+ CSFLogDebug(logTag, "%s: framerate changing to %u (from %u)",
+ __FUNCTION__, framerate, mSendingFramerate);
+ mSendingFramerate = framerate;
+ changed = true;
+ }
+
+ if (changed) {
+ // On a resolution change, bounce this to the correct thread to
+ // re-configure (same as used for Init(). Do *not* block the calling
+ // thread since that may be the MSG thread.
+
+ // MUST run on the same thread as Init()/etc
+ if (!NS_IsMainThread()) {
+ // Note: on *initial* config (first frame), best would be to drop
+ // frames until the config is done, then encode the most recent frame
+ // provided and continue from there. We don't do this, but we do drop
+ // all frames while in the process of a reconfig and then encode the
+ // frame that started the reconfig, which is close. There may be
+ // barely perceptible glitch in the video due to the dropped frame(s).
+ mInReconfig = true;
+
+ // We can't pass a UniquePtr<> or unique_ptr<> to a lambda directly
+ webrtc::I420VideoFrame *new_frame = nullptr;
+ if (frame) {
+ new_frame = new webrtc::I420VideoFrame();
+ // the internal buffer pointer is refcounted, so we don't have 2 copies here
+ new_frame->ShallowCopy(*frame);
+ }
+ RefPtr<WebrtcVideoConduit> self(this);
+ RefPtr<Runnable> webrtc_runnable =
+ media::NewRunnableFrom([self, width, height, new_frame]() -> nsresult {
+ UniquePtr<webrtc::I420VideoFrame> local_frame(new_frame); // Simplify cleanup
+
+ MutexAutoLock lock(self->mCodecMutex);
+ return self->ReconfigureSendCodec(width, height, new_frame);
+ });
+ // new_frame now owned by lambda
+ CSFLogDebug(logTag, "%s: proxying lambda to WebRTC thread for reconfig (width %u/%u, height %u/%u",
+ __FUNCTION__, width, mLastWidth, height, mLastHeight);
+ NS_DispatchToMainThread(webrtc_runnable.forget());
+ if (new_frame) {
+ return true; // queued it
+ }
+ } else {
+ // already on the right thread
+ ReconfigureSendCodec(width, height, frame);
+ }
+ }
+ return false;
+}
+
+nsresult
+WebrtcVideoConduit::ReconfigureSendCodec(unsigned short width,
+ unsigned short height,
+ webrtc::I420VideoFrame *frame)
+{
+ mCodecMutex.AssertCurrentThreadOwns();
+
+ // Get current vie codec.
+ webrtc::VideoCodec vie_codec;
+ int32_t err;
+
+ mInReconfig = false;
+ if ((err = mPtrViECodec->GetSendCodec(mChannel, vie_codec)) != 0)
+ {
+ CSFLogError(logTag, "%s: GetSendCodec failed, err %d", __FUNCTION__, err);
+ return NS_ERROR_FAILURE;
+ }
+
+ CSFLogDebug(logTag,
+ "%s: Requesting resolution change to %ux%u (from %ux%u)",
+ __FUNCTION__, width, height, vie_codec.width, vie_codec.height);
+
+ if (mRtpStreamIdEnabled) {
+ vie_codec.ridId = mRtpStreamIdExtId;
+ }
+
+ vie_codec.width = width;
+ vie_codec.height = height;
+ vie_codec.maxFramerate = mSendingFramerate;
+ SelectBitrates(vie_codec.width, vie_codec.height, 0,
+ mLastFramerateTenths,
+ vie_codec.minBitrate,
+ vie_codec.startBitrate,
+ vie_codec.maxBitrate);
+
+ // These are based on lowest-fidelity, because if there is insufficient
+ // bandwidth for all streams, only the lowest fidelity one will be sent.
+ uint32_t minMinBitrate = 0;
+ uint32_t minStartBitrate = 0;
+ // Total for all simulcast streams.
+ uint32_t totalMaxBitrate = 0;
+
+ for (size_t i = vie_codec.numberOfSimulcastStreams; i > 0; --i) {
+ webrtc::SimulcastStream& stream(vie_codec.simulcastStream[i - 1]);
+ stream.width = width;
+ stream.height = height;
+ MOZ_ASSERT(stream.jsScaleDownBy >= 1.0);
+ uint32_t new_width = uint32_t(width / stream.jsScaleDownBy);
+ uint32_t new_height = uint32_t(height / stream.jsScaleDownBy);
+ // TODO: If two layers are similar, only alloc bits to one (Bug 1249859)
+ if (new_width != width || new_height != height) {
+ if (vie_codec.numberOfSimulcastStreams == 1) {
+ // Use less strict scaling in unicast. That way 320x240 / 3 = 106x79.
+ ConstrainPreservingAspectRatio(new_width, new_height,
+ &stream.width, &stream.height);
+ } else {
+ // webrtc.org supposedly won't tolerate simulcast unless every stream
+ // is exactly the same aspect ratio. 320x240 / 3 = 80x60.
+ ConstrainPreservingAspectRatioExact(new_width*new_height,
+ &stream.width, &stream.height);
+ }
+ }
+ // Give each layer default appropriate bandwidth limits based on the
+ // resolution/framerate of that layer
+ SelectBitrates(stream.width, stream.height,
+ MinIgnoreZero(stream.jsMaxBitrate, vie_codec.maxBitrate),
+ mLastFramerateTenths,
+ stream.minBitrate,
+ stream.targetBitrate,
+ stream.maxBitrate);
+
+ // webrtc.org expects the last, highest fidelity, simulcast stream to
+ // always have the same resolution as vie_codec
+ // Also set the least user-constrained of the stream bitrates on vie_codec.
+ if (i == vie_codec.numberOfSimulcastStreams) {
+ vie_codec.width = stream.width;
+ vie_codec.height = stream.height;
+ }
+ minMinBitrate = MinIgnoreZero(stream.minBitrate, minMinBitrate);
+ minStartBitrate = MinIgnoreZero(stream.targetBitrate, minStartBitrate);
+ totalMaxBitrate += stream.maxBitrate;
+ }
+ if (vie_codec.numberOfSimulcastStreams != 0) {
+ vie_codec.minBitrate = std::max(minMinBitrate, vie_codec.minBitrate);
+ vie_codec.maxBitrate = std::min(totalMaxBitrate, vie_codec.maxBitrate);
+ vie_codec.startBitrate = std::max(vie_codec.minBitrate,
+ std::min(minStartBitrate,
+ vie_codec.maxBitrate));
+ }
+ vie_codec.mode = mCodecMode;
+ if ((err = mPtrViECodec->SetSendCodec(mChannel, vie_codec)) != 0)
+ {
+ CSFLogError(logTag, "%s: SetSendCodec(%ux%u) failed, err %d",
+ __FUNCTION__, width, height, err);
+ return NS_ERROR_FAILURE;
+ }
+ if (mMinBitrateEstimate != 0) {
+ mPtrViENetwork->SetBitrateConfig(mChannel,
+ mMinBitrateEstimate,
+ std::max(vie_codec.startBitrate,
+ mMinBitrateEstimate),
+ std::max(vie_codec.maxBitrate,
+ mMinBitrateEstimate));
+ }
+
+ CSFLogDebug(logTag, "%s: Encoder resolution changed to %ux%u @ %ufps, bitrate %u:%u",
+ __FUNCTION__, width, height, mSendingFramerate,
+ vie_codec.minBitrate, vie_codec.maxBitrate);
+ if (frame) {
+ // XXX I really don't like doing this from MainThread...
+ mPtrExtCapture->IncomingFrame(*frame);
+ mVideoCodecStat->SentFrame();
+ CSFLogDebug(logTag, "%s Inserted a frame from reconfig lambda", __FUNCTION__);
+ }
+ return NS_OK;
+}
+
+// Invoked under lock of mCodecMutex!
+unsigned int
+WebrtcVideoConduit::SelectSendFrameRate(unsigned int framerate) const
+{
+ mCodecMutex.AssertCurrentThreadOwns();
+ unsigned int new_framerate = framerate;
+
+ // Limit frame rate based on max-mbps
+ if (mCurSendCodecConfig && mCurSendCodecConfig->mEncodingConstraints.maxMbps)
+ {
+ unsigned int cur_fs, mb_width, mb_height, max_fps;
+
+ mb_width = (mSendingWidth + 15) >> 4;
+ mb_height = (mSendingHeight + 15) >> 4;
+
+ cur_fs = mb_width * mb_height;
+ if (cur_fs > 0) { // in case no frames have been sent
+ max_fps = mCurSendCodecConfig->mEncodingConstraints.maxMbps/cur_fs;
+ if (max_fps < mSendingFramerate) {
+ new_framerate = max_fps;
+ }
+
+ if (mCurSendCodecConfig->mEncodingConstraints.maxFps != 0 &&
+ mCurSendCodecConfig->mEncodingConstraints.maxFps < mSendingFramerate) {
+ new_framerate = mCurSendCodecConfig->mEncodingConstraints.maxFps;
+ }
+ }
+ }
+ return new_framerate;
+}
+
+MediaConduitErrorCode
+WebrtcVideoConduit::SetExternalSendCodec(VideoCodecConfig* config,
+ VideoEncoder* encoder) {
+ NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
+ if (!mPtrExtCodec->RegisterExternalSendCodec(mChannel,
+ config->mType,
+ static_cast<WebrtcVideoEncoder*>(encoder),
+ false)) {
+ mExternalSendCodecHandle = encoder;
+ mExternalSendCodec = new VideoCodecConfig(*config);
+ return kMediaConduitNoError;
+ }
+ return kMediaConduitInvalidSendCodec;
+}
+
+MediaConduitErrorCode
+WebrtcVideoConduit::SetExternalRecvCodec(VideoCodecConfig* config,
+ VideoDecoder* decoder) {
+ NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
+ if (!mPtrExtCodec->RegisterExternalReceiveCodec(mChannel,
+ config->mType,
+ static_cast<WebrtcVideoDecoder*>(decoder))) {
+ mExternalRecvCodecHandle = decoder;
+ mExternalRecvCodec = new VideoCodecConfig(*config);
+ return kMediaConduitNoError;
+ }
+ return kMediaConduitInvalidReceiveCodec;
+}
+
+MediaConduitErrorCode
+WebrtcVideoConduit::EnableRTPStreamIdExtension(bool enabled, uint8_t id) {
+ mRtpStreamIdEnabled = enabled;
+ mRtpStreamIdExtId = id;
+ return kMediaConduitNoError;
+}
+
+MediaConduitErrorCode
+WebrtcVideoConduit::SendVideoFrame(unsigned char* video_frame,
+ unsigned int video_frame_length,
+ unsigned short width,
+ unsigned short height,
+ VideoType video_type,
+ uint64_t capture_time)
+{
+
+ //check for the parameters sanity
+ if(!video_frame || video_frame_length == 0 ||
+ width == 0 || height == 0)
+ {
+ CSFLogError(logTag, "%s Invalid Parameters ",__FUNCTION__);
+ MOZ_ASSERT(false);
+ return kMediaConduitMalformedArgument;
+ }
+ MOZ_ASSERT(video_type == VideoType::kVideoI420);
+ MOZ_ASSERT(mPtrExtCapture);
+
+ // Transmission should be enabled before we insert any frames.
+ if(!mEngineTransmitting)
+ {
+ CSFLogError(logTag, "%s Engine not transmitting ", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+
+ // insert the frame to video engine in I420 format only
+ webrtc::I420VideoFrame i420_frame;
+ i420_frame.CreateFrame(video_frame, width, height, webrtc::kVideoRotation_0);
+ i420_frame.set_timestamp(capture_time);
+ i420_frame.set_render_time_ms(capture_time);
+
+ return SendVideoFrame(i420_frame);
+}
+
+MediaConduitErrorCode
+WebrtcVideoConduit::SendVideoFrame(webrtc::I420VideoFrame& frame)
+{
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+ // See if we need to recalculate what we're sending.
+ // Don't compare mSendingWidth/Height, since those may not be the same as the input.
+ {
+ MutexAutoLock lock(mCodecMutex);
+ if (mInReconfig) {
+ // Waiting for it to finish
+ return kMediaConduitNoError;
+ }
+ if (frame.width() != mLastWidth || frame.height() != mLastHeight) {
+ CSFLogDebug(logTag, "%s: call SelectSendResolution with %ux%u",
+ __FUNCTION__, frame.width(), frame.height());
+ if (SelectSendResolution(frame.width(), frame.height(), &frame)) {
+ // SelectSendResolution took ownership of the data in i420_frame.
+ // Submit the frame after reconfig is done
+ return kMediaConduitNoError;
+ }
+ }
+ }
+ mPtrExtCapture->IncomingFrame(frame);
+
+ mVideoCodecStat->SentFrame();
+ CSFLogDebug(logTag, "%s Inserted a frame", __FUNCTION__);
+ return kMediaConduitNoError;
+}
+
+// Transport Layer Callbacks
+MediaConduitErrorCode
+WebrtcVideoConduit::ReceivedRTPPacket(const void *data, int len)
+{
+ CSFLogDebug(logTag, "%s: seq# %u, Channel %d, Len %d ", __FUNCTION__,
+ (uint16_t) ntohs(((uint16_t*) data)[1]), mChannel, len);
+
+ // Media Engine should be receiving already.
+ if(mEngineReceiving)
+ {
+ // let the engine know of a RTP packet to decode
+ // XXX we need to get passed the time the packet was received
+ if(mPtrViENetwork->ReceivedRTPPacket(mChannel, data, len, webrtc::PacketTime()) == -1)
+ {
+ int error = mPtrViEBase->LastError();
+ CSFLogError(logTag, "%s RTP Processing Failed %d ", __FUNCTION__, error);
+ if(error >= kViERtpRtcpInvalidChannelId && error <= kViERtpRtcpRtcpDisabled)
+ {
+ return kMediaConduitRTPProcessingFailed;
+ }
+ return kMediaConduitRTPRTCPModuleError;
+ }
+ } else {
+ CSFLogError(logTag, "Error: %s when not receiving", __FUNCTION__);
+ return kMediaConduitSessionNotInited;
+ }
+
+ return kMediaConduitNoError;
+}
+
+MediaConduitErrorCode
+WebrtcVideoConduit::ReceivedRTCPPacket(const void *data, int len)
+{
+ CSFLogDebug(logTag, " %s Channel %d, Len %d ", __FUNCTION__, mChannel, len);
+
+ //Media Engine should be receiving already
+ if(mPtrViENetwork->ReceivedRTCPPacket(mChannel,data,len) == -1)
+ {
+ int error = mPtrViEBase->LastError();
+ CSFLogError(logTag, "%s RTCP Processing Failed %d", __FUNCTION__, error);
+ if(error >= kViERtpRtcpInvalidChannelId && error <= kViERtpRtcpRtcpDisabled)
+ {
+ return kMediaConduitRTPProcessingFailed;
+ }
+ return kMediaConduitRTPRTCPModuleError;
+ }
+ return kMediaConduitNoError;
+}
+
+MediaConduitErrorCode
+WebrtcVideoConduit::StopTransmitting()
+{
+ if(mEngineTransmitting)
+ {
+ CSFLogDebug(logTag, "%s Engine Already Sending. Attemping to Stop ", __FUNCTION__);
+ if(mPtrViEBase->StopSend(mChannel) == -1)
+ {
+ CSFLogError(logTag, "%s StopSend() Failed %d ",__FUNCTION__,
+ mPtrViEBase->LastError());
+ return kMediaConduitUnknownError;
+ }
+
+ mEngineTransmitting = false;
+ }
+
+ return kMediaConduitNoError;
+}
+
+MediaConduitErrorCode
+WebrtcVideoConduit::StartTransmitting()
+{
+ if (!mEngineTransmitting) {
+ if(mPtrViEBase->StartSend(mChannel) == -1)
+ {
+ CSFLogError(logTag, "%s Start Send Error %d ", __FUNCTION__,
+ mPtrViEBase->LastError());
+ return kMediaConduitUnknownError;
+ }
+
+ mEngineTransmitting = true;
+ }
+
+ return kMediaConduitNoError;
+}
+
+MediaConduitErrorCode
+WebrtcVideoConduit::StopReceiving()
+{
+ NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
+ // Are we receiving already? If so, stop receiving and playout
+ // since we can't apply new recv codec when the engine is playing.
+ if(mEngineReceiving)
+ {
+ CSFLogDebug(logTag, "%s Engine Already Receiving . Attemping to Stop ", __FUNCTION__);
+ if(mPtrViEBase->StopReceive(mChannel) == -1)
+ {
+ int error = mPtrViEBase->LastError();
+ if(error == kViEBaseUnknownError)
+ {
+ CSFLogDebug(logTag, "%s StopReceive() Success ", __FUNCTION__);
+ } else {
+ CSFLogError(logTag, "%s StopReceive() Failed %d ", __FUNCTION__,
+ mPtrViEBase->LastError());
+ return kMediaConduitUnknownError;
+ }
+ }
+ mEngineReceiving = false;
+ }
+
+ return kMediaConduitNoError;
+}
+
+MediaConduitErrorCode
+WebrtcVideoConduit::StartReceiving()
+{
+ if (!mEngineReceiving) {
+ CSFLogDebug(logTag, "%s Attemping to start... ", __FUNCTION__);
+ //Start Receive on the video engine
+ if(mPtrViEBase->StartReceive(mChannel) == -1)
+ {
+ int error = mPtrViEBase->LastError();
+ CSFLogError(logTag, "%s Start Receive Error %d ", __FUNCTION__, error);
+
+ return kMediaConduitUnknownError;
+ }
+
+ mEngineReceiving = true;
+ }
+
+ return kMediaConduitNoError;
+}
+
+//WebRTC::RTP Callback Implementation
+// Called on MSG thread
+int WebrtcVideoConduit::SendPacket(int channel, const void* data, size_t len)
+{
+ CSFLogDebug(logTag, "%s : channel %d len %lu", __FUNCTION__, channel, (unsigned long) len);
+
+ ReentrantMonitorAutoEnter enter(mTransportMonitor);
+ if(mTransmitterTransport &&
+ (mTransmitterTransport->SendRtpPacket(data, len) == NS_OK))
+ {
+ CSFLogDebug(logTag, "%s Sent RTP Packet ", __FUNCTION__);
+ return len;
+ } else {
+ CSFLogError(logTag, "%s RTP Packet Send Failed ", __FUNCTION__);
+ return -1;
+ }
+}
+
+// Called from multiple threads including webrtc Process thread
+int WebrtcVideoConduit::SendRTCPPacket(int channel, const void* data, size_t len)
+{
+ CSFLogDebug(logTag, "%s : channel %d , len %lu ", __FUNCTION__, channel, (unsigned long) len);
+
+ // We come here if we have only one pipeline/conduit setup,
+ // such as for unidirectional streams.
+ // We also end up here if we are receiving
+ ReentrantMonitorAutoEnter enter(mTransportMonitor);
+ if(mReceiverTransport &&
+ mReceiverTransport->SendRtcpPacket(data, len) == NS_OK)
+ {
+ // Might be a sender report, might be a receiver report, we don't know.
+ CSFLogDebug(logTag, "%s Sent RTCP Packet ", __FUNCTION__);
+ return len;
+ } else if(mTransmitterTransport &&
+ (mTransmitterTransport->SendRtcpPacket(data, len) == NS_OK)) {
+ CSFLogDebug(logTag, "%s Sent RTCP Packet (sender report) ", __FUNCTION__);
+ return len;
+ } else {
+ CSFLogError(logTag, "%s RTCP Packet Send Failed ", __FUNCTION__);
+ return -1;
+ }
+}
+
+// WebRTC::ExternalMedia Implementation
+int
+WebrtcVideoConduit::FrameSizeChange(unsigned int width,
+ unsigned int height,
+ unsigned int numStreams)
+{
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+
+
+ ReentrantMonitorAutoEnter enter(mTransportMonitor);
+ mReceivingWidth = width;
+ mReceivingHeight = height;
+ mNumReceivingStreams = numStreams;
+
+ if(mRenderer)
+ {
+ mRenderer->FrameSizeChange(width, height, numStreams);
+ return 0;
+ }
+
+ CSFLogError(logTag, "%s Renderer is NULL ", __FUNCTION__);
+ return -1;
+}
+
+int
+WebrtcVideoConduit::DeliverFrame(unsigned char* buffer,
+ size_t buffer_size,
+ uint32_t time_stamp,
+ int64_t ntp_time_ms,
+ int64_t render_time,
+ void *handle)
+{
+ return DeliverFrame(buffer, buffer_size, mReceivingWidth, (mReceivingWidth+1)>>1,
+ time_stamp, ntp_time_ms, render_time, handle);
+}
+
+int
+WebrtcVideoConduit::DeliverFrame(unsigned char* buffer,
+ size_t buffer_size,
+ uint32_t y_stride,
+ uint32_t cbcr_stride,
+ uint32_t time_stamp,
+ int64_t ntp_time_ms,
+ int64_t render_time,
+ void *handle)
+{
+ CSFLogDebug(logTag, "%s Buffer Size %lu", __FUNCTION__, (unsigned long) buffer_size);
+
+ ReentrantMonitorAutoEnter enter(mTransportMonitor);
+ if(mRenderer)
+ {
+ layers::Image* img = nullptr;
+ // |handle| should be a webrtc::NativeHandle if available.
+ if (handle) {
+ webrtc::NativeHandle* native_h = static_cast<webrtc::NativeHandle*>(handle);
+ // In the handle, there should be a layers::Image.
+ img = static_cast<layers::Image*>(native_h->GetHandle());
+ }
+
+ if (mVideoLatencyTestEnable && mReceivingWidth && mReceivingHeight) {
+ uint64_t now = PR_Now();
+ uint64_t timestamp = 0;
+ bool ok = YuvStamper::Decode(mReceivingWidth, mReceivingHeight, mReceivingWidth,
+ buffer,
+ reinterpret_cast<unsigned char*>(&timestamp),
+ sizeof(timestamp), 0, 0);
+ if (ok) {
+ VideoLatencyUpdate(now - timestamp);
+ }
+ }
+
+ const ImageHandle img_h(img);
+ mRenderer->RenderVideoFrame(buffer, buffer_size, y_stride, cbcr_stride,
+ time_stamp, render_time, img_h);
+ return 0;
+ }
+
+ CSFLogError(logTag, "%s Renderer is NULL ", __FUNCTION__);
+ return -1;
+}
+
+int
+WebrtcVideoConduit::DeliverI420Frame(const webrtc::I420VideoFrame& webrtc_frame)
+{
+ if (!webrtc_frame.native_handle()) {
+ uint32_t y_stride = webrtc_frame.stride(static_cast<webrtc::PlaneType>(0));
+ return DeliverFrame(const_cast<uint8_t*>(webrtc_frame.buffer(webrtc::kYPlane)),
+ CalcBufferSize(webrtc::kI420, y_stride, webrtc_frame.height()),
+ y_stride,
+ webrtc_frame.stride(static_cast<webrtc::PlaneType>(1)),
+ webrtc_frame.timestamp(),
+ webrtc_frame.ntp_time_ms(),
+ webrtc_frame.render_time_ms(), nullptr);
+ }
+ size_t buffer_size = CalcBufferSize(webrtc::kI420, webrtc_frame.width(), webrtc_frame.height());
+ CSFLogDebug(logTag, "%s Buffer Size %lu", __FUNCTION__, (unsigned long) buffer_size);
+
+ ReentrantMonitorAutoEnter enter(mTransportMonitor);
+ if(mRenderer)
+ {
+ layers::Image* img = nullptr;
+ // |handle| should be a webrtc::NativeHandle if available.
+ webrtc::NativeHandle* native_h = static_cast<webrtc::NativeHandle*>(webrtc_frame.native_handle());
+ if (native_h) {
+ // In the handle, there should be a layers::Image.
+ img = static_cast<layers::Image*>(native_h->GetHandle());
+ }
+
+#if 0
+ //#ifndef MOZ_WEBRTC_OMX
+ // XXX - this may not be possible on GONK with textures!
+ if (mVideoLatencyTestEnable && mReceivingWidth && mReceivingHeight) {
+ uint64_t now = PR_Now();
+ uint64_t timestamp = 0;
+ bool ok = YuvStamper::Decode(mReceivingWidth, mReceivingHeight, mReceivingWidth,
+ buffer,
+ reinterpret_cast<unsigned char*>(&timestamp),
+ sizeof(timestamp), 0, 0);
+ if (ok) {
+ VideoLatencyUpdate(now - timestamp);
+ }
+ }
+#endif
+
+ const ImageHandle img_h(img);
+ mRenderer->RenderVideoFrame(nullptr, buffer_size, webrtc_frame.timestamp(),
+ webrtc_frame.render_time_ms(), img_h);
+ return 0;
+ }
+
+ CSFLogError(logTag, "%s Renderer is NULL ", __FUNCTION__);
+ return -1;
+}
+
+/**
+ * Copy the codec passed into Conduit's database
+ */
+
+void
+WebrtcVideoConduit::CodecConfigToWebRTCCodec(const VideoCodecConfig* codecInfo,
+ webrtc::VideoCodec& cinst)
+{
+ // Note: this assumes cinst is initialized to a base state either by
+ // hand or from a config fetched with GetConfig(); this modifies the config
+ // to match parameters from VideoCodecConfig
+ cinst.plType = codecInfo->mType;
+ if (codecInfo->mName == "H264") {
+ cinst.codecType = webrtc::kVideoCodecH264;
+ PL_strncpyz(cinst.plName, "H264", sizeof(cinst.plName));
+ } else if (codecInfo->mName == "VP8") {
+ cinst.codecType = webrtc::kVideoCodecVP8;
+ PL_strncpyz(cinst.plName, "VP8", sizeof(cinst.plName));
+ } else if (codecInfo->mName == "VP9") {
+ cinst.codecType = webrtc::kVideoCodecVP9;
+ PL_strncpyz(cinst.plName, "VP9", sizeof(cinst.plName));
+ } else if (codecInfo->mName == "I420") {
+ cinst.codecType = webrtc::kVideoCodecI420;
+ PL_strncpyz(cinst.plName, "I420", sizeof(cinst.plName));
+ } else {
+ cinst.codecType = webrtc::kVideoCodecUnknown;
+ PL_strncpyz(cinst.plName, "Unknown", sizeof(cinst.plName));
+ }
+
+ // width/height will be overridden on the first frame; they must be 'sane' for
+ // SetSendCodec()
+ if (codecInfo->mEncodingConstraints.maxFps > 0) {
+ cinst.maxFramerate = codecInfo->mEncodingConstraints.maxFps;
+ } else {
+ cinst.maxFramerate = DEFAULT_VIDEO_MAX_FRAMERATE;
+ }
+
+ // Defaults if rates aren't forced by pref. Typically defaults are
+ // overridden on the first video frame.
+ cinst.minBitrate = mMinBitrate ? mMinBitrate : 200;
+ cinst.startBitrate = mStartBitrate ? mStartBitrate : 300;
+ cinst.targetBitrate = cinst.startBitrate;
+ cinst.maxBitrate = mMaxBitrate ? mMaxBitrate : 2000;
+
+ if (cinst.codecType == webrtc::kVideoCodecH264)
+ {
+#ifdef MOZ_WEBRTC_OMX
+ cinst.resolution_divisor = 16;
+#endif
+ // cinst.codecSpecific.H264.profile = ?
+ cinst.codecSpecific.H264.profile_byte = codecInfo->mProfile;
+ cinst.codecSpecific.H264.constraints = codecInfo->mConstraints;
+ cinst.codecSpecific.H264.level = codecInfo->mLevel;
+ cinst.codecSpecific.H264.packetizationMode = codecInfo->mPacketizationMode;
+ if (codecInfo->mEncodingConstraints.maxBr > 0) {
+ // webrtc.org uses kbps, we use bps
+ cinst.maxBitrate =
+ MinIgnoreZero(cinst.maxBitrate,
+ codecInfo->mEncodingConstraints.maxBr)/1000;
+ }
+ if (codecInfo->mEncodingConstraints.maxMbps > 0) {
+ // Not supported yet!
+ CSFLogError(logTag, "%s H.264 max_mbps not supported yet ", __FUNCTION__);
+ }
+ // XXX parse the encoded SPS/PPS data
+ // paranoia
+ cinst.codecSpecific.H264.spsData = nullptr;
+ cinst.codecSpecific.H264.spsLen = 0;
+ cinst.codecSpecific.H264.ppsData = nullptr;
+ cinst.codecSpecific.H264.ppsLen = 0;
+ }
+ // Init mSimulcastEncodings always since they hold info from setParameters.
+ // TODO(bug 1210175): H264 doesn't support simulcast yet.
+ size_t numberOfSimulcastEncodings = std::min(codecInfo->mSimulcastEncodings.size(), (size_t)webrtc::kMaxSimulcastStreams);
+ for (size_t i = 0; i < numberOfSimulcastEncodings; ++i) {
+ const VideoCodecConfig::SimulcastEncoding& encoding =
+ codecInfo->mSimulcastEncodings[i];
+ // Make sure the constraints on the whole stream are reflected.
+ webrtc::SimulcastStream stream;
+ memset(&stream, 0, sizeof(stream));
+ stream.width = cinst.width;
+ stream.height = cinst.height;
+ stream.numberOfTemporalLayers = 1;
+ stream.maxBitrate = cinst.maxBitrate;
+ stream.targetBitrate = cinst.targetBitrate;
+ stream.minBitrate = cinst.minBitrate;
+ stream.qpMax = cinst.qpMax;
+ strncpy(stream.rid, encoding.rid.c_str(), sizeof(stream.rid)-1);
+ stream.rid[sizeof(stream.rid) - 1] = 0;
+
+ // Apply encoding-specific constraints.
+ stream.width = MinIgnoreZero(
+ stream.width,
+ (unsigned short)encoding.constraints.maxWidth);
+ stream.height = MinIgnoreZero(
+ stream.height,
+ (unsigned short)encoding.constraints.maxHeight);
+
+ // webrtc.org uses kbps, we use bps
+ stream.jsMaxBitrate = encoding.constraints.maxBr/1000;
+ stream.jsScaleDownBy = encoding.constraints.scaleDownBy;
+
+ MOZ_ASSERT(stream.jsScaleDownBy >= 1.0);
+ uint32_t width = stream.width? stream.width : 640;
+ uint32_t height = stream.height? stream.height : 480;
+ uint32_t new_width = uint32_t(width / stream.jsScaleDownBy);
+ uint32_t new_height = uint32_t(height / stream.jsScaleDownBy);
+
+ if (new_width != width || new_height != height) {
+ // Estimate. Overridden on first frame.
+ SelectBitrates(new_width, new_height, stream.jsMaxBitrate,
+ mLastFramerateTenths,
+ stream.minBitrate,
+ stream.targetBitrate,
+ stream.maxBitrate);
+ }
+ // webrtc.org expects simulcast streams to be ordered by increasing
+ // fidelity, our jsep code does the opposite.
+ cinst.simulcastStream[numberOfSimulcastEncodings-i-1] = stream;
+ }
+
+ cinst.numberOfSimulcastStreams = numberOfSimulcastEncodings;
+}
+
+/**
+ * Perform validation on the codecConfig to be applied
+ * Verifies if the codec is already applied.
+ */
+MediaConduitErrorCode
+WebrtcVideoConduit::ValidateCodecConfig(const VideoCodecConfig* codecInfo,
+ bool send)
+{
+ if(!codecInfo)
+ {
+ CSFLogError(logTag, "%s Null CodecConfig ", __FUNCTION__);
+ return kMediaConduitMalformedArgument;
+ }
+
+ if((codecInfo->mName.empty()) ||
+ (codecInfo->mName.length() >= CODEC_PLNAME_SIZE))
+ {
+ CSFLogError(logTag, "%s Invalid Payload Name Length ", __FUNCTION__);
+ return kMediaConduitMalformedArgument;
+ }
+
+ return kMediaConduitNoError;
+}
+
+void
+WebrtcVideoConduit::VideoLatencyUpdate(uint64_t newSample)
+{
+ mVideoLatencyAvg = (sRoundingPadding * newSample + sAlphaNum * mVideoLatencyAvg) / sAlphaDen;
+}
+
+uint64_t
+WebrtcVideoConduit::MozVideoLatencyAvg()
+{
+ return mVideoLatencyAvg / sRoundingPadding;
+}
+
+uint64_t
+WebrtcVideoConduit::CodecPluginID()
+{
+ if (mExternalSendCodecHandle) {
+ return mExternalSendCodecHandle->PluginID();
+ } else if (mExternalRecvCodecHandle) {
+ return mExternalRecvCodecHandle->PluginID();
+ }
+ return 0;
+}
+
+bool
+WebrtcVideoConduit::DetermineREDAndULPFECPayloadTypes(uint8_t &payload_type_red, uint8_t &payload_type_ulpfec)
+{
+ webrtc::VideoCodec video_codec;
+ payload_type_red = INVALID_RTP_PAYLOAD;
+ payload_type_ulpfec = INVALID_RTP_PAYLOAD;
+
+ for(int idx=0; idx < mPtrViECodec->NumberOfCodecs(); idx++)
+ {
+ if(mPtrViECodec->GetCodec(idx, video_codec) == 0)
+ {
+ switch(video_codec.codecType) {
+ case webrtc::VideoCodecType::kVideoCodecRED:
+ payload_type_red = video_codec.plType;
+ break;
+ case webrtc::VideoCodecType::kVideoCodecULPFEC:
+ payload_type_ulpfec = video_codec.plType;
+ break;
+ default:
+ break;
+ }
+ }
+ }
+
+ return payload_type_red != INVALID_RTP_PAYLOAD
+ && payload_type_ulpfec != INVALID_RTP_PAYLOAD;
+}
+
+}// end namespace
diff --git a/media/webrtc/signaling/src/media-conduit/VideoConduit.h b/media/webrtc/signaling/src/media-conduit/VideoConduit.h
new file mode 100755
index 000000000..323a6a284
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/VideoConduit.h
@@ -0,0 +1,429 @@
+/* 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/. */
+
+#ifndef VIDEO_SESSION_H_
+#define VIDEO_SESSION_H_
+
+#include "nsAutoPtr.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/Atomics.h"
+
+#include "MediaConduitInterface.h"
+#include "MediaEngineWrapper.h"
+#include "CodecStatistics.h"
+#include "LoadManagerFactory.h"
+#include "LoadManager.h"
+#include "runnable_utils.h"
+
+// conflicts with #include of scoped_ptr.h
+#undef FF
+// Video Engine Includes
+#include "webrtc/common_types.h"
+#ifdef FF
+#undef FF // Avoid name collision between scoped_ptr.h and nsCRTGlue.h.
+#endif
+#include "webrtc/modules/video_coding/codecs/interface/video_codec_interface.h"
+#include "webrtc/video_engine/include/vie_base.h"
+#include "webrtc/video_engine/include/vie_capture.h"
+#include "webrtc/video_engine/include/vie_codec.h"
+#include "webrtc/video_engine/include/vie_external_codec.h"
+#include "webrtc/video_engine/include/vie_render.h"
+#include "webrtc/video_engine/include/vie_network.h"
+#include "webrtc/video_engine/include/vie_rtp_rtcp.h"
+
+/** This file hosts several structures identifying different aspects
+ * of a RTP Session.
+ */
+
+ using webrtc::ViEBase;
+ using webrtc::ViENetwork;
+ using webrtc::ViECodec;
+ using webrtc::ViECapture;
+ using webrtc::ViERender;
+ using webrtc::ViEExternalCapture;
+ using webrtc::ViEExternalCodec;
+
+namespace mozilla {
+
+class WebrtcAudioConduit;
+class nsThread;
+
+// Interface of external video encoder for WebRTC.
+class WebrtcVideoEncoder:public VideoEncoder
+ ,public webrtc::VideoEncoder
+{};
+
+// Interface of external video decoder for WebRTC.
+class WebrtcVideoDecoder:public VideoDecoder
+ ,public webrtc::VideoDecoder
+{};
+
+/**
+ * Concrete class for Video session. Hooks up
+ * - media-source and target to external transport
+ */
+class WebrtcVideoConduit : public VideoSessionConduit
+ , public webrtc::Transport
+ , public webrtc::ExternalRenderer
+{
+public:
+ //VoiceEngine defined constant for Payload Name Size.
+ static const unsigned int CODEC_PLNAME_SIZE;
+
+ /**
+ * Set up A/V sync between this (incoming) VideoConduit and an audio conduit.
+ */
+ void SyncTo(WebrtcAudioConduit *aConduit);
+
+ /**
+ * Function to attach Renderer end-point for the Media-Video conduit.
+ * @param aRenderer : Reference to the concrete Video renderer implementation
+ * Note: Multiple invocations of this API shall remove an existing renderer
+ * and attaches the new to the Conduit.
+ */
+ virtual MediaConduitErrorCode AttachRenderer(RefPtr<VideoRenderer> aVideoRenderer) override;
+ virtual void DetachRenderer() override;
+
+ /**
+ * APIs used by the registered external transport to this Conduit to
+ * feed in received RTP Frames to the VideoEngine for decoding
+ */
+ virtual MediaConduitErrorCode ReceivedRTPPacket(const void *data, int len) override;
+
+ /**
+ * APIs used by the registered external transport to this Conduit to
+ * feed in received RTP Frames to the VideoEngine for decoding
+ */
+ virtual MediaConduitErrorCode ReceivedRTCPPacket(const void *data, int len) override;
+
+ virtual MediaConduitErrorCode StopTransmitting() override;
+ virtual MediaConduitErrorCode StartTransmitting() override;
+ virtual MediaConduitErrorCode StopReceiving() override;
+ virtual MediaConduitErrorCode StartReceiving() override;
+
+ /**
+ * Function to configure sending codec mode for different content
+ */
+ virtual MediaConduitErrorCode ConfigureCodecMode(webrtc::VideoCodecMode) override;
+
+ /**
+ * Function to configure send codec for the video session
+ * @param sendSessionConfig: CodecConfiguration
+ * @result: On Success, the video engine is configured with passed in codec for send
+ * On failure, video engine transmit functionality is disabled.
+ * NOTE: This API can be invoked multiple time. Invoking this API may involve restarting
+ * transmission sub-system on the engine.
+ */
+ virtual MediaConduitErrorCode ConfigureSendMediaCodec(const VideoCodecConfig* codecInfo) override;
+
+ /**
+ * Function to configure list of receive codecs for the video session
+ * @param sendSessionConfig: CodecConfiguration
+ * @result: On Success, the video engine is configured with passed in codec for send
+ * Also the playout is enabled.
+ * On failure, video engine transmit functionality is disabled.
+ * NOTE: This API can be invoked multiple time. Invoking this API may involve restarting
+ * transmission sub-system on the engine.
+ */
+ virtual MediaConduitErrorCode ConfigureRecvMediaCodecs(
+ const std::vector<VideoCodecConfig* >& codecConfigList) override;
+
+ /**
+ * Register Transport for this Conduit. RTP and RTCP frames from the VideoEngine
+ * shall be passed to the registered transport for transporting externally.
+ */
+ virtual MediaConduitErrorCode SetTransmitterTransport(RefPtr<TransportInterface> aTransport) override;
+
+ virtual MediaConduitErrorCode SetReceiverTransport(RefPtr<TransportInterface> aTransport) override;
+
+ /**
+ * Function to set the encoding bitrate limits based on incoming frame size and rate
+ * @param width, height: dimensions of the frame
+ * @param cap: user-enforced max bitrate, or 0
+ * @param aLastFramerateTenths: holds the current input framerate
+ * @param out_start, out_min, out_max: bitrate results
+ */
+ void SelectBitrates(unsigned short width,
+ unsigned short height,
+ unsigned int cap,
+ mozilla::Atomic<int32_t, mozilla::Relaxed>& aLastFramerateTenths,
+ unsigned int& out_min,
+ unsigned int& out_start,
+ unsigned int& out_max);
+
+ /**
+ * Function to select and change the encoding resolution based on incoming frame size
+ * and current available bandwidth.
+ * @param width, height: dimensions of the frame
+ * @param frame: optional frame to submit for encoding after reconfig
+ */
+ bool SelectSendResolution(unsigned short width,
+ unsigned short height,
+ webrtc::I420VideoFrame *frame);
+
+ /**
+ * Function to reconfigure the current send codec for a different
+ * width/height/framerate/etc.
+ * @param width, height: dimensions of the frame
+ * @param frame: optional frame to submit for encoding after reconfig
+ */
+ nsresult ReconfigureSendCodec(unsigned short width,
+ unsigned short height,
+ webrtc::I420VideoFrame *frame);
+
+ /**
+ * Function to select and change the encoding frame rate based on incoming frame rate
+ * and max-mbps setting.
+ * @param current framerate
+ * @result new framerate
+ */
+ unsigned int SelectSendFrameRate(unsigned int framerate) const;
+
+ /**
+ * Function to deliver a capture video frame for encoding and transport
+ * @param video_frame: pointer to captured video-frame.
+ * @param video_frame_length: size of the frame
+ * @param width, height: dimensions of the frame
+ * @param video_type: Type of the video frame - I420, RAW
+ * @param captured_time: timestamp when the frame was captured.
+ * if 0 timestamp is automatcally generated by the engine.
+ *NOTE: ConfigureSendMediaCodec() SHOULD be called before this function can be invoked
+ * This ensures the inserted video-frames can be transmitted by the conduit
+ */
+ virtual MediaConduitErrorCode SendVideoFrame(unsigned char* video_frame,
+ unsigned int video_frame_length,
+ unsigned short width,
+ unsigned short height,
+ VideoType video_type,
+ uint64_t capture_time) override;
+ virtual MediaConduitErrorCode SendVideoFrame(webrtc::I420VideoFrame& frame) override;
+
+ /**
+ * Set an external encoder object |encoder| to the payload type |pltype|
+ * for sender side codec.
+ */
+ virtual MediaConduitErrorCode SetExternalSendCodec(VideoCodecConfig* config,
+ VideoEncoder* encoder) override;
+
+ /**
+ * Set an external decoder object |decoder| to the payload type |pltype|
+ * for receiver side codec.
+ */
+ virtual MediaConduitErrorCode SetExternalRecvCodec(VideoCodecConfig* config,
+ VideoDecoder* decoder) override;
+
+ /**
+ * Enables use of Rtp Stream Id, and sets the extension ID.
+ */
+ virtual MediaConduitErrorCode EnableRTPStreamIdExtension(bool enabled, uint8_t id) override;
+
+ /**
+ * Webrtc transport implementation to send and receive RTP packet.
+ * VideoConduit registers itself as ExternalTransport to the VideoEngine
+ */
+ virtual int SendPacket(int channel, const void *data, size_t len) override;
+
+ /**
+ * Webrtc transport implementation to send and receive RTCP packet.
+ * VideoConduit registers itself as ExternalTransport to the VideoEngine
+ */
+ virtual int SendRTCPPacket(int channel, const void *data, size_t len) override;
+
+
+ /**
+ * Webrtc External Renderer Implementation APIs.
+ * Raw I420 Frames are delivred to the VideoConduit by the VideoEngine
+ */
+ virtual int FrameSizeChange(unsigned int, unsigned int, unsigned int) override;
+
+ virtual int DeliverFrame(unsigned char*, size_t, uint32_t , int64_t,
+ int64_t, void *handle) override;
+
+ virtual int DeliverFrame(unsigned char*, size_t, uint32_t, uint32_t, uint32_t , int64_t,
+ int64_t, void *handle);
+
+ virtual int DeliverI420Frame(const webrtc::I420VideoFrame& webrtc_frame) override;
+
+ /**
+ * Does DeliverFrame() support a null buffer and non-null handle
+ * (video texture)?
+ * B2G support it (when using HW video decoder with graphic buffer output).
+ * XXX Investigate! Especially for Android
+ */
+ virtual bool IsTextureSupported() override {
+#ifdef WEBRTC_GONK
+ return true;
+#else
+ return false;
+#endif
+ }
+
+ virtual uint64_t CodecPluginID() override;
+
+ unsigned short SendingWidth() override {
+ return mSendingWidth;
+ }
+
+ unsigned short SendingHeight() override {
+ return mSendingHeight;
+ }
+
+ unsigned int SendingMaxFs() override {
+ if(mCurSendCodecConfig) {
+ return mCurSendCodecConfig->mEncodingConstraints.maxFs;
+ }
+ return 0;
+ }
+
+ unsigned int SendingMaxFr() override {
+ if(mCurSendCodecConfig) {
+ return mCurSendCodecConfig->mEncodingConstraints.maxFps;
+ }
+ return 0;
+ }
+
+ WebrtcVideoConduit();
+ virtual ~WebrtcVideoConduit();
+
+ MediaConduitErrorCode InitMain();
+ virtual MediaConduitErrorCode Init();
+ virtual void Destroy();
+
+ int GetChannel() { return mChannel; }
+ webrtc::VideoEngine* GetVideoEngine() { return mVideoEngine; }
+ bool GetLocalSSRC(unsigned int* ssrc) override;
+ bool SetLocalSSRC(unsigned int ssrc) override;
+ bool GetRemoteSSRC(unsigned int* ssrc) override;
+ bool SetLocalCNAME(const char* cname) override;
+ bool GetVideoEncoderStats(double* framerateMean,
+ double* framerateStdDev,
+ double* bitrateMean,
+ double* bitrateStdDev,
+ uint32_t* droppedFrames) override;
+ bool GetVideoDecoderStats(double* framerateMean,
+ double* framerateStdDev,
+ double* bitrateMean,
+ double* bitrateStdDev,
+ uint32_t* discardedPackets) override;
+ bool GetAVStats(int32_t* jitterBufferDelayMs,
+ int32_t* playoutBufferDelayMs,
+ int32_t* avSyncOffsetMs) override;
+ bool GetRTPStats(unsigned int* jitterMs, unsigned int* cumulativeLost) override;
+ bool GetRTCPReceiverReport(DOMHighResTimeStamp* timestamp,
+ uint32_t* jitterMs,
+ uint32_t* packetsReceived,
+ uint64_t* bytesReceived,
+ uint32_t* cumulativeLost,
+ int32_t* rttMs) override;
+ bool GetRTCPSenderReport(DOMHighResTimeStamp* timestamp,
+ unsigned int* packetsSent,
+ uint64_t* bytesSent) override;
+ uint64_t MozVideoLatencyAvg();
+
+private:
+ DISALLOW_COPY_AND_ASSIGN(WebrtcVideoConduit);
+
+ static inline bool OnThread(nsIEventTarget *thread)
+ {
+ bool on;
+ nsresult rv;
+ rv = thread->IsOnCurrentThread(&on);
+
+ // If the target thread has already shut down, we don't want to assert.
+ if (rv != NS_ERROR_NOT_INITIALIZED) {
+ MOZ_ASSERT(NS_SUCCEEDED(rv));
+ }
+
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return false;
+ }
+ return on;
+ }
+
+ //Local database of currently applied receive codecs
+ typedef std::vector<VideoCodecConfig* > RecvCodecList;
+
+ //Function to convert between WebRTC and Conduit codec structures
+ void CodecConfigToWebRTCCodec(const VideoCodecConfig* codecInfo,
+ webrtc::VideoCodec& cinst);
+
+ //Checks the codec to be applied
+ MediaConduitErrorCode ValidateCodecConfig(const VideoCodecConfig* codecInfo, bool send);
+
+ //Utility function to dump recv codec database
+ void DumpCodecDB() const;
+
+ // Video Latency Test averaging filter
+ void VideoLatencyUpdate(uint64_t new_sample);
+
+ // Utility function to determine RED and ULPFEC payload types
+ bool DetermineREDAndULPFECPayloadTypes(uint8_t &payload_type_red, uint8_t &payload_type_ulpfec);
+
+ webrtc::VideoEngine* mVideoEngine;
+ mozilla::ReentrantMonitor mTransportMonitor;
+ RefPtr<TransportInterface> mTransmitterTransport;
+ RefPtr<TransportInterface> mReceiverTransport;
+ RefPtr<VideoRenderer> mRenderer;
+
+ ScopedCustomReleasePtr<webrtc::ViEBase> mPtrViEBase;
+ ScopedCustomReleasePtr<webrtc::ViECapture> mPtrViECapture;
+ ScopedCustomReleasePtr<webrtc::ViECodec> mPtrViECodec;
+ ScopedCustomReleasePtr<webrtc::ViENetwork> mPtrViENetwork;
+ ScopedCustomReleasePtr<webrtc::ViERender> mPtrViERender;
+ ScopedCustomReleasePtr<webrtc::ViERTP_RTCP> mPtrRTP;
+ ScopedCustomReleasePtr<webrtc::ViEExternalCodec> mPtrExtCodec;
+
+ webrtc::ViEExternalCapture* mPtrExtCapture;
+
+ // Engine state we are concerned with.
+ mozilla::Atomic<bool> mEngineTransmitting; //If true ==> Transmit Sub-system is up and running
+ mozilla::Atomic<bool> mEngineReceiving; // if true ==> Receive Sus-sysmtem up and running
+
+ int mChannel; // Video Channel for this conduit
+ int mCapId; // Capturer for this conduit
+
+ Mutex mCodecMutex; // protects mCurrSendCodecConfig
+ nsAutoPtr<VideoCodecConfig> mCurSendCodecConfig;
+ bool mInReconfig;
+
+ unsigned short mLastWidth;
+ unsigned short mLastHeight;
+ unsigned short mSendingWidth;
+ unsigned short mSendingHeight;
+ unsigned short mReceivingWidth;
+ unsigned short mReceivingHeight;
+ unsigned int mSendingFramerate;
+ // scaled by *10 because Atomic<double/float> isn't supported
+ mozilla::Atomic<int32_t, mozilla::Relaxed> mLastFramerateTenths;
+ unsigned short mNumReceivingStreams;
+ bool mVideoLatencyTestEnable;
+ uint64_t mVideoLatencyAvg;
+ uint32_t mMinBitrate;
+ uint32_t mStartBitrate;
+ uint32_t mMaxBitrate;
+ uint32_t mMinBitrateEstimate;
+
+ bool mRtpStreamIdEnabled;
+ uint8_t mRtpStreamIdExtId;
+
+ static const unsigned int sAlphaNum = 7;
+ static const unsigned int sAlphaDen = 8;
+ static const unsigned int sRoundingPadding = 1024;
+
+ RefPtr<WebrtcAudioConduit> mSyncedTo;
+
+ nsAutoPtr<VideoCodecConfig> mExternalSendCodec;
+ nsAutoPtr<VideoCodecConfig> mExternalRecvCodec;
+ nsAutoPtr<VideoEncoder> mExternalSendCodecHandle;
+ nsAutoPtr<VideoDecoder> mExternalRecvCodecHandle;
+
+ // statistics object for video codec;
+ nsAutoPtr<VideoCodecStatistics> mVideoCodecStat;
+
+ nsAutoPtr<LoadManager> mLoadManager;
+ webrtc::VideoCodecMode mCodecMode;
+};
+} // end namespace
+
+#endif
diff --git a/media/webrtc/signaling/src/media-conduit/VideoTypes.h b/media/webrtc/signaling/src/media-conduit/VideoTypes.h
new file mode 100755
index 000000000..e4cff3962
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/VideoTypes.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2012, The WebRTC project authors. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * * Neither the name of Google nor the names of its contributors may
+ * be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef VIDEO_TYPE_
+#define VIDEO_TYPE_
+
+namespace mozilla
+{
+/*
+ * Enumeration for different video types supported by the
+ * video-engine. If more types will be supported in the future
+ * newer one shall be appended to the bottom of the list
+ */
+enum VideoType
+{
+ kVideoI420 = 0,
+ kVideoYV12 = 1,
+ kVideoYUY2 = 2,
+ kVideoUYVY = 3,
+ kVideoIYUV = 4,
+ kVideoARGB = 5,
+ kVideoRGB24 = 6,
+ kVideoRGB565 = 7,
+ kVideoARGB4444 = 8,
+ kVideoARGB1555 = 9,
+ kVideoMJPEG = 10,
+ kVideoNV12 = 11,
+ kVideoNV21 = 12,
+ kVideoBGRA = 13,
+ kVideoUnknown = 99
+};
+}
+#endif
diff --git a/media/webrtc/signaling/src/media-conduit/WebrtcGmpVideoCodec.cpp b/media/webrtc/signaling/src/media-conduit/WebrtcGmpVideoCodec.cpp
new file mode 100644
index 000000000..ad47e5316
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/WebrtcGmpVideoCodec.cpp
@@ -0,0 +1,965 @@
+/* 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 "WebrtcGmpVideoCodec.h"
+
+#include <iostream>
+#include <vector>
+
+#include "mozilla/Move.h"
+#include "mozilla/SyncRunnable.h"
+#include "VideoConduit.h"
+#include "AudioConduit.h"
+#include "runnable_utils.h"
+
+#include "mozIGeckoMediaPluginService.h"
+#include "nsServiceManagerUtils.h"
+#include "GMPVideoDecoderProxy.h"
+#include "GMPVideoEncoderProxy.h"
+#include "MainThreadUtils.h"
+
+#include "gmp-video-host.h"
+#include "gmp-video-frame-i420.h"
+#include "gmp-video-frame-encoded.h"
+
+#include "webrtc/video_engine/include/vie_external_codec.h"
+
+namespace mozilla {
+
+#ifdef LOG
+#undef LOG
+#endif
+
+#ifdef MOZILLA_INTERNAL_API
+extern mozilla::LogModule* GetGMPLog();
+#else
+// For CPP unit tests
+PRLogModuleInfo*
+GetGMPLog()
+{
+ static PRLogModuleInfo *sLog;
+ if (!sLog)
+ sLog = PR_NewLogModule("GMP");
+ return sLog;
+}
+#endif
+#define LOGD(msg) MOZ_LOG(GetGMPLog(), mozilla::LogLevel::Debug, msg)
+#define LOG(level, msg) MOZ_LOG(GetGMPLog(), (level), msg)
+
+WebrtcGmpPCHandleSetter::WebrtcGmpPCHandleSetter(const std::string& aPCHandle)
+{
+ if (!NS_IsMainThread()) {
+ MOZ_ASSERT(false, "WebrtcGmpPCHandleSetter can only be used on main");
+ return;
+ }
+ MOZ_ASSERT(sCurrentHandle.empty());
+ sCurrentHandle = aPCHandle;
+}
+
+WebrtcGmpPCHandleSetter::~WebrtcGmpPCHandleSetter()
+{
+ if (!NS_IsMainThread()) {
+ MOZ_ASSERT(false, "WebrtcGmpPCHandleSetter can only be used on main");
+ return;
+ }
+
+ sCurrentHandle.clear();
+}
+
+/* static */ std::string
+WebrtcGmpPCHandleSetter::GetCurrentHandle()
+{
+ if (!NS_IsMainThread()) {
+ MOZ_ASSERT(false, "WebrtcGmpPCHandleSetter can only be used on main");
+ return "";
+ }
+
+ return sCurrentHandle;
+}
+
+std::string WebrtcGmpPCHandleSetter::sCurrentHandle = "";
+
+// Encoder.
+WebrtcGmpVideoEncoder::WebrtcGmpVideoEncoder()
+ : mGMP(nullptr)
+ , mInitting(false)
+ , mHost(nullptr)
+ , mMaxPayloadSize(0)
+ , mCallbackMutex("WebrtcGmpVideoEncoder encoded callback mutex")
+ , mCallback(nullptr)
+ , mCachedPluginId(0)
+{
+#ifdef MOZILLA_INTERNAL_API
+ if (mPCHandle.empty()) {
+ mPCHandle = WebrtcGmpPCHandleSetter::GetCurrentHandle();
+ }
+ MOZ_ASSERT(!mPCHandle.empty());
+#endif
+}
+
+WebrtcGmpVideoEncoder::~WebrtcGmpVideoEncoder()
+{
+ // We should not have been destroyed if we never closed our GMP
+ MOZ_ASSERT(!mGMP);
+}
+
+static int
+WebrtcFrameTypeToGmpFrameType(webrtc::VideoFrameType aIn,
+ GMPVideoFrameType *aOut)
+{
+ MOZ_ASSERT(aOut);
+ switch(aIn) {
+ case webrtc::kKeyFrame:
+ *aOut = kGMPKeyFrame;
+ break;
+ case webrtc::kDeltaFrame:
+ *aOut = kGMPDeltaFrame;
+ break;
+ case webrtc::kGoldenFrame:
+ *aOut = kGMPGoldenFrame;
+ break;
+ case webrtc::kAltRefFrame:
+ *aOut = kGMPAltRefFrame;
+ break;
+ case webrtc::kSkipFrame:
+ *aOut = kGMPSkipFrame;
+ break;
+ default:
+ MOZ_CRASH("Unexpected VideoFrameType");
+ }
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+static int
+GmpFrameTypeToWebrtcFrameType(GMPVideoFrameType aIn,
+ webrtc::VideoFrameType *aOut)
+{
+ MOZ_ASSERT(aOut);
+ switch(aIn) {
+ case kGMPKeyFrame:
+ *aOut = webrtc::kKeyFrame;
+ break;
+ case kGMPDeltaFrame:
+ *aOut = webrtc::kDeltaFrame;
+ break;
+ case kGMPGoldenFrame:
+ *aOut = webrtc::kGoldenFrame;
+ break;
+ case kGMPAltRefFrame:
+ *aOut = webrtc::kAltRefFrame;
+ break;
+ case kGMPSkipFrame:
+ *aOut = webrtc::kSkipFrame;
+ break;
+ default:
+ MOZ_CRASH("Unexpected GMPVideoFrameType");
+ }
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t
+WebrtcGmpVideoEncoder::InitEncode(const webrtc::VideoCodec* aCodecSettings,
+ int32_t aNumberOfCores,
+ uint32_t aMaxPayloadSize)
+{
+ if (!mMPS) {
+ mMPS = do_GetService("@mozilla.org/gecko-media-plugin-service;1");
+ }
+ MOZ_ASSERT(mMPS);
+
+ if (!mGMPThread) {
+ if (NS_WARN_IF(NS_FAILED(mMPS->GetThread(getter_AddRefs(mGMPThread))))) {
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+ }
+
+ // Bug XXXXXX: transfer settings from codecSettings to codec.
+ GMPVideoCodec codecParams;
+ memset(&codecParams, 0, sizeof(codecParams));
+
+ codecParams.mGMPApiVersion = 33;
+ codecParams.mStartBitrate = aCodecSettings->startBitrate;
+ codecParams.mMinBitrate = aCodecSettings->minBitrate;
+ codecParams.mMaxBitrate = aCodecSettings->maxBitrate;
+ codecParams.mMaxFramerate = aCodecSettings->maxFramerate;
+ mMaxPayloadSize = aMaxPayloadSize;
+
+ memset(&mCodecSpecificInfo, 0, sizeof(webrtc::CodecSpecificInfo));
+ mCodecSpecificInfo.codecType = webrtc::kVideoCodecH264;
+ mCodecSpecificInfo.codecSpecific.H264.packetizationMode = aCodecSettings->codecSpecific.H264.packetizationMode;
+ if (mCodecSpecificInfo.codecSpecific.H264.packetizationMode == 1) {
+ mMaxPayloadSize = 0; // No limit.
+ }
+
+ if (aCodecSettings->mode == webrtc::kScreensharing) {
+ codecParams.mMode = kGMPScreensharing;
+ } else {
+ codecParams.mMode = kGMPRealtimeVideo;
+ }
+
+ codecParams.mWidth = aCodecSettings->width;
+ codecParams.mHeight = aCodecSettings->height;
+
+ RefPtr<GmpInitDoneRunnable> initDone(new GmpInitDoneRunnable(mPCHandle));
+ mGMPThread->Dispatch(WrapRunnableNM(WebrtcGmpVideoEncoder::InitEncode_g,
+ RefPtr<WebrtcGmpVideoEncoder>(this),
+ codecParams,
+ aNumberOfCores,
+ aMaxPayloadSize,
+ initDone),
+ NS_DISPATCH_NORMAL);
+
+ // Since init of the GMP encoder is a multi-step async dispatch (including
+ // dispatches to main), and since this function is invoked on main, there's
+ // no safe way to block until this init is done. If an error occurs, we'll
+ // handle it later.
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+/* static */
+void
+WebrtcGmpVideoEncoder::InitEncode_g(
+ const RefPtr<WebrtcGmpVideoEncoder>& aThis,
+ const GMPVideoCodec& aCodecParams,
+ int32_t aNumberOfCores,
+ uint32_t aMaxPayloadSize,
+ const RefPtr<GmpInitDoneRunnable>& aInitDone)
+{
+ nsTArray<nsCString> tags;
+ tags.AppendElement(NS_LITERAL_CSTRING("h264"));
+ UniquePtr<GetGMPVideoEncoderCallback> callback(
+ new InitDoneCallback(aThis, aInitDone, aCodecParams, aMaxPayloadSize));
+ aThis->mInitting = true;
+ nsresult rv = aThis->mMPS->GetGMPVideoEncoder(nullptr,
+ &tags,
+ NS_LITERAL_CSTRING(""),
+ Move(callback));
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ LOGD(("GMP Encode: GetGMPVideoEncoder failed"));
+ aThis->Close_g();
+ aInitDone->Dispatch(WEBRTC_VIDEO_CODEC_ERROR,
+ "GMP Encode: GetGMPVideoEncoder failed");
+ }
+}
+
+int32_t
+WebrtcGmpVideoEncoder::GmpInitDone(GMPVideoEncoderProxy* aGMP,
+ GMPVideoHost* aHost,
+ std::string* aErrorOut)
+{
+ if (!mInitting || !aGMP || !aHost) {
+ *aErrorOut = "GMP Encode: Either init was aborted, "
+ "or init failed to supply either a GMP Encoder or GMP host.";
+ if (aGMP) {
+ // This could destroy us, since aGMP may be the last thing holding a ref
+ // Return immediately.
+ aGMP->Close();
+ }
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ mInitting = false;
+
+ if (mGMP && mGMP != aGMP) {
+ Close_g();
+ }
+
+ mGMP = aGMP;
+ mHost = aHost;
+ mCachedPluginId = mGMP->GetPluginId();
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t
+WebrtcGmpVideoEncoder::GmpInitDone(GMPVideoEncoderProxy* aGMP,
+ GMPVideoHost* aHost,
+ const GMPVideoCodec& aCodecParams,
+ uint32_t aMaxPayloadSize,
+ std::string* aErrorOut)
+{
+ int32_t r = GmpInitDone(aGMP, aHost, aErrorOut);
+ if (r != WEBRTC_VIDEO_CODEC_OK) {
+ // We might have been destroyed if GmpInitDone failed.
+ // Return immediately.
+ return r;
+ }
+ mCodecParams = aCodecParams;
+ return InitEncoderForSize(aCodecParams.mWidth,
+ aCodecParams.mHeight,
+ aErrorOut);
+}
+
+void
+WebrtcGmpVideoEncoder::Close_g()
+{
+ GMPVideoEncoderProxy* gmp(mGMP);
+ mGMP = nullptr;
+ mHost = nullptr;
+ mInitting = false;
+
+ if (gmp) {
+ // Do this last, since this could cause us to be destroyed
+ gmp->Close();
+ }
+}
+
+int32_t
+WebrtcGmpVideoEncoder::InitEncoderForSize(unsigned short aWidth,
+ unsigned short aHeight,
+ std::string* aErrorOut)
+{
+ mCodecParams.mWidth = aWidth;
+ mCodecParams.mHeight = aHeight;
+ // Pass dummy codecSpecific data for now...
+ nsTArray<uint8_t> codecSpecific;
+
+ GMPErr err = mGMP->InitEncode(mCodecParams, codecSpecific, this, 1, mMaxPayloadSize);
+ if (err != GMPNoErr) {
+ *aErrorOut = "GMP Encode: InitEncode failed";
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+
+int32_t
+WebrtcGmpVideoEncoder::Encode(const webrtc::I420VideoFrame& aInputImage,
+ const webrtc::CodecSpecificInfo* aCodecSpecificInfo,
+ const std::vector<webrtc::VideoFrameType>* aFrameTypes)
+{
+ MOZ_ASSERT(aInputImage.width() >= 0 && aInputImage.height() >= 0);
+ // Would be really nice to avoid this sync dispatch, but it would require a
+ // copy of the frame, since it doesn't appear to actually have a refcount.
+ mGMPThread->Dispatch(
+ WrapRunnable(this,
+ &WebrtcGmpVideoEncoder::Encode_g,
+ &aInputImage,
+ aCodecSpecificInfo,
+ aFrameTypes),
+ NS_DISPATCH_SYNC);
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+void
+WebrtcGmpVideoEncoder::RegetEncoderForResolutionChange(
+ uint32_t aWidth,
+ uint32_t aHeight,
+ const RefPtr<GmpInitDoneRunnable>& aInitDone)
+{
+ Close_g();
+
+ UniquePtr<GetGMPVideoEncoderCallback> callback(
+ new InitDoneForResolutionChangeCallback(this,
+ aInitDone,
+ aWidth,
+ aHeight));
+
+ // OpenH264 codec (at least) can't handle dynamic input resolution changes
+ // re-init the plugin when the resolution changes
+ // XXX allow codec to indicate it doesn't need re-init!
+ nsTArray<nsCString> tags;
+ tags.AppendElement(NS_LITERAL_CSTRING("h264"));
+ mInitting = true;
+ if (NS_WARN_IF(NS_FAILED(mMPS->GetGMPVideoEncoder(nullptr,
+ &tags,
+ NS_LITERAL_CSTRING(""),
+ Move(callback))))) {
+ aInitDone->Dispatch(WEBRTC_VIDEO_CODEC_ERROR,
+ "GMP Encode: GetGMPVideoEncoder failed");
+ }
+}
+
+int32_t
+WebrtcGmpVideoEncoder::Encode_g(const webrtc::I420VideoFrame* aInputImage,
+ const webrtc::CodecSpecificInfo* aCodecSpecificInfo,
+ const std::vector<webrtc::VideoFrameType>* aFrameTypes)
+{
+ if (!mGMP) {
+ // destroyed via Terminate(), failed to init, or just not initted yet
+ LOGD(("GMP Encode: not initted yet"));
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+ MOZ_ASSERT(mHost);
+
+ if (static_cast<uint32_t>(aInputImage->width()) != mCodecParams.mWidth ||
+ static_cast<uint32_t>(aInputImage->height()) != mCodecParams.mHeight) {
+ LOGD(("GMP Encode: resolution change from %ux%u to %dx%d",
+ mCodecParams.mWidth, mCodecParams.mHeight, aInputImage->width(), aInputImage->height()));
+
+ RefPtr<GmpInitDoneRunnable> initDone(new GmpInitDoneRunnable(mPCHandle));
+ RegetEncoderForResolutionChange(aInputImage->width(),
+ aInputImage->height(),
+ initDone);
+ if (!mGMP) {
+ // We needed to go async to re-get the encoder. Bail.
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+ }
+
+ GMPVideoFrame* ftmp = nullptr;
+ GMPErr err = mHost->CreateFrame(kGMPI420VideoFrame, &ftmp);
+ if (err != GMPNoErr) {
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+ GMPUniquePtr<GMPVideoi420Frame> frame(static_cast<GMPVideoi420Frame*>(ftmp));
+
+ err = frame->CreateFrame(aInputImage->allocated_size(webrtc::kYPlane),
+ aInputImage->buffer(webrtc::kYPlane),
+ aInputImage->allocated_size(webrtc::kUPlane),
+ aInputImage->buffer(webrtc::kUPlane),
+ aInputImage->allocated_size(webrtc::kVPlane),
+ aInputImage->buffer(webrtc::kVPlane),
+ aInputImage->width(),
+ aInputImage->height(),
+ aInputImage->stride(webrtc::kYPlane),
+ aInputImage->stride(webrtc::kUPlane),
+ aInputImage->stride(webrtc::kVPlane));
+ if (err != GMPNoErr) {
+ return err;
+ }
+ frame->SetTimestamp((aInputImage->timestamp() * 1000ll)/90); // note: rounds down!
+ //frame->SetDuration(1000000ll/30); // XXX base duration on measured current FPS - or don't bother
+
+ // Bug XXXXXX: Set codecSpecific info
+ GMPCodecSpecificInfo info;
+ memset(&info, 0, sizeof(info));
+ info.mCodecType = kGMPVideoCodecH264;
+ nsTArray<uint8_t> codecSpecificInfo;
+ codecSpecificInfo.AppendElements((uint8_t*)&info, sizeof(GMPCodecSpecificInfo));
+
+ nsTArray<GMPVideoFrameType> gmp_frame_types;
+ for (auto it = aFrameTypes->begin(); it != aFrameTypes->end(); ++it) {
+ GMPVideoFrameType ft;
+
+ int32_t ret = WebrtcFrameTypeToGmpFrameType(*it, &ft);
+ if (ret != WEBRTC_VIDEO_CODEC_OK) {
+ return ret;
+ }
+
+ gmp_frame_types.AppendElement(ft);
+ }
+
+ LOGD(("GMP Encode: %llu", (aInputImage->timestamp() * 1000ll)/90));
+ err = mGMP->Encode(Move(frame), codecSpecificInfo, gmp_frame_types);
+ if (err != GMPNoErr) {
+ return err;
+ }
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t
+WebrtcGmpVideoEncoder::RegisterEncodeCompleteCallback(webrtc::EncodedImageCallback* aCallback)
+{
+ MutexAutoLock lock(mCallbackMutex);
+ mCallback = aCallback;
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+/* static */ void
+WebrtcGmpVideoEncoder::ReleaseGmp_g(RefPtr<WebrtcGmpVideoEncoder>& aEncoder)
+{
+ aEncoder->Close_g();
+}
+
+int32_t
+WebrtcGmpVideoEncoder::ReleaseGmp()
+{
+ LOGD(("GMP Released:"));
+ if (mGMPThread) {
+ mGMPThread->Dispatch(
+ WrapRunnableNM(&WebrtcGmpVideoEncoder::ReleaseGmp_g,
+ RefPtr<WebrtcGmpVideoEncoder>(this)),
+ NS_DISPATCH_NORMAL);
+ }
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t
+WebrtcGmpVideoEncoder::SetChannelParameters(uint32_t aPacketLoss, int aRTT)
+{
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t
+WebrtcGmpVideoEncoder::SetRates(uint32_t aNewBitRate, uint32_t aFrameRate)
+{
+ MOZ_ASSERT(mGMPThread);
+ if (aFrameRate == 0) {
+ aFrameRate = 30; // Assume 30fps if we don't know the rate
+ }
+ mGMPThread->Dispatch(WrapRunnableNM(&WebrtcGmpVideoEncoder::SetRates_g,
+ RefPtr<WebrtcGmpVideoEncoder>(this),
+ aNewBitRate,
+ aFrameRate),
+ NS_DISPATCH_NORMAL);
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+/* static */ int32_t
+WebrtcGmpVideoEncoder::SetRates_g(RefPtr<WebrtcGmpVideoEncoder> aThis,
+ uint32_t aNewBitRate,
+ uint32_t aFrameRate)
+{
+ if (!aThis->mGMP) {
+ // destroyed via Terminate()
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ GMPErr err = aThis->mGMP->SetRates(aNewBitRate, aFrameRate);
+ if (err != GMPNoErr) {
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+// GMPVideoEncoderCallback virtual functions.
+void
+WebrtcGmpVideoEncoder::Terminated()
+{
+ LOGD(("GMP Encoder Terminated: %p", (void *)this));
+
+ mGMP->Close();
+ mGMP = nullptr;
+ mHost = nullptr;
+ mInitting = false;
+ // Could now notify that it's dead
+}
+
+void
+WebrtcGmpVideoEncoder::Encoded(GMPVideoEncodedFrame* aEncodedFrame,
+ const nsTArray<uint8_t>& aCodecSpecificInfo)
+{
+ MutexAutoLock lock(mCallbackMutex);
+ if (mCallback) {
+ webrtc::VideoFrameType ft;
+ GmpFrameTypeToWebrtcFrameType(aEncodedFrame->FrameType(), &ft);
+ uint32_t timestamp = (aEncodedFrame->TimeStamp() * 90ll + 999)/1000;
+
+ LOGD(("GMP Encoded: %llu, type %d, len %d",
+ aEncodedFrame->TimeStamp(),
+ aEncodedFrame->BufferType(),
+ aEncodedFrame->Size()));
+
+ // Right now makes one Encoded() callback per unit
+ // XXX convert to FragmentationHeader format (array of offsets and sizes plus a buffer) in
+ // combination with H264 packetization changes in webrtc/trunk code
+ uint8_t *buffer = aEncodedFrame->Buffer();
+ uint8_t *end = aEncodedFrame->Buffer() + aEncodedFrame->Size();
+ size_t size_bytes;
+ switch (aEncodedFrame->BufferType()) {
+ case GMP_BufferSingle:
+ size_bytes = 0;
+ break;
+ case GMP_BufferLength8:
+ size_bytes = 1;
+ break;
+ case GMP_BufferLength16:
+ size_bytes = 2;
+ break;
+ case GMP_BufferLength24:
+ size_bytes = 3;
+ break;
+ case GMP_BufferLength32:
+ size_bytes = 4;
+ break;
+ default:
+ // Really that it's not in the enum
+ LOG(LogLevel::Error,
+ ("GMP plugin returned incorrect type (%d)", aEncodedFrame->BufferType()));
+ // XXX Bug 1041232 - need a better API for interfacing to the
+ // plugin so we can kill it here
+ return;
+ }
+
+ struct nal_entry {
+ uint32_t offset;
+ uint32_t size;
+ };
+ AutoTArray<nal_entry, 1> nals;
+ uint32_t size;
+ // make sure we don't read past the end of the buffer getting the size
+ while (buffer+size_bytes < end) {
+ switch (aEncodedFrame->BufferType()) {
+ case GMP_BufferSingle:
+ size = aEncodedFrame->Size();
+ break;
+ case GMP_BufferLength8:
+ size = *buffer++;
+ break;
+ case GMP_BufferLength16:
+ // presumes we can do unaligned loads
+ size = *(reinterpret_cast<uint16_t*>(buffer));
+ buffer += 2;
+ break;
+ case GMP_BufferLength24:
+ // 24-bits is a pain, since byte-order issues make things painful
+ // I'm going to define 24-bit as little-endian always; big-endian must convert
+ size = ((uint32_t) *buffer) |
+ (((uint32_t) *(buffer+1)) << 8) |
+ (((uint32_t) *(buffer+2)) << 16);
+ buffer += 3;
+ break;
+ case GMP_BufferLength32:
+ // presumes we can do unaligned loads
+ size = *(reinterpret_cast<uint32_t*>(buffer));
+ buffer += 4;
+ break;
+ default:
+ MOZ_CRASH("GMP_BufferType already handled in switch above");
+ }
+ if (buffer+size > end) {
+ // XXX see above - should we kill the plugin for returning extra bytes? Probably
+ LOG(LogLevel::Error,
+ ("GMP plugin returned badly formatted encoded data: end is %td bytes past buffer end",
+ buffer+size - end));
+ return;
+ }
+ // XXX optimize by making buffer an offset
+ nal_entry nal = {((uint32_t) (buffer-aEncodedFrame->Buffer())), (uint32_t) size};
+ nals.AppendElement(nal);
+ buffer += size;
+ // on last one, buffer == end normally
+ }
+ if (buffer != end) {
+ // At most 3 bytes can be left over, depending on buffertype
+ LOGD(("GMP plugin returned %td extra bytes", end - buffer));
+ }
+
+ size_t num_nals = nals.Length();
+ if (num_nals > 0) {
+ webrtc::RTPFragmentationHeader fragmentation;
+ fragmentation.VerifyAndAllocateFragmentationHeader(num_nals);
+ for (size_t i = 0; i < num_nals; i++) {
+ fragmentation.fragmentationOffset[i] = nals[i].offset;
+ fragmentation.fragmentationLength[i] = nals[i].size;
+ }
+
+ webrtc::EncodedImage unit(aEncodedFrame->Buffer(), size, size);
+ unit._frameType = ft;
+ unit._timeStamp = timestamp;
+ // Ensure we ignore this when calculating RTCP timestamps
+ unit.capture_time_ms_ = -1;
+ unit._completeFrame = true;
+
+ // TODO: Currently the OpenH264 codec does not preserve any codec
+ // specific info passed into it and just returns default values.
+ // If this changes in the future, it would be nice to get rid of
+ // mCodecSpecificInfo.
+ mCallback->Encoded(unit, &mCodecSpecificInfo, &fragmentation);
+ }
+ }
+}
+
+// Decoder.
+WebrtcGmpVideoDecoder::WebrtcGmpVideoDecoder() :
+ mGMP(nullptr),
+ mInitting(false),
+ mHost(nullptr),
+ mCallbackMutex("WebrtcGmpVideoDecoder decoded callback mutex"),
+ mCallback(nullptr),
+ mCachedPluginId(0),
+ mDecoderStatus(GMPNoErr)
+{
+#ifdef MOZILLA_INTERNAL_API
+ if (mPCHandle.empty()) {
+ mPCHandle = WebrtcGmpPCHandleSetter::GetCurrentHandle();
+ }
+ MOZ_ASSERT(!mPCHandle.empty());
+#endif
+}
+
+WebrtcGmpVideoDecoder::~WebrtcGmpVideoDecoder()
+{
+ // We should not have been destroyed if we never closed our GMP
+ MOZ_ASSERT(!mGMP);
+}
+
+int32_t
+WebrtcGmpVideoDecoder::InitDecode(const webrtc::VideoCodec* aCodecSettings,
+ int32_t aNumberOfCores)
+{
+ if (!mMPS) {
+ mMPS = do_GetService("@mozilla.org/gecko-media-plugin-service;1");
+ }
+ MOZ_ASSERT(mMPS);
+
+ if (!mGMPThread) {
+ if (NS_WARN_IF(NS_FAILED(mMPS->GetThread(getter_AddRefs(mGMPThread))))) {
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+ }
+
+ RefPtr<GmpInitDoneRunnable> initDone(new GmpInitDoneRunnable(mPCHandle));
+ mGMPThread->Dispatch(WrapRunnableNM(&WebrtcGmpVideoDecoder::InitDecode_g,
+ RefPtr<WebrtcGmpVideoDecoder>(this),
+ aCodecSettings,
+ aNumberOfCores,
+ initDone),
+ NS_DISPATCH_NORMAL);
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+/* static */ void
+WebrtcGmpVideoDecoder::InitDecode_g(
+ const RefPtr<WebrtcGmpVideoDecoder>& aThis,
+ const webrtc::VideoCodec* aCodecSettings,
+ int32_t aNumberOfCores,
+ const RefPtr<GmpInitDoneRunnable>& aInitDone)
+{
+ nsTArray<nsCString> tags;
+ tags.AppendElement(NS_LITERAL_CSTRING("h264"));
+ UniquePtr<GetGMPVideoDecoderCallback> callback(
+ new InitDoneCallback(aThis, aInitDone));
+ aThis->mInitting = true;
+ nsresult rv = aThis->mMPS->GetGMPVideoDecoder(nullptr,
+ &tags,
+ NS_LITERAL_CSTRING(""),
+ Move(callback));
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ LOGD(("GMP Decode: GetGMPVideoDecoder failed"));
+ aThis->Close_g();
+ aInitDone->Dispatch(WEBRTC_VIDEO_CODEC_ERROR,
+ "GMP Decode: GetGMPVideoDecoder failed.");
+ }
+}
+
+int32_t
+WebrtcGmpVideoDecoder::GmpInitDone(GMPVideoDecoderProxy* aGMP,
+ GMPVideoHost* aHost,
+ std::string* aErrorOut)
+{
+ if (!mInitting || !aGMP || !aHost) {
+ *aErrorOut = "GMP Decode: Either init was aborted, "
+ "or init failed to supply either a GMP decoder or GMP host.";
+ if (aGMP) {
+ // This could destroy us, since aGMP may be the last thing holding a ref
+ // Return immediately.
+ aGMP->Close();
+ }
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ mInitting = false;
+
+ if (mGMP && mGMP != aGMP) {
+ Close_g();
+ }
+
+ mGMP = aGMP;
+ mHost = aHost;
+ mCachedPluginId = mGMP->GetPluginId();
+ // Bug XXXXXX: transfer settings from codecSettings to codec.
+ GMPVideoCodec codec;
+ memset(&codec, 0, sizeof(codec));
+ codec.mGMPApiVersion = 33;
+
+ // XXX this is currently a hack
+ //GMPVideoCodecUnion codecSpecific;
+ //memset(&codecSpecific, 0, sizeof(codecSpecific));
+ nsTArray<uint8_t> codecSpecific;
+ nsresult rv = mGMP->InitDecode(codec, codecSpecific, this, 1);
+ if (NS_FAILED(rv)) {
+ *aErrorOut = "GMP Decode: InitDecode failed";
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+void
+WebrtcGmpVideoDecoder::Close_g()
+{
+ GMPVideoDecoderProxy* gmp(mGMP);
+ mGMP = nullptr;
+ mHost = nullptr;
+ mInitting = false;
+
+ if (gmp) {
+ // Do this last, since this could cause us to be destroyed
+ gmp->Close();
+ }
+}
+
+int32_t
+WebrtcGmpVideoDecoder::Decode(const webrtc::EncodedImage& aInputImage,
+ bool aMissingFrames,
+ const webrtc::RTPFragmentationHeader* aFragmentation,
+ const webrtc::CodecSpecificInfo* aCodecSpecificInfo,
+ int64_t aRenderTimeMs)
+{
+ int32_t ret;
+ MOZ_ASSERT(mGMPThread);
+ MOZ_ASSERT(!NS_IsMainThread());
+ // Would be really nice to avoid this sync dispatch, but it would require a
+ // copy of the frame, since it doesn't appear to actually have a refcount.
+ mozilla::SyncRunnable::DispatchToThread(mGMPThread,
+ WrapRunnableRet(&ret, this,
+ &WebrtcGmpVideoDecoder::Decode_g,
+ aInputImage,
+ aMissingFrames,
+ aFragmentation,
+ aCodecSpecificInfo,
+ aRenderTimeMs));
+
+ return ret;
+}
+
+int32_t
+WebrtcGmpVideoDecoder::Decode_g(const webrtc::EncodedImage& aInputImage,
+ bool aMissingFrames,
+ const webrtc::RTPFragmentationHeader* aFragmentation,
+ const webrtc::CodecSpecificInfo* aCodecSpecificInfo,
+ int64_t aRenderTimeMs)
+{
+ if (!mGMP) {
+ // destroyed via Terminate(), failed to init, or just not initted yet
+ LOGD(("GMP Decode: not initted yet"));
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+ MOZ_ASSERT(mHost);
+
+ if (!aInputImage._length) {
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ GMPVideoFrame* ftmp = nullptr;
+ GMPErr err = mHost->CreateFrame(kGMPEncodedVideoFrame, &ftmp);
+ if (err != GMPNoErr) {
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ GMPUniquePtr<GMPVideoEncodedFrame> frame(static_cast<GMPVideoEncodedFrame*>(ftmp));
+ err = frame->CreateEmptyFrame(aInputImage._length);
+ if (err != GMPNoErr) {
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ // XXX At this point, we only will get mode1 data (a single length and a buffer)
+ // Session_info.cc/etc code needs to change to support mode 0.
+ *(reinterpret_cast<uint32_t*>(frame->Buffer())) = frame->Size();
+
+ // XXX It'd be wonderful not to have to memcpy the encoded data!
+ memcpy(frame->Buffer()+4, aInputImage._buffer+4, frame->Size()-4);
+
+ frame->SetEncodedWidth(aInputImage._encodedWidth);
+ frame->SetEncodedHeight(aInputImage._encodedHeight);
+ frame->SetTimeStamp((aInputImage._timeStamp * 1000ll)/90); // rounds down
+ frame->SetCompleteFrame(aInputImage._completeFrame);
+ frame->SetBufferType(GMP_BufferLength32);
+
+ GMPVideoFrameType ft;
+ int32_t ret = WebrtcFrameTypeToGmpFrameType(aInputImage._frameType, &ft);
+ if (ret != WEBRTC_VIDEO_CODEC_OK) {
+ return ret;
+ }
+
+ // Bug XXXXXX: Set codecSpecific info
+ GMPCodecSpecificInfo info;
+ memset(&info, 0, sizeof(info));
+ info.mCodecType = kGMPVideoCodecH264;
+ info.mCodecSpecific.mH264.mSimulcastIdx = 0;
+ nsTArray<uint8_t> codecSpecificInfo;
+ codecSpecificInfo.AppendElements((uint8_t*)&info, sizeof(GMPCodecSpecificInfo));
+
+ LOGD(("GMP Decode: %llu, len %d", frame->TimeStamp(), aInputImage._length));
+ nsresult rv = mGMP->Decode(Move(frame),
+ aMissingFrames,
+ codecSpecificInfo,
+ aRenderTimeMs);
+ if (NS_FAILED(rv)) {
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+ if(mDecoderStatus != GMPNoErr){
+ mDecoderStatus = GMPNoErr;
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t
+WebrtcGmpVideoDecoder::RegisterDecodeCompleteCallback( webrtc::DecodedImageCallback* aCallback)
+{
+ MutexAutoLock lock(mCallbackMutex);
+ mCallback = aCallback;
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+
+/* static */ void
+WebrtcGmpVideoDecoder::ReleaseGmp_g(RefPtr<WebrtcGmpVideoDecoder>& aDecoder)
+{
+ aDecoder->Close_g();
+}
+
+int32_t
+WebrtcGmpVideoDecoder::ReleaseGmp()
+{
+ LOGD(("GMP Released:"));
+ RegisterDecodeCompleteCallback(nullptr);
+
+ if (mGMPThread) {
+ mGMPThread->Dispatch(
+ WrapRunnableNM(&WebrtcGmpVideoDecoder::ReleaseGmp_g,
+ RefPtr<WebrtcGmpVideoDecoder>(this)),
+ NS_DISPATCH_NORMAL);
+ }
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t
+WebrtcGmpVideoDecoder::Reset()
+{
+ // XXX ?
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+void
+WebrtcGmpVideoDecoder::Terminated()
+{
+ LOGD(("GMP Decoder Terminated: %p", (void *)this));
+
+ mGMP->Close();
+ mGMP = nullptr;
+ mHost = nullptr;
+ mInitting = false;
+ // Could now notify that it's dead
+}
+
+void
+WebrtcGmpVideoDecoder::Decoded(GMPVideoi420Frame* aDecodedFrame)
+{
+ MutexAutoLock lock(mCallbackMutex);
+ if (mCallback) {
+ webrtc::I420VideoFrame image;
+ int ret = image.CreateFrame(aDecodedFrame->Buffer(kGMPYPlane),
+ aDecodedFrame->Buffer(kGMPUPlane),
+ aDecodedFrame->Buffer(kGMPVPlane),
+ aDecodedFrame->Width(),
+ aDecodedFrame->Height(),
+ aDecodedFrame->Stride(kGMPYPlane),
+ aDecodedFrame->Stride(kGMPUPlane),
+ aDecodedFrame->Stride(kGMPVPlane));
+ if (ret != 0) {
+ return;
+ }
+ image.set_timestamp((aDecodedFrame->Timestamp() * 90ll + 999)/1000); // round up
+ image.set_render_time_ms(0);
+
+ LOGD(("GMP Decoded: %llu", aDecodedFrame->Timestamp()));
+ mCallback->Decoded(image);
+ }
+ aDecodedFrame->Destroy();
+}
+
+}
diff --git a/media/webrtc/signaling/src/media-conduit/WebrtcGmpVideoCodec.h b/media/webrtc/signaling/src/media-conduit/WebrtcGmpVideoCodec.h
new file mode 100644
index 000000000..0c01bf53c
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/WebrtcGmpVideoCodec.h
@@ -0,0 +1,528 @@
+/*
+ * Copyright (c) 2012, The WebRTC project authors. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * * Neither the name of Google nor the names of its contributors may
+ * be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef WEBRTCGMPVIDEOCODEC_H_
+#define WEBRTCGMPVIDEOCODEC_H_
+
+#include <iostream>
+#include <queue>
+#include <string>
+
+#include "nsThreadUtils.h"
+#include "mozilla/Monitor.h"
+#include "mozilla/Mutex.h"
+
+#include "mozIGeckoMediaPluginService.h"
+#include "MediaConduitInterface.h"
+#include "AudioConduit.h"
+#include "VideoConduit.h"
+#include "webrtc/modules/video_coding/codecs/interface/video_codec_interface.h"
+
+#include "gmp-video-host.h"
+#include "GMPVideoDecoderProxy.h"
+#include "GMPVideoEncoderProxy.h"
+
+#include "PeerConnectionImpl.h"
+
+namespace mozilla {
+
+// Class that allows code on the other side of webrtc.org to tell
+// WebrtcGmpVideoEncoder/Decoder what PC they should send errors to.
+// This is necessary because webrtc.org gives us no way to plumb the handle
+// through, nor does it give us any way to inform it of an error that will
+// make it back to the PC that cares (except for errors encountered
+// synchronously in functions like InitEncode/Decode, which will not happen
+// because GMP init is async).
+// Right now, this is used in MediaPipelineFactory.
+class WebrtcGmpPCHandleSetter
+{
+ public:
+ explicit WebrtcGmpPCHandleSetter(const std::string& aPCHandle);
+
+ ~WebrtcGmpPCHandleSetter();
+
+ static std::string GetCurrentHandle();
+
+ private:
+ static std::string sCurrentHandle;
+};
+
+class GmpInitDoneRunnable : public Runnable
+{
+ public:
+ explicit GmpInitDoneRunnable(const std::string& aPCHandle) :
+ mResult(WEBRTC_VIDEO_CODEC_OK),
+ mPCHandle(aPCHandle)
+ {
+ }
+
+ NS_IMETHOD Run() override
+ {
+ if (mResult == WEBRTC_VIDEO_CODEC_OK) {
+ // Might be useful to notify the PeerConnection about successful init
+ // someday.
+ return NS_OK;
+ }
+
+ PeerConnectionWrapper wrapper(mPCHandle);
+ if (wrapper.impl()) {
+ wrapper.impl()->OnMediaError(mError);
+ }
+ return NS_OK;
+ }
+
+ void Dispatch(int32_t aResult, const std::string& aError = "")
+ {
+ mResult = aResult;
+ mError = aError;
+ nsCOMPtr<nsIThread> mainThread(do_GetMainThread());
+ if (mainThread) {
+ // For some reason, the compiler on CI is treating |this| as a const
+ // pointer, despite the fact that we're in a non-const function. And,
+ // interestingly enough, correcting this doesn't require a const_cast.
+ mainThread->Dispatch(do_AddRef(static_cast<nsIRunnable*>(this)),
+ NS_DISPATCH_NORMAL);
+ }
+ }
+
+ int32_t Result()
+ {
+ return mResult;
+ }
+
+ private:
+ int32_t mResult;
+ std::string mPCHandle;
+ std::string mError;
+};
+
+class WebrtcGmpVideoEncoder : public GMPVideoEncoderCallbackProxy
+{
+public:
+ WebrtcGmpVideoEncoder();
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WebrtcGmpVideoEncoder);
+
+ // Implement VideoEncoder interface, sort of.
+ // (We cannot use |Release|, since that's needed for nsRefPtr)
+ virtual uint64_t PluginID() const
+ {
+ return mCachedPluginId;
+ }
+
+ virtual int32_t InitEncode(const webrtc::VideoCodec* aCodecSettings,
+ int32_t aNumberOfCores,
+ uint32_t aMaxPayloadSize);
+
+ virtual int32_t Encode(const webrtc::I420VideoFrame& aInputImage,
+ const webrtc::CodecSpecificInfo* aCodecSpecificInfo,
+ const std::vector<webrtc::VideoFrameType>* aFrameTypes);
+
+ virtual int32_t RegisterEncodeCompleteCallback(
+ webrtc::EncodedImageCallback* aCallback);
+
+ virtual int32_t ReleaseGmp();
+
+ virtual int32_t SetChannelParameters(uint32_t aPacketLoss,
+ int aRTT);
+
+ virtual int32_t SetRates(uint32_t aNewBitRate,
+ uint32_t aFrameRate);
+
+ // GMPVideoEncoderCallback virtual functions.
+ virtual void Terminated() override;
+
+ virtual void Encoded(GMPVideoEncodedFrame* aEncodedFrame,
+ const nsTArray<uint8_t>& aCodecSpecificInfo) override;
+
+ virtual void Error(GMPErr aError) override {
+ }
+
+private:
+ virtual ~WebrtcGmpVideoEncoder();
+
+ static void InitEncode_g(const RefPtr<WebrtcGmpVideoEncoder>& aThis,
+ const GMPVideoCodec& aCodecParams,
+ int32_t aNumberOfCores,
+ uint32_t aMaxPayloadSize,
+ const RefPtr<GmpInitDoneRunnable>& aInitDone);
+ int32_t GmpInitDone(GMPVideoEncoderProxy* aGMP, GMPVideoHost* aHost,
+ const GMPVideoCodec& aCodecParams,
+ uint32_t aMaxPayloadSize,
+ std::string* aErrorOut);
+ int32_t GmpInitDone(GMPVideoEncoderProxy* aGMP,
+ GMPVideoHost* aHost,
+ std::string* aErrorOut);
+ int32_t InitEncoderForSize(unsigned short aWidth,
+ unsigned short aHeight,
+ std::string* aErrorOut);
+ static void ReleaseGmp_g(RefPtr<WebrtcGmpVideoEncoder>& aEncoder);
+ void Close_g();
+
+ class InitDoneCallback : public GetGMPVideoEncoderCallback
+ {
+ public:
+ InitDoneCallback(const RefPtr<WebrtcGmpVideoEncoder>& aEncoder,
+ const RefPtr<GmpInitDoneRunnable>& aInitDone,
+ const GMPVideoCodec& aCodecParams,
+ uint32_t aMaxPayloadSize)
+ : mEncoder(aEncoder),
+ mInitDone(aInitDone),
+ mCodecParams(aCodecParams),
+ mMaxPayloadSize(aMaxPayloadSize)
+ {
+ }
+
+ virtual void Done(GMPVideoEncoderProxy* aGMP, GMPVideoHost* aHost) override
+ {
+ std::string errorOut;
+ int32_t result = mEncoder->GmpInitDone(aGMP,
+ aHost,
+ mCodecParams,
+ mMaxPayloadSize,
+ &errorOut);
+
+ mInitDone->Dispatch(result, errorOut);
+ }
+
+ private:
+ RefPtr<WebrtcGmpVideoEncoder> mEncoder;
+ RefPtr<GmpInitDoneRunnable> mInitDone;
+ GMPVideoCodec mCodecParams;
+ uint32_t mMaxPayloadSize;
+ };
+
+ int32_t Encode_g(const webrtc::I420VideoFrame* aInputImage,
+ const webrtc::CodecSpecificInfo* aCodecSpecificInfo,
+ const std::vector<webrtc::VideoFrameType>* aFrameTypes);
+ void RegetEncoderForResolutionChange(
+ uint32_t aWidth,
+ uint32_t aHeight,
+ const RefPtr<GmpInitDoneRunnable>& aInitDone);
+
+ class InitDoneForResolutionChangeCallback : public GetGMPVideoEncoderCallback
+ {
+ public:
+ InitDoneForResolutionChangeCallback(
+ const RefPtr<WebrtcGmpVideoEncoder>& aEncoder,
+ const RefPtr<GmpInitDoneRunnable>& aInitDone,
+ uint32_t aWidth,
+ uint32_t aHeight)
+ : mEncoder(aEncoder),
+ mInitDone(aInitDone),
+ mWidth(aWidth),
+ mHeight(aHeight)
+ {
+ }
+
+ virtual void Done(GMPVideoEncoderProxy* aGMP, GMPVideoHost* aHost) override
+ {
+ std::string errorOut;
+ int32_t result = mEncoder->GmpInitDone(aGMP, aHost, &errorOut);
+ if (result != WEBRTC_VIDEO_CODEC_OK) {
+ mInitDone->Dispatch(result, errorOut);
+ return;
+ }
+
+ result = mEncoder->InitEncoderForSize(mWidth, mHeight, &errorOut);
+ mInitDone->Dispatch(result, errorOut);
+ }
+
+ private:
+ RefPtr<WebrtcGmpVideoEncoder> mEncoder;
+ RefPtr<GmpInitDoneRunnable> mInitDone;
+ uint32_t mWidth;
+ uint32_t mHeight;
+ };
+
+ static int32_t SetRates_g(RefPtr<WebrtcGmpVideoEncoder> aThis,
+ uint32_t aNewBitRate,
+ uint32_t aFrameRate);
+
+ nsCOMPtr<mozIGeckoMediaPluginService> mMPS;
+ nsCOMPtr<nsIThread> mGMPThread;
+ GMPVideoEncoderProxy* mGMP;
+ // Used to handle a race where Release() is called while init is in progress
+ bool mInitting;
+ GMPVideoHost* mHost;
+ GMPVideoCodec mCodecParams;
+ uint32_t mMaxPayloadSize;
+ webrtc::CodecSpecificInfo mCodecSpecificInfo;
+ // Protects mCallback
+ Mutex mCallbackMutex;
+ webrtc::EncodedImageCallback* mCallback;
+ uint64_t mCachedPluginId;
+ std::string mPCHandle;
+};
+
+
+// Basically a strong ref to a WebrtcGmpVideoEncoder, that also translates
+// from Release() to WebrtcGmpVideoEncoder::ReleaseGmp(), since we need
+// WebrtcGmpVideoEncoder::Release() for managing the refcount.
+// The webrtc.org code gets one of these, so it doesn't unilaterally delete
+// the "real" encoder.
+class WebrtcVideoEncoderProxy : public WebrtcVideoEncoder
+{
+ public:
+ WebrtcVideoEncoderProxy() :
+ mEncoderImpl(new WebrtcGmpVideoEncoder)
+ {}
+
+ virtual ~WebrtcVideoEncoderProxy()
+ {
+ RegisterEncodeCompleteCallback(nullptr);
+ }
+
+ uint64_t PluginID() const override
+ {
+ return mEncoderImpl->PluginID();
+ }
+
+ int32_t InitEncode(const webrtc::VideoCodec* aCodecSettings,
+ int32_t aNumberOfCores,
+ size_t aMaxPayloadSize) override
+ {
+ return mEncoderImpl->InitEncode(aCodecSettings,
+ aNumberOfCores,
+ aMaxPayloadSize);
+ }
+
+ int32_t Encode(
+ const webrtc::I420VideoFrame& aInputImage,
+ const webrtc::CodecSpecificInfo* aCodecSpecificInfo,
+ const std::vector<webrtc::VideoFrameType>* aFrameTypes) override
+ {
+ return mEncoderImpl->Encode(aInputImage,
+ aCodecSpecificInfo,
+ aFrameTypes);
+ }
+
+ int32_t RegisterEncodeCompleteCallback(
+ webrtc::EncodedImageCallback* aCallback) override
+ {
+ return mEncoderImpl->RegisterEncodeCompleteCallback(aCallback);
+ }
+
+ int32_t Release() override
+ {
+ return mEncoderImpl->ReleaseGmp();
+ }
+
+ int32_t SetChannelParameters(uint32_t aPacketLoss,
+ int64_t aRTT) override
+ {
+ return mEncoderImpl->SetChannelParameters(aPacketLoss, aRTT);
+ }
+
+ int32_t SetRates(uint32_t aNewBitRate,
+ uint32_t aFrameRate) override
+ {
+ return mEncoderImpl->SetRates(aNewBitRate, aFrameRate);
+ }
+
+ private:
+ RefPtr<WebrtcGmpVideoEncoder> mEncoderImpl;
+};
+
+class WebrtcGmpVideoDecoder : public GMPVideoDecoderCallbackProxy
+{
+public:
+ WebrtcGmpVideoDecoder();
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WebrtcGmpVideoDecoder);
+
+ // Implement VideoEncoder interface, sort of.
+ // (We cannot use |Release|, since that's needed for nsRefPtr)
+ virtual uint64_t PluginID() const
+ {
+ return mCachedPluginId;
+ }
+
+ virtual int32_t InitDecode(const webrtc::VideoCodec* aCodecSettings,
+ int32_t aNumberOfCores);
+ virtual int32_t Decode(const webrtc::EncodedImage& aInputImage,
+ bool aMissingFrames,
+ const webrtc::RTPFragmentationHeader* aFragmentation,
+ const webrtc::CodecSpecificInfo* aCodecSpecificInfo,
+ int64_t aRenderTimeMs);
+ virtual int32_t RegisterDecodeCompleteCallback(webrtc::DecodedImageCallback* aCallback);
+
+ virtual int32_t ReleaseGmp();
+
+ virtual int32_t Reset();
+
+ // GMPVideoDecoderCallbackProxy
+ virtual void Terminated() override;
+
+ virtual void Decoded(GMPVideoi420Frame* aDecodedFrame) override;
+
+ virtual void ReceivedDecodedReferenceFrame(const uint64_t aPictureId) override {
+ MOZ_CRASH();
+ }
+
+ virtual void ReceivedDecodedFrame(const uint64_t aPictureId) override {
+ MOZ_CRASH();
+ }
+
+ virtual void InputDataExhausted() override {
+ }
+
+ virtual void DrainComplete() override {
+ }
+
+ virtual void ResetComplete() override {
+ }
+
+ virtual void Error(GMPErr aError) override {
+ mDecoderStatus = aError;
+ }
+
+private:
+ virtual ~WebrtcGmpVideoDecoder();
+
+ static void InitDecode_g(
+ const RefPtr<WebrtcGmpVideoDecoder>& aThis,
+ const webrtc::VideoCodec* aCodecSettings,
+ int32_t aNumberOfCores,
+ const RefPtr<GmpInitDoneRunnable>& aInitDone);
+ int32_t GmpInitDone(GMPVideoDecoderProxy* aGMP,
+ GMPVideoHost* aHost,
+ std::string* aErrorOut);
+ static void ReleaseGmp_g(RefPtr<WebrtcGmpVideoDecoder>& aDecoder);
+ void Close_g();
+
+ class InitDoneCallback : public GetGMPVideoDecoderCallback
+ {
+ public:
+ explicit InitDoneCallback(const RefPtr<WebrtcGmpVideoDecoder>& aDecoder,
+ const RefPtr<GmpInitDoneRunnable>& aInitDone)
+ : mDecoder(aDecoder),
+ mInitDone(aInitDone)
+ {
+ }
+
+ virtual void Done(GMPVideoDecoderProxy* aGMP, GMPVideoHost* aHost)
+ {
+ std::string errorOut;
+ int32_t result = mDecoder->GmpInitDone(aGMP, aHost, &errorOut);
+
+ mInitDone->Dispatch(result, errorOut);
+ }
+
+ private:
+ RefPtr<WebrtcGmpVideoDecoder> mDecoder;
+ RefPtr<GmpInitDoneRunnable> mInitDone;
+ };
+
+ virtual int32_t Decode_g(const webrtc::EncodedImage& aInputImage,
+ bool aMissingFrames,
+ const webrtc::RTPFragmentationHeader* aFragmentation,
+ const webrtc::CodecSpecificInfo* aCodecSpecificInfo,
+ int64_t aRenderTimeMs);
+
+ nsCOMPtr<mozIGeckoMediaPluginService> mMPS;
+ nsCOMPtr<nsIThread> mGMPThread;
+ GMPVideoDecoderProxy* mGMP; // Addref is held for us
+ // Used to handle a race where Release() is called while init is in progress
+ bool mInitting;
+ GMPVideoHost* mHost;
+ // Protects mCallback
+ Mutex mCallbackMutex;
+ webrtc::DecodedImageCallback* mCallback;
+ Atomic<uint64_t> mCachedPluginId;
+ GMPErr mDecoderStatus;
+ std::string mPCHandle;
+};
+
+// Basically a strong ref to a WebrtcGmpVideoDecoder, that also translates
+// from Release() to WebrtcGmpVideoDecoder::ReleaseGmp(), since we need
+// WebrtcGmpVideoDecoder::Release() for managing the refcount.
+// The webrtc.org code gets one of these, so it doesn't unilaterally delete
+// the "real" encoder.
+class WebrtcVideoDecoderProxy : public WebrtcVideoDecoder
+{
+ public:
+ WebrtcVideoDecoderProxy() :
+ mDecoderImpl(new WebrtcGmpVideoDecoder)
+ {}
+
+ virtual ~WebrtcVideoDecoderProxy()
+ {
+ RegisterDecodeCompleteCallback(nullptr);
+ }
+
+ uint64_t PluginID() const override
+ {
+ return mDecoderImpl->PluginID();
+ }
+
+ int32_t InitDecode(const webrtc::VideoCodec* aCodecSettings,
+ int32_t aNumberOfCores) override
+ {
+ return mDecoderImpl->InitDecode(aCodecSettings, aNumberOfCores);
+ }
+
+ int32_t Decode(
+ const webrtc::EncodedImage& aInputImage,
+ bool aMissingFrames,
+ const webrtc::RTPFragmentationHeader* aFragmentation,
+ const webrtc::CodecSpecificInfo* aCodecSpecificInfo,
+ int64_t aRenderTimeMs) override
+ {
+ return mDecoderImpl->Decode(aInputImage,
+ aMissingFrames,
+ aFragmentation,
+ aCodecSpecificInfo,
+ aRenderTimeMs);
+ }
+
+ int32_t RegisterDecodeCompleteCallback(
+ webrtc::DecodedImageCallback* aCallback) override
+ {
+ return mDecoderImpl->RegisterDecodeCompleteCallback(aCallback);
+ }
+
+ int32_t Release() override
+ {
+ return mDecoderImpl->ReleaseGmp();
+ }
+
+ int32_t Reset() override
+ {
+ return mDecoderImpl->Reset();
+ }
+
+ private:
+ RefPtr<WebrtcGmpVideoDecoder> mDecoderImpl;
+};
+
+}
+
+#endif
diff --git a/media/webrtc/signaling/src/media-conduit/WebrtcMediaCodecVP8VideoCodec.cpp b/media/webrtc/signaling/src/media-conduit/WebrtcMediaCodecVP8VideoCodec.cpp
new file mode 100644
index 000000000..27b99d5ed
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/WebrtcMediaCodecVP8VideoCodec.cpp
@@ -0,0 +1,1004 @@
+/* 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 <cstdio>
+#include <iostream>
+#include <queue>
+
+#include "CSFLog.h"
+#include "nspr.h"
+
+#include "MediaCodec.h"
+#include "WebrtcMediaCodecVP8VideoCodec.h"
+#include "AndroidJNIWrapper.h"
+#include "mozilla/ArrayUtils.h"
+#include "nsThreadUtils.h"
+#include "mozilla/Monitor.h"
+#include "runnable_utils.h"
+
+#include "AudioConduit.h"
+#include "VideoConduit.h"
+#include "libyuv/convert_from.h"
+#include "libyuv/convert.h"
+#include "libyuv/row.h"
+
+#include <webrtc/common_video/libyuv/include/webrtc_libyuv.h>
+
+using namespace mozilla;
+using namespace mozilla::java::sdk;
+
+static const int32_t DECODER_TIMEOUT = 10 * PR_USEC_PER_MSEC; // 10ms
+static const char MEDIACODEC_VIDEO_MIME_VP8[] = "video/x-vnd.on2.vp8";
+
+namespace mozilla {
+
+static const char* logTag ="WebrtcMediaCodecVP8VideoCodec";
+
+static MediaCodec::LocalRef CreateDecoder(const char* aMimeType)
+{
+ if (!aMimeType) {
+ return nullptr;
+ }
+
+ MediaCodec::LocalRef codec;
+ MediaCodec::CreateDecoderByType(aMimeType, &codec);
+ return codec;
+}
+
+static MediaCodec::LocalRef CreateEncoder(const char* aMimeType)
+{
+ if (!aMimeType) {
+ return nullptr;
+ }
+
+ MediaCodec::LocalRef codec;
+ MediaCodec::CreateEncoderByType(aMimeType, &codec);
+ return codec;
+}
+
+static void
+ShutdownThread(nsCOMPtr<nsIThread>& aThread)
+{
+ aThread->Shutdown();
+}
+
+// Base runnable class to repeatly pull MediaCodec output buffers in seperate thread.
+// How to use:
+// - implementing DrainOutput() to get output. Remember to return false to tell
+// drain not to pop input queue.
+// - call QueueInput() to schedule a run to drain output. The input, aFrame,
+// should contains corresponding info such as image size and timestamps for
+// DrainOutput() implementation to construct data needed by encoded/decoded
+// callbacks.
+class MediaCodecOutputDrain : public Runnable
+{
+public:
+ void Start() {
+ MonitorAutoLock lock(mMonitor);
+ if (mThread == nullptr) {
+ NS_NewNamedThread("OutputDrain", getter_AddRefs(mThread));
+ }
+ mEnding = false;
+ mThread->Dispatch(this, NS_DISPATCH_NORMAL);
+ }
+
+ void Stop() {
+ MonitorAutoLock lock(mMonitor);
+ mEnding = true;
+ lock.NotifyAll(); // In case Run() is waiting.
+
+ if (mThread != nullptr) {
+ MonitorAutoUnlock unlock(mMonitor);
+ NS_DispatchToMainThread(
+ WrapRunnableNM<decltype(&ShutdownThread),
+ nsCOMPtr<nsIThread> >(&ShutdownThread, mThread));
+ mThread = nullptr;
+ }
+ }
+
+ void QueueInput(const EncodedFrame& aFrame)
+ {
+ MonitorAutoLock lock(mMonitor);
+
+ MOZ_ASSERT(mThread);
+
+ mInputFrames.push(aFrame);
+ // Notify Run() about queued input and it can start working.
+ lock.NotifyAll();
+ }
+
+ NS_IMETHOD Run() override
+ {
+ MOZ_ASSERT(mThread);
+
+ MonitorAutoLock lock(mMonitor);
+ while (true) {
+ if (mInputFrames.empty()) {
+ // Wait for new input.
+ lock.Wait();
+ }
+
+ if (mEnding) {
+ // Stop draining.
+ break;
+ }
+
+ MOZ_ASSERT(!mInputFrames.empty());
+ {
+ // Release monitor while draining because it's blocking.
+ MonitorAutoUnlock unlock(mMonitor);
+ DrainOutput();
+ }
+ }
+
+ return NS_OK;
+ }
+
+protected:
+ MediaCodecOutputDrain()
+ : mMonitor("MediaCodecOutputDrain monitor")
+ , mEnding(false)
+ {}
+
+ // Drain output buffer for input frame queue mInputFrames.
+ // mInputFrames contains info such as size and time of the input frames.
+ // We have to give a queue to handle encoder frame skips - we can input 10
+ // frames and get one back. NOTE: any access of aInputFrames MUST be preceded
+ // locking mMonitor!
+
+ // Blocks waiting for decoded buffers, but for a limited period because
+ // we need to check for shutdown.
+ virtual bool DrainOutput() = 0;
+
+protected:
+ // This monitor protects all things below it, and is also used to
+ // wait/notify queued input.
+ Monitor mMonitor;
+ std::queue<EncodedFrame> mInputFrames;
+
+private:
+ // also protected by mMonitor
+ nsCOMPtr<nsIThread> mThread;
+ bool mEnding;
+};
+
+class WebrtcAndroidMediaCodec {
+public:
+ WebrtcAndroidMediaCodec()
+ : mEncoderCallback(nullptr)
+ , mDecoderCallback(nullptr)
+ , isStarted(false)
+ , mEnding(false) {
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+ }
+
+ nsresult Configure(uint32_t width,
+ uint32_t height,
+ const jobject aSurface,
+ uint32_t flags,
+ const char* mime,
+ bool encoder) {
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+ nsresult res = NS_OK;
+
+ if (!mCoder) {
+ mWidth = width;
+ mHeight = height;
+
+ MediaFormat::LocalRef format;
+
+ res = MediaFormat::CreateVideoFormat(nsCString(mime),
+ mWidth,
+ mHeight,
+ &format);
+
+ if (NS_FAILED(res)) {
+ CSFLogDebug(logTag, "WebrtcAndroidMediaCodec::%s, CreateVideoFormat failed err = %d", __FUNCTION__, (int)res);
+ return NS_ERROR_FAILURE;
+ }
+
+ if (encoder) {
+ mCoder = CreateEncoder(mime);
+
+ if (NS_FAILED(res)) {
+ CSFLogDebug(logTag, "WebrtcAndroidMediaCodec::%s, CreateEncoderByType failed err = %d", __FUNCTION__, (int)res);
+ return NS_ERROR_FAILURE;
+ }
+
+ res = format->SetInteger(nsCString("bitrate"), 1000*300);
+ res = format->SetInteger(nsCString("bitrate-mode"), 2);
+ res = format->SetInteger(nsCString("color-format"), 21);
+ res = format->SetInteger(nsCString("frame-rate"), 30);
+ res = format->SetInteger(nsCString("i-frame-interval"), 100);
+
+ } else {
+ mCoder = CreateDecoder(mime);
+ if (NS_FAILED(res)) {
+ CSFLogDebug(logTag, "WebrtcAndroidMediaCodec::%s, CreateDecoderByType failed err = %d", __FUNCTION__, (int)res);
+ return NS_ERROR_FAILURE;
+ }
+ }
+ res = mCoder->Configure(format, nullptr, nullptr, flags);
+ if (NS_FAILED(res)) {
+ CSFLogDebug(logTag, "WebrtcAndroidMediaCodec::%s, err = %d", __FUNCTION__, (int)res);
+ }
+ }
+
+ return res;
+ }
+
+ nsresult Start() {
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+
+ if (!mCoder) {
+ return NS_ERROR_FAILURE;
+ }
+
+ mEnding = false;
+
+ nsresult res;
+ res = mCoder->Start();
+ if (NS_FAILED(res)) {
+ CSFLogDebug(logTag, "WebrtcAndroidMediaCodec::%s, mCoder->start() return err = %d",
+ __FUNCTION__, (int)res);
+ return res;
+ }
+ isStarted = true;
+ return NS_OK;
+ }
+
+ nsresult Stop() {
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+ mEnding = true;
+
+ if (mOutputDrain != nullptr) {
+ mOutputDrain->Stop();
+ mOutputDrain = nullptr;
+ }
+
+ mCoder->Stop();
+ mCoder->Release();
+ isStarted = false;
+ return NS_OK;
+ }
+
+ void GenerateVideoFrame(
+ size_t width, size_t height, uint32_t timeStamp,
+ void* decoded,
+ webrtc::I420VideoFrame* videoFrame, int color_format) {
+
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+
+ // TODO: eliminate extra pixel copy/color conversion
+ size_t widthUV = (width + 1) / 2;
+ if (videoFrame->CreateEmptyFrame(width, height, width, widthUV, widthUV)) {
+ return;
+ }
+
+ uint8_t* src_nv12 = static_cast<uint8_t *>(decoded);
+ int src_nv12_y_size = width * height;
+
+ uint8_t* dstY = videoFrame->buffer(webrtc::kYPlane);
+ uint8_t* dstU = videoFrame->buffer(webrtc::kUPlane);
+ uint8_t* dstV = videoFrame->buffer(webrtc::kVPlane);
+
+ libyuv::NV12ToI420(src_nv12, width,
+ src_nv12 + src_nv12_y_size, (width + 1) & ~1,
+ dstY, width,
+ dstU, (width + 1) / 2,
+ dstV,
+ (width + 1) / 2,
+ width, height);
+
+ videoFrame->set_timestamp(timeStamp);
+ }
+
+ int32_t
+ FeedMediaCodecInput(
+ const webrtc::EncodedImage& inputImage,
+ int64_t renderTimeMs) {
+
+#ifdef WEBRTC_MEDIACODEC_DEBUG
+ uint32_t time = PR_IntervalNow();
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+#endif
+
+ int inputIndex = DequeueInputBuffer(DECODER_TIMEOUT);
+ if (inputIndex == -1) {
+ CSFLogError(logTag, "%s equeue input buffer failed", __FUNCTION__);
+ return inputIndex;
+ }
+
+#ifdef WEBRTC_MEDIACODEC_DEBUG
+ CSFLogDebug(logTag, "%s dequeue input buffer took %u ms", __FUNCTION__, PR_IntervalToMilliseconds(PR_IntervalNow()-time));
+ time = PR_IntervalNow();
+#endif
+
+ size_t size = inputImage._length;
+
+ JNIEnv* env = jsjni_GetJNIForThread();
+ jobject buffer = env->GetObjectArrayElement(mInputBuffers, inputIndex);
+ void* directBuffer = env->GetDirectBufferAddress(buffer);
+
+ PodCopy((uint8_t*)directBuffer, inputImage._buffer, size);
+
+ if (inputIndex >= 0) {
+ CSFLogError(logTag, "%s queue input buffer inputIndex = %d", __FUNCTION__, inputIndex);
+ QueueInputBuffer(inputIndex, 0, size, renderTimeMs, 0);
+
+ {
+ if (mOutputDrain == nullptr) {
+ mOutputDrain = new OutputDrain(this);
+ mOutputDrain->Start();
+ }
+ EncodedFrame frame;
+ frame.width_ = mWidth;
+ frame.height_ = mHeight;
+ frame.timeStamp_ = inputImage._timeStamp;
+ frame.decode_timestamp_ = renderTimeMs;
+ mOutputDrain->QueueInput(frame);
+ }
+ env->DeleteLocalRef(buffer);
+ }
+
+ return inputIndex;
+ }
+
+ nsresult
+ DrainOutput(std::queue<EncodedFrame>& aInputFrames, Monitor& aMonitor) {
+ MOZ_ASSERT(mCoder != nullptr);
+ if (mCoder == nullptr) {
+ return NS_ERROR_FAILURE;
+ }
+
+#ifdef WEBRTC_MEDIACODEC_DEBUG
+ uint32_t time = PR_IntervalNow();
+#endif
+ nsresult res;
+ BufferInfo::LocalRef bufferInfo;
+ res = BufferInfo::New(&bufferInfo);
+ if (NS_FAILED(res)) {
+ CSFLogDebug(logTag, "WebrtcAndroidMediaCodec::%s, BufferInfo::New return err = %d",
+ __FUNCTION__, (int)res);
+ return res;
+ }
+ int32_t outputIndex = DequeueOutputBuffer(bufferInfo);
+
+ if (outputIndex == MediaCodec::INFO_TRY_AGAIN_LATER) {
+ // Not an error: output not available yet. Try later.
+ CSFLogDebug(logTag, "%s dequeue output buffer try again:%d", __FUNCTION__, outputIndex);
+ } else if (outputIndex == MediaCodec::INFO_OUTPUT_FORMAT_CHANGED) {
+ // handle format change
+ CSFLogDebug(logTag, "%s dequeue output buffer format changed:%d", __FUNCTION__, outputIndex);
+ } else if (outputIndex == MediaCodec::INFO_OUTPUT_BUFFERS_CHANGED) {
+ CSFLogDebug(logTag, "%s dequeue output buffer changed:%d", __FUNCTION__, outputIndex);
+ GetOutputBuffers();
+ } else if (outputIndex < 0) {
+ CSFLogDebug(logTag, "%s dequeue output buffer unknow error:%d", __FUNCTION__, outputIndex);
+ MonitorAutoLock lock(aMonitor);
+ aInputFrames.pop();
+ } else {
+#ifdef WEBRTC_MEDIACODEC_DEBUG
+ CSFLogDebug(logTag, "%s dequeue output buffer# return status is %d took %u ms", __FUNCTION__, outputIndex, PR_IntervalToMilliseconds(PR_IntervalNow()-time));
+#endif
+ EncodedFrame frame;
+ {
+ MonitorAutoLock lock(aMonitor);
+ frame = aInputFrames.front();
+ aInputFrames.pop();
+ }
+
+ if (mEnding) {
+ ReleaseOutputBuffer(outputIndex, false);
+ return NS_OK;
+ }
+
+ JNIEnv* env = jsjni_GetJNIForThread();
+ jobject buffer = env->GetObjectArrayElement(mOutputBuffers, outputIndex);
+ if (buffer) {
+ // The buffer will be null on Android L if we are decoding to a Surface
+ void* directBuffer = env->GetDirectBufferAddress(buffer);
+
+ int color_format = 0;
+
+ CSFLogDebug(logTag, "%s generate video frame, width = %d, height = %d, timeStamp_ = %d", __FUNCTION__, frame.width_, frame.height_, frame.timeStamp_);
+ GenerateVideoFrame(frame.width_, frame.height_, frame.timeStamp_, directBuffer, &mVideoFrame, color_format);
+ mDecoderCallback->Decoded(mVideoFrame);
+
+ ReleaseOutputBuffer(outputIndex, false);
+ env->DeleteLocalRef(buffer);
+ }
+ }
+ return NS_OK;
+ }
+
+ int32_t DequeueInputBuffer(int64_t time) {
+ nsresult res;
+ int32_t inputIndex;
+ res = mCoder->DequeueInputBuffer(time, &inputIndex);
+
+ if (NS_FAILED(res)) {
+ CSFLogDebug(logTag, "WebrtcAndroidMediaCodec::%s, mCoder->DequeueInputBuffer() return err = %d",
+ __FUNCTION__, (int)res);
+ return -1;
+ }
+ return inputIndex;
+ }
+
+ void QueueInputBuffer(int32_t inputIndex, int32_t offset, size_t size, int64_t renderTimes, int32_t flags) {
+ nsresult res = NS_OK;
+ res = mCoder->QueueInputBuffer(inputIndex, offset, size, renderTimes, flags);
+
+ if (NS_FAILED(res)) {
+ CSFLogDebug(logTag, "WebrtcAndroidMediaCodec::%s, mCoder->QueueInputBuffer() return err = %d",
+ __FUNCTION__, (int)res);
+ }
+ }
+
+ int32_t DequeueOutputBuffer(BufferInfo::Param aInfo) {
+ nsresult res;
+
+ int32_t outputStatus;
+ res = mCoder->DequeueOutputBuffer(aInfo, DECODER_TIMEOUT, &outputStatus);
+
+ if (NS_FAILED(res)) {
+ CSFLogDebug(logTag, "WebrtcAndroidMediaCodec::%s, mCoder->DequeueOutputBuffer() return err = %d",
+ __FUNCTION__, (int)res);
+ return -1;
+ }
+
+ return outputStatus;
+ }
+
+ void ReleaseOutputBuffer(int32_t index, bool flag) {
+ mCoder->ReleaseOutputBuffer(index, flag);
+ }
+
+ jobjectArray GetInputBuffers() {
+ JNIEnv* env = jsjni_GetJNIForThread();
+
+ if (mInputBuffers) {
+ env->DeleteGlobalRef(mInputBuffers);
+ }
+
+ nsresult res;
+ jni::ObjectArray::LocalRef inputBuffers;
+ res = mCoder->GetInputBuffers(&inputBuffers);
+ mInputBuffers = (jobjectArray) env->NewGlobalRef(inputBuffers.Get());
+ if (NS_FAILED(res)) {
+ CSFLogDebug(logTag, "WebrtcAndroidMediaCodec::%s, GetInputBuffers return err = %d",
+ __FUNCTION__, (int)res);
+ return nullptr;
+ }
+
+ return mInputBuffers;
+ }
+
+ jobjectArray GetOutputBuffers() {
+ JNIEnv* env = jsjni_GetJNIForThread();
+
+ if (mOutputBuffers) {
+ env->DeleteGlobalRef(mOutputBuffers);
+ }
+
+ nsresult res;
+ jni::ObjectArray::LocalRef outputBuffers;
+ res = mCoder->GetOutputBuffers(&outputBuffers);
+ mOutputBuffers = (jobjectArray) env->NewGlobalRef(outputBuffers.Get());
+ if (NS_FAILED(res)) {
+ CSFLogDebug(logTag, "WebrtcAndroidMediaCodec::%s, GetOutputBuffers return err = %d",
+ __FUNCTION__, (int)res);
+ return nullptr;
+ }
+
+ return mOutputBuffers;
+ }
+
+ void SetDecoderCallback(webrtc::DecodedImageCallback* aCallback) {
+ mDecoderCallback = aCallback;
+ }
+
+ void SetEncoderCallback(webrtc::EncodedImageCallback* aCallback) {
+ mEncoderCallback = aCallback;
+ }
+
+protected:
+ virtual ~WebrtcAndroidMediaCodec() {
+ }
+
+private:
+class OutputDrain : public MediaCodecOutputDrain
+ {
+ public:
+ OutputDrain(WebrtcAndroidMediaCodec* aMediaCodec)
+ : MediaCodecOutputDrain()
+ , mMediaCodec(aMediaCodec)
+ {}
+
+ protected:
+ virtual bool DrainOutput() override
+ {
+ return (mMediaCodec->DrainOutput(mInputFrames, mMonitor) == NS_OK);
+ }
+
+ private:
+ WebrtcAndroidMediaCodec* mMediaCodec;
+ };
+
+ friend class WebrtcMediaCodecVP8VideoEncoder;
+ friend class WebrtcMediaCodecVP8VideoDecoder;
+
+ MediaCodec::GlobalRef mCoder;
+ webrtc::EncodedImageCallback* mEncoderCallback;
+ webrtc::DecodedImageCallback* mDecoderCallback;
+ webrtc::I420VideoFrame mVideoFrame;
+
+ jobjectArray mInputBuffers;
+ jobjectArray mOutputBuffers;
+
+ RefPtr<OutputDrain> mOutputDrain;
+ uint32_t mWidth;
+ uint32_t mHeight;
+ bool isStarted;
+ bool mEnding;
+
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WebrtcAndroidMediaCodec)
+};
+
+static bool I420toNV12(uint8_t* dstY, uint16_t* dstUV, const webrtc::I420VideoFrame& inputImage) {
+ uint8_t* buffer = dstY;
+ uint8_t* dst_y = buffer;
+ int dst_stride_y = inputImage.stride(webrtc::kYPlane);
+ uint8_t* dst_uv = buffer + inputImage.stride(webrtc::kYPlane) *
+ inputImage.height();
+ int dst_stride_uv = inputImage.stride(webrtc::kUPlane) * 2;
+
+ // Why NV12? Because COLOR_FORMAT_YUV420_SEMIPLANAR. Most hardware is NV12-friendly.
+ bool converted = !libyuv::I420ToNV12(inputImage.buffer(webrtc::kYPlane),
+ inputImage.stride(webrtc::kYPlane),
+ inputImage.buffer(webrtc::kUPlane),
+ inputImage.stride(webrtc::kUPlane),
+ inputImage.buffer(webrtc::kVPlane),
+ inputImage.stride(webrtc::kVPlane),
+ dst_y,
+ dst_stride_y,
+ dst_uv,
+ dst_stride_uv,
+ inputImage.width(),
+ inputImage.height());
+ return converted;
+}
+
+// Encoder.
+WebrtcMediaCodecVP8VideoEncoder::WebrtcMediaCodecVP8VideoEncoder()
+ : mTimestamp(0)
+ , mCallback(nullptr)
+ , mMediaCodecEncoder(nullptr) {
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+
+ memset(&mEncodedImage, 0, sizeof(mEncodedImage));
+}
+
+bool WebrtcMediaCodecVP8VideoEncoder::ResetInputBuffers() {
+ mInputBuffers = mMediaCodecEncoder->GetInputBuffers();
+
+ if (!mInputBuffers)
+ return false;
+
+ return true;
+}
+
+bool WebrtcMediaCodecVP8VideoEncoder::ResetOutputBuffers() {
+ mOutputBuffers = mMediaCodecEncoder->GetOutputBuffers();
+
+ if (!mOutputBuffers)
+ return false;
+
+ return true;
+}
+
+int32_t
+WebrtcMediaCodecVP8VideoEncoder::VerifyAndAllocate(const uint32_t minimumSize)
+{
+ if(minimumSize > mEncodedImage._size)
+ {
+ // create buffer of sufficient size
+ uint8_t* newBuffer = new uint8_t[minimumSize];
+ if (newBuffer == nullptr) {
+ return -1;
+ }
+ if(mEncodedImage._buffer) {
+ // copy old data
+ memcpy(newBuffer, mEncodedImage._buffer, mEncodedImage._size);
+ delete [] mEncodedImage._buffer;
+ }
+ mEncodedImage._buffer = newBuffer;
+ mEncodedImage._size = minimumSize;
+ }
+ return 0;
+}
+
+int32_t WebrtcMediaCodecVP8VideoEncoder::InitEncode(
+ const webrtc::VideoCodec* codecSettings,
+ int32_t numberOfCores,
+ size_t maxPayloadSize) {
+ mMaxPayloadSize = maxPayloadSize;
+ CSFLogDebug(logTag, "%s, w = %d, h = %d", __FUNCTION__, codecSettings->width, codecSettings->height);
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t WebrtcMediaCodecVP8VideoEncoder::Encode(
+ const webrtc::I420VideoFrame& inputImage,
+ const webrtc::CodecSpecificInfo* codecSpecificInfo,
+ const std::vector<webrtc::VideoFrameType>* frame_types) {
+ CSFLogDebug(logTag, "%s, w = %d, h = %d", __FUNCTION__, inputImage.width(), inputImage.height());
+
+ if (!mMediaCodecEncoder) {
+ mMediaCodecEncoder = new WebrtcAndroidMediaCodec();
+ }
+
+ if (!mMediaCodecEncoder->isStarted) {
+ if (inputImage.width() == 0 || inputImage.height() == 0) {
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ } else {
+ mFrameWidth = inputImage.width();
+ mFrameHeight = inputImage.height();
+ }
+
+ mMediaCodecEncoder->SetEncoderCallback(mCallback);
+ nsresult res = mMediaCodecEncoder->Configure(mFrameWidth, mFrameHeight, nullptr, MediaCodec::CONFIGURE_FLAG_ENCODE, MEDIACODEC_VIDEO_MIME_VP8, true /* encoder */);
+
+ if (res != NS_OK) {
+ CSFLogDebug(logTag, "%s, encoder configure return err = %d",
+ __FUNCTION__, (int)res);
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ res = mMediaCodecEncoder->Start();
+
+ if (NS_FAILED(res)) {
+ mMediaCodecEncoder->isStarted = false;
+ CSFLogDebug(logTag, "%s start encoder. err = %d", __FUNCTION__, (int)res);
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ bool retBool = ResetInputBuffers();
+ if (!retBool) {
+ CSFLogDebug(logTag, "%s ResetInputBuffers failed.", __FUNCTION__);
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+ retBool = ResetOutputBuffers();
+ if (!retBool) {
+ CSFLogDebug(logTag, "%s ResetOutputBuffers failed.", __FUNCTION__);
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ mMediaCodecEncoder->isStarted = true;
+ }
+
+#ifdef WEBRTC_MEDIACODEC_DEBUG
+ uint32_t time = PR_IntervalNow();
+#endif
+
+ size_t sizeY = inputImage.allocated_size(webrtc::kYPlane);
+ size_t sizeUV = inputImage.allocated_size(webrtc::kUPlane);
+ size_t size = sizeY + 2 * sizeUV;
+
+ int inputIndex = mMediaCodecEncoder->DequeueInputBuffer(DECODER_TIMEOUT);
+ if (inputIndex == -1) {
+ CSFLogError(logTag, "%s dequeue input buffer failed", __FUNCTION__);
+ return inputIndex;
+ }
+
+#ifdef WEBRTC_MEDIACODEC_DEBUG
+ CSFLogDebug(logTag, "%s WebrtcMediaCodecVP8VideoEncoder::Encode() dequeue OMX input buffer took %u ms", __FUNCTION__, PR_IntervalToMilliseconds(PR_IntervalNow()-time));
+#endif
+
+ if (inputIndex >= 0) {
+ JNIEnv* env = jsjni_GetJNIForThread();
+ jobject buffer = env->GetObjectArrayElement(mInputBuffers, inputIndex);
+ void* directBuffer = env->GetDirectBufferAddress(buffer);
+
+ uint8_t* dstY = static_cast<uint8_t*>(directBuffer);
+ uint16_t* dstUV = reinterpret_cast<uint16_t*>(dstY + sizeY);
+
+ bool converted = I420toNV12(dstY, dstUV, inputImage);
+ if (!converted) {
+ CSFLogError(logTag, "%s WebrtcMediaCodecVP8VideoEncoder::Encode() convert input buffer to NV12 error.", __FUNCTION__);
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ env->DeleteLocalRef(buffer);
+
+#ifdef WEBRTC_MEDIACODEC_DEBUG
+ time = PR_IntervalNow();
+ CSFLogError(logTag, "%s queue input buffer inputIndex = %d", __FUNCTION__, inputIndex);
+#endif
+
+ mMediaCodecEncoder->QueueInputBuffer(inputIndex, 0, size, inputImage.render_time_ms() * PR_USEC_PER_MSEC /* ms to us */, 0);
+#ifdef WEBRTC_MEDIACODEC_DEBUG
+ CSFLogDebug(logTag, "%s WebrtcMediaCodecVP8VideoEncoder::Encode() queue input buffer took %u ms", __FUNCTION__, PR_IntervalToMilliseconds(PR_IntervalNow()-time));
+#endif
+ mEncodedImage._encodedWidth = inputImage.width();
+ mEncodedImage._encodedHeight = inputImage.height();
+ mEncodedImage._timeStamp = inputImage.timestamp();
+ mEncodedImage.capture_time_ms_ = inputImage.timestamp();
+
+ nsresult res;
+ BufferInfo::LocalRef bufferInfo;
+ res = BufferInfo::New(&bufferInfo);
+ if (NS_FAILED(res)) {
+ CSFLogDebug(logTag, "WebrtcMediaCodecVP8VideoEncoder::%s, BufferInfo::New return err = %d",
+ __FUNCTION__, (int)res);
+ return -1;
+ }
+
+ int32_t outputIndex = mMediaCodecEncoder->DequeueOutputBuffer(bufferInfo);
+
+ if (outputIndex == MediaCodec::INFO_TRY_AGAIN_LATER) {
+ // Not an error: output not available yet. Try later.
+ CSFLogDebug(logTag, "%s dequeue output buffer try again:%d", __FUNCTION__, outputIndex);
+ } else if (outputIndex == MediaCodec::INFO_OUTPUT_FORMAT_CHANGED) {
+ // handle format change
+ CSFLogDebug(logTag, "%s dequeue output buffer format changed:%d", __FUNCTION__, outputIndex);
+ } else if (outputIndex == MediaCodec::INFO_OUTPUT_BUFFERS_CHANGED) {
+ CSFLogDebug(logTag, "%s dequeue output buffer changed:%d", __FUNCTION__, outputIndex);
+ mMediaCodecEncoder->GetOutputBuffers();
+ } else if (outputIndex < 0) {
+ CSFLogDebug(logTag, "%s dequeue output buffer unknow error:%d", __FUNCTION__, outputIndex);
+ } else {
+#ifdef WEBRTC_MEDIACODEC_DEBUG
+ CSFLogDebug(logTag, "%s dequeue output buffer return status is %d took %u ms", __FUNCTION__, outputIndex, PR_IntervalToMilliseconds(PR_IntervalNow()-time));
+#endif
+
+ JNIEnv* env = jsjni_GetJNIForThread();
+ jobject buffer = env->GetObjectArrayElement(mOutputBuffers, outputIndex);
+ if (buffer) {
+ int32_t offset;
+ bufferInfo->Offset(&offset);
+ int32_t flags;
+ bufferInfo->Flags(&flags);
+
+ // The buffer will be null on Android L if we are decoding to a Surface
+ void* directBuffer = reinterpret_cast<uint8_t*>(env->GetDirectBufferAddress(buffer)) + offset;
+
+ if (flags == MediaCodec::BUFFER_FLAG_SYNC_FRAME) {
+ mEncodedImage._frameType = webrtc::kKeyFrame;
+ } else {
+ mEncodedImage._frameType = webrtc::kDeltaFrame;
+ }
+ mEncodedImage._completeFrame = true;
+
+ int32_t size;
+ bufferInfo->Size(&size);
+#ifdef WEBRTC_MEDIACODEC_DEBUG
+ CSFLogDebug(logTag, "%s dequeue output buffer ok, index:%d, buffer size = %d, buffer offset = %d, flags = %d", __FUNCTION__, outputIndex, size, offset, flags);
+#endif
+
+ if(VerifyAndAllocate(size) == -1) {
+ CSFLogDebug(logTag, "%s VerifyAndAllocate buffers failed", __FUNCTION__);
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ mEncodedImage._length = size;
+
+ // xxx It's too bad the mediacodec API forces us to memcpy this....
+ // we should find a way that able to 'hold' the buffer or transfer it from inputImage (ping-pong
+ // buffers or select them from a small pool)
+ memcpy(mEncodedImage._buffer, directBuffer, mEncodedImage._length);
+
+ webrtc::CodecSpecificInfo info;
+ info.codecType = webrtc::kVideoCodecVP8;
+ info.codecSpecific.VP8.pictureId = -1;
+ info.codecSpecific.VP8.tl0PicIdx = -1;
+ info.codecSpecific.VP8.keyIdx = -1;
+ info.codecSpecific.VP8.temporalIdx = 1;
+
+ // Generate a header describing a single fragment.
+ webrtc::RTPFragmentationHeader header;
+ memset(&header, 0, sizeof(header));
+ header.VerifyAndAllocateFragmentationHeader(1);
+ header.fragmentationLength[0] = mEncodedImage._length;
+
+ mCallback->Encoded(mEncodedImage, &info, &header);
+
+ mMediaCodecEncoder->ReleaseOutputBuffer(outputIndex, false);
+ env->DeleteLocalRef(buffer);
+ }
+ }
+ }
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t WebrtcMediaCodecVP8VideoEncoder::RegisterEncodeCompleteCallback(webrtc::EncodedImageCallback* callback) {
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+ mCallback = callback;
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t WebrtcMediaCodecVP8VideoEncoder::Release() {
+
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+ delete mMediaCodecEncoder;
+ mMediaCodecEncoder = nullptr;
+
+ delete [] mEncodedImage._buffer;
+ mEncodedImage._buffer = nullptr;
+ mEncodedImage._size = 0;
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+WebrtcMediaCodecVP8VideoEncoder::~WebrtcMediaCodecVP8VideoEncoder() {
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+ Release();
+}
+
+int32_t WebrtcMediaCodecVP8VideoEncoder::SetChannelParameters(uint32_t packetLoss, int64_t rtt) {
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t WebrtcMediaCodecVP8VideoEncoder::SetRates(uint32_t newBitRate, uint32_t frameRate) {
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+ if (!mMediaCodecEncoder) {
+ return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
+ }
+
+ // XXX
+ // 1. implement MediaCodec's setParameters method
+ // 2.find a way to initiate a Java Bundle instance as parameter for MediaCodec setParameters method.
+ // mMediaCodecEncoder->setParameters
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+// Decoder.
+WebrtcMediaCodecVP8VideoDecoder::WebrtcMediaCodecVP8VideoDecoder()
+ : mCallback(nullptr)
+ , mFrameWidth(0)
+ , mFrameHeight(0)
+ , mMediaCodecDecoder(nullptr) {
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+}
+
+bool WebrtcMediaCodecVP8VideoDecoder::ResetInputBuffers() {
+ mInputBuffers = mMediaCodecDecoder->GetInputBuffers();
+
+ if (!mInputBuffers)
+ return false;
+
+ return true;
+}
+
+bool WebrtcMediaCodecVP8VideoDecoder::ResetOutputBuffers() {
+ mOutputBuffers = mMediaCodecDecoder->GetOutputBuffers();
+
+ if (!mOutputBuffers)
+ return false;
+
+ return true;
+}
+
+
+int32_t WebrtcMediaCodecVP8VideoDecoder::InitDecode(
+ const webrtc::VideoCodec* codecSettings,
+ int32_t numberOfCores) {
+
+ if (!mMediaCodecDecoder) {
+ mMediaCodecDecoder = new WebrtcAndroidMediaCodec();
+ }
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t WebrtcMediaCodecVP8VideoDecoder::Decode(
+ const webrtc::EncodedImage& inputImage,
+ bool missingFrames,
+ const webrtc::RTPFragmentationHeader* fragmentation,
+ const webrtc::CodecSpecificInfo* codecSpecificInfo,
+ int64_t renderTimeMs) {
+
+ CSFLogDebug(logTag, "%s, renderTimeMs = %lld ", __FUNCTION__, renderTimeMs);
+
+ if (inputImage._length== 0 || !inputImage._buffer) {
+ CSFLogDebug(logTag, "%s, input Image invalid. length = %d", __FUNCTION__, inputImage._length);
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ if (inputImage._frameType == webrtc::kKeyFrame) {
+ CSFLogDebug(logTag, "%s, inputImage is Golden frame",
+ __FUNCTION__);
+ mFrameWidth = inputImage._encodedWidth;
+ mFrameHeight = inputImage._encodedHeight;
+ }
+
+ if (!mMediaCodecDecoder->isStarted) {
+ if (mFrameWidth == 0 || mFrameHeight == 0) {
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ mMediaCodecDecoder->SetDecoderCallback(mCallback);
+ nsresult res = mMediaCodecDecoder->Configure(mFrameWidth, mFrameHeight, nullptr, 0, MEDIACODEC_VIDEO_MIME_VP8, false /* decoder */);
+
+ if (res != NS_OK) {
+ CSFLogDebug(logTag, "%s, decoder configure return err = %d",
+ __FUNCTION__, (int)res);
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ res = mMediaCodecDecoder->Start();
+
+ if (NS_FAILED(res)) {
+ mMediaCodecDecoder->isStarted = false;
+ CSFLogDebug(logTag, "%s start decoder. err = %d", __FUNCTION__, (int)res);
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ bool retBool = ResetInputBuffers();
+ if (!retBool) {
+ CSFLogDebug(logTag, "%s ResetInputBuffers failed.", __FUNCTION__);
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+ retBool = ResetOutputBuffers();
+ if (!retBool) {
+ CSFLogDebug(logTag, "%s ResetOutputBuffers failed.", __FUNCTION__);
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ mMediaCodecDecoder->isStarted = true;
+ }
+#ifdef WEBRTC_MEDIACODEC_DEBUG
+ uint32_t time = PR_IntervalNow();
+ CSFLogDebug(logTag, "%s start decoder took %u ms", __FUNCTION__, PR_IntervalToMilliseconds(PR_IntervalNow()-time));
+#endif
+
+ bool feedFrame = true;
+ int32_t ret = WEBRTC_VIDEO_CODEC_ERROR;
+
+ while (feedFrame) {
+ ret = mMediaCodecDecoder->FeedMediaCodecInput(inputImage, renderTimeMs);
+ feedFrame = (ret == -1);
+ }
+
+ CSFLogDebug(logTag, "%s end, ret = %d", __FUNCTION__, ret);
+
+ return ret;
+}
+
+void WebrtcMediaCodecVP8VideoDecoder::DecodeFrame(EncodedFrame* frame) {
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+}
+
+int32_t WebrtcMediaCodecVP8VideoDecoder::RegisterDecodeCompleteCallback(webrtc::DecodedImageCallback* callback) {
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+
+ mCallback = callback;
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t WebrtcMediaCodecVP8VideoDecoder::Release() {
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+
+ delete mMediaCodecDecoder;
+ mMediaCodecDecoder = nullptr;
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+WebrtcMediaCodecVP8VideoDecoder::~WebrtcMediaCodecVP8VideoDecoder() {
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+
+ Release();
+}
+
+int32_t WebrtcMediaCodecVP8VideoDecoder::Reset() {
+ CSFLogDebug(logTag, "%s ", __FUNCTION__);
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+}
diff --git a/media/webrtc/signaling/src/media-conduit/WebrtcMediaCodecVP8VideoCodec.h b/media/webrtc/signaling/src/media-conduit/WebrtcMediaCodecVP8VideoCodec.h
new file mode 100644
index 000000000..9d7e900fe
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/WebrtcMediaCodecVP8VideoCodec.h
@@ -0,0 +1,114 @@
+/* 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/. */
+
+#ifndef WebrtcMediaCodecVP8VideoCodec_h__
+#define WebrtcMediaCodecVP8VideoCodec_h__
+
+#include "mozilla/Mutex.h"
+#include "nsThreadUtils.h"
+#include "nsAutoPtr.h"
+
+#include "MediaConduitInterface.h"
+#include "AudioConduit.h"
+#include "VideoConduit.h"
+
+namespace mozilla {
+
+struct EncodedFrame {
+ uint32_t width_;
+ uint32_t height_;
+ uint32_t timeStamp_;
+ uint64_t decode_timestamp_;
+};
+
+class WebrtcAndroidMediaCodec;
+
+class WebrtcMediaCodecVP8VideoEncoder : public WebrtcVideoEncoder {
+public:
+ WebrtcMediaCodecVP8VideoEncoder();
+
+ virtual ~WebrtcMediaCodecVP8VideoEncoder() override;
+
+ // Implement VideoEncoder interface.
+ virtual uint64_t PluginID() const override { return 0; }
+
+ virtual int32_t InitEncode(const webrtc::VideoCodec* codecSettings,
+ int32_t numberOfCores,
+ size_t maxPayloadSize) override;
+
+ virtual int32_t Encode(const webrtc::I420VideoFrame& inputImage,
+ const webrtc::CodecSpecificInfo* codecSpecificInfo,
+ const std::vector<webrtc::VideoFrameType>* frame_types) override;
+
+ virtual int32_t RegisterEncodeCompleteCallback(webrtc::EncodedImageCallback* callback) override;
+
+ virtual int32_t Release() override;
+
+ virtual int32_t SetChannelParameters(uint32_t packetLoss, int64_t rtt) override;
+
+ virtual int32_t SetRates(uint32_t newBitRate, uint32_t frameRate) override;
+
+private:
+ int32_t VerifyAndAllocate(const uint32_t minimumSize);
+ bool ResetInputBuffers();
+ bool ResetOutputBuffers();
+
+ size_t mMaxPayloadSize;
+ uint32_t mTimestamp;
+ webrtc::EncodedImage mEncodedImage;
+ webrtc::EncodedImageCallback* mCallback;
+ uint32_t mFrameWidth;
+ uint32_t mFrameHeight;
+
+ WebrtcAndroidMediaCodec* mMediaCodecEncoder;
+
+ jobjectArray mInputBuffers;
+ jobjectArray mOutputBuffers;
+};
+
+class WebrtcMediaCodecVP8VideoDecoder : public WebrtcVideoDecoder {
+public:
+ WebrtcMediaCodecVP8VideoDecoder();
+
+ virtual ~WebrtcMediaCodecVP8VideoDecoder() override;
+
+ // Implement VideoDecoder interface.
+ virtual uint64_t PluginID() const override { return 0; }
+
+ virtual int32_t InitDecode(const webrtc::VideoCodec* codecSettings,
+ int32_t numberOfCores) override;
+
+ virtual int32_t Decode(const webrtc::EncodedImage& inputImage,
+ bool missingFrames,
+ const webrtc::RTPFragmentationHeader* fragmentation,
+ const webrtc::CodecSpecificInfo*
+ codecSpecificInfo = NULL,
+ int64_t renderTimeMs = -1) override;
+
+ virtual int32_t RegisterDecodeCompleteCallback(webrtc::DecodedImageCallback* callback) override;
+
+ virtual int32_t Release() override;
+
+ virtual int32_t Reset() override;
+
+private:
+ void DecodeFrame(EncodedFrame* frame);
+ void RunCallback();
+ bool ResetInputBuffers();
+ bool ResetOutputBuffers();
+
+ webrtc::DecodedImageCallback* mCallback;
+
+ uint32_t mFrameWidth;
+ uint32_t mFrameHeight;
+
+ WebrtcAndroidMediaCodec* mMediaCodecDecoder;
+ jobjectArray mInputBuffers;
+ jobjectArray mOutputBuffers;
+
+};
+
+}
+
+#endif // WebrtcMediaCodecVP8VideoCodec_h__
diff --git a/media/webrtc/signaling/src/media-conduit/WebrtcOMXH264VideoCodec.cpp b/media/webrtc/signaling/src/media-conduit/WebrtcOMXH264VideoCodec.cpp
new file mode 100644
index 000000000..dc052f4e0
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/WebrtcOMXH264VideoCodec.cpp
@@ -0,0 +1,1253 @@
+/* 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 "CSFLog.h"
+
+#include "WebrtcOMXH264VideoCodec.h"
+
+// Android/Stagefright
+#include <avc_utils.h>
+#include <binder/ProcessState.h>
+#include <foundation/ABuffer.h>
+#include <foundation/AMessage.h>
+#include <gui/Surface.h>
+#include <media/ICrypto.h>
+#include <media/stagefright/MediaCodec.h>
+#include <media/stagefright/MediaDefs.h>
+#include <media/stagefright/MediaErrors.h>
+#include <media/stagefright/MetaData.h>
+#include <OMX_Component.h>
+using namespace android;
+
+// WebRTC
+//#include "webrtc/common_video/interface/texture_video_frame.h"
+#include "webrtc/video_engine/include/vie_external_codec.h"
+#include "runnable_utils.h"
+
+// Gecko
+#if defined(MOZ_WIDGET_GONK) && ANDROID_VERSION >= 21
+#include "GonkBufferQueueProducer.h"
+#endif
+#include "GonkNativeWindow.h"
+#include "GrallocImages.h"
+#include "mozilla/Atomics.h"
+#include "mozilla/Mutex.h"
+#include "nsThreadUtils.h"
+#include "OMXCodecWrapper.h"
+#include "TextureClient.h"
+#include "mozilla/IntegerPrintfMacros.h"
+
+#define DEQUEUE_BUFFER_TIMEOUT_US (100 * 1000ll) // 100ms.
+#define START_DEQUEUE_BUFFER_TIMEOUT_US (10 * DEQUEUE_BUFFER_TIMEOUT_US) // 1s.
+#define DRAIN_THREAD_TIMEOUT_US (1000 * 1000ll) // 1s.
+
+#define WOHVC_LOG_TAG "WebrtcOMXH264VideoCodec"
+#define CODEC_LOGV(...) CSFLogInfo(WOHVC_LOG_TAG, __VA_ARGS__)
+#define CODEC_LOGD(...) CSFLogDebug(WOHVC_LOG_TAG, __VA_ARGS__)
+#define CODEC_LOGI(...) CSFLogInfo(WOHVC_LOG_TAG, __VA_ARGS__)
+#define CODEC_LOGW(...) CSFLogWarn(WOHVC_LOG_TAG, __VA_ARGS__)
+#define CODEC_LOGE(...) CSFLogError(WOHVC_LOG_TAG, __VA_ARGS__)
+
+namespace mozilla {
+
+static const uint8_t kNALStartCode[] = { 0x00, 0x00, 0x00, 0x01 };
+enum {
+ kNALTypeIDR = 5,
+ kNALTypeSPS = 7,
+ kNALTypePPS = 8,
+};
+
+// NS_INLINE_DECL_THREADSAFE_REFCOUNTING() cannot be used directly in
+// ImageNativeHandle below because the return type of webrtc::NativeHandle
+// AddRef()/Release() conflicts with those defined in macro. To avoid another
+// copy/paste of ref-counting implementation here, this dummy base class
+// is created to proivde another level of indirection.
+class DummyRefCountBase {
+public:
+ // Use the name of real class for logging.
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(DummyRefCountBase)
+protected:
+ // To make sure subclass will be deleted/destructed properly.
+ virtual ~DummyRefCountBase() {}
+};
+
+// This function implements 2 interafces:
+// 1. webrtc::NativeHandle: to wrap layers::Image object so decoded frames can
+// be passed through WebRTC rendering pipeline using TextureVideoFrame.
+// 2. ImageHandle: for renderer to get the image object inside without knowledge
+// about webrtc::NativeHandle.
+class ImageNativeHandle final
+ : public webrtc::NativeHandle
+ , public DummyRefCountBase
+{
+public:
+ ImageNativeHandle(layers::Image* aImage)
+ : mImage(aImage)
+ {}
+
+ // Implement webrtc::NativeHandle.
+ virtual void* GetHandle() override { return mImage.get(); }
+
+ virtual int AddRef() override
+ {
+ return DummyRefCountBase::AddRef();
+ }
+
+ virtual int Release() override
+ {
+ return DummyRefCountBase::Release();
+ }
+
+private:
+ RefPtr<layers::Image> mImage;
+};
+
+struct EncodedFrame
+{
+ uint32_t mWidth;
+ uint32_t mHeight;
+ uint32_t mTimestamp;
+ int64_t mRenderTimeMs;
+};
+
+static void
+ShutdownThread(nsCOMPtr<nsIThread>& aThread)
+{
+ aThread->Shutdown();
+}
+
+// Base runnable class to repeatly pull OMX output buffers in seperate thread.
+// How to use:
+// - implementing DrainOutput() to get output. Remember to return false to tell
+// drain not to pop input queue.
+// - call QueueInput() to schedule a run to drain output. The input, aFrame,
+// should contains corresponding info such as image size and timestamps for
+// DrainOutput() implementation to construct data needed by encoded/decoded
+// callbacks.
+// TODO: Bug 997110 - Revisit queue/drain logic. Current design assumes that
+// encoder only generate one output buffer per input frame and won't work
+// if encoder drops frames or generates multiple output per input.
+class OMXOutputDrain : public Runnable
+{
+public:
+ void Start() {
+ CODEC_LOGD("OMXOutputDrain starting");
+ MonitorAutoLock lock(mMonitor);
+ if (mThread == nullptr) {
+ NS_NewNamedThread("OMXOutputDrain", getter_AddRefs(mThread));
+ }
+ CODEC_LOGD("OMXOutputDrain started");
+ mEnding = false;
+ mThread->Dispatch(this, NS_DISPATCH_NORMAL);
+ }
+
+ void Stop() {
+ CODEC_LOGD("OMXOutputDrain stopping");
+ MonitorAutoLock lock(mMonitor);
+ mEnding = true;
+ lock.NotifyAll(); // In case Run() is waiting.
+
+ if (mThread != nullptr) {
+ MonitorAutoUnlock unlock(mMonitor);
+ CODEC_LOGD("OMXOutputDrain thread shutdown");
+ NS_DispatchToMainThread(
+ WrapRunnableNM<decltype(&ShutdownThread),
+ nsCOMPtr<nsIThread> >(&ShutdownThread, mThread));
+ mThread = nullptr;
+ }
+ CODEC_LOGD("OMXOutputDrain stopped");
+ }
+
+ void QueueInput(const EncodedFrame& aFrame)
+ {
+ MonitorAutoLock lock(mMonitor);
+
+ MOZ_ASSERT(mThread);
+
+ mInputFrames.push(aFrame);
+ // Notify Run() about queued input and it can start working.
+ lock.NotifyAll();
+ }
+
+ NS_IMETHOD Run() override
+ {
+ MonitorAutoLock lock(mMonitor);
+ if (mEnding) {
+ return NS_OK;
+ }
+ MOZ_ASSERT(mThread);
+
+ while (true) {
+ if (mInputFrames.empty()) {
+ // Wait for new input.
+ lock.Wait();
+ }
+
+ if (mEnding) {
+ CODEC_LOGD("OMXOutputDrain Run() ending");
+ // Stop draining.
+ break;
+ }
+
+ MOZ_ASSERT(!mInputFrames.empty());
+ {
+ // Release monitor while draining because it's blocking.
+ MonitorAutoUnlock unlock(mMonitor);
+ DrainOutput();
+ }
+ }
+
+ CODEC_LOGD("OMXOutputDrain Ended");
+ return NS_OK;
+ }
+
+protected:
+ OMXOutputDrain()
+ : mMonitor("OMXOutputDrain monitor")
+ , mEnding(false)
+ {}
+
+ // Drain output buffer for input frame queue mInputFrames.
+ // mInputFrames contains info such as size and time of the input frames.
+ // We have to give a queue to handle encoder frame skips - we can input 10
+ // frames and get one back. NOTE: any access of aInputFrames MUST be preceded
+ // locking mMonitor!
+
+ // Blocks waiting for decoded buffers, but for a limited period because
+ // we need to check for shutdown.
+ virtual bool DrainOutput() = 0;
+
+protected:
+ // This monitor protects all things below it, and is also used to
+ // wait/notify queued input.
+ Monitor mMonitor;
+ std::queue<EncodedFrame> mInputFrames;
+
+private:
+ // also protected by mMonitor
+ nsCOMPtr<nsIThread> mThread;
+ bool mEnding;
+};
+
+// Assumption: SPS is first paramset or is not present
+static bool IsParamSets(uint8_t* aData, size_t aSize)
+{
+ MOZ_ASSERT(aData && aSize > sizeof(kNALStartCode));
+ return (aData[sizeof(kNALStartCode)] & 0x1f) == kNALTypeSPS;
+}
+
+// get the length of any pre-pended SPS/PPS's
+static size_t ParamSetLength(uint8_t* aData, size_t aSize)
+{
+ const uint8_t* data = aData;
+ size_t size = aSize;
+ const uint8_t* nalStart = nullptr;
+ size_t nalSize = 0;
+ while (getNextNALUnit(&data, &size, &nalStart, &nalSize, true) == OK) {
+ if ((*nalStart & 0x1f) != kNALTypeSPS &&
+ (*nalStart & 0x1f) != kNALTypePPS) {
+ MOZ_ASSERT(nalStart - sizeof(kNALStartCode) >= aData);
+ return (nalStart - sizeof(kNALStartCode)) - aData; // SPS/PPS/iframe
+ }
+ }
+ return aSize; // it's only SPS/PPS
+}
+
+// H.264 decoder using stagefright.
+// It implements gonk native window callback to receive buffers from
+// MediaCodec::RenderOutputBufferAndRelease().
+class WebrtcOMXDecoder final : public GonkNativeWindowNewFrameCallback
+{
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WebrtcOMXDecoder)
+
+private:
+ virtual ~WebrtcOMXDecoder()
+ {
+ CODEC_LOGD("WebrtcOMXH264VideoDecoder:%p OMX destructor", this);
+ if (mStarted) {
+ Stop();
+ }
+ if (mCodec != nullptr) {
+ mCodec->release();
+ mCodec.clear();
+ }
+ mLooper.clear();
+ }
+
+public:
+ WebrtcOMXDecoder(const char* aMimeType,
+ webrtc::DecodedImageCallback* aCallback)
+ : mWidth(0)
+ , mHeight(0)
+ , mStarted(false)
+ , mCallback(aCallback)
+ , mDecodedFrameLock("WebRTC decoded frame lock")
+ , mEnding(false)
+ {
+ // Create binder thread pool required by stagefright.
+ android::ProcessState::self()->startThreadPool();
+
+ mLooper = new ALooper;
+ mLooper->start();
+ CODEC_LOGD("WebrtcOMXH264VideoDecoder:%p creating decoder", this);
+ mCodec = MediaCodec::CreateByType(mLooper, aMimeType, false /* encoder */);
+ CODEC_LOGD("WebrtcOMXH264VideoDecoder:%p OMX created", this);
+ }
+
+ // Find SPS in input data and extract picture width and height if found.
+ static status_t ExtractPicDimensions(uint8_t* aData, size_t aSize,
+ int32_t* aWidth, int32_t* aHeight)
+ {
+ MOZ_ASSERT(aData && aSize > sizeof(kNALStartCode));
+ if ((aData[sizeof(kNALStartCode)] & 0x1f) != kNALTypeSPS) {
+ return ERROR_MALFORMED;
+ }
+ sp<ABuffer> sps = new ABuffer(&aData[sizeof(kNALStartCode)], aSize - sizeof(kNALStartCode));
+ FindAVCDimensions(sps, aWidth, aHeight);
+ return OK;
+ }
+
+ // Configure decoder using image width/height.
+ status_t ConfigureWithPicDimensions(int32_t aWidth, int32_t aHeight)
+ {
+ MOZ_ASSERT(mCodec != nullptr);
+ if (mCodec == nullptr) {
+ return INVALID_OPERATION;
+ }
+
+ CODEC_LOGD("OMX:%p decoder width:%d height:%d", this, aWidth, aHeight);
+
+ sp<AMessage> config = new AMessage();
+ config->setString("mime", MEDIA_MIMETYPE_VIDEO_AVC);
+ config->setInt32("width", aWidth);
+ config->setInt32("height", aHeight);
+ mWidth = aWidth;
+ mHeight = aHeight;
+
+ sp<Surface> surface = nullptr;
+#if defined(MOZ_WIDGET_GONK) && ANDROID_VERSION >= 21
+ sp<IGraphicBufferProducer> producer;
+ sp<IGonkGraphicBufferConsumer> consumer;
+ GonkBufferQueue::createBufferQueue(&producer, &consumer);
+ mNativeWindow = new GonkNativeWindow(consumer);
+#else
+ mNativeWindow = new GonkNativeWindow();
+#endif
+ if (mNativeWindow.get()) {
+ // listen to buffers queued by MediaCodec::RenderOutputBufferAndRelease().
+ mNativeWindow->setNewFrameCallback(this);
+ // XXX remove buffer changes after a better solution lands - bug 1009420
+#if defined(MOZ_WIDGET_GONK) && ANDROID_VERSION >= 21
+ static_cast<GonkBufferQueueProducer*>(producer.get())->setSynchronousMode(false);
+ // More spare buffers to avoid OMX decoder waiting for native window
+ consumer->setMaxAcquiredBufferCount(WEBRTC_OMX_H264_MIN_DECODE_BUFFERS);
+ surface = new Surface(producer);
+#else
+ sp<GonkBufferQueue> bq = mNativeWindow->getBufferQueue();
+ bq->setSynchronousMode(false);
+ // More spare buffers to avoid OMX decoder waiting for native window
+ bq->setMaxAcquiredBufferCount(WEBRTC_OMX_H264_MIN_DECODE_BUFFERS);
+ surface = new Surface(bq);
+#endif
+ }
+ status_t result = mCodec->configure(config, surface, nullptr, 0);
+ if (result == OK) {
+ CODEC_LOGD("OMX:%p decoder configured", this);
+ result = Start();
+ }
+ return result;
+ }
+
+ status_t
+ FillInput(const webrtc::EncodedImage& aEncoded, bool aIsFirstFrame,
+ int64_t& aRenderTimeMs)
+ {
+ MOZ_ASSERT(mCodec != nullptr && aEncoded._buffer && aEncoded._length > 0);
+ if (mCodec == nullptr || !aEncoded._buffer || aEncoded._length == 0) {
+ return INVALID_OPERATION;
+ }
+
+ // Break input encoded data into NALUs and send each one to decode.
+ // 8x10 decoder doesn't allow picture coding NALs to be in the same buffer
+ // with SPS/PPS (BUFFER_FLAG_CODECCONFIG) per QC
+ const uint8_t* data = aEncoded._buffer;
+ size_t size = aEncoded._length;
+ const uint8_t* nalStart = nullptr;
+ size_t nalSize = 0;
+ status_t err = OK;
+
+ // this returns a pointer to the NAL byte (after the StartCode)
+ while (getNextNALUnit(&data, &size, &nalStart, &nalSize, true) == OK) {
+ // Individual NALU inherits metadata from input encoded data.
+ webrtc::EncodedImage nalu(aEncoded);
+
+ nalu._buffer = const_cast<uint8_t*>(nalStart) - sizeof(kNALStartCode);
+ MOZ_ASSERT(nalu._buffer >= aEncoded._buffer);
+ nalu._length = nalSize + sizeof(kNALStartCode);
+ MOZ_ASSERT(nalu._buffer + nalu._length <= aEncoded._buffer + aEncoded._length);
+
+ size_t index;
+ err = mCodec->dequeueInputBuffer(&index,
+ aIsFirstFrame ? START_DEQUEUE_BUFFER_TIMEOUT_US : DEQUEUE_BUFFER_TIMEOUT_US);
+ if (err != OK) {
+ if (err != -EAGAIN) {
+ CODEC_LOGE("decode dequeue input buffer error:%d", err);
+ } else {
+ CODEC_LOGE("decode dequeue 100ms without a buffer (EAGAIN)");
+ }
+ return err;
+ }
+
+ // Prepend start code to buffer.
+ MOZ_ASSERT(memcmp(nalu._buffer, kNALStartCode, sizeof(kNALStartCode)) == 0);
+ const sp<ABuffer>& omxIn = mInputBuffers.itemAt(index);
+ MOZ_ASSERT(omxIn->capacity() >= nalu._length);
+ omxIn->setRange(0, nalu._length);
+ // Copying is needed because MediaCodec API doesn't support externally
+ // allocated buffer as input.
+ uint8_t* dst = omxIn->data();
+ memcpy(dst, nalu._buffer, nalu._length);
+ int64_t inputTimeUs = (nalu._timeStamp * 1000ll) / 90; // 90kHz -> us.
+ // Assign input flags according to input buffer NALU and frame types.
+ uint32_t flags;
+ int nalType = dst[sizeof(kNALStartCode)] & 0x1f;
+ switch (nalType) {
+ case kNALTypeSPS:
+ case kNALTypePPS:
+ flags = MediaCodec::BUFFER_FLAG_CODECCONFIG;
+ break;
+ case kNALTypeIDR:
+ flags = MediaCodec::BUFFER_FLAG_SYNCFRAME;
+ break;
+ default:
+ flags = 0;
+ break;
+ }
+ CODEC_LOGD("Decoder input: %d bytes (NAL 0x%02x), time %lld (%u), flags 0x%x",
+ nalu._length, dst[sizeof(kNALStartCode)], inputTimeUs, nalu._timeStamp, flags);
+ err = mCodec->queueInputBuffer(index, 0, nalu._length, inputTimeUs, flags);
+ if (err == OK && !(flags & MediaCodec::BUFFER_FLAG_CODECCONFIG)) {
+ if (mOutputDrain == nullptr) {
+ mOutputDrain = new OutputDrain(this);
+ mOutputDrain->Start();
+ }
+ EncodedFrame frame;
+ frame.mWidth = mWidth;
+ frame.mHeight = mHeight;
+ frame.mTimestamp = nalu._timeStamp;
+ frame.mRenderTimeMs = aRenderTimeMs;
+ mOutputDrain->QueueInput(frame);
+ }
+ }
+
+ return err;
+ }
+
+ status_t
+ DrainOutput(std::queue<EncodedFrame>& aInputFrames, Monitor& aMonitor)
+ {
+ MOZ_ASSERT(mCodec != nullptr);
+ if (mCodec == nullptr) {
+ return INVALID_OPERATION;
+ }
+
+ size_t index = 0;
+ size_t outOffset = 0;
+ size_t outSize = 0;
+ int64_t outTime = -1ll;
+ uint32_t outFlags = 0;
+ status_t err = mCodec->dequeueOutputBuffer(&index, &outOffset, &outSize,
+ &outTime, &outFlags,
+ DRAIN_THREAD_TIMEOUT_US);
+ switch (err) {
+ case OK:
+ break;
+ case -EAGAIN:
+ // Not an error: output not available yet. Try later.
+ CODEC_LOGI("decode dequeue OMX output buffer timed out. Try later.");
+ return err;
+ case INFO_FORMAT_CHANGED:
+ // Not an error: will get this value when OMX output buffer is enabled,
+ // or when input size changed.
+ CODEC_LOGD("decode dequeue OMX output buffer format change");
+ return err;
+ case INFO_OUTPUT_BUFFERS_CHANGED:
+ // Not an error: will get this value when OMX output buffer changed
+ // (probably because of input size change).
+ CODEC_LOGD("decode dequeue OMX output buffer change");
+ err = mCodec->getOutputBuffers(&mOutputBuffers);
+ MOZ_ASSERT(err == OK);
+ return INFO_OUTPUT_BUFFERS_CHANGED;
+ default:
+ CODEC_LOGE("decode dequeue OMX output buffer error:%d", err);
+ // Return OK to instruct OutputDrain to drop input from queue.
+ MonitorAutoLock lock(aMonitor);
+ aInputFrames.pop();
+ return OK;
+ }
+
+ CODEC_LOGD("Decoder output: %d bytes, offset %u, time %lld, flags 0x%x",
+ outSize, outOffset, outTime, outFlags);
+ if (mCallback) {
+ EncodedFrame frame;
+ {
+ MonitorAutoLock lock(aMonitor);
+ frame = aInputFrames.front();
+ aInputFrames.pop();
+ }
+ {
+ // Store info of this frame. OnNewFrame() will need the timestamp later.
+ MutexAutoLock lock(mDecodedFrameLock);
+ if (mEnding) {
+ mCodec->releaseOutputBuffer(index);
+ return err;
+ }
+ mDecodedFrames.push(frame);
+ }
+ // Ask codec to queue buffer back to native window. OnNewFrame() will be
+ // called.
+ mCodec->renderOutputBufferAndRelease(index);
+ // Once consumed, buffer will be queued back to GonkNativeWindow for codec
+ // to dequeue/use.
+ } else {
+ mCodec->releaseOutputBuffer(index);
+ }
+
+ return err;
+ }
+
+ // Will be called when MediaCodec::RenderOutputBufferAndRelease() returns
+ // buffers back to native window for rendering.
+ void OnNewFrame() override
+ {
+ RefPtr<layers::TextureClient> buffer = mNativeWindow->getCurrentBuffer();
+ if (!buffer) {
+ CODEC_LOGE("Decoder NewFrame: Get null buffer");
+ return;
+ }
+
+ gfx::IntSize picSize(buffer->GetSize());
+ nsAutoPtr<layers::GrallocImage> grallocImage(new layers::GrallocImage());
+ grallocImage->AdoptData(buffer, picSize);
+
+ // Get timestamp of the frame about to render.
+ int64_t timestamp = -1;
+ int64_t renderTimeMs = -1;
+ {
+ MutexAutoLock lock(mDecodedFrameLock);
+ if (mDecodedFrames.empty()) {
+ return;
+ }
+ EncodedFrame decoded = mDecodedFrames.front();
+ timestamp = decoded.mTimestamp;
+ renderTimeMs = decoded.mRenderTimeMs;
+ mDecodedFrames.pop();
+ }
+ MOZ_ASSERT(timestamp >= 0 && renderTimeMs >= 0);
+
+ CODEC_LOGD("Decoder NewFrame: %dx%d, timestamp %lld, renderTimeMs %lld",
+ picSize.width, picSize.height, timestamp, renderTimeMs);
+
+ nsAutoPtr<webrtc::I420VideoFrame> videoFrame(new webrtc::I420VideoFrame(
+ new ImageNativeHandle(grallocImage.forget()),
+ picSize.width,
+ picSize.height,
+ timestamp,
+ renderTimeMs));
+ if (videoFrame != nullptr) {
+ mCallback->Decoded(*videoFrame);
+ }
+ }
+
+private:
+ class OutputDrain : public OMXOutputDrain
+ {
+ public:
+ OutputDrain(WebrtcOMXDecoder* aOMX)
+ : OMXOutputDrain()
+ , mOMX(aOMX)
+ {}
+
+ protected:
+ virtual bool DrainOutput() override
+ {
+ return (mOMX->DrainOutput(mInputFrames, mMonitor) == OK);
+ }
+
+ private:
+ WebrtcOMXDecoder* mOMX;
+ };
+
+ status_t Start()
+ {
+ MOZ_ASSERT(!mStarted);
+ if (mStarted) {
+ return OK;
+ }
+
+ {
+ MutexAutoLock lock(mDecodedFrameLock);
+ mEnding = false;
+ }
+ status_t err = mCodec->start();
+ if (err == OK) {
+ mStarted = true;
+ mCodec->getInputBuffers(&mInputBuffers);
+ mCodec->getOutputBuffers(&mOutputBuffers);
+ }
+
+ return err;
+ }
+
+ status_t Stop()
+ {
+ MOZ_ASSERT(mStarted);
+ if (!mStarted) {
+ return OK;
+ }
+
+ CODEC_LOGD("OMXOutputDrain decoder stopping");
+ // Drop all 'pending to render' frames.
+ {
+ MutexAutoLock lock(mDecodedFrameLock);
+ mEnding = true;
+ while (!mDecodedFrames.empty()) {
+ mDecodedFrames.pop();
+ }
+ }
+
+ if (mOutputDrain != nullptr) {
+ CODEC_LOGD("decoder's OutputDrain stopping");
+ mOutputDrain->Stop();
+ mOutputDrain = nullptr;
+ }
+
+ status_t err = mCodec->stop();
+ if (err == OK) {
+ mInputBuffers.clear();
+ mOutputBuffers.clear();
+ mStarted = false;
+ } else {
+ MOZ_ASSERT(false);
+ }
+ CODEC_LOGD("OMXOutputDrain decoder stopped");
+ return err;
+ }
+
+ sp<ALooper> mLooper;
+ sp<MediaCodec> mCodec; // OMXCodec
+ int mWidth;
+ int mHeight;
+ android::Vector<sp<ABuffer> > mInputBuffers;
+ android::Vector<sp<ABuffer> > mOutputBuffers;
+ bool mStarted;
+
+ sp<GonkNativeWindow> mNativeWindow;
+
+ RefPtr<OutputDrain> mOutputDrain;
+ webrtc::DecodedImageCallback* mCallback;
+
+ Mutex mDecodedFrameLock; // To protect mDecodedFrames and mEnding
+ std::queue<EncodedFrame> mDecodedFrames;
+ bool mEnding;
+};
+
+class EncOutputDrain : public OMXOutputDrain
+{
+public:
+ EncOutputDrain(OMXVideoEncoder* aOMX, webrtc::EncodedImageCallback* aCallback)
+ : OMXOutputDrain()
+ , mOMX(aOMX)
+ , mCallback(aCallback)
+ , mIsPrevFrameParamSets(false)
+ {}
+
+protected:
+ virtual bool DrainOutput() override
+ {
+ nsTArray<uint8_t> output;
+ int64_t timeUs = -1ll;
+ int flags = 0;
+ nsresult rv = mOMX->GetNextEncodedFrame(&output, &timeUs, &flags,
+ DRAIN_THREAD_TIMEOUT_US);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ // Fail to get encoded frame. The corresponding input frame should be
+ // removed.
+ // We'll treat this like a skipped frame
+ return true;
+ }
+
+ if (output.Length() == 0) {
+ // No encoded data yet. Try later.
+ CODEC_LOGD("OMX: (encode no output available this time)");
+ return false;
+ }
+
+ // Conversion to us rounds down, so we need to round up for us->90KHz
+ uint32_t target_timestamp = (timeUs * 90ll + 999) / 1000; // us -> 90KHz
+ // 8x10 v2.0 encoder doesn't set this reliably:
+ //bool isParamSets = (flags & MediaCodec::BUFFER_FLAG_CODECCONFIG);
+ // Assume that SPS/PPS will be at the start of any buffer
+ // Assume PPS will not be in a separate buffer - SPS/PPS or SPS/PPS/iframe
+ bool isParamSets = IsParamSets(output.Elements(), output.Length());
+ bool isIFrame = (flags & MediaCodec::BUFFER_FLAG_SYNCFRAME);
+ CODEC_LOGD("OMX: encoded frame (%d): time %lld (%u), flags x%x",
+ output.Length(), timeUs, target_timestamp, flags);
+ // Should not be parameter sets and I-frame at the same time.
+ // Except that it is possible, apparently, after an encoder re-config (bug 1063883)
+ // MOZ_ASSERT(!(isParamSets && isIFrame));
+
+ if (mCallback) {
+ // Implementation here assumes encoder output to be a buffer containing
+ // parameter sets(SPS + PPS) followed by a series of buffers, each for
+ // one input frame.
+ // TODO: handle output violating this assumpton in bug 997110.
+ webrtc::EncodedImage encoded(output.Elements(), output.Length(),
+ output.Capacity());
+ encoded._frameType = (isParamSets || isIFrame) ?
+ webrtc::kKeyFrame : webrtc::kDeltaFrame;
+ EncodedFrame input_frame;
+ {
+ MonitorAutoLock lock(mMonitor);
+ // will sps/pps have the same timestamp as their iframe? Initial one on 8x10 has
+ // 0 timestamp.
+ if (isParamSets) {
+ // Let's assume it was the first item in the queue, but leave it there since an
+ // IDR will follow
+ input_frame = mInputFrames.front();
+ } else {
+ do {
+ if (mInputFrames.empty()) {
+ // Let's assume it was the last item in the queue, but leave it there
+ mInputFrames.push(input_frame);
+ CODEC_LOGE("OMX: encoded timestamp %u which doesn't match input queue!! (head %u)",
+ target_timestamp, input_frame.mTimestamp);
+ break;
+ }
+
+ input_frame = mInputFrames.front();
+ mInputFrames.pop();
+ if (input_frame.mTimestamp != target_timestamp) {
+ CODEC_LOGD("OMX: encoder skipped frame timestamp %u", input_frame.mTimestamp);
+ }
+ } while (input_frame.mTimestamp != target_timestamp);
+ }
+ }
+
+ encoded._encodedWidth = input_frame.mWidth;
+ encoded._encodedHeight = input_frame.mHeight;
+ encoded._timeStamp = input_frame.mTimestamp;
+ encoded.capture_time_ms_ = input_frame.mRenderTimeMs;
+ encoded._completeFrame = true;
+
+ CODEC_LOGD("Encoded frame: %d bytes, %dx%d, is_param %d, is_iframe %d, timestamp %u, captureTimeMs %" PRIu64,
+ encoded._length, encoded._encodedWidth, encoded._encodedHeight,
+ isParamSets, isIFrame, encoded._timeStamp, encoded.capture_time_ms_);
+ // Prepend SPS/PPS to I-frames unless they were sent last time.
+ SendEncodedDataToCallback(encoded, isIFrame && !mIsPrevFrameParamSets && !isParamSets);
+ // This will be true only for the frame following a paramset block! So if we're
+ // working with a correct encoder that generates SPS/PPS then iframe always, we
+ // won't try to insert. (also, don't set if we get SPS/PPS/iframe in one buffer)
+ mIsPrevFrameParamSets = isParamSets && !isIFrame;
+ if (isParamSets) {
+ // copy off the param sets for inserting later
+ mParamSets.Clear();
+ // since we may have SPS/PPS or SPS/PPS/iframe
+ size_t length = ParamSetLength(encoded._buffer, encoded._length);
+ MOZ_ASSERT(length > 0);
+ mParamSets.AppendElements(encoded._buffer, length);
+ }
+ }
+
+ return !isParamSets; // not really needed anymore
+ }
+
+private:
+ // Send encoded data to callback.The data will be broken into individual NALUs
+ // if necessary and sent to callback one by one. This function can also insert
+ // SPS/PPS NALUs in front of input data if requested.
+ void SendEncodedDataToCallback(webrtc::EncodedImage& aEncodedImage,
+ bool aPrependParamSets)
+ {
+ if (aPrependParamSets) {
+ webrtc::EncodedImage prepend(aEncodedImage);
+ // Insert current parameter sets in front of the input encoded data.
+ MOZ_ASSERT(mParamSets.Length() > sizeof(kNALStartCode)); // Start code + ...
+ prepend._length = mParamSets.Length();
+ prepend._buffer = mParamSets.Elements();
+ // Break into NALUs and send.
+ CODEC_LOGD("Prepending SPS/PPS: %d bytes, timestamp %u, captureTimeMs %" PRIu64,
+ prepend._length, prepend._timeStamp, prepend.capture_time_ms_);
+ SendEncodedDataToCallback(prepend, false);
+ }
+
+ struct nal_entry {
+ uint32_t offset;
+ uint32_t size;
+ };
+ AutoTArray<nal_entry, 1> nals;
+
+ // Break input encoded data into NALUs and send each one to callback.
+ const uint8_t* data = aEncodedImage._buffer;
+ size_t size = aEncodedImage._length;
+ const uint8_t* nalStart = nullptr;
+ size_t nalSize = 0;
+ while (getNextNALUnit(&data, &size, &nalStart, &nalSize, true) == OK) {
+ // XXX optimize by making buffer an offset
+ nal_entry nal = {((uint32_t) (nalStart - aEncodedImage._buffer)), (uint32_t) nalSize};
+ nals.AppendElement(nal);
+ }
+
+ size_t num_nals = nals.Length();
+ if (num_nals > 0) {
+ webrtc::RTPFragmentationHeader fragmentation;
+ fragmentation.VerifyAndAllocateFragmentationHeader(num_nals);
+ for (size_t i = 0; i < num_nals; i++) {
+ fragmentation.fragmentationOffset[i] = nals[i].offset;
+ fragmentation.fragmentationLength[i] = nals[i].size;
+ }
+ webrtc::EncodedImage unit(aEncodedImage);
+ unit._completeFrame = true;
+
+ mCallback->Encoded(unit, nullptr, &fragmentation);
+ }
+ }
+
+ OMXVideoEncoder* mOMX;
+ webrtc::EncodedImageCallback* mCallback;
+ bool mIsPrevFrameParamSets;
+ nsTArray<uint8_t> mParamSets;
+};
+
+// Encoder.
+WebrtcOMXH264VideoEncoder::WebrtcOMXH264VideoEncoder()
+ : mOMX(nullptr)
+ , mCallback(nullptr)
+ , mWidth(0)
+ , mHeight(0)
+ , mFrameRate(0)
+ , mBitRateKbps(0)
+#ifdef OMX_IDR_NEEDED_FOR_BITRATE
+ , mBitRateAtLastIDR(0)
+#endif
+ , mOMXConfigured(false)
+ , mOMXReconfigure(false)
+{
+ mReservation = new OMXCodecReservation(true);
+ CODEC_LOGD("WebrtcOMXH264VideoEncoder:%p constructed", this);
+}
+
+int32_t
+WebrtcOMXH264VideoEncoder::InitEncode(const webrtc::VideoCodec* aCodecSettings,
+ int32_t aNumOfCores,
+ size_t aMaxPayloadSize)
+{
+ CODEC_LOGD("WebrtcOMXH264VideoEncoder:%p init", this);
+
+ if (mOMX == nullptr) {
+ nsAutoPtr<OMXVideoEncoder> omx(OMXCodecWrapper::CreateAVCEncoder());
+ if (NS_WARN_IF(omx == nullptr)) {
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+ mOMX = omx.forget();
+ CODEC_LOGD("WebrtcOMXH264VideoEncoder:%p OMX created", this);
+ }
+
+ if (!mReservation->ReserveOMXCodec()) {
+ CODEC_LOGD("WebrtcOMXH264VideoEncoder:%p Encoder in use", this);
+ mOMX = nullptr;
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ // Defer configuration until 1st frame is received because this function will
+ // be called more than once, and unfortunately with incorrect setting values
+ // at first.
+ mWidth = aCodecSettings->width;
+ mHeight = aCodecSettings->height;
+ mFrameRate = aCodecSettings->maxFramerate;
+ mBitRateKbps = aCodecSettings->startBitrate;
+ // XXX handle maxpayloadsize (aka mode 0/1)
+
+ CODEC_LOGD("WebrtcOMXH264VideoEncoder:%p OMX Encoder reserved", this);
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t
+WebrtcOMXH264VideoEncoder::Encode(const webrtc::I420VideoFrame& aInputImage,
+ const webrtc::CodecSpecificInfo* aCodecSpecificInfo,
+ const std::vector<webrtc::VideoFrameType>* aFrameTypes)
+{
+ MOZ_ASSERT(mOMX != nullptr);
+ if (mOMX == nullptr) {
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ // Have to reconfigure for resolution or framerate changes :-(
+ // ~220ms initial configure on 8x10, 50-100ms for re-configure it appears
+ // XXX drop frames while this is happening?
+ if (aInputImage.width() < 0 || (uint32_t)aInputImage.width() != mWidth ||
+ aInputImage.height() < 0 || (uint32_t)aInputImage.height() != mHeight) {
+ mWidth = aInputImage.width();
+ mHeight = aInputImage.height();
+ mOMXReconfigure = true;
+ }
+
+ if (!mOMXConfigured || mOMXReconfigure) {
+ if (mOMXConfigured) {
+ CODEC_LOGD("WebrtcOMXH264VideoEncoder:%p reconfiguring encoder %dx%d @ %u fps",
+ this, mWidth, mHeight, mFrameRate);
+ mOMXConfigured = false;
+ }
+ mOMXReconfigure = false;
+ // XXX This can take time. Encode() likely assumes encodes are queued "quickly" and
+ // don't block the input too long. Frames may build up.
+
+ // XXX take from negotiated SDP in codecSpecific data
+ OMX_VIDEO_AVCLEVELTYPE level = OMX_VIDEO_AVCLevel3;
+ // OMX_Video_ControlRateConstant is not supported on QC 8x10
+ OMX_VIDEO_CONTROLRATETYPE bitrateMode = OMX_Video_ControlRateConstantSkipFrames;
+
+ // Set up configuration parameters for AVC/H.264 encoder.
+ sp<AMessage> format = new AMessage;
+ // Fixed values
+ format->setString("mime", MEDIA_MIMETYPE_VIDEO_AVC);
+ // XXX We should only set to < infinity if we're not using any recovery RTCP options
+ // However, we MUST set it to a lower value because the 8x10 rate controller
+ // only changes rate at GOP boundaries.... but it also changes rate on requested GOPs
+
+ // Too long and we have very low bitrates for the first second or two... plus
+ // bug 1014921 means we have to force them every ~3 seconds or less.
+ format->setInt32("i-frame-interval", 4 /* seconds */);
+ // See mozilla::layers::GrallocImage, supports YUV 4:2:0, CbCr width and
+ // height is half that of Y
+ format->setInt32("color-format", OMX_COLOR_FormatYUV420SemiPlanar);
+ format->setInt32("profile", OMX_VIDEO_AVCProfileBaseline);
+ format->setInt32("level", level);
+ format->setInt32("bitrate-mode", bitrateMode);
+ format->setInt32("store-metadata-in-buffers", 0);
+ // XXX Unfortunately, 8x10 doesn't support this, but ask anyways
+ format->setInt32("prepend-sps-pps-to-idr-frames", 1);
+ // Input values.
+ format->setInt32("width", mWidth);
+ format->setInt32("height", mHeight);
+ format->setInt32("stride", mWidth);
+ format->setInt32("slice-height", mHeight);
+ format->setInt32("frame-rate", mFrameRate);
+ format->setInt32("bitrate", mBitRateKbps*1000);
+
+ CODEC_LOGD("WebrtcOMXH264VideoEncoder:%p configuring encoder %dx%d @ %d fps, rate %d kbps",
+ this, mWidth, mHeight, mFrameRate, mBitRateKbps);
+ nsresult rv = mOMX->ConfigureDirect(format,
+ OMXVideoEncoder::BlobFormat::AVC_NAL);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ CODEC_LOGE("WebrtcOMXH264VideoEncoder:%p FAILED configuring encoder %d", this, int(rv));
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+ mOMXConfigured = true;
+#ifdef OMX_IDR_NEEDED_FOR_BITRATE
+ mLastIDRTime = TimeStamp::Now();
+ mBitRateAtLastIDR = mBitRateKbps;
+#endif
+ }
+
+ if (aFrameTypes && aFrameTypes->size() &&
+ ((*aFrameTypes)[0] == webrtc::kKeyFrame)) {
+ mOMX->RequestIDRFrame();
+#ifdef OMX_IDR_NEEDED_FOR_BITRATE
+ mLastIDRTime = TimeStamp::Now();
+ mBitRateAtLastIDR = mBitRateKbps;
+ } else if (mBitRateKbps != mBitRateAtLastIDR) {
+ // 8x10 OMX codec requires a keyframe to shift bitrates!
+ TimeStamp now = TimeStamp::Now();
+ if (mLastIDRTime.IsNull()) {
+ // paranoia
+ mLastIDRTime = now;
+ }
+ int32_t timeSinceLastIDR = (now - mLastIDRTime).ToMilliseconds();
+
+ // Balance asking for IDRs too often against direction and amount of bitrate change.
+
+ // HACK for bug 1014921: 8x10 has encode/decode mismatches that build up errors
+ // if you go too long without an IDR. In normal use, bitrate will change often
+ // enough to never hit this time limit.
+ if ((timeSinceLastIDR > 3000) ||
+ (mBitRateKbps < (mBitRateAtLastIDR * 8)/10) ||
+ (timeSinceLastIDR < 300 && mBitRateKbps < (mBitRateAtLastIDR * 9)/10) ||
+ (timeSinceLastIDR < 1000 && mBitRateKbps < (mBitRateAtLastIDR * 97)/100) ||
+ (timeSinceLastIDR >= 1000 && mBitRateKbps < mBitRateAtLastIDR) ||
+ (mBitRateKbps > (mBitRateAtLastIDR * 15)/10) ||
+ (timeSinceLastIDR < 500 && mBitRateKbps > (mBitRateAtLastIDR * 13)/10) ||
+ (timeSinceLastIDR < 1000 && mBitRateKbps > (mBitRateAtLastIDR * 11)/10) ||
+ (timeSinceLastIDR >= 1000 && mBitRateKbps > mBitRateAtLastIDR)) {
+ CODEC_LOGD("Requesting IDR for bitrate change from %u to %u (time since last idr %dms)",
+ mBitRateAtLastIDR, mBitRateKbps, timeSinceLastIDR);
+
+ mOMX->RequestIDRFrame();
+ mLastIDRTime = now;
+ mBitRateAtLastIDR = mBitRateKbps;
+ }
+#endif
+ }
+
+ // Wrap I420VideoFrame input with PlanarYCbCrImage for OMXVideoEncoder.
+ layers::PlanarYCbCrData yuvData;
+ yuvData.mYChannel = const_cast<uint8_t*>(aInputImage.buffer(webrtc::kYPlane));
+ yuvData.mYSize = gfx::IntSize(aInputImage.width(), aInputImage.height());
+ yuvData.mYStride = aInputImage.stride(webrtc::kYPlane);
+ MOZ_ASSERT(aInputImage.stride(webrtc::kUPlane) == aInputImage.stride(webrtc::kVPlane));
+ yuvData.mCbCrStride = aInputImage.stride(webrtc::kUPlane);
+ yuvData.mCbChannel = const_cast<uint8_t*>(aInputImage.buffer(webrtc::kUPlane));
+ yuvData.mCrChannel = const_cast<uint8_t*>(aInputImage.buffer(webrtc::kVPlane));
+ yuvData.mCbCrSize = gfx::IntSize((yuvData.mYSize.width + 1) / 2,
+ (yuvData.mYSize.height + 1) / 2);
+ yuvData.mPicSize = yuvData.mYSize;
+ yuvData.mStereoMode = StereoMode::MONO;
+ layers::RecyclingPlanarYCbCrImage img(nullptr);
+ // AdoptData() doesn't need AllocateAndGetNewBuffer(); OMXVideoEncoder is ok with this
+ img.AdoptData(yuvData);
+
+ CODEC_LOGD("Encode frame: %dx%d, timestamp %u (%lld), renderTimeMs %" PRIu64,
+ aInputImage.width(), aInputImage.height(),
+ aInputImage.timestamp(), aInputImage.timestamp() * 1000ll / 90,
+ aInputImage.render_time_ms());
+
+ nsresult rv = mOMX->Encode(&img,
+ yuvData.mYSize.width,
+ yuvData.mYSize.height,
+ aInputImage.timestamp() * 1000ll / 90, // 90kHz -> us.
+ 0);
+ if (rv == NS_OK) {
+ if (mOutputDrain == nullptr) {
+ mOutputDrain = new EncOutputDrain(mOMX, mCallback);
+ mOutputDrain->Start();
+ }
+ EncodedFrame frame;
+ frame.mWidth = mWidth;
+ frame.mHeight = mHeight;
+ frame.mTimestamp = aInputImage.timestamp();
+ frame.mRenderTimeMs = aInputImage.render_time_ms();
+ mOutputDrain->QueueInput(frame);
+ }
+
+ return (rv == NS_OK) ? WEBRTC_VIDEO_CODEC_OK : WEBRTC_VIDEO_CODEC_ERROR;
+}
+
+int32_t
+WebrtcOMXH264VideoEncoder::RegisterEncodeCompleteCallback(
+ webrtc::EncodedImageCallback* aCallback)
+{
+ CODEC_LOGD("WebrtcOMXH264VideoEncoder:%p set callback:%p", this, aCallback);
+ MOZ_ASSERT(aCallback);
+ mCallback = aCallback;
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t
+WebrtcOMXH264VideoEncoder::Release()
+{
+ CODEC_LOGD("WebrtcOMXH264VideoEncoder:%p will be released", this);
+
+ if (mOutputDrain != nullptr) {
+ mOutputDrain->Stop();
+ mOutputDrain = nullptr;
+ }
+ mOMXConfigured = false;
+ bool hadOMX = !!mOMX;
+ mOMX = nullptr;
+ if (hadOMX) {
+ mReservation->ReleaseOMXCodec();
+ }
+ CODEC_LOGD("WebrtcOMXH264VideoEncoder:%p released", this);
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+WebrtcOMXH264VideoEncoder::~WebrtcOMXH264VideoEncoder()
+{
+ CODEC_LOGD("WebrtcOMXH264VideoEncoder:%p will be destructed", this);
+
+ Release();
+}
+
+// Inform the encoder of the new packet loss rate and the round-trip time of
+// the network. aPacketLossRate is fraction lost and can be 0~255
+// (255 means 100% lost).
+// Note: stagefright doesn't handle these parameters.
+int32_t
+WebrtcOMXH264VideoEncoder::SetChannelParameters(uint32_t aPacketLossRate,
+ int64_t aRoundTripTimeMs)
+{
+ CODEC_LOGD("WebrtcOMXH264VideoEncoder:%p set channel packet loss:%u, rtt:%" PRIi64,
+ this, aPacketLossRate, aRoundTripTimeMs);
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+// TODO: Bug 997567. Find the way to support frame rate change.
+int32_t
+WebrtcOMXH264VideoEncoder::SetRates(uint32_t aBitRateKbps, uint32_t aFrameRate)
+{
+ CODEC_LOGE("WebrtcOMXH264VideoEncoder:%p set bitrate:%u, frame rate:%u (%u))",
+ this, aBitRateKbps, aFrameRate, mFrameRate);
+ MOZ_ASSERT(mOMX != nullptr);
+ if (mOMX == nullptr) {
+ return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
+ }
+
+ // XXX Should use StageFright framerate change, perhaps only on major changes of framerate.
+
+ // Without Stagefright support, Algorithm should be:
+ // if (frameRate < 50% of configured) {
+ // drop framerate to next step down that includes current framerate within 50%
+ // } else if (frameRate > configured) {
+ // change config to next step up that includes current framerate
+ // }
+#if !defined(TEST_OMX_FRAMERATE_CHANGES)
+ if (aFrameRate > mFrameRate ||
+ aFrameRate < mFrameRate/2) {
+ uint32_t old_rate = mFrameRate;
+ if (aFrameRate >= 15) {
+ mFrameRate = 30;
+ } else if (aFrameRate >= 10) {
+ mFrameRate = 20;
+ } else if (aFrameRate >= 8) {
+ mFrameRate = 15;
+ } else /* if (aFrameRate >= 5)*/ {
+ // don't go lower; encoder may not be stable
+ mFrameRate = 10;
+ }
+ if (mFrameRate < aFrameRate) { // safety
+ mFrameRate = aFrameRate;
+ }
+ if (old_rate != mFrameRate) {
+ mOMXReconfigure = true; // force re-configure on next frame
+ }
+ }
+#else
+ // XXX for testing, be wild!
+ if (aFrameRate != mFrameRate) {
+ mFrameRate = aFrameRate;
+ mOMXReconfigure = true; // force re-configure on next frame
+ }
+#endif
+
+ // XXX Limit bitrate for 8x10 devices to a specific level depending on fps and resolution
+ // mBitRateKbps = LimitBitrate8x10(mWidth, mHeight, mFrameRate, aBitRateKbps);
+ // Rely on global single setting (~720 kbps for HVGA@30fps) for now
+ if (aBitRateKbps > 700) {
+ aBitRateKbps = 700;
+ }
+ mBitRateKbps = aBitRateKbps;
+ nsresult rv = mOMX->SetBitrate(mBitRateKbps);
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "SetBitrate failed");
+ return NS_FAILED(rv) ? WEBRTC_VIDEO_CODEC_OK : WEBRTC_VIDEO_CODEC_ERROR;
+}
+
+// Decoder.
+WebrtcOMXH264VideoDecoder::WebrtcOMXH264VideoDecoder()
+ : mCallback(nullptr)
+ , mOMX(nullptr)
+{
+ mReservation = new OMXCodecReservation(false);
+ CODEC_LOGD("WebrtcOMXH264VideoDecoder:%p will be constructed", this);
+}
+
+int32_t
+WebrtcOMXH264VideoDecoder::InitDecode(const webrtc::VideoCodec* aCodecSettings,
+ int32_t aNumOfCores)
+{
+ CODEC_LOGD("WebrtcOMXH264VideoDecoder:%p init OMX:%p", this, mOMX.get());
+
+ if (!mReservation->ReserveOMXCodec()) {
+ CODEC_LOGD("WebrtcOMXH264VideoDecoder:%p Decoder in use", this);
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ // Defer configuration until SPS/PPS NALUs (where actual decoder config
+ // values can be extracted) are received.
+
+ CODEC_LOGD("WebrtcOMXH264VideoDecoder:%p OMX Decoder reserved", this);
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t
+WebrtcOMXH264VideoDecoder::Decode(const webrtc::EncodedImage& aInputImage,
+ bool aMissingFrames,
+ const webrtc::RTPFragmentationHeader* aFragmentation,
+ const webrtc::CodecSpecificInfo* aCodecSpecificInfo,
+ int64_t aRenderTimeMs)
+{
+ if (aInputImage._length== 0 || !aInputImage._buffer) {
+ return WEBRTC_VIDEO_CODEC_ERROR;
+ }
+
+ bool configured = !!mOMX;
+ if (!configured) {
+ // Search for SPS NALU in input to get width/height config.
+ int32_t width;
+ int32_t height;
+ status_t result = WebrtcOMXDecoder::ExtractPicDimensions(aInputImage._buffer,
+ aInputImage._length,
+ &width, &height);
+ if (result != OK) {
+ // Cannot config decoder because SPS haven't been seen.
+ CODEC_LOGI("WebrtcOMXH264VideoDecoder:%p missing SPS in input (nal 0x%02x, len %d)",
+ this, aInputImage._buffer[sizeof(kNALStartCode)] & 0x1f, aInputImage._length);
+ return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
+ }
+ RefPtr<WebrtcOMXDecoder> omx = new WebrtcOMXDecoder(MEDIA_MIMETYPE_VIDEO_AVC,
+ mCallback);
+ result = omx->ConfigureWithPicDimensions(width, height);
+ if (NS_WARN_IF(result != OK)) {
+ return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
+ }
+ CODEC_LOGD("WebrtcOMXH264VideoDecoder:%p start OMX", this);
+ mOMX = omx;
+ }
+
+ bool feedFrame = true;
+ while (feedFrame) {
+ status_t err = mOMX->FillInput(aInputImage, !configured, aRenderTimeMs);
+ feedFrame = (err == -EAGAIN); // No input buffer available. Try again.
+ }
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t
+WebrtcOMXH264VideoDecoder::RegisterDecodeCompleteCallback(webrtc::DecodedImageCallback* aCallback)
+{
+ CODEC_LOGD("WebrtcOMXH264VideoDecoder:%p set callback:%p", this, aCallback);
+ MOZ_ASSERT(aCallback);
+ mCallback = aCallback;
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t
+WebrtcOMXH264VideoDecoder::Release()
+{
+ CODEC_LOGD("WebrtcOMXH264VideoDecoder:%p will be released", this);
+
+ mOMX = nullptr; // calls Stop()
+ mReservation->ReleaseOMXCodec();
+
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+WebrtcOMXH264VideoDecoder::~WebrtcOMXH264VideoDecoder()
+{
+ CODEC_LOGD("WebrtcOMXH264VideoDecoder:%p will be destructed", this);
+ Release();
+}
+
+int32_t
+WebrtcOMXH264VideoDecoder::Reset()
+{
+ CODEC_LOGW("WebrtcOMXH264VideoDecoder::Reset() will NOT reset decoder");
+ return WEBRTC_VIDEO_CODEC_OK;
+}
+
+}
diff --git a/media/webrtc/signaling/src/media-conduit/WebrtcOMXH264VideoCodec.h b/media/webrtc/signaling/src/media-conduit/WebrtcOMXH264VideoCodec.h
new file mode 100644
index 000000000..71cf5c681
--- /dev/null
+++ b/media/webrtc/signaling/src/media-conduit/WebrtcOMXH264VideoCodec.h
@@ -0,0 +1,108 @@
+/* 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/. */
+
+#ifndef WEBRTC_GONK
+#pragma error WebrtcOMXH264VideoCodec works only on B2G.
+#endif
+
+#ifndef WEBRTC_OMX_H264_CODEC_H_
+#define WEBRTC_OMX_H264_CODEC_H_
+
+#include "AudioConduit.h"
+#include "VideoConduit.h"
+#include <foundation/ABase.h>
+#include <utils/RefBase.h>
+#include "OMXCodecWrapper.h"
+
+namespace android {
+ class OMXVideoEncoder;
+}
+
+namespace mozilla {
+
+class WebrtcOMXDecoder;
+class OMXOutputDrain;
+
+// XXX see if we can reduce this
+#define WEBRTC_OMX_H264_MIN_DECODE_BUFFERS 10
+#define OMX_IDR_NEEDED_FOR_BITRATE 0
+
+class WebrtcOMXH264VideoEncoder : public WebrtcVideoEncoder
+{
+public:
+ WebrtcOMXH264VideoEncoder();
+
+ virtual ~WebrtcOMXH264VideoEncoder();
+
+ // Implement VideoEncoder interface.
+ virtual uint64_t PluginID() const override { return 0; }
+
+ virtual int32_t InitEncode(const webrtc::VideoCodec* aCodecSettings,
+ int32_t aNumOfCores,
+ size_t aMaxPayloadSize) override;
+
+ virtual int32_t Encode(const webrtc::I420VideoFrame& aInputImage,
+ const webrtc::CodecSpecificInfo* aCodecSpecificInfo,
+ const std::vector<webrtc::VideoFrameType>* aFrameTypes) override;
+
+ virtual int32_t RegisterEncodeCompleteCallback(webrtc::EncodedImageCallback* aCallback) override;
+
+ virtual int32_t Release() override;
+
+ virtual int32_t SetChannelParameters(uint32_t aPacketLossRate,
+ int64_t aRoundTripTimeMs) override;
+
+ virtual int32_t SetRates(uint32_t aBitRate, uint32_t aFrameRate) override;
+
+private:
+ nsAutoPtr<android::OMXVideoEncoder> mOMX;
+ android::sp<android::OMXCodecReservation> mReservation;
+
+ webrtc::EncodedImageCallback* mCallback;
+ RefPtr<OMXOutputDrain> mOutputDrain;
+ uint32_t mWidth;
+ uint32_t mHeight;
+ uint32_t mFrameRate;
+ uint32_t mBitRateKbps;
+#ifdef OMX_IDR_NEEDED_FOR_BITRATE
+ uint32_t mBitRateAtLastIDR;
+ TimeStamp mLastIDRTime;
+#endif
+ bool mOMXConfigured;
+ bool mOMXReconfigure;
+ webrtc::EncodedImage mEncodedImage;
+};
+
+class WebrtcOMXH264VideoDecoder : public WebrtcVideoDecoder
+{
+public:
+ WebrtcOMXH264VideoDecoder();
+
+ virtual ~WebrtcOMXH264VideoDecoder();
+
+ // Implement VideoDecoder interface.
+ virtual uint64_t PluginID() const override { return 0; }
+
+ virtual int32_t InitDecode(const webrtc::VideoCodec* aCodecSettings,
+ int32_t aNumOfCores) override;
+ virtual int32_t Decode(const webrtc::EncodedImage& aInputImage,
+ bool aMissingFrames,
+ const webrtc::RTPFragmentationHeader* aFragmentation,
+ const webrtc::CodecSpecificInfo* aCodecSpecificInfo = nullptr,
+ int64_t aRenderTimeMs = -1) override;
+ virtual int32_t RegisterDecodeCompleteCallback(webrtc::DecodedImageCallback* callback) override;
+
+ virtual int32_t Release() override;
+
+ virtual int32_t Reset() override;
+
+private:
+ webrtc::DecodedImageCallback* mCallback;
+ RefPtr<WebrtcOMXDecoder> mOMX;
+ android::sp<android::OMXCodecReservation> mReservation;
+};
+
+}
+
+#endif // WEBRTC_OMX_H264_CODEC_H_
diff --git a/media/webrtc/signaling/src/media/CSFAudioControlWrapper.cpp b/media/webrtc/signaling/src/media/CSFAudioControlWrapper.cpp
new file mode 100644
index 000000000..87ca396b7
--- /dev/null
+++ b/media/webrtc/signaling/src/media/CSFAudioControlWrapper.cpp
@@ -0,0 +1,149 @@
+/* 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 "CSFLog.h"
+#include "CSFAudioControlWrapper.h"
+
+static const char* logTag = "VcmSipccBinding";
+
+namespace CSF {
+
+ std::vector<std::string> AudioControlWrapper::getRecordingDevices()
+ {
+ if (_realAudioControl != nullptr)
+ {
+ return _realAudioControl->getRecordingDevices();
+ }
+ else
+ {
+ CSFLogWarn( logTag, "Attempt to getRecordingDevices for expired audio control");
+ std::vector<std::string> vec;
+ return vec;
+ }
+ }
+
+ std::vector<std::string> AudioControlWrapper::getPlayoutDevices()
+ {
+ if (_realAudioControl != nullptr)
+ {
+ return _realAudioControl->getPlayoutDevices();
+ }
+ else
+ {
+ CSFLogWarn( logTag, "Attempt to getPlayoutDevices for expired audio control");
+ std::vector<std::string> vec;
+ return vec;
+ }
+ }
+
+ std::string AudioControlWrapper::getRecordingDevice()
+ {
+ if (_realAudioControl != nullptr)
+ {
+ return _realAudioControl->getRecordingDevice();
+ }
+ else
+ {
+ CSFLogWarn( logTag, "Attempt to getRecordingDevice for expired audio control");
+ return "";
+ }
+ }
+
+ std::string AudioControlWrapper::getPlayoutDevice()
+ {
+ if (_realAudioControl != nullptr)
+ {
+ return _realAudioControl->getPlayoutDevice();
+ }
+ else
+ {
+ CSFLogWarn( logTag, "Attempt to getPlayoutDevice for expired audio control");
+ return "";
+ }
+ }
+
+ bool AudioControlWrapper::setRecordingDevice( const std::string& name )
+ {
+ if (_realAudioControl != nullptr)
+ {
+ return _realAudioControl->setRecordingDevice(name);
+ }
+ else
+ {
+ CSFLogWarn( logTag, "Attempt to setRecordingDevice to %s for expired audio control",
+ name.c_str());
+ return false;
+ }
+ }
+
+ bool AudioControlWrapper::setPlayoutDevice( const std::string& name )
+ {
+ if (_realAudioControl != nullptr)
+ {
+ return _realAudioControl->setPlayoutDevice(name);
+ }
+ else
+ {
+ CSFLogWarn( logTag, "Attempt to setPlayoutDevice to %s for expired audio control",
+ name.c_str());
+ return false;
+ }
+ }
+
+ bool AudioControlWrapper::setDefaultVolume( int volume )
+ {
+ if (_realAudioControl != nullptr)
+ {
+ return _realAudioControl->setDefaultVolume(volume);
+ }
+ else
+ {
+ CSFLogWarn( logTag, "Attempt to setDefaultVolume for expired audio control");
+ return false;
+ }
+ }
+
+ int AudioControlWrapper::getDefaultVolume()
+ {
+ if (_realAudioControl != nullptr)
+ {
+ return _realAudioControl->getDefaultVolume();
+ }
+ else
+ {
+ CSFLogWarn( logTag, "Attempt to getDefaultVolume for expired audio control");
+ return -1;
+ }
+ }
+
+ bool AudioControlWrapper::setRingerVolume( int volume )
+ {
+ if (_realAudioControl != nullptr)
+ {
+ return _realAudioControl->setRingerVolume(volume);
+ }
+ else
+ {
+ CSFLogWarn( logTag, "Attempt to setRingerVolume for expired audio control");
+ return false;
+ }
+ }
+
+ int AudioControlWrapper::getRingerVolume()
+ {
+ if (_realAudioControl != nullptr)
+ {
+ return _realAudioControl->getRingerVolume();
+ }
+ else
+ {
+ CSFLogWarn( logTag, "Attempt to getRingerVolume for expired audio control");
+ return -1;
+ }
+ }
+
+ AudioControlWrapper::~AudioControlWrapper()
+ {
+ }
+}
diff --git a/media/webrtc/signaling/src/media/CSFAudioControlWrapper.h b/media/webrtc/signaling/src/media/CSFAudioControlWrapper.h
new file mode 100644
index 000000000..0faccbd0d
--- /dev/null
+++ b/media/webrtc/signaling/src/media/CSFAudioControlWrapper.h
@@ -0,0 +1,42 @@
+/* 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/. */
+
+#pragma once
+
+#include "mozilla/RefPtr.h"
+#include "CC_Common.h"
+#include "CSFAudioControl.h"
+
+namespace CSF
+{
+ DECLARE_NS_PTR(AudioControlWrapper)
+ class ECC_API AudioControlWrapper : public AudioControl
+ {
+ public:
+ // device names are in UTF-8 encoding
+
+ explicit AudioControlWrapper(AudioControl * audioControl){_realAudioControl = audioControl;};
+ virtual std::vector<std::string> getRecordingDevices();
+ virtual std::vector<std::string> getPlayoutDevices();
+
+ virtual std::string getRecordingDevice();
+ virtual std::string getPlayoutDevice();
+
+ virtual bool setRecordingDevice( const std::string& name );
+ virtual bool setPlayoutDevice( const std::string& name );
+
+ virtual bool setDefaultVolume( int volume );
+ virtual int getDefaultVolume();
+
+ virtual bool setRingerVolume( int volume );
+ virtual int getRingerVolume();
+
+ virtual void setAudioControl(AudioControl * audioControl){_realAudioControl = audioControl;};
+
+ private:
+ virtual ~AudioControlWrapper();
+
+ RefPtr<AudioControl> _realAudioControl;
+ };
+};
diff --git a/media/webrtc/signaling/src/media/CSFAudioTermination.h b/media/webrtc/signaling/src/media/CSFAudioTermination.h
new file mode 100644
index 000000000..25bc0c095
--- /dev/null
+++ b/media/webrtc/signaling/src/media/CSFAudioTermination.h
@@ -0,0 +1,117 @@
+/* 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/. */
+
+#ifndef CSFAUDIOMEDIATERMINATION_H_
+#define CSFAUDIOMEDIATERMINATION_H_
+
+#include <CSFMediaTermination.h>
+
+typedef enum
+{
+ AudioCodecMask_G711 = 1,
+ AudioCodecMask_LINEAR = 2,
+ AudioCodecMask_G722 = 4,
+ AudioCodecMask_iLBC = 16,
+ AudioCodecMask_iSAC = 32
+
+} AudioCodecMask;
+
+typedef enum
+{
+ RingMode_INSIDE_RING,
+ RingMode_OUTSIDE_RING,
+ RingMode_FEATURE_RING,
+ RingMode_BELLCORE_DR1,
+ RingMode_BELLCORE_DR2,
+ RingMode_BELLCORE_DR3,
+ RingMode_BELLCORE_DR4,
+ RingMode_BELLCORE_DR5,
+ RingMode_FLASHONLY_RING,
+ RingMode_PRECEDENCE_RING
+
+} RingMode;
+
+typedef enum
+{
+ ToneType_INSIDE_DIAL_TONE,
+ ToneType_OUTSIDE_DIAL_TONE,
+ ToneType_LINE_BUSY_TONE,
+ ToneType_ALERTING_TONE,
+ ToneType_BUSY_VERIFY_TONE,
+ ToneType_STUTTER_TONE,
+ ToneType_MSG_WAITING_TONE,
+ ToneType_REORDER_TONE,
+ ToneType_CALL_WAITING_TONE,
+ ToneType_CALL_WAITING_2_TONE,
+ ToneType_CALL_WAITING_3_TONE,
+ ToneType_CALL_WAITING_4_TONE,
+ ToneType_HOLD_TONE,
+ ToneType_CONFIRMATION_TONE,
+ ToneType_PERMANENT_SIGNAL_TONE,
+ ToneType_REMINDER_RING_TONE,
+ ToneType_NO_TONE,
+ ToneType_ZIP_ZIP,
+ ToneType_ZIP,
+ ToneType_BEEP_BONK,
+ ToneType_RECORDERWARNING_TONE,
+ ToneType_RECORDERDETECTED_TONE,
+ ToneType_MONITORWARNING_TONE,
+ ToneType_SECUREWARNING_TONE
+
+} ToneType;
+
+typedef enum
+{
+ ToneDirection_PLAY_TONE_TO_EAR = 1,
+ ToneDirection_PLAY_TONE_TO_NET = 2,
+ ToneDirection_PLAY_TONE_TO_ALL = 3
+
+} ToneDirection;
+
+typedef enum
+{
+ AudioPayloadType_G711ALAW64K = 2,
+ AudioPayloadType_G711ALAW56K = 3,
+ AudioPayloadType_G711ULAW64K = 4,
+ AudioPayloadType_G711ULAW56K = 5,
+ AudioPayloadType_G722_64K = 6,
+ AudioPayloadType_G722_56K = 7,
+ AudioPayloadType_G722_48K = 8,
+ AudioPayloadType_RFC2833 = 38,
+ AudioPayloadType_ILBC20 = 39,
+ AudioPayloadType_ILBC30 = 40,
+ AudioPayloadType_ISAC = 41,
+ AudioPayloadType_OPUS = 109
+
+} AudioPayloadType;
+
+#if __cplusplus
+
+namespace CSF
+{
+ //AudioTermination adds to the core MediaTermination
+ class AudioTermination : public MediaTermination
+ {
+ public:
+ virtual int toneStart ( ToneType type, ToneDirection direction, int alertInfo, int groupId, int streamId, bool useBackup ) = 0;
+ virtual int toneStop ( ToneType type, int groupId, int streamId ) = 0;
+ virtual int ringStart ( int lineId, RingMode mode, bool once ) = 0;
+ virtual int ringStop ( int lineId ) = 0;
+
+ virtual int sendDtmf ( int streamId, int digit ) = 0;
+ virtual bool mute ( int streamId, bool mute ) = 0;
+ virtual bool isMuted ( int streamId ) = 0;
+
+ virtual bool setVolume ( int streamId, int volume ) = 0;
+ virtual int getVolume ( int streamId ) = 0;
+
+ virtual void setVADEnabled (bool vadEnabled) = 0;
+
+ };
+
+} // namespace
+
+#endif // __cplusplus
+
+#endif /* CSFAUDIOMEDIATERMINATION_H_ */
diff --git a/media/webrtc/signaling/src/media/CSFMediaProvider.h b/media/webrtc/signaling/src/media/CSFMediaProvider.h
new file mode 100644
index 000000000..d61f8c067
--- /dev/null
+++ b/media/webrtc/signaling/src/media/CSFMediaProvider.h
@@ -0,0 +1,54 @@
+/* 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/. */
+
+#ifndef CSFMEDIAPROVIDER_H_
+#define CSFMEDIAPROVIDER_H_
+
+#if __cplusplus
+
+#include <string>
+
+namespace CSF
+{
+ class AudioControl;
+ class VideoControl;
+ class AudioTermination;
+ class VideoTermination;
+ class MediaProviderObserver;
+
+
+ class MediaProvider
+ {
+ public:
+ static MediaProvider* create( );///factory method for all MediaProvider derived types (ctor is protected).
+ virtual ~MediaProvider() = 0;
+
+ virtual int init() = 0;
+ virtual void shutdown() = 0;
+
+ virtual AudioControl* getAudioControl() = 0;
+ virtual VideoControl* getVideoControl() = 0;
+ virtual AudioTermination* getAudioTermination() = 0;
+ virtual VideoTermination* getVideoTermination() = 0;
+
+ virtual void addMediaProviderObserver( MediaProviderObserver* observer ) = 0;
+
+ protected:
+ MediaProvider() {};
+ };
+
+ class MediaProviderObserver
+ {
+ public:
+ virtual void onVideoModeChanged( bool enable ) {}
+ virtual void onKeyFrameRequested( int callId ) {}
+ virtual void onMediaLost( int callId ) {}
+ virtual void onMediaRestored( int callId ) {}
+ };
+
+} // namespace
+
+#endif // __cplusplus
+
+#endif /* CSFMEDIAPROVIDER_H_ */
diff --git a/media/webrtc/signaling/src/media/CSFMediaTermination.h b/media/webrtc/signaling/src/media/CSFMediaTermination.h
new file mode 100644
index 000000000..1636c6c50
--- /dev/null
+++ b/media/webrtc/signaling/src/media/CSFMediaTermination.h
@@ -0,0 +1,55 @@
+/* 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/. */
+
+#ifndef CSFMEDIATERMINATION_H_
+#define CSFMEDIATERMINATION_H_
+
+// definitions shared by audio and video
+
+typedef enum
+{
+ CodecRequestType_DECODEONLY,
+ CodecRequestType_ENCODEONLY,
+ CodecRequestType_FULLDUPLEX,
+ CodecRequestType_IGNORE,
+
+} CodecRequestType;
+
+typedef enum
+{
+ EncryptionAlgorithm_NONE,
+ EncryptionAlgorithm_AES_128_COUNTER
+
+} EncryptionAlgorithm;
+
+#if __cplusplus
+
+namespace CSF
+{
+ class MediaTermination
+ {
+ public:
+ virtual int getCodecList( CodecRequestType requestType ) = 0;
+
+ virtual int rxAlloc ( int groupId, int streamId, int requestedPort ) = 0;
+ virtual int rxOpen ( int groupId, int streamId, int requestedPort, int listenIp, bool isMulticast ) = 0;
+ virtual int rxStart ( int groupId, int streamId, int payloadType, int packPeriod, int localPort, int rfc2833PayloadType,
+ EncryptionAlgorithm algorithm, unsigned char* key, int keyLen, unsigned char* salt, int saltLen, int mode, int party ) = 0;
+ virtual void rxClose ( int groupId, int streamId ) = 0;
+ virtual void rxRelease ( int groupId, int streamId, int port ) = 0;
+
+ virtual int txStart ( int groupId, int streamId, int payloadType, int packPeriod, bool vad, short tos,
+ char* remoteIpAddr, int remotePort, int rfc2833PayloadType, EncryptionAlgorithm algorithm,
+ unsigned char* key, int keyLen, unsigned char* salt, int saltLen, int mode, int party ) = 0;
+ virtual void txClose ( int groupId, int streamId ) = 0;
+
+ virtual void setLocalIP ( const char* addr ) = 0;
+ virtual void setMediaPorts ( int startPort, int endPort ) = 0;
+ virtual void setDSCPValue ( int value ) = 0;
+ };
+} // namespace
+
+#endif // __cplusplus
+
+#endif /* CSFMEDIATERMINATION_H_ */
diff --git a/media/webrtc/signaling/src/media/CSFToneDefinitions.h b/media/webrtc/signaling/src/media/CSFToneDefinitions.h
new file mode 100644
index 000000000..2fe6f879d
--- /dev/null
+++ b/media/webrtc/signaling/src/media/CSFToneDefinitions.h
@@ -0,0 +1,137 @@
+/* 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/. */
+
+/* Tone Coefficients and YN_2 values */
+/* Based on 8kHz sampling rate */
+#define MILLISECONDS_TO_SAMPLES(PERIOD) (short)((PERIOD) << 3)
+
+#define TGN_COEF_300 (short)31863
+#define TGN_COEF_350 (short)31538
+#define TGN_COEF_425 (short)30959
+#define TGN_COEF_440 (short)30831
+#define TGN_COEF_450 (short)30743
+#define TGN_COEF_480 (short)30467
+#define TGN_COEF_500 (short)30274
+#define TGN_COEF_548 (short)29780
+#define TGN_COEF_600 (short)29197
+#define TGN_COEF_620 (short)28959
+#define TGN_COEF_697 (short)27980
+#define TGN_COEF_770 (short)26956
+#define TGN_COEF_852 (short)25701
+#define TGN_COEF_941 (short)24219
+#define TGN_COEF_1209 (short)19073
+#define TGN_COEF_1336 (short)16325
+#define TGN_COEF_1400 (short)14876
+#define TGN_COEF_1477 (short)13085
+#define TGN_COEF_1633 (short)9315
+#define TGN_COEF_1000 (short)23170
+#define TGN_COEF_1MW (short)23098
+#define TGN_COEF_1MW_neg15dBm (short)23098
+
+#define TGN_YN_2_300 (short)-840
+#define TGN_YN_2_350 (short)-814
+#define TGN_YN_2_425 (short)-1966
+#define TGN_YN_2_440 (short)-2032
+#define TGN_YN_2_450 (short)-1384
+#define TGN_YN_2_480 (short)-1104
+#define TGN_YN_2_500 (short)-1148
+#define TGN_YN_2_548 (short)-1252
+#define TGN_YN_2_600 (short)-2270
+#define TGN_YN_2_620 (short)-1404
+#define TGN_YN_2_697 (short)-1561
+#define TGN_YN_2_770 (short)-1706
+#define TGN_YN_2_852 (short)-1861
+#define TGN_YN_2_941 (short)-2021
+#define TGN_YN_2_1209 (short)-2439
+#define TGN_YN_2_1336 (short)-2601
+#define TGN_YN_2_1400 (short)-5346 //tone level=-11.61 dBm0, same as CallWaiting CSCsd65600
+#define TGN_YN_2_1477 (short)-2750
+#define TGN_YN_2_1633 (short)-2875
+#define TGN_YN_2_1000 (short)-1414
+#define TGN_YN_2_1MW (short)-16192
+#define TGN_YN_2_1MW_neg15dBm (short)-2879
+
+// for MLPP tones
+#define TGN_COEF_440_PREC_RB (short)30831
+#define TGN_COEF_480_PREC_RB (short)30467
+#define TGN_COEF_440_PREEMP (short)30831
+#define TGN_COEF_620_PREEMP (short)28959
+#define TGN_COEF_440_PREC_CW (short)30831
+
+#define TGN_YN_2_440_PREC_RB (short)-1016
+#define TGN_YN_2_480_PREC_RB (short)-1104
+#define TGN_YN_2_440_PREEMP (short)-1016
+#define TGN_YN_2_620_PREEMP (short)-1404
+#define TGN_YN_2_440_PREC_CW (short)-1016
+
+
+/* Based on 16kHz sampling rate */
+/*
+#define MILLISECONDS_TO_SAMPLES(PERIOD) ((PERIOD) << 4)
+*/
+
+/* Tone Coefficients and YN_2 values */
+/* Based on 16kHz sampling rate */
+/*
+#define TGN_COEF_350 (short)32459
+#define TGN_COEF_440 (short)32280
+#define TGN_COEF_450 (short)32258
+#define TGN_COEF_480 (short)32188
+#define TGN_COEF_500 (short)32138
+#define TGN_COEF_548 (short)32012
+#define TGN_COEF_600 (short)31863
+#define TGN_COEF_620 (short)31802
+#define TGN_COEF_697 (short)31548
+#define TGN_COEF_770 (short)31281
+#define TGN_COEF_852 (short)30951
+#define TGN_COEF_941 (short)30556
+#define TGN_COEF_1209 (short)29144
+#define TGN_COEF_1336 (short)28361
+#define TGN_COEF_1477 (short)27409
+#define TGN_COEF_1633 (short)26258
+#define TGN_COEF_1000 (short)30274
+#define TGN_COEF_1MW (short)30254
+#define TGN_COEF_1MW_neg15dBm (short)30254
+
+#define TGN_YN_2_350 (short)-410
+#define TGN_YN_2_440 (short)-1031
+#define TGN_YN_2_450 (short)-702
+#define TGN_YN_2_480 (short)-561
+#define TGN_YN_2_500 (short)-584
+#define TGN_YN_2_548 (short)-640
+#define TGN_YN_2_600 (short)-1166
+#define TGN_YN_2_620 (short)-722
+#define TGN_YN_2_697 (short)-810
+#define TGN_YN_2_770 (short)-892
+#define TGN_YN_2_852 (short)-984
+#define TGN_YN_2_941 (short)-1083
+#define TGN_YN_2_1209 (short)-1370
+#define TGN_YN_2_1336 (short)-1502
+#define TGN_YN_2_1477 (short)-1643
+#define TGN_YN_2_1633 (short)-1794
+#define TGN_YN_2_1000 (short)-764
+#define TGN_YN_2_1MW (short)-8768
+#define TGN_YN_2_1MW_neg15dBm (short)-1558
+
+// for MLPP tones
+#define TGN_COEF_440_PREC_RB (short)32280
+#define TGN_COEF_480_PREC_RB (short)32188
+#define TGN_COEF_440_PREEMP (short)32280
+#define TGN_COEF_620_PREEMP (short)31802
+#define TGN_COEF_440_PREC_CW (short)32280
+
+#define TGN_YN_2_440_PREC_RB (short)-515
+#define TGN_YN_2_480_PREC_RB (short)-561
+#define TGN_YN_2_440_PREEMP (short)-515
+#define TGN_YN_2_620_PREEMP (short)-722
+#define TGN_YN_2_440_PREC_CW (short)-515
+*/
+
+#define BEEP_REC_ON MILLISECONDS_TO_SAMPLES(500)
+#define BEEP_REC_OFF MILLISECONDS_TO_SAMPLES((15000 - 500) / 2)
+#define BEEP_MON_ON1 MILLISECONDS_TO_SAMPLES(1500)
+#define BEEP_MON_OFF1 MILLISECONDS_TO_SAMPLES(8000)
+#define BEEP_MON_ON2 MILLISECONDS_TO_SAMPLES(500)
+#define BEEP_MON_OFF2 MILLISECONDS_TO_SAMPLES(8000)
+
diff --git a/media/webrtc/signaling/src/media/CSFVideoCallMediaControl.h b/media/webrtc/signaling/src/media/CSFVideoCallMediaControl.h
new file mode 100644
index 000000000..67c35ed7b
--- /dev/null
+++ b/media/webrtc/signaling/src/media/CSFVideoCallMediaControl.h
@@ -0,0 +1,28 @@
+/* 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/. */
+
+#ifndef CSFVIDEOCALLMEDIACONTROL_H_
+#define CSFVIDEOCALLMEDIACONTROL_H_
+
+#include <csf/CSFVideoMediaControl.h>
+
+#if __cplusplus
+
+namespace CSF
+{
+ class VideoCallMediaControl
+ {
+ public:
+ virtual void setVideoMode( VideoEnableMode mode ) = 0;
+
+ // window type is platform-specific
+ virtual void setRemoteWindow( VideoWindowHandle window ) = 0;
+ virtual void showRemoteWindow( bool show ) = 0;
+ };
+
+} // namespace
+
+#endif // __cplusplus
+
+#endif /* CSFVIDEOCALLMEDIACONTROL_H_ */
diff --git a/media/webrtc/signaling/src/media/CSFVideoControlWrapper.h b/media/webrtc/signaling/src/media/CSFVideoControlWrapper.h
new file mode 100644
index 000000000..226a7efae
--- /dev/null
+++ b/media/webrtc/signaling/src/media/CSFVideoControlWrapper.h
@@ -0,0 +1,48 @@
+/* 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/. */
+
+#ifndef CSFVIDEOCONTROLWRAPPER_H_
+#define CSFVIDEOCONTROLWRAPPER_H_
+
+#include "CC_Common.h"
+#include "CSFVideoControl.h"
+
+#if __cplusplus
+
+#include <string>
+#include <vector>
+
+namespace CSF
+{
+ DECLARE_NS_PTR(VideoControlWrapper)
+ typedef void *VideoWindowHandle;
+
+ class ECC_API VideoControlWrapper : public VideoControl
+ {
+ public:
+ explicit VideoControlWrapper(VideoControl * videoControl){_realVideoControl = videoControl;};
+
+ virtual void setVideoMode( bool enable );
+
+ // window type is platform-specific
+ virtual void setPreviewWindow( VideoWindowHandle window, int top, int left, int bottom, int right, RenderScaling style );
+ virtual void showPreviewWindow( bool show );
+
+ // device names are in UTF-8 encoding
+ virtual std::vector<std::string> getCaptureDevices();
+
+ virtual std::string getCaptureDevice();
+ virtual bool setCaptureDevice( const std::string& name );
+
+ virtual void setVideoControl( VideoControl * videoControl ){_realVideoControl = videoControl;};
+
+ private:
+ VideoControl * _realVideoControl;
+ };
+
+} // namespace
+
+#endif // __cplusplus
+
+#endif /* CSFVIDEOCONTROLWRAPPER_H_ */
diff --git a/media/webrtc/signaling/src/media/CSFVideoTermination.h b/media/webrtc/signaling/src/media/CSFVideoTermination.h
new file mode 100644
index 000000000..62fcf8569
--- /dev/null
+++ b/media/webrtc/signaling/src/media/CSFVideoTermination.h
@@ -0,0 +1,36 @@
+/* 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/. */
+
+#ifndef CSFVIDEOMEDIATERMINATION_H_
+#define CSFVIDEOMEDIATERMINATION_H_
+
+#include <CSFMediaTermination.h>
+#include <CSFVideoControl.h>
+
+typedef enum
+{
+ VideoCodecMask_H264 = 1,
+ VideoCodecMask_H263 = 2
+
+} VideoCodecMask;
+
+#if __cplusplus
+
+namespace CSF
+{
+ class VideoTermination : public MediaTermination
+ {
+ public:
+ virtual void setRemoteWindow( int streamId, VideoWindowHandle window) = 0;
+ virtual int setExternalRenderer( int streamId, VideoFormat videoFormat, ExternalRendererHandle render) = 0;
+ virtual void sendIFrame ( int streamId ) = 0;
+ virtual bool mute ( int streamId, bool mute ) = 0;
+ virtual void setAudioStreamId( int streamId) = 0;
+ };
+
+} // namespace
+
+#endif // __cplusplus
+
+#endif /* CSFVIDEOMEDIATERMINATION_H_ */
diff --git a/media/webrtc/signaling/src/media/cip_mmgr_mediadefinitions.h b/media/webrtc/signaling/src/media/cip_mmgr_mediadefinitions.h
new file mode 100644
index 000000000..7d1706ce2
--- /dev/null
+++ b/media/webrtc/signaling/src/media/cip_mmgr_mediadefinitions.h
@@ -0,0 +1,125 @@
+/* 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/. */
+
+#ifndef _Included_cip_mmgr_MediaDefinitions
+#define _Included_cip_mmgr_MediaDefinitions
+#ifdef __cplusplus
+extern "C" {
+#endif
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_NONSTANDARD
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_NONSTANDARD 1L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_G711ALAW64K
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_G711ALAW64K 2L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_G711ALAW56K
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_G711ALAW56K 3L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_G711ULAW64K
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_G711ULAW64K 4L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_G711ULAW56K
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_G711ULAW56K 5L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_G722_64K
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_G722_64K 6L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_G722_56K
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_G722_56K 7L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_G722_48K
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_G722_48K 8L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_G7231_5P3K
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_G7231_5P3K 9L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_G7231_6P3K
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_G7231_6P3K 10L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_G728
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_G728 11L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_G729
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_G729 12L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_G729ANNEXA
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_G729ANNEXA 13L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_IS11172AUDIOCAP
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_IS11172AUDIOCAP 14L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_IS13818AUDIOCAP
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_IS13818AUDIOCAP 15L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_G729ANNEXB
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_G729ANNEXB 16L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_G729ANNEXAWANNEXB
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_G729ANNEXAWANNEXB 17L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_GSM_FULL_RATE
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_GSM_FULL_RATE 18L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_GSM_HALF_RATE
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_GSM_HALF_RATE 19L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_GSM_ENHANCED_FULL_RATE
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_GSM_ENHANCED_FULL_RATE 20L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_WIDE_BAND_256K
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_WIDE_BAND_256K 21L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_WIDE_BAND_128K
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_WIDE_BAND_128K 22L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_DATA64
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_DATA64 23L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_DATA56
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_DATA56 24L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_GSM
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_GSM 25L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_ACTIVEVOICE
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_ACTIVEVOICE 26L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_G726_32K
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_G726_32K 27L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_G726_24K
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_G726_24K 28L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_G726_16K
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_G726_16K 29L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_H261
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_H261 30L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_H263
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_H263 31L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_T120
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_T120 32L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_H224
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_H224 33L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_PCM_44_1K_16BIT_STEREO
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_PCM_44_1K_16BIT_STEREO 34L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_PCM_44_1K_16BIT_MONO
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_PCM_44_1K_16BIT_MONO 35L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_ZORAN_VIDEO
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_ZORAN_VIDEO 36L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_LOGITECH_VIDEO
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_LOGITECH_VIDEO 37L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_RFC2833
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_RFC2833 38L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_ILBC20
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_ILBC20 39L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_ILBC30
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_ILBC30 40L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_ISAC
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_ISAC 41L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_VP8
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_VP8 42L
+#undef cip_mmgr_MediaDefinitions_MEDIA_TYPE_OPUS
+#define cip_mmgr_MediaDefinitions_MEDIA_TYPE_OPUS 109L
+
+
+#undef cip_mmgr_MediaDefinitions_BANDWIDTH_NARROWBAND
+#define cip_mmgr_MediaDefinitions_BANDWIDTH_NARROWBAND 200L
+#undef cip_mmgr_MediaDefinitions_BANDWIDTH_WIDEBAND
+#define cip_mmgr_MediaDefinitions_BANDWIDTH_WIDEBAND 201L
+
+#undef cip_mmgr_MediaDefinitions_MEDIA_RESOURCE_G711_BIT_POSITION
+#define cip_mmgr_MediaDefinitions_MEDIA_RESOURCE_G711_BIT_POSITION 1L
+#undef cip_mmgr_MediaDefinitions_MEDIA_RESOURCE_G729A_BIT_POSITION
+#define cip_mmgr_MediaDefinitions_MEDIA_RESOURCE_G729A_BIT_POSITION 2L
+#undef cip_mmgr_MediaDefinitions_MEDIA_RESOURCE_G729B_BIT_POSITION
+#define cip_mmgr_MediaDefinitions_MEDIA_RESOURCE_G729B_BIT_POSITION 4L
+#undef cip_mmgr_MediaDefinitions_MEDIA_RESOURCE_LINEAR_BIT_POSITION
+#define cip_mmgr_MediaDefinitions_MEDIA_RESOURCE_LINEAR_BIT_POSITION 8L
+#undef cip_mmgr_MediaDefinitions_MEDIA_RESOURCE_G722_BIT_POSITION
+#define cip_mmgr_MediaDefinitions_MEDIA_RESOURCE_G722_BIT_POSITION 16L
+#undef cip_mmgr_MediaDefinitions_MEDIA_RESOURCE_ILBC_BIT_POSITION
+#define cip_mmgr_MediaDefinitions_MEDIA_RESOURCE_ILBC_BIT_POSITION 32L
+
+#undef cip_mmgr_MediaDefinitions_FULLDUPLEX
+#define cip_mmgr_MediaDefinitions_FULLDUPLEX 0L
+#undef cip_mmgr_MediaDefinitions_HALFDUPLEX_DECODE
+#define cip_mmgr_MediaDefinitions_HALFDUPLEX_DECODE 1L
+#undef cip_mmgr_MediaDefinitions_HALFDUPLEX_ENCODE
+#define cip_mmgr_MediaDefinitions_HALFDUPLEX_ENCODE 2L
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/media/webrtc/signaling/src/mediapipeline/MediaPipeline.cpp b/media/webrtc/signaling/src/mediapipeline/MediaPipeline.cpp
new file mode 100644
index 000000000..586876406
--- /dev/null
+++ b/media/webrtc/signaling/src/mediapipeline/MediaPipeline.cpp
@@ -0,0 +1,2377 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+// Original author: ekr@rtfm.com
+
+#include "MediaPipeline.h"
+
+#ifndef USE_FAKE_MEDIA_STREAMS
+#include "MediaStreamGraphImpl.h"
+#endif
+
+#include <math.h>
+
+#include "nspr.h"
+#include "srtp.h"
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+#include "VideoSegment.h"
+#include "Layers.h"
+#include "LayersLogging.h"
+#include "ImageTypes.h"
+#include "ImageContainer.h"
+#include "DOMMediaStream.h"
+#include "MediaStreamTrack.h"
+#include "MediaStreamListener.h"
+#include "MediaStreamVideoSink.h"
+#include "VideoUtils.h"
+#include "VideoStreamTrack.h"
+#ifdef WEBRTC_GONK
+#include "GrallocImages.h"
+#include "mozilla/layers/GrallocTextureClient.h"
+#endif
+#endif
+
+#include "nsError.h"
+#include "AudioSegment.h"
+#include "MediaSegment.h"
+#include "MediaPipelineFilter.h"
+#include "databuffer.h"
+#include "transportflow.h"
+#include "transportlayer.h"
+#include "transportlayerdtls.h"
+#include "transportlayerice.h"
+#include "runnable_utils.h"
+#include "libyuv/convert.h"
+#include "mozilla/SharedThreadPool.h"
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+#include "mozilla/PeerIdentity.h"
+#include "mozilla/TaskQueue.h"
+#endif
+#include "mozilla/gfx/Point.h"
+#include "mozilla/gfx/Types.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/UniquePtrExtensions.h"
+#include "mozilla/Sprintf.h"
+
+#include "webrtc/common_types.h"
+#include "webrtc/common_video/interface/native_handle.h"
+#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
+#include "webrtc/video_engine/include/vie_errors.h"
+
+#include "logging.h"
+
+// Max size given stereo is 480*2*2 = 1920 (10ms of 16-bits stereo audio at
+// 48KHz)
+#define AUDIO_SAMPLE_BUFFER_MAX 480*2*2
+static_assert((WEBRTC_DEFAULT_SAMPLE_RATE/100)*sizeof(uint16_t) * 2
+ <= AUDIO_SAMPLE_BUFFER_MAX,
+ "AUDIO_SAMPLE_BUFFER_MAX is not large enough");
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::gfx;
+using namespace mozilla::layers;
+
+// Logging context
+MOZ_MTLOG_MODULE("mediapipeline")
+
+namespace mozilla {
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+class VideoConverterListener
+{
+public:
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(VideoConverterListener)
+
+ virtual void OnVideoFrameConverted(unsigned char* aVideoFrame,
+ unsigned int aVideoFrameLength,
+ unsigned short aWidth,
+ unsigned short aHeight,
+ VideoType aVideoType,
+ uint64_t aCaptureTime) = 0;
+
+ virtual void OnVideoFrameConverted(webrtc::I420VideoFrame& aVideoFrame) = 0;
+
+protected:
+ virtual ~VideoConverterListener() {}
+};
+
+// I420 buffer size macros
+#define YSIZE(x,y) ((x)*(y))
+#define CRSIZE(x,y) ((((x)+1) >> 1) * (((y)+1) >> 1))
+#define I420SIZE(x,y) (YSIZE((x),(y)) + 2 * CRSIZE((x),(y)))
+
+// An async video frame format converter.
+//
+// Input is typically a MediaStream(Track)Listener driven by MediaStreamGraph.
+//
+// We keep track of the size of the TaskQueue so we can drop frames if
+// conversion is taking too long.
+//
+// Output is passed through to all added VideoConverterListeners on a TaskQueue
+// thread whenever a frame is converted.
+class VideoFrameConverter
+{
+public:
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(VideoFrameConverter)
+
+ VideoFrameConverter()
+ : mLength(0)
+ , last_img_(-1) // -1 is not a guaranteed invalid serial. See bug 1262134.
+ , disabled_frame_sent_(false)
+#ifdef DEBUG
+ , mThrottleCount(0)
+ , mThrottleRecord(0)
+#endif
+ , mMutex("VideoFrameConverter")
+ {
+ MOZ_COUNT_CTOR(VideoFrameConverter);
+
+ RefPtr<SharedThreadPool> pool =
+ SharedThreadPool::Get(NS_LITERAL_CSTRING("VideoFrameConverter"));
+
+ mTaskQueue = MakeAndAddRef<TaskQueue>(pool.forget());
+ }
+
+ void QueueVideoChunk(VideoChunk& aChunk, bool aForceBlack)
+ {
+ if (aChunk.IsNull()) {
+ return;
+ }
+
+ // We get passed duplicate frames every ~10ms even with no frame change.
+ int32_t serial = aChunk.mFrame.GetImage()->GetSerial();
+ if (serial == last_img_) {
+ return;
+ }
+ last_img_ = serial;
+
+ // A throttling limit of 1 allows us to convert 2 frames concurrently.
+ // It's short enough to not build up too significant a delay, while
+ // giving us a margin to not cause some machines to drop every other frame.
+ const int32_t queueThrottlingLimit = 1;
+ if (mLength > queueThrottlingLimit) {
+ MOZ_MTLOG(ML_DEBUG, "VideoFrameConverter " << this << " queue is full." <<
+ " Throttling by throwing away a frame.");
+#ifdef DEBUG
+ ++mThrottleCount;
+ mThrottleRecord = std::max(mThrottleCount, mThrottleRecord);
+#endif
+ return;
+ }
+
+#ifdef DEBUG
+ if (mThrottleCount > 0) {
+ auto level = ML_DEBUG;
+ if (mThrottleCount > 5) {
+ // Log at a higher level when we have large drops.
+ level = ML_INFO;
+ }
+ MOZ_MTLOG(level, "VideoFrameConverter " << this << " stopped" <<
+ " throttling after throwing away " << mThrottleCount <<
+ " frames. Longest throttle so far was " <<
+ mThrottleRecord << " frames.");
+ mThrottleCount = 0;
+ }
+#endif
+
+ bool forceBlack = aForceBlack || aChunk.mFrame.GetForceBlack();
+
+ if (forceBlack) {
+ // Reset the last-img check.
+ // -1 is not a guaranteed invalid serial. See bug 1262134.
+ last_img_ = -1;
+
+ if (disabled_frame_sent_) {
+ // After disabling we just pass one black frame to the encoder.
+ // Allocating and setting it to black steals some performance
+ // that can be avoided. We don't handle resolution changes while
+ // disabled for now.
+ return;
+ }
+
+ disabled_frame_sent_ = true;
+ } else {
+ disabled_frame_sent_ = false;
+ }
+
+ ++mLength; // Atomic
+
+ nsCOMPtr<nsIRunnable> runnable =
+ NewRunnableMethod<StorensRefPtrPassByPtr<Image>, bool>(
+ this, &VideoFrameConverter::ProcessVideoFrame,
+ aChunk.mFrame.GetImage(), forceBlack);
+ mTaskQueue->Dispatch(runnable.forget());
+ }
+
+ void AddListener(VideoConverterListener* aListener)
+ {
+ MutexAutoLock lock(mMutex);
+
+ MOZ_ASSERT(!mListeners.Contains(aListener));
+ mListeners.AppendElement(aListener);
+ }
+
+ bool RemoveListener(VideoConverterListener* aListener)
+ {
+ MutexAutoLock lock(mMutex);
+
+ return mListeners.RemoveElement(aListener);
+ }
+
+ void Shutdown()
+ {
+ mTaskQueue->BeginShutdown();
+ mTaskQueue->AwaitShutdownAndIdle();
+ }
+
+protected:
+ virtual ~VideoFrameConverter()
+ {
+ MOZ_COUNT_DTOR(VideoFrameConverter);
+ }
+
+ void VideoFrameConverted(unsigned char* aVideoFrame,
+ unsigned int aVideoFrameLength,
+ unsigned short aWidth,
+ unsigned short aHeight,
+ VideoType aVideoType,
+ uint64_t aCaptureTime)
+ {
+ MutexAutoLock lock(mMutex);
+
+ for (RefPtr<VideoConverterListener>& listener : mListeners) {
+ listener->OnVideoFrameConverted(aVideoFrame, aVideoFrameLength,
+ aWidth, aHeight, aVideoType, aCaptureTime);
+ }
+ }
+
+ void VideoFrameConverted(webrtc::I420VideoFrame& aVideoFrame)
+ {
+ MutexAutoLock lock(mMutex);
+
+ for (RefPtr<VideoConverterListener>& listener : mListeners) {
+ listener->OnVideoFrameConverted(aVideoFrame);
+ }
+ }
+
+ void ProcessVideoFrame(Image* aImage, bool aForceBlack)
+ {
+ --mLength; // Atomic
+ MOZ_ASSERT(mLength >= 0);
+
+ if (aForceBlack) {
+ IntSize size = aImage->GetSize();
+ uint32_t yPlaneLen = YSIZE(size.width, size.height);
+ uint32_t cbcrPlaneLen = 2 * CRSIZE(size.width, size.height);
+ uint32_t length = yPlaneLen + cbcrPlaneLen;
+
+ // Send a black image.
+ auto pixelData = MakeUniqueFallible<uint8_t[]>(length);
+ if (pixelData) {
+ // YCrCb black = 0x10 0x80 0x80
+ memset(pixelData.get(), 0x10, yPlaneLen);
+ // Fill Cb/Cr planes
+ memset(pixelData.get() + yPlaneLen, 0x80, cbcrPlaneLen);
+
+ MOZ_MTLOG(ML_DEBUG, "Sending a black video frame");
+ VideoFrameConverted(pixelData.get(), length, size.width, size.height,
+ mozilla::kVideoI420, 0);
+ }
+ return;
+ }
+
+ ImageFormat format = aImage->GetFormat();
+#ifdef WEBRTC_GONK
+ GrallocImage* nativeImage = aImage->AsGrallocImage();
+ if (nativeImage) {
+ android::sp<android::GraphicBuffer> graphicBuffer = nativeImage->GetGraphicBuffer();
+ int pixelFormat = graphicBuffer->getPixelFormat(); /* PixelFormat is an enum == int */
+ mozilla::VideoType destFormat;
+ switch (pixelFormat) {
+ case HAL_PIXEL_FORMAT_YV12:
+ // all android must support this
+ destFormat = mozilla::kVideoYV12;
+ break;
+ case GrallocImage::HAL_PIXEL_FORMAT_YCbCr_420_SP:
+ destFormat = mozilla::kVideoNV21;
+ break;
+ case GrallocImage::HAL_PIXEL_FORMAT_YCbCr_420_P:
+ destFormat = mozilla::kVideoI420;
+ break;
+ default:
+ // XXX Bug NNNNNNN
+ // use http://dxr.mozilla.org/mozilla-central/source/content/media/omx/I420ColorConverterHelper.cpp
+ // to convert unknown types (OEM-specific) to I420
+ MOZ_MTLOG(ML_ERROR, "Un-handled GRALLOC buffer type:" << pixelFormat);
+ MOZ_CRASH();
+ }
+ void *basePtr;
+ graphicBuffer->lock(android::GraphicBuffer::USAGE_SW_READ_MASK, &basePtr);
+ uint32_t width = graphicBuffer->getWidth();
+ uint32_t height = graphicBuffer->getHeight();
+ // XXX gralloc buffer's width and stride could be different depends on implementations.
+
+ if (destFormat != mozilla::kVideoI420) {
+ unsigned char *video_frame = static_cast<unsigned char*>(basePtr);
+ webrtc::I420VideoFrame i420_frame;
+ int stride_y = width;
+ int stride_uv = (width + 1) / 2;
+ int target_width = width;
+ int target_height = height;
+ if (i420_frame.CreateEmptyFrame(target_width,
+ abs(target_height),
+ stride_y,
+ stride_uv, stride_uv) < 0) {
+ MOZ_ASSERT(false, "Can't allocate empty i420frame");
+ return;
+ }
+ webrtc::VideoType commonVideoType =
+ webrtc::RawVideoTypeToCommonVideoVideoType(
+ static_cast<webrtc::RawVideoType>((int)destFormat));
+ if (ConvertToI420(commonVideoType, video_frame, 0, 0, width, height,
+ I420SIZE(width, height), webrtc::kVideoRotation_0,
+ &i420_frame)) {
+ MOZ_ASSERT(false, "Can't convert video type for sending to I420");
+ return;
+ }
+ i420_frame.set_ntp_time_ms(0);
+ VideoFrameConverted(i420_frame);
+ } else {
+ VideoFrameConverted(static_cast<unsigned char*>(basePtr),
+ I420SIZE(width, height),
+ width,
+ height,
+ destFormat, 0);
+ }
+ graphicBuffer->unlock();
+ return;
+ } else
+#endif
+ if (format == ImageFormat::PLANAR_YCBCR) {
+ // Cast away constness b/c some of the accessors are non-const
+ PlanarYCbCrImage* yuv = const_cast<PlanarYCbCrImage *>(
+ static_cast<const PlanarYCbCrImage *>(aImage));
+
+ const PlanarYCbCrData *data = yuv->GetData();
+ if (data) {
+ uint8_t *y = data->mYChannel;
+ uint8_t *cb = data->mCbChannel;
+ uint8_t *cr = data->mCrChannel;
+ int32_t yStride = data->mYStride;
+ int32_t cbCrStride = data->mCbCrStride;
+ uint32_t width = yuv->GetSize().width;
+ uint32_t height = yuv->GetSize().height;
+
+ webrtc::I420VideoFrame i420_frame;
+ int rv = i420_frame.CreateFrame(y, cb, cr, width, height,
+ yStride, cbCrStride, cbCrStride,
+ webrtc::kVideoRotation_0);
+ if (rv != 0) {
+ NS_ERROR("Creating an I420 frame failed");
+ return;
+ }
+
+ MOZ_MTLOG(ML_DEBUG, "Sending an I420 video frame");
+ VideoFrameConverted(i420_frame);
+ return;
+ }
+ }
+
+ RefPtr<SourceSurface> surf = aImage->GetAsSourceSurface();
+ if (!surf) {
+ MOZ_MTLOG(ML_ERROR, "Getting surface from " << Stringify(format) << " image failed");
+ return;
+ }
+
+ RefPtr<DataSourceSurface> data = surf->GetDataSurface();
+ if (!data) {
+ MOZ_MTLOG(ML_ERROR, "Getting data surface from " << Stringify(format)
+ << " image with " << Stringify(surf->GetType()) << "("
+ << Stringify(surf->GetFormat()) << ") surface failed");
+ return;
+ }
+
+ IntSize size = aImage->GetSize();
+ int half_width = (size.width + 1) >> 1;
+ int half_height = (size.height + 1) >> 1;
+ int c_size = half_width * half_height;
+ int buffer_size = YSIZE(size.width, size.height) + 2 * c_size;
+ auto yuv_scoped = MakeUniqueFallible<uint8[]>(buffer_size);
+ if (!yuv_scoped) {
+ return;
+ }
+ uint8* yuv = yuv_scoped.get();
+
+ DataSourceSurface::ScopedMap map(data, DataSourceSurface::READ);
+ if (!map.IsMapped()) {
+ MOZ_MTLOG(ML_ERROR, "Reading DataSourceSurface from " << Stringify(format)
+ << " image with " << Stringify(surf->GetType()) << "("
+ << Stringify(surf->GetFormat()) << ") surface failed");
+ return;
+ }
+
+ int rv;
+ int cb_offset = YSIZE(size.width, size.height);
+ int cr_offset = cb_offset + c_size;
+ switch (surf->GetFormat()) {
+ case SurfaceFormat::B8G8R8A8:
+ case SurfaceFormat::B8G8R8X8:
+ rv = libyuv::ARGBToI420(static_cast<uint8*>(map.GetData()),
+ map.GetStride(),
+ yuv, size.width,
+ yuv + cb_offset, half_width,
+ yuv + cr_offset, half_width,
+ size.width, size.height);
+ break;
+ case SurfaceFormat::R5G6B5_UINT16:
+ rv = libyuv::RGB565ToI420(static_cast<uint8*>(map.GetData()),
+ map.GetStride(),
+ yuv, size.width,
+ yuv + cb_offset, half_width,
+ yuv + cr_offset, half_width,
+ size.width, size.height);
+ break;
+ default:
+ MOZ_MTLOG(ML_ERROR, "Unsupported RGB video format" << Stringify(surf->GetFormat()));
+ MOZ_ASSERT(PR_FALSE);
+ return;
+ }
+ if (rv != 0) {
+ MOZ_MTLOG(ML_ERROR, Stringify(surf->GetFormat()) << " to I420 conversion failed");
+ return;
+ }
+ MOZ_MTLOG(ML_DEBUG, "Sending an I420 video frame converted from " <<
+ Stringify(surf->GetFormat()));
+ VideoFrameConverted(yuv, buffer_size, size.width, size.height, mozilla::kVideoI420, 0);
+ }
+
+ Atomic<int32_t, Relaxed> mLength;
+ RefPtr<TaskQueue> mTaskQueue;
+
+ // Written and read from the queueing thread (normally MSG).
+ int32_t last_img_; // serial number of last Image
+ bool disabled_frame_sent_; // If a black frame has been sent after disabling.
+#ifdef DEBUG
+ uint32_t mThrottleCount;
+ uint32_t mThrottleRecord;
+#endif
+
+ // mMutex guards the below variables.
+ Mutex mMutex;
+ nsTArray<RefPtr<VideoConverterListener>> mListeners;
+};
+#endif
+
+// An async inserter for audio data, to avoid running audio codec encoders
+// on the MSG/input audio thread. Basically just bounces all the audio
+// data to a single audio processing/input queue. We could if we wanted to
+// use multiple threads and a TaskQueue.
+class AudioProxyThread
+{
+public:
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(AudioProxyThread)
+
+ explicit AudioProxyThread(AudioSessionConduit *aConduit)
+ : mConduit(aConduit)
+ {
+ MOZ_ASSERT(mConduit);
+ MOZ_COUNT_CTOR(AudioProxyThread);
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ // Use only 1 thread; also forces FIFO operation
+ // We could use multiple threads, but that may be dicier with the webrtc.org
+ // code. If so we'd need to use TaskQueues like the videoframe converter
+ RefPtr<SharedThreadPool> pool =
+ SharedThreadPool::Get(NS_LITERAL_CSTRING("AudioProxy"), 1);
+
+ mThread = pool.get();
+#else
+ nsCOMPtr<nsIThread> thread;
+ if (!NS_WARN_IF(NS_FAILED(NS_NewNamedThread("AudioProxy", getter_AddRefs(thread))))) {
+ mThread = thread;
+ }
+#endif
+ }
+
+ // called on mThread
+ void InternalProcessAudioChunk(
+ TrackRate rate,
+ AudioChunk& chunk,
+ bool enabled) {
+
+ // Convert to interleaved, 16-bits integer audio, with a maximum of two
+ // channels (since the WebRTC.org code below makes the assumption that the
+ // input audio is either mono or stereo).
+ uint32_t outputChannels = chunk.ChannelCount() == 1 ? 1 : 2;
+ const int16_t* samples = nullptr;
+ UniquePtr<int16_t[]> convertedSamples;
+
+ // We take advantage of the fact that the common case (microphone directly to
+ // PeerConnection, that is, a normal call), the samples are already 16-bits
+ // mono, so the representation in interleaved and planar is the same, and we
+ // can just use that.
+ if (enabled && outputChannels == 1 && chunk.mBufferFormat == AUDIO_FORMAT_S16) {
+ samples = chunk.ChannelData<int16_t>().Elements()[0];
+ } else {
+ convertedSamples = MakeUnique<int16_t[]>(chunk.mDuration * outputChannels);
+
+ if (!enabled || chunk.mBufferFormat == AUDIO_FORMAT_SILENCE) {
+ PodZero(convertedSamples.get(), chunk.mDuration * outputChannels);
+ } else if (chunk.mBufferFormat == AUDIO_FORMAT_FLOAT32) {
+ DownmixAndInterleave(chunk.ChannelData<float>(),
+ chunk.mDuration, chunk.mVolume, outputChannels,
+ convertedSamples.get());
+ } else if (chunk.mBufferFormat == AUDIO_FORMAT_S16) {
+ DownmixAndInterleave(chunk.ChannelData<int16_t>(),
+ chunk.mDuration, chunk.mVolume, outputChannels,
+ convertedSamples.get());
+ }
+ samples = convertedSamples.get();
+ }
+
+ MOZ_ASSERT(!(rate%100)); // rate should be a multiple of 100
+
+ // Check if the rate or the number of channels has changed since the last time
+ // we came through. I realize it may be overkill to check if the rate has
+ // changed, but I believe it is possible (e.g. if we change sources) and it
+ // costs us very little to handle this case.
+
+ uint32_t audio_10ms = rate / 100;
+
+ if (!packetizer_ ||
+ packetizer_->PacketSize() != audio_10ms ||
+ packetizer_->Channels() != outputChannels) {
+ // It's ok to drop the audio still in the packetizer here.
+ packetizer_ = new AudioPacketizer<int16_t, int16_t>(audio_10ms, outputChannels);
+ }
+
+ packetizer_->Input(samples, chunk.mDuration);
+
+ while (packetizer_->PacketsAvailable()) {
+ uint32_t samplesPerPacket = packetizer_->PacketSize() *
+ packetizer_->Channels();
+ // We know that webrtc.org's code going to copy the samples down the line,
+ // so we can just use a stack buffer here instead of malloc-ing.
+ int16_t packet[AUDIO_SAMPLE_BUFFER_MAX];
+
+ packetizer_->Output(packet);
+ mConduit->SendAudioFrame(packet, samplesPerPacket, rate, 0);
+ }
+ }
+
+ void QueueAudioChunk(TrackRate rate, AudioChunk& chunk, bool enabled)
+ {
+ RUN_ON_THREAD(mThread,
+ WrapRunnable(RefPtr<AudioProxyThread>(this),
+ &AudioProxyThread::InternalProcessAudioChunk,
+ rate, chunk, enabled),
+ NS_DISPATCH_NORMAL);
+ }
+
+protected:
+ virtual ~AudioProxyThread()
+ {
+ // Conduits must be released on MainThread, and we might have the last reference
+ // We don't need to worry about runnables still trying to access the conduit, since
+ // the runnables hold a ref to AudioProxyThread.
+ NS_ReleaseOnMainThread(mConduit.forget());
+ MOZ_COUNT_DTOR(AudioProxyThread);
+ }
+
+ RefPtr<AudioSessionConduit> mConduit;
+ nsCOMPtr<nsIEventTarget> mThread;
+ // Only accessed on mThread
+ nsAutoPtr<AudioPacketizer<int16_t, int16_t>> packetizer_;
+};
+
+static char kDTLSExporterLabel[] = "EXTRACTOR-dtls_srtp";
+
+MediaPipeline::MediaPipeline(const std::string& pc,
+ Direction direction,
+ nsCOMPtr<nsIEventTarget> main_thread,
+ nsCOMPtr<nsIEventTarget> sts_thread,
+ const std::string& track_id,
+ int level,
+ RefPtr<MediaSessionConduit> conduit,
+ RefPtr<TransportFlow> rtp_transport,
+ RefPtr<TransportFlow> rtcp_transport,
+ nsAutoPtr<MediaPipelineFilter> filter)
+ : direction_(direction),
+ track_id_(track_id),
+ level_(level),
+ conduit_(conduit),
+ rtp_(rtp_transport, rtcp_transport ? RTP : MUX),
+ rtcp_(rtcp_transport ? rtcp_transport : rtp_transport,
+ rtcp_transport ? RTCP : MUX),
+ main_thread_(main_thread),
+ sts_thread_(sts_thread),
+ rtp_packets_sent_(0),
+ rtcp_packets_sent_(0),
+ rtp_packets_received_(0),
+ rtcp_packets_received_(0),
+ rtp_bytes_sent_(0),
+ rtp_bytes_received_(0),
+ pc_(pc),
+ description_(),
+ filter_(filter),
+ rtp_parser_(webrtc::RtpHeaderParser::Create()) {
+ // To indicate rtcp-mux rtcp_transport should be nullptr.
+ // Therefore it's an error to send in the same flow for
+ // both rtp and rtcp.
+ MOZ_ASSERT(rtp_transport != rtcp_transport);
+
+ // PipelineTransport() will access this->sts_thread_; moved here for safety
+ transport_ = new PipelineTransport(this);
+}
+
+MediaPipeline::~MediaPipeline() {
+ ASSERT_ON_THREAD(main_thread_);
+ MOZ_MTLOG(ML_INFO, "Destroying MediaPipeline: " << description_);
+}
+
+nsresult MediaPipeline::Init() {
+ ASSERT_ON_THREAD(main_thread_);
+
+ if (direction_ == RECEIVE) {
+ conduit_->SetReceiverTransport(transport_);
+ } else {
+ conduit_->SetTransmitterTransport(transport_);
+ }
+
+ RUN_ON_THREAD(sts_thread_,
+ WrapRunnable(
+ RefPtr<MediaPipeline>(this),
+ &MediaPipeline::Init_s),
+ NS_DISPATCH_NORMAL);
+
+ return NS_OK;
+}
+
+nsresult MediaPipeline::Init_s() {
+ ASSERT_ON_THREAD(sts_thread_);
+
+ return AttachTransport_s();
+}
+
+
+// Disconnect us from the transport so that we can cleanly destruct the
+// pipeline on the main thread. ShutdownMedia_m() must have already been
+// called
+void
+MediaPipeline::DetachTransport_s()
+{
+ ASSERT_ON_THREAD(sts_thread_);
+
+ disconnect_all();
+ transport_->Detach();
+ rtp_.Detach();
+ rtcp_.Detach();
+}
+
+nsresult
+MediaPipeline::AttachTransport_s()
+{
+ ASSERT_ON_THREAD(sts_thread_);
+ nsresult res;
+ MOZ_ASSERT(rtp_.transport_);
+ MOZ_ASSERT(rtcp_.transport_);
+ res = ConnectTransport_s(rtp_);
+ if (NS_FAILED(res)) {
+ return res;
+ }
+
+ if (rtcp_.transport_ != rtp_.transport_) {
+ res = ConnectTransport_s(rtcp_);
+ if (NS_FAILED(res)) {
+ return res;
+ }
+ }
+
+ transport_->Attach(this);
+
+ return NS_OK;
+}
+
+void
+MediaPipeline::UpdateTransport_m(int level,
+ RefPtr<TransportFlow> rtp_transport,
+ RefPtr<TransportFlow> rtcp_transport,
+ nsAutoPtr<MediaPipelineFilter> filter)
+{
+ RUN_ON_THREAD(sts_thread_,
+ WrapRunnable(
+ this,
+ &MediaPipeline::UpdateTransport_s,
+ level,
+ rtp_transport,
+ rtcp_transport,
+ filter),
+ NS_DISPATCH_NORMAL);
+}
+
+void
+MediaPipeline::UpdateTransport_s(int level,
+ RefPtr<TransportFlow> rtp_transport,
+ RefPtr<TransportFlow> rtcp_transport,
+ nsAutoPtr<MediaPipelineFilter> filter)
+{
+ bool rtcp_mux = false;
+ if (!rtcp_transport) {
+ rtcp_transport = rtp_transport;
+ rtcp_mux = true;
+ }
+
+ if ((rtp_transport != rtp_.transport_) ||
+ (rtcp_transport != rtcp_.transport_)) {
+ DetachTransport_s();
+ rtp_ = TransportInfo(rtp_transport, rtcp_mux ? MUX : RTP);
+ rtcp_ = TransportInfo(rtcp_transport, rtcp_mux ? MUX : RTCP);
+ AttachTransport_s();
+ }
+
+ level_ = level;
+
+ if (filter_ && filter) {
+ // Use the new filter, but don't forget any remote SSRCs that we've learned
+ // by receiving traffic.
+ filter_->Update(*filter);
+ } else {
+ filter_ = filter;
+ }
+}
+
+void
+MediaPipeline::SelectSsrc_m(size_t ssrc_index)
+{
+ RUN_ON_THREAD(sts_thread_,
+ WrapRunnable(
+ this,
+ &MediaPipeline::SelectSsrc_s,
+ ssrc_index),
+ NS_DISPATCH_NORMAL);
+}
+
+void
+MediaPipeline::SelectSsrc_s(size_t ssrc_index)
+{
+ filter_ = new MediaPipelineFilter;
+ if (ssrc_index < ssrcs_received_.size()) {
+ filter_->AddRemoteSSRC(ssrcs_received_[ssrc_index]);
+ } else {
+ MOZ_MTLOG(ML_WARNING, "SelectSsrc called with " << ssrc_index << " but we "
+ << "have only seen " << ssrcs_received_.size()
+ << " ssrcs");
+ }
+}
+
+void MediaPipeline::StateChange(TransportFlow *flow, TransportLayer::State state) {
+ TransportInfo* info = GetTransportInfo_s(flow);
+ MOZ_ASSERT(info);
+
+ if (state == TransportLayer::TS_OPEN) {
+ MOZ_MTLOG(ML_INFO, "Flow is ready");
+ TransportReady_s(*info);
+ } else if (state == TransportLayer::TS_CLOSED ||
+ state == TransportLayer::TS_ERROR) {
+ TransportFailed_s(*info);
+ }
+}
+
+static bool MakeRtpTypeToStringArray(const char** array) {
+ static const char* RTP_str = "RTP";
+ static const char* RTCP_str = "RTCP";
+ static const char* MUX_str = "RTP/RTCP mux";
+ array[MediaPipeline::RTP] = RTP_str;
+ array[MediaPipeline::RTCP] = RTCP_str;
+ array[MediaPipeline::MUX] = MUX_str;
+ return true;
+}
+
+static const char* ToString(MediaPipeline::RtpType type) {
+ static const char* array[(int)MediaPipeline::MAX_RTP_TYPE] = {nullptr};
+ // Dummy variable to cause init to happen only on first call
+ static bool dummy = MakeRtpTypeToStringArray(array);
+ (void)dummy;
+ return array[type];
+}
+
+nsresult MediaPipeline::TransportReady_s(TransportInfo &info) {
+ MOZ_ASSERT(!description_.empty());
+
+ // TODO(ekr@rtfm.com): implement some kind of notification on
+ // failure. bug 852665.
+ if (info.state_ != MP_CONNECTING) {
+ MOZ_MTLOG(ML_ERROR, "Transport ready for flow in wrong state:" <<
+ description_ << ": " << ToString(info.type_));
+ return NS_ERROR_FAILURE;
+ }
+
+ MOZ_MTLOG(ML_INFO, "Transport ready for pipeline " <<
+ static_cast<void *>(this) << " flow " << description_ << ": " <<
+ ToString(info.type_));
+
+ // TODO(bcampen@mozilla.com): Should we disconnect from the flow on failure?
+ nsresult res;
+
+ // Now instantiate the SRTP objects
+ TransportLayerDtls *dtls = static_cast<TransportLayerDtls *>(
+ info.transport_->GetLayer(TransportLayerDtls::ID()));
+ MOZ_ASSERT(dtls); // DTLS is mandatory
+
+ uint16_t cipher_suite;
+ res = dtls->GetSrtpCipher(&cipher_suite);
+ if (NS_FAILED(res)) {
+ MOZ_MTLOG(ML_ERROR, "Failed to negotiate DTLS-SRTP. This is an error");
+ info.state_ = MP_CLOSED;
+ UpdateRtcpMuxState(info);
+ return res;
+ }
+
+ // SRTP Key Exporter as per RFC 5764 S 4.2
+ unsigned char srtp_block[SRTP_TOTAL_KEY_LENGTH * 2];
+ res = dtls->ExportKeyingMaterial(kDTLSExporterLabel, false, "",
+ srtp_block, sizeof(srtp_block));
+ if (NS_FAILED(res)) {
+ MOZ_MTLOG(ML_ERROR, "Failed to compute DTLS-SRTP keys. This is an error");
+ info.state_ = MP_CLOSED;
+ UpdateRtcpMuxState(info);
+ MOZ_CRASH(); // TODO: Remove once we have enough field experience to
+ // know it doesn't happen. bug 798797. Note that the
+ // code after this never executes.
+ return res;
+ }
+
+ // Slice and dice as per RFC 5764 S 4.2
+ unsigned char client_write_key[SRTP_TOTAL_KEY_LENGTH];
+ unsigned char server_write_key[SRTP_TOTAL_KEY_LENGTH];
+ int offset = 0;
+ memcpy(client_write_key, srtp_block + offset, SRTP_MASTER_KEY_LENGTH);
+ offset += SRTP_MASTER_KEY_LENGTH;
+ memcpy(server_write_key, srtp_block + offset, SRTP_MASTER_KEY_LENGTH);
+ offset += SRTP_MASTER_KEY_LENGTH;
+ memcpy(client_write_key + SRTP_MASTER_KEY_LENGTH,
+ srtp_block + offset, SRTP_MASTER_SALT_LENGTH);
+ offset += SRTP_MASTER_SALT_LENGTH;
+ memcpy(server_write_key + SRTP_MASTER_KEY_LENGTH,
+ srtp_block + offset, SRTP_MASTER_SALT_LENGTH);
+ offset += SRTP_MASTER_SALT_LENGTH;
+ MOZ_ASSERT(offset == sizeof(srtp_block));
+
+ unsigned char *write_key;
+ unsigned char *read_key;
+
+ if (dtls->role() == TransportLayerDtls::CLIENT) {
+ write_key = client_write_key;
+ read_key = server_write_key;
+ } else {
+ write_key = server_write_key;
+ read_key = client_write_key;
+ }
+
+ MOZ_ASSERT(!info.send_srtp_ && !info.recv_srtp_);
+ info.send_srtp_ = SrtpFlow::Create(cipher_suite, false, write_key,
+ SRTP_TOTAL_KEY_LENGTH);
+ info.recv_srtp_ = SrtpFlow::Create(cipher_suite, true, read_key,
+ SRTP_TOTAL_KEY_LENGTH);
+ if (!info.send_srtp_ || !info.recv_srtp_) {
+ MOZ_MTLOG(ML_ERROR, "Couldn't create SRTP flow for "
+ << ToString(info.type_));
+ info.state_ = MP_CLOSED;
+ UpdateRtcpMuxState(info);
+ return NS_ERROR_FAILURE;
+ }
+
+ MOZ_MTLOG(ML_INFO, "Listening for " << ToString(info.type_)
+ << " packets received on " <<
+ static_cast<void *>(dtls->downward()));
+
+ switch (info.type_) {
+ case RTP:
+ dtls->downward()->SignalPacketReceived.connect(
+ this,
+ &MediaPipeline::RtpPacketReceived);
+ break;
+ case RTCP:
+ dtls->downward()->SignalPacketReceived.connect(
+ this,
+ &MediaPipeline::RtcpPacketReceived);
+ break;
+ case MUX:
+ dtls->downward()->SignalPacketReceived.connect(
+ this,
+ &MediaPipeline::PacketReceived);
+ break;
+ default:
+ MOZ_CRASH();
+ }
+
+ info.state_ = MP_OPEN;
+ UpdateRtcpMuxState(info);
+ return NS_OK;
+}
+
+nsresult MediaPipeline::TransportFailed_s(TransportInfo &info) {
+ ASSERT_ON_THREAD(sts_thread_);
+
+ info.state_ = MP_CLOSED;
+ UpdateRtcpMuxState(info);
+
+ MOZ_MTLOG(ML_INFO, "Transport closed for flow " << ToString(info.type_));
+
+ NS_WARNING(
+ "MediaPipeline Transport failed. This is not properly cleaned up yet");
+
+ // TODO(ekr@rtfm.com): SECURITY: Figure out how to clean up if the
+ // connection was good and now it is bad.
+ // TODO(ekr@rtfm.com): Report up so that the PC knows we
+ // have experienced an error.
+
+ return NS_OK;
+}
+
+void MediaPipeline::UpdateRtcpMuxState(TransportInfo &info) {
+ if (info.type_ == MUX) {
+ if (info.transport_ == rtcp_.transport_) {
+ rtcp_.state_ = info.state_;
+ if (!rtcp_.send_srtp_) {
+ rtcp_.send_srtp_ = info.send_srtp_;
+ rtcp_.recv_srtp_ = info.recv_srtp_;
+ }
+ }
+ }
+}
+
+nsresult MediaPipeline::SendPacket(TransportFlow *flow, const void *data,
+ int len) {
+ ASSERT_ON_THREAD(sts_thread_);
+
+ // Note that we bypass the DTLS layer here
+ TransportLayerDtls *dtls = static_cast<TransportLayerDtls *>(
+ flow->GetLayer(TransportLayerDtls::ID()));
+ MOZ_ASSERT(dtls);
+
+ TransportResult res = dtls->downward()->
+ SendPacket(static_cast<const unsigned char *>(data), len);
+
+ if (res != len) {
+ // Ignore blocking indications
+ if (res == TE_WOULDBLOCK)
+ return NS_OK;
+
+ MOZ_MTLOG(ML_ERROR, "Failed write on stream " << description_);
+ return NS_BASE_STREAM_CLOSED;
+ }
+
+ return NS_OK;
+}
+
+void MediaPipeline::increment_rtp_packets_sent(int32_t bytes) {
+ ++rtp_packets_sent_;
+ rtp_bytes_sent_ += bytes;
+
+ if (!(rtp_packets_sent_ % 100)) {
+ MOZ_MTLOG(ML_INFO, "RTP sent packet count for " << description_
+ << " Pipeline " << static_cast<void *>(this)
+ << " Flow : " << static_cast<void *>(rtp_.transport_)
+ << ": " << rtp_packets_sent_
+ << " (" << rtp_bytes_sent_ << " bytes)");
+ }
+}
+
+void MediaPipeline::increment_rtcp_packets_sent() {
+ ++rtcp_packets_sent_;
+ if (!(rtcp_packets_sent_ % 100)) {
+ MOZ_MTLOG(ML_INFO, "RTCP sent packet count for " << description_
+ << " Pipeline " << static_cast<void *>(this)
+ << " Flow : " << static_cast<void *>(rtcp_.transport_)
+ << ": " << rtcp_packets_sent_);
+ }
+}
+
+void MediaPipeline::increment_rtp_packets_received(int32_t bytes) {
+ ++rtp_packets_received_;
+ rtp_bytes_received_ += bytes;
+ if (!(rtp_packets_received_ % 100)) {
+ MOZ_MTLOG(ML_INFO, "RTP received packet count for " << description_
+ << " Pipeline " << static_cast<void *>(this)
+ << " Flow : " << static_cast<void *>(rtp_.transport_)
+ << ": " << rtp_packets_received_
+ << " (" << rtp_bytes_received_ << " bytes)");
+ }
+}
+
+void MediaPipeline::increment_rtcp_packets_received() {
+ ++rtcp_packets_received_;
+ if (!(rtcp_packets_received_ % 100)) {
+ MOZ_MTLOG(ML_INFO, "RTCP received packet count for " << description_
+ << " Pipeline " << static_cast<void *>(this)
+ << " Flow : " << static_cast<void *>(rtcp_.transport_)
+ << ": " << rtcp_packets_received_);
+ }
+}
+
+void MediaPipeline::RtpPacketReceived(TransportLayer *layer,
+ const unsigned char *data,
+ size_t len) {
+ if (!transport_->pipeline()) {
+ MOZ_MTLOG(ML_ERROR, "Discarding incoming packet; transport disconnected");
+ return;
+ }
+
+ if (!conduit_) {
+ MOZ_MTLOG(ML_DEBUG, "Discarding incoming packet; media disconnected");
+ return;
+ }
+
+ if (rtp_.state_ != MP_OPEN) {
+ MOZ_MTLOG(ML_ERROR, "Discarding incoming packet; pipeline not open");
+ return;
+ }
+
+ if (rtp_.transport_->state() != TransportLayer::TS_OPEN) {
+ MOZ_MTLOG(ML_ERROR, "Discarding incoming packet; transport not open");
+ return;
+ }
+
+ // This should never happen.
+ MOZ_ASSERT(rtp_.recv_srtp_);
+
+ if (direction_ == TRANSMIT) {
+ return;
+ }
+
+ if (!len) {
+ return;
+ }
+
+ // Filter out everything but RTP/RTCP
+ if (data[0] < 128 || data[0] > 191) {
+ return;
+ }
+
+ webrtc::RTPHeader header;
+ if (!rtp_parser_->Parse(data, len, &header)) {
+ return;
+ }
+
+ if (std::find(ssrcs_received_.begin(), ssrcs_received_.end(), header.ssrc) ==
+ ssrcs_received_.end()) {
+ ssrcs_received_.push_back(header.ssrc);
+ }
+
+ if (filter_ && !filter_->Filter(header)) {
+ return;
+ }
+
+ // Make a copy rather than cast away constness
+ auto inner_data = MakeUnique<unsigned char[]>(len);
+ memcpy(inner_data.get(), data, len);
+ int out_len = 0;
+ nsresult res = rtp_.recv_srtp_->UnprotectRtp(inner_data.get(),
+ len, len, &out_len);
+ if (!NS_SUCCEEDED(res)) {
+ char tmp[16];
+
+ SprintfLiteral(tmp, "%.2x %.2x %.2x %.2x",
+ inner_data[0],
+ inner_data[1],
+ inner_data[2],
+ inner_data[3]);
+
+ MOZ_MTLOG(ML_NOTICE, "Error unprotecting RTP in " << description_
+ << "len= " << len << "[" << tmp << "...]");
+
+ return;
+ }
+ MOZ_MTLOG(ML_DEBUG, description_ << " received RTP packet.");
+ increment_rtp_packets_received(out_len);
+
+ (void)conduit_->ReceivedRTPPacket(inner_data.get(), out_len); // Ignore error codes
+}
+
+void MediaPipeline::RtcpPacketReceived(TransportLayer *layer,
+ const unsigned char *data,
+ size_t len) {
+ if (!transport_->pipeline()) {
+ MOZ_MTLOG(ML_DEBUG, "Discarding incoming packet; transport disconnected");
+ return;
+ }
+
+ if (!conduit_) {
+ MOZ_MTLOG(ML_DEBUG, "Discarding incoming packet; media disconnected");
+ return;
+ }
+
+ if (rtcp_.state_ != MP_OPEN) {
+ MOZ_MTLOG(ML_DEBUG, "Discarding incoming packet; pipeline not open");
+ return;
+ }
+
+ if (rtcp_.transport_->state() != TransportLayer::TS_OPEN) {
+ MOZ_MTLOG(ML_ERROR, "Discarding incoming packet; transport not open");
+ return;
+ }
+
+ if (!len) {
+ return;
+ }
+
+ // Filter out everything but RTP/RTCP
+ if (data[0] < 128 || data[0] > 191) {
+ return;
+ }
+
+ // We do not filter RTCP for send pipelines, since the webrtc.org code for
+ // senders already has logic to ignore RRs that do not apply.
+ // TODO bug 1279153: remove SR check for reduced size RTCP
+ if (filter_ && direction_ == RECEIVE) {
+ if (!filter_->FilterSenderReport(data, len)) {
+ MOZ_MTLOG(ML_NOTICE, "Dropping incoming RTCP packet; filtered out");
+ return;
+ }
+ }
+
+ // Make a copy rather than cast away constness
+ auto inner_data = MakeUnique<unsigned char[]>(len);
+ memcpy(inner_data.get(), data, len);
+ int out_len;
+
+ nsresult res = rtcp_.recv_srtp_->UnprotectRtcp(inner_data.get(),
+ len,
+ len,
+ &out_len);
+
+ if (!NS_SUCCEEDED(res))
+ return;
+
+ MOZ_MTLOG(ML_DEBUG, description_ << " received RTCP packet.");
+ increment_rtcp_packets_received();
+
+ MOZ_ASSERT(rtcp_.recv_srtp_); // This should never happen
+
+ (void)conduit_->ReceivedRTCPPacket(inner_data.get(), out_len); // Ignore error codes
+}
+
+bool MediaPipeline::IsRtp(const unsigned char *data, size_t len) {
+ if (len < 2)
+ return false;
+
+ // Check if this is a RTCP packet. Logic based on the types listed in
+ // media/webrtc/trunk/src/modules/rtp_rtcp/source/rtp_utility.cc
+
+ // Anything outside this range is RTP.
+ if ((data[1] < 192) || (data[1] > 207))
+ return true;
+
+ if (data[1] == 192) // FIR
+ return false;
+
+ if (data[1] == 193) // NACK, but could also be RTP. This makes us sad
+ return true; // but it's how webrtc.org behaves.
+
+ if (data[1] == 194)
+ return true;
+
+ if (data[1] == 195) // IJ.
+ return false;
+
+ if ((data[1] > 195) && (data[1] < 200)) // the > 195 is redundant
+ return true;
+
+ if ((data[1] >= 200) && (data[1] <= 207)) // SR, RR, SDES, BYE,
+ return false; // APP, RTPFB, PSFB, XR
+
+ MOZ_ASSERT(false); // Not reached, belt and suspenders.
+ return true;
+}
+
+void MediaPipeline::PacketReceived(TransportLayer *layer,
+ const unsigned char *data,
+ size_t len) {
+ if (!transport_->pipeline()) {
+ MOZ_MTLOG(ML_DEBUG, "Discarding incoming packet; transport disconnected");
+ return;
+ }
+
+ if (IsRtp(data, len)) {
+ RtpPacketReceived(layer, data, len);
+ } else {
+ RtcpPacketReceived(layer, data, len);
+ }
+}
+
+class MediaPipelineTransmit::PipelineListener
+ : public DirectMediaStreamTrackListener
+{
+friend class MediaPipelineTransmit;
+public:
+ explicit PipelineListener(const RefPtr<MediaSessionConduit>& conduit)
+ : conduit_(conduit),
+ track_id_(TRACK_INVALID),
+ mMutex("MediaPipelineTransmit::PipelineListener"),
+ track_id_external_(TRACK_INVALID),
+ active_(false),
+ enabled_(false),
+ direct_connect_(false)
+ {
+ }
+
+ ~PipelineListener()
+ {
+ if (!NS_IsMainThread()) {
+ // release conduit on mainthread. Must use forget()!
+ nsresult rv = NS_DispatchToMainThread(new
+ ConduitDeleteEvent(conduit_.forget()));
+ MOZ_ASSERT(!NS_FAILED(rv),"Could not dispatch conduit shutdown to main");
+ if (NS_FAILED(rv)) {
+ MOZ_CRASH();
+ }
+ } else {
+ conduit_ = nullptr;
+ }
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ if (converter_) {
+ converter_->Shutdown();
+ }
+#endif
+ }
+
+ // Dispatches setting the internal TrackID to TRACK_INVALID to the media
+ // graph thread to keep it in sync with other MediaStreamGraph operations
+ // like RemoveListener() and AddListener(). The TrackID will be updated on
+ // the next NewData() callback.
+ void UnsetTrackId(MediaStreamGraphImpl* graph);
+
+ void SetActive(bool active) { active_ = active; }
+ void SetEnabled(bool enabled) { enabled_ = enabled; }
+
+ // These are needed since nested classes don't have access to any particular
+ // instance of the parent
+ void SetAudioProxy(const RefPtr<AudioProxyThread>& proxy)
+ {
+ audio_processing_ = proxy;
+ }
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ void SetVideoFrameConverter(const RefPtr<VideoFrameConverter>& converter)
+ {
+ converter_ = converter;
+ }
+
+ void OnVideoFrameConverted(unsigned char* aVideoFrame,
+ unsigned int aVideoFrameLength,
+ unsigned short aWidth,
+ unsigned short aHeight,
+ VideoType aVideoType,
+ uint64_t aCaptureTime)
+ {
+ MOZ_ASSERT(conduit_->type() == MediaSessionConduit::VIDEO);
+ static_cast<VideoSessionConduit*>(conduit_.get())->SendVideoFrame(
+ aVideoFrame, aVideoFrameLength, aWidth, aHeight, aVideoType, aCaptureTime);
+ }
+
+ void OnVideoFrameConverted(webrtc::I420VideoFrame& aVideoFrame)
+ {
+ MOZ_ASSERT(conduit_->type() == MediaSessionConduit::VIDEO);
+ static_cast<VideoSessionConduit*>(conduit_.get())->SendVideoFrame(aVideoFrame);
+ }
+#endif
+
+ // Implement MediaStreamTrackListener
+ void NotifyQueuedChanges(MediaStreamGraph* aGraph,
+ StreamTime aTrackOffset,
+ const MediaSegment& aQueuedMedia) override;
+
+ // Implement DirectMediaStreamTrackListener
+ void NotifyRealtimeTrackData(MediaStreamGraph* aGraph,
+ StreamTime aTrackOffset,
+ const MediaSegment& aMedia) override;
+ void NotifyDirectListenerInstalled(InstallationResult aResult) override;
+ void NotifyDirectListenerUninstalled() override;
+
+private:
+ void UnsetTrackIdImpl() {
+ MutexAutoLock lock(mMutex);
+ track_id_ = track_id_external_ = TRACK_INVALID;
+ }
+
+ void NewData(MediaStreamGraph* graph,
+ StreamTime offset,
+ const MediaSegment& media);
+
+ RefPtr<MediaSessionConduit> conduit_;
+ RefPtr<AudioProxyThread> audio_processing_;
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ RefPtr<VideoFrameConverter> converter_;
+#endif
+
+ // May be TRACK_INVALID until we see data from the track
+ TrackID track_id_; // this is the current TrackID this listener is attached to
+ Mutex mMutex;
+ // protected by mMutex
+ // May be TRACK_INVALID until we see data from the track
+ TrackID track_id_external_; // this is queried from other threads
+
+ // active is true if there is a transport to send on
+ mozilla::Atomic<bool> active_;
+ // enabled is true if the media access control permits sending
+ // actual content; when false you get black/silence
+ mozilla::Atomic<bool> enabled_;
+
+ // Written and read on the MediaStreamGraph thread
+ bool direct_connect_;
+};
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+// Implements VideoConverterListener for MediaPipeline.
+//
+// We pass converted frames on to MediaPipelineTransmit::PipelineListener
+// where they are further forwarded to VideoConduit.
+// MediaPipelineTransmit calls Detach() during shutdown to ensure there is
+// no cyclic dependencies between us and PipelineListener.
+class MediaPipelineTransmit::VideoFrameFeeder
+ : public VideoConverterListener
+{
+public:
+ explicit VideoFrameFeeder(const RefPtr<PipelineListener>& listener)
+ : listener_(listener),
+ mutex_("VideoFrameFeeder")
+ {
+ MOZ_COUNT_CTOR(VideoFrameFeeder);
+ }
+
+ void Detach()
+ {
+ MutexAutoLock lock(mutex_);
+
+ listener_ = nullptr;
+ }
+
+ void OnVideoFrameConverted(unsigned char* aVideoFrame,
+ unsigned int aVideoFrameLength,
+ unsigned short aWidth,
+ unsigned short aHeight,
+ VideoType aVideoType,
+ uint64_t aCaptureTime) override
+ {
+ MutexAutoLock lock(mutex_);
+
+ if (!listener_) {
+ return;
+ }
+
+ listener_->OnVideoFrameConverted(aVideoFrame, aVideoFrameLength,
+ aWidth, aHeight, aVideoType, aCaptureTime);
+ }
+
+ void OnVideoFrameConverted(webrtc::I420VideoFrame& aVideoFrame) override
+ {
+ MutexAutoLock lock(mutex_);
+
+ if (!listener_) {
+ return;
+ }
+
+ listener_->OnVideoFrameConverted(aVideoFrame);
+ }
+
+protected:
+ virtual ~VideoFrameFeeder()
+ {
+ MOZ_COUNT_DTOR(VideoFrameFeeder);
+ }
+
+ RefPtr<PipelineListener> listener_;
+ Mutex mutex_;
+};
+#endif
+
+class MediaPipelineTransmit::PipelineVideoSink :
+ public MediaStreamVideoSink
+{
+public:
+ explicit PipelineVideoSink(const RefPtr<MediaSessionConduit>& conduit,
+ MediaPipelineTransmit::PipelineListener* listener)
+ : conduit_(conduit)
+ , pipelineListener_(listener)
+ {
+ }
+
+ virtual void SetCurrentFrames(const VideoSegment& aSegment) override;
+ virtual void ClearFrames() override {}
+
+private:
+ ~PipelineVideoSink() {
+ // release conduit on mainthread. Must use forget()!
+ nsresult rv = NS_DispatchToMainThread(new
+ ConduitDeleteEvent(conduit_.forget()));
+ MOZ_ASSERT(!NS_FAILED(rv),"Could not dispatch conduit shutdown to main");
+ if (NS_FAILED(rv)) {
+ MOZ_CRASH();
+ }
+ }
+ RefPtr<MediaSessionConduit> conduit_;
+ MediaPipelineTransmit::PipelineListener* pipelineListener_;
+};
+
+MediaPipelineTransmit::MediaPipelineTransmit(
+ const std::string& pc,
+ nsCOMPtr<nsIEventTarget> main_thread,
+ nsCOMPtr<nsIEventTarget> sts_thread,
+ dom::MediaStreamTrack* domtrack,
+ const std::string& track_id,
+ int level,
+ RefPtr<MediaSessionConduit> conduit,
+ RefPtr<TransportFlow> rtp_transport,
+ RefPtr<TransportFlow> rtcp_transport,
+ nsAutoPtr<MediaPipelineFilter> filter) :
+ MediaPipeline(pc, TRANSMIT, main_thread, sts_thread, track_id, level,
+ conduit, rtp_transport, rtcp_transport, filter),
+ listener_(new PipelineListener(conduit)),
+ video_sink_(new PipelineVideoSink(conduit, listener_)),
+ domtrack_(domtrack)
+{
+ if (!IsVideo()) {
+ audio_processing_ = MakeAndAddRef<AudioProxyThread>(static_cast<AudioSessionConduit*>(conduit.get()));
+ listener_->SetAudioProxy(audio_processing_);
+ }
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ else { // Video
+ // For video we send frames to an async VideoFrameConverter that calls
+ // back to a VideoFrameFeeder that feeds I420 frames to VideoConduit.
+
+ feeder_ = MakeAndAddRef<VideoFrameFeeder>(listener_);
+
+ converter_ = MakeAndAddRef<VideoFrameConverter>();
+ converter_->AddListener(feeder_);
+
+ listener_->SetVideoFrameConverter(converter_);
+ }
+#endif
+}
+
+MediaPipelineTransmit::~MediaPipelineTransmit()
+{
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ if (feeder_) {
+ feeder_->Detach();
+ }
+#endif
+}
+
+nsresult MediaPipelineTransmit::Init() {
+ AttachToTrack(track_id_);
+
+ return MediaPipeline::Init();
+}
+
+void MediaPipelineTransmit::AttachToTrack(const std::string& track_id) {
+ ASSERT_ON_THREAD(main_thread_);
+
+ description_ = pc_ + "| ";
+ description_ += conduit_->type() == MediaSessionConduit::AUDIO ?
+ "Transmit audio[" : "Transmit video[";
+ description_ += track_id;
+ description_ += "]";
+
+ // TODO(ekr@rtfm.com): Check for errors
+ MOZ_MTLOG(ML_DEBUG, "Attaching pipeline to track "
+ << static_cast<void *>(domtrack_) << " conduit type=" <<
+ (conduit_->type() == MediaSessionConduit::AUDIO ?"audio":"video"));
+
+ // Register the Listener directly with the source if we can.
+ // We also register it as a non-direct listener so we fall back to that
+ // if installing the direct listener fails. As a direct listener we get access
+ // to direct unqueued (and not resampled) data.
+ domtrack_->AddDirectListener(listener_);
+ domtrack_->AddListener(listener_);
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ domtrack_->AddDirectListener(video_sink_);
+#endif
+
+#ifndef MOZILLA_INTERNAL_API
+ // this enables the unit tests that can't fiddle with principals and the like
+ listener_->SetEnabled(true);
+#endif
+}
+
+bool
+MediaPipelineTransmit::IsVideo() const
+{
+ return !!domtrack_->AsVideoStreamTrack();
+}
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+void MediaPipelineTransmit::UpdateSinkIdentity_m(MediaStreamTrack* track,
+ nsIPrincipal* principal,
+ const PeerIdentity* sinkIdentity) {
+ ASSERT_ON_THREAD(main_thread_);
+
+ if (track != nullptr && track != domtrack_) {
+ // If a track is specified, then it might not be for this pipeline,
+ // since we receive notifications for all tracks on the PC.
+ // nullptr means that the PeerIdentity has changed and shall be applied
+ // to all tracks of the PC.
+ return;
+ }
+
+ bool enableTrack = principal->Subsumes(domtrack_->GetPrincipal());
+ if (!enableTrack) {
+ // first try didn't work, but there's a chance that this is still available
+ // if our track is bound to a peerIdentity, and the peer connection (our
+ // sink) is bound to the same identity, then we can enable the track.
+ const PeerIdentity* trackIdentity = domtrack_->GetPeerIdentity();
+ if (sinkIdentity && trackIdentity) {
+ enableTrack = (*sinkIdentity == *trackIdentity);
+ }
+ }
+
+ listener_->SetEnabled(enableTrack);
+}
+#endif
+
+void
+MediaPipelineTransmit::DetachMedia()
+{
+ ASSERT_ON_THREAD(main_thread_);
+ if (domtrack_) {
+ domtrack_->RemoveDirectListener(listener_);
+ domtrack_->RemoveListener(listener_);
+ domtrack_->RemoveDirectListener(video_sink_);
+ domtrack_ = nullptr;
+ }
+ // Let the listener be destroyed with the pipeline (or later).
+}
+
+nsresult MediaPipelineTransmit::TransportReady_s(TransportInfo &info) {
+ ASSERT_ON_THREAD(sts_thread_);
+ // Call base ready function.
+ MediaPipeline::TransportReady_s(info);
+
+ // Should not be set for a transmitter
+ if (&info == &rtp_) {
+ listener_->SetActive(true);
+ }
+
+ return NS_OK;
+}
+
+nsresult MediaPipelineTransmit::ReplaceTrack(MediaStreamTrack& domtrack) {
+ // MainThread, checked in calls we make
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ nsString nsTrackId;
+ domtrack.GetId(nsTrackId);
+ std::string track_id(NS_ConvertUTF16toUTF8(nsTrackId).get());
+#else
+ std::string track_id = domtrack.GetId();
+#endif
+ MOZ_MTLOG(ML_DEBUG, "Reattaching pipeline " << description_ << " to track "
+ << static_cast<void *>(&domtrack)
+ << " track " << track_id << " conduit type=" <<
+ (conduit_->type() == MediaSessionConduit::AUDIO ?"audio":"video"));
+
+ DetachMedia();
+ domtrack_ = &domtrack; // Detach clears it
+ // Unsets the track id after RemoveListener() takes effect.
+ listener_->UnsetTrackId(domtrack_->GraphImpl());
+ track_id_ = track_id;
+ AttachToTrack(track_id);
+ return NS_OK;
+}
+
+void MediaPipeline::DisconnectTransport_s(TransportInfo &info) {
+ MOZ_ASSERT(info.transport_);
+ ASSERT_ON_THREAD(sts_thread_);
+
+ info.transport_->SignalStateChange.disconnect(this);
+ // We do this even if we're a transmitter, since we are still possibly
+ // registered to receive RTCP.
+ TransportLayerDtls *dtls = static_cast<TransportLayerDtls *>(
+ info.transport_->GetLayer(TransportLayerDtls::ID()));
+ MOZ_ASSERT(dtls); // DTLS is mandatory
+ MOZ_ASSERT(dtls->downward());
+ dtls->downward()->SignalPacketReceived.disconnect(this);
+}
+
+nsresult MediaPipeline::ConnectTransport_s(TransportInfo &info) {
+ MOZ_ASSERT(info.transport_);
+ ASSERT_ON_THREAD(sts_thread_);
+
+ // Look to see if the transport is ready
+ if (info.transport_->state() == TransportLayer::TS_OPEN) {
+ nsresult res = TransportReady_s(info);
+ if (NS_FAILED(res)) {
+ MOZ_MTLOG(ML_ERROR, "Error calling TransportReady(); res="
+ << static_cast<uint32_t>(res) << " in " << __FUNCTION__);
+ return res;
+ }
+ } else if (info.transport_->state() == TransportLayer::TS_ERROR) {
+ MOZ_MTLOG(ML_ERROR, ToString(info.type_)
+ << "transport is already in error state");
+ TransportFailed_s(info);
+ return NS_ERROR_FAILURE;
+ }
+
+ info.transport_->SignalStateChange.connect(this,
+ &MediaPipeline::StateChange);
+
+ return NS_OK;
+}
+
+MediaPipeline::TransportInfo* MediaPipeline::GetTransportInfo_s(
+ TransportFlow *flow) {
+ ASSERT_ON_THREAD(sts_thread_);
+ if (flow == rtp_.transport_) {
+ return &rtp_;
+ }
+
+ if (flow == rtcp_.transport_) {
+ return &rtcp_;
+ }
+
+ return nullptr;
+}
+
+nsresult MediaPipeline::PipelineTransport::SendRtpPacket(
+ const void *data, int len) {
+
+ nsAutoPtr<DataBuffer> buf(new DataBuffer(static_cast<const uint8_t *>(data),
+ len, len + SRTP_MAX_EXPANSION));
+
+ RUN_ON_THREAD(sts_thread_,
+ WrapRunnable(
+ RefPtr<MediaPipeline::PipelineTransport>(this),
+ &MediaPipeline::PipelineTransport::SendRtpRtcpPacket_s,
+ buf, true),
+ NS_DISPATCH_NORMAL);
+
+ return NS_OK;
+}
+
+nsresult MediaPipeline::PipelineTransport::SendRtpRtcpPacket_s(
+ nsAutoPtr<DataBuffer> data,
+ bool is_rtp) {
+
+ ASSERT_ON_THREAD(sts_thread_);
+ if (!pipeline_) {
+ return NS_OK; // Detached
+ }
+ TransportInfo& transport = is_rtp ? pipeline_->rtp_ : pipeline_->rtcp_;
+
+ if (!transport.send_srtp_) {
+ MOZ_MTLOG(ML_DEBUG, "Couldn't write RTP/RTCP packet; SRTP not set up yet");
+ return NS_OK;
+ }
+
+ MOZ_ASSERT(transport.transport_);
+ NS_ENSURE_TRUE(transport.transport_, NS_ERROR_NULL_POINTER);
+
+ // libsrtp enciphers in place, so we need a big enough buffer.
+ MOZ_ASSERT(data->capacity() >= data->len() + SRTP_MAX_EXPANSION);
+
+ int out_len;
+ nsresult res;
+ if (is_rtp) {
+ res = transport.send_srtp_->ProtectRtp(data->data(),
+ data->len(),
+ data->capacity(),
+ &out_len);
+ } else {
+ res = transport.send_srtp_->ProtectRtcp(data->data(),
+ data->len(),
+ data->capacity(),
+ &out_len);
+ }
+ if (!NS_SUCCEEDED(res)) {
+ return res;
+ }
+
+ // paranoia; don't have uninitialized bytes included in data->len()
+ data->SetLength(out_len);
+
+ MOZ_MTLOG(ML_DEBUG, pipeline_->description_ << " sending " <<
+ (is_rtp ? "RTP" : "RTCP") << " packet");
+ if (is_rtp) {
+ pipeline_->increment_rtp_packets_sent(out_len);
+ } else {
+ pipeline_->increment_rtcp_packets_sent();
+ }
+ return pipeline_->SendPacket(transport.transport_, data->data(), out_len);
+}
+
+nsresult MediaPipeline::PipelineTransport::SendRtcpPacket(
+ const void *data, int len) {
+
+ nsAutoPtr<DataBuffer> buf(new DataBuffer(static_cast<const uint8_t *>(data),
+ len, len + SRTP_MAX_EXPANSION));
+
+ RUN_ON_THREAD(sts_thread_,
+ WrapRunnable(
+ RefPtr<MediaPipeline::PipelineTransport>(this),
+ &MediaPipeline::PipelineTransport::SendRtpRtcpPacket_s,
+ buf, false),
+ NS_DISPATCH_NORMAL);
+
+ return NS_OK;
+}
+
+void MediaPipelineTransmit::PipelineListener::
+UnsetTrackId(MediaStreamGraphImpl* graph) {
+#ifndef USE_FAKE_MEDIA_STREAMS
+ class Message : public ControlMessage {
+ public:
+ explicit Message(PipelineListener* listener) :
+ ControlMessage(nullptr), listener_(listener) {}
+ virtual void Run() override
+ {
+ listener_->UnsetTrackIdImpl();
+ }
+ RefPtr<PipelineListener> listener_;
+ };
+ graph->AppendMessage(MakeUnique<Message>(this));
+#else
+ UnsetTrackIdImpl();
+#endif
+}
+// Called if we're attached with AddDirectListener()
+void MediaPipelineTransmit::PipelineListener::
+NotifyRealtimeTrackData(MediaStreamGraph* graph,
+ StreamTime offset,
+ const MediaSegment& media) {
+ MOZ_MTLOG(ML_DEBUG, "MediaPipeline::NotifyRealtimeTrackData() listener=" <<
+ this << ", offset=" << offset <<
+ ", duration=" << media.GetDuration());
+
+ NewData(graph, offset, media);
+}
+
+void MediaPipelineTransmit::PipelineListener::
+NotifyQueuedChanges(MediaStreamGraph* graph,
+ StreamTime offset,
+ const MediaSegment& queued_media) {
+ MOZ_MTLOG(ML_DEBUG, "MediaPipeline::NotifyQueuedChanges()");
+
+ // ignore non-direct data if we're also getting direct data
+ if (!direct_connect_) {
+ NewData(graph, offset, queued_media);
+ }
+}
+
+void MediaPipelineTransmit::PipelineListener::
+NotifyDirectListenerInstalled(InstallationResult aResult) {
+ MOZ_MTLOG(ML_INFO, "MediaPipeline::NotifyDirectListenerInstalled() listener= " <<
+ this << ", result=" << static_cast<int32_t>(aResult));
+
+ direct_connect_ = InstallationResult::SUCCESS == aResult;
+}
+
+void MediaPipelineTransmit::PipelineListener::
+NotifyDirectListenerUninstalled() {
+ MOZ_MTLOG(ML_INFO, "MediaPipeline::NotifyDirectListenerUninstalled() listener=" << this);
+
+ direct_connect_ = false;
+}
+
+void MediaPipelineTransmit::PipelineListener::
+NewData(MediaStreamGraph* graph,
+ StreamTime offset,
+ const MediaSegment& media) {
+ if (!active_) {
+ MOZ_MTLOG(ML_DEBUG, "Discarding packets because transport not ready");
+ return;
+ }
+
+ if (conduit_->type() !=
+ (media.GetType() == MediaSegment::AUDIO ? MediaSessionConduit::AUDIO :
+ MediaSessionConduit::VIDEO)) {
+ MOZ_ASSERT(false, "The media type should always be correct since the "
+ "listener is locked to a specific track");
+ return;
+ }
+
+ // TODO(ekr@rtfm.com): For now assume that we have only one
+ // track type and it's destined for us
+ // See bug 784517
+ if (media.GetType() == MediaSegment::AUDIO) {
+ AudioSegment* audio = const_cast<AudioSegment *>(
+ static_cast<const AudioSegment *>(&media));
+
+ AudioSegment::ChunkIterator iter(*audio);
+ while(!iter.IsEnded()) {
+ TrackRate rate;
+#ifdef USE_FAKE_MEDIA_STREAMS
+ rate = Fake_MediaStream::GraphRate();
+#else
+ rate = graph->GraphRate();
+#endif
+ audio_processing_->QueueAudioChunk(rate, *iter, enabled_);
+ iter.Next();
+ }
+ } else {
+ // Ignore
+ }
+}
+
+void MediaPipelineTransmit::PipelineVideoSink::
+SetCurrentFrames(const VideoSegment& aSegment)
+{
+ MOZ_ASSERT(pipelineListener_);
+
+ if (!pipelineListener_->active_) {
+ MOZ_MTLOG(ML_DEBUG, "Discarding packets because transport not ready");
+ return;
+ }
+
+ if (conduit_->type() != MediaSessionConduit::VIDEO) {
+ // Ignore data of wrong kind in case we have a muxed stream
+ return;
+ }
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ VideoSegment* video = const_cast<VideoSegment *>(&aSegment);
+
+ VideoSegment::ChunkIterator iter(*video);
+ while(!iter.IsEnded()) {
+ pipelineListener_->converter_->QueueVideoChunk(*iter, !pipelineListener_->enabled_);
+ iter.Next();
+ }
+#endif
+}
+
+class TrackAddedCallback {
+ public:
+ virtual void TrackAdded(TrackTicks current_ticks) = 0;
+
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(TrackAddedCallback);
+
+ protected:
+ virtual ~TrackAddedCallback() {}
+};
+
+class GenericReceiveListener;
+
+class GenericReceiveCallback : public TrackAddedCallback
+{
+ public:
+ explicit GenericReceiveCallback(GenericReceiveListener* listener)
+ : listener_(listener) {}
+
+ void TrackAdded(TrackTicks time);
+
+ private:
+ RefPtr<GenericReceiveListener> listener_;
+};
+
+// Add a listener on the MSG thread using the MSG command queue
+static void AddListener(MediaStream* source, MediaStreamListener* listener) {
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ class Message : public ControlMessage {
+ public:
+ Message(MediaStream* stream, MediaStreamListener* listener)
+ : ControlMessage(stream),
+ listener_(listener) {}
+
+ virtual void Run() override {
+ mStream->AddListenerImpl(listener_.forget());
+ }
+ private:
+ RefPtr<MediaStreamListener> listener_;
+ };
+
+ MOZ_ASSERT(listener);
+
+ source->GraphImpl()->AppendMessage(MakeUnique<Message>(source, listener));
+#else
+ source->AddListener(listener);
+#endif
+}
+
+class GenericReceiveListener : public MediaStreamListener
+{
+ public:
+ GenericReceiveListener(SourceMediaStream *source, TrackID track_id)
+ : source_(source),
+ track_id_(track_id),
+ played_ticks_(0),
+ principal_handle_(PRINCIPAL_HANDLE_NONE) {}
+
+ virtual ~GenericReceiveListener() {}
+
+ void AddSelf()
+ {
+ AddListener(source_, this);
+ }
+
+ void EndTrack()
+ {
+ source_->EndTrack(track_id_);
+ }
+
+#ifndef USE_FAKE_MEDIA_STREAMS
+ // Must be called on the main thread
+ void SetPrincipalHandle_m(const PrincipalHandle& principal_handle)
+ {
+ class Message : public ControlMessage
+ {
+ public:
+ Message(GenericReceiveListener* listener,
+ MediaStream* stream,
+ const PrincipalHandle& principal_handle)
+ : ControlMessage(stream),
+ listener_(listener),
+ principal_handle_(principal_handle)
+ {}
+
+ void Run() override {
+ listener_->SetPrincipalHandle_msg(principal_handle_);
+ }
+
+ RefPtr<GenericReceiveListener> listener_;
+ PrincipalHandle principal_handle_;
+ };
+
+ source_->GraphImpl()->AppendMessage(MakeUnique<Message>(this, source_, principal_handle));
+ }
+
+ // Must be called on the MediaStreamGraph thread
+ void SetPrincipalHandle_msg(const PrincipalHandle& principal_handle)
+ {
+ principal_handle_ = principal_handle;
+ }
+#endif // USE_FAKE_MEDIA_STREAMS
+
+ protected:
+ SourceMediaStream *source_;
+ const TrackID track_id_;
+ TrackTicks played_ticks_;
+ PrincipalHandle principal_handle_;
+};
+
+MediaPipelineReceive::MediaPipelineReceive(
+ const std::string& pc,
+ nsCOMPtr<nsIEventTarget> main_thread,
+ nsCOMPtr<nsIEventTarget> sts_thread,
+ SourceMediaStream *stream,
+ const std::string& track_id,
+ int level,
+ RefPtr<MediaSessionConduit> conduit,
+ RefPtr<TransportFlow> rtp_transport,
+ RefPtr<TransportFlow> rtcp_transport,
+ nsAutoPtr<MediaPipelineFilter> filter) :
+ MediaPipeline(pc, RECEIVE, main_thread, sts_thread,
+ track_id, level, conduit, rtp_transport,
+ rtcp_transport, filter),
+ stream_(stream),
+ segments_added_(0)
+{
+ MOZ_ASSERT(stream_);
+}
+
+MediaPipelineReceive::~MediaPipelineReceive()
+{
+ MOZ_ASSERT(!stream_); // Check that we have shut down already.
+}
+
+class MediaPipelineReceiveAudio::PipelineListener
+ : public GenericReceiveListener
+{
+public:
+ PipelineListener(SourceMediaStream * source, TrackID track_id,
+ const RefPtr<MediaSessionConduit>& conduit)
+ : GenericReceiveListener(source, track_id),
+ conduit_(conduit)
+ {
+ }
+
+ ~PipelineListener()
+ {
+ if (!NS_IsMainThread()) {
+ // release conduit on mainthread. Must use forget()!
+ nsresult rv = NS_DispatchToMainThread(new
+ ConduitDeleteEvent(conduit_.forget()));
+ MOZ_ASSERT(!NS_FAILED(rv),"Could not dispatch conduit shutdown to main");
+ if (NS_FAILED(rv)) {
+ MOZ_CRASH();
+ }
+ } else {
+ conduit_ = nullptr;
+ }
+ }
+
+ // Implement MediaStreamListener
+ void NotifyPull(MediaStreamGraph* graph, StreamTime desired_time) override
+ {
+ MOZ_ASSERT(source_);
+ if (!source_) {
+ MOZ_MTLOG(ML_ERROR, "NotifyPull() called from a non-SourceMediaStream");
+ return;
+ }
+
+ // This comparison is done in total time to avoid accumulated roundoff errors.
+ while (source_->TicksToTimeRoundDown(WEBRTC_DEFAULT_SAMPLE_RATE,
+ played_ticks_) < desired_time) {
+ int16_t scratch_buffer[AUDIO_SAMPLE_BUFFER_MAX];
+
+ int samples_length;
+
+ // This fetches 10ms of data, either mono or stereo
+ MediaConduitErrorCode err =
+ static_cast<AudioSessionConduit*>(conduit_.get())->GetAudioFrame(
+ scratch_buffer,
+ WEBRTC_DEFAULT_SAMPLE_RATE,
+ 0, // TODO(ekr@rtfm.com): better estimate of "capture" (really playout) delay
+ samples_length);
+
+ if (err != kMediaConduitNoError) {
+ // Insert silence on conduit/GIPS failure (extremely unlikely)
+ MOZ_MTLOG(ML_ERROR, "Audio conduit failed (" << err
+ << ") to return data @ " << played_ticks_
+ << " (desired " << desired_time << " -> "
+ << source_->StreamTimeToSeconds(desired_time) << ")");
+ // if this is not enough we'll loop and provide more
+ samples_length = WEBRTC_DEFAULT_SAMPLE_RATE/100;
+ PodArrayZero(scratch_buffer);
+ }
+
+ MOZ_ASSERT(samples_length * sizeof(uint16_t) < AUDIO_SAMPLE_BUFFER_MAX);
+
+ MOZ_MTLOG(ML_DEBUG, "Audio conduit returned buffer of length "
+ << samples_length);
+
+ RefPtr<SharedBuffer> samples = SharedBuffer::Create(samples_length * sizeof(uint16_t));
+ int16_t *samples_data = static_cast<int16_t *>(samples->Data());
+ AudioSegment segment;
+ // We derive the number of channels of the stream from the number of samples
+ // the AudioConduit gives us, considering it gives us packets of 10ms and we
+ // know the rate.
+ uint32_t channelCount = samples_length / (WEBRTC_DEFAULT_SAMPLE_RATE / 100);
+ AutoTArray<int16_t*,2> channels;
+ AutoTArray<const int16_t*,2> outputChannels;
+ size_t frames = samples_length / channelCount;
+
+ channels.SetLength(channelCount);
+
+ size_t offset = 0;
+ for (size_t i = 0; i < channelCount; i++) {
+ channels[i] = samples_data + offset;
+ offset += frames;
+ }
+
+ DeinterleaveAndConvertBuffer(scratch_buffer,
+ frames,
+ channelCount,
+ channels.Elements());
+
+ outputChannels.AppendElements(channels);
+
+ segment.AppendFrames(samples.forget(), outputChannels, frames,
+ principal_handle_);
+
+ // Handle track not actually added yet or removed/finished
+ if (source_->AppendToTrack(track_id_, &segment)) {
+ played_ticks_ += frames;
+ } else {
+ MOZ_MTLOG(ML_ERROR, "AppendToTrack failed");
+ // we can't un-read the data, but that's ok since we don't want to
+ // buffer - but don't i-loop!
+ return;
+ }
+ }
+ }
+
+private:
+ RefPtr<MediaSessionConduit> conduit_;
+};
+
+MediaPipelineReceiveAudio::MediaPipelineReceiveAudio(
+ const std::string& pc,
+ nsCOMPtr<nsIEventTarget> main_thread,
+ nsCOMPtr<nsIEventTarget> sts_thread,
+ SourceMediaStream* stream,
+ const std::string& media_stream_track_id,
+ TrackID numeric_track_id,
+ int level,
+ RefPtr<AudioSessionConduit> conduit,
+ RefPtr<TransportFlow> rtp_transport,
+ RefPtr<TransportFlow> rtcp_transport,
+ nsAutoPtr<MediaPipelineFilter> filter) :
+ MediaPipelineReceive(pc, main_thread, sts_thread,
+ stream, media_stream_track_id, level, conduit,
+ rtp_transport, rtcp_transport, filter),
+ listener_(new PipelineListener(stream, numeric_track_id, conduit))
+{}
+
+void MediaPipelineReceiveAudio::DetachMedia()
+{
+ ASSERT_ON_THREAD(main_thread_);
+ if (stream_ && listener_) {
+ listener_->EndTrack();
+ stream_->RemoveListener(listener_);
+ stream_ = nullptr;
+ }
+}
+
+nsresult MediaPipelineReceiveAudio::Init() {
+ ASSERT_ON_THREAD(main_thread_);
+ MOZ_MTLOG(ML_DEBUG, __FUNCTION__);
+
+ description_ = pc_ + "| Receive audio[";
+ description_ += track_id_;
+ description_ += "]";
+
+ listener_->AddSelf();
+
+ return MediaPipelineReceive::Init();
+}
+
+#ifndef USE_FAKE_MEDIA_STREAMS
+void MediaPipelineReceiveAudio::SetPrincipalHandle_m(const PrincipalHandle& principal_handle)
+{
+ listener_->SetPrincipalHandle_m(principal_handle);
+}
+#endif // USE_FAKE_MEDIA_STREAMS
+
+class MediaPipelineReceiveVideo::PipelineListener
+ : public GenericReceiveListener {
+public:
+ PipelineListener(SourceMediaStream * source, TrackID track_id)
+ : GenericReceiveListener(source, track_id),
+ width_(0),
+ height_(0),
+#if defined(MOZILLA_INTERNAL_API)
+ image_container_(),
+ image_(),
+#endif
+ monitor_("Video PipelineListener")
+ {
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ image_container_ =
+ LayerManager::CreateImageContainer(ImageContainer::ASYNCHRONOUS);
+#endif
+ }
+
+ // Implement MediaStreamListener
+ void NotifyPull(MediaStreamGraph* graph, StreamTime desired_time) override
+ {
+ #if defined(MOZILLA_INTERNAL_API)
+ ReentrantMonitorAutoEnter enter(monitor_);
+
+ RefPtr<Image> image = image_;
+ StreamTime delta = desired_time - played_ticks_;
+
+ // Don't append if we've already provided a frame that supposedly
+ // goes past the current aDesiredTime Doing so means a negative
+ // delta and thus messes up handling of the graph
+ if (delta > 0) {
+ VideoSegment segment;
+ segment.AppendFrame(image.forget(), delta, IntSize(width_, height_),
+ principal_handle_);
+ // Handle track not actually added yet or removed/finished
+ if (source_->AppendToTrack(track_id_, &segment)) {
+ played_ticks_ = desired_time;
+ } else {
+ MOZ_MTLOG(ML_ERROR, "AppendToTrack failed");
+ return;
+ }
+ }
+ #endif
+ }
+
+ // Accessors for external writes from the renderer
+ void FrameSizeChange(unsigned int width,
+ unsigned int height,
+ unsigned int number_of_streams) {
+ ReentrantMonitorAutoEnter enter(monitor_);
+
+ width_ = width;
+ height_ = height;
+ }
+
+ void RenderVideoFrame(const unsigned char* buffer,
+ size_t buffer_size,
+ uint32_t time_stamp,
+ int64_t render_time,
+ const RefPtr<layers::Image>& video_image)
+ {
+ RenderVideoFrame(buffer, buffer_size, width_, (width_ + 1) >> 1,
+ time_stamp, render_time, video_image);
+ }
+
+ void RenderVideoFrame(const unsigned char* buffer,
+ size_t buffer_size,
+ uint32_t y_stride,
+ uint32_t cbcr_stride,
+ uint32_t time_stamp,
+ int64_t render_time,
+ const RefPtr<layers::Image>& video_image)
+ {
+#ifdef MOZILLA_INTERNAL_API
+ ReentrantMonitorAutoEnter enter(monitor_);
+#endif // MOZILLA_INTERNAL_API
+
+#if defined(MOZILLA_INTERNAL_API)
+ if (buffer) {
+ // Create a video frame using |buffer|.
+#ifdef MOZ_WIDGET_GONK
+ RefPtr<PlanarYCbCrImage> yuvImage = new GrallocImage();
+#else
+ RefPtr<PlanarYCbCrImage> yuvImage = image_container_->CreatePlanarYCbCrImage();
+#endif
+ uint8_t* frame = const_cast<uint8_t*>(static_cast<const uint8_t*> (buffer));
+
+ PlanarYCbCrData yuvData;
+ yuvData.mYChannel = frame;
+ yuvData.mYSize = IntSize(y_stride, height_);
+ yuvData.mYStride = y_stride;
+ yuvData.mCbCrStride = cbcr_stride;
+ yuvData.mCbChannel = frame + height_ * yuvData.mYStride;
+ yuvData.mCrChannel = yuvData.mCbChannel + ((height_ + 1) >> 1) * yuvData.mCbCrStride;
+ yuvData.mCbCrSize = IntSize(yuvData.mCbCrStride, (height_ + 1) >> 1);
+ yuvData.mPicX = 0;
+ yuvData.mPicY = 0;
+ yuvData.mPicSize = IntSize(width_, height_);
+ yuvData.mStereoMode = StereoMode::MONO;
+
+ if (!yuvImage->CopyData(yuvData)) {
+ MOZ_ASSERT(false);
+ return;
+ }
+
+ image_ = yuvImage;
+ }
+#ifdef WEBRTC_GONK
+ else {
+ // Decoder produced video frame that can be appended to the track directly.
+ MOZ_ASSERT(video_image);
+ image_ = video_image;
+ }
+#endif // WEBRTC_GONK
+#endif // MOZILLA_INTERNAL_API
+ }
+
+private:
+ int width_;
+ int height_;
+#if defined(MOZILLA_INTERNAL_API)
+ RefPtr<layers::ImageContainer> image_container_;
+ RefPtr<layers::Image> image_;
+#endif
+ mozilla::ReentrantMonitor monitor_; // Monitor for processing WebRTC frames.
+ // Protects image_ against:
+ // - Writing from the GIPS thread
+ // - Reading from the MSG thread
+};
+
+class MediaPipelineReceiveVideo::PipelineRenderer : public VideoRenderer
+{
+public:
+ explicit PipelineRenderer(MediaPipelineReceiveVideo *pipeline) :
+ pipeline_(pipeline) {}
+
+ void Detach() { pipeline_ = nullptr; }
+
+ // Implement VideoRenderer
+ void FrameSizeChange(unsigned int width,
+ unsigned int height,
+ unsigned int number_of_streams) override
+ {
+ pipeline_->listener_->FrameSizeChange(width, height, number_of_streams);
+ }
+
+ void RenderVideoFrame(const unsigned char* buffer,
+ size_t buffer_size,
+ uint32_t time_stamp,
+ int64_t render_time,
+ const ImageHandle& handle) override
+ {
+ pipeline_->listener_->RenderVideoFrame(buffer, buffer_size,
+ time_stamp, render_time,
+ handle.GetImage());
+ }
+
+ void RenderVideoFrame(const unsigned char* buffer,
+ size_t buffer_size,
+ uint32_t y_stride,
+ uint32_t cbcr_stride,
+ uint32_t time_stamp,
+ int64_t render_time,
+ const ImageHandle& handle) override
+ {
+ pipeline_->listener_->RenderVideoFrame(buffer, buffer_size,
+ y_stride, cbcr_stride,
+ time_stamp, render_time,
+ handle.GetImage());
+ }
+
+private:
+ MediaPipelineReceiveVideo *pipeline_; // Raw pointer to avoid cycles
+};
+
+
+MediaPipelineReceiveVideo::MediaPipelineReceiveVideo(
+ const std::string& pc,
+ nsCOMPtr<nsIEventTarget> main_thread,
+ nsCOMPtr<nsIEventTarget> sts_thread,
+ SourceMediaStream *stream,
+ const std::string& media_stream_track_id,
+ TrackID numeric_track_id,
+ int level,
+ RefPtr<VideoSessionConduit> conduit,
+ RefPtr<TransportFlow> rtp_transport,
+ RefPtr<TransportFlow> rtcp_transport,
+ nsAutoPtr<MediaPipelineFilter> filter) :
+ MediaPipelineReceive(pc, main_thread, sts_thread,
+ stream, media_stream_track_id, level, conduit,
+ rtp_transport, rtcp_transport, filter),
+ renderer_(new PipelineRenderer(this)),
+ listener_(new PipelineListener(stream, numeric_track_id))
+{}
+
+void MediaPipelineReceiveVideo::DetachMedia()
+{
+ ASSERT_ON_THREAD(main_thread_);
+
+ // stop generating video and thus stop invoking the PipelineRenderer
+ // and PipelineListener - the renderer has a raw ptr to the Pipeline to
+ // avoid cycles, and the render callbacks are invoked from a different
+ // thread so simple null-checks would cause TSAN bugs without locks.
+ static_cast<VideoSessionConduit*>(conduit_.get())->DetachRenderer();
+ if (stream_ && listener_) {
+ listener_->EndTrack();
+ stream_->RemoveListener(listener_);
+ stream_ = nullptr;
+ }
+}
+
+nsresult MediaPipelineReceiveVideo::Init() {
+ ASSERT_ON_THREAD(main_thread_);
+ MOZ_MTLOG(ML_DEBUG, __FUNCTION__);
+
+ description_ = pc_ + "| Receive video[";
+ description_ += track_id_;
+ description_ += "]";
+
+#if defined(MOZILLA_INTERNAL_API)
+ listener_->AddSelf();
+#endif
+
+ // Always happens before we can DetachMedia()
+ static_cast<VideoSessionConduit *>(conduit_.get())->
+ AttachRenderer(renderer_);
+
+ return MediaPipelineReceive::Init();
+}
+
+#ifndef USE_FAKE_MEDIA_STREAMS
+void MediaPipelineReceiveVideo::SetPrincipalHandle_m(const PrincipalHandle& principal_handle)
+{
+ listener_->SetPrincipalHandle_m(principal_handle);
+}
+#endif // USE_FAKE_MEDIA_STREAMS
+
+} // end namespace
diff --git a/media/webrtc/signaling/src/mediapipeline/MediaPipeline.h b/media/webrtc/signaling/src/mediapipeline/MediaPipeline.h
new file mode 100644
index 000000000..d609cbd47
--- /dev/null
+++ b/media/webrtc/signaling/src/mediapipeline/MediaPipeline.h
@@ -0,0 +1,479 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+// Original author: ekr@rtfm.com
+
+#ifndef mediapipeline_h__
+#define mediapipeline_h__
+
+#include "sigslot.h"
+
+#ifdef USE_FAKE_MEDIA_STREAMS
+#include "FakeMediaStreams.h"
+#endif
+#include "MediaConduitInterface.h"
+#include "mozilla/ReentrantMonitor.h"
+#include "mozilla/Atomics.h"
+#include "SrtpFlow.h"
+#include "databuffer.h"
+#include "runnable_utils.h"
+#include "transportflow.h"
+#include "AudioPacketizer.h"
+#include "StreamTracks.h"
+
+#include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
+
+// Should come from MediaEngine.h, but that's a pain to include here
+// because of the MOZILLA_EXTERNAL_LINKAGE stuff.
+#define WEBRTC_DEFAULT_SAMPLE_RATE 32000
+
+class nsIPrincipal;
+
+namespace mozilla {
+class MediaPipelineFilter;
+class PeerIdentity;
+class AudioProxyThread;
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+class VideoFrameConverter;
+#endif
+
+#ifndef USE_FAKE_MEDIA_STREAMS
+namespace dom {
+ class MediaStreamTrack;
+} // namespace dom
+
+class SourceMediaStream;
+#endif // USE_FAKE_MEDIA_STREAMS
+
+// A class that represents the pipeline of audio and video
+// The dataflow looks like:
+//
+// TRANSMIT
+// CaptureDevice -> stream -> [us] -> conduit -> [us] -> transport -> network
+//
+// RECEIVE
+// network -> transport -> [us] -> conduit -> [us] -> stream -> Playout
+//
+// The boxes labeled [us] are just bridge logic implemented in this class
+//
+// We have to deal with a number of threads:
+//
+// GSM:
+// * Assembles the pipeline
+// SocketTransportService
+// * Receives notification that ICE and DTLS have completed
+// * Processes incoming network data and passes it to the conduit
+// * Processes outgoing RTP and RTCP
+// MediaStreamGraph
+// * Receives outgoing data from the MediaStreamGraph
+// * Receives pull requests for more data from the
+// MediaStreamGraph
+// One or another GIPS threads
+// * Receives RTCP messages to send to the other side
+// * Processes video frames GIPS wants to render
+//
+// For a transmitting conduit, "output" is RTP and "input" is RTCP.
+// For a receiving conduit, "input" is RTP and "output" is RTCP.
+//
+
+class MediaPipeline : public sigslot::has_slots<> {
+ public:
+ enum Direction { TRANSMIT, RECEIVE };
+ enum State { MP_CONNECTING, MP_OPEN, MP_CLOSED };
+ MediaPipeline(const std::string& pc,
+ Direction direction,
+ nsCOMPtr<nsIEventTarget> main_thread,
+ nsCOMPtr<nsIEventTarget> sts_thread,
+ const std::string& track_id,
+ int level,
+ RefPtr<MediaSessionConduit> conduit,
+ RefPtr<TransportFlow> rtp_transport,
+ RefPtr<TransportFlow> rtcp_transport,
+ nsAutoPtr<MediaPipelineFilter> filter);
+
+ // Must be called on the STS thread. Must be called after ShutdownMedia_m().
+ void DetachTransport_s();
+
+ // Must be called on the main thread.
+ void ShutdownMedia_m()
+ {
+ ASSERT_ON_THREAD(main_thread_);
+
+ if (direction_ == RECEIVE) {
+ conduit_->StopReceiving();
+ } else {
+ conduit_->StopTransmitting();
+ }
+ DetachMedia();
+ }
+
+ virtual nsresult Init();
+
+ void UpdateTransport_m(int level,
+ RefPtr<TransportFlow> rtp_transport,
+ RefPtr<TransportFlow> rtcp_transport,
+ nsAutoPtr<MediaPipelineFilter> filter);
+
+ void UpdateTransport_s(int level,
+ RefPtr<TransportFlow> rtp_transport,
+ RefPtr<TransportFlow> rtcp_transport,
+ nsAutoPtr<MediaPipelineFilter> filter);
+
+ // Used only for testing; installs a MediaPipelineFilter that filters
+ // everything but the nth ssrc
+ void SelectSsrc_m(size_t ssrc_index);
+ void SelectSsrc_s(size_t ssrc_index);
+
+ virtual Direction direction() const { return direction_; }
+ virtual const std::string& trackid() const { return track_id_; }
+ virtual int level() const { return level_; }
+ virtual bool IsVideo() const = 0;
+
+ bool IsDoingRtcpMux() const {
+ return (rtp_.type_ == MUX);
+ }
+
+ int32_t rtp_packets_sent() const { return rtp_packets_sent_; }
+ int64_t rtp_bytes_sent() const { return rtp_bytes_sent_; }
+ int32_t rtcp_packets_sent() const { return rtcp_packets_sent_; }
+ int32_t rtp_packets_received() const { return rtp_packets_received_; }
+ int64_t rtp_bytes_received() const { return rtp_bytes_received_; }
+ int32_t rtcp_packets_received() const { return rtcp_packets_received_; }
+
+ MediaSessionConduit *Conduit() const { return conduit_; }
+
+ // Thread counting
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MediaPipeline)
+
+ typedef enum {
+ RTP,
+ RTCP,
+ MUX,
+ MAX_RTP_TYPE
+ } RtpType;
+
+ protected:
+ virtual ~MediaPipeline();
+ virtual void DetachMedia() {}
+ nsresult AttachTransport_s();
+
+ // Separate class to allow ref counting
+ class PipelineTransport : public TransportInterface {
+ public:
+ // Implement the TransportInterface functions
+ explicit PipelineTransport(MediaPipeline *pipeline)
+ : pipeline_(pipeline),
+ sts_thread_(pipeline->sts_thread_) {}
+
+ void Attach(MediaPipeline *pipeline) { pipeline_ = pipeline; }
+ void Detach() { pipeline_ = nullptr; }
+ MediaPipeline *pipeline() const { return pipeline_; }
+
+ virtual nsresult SendRtpPacket(const void* data, int len);
+ virtual nsresult SendRtcpPacket(const void* data, int len);
+
+ private:
+ nsresult SendRtpRtcpPacket_s(nsAutoPtr<DataBuffer> data,
+ bool is_rtp);
+
+ MediaPipeline *pipeline_; // Raw pointer to avoid cycles
+ nsCOMPtr<nsIEventTarget> sts_thread_;
+ };
+ friend class PipelineTransport;
+
+ class TransportInfo {
+ public:
+ TransportInfo(RefPtr<TransportFlow> flow, RtpType type) :
+ transport_(flow),
+ state_(MP_CONNECTING),
+ type_(type) {
+ MOZ_ASSERT(flow);
+ }
+
+ void Detach()
+ {
+ transport_ = nullptr;
+ send_srtp_ = nullptr;
+ recv_srtp_ = nullptr;
+ }
+
+ RefPtr<TransportFlow> transport_;
+ State state_;
+ RefPtr<SrtpFlow> send_srtp_;
+ RefPtr<SrtpFlow> recv_srtp_;
+ RtpType type_;
+ };
+
+ // The transport is down
+ virtual nsresult TransportFailed_s(TransportInfo &info);
+ // The transport is ready
+ virtual nsresult TransportReady_s(TransportInfo &info);
+ void UpdateRtcpMuxState(TransportInfo &info);
+
+ // Unhooks from signals
+ void DisconnectTransport_s(TransportInfo &info);
+ nsresult ConnectTransport_s(TransportInfo &info);
+
+ TransportInfo* GetTransportInfo_s(TransportFlow *flow);
+
+ void increment_rtp_packets_sent(int bytes);
+ void increment_rtcp_packets_sent();
+ void increment_rtp_packets_received(int bytes);
+ void increment_rtcp_packets_received();
+
+ virtual nsresult SendPacket(TransportFlow *flow, const void *data, int len);
+
+ // Process slots on transports
+ void StateChange(TransportFlow *flow, TransportLayer::State);
+ void RtpPacketReceived(TransportLayer *layer, const unsigned char *data,
+ size_t len);
+ void RtcpPacketReceived(TransportLayer *layer, const unsigned char *data,
+ size_t len);
+ void PacketReceived(TransportLayer *layer, const unsigned char *data,
+ size_t len);
+
+ Direction direction_;
+ std::string track_id_; // The track on the stream.
+ // Written on the main thread.
+ // Used on STS and MediaStreamGraph threads.
+ // Not used outside initialization in MediaPipelineTransmit
+ // The m-line index (starting at 0, to match convention) Atomic because
+ // this value is updated from STS, but read on main, and we don't want to
+ // bother with dispatches just to get an int occasionally.
+ Atomic<int> level_;
+ RefPtr<MediaSessionConduit> conduit_; // Our conduit. Written on the main
+ // thread. Read on STS thread.
+
+ // The transport objects. Read/written on STS thread.
+ TransportInfo rtp_;
+ TransportInfo rtcp_;
+
+ // Pointers to the threads we need. Initialized at creation
+ // and used all over the place.
+ nsCOMPtr<nsIEventTarget> main_thread_;
+ nsCOMPtr<nsIEventTarget> sts_thread_;
+
+ // Created on Init. Referenced by the conduit and eventually
+ // destroyed on the STS thread.
+ RefPtr<PipelineTransport> transport_;
+
+ // Only safe to access from STS thread.
+ // Build into TransportInfo?
+ int32_t rtp_packets_sent_;
+ int32_t rtcp_packets_sent_;
+ int32_t rtp_packets_received_;
+ int32_t rtcp_packets_received_;
+ int64_t rtp_bytes_sent_;
+ int64_t rtp_bytes_received_;
+
+ std::vector<uint32_t> ssrcs_received_;
+
+ // Written on Init. Read on STS thread.
+ std::string pc_;
+ std::string description_;
+
+ // Written on Init, all following accesses are on the STS thread.
+ nsAutoPtr<MediaPipelineFilter> filter_;
+ nsAutoPtr<webrtc::RtpHeaderParser> rtp_parser_;
+
+ private:
+ nsresult Init_s();
+
+ bool IsRtp(const unsigned char *data, size_t len);
+};
+
+class ConduitDeleteEvent: public Runnable
+{
+public:
+ explicit ConduitDeleteEvent(already_AddRefed<MediaSessionConduit> aConduit) :
+ mConduit(aConduit) {}
+
+ /* we exist solely to proxy release of the conduit */
+ NS_IMETHOD Run() override { return NS_OK; }
+private:
+ RefPtr<MediaSessionConduit> mConduit;
+};
+
+// A specialization of pipeline for reading from an input device
+// and transmitting to the network.
+class MediaPipelineTransmit : public MediaPipeline {
+public:
+ // Set rtcp_transport to nullptr to use rtcp-mux
+ MediaPipelineTransmit(const std::string& pc,
+ nsCOMPtr<nsIEventTarget> main_thread,
+ nsCOMPtr<nsIEventTarget> sts_thread,
+ dom::MediaStreamTrack* domtrack,
+ const std::string& track_id,
+ int level,
+ RefPtr<MediaSessionConduit> conduit,
+ RefPtr<TransportFlow> rtp_transport,
+ RefPtr<TransportFlow> rtcp_transport,
+ nsAutoPtr<MediaPipelineFilter> filter);
+
+ // Initialize (stuff here may fail)
+ nsresult Init() override;
+
+ virtual void AttachToTrack(const std::string& track_id);
+
+ // written and used from MainThread
+ bool IsVideo() const override;
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ // When the principal of the domtrack changes, it calls through to here
+ // so that we can determine whether to enable track transmission.
+ // `track` has to be null or equal `domtrack_` for us to apply the update.
+ virtual void UpdateSinkIdentity_m(dom::MediaStreamTrack* track,
+ nsIPrincipal* principal,
+ const PeerIdentity* sinkIdentity);
+#endif
+
+ // Called on the main thread.
+ void DetachMedia() override;
+
+ // Override MediaPipeline::TransportReady.
+ nsresult TransportReady_s(TransportInfo &info) override;
+
+ // Replace a track with a different one
+ // In non-compliance with the likely final spec, allow the new
+ // track to be part of a different stream (since we don't support
+ // multiple tracks of a type in a stream yet). bug 1056650
+ virtual nsresult ReplaceTrack(dom::MediaStreamTrack& domtrack);
+
+ // Separate classes to allow ref counting
+ class PipelineListener;
+ class VideoFrameFeeder;
+ class PipelineVideoSink;
+
+ protected:
+ ~MediaPipelineTransmit();
+
+ private:
+ RefPtr<PipelineListener> listener_;
+ RefPtr<AudioProxyThread> audio_processing_;
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ RefPtr<VideoFrameFeeder> feeder_;
+ RefPtr<VideoFrameConverter> converter_;
+#endif
+ RefPtr<PipelineVideoSink> video_sink_;
+ dom::MediaStreamTrack* domtrack_;
+};
+
+
+// A specialization of pipeline for reading from the network and
+// rendering video.
+class MediaPipelineReceive : public MediaPipeline {
+ public:
+ // Set rtcp_transport to nullptr to use rtcp-mux
+ MediaPipelineReceive(const std::string& pc,
+ nsCOMPtr<nsIEventTarget> main_thread,
+ nsCOMPtr<nsIEventTarget> sts_thread,
+ SourceMediaStream *stream,
+ const std::string& track_id,
+ int level,
+ RefPtr<MediaSessionConduit> conduit,
+ RefPtr<TransportFlow> rtp_transport,
+ RefPtr<TransportFlow> rtcp_transport,
+ nsAutoPtr<MediaPipelineFilter> filter);
+
+ int segments_added() const { return segments_added_; }
+
+#ifndef USE_FAKE_MEDIA_STREAMS
+ // Sets the PrincipalHandle we set on the media chunks produced by this
+ // pipeline. Must be called on the main thread.
+ virtual void SetPrincipalHandle_m(const PrincipalHandle& principal_handle) = 0;
+#endif // USE_FAKE_MEDIA_STREAMS
+ protected:
+ ~MediaPipelineReceive();
+
+ RefPtr<SourceMediaStream> stream_;
+ int segments_added_;
+
+ private:
+};
+
+
+// A specialization of pipeline for reading from the network and
+// rendering audio.
+class MediaPipelineReceiveAudio : public MediaPipelineReceive {
+ public:
+ MediaPipelineReceiveAudio(const std::string& pc,
+ nsCOMPtr<nsIEventTarget> main_thread,
+ nsCOMPtr<nsIEventTarget> sts_thread,
+ SourceMediaStream* stream,
+ // This comes from an msid attribute. Everywhere
+ // but MediaStreamGraph uses this.
+ const std::string& media_stream_track_id,
+ // This is an integer identifier that is only
+ // unique within a single DOMMediaStream, which is
+ // used by MediaStreamGraph
+ TrackID numeric_track_id,
+ int level,
+ RefPtr<AudioSessionConduit> conduit,
+ RefPtr<TransportFlow> rtp_transport,
+ RefPtr<TransportFlow> rtcp_transport,
+ nsAutoPtr<MediaPipelineFilter> filter);
+
+ void DetachMedia() override;
+
+ nsresult Init() override;
+ bool IsVideo() const override { return false; }
+
+#ifndef USE_FAKE_MEDIA_STREAMS
+ void SetPrincipalHandle_m(const PrincipalHandle& principal_handle) override;
+#endif // USE_FAKE_MEDIA_STREAMS
+
+ private:
+ // Separate class to allow ref counting
+ class PipelineListener;
+
+ RefPtr<PipelineListener> listener_;
+};
+
+
+// A specialization of pipeline for reading from the network and
+// rendering video.
+class MediaPipelineReceiveVideo : public MediaPipelineReceive {
+ public:
+ MediaPipelineReceiveVideo(const std::string& pc,
+ nsCOMPtr<nsIEventTarget> main_thread,
+ nsCOMPtr<nsIEventTarget> sts_thread,
+ SourceMediaStream *stream,
+ // This comes from an msid attribute. Everywhere
+ // but MediaStreamGraph uses this.
+ const std::string& media_stream_track_id,
+ // This is an integer identifier that is only
+ // unique within a single DOMMediaStream, which is
+ // used by MediaStreamGraph
+ TrackID numeric_track_id,
+ int level,
+ RefPtr<VideoSessionConduit> conduit,
+ RefPtr<TransportFlow> rtp_transport,
+ RefPtr<TransportFlow> rtcp_transport,
+ nsAutoPtr<MediaPipelineFilter> filter);
+
+ // Called on the main thread.
+ void DetachMedia() override;
+
+ nsresult Init() override;
+ bool IsVideo() const override { return true; }
+
+#ifndef USE_FAKE_MEDIA_STREAMS
+ void SetPrincipalHandle_m(const PrincipalHandle& principal_handle) override;
+#endif // USE_FAKE_MEDIA_STREAMS
+
+ private:
+ class PipelineRenderer;
+ friend class PipelineRenderer;
+
+ // Separate class to allow ref counting
+ class PipelineListener;
+
+ RefPtr<PipelineRenderer> renderer_;
+ RefPtr<PipelineListener> listener_;
+};
+
+
+} // namespace mozilla
+#endif
diff --git a/media/webrtc/signaling/src/mediapipeline/MediaPipelineFilter.cpp b/media/webrtc/signaling/src/mediapipeline/MediaPipelineFilter.cpp
new file mode 100644
index 000000000..b56c272f9
--- /dev/null
+++ b/media/webrtc/signaling/src/mediapipeline/MediaPipelineFilter.cpp
@@ -0,0 +1,97 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: softtabstop=2:shiftwidth=2:expandtab
+ * */
+/* 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/. */
+
+// Original author: bcampen@mozilla.com
+
+#include "MediaPipelineFilter.h"
+
+#include "webrtc/modules/interface/module_common_types.h"
+
+namespace mozilla {
+
+MediaPipelineFilter::MediaPipelineFilter() : correlator_(0) {
+}
+
+bool MediaPipelineFilter::Filter(const webrtc::RTPHeader& header,
+ uint32_t correlator) {
+ if (correlator) {
+ // This special correlator header takes precedence. It also lets us learn
+ // about SSRC mappings if we don't know about them yet.
+ if (correlator == correlator_) {
+ AddRemoteSSRC(header.ssrc);
+ return true;
+ } else {
+ // Some other stream; it is possible that an SSRC has moved, so make sure
+ // we don't have that SSRC in our filter any more.
+ remote_ssrc_set_.erase(header.ssrc);
+ return false;
+ }
+ }
+
+ if (remote_ssrc_set_.count(header.ssrc)) {
+ return true;
+ }
+
+ // Last ditch effort...
+ if (payload_type_set_.count(header.payloadType)) {
+ // Actual match. We need to update the ssrc map so we can route rtcp
+ // sender reports correctly (these use a different payload-type field)
+ AddRemoteSSRC(header.ssrc);
+ return true;
+ }
+
+ return false;
+}
+
+void MediaPipelineFilter::AddRemoteSSRC(uint32_t ssrc) {
+ remote_ssrc_set_.insert(ssrc);
+}
+
+void MediaPipelineFilter::AddUniquePT(uint8_t payload_type) {
+ payload_type_set_.insert(payload_type);
+}
+
+void MediaPipelineFilter::SetCorrelator(uint32_t correlator) {
+ correlator_ = correlator;
+}
+
+void MediaPipelineFilter::Update(const MediaPipelineFilter& filter_update) {
+ // We will not stomp the remote_ssrc_set_ if the update has no ssrcs,
+ // because we don't want to unlearn any remote ssrcs unless the other end
+ // has explicitly given us a new set.
+ if (!filter_update.remote_ssrc_set_.empty()) {
+ remote_ssrc_set_ = filter_update.remote_ssrc_set_;
+ }
+
+ payload_type_set_ = filter_update.payload_type_set_;
+ correlator_ = filter_update.correlator_;
+}
+
+bool
+MediaPipelineFilter::FilterSenderReport(const unsigned char* data,
+ size_t len) const {
+ if (len < FIRST_SSRC_OFFSET + 4) {
+ return false;
+ }
+
+ uint8_t payload_type = data[PT_OFFSET];
+
+ if (payload_type != SENDER_REPORT_T) {
+ return false;
+ }
+
+ uint32_t ssrc = 0;
+ ssrc += (uint32_t)data[FIRST_SSRC_OFFSET] << 24;
+ ssrc += (uint32_t)data[FIRST_SSRC_OFFSET + 1] << 16;
+ ssrc += (uint32_t)data[FIRST_SSRC_OFFSET + 2] << 8;
+ ssrc += (uint32_t)data[FIRST_SSRC_OFFSET + 3];
+
+ return !!remote_ssrc_set_.count(ssrc);
+}
+
+} // end namespace mozilla
+
diff --git a/media/webrtc/signaling/src/mediapipeline/MediaPipelineFilter.h b/media/webrtc/signaling/src/mediapipeline/MediaPipelineFilter.h
new file mode 100644
index 000000000..31de8ccb2
--- /dev/null
+++ b/media/webrtc/signaling/src/mediapipeline/MediaPipelineFilter.h
@@ -0,0 +1,86 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: softtabstop=2:shiftwidth=2:expandtab
+ * */
+/* 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/. */
+
+// Original author: bcampen@mozilla.com
+
+#ifndef mediapipelinefilter_h__
+#define mediapipelinefilter_h__
+
+#include <cstddef>
+#include <stdint.h>
+
+#include <set>
+
+namespace webrtc {
+struct RTPHeader;
+}
+
+namespace mozilla {
+
+// A class that handles the work of filtering RTP packets that arrive at a
+// MediaPipeline. This is primarily important for the use of BUNDLE (ie;
+// multiple m-lines share the same RTP stream). There are three ways that this
+// can work;
+//
+// 1) In our SDP, we include a media-level extmap parameter with a unique
+// integer of our choosing, with the hope that the other side will include
+// this value in a header in the first few RTP packets it sends us. This
+// allows us to perform correlation in cases where the other side has not
+// informed us of the ssrcs it will be sending (either because it did not
+// include them in its SDP, or their SDP has not arrived yet)
+// and also gives us the opportunity to learn SSRCs from packets so adorned.
+//
+// 2) If the remote endpoint includes SSRC media-level attributes in its SDP,
+// we can simply use this information to populate the filter. The only
+// shortcoming here is when RTP packets arrive before the answer does. See
+// above.
+//
+// 3) As a fallback, we can try to use payload type IDs to perform correlation,
+// but only when the type id is unique to this media section.
+// This too allows us to learn about SSRCs (mostly useful for filtering
+// sender reports later).
+class MediaPipelineFilter {
+ public:
+ MediaPipelineFilter();
+
+ // Checks whether this packet passes the filter, possibly updating the filter
+ // in the process (if the correlator or payload types are used, they can teach
+ // the filter about ssrcs)
+ bool Filter(const webrtc::RTPHeader& header, uint32_t correlator = 0);
+
+ // RTCP doesn't have things like the RTP correlator, and uses its own
+ // payload types too.
+ bool FilterSenderReport(const unsigned char* data, size_t len) const;
+
+ void AddRemoteSSRC(uint32_t ssrc);
+
+ // When a payload type id is unique to our media section, add it here.
+ void AddUniquePT(uint8_t payload_type);
+ void SetCorrelator(uint32_t correlator);
+
+ void Update(const MediaPipelineFilter& filter_update);
+
+ // Some payload types
+ static const uint8_t SENDER_REPORT_T = 200;
+
+ private:
+ // Payload type is always in the second byte
+ static const size_t PT_OFFSET = 1;
+ // First SSRC always starts at the fifth byte.
+ static const size_t FIRST_SSRC_OFFSET = 4;
+
+ uint32_t correlator_;
+ // The number of filters we manage here is quite small, so I am optimizing
+ // for readability.
+ std::set<uint32_t> remote_ssrc_set_;
+ std::set<uint8_t> payload_type_set_;
+};
+
+} // end namespace mozilla
+
+#endif // mediapipelinefilter_h__
+
diff --git a/media/webrtc/signaling/src/mediapipeline/SrtpFlow.cpp b/media/webrtc/signaling/src/mediapipeline/SrtpFlow.cpp
new file mode 100644
index 000000000..59c3dac0a
--- /dev/null
+++ b/media/webrtc/signaling/src/mediapipeline/SrtpFlow.cpp
@@ -0,0 +1,251 @@
+/* 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/. */
+
+// Original author: ekr@rtfm.com
+
+#include "logging.h"
+#include "SrtpFlow.h"
+
+#include "srtp.h"
+#include "ssl.h"
+#include "sslproto.h"
+
+#include "mozilla/RefPtr.h"
+
+// Logging context
+using namespace mozilla;
+MOZ_MTLOG_MODULE("mediapipeline")
+
+namespace mozilla {
+
+bool SrtpFlow::initialized; // Static
+
+SrtpFlow::~SrtpFlow() {
+ if (session_) {
+ srtp_dealloc(session_);
+ }
+}
+
+RefPtr<SrtpFlow> SrtpFlow::Create(int cipher_suite,
+ bool inbound,
+ const void *key,
+ size_t key_len) {
+ nsresult res = Init();
+ if (!NS_SUCCEEDED(res))
+ return nullptr;
+
+ RefPtr<SrtpFlow> flow = new SrtpFlow();
+
+ if (!key) {
+ MOZ_MTLOG(ML_ERROR, "Null SRTP key specified");
+ return nullptr;
+ }
+
+ if (key_len != SRTP_TOTAL_KEY_LENGTH) {
+ MOZ_MTLOG(ML_ERROR, "Invalid SRTP key length");
+ return nullptr;
+ }
+
+ srtp_policy_t policy;
+ memset(&policy, 0, sizeof(srtp_policy_t));
+
+ // Note that we set the same cipher suite for RTP and RTCP
+ // since any flow can only have one cipher suite with DTLS-SRTP
+ switch (cipher_suite) {
+ case SRTP_AES128_CM_HMAC_SHA1_80:
+ MOZ_MTLOG(ML_DEBUG,
+ "Setting SRTP cipher suite SRTP_AES128_CM_HMAC_SHA1_80");
+ crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy.rtp);
+ crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy.rtcp);
+ break;
+ case SRTP_AES128_CM_HMAC_SHA1_32:
+ MOZ_MTLOG(ML_DEBUG,
+ "Setting SRTP cipher suite SRTP_AES128_CM_HMAC_SHA1_32");
+ crypto_policy_set_aes_cm_128_hmac_sha1_32(&policy.rtp);
+ crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy.rtcp); // 80-bit per RFC 5764
+ break; // S 4.1.2.
+ default:
+ MOZ_MTLOG(ML_ERROR, "Request to set unknown SRTP cipher suite");
+ return nullptr;
+ }
+ // This key is copied into the srtp_t object, so we don't
+ // need to keep it.
+ policy.key = const_cast<unsigned char *>(
+ static_cast<const unsigned char *>(key));
+ policy.ssrc.type = inbound ? ssrc_any_inbound : ssrc_any_outbound;
+ policy.ssrc.value = 0;
+ policy.ekt = nullptr;
+ policy.window_size = 1024; // Use the Chrome value. Needs to be revisited. Default is 128
+ policy.allow_repeat_tx = 1; // Use Chrome value; needed for NACK mode to work
+ policy.next = nullptr;
+
+ // Now make the session
+ err_status_t r = srtp_create(&flow->session_, &policy);
+ if (r != err_status_ok) {
+ MOZ_MTLOG(ML_ERROR, "Error creating srtp session");
+ return nullptr;
+ }
+
+ return flow;
+}
+
+
+nsresult SrtpFlow::CheckInputs(bool protect, void *in, int in_len,
+ int max_len, int *out_len) {
+ MOZ_ASSERT(in);
+ if (!in) {
+ MOZ_MTLOG(ML_ERROR, "NULL input value");
+ return NS_ERROR_NULL_POINTER;
+ }
+
+ if (in_len < 0) {
+ MOZ_MTLOG(ML_ERROR, "Input length is negative");
+ return NS_ERROR_ILLEGAL_VALUE;
+ }
+
+ if (max_len < 0) {
+ MOZ_MTLOG(ML_ERROR, "Max output length is negative");
+ return NS_ERROR_ILLEGAL_VALUE;
+ }
+
+ if (protect) {
+ if ((max_len < SRTP_MAX_EXPANSION) ||
+ ((max_len - SRTP_MAX_EXPANSION) < in_len)) {
+ MOZ_MTLOG(ML_ERROR, "Output too short");
+ return NS_ERROR_ILLEGAL_VALUE;
+ }
+ }
+ else {
+ if (in_len > max_len) {
+ MOZ_MTLOG(ML_ERROR, "Output too short");
+ return NS_ERROR_ILLEGAL_VALUE;
+ }
+ }
+
+ return NS_OK;
+}
+
+nsresult SrtpFlow::ProtectRtp(void *in, int in_len,
+ int max_len, int *out_len) {
+ nsresult res = CheckInputs(true, in, in_len, max_len, out_len);
+ if (NS_FAILED(res))
+ return res;
+
+ int len = in_len;
+ err_status_t r = srtp_protect(session_, in, &len);
+
+ if (r != err_status_ok) {
+ MOZ_MTLOG(ML_ERROR, "Error protecting SRTP packet");
+ return NS_ERROR_FAILURE;
+ }
+
+ MOZ_ASSERT(len <= max_len);
+ *out_len = len;
+
+
+ MOZ_MTLOG(ML_DEBUG, "Successfully protected an SRTP packet of len "
+ << *out_len);
+
+ return NS_OK;
+}
+
+nsresult SrtpFlow::UnprotectRtp(void *in, int in_len,
+ int max_len, int *out_len) {
+ nsresult res = CheckInputs(false, in, in_len, max_len, out_len);
+ if (NS_FAILED(res))
+ return res;
+
+ int len = in_len;
+ err_status_t r = srtp_unprotect(session_, in, &len);
+
+ if (r != err_status_ok) {
+ MOZ_MTLOG(ML_ERROR, "Error unprotecting SRTP packet error=" << (int)r);
+ return NS_ERROR_FAILURE;
+ }
+
+ MOZ_ASSERT(len <= max_len);
+ *out_len = len;
+
+ MOZ_MTLOG(ML_DEBUG, "Successfully unprotected an SRTP packet of len "
+ << *out_len);
+
+ return NS_OK;
+}
+
+nsresult SrtpFlow::ProtectRtcp(void *in, int in_len,
+ int max_len, int *out_len) {
+ nsresult res = CheckInputs(true, in, in_len, max_len, out_len);
+ if (NS_FAILED(res))
+ return res;
+
+ int len = in_len;
+ err_status_t r = srtp_protect_rtcp(session_, in, &len);
+
+ if (r != err_status_ok) {
+ MOZ_MTLOG(ML_ERROR, "Error protecting SRTCP packet");
+ return NS_ERROR_FAILURE;
+ }
+
+ MOZ_ASSERT(len <= max_len);
+ *out_len = len;
+
+ MOZ_MTLOG(ML_DEBUG, "Successfully protected an SRTCP packet of len "
+ << *out_len);
+
+ return NS_OK;
+}
+
+nsresult SrtpFlow::UnprotectRtcp(void *in, int in_len,
+ int max_len, int *out_len) {
+ nsresult res = CheckInputs(false, in, in_len, max_len, out_len);
+ if (NS_FAILED(res))
+ return res;
+
+ int len = in_len;
+ err_status_t r = srtp_unprotect_rtcp(session_, in, &len);
+
+ if (r != err_status_ok) {
+ MOZ_MTLOG(ML_ERROR, "Error unprotecting SRTCP packet error=" << (int)r);
+ return NS_ERROR_FAILURE;
+ }
+
+ MOZ_ASSERT(len <= max_len);
+ *out_len = len;
+
+ MOZ_MTLOG(ML_DEBUG, "Successfully unprotected an SRTCP packet of len "
+ << *out_len);
+
+ return NS_OK;
+}
+
+// Statics
+void SrtpFlow::srtp_event_handler(srtp_event_data_t *data) {
+ // TODO(ekr@rtfm.com): Implement this
+ MOZ_CRASH();
+}
+
+nsresult SrtpFlow::Init() {
+ if (!initialized) {
+ err_status_t r = srtp_init();
+ if (r != err_status_ok) {
+ MOZ_MTLOG(ML_ERROR, "Could not initialize SRTP");
+ MOZ_ASSERT(PR_FALSE);
+ return NS_ERROR_FAILURE;
+ }
+
+ r = srtp_install_event_handler(&SrtpFlow::srtp_event_handler);
+ if (r != err_status_ok) {
+ MOZ_MTLOG(ML_ERROR, "Could not install SRTP event handler");
+ MOZ_ASSERT(PR_FALSE);
+ return NS_ERROR_FAILURE;
+ }
+
+ initialized = true;
+ }
+
+ return NS_OK;
+}
+
+} // end of namespace
+
diff --git a/media/webrtc/signaling/src/mediapipeline/SrtpFlow.h b/media/webrtc/signaling/src/mediapipeline/SrtpFlow.h
new file mode 100644
index 000000000..9bb9c2a67
--- /dev/null
+++ b/media/webrtc/signaling/src/mediapipeline/SrtpFlow.h
@@ -0,0 +1,68 @@
+/* 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/. */
+
+// Original author: ekr@rtfm.com
+
+#ifndef srtpflow_h__
+#define srtpflow_h__
+
+#include "ssl.h"
+#include "sslproto.h"
+#include "mozilla/RefPtr.h"
+#include "nsISupportsImpl.h"
+
+typedef struct srtp_policy_t srtp_policy_t;
+typedef struct srtp_ctx_t *srtp_t;
+typedef struct srtp_event_data_t srtp_event_data_t;
+
+namespace mozilla {
+
+#define SRTP_MASTER_KEY_LENGTH 16
+#define SRTP_MASTER_SALT_LENGTH 14
+#define SRTP_TOTAL_KEY_LENGTH (SRTP_MASTER_KEY_LENGTH + SRTP_MASTER_SALT_LENGTH)
+
+// SRTCP requires an auth tag *plus* a 4-byte index-plus-'E'-bit value (see
+// RFC 3711)
+#define SRTP_MAX_EXPANSION (SRTP_MAX_TRAILER_LEN+4)
+
+
+class SrtpFlow {
+ ~SrtpFlow();
+ public:
+
+
+ static RefPtr<SrtpFlow> Create(int cipher_suite,
+ bool inbound,
+ const void *key,
+ size_t key_len);
+
+ nsresult ProtectRtp(void *in, int in_len,
+ int max_len, int *out_len);
+ nsresult UnprotectRtp(void *in, int in_len,
+ int max_len, int *out_len);
+ nsresult ProtectRtcp(void *in, int in_len,
+ int max_len, int *out_len);
+ nsresult UnprotectRtcp(void *in, int in_len,
+ int max_len, int *out_len);
+
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(SrtpFlow)
+
+ static void srtp_event_handler(srtp_event_data_t *data);
+
+
+ private:
+ SrtpFlow() : session_(nullptr) {}
+
+ nsresult CheckInputs(bool protect, void *in, int in_len,
+ int max_len, int *out_len);
+
+ static nsresult Init();
+ static bool initialized; // Was libsrtp initialized? Only happens once.
+
+ srtp_t session_;
+};
+
+} // End of namespace
+#endif
+
diff --git a/media/webrtc/signaling/src/peerconnection/MediaPipelineFactory.cpp b/media/webrtc/signaling/src/peerconnection/MediaPipelineFactory.cpp
new file mode 100644
index 000000000..61c2719cd
--- /dev/null
+++ b/media/webrtc/signaling/src/peerconnection/MediaPipelineFactory.cpp
@@ -0,0 +1,1076 @@
+/* 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 "logging.h"
+#include "nsIGfxInfo.h"
+#include "nsServiceManagerUtils.h"
+
+#include "PeerConnectionImpl.h"
+#include "PeerConnectionMedia.h"
+#include "MediaPipelineFactory.h"
+#include "MediaPipelineFilter.h"
+#include "transportflow.h"
+#include "transportlayer.h"
+#include "transportlayerdtls.h"
+#include "transportlayerice.h"
+
+#include "signaling/src/jsep/JsepTrack.h"
+#include "signaling/src/jsep/JsepTransport.h"
+#include "signaling/src/common/PtrVector.h"
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+#include "MediaStreamTrack.h"
+#include "nsIPrincipal.h"
+#include "nsIDocument.h"
+#include "mozilla/Preferences.h"
+#include "MediaEngine.h"
+#endif
+
+#include "GmpVideoCodec.h"
+#ifdef MOZ_WEBRTC_OMX
+#include "OMXVideoCodec.h"
+#include "OMXCodecWrapper.h"
+#endif
+
+#ifdef MOZ_WEBRTC_MEDIACODEC
+#include "MediaCodecVideoCodec.h"
+#endif
+
+#ifdef MOZILLA_INTERNAL_API
+#include "mozilla/Preferences.h"
+#endif
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+#include "WebrtcGmpVideoCodec.h"
+#endif
+
+#include <stdlib.h>
+
+namespace mozilla {
+
+MOZ_MTLOG_MODULE("MediaPipelineFactory")
+
+static nsresult
+JsepCodecDescToCodecConfig(const JsepCodecDescription& aCodec,
+ AudioCodecConfig** aConfig)
+{
+ MOZ_ASSERT(aCodec.mType == SdpMediaSection::kAudio);
+ if (aCodec.mType != SdpMediaSection::kAudio)
+ return NS_ERROR_INVALID_ARG;
+
+ const JsepAudioCodecDescription& desc =
+ static_cast<const JsepAudioCodecDescription&>(aCodec);
+
+ uint16_t pt;
+
+ if (!desc.GetPtAsInt(&pt)) {
+ MOZ_MTLOG(ML_ERROR, "Invalid payload type: " << desc.mDefaultPt);
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ *aConfig = new AudioCodecConfig(pt,
+ desc.mName,
+ desc.mClock,
+ desc.mPacketSize,
+ desc.mForceMono ? 1 : desc.mChannels,
+ desc.mBitrate,
+ desc.mFECEnabled);
+ (*aConfig)->mMaxPlaybackRate = desc.mMaxPlaybackRate;
+ (*aConfig)->mDtmfEnabled = desc.mDtmfEnabled;
+
+ return NS_OK;
+}
+
+static std::vector<JsepCodecDescription*>
+GetCodecs(const JsepTrackNegotiatedDetails& aDetails)
+{
+ // We do not try to handle cases where a codec is not used on the primary
+ // encoding.
+ if (aDetails.GetEncodingCount()) {
+ return aDetails.GetEncoding(0).GetCodecs();
+ }
+ return std::vector<JsepCodecDescription*>();
+}
+
+static nsresult
+NegotiatedDetailsToAudioCodecConfigs(const JsepTrackNegotiatedDetails& aDetails,
+ PtrVector<AudioCodecConfig>* aConfigs)
+{
+ std::vector<JsepCodecDescription*> codecs(GetCodecs(aDetails));
+ for (const JsepCodecDescription* codec : codecs) {
+ AudioCodecConfig* config;
+ if (NS_FAILED(JsepCodecDescToCodecConfig(*codec, &config))) {
+ return NS_ERROR_INVALID_ARG;
+ }
+ aConfigs->values.push_back(config);
+ }
+ return NS_OK;
+}
+
+static nsresult
+JsepCodecDescToCodecConfig(const JsepCodecDescription& aCodec,
+ VideoCodecConfig** aConfig)
+{
+ MOZ_ASSERT(aCodec.mType == SdpMediaSection::kVideo);
+ if (aCodec.mType != SdpMediaSection::kVideo) {
+ MOZ_ASSERT(false, "JsepCodecDescription has wrong type");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ const JsepVideoCodecDescription& desc =
+ static_cast<const JsepVideoCodecDescription&>(aCodec);
+
+ uint16_t pt;
+
+ if (!desc.GetPtAsInt(&pt)) {
+ MOZ_MTLOG(ML_ERROR, "Invalid payload type: " << desc.mDefaultPt);
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ UniquePtr<VideoCodecConfigH264> h264Config;
+
+ if (desc.mName == "H264") {
+ h264Config = MakeUnique<VideoCodecConfigH264>();
+ size_t spropSize = sizeof(h264Config->sprop_parameter_sets);
+ strncpy(h264Config->sprop_parameter_sets,
+ desc.mSpropParameterSets.c_str(),
+ spropSize);
+ h264Config->sprop_parameter_sets[spropSize - 1] = '\0';
+ h264Config->packetization_mode = desc.mPacketizationMode;
+ h264Config->profile_level_id = desc.mProfileLevelId;
+ h264Config->tias_bw = 0; // TODO. Issue 165.
+ }
+
+ VideoCodecConfig* configRaw;
+ configRaw = new VideoCodecConfig(
+ pt, desc.mName, desc.mConstraints, h264Config.get());
+
+ configRaw->mAckFbTypes = desc.mAckFbTypes;
+ configRaw->mNackFbTypes = desc.mNackFbTypes;
+ configRaw->mCcmFbTypes = desc.mCcmFbTypes;
+ configRaw->mRembFbSet = desc.RtcpFbRembIsSet();
+ configRaw->mFECFbSet = desc.mFECEnabled;
+
+ *aConfig = configRaw;
+ return NS_OK;
+}
+
+static nsresult
+NegotiatedDetailsToVideoCodecConfigs(const JsepTrackNegotiatedDetails& aDetails,
+ PtrVector<VideoCodecConfig>* aConfigs)
+{
+ std::vector<JsepCodecDescription*> codecs(GetCodecs(aDetails));
+ for (const JsepCodecDescription* codec : codecs) {
+ VideoCodecConfig* config;
+ if (NS_FAILED(JsepCodecDescToCodecConfig(*codec, &config))) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ for (size_t i = 0; i < aDetails.GetEncodingCount(); ++i) {
+ const JsepTrackEncoding& jsepEncoding(aDetails.GetEncoding(i));
+ if (jsepEncoding.HasFormat(codec->mDefaultPt)) {
+ VideoCodecConfig::SimulcastEncoding encoding;
+ encoding.rid = jsepEncoding.mRid;
+ encoding.constraints = jsepEncoding.mConstraints;
+ config->mSimulcastEncodings.push_back(encoding);
+ }
+ }
+ aConfigs->values.push_back(config);
+ }
+
+ return NS_OK;
+}
+
+// Accessing the PCMedia should be safe here because we shouldn't
+// have enqueued this function unless it was still active and
+// the ICE data is destroyed on the STS.
+static void
+FinalizeTransportFlow_s(RefPtr<PeerConnectionMedia> aPCMedia,
+ RefPtr<TransportFlow> aFlow, size_t aLevel,
+ bool aIsRtcp,
+ nsAutoPtr<PtrVector<TransportLayer> > aLayerList)
+{
+ TransportLayerIce* ice =
+ static_cast<TransportLayerIce*>(aLayerList->values.front());
+ ice->SetParameters(aPCMedia->ice_ctx(),
+ aPCMedia->ice_media_stream(aLevel),
+ aIsRtcp ? 2 : 1);
+ nsAutoPtr<std::queue<TransportLayer*> > layerQueue(
+ new std::queue<TransportLayer*>);
+ for (auto i = aLayerList->values.begin(); i != aLayerList->values.end();
+ ++i) {
+ layerQueue->push(*i);
+ }
+ aLayerList->values.clear();
+ (void)aFlow->PushLayers(layerQueue); // TODO(bug 854518): Process errors.
+}
+
+static void
+AddNewIceStreamForRestart_s(RefPtr<PeerConnectionMedia> aPCMedia,
+ RefPtr<TransportFlow> aFlow,
+ size_t aLevel,
+ bool aIsRtcp)
+{
+ TransportLayerIce* ice =
+ static_cast<TransportLayerIce*>(aFlow->GetLayer("ice"));
+ ice->SetParameters(aPCMedia->ice_ctx(),
+ aPCMedia->ice_media_stream(aLevel),
+ aIsRtcp ? 2 : 1);
+}
+
+nsresult
+MediaPipelineFactory::CreateOrGetTransportFlow(
+ size_t aLevel,
+ bool aIsRtcp,
+ const JsepTransport& aTransport,
+ RefPtr<TransportFlow>* aFlowOutparam)
+{
+ nsresult rv;
+ RefPtr<TransportFlow> flow;
+
+ flow = mPCMedia->GetTransportFlow(aLevel, aIsRtcp);
+ if (flow) {
+ if (mPCMedia->IsIceRestarting()) {
+ MOZ_MTLOG(ML_INFO, "Flow[" << flow->id() << "]: "
+ << "detected ICE restart - level: "
+ << aLevel << " rtcp: " << aIsRtcp);
+
+ rv = mPCMedia->GetSTSThread()->Dispatch(
+ WrapRunnableNM(AddNewIceStreamForRestart_s,
+ mPCMedia, flow, aLevel, aIsRtcp),
+ NS_DISPATCH_NORMAL);
+ if (NS_FAILED(rv)) {
+ MOZ_MTLOG(ML_ERROR, "Failed to dispatch AddNewIceStreamForRestart_s");
+ return rv;
+ }
+ }
+
+ *aFlowOutparam = flow;
+ return NS_OK;
+ }
+
+ std::ostringstream osId;
+ osId << mPC->GetHandle() << ":" << aLevel << ","
+ << (aIsRtcp ? "rtcp" : "rtp");
+ flow = new TransportFlow(osId.str());
+
+ // The media streams are made on STS so we need to defer setup.
+ auto ice = MakeUnique<TransportLayerIce>(mPC->GetHandle());
+ auto dtls = MakeUnique<TransportLayerDtls>();
+ dtls->SetRole(aTransport.mDtls->GetRole() ==
+ JsepDtlsTransport::kJsepDtlsClient
+ ? TransportLayerDtls::CLIENT
+ : TransportLayerDtls::SERVER);
+
+ RefPtr<DtlsIdentity> pcid = mPC->Identity();
+ if (!pcid) {
+ MOZ_MTLOG(ML_ERROR, "Failed to get DTLS identity.");
+ return NS_ERROR_FAILURE;
+ }
+ dtls->SetIdentity(pcid);
+
+ const SdpFingerprintAttributeList& fingerprints =
+ aTransport.mDtls->GetFingerprints();
+ for (auto fp = fingerprints.mFingerprints.begin();
+ fp != fingerprints.mFingerprints.end();
+ ++fp) {
+ std::ostringstream ss;
+ ss << fp->hashFunc;
+ rv = dtls->SetVerificationDigest(ss.str(), &fp->fingerprint[0],
+ fp->fingerprint.size());
+ if (NS_FAILED(rv)) {
+ MOZ_MTLOG(ML_ERROR, "Could not set fingerprint");
+ return rv;
+ }
+ }
+
+ std::vector<uint16_t> srtpCiphers;
+ srtpCiphers.push_back(SRTP_AES128_CM_HMAC_SHA1_80);
+ srtpCiphers.push_back(SRTP_AES128_CM_HMAC_SHA1_32);
+
+ rv = dtls->SetSrtpCiphers(srtpCiphers);
+ if (NS_FAILED(rv)) {
+ MOZ_MTLOG(ML_ERROR, "Couldn't set SRTP ciphers");
+ return rv;
+ }
+
+ // Always permits negotiation of the confidential mode.
+ // Only allow non-confidential (which is an allowed default),
+ // if we aren't confidential.
+ std::set<std::string> alpn;
+ std::string alpnDefault = "";
+ alpn.insert("c-webrtc");
+ if (!mPC->PrivacyRequested()) {
+ alpnDefault = "webrtc";
+ alpn.insert(alpnDefault);
+ }
+ rv = dtls->SetAlpn(alpn, alpnDefault);
+ if (NS_FAILED(rv)) {
+ MOZ_MTLOG(ML_ERROR, "Couldn't set ALPN");
+ return rv;
+ }
+
+ nsAutoPtr<PtrVector<TransportLayer> > layers(new PtrVector<TransportLayer>);
+ layers->values.push_back(ice.release());
+ layers->values.push_back(dtls.release());
+
+ rv = mPCMedia->GetSTSThread()->Dispatch(
+ WrapRunnableNM(FinalizeTransportFlow_s, mPCMedia, flow, aLevel, aIsRtcp,
+ layers),
+ NS_DISPATCH_NORMAL);
+ if (NS_FAILED(rv)) {
+ MOZ_MTLOG(ML_ERROR, "Failed to dispatch FinalizeTransportFlow_s");
+ return rv;
+ }
+
+ mPCMedia->AddTransportFlow(aLevel, aIsRtcp, flow);
+
+ *aFlowOutparam = flow;
+
+ return NS_OK;
+}
+
+nsresult
+MediaPipelineFactory::GetTransportParameters(
+ const JsepTrackPair& aTrackPair,
+ const JsepTrack& aTrack,
+ size_t* aLevelOut,
+ RefPtr<TransportFlow>* aRtpOut,
+ RefPtr<TransportFlow>* aRtcpOut,
+ nsAutoPtr<MediaPipelineFilter>* aFilterOut)
+{
+ *aLevelOut = aTrackPair.mLevel;
+
+ size_t transportLevel = aTrackPair.mBundleLevel.isSome() ?
+ *aTrackPair.mBundleLevel :
+ aTrackPair.mLevel;
+
+ nsresult rv = CreateOrGetTransportFlow(
+ transportLevel, false, *aTrackPair.mRtpTransport, aRtpOut);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ MOZ_ASSERT(aRtpOut);
+
+ if (aTrackPair.mRtcpTransport) {
+ rv = CreateOrGetTransportFlow(
+ transportLevel, true, *aTrackPair.mRtcpTransport, aRtcpOut);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ MOZ_ASSERT(aRtcpOut);
+ }
+
+ if (aTrackPair.mBundleLevel.isSome()) {
+ bool receiving = aTrack.GetDirection() == sdp::kRecv;
+
+ *aFilterOut = new MediaPipelineFilter;
+
+ if (receiving) {
+ // Add remote SSRCs so we can distinguish which RTP packets actually
+ // belong to this pipeline (also RTCP sender reports).
+ for (auto i = aTrack.GetSsrcs().begin();
+ i != aTrack.GetSsrcs().end(); ++i) {
+ (*aFilterOut)->AddRemoteSSRC(*i);
+ }
+
+ // TODO(bug 1105005): Tell the filter about the mid for this track
+
+ // Add unique payload types as a last-ditch fallback
+ auto uniquePts = aTrack.GetNegotiatedDetails()->GetUniquePayloadTypes();
+ for (auto i = uniquePts.begin(); i != uniquePts.end(); ++i) {
+ (*aFilterOut)->AddUniquePT(*i);
+ }
+ }
+ }
+
+ return NS_OK;
+}
+
+nsresult
+MediaPipelineFactory::CreateOrUpdateMediaPipeline(
+ const JsepTrackPair& aTrackPair,
+ const JsepTrack& aTrack)
+{
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ // The GMP code is all the way on the other side of webrtc.org, and it is not
+ // feasible to plumb this information all the way through. So, we set it (for
+ // the duration of this call) in a global variable. This allows the GMP code
+ // to report errors to the PC.
+ WebrtcGmpPCHandleSetter setter(mPC->GetHandle());
+#endif
+
+ MOZ_ASSERT(aTrackPair.mRtpTransport);
+
+ bool receiving = aTrack.GetDirection() == sdp::kRecv;
+
+ size_t level;
+ RefPtr<TransportFlow> rtpFlow;
+ RefPtr<TransportFlow> rtcpFlow;
+ nsAutoPtr<MediaPipelineFilter> filter;
+
+ nsresult rv = GetTransportParameters(aTrackPair,
+ aTrack,
+ &level,
+ &rtpFlow,
+ &rtcpFlow,
+ &filter);
+ if (NS_FAILED(rv)) {
+ MOZ_MTLOG(ML_ERROR, "Failed to get transport parameters for pipeline, rv="
+ << static_cast<unsigned>(rv));
+ return rv;
+ }
+
+ if (aTrack.GetMediaType() == SdpMediaSection::kApplication) {
+ // GetTransportParameters has already done everything we need for
+ // datachannel.
+ return NS_OK;
+ }
+
+ // Find the stream we need
+ SourceStreamInfo* stream;
+ if (receiving) {
+ stream = mPCMedia->GetRemoteStreamById(aTrack.GetStreamId());
+ } else {
+ stream = mPCMedia->GetLocalStreamById(aTrack.GetStreamId());
+ }
+
+ if (!stream) {
+ MOZ_MTLOG(ML_ERROR, "Negotiated " << (receiving ? "recv" : "send")
+ << " stream id " << aTrack.GetStreamId() << " was never added");
+ MOZ_ASSERT(false);
+ return NS_ERROR_FAILURE;
+ }
+
+ if (!stream->HasTrack(aTrack.GetTrackId())) {
+ MOZ_MTLOG(ML_ERROR, "Negotiated " << (receiving ? "recv" : "send")
+ << " track id " << aTrack.GetTrackId() << " was never added");
+ MOZ_ASSERT(false);
+ return NS_ERROR_FAILURE;
+ }
+
+ RefPtr<MediaSessionConduit> conduit;
+ if (aTrack.GetMediaType() == SdpMediaSection::kAudio) {
+ rv = GetOrCreateAudioConduit(aTrackPair, aTrack, &conduit);
+ if (NS_FAILED(rv))
+ return rv;
+ } else if (aTrack.GetMediaType() == SdpMediaSection::kVideo) {
+ rv = GetOrCreateVideoConduit(aTrackPair, aTrack, &conduit);
+ if (NS_FAILED(rv))
+ return rv;
+ } else {
+ // We've created the TransportFlow, nothing else to do here.
+ return NS_OK;
+ }
+
+ if (aTrack.GetActive()) {
+ if (receiving) {
+ auto error = conduit->StartReceiving();
+ if (error) {
+ MOZ_MTLOG(ML_ERROR, "StartReceiving failed: " << error);
+ return NS_ERROR_FAILURE;
+ }
+ } else {
+ auto error = conduit->StartTransmitting();
+ if (error) {
+ MOZ_MTLOG(ML_ERROR, "StartTransmitting failed: " << error);
+ return NS_ERROR_FAILURE;
+ }
+ }
+ } else {
+ if (receiving) {
+ auto error = conduit->StopReceiving();
+ if (error) {
+ MOZ_MTLOG(ML_ERROR, "StopReceiving failed: " << error);
+ return NS_ERROR_FAILURE;
+ }
+ } else {
+ auto error = conduit->StopTransmitting();
+ if (error) {
+ MOZ_MTLOG(ML_ERROR, "StopTransmitting failed: " << error);
+ return NS_ERROR_FAILURE;
+ }
+ }
+ }
+
+ RefPtr<MediaPipeline> pipeline =
+ stream->GetPipelineByTrackId_m(aTrack.GetTrackId());
+
+ if (pipeline && pipeline->level() != static_cast<int>(level)) {
+ MOZ_MTLOG(ML_WARNING, "Track " << aTrack.GetTrackId() <<
+ " has moved from level " << pipeline->level() <<
+ " to level " << level <<
+ ". This requires re-creating the MediaPipeline.");
+ RefPtr<dom::MediaStreamTrack> domTrack =
+ stream->GetTrackById(aTrack.GetTrackId());
+ MOZ_ASSERT(domTrack, "MediaPipeline existed for a track, but no MediaStreamTrack");
+
+ // Since we do not support changing the conduit on a pre-existing
+ // MediaPipeline
+ pipeline = nullptr;
+ stream->RemoveTrack(aTrack.GetTrackId());
+ stream->AddTrack(aTrack.GetTrackId(), domTrack);
+ }
+
+ if (pipeline) {
+ pipeline->UpdateTransport_m(level, rtpFlow, rtcpFlow, filter);
+ return NS_OK;
+ }
+
+ MOZ_MTLOG(ML_DEBUG,
+ "Creating media pipeline"
+ << " m-line index=" << aTrackPair.mLevel
+ << " type=" << aTrack.GetMediaType()
+ << " direction=" << aTrack.GetDirection());
+
+ if (receiving) {
+ rv = CreateMediaPipelineReceiving(aTrackPair, aTrack,
+ level, rtpFlow, rtcpFlow, filter,
+ conduit);
+ if (NS_FAILED(rv))
+ return rv;
+ } else {
+ rv = CreateMediaPipelineSending(aTrackPair, aTrack,
+ level, rtpFlow, rtcpFlow, filter,
+ conduit);
+ if (NS_FAILED(rv))
+ return rv;
+ }
+
+ return NS_OK;
+}
+
+nsresult
+MediaPipelineFactory::CreateMediaPipelineReceiving(
+ const JsepTrackPair& aTrackPair,
+ const JsepTrack& aTrack,
+ size_t aLevel,
+ RefPtr<TransportFlow> aRtpFlow,
+ RefPtr<TransportFlow> aRtcpFlow,
+ nsAutoPtr<MediaPipelineFilter> aFilter,
+ const RefPtr<MediaSessionConduit>& aConduit)
+{
+ // We will error out earlier if this isn't here.
+ RefPtr<RemoteSourceStreamInfo> stream =
+ mPCMedia->GetRemoteStreamById(aTrack.GetStreamId());
+
+ RefPtr<MediaPipelineReceive> pipeline;
+
+ TrackID numericTrackId = stream->GetNumericTrackId(aTrack.GetTrackId());
+ MOZ_ASSERT(IsTrackIDExplicit(numericTrackId));
+
+ MOZ_MTLOG(ML_DEBUG, __FUNCTION__ << ": Creating pipeline for "
+ << numericTrackId << " -> " << aTrack.GetTrackId());
+
+ if (aTrack.GetMediaType() == SdpMediaSection::kAudio) {
+ pipeline = new MediaPipelineReceiveAudio(
+ mPC->GetHandle(),
+ mPC->GetMainThread().get(),
+ mPC->GetSTSThread(),
+ stream->GetMediaStream()->GetInputStream()->AsSourceStream(),
+ aTrack.GetTrackId(),
+ numericTrackId,
+ aLevel,
+ static_cast<AudioSessionConduit*>(aConduit.get()), // Ugly downcast.
+ aRtpFlow,
+ aRtcpFlow,
+ aFilter);
+ } else if (aTrack.GetMediaType() == SdpMediaSection::kVideo) {
+ pipeline = new MediaPipelineReceiveVideo(
+ mPC->GetHandle(),
+ mPC->GetMainThread().get(),
+ mPC->GetSTSThread(),
+ stream->GetMediaStream()->GetInputStream()->AsSourceStream(),
+ aTrack.GetTrackId(),
+ numericTrackId,
+ aLevel,
+ static_cast<VideoSessionConduit*>(aConduit.get()), // Ugly downcast.
+ aRtpFlow,
+ aRtcpFlow,
+ aFilter);
+ } else {
+ MOZ_ASSERT(false);
+ MOZ_MTLOG(ML_ERROR, "Invalid media type in CreateMediaPipelineReceiving");
+ return NS_ERROR_FAILURE;
+ }
+
+ nsresult rv = pipeline->Init();
+ if (NS_FAILED(rv)) {
+ MOZ_MTLOG(ML_ERROR, "Couldn't initialize receiving pipeline");
+ return rv;
+ }
+
+ rv = stream->StorePipeline(aTrack.GetTrackId(),
+ RefPtr<MediaPipeline>(pipeline));
+ if (NS_FAILED(rv)) {
+ MOZ_MTLOG(ML_ERROR, "Couldn't store receiving pipeline " <<
+ static_cast<unsigned>(rv));
+ return rv;
+ }
+
+ stream->SyncPipeline(pipeline);
+
+ return NS_OK;
+}
+
+nsresult
+MediaPipelineFactory::CreateMediaPipelineSending(
+ const JsepTrackPair& aTrackPair,
+ const JsepTrack& aTrack,
+ size_t aLevel,
+ RefPtr<TransportFlow> aRtpFlow,
+ RefPtr<TransportFlow> aRtcpFlow,
+ nsAutoPtr<MediaPipelineFilter> aFilter,
+ const RefPtr<MediaSessionConduit>& aConduit)
+{
+ nsresult rv;
+
+ // This is checked earlier
+ RefPtr<LocalSourceStreamInfo> stream =
+ mPCMedia->GetLocalStreamById(aTrack.GetStreamId());
+
+ dom::MediaStreamTrack* track =
+ stream->GetTrackById(aTrack.GetTrackId());
+ MOZ_ASSERT(track);
+
+ // Now we have all the pieces, create the pipeline
+ RefPtr<MediaPipelineTransmit> pipeline = new MediaPipelineTransmit(
+ mPC->GetHandle(),
+ mPC->GetMainThread().get(),
+ mPC->GetSTSThread(),
+ track,
+ aTrack.GetTrackId(),
+ aLevel,
+ aConduit,
+ aRtpFlow,
+ aRtcpFlow,
+ aFilter);
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ // implement checking for peerIdentity (where failure == black/silence)
+ nsIDocument* doc = mPC->GetWindow()->GetExtantDoc();
+ if (doc) {
+ pipeline->UpdateSinkIdentity_m(track,
+ doc->NodePrincipal(),
+ mPC->GetPeerIdentity());
+ } else {
+ MOZ_MTLOG(ML_ERROR, "Cannot initialize pipeline without attached doc");
+ return NS_ERROR_FAILURE; // Don't remove this till we know it's safe.
+ }
+#endif
+
+ rv = pipeline->Init();
+ if (NS_FAILED(rv)) {
+ MOZ_MTLOG(ML_ERROR, "Couldn't initialize sending pipeline");
+ return rv;
+ }
+
+ rv = stream->StorePipeline(aTrack.GetTrackId(),
+ RefPtr<MediaPipeline>(pipeline));
+ if (NS_FAILED(rv)) {
+ MOZ_MTLOG(ML_ERROR, "Couldn't store receiving pipeline " <<
+ static_cast<unsigned>(rv));
+ return rv;
+ }
+
+ return NS_OK;
+}
+
+nsresult
+MediaPipelineFactory::GetOrCreateAudioConduit(
+ const JsepTrackPair& aTrackPair,
+ const JsepTrack& aTrack,
+ RefPtr<MediaSessionConduit>* aConduitp)
+{
+
+ if (!aTrack.GetNegotiatedDetails()) {
+ MOZ_ASSERT(false, "Track is missing negotiated details");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ bool receiving = aTrack.GetDirection() == sdp::kRecv;
+
+ RefPtr<AudioSessionConduit> conduit =
+ mPCMedia->GetAudioConduit(aTrackPair.mLevel);
+
+ if (!conduit) {
+ conduit = AudioSessionConduit::Create();
+ if (!conduit) {
+ MOZ_MTLOG(ML_ERROR, "Could not create audio conduit");
+ return NS_ERROR_FAILURE;
+ }
+
+ mPCMedia->AddAudioConduit(aTrackPair.mLevel, conduit);
+ }
+
+ PtrVector<AudioCodecConfig> configs;
+ nsresult rv = NegotiatedDetailsToAudioCodecConfigs(
+ *aTrack.GetNegotiatedDetails(), &configs);
+
+ if (NS_FAILED(rv)) {
+ MOZ_MTLOG(ML_ERROR, "Failed to convert JsepCodecDescriptions to "
+ "AudioCodecConfigs.");
+ return rv;
+ }
+
+ if (configs.values.empty()) {
+ MOZ_MTLOG(ML_ERROR, "Can't set up a conduit with 0 codecs");
+ return NS_ERROR_FAILURE;
+ }
+
+ if (receiving) {
+ auto error = conduit->ConfigureRecvMediaCodecs(configs.values);
+
+ if (error) {
+ MOZ_MTLOG(ML_ERROR, "ConfigureRecvMediaCodecs failed: " << error);
+ return NS_ERROR_FAILURE;
+ }
+
+ if (!aTrackPair.mSending) {
+ // No send track, but we still need to configure an SSRC for receiver
+ // reports.
+ if (!conduit->SetLocalSSRC(aTrackPair.mRecvonlySsrc)) {
+ MOZ_MTLOG(ML_ERROR, "SetLocalSSRC failed");
+ return NS_ERROR_FAILURE;
+ }
+ }
+ } else {
+ // For now we only expect to have one ssrc per local track.
+ auto ssrcs = aTrack.GetSsrcs();
+ if (!ssrcs.empty()) {
+ if (!conduit->SetLocalSSRC(ssrcs.front())) {
+ MOZ_MTLOG(ML_ERROR, "SetLocalSSRC failed");
+ return NS_ERROR_FAILURE;
+ }
+ }
+
+ conduit->SetLocalCNAME(aTrack.GetCNAME().c_str());
+
+ if (configs.values.size() > 1
+ && configs.values.back()->mName == "telephone-event") {
+ // we have a telephone event codec, so we need to make sure
+ // the dynamic pt is set properly
+ conduit->SetDtmfPayloadType(configs.values.back()->mType);
+ }
+
+ auto error = conduit->ConfigureSendMediaCodec(configs.values[0]);
+ if (error) {
+ MOZ_MTLOG(ML_ERROR, "ConfigureSendMediaCodec failed: " << error);
+ return NS_ERROR_FAILURE;
+ }
+
+ const SdpExtmapAttributeList::Extmap* audioLevelExt =
+ aTrack.GetNegotiatedDetails()->GetExt(
+ "urn:ietf:params:rtp-hdrext:ssrc-audio-level");
+
+ if (audioLevelExt) {
+ MOZ_MTLOG(ML_DEBUG, "Calling EnableAudioLevelExtension");
+ error = conduit->EnableAudioLevelExtension(true, audioLevelExt->entry);
+
+ if (error) {
+ MOZ_MTLOG(ML_ERROR, "EnableAudioLevelExtension failed: " << error);
+ return NS_ERROR_FAILURE;
+ }
+ }
+ }
+
+ *aConduitp = conduit;
+
+ return NS_OK;
+}
+
+nsresult
+MediaPipelineFactory::GetOrCreateVideoConduit(
+ const JsepTrackPair& aTrackPair,
+ const JsepTrack& aTrack,
+ RefPtr<MediaSessionConduit>* aConduitp)
+{
+
+ if (!aTrack.GetNegotiatedDetails()) {
+ MOZ_ASSERT(false, "Track is missing negotiated details");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ bool receiving = aTrack.GetDirection() == sdp::kRecv;
+
+ RefPtr<VideoSessionConduit> conduit =
+ mPCMedia->GetVideoConduit(aTrackPair.mLevel);
+
+ if (!conduit) {
+ conduit = VideoSessionConduit::Create();
+ if (!conduit) {
+ MOZ_MTLOG(ML_ERROR, "Could not create video conduit");
+ return NS_ERROR_FAILURE;
+ }
+
+ mPCMedia->AddVideoConduit(aTrackPair.mLevel, conduit);
+ }
+
+ PtrVector<VideoCodecConfig> configs;
+ nsresult rv = NegotiatedDetailsToVideoCodecConfigs(
+ *aTrack.GetNegotiatedDetails(), &configs);
+
+ if (NS_FAILED(rv)) {
+ MOZ_MTLOG(ML_ERROR, "Failed to convert JsepCodecDescriptions to "
+ "VideoCodecConfigs.");
+ return rv;
+ }
+
+ if (configs.values.empty()) {
+ MOZ_MTLOG(ML_ERROR, "Can't set up a conduit with 0 codecs");
+ return NS_ERROR_FAILURE;
+ }
+
+ if (receiving) {
+ if (aTrackPair.mSending) {
+ auto ssrcs = &aTrackPair.mSending->GetSsrcs();
+ if (!ssrcs->empty()) {
+ if (!conduit->SetLocalSSRC(ssrcs->front())) {
+ MOZ_MTLOG(ML_ERROR, "SetLocalSSRC failed(1)");
+ return NS_ERROR_FAILURE;
+ }
+ } else {
+ MOZ_MTLOG(ML_ERROR, "Sending without an SSRC??");
+ return NS_ERROR_FAILURE;
+ }
+ } else {
+ // No send track, but we still need to configure an SSRC for receiver
+ // reports.
+ if (!conduit->SetLocalSSRC(aTrackPair.mRecvonlySsrc)) {
+ MOZ_MTLOG(ML_ERROR, "SetLocalSSRC failed(2)");
+ return NS_ERROR_FAILURE;
+ }
+ }
+
+ // Prune out stuff we cannot actually do. We should work to eliminate the
+ // need for this.
+ bool configuredH264 = false;
+ for (size_t i = 0; i < configs.values.size();) {
+ // TODO(bug 1200768): We can only handle configuring one recv H264 codec
+ if (configuredH264 && (configs.values[i]->mName == "H264")) {
+ delete configs.values[i];
+ configs.values.erase(configs.values.begin() + i);
+ continue;
+ }
+
+ // TODO(bug 1018791): This really should be checked sooner
+ if (EnsureExternalCodec(*conduit, configs.values[i], false)) {
+ delete configs.values[i];
+ configs.values.erase(configs.values.begin() + i);
+ continue;
+ }
+
+ if (configs.values[i]->mName == "H264") {
+ configuredH264 = true;
+ }
+ ++i;
+ }
+
+ auto error = conduit->ConfigureRecvMediaCodecs(configs.values);
+
+ if (error) {
+ MOZ_MTLOG(ML_ERROR, "ConfigureRecvMediaCodecs failed: " << error);
+ return NS_ERROR_FAILURE;
+ }
+ } else {
+ // For now we only expect to have one ssrc per local track.
+ auto ssrcs = aTrack.GetSsrcs();
+ if (!ssrcs.empty()) {
+ if (!conduit->SetLocalSSRC(ssrcs.front())) {
+ MOZ_MTLOG(ML_ERROR, "SetLocalSSRC failed");
+ return NS_ERROR_FAILURE;
+ }
+ }
+
+ conduit->SetLocalCNAME(aTrack.GetCNAME().c_str());
+
+ rv = ConfigureVideoCodecMode(aTrack,*conduit);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ // TODO(bug 1018791): This really should be checked sooner
+ if (EnsureExternalCodec(*conduit, configs.values[0], true)) {
+ MOZ_MTLOG(ML_ERROR, "External codec not available");
+ return NS_ERROR_FAILURE;
+ }
+
+
+ auto error = conduit->ConfigureSendMediaCodec(configs.values[0]);
+
+ const SdpExtmapAttributeList::Extmap* rtpStreamIdExt =
+ aTrack.GetNegotiatedDetails()->GetExt(
+ "urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id");
+
+ if (rtpStreamIdExt) {
+ MOZ_MTLOG(ML_DEBUG, "Calling EnableRTPSenderIdExtension");
+ error = conduit->EnableRTPStreamIdExtension(true, rtpStreamIdExt->entry);
+
+ if (error) {
+ MOZ_MTLOG(ML_ERROR, "EnableRTPSenderIdExtension failed: " << error);
+ return NS_ERROR_FAILURE;
+ }
+ }
+
+ if (error) {
+ MOZ_MTLOG(ML_ERROR, "ConfigureSendMediaCodec failed: " << error);
+ return NS_ERROR_FAILURE;
+ }
+ }
+
+ *aConduitp = conduit;
+
+ return NS_OK;
+}
+
+nsresult
+MediaPipelineFactory::ConfigureVideoCodecMode(const JsepTrack& aTrack,
+ VideoSessionConduit& aConduit)
+{
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ RefPtr<LocalSourceStreamInfo> stream =
+ mPCMedia->GetLocalStreamByTrackId(aTrack.GetTrackId());
+
+ //get video track
+ RefPtr<mozilla::dom::MediaStreamTrack> track =
+ stream->GetTrackById(aTrack.GetTrackId());
+
+ RefPtr<mozilla::dom::VideoStreamTrack> videotrack =
+ track->AsVideoStreamTrack();
+
+ if (!videotrack) {
+ MOZ_MTLOG(ML_ERROR, "video track not available");
+ return NS_ERROR_FAILURE;
+ }
+
+ dom::MediaSourceEnum source = videotrack->GetSource().GetMediaSource();
+ webrtc::VideoCodecMode mode = webrtc::kRealtimeVideo;
+ switch (source) {
+ case dom::MediaSourceEnum::Browser:
+ case dom::MediaSourceEnum::Screen:
+ case dom::MediaSourceEnum::Application:
+ case dom::MediaSourceEnum::Window:
+ mode = webrtc::kScreensharing;
+ break;
+
+ case dom::MediaSourceEnum::Camera:
+ default:
+ mode = webrtc::kRealtimeVideo;
+ break;
+ }
+
+ auto error = aConduit.ConfigureCodecMode(mode);
+ if (error) {
+ MOZ_MTLOG(ML_ERROR, "ConfigureCodecMode failed: " << error);
+ return NS_ERROR_FAILURE;
+ }
+
+#endif
+ return NS_OK;
+}
+
+/*
+ * Add external H.264 video codec.
+ */
+MediaConduitErrorCode
+MediaPipelineFactory::EnsureExternalCodec(VideoSessionConduit& aConduit,
+ VideoCodecConfig* aConfig,
+ bool aIsSend)
+{
+ if (aConfig->mName == "VP8") {
+#ifdef MOZ_WEBRTC_MEDIACODEC
+ if (aIsSend) {
+#ifdef MOZILLA_INTERNAL_API
+ bool enabled = mozilla::Preferences::GetBool("media.navigator.hardware.vp8_encode.acceleration_enabled", false);
+#else
+ bool enabled = false;
+#endif
+ if (enabled) {
+ nsCOMPtr<nsIGfxInfo> gfxInfo = do_GetService("@mozilla.org/gfx/info;1");
+ if (gfxInfo) {
+ int32_t status;
+ nsCString discardFailureId;
+ if (NS_SUCCEEDED(gfxInfo->GetFeatureStatus(nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION_ENCODE, discardFailureId, &status))) {
+ if (status != nsIGfxInfo::FEATURE_STATUS_OK) {
+ NS_WARNING("VP8 encoder hardware is not whitelisted: disabling.\n");
+ } else {
+ VideoEncoder* encoder = nullptr;
+ encoder = MediaCodecVideoCodec::CreateEncoder(MediaCodecVideoCodec::CodecType::CODEC_VP8);
+ if (encoder) {
+ return aConduit.SetExternalSendCodec(aConfig, encoder);
+ }
+ return kMediaConduitNoError;
+ }
+ }
+ }
+ }
+ } else {
+#ifdef MOZILLA_INTERNAL_API
+ bool enabled = mozilla::Preferences::GetBool("media.navigator.hardware.vp8_decode.acceleration_enabled", false);
+#else
+ bool enabled = false;
+#endif
+ if (enabled) {
+ nsCOMPtr<nsIGfxInfo> gfxInfo = do_GetService("@mozilla.org/gfx/info;1");
+ if (gfxInfo) {
+ int32_t status;
+ nsCString discardFailureId;
+ if (NS_SUCCEEDED(gfxInfo->GetFeatureStatus(nsIGfxInfo::FEATURE_WEBRTC_HW_ACCELERATION_DECODE, discardFailureId, &status))) {
+ if (status != nsIGfxInfo::FEATURE_STATUS_OK) {
+ NS_WARNING("VP8 decoder hardware is not whitelisted: disabling.\n");
+ } else {
+ VideoDecoder* decoder;
+ decoder = MediaCodecVideoCodec::CreateDecoder(MediaCodecVideoCodec::CodecType::CODEC_VP8);
+ if (decoder) {
+ return aConduit.SetExternalRecvCodec(aConfig, decoder);
+ }
+ return kMediaConduitNoError;
+ }
+ }
+ }
+ }
+ }
+#endif
+ return kMediaConduitNoError;
+ }
+ if (aConfig->mName == "VP9") {
+ return kMediaConduitNoError;
+ }
+ if (aConfig->mName == "H264") {
+ if (aConduit.CodecPluginID() != 0) {
+ return kMediaConduitNoError;
+ }
+ // Register H.264 codec.
+ if (aIsSend) {
+ VideoEncoder* encoder = nullptr;
+#ifdef MOZ_WEBRTC_OMX
+ encoder =
+ OMXVideoCodec::CreateEncoder(OMXVideoCodec::CodecType::CODEC_H264);
+#else
+ encoder = GmpVideoCodec::CreateEncoder();
+#endif
+ if (encoder) {
+ return aConduit.SetExternalSendCodec(aConfig, encoder);
+ }
+ return kMediaConduitInvalidSendCodec;
+ }
+ VideoDecoder* decoder = nullptr;
+#ifdef MOZ_WEBRTC_OMX
+ decoder =
+ OMXVideoCodec::CreateDecoder(OMXVideoCodec::CodecType::CODEC_H264);
+#else
+ decoder = GmpVideoCodec::CreateDecoder();
+#endif
+ if (decoder) {
+ return aConduit.SetExternalRecvCodec(aConfig, decoder);
+ }
+ return kMediaConduitInvalidReceiveCodec;
+ }
+ MOZ_MTLOG(ML_ERROR,
+ "Invalid video codec configured: " << aConfig->mName.c_str());
+ return aIsSend ? kMediaConduitInvalidSendCodec
+ : kMediaConduitInvalidReceiveCodec;
+}
+
+} // namespace mozilla
diff --git a/media/webrtc/signaling/src/peerconnection/MediaPipelineFactory.h b/media/webrtc/signaling/src/peerconnection/MediaPipelineFactory.h
new file mode 100644
index 000000000..972c4368a
--- /dev/null
+++ b/media/webrtc/signaling/src/peerconnection/MediaPipelineFactory.h
@@ -0,0 +1,82 @@
+/* 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/. */
+#ifndef _MEDIAPIPELINEFACTORY_H_
+#define _MEDIAPIPELINEFACTORY_H_
+
+#include "MediaConduitInterface.h"
+#include "PeerConnectionMedia.h"
+#include "transportflow.h"
+
+#include "signaling/src/jsep/JsepTrack.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/UniquePtr.h"
+
+namespace mozilla {
+
+class MediaPipelineFactory
+{
+public:
+ explicit MediaPipelineFactory(PeerConnectionMedia* aPCMedia)
+ : mPCMedia(aPCMedia), mPC(aPCMedia->GetPC())
+ {
+ }
+
+ nsresult CreateOrUpdateMediaPipeline(const JsepTrackPair& aTrackPair,
+ const JsepTrack& aTrack);
+
+private:
+ nsresult CreateMediaPipelineReceiving(
+ const JsepTrackPair& aTrackPair,
+ const JsepTrack& aTrack,
+ size_t level,
+ RefPtr<TransportFlow> aRtpFlow,
+ RefPtr<TransportFlow> aRtcpFlow,
+ nsAutoPtr<MediaPipelineFilter> filter,
+ const RefPtr<MediaSessionConduit>& aConduit);
+
+ nsresult CreateMediaPipelineSending(
+ const JsepTrackPair& aTrackPair,
+ const JsepTrack& aTrack,
+ size_t level,
+ RefPtr<TransportFlow> aRtpFlow,
+ RefPtr<TransportFlow> aRtcpFlow,
+ nsAutoPtr<MediaPipelineFilter> filter,
+ const RefPtr<MediaSessionConduit>& aConduit);
+
+ nsresult GetOrCreateAudioConduit(const JsepTrackPair& aTrackPair,
+ const JsepTrack& aTrack,
+ RefPtr<MediaSessionConduit>* aConduitp);
+
+ nsresult GetOrCreateVideoConduit(const JsepTrackPair& aTrackPair,
+ const JsepTrack& aTrack,
+ RefPtr<MediaSessionConduit>* aConduitp);
+
+ MediaConduitErrorCode EnsureExternalCodec(VideoSessionConduit& aConduit,
+ VideoCodecConfig* aConfig,
+ bool aIsSend);
+
+ nsresult CreateOrGetTransportFlow(size_t aLevel, bool aIsRtcp,
+ const JsepTransport& transport,
+ RefPtr<TransportFlow>* out);
+
+ nsresult GetTransportParameters(const JsepTrackPair& aTrackPair,
+ const JsepTrack& aTrack,
+ size_t* aLevelOut,
+ RefPtr<TransportFlow>* aRtpOut,
+ RefPtr<TransportFlow>* aRtcpOut,
+ nsAutoPtr<MediaPipelineFilter>* aFilterOut);
+
+ nsresult ConfigureVideoCodecMode(const JsepTrack& aTrack,
+ VideoSessionConduit& aConduit);
+
+private:
+ // Not owned, and assumed to exist as long as the factory.
+ // The factory is a transient object, so this is fairly easy.
+ PeerConnectionMedia* mPCMedia;
+ PeerConnectionImpl* mPC;
+};
+
+} // namespace mozilla
+
+#endif
diff --git a/media/webrtc/signaling/src/peerconnection/MediaStreamList.cpp b/media/webrtc/signaling/src/peerconnection/MediaStreamList.cpp
new file mode 100644
index 000000000..f10b4447f
--- /dev/null
+++ b/media/webrtc/signaling/src/peerconnection/MediaStreamList.cpp
@@ -0,0 +1,104 @@
+/* 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 "CSFLog.h"
+#include "base/basictypes.h"
+#include "MediaStreamList.h"
+#ifdef MOZILLA_INTERNAL_API
+#include "mozilla/dom/MediaStreamListBinding.h"
+#endif
+#include "nsIScriptGlobalObject.h"
+#include "PeerConnectionImpl.h"
+#include "PeerConnectionMedia.h"
+
+namespace mozilla {
+namespace dom {
+
+MediaStreamList::MediaStreamList(PeerConnectionImpl* peerConnection,
+ StreamType type)
+ : mPeerConnection(peerConnection),
+ mType(type)
+{
+}
+
+MediaStreamList::~MediaStreamList()
+{
+}
+
+#ifdef MOZILLA_INTERNAL_API
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(MediaStreamList)
+#else
+NS_IMPL_CYCLE_COLLECTION_CLASS(MediaStreamList)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(MediaStreamList)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(MediaStreamList)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(MediaStreamList)
+NS_IMPL_CYCLE_COLLECTION_TRACE_END
+#endif
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(MediaStreamList)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(MediaStreamList)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(MediaStreamList)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+JSObject*
+MediaStreamList::WrapObject(JSContext* cx, JS::Handle<JSObject*> aGivenProto)
+{
+#ifdef MOZILLA_INTERNAL_API
+ return MediaStreamListBinding::Wrap(cx, this, aGivenProto);
+#else
+ return nullptr;
+#endif
+}
+
+nsISupports*
+MediaStreamList::GetParentObject()
+{
+ return mPeerConnection->GetWindow();
+}
+
+template<class T>
+static DOMMediaStream*
+GetStreamFromInfo(T* info, bool& found)
+{
+ if (!info) {
+ found = false;
+ return nullptr;
+ }
+
+ found = true;
+ return info->GetMediaStream();
+}
+
+DOMMediaStream*
+MediaStreamList::IndexedGetter(uint32_t index, bool& found)
+{
+ if (!mPeerConnection->media()) { // PeerConnection closed
+ found = false;
+ return nullptr;
+ }
+ if (mType == Local) {
+ return GetStreamFromInfo(mPeerConnection->media()->
+ GetLocalStreamByIndex(index), found);
+ }
+
+ return GetStreamFromInfo(mPeerConnection->media()->
+ GetRemoteStreamByIndex(index), found);
+}
+
+uint32_t
+MediaStreamList::Length()
+{
+ if (!mPeerConnection->media()) { // PeerConnection closed
+ return 0;
+ }
+ return mType == Local ? mPeerConnection->media()->LocalStreamsLength() :
+ mPeerConnection->media()->RemoteStreamsLength();
+}
+
+} // namespace dom
+} // namespace mozilla
diff --git a/media/webrtc/signaling/src/peerconnection/MediaStreamList.h b/media/webrtc/signaling/src/peerconnection/MediaStreamList.h
new file mode 100644
index 000000000..de9040227
--- /dev/null
+++ b/media/webrtc/signaling/src/peerconnection/MediaStreamList.h
@@ -0,0 +1,54 @@
+/* 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/. */
+
+#ifndef MediaStreamList_h__
+#define MediaStreamList_h__
+
+#include "mozilla/ErrorResult.h"
+#include "nsISupportsImpl.h"
+#include "nsAutoPtr.h"
+#include "nsWrapperCache.h"
+
+#ifdef USE_FAKE_MEDIA_STREAMS
+#include "FakeMediaStreams.h"
+#else
+#include "DOMMediaStream.h"
+#endif
+
+namespace mozilla {
+class PeerConnectionImpl;
+namespace dom {
+
+class MediaStreamList : public nsISupports,
+ public nsWrapperCache
+{
+public:
+ enum StreamType {
+ Local,
+ Remote
+ };
+
+ MediaStreamList(PeerConnectionImpl* peerConnection, StreamType type);
+
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(MediaStreamList)
+
+ virtual JSObject* WrapObject(JSContext *cx, JS::Handle<JSObject*> aGivenProto)
+ override;
+ nsISupports* GetParentObject();
+
+ DOMMediaStream* IndexedGetter(uint32_t index, bool& found);
+ uint32_t Length();
+
+private:
+ virtual ~MediaStreamList();
+
+ RefPtr<PeerConnectionImpl> mPeerConnection;
+ StreamType mType;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // MediaStreamList_h__
diff --git a/media/webrtc/signaling/src/peerconnection/PeerConnectionCtx.cpp b/media/webrtc/signaling/src/peerconnection/PeerConnectionCtx.cpp
new file mode 100644
index 000000000..515258efb
--- /dev/null
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionCtx.cpp
@@ -0,0 +1,452 @@
+/* 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 "CSFLog.h"
+
+#include "PeerConnectionImpl.h"
+#include "PeerConnectionCtx.h"
+#include "runnable_utils.h"
+#include "prcvar.h"
+
+#include "mozilla/Telemetry.h"
+#include "browser_logging/WebRtcLog.h"
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+#include "mozilla/dom/RTCPeerConnectionBinding.h"
+#include "mozilla/Preferences.h"
+#include <mozilla/Types.h>
+#endif
+
+#include "nsNetCID.h" // NS_SOCKETTRANSPORTSERVICE_CONTRACTID
+#include "nsServiceManagerUtils.h" // do_GetService
+#include "nsIObserverService.h"
+#include "nsIObserver.h"
+#include "mozilla/Services.h"
+#include "mozilla/StaticPtr.h"
+
+#include "gmp-video-decode.h" // GMP_API_VIDEO_DECODER
+#include "gmp-video-encode.h" // GMP_API_VIDEO_ENCODER
+
+static const char* logTag = "PeerConnectionCtx";
+
+namespace mozilla {
+
+using namespace dom;
+
+class PeerConnectionCtxShutdown : public nsIObserver
+{
+public:
+ NS_DECL_ISUPPORTS
+
+ PeerConnectionCtxShutdown() {}
+
+ void Init()
+ {
+ nsCOMPtr<nsIObserverService> observerService =
+ services::GetObserverService();
+ if (!observerService)
+ return;
+
+ nsresult rv = NS_OK;
+
+#ifdef MOZILLA_INTERNAL_API
+ rv = observerService->AddObserver(this,
+ NS_XPCOM_SHUTDOWN_OBSERVER_ID,
+ false);
+ MOZ_ALWAYS_SUCCEEDS(rv);
+#endif
+ (void) rv;
+ }
+
+ NS_IMETHOD Observe(nsISupports* aSubject, const char* aTopic,
+ const char16_t* aData) override {
+ if (strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0) {
+ CSFLogDebug(logTag, "Shutting down PeerConnectionCtx");
+ PeerConnectionCtx::Destroy();
+
+ nsCOMPtr<nsIObserverService> observerService =
+ services::GetObserverService();
+ if (!observerService)
+ return NS_ERROR_FAILURE;
+
+ nsresult rv = observerService->RemoveObserver(this,
+ NS_XPCOM_SHUTDOWN_OBSERVER_ID);
+ MOZ_ALWAYS_SUCCEEDS(rv);
+
+ // Make sure we're not deleted while still inside ::Observe()
+ RefPtr<PeerConnectionCtxShutdown> kungFuDeathGrip(this);
+ PeerConnectionCtx::gPeerConnectionCtxShutdown = nullptr;
+ }
+ return NS_OK;
+ }
+
+private:
+ virtual ~PeerConnectionCtxShutdown()
+ {
+ nsCOMPtr<nsIObserverService> observerService =
+ services::GetObserverService();
+ if (observerService)
+ observerService->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
+ }
+};
+
+NS_IMPL_ISUPPORTS(PeerConnectionCtxShutdown, nsIObserver);
+}
+
+namespace mozilla {
+
+PeerConnectionCtx* PeerConnectionCtx::gInstance;
+nsIThread* PeerConnectionCtx::gMainThread;
+StaticRefPtr<PeerConnectionCtxShutdown> PeerConnectionCtx::gPeerConnectionCtxShutdown;
+
+const std::map<const std::string, PeerConnectionImpl *>&
+PeerConnectionCtx::mGetPeerConnections()
+{
+ return mPeerConnections;
+}
+
+nsresult PeerConnectionCtx::InitializeGlobal(nsIThread *mainThread,
+ nsIEventTarget* stsThread) {
+ if (!gMainThread) {
+ gMainThread = mainThread;
+ } else {
+ MOZ_ASSERT(gMainThread == mainThread);
+ }
+
+ nsresult res;
+
+ MOZ_ASSERT(NS_IsMainThread());
+
+ if (!gInstance) {
+ CSFLogDebug(logTag, "Creating PeerConnectionCtx");
+ PeerConnectionCtx *ctx = new PeerConnectionCtx();
+
+ res = ctx->Initialize();
+ PR_ASSERT(NS_SUCCEEDED(res));
+ if (!NS_SUCCEEDED(res))
+ return res;
+
+ gInstance = ctx;
+
+ if (!PeerConnectionCtx::gPeerConnectionCtxShutdown) {
+ PeerConnectionCtx::gPeerConnectionCtxShutdown = new PeerConnectionCtxShutdown();
+ PeerConnectionCtx::gPeerConnectionCtxShutdown->Init();
+ }
+ }
+
+ EnableWebRtcLog();
+ return NS_OK;
+}
+
+PeerConnectionCtx* PeerConnectionCtx::GetInstance() {
+ MOZ_ASSERT(gInstance);
+ return gInstance;
+}
+
+bool PeerConnectionCtx::isActive() {
+ return gInstance;
+}
+
+void PeerConnectionCtx::Destroy() {
+ CSFLogDebug(logTag, "%s", __FUNCTION__);
+
+ if (gInstance) {
+ gInstance->Cleanup();
+ delete gInstance;
+ gInstance = nullptr;
+ }
+
+ StopWebRtcLog();
+}
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+typedef Vector<nsAutoPtr<RTCStatsQuery>> RTCStatsQueries;
+
+// Telemetry reporting every second after start of first call.
+// The threading model around the media pipelines is weird:
+// - The pipelines are containers,
+// - containers that are only safe on main thread, with members only safe on STS,
+// - hence the there and back again approach.
+
+static auto
+FindId(const Sequence<RTCInboundRTPStreamStats>& aArray,
+ const nsString &aId) -> decltype(aArray.Length()) {
+ for (decltype(aArray.Length()) i = 0; i < aArray.Length(); i++) {
+ if (aArray[i].mId.Value() == aId) {
+ return i;
+ }
+ }
+ return aArray.NoIndex;
+}
+
+static auto
+FindId(const nsTArray<nsAutoPtr<RTCStatsReportInternal>>& aArray,
+ const nsString &aId) -> decltype(aArray.Length()) {
+ for (decltype(aArray.Length()) i = 0; i < aArray.Length(); i++) {
+ if (aArray[i]->mPcid == aId) {
+ return i;
+ }
+ }
+ return aArray.NoIndex;
+}
+
+static void
+FreeOnMain_m(nsAutoPtr<RTCStatsQueries> aQueryList) {
+ MOZ_ASSERT(NS_IsMainThread());
+}
+
+static void
+EverySecondTelemetryCallback_s(nsAutoPtr<RTCStatsQueries> aQueryList) {
+ using namespace Telemetry;
+
+ if(!PeerConnectionCtx::isActive()) {
+ return;
+ }
+ PeerConnectionCtx *ctx = PeerConnectionCtx::GetInstance();
+
+ for (auto q = aQueryList->begin(); q != aQueryList->end(); ++q) {
+ PeerConnectionImpl::ExecuteStatsQuery_s(*q);
+ auto& r = *(*q)->report;
+ if (r.mInboundRTPStreamStats.WasPassed()) {
+ // First, get reports from a second ago, if any, for calculations below
+ const Sequence<RTCInboundRTPStreamStats> *lastInboundStats = nullptr;
+ {
+ auto i = FindId(ctx->mLastReports, r.mPcid);
+ if (i != ctx->mLastReports.NoIndex) {
+ lastInboundStats = &ctx->mLastReports[i]->mInboundRTPStreamStats.Value();
+ }
+ }
+ // Then, look for the things we want telemetry on
+ auto& array = r.mInboundRTPStreamStats.Value();
+ for (decltype(array.Length()) i = 0; i < array.Length(); i++) {
+ auto& s = array[i];
+ bool isAudio = (s.mId.Value().Find("audio") != -1);
+ if (s.mPacketsLost.WasPassed() && s.mPacketsReceived.WasPassed() &&
+ (s.mPacketsLost.Value() + s.mPacketsReceived.Value()) != 0) {
+ ID id;
+ if (s.mIsRemote) {
+ id = isAudio ? WEBRTC_AUDIO_QUALITY_OUTBOUND_PACKETLOSS_RATE :
+ WEBRTC_VIDEO_QUALITY_OUTBOUND_PACKETLOSS_RATE;
+ } else {
+ id = isAudio ? WEBRTC_AUDIO_QUALITY_INBOUND_PACKETLOSS_RATE :
+ WEBRTC_VIDEO_QUALITY_INBOUND_PACKETLOSS_RATE;
+ }
+ // *1000 so we can read in 10's of a percent (permille)
+ Accumulate(id,
+ (s.mPacketsLost.Value() * 1000) /
+ (s.mPacketsLost.Value() + s.mPacketsReceived.Value()));
+ }
+ if (s.mJitter.WasPassed()) {
+ ID id;
+ if (s.mIsRemote) {
+ id = isAudio ? WEBRTC_AUDIO_QUALITY_OUTBOUND_JITTER :
+ WEBRTC_VIDEO_QUALITY_OUTBOUND_JITTER;
+ } else {
+ id = isAudio ? WEBRTC_AUDIO_QUALITY_INBOUND_JITTER :
+ WEBRTC_VIDEO_QUALITY_INBOUND_JITTER;
+ }
+ Accumulate(id, s.mJitter.Value());
+ }
+ if (s.mMozRtt.WasPassed()) {
+ MOZ_ASSERT(s.mIsRemote);
+ ID id = isAudio ? WEBRTC_AUDIO_QUALITY_OUTBOUND_RTT :
+ WEBRTC_VIDEO_QUALITY_OUTBOUND_RTT;
+ Accumulate(id, s.mMozRtt.Value());
+ }
+ if (lastInboundStats && s.mBytesReceived.WasPassed()) {
+ auto& laststats = *lastInboundStats;
+ auto i = FindId(laststats, s.mId.Value());
+ if (i != laststats.NoIndex) {
+ auto& lasts = laststats[i];
+ if (lasts.mBytesReceived.WasPassed()) {
+ auto delta_ms = int32_t(s.mTimestamp.Value() -
+ lasts.mTimestamp.Value());
+ // In theory we're called every second, so delta *should* be in that range.
+ // Small deltas could cause errors due to division
+ if (delta_ms > 500 && delta_ms < 60000) {
+ ID id;
+ if (s.mIsRemote) {
+ id = isAudio ? WEBRTC_AUDIO_QUALITY_OUTBOUND_BANDWIDTH_KBITS :
+ WEBRTC_VIDEO_QUALITY_OUTBOUND_BANDWIDTH_KBITS;
+ } else {
+ id = isAudio ? WEBRTC_AUDIO_QUALITY_INBOUND_BANDWIDTH_KBITS :
+ WEBRTC_VIDEO_QUALITY_INBOUND_BANDWIDTH_KBITS;
+ }
+ Accumulate(id, ((s.mBytesReceived.Value() -
+ lasts.mBytesReceived.Value()) * 8) / delta_ms);
+ }
+ // We could accumulate values until enough time has passed
+ // and then Accumulate() but this isn't that important.
+ }
+ }
+ }
+ }
+ }
+ }
+ // Steal and hang on to reports for the next second
+ ctx->mLastReports.Clear();
+ for (auto q = aQueryList->begin(); q != aQueryList->end(); ++q) {
+ ctx->mLastReports.AppendElement((*q)->report.forget()); // steal avoids copy
+ }
+ // Container must be freed back on main thread
+ NS_DispatchToMainThread(WrapRunnableNM(&FreeOnMain_m, aQueryList),
+ NS_DISPATCH_NORMAL);
+}
+
+void
+PeerConnectionCtx::EverySecondTelemetryCallback_m(nsITimer* timer, void *closure) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(PeerConnectionCtx::isActive());
+ auto ctx = static_cast<PeerConnectionCtx*>(closure);
+ if (ctx->mPeerConnections.empty()) {
+ return;
+ }
+ nsresult rv;
+ nsCOMPtr<nsIEventTarget> stsThread =
+ do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv);
+ if (NS_FAILED(rv)) {
+ return;
+ }
+ MOZ_ASSERT(stsThread);
+
+ nsAutoPtr<RTCStatsQueries> queries(new RTCStatsQueries);
+ for (auto p = ctx->mPeerConnections.begin();
+ p != ctx->mPeerConnections.end(); ++p) {
+ if (p->second->HasMedia()) {
+ if (!queries->append(nsAutoPtr<RTCStatsQuery>(new RTCStatsQuery(true)))) {
+ return;
+ }
+ if (NS_WARN_IF(NS_FAILED(p->second->BuildStatsQuery_m(nullptr, // all tracks
+ queries->back())))) {
+ queries->popBack();
+ } else {
+ MOZ_ASSERT(queries->back()->report);
+ }
+ }
+ }
+ if (!queries->empty()) {
+ rv = RUN_ON_THREAD(stsThread,
+ WrapRunnableNM(&EverySecondTelemetryCallback_s, queries),
+ NS_DISPATCH_NORMAL);
+ NS_ENSURE_SUCCESS_VOID(rv);
+ }
+}
+#endif
+
+nsresult PeerConnectionCtx::Initialize() {
+ initGMP();
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ mTelemetryTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
+ MOZ_ASSERT(mTelemetryTimer);
+ nsresult rv = mTelemetryTimer->SetTarget(gMainThread);
+ NS_ENSURE_SUCCESS(rv, rv);
+ mTelemetryTimer->InitWithFuncCallback(EverySecondTelemetryCallback_m, this, 1000,
+ nsITimer::TYPE_REPEATING_PRECISE_CAN_SKIP);
+
+ if (XRE_IsContentProcess()) {
+ WebrtcGlobalChild::Create();
+ }
+#endif // MOZILLA_INTERNAL_API
+
+ return NS_OK;
+}
+
+static void GMPReady_m() {
+ if (PeerConnectionCtx::isActive()) {
+ PeerConnectionCtx::GetInstance()->onGMPReady();
+ }
+};
+
+static void GMPReady() {
+ PeerConnectionCtx::gMainThread->Dispatch(WrapRunnableNM(&GMPReady_m),
+ NS_DISPATCH_NORMAL);
+};
+
+void PeerConnectionCtx::initGMP()
+{
+ mGMPService = do_GetService("@mozilla.org/gecko-media-plugin-service;1");
+
+ if (!mGMPService) {
+ CSFLogError(logTag, "%s failed to get the gecko-media-plugin-service",
+ __FUNCTION__);
+ return;
+ }
+
+ nsCOMPtr<nsIThread> thread;
+ nsresult rv = mGMPService->GetThread(getter_AddRefs(thread));
+
+ if (NS_FAILED(rv)) {
+ mGMPService = nullptr;
+ CSFLogError(logTag,
+ "%s failed to get the gecko-media-plugin thread, err=%u",
+ __FUNCTION__,
+ static_cast<unsigned>(rv));
+ return;
+ }
+
+ // presumes that all GMP dir scans have been queued for the GMPThread
+ thread->Dispatch(WrapRunnableNM(&GMPReady), NS_DISPATCH_NORMAL);
+}
+
+nsresult PeerConnectionCtx::Cleanup() {
+ CSFLogDebug(logTag, "%s", __FUNCTION__);
+
+ mQueuedJSEPOperations.Clear();
+ mGMPService = nullptr;
+ return NS_OK;
+}
+
+PeerConnectionCtx::~PeerConnectionCtx() {
+ // ensure mTelemetryTimer ends on main thread
+ MOZ_ASSERT(NS_IsMainThread());
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ if (mTelemetryTimer) {
+ mTelemetryTimer->Cancel();
+ }
+#endif
+};
+
+void PeerConnectionCtx::queueJSEPOperation(nsIRunnable* aOperation) {
+ mQueuedJSEPOperations.AppendElement(aOperation);
+}
+
+void PeerConnectionCtx::onGMPReady() {
+ mGMPReady = true;
+ for (size_t i = 0; i < mQueuedJSEPOperations.Length(); ++i) {
+ mQueuedJSEPOperations[i]->Run();
+ }
+ mQueuedJSEPOperations.Clear();
+}
+
+bool PeerConnectionCtx::gmpHasH264() {
+ if (!mGMPService) {
+ return false;
+ }
+
+ // XXX I'd prefer if this was all known ahead of time...
+
+ nsTArray<nsCString> tags;
+ tags.AppendElement(NS_LITERAL_CSTRING("h264"));
+
+ bool has_gmp;
+ nsresult rv;
+ rv = mGMPService->HasPluginForAPI(NS_LITERAL_CSTRING(GMP_API_VIDEO_ENCODER),
+ &tags,
+ &has_gmp);
+ if (NS_FAILED(rv) || !has_gmp) {
+ return false;
+ }
+
+ rv = mGMPService->HasPluginForAPI(NS_LITERAL_CSTRING(GMP_API_VIDEO_DECODER),
+ &tags,
+ &has_gmp);
+ if (NS_FAILED(rv) || !has_gmp) {
+ return false;
+ }
+
+ return true;
+}
+
+} // namespace mozilla
diff --git a/media/webrtc/signaling/src/peerconnection/PeerConnectionCtx.h b/media/webrtc/signaling/src/peerconnection/PeerConnectionCtx.h
new file mode 100644
index 000000000..3f7d6250b
--- /dev/null
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionCtx.h
@@ -0,0 +1,109 @@
+/* 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/. */
+
+#ifndef peerconnectionctx_h___h__
+#define peerconnectionctx_h___h__
+
+#include <string>
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+#include "WebrtcGlobalChild.h"
+#endif
+
+#include "mozilla/Attributes.h"
+#include "mozilla/StaticPtr.h"
+#include "PeerConnectionImpl.h"
+#include "mozIGeckoMediaPluginService.h"
+#include "nsIRunnable.h"
+
+namespace mozilla {
+class PeerConnectionCtxShutdown;
+
+namespace dom {
+class WebrtcGlobalInformation;
+}
+
+// A class to hold some of the singleton objects we need:
+// * The global PeerConnectionImpl table and its associated lock.
+// * Stats report objects for PCs that are gone
+// * GMP related state
+class PeerConnectionCtx {
+ public:
+ static nsresult InitializeGlobal(nsIThread *mainThread, nsIEventTarget *stsThread);
+ static PeerConnectionCtx* GetInstance();
+ static bool isActive();
+ static void Destroy();
+
+ bool isReady() {
+ // If mGMPService is not set, we aren't using GMP.
+ if (mGMPService) {
+ return mGMPReady;
+ }
+ return true;
+ }
+
+ void queueJSEPOperation(nsIRunnable* aJSEPOperation);
+ void onGMPReady();
+
+ bool gmpHasH264();
+
+ // Make these classes friend so that they can access mPeerconnections.
+ friend class PeerConnectionImpl;
+ friend class PeerConnectionWrapper;
+ friend class mozilla::dom::WebrtcGlobalInformation;
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ // WebrtcGlobalInformation uses this; we put it here so we don't need to
+ // create another shutdown observer class.
+ mozilla::dom::Sequence<mozilla::dom::RTCStatsReportInternal>
+ mStatsForClosedPeerConnections;
+#endif
+
+ const std::map<const std::string, PeerConnectionImpl *>& mGetPeerConnections();
+ private:
+ // We could make these available only via accessors but it's too much trouble.
+ std::map<const std::string, PeerConnectionImpl *> mPeerConnections;
+
+ PeerConnectionCtx() : mGMPReady(false) {}
+ // This is a singleton, so don't copy construct it, etc.
+ PeerConnectionCtx(const PeerConnectionCtx& other) = delete;
+ void operator=(const PeerConnectionCtx& other) = delete;
+ virtual ~PeerConnectionCtx();
+
+ nsresult Initialize();
+ nsresult Cleanup();
+
+ void initGMP();
+
+ static void
+ EverySecondTelemetryCallback_m(nsITimer* timer, void *);
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ nsCOMPtr<nsITimer> mTelemetryTimer;
+
+public:
+ // TODO(jib): If we ever enable move semantics on std::map...
+ //std::map<nsString,nsAutoPtr<mozilla::dom::RTCStatsReportInternal>> mLastReports;
+ nsTArray<nsAutoPtr<mozilla::dom::RTCStatsReportInternal>> mLastReports;
+private:
+#endif
+
+ // We cannot form offers/answers properly until the Gecko Media Plugin stuff
+ // has been initted, which is a complicated mess of thread dispatches,
+ // including sync dispatches to main. So, we need to be able to queue up
+ // offer creation (or SetRemote, when we're the answerer) until all of this is
+ // ready to go, since blocking on this init is just begging for deadlock.
+ nsCOMPtr<mozIGeckoMediaPluginService> mGMPService;
+ bool mGMPReady;
+ nsTArray<nsCOMPtr<nsIRunnable>> mQueuedJSEPOperations;
+
+ static PeerConnectionCtx *gInstance;
+public:
+ static nsIThread *gMainThread;
+ static mozilla::StaticRefPtr<mozilla::PeerConnectionCtxShutdown> gPeerConnectionCtxShutdown;
+};
+
+} // namespace mozilla
+
+#endif
diff --git a/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.cpp b/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.cpp
new file mode 100644
index 000000000..33422ed7a
--- /dev/null
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.cpp
@@ -0,0 +1,4176 @@
+/* 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 <cstdlib>
+#include <cerrno>
+#include <deque>
+#include <set>
+#include <sstream>
+#include <vector>
+
+#include "CSFLog.h"
+#include "timecard.h"
+
+#include "jsapi.h"
+#include "nspr.h"
+#include "nss.h"
+#include "pk11pub.h"
+
+#include "nsNetCID.h"
+#include "nsIProperty.h"
+#include "nsIPropertyBag2.h"
+#include "nsIServiceManager.h"
+#include "nsISimpleEnumerator.h"
+#include "nsServiceManagerUtils.h"
+#include "nsISocketTransportService.h"
+#include "nsIConsoleService.h"
+#include "nsThreadUtils.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsProxyRelease.h"
+#include "nsQueryObject.h"
+#include "prtime.h"
+
+#include "AudioConduit.h"
+#include "VideoConduit.h"
+#include "runnable_utils.h"
+#include "PeerConnectionCtx.h"
+#include "PeerConnectionImpl.h"
+#include "PeerConnectionMedia.h"
+#include "nsDOMDataChannelDeclarations.h"
+#include "dtlsidentity.h"
+#include "signaling/src/sdp/SdpAttribute.h"
+
+#include "signaling/src/jsep/JsepTrack.h"
+#include "signaling/src/jsep/JsepSession.h"
+#include "signaling/src/jsep/JsepSessionImpl.h"
+
+#include "mozilla/IntegerPrintfMacros.h"
+#include "mozilla/Sprintf.h"
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+#ifdef XP_WIN
+// We need to undef the MS macro for nsIDocument::CreateEvent
+#ifdef CreateEvent
+#undef CreateEvent
+#endif
+#endif // XP_WIN
+
+#include "nsIDocument.h"
+#include "nsGlobalWindow.h"
+#include "nsDOMDataChannel.h"
+#include "mozilla/dom/Performance.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/PublicSSL.h"
+#include "nsXULAppAPI.h"
+#include "nsContentUtils.h"
+#include "nsDOMJSUtils.h"
+#include "nsIScriptError.h"
+#include "nsPrintfCString.h"
+#include "nsURLHelper.h"
+#include "nsNetUtil.h"
+#include "nsIURLParser.h"
+#include "nsIDOMDataChannel.h"
+#include "nsIDOMLocation.h"
+#include "nsNullPrincipal.h"
+#include "mozilla/PeerIdentity.h"
+#include "mozilla/dom/RTCCertificate.h"
+#include "mozilla/dom/RTCConfigurationBinding.h"
+#include "mozilla/dom/RTCDTMFSenderBinding.h"
+#include "mozilla/dom/RTCDTMFToneChangeEvent.h"
+#include "mozilla/dom/RTCRtpSenderBinding.h"
+#include "mozilla/dom/RTCStatsReportBinding.h"
+#include "mozilla/dom/RTCPeerConnectionBinding.h"
+#include "mozilla/dom/PeerConnectionImplBinding.h"
+#include "mozilla/dom/DataChannelBinding.h"
+#include "mozilla/dom/PerformanceTiming.h"
+#include "mozilla/dom/PluginCrashedEvent.h"
+#include "MediaStreamList.h"
+#include "MediaStreamTrack.h"
+#include "AudioStreamTrack.h"
+#include "VideoStreamTrack.h"
+#include "nsIScriptGlobalObject.h"
+#include "MediaStreamGraph.h"
+#include "DOMMediaStream.h"
+#include "rlogconnector.h"
+#include "WebrtcGlobalInformation.h"
+#include "mozilla/dom/Event.h"
+#include "nsIDOMCustomEvent.h"
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/net/DataChannelProtocol.h"
+#endif
+
+#ifndef USE_FAKE_MEDIA_STREAMS
+#include "MediaStreamGraphImpl.h"
+#endif
+
+#ifdef XP_WIN
+// We need to undef the MS macro again in case the windows include file
+// got imported after we included nsIDocument.h
+#ifdef CreateEvent
+#undef CreateEvent
+#endif
+#endif // XP_WIN
+
+#ifndef USE_FAKE_MEDIA_STREAMS
+#include "MediaSegment.h"
+#endif
+
+#ifdef USE_FAKE_PCOBSERVER
+#include "FakePCObserver.h"
+#else
+#include "mozilla/dom/PeerConnectionObserverBinding.h"
+#endif
+#include "mozilla/dom/PeerConnectionObserverEnumsBinding.h"
+
+#ifdef MOZ_WEBRTC_OMX
+#include "OMXVideoCodec.h"
+#include "OMXCodecWrapper.h"
+#endif
+
+#define ICE_PARSING "In RTCConfiguration passed to RTCPeerConnection constructor"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+typedef PCObserverString ObString;
+
+static const char* logTag = "PeerConnectionImpl";
+
+// Getting exceptions back down from PCObserver is generally not harmful.
+namespace {
+// This is a terrible hack. The problem is that SuppressException is not
+// inline, and we link this file without libxul in some cases (e.g. for our test
+// setup). So we can't use ErrorResult or IgnoredErrorResult because those call
+// SuppressException... And we can't use FastErrorResult because we can't
+// include BindingUtils.h, because our linking is completely fucked up. Use
+// BaseErrorResult directly. Please do not let me see _anyone_ doing this
+// without really careful review from someone who knows what they are doing.
+class JSErrorResult :
+ public binding_danger::TErrorResult<binding_danger::JustAssertCleanupPolicy>
+{
+public:
+ ~JSErrorResult()
+ {
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ SuppressException();
+#endif
+ }
+};
+
+// The WrapRunnable() macros copy passed-in args and passes them to the function
+// later on the other thread. ErrorResult cannot be passed like this because it
+// disallows copy-semantics.
+//
+// This WrappableJSErrorResult hack solves this by not actually copying the
+// ErrorResult, but creating a new one instead, which works because we don't
+// care about the result.
+//
+// Since this is for JS-calls, these can only be dispatched to the main thread.
+
+class WrappableJSErrorResult {
+public:
+ WrappableJSErrorResult()
+ : mRv(MakeUnique<JSErrorResult>()),
+ isCopy(false) {}
+ WrappableJSErrorResult(const WrappableJSErrorResult &other)
+ : mRv(MakeUnique<JSErrorResult>()),
+ isCopy(true) {}
+ ~WrappableJSErrorResult() {
+ if (isCopy) {
+ MOZ_ASSERT(NS_IsMainThread());
+ }
+ }
+ operator JSErrorResult &() { return *mRv; }
+ operator ErrorResult &() { return *mRv; }
+private:
+ mozilla::UniquePtr<JSErrorResult> mRv;
+ bool isCopy;
+};
+}
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+static nsresult InitNSSInContent()
+{
+ NS_ENSURE_TRUE(NS_IsMainThread(), NS_ERROR_NOT_SAME_THREAD);
+
+ if (!XRE_IsContentProcess()) {
+ MOZ_ASSERT_UNREACHABLE("Must be called in content process");
+ return NS_ERROR_FAILURE;
+ }
+
+ static bool nssStarted = false;
+ if (nssStarted) {
+ return NS_OK;
+ }
+
+ if (NSS_NoDB_Init(nullptr) != SECSuccess) {
+ CSFLogError(logTag, "NSS_NoDB_Init failed.");
+ return NS_ERROR_FAILURE;
+ }
+
+ if (NS_FAILED(mozilla::psm::InitializeCipherSuite())) {
+ CSFLogError(logTag, "Fail to set up nss cipher suite.");
+ return NS_ERROR_FAILURE;
+ }
+
+ mozilla::psm::DisableMD5();
+
+ nssStarted = true;
+
+ return NS_OK;
+}
+#endif // MOZILLA_INTERNAL_API
+
+namespace mozilla {
+ class DataChannel;
+}
+
+class nsIDOMDataChannel;
+
+PRLogModuleInfo *signalingLogInfo() {
+ static PRLogModuleInfo *logModuleInfo = nullptr;
+ if (!logModuleInfo) {
+ logModuleInfo = PR_NewLogModule("signaling");
+ }
+ return logModuleInfo;
+}
+
+// XXX Workaround for bug 998092 to maintain the existing broken semantics
+template<>
+struct nsISupportsWeakReference::COMTypeInfo<nsSupportsWeakReference, void> {
+ static const nsIID kIID;
+};
+const nsIID nsISupportsWeakReference::COMTypeInfo<nsSupportsWeakReference, void>::kIID = NS_ISUPPORTSWEAKREFERENCE_IID;
+
+namespace mozilla {
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+RTCStatsQuery::RTCStatsQuery(bool internal) :
+ failed(false),
+ internalStats(internal),
+ grabAllLevels(false) {
+}
+
+RTCStatsQuery::~RTCStatsQuery() {
+ MOZ_ASSERT(NS_IsMainThread());
+}
+
+#endif
+
+NS_IMPL_ISUPPORTS0(PeerConnectionImpl)
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+bool
+PeerConnectionImpl::WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto,
+ JS::MutableHandle<JSObject*> aReflector)
+{
+ return PeerConnectionImplBinding::Wrap(aCx, this, aGivenProto, aReflector);
+}
+#endif
+
+bool PCUuidGenerator::Generate(std::string* idp) {
+ nsresult rv;
+
+ if(!mGenerator) {
+ mGenerator = do_GetService("@mozilla.org/uuid-generator;1", &rv);
+ if (NS_FAILED(rv)) {
+ return false;
+ }
+ if (!mGenerator) {
+ return false;
+ }
+ }
+
+ nsID id;
+ rv = mGenerator->GenerateUUIDInPlace(&id);
+ if (NS_FAILED(rv)) {
+ return false;
+ }
+ char buffer[NSID_LENGTH];
+ id.ToProvidedString(buffer);
+ idp->assign(buffer);
+
+ return true;
+}
+
+bool IsPrivateBrowsing(nsPIDOMWindowInner* aWindow)
+{
+#if defined(MOZILLA_EXTERNAL_LINKAGE)
+ return false;
+#else
+ if (!aWindow) {
+ return false;
+ }
+
+ nsIDocument *doc = aWindow->GetExtantDoc();
+ if (!doc) {
+ return false;
+ }
+
+ nsILoadContext *loadContext = doc->GetLoadContext();
+ return loadContext && loadContext->UsePrivateBrowsing();
+#endif
+}
+
+PeerConnectionImpl::PeerConnectionImpl(const GlobalObject* aGlobal)
+: mTimeCard(MOZ_LOG_TEST(signalingLogInfo(),LogLevel::Error) ?
+ create_timecard() : nullptr)
+ , mSignalingState(PCImplSignalingState::SignalingStable)
+ , mIceConnectionState(PCImplIceConnectionState::New)
+ , mIceGatheringState(PCImplIceGatheringState::New)
+ , mDtlsConnected(false)
+ , mWindow(nullptr)
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ , mCertificate(nullptr)
+#else
+ , mIdentity(nullptr)
+#endif
+ , mPrivacyRequested(false)
+ , mSTSThread(nullptr)
+ , mAllowIceLoopback(false)
+ , mAllowIceLinkLocal(false)
+ , mMedia(nullptr)
+ , mUuidGen(MakeUnique<PCUuidGenerator>())
+ , mNumAudioStreams(0)
+ , mNumVideoStreams(0)
+ , mHaveConfiguredCodecs(false)
+ , mHaveDataStream(false)
+ , mAddCandidateErrorCount(0)
+ , mTrickle(true) // TODO(ekr@rtfm.com): Use pref
+ , mNegotiationNeeded(false)
+ , mPrivateWindow(false)
+{
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ MOZ_ASSERT(NS_IsMainThread());
+ auto log = RLogConnector::CreateInstance();
+ if (aGlobal) {
+ mWindow = do_QueryInterface(aGlobal->GetAsSupports());
+ if (IsPrivateBrowsing(mWindow)) {
+ mPrivateWindow = true;
+ log->EnterPrivateMode();
+ }
+ }
+#endif
+ CSFLogInfo(logTag, "%s: PeerConnectionImpl constructor for %s",
+ __FUNCTION__, mHandle.c_str());
+ STAMP_TIMECARD(mTimeCard, "Constructor Completed");
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ mAllowIceLoopback = Preferences::GetBool(
+ "media.peerconnection.ice.loopback", false);
+ mAllowIceLinkLocal = Preferences::GetBool(
+ "media.peerconnection.ice.link_local", false);
+#endif
+ memset(mMaxReceiving, 0, sizeof(mMaxReceiving));
+ memset(mMaxSending, 0, sizeof(mMaxSending));
+}
+
+PeerConnectionImpl::~PeerConnectionImpl()
+{
+ if (mTimeCard) {
+ STAMP_TIMECARD(mTimeCard, "Destructor Invoked");
+ print_timecard(mTimeCard);
+ destroy_timecard(mTimeCard);
+ mTimeCard = nullptr;
+ }
+ // This aborts if not on main thread (in Debug builds)
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ if (mPrivateWindow) {
+ auto * log = RLogConnector::GetInstance();
+ if (log) {
+ log->ExitPrivateMode();
+ }
+ mPrivateWindow = false;
+ }
+#endif
+ if (PeerConnectionCtx::isActive()) {
+ PeerConnectionCtx::GetInstance()->mPeerConnections.erase(mHandle);
+ } else {
+ CSFLogError(logTag, "PeerConnectionCtx is already gone. Ignoring...");
+ }
+
+ CSFLogInfo(logTag, "%s: PeerConnectionImpl destructor invoked for %s",
+ __FUNCTION__, mHandle.c_str());
+
+ Close();
+
+ // Since this and Initialize() occur on MainThread, they can't both be
+ // running at once
+
+ // Right now, we delete PeerConnectionCtx at XPCOM shutdown only, but we
+ // probably want to shut it down more aggressively to save memory. We
+ // could shut down here when there are no uses. It might be more optimal
+ // to release off a timer (and XPCOM Shutdown) to avoid churn
+}
+
+already_AddRefed<DOMMediaStream>
+PeerConnectionImpl::MakeMediaStream()
+{
+ MediaStreamGraph* graph =
+ MediaStreamGraph::GetInstance(MediaStreamGraph::AUDIO_THREAD_DRIVER,
+ AudioChannel::Normal);
+
+ RefPtr<DOMMediaStream> stream =
+ DOMMediaStream::CreateSourceStreamAsInput(GetWindow(), graph);
+
+ CSFLogDebug(logTag, "Created media stream %p, inner: %p", stream.get(), stream->GetInputStream());
+
+ return stream.forget();
+}
+
+nsresult
+PeerConnectionImpl::CreateRemoteSourceStreamInfo(RefPtr<RemoteSourceStreamInfo>*
+ aInfo,
+ const std::string& aStreamID)
+{
+ MOZ_ASSERT(aInfo);
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+
+ RefPtr<DOMMediaStream> stream = MakeMediaStream();
+ if (!stream) {
+ return NS_ERROR_FAILURE;
+ }
+
+ RefPtr<RemoteSourceStreamInfo> remote;
+ remote = new RemoteSourceStreamInfo(stream.forget(), mMedia, aStreamID);
+ *aInfo = remote;
+
+ return NS_OK;
+}
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+/**
+ * In JS, an RTCConfiguration looks like this:
+ *
+ * { "iceServers": [ { url:"stun:stun.example.org" },
+ * { url:"turn:turn.example.org?transport=udp",
+ * username: "jib", credential:"mypass"} ] }
+ *
+ * This function converts that into an internal PeerConnectionConfiguration
+ * object.
+ */
+nsresult
+PeerConnectionConfiguration::Init(const RTCConfiguration& aSrc)
+{
+ if (aSrc.mIceServers.WasPassed()) {
+ for (size_t i = 0; i < aSrc.mIceServers.Value().Length(); i++) {
+ nsresult rv = AddIceServer(aSrc.mIceServers.Value()[i]);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ }
+
+ switch (aSrc.mBundlePolicy) {
+ case dom::RTCBundlePolicy::Balanced:
+ setBundlePolicy(kBundleBalanced);
+ break;
+ case dom::RTCBundlePolicy::Max_compat:
+ setBundlePolicy(kBundleMaxCompat);
+ break;
+ case dom::RTCBundlePolicy::Max_bundle:
+ setBundlePolicy(kBundleMaxBundle);
+ break;
+ default:
+ MOZ_CRASH();
+ }
+
+ switch (aSrc.mIceTransportPolicy) {
+ case dom::RTCIceTransportPolicy::Relay:
+ setIceTransportPolicy(NrIceCtx::ICE_POLICY_RELAY);
+ break;
+ case dom::RTCIceTransportPolicy::All:
+ if (Preferences::GetBool("media.peerconnection.ice.no_host", false)) {
+ setIceTransportPolicy(NrIceCtx::ICE_POLICY_NO_HOST);
+ } else {
+ setIceTransportPolicy(NrIceCtx::ICE_POLICY_ALL);
+ }
+ break;
+ default:
+ MOZ_CRASH();
+ }
+ return NS_OK;
+}
+
+nsresult
+PeerConnectionConfiguration::AddIceServer(const RTCIceServer &aServer)
+{
+ NS_ENSURE_STATE(aServer.mUrls.WasPassed());
+ NS_ENSURE_STATE(aServer.mUrls.Value().IsStringSequence());
+ auto &urls = aServer.mUrls.Value().GetAsStringSequence();
+ for (size_t i = 0; i < urls.Length(); i++) {
+ // Without STUN/TURN handlers, NS_NewURI returns nsSimpleURI rather than
+ // nsStandardURL. To parse STUN/TURN URI's to spec
+ // http://tools.ietf.org/html/draft-nandakumar-rtcweb-stun-uri-02#section-3
+ // http://tools.ietf.org/html/draft-petithuguenin-behave-turn-uri-03#section-3
+ // we parse out the query-string, and use ParseAuthority() on the rest
+ RefPtr<nsIURI> url;
+ nsresult rv = NS_NewURI(getter_AddRefs(url), urls[i]);
+ NS_ENSURE_SUCCESS(rv, rv);
+ bool isStun = false, isStuns = false, isTurn = false, isTurns = false;
+ url->SchemeIs("stun", &isStun);
+ url->SchemeIs("stuns", &isStuns);
+ url->SchemeIs("turn", &isTurn);
+ url->SchemeIs("turns", &isTurns);
+ if (!(isStun || isStuns || isTurn || isTurns)) {
+ return NS_ERROR_FAILURE;
+ }
+ if (isTurns || isStuns) {
+ continue; // TODO: Support TURNS and STUNS (Bug 1056934)
+ }
+ nsAutoCString spec;
+ rv = url->GetSpec(spec);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // TODO(jib@mozilla.com): Revisit once nsURI supports STUN/TURN (Bug 833509)
+ int32_t port;
+ nsAutoCString host;
+ nsAutoCString transport;
+ {
+ uint32_t hostPos;
+ int32_t hostLen;
+ nsAutoCString path;
+ rv = url->GetPath(path);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Tolerate query-string + parse 'transport=[udp|tcp]' by hand.
+ int32_t questionmark = path.FindChar('?');
+ if (questionmark >= 0) {
+ const nsCString match = NS_LITERAL_CSTRING("transport=");
+
+ for (int32_t i = questionmark, endPos; i >= 0; i = endPos) {
+ endPos = path.FindCharInSet("&", i + 1);
+ const nsDependentCSubstring fieldvaluepair = Substring(path, i + 1,
+ endPos);
+ if (StringBeginsWith(fieldvaluepair, match)) {
+ transport = Substring(fieldvaluepair, match.Length());
+ ToLowerCase(transport);
+ }
+ }
+ path.SetLength(questionmark);
+ }
+
+ rv = net_GetAuthURLParser()->ParseAuthority(path.get(), path.Length(),
+ nullptr, nullptr,
+ nullptr, nullptr,
+ &hostPos, &hostLen, &port);
+ NS_ENSURE_SUCCESS(rv, rv);
+ if (!hostLen) {
+ return NS_ERROR_FAILURE;
+ }
+ if (hostPos > 1) /* The username was removed */
+ return NS_ERROR_FAILURE;
+ path.Mid(host, hostPos, hostLen);
+ }
+ if (port == -1)
+ port = (isStuns || isTurns)? 5349 : 3478;
+
+ if (isTurn || isTurns) {
+ NS_ConvertUTF16toUTF8 credential(aServer.mCredential.Value());
+ NS_ConvertUTF16toUTF8 username(aServer.mUsername.Value());
+
+ if (!addTurnServer(host.get(), port,
+ username.get(),
+ credential.get(),
+ (transport.IsEmpty() ?
+ kNrIceTransportUdp : transport.get()))) {
+ return NS_ERROR_FAILURE;
+ }
+ } else {
+ if (!addStunServer(host.get(), port, (transport.IsEmpty() ?
+ kNrIceTransportUdp : transport.get()))) {
+ return NS_ERROR_FAILURE;
+ }
+ }
+ }
+ return NS_OK;
+}
+#endif
+
+nsresult
+PeerConnectionImpl::Initialize(PeerConnectionObserver& aObserver,
+ nsGlobalWindow* aWindow,
+ const PeerConnectionConfiguration& aConfiguration,
+ nsISupports* aThread)
+{
+ nsresult res;
+
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(aThread);
+ if (!mThread) {
+ mThread = do_QueryInterface(aThread);
+ MOZ_ASSERT(mThread);
+ }
+ CheckThread();
+
+ mPCObserver = do_GetWeakReference(&aObserver);
+
+ // Find the STS thread
+
+ mSTSThread = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &res);
+ MOZ_ASSERT(mSTSThread);
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+
+ // Initialize NSS if we are in content process. For chrome process, NSS should already
+ // been initialized.
+ if (XRE_IsParentProcess()) {
+ // This code interferes with the C++ unit test startup code.
+ nsCOMPtr<nsISupports> nssDummy = do_GetService("@mozilla.org/psm;1", &res);
+ NS_ENSURE_SUCCESS(res, res);
+ } else {
+ NS_ENSURE_SUCCESS(res = InitNSSInContent(), res);
+ }
+
+ // Currently no standalone unit tests for DataChannel,
+ // which is the user of mWindow
+ MOZ_ASSERT(aWindow);
+ mWindow = aWindow->AsInner();
+ NS_ENSURE_STATE(mWindow);
+#endif // MOZILLA_INTERNAL_API
+
+ PRTime timestamp = PR_Now();
+ // Ok if we truncate this.
+ char temp[128];
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ nsAutoCString locationCStr;
+
+ if (nsCOMPtr<nsIDOMLocation> location = mWindow->GetLocation()) {
+ nsAutoString locationAStr;
+ location->ToString(locationAStr);
+
+ CopyUTF16toUTF8(locationAStr, locationCStr);
+ }
+
+ SprintfLiteral(temp,
+ "%" PRIu64 " (id=%" PRIu64 " url=%s)",
+ static_cast<uint64_t>(timestamp),
+ static_cast<uint64_t>(mWindow ? mWindow->WindowID() : 0),
+ locationCStr.get() ? locationCStr.get() : "NULL");
+
+#else
+ SprintfLiteral(temp, "%" PRIu64, static_cast<uint64_t>(timestamp));
+#endif // MOZILLA_INTERNAL_API
+
+ mName = temp;
+
+ // Generate a random handle
+ unsigned char handle_bin[8];
+ SECStatus rv;
+ rv = PK11_GenerateRandom(handle_bin, sizeof(handle_bin));
+ if (rv != SECSuccess) {
+ MOZ_CRASH();
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ char hex[17];
+ SprintfLiteral(hex, "%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x",
+ handle_bin[0],
+ handle_bin[1],
+ handle_bin[2],
+ handle_bin[3],
+ handle_bin[4],
+ handle_bin[5],
+ handle_bin[6],
+ handle_bin[7]);
+
+ mHandle = hex;
+
+ STAMP_TIMECARD(mTimeCard, "Initializing PC Ctx");
+ res = PeerConnectionCtx::InitializeGlobal(mThread, mSTSThread);
+ NS_ENSURE_SUCCESS(res, res);
+
+ mMedia = new PeerConnectionMedia(this);
+
+ // Connect ICE slots.
+ mMedia->SignalIceGatheringStateChange.connect(
+ this,
+ &PeerConnectionImpl::IceGatheringStateChange);
+ mMedia->SignalUpdateDefaultCandidate.connect(
+ this,
+ &PeerConnectionImpl::UpdateDefaultCandidate);
+ mMedia->SignalEndOfLocalCandidates.connect(
+ this,
+ &PeerConnectionImpl::EndOfLocalCandidates);
+ mMedia->SignalIceConnectionStateChange.connect(
+ this,
+ &PeerConnectionImpl::IceConnectionStateChange);
+
+ mMedia->SignalCandidate.connect(this, &PeerConnectionImpl::CandidateReady);
+
+ // Initialize the media object.
+ res = mMedia->Init(aConfiguration.getStunServers(),
+ aConfiguration.getTurnServers(),
+ aConfiguration.getIceTransportPolicy());
+ if (NS_FAILED(res)) {
+ CSFLogError(logTag, "%s: Couldn't initialize media object", __FUNCTION__);
+ return res;
+ }
+
+ PeerConnectionCtx::GetInstance()->mPeerConnections[mHandle] = this;
+
+ mJsepSession = MakeUnique<JsepSessionImpl>(mName,
+ MakeUnique<PCUuidGenerator>());
+
+ res = mJsepSession->Init();
+ if (NS_FAILED(res)) {
+ CSFLogError(logTag, "%s: Couldn't init JSEP Session, res=%u",
+ __FUNCTION__,
+ static_cast<unsigned>(res));
+ return res;
+ }
+
+ res = mJsepSession->SetIceCredentials(mMedia->ice_ctx()->ufrag(),
+ mMedia->ice_ctx()->pwd());
+ if (NS_FAILED(res)) {
+ CSFLogError(logTag, "%s: Couldn't set ICE credentials, res=%u",
+ __FUNCTION__,
+ static_cast<unsigned>(res));
+ return res;
+ }
+
+#if defined(MOZILLA_EXTERNAL_LINKAGE)
+ {
+ mIdentity = DtlsIdentity::Generate();
+ if (!mIdentity) {
+ return NS_ERROR_FAILURE;
+ }
+
+ std::vector<uint8_t> fingerprint;
+ res = CalculateFingerprint(DtlsIdentity::DEFAULT_HASH_ALGORITHM,
+ &fingerprint);
+ NS_ENSURE_SUCCESS(res, res);
+
+ res = mJsepSession->AddDtlsFingerprint(DtlsIdentity::DEFAULT_HASH_ALGORITHM,
+ fingerprint);
+ NS_ENSURE_SUCCESS(res, res);
+ }
+#endif
+
+ res = mJsepSession->SetBundlePolicy(aConfiguration.getBundlePolicy());
+ if (NS_FAILED(res)) {
+ CSFLogError(logTag, "%s: Couldn't set bundle policy, res=%u, error=%s",
+ __FUNCTION__,
+ static_cast<unsigned>(res),
+ mJsepSession->GetLastError().c_str());
+ return res;
+ }
+
+ return NS_OK;
+}
+
+#ifndef MOZILLA_EXTERNAL_LINKAGE
+void
+PeerConnectionImpl::Initialize(PeerConnectionObserver& aObserver,
+ nsGlobalWindow& aWindow,
+ const RTCConfiguration& aConfiguration,
+ nsISupports* aThread,
+ ErrorResult &rv)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(aThread);
+ mThread = do_QueryInterface(aThread);
+
+ PeerConnectionConfiguration converted;
+ nsresult res = converted.Init(aConfiguration);
+ if (NS_FAILED(res)) {
+ CSFLogError(logTag, "%s: Invalid RTCConfiguration", __FUNCTION__);
+ rv.Throw(res);
+ return;
+ }
+
+ res = Initialize(aObserver, &aWindow, converted, aThread);
+ if (NS_FAILED(res)) {
+ rv.Throw(res);
+ }
+
+ if (!aConfiguration.mPeerIdentity.IsEmpty()) {
+ mPeerIdentity = new PeerIdentity(aConfiguration.mPeerIdentity);
+ mPrivacyRequested = true;
+ }
+}
+#endif
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+void
+PeerConnectionImpl::SetCertificate(mozilla::dom::RTCCertificate& aCertificate)
+{
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ MOZ_ASSERT(!mCertificate, "This can only be called once");
+ mCertificate = &aCertificate;
+
+ std::vector<uint8_t> fingerprint;
+ nsresult rv = CalculateFingerprint(DtlsIdentity::DEFAULT_HASH_ALGORITHM,
+ &fingerprint);
+ if (NS_FAILED(rv)) {
+ CSFLogError(logTag, "%s: Couldn't calculate fingerprint, rv=%u",
+ __FUNCTION__, static_cast<unsigned>(rv));
+ mCertificate = nullptr;
+ return;
+ }
+ rv = mJsepSession->AddDtlsFingerprint(DtlsIdentity::DEFAULT_HASH_ALGORITHM,
+ fingerprint);
+ if (NS_FAILED(rv)) {
+ CSFLogError(logTag, "%s: Couldn't set DTLS credentials, rv=%u",
+ __FUNCTION__, static_cast<unsigned>(rv));
+ mCertificate = nullptr;
+ }
+}
+
+const RefPtr<mozilla::dom::RTCCertificate>&
+PeerConnectionImpl::Certificate() const
+{
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ return mCertificate;
+}
+#endif
+
+RefPtr<DtlsIdentity>
+PeerConnectionImpl::Identity() const
+{
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ MOZ_ASSERT(mCertificate);
+ return mCertificate->CreateDtlsIdentity();
+#else
+ RefPtr<DtlsIdentity> id = mIdentity;
+ return id;
+#endif
+}
+
+class CompareCodecPriority {
+ public:
+ void SetPreferredCodec(int32_t preferredCodec) {
+ // This pref really ought to be a string, preferably something like
+ // "H264" or "VP8" instead of a payload type.
+ // Bug 1101259.
+ std::ostringstream os;
+ os << preferredCodec;
+ mPreferredCodec = os.str();
+ }
+
+ bool operator()(JsepCodecDescription* lhs,
+ JsepCodecDescription* rhs) const {
+ if (!mPreferredCodec.empty() &&
+ lhs->mDefaultPt == mPreferredCodec &&
+ rhs->mDefaultPt != mPreferredCodec) {
+ return true;
+ }
+
+ if (lhs->mStronglyPreferred && !rhs->mStronglyPreferred) {
+ return true;
+ }
+
+ return false;
+ }
+
+ private:
+ std::string mPreferredCodec;
+};
+
+class ConfigureCodec {
+ public:
+ explicit ConfigureCodec(nsCOMPtr<nsIPrefBranch>& branch) :
+ mHardwareH264Enabled(false),
+ mHardwareH264Supported(false),
+ mSoftwareH264Enabled(false),
+ mH264Enabled(false),
+ mVP9Enabled(false),
+ mH264Level(13), // minimum suggested for WebRTC spec
+ mH264MaxBr(0), // Unlimited
+ mH264MaxMbps(0), // Unlimited
+ mVP8MaxFs(0),
+ mVP8MaxFr(0),
+ mUseTmmbr(false),
+ mUseRemb(false),
+ mUseAudioFec(false),
+ mRedUlpfecEnabled(false),
+ mDtmfEnabled(false)
+ {
+#ifdef MOZ_WEBRTC_OMX
+ // Check to see if what HW codecs are available (not in use) at this moment.
+ // Note that streaming video decode can reserve a decoder
+
+ // XXX See bug 1018791 Implement W3 codec reservation policy
+ // Note that currently, OMXCodecReservation needs to be held by an sp<> because it puts
+ // 'this' into an sp<EventListener> to talk to the resource reservation code
+
+ // This pref is a misnomer; it is solely for h264 _hardware_ support.
+ branch->GetBoolPref("media.peerconnection.video.h264_enabled",
+ &mHardwareH264Enabled);
+
+ if (mHardwareH264Enabled) {
+ // Ok, it is preffed on. Can we actually do it?
+ android::sp<android::OMXCodecReservation> encode = new android::OMXCodecReservation(true);
+ android::sp<android::OMXCodecReservation> decode = new android::OMXCodecReservation(false);
+
+ // Currently we just check if they're available right now, which will fail if we're
+ // trying to call ourself, for example. It will work for most real-world cases, like
+ // if we try to add a person to a 2-way call to make a 3-way mesh call
+ if (encode->ReserveOMXCodec() && decode->ReserveOMXCodec()) {
+ CSFLogDebug( logTag, "%s: H264 hardware codec available", __FUNCTION__);
+ mHardwareH264Supported = true;
+ }
+ }
+
+#endif // MOZ_WEBRTC_OMX
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ mSoftwareH264Enabled = PeerConnectionCtx::GetInstance()->gmpHasH264();
+#else
+ // For unit-tests
+ mSoftwareH264Enabled = true;
+#endif
+
+ mH264Enabled = mHardwareH264Supported || mSoftwareH264Enabled;
+
+ branch->GetIntPref("media.navigator.video.h264.level", &mH264Level);
+ mH264Level &= 0xFF;
+
+ branch->GetIntPref("media.navigator.video.h264.max_br", &mH264MaxBr);
+
+#ifdef MOZ_WEBRTC_OMX
+ // Level 1.2; but let's allow CIF@30 or QVGA@30+ by default
+ mH264MaxMbps = 11880;
+#endif
+
+ branch->GetIntPref("media.navigator.video.h264.max_mbps", &mH264MaxMbps);
+
+ branch->GetBoolPref("media.peerconnection.video.vp9_enabled",
+ &mVP9Enabled);
+
+ branch->GetIntPref("media.navigator.video.max_fs", &mVP8MaxFs);
+ if (mVP8MaxFs <= 0) {
+ mVP8MaxFs = 12288; // We must specify something other than 0
+ }
+
+ branch->GetIntPref("media.navigator.video.max_fr", &mVP8MaxFr);
+ if (mVP8MaxFr <= 0) {
+ mVP8MaxFr = 60; // We must specify something other than 0
+ }
+
+ // TMMBR is enabled from a pref in about:config
+ branch->GetBoolPref("media.navigator.video.use_tmmbr", &mUseTmmbr);
+
+ // REMB is enabled by default, but can be disabled from about:config
+ branch->GetBoolPref("media.navigator.video.use_remb", &mUseRemb);
+
+ branch->GetBoolPref("media.navigator.audio.use_fec", &mUseAudioFec);
+
+ branch->GetBoolPref("media.navigator.video.red_ulpfec_enabled",
+ &mRedUlpfecEnabled);
+
+ // media.peerconnection.dtmf.enabled controls both sdp generation for
+ // DTMF support as well as DTMF exposure to DOM
+ branch->GetBoolPref("media.peerconnection.dtmf.enabled", &mDtmfEnabled);
+ }
+
+ void operator()(JsepCodecDescription* codec) const
+ {
+ switch (codec->mType) {
+ case SdpMediaSection::kAudio:
+ {
+ JsepAudioCodecDescription& audioCodec =
+ static_cast<JsepAudioCodecDescription&>(*codec);
+ if (audioCodec.mName == "opus") {
+ audioCodec.mFECEnabled = mUseAudioFec;
+ } else if (audioCodec.mName == "telephone-event") {
+ audioCodec.mEnabled = mDtmfEnabled;
+ }
+ }
+ break;
+ case SdpMediaSection::kVideo:
+ {
+ JsepVideoCodecDescription& videoCodec =
+ static_cast<JsepVideoCodecDescription&>(*codec);
+
+ if (videoCodec.mName == "H264") {
+ // Override level
+ videoCodec.mProfileLevelId &= 0xFFFF00;
+ videoCodec.mProfileLevelId |= mH264Level;
+
+ videoCodec.mConstraints.maxBr = mH264MaxBr;
+
+ videoCodec.mConstraints.maxMbps = mH264MaxMbps;
+
+ // Might disable it, but we set up other params anyway
+ videoCodec.mEnabled = mH264Enabled;
+
+ if (videoCodec.mPacketizationMode == 0 && !mSoftwareH264Enabled) {
+ // We're assuming packetization mode 0 is unsupported by
+ // hardware.
+ videoCodec.mEnabled = false;
+ }
+
+ if (mHardwareH264Supported) {
+ videoCodec.mStronglyPreferred = true;
+ }
+ } else if (videoCodec.mName == "red") {
+ videoCodec.mEnabled = mRedUlpfecEnabled;
+ } else if (videoCodec.mName == "ulpfec") {
+ videoCodec.mEnabled = mRedUlpfecEnabled;
+ } else if (videoCodec.mName == "VP8" || videoCodec.mName == "VP9") {
+ if (videoCodec.mName == "VP9" && !mVP9Enabled) {
+ videoCodec.mEnabled = false;
+ break;
+ }
+ videoCodec.mConstraints.maxFs = mVP8MaxFs;
+ videoCodec.mConstraints.maxFps = mVP8MaxFr;
+ }
+
+ if (mUseTmmbr) {
+ videoCodec.EnableTmmbr();
+ }
+ if (mUseRemb) {
+ videoCodec.EnableRemb();
+ }
+ }
+ break;
+ case SdpMediaSection::kText:
+ case SdpMediaSection::kApplication:
+ case SdpMediaSection::kMessage:
+ {} // Nothing to configure for these.
+ }
+ }
+
+ private:
+ bool mHardwareH264Enabled;
+ bool mHardwareH264Supported;
+ bool mSoftwareH264Enabled;
+ bool mH264Enabled;
+ bool mVP9Enabled;
+ int32_t mH264Level;
+ int32_t mH264MaxBr;
+ int32_t mH264MaxMbps;
+ int32_t mVP8MaxFs;
+ int32_t mVP8MaxFr;
+ bool mUseTmmbr;
+ bool mUseRemb;
+ bool mUseAudioFec;
+ bool mRedUlpfecEnabled;
+ bool mDtmfEnabled;
+};
+
+class ConfigureRedCodec {
+ public:
+ explicit ConfigureRedCodec(nsCOMPtr<nsIPrefBranch>& branch,
+ std::vector<uint8_t>* redundantEncodings) :
+ mRedundantEncodings(redundantEncodings)
+ {
+ // if we wanted to override or modify which encodings are considered
+ // for redundant encodings, we'd probably want to handle it here by
+ // checking prefs modifying the operator() code below
+ }
+
+ void operator()(JsepCodecDescription* codec) const
+ {
+ if (codec->mType == SdpMediaSection::kVideo &&
+ codec->mEnabled == false) {
+ uint8_t pt = (uint8_t)strtoul(codec->mDefaultPt.c_str(), nullptr, 10);
+ // don't search for the codec payload type unless we have a valid
+ // conversion (non-zero)
+ if (pt != 0) {
+ std::vector<uint8_t>::iterator it =
+ std::find(mRedundantEncodings->begin(),
+ mRedundantEncodings->end(),
+ pt);
+ if (it != mRedundantEncodings->end()) {
+ mRedundantEncodings->erase(it);
+ }
+ }
+ }
+ }
+
+ private:
+ std::vector<uint8_t>* mRedundantEncodings;
+};
+
+nsresult
+PeerConnectionImpl::ConfigureJsepSessionCodecs() {
+ nsresult res;
+ nsCOMPtr<nsIPrefService> prefs =
+ do_GetService("@mozilla.org/preferences-service;1", &res);
+
+ if (NS_FAILED(res)) {
+ CSFLogError(logTag, "%s: Couldn't get prefs service, res=%u",
+ __FUNCTION__,
+ static_cast<unsigned>(res));
+ return res;
+ }
+
+ nsCOMPtr<nsIPrefBranch> branch = do_QueryInterface(prefs);
+ if (!branch) {
+ CSFLogError(logTag, "%s: Couldn't get prefs branch", __FUNCTION__);
+ return NS_ERROR_FAILURE;
+ }
+
+ ConfigureCodec configurer(branch);
+ mJsepSession->ForEachCodec(configurer);
+
+ // first find the red codec description
+ std::vector<JsepCodecDescription*>& codecs = mJsepSession->Codecs();
+ JsepVideoCodecDescription* redCodec = nullptr;
+ for (auto codec : codecs) {
+ // we only really care about finding the RED codec if it is
+ // enabled
+ if (codec->mName == "red" && codec->mEnabled) {
+ redCodec = static_cast<JsepVideoCodecDescription*>(codec);
+ break;
+ }
+ }
+ // if red codec was found, configure it for the other enabled codecs
+ if (redCodec) {
+ ConfigureRedCodec configureRed(branch, &(redCodec->mRedundantEncodings));
+ mJsepSession->ForEachCodec(configureRed);
+ }
+
+ // We use this to sort the list of codecs once everything is configured
+ CompareCodecPriority comparator;
+
+ // Sort by priority
+ int32_t preferredCodec = 0;
+ branch->GetIntPref("media.navigator.video.preferred_codec",
+ &preferredCodec);
+
+ if (preferredCodec) {
+ comparator.SetPreferredCodec(preferredCodec);
+ }
+
+ mJsepSession->SortCodecs(comparator);
+ return NS_OK;
+}
+
+// Data channels won't work without a window, so in order for the C++ unit
+// tests to work (it doesn't have a window available) we ifdef the following
+// two implementations.
+NS_IMETHODIMP
+PeerConnectionImpl::EnsureDataConnection(uint16_t aNumstreams)
+{
+ PC_AUTO_ENTER_API_CALL(false);
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ if (mDataConnection) {
+ CSFLogDebug(logTag,"%s DataConnection already connected",__FUNCTION__);
+ // Ignore the request to connect when already connected. This entire
+ // implementation is temporary. Ignore aNumstreams as it's merely advisory
+ // and we increase the number of streams dynamically as needed.
+ return NS_OK;
+ }
+ mDataConnection = new DataChannelConnection(this);
+ if (!mDataConnection->Init(5000, aNumstreams, true)) {
+ CSFLogError(logTag,"%s DataConnection Init Failed",__FUNCTION__);
+ return NS_ERROR_FAILURE;
+ }
+ CSFLogDebug(logTag,"%s DataChannelConnection %p attached to %s",
+ __FUNCTION__, (void*) mDataConnection.get(), mHandle.c_str());
+#endif
+ return NS_OK;
+}
+
+nsresult
+PeerConnectionImpl::GetDatachannelParameters(
+ const mozilla::JsepApplicationCodecDescription** datachannelCodec,
+ uint16_t* level) const {
+
+ auto trackPairs = mJsepSession->GetNegotiatedTrackPairs();
+ for (auto j = trackPairs.begin(); j != trackPairs.end(); ++j) {
+ JsepTrackPair& trackPair = *j;
+
+ bool sendDataChannel =
+ trackPair.mSending &&
+ trackPair.mSending->GetMediaType() == SdpMediaSection::kApplication;
+ bool recvDataChannel =
+ trackPair.mReceiving &&
+ trackPair.mReceiving->GetMediaType() == SdpMediaSection::kApplication;
+ (void)recvDataChannel;
+ MOZ_ASSERT(sendDataChannel == recvDataChannel);
+
+ if (sendDataChannel) {
+ // This will release assert if there is no such index, and that's ok
+ const JsepTrackEncoding& encoding =
+ trackPair.mSending->GetNegotiatedDetails()->GetEncoding(0);
+
+ if (encoding.GetCodecs().empty()) {
+ CSFLogError(logTag, "%s: Negotiated m=application with no codec. "
+ "This is likely to be broken.",
+ __FUNCTION__);
+ return NS_ERROR_FAILURE;
+ }
+
+ for (const JsepCodecDescription* codec : encoding.GetCodecs()) {
+ if (codec->mType != SdpMediaSection::kApplication) {
+ CSFLogError(logTag, "%s: Codec type for m=application was %u, this "
+ "is a bug.",
+ __FUNCTION__,
+ static_cast<unsigned>(codec->mType));
+ MOZ_ASSERT(false, "Codec for m=application was not \"application\"");
+ return NS_ERROR_FAILURE;
+ }
+
+ if (codec->mName != "webrtc-datachannel") {
+ CSFLogWarn(logTag, "%s: Codec for m=application was not "
+ "webrtc-datachannel (was instead %s). ",
+ __FUNCTION__,
+ codec->mName.c_str());
+ continue;
+ }
+
+ *datachannelCodec =
+ static_cast<const JsepApplicationCodecDescription*>(codec);
+ if (trackPair.mBundleLevel.isSome()) {
+ *level = static_cast<uint16_t>(*trackPair.mBundleLevel);
+ } else {
+ *level = static_cast<uint16_t>(trackPair.mLevel);
+ }
+ return NS_OK;
+ }
+ }
+ }
+
+ *datachannelCodec = nullptr;
+ *level = 0;
+ return NS_OK;
+}
+
+/* static */
+void
+PeerConnectionImpl::DeferredAddTrackToJsepSession(
+ const std::string& pcHandle,
+ SdpMediaSection::MediaType type,
+ const std::string& streamId,
+ const std::string& trackId)
+{
+ PeerConnectionWrapper wrapper(pcHandle);
+
+ if (wrapper.impl()) {
+ if (!PeerConnectionCtx::GetInstance()->isReady()) {
+ MOZ_CRASH("Why is DeferredAddTrackToJsepSession being executed when the "
+ "PeerConnectionCtx isn't ready?");
+ }
+ wrapper.impl()->AddTrackToJsepSession(type, streamId, trackId);
+ }
+}
+
+nsresult
+PeerConnectionImpl::AddTrackToJsepSession(SdpMediaSection::MediaType type,
+ const std::string& streamId,
+ const std::string& trackId)
+{
+ nsresult res = ConfigureJsepSessionCodecs();
+ if (NS_FAILED(res)) {
+ CSFLogError(logTag, "Failed to configure codecs");
+ return res;
+ }
+
+ res = mJsepSession->AddTrack(
+ new JsepTrack(type, streamId, trackId, sdp::kSend));
+
+ if (NS_FAILED(res)) {
+ std::string errorString = mJsepSession->GetLastError();
+ CSFLogError(logTag, "%s (%s) : pc = %s, error = %s",
+ __FUNCTION__,
+ type == SdpMediaSection::kAudio ? "audio" : "video",
+ mHandle.c_str(),
+ errorString.c_str());
+ return NS_ERROR_FAILURE;
+ }
+
+ return NS_OK;
+}
+
+nsresult
+PeerConnectionImpl::InitializeDataChannel()
+{
+ PC_AUTO_ENTER_API_CALL(false);
+ CSFLogDebug(logTag, "%s", __FUNCTION__);
+
+ const JsepApplicationCodecDescription* codec;
+ uint16_t level;
+ nsresult rv = GetDatachannelParameters(&codec, &level);
+
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!codec) {
+ CSFLogDebug(logTag, "%s: We did not negotiate datachannel", __FUNCTION__);
+ return NS_OK;
+ }
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ uint32_t channels = codec->mChannels;
+ if (channels > MAX_NUM_STREAMS) {
+ channels = MAX_NUM_STREAMS;
+ }
+
+ rv = EnsureDataConnection(channels);
+ if (NS_SUCCEEDED(rv)) {
+ uint16_t localport = 5000;
+ uint16_t remoteport = 0;
+ // The logic that reflects the remote payload type is what sets the remote
+ // port here.
+ if (!codec->GetPtAsInt(&remoteport)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ // use the specified TransportFlow
+ RefPtr<TransportFlow> flow = mMedia->GetTransportFlow(level, false).get();
+ CSFLogDebug(logTag, "Transportflow[%u] = %p",
+ static_cast<unsigned>(level), flow.get());
+ if (flow) {
+ if (mDataConnection->ConnectViaTransportFlow(flow,
+ localport,
+ remoteport)) {
+ return NS_OK;
+ }
+ }
+ // If we inited the DataConnection, call Destroy() before releasing it
+ mDataConnection->Destroy();
+ }
+ mDataConnection = nullptr;
+#endif
+ return NS_ERROR_FAILURE;
+}
+
+already_AddRefed<nsDOMDataChannel>
+PeerConnectionImpl::CreateDataChannel(const nsAString& aLabel,
+ const nsAString& aProtocol,
+ uint16_t aType,
+ bool outOfOrderAllowed,
+ uint16_t aMaxTime,
+ uint16_t aMaxNum,
+ bool aExternalNegotiated,
+ uint16_t aStream,
+ ErrorResult &rv)
+{
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ RefPtr<nsDOMDataChannel> result;
+ rv = CreateDataChannel(aLabel, aProtocol, aType, outOfOrderAllowed,
+ aMaxTime, aMaxNum, aExternalNegotiated,
+ aStream, getter_AddRefs(result));
+ return result.forget();
+#else
+ return nullptr;
+#endif
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::CreateDataChannel(const nsAString& aLabel,
+ const nsAString& aProtocol,
+ uint16_t aType,
+ bool outOfOrderAllowed,
+ uint16_t aMaxTime,
+ uint16_t aMaxNum,
+ bool aExternalNegotiated,
+ uint16_t aStream,
+ nsDOMDataChannel** aRetval)
+{
+ PC_AUTO_ENTER_API_CALL(false);
+ MOZ_ASSERT(aRetval);
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ RefPtr<DataChannel> dataChannel;
+ DataChannelConnection::Type theType =
+ static_cast<DataChannelConnection::Type>(aType);
+
+ nsresult rv = EnsureDataConnection(WEBRTC_DATACHANNEL_STREAMS_DEFAULT);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ dataChannel = mDataConnection->Open(
+ NS_ConvertUTF16toUTF8(aLabel), NS_ConvertUTF16toUTF8(aProtocol), theType,
+ !outOfOrderAllowed,
+ aType == DataChannelConnection::PARTIAL_RELIABLE_REXMIT ? aMaxNum :
+ (aType == DataChannelConnection::PARTIAL_RELIABLE_TIMED ? aMaxTime : 0),
+ nullptr, nullptr, aExternalNegotiated, aStream
+ );
+ NS_ENSURE_TRUE(dataChannel,NS_ERROR_FAILURE);
+
+ CSFLogDebug(logTag, "%s: making DOMDataChannel", __FUNCTION__);
+
+ if (!mHaveDataStream) {
+
+ std::string streamId;
+ std::string trackId;
+
+ // Generate random ids because these aren't linked to any local streams.
+ if (!mUuidGen->Generate(&streamId)) {
+ return NS_ERROR_FAILURE;
+ }
+ if (!mUuidGen->Generate(&trackId)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ RefPtr<JsepTrack> track(new JsepTrack(
+ mozilla::SdpMediaSection::kApplication,
+ streamId,
+ trackId,
+ sdp::kSend));
+
+ rv = mJsepSession->AddTrack(track);
+ if (NS_FAILED(rv)) {
+ CSFLogError(logTag, "%s: Failed to add application track.",
+ __FUNCTION__);
+ return rv;
+ }
+ mHaveDataStream = true;
+ OnNegotiationNeeded();
+ }
+ nsIDOMDataChannel *retval;
+ rv = NS_NewDOMDataChannel(dataChannel.forget(), mWindow, &retval);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ *aRetval = static_cast<nsDOMDataChannel*>(retval);
+#endif
+ return NS_OK;
+}
+
+// do_QueryObjectReferent() - Helps get PeerConnectionObserver from nsWeakPtr.
+//
+// nsWeakPtr deals in XPCOM interfaces, while webidl bindings are concrete objs.
+// TODO: Turn this into a central (template) function somewhere (Bug 939178)
+//
+// Without it, each weak-ref call in this file would look like this:
+//
+// nsCOMPtr<nsISupportsWeakReference> tmp = do_QueryReferent(mPCObserver);
+// if (!tmp) {
+// return;
+// }
+// RefPtr<nsSupportsWeakReference> tmp2 = do_QueryObject(tmp);
+// RefPtr<PeerConnectionObserver> pco = static_cast<PeerConnectionObserver*>(&*tmp2);
+
+static already_AddRefed<PeerConnectionObserver>
+do_QueryObjectReferent(nsIWeakReference* aRawPtr) {
+ nsCOMPtr<nsISupportsWeakReference> tmp = do_QueryReferent(aRawPtr);
+ if (!tmp) {
+ return nullptr;
+ }
+ RefPtr<nsSupportsWeakReference> tmp2 = do_QueryObject(tmp);
+ RefPtr<PeerConnectionObserver> tmp3 = static_cast<PeerConnectionObserver*>(&*tmp2);
+ return tmp3.forget();
+}
+
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+// Not a member function so that we don't need to keep the PC live.
+static void NotifyDataChannel_m(RefPtr<nsIDOMDataChannel> aChannel,
+ RefPtr<PeerConnectionObserver> aObserver)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ JSErrorResult rv;
+ RefPtr<nsDOMDataChannel> channel = static_cast<nsDOMDataChannel*>(&*aChannel);
+ aObserver->NotifyDataChannel(*channel, rv);
+ NS_DataChannelAppReady(aChannel);
+}
+#endif
+
+void
+PeerConnectionImpl::NotifyDataChannel(already_AddRefed<DataChannel> aChannel)
+{
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+
+ // XXXkhuey this is completely fucked up. We can't use RefPtr<DataChannel>
+ // here because DataChannel's AddRef/Release are non-virtual and not visible
+ // if !MOZILLA_INTERNAL_API, but this function leaks the DataChannel if
+ // !MOZILLA_INTERNAL_API because it never transfers the ref to
+ // NS_NewDOMDataChannel.
+ DataChannel* channel = aChannel.take();
+ MOZ_ASSERT(channel);
+
+ CSFLogDebug(logTag, "%s: channel: %p", __FUNCTION__, channel);
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ nsCOMPtr<nsIDOMDataChannel> domchannel;
+ nsresult rv = NS_NewDOMDataChannel(already_AddRefed<DataChannel>(channel),
+ mWindow, getter_AddRefs(domchannel));
+ NS_ENSURE_SUCCESS_VOID(rv);
+
+ mHaveDataStream = true;
+
+ RefPtr<PeerConnectionObserver> pco = do_QueryObjectReferent(mPCObserver);
+ if (!pco) {
+ return;
+ }
+
+ RUN_ON_THREAD(mThread,
+ WrapRunnableNM(NotifyDataChannel_m,
+ domchannel.get(),
+ pco),
+ NS_DISPATCH_NORMAL);
+#endif
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::CreateOffer(const RTCOfferOptions& aOptions)
+{
+ JsepOfferOptions options;
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ // convert the RTCOfferOptions to JsepOfferOptions
+ if (aOptions.mOfferToReceiveAudio.WasPassed()) {
+ options.mOfferToReceiveAudio =
+ mozilla::Some(size_t(aOptions.mOfferToReceiveAudio.Value()));
+ }
+
+ if (aOptions.mOfferToReceiveVideo.WasPassed()) {
+ options.mOfferToReceiveVideo =
+ mozilla::Some(size_t(aOptions.mOfferToReceiveVideo.Value()));
+ }
+
+ options.mIceRestart = mozilla::Some(aOptions.mIceRestart);
+
+ if (aOptions.mMozDontOfferDataChannel.WasPassed()) {
+ options.mDontOfferDataChannel =
+ mozilla::Some(aOptions.mMozDontOfferDataChannel.Value());
+ }
+#endif
+ return CreateOffer(options);
+}
+
+static void DeferredCreateOffer(const std::string& aPcHandle,
+ const JsepOfferOptions& aOptions) {
+ PeerConnectionWrapper wrapper(aPcHandle);
+
+ if (wrapper.impl()) {
+ if (!PeerConnectionCtx::GetInstance()->isReady()) {
+ MOZ_CRASH("Why is DeferredCreateOffer being executed when the "
+ "PeerConnectionCtx isn't ready?");
+ }
+ wrapper.impl()->CreateOffer(aOptions);
+ }
+}
+
+// Used by unit tests and the IDL CreateOffer.
+NS_IMETHODIMP
+PeerConnectionImpl::CreateOffer(const JsepOfferOptions& aOptions)
+{
+ PC_AUTO_ENTER_API_CALL(true);
+ bool restartIce = aOptions.mIceRestart.isSome() && *(aOptions.mIceRestart);
+ if (!restartIce &&
+ mMedia->GetIceRestartState() ==
+ PeerConnectionMedia::ICE_RESTART_PROVISIONAL) {
+ RollbackIceRestart();
+ }
+
+ RefPtr<PeerConnectionObserver> pco = do_QueryObjectReferent(mPCObserver);
+ if (!pco) {
+ return NS_OK;
+ }
+
+ if (!PeerConnectionCtx::GetInstance()->isReady()) {
+ // Uh oh. We're not ready yet. Enqueue this operation.
+ PeerConnectionCtx::GetInstance()->queueJSEPOperation(
+ WrapRunnableNM(DeferredCreateOffer, mHandle, aOptions));
+ STAMP_TIMECARD(mTimeCard, "Deferring CreateOffer (not ready)");
+ return NS_OK;
+ }
+
+ CSFLogDebug(logTag, "CreateOffer()");
+
+ nsresult nrv;
+ if (restartIce && !mJsepSession->GetLocalDescription().empty()) {
+ // If restart is requested and a restart is already in progress, we
+ // need to make room for the restart request so we either rollback
+ // or finalize to "clear" the previous restart.
+ if (mMedia->GetIceRestartState() ==
+ PeerConnectionMedia::ICE_RESTART_PROVISIONAL) {
+ // we're mid-restart and can rollback
+ RollbackIceRestart();
+ } else if (mMedia->GetIceRestartState() ==
+ PeerConnectionMedia::ICE_RESTART_COMMITTED) {
+ // we're mid-restart and can't rollback, finalize restart even
+ // though we're not really ready yet
+ FinalizeIceRestart();
+ }
+
+ CSFLogInfo(logTag, "Offerer restarting ice");
+ nrv = SetupIceRestart();
+ if (NS_FAILED(nrv)) {
+ CSFLogError(logTag, "%s: SetupIceRestart failed, res=%u",
+ __FUNCTION__,
+ static_cast<unsigned>(nrv));
+ return nrv;
+ }
+ }
+
+ nrv = ConfigureJsepSessionCodecs();
+ if (NS_FAILED(nrv)) {
+ CSFLogError(logTag, "Failed to configure codecs");
+ return nrv;
+ }
+
+ STAMP_TIMECARD(mTimeCard, "Create Offer");
+
+ std::string offer;
+
+ nrv = mJsepSession->CreateOffer(aOptions, &offer);
+ JSErrorResult rv;
+ if (NS_FAILED(nrv)) {
+ Error error;
+ switch (nrv) {
+ case NS_ERROR_UNEXPECTED:
+ error = kInvalidState;
+ break;
+ default:
+ error = kInternalError;
+ }
+ std::string errorString = mJsepSession->GetLastError();
+
+ CSFLogError(logTag, "%s: pc = %s, error = %s",
+ __FUNCTION__, mHandle.c_str(), errorString.c_str());
+ pco->OnCreateOfferError(error, ObString(errorString.c_str()), rv);
+ } else {
+ pco->OnCreateOfferSuccess(ObString(offer.c_str()), rv);
+ }
+
+ UpdateSignalingState();
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::CreateAnswer()
+{
+ PC_AUTO_ENTER_API_CALL(true);
+
+ RefPtr<PeerConnectionObserver> pco = do_QueryObjectReferent(mPCObserver);
+ if (!pco) {
+ return NS_OK;
+ }
+
+ CSFLogDebug(logTag, "CreateAnswer()");
+
+ nsresult nrv;
+ if (mJsepSession->RemoteIceIsRestarting()) {
+ if (mMedia->GetIceRestartState() ==
+ PeerConnectionMedia::ICE_RESTART_COMMITTED) {
+ FinalizeIceRestart();
+ } else if (!mMedia->IsIceRestarting()) {
+ CSFLogInfo(logTag, "Answerer restarting ice");
+ nrv = SetupIceRestart();
+ if (NS_FAILED(nrv)) {
+ CSFLogError(logTag, "%s: SetupIceRestart failed, res=%u",
+ __FUNCTION__,
+ static_cast<unsigned>(nrv));
+ return nrv;
+ }
+ }
+ }
+
+ STAMP_TIMECARD(mTimeCard, "Create Answer");
+ // TODO(bug 1098015): Once RTCAnswerOptions is standardized, we'll need to
+ // add it as a param to CreateAnswer, and convert it here.
+ JsepAnswerOptions options;
+ std::string answer;
+
+ nrv = mJsepSession->CreateAnswer(options, &answer);
+ JSErrorResult rv;
+ if (NS_FAILED(nrv)) {
+ Error error;
+ switch (nrv) {
+ case NS_ERROR_UNEXPECTED:
+ error = kInvalidState;
+ break;
+ default:
+ error = kInternalError;
+ }
+ std::string errorString = mJsepSession->GetLastError();
+
+ CSFLogError(logTag, "%s: pc = %s, error = %s",
+ __FUNCTION__, mHandle.c_str(), errorString.c_str());
+ pco->OnCreateAnswerError(error, ObString(errorString.c_str()), rv);
+ } else {
+ pco->OnCreateAnswerSuccess(ObString(answer.c_str()), rv);
+ }
+
+ UpdateSignalingState();
+
+ return NS_OK;
+}
+
+nsresult
+PeerConnectionImpl::SetupIceRestart()
+{
+ if (mMedia->IsIceRestarting()) {
+ CSFLogError(logTag, "%s: ICE already restarting",
+ __FUNCTION__);
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ std::string ufrag = mMedia->ice_ctx()->GetNewUfrag();
+ std::string pwd = mMedia->ice_ctx()->GetNewPwd();
+ if (ufrag.empty() || pwd.empty()) {
+ CSFLogError(logTag, "%s: Bad ICE credentials (ufrag:'%s'/pwd:'%s')",
+ __FUNCTION__,
+ ufrag.c_str(), pwd.c_str());
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ // hold on to the current ice creds in case of rollback
+ mPreviousIceUfrag = mJsepSession->GetUfrag();
+ mPreviousIcePwd = mJsepSession->GetPwd();
+ mMedia->BeginIceRestart(ufrag, pwd);
+
+ nsresult nrv = mJsepSession->SetIceCredentials(ufrag, pwd);
+ if (NS_FAILED(nrv)) {
+ CSFLogError(logTag, "%s: Couldn't set ICE credentials, res=%u",
+ __FUNCTION__,
+ static_cast<unsigned>(nrv));
+ return nrv;
+ }
+
+ return NS_OK;
+}
+
+nsresult
+PeerConnectionImpl::RollbackIceRestart()
+{
+ mMedia->RollbackIceRestart();
+ // put back the previous ice creds
+ nsresult nrv = mJsepSession->SetIceCredentials(mPreviousIceUfrag,
+ mPreviousIcePwd);
+ if (NS_FAILED(nrv)) {
+ CSFLogError(logTag, "%s: Couldn't set ICE credentials, res=%u",
+ __FUNCTION__,
+ static_cast<unsigned>(nrv));
+ return nrv;
+ }
+ mPreviousIceUfrag = "";
+ mPreviousIcePwd = "";
+
+ return NS_OK;
+}
+
+void
+PeerConnectionImpl::FinalizeIceRestart()
+{
+ mMedia->FinalizeIceRestart();
+ // clear the previous ice creds since they are no longer needed
+ mPreviousIceUfrag = "";
+ mPreviousIcePwd = "";
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::SetLocalDescription(int32_t aAction, const char* aSDP)
+{
+ PC_AUTO_ENTER_API_CALL(true);
+
+ if (!aSDP) {
+ CSFLogError(logTag, "%s - aSDP is NULL", __FUNCTION__);
+ return NS_ERROR_FAILURE;
+ }
+
+ JSErrorResult rv;
+ RefPtr<PeerConnectionObserver> pco = do_QueryObjectReferent(mPCObserver);
+ if (!pco) {
+ return NS_OK;
+ }
+
+ STAMP_TIMECARD(mTimeCard, "Set Local Description");
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ bool isolated = mMedia->AnyLocalTrackHasPeerIdentity();
+ mPrivacyRequested = mPrivacyRequested || isolated;
+#endif
+
+ mLocalRequestedSDP = aSDP;
+
+ JsepSdpType sdpType;
+ switch (aAction) {
+ case IPeerConnection::kActionOffer:
+ sdpType = mozilla::kJsepSdpOffer;
+ break;
+ case IPeerConnection::kActionAnswer:
+ sdpType = mozilla::kJsepSdpAnswer;
+ break;
+ case IPeerConnection::kActionPRAnswer:
+ sdpType = mozilla::kJsepSdpPranswer;
+ break;
+ case IPeerConnection::kActionRollback:
+ sdpType = mozilla::kJsepSdpRollback;
+ break;
+ default:
+ MOZ_ASSERT(false);
+ return NS_ERROR_FAILURE;
+
+ }
+ nsresult nrv = mJsepSession->SetLocalDescription(sdpType,
+ mLocalRequestedSDP);
+ if (NS_FAILED(nrv)) {
+ Error error;
+ switch (nrv) {
+ case NS_ERROR_INVALID_ARG:
+ error = kInvalidSessionDescription;
+ break;
+ case NS_ERROR_UNEXPECTED:
+ error = kInvalidState;
+ break;
+ default:
+ error = kInternalError;
+ }
+
+ std::string errorString = mJsepSession->GetLastError();
+ CSFLogError(logTag, "%s: pc = %s, error = %s",
+ __FUNCTION__, mHandle.c_str(), errorString.c_str());
+ pco->OnSetLocalDescriptionError(error, ObString(errorString.c_str()), rv);
+ } else {
+ pco->OnSetLocalDescriptionSuccess(rv);
+ }
+
+ UpdateSignalingState(sdpType == mozilla::kJsepSdpRollback);
+ return NS_OK;
+}
+
+static void DeferredSetRemote(const std::string& aPcHandle,
+ int32_t aAction,
+ const std::string& aSdp) {
+ PeerConnectionWrapper wrapper(aPcHandle);
+
+ if (wrapper.impl()) {
+ if (!PeerConnectionCtx::GetInstance()->isReady()) {
+ MOZ_CRASH("Why is DeferredSetRemote being executed when the "
+ "PeerConnectionCtx isn't ready?");
+ }
+ wrapper.impl()->SetRemoteDescription(aAction, aSdp.c_str());
+ }
+}
+
+static void StartTrack(MediaStream* aSource,
+ TrackID aTrackId,
+ nsAutoPtr<MediaSegment>&& aSegment) {
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ class Message : public ControlMessage {
+ public:
+ Message(MediaStream* aStream,
+ TrackID aTrack,
+ nsAutoPtr<MediaSegment>&& aSegment)
+ : ControlMessage(aStream),
+ track_id_(aTrack),
+ segment_(aSegment) {}
+
+ virtual void Run() override {
+ TrackRate track_rate = segment_->GetType() == MediaSegment::AUDIO ?
+ WEBRTC_DEFAULT_SAMPLE_RATE : mStream->GraphRate();
+ StreamTime current_end = mStream->GetTracksEnd();
+ TrackTicks current_ticks =
+ mStream->TimeToTicksRoundUp(track_rate, current_end);
+
+ // Add a track 'now' to avoid possible underrun, especially if we add
+ // a track "later".
+
+ if (current_end != 0L) {
+ CSFLogDebug(logTag, "added track @ %u -> %f",
+ static_cast<unsigned>(current_end),
+ mStream->StreamTimeToSeconds(current_end));
+ }
+
+ // To avoid assertions, we need to insert a dummy segment that covers up
+ // to the "start" time for the track
+ segment_->AppendNullData(current_ticks);
+ if (segment_->GetType() == MediaSegment::AUDIO) {
+ mStream->AsSourceStream()->AddAudioTrack(
+ track_id_,
+ WEBRTC_DEFAULT_SAMPLE_RATE,
+ 0,
+ static_cast<AudioSegment*>(segment_.forget()));
+ } else {
+ mStream->AsSourceStream()->AddTrack(track_id_, 0, segment_.forget());
+ }
+ }
+ private:
+ TrackID track_id_;
+ nsAutoPtr<MediaSegment> segment_;
+ };
+
+ aSource->GraphImpl()->AppendMessage(
+ MakeUnique<Message>(aSource, aTrackId, Move(aSegment)));
+ CSFLogInfo(logTag, "Dispatched track-add for track id %u on stream %p",
+ aTrackId, aSource);
+#endif
+}
+
+
+nsresult
+PeerConnectionImpl::CreateNewRemoteTracks(RefPtr<PeerConnectionObserver>& aPco)
+{
+ JSErrorResult jrv;
+
+ std::vector<RefPtr<JsepTrack>> newTracks =
+ mJsepSession->GetRemoteTracksAdded();
+
+ // Group new tracks by stream id
+ std::map<std::string, std::vector<RefPtr<JsepTrack>>> tracksByStreamId;
+ for (auto i = newTracks.begin(); i != newTracks.end(); ++i) {
+ RefPtr<JsepTrack> track = *i;
+
+ if (track->GetMediaType() == mozilla::SdpMediaSection::kApplication) {
+ // Ignore datachannel
+ continue;
+ }
+
+ tracksByStreamId[track->GetStreamId()].push_back(track);
+ }
+
+ for (auto i = tracksByStreamId.begin(); i != tracksByStreamId.end(); ++i) {
+ std::string streamId = i->first;
+ std::vector<RefPtr<JsepTrack>>& tracks = i->second;
+
+ bool newStream = false;
+ RefPtr<RemoteSourceStreamInfo> info =
+ mMedia->GetRemoteStreamById(streamId);
+ if (!info) {
+ newStream = true;
+ nsresult nrv = CreateRemoteSourceStreamInfo(&info, streamId);
+ if (NS_FAILED(nrv)) {
+ aPco->OnSetRemoteDescriptionError(
+ kInternalError,
+ ObString("CreateRemoteSourceStreamInfo failed"),
+ jrv);
+ return nrv;
+ }
+
+ nrv = mMedia->AddRemoteStream(info);
+ if (NS_FAILED(nrv)) {
+ aPco->OnSetRemoteDescriptionError(
+ kInternalError,
+ ObString("AddRemoteStream failed"),
+ jrv);
+ return nrv;
+ }
+
+ CSFLogDebug(logTag, "Added remote stream %s", info->GetId().c_str());
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ info->GetMediaStream()->AssignId(NS_ConvertUTF8toUTF16(streamId.c_str()));
+ info->GetMediaStream()->SetLogicalStreamStartTime(
+ info->GetMediaStream()->GetPlaybackStream()->GetCurrentTime());
+#else
+ info->GetMediaStream()->AssignId((streamId));
+#endif
+ }
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ Sequence<OwningNonNull<DOMMediaStream>> streams;
+ if (!streams.AppendElement(OwningNonNull<DOMMediaStream>(
+ *info->GetMediaStream()),
+ fallible)) {
+ MOZ_ASSERT(false);
+ return NS_ERROR_FAILURE;
+ }
+
+ // Set the principal used for creating the tracks. This makes the stream
+ // data (audio/video samples) accessible to the receiving page. We're
+ // only certain that privacy hasn't been requested if we're connected.
+ nsCOMPtr<nsIPrincipal> principal;
+ nsIDocument* doc = GetWindow()->GetExtantDoc();
+ MOZ_ASSERT(doc);
+ if (mDtlsConnected && !PrivacyRequested()) {
+ principal = doc->NodePrincipal();
+ } else {
+ // we're either certain that we need isolation for the streams, OR
+ // we're not sure and we can fix the stream in SetDtlsConnected
+ principal = nsNullPrincipal::CreateWithInheritedAttributes(doc->NodePrincipal());
+ }
+#endif
+
+ // We need to select unique ids, just use max + 1
+ TrackID maxTrackId = 0;
+ {
+ nsTArray<RefPtr<dom::MediaStreamTrack>> domTracks;
+ info->GetMediaStream()->GetTracks(domTracks);
+ for (auto& track : domTracks) {
+ maxTrackId = std::max(maxTrackId, track->mTrackID);
+ }
+ }
+
+ for (RefPtr<JsepTrack>& track : tracks) {
+ std::string webrtcTrackId(track->GetTrackId());
+ if (!info->HasTrack(webrtcTrackId)) {
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ RefPtr<RemoteTrackSource> source =
+ new RemoteTrackSource(principal, nsString());
+#else
+ RefPtr<MediaStreamTrackSource> source = new MediaStreamTrackSource();
+#endif
+ TrackID trackID = ++maxTrackId;
+ RefPtr<MediaStreamTrack> domTrack;
+ nsAutoPtr<MediaSegment> segment;
+ if (track->GetMediaType() == SdpMediaSection::kAudio) {
+ domTrack =
+ info->GetMediaStream()->CreateDOMTrack(trackID,
+ MediaSegment::AUDIO,
+ source);
+ info->GetMediaStream()->AddTrackInternal(domTrack);
+ segment = new AudioSegment;
+ } else {
+ domTrack =
+ info->GetMediaStream()->CreateDOMTrack(trackID,
+ MediaSegment::VIDEO,
+ source);
+ info->GetMediaStream()->AddTrackInternal(domTrack);
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ segment = new VideoSegment;
+#endif
+ }
+
+ StartTrack(info->GetMediaStream()->GetInputStream()->AsSourceStream(),
+ trackID, Move(segment));
+ info->AddTrack(webrtcTrackId, domTrack);
+ CSFLogDebug(logTag, "Added remote track %s/%s",
+ info->GetId().c_str(), webrtcTrackId.c_str());
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ domTrack->AssignId(NS_ConvertUTF8toUTF16(webrtcTrackId.c_str()));
+ aPco->OnAddTrack(*domTrack, streams, jrv);
+ if (jrv.Failed()) {
+ CSFLogError(logTag, ": OnAddTrack(%s) failed! Error: %u",
+ webrtcTrackId.c_str(),
+ jrv.ErrorCodeAsInt());
+ }
+#endif
+ }
+ }
+
+ if (newStream) {
+ aPco->OnAddStream(*info->GetMediaStream(), jrv);
+ if (jrv.Failed()) {
+ CSFLogError(logTag, ": OnAddStream() failed! Error: %u",
+ jrv.ErrorCodeAsInt());
+ }
+ }
+ }
+ return NS_OK;
+}
+
+void
+PeerConnectionImpl::RemoveOldRemoteTracks(RefPtr<PeerConnectionObserver>& aPco)
+{
+ JSErrorResult jrv;
+
+ std::vector<RefPtr<JsepTrack>> removedTracks =
+ mJsepSession->GetRemoteTracksRemoved();
+
+ for (auto i = removedTracks.begin(); i != removedTracks.end(); ++i) {
+ const std::string& streamId = (*i)->GetStreamId();
+ const std::string& trackId = (*i)->GetTrackId();
+
+ RefPtr<RemoteSourceStreamInfo> info = mMedia->GetRemoteStreamById(streamId);
+ if (!info) {
+ MOZ_ASSERT(false, "A stream/track was removed that wasn't in PCMedia. "
+ "This is a bug.");
+ continue;
+ }
+
+ mMedia->RemoveRemoteTrack(streamId, trackId);
+
+ DOMMediaStream* stream = info->GetMediaStream();
+ nsTArray<RefPtr<MediaStreamTrack>> tracks;
+ stream->GetTracks(tracks);
+ for (auto& track : tracks) {
+ if (PeerConnectionImpl::GetTrackId(*track) == trackId) {
+ aPco->OnRemoveTrack(*track, jrv);
+ break;
+ }
+ }
+
+ // We might be holding the last ref, but that's ok.
+ if (!info->GetTrackCount()) {
+ aPco->OnRemoveStream(*stream, jrv);
+ }
+ }
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::SetRemoteDescription(int32_t action, const char* aSDP)
+{
+ PC_AUTO_ENTER_API_CALL(true);
+
+ if (!aSDP) {
+ CSFLogError(logTag, "%s - aSDP is NULL", __FUNCTION__);
+ return NS_ERROR_FAILURE;
+ }
+
+ JSErrorResult jrv;
+ RefPtr<PeerConnectionObserver> pco = do_QueryObjectReferent(mPCObserver);
+ if (!pco) {
+ return NS_OK;
+ }
+
+ if (action == IPeerConnection::kActionOffer) {
+ if (!PeerConnectionCtx::GetInstance()->isReady()) {
+ // Uh oh. We're not ready yet. Enqueue this operation. (This must be a
+ // remote offer, or else we would not have gotten this far)
+ PeerConnectionCtx::GetInstance()->queueJSEPOperation(
+ WrapRunnableNM(DeferredSetRemote,
+ mHandle,
+ action,
+ std::string(aSDP)));
+ STAMP_TIMECARD(mTimeCard, "Deferring SetRemote (not ready)");
+ return NS_OK;
+ }
+
+ nsresult nrv = ConfigureJsepSessionCodecs();
+ if (NS_FAILED(nrv)) {
+ CSFLogError(logTag, "Failed to configure codecs");
+ return nrv;
+ }
+ }
+
+ STAMP_TIMECARD(mTimeCard, "Set Remote Description");
+
+ mRemoteRequestedSDP = aSDP;
+ JsepSdpType sdpType;
+ switch (action) {
+ case IPeerConnection::kActionOffer:
+ sdpType = mozilla::kJsepSdpOffer;
+ break;
+ case IPeerConnection::kActionAnswer:
+ sdpType = mozilla::kJsepSdpAnswer;
+ break;
+ case IPeerConnection::kActionPRAnswer:
+ sdpType = mozilla::kJsepSdpPranswer;
+ break;
+ case IPeerConnection::kActionRollback:
+ sdpType = mozilla::kJsepSdpRollback;
+ break;
+ default:
+ MOZ_ASSERT(false);
+ return NS_ERROR_FAILURE;
+ }
+
+ nsresult nrv = mJsepSession->SetRemoteDescription(sdpType,
+ mRemoteRequestedSDP);
+ if (NS_FAILED(nrv)) {
+ Error error;
+ switch (nrv) {
+ case NS_ERROR_INVALID_ARG:
+ error = kInvalidSessionDescription;
+ break;
+ case NS_ERROR_UNEXPECTED:
+ error = kInvalidState;
+ break;
+ default:
+ error = kInternalError;
+ }
+
+ std::string errorString = mJsepSession->GetLastError();
+ CSFLogError(logTag, "%s: pc = %s, error = %s",
+ __FUNCTION__, mHandle.c_str(), errorString.c_str());
+ pco->OnSetRemoteDescriptionError(error, ObString(errorString.c_str()), jrv);
+ } else {
+ nrv = CreateNewRemoteTracks(pco);
+ if (NS_FAILED(nrv)) {
+ // aPco was already notified, just return early.
+ return NS_OK;
+ }
+
+ RemoveOldRemoteTracks(pco);
+
+ pco->OnSetRemoteDescriptionSuccess(jrv);
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ startCallTelem();
+#endif
+ }
+
+ UpdateSignalingState(sdpType == mozilla::kJsepSdpRollback);
+ return NS_OK;
+}
+
+// WebRTC uses highres time relative to the UNIX epoch (Jan 1, 1970, UTC).
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+nsresult
+PeerConnectionImpl::GetTimeSinceEpoch(DOMHighResTimeStamp *result) {
+ MOZ_ASSERT(NS_IsMainThread());
+ Performance *perf = mWindow->GetPerformance();
+ NS_ENSURE_TRUE(perf && perf->Timing(), NS_ERROR_UNEXPECTED);
+ *result = perf->Now() + perf->Timing()->NavigationStart();
+ return NS_OK;
+}
+
+class RTCStatsReportInternalConstruct : public RTCStatsReportInternal {
+public:
+ RTCStatsReportInternalConstruct(const nsString &pcid, DOMHighResTimeStamp now) {
+ mPcid = pcid;
+ mInboundRTPStreamStats.Construct();
+ mOutboundRTPStreamStats.Construct();
+ mMediaStreamTrackStats.Construct();
+ mMediaStreamStats.Construct();
+ mTransportStats.Construct();
+ mIceComponentStats.Construct();
+ mIceCandidatePairStats.Construct();
+ mIceCandidateStats.Construct();
+ mCodecStats.Construct();
+ mTimestamp.Construct(now);
+ }
+};
+#endif
+
+NS_IMETHODIMP
+PeerConnectionImpl::GetStats(MediaStreamTrack *aSelector) {
+ PC_AUTO_ENTER_API_CALL(true);
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ if (!mMedia) {
+ // Since we zero this out before the d'tor, we should check.
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ nsAutoPtr<RTCStatsQuery> query(new RTCStatsQuery(false));
+
+ nsresult rv = BuildStatsQuery_m(aSelector, query.get());
+
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ RUN_ON_THREAD(mSTSThread,
+ WrapRunnableNM(&PeerConnectionImpl::GetStatsForPCObserver_s,
+ mHandle,
+ query),
+ NS_DISPATCH_NORMAL);
+#endif
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::AddIceCandidate(const char* aCandidate, const char* aMid, unsigned short aLevel) {
+ PC_AUTO_ENTER_API_CALL(true);
+
+ JSErrorResult rv;
+ RefPtr<PeerConnectionObserver> pco = do_QueryObjectReferent(mPCObserver);
+ if (!pco) {
+ return NS_OK;
+ }
+
+ STAMP_TIMECARD(mTimeCard, "Add Ice Candidate");
+
+ CSFLogDebug(logTag, "AddIceCandidate: %s", aCandidate);
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ // When remote candidates are added before our ICE ctx is up and running
+ // (the transition to New is async through STS, so this is not impossible),
+ // we won't record them as trickle candidates. Is this what we want?
+ if(!mIceStartTime.IsNull()) {
+ TimeDuration timeDelta = TimeStamp::Now() - mIceStartTime;
+ if (mIceConnectionState == PCImplIceConnectionState::Failed) {
+ Telemetry::Accumulate(Telemetry::WEBRTC_ICE_LATE_TRICKLE_ARRIVAL_TIME,
+ timeDelta.ToMilliseconds());
+ } else {
+ Telemetry::Accumulate(Telemetry::WEBRTC_ICE_ON_TIME_TRICKLE_ARRIVAL_TIME,
+ timeDelta.ToMilliseconds());
+ }
+ }
+#endif
+
+ nsresult res = mJsepSession->AddRemoteIceCandidate(aCandidate, aMid, aLevel);
+
+ if (NS_SUCCEEDED(res)) {
+ // We do not bother PCMedia about this before offer/answer concludes.
+ // Once offer/answer concludes, PCMedia will extract these candidates from
+ // the remote SDP.
+ if (mSignalingState == PCImplSignalingState::SignalingStable) {
+ mMedia->AddIceCandidate(aCandidate, aMid, aLevel);
+ }
+ pco->OnAddIceCandidateSuccess(rv);
+ } else {
+ ++mAddCandidateErrorCount;
+ Error error;
+ switch (res) {
+ case NS_ERROR_UNEXPECTED:
+ error = kInvalidState;
+ break;
+ case NS_ERROR_INVALID_ARG:
+ error = kInvalidCandidate;
+ break;
+ default:
+ error = kInternalError;
+ }
+
+ std::string errorString = mJsepSession->GetLastError();
+
+ CSFLogError(logTag, "Failed to incorporate remote candidate into SDP:"
+ " res = %u, candidate = %s, level = %u, error = %s",
+ static_cast<unsigned>(res),
+ aCandidate,
+ static_cast<unsigned>(aLevel),
+ errorString.c_str());
+
+ pco->OnAddIceCandidateError(error, ObString(errorString.c_str()), rv);
+ }
+
+ UpdateSignalingState();
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::CloseStreams() {
+ PC_AUTO_ENTER_API_CALL(false);
+
+ return NS_OK;
+}
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+nsresult
+PeerConnectionImpl::SetPeerIdentity(const nsAString& aPeerIdentity)
+{
+ PC_AUTO_ENTER_API_CALL(true);
+ MOZ_ASSERT(!aPeerIdentity.IsEmpty());
+
+ // once set, this can't be changed
+ if (mPeerIdentity) {
+ if (!mPeerIdentity->Equals(aPeerIdentity)) {
+ return NS_ERROR_FAILURE;
+ }
+ } else {
+ mPeerIdentity = new PeerIdentity(aPeerIdentity);
+ nsIDocument* doc = GetWindow()->GetExtantDoc();
+ if (!doc) {
+ CSFLogInfo(logTag, "Can't update principal on streams; document gone");
+ return NS_ERROR_FAILURE;
+ }
+ MediaStreamTrack* allTracks = nullptr;
+ mMedia->UpdateSinkIdentity_m(allTracks, doc->NodePrincipal(), mPeerIdentity);
+ }
+ return NS_OK;
+}
+#endif
+
+nsresult
+PeerConnectionImpl::SetDtlsConnected(bool aPrivacyRequested)
+{
+ PC_AUTO_ENTER_API_CALL(false);
+
+ // For this, as with mPrivacyRequested, once we've connected to a peer, we
+ // fixate on that peer. Dealing with multiple peers or connections is more
+ // than this run-down wreck of an object can handle.
+ // Besides, this is only used to say if we have been connected ever.
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ if (!mPrivacyRequested && !aPrivacyRequested && !mDtlsConnected) {
+ // now we know that privacy isn't needed for sure
+ nsIDocument* doc = GetWindow()->GetExtantDoc();
+ if (!doc) {
+ CSFLogInfo(logTag, "Can't update principal on streams; document gone");
+ return NS_ERROR_FAILURE;
+ }
+ mMedia->UpdateRemoteStreamPrincipals_m(doc->NodePrincipal());
+ }
+#endif
+ mDtlsConnected = true;
+ mPrivacyRequested = mPrivacyRequested || aPrivacyRequested;
+ return NS_OK;
+}
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+void
+PeerConnectionImpl::PrincipalChanged(MediaStreamTrack* aTrack) {
+ nsIDocument* doc = GetWindow()->GetExtantDoc();
+ if (doc) {
+ mMedia->UpdateSinkIdentity_m(aTrack, doc->NodePrincipal(), mPeerIdentity);
+ } else {
+ CSFLogInfo(logTag, "Can't update sink principal; document gone");
+ }
+}
+#endif
+
+std::string
+PeerConnectionImpl::GetTrackId(const MediaStreamTrack& aTrack)
+{
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ nsString wideTrackId;
+ aTrack.GetId(wideTrackId);
+ return NS_ConvertUTF16toUTF8(wideTrackId).get();
+#else
+ return aTrack.GetId();
+#endif
+}
+
+std::string
+PeerConnectionImpl::GetStreamId(const DOMMediaStream& aStream)
+{
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ nsString wideStreamId;
+ aStream.GetId(wideStreamId);
+ return NS_ConvertUTF16toUTF8(wideStreamId).get();
+#else
+ return aStream.GetId();
+#endif
+}
+
+void
+PeerConnectionImpl::OnMediaError(const std::string& aError)
+{
+ CSFLogError(logTag, "Encountered media error! %s", aError.c_str());
+ // TODO: Let content know about this somehow.
+}
+
+nsresult
+PeerConnectionImpl::AddTrack(MediaStreamTrack& aTrack,
+ const Sequence<OwningNonNull<DOMMediaStream>>& aStreams)
+{
+ PC_AUTO_ENTER_API_CALL(true);
+
+ if (!aStreams.Length()) {
+ CSFLogError(logTag, "%s: At least one stream arg required", __FUNCTION__);
+ return NS_ERROR_FAILURE;
+ }
+
+ return AddTrack(aTrack, aStreams[0]);
+}
+
+nsresult
+PeerConnectionImpl::AddTrack(MediaStreamTrack& aTrack,
+ DOMMediaStream& aMediaStream)
+{
+ std::string streamId = PeerConnectionImpl::GetStreamId(aMediaStream);
+ std::string trackId = PeerConnectionImpl::GetTrackId(aTrack);
+ nsresult res = mMedia->AddTrack(aMediaStream, streamId, aTrack, trackId);
+ if (NS_FAILED(res)) {
+ return res;
+ }
+
+ CSFLogDebug(logTag, "Added track (%s) to stream %s",
+ trackId.c_str(), streamId.c_str());
+
+ aTrack.AddPrincipalChangeObserver(this);
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ PrincipalChanged(&aTrack);
+#endif
+
+ if (aTrack.AsAudioStreamTrack()) {
+ res = AddTrackToJsepSession(SdpMediaSection::kAudio, streamId, trackId);
+ if (NS_FAILED(res)) {
+ return res;
+ }
+ mNumAudioStreams++;
+ }
+
+ if (aTrack.AsVideoStreamTrack()) {
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ if (!Preferences::GetBool("media.peerconnection.video.enabled", true)) {
+ // Before this code was moved, this would silently ignore just like it
+ // does now. Is this actually what we want to do?
+ return NS_OK;
+ }
+#endif
+
+ res = AddTrackToJsepSession(SdpMediaSection::kVideo, streamId, trackId);
+ if (NS_FAILED(res)) {
+ return res;
+ }
+ mNumVideoStreams++;
+ }
+ OnNegotiationNeeded();
+ return NS_OK;
+}
+
+nsresult
+PeerConnectionImpl::SelectSsrc(MediaStreamTrack& aRecvTrack,
+ unsigned short aSsrcIndex)
+{
+ for (size_t i = 0; i < mMedia->RemoteStreamsLength(); ++i) {
+ if (mMedia->GetRemoteStreamByIndex(i)->GetMediaStream()->
+ HasTrack(aRecvTrack)) {
+ auto& pipelines = mMedia->GetRemoteStreamByIndex(i)->GetPipelines();
+ std::string trackId = PeerConnectionImpl::GetTrackId(aRecvTrack);
+ auto it = pipelines.find(trackId);
+ if (it != pipelines.end()) {
+ it->second->SelectSsrc_m(aSsrcIndex);
+ }
+ }
+ }
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::RemoveTrack(MediaStreamTrack& aTrack) {
+ PC_AUTO_ENTER_API_CALL(true);
+
+ std::string trackId = PeerConnectionImpl::GetTrackId(aTrack);
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ nsString wideTrackId;
+ aTrack.GetId(wideTrackId);
+ for (size_t i = 0; i < mDTMFStates.Length(); ++i) {
+ if (mDTMFStates[i]->mTrackId == wideTrackId) {
+ mDTMFStates[i]->mSendTimer->Cancel();
+ mDTMFStates.RemoveElementAt(i);
+ break;
+ }
+ }
+#endif
+
+ RefPtr<LocalSourceStreamInfo> info = media()->GetLocalStreamByTrackId(trackId);
+
+ if (!info) {
+ CSFLogError(logTag, "%s: Unknown stream", __FUNCTION__);
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ nsresult rv =
+ mJsepSession->RemoveTrack(info->GetId(), trackId);
+
+ if (NS_FAILED(rv)) {
+ CSFLogError(logTag, "%s: Unknown stream/track ids %s %s",
+ __FUNCTION__,
+ info->GetId().c_str(),
+ trackId.c_str());
+ return rv;
+ }
+
+ media()->RemoveLocalTrack(info->GetId(), trackId);
+
+ aTrack.RemovePrincipalChangeObserver(this);
+
+ OnNegotiationNeeded();
+
+ return NS_OK;
+}
+
+static int GetDTMFToneCode(uint16_t c)
+{
+ const char* DTMF_TONECODES = "0123456789*#ABCD";
+
+ if (c == ',') {
+ // , is a special character indicating a 2 second delay
+ return -1;
+ }
+
+ const char* i = strchr(DTMF_TONECODES, c);
+ MOZ_ASSERT(i);
+ return i - DTMF_TONECODES;
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::InsertDTMF(mozilla::dom::RTCRtpSender& sender,
+ const nsAString& tones, uint32_t duration,
+ uint32_t interToneGap) {
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ PC_AUTO_ENTER_API_CALL(false);
+
+ // Check values passed in from PeerConnection.js
+ MOZ_ASSERT(duration >= 40, "duration must be at least 40");
+ MOZ_ASSERT(duration <= 6000, "duration must be at most 6000");
+ MOZ_ASSERT(interToneGap >= 30, "interToneGap must be at least 30");
+
+ JSErrorResult jrv;
+
+ // Retrieve track
+ RefPtr<MediaStreamTrack> mst = sender.GetTrack(jrv);
+ if (jrv.Failed()) {
+ NS_WARNING("Failed to retrieve track for RTCRtpSender!");
+ return jrv.StealNSResult();
+ }
+
+ nsString senderTrackId;
+ mst->GetId(senderTrackId);
+
+ // Attempt to locate state for the DTMFSender
+ RefPtr<DTMFState> state;
+ for (auto& dtmfState : mDTMFStates) {
+ if (dtmfState->mTrackId == senderTrackId) {
+ state = dtmfState;
+ break;
+ }
+ }
+
+ // No state yet, create a new one
+ if (!state) {
+ state = *mDTMFStates.AppendElement(new DTMFState);
+ state->mPeerConnectionImpl = this;
+ state->mTrackId = senderTrackId;
+ state->mSendTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
+ MOZ_ASSERT(state->mSendTimer);
+ }
+ MOZ_ASSERT(state);
+
+ auto trackPairs = mJsepSession->GetNegotiatedTrackPairs();
+ state->mLevel = -1;
+ for (auto& trackPair : trackPairs) {
+ if (state->mTrackId.EqualsASCII(trackPair.mSending->GetTrackId().c_str())) {
+ if (trackPair.mBundleLevel.isSome()) {
+ state->mLevel = *trackPair.mBundleLevel;
+ } else {
+ state->mLevel = trackPair.mLevel;
+ }
+ break;
+ }
+ }
+
+ state->mTones = tones;
+ state->mDuration = duration;
+ state->mInterToneGap = interToneGap;
+ if (!state->mTones.IsEmpty()) {
+ state->mSendTimer->InitWithCallback(state, 0, nsITimer::TYPE_ONE_SHOT);
+ }
+#endif
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::GetDTMFToneBuffer(mozilla::dom::RTCRtpSender& sender,
+ nsAString& outToneBuffer) {
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ PC_AUTO_ENTER_API_CALL(false);
+
+ JSErrorResult jrv;
+
+ // Retrieve track
+ RefPtr<MediaStreamTrack> mst = sender.GetTrack(jrv);
+ if (jrv.Failed()) {
+ NS_WARNING("Failed to retrieve track for RTCRtpSender!");
+ return jrv.StealNSResult();
+ }
+
+ nsString senderTrackId;
+ mst->GetId(senderTrackId);
+
+ // Attempt to locate state for the DTMFSender
+ for (auto& dtmfState : mDTMFStates) {
+ if (dtmfState->mTrackId == senderTrackId) {
+ outToneBuffer = dtmfState->mTones;
+ break;
+ }
+ }
+#endif
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::ReplaceTrack(MediaStreamTrack& aThisTrack,
+ MediaStreamTrack& aWithTrack) {
+ PC_AUTO_ENTER_API_CALL(true);
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ nsString trackId;
+ aThisTrack.GetId(trackId);
+
+ for (size_t i = 0; i < mDTMFStates.Length(); ++i) {
+ if (mDTMFStates[i]->mTrackId == trackId) {
+ mDTMFStates[i]->mSendTimer->Cancel();
+ mDTMFStates.RemoveElementAt(i);
+ break;
+ }
+ }
+#endif
+
+ RefPtr<PeerConnectionObserver> pco = do_QueryObjectReferent(mPCObserver);
+ if (!pco) {
+ return NS_ERROR_UNEXPECTED;
+ }
+ JSErrorResult jrv;
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ if (&aThisTrack == &aWithTrack) {
+ pco->OnReplaceTrackSuccess(jrv);
+ if (jrv.Failed()) {
+ CSFLogError(logTag, "Error firing replaceTrack success callback");
+ return NS_ERROR_UNEXPECTED;
+ }
+ return NS_OK;
+ }
+
+ nsString thisKind;
+ aThisTrack.GetKind(thisKind);
+ nsString withKind;
+ aWithTrack.GetKind(withKind);
+
+ if (thisKind != withKind) {
+ pco->OnReplaceTrackError(kIncompatibleMediaStreamTrack,
+ ObString(mJsepSession->GetLastError().c_str()),
+ jrv);
+ if (jrv.Failed()) {
+ CSFLogError(logTag, "Error firing replaceTrack success callback");
+ return NS_ERROR_UNEXPECTED;
+ }
+ return NS_OK;
+ }
+#endif
+ std::string origTrackId = PeerConnectionImpl::GetTrackId(aThisTrack);
+ std::string newTrackId = PeerConnectionImpl::GetTrackId(aWithTrack);
+
+ RefPtr<LocalSourceStreamInfo> info =
+ media()->GetLocalStreamByTrackId(origTrackId);
+ if (!info) {
+ CSFLogError(logTag, "Could not find stream from trackId");
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ std::string origStreamId = info->GetId();
+ std::string newStreamId =
+ PeerConnectionImpl::GetStreamId(*aWithTrack.mOwningStream);
+
+ nsresult rv = mJsepSession->ReplaceTrack(origStreamId,
+ origTrackId,
+ newStreamId,
+ newTrackId);
+ if (NS_FAILED(rv)) {
+ pco->OnReplaceTrackError(kInvalidMediastreamTrack,
+ ObString(mJsepSession->GetLastError().c_str()),
+ jrv);
+ if (jrv.Failed()) {
+ CSFLogError(logTag, "Error firing replaceTrack error callback");
+ return NS_ERROR_UNEXPECTED;
+ }
+ return NS_OK;
+ }
+
+ rv = media()->ReplaceTrack(origStreamId,
+ origTrackId,
+ aWithTrack,
+ newStreamId,
+ newTrackId);
+
+ if (NS_FAILED(rv)) {
+ CSFLogError(logTag, "Unexpected error in ReplaceTrack: %d",
+ static_cast<int>(rv));
+ pco->OnReplaceTrackError(kInvalidMediastreamTrack,
+ ObString("Failed to replace track"),
+ jrv);
+ if (jrv.Failed()) {
+ CSFLogError(logTag, "Error firing replaceTrack error callback");
+ return NS_ERROR_UNEXPECTED;
+ }
+ return NS_OK;
+ }
+ aThisTrack.RemovePrincipalChangeObserver(this);
+ aWithTrack.AddPrincipalChangeObserver(this);
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ PrincipalChanged(&aWithTrack);
+#endif
+
+ // We update the media pipelines here so we can apply different codec
+ // settings for different sources (e.g. screensharing as opposed to camera.)
+ // TODO: We should probably only do this if the source has in fact changed.
+ mMedia->UpdateMediaPipelines(*mJsepSession);
+
+ pco->OnReplaceTrackSuccess(jrv);
+ if (jrv.Failed()) {
+ CSFLogError(logTag, "Error firing replaceTrack success callback");
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ return NS_OK;
+}
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+NS_IMETHODIMP
+PeerConnectionImpl::SetParameters(MediaStreamTrack& aTrack,
+ const RTCRtpParameters& aParameters) {
+ PC_AUTO_ENTER_API_CALL(true);
+
+ std::vector<JsepTrack::JsConstraints> constraints;
+ if (aParameters.mEncodings.WasPassed()) {
+ for (auto& encoding : aParameters.mEncodings.Value()) {
+ JsepTrack::JsConstraints constraint;
+ if (encoding.mRid.WasPassed()) {
+ constraint.rid = NS_ConvertUTF16toUTF8(encoding.mRid.Value()).get();
+ }
+ if (encoding.mMaxBitrate.WasPassed()) {
+ constraint.constraints.maxBr = encoding.mMaxBitrate.Value();
+ }
+ constraint.constraints.scaleDownBy = encoding.mScaleResolutionDownBy;
+ constraints.push_back(constraint);
+ }
+ }
+ return SetParameters(aTrack, constraints);
+}
+#endif
+
+nsresult
+PeerConnectionImpl::SetParameters(
+ MediaStreamTrack& aTrack,
+ const std::vector<JsepTrack::JsConstraints>& aConstraints)
+{
+ std::string trackId = PeerConnectionImpl::GetTrackId(aTrack);
+ RefPtr<LocalSourceStreamInfo> info = media()->GetLocalStreamByTrackId(trackId);
+ if (!info) {
+ CSFLogError(logTag, "%s: Unknown stream", __FUNCTION__);
+ return NS_ERROR_INVALID_ARG;
+ }
+ std::string streamId = info->GetId();
+
+ return mJsepSession->SetParameters(streamId, trackId, aConstraints);
+}
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+NS_IMETHODIMP
+PeerConnectionImpl::GetParameters(MediaStreamTrack& aTrack,
+ RTCRtpParameters& aOutParameters) {
+ PC_AUTO_ENTER_API_CALL(true);
+
+ std::vector<JsepTrack::JsConstraints> constraints;
+ nsresult rv = GetParameters(aTrack, &constraints);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ aOutParameters.mEncodings.Construct();
+ for (auto& constraint : constraints) {
+ RTCRtpEncodingParameters encoding;
+ encoding.mRid.Construct(NS_ConvertASCIItoUTF16(constraint.rid.c_str()));
+ encoding.mMaxBitrate.Construct(constraint.constraints.maxBr);
+ encoding.mScaleResolutionDownBy = constraint.constraints.scaleDownBy;
+ aOutParameters.mEncodings.Value().AppendElement(Move(encoding), fallible);
+ }
+ return NS_OK;
+}
+#endif
+
+nsresult
+PeerConnectionImpl::GetParameters(
+ MediaStreamTrack& aTrack,
+ std::vector<JsepTrack::JsConstraints>* aOutConstraints)
+{
+ std::string trackId = PeerConnectionImpl::GetTrackId(aTrack);
+ RefPtr<LocalSourceStreamInfo> info = media()->GetLocalStreamByTrackId(trackId);
+ if (!info) {
+ CSFLogError(logTag, "%s: Unknown stream", __FUNCTION__);
+ return NS_ERROR_INVALID_ARG;
+ }
+ std::string streamId = info->GetId();
+
+ return mJsepSession->GetParameters(streamId, trackId, aOutConstraints);
+}
+
+nsresult
+PeerConnectionImpl::CalculateFingerprint(
+ const std::string& algorithm,
+ std::vector<uint8_t>* fingerprint) const {
+ uint8_t buf[DtlsIdentity::HASH_ALGORITHM_MAX_LENGTH];
+ size_t len = 0;
+
+ MOZ_ASSERT(fingerprint);
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ const UniqueCERTCertificate& cert = mCertificate->Certificate();
+#else
+ const UniqueCERTCertificate& cert = mIdentity->cert();
+#endif
+ nsresult rv = DtlsIdentity::ComputeFingerprint(cert, algorithm,
+ &buf[0], sizeof(buf),
+ &len);
+ if (NS_FAILED(rv)) {
+ CSFLogError(logTag, "Unable to calculate certificate fingerprint, rv=%u",
+ static_cast<unsigned>(rv));
+ return rv;
+ }
+ MOZ_ASSERT(len > 0 && len <= DtlsIdentity::HASH_ALGORITHM_MAX_LENGTH);
+ fingerprint->assign(buf, buf + len);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::GetFingerprint(char** fingerprint)
+{
+ MOZ_ASSERT(fingerprint);
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ MOZ_ASSERT(mCertificate);
+#endif
+ std::vector<uint8_t> fp;
+ nsresult rv = CalculateFingerprint(DtlsIdentity::DEFAULT_HASH_ALGORITHM, &fp);
+ NS_ENSURE_SUCCESS(rv, rv);
+ std::ostringstream os;
+ os << DtlsIdentity::DEFAULT_HASH_ALGORITHM << ' '
+ << SdpFingerprintAttributeList::FormatFingerprint(fp);
+ std::string fpStr = os.str();
+
+ char* tmp = new char[fpStr.size() + 1];
+ std::copy(fpStr.begin(), fpStr.end(), tmp);
+ tmp[fpStr.size()] = '\0';
+
+ *fingerprint = tmp;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::GetLocalDescription(char** aSDP)
+{
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ MOZ_ASSERT(aSDP);
+ std::string localSdp = mJsepSession->GetLocalDescription();
+
+ char* tmp = new char[localSdp.size() + 1];
+ std::copy(localSdp.begin(), localSdp.end(), tmp);
+ tmp[localSdp.size()] = '\0';
+
+ *aSDP = tmp;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::GetRemoteDescription(char** aSDP)
+{
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ MOZ_ASSERT(aSDP);
+ std::string remoteSdp = mJsepSession->GetRemoteDescription();
+
+ char* tmp = new char[remoteSdp.size() + 1];
+ std::copy(remoteSdp.begin(), remoteSdp.end(), tmp);
+ tmp[remoteSdp.size()] = '\0';
+
+ *aSDP = tmp;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::SignalingState(PCImplSignalingState* aState)
+{
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ MOZ_ASSERT(aState);
+
+ *aState = mSignalingState;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::IceConnectionState(PCImplIceConnectionState* aState)
+{
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ MOZ_ASSERT(aState);
+
+ *aState = mIceConnectionState;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::IceGatheringState(PCImplIceGatheringState* aState)
+{
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ MOZ_ASSERT(aState);
+
+ *aState = mIceGatheringState;
+ return NS_OK;
+}
+
+nsresult
+PeerConnectionImpl::CheckApiState(bool assert_ice_ready) const
+{
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ MOZ_ASSERT(mTrickle || !assert_ice_ready ||
+ (mIceGatheringState == PCImplIceGatheringState::Complete));
+
+ if (IsClosed()) {
+ CSFLogError(logTag, "%s: called API while closed", __FUNCTION__);
+ return NS_ERROR_FAILURE;
+ }
+ if (!mMedia) {
+ CSFLogError(logTag, "%s: called API with disposed mMedia", __FUNCTION__);
+ return NS_ERROR_FAILURE;
+ }
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::Close()
+{
+ CSFLogDebug(logTag, "%s: for %s", __FUNCTION__, mHandle.c_str());
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+
+ SetSignalingState_m(PCImplSignalingState::SignalingClosed);
+
+ return NS_OK;
+}
+
+bool
+PeerConnectionImpl::PluginCrash(uint32_t aPluginID,
+ const nsAString& aPluginName)
+{
+ // fire an event to the DOM window if this is "ours"
+ bool result = mMedia ? mMedia->AnyCodecHasPluginID(aPluginID) : false;
+ if (!result) {
+ return false;
+ }
+
+ CSFLogError(logTag, "%s: Our plugin %llu crashed", __FUNCTION__, static_cast<unsigned long long>(aPluginID));
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ nsCOMPtr<nsIDocument> doc = mWindow->GetExtantDoc();
+ if (!doc) {
+ NS_WARNING("Couldn't get document for PluginCrashed event!");
+ return true;
+ }
+
+ PluginCrashedEventInit init;
+ init.mPluginID = aPluginID;
+ init.mPluginName = aPluginName;
+ init.mSubmittedCrashReport = false;
+ init.mGmpPlugin = true;
+ init.mBubbles = true;
+ init.mCancelable = true;
+
+ RefPtr<PluginCrashedEvent> event =
+ PluginCrashedEvent::Constructor(doc, NS_LITERAL_STRING("PluginCrashed"), init);
+
+ event->SetTrusted(true);
+ event->WidgetEventPtr()->mFlags.mOnlyChromeDispatch = true;
+
+ EventDispatcher::DispatchDOMEvent(mWindow, nullptr, event, nullptr, nullptr);
+#endif
+
+ return true;
+}
+
+void
+PeerConnectionImpl::RecordEndOfCallTelemetry() const
+{
+ if (!mJsepSession) {
+ return;
+ }
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ // Bitmask used for WEBRTC/LOOP_CALL_TYPE telemetry reporting
+ static const uint32_t kAudioTypeMask = 1;
+ static const uint32_t kVideoTypeMask = 2;
+ static const uint32_t kDataChannelTypeMask = 4;
+
+ // Report end-of-call Telemetry
+ if (mJsepSession->GetNegotiations() > 0) {
+ Telemetry::Accumulate(Telemetry::WEBRTC_RENEGOTIATIONS,
+ mJsepSession->GetNegotiations()-1);
+ }
+ Telemetry::Accumulate(Telemetry::WEBRTC_MAX_VIDEO_SEND_TRACK,
+ mMaxSending[SdpMediaSection::MediaType::kVideo]);
+ Telemetry::Accumulate(Telemetry::WEBRTC_MAX_VIDEO_RECEIVE_TRACK,
+ mMaxReceiving[SdpMediaSection::MediaType::kVideo]);
+ Telemetry::Accumulate(Telemetry::WEBRTC_MAX_AUDIO_SEND_TRACK,
+ mMaxSending[SdpMediaSection::MediaType::kAudio]);
+ Telemetry::Accumulate(Telemetry::WEBRTC_MAX_AUDIO_RECEIVE_TRACK,
+ mMaxReceiving[SdpMediaSection::MediaType::kAudio]);
+ // DataChannels appear in both Sending and Receiving
+ Telemetry::Accumulate(Telemetry::WEBRTC_DATACHANNEL_NEGOTIATED,
+ mMaxSending[SdpMediaSection::MediaType::kApplication]);
+ // Enumerated/bitmask: 1 = Audio, 2 = Video, 4 = DataChannel
+ // A/V = 3, A/V/D = 7, etc
+ uint32_t type = 0;
+ if (mMaxSending[SdpMediaSection::MediaType::kAudio] ||
+ mMaxReceiving[SdpMediaSection::MediaType::kAudio]) {
+ type = kAudioTypeMask;
+ }
+ if (mMaxSending[SdpMediaSection::MediaType::kVideo] ||
+ mMaxReceiving[SdpMediaSection::MediaType::kVideo]) {
+ type |= kVideoTypeMask;
+ }
+ if (mMaxSending[SdpMediaSection::MediaType::kApplication]) {
+ type |= kDataChannelTypeMask;
+ }
+ Telemetry::Accumulate(Telemetry::WEBRTC_CALL_TYPE,
+ type);
+#endif
+}
+
+nsresult
+PeerConnectionImpl::CloseInt()
+{
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+
+ for (auto& dtmfState : mDTMFStates) {
+ dtmfState->mSendTimer->Cancel();
+ }
+
+ // We do this at the end of the call because we want to make sure we've waited
+ // for all trickle ICE candidates to come in; this can happen well after we've
+ // transitioned to connected. As a bonus, this allows us to detect race
+ // conditions where a stats dispatch happens right as the PC closes.
+ if (!mPrivateWindow) {
+ RecordLongtermICEStatistics();
+ }
+ RecordEndOfCallTelemetry();
+ CSFLogInfo(logTag, "%s: Closing PeerConnectionImpl %s; "
+ "ending call", __FUNCTION__, mHandle.c_str());
+ if (mJsepSession) {
+ mJsepSession->Close();
+ }
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ if (mDataConnection) {
+ CSFLogInfo(logTag, "%s: Destroying DataChannelConnection %p for %s",
+ __FUNCTION__, (void *) mDataConnection.get(), mHandle.c_str());
+ mDataConnection->Destroy();
+ mDataConnection = nullptr; // it may not go away until the runnables are dead
+ }
+#endif
+ ShutdownMedia();
+
+ // DataConnection will need to stay alive until all threads/runnables exit
+
+ return NS_OK;
+}
+
+void
+PeerConnectionImpl::ShutdownMedia()
+{
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+
+ if (!mMedia)
+ return;
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ // before we destroy references to local tracks, detach from them
+ for(uint32_t i = 0; i < media()->LocalStreamsLength(); ++i) {
+ LocalSourceStreamInfo *info = media()->GetLocalStreamByIndex(i);
+ for (const auto& pair : info->GetMediaStreamTracks()) {
+ pair.second->RemovePrincipalChangeObserver(this);
+ }
+ }
+
+ // End of call to be recorded in Telemetry
+ if (!mStartTime.IsNull()){
+ TimeDuration timeDelta = TimeStamp::Now() - mStartTime;
+ Telemetry::Accumulate(Telemetry::WEBRTC_CALL_DURATION,
+ timeDelta.ToSeconds());
+ }
+#endif
+
+ // Forget the reference so that we can transfer it to
+ // SelfDestruct().
+ mMedia.forget().take()->SelfDestruct();
+}
+
+void
+PeerConnectionImpl::SetSignalingState_m(PCImplSignalingState aSignalingState,
+ bool rollback)
+{
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ if (mSignalingState == aSignalingState ||
+ mSignalingState == PCImplSignalingState::SignalingClosed) {
+ return;
+ }
+
+ if (aSignalingState == PCImplSignalingState::SignalingHaveLocalOffer ||
+ (aSignalingState == PCImplSignalingState::SignalingStable &&
+ mSignalingState == PCImplSignalingState::SignalingHaveRemoteOffer &&
+ !rollback)) {
+ mMedia->EnsureTransports(*mJsepSession);
+ }
+
+ mSignalingState = aSignalingState;
+
+ bool fireNegotiationNeeded = false;
+ if (mSignalingState == PCImplSignalingState::SignalingStable) {
+ if (mMedia->GetIceRestartState() ==
+ PeerConnectionMedia::ICE_RESTART_PROVISIONAL) {
+ if (rollback) {
+ RollbackIceRestart();
+ } else {
+ mMedia->CommitIceRestart();
+ }
+ }
+
+ // Either negotiation is done, or we've rolled back. In either case, we
+ // need to re-evaluate whether further negotiation is required.
+ mNegotiationNeeded = false;
+ // If we're rolling back a local offer, we might need to remove some
+ // transports, but nothing further needs to be done.
+ mMedia->ActivateOrRemoveTransports(*mJsepSession);
+ if (!rollback) {
+ mMedia->UpdateMediaPipelines(*mJsepSession);
+ InitializeDataChannel();
+ mMedia->StartIceChecks(*mJsepSession);
+ }
+
+ if (!mJsepSession->AllLocalTracksAreAssigned()) {
+ CSFLogInfo(logTag, "Not all local tracks were assigned to an "
+ "m-section, either because the offerer did not offer"
+ " to receive enough tracks, or because tracks were "
+ "added after CreateOffer/Answer, but before "
+ "offer/answer completed. This requires "
+ "renegotiation.");
+ fireNegotiationNeeded = true;
+ }
+
+ // Telemetry: record info on the current state of streams/renegotiations/etc
+ // Note: this code gets run on rollbacks as well!
+
+ // Update the max channels used with each direction for each type
+ uint16_t receiving[SdpMediaSection::kMediaTypes];
+ uint16_t sending[SdpMediaSection::kMediaTypes];
+ mJsepSession->CountTracks(receiving, sending);
+ for (size_t i = 0; i < SdpMediaSection::kMediaTypes; i++) {
+ if (mMaxReceiving[i] < receiving[i]) {
+ mMaxReceiving[i] = receiving[i];
+ }
+ if (mMaxSending[i] < sending[i]) {
+ mMaxSending[i] = sending[i];
+ }
+ }
+ }
+
+ if (mSignalingState == PCImplSignalingState::SignalingClosed) {
+ CloseInt();
+ }
+
+ RefPtr<PeerConnectionObserver> pco = do_QueryObjectReferent(mPCObserver);
+ if (!pco) {
+ return;
+ }
+ JSErrorResult rv;
+ pco->OnStateChange(PCObserverStateType::SignalingState, rv);
+
+ if (fireNegotiationNeeded) {
+ // We don't use MaybeFireNegotiationNeeded here, since content might have
+ // already cased a transition from stable.
+ OnNegotiationNeeded();
+ }
+}
+
+void
+PeerConnectionImpl::UpdateSignalingState(bool rollback) {
+ mozilla::JsepSignalingState state =
+ mJsepSession->GetState();
+
+ PCImplSignalingState newState;
+
+ switch(state) {
+ case kJsepStateStable:
+ newState = PCImplSignalingState::SignalingStable;
+ break;
+ case kJsepStateHaveLocalOffer:
+ newState = PCImplSignalingState::SignalingHaveLocalOffer;
+ break;
+ case kJsepStateHaveRemoteOffer:
+ newState = PCImplSignalingState::SignalingHaveRemoteOffer;
+ break;
+ case kJsepStateHaveLocalPranswer:
+ newState = PCImplSignalingState::SignalingHaveLocalPranswer;
+ break;
+ case kJsepStateHaveRemotePranswer:
+ newState = PCImplSignalingState::SignalingHaveRemotePranswer;
+ break;
+ case kJsepStateClosed:
+ newState = PCImplSignalingState::SignalingClosed;
+ break;
+ default:
+ MOZ_CRASH();
+ }
+
+ SetSignalingState_m(newState, rollback);
+}
+
+bool
+PeerConnectionImpl::IsClosed() const
+{
+ return mSignalingState == PCImplSignalingState::SignalingClosed;
+}
+
+bool
+PeerConnectionImpl::HasMedia() const
+{
+ return mMedia;
+}
+
+PeerConnectionWrapper::PeerConnectionWrapper(const std::string& handle)
+ : impl_(nullptr) {
+ if (PeerConnectionCtx::GetInstance()->mPeerConnections.find(handle) ==
+ PeerConnectionCtx::GetInstance()->mPeerConnections.end()) {
+ return;
+ }
+
+ PeerConnectionImpl *impl = PeerConnectionCtx::GetInstance()->mPeerConnections[handle];
+
+ if (!impl->media())
+ return;
+
+ impl_ = impl;
+}
+
+const std::string&
+PeerConnectionImpl::GetHandle()
+{
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ return mHandle;
+}
+
+const std::string&
+PeerConnectionImpl::GetName()
+{
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ return mName;
+}
+
+static mozilla::dom::PCImplIceConnectionState
+toDomIceConnectionState(NrIceCtx::ConnectionState state) {
+ switch (state) {
+ case NrIceCtx::ICE_CTX_INIT:
+ return PCImplIceConnectionState::New;
+ case NrIceCtx::ICE_CTX_CHECKING:
+ return PCImplIceConnectionState::Checking;
+ case NrIceCtx::ICE_CTX_CONNECTED:
+ return PCImplIceConnectionState::Connected;
+ case NrIceCtx::ICE_CTX_COMPLETED:
+ return PCImplIceConnectionState::Completed;
+ case NrIceCtx::ICE_CTX_FAILED:
+ return PCImplIceConnectionState::Failed;
+ case NrIceCtx::ICE_CTX_DISCONNECTED:
+ return PCImplIceConnectionState::Disconnected;
+ case NrIceCtx::ICE_CTX_CLOSED:
+ return PCImplIceConnectionState::Closed;
+ }
+ MOZ_CRASH();
+}
+
+static mozilla::dom::PCImplIceGatheringState
+toDomIceGatheringState(NrIceCtx::GatheringState state) {
+ switch (state) {
+ case NrIceCtx::ICE_CTX_GATHER_INIT:
+ return PCImplIceGatheringState::New;
+ case NrIceCtx::ICE_CTX_GATHER_STARTED:
+ return PCImplIceGatheringState::Gathering;
+ case NrIceCtx::ICE_CTX_GATHER_COMPLETE:
+ return PCImplIceGatheringState::Complete;
+ }
+ MOZ_CRASH();
+}
+
+void
+PeerConnectionImpl::CandidateReady(const std::string& candidate,
+ uint16_t level) {
+ PC_AUTO_ENTER_API_CALL_VOID_RETURN(false);
+
+ std::string mid;
+ bool skipped = false;
+ nsresult res = mJsepSession->AddLocalIceCandidate(candidate,
+ level,
+ &mid,
+ &skipped);
+
+ if (NS_FAILED(res)) {
+ std::string errorString = mJsepSession->GetLastError();
+
+ CSFLogError(logTag, "Failed to incorporate local candidate into SDP:"
+ " res = %u, candidate = %s, level = %u, error = %s",
+ static_cast<unsigned>(res),
+ candidate.c_str(),
+ static_cast<unsigned>(level),
+ errorString.c_str());
+ return;
+ }
+
+ if (skipped) {
+ CSFLogDebug(logTag, "Skipped adding local candidate %s (level %u) to SDP, "
+ "this typically happens because the m-section is "
+ "bundled, which means it doesn't make sense for it to "
+ "have its own transport-related attributes.",
+ candidate.c_str(),
+ static_cast<unsigned>(level));
+ return;
+ }
+
+ CSFLogDebug(logTag, "Passing local candidate to content: %s",
+ candidate.c_str());
+ SendLocalIceCandidateToContent(level, mid, candidate);
+
+ UpdateSignalingState();
+}
+
+static void
+SendLocalIceCandidateToContentImpl(nsWeakPtr weakPCObserver,
+ uint16_t level,
+ const std::string& mid,
+ const std::string& candidate) {
+ RefPtr<PeerConnectionObserver> pco = do_QueryObjectReferent(weakPCObserver);
+ if (!pco) {
+ return;
+ }
+
+ JSErrorResult rv;
+ pco->OnIceCandidate(level,
+ ObString(mid.c_str()),
+ ObString(candidate.c_str()),
+ rv);
+}
+
+void
+PeerConnectionImpl::SendLocalIceCandidateToContent(
+ uint16_t level,
+ const std::string& mid,
+ const std::string& candidate) {
+ // We dispatch this because OnSetLocalDescriptionSuccess does a setTimeout(0)
+ // to unwind the stack, but the event handlers don't. We need to ensure that
+ // the candidates do not skip ahead of the callback.
+ NS_DispatchToMainThread(
+ WrapRunnableNM(&SendLocalIceCandidateToContentImpl,
+ mPCObserver,
+ level,
+ mid,
+ candidate),
+ NS_DISPATCH_NORMAL);
+}
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+static bool isDone(PCImplIceConnectionState state) {
+ return state != PCImplIceConnectionState::Checking &&
+ state != PCImplIceConnectionState::New;
+}
+
+static bool isSucceeded(PCImplIceConnectionState state) {
+ return state == PCImplIceConnectionState::Connected ||
+ state == PCImplIceConnectionState::Completed;
+}
+
+static bool isFailed(PCImplIceConnectionState state) {
+ return state == PCImplIceConnectionState::Failed;
+}
+#endif
+
+void PeerConnectionImpl::IceConnectionStateChange(
+ NrIceCtx* ctx,
+ NrIceCtx::ConnectionState state) {
+ PC_AUTO_ENTER_API_CALL_VOID_RETURN(false);
+
+ CSFLogDebug(logTag, "%s", __FUNCTION__);
+
+ auto domState = toDomIceConnectionState(state);
+ if (domState == mIceConnectionState) {
+ // no work to be done since the states are the same.
+ // this can happen during ICE rollback situations.
+ return;
+ }
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ if (!isDone(mIceConnectionState) && isDone(domState)) {
+ // mIceStartTime can be null if going directly from New to Closed, in which
+ // case we don't count it as a success or a failure.
+ if (!mIceStartTime.IsNull()){
+ TimeDuration timeDelta = TimeStamp::Now() - mIceStartTime;
+ if (isSucceeded(domState)) {
+ Telemetry::Accumulate(Telemetry::WEBRTC_ICE_SUCCESS_TIME,
+ timeDelta.ToMilliseconds());
+ } else if (isFailed(domState)) {
+ Telemetry::Accumulate(Telemetry::WEBRTC_ICE_FAILURE_TIME,
+ timeDelta.ToMilliseconds());
+ }
+ }
+
+ if (isSucceeded(domState)) {
+ Telemetry::Accumulate(
+ Telemetry::WEBRTC_ICE_ADD_CANDIDATE_ERRORS_GIVEN_SUCCESS,
+ mAddCandidateErrorCount);
+ } else if (isFailed(domState)) {
+ Telemetry::Accumulate(
+ Telemetry::WEBRTC_ICE_ADD_CANDIDATE_ERRORS_GIVEN_FAILURE,
+ mAddCandidateErrorCount);
+ }
+ }
+#endif
+
+ mIceConnectionState = domState;
+
+ if (mIceConnectionState == PCImplIceConnectionState::Connected ||
+ mIceConnectionState == PCImplIceConnectionState::Completed ||
+ mIceConnectionState == PCImplIceConnectionState::Failed) {
+ if (mMedia->IsIceRestarting()) {
+ FinalizeIceRestart();
+ }
+ }
+
+ // Would be nice if we had a means of converting one of these dom enums
+ // to a string that wasn't almost as much text as this switch statement...
+ switch (mIceConnectionState) {
+ case PCImplIceConnectionState::New:
+ STAMP_TIMECARD(mTimeCard, "Ice state: new");
+ break;
+ case PCImplIceConnectionState::Checking:
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ // For telemetry
+ mIceStartTime = TimeStamp::Now();
+#endif
+ STAMP_TIMECARD(mTimeCard, "Ice state: checking");
+ break;
+ case PCImplIceConnectionState::Connected:
+ STAMP_TIMECARD(mTimeCard, "Ice state: connected");
+ break;
+ case PCImplIceConnectionState::Completed:
+ STAMP_TIMECARD(mTimeCard, "Ice state: completed");
+ break;
+ case PCImplIceConnectionState::Failed:
+ STAMP_TIMECARD(mTimeCard, "Ice state: failed");
+ break;
+ case PCImplIceConnectionState::Disconnected:
+ STAMP_TIMECARD(mTimeCard, "Ice state: disconnected");
+ break;
+ case PCImplIceConnectionState::Closed:
+ STAMP_TIMECARD(mTimeCard, "Ice state: closed");
+ break;
+ default:
+ MOZ_ASSERT_UNREACHABLE("Unexpected mIceConnectionState!");
+ }
+
+ RefPtr<PeerConnectionObserver> pco = do_QueryObjectReferent(mPCObserver);
+ if (!pco) {
+ return;
+ }
+ WrappableJSErrorResult rv;
+ RUN_ON_THREAD(mThread,
+ WrapRunnable(pco,
+ &PeerConnectionObserver::OnStateChange,
+ PCObserverStateType::IceConnectionState,
+ rv, static_cast<JSCompartment*>(nullptr)),
+ NS_DISPATCH_NORMAL);
+}
+
+void
+PeerConnectionImpl::IceGatheringStateChange(
+ NrIceCtx* ctx,
+ NrIceCtx::GatheringState state)
+{
+ PC_AUTO_ENTER_API_CALL_VOID_RETURN(false);
+
+ CSFLogDebug(logTag, "%s", __FUNCTION__);
+
+ mIceGatheringState = toDomIceGatheringState(state);
+
+ // Would be nice if we had a means of converting one of these dom enums
+ // to a string that wasn't almost as much text as this switch statement...
+ switch (mIceGatheringState) {
+ case PCImplIceGatheringState::New:
+ STAMP_TIMECARD(mTimeCard, "Ice gathering state: new");
+ break;
+ case PCImplIceGatheringState::Gathering:
+ STAMP_TIMECARD(mTimeCard, "Ice gathering state: gathering");
+ break;
+ case PCImplIceGatheringState::Complete:
+ STAMP_TIMECARD(mTimeCard, "Ice gathering state: complete");
+ break;
+ default:
+ MOZ_ASSERT_UNREACHABLE("Unexpected mIceGatheringState!");
+ }
+
+ RefPtr<PeerConnectionObserver> pco = do_QueryObjectReferent(mPCObserver);
+ if (!pco) {
+ return;
+ }
+ WrappableJSErrorResult rv;
+ mThread->Dispatch(WrapRunnable(pco,
+ &PeerConnectionObserver::OnStateChange,
+ PCObserverStateType::IceGatheringState,
+ rv, static_cast<JSCompartment*>(nullptr)),
+ NS_DISPATCH_NORMAL);
+
+ if (mIceGatheringState == PCImplIceGatheringState::Complete) {
+ SendLocalIceCandidateToContent(0, "", "");
+ }
+}
+
+void
+PeerConnectionImpl::UpdateDefaultCandidate(const std::string& defaultAddr,
+ uint16_t defaultPort,
+ const std::string& defaultRtcpAddr,
+ uint16_t defaultRtcpPort,
+ uint16_t level) {
+ CSFLogDebug(logTag, "%s", __FUNCTION__);
+ mJsepSession->UpdateDefaultCandidate(defaultAddr,
+ defaultPort,
+ defaultRtcpAddr,
+ defaultRtcpPort,
+ level);
+}
+
+void
+PeerConnectionImpl::EndOfLocalCandidates(uint16_t level) {
+ CSFLogDebug(logTag, "%s", __FUNCTION__);
+ mJsepSession->EndOfLocalCandidates(level);
+}
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+nsresult
+PeerConnectionImpl::BuildStatsQuery_m(
+ mozilla::dom::MediaStreamTrack *aSelector,
+ RTCStatsQuery *query) {
+
+ if (!HasMedia()) {
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ if (!mThread) {
+ CSFLogError(logTag, "Could not build stats query, no MainThread");
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ nsresult rv = GetTimeSinceEpoch(&(query->now));
+ if (NS_FAILED(rv)) {
+ CSFLogError(logTag, "Could not build stats query, could not get timestamp");
+ return rv;
+ }
+
+ // Note: mMedia->ice_ctx() is deleted on STS thread; so make sure we grab and hold
+ // a ref instead of making multiple calls. NrIceCtx uses threadsafe refcounting.
+ // NOTE: Do this after all other failure tests, to ensure we don't
+ // accidentally release the Ctx on Mainthread.
+ query->iceCtx = mMedia->ice_ctx();
+ if (!query->iceCtx) {
+ CSFLogError(logTag, "Could not build stats query, no ice_ctx");
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ // We do not use the pcHandle here, since that's risky to expose to content.
+ query->report = new RTCStatsReportInternalConstruct(
+ NS_ConvertASCIItoUTF16(mName.c_str()),
+ query->now);
+
+ query->iceStartTime = mIceStartTime;
+ query->failed = isFailed(mIceConnectionState);
+
+ // Populate SDP on main
+ if (query->internalStats) {
+ if (mJsepSession) {
+ std::string localDescription = mJsepSession->GetLocalDescription();
+ std::string remoteDescription = mJsepSession->GetRemoteDescription();
+ query->report->mLocalSdp.Construct(
+ NS_ConvertASCIItoUTF16(localDescription.c_str()));
+ query->report->mRemoteSdp.Construct(
+ NS_ConvertASCIItoUTF16(remoteDescription.c_str()));
+ }
+ }
+
+ // Gather up pipelines from mMedia so they may be inspected on STS
+
+ std::string trackId;
+ if (aSelector) {
+ trackId = PeerConnectionImpl::GetTrackId(*aSelector);
+ }
+
+ for (int i = 0, len = mMedia->LocalStreamsLength(); i < len; i++) {
+ for (auto pipeline : mMedia->GetLocalStreamByIndex(i)->GetPipelines()) {
+ if (!aSelector || pipeline.second->trackid() == trackId) {
+ query->pipelines.AppendElement(pipeline.second);
+ }
+ }
+ }
+ for (int i = 0, len = mMedia->RemoteStreamsLength(); i < len; i++) {
+ for (auto pipeline : mMedia->GetRemoteStreamByIndex(i)->GetPipelines()) {
+ if (!aSelector || pipeline.second->trackid() == trackId) {
+ query->pipelines.AppendElement(pipeline.second);
+ }
+ }
+ }
+
+ if (!aSelector) {
+ query->grabAllLevels = true;
+ }
+
+ return rv;
+}
+
+static void ToRTCIceCandidateStats(
+ const std::vector<NrIceCandidate>& candidates,
+ RTCStatsType candidateType,
+ const nsString& componentId,
+ DOMHighResTimeStamp now,
+ RTCStatsReportInternal* report) {
+
+ MOZ_ASSERT(report);
+ for (auto c = candidates.begin(); c != candidates.end(); ++c) {
+ RTCIceCandidateStats cand;
+ cand.mType.Construct(candidateType);
+ NS_ConvertASCIItoUTF16 codeword(c->codeword.c_str());
+ cand.mComponentId.Construct(componentId);
+ cand.mId.Construct(codeword);
+ cand.mTimestamp.Construct(now);
+ cand.mCandidateType.Construct(
+ RTCStatsIceCandidateType(c->type));
+ cand.mIpAddress.Construct(
+ NS_ConvertASCIItoUTF16(c->cand_addr.host.c_str()));
+ cand.mPortNumber.Construct(c->cand_addr.port);
+ cand.mTransport.Construct(
+ NS_ConvertASCIItoUTF16(c->cand_addr.transport.c_str()));
+ if (candidateType == RTCStatsType::Localcandidate) {
+ cand.mMozLocalTransport.Construct(
+ NS_ConvertASCIItoUTF16(c->local_addr.transport.c_str()));
+ }
+ report->mIceCandidateStats.Value().AppendElement(cand, fallible);
+ }
+}
+
+static void RecordIceStats_s(
+ NrIceMediaStream& mediaStream,
+ bool internalStats,
+ DOMHighResTimeStamp now,
+ RTCStatsReportInternal* report) {
+
+ NS_ConvertASCIItoUTF16 componentId(mediaStream.name().c_str());
+
+ std::vector<NrIceCandidatePair> candPairs;
+ nsresult res = mediaStream.GetCandidatePairs(&candPairs);
+ if (NS_FAILED(res)) {
+ CSFLogError(logTag, "%s: Error getting candidate pairs", __FUNCTION__);
+ return;
+ }
+
+ for (auto p = candPairs.begin(); p != candPairs.end(); ++p) {
+ NS_ConvertASCIItoUTF16 codeword(p->codeword.c_str());
+ NS_ConvertASCIItoUTF16 localCodeword(p->local.codeword.c_str());
+ NS_ConvertASCIItoUTF16 remoteCodeword(p->remote.codeword.c_str());
+ // Only expose candidate-pair statistics to chrome, until we've thought
+ // through the implications of exposing it to content.
+
+ RTCIceCandidatePairStats s;
+ s.mId.Construct(codeword);
+ s.mComponentId.Construct(componentId);
+ s.mTimestamp.Construct(now);
+ s.mType.Construct(RTCStatsType::Candidatepair);
+ s.mLocalCandidateId.Construct(localCodeword);
+ s.mRemoteCandidateId.Construct(remoteCodeword);
+ s.mNominated.Construct(p->nominated);
+ s.mPriority.Construct(p->priority);
+ s.mSelected.Construct(p->selected);
+ s.mState.Construct(RTCStatsIceCandidatePairState(p->state));
+ report->mIceCandidatePairStats.Value().AppendElement(s, fallible);
+ }
+
+ std::vector<NrIceCandidate> candidates;
+ if (NS_SUCCEEDED(mediaStream.GetLocalCandidates(&candidates))) {
+ ToRTCIceCandidateStats(candidates,
+ RTCStatsType::Localcandidate,
+ componentId,
+ now,
+ report);
+ }
+ candidates.clear();
+
+ if (NS_SUCCEEDED(mediaStream.GetRemoteCandidates(&candidates))) {
+ ToRTCIceCandidateStats(candidates,
+ RTCStatsType::Remotecandidate,
+ componentId,
+ now,
+ report);
+ }
+}
+
+nsresult
+PeerConnectionImpl::ExecuteStatsQuery_s(RTCStatsQuery *query) {
+
+ ASSERT_ON_THREAD(query->iceCtx->thread());
+
+ // Gather stats from pipelines provided (can't touch mMedia + stream on STS)
+
+ for (size_t p = 0; p < query->pipelines.Length(); ++p) {
+ const MediaPipeline& mp = *query->pipelines[p];
+ bool isAudio = (mp.Conduit()->type() == MediaSessionConduit::AUDIO);
+ nsString mediaType = isAudio ?
+ NS_LITERAL_STRING("audio") : NS_LITERAL_STRING("video");
+ nsString idstr = mediaType;
+ idstr.AppendLiteral("_");
+ idstr.AppendInt(mp.level());
+
+ // Gather pipeline stats.
+ switch (mp.direction()) {
+ case MediaPipeline::TRANSMIT: {
+ nsString localId = NS_LITERAL_STRING("outbound_rtp_") + idstr;
+ nsString remoteId;
+ nsString ssrc;
+ unsigned int ssrcval;
+ if (mp.Conduit()->GetLocalSSRC(&ssrcval)) {
+ ssrc.AppendInt(ssrcval);
+ }
+ {
+ // First, fill in remote stat with rtcp receiver data, if present.
+ // ReceiverReports have less information than SenderReports,
+ // so fill in what we can.
+ DOMHighResTimeStamp timestamp;
+ uint32_t jitterMs;
+ uint32_t packetsReceived;
+ uint64_t bytesReceived;
+ uint32_t packetsLost;
+ int32_t rtt;
+ if (mp.Conduit()->GetRTCPReceiverReport(&timestamp, &jitterMs,
+ &packetsReceived,
+ &bytesReceived,
+ &packetsLost,
+ &rtt)) {
+ remoteId = NS_LITERAL_STRING("outbound_rtcp_") + idstr;
+ RTCInboundRTPStreamStats s;
+ s.mTimestamp.Construct(timestamp);
+ s.mId.Construct(remoteId);
+ s.mType.Construct(RTCStatsType::Inboundrtp);
+ if (ssrc.Length()) {
+ s.mSsrc.Construct(ssrc);
+ }
+ s.mMediaType.Construct(mediaType);
+ s.mJitter.Construct(double(jitterMs)/1000);
+ s.mRemoteId.Construct(localId);
+ s.mIsRemote = true;
+ s.mPacketsReceived.Construct(packetsReceived);
+ s.mBytesReceived.Construct(bytesReceived);
+ s.mPacketsLost.Construct(packetsLost);
+ s.mMozRtt.Construct(rtt);
+ query->report->mInboundRTPStreamStats.Value().AppendElement(s,
+ fallible);
+ }
+ }
+ // Then, fill in local side (with cross-link to remote only if present)
+ {
+ RTCOutboundRTPStreamStats s;
+ s.mTimestamp.Construct(query->now);
+ s.mId.Construct(localId);
+ s.mType.Construct(RTCStatsType::Outboundrtp);
+ if (ssrc.Length()) {
+ s.mSsrc.Construct(ssrc);
+ }
+ s.mMediaType.Construct(mediaType);
+ s.mRemoteId.Construct(remoteId);
+ s.mIsRemote = false;
+ s.mPacketsSent.Construct(mp.rtp_packets_sent());
+ s.mBytesSent.Construct(mp.rtp_bytes_sent());
+
+ // Lastly, fill in video encoder stats if this is video
+ if (!isAudio) {
+ double framerateMean;
+ double framerateStdDev;
+ double bitrateMean;
+ double bitrateStdDev;
+ uint32_t droppedFrames;
+ if (mp.Conduit()->GetVideoEncoderStats(&framerateMean,
+ &framerateStdDev,
+ &bitrateMean,
+ &bitrateStdDev,
+ &droppedFrames)) {
+ s.mFramerateMean.Construct(framerateMean);
+ s.mFramerateStdDev.Construct(framerateStdDev);
+ s.mBitrateMean.Construct(bitrateMean);
+ s.mBitrateStdDev.Construct(bitrateStdDev);
+ s.mDroppedFrames.Construct(droppedFrames);
+ }
+ }
+ query->report->mOutboundRTPStreamStats.Value().AppendElement(s,
+ fallible);
+ }
+ break;
+ }
+ case MediaPipeline::RECEIVE: {
+ nsString localId = NS_LITERAL_STRING("inbound_rtp_") + idstr;
+ nsString remoteId;
+ nsString ssrc;
+ unsigned int ssrcval;
+ if (mp.Conduit()->GetRemoteSSRC(&ssrcval)) {
+ ssrc.AppendInt(ssrcval);
+ }
+ {
+ // First, fill in remote stat with rtcp sender data, if present.
+ DOMHighResTimeStamp timestamp;
+ uint32_t packetsSent;
+ uint64_t bytesSent;
+ if (mp.Conduit()->GetRTCPSenderReport(&timestamp,
+ &packetsSent, &bytesSent)) {
+ remoteId = NS_LITERAL_STRING("inbound_rtcp_") + idstr;
+ RTCOutboundRTPStreamStats s;
+ s.mTimestamp.Construct(timestamp);
+ s.mId.Construct(remoteId);
+ s.mType.Construct(RTCStatsType::Outboundrtp);
+ if (ssrc.Length()) {
+ s.mSsrc.Construct(ssrc);
+ }
+ s.mMediaType.Construct(mediaType);
+ s.mRemoteId.Construct(localId);
+ s.mIsRemote = true;
+ s.mPacketsSent.Construct(packetsSent);
+ s.mBytesSent.Construct(bytesSent);
+ query->report->mOutboundRTPStreamStats.Value().AppendElement(s,
+ fallible);
+ }
+ }
+ // Then, fill in local side (with cross-link to remote only if present)
+ RTCInboundRTPStreamStats s;
+ s.mTimestamp.Construct(query->now);
+ s.mId.Construct(localId);
+ s.mType.Construct(RTCStatsType::Inboundrtp);
+ if (ssrc.Length()) {
+ s.mSsrc.Construct(ssrc);
+ }
+ s.mMediaType.Construct(mediaType);
+ unsigned int jitterMs, packetsLost;
+ if (mp.Conduit()->GetRTPStats(&jitterMs, &packetsLost)) {
+ s.mJitter.Construct(double(jitterMs)/1000);
+ s.mPacketsLost.Construct(packetsLost);
+ }
+ if (remoteId.Length()) {
+ s.mRemoteId.Construct(remoteId);
+ }
+ s.mIsRemote = false;
+ s.mPacketsReceived.Construct(mp.rtp_packets_received());
+ s.mBytesReceived.Construct(mp.rtp_bytes_received());
+
+ if (query->internalStats && isAudio) {
+ int32_t jitterBufferDelay;
+ int32_t playoutBufferDelay;
+ int32_t avSyncDelta;
+ if (mp.Conduit()->GetAVStats(&jitterBufferDelay,
+ &playoutBufferDelay,
+ &avSyncDelta)) {
+ s.mMozJitterBufferDelay.Construct(jitterBufferDelay);
+ s.mMozAvSyncDelay.Construct(avSyncDelta);
+ }
+ }
+ // Lastly, fill in video decoder stats if this is video
+ if (!isAudio) {
+ double framerateMean;
+ double framerateStdDev;
+ double bitrateMean;
+ double bitrateStdDev;
+ uint32_t discardedPackets;
+ if (mp.Conduit()->GetVideoDecoderStats(&framerateMean,
+ &framerateStdDev,
+ &bitrateMean,
+ &bitrateStdDev,
+ &discardedPackets)) {
+ s.mFramerateMean.Construct(framerateMean);
+ s.mFramerateStdDev.Construct(framerateStdDev);
+ s.mBitrateMean.Construct(bitrateMean);
+ s.mBitrateStdDev.Construct(bitrateStdDev);
+ s.mDiscardedPackets.Construct(discardedPackets);
+ }
+ }
+ query->report->mInboundRTPStreamStats.Value().AppendElement(s,
+ fallible);
+ break;
+ }
+ }
+
+ if (!query->grabAllLevels) {
+ // If we're grabbing all levels, that means we want datachannels too,
+ // which don't have pipelines.
+ if (query->iceCtx->GetStream(p)) {
+ RecordIceStats_s(*query->iceCtx->GetStream(p),
+ query->internalStats,
+ query->now,
+ query->report);
+ }
+ }
+ }
+
+ if (query->grabAllLevels) {
+ for (size_t i = 0; i < query->iceCtx->GetStreamCount(); ++i) {
+ if (query->iceCtx->GetStream(i)) {
+ RecordIceStats_s(*query->iceCtx->GetStream(i),
+ query->internalStats,
+ query->now,
+ query->report);
+ }
+ }
+ }
+
+ // NrIceCtx must be destroyed on STS, so it is not safe
+ // to dispatch it back to main.
+ query->iceCtx = nullptr;
+ return NS_OK;
+}
+
+void PeerConnectionImpl::GetStatsForPCObserver_s(
+ const std::string& pcHandle, // The Runnable holds the memory
+ nsAutoPtr<RTCStatsQuery> query) {
+
+ MOZ_ASSERT(query);
+ MOZ_ASSERT(query->iceCtx);
+ ASSERT_ON_THREAD(query->iceCtx->thread());
+
+ nsresult rv = PeerConnectionImpl::ExecuteStatsQuery_s(query.get());
+
+ NS_DispatchToMainThread(
+ WrapRunnableNM(
+ &PeerConnectionImpl::DeliverStatsReportToPCObserver_m,
+ pcHandle,
+ rv,
+ query),
+ NS_DISPATCH_NORMAL);
+}
+
+void PeerConnectionImpl::DeliverStatsReportToPCObserver_m(
+ const std::string& pcHandle,
+ nsresult result,
+ nsAutoPtr<RTCStatsQuery> query) {
+
+ // Is the PeerConnectionImpl still around?
+ PeerConnectionWrapper pcw(pcHandle);
+ if (pcw.impl()) {
+ RefPtr<PeerConnectionObserver> pco =
+ do_QueryObjectReferent(pcw.impl()->mPCObserver);
+ if (pco) {
+ JSErrorResult rv;
+ if (NS_SUCCEEDED(result)) {
+ pco->OnGetStatsSuccess(*query->report, rv);
+ } else {
+ pco->OnGetStatsError(kInternalError,
+ ObString("Failed to fetch statistics"),
+ rv);
+ }
+
+ if (rv.Failed()) {
+ CSFLogError(logTag, "Error firing stats observer callback");
+ }
+ }
+ }
+}
+
+#endif
+
+void
+PeerConnectionImpl::RecordLongtermICEStatistics() {
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ WebrtcGlobalInformation::StoreLongTermICEStatistics(*this);
+#endif
+}
+
+void
+PeerConnectionImpl::OnNegotiationNeeded()
+{
+ if (mSignalingState != PCImplSignalingState::SignalingStable) {
+ // We will check whether we need to renegotiate when we reach stable again
+ return;
+ }
+
+ if (mNegotiationNeeded) {
+ return;
+ }
+
+ mNegotiationNeeded = true;
+
+ RUN_ON_THREAD(mThread,
+ WrapRunnableNM(&MaybeFireNegotiationNeeded_static, mHandle),
+ NS_DISPATCH_NORMAL);
+}
+
+/* static */
+void
+PeerConnectionImpl::MaybeFireNegotiationNeeded_static(
+ const std::string& pcHandle)
+{
+ PeerConnectionWrapper wrapper(pcHandle);
+ if (!wrapper.impl()) {
+ return;
+ }
+
+ wrapper.impl()->MaybeFireNegotiationNeeded();
+}
+
+void
+PeerConnectionImpl::MaybeFireNegotiationNeeded()
+{
+ if (!mNegotiationNeeded) {
+ return;
+ }
+
+ RefPtr<PeerConnectionObserver> pco = do_QueryObjectReferent(mPCObserver);
+ if (!pco) {
+ return;
+ }
+
+ JSErrorResult rv;
+ pco->OnNegotiationNeeded(rv);
+}
+
+void
+PeerConnectionImpl::IceStreamReady(NrIceMediaStream *aStream)
+{
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ MOZ_ASSERT(aStream);
+
+ CSFLogDebug(logTag, "%s: %s", __FUNCTION__, aStream->name().c_str());
+}
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+//Telemetry for when calls start
+void
+PeerConnectionImpl::startCallTelem() {
+ if (!mStartTime.IsNull()) {
+ return;
+ }
+
+ // Start time for calls
+ mStartTime = TimeStamp::Now();
+
+ // Increment session call counter
+ // If we want to track Loop calls independently here, we need two histograms.
+ Telemetry::Accumulate(Telemetry::WEBRTC_CALL_COUNT_2, 1);
+}
+#endif
+
+NS_IMETHODIMP
+PeerConnectionImpl::GetLocalStreams(nsTArray<RefPtr<DOMMediaStream > >& result)
+{
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ for(uint32_t i=0; i < media()->LocalStreamsLength(); i++) {
+ LocalSourceStreamInfo *info = media()->GetLocalStreamByIndex(i);
+ NS_ENSURE_TRUE(info, NS_ERROR_UNEXPECTED);
+ result.AppendElement(info->GetMediaStream());
+ }
+ return NS_OK;
+#else
+ return NS_ERROR_FAILURE;
+#endif
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::GetRemoteStreams(nsTArray<RefPtr<DOMMediaStream > >& result)
+{
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ for(uint32_t i=0; i < media()->RemoteStreamsLength(); i++) {
+ RemoteSourceStreamInfo *info = media()->GetRemoteStreamByIndex(i);
+ NS_ENSURE_TRUE(info, NS_ERROR_UNEXPECTED);
+ result.AppendElement(info->GetMediaStream());
+ }
+ return NS_OK;
+#else
+ return NS_ERROR_FAILURE;
+#endif
+}
+
+nsresult
+PeerConnectionImpl::DTMFState::Notify(nsITimer* timer)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+
+ nsString eventTone;
+ if (!mTones.IsEmpty()) {
+ uint16_t toneChar = mTones.CharAt(0);
+ int tone = GetDTMFToneCode(toneChar);
+
+ eventTone.Assign(toneChar);
+
+ mTones.Cut(0, 1);
+
+ if (tone == -1) {
+ mSendTimer->InitWithCallback(this, 2000, nsITimer::TYPE_ONE_SHOT);
+ } else {
+ // Reset delay if necessary
+ mSendTimer->InitWithCallback(this,
+ mDuration + mInterToneGap,
+ nsITimer::TYPE_ONE_SHOT);
+
+ RefPtr<AudioSessionConduit> conduit =
+ mPeerConnectionImpl->mMedia->GetAudioConduit(mLevel);
+
+ if (conduit) {
+ uint32_t duration = mDuration;
+ mPeerConnectionImpl->mSTSThread->Dispatch(WrapRunnableNM([conduit, tone, duration] () {
+ //Note: We default to channel 0, not inband, and 6dB attenuation.
+ // here. We might want to revisit these choices in the future.
+ conduit->InsertDTMFTone(0, tone, true, duration, 6);
+ }), NS_DISPATCH_NORMAL);
+ }
+ }
+ } else {
+ mSendTimer->Cancel();
+ }
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ RefPtr<PeerConnectionObserver> pco = do_QueryObjectReferent(mPeerConnectionImpl->mPCObserver);
+ if (!pco) {
+ NS_WARNING("Failed to dispatch the RTCDTMFToneChange event!");
+ return NS_OK; // Return is ignored anyhow
+ }
+
+ JSErrorResult jrv;
+ pco->OnDTMFToneChange(mTrackId, eventTone, jrv);
+
+ if (jrv.Failed()) {
+ NS_WARNING("Failed to dispatch the RTCDTMFToneChange event!");
+ }
+#endif
+
+ return NS_OK;
+}
+
+PeerConnectionImpl::DTMFState::DTMFState() = default;
+PeerConnectionImpl::DTMFState::~DTMFState() = default;
+
+NS_IMPL_ISUPPORTS(PeerConnectionImpl::DTMFState, nsITimerCallback)
+
+} // end mozilla namespace
diff --git a/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.h b/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.h
new file mode 100644
index 000000000..c29d08180
--- /dev/null
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.h
@@ -0,0 +1,894 @@
+/* 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/. */
+
+#ifndef _PEER_CONNECTION_IMPL_H_
+#define _PEER_CONNECTION_IMPL_H_
+
+#include <deque>
+#include <string>
+#include <vector>
+#include <map>
+#include <cmath>
+
+#include "prlock.h"
+#include "mozilla/RefPtr.h"
+#include "nsWeakPtr.h"
+#include "nsAutoPtr.h"
+#include "nsIWeakReferenceUtils.h" // for the definition of nsWeakPtr
+#include "IPeerConnection.h"
+#include "sigslot.h"
+#include "nricectx.h"
+#include "nricemediastream.h"
+#include "nsComponentManagerUtils.h"
+#include "nsPIDOMWindow.h"
+#include "nsIUUIDGenerator.h"
+#include "nsIThread.h"
+
+#include "signaling/src/jsep/JsepSession.h"
+#include "signaling/src/jsep/JsepSessionImpl.h"
+#include "signaling/src/sdp/SdpMediaSection.h"
+
+#include "mozilla/ErrorResult.h"
+#include "mozilla/dom/PeerConnectionImplEnumsBinding.h"
+#include "PrincipalChangeObserver.h"
+#include "StreamTracks.h"
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+#include "mozilla/TimeStamp.h"
+#include "mozilla/net/DataChannel.h"
+#include "VideoUtils.h"
+#include "VideoSegment.h"
+#include "mozilla/dom/RTCStatsReportBinding.h"
+#include "nsIPrincipal.h"
+#include "mozilla/PeerIdentity.h"
+#endif
+
+namespace test {
+#ifdef USE_FAKE_PCOBSERVER
+class AFakePCObserver;
+#endif
+}
+
+#ifdef USE_FAKE_MEDIA_STREAMS
+class Fake_DOMMediaStream;
+class Fake_MediaStreamTrack;
+#endif
+
+class nsGlobalWindow;
+class nsDOMDataChannel;
+
+namespace mozilla {
+class DataChannel;
+class DtlsIdentity;
+class NrIceCtx;
+class NrIceMediaStream;
+class NrIceStunServer;
+class NrIceTurnServer;
+class MediaPipeline;
+
+#ifdef USE_FAKE_MEDIA_STREAMS
+typedef Fake_DOMMediaStream DOMMediaStream;
+#else
+class DOMMediaStream;
+#endif
+
+namespace dom {
+class RTCCertificate;
+struct RTCConfiguration;
+class RTCDTMFSender;
+struct RTCIceServer;
+struct RTCOfferOptions;
+struct RTCRtpParameters;
+class RTCRtpSender;
+#ifdef USE_FAKE_MEDIA_STREAMS
+typedef Fake_MediaStreamTrack MediaStreamTrack;
+#else
+class MediaStreamTrack;
+#endif
+
+#ifdef USE_FAKE_PCOBSERVER
+typedef test::AFakePCObserver PeerConnectionObserver;
+typedef const char *PCObserverString;
+#else
+class PeerConnectionObserver;
+typedef NS_ConvertUTF8toUTF16 PCObserverString;
+#endif
+}
+}
+
+#if defined(__cplusplus) && __cplusplus >= 201103L
+typedef struct Timecard Timecard;
+#else
+#include "timecard.h"
+#endif
+
+// To preserve blame, convert nsresult to ErrorResult with wrappers. These macros
+// help declare wrappers w/function being wrapped when there are no differences.
+
+#define NS_IMETHODIMP_TO_ERRORRESULT(func, rv, ...) \
+NS_IMETHODIMP func(__VA_ARGS__); \
+void func (__VA_ARGS__, rv)
+
+#define NS_IMETHODIMP_TO_ERRORRESULT_RETREF(resulttype, func, rv, ...) \
+NS_IMETHODIMP func(__VA_ARGS__, resulttype **result); \
+already_AddRefed<resulttype> func (__VA_ARGS__, rv)
+
+struct MediaStreamTable;
+
+namespace mozilla {
+
+using mozilla::dom::PeerConnectionObserver;
+using mozilla::dom::RTCConfiguration;
+using mozilla::dom::RTCIceServer;
+using mozilla::dom::RTCOfferOptions;
+using mozilla::DOMMediaStream;
+using mozilla::NrIceCtx;
+using mozilla::NrIceMediaStream;
+using mozilla::DtlsIdentity;
+using mozilla::ErrorResult;
+using mozilla::NrIceStunServer;
+using mozilla::NrIceTurnServer;
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+using mozilla::PeerIdentity;
+#endif
+
+class PeerConnectionWrapper;
+class PeerConnectionMedia;
+class RemoteSourceStreamInfo;
+
+// Uuid Generator
+class PCUuidGenerator : public mozilla::JsepUuidGenerator {
+ public:
+ virtual bool Generate(std::string* idp) override;
+
+ private:
+ nsCOMPtr<nsIUUIDGenerator> mGenerator;
+};
+
+class PeerConnectionConfiguration
+{
+public:
+ PeerConnectionConfiguration()
+ : mBundlePolicy(kBundleBalanced),
+ mIceTransportPolicy(NrIceCtx::ICE_POLICY_ALL) {}
+
+ bool addStunServer(const std::string& addr, uint16_t port,
+ const char* transport)
+ {
+ UniquePtr<NrIceStunServer> server(NrIceStunServer::Create(addr, port, transport));
+ if (!server) {
+ return false;
+ }
+ addStunServer(*server);
+ return true;
+ }
+ bool addTurnServer(const std::string& addr, uint16_t port,
+ const std::string& username,
+ const std::string& pwd,
+ const char* transport)
+ {
+ // TODO(ekr@rtfm.com): Need support for SASLprep for
+ // username and password. Bug # ???
+ std::vector<unsigned char> password(pwd.begin(), pwd.end());
+
+ UniquePtr<NrIceTurnServer> server(NrIceTurnServer::Create(addr, port, username, password,
+ transport));
+ if (!server) {
+ return false;
+ }
+ addTurnServer(*server);
+ return true;
+ }
+ void addStunServer(const NrIceStunServer& server) { mStunServers.push_back (server); }
+ void addTurnServer(const NrIceTurnServer& server) { mTurnServers.push_back (server); }
+ const std::vector<NrIceStunServer>& getStunServers() const { return mStunServers; }
+ const std::vector<NrIceTurnServer>& getTurnServers() const { return mTurnServers; }
+ void setBundlePolicy(JsepBundlePolicy policy) { mBundlePolicy = policy;}
+ JsepBundlePolicy getBundlePolicy() const { return mBundlePolicy; }
+ void setIceTransportPolicy(NrIceCtx::Policy policy) { mIceTransportPolicy = policy;}
+ NrIceCtx::Policy getIceTransportPolicy() const { return mIceTransportPolicy; }
+
+#ifndef MOZILLA_EXTERNAL_LINKAGE
+ nsresult Init(const RTCConfiguration& aSrc);
+ nsresult AddIceServer(const RTCIceServer& aServer);
+#endif
+
+private:
+ std::vector<NrIceStunServer> mStunServers;
+ std::vector<NrIceTurnServer> mTurnServers;
+ JsepBundlePolicy mBundlePolicy;
+ NrIceCtx::Policy mIceTransportPolicy;
+};
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+// Not an inner class so we can forward declare.
+class RTCStatsQuery {
+ public:
+ explicit RTCStatsQuery(bool internalStats);
+ ~RTCStatsQuery();
+
+ nsAutoPtr<mozilla::dom::RTCStatsReportInternal> report;
+ std::string error;
+ // A timestamp to help with telemetry.
+ mozilla::TimeStamp iceStartTime;
+ // Just for convenience, maybe integrate into the report later
+ bool failed;
+
+ private:
+ friend class PeerConnectionImpl;
+ std::string pcName;
+ bool internalStats;
+ nsTArray<RefPtr<mozilla::MediaPipeline>> pipelines;
+ RefPtr<NrIceCtx> iceCtx;
+ bool grabAllLevels;
+ DOMHighResTimeStamp now;
+};
+#endif // MOZILLA_INTERNAL_API
+
+// Enter an API call and check that the state is OK,
+// the PC isn't closed, etc.
+#define PC_AUTO_ENTER_API_CALL(assert_ice_ready) \
+ do { \
+ /* do/while prevents res from conflicting with locals */ \
+ nsresult res = CheckApiState(assert_ice_ready); \
+ if (NS_FAILED(res)) return res; \
+ } while(0)
+#define PC_AUTO_ENTER_API_CALL_VOID_RETURN(assert_ice_ready) \
+ do { \
+ /* do/while prevents res from conflicting with locals */ \
+ nsresult res = CheckApiState(assert_ice_ready); \
+ if (NS_FAILED(res)) return; \
+ } while(0)
+#define PC_AUTO_ENTER_API_CALL_NO_CHECK() CheckThread()
+
+class PeerConnectionImpl final : public nsISupports,
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ public mozilla::DataChannelConnection::DataConnectionListener,
+ public dom::PrincipalChangeObserver<dom::MediaStreamTrack>,
+#endif
+ public sigslot::has_slots<>
+{
+ struct Internal; // Avoid exposing c includes to bindings
+
+public:
+ explicit PeerConnectionImpl(const mozilla::dom::GlobalObject* aGlobal = nullptr);
+
+ enum Error {
+ kNoError = 0,
+ kInvalidCandidate = 2,
+ kInvalidMediastreamTrack = 3,
+ kInvalidState = 4,
+ kInvalidSessionDescription = 5,
+ kIncompatibleSessionDescription = 6,
+ kIncompatibleMediaStreamTrack = 8,
+ kInternalError = 9
+ };
+
+ NS_DECL_THREADSAFE_ISUPPORTS
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ bool WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
+#endif
+
+ static already_AddRefed<PeerConnectionImpl>
+ Constructor(const mozilla::dom::GlobalObject& aGlobal, ErrorResult& rv);
+ static PeerConnectionImpl* CreatePeerConnection();
+ already_AddRefed<DOMMediaStream> MakeMediaStream();
+
+ nsresult CreateRemoteSourceStreamInfo(RefPtr<RemoteSourceStreamInfo>* aInfo,
+ const std::string& aId);
+
+ // DataConnection observers
+ void NotifyDataChannel(already_AddRefed<mozilla::DataChannel> aChannel)
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ // PeerConnectionImpl only inherits from mozilla::DataChannelConnection
+ // inside libxul.
+ override
+#endif
+ ;
+
+ // Get the media object
+ const RefPtr<PeerConnectionMedia>& media() const {
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ return mMedia;
+ }
+
+ // Configure the ability to use localhost.
+ void SetAllowIceLoopback(bool val) { mAllowIceLoopback = val; }
+ bool GetAllowIceLoopback() const { return mAllowIceLoopback; }
+
+ // Configure the ability to use IPV6 link-local addresses.
+ void SetAllowIceLinkLocal(bool val) { mAllowIceLinkLocal = val; }
+ bool GetAllowIceLinkLocal() const { return mAllowIceLinkLocal; }
+
+ // Handle system to allow weak references to be passed through C code
+ virtual const std::string& GetHandle();
+
+ // Name suitable for exposing to content
+ virtual const std::string& GetName();
+
+ // ICE events
+ void IceConnectionStateChange(NrIceCtx* ctx,
+ NrIceCtx::ConnectionState state);
+ void IceGatheringStateChange(NrIceCtx* ctx,
+ NrIceCtx::GatheringState state);
+ void UpdateDefaultCandidate(const std::string& defaultAddr,
+ uint16_t defaultPort,
+ const std::string& defaultRtcpAddr,
+ uint16_t defaultRtcpPort,
+ uint16_t level);
+ void EndOfLocalCandidates(uint16_t level);
+ void IceStreamReady(NrIceMediaStream *aStream);
+
+ static void ListenThread(void *aData);
+ static void ConnectThread(void *aData);
+
+ // Get the main thread
+ nsCOMPtr<nsIThread> GetMainThread() {
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ return mThread;
+ }
+
+ // Get the STS thread
+ nsIEventTarget* GetSTSThread() {
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ return mSTSThread;
+ }
+
+ nsPIDOMWindowInner* GetWindow() const {
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ return mWindow;
+ }
+
+ // Initialize PeerConnection from a PeerConnectionConfiguration object
+ // (used directly by unit-tests, and indirectly by the JS entry point)
+ // This is necessary because RTCConfiguration can't be used by unit-tests
+ nsresult Initialize(PeerConnectionObserver& aObserver,
+ nsGlobalWindow* aWindow,
+ const PeerConnectionConfiguration& aConfiguration,
+ nsISupports* aThread);
+
+#ifndef MOZILLA_EXTERNAL_LINKAGE
+ // Initialize PeerConnection from an RTCConfiguration object (JS entrypoint)
+ void Initialize(PeerConnectionObserver& aObserver,
+ nsGlobalWindow& aWindow,
+ const RTCConfiguration& aConfiguration,
+ nsISupports* aThread,
+ ErrorResult &rv);
+#endif
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ void SetCertificate(mozilla::dom::RTCCertificate& aCertificate);
+ const RefPtr<mozilla::dom::RTCCertificate>& Certificate() const;
+#endif
+ // This is a hack to support external linkage.
+ RefPtr<DtlsIdentity> Identity() const;
+
+ NS_IMETHODIMP_TO_ERRORRESULT(CreateOffer, ErrorResult &rv,
+ const RTCOfferOptions& aOptions)
+ {
+ rv = CreateOffer(aOptions);
+ }
+
+ NS_IMETHODIMP CreateAnswer();
+ void CreateAnswer(ErrorResult &rv)
+ {
+ rv = CreateAnswer();
+ }
+
+ NS_IMETHODIMP CreateOffer(
+ const mozilla::JsepOfferOptions& aConstraints);
+
+ NS_IMETHODIMP SetLocalDescription (int32_t aAction, const char* aSDP);
+
+ void SetLocalDescription (int32_t aAction, const nsAString& aSDP, ErrorResult &rv)
+ {
+ rv = SetLocalDescription(aAction, NS_ConvertUTF16toUTF8(aSDP).get());
+ }
+
+ nsresult CreateNewRemoteTracks(RefPtr<PeerConnectionObserver>& aPco);
+
+ void RemoveOldRemoteTracks(RefPtr<PeerConnectionObserver>& aPco);
+
+ NS_IMETHODIMP SetRemoteDescription (int32_t aAction, const char* aSDP);
+
+ void SetRemoteDescription (int32_t aAction, const nsAString& aSDP, ErrorResult &rv)
+ {
+ rv = SetRemoteDescription(aAction, NS_ConvertUTF16toUTF8(aSDP).get());
+ }
+
+ NS_IMETHODIMP_TO_ERRORRESULT(GetStats, ErrorResult &rv,
+ mozilla::dom::MediaStreamTrack *aSelector)
+ {
+ rv = GetStats(aSelector);
+ }
+
+ NS_IMETHODIMP AddIceCandidate(const char* aCandidate, const char* aMid,
+ unsigned short aLevel);
+
+ void AddIceCandidate(const nsAString& aCandidate, const nsAString& aMid,
+ unsigned short aLevel, ErrorResult &rv)
+ {
+ rv = AddIceCandidate(NS_ConvertUTF16toUTF8(aCandidate).get(),
+ NS_ConvertUTF16toUTF8(aMid).get(), aLevel);
+ }
+
+ NS_IMETHODIMP CloseStreams();
+
+ void CloseStreams(ErrorResult &rv)
+ {
+ rv = CloseStreams();
+ }
+
+ NS_IMETHODIMP_TO_ERRORRESULT(AddTrack, ErrorResult &rv,
+ mozilla::dom::MediaStreamTrack& aTrack,
+ const mozilla::dom::Sequence<mozilla::OwningNonNull<DOMMediaStream>>& aStreams)
+ {
+ rv = AddTrack(aTrack, aStreams);
+ }
+
+ NS_IMETHODIMP_TO_ERRORRESULT(RemoveTrack, ErrorResult &rv,
+ mozilla::dom::MediaStreamTrack& aTrack)
+ {
+ rv = RemoveTrack(aTrack);
+ }
+
+ nsresult
+ AddTrack(mozilla::dom::MediaStreamTrack& aTrack, DOMMediaStream& aStream);
+
+ NS_IMETHODIMP_TO_ERRORRESULT(InsertDTMF, ErrorResult &rv,
+ dom::RTCRtpSender& sender,
+ const nsAString& tones,
+ uint32_t duration, uint32_t interToneGap) {
+ rv = InsertDTMF(sender, tones, duration, interToneGap);
+ }
+
+ NS_IMETHODIMP_TO_ERRORRESULT(GetDTMFToneBuffer, ErrorResult &rv,
+ dom::RTCRtpSender& sender,
+ nsAString& outToneBuffer) {
+ rv = GetDTMFToneBuffer(sender, outToneBuffer);
+ }
+
+ NS_IMETHODIMP_TO_ERRORRESULT(ReplaceTrack, ErrorResult &rv,
+ mozilla::dom::MediaStreamTrack& aThisTrack,
+ mozilla::dom::MediaStreamTrack& aWithTrack)
+ {
+ rv = ReplaceTrack(aThisTrack, aWithTrack);
+ }
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ NS_IMETHODIMP_TO_ERRORRESULT(SetParameters, ErrorResult &rv,
+ dom::MediaStreamTrack& aTrack,
+ const dom::RTCRtpParameters& aParameters)
+ {
+ rv = SetParameters(aTrack, aParameters);
+ }
+
+ NS_IMETHODIMP_TO_ERRORRESULT(GetParameters, ErrorResult &rv,
+ dom::MediaStreamTrack& aTrack,
+ dom::RTCRtpParameters& aOutParameters)
+ {
+ rv = GetParameters(aTrack, aOutParameters);
+ }
+#endif
+
+ nsresult
+ SetParameters(dom::MediaStreamTrack& aTrack,
+ const std::vector<JsepTrack::JsConstraints>& aConstraints);
+
+ nsresult
+ GetParameters(dom::MediaStreamTrack& aTrack,
+ std::vector<JsepTrack::JsConstraints>* aOutConstraints);
+
+ NS_IMETHODIMP_TO_ERRORRESULT(SelectSsrc, ErrorResult &rv,
+ dom::MediaStreamTrack& aRecvTrack,
+ unsigned short aSsrcIndex)
+ {
+ rv = SelectSsrc(aRecvTrack, aSsrcIndex);
+ }
+
+ nsresult GetPeerIdentity(nsAString& peerIdentity)
+ {
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ if (mPeerIdentity) {
+ peerIdentity = mPeerIdentity->ToString();
+ return NS_OK;
+ }
+#endif
+
+ peerIdentity.SetIsVoid(true);
+ return NS_OK;
+ }
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ const PeerIdentity* GetPeerIdentity() const { return mPeerIdentity; }
+ nsresult SetPeerIdentity(const nsAString& peerIdentity);
+
+ const std::string& GetIdAsAscii() const
+ {
+ return mName;
+ }
+
+ nsresult GetId(nsAString& id)
+ {
+ id = NS_ConvertASCIItoUTF16(mName.c_str());
+ return NS_OK;
+ }
+
+ nsresult SetId(const nsAString& id)
+ {
+ mName = NS_ConvertUTF16toUTF8(id).get();
+ return NS_OK;
+ }
+#endif
+
+ // this method checks to see if we've made a promise to protect media.
+ bool PrivacyRequested() const { return mPrivacyRequested; }
+
+ NS_IMETHODIMP GetFingerprint(char** fingerprint);
+ void GetFingerprint(nsAString& fingerprint)
+ {
+ char *tmp;
+ GetFingerprint(&tmp);
+ fingerprint.AssignASCII(tmp);
+ delete[] tmp;
+ }
+
+ NS_IMETHODIMP GetLocalDescription(char** aSDP);
+
+ void GetLocalDescription(nsAString& aSDP)
+ {
+ char *tmp;
+ GetLocalDescription(&tmp);
+ aSDP.AssignASCII(tmp);
+ delete[] tmp;
+ }
+
+ NS_IMETHODIMP GetRemoteDescription(char** aSDP);
+
+ void GetRemoteDescription(nsAString& aSDP)
+ {
+ char *tmp;
+ GetRemoteDescription(&tmp);
+ aSDP.AssignASCII(tmp);
+ delete[] tmp;
+ }
+
+ NS_IMETHODIMP SignalingState(mozilla::dom::PCImplSignalingState* aState);
+
+ mozilla::dom::PCImplSignalingState SignalingState()
+ {
+ mozilla::dom::PCImplSignalingState state;
+ SignalingState(&state);
+ return state;
+ }
+
+ NS_IMETHODIMP IceConnectionState(
+ mozilla::dom::PCImplIceConnectionState* aState);
+
+ mozilla::dom::PCImplIceConnectionState IceConnectionState()
+ {
+ mozilla::dom::PCImplIceConnectionState state;
+ IceConnectionState(&state);
+ return state;
+ }
+
+ NS_IMETHODIMP IceGatheringState(
+ mozilla::dom::PCImplIceGatheringState* aState);
+
+ mozilla::dom::PCImplIceGatheringState IceGatheringState()
+ {
+ mozilla::dom::PCImplIceGatheringState state;
+ IceGatheringState(&state);
+ return state;
+ }
+
+ NS_IMETHODIMP Close();
+
+ void Close(ErrorResult &rv)
+ {
+ rv = Close();
+ }
+
+ bool PluginCrash(uint32_t aPluginID,
+ const nsAString& aPluginName);
+
+ void RecordEndOfCallTelemetry() const;
+
+ nsresult InitializeDataChannel();
+
+ NS_IMETHODIMP_TO_ERRORRESULT_RETREF(nsDOMDataChannel,
+ CreateDataChannel, ErrorResult &rv,
+ const nsAString& aLabel,
+ const nsAString& aProtocol,
+ uint16_t aType,
+ bool outOfOrderAllowed,
+ uint16_t aMaxTime,
+ uint16_t aMaxNum,
+ bool aExternalNegotiated,
+ uint16_t aStream);
+
+ NS_IMETHODIMP_TO_ERRORRESULT(GetLocalStreams, ErrorResult &rv,
+ nsTArray<RefPtr<DOMMediaStream > >& result)
+ {
+ rv = GetLocalStreams(result);
+ }
+
+ NS_IMETHODIMP_TO_ERRORRESULT(GetRemoteStreams, ErrorResult &rv,
+ nsTArray<RefPtr<DOMMediaStream > >& result)
+ {
+ rv = GetRemoteStreams(result);
+ }
+
+ // Called whenever something is unrecognized by the parser
+ // May be called more than once and does not necessarily mean
+ // that parsing was stopped, only that something was unrecognized.
+ void OnSdpParseError(const char* errorMessage);
+
+ // Called when OnLocal/RemoteDescriptionSuccess/Error
+ // is called to start the list over.
+ void ClearSdpParseErrorMessages();
+
+ // Called to retreive the list of parsing errors.
+ const std::vector<std::string> &GetSdpParseErrors();
+
+ // Sets the RTC Signaling State
+ void SetSignalingState_m(mozilla::dom::PCImplSignalingState aSignalingState,
+ bool rollback = false);
+
+ // Updates the RTC signaling state based on the JsepSession state
+ void UpdateSignalingState(bool rollback = false);
+
+ bool IsClosed() const;
+ // called when DTLS connects; we only need this once
+ nsresult SetDtlsConnected(bool aPrivacyRequested);
+
+ bool HasMedia() const;
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ // initialize telemetry for when calls start
+ void startCallTelem();
+
+ nsresult BuildStatsQuery_m(
+ mozilla::dom::MediaStreamTrack *aSelector,
+ RTCStatsQuery *query);
+
+ static nsresult ExecuteStatsQuery_s(RTCStatsQuery *query);
+
+ // for monitoring changes in track ownership
+ // PeerConnectionMedia can't do it because it doesn't know about principals
+ virtual void PrincipalChanged(dom::MediaStreamTrack* aTrack) override;
+
+#endif
+
+ static std::string GetStreamId(const DOMMediaStream& aStream);
+ static std::string GetTrackId(const dom::MediaStreamTrack& track);
+
+ void OnMediaError(const std::string& aError);
+
+private:
+ virtual ~PeerConnectionImpl();
+ PeerConnectionImpl(const PeerConnectionImpl&rhs);
+ PeerConnectionImpl& operator=(PeerConnectionImpl);
+ nsresult CalculateFingerprint(const std::string& algorithm,
+ std::vector<uint8_t>* fingerprint) const;
+ nsresult ConfigureJsepSessionCodecs();
+
+ NS_IMETHODIMP EnsureDataConnection(uint16_t aNumstreams);
+
+ nsresult CloseInt();
+ nsresult CheckApiState(bool assert_ice_ready) const;
+ void CheckThread() const {
+ MOZ_ASSERT(CheckThreadInt(), "Wrong thread");
+ }
+ bool CheckThreadInt() const {
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ // Thread assertions are disabled in the C++ unit tests because those
+ // make API calls off the main thread.
+ // This affects the standalone version of WebRTC since it is also used
+ // for an alternate build of the unit tests.
+ // TODO(ekr@rtfm.com): Fix the unit tests so they don't do that.
+ bool on;
+ NS_ENSURE_SUCCESS(mThread->IsOnCurrentThread(&on), false);
+ NS_ENSURE_TRUE(on, false);
+#endif
+ return true;
+ }
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ nsresult GetTimeSinceEpoch(DOMHighResTimeStamp *result);
+#endif
+
+ // Shut down media - called on main thread only
+ void ShutdownMedia();
+
+ void CandidateReady(const std::string& candidate, uint16_t level);
+ void SendLocalIceCandidateToContent(uint16_t level,
+ const std::string& mid,
+ const std::string& candidate);
+
+ nsresult GetDatachannelParameters(
+ const mozilla::JsepApplicationCodecDescription** codec,
+ uint16_t* level) const;
+
+ static void DeferredAddTrackToJsepSession(const std::string& pcHandle,
+ SdpMediaSection::MediaType type,
+ const std::string& streamId,
+ const std::string& trackId);
+
+ nsresult AddTrackToJsepSession(SdpMediaSection::MediaType type,
+ const std::string& streamId,
+ const std::string& trackId);
+
+ nsresult SetupIceRestart();
+ nsresult RollbackIceRestart();
+ void FinalizeIceRestart();
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ static void GetStatsForPCObserver_s(
+ const std::string& pcHandle,
+ nsAutoPtr<RTCStatsQuery> query);
+
+ // Sends an RTCStatsReport to JS. Must run on main thread.
+ static void DeliverStatsReportToPCObserver_m(
+ const std::string& pcHandle,
+ nsresult result,
+ nsAutoPtr<RTCStatsQuery> query);
+#endif
+
+ // When ICE completes, we record a bunch of statistics that outlive the
+ // PeerConnection. This is just telemetry right now, but this can also
+ // include things like dumping the RLogConnector somewhere, saving away
+ // an RTCStatsReport somewhere so it can be inspected after the call is over,
+ // or other things.
+ void RecordLongtermICEStatistics();
+
+ void OnNegotiationNeeded();
+ static void MaybeFireNegotiationNeeded_static(const std::string& pcHandle);
+ void MaybeFireNegotiationNeeded();
+
+ // Timecard used to measure processing time. This should be the first class
+ // attribute so that we accurately measure the time required to instantiate
+ // any other attributes of this class.
+ Timecard *mTimeCard;
+
+ mozilla::dom::PCImplSignalingState mSignalingState;
+
+ // ICE State
+ mozilla::dom::PCImplIceConnectionState mIceConnectionState;
+ mozilla::dom::PCImplIceGatheringState mIceGatheringState;
+
+ // DTLS
+ // this is true if we have been connected ever, see SetDtlsConnected
+ bool mDtlsConnected;
+
+ nsCOMPtr<nsIThread> mThread;
+ // TODO: Remove if we ever properly wire PeerConnection for cycle-collection.
+ nsWeakPtr mPCObserver;
+
+ nsCOMPtr<nsPIDOMWindowInner> mWindow;
+
+ // The SDP sent in from JS - here for debugging.
+ std::string mLocalRequestedSDP;
+ std::string mRemoteRequestedSDP;
+
+ // DTLS fingerprint
+ std::string mFingerprint;
+ std::string mRemoteFingerprint;
+
+ // identity-related fields
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ // The entity on the other end of the peer-to-peer connection;
+ // void if they are not yet identified, and no identity setting has been set
+ RefPtr<PeerIdentity> mPeerIdentity;
+ // The certificate we are using.
+ RefPtr<mozilla::dom::RTCCertificate> mCertificate;
+#else
+ RefPtr<DtlsIdentity> mIdentity;
+#endif
+ // Whether an app should be prevented from accessing media produced by the PC
+ // If this is true, then media will not be sent until mPeerIdentity matches
+ // local streams PeerIdentity; and remote streams are protected from content
+ //
+ // This can be false if mPeerIdentity is set, in the case where identity is
+ // provided, but the media is not protected from the app on either side
+ bool mPrivacyRequested;
+
+ // A handle to refer to this PC with
+ std::string mHandle;
+
+ // A name for this PC that we are willing to expose to content.
+ std::string mName;
+
+ // The target to run stuff on
+ nsCOMPtr<nsIEventTarget> mSTSThread;
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ // DataConnection that's used to get all the DataChannels
+ RefPtr<mozilla::DataChannelConnection> mDataConnection;
+#endif
+
+ bool mAllowIceLoopback;
+ bool mAllowIceLinkLocal;
+ RefPtr<PeerConnectionMedia> mMedia;
+
+ // The JSEP negotiation session.
+ mozilla::UniquePtr<PCUuidGenerator> mUuidGen;
+ mozilla::UniquePtr<mozilla::JsepSession> mJsepSession;
+ std::string mPreviousIceUfrag; // used during rollback of ice restart
+ std::string mPreviousIcePwd; // used during rollback of ice restart
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ // Start time of ICE, used for telemetry
+ mozilla::TimeStamp mIceStartTime;
+ // Start time of call used for Telemetry
+ mozilla::TimeStamp mStartTime;
+#endif
+
+ // Temporary: used to prevent multiple audio streams or multiple video streams
+ // in a single PC. This is tied up in the IETF discussion around proper
+ // representation of multiple streams in SDP, and strongly related to
+ // Bug 840728.
+ int mNumAudioStreams;
+ int mNumVideoStreams;
+ bool mHaveConfiguredCodecs;
+
+ bool mHaveDataStream;
+
+ unsigned int mAddCandidateErrorCount;
+
+ bool mTrickle;
+
+ bool mNegotiationNeeded;
+
+ bool mPrivateWindow;
+
+ // storage for Telemetry data
+ uint16_t mMaxReceiving[SdpMediaSection::kMediaTypes];
+ uint16_t mMaxSending[SdpMediaSection::kMediaTypes];
+
+ // DTMF
+ class DTMFState : public nsITimerCallback {
+ virtual ~DTMFState();
+ public:
+ DTMFState();
+
+ NS_DECL_NSITIMERCALLBACK
+ NS_DECL_THREADSAFE_ISUPPORTS
+
+ PeerConnectionImpl* mPeerConnectionImpl;
+ nsCOMPtr<nsITimer> mSendTimer;
+ nsString mTrackId;
+ nsString mTones;
+ size_t mLevel;
+ uint32_t mDuration;
+ uint32_t mInterToneGap;
+ };
+
+ nsTArray<RefPtr<DTMFState>> mDTMFStates;
+
+public:
+ //these are temporary until the DataChannel Listen/Connect API is removed
+ unsigned short listenPort;
+ unsigned short connectPort;
+ char *connectStr; // XXX ownership/free
+};
+
+// This is what is returned when you acquire on a handle
+class PeerConnectionWrapper
+{
+ public:
+ explicit PeerConnectionWrapper(const std::string& handle);
+
+ PeerConnectionImpl *impl() { return impl_; }
+
+ private:
+ RefPtr<PeerConnectionImpl> impl_;
+};
+
+} // end mozilla namespace
+
+#undef NS_IMETHODIMP_TO_ERRORRESULT
+#undef NS_IMETHODIMP_TO_ERRORRESULT_RETREF
+#endif // _PEER_CONNECTION_IMPL_H_
diff --git a/media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.cpp b/media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.cpp
new file mode 100644
index 000000000..4f42b0bb7
--- /dev/null
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.cpp
@@ -0,0 +1,1672 @@
+/* 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 <ostream>
+#include <string>
+#include <vector>
+
+#include "CSFLog.h"
+
+#include "nspr.h"
+
+#include "nricectx.h"
+#include "nricemediastream.h"
+#include "MediaPipelineFactory.h"
+#include "PeerConnectionImpl.h"
+#include "PeerConnectionMedia.h"
+#include "AudioConduit.h"
+#include "VideoConduit.h"
+#include "runnable_utils.h"
+#include "transportlayerice.h"
+#include "transportlayerdtls.h"
+#include "signaling/src/jsep/JsepSession.h"
+#include "signaling/src/jsep/JsepTransport.h"
+
+#ifdef USE_FAKE_STREAMS
+#include "DOMMediaStream.h"
+#include "FakeMediaStreams.h"
+#else
+#include "MediaSegment.h"
+#ifdef MOZILLA_INTERNAL_API
+#include "MediaStreamGraph.h"
+#endif
+#endif
+
+#ifndef USE_FAKE_MEDIA_STREAMS
+#include "MediaStreamGraphImpl.h"
+#endif
+
+#include "nsNetCID.h"
+#include "nsNetUtil.h"
+#include "nsIURI.h"
+#include "nsIScriptSecurityManager.h"
+#include "nsICancelable.h"
+#include "nsILoadInfo.h"
+#include "nsIContentPolicy.h"
+#include "nsIProxyInfo.h"
+#include "nsIProtocolProxyService.h"
+
+#include "nsProxyRelease.h"
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+#include "MediaStreamList.h"
+#include "nsIScriptGlobalObject.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/dom/RTCStatsReportBinding.h"
+#include "MediaStreamTrack.h"
+#include "VideoStreamTrack.h"
+#include "MediaStreamError.h"
+#include "MediaManager.h"
+#endif
+
+
+
+namespace mozilla {
+using namespace dom;
+
+static const char* logTag = "PeerConnectionMedia";
+
+nsresult
+PeerConnectionMedia::ReplaceTrack(const std::string& aOldStreamId,
+ const std::string& aOldTrackId,
+ MediaStreamTrack& aNewTrack,
+ const std::string& aNewStreamId,
+ const std::string& aNewTrackId)
+{
+ RefPtr<LocalSourceStreamInfo> oldInfo(GetLocalStreamById(aOldStreamId));
+
+ if (!oldInfo) {
+ CSFLogError(logTag, "Failed to find stream id %s", aOldStreamId.c_str());
+ return NS_ERROR_NOT_AVAILABLE;
+ }
+
+ nsresult rv = AddTrack(*aNewTrack.mOwningStream, aNewStreamId,
+ aNewTrack, aNewTrackId);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ RefPtr<LocalSourceStreamInfo> newInfo(GetLocalStreamById(aNewStreamId));
+
+ if (!newInfo) {
+ CSFLogError(logTag, "Failed to add track id %s", aNewTrackId.c_str());
+ MOZ_ASSERT(false);
+ return NS_ERROR_FAILURE;
+ }
+
+ rv = newInfo->TakePipelineFrom(oldInfo, aOldTrackId, aNewTrack, aNewTrackId);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ return RemoveLocalTrack(aOldStreamId, aOldTrackId);
+}
+
+static void
+PipelineReleaseRef_m(RefPtr<MediaPipeline> pipeline)
+{}
+
+static void
+PipelineDetachTransport_s(RefPtr<MediaPipeline> pipeline,
+ nsCOMPtr<nsIThread> mainThread)
+{
+ pipeline->DetachTransport_s();
+ mainThread->Dispatch(
+ // Make sure we let go of our reference before dispatching
+ // If the dispatch fails, well, we're hosed anyway.
+ WrapRunnableNM(PipelineReleaseRef_m, pipeline.forget()),
+ NS_DISPATCH_NORMAL);
+}
+
+void
+SourceStreamInfo::EndTrack(MediaStream* stream, dom::MediaStreamTrack* track)
+{
+ if (!stream || !stream->AsSourceStream()) {
+ return;
+ }
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ class Message : public ControlMessage {
+ public:
+ Message(MediaStream* stream, TrackID track)
+ : ControlMessage(stream),
+ track_id_(track) {}
+
+ virtual void Run() override {
+ mStream->AsSourceStream()->EndTrack(track_id_);
+ }
+ private:
+ TrackID track_id_;
+ };
+
+ stream->GraphImpl()->AppendMessage(
+ MakeUnique<Message>(stream, track->mTrackID));
+#endif
+
+}
+
+void
+SourceStreamInfo::RemoveTrack(const std::string& trackId)
+{
+ mTracks.erase(trackId);
+
+ RefPtr<MediaPipeline> pipeline = GetPipelineByTrackId_m(trackId);
+ if (pipeline) {
+ mPipelines.erase(trackId);
+ pipeline->ShutdownMedia_m();
+ mParent->GetSTSThread()->Dispatch(
+ WrapRunnableNM(PipelineDetachTransport_s,
+ pipeline.forget(),
+ mParent->GetMainThread()),
+ NS_DISPATCH_NORMAL);
+ }
+}
+
+void SourceStreamInfo::DetachTransport_s()
+{
+ ASSERT_ON_THREAD(mParent->GetSTSThread());
+ // walk through all the MediaPipelines and call the shutdown
+ // transport functions. Must be on the STS thread.
+ for (auto it = mPipelines.begin(); it != mPipelines.end(); ++it) {
+ it->second->DetachTransport_s();
+ }
+}
+
+void SourceStreamInfo::DetachMedia_m()
+{
+ ASSERT_ON_THREAD(mParent->GetMainThread());
+
+ // walk through all the MediaPipelines and call the shutdown
+ // media functions. Must be on the main thread.
+ for (auto it = mPipelines.begin(); it != mPipelines.end(); ++it) {
+ it->second->ShutdownMedia_m();
+ }
+ mMediaStream = nullptr;
+}
+
+already_AddRefed<PeerConnectionImpl>
+PeerConnectionImpl::Constructor(const dom::GlobalObject& aGlobal, ErrorResult& rv)
+{
+ RefPtr<PeerConnectionImpl> pc = new PeerConnectionImpl(&aGlobal);
+
+ CSFLogDebug(logTag, "Created PeerConnection: %p", pc.get());
+
+ return pc.forget();
+}
+
+PeerConnectionImpl* PeerConnectionImpl::CreatePeerConnection()
+{
+ PeerConnectionImpl *pc = new PeerConnectionImpl();
+
+ CSFLogDebug(logTag, "Created PeerConnection: %p", pc);
+
+ return pc;
+}
+
+NS_IMETHODIMP PeerConnectionMedia::ProtocolProxyQueryHandler::
+OnProxyAvailable(nsICancelable *request,
+ nsIChannel *aChannel,
+ nsIProxyInfo *proxyinfo,
+ nsresult result) {
+
+ if (!pcm_->mProxyRequest) {
+ // PeerConnectionMedia is no longer waiting
+ return NS_OK;
+ }
+
+ CSFLogInfo(logTag, "%s: Proxy Available: %d", __FUNCTION__, (int)result);
+
+ if (NS_SUCCEEDED(result) && proxyinfo) {
+ SetProxyOnPcm(*proxyinfo);
+ }
+
+ pcm_->mProxyResolveCompleted = true;
+ pcm_->mProxyRequest = nullptr;
+ pcm_->FlushIceCtxOperationQueueIfReady();
+
+ return NS_OK;
+}
+
+void
+PeerConnectionMedia::ProtocolProxyQueryHandler::SetProxyOnPcm(
+ nsIProxyInfo& proxyinfo)
+{
+ CSFLogInfo(logTag, "%s: Had proxyinfo", __FUNCTION__);
+ nsresult rv;
+ nsCString httpsProxyHost;
+ int32_t httpsProxyPort;
+
+ rv = proxyinfo.GetHost(httpsProxyHost);
+ if (NS_FAILED(rv)) {
+ CSFLogError(logTag, "%s: Failed to get proxy server host", __FUNCTION__);
+ return;
+ }
+
+ rv = proxyinfo.GetPort(&httpsProxyPort);
+ if (NS_FAILED(rv)) {
+ CSFLogError(logTag, "%s: Failed to get proxy server port", __FUNCTION__);
+ return;
+ }
+
+ if (pcm_->mIceCtxHdlr.get()) {
+ assert(httpsProxyPort >= 0 && httpsProxyPort < (1 << 16));
+ // Note that this could check if PrivacyRequested() is set on the PC and
+ // remove "webrtc" from the ALPN list. But that would only work if the PC
+ // was constructed with a peerIdentity constraint, not when isolated
+ // streams are added. If we ever need to signal to the proxy that the
+ // media is isolated, then we would need to restructure this code.
+ pcm_->mProxyServer.reset(
+ new NrIceProxyServer(httpsProxyHost.get(),
+ static_cast<uint16_t>(httpsProxyPort),
+ "webrtc,c-webrtc"));
+ } else {
+ CSFLogError(logTag, "%s: Failed to set proxy server (ICE ctx unavailable)",
+ __FUNCTION__);
+ }
+}
+
+NS_IMPL_ISUPPORTS(PeerConnectionMedia::ProtocolProxyQueryHandler, nsIProtocolProxyCallback)
+
+PeerConnectionMedia::PeerConnectionMedia(PeerConnectionImpl *parent)
+ : mParent(parent),
+ mParentHandle(parent->GetHandle()),
+ mParentName(parent->GetName()),
+ mIceCtxHdlr(nullptr),
+ mDNSResolver(new NrIceResolver()),
+ mUuidGen(MakeUnique<PCUuidGenerator>()),
+ mMainThread(mParent->GetMainThread()),
+ mSTSThread(mParent->GetSTSThread()),
+ mProxyResolveCompleted(false),
+ mIceRestartState(ICE_RESTART_NONE) {
+}
+
+nsresult
+PeerConnectionMedia::InitProxy()
+{
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ // Allow mochitests to disable this, since mochitest configures a fake proxy
+ // that serves up content.
+ bool disable = Preferences::GetBool("media.peerconnection.disable_http_proxy",
+ false);
+ if (disable) {
+ mProxyResolveCompleted = true;
+ return NS_OK;
+ }
+#endif
+
+ nsresult rv;
+ nsCOMPtr<nsIProtocolProxyService> pps =
+ do_GetService(NS_PROTOCOLPROXYSERVICE_CONTRACTID, &rv);
+ if (NS_FAILED(rv)) {
+ CSFLogError(logTag, "%s: Failed to get proxy service: %d", __FUNCTION__, (int)rv);
+ return NS_ERROR_FAILURE;
+ }
+
+ // We use the following URL to find the "default" proxy address for all HTTPS
+ // connections. We will only attempt one HTTP(S) CONNECT per peer connection.
+ // "example.com" is guaranteed to be unallocated and should return the best default.
+ nsCOMPtr<nsIURI> fakeHttpsLocation;
+ rv = NS_NewURI(getter_AddRefs(fakeHttpsLocation), "https://example.com");
+ if (NS_FAILED(rv)) {
+ CSFLogError(logTag, "%s: Failed to set URI: %d", __FUNCTION__, (int)rv);
+ return NS_ERROR_FAILURE;
+ }
+
+ nsCOMPtr<nsIScriptSecurityManager> secMan(
+ do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID, &rv));
+ if (NS_FAILED(rv)) {
+ CSFLogError(logTag, "%s: Failed to get IOService: %d",
+ __FUNCTION__, (int)rv);
+ CSFLogError(logTag, "%s: Failed to get securityManager: %d", __FUNCTION__, (int)rv);
+ return NS_ERROR_FAILURE;
+ }
+
+ nsCOMPtr<nsIPrincipal> systemPrincipal;
+ rv = secMan->GetSystemPrincipal(getter_AddRefs(systemPrincipal));
+ if (NS_FAILED(rv)) {
+ CSFLogError(logTag, "%s: Failed to get systemPrincipal: %d", __FUNCTION__, (int)rv);
+ return NS_ERROR_FAILURE;
+ }
+
+ nsCOMPtr<nsIChannel> channel;
+ rv = NS_NewChannel(getter_AddRefs(channel),
+ fakeHttpsLocation,
+ systemPrincipal,
+ nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL,
+ nsIContentPolicy::TYPE_OTHER);
+
+ if (NS_FAILED(rv)) {
+ CSFLogError(logTag, "%s: Failed to get channel from URI: %d",
+ __FUNCTION__, (int)rv);
+ return NS_ERROR_FAILURE;
+ }
+
+ RefPtr<ProtocolProxyQueryHandler> handler = new ProtocolProxyQueryHandler(this);
+ rv = pps->AsyncResolve(channel,
+ nsIProtocolProxyService::RESOLVE_PREFER_HTTPS_PROXY |
+ nsIProtocolProxyService::RESOLVE_ALWAYS_TUNNEL,
+ handler, getter_AddRefs(mProxyRequest));
+ if (NS_FAILED(rv)) {
+ CSFLogError(logTag, "%s: Failed to resolve protocol proxy: %d", __FUNCTION__, (int)rv);
+ return NS_ERROR_FAILURE;
+ }
+
+ return NS_OK;
+}
+
+nsresult PeerConnectionMedia::Init(const std::vector<NrIceStunServer>& stun_servers,
+ const std::vector<NrIceTurnServer>& turn_servers,
+ NrIceCtx::Policy policy)
+{
+ nsresult rv = InitProxy();
+ NS_ENSURE_SUCCESS(rv, rv);
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ bool ice_tcp = Preferences::GetBool("media.peerconnection.ice.tcp", false);
+#else
+ bool ice_tcp = false;
+#endif
+
+ // TODO(ekr@rtfm.com): need some way to set not offerer later
+ // Looks like a bug in the NrIceCtx API.
+ mIceCtxHdlr = NrIceCtxHandler::Create("PC:" + mParentName,
+ true, // Offerer
+ mParent->GetAllowIceLoopback(),
+ ice_tcp,
+ mParent->GetAllowIceLinkLocal(),
+ policy);
+ if(!mIceCtxHdlr) {
+ CSFLogError(logTag, "%s: Failed to create Ice Context", __FUNCTION__);
+ return NS_ERROR_FAILURE;
+ }
+
+ if (NS_FAILED(rv = mIceCtxHdlr->ctx()->SetStunServers(stun_servers))) {
+ CSFLogError(logTag, "%s: Failed to set stun servers", __FUNCTION__);
+ return rv;
+ }
+ // Give us a way to globally turn off TURN support
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ bool disabled = Preferences::GetBool("media.peerconnection.turn.disable", false);
+#else
+ bool disabled = false;
+#endif
+ if (!disabled) {
+ if (NS_FAILED(rv = mIceCtxHdlr->ctx()->SetTurnServers(turn_servers))) {
+ CSFLogError(logTag, "%s: Failed to set turn servers", __FUNCTION__);
+ return rv;
+ }
+ } else if (turn_servers.size() != 0) {
+ CSFLogError(logTag, "%s: Setting turn servers disabled", __FUNCTION__);
+ }
+ if (NS_FAILED(rv = mDNSResolver->Init())) {
+ CSFLogError(logTag, "%s: Failed to initialize dns resolver", __FUNCTION__);
+ return rv;
+ }
+ if (NS_FAILED(rv =
+ mIceCtxHdlr->ctx()->SetResolver(mDNSResolver->AllocateResolver()))) {
+ CSFLogError(logTag, "%s: Failed to get dns resolver", __FUNCTION__);
+ return rv;
+ }
+ ConnectSignals(mIceCtxHdlr->ctx().get());
+
+ return NS_OK;
+}
+
+void
+PeerConnectionMedia::EnsureTransports(const JsepSession& aSession)
+{
+ auto transports = aSession.GetTransports();
+ for (size_t i = 0; i < transports.size(); ++i) {
+ RefPtr<JsepTransport> transport = transports[i];
+ RUN_ON_THREAD(
+ GetSTSThread(),
+ WrapRunnable(RefPtr<PeerConnectionMedia>(this),
+ &PeerConnectionMedia::EnsureTransport_s,
+ i,
+ transport->mComponents),
+ NS_DISPATCH_NORMAL);
+ }
+
+ GatherIfReady();
+}
+
+void
+PeerConnectionMedia::EnsureTransport_s(size_t aLevel, size_t aComponentCount)
+{
+ RefPtr<NrIceMediaStream> stream(mIceCtxHdlr->ctx()->GetStream(aLevel));
+ if (!stream) {
+ CSFLogDebug(logTag, "%s: Creating ICE media stream=%u components=%u",
+ mParentHandle.c_str(),
+ static_cast<unsigned>(aLevel),
+ static_cast<unsigned>(aComponentCount));
+
+ std::ostringstream os;
+ os << mParentName << " aLevel=" << aLevel;
+ RefPtr<NrIceMediaStream> stream =
+ mIceCtxHdlr->CreateStream(os.str().c_str(),
+ aComponentCount);
+
+ if (!stream) {
+ CSFLogError(logTag, "Failed to create ICE stream.");
+ return;
+ }
+
+ stream->SetLevel(aLevel);
+ stream->SignalReady.connect(this, &PeerConnectionMedia::IceStreamReady_s);
+ stream->SignalCandidate.connect(this,
+ &PeerConnectionMedia::OnCandidateFound_s);
+ mIceCtxHdlr->ctx()->SetStream(aLevel, stream);
+ }
+}
+
+void
+PeerConnectionMedia::ActivateOrRemoveTransports(const JsepSession& aSession)
+{
+ auto transports = aSession.GetTransports();
+ for (size_t i = 0; i < transports.size(); ++i) {
+ RefPtr<JsepTransport> transport = transports[i];
+
+ std::string ufrag;
+ std::string pwd;
+ std::vector<std::string> candidates;
+
+ if (transport->mComponents) {
+ MOZ_ASSERT(transport->mIce);
+ CSFLogDebug(logTag, "Transport %u is active", static_cast<unsigned>(i));
+ ufrag = transport->mIce->GetUfrag();
+ pwd = transport->mIce->GetPassword();
+ candidates = transport->mIce->GetCandidates();
+ } else {
+ CSFLogDebug(logTag, "Transport %u is disabled", static_cast<unsigned>(i));
+ // Make sure the MediaPipelineFactory doesn't try to use these.
+ RemoveTransportFlow(i, false);
+ RemoveTransportFlow(i, true);
+ }
+
+ RUN_ON_THREAD(
+ GetSTSThread(),
+ WrapRunnable(RefPtr<PeerConnectionMedia>(this),
+ &PeerConnectionMedia::ActivateOrRemoveTransport_s,
+ i,
+ transport->mComponents,
+ ufrag,
+ pwd,
+ candidates),
+ NS_DISPATCH_NORMAL);
+ }
+
+ // We can have more streams than m-lines due to rollback.
+ RUN_ON_THREAD(
+ GetSTSThread(),
+ WrapRunnable(RefPtr<PeerConnectionMedia>(this),
+ &PeerConnectionMedia::RemoveTransportsAtOrAfter_s,
+ transports.size()),
+ NS_DISPATCH_NORMAL);
+}
+
+void
+PeerConnectionMedia::ActivateOrRemoveTransport_s(
+ size_t aMLine,
+ size_t aComponentCount,
+ const std::string& aUfrag,
+ const std::string& aPassword,
+ const std::vector<std::string>& aCandidateList) {
+
+ if (!aComponentCount) {
+ CSFLogDebug(logTag, "%s: Removing ICE media stream=%u",
+ mParentHandle.c_str(),
+ static_cast<unsigned>(aMLine));
+ mIceCtxHdlr->ctx()->SetStream(aMLine, nullptr);
+ return;
+ }
+
+ RefPtr<NrIceMediaStream> stream(mIceCtxHdlr->ctx()->GetStream(aMLine));
+ if (!stream) {
+ MOZ_ASSERT(false);
+ return;
+ }
+
+ if (!stream->HasParsedAttributes()) {
+ CSFLogDebug(logTag, "%s: Activating ICE media stream=%u components=%u",
+ mParentHandle.c_str(),
+ static_cast<unsigned>(aMLine),
+ static_cast<unsigned>(aComponentCount));
+
+ std::vector<std::string> attrs;
+ for (auto i = aCandidateList.begin(); i != aCandidateList.end(); ++i) {
+ attrs.push_back("candidate:" + *i);
+ }
+ attrs.push_back("ice-ufrag:" + aUfrag);
+ attrs.push_back("ice-pwd:" + aPassword);
+
+ nsresult rv = stream->ParseAttributes(attrs);
+ if (NS_FAILED(rv)) {
+ CSFLogError(logTag, "Couldn't parse ICE attributes, rv=%u",
+ static_cast<unsigned>(rv));
+ }
+
+ for (size_t c = aComponentCount; c < stream->components(); ++c) {
+ // components are 1-indexed
+ stream->DisableComponent(c + 1);
+ }
+ }
+}
+
+void
+PeerConnectionMedia::RemoveTransportsAtOrAfter_s(size_t aMLine)
+{
+ for (size_t i = aMLine; i < mIceCtxHdlr->ctx()->GetStreamCount(); ++i) {
+ mIceCtxHdlr->ctx()->SetStream(i, nullptr);
+ }
+}
+
+nsresult PeerConnectionMedia::UpdateMediaPipelines(
+ const JsepSession& session) {
+ auto trackPairs = session.GetNegotiatedTrackPairs();
+ MediaPipelineFactory factory(this);
+ nsresult rv;
+
+ for (auto i = trackPairs.begin(); i != trackPairs.end(); ++i) {
+ JsepTrackPair pair = *i;
+
+ if (pair.mReceiving) {
+ rv = factory.CreateOrUpdateMediaPipeline(pair, *pair.mReceiving);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ }
+
+ if (pair.mSending) {
+ rv = factory.CreateOrUpdateMediaPipeline(pair, *pair.mSending);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ }
+ }
+
+ for (auto& stream : mRemoteSourceStreams) {
+ stream->StartReceiving();
+ }
+
+ return NS_OK;
+}
+
+void
+PeerConnectionMedia::StartIceChecks(const JsepSession& aSession)
+{
+ nsCOMPtr<nsIRunnable> runnable(
+ WrapRunnable(
+ RefPtr<PeerConnectionMedia>(this),
+ &PeerConnectionMedia::StartIceChecks_s,
+ aSession.IsIceControlling(),
+ aSession.RemoteIsIceLite(),
+ // Copy, just in case API changes to return a ref
+ std::vector<std::string>(aSession.GetIceOptions())));
+
+ PerformOrEnqueueIceCtxOperation(runnable);
+}
+
+void
+PeerConnectionMedia::StartIceChecks_s(
+ bool aIsControlling,
+ bool aIsIceLite,
+ const std::vector<std::string>& aIceOptionsList) {
+
+ CSFLogDebug(logTag, "Starting ICE Checking");
+
+ std::vector<std::string> attributes;
+ if (aIsIceLite) {
+ attributes.push_back("ice-lite");
+ }
+
+ if (!aIceOptionsList.empty()) {
+ attributes.push_back("ice-options:");
+ for (auto i = aIceOptionsList.begin(); i != aIceOptionsList.end(); ++i) {
+ attributes.back() += *i + ' ';
+ }
+ }
+
+ nsresult rv = mIceCtxHdlr->ctx()->ParseGlobalAttributes(attributes);
+ if (NS_FAILED(rv)) {
+ CSFLogError(logTag, "%s: couldn't parse global parameters", __FUNCTION__ );
+ }
+
+ mIceCtxHdlr->ctx()->SetControlling(aIsControlling ?
+ NrIceCtx::ICE_CONTROLLING :
+ NrIceCtx::ICE_CONTROLLED);
+
+ mIceCtxHdlr->ctx()->StartChecks();
+}
+
+bool
+PeerConnectionMedia::IsIceRestarting() const
+{
+ ASSERT_ON_THREAD(mMainThread);
+
+ return (mIceRestartState != ICE_RESTART_NONE);
+}
+
+PeerConnectionMedia::IceRestartState
+PeerConnectionMedia::GetIceRestartState() const
+{
+ ASSERT_ON_THREAD(mMainThread);
+
+ return mIceRestartState;
+}
+
+void
+PeerConnectionMedia::BeginIceRestart(const std::string& ufrag,
+ const std::string& pwd)
+{
+ ASSERT_ON_THREAD(mMainThread);
+ if (IsIceRestarting()) {
+ return;
+ }
+
+ RefPtr<NrIceCtx> new_ctx = mIceCtxHdlr->CreateCtx(ufrag, pwd);
+
+ RUN_ON_THREAD(GetSTSThread(),
+ WrapRunnable(
+ RefPtr<PeerConnectionMedia>(this),
+ &PeerConnectionMedia::BeginIceRestart_s,
+ new_ctx),
+ NS_DISPATCH_NORMAL);
+
+ mIceRestartState = ICE_RESTART_PROVISIONAL;
+}
+
+void
+PeerConnectionMedia::BeginIceRestart_s(RefPtr<NrIceCtx> new_ctx)
+{
+ ASSERT_ON_THREAD(mSTSThread);
+
+ // hold the original context so we can disconnect signals if needed
+ RefPtr<NrIceCtx> originalCtx = mIceCtxHdlr->ctx();
+
+ if (mIceCtxHdlr->BeginIceRestart(new_ctx)) {
+ ConnectSignals(mIceCtxHdlr->ctx().get(), originalCtx.get());
+ }
+}
+
+void
+PeerConnectionMedia::CommitIceRestart()
+{
+ ASSERT_ON_THREAD(mMainThread);
+ if (mIceRestartState != ICE_RESTART_PROVISIONAL) {
+ return;
+ }
+
+ mIceRestartState = ICE_RESTART_COMMITTED;
+}
+
+void
+PeerConnectionMedia::FinalizeIceRestart()
+{
+ ASSERT_ON_THREAD(mMainThread);
+ if (!IsIceRestarting()) {
+ return;
+ }
+
+ RUN_ON_THREAD(GetSTSThread(),
+ WrapRunnable(
+ RefPtr<PeerConnectionMedia>(this),
+ &PeerConnectionMedia::FinalizeIceRestart_s),
+ NS_DISPATCH_NORMAL);
+
+ mIceRestartState = ICE_RESTART_NONE;
+}
+
+void
+PeerConnectionMedia::FinalizeIceRestart_s()
+{
+ ASSERT_ON_THREAD(mSTSThread);
+
+ // reset old streams since we don't need them anymore
+ for (auto i = mTransportFlows.begin();
+ i != mTransportFlows.end();
+ ++i) {
+ RefPtr<TransportFlow> aFlow = i->second;
+ if (!aFlow) continue;
+ TransportLayerIce* ice =
+ static_cast<TransportLayerIce*>(aFlow->GetLayer(TransportLayerIce::ID()));
+ ice->ResetOldStream();
+ }
+
+ mIceCtxHdlr->FinalizeIceRestart();
+}
+
+void
+PeerConnectionMedia::RollbackIceRestart()
+{
+ ASSERT_ON_THREAD(mMainThread);
+ if (mIceRestartState != ICE_RESTART_PROVISIONAL) {
+ return;
+ }
+
+ RUN_ON_THREAD(GetSTSThread(),
+ WrapRunnable(
+ RefPtr<PeerConnectionMedia>(this),
+ &PeerConnectionMedia::RollbackIceRestart_s),
+ NS_DISPATCH_NORMAL);
+
+ mIceRestartState = ICE_RESTART_NONE;
+}
+
+void
+PeerConnectionMedia::RollbackIceRestart_s()
+{
+ ASSERT_ON_THREAD(mSTSThread);
+
+ // hold the restart context so we can disconnect signals
+ RefPtr<NrIceCtx> restartCtx = mIceCtxHdlr->ctx();
+
+ // restore old streams since we're rolling back
+ for (auto i = mTransportFlows.begin();
+ i != mTransportFlows.end();
+ ++i) {
+ RefPtr<TransportFlow> aFlow = i->second;
+ if (!aFlow) continue;
+ TransportLayerIce* ice =
+ static_cast<TransportLayerIce*>(aFlow->GetLayer(TransportLayerIce::ID()));
+ ice->RestoreOldStream();
+ }
+
+ mIceCtxHdlr->RollbackIceRestart();
+ ConnectSignals(mIceCtxHdlr->ctx().get(), restartCtx.get());
+}
+
+bool
+PeerConnectionMedia::GetPrefDefaultAddressOnly() const
+{
+ ASSERT_ON_THREAD(mMainThread); // will crash on STS thread
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ uint64_t winId = mParent->GetWindow()->WindowID();
+
+ bool default_address_only = Preferences::GetBool(
+ "media.peerconnection.ice.default_address_only", false);
+ default_address_only |=
+ !MediaManager::Get()->IsActivelyCapturingOrHasAPermission(winId);
+#else
+ bool default_address_only = true;
+#endif
+ return default_address_only;
+}
+
+bool
+PeerConnectionMedia::GetPrefProxyOnly() const
+{
+ ASSERT_ON_THREAD(mMainThread); // will crash on STS thread
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ return Preferences::GetBool("media.peerconnection.ice.proxy_only", false);
+#else
+ return false;
+#endif
+}
+
+void
+PeerConnectionMedia::ConnectSignals(NrIceCtx *aCtx, NrIceCtx *aOldCtx)
+{
+ aCtx->SignalGatheringStateChange.connect(
+ this,
+ &PeerConnectionMedia::IceGatheringStateChange_s);
+ aCtx->SignalConnectionStateChange.connect(
+ this,
+ &PeerConnectionMedia::IceConnectionStateChange_s);
+
+ if (aOldCtx) {
+ MOZ_ASSERT(aCtx != aOldCtx);
+ aOldCtx->SignalGatheringStateChange.disconnect(this);
+ aOldCtx->SignalConnectionStateChange.disconnect(this);
+
+ // if the old and new connection state and/or gathering state is
+ // different fire the state update. Note: we don't fire the update
+ // if the state is *INIT since updates for the INIT state aren't
+ // sent during the normal flow. (mjf)
+ if (aOldCtx->connection_state() != aCtx->connection_state() &&
+ aCtx->connection_state() != NrIceCtx::ICE_CTX_INIT) {
+ aCtx->SignalConnectionStateChange(aCtx, aCtx->connection_state());
+ }
+
+ if (aOldCtx->gathering_state() != aCtx->gathering_state() &&
+ aCtx->gathering_state() != NrIceCtx::ICE_CTX_GATHER_INIT) {
+ aCtx->SignalGatheringStateChange(aCtx, aCtx->gathering_state());
+ }
+ }
+}
+
+void
+PeerConnectionMedia::AddIceCandidate(const std::string& candidate,
+ const std::string& mid,
+ uint32_t aMLine) {
+ RUN_ON_THREAD(GetSTSThread(),
+ WrapRunnable(
+ RefPtr<PeerConnectionMedia>(this),
+ &PeerConnectionMedia::AddIceCandidate_s,
+ std::string(candidate), // Make copies.
+ std::string(mid),
+ aMLine),
+ NS_DISPATCH_NORMAL);
+}
+void
+PeerConnectionMedia::AddIceCandidate_s(const std::string& aCandidate,
+ const std::string& aMid,
+ uint32_t aMLine) {
+ RefPtr<NrIceMediaStream> stream(mIceCtxHdlr->ctx()->GetStream(aMLine));
+ if (!stream) {
+ CSFLogError(logTag, "No ICE stream for candidate at level %u: %s",
+ static_cast<unsigned>(aMLine), aCandidate.c_str());
+ return;
+ }
+
+ nsresult rv = stream->ParseTrickleCandidate(aCandidate);
+ if (NS_FAILED(rv)) {
+ CSFLogError(logTag, "Couldn't process ICE candidate at level %u",
+ static_cast<unsigned>(aMLine));
+ return;
+ }
+}
+
+void
+PeerConnectionMedia::FlushIceCtxOperationQueueIfReady()
+{
+ ASSERT_ON_THREAD(mMainThread);
+
+ if (IsIceCtxReady()) {
+ for (auto i = mQueuedIceCtxOperations.begin();
+ i != mQueuedIceCtxOperations.end();
+ ++i) {
+ GetSTSThread()->Dispatch(*i, NS_DISPATCH_NORMAL);
+ }
+ mQueuedIceCtxOperations.clear();
+ }
+}
+
+void
+PeerConnectionMedia::PerformOrEnqueueIceCtxOperation(nsIRunnable* runnable)
+{
+ ASSERT_ON_THREAD(mMainThread);
+
+ if (IsIceCtxReady()) {
+ GetSTSThread()->Dispatch(runnable, NS_DISPATCH_NORMAL);
+ } else {
+ mQueuedIceCtxOperations.push_back(runnable);
+ }
+}
+
+void
+PeerConnectionMedia::GatherIfReady() {
+ ASSERT_ON_THREAD(mMainThread);
+
+ nsCOMPtr<nsIRunnable> runnable(WrapRunnable(
+ RefPtr<PeerConnectionMedia>(this),
+ &PeerConnectionMedia::EnsureIceGathering_s,
+ GetPrefDefaultAddressOnly(),
+ GetPrefProxyOnly()));
+
+ PerformOrEnqueueIceCtxOperation(runnable);
+}
+
+void
+PeerConnectionMedia::EnsureIceGathering_s(bool aDefaultRouteOnly,
+ bool aProxyOnly) {
+ if (mProxyServer) {
+ mIceCtxHdlr->ctx()->SetProxyServer(*mProxyServer);
+ } else if (aProxyOnly) {
+ IceGatheringStateChange_s(mIceCtxHdlr->ctx().get(),
+ NrIceCtx::ICE_CTX_GATHER_COMPLETE);
+ return;
+ }
+
+ // Start gathering, but only if there are streams
+ for (size_t i = 0; i < mIceCtxHdlr->ctx()->GetStreamCount(); ++i) {
+ if (mIceCtxHdlr->ctx()->GetStream(i)) {
+ mIceCtxHdlr->ctx()->StartGathering(aDefaultRouteOnly, aProxyOnly);
+ return;
+ }
+ }
+
+ // If there are no streams, we're probably in a situation where we've rolled
+ // back while still waiting for our proxy configuration to come back. Make
+ // sure content knows that the rollback has stuck wrt gathering.
+ IceGatheringStateChange_s(mIceCtxHdlr->ctx().get(),
+ NrIceCtx::ICE_CTX_GATHER_COMPLETE);
+}
+
+nsresult
+PeerConnectionMedia::AddTrack(DOMMediaStream& aMediaStream,
+ const std::string& streamId,
+ MediaStreamTrack& aTrack,
+ const std::string& trackId)
+{
+ ASSERT_ON_THREAD(mMainThread);
+
+ CSFLogDebug(logTag, "%s: MediaStream: %p", __FUNCTION__, &aMediaStream);
+
+ RefPtr<LocalSourceStreamInfo> localSourceStream =
+ GetLocalStreamById(streamId);
+
+ if (!localSourceStream) {
+ localSourceStream = new LocalSourceStreamInfo(&aMediaStream, this, streamId);
+ mLocalSourceStreams.AppendElement(localSourceStream);
+ }
+
+ localSourceStream->AddTrack(trackId, &aTrack);
+ return NS_OK;
+}
+
+nsresult
+PeerConnectionMedia::RemoveLocalTrack(const std::string& streamId,
+ const std::string& trackId)
+{
+ ASSERT_ON_THREAD(mMainThread);
+
+ CSFLogDebug(logTag, "%s: stream: %s track: %s", __FUNCTION__,
+ streamId.c_str(), trackId.c_str());
+
+ RefPtr<LocalSourceStreamInfo> localSourceStream =
+ GetLocalStreamById(streamId);
+ if (!localSourceStream) {
+ return NS_ERROR_ILLEGAL_VALUE;
+ }
+
+ localSourceStream->RemoveTrack(trackId);
+ if (!localSourceStream->GetTrackCount()) {
+ mLocalSourceStreams.RemoveElement(localSourceStream);
+ }
+ return NS_OK;
+}
+
+nsresult
+PeerConnectionMedia::RemoveRemoteTrack(const std::string& streamId,
+ const std::string& trackId)
+{
+ ASSERT_ON_THREAD(mMainThread);
+
+ CSFLogDebug(logTag, "%s: stream: %s track: %s", __FUNCTION__,
+ streamId.c_str(), trackId.c_str());
+
+ RefPtr<RemoteSourceStreamInfo> remoteSourceStream =
+ GetRemoteStreamById(streamId);
+ if (!remoteSourceStream) {
+ return NS_ERROR_ILLEGAL_VALUE;
+ }
+
+ remoteSourceStream->RemoveTrack(trackId);
+ if (!remoteSourceStream->GetTrackCount()) {
+ mRemoteSourceStreams.RemoveElement(remoteSourceStream);
+ }
+ return NS_OK;
+}
+
+void
+PeerConnectionMedia::SelfDestruct()
+{
+ ASSERT_ON_THREAD(mMainThread);
+
+ CSFLogDebug(logTag, "%s: ", __FUNCTION__);
+
+ // Shut down the media
+ for (uint32_t i=0; i < mLocalSourceStreams.Length(); ++i) {
+ mLocalSourceStreams[i]->DetachMedia_m();
+ }
+
+ for (uint32_t i=0; i < mRemoteSourceStreams.Length(); ++i) {
+ mRemoteSourceStreams[i]->DetachMedia_m();
+ }
+
+ if (mProxyRequest) {
+ mProxyRequest->Cancel(NS_ERROR_ABORT);
+ mProxyRequest = nullptr;
+ }
+
+ // Shutdown the transport (async)
+ RUN_ON_THREAD(mSTSThread, WrapRunnable(
+ this, &PeerConnectionMedia::ShutdownMediaTransport_s),
+ NS_DISPATCH_NORMAL);
+
+ CSFLogDebug(logTag, "%s: Media shut down", __FUNCTION__);
+}
+
+void
+PeerConnectionMedia::SelfDestruct_m()
+{
+ CSFLogDebug(logTag, "%s: ", __FUNCTION__);
+
+ ASSERT_ON_THREAD(mMainThread);
+
+ mLocalSourceStreams.Clear();
+ mRemoteSourceStreams.Clear();
+
+ mMainThread = nullptr;
+
+ // Final self-destruct.
+ this->Release();
+}
+
+void
+PeerConnectionMedia::ShutdownMediaTransport_s()
+{
+ ASSERT_ON_THREAD(mSTSThread);
+
+ CSFLogDebug(logTag, "%s: ", __FUNCTION__);
+
+ // Here we access m{Local|Remote}SourceStreams off the main thread.
+ // That's OK because by here PeerConnectionImpl has forgotten about us,
+ // so there is no chance of getting a call in here from outside.
+ // The dispatches from SelfDestruct() and to SelfDestruct_m() provide
+ // memory barriers that protect us from badness.
+ for (uint32_t i=0; i < mLocalSourceStreams.Length(); ++i) {
+ mLocalSourceStreams[i]->DetachTransport_s();
+ }
+
+ for (uint32_t i=0; i < mRemoteSourceStreams.Length(); ++i) {
+ mRemoteSourceStreams[i]->DetachTransport_s();
+ }
+
+ disconnect_all();
+ mTransportFlows.clear();
+ mIceCtxHdlr = nullptr;
+
+ mMainThread->Dispatch(WrapRunnable(this, &PeerConnectionMedia::SelfDestruct_m),
+ NS_DISPATCH_NORMAL);
+}
+
+LocalSourceStreamInfo*
+PeerConnectionMedia::GetLocalStreamByIndex(int aIndex)
+{
+ ASSERT_ON_THREAD(mMainThread);
+ if(aIndex < 0 || aIndex >= (int) mLocalSourceStreams.Length()) {
+ return nullptr;
+ }
+
+ MOZ_ASSERT(mLocalSourceStreams[aIndex]);
+ return mLocalSourceStreams[aIndex];
+}
+
+LocalSourceStreamInfo*
+PeerConnectionMedia::GetLocalStreamById(const std::string& id)
+{
+ ASSERT_ON_THREAD(mMainThread);
+ for (size_t i = 0; i < mLocalSourceStreams.Length(); ++i) {
+ if (id == mLocalSourceStreams[i]->GetId()) {
+ return mLocalSourceStreams[i];
+ }
+ }
+
+ return nullptr;
+}
+
+LocalSourceStreamInfo*
+PeerConnectionMedia::GetLocalStreamByTrackId(const std::string& id)
+{
+ ASSERT_ON_THREAD(mMainThread);
+ for (RefPtr<LocalSourceStreamInfo>& info : mLocalSourceStreams) {
+ if (info->HasTrack(id)) {
+ return info;
+ }
+ }
+
+ return nullptr;
+}
+
+RemoteSourceStreamInfo*
+PeerConnectionMedia::GetRemoteStreamByIndex(size_t aIndex)
+{
+ ASSERT_ON_THREAD(mMainThread);
+ MOZ_ASSERT(mRemoteSourceStreams.SafeElementAt(aIndex));
+ return mRemoteSourceStreams.SafeElementAt(aIndex);
+}
+
+RemoteSourceStreamInfo*
+PeerConnectionMedia::GetRemoteStreamById(const std::string& id)
+{
+ ASSERT_ON_THREAD(mMainThread);
+ for (size_t i = 0; i < mRemoteSourceStreams.Length(); ++i) {
+ if (id == mRemoteSourceStreams[i]->GetId()) {
+ return mRemoteSourceStreams[i];
+ }
+ }
+
+ return nullptr;
+}
+
+RemoteSourceStreamInfo*
+PeerConnectionMedia::GetRemoteStreamByTrackId(const std::string& id)
+{
+ ASSERT_ON_THREAD(mMainThread);
+ for (RefPtr<RemoteSourceStreamInfo>& info : mRemoteSourceStreams) {
+ if (info->HasTrack(id)) {
+ return info;
+ }
+ }
+
+ return nullptr;
+}
+
+
+nsresult
+PeerConnectionMedia::AddRemoteStream(RefPtr<RemoteSourceStreamInfo> aInfo)
+{
+ ASSERT_ON_THREAD(mMainThread);
+
+ mRemoteSourceStreams.AppendElement(aInfo);
+
+ return NS_OK;
+}
+
+void
+PeerConnectionMedia::IceGatheringStateChange_s(NrIceCtx* ctx,
+ NrIceCtx::GatheringState state)
+{
+ ASSERT_ON_THREAD(mSTSThread);
+
+ if (state == NrIceCtx::ICE_CTX_GATHER_COMPLETE) {
+ // Fire off EndOfLocalCandidates for each stream
+ for (size_t i = 0; ; ++i) {
+ RefPtr<NrIceMediaStream> stream(ctx->GetStream(i));
+ if (!stream) {
+ break;
+ }
+
+ NrIceCandidate candidate;
+ NrIceCandidate rtcpCandidate;
+ GetDefaultCandidates(*stream, &candidate, &rtcpCandidate);
+ EndOfLocalCandidates(candidate.cand_addr.host,
+ candidate.cand_addr.port,
+ rtcpCandidate.cand_addr.host,
+ rtcpCandidate.cand_addr.port,
+ i);
+ }
+ }
+
+ // ShutdownMediaTransport_s has not run yet because it unhooks this function
+ // from its signal, which means that SelfDestruct_m has not been dispatched
+ // yet either, so this PCMedia will still be around when this dispatch reaches
+ // main.
+ GetMainThread()->Dispatch(
+ WrapRunnable(this,
+ &PeerConnectionMedia::IceGatheringStateChange_m,
+ ctx,
+ state),
+ NS_DISPATCH_NORMAL);
+}
+
+void
+PeerConnectionMedia::IceConnectionStateChange_s(NrIceCtx* ctx,
+ NrIceCtx::ConnectionState state)
+{
+ ASSERT_ON_THREAD(mSTSThread);
+ // ShutdownMediaTransport_s has not run yet because it unhooks this function
+ // from its signal, which means that SelfDestruct_m has not been dispatched
+ // yet either, so this PCMedia will still be around when this dispatch reaches
+ // main.
+ GetMainThread()->Dispatch(
+ WrapRunnable(this,
+ &PeerConnectionMedia::IceConnectionStateChange_m,
+ ctx,
+ state),
+ NS_DISPATCH_NORMAL);
+}
+
+void
+PeerConnectionMedia::OnCandidateFound_s(NrIceMediaStream *aStream,
+ const std::string &aCandidateLine)
+{
+ ASSERT_ON_THREAD(mSTSThread);
+ MOZ_ASSERT(aStream);
+ MOZ_RELEASE_ASSERT(mIceCtxHdlr);
+
+ CSFLogDebug(logTag, "%s: %s", __FUNCTION__, aStream->name().c_str());
+
+ NrIceCandidate candidate;
+ NrIceCandidate rtcpCandidate;
+ GetDefaultCandidates(*aStream, &candidate, &rtcpCandidate);
+
+ // ShutdownMediaTransport_s has not run yet because it unhooks this function
+ // from its signal, which means that SelfDestruct_m has not been dispatched
+ // yet either, so this PCMedia will still be around when this dispatch reaches
+ // main.
+ GetMainThread()->Dispatch(
+ WrapRunnable(this,
+ &PeerConnectionMedia::OnCandidateFound_m,
+ aCandidateLine,
+ candidate.cand_addr.host,
+ candidate.cand_addr.port,
+ rtcpCandidate.cand_addr.host,
+ rtcpCandidate.cand_addr.port,
+ aStream->GetLevel()),
+ NS_DISPATCH_NORMAL);
+}
+
+void
+PeerConnectionMedia::EndOfLocalCandidates(const std::string& aDefaultAddr,
+ uint16_t aDefaultPort,
+ const std::string& aDefaultRtcpAddr,
+ uint16_t aDefaultRtcpPort,
+ uint16_t aMLine)
+{
+ GetMainThread()->Dispatch(
+ WrapRunnable(this,
+ &PeerConnectionMedia::EndOfLocalCandidates_m,
+ aDefaultAddr,
+ aDefaultPort,
+ aDefaultRtcpAddr,
+ aDefaultRtcpPort,
+ aMLine),
+ NS_DISPATCH_NORMAL);
+}
+
+void
+PeerConnectionMedia::GetDefaultCandidates(const NrIceMediaStream& aStream,
+ NrIceCandidate* aCandidate,
+ NrIceCandidate* aRtcpCandidate)
+{
+ nsresult res = aStream.GetDefaultCandidate(1, aCandidate);
+ // Optional; component won't exist if doing rtcp-mux
+ if (NS_FAILED(aStream.GetDefaultCandidate(2, aRtcpCandidate))) {
+ aRtcpCandidate->cand_addr.host.clear();
+ aRtcpCandidate->cand_addr.port = 0;
+ }
+ if (NS_FAILED(res)) {
+ aCandidate->cand_addr.host.clear();
+ aCandidate->cand_addr.port = 0;
+ CSFLogError(logTag, "%s: GetDefaultCandidates failed for level %u, "
+ "res=%u",
+ __FUNCTION__,
+ static_cast<unsigned>(aStream.GetLevel()),
+ static_cast<unsigned>(res));
+ }
+}
+
+void
+PeerConnectionMedia::IceGatheringStateChange_m(NrIceCtx* ctx,
+ NrIceCtx::GatheringState state)
+{
+ ASSERT_ON_THREAD(mMainThread);
+ SignalIceGatheringStateChange(ctx, state);
+}
+
+void
+PeerConnectionMedia::IceConnectionStateChange_m(NrIceCtx* ctx,
+ NrIceCtx::ConnectionState state)
+{
+ ASSERT_ON_THREAD(mMainThread);
+ SignalIceConnectionStateChange(ctx, state);
+}
+
+void
+PeerConnectionMedia::IceStreamReady_s(NrIceMediaStream *aStream)
+{
+ MOZ_ASSERT(aStream);
+
+ CSFLogDebug(logTag, "%s: %s", __FUNCTION__, aStream->name().c_str());
+}
+
+void
+PeerConnectionMedia::OnCandidateFound_m(const std::string& aCandidateLine,
+ const std::string& aDefaultAddr,
+ uint16_t aDefaultPort,
+ const std::string& aDefaultRtcpAddr,
+ uint16_t aDefaultRtcpPort,
+ uint16_t aMLine)
+{
+ ASSERT_ON_THREAD(mMainThread);
+ if (!aDefaultAddr.empty()) {
+ SignalUpdateDefaultCandidate(aDefaultAddr,
+ aDefaultPort,
+ aDefaultRtcpAddr,
+ aDefaultRtcpPort,
+ aMLine);
+ }
+ SignalCandidate(aCandidateLine, aMLine);
+}
+
+void
+PeerConnectionMedia::EndOfLocalCandidates_m(const std::string& aDefaultAddr,
+ uint16_t aDefaultPort,
+ const std::string& aDefaultRtcpAddr,
+ uint16_t aDefaultRtcpPort,
+ uint16_t aMLine) {
+ ASSERT_ON_THREAD(mMainThread);
+ if (!aDefaultAddr.empty()) {
+ SignalUpdateDefaultCandidate(aDefaultAddr,
+ aDefaultPort,
+ aDefaultRtcpAddr,
+ aDefaultRtcpPort,
+ aMLine);
+ }
+ SignalEndOfLocalCandidates(aMLine);
+}
+
+void
+PeerConnectionMedia::DtlsConnected_s(TransportLayer *layer,
+ TransportLayer::State state)
+{
+ MOZ_ASSERT(layer->id() == "dtls");
+ TransportLayerDtls* dtlsLayer = static_cast<TransportLayerDtls*>(layer);
+ dtlsLayer->SignalStateChange.disconnect(this);
+
+ bool privacyRequested = (dtlsLayer->GetNegotiatedAlpn() == "c-webrtc");
+ GetMainThread()->Dispatch(
+ WrapRunnableNM(&PeerConnectionMedia::DtlsConnected_m,
+ mParentHandle, privacyRequested),
+ NS_DISPATCH_NORMAL);
+}
+
+void
+PeerConnectionMedia::DtlsConnected_m(const std::string& aParentHandle,
+ bool aPrivacyRequested)
+{
+ PeerConnectionWrapper pcWrapper(aParentHandle);
+ PeerConnectionImpl* pc = pcWrapper.impl();
+ if (pc) {
+ pc->SetDtlsConnected(aPrivacyRequested);
+ }
+}
+
+void
+PeerConnectionMedia::AddTransportFlow(int aIndex, bool aRtcp,
+ const RefPtr<TransportFlow> &aFlow)
+{
+ int index_inner = GetTransportFlowIndex(aIndex, aRtcp);
+
+ MOZ_ASSERT(!mTransportFlows[index_inner]);
+ mTransportFlows[index_inner] = aFlow;
+
+ GetSTSThread()->Dispatch(
+ WrapRunnable(this, &PeerConnectionMedia::ConnectDtlsListener_s, aFlow),
+ NS_DISPATCH_NORMAL);
+}
+
+void
+PeerConnectionMedia::RemoveTransportFlow(int aIndex, bool aRtcp)
+{
+ int index_inner = GetTransportFlowIndex(aIndex, aRtcp);
+ NS_ProxyRelease(GetSTSThread(), mTransportFlows[index_inner].forget());
+}
+
+void
+PeerConnectionMedia::ConnectDtlsListener_s(const RefPtr<TransportFlow>& aFlow)
+{
+ TransportLayer* dtls = aFlow->GetLayer(TransportLayerDtls::ID());
+ if (dtls) {
+ dtls->SignalStateChange.connect(this, &PeerConnectionMedia::DtlsConnected_s);
+ }
+}
+
+nsresult
+LocalSourceStreamInfo::TakePipelineFrom(RefPtr<LocalSourceStreamInfo>& info,
+ const std::string& oldTrackId,
+ MediaStreamTrack& aNewTrack,
+ const std::string& newTrackId)
+{
+ if (mPipelines.count(newTrackId)) {
+ CSFLogError(logTag, "%s: Pipeline already exists for %s/%s",
+ __FUNCTION__, mId.c_str(), newTrackId.c_str());
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ RefPtr<MediaPipeline> pipeline(info->ForgetPipelineByTrackId_m(oldTrackId));
+
+ if (!pipeline) {
+ // Replacetrack can potentially happen in the middle of offer/answer, before
+ // the pipeline has been created.
+ CSFLogInfo(logTag, "%s: Replacing track before the pipeline has been "
+ "created, nothing to do.", __FUNCTION__);
+ return NS_OK;
+ }
+
+ nsresult rv =
+ static_cast<MediaPipelineTransmit*>(pipeline.get())->ReplaceTrack(aNewTrack);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ mPipelines[newTrackId] = pipeline;
+
+ return NS_OK;
+}
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+/**
+ * Tells you if any local track is isolated to a specific peer identity.
+ * Obviously, we want all the tracks to be isolated equally so that they can
+ * all be sent or not. We check once when we are setting a local description
+ * and that determines if we flip the "privacy requested" bit on. Once the bit
+ * is on, all media originating from this peer connection is isolated.
+ *
+ * @returns true if any track has a peerIdentity set on it
+ */
+bool
+PeerConnectionMedia::AnyLocalTrackHasPeerIdentity() const
+{
+ ASSERT_ON_THREAD(mMainThread);
+
+ for (uint32_t u = 0; u < mLocalSourceStreams.Length(); u++) {
+ for (auto pair : mLocalSourceStreams[u]->GetMediaStreamTracks()) {
+ if (pair.second->GetPeerIdentity() != nullptr) {
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+void
+PeerConnectionMedia::UpdateRemoteStreamPrincipals_m(nsIPrincipal* aPrincipal)
+{
+ ASSERT_ON_THREAD(mMainThread);
+
+ for (uint32_t u = 0; u < mRemoteSourceStreams.Length(); u++) {
+ mRemoteSourceStreams[u]->UpdatePrincipal_m(aPrincipal);
+ }
+}
+
+void
+PeerConnectionMedia::UpdateSinkIdentity_m(MediaStreamTrack* aTrack,
+ nsIPrincipal* aPrincipal,
+ const PeerIdentity* aSinkIdentity)
+{
+ ASSERT_ON_THREAD(mMainThread);
+
+ for (uint32_t u = 0; u < mLocalSourceStreams.Length(); u++) {
+ mLocalSourceStreams[u]->UpdateSinkIdentity_m(aTrack, aPrincipal,
+ aSinkIdentity);
+ }
+}
+
+void
+LocalSourceStreamInfo::UpdateSinkIdentity_m(MediaStreamTrack* aTrack,
+ nsIPrincipal* aPrincipal,
+ const PeerIdentity* aSinkIdentity)
+{
+ for (auto it = mPipelines.begin(); it != mPipelines.end(); ++it) {
+ MediaPipelineTransmit* pipeline =
+ static_cast<MediaPipelineTransmit*>((*it).second.get());
+ pipeline->UpdateSinkIdentity_m(aTrack, aPrincipal, aSinkIdentity);
+ }
+}
+
+void RemoteSourceStreamInfo::UpdatePrincipal_m(nsIPrincipal* aPrincipal)
+{
+ // This blasts away the existing principal.
+ // We only do this when we become certain that the all tracks are safe to make
+ // accessible to the script principal.
+ for (auto& trackPair : mTracks) {
+ MOZ_RELEASE_ASSERT(trackPair.second);
+ RemoteTrackSource& source =
+ static_cast<RemoteTrackSource&>(trackPair.second->GetSource());
+ source.SetPrincipal(aPrincipal);
+
+ RefPtr<MediaPipeline> pipeline = GetPipelineByTrackId_m(trackPair.first);
+ if (pipeline) {
+ MOZ_ASSERT(pipeline->direction() == MediaPipeline::RECEIVE);
+ static_cast<MediaPipelineReceive*>(pipeline.get())
+ ->SetPrincipalHandle_m(MakePrincipalHandle(aPrincipal));
+ }
+ }
+}
+#endif // MOZILLA_INTERNAL_API
+
+bool
+PeerConnectionMedia::AnyCodecHasPluginID(uint64_t aPluginID)
+{
+ for (uint32_t i=0; i < mLocalSourceStreams.Length(); ++i) {
+ if (mLocalSourceStreams[i]->AnyCodecHasPluginID(aPluginID)) {
+ return true;
+ }
+ }
+ for (uint32_t i=0; i < mRemoteSourceStreams.Length(); ++i) {
+ if (mRemoteSourceStreams[i]->AnyCodecHasPluginID(aPluginID)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+bool
+SourceStreamInfo::AnyCodecHasPluginID(uint64_t aPluginID)
+{
+ // Scan the videoConduits for this plugin ID
+ for (auto it = mPipelines.begin(); it != mPipelines.end(); ++it) {
+ if (it->second->Conduit()->CodecPluginID() == aPluginID) {
+ return true;
+ }
+ }
+ return false;
+}
+
+nsresult
+SourceStreamInfo::StorePipeline(
+ const std::string& trackId,
+ const RefPtr<mozilla::MediaPipeline>& aPipeline)
+{
+ MOZ_ASSERT(mPipelines.find(trackId) == mPipelines.end());
+ if (mPipelines.find(trackId) != mPipelines.end()) {
+ CSFLogError(logTag, "%s: Storing duplicate track", __FUNCTION__);
+ return NS_ERROR_FAILURE;
+ }
+
+ mPipelines[trackId] = aPipeline;
+ return NS_OK;
+}
+
+void
+RemoteSourceStreamInfo::DetachMedia_m()
+{
+ for (auto& webrtcIdAndTrack : mTracks) {
+ EndTrack(mMediaStream->GetInputStream(), webrtcIdAndTrack.second);
+ }
+ SourceStreamInfo::DetachMedia_m();
+}
+
+void
+RemoteSourceStreamInfo::RemoveTrack(const std::string& trackId)
+{
+ auto it = mTracks.find(trackId);
+ if (it != mTracks.end()) {
+ EndTrack(mMediaStream->GetInputStream(), it->second);
+ }
+
+ SourceStreamInfo::RemoveTrack(trackId);
+}
+
+void
+RemoteSourceStreamInfo::SyncPipeline(
+ RefPtr<MediaPipelineReceive> aPipeline)
+{
+ // See if we have both audio and video here, and if so cross the streams and
+ // sync them
+ // TODO: Do we need to prevent multiple syncs if there is more than one audio
+ // or video track in a single media stream? What are we supposed to do in this
+ // case?
+ for (auto i = mPipelines.begin(); i != mPipelines.end(); ++i) {
+ if (i->second->IsVideo() != aPipeline->IsVideo()) {
+ // Ok, we have one video, one non-video - cross the streams!
+ WebrtcAudioConduit *audio_conduit =
+ static_cast<WebrtcAudioConduit*>(aPipeline->IsVideo() ?
+ i->second->Conduit() :
+ aPipeline->Conduit());
+ WebrtcVideoConduit *video_conduit =
+ static_cast<WebrtcVideoConduit*>(aPipeline->IsVideo() ?
+ aPipeline->Conduit() :
+ i->second->Conduit());
+ video_conduit->SyncTo(audio_conduit);
+ CSFLogDebug(logTag, "Syncing %p to %p, %s to %s",
+ video_conduit, audio_conduit,
+ i->first.c_str(), aPipeline->trackid().c_str());
+ }
+ }
+}
+
+void
+RemoteSourceStreamInfo::StartReceiving()
+{
+ if (mReceiving || mPipelines.empty()) {
+ return;
+ }
+
+ mReceiving = true;
+
+ SourceMediaStream* source = GetMediaStream()->GetInputStream()->AsSourceStream();
+ source->SetPullEnabled(true);
+ // AdvanceKnownTracksTicksTime(HEAT_DEATH_OF_UNIVERSE) means that in
+ // theory per the API, we can't add more tracks before that
+ // time. However, the impl actually allows it, and it avoids a whole
+ // bunch of locking that would be required (and potential blocking)
+ // if we used smaller values and updated them on each NotifyPull.
+ source->AdvanceKnownTracksTime(STREAM_TIME_MAX);
+ CSFLogDebug(logTag, "Finished adding tracks to MediaStream %p", source);
+}
+
+RefPtr<MediaPipeline> SourceStreamInfo::GetPipelineByTrackId_m(
+ const std::string& trackId) {
+ ASSERT_ON_THREAD(mParent->GetMainThread());
+
+ // Refuse to hand out references if we're tearing down.
+ // (Since teardown involves a dispatch to and from STS before MediaPipelines
+ // are released, it is safe to start other dispatches to and from STS with a
+ // RefPtr<MediaPipeline>, since that reference won't be the last one
+ // standing)
+ if (mMediaStream) {
+ if (mPipelines.count(trackId)) {
+ return mPipelines[trackId];
+ }
+ }
+
+ return nullptr;
+}
+
+already_AddRefed<MediaPipeline>
+LocalSourceStreamInfo::ForgetPipelineByTrackId_m(const std::string& trackId)
+{
+ ASSERT_ON_THREAD(mParent->GetMainThread());
+
+ // Refuse to hand out references if we're tearing down.
+ // (Since teardown involves a dispatch to and from STS before MediaPipelines
+ // are released, it is safe to start other dispatches to and from STS with a
+ // RefPtr<MediaPipeline>, since that reference won't be the last one
+ // standing)
+ if (mMediaStream) {
+ if (mPipelines.count(trackId)) {
+ RefPtr<MediaPipeline> pipeline(mPipelines[trackId]);
+ mPipelines.erase(trackId);
+ return pipeline.forget();
+ }
+ }
+
+ return nullptr;
+}
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+auto
+RemoteTrackSource::ApplyConstraints(
+ nsPIDOMWindowInner* aWindow,
+ const dom::MediaTrackConstraints& aConstraints) -> already_AddRefed<PledgeVoid>
+{
+ RefPtr<PledgeVoid> p = new PledgeVoid();
+ p->Reject(new dom::MediaStreamError(aWindow,
+ NS_LITERAL_STRING("OverconstrainedError"),
+ NS_LITERAL_STRING("")));
+ return p.forget();
+}
+#endif
+
+} // namespace mozilla
diff --git a/media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.h b/media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.h
new file mode 100644
index 000000000..c0001a5e5
--- /dev/null
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.h
@@ -0,0 +1,586 @@
+/* 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/. */
+
+#ifndef _PEER_CONNECTION_MEDIA_H_
+#define _PEER_CONNECTION_MEDIA_H_
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include "nspr.h"
+#include "prlock.h"
+
+#include "mozilla/RefPtr.h"
+#include "mozilla/UniquePtr.h"
+#include "nsComponentManagerUtils.h"
+#include "nsIProtocolProxyCallback.h"
+
+#include "signaling/src/jsep/JsepSession.h"
+#include "AudioSegment.h"
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+#include "Layers.h"
+#include "VideoUtils.h"
+#include "ImageLayers.h"
+#include "VideoSegment.h"
+#include "MediaStreamTrack.h"
+#endif
+
+class nsIPrincipal;
+
+namespace mozilla {
+class DataChannel;
+class PeerIdentity;
+class MediaPipelineFactory;
+namespace dom {
+struct RTCInboundRTPStreamStats;
+struct RTCOutboundRTPStreamStats;
+}
+}
+
+#include "nricectxhandler.h"
+#include "nriceresolver.h"
+#include "nricemediastream.h"
+#include "MediaPipeline.h"
+
+namespace mozilla {
+
+class PeerConnectionImpl;
+class PeerConnectionMedia;
+class PCUuidGenerator;
+
+class SourceStreamInfo {
+public:
+ SourceStreamInfo(DOMMediaStream* aMediaStream,
+ PeerConnectionMedia *aParent,
+ const std::string& aId)
+ : mMediaStream(aMediaStream),
+ mParent(aParent),
+ mId(aId) {
+ MOZ_ASSERT(mMediaStream);
+ }
+
+ SourceStreamInfo(already_AddRefed<DOMMediaStream>& aMediaStream,
+ PeerConnectionMedia *aParent,
+ const std::string& aId)
+ : mMediaStream(aMediaStream),
+ mParent(aParent),
+ mId(aId) {
+ MOZ_ASSERT(mMediaStream);
+ }
+
+ virtual ~SourceStreamInfo() {}
+
+ DOMMediaStream* GetMediaStream() const {
+ return mMediaStream;
+ }
+
+ nsresult StorePipeline(const std::string& trackId,
+ const RefPtr<MediaPipeline>& aPipeline);
+
+ virtual void AddTrack(const std::string& trackId,
+ const RefPtr<dom::MediaStreamTrack>& aTrack)
+ {
+ mTracks.insert(std::make_pair(trackId, aTrack));
+ }
+ virtual void RemoveTrack(const std::string& trackId);
+ bool HasTrack(const std::string& trackId) const
+ {
+ return !!mTracks.count(trackId);
+ }
+ size_t GetTrackCount() const { return mTracks.size(); }
+
+ // This method exists for stats and the unittests.
+ // It allows visibility into the pipelines and flows.
+ const std::map<std::string, RefPtr<MediaPipeline>>&
+ GetPipelines() const { return mPipelines; }
+ RefPtr<MediaPipeline> GetPipelineByTrackId_m(const std::string& trackId);
+ // This is needed so PeerConnectionImpl can unregister itself as
+ // PrincipalChangeObserver from each track.
+ const std::map<std::string, RefPtr<dom::MediaStreamTrack>>&
+ GetMediaStreamTracks() const { return mTracks; }
+ dom::MediaStreamTrack* GetTrackById(const std::string& trackId) const
+ {
+ auto it = mTracks.find(trackId);
+ if (it == mTracks.end()) {
+ return nullptr;
+ }
+
+ return it->second;
+ }
+ const std::string& GetId() const { return mId; }
+
+ void DetachTransport_s();
+ virtual void DetachMedia_m();
+ bool AnyCodecHasPluginID(uint64_t aPluginID);
+protected:
+ void EndTrack(MediaStream* stream, dom::MediaStreamTrack* track);
+ RefPtr<DOMMediaStream> mMediaStream;
+ PeerConnectionMedia *mParent;
+ const std::string mId;
+ // These get set up before we generate our local description, the pipelines
+ // and conduits are set up once offer/answer completes.
+ std::map<std::string, RefPtr<dom::MediaStreamTrack>> mTracks;
+ std::map<std::string, RefPtr<MediaPipeline>> mPipelines;
+};
+
+// TODO(ekr@rtfm.com): Refactor {Local,Remote}SourceStreamInfo
+// bug 837539.
+class LocalSourceStreamInfo : public SourceStreamInfo {
+ ~LocalSourceStreamInfo() {
+ mMediaStream = nullptr;
+ }
+public:
+ LocalSourceStreamInfo(DOMMediaStream *aMediaStream,
+ PeerConnectionMedia *aParent,
+ const std::string& aId)
+ : SourceStreamInfo(aMediaStream, aParent, aId) {}
+
+ nsresult TakePipelineFrom(RefPtr<LocalSourceStreamInfo>& info,
+ const std::string& oldTrackId,
+ dom::MediaStreamTrack& aNewTrack,
+ const std::string& newTrackId);
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ void UpdateSinkIdentity_m(dom::MediaStreamTrack* aTrack,
+ nsIPrincipal* aPrincipal,
+ const PeerIdentity* aSinkIdentity);
+#endif
+
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(LocalSourceStreamInfo)
+
+private:
+ already_AddRefed<MediaPipeline> ForgetPipelineByTrackId_m(
+ const std::string& trackId);
+};
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+class RemoteTrackSource : public dom::MediaStreamTrackSource
+{
+public:
+ explicit RemoteTrackSource(nsIPrincipal* aPrincipal, const nsString& aLabel)
+ : dom::MediaStreamTrackSource(aPrincipal, aLabel) {}
+
+ dom::MediaSourceEnum GetMediaSource() const override
+ {
+ return dom::MediaSourceEnum::Other;
+ }
+
+ already_AddRefed<PledgeVoid>
+ ApplyConstraints(nsPIDOMWindowInner* aWindow,
+ const dom::MediaTrackConstraints& aConstraints) override;
+
+ void Stop() override
+ {
+ // XXX (Bug 1314270): Implement rejection logic if necessary when we have
+ // clarity in the spec.
+ }
+
+ void SetPrincipal(nsIPrincipal* aPrincipal)
+ {
+ mPrincipal = aPrincipal;
+ PrincipalChanged();
+ }
+
+protected:
+ virtual ~RemoteTrackSource() {}
+};
+#endif
+
+class RemoteSourceStreamInfo : public SourceStreamInfo {
+ ~RemoteSourceStreamInfo() {}
+ public:
+ RemoteSourceStreamInfo(already_AddRefed<DOMMediaStream> aMediaStream,
+ PeerConnectionMedia *aParent,
+ const std::string& aId)
+ : SourceStreamInfo(aMediaStream, aParent, aId),
+ mReceiving(false)
+ {
+ }
+
+ void DetachMedia_m() override;
+ void RemoveTrack(const std::string& trackId) override;
+ void SyncPipeline(RefPtr<MediaPipelineReceive> aPipeline);
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ void UpdatePrincipal_m(nsIPrincipal* aPrincipal);
+#endif
+
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(RemoteSourceStreamInfo)
+
+ void AddTrack(const std::string& trackId,
+ const RefPtr<dom::MediaStreamTrack>& aTrack) override
+ {
+ SourceStreamInfo::AddTrack(trackId, aTrack);
+ }
+
+ TrackID GetNumericTrackId(const std::string& trackId) const
+ {
+ dom::MediaStreamTrack* track = GetTrackById(trackId);
+ if (!track) {
+ return TRACK_INVALID;
+ }
+ return track->mTrackID;
+ }
+
+ void StartReceiving();
+
+ private:
+ // True iff SetPullEnabled(true) has been called on the DOMMediaStream. This
+ // happens when offer/answer concludes.
+ bool mReceiving;
+};
+
+class PeerConnectionMedia : public sigslot::has_slots<> {
+ ~PeerConnectionMedia()
+ {
+ MOZ_RELEASE_ASSERT(!mMainThread);
+ }
+
+ public:
+ explicit PeerConnectionMedia(PeerConnectionImpl *parent);
+
+ enum IceRestartState { ICE_RESTART_NONE,
+ ICE_RESTART_PROVISIONAL,
+ ICE_RESTART_COMMITTED
+ };
+
+ PeerConnectionImpl* GetPC() { return mParent; }
+ nsresult Init(const std::vector<NrIceStunServer>& stun_servers,
+ const std::vector<NrIceTurnServer>& turn_servers,
+ NrIceCtx::Policy policy);
+ // WARNING: This destroys the object!
+ void SelfDestruct();
+
+ RefPtr<NrIceCtxHandler> ice_ctx_hdlr() const { return mIceCtxHdlr; }
+ RefPtr<NrIceCtx> ice_ctx() const { return mIceCtxHdlr->ctx(); }
+
+ RefPtr<NrIceMediaStream> ice_media_stream(size_t i) const {
+ return mIceCtxHdlr->ctx()->GetStream(i);
+ }
+
+ size_t num_ice_media_streams() const {
+ return mIceCtxHdlr->ctx()->GetStreamCount();
+ }
+
+ // Ensure ICE transports exist that we might need when offer/answer concludes
+ void EnsureTransports(const JsepSession& aSession);
+
+ // Activate or remove ICE transports at the conclusion of offer/answer,
+ // or when rollback occurs.
+ void ActivateOrRemoveTransports(const JsepSession& aSession);
+
+ // Start ICE checks.
+ void StartIceChecks(const JsepSession& session);
+
+ bool IsIceRestarting() const;
+ IceRestartState GetIceRestartState() const;
+
+ // Begin ICE restart
+ void BeginIceRestart(const std::string& ufrag,
+ const std::string& pwd);
+ // Commit ICE Restart - offer/answer complete, no rollback possible
+ void CommitIceRestart();
+ // Finalize ICE restart
+ void FinalizeIceRestart();
+ // Abort ICE restart
+ void RollbackIceRestart();
+
+ // Process a trickle ICE candidate.
+ void AddIceCandidate(const std::string& candidate, const std::string& mid,
+ uint32_t aMLine);
+
+ // Handle complete media pipelines.
+ nsresult UpdateMediaPipelines(const JsepSession& session);
+
+ // Add a track (main thread only)
+ nsresult AddTrack(DOMMediaStream& aMediaStream,
+ const std::string& streamId,
+ dom::MediaStreamTrack& aTrack,
+ const std::string& trackId);
+
+ nsresult RemoveLocalTrack(const std::string& streamId,
+ const std::string& trackId);
+ nsresult RemoveRemoteTrack(const std::string& streamId,
+ const std::string& trackId);
+
+ // Get a specific local stream
+ uint32_t LocalStreamsLength()
+ {
+ return mLocalSourceStreams.Length();
+ }
+ LocalSourceStreamInfo* GetLocalStreamByIndex(int index);
+ LocalSourceStreamInfo* GetLocalStreamById(const std::string& id);
+ LocalSourceStreamInfo* GetLocalStreamByTrackId(const std::string& id);
+
+ // Get a specific remote stream
+ uint32_t RemoteStreamsLength()
+ {
+ return mRemoteSourceStreams.Length();
+ }
+
+ RemoteSourceStreamInfo* GetRemoteStreamByIndex(size_t index);
+ RemoteSourceStreamInfo* GetRemoteStreamById(const std::string& id);
+ RemoteSourceStreamInfo* GetRemoteStreamByTrackId(const std::string& id);
+
+ // Add a remote stream.
+ nsresult AddRemoteStream(RefPtr<RemoteSourceStreamInfo> aInfo);
+
+ nsresult ReplaceTrack(const std::string& aOldStreamId,
+ const std::string& aOldTrackId,
+ dom::MediaStreamTrack& aNewTrack,
+ const std::string& aNewStreamId,
+ const std::string& aNewTrackId);
+
+#if !defined(MOZILLA_EXTERNAL_LINKAGE)
+ // In cases where the peer isn't yet identified, we disable the pipeline (not
+ // the stream, that would potentially affect others), so that it sends
+ // black/silence. Once the peer is identified, re-enable those streams.
+ // aTrack will be set if this update came from a principal change on aTrack.
+ void UpdateSinkIdentity_m(dom::MediaStreamTrack* aTrack,
+ nsIPrincipal* aPrincipal,
+ const PeerIdentity* aSinkIdentity);
+ // this determines if any track is peerIdentity constrained
+ bool AnyLocalTrackHasPeerIdentity() const;
+ // When we finally learn who is on the other end, we need to change the ownership
+ // on streams
+ void UpdateRemoteStreamPrincipals_m(nsIPrincipal* aPrincipal);
+#endif
+
+ bool AnyCodecHasPluginID(uint64_t aPluginID);
+
+ const nsCOMPtr<nsIThread>& GetMainThread() const { return mMainThread; }
+ const nsCOMPtr<nsIEventTarget>& GetSTSThread() const { return mSTSThread; }
+
+ static size_t GetTransportFlowIndex(int aStreamIndex, bool aRtcp)
+ {
+ return aStreamIndex * 2 + (aRtcp ? 1 : 0);
+ }
+
+ // Get a transport flow either RTP/RTCP for a particular stream
+ // A stream can be of audio/video/datachannel/budled(?) types
+ RefPtr<TransportFlow> GetTransportFlow(int aStreamIndex, bool aIsRtcp) {
+ int index_inner = GetTransportFlowIndex(aStreamIndex, aIsRtcp);
+
+ if (mTransportFlows.find(index_inner) == mTransportFlows.end())
+ return nullptr;
+
+ return mTransportFlows[index_inner];
+ }
+
+ // Add a transport flow
+ void AddTransportFlow(int aIndex, bool aRtcp,
+ const RefPtr<TransportFlow> &aFlow);
+ void RemoveTransportFlow(int aIndex, bool aRtcp);
+ void ConnectDtlsListener_s(const RefPtr<TransportFlow>& aFlow);
+ void DtlsConnected_s(TransportLayer* aFlow,
+ TransportLayer::State state);
+ static void DtlsConnected_m(const std::string& aParentHandle,
+ bool aPrivacyRequested);
+
+ RefPtr<AudioSessionConduit> GetAudioConduit(size_t level) {
+ auto it = mConduits.find(level);
+ if (it == mConduits.end()) {
+ return nullptr;
+ }
+
+ if (it->second.first) {
+ MOZ_ASSERT(false, "In GetAudioConduit, we found a video conduit!");
+ return nullptr;
+ }
+
+ return RefPtr<AudioSessionConduit>(
+ static_cast<AudioSessionConduit*>(it->second.second.get()));
+ }
+
+ RefPtr<VideoSessionConduit> GetVideoConduit(size_t level) {
+ auto it = mConduits.find(level);
+ if (it == mConduits.end()) {
+ return nullptr;
+ }
+
+ if (!it->second.first) {
+ MOZ_ASSERT(false, "In GetVideoConduit, we found an audio conduit!");
+ return nullptr;
+ }
+
+ return RefPtr<VideoSessionConduit>(
+ static_cast<VideoSessionConduit*>(it->second.second.get()));
+ }
+
+ // Add a conduit
+ void AddAudioConduit(size_t level, const RefPtr<AudioSessionConduit> &aConduit) {
+ mConduits[level] = std::make_pair(false, aConduit);
+ }
+
+ void AddVideoConduit(size_t level, const RefPtr<VideoSessionConduit> &aConduit) {
+ mConduits[level] = std::make_pair(true, aConduit);
+ }
+
+ // ICE state signals
+ sigslot::signal2<NrIceCtx*, NrIceCtx::GatheringState>
+ SignalIceGatheringStateChange;
+ sigslot::signal2<NrIceCtx*, NrIceCtx::ConnectionState>
+ SignalIceConnectionStateChange;
+ // This passes a candidate:... attribute and level
+ sigslot::signal2<const std::string&, uint16_t> SignalCandidate;
+ // This passes address, port, level of the default candidate.
+ sigslot::signal5<const std::string&, uint16_t,
+ const std::string&, uint16_t, uint16_t>
+ SignalUpdateDefaultCandidate;
+ sigslot::signal1<uint16_t>
+ SignalEndOfLocalCandidates;
+
+ private:
+ nsresult InitProxy();
+ class ProtocolProxyQueryHandler : public nsIProtocolProxyCallback {
+ public:
+ explicit ProtocolProxyQueryHandler(PeerConnectionMedia *pcm) :
+ pcm_(pcm) {}
+
+ NS_IMETHOD OnProxyAvailable(nsICancelable *request,
+ nsIChannel *aChannel,
+ nsIProxyInfo *proxyinfo,
+ nsresult result) override;
+ NS_DECL_ISUPPORTS
+
+ private:
+ void SetProxyOnPcm(nsIProxyInfo& proxyinfo);
+ RefPtr<PeerConnectionMedia> pcm_;
+ virtual ~ProtocolProxyQueryHandler() {}
+ };
+
+ // Shutdown media transport. Must be called on STS thread.
+ void ShutdownMediaTransport_s();
+
+ // Final destruction of the media stream. Must be called on the main
+ // thread.
+ void SelfDestruct_m();
+
+ // Manage ICE transports.
+ void EnsureTransport_s(size_t aLevel, size_t aComponentCount);
+ void ActivateOrRemoveTransport_s(
+ size_t aMLine,
+ size_t aComponentCount,
+ const std::string& aUfrag,
+ const std::string& aPassword,
+ const std::vector<std::string>& aCandidateList);
+ void RemoveTransportsAtOrAfter_s(size_t aMLine);
+
+ void GatherIfReady();
+ void FlushIceCtxOperationQueueIfReady();
+ void PerformOrEnqueueIceCtxOperation(nsIRunnable* runnable);
+ void EnsureIceGathering_s(bool aDefaultRouteOnly, bool aProxyOnly);
+ void StartIceChecks_s(bool aIsControlling,
+ bool aIsIceLite,
+ const std::vector<std::string>& aIceOptionsList);
+
+ void BeginIceRestart_s(RefPtr<NrIceCtx> new_ctx);
+ void FinalizeIceRestart_s();
+ void RollbackIceRestart_s();
+ bool GetPrefDefaultAddressOnly() const;
+ bool GetPrefProxyOnly() const;
+
+ void ConnectSignals(NrIceCtx *aCtx, NrIceCtx *aOldCtx=nullptr);
+
+ // Process a trickle ICE candidate.
+ void AddIceCandidate_s(const std::string& aCandidate, const std::string& aMid,
+ uint32_t aMLine);
+
+
+ // ICE events
+ void IceGatheringStateChange_s(NrIceCtx* ctx,
+ NrIceCtx::GatheringState state);
+ void IceConnectionStateChange_s(NrIceCtx* ctx,
+ NrIceCtx::ConnectionState state);
+ void IceStreamReady_s(NrIceMediaStream *aStream);
+ void OnCandidateFound_s(NrIceMediaStream *aStream,
+ const std::string& aCandidate);
+ void EndOfLocalCandidates(const std::string& aDefaultAddr,
+ uint16_t aDefaultPort,
+ const std::string& aDefaultRtcpAddr,
+ uint16_t aDefaultRtcpPort,
+ uint16_t aMLine);
+ void GetDefaultCandidates(const NrIceMediaStream& aStream,
+ NrIceCandidate* aCandidate,
+ NrIceCandidate* aRtcpCandidate);
+
+ void IceGatheringStateChange_m(NrIceCtx* ctx,
+ NrIceCtx::GatheringState state);
+ void IceConnectionStateChange_m(NrIceCtx* ctx,
+ NrIceCtx::ConnectionState state);
+ void OnCandidateFound_m(const std::string& aCandidateLine,
+ const std::string& aDefaultAddr,
+ uint16_t aDefaultPort,
+ const std::string& aDefaultRtcpAddr,
+ uint16_t aDefaultRtcpPort,
+ uint16_t aMLine);
+ void EndOfLocalCandidates_m(const std::string& aDefaultAddr,
+ uint16_t aDefaultPort,
+ const std::string& aDefaultRtcpAddr,
+ uint16_t aDefaultRtcpPort,
+ uint16_t aMLine);
+ bool IsIceCtxReady() const {
+ return mProxyResolveCompleted;
+ }
+
+ // The parent PC
+ PeerConnectionImpl *mParent;
+ // and a loose handle on it for event driven stuff
+ std::string mParentHandle;
+ std::string mParentName;
+
+ // A list of streams returned from GetUserMedia
+ // This is only accessed on the main thread (with one special exception)
+ nsTArray<RefPtr<LocalSourceStreamInfo> > mLocalSourceStreams;
+
+ // A list of streams provided by the other side
+ // This is only accessed on the main thread (with one special exception)
+ nsTArray<RefPtr<RemoteSourceStreamInfo> > mRemoteSourceStreams;
+
+ std::map<size_t, std::pair<bool, RefPtr<MediaSessionConduit>>> mConduits;
+
+ // ICE objects
+ RefPtr<NrIceCtxHandler> mIceCtxHdlr;
+
+ // DNS
+ RefPtr<NrIceResolver> mDNSResolver;
+
+ // Transport flows: even is RTP, odd is RTCP
+ std::map<int, RefPtr<TransportFlow> > mTransportFlows;
+
+ // UUID Generator
+ UniquePtr<PCUuidGenerator> mUuidGen;
+
+ // The main thread.
+ nsCOMPtr<nsIThread> mMainThread;
+
+ // The STS thread.
+ nsCOMPtr<nsIEventTarget> mSTSThread;
+
+ // Used whenever we need to dispatch a runnable to STS to tweak something
+ // on our ICE ctx, but are not ready to do so at the moment (eg; we are
+ // waiting to get a callback with our http proxy config before we start
+ // gathering or start checking)
+ std::vector<nsCOMPtr<nsIRunnable>> mQueuedIceCtxOperations;
+
+ // Used to cancel any ongoing proxy request.
+ nsCOMPtr<nsICancelable> mProxyRequest;
+
+ // Used to track the state of the request.
+ bool mProxyResolveCompleted;
+
+ // Used to store the result of the request.
+ UniquePtr<NrIceProxyServer> mProxyServer;
+
+ // Used to track the state of ice restart
+ IceRestartState mIceRestartState;
+
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(PeerConnectionMedia)
+};
+
+} // namespace mozilla
+
+#endif
diff --git a/media/webrtc/signaling/src/peerconnection/WebrtcGlobalChild.h b/media/webrtc/signaling/src/peerconnection/WebrtcGlobalChild.h
new file mode 100644
index 000000000..544315a3e
--- /dev/null
+++ b/media/webrtc/signaling/src/peerconnection/WebrtcGlobalChild.h
@@ -0,0 +1,40 @@
+/* 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/. */
+
+#ifndef _WEBRTC_GLOBAL_CHILD_H_
+#define _WEBRTC_GLOBAL_CHILD_H_
+
+#include "mozilla/dom/PWebrtcGlobalChild.h"
+
+namespace mozilla {
+namespace dom {
+
+class WebrtcGlobalChild :
+ public PWebrtcGlobalChild
+{
+ friend class ContentChild;
+
+ bool mShutdown;
+
+ MOZ_IMPLICIT WebrtcGlobalChild();
+ virtual void ActorDestroy(ActorDestroyReason aWhy) override;
+
+ virtual bool RecvGetStatsRequest(const int& aRequestId,
+ const nsString& aPcIdFilter) override;
+ virtual bool RecvClearStatsRequest() override;
+ virtual bool RecvGetLogRequest(const int& aReqestId,
+ const nsCString& aPattern) override;
+ virtual bool RecvClearLogRequest() override;
+ virtual bool RecvSetAecLogging(const bool& aEnable) override;
+ virtual bool RecvSetDebugMode(const int& aLevel) override;
+
+public:
+ virtual ~WebrtcGlobalChild();
+ static WebrtcGlobalChild* Create();
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // _WEBRTC_GLOBAL_CHILD_H_
diff --git a/media/webrtc/signaling/src/peerconnection/WebrtcGlobalInformation.cpp b/media/webrtc/signaling/src/peerconnection/WebrtcGlobalInformation.cpp
new file mode 100644
index 000000000..96bdd5b70
--- /dev/null
+++ b/media/webrtc/signaling/src/peerconnection/WebrtcGlobalInformation.cpp
@@ -0,0 +1,1241 @@
+/* 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 "WebrtcGlobalInformation.h"
+#include "mozilla/media/webrtc/WebrtcGlobal.h"
+#include "WebrtcGlobalChild.h"
+#include "WebrtcGlobalParent.h"
+
+#include <deque>
+#include <string>
+#include <algorithm>
+#include <vector>
+#include <map>
+#include <queue>
+
+#include "CSFLog.h"
+#include "WebRtcLog.h"
+#include "mozilla/dom/WebrtcGlobalInformationBinding.h"
+#include "mozilla/dom/ContentChild.h"
+
+#include "nsAutoPtr.h"
+#include "nsNetCID.h" // NS_SOCKETTRANSPORTSERVICE_CONTRACTID
+#include "nsServiceManagerUtils.h" // do_GetService
+#include "mozilla/ErrorResult.h"
+#include "mozilla/Vector.h"
+#include "nsProxyRelease.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/Unused.h"
+#include "mozilla/StaticMutex.h"
+#include "mozilla/RefPtr.h"
+
+#include "rlogconnector.h"
+#include "runnable_utils.h"
+#include "PeerConnectionCtx.h"
+#include "PeerConnectionImpl.h"
+#include "webrtc/system_wrappers/interface/trace.h"
+
+static const char* logTag = "WebrtcGlobalInformation";
+
+namespace mozilla {
+namespace dom {
+
+typedef Vector<nsAutoPtr<RTCStatsQuery>> RTCStatsQueries;
+typedef nsTArray<RTCStatsReportInternal> Stats;
+
+template<class Request, typename Callback,
+ typename Result, typename QueryParam>
+class RequestManager
+{
+public:
+
+ static Request* Create(Callback& aCallback, QueryParam& aParam)
+ {
+ mozilla::StaticMutexAutoLock lock(sMutex);
+
+ int id = ++sLastRequestId;
+ auto result = sRequests.insert(
+ std::make_pair(id, Request(id, aCallback, aParam)));
+
+ if (!result.second) {
+ return nullptr;
+ }
+
+ return &result.first->second;
+ }
+
+ static void Delete(int aId)
+ {
+ mozilla::StaticMutexAutoLock lock(sMutex);
+ sRequests.erase(aId);
+ }
+
+ static Request* Get(int aId)
+ {
+ mozilla::StaticMutexAutoLock lock(sMutex);
+ auto r = sRequests.find(aId);
+
+ if (r == sRequests.end()) {
+ return nullptr;
+ }
+
+ return &r->second;
+ }
+
+ Result mResult;
+ std::queue<RefPtr<WebrtcGlobalParent>> mContactList;
+ const int mRequestId;
+
+ RefPtr<WebrtcGlobalParent> GetNextParent()
+ {
+ while (!mContactList.empty()) {
+ RefPtr<WebrtcGlobalParent> next = mContactList.front();
+ mContactList.pop();
+ if (next->IsActive()) {
+ return next;
+ }
+ }
+
+ return nullptr;
+ }
+
+ void Complete()
+ {
+ ErrorResult rv;
+ mCallback.get()->Call(mResult, rv);
+
+ if (rv.Failed()) {
+ CSFLogError(logTag, "Error firing stats observer callback");
+ }
+ }
+
+protected:
+ // The mutex is used to protect two related operations involving the sRequest map
+ // and the sLastRequestId. For the map, it prevents more than one thread from
+ // adding or deleting map entries at the same time. For id generation,
+ // it creates an atomic allocation and increment.
+ static mozilla::StaticMutex sMutex;
+ static std::map<int, Request> sRequests;
+ static int sLastRequestId;
+
+ Callback mCallback;
+
+ explicit RequestManager(int aId, Callback& aCallback)
+ : mRequestId(aId)
+ , mCallback(aCallback)
+ {}
+ ~RequestManager() {}
+private:
+
+ RequestManager() = delete;
+ RequestManager& operator=(const RequestManager&) = delete;
+};
+
+template<class Request, typename Callback,
+ typename Result, typename QueryParam>
+mozilla::StaticMutex RequestManager<Request, Callback, Result, QueryParam>::sMutex;
+template<class Request, typename Callback,
+ typename Result, typename QueryParam>
+std::map<int, Request> RequestManager<Request, Callback, Result, QueryParam>::sRequests;
+template<class Request, typename Callback,
+ typename Result, typename QueryParam>
+int RequestManager<Request, Callback, Result, QueryParam>::sLastRequestId;
+
+typedef nsMainThreadPtrHandle<WebrtcGlobalStatisticsCallback> StatsRequestCallback;
+
+class StatsRequest
+ : public RequestManager<StatsRequest,
+ StatsRequestCallback,
+ WebrtcGlobalStatisticsReport,
+ nsAString>
+{
+public:
+ const nsString mPcIdFilter;
+ explicit StatsRequest(int aId, StatsRequestCallback& aCallback, nsAString& aFilter)
+ : RequestManager(aId, aCallback)
+ , mPcIdFilter(aFilter)
+ {
+ mResult.mReports.Construct();
+ }
+
+private:
+ StatsRequest() = delete;
+ StatsRequest& operator=(const StatsRequest&) = delete;
+};
+
+typedef nsMainThreadPtrHandle<WebrtcGlobalLoggingCallback> LogRequestCallback;
+
+class LogRequest
+ : public RequestManager<LogRequest,
+ LogRequestCallback,
+ Sequence<nsString>,
+ const nsACString>
+{
+public:
+ const nsCString mPattern;
+ explicit LogRequest(int aId, LogRequestCallback& aCallback, const nsACString& aPattern)
+ : RequestManager(aId, aCallback)
+ , mPattern(aPattern)
+ {}
+
+private:
+ LogRequest() = delete;
+ LogRequest& operator=(const LogRequest&) = delete;
+};
+
+class WebrtcContentParents
+{
+public:
+ static WebrtcGlobalParent* Alloc();
+ static void Dealloc(WebrtcGlobalParent* aParent);
+ static bool Empty()
+ {
+ return sContentParents.empty();
+ }
+ static const std::vector<RefPtr<WebrtcGlobalParent>>& GetAll()
+ {
+ return sContentParents;
+ }
+private:
+ static std::vector<RefPtr<WebrtcGlobalParent>> sContentParents;
+ WebrtcContentParents() = delete;
+ WebrtcContentParents(const WebrtcContentParents&) = delete;
+ WebrtcContentParents& operator=(const WebrtcContentParents&) = delete;
+};
+
+std::vector<RefPtr<WebrtcGlobalParent>> WebrtcContentParents::sContentParents;
+
+WebrtcGlobalParent* WebrtcContentParents::Alloc()
+{
+ RefPtr<WebrtcGlobalParent> cp = new WebrtcGlobalParent;
+ sContentParents.push_back(cp);
+ return cp.get();
+}
+
+void WebrtcContentParents::Dealloc(WebrtcGlobalParent* aParent)
+{
+ if (aParent) {
+ aParent->mShutdown = true;
+ auto cp = std::find(sContentParents.begin(), sContentParents.end(), aParent);
+ if (cp != sContentParents.end()) {
+ sContentParents.erase(cp);
+ }
+ }
+}
+
+static PeerConnectionCtx* GetPeerConnectionCtx()
+{
+ if(PeerConnectionCtx::isActive()) {
+ MOZ_ASSERT(PeerConnectionCtx::GetInstance());
+ return PeerConnectionCtx::GetInstance();
+ }
+ return nullptr;
+}
+
+static void
+OnStatsReport_m(WebrtcGlobalChild* aThisChild,
+ const int aRequestId,
+ nsAutoPtr<RTCStatsQueries> aQueryList)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(aQueryList);
+
+ if (aThisChild) {
+ Stats stats;
+
+ // Copy stats generated for the currently active PeerConnections
+ for (auto&& query : *aQueryList) {
+ stats.AppendElement(*(query->report));
+ }
+ // Reports saved for closed/destroyed PeerConnections
+ auto ctx = PeerConnectionCtx::GetInstance();
+ if (ctx) {
+ for (auto&& pc : ctx->mStatsForClosedPeerConnections) {
+ stats.AppendElement(pc);
+ }
+ }
+
+ Unused << aThisChild->SendGetStatsResult(aRequestId, stats);
+ return;
+ }
+
+ // This is the last stats report to be collected. (Must be the gecko process).
+ MOZ_ASSERT(XRE_IsParentProcess());
+
+ StatsRequest* request = StatsRequest::Get(aRequestId);
+
+ if (!request) {
+ CSFLogError(logTag, "Bad RequestId");
+ return;
+ }
+
+ for (auto&& query : *aQueryList) {
+ request->mResult.mReports.Value().AppendElement(*(query->report), fallible);
+ }
+
+ // Reports saved for closed/destroyed PeerConnections
+ auto ctx = PeerConnectionCtx::GetInstance();
+ if (ctx) {
+ for (auto&& pc : ctx->mStatsForClosedPeerConnections) {
+ request->mResult.mReports.Value().AppendElement(pc, fallible);
+ }
+ }
+
+ request->Complete();
+ StatsRequest::Delete(aRequestId);
+}
+
+static void
+GetAllStats_s(WebrtcGlobalChild* aThisChild,
+ const int aRequestId,
+ nsAutoPtr<RTCStatsQueries> aQueryList)
+{
+ MOZ_ASSERT(aQueryList);
+ // The call to PeerConnetionImpl must happen from a runnable
+ // dispatched on the STS thread.
+
+ // Get stats from active connections.
+ for (auto&& query : *aQueryList) {
+ PeerConnectionImpl::ExecuteStatsQuery_s(query);
+ }
+
+ // After the RTCStatsQueries have been filled in, control must return
+ // to the main thread before their eventual destruction.
+ NS_DispatchToMainThread(WrapRunnableNM(&OnStatsReport_m,
+ aThisChild,
+ aRequestId,
+ aQueryList),
+ NS_DISPATCH_NORMAL);
+}
+
+static void OnGetLogging_m(WebrtcGlobalChild* aThisChild,
+ const int aRequestId,
+ nsAutoPtr<std::deque<std::string>> aLogList)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+
+ if (aThisChild) {
+ // Add this log to the collection of logs and call into
+ // the next content process.
+ Sequence<nsString> nsLogs;
+
+ if (!aLogList->empty()) {
+ for (auto& line : *aLogList) {
+ nsLogs.AppendElement(NS_ConvertUTF8toUTF16(line.c_str()), fallible);
+ }
+ nsLogs.AppendElement(NS_LITERAL_STRING("+++++++ END ++++++++"), fallible);
+ }
+
+ Unused << aThisChild->SendGetLogResult(aRequestId, nsLogs);
+ return;
+ }
+
+ // This is the last log to be collected. (Must be the gecko process).
+ MOZ_ASSERT(XRE_IsParentProcess());
+
+ LogRequest* request = LogRequest::Get(aRequestId);
+
+ if (!request) {
+ CSFLogError(logTag, "Bad RequestId");
+ return;
+ }
+
+ if (!aLogList->empty()) {
+ for (auto& line : *aLogList) {
+ request->mResult.AppendElement(NS_ConvertUTF8toUTF16(line.c_str()),
+ fallible);
+ }
+ request->mResult.AppendElement(NS_LITERAL_STRING("+++++++ END ++++++++"),
+ fallible);
+ }
+
+ request->Complete();
+ LogRequest::Delete(aRequestId);
+}
+
+static void GetLogging_s(WebrtcGlobalChild* aThisChild,
+ const int aRequestId,
+ const std::string& aPattern)
+{
+ // Request log while not on the main thread.
+ RLogConnector* logs = RLogConnector::GetInstance();
+ nsAutoPtr<std::deque<std::string>> result(new std::deque<std::string>);
+ // Might not exist yet.
+ if (logs) {
+ logs->Filter(aPattern, 0, result);
+ }
+ // Return to main thread to complete processing.
+ NS_DispatchToMainThread(WrapRunnableNM(&OnGetLogging_m,
+ aThisChild,
+ aRequestId,
+ result),
+ NS_DISPATCH_NORMAL);
+}
+
+static nsresult
+BuildStatsQueryList(
+ const std::map<const std::string, PeerConnectionImpl *>& aPeerConnections,
+ const nsAString& aPcIdFilter,
+ RTCStatsQueries* queries)
+{
+ nsresult rv;
+
+ for (auto&& pc : aPeerConnections) {
+ MOZ_ASSERT(pc.second);
+ if (aPcIdFilter.IsEmpty() ||
+ aPcIdFilter.EqualsASCII(pc.second->GetIdAsAscii().c_str())) {
+ if (pc.second->HasMedia()) {
+ if (!queries->append(nsAutoPtr<RTCStatsQuery>(new RTCStatsQuery(true)))) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ rv = pc.second->BuildStatsQuery_m(nullptr, queries->back()); // all tracks
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+ MOZ_ASSERT(queries->back()->report);
+ }
+ }
+ }
+
+ return NS_OK;
+}
+
+static nsresult
+RunStatsQuery(
+ const std::map<const std::string, PeerConnectionImpl *>& aPeerConnections,
+ const nsAString& aPcIdFilter,
+ WebrtcGlobalChild* aThisChild,
+ const int aRequestId)
+{
+ nsAutoPtr<RTCStatsQueries> queries(new RTCStatsQueries);
+ nsresult rv = BuildStatsQueryList(aPeerConnections, aPcIdFilter, queries);
+
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ nsCOMPtr<nsIEventTarget> stsThread =
+ do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv);
+
+ if (NS_FAILED(rv)) {
+ return rv;
+ } else if (!stsThread) {
+ return NS_ERROR_FAILURE;
+ }
+
+ rv = RUN_ON_THREAD(stsThread,
+ WrapRunnableNM(&GetAllStats_s,
+ aThisChild,
+ aRequestId,
+ queries),
+ NS_DISPATCH_NORMAL);
+ return rv;
+}
+
+void ClearClosedStats()
+{
+ PeerConnectionCtx* ctx = GetPeerConnectionCtx();
+
+ if (ctx) {
+ ctx->mStatsForClosedPeerConnections.Clear();
+ }
+}
+
+void
+WebrtcGlobalInformation::ClearAllStats(
+ const GlobalObject& aGlobal)
+{
+ if (!NS_IsMainThread()) {
+ return;
+ }
+
+ // Chrome-only API
+ MOZ_ASSERT(XRE_IsParentProcess());
+
+ if (!WebrtcContentParents::Empty()) {
+ // Pass on the request to any content process based PeerConnections.
+ for (auto& cp : WebrtcContentParents::GetAll()) {
+ Unused << cp->SendClearStatsRequest();
+ }
+ }
+
+ // Flush the history for the chrome process
+ ClearClosedStats();
+}
+
+void
+WebrtcGlobalInformation::GetAllStats(
+ const GlobalObject& aGlobal,
+ WebrtcGlobalStatisticsCallback& aStatsCallback,
+ const Optional<nsAString>& pcIdFilter,
+ ErrorResult& aRv)
+{
+ if (!NS_IsMainThread()) {
+ aRv.Throw(NS_ERROR_NOT_SAME_THREAD);
+ return;
+ }
+
+ MOZ_ASSERT(XRE_IsParentProcess());
+
+ // CallbackObject does not support threadsafe refcounting, and must be
+ // used and destroyed on main.
+ StatsRequestCallback callbackHandle(
+ new nsMainThreadPtrHolder<WebrtcGlobalStatisticsCallback>(&aStatsCallback));
+
+ nsString filter;
+ if (pcIdFilter.WasPassed()) {
+ filter = pcIdFilter.Value();
+ }
+
+ auto* request = StatsRequest::Create(callbackHandle, filter);
+
+ if (!request) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return;
+ }
+
+ if (!WebrtcContentParents::Empty()) {
+ // Pass on the request to any content based PeerConnections.
+ for (auto& cp : WebrtcContentParents::GetAll()) {
+ request->mContactList.push(cp);
+ }
+
+ auto next = request->GetNextParent();
+ if (next) {
+ aRv = next->SendGetStatsRequest(request->mRequestId, request->mPcIdFilter) ?
+ NS_OK : NS_ERROR_FAILURE;
+ return;
+ }
+ }
+ // No content resident PeerConnectionCtx instances.
+ // Check this process.
+ PeerConnectionCtx* ctx = GetPeerConnectionCtx();
+ nsresult rv;
+
+ if (ctx) {
+ rv = RunStatsQuery(ctx->mGetPeerConnections(),
+ filter, nullptr, request->mRequestId);
+
+ if (NS_FAILED(rv)) {
+ StatsRequest::Delete(request->mRequestId);
+ }
+ } else {
+ // Just send back an empty report.
+ rv = NS_OK;
+ request->Complete();
+ StatsRequest::Delete(request->mRequestId);
+ }
+
+ aRv = rv;
+ return;
+}
+
+static nsresult
+RunLogQuery(const nsCString& aPattern,
+ WebrtcGlobalChild* aThisChild,
+ const int aRequestId)
+{
+ nsresult rv;
+ nsCOMPtr<nsIEventTarget> stsThread =
+ do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv);
+
+ if (NS_FAILED(rv)) {
+ return rv;
+ } else if (!stsThread) {
+ return NS_ERROR_FAILURE;
+ }
+
+ rv = RUN_ON_THREAD(stsThread,
+ WrapRunnableNM(&GetLogging_s,
+ aThisChild,
+ aRequestId,
+ aPattern.get()),
+ NS_DISPATCH_NORMAL);
+ return rv;
+}
+
+static void ClearLogs_s()
+{
+ // Make call off main thread.
+ RLogConnector* logs = RLogConnector::GetInstance();
+ if (logs) {
+ logs->Clear();
+ }
+}
+
+static nsresult
+RunLogClear()
+{
+ nsresult rv;
+ nsCOMPtr<nsIEventTarget> stsThread =
+ do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv);
+
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ if (!stsThread) {
+ return NS_ERROR_FAILURE;
+ }
+
+ return RUN_ON_THREAD(stsThread,
+ WrapRunnableNM(&ClearLogs_s),
+ NS_DISPATCH_NORMAL);
+}
+
+void
+WebrtcGlobalInformation::ClearLogging(
+ const GlobalObject& aGlobal)
+{
+ if (!NS_IsMainThread()) {
+ return;
+ }
+
+ // Chrome-only API
+ MOZ_ASSERT(XRE_IsParentProcess());
+
+ if (!WebrtcContentParents::Empty()) {
+ // Clear content process signaling logs
+ for (auto& cp : WebrtcContentParents::GetAll()) {
+ Unused << cp->SendClearLogRequest();
+ }
+ }
+
+ // Clear chrome process signaling logs
+ Unused << RunLogClear();
+}
+
+void
+WebrtcGlobalInformation::GetLogging(
+ const GlobalObject& aGlobal,
+ const nsAString& aPattern,
+ WebrtcGlobalLoggingCallback& aLoggingCallback,
+ ErrorResult& aRv)
+{
+ if (!NS_IsMainThread()) {
+ aRv.Throw(NS_ERROR_NOT_SAME_THREAD);
+ return;
+ }
+
+ MOZ_ASSERT(XRE_IsParentProcess());
+
+ // CallbackObject does not support threadsafe refcounting, and must be
+ // destroyed on main.
+ LogRequestCallback callbackHandle(
+ new nsMainThreadPtrHolder<WebrtcGlobalLoggingCallback>(&aLoggingCallback));
+
+ nsAutoCString pattern;
+ CopyUTF16toUTF8(aPattern, pattern);
+
+ LogRequest* request = LogRequest::Create(callbackHandle, pattern);
+
+ if (!request) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return;
+ }
+
+ if (!WebrtcContentParents::Empty()) {
+ // Pass on the request to any content based PeerConnections.
+ for (auto& cp : WebrtcContentParents::GetAll()) {
+ request->mContactList.push(cp);
+ }
+
+ auto next = request->GetNextParent();
+ if (next) {
+ aRv = next->SendGetLogRequest(request->mRequestId, request->mPattern) ?
+ NS_OK : NS_ERROR_FAILURE;
+ return;
+ }
+ }
+
+ nsresult rv = RunLogQuery(request->mPattern, nullptr, request->mRequestId);
+
+ if (NS_FAILED(rv)) {
+ LogRequest::Delete(request->mRequestId);
+ }
+
+ aRv = rv;
+ return;
+}
+
+static int32_t sLastSetLevel = 0;
+static bool sLastAECDebug = false;
+
+void
+WebrtcGlobalInformation::SetDebugLevel(const GlobalObject& aGlobal, int32_t aLevel)
+{
+ if (aLevel) {
+ StartWebRtcLog(webrtc::TraceLevel(aLevel));
+ } else {
+ StopWebRtcLog();
+ }
+ sLastSetLevel = aLevel;
+
+ for (auto& cp : WebrtcContentParents::GetAll()){
+ Unused << cp->SendSetDebugMode(aLevel);
+ }
+}
+
+int32_t
+WebrtcGlobalInformation::DebugLevel(const GlobalObject& aGlobal)
+{
+ return sLastSetLevel;
+}
+
+void
+WebrtcGlobalInformation::SetAecDebug(const GlobalObject& aGlobal, bool aEnable)
+{
+ if (aEnable) {
+ StartAecLog();
+ } else {
+ StopAecLog();
+ }
+
+ sLastAECDebug = aEnable;
+
+ for (auto& cp : WebrtcContentParents::GetAll()){
+ Unused << cp->SendSetAecLogging(aEnable);
+ }
+}
+
+bool
+WebrtcGlobalInformation::AecDebug(const GlobalObject& aGlobal)
+{
+ return sLastAECDebug;
+}
+
+bool
+WebrtcGlobalParent::RecvGetStatsResult(const int& aRequestId,
+ nsTArray<RTCStatsReportInternal>&& Stats)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+ nsresult rv = NS_OK;
+
+ StatsRequest* request = StatsRequest::Get(aRequestId);
+
+ if (!request) {
+ CSFLogError(logTag, "Bad RequestId");
+ return false;
+ }
+
+ for (auto&& s : Stats) {
+ request->mResult.mReports.Value().AppendElement(s, fallible);
+ }
+
+ auto next = request->GetNextParent();
+ if (next) {
+ // There are more content instances to query.
+ return next->SendGetStatsRequest(request->mRequestId, request->mPcIdFilter);
+ }
+
+ // Content queries complete, run chrome instance query if applicable
+ PeerConnectionCtx* ctx = GetPeerConnectionCtx();
+
+ if (ctx) {
+ rv = RunStatsQuery(ctx->mGetPeerConnections(),
+ request->mPcIdFilter, nullptr, aRequestId);
+ } else {
+ // No instance in the process, return the collections as is
+ request->Complete();
+ StatsRequest::Delete(aRequestId);
+ }
+
+ return NS_SUCCEEDED(rv);
+}
+
+bool
+WebrtcGlobalParent::RecvGetLogResult(const int& aRequestId,
+ const WebrtcGlobalLog& aLog)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+
+ LogRequest* request = LogRequest::Get(aRequestId);
+
+ if (!request) {
+ CSFLogError(logTag, "Bad RequestId");
+ return false;
+ }
+ request->mResult.AppendElements(aLog, fallible);
+
+ auto next = request->GetNextParent();
+ if (next) {
+ // There are more content instances to query.
+ return next->SendGetLogRequest(request->mRequestId, request->mPattern);
+ }
+
+ // Content queries complete, run chrome instance query if applicable
+ nsresult rv = RunLogQuery(request->mPattern, nullptr, aRequestId);
+
+ if (NS_FAILED(rv)) {
+ //Unable to get gecko process log. Return what has been collected.
+ CSFLogError(logTag, "Unable to extract chrome process log");
+ request->Complete();
+ LogRequest::Delete(aRequestId);
+ }
+
+ return true;
+}
+
+WebrtcGlobalParent*
+WebrtcGlobalParent::Alloc()
+{
+ return WebrtcContentParents::Alloc();
+}
+
+bool
+WebrtcGlobalParent::Dealloc(WebrtcGlobalParent * aActor)
+{
+ WebrtcContentParents::Dealloc(aActor);
+ return true;
+}
+
+void
+WebrtcGlobalParent::ActorDestroy(ActorDestroyReason aWhy)
+{
+ mShutdown = true;
+ return;
+}
+
+bool
+WebrtcGlobalParent::Recv__delete__()
+{
+ return true;
+}
+
+MOZ_IMPLICIT WebrtcGlobalParent::WebrtcGlobalParent()
+ : mShutdown(false)
+{
+ MOZ_COUNT_CTOR(WebrtcGlobalParent);
+}
+
+MOZ_IMPLICIT WebrtcGlobalParent::~WebrtcGlobalParent()
+{
+ MOZ_COUNT_DTOR(WebrtcGlobalParent);
+}
+
+bool
+WebrtcGlobalChild::RecvGetStatsRequest(const int& aRequestId,
+ const nsString& aPcIdFilter)
+{
+ if (mShutdown) {
+ return true;
+ }
+
+ PeerConnectionCtx* ctx = GetPeerConnectionCtx();
+
+ if (ctx) {
+ nsresult rv = RunStatsQuery(ctx->mGetPeerConnections(),
+ aPcIdFilter, this, aRequestId);
+ return NS_SUCCEEDED(rv);
+ }
+
+ nsTArray<RTCStatsReportInternal> empty_stats;
+ SendGetStatsResult(aRequestId, empty_stats);
+
+ return true;
+}
+
+bool
+WebrtcGlobalChild::RecvClearStatsRequest()
+{
+ if (mShutdown) {
+ return true;
+ }
+
+ ClearClosedStats();
+ return true;
+}
+
+bool
+WebrtcGlobalChild::RecvGetLogRequest(const int& aRequestId,
+ const nsCString& aPattern)
+{
+ if (mShutdown) {
+ return true;
+ }
+
+ nsresult rv;
+ nsCOMPtr<nsIEventTarget> stsThread =
+ do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv);
+
+ if (NS_SUCCEEDED(rv) && stsThread) {
+ rv = RUN_ON_THREAD(stsThread,
+ WrapRunnableNM(&GetLogging_s, this, aRequestId, aPattern.get()),
+ NS_DISPATCH_NORMAL);
+
+ if (NS_SUCCEEDED(rv)) {
+ return true;
+ }
+ }
+
+ Sequence<nsString> empty_log;
+ SendGetLogResult(aRequestId, empty_log);
+
+ return true;
+}
+
+bool
+WebrtcGlobalChild::RecvClearLogRequest()
+{
+ if (mShutdown) {
+ return true;
+ }
+
+ RunLogClear();
+ return true;
+}
+
+bool
+WebrtcGlobalChild::RecvSetAecLogging(const bool& aEnable)
+{
+ if (!mShutdown) {
+ if (aEnable) {
+ StartAecLog();
+ } else {
+ StopAecLog();
+ }
+ }
+ return true;
+}
+
+bool
+WebrtcGlobalChild::RecvSetDebugMode(const int& aLevel)
+{
+ if (!mShutdown) {
+ if (aLevel) {
+ StartWebRtcLog(webrtc::TraceLevel(aLevel));
+ } else {
+ StopWebRtcLog();
+ }
+ }
+ return true;
+}
+
+WebrtcGlobalChild*
+WebrtcGlobalChild::Create()
+{
+ WebrtcGlobalChild* child =
+ static_cast<WebrtcGlobalChild*>(
+ ContentChild::GetSingleton()->SendPWebrtcGlobalConstructor());
+ return child;
+}
+
+void
+WebrtcGlobalChild::ActorDestroy(ActorDestroyReason aWhy)
+{
+ mShutdown = true;
+}
+
+MOZ_IMPLICIT WebrtcGlobalChild::WebrtcGlobalChild()
+ : mShutdown(false)
+{
+ MOZ_COUNT_CTOR(WebrtcGlobalChild);
+}
+
+MOZ_IMPLICIT WebrtcGlobalChild::~WebrtcGlobalChild()
+{
+ MOZ_COUNT_DTOR(WebrtcGlobalChild);
+}
+
+struct StreamResult {
+ StreamResult() : candidateTypeBitpattern(0), streamSucceeded(false) {}
+ uint32_t candidateTypeBitpattern;
+ bool streamSucceeded;
+};
+
+static uint32_t GetCandidateIpAndTransportMask(const RTCIceCandidateStats *cand) {
+
+ enum {
+ CANDIDATE_BITMASK_UDP = 1,
+ CANDIDATE_BITMASK_TCP = 1 << 1,
+ CANDIDATE_BITMASK_IPV6 = 1 << 2,
+ };
+
+ uint32_t res = 0;
+
+ nsAutoCString transport;
+ // prefer local transport for local relay candidates
+ if (cand->mMozLocalTransport.WasPassed()) {
+ transport.Assign(NS_ConvertUTF16toUTF8(cand->mMozLocalTransport.Value()));
+ } else {
+ transport.Assign(NS_ConvertUTF16toUTF8(cand->mTransport.Value()));
+ }
+ if (transport == kNrIceTransportUdp) {
+ res |= CANDIDATE_BITMASK_UDP;
+ } else if (transport == kNrIceTransportTcp) {
+ res |= CANDIDATE_BITMASK_TCP;
+ }
+
+ if (cand->mIpAddress.Value().FindChar(':') != -1) {
+ res |= CANDIDATE_BITMASK_IPV6;
+ }
+
+ return res;
+};
+
+static void StoreLongTermICEStatisticsImpl_m(
+ nsresult result,
+ nsAutoPtr<RTCStatsQuery> query) {
+
+ using namespace Telemetry;
+
+ if (NS_FAILED(result) ||
+ !query->error.empty() ||
+ !query->report->mIceCandidateStats.WasPassed()) {
+ return;
+ }
+
+ query->report->mClosed.Construct(true);
+
+ // TODO(bcampen@mozilla.com): Do we need to watch out for cases where the
+ // components within a stream didn't have the same types of relayed
+ // candidates? I have a feeling that late trickle could cause this, but right
+ // now we don't have enough information to detect it (we would need to know
+ // the ICE component id for each candidate pair and candidate)
+
+ std::map<std::string, StreamResult> streamResults;
+
+ // Build list of streams, and whether or not they failed.
+ for (size_t i = 0;
+ i < query->report->mIceCandidatePairStats.Value().Length();
+ ++i) {
+ const RTCIceCandidatePairStats &pair =
+ query->report->mIceCandidatePairStats.Value()[i];
+
+ if (!pair.mState.WasPassed() || !pair.mComponentId.WasPassed()) {
+ MOZ_CRASH();
+ continue;
+ }
+
+ // Note: this is not a "component" in the ICE definition, this is really a
+ // stream ID. This is just the way the stats API is standardized right now.
+ // Very confusing.
+ std::string streamId(
+ NS_ConvertUTF16toUTF8(pair.mComponentId.Value()).get());
+
+ streamResults[streamId].streamSucceeded |=
+ pair.mState.Value() == RTCStatsIceCandidatePairState::Succeeded;
+ }
+
+ for (size_t i = 0;
+ i < query->report->mIceCandidateStats.Value().Length();
+ ++i) {
+ const RTCIceCandidateStats &cand =
+ query->report->mIceCandidateStats.Value()[i];
+
+ if (!cand.mType.WasPassed() ||
+ !cand.mCandidateType.WasPassed() ||
+ !cand.mTransport.WasPassed() ||
+ !cand.mIpAddress.WasPassed() ||
+ !cand.mComponentId.WasPassed()) {
+ // Crash on debug, ignore this candidate otherwise.
+ MOZ_CRASH();
+ continue;
+ }
+
+ /* The bitmask after examaning a candidate should look like this:
+ * REMOTE_GATHERED_HOST_UDP = 1,
+ * REMOTE_GATHERED_HOST_TCP = 1 << 1,
+ * REMOTE_GATHERED_HOST_IPV6 = 1 << 2,
+ * REMOTE_GATHERED_SERVER_REFLEXIVE_UDP = 1 << 3,
+ * REMOTE_GATHERED_SERVER_REFLEXIVE_TCP = 1 << 4,
+ * REMOTE_GATHERED_SERVER_REFLEXIVE_IPV6 = 1 << 5,
+ * REMOTE_GATHERED_TURN_UDP = 1 << 6,
+ * REMOTE_GATHERED_TURN_TCP = 1 << 7, // dummy place holder
+ * REMOTE_GATHERED_TURN_IPV6 = 1 << 8,
+ * REMOTE_GATHERED_PEER_REFLEXIVE_UDP = 1 << 9,
+ * REMOTE_GATHERED_PEER_REFLEXIVE_TCP = 1 << 10,
+ * REMOTE_GATHERED_PEER_REFLEXIVE_IPV6 = 1 << 11,
+ * LOCAL_GATHERED_HOST_UDP = 1 << 16,
+ * LOCAL_GATHERED_HOST_TCP = 1 << 17,
+ * LOCAL_GATHERED_HOST_IPV6 = 1 << 18,
+ * LOCAL_GATHERED_SERVER_REFLEXIVE_UDP = 1 << 19,
+ * LOCAL_GATHERED_SERVER_REFLEXIVE_TCP = 1 << 20,
+ * LOCAL_GATHERED_SERVER_REFLEXIVE_IPV6 = 1 << 21,
+ * LOCAL_GATHERED_TURN_UDP = 1 << 22,
+ * LOCAL_GATHERED_TURN_TCP = 1 << 23,
+ * LOCAL_GATHERED_TURN_IPV6 = 1 << 24,
+ * LOCAL_GATHERED_PEERREFLEXIVE_UDP = 1 << 25,
+ * LOCAL_GATHERED_PEERREFLEXIVE_TCP = 1 << 26,
+ * LOCAL_GATHERED_PEERREFLEXIVE_IPV6 = 1 << 27,
+ *
+ * This results in following shift values
+ */
+ static const uint32_t kLocalShift = 16;
+ static const uint32_t kSrflxShift = 3;
+ static const uint32_t kRelayShift = 6;
+ static const uint32_t kPrflxShift = 9;
+
+ uint32_t candBitmask = GetCandidateIpAndTransportMask(&cand);
+
+ // Note: shift values need to result in the above enum table
+ if (cand.mType.Value() == RTCStatsType::Localcandidate) {
+ candBitmask <<= kLocalShift;
+ }
+
+ if (cand.mCandidateType.Value() == RTCStatsIceCandidateType::Serverreflexive) {
+ candBitmask <<= kSrflxShift;
+ } else if (cand.mCandidateType.Value() == RTCStatsIceCandidateType::Relayed) {
+ candBitmask <<= kRelayShift;
+ } else if (cand.mCandidateType.Value() == RTCStatsIceCandidateType::Peerreflexive) {
+ candBitmask <<= kPrflxShift;
+ }
+
+ // Note: this is not a "component" in the ICE definition, this is really a
+ // stream ID. This is just the way the stats API is standardized right now.
+ // Very confusing.
+ std::string streamId(
+ NS_ConvertUTF16toUTF8(cand.mComponentId.Value()).get());
+
+ streamResults[streamId].candidateTypeBitpattern |= candBitmask;
+ }
+
+ for (auto i = streamResults.begin(); i != streamResults.end(); ++i) {
+ Telemetry::RecordWebrtcIceCandidates(i->second.candidateTypeBitpattern,
+ i->second.streamSucceeded);
+ }
+
+ // Beyond ICE, accumulate telemetry for various PER_CALL settings here.
+
+ if (query->report->mOutboundRTPStreamStats.WasPassed()) {
+ auto& array = query->report->mOutboundRTPStreamStats.Value();
+ for (decltype(array.Length()) i = 0; i < array.Length(); i++) {
+ auto& s = array[i];
+ bool isVideo = (s.mId.Value().Find("video") != -1);
+ if (!isVideo || s.mIsRemote) {
+ continue;
+ }
+ if (s.mBitrateMean.WasPassed()) {
+ Accumulate(WEBRTC_VIDEO_ENCODER_BITRATE_AVG_PER_CALL_KBPS,
+ uint32_t(s.mBitrateMean.Value() / 1000));
+ }
+ if (s.mBitrateStdDev.WasPassed()) {
+ Accumulate(WEBRTC_VIDEO_ENCODER_BITRATE_STD_DEV_PER_CALL_KBPS,
+ uint32_t(s.mBitrateStdDev.Value() / 1000));
+ }
+ if (s.mFramerateMean.WasPassed()) {
+ Accumulate(WEBRTC_VIDEO_ENCODER_FRAMERATE_AVG_PER_CALL,
+ uint32_t(s.mFramerateMean.Value()));
+ }
+ if (s.mFramerateStdDev.WasPassed()) {
+ Accumulate(WEBRTC_VIDEO_ENCODER_FRAMERATE_10X_STD_DEV_PER_CALL,
+ uint32_t(s.mFramerateStdDev.Value() * 10));
+ }
+ if (s.mDroppedFrames.WasPassed() && !query->iceStartTime.IsNull()) {
+ double mins = (TimeStamp::Now() - query->iceStartTime).ToSeconds() / 60;
+ if (mins > 0) {
+ Accumulate(WEBRTC_VIDEO_ENCODER_DROPPED_FRAMES_PER_CALL_FPM,
+ uint32_t(double(s.mDroppedFrames.Value()) / mins));
+ }
+ }
+ }
+ }
+
+ if (query->report->mInboundRTPStreamStats.WasPassed()) {
+ auto& array = query->report->mInboundRTPStreamStats.Value();
+ for (decltype(array.Length()) i = 0; i < array.Length(); i++) {
+ auto& s = array[i];
+ bool isVideo = (s.mId.Value().Find("video") != -1);
+ if (!isVideo || s.mIsRemote) {
+ continue;
+ }
+ if (s.mBitrateMean.WasPassed()) {
+ Accumulate(WEBRTC_VIDEO_DECODER_BITRATE_AVG_PER_CALL_KBPS,
+ uint32_t(s.mBitrateMean.Value() / 1000));
+ }
+ if (s.mBitrateStdDev.WasPassed()) {
+ Accumulate(WEBRTC_VIDEO_DECODER_BITRATE_STD_DEV_PER_CALL_KBPS,
+ uint32_t(s.mBitrateStdDev.Value() / 1000));
+ }
+ if (s.mFramerateMean.WasPassed()) {
+ Accumulate(WEBRTC_VIDEO_DECODER_FRAMERATE_AVG_PER_CALL,
+ uint32_t(s.mFramerateMean.Value()));
+ }
+ if (s.mFramerateStdDev.WasPassed()) {
+ Accumulate(WEBRTC_VIDEO_DECODER_FRAMERATE_10X_STD_DEV_PER_CALL,
+ uint32_t(s.mFramerateStdDev.Value() * 10));
+ }
+ if (s.mDiscardedPackets.WasPassed() && !query->iceStartTime.IsNull()) {
+ double mins = (TimeStamp::Now() - query->iceStartTime).ToSeconds() / 60;
+ if (mins > 0) {
+ Accumulate(WEBRTC_VIDEO_DECODER_DISCARDED_PACKETS_PER_CALL_PPM,
+ uint32_t(double(s.mDiscardedPackets.Value()) / mins));
+ }
+ }
+ }
+ }
+
+ // Finally, store the stats
+
+ PeerConnectionCtx *ctx = GetPeerConnectionCtx();
+ if (ctx) {
+ ctx->mStatsForClosedPeerConnections.AppendElement(*query->report, fallible);
+ }
+}
+
+static void GetStatsForLongTermStorage_s(
+ nsAutoPtr<RTCStatsQuery> query) {
+
+ MOZ_ASSERT(query);
+
+ nsresult rv = PeerConnectionImpl::ExecuteStatsQuery_s(query.get());
+
+ // Check whether packets were dropped due to rate limiting during
+ // this call. (These calls must be made on STS)
+ unsigned char rate_limit_bit_pattern = 0;
+ if (!mozilla::nr_socket_short_term_violation_time().IsNull() &&
+ !query->iceStartTime.IsNull() &&
+ mozilla::nr_socket_short_term_violation_time() >= query->iceStartTime) {
+ rate_limit_bit_pattern |= 1;
+ }
+ if (!mozilla::nr_socket_long_term_violation_time().IsNull() &&
+ !query->iceStartTime.IsNull() &&
+ mozilla::nr_socket_long_term_violation_time() >= query->iceStartTime) {
+ rate_limit_bit_pattern |= 2;
+ }
+
+ if (query->failed) {
+ Telemetry::Accumulate(
+ Telemetry::WEBRTC_STUN_RATE_LIMIT_EXCEEDED_BY_TYPE_GIVEN_FAILURE,
+ rate_limit_bit_pattern);
+ } else {
+ Telemetry::Accumulate(
+ Telemetry::WEBRTC_STUN_RATE_LIMIT_EXCEEDED_BY_TYPE_GIVEN_SUCCESS,
+ rate_limit_bit_pattern);
+ }
+
+ // Even if Telemetry::Accumulate is threadsafe, we still need to send the
+ // query back to main, since that is where it must be destroyed.
+ NS_DispatchToMainThread(
+ WrapRunnableNM(
+ &StoreLongTermICEStatisticsImpl_m,
+ rv,
+ query),
+ NS_DISPATCH_NORMAL);
+}
+
+void WebrtcGlobalInformation::StoreLongTermICEStatistics(
+ PeerConnectionImpl& aPc) {
+ Telemetry::Accumulate(Telemetry::WEBRTC_ICE_FINAL_CONNECTION_STATE,
+ static_cast<uint32_t>(aPc.IceConnectionState()));
+
+ if (aPc.IceConnectionState() == PCImplIceConnectionState::New) {
+ // ICE has not started; we won't have any remote candidates, so recording
+ // statistics on gathered candidates is pointless.
+ return;
+ }
+
+ nsAutoPtr<RTCStatsQuery> query(new RTCStatsQuery(true));
+
+ nsresult rv = aPc.BuildStatsQuery_m(nullptr, query.get());
+
+ NS_ENSURE_SUCCESS_VOID(rv);
+
+ RUN_ON_THREAD(aPc.GetSTSThread(),
+ WrapRunnableNM(&GetStatsForLongTermStorage_s,
+ query),
+ NS_DISPATCH_NORMAL);
+}
+
+} // namespace dom
+} // namespace mozilla
diff --git a/media/webrtc/signaling/src/peerconnection/WebrtcGlobalInformation.h b/media/webrtc/signaling/src/peerconnection/WebrtcGlobalInformation.h
new file mode 100644
index 000000000..fb3789c20
--- /dev/null
+++ b/media/webrtc/signaling/src/peerconnection/WebrtcGlobalInformation.h
@@ -0,0 +1,56 @@
+/* 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/. */
+
+#ifndef _WEBRTC_GLOBAL_INFORMATION_H_
+#define _WEBRTC_GLOBAL_INFORMATION_H_
+
+#include "nsString.h"
+#include "mozilla/dom/BindingDeclarations.h" // for Optional
+
+namespace mozilla {
+class PeerConnectionImpl;
+class ErrorResult;
+
+namespace dom {
+
+class GlobalObject;
+class WebrtcGlobalStatisticsCallback;
+class WebrtcGlobalLoggingCallback;
+
+class WebrtcGlobalInformation
+{
+public:
+ static void GetAllStats(const GlobalObject& aGlobal,
+ WebrtcGlobalStatisticsCallback& aStatsCallback,
+ const Optional<nsAString>& pcIdFilter,
+ ErrorResult& aRv);
+
+ static void ClearAllStats(const GlobalObject& aGlobal);
+
+ static void GetLogging(const GlobalObject& aGlobal,
+ const nsAString& aPattern,
+ WebrtcGlobalLoggingCallback& aLoggingCallback,
+ ErrorResult& aRv);
+
+ static void ClearLogging(const GlobalObject& aGlobal);
+
+ static void SetDebugLevel(const GlobalObject& aGlobal, int32_t aLevel);
+ static int32_t DebugLevel(const GlobalObject& aGlobal);
+
+ static void SetAecDebug(const GlobalObject& aGlobal, bool aEnable);
+ static bool AecDebug(const GlobalObject& aGlobal);
+
+ static void StoreLongTermICEStatistics(PeerConnectionImpl& aPc);
+
+private:
+ WebrtcGlobalInformation() = delete;
+ WebrtcGlobalInformation(const WebrtcGlobalInformation& aOrig) = delete;
+ WebrtcGlobalInformation& operator=(
+ const WebrtcGlobalInformation& aRhs) = delete;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // _WEBRTC_GLOBAL_INFORMATION_H_
diff --git a/media/webrtc/signaling/src/peerconnection/WebrtcGlobalParent.h b/media/webrtc/signaling/src/peerconnection/WebrtcGlobalParent.h
new file mode 100644
index 000000000..4e2d0509f
--- /dev/null
+++ b/media/webrtc/signaling/src/peerconnection/WebrtcGlobalParent.h
@@ -0,0 +1,53 @@
+/* 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/. */
+
+#ifndef _WEBRTC_GLOBAL_PARENT_H_
+#define _WEBRTC_GLOBAL_PARENT_H_
+
+#include "mozilla/dom/PWebrtcGlobalParent.h"
+#include "mozilla/dom/RTCStatsReportBinding.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "nsISupportsImpl.h"
+
+namespace mozilla {
+namespace dom {
+
+class WebrtcParents;
+
+class WebrtcGlobalParent
+ : public PWebrtcGlobalParent
+{
+ friend class ContentParent;
+ friend class WebrtcGlobalInformation;
+ friend class WebrtcContentParents;
+
+ bool mShutdown;
+
+ MOZ_IMPLICIT WebrtcGlobalParent();
+
+ static WebrtcGlobalParent* Alloc();
+ static bool Dealloc(WebrtcGlobalParent* aActor);
+
+ virtual bool RecvGetStatsResult(const int& aRequestId,
+ nsTArray<RTCStatsReportInternal>&& aStats) override;
+ virtual bool RecvGetLogResult(const int& aRequestId,
+ const WebrtcGlobalLog& aLog) override;
+
+ virtual void ActorDestroy(ActorDestroyReason aWhy) override;
+ virtual bool Recv__delete__() override;
+
+ virtual ~WebrtcGlobalParent();
+public:
+ NS_INLINE_DECL_REFCOUNTING(WebrtcGlobalParent)
+
+ bool IsActive()
+ {
+ return !mShutdown;
+ }
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // _WEBRTC_GLOBAL_PARENT_H_
diff --git a/media/webrtc/signaling/src/sdp/Sdp.h b/media/webrtc/signaling/src/sdp/Sdp.h
new file mode 100644
index 000000000..8eeb89e2f
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/Sdp.h
@@ -0,0 +1,195 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* 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/. */
+
+/*
+
+ ,-----. ,--. ,--.
+ ' .--./ ,--,--.,--.,--.,-' '-.`--' ,---. ,--,--,
+ | | ' ,-. || || |'-. .-',--.| .-. || `
+ ' '--'\\ '-' |' '' ' | | | |' '-' '| || |
+ `-----' `--`--' `----' `--' `--' `---' `--''--'
+
+ :+o+-
+ -dNNNNNd.
+ yNNNNNNNs
+ :mNNNNNm-
+ `/sso/``-://-
+ .:+sydNNNNNNms: `://`
+ `-/+shmNNNNNNNNNNNNNNNms- :mNNNm/
+ `-/oydmNNNNNNNNNNNNNNNNNNNNNNNNdo- +NNNNNN+
+ .shmNNNNNNNNNNNmdyo/:dNNNNNNNNNNNNNNNNdo. `sNNNNNm+
+ hNNNNNNNNmhs+:-` .dNNNNNNNNNNNNNNNNNNNNh+-` `hNNNNNm:
+ -yddyo/:. -dNNNNm::ymNNNNNNNNNNNNNNNmdy+/dNNNNNd.
+ :mNNNNd. `/ymNNNNNNNNNNNNNNNNNNNNNNh`
+ +NNNNNh` `+hNNNNNNNNNNNNNNNNNNNs
+ sNNNNNy` .yNNNNNm`-/oymNNNm+
+ `yNNNNNo oNNNNNm` `-.
+ .dNNNNm/ oNNNNNm`
+ oNNNNm: +NNNNNm`
+ `+yho. +NNNNNm`
+ +NNNNNNs.
+ `yNNNNNNmy-
+ -smNNNNNNh:
+ .smNNNNNNh/
+ `omNNNNNNd:
+ `+dNNNNNd
+ ````......```` /hmdy-
+ `.:/+osyhddmNNMMMMMMMMMMMMMMMMMMMMNNmddhyso+/:.`
+ `-+shmNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNmhs+-`
+ -smMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMds-
+ hMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMh
+ yMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMs
+ .ohNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNh+.
+ ./oydmMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMmhyo:.
+ `.:/+osyyhddmmNNMMMMMMMMMMMMMMNNmmddhyyso+/:.`
+
+ ,--------.,--. ,--. ,--.
+ '--. .--'| ,---. `--' ,---. | | ,---.
+ | | | .-. |,--.( .-' | |( .-'
+ | | | | | || |.-' `) | |.-' `)
+ `--' `--' `--'`--'`----' `--'`----'
+ ,--.
+ ,---. ,------. ,------. ,--. | |
+ ' .-' | .-. \ | .--. ' ,--,--.,--.--.,-' '-. ,--,--.| |
+ `. `-. | | \ :| '--' |' ,-. || .--''-. .-'' ,-. || |
+ .-' || '--' /| | --' \ '-' || | | | \ '-' |`--'
+ `-----' `-------' `--' `--`--'`--' `--' `--`--'.--.
+ '__'
+*/
+
+#ifndef _SDP_H_
+#define _SDP_H_
+
+#include <ostream>
+#include <vector>
+#include <sstream>
+#include "mozilla/UniquePtr.h"
+#include "mozilla/Maybe.h"
+#include "signaling/src/sdp/SdpMediaSection.h"
+#include "signaling/src/sdp/SdpAttributeList.h"
+#include "signaling/src/sdp/SdpEnum.h"
+
+namespace mozilla
+{
+
+class SdpOrigin;
+class SdpEncryptionKey;
+class SdpMediaSection;
+
+/**
+ * Base class for an SDP
+ */
+class Sdp
+{
+public:
+ Sdp(){};
+ virtual ~Sdp(){};
+
+ virtual const SdpOrigin& GetOrigin() const = 0;
+ // Note: connection information is always retrieved from media sections
+ virtual uint32_t GetBandwidth(const std::string& type) const = 0;
+
+ virtual const SdpAttributeList& GetAttributeList() const = 0;
+ virtual SdpAttributeList& GetAttributeList() = 0;
+
+ virtual size_t GetMediaSectionCount() const = 0;
+ virtual const SdpMediaSection& GetMediaSection(size_t level) const = 0;
+ virtual SdpMediaSection& GetMediaSection(size_t level) = 0;
+
+ virtual SdpMediaSection& AddMediaSection(SdpMediaSection::MediaType media,
+ SdpDirectionAttribute::Direction dir,
+ uint16_t port,
+ SdpMediaSection::Protocol proto,
+ sdp::AddrType addrType,
+ const std::string& addr) = 0;
+
+ virtual void Serialize(std::ostream&) const = 0;
+
+ std::string ToString() const;
+};
+
+inline std::ostream& operator<<(std::ostream& os, const Sdp& sdp)
+{
+ sdp.Serialize(os);
+ return os;
+}
+
+inline std::string
+Sdp::ToString() const
+{
+ std::stringstream s;
+ s << *this;
+ return s.str();
+}
+
+class SdpOrigin
+{
+public:
+ SdpOrigin(const std::string& username, uint64_t sessId, uint64_t sessVer,
+ sdp::AddrType addrType, const std::string& addr)
+ : mUsername(username),
+ mSessionId(sessId),
+ mSessionVersion(sessVer),
+ mAddrType(addrType),
+ mAddress(addr)
+ {
+ }
+
+ const std::string&
+ GetUsername() const
+ {
+ return mUsername;
+ }
+
+ uint64_t
+ GetSessionId() const
+ {
+ return mSessionId;
+ }
+
+ uint64_t
+ GetSessionVersion() const
+ {
+ return mSessionVersion;
+ }
+
+ sdp::AddrType
+ GetAddrType() const
+ {
+ return mAddrType;
+ }
+
+ const std::string&
+ GetAddress() const
+ {
+ return mAddress;
+ }
+
+ void
+ Serialize(std::ostream& os) const
+ {
+ sdp::NetType netType = sdp::kInternet;
+ os << "o=" << mUsername << " " << mSessionId << " " << mSessionVersion
+ << " " << netType << " " << mAddrType << " " << mAddress << "\r\n";
+ }
+
+private:
+ std::string mUsername;
+ uint64_t mSessionId;
+ uint64_t mSessionVersion;
+ sdp::AddrType mAddrType;
+ std::string mAddress;
+};
+
+inline std::ostream& operator<<(std::ostream& os, const SdpOrigin& origin)
+{
+ origin.Serialize(os);
+ return os;
+}
+
+} // namespace mozilla
+
+#endif
diff --git a/media/webrtc/signaling/src/sdp/SdpAttribute.cpp b/media/webrtc/signaling/src/sdp/SdpAttribute.cpp
new file mode 100644
index 000000000..06fc94dbb
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/SdpAttribute.cpp
@@ -0,0 +1,1674 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* 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 "signaling/src/sdp/SdpAttribute.h"
+#include "signaling/src/sdp/SdpHelper.h"
+#include <iomanip>
+
+#ifdef CRLF
+#undef CRLF
+#endif
+#define CRLF "\r\n"
+
+namespace mozilla
+{
+
+static unsigned char
+PeekChar(std::istream& is, std::string* error)
+{
+ int next = is.peek();
+ if (next == EOF) {
+ *error = "Truncated";
+ return 0;
+ }
+
+ return next;
+}
+
+static std::string ParseToken(std::istream& is,
+ const std::string& delims,
+ std::string* error)
+{
+ std::string token;
+ while (is) {
+ unsigned char c = PeekChar(is, error);
+ if (!c || (delims.find(c) != std::string::npos)) {
+ break;
+ }
+ token.push_back(std::tolower(is.get()));
+ }
+ return token;
+}
+
+static bool
+SkipChar(std::istream& is, unsigned char c, std::string* error)
+{
+ if (PeekChar(is, error) != c) {
+ *error = "Expected \'";
+ error->push_back(c);
+ error->push_back('\'');
+ return false;
+ }
+
+ is.get();
+ return true;
+}
+
+
+void
+SdpConnectionAttribute::Serialize(std::ostream& os) const
+{
+ os << "a=" << mType << ":" << mValue << CRLF;
+}
+
+void
+SdpDirectionAttribute::Serialize(std::ostream& os) const
+{
+ os << "a=" << mValue << CRLF;
+}
+
+void
+SdpDtlsMessageAttribute::Serialize(std::ostream& os) const
+{
+ os << "a=" << mType << ":" << mRole << " " << mValue << CRLF;
+}
+
+bool
+SdpDtlsMessageAttribute::Parse(std::istream& is, std::string* error)
+{
+ std::string roleToken = ParseToken(is, " ", error);
+ if (roleToken == "server") {
+ mRole = kServer;
+ } else if (roleToken == "client") {
+ mRole = kClient;
+ } else {
+ *error = "Invalid dtls-message role; must be either client or server";
+ return false;
+ }
+
+ is >> std::ws;
+
+ std::string s(std::istreambuf_iterator<char>(is), {});
+ mValue = s;
+
+ return true;
+}
+
+void
+SdpExtmapAttributeList::Serialize(std::ostream& os) const
+{
+ for (auto i = mExtmaps.begin(); i != mExtmaps.end(); ++i) {
+ os << "a=" << mType << ":" << i->entry;
+ if (i->direction_specified) {
+ os << "/" << i->direction;
+ }
+ os << " " << i->extensionname;
+ if (i->extensionattributes.length()) {
+ os << " " << i->extensionattributes;
+ }
+ os << CRLF;
+ }
+}
+
+void
+SdpFingerprintAttributeList::Serialize(std::ostream& os) const
+{
+ for (auto i = mFingerprints.begin(); i != mFingerprints.end(); ++i) {
+ os << "a=" << mType << ":" << i->hashFunc << " "
+ << FormatFingerprint(i->fingerprint) << CRLF;
+ }
+}
+
+// Format the fingerprint in RFC 4572 Section 5 attribute format
+std::string
+SdpFingerprintAttributeList::FormatFingerprint(const std::vector<uint8_t>& fp)
+{
+ if (fp.empty()) {
+ MOZ_ASSERT(false, "Cannot format an empty fingerprint.");
+ return "";
+ }
+
+ std::ostringstream os;
+ for (auto i = fp.begin(); i != fp.end(); ++i) {
+ os << ":" << std::hex << std::uppercase << std::setw(2) << std::setfill('0')
+ << static_cast<uint32_t>(*i);
+ }
+ return os.str().substr(1);
+}
+
+static uint8_t
+FromUppercaseHex(char ch)
+{
+ if ((ch >= '0') && (ch <= '9')) {
+ return ch - '0';
+ }
+ if ((ch >= 'A') && (ch <= 'F')) {
+ return ch - 'A' + 10;
+ }
+ return 16; // invalid
+}
+
+// Parse the fingerprint from RFC 4572 Section 5 attribute format
+std::vector<uint8_t>
+SdpFingerprintAttributeList::ParseFingerprint(const std::string& str)
+{
+ size_t targetSize = (str.length() + 1) / 3;
+ std::vector<uint8_t> fp(targetSize);
+ size_t fpIndex = 0;
+
+ if (str.length() % 3 != 2) {
+ fp.clear();
+ return fp;
+ }
+
+ for (size_t i = 0; i < str.length(); i += 3) {
+ uint8_t high = FromUppercaseHex(str[i]);
+ uint8_t low = FromUppercaseHex(str[i + 1]);
+ if (high > 0xf || low > 0xf ||
+ (i + 2 < str.length() && str[i + 2] != ':')) {
+ fp.clear(); // error
+ return fp;
+ }
+ fp[fpIndex++] = high << 4 | low;
+ }
+ return fp;
+}
+
+void
+SdpFmtpAttributeList::Serialize(std::ostream& os) const
+{
+ for (auto i = mFmtps.begin(); i != mFmtps.end(); ++i) {
+ if (i->parameters) {
+ os << "a=" << mType << ":" << i->format << " ";
+ i->parameters->Serialize(os);
+ os << CRLF;
+ }
+ }
+}
+
+void
+SdpGroupAttributeList::Serialize(std::ostream& os) const
+{
+ for (auto i = mGroups.begin(); i != mGroups.end(); ++i) {
+ os << "a=" << mType << ":" << i->semantics;
+ for (auto j = i->tags.begin(); j != i->tags.end(); ++j) {
+ os << " " << (*j);
+ }
+ os << CRLF;
+ }
+}
+
+// We're just using an SdpStringAttribute for this right now
+#if 0
+void SdpIdentityAttribute::Serialize(std::ostream& os) const
+{
+ os << "a=" << mType << ":" << mAssertion;
+ for (auto i = mExtensions.begin(); i != mExtensions.end(); i++) {
+ os << (i == mExtensions.begin() ? " " : ";") << (*i);
+ }
+ os << CRLF;
+}
+#endif
+
+// Class to help with omitting a leading delimiter for the first item in a list
+class SkipFirstDelimiter
+{
+ public:
+ explicit SkipFirstDelimiter(const std::string& delim) :
+ mDelim(delim),
+ mFirst(true)
+ {}
+
+ std::ostream& print(std::ostream& os)
+ {
+ if (!mFirst) {
+ os << mDelim;
+ }
+ mFirst = false;
+ return os;
+ }
+
+ private:
+ std::string mDelim;
+ bool mFirst;
+};
+
+static std::ostream& operator<<(std::ostream& os, SkipFirstDelimiter& delim)
+{
+ return delim.print(os);
+}
+
+void
+SdpImageattrAttributeList::XYRange::Serialize(std::ostream& os) const
+{
+ if (discreteValues.size() == 0) {
+ os << "[" << min << ":";
+ if (step != 1) {
+ os << step << ":";
+ }
+ os << max << "]";
+ } else if (discreteValues.size() == 1) {
+ os << discreteValues.front();
+ } else {
+ os << "[";
+ SkipFirstDelimiter comma(",");
+ for (auto value : discreteValues) {
+ os << comma << value;
+ }
+ os << "]";
+ }
+}
+
+template<typename T>
+bool
+GetUnsigned(std::istream& is, T min, T max, T* value, std::string* error)
+{
+ if (PeekChar(is, error) == '-') {
+ *error = "Value is less than 0";
+ return false;
+ }
+
+ is >> std::noskipws >> *value;
+
+ if (is.fail()) {
+ *error = "Malformed";
+ return false;
+ }
+
+ if (*value < min) {
+ *error = "Value too small";
+ return false;
+ }
+
+ if (*value > max) {
+ *error = "Value too large";
+ return false;
+ }
+
+ return true;
+}
+
+static bool
+GetXYValue(std::istream& is, uint32_t* value, std::string* error)
+{
+ return GetUnsigned<uint32_t>(is, 1, 999999, value, error);
+}
+
+bool
+SdpImageattrAttributeList::XYRange::ParseDiscreteValues(std::istream& is,
+ std::string* error)
+{
+ do {
+ uint32_t value;
+ if (!GetXYValue(is, &value, error)) {
+ return false;
+ }
+ discreteValues.push_back(value);
+ } while (SkipChar(is, ',', error));
+
+ return SkipChar(is, ']', error);
+}
+
+bool
+SdpImageattrAttributeList::XYRange::ParseAfterMin(std::istream& is,
+ std::string* error)
+{
+ // We have already parsed "[320:", and now expect another uint
+ uint32_t value;
+ if (!GetXYValue(is, &value, error)) {
+ return false;
+ }
+
+ if (SkipChar(is, ':', error)) {
+ // Range with step eg [320:16:640]
+ step = value;
+ // Now |value| should be the max
+ if (!GetXYValue(is, &value, error)) {
+ return false;
+ }
+ }
+
+ max = value;
+ if (min >= max) {
+ *error = "Min is not smaller than max";
+ return false;
+ }
+
+ return SkipChar(is, ']', error);
+}
+
+bool
+SdpImageattrAttributeList::XYRange::ParseAfterBracket(std::istream& is,
+ std::string* error)
+{
+ // Either a range, or a list of discrete values
+ // [320:640], [320:16:640], or [320,640]
+ uint32_t value;
+ if (!GetXYValue(is, &value, error)) {
+ return false;
+ }
+
+ if (SkipChar(is, ':', error)) {
+ // Range - [640:480] or [640:16:480]
+ min = value;
+ return ParseAfterMin(is, error);
+ }
+
+ if (SkipChar(is, ',', error)) {
+ discreteValues.push_back(value);
+ return ParseDiscreteValues(is, error);
+ }
+
+ *error = "Expected \':\' or \',\'";
+ return false;
+}
+
+bool
+SdpImageattrAttributeList::XYRange::Parse(std::istream& is, std::string* error)
+{
+ if (SkipChar(is, '[', error)) {
+ return ParseAfterBracket(is, error);
+ }
+
+ // Single discrete value
+ uint32_t value;
+ if (!GetXYValue(is, &value, error)) {
+ return false;
+ }
+ discreteValues.push_back(value);
+
+ return true;
+}
+
+static bool
+GetSPValue(std::istream& is, float* value, std::string* error)
+{
+ return GetUnsigned<float>(is, 0.1f, 9.9999f, value, error);
+}
+
+static bool
+GetQValue(std::istream& is, float* value, std::string* error)
+{
+ return GetUnsigned<float>(is, 0.0f, 1.0f, value, error);
+}
+
+bool
+SdpImageattrAttributeList::SRange::ParseDiscreteValues(std::istream& is,
+ std::string* error)
+{
+ do {
+ float value;
+ if (!GetSPValue(is, &value, error)) {
+ return false;
+ }
+ discreteValues.push_back(value);
+ } while (SkipChar(is, ',', error));
+
+ return SkipChar(is, ']', error);
+}
+
+bool
+SdpImageattrAttributeList::SRange::ParseAfterMin(std::istream& is,
+ std::string* error)
+{
+ if (!GetSPValue(is, &max, error)) {
+ return false;
+ }
+
+ if (min >= max) {
+ *error = "Min is not smaller than max";
+ return false;
+ }
+
+ return SkipChar(is, ']', error);
+}
+
+bool
+SdpImageattrAttributeList::SRange::ParseAfterBracket(std::istream& is,
+ std::string* error)
+{
+ // Either a range, or a list of discrete values
+ float value;
+ if (!GetSPValue(is, &value, error)) {
+ return false;
+ }
+
+ if (SkipChar(is, '-', error)) {
+ min = value;
+ return ParseAfterMin(is, error);
+ }
+
+ if (SkipChar(is, ',', error)) {
+ discreteValues.push_back(value);
+ return ParseDiscreteValues(is, error);
+ }
+
+ *error = "Expected either \'-\' or \',\'";
+ return false;
+}
+
+bool
+SdpImageattrAttributeList::SRange::Parse(std::istream& is, std::string* error)
+{
+ if (SkipChar(is, '[', error)) {
+ return ParseAfterBracket(is, error);
+ }
+
+ // Single discrete value
+ float value;
+ if (!GetSPValue(is, &value, error)) {
+ return false;
+ }
+ discreteValues.push_back(value);
+ return true;
+}
+
+bool
+SdpImageattrAttributeList::PRange::Parse(std::istream& is, std::string* error)
+{
+ if (!SkipChar(is, '[', error)) {
+ return false;
+ }
+
+ if (!GetSPValue(is, &min, error)) {
+ return false;
+ }
+
+ if (!SkipChar(is, '-', error)) {
+ return false;
+ }
+
+ if (!GetSPValue(is, &max, error)) {
+ return false;
+ }
+
+ if (min >= max) {
+ *error = "min must be smaller than max";
+ return false;
+ }
+
+ if (!SkipChar(is, ']', error)) {
+ return false;
+ }
+ return true;
+}
+
+void
+SdpImageattrAttributeList::SRange::Serialize(std::ostream& os) const
+{
+ os << std::setprecision(4) << std::fixed;
+ if (discreteValues.size() == 0) {
+ os << "[" << min << "-" << max << "]";
+ } else if (discreteValues.size() == 1) {
+ os << discreteValues.front();
+ } else {
+ os << "[";
+ SkipFirstDelimiter comma(",");
+ for (auto value : discreteValues) {
+ os << comma << value;
+ }
+ os << "]";
+ }
+}
+
+void
+SdpImageattrAttributeList::PRange::Serialize(std::ostream& os) const
+{
+ os << std::setprecision(4) << std::fixed;
+ os << "[" << min << "-" << max << "]";
+}
+
+static std::string ParseKey(std::istream& is, std::string* error)
+{
+ std::string token = ParseToken(is, "=", error);
+ if (!SkipChar(is, '=', error)) {
+ return "";
+ }
+ return token;
+}
+
+static bool SkipBraces(std::istream& is, std::string* error)
+{
+ if (PeekChar(is, error) != '[') {
+ *error = "Expected \'[\'";
+ return false;
+ }
+
+ size_t braceCount = 0;
+ do {
+ switch (PeekChar(is, error)) {
+ case '[':
+ ++braceCount;
+ break;
+ case ']':
+ --braceCount;
+ break;
+ default:
+ break;
+ }
+ is.get();
+ } while (braceCount && is);
+
+ if (!is) {
+ *error = "Expected closing brace";
+ return false;
+ }
+
+ return true;
+}
+
+// Assumptions:
+// 1. If the value contains '[' or ']', they are balanced.
+// 2. The value contains no ',' outside of brackets.
+static bool SkipValue(std::istream& is, std::string* error)
+{
+ while (is) {
+ switch (PeekChar(is, error)) {
+ case ',':
+ case ']':
+ return true;
+ case '[':
+ if (!SkipBraces(is, error)) {
+ return false;
+ }
+ break;
+ default:
+ is.get();
+ }
+ }
+
+ *error = "No closing \']\' on set";
+ return false;
+}
+
+bool
+SdpImageattrAttributeList::Set::Parse(std::istream& is, std::string* error)
+{
+ if (!SkipChar(is, '[', error)) {
+ return false;
+ }
+
+ if (ParseKey(is, error) != "x") {
+ *error = "Expected x=";
+ return false;
+ }
+
+ if (!xRange.Parse(is, error)) {
+ return false;
+ }
+
+ if (!SkipChar(is, ',', error)) {
+ return false;
+ }
+
+ if (ParseKey(is, error) != "y") {
+ *error = "Expected y=";
+ return false;
+ }
+
+ if (!yRange.Parse(is, error)) {
+ return false;
+ }
+
+ qValue = 0.5f; // default
+
+ bool gotSar = false;
+ bool gotPar = false;
+ bool gotQ = false;
+
+ while (SkipChar(is, ',', error)) {
+ std::string key = ParseKey(is, error);
+ if (key.empty()) {
+ *error = "Expected key-value";
+ return false;
+ }
+
+ if (key == "sar") {
+ if (gotSar) {
+ *error = "Extra sar parameter";
+ return false;
+ }
+ gotSar = true;
+ if (!sRange.Parse(is, error)) {
+ return false;
+ }
+ } else if (key == "par") {
+ if (gotPar) {
+ *error = "Extra par parameter";
+ return false;
+ }
+ gotPar = true;
+ if (!pRange.Parse(is, error)) {
+ return false;
+ }
+ } else if (key == "q") {
+ if (gotQ) {
+ *error = "Extra q parameter";
+ return false;
+ }
+ gotQ = true;
+ if (!GetQValue(is, &qValue, error)) {
+ return false;
+ }
+ } else {
+ if (!SkipValue(is, error)) {
+ return false;
+ }
+ }
+ }
+
+ return SkipChar(is, ']', error);
+}
+
+void
+SdpImageattrAttributeList::Set::Serialize(std::ostream& os) const
+{
+ os << "[x=";
+ xRange.Serialize(os);
+ os << ",y=";
+ yRange.Serialize(os);
+ if (sRange.IsSet()) {
+ os << ",sar=";
+ sRange.Serialize(os);
+ }
+ if (pRange.IsSet()) {
+ os << ",par=";
+ pRange.Serialize(os);
+ }
+ if (qValue >= 0) {
+ os << std::setprecision(2) << std::fixed << ",q=" << qValue;
+ }
+ os << "]";
+}
+
+bool
+SdpImageattrAttributeList::Imageattr::ParseSets(std::istream& is,
+ std::string* error)
+{
+ std::string type = ParseToken(is, " \t", error);
+
+ bool* isAll = nullptr;
+ std::vector<Set>* sets = nullptr;
+
+ if (type == "send") {
+ isAll = &sendAll;
+ sets = &sendSets;
+ } else if (type == "recv") {
+ isAll = &recvAll;
+ sets = &recvSets;
+ } else {
+ *error = "Unknown type, must be either send or recv";
+ return false;
+ }
+
+ if (*isAll || !sets->empty()) {
+ *error = "Multiple send or recv set lists";
+ return false;
+ }
+
+ is >> std::ws;
+ if (SkipChar(is, '*', error)) {
+ *isAll = true;
+ return true;
+ }
+
+ do {
+ Set set;
+ if (!set.Parse(is, error)) {
+ return false;
+ }
+
+ sets->push_back(set);
+ is >> std::ws;
+ } while (PeekChar(is, error) == '[');
+
+ return true;
+}
+
+bool
+SdpImageattrAttributeList::Imageattr::Parse(std::istream& is,
+ std::string* error)
+{
+ if (!SkipChar(is, '*', error)) {
+ uint16_t value;
+ if (!GetUnsigned<uint16_t>(is, 0, UINT16_MAX, &value, error)) {
+ return false;
+ }
+ pt = Some(value);
+ }
+
+ is >> std::ws;
+ if (!ParseSets(is, error)) {
+ return false;
+ }
+
+ // There might be a second one
+ is >> std::ws;
+ if (is.eof()) {
+ return true;
+ }
+
+ if (!ParseSets(is, error)) {
+ return false;
+ }
+
+ is >> std::ws;
+ if (!is.eof()) {
+ *error = "Trailing characters";
+ return false;
+ }
+
+ return true;
+}
+
+void
+SdpImageattrAttributeList::Imageattr::Serialize(std::ostream& os) const
+{
+ if (pt.isSome()) {
+ os << *pt;
+ } else {
+ os << "*";
+ }
+
+ if (sendAll) {
+ os << " send *";
+ } else if (!sendSets.empty()) {
+ os << " send";
+ for (auto& set : sendSets) {
+ os << " ";
+ set.Serialize(os);
+ }
+ }
+
+ if (recvAll) {
+ os << " recv *";
+ } else if (!recvSets.empty()) {
+ os << " recv";
+ for (auto& set : recvSets) {
+ os << " ";
+ set.Serialize(os);
+ }
+ }
+}
+
+void
+SdpImageattrAttributeList::Serialize(std::ostream& os) const
+{
+ for (auto& imageattr : mImageattrs) {
+ os << "a=" << mType << ":";
+ imageattr.Serialize(os);
+ os << CRLF;
+ }
+}
+
+bool
+SdpImageattrAttributeList::PushEntry(const std::string& raw,
+ std::string* error,
+ size_t* errorPos)
+{
+ std::istringstream is(raw);
+
+ Imageattr imageattr;
+ if (!imageattr.Parse(is, error)) {
+ is.clear();
+ *errorPos = is.tellg();
+ return false;
+ }
+
+ mImageattrs.push_back(imageattr);
+ return true;
+}
+
+void
+SdpMsidAttributeList::Serialize(std::ostream& os) const
+{
+ for (auto i = mMsids.begin(); i != mMsids.end(); ++i) {
+ os << "a=" << mType << ":" << i->identifier;
+ if (i->appdata.length()) {
+ os << " " << i->appdata;
+ }
+ os << CRLF;
+ }
+}
+
+void
+SdpMsidSemanticAttributeList::Serialize(std::ostream& os) const
+{
+ for (auto i = mMsidSemantics.begin(); i != mMsidSemantics.end(); ++i) {
+ os << "a=" << mType << ":" << i->semantic;
+ for (auto j = i->msids.begin(); j != i->msids.end(); ++j) {
+ os << " " << *j;
+ }
+ os << CRLF;
+ }
+}
+
+void
+SdpRemoteCandidatesAttribute::Serialize(std::ostream& os) const
+{
+ if (mCandidates.empty()) {
+ return;
+ }
+
+ os << "a=" << mType;
+ for (auto i = mCandidates.begin(); i != mCandidates.end(); i++) {
+ os << (i == mCandidates.begin() ? ":" : " ") << i->id << " " << i->address
+ << " " << i->port;
+ }
+ os << CRLF;
+}
+
+bool
+SdpRidAttributeList::Rid::ParseParameters(std::istream& is, std::string* error)
+{
+ if (!PeekChar(is, error)) {
+ // No parameters
+ return true;
+ }
+
+ do {
+ is >> std::ws;
+ std::string key = ParseKey(is, error);
+ if (key.empty()) {
+ return false; // Illegal trailing cruft
+ }
+
+ // This allows pt= to appear anywhere, instead of only at the beginning, but
+ // this ends up being significantly less code.
+ if (key == "pt") {
+ if (!ParseFormats(is, error)) {
+ return false;
+ }
+ } else if (key == "max-width") {
+ if (!GetUnsigned<uint32_t>(
+ is, 0, UINT32_MAX, &constraints.maxWidth, error)) {
+ return false;
+ }
+ } else if (key == "max-height") {
+ if (!GetUnsigned<uint32_t>(
+ is, 0, UINT32_MAX, &constraints.maxHeight, error)) {
+ return false;
+ }
+ } else if (key == "max-fps") {
+ if (!GetUnsigned<uint32_t>(
+ is, 0, UINT32_MAX, &constraints.maxFps, error)) {
+ return false;
+ }
+ } else if (key == "max-fs") {
+ if (!GetUnsigned<uint32_t>(
+ is, 0, UINT32_MAX, &constraints.maxFs, error)) {
+ return false;
+ }
+ } else if (key == "max-br") {
+ if (!GetUnsigned<uint32_t>(
+ is, 0, UINT32_MAX, &constraints.maxBr, error)) {
+ return false;
+ }
+ } else if (key == "max-pps") {
+ if (!GetUnsigned<uint32_t>(
+ is, 0, UINT32_MAX, &constraints.maxPps, error)) {
+ return false;
+ }
+ } else if (key == "depend") {
+ if (!ParseDepend(is, error)) {
+ return false;
+ }
+ } else {
+ (void) ParseToken(is, ";", error);
+ }
+ } while (SkipChar(is, ';', error));
+ return true;
+}
+
+bool
+SdpRidAttributeList::Rid::ParseDepend(
+ std::istream& is,
+ std::string* error)
+{
+ do {
+ std::string id = ParseToken(is, ",;", error);
+ if (id.empty()) {
+ return false;
+ }
+ dependIds.push_back(id);
+ } while(SkipChar(is, ',', error));
+
+ return true;
+}
+
+bool
+SdpRidAttributeList::Rid::ParseFormats(
+ std::istream& is,
+ std::string* error)
+{
+ do {
+ uint16_t fmt;
+ if (!GetUnsigned<uint16_t>(is, 0, 127, &fmt, error)) {
+ return false;
+ }
+ formats.push_back(fmt);
+ } while (SkipChar(is, ',', error));
+
+ return true;
+}
+
+void
+SdpRidAttributeList::Rid::SerializeParameters(std::ostream& os) const
+{
+ if (!HasParameters()) {
+ return;
+ }
+
+ os << " ";
+
+ SkipFirstDelimiter semic(";");
+
+ if (!formats.empty()) {
+ os << semic << "pt=";
+ SkipFirstDelimiter comma(",");
+ for (uint16_t fmt : formats) {
+ os << comma << fmt;
+ }
+ }
+
+ if (constraints.maxWidth) {
+ os << semic << "max-width=" << constraints.maxWidth;
+ }
+
+ if (constraints.maxHeight) {
+ os << semic << "max-height=" << constraints.maxHeight;
+ }
+
+ if (constraints.maxFps) {
+ os << semic << "max-fps=" << constraints.maxFps;
+ }
+
+ if (constraints.maxFs) {
+ os << semic << "max-fs=" << constraints.maxFs;
+ }
+
+ if (constraints.maxBr) {
+ os << semic << "max-br=" << constraints.maxBr;
+ }
+
+ if (constraints.maxPps) {
+ os << semic << "max-pps=" << constraints.maxPps;
+ }
+
+ if (!dependIds.empty()) {
+ os << semic << "depend=";
+ SkipFirstDelimiter comma(",");
+ for (const std::string& id : dependIds) {
+ os << comma << id;
+ }
+ }
+}
+
+bool
+SdpRidAttributeList::Rid::Parse(std::istream& is, std::string* error)
+{
+ id = ParseToken(is, " ", error);
+ if (id.empty()) {
+ return false;
+ }
+
+ is >> std::ws;
+ std::string directionToken = ParseToken(is, " ", error);
+ if (directionToken == "send") {
+ direction = sdp::kSend;
+ } else if (directionToken == "recv") {
+ direction = sdp::kRecv;
+ } else {
+ *error = "Invalid direction, must be either send or recv";
+ return false;
+ }
+
+ return ParseParameters(is, error);
+}
+
+void
+SdpRidAttributeList::Rid::Serialize(std::ostream& os) const
+{
+ os << id << " " << direction;
+ SerializeParameters(os);
+}
+
+bool
+SdpRidAttributeList::Rid::HasFormat(const std::string& format) const
+{
+ uint16_t formatAsInt;
+ if (!SdpHelper::GetPtAsInt(format, &formatAsInt)) {
+ return false;
+ }
+
+ if (formats.empty()) {
+ return true;
+ }
+
+ return (std::find(formats.begin(), formats.end(), formatAsInt) !=
+ formats.end());
+}
+
+void
+SdpRidAttributeList::Serialize(std::ostream& os) const
+{
+ for (const Rid& rid : mRids) {
+ os << "a=" << mType << ":";
+ rid.Serialize(os);
+ os << CRLF;
+ }
+}
+
+bool
+SdpRidAttributeList::PushEntry(const std::string& raw,
+ std::string* error,
+ size_t* errorPos)
+{
+ std::istringstream is(raw);
+
+ Rid rid;
+ if (!rid.Parse(is, error)) {
+ is.clear();
+ *errorPos = is.tellg();
+ return false;
+ }
+
+ mRids.push_back(rid);
+ return true;
+}
+
+void
+SdpRtcpAttribute::Serialize(std::ostream& os) const
+{
+ os << "a=" << mType << ":" << mPort;
+ if (!mAddress.empty()) {
+ os << " " << mNetType << " " << mAddrType << " " << mAddress;
+ }
+ os << CRLF;
+}
+
+const char* SdpRtcpFbAttributeList::pli = "pli";
+const char* SdpRtcpFbAttributeList::sli = "sli";
+const char* SdpRtcpFbAttributeList::rpsi = "rpsi";
+const char* SdpRtcpFbAttributeList::app = "app";
+
+const char* SdpRtcpFbAttributeList::fir = "fir";
+const char* SdpRtcpFbAttributeList::tmmbr = "tmmbr";
+const char* SdpRtcpFbAttributeList::tstr = "tstr";
+const char* SdpRtcpFbAttributeList::vbcm = "vbcm";
+
+void
+SdpRtcpFbAttributeList::Serialize(std::ostream& os) const
+{
+ for (auto i = mFeedbacks.begin(); i != mFeedbacks.end(); ++i) {
+ os << "a=" << mType << ":" << i->pt << " " << i->type;
+ if (i->parameter.length()) {
+ os << " " << i->parameter;
+ if (i->extra.length()) {
+ os << " " << i->extra;
+ }
+ }
+ os << CRLF;
+ }
+}
+
+static bool
+ShouldSerializeChannels(SdpRtpmapAttributeList::CodecType type)
+{
+ switch (type) {
+ case SdpRtpmapAttributeList::kOpus:
+ case SdpRtpmapAttributeList::kG722:
+ return true;
+ case SdpRtpmapAttributeList::kPCMU:
+ case SdpRtpmapAttributeList::kPCMA:
+ case SdpRtpmapAttributeList::kVP8:
+ case SdpRtpmapAttributeList::kVP9:
+ case SdpRtpmapAttributeList::kiLBC:
+ case SdpRtpmapAttributeList::kiSAC:
+ case SdpRtpmapAttributeList::kH264:
+ case SdpRtpmapAttributeList::kRed:
+ case SdpRtpmapAttributeList::kUlpfec:
+ case SdpRtpmapAttributeList::kTelephoneEvent:
+ return false;
+ case SdpRtpmapAttributeList::kOtherCodec:
+ return true;
+ }
+ MOZ_CRASH();
+}
+
+void
+SdpRtpmapAttributeList::Serialize(std::ostream& os) const
+{
+ for (auto i = mRtpmaps.begin(); i != mRtpmaps.end(); ++i) {
+ os << "a=" << mType << ":" << i->pt << " " << i->name << "/" << i->clock;
+ if (i->channels && ShouldSerializeChannels(i->codec)) {
+ os << "/" << i->channels;
+ }
+ os << CRLF;
+ }
+}
+
+void
+SdpSctpmapAttributeList::Serialize(std::ostream& os) const
+{
+ for (auto i = mSctpmaps.begin(); i != mSctpmaps.end(); ++i) {
+ os << "a=" << mType << ":" << i->pt << " " << i->name << " " << i->streams
+ << CRLF;
+ }
+}
+
+void
+SdpSetupAttribute::Serialize(std::ostream& os) const
+{
+ os << "a=" << mType << ":" << mRole << CRLF;
+}
+
+void
+SdpSimulcastAttribute::Version::Serialize(std::ostream& os) const
+{
+ SkipFirstDelimiter comma(",");
+ for (const std::string& choice : choices) {
+ os << comma << choice;
+ }
+}
+
+bool
+SdpSimulcastAttribute::Version::Parse(std::istream& is, std::string* error)
+{
+ do {
+ std::string value = ParseToken(is, ",; ", error);
+ if (value.empty()) {
+ return false;
+ }
+ choices.push_back(value);
+ } while (SkipChar(is, ',', error));
+
+ return true;
+}
+
+bool
+SdpSimulcastAttribute::Version::GetChoicesAsFormats(
+ std::vector<uint16_t>* formats) const
+{
+ for (const std::string& choice : choices) {
+ uint16_t format;
+ if (!SdpHelper::GetPtAsInt(choice, &format) || (format > 127)) {
+ return false;
+ }
+ formats->push_back(format);
+ }
+
+ return true;
+}
+
+void
+SdpSimulcastAttribute::Versions::Serialize(std::ostream& os) const
+{
+ switch (type) {
+ case kRid:
+ os << "rid=";
+ break;
+ case kPt:
+ os << "pt=";
+ break;
+ }
+
+ SkipFirstDelimiter semic(";");
+ for (const Version& version : *this) {
+ if (!version.IsSet()) {
+ continue;
+ }
+ os << semic;
+ version.Serialize(os);
+ }
+}
+
+bool
+SdpSimulcastAttribute::Versions::Parse(std::istream& is, std::string* error)
+{
+ std::string rawType = ParseKey(is, error);
+ if (rawType.empty()) {
+ return false;
+ }
+
+ if (rawType == "pt") {
+ type = kPt;
+ } else if (rawType == "rid") {
+ type = kRid;
+ } else {
+ *error = "Unknown simulcast identification type ";
+ error->append(rawType);
+ return false;
+ }
+
+ do {
+ Version version;
+ if (!version.Parse(is, error)) {
+ return false;
+ }
+
+ if (type == kPt) {
+ std::vector<uint16_t> formats;
+ if (!version.GetChoicesAsFormats(&formats)) {
+ *error = "Invalid payload type";
+ return false;
+ }
+ }
+
+ push_back(version);
+ } while(SkipChar(is, ';', error));
+
+ return true;
+}
+
+void
+SdpSimulcastAttribute::Serialize(std::ostream& os) const
+{
+ MOZ_ASSERT(sendVersions.IsSet() || recvVersions.IsSet());
+
+ os << "a=" << mType << ":";
+
+ if (sendVersions.IsSet()) {
+ os << " send ";
+ sendVersions.Serialize(os);
+ }
+
+ if (recvVersions.IsSet()) {
+ os << " recv ";
+ recvVersions.Serialize(os);
+ }
+
+ os << CRLF;
+}
+
+bool
+SdpSimulcastAttribute::Parse(std::istream& is, std::string* error)
+{
+ bool gotRecv = false;
+ bool gotSend = false;
+
+ while (true) {
+ is >> std::ws;
+ std::string token = ParseToken(is, " \t", error);
+ if (token.empty()) {
+ break;
+ }
+
+ if (token == "send") {
+ if (gotSend) {
+ *error = "Already got a send list";
+ return false;
+ }
+ gotSend = true;
+
+ is >> std::ws;
+ if (!sendVersions.Parse(is, error)) {
+ return false;
+ }
+ } else if (token == "recv") {
+ if (gotRecv) {
+ *error = "Already got a recv list";
+ return false;
+ }
+ gotRecv = true;
+
+ is >> std::ws;
+ if (!recvVersions.Parse(is, error)) {
+ return false;
+ }
+ } else {
+ *error = "Type must be either 'send' or 'recv'";
+ return false;
+ }
+ }
+
+ if (!gotSend && !gotRecv) {
+ *error = "Empty simulcast attribute";
+ return false;
+ }
+
+ return true;
+}
+
+void
+SdpSsrcAttributeList::Serialize(std::ostream& os) const
+{
+ for (auto i = mSsrcs.begin(); i != mSsrcs.end(); ++i) {
+ os << "a=" << mType << ":" << i->ssrc << " " << i->attribute << CRLF;
+ }
+}
+
+void
+SdpSsrcGroupAttributeList::Serialize(std::ostream& os) const
+{
+ for (auto i = mSsrcGroups.begin(); i != mSsrcGroups.end(); ++i) {
+ os << "a=" << mType << ":" << i->semantics;
+ for (auto j = i->ssrcs.begin(); j != i->ssrcs.end(); ++j) {
+ os << " " << (*j);
+ }
+ os << CRLF;
+ }
+}
+
+void
+SdpMultiStringAttribute::Serialize(std::ostream& os) const
+{
+ for (auto i = mValues.begin(); i != mValues.end(); ++i) {
+ os << "a=" << mType << ":" << *i << CRLF;
+ }
+}
+
+void
+SdpOptionsAttribute::Serialize(std::ostream& os) const
+{
+ if (mValues.empty()) {
+ return;
+ }
+
+ os << "a=" << mType << ":";
+
+ for (auto i = mValues.begin(); i != mValues.end(); ++i) {
+ if (i != mValues.begin()) {
+ os << " ";
+ }
+ os << *i;
+ }
+ os << CRLF;
+}
+
+void
+SdpOptionsAttribute::Load(const std::string& value)
+{
+ size_t start = 0;
+ size_t end = value.find(' ');
+ while (end != std::string::npos) {
+ PushEntry(value.substr(start, end));
+ start = end + 1;
+ end = value.find(' ', start);
+ }
+ PushEntry(value.substr(start));
+}
+
+void
+SdpFlagAttribute::Serialize(std::ostream& os) const
+{
+ os << "a=" << mType << CRLF;
+}
+
+void
+SdpStringAttribute::Serialize(std::ostream& os) const
+{
+ os << "a=" << mType << ":" << mValue << CRLF;
+}
+
+void
+SdpNumberAttribute::Serialize(std::ostream& os) const
+{
+ os << "a=" << mType << ":" << mValue << CRLF;
+}
+
+bool
+SdpAttribute::IsAllowedAtMediaLevel(AttributeType type)
+{
+ switch (type) {
+ case kBundleOnlyAttribute:
+ return true;
+ case kCandidateAttribute:
+ return true;
+ case kConnectionAttribute:
+ return true;
+ case kDirectionAttribute:
+ return true;
+ case kDtlsMessageAttribute:
+ return false;
+ case kEndOfCandidatesAttribute:
+ return true;
+ case kExtmapAttribute:
+ return true;
+ case kFingerprintAttribute:
+ return true;
+ case kFmtpAttribute:
+ return true;
+ case kGroupAttribute:
+ return false;
+ case kIceLiteAttribute:
+ return false;
+ case kIceMismatchAttribute:
+ return true;
+ // RFC 5245 says this is session-level only, but
+ // draft-ietf-mmusic-ice-sip-sdp-03 updates this to allow at the media
+ // level.
+ case kIceOptionsAttribute:
+ return true;
+ case kIcePwdAttribute:
+ return true;
+ case kIceUfragAttribute:
+ return true;
+ case kIdentityAttribute:
+ return false;
+ case kImageattrAttribute:
+ return true;
+ case kInactiveAttribute:
+ return true;
+ case kLabelAttribute:
+ return true;
+ case kMaxptimeAttribute:
+ return true;
+ case kMidAttribute:
+ return true;
+ case kMsidAttribute:
+ return true;
+ case kMsidSemanticAttribute:
+ return false;
+ case kPtimeAttribute:
+ return true;
+ case kRecvonlyAttribute:
+ return true;
+ case kRemoteCandidatesAttribute:
+ return true;
+ case kRidAttribute:
+ return true;
+ case kRtcpAttribute:
+ return true;
+ case kRtcpFbAttribute:
+ return true;
+ case kRtcpMuxAttribute:
+ return true;
+ case kRtcpRsizeAttribute:
+ return true;
+ case kRtpmapAttribute:
+ return true;
+ case kSctpmapAttribute:
+ return true;
+ case kSendonlyAttribute:
+ return true;
+ case kSendrecvAttribute:
+ return true;
+ case kSetupAttribute:
+ return true;
+ case kSimulcastAttribute:
+ return true;
+ case kSsrcAttribute:
+ return true;
+ case kSsrcGroupAttribute:
+ return true;
+ }
+ MOZ_CRASH("Unknown attribute type");
+}
+
+bool
+SdpAttribute::IsAllowedAtSessionLevel(AttributeType type)
+{
+ switch (type) {
+ case kBundleOnlyAttribute:
+ return false;
+ case kCandidateAttribute:
+ return false;
+ case kConnectionAttribute:
+ return true;
+ case kDirectionAttribute:
+ return true;
+ case kDtlsMessageAttribute:
+ return true;
+ case kEndOfCandidatesAttribute:
+ return true;
+ case kExtmapAttribute:
+ return true;
+ case kFingerprintAttribute:
+ return true;
+ case kFmtpAttribute:
+ return false;
+ case kGroupAttribute:
+ return true;
+ case kIceLiteAttribute:
+ return true;
+ case kIceMismatchAttribute:
+ return false;
+ case kIceOptionsAttribute:
+ return true;
+ case kIcePwdAttribute:
+ return true;
+ case kIceUfragAttribute:
+ return true;
+ case kIdentityAttribute:
+ return true;
+ case kImageattrAttribute:
+ return false;
+ case kInactiveAttribute:
+ return true;
+ case kLabelAttribute:
+ return false;
+ case kMaxptimeAttribute:
+ return false;
+ case kMidAttribute:
+ return false;
+ case kMsidSemanticAttribute:
+ return true;
+ case kMsidAttribute:
+ return false;
+ case kPtimeAttribute:
+ return false;
+ case kRecvonlyAttribute:
+ return true;
+ case kRemoteCandidatesAttribute:
+ return false;
+ case kRidAttribute:
+ return false;
+ case kRtcpAttribute:
+ return false;
+ case kRtcpFbAttribute:
+ return false;
+ case kRtcpMuxAttribute:
+ return false;
+ case kRtcpRsizeAttribute:
+ return false;
+ case kRtpmapAttribute:
+ return false;
+ case kSctpmapAttribute:
+ return false;
+ case kSendonlyAttribute:
+ return true;
+ case kSendrecvAttribute:
+ return true;
+ case kSetupAttribute:
+ return true;
+ case kSimulcastAttribute:
+ return false;
+ case kSsrcAttribute:
+ return false;
+ case kSsrcGroupAttribute:
+ return false;
+ }
+ MOZ_CRASH("Unknown attribute type");
+}
+
+const std::string
+SdpAttribute::GetAttributeTypeString(AttributeType type)
+{
+ switch (type) {
+ case kBundleOnlyAttribute:
+ return "bundle-only";
+ case kCandidateAttribute:
+ return "candidate";
+ case kConnectionAttribute:
+ return "connection";
+ case kDtlsMessageAttribute:
+ return "dtls-message";
+ case kEndOfCandidatesAttribute:
+ return "end-of-candidates";
+ case kExtmapAttribute:
+ return "extmap";
+ case kFingerprintAttribute:
+ return "fingerprint";
+ case kFmtpAttribute:
+ return "fmtp";
+ case kGroupAttribute:
+ return "group";
+ case kIceLiteAttribute:
+ return "ice-lite";
+ case kIceMismatchAttribute:
+ return "ice-mismatch";
+ case kIceOptionsAttribute:
+ return "ice-options";
+ case kIcePwdAttribute:
+ return "ice-pwd";
+ case kIceUfragAttribute:
+ return "ice-ufrag";
+ case kIdentityAttribute:
+ return "identity";
+ case kImageattrAttribute:
+ return "imageattr";
+ case kInactiveAttribute:
+ return "inactive";
+ case kLabelAttribute:
+ return "label";
+ case kMaxptimeAttribute:
+ return "maxptime";
+ case kMidAttribute:
+ return "mid";
+ case kMsidAttribute:
+ return "msid";
+ case kMsidSemanticAttribute:
+ return "msid-semantic";
+ case kPtimeAttribute:
+ return "ptime";
+ case kRecvonlyAttribute:
+ return "recvonly";
+ case kRemoteCandidatesAttribute:
+ return "remote-candidates";
+ case kRidAttribute:
+ return "rid";
+ case kRtcpAttribute:
+ return "rtcp";
+ case kRtcpFbAttribute:
+ return "rtcp-fb";
+ case kRtcpMuxAttribute:
+ return "rtcp-mux";
+ case kRtcpRsizeAttribute:
+ return "rtcp-rsize";
+ case kRtpmapAttribute:
+ return "rtpmap";
+ case kSctpmapAttribute:
+ return "sctpmap";
+ case kSendonlyAttribute:
+ return "sendonly";
+ case kSendrecvAttribute:
+ return "sendrecv";
+ case kSetupAttribute:
+ return "setup";
+ case kSimulcastAttribute:
+ return "simulcast";
+ case kSsrcAttribute:
+ return "ssrc";
+ case kSsrcGroupAttribute:
+ return "ssrc-group";
+ case kDirectionAttribute:
+ MOZ_CRASH("kDirectionAttribute not valid here");
+ }
+ MOZ_CRASH("Unknown attribute type");
+}
+
+} // namespace mozilla
diff --git a/media/webrtc/signaling/src/sdp/SdpAttribute.h b/media/webrtc/signaling/src/sdp/SdpAttribute.h
new file mode 100644
index 000000000..d3cf547ff
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/SdpAttribute.h
@@ -0,0 +1,1788 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef _SDPATTRIBUTE_H_
+#define _SDPATTRIBUTE_H_
+
+#include <algorithm>
+#include <cctype>
+#include <vector>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+#include <iomanip>
+#include <string>
+
+#include "mozilla/UniquePtr.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/Maybe.h"
+
+#include "signaling/src/sdp/SdpEnum.h"
+#include "signaling/src/common/EncodingConstraints.h"
+
+namespace mozilla
+{
+
+/**
+ * Base class for SDP attributes
+*/
+class SdpAttribute
+{
+public:
+ enum AttributeType {
+ kFirstAttribute = 0,
+ kBundleOnlyAttribute = 0,
+ kCandidateAttribute,
+ kConnectionAttribute,
+ kDirectionAttribute,
+ kDtlsMessageAttribute,
+ kEndOfCandidatesAttribute,
+ kExtmapAttribute,
+ kFingerprintAttribute,
+ kFmtpAttribute,
+ kGroupAttribute,
+ kIceLiteAttribute,
+ kIceMismatchAttribute,
+ kIceOptionsAttribute,
+ kIcePwdAttribute,
+ kIceUfragAttribute,
+ kIdentityAttribute,
+ kImageattrAttribute,
+ kInactiveAttribute,
+ kLabelAttribute,
+ kMaxptimeAttribute,
+ kMidAttribute,
+ kMsidAttribute,
+ kMsidSemanticAttribute,
+ kPtimeAttribute,
+ kRecvonlyAttribute,
+ kRemoteCandidatesAttribute,
+ kRidAttribute,
+ kRtcpAttribute,
+ kRtcpFbAttribute,
+ kRtcpMuxAttribute,
+ kRtcpRsizeAttribute,
+ kRtpmapAttribute,
+ kSctpmapAttribute,
+ kSendonlyAttribute,
+ kSendrecvAttribute,
+ kSetupAttribute,
+ kSimulcastAttribute,
+ kSsrcAttribute,
+ kSsrcGroupAttribute,
+ kLastAttribute = kSsrcGroupAttribute
+ };
+
+ explicit SdpAttribute(AttributeType type) : mType(type) {}
+ virtual ~SdpAttribute() {}
+
+ AttributeType
+ GetType() const
+ {
+ return mType;
+ }
+
+ virtual void Serialize(std::ostream&) const = 0;
+
+ static bool IsAllowedAtSessionLevel(AttributeType type);
+ static bool IsAllowedAtMediaLevel(AttributeType type);
+ static const std::string GetAttributeTypeString(AttributeType type);
+
+protected:
+ AttributeType mType;
+};
+
+inline std::ostream& operator<<(std::ostream& os, const SdpAttribute& attr)
+{
+ attr.Serialize(os);
+ return os;
+}
+
+inline std::ostream& operator<<(std::ostream& os,
+ const SdpAttribute::AttributeType type)
+{
+ os << SdpAttribute::GetAttributeTypeString(type);
+ return os;
+}
+
+///////////////////////////////////////////////////////////////////////////
+// a=candidate, RFC5245
+//-------------------------------------------------------------------------
+//
+// candidate-attribute = "candidate" ":" foundation SP component-id SP
+// transport SP
+// priority SP
+// connection-address SP ;from RFC 4566
+// port ;port from RFC 4566
+// SP cand-type
+// [SP rel-addr]
+// [SP rel-port]
+// *(SP extension-att-name SP
+// extension-att-value)
+// foundation = 1*32ice-char
+// component-id = 1*5DIGIT
+// transport = "UDP" / transport-extension
+// transport-extension = token ; from RFC 3261
+// priority = 1*10DIGIT
+// cand-type = "typ" SP candidate-types
+// candidate-types = "host" / "srflx" / "prflx" / "relay" / token
+// rel-addr = "raddr" SP connection-address
+// rel-port = "rport" SP port
+// extension-att-name = byte-string ;from RFC 4566
+// extension-att-value = byte-string
+// ice-char = ALPHA / DIGIT / "+" / "/"
+
+// We use a SdpMultiStringAttribute for candidates
+
+///////////////////////////////////////////////////////////////////////////
+// a=connection, RFC4145
+//-------------------------------------------------------------------------
+// connection-attr = "a=connection:" conn-value
+// conn-value = "new" / "existing"
+class SdpConnectionAttribute : public SdpAttribute
+{
+public:
+ enum ConnValue { kNew, kExisting };
+
+ explicit SdpConnectionAttribute(SdpConnectionAttribute::ConnValue value)
+ : SdpAttribute(kConnectionAttribute), mValue(value)
+ {
+ }
+
+ virtual void Serialize(std::ostream& os) const override;
+
+ ConnValue mValue;
+};
+
+inline std::ostream& operator<<(std::ostream& os,
+ SdpConnectionAttribute::ConnValue c)
+{
+ switch (c) {
+ case SdpConnectionAttribute::kNew:
+ os << "new";
+ break;
+ case SdpConnectionAttribute::kExisting:
+ os << "existing";
+ break;
+ default:
+ MOZ_ASSERT(false);
+ os << "?";
+ }
+ return os;
+}
+
+///////////////////////////////////////////////////////////////////////////
+// a=sendrecv / a=sendonly / a=recvonly / a=inactive, RFC 4566
+//-------------------------------------------------------------------------
+class SdpDirectionAttribute : public SdpAttribute
+{
+public:
+ enum Direction {
+ kInactive = 0,
+ kSendonly = sdp::kSend,
+ kRecvonly = sdp::kRecv,
+ kSendrecv = sdp::kSend | sdp::kRecv
+ };
+
+ explicit SdpDirectionAttribute(Direction value)
+ : SdpAttribute(kDirectionAttribute), mValue(value)
+ {
+ }
+
+ virtual void Serialize(std::ostream& os) const override;
+
+ Direction mValue;
+};
+
+inline std::ostream& operator<<(std::ostream& os,
+ SdpDirectionAttribute::Direction d)
+{
+ switch (d) {
+ case SdpDirectionAttribute::kSendonly:
+ os << "sendonly";
+ break;
+ case SdpDirectionAttribute::kRecvonly:
+ os << "recvonly";
+ break;
+ case SdpDirectionAttribute::kSendrecv:
+ os << "sendrecv";
+ break;
+ case SdpDirectionAttribute::kInactive:
+ os << "inactive";
+ break;
+ default:
+ MOZ_ASSERT(false);
+ os << "?";
+ }
+ return os;
+}
+
+///////////////////////////////////////////////////////////////////////////
+// a=dtls-message, draft-rescorla-dtls-in-sdp
+//-------------------------------------------------------------------------
+// attribute =/ dtls-message-attribute
+//
+// dtls-message-attribute = "dtls-message" ":" role SP value
+//
+// role = "client" / "server"
+//
+// value = 1*(ALPHA / DIGIT / "+" / "/" / "=" )
+// ; base64 encoded message
+class SdpDtlsMessageAttribute : public SdpAttribute
+{
+public:
+ enum Role {
+ kClient,
+ kServer
+ };
+
+ explicit SdpDtlsMessageAttribute(Role role, const std::string& value)
+ : SdpAttribute(kDtlsMessageAttribute),
+ mRole(role),
+ mValue(value)
+ {}
+
+ explicit SdpDtlsMessageAttribute(const std::string& unparsed)
+ : SdpAttribute(kDtlsMessageAttribute),
+ mRole(kClient)
+ {
+ std::istringstream is(unparsed);
+ std::string error;
+ // We're not really worried about errors here if we don't parse;
+ // this attribute is a pure optimization.
+ Parse(is, &error);
+ }
+
+ virtual void Serialize(std::ostream& os) const override;
+ bool Parse(std::istream& is, std::string* error);
+
+ Role mRole;
+ std::string mValue;
+};
+
+inline std::ostream& operator<<(std::ostream& os,
+ SdpDtlsMessageAttribute::Role r)
+{
+ switch (r) {
+ case SdpDtlsMessageAttribute::kClient:
+ os << "client";
+ break;
+ case SdpDtlsMessageAttribute::kServer:
+ os << "server";
+ break;
+ default:
+ MOZ_ASSERT(false);
+ os << "?";
+ }
+ return os;
+}
+
+
+///////////////////////////////////////////////////////////////////////////
+// a=extmap, RFC5285
+//-------------------------------------------------------------------------
+// RFC5285
+// extmap = mapentry SP extensionname [SP extensionattributes]
+//
+// extensionname = URI
+//
+// direction = "sendonly" / "recvonly" / "sendrecv" / "inactive"
+//
+// mapentry = "extmap:" 1*5DIGIT ["/" direction]
+//
+// extensionattributes = byte-string
+//
+// URI = <Defined in RFC 3986>
+//
+// byte-string = <Defined in RFC 4566>
+//
+// SP = <Defined in RFC 5234>
+//
+// DIGIT = <Defined in RFC 5234>
+class SdpExtmapAttributeList : public SdpAttribute
+{
+public:
+ SdpExtmapAttributeList() : SdpAttribute(kExtmapAttribute) {}
+
+ struct Extmap {
+ uint16_t entry;
+ SdpDirectionAttribute::Direction direction;
+ bool direction_specified;
+ std::string extensionname;
+ std::string extensionattributes;
+ };
+
+ void
+ PushEntry(uint16_t entry, SdpDirectionAttribute::Direction direction,
+ bool direction_specified, const std::string& extensionname,
+ const std::string& extensionattributes = "")
+ {
+ Extmap value = { entry, direction, direction_specified, extensionname,
+ extensionattributes };
+ mExtmaps.push_back(value);
+ }
+
+ virtual void Serialize(std::ostream& os) const override;
+
+ std::vector<Extmap> mExtmaps;
+};
+
+///////////////////////////////////////////////////////////////////////////
+// a=fingerprint, RFC4572
+//-------------------------------------------------------------------------
+// fingerprint-attribute = "fingerprint" ":" hash-func SP fingerprint
+//
+// hash-func = "sha-1" / "sha-224" / "sha-256" /
+// "sha-384" / "sha-512" /
+// "md5" / "md2" / token
+// ; Additional hash functions can only come
+// ; from updates to RFC 3279
+//
+// fingerprint = 2UHEX *(":" 2UHEX)
+// ; Each byte in upper-case hex, separated
+// ; by colons.
+//
+// UHEX = DIGIT / %x41-46 ; A-F uppercase
+class SdpFingerprintAttributeList : public SdpAttribute
+{
+public:
+ SdpFingerprintAttributeList() : SdpAttribute(kFingerprintAttribute) {}
+
+ enum HashAlgorithm {
+ kSha1,
+ kSha224,
+ kSha256,
+ kSha384,
+ kSha512,
+ kMd5,
+ kMd2,
+ kUnknownAlgorithm
+ };
+
+ struct Fingerprint {
+ HashAlgorithm hashFunc;
+ std::vector<uint8_t> fingerprint;
+ };
+
+ // For use by application programmers. Enforces that it's a known and
+ // non-crazy algorithm.
+ void
+ PushEntry(std::string algorithm_str,
+ const std::vector<uint8_t>& fingerprint,
+ bool enforcePlausible = true)
+ {
+ std::transform(algorithm_str.begin(),
+ algorithm_str.end(),
+ algorithm_str.begin(),
+ ::tolower);
+
+ SdpFingerprintAttributeList::HashAlgorithm algorithm =
+ SdpFingerprintAttributeList::kUnknownAlgorithm;
+
+ if (algorithm_str == "sha-1") {
+ algorithm = SdpFingerprintAttributeList::kSha1;
+ } else if (algorithm_str == "sha-224") {
+ algorithm = SdpFingerprintAttributeList::kSha224;
+ } else if (algorithm_str == "sha-256") {
+ algorithm = SdpFingerprintAttributeList::kSha256;
+ } else if (algorithm_str == "sha-384") {
+ algorithm = SdpFingerprintAttributeList::kSha384;
+ } else if (algorithm_str == "sha-512") {
+ algorithm = SdpFingerprintAttributeList::kSha512;
+ } else if (algorithm_str == "md5") {
+ algorithm = SdpFingerprintAttributeList::kMd5;
+ } else if (algorithm_str == "md2") {
+ algorithm = SdpFingerprintAttributeList::kMd2;
+ }
+
+ if ((algorithm == SdpFingerprintAttributeList::kUnknownAlgorithm) ||
+ fingerprint.empty()) {
+ if (enforcePlausible) {
+ MOZ_ASSERT(false, "Unknown fingerprint algorithm");
+ } else {
+ return;
+ }
+ }
+
+ PushEntry(algorithm, fingerprint);
+ }
+
+ void
+ PushEntry(HashAlgorithm hashFunc, const std::vector<uint8_t>& fingerprint)
+ {
+ Fingerprint value = { hashFunc, fingerprint };
+ mFingerprints.push_back(value);
+ }
+
+ virtual void Serialize(std::ostream& os) const override;
+
+ std::vector<Fingerprint> mFingerprints;
+
+ static std::string FormatFingerprint(const std::vector<uint8_t>& fp);
+ static std::vector<uint8_t> ParseFingerprint(const std::string& str);
+};
+
+inline std::ostream& operator<<(std::ostream& os,
+ SdpFingerprintAttributeList::HashAlgorithm a)
+{
+ switch (a) {
+ case SdpFingerprintAttributeList::kSha1:
+ os << "sha-1";
+ break;
+ case SdpFingerprintAttributeList::kSha224:
+ os << "sha-224";
+ break;
+ case SdpFingerprintAttributeList::kSha256:
+ os << "sha-256";
+ break;
+ case SdpFingerprintAttributeList::kSha384:
+ os << "sha-384";
+ break;
+ case SdpFingerprintAttributeList::kSha512:
+ os << "sha-512";
+ break;
+ case SdpFingerprintAttributeList::kMd5:
+ os << "md5";
+ break;
+ case SdpFingerprintAttributeList::kMd2:
+ os << "md2";
+ break;
+ default:
+ MOZ_ASSERT(false);
+ os << "?";
+ }
+ return os;
+}
+
+///////////////////////////////////////////////////////////////////////////
+// a=group, RFC5888
+//-------------------------------------------------------------------------
+// group-attribute = "a=group:" semantics
+// *(SP identification-tag)
+// semantics = "LS" / "FID" / semantics-extension
+// semantics-extension = token
+// identification-tag = token
+class SdpGroupAttributeList : public SdpAttribute
+{
+public:
+ SdpGroupAttributeList() : SdpAttribute(kGroupAttribute) {}
+
+ enum Semantics {
+ kLs, // RFC5888
+ kFid, // RFC5888
+ kSrf, // RFC3524
+ kAnat, // RFC4091
+ kFec, // RFC5956
+ kFecFr, // RFC5956
+ kCs, // draft-mehta-rmt-flute-sdp-05
+ kDdp, // RFC5583
+ kDup, // RFC7104
+ kBundle // draft-ietf-mmusic-bundle
+ };
+
+ struct Group {
+ Semantics semantics;
+ std::vector<std::string> tags;
+ };
+
+ void
+ PushEntry(Semantics semantics, const std::vector<std::string>& tags)
+ {
+ Group value = { semantics, tags };
+ mGroups.push_back(value);
+ }
+
+ void
+ RemoveMid(const std::string& mid)
+ {
+ for (auto i = mGroups.begin(); i != mGroups.end();) {
+ auto tag = std::find(i->tags.begin(), i->tags.end(), mid);
+ if (tag != i->tags.end()) {
+ i->tags.erase(tag);
+ }
+
+ if (i->tags.empty()) {
+ i = mGroups.erase(i);
+ } else {
+ ++i;
+ }
+ }
+ }
+
+ virtual void Serialize(std::ostream& os) const override;
+
+ std::vector<Group> mGroups;
+};
+
+inline std::ostream& operator<<(std::ostream& os,
+ SdpGroupAttributeList::Semantics s)
+{
+ switch (s) {
+ case SdpGroupAttributeList::kLs:
+ os << "LS";
+ break;
+ case SdpGroupAttributeList::kFid:
+ os << "FID";
+ break;
+ case SdpGroupAttributeList::kSrf:
+ os << "SRF";
+ break;
+ case SdpGroupAttributeList::kAnat:
+ os << "ANAT";
+ break;
+ case SdpGroupAttributeList::kFec:
+ os << "FEC";
+ break;
+ case SdpGroupAttributeList::kFecFr:
+ os << "FEC-FR";
+ break;
+ case SdpGroupAttributeList::kCs:
+ os << "CS";
+ break;
+ case SdpGroupAttributeList::kDdp:
+ os << "DDP";
+ break;
+ case SdpGroupAttributeList::kDup:
+ os << "DUP";
+ break;
+ case SdpGroupAttributeList::kBundle:
+ os << "BUNDLE";
+ break;
+ default:
+ MOZ_ASSERT(false);
+ os << "?";
+ }
+ return os;
+}
+
+///////////////////////////////////////////////////////////////////////////
+// a=identity, draft-ietf-rtcweb-security-arch
+//-------------------------------------------------------------------------
+// identity-attribute = "identity:" identity-assertion
+// [ SP identity-extension
+// *(";" [ SP ] identity-extension) ]
+// identity-assertion = base64
+// base64 = 1*(ALPHA / DIGIT / "+" / "/" / "=" )
+// identity-extension = extension-att-name [ "=" extension-att-value ]
+// extension-att-name = token
+// extension-att-value = 1*(%x01-09 / %x0b-0c / %x0e-3a / %x3c-ff)
+// ; byte-string from [RFC4566] omitting ";"
+
+// We're just using an SdpStringAttribute for this right now
+#if 0
+class SdpIdentityAttribute : public SdpAttribute
+{
+public:
+ explicit SdpIdentityAttribute(const std::string &assertion,
+ const std::vector<std::string> &extensions =
+ std::vector<std::string>()) :
+ SdpAttribute(kIdentityAttribute),
+ mAssertion(assertion),
+ mExtensions(extensions) {}
+
+ virtual void Serialize(std::ostream& os) const override;
+
+ std::string mAssertion;
+ std::vector<std::string> mExtensions;
+}
+#endif
+
+///////////////////////////////////////////////////////////////////////////
+// a=imageattr, RFC6236
+//-------------------------------------------------------------------------
+// image-attr = "imageattr:" PT 1*2( 1*WSP ( "send" / "recv" )
+// 1*WSP attr-list )
+// PT = 1*DIGIT / "*"
+// attr-list = ( set *(1*WSP set) ) / "*"
+// ; WSP and DIGIT defined in [RFC5234]
+//
+// set= "[" "x=" xyrange "," "y=" xyrange *( "," key-value ) "]"
+// ; x is the horizontal image size range (pixel count)
+// ; y is the vertical image size range (pixel count)
+//
+// key-value = ( "sar=" srange )
+// / ( "par=" prange )
+// / ( "q=" qvalue )
+// ; Key-value MAY be extended with other keyword
+// ; parameters.
+// ; At most, one instance each of sar, par, or q
+// ; is allowed in a set.
+// ;
+// ; sar (sample aspect ratio) is the sample aspect ratio
+// ; associated with the set (optional, MAY be ignored)
+// ; par (picture aspect ratio) is the allowed
+// ; ratio between the display's x and y physical
+// ; size (optional)
+// ; q (optional, range [0.0..1.0], default value 0.5)
+// ; is the preference for the given set,
+// ; a higher value means a higher preference
+//
+// onetonine = "1" / "2" / "3" / "4" / "5" / "6" / "7" / "8" / "9"
+// ; Digit between 1 and 9
+// xyvalue = onetonine *5DIGIT
+// ; Digit between 1 and 9 that is
+// ; followed by 0 to 5 other digits
+// step = xyvalue
+// xyrange = ( "[" xyvalue ":" [ step ":" ] xyvalue "]" )
+// ; Range between a lower and an upper value
+// ; with an optional step, default step = 1
+// ; The rightmost occurrence of xyvalue MUST have a
+// ; higher value than the leftmost occurrence.
+// / ( "[" xyvalue 1*( "," xyvalue ) "]" )
+// ; Discrete values separated by ','
+// / ( xyvalue )
+// ; A single value
+// spvalue = ( "0" "." onetonine *3DIGIT )
+// ; Values between 0.1000 and 0.9999
+// / ( onetonine "." 1*4DIGIT )
+// ; Values between 1.0000 and 9.9999
+// srange = ( "[" spvalue 1*( "," spvalue ) "]" )
+// ; Discrete values separated by ','.
+// ; Each occurrence of spvalue MUST be
+// ; greater than the previous occurrence.
+// / ( "[" spvalue "-" spvalue "]" )
+// ; Range between a lower and an upper level (inclusive)
+// ; The second occurrence of spvalue MUST have a higher
+// ; value than the first
+// / ( spvalue )
+// ; A single value
+//
+// prange = ( "[" spvalue "-" spvalue "]" )
+// ; Range between a lower and an upper level (inclusive)
+// ; The second occurrence of spvalue MUST have a higher
+// ; value than the first
+//
+// qvalue = ( "0" "." 1*2DIGIT )
+// / ( "1" "." 1*2("0") )
+// ; Values between 0.00 and 1.00
+//
+// XXX TBD -- We don't use this yet, and it's a project unto itself.
+//
+
+class SdpImageattrAttributeList : public SdpAttribute
+{
+public:
+ SdpImageattrAttributeList() : SdpAttribute(kImageattrAttribute) {}
+
+ class XYRange
+ {
+ public:
+ XYRange() : min(0), max(0), step(1) {}
+ void Serialize(std::ostream& os) const;
+ bool Parse(std::istream& is, std::string* error);
+ bool ParseAfterBracket(std::istream& is, std::string* error);
+ bool ParseAfterMin(std::istream& is, std::string* error);
+ bool ParseDiscreteValues(std::istream& is, std::string* error);
+ std::vector<uint32_t> discreteValues;
+ // min/max are used iff discreteValues is empty
+ uint32_t min;
+ uint32_t max;
+ uint32_t step;
+ };
+
+ class SRange
+ {
+ public:
+ SRange() : min(0), max(0) {}
+ void Serialize(std::ostream& os) const;
+ bool Parse(std::istream& is, std::string* error);
+ bool ParseAfterBracket(std::istream& is, std::string* error);
+ bool ParseAfterMin(std::istream& is, std::string* error);
+ bool ParseDiscreteValues(std::istream& is, std::string* error);
+ bool IsSet() const
+ {
+ return !discreteValues.empty() || (min && max);
+ }
+ std::vector<float> discreteValues;
+ // min/max are used iff discreteValues is empty
+ float min;
+ float max;
+ };
+
+ class PRange
+ {
+ public:
+ PRange() : min(0), max(0) {}
+ void Serialize(std::ostream& os) const;
+ bool Parse(std::istream& is, std::string* error);
+ bool IsSet() const
+ {
+ return min && max;
+ }
+ float min;
+ float max;
+ };
+
+ class Set
+ {
+ public:
+ Set() : qValue(-1) {}
+ void Serialize(std::ostream& os) const;
+ bool Parse(std::istream& is, std::string* error);
+ XYRange xRange;
+ XYRange yRange;
+ SRange sRange;
+ PRange pRange;
+ float qValue;
+ };
+
+ class Imageattr
+ {
+ public:
+ Imageattr() : pt(), sendAll(false), recvAll(false) {}
+ void Serialize(std::ostream& os) const;
+ bool Parse(std::istream& is, std::string* error);
+ bool ParseSets(std::istream& is, std::string* error);
+ // If not set, this means all payload types
+ Maybe<uint16_t> pt;
+ bool sendAll;
+ std::vector<Set> sendSets;
+ bool recvAll;
+ std::vector<Set> recvSets;
+ };
+
+ virtual void Serialize(std::ostream& os) const override;
+ bool PushEntry(const std::string& raw, std::string* error, size_t* errorPos);
+
+ std::vector<Imageattr> mImageattrs;
+};
+
+///////////////////////////////////////////////////////////////////////////
+// a=msid, draft-ietf-mmusic-msid
+//-------------------------------------------------------------------------
+// msid-attr = "msid:" identifier [ SP appdata ]
+// identifier = 1*64token-char ; see RFC 4566
+// appdata = 1*64token-char ; see RFC 4566
+class SdpMsidAttributeList : public SdpAttribute
+{
+public:
+ SdpMsidAttributeList() : SdpAttribute(kMsidAttribute) {}
+
+ struct Msid {
+ std::string identifier;
+ std::string appdata;
+ };
+
+ void
+ PushEntry(const std::string& identifier, const std::string& appdata = "")
+ {
+ Msid value = { identifier, appdata };
+ mMsids.push_back(value);
+ }
+
+ virtual void Serialize(std::ostream& os) const override;
+
+ std::vector<Msid> mMsids;
+};
+
+///////////////////////////////////////////////////////////////////////////
+// a=msid-semantic, draft-ietf-mmusic-msid
+//-------------------------------------------------------------------------
+// msid-semantic-attr = "msid-semantic:" msid-semantic msid-list
+// msid-semantic = token ; see RFC 4566
+// msid-list = *(" " msid-id) / " *"
+class SdpMsidSemanticAttributeList : public SdpAttribute
+{
+public:
+ SdpMsidSemanticAttributeList() : SdpAttribute(kMsidSemanticAttribute) {}
+
+ struct MsidSemantic
+ {
+ // TODO: Once we have some more of these, we might want to make an enum
+ std::string semantic;
+ std::vector<std::string> msids;
+ };
+
+ void
+ PushEntry(const std::string& semantic, const std::vector<std::string>& msids)
+ {
+ MsidSemantic value = {semantic, msids};
+ mMsidSemantics.push_back(value);
+ }
+
+ virtual void Serialize(std::ostream& os) const override;
+
+ std::vector<MsidSemantic> mMsidSemantics;
+};
+
+///////////////////////////////////////////////////////////////////////////
+// a=remote-candiate, RFC5245
+//-------------------------------------------------------------------------
+// remote-candidate-att = "remote-candidates" ":" remote-candidate
+// 0*(SP remote-candidate)
+// remote-candidate = component-ID SP connection-address SP port
+class SdpRemoteCandidatesAttribute : public SdpAttribute
+{
+public:
+ struct Candidate {
+ std::string id;
+ std::string address;
+ uint16_t port;
+ };
+
+ explicit SdpRemoteCandidatesAttribute(
+ const std::vector<Candidate>& candidates)
+ : SdpAttribute(kRemoteCandidatesAttribute), mCandidates(candidates)
+ {
+ }
+
+ virtual void Serialize(std::ostream& os) const override;
+
+ std::vector<Candidate> mCandidates;
+};
+
+/*
+a=rid, draft-pthatcher-mmusic-rid-01
+
+ rid-syntax = "a=rid:" rid-identifier SP rid-dir
+ [ rid-pt-param-list / rid-param-list ]
+
+ rid-identifier = 1*(alpha-numeric / "-" / "_")
+
+ rid-dir = "send" / "recv"
+
+ rid-pt-param-list = SP rid-fmt-list *(";" rid-param)
+
+ rid-param-list = SP rid-param *(";" rid-param)
+
+ rid-fmt-list = "pt=" fmt *( "," fmt )
+ ; fmt defined in {{RFC4566}}
+
+ rid-param = rid-width-param
+ / rid-height-param
+ / rid-fps-param
+ / rid-fs-param
+ / rid-br-param
+ / rid-pps-param
+ / rid-depend-param
+ / rid-param-other
+
+ rid-width-param = "max-width" [ "=" int-param-val ]
+
+ rid-height-param = "max-height" [ "=" int-param-val ]
+
+ rid-fps-param = "max-fps" [ "=" int-param-val ]
+
+ rid-fs-param = "max-fs" [ "=" int-param-val ]
+
+ rid-br-param = "max-br" [ "=" int-param-val ]
+
+ rid-pps-param = "max-pps" [ "=" int-param-val ]
+
+ rid-depend-param = "depend=" rid-list
+
+ rid-param-other = 1*(alpha-numeric / "-") [ "=" param-val ]
+
+ rid-list = rid-identifier *( "," rid-identifier )
+
+ int-param-val = 1*DIGIT
+
+ param-val = *( %x20-58 / %x60-7E )
+ ; Any printable character except semicolon
+*/
+class SdpRidAttributeList : public SdpAttribute
+{
+public:
+ explicit SdpRidAttributeList()
+ : SdpAttribute(kRidAttribute)
+ {}
+
+ struct Rid
+ {
+ Rid() :
+ direction(sdp::kSend)
+ {}
+
+ bool Parse(std::istream& is, std::string* error);
+ bool ParseParameters(std::istream& is, std::string* error);
+ bool ParseDepend(std::istream& is, std::string* error);
+ bool ParseFormats(std::istream& is, std::string* error);
+ void Serialize(std::ostream& os) const;
+ void SerializeParameters(std::ostream& os) const;
+ bool HasFormat(const std::string& format) const;
+ bool HasParameters() const
+ {
+ return !formats.empty() ||
+ constraints.maxWidth ||
+ constraints.maxHeight ||
+ constraints.maxFps ||
+ constraints.maxFs ||
+ constraints.maxBr ||
+ constraints.maxPps ||
+ !dependIds.empty();
+ }
+
+
+ std::string id;
+ sdp::Direction direction;
+ std::vector<uint16_t> formats; // Empty implies all
+ EncodingConstraints constraints;
+ std::vector<std::string> dependIds;
+ };
+
+ virtual void Serialize(std::ostream& os) const override;
+ bool PushEntry(const std::string& raw, std::string* error, size_t* errorPos);
+
+ std::vector<Rid> mRids;
+};
+
+///////////////////////////////////////////////////////////////////////////
+// a=rtcp, RFC3605
+//-------------------------------------------------------------------------
+// rtcp-attribute = "a=rtcp:" port [nettype space addrtype space
+// connection-address] CRLF
+class SdpRtcpAttribute : public SdpAttribute
+{
+public:
+ explicit SdpRtcpAttribute(uint16_t port)
+ : SdpAttribute(kRtcpAttribute),
+ mPort(port),
+ mNetType(sdp::kNetTypeNone),
+ mAddrType(sdp::kAddrTypeNone)
+ {}
+
+ SdpRtcpAttribute(uint16_t port,
+ sdp::NetType netType,
+ sdp::AddrType addrType,
+ const std::string& address)
+ : SdpAttribute(kRtcpAttribute),
+ mPort(port),
+ mNetType(netType),
+ mAddrType(addrType),
+ mAddress(address)
+ {
+ MOZ_ASSERT(netType != sdp::kNetTypeNone);
+ MOZ_ASSERT(addrType != sdp::kAddrTypeNone);
+ MOZ_ASSERT(!address.empty());
+ }
+
+ virtual void Serialize(std::ostream& os) const override;
+
+ uint16_t mPort;
+ sdp::NetType mNetType;
+ sdp::AddrType mAddrType;
+ std::string mAddress;
+};
+
+///////////////////////////////////////////////////////////////////////////
+// a=rtcp-fb, RFC4585
+//-------------------------------------------------------------------------
+// rtcp-fb-syntax = "a=rtcp-fb:" rtcp-fb-pt SP rtcp-fb-val CRLF
+//
+// rtcp-fb-pt = "*" ; wildcard: applies to all formats
+// / fmt ; as defined in SDP spec
+//
+// rtcp-fb-val = "ack" rtcp-fb-ack-param
+// / "nack" rtcp-fb-nack-param
+// / "trr-int" SP 1*DIGIT
+// / rtcp-fb-id rtcp-fb-param
+//
+// rtcp-fb-id = 1*(alpha-numeric / "-" / "_")
+//
+// rtcp-fb-param = SP "app" [SP byte-string]
+// / SP token [SP byte-string]
+// / ; empty
+//
+// rtcp-fb-ack-param = SP "rpsi"
+// / SP "app" [SP byte-string]
+// / SP token [SP byte-string]
+// / ; empty
+//
+// rtcp-fb-nack-param = SP "pli"
+// / SP "sli"
+// / SP "rpsi"
+// / SP "app" [SP byte-string]
+// / SP token [SP byte-string]
+// / ; empty
+//
+class SdpRtcpFbAttributeList : public SdpAttribute
+{
+public:
+ SdpRtcpFbAttributeList() : SdpAttribute(kRtcpFbAttribute) {}
+
+ enum Type { kAck, kApp, kCcm, kNack, kTrrInt, kRemb };
+
+ static const char* pli;
+ static const char* sli;
+ static const char* rpsi;
+ static const char* app;
+
+ static const char* fir;
+ static const char* tmmbr;
+ static const char* tstr;
+ static const char* vbcm;
+
+ struct Feedback {
+ std::string pt;
+ Type type;
+ std::string parameter;
+ std::string extra;
+ };
+
+ void
+ PushEntry(const std::string& pt, Type type, const std::string& parameter = "",
+ const std::string& extra = "")
+ {
+ Feedback value = { pt, type, parameter, extra };
+ mFeedbacks.push_back(value);
+ }
+
+ virtual void Serialize(std::ostream& os) const override;
+
+ std::vector<Feedback> mFeedbacks;
+};
+
+inline std::ostream& operator<<(std::ostream& os,
+ SdpRtcpFbAttributeList::Type type)
+{
+ switch (type) {
+ case SdpRtcpFbAttributeList::kAck:
+ os << "ack";
+ break;
+ case SdpRtcpFbAttributeList::kApp:
+ os << "app";
+ break;
+ case SdpRtcpFbAttributeList::kCcm:
+ os << "ccm";
+ break;
+ case SdpRtcpFbAttributeList::kNack:
+ os << "nack";
+ break;
+ case SdpRtcpFbAttributeList::kTrrInt:
+ os << "trr-int";
+ break;
+ case SdpRtcpFbAttributeList::kRemb:
+ os << "goog-remb";
+ break;
+ default:
+ MOZ_ASSERT(false);
+ os << "?";
+ }
+ return os;
+}
+
+///////////////////////////////////////////////////////////////////////////
+// a=rtpmap, RFC4566
+//-------------------------------------------------------------------------
+// a=rtpmap:<payload type> <encoding name>/<clock rate> [/<encoding parameters>]
+class SdpRtpmapAttributeList : public SdpAttribute
+{
+public:
+ SdpRtpmapAttributeList() : SdpAttribute(kRtpmapAttribute) {}
+
+ // Minimal set to get going
+ enum CodecType {
+ kOpus,
+ kG722,
+ kPCMU,
+ kPCMA,
+ kVP8,
+ kVP9,
+ kiLBC,
+ kiSAC,
+ kH264,
+ kRed,
+ kUlpfec,
+ kTelephoneEvent,
+ kOtherCodec
+ };
+
+ struct Rtpmap {
+ std::string pt;
+ CodecType codec;
+ std::string name;
+ uint32_t clock;
+ // Technically, this could mean something else in the future.
+ // In practice, that's probably not going to happen.
+ uint32_t channels;
+ };
+
+ void
+ PushEntry(const std::string& pt, CodecType codec, const std::string& name,
+ uint32_t clock, uint32_t channels = 0)
+ {
+ Rtpmap value = { pt, codec, name, clock, channels };
+ mRtpmaps.push_back(value);
+ }
+
+ virtual void Serialize(std::ostream& os) const override;
+
+ bool
+ HasEntry(const std::string& pt) const
+ {
+ for (auto it = mRtpmaps.begin(); it != mRtpmaps.end(); ++it) {
+ if (it->pt == pt) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ const Rtpmap&
+ GetEntry(const std::string& pt) const
+ {
+ for (auto it = mRtpmaps.begin(); it != mRtpmaps.end(); ++it) {
+ if (it->pt == pt) {
+ return *it;
+ }
+ }
+ MOZ_CRASH();
+ }
+
+ std::vector<Rtpmap> mRtpmaps;
+};
+
+inline std::ostream& operator<<(std::ostream& os,
+ SdpRtpmapAttributeList::CodecType c)
+{
+ switch (c) {
+ case SdpRtpmapAttributeList::kOpus:
+ os << "opus";
+ break;
+ case SdpRtpmapAttributeList::kG722:
+ os << "G722";
+ break;
+ case SdpRtpmapAttributeList::kPCMU:
+ os << "PCMU";
+ break;
+ case SdpRtpmapAttributeList::kPCMA:
+ os << "PCMA";
+ break;
+ case SdpRtpmapAttributeList::kVP8:
+ os << "VP8";
+ break;
+ case SdpRtpmapAttributeList::kVP9:
+ os << "VP9";
+ break;
+ case SdpRtpmapAttributeList::kiLBC:
+ os << "iLBC";
+ break;
+ case SdpRtpmapAttributeList::kiSAC:
+ os << "iSAC";
+ break;
+ case SdpRtpmapAttributeList::kH264:
+ os << "H264";
+ break;
+ case SdpRtpmapAttributeList::kRed:
+ os << "red";
+ break;
+ case SdpRtpmapAttributeList::kUlpfec:
+ os << "ulpfec";
+ break;
+ case SdpRtpmapAttributeList::kTelephoneEvent:
+ os << "telephone-event";
+ break;
+ default:
+ MOZ_ASSERT(false);
+ os << "?";
+ }
+ return os;
+}
+
+///////////////////////////////////////////////////////////////////////////
+// a=fmtp, RFC4566, RFC5576
+//-------------------------------------------------------------------------
+// a=fmtp:<format> <format specific parameters>
+//
+class SdpFmtpAttributeList : public SdpAttribute
+{
+public:
+ SdpFmtpAttributeList() : SdpAttribute(kFmtpAttribute) {}
+
+ // Base class for format parameters
+ class Parameters
+ {
+ public:
+ explicit Parameters(SdpRtpmapAttributeList::CodecType aCodec)
+ : codec_type(aCodec)
+ {
+ }
+
+ virtual ~Parameters() {}
+ virtual Parameters* Clone() const = 0;
+ virtual void Serialize(std::ostream& os) const = 0;
+
+ SdpRtpmapAttributeList::CodecType codec_type;
+ };
+
+ class RedParameters : public Parameters
+ {
+ public:
+ RedParameters()
+ : Parameters(SdpRtpmapAttributeList::kRed)
+ {
+ }
+
+ virtual Parameters*
+ Clone() const override
+ {
+ return new RedParameters(*this);
+ }
+
+ virtual void
+ Serialize(std::ostream& os) const override
+ {
+ for(size_t i = 0; i < encodings.size(); ++i) {
+ os << (i != 0 ? "/" : "")
+ << std::to_string(encodings[i]);
+ }
+ }
+
+ std::vector<uint8_t> encodings;
+ };
+
+ class H264Parameters : public Parameters
+ {
+ public:
+ static const uint32_t kDefaultProfileLevelId = 0x420010;
+
+ H264Parameters()
+ : Parameters(SdpRtpmapAttributeList::kH264),
+ packetization_mode(0),
+ level_asymmetry_allowed(false),
+ profile_level_id(kDefaultProfileLevelId),
+ max_mbps(0),
+ max_fs(0),
+ max_cpb(0),
+ max_dpb(0),
+ max_br(0)
+ {
+ memset(sprop_parameter_sets, 0, sizeof(sprop_parameter_sets));
+ }
+
+ virtual Parameters*
+ Clone() const override
+ {
+ return new H264Parameters(*this);
+ }
+
+ virtual void
+ Serialize(std::ostream& os) const override
+ {
+ // Note: don't move this, since having an unconditional param up top
+ // lets us avoid a whole bunch of conditional streaming of ';' below
+ os << "profile-level-id=" << std::hex << std::setfill('0') << std::setw(6)
+ << profile_level_id << std::dec << std::setfill(' ');
+
+ os << ";level-asymmetry-allowed=" << (level_asymmetry_allowed ? 1 : 0);
+
+ if (strlen(sprop_parameter_sets)) {
+ os << ";sprop-parameter-sets=" << sprop_parameter_sets;
+ }
+
+ if (packetization_mode != 0) {
+ os << ";packetization-mode=" << packetization_mode;
+ }
+
+ if (max_mbps != 0) {
+ os << ";max-mbps=" << max_mbps;
+ }
+
+ if (max_fs != 0) {
+ os << ";max-fs=" << max_fs;
+ }
+
+ if (max_cpb != 0) {
+ os << ";max-cpb=" << max_cpb;
+ }
+
+ if (max_dpb != 0) {
+ os << ";max-dpb=" << max_dpb;
+ }
+
+ if (max_br != 0) {
+ os << ";max-br=" << max_br;
+ }
+ }
+
+ static const size_t max_sprop_len = 128;
+ char sprop_parameter_sets[max_sprop_len];
+ unsigned int packetization_mode;
+ bool level_asymmetry_allowed;
+ unsigned int profile_level_id;
+ unsigned int max_mbps;
+ unsigned int max_fs;
+ unsigned int max_cpb;
+ unsigned int max_dpb;
+ unsigned int max_br;
+ };
+
+ // Also used for VP9 since they share parameters
+ class VP8Parameters : public Parameters
+ {
+ public:
+ explicit VP8Parameters(SdpRtpmapAttributeList::CodecType type)
+ : Parameters(type), max_fs(0), max_fr(0)
+ {
+ }
+
+ virtual Parameters*
+ Clone() const override
+ {
+ return new VP8Parameters(*this);
+ }
+
+ virtual void
+ Serialize(std::ostream& os) const override
+ {
+ // draft-ietf-payload-vp8-11 says these are mandatory, upper layer
+ // needs to ensure they're set properly.
+ os << "max-fs=" << max_fs;
+ os << ";max-fr=" << max_fr;
+ }
+
+ unsigned int max_fs;
+ unsigned int max_fr;
+ };
+
+ class OpusParameters : public Parameters
+ {
+ public:
+ enum { kDefaultMaxPlaybackRate = 48000,
+ kDefaultStereo = 0,
+ kDefaultUseInBandFec = 0 };
+ OpusParameters() :
+ Parameters(SdpRtpmapAttributeList::kOpus),
+ maxplaybackrate(kDefaultMaxPlaybackRate),
+ stereo(kDefaultStereo),
+ useInBandFec(kDefaultUseInBandFec)
+ {}
+
+ Parameters*
+ Clone() const override
+ {
+ return new OpusParameters(*this);
+ }
+
+ void
+ Serialize(std::ostream& os) const override
+ {
+ os << "maxplaybackrate=" << maxplaybackrate
+ << ";stereo=" << stereo
+ << ";useinbandfec=" << useInBandFec;
+ }
+
+ unsigned int maxplaybackrate;
+ unsigned int stereo;
+ unsigned int useInBandFec;
+ };
+
+ class TelephoneEventParameters : public Parameters
+ {
+ public:
+ TelephoneEventParameters() :
+ Parameters(SdpRtpmapAttributeList::kTelephoneEvent),
+ dtmfTones("0-15")
+ {}
+
+ virtual Parameters*
+ Clone() const override
+ {
+ return new TelephoneEventParameters(*this);
+ }
+
+ void
+ Serialize(std::ostream& os) const override
+ {
+ os << dtmfTones;
+ }
+
+ std::string dtmfTones;
+ };
+
+ class Fmtp
+ {
+ public:
+ Fmtp(const std::string& aFormat, UniquePtr<Parameters> aParameters)
+ : format(aFormat),
+ parameters(Move(aParameters))
+ {
+ }
+
+ Fmtp(const std::string& aFormat, const Parameters& aParameters)
+ : format(aFormat),
+ parameters(aParameters.Clone())
+ {
+ }
+
+ // TODO: Rip all of this out when we have move semantics in the stl.
+ Fmtp(const Fmtp& orig) { *this = orig; }
+
+ Fmtp& operator=(const Fmtp& rhs)
+ {
+ if (this != &rhs) {
+ format = rhs.format;
+ parameters.reset(rhs.parameters ? rhs.parameters->Clone() : nullptr);
+ }
+ return *this;
+ }
+
+ // The contract around these is as follows:
+ // * |parameters| is only set if we recognized the media type and had
+ // a subclass of Parameters to represent that type of parameters
+ // * |parameters| is a best-effort representation; it might be missing
+ // stuff
+ // * Parameters::codec_type tells you the concrete class, eg
+ // kH264 -> H264Parameters
+ std::string format;
+ UniquePtr<Parameters> parameters;
+ };
+
+ virtual void Serialize(std::ostream& os) const override;
+
+ void
+ PushEntry(const std::string& format, UniquePtr<Parameters> parameters)
+ {
+ mFmtps.push_back(Fmtp(format, Move(parameters)));
+ }
+
+ std::vector<Fmtp> mFmtps;
+};
+
+///////////////////////////////////////////////////////////////////////////
+// a=sctpmap, draft-ietf-mmusic-sctp-sdp-05
+//-------------------------------------------------------------------------
+// sctpmap-attr = "a=sctpmap:" sctpmap-number media-subtypes
+// [streams]
+// sctpmap-number = 1*DIGIT
+// protocol = labelstring
+// labelstring = text
+// text = byte-string
+// streams = 1*DIGIT
+//
+// We're going to pretend that there are spaces where they make sense.
+//
+// (draft-06 is not backward compatabile and draft-07 replaced sctpmap's with
+// fmtp maps - we should carefully choose when to upgrade)
+class SdpSctpmapAttributeList : public SdpAttribute
+{
+public:
+ SdpSctpmapAttributeList() : SdpAttribute(kSctpmapAttribute) {}
+
+ struct Sctpmap {
+ std::string pt;
+ std::string name;
+ uint32_t streams;
+ };
+
+ void
+ PushEntry(const std::string& pt, const std::string& name,
+ uint32_t streams = 0)
+ {
+ Sctpmap value = { pt, name, streams };
+ mSctpmaps.push_back(value);
+ }
+
+ virtual void Serialize(std::ostream& os) const override;
+
+ bool
+ HasEntry(const std::string& pt) const
+ {
+ for (auto it = mSctpmaps.begin(); it != mSctpmaps.end(); ++it) {
+ if (it->pt == pt) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ const Sctpmap&
+ GetEntry(const std::string& pt) const
+ {
+ for (auto it = mSctpmaps.begin(); it != mSctpmaps.end(); ++it) {
+ if (it->pt == pt) {
+ return *it;
+ }
+ }
+ MOZ_CRASH();
+ }
+
+ std::vector<Sctpmap> mSctpmaps;
+};
+
+///////////////////////////////////////////////////////////////////////////
+// a=setup, RFC4145
+//-------------------------------------------------------------------------
+// setup-attr = "a=setup:" role
+// role = "active" / "passive" / "actpass" / "holdconn"
+class SdpSetupAttribute : public SdpAttribute
+{
+public:
+ enum Role { kActive, kPassive, kActpass, kHoldconn };
+
+ explicit SdpSetupAttribute(Role role)
+ : SdpAttribute(kSetupAttribute), mRole(role)
+ {
+ }
+
+ virtual void Serialize(std::ostream& os) const override;
+
+ Role mRole;
+};
+
+inline std::ostream& operator<<(std::ostream& os, SdpSetupAttribute::Role r)
+{
+ switch (r) {
+ case SdpSetupAttribute::kActive:
+ os << "active";
+ break;
+ case SdpSetupAttribute::kPassive:
+ os << "passive";
+ break;
+ case SdpSetupAttribute::kActpass:
+ os << "actpass";
+ break;
+ case SdpSetupAttribute::kHoldconn:
+ os << "holdconn";
+ break;
+ default:
+ MOZ_ASSERT(false);
+ os << "?";
+ }
+ return os;
+}
+
+// sc-attr = "a=simulcast:" 1*2( WSP sc-str-list ) [WSP sc-pause-list]
+// sc-str-list = sc-dir WSP sc-id-type "=" sc-alt-list *( ";" sc-alt-list )
+// sc-pause-list = "paused=" sc-alt-list
+// sc-dir = "send" / "recv"
+// sc-id-type = "pt" / "rid" / token
+// sc-alt-list = sc-id *( "," sc-id )
+// sc-id = fmt / rid-identifier / token
+// ; WSP defined in [RFC5234]
+// ; fmt, token defined in [RFC4566]
+// ; rid-identifier defined in [I-D.pthatcher-mmusic-rid]
+class SdpSimulcastAttribute : public SdpAttribute
+{
+public:
+ SdpSimulcastAttribute() : SdpAttribute(kSimulcastAttribute) {}
+
+ void Serialize(std::ostream& os) const override;
+ bool Parse(std::istream& is, std::string* error);
+
+ class Version
+ {
+ public:
+ void Serialize(std::ostream& os) const;
+ bool IsSet() const
+ {
+ return !choices.empty();
+ }
+ bool Parse(std::istream& is, std::string* error);
+ bool GetChoicesAsFormats(std::vector<uint16_t>* formats) const;
+
+ std::vector<std::string> choices;
+ };
+
+ class Versions : public std::vector<Version>
+ {
+ public:
+ enum Type {
+ kPt,
+ kRid
+ };
+
+ Versions() : type(kRid) {}
+ void Serialize(std::ostream& os) const;
+ bool IsSet() const
+ {
+ if (empty()) {
+ return false;
+ }
+
+ for (const Version& version : *this) {
+ if (version.IsSet()) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ bool Parse(std::istream& is, std::string* error);
+ Type type;
+ };
+
+ Versions sendVersions;
+ Versions recvVersions;
+};
+
+///////////////////////////////////////////////////////////////////////////
+// a=ssrc, RFC5576
+//-------------------------------------------------------------------------
+// ssrc-attr = "ssrc:" ssrc-id SP attribute
+// ; The base definition of "attribute" is in RFC 4566.
+// ; (It is the content of "a=" lines.)
+//
+// ssrc-id = integer ; 0 .. 2**32 - 1
+//-------------------------------------------------------------------------
+// TODO -- In the future, it might be nice if we ran a parse on the
+// attribute section of this so that we could interpret it semantically.
+// For WebRTC, the key use case for a=ssrc is assocaiting SSRCs with
+// media sections, and we're not really going to care about the attribute
+// itself. So we're just going to store it as a string for the time being.
+// Issue 187.
+class SdpSsrcAttributeList : public SdpAttribute
+{
+public:
+ SdpSsrcAttributeList() : SdpAttribute(kSsrcAttribute) {}
+
+ struct Ssrc {
+ uint32_t ssrc;
+ std::string attribute;
+ };
+
+ void
+ PushEntry(uint32_t ssrc, const std::string& attribute)
+ {
+ Ssrc value = { ssrc, attribute };
+ mSsrcs.push_back(value);
+ }
+
+ virtual void Serialize(std::ostream& os) const override;
+
+ std::vector<Ssrc> mSsrcs;
+};
+
+///////////////////////////////////////////////////////////////////////////
+// a=ssrc-group, RFC5576
+//-------------------------------------------------------------------------
+// ssrc-group-attr = "ssrc-group:" semantics *(SP ssrc-id)
+//
+// semantics = "FEC" / "FID" / token
+//
+// ssrc-id = integer ; 0 .. 2**32 - 1
+class SdpSsrcGroupAttributeList : public SdpAttribute
+{
+public:
+ enum Semantics {
+ kFec, // RFC5576
+ kFid, // RFC5576
+ kFecFr, // RFC5956
+ kDup // RFC7104
+ };
+
+ struct SsrcGroup {
+ Semantics semantics;
+ std::vector<uint32_t> ssrcs;
+ };
+
+ SdpSsrcGroupAttributeList() : SdpAttribute(kSsrcGroupAttribute) {}
+
+ void
+ PushEntry(Semantics semantics, const std::vector<uint32_t>& ssrcs)
+ {
+ SsrcGroup value = { semantics, ssrcs };
+ mSsrcGroups.push_back(value);
+ }
+
+ virtual void Serialize(std::ostream& os) const override;
+
+ std::vector<SsrcGroup> mSsrcGroups;
+};
+
+inline std::ostream& operator<<(std::ostream& os,
+ SdpSsrcGroupAttributeList::Semantics s)
+{
+ switch (s) {
+ case SdpSsrcGroupAttributeList::kFec:
+ os << "FEC";
+ break;
+ case SdpSsrcGroupAttributeList::kFid:
+ os << "FID";
+ break;
+ case SdpSsrcGroupAttributeList::kFecFr:
+ os << "FEC-FR";
+ break;
+ case SdpSsrcGroupAttributeList::kDup:
+ os << "DUP";
+ break;
+ default:
+ MOZ_ASSERT(false);
+ os << "?";
+ }
+ return os;
+}
+
+///////////////////////////////////////////////////////////////////////////
+class SdpMultiStringAttribute : public SdpAttribute
+{
+public:
+ explicit SdpMultiStringAttribute(AttributeType type) : SdpAttribute(type) {}
+
+ void
+ PushEntry(const std::string& entry)
+ {
+ mValues.push_back(entry);
+ }
+
+ virtual void Serialize(std::ostream& os) const;
+
+ std::vector<std::string> mValues;
+};
+
+// otherwise identical to SdpMultiStringAttribute, this is used for
+// ice-options and other places where the value is serialized onto
+// a single line with space separating tokens
+class SdpOptionsAttribute : public SdpAttribute
+{
+public:
+ explicit SdpOptionsAttribute(AttributeType type) : SdpAttribute(type) {}
+
+ void
+ PushEntry(const std::string& entry)
+ {
+ mValues.push_back(entry);
+ }
+
+ void Load(const std::string& value);
+
+ virtual void Serialize(std::ostream& os) const;
+
+ std::vector<std::string> mValues;
+};
+
+// Used for attributes that take no value (eg; a=ice-lite)
+class SdpFlagAttribute : public SdpAttribute
+{
+public:
+ explicit SdpFlagAttribute(AttributeType type) : SdpAttribute(type) {}
+
+ virtual void Serialize(std::ostream& os) const override;
+};
+
+// Used for any other kind of single-valued attribute not otherwise specialized
+class SdpStringAttribute : public SdpAttribute
+{
+public:
+ explicit SdpStringAttribute(AttributeType type, const std::string& value)
+ : SdpAttribute(type), mValue(value)
+ {
+ }
+
+ virtual void Serialize(std::ostream& os) const override;
+
+ std::string mValue;
+};
+
+// Used for any purely (non-negative) numeric attribute
+class SdpNumberAttribute : public SdpAttribute
+{
+public:
+ explicit SdpNumberAttribute(AttributeType type, uint32_t value = 0)
+ : SdpAttribute(type), mValue(value)
+ {
+ }
+
+ virtual void Serialize(std::ostream& os) const override;
+
+ uint32_t mValue;
+};
+
+} // namespace mozilla
+
+#endif
diff --git a/media/webrtc/signaling/src/sdp/SdpAttributeList.h b/media/webrtc/signaling/src/sdp/SdpAttributeList.h
new file mode 100644
index 000000000..fa84efea6
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/SdpAttributeList.h
@@ -0,0 +1,94 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef _SDPATTRIBUTELIST_H_
+#define _SDPATTRIBUTELIST_H_
+
+#include "mozilla/UniquePtr.h"
+#include "mozilla/Attributes.h"
+
+#include "signaling/src/sdp/SdpAttribute.h"
+
+namespace mozilla
+{
+
+class SdpAttributeList
+{
+public:
+ virtual ~SdpAttributeList() {}
+ typedef SdpAttribute::AttributeType AttributeType;
+
+ // Avoid default params on virtual functions
+ bool
+ HasAttribute(AttributeType type) const
+ {
+ return HasAttribute(type, true);
+ }
+
+ const SdpAttribute*
+ GetAttribute(AttributeType type) const
+ {
+ return GetAttribute(type, true);
+ }
+
+ virtual bool HasAttribute(AttributeType type, bool sessionFallback) const = 0;
+ virtual const SdpAttribute* GetAttribute(AttributeType type,
+ bool sessionFallback) const = 0;
+ // The setter takes an attribute of any type, and takes ownership
+ virtual void SetAttribute(SdpAttribute* attr) = 0;
+ virtual void RemoveAttribute(AttributeType type) = 0;
+ virtual void Clear() = 0;
+
+ virtual const SdpConnectionAttribute& GetConnection() const = 0;
+ virtual const SdpOptionsAttribute& GetIceOptions() const = 0;
+ virtual const SdpRtcpAttribute& GetRtcp() const = 0;
+ virtual const SdpRemoteCandidatesAttribute& GetRemoteCandidates() const = 0;
+ virtual const SdpSetupAttribute& GetSetup() const = 0;
+ virtual const SdpDtlsMessageAttribute& GetDtlsMessage() const = 0;
+
+ // These attributes can appear multiple times, so the returned
+ // classes actually represent a collection of values.
+ virtual const std::vector<std::string>& GetCandidate() const = 0;
+ virtual const SdpExtmapAttributeList& GetExtmap() const = 0;
+ virtual const SdpFingerprintAttributeList& GetFingerprint() const = 0;
+ virtual const SdpFmtpAttributeList& GetFmtp() const = 0;
+ virtual const SdpGroupAttributeList& GetGroup() const = 0;
+ virtual const SdpImageattrAttributeList& GetImageattr() const = 0;
+ virtual const SdpSimulcastAttribute& GetSimulcast() const = 0;
+ virtual const SdpMsidAttributeList& GetMsid() const = 0;
+ virtual const SdpMsidSemanticAttributeList& GetMsidSemantic() const = 0;
+ virtual const SdpRidAttributeList& GetRid() const = 0;
+ virtual const SdpRtcpFbAttributeList& GetRtcpFb() const = 0;
+ virtual const SdpRtpmapAttributeList& GetRtpmap() const = 0;
+ virtual const SdpSctpmapAttributeList& GetSctpmap() const = 0;
+ virtual const SdpSsrcAttributeList& GetSsrc() const = 0;
+ virtual const SdpSsrcGroupAttributeList& GetSsrcGroup() const = 0;
+
+ // These attributes are effectively simple types, so we'll make life
+ // easy by just returning their value.
+ virtual const std::string& GetIcePwd() const = 0;
+ virtual const std::string& GetIceUfrag() const = 0;
+ virtual const std::string& GetIdentity() const = 0;
+ virtual const std::string& GetLabel() const = 0;
+ virtual unsigned int GetMaxptime() const = 0;
+ virtual const std::string& GetMid() const = 0;
+ virtual unsigned int GetPtime() const = 0;
+
+ // This is "special", because it's multiple things
+ virtual SdpDirectionAttribute::Direction GetDirection() const = 0;
+
+ virtual void Serialize(std::ostream&) const = 0;
+};
+
+inline std::ostream& operator<<(std::ostream& os, const SdpAttributeList& al)
+{
+ al.Serialize(os);
+ return os;
+}
+
+} // namespace mozilla
+
+#endif
diff --git a/media/webrtc/signaling/src/sdp/SdpEnum.h b/media/webrtc/signaling/src/sdp/SdpEnum.h
new file mode 100644
index 000000000..b4a0d16b3
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/SdpEnum.h
@@ -0,0 +1,70 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef _SDPENUM_H_
+#define _SDPENUM_H_
+
+#include <ostream>
+
+#include "mozilla/Assertions.h"
+
+namespace mozilla
+{
+namespace sdp
+{
+
+enum NetType { kNetTypeNone, kInternet };
+
+inline std::ostream& operator<<(std::ostream& os, sdp::NetType t)
+{
+ switch (t) {
+ case sdp::kNetTypeNone:
+ MOZ_ASSERT(false);
+ return os << "NONE";
+ case sdp::kInternet:
+ return os << "IN";
+ }
+ MOZ_CRASH("Unknown NetType");
+}
+
+enum AddrType { kAddrTypeNone, kIPv4, kIPv6 };
+
+inline std::ostream& operator<<(std::ostream& os, sdp::AddrType t)
+{
+ switch (t) {
+ case sdp::kAddrTypeNone:
+ MOZ_ASSERT(false);
+ return os << "NONE";
+ case sdp::kIPv4:
+ return os << "IP4";
+ case sdp::kIPv6:
+ return os << "IP6";
+ }
+ MOZ_CRASH("Unknown AddrType");
+}
+
+enum Direction {
+ // Start at 1 so these can be used as flags
+ kSend = 1,
+ kRecv = 2
+};
+
+inline std::ostream& operator<<(std::ostream& os, sdp::Direction d)
+{
+ switch (d) {
+ case sdp::kSend:
+ return os << "send";
+ case sdp::kRecv:
+ return os << "recv";
+ }
+ MOZ_CRASH("Unknown Direction");
+}
+
+} // namespace sdp
+
+} // namespace mozilla
+
+#endif
diff --git a/media/webrtc/signaling/src/sdp/SdpErrorHolder.h b/media/webrtc/signaling/src/sdp/SdpErrorHolder.h
new file mode 100644
index 000000000..556fcefb6
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/SdpErrorHolder.h
@@ -0,0 +1,50 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef _SDPERRORHOLDER_H_
+#define _SDPERRORHOLDER_H_
+
+#include <vector>
+#include <string>
+
+namespace mozilla
+{
+
+class SdpErrorHolder
+{
+public:
+ SdpErrorHolder() {}
+ virtual ~SdpErrorHolder() {}
+
+ void
+ AddParseError(size_t line, const std::string& message)
+ {
+ mErrors.push_back(std::make_pair(line, message));
+ }
+
+ void
+ ClearParseErrors()
+ {
+ mErrors.clear();
+ }
+
+ /**
+ * Returns a reference to the list of parse errors.
+ * This gets cleared out when you call Parse.
+ */
+ const std::vector<std::pair<size_t, std::string> >&
+ GetParseErrors() const
+ {
+ return mErrors;
+ }
+
+private:
+ std::vector<std::pair<size_t, std::string> > mErrors;
+};
+
+} // namespace mozilla
+
+#endif
diff --git a/media/webrtc/signaling/src/sdp/SdpHelper.cpp b/media/webrtc/signaling/src/sdp/SdpHelper.cpp
new file mode 100644
index 000000000..e476b29e5
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/SdpHelper.cpp
@@ -0,0 +1,811 @@
+/* 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 "signaling/src/sdp/SdpHelper.h"
+
+#include "signaling/src/sdp/Sdp.h"
+#include "signaling/src/sdp/SdpMediaSection.h"
+#include "logging.h"
+
+#include "nsDebug.h"
+#include "nsError.h"
+#include "prprf.h"
+
+#include <string.h>
+#include <set>
+
+namespace mozilla {
+MOZ_MTLOG_MODULE("sdp")
+
+#define SDP_SET_ERROR(error) \
+ do { \
+ std::ostringstream os; \
+ os << error; \
+ mLastError = os.str(); \
+ MOZ_MTLOG(ML_ERROR, mLastError); \
+ } while (0);
+
+nsresult
+SdpHelper::CopyTransportParams(size_t numComponents,
+ const SdpMediaSection& oldLocal,
+ SdpMediaSection* newLocal)
+{
+ // Copy over m-section details
+ newLocal->SetPort(oldLocal.GetPort());
+ newLocal->GetConnection() = oldLocal.GetConnection();
+
+ const SdpAttributeList& oldLocalAttrs = oldLocal.GetAttributeList();
+ SdpAttributeList& newLocalAttrs = newLocal->GetAttributeList();
+
+ // Now we copy over attributes that won't be added by the usual logic
+ if (oldLocalAttrs.HasAttribute(SdpAttribute::kCandidateAttribute) &&
+ numComponents) {
+ UniquePtr<SdpMultiStringAttribute> candidateAttrs(
+ new SdpMultiStringAttribute(SdpAttribute::kCandidateAttribute));
+ for (const std::string& candidate : oldLocalAttrs.GetCandidate()) {
+ size_t component;
+ nsresult rv = GetComponent(candidate, &component);
+ NS_ENSURE_SUCCESS(rv, rv);
+ if (numComponents >= component) {
+ candidateAttrs->mValues.push_back(candidate);
+ }
+ }
+ if (candidateAttrs->mValues.size()) {
+ newLocalAttrs.SetAttribute(candidateAttrs.release());
+ }
+ }
+
+ if (numComponents == 2 &&
+ oldLocalAttrs.HasAttribute(SdpAttribute::kRtcpAttribute)) {
+ // copy rtcp attribute if we had one that we are using
+ newLocalAttrs.SetAttribute(new SdpRtcpAttribute(oldLocalAttrs.GetRtcp()));
+ }
+
+ return NS_OK;
+}
+
+bool
+SdpHelper::AreOldTransportParamsValid(const Sdp& oldAnswer,
+ const Sdp& offerersPreviousSdp,
+ const Sdp& newOffer,
+ size_t level)
+{
+ if (MsectionIsDisabled(oldAnswer.GetMediaSection(level)) ||
+ MsectionIsDisabled(newOffer.GetMediaSection(level))) {
+ // Obvious
+ return false;
+ }
+
+ if (IsBundleSlave(oldAnswer, level)) {
+ // The transport attributes on this m-section were thrown away, because it
+ // was bundled.
+ return false;
+ }
+
+ if (newOffer.GetMediaSection(level).GetAttributeList().HasAttribute(
+ SdpAttribute::kBundleOnlyAttribute) &&
+ IsBundleSlave(newOffer, level)) {
+ // It never makes sense to put transport attributes in a bundle-only
+ // m-section
+ return false;
+ }
+
+ if (IceCredentialsDiffer(newOffer.GetMediaSection(level),
+ offerersPreviousSdp.GetMediaSection(level))) {
+ return false;
+ }
+
+ return true;
+}
+
+bool
+SdpHelper::IceCredentialsDiffer(const SdpMediaSection& msection1,
+ const SdpMediaSection& msection2)
+{
+ const SdpAttributeList& attrs1(msection1.GetAttributeList());
+ const SdpAttributeList& attrs2(msection2.GetAttributeList());
+
+ if ((attrs1.GetIceUfrag() != attrs2.GetIceUfrag()) ||
+ (attrs1.GetIcePwd() != attrs2.GetIcePwd())) {
+ return true;
+ }
+
+ return false;
+}
+
+nsresult
+SdpHelper::GetComponent(const std::string& candidate, size_t* component)
+{
+ unsigned int temp;
+ int32_t result = PR_sscanf(candidate.c_str(), "%*s %u", &temp);
+ if (result == 1) {
+ *component = temp;
+ return NS_OK;
+ }
+ SDP_SET_ERROR("Malformed ICE candidate: " << candidate);
+ return NS_ERROR_INVALID_ARG;
+}
+
+bool
+SdpHelper::MsectionIsDisabled(const SdpMediaSection& msection) const
+{
+ return !msection.GetPort() &&
+ !msection.GetAttributeList().HasAttribute(
+ SdpAttribute::kBundleOnlyAttribute);
+}
+
+void
+SdpHelper::DisableMsection(Sdp* sdp, SdpMediaSection* msection)
+{
+ // Make sure to remove the mid from any group attributes
+ if (msection->GetAttributeList().HasAttribute(SdpAttribute::kMidAttribute)) {
+ std::string mid = msection->GetAttributeList().GetMid();
+ if (sdp->GetAttributeList().HasAttribute(SdpAttribute::kGroupAttribute)) {
+ UniquePtr<SdpGroupAttributeList> newGroupAttr(new SdpGroupAttributeList(
+ sdp->GetAttributeList().GetGroup()));
+ newGroupAttr->RemoveMid(mid);
+ sdp->GetAttributeList().SetAttribute(newGroupAttr.release());
+ }
+ }
+
+ // Clear out attributes.
+ msection->GetAttributeList().Clear();
+
+ auto* direction =
+ new SdpDirectionAttribute(SdpDirectionAttribute::kInactive);
+ msection->GetAttributeList().SetAttribute(direction);
+ msection->SetPort(0);
+
+ msection->ClearCodecs();
+
+ auto mediaType = msection->GetMediaType();
+ switch (mediaType) {
+ case SdpMediaSection::kAudio:
+ msection->AddCodec("0", "PCMU", 8000, 1);
+ break;
+ case SdpMediaSection::kVideo:
+ msection->AddCodec("120", "VP8", 90000, 1);
+ break;
+ case SdpMediaSection::kApplication:
+ msection->AddDataChannel("5000", "rejected", 0);
+ break;
+ default:
+ // We need to have something here to fit the grammar, this seems safe
+ // and 19 is a reserved payload type which should not be used by anyone.
+ msection->AddCodec("19", "reserved", 8000, 1);
+ }
+}
+
+void
+SdpHelper::GetBundleGroups(
+ const Sdp& sdp,
+ std::vector<SdpGroupAttributeList::Group>* bundleGroups) const
+{
+ if (sdp.GetAttributeList().HasAttribute(SdpAttribute::kGroupAttribute)) {
+ for (auto& group : sdp.GetAttributeList().GetGroup().mGroups) {
+ if (group.semantics == SdpGroupAttributeList::kBundle) {
+ bundleGroups->push_back(group);
+ }
+ }
+ }
+}
+
+nsresult
+SdpHelper::GetBundledMids(const Sdp& sdp, BundledMids* bundledMids)
+{
+ std::vector<SdpGroupAttributeList::Group> bundleGroups;
+ GetBundleGroups(sdp, &bundleGroups);
+
+ for (SdpGroupAttributeList::Group& group : bundleGroups) {
+ if (group.tags.empty()) {
+ SDP_SET_ERROR("Empty BUNDLE group");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ const SdpMediaSection* masterBundleMsection(
+ FindMsectionByMid(sdp, group.tags[0]));
+
+ if (!masterBundleMsection) {
+ SDP_SET_ERROR("mid specified for bundle transport in group attribute"
+ " does not exist in the SDP. (mid=" << group.tags[0] << ")");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ if (MsectionIsDisabled(*masterBundleMsection)) {
+ SDP_SET_ERROR("mid specified for bundle transport in group attribute"
+ " points at a disabled m-section. (mid=" << group.tags[0] << ")");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ for (const std::string& mid : group.tags) {
+ if (bundledMids->count(mid)) {
+ SDP_SET_ERROR("mid \'" << mid << "\' appears more than once in a "
+ "BUNDLE group");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ (*bundledMids)[mid] = masterBundleMsection;
+ }
+ }
+
+ return NS_OK;
+}
+
+bool
+SdpHelper::IsBundleSlave(const Sdp& sdp, uint16_t level)
+{
+ auto& msection = sdp.GetMediaSection(level);
+
+ if (!msection.GetAttributeList().HasAttribute(SdpAttribute::kMidAttribute)) {
+ // No mid, definitely no bundle for this m-section
+ return false;
+ }
+ std::string mid(msection.GetAttributeList().GetMid());
+
+ BundledMids bundledMids;
+ nsresult rv = GetBundledMids(sdp, &bundledMids);
+ if (NS_FAILED(rv)) {
+ // Should have been caught sooner.
+ MOZ_ASSERT(false);
+ return false;
+ }
+
+ if (bundledMids.count(mid) && level != bundledMids[mid]->GetLevel()) {
+ // mid is bundled, and isn't the bundle m-section
+ return true;
+ }
+
+ return false;
+}
+
+nsresult
+SdpHelper::GetMidFromLevel(const Sdp& sdp,
+ uint16_t level,
+ std::string* mid)
+{
+ if (level >= sdp.GetMediaSectionCount()) {
+ SDP_SET_ERROR("Index " << level << " out of range");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ const SdpMediaSection& msection = sdp.GetMediaSection(level);
+ const SdpAttributeList& attrList = msection.GetAttributeList();
+
+ // grab the mid and set the outparam
+ if (attrList.HasAttribute(SdpAttribute::kMidAttribute)) {
+ *mid = attrList.GetMid();
+ }
+
+ return NS_OK;
+}
+
+nsresult
+SdpHelper::AddCandidateToSdp(Sdp* sdp,
+ const std::string& candidateUntrimmed,
+ const std::string& mid,
+ uint16_t level)
+{
+
+ if (level >= sdp->GetMediaSectionCount()) {
+ SDP_SET_ERROR("Index " << level << " out of range");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ // Trim off '[a=]candidate:'
+ size_t begin = candidateUntrimmed.find(':');
+ if (begin == std::string::npos) {
+ SDP_SET_ERROR("Invalid candidate, no ':' (" << candidateUntrimmed << ")");
+ return NS_ERROR_INVALID_ARG;
+ }
+ ++begin;
+
+ std::string candidate = candidateUntrimmed.substr(begin);
+
+ // https://tools.ietf.org/html/draft-ietf-rtcweb-jsep-11#section-3.4.2.1
+ // Implementations receiving an ICE Candidate object MUST use the MID if
+ // present, or the m= line index, if not (as it could have come from a
+ // non-JSEP endpoint). (bug 1095793)
+ SdpMediaSection* msection = 0;
+ if (!mid.empty()) {
+ // FindMsectionByMid could return nullptr
+ msection = FindMsectionByMid(*sdp, mid);
+
+ // Check to make sure mid matches what we'd get by
+ // looking up the m= line using the level. (mjf)
+ std::string checkMid;
+ nsresult rv = GetMidFromLevel(*sdp, level, &checkMid);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ if (mid != checkMid) {
+ SDP_SET_ERROR("Mismatch between mid and level - \"" << mid
+ << "\" is not the mid for level " << level
+ << "; \"" << checkMid << "\" is");
+ return NS_ERROR_INVALID_ARG;
+ }
+ }
+ if (!msection) {
+ msection = &(sdp->GetMediaSection(level));
+ }
+
+ SdpAttributeList& attrList = msection->GetAttributeList();
+
+ UniquePtr<SdpMultiStringAttribute> candidates;
+ if (!attrList.HasAttribute(SdpAttribute::kCandidateAttribute)) {
+ // Create new
+ candidates.reset(
+ new SdpMultiStringAttribute(SdpAttribute::kCandidateAttribute));
+ } else {
+ // Copy existing
+ candidates.reset(new SdpMultiStringAttribute(
+ *static_cast<const SdpMultiStringAttribute*>(
+ attrList.GetAttribute(SdpAttribute::kCandidateAttribute))));
+ }
+ candidates->PushEntry(candidate);
+ attrList.SetAttribute(candidates.release());
+
+ return NS_OK;
+}
+
+void
+SdpHelper::SetIceGatheringComplete(Sdp* sdp,
+ uint16_t level,
+ BundledMids bundledMids)
+{
+ SdpMediaSection& msection = sdp->GetMediaSection(level);
+
+ if (kSlaveBundle == GetMsectionBundleType(*sdp,
+ level,
+ bundledMids,
+ nullptr)) {
+ return; // Slave bundle m-section. Skip.
+ }
+
+ SdpAttributeList& attrs = msection.GetAttributeList();
+ attrs.SetAttribute(
+ new SdpFlagAttribute(SdpAttribute::kEndOfCandidatesAttribute));
+ // Remove trickle-ice option
+ attrs.RemoveAttribute(SdpAttribute::kIceOptionsAttribute);
+}
+
+void
+SdpHelper::SetDefaultAddresses(const std::string& defaultCandidateAddr,
+ uint16_t defaultCandidatePort,
+ const std::string& defaultRtcpCandidateAddr,
+ uint16_t defaultRtcpCandidatePort,
+ Sdp* sdp,
+ uint16_t level,
+ BundledMids bundledMids)
+{
+ SdpMediaSection& msection = sdp->GetMediaSection(level);
+ std::string masterMid;
+
+ MsectionBundleType bundleType = GetMsectionBundleType(*sdp,
+ level,
+ bundledMids,
+ &masterMid);
+ if (kSlaveBundle == bundleType) {
+ return; // Slave bundle m-section. Skip.
+ }
+ if (kMasterBundle == bundleType) {
+ // Master bundle m-section. Set defaultCandidateAddr and
+ // defaultCandidatePort on all bundled m-sections.
+ const SdpMediaSection* masterBundleMsection(bundledMids[masterMid]);
+ for (auto i = bundledMids.begin(); i != bundledMids.end(); ++i) {
+ if (i->second != masterBundleMsection) {
+ continue;
+ }
+ SdpMediaSection* bundledMsection = FindMsectionByMid(*sdp, i->first);
+ if (!bundledMsection) {
+ MOZ_ASSERT(false);
+ continue;
+ }
+ SetDefaultAddresses(defaultCandidateAddr,
+ defaultCandidatePort,
+ defaultRtcpCandidateAddr,
+ defaultRtcpCandidatePort,
+ bundledMsection);
+ }
+ }
+
+ SetDefaultAddresses(defaultCandidateAddr,
+ defaultCandidatePort,
+ defaultRtcpCandidateAddr,
+ defaultRtcpCandidatePort,
+ &msection);
+}
+
+void
+SdpHelper::SetDefaultAddresses(const std::string& defaultCandidateAddr,
+ uint16_t defaultCandidatePort,
+ const std::string& defaultRtcpCandidateAddr,
+ uint16_t defaultRtcpCandidatePort,
+ SdpMediaSection* msection)
+{
+ msection->GetConnection().SetAddress(defaultCandidateAddr);
+ msection->SetPort(defaultCandidatePort);
+
+ if (!defaultRtcpCandidateAddr.empty()) {
+ sdp::AddrType ipVersion = sdp::kIPv4;
+ if (defaultRtcpCandidateAddr.find(':') != std::string::npos) {
+ ipVersion = sdp::kIPv6;
+ }
+ msection->GetAttributeList().SetAttribute(new SdpRtcpAttribute(
+ defaultRtcpCandidatePort,
+ sdp::kInternet,
+ ipVersion,
+ defaultRtcpCandidateAddr));
+ }
+}
+
+nsresult
+SdpHelper::GetIdsFromMsid(const Sdp& sdp,
+ const SdpMediaSection& msection,
+ std::string* streamId,
+ std::string* trackId)
+{
+ if (!sdp.GetAttributeList().HasAttribute(
+ SdpAttribute::kMsidSemanticAttribute)) {
+ return NS_ERROR_NOT_AVAILABLE;
+ }
+
+ auto& msidSemantics = sdp.GetAttributeList().GetMsidSemantic().mMsidSemantics;
+ std::vector<SdpMsidAttributeList::Msid> allMsids;
+ nsresult rv = GetMsids(msection, &allMsids);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ bool allMsidsAreWebrtc = false;
+ std::set<std::string> webrtcMsids;
+
+ for (auto i = msidSemantics.begin(); i != msidSemantics.end(); ++i) {
+ if (i->semantic == "WMS") {
+ for (auto j = i->msids.begin(); j != i->msids.end(); ++j) {
+ if (*j == "*") {
+ allMsidsAreWebrtc = true;
+ } else {
+ webrtcMsids.insert(*j);
+ }
+ }
+ break;
+ }
+ }
+
+ bool found = false;
+
+ for (auto i = allMsids.begin(); i != allMsids.end(); ++i) {
+ if (allMsidsAreWebrtc || webrtcMsids.count(i->identifier)) {
+ if (i->appdata.empty()) {
+ SDP_SET_ERROR("Invalid webrtc msid at level " << msection.GetLevel()
+ << ": Missing track id.");
+ return NS_ERROR_INVALID_ARG;
+ }
+ if (!found) {
+ *streamId = i->identifier;
+ *trackId = i->appdata;
+ found = true;
+ } else if ((*streamId != i->identifier) || (*trackId != i->appdata)) {
+ SDP_SET_ERROR("Found multiple different webrtc msids in m-section "
+ << msection.GetLevel() << ". The behavior here is "
+ "undefined.");
+ return NS_ERROR_INVALID_ARG;
+ }
+ }
+ }
+
+ if (!found) {
+ return NS_ERROR_NOT_AVAILABLE;
+ }
+
+ return NS_OK;
+}
+
+nsresult
+SdpHelper::GetMsids(const SdpMediaSection& msection,
+ std::vector<SdpMsidAttributeList::Msid>* msids)
+{
+ if (msection.GetAttributeList().HasAttribute(SdpAttribute::kMsidAttribute)) {
+ *msids = msection.GetAttributeList().GetMsid().mMsids;
+ }
+
+ // Can we find some additional msids in ssrc attributes?
+ // (Chrome does not put plain-old msid attributes in its SDP)
+ if (msection.GetAttributeList().HasAttribute(SdpAttribute::kSsrcAttribute)) {
+ auto& ssrcs = msection.GetAttributeList().GetSsrc().mSsrcs;
+
+ for (auto i = ssrcs.begin(); i != ssrcs.end(); ++i) {
+ if (i->attribute.find("msid:") == 0) {
+ std::string streamId;
+ std::string trackId;
+ nsresult rv = ParseMsid(i->attribute, &streamId, &trackId);
+ NS_ENSURE_SUCCESS(rv, rv);
+ msids->push_back({streamId, trackId});
+ }
+ }
+ }
+
+ return NS_OK;
+}
+
+nsresult
+SdpHelper::ParseMsid(const std::string& msidAttribute,
+ std::string* streamId,
+ std::string* trackId)
+{
+ // Would be nice if SdpSsrcAttributeList could parse out the contained
+ // attribute, but at least the parse here is simple.
+ // We are being very forgiving here wrt whitespace; tabs are not actually
+ // allowed, nor is leading/trailing whitespace.
+ size_t streamIdStart = msidAttribute.find_first_not_of(" \t", 5);
+ // We do not assume the appdata token is here, since this is not
+ // necessarily a webrtc msid
+ if (streamIdStart == std::string::npos) {
+ SDP_SET_ERROR("Malformed source-level msid attribute: "
+ << msidAttribute);
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ size_t streamIdEnd = msidAttribute.find_first_of(" \t", streamIdStart);
+ if (streamIdEnd == std::string::npos) {
+ streamIdEnd = msidAttribute.size();
+ }
+
+ size_t trackIdStart =
+ msidAttribute.find_first_not_of(" \t", streamIdEnd);
+ if (trackIdStart == std::string::npos) {
+ trackIdStart = msidAttribute.size();
+ }
+
+ size_t trackIdEnd = msidAttribute.find_first_of(" \t", trackIdStart);
+ if (trackIdEnd == std::string::npos) {
+ trackIdEnd = msidAttribute.size();
+ }
+
+ size_t streamIdSize = streamIdEnd - streamIdStart;
+ size_t trackIdSize = trackIdEnd - trackIdStart;
+
+ *streamId = msidAttribute.substr(streamIdStart, streamIdSize);
+ *trackId = msidAttribute.substr(trackIdStart, trackIdSize);
+ return NS_OK;
+}
+
+void
+SdpHelper::SetupMsidSemantic(const std::vector<std::string>& msids,
+ Sdp* sdp) const
+{
+ if (!msids.empty()) {
+ UniquePtr<SdpMsidSemanticAttributeList> msidSemantics(
+ new SdpMsidSemanticAttributeList);
+ msidSemantics->PushEntry("WMS", msids);
+ sdp->GetAttributeList().SetAttribute(msidSemantics.release());
+ }
+}
+
+std::string
+SdpHelper::GetCNAME(const SdpMediaSection& msection) const
+{
+ if (msection.GetAttributeList().HasAttribute(SdpAttribute::kSsrcAttribute)) {
+ auto& ssrcs = msection.GetAttributeList().GetSsrc().mSsrcs;
+ for (auto i = ssrcs.begin(); i != ssrcs.end(); ++i) {
+ if (i->attribute.find("cname:") == 0) {
+ return i->attribute.substr(6);
+ }
+ }
+ }
+ return "";
+}
+
+const SdpMediaSection*
+SdpHelper::FindMsectionByMid(const Sdp& sdp,
+ const std::string& mid) const
+{
+ for (size_t i = 0; i < sdp.GetMediaSectionCount(); ++i) {
+ auto& attrs = sdp.GetMediaSection(i).GetAttributeList();
+ if (attrs.HasAttribute(SdpAttribute::kMidAttribute) &&
+ attrs.GetMid() == mid) {
+ return &sdp.GetMediaSection(i);
+ }
+ }
+ return nullptr;
+}
+
+SdpMediaSection*
+SdpHelper::FindMsectionByMid(Sdp& sdp,
+ const std::string& mid) const
+{
+ for (size_t i = 0; i < sdp.GetMediaSectionCount(); ++i) {
+ auto& attrs = sdp.GetMediaSection(i).GetAttributeList();
+ if (attrs.HasAttribute(SdpAttribute::kMidAttribute) &&
+ attrs.GetMid() == mid) {
+ return &sdp.GetMediaSection(i);
+ }
+ }
+ return nullptr;
+}
+
+nsresult
+SdpHelper::CopyStickyParams(const SdpMediaSection& source,
+ SdpMediaSection* dest)
+{
+ auto& sourceAttrs = source.GetAttributeList();
+ auto& destAttrs = dest->GetAttributeList();
+
+ // There's no reason to renegotiate rtcp-mux
+ if (sourceAttrs.HasAttribute(SdpAttribute::kRtcpMuxAttribute)) {
+ destAttrs.SetAttribute(
+ new SdpFlagAttribute(SdpAttribute::kRtcpMuxAttribute));
+ }
+
+ // mid should stay the same
+ if (sourceAttrs.HasAttribute(SdpAttribute::kMidAttribute)) {
+ destAttrs.SetAttribute(
+ new SdpStringAttribute(SdpAttribute::kMidAttribute,
+ sourceAttrs.GetMid()));
+ }
+
+ return NS_OK;
+}
+
+bool
+SdpHelper::HasRtcp(SdpMediaSection::Protocol proto) const
+{
+ switch (proto) {
+ case SdpMediaSection::kRtpAvpf:
+ case SdpMediaSection::kDccpRtpAvpf:
+ case SdpMediaSection::kDccpRtpSavpf:
+ case SdpMediaSection::kRtpSavpf:
+ case SdpMediaSection::kUdpTlsRtpSavpf:
+ case SdpMediaSection::kTcpTlsRtpSavpf:
+ case SdpMediaSection::kDccpTlsRtpSavpf:
+ return true;
+ case SdpMediaSection::kRtpAvp:
+ case SdpMediaSection::kUdp:
+ case SdpMediaSection::kVat:
+ case SdpMediaSection::kRtp:
+ case SdpMediaSection::kUdptl:
+ case SdpMediaSection::kTcp:
+ case SdpMediaSection::kTcpRtpAvp:
+ case SdpMediaSection::kRtpSavp:
+ case SdpMediaSection::kTcpBfcp:
+ case SdpMediaSection::kTcpTlsBfcp:
+ case SdpMediaSection::kTcpTls:
+ case SdpMediaSection::kFluteUdp:
+ case SdpMediaSection::kTcpMsrp:
+ case SdpMediaSection::kTcpTlsMsrp:
+ case SdpMediaSection::kDccp:
+ case SdpMediaSection::kDccpRtpAvp:
+ case SdpMediaSection::kDccpRtpSavp:
+ case SdpMediaSection::kUdpTlsRtpSavp:
+ case SdpMediaSection::kTcpTlsRtpSavp:
+ case SdpMediaSection::kDccpTlsRtpSavp:
+ case SdpMediaSection::kUdpMbmsFecRtpAvp:
+ case SdpMediaSection::kUdpMbmsFecRtpSavp:
+ case SdpMediaSection::kUdpMbmsRepair:
+ case SdpMediaSection::kFecUdp:
+ case SdpMediaSection::kUdpFec:
+ case SdpMediaSection::kTcpMrcpv2:
+ case SdpMediaSection::kTcpTlsMrcpv2:
+ case SdpMediaSection::kPstn:
+ case SdpMediaSection::kUdpTlsUdptl:
+ case SdpMediaSection::kSctp:
+ case SdpMediaSection::kSctpDtls:
+ case SdpMediaSection::kDtlsSctp:
+ return false;
+ }
+ MOZ_CRASH("Unknown protocol, probably corruption.");
+}
+
+SdpMediaSection::Protocol
+SdpHelper::GetProtocolForMediaType(SdpMediaSection::MediaType type)
+{
+ if (type == SdpMediaSection::kApplication) {
+ return SdpMediaSection::kDtlsSctp;
+ }
+
+ return SdpMediaSection::kUdpTlsRtpSavpf;
+}
+
+void
+SdpHelper::appendSdpParseErrors(
+ const std::vector<std::pair<size_t, std::string> >& aErrors,
+ std::string* aErrorString)
+{
+ std::ostringstream os;
+ for (auto i = aErrors.begin(); i != aErrors.end(); ++i) {
+ os << "SDP Parse Error on line " << i->first << ": " + i->second
+ << std::endl;
+ }
+ *aErrorString += os.str();
+}
+
+/* static */ bool
+SdpHelper::GetPtAsInt(const std::string& ptString, uint16_t* ptOutparam)
+{
+ char* end;
+ unsigned long pt = strtoul(ptString.c_str(), &end, 10);
+ size_t length = static_cast<size_t>(end - ptString.c_str());
+ if ((pt > UINT16_MAX) || (length != ptString.size())) {
+ return false;
+ }
+ *ptOutparam = pt;
+ return true;
+}
+
+void
+SdpHelper::AddCommonExtmaps(
+ const SdpMediaSection& remoteMsection,
+ const std::vector<SdpExtmapAttributeList::Extmap>& localExtensions,
+ SdpMediaSection* localMsection)
+{
+ if (!remoteMsection.GetAttributeList().HasAttribute(
+ SdpAttribute::kExtmapAttribute)) {
+ return;
+ }
+
+ UniquePtr<SdpExtmapAttributeList> localExtmap(new SdpExtmapAttributeList);
+ auto& theirExtmap = remoteMsection.GetAttributeList().GetExtmap().mExtmaps;
+ for (auto i = theirExtmap.begin(); i != theirExtmap.end(); ++i) {
+ for (auto j = localExtensions.begin(); j != localExtensions.end(); ++j) {
+ // verify we have a valid combination of directions. For kInactive
+ // we'll just not add the response
+ if (i->extensionname == j->extensionname &&
+ (((i->direction == SdpDirectionAttribute::Direction::kSendrecv ||
+ i->direction == SdpDirectionAttribute::Direction::kSendonly) &&
+ (j->direction == SdpDirectionAttribute::Direction::kSendrecv ||
+ j->direction == SdpDirectionAttribute::Direction::kRecvonly)) ||
+
+ ((i->direction == SdpDirectionAttribute::Direction::kSendrecv ||
+ i->direction == SdpDirectionAttribute::Direction::kRecvonly) &&
+ (j->direction == SdpDirectionAttribute::Direction::kSendrecv ||
+ j->direction == SdpDirectionAttribute::Direction::kSendonly)))) {
+ auto k = *i; // we need to modify it
+ if (j->direction == SdpDirectionAttribute::Direction::kSendonly) {
+ k.direction = SdpDirectionAttribute::Direction::kRecvonly;
+ } else if (j->direction == SdpDirectionAttribute::Direction::kRecvonly) {
+ k.direction = SdpDirectionAttribute::Direction::kSendonly;
+ }
+ localExtmap->mExtmaps.push_back(k);
+
+ // RFC 5285 says that ids >= 4096 can be used by the offerer to
+ // force the answerer to pick, otherwise the value in the offer is
+ // used.
+ if (localExtmap->mExtmaps.back().entry >= 4096) {
+ localExtmap->mExtmaps.back().entry = j->entry;
+ }
+ }
+ }
+ }
+
+ if (!localExtmap->mExtmaps.empty()) {
+ localMsection->GetAttributeList().SetAttribute(localExtmap.release());
+ }
+}
+
+SdpHelper::MsectionBundleType
+SdpHelper::GetMsectionBundleType(const Sdp& sdp,
+ uint16_t level,
+ BundledMids& bundledMids,
+ std::string* masterMid) const
+{
+ const SdpMediaSection& msection = sdp.GetMediaSection(level);
+ if (msection.GetAttributeList().HasAttribute(SdpAttribute::kMidAttribute)) {
+ std::string mid(msection.GetAttributeList().GetMid());
+ if (bundledMids.count(mid)) {
+ const SdpMediaSection* masterBundleMsection(bundledMids[mid]);
+ if (msection.GetLevel() != masterBundleMsection->GetLevel()) {
+ return kSlaveBundle;
+ }
+
+ // allow the caller not to care about the masterMid
+ if (masterMid) {
+ *masterMid = mid;
+ }
+ return kMasterBundle;
+ }
+ }
+ return kNoBundle;
+}
+
+} // namespace mozilla
+
+
diff --git a/media/webrtc/signaling/src/sdp/SdpHelper.h b/media/webrtc/signaling/src/sdp/SdpHelper.h
new file mode 100644
index 000000000..21940f280
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/SdpHelper.h
@@ -0,0 +1,131 @@
+/* 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/. */
+
+#ifndef _SDPHELPER_H_
+#define _SDPHELPER_H_
+
+#include "nsError.h"
+
+#include "signaling/src/sdp/SdpMediaSection.h"
+#include "signaling/src/sdp/SdpAttribute.h"
+
+#include "m_cpp_utils.h"
+
+#include <string>
+#include <map>
+#include <vector>
+
+namespace mozilla {
+class SdpMediaSection;
+class Sdp;
+
+class SdpHelper {
+ public:
+ enum MsectionBundleType {
+ kNoBundle,
+ kSlaveBundle,
+ kMasterBundle
+ };
+
+ // Takes a std::string* into which error strings will be written for the
+ // lifetime of the SdpHelper.
+ explicit SdpHelper(std::string* errorDest) : mLastError(*errorDest) {}
+ ~SdpHelper() {}
+
+ nsresult GetComponent(const std::string& candidate, size_t* component);
+ nsresult CopyTransportParams(size_t numComponents,
+ const SdpMediaSection& source,
+ SdpMediaSection* dest);
+ bool AreOldTransportParamsValid(const Sdp& oldAnswer,
+ const Sdp& offerersPreviousSdp,
+ const Sdp& newOffer,
+ size_t level);
+ bool IceCredentialsDiffer(const SdpMediaSection& msection1,
+ const SdpMediaSection& msection2);
+
+ bool MsectionIsDisabled(const SdpMediaSection& msection) const;
+ static void DisableMsection(Sdp* sdp, SdpMediaSection* msection);
+
+ // Maps each mid to the m-section that is the master of its bundle.
+ // Mids that do not appear in an a=group:BUNDLE do not appear here.
+ typedef std::map<std::string, const SdpMediaSection*> BundledMids;
+
+ nsresult GetBundledMids(const Sdp& sdp, BundledMids* bundledMids);
+
+ bool IsBundleSlave(const Sdp& localSdp, uint16_t level);
+ void GetBundleGroups(
+ const Sdp& sdp,
+ std::vector<SdpGroupAttributeList::Group>* groups) const;
+
+ nsresult GetMidFromLevel(const Sdp& sdp,
+ uint16_t level,
+ std::string* mid);
+ nsresult GetIdsFromMsid(const Sdp& sdp,
+ const SdpMediaSection& msection,
+ std::string* streamId,
+ std::string* trackId);
+ nsresult GetMsids(const SdpMediaSection& msection,
+ std::vector<SdpMsidAttributeList::Msid>* msids);
+ nsresult ParseMsid(const std::string& msidAttribute,
+ std::string* streamId,
+ std::string* trackId);
+ nsresult AddCandidateToSdp(Sdp* sdp,
+ const std::string& candidate,
+ const std::string& mid,
+ uint16_t level);
+ void SetIceGatheringComplete(Sdp* sdp,
+ uint16_t level,
+ BundledMids bundledMids);
+ void SetDefaultAddresses(const std::string& defaultCandidateAddr,
+ uint16_t defaultCandidatePort,
+ const std::string& defaultRtcpCandidateAddr,
+ uint16_t defaultRtcpCandidatePort,
+ Sdp* sdp,
+ uint16_t level,
+ BundledMids bundledMids);
+ void SetDefaultAddresses(const std::string& defaultCandidateAddr,
+ uint16_t defaultCandidatePort,
+ const std::string& defaultRtcpCandidateAddr,
+ uint16_t defaultRtcpCandidatePort,
+ SdpMediaSection* msection);
+ void SetupMsidSemantic(const std::vector<std::string>& msids,
+ Sdp* sdp) const;
+ MsectionBundleType GetMsectionBundleType(const Sdp& sdp,
+ uint16_t level,
+ BundledMids& bundledMids,
+ std::string* masterMid) const;
+
+ std::string GetCNAME(const SdpMediaSection& msection) const;
+
+ SdpMediaSection* FindMsectionByMid(Sdp& sdp,
+ const std::string& mid) const;
+
+ const SdpMediaSection* FindMsectionByMid(const Sdp& sdp,
+ const std::string& mid) const;
+
+ nsresult CopyStickyParams(const SdpMediaSection& source,
+ SdpMediaSection* dest);
+ bool HasRtcp(SdpMediaSection::Protocol proto) const;
+ static SdpMediaSection::Protocol GetProtocolForMediaType(
+ SdpMediaSection::MediaType type);
+ void appendSdpParseErrors(
+ const std::vector<std::pair<size_t, std::string> >& aErrors,
+ std::string* aErrorString);
+
+ static bool GetPtAsInt(const std::string& ptString, uint16_t* ptOutparam);
+
+ void AddCommonExtmaps(
+ const SdpMediaSection& remoteMsection,
+ const std::vector<SdpExtmapAttributeList::Extmap>& localExtensions,
+ SdpMediaSection* localMsection);
+
+ private:
+ std::string& mLastError;
+
+ DISALLOW_COPY_ASSIGN(SdpHelper);
+};
+} // namespace mozilla
+
+#endif // _SDPHELPER_H_
+
diff --git a/media/webrtc/signaling/src/sdp/SdpMediaSection.cpp b/media/webrtc/signaling/src/sdp/SdpMediaSection.cpp
new file mode 100644
index 000000000..bd3fab555
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/SdpMediaSection.cpp
@@ -0,0 +1,196 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* 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 "signaling/src/sdp/SdpMediaSection.h"
+
+namespace mozilla
+{
+const SdpFmtpAttributeList::Parameters*
+SdpMediaSection::FindFmtp(const std::string& pt) const
+{
+ const SdpAttributeList& attrs = GetAttributeList();
+
+ if (attrs.HasAttribute(SdpAttribute::kFmtpAttribute)) {
+ for (auto& fmtpAttr : attrs.GetFmtp().mFmtps) {
+ if (fmtpAttr.format == pt && fmtpAttr.parameters) {
+ return fmtpAttr.parameters.get();
+ }
+ }
+ }
+ return nullptr;
+}
+
+void
+SdpMediaSection::SetFmtp(const SdpFmtpAttributeList::Fmtp& fmtpToSet)
+{
+ UniquePtr<SdpFmtpAttributeList> fmtps(new SdpFmtpAttributeList);
+
+ if (GetAttributeList().HasAttribute(SdpAttribute::kFmtpAttribute)) {
+ *fmtps = GetAttributeList().GetFmtp();
+ }
+
+ bool found = false;
+ for (SdpFmtpAttributeList::Fmtp& fmtp : fmtps->mFmtps) {
+ if (fmtp.format == fmtpToSet.format) {
+ fmtp = fmtpToSet;
+ found = true;
+ }
+ }
+
+ if (!found) {
+ fmtps->mFmtps.push_back(fmtpToSet);
+ }
+
+ GetAttributeList().SetAttribute(fmtps.release());
+}
+
+void
+SdpMediaSection::RemoveFmtp(const std::string& pt)
+{
+ UniquePtr<SdpFmtpAttributeList> fmtps(new SdpFmtpAttributeList);
+
+ SdpAttributeList& attrList = GetAttributeList();
+ if (attrList.HasAttribute(SdpAttribute::kFmtpAttribute)) {
+ *fmtps = attrList.GetFmtp();
+ }
+
+ for (size_t i = 0; i < fmtps->mFmtps.size(); ++i) {
+ if (pt == fmtps->mFmtps[i].format) {
+ fmtps->mFmtps.erase(fmtps->mFmtps.begin() + i);
+ break;
+ }
+ }
+
+ attrList.SetAttribute(fmtps.release());
+}
+
+const SdpRtpmapAttributeList::Rtpmap*
+SdpMediaSection::FindRtpmap(const std::string& pt) const
+{
+ auto& attrs = GetAttributeList();
+ if (!attrs.HasAttribute(SdpAttribute::kRtpmapAttribute)) {
+ return nullptr;
+ }
+
+ const SdpRtpmapAttributeList& rtpmap = attrs.GetRtpmap();
+ if (!rtpmap.HasEntry(pt)) {
+ return nullptr;
+ }
+
+ return &rtpmap.GetEntry(pt);
+}
+
+const SdpSctpmapAttributeList::Sctpmap*
+SdpMediaSection::FindSctpmap(const std::string& pt) const
+{
+ auto& attrs = GetAttributeList();
+ if (!attrs.HasAttribute(SdpAttribute::kSctpmapAttribute)) {
+ return nullptr;
+ }
+
+ const SdpSctpmapAttributeList& sctpmap = attrs.GetSctpmap();
+ if (!sctpmap.HasEntry(pt)) {
+ return nullptr;
+ }
+
+ return &sctpmap.GetEntry(pt);
+}
+
+bool
+SdpMediaSection::HasRtcpFb(const std::string& pt,
+ SdpRtcpFbAttributeList::Type type,
+ const std::string& subType) const
+{
+ const SdpAttributeList& attrs(GetAttributeList());
+
+ if (!attrs.HasAttribute(SdpAttribute::kRtcpFbAttribute)) {
+ return false;
+ }
+
+ for (auto& rtcpfb : attrs.GetRtcpFb().mFeedbacks) {
+ if (rtcpfb.type == type) {
+ if (rtcpfb.pt == "*" || rtcpfb.pt == pt) {
+ if (rtcpfb.parameter == subType) {
+ return true;
+ }
+ }
+ }
+ }
+
+ return false;
+}
+
+SdpRtcpFbAttributeList
+SdpMediaSection::GetRtcpFbs() const
+{
+ SdpRtcpFbAttributeList result;
+ if (GetAttributeList().HasAttribute(SdpAttribute::kRtcpFbAttribute)) {
+ result = GetAttributeList().GetRtcpFb();
+ }
+ return result;
+}
+
+void
+SdpMediaSection::SetRtcpFbs(const SdpRtcpFbAttributeList& rtcpfbs)
+{
+ if (rtcpfbs.mFeedbacks.empty()) {
+ GetAttributeList().RemoveAttribute(SdpAttribute::kRtcpFbAttribute);
+ return;
+ }
+
+ GetAttributeList().SetAttribute(new SdpRtcpFbAttributeList(rtcpfbs));
+}
+
+void
+SdpMediaSection::SetSsrcs(const std::vector<uint32_t>& ssrcs,
+ const std::string& cname)
+{
+ if (ssrcs.empty()) {
+ GetAttributeList().RemoveAttribute(SdpAttribute::kSsrcAttribute);
+ return;
+ }
+
+ UniquePtr<SdpSsrcAttributeList> ssrcAttr(new SdpSsrcAttributeList);
+ for (auto ssrc : ssrcs) {
+ // When using ssrc attributes, we are required to at least have a cname.
+ // (See https://tools.ietf.org/html/rfc5576#section-6.1)
+ std::string cnameAttr("cname:");
+ cnameAttr += cname;
+ ssrcAttr->PushEntry(ssrc, cnameAttr);
+ }
+
+ GetAttributeList().SetAttribute(ssrcAttr.release());
+}
+
+void
+SdpMediaSection::AddMsid(const std::string& id, const std::string& appdata)
+{
+ UniquePtr<SdpMsidAttributeList> msids(new SdpMsidAttributeList);
+ if (GetAttributeList().HasAttribute(SdpAttribute::kMsidAttribute)) {
+ msids->mMsids = GetAttributeList().GetMsid().mMsids;
+ }
+ msids->PushEntry(id, appdata);
+ GetAttributeList().SetAttribute(msids.release());
+}
+
+const SdpRidAttributeList::Rid*
+SdpMediaSection::FindRid(const std::string& id) const
+{
+ if (!GetAttributeList().HasAttribute(SdpAttribute::kRidAttribute)) {
+ return nullptr;
+ }
+
+ for (const auto& rid : GetAttributeList().GetRid().mRids) {
+ if (rid.id == id) {
+ return &rid;
+ }
+ }
+
+ return nullptr;
+}
+
+} // namespace mozilla
+
diff --git a/media/webrtc/signaling/src/sdp/SdpMediaSection.h b/media/webrtc/signaling/src/sdp/SdpMediaSection.h
new file mode 100644
index 000000000..16242ab16
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/SdpMediaSection.h
@@ -0,0 +1,361 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef _SDPMEDIASECTION_H_
+#define _SDPMEDIASECTION_H_
+
+#include "mozilla/Maybe.h"
+#include "signaling/src/sdp/SdpEnum.h"
+#include "signaling/src/sdp/SdpAttributeList.h"
+#include <string>
+#include <vector>
+#include <sstream>
+
+namespace mozilla
+{
+
+class SdpAttributeList;
+
+class SdpConnection;
+
+class SdpMediaSection
+{
+public:
+ enum MediaType { kAudio, kVideo, kText, kApplication, kMessage };
+ // don't add to enum to avoid warnings about unhandled enum values
+ static const size_t kMediaTypes = static_cast<size_t>(kMessage) + 1;
+
+ enum Protocol {
+ kRtpAvp, // RTP/AVP [RFC4566]
+ kUdp, // udp [RFC4566]
+ kVat, // vat [historic]
+ kRtp, // rtp [historic]
+ kUdptl, // udptl [ITU-T]
+ kTcp, // TCP [RFC4145]
+ kRtpAvpf, // RTP/AVPF [RFC4585]
+ kTcpRtpAvp, // TCP/RTP/AVP [RFC4571]
+ kRtpSavp, // RTP/SAVP [RFC3711]
+ kTcpBfcp, // TCP/BFCP [RFC4583]
+ kTcpTlsBfcp, // TCP/TLS/BFCP [RFC4583]
+ kTcpTls, // TCP/TLS [RFC4572]
+ kFluteUdp, // FLUTE/UDP [RFC-mehta-rmt-flute-sdp-05]
+ kTcpMsrp, // TCP/MSRP [RFC4975]
+ kTcpTlsMsrp, // TCP/TLS/MSRP [RFC4975]
+ kDccp, // DCCP [RFC5762]
+ kDccpRtpAvp, // DCCP/RTP/AVP [RFC5762]
+ kDccpRtpSavp, // DCCP/RTP/SAVP [RFC5762]
+ kDccpRtpAvpf, // DCCP/RTP/AVPF [RFC5762]
+ kDccpRtpSavpf, // DCCP/RTP/SAVPF [RFC5762]
+ kRtpSavpf, // RTP/SAVPF [RFC5124]
+ kUdpTlsRtpSavp, // UDP/TLS/RTP/SAVP [RFC5764]
+ kTcpTlsRtpSavp, // TCP/TLS/RTP/SAVP [JSEP-TBD]
+ kDccpTlsRtpSavp, // DCCP/TLS/RTP/SAVP [RFC5764]
+ kUdpTlsRtpSavpf, // UDP/TLS/RTP/SAVPF [RFC5764]
+ kTcpTlsRtpSavpf, // TCP/TLS/RTP/SAVPF [JSEP-TBD]
+ kDccpTlsRtpSavpf, // DCCP/TLS/RTP/SAVPF [RFC5764]
+ kUdpMbmsFecRtpAvp, // UDP/MBMS-FEC/RTP/AVP [RFC6064]
+ kUdpMbmsFecRtpSavp, // UDP/MBMS-FEC/RTP/SAVP [RFC6064]
+ kUdpMbmsRepair, // UDP/MBMS-REPAIR [RFC6064]
+ kFecUdp, // FEC/UDP [RFC6364]
+ kUdpFec, // UDP/FEC [RFC6364]
+ kTcpMrcpv2, // TCP/MRCPv2 [RFC6787]
+ kTcpTlsMrcpv2, // TCP/TLS/MRCPv2 [RFC6787]
+ kPstn, // PSTN [RFC7195]
+ kUdpTlsUdptl, // UDP/TLS/UDPTL [RFC7345]
+ kSctp, // SCTP [draft-ietf-mmusic-sctp-sdp-07]
+ kSctpDtls, // SCTP/DTLS [draft-ietf-mmusic-sctp-sdp-07]
+ kDtlsSctp // DTLS/SCTP [draft-ietf-mmusic-sctp-sdp-07]
+ };
+
+ explicit SdpMediaSection(size_t level) : mLevel(level) {}
+
+ virtual MediaType GetMediaType() const = 0;
+ virtual unsigned int GetPort() const = 0;
+ virtual void SetPort(unsigned int port) = 0;
+ virtual unsigned int GetPortCount() const = 0;
+ virtual Protocol GetProtocol() const = 0;
+ virtual const SdpConnection& GetConnection() const = 0;
+ virtual SdpConnection& GetConnection() = 0;
+ virtual uint32_t GetBandwidth(const std::string& type) const = 0;
+ virtual const std::vector<std::string>& GetFormats() const = 0;
+
+ std::vector<std::string> GetFormatsForSimulcastVersion(
+ size_t simulcastVersion, bool send, bool recv) const;
+ virtual const SdpAttributeList& GetAttributeList() const = 0;
+ virtual SdpAttributeList& GetAttributeList() = 0;
+
+ virtual SdpDirectionAttribute GetDirectionAttribute() const = 0;
+
+ virtual void Serialize(std::ostream&) const = 0;
+
+ virtual void AddCodec(const std::string& pt, const std::string& name,
+ uint32_t clockrate, uint16_t channels) = 0;
+ virtual void ClearCodecs() = 0;
+
+ virtual void AddDataChannel(const std::string& pt, const std::string& name,
+ uint16_t streams) = 0;
+
+ size_t
+ GetLevel() const
+ {
+ return mLevel;
+ }
+
+ inline bool
+ IsReceiving() const
+ {
+ return GetDirectionAttribute().mValue & sdp::kRecv;
+ }
+
+ inline bool
+ IsSending() const
+ {
+ return GetDirectionAttribute().mValue & sdp::kSend;
+ }
+
+ inline void
+ SetReceiving(bool receiving)
+ {
+ auto direction = GetDirectionAttribute().mValue;
+ if (direction & sdp::kSend) {
+ SetDirection(receiving ?
+ SdpDirectionAttribute::kSendrecv :
+ SdpDirectionAttribute::kSendonly);
+ } else {
+ SetDirection(receiving ?
+ SdpDirectionAttribute::kRecvonly :
+ SdpDirectionAttribute::kInactive);
+ }
+ }
+
+ inline void
+ SetSending(bool sending)
+ {
+ auto direction = GetDirectionAttribute().mValue;
+ if (direction & sdp::kRecv) {
+ SetDirection(sending ?
+ SdpDirectionAttribute::kSendrecv :
+ SdpDirectionAttribute::kRecvonly);
+ } else {
+ SetDirection(sending ?
+ SdpDirectionAttribute::kSendonly :
+ SdpDirectionAttribute::kInactive);
+ }
+ }
+
+ inline void SetDirection(SdpDirectionAttribute::Direction direction)
+ {
+ GetAttributeList().SetAttribute(new SdpDirectionAttribute(direction));
+ }
+
+ const SdpFmtpAttributeList::Parameters* FindFmtp(const std::string& pt) const;
+ void SetFmtp(const SdpFmtpAttributeList::Fmtp& fmtp);
+ void RemoveFmtp(const std::string& pt);
+ const SdpRtpmapAttributeList::Rtpmap* FindRtpmap(const std::string& pt) const;
+ const SdpSctpmapAttributeList::Sctpmap* FindSctpmap(
+ const std::string& pt) const;
+ bool HasRtcpFb(const std::string& pt,
+ SdpRtcpFbAttributeList::Type type,
+ const std::string& subType) const;
+ SdpRtcpFbAttributeList GetRtcpFbs() const;
+ void SetRtcpFbs(const SdpRtcpFbAttributeList& rtcpfbs);
+ bool HasFormat(const std::string& format) const
+ {
+ return std::find(GetFormats().begin(), GetFormats().end(), format) !=
+ GetFormats().end();
+ }
+ void SetSsrcs(const std::vector<uint32_t>& ssrcs,
+ const std::string& cname);
+ void AddMsid(const std::string& id, const std::string& appdata);
+ const SdpRidAttributeList::Rid* FindRid(const std::string& id) const;
+
+private:
+ size_t mLevel;
+};
+
+inline std::ostream& operator<<(std::ostream& os, const SdpMediaSection& ms)
+{
+ ms.Serialize(os);
+ return os;
+}
+
+inline std::ostream& operator<<(std::ostream& os, SdpMediaSection::MediaType t)
+{
+ switch (t) {
+ case SdpMediaSection::kAudio:
+ return os << "audio";
+ case SdpMediaSection::kVideo:
+ return os << "video";
+ case SdpMediaSection::kText:
+ return os << "text";
+ case SdpMediaSection::kApplication:
+ return os << "application";
+ case SdpMediaSection::kMessage:
+ return os << "message";
+ }
+ MOZ_ASSERT(false, "Unknown MediaType");
+ return os << "?";
+}
+
+inline std::ostream& operator<<(std::ostream& os, SdpMediaSection::Protocol p)
+{
+ switch (p) {
+ case SdpMediaSection::kRtpAvp:
+ return os << "RTP/AVP";
+ case SdpMediaSection::kUdp:
+ return os << "udp";
+ case SdpMediaSection::kVat:
+ return os << "vat";
+ case SdpMediaSection::kRtp:
+ return os << "rtp";
+ case SdpMediaSection::kUdptl:
+ return os << "udptl";
+ case SdpMediaSection::kTcp:
+ return os << "TCP";
+ case SdpMediaSection::kRtpAvpf:
+ return os << "RTP/AVPF";
+ case SdpMediaSection::kTcpRtpAvp:
+ return os << "TCP/RTP/AVP";
+ case SdpMediaSection::kRtpSavp:
+ return os << "RTP/SAVP";
+ case SdpMediaSection::kTcpBfcp:
+ return os << "TCP/BFCP";
+ case SdpMediaSection::kTcpTlsBfcp:
+ return os << "TCP/TLS/BFCP";
+ case SdpMediaSection::kTcpTls:
+ return os << "TCP/TLS";
+ case SdpMediaSection::kFluteUdp:
+ return os << "FLUTE/UDP";
+ case SdpMediaSection::kTcpMsrp:
+ return os << "TCP/MSRP";
+ case SdpMediaSection::kTcpTlsMsrp:
+ return os << "TCP/TLS/MSRP";
+ case SdpMediaSection::kDccp:
+ return os << "DCCP";
+ case SdpMediaSection::kDccpRtpAvp:
+ return os << "DCCP/RTP/AVP";
+ case SdpMediaSection::kDccpRtpSavp:
+ return os << "DCCP/RTP/SAVP";
+ case SdpMediaSection::kDccpRtpAvpf:
+ return os << "DCCP/RTP/AVPF";
+ case SdpMediaSection::kDccpRtpSavpf:
+ return os << "DCCP/RTP/SAVPF";
+ case SdpMediaSection::kRtpSavpf:
+ return os << "RTP/SAVPF";
+ case SdpMediaSection::kUdpTlsRtpSavp:
+ return os << "UDP/TLS/RTP/SAVP";
+ case SdpMediaSection::kTcpTlsRtpSavp:
+ return os << "TCP/TLS/RTP/SAVP";
+ case SdpMediaSection::kDccpTlsRtpSavp:
+ return os << "DCCP/TLS/RTP/SAVP";
+ case SdpMediaSection::kUdpTlsRtpSavpf:
+ return os << "UDP/TLS/RTP/SAVPF";
+ case SdpMediaSection::kTcpTlsRtpSavpf:
+ return os << "TCP/TLS/RTP/SAVPF";
+ case SdpMediaSection::kDccpTlsRtpSavpf:
+ return os << "DCCP/TLS/RTP/SAVPF";
+ case SdpMediaSection::kUdpMbmsFecRtpAvp:
+ return os << "UDP/MBMS-FEC/RTP/AVP";
+ case SdpMediaSection::kUdpMbmsFecRtpSavp:
+ return os << "UDP/MBMS-FEC/RTP/SAVP";
+ case SdpMediaSection::kUdpMbmsRepair:
+ return os << "UDP/MBMS-REPAIR";
+ case SdpMediaSection::kFecUdp:
+ return os << "FEC/UDP";
+ case SdpMediaSection::kUdpFec:
+ return os << "UDP/FEC";
+ case SdpMediaSection::kTcpMrcpv2:
+ return os << "TCP/MRCPv2";
+ case SdpMediaSection::kTcpTlsMrcpv2:
+ return os << "TCP/TLS/MRCPv2";
+ case SdpMediaSection::kPstn:
+ return os << "PSTN";
+ case SdpMediaSection::kUdpTlsUdptl:
+ return os << "UDP/TLS/UDPTL";
+ case SdpMediaSection::kSctp:
+ return os << "SCTP";
+ case SdpMediaSection::kSctpDtls:
+ return os << "SCTP/DTLS";
+ case SdpMediaSection::kDtlsSctp:
+ return os << "DTLS/SCTP";
+ }
+ MOZ_ASSERT(false, "Unknown Protocol");
+ return os << "?";
+}
+
+class SdpConnection
+{
+public:
+ SdpConnection(sdp::AddrType addrType, std::string addr, uint8_t ttl = 0,
+ uint32_t count = 0)
+ : mAddrType(addrType), mAddr(addr), mTtl(ttl), mCount(count)
+ {
+ }
+ ~SdpConnection() {}
+
+ sdp::AddrType
+ GetAddrType() const
+ {
+ return mAddrType;
+ }
+ const std::string&
+ GetAddress() const
+ {
+ return mAddr;
+ }
+ void
+ SetAddress(const std::string& address)
+ {
+ mAddr = address;
+ if (mAddr.find(':') != std::string::npos) {
+ mAddrType = sdp::kIPv6;
+ } else {
+ mAddrType = sdp::kIPv4;
+ }
+ }
+ uint8_t
+ GetTtl() const
+ {
+ return mTtl;
+ }
+ uint32_t
+ GetCount() const
+ {
+ return mCount;
+ }
+
+ void
+ Serialize(std::ostream& os) const
+ {
+ sdp::NetType netType = sdp::kInternet;
+
+ os << "c=" << netType << " " << mAddrType << " " << mAddr;
+
+ if (mTtl) {
+ os << "/" << static_cast<uint32_t>(mTtl);
+ if (mCount) {
+ os << "/" << mCount;
+ }
+ }
+ os << "\r\n";
+ }
+
+private:
+ sdp::AddrType mAddrType;
+ std::string mAddr;
+ uint8_t mTtl; // 0-255; 0 when unset
+ uint32_t mCount; // 0 when unset
+};
+
+inline std::ostream& operator<<(std::ostream& os, const SdpConnection& c)
+{
+ c.Serialize(os);
+ return os;
+}
+
+} // namespace mozilla
+
+#endif
diff --git a/media/webrtc/signaling/src/sdp/SipccSdp.cpp b/media/webrtc/signaling/src/sdp/SipccSdp.cpp
new file mode 100644
index 000000000..c23fcf7e9
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/SipccSdp.cpp
@@ -0,0 +1,180 @@
+/* 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 "signaling/src/sdp/SipccSdp.h"
+
+#include <cstdlib>
+#include "mozilla/UniquePtr.h"
+#include "mozilla/Assertions.h"
+#include "signaling/src/sdp/SdpErrorHolder.h"
+
+#ifdef CRLF
+#undef CRLF
+#endif
+#define CRLF "\r\n"
+
+namespace mozilla
+{
+
+const SdpOrigin&
+SipccSdp::GetOrigin() const
+{
+ return mOrigin;
+}
+
+uint32_t
+SipccSdp::GetBandwidth(const std::string& type) const
+{
+ auto found = mBandwidths.find(type);
+ if (found == mBandwidths.end()) {
+ return 0;
+ }
+ return found->second;
+}
+
+const SdpMediaSection&
+SipccSdp::GetMediaSection(size_t level) const
+{
+ if (level > mMediaSections.values.size()) {
+ MOZ_CRASH();
+ }
+ return *mMediaSections.values[level];
+}
+
+SdpMediaSection&
+SipccSdp::GetMediaSection(size_t level)
+{
+ if (level > mMediaSections.values.size()) {
+ MOZ_CRASH();
+ }
+ return *mMediaSections.values[level];
+}
+
+SdpMediaSection&
+SipccSdp::AddMediaSection(SdpMediaSection::MediaType mediaType,
+ SdpDirectionAttribute::Direction dir, uint16_t port,
+ SdpMediaSection::Protocol protocol,
+ sdp::AddrType addrType, const std::string& addr)
+{
+ size_t level = mMediaSections.values.size();
+ SipccSdpMediaSection* media =
+ new SipccSdpMediaSection(level, &mAttributeList);
+ media->mMediaType = mediaType;
+ media->mPort = port;
+ media->mPortCount = 0;
+ media->mProtocol = protocol;
+ media->mConnection = MakeUnique<SdpConnection>(addrType, addr);
+ media->GetAttributeList().SetAttribute(new SdpDirectionAttribute(dir));
+ mMediaSections.values.push_back(media);
+ return *media;
+}
+
+bool
+SipccSdp::LoadOrigin(sdp_t* sdp, SdpErrorHolder& errorHolder)
+{
+ std::string username = sdp_get_owner_username(sdp);
+ uint64_t sessId = strtoull(sdp_get_owner_sessionid(sdp), nullptr, 10);
+ uint64_t sessVer = strtoull(sdp_get_owner_version(sdp), nullptr, 10);
+
+ sdp_nettype_e type = sdp_get_owner_network_type(sdp);
+ if (type != SDP_NT_INTERNET) {
+ errorHolder.AddParseError(2, "Unsupported network type");
+ return false;
+ }
+
+ sdp::AddrType addrType;
+ switch (sdp_get_owner_address_type(sdp)) {
+ case SDP_AT_IP4:
+ addrType = sdp::kIPv4;
+ break;
+ case SDP_AT_IP6:
+ addrType = sdp::kIPv6;
+ break;
+ default:
+ errorHolder.AddParseError(2, "Unsupported address type");
+ return false;
+ }
+
+ std::string address = sdp_get_owner_address(sdp);
+ mOrigin = SdpOrigin(username, sessId, sessVer, addrType, address);
+ return true;
+}
+
+bool
+SipccSdp::Load(sdp_t* sdp, SdpErrorHolder& errorHolder)
+{
+ // Believe it or not, SDP_SESSION_LEVEL is 0xFFFF
+ if (!mAttributeList.Load(sdp, SDP_SESSION_LEVEL, errorHolder)) {
+ return false;
+ }
+
+ if (!LoadOrigin(sdp, errorHolder)) {
+ return false;
+ }
+
+ if (!mBandwidths.Load(sdp, SDP_SESSION_LEVEL, errorHolder)) {
+ return false;
+ }
+
+ for (int i = 0; i < sdp_get_num_media_lines(sdp); ++i) {
+ // note that we pass a "level" here that is one higher
+ // sipcc counts media sections from 1, using 0xFFFF as the "session"
+ UniquePtr<SipccSdpMediaSection> section(
+ new SipccSdpMediaSection(i, &mAttributeList));
+ if (!section->Load(sdp, i + 1, errorHolder)) {
+ return false;
+ }
+ mMediaSections.values.push_back(section.release());
+ }
+ return true;
+}
+
+void
+SipccSdp::Serialize(std::ostream& os) const
+{
+ os << "v=0" << CRLF << mOrigin << "s=-" << CRLF;
+
+ // We don't support creating i=, u=, e=, p=
+ // We don't generate c= at the session level (only in media)
+
+ mBandwidths.Serialize(os);
+ os << "t=0 0" << CRLF;
+
+ // We don't support r= or z=
+
+ // attributes
+ os << mAttributeList;
+
+ // media sections
+ for (const SdpMediaSection* msection : mMediaSections.values) {
+ os << *msection;
+ }
+}
+
+bool
+SipccSdpBandwidths::Load(sdp_t* sdp, uint16_t level,
+ SdpErrorHolder& errorHolder)
+{
+ size_t count = sdp_get_num_bw_lines(sdp, level);
+ for (size_t i = 1; i <= count; ++i) {
+ sdp_bw_modifier_e bwtype = sdp_get_bw_modifier(sdp, level, i);
+ uint32_t bandwidth = sdp_get_bw_value(sdp, level, i);
+ if (bwtype != SDP_BW_MODIFIER_UNSUPPORTED) {
+ const char* typeName = sdp_get_bw_modifier_name(bwtype);
+ (*this)[typeName] = bandwidth;
+ }
+ }
+
+ return true;
+}
+
+void
+SipccSdpBandwidths::Serialize(std::ostream& os) const
+{
+ for (auto i = begin(); i != end(); ++i) {
+ os << "b=" << i->first << ":" << i->second << CRLF;
+ }
+}
+
+} // namespace mozilla
diff --git a/media/webrtc/signaling/src/sdp/SipccSdp.h b/media/webrtc/signaling/src/sdp/SipccSdp.h
new file mode 100644
index 000000000..04ef202ab
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/SipccSdp.h
@@ -0,0 +1,88 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef _SIPCCSDP_H_
+#define _SIPCCSDP_H_
+
+#include <map>
+#include <vector>
+#include "mozilla/Attributes.h"
+
+#include "signaling/src/sdp/Sdp.h"
+#include "signaling/src/sdp/SipccSdpMediaSection.h"
+#include "signaling/src/sdp/SipccSdpAttributeList.h"
+extern "C" {
+#include "signaling/src/sdp/sipcc/sdp.h"
+}
+
+#include "signaling/src/common/PtrVector.h"
+
+namespace mozilla
+{
+
+class SipccSdpParser;
+class SdpErrorHolder;
+
+class SipccSdp final : public Sdp
+{
+ friend class SipccSdpParser;
+
+public:
+ explicit SipccSdp(const SdpOrigin& origin)
+ : mOrigin(origin), mAttributeList(nullptr)
+ {
+ }
+
+ virtual const SdpOrigin& GetOrigin() const override;
+
+ // Note: connection information is always retrieved from media sections
+ virtual uint32_t GetBandwidth(const std::string& type) const override;
+
+ virtual size_t
+ GetMediaSectionCount() const override
+ {
+ return mMediaSections.values.size();
+ }
+
+ virtual const SdpAttributeList&
+ GetAttributeList() const override
+ {
+ return mAttributeList;
+ }
+
+ virtual SdpAttributeList&
+ GetAttributeList() override
+ {
+ return mAttributeList;
+ }
+
+ virtual const SdpMediaSection& GetMediaSection(size_t level) const
+ override;
+
+ virtual SdpMediaSection& GetMediaSection(size_t level) override;
+
+ virtual SdpMediaSection& AddMediaSection(
+ SdpMediaSection::MediaType media, SdpDirectionAttribute::Direction dir,
+ uint16_t port, SdpMediaSection::Protocol proto, sdp::AddrType addrType,
+ const std::string& addr) override;
+
+ virtual void Serialize(std::ostream&) const override;
+
+private:
+ SipccSdp() : mOrigin("", 0, 0, sdp::kIPv4, ""), mAttributeList(nullptr) {}
+
+ bool Load(sdp_t* sdp, SdpErrorHolder& errorHolder);
+ bool LoadOrigin(sdp_t* sdp, SdpErrorHolder& errorHolder);
+
+ SdpOrigin mOrigin;
+ SipccSdpBandwidths mBandwidths;
+ SipccSdpAttributeList mAttributeList;
+ PtrVector<SipccSdpMediaSection> mMediaSections;
+};
+
+} // namespace mozilla
+
+#endif // _sdp_h_
diff --git a/media/webrtc/signaling/src/sdp/SipccSdpAttributeList.cpp b/media/webrtc/signaling/src/sdp/SipccSdpAttributeList.cpp
new file mode 100644
index 000000000..5357f4728
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/SipccSdpAttributeList.cpp
@@ -0,0 +1,1413 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* 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 "signaling/src/sdp/SipccSdpAttributeList.h"
+
+#include <ostream>
+#include "mozilla/Assertions.h"
+#include "signaling/src/sdp/SdpErrorHolder.h"
+
+extern "C" {
+#include "signaling/src/sdp/sipcc/sdp_private.h"
+}
+
+namespace mozilla
+{
+
+/* static */ const std::string SipccSdpAttributeList::kEmptyString = "";
+
+SipccSdpAttributeList::SipccSdpAttributeList(
+ const SipccSdpAttributeList* sessionLevel)
+ : mSessionLevel(sessionLevel)
+{
+ memset(&mAttributes, 0, sizeof(mAttributes));
+}
+
+SipccSdpAttributeList::~SipccSdpAttributeList()
+{
+ for (size_t i = 0; i < kNumAttributeTypes; ++i) {
+ delete mAttributes[i];
+ }
+}
+
+bool
+SipccSdpAttributeList::HasAttribute(AttributeType type,
+ bool sessionFallback) const
+{
+ return !!GetAttribute(type, sessionFallback);
+}
+
+const SdpAttribute*
+SipccSdpAttributeList::GetAttribute(AttributeType type,
+ bool sessionFallback) const
+{
+ const SdpAttribute* value = mAttributes[static_cast<size_t>(type)];
+ // Only do fallback when the attribute can appear at both the media and
+ // session level
+ if (!value && !AtSessionLevel() && sessionFallback &&
+ SdpAttribute::IsAllowedAtSessionLevel(type) &&
+ SdpAttribute::IsAllowedAtMediaLevel(type)) {
+ return mSessionLevel->GetAttribute(type, false);
+ }
+ return value;
+}
+
+void
+SipccSdpAttributeList::RemoveAttribute(AttributeType type)
+{
+ delete mAttributes[static_cast<size_t>(type)];
+ mAttributes[static_cast<size_t>(type)] = nullptr;
+}
+
+void
+SipccSdpAttributeList::Clear()
+{
+ for (size_t i = 0; i < kNumAttributeTypes; ++i) {
+ RemoveAttribute(static_cast<AttributeType>(i));
+ }
+}
+
+void
+SipccSdpAttributeList::SetAttribute(SdpAttribute* attr)
+{
+ if (!IsAllowedHere(attr->GetType())) {
+ MOZ_ASSERT(false, "This type of attribute is not allowed here");
+ return;
+ }
+ RemoveAttribute(attr->GetType());
+ mAttributes[attr->GetType()] = attr;
+}
+
+void
+SipccSdpAttributeList::LoadSimpleString(sdp_t* sdp, uint16_t level,
+ sdp_attr_e attr,
+ AttributeType targetType,
+ SdpErrorHolder& errorHolder)
+{
+ const char* value = sdp_attr_get_simple_string(sdp, attr, level, 0, 1);
+ if (value) {
+ if (!IsAllowedHere(targetType)) {
+ uint32_t lineNumber = sdp_attr_line_number(sdp, attr, level, 0, 1);
+ WarnAboutMisplacedAttribute(targetType, lineNumber, errorHolder);
+ } else {
+ SetAttribute(new SdpStringAttribute(targetType, std::string(value)));
+ }
+ }
+}
+
+void
+SipccSdpAttributeList::LoadSimpleStrings(sdp_t* sdp, uint16_t level,
+ SdpErrorHolder& errorHolder)
+{
+ LoadSimpleString(sdp, level, SDP_ATTR_MID, SdpAttribute::kMidAttribute,
+ errorHolder);
+ LoadSimpleString(sdp, level, SDP_ATTR_LABEL, SdpAttribute::kLabelAttribute,
+ errorHolder);
+}
+
+void
+SipccSdpAttributeList::LoadSimpleNumber(sdp_t* sdp, uint16_t level,
+ sdp_attr_e attr,
+ AttributeType targetType,
+ SdpErrorHolder& errorHolder)
+{
+ if (sdp_attr_valid(sdp, attr, level, 0, 1)) {
+ if (!IsAllowedHere(targetType)) {
+ uint32_t lineNumber = sdp_attr_line_number(sdp, attr, level, 0, 1);
+ WarnAboutMisplacedAttribute(targetType, lineNumber, errorHolder);
+ } else {
+ uint32_t value = sdp_attr_get_simple_u32(sdp, attr, level, 0, 1);
+ SetAttribute(new SdpNumberAttribute(targetType, value));
+ }
+ }
+}
+
+void
+SipccSdpAttributeList::LoadSimpleNumbers(sdp_t* sdp, uint16_t level,
+ SdpErrorHolder& errorHolder)
+{
+ LoadSimpleNumber(sdp, level, SDP_ATTR_PTIME, SdpAttribute::kPtimeAttribute,
+ errorHolder);
+ LoadSimpleNumber(sdp, level, SDP_ATTR_MAXPTIME,
+ SdpAttribute::kMaxptimeAttribute, errorHolder);
+}
+
+void
+SipccSdpAttributeList::LoadFlags(sdp_t* sdp, uint16_t level)
+{
+ if (AtSessionLevel()) {
+ if (sdp_attr_valid(sdp, SDP_ATTR_ICE_LITE, level, 0, 1)) {
+ SetAttribute(new SdpFlagAttribute(SdpAttribute::kIceLiteAttribute));
+ }
+ } else { // media-level
+ if (sdp_attr_valid(sdp, SDP_ATTR_RTCP_MUX, level, 0, 1)) {
+ SetAttribute(new SdpFlagAttribute(SdpAttribute::kRtcpMuxAttribute));
+ }
+ if (sdp_attr_valid(sdp, SDP_ATTR_END_OF_CANDIDATES, level, 0, 1)) {
+ SetAttribute(
+ new SdpFlagAttribute(SdpAttribute::kEndOfCandidatesAttribute));
+ }
+ if (sdp_attr_valid(sdp, SDP_ATTR_BUNDLE_ONLY, level, 0, 1)) {
+ SetAttribute(new SdpFlagAttribute(SdpAttribute::kBundleOnlyAttribute));
+ }
+ }
+}
+
+static void
+ConvertDirection(sdp_direction_e sipcc_direction,
+ SdpDirectionAttribute::Direction* dir_outparam)
+{
+ switch (sipcc_direction) {
+ case SDP_DIRECTION_SENDRECV:
+ *dir_outparam = SdpDirectionAttribute::kSendrecv;
+ return;
+ case SDP_DIRECTION_SENDONLY:
+ *dir_outparam = SdpDirectionAttribute::kSendonly;
+ return;
+ case SDP_DIRECTION_RECVONLY:
+ *dir_outparam = SdpDirectionAttribute::kRecvonly;
+ return;
+ case SDP_DIRECTION_INACTIVE:
+ *dir_outparam = SdpDirectionAttribute::kInactive;
+ return;
+ case SDP_MAX_QOS_DIRECTIONS:
+ // Nothing actually sets this value.
+ // Fall through to MOZ_CRASH below.
+ {
+ }
+ }
+
+ MOZ_CRASH("Invalid direction from sipcc; this is probably corruption");
+}
+
+void
+SipccSdpAttributeList::LoadDirection(sdp_t* sdp, uint16_t level,
+ SdpErrorHolder& errorHolder)
+{
+ SdpDirectionAttribute::Direction dir;
+ ConvertDirection(sdp_get_media_direction(sdp, level, 0), &dir);
+ SetAttribute(new SdpDirectionAttribute(dir));
+}
+
+void
+SipccSdpAttributeList::LoadIceAttributes(sdp_t* sdp, uint16_t level)
+{
+ char* value;
+ sdp_result_e sdpres =
+ sdp_attr_get_ice_attribute(sdp, level, 0, SDP_ATTR_ICE_UFRAG, 1, &value);
+ if (sdpres == SDP_SUCCESS) {
+ SetAttribute(new SdpStringAttribute(SdpAttribute::kIceUfragAttribute,
+ std::string(value)));
+ }
+ sdpres =
+ sdp_attr_get_ice_attribute(sdp, level, 0, SDP_ATTR_ICE_PWD, 1, &value);
+ if (sdpres == SDP_SUCCESS) {
+ SetAttribute(new SdpStringAttribute(SdpAttribute::kIcePwdAttribute,
+ std::string(value)));
+ }
+
+ const char* iceOptVal =
+ sdp_attr_get_simple_string(sdp, SDP_ATTR_ICE_OPTIONS, level, 0, 1);
+ if (iceOptVal) {
+ auto* iceOptions =
+ new SdpOptionsAttribute(SdpAttribute::kIceOptionsAttribute);
+ iceOptions->Load(iceOptVal);
+ SetAttribute(iceOptions);
+ }
+}
+
+bool
+SipccSdpAttributeList::LoadFingerprint(sdp_t* sdp, uint16_t level,
+ SdpErrorHolder& errorHolder)
+{
+ char* value;
+ UniquePtr<SdpFingerprintAttributeList> fingerprintAttrs;
+
+ for (uint16_t i = 1; i < UINT16_MAX; ++i) {
+ sdp_result_e result = sdp_attr_get_dtls_fingerprint_attribute(
+ sdp, level, 0, SDP_ATTR_DTLS_FINGERPRINT, i, &value);
+
+ if (result != SDP_SUCCESS) {
+ break;
+ }
+
+ std::string fingerprintAttr(value);
+ uint32_t lineNumber =
+ sdp_attr_line_number(sdp, SDP_ATTR_DTLS_FINGERPRINT, level, 0, i);
+
+ // sipcc does not expose parse code for this
+ size_t start = fingerprintAttr.find_first_not_of(" \t");
+ if (start == std::string::npos) {
+ errorHolder.AddParseError(lineNumber, "Empty fingerprint attribute");
+ return false;
+ }
+
+ size_t end = fingerprintAttr.find_first_of(" \t", start);
+ if (end == std::string::npos) {
+ // One token, no trailing ws
+ errorHolder.AddParseError(lineNumber,
+ "Only one token in fingerprint attribute");
+ return false;
+ }
+
+ std::string algorithmToken(fingerprintAttr.substr(start, end - start));
+
+ start = fingerprintAttr.find_first_not_of(" \t", end);
+ if (start == std::string::npos) {
+ // One token, trailing ws
+ errorHolder.AddParseError(lineNumber,
+ "Only one token in fingerprint attribute");
+ return false;
+ }
+
+ std::string fingerprintToken(fingerprintAttr.substr(start));
+
+ std::vector<uint8_t> fingerprint =
+ SdpFingerprintAttributeList::ParseFingerprint(fingerprintToken);
+ if (fingerprint.size() == 0) {
+ errorHolder.AddParseError(lineNumber, "Malformed fingerprint token");
+ return false;
+ }
+
+ if (!fingerprintAttrs) {
+ fingerprintAttrs.reset(new SdpFingerprintAttributeList);
+ }
+
+ // Don't assert on unknown algorithm, just skip
+ fingerprintAttrs->PushEntry(algorithmToken, fingerprint, false);
+ }
+
+ if (fingerprintAttrs) {
+ SetAttribute(fingerprintAttrs.release());
+ }
+
+ return true;
+}
+
+void
+SipccSdpAttributeList::LoadCandidate(sdp_t* sdp, uint16_t level)
+{
+ char* value;
+ auto candidates =
+ MakeUnique<SdpMultiStringAttribute>(SdpAttribute::kCandidateAttribute);
+
+ for (uint16_t i = 1; i < UINT16_MAX; ++i) {
+ sdp_result_e result = sdp_attr_get_ice_attribute(
+ sdp, level, 0, SDP_ATTR_ICE_CANDIDATE, i, &value);
+
+ if (result != SDP_SUCCESS) {
+ break;
+ }
+
+ candidates->mValues.push_back(value);
+ }
+
+ if (!candidates->mValues.empty()) {
+ SetAttribute(candidates.release());
+ }
+}
+
+bool
+SipccSdpAttributeList::LoadSctpmap(sdp_t* sdp, uint16_t level,
+ SdpErrorHolder& errorHolder)
+{
+ auto sctpmap = MakeUnique<SdpSctpmapAttributeList>();
+ for (uint16_t i = 0; i < UINT16_MAX; ++i) {
+ sdp_attr_t* attr = sdp_find_attr(sdp, level, 0, SDP_ATTR_SCTPMAP, i + 1);
+
+ if (!attr) {
+ break;
+ }
+
+ // Yeah, this is a little weird, but for now we'll just store this as a
+ // payload type.
+ uint16_t payloadType = attr->attr.sctpmap.port;
+ uint16_t streams = attr->attr.sctpmap.streams;
+ const char* name = attr->attr.sctpmap.protocol;
+
+ std::ostringstream osPayloadType;
+ osPayloadType << payloadType;
+ sctpmap->PushEntry(osPayloadType.str(), name, streams);
+ }
+
+ if (!sctpmap->mSctpmaps.empty()) {
+ SetAttribute(sctpmap.release());
+ }
+
+ return true;
+}
+
+SdpRtpmapAttributeList::CodecType
+SipccSdpAttributeList::GetCodecType(rtp_ptype type)
+{
+ switch (type) {
+ case RTP_PCMU:
+ return SdpRtpmapAttributeList::kPCMU;
+ case RTP_PCMA:
+ return SdpRtpmapAttributeList::kPCMA;
+ case RTP_G722:
+ return SdpRtpmapAttributeList::kG722;
+ case RTP_H264_P0:
+ case RTP_H264_P1:
+ return SdpRtpmapAttributeList::kH264;
+ case RTP_OPUS:
+ return SdpRtpmapAttributeList::kOpus;
+ case RTP_VP8:
+ return SdpRtpmapAttributeList::kVP8;
+ case RTP_VP9:
+ return SdpRtpmapAttributeList::kVP9;
+ case RTP_RED:
+ return SdpRtpmapAttributeList::kRed;
+ case RTP_ULPFEC:
+ return SdpRtpmapAttributeList::kUlpfec;
+ case RTP_TELEPHONE_EVENT:
+ return SdpRtpmapAttributeList::kTelephoneEvent;
+ case RTP_NONE:
+ // Happens when sipcc doesn't know how to translate to the enum
+ case RTP_CELP:
+ case RTP_G726:
+ case RTP_GSM:
+ case RTP_G723:
+ case RTP_DVI4:
+ case RTP_DVI4_II:
+ case RTP_LPC:
+ case RTP_G728:
+ case RTP_G729:
+ case RTP_JPEG:
+ case RTP_NV:
+ case RTP_H261:
+ case RTP_L16:
+ case RTP_H263:
+ case RTP_ILBC:
+ case RTP_I420:
+ return SdpRtpmapAttributeList::kOtherCodec;
+ }
+ MOZ_CRASH("Invalid codec type from sipcc. Probably corruption.");
+}
+
+bool
+SipccSdpAttributeList::LoadRtpmap(sdp_t* sdp, uint16_t level,
+ SdpErrorHolder& errorHolder)
+{
+ auto rtpmap = MakeUnique<SdpRtpmapAttributeList>();
+ uint16_t count;
+ sdp_result_e result =
+ sdp_attr_num_instances(sdp, level, 0, SDP_ATTR_RTPMAP, &count);
+ if (result != SDP_SUCCESS) {
+ MOZ_ASSERT(false, "Unable to get rtpmap size");
+ errorHolder.AddParseError(sdp_get_media_line_number(sdp, level),
+ "Unable to get rtpmap size");
+ return false;
+ }
+ for (uint16_t i = 0; i < count; ++i) {
+ uint16_t pt = sdp_attr_get_rtpmap_payload_type(sdp, level, 0, i + 1);
+ const char* ccName = sdp_attr_get_rtpmap_encname(sdp, level, 0, i + 1);
+
+ if (!ccName) {
+ // Probably no rtpmap attribute for a pt in an m-line
+ errorHolder.AddParseError(sdp_get_media_line_number(sdp, level),
+ "No rtpmap attribute for payload type");
+ continue;
+ }
+
+ std::string name(ccName);
+
+ SdpRtpmapAttributeList::CodecType codec =
+ GetCodecType(sdp_get_known_payload_type(sdp, level, pt));
+
+ uint32_t clock = sdp_attr_get_rtpmap_clockrate(sdp, level, 0, i + 1);
+ uint16_t channels = 0;
+
+ // sipcc gives us a channels value of "1" for video
+ if (sdp_get_media_type(sdp, level) == SDP_MEDIA_AUDIO) {
+ channels = sdp_attr_get_rtpmap_num_chan(sdp, level, 0, i + 1);
+ }
+
+ std::ostringstream osPayloadType;
+ osPayloadType << pt;
+ rtpmap->PushEntry(osPayloadType.str(), codec, name, clock, channels);
+ }
+
+ if (!rtpmap->mRtpmaps.empty()) {
+ SetAttribute(rtpmap.release());
+ }
+
+ return true;
+}
+
+void
+SipccSdpAttributeList::LoadSetup(sdp_t* sdp, uint16_t level)
+{
+ sdp_setup_type_e setupType;
+ auto sdpres = sdp_attr_get_setup_attribute(sdp, level, 0, 1, &setupType);
+
+ if (sdpres != SDP_SUCCESS) {
+ return;
+ }
+
+ switch (setupType) {
+ case SDP_SETUP_ACTIVE:
+ SetAttribute(new SdpSetupAttribute(SdpSetupAttribute::kActive));
+ return;
+ case SDP_SETUP_PASSIVE:
+ SetAttribute(new SdpSetupAttribute(SdpSetupAttribute::kPassive));
+ return;
+ case SDP_SETUP_ACTPASS:
+ SetAttribute(new SdpSetupAttribute(SdpSetupAttribute::kActpass));
+ return;
+ case SDP_SETUP_HOLDCONN:
+ SetAttribute(new SdpSetupAttribute(SdpSetupAttribute::kHoldconn));
+ return;
+ case SDP_SETUP_UNKNOWN:
+ return;
+ case SDP_SETUP_NOT_FOUND:
+ case SDP_MAX_SETUP:
+ // There is no code that will set these.
+ // Fall through to MOZ_CRASH() below.
+ {
+ }
+ }
+
+ MOZ_CRASH("Invalid setup type from sipcc. This is probably corruption.");
+}
+
+void
+SipccSdpAttributeList::LoadSsrc(sdp_t* sdp, uint16_t level)
+{
+ auto ssrcs = MakeUnique<SdpSsrcAttributeList>();
+
+ for (uint16_t i = 1; i < UINT16_MAX; ++i) {
+ sdp_attr_t* attr = sdp_find_attr(sdp, level, 0, SDP_ATTR_SSRC, i);
+
+ if (!attr) {
+ break;
+ }
+
+ sdp_ssrc_t* ssrc = &(attr->attr.ssrc);
+ ssrcs->PushEntry(ssrc->ssrc, ssrc->attribute);
+ }
+
+ if (!ssrcs->mSsrcs.empty()) {
+ SetAttribute(ssrcs.release());
+ }
+}
+
+bool
+SipccSdpAttributeList::LoadImageattr(sdp_t* sdp,
+ uint16_t level,
+ SdpErrorHolder& errorHolder)
+{
+ UniquePtr<SdpImageattrAttributeList> imageattrs(
+ new SdpImageattrAttributeList);
+
+ for (uint16_t i = 1; i < UINT16_MAX; ++i) {
+ const char* imageattrRaw = sdp_attr_get_simple_string(sdp,
+ SDP_ATTR_IMAGEATTR,
+ level,
+ 0,
+ i);
+ if (!imageattrRaw) {
+ break;
+ }
+
+ std::string error;
+ size_t errorPos;
+ if (!imageattrs->PushEntry(imageattrRaw, &error, &errorPos)) {
+ std::ostringstream fullError;
+ fullError << error << " at column " << errorPos;
+ errorHolder.AddParseError(
+ sdp_attr_line_number(sdp, SDP_ATTR_IMAGEATTR, level, 0, i),
+ fullError.str());
+ return false;
+ }
+ }
+
+ if (!imageattrs->mImageattrs.empty()) {
+ SetAttribute(imageattrs.release());
+ }
+ return true;
+}
+
+bool
+SipccSdpAttributeList::LoadSimulcast(sdp_t* sdp,
+ uint16_t level,
+ SdpErrorHolder& errorHolder)
+{
+ const char* simulcastRaw = sdp_attr_get_simple_string(sdp,
+ SDP_ATTR_SIMULCAST,
+ level,
+ 0,
+ 1);
+ if (!simulcastRaw) {
+ return true;
+ }
+
+ UniquePtr<SdpSimulcastAttribute> simulcast(
+ new SdpSimulcastAttribute);
+
+ std::istringstream is(simulcastRaw);
+ std::string error;
+ if (!simulcast->Parse(is, &error)) {
+ std::ostringstream fullError;
+ fullError << error << " at column " << is.tellg();
+ errorHolder.AddParseError(
+ sdp_attr_line_number(sdp, SDP_ATTR_SIMULCAST, level, 0, 1),
+ fullError.str());
+ return false;
+ }
+
+ SetAttribute(simulcast.release());
+ return true;
+}
+
+bool
+SipccSdpAttributeList::LoadGroups(sdp_t* sdp, uint16_t level,
+ SdpErrorHolder& errorHolder)
+{
+ uint16_t attrCount = 0;
+ if (sdp_attr_num_instances(sdp, level, 0, SDP_ATTR_GROUP, &attrCount) !=
+ SDP_SUCCESS) {
+ MOZ_ASSERT(false, "Could not get count of group attributes");
+ errorHolder.AddParseError(0, "Could not get count of group attributes");
+ return false;
+ }
+
+ UniquePtr<SdpGroupAttributeList> groups = MakeUnique<SdpGroupAttributeList>();
+ for (uint16_t attr = 1; attr <= attrCount; ++attr) {
+ SdpGroupAttributeList::Semantics semantics;
+ std::vector<std::string> tags;
+
+ switch (sdp_get_group_attr(sdp, level, 0, attr)) {
+ case SDP_GROUP_ATTR_FID:
+ semantics = SdpGroupAttributeList::kFid;
+ break;
+ case SDP_GROUP_ATTR_LS:
+ semantics = SdpGroupAttributeList::kLs;
+ break;
+ case SDP_GROUP_ATTR_ANAT:
+ semantics = SdpGroupAttributeList::kAnat;
+ break;
+ case SDP_GROUP_ATTR_BUNDLE:
+ semantics = SdpGroupAttributeList::kBundle;
+ break;
+ default:
+ continue;
+ }
+
+ uint16_t idCount = sdp_get_group_num_id(sdp, level, 0, attr);
+ for (uint16_t id = 1; id <= idCount; ++id) {
+ const char* idStr = sdp_get_group_id(sdp, level, 0, attr, id);
+ if (!idStr) {
+ std::ostringstream os;
+ os << "bad a=group identifier at " << (attr - 1) << ", " << (id - 1);
+ errorHolder.AddParseError(0, os.str());
+ return false;
+ }
+ tags.push_back(std::string(idStr));
+ }
+ groups->PushEntry(semantics, tags);
+ }
+
+ if (!groups->mGroups.empty()) {
+ SetAttribute(groups.release());
+ }
+
+ return true;
+}
+
+bool
+SipccSdpAttributeList::LoadMsidSemantics(sdp_t* sdp, uint16_t level,
+ SdpErrorHolder& errorHolder)
+{
+ auto msidSemantics = MakeUnique<SdpMsidSemanticAttributeList>();
+
+ for (uint16_t i = 1; i < UINT16_MAX; ++i) {
+ sdp_attr_t* attr = sdp_find_attr(sdp, level, 0, SDP_ATTR_MSID_SEMANTIC, i);
+
+ if (!attr) {
+ break;
+ }
+
+ sdp_msid_semantic_t* msid_semantic = &(attr->attr.msid_semantic);
+ std::vector<std::string> msids;
+ for (size_t i = 0; i < SDP_MAX_MEDIA_STREAMS; ++i) {
+ if (!msid_semantic->msids[i]) {
+ break;
+ }
+
+ msids.push_back(msid_semantic->msids[i]);
+ }
+
+ msidSemantics->PushEntry(msid_semantic->semantic, msids);
+ }
+
+ if (!msidSemantics->mMsidSemantics.empty()) {
+ SetAttribute(msidSemantics.release());
+ }
+ return true;
+}
+
+void
+SipccSdpAttributeList::LoadIdentity(sdp_t* sdp, uint16_t level)
+{
+ const char* val = sdp_attr_get_long_string(sdp, SDP_ATTR_IDENTITY, level, 0, 1);
+ if (val) {
+ SetAttribute(new SdpStringAttribute(SdpAttribute::kIdentityAttribute,
+ std::string(val)));
+ }
+}
+
+void
+SipccSdpAttributeList::LoadDtlsMessage(sdp_t* sdp, uint16_t level)
+{
+ const char* val = sdp_attr_get_long_string(sdp, SDP_ATTR_DTLS_MESSAGE, level,
+ 0, 1);
+ if (val) {
+ // sipcc does not expose parse code for this, so we use a SDParta-provided
+ // parser
+ std::string strval(val);
+ SetAttribute(new SdpDtlsMessageAttribute(strval));
+ }
+}
+
+void
+SipccSdpAttributeList::LoadFmtp(sdp_t* sdp, uint16_t level)
+{
+ auto fmtps = MakeUnique<SdpFmtpAttributeList>();
+
+ for (uint16_t i = 1; i < UINT16_MAX; ++i) {
+ sdp_attr_t* attr = sdp_find_attr(sdp, level, 0, SDP_ATTR_FMTP, i);
+
+ if (!attr) {
+ break;
+ }
+
+ sdp_fmtp_t* fmtp = &(attr->attr.fmtp);
+
+ // Get the payload type
+ std::stringstream osPayloadType;
+ // payload_num is the number in the fmtp attribute, verbatim
+ osPayloadType << fmtp->payload_num;
+
+ // Get parsed form of parameters, if supported
+ UniquePtr<SdpFmtpAttributeList::Parameters> parameters;
+
+ rtp_ptype codec = sdp_get_known_payload_type(sdp, level, fmtp->payload_num);
+
+ switch (codec) {
+ case RTP_H264_P0:
+ case RTP_H264_P1: {
+ SdpFmtpAttributeList::H264Parameters* h264Parameters(
+ new SdpFmtpAttributeList::H264Parameters);
+
+ sstrncpy(h264Parameters->sprop_parameter_sets, fmtp->parameter_sets,
+ sizeof(h264Parameters->sprop_parameter_sets));
+
+ h264Parameters->level_asymmetry_allowed =
+ !!(fmtp->level_asymmetry_allowed);
+
+ h264Parameters->packetization_mode = fmtp->packetization_mode;
+ sscanf(fmtp->profile_level_id, "%x", &h264Parameters->profile_level_id);
+ h264Parameters->max_mbps = fmtp->max_mbps;
+ h264Parameters->max_fs = fmtp->max_fs;
+ h264Parameters->max_cpb = fmtp->max_cpb;
+ h264Parameters->max_dpb = fmtp->max_dpb;
+ h264Parameters->max_br = fmtp->max_br;
+
+ parameters.reset(h264Parameters);
+ } break;
+ case RTP_VP9: {
+ SdpFmtpAttributeList::VP8Parameters* vp9Parameters(
+ new SdpFmtpAttributeList::VP8Parameters(
+ SdpRtpmapAttributeList::kVP9));
+
+ vp9Parameters->max_fs = fmtp->max_fs;
+ vp9Parameters->max_fr = fmtp->max_fr;
+
+ parameters.reset(vp9Parameters);
+ } break;
+ case RTP_VP8: {
+ SdpFmtpAttributeList::VP8Parameters* vp8Parameters(
+ new SdpFmtpAttributeList::VP8Parameters(
+ SdpRtpmapAttributeList::kVP8));
+
+ vp8Parameters->max_fs = fmtp->max_fs;
+ vp8Parameters->max_fr = fmtp->max_fr;
+
+ parameters.reset(vp8Parameters);
+ } break;
+ case RTP_RED: {
+ SdpFmtpAttributeList::RedParameters* redParameters(
+ new SdpFmtpAttributeList::RedParameters);
+ for (int i = 0;
+ i < SDP_FMTP_MAX_REDUNDANT_ENCODINGS && fmtp->redundant_encodings[i];
+ ++i) {
+ redParameters->encodings.push_back(fmtp->redundant_encodings[i]);
+ }
+
+ parameters.reset(redParameters);
+ } break;
+ case RTP_OPUS: {
+ SdpFmtpAttributeList::OpusParameters* opusParameters(
+ new SdpFmtpAttributeList::OpusParameters);
+ opusParameters->maxplaybackrate = fmtp->maxplaybackrate;
+ opusParameters->stereo = fmtp->stereo;
+ opusParameters->useInBandFec = fmtp->useinbandfec;
+ parameters.reset(opusParameters);
+ } break;
+ case RTP_TELEPHONE_EVENT: {
+ SdpFmtpAttributeList::TelephoneEventParameters* teParameters(
+ new SdpFmtpAttributeList::TelephoneEventParameters);
+ if (strlen(fmtp->dtmf_tones) > 0) {
+ teParameters->dtmfTones = fmtp->dtmf_tones;
+ }
+ parameters.reset(teParameters);
+ } break;
+ default: {
+ }
+ }
+
+ fmtps->PushEntry(osPayloadType.str(), Move(parameters));
+ }
+
+ if (!fmtps->mFmtps.empty()) {
+ SetAttribute(fmtps.release());
+ }
+}
+
+void
+SipccSdpAttributeList::LoadMsids(sdp_t* sdp, uint16_t level,
+ SdpErrorHolder& errorHolder)
+{
+ uint16_t attrCount = 0;
+ if (sdp_attr_num_instances(sdp, level, 0, SDP_ATTR_MSID, &attrCount) !=
+ SDP_SUCCESS) {
+ MOZ_ASSERT(false, "Unable to get count of msid attributes");
+ errorHolder.AddParseError(0, "Unable to get count of msid attributes");
+ return;
+ }
+ auto msids = MakeUnique<SdpMsidAttributeList>();
+ for (uint16_t i = 1; i <= attrCount; ++i) {
+ uint32_t lineNumber = sdp_attr_line_number(sdp, SDP_ATTR_MSID, level, 0, i);
+
+ const char* identifier = sdp_attr_get_msid_identifier(sdp, level, 0, i);
+ if (!identifier) {
+ errorHolder.AddParseError(lineNumber, "msid attribute with bad identity");
+ continue;
+ }
+
+ const char* appdata = sdp_attr_get_msid_appdata(sdp, level, 0, i);
+ if (!appdata) {
+ errorHolder.AddParseError(lineNumber, "msid attribute with bad appdata");
+ continue;
+ }
+
+ msids->PushEntry(identifier, appdata);
+ }
+
+ if (!msids->mMsids.empty()) {
+ SetAttribute(msids.release());
+ }
+}
+
+bool
+SipccSdpAttributeList::LoadRid(sdp_t* sdp,
+ uint16_t level,
+ SdpErrorHolder& errorHolder)
+{
+ UniquePtr<SdpRidAttributeList> rids(new SdpRidAttributeList);
+
+ for (uint16_t i = 1; i < UINT16_MAX; ++i) {
+ const char* ridRaw = sdp_attr_get_simple_string(sdp,
+ SDP_ATTR_RID,
+ level,
+ 0,
+ i);
+ if (!ridRaw) {
+ break;
+ }
+
+ std::string error;
+ size_t errorPos;
+ if (!rids->PushEntry(ridRaw, &error, &errorPos)) {
+ std::ostringstream fullError;
+ fullError << error << " at column " << errorPos;
+ errorHolder.AddParseError(
+ sdp_attr_line_number(sdp, SDP_ATTR_RID, level, 0, i),
+ fullError.str());
+ return false;
+ }
+ }
+
+ if (!rids->mRids.empty()) {
+ SetAttribute(rids.release());
+ }
+ return true;
+}
+
+void
+SipccSdpAttributeList::LoadExtmap(sdp_t* sdp, uint16_t level,
+ SdpErrorHolder& errorHolder)
+{
+ auto extmaps = MakeUnique<SdpExtmapAttributeList>();
+
+ for (uint16_t i = 1; i < UINT16_MAX; ++i) {
+ sdp_attr_t* attr = sdp_find_attr(sdp, level, 0, SDP_ATTR_EXTMAP, i);
+
+ if (!attr) {
+ break;
+ }
+
+ sdp_extmap_t* extmap = &(attr->attr.extmap);
+
+ SdpDirectionAttribute::Direction dir = SdpDirectionAttribute::kSendrecv;
+
+ if (extmap->media_direction_specified) {
+ ConvertDirection(extmap->media_direction, &dir);
+ }
+
+ extmaps->PushEntry(extmap->id, dir, extmap->media_direction_specified,
+ extmap->uri, extmap->extension_attributes);
+ }
+
+ if (!extmaps->mExtmaps.empty()) {
+ if (!AtSessionLevel() &&
+ mSessionLevel->HasAttribute(SdpAttribute::kExtmapAttribute)) {
+ uint32_t lineNumber =
+ sdp_attr_line_number(sdp, SDP_ATTR_EXTMAP, level, 0, 1);
+ errorHolder.AddParseError(
+ lineNumber, "extmap attributes in both session and media level");
+ }
+ SetAttribute(extmaps.release());
+ }
+}
+
+void
+SipccSdpAttributeList::LoadRtcpFb(sdp_t* sdp, uint16_t level,
+ SdpErrorHolder& errorHolder)
+{
+ auto rtcpfbs = MakeUnique<SdpRtcpFbAttributeList>();
+
+ for (uint16_t i = 1; i < UINT16_MAX; ++i) {
+ sdp_attr_t* attr = sdp_find_attr(sdp, level, 0, SDP_ATTR_RTCP_FB, i);
+
+ if (!attr) {
+ break;
+ }
+
+ sdp_fmtp_fb_t* rtcpfb = &attr->attr.rtcp_fb;
+
+ SdpRtcpFbAttributeList::Type type;
+ std::string parameter;
+
+ // Set type and parameter
+ switch (rtcpfb->feedback_type) {
+ case SDP_RTCP_FB_ACK:
+ type = SdpRtcpFbAttributeList::kAck;
+ switch (rtcpfb->param.ack) {
+ // TODO: sipcc doesn't seem to support ack with no following token.
+ // Issue 189.
+ case SDP_RTCP_FB_ACK_RPSI:
+ parameter = SdpRtcpFbAttributeList::rpsi;
+ break;
+ case SDP_RTCP_FB_ACK_APP:
+ parameter = SdpRtcpFbAttributeList::app;
+ break;
+ default:
+ // Type we don't care about, ignore.
+ continue;
+ }
+ break;
+ case SDP_RTCP_FB_CCM:
+ type = SdpRtcpFbAttributeList::kCcm;
+ switch (rtcpfb->param.ccm) {
+ case SDP_RTCP_FB_CCM_FIR:
+ parameter = SdpRtcpFbAttributeList::fir;
+ break;
+ case SDP_RTCP_FB_CCM_TMMBR:
+ parameter = SdpRtcpFbAttributeList::tmmbr;
+ break;
+ case SDP_RTCP_FB_CCM_TSTR:
+ parameter = SdpRtcpFbAttributeList::tstr;
+ break;
+ case SDP_RTCP_FB_CCM_VBCM:
+ parameter = SdpRtcpFbAttributeList::vbcm;
+ break;
+ default:
+ // Type we don't care about, ignore.
+ continue;
+ }
+ break;
+ case SDP_RTCP_FB_NACK:
+ type = SdpRtcpFbAttributeList::kNack;
+ switch (rtcpfb->param.nack) {
+ case SDP_RTCP_FB_NACK_BASIC:
+ break;
+ case SDP_RTCP_FB_NACK_SLI:
+ parameter = SdpRtcpFbAttributeList::sli;
+ break;
+ case SDP_RTCP_FB_NACK_PLI:
+ parameter = SdpRtcpFbAttributeList::pli;
+ break;
+ case SDP_RTCP_FB_NACK_RPSI:
+ parameter = SdpRtcpFbAttributeList::rpsi;
+ break;
+ case SDP_RTCP_FB_NACK_APP:
+ parameter = SdpRtcpFbAttributeList::app;
+ break;
+ default:
+ // Type we don't care about, ignore.
+ continue;
+ }
+ break;
+ case SDP_RTCP_FB_TRR_INT: {
+ type = SdpRtcpFbAttributeList::kTrrInt;
+ std::ostringstream os;
+ os << rtcpfb->param.trr_int;
+ parameter = os.str();
+ } break;
+ case SDP_RTCP_FB_REMB: {
+ type = SdpRtcpFbAttributeList::kRemb;
+ } break;
+ default:
+ // Type we don't care about, ignore.
+ continue;
+ }
+
+ std::stringstream osPayloadType;
+ if (rtcpfb->payload_num == UINT16_MAX) {
+ osPayloadType << "*";
+ } else {
+ osPayloadType << rtcpfb->payload_num;
+ }
+
+ std::string pt(osPayloadType.str());
+ std::string extra(rtcpfb->extra);
+
+ rtcpfbs->PushEntry(pt, type, parameter, extra);
+ }
+
+ if (!rtcpfbs->mFeedbacks.empty()) {
+ SetAttribute(rtcpfbs.release());
+ }
+}
+
+void
+SipccSdpAttributeList::LoadRtcp(sdp_t* sdp, uint16_t level,
+ SdpErrorHolder& errorHolder)
+{
+ sdp_attr_t* attr = sdp_find_attr(sdp, level, 0, SDP_ATTR_RTCP, 1);
+
+ if (!attr) {
+ return;
+ }
+
+ sdp_rtcp_t* rtcp = &attr->attr.rtcp;
+
+ if (rtcp->nettype != SDP_NT_INTERNET) {
+ return;
+ }
+
+ if (rtcp->addrtype != SDP_AT_IP4 && rtcp->addrtype != SDP_AT_IP6) {
+ return;
+ }
+
+ if (!strlen(rtcp->addr)) {
+ SetAttribute(new SdpRtcpAttribute(rtcp->port));
+ } else {
+ SetAttribute(
+ new SdpRtcpAttribute(
+ rtcp->port,
+ sdp::kInternet,
+ rtcp->addrtype == SDP_AT_IP4 ? sdp::kIPv4 : sdp::kIPv6,
+ rtcp->addr));
+ }
+}
+
+bool
+SipccSdpAttributeList::Load(sdp_t* sdp, uint16_t level,
+ SdpErrorHolder& errorHolder)
+{
+
+ LoadSimpleStrings(sdp, level, errorHolder);
+ LoadSimpleNumbers(sdp, level, errorHolder);
+ LoadFlags(sdp, level);
+ LoadDirection(sdp, level, errorHolder);
+
+ if (AtSessionLevel()) {
+ if (!LoadGroups(sdp, level, errorHolder)) {
+ return false;
+ }
+
+ if (!LoadMsidSemantics(sdp, level, errorHolder)) {
+ return false;
+ }
+
+ LoadIdentity(sdp, level);
+ LoadDtlsMessage(sdp, level);
+ } else {
+ sdp_media_e mtype = sdp_get_media_type(sdp, level);
+ if (mtype == SDP_MEDIA_APPLICATION) {
+ if (!LoadSctpmap(sdp, level, errorHolder)) {
+ return false;
+ }
+ } else {
+ if (!LoadRtpmap(sdp, level, errorHolder)) {
+ return false;
+ }
+ }
+ LoadCandidate(sdp, level);
+ LoadFmtp(sdp, level);
+ LoadMsids(sdp, level, errorHolder);
+ LoadRtcpFb(sdp, level, errorHolder);
+ LoadRtcp(sdp, level, errorHolder);
+ LoadSsrc(sdp, level);
+ if (!LoadImageattr(sdp, level, errorHolder)) {
+ return false;
+ }
+ if (!LoadSimulcast(sdp, level, errorHolder)) {
+ return false;
+ }
+ if (!LoadRid(sdp, level, errorHolder)) {
+ return false;
+ }
+ }
+
+ LoadIceAttributes(sdp, level);
+ if (!LoadFingerprint(sdp, level, errorHolder)) {
+ return false;
+ }
+ LoadSetup(sdp, level);
+ LoadExtmap(sdp, level, errorHolder);
+
+ return true;
+}
+
+bool
+SipccSdpAttributeList::IsAllowedHere(SdpAttribute::AttributeType type) const
+{
+ if (AtSessionLevel() && !SdpAttribute::IsAllowedAtSessionLevel(type)) {
+ return false;
+ }
+
+ if (!AtSessionLevel() && !SdpAttribute::IsAllowedAtMediaLevel(type)) {
+ return false;
+ }
+
+ return true;
+}
+
+void
+SipccSdpAttributeList::WarnAboutMisplacedAttribute(
+ SdpAttribute::AttributeType type, uint32_t lineNumber,
+ SdpErrorHolder& errorHolder)
+{
+ std::string warning = SdpAttribute::GetAttributeTypeString(type) +
+ (AtSessionLevel() ? " at session level. Ignoring."
+ : " at media level. Ignoring.");
+ errorHolder.AddParseError(lineNumber, warning);
+}
+
+const std::vector<std::string>&
+SipccSdpAttributeList::GetCandidate() const
+{
+ if (!HasAttribute(SdpAttribute::kCandidateAttribute)) {
+ MOZ_CRASH();
+ }
+
+ return static_cast<const SdpMultiStringAttribute*>(
+ GetAttribute(SdpAttribute::kCandidateAttribute))->mValues;
+}
+
+const SdpConnectionAttribute&
+SipccSdpAttributeList::GetConnection() const
+{
+ if (!HasAttribute(SdpAttribute::kConnectionAttribute)) {
+ MOZ_CRASH();
+ }
+
+ return *static_cast<const SdpConnectionAttribute*>(
+ GetAttribute(SdpAttribute::kConnectionAttribute));
+}
+
+SdpDirectionAttribute::Direction
+SipccSdpAttributeList::GetDirection() const
+{
+ if (!HasAttribute(SdpAttribute::kDirectionAttribute)) {
+ MOZ_CRASH();
+ }
+
+ const SdpAttribute* attr = GetAttribute(SdpAttribute::kDirectionAttribute);
+ return static_cast<const SdpDirectionAttribute*>(attr)->mValue;
+}
+
+const SdpDtlsMessageAttribute&
+SipccSdpAttributeList::GetDtlsMessage() const
+{
+ if (!HasAttribute(SdpAttribute::kDtlsMessageAttribute)) {
+ MOZ_CRASH();
+ }
+ const SdpAttribute* attr = GetAttribute(SdpAttribute::kDtlsMessageAttribute);
+ return *static_cast<const SdpDtlsMessageAttribute*>(attr);
+}
+
+const SdpExtmapAttributeList&
+SipccSdpAttributeList::GetExtmap() const
+{
+ if (!HasAttribute(SdpAttribute::kExtmapAttribute)) {
+ MOZ_CRASH();
+ }
+
+ return *static_cast<const SdpExtmapAttributeList*>(
+ GetAttribute(SdpAttribute::kExtmapAttribute));
+}
+
+const SdpFingerprintAttributeList&
+SipccSdpAttributeList::GetFingerprint() const
+{
+ if (!HasAttribute(SdpAttribute::kFingerprintAttribute)) {
+ MOZ_CRASH();
+ }
+ const SdpAttribute* attr = GetAttribute(SdpAttribute::kFingerprintAttribute);
+ return *static_cast<const SdpFingerprintAttributeList*>(attr);
+}
+
+const SdpFmtpAttributeList&
+SipccSdpAttributeList::GetFmtp() const
+{
+ if (!HasAttribute(SdpAttribute::kFmtpAttribute)) {
+ MOZ_CRASH();
+ }
+
+ return *static_cast<const SdpFmtpAttributeList*>(
+ GetAttribute(SdpAttribute::kFmtpAttribute));
+}
+
+const SdpGroupAttributeList&
+SipccSdpAttributeList::GetGroup() const
+{
+ if (!HasAttribute(SdpAttribute::kGroupAttribute)) {
+ MOZ_CRASH();
+ }
+
+ return *static_cast<const SdpGroupAttributeList*>(
+ GetAttribute(SdpAttribute::kGroupAttribute));
+}
+
+const SdpOptionsAttribute&
+SipccSdpAttributeList::GetIceOptions() const
+{
+ if (!HasAttribute(SdpAttribute::kIceOptionsAttribute)) {
+ MOZ_CRASH();
+ }
+
+ const SdpAttribute* attr = GetAttribute(SdpAttribute::kIceOptionsAttribute);
+ return *static_cast<const SdpOptionsAttribute*>(attr);
+}
+
+const std::string&
+SipccSdpAttributeList::GetIcePwd() const
+{
+ if (!HasAttribute(SdpAttribute::kIcePwdAttribute)) {
+ return kEmptyString;
+ }
+ const SdpAttribute* attr = GetAttribute(SdpAttribute::kIcePwdAttribute);
+ return static_cast<const SdpStringAttribute*>(attr)->mValue;
+}
+
+const std::string&
+SipccSdpAttributeList::GetIceUfrag() const
+{
+ if (!HasAttribute(SdpAttribute::kIceUfragAttribute)) {
+ return kEmptyString;
+ }
+ const SdpAttribute* attr = GetAttribute(SdpAttribute::kIceUfragAttribute);
+ return static_cast<const SdpStringAttribute*>(attr)->mValue;
+}
+
+const std::string&
+SipccSdpAttributeList::GetIdentity() const
+{
+ if (!HasAttribute(SdpAttribute::kIdentityAttribute)) {
+ return kEmptyString;
+ }
+ const SdpAttribute* attr = GetAttribute(SdpAttribute::kIdentityAttribute);
+ return static_cast<const SdpStringAttribute*>(attr)->mValue;
+}
+
+const SdpImageattrAttributeList&
+SipccSdpAttributeList::GetImageattr() const
+{
+ if (!HasAttribute(SdpAttribute::kImageattrAttribute)) {
+ MOZ_CRASH();
+ }
+ const SdpAttribute* attr = GetAttribute(SdpAttribute::kImageattrAttribute);
+ return *static_cast<const SdpImageattrAttributeList*>(attr);
+}
+
+const SdpSimulcastAttribute&
+SipccSdpAttributeList::GetSimulcast() const
+{
+ if (!HasAttribute(SdpAttribute::kSimulcastAttribute)) {
+ MOZ_CRASH();
+ }
+ const SdpAttribute* attr = GetAttribute(SdpAttribute::kSimulcastAttribute);
+ return *static_cast<const SdpSimulcastAttribute*>(attr);
+}
+
+const std::string&
+SipccSdpAttributeList::GetLabel() const
+{
+ if (!HasAttribute(SdpAttribute::kLabelAttribute)) {
+ return kEmptyString;
+ }
+ const SdpAttribute* attr = GetAttribute(SdpAttribute::kLabelAttribute);
+ return static_cast<const SdpStringAttribute*>(attr)->mValue;
+}
+
+uint32_t
+SipccSdpAttributeList::GetMaxptime() const
+{
+ if (!HasAttribute(SdpAttribute::kMaxptimeAttribute)) {
+ MOZ_CRASH();
+ }
+ const SdpAttribute* attr = GetAttribute(SdpAttribute::kMaxptimeAttribute);
+ return static_cast<const SdpNumberAttribute*>(attr)->mValue;
+}
+
+const std::string&
+SipccSdpAttributeList::GetMid() const
+{
+ if (!HasAttribute(SdpAttribute::kMidAttribute)) {
+ return kEmptyString;
+ }
+ const SdpAttribute* attr = GetAttribute(SdpAttribute::kMidAttribute);
+ return static_cast<const SdpStringAttribute*>(attr)->mValue;
+}
+
+const SdpMsidAttributeList&
+SipccSdpAttributeList::GetMsid() const
+{
+ if (!HasAttribute(SdpAttribute::kMsidAttribute)) {
+ MOZ_CRASH();
+ }
+ const SdpAttribute* attr = GetAttribute(SdpAttribute::kMsidAttribute);
+ return *static_cast<const SdpMsidAttributeList*>(attr);
+}
+
+const SdpMsidSemanticAttributeList&
+SipccSdpAttributeList::GetMsidSemantic() const
+{
+ if (!HasAttribute(SdpAttribute::kMsidSemanticAttribute)) {
+ MOZ_CRASH();
+ }
+ const SdpAttribute* attr = GetAttribute(SdpAttribute::kMsidSemanticAttribute);
+ return *static_cast<const SdpMsidSemanticAttributeList*>(attr);
+}
+
+const SdpRidAttributeList&
+SipccSdpAttributeList::GetRid() const
+{
+ if (!HasAttribute(SdpAttribute::kRidAttribute)) {
+ MOZ_CRASH();
+ }
+ const SdpAttribute* attr = GetAttribute(SdpAttribute::kRidAttribute);
+ return *static_cast<const SdpRidAttributeList*>(attr);
+}
+
+uint32_t
+SipccSdpAttributeList::GetPtime() const
+{
+ if (!HasAttribute(SdpAttribute::kPtimeAttribute)) {
+ MOZ_CRASH();
+ }
+ const SdpAttribute* attr = GetAttribute(SdpAttribute::kPtimeAttribute);
+ return static_cast<const SdpNumberAttribute*>(attr)->mValue;
+}
+
+const SdpRtcpAttribute&
+SipccSdpAttributeList::GetRtcp() const
+{
+ if (!HasAttribute(SdpAttribute::kRtcpAttribute)) {
+ MOZ_CRASH();
+ }
+ const SdpAttribute* attr = GetAttribute(SdpAttribute::kRtcpAttribute);
+ return *static_cast<const SdpRtcpAttribute*>(attr);
+}
+
+const SdpRtcpFbAttributeList&
+SipccSdpAttributeList::GetRtcpFb() const
+{
+ if (!HasAttribute(SdpAttribute::kRtcpFbAttribute)) {
+ MOZ_CRASH();
+ }
+ const SdpAttribute* attr = GetAttribute(SdpAttribute::kRtcpFbAttribute);
+ return *static_cast<const SdpRtcpFbAttributeList*>(attr);
+}
+
+const SdpRemoteCandidatesAttribute&
+SipccSdpAttributeList::GetRemoteCandidates() const
+{
+ MOZ_CRASH("Not yet implemented");
+}
+
+const SdpRtpmapAttributeList&
+SipccSdpAttributeList::GetRtpmap() const
+{
+ if (!HasAttribute(SdpAttribute::kRtpmapAttribute)) {
+ MOZ_CRASH();
+ }
+ const SdpAttribute* attr = GetAttribute(SdpAttribute::kRtpmapAttribute);
+ return *static_cast<const SdpRtpmapAttributeList*>(attr);
+}
+
+const SdpSctpmapAttributeList&
+SipccSdpAttributeList::GetSctpmap() const
+{
+ if (!HasAttribute(SdpAttribute::kSctpmapAttribute)) {
+ MOZ_CRASH();
+ }
+ const SdpAttribute* attr = GetAttribute(SdpAttribute::kSctpmapAttribute);
+ return *static_cast<const SdpSctpmapAttributeList*>(attr);
+}
+
+const SdpSetupAttribute&
+SipccSdpAttributeList::GetSetup() const
+{
+ if (!HasAttribute(SdpAttribute::kSetupAttribute)) {
+ MOZ_CRASH();
+ }
+ const SdpAttribute* attr = GetAttribute(SdpAttribute::kSetupAttribute);
+ return *static_cast<const SdpSetupAttribute*>(attr);
+}
+
+const SdpSsrcAttributeList&
+SipccSdpAttributeList::GetSsrc() const
+{
+ if (!HasAttribute(SdpAttribute::kSsrcAttribute)) {
+ MOZ_CRASH();
+ }
+ const SdpAttribute* attr = GetAttribute(SdpAttribute::kSsrcAttribute);
+ return *static_cast<const SdpSsrcAttributeList*>(attr);
+}
+
+const SdpSsrcGroupAttributeList&
+SipccSdpAttributeList::GetSsrcGroup() const
+{
+ MOZ_CRASH("Not yet implemented");
+}
+
+void
+SipccSdpAttributeList::Serialize(std::ostream& os) const
+{
+ for (size_t i = 0; i < kNumAttributeTypes; ++i) {
+ if (mAttributes[i]) {
+ os << *mAttributes[i];
+ }
+ }
+}
+
+} // namespace mozilla
diff --git a/media/webrtc/signaling/src/sdp/SipccSdpAttributeList.h b/media/webrtc/signaling/src/sdp/SipccSdpAttributeList.h
new file mode 100644
index 000000000..62dded52e
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/SipccSdpAttributeList.h
@@ -0,0 +1,147 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef _SIPCCSDPATTRIBUTELIST_H_
+#define _SIPCCSDPATTRIBUTELIST_H_
+
+#include "signaling/src/sdp/SdpAttributeList.h"
+
+extern "C" {
+#include "signaling/src/sdp/sipcc/sdp.h"
+}
+
+namespace mozilla
+{
+
+class SipccSdp;
+class SipccSdpMediaSection;
+class SdpErrorHolder;
+
+class SipccSdpAttributeList : public SdpAttributeList
+{
+ friend class SipccSdpMediaSection;
+ friend class SipccSdp;
+
+public:
+ // Make sure we don't hide the default arg thunks
+ using SdpAttributeList::HasAttribute;
+ using SdpAttributeList::GetAttribute;
+
+ virtual bool HasAttribute(AttributeType type,
+ bool sessionFallback) const override;
+ virtual const SdpAttribute* GetAttribute(
+ AttributeType type, bool sessionFallback) const override;
+ virtual void SetAttribute(SdpAttribute* attr) override;
+ virtual void RemoveAttribute(AttributeType type) override;
+ virtual void Clear() override;
+
+ virtual const SdpConnectionAttribute& GetConnection() const override;
+ virtual const SdpFingerprintAttributeList& GetFingerprint() const
+ override;
+ virtual const SdpGroupAttributeList& GetGroup() const override;
+ virtual const SdpOptionsAttribute& GetIceOptions() const override;
+ virtual const SdpRtcpAttribute& GetRtcp() const override;
+ virtual const SdpRemoteCandidatesAttribute& GetRemoteCandidates() const
+ override;
+ virtual const SdpSetupAttribute& GetSetup() const override;
+ virtual const SdpSsrcAttributeList& GetSsrc() const override;
+ virtual const SdpSsrcGroupAttributeList& GetSsrcGroup() const override;
+ virtual const SdpDtlsMessageAttribute& GetDtlsMessage() const override;
+
+ // These attributes can appear multiple times, so the returned
+ // classes actually represent a collection of values.
+ virtual const std::vector<std::string>& GetCandidate() const override;
+ virtual const SdpExtmapAttributeList& GetExtmap() const override;
+ virtual const SdpFmtpAttributeList& GetFmtp() const override;
+ virtual const SdpImageattrAttributeList& GetImageattr() const override;
+ const SdpSimulcastAttribute& GetSimulcast() const override;
+ virtual const SdpMsidAttributeList& GetMsid() const override;
+ virtual const SdpMsidSemanticAttributeList& GetMsidSemantic()
+ const override;
+ const SdpRidAttributeList& GetRid() const override;
+ virtual const SdpRtcpFbAttributeList& GetRtcpFb() const override;
+ virtual const SdpRtpmapAttributeList& GetRtpmap() const override;
+ virtual const SdpSctpmapAttributeList& GetSctpmap() const override;
+
+ // These attributes are effectively simple types, so we'll make life
+ // easy by just returning their value.
+ virtual const std::string& GetIcePwd() const override;
+ virtual const std::string& GetIceUfrag() const override;
+ virtual const std::string& GetIdentity() const override;
+ virtual const std::string& GetLabel() const override;
+ virtual unsigned int GetMaxptime() const override;
+ virtual const std::string& GetMid() const override;
+ virtual unsigned int GetPtime() const override;
+
+ virtual SdpDirectionAttribute::Direction GetDirection() const override;
+
+ virtual void Serialize(std::ostream&) const override;
+
+ virtual ~SipccSdpAttributeList();
+
+private:
+ static const std::string kEmptyString;
+ static const size_t kNumAttributeTypes = SdpAttribute::kLastAttribute + 1;
+
+ // Pass a session-level attribute list if constructing a media-level one,
+ // otherwise pass nullptr
+ explicit SipccSdpAttributeList(const SipccSdpAttributeList* sessionLevel);
+
+ bool Load(sdp_t* sdp, uint16_t level, SdpErrorHolder& errorHolder);
+ void LoadSimpleStrings(sdp_t* sdp, uint16_t level,
+ SdpErrorHolder& errorHolder);
+ void LoadSimpleString(sdp_t* sdp, uint16_t level, sdp_attr_e attr,
+ AttributeType targetType, SdpErrorHolder& errorHolder);
+ void LoadSimpleNumbers(sdp_t* sdp, uint16_t level,
+ SdpErrorHolder& errorHolder);
+ void LoadSimpleNumber(sdp_t* sdp, uint16_t level, sdp_attr_e attr,
+ AttributeType targetType, SdpErrorHolder& errorHolder);
+ void LoadFlags(sdp_t* sdp, uint16_t level);
+ void LoadDirection(sdp_t* sdp, uint16_t level, SdpErrorHolder& errorHolder);
+ bool LoadRtpmap(sdp_t* sdp, uint16_t level, SdpErrorHolder& errorHolder);
+ bool LoadSctpmap(sdp_t* sdp, uint16_t level, SdpErrorHolder& errorHolder);
+ void LoadIceAttributes(sdp_t* sdp, uint16_t level);
+ bool LoadFingerprint(sdp_t* sdp, uint16_t level, SdpErrorHolder& errorHolder);
+ void LoadCandidate(sdp_t* sdp, uint16_t level);
+ void LoadSetup(sdp_t* sdp, uint16_t level);
+ void LoadSsrc(sdp_t* sdp, uint16_t level);
+ bool LoadImageattr(sdp_t* sdp, uint16_t level, SdpErrorHolder& errorHolder);
+ bool LoadSimulcast(sdp_t* sdp, uint16_t level, SdpErrorHolder& errorHolder);
+ bool LoadGroups(sdp_t* sdp, uint16_t level, SdpErrorHolder& errorHolder);
+ bool LoadMsidSemantics(sdp_t* sdp,
+ uint16_t level,
+ SdpErrorHolder& errorHolder);
+ void LoadIdentity(sdp_t* sdp, uint16_t level);
+ void LoadDtlsMessage(sdp_t* sdp, uint16_t level);
+ void LoadFmtp(sdp_t* sdp, uint16_t level);
+ void LoadMsids(sdp_t* sdp, uint16_t level, SdpErrorHolder& errorHolder);
+ bool LoadRid(sdp_t* sdp, uint16_t level, SdpErrorHolder& errorHolder);
+ void LoadExtmap(sdp_t* sdp, uint16_t level, SdpErrorHolder& errorHolder);
+ void LoadRtcpFb(sdp_t* sdp, uint16_t level, SdpErrorHolder& errorHolder);
+ void LoadRtcp(sdp_t* sdp, uint16_t level, SdpErrorHolder& errorHolder);
+ static SdpRtpmapAttributeList::CodecType GetCodecType(rtp_ptype type);
+
+ bool
+ AtSessionLevel() const
+ {
+ return !mSessionLevel;
+ }
+ bool IsAllowedHere(SdpAttribute::AttributeType type) const;
+ void WarnAboutMisplacedAttribute(SdpAttribute::AttributeType type,
+ uint32_t lineNumber,
+ SdpErrorHolder& errorHolder);
+
+ const SipccSdpAttributeList* mSessionLevel;
+
+ SdpAttribute* mAttributes[kNumAttributeTypes];
+
+ SipccSdpAttributeList(const SipccSdpAttributeList& orig) = delete;
+ SipccSdpAttributeList& operator=(const SipccSdpAttributeList& rhs) = delete;
+};
+
+} // namespace mozilla
+
+#endif
diff --git a/media/webrtc/signaling/src/sdp/SipccSdpMediaSection.cpp b/media/webrtc/signaling/src/sdp/SipccSdpMediaSection.cpp
new file mode 100644
index 000000000..33c2a9e0d
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/SipccSdpMediaSection.cpp
@@ -0,0 +1,423 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* 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 "signaling/src/sdp/SipccSdpMediaSection.h"
+
+#include <ostream>
+#include "signaling/src/sdp/SdpErrorHolder.h"
+
+#ifdef CRLF
+#undef CRLF
+#endif
+#define CRLF "\r\n"
+
+namespace mozilla
+{
+
+unsigned int
+SipccSdpMediaSection::GetPort() const
+{
+ return mPort;
+}
+
+void
+SipccSdpMediaSection::SetPort(unsigned int port)
+{
+ mPort = port;
+}
+
+unsigned int
+SipccSdpMediaSection::GetPortCount() const
+{
+ return mPortCount;
+}
+
+SdpMediaSection::Protocol
+SipccSdpMediaSection::GetProtocol() const
+{
+ return mProtocol;
+}
+
+const SdpConnection&
+SipccSdpMediaSection::GetConnection() const
+{
+ return *mConnection;
+}
+
+SdpConnection&
+SipccSdpMediaSection::GetConnection()
+{
+ return *mConnection;
+}
+
+uint32_t
+SipccSdpMediaSection::GetBandwidth(const std::string& type) const
+{
+ auto found = mBandwidths.find(type);
+ if (found == mBandwidths.end()) {
+ return 0;
+ }
+ return found->second;
+}
+
+const std::vector<std::string>&
+SipccSdpMediaSection::GetFormats() const
+{
+ return mFormats;
+}
+
+const SdpAttributeList&
+SipccSdpMediaSection::GetAttributeList() const
+{
+ return mAttributeList;
+}
+
+SdpAttributeList&
+SipccSdpMediaSection::GetAttributeList()
+{
+ return mAttributeList;
+}
+
+SdpDirectionAttribute
+SipccSdpMediaSection::GetDirectionAttribute() const
+{
+ return SdpDirectionAttribute(mAttributeList.GetDirection());
+}
+
+bool
+SipccSdpMediaSection::Load(sdp_t* sdp, uint16_t level,
+ SdpErrorHolder& errorHolder)
+{
+ switch (sdp_get_media_type(sdp, level)) {
+ case SDP_MEDIA_AUDIO:
+ mMediaType = kAudio;
+ break;
+ case SDP_MEDIA_VIDEO:
+ mMediaType = kVideo;
+ break;
+ case SDP_MEDIA_APPLICATION:
+ mMediaType = kApplication;
+ break;
+ case SDP_MEDIA_TEXT:
+ mMediaType = kText;
+ break;
+
+ default:
+ errorHolder.AddParseError(sdp_get_media_line_number(sdp, level),
+ "Unsupported media section type");
+ return false;
+ }
+
+ mPort = sdp_get_media_portnum(sdp, level);
+ int32_t pc = sdp_get_media_portcount(sdp, level);
+ if (pc == SDP_INVALID_VALUE) {
+ // SDP_INVALID_VALUE (ie; -2) is used when there is no port count. :(
+ mPortCount = 0;
+ } else if (pc > static_cast<int32_t>(UINT16_MAX) || pc < 0) {
+ errorHolder.AddParseError(sdp_get_media_line_number(sdp, level),
+ "Invalid port count");
+ return false;
+ } else {
+ mPortCount = pc;
+ }
+
+ if (!LoadProtocol(sdp, level, errorHolder)) {
+ return false;
+ }
+
+ if (!LoadFormats(sdp, level, errorHolder)) {
+ return false;
+ }
+
+ if (!mAttributeList.Load(sdp, level, errorHolder)) {
+ return false;
+ }
+
+ if (!ValidateSimulcast(sdp, level, errorHolder)) {
+ return false;
+ }
+
+ if (!mBandwidths.Load(sdp, level, errorHolder)) {
+ return false;
+ }
+
+ return LoadConnection(sdp, level, errorHolder);
+}
+
+bool
+SipccSdpMediaSection::LoadProtocol(sdp_t* sdp, uint16_t level,
+ SdpErrorHolder& errorHolder)
+{
+ switch (sdp_get_media_transport(sdp, level)) {
+ case SDP_TRANSPORT_RTPAVP:
+ mProtocol = kRtpAvp;
+ break;
+ case SDP_TRANSPORT_RTPSAVP:
+ mProtocol = kRtpSavp;
+ break;
+ case SDP_TRANSPORT_RTPAVPF:
+ mProtocol = kRtpAvpf;
+ break;
+ case SDP_TRANSPORT_RTPSAVPF:
+ mProtocol = kRtpSavpf;
+ break;
+ case SDP_TRANSPORT_UDPTLSRTPSAVP:
+ mProtocol = kUdpTlsRtpSavp;
+ break;
+ case SDP_TRANSPORT_UDPTLSRTPSAVPF:
+ mProtocol = kUdpTlsRtpSavpf;
+ break;
+ case SDP_TRANSPORT_TCPTLSRTPSAVP:
+ mProtocol = kTcpTlsRtpSavp;
+ break;
+ case SDP_TRANSPORT_TCPTLSRTPSAVPF:
+ mProtocol = kTcpTlsRtpSavpf;
+ break;
+ case SDP_TRANSPORT_DTLSSCTP:
+ mProtocol = kDtlsSctp;
+ break;
+
+ default:
+ errorHolder.AddParseError(sdp_get_media_line_number(sdp, level),
+ "Unsupported media transport type");
+ return false;
+ }
+ return true;
+}
+
+bool
+SipccSdpMediaSection::LoadFormats(sdp_t* sdp,
+ uint16_t level,
+ SdpErrorHolder& errorHolder)
+{
+ sdp_media_e mtype = sdp_get_media_type(sdp, level);
+
+ if (mtype == SDP_MEDIA_APPLICATION) {
+ uint32_t ptype = sdp_get_media_sctp_port(sdp, level);
+ std::ostringstream osPayloadType;
+ osPayloadType << ptype;
+ mFormats.push_back(osPayloadType.str());
+ } else if (mtype == SDP_MEDIA_AUDIO || mtype == SDP_MEDIA_VIDEO) {
+ uint16_t count = sdp_get_media_num_payload_types(sdp, level);
+ for (uint16_t i = 0; i < count; ++i) {
+ sdp_payload_ind_e indicator; // we ignore this, which is fine
+ uint32_t ptype =
+ sdp_get_media_payload_type(sdp, level, i + 1, &indicator);
+
+ if (GET_DYN_PAYLOAD_TYPE_VALUE(ptype) > UINT8_MAX) {
+ errorHolder.AddParseError(sdp_get_media_line_number(sdp, level),
+ "Format is too large");
+ return false;
+ }
+
+ std::ostringstream osPayloadType;
+ // sipcc stores payload types in a funny way. When sipcc and the SDP it
+ // parsed differ on what payload type number should be used for a given
+ // codec, sipcc's value goes in the lower byte, and the SDP's value in
+ // the upper byte. When they do not differ, only the lower byte is used.
+ // We want what was in the SDP, verbatim.
+ osPayloadType << GET_DYN_PAYLOAD_TYPE_VALUE(ptype);
+ mFormats.push_back(osPayloadType.str());
+ }
+ }
+
+ return true;
+}
+
+bool
+SipccSdpMediaSection::ValidateSimulcast(sdp_t* sdp, uint16_t level,
+ SdpErrorHolder& errorHolder) const
+{
+ if (!GetAttributeList().HasAttribute(SdpAttribute::kSimulcastAttribute)) {
+ return true;
+ }
+
+ const SdpSimulcastAttribute& simulcast(GetAttributeList().GetSimulcast());
+ if (!ValidateSimulcastVersions(
+ sdp, level, simulcast.sendVersions, sdp::kSend, errorHolder)) {
+ return false;
+ }
+ if (!ValidateSimulcastVersions(
+ sdp, level, simulcast.recvVersions, sdp::kRecv, errorHolder)) {
+ return false;
+ }
+ return true;
+}
+
+bool
+SipccSdpMediaSection::ValidateSimulcastVersions(
+ sdp_t* sdp,
+ uint16_t level,
+ const SdpSimulcastAttribute::Versions& versions,
+ sdp::Direction direction,
+ SdpErrorHolder& errorHolder) const
+{
+ if (versions.IsSet() && !(direction & GetDirectionAttribute().mValue)) {
+ errorHolder.AddParseError(sdp_get_media_line_number(sdp, level),
+ "simulcast attribute has a direction that is "
+ "inconsistent with the direction of this media "
+ "section.");
+ return false;
+ }
+
+ for (const SdpSimulcastAttribute::Version& version : versions) {
+ for (const std::string& id : version.choices) {
+ if (versions.type == SdpSimulcastAttribute::Versions::kRid) {
+ const SdpRidAttributeList::Rid* ridAttr = FindRid(id);
+ if (!ridAttr || (ridAttr->direction != direction)) {
+ std::ostringstream os;
+ os << "No rid attribute for \'" << id << "\'";
+ errorHolder.AddParseError(sdp_get_media_line_number(sdp, level),
+ os.str());
+ return false;
+ }
+ } else if (versions.type == SdpSimulcastAttribute::Versions::kPt) {
+ if (std::find(mFormats.begin(), mFormats.end(), id)
+ == mFormats.end()) {
+ std::ostringstream os;
+ os << "No pt for \'" << id << "\'";
+ errorHolder.AddParseError(sdp_get_media_line_number(sdp, level),
+ os.str());
+ return false;
+ }
+ }
+ }
+ }
+ return true;
+}
+
+bool
+SipccSdpMediaSection::LoadConnection(sdp_t* sdp, uint16_t level,
+ SdpErrorHolder& errorHolder)
+{
+ if (!sdp_connection_valid(sdp, level)) {
+ level = SDP_SESSION_LEVEL;
+ if (!sdp_connection_valid(sdp, level)) {
+ errorHolder.AddParseError(sdp_get_media_line_number(sdp, level),
+ "Missing c= line");
+ return false;
+ }
+ }
+
+ sdp_nettype_e type = sdp_get_conn_nettype(sdp, level);
+ if (type != SDP_NT_INTERNET) {
+ errorHolder.AddParseError(sdp_get_media_line_number(sdp, level),
+ "Unsupported network type");
+ return false;
+ }
+
+ sdp::AddrType addrType;
+ switch (sdp_get_conn_addrtype(sdp, level)) {
+ case SDP_AT_IP4:
+ addrType = sdp::kIPv4;
+ break;
+ case SDP_AT_IP6:
+ addrType = sdp::kIPv6;
+ break;
+ default:
+ errorHolder.AddParseError(sdp_get_media_line_number(sdp, level),
+ "Unsupported address type");
+ return false;
+ }
+
+ std::string address = sdp_get_conn_address(sdp, level);
+ int16_t ttl = static_cast<uint16_t>(sdp_get_mcast_ttl(sdp, level));
+ if (ttl < 0) {
+ ttl = 0;
+ }
+ int32_t numAddr =
+ static_cast<uint32_t>(sdp_get_mcast_num_of_addresses(sdp, level));
+ if (numAddr < 0) {
+ numAddr = 0;
+ }
+ mConnection = MakeUnique<SdpConnection>(addrType, address, ttl, numAddr);
+ return true;
+}
+
+void
+SipccSdpMediaSection::AddCodec(const std::string& pt, const std::string& name,
+ uint32_t clockrate, uint16_t channels)
+{
+ mFormats.push_back(pt);
+
+ SdpRtpmapAttributeList* rtpmap = new SdpRtpmapAttributeList();
+ if (mAttributeList.HasAttribute(SdpAttribute::kRtpmapAttribute)) {
+ const SdpRtpmapAttributeList& old = mAttributeList.GetRtpmap();
+ for (auto it = old.mRtpmaps.begin(); it != old.mRtpmaps.end(); ++it) {
+ rtpmap->mRtpmaps.push_back(*it);
+ }
+ }
+ SdpRtpmapAttributeList::CodecType codec = SdpRtpmapAttributeList::kOtherCodec;
+ if (name == "opus") {
+ codec = SdpRtpmapAttributeList::kOpus;
+ } else if (name == "G722") {
+ codec = SdpRtpmapAttributeList::kG722;
+ } else if (name == "PCMU") {
+ codec = SdpRtpmapAttributeList::kPCMU;
+ } else if (name == "PCMA") {
+ codec = SdpRtpmapAttributeList::kPCMA;
+ } else if (name == "VP8") {
+ codec = SdpRtpmapAttributeList::kVP8;
+ } else if (name == "VP9") {
+ codec = SdpRtpmapAttributeList::kVP9;
+ } else if (name == "H264") {
+ codec = SdpRtpmapAttributeList::kH264;
+ }
+
+ rtpmap->PushEntry(pt, codec, name, clockrate, channels);
+ mAttributeList.SetAttribute(rtpmap);
+}
+
+void
+SipccSdpMediaSection::ClearCodecs()
+{
+ mFormats.clear();
+ mAttributeList.RemoveAttribute(SdpAttribute::kRtpmapAttribute);
+ mAttributeList.RemoveAttribute(SdpAttribute::kFmtpAttribute);
+ mAttributeList.RemoveAttribute(SdpAttribute::kSctpmapAttribute);
+ mAttributeList.RemoveAttribute(SdpAttribute::kRtcpFbAttribute);
+}
+
+void
+SipccSdpMediaSection::AddDataChannel(const std::string& pt,
+ const std::string& name, uint16_t streams)
+{
+ // Only one allowed, for now. This may change as the specs (and deployments)
+ // evolve.
+ mFormats.clear();
+ mFormats.push_back(pt);
+ SdpSctpmapAttributeList* sctpmap = new SdpSctpmapAttributeList();
+ sctpmap->PushEntry(pt, name, streams);
+ mAttributeList.SetAttribute(sctpmap);
+}
+
+void
+SipccSdpMediaSection::Serialize(std::ostream& os) const
+{
+ os << "m=" << mMediaType << " " << mPort;
+ if (mPortCount) {
+ os << "/" << mPortCount;
+ }
+ os << " " << mProtocol;
+ for (auto i = mFormats.begin(); i != mFormats.end(); ++i) {
+ os << " " << (*i);
+ }
+ os << CRLF;
+
+ // We dont do i=
+
+ if (mConnection) {
+ os << *mConnection;
+ }
+
+ mBandwidths.Serialize(os);
+
+ // We dont do k= because they're evil
+
+ os << mAttributeList;
+}
+
+} // namespace mozilla
diff --git a/media/webrtc/signaling/src/sdp/SipccSdpMediaSection.h b/media/webrtc/signaling/src/sdp/SipccSdpMediaSection.h
new file mode 100644
index 000000000..6d2dafa7b
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/SipccSdpMediaSection.h
@@ -0,0 +1,102 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef _SIPCCSDPMEDIASECTION_H_
+#define _SIPCCSDPMEDIASECTION_H_
+
+#include "mozilla/Attributes.h"
+#include "mozilla/UniquePtr.h"
+#include "signaling/src/sdp/SdpMediaSection.h"
+#include "signaling/src/sdp/SipccSdpAttributeList.h"
+
+#include <map>
+
+extern "C" {
+#include "signaling/src/sdp/sipcc/sdp.h"
+}
+
+namespace mozilla
+{
+
+class SipccSdp;
+class SdpErrorHolder;
+
+class SipccSdpBandwidths final : public std::map<std::string, uint32_t>
+{
+public:
+ bool Load(sdp_t* sdp, uint16_t level, SdpErrorHolder& errorHolder);
+ void Serialize(std::ostream& os) const;
+};
+
+class SipccSdpMediaSection final : public SdpMediaSection
+{
+ friend class SipccSdp;
+
+public:
+ ~SipccSdpMediaSection() {}
+
+ virtual MediaType
+ GetMediaType() const override
+ {
+ return mMediaType;
+ }
+
+ virtual unsigned int GetPort() const override;
+ virtual void SetPort(unsigned int port) override;
+ virtual unsigned int GetPortCount() const override;
+ virtual Protocol GetProtocol() const override;
+ virtual const SdpConnection& GetConnection() const override;
+ virtual SdpConnection& GetConnection() override;
+ virtual uint32_t GetBandwidth(const std::string& type) const override;
+ virtual const std::vector<std::string>& GetFormats() const override;
+
+ virtual const SdpAttributeList& GetAttributeList() const override;
+ virtual SdpAttributeList& GetAttributeList() override;
+ virtual SdpDirectionAttribute GetDirectionAttribute() const override;
+
+ virtual void AddCodec(const std::string& pt, const std::string& name,
+ uint32_t clockrate, uint16_t channels) override;
+ virtual void ClearCodecs() override;
+
+ virtual void AddDataChannel(const std::string& pt, const std::string& name,
+ uint16_t streams) override;
+
+ virtual void Serialize(std::ostream&) const override;
+
+private:
+ SipccSdpMediaSection(size_t level, const SipccSdpAttributeList* sessionLevel)
+ : SdpMediaSection(level), mAttributeList(sessionLevel)
+ {
+ }
+
+ bool Load(sdp_t* sdp, uint16_t level, SdpErrorHolder& errorHolder);
+ bool LoadConnection(sdp_t* sdp, uint16_t level, SdpErrorHolder& errorHolder);
+ bool LoadProtocol(sdp_t* sdp, uint16_t level, SdpErrorHolder& errorHolder);
+ bool LoadFormats(sdp_t* sdp, uint16_t level, SdpErrorHolder& errorHolder);
+ bool ValidateSimulcast(sdp_t* sdp, uint16_t level,
+ SdpErrorHolder& errorHolder) const;
+ bool ValidateSimulcastVersions(
+ sdp_t* sdp,
+ uint16_t level,
+ const SdpSimulcastAttribute::Versions& versions,
+ sdp::Direction direction,
+ SdpErrorHolder& errorHolder) const;
+
+ // the following values are cached on first get
+ MediaType mMediaType;
+ uint16_t mPort;
+ uint16_t mPortCount;
+ Protocol mProtocol;
+ std::vector<std::string> mFormats;
+
+ UniquePtr<SdpConnection> mConnection;
+ SipccSdpBandwidths mBandwidths;
+
+ SipccSdpAttributeList mAttributeList;
+};
+}
+
+#endif
diff --git a/media/webrtc/signaling/src/sdp/SipccSdpParser.cpp b/media/webrtc/signaling/src/sdp/SipccSdpParser.cpp
new file mode 100644
index 000000000..04fea305c
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/SipccSdpParser.cpp
@@ -0,0 +1,83 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* 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 "signaling/src/sdp/SipccSdpParser.h"
+#include "signaling/src/sdp/SipccSdp.h"
+
+#include <utility>
+extern "C" {
+#include "signaling/src/sdp/sipcc/sdp.h"
+}
+
+namespace mozilla
+{
+
+extern "C" {
+
+void
+sipcc_sdp_parser_error_handler(void *context, uint32_t line,
+ const char *message)
+{
+ SdpErrorHolder *errorHolder = static_cast<SdpErrorHolder *>(context);
+ std::string err(message);
+ errorHolder->AddParseError(line, err);
+}
+
+} // extern "C"
+
+UniquePtr<Sdp>
+SipccSdpParser::Parse(const std::string &sdpText)
+{
+ ClearParseErrors();
+
+ sdp_conf_options_t *sipcc_config = sdp_init_config();
+ if (!sipcc_config) {
+ return UniquePtr<Sdp>();
+ }
+
+ sdp_nettype_supported(sipcc_config, SDP_NT_INTERNET, true);
+ sdp_addrtype_supported(sipcc_config, SDP_AT_IP4, true);
+ sdp_addrtype_supported(sipcc_config, SDP_AT_IP6, true);
+ sdp_transport_supported(sipcc_config, SDP_TRANSPORT_RTPAVP, true);
+ sdp_transport_supported(sipcc_config, SDP_TRANSPORT_RTPAVPF, true);
+ sdp_transport_supported(sipcc_config, SDP_TRANSPORT_RTPSAVP, true);
+ sdp_transport_supported(sipcc_config, SDP_TRANSPORT_RTPSAVPF, true);
+ sdp_transport_supported(sipcc_config, SDP_TRANSPORT_UDPTLSRTPSAVP, true);
+ sdp_transport_supported(sipcc_config, SDP_TRANSPORT_UDPTLSRTPSAVPF, true);
+ sdp_transport_supported(sipcc_config, SDP_TRANSPORT_TCPTLSRTPSAVP, true);
+ sdp_transport_supported(sipcc_config, SDP_TRANSPORT_TCPTLSRTPSAVPF, true);
+ sdp_transport_supported(sipcc_config, SDP_TRANSPORT_DTLSSCTP, true);
+ sdp_require_session_name(sipcc_config, false);
+
+ sdp_config_set_error_handler(sipcc_config, &sipcc_sdp_parser_error_handler,
+ this);
+
+ // Takes ownership of |sipcc_config| iff it succeeds
+ sdp_t *sdp = sdp_init_description(sipcc_config);
+ if (!sdp) {
+ sdp_free_config(sipcc_config);
+ return UniquePtr<Sdp>();
+ }
+
+ const char *rawString = sdpText.c_str();
+ sdp_result_e sdpres = sdp_parse(sdp, rawString, sdpText.length());
+ if (sdpres != SDP_SUCCESS) {
+ sdp_free_description(sdp);
+ return UniquePtr<Sdp>();
+ }
+
+ UniquePtr<SipccSdp> sipccSdp(new SipccSdp);
+
+ bool success = sipccSdp->Load(sdp, *this);
+ sdp_free_description(sdp);
+ if (!success) {
+ return UniquePtr<Sdp>();
+ }
+
+ return UniquePtr<Sdp>(Move(sipccSdp));
+}
+
+} // namespace mozilla
diff --git a/media/webrtc/signaling/src/sdp/SipccSdpParser.h b/media/webrtc/signaling/src/sdp/SipccSdpParser.h
new file mode 100644
index 000000000..f28780ddf
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/SipccSdpParser.h
@@ -0,0 +1,35 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef _SIPCCSDPPARSER_H_
+#define _SIPCCSDPPARSER_H_
+
+#include <string>
+
+#include "mozilla/UniquePtr.h"
+
+#include "signaling/src/sdp/Sdp.h"
+#include "signaling/src/sdp/SdpErrorHolder.h"
+
+namespace mozilla
+{
+
+class SipccSdpParser final : public SdpErrorHolder
+{
+public:
+ SipccSdpParser() {}
+ virtual ~SipccSdpParser() {}
+
+ /**
+ * This parses the provided text into an SDP object.
+ * This returns a nullptr-valued pointer if things go poorly.
+ */
+ UniquePtr<Sdp> Parse(const std::string& sdpText);
+};
+
+} // namespace mozilla
+
+#endif
diff --git a/media/webrtc/signaling/src/sdp/sipcc/ccsdp.h b/media/webrtc/signaling/src/sdp/sipcc/ccsdp.h
new file mode 100644
index 000000000..8a04d8f0b
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/ccsdp.h
@@ -0,0 +1,207 @@
+/* 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/. */
+
+#ifndef __CCSDP_H__
+#define __CCSDP_H__
+
+#include "cpr_types.h"
+#include "ccsdp_rtcp_fb.h"
+
+#define SIPSDP_ILBC_MODE20 20
+
+/**
+ * Return codes for sdp helper APIs
+ */
+typedef enum rtp_ptype_
+{
+ RTP_NONE = -1,
+ RTP_PCMU = 0,
+ RTP_CELP = 1,
+ RTP_G726 = 2,
+ RTP_GSM = 3,
+ RTP_G723 = 4,
+ RTP_DVI4 = 5,
+ RTP_DVI4_II = 6,
+ RTP_LPC = 7,
+ RTP_PCMA = 8,
+ RTP_G722 = 9,
+ RTP_G728 = 15,
+ RTP_G729 = 18,
+ RTP_JPEG = 26,
+ RTP_NV = 28,
+ RTP_H261 = 31,
+ RTP_H264_P0 = 97,
+ RTP_H264_P1 = 126,
+ RTP_TELEPHONE_EVENT = 101,
+ RTP_L16 = 102,
+ RTP_H263 = 103,
+ RTP_ILBC = 116, /* used only to make an offer */
+ RTP_OPUS = 109,
+ RTP_VP8 = 120,
+ RTP_VP9 = 121,
+ RTP_RED = 122,
+ RTP_ULPFEC = 123,
+ RTP_I420 = 124,
+ RTP_ISAC = 124
+} rtp_ptype;
+
+typedef struct {
+ const char *name;
+ int value;
+} ccsdp_key_table_entry_t;
+
+typedef enum max_coded_audio_bandwidth_ {
+ opus_nb = 0, /* Narrowband */
+ opus_mb = 1, /* Mediumband */
+ opus_wb = 2, /* Wideband */
+ opus_swb = 3, /* Super-wideband */
+ opus_fb = 4 /* Fullband */
+} max_coded_audio_bandwidth;
+
+static const ccsdp_key_table_entry_t max_coded_audio_bandwidth_table[] = {
+ {"nb", opus_nb},
+ {"mb", opus_mb},
+ {"wb", opus_wb},
+ {"swb", opus_swb},
+ {"fb", opus_fb}
+};
+
+typedef enum {
+ SDP_SUCCESS, /**< Success */
+ SDP_FAILURE,
+ SDP_INVALID_SDP_PTR,
+ SDP_NOT_SDP_DESCRIPTION,
+ SDP_INVALID_TOKEN_ORDERING,
+ SDP_INVALID_PARAMETER,
+ SDP_INVALID_MEDIA_LEVEL,
+ SDP_INVALID_CAPABILITY,
+ SDP_NO_RESOURCE,
+ SDP_UNRECOGNIZED_TOKEN,
+ SDP_NULL_BUF_PTR,
+ SDP_POTENTIAL_SDP_OVERFLOW,
+ SDP_EMPTY_TOKEN,
+ SDP_MAX_RC
+} sdp_result_e;
+
+/**
+ * Indicates invalid bandwidth value
+ */
+#define SDP_INVALID_VALUE (-2)
+
+/**
+ * Bandwidth modifier type for b= SDP line
+ */
+typedef enum {
+ SDP_BW_MODIFIER_INVALID = -1,
+ SDP_BW_MODIFIER_AS, /** < b=AS: */
+ SDP_BW_MODIFIER_CT, /** < b=CT: */
+ SDP_BW_MODIFIER_TIAS, /** < b=TIAS: */
+ SDP_MAX_BW_MODIFIER_VAL,
+ SDP_BW_MODIFIER_UNSUPPORTED
+} sdp_bw_modifier_e;
+
+/**
+ * SDP attribute types
+ */
+/* Attribute Types */
+typedef enum {
+ SDP_ATTR_BEARER = 0,
+ SDP_ATTR_CALLED,
+ SDP_ATTR_CONN_TYPE,
+ SDP_ATTR_DIALED,
+ SDP_ATTR_DIALING,
+ SDP_ATTR_DIRECTION,
+ SDP_ATTR_EECID,
+ SDP_ATTR_FMTP,
+ SDP_ATTR_SCTPMAP,
+ SDP_ATTR_FRAMING,
+ SDP_ATTR_INACTIVE,
+ SDP_ATTR_PTIME,
+ SDP_ATTR_QOS,
+ SDP_ATTR_CURR,
+ SDP_ATTR_DES,
+ SDP_ATTR_CONF,
+ SDP_ATTR_RECVONLY,
+ SDP_ATTR_RTPMAP,
+ SDP_ATTR_SECURE,
+ SDP_ATTR_SENDONLY,
+ SDP_ATTR_SENDRECV,
+ SDP_ATTR_SUBNET,
+ SDP_ATTR_T38_VERSION,
+ SDP_ATTR_T38_MAXBITRATE,
+ SDP_ATTR_T38_FILLBITREMOVAL,
+ SDP_ATTR_T38_TRANSCODINGMMR,
+ SDP_ATTR_T38_TRANSCODINGJBIG,
+ SDP_ATTR_T38_RATEMGMT,
+ SDP_ATTR_T38_MAXBUFFER,
+ SDP_ATTR_T38_MAXDGRAM,
+ SDP_ATTR_T38_UDPEC,
+ SDP_ATTR_X_CAP,
+ SDP_ATTR_X_CPAR,
+ SDP_ATTR_X_PC_CODEC,
+ SDP_ATTR_X_PC_QOS,
+ SDP_ATTR_X_QOS,
+ SDP_ATTR_X_SQN,
+ SDP_ATTR_TMRGWXID,
+ SDP_ATTR_TC1_PAYLOAD_BYTES,
+ SDP_ATTR_TC1_WINDOW_SIZE,
+ SDP_ATTR_TC2_PAYLOAD_BYTES,
+ SDP_ATTR_TC2_WINDOW_SIZE,
+ SDP_ATTR_RTCP,
+ SDP_ATTR_RTR,
+ SDP_ATTR_SILENCESUPP,
+ SDP_ATTR_SRTP_CONTEXT, /* version 2 sdescriptions */
+ SDP_ATTR_MPTIME,
+ SDP_ATTR_X_SIDIN,
+ SDP_ATTR_X_SIDOUT,
+ SDP_ATTR_X_CONFID,
+ SDP_ATTR_GROUP,
+ SDP_ATTR_MID,
+ SDP_ATTR_SOURCE_FILTER,
+ SDP_ATTR_RTCP_UNICAST,
+ SDP_ATTR_MAXPRATE,
+ SDP_ATTR_SQN,
+ SDP_ATTR_CDSC,
+ SDP_ATTR_CPAR,
+ SDP_ATTR_SPRTMAP,
+ SDP_ATTR_SDESCRIPTIONS, /* version 9 sdescriptions */
+ SDP_ATTR_LABEL,
+ SDP_ATTR_FRAMERATE,
+ SDP_ATTR_ICE_CANDIDATE,
+ SDP_ATTR_ICE_UFRAG,
+ SDP_ATTR_ICE_PWD,
+ SDP_ATTR_ICE_LITE,
+ SDP_ATTR_RTCP_MUX,
+ SDP_ATTR_DTLS_FINGERPRINT,
+ SDP_ATTR_MAXPTIME,
+ SDP_ATTR_RTCP_FB, /* RFC 4585 */
+ SDP_ATTR_SETUP,
+ SDP_ATTR_CONNECTION,
+ SDP_ATTR_EXTMAP, /* RFC 5285 */
+ SDP_ATTR_IDENTITY,
+ SDP_ATTR_MSID,
+ SDP_ATTR_MSID_SEMANTIC,
+ SDP_ATTR_BUNDLE_ONLY,
+ SDP_ATTR_END_OF_CANDIDATES,
+ SDP_ATTR_ICE_OPTIONS,
+ SDP_ATTR_SSRC,
+ SDP_ATTR_IMAGEATTR,
+ SDP_ATTR_SIMULCAST,
+ SDP_ATTR_RID,
+ SDP_ATTR_DTLS_MESSAGE,
+ SDP_MAX_ATTR_TYPES,
+ SDP_ATTR_INVALID
+} sdp_attr_e;
+
+typedef enum {
+ SDP_SETUP_NOT_FOUND = -1,
+ SDP_SETUP_ACTIVE = 0,
+ SDP_SETUP_PASSIVE,
+ SDP_SETUP_ACTPASS,
+ SDP_SETUP_HOLDCONN,
+ SDP_MAX_SETUP,
+ SDP_SETUP_UNKNOWN
+} sdp_setup_type_e;
+
+#endif
diff --git a/media/webrtc/signaling/src/sdp/sipcc/ccsdp_rtcp_fb.h b/media/webrtc/signaling/src/sdp/sipcc/ccsdp_rtcp_fb.h
new file mode 100644
index 000000000..5518521ba
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/ccsdp_rtcp_fb.h
@@ -0,0 +1,63 @@
+/* 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/. */
+
+#ifndef __CCSDP_RTCP_FB_H__
+#define __CCSDP_RTCP_FB_H__
+
+/* a=rtcp-fb enumerations */
+
+typedef enum {
+ SDP_RTCP_FB_ANY = -1,
+ SDP_RTCP_FB_ACK = 0,
+ SDP_RTCP_FB_CCM,
+ SDP_RTCP_FB_NACK,
+ SDP_RTCP_FB_TRR_INT,
+ // from https://www.ietf.org/archive/id/draft-alvestrand-rmcat-remb-03.txt
+ SDP_RTCP_FB_REMB,
+ SDP_MAX_RTCP_FB,
+ SDP_RTCP_FB_UNKNOWN
+} sdp_rtcp_fb_type_e;
+
+typedef enum {
+ SDP_RTCP_FB_NACK_NOT_FOUND = -1,
+ SDP_RTCP_FB_NACK_BASIC = 0,
+ SDP_RTCP_FB_NACK_SLI,
+ SDP_RTCP_FB_NACK_PLI,
+ SDP_RTCP_FB_NACK_RPSI,
+ SDP_RTCP_FB_NACK_APP,
+ SDP_RTCP_FB_NACK_RAI,
+ SDP_RTCP_FB_NACK_TLLEI,
+ SDP_RTCP_FB_NACK_PSLEI,
+ SDP_RTCP_FB_NACK_ECN,
+ SDP_MAX_RTCP_FB_NACK,
+ SDP_RTCP_FB_NACK_UNKNOWN
+} sdp_rtcp_fb_nack_type_e;
+
+typedef enum {
+ SDP_RTCP_FB_ACK_NOT_FOUND = -1,
+ SDP_RTCP_FB_ACK_RPSI = 0,
+ SDP_RTCP_FB_ACK_APP,
+ SDP_MAX_RTCP_FB_ACK,
+ SDP_RTCP_FB_ACK_UNKNOWN
+} sdp_rtcp_fb_ack_type_e;
+
+// Codec Control Messages - defined by RFC 5104
+typedef enum {
+ SDP_RTCP_FB_CCM_NOT_FOUND = -1,
+ SDP_RTCP_FB_CCM_FIR = 0,
+ SDP_RTCP_FB_CCM_TMMBR,
+ SDP_RTCP_FB_CCM_TSTR,
+ SDP_RTCP_FB_CCM_VBCM,
+ SDP_MAX_RTCP_FB_CCM,
+ SDP_RTCP_FB_CCM_UNKNOWN
+} sdp_rtcp_fb_ccm_type_e;
+
+#ifdef __cplusplus
+static_assert(SDP_MAX_RTCP_FB_NACK +
+ SDP_MAX_RTCP_FB_ACK +
+ SDP_MAX_RTCP_FB_CCM < 32,
+ "rtcp-fb Bitmap is larger than 32 bits");
+#endif
+
+#endif
diff --git a/media/webrtc/signaling/src/sdp/sipcc/cpr_darwin_types.h b/media/webrtc/signaling/src/sdp/sipcc/cpr_darwin_types.h
new file mode 100644
index 000000000..97a2644b5
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/cpr_darwin_types.h
@@ -0,0 +1,68 @@
+/* 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/. */
+
+#ifndef _CPR_DARWIN_TYPES_H_
+#define _CPR_DARWIN_TYPES_H_
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <stddef.h>
+#include "inttypes.h"
+
+
+/**
+ * @typedef boolean
+ *
+ * Define boolean as an unsigned byte
+ *
+ * @note There are differences within TNP header files
+ * @li curses.h: bool => char
+ * @li types.h: boolean_t => enum
+ * @li dki_lock.h: bool_t => int
+ */
+typedef uint8_t boolean;
+
+/*
+ * Define min/max
+ * defined in param.h
+ *
+ * The GNU versions of the MAX and MIN macros do two things better than
+ * the old versions:
+ * 1. they are more optimal as they only evaluate a & b once by creating a
+ * a variable of each type on the local stack.
+ * 2. they fix potential errors due to side-effects where a and b were
+ * evaluated twice, i.e. MIN(i++,j++)
+ *
+ * @note b could be cast to a's type, to help with usage where the code
+ * compares signed and unsigned types.
+ */
+#ifndef MIN
+#ifdef __GNUC__
+#define MIN(a,b) ({ typeof(a) _a = (a); typeof(b) _b = (b); _a < _b ? _a : _b; })
+#else
+#define MIN(a,b) (((a) < (b)) ? (a) : (b))
+#endif
+#endif
+
+#ifndef MAX
+#ifdef __GNUC__
+#define MAX(a,b) ({ typeof(a) _a = (a); typeof(b) _b = (b); _a > _b ? _a : _b; })
+#else
+#define MAX(a,b) (((a) > (b)) ? (a) : (b))
+#endif
+#endif
+
+/**
+ * Define TRUE/FALSE
+ * defined in several header files
+ */
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+#endif
diff --git a/media/webrtc/signaling/src/sdp/sipcc/cpr_linux_types.h b/media/webrtc/signaling/src/sdp/sipcc/cpr_linux_types.h
new file mode 100644
index 000000000..78f05f413
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/cpr_linux_types.h
@@ -0,0 +1,82 @@
+/* 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/. */
+
+#ifndef _CPR_LINUX_TYPES_H_
+#define _CPR_LINUX_TYPES_H_
+
+#include "sys/types.h"
+#include "stddef.h"
+#include "inttypes.h"
+
+/**
+ * @typedef boolean
+ *
+ * Define boolean as an unsigned byte
+ *
+ * @note There are differences within TNP header files
+ * @li curses.h: bool => char
+ * @li types.h: boolean_t => enum
+ * @li dki_lock.h: bool_t => int
+ */
+typedef uint8_t boolean;
+
+/*
+ * Define size_t
+ * defined in numerous header files
+ */
+/* DONE (sys/types.h => unsigned int) */
+
+/*
+ * Define ssize_t
+ */
+/* DONE (sys/types.h => int) */
+
+/*
+ * Define MIN/MAX
+ * defined in param.h
+ *
+ * The GNU versions of the MAX and MIN macros do two things better than
+ * the old versions:
+ * 1. they are more optimal as they only evaluate a & b once by creating a
+ * a variable of each type on the local stack.
+ * 2. they fix potential errors due to side-effects where a and b were
+ * evaluated twice, i.e. MIN(i++,j++)
+ *
+ * @note b could be cast to a's type, to help with usage where the code
+ * compares signed and unsigned types.
+ */
+#ifndef MIN
+#ifdef __GNUC__
+#define MIN(a,b) ({ typeof(a) _a = (a); typeof(b) _b = (b); _a < _b ? _a : _b; })
+#else
+#define MIN(a,b) (((a) < (b)) ? (a) : (b))
+#endif
+#endif
+
+#ifndef MAX
+#ifdef __GNUC__
+#define MAX(a,b) ({ typeof(a) _a = (a); typeof(b) _b = (b); _a > _b ? _a : _b; })
+#else
+#define MAX(a,b) (((a) > (b)) ? (a) : (b))
+#endif
+#endif
+
+/**
+ * Define TRUE/FALSE
+ * defined in several header files
+ */
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+/*
+ * Define offsetof
+ */
+/* DONE (stddef.h) */
+
+#endif
diff --git a/media/webrtc/signaling/src/sdp/sipcc/cpr_string.c b/media/webrtc/signaling/src/sdp/sipcc/cpr_string.c
new file mode 100644
index 000000000..c210c3971
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/cpr_string.c
@@ -0,0 +1,272 @@
+/* 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 <stdarg.h>
+
+#include "mozilla/Assertions.h"
+#include "cpr_types.h"
+#include "cpr_string.h"
+#include "cpr_strings.h"
+
+/* From cpr_stdlib.h */
+#include "mozilla/mozalloc.h"
+
+#define cpr_malloc(a) moz_xmalloc(a)
+#define cpr_calloc(a, b) moz_xcalloc(a, b)
+#define cpr_realloc(a, b) moz_xrealloc(a, b)
+#define cpr_free(a) free(a)
+
+
+/**
+ * sstrncpy
+ *
+ * This is Cisco's *safe* version of strncpy. The string will always
+ * be NUL terminated (which is not ANSI compliant).
+ *
+ * Parameters: s1 - first string
+ * s2 - second string
+ * max - maximum length in octets to concat.
+ *
+ * Return: Pointer to the *end* of the string
+ *
+ * Remarks: Modified to be explicitly safe for all inputs.
+ * Also return the number of characters copied excluding the
+ * NUL terminator vs. the original string s1. This simplifies
+ * code where sstrncat functions follow.
+ */
+unsigned long
+sstrncpy (char *dst, const char *src, unsigned long max)
+{
+ unsigned long cnt = 0;
+
+ if (dst == NULL) {
+ return 0;
+ }
+
+ if (src) {
+ while ((max-- > 1) && (*src)) {
+ *dst = *src;
+ dst++;
+ src++;
+ cnt++;
+ }
+ }
+
+#if defined(CPR_SSTRNCPY_PAD)
+ /*
+ * To be equivalent to the TI compiler version
+ * v2.01, SSTRNCPY_PAD needs to be defined
+ */
+ while (max-- > 1) {
+ *dst = '\0';
+ dst++;
+ }
+#endif
+ *dst = '\0';
+
+ return cnt;
+}
+
+/**
+ * sstrncat
+ *
+ * This is Cisco's *safe* version of strncat. The string will always
+ * be NUL terminated (which is not ANSI compliant).
+ *
+ * Parameters: s1 - first string
+ * s2 - second string
+ * max - maximum length in octets to concatenate
+ *
+ * Return: Pointer to the *end* of the string
+ *
+ * Remarks: Modified to be explicitly safe for all inputs.
+ * Also return the end vs. the beginning of the string s1
+ * which is useful for multiple sstrncat calls.
+ */
+char *
+sstrncat (char *s1, const char *s2, unsigned long max)
+{
+ if (s1 == NULL)
+ return (char *) NULL;
+
+ while (*s1)
+ s1++;
+
+ if (s2) {
+ while ((max-- > 1) && (*s2)) {
+ *s1 = *s2;
+ s1++;
+ s2++;
+ }
+ }
+ *s1 = '\0';
+
+ return s1;
+}
+
+/*
+ * flex_string
+ */
+
+/*
+ * flex_string_init
+ *
+ * Not thread-safe
+ */
+void flex_string_init(flex_string *fs) {
+ fs->buffer_length = FLEX_STRING_CHUNK_SIZE;
+ fs->string_length = 0;
+ fs->buffer = cpr_malloc(fs->buffer_length);
+ fs->buffer[0] = '\0';
+}
+
+/*
+ * flex_string_free
+ *
+ * Not thread-safe
+ */
+void flex_string_free(flex_string *fs) {
+ fs->buffer_length = 0;
+ fs->string_length = 0;
+ cpr_free(fs->buffer);
+ fs->buffer = NULL;
+}
+
+/* For sanity check before alloc */
+#define FLEX_STRING_MAX_SIZE (10 * 1024 * 1024) /* 10MB */
+
+/*
+ * flex_string_check_alloc
+ *
+ * Allocate enough chunks to hold the new minimum size.
+ *
+ * Not thread-safe
+ */
+void flex_string_check_alloc(flex_string *fs, size_t new_min_length) {
+ if (new_min_length > fs->buffer_length) {
+ /* Oversize, allocate more */
+
+ /* Sanity check on allocation size */
+ if (new_min_length > FLEX_STRING_MAX_SIZE) {
+ MOZ_CRASH();
+ }
+
+ /* Alloc to nearest chunk */
+ fs->buffer_length = (((new_min_length - 1) / FLEX_STRING_CHUNK_SIZE) + 1) * FLEX_STRING_CHUNK_SIZE;
+
+ fs->buffer = cpr_realloc(fs->buffer, fs->buffer_length);
+ }
+}
+
+/*
+ * flex_string_append
+ *
+ * Not thread-safe
+ */
+void flex_string_append(flex_string *fs, const char *more) {
+ fs->string_length += strlen(more);
+
+ flex_string_check_alloc(fs, fs->string_length + 1);
+
+ sstrncat(fs->buffer, more, fs->buffer_length - strlen(fs->buffer));
+}
+
+/*
+ * va_copy is part of the C99 spec but MSVC doesn't have it.
+ */
+#ifndef va_copy
+#define va_copy(d,s) ((d) = (s))
+#endif
+
+/*
+ * flex_string_vsprintf
+ *
+ * Not thread-safe
+ */
+void flex_string_vsprintf(flex_string *fs, const char *format, va_list original_ap) {
+ va_list ap;
+ int vsnprintf_result;
+
+ va_copy(ap, original_ap);
+ vsnprintf_result = vsnprintf(fs->buffer + fs->string_length, fs->buffer_length - fs->string_length, format, ap);
+ va_end(ap);
+
+ /* Special case just for Windows where vsnprintf is broken
+ and returns -1 if buffer too large unless you size it 0. */
+ if (vsnprintf_result < 0) {
+ va_copy(ap, original_ap);
+ vsnprintf_result = vsnprintf(NULL, 0, format, ap);
+ va_end(ap);
+ }
+
+ if (fs->string_length + vsnprintf_result >= fs->buffer_length) {
+ /* Buffer overflow, resize */
+ flex_string_check_alloc(fs, fs->string_length + vsnprintf_result + 1);
+
+ /* Try again with new buffer */
+ va_copy(ap, original_ap);
+ vsnprintf_result = vsnprintf(fs->buffer + fs->string_length, fs->buffer_length - fs->string_length, format, ap);
+ va_end(ap);
+ MOZ_ASSERT(vsnprintf_result > 0 &&
+ (size_t)vsnprintf_result < (fs->buffer_length - fs->string_length));
+ }
+
+ if (vsnprintf_result > 0) {
+ fs->string_length += vsnprintf_result;
+ }
+}
+
+/*
+ * flex_string_sprintf
+ *
+ * Not thread-safe
+ */
+void flex_string_sprintf(flex_string *fs, const char *format, ...) {
+ va_list ap;
+
+ va_start(ap, format);
+ flex_string_vsprintf(fs, format, ap);
+ va_end(ap);
+}
+
+
+
+/* From cpr_linux_string.c */
+/**
+ * cpr_strdup
+ *
+ * @brief The CPR wrapper for strdup
+
+ * The cpr_strdup shall return a pointer to a new string, which is a duplicate
+ * of the string pointed to by "str" argument. A null pointer is returned if the
+ * new string cannot be created.
+ *
+ * @param[in] str - The string that needs to be duplicated
+ *
+ * @return The duplicated string or NULL in case of no memory
+ *
+ */
+char *
+cpr_strdup (const char *str)
+{
+ char *dup;
+ size_t len;
+
+ if (!str) {
+ return (char *) NULL;
+ }
+
+ len = strlen(str);
+ if (len == 0) {
+ return (char *) NULL;
+ }
+ len++;
+
+ dup = cpr_malloc(len * sizeof(char));
+ if (!dup) {
+ return (char *) NULL;
+ }
+ (void) memcpy(dup, str, len);
+ return dup;
+}
diff --git a/media/webrtc/signaling/src/sdp/sipcc/cpr_string.h b/media/webrtc/signaling/src/sdp/sipcc/cpr_string.h
new file mode 100644
index 000000000..de6b1cc8a
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/cpr_string.h
@@ -0,0 +1,139 @@
+/* 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/. */
+
+#ifndef _CPR_STRING_H_
+#define _CPR_STRING_H_
+
+#include <stdarg.h>
+
+#include "cpr_types.h"
+#include "cpr_strings.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * sstrncpy
+ *
+ * @brief The CPR wrapper for strncpy
+ *
+ * This is Cisco's *safe* version of strncpy. The string will always
+ * be NUL terminated (which is not ANSI compliant).
+ *
+ * @param[in] dst - The destination string
+ * @param[in] src - The source
+ * @param[in] max - maximum length in octets to concatenate
+ *
+ * @return Pointer to the @b end of the string
+ *
+ * @note Modified to be explicitly safe for all inputs.
+ * Also return the number of characters copied excluding the
+ * NUL terminator vs. the original string s1. This simplifies
+ * code where sstrncat functions follow.
+ */
+unsigned long
+sstrncpy(char *dst, const char *src, unsigned long max);
+
+
+/**
+ * sstrncat
+ *
+ * @brief The CPR wrapper for strncat
+ *
+ * This is Cisco's *safe* version of strncat. The string will always
+ * be NUL terminated (which is not ANSI compliant).
+ *
+ * @param[in] s1 - first string
+ * @param[in] s2 - second string
+ * @param[in] max - maximum length in octets to concatenate
+ *
+ * @return Pointer to the @b end of the string
+ *
+ * @note Modified to be explicitly safe for all inputs.
+ * Also return the end vs. the beginning of the string s1
+ * which is useful for multiple sstrncat calls.
+ */
+char *
+sstrncat(char *s1, const char *s2, unsigned long max);
+
+
+/*
+ * flex_string
+ */
+#define FLEX_STRING_CHUNK_SIZE 256
+
+typedef struct {
+ char *buffer;
+ size_t buffer_length;
+ size_t string_length;
+} flex_string;
+
+/*
+ * flex_string_init
+ *
+ * Not thread-safe
+ */
+void flex_string_init(flex_string *fs);
+
+/*
+ * flex_string_free
+ *
+ * Not thread-safe
+ */
+void flex_string_free(flex_string *fs);
+
+/*
+ * flex_string_check_alloc
+ *
+ * Allocate enough chunks to hold the new minimum size.
+ *
+ * Not thread-safe
+ */
+void flex_string_check_alloc(flex_string *fs, size_t new_min_length);
+
+/*
+ * flex_string_append
+ *
+ * Not thread-safe
+ */
+void flex_string_append(flex_string *fs, const char *more);
+
+/*
+ * flex_string_sprintf
+ *
+ * Not thread-safe
+ */
+void flex_string_vsprintf(flex_string *fs, const char *format, va_list original_ap);
+
+/*
+ * flex_string_sprintf
+ *
+ * Not thread-safe
+ */
+void flex_string_sprintf(flex_string *fs, const char *format, ...);
+
+
+/* From cpr_linux_string.h */
+/* cpr_strdup
+ *
+ * @brief The CPR wrapper for strdup
+
+ * The cpr_strdup shall return a pointer to a new string, which is a duplicate
+ * of the string pointed to by "str" argument. A null pointer is returned if the
+ * new string cannot be created.
+ *
+ * @param[in] str - The string that needs to be duplicated
+ *
+ * @return The duplicated string or NULL in case of no memory
+ *
+ */
+char *
+cpr_strdup(const char *str);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/media/webrtc/signaling/src/sdp/sipcc/cpr_strings.h b/media/webrtc/signaling/src/sdp/sipcc/cpr_strings.h
new file mode 100644
index 000000000..2d18d4638
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/cpr_strings.h
@@ -0,0 +1,22 @@
+/* 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/. */
+
+#ifndef _CPR_STRINGS_H_
+#define _CPR_STRINGS_H_
+
+#include "cpr_types.h"
+
+#include <string.h>
+
+#if defined(_MSC_VER)
+#define cpr_strcasecmp _stricmp
+#define cpr_strncasecmp _strnicmp
+#else // _MSC_VER
+
+#define cpr_strcasecmp strcasecmp
+#define cpr_strncasecmp strncasecmp
+
+#endif // _MSC_VER
+
+#endif
diff --git a/media/webrtc/signaling/src/sdp/sipcc/cpr_types.h b/media/webrtc/signaling/src/sdp/sipcc/cpr_types.h
new file mode 100644
index 000000000..808067e61
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/cpr_types.h
@@ -0,0 +1,126 @@
+/* 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/. */
+
+#ifndef _CPR_TYPES_H_
+#define _CPR_TYPES_H_
+
+#if defined SIP_OS_LINUX
+#include "cpr_linux_types.h"
+#elif defined SIP_OS_WINDOWS
+#include "cpr_win_types.h"
+#elif defined SIP_OS_OSX
+#include "cpr_darwin_types.h"
+#else
+//lol
+//#error "Unsupported platform"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * CPR Return Codes
+ */
+typedef enum
+{
+ CPR_SUCCESS,
+ CPR_FAILURE
+} cpr_status_e;
+typedef cpr_status_e cprRC_t;
+
+/*
+ * IPv4 address structure
+ */
+typedef uint32_t cpr_in_addr_t;
+
+struct in_addr_s
+{
+#ifdef s_addr
+ /* can occur with Windows winsock.h */
+ union {
+ struct {
+ unsigned char s_b1, s_b2, sb_b3, s_b4;
+ } S_un_b;
+ cpr_in_addr_t S_addr;
+ } S_un;
+#else
+ cpr_in_addr_t s_addr;
+#endif
+};
+
+/*
+ * IPv6 address structure
+ */
+typedef struct
+{
+ union
+ {
+ uint8_t base8[16];
+ uint16_t base16[8];
+ uint32_t base32[4];
+ } addr;
+} cpr_in6_addr_t;
+
+#ifndef s6_addr
+#define s6_addr addr.base8
+#endif
+#ifndef s6_addr16
+#define s6_addr16 addr.base16
+#endif
+#ifndef s6_addr32
+#define s6_addr32 addr.base32
+#endif
+
+typedef enum
+{
+ CPR_IP_ADDR_INVALID=0,
+ CPR_IP_ADDR_IPV4,
+ CPR_IP_ADDR_IPV6
+} cpr_ip_type;
+
+typedef enum
+{
+ CPR_IP_MODE_IPV4 = 0,
+ CPR_IP_MODE_IPV6,
+ CPR_IP_MODE_DUAL
+}
+cpr_ip_mode_e;
+/*
+ * IP address structure
+ */
+typedef struct
+{
+ cpr_ip_type type;
+ union
+ {
+ cpr_in_addr_t ip4;
+ cpr_in6_addr_t ip6;
+ } u;
+} cpr_ip_addr_t;
+
+extern const cpr_ip_addr_t ip_addr_invalid;
+
+#define MAX_IPADDR_STR_LEN 48
+
+
+#define CPR_IP_ADDR_INIT(a) a.type = CPR_IP_ADDR_INVALID;
+
+/*
+ * !!! NOTE !!!
+ *
+ * The strings of type string_t are actually very special blocks
+ * of memory that have a "hidden" header block immediately preceding
+ * the pointer. You MUST use the functions in string_lib.c to
+ * create, manipulate, destroy, copy, or otherwise work with these
+ * strings.
+ */
+
+typedef const char *string_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/media/webrtc/signaling/src/sdp/sipcc/cpr_win_types.h b/media/webrtc/signaling/src/sdp/sipcc/cpr_win_types.h
new file mode 100644
index 000000000..c4dfa0b72
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/cpr_win_types.h
@@ -0,0 +1,71 @@
+/* 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/. */
+
+#ifndef _CPR_WIN_TYPES_H_
+#define _CPR_WIN_TYPES_H_
+
+#include <sys/types.h>
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <windows.h>
+#ifdef SIPCC_BUILD
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <windef.h>
+#endif
+#include <stddef.h>
+#include <stdlib.h>
+
+/*
+ * Define POSIX types
+ * [u]int[8,16,32,64]_t
+ */
+#include <stdint.h>
+
+/*
+ * Define boolean
+ * in windef.h: BOOL => int
+ */
+typedef uint8_t boolean;
+
+/*
+ * Define ssize_t if required. The MinGW W32API already defines ssize_t
+ * in <sys/types.h> (protected by _SSIZE_T_) so this will only apply to
+ * Microsoft SDK.
+ *
+ * NOTE: size_t should already be declared by both the MinGW and Microsoft
+ * SDKs.
+ */
+#ifndef _SSIZE_T_
+#define _SSIZE_T_
+typedef int ssize_t;
+#endif
+
+/*
+ * Define pid_t.
+ */
+typedef int pid_t;
+
+/*
+ * Define min/max
+ * defined in windef.h as lowercase
+ */
+#ifndef MIN
+#define MIN min
+#endif
+
+#ifndef MAX
+#define MAX max
+#endif
+
+/*
+ * Define NULL
+ * defined in numerous header files
+ */
+/* DONE defined in windef.h */
+
+#endif // _CPR_WIN_TYPES_H_
diff --git a/media/webrtc/signaling/src/sdp/sipcc/sdp.h b/media/webrtc/signaling/src/sdp/sipcc/sdp.h
new file mode 100644
index 000000000..9bd2ce132
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/sdp.h
@@ -0,0 +1,1794 @@
+/* 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/. */
+
+#ifndef _SIPCC_SDP_H_
+#define _SIPCC_SDP_H_
+
+#include "sdp_os_defs.h"
+#include "ccsdp.h"
+
+/* SDP Defines */
+
+/* The following defines are used to indicate params that are specified
+ * as the choose parameter or parameters that are invalid. These can
+ * be used where the value required is really a uint16_t, but is represented
+ * by an int32_t.
+ */
+#define SDP_CHOOSE_PARAM (-1)
+#define SDP_SESSION_LEVEL 0xFFFF
+
+#define UNKNOWN_CRYPTO_SUITE "UNKNOWN_CRYPTO_SUITE"
+#define AES_CM_128_HMAC_SHA1_32 "AES_CM_128_HMAC_SHA1_32"
+#define AES_CM_128_HMAC_SHA1_80 "AES_CM_128_HMAC_SHA1_80"
+#define F8_128_HMAC_SHA1_80 "F8_128_HMAC_SHA1_80"
+
+/* Pulled in from rtp_defs.h. */
+#define GET_DYN_PAYLOAD_TYPE_VALUE(a) ((a & 0XFF00) ? ((a & 0XFF00) >> 8) : a)
+#define SET_PAYLOAD_TYPE_WITH_DYNAMIC(a,b) ((a << 8) | b)
+
+/*
+ * SDP_SRTP_MAX_KEY_SIZE_BYTES
+ * Maximum size for a SRTP Master Key in bytes.
+ */
+#define SDP_SRTP_MAX_KEY_SIZE_BYTES 16
+/*
+ * SDP_SRTP_MAX_SALT_SIZE_BYTES
+ * Maximum size for a SRTP Master Salt in bytes.
+ */
+#define SDP_SRTP_MAX_SALT_SIZE_BYTES 14
+/*
+ * SDP_SRTP_MAX_MKI_SIZE_BYTES
+ * Maximum size for a SRTP Master Key Index in bytes.
+ */
+#define SDP_SRTP_MAX_MKI_SIZE_BYTES 4
+
+/* Max number of characters for Lifetime */
+#define SDP_SRTP_MAX_LIFETIME_BYTES 16
+
+#define SDP_SDESCRIPTIONS_KEY_SIZE_UNKNOWN 0
+#define SDP_SRTP_CRYPTO_SELECTION_FLAGS_UNKNOWN 0
+
+/* Max number of fmtp redundant encodings */
+#define SDP_FMTP_MAX_REDUNDANT_ENCODINGS 128
+
+/*
+ * SRTP_CONTEXT_SET_*
+ * Set a SRTP Context field flag
+ */
+#define SDP_SRTP_ENCRYPT_MASK 0x00000001
+#define SDP_SRTP_AUTHENTICATE_MASK 0x00000002
+#define SDP_SRTCP_ENCRYPT_MASK 0x00000004
+#define SDP_SRTCP_SSRC_MASK 0x20000000
+#define SDP_SRTCP_ROC_MASK 0x10000000
+#define SDP_SRTCP_KDR_MASK 0x08000000
+#define SDP_SRTCP_KEY_MASK 0x80000000
+#define SDP_SRTCP_SALT_MASK 0x40000000
+
+#define SDP_SRTP_CONTEXT_SET_SSRC(cw) ((cw) |= SDP_SRTCP_SSRC_MASK)
+#define SDP_SRTP_CONTEXT_SET_ROC(cw) ((cw) |= SDP_SRTCP_ROC_MASK)
+#define SDP_SRTP_CONTEXT_SET_KDR(cw) ((cw) |= SDP_SRTCP_KDR_MASK)
+#define SDP_SRTP_CONTEXT_SET_MASTER_KEY(cw) ((cw) |= SDP_SRTCP_KEY_MASK)
+#define SDP_SRTP_CONTEXT_SET_MASTER_SALT(cw) ((cw) |= SDP_SRTCP_SALT_MASK)
+#define SDP_SRTP_CONTEXT_SET_ENCRYPT_AUTHENTICATE(cw) \
+ ((cw) |= (SDP_SRTP_ENCRYPT_MASK | SDP_SRTP_AUTHENTICATE_MASK | \
+ SDP_SRTCP_ENCRYPT_MASK))
+#define SDP_SRTP_CONTEXT_RESET_SSRC(cw) ((cw) &= ~(SDP_SRTCP_SSRC_MASK))
+#define SDP_SRTP_CONTEXT_RESET_ROC(cw) ((cw) &= ~(SDP_SRTCP_ROC_MASK))
+#define SDP_SRTP_CONTEXT_RESET_KDR(cw) ((cw) &= ~(SDP_SRTCP_KDR_MASK))
+#define SDP_CONTEXT_RESET_MASTER_KEY(cw) ((cw) &= ~(SDP_SRTCP_KEY_MASK))
+#define SDP_CONTEXT_RESET_MASTER_SALT(cw) ((cw) &= ~(SDP_SRTCP_SALT_MASK))
+#define SDP_EXTMAP_AUDIO_LEVEL "urn:ietf:params:rtp-hdrext:ssrc-audio-level"
+
+/* SDP Enum Types */
+typedef enum {
+ SDP_DEBUG_TRACE,
+ SDP_DEBUG_WARNINGS,
+ SDP_DEBUG_ERRORS,
+ SDP_MAX_DEBUG_TYPES
+} sdp_debug_e;
+
+typedef enum {
+ SDP_CHOOSE_CONN_ADDR,
+ SDP_CHOOSE_PORTNUM,
+ SDP_MAX_CHOOSE_PARAMS
+} sdp_choose_param_e;
+
+
+/* Token Lines - these must be in the same order they should
+ * appear in an SDP.
+ */
+typedef enum {
+ SDP_TOKEN_V = 0,
+ SDP_TOKEN_O,
+ SDP_TOKEN_S,
+ SDP_TOKEN_I,
+ SDP_TOKEN_U,
+ SDP_TOKEN_E,
+ SDP_TOKEN_P,
+ SDP_TOKEN_C,
+ SDP_TOKEN_B,
+ SDP_TOKEN_T,
+ SDP_TOKEN_R,
+ SDP_TOKEN_Z,
+ SDP_TOKEN_K,
+ SDP_TOKEN_A,
+ SDP_TOKEN_M,
+ SDP_MAX_TOKENS
+} sdp_token_e;
+
+/* Media Types */
+typedef enum {
+ SDP_MEDIA_AUDIO = 0,
+ SDP_MEDIA_VIDEO,
+ SDP_MEDIA_APPLICATION,
+ SDP_MEDIA_DATA,
+ SDP_MEDIA_CONTROL,
+ SDP_MEDIA_NAS_RADIUS,
+ SDP_MEDIA_NAS_TACACS,
+ SDP_MEDIA_NAS_DIAMETER,
+ SDP_MEDIA_NAS_L2TP,
+ SDP_MEDIA_NAS_LOGIN,
+ SDP_MEDIA_NAS_NONE,
+ SDP_MEDIA_TEXT,
+ SDP_MEDIA_IMAGE,
+ SDP_MAX_MEDIA_TYPES,
+ SDP_MEDIA_UNSUPPORTED,
+ SDP_MEDIA_INVALID
+} sdp_media_e;
+
+
+/* Connection Network Type */
+typedef enum {
+ SDP_NT_INTERNET = 0, /* 0 -> IP - In SDP "IN" is defined */
+ /* to mean "Internet" */
+ SDP_NT_ATM, /* 1 -> ATM */
+ SDP_NT_FR, /* 2 -> FRAME RELAY */
+ SDP_NT_LOCAL, /* 3 -> local */
+ SDP_MAX_NETWORK_TYPES,
+ SDP_NT_UNSUPPORTED,
+ SDP_NT_INVALID
+} sdp_nettype_e;
+
+
+/* Address Type */
+typedef enum {
+ SDP_AT_IP4 = 0, /* 0 -> IP Version 4 (IP4) */
+ SDP_AT_IP6, /* 1 -> IP Version 6 (IP6) */
+ SDP_AT_NSAP, /* 2 -> 20 byte NSAP address */
+ SDP_AT_EPN, /* 3 -> 32 bytes of endpoint name */
+ SDP_AT_E164, /* 4 -> 15 digit decimal number addr */
+ SDP_AT_GWID, /* 5 -> Private gw id. ASCII string */
+ SDP_MAX_ADDR_TYPES,
+ SDP_AT_UNSUPPORTED,
+ SDP_AT_FQDN,
+ SDP_AT_INVALID
+} sdp_addrtype_e;
+
+
+/* Transport Types */
+
+#define SDP_MAX_PROFILES 3
+
+typedef enum {
+ SDP_TRANSPORT_RTPAVP = 0,
+ SDP_TRANSPORT_UDP,
+ SDP_TRANSPORT_UDPTL,
+ SDP_TRANSPORT_CES10,
+ SDP_TRANSPORT_LOCAL,
+ SDP_TRANSPORT_AAL2_ITU,
+ SDP_TRANSPORT_AAL2_ATMF,
+ SDP_TRANSPORT_AAL2_CUSTOM,
+ SDP_TRANSPORT_AAL1AVP,
+ SDP_TRANSPORT_UDPSPRT,
+ SDP_TRANSPORT_RTPSAVP,
+ SDP_TRANSPORT_TCP,
+ SDP_TRANSPORT_RTPSAVPF,
+ SDP_TRANSPORT_DTLSSCTP,
+ SDP_TRANSPORT_RTPAVPF,
+ SDP_TRANSPORT_UDPTLSRTPSAVP,
+ SDP_TRANSPORT_UDPTLSRTPSAVPF,
+ SDP_TRANSPORT_TCPTLSRTPSAVP,
+ SDP_TRANSPORT_TCPTLSRTPSAVPF,
+ SDP_MAX_TRANSPORT_TYPES,
+ SDP_TRANSPORT_UNSUPPORTED,
+ SDP_TRANSPORT_INVALID
+} sdp_transport_e;
+
+
+/* Encryption KeyType */
+typedef enum {
+ SDP_ENCRYPT_CLEAR, /* 0 -> Key given in the clear */
+ SDP_ENCRYPT_BASE64, /* 1 -> Base64 encoded key */
+ SDP_ENCRYPT_URI, /* 2 -> Ptr to URI */
+ SDP_ENCRYPT_PROMPT, /* 3 -> No key included, prompt user */
+ SDP_MAX_ENCRYPT_TYPES,
+ SDP_ENCRYPT_UNSUPPORTED,
+ SDP_ENCRYPT_INVALID
+} sdp_encrypt_type_e;
+
+
+/* Known string payload types */
+typedef enum {
+ SDP_PAYLOAD_T38,
+ SDP_PAYLOAD_XTMR,
+ SDP_PAYLOAD_T120,
+ SDP_MAX_STRING_PAYLOAD_TYPES,
+ SDP_PAYLOAD_UNSUPPORTED,
+ SDP_PAYLOAD_INVALID
+} sdp_payload_e;
+
+
+/* Payload type indicator */
+typedef enum {
+ SDP_PAYLOAD_NUMERIC,
+ SDP_PAYLOAD_ENUM
+} sdp_payload_ind_e;
+
+
+/* Image payload types */
+typedef enum {
+ SDP_PORT_NUM_ONLY, /* <port> or '$' */
+ SDP_PORT_NUM_COUNT, /* <port>/<number of ports> */
+ SDP_PORT_VPI_VCI, /* <vpi>/<vci> */
+ SDP_PORT_VCCI, /* <vcci> */
+ SDP_PORT_NUM_VPI_VCI, /* <port>/<vpi>/<vci> */
+ SDP_PORT_VCCI_CID, /* <vcci>/<cid> or '$'/'$' */
+ SDP_PORT_NUM_VPI_VCI_CID, /* <port>/<vpi>/<vci>/<cid> */
+ SDP_MAX_PORT_FORMAT_TYPES,
+ SDP_PORT_FORMAT_INVALID
+} sdp_port_format_e;
+
+
+/* Fmtp attribute format Types */
+typedef enum {
+ SDP_FMTP_NTE,
+ SDP_FMTP_CODEC_INFO,
+ SDP_FMTP_MODE,
+ SDP_FMTP_DATACHANNEL,
+ SDP_FMTP_UNKNOWN_TYPE,
+ SDP_FMTP_MAX_TYPE
+} sdp_fmtp_format_type_e;
+
+
+/* T.38 Rate Mgmt Types */
+typedef enum {
+ SDP_T38_LOCAL_TCF,
+ SDP_T38_TRANSFERRED_TCF,
+ SDP_T38_UNKNOWN_RATE,
+ SDP_T38_MAX_RATES
+} sdp_t38_ratemgmt_e;
+
+
+/* T.38 udp EC Types */
+typedef enum {
+ SDP_T38_UDP_REDUNDANCY,
+ SDP_T38_UDP_FEC,
+ SDP_T38_UDPEC_UNKNOWN,
+ SDP_T38_MAX_UDPEC
+} sdp_t38_udpec_e;
+
+/* Bitmaps for manipulating sdp_direction_e */
+typedef enum {
+ SDP_DIRECTION_FLAG_SEND=0x01,
+ SDP_DIRECTION_FLAG_RECV=0x02
+} sdp_direction_flag_e;
+
+/* Media flow direction */
+typedef enum {
+ SDP_DIRECTION_INACTIVE = 0,
+ SDP_DIRECTION_SENDONLY = SDP_DIRECTION_FLAG_SEND,
+ SDP_DIRECTION_RECVONLY = SDP_DIRECTION_FLAG_RECV,
+ SDP_DIRECTION_SENDRECV = SDP_DIRECTION_FLAG_SEND | SDP_DIRECTION_FLAG_RECV,
+ SDP_MAX_QOS_DIRECTIONS
+} sdp_direction_e;
+
+#define SDP_DIRECTION_PRINT(arg) \
+ (((sdp_direction_e)(arg)) == SDP_DIRECTION_INACTIVE ? "SDP_DIRECTION_INACTIVE " : \
+ ((sdp_direction_e)(arg)) == SDP_DIRECTION_SENDONLY ? "SDP_DIRECTION_SENDONLY": \
+ ((sdp_direction_e)(arg)) == SDP_DIRECTION_RECVONLY ? "SDP_DIRECTION_RECVONLY ": \
+ ((sdp_direction_e)(arg)) == SDP_DIRECTION_SENDRECV ? " SDP_DIRECTION_SENDRECV": "SDP_MAX_QOS_DIRECTIONS")
+
+
+/* QOS Strength tag */
+typedef enum {
+ SDP_QOS_STRENGTH_OPT,
+ SDP_QOS_STRENGTH_MAND,
+ SDP_QOS_STRENGTH_SUCC,
+ SDP_QOS_STRENGTH_FAIL,
+ SDP_QOS_STRENGTH_NONE,
+ SDP_MAX_QOS_STRENGTH,
+ SDP_QOS_STRENGTH_UNKNOWN
+} sdp_qos_strength_e;
+
+
+/* QOS direction */
+typedef enum {
+ SDP_QOS_DIR_SEND,
+ SDP_QOS_DIR_RECV,
+ SDP_QOS_DIR_SENDRECV,
+ SDP_QOS_DIR_NONE,
+ SDP_MAX_QOS_DIR,
+ SDP_QOS_DIR_UNKNOWN
+} sdp_qos_dir_e;
+
+/* QoS Status types */
+typedef enum {
+ SDP_QOS_LOCAL,
+ SDP_QOS_REMOTE,
+ SDP_QOS_E2E,
+ SDP_MAX_QOS_STATUS_TYPES,
+ SDP_QOS_STATUS_TYPE_UNKNOWN
+} sdp_qos_status_types_e;
+
+/* QoS Status types */
+typedef enum {
+ SDP_CURR_QOS_TYPE,
+ SDP_CURR_UNKNOWN_TYPE,
+ SDP_MAX_CURR_TYPES
+} sdp_curr_type_e;
+
+/* QoS Status types */
+typedef enum {
+ SDP_DES_QOS_TYPE,
+ SDP_DES_UNKNOWN_TYPE,
+ SDP_MAX_DES_TYPES
+} sdp_des_type_e;
+
+/* QoS Status types */
+typedef enum {
+ SDP_CONF_QOS_TYPE,
+ SDP_CONF_UNKNOWN_TYPE,
+ SDP_MAX_CONF_TYPES
+} sdp_conf_type_e;
+
+
+/* Named event range result values. */
+typedef enum {
+ SDP_NO_MATCH,
+ SDP_PARTIAL_MATCH,
+ SDP_FULL_MATCH
+} sdp_ne_res_e;
+
+/* Fmtp attribute parameters for audio/video codec information */
+typedef enum {
+
+ /* mainly for audio codecs */
+ SDP_ANNEX_A, /* 0 */
+ SDP_ANNEX_B,
+ SDP_BITRATE,
+
+ /* for video codecs */
+ SDP_QCIF,
+ SDP_CIF,
+ SDP_MAXBR,
+ SDP_SQCIF,
+ SDP_CIF4,
+ SDP_CIF16,
+ SDP_CUSTOM,
+ SDP_PAR,
+ SDP_CPCF,
+ SDP_BPP,
+ SDP_HRD,
+ SDP_PROFILE,
+ SDP_LEVEL,
+ SDP_INTERLACE,
+
+ /* H.264 related */
+ SDP_PROFILE_LEVEL_ID, /* 17 */
+ SDP_PARAMETER_SETS,
+ SDP_PACKETIZATION_MODE,
+ SDP_INTERLEAVING_DEPTH,
+ SDP_DEINT_BUF_REQ,
+ SDP_MAX_DON_DIFF,
+ SDP_INIT_BUF_TIME,
+
+ SDP_MAX_MBPS,
+ SDP_MAX_FS,
+ SDP_MAX_CPB,
+ SDP_MAX_DPB,
+ SDP_MAX_BR,
+ SDP_REDUNDANT_PIC_CAP,
+ SDP_DEINT_BUF_CAP,
+ SDP_MAX_RCMD_NALU_SIZE,
+
+ SDP_PARAMETER_ADD,
+
+ /* Annexes - begin */
+ /* Some require special handling as they don't have token=token format*/
+ SDP_ANNEX_D,
+ SDP_ANNEX_F,
+ SDP_ANNEX_I,
+ SDP_ANNEX_J,
+ SDP_ANNEX_T,
+
+ /* These annexes have token=token format */
+ SDP_ANNEX_K,
+ SDP_ANNEX_N,
+ SDP_ANNEX_P,
+
+ SDP_MODE,
+ SDP_LEVEL_ASYMMETRY_ALLOWED,
+ SDP_MAX_AVERAGE_BIT_RATE,
+ SDP_USED_TX,
+ SDP_STEREO,
+ SDP_USE_IN_BAND_FEC,
+ SDP_MAX_CODED_AUDIO_BW,
+ SDP_CBR,
+ SDP_MAX_FR,
+ SDP_MAX_PLAYBACK_RATE,
+ SDP_MAX_FMTP_PARAM,
+ SDP_FMTP_PARAM_UNKNOWN
+} sdp_fmtp_codec_param_e;
+
+/* Fmtp attribute parameters values for
+ fmtp attribute parameters which convey codec
+ information */
+
+typedef enum {
+ SDP_YES,
+ SDP_NO,
+ SDP_MAX_FMTP_PARAM_VAL,
+ SDP_FMTP_PARAM_UNKNOWN_VAL
+} sdp_fmtp_codec_param_val_e;
+
+/* silenceSupp suppPref */
+typedef enum {
+ SDP_SILENCESUPP_PREF_STANDARD,
+ SDP_SILENCESUPP_PREF_CUSTOM,
+ SDP_SILENCESUPP_PREF_NULL, /* "-" */
+ SDP_MAX_SILENCESUPP_PREF,
+ SDP_SILENCESUPP_PREF_UNKNOWN
+} sdp_silencesupp_pref_e;
+
+/* silenceSupp sidUse */
+typedef enum {
+ SDP_SILENCESUPP_SIDUSE_NOSID,
+ SDP_SILENCESUPP_SIDUSE_FIXED,
+ SDP_SILENCESUPP_SIDUSE_SAMPLED,
+ SDP_SILENCESUPP_SIDUSE_NULL, /* "-" */
+ SDP_MAX_SILENCESUPP_SIDUSE,
+ SDP_SILENCESUPP_SIDUSE_UNKNOWN
+} sdp_silencesupp_siduse_e;
+
+typedef enum {
+ SDP_MEDIADIR_ROLE_PASSIVE,
+ SDP_MEDIADIR_ROLE_ACTIVE,
+ SDP_MEDIADIR_ROLE_BOTH,
+ SDP_MEDIADIR_ROLE_REUSE,
+ SDP_MEDIADIR_ROLE_UNKNOWN,
+ SDP_MAX_MEDIADIR_ROLES,
+ SDP_MEDIADIR_ROLE_UNSUPPORTED,
+ SDP_MEDIADIR_ROLE_INVALID
+} sdp_mediadir_role_e;
+
+typedef enum {
+ SDP_GROUP_ATTR_FID,
+ SDP_GROUP_ATTR_LS,
+ SDP_GROUP_ATTR_ANAT,
+ SDP_GROUP_ATTR_BUNDLE,
+ SDP_MAX_GROUP_ATTR_VAL,
+ SDP_GROUP_ATTR_UNSUPPORTED
+} sdp_group_attr_e;
+
+typedef enum {
+ SDP_SRC_FILTER_INCL,
+ SDP_SRC_FILTER_EXCL,
+ SDP_MAX_FILTER_MODE,
+ SDP_FILTER_MODE_NOT_PRESENT
+} sdp_src_filter_mode_e;
+
+typedef enum {
+ SDP_RTCP_UNICAST_MODE_REFLECTION,
+ SDP_RTCP_UNICAST_MODE_RSI,
+ SDP_RTCP_MAX_UNICAST_MODE,
+ SDP_RTCP_UNICAST_MODE_NOT_PRESENT
+} sdp_rtcp_unicast_mode_e;
+
+typedef enum {
+ SDP_CONNECTION_NOT_FOUND = -1,
+ SDP_CONNECTION_NEW = 0,
+ SDP_CONNECTION_EXISTING,
+ SDP_MAX_CONNECTION,
+ SDP_CONNECTION_UNKNOWN
+} sdp_connection_type_e;
+
+/*
+ * sdp_srtp_fec_order_t
+ * This type defines the order in which to perform FEC
+ * (Forward Error Correction) and SRTP Encryption/Authentication.
+ */
+typedef enum sdp_srtp_fec_order_t_ {
+ SDP_SRTP_THEN_FEC, /* upon sending perform SRTP then FEC */
+ SDP_FEC_THEN_SRTP, /* upon sending perform FEC then SRTP */
+ SDP_SRTP_FEC_SPLIT /* upon sending perform SRTP Encryption,
+ * then FEC, the SRTP Authentication */
+} sdp_srtp_fec_order_t;
+
+
+/*
+ * sdp_srtp_crypto_suite_t
+ * Enumeration of the crypto suites supported for MGCP SRTP
+ * package.
+ */
+typedef enum sdp_srtp_crypto_suite_t_ {
+ SDP_SRTP_UNKNOWN_CRYPTO_SUITE = 0,
+ SDP_SRTP_AES_CM_128_HMAC_SHA1_32,
+ SDP_SRTP_AES_CM_128_HMAC_SHA1_80,
+ SDP_SRTP_F8_128_HMAC_SHA1_80,
+ SDP_SRTP_MAX_NUM_CRYPTO_SUITES
+} sdp_srtp_crypto_suite_t;
+
+/*
+ * SDP SRTP crypto suite definition parameters
+ *
+ * SDP_SRTP_<crypto_suite>_KEY_BYTES
+ * The size of a master key for <crypto_suite> in bytes.
+ *
+ * SDP_SRTP_<crypto_suite>_SALT_BYTES
+ * The size of a master salt for <crypto_suite> in bytes.
+ */
+#define SDP_SRTP_AES_CM_128_HMAC_SHA1_32_KEY_BYTES 16
+#define SDP_SRTP_AES_CM_128_HMAC_SHA1_32_SALT_BYTES 14
+#define SDP_SRTP_AES_CM_128_HMAC_SHA1_80_KEY_BYTES 16
+#define SDP_SRTP_AES_CM_128_HMAC_SHA1_80_SALT_BYTES 14
+#define SDP_SRTP_F8_128_HMAC_SHA1_80_KEY_BYTES 16
+#define SDP_SRTP_F8_128_HMAC_SHA1_80_SALT_BYTES 14
+
+/* SDP Defines */
+
+#define SDP_MAX_LONG_STRING_LEN 4096 /* Max len for long SDP strings */
+#define SDP_MAX_STRING_LEN 256 /* Max len for SDP string */
+#define SDP_MAX_SHORT_STRING_LEN 12 /* Max len for a short SDP string */
+#define SDP_MAX_PAYLOAD_TYPES 23 /* Max payload types in m= line */
+#define SDP_TOKEN_LEN 2 /* Len of <token>= */
+#define SDP_CURRENT_VERSION 0 /* Current default SDP version */
+#define SDP_MAX_PORT_PARAMS 4 /* Max m= port params - x/x/x/x */
+#define SDP_MIN_DYNAMIC_PAYLOAD 96 /* Min dynamic payload */
+#define SDP_MAX_DYNAMIC_PAYLOAD 127 /* Max dynamic payload */
+#define SDP_MIN_CIF_VALUE 1 /* applies to all QCIF,CIF,CIF4,CIF16,SQCIF */
+#define SDP_MAX_CIF_VALUE 32 /* applies to all QCIF,CIF,CIF4,CIF16,SQCIF */
+#define SDP_MAX_SRC_ADDR_LIST 1 /* Max source addrs for which filter applies */
+
+
+#define SDP_DEFAULT_PACKETIZATION_MODE_VALUE 0 /* max packetization mode for H.264 */
+#define SDP_MAX_PACKETIZATION_MODE_VALUE 2 /* max packetization mode for H.264 */
+#define SDP_INVALID_PACKETIZATION_MODE_VALUE 255
+
+#define SDP_MAX_LEVEL_ASYMMETRY_ALLOWED_VALUE 1 /* max level asymmetry allowed value for H.264 */
+#define SDP_DEFAULT_LEVEL_ASYMMETRY_ALLOWED_VALUE 0 /* default level asymmetry allowed value for H.264 */
+#define SDP_INVALID_LEVEL_ASYMMETRY_ALLOWED_VALUE 2 /* invalid value for level-asymmetry-allowed param for H.264 */
+
+
+/* Max number of stream ids that can be grouped together */
+#define SDP_MAX_MEDIA_STREAMS 32
+
+#define SDP_UNSUPPORTED "Unsupported"
+#define SDP_MAX_LINE_LEN 256 /* Max len for SDP Line */
+
+#define SDP_MAX_PROFILE_VALUE 10
+#define SDP_MAX_LEVEL_VALUE 100
+#define SDP_MIN_PROFILE_LEVEL_VALUE 0
+#define SDP_MAX_TTL_VALUE 255
+#define SDP_MIN_MCAST_ADDR_HI_BIT_VAL 224
+#define SDP_MAX_MCAST_ADDR_HI_BIT_VAL 239
+
+/* SDP Enum Types */
+
+typedef enum {
+ SDP_ERR_INVALID_CONF_PTR,
+ SDP_ERR_INVALID_SDP_PTR,
+ SDP_ERR_INTERNAL,
+ SDP_MAX_ERR_TYPES
+} sdp_errmsg_e;
+
+/* SDP Structure Definitions */
+
+/* String names of varios tokens */
+typedef struct {
+ char *name;
+ uint8_t strlen;
+} sdp_namearray_t;
+
+/* c= line info */
+typedef struct {
+ sdp_nettype_e nettype;
+ sdp_addrtype_e addrtype;
+ char conn_addr[SDP_MAX_STRING_LEN+1];
+ tinybool is_multicast;
+ uint16_t ttl;
+ uint16_t num_of_addresses;
+} sdp_conn_t;
+
+/* t= line info */
+typedef struct sdp_timespec {
+ char start_time[SDP_MAX_STRING_LEN+1];
+ char stop_time[SDP_MAX_STRING_LEN+1];
+ struct sdp_timespec *next_p;
+} sdp_timespec_t;
+
+
+/* k= line info */
+typedef struct sdp_encryptspec {
+ sdp_encrypt_type_e encrypt_type;
+ char encrypt_key[SDP_MAX_STRING_LEN+1];
+} sdp_encryptspec_t;
+
+
+/* FMTP attribute deals with named events in the range of 0-255 as
+ * defined in RFC 2833 */
+#define SDP_MIN_NE_VALUE 0
+#define SDP_MAX_NE_VALUES 256
+#define SDP_NE_BITS_PER_WORD ( sizeof(uint32_t) * 8 )
+#define SDP_NE_NUM_BMAP_WORDS ((SDP_MAX_NE_VALUES + SDP_NE_BITS_PER_WORD - 1)/SDP_NE_BITS_PER_WORD )
+#define SDP_NE_BIT_0 ( 0x00000001 )
+#define SDP_NE_ALL_BITS ( 0xFFFFFFFF )
+
+#define SDP_DEINT_BUF_REQ_FLAG 0x1
+#define SDP_INIT_BUF_TIME_FLAG 0x2
+#define SDP_MAX_RCMD_NALU_SIZE_FLAG 0x4
+#define SDP_DEINT_BUF_CAP_FLAG 0x8
+
+#define SDP_FMTP_UNUSED 0xFFFF
+
+typedef struct sdp_fmtp {
+ uint16_t payload_num;
+ uint32_t maxval; /* maxval optimizes bmap search */
+ uint32_t bmap[ SDP_NE_NUM_BMAP_WORDS ];
+ sdp_fmtp_format_type_e fmtp_format; /* Gives the format type
+ for FMTP attribute*/
+ tinybool annexb_required;
+ tinybool annexa_required;
+
+ tinybool annexa;
+ tinybool annexb;
+ uint32_t bitrate;
+ uint32_t mode;
+
+ /* some OPUS specific fmtp params */
+ uint32_t maxplaybackrate;
+ uint32_t maxaveragebitrate;
+ uint16_t usedtx;
+ uint16_t stereo;
+ uint16_t useinbandfec;
+ char maxcodedaudiobandwidth[SDP_MAX_STRING_LEN+1];
+ uint16_t cbr;
+
+ /* BEGIN - All Video related FMTP parameters */
+ uint16_t qcif;
+ uint16_t cif;
+ uint16_t maxbr;
+ uint16_t sqcif;
+ uint16_t cif4;
+ uint16_t cif16;
+
+ uint16_t custom_x;
+ uint16_t custom_y;
+ uint16_t custom_mpi;
+ /* CUSTOM=360,240,4 implies X-AXIS=360, Y-AXIS=240; MPI=4 */
+ uint16_t par_width;
+ uint16_t par_height;
+ /* PAR=12:11 implies par_width=12, par_height=11 */
+
+ /* CPCF should be a float. IOS does not support float and so it is uint16_t */
+ /* For portable stack, CPCF should be defined as float and the parsing should
+ * be modified accordingly */
+ uint16_t cpcf;
+ uint16_t bpp;
+ uint16_t hrd;
+
+ int16_t profile;
+ int16_t level;
+ tinybool is_interlace;
+
+ /* some more H.264 specific fmtp params */
+ char profile_level_id[SDP_MAX_STRING_LEN+1];
+ char parameter_sets[SDP_MAX_STRING_LEN+1];
+ uint16_t packetization_mode;
+ uint16_t level_asymmetry_allowed;
+ uint16_t interleaving_depth;
+ uint32_t deint_buf_req;
+ uint32_t max_don_diff;
+ uint32_t init_buf_time;
+
+ uint32_t max_mbps;
+ uint32_t max_fs;
+ uint32_t max_fr;
+ uint32_t max_cpb;
+ uint32_t max_dpb;
+ uint32_t max_br;
+ tinybool redundant_pic_cap;
+ uint32_t deint_buf_cap;
+ uint32_t max_rcmd_nalu_size;
+ uint16_t parameter_add;
+
+ tinybool annex_d;
+
+ tinybool annex_f;
+ tinybool annex_i;
+ tinybool annex_j;
+ tinybool annex_t;
+
+ /* H.263 codec requires annex K,N and P to have values */
+ uint16_t annex_k_val;
+ uint16_t annex_n_val;
+
+ /* RFC 5109 Section 4.2 for specifying redundant encodings */
+ uint8_t redundant_encodings[SDP_FMTP_MAX_REDUNDANT_ENCODINGS];
+
+ /* RFC 2833 Section 3.9 (4733) for specifying support DTMF tones:
+ The list of values consists of comma-separated elements, which
+ can be either a single decimal number or two decimal numbers
+ separated by a hyphen (dash), where the second number is larger
+ than the first. No whitespace is allowed between numbers or
+ hyphens. The list does not have to be sorted.
+ */
+ char dtmf_tones[SDP_MAX_STRING_LEN+1];
+
+ /* Annex P can take one or more values in the range 1-4 . e.g P=1,3 */
+ uint16_t annex_p_val_picture_resize; /* 1 = four; 2 = sixteenth */
+ uint16_t annex_p_val_warp; /* 3 = half; 4=sixteenth */
+
+ uint8_t flag;
+
+ /* END - All Video related FMTP parameters */
+
+} sdp_fmtp_t;
+
+/* a=sctpmap line used for Datachannels */
+typedef struct sdp_sctpmap {
+ uint16_t port;
+ uint32_t streams; /* Num streams per Datachannel */
+ char protocol[SDP_MAX_STRING_LEN+1];
+} sdp_sctpmap_t;
+
+#define SDP_MAX_MSID_LEN 64
+
+typedef struct sdp_msid {
+ char identifier[SDP_MAX_MSID_LEN+1];
+ char appdata[SDP_MAX_MSID_LEN+1];
+} sdp_msid_t;
+
+/* a=qos|secure|X-pc-qos|X-qos info */
+typedef struct sdp_qos {
+ sdp_qos_strength_e strength;
+ sdp_qos_dir_e direction;
+ tinybool confirm;
+ sdp_qos_status_types_e status_type;
+} sdp_qos_t;
+
+/* a=curr:qos status_type direction */
+typedef struct sdp_curr {
+ sdp_curr_type_e type;
+ sdp_qos_status_types_e status_type;
+ sdp_qos_dir_e direction;
+} sdp_curr_t;
+
+/* a=des:qos strength status_type direction */
+typedef struct sdp_des {
+ sdp_des_type_e type;
+ sdp_qos_strength_e strength;
+ sdp_qos_status_types_e status_type;
+ sdp_qos_dir_e direction;
+} sdp_des_t;
+
+/* a=conf:qos status_type direction */
+typedef struct sdp_conf {
+ sdp_conf_type_e type;
+ sdp_qos_status_types_e status_type;
+ sdp_qos_dir_e direction;
+} sdp_conf_t;
+
+
+/* a=rtpmap or a=sprtmap info */
+typedef struct sdp_transport_map {
+ uint16_t payload_num;
+ char encname[SDP_MAX_STRING_LEN+1];
+ uint32_t clockrate;
+ uint16_t num_chan;
+} sdp_transport_map_t;
+
+
+/* a=rtr info */
+typedef struct sdp_rtr {
+ tinybool confirm;
+} sdp_rtr_t;
+
+/* a=subnet info */
+typedef struct sdp_subnet {
+ sdp_nettype_e nettype;
+ sdp_addrtype_e addrtype;
+ char addr[SDP_MAX_STRING_LEN+1];
+ int32_t prefix;
+} sdp_subnet_t;
+
+
+/* a=X-pc-codec info */
+typedef struct sdp_pccodec {
+ uint16_t num_payloads;
+ ushort payload_type[SDP_MAX_PAYLOAD_TYPES];
+} sdp_pccodec_t;
+
+/* a=direction info */
+typedef struct sdp_comediadir {
+ sdp_mediadir_role_e role;
+ tinybool conn_info_present;
+ sdp_conn_t conn_info;
+ uint32_t src_port;
+} sdp_comediadir_t;
+
+
+
+/* a=silenceSupp info */
+typedef struct sdp_silencesupp {
+ tinybool enabled;
+ tinybool timer_null;
+ uint16_t timer;
+ sdp_silencesupp_pref_e pref;
+ sdp_silencesupp_siduse_e siduse;
+ tinybool fxnslevel_null;
+ uint8_t fxnslevel;
+} sdp_silencesupp_t;
+
+
+/*
+ * a=mptime info */
+/* Note that an interval value of zero corresponds to
+ * the "-" syntax on the a= line.
+ */
+typedef struct sdp_mptime {
+ uint16_t num_intervals;
+ ushort intervals[SDP_MAX_PAYLOAD_TYPES];
+} sdp_mptime_t;
+
+/*
+ * a=X-sidin:<val>, a=X-sidout:< val> and a=X-confid: <val>
+ * Stream Id,ConfID related attributes to be used for audio/video conferencing
+ *
+*/
+
+typedef struct sdp_stream_data {
+ char x_sidin[SDP_MAX_STRING_LEN+1];
+ char x_sidout[SDP_MAX_STRING_LEN+1];
+ char x_confid[SDP_MAX_STRING_LEN+1];
+ sdp_group_attr_e group_attr; /* FID or LS */
+ uint16_t num_group_id;
+ char * group_ids[SDP_MAX_MEDIA_STREAMS];
+} sdp_stream_data_t;
+
+typedef struct sdp_msid_semantic {
+ char semantic[SDP_MAX_STRING_LEN+1];
+ char * msids[SDP_MAX_MEDIA_STREAMS];
+} sdp_msid_semantic_t;
+
+/*
+ * a=source-filter:<filter-mode> <filter-spec>
+ * <filter-spec> = <nettype> <addrtype> <dest-addr> <src_addr><src_addr>...
+ * One or more source addresses to apply filter, for one or more connection
+ * address in unicast/multicast environments
+ */
+typedef struct sdp_source_filter {
+ sdp_src_filter_mode_e mode;
+ sdp_nettype_e nettype;
+ sdp_addrtype_e addrtype;
+ char dest_addr[SDP_MAX_STRING_LEN+1];
+ uint16_t num_src_addr;
+ char src_list[SDP_MAX_SRC_ADDR_LIST+1][SDP_MAX_STRING_LEN+1];
+} sdp_source_filter_t;
+
+/*
+ * a=rtcp-fb:<payload-type> <feedback-type> [<feedback-parameters>]
+ * Defines RTCP feedback parameters
+ */
+#define SDP_ALL_PAYLOADS 0xFFFF
+typedef struct sdp_fmtp_fb {
+ uint16_t payload_num; /* can be SDP_ALL_PAYLOADS */
+ sdp_rtcp_fb_type_e feedback_type;
+ union {
+ sdp_rtcp_fb_ack_type_e ack;
+ sdp_rtcp_fb_ccm_type_e ccm;
+ sdp_rtcp_fb_nack_type_e nack;
+ uint32_t trr_int;
+ } param;
+ char extra[SDP_MAX_STRING_LEN + 1]; /* Holds any trailing information that
+ cannot be represented by preceding
+ fields. */
+} sdp_fmtp_fb_t;
+
+typedef struct sdp_rtcp {
+ sdp_nettype_e nettype;
+ sdp_addrtype_e addrtype;
+ char addr[SDP_MAX_STRING_LEN+1];
+ uint16_t port;
+} sdp_rtcp_t;
+
+/*
+ * b=<bw-modifier>:<val>
+ *
+*/
+typedef struct sdp_bw_data {
+ struct sdp_bw_data *next_p;
+ sdp_bw_modifier_e bw_modifier;
+ int bw_val;
+} sdp_bw_data_t;
+
+/*
+ * This structure houses a linked list of sdp_bw_data_t instances. Each
+ * sdp_bw_data_t instance represents one b= line.
+ */
+typedef struct sdp_bw {
+ uint16_t bw_data_count;
+ sdp_bw_data_t *bw_data_list;
+} sdp_bw_t;
+
+/* Media lines for AAL2 may have more than one transport type defined
+ * each with its own payload type list. These are referred to as
+ * profile types instead of transport types. This structure is used
+ * to handle these multiple profile types. Note: One additional profile
+ * field is needed because of the way parsing is done. This is not an
+ * error. */
+typedef struct sdp_media_profiles {
+ uint16_t num_profiles;
+ sdp_transport_e profile[SDP_MAX_PROFILES+1];
+ uint16_t num_payloads[SDP_MAX_PROFILES];
+ sdp_payload_ind_e payload_indicator[SDP_MAX_PROFILES][SDP_MAX_PAYLOAD_TYPES];
+ uint16_t payload_type[SDP_MAX_PROFILES][SDP_MAX_PAYLOAD_TYPES];
+} sdp_media_profiles_t;
+/*
+ * a=extmap:<value>["/"<direction>] <URI> <extensionattributes>
+ *
+ */
+typedef struct sdp_extmap {
+ uint16_t id;
+ sdp_direction_e media_direction;
+ tinybool media_direction_specified;
+ char uri[SDP_MAX_STRING_LEN+1];
+ char extension_attributes[SDP_MAX_STRING_LEN+1];
+} sdp_extmap_t;
+
+typedef struct sdp_ssrc {
+ uint32_t ssrc;
+ char attribute[SDP_MAX_STRING_LEN + 1];
+} sdp_ssrc_t;
+
+/*
+ * sdp_srtp_crypto_context_t
+ * This type is used to hold cryptographic context information.
+ *
+ */
+typedef struct sdp_srtp_crypto_context_t_ {
+ int32_t tag;
+ unsigned long selection_flags;
+ sdp_srtp_crypto_suite_t suite;
+ unsigned char master_key[SDP_SRTP_MAX_KEY_SIZE_BYTES];
+ unsigned char master_salt[SDP_SRTP_MAX_SALT_SIZE_BYTES];
+ unsigned char master_key_size_bytes;
+ unsigned char master_salt_size_bytes;
+ unsigned long ssrc; /* not used */
+ unsigned long roc; /* not used */
+ unsigned long kdr; /* not used */
+ unsigned short seq; /* not used */
+ sdp_srtp_fec_order_t fec_order; /* not used */
+ unsigned char master_key_lifetime[SDP_SRTP_MAX_LIFETIME_BYTES];
+ unsigned char mki[SDP_SRTP_MAX_MKI_SIZE_BYTES];
+ uint16_t mki_size_bytes;
+ char* session_parameters;
+} sdp_srtp_crypto_context_t;
+
+
+/* m= line info and associated attribute list */
+/* Note: Most of the port parameter values are 16-bit values. We set
+ * the type to int32_t so we can return either a 16-bit value or the
+ * choose value. */
+typedef struct sdp_mca {
+ sdp_media_e media;
+ sdp_conn_t conn;
+ sdp_transport_e transport;
+ sdp_port_format_e port_format;
+ int32_t port;
+ int32_t sctpport;
+ int32_t num_ports;
+ int32_t vpi;
+ uint32_t vci; /* VCI needs to be 32-bit */
+ int32_t vcci;
+ int32_t cid;
+ uint16_t num_payloads;
+ sdp_payload_ind_e payload_indicator[SDP_MAX_PAYLOAD_TYPES];
+ uint16_t payload_type[SDP_MAX_PAYLOAD_TYPES];
+ sdp_media_profiles_t *media_profiles_p;
+ tinybool sessinfo_found;
+ sdp_encryptspec_t encrypt;
+ sdp_bw_t bw;
+ sdp_attr_e media_direction; /* Either INACTIVE, SENDONLY,
+ RECVONLY, or SENDRECV */
+ uint32_t mid;
+ uint32_t line_number;
+ struct sdp_attr *media_attrs_p;
+ struct sdp_mca *next_p;
+} sdp_mca_t;
+
+
+/* generic a= line info */
+typedef struct sdp_attr {
+ sdp_attr_e type;
+ uint32_t line_number;
+ union {
+ tinybool boolean_val;
+ uint32_t u32_val;
+ char string_val[SDP_MAX_STRING_LEN+1];
+ char *stringp;
+ char ice_attr[SDP_MAX_STRING_LEN+1];
+ sdp_fmtp_t fmtp;
+ sdp_sctpmap_t sctpmap;
+ sdp_msid_t msid;
+ sdp_qos_t qos;
+ sdp_curr_t curr;
+ sdp_des_t des;
+ sdp_conf_t conf;
+ sdp_transport_map_t transport_map; /* A rtpmap or sprtmap */
+ sdp_subnet_t subnet;
+ sdp_t38_ratemgmt_e t38ratemgmt;
+ sdp_t38_udpec_e t38udpec;
+ sdp_pccodec_t pccodec;
+ sdp_silencesupp_t silencesupp;
+ sdp_mca_t *cap_p; /* A X-CAP or CDSC attribute */
+ sdp_rtr_t rtr;
+ sdp_comediadir_t comediadir;
+ sdp_srtp_crypto_context_t srtp_context;
+ sdp_mptime_t mptime;
+ sdp_stream_data_t stream_data;
+ sdp_msid_semantic_t msid_semantic;
+ char unknown[SDP_MAX_STRING_LEN+1];
+ sdp_source_filter_t source_filter;
+ sdp_fmtp_fb_t rtcp_fb;
+ sdp_rtcp_t rtcp;
+ sdp_setup_type_e setup;
+ sdp_connection_type_e connection;
+ sdp_extmap_t extmap;
+ sdp_ssrc_t ssrc;
+ } attr;
+ struct sdp_attr *next_p;
+} sdp_attr_t;
+typedef struct sdp_srtp_crypto_suite_list_ {
+ sdp_srtp_crypto_suite_t crypto_suite_val;
+ char * crypto_suite_str;
+ unsigned char key_size_bytes;
+ unsigned char salt_size_bytes;
+} sdp_srtp_crypto_suite_list;
+
+typedef void (*sdp_parse_error_handler)(void *context,
+ uint32_t line,
+ const char *message);
+
+/* Application configuration options */
+typedef struct sdp_conf_options {
+ tinybool debug_flag[SDP_MAX_DEBUG_TYPES];
+ tinybool version_reqd;
+ tinybool owner_reqd;
+ tinybool session_name_reqd;
+ tinybool timespec_reqd;
+ tinybool media_supported[SDP_MAX_MEDIA_TYPES];
+ tinybool nettype_supported[SDP_MAX_NETWORK_TYPES];
+ tinybool addrtype_supported[SDP_MAX_ADDR_TYPES];
+ tinybool transport_supported[SDP_MAX_TRANSPORT_TYPES];
+ tinybool allow_choose[SDP_MAX_CHOOSE_PARAMS];
+ /* Statistics counts */
+ uint32_t num_builds;
+ uint32_t num_parses;
+ uint32_t num_not_sdp_desc;
+ uint32_t num_invalid_token_order;
+ uint32_t num_invalid_param;
+ uint32_t num_no_resource;
+ struct sdp_conf_options *next_p;
+ sdp_parse_error_handler error_handler;
+ void *error_handler_context;
+} sdp_conf_options_t;
+
+
+/* Session level SDP info with pointers to media line info. */
+/* Elements here that can only be one of are included directly. Elements */
+/* that can be more than one are pointers. */
+typedef struct {
+ sdp_conf_options_t *conf_p;
+ tinybool debug_flag[SDP_MAX_DEBUG_TYPES];
+ char debug_str[SDP_MAX_STRING_LEN+1];
+ uint32_t debug_id;
+ int32_t version; /* version is really a uint16_t */
+ char owner_name[SDP_MAX_STRING_LEN+1];
+ char owner_sessid[SDP_MAX_STRING_LEN+1];
+ char owner_version[SDP_MAX_STRING_LEN+1];
+ sdp_nettype_e owner_network_type;
+ sdp_addrtype_e owner_addr_type;
+ char owner_addr[SDP_MAX_STRING_LEN+1];
+ char sessname[SDP_MAX_STRING_LEN+1];
+ tinybool sessinfo_found;
+ tinybool uri_found;
+ sdp_conn_t default_conn;
+ sdp_timespec_t *timespec_p;
+ sdp_encryptspec_t encrypt;
+ sdp_bw_t bw;
+ sdp_attr_t *sess_attrs_p;
+
+ /* Info to help with building capability attributes. */
+ uint16_t cur_cap_num;
+ sdp_mca_t *cur_cap_p;
+ /* Info to help parsing X-cpar attrs. */
+ uint16_t cap_valid;
+ uint16_t last_cap_inst;
+ /* Info to help building X-cpar/cpar attrs. */
+ sdp_attr_e last_cap_type;
+
+ /* Facilitates reporting line number for SDP errors */
+ uint32_t parse_line;
+
+ /* MCA - Media, connection, and attributes */
+ sdp_mca_t *mca_p;
+ ushort mca_count;
+} sdp_t;
+
+
+/* Token processing table. */
+typedef struct {
+ char *name;
+ sdp_result_e (*parse_func)(sdp_t *sdp_p, uint16_t level, const char *ptr);
+ sdp_result_e (*build_func)(sdp_t *sdp_p, uint16_t level, flex_string *fs);
+} sdp_tokenarray_t;
+
+/* Attribute processing table. */
+typedef struct {
+ char *name;
+ uint16_t strlen;
+ sdp_result_e (*parse_func)(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr);
+ sdp_result_e (*build_func)(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs);
+} sdp_attrarray_t;
+
+
+/* Prototypes */
+
+/* sdp_config.c */
+extern sdp_conf_options_t *sdp_init_config(void);
+extern void sdp_free_config(sdp_conf_options_t *config_p);
+extern void sdp_appl_debug(sdp_conf_options_t *config_p, sdp_debug_e debug_type,
+ tinybool debug_flag);
+extern void sdp_require_version(sdp_conf_options_t *config_p, tinybool version_required);
+extern void sdp_require_owner(sdp_conf_options_t *config_p, tinybool owner_required);
+extern void sdp_require_session_name(sdp_conf_options_t *config_p,
+ tinybool sess_name_required);
+extern void sdp_require_timespec(sdp_conf_options_t *config_p, tinybool timespec_required);
+extern void sdp_media_supported(sdp_conf_options_t *config_p, sdp_media_e media_type,
+ tinybool media_supported);
+extern void sdp_nettype_supported(sdp_conf_options_t *config_p, sdp_nettype_e nettype,
+ tinybool nettype_supported);
+extern void sdp_addrtype_supported(sdp_conf_options_t *config_p, sdp_addrtype_e addrtype,
+ tinybool addrtype_supported);
+extern void sdp_transport_supported(sdp_conf_options_t *config_p, sdp_transport_e transport,
+ tinybool transport_supported);
+extern void sdp_allow_choose(sdp_conf_options_t *config_p, sdp_choose_param_e param,
+ tinybool choose_allowed);
+extern void sdp_config_set_error_handler(sdp_conf_options_t *config_p,
+ sdp_parse_error_handler handler,
+ void *context);
+
+/* sdp_main.c */
+extern sdp_t *sdp_init_description(sdp_conf_options_t *config_p);
+extern void sdp_debug(sdp_t *sdp_ptr, sdp_debug_e debug_type, tinybool debug_flag);
+extern void sdp_set_string_debug(sdp_t *sdp_ptr, const char *debug_str);
+extern sdp_result_e sdp_parse(sdp_t *sdp_ptr, const char *buf, size_t len);
+extern sdp_result_e sdp_build(sdp_t *sdp_ptr, flex_string *fs);
+extern sdp_result_e sdp_free_description(sdp_t *sdp_ptr);
+extern void sdp_parse_error(sdp_t *sdp, const char *format, ...);
+
+extern const char *sdp_get_result_name(sdp_result_e rc);
+
+
+/* sdp_access.c */
+extern tinybool sdp_version_valid(sdp_t *sdp_p);
+extern int32_t sdp_get_version(sdp_t *sdp_p);
+extern sdp_result_e sdp_set_version(sdp_t *sdp_p, int32_t version);
+
+extern tinybool sdp_owner_valid(sdp_t *sdp_p);
+extern const char *sdp_get_owner_username(sdp_t *sdp_p);
+extern const char *sdp_get_owner_sessionid(sdp_t *sdp_p);
+extern const char *sdp_get_owner_version(sdp_t *sdp_p);
+extern sdp_nettype_e sdp_get_owner_network_type(sdp_t *sdp_p);
+extern sdp_addrtype_e sdp_get_owner_address_type(sdp_t *sdp_p);
+extern const char *sdp_get_owner_address(sdp_t *sdp_p);
+extern sdp_result_e sdp_set_owner_username(sdp_t *sdp_p, const char *username);
+extern sdp_result_e sdp_set_owner_sessionid(sdp_t *sdp_p, const char *sessid);
+extern sdp_result_e sdp_set_owner_version(sdp_t *sdp_p, const char *version);
+extern sdp_result_e sdp_set_owner_network_type(sdp_t *sdp_p,
+ sdp_nettype_e network_type);
+extern sdp_result_e sdp_set_owner_address_type(sdp_t *sdp_p,
+ sdp_addrtype_e address_type);
+extern sdp_result_e sdp_set_owner_address(sdp_t *sdp_p, const char *address);
+
+extern tinybool sdp_session_name_valid(sdp_t *sdp_p);
+extern const char *sdp_get_session_name(sdp_t *sdp_p);
+extern sdp_result_e sdp_set_session_name(sdp_t *sdp_p, const char *sessname);
+
+extern tinybool sdp_timespec_valid(sdp_t *sdp_ptr);
+extern const char *sdp_get_time_start(sdp_t *sdp_ptr);
+extern const char *sdp_get_time_stop(sdp_t *sdp_ptr);
+sdp_result_e sdp_set_time_start(sdp_t *sdp_p, const char *start_time);
+sdp_result_e sdp_set_time_stop(sdp_t *sdp_p, const char *stop_time);
+
+extern tinybool sdp_encryption_valid(sdp_t *sdp_p, uint16_t level);
+extern sdp_encrypt_type_e sdp_get_encryption_method(sdp_t *sdp_p, uint16_t level);
+extern const char *sdp_get_encryption_key(sdp_t *sdp_p, uint16_t level);
+
+extern tinybool sdp_connection_valid(sdp_t *sdp_p, uint16_t level);
+extern tinybool sdp_bw_line_exists(sdp_t *sdp_p, uint16_t level, uint16_t inst_num);
+extern tinybool sdp_bandwidth_valid(sdp_t *sdp_p, uint16_t level, uint16_t inst_num);
+extern sdp_nettype_e sdp_get_conn_nettype(sdp_t *sdp_p, uint16_t level);
+extern sdp_addrtype_e sdp_get_conn_addrtype(sdp_t *sdp_p, uint16_t level);
+extern const char *sdp_get_conn_address(sdp_t *sdp_p, uint16_t level);
+
+extern tinybool sdp_is_mcast_addr (sdp_t *sdp_p, uint16_t level);
+extern int32_t sdp_get_mcast_ttl(sdp_t *sdp_p, uint16_t level);
+extern int32_t sdp_get_mcast_num_of_addresses(sdp_t *sdp_p, uint16_t level);
+
+extern sdp_result_e sdp_set_conn_nettype(sdp_t *sdp_p, uint16_t level,
+ sdp_nettype_e nettype);
+extern sdp_result_e sdp_set_conn_addrtype(sdp_t *sdp_p, uint16_t level,
+ sdp_addrtype_e addrtype);
+extern sdp_result_e sdp_set_conn_address(sdp_t *sdp_p, uint16_t level,
+ const char *address);
+
+extern tinybool sdp_media_line_valid(sdp_t *sdp_p, uint16_t level);
+extern uint16_t sdp_get_num_media_lines(sdp_t *sdp_ptr);
+extern sdp_media_e sdp_get_media_type(sdp_t *sdp_p, uint16_t level);
+extern uint32_t sdp_get_media_line_number(sdp_t *sdp_p, uint16_t level);
+extern sdp_port_format_e sdp_get_media_port_format(sdp_t *sdp_p, uint16_t level);
+extern int32_t sdp_get_media_portnum(sdp_t *sdp_p, uint16_t level);
+extern int32_t sdp_get_media_portcount(sdp_t *sdp_p, uint16_t level);
+extern int32_t sdp_get_media_vpi(sdp_t *sdp_p, uint16_t level);
+extern uint32_t sdp_get_media_vci(sdp_t *sdp_p, uint16_t level);
+extern int32_t sdp_get_media_vcci(sdp_t *sdp_p, uint16_t level);
+extern int32_t sdp_get_media_cid(sdp_t *sdp_p, uint16_t level);
+extern sdp_transport_e sdp_get_media_transport(sdp_t *sdp_p, uint16_t level);
+extern uint16_t sdp_get_media_num_profiles(sdp_t *sdp_p, uint16_t level);
+extern sdp_transport_e sdp_get_media_profile(sdp_t *sdp_p, uint16_t level,
+ uint16_t profile_num);
+extern uint16_t sdp_get_media_num_payload_types(sdp_t *sdp_p, uint16_t level);
+extern uint16_t sdp_get_media_profile_num_payload_types(sdp_t *sdp_p, uint16_t level,
+ uint16_t profile_num);
+extern rtp_ptype sdp_get_known_payload_type(sdp_t *sdp_p,
+ uint16_t level,
+ uint16_t payload_type_raw);
+extern uint32_t sdp_get_media_payload_type(sdp_t *sdp_p, uint16_t level,
+ uint16_t payload_num, sdp_payload_ind_e *indicator);
+extern uint32_t sdp_get_media_profile_payload_type(sdp_t *sdp_p, uint16_t level,
+ uint16_t prof_num, uint16_t payload_num, sdp_payload_ind_e *indicator);
+extern sdp_result_e sdp_insert_media_line(sdp_t *sdp_p, uint16_t level);
+extern sdp_result_e sdp_set_media_type(sdp_t *sdp_p, uint16_t level,
+ sdp_media_e media);
+extern sdp_result_e sdp_set_media_portnum(sdp_t *sdp_p, uint16_t level,
+ int32_t portnum, int32_t sctpport);
+extern int32_t sdp_get_media_sctp_port(sdp_t *sdp_p, uint16_t level);
+extern sdp_result_e sdp_set_media_transport(sdp_t *sdp_p, uint16_t level,
+ sdp_transport_e transport);
+extern sdp_result_e sdp_add_media_profile(sdp_t *sdp_p, uint16_t level,
+ sdp_transport_e profile);
+extern sdp_result_e sdp_add_media_payload_type(sdp_t *sdp_p, uint16_t level,
+ uint16_t payload_type, sdp_payload_ind_e indicator);
+extern sdp_result_e sdp_add_media_profile_payload_type(sdp_t *sdp_p,
+ uint16_t level, uint16_t prof_num, uint16_t payload_type,
+ sdp_payload_ind_e indicator);
+
+/* sdp_attr_access.c */
+extern sdp_attr_t *sdp_find_attr (sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ sdp_attr_e attr_type, uint16_t inst_num);
+
+extern int sdp_find_fmtp_inst(sdp_t *sdp_ptr, uint16_t level, uint16_t payload_num);
+extern sdp_result_e sdp_add_new_attr(sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ sdp_attr_e attr_type, uint16_t *inst_num);
+extern sdp_result_e sdp_attr_num_instances(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, sdp_attr_e attr_type, uint16_t *num_attr_inst);
+extern tinybool sdp_attr_valid(sdp_t *sdp_p, sdp_attr_e attr_type,
+ uint16_t level, uint8_t cap_num, uint16_t inst_num);
+extern uint32_t sdp_attr_line_number(sdp_t *sdp_p, sdp_attr_e attr_type,
+ uint16_t level, uint8_t cap_num, uint16_t inst_num);
+extern const char *sdp_attr_get_simple_string(sdp_t *sdp_p,
+ sdp_attr_e attr_type, uint16_t level, uint8_t cap_num, uint16_t inst_num);
+extern const char *sdp_attr_get_long_string(sdp_t *sdp_p,
+ sdp_attr_e attr_type, uint16_t level, uint8_t cap_num, uint16_t inst_num);
+extern uint32_t sdp_attr_get_simple_u32(sdp_t *sdp_p, sdp_attr_e attr_type,
+ uint16_t level, uint8_t cap_num, uint16_t inst_num);
+extern tinybool sdp_attr_get_simple_boolean(sdp_t *sdp_p,
+ sdp_attr_e attr_type, uint16_t level, uint8_t cap_num, uint16_t inst_num);
+extern tinybool sdp_attr_is_present (sdp_t *sdp_p, sdp_attr_e attr_type,
+ uint16_t level, uint8_t cap_num);
+extern const char* sdp_attr_get_maxprate(sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num);
+extern sdp_t38_ratemgmt_e sdp_attr_get_t38ratemgmt(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern sdp_t38_udpec_e sdp_attr_get_t38udpec(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern sdp_direction_e sdp_get_media_direction(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num);
+extern sdp_qos_strength_e sdp_attr_get_qos_strength(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, sdp_attr_e qos_attr, uint16_t inst_num);
+extern sdp_qos_status_types_e sdp_attr_get_qos_status_type (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, sdp_attr_e qos_attr, uint16_t inst_num);
+extern sdp_qos_dir_e sdp_attr_get_qos_direction(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, sdp_attr_e qos_attr, uint16_t inst_num);
+extern tinybool sdp_attr_get_qos_confirm(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, sdp_attr_e qos_attr, uint16_t inst_num);
+extern sdp_curr_type_e sdp_attr_get_curr_type (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, sdp_attr_e qos_attr, uint16_t inst_num);
+extern sdp_des_type_e sdp_attr_get_des_type (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, sdp_attr_e qos_attr, uint16_t inst_num);
+extern sdp_conf_type_e sdp_attr_get_conf_type (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, sdp_attr_e qos_attr, uint16_t inst_num);
+extern sdp_nettype_e sdp_attr_get_subnet_nettype(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern sdp_addrtype_e sdp_attr_get_subnet_addrtype(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern const char *sdp_attr_get_subnet_addr(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern int32_t sdp_attr_get_subnet_prefix(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern rtp_ptype sdp_attr_get_rtpmap_known_codec(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern tinybool sdp_attr_rtpmap_payload_valid(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t *inst_num, uint16_t payload_type);
+extern uint16_t sdp_attr_get_rtpmap_payload_type(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern const char *sdp_attr_get_rtpmap_encname(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern uint32_t sdp_attr_get_rtpmap_clockrate(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern uint16_t sdp_attr_get_rtpmap_num_chan(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern tinybool sdp_attr_sprtmap_payload_valid(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t *inst_num, uint16_t payload_type);
+extern uint16_t sdp_attr_get_sprtmap_payload_type(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern const char *sdp_attr_get_sprtmap_encname(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern uint32_t sdp_attr_get_sprtmap_clockrate(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern uint16_t sdp_attr_get_sprtmap_num_chan(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern tinybool sdp_attr_fmtp_payload_valid(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t *inst_num, uint16_t payload_type);
+extern uint16_t sdp_attr_get_fmtp_payload_type(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern sdp_ne_res_e sdp_attr_fmtp_is_range_set(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint8_t low_val, uint8_t high_val);
+extern tinybool sdp_attr_fmtp_valid(sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ uint16_t inst_num, uint16_t appl_maxval, uint32_t* evt_array);
+extern sdp_result_e sdp_attr_set_fmtp_payload_type(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ uint16_t payload_num);
+extern sdp_result_e sdp_attr_get_fmtp_range(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint32_t *bmap);
+extern sdp_result_e sdp_attr_clear_fmtp_range(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint8_t low_val, uint8_t high_val);
+extern sdp_ne_res_e sdp_attr_compare_fmtp_ranges(sdp_t *src_sdp_ptr,
+ sdp_t *dst_sdp_ptr, uint16_t src_level, uint16_t dst_level,
+ uint8_t src_cap_num, uint8_t dst_cap_num, uint16_t src_inst_num,
+ uint16_t dst_inst_num);
+extern sdp_result_e sdp_attr_copy_fmtp_ranges(sdp_t *src_sdp_ptr,
+ sdp_t *dst_sdp_ptr, uint16_t src_level, uint16_t dst_level,
+ uint8_t src_cap_num, uint8_t dst_cap_num, uint16_t src_inst_num,
+ uint16_t dst_inst_num);
+extern uint32_t sdp_attr_get_fmtp_mode_for_payload_type (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint32_t payload_type);
+
+extern sdp_result_e sdp_attr_set_fmtp_max_fs (sdp_t *sdp_p,
+ uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num,
+ uint32_t max_fs);
+
+extern sdp_result_e sdp_attr_set_fmtp_max_fr (sdp_t *sdp_p,
+ uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num,
+ uint32_t max_fr);
+
+/* get routines */
+extern int32_t sdp_attr_get_fmtp_bitrate_type (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+
+extern int32_t sdp_attr_get_fmtp_cif (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern int32_t sdp_attr_get_fmtp_qcif (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern int32_t sdp_attr_get_fmtp_sqcif (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern int32_t sdp_attr_get_fmtp_cif4 (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern int32_t sdp_attr_get_fmtp_cif16 (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern int32_t sdp_attr_get_fmtp_maxbr (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern sdp_result_e sdp_attr_get_fmtp_max_average_bitrate (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint32_t* val);
+extern sdp_result_e sdp_attr_get_fmtp_usedtx (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, tinybool* val);
+extern sdp_result_e sdp_attr_get_fmtp_stereo (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, tinybool* val);
+extern sdp_result_e sdp_attr_get_fmtp_useinbandfec (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, tinybool* val);
+extern char* sdp_attr_get_fmtp_maxcodedaudiobandwidth (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern sdp_result_e sdp_attr_get_fmtp_cbr (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, tinybool* val);
+extern int32_t sdp_attr_get_fmtp_custom_x (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern int32_t sdp_attr_get_fmtp_custom_y (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern int32_t sdp_attr_get_fmtp_custom_mpi (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern int32_t sdp_attr_get_fmtp_par_width (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern int32_t sdp_attr_get_fmtp_par_height (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern int32_t sdp_attr_get_fmtp_bpp (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern int32_t sdp_attr_get_fmtp_hrd (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern int32_t sdp_attr_get_fmtp_profile (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern int32_t sdp_attr_get_fmtp_level (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern tinybool sdp_attr_get_fmtp_interlace (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern tinybool sdp_attr_get_fmtp_annex_d (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern tinybool sdp_attr_get_fmtp_annex_f (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern tinybool sdp_attr_get_fmtp_annex_i (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern tinybool sdp_attr_get_fmtp_annex_j (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern tinybool sdp_attr_get_fmtp_annex_t (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern int32_t sdp_attr_get_fmtp_annex_k_val (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern int32_t sdp_attr_get_fmtp_annex_n_val (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+
+extern int32_t sdp_attr_get_fmtp_annex_p_picture_resize (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern int32_t sdp_attr_get_fmtp_annex_p_warp (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+
+/* sctpmap params */
+extern uint16_t sdp_attr_get_sctpmap_port(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern sdp_result_e sdp_attr_get_sctpmap_protocol (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, char* protocol);
+extern sdp_result_e sdp_attr_get_sctpmap_streams (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint32_t* val);
+
+extern const char *sdp_attr_get_msid_identifier(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern const char *sdp_attr_get_msid_appdata(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+
+/* H.264 codec specific params */
+
+extern const char *sdp_attr_get_fmtp_profile_id(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern const char *sdp_attr_get_fmtp_param_sets(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern sdp_result_e sdp_attr_get_fmtp_pack_mode (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint16_t *val);
+
+extern sdp_result_e sdp_attr_get_fmtp_level_asymmetry_allowed (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint16_t *val);
+
+extern sdp_result_e sdp_attr_get_fmtp_interleaving_depth (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ uint16_t *val);
+extern sdp_result_e sdp_attr_get_fmtp_max_don_diff (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ uint32_t *val);
+
+/* The following four H.264 parameters that require special handling as
+ * the values range from 0 - 4294967295
+ */
+extern sdp_result_e sdp_attr_get_fmtp_deint_buf_req (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ uint32_t *val);
+extern sdp_result_e sdp_attr_get_fmtp_deint_buf_cap (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ uint32_t *val);
+extern sdp_result_e sdp_attr_get_fmtp_init_buf_time (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ uint32_t *val);
+extern sdp_result_e sdp_attr_get_fmtp_max_rcmd_nalu_size (sdp_t *sdp_p,
+ uint16_t level, uint8_t cap_num,
+ uint16_t inst_num, uint32_t *val);
+
+
+extern sdp_result_e sdp_attr_get_fmtp_max_mbps (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint32_t *val);
+extern sdp_result_e sdp_attr_get_fmtp_max_fs (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint32_t *val);
+extern sdp_result_e sdp_attr_get_fmtp_max_fr (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint32_t *val);
+extern sdp_result_e sdp_attr_get_fmtp_max_cpb (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint32_t *val);
+extern sdp_result_e sdp_attr_get_fmtp_max_dpb (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint32_t *val);
+extern sdp_result_e sdp_attr_get_fmtp_max_br (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint32_t *val);
+extern tinybool sdp_attr_fmtp_is_redundant_pic_cap (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num);
+extern tinybool sdp_attr_fmtp_is_parameter_add (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num);
+extern tinybool sdp_attr_fmtp_is_annexa_set (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num);
+
+extern tinybool sdp_attr_fmtp_is_annexb_set (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num);
+
+extern sdp_fmtp_format_type_e sdp_attr_fmtp_get_fmtp_format (sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ uint16_t inst_num);
+
+extern uint16_t sdp_attr_get_pccodec_num_payload_types(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern uint16_t sdp_attr_get_pccodec_payload_type(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint16_t payload_num);
+extern sdp_result_e sdp_attr_add_pccodec_payload_type(sdp_t *sdp_p,
+ uint16_t level, uint8_t cap_num,
+ uint16_t inst_num, uint16_t payload_type);
+extern uint16_t sdp_attr_get_xcap_first_cap_num(sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num);
+extern sdp_media_e sdp_attr_get_xcap_media_type(sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num);
+extern sdp_transport_e sdp_attr_get_xcap_transport_type(sdp_t *sdp_p,
+ uint16_t level, uint16_t inst_num);
+extern uint16_t sdp_attr_get_xcap_num_payload_types(sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num);
+extern uint16_t sdp_attr_get_xcap_payload_type(sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num, uint16_t payload_num,
+ sdp_payload_ind_e *indicator);
+extern sdp_result_e sdp_attr_add_xcap_payload_type(sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num, uint16_t payload_type,
+ sdp_payload_ind_e indicator);
+extern uint16_t sdp_attr_get_cdsc_first_cap_num(sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num);
+extern sdp_media_e sdp_attr_get_cdsc_media_type(sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num);
+extern sdp_transport_e sdp_attr_get_cdsc_transport_type(sdp_t *sdp_p,
+ uint16_t level, uint16_t inst_num);
+extern uint16_t sdp_attr_get_cdsc_num_payload_types(sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num);
+extern uint16_t sdp_attr_get_cdsc_payload_type(sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num, uint16_t payload_num,
+ sdp_payload_ind_e *indicator);
+extern sdp_result_e sdp_attr_add_cdsc_payload_type(sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num, uint16_t payload_type,
+ sdp_payload_ind_e indicator);
+extern tinybool sdp_media_dynamic_payload_valid (sdp_t *sdp_p, uint16_t payload_type,
+ uint16_t m_line);
+
+extern tinybool sdp_attr_get_rtr_confirm (sdp_t *, uint16_t, uint8_t, uint16_t);
+
+extern tinybool sdp_attr_get_silencesupp_enabled(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern uint16_t sdp_attr_get_silencesupp_timer(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ tinybool *null_ind);
+extern sdp_silencesupp_pref_e sdp_attr_get_silencesupp_pref(sdp_t *sdp_p,
+ uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num);
+extern sdp_silencesupp_siduse_e sdp_attr_get_silencesupp_siduse(sdp_t *sdp_p,
+ uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num);
+extern uint8_t sdp_attr_get_silencesupp_fxnslevel(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ tinybool *null_ind);
+extern sdp_mediadir_role_e sdp_attr_get_comediadir_role(sdp_t *sdp_p,
+ uint16_t level, uint8_t cap_num,
+ uint16_t inst_num);
+
+extern uint16_t sdp_attr_get_mptime_num_intervals(
+ sdp_t *sdp_p, uint16_t level, uint8_t cap_num, uint16_t inst_num);
+extern uint16_t sdp_attr_get_mptime_interval(
+ sdp_t *sdp_p, uint16_t level, uint8_t cap_num, uint16_t inst_num, uint16_t interval_num);
+extern sdp_result_e sdp_attr_add_mptime_interval(
+ sdp_t *sdp_p, uint16_t level, uint8_t cap_num, uint16_t inst_num, uint16_t interval);
+
+
+extern sdp_result_e sdp_copy_all_bw_lines(sdp_t *src_sdp_ptr, sdp_t *dst_sdp_ptr,
+ uint16_t src_level, uint16_t dst_level);
+extern sdp_bw_modifier_e sdp_get_bw_modifier(sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num);
+extern const char *sdp_get_bw_modifier_name(sdp_bw_modifier_e bw_modifier);
+extern int32_t sdp_get_bw_value(sdp_t *sdp_p, uint16_t level, uint16_t inst_num);
+extern int32_t sdp_get_num_bw_lines (sdp_t *sdp_p, uint16_t level);
+
+extern sdp_result_e sdp_add_new_bw_line(sdp_t *sdp_p, uint16_t level,
+ sdp_bw_modifier_e bw_modifier, uint16_t *inst_num);
+
+extern sdp_group_attr_e sdp_get_group_attr(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+
+extern const char* sdp_attr_get_x_sidout (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+
+
+extern const char* sdp_attr_get_x_sidin (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+
+extern const char* sdp_attr_get_x_confid (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+
+extern uint16_t sdp_get_group_num_id(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+
+extern const char* sdp_get_group_id(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint16_t id_num);
+
+extern int32_t sdp_get_mid_value(sdp_t *sdp_p, uint16_t level);
+extern sdp_result_e sdp_include_new_filter_src_addr(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ const char *src_addr);
+extern sdp_src_filter_mode_e sdp_get_source_filter_mode(sdp_t *sdp_p,
+ uint16_t level, uint8_t cap_num,
+ uint16_t inst_num);
+extern sdp_result_e sdp_get_filter_destination_attributes(sdp_t *sdp_p,
+ uint16_t level, uint8_t cap_num,
+ uint16_t inst_num,
+ sdp_nettype_e *nettype,
+ sdp_addrtype_e *addrtype,
+ char *dest_addr);
+extern int32_t sdp_get_filter_source_address_count(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num);
+extern sdp_result_e sdp_get_filter_source_address (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ uint16_t src_addr_id,
+ char *src_addr);
+
+extern sdp_rtcp_unicast_mode_e sdp_get_rtcp_unicast_mode(sdp_t *sdp_p,
+ uint16_t level, uint8_t cap_num,
+ uint16_t inst_num);
+
+void sdp_crypto_debug(char *buffer, ulong length_bytes);
+char * sdp_debug_msg_filter(char *buffer, ulong length_bytes);
+
+extern int32_t
+sdp_attr_get_sdescriptions_tag(sdp_t *sdp_p,
+ uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num);
+
+extern sdp_srtp_crypto_suite_t
+sdp_attr_get_sdescriptions_crypto_suite(sdp_t *sdp_p,
+ uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num);
+
+extern const char*
+sdp_attr_get_sdescriptions_key(sdp_t *sdp_p,
+ uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num);
+
+extern const char*
+sdp_attr_get_sdescriptions_salt(sdp_t *sdp_p,
+ uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num);
+
+extern const char*
+sdp_attr_get_sdescriptions_lifetime(sdp_t *sdp_p,
+ uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num);
+
+extern sdp_result_e
+sdp_attr_get_sdescriptions_mki(sdp_t *sdp_p,
+ uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num,
+ const char **mki_value,
+ uint16_t *mki_length);
+
+extern const char*
+sdp_attr_get_sdescriptions_session_params(sdp_t *sdp_p,
+ uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num);
+
+extern unsigned char
+sdp_attr_get_sdescriptions_key_size(sdp_t *sdp_p,
+ uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num);
+
+extern unsigned char
+sdp_attr_get_sdescriptions_salt_size(sdp_t *sdp_p,
+ uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num);
+
+extern unsigned long
+sdp_attr_get_srtp_crypto_selection_flags(sdp_t *sdp_p,
+ uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num);
+
+sdp_result_e
+sdp_attr_get_ice_attribute (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, sdp_attr_e sdp_attr, uint16_t inst_num,
+ char **out);
+
+sdp_result_e
+sdp_attr_get_rtcp_mux_attribute (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, sdp_attr_e sdp_attr, uint16_t inst_num,
+ tinybool *rtcp_mux);
+
+sdp_result_e
+sdp_attr_get_setup_attribute (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, sdp_setup_type_e *setup_type);
+
+sdp_result_e
+sdp_attr_get_connection_attribute (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, sdp_connection_type_e *connection_type);
+
+sdp_result_e
+sdp_attr_get_dtls_fingerprint_attribute (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, sdp_attr_e sdp_attr, uint16_t inst_num,
+ char **out);
+
+sdp_rtcp_fb_ack_type_e
+sdp_attr_get_rtcp_fb_ack(sdp_t *sdp_p, uint16_t level, uint16_t payload_type, uint16_t inst);
+
+sdp_rtcp_fb_nack_type_e
+sdp_attr_get_rtcp_fb_nack(sdp_t *sdp_p, uint16_t level, uint16_t payload_type, uint16_t inst);
+
+uint32_t
+sdp_attr_get_rtcp_fb_trr_int(sdp_t *sdp_p, uint16_t level, uint16_t payload_type,
+ uint16_t inst);
+
+tinybool
+sdp_attr_get_rtcp_fb_remb_enabled(sdp_t *sdp_p, uint16_t level,
+ uint16_t payload_type);
+
+sdp_rtcp_fb_ccm_type_e
+sdp_attr_get_rtcp_fb_ccm(sdp_t *sdp_p, uint16_t level, uint16_t payload_type, uint16_t inst);
+
+sdp_result_e
+sdp_attr_set_rtcp_fb_ack(sdp_t *sdp_p, uint16_t level, uint16_t payload_type, uint16_t inst,
+ sdp_rtcp_fb_ack_type_e type);
+
+sdp_result_e
+sdp_attr_set_rtcp_fb_nack(sdp_t *sdp_p, uint16_t level, uint16_t payload_type, uint16_t inst,
+ sdp_rtcp_fb_nack_type_e);
+
+sdp_result_e
+sdp_attr_set_rtcp_fb_trr_int(sdp_t *sdp_p, uint16_t level, uint16_t payload_type,
+ uint16_t inst, uint32_t interval);
+
+sdp_result_e
+sdp_attr_set_rtcp_fb_remb(sdp_t *sdp_p, uint16_t level, uint16_t payload_type,
+ uint16_t inst);
+
+sdp_result_e
+sdp_attr_set_rtcp_fb_ccm(sdp_t *sdp_p, uint16_t level, uint16_t payload_type, uint16_t inst,
+ sdp_rtcp_fb_ccm_type_e);
+const char *
+sdp_attr_get_extmap_uri(sdp_t *sdp_p, uint16_t level, uint16_t inst);
+
+uint16_t
+sdp_attr_get_extmap_id(sdp_t *sdp_p, uint16_t level, uint16_t inst);
+
+sdp_result_e
+sdp_attr_set_extmap(sdp_t *sdp_p, uint16_t level, uint16_t id, const char* uri, uint16_t inst);
+
+#endif /* _SDP_H_ */
diff --git a/media/webrtc/signaling/src/sdp/sipcc/sdp_access.c b/media/webrtc/signaling/src/sdp/sipcc/sdp_access.c
new file mode 100644
index 000000000..394e69bc8
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/sdp_access.c
@@ -0,0 +1,2083 @@
+/* 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 "sdp_os_defs.h"
+#include "sdp.h"
+#include "sdp_private.h"
+
+#include "CSFLog.h"
+
+static const char* logTag = "sdp_access";
+
+/* Pulled in from ccsip_sdp.h */
+/* Possible encoding names of static payload types*/
+#define SIPSDP_ATTR_ENCNAME_PCMU "PCMU"
+#define SIPSDP_ATTR_ENCNAME_PCMA "PCMA"
+#define SIPSDP_ATTR_ENCNAME_G729 "G729"
+#define SIPSDP_ATTR_ENCNAME_G723 "G723"
+#define SIPSDP_ATTR_ENCNAME_G726 "G726-32"
+#define SIPSDP_ATTR_ENCNAME_G728 "G728"
+#define SIPSDP_ATTR_ENCNAME_GSM "GSM"
+#define SIPSDP_ATTR_ENCNAME_CN "CN"
+#define SIPSDP_ATTR_ENCNAME_G722 "G722"
+#define SIPSDP_ATTR_ENCNAME_ILBC "iLBC"
+#define SIPSDP_ATTR_ENCNAME_H263v2 "H263-1998"
+#define SIPSDP_ATTR_ENCNAME_H264 "H264"
+#define SIPSDP_ATTR_ENCNAME_VP8 "VP8"
+#define SIPSDP_ATTR_ENCNAME_VP9 "VP9"
+#define SIPSDP_ATTR_ENCNAME_L16_256K "L16"
+#define SIPSDP_ATTR_ENCNAME_ISAC "ISAC"
+#define SIPSDP_ATTR_ENCNAME_OPUS "opus"
+#define SIPSDP_ATTR_ENCNAME_RED "red"
+#define SIPSDP_ATTR_ENCNAME_ULPFEC "ulpfec"
+#define SIPSDP_ATTR_ENCNAME_TELEPHONE_EVENT "telephone-event"
+
+/* Function: sdp_find_media_level
+ * Description: Find and return a pointer to the specified media level,
+ * if it exists.
+ * Note: This is not an API for the application but an internal
+ * routine used by the SDP library.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The media level to find.
+ * Returns: Pointer to the media level or NULL if not found.
+ */
+sdp_mca_t *sdp_find_media_level (sdp_t *sdp_p, uint16_t level)
+{
+ int i;
+ sdp_mca_t *mca_p = NULL;
+
+ if ((level >= 1) && (level <= sdp_p->mca_count)) {
+ for (i=1, mca_p = sdp_p->mca_p;
+ ((i < level) && (mca_p != NULL));
+ mca_p = mca_p->next_p, i++) {
+
+ /*sa_ignore EMPTYLOOP*/
+ ; /* Do nothing. */
+ }
+ }
+
+ return (mca_p);
+}
+
+/* Function: sdp_version_valid
+ * Description: Returns true or false depending on whether the version
+ * set for this SDP is valid. Currently the only valid
+ * version is 0.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * Returns: TRUE or FALSE.
+ */
+tinybool sdp_version_valid (sdp_t *sdp_p)
+{
+ if (sdp_p->version == SDP_INVALID_VALUE) {
+ return (FALSE);
+ } else {
+ return (TRUE);
+ }
+}
+
+/* Function: sdp_get_version
+ * Description: Returns the version value set for the given SDP.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * Returns: Version value.
+ */
+int32_t sdp_get_version (sdp_t *sdp_p)
+{
+ return (sdp_p->version);
+}
+
+/* Function: sdp_set_version
+ * Description: Sets the value of the version parameter for the v= version
+ * token line.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * version Version to set.
+ * Returns: SDP_SUCCESS
+ */
+sdp_result_e sdp_set_version (sdp_t *sdp_p, int32_t version)
+{
+ sdp_p->version = version;
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_owner_valid
+ * Description: Returns true or false depending on whether the owner
+ * token line has been defined for this SDP.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * Returns: TRUE or FALSE.
+ */
+tinybool sdp_owner_valid (sdp_t *sdp_p)
+{
+ if ((sdp_p->owner_name[0] == '\0') ||
+ (sdp_p->owner_network_type == SDP_NT_INVALID) ||
+ (sdp_p->owner_addr_type == SDP_AT_INVALID) ||
+ (sdp_p->owner_addr[0] == '\0')) {
+ return (FALSE);
+ } else {
+ return (TRUE);
+ }
+}
+
+/* Function: sdp_get_owner_username
+ * Description: Returns a pointer to the value of the username parameter
+ * from the o= owner token line. Value is returned as a
+ * const ptr and so cannot be modified by the application.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * Returns: Version value.
+ */
+const char *sdp_get_owner_username (sdp_t *sdp_p)
+{
+ return (sdp_p->owner_name);
+}
+
+/* Function: sdp_get_owner_sessionid
+ * Description: Returns the session id parameter from the o= owner token
+ * line. Because the value may be larger than 32 bits, this
+ * parameter is returned as a string, though has been verified
+ * to be numeric. Value is returned as a const ptr and so
+ * cannot be modified by the application.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * Returns: Ptr to owner session id or NULL.
+ */
+const char *sdp_get_owner_sessionid (sdp_t *sdp_p)
+{
+ return (sdp_p->owner_sessid);
+}
+
+/* Function: sdp_get_owner_version
+ * Description: Returns the version parameter from the o= owner token
+ * line. Because the value may be larger than 32 bits, this
+ * parameter is returned as a string, though has been verified
+ * to be numeric. Value is returned as a const ptr and so
+ * cannot be modified by the application.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * Returns: Ptr to owner version or NULL.
+ */
+const char *sdp_get_owner_version (sdp_t *sdp_p)
+{
+ return (sdp_p->owner_version);
+}
+
+/* Function: sdp_get_owner_network_type
+ * Description: Returns the network type parameter from the o= owner token
+ * line. If network type has not been set SDP_NT_INVALID will
+ * be returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * Returns: Network type or SDP_NT_INVALID.
+ */
+sdp_nettype_e sdp_get_owner_network_type (sdp_t *sdp_p)
+{
+ return (sdp_p->owner_network_type);
+}
+
+/* Function: sdp_get_owner_address_type
+ * Description: Returns the address type parameter from the o= owner token
+ * line. If address type has not been set SDP_AT_INVALID will
+ * be returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * Returns: Address type or SDP_AT_INVALID.
+ */
+sdp_addrtype_e sdp_get_owner_address_type (sdp_t *sdp_p)
+{
+ return (sdp_p->owner_addr_type);
+}
+
+/* Function: sdp_get_owner_address
+ * Description: Returns the address parameter from the o= owner token
+ * line. Value is returned as a const ptr and so
+ * cannot be modified by the application.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * Returns: Ptr to address or NULL.
+ */
+const char *sdp_get_owner_address (sdp_t *sdp_p)
+{
+ return (sdp_p->owner_addr);
+}
+
+/* Function: sdp_set_owner_username
+ * Description: Sets the value of the username parameter for the o= owner
+ * token line. The string is copied into the SDP structure
+ * so application memory will not be referenced by the SDP lib.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * username Ptr to the username string.
+ * Returns: SDP_SUCCESS
+ */
+sdp_result_e sdp_set_owner_username (sdp_t *sdp_p, const char *username)
+{
+ sstrncpy(sdp_p->owner_name, username, sizeof(sdp_p->owner_name));
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_set_owner_username
+ * Description: Sets the value of the session id parameter for the o= owner
+ * token line. The string is copied into the SDP structure
+ * so application memory will not be referenced by the SDP lib.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * sessionid Ptr to the sessionid string.
+ * Returns: SDP_SUCCESS
+ */
+sdp_result_e sdp_set_owner_sessionid (sdp_t *sdp_p, const char *sessionid)
+{
+ sstrncpy(sdp_p->owner_sessid, sessionid, sizeof(sdp_p->owner_sessid));
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_set_owner_version
+ * Description: Sets the value of the version parameter for the o= owner
+ * token line. The string is copied into the SDP structure
+ * so application memory will not be referenced by the SDP lib.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * version Ptr to the version string.
+ * Returns: SDP_SUCCESS
+ */
+sdp_result_e sdp_set_owner_version (sdp_t *sdp_p, const char *version)
+{
+ sstrncpy(sdp_p->owner_version, version, sizeof(sdp_p->owner_version));
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_set_owner_network_type
+ * Description: Sets the value of the network type parameter for the o= owner
+ * token line.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * network_type Network type for the owner line.
+ * Returns: SDP_SUCCESS
+ */
+sdp_result_e sdp_set_owner_network_type (sdp_t *sdp_p,
+ sdp_nettype_e network_type)
+{
+ sdp_p->owner_network_type = network_type;
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_set_owner_address_type
+ * Description: Sets the value of the address type parameter for the o= owner
+ * token line.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * address_type Address type for the owner line.
+ * Returns: SDP_SUCCESS
+ */
+sdp_result_e sdp_set_owner_address_type (sdp_t *sdp_p,
+ sdp_addrtype_e address_type)
+{
+ sdp_p->owner_addr_type = address_type;
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_set_owner_address
+ * Description: Sets the value of the address parameter for the o= owner
+ * token line. The string is copied into the SDP structure
+ * so application memory will not be referenced by the SDP lib.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * version Ptr to the version string.
+ * Returns: SDP_SUCCESS
+ */
+sdp_result_e sdp_set_owner_address (sdp_t *sdp_p, const char *address)
+{
+ sstrncpy(sdp_p->owner_addr, address, sizeof(sdp_p->owner_addr));
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_session_name_valid
+ * Description: Returns true or false depending on whether the session name
+ * s= token line has been defined for this SDP.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * Returns: TRUE or FALSE.
+ */
+tinybool sdp_session_name_valid (sdp_t *sdp_p)
+{
+ if (sdp_p->sessname[0] == '\0') {
+ return (FALSE);
+ } else {
+ return (TRUE);
+ }
+}
+
+/* Function: sdp_get_session_name
+ * Description: Returns the session name parameter from the s= session
+ * name token line. Value is returned as a const ptr and so
+ * cannot be modified by the application.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * Returns: Ptr to session name or NULL.
+ */
+const char *sdp_get_session_name (sdp_t *sdp_p)
+{
+ return (sdp_p->sessname);
+}
+
+/* Function: sdp_set_session_name
+ * Description: Sets the value of the session name parameter for the s=
+ * session name token line. The string is copied into the
+ * SDP structure so application memory will not be
+ * referenced by the SDP lib.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * sessname Ptr to the session name string.
+ * Returns: SDP_SUCCESS
+ */
+sdp_result_e sdp_set_session_name (sdp_t *sdp_p, const char *sessname)
+{
+ sstrncpy(sdp_p->sessname, sessname, sizeof(sdp_p->sessname));
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_timespec_valid
+ * Description: Returns true or false depending on whether the timespec t=
+ * token line has been defined for this SDP.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * Returns: TRUE or FALSE.
+ */
+tinybool sdp_timespec_valid (sdp_t *sdp_p)
+{
+ if ((sdp_p->timespec_p == NULL) ||
+ (sdp_p->timespec_p->start_time[0] == '\0') ||
+ (sdp_p->timespec_p->stop_time[0] == '\0')) {
+ return (FALSE);
+ } else {
+ return (TRUE);
+ }
+}
+
+/* Function: sdp_get_time_start
+ * Description: Returns the start time parameter from the t= timespec token
+ * line. Because the value may be larger than 32 bits, this
+ * parameter is returned as a string, though has been verified
+ * to be numeric. Value is returned as a const ptr and so
+ * cannot be modified by the application.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * Returns: Ptr to start time or NULL.
+ */
+const char *sdp_get_time_start (sdp_t *sdp_p)
+{
+ if (sdp_p->timespec_p != NULL) {
+ return (sdp_p->timespec_p->start_time);
+ } else {
+ return (NULL);
+ }
+}
+
+/* Function: sdp_get_time_stop
+ * Description: Returns the stop time parameter from the t= timespec token
+ * line. Because the value may be larger than 32 bits, this
+ * parameter is returned as a string, though has been verified
+ * to be numeric. Value is returned as a const ptr and so
+ * cannot be modified by the application.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * Returns: Ptr to stop time or NULL.
+ */
+const char *sdp_get_time_stop (sdp_t *sdp_p)
+{
+ if (sdp_p->timespec_p != NULL) {
+ return (sdp_p->timespec_p->stop_time);
+ } else {
+ return (NULL);
+ }
+}
+
+/* Function: sdp_set_time_start
+ * Description: Sets the value of the start time parameter for the t=
+ * timespec token line. The string is copied into the
+ * SDP structure so application memory will not be
+ * referenced by the SDP lib.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * start_time Ptr to the start time string.
+ * Returns: SDP_SUCCESS
+ */
+sdp_result_e sdp_set_time_start (sdp_t *sdp_p, const char *start_time)
+{
+ if (sdp_p->timespec_p == NULL) {
+ sdp_p->timespec_p = (sdp_timespec_t *)SDP_MALLOC(sizeof(sdp_timespec_t));
+ if (sdp_p->timespec_p == NULL) {
+ sdp_p->conf_p->num_no_resource++;
+ return (SDP_NO_RESOURCE);
+ }
+ sdp_p->timespec_p->start_time[0] = '\0';
+ sdp_p->timespec_p->stop_time[0] = '\0';
+ }
+ sstrncpy(sdp_p->timespec_p->start_time, start_time,
+ sizeof(sdp_p->timespec_p->start_time));
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_set_time_stop
+ * Description: Sets the value of the stop time parameter for the t=
+ * timespec token line. The string is copied into the
+ * SDP structure so application memory will not be
+ * referenced by the SDP lib.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * stop_time Ptr to the stop time string.
+ * Returns: SDP_SUCCESS
+ */
+sdp_result_e sdp_set_time_stop (sdp_t *sdp_p, const char *stop_time)
+{
+ if (sdp_p->timespec_p == NULL) {
+ sdp_p->timespec_p = (sdp_timespec_t *)SDP_MALLOC(sizeof(sdp_timespec_t));
+ if (sdp_p->timespec_p == NULL) {
+ sdp_p->conf_p->num_no_resource++;
+ return (SDP_NO_RESOURCE);
+ }
+ sdp_p->timespec_p->start_time[0] = '\0';
+ sdp_p->timespec_p->stop_time[0] = '\0';
+ }
+ sstrncpy(sdp_p->timespec_p->stop_time, stop_time,
+ sizeof(sdp_p->timespec_p->stop_time));
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_encryption_valid
+ * Description: Returns true or false depending on whether the encryption k=
+ * token line has been defined for this SDP at the given level.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the k= line. Will be
+ * either SDP_SESSION_LEVEL or 1-n specifying a
+ * media line level.
+ * Returns: TRUE or FALSE.
+ */
+tinybool sdp_encryption_valid (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_encryptspec_t *encrypt_p;
+ sdp_mca_t *mca_p;
+
+ if (level == SDP_SESSION_LEVEL) {
+ encrypt_p = &(sdp_p->encrypt);
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (FALSE);
+ }
+ encrypt_p = &(mca_p->encrypt);
+ }
+
+ if ((encrypt_p->encrypt_type == SDP_ENCRYPT_INVALID) ||
+ ((encrypt_p->encrypt_type != SDP_ENCRYPT_PROMPT) &&
+ (encrypt_p->encrypt_key[0] == '\0'))) {
+ return (FALSE);
+ } else {
+ return (TRUE);
+ }
+}
+
+/* Function: sdp_get_encryption_method
+ * Description: Returns the encryption method parameter from the k=
+ * encryption token line. If encryption method has not been
+ * set SDP_ENCRYPT_INVALID will be returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the c= line. Will be
+ * either SDP_SESSION_LEVEL or 1-n specifying a
+ * media line level.
+ * Returns: Encryption method or SDP_ENCRYPT_INVALID.
+ */
+sdp_encrypt_type_e sdp_get_encryption_method (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_encryptspec_t *encrypt_p;
+ sdp_mca_t *mca_p;
+
+ if (level == SDP_SESSION_LEVEL) {
+ encrypt_p = &(sdp_p->encrypt);
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (SDP_ENCRYPT_INVALID);
+ }
+ encrypt_p = &(mca_p->encrypt);
+ }
+
+ return (encrypt_p->encrypt_type);
+}
+
+/* Function: sdp_get_encryption_key
+ * Description: Returns a pointer to the encryption key parameter
+ * from the k= encryption token line. Value is returned as a
+ * const ptr and so cannot be modified by the application.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the c= line. Will be
+ * either SDP_SESSION_LEVEL or 1-n specifying a
+ * media line level.
+ * Returns: Ptr to encryption key or NULL.
+ */
+const char *sdp_get_encryption_key (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_encryptspec_t *encrypt_p;
+ sdp_mca_t *mca_p;
+
+ if (level == SDP_SESSION_LEVEL) {
+ encrypt_p = &(sdp_p->encrypt);
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (NULL);
+ }
+ encrypt_p = &(mca_p->encrypt);
+ }
+
+ return (encrypt_p->encrypt_key);
+}
+
+/* Function: sdp_connection_valid
+ * Description: Returns true or false depending on whether the connection c=
+ * token line has been defined for this SDP at the given level.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the c= line. Will be
+ * either SDP_SESSION_LEVEL or 1-n specifying a
+ * media line level.
+ * Returns: TRUE or FALSE.
+ */
+tinybool sdp_connection_valid (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_conn_t *conn_p;
+ sdp_mca_t *mca_p;
+
+ if (level == SDP_SESSION_LEVEL) {
+ conn_p = &(sdp_p->default_conn);
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (FALSE);
+ }
+ conn_p = &(mca_p->conn);
+ }
+
+ /*if network type is ATM . then allow c= line without address type
+ * and address . This is a special case to cover PVC
+ */
+ if (conn_p->nettype == SDP_NT_ATM &&
+ conn_p->addrtype == SDP_AT_INVALID) {
+ return TRUE;
+ }
+
+ if ((conn_p->nettype >= SDP_MAX_NETWORK_TYPES) ||
+ (conn_p->addrtype >= SDP_MAX_ADDR_TYPES) ||
+ (conn_p->conn_addr[0] == '\0')) {
+ return (FALSE);
+ } else {
+ return (TRUE);
+ }
+}
+
+/* Function: sdp_bandwidth_valid
+ * Description: Returns true or false depending on whether the bandwidth b=
+ * token line has been defined for this SDP at the given level.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the c= line. Will be
+ * either SDP_SESSION_LEVEL or 1-n specifying a
+ * media line level.
+ * inst_num instance number of bw line at that level. The first
+ * instance has a inst_num of 1 and so on.
+ * Returns: TRUE or FALSE.
+ */
+tinybool sdp_bandwidth_valid (sdp_t *sdp_p, uint16_t level, uint16_t inst_num)
+{
+ sdp_bw_data_t *bw_data_p;
+
+ bw_data_p = sdp_find_bw_line(sdp_p, level, inst_num);
+ if (bw_data_p != NULL) {
+ if ((bw_data_p->bw_modifier < SDP_BW_MODIFIER_AS) ||
+ (bw_data_p->bw_modifier >= SDP_MAX_BW_MODIFIER_VAL)) {
+ return FALSE;
+ } else {
+ return TRUE;
+ }
+ } else {
+ return FALSE;
+ }
+}
+
+/*
+ * sdp_bw_line_exists
+ *
+ * Description: This api retruns true if there exists a bw line at the
+ * instance and level specified.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the c= line. Will be
+ * either SDP_SESSION_LEVEL or 1-n specifying a
+ * media line level.
+ * inst_num instance number of bw line at that level. The first
+ * instance has a inst_num of 1 and so on.
+ * Returns: TRUE or FALSE
+ */
+tinybool sdp_bw_line_exists (sdp_t *sdp_p, uint16_t level, uint16_t inst_num)
+{
+ sdp_bw_data_t *bw_data_p;
+
+ bw_data_p = sdp_find_bw_line(sdp_p, level, inst_num);
+ if (bw_data_p != NULL) {
+ return TRUE;
+ } else {
+ return FALSE;
+ }
+}
+
+/* Function: sdp_get_conn_nettype
+ * Description: Returns the network type parameter from the c=
+ * connection token line. If network type has not been
+ * set SDP_NT_INVALID will be returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the c= line. Will be
+ * either SDP_SESSION_LEVEL or 1-n specifying a
+ * media line level.
+ * Returns: Network type or SDP_NT_INVALID.
+ */
+sdp_nettype_e sdp_get_conn_nettype (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_conn_t *conn_p;
+ sdp_mca_t *mca_p;
+
+ if (level == SDP_SESSION_LEVEL) {
+ conn_p = &(sdp_p->default_conn);
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (SDP_NT_INVALID);
+ }
+ conn_p = &(mca_p->conn);
+ }
+
+ return (conn_p->nettype);
+}
+
+/* Function: sdp_get_conn_addrtype
+ * Description: Returns the address type parameter from the c=
+ * connection token line. If address type has not been
+ * set SDP_AT_INVALID will be returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the c= line. Will be
+ * either SDP_SESSION_LEVEL or 1-n specifying a
+ * media line level.
+ * Returns: Address type or SDP_AT_INVALID.
+ */
+sdp_addrtype_e sdp_get_conn_addrtype (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_conn_t *conn_p;
+ sdp_mca_t *mca_p;
+
+ if (level == SDP_SESSION_LEVEL) {
+ conn_p = &(sdp_p->default_conn);
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (SDP_AT_INVALID);
+ }
+ conn_p = &(mca_p->conn);
+ }
+
+ return (conn_p->addrtype);
+}
+
+/* Function: sdp_get_conn_address
+ * Description: Returns a pointer to the address parameter
+ * from the c= connection token line. Value is returned as a
+ * const ptr and so cannot be modified by the application.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the c= line. Will be
+ * either SDP_SESSION_LEVEL or 1-n specifying a
+ * media line level.
+ * Returns: Ptr to address or NULL.
+ */
+const char *sdp_get_conn_address (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_conn_t *conn_p;
+ sdp_mca_t *mca_p;
+
+ if (level == SDP_SESSION_LEVEL) {
+ conn_p = &(sdp_p->default_conn);
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (NULL);
+ }
+ conn_p = &(mca_p->conn);
+ }
+
+ return (conn_p->conn_addr);
+}
+
+/* Function: sdp_is_mcast_addr
+ * Description: Returns a boolean to indicate if the addr is multicast in
+ * the c=line.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the c= line. Will be
+ * either SDP_SESSION_LEVEL or 1-n specifying a
+ * media line level.
+ * Returns: TRUE if the addr is multicast, FALSE if not.
+ */
+
+tinybool sdp_is_mcast_addr (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_conn_t *conn_p;
+ sdp_mca_t *mca_p;
+
+ if (level == SDP_SESSION_LEVEL) {
+ conn_p = &(sdp_p->default_conn);
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p != NULL) {
+ conn_p = &(mca_p->conn);
+ } else {
+ return (FALSE);
+ }
+ }
+
+ if ((conn_p) && (conn_p->is_multicast)) {
+ return (TRUE);
+ } else {
+ return (FALSE);
+ }
+}
+
+/* Function: sdp_get_mcast_ttl
+ * Description: Get the time to live(ttl) value for the multicast address
+ * if present.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the c= line. Will be
+ * either SDP_SESSION_LEVEL or 1-n specifying a
+ * media line level.
+ * Returns: Multicast address - Time to live (ttl) value
+ */
+
+int32_t sdp_get_mcast_ttl (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_conn_t *conn_p;
+ sdp_mca_t *mca_p;
+ uint16_t ttl=0;
+
+ if (level == SDP_SESSION_LEVEL) {
+ conn_p = &(sdp_p->default_conn);
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p != NULL) {
+ conn_p = &(mca_p->conn);
+ } else {
+ return SDP_INVALID_VALUE;
+ }
+ }
+
+ if (conn_p) {
+ ttl = conn_p->ttl;
+ }
+ return ttl;
+}
+
+/* Function: sdp_get_mcast_num_of_addresses
+ * Description: Get the number of addresses value for the multicast address
+ * if present.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the c= line. Will be
+ * either SDP_SESSION_LEVEL or 1-n specifying a
+ * media line level.
+ * Returns: Multicast address - number of addresses value
+ */
+
+int32_t sdp_get_mcast_num_of_addresses (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_conn_t *conn_p;
+ sdp_mca_t *mca_p;
+ uint16_t num_addr = 0;
+
+ if (level == SDP_SESSION_LEVEL) {
+ conn_p = &(sdp_p->default_conn);
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p != NULL) {
+ conn_p = &(mca_p->conn);
+ } else {
+ return (SDP_INVALID_VALUE);
+ }
+ }
+
+ if (conn_p) {
+ num_addr = conn_p->num_of_addresses;
+ }
+ return num_addr;
+}
+/* Function: sdp_set_conn_nettype
+ * Description: Sets the value of the network type parameter for the c=
+ * connection token line.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * nettype Network type for the connection line.
+ * level The level to check for the c= line. Will be
+ * either SDP_SESSION_LEVEL or 1-n specifying a
+ * media line level.
+ * Returns: SDP_SUCCESS or SDP_INVALID_PARAMETER
+ */
+sdp_result_e sdp_set_conn_nettype (sdp_t *sdp_p, uint16_t level,
+ sdp_nettype_e nettype)
+{
+ sdp_conn_t *conn_p;
+ sdp_mca_t *mca_p;
+
+ if (level == SDP_SESSION_LEVEL) {
+ conn_p = &(sdp_p->default_conn);
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ conn_p = &(mca_p->conn);
+ }
+
+ conn_p->nettype = nettype;
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_set_conn_addrtype
+ * Description: Sets the value of the address type parameter for the c=
+ * connection token line.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * addrtype Address type for the connection line.
+ * level The level to check for the c= line. Will be
+ * either SDP_SESSION_LEVEL or 1-n specifying a
+ * media line level.
+ * Returns: SDP_SUCCESS or SDP_INVALID_PARAMETER
+ */
+sdp_result_e sdp_set_conn_addrtype (sdp_t *sdp_p, uint16_t level,
+ sdp_addrtype_e addrtype)
+{
+ sdp_conn_t *conn_p;
+ sdp_mca_t *mca_p;
+
+ if (level == SDP_SESSION_LEVEL) {
+ conn_p = &(sdp_p->default_conn);
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ conn_p = &(mca_p->conn);
+ }
+
+ conn_p->addrtype = addrtype;
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_set_conn_address
+ * Description: Sets the value of the address parameter for the c=
+ * connection token line. The string is copied into the
+ * SDP structure so application memory will not be
+ * referenced by the SDP lib.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the c= line. Will be
+ * either SDP_SESSION_LEVEL or 1-n specifying a
+ * media line level.
+ * address Ptr to the address string.
+ * Returns: SDP_SUCCESS
+ */
+sdp_result_e sdp_set_conn_address (sdp_t *sdp_p, uint16_t level,
+ const char *address)
+{
+ sdp_conn_t *conn_p;
+ sdp_mca_t *mca_p;
+
+ if (level == SDP_SESSION_LEVEL) {
+ conn_p = &(sdp_p->default_conn);
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ conn_p = &(mca_p->conn);
+ }
+
+ sstrncpy(conn_p->conn_addr, address, sizeof(conn_p->conn_addr));
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_media_line_valid
+ * Description: Returns true or false depending on whether the specified
+ * media line m= has been defined for this SDP. The
+ * SDP_SESSION_LEVEL level is not valid for this check since,
+ * by definition, this is a media level.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the c= line. Will be
+ * 1-n specifying a media line level.
+ * Returns: TRUE or FALSE.
+ */
+tinybool sdp_media_line_valid (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (FALSE);
+ }
+
+ /* Validate params for this media line */
+ if ((mca_p->media >= SDP_MAX_MEDIA_TYPES) ||
+ (mca_p->port_format >= SDP_MAX_PORT_FORMAT_TYPES) ||
+ (mca_p->transport >= SDP_MAX_TRANSPORT_TYPES) ||
+ (mca_p->num_payloads == 0)) {
+ return (FALSE);
+ } else {
+ return (TRUE);
+ }
+}
+
+/* Function: sdp_get_num_media_lines
+ * Description: Returns the number of media lines associated with the SDP.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * Returns: Number of media lines.
+ */
+uint16_t sdp_get_num_media_lines (sdp_t *sdp_p)
+{
+ return (sdp_p->mca_count);
+}
+
+/* Function: sdp_get_media_type
+ * Description: Returns the media type parameter from the m=
+ * media token line. If media type has not been
+ * set SDP_MEDIA_INVALID will be returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to of the m= media line. Will be 1-n.
+ * Returns: Media type or SDP_MEDIA_INVALID.
+ */
+sdp_media_e sdp_get_media_type (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (SDP_MEDIA_INVALID);
+ }
+
+ return (mca_p->media);
+}
+
+/* Function: sdp_get_media_line_number
+ * Description: Returns the line number in the SDP the media
+ * section starts on. Only set if SDP has been parsed
+ * (rather than built).
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to of the m= media line. Will be 1-n.
+ * Returns: Line number (0 if not found or if locally built)
+ */
+uint32_t sdp_get_media_line_number (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return 0;
+ }
+
+ return (mca_p->line_number);
+}
+
+/* Function: sdp_get_media_port_format
+ * Description: Returns the port format type associated with the m=
+ * media token line. If port format type has not been
+ * set SDP_PORT_FORMAT_INVALID will be returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to of the m= media line. Will be 1-n.
+ * Returns: Port format type or SDP_PORT_FORMAT_INVALID.
+ */
+sdp_port_format_e sdp_get_media_port_format (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (SDP_PORT_FORMAT_INVALID);
+ }
+
+ return (mca_p->port_format);
+}
+
+/* Function: sdp_get_media_portnum
+ * Description: Returns the port number associated with the m=
+ * media token line. If port number has not been
+ * set SDP_INVALID_VALUE will be returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to of the m= media line. Will be 1-n.
+ * Returns: Port number or SDP_INVALID_VALUE.
+ */
+int32_t sdp_get_media_portnum (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (SDP_INVALID_VALUE);
+ }
+
+ /* Make sure port number is valid for the specified format. */
+ if ((mca_p->port_format != SDP_PORT_NUM_ONLY) &&
+ (mca_p->port_format != SDP_PORT_NUM_COUNT) &&
+ (mca_p->port_format != SDP_PORT_NUM_VPI_VCI) &&
+ (mca_p->port_format != SDP_PORT_NUM_VPI_VCI_CID)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Port num not valid for media line %u",
+ sdp_p->debug_str, (unsigned)level);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ }
+
+ return (mca_p->port);
+}
+
+/* Function: sdp_get_media_portcount
+ * Description: Returns the port count associated with the m=
+ * media token line. If port count has not been
+ * set SDP_INVALID_VALUE will be returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to of the m= media line. Will be 1-n.
+ * Returns: Port count or SDP_INVALID_VALUE.
+ */
+int32_t sdp_get_media_portcount (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (SDP_INVALID_VALUE);
+ }
+
+ /* Make sure port number is valid for the specified format. */
+ if (mca_p->port_format != SDP_PORT_NUM_COUNT) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Port count not valid for media line %u",
+ sdp_p->debug_str, (unsigned)level);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ }
+
+ return (mca_p->num_ports);
+}
+
+/* Function: sdp_get_media_vpi
+ * Description: Returns the VPI parameter associated with the m=
+ * media token line. If VPI has not been set
+ * SDP_INVALID_VALUE will be returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to of the m= media line. Will be 1-n.
+ * Returns: VPI or SDP_INVALID_VALUE.
+ */
+int32_t sdp_get_media_vpi (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (SDP_INVALID_VALUE);
+ }
+
+ /* Make sure port number is valid for the specified format. */
+ if ((mca_p->port_format != SDP_PORT_VPI_VCI) &&
+ (mca_p->port_format != SDP_PORT_NUM_VPI_VCI) &&
+ (mca_p->port_format != SDP_PORT_NUM_VPI_VCI_CID)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s VPI not valid for media line %u",
+ sdp_p->debug_str, (unsigned)level);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ }
+
+ return (mca_p->vpi);
+}
+
+/* Function: sdp_get_media_vci
+ * Description: Returns the VCI parameter associated with the m=
+ * media token line. If VCI has not been set
+ * SDP_INVALID_VALUE will be returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to of the m= media line. Will be 1-n.
+ * Returns: VCI or zero.
+ */
+uint32_t sdp_get_media_vci (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (0);
+ }
+
+ /* Make sure port number is valid for the specified format. */
+ if ((mca_p->port_format != SDP_PORT_VPI_VCI) &&
+ (mca_p->port_format != SDP_PORT_NUM_VPI_VCI) &&
+ (mca_p->port_format != SDP_PORT_NUM_VPI_VCI_CID)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s VCI not valid for media line %u",
+ sdp_p->debug_str, (unsigned)level);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ }
+
+ return (mca_p->vci);
+}
+
+/* Function: sdp_get_media_vcci
+ * Description: Returns the VCCI parameter associated with the m=
+ * media token line. If VCCI has not been set
+ * SDP_INVALID_VALUE will be returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to of the m= media line. Will be 1-n.
+ * Returns: VCCI or SDP_INVALID_VALUE.
+ */
+int32_t sdp_get_media_vcci (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (SDP_INVALID_VALUE);
+ }
+
+ /* Make sure port number is valid for the specified format. */
+ if ((mca_p->port_format != SDP_PORT_VCCI) &&
+ (mca_p->port_format != SDP_PORT_VCCI_CID)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s VCCI not valid for media line %u",
+ sdp_p->debug_str, (unsigned)level);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ }
+
+ return (mca_p->vcci);
+}
+
+/* Function: sdp_get_media_cid
+ * Description: Returns the CID parameter associated with the m=
+ * media token line. If CID has not been set
+ * SDP_INVALID_VALUE will be returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to of the m= media line. Will be 1-n.
+ * Returns: CID or SDP_INVALID_VALUE.
+ */
+int32_t sdp_get_media_cid (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (SDP_INVALID_VALUE);
+ }
+
+ /* Make sure port number is valid for the specified format. */
+ if ((mca_p->port_format != SDP_PORT_VCCI_CID) &&
+ (mca_p->port_format != SDP_PORT_NUM_VPI_VCI_CID)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s CID not valid for media line %u",
+ sdp_p->debug_str, (unsigned)level);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ }
+
+ return (mca_p->cid);
+}
+
+/* Function: sdp_get_media_transport
+ * Description: Returns the transport type parameter associated with the m=
+ * media token line. If transport type has not been set
+ * SDP_TRANSPORT_INVALID will be returned. If the transport
+ * type is one of the AAL2 variants, the profile routines below
+ * should be used to access multiple profile types and payload
+ * lists per m= line.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to of the m= media line. Will be 1-n.
+ * Returns: CID or SDP_TRANSPORT_INVALID.
+ */
+sdp_transport_e sdp_get_media_transport (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (SDP_TRANSPORT_INVALID);
+ }
+
+ return (mca_p->transport);
+}
+
+/* Function: sdp_get_media_num_profiles
+ * Description: Returns the number of profiles associated with the m=
+ * media token line. If the media line is invalid, zero will
+ * be returned. Application must validate the media line
+ * before using this routine. Multiple profile types per
+ * media line is currently only used for AAL2. If the appl
+ * detects that the transport type is one of the AAL2 types,
+ * it should use these profile access routines to access the
+ * profile types and payload list for each.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to of the m= media line. Will be 1-n.
+ * Returns: Number of profiles or zero.
+ */
+uint16_t sdp_get_media_num_profiles (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (0);
+ }
+
+ if (mca_p->media_profiles_p == NULL) {
+ return (0);
+ } else {
+ return (mca_p->media_profiles_p->num_profiles);
+ }
+}
+
+/* Function: sdp_get_media_profile
+ * Description: Returns the specified profile type associated with the m=
+ * media token line. If the media line or profile number is
+ * invalid, SDP_TRANSPORT_INVALID will be returned.
+ * Applications must validate the media line before using this
+ * routine.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to of the m= media line. Will be 1-n.
+ * profile_num The specific profile type number to be retrieved.
+ * Returns: The profile type or SDP_TRANSPORT_INVALID.
+ */
+sdp_transport_e sdp_get_media_profile (sdp_t *sdp_p, uint16_t level,
+ uint16_t profile_num)
+{
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (SDP_TRANSPORT_INVALID);
+ }
+
+ if ((profile_num < 1) ||
+ (profile_num > mca_p->media_profiles_p->num_profiles)) {
+ return (SDP_TRANSPORT_INVALID);
+ } else {
+ return (mca_p->media_profiles_p->profile[profile_num-1]);
+ }
+}
+
+/* Function: sdp_get_media_num_payload_types
+ * Description: Returns the number of payload types associated with the m=
+ * media token line. If the media line is invalid, zero will
+ * be returned. Application must validate the media line
+ * before using this routine.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to of the m= media line. Will be 1-n.
+ * Returns: Number of payload types or zero.
+ */
+uint16_t sdp_get_media_num_payload_types (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (0);
+ }
+
+ return (mca_p->num_payloads);
+}
+
+/* Function: sdp_get_media_profile_num_payload_types
+ * Description: Returns the number of payload types associated with the
+ * specified profile on the m= media token line. If the
+ * media line or profile number is invalid, zero will
+ * be returned. Application must validate the media line
+ * and profile before using this routine.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to of the m= media line. Will be 1-n.
+ * profile_num The specific profile number. Will be 1-n.
+ * Returns: Number of payload types or zero.
+ */
+uint16_t sdp_get_media_profile_num_payload_types (sdp_t *sdp_p, uint16_t level,
+ uint16_t profile_num)
+{
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (0);
+ }
+
+ if ((profile_num < 1) ||
+ (profile_num > mca_p->media_profiles_p->num_profiles)) {
+ return (0);
+ } else {
+ return (mca_p->media_profiles_p->num_payloads[profile_num-1]);
+ }
+}
+
+rtp_ptype sdp_get_known_payload_type(sdp_t *sdp_p,
+ uint16_t level,
+ uint16_t payload_type_raw) {
+ sdp_attr_t *attr_p;
+ sdp_transport_map_t *rtpmap;
+ uint16_t pack_mode = 0; /*default 0, if remote did not provide any */
+ const char *encname = NULL;
+ uint16_t num_a_lines = 0;
+ int i;
+
+ /*
+ * Get number of RTPMAP attributes for the media line
+ */
+ (void) sdp_attr_num_instances(sdp_p, level, 0, SDP_ATTR_RTPMAP,
+ &num_a_lines);
+
+ /*
+ * Loop through media line RTPMAP attributes.
+ */
+ for (i = 0; i < num_a_lines; i++) {
+ attr_p = sdp_find_attr(sdp_p, level, 0, SDP_ATTR_RTPMAP, (i + 1));
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s rtpmap attribute, level %u instance %u "
+ "not found.",
+ sdp_p->debug_str,
+ (unsigned)level,
+ (unsigned)(i + 1));
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (RTP_NONE);
+ }
+
+ rtpmap = &(attr_p->attr.transport_map);
+
+ if (rtpmap->payload_num == payload_type_raw) {
+ encname = rtpmap->encname;
+ if (encname) {
+ if (cpr_strcasecmp(encname, SIPSDP_ATTR_ENCNAME_ILBC) == 0) {
+ return (RTP_ILBC);
+ }
+ if (cpr_strcasecmp(encname, SIPSDP_ATTR_ENCNAME_L16_256K) == 0) {
+ return (RTP_L16);
+ }
+ if (cpr_strcasecmp(encname, SIPSDP_ATTR_ENCNAME_ISAC) == 0) {
+ return (RTP_ISAC);
+ }
+ if (cpr_strcasecmp(encname, SIPSDP_ATTR_ENCNAME_OPUS) == 0) {
+ return (RTP_OPUS);
+ }
+ if (cpr_strcasecmp(encname, SIPSDP_ATTR_ENCNAME_PCMU) == 0) {
+ return (RTP_PCMU);
+ }
+ if (cpr_strcasecmp(encname, SIPSDP_ATTR_ENCNAME_PCMA) == 0) {
+ return (RTP_PCMA);
+ }
+ if (cpr_strcasecmp(encname, SIPSDP_ATTR_ENCNAME_G722) == 0) {
+ return (RTP_G722);
+ }
+ if (cpr_strcasecmp(encname, SIPSDP_ATTR_ENCNAME_H264) == 0) {
+ int fmtp_inst = sdp_find_fmtp_inst(sdp_p, level, rtpmap->payload_num);
+ if (fmtp_inst < 0) {
+ return (RTP_H264_P0);
+ } else {
+ sdp_attr_get_fmtp_pack_mode(sdp_p, level, 0, (uint16_t) fmtp_inst, &pack_mode);
+ if (pack_mode == SDP_DEFAULT_PACKETIZATION_MODE_VALUE) {
+ return (RTP_H264_P0);
+ } else {
+ return (RTP_H264_P1);
+ }
+ }
+ }
+ if (cpr_strcasecmp(encname, SIPSDP_ATTR_ENCNAME_VP8) == 0) {
+ return (RTP_VP8);
+ }
+ if (cpr_strcasecmp(encname, SIPSDP_ATTR_ENCNAME_VP9) == 0) {
+ return (RTP_VP9);
+ }
+ if (cpr_strcasecmp(encname, SIPSDP_ATTR_ENCNAME_RED) == 0) {
+ return (RTP_RED);
+ }
+ if (cpr_strcasecmp(encname, SIPSDP_ATTR_ENCNAME_ULPFEC) == 0) {
+ return (RTP_ULPFEC);
+ }
+ if (cpr_strcasecmp(encname, SIPSDP_ATTR_ENCNAME_TELEPHONE_EVENT) == 0) {
+ return (RTP_TELEPHONE_EVENT);
+ }
+ }
+ }
+ }
+
+ return (RTP_NONE);
+}
+
+/* Function: sdp_get_media_payload_type
+ * Description: Returns the payload type of the specified payload for the m=
+ * media token line. If the media line or payload number is
+ * invalid, zero will be returned. Application must validate
+ * the media line before using this routine.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to of the m= media line. Will be 1-n.
+ * payload_num Number of the payload type to retrieve. The
+ * range is (1 - max num payloads).
+ * indicator Returns the type of payload returned, either
+ * NUMERIC or ENUM.
+ * Returns: Payload type or zero.
+ */
+uint32_t sdp_get_media_payload_type (sdp_t *sdp_p, uint16_t level, uint16_t payload_num,
+ sdp_payload_ind_e *indicator)
+{
+ sdp_mca_t *mca_p;
+ rtp_ptype ptype;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (0);
+ }
+
+ if ((payload_num < 1) || (payload_num > mca_p->num_payloads)) {
+ return (0);
+ }
+
+ *indicator = mca_p->payload_indicator[payload_num-1];
+ if ((mca_p->payload_type[payload_num-1] >= SDP_MIN_DYNAMIC_PAYLOAD) &&
+ (mca_p->payload_type[payload_num-1] <= SDP_MAX_DYNAMIC_PAYLOAD)) {
+ ptype = sdp_get_known_payload_type(sdp_p,
+ level,
+ mca_p->payload_type[payload_num-1]);
+ if (ptype != RTP_NONE) {
+ return (SET_PAYLOAD_TYPE_WITH_DYNAMIC(
+ mca_p->payload_type[payload_num-1], ptype));
+ }
+
+ }
+ return (mca_p->payload_type[payload_num-1]);
+}
+
+/* Function: sdp_get_media_profile_payload_type
+ * Description: Returns the payload type of the specified payload for the m=
+ * media token line. If the media line or payload number is
+ * invalid, zero will be returned. Application must validate
+ * the media line before using this routine.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to of the m= media line. Will be 1-n.
+ * payload_num Number of the payload type to retrieve. The
+ * range is (1 - max num payloads).
+ * indicator Returns the type of payload returned, either
+ * NUMERIC or ENUM.
+ * Returns: Payload type or zero.
+ */
+uint32_t sdp_get_media_profile_payload_type (sdp_t *sdp_p, uint16_t level, uint16_t prof_num,
+ uint16_t payload_num,
+ sdp_payload_ind_e *indicator)
+{
+ sdp_mca_t *mca_p;
+ sdp_media_profiles_t *prof_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (0);
+ }
+
+ prof_p = mca_p->media_profiles_p;
+ if ((prof_num < 1) ||
+ (prof_num > prof_p->num_profiles)) {
+ return (0);
+ }
+
+ if ((payload_num < 1) ||
+ (payload_num > prof_p->num_payloads[prof_num-1])) {
+ return (0);
+ }
+
+ *indicator = prof_p->payload_indicator[prof_num-1][payload_num-1];
+ return (prof_p->payload_type[prof_num-1][payload_num-1]);
+}
+
+/* Function: sdp_insert_media_line
+ * Description: Insert a new media line at the level specified for the
+ * given SDP.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The new media level to insert. Will be 1-n.
+ * Returns: SDP_SUCCESS, SDP_NO_RESOURCE, or SDP_INVALID_PARAMETER
+ */
+sdp_result_e sdp_insert_media_line (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_mca_t *mca_p;
+ sdp_mca_t *new_mca_p;
+
+ if ((level < 1) || (level > (sdp_p->mca_count+1))) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Invalid media line (%u) to insert, max is "
+ "(%u).", sdp_p->debug_str, (unsigned)level, (unsigned)sdp_p->mca_count);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Allocate resource for new media stream. */
+ new_mca_p = sdp_alloc_mca(0);
+ if (new_mca_p == NULL) {
+ sdp_p->conf_p->num_no_resource++;
+ return (SDP_NO_RESOURCE);
+ }
+
+ if (level == 1) {
+ /* We're inserting the first media line */
+ new_mca_p->next_p = sdp_p->mca_p;
+ sdp_p->mca_p = new_mca_p;
+ } else {
+ /* Find the pointer to the media stream just prior to where
+ * we want to insert the new stream.
+ */
+ mca_p = sdp_find_media_level(sdp_p, (uint16_t)(level-1));
+ if (mca_p == NULL) {
+ SDP_FREE(new_mca_p);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ new_mca_p->next_p = mca_p->next_p;
+ mca_p->next_p = new_mca_p;
+ }
+
+ sdp_p->mca_count++;
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_set_media_type
+ * Description: Sets the value of the media type parameter for the m=
+ * media token line.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The media level to set the param. Will be 1-n.
+ * media Media type for the media line.
+ * Returns: SDP_SUCCESS or SDP_INVALID_PARAMETER
+ */
+sdp_result_e sdp_set_media_type (sdp_t *sdp_p, uint16_t level, sdp_media_e media)
+{
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ mca_p->media = media;
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_set_media_portnum
+ * Description: Sets the value of the port number parameter for the m=
+ * media token line. If the port number is not valid with the
+ * port format specified for the media line, this call will
+ * fail.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The media level to set the param. Will be 1-n.
+ * portnum Port number to set.
+ * sctpport sctp port for application m= line
+ * Returns: SDP_SUCCESS or SDP_INVALID_PARAMETER
+ */
+sdp_result_e sdp_set_media_portnum (sdp_t *sdp_p, uint16_t level, int32_t portnum, int32_t sctp_port)
+{
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ mca_p->port = portnum;
+ mca_p->sctpport = sctp_port;
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_get_media_sctp_port
+ * Description: Gets the value of the sctp port number parameter for the m=
+ * media token line.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The media level to set the param. Will be 1-n.
+ * Returns: sctp_port or -1 on failure
+ */
+int32_t sdp_get_media_sctp_port(sdp_t *sdp_p, uint16_t level)
+{
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (!mca_p) {
+ sdp_p->conf_p->num_invalid_param++;
+ return -1;
+ }
+
+ return mca_p->sctpport;
+}
+
+/* Function: sdp_set_media_transport
+ * Description: Sets the value of the transport type parameter for the m=
+ * media token line.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The media level to set the param. Will be 1-n.
+ * transport The transport type to set.
+ * Returns: SDP_SUCCESS or SDP_INVALID_PARAMETER
+ */
+sdp_result_e sdp_set_media_transport (sdp_t *sdp_p, uint16_t level,
+ sdp_transport_e transport)
+{
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ mca_p->transport = transport;
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_add_media_profile
+ * Description: Add a new profile type for the m= media token line. This is
+ * used for AAL2 transport/profile types where more than one can
+ * be specified per media line. All other transport types should
+ * use the other transport access routines rather than this.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The media level to add the param. Will be 1-n.
+ * profile The profile type to add.
+ * Returns: SDP_SUCCESS or SDP_INVALID_PARAMETER
+ */
+sdp_result_e sdp_add_media_profile (sdp_t *sdp_p, uint16_t level,
+ sdp_transport_e profile)
+{
+ uint16_t prof_num;
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ if (mca_p->media_profiles_p == NULL) {
+ mca_p->media_profiles_p = (sdp_media_profiles_t *) \
+ SDP_MALLOC(sizeof(sdp_media_profiles_t));
+ if (mca_p->media_profiles_p == NULL) {
+ sdp_p->conf_p->num_no_resource++;
+ return (SDP_NO_RESOURCE);
+ } else {
+ mca_p->media_profiles_p->num_profiles = 0;
+ /* Set the transport type to this first profile type. */
+ mca_p->transport = profile;
+ }
+ }
+
+ if (mca_p->media_profiles_p->num_profiles >= SDP_MAX_PROFILES) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Max number of media profiles already specified"
+ " for media level %u", sdp_p->debug_str, (unsigned)level);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ prof_num = mca_p->media_profiles_p->num_profiles++;
+ mca_p->media_profiles_p->profile[prof_num] = profile;
+ mca_p->media_profiles_p->num_payloads[prof_num] = 0;
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_add_media_payload_type
+ * Description: Add a new payload type for the media line at the level
+ * specified. The new payload type will be added at the end
+ * of the payload type list.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The media level to add the payload. Will be 1-n.
+ * payload_type The new payload type.
+ * indicator Defines the type of payload returned, either
+ * NUMERIC or ENUM.
+ * Returns: SDP_SUCCESS or SDP_INVALID_PARAMETER
+ */
+sdp_result_e sdp_add_media_payload_type (sdp_t *sdp_p, uint16_t level,
+ uint16_t payload_type,
+ sdp_payload_ind_e indicator)
+{
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ if (mca_p->num_payloads == SDP_MAX_PAYLOAD_TYPES) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Max number of payload types already defined "
+ "for media line %u", sdp_p->debug_str, (unsigned)level);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ mca_p->payload_indicator[mca_p->num_payloads] = indicator;
+ mca_p->payload_type[mca_p->num_payloads++] = payload_type;
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_add_media_profile_payload_type
+ * Description: Add a new payload type for the media line at the level
+ * specified. The new payload type will be added at the end
+ * of the payload type list.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The media level to add the payload. Will be 1-n.
+ * prof_num The profile number to add the payload type.
+ * payload_type The new payload type.
+ * indicator Defines the type of payload returned, either
+ * NUMERIC or ENUM.
+ * Returns: SDP_SUCCESS or SDP_INVALID_PARAMETER
+ */
+sdp_result_e sdp_add_media_profile_payload_type (sdp_t *sdp_p, uint16_t level,
+ uint16_t prof_num, uint16_t payload_type,
+ sdp_payload_ind_e indicator)
+{
+ uint16_t num_payloads;
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ if ((prof_num < 1) ||
+ (prof_num > mca_p->media_profiles_p->num_profiles)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Invalid profile number (%u) for set profile "
+ " payload type", sdp_p->debug_str, (unsigned)level);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ if (mca_p->media_profiles_p->num_payloads[prof_num-1] ==
+ SDP_MAX_PAYLOAD_TYPES) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Max number of profile payload types already "
+ "defined profile %u on media line %u",
+ sdp_p->debug_str, (unsigned)prof_num, (unsigned)level);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Get the current num payloads for this profile, and inc the number
+ * of payloads at the same time. Then store the new payload type. */
+ num_payloads = mca_p->media_profiles_p->num_payloads[prof_num-1]++;
+ mca_p->media_profiles_p->payload_indicator[prof_num-1][num_payloads] =
+ indicator;
+ mca_p->media_profiles_p->payload_type[prof_num-1][num_payloads] =
+ payload_type;
+ return (SDP_SUCCESS);
+}
+
+/*
+ * sdp_find_bw_line
+ *
+ * This helper function locates a specific bw line instance given the
+ * sdp, the level and the instance number of the bw line.
+ *
+ * Returns: Pointer to the sdp_bw_data_t instance, or NULL.
+ */
+sdp_bw_data_t* sdp_find_bw_line (sdp_t *sdp_p, uint16_t level, uint16_t inst_num)
+{
+ sdp_bw_t *bw_p;
+ sdp_bw_data_t *bw_data_p;
+ sdp_mca_t *mca_p;
+ int bw_attr_count=0;
+
+ if (level == SDP_SESSION_LEVEL) {
+ bw_p = &(sdp_p->bw);
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ sdp_p->conf_p->num_invalid_param++;
+ return (NULL);
+ }
+ bw_p = &(mca_p->bw);
+ }
+
+ for (bw_data_p = bw_p->bw_data_list;
+ bw_data_p != NULL;
+ bw_data_p = bw_data_p->next_p) {
+ bw_attr_count++;
+ if (bw_attr_count == inst_num) {
+ return bw_data_p;
+ }
+ }
+
+ return NULL;
+}
+
+/*
+ * sdp_copy_all_bw_lines
+ *
+ * Appends all the bw lines from the specified level of the orig sdp to the
+ * specified level of the dst sdp.
+ *
+ * Parameters: src_sdp_p The source SDP handle.
+ * dst_sdp_p The dest SDP handle.
+ * src_level The level in the src sdp from where to get the
+ * attributes.
+ * dst_level The level in the dst sdp where to put the
+ * attributes.
+ * Returns: SDP_SUCCESS Attributes were successfully copied.
+ */
+sdp_result_e sdp_copy_all_bw_lines (sdp_t *src_sdp_p, sdp_t *dst_sdp_p,
+ uint16_t src_level, uint16_t dst_level)
+{
+ sdp_bw_data_t *orig_bw_data_p;
+ sdp_bw_data_t *new_bw_data_p;
+ sdp_bw_data_t *bw_data_p;
+ sdp_bw_t *src_bw_p;
+ sdp_bw_t *dst_bw_p;
+ sdp_mca_t *mca_p;
+
+ /* Find src bw list */
+ if (src_level == SDP_SESSION_LEVEL) {
+ src_bw_p = &(src_sdp_p->bw);
+ } else {
+ mca_p = sdp_find_media_level(src_sdp_p, src_level);
+ if (mca_p == NULL) {
+ if (src_sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Invalid src media level (%u) for copy all "
+ "attrs ", src_sdp_p->debug_str, (unsigned)src_level);
+ }
+ return (SDP_INVALID_PARAMETER);
+ }
+ src_bw_p = &(mca_p->bw);
+ }
+
+ /* Find dst bw list */
+ if (dst_level == SDP_SESSION_LEVEL) {
+ dst_bw_p = &(dst_sdp_p->bw);
+ } else {
+ mca_p = sdp_find_media_level(dst_sdp_p, dst_level);
+ if (mca_p == NULL) {
+ if (src_sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Invalid dst media level (%u) for copy all "
+ "attrs ", src_sdp_p->debug_str, (unsigned)dst_level);
+ }
+ return (SDP_INVALID_PARAMETER);
+ }
+ dst_bw_p = &(mca_p->bw);
+ }
+
+ orig_bw_data_p = src_bw_p->bw_data_list;
+ while (orig_bw_data_p) {
+ /* For ever bw line in the src, allocate a new one for the dst */
+ new_bw_data_p = (sdp_bw_data_t*)SDP_MALLOC(sizeof(sdp_bw_data_t));
+ if (new_bw_data_p == NULL) {
+ return (SDP_NO_RESOURCE);
+ }
+ new_bw_data_p->next_p = NULL;
+ new_bw_data_p->bw_modifier = orig_bw_data_p->bw_modifier;
+ new_bw_data_p->bw_val = orig_bw_data_p->bw_val;
+
+ /*
+ * Enqueue the sdp_bw_data_t instance at the end of the list of
+ * sdp_bw_data_t instances.
+ */
+ if (dst_bw_p->bw_data_list == NULL) {
+ dst_bw_p->bw_data_list = new_bw_data_p;
+ } else {
+ for (bw_data_p = dst_bw_p->bw_data_list;
+ bw_data_p->next_p != NULL;
+ bw_data_p = bw_data_p->next_p) {
+
+ /*sa_ignore EMPTYLOOP*/
+ ; /* Do nothing. */
+ }
+
+ bw_data_p->next_p = new_bw_data_p;
+ }
+ dst_bw_p->bw_data_count++;
+
+ orig_bw_data_p = orig_bw_data_p->next_p;
+ }
+
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_get_bw_modifier
+ * Description: Returns the bandwidth modifier parameter from the b=
+ * line. If no bw modifier has been set ,
+ * SDP_BW_MODIFIER_UNSUPPORTED will be returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level from which to get the bw modifier.
+ * inst_num instance number of bw line at that level. The first
+ * instance has a inst_num of 1 and so on.
+ * Returns: Valid modifer value or SDP_BW_MODIFIER_UNSUPPORTED.
+ */
+sdp_bw_modifier_e sdp_get_bw_modifier (sdp_t *sdp_p, uint16_t level, uint16_t inst_num)
+{
+ sdp_bw_data_t *bw_data_p;
+
+ bw_data_p = sdp_find_bw_line(sdp_p, level, inst_num);
+
+ if (bw_data_p) {
+ return (bw_data_p->bw_modifier);
+ } else {
+ return (SDP_BW_MODIFIER_UNSUPPORTED);
+ }
+}
+
+/* Function: sdp_get_bw_value
+ * Description: Returns the bandwidth value parameter from the b=
+ * line.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level from which to get the bw value.
+ * inst_num instance number of bw line at the level. The first
+ * instance has a inst_num of 1 and so on.
+ * Returns: A valid numerical bw value or SDP_INVALID_VALUE.
+ */
+int32_t sdp_get_bw_value (sdp_t *sdp_p, uint16_t level, uint16_t inst_num)
+{
+ sdp_bw_data_t *bw_data_p;
+
+ bw_data_p = sdp_find_bw_line(sdp_p, level, inst_num);
+
+ if (bw_data_p) {
+ return (bw_data_p->bw_val);
+ } else {
+ return (SDP_INVALID_VALUE);
+ }
+}
+
+/*
+ * sdp_get_num_bw_lines
+ *
+ * Returns the number of bw lines are present at a given level.
+ *
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level at which the count of bw lines is required
+ *
+ * Returns: A valid count or SDP_INVALID_VALUE
+ */
+int32_t sdp_get_num_bw_lines (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_bw_t *bw_p;
+ sdp_mca_t *mca_p;
+
+ if (level == SDP_SESSION_LEVEL) {
+ bw_p = &(sdp_p->bw);
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ }
+ bw_p = &(mca_p->bw);
+ }
+
+ return (bw_p->bw_data_count);
+}
+
+/*
+ * sdp_add_new_bw_line
+ *
+ * To specify bandwidth parameters at any level, a bw line must first be
+ * added at that level using this function. After this addition, you can set
+ * the properties of the added bw line by using sdp_set_bw().
+ *
+ * Note carefully though, that since there can be multiple instances of bw
+ * lines at any level, you must specify the instance number when setting
+ * or getting the properties of a bw line at any level.
+ *
+ * This function returns within the inst_num variable, the instance number
+ * of the created bw_line at that level. The instance number is 1-based.
+ * For example:
+ * v=0 #Session Level
+ * o=mhandley 2890844526 2890842807 IN IP4 126.16.64.4
+ * s=SDP Seminar
+ * c=IN IP4 10.1.0.2
+ * t=0 0
+ * b=AS:60 # instance number 1
+ * b=TIAS:50780 # instance number 2
+ * m=audio 1234 RTP/AVP 0 101 102 # 1st Media level
+ * b=AS:12 # instance number 1
+ * b=TIAS:8480 # instance number 2
+ * m=audio 1234 RTP/AVP 0 101 102 # 2nd Media level
+ * b=AS:20 # instance number 1
+ *
+ * Parameters:
+ * sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to create the bw line.
+ * bw_modifier The Type of bandwidth, CT, AS or TIAS.
+ * *inst_num This memory is set with the instance number of the newly
+ * created bw line instance.
+ */
+sdp_result_e sdp_add_new_bw_line (sdp_t *sdp_p, uint16_t level, sdp_bw_modifier_e bw_modifier, uint16_t *inst_num)
+{
+ sdp_bw_t *bw_p;
+ sdp_mca_t *mca_p;
+ sdp_bw_data_t *new_bw_data_p;
+ sdp_bw_data_t *bw_data_p = NULL;
+
+ *inst_num = 0;
+
+ if (level == SDP_SESSION_LEVEL) {
+ bw_p = &(sdp_p->bw);
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ bw_p = &(mca_p->bw);
+ }
+
+ //see if a bw line already exist for this bw_modifier.
+ for(bw_data_p = bw_p->bw_data_list; bw_data_p != NULL; bw_data_p = bw_data_p->next_p) {
+ ++(*inst_num);
+ if (bw_data_p->bw_modifier == bw_modifier) {
+ return (SDP_SUCCESS);
+ }
+ }
+
+ /*
+ * Allocate a new sdp_bw_data_t instance and set it's values from the
+ * input parameters.
+ */
+ new_bw_data_p = (sdp_bw_data_t*)SDP_MALLOC(sizeof(sdp_bw_data_t));
+ if (new_bw_data_p == NULL) {
+ sdp_p->conf_p->num_no_resource++;
+ return (SDP_NO_RESOURCE);
+ }
+ new_bw_data_p->next_p = NULL;
+ new_bw_data_p->bw_modifier = SDP_BW_MODIFIER_UNSUPPORTED;
+ new_bw_data_p->bw_val = 0;
+
+ /*
+ * Enqueue the sdp_bw_data_t instance at the end of the list of
+ * sdp_bw_data_t instances.
+ */
+ if (bw_p->bw_data_list == NULL) {
+ bw_p->bw_data_list = new_bw_data_p;
+ } else {
+ for (bw_data_p = bw_p->bw_data_list;
+ bw_data_p->next_p != NULL;
+ bw_data_p = bw_data_p->next_p) {
+
+ /*sa_ignore EMPTYLOOP*/
+ ; /* Do nothing. */
+ }
+
+ bw_data_p->next_p = new_bw_data_p;
+ }
+ *inst_num = ++bw_p->bw_data_count;
+
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_get_mid_value
+ * Description: Returns the mid value parameter from the a= mid: line.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level SDP_MEDIA_LEVEL
+ * Returns: mid value.
+ */
+int32_t sdp_get_mid_value (sdp_t *sdp_p, uint16_t level)
+{
+ sdp_mca_t *mca_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ }
+ return (mca_p->mid);
+}
+
diff --git a/media/webrtc/signaling/src/sdp/sipcc/sdp_attr.c b/media/webrtc/signaling/src/sdp/sipcc/sdp_attr.c
new file mode 100644
index 000000000..e3afa2637
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/sdp_attr.c
@@ -0,0 +1,5120 @@
+/* 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 <errno.h>
+#include <limits.h>
+#include <stdio.h>
+
+#include "plstr.h"
+#include "sdp_os_defs.h"
+#include "sdp.h"
+#include "sdp_private.h"
+#include "sdp_base64.h"
+
+#include "CSFLog.h"
+
+static const char* logTag = "sdp_attr";
+
+/*
+ * Macro for sdp_build_attr_fmtp
+ * Adds name-value pair where value is char*
+ */
+#define FMTP_BUILD_STRING(condition, name, value) \
+ if ((condition)) { \
+ sdp_append_name_and_string(fs, (name), (value), semicolon); \
+ semicolon = TRUE; \
+ }
+
+/*
+ * Macro for sdp_build_attr_fmtp
+ * Adds name-value pair where value is unsigned
+ */
+#define FMTP_BUILD_UNSIGNED(condition, name, value) \
+ if ((condition)) { \
+ sdp_append_name_and_unsigned(fs, (name), (value), semicolon); \
+ semicolon = TRUE; \
+ }
+
+/*
+ * Macro for sdp_build_attr_fmtp
+ * Adds flag string on condition
+ */
+#define FMTP_BUILD_FLAG(condition, name) \
+ if ((condition)) { \
+ if (semicolon) { \
+ flex_string_append(fs, ";"); \
+ } \
+ flex_string_append(fs, name); \
+ semicolon = TRUE; \
+ }
+
+static int find_token_enum(const char *attr_name,
+ sdp_t *sdp_p,
+ const char **ptr,
+ const sdp_namearray_t *types,
+ int type_count,
+ int unknown_value)
+{
+ sdp_result_e result = SDP_SUCCESS;
+ char tmp[SDP_MAX_STRING_LEN+1];
+ int i;
+
+ *ptr = sdp_getnextstrtok(*ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: problem parsing %s", sdp_p->debug_str, attr_name);
+ sdp_p->conf_p->num_invalid_param++;
+ return -1;
+ }
+
+ for (i=0; i < type_count; i++) {
+ if (!cpr_strncasecmp(tmp, types[i].name, types[i].strlen)) {
+ return i;
+ }
+ }
+ return unknown_value;
+}
+
+/*
+ * Helper function for adding nv-pair where value is string.
+ */
+static void sdp_append_name_and_string(flex_string *fs,
+ const char *name,
+ const char *value,
+ tinybool semicolon)
+{
+ flex_string_sprintf(fs, "%s%s=%s",
+ semicolon ? ";" : "",
+ name,
+ value);
+}
+
+/*
+ * Helper function for adding nv-pair where value is unsigned.
+ */
+static void sdp_append_name_and_unsigned(flex_string *fs,
+ const char *name,
+ unsigned int value,
+ tinybool semicolon)
+{
+ flex_string_sprintf(fs, "%s%s=%u",
+ semicolon ? ";" : "",
+ name,
+ value);
+}
+
+/* Function: sdp_parse_attribute
+ * Description: Figure out the type of attribute and call the appropriate
+ * parsing routine. If parsing errors are encountered,
+ * warnings will be printed and the attribute will be ignored.
+ * Unrecognized/invalid attributes do not cause overall parsing
+ * errors. All errors detected are noted as warnings.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * ptr Pointer to the attribute string to parse.
+ */
+sdp_result_e sdp_parse_attribute (sdp_t *sdp_p, uint16_t level, const char *ptr)
+{
+ int i;
+ uint8_t xcpar_flag = FALSE;
+ sdp_result_e result;
+ sdp_mca_t *mca_p=NULL;
+ sdp_attr_t *attr_p;
+ sdp_attr_t *next_attr_p;
+ sdp_attr_t *prev_attr_p = NULL;
+ char tmp[SDP_MAX_STRING_LEN];
+
+ /* Validate the level */
+ if (level != SDP_SESSION_LEVEL) {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (SDP_FAILURE);
+ }
+ }
+
+ /* Find the attribute type. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), ": \t", &result);
+ if (ptr == NULL) {
+ sdp_parse_error(sdp_p,
+ "%s No attribute type specified, parse failed.", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ if (ptr[0] == ':') {
+ /* Skip the ':' char for parsing attribute parameters. */
+ ptr++;
+ }
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s No attribute type specified, parse failed.", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ attr_p = (sdp_attr_t *)SDP_MALLOC(sizeof(sdp_attr_t));
+ if (attr_p == NULL) {
+ sdp_p->conf_p->num_no_resource++;
+ return (SDP_NO_RESOURCE);
+ }
+ attr_p->line_number = sdp_p->parse_line;
+ attr_p->type = SDP_ATTR_INVALID;
+ attr_p->next_p = NULL;
+ for (i=0; i < SDP_MAX_ATTR_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_attr[i].name, sdp_attr[i].strlen) == 0) {
+ attr_p->type = (sdp_attr_e)i;
+ break;
+ }
+ }
+ if (attr_p->type == SDP_ATTR_INVALID) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Unrecognized attribute (%s) ",
+ sdp_p->debug_str, tmp);
+ sdp_free_attr(attr_p);
+ return (SDP_SUCCESS);
+ }
+
+ /* If this is an X-cpar or cpar attribute, set the flag. The attribute
+ * type will be changed by the parse. */
+ if ((attr_p->type == SDP_ATTR_X_CPAR) ||
+ (attr_p->type == SDP_ATTR_CPAR)) {
+ xcpar_flag = TRUE;
+ }
+
+ /* Parse the attribute. */
+ result = sdp_attr[attr_p->type].parse_func(sdp_p, attr_p, ptr);
+ if (result != SDP_SUCCESS) {
+ sdp_free_attr(attr_p);
+ /* Return success so the parse won't fail. We don't want to
+ * fail on errors with attributes but just ignore them.
+ */
+ return (SDP_SUCCESS);
+ }
+
+ /* If this was an X-cpar/cpar attribute, it was hooked into the X-cap/cdsc
+ * structure, so we're finished.
+ */
+ if (xcpar_flag == TRUE) {
+ return (result);
+ }
+
+ /* Add the attribute in the appropriate place. */
+ if (level == SDP_SESSION_LEVEL) {
+ for (next_attr_p = sdp_p->sess_attrs_p; next_attr_p != NULL;
+ prev_attr_p = next_attr_p,
+ next_attr_p = next_attr_p->next_p) {
+ ; /* Empty for */
+ }
+ if (prev_attr_p == NULL) {
+ sdp_p->sess_attrs_p = attr_p;
+ } else {
+ prev_attr_p->next_p = attr_p;
+ }
+ } else {
+ for (next_attr_p = mca_p->media_attrs_p; next_attr_p != NULL;
+ prev_attr_p = next_attr_p,
+ next_attr_p = next_attr_p->next_p) {
+ ; /* Empty for */
+ }
+ if (prev_attr_p == NULL) {
+ mca_p->media_attrs_p = attr_p;
+ } else {
+ prev_attr_p->next_p = attr_p;
+ }
+ }
+
+ return (result);
+}
+
+/* Build all of the attributes defined for the specified level. */
+sdp_result_e sdp_build_attribute (sdp_t *sdp_p, uint16_t level, flex_string *fs)
+{
+ sdp_attr_t *attr_p;
+ sdp_mca_t *mca_p=NULL;
+ sdp_result_e result;
+
+ if (level == SDP_SESSION_LEVEL) {
+ attr_p = sdp_p->sess_attrs_p;
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (SDP_FAILURE);
+ }
+ attr_p = mca_p->media_attrs_p;
+ }
+ /* Re-initialize the current capability number for this new level. */
+ sdp_p->cur_cap_num = 1;
+
+ /* Build all of the attributes for this level. Note that if there
+ * is a problem building an attribute, we don't fail but just ignore it.*/
+ while (attr_p != NULL) {
+ if (attr_p->type >= SDP_MAX_ATTR_TYPES) {
+ if (sdp_p->debug_flag[SDP_DEBUG_WARNINGS]) {
+ CSFLogDebug(logTag, "%s Invalid attribute type to build (%u)",
+ sdp_p->debug_str, (unsigned)attr_p->type);
+ }
+ } else {
+ result = sdp_attr[attr_p->type].build_func(sdp_p, attr_p, fs);
+
+ if (result != SDP_SUCCESS) {
+ CSFLogError(logTag, "%s error building attribute %d", __FUNCTION__, result);
+ return result;
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Built a=%s attribute line", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type));
+ }
+ }
+ attr_p = attr_p->next_p;
+ }
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_simple_string (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ sdp_result_e result;
+
+ ptr = sdp_getnextstrtok(ptr, attr_p->attr.string_val,
+ sizeof(attr_p->attr.string_val), " \t", &result);
+
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No string token found for %s attribute",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type));
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, %s", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type),
+ attr_p->attr.string_val);
+ }
+ return (SDP_SUCCESS);
+ }
+}
+
+sdp_result_e sdp_build_attr_simple_string (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ flex_string_sprintf(fs, "a=%s:%s\r\n", sdp_attr[attr_p->type].name,
+ attr_p->attr.string_val);
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_simple_u32 (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ sdp_result_e result;
+
+ attr_p->attr.u32_val = sdp_getnextnumtok(ptr, &ptr, " \t", &result);
+
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Numeric token for %s attribute not found",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type));
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, %u", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type), attr_p->attr.u32_val);
+ }
+ return (SDP_SUCCESS);
+ }
+}
+
+sdp_result_e sdp_build_attr_simple_u32 (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ flex_string_sprintf(fs, "a=%s:%u\r\n", sdp_attr[attr_p->type].name,
+ attr_p->attr.u32_val);
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_simple_bool (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ sdp_result_e result;
+
+ if (sdp_getnextnumtok(ptr, &ptr, " \t", &result) == 0) {
+ attr_p->attr.boolean_val = FALSE;
+ } else {
+ attr_p->attr.boolean_val= TRUE;
+ }
+
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Boolean token for %s attribute not found",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type));
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ if (attr_p->attr.boolean_val) {
+ SDP_PRINT("%s Parsed a=%s, boolean is TRUE", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type));
+ } else {
+ SDP_PRINT("%s Parsed a=%s, boolean is FALSE", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type));
+ }
+ }
+ return (SDP_SUCCESS);
+ }
+}
+
+sdp_result_e sdp_build_attr_simple_bool (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ flex_string_sprintf(fs, "a=%s:%s\r\n", sdp_attr[attr_p->type].name,
+ attr_p->attr.boolean_val ? "1" : "0");
+
+ return SDP_SUCCESS;
+}
+
+/*
+ * sdp_parse_attr_maxprate
+ *
+ * This function parses maxprate attribute lines. The ABNF for this a=
+ * line is:
+ * max-p-rate-def = "a" "=" "maxprate" ":" packet-rate CRLF
+ * packet-rate = 1*DIGIT ["." 1*DIGIT]
+ *
+ * Returns:
+ * SDP_INVALID_PARAMETER - If we are unable to parse the string OR if
+ * packet-rate is not in the right format as per
+ * the ABNF.
+ *
+ * SDP_SUCCESS - If we are able to successfully parse the a= line.
+ */
+sdp_result_e sdp_parse_attr_maxprate (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ sdp_result_e result;
+
+ ptr = sdp_getnextstrtok(ptr, attr_p->attr.string_val,
+ sizeof(attr_p->attr.string_val), " \t", &result);
+
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No string token found for %s attribute",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type));
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ if (!sdp_validate_maxprate(attr_p->attr.string_val)) {
+ sdp_parse_error(sdp_p,
+ "%s is not a valid maxprate value.",
+ attr_p->attr.string_val);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, %s", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type),
+ attr_p->attr.string_val);
+ }
+ return (SDP_SUCCESS);
+ }
+}
+
+/*
+ * sdp_attr_fmtp_no_value
+ * Helper function for sending the warning when a parameter value is
+ * missing.
+ *
+ */
+static void sdp_attr_fmtp_no_value(sdp_t *sdp, const char *param_name)
+{
+ sdp_parse_error(sdp,
+ "%s Warning: No %s value specified for fmtp attribute",
+ sdp->debug_str, param_name);
+ sdp->conf_p->num_invalid_param++;
+}
+
+/*
+ * sdp_attr_fmtp_invalid_value
+ * Helper function for sending the warning when a parameter value is
+ * incorrect.
+ *
+ */
+static void sdp_attr_fmtp_invalid_value(sdp_t *sdp, const char *param_name,
+ const char* param_value)
+{
+ sdp_parse_error(sdp,
+ "%s Warning: Invalid %s: %s specified for fmtp attribute",
+ sdp->debug_str, param_name, param_value);
+ sdp->conf_p->num_invalid_param++;
+}
+
+/*
+ * sdp_verify_attr_fmtp_telephone_event
+ * Helper function for verifying the telephone-event fmtp format
+ */
+static sdp_result_e sdp_verify_attr_fmtp_telephone_event(char *fmtpVal)
+{
+ size_t len = PL_strlen(fmtpVal);
+
+ // make sure the basics are good:
+ // - at least 1 character
+ // - no illegal chars
+ // - first char is a number
+ if (len < 1
+ || strspn(fmtpVal, "0123456789,-") != len
+ || PL_strstr(fmtpVal, ",,")
+ || fmtpVal[len-1] == ','
+ || !('0' <= fmtpVal[0] && fmtpVal[0] <= '9')) {
+ return SDP_INVALID_PARAMETER;
+ }
+
+ // Now that we've passed the basic sanity test, copy the string so we
+ // can tokenize and check the format of the tokens without disturbing
+ // the input string.
+ char dtmf_tones[SDP_MAX_STRING_LEN+1];
+ PL_strncpyz(dtmf_tones, fmtpVal, sizeof(dtmf_tones));
+
+ char *strtok_state;
+ char *temp = PL_strtok_r(dtmf_tones, ",", &strtok_state);
+
+ while (temp != NULL) {
+ len = PL_strlen(temp);
+ if (len > 5) {
+ // an example of a max size token is "11-15", so if the
+ // token is longer than 5 it is bad
+ return SDP_INVALID_PARAMETER;
+ }
+
+ // case where we have 1 or 2 characters, example 4 or 23
+ if (len < 3 && strspn(temp, "0123456789") != len) {
+ return SDP_INVALID_PARAMETER;
+ } else if (len >= 3) {
+ // case where we have 3-5 characters, ex 3-5, 2-33, or 10-20
+ sdp_result_e result1 = SDP_SUCCESS;
+ sdp_result_e result2 = SDP_SUCCESS;
+ uint8_t low_val;
+ uint8_t high_val;
+ low_val = (uint8_t)sdp_getnextnumtok(temp, (const char **)&temp,
+ "-", &result1);
+ high_val = (uint8_t)sdp_getnextnumtok(temp, (const char **)&temp,
+ "-", &result2);
+ if (temp[0] // we don't want to find a second hyphen
+ || result1 != SDP_SUCCESS
+ || result2 != SDP_SUCCESS) {
+ return SDP_INVALID_PARAMETER;
+ }
+
+ if (low_val > 99
+ || high_val > 99
+ || high_val <= low_val) {
+ return SDP_INVALID_PARAMETER;
+ }
+ }
+
+ temp=PL_strtok_r(NULL, ",", &strtok_state);
+ }
+
+ return SDP_SUCCESS;
+}
+
+/* Note: The fmtp attribute formats currently handled are:
+ * fmtp:<payload type> <event>,<event>...
+ * fmtp:<payload_type> [annexa=yes/no] [annexb=yes/no] [bitrate=<value>]
+ * [QCIF =<value>] [CIF =<value>] [MaxBR = <value>] one or more
+ * Other FMTP params as per H.263, H.263+, H.264 codec support.
+ * Note -"value" is a numeric value > 0 and each event is a
+ * single number or a range separated by a '-'.
+ * Example: fmtp:101 1,3-15,20
+ * Video codecs have annexes that can be listed in the following legal formats:
+ * a) a=fmtp:34 param1=token;D;I;J;K=1;N=2;P=1,3
+ * b) a=fmtp:34 param1=token;D;I;J;K=1;N=2;P=1,3;T
+ * c) a=fmtp:34 param1=token;D;I;J
+ *
+ */
+sdp_result_e sdp_get_fmtp_tok(sdp_t *sdp_p,
+ const char** fmtp_ptr,
+ const char* fmtp_name,
+ char* buf,
+ size_t buf_size,
+ char** tok)
+{
+ sdp_result_e result1 = SDP_SUCCESS;
+
+ *fmtp_ptr = sdp_getnextstrtok(*fmtp_ptr, buf, buf_size, "; \t", &result1);
+ if (result1 != SDP_SUCCESS) {
+ *fmtp_ptr = sdp_getnextstrtok(*fmtp_ptr, buf, buf_size, " \t", &result1);
+ if (result1 != SDP_SUCCESS) {
+ sdp_attr_fmtp_no_value(sdp_p, fmtp_name);
+ return SDP_INVALID_PARAMETER;
+ }
+ }
+ *tok = buf;
+ (*tok)++;
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_get_fmtp_tok_val(sdp_t *sdp_p,
+ const char** fmtp_ptr,
+ const char* fmtp_name,
+ char* buf,
+ size_t buf_size,
+ char** tok,
+ unsigned long* strtoul_result,
+ unsigned long illegal_value,
+ unsigned long min_limit,
+ unsigned long max_limit)
+{
+ sdp_result_e result1 = SDP_SUCCESS;
+ unsigned long value;
+ char* strtoul_end;
+
+ result1 = sdp_get_fmtp_tok(sdp_p, fmtp_ptr, fmtp_name, buf, buf_size, tok);
+ if (result1 != SDP_SUCCESS) return result1;
+
+ errno = 0;
+ value = strtoul(*tok, &strtoul_end, 10);
+
+ if (errno
+ || (*tok == strtoul_end)
+ || (illegal_value != -1UL && value == illegal_value)
+ || (min_limit != -1UL && value < min_limit)
+ || (max_limit != -1UL && value > max_limit)) {
+ sdp_attr_fmtp_invalid_value(sdp_p, fmtp_name, *tok);
+ return SDP_INVALID_PARAMETER;
+ }
+ *strtoul_result = value;
+
+ return SDP_SUCCESS;
+}
+
+
+sdp_result_e sdp_parse_attr_fmtp (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ uint16_t i;
+ uint32_t mapword;
+ uint32_t bmap;
+ uint8_t low_val;
+ uint8_t high_val;
+ const char *ptr2;
+ const char *fmtp_ptr;
+ sdp_result_e result1 = SDP_SUCCESS;
+ sdp_result_e result2 = SDP_SUCCESS;
+ tinybool done = FALSE;
+ tinybool codec_info_found = FALSE;
+ sdp_fmtp_t *fmtp_p;
+ char tmp[SDP_MAX_STRING_LEN];
+ char *src_ptr;
+ char *temp_ptr = NULL;
+ char *tok=NULL;
+ char *temp=NULL;
+ uint16_t custom_x=0;
+ uint16_t custom_y=0;
+ uint16_t custom_mpi=0;
+ uint16_t par_height=0;
+ uint16_t par_width=0;
+ uint16_t cpcf=0;
+ uint16_t iter=0;
+
+ ulong l_val = 0;
+ char* strtok_state;
+ unsigned long strtoul_result;
+ char* strtoul_end;
+
+ /* Find the payload type number. */
+ attr_p->attr.fmtp.payload_num = (uint16_t)sdp_getnextnumtok(ptr, &ptr,
+ " \t", &result1);
+ if (result1 != SDP_SUCCESS) {
+ sdp_attr_fmtp_no_value(sdp_p, "payload type");
+ return SDP_INVALID_PARAMETER;
+ }
+ fmtp_p = &(attr_p->attr.fmtp);
+ fmtp_p->fmtp_format = SDP_FMTP_UNKNOWN_TYPE;
+ fmtp_p->parameter_add = 1;
+ fmtp_p->flag = 0;
+
+ /*
+ * set default value of packetization mode and level-asymmetry-allowed. If
+ * remote sdp does not specify any value for these two parameters, then the
+ * default value will be assumed for remote sdp. If remote sdp does specify
+ * any value for these parameters, then default value will be overridden.
+ */
+ fmtp_p->packetization_mode = SDP_DEFAULT_PACKETIZATION_MODE_VALUE;
+ fmtp_p->level_asymmetry_allowed = SDP_DEFAULT_LEVEL_ASYMMETRY_ALLOWED_VALUE;
+
+ temp_ptr = cpr_strdup(ptr);
+ if (temp_ptr == NULL) {
+ return (SDP_FAILURE);
+ }
+ fmtp_ptr = src_ptr = temp_ptr;
+
+ src_ptr = temp_ptr;
+ while (!done) {
+ fmtp_ptr = sdp_getnextstrtok(fmtp_ptr, tmp, sizeof(tmp), "= \t", &result1);
+ if (result1 == SDP_SUCCESS) {
+ if (cpr_strncasecmp(tmp, sdp_fmtp_codec_param[1].name,
+ sdp_fmtp_codec_param[1].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok(sdp_p, &fmtp_ptr, "annexb", tmp, sizeof(tmp), &tok);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ if (cpr_strncasecmp(tok,sdp_fmtp_codec_param_val[0].name,
+ sdp_fmtp_codec_param_val[0].strlen) == 0) {
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->annexb_required = TRUE;
+ fmtp_p->annexb = TRUE;
+ } else if (cpr_strncasecmp(tok,sdp_fmtp_codec_param_val[1].name,
+ sdp_fmtp_codec_param_val[1].strlen) == 0) {
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->annexb_required = TRUE;
+ fmtp_p->annexb = FALSE;
+ } else {
+ sdp_attr_fmtp_invalid_value(sdp_p, "annexb", tok);
+ SDP_FREE(temp_ptr);
+ return SDP_INVALID_PARAMETER;
+ }
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp, sdp_fmtp_codec_param[0].name,
+ sdp_fmtp_codec_param[0].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok(sdp_p, &fmtp_ptr, "annexa", tmp, sizeof(tmp), &tok);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ if (cpr_strncasecmp(tok,sdp_fmtp_codec_param_val[0].name,
+ sdp_fmtp_codec_param_val[0].strlen) == 0) {
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->annexa = TRUE;
+ fmtp_p->annexa_required = TRUE;
+ } else if (cpr_strncasecmp(tok,sdp_fmtp_codec_param_val[1].name,
+ sdp_fmtp_codec_param_val[1].strlen) == 0) {
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->annexa = FALSE;
+ fmtp_p->annexa_required = TRUE;
+ } else {
+ sdp_attr_fmtp_invalid_value(sdp_p, "annexa", tok);
+ SDP_FREE(temp_ptr);
+ return SDP_INVALID_PARAMETER;
+ }
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[2].name,
+ sdp_fmtp_codec_param[2].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "bitrate", tmp, sizeof(tmp),
+ &tok, &strtoul_result, 0, -1, UINT_MAX);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->bitrate = (uint32_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[41].name,
+ sdp_fmtp_codec_param[41].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "mode", tmp, sizeof(tmp),
+ &tok, &strtoul_result, -1, -1, UINT_MAX);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_MODE;
+ fmtp_p->mode = (uint32_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[3].name,
+ sdp_fmtp_codec_param[3].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "qcif", tmp, sizeof(tmp),
+ &tok, &strtoul_result, -1, SDP_MIN_CIF_VALUE, SDP_MAX_CIF_VALUE);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->qcif = (uint16_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[4].name,
+ sdp_fmtp_codec_param[4].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "cif", tmp, sizeof(tmp),
+ &tok, &strtoul_result, -1, SDP_MIN_CIF_VALUE, SDP_MAX_CIF_VALUE);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->cif = (uint16_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[5].name,
+ sdp_fmtp_codec_param[5].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "maxbr", tmp, sizeof(tmp),
+ &tok, &strtoul_result, 0, -1, USHRT_MAX);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->maxbr = (uint16_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[6].name,
+ sdp_fmtp_codec_param[6].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "sqcif", tmp, sizeof(tmp),
+ &tok, &strtoul_result, -1, SDP_MIN_CIF_VALUE, SDP_MAX_CIF_VALUE);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->sqcif = (uint16_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[7].name,
+ sdp_fmtp_codec_param[7].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "cif4", tmp, sizeof(tmp),
+ &tok, &strtoul_result, -1, SDP_MIN_CIF_VALUE, SDP_MAX_CIF_VALUE);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->cif4 = (uint16_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[8].name,
+ sdp_fmtp_codec_param[8].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "cif16", tmp, sizeof(tmp),
+ &tok, &strtoul_result, -1, SDP_MIN_CIF_VALUE, SDP_MAX_CIF_VALUE);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->cif16 = (uint16_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[9].name,
+ sdp_fmtp_codec_param[9].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok(sdp_p, &fmtp_ptr, "custom", tmp, sizeof(tmp), &tok);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ temp=PL_strtok_r(tok, ",", &strtok_state);
+ iter++;
+ if (temp) {
+ iter=1;
+ while (temp != NULL) {
+ errno = 0;
+ strtoul_result = strtoul(temp, &strtoul_end, 10);
+
+ if (errno || temp == strtoul_end || strtoul_result > USHRT_MAX){
+ custom_x = custom_y = custom_mpi = 0;
+ break;
+ }
+
+ if (iter == 1)
+ custom_x = (uint16_t) strtoul_result;
+ if (iter == 2)
+ custom_y = (uint16_t) strtoul_result;
+ if (iter == 3)
+ custom_mpi = (uint16_t) strtoul_result;
+
+ temp=PL_strtok_r(NULL, ",", &strtok_state);
+ iter++;
+ }
+ }
+
+ /* custom x,y and mpi values from tmp */
+ if (!custom_x || !custom_y || !custom_mpi) {
+ sdp_attr_fmtp_invalid_value(sdp_p, "x/y/MPI", temp);
+ SDP_FREE(temp_ptr);
+ return SDP_INVALID_PARAMETER;
+ }
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->custom_x = custom_x;
+ fmtp_p->custom_y = custom_y;
+ fmtp_p->custom_mpi = custom_mpi;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[10].name,
+ sdp_fmtp_codec_param[10].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok(sdp_p, &fmtp_ptr, "par", tmp, sizeof(tmp), &tok);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ temp=PL_strtok_r(tok, ":", &strtok_state);
+ if (temp) {
+ iter=1;
+ /* get par width and par height for the aspect ratio */
+ while (temp != NULL) {
+ errno = 0;
+ strtoul_result = strtoul(temp, &strtoul_end, 10);
+
+ if (errno || temp == strtoul_end || strtoul_result > USHRT_MAX) {
+ par_width = par_height = 0;
+ break;
+ }
+
+ if (iter == 1)
+ par_width = (uint16_t) strtoul_result;
+ else
+ par_height = (uint16_t) strtoul_result;
+
+ temp=PL_strtok_r(NULL, ",", &strtok_state);
+ iter++;
+ }
+ }
+ if (!par_width || !par_height) {
+ sdp_attr_fmtp_invalid_value(sdp_p, "par_width or par_height", temp);
+ SDP_FREE(temp_ptr);
+ return SDP_INVALID_PARAMETER;
+ }
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->par_width = par_width;
+ fmtp_p->par_height = par_height;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[11].name,
+ sdp_fmtp_codec_param[11].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok(sdp_p, &fmtp_ptr, "cpcf", tmp, sizeof(tmp), &tok);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ temp=PL_strtok_r(tok, ".", &strtok_state);
+ if ( temp != NULL ) {
+ errno = 0;
+ strtoul_result = strtoul(temp, &strtoul_end, 10);
+
+ if (errno || temp == strtoul_end || strtoul_result > USHRT_MAX) {
+ cpcf = 0;
+ } else {
+ cpcf = (uint16_t) strtoul_result;
+ }
+ }
+
+ if (!cpcf) {
+ sdp_attr_fmtp_invalid_value(sdp_p, "cpcf", tok);
+ SDP_FREE(temp_ptr);
+ return SDP_INVALID_PARAMETER;
+ }
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->cpcf = cpcf;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[12].name,
+ sdp_fmtp_codec_param[12].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "bpp", tmp, sizeof(tmp),
+ &tok, &strtoul_result, 0, -1, USHRT_MAX);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->bpp = (uint16_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[13].name,
+ sdp_fmtp_codec_param[13].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "hrd", tmp, sizeof(tmp),
+ &tok, &strtoul_result, 0, -1, USHRT_MAX);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->hrd = (uint16_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[14].name,
+ sdp_fmtp_codec_param[14].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "profile", tmp, sizeof(tmp),
+ &tok, &strtoul_result, -1, -1, SDP_MAX_PROFILE_VALUE);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->profile = (short) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[15].name,
+ sdp_fmtp_codec_param[15].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "level", tmp, sizeof(tmp),
+ &tok, &strtoul_result, -1, -1, SDP_MAX_LEVEL_VALUE);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->level = (short) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[16].name,
+ sdp_fmtp_codec_param[16].strlen) == 0) {
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->is_interlace = TRUE;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[17].name,
+ sdp_fmtp_codec_param[17].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok(sdp_p, &fmtp_ptr, "profile_level_id", tmp, sizeof(tmp), &tok);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ sstrncpy(fmtp_p->profile_level_id , tok, sizeof(fmtp_p->profile_level_id));
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[18].name,
+ sdp_fmtp_codec_param[18].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok(sdp_p, &fmtp_ptr, "parameter_sets", tmp, sizeof(tmp), &tok);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ sstrncpy(fmtp_p->parameter_sets , tok, sizeof(fmtp_p->parameter_sets));
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[19].name,
+ sdp_fmtp_codec_param[19].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "packetization_mode", tmp, sizeof(tmp),
+ &tok, &strtoul_result, -1, -1, 2);
+ // this one is different for some reason. Most others don't increment
+ // the num_invalid_param field. (mjf)
+ if (result1 == SDP_INVALID_PARAMETER) { sdp_p->conf_p->num_invalid_param++; }
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->packetization_mode = (int16_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[20].name,
+ sdp_fmtp_codec_param[20].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "interleaving_depth", tmp, sizeof(tmp),
+ &tok, &strtoul_result, 0, -1, USHRT_MAX);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->interleaving_depth = (uint16_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[21].name,
+ sdp_fmtp_codec_param[21].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok(sdp_p, &fmtp_ptr, "deint_buf", tmp, sizeof(tmp), &tok);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ if (sdp_checkrange(sdp_p, tok, &l_val) == TRUE) {
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->deint_buf_req = (uint32_t) l_val;
+ fmtp_p->flag |= SDP_DEINT_BUF_REQ_FLAG;
+ codec_info_found = TRUE;
+ } else {
+ sdp_attr_fmtp_invalid_value(sdp_p, "deint_buf_req", tok);
+ SDP_FREE(temp_ptr);
+ return SDP_INVALID_PARAMETER;
+ }
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[22].name,
+ sdp_fmtp_codec_param[22].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "max_don_diff", tmp, sizeof(tmp),
+ &tok, &strtoul_result, 0, -1, UINT_MAX);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->max_don_diff = (uint32_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[23].name,
+ sdp_fmtp_codec_param[23].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok(sdp_p, &fmtp_ptr, "init_buf_time", tmp, sizeof(tmp), &tok);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ if (sdp_checkrange(sdp_p, tok, &l_val) == TRUE) {
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->init_buf_time = (uint32_t) l_val;
+ fmtp_p->flag |= SDP_INIT_BUF_TIME_FLAG;
+ codec_info_found = TRUE;
+ } else {
+ sdp_attr_fmtp_invalid_value(sdp_p, "init_buf_time", tok);
+ SDP_FREE(temp_ptr);
+ return SDP_INVALID_PARAMETER;
+ }
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[24].name,
+ sdp_fmtp_codec_param[24].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "max_mbps", tmp, sizeof(tmp),
+ &tok, &strtoul_result, 0, -1, UINT_MAX);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->max_mbps = (uint32_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[25].name,
+ sdp_fmtp_codec_param[25].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "max-fs", tmp, sizeof(tmp),
+ &tok, &strtoul_result, 0, -1, UINT_MAX);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->max_fs = (uint32_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[26].name,
+ sdp_fmtp_codec_param[26].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "max_cbp", tmp, sizeof(tmp),
+ &tok, &strtoul_result, 0, -1, UINT_MAX);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->max_cpb = (uint32_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[27].name,
+ sdp_fmtp_codec_param[27].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "max_dpb", tmp, sizeof(tmp),
+ &tok, &strtoul_result, 0, -1, UINT_MAX);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->max_dpb = (uint32_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[28].name,
+ sdp_fmtp_codec_param[28].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "max_br", tmp, sizeof(tmp),
+ &tok, &strtoul_result, 0, -1, UINT_MAX);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->max_br = (uint32_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[29].name,
+ sdp_fmtp_codec_param[29].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "redundant_pic_cap", tmp, sizeof(tmp),
+ &tok, &strtoul_result, 0, -1, 1);
+ fmtp_p->redundant_pic_cap = (result1 == SDP_SUCCESS);
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[30].name,
+ sdp_fmtp_codec_param[30].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok(sdp_p, &fmtp_ptr, "deint_buf_cap", tmp, sizeof(tmp), &tok);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ if (sdp_checkrange(sdp_p, tok, &l_val) == TRUE) {
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->deint_buf_cap = (uint32_t) l_val;
+ fmtp_p->flag |= SDP_DEINT_BUF_CAP_FLAG;
+ codec_info_found = TRUE;
+ } else {
+ sdp_attr_fmtp_invalid_value(sdp_p, "deint_buf_cap", tok);
+ SDP_FREE(temp_ptr);
+ return SDP_INVALID_PARAMETER;
+ }
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[31].name,
+ sdp_fmtp_codec_param[31].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok(sdp_p, &fmtp_ptr, "max_rcmd_nalu_size", tmp, sizeof(tmp), &tok);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ if (sdp_checkrange(sdp_p, tok, &l_val) == TRUE) {
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->max_rcmd_nalu_size = (uint32_t) l_val;
+ fmtp_p->flag |= SDP_MAX_RCMD_NALU_SIZE_FLAG;
+ codec_info_found = TRUE;
+ } else {
+ sdp_attr_fmtp_invalid_value(sdp_p, "max_rcmd_nalu_size", tok);
+ SDP_FREE(temp_ptr);
+ return SDP_INVALID_PARAMETER;
+ }
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[32].name,
+ sdp_fmtp_codec_param[32].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "parameter_add", tmp, sizeof(tmp),
+ &tok, &strtoul_result, 0, -1, 1);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->parameter_add = (uint16_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[33].name,
+ sdp_fmtp_codec_param[33].strlen) == 0) {
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->annex_d = TRUE;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[34].name,
+ sdp_fmtp_codec_param[34].strlen) == 0) {
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->annex_f = TRUE;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[35].name,
+ sdp_fmtp_codec_param[35].strlen) == 0) {
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->annex_i = TRUE;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[36].name,
+ sdp_fmtp_codec_param[36].strlen) == 0) {
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->annex_j = TRUE;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[37].name,
+ sdp_fmtp_codec_param[36].strlen) == 0) {
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->annex_t = TRUE;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[38].name,
+ sdp_fmtp_codec_param[38].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "annex_k", tmp, sizeof(tmp),
+ &tok, &strtoul_result, 0, -1, USHRT_MAX);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->annex_k_val = (uint16_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[39].name,
+ sdp_fmtp_codec_param[39].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "annex_n", tmp, sizeof(tmp),
+ &tok, &strtoul_result, 0, -1, USHRT_MAX);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->annex_n_val = (uint16_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[40].name,
+ sdp_fmtp_codec_param[40].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok(sdp_p, &fmtp_ptr, "annex_p", tmp, sizeof(tmp), &tok);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->annex_p_val_picture_resize = 0;
+ fmtp_p->annex_p_val_warp = 0;
+ temp = PL_strtok_r(tok, ",", &strtok_state);
+ if (temp) {
+ iter=1;
+ while (temp != NULL) {
+ errno = 0;
+ strtoul_result = strtoul(temp, &strtoul_end, 10);
+
+ if (errno || temp == strtoul_end || strtoul_result > USHRT_MAX) {
+ break;
+ }
+
+ if (iter == 1)
+ fmtp_p->annex_p_val_picture_resize = (uint16_t) strtoul_result;
+ else if (iter == 2)
+ fmtp_p->annex_p_val_warp = (uint16_t) strtoul_result;
+
+ temp = PL_strtok_r(NULL, ",", &strtok_state);
+ iter++;
+ }
+ } else {
+ SDP_FREE(temp_ptr);
+ return SDP_INVALID_PARAMETER;
+ }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[42].name,
+ sdp_fmtp_codec_param[42].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "level_asymmetry_allowed", tmp, sizeof(tmp),
+ &tok, &strtoul_result, -1, -1, SDP_MAX_LEVEL_ASYMMETRY_ALLOWED_VALUE);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->level_asymmetry_allowed = (int) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[43].name,
+ sdp_fmtp_codec_param[43].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "maxaveragebitrate", tmp, sizeof(tmp),
+ &tok, &strtoul_result, 0, -1, UINT_MAX);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->maxaveragebitrate = (uint32_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[44].name,
+ sdp_fmtp_codec_param[44].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "usedtx", tmp, sizeof(tmp),
+ &tok, &strtoul_result, -1, -1, 1);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->usedtx = (uint16_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[45].name,
+ sdp_fmtp_codec_param[45].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "stereo", tmp, sizeof(tmp),
+ &tok, &strtoul_result, -1, -1, 1);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->stereo = (uint16_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[46].name,
+ sdp_fmtp_codec_param[46].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "useinbandfec", tmp, sizeof(tmp),
+ &tok, &strtoul_result, -1, -1, 1);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->useinbandfec = (uint16_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[47].name,
+ sdp_fmtp_codec_param[47].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok(sdp_p, &fmtp_ptr, "maxcodedaudiobandwidth", tmp, sizeof(tmp), &tok);
+ // this one is different for some reason. Most others don't increment
+ // the num_invalid_param field. (mjf)
+ if (result1 == SDP_INVALID_PARAMETER) { sdp_p->conf_p->num_invalid_param++; }
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ sstrncpy(fmtp_p->maxcodedaudiobandwidth , tok, sizeof(fmtp_p->maxcodedaudiobandwidth));
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[48].name,
+ sdp_fmtp_codec_param[48].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "cbr", tmp, sizeof(tmp),
+ &tok, &strtoul_result, -1, -1, 1);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->cbr = (uint16_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[49].name,
+ sdp_fmtp_codec_param[49].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "max-fr", tmp, sizeof(tmp),
+ &tok, &strtoul_result, 0, -1, UINT_MAX);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->max_fr = (uint32_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (cpr_strncasecmp(tmp,sdp_fmtp_codec_param[50].name,
+ sdp_fmtp_codec_param[50].strlen) == 0) {
+ result1 = sdp_get_fmtp_tok_val(sdp_p, &fmtp_ptr, "maxplaybackrate", tmp, sizeof(tmp),
+ &tok, &strtoul_result, 0, -1, UINT_MAX);
+ if (result1 != SDP_SUCCESS) { SDP_FREE(temp_ptr); return result1; }
+
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+ fmtp_p->maxplaybackrate = (uint32_t) strtoul_result;
+ codec_info_found = TRUE;
+
+ } else if (fmtp_ptr != NULL && *fmtp_ptr == '\n') {
+ temp=PL_strtok_r(tmp, ";", &strtok_state);
+ if (temp) {
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Annexes are possibly there for this fmtp %s tmp: %s line\n",
+ sdp_p->debug_str, fmtp_ptr, tmp);
+ }
+ while (temp != NULL) {
+ if (strchr(temp, 'D') !=NULL) {
+ attr_p->attr.fmtp.annex_d = TRUE;
+ }
+ if (strchr(temp, 'F') !=NULL) {
+ attr_p->attr.fmtp.annex_f = TRUE;
+ }
+ if (strchr(temp, 'I') !=NULL) {
+ attr_p->attr.fmtp.annex_i = TRUE;
+ }
+ if (strchr(temp, 'J') !=NULL) {
+ attr_p->attr.fmtp.annex_j = TRUE;
+ }
+ if (strchr(temp, 'T') !=NULL) {
+ attr_p->attr.fmtp.annex_t = TRUE;
+ }
+ temp=PL_strtok_r(NULL, ";", &strtok_state);
+ }
+ } /* if (temp) */
+ done = TRUE;
+ } else if (strchr(tmp, '/')) {
+ // XXX Note that because RFC 5109 so conveniently specified
+ // this fmtp with no param names, we hope that nothing else
+ // has a slash in the string because otherwise we won't know
+ // how to differentiate.
+ temp=PL_strtok_r(tmp, "/", &strtok_state);
+ if (temp) {
+ iter = 0;
+ while (temp != NULL) {
+ errno = 0;
+ strtoul_result = strtoul(temp, &strtoul_end, 10);
+
+ if (errno ||
+ temp == strtoul_end || strtoul_result > USHRT_MAX) {
+ temp = NULL;
+ continue;
+ }
+ fmtp_p->redundant_encodings[iter++] =
+ (uint8_t)strtoul_result;
+ temp=PL_strtok_r(NULL, "/", &strtok_state);
+ }
+ } /* if (temp) */
+ } else if (SDP_SUCCESS == sdp_verify_attr_fmtp_telephone_event(tmp)) {
+ // XXX Note that DTMF fmtp will fall into here:
+ // a=fmtp:101 0-15 (or 0-15,NN,NN etc)
+ sstrncpy(fmtp_p->dtmf_tones , tmp, sizeof(fmtp_p->dtmf_tones));
+ codec_info_found = TRUE;
+ } else {
+ // unknown parameter - eat chars until ';'
+ CSFLogDebug(logTag, "%s Unknown fmtp type (%s) - ignoring", __FUNCTION__,
+ tmp);
+ fmtp_ptr = sdp_getnextstrtok(fmtp_ptr, tmp, sizeof(tmp), "; \t",
+ &result1);
+ if (result1 != SDP_SUCCESS) {
+ fmtp_ptr = sdp_getnextstrtok(fmtp_ptr, tmp, sizeof(tmp), " \t", &result1);
+ if (result1 != SDP_SUCCESS) {
+ // hmmm, no ; or spaces or tabs; continue on
+ }
+ }
+ }
+ if (*fmtp_ptr == '\n') {
+ // reached end of line, stop parsing
+ done = TRUE;
+ } else {
+ fmtp_ptr++;
+ }
+ } else {
+ done = TRUE;
+ }
+ } /* while - done loop*/
+
+ if (codec_info_found) {
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, payload type %u, bitrate %u, mode %u QCIF = %u, CIF = %u, MAXBR= %u, SQCIF=%u, CIF4= %u, CIF16=%u, CUSTOM=%u,%u,%u , PAR=%u:%u,CPCF=%u, BPP=%u, HRD=%u \n",
+ sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type),
+ attr_p->attr.fmtp.payload_num,
+ attr_p->attr.fmtp.bitrate,
+ attr_p->attr.fmtp.mode,
+ attr_p->attr.fmtp.qcif,
+ attr_p->attr.fmtp.cif,
+ attr_p->attr.fmtp.maxbr,
+ attr_p->attr.fmtp.sqcif,
+ attr_p->attr.fmtp.cif4,
+ attr_p->attr.fmtp.cif16,
+ attr_p->attr.fmtp.custom_x,attr_p->attr.fmtp.custom_y,
+ attr_p->attr.fmtp.custom_mpi,
+ attr_p->attr.fmtp.par_width,
+ attr_p->attr.fmtp.par_height,
+ attr_p->attr.fmtp.cpcf,
+ attr_p->attr.fmtp.bpp,
+ attr_p->attr.fmtp.hrd
+ );
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, payload type %u,PROFILE=%u,LEVEL=%u, INTERLACE - %s",
+ sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type),
+ attr_p->attr.fmtp.payload_num,
+ attr_p->attr.fmtp.profile,
+ attr_p->attr.fmtp.level,
+ attr_p->attr.fmtp.is_interlace ? "YES":"NO");
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed H.264 attributes: profile-level-id=%s, parameter-sets=%s, packetization-mode=%d level-asymmetry-allowed=%d interleaving-depth=%d deint-buf-req=%u max-don-diff=%u, init_buf-time=%u\n",
+ sdp_p->debug_str,
+ attr_p->attr.fmtp.profile_level_id,
+ attr_p->attr.fmtp.parameter_sets,
+ attr_p->attr.fmtp.packetization_mode,
+ attr_p->attr.fmtp.level_asymmetry_allowed,
+ attr_p->attr.fmtp.interleaving_depth,
+ attr_p->attr.fmtp.deint_buf_req,
+ attr_p->attr.fmtp.max_don_diff,
+ attr_p->attr.fmtp.init_buf_time
+ );
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("\n%s Parsed H.264 opt attributes: max-mbps=%u, max-fs=%u, max-cpb=%u max-dpb=%u max-br=%u redundant-pic-cap=%d, deint-buf-cap=%u, max-rcmd-nalu-size=%u , parameter-add=%d\n",
+ sdp_p->debug_str,
+ attr_p->attr.fmtp.max_mbps,
+ attr_p->attr.fmtp.max_fs,
+ attr_p->attr.fmtp.max_cpb,
+ attr_p->attr.fmtp.max_dpb,
+ attr_p->attr.fmtp.max_br,
+ attr_p->attr.fmtp.redundant_pic_cap,
+ attr_p->attr.fmtp.deint_buf_cap,
+ attr_p->attr.fmtp.max_rcmd_nalu_size,
+ attr_p->attr.fmtp.parameter_add);
+
+ }
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed annexes are : D=%d F=%d I=%d J=%d T=%d, K=%d N=%d P=%d,%d\n",
+ sdp_p->debug_str,
+ attr_p->attr.fmtp.annex_d,
+ attr_p->attr.fmtp.annex_f, attr_p->attr.fmtp.annex_i,
+ attr_p->attr.fmtp.annex_j, attr_p->attr.fmtp.annex_t,
+ attr_p->attr.fmtp.annex_k_val,
+ attr_p->attr.fmtp.annex_n_val,
+ attr_p->attr.fmtp.annex_p_val_picture_resize,
+ attr_p->attr.fmtp.annex_p_val_warp);
+
+ }
+ SDP_FREE(temp_ptr);
+ return (SDP_SUCCESS);
+ } else {
+ done = FALSE;
+ fmtp_ptr = src_ptr;
+ tmp[0] = '\0';
+ }
+
+ for (i=0; !done; i++) {
+ fmtp_p->fmtp_format = SDP_FMTP_NTE;
+ /* Look for comma separated events */
+ fmtp_ptr = sdp_getnextstrtok(fmtp_ptr, tmp, sizeof(tmp), ", \t", &result1);
+ if (result1 != SDP_SUCCESS) {
+ done = TRUE;
+ continue;
+ }
+ /* Now look for '-' separated range */
+ ptr2 = tmp;
+ low_val = (uint8_t)sdp_getnextnumtok(ptr2, (const char **)&ptr2,
+ "- \t", &result1);
+ if (*ptr2 == '-') {
+ high_val = (uint8_t)sdp_getnextnumtok(ptr2, (const char **)&ptr2,
+ "- \t", &result2);
+ } else {
+ high_val = low_val;
+ }
+
+ if ((result1 != SDP_SUCCESS) || (result2 != SDP_SUCCESS)) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Invalid named events specified for fmtp attribute.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ SDP_FREE(temp_ptr);
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ for (i = low_val; i <= high_val; i++) {
+ mapword = i/SDP_NE_BITS_PER_WORD;
+ bmap = SDP_NE_BIT_0 << (i%32);
+ fmtp_p->bmap[mapword] |= bmap;
+ }
+ if (high_val > fmtp_p->maxval) {
+ fmtp_p->maxval = high_val;
+ }
+ }
+
+ if (fmtp_p->maxval == 0) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No named events specified for fmtp attribute.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ SDP_FREE(temp_ptr);
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, payload type %u, ", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type),
+ attr_p->attr.fmtp.payload_num);
+ }
+ SDP_FREE(temp_ptr);
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e
+sdp_build_attr_fmtp_params (sdp_t *sdp_p, sdp_fmtp_t *fmtp_p, flex_string *fs)
+{
+ uint16_t event_id;
+ uint32_t mask;
+ uint32_t mapword;
+ uint8_t min = 0;
+ uint8_t max = 0;
+ tinybool range_start = FALSE;
+ tinybool range_end = FALSE;
+ tinybool semicolon = FALSE;
+
+ switch (fmtp_p->fmtp_format) {
+ case SDP_FMTP_MODE:
+ sdp_append_name_and_unsigned(fs, "mode", fmtp_p->mode, FALSE);
+ break;
+
+ case SDP_FMTP_CODEC_INFO:
+ FMTP_BUILD_UNSIGNED(fmtp_p->bitrate > 0, "bitrate", fmtp_p->bitrate)
+
+ FMTP_BUILD_STRING(fmtp_p->annexa_required,
+ "annexa", (fmtp_p->annexa ? "yes" : "no"))
+
+ FMTP_BUILD_STRING(fmtp_p->annexb_required,
+ "annexb", (fmtp_p->annexa ? "yes" : "no"))
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->qcif > 0, "QCIF", fmtp_p->qcif)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->cif > 0, "CIF", fmtp_p->cif)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->maxbr > 0, "MAXBR", fmtp_p->maxbr)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->sqcif > 0, "SQCIF", fmtp_p->sqcif)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->cif4 > 0, "CIF4", fmtp_p->cif4)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->cif16 > 0, "CIF16", fmtp_p->cif16)
+
+ if ((fmtp_p->custom_x > 0) && (fmtp_p->custom_y > 0) &&
+ (fmtp_p->custom_mpi > 0)) {
+ flex_string_sprintf(fs, "%sCUSTOM=%u,%u,%u",
+ semicolon ? ";" : "",
+ fmtp_p->custom_x,
+ fmtp_p->custom_y,
+ fmtp_p->custom_mpi);
+
+ semicolon = TRUE;
+ }
+
+ if ((fmtp_p->par_height > 0) && (fmtp_p->par_width > 0)) {
+ flex_string_sprintf(fs, "%sPAR=%u:%u",
+ semicolon ? ";" : "",
+ fmtp_p->par_width,
+ fmtp_p->par_width);
+
+ semicolon = TRUE;
+ }
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->cpcf > 0, "CPCF", fmtp_p->cpcf)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->bpp > 0, "BPP", fmtp_p->bpp)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->hrd > 0, "HRD", fmtp_p->hrd)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->profile >= 0, "PROFILE", fmtp_p->profile)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->level >= 0, "LEVEL", fmtp_p->level)
+
+ FMTP_BUILD_FLAG(fmtp_p->is_interlace, "INTERLACE")
+
+ FMTP_BUILD_FLAG(fmtp_p->annex_d, "D")
+
+ FMTP_BUILD_FLAG(fmtp_p->annex_f, "F")
+
+ FMTP_BUILD_FLAG(fmtp_p->annex_i, "I")
+
+ FMTP_BUILD_FLAG(fmtp_p->annex_j, "J")
+
+ FMTP_BUILD_FLAG(fmtp_p->annex_t, "T")
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->annex_k_val > 0,
+ "K", fmtp_p->annex_k_val)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->annex_n_val > 0,
+ "N", fmtp_p->annex_n_val)
+
+ if ((fmtp_p->annex_p_val_picture_resize > 0) &&
+ (fmtp_p->annex_p_val_warp > 0)) {
+ flex_string_sprintf(fs, "%sP=%d:%d",
+ semicolon ? ";" : "",
+ fmtp_p->annex_p_val_picture_resize,
+ fmtp_p->annex_p_val_warp);
+
+ semicolon = TRUE;
+ }
+
+ FMTP_BUILD_STRING(strlen(fmtp_p->profile_level_id) > 0,
+ "profile-level-id", fmtp_p->profile_level_id)
+
+ FMTP_BUILD_STRING(strlen(fmtp_p->parameter_sets) > 0,
+ "sprop-parameter-sets", fmtp_p->parameter_sets)
+
+ FMTP_BUILD_UNSIGNED(
+ fmtp_p->packetization_mode < SDP_MAX_PACKETIZATION_MODE_VALUE,
+ "packetization-mode", fmtp_p->packetization_mode)
+
+ FMTP_BUILD_UNSIGNED(
+ fmtp_p->level_asymmetry_allowed <=
+ SDP_MAX_LEVEL_ASYMMETRY_ALLOWED_VALUE,
+ "level-asymmetry-allowed", fmtp_p->level_asymmetry_allowed)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->interleaving_depth > 0,
+ "sprop-interleaving-depth", fmtp_p->interleaving_depth)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->flag & SDP_DEINT_BUF_REQ_FLAG,
+ "sprop-deint-buf-req", fmtp_p->deint_buf_req)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->max_don_diff > 0,
+ "sprop-max-don-diff", fmtp_p->max_don_diff)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->flag & SDP_INIT_BUF_TIME_FLAG,
+ "sprop-init-buf-time", fmtp_p->init_buf_time)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->max_mbps > 0,
+ "max-mbps", fmtp_p->max_mbps)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->max_fs > 0, "max-fs", fmtp_p->max_fs)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->max_fr > 0, "max-fr", fmtp_p->max_fr)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->max_cpb > 0, "max-cpb", fmtp_p->max_cpb)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->max_dpb > 0, "max-dpb", fmtp_p->max_dpb)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->max_br > 0, "max-br", fmtp_p->max_br)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->redundant_pic_cap > 0,
+ "redundant-pic-cap", fmtp_p->redundant_pic_cap)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->flag & SDP_DEINT_BUF_CAP_FLAG,
+ "deint-buf-cap", fmtp_p->deint_buf_cap)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->flag & SDP_MAX_RCMD_NALU_SIZE_FLAG,
+ "max-rcmd-naFMTP_BUILD_FLlu-size", fmtp_p->max_rcmd_nalu_size)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->parameter_add <= 1, "parameter-add",
+ fmtp_p->parameter_add)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->maxaveragebitrate > 0,
+ "maxaveragebitrate", fmtp_p->maxaveragebitrate)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->usedtx <= 1, "usedtx", fmtp_p->usedtx)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->stereo <= 1, "stereo", fmtp_p->stereo)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->useinbandfec <= 1,
+ "useinbandfec", fmtp_p->useinbandfec)
+
+ FMTP_BUILD_STRING(strlen(fmtp_p->maxcodedaudiobandwidth) > 0,
+ "maxcodedaudiobandwidth", fmtp_p->maxcodedaudiobandwidth)
+
+ FMTP_BUILD_UNSIGNED(fmtp_p->cbr <= 1, "cbr", fmtp_p->cbr)
+
+ break;
+
+ case SDP_FMTP_NTE:
+ default:
+ break;
+ }
+
+ for(event_id = 0, mapword = 0, mask = SDP_NE_BIT_0;
+ event_id <= fmtp_p->maxval;
+ event_id++, mapword = event_id/SDP_NE_BITS_PER_WORD ) {
+
+ if (event_id % SDP_NE_BITS_PER_WORD) {
+ mask <<= 1;
+ } else {
+ /* crossed a bitmap word boundary */
+ mask = SDP_NE_BIT_0;
+ if (!range_start && !range_end && !fmtp_p->bmap[mapword]) {
+ /* no events in this word, skip to the last event id
+ * in this bitmap word. */
+ event_id += SDP_NE_BITS_PER_WORD - 1;
+ continue;
+ }
+ }
+
+ if (fmtp_p->bmap[mapword] & mask) {
+ if (!range_start) {
+ range_start = TRUE;
+ min = max = (uint8_t)event_id;
+ } else {
+ max = (uint8_t)event_id;
+ }
+ range_end = (max == fmtp_p->maxval);
+ } else {
+ /* If we were in the middle of a range, then we've hit the
+ * end. If we weren't, there is no end to hit. */
+ range_end = range_start;
+ }
+
+ /* If this is the end of the range, print it to the string. */
+ if (range_end) {
+ range_start = range_end = FALSE;
+
+ flex_string_sprintf(fs, "%u", min);
+
+ if (min != max) {
+ flex_string_sprintf(fs, "-%u", max);
+ }
+
+ if (max != fmtp_p->maxval) {
+ flex_string_append(fs, ",");
+ }
+ }
+ }
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_build_attr_fmtp (sdp_t *sdp_p, sdp_attr_t *attr_p, flex_string *fs)
+{
+ sdp_fmtp_t *fmtp_p;
+ sdp_result_e result;
+
+ flex_string_sprintf(fs, "a=%s:%u ",
+ sdp_attr[attr_p->type].name,
+ attr_p->attr.fmtp.payload_num);
+
+ fmtp_p = &(attr_p->attr.fmtp);
+
+ result = sdp_build_attr_fmtp_params(sdp_p, fmtp_p, fs);
+
+ if (result != SDP_SUCCESS) {
+ return result;
+ }
+
+ flex_string_append(fs, "\r\n");
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_sctpmap(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ sdp_result_e result = SDP_SUCCESS;
+ char tmp[SDP_MAX_STRING_LEN];
+ uint32_t streams;
+
+ /* Find the payload type number. */
+ attr_p->attr.sctpmap.port = (uint16_t)sdp_getnextnumtok(ptr, &ptr,
+ " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: no sctpmap port number",
+ sdp_p->debug_str);
+ return SDP_INVALID_PARAMETER;
+ }
+
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No sctpmap protocol specified.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_INVALID_PARAMETER;
+ }
+ sstrncpy(attr_p->attr.sctpmap.protocol, tmp,
+ sizeof (attr_p->attr.sctpmap.protocol));
+
+ streams = sdp_getnextnumtok(ptr, &ptr, " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No sctpmap streams specified.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_INVALID_PARAMETER;
+ }
+
+ attr_p->attr.sctpmap.streams = streams;
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_build_attr_sctpmap(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ flex_string_sprintf(fs, "a=%s:%u %s %u\r\n",
+ sdp_attr[attr_p->type].name,
+ attr_p->attr.sctpmap.port,
+ attr_p->attr.sctpmap.protocol,
+ attr_p->attr.sctpmap.streams);
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_direction (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ /* No parameters to parse. */
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type));
+ }
+
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_attr_direction (sdp_t *sdp_p, sdp_attr_t *attr_p, flex_string *fs)
+{
+ flex_string_sprintf(fs, "a=%s\r\n", sdp_get_attr_name(attr_p->type));
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_qos (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ int i;
+ sdp_result_e result;
+ char tmp[SDP_MAX_STRING_LEN];
+
+ /* Find the strength tag. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No qos strength tag specified.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ attr_p->attr.qos.strength = SDP_QOS_STRENGTH_UNKNOWN;
+ for (i=0; i < SDP_MAX_QOS_STRENGTH; i++) {
+ if (cpr_strncasecmp(tmp, sdp_qos_strength[i].name,
+ sdp_qos_strength[i].strlen) == 0) {
+ attr_p->attr.qos.strength = (sdp_qos_strength_e)i;
+ }
+ }
+ if (attr_p->attr.qos.strength == SDP_QOS_STRENGTH_UNKNOWN) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: QOS strength tag unrecognized (%s)",
+ sdp_p->debug_str, tmp);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Find the qos direction. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No qos direction specified.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ attr_p->attr.qos.direction = SDP_QOS_DIR_UNKNOWN;
+ for (i=0; i < SDP_MAX_QOS_DIR; i++) {
+ if (cpr_strncasecmp(tmp, sdp_qos_direction[i].name,
+ sdp_qos_direction[i].strlen) == 0) {
+ attr_p->attr.qos.direction = (sdp_qos_dir_e)i;
+ }
+ }
+ if (attr_p->attr.qos.direction == SDP_QOS_DIR_UNKNOWN) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: QOS direction unrecognized (%s)",
+ sdp_p->debug_str, tmp);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* See if confirm was specified. Defaults to FALSE. */
+ attr_p->attr.qos.confirm = FALSE;
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result == SDP_SUCCESS) {
+ if (cpr_strncasecmp(tmp, "confirm", sizeof("confirm")) == 0) {
+ attr_p->attr.qos.confirm = TRUE;
+ }
+ if (attr_p->attr.qos.confirm == FALSE) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: QOS confirm parameter invalid (%s)",
+ sdp_p->debug_str, tmp);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, strength %s, direction %s, confirm %s",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type),
+ sdp_get_qos_strength_name(attr_p->attr.qos.strength),
+ sdp_get_qos_direction_name(attr_p->attr.qos.direction),
+ (attr_p->attr.qos.confirm ? "set" : "not set"));
+ }
+
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_attr_qos (sdp_t *sdp_p, sdp_attr_t *attr_p, flex_string *fs)
+{
+ flex_string_sprintf(fs, "a=%s:%s %s%s\r\n", sdp_attr[attr_p->type].name,
+ sdp_get_qos_strength_name(attr_p->attr.qos.strength),
+ sdp_get_qos_direction_name(attr_p->attr.qos.direction),
+ attr_p->attr.qos.confirm ? " confirm" : "");
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_curr (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ int i;
+ sdp_result_e result;
+ char tmp[SDP_MAX_STRING_LEN];
+
+ /* Find the curr type tag. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No curr attr type specified.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ attr_p->attr.curr.type = SDP_CURR_UNKNOWN_TYPE;
+ for (i=0; i < SDP_MAX_CURR_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_curr_type[i].name,
+ sdp_curr_type[i].strlen) == 0) {
+ attr_p->attr.curr.type = (sdp_curr_type_e)i;
+ }
+ }
+
+ if (attr_p->attr.curr.type != SDP_CURR_QOS_TYPE) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Unknown curr type.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Check qos status type */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No curr attr type specified.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ attr_p->attr.curr.status_type = SDP_QOS_STATUS_TYPE_UNKNOWN;
+ for (i=0; i < SDP_MAX_QOS_STATUS_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_qos_status_type[i].name,
+ sdp_qos_status_type[i].strlen) == 0) {
+ attr_p->attr.curr.status_type = (sdp_qos_status_types_e)i;
+ }
+ }
+
+
+ /* Find the qos direction. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No qos direction specified.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ attr_p->attr.curr.direction = SDP_QOS_DIR_UNKNOWN;
+ for (i=0; i < SDP_MAX_QOS_DIR; i++) {
+ if (cpr_strncasecmp(tmp, sdp_qos_direction[i].name,
+ sdp_qos_direction[i].strlen) == 0) {
+ attr_p->attr.curr.direction = (sdp_qos_dir_e)i;
+ }
+ }
+ if (attr_p->attr.curr.direction == SDP_QOS_DIR_UNKNOWN) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: QOS direction unrecognized (%s)",
+ sdp_p->debug_str, tmp);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, type %s status type %s, direction %s",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type),
+ sdp_get_curr_type_name(attr_p->attr.curr.type),
+ sdp_get_qos_status_type_name(attr_p->attr.curr.status_type),
+ sdp_get_qos_direction_name(attr_p->attr.curr.direction));
+ }
+
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_attr_curr (sdp_t *sdp_p, sdp_attr_t *attr_p, flex_string *fs)
+{
+ flex_string_sprintf(fs, "a=%s:%s %s %s\r\n",
+ sdp_attr[attr_p->type].name,
+ sdp_get_curr_type_name(attr_p->attr.curr.type),
+ sdp_get_qos_status_type_name(attr_p->attr.curr.status_type),
+ sdp_get_qos_direction_name(attr_p->attr.curr.direction));
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_des (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ int i;
+ sdp_result_e result;
+ char tmp[SDP_MAX_STRING_LEN];
+
+ /* Find the curr type tag. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No des attr type specified.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ attr_p->attr.des.type = SDP_DES_UNKNOWN_TYPE;
+ for (i=0; i < SDP_MAX_CURR_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_des_type[i].name,
+ sdp_des_type[i].strlen) == 0) {
+ attr_p->attr.des.type = (sdp_des_type_e)i;
+ }
+ }
+
+ if (attr_p->attr.des.type != SDP_DES_QOS_TYPE) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Unknown conf type.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Find the strength tag. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No qos strength tag specified.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ attr_p->attr.des.strength = SDP_QOS_STRENGTH_UNKNOWN;
+ for (i=0; i < SDP_MAX_QOS_STRENGTH; i++) {
+ if (cpr_strncasecmp(tmp, sdp_qos_strength[i].name,
+ sdp_qos_strength[i].strlen) == 0) {
+ attr_p->attr.des.strength = (sdp_qos_strength_e)i;
+ }
+ }
+ if (attr_p->attr.des.strength == SDP_QOS_STRENGTH_UNKNOWN) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: QOS strength tag unrecognized (%s)",
+ sdp_p->debug_str, tmp);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Check qos status type */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No des attr type specified.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ attr_p->attr.des.status_type = SDP_QOS_STATUS_TYPE_UNKNOWN;
+ for (i=0; i < SDP_MAX_QOS_STATUS_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_qos_status_type[i].name,
+ sdp_qos_status_type[i].strlen) == 0) {
+ attr_p->attr.des.status_type = (sdp_qos_status_types_e)i;
+ }
+ }
+
+
+ /* Find the qos direction. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No qos direction specified.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ attr_p->attr.des.direction = SDP_QOS_DIR_UNKNOWN;
+ for (i=0; i < SDP_MAX_QOS_DIR; i++) {
+ if (cpr_strncasecmp(tmp, sdp_qos_direction[i].name,
+ sdp_qos_direction[i].strlen) == 0) {
+ attr_p->attr.des.direction = (sdp_qos_dir_e)i;
+ }
+ }
+ if (attr_p->attr.des.direction == SDP_QOS_DIR_UNKNOWN) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: QOS direction unrecognized (%s)",
+ sdp_p->debug_str, tmp);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, type %s strength %s status type %s, direction %s",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type),
+ sdp_get_des_type_name(attr_p->attr.des.type),
+ sdp_get_qos_strength_name(attr_p->attr.qos.strength),
+ sdp_get_qos_status_type_name(attr_p->attr.des.status_type),
+ sdp_get_qos_direction_name(attr_p->attr.des.direction));
+ }
+
+ return (SDP_SUCCESS);
+}
+
+
+sdp_result_e sdp_build_attr_des (sdp_t *sdp_p, sdp_attr_t *attr_p, flex_string *fs)
+{
+ flex_string_sprintf(fs, "a=%s:%s %s %s %s\r\n",
+ sdp_attr[attr_p->type].name,
+ sdp_get_curr_type_name((sdp_curr_type_e)attr_p->attr.des.type),
+ sdp_get_qos_strength_name(attr_p->attr.des.strength),
+ sdp_get_qos_status_type_name(attr_p->attr.des.status_type),
+ sdp_get_qos_direction_name(attr_p->attr.des.direction));
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_conf (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ int i;
+ sdp_result_e result;
+ char tmp[SDP_MAX_STRING_LEN];
+
+ /* Find the curr type tag. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No conf attr type specified.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ attr_p->attr.conf.type = SDP_CONF_UNKNOWN_TYPE;
+ for (i=0; i < SDP_MAX_CURR_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_conf_type[i].name,
+ sdp_conf_type[i].strlen) == 0) {
+ attr_p->attr.conf.type = (sdp_conf_type_e)i;
+ }
+ }
+
+ if (attr_p->attr.conf.type != SDP_CONF_QOS_TYPE) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Unknown conf type.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Check qos status type */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No conf attr type specified.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ attr_p->attr.conf.status_type = SDP_QOS_STATUS_TYPE_UNKNOWN;
+ for (i=0; i < SDP_MAX_QOS_STATUS_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_qos_status_type[i].name,
+ sdp_qos_status_type[i].strlen) == 0) {
+ attr_p->attr.conf.status_type = (sdp_qos_status_types_e)i;
+ }
+ }
+
+
+ /* Find the qos direction. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No qos direction specified.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ attr_p->attr.conf.direction = SDP_QOS_DIR_UNKNOWN;
+ for (i=0; i < SDP_MAX_QOS_DIR; i++) {
+ if (cpr_strncasecmp(tmp, sdp_qos_direction[i].name,
+ sdp_qos_direction[i].strlen) == 0) {
+ attr_p->attr.conf.direction = (sdp_qos_dir_e)i;
+ }
+ }
+ if (attr_p->attr.conf.direction == SDP_QOS_DIR_UNKNOWN) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: QOS direction unrecognized (%s)",
+ sdp_p->debug_str, tmp);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, type %s status type %s, direction %s",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type),
+ sdp_get_conf_type_name(attr_p->attr.conf.type),
+ sdp_get_qos_status_type_name(attr_p->attr.conf.status_type),
+ sdp_get_qos_direction_name(attr_p->attr.conf.direction));
+ }
+
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_attr_conf (sdp_t *sdp_p, sdp_attr_t *attr_p, flex_string *fs)
+{
+ flex_string_sprintf(fs, "a=%s:%s %s %s\r\n",
+ sdp_attr[attr_p->type].name,
+ sdp_get_conf_type_name(attr_p->attr.conf.type),
+ sdp_get_qos_status_type_name(attr_p->attr.conf.status_type),
+ sdp_get_qos_direction_name(attr_p->attr.conf.direction));
+
+ return SDP_SUCCESS;
+}
+
+/*
+ * Parse a rtpmap or a sprtmap. Both formats use the same structure
+ * the only difference being the keyword "rtpmap" vs "sprtmap". The
+ * rtpmap field in the sdp_attr_t is used to store both mappings.
+ */
+sdp_result_e sdp_parse_attr_transport_map (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ sdp_result_e result;
+
+ attr_p->attr.transport_map.payload_num = 0;
+ attr_p->attr.transport_map.encname[0] = '\0';
+ attr_p->attr.transport_map.clockrate = 0;
+ attr_p->attr.transport_map.num_chan = 1;
+
+ /* Find the payload type number. */
+ attr_p->attr.transport_map.payload_num =
+ (uint16_t)sdp_getnextnumtok(ptr, &ptr, " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Invalid payload type specified for %s attribute.",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type));
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Find the encoding name. */
+ ptr = sdp_getnextstrtok(ptr, attr_p->attr.transport_map.encname,
+ sizeof(attr_p->attr.transport_map.encname), "/ \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No encoding name specified in %s attribute.",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type));
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Find the clockrate. */
+ attr_p->attr.transport_map.clockrate =
+ sdp_getnextnumtok(ptr, &ptr, "/ \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No clockrate specified for "
+ "%s attribute, set to default of 8000.",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type));
+ attr_p->attr.transport_map.clockrate = 8000;
+ }
+
+ /* Find the number of channels, if specified. This is optional. */
+ if (*ptr == '/') {
+ /* If a '/' exists, expect something valid beyond it. */
+ attr_p->attr.transport_map.num_chan =
+ (uint16_t)sdp_getnextnumtok(ptr, &ptr, "/ \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Invalid number of channels parameter"
+ " for rtpmap attribute.", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, payload type %u, encoding name %s, "
+ "clockrate %u", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type),
+ attr_p->attr.transport_map.payload_num,
+ attr_p->attr.transport_map.encname,
+ attr_p->attr.transport_map.clockrate);
+ if (attr_p->attr.transport_map.num_chan != 1) {
+ SDP_PRINT("/%u", attr_p->attr.transport_map.num_chan);
+ }
+ }
+
+ return (SDP_SUCCESS);
+}
+
+/*
+ * Build a rtpmap or a sprtmap. Both formats use the same structure
+ * the only difference being the keyword "rtpmap" vs "sprtmap". The
+ * rtpmap field in the sdp_attr_t is used for both mappings.
+ */
+sdp_result_e sdp_build_attr_transport_map (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ if (attr_p->attr.transport_map.num_chan == 1) {
+ flex_string_sprintf(fs, "a=%s:%u %s/%u\r\n",
+ sdp_attr[attr_p->type].name,
+ attr_p->attr.transport_map.payload_num,
+ attr_p->attr.transport_map.encname,
+ attr_p->attr.transport_map.clockrate);
+ } else {
+ flex_string_sprintf(fs, "a=%s:%u %s/%u/%u\r\n",
+ sdp_attr[attr_p->type].name,
+ attr_p->attr.transport_map.payload_num,
+ attr_p->attr.transport_map.encname,
+ attr_p->attr.transport_map.clockrate,
+ attr_p->attr.transport_map.num_chan);
+ }
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_subnet (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ int i;
+ char *slash_ptr;
+ sdp_result_e result;
+ tinybool type_found = FALSE;
+ char tmp[SDP_MAX_STRING_LEN];
+
+ /* Find the subnet network type. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No network type specified in subnet attribute.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ attr_p->attr.subnet.nettype = SDP_NT_UNSUPPORTED;
+ for (i=0; i < SDP_MAX_NETWORK_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_nettype[i].name,
+ sdp_nettype[i].strlen) == 0) {
+ type_found = TRUE;
+ }
+ if (type_found == TRUE) {
+ if (sdp_p->conf_p->nettype_supported[i] == TRUE) {
+ attr_p->attr.subnet.nettype = (sdp_nettype_e)i;
+ }
+ type_found = FALSE;
+ }
+ }
+ if (attr_p->attr.subnet.nettype == SDP_NT_UNSUPPORTED) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Subnet network type unsupported (%s).",
+ sdp_p->debug_str, tmp);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Find the subnet address type. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No address type specified in subnet attribute.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ attr_p->attr.subnet.addrtype = SDP_AT_UNSUPPORTED;
+ for (i=0; i < SDP_MAX_ADDR_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_addrtype[i].name,
+ sdp_addrtype[i].strlen) == 0) {
+ type_found = TRUE;
+ }
+ if (type_found == TRUE) {
+ if (sdp_p->conf_p->addrtype_supported[i] == TRUE) {
+ attr_p->attr.subnet.addrtype = (sdp_addrtype_e)i;
+ }
+ type_found = FALSE;
+ }
+ }
+ if (attr_p->attr.subnet.addrtype == SDP_AT_UNSUPPORTED) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Subnet address type unsupported (%s).",
+ sdp_p->debug_str, tmp);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Find the subnet address. */
+ ptr = sdp_getnextstrtok(ptr, attr_p->attr.subnet.addr,
+ sizeof(attr_p->attr.subnet.addr), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No subnet address specified in "
+ "subnet attribute.", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ slash_ptr = sdp_findchar(attr_p->attr.subnet.addr, "/");
+ if (*slash_ptr == '/') {
+ *slash_ptr++ = '\0';
+ /* If the '/' exists, expect a valid prefix to follow. */
+ attr_p->attr.subnet.prefix = sdp_getnextnumtok(slash_ptr,
+ (const char **)&slash_ptr,
+ " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Invalid subnet prefix specified in "
+ "subnet attribute.", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ } else {
+ attr_p->attr.subnet.prefix = SDP_INVALID_VALUE;
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, network %s, addr type %s, address %s ",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type),
+ sdp_get_network_name(attr_p->attr.subnet.nettype),
+ sdp_get_address_name(attr_p->attr.subnet.addrtype),
+ attr_p->attr.subnet.addr);
+ if (attr_p->attr.subnet.prefix != SDP_INVALID_VALUE) {
+ SDP_PRINT("/%u", (ushort)attr_p->attr.subnet.prefix);
+ }
+ }
+
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_attr_subnet (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ if (attr_p->attr.subnet.prefix == SDP_INVALID_VALUE) {
+ flex_string_sprintf(fs, "a=%s:%s %s %s\r\n",
+ sdp_attr[attr_p->type].name,
+ sdp_get_network_name(attr_p->attr.subnet.nettype),
+ sdp_get_address_name(attr_p->attr.subnet.addrtype),
+ attr_p->attr.subnet.addr);
+ } else {
+ flex_string_sprintf(fs, "a=%s:%s %s %s/%u\r\n",
+ sdp_attr[attr_p->type].name,
+ sdp_get_network_name(attr_p->attr.subnet.nettype),
+ sdp_get_address_name(attr_p->attr.subnet.addrtype),
+ attr_p->attr.subnet.addr,
+ (ushort)attr_p->attr.subnet.prefix);
+ }
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_t38_ratemgmt (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ int i;
+ sdp_result_e result;
+ char tmp[SDP_MAX_STRING_LEN];
+
+ /* Find the rate mgmt. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No t38 rate management specified.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ attr_p->attr.t38ratemgmt = SDP_T38_UNKNOWN_RATE;
+ for (i=0; i < SDP_T38_MAX_RATES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_t38_rate[i].name,
+ sdp_t38_rate[i].strlen) == 0) {
+ attr_p->attr.t38ratemgmt = (sdp_t38_ratemgmt_e)i;
+ }
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, rate %s", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type),
+ sdp_get_t38_ratemgmt_name(attr_p->attr.t38ratemgmt));
+ }
+
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_attr_t38_ratemgmt (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ flex_string_sprintf(fs, "a=%s:%s\r\n",
+ sdp_attr[attr_p->type].name,
+ sdp_get_t38_ratemgmt_name(attr_p->attr.t38ratemgmt));
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_t38_udpec (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ int i;
+ sdp_result_e result;
+ char tmp[SDP_MAX_STRING_LEN];
+
+ /* Find the udpec. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No t38 udpEC specified.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ attr_p->attr.t38udpec = SDP_T38_UDPEC_UNKNOWN;
+ for (i=0; i < SDP_T38_MAX_UDPEC; i++) {
+ if (cpr_strncasecmp(tmp, sdp_t38_udpec[i].name,
+ sdp_t38_udpec[i].strlen) == 0) {
+ attr_p->attr.t38udpec = (sdp_t38_udpec_e)i;
+ }
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, udpec %s", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type),
+ sdp_get_t38_udpec_name(attr_p->attr.t38udpec));
+ }
+
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_attr_t38_udpec (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ flex_string_sprintf(fs, "a=%s:%s\r\n",
+ sdp_attr[attr_p->type].name,
+ sdp_get_t38_udpec_name(attr_p->attr.t38udpec));
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_pc_codec (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ uint16_t i;
+ sdp_result_e result;
+
+ for (i=0; i < SDP_MAX_PAYLOAD_TYPES; i++) {
+ attr_p->attr.pccodec.payload_type[i] = (ushort)sdp_getnextnumtok(ptr, &ptr,
+ " \t", &result);
+ if (result != SDP_SUCCESS) {
+ break;
+ }
+ attr_p->attr.pccodec.num_payloads++;
+ }
+
+ if (attr_p->attr.pccodec.num_payloads == 0) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No payloads specified for %s attr.",
+ sdp_p->debug_str, sdp_attr[attr_p->type].name);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, num payloads %u, payloads: ",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type),
+ attr_p->attr.pccodec.num_payloads);
+ for (i=0; i < attr_p->attr.pccodec.num_payloads; i++) {
+ SDP_PRINT("%u ", attr_p->attr.pccodec.payload_type[i]);
+ }
+ }
+
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_attr_pc_codec (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ int i;
+
+ flex_string_sprintf(fs, "a=%s: ", sdp_attr[attr_p->type].name);
+
+ for (i=0; i < attr_p->attr.pccodec.num_payloads; i++) {
+ flex_string_sprintf(fs, "%u ", attr_p->attr.pccodec.payload_type[i]);
+ }
+
+ flex_string_append(fs, "\r\n");
+
+ return SDP_SUCCESS;
+}
+
+
+sdp_result_e sdp_parse_attr_cap (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ uint16_t i;
+ sdp_result_e result;
+ sdp_mca_t *cap_p;
+ char tmp[SDP_MAX_STRING_LEN];
+
+ /* Set the capability pointer to NULL for now in case we encounter
+ * an error in parsing.
+ */
+ attr_p->attr.cap_p = NULL;
+ /* Set the capability valid flag to FALSE in case we encounter an
+ * error. If we do, we don't want to process any X-cpar/cpar attributes
+ * from this point until we process the next valid X-cap/cdsc attr. */
+ sdp_p->cap_valid = FALSE;
+
+ /* Allocate resource for new capability. Note that the capability
+ * uses the same structure used for media lines.
+ */
+ cap_p = sdp_alloc_mca(sdp_p->parse_line);
+ if (cap_p == NULL) {
+ sdp_p->conf_p->num_no_resource++;
+ return (SDP_NO_RESOURCE);
+ }
+
+ /* Find the capability number. We don't need to store this since we
+ * calculate it for ourselves as we need to. But it must be specified. */
+ (void)sdp_getnextnumtok(ptr, &ptr, "/ \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Capability not specified for %s, "
+ "unable to parse.", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type));
+ SDP_FREE(cap_p);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Find the media type. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s No media type specified for %s attribute, "
+ "unable to parse.",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type));
+ SDP_FREE(cap_p);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ cap_p->media = SDP_MEDIA_UNSUPPORTED;
+ for (i=0; i < SDP_MAX_MEDIA_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_media[i].name, sdp_media[i].strlen) == 0) {
+ cap_p->media = (sdp_media_e)i;
+ break;
+ }
+ }
+ if (cap_p->media == SDP_MEDIA_UNSUPPORTED) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Media type unsupported (%s).",
+ sdp_p->debug_str, tmp);
+ SDP_FREE(cap_p);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Find the transport protocol type. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s No transport protocol type specified, "
+ "unable to parse.", sdp_p->debug_str);
+ SDP_FREE(cap_p);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ cap_p->transport = SDP_TRANSPORT_UNSUPPORTED;
+ for (i=0; i < SDP_MAX_TRANSPORT_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_transport[i].name,
+ sdp_transport[i].strlen) == 0) {
+ cap_p->transport = (sdp_transport_e)i;
+ break;
+ }
+ }
+ if (cap_p->transport == SDP_TRANSPORT_UNSUPPORTED) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Transport protocol type unsupported (%s).",
+ sdp_p->debug_str, tmp);
+ SDP_FREE(cap_p);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Find payload formats. AAL2 X-cap lines allow multiple
+ * transport/profile types per line, so these are handled differently.
+ */
+ if ((cap_p->transport == SDP_TRANSPORT_AAL2_ITU) ||
+ (cap_p->transport == SDP_TRANSPORT_AAL2_ATMF) ||
+ (cap_p->transport == SDP_TRANSPORT_AAL2_CUSTOM)) {
+ /* Capability processing is not currently defined for AAL2 types
+ * with multiple profiles. We don't process. */
+ sdp_parse_error(sdp_p,
+ "%s Warning: AAL2 profiles unsupported with "
+ "%s attributes.", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type));
+ SDP_FREE(cap_p);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ /* Transport is a non-AAL2 type. Parse payloads normally. */
+ sdp_parse_payload_types(sdp_p, cap_p, ptr);
+ if (cap_p->num_payloads == 0) {
+ SDP_FREE(cap_p);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ }
+
+ attr_p->attr.cap_p = cap_p;
+ /*
+ * This capability attr is valid. We can now handle X-cpar or
+ * cpar attrs.
+ */
+ sdp_p->cap_valid = TRUE;
+ sdp_p->last_cap_inst++;
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed %s media type %s, Transport %s, "
+ "Num payloads %u", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type),
+ sdp_get_media_name(cap_p->media),
+ sdp_get_transport_name(cap_p->transport),
+ cap_p->num_payloads);
+ }
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_attr_cap (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ uint16_t i, j;
+ sdp_mca_t *cap_p;
+ sdp_media_profiles_t *profile_p;
+
+ /* Get a pointer to the capability structure. */
+ cap_p = attr_p->attr.cap_p;
+
+ if (cap_p == NULL) {
+ CSFLogError(logTag, "%s Invalid %s attribute, unable to build.",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type));
+ sdp_p->conf_p->num_invalid_param++;
+ /* Return success so build won't fail. */
+ return (SDP_SUCCESS);
+ }
+
+ /* Validate params for this capability line */
+ if ((cap_p->media >= SDP_MAX_MEDIA_TYPES) ||
+ (cap_p->transport >= SDP_MAX_TRANSPORT_TYPES)) {
+ CSFLogDebug(logTag, logTag, "%s Media or transport type invalid for %s "
+ "attribute, unable to build.", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type));
+ sdp_p->conf_p->num_invalid_param++;
+ /* Return success so build won't fail. */
+ return (SDP_SUCCESS);
+ }
+
+ flex_string_sprintf(fs, "a=%s: %u %s ", sdp_attr[attr_p->type].name,
+ sdp_p->cur_cap_num, sdp_get_media_name(cap_p->media));
+
+ /* If the X-cap line has AAL2 profiles, build them differently. */
+ if ((cap_p->transport == SDP_TRANSPORT_AAL2_ITU) ||
+ (cap_p->transport == SDP_TRANSPORT_AAL2_ATMF) ||
+ (cap_p->transport == SDP_TRANSPORT_AAL2_CUSTOM)) {
+ profile_p = cap_p->media_profiles_p;
+ for (i=0; i < profile_p->num_profiles; i++) {
+ flex_string_sprintf(fs, "%s",
+ sdp_get_transport_name(profile_p->profile[i]));
+
+ for (j=0; j < profile_p->num_payloads[i]; j++) {
+ flex_string_sprintf(fs, " %u",
+ profile_p->payload_type[i][j]);
+ }
+ flex_string_append(fs, " ");
+ }
+
+ flex_string_append(fs, "\r\n");
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Built m= media line", sdp_p->debug_str);
+ }
+ return SDP_SUCCESS;
+ }
+
+ /* Build the transport name */
+ flex_string_sprintf(fs, "%s", sdp_get_transport_name(cap_p->transport));
+
+ /* Build the format lists */
+ for (i=0; i < cap_p->num_payloads; i++) {
+ if (cap_p->payload_indicator[i] == SDP_PAYLOAD_ENUM) {
+ flex_string_sprintf(fs, " %s",
+ sdp_get_payload_name((sdp_payload_e)cap_p->payload_type[i]));
+ } else {
+ flex_string_sprintf(fs, " %u", cap_p->payload_type[i]);
+ }
+ }
+
+ flex_string_append(fs, "\r\n");
+
+ /* Increment the current capability number for the next X-cap/cdsc attr. */
+ sdp_p->cur_cap_num += cap_p->num_payloads;
+ sdp_p->last_cap_type = attr_p->type;
+
+ /* Build any X-cpar/cpar attributes associated with this X-cap/cdsc line. */
+ return sdp_build_attr_cpar(sdp_p, cap_p->media_attrs_p, fs);
+}
+
+
+sdp_result_e sdp_parse_attr_cpar (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ uint16_t i;
+ sdp_result_e result;
+ sdp_mca_t *cap_p;
+ sdp_attr_t *cap_attr_p = NULL;
+ sdp_attr_t *prev_attr_p;
+ char tmp[SDP_MAX_STRING_LEN];
+
+ /* Make sure we've processed a valid X-cap/cdsc attr prior to this and
+ * if so, get the cap pointer. */
+ if (sdp_p->cap_valid == TRUE) {
+ sdp_attr_e cap_type;
+
+ if (attr_p->type == SDP_ATTR_CPAR) {
+ cap_type = SDP_ATTR_CDSC;
+ } else {
+ /* Default to X-CAP for everything else */
+ cap_type = SDP_ATTR_X_CAP;
+ }
+
+ if (sdp_p->mca_count == 0) {
+ cap_attr_p = sdp_find_attr(sdp_p, SDP_SESSION_LEVEL, 0,
+ cap_type, sdp_p->last_cap_inst);
+ } else {
+ cap_attr_p = sdp_find_attr(sdp_p, sdp_p->mca_count, 0,
+ cap_type, sdp_p->last_cap_inst);
+ }
+ }
+ if ((cap_attr_p == NULL) || (cap_attr_p->attr.cap_p == NULL)) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: %s attribute specified with no "
+ "prior %s attribute", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type),
+ (attr_p->type == SDP_ATTR_CPAR)?
+ (sdp_get_attr_name(SDP_ATTR_CDSC)) :
+ (sdp_get_attr_name(SDP_ATTR_X_CAP)) );
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /*
+ * Ensure there is no mixed syntax like CDSC followed by X-CPAR
+ * or X-CAP followed by CPAR.
+ */
+ if (((cap_attr_p->type == SDP_ATTR_CDSC) &&
+ (attr_p->type == SDP_ATTR_X_CPAR)) ||
+ ( (cap_attr_p->type == SDP_ATTR_X_CAP) &&
+ (attr_p->type == SDP_ATTR_CPAR)) ) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: %s attribute inconsistent with "
+ "prior %s attribute", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type),
+ sdp_get_attr_name(cap_attr_p->type));
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ cap_p = cap_attr_p->attr.cap_p;
+
+ /* a= is the only token we handle in an X-cpar/cpar attribute. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), "= \t", &result);
+
+ if ((result != SDP_SUCCESS) || (tmp[0] != 'a') || (tmp[1] != '\0')) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Invalid token type (%s) in %s "
+ "attribute, unable to parse", sdp_p->debug_str, tmp,
+ sdp_get_attr_name(attr_p->type));
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ /*sa_ignore NO_NULL_CHK
+ *{ptr is valid since the pointer was checked earlier and the
+ * function would have exited if NULL.}
+ */
+ if (*ptr == '=') {
+ ptr++;
+ }
+
+ /* Find the attribute type. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), ": \t", &result);
+ /*sa_ignore NO_NULL_CHK
+ *{ptr is valid since the pointer was checked earlier and the
+ * function would have exited if NULL.}
+ */
+ if (ptr[0] == ':') {
+ /* Skip the ':' char for parsing attribute parameters. */
+ ptr++;
+ }
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s No attribute type specified for %s attribute, unable to parse.",
+ sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type));
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Reset the type of the attribute from X-cpar/cpar to whatever the
+ * specified type is. */
+ attr_p->type = SDP_ATTR_INVALID;
+ attr_p->next_p = NULL;
+ for (i=0; i < SDP_MAX_ATTR_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_attr[i].name, sdp_attr[i].strlen) == 0) {
+ attr_p->type = (sdp_attr_e)i;
+ }
+ }
+ if (attr_p->type == SDP_ATTR_INVALID) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Unrecognized attribute (%s) for %s attribute, unable to parse.",
+ sdp_p->debug_str, tmp,
+ sdp_get_attr_name(attr_p->type));
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* We don't allow recursion with the capability attributes. */
+ if ((attr_p->type == SDP_ATTR_X_SQN) ||
+ (attr_p->type == SDP_ATTR_X_CAP) ||
+ (attr_p->type == SDP_ATTR_X_CPAR) ||
+ (attr_p->type == SDP_ATTR_SQN) ||
+ (attr_p->type == SDP_ATTR_CDSC) ||
+ (attr_p->type == SDP_ATTR_CPAR)) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Invalid attribute (%s) for %s"
+ " attribute, unable to parse.", sdp_p->debug_str, tmp,
+ sdp_get_attr_name(attr_p->type));
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Parse the attribute. */
+ result = sdp_attr[attr_p->type].parse_func(sdp_p, attr_p, ptr);
+ if (result != SDP_SUCCESS) {
+ return (result);
+ }
+
+ /* Hook the attribute into the capability structure. */
+ if (cap_p->media_attrs_p == NULL) {
+ cap_p->media_attrs_p = attr_p;
+ } else {
+ for (prev_attr_p = cap_p->media_attrs_p;
+ prev_attr_p->next_p != NULL;
+ prev_attr_p = prev_attr_p->next_p) {
+ ; /* Empty for */
+ }
+ prev_attr_p->next_p = attr_p;
+ }
+
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_attr_cpar (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ sdp_result_e result;
+ const char *cpar_name;
+
+ /* Determine whether to use cpar or X-cpar */
+ if (sdp_p->last_cap_type == SDP_ATTR_CDSC) {
+ cpar_name = sdp_get_attr_name(SDP_ATTR_CPAR);
+ } else {
+ /*
+ * Default to X-CPAR if anything else. This is the backward
+ * compatible value.
+ */
+ cpar_name = sdp_get_attr_name(SDP_ATTR_X_CPAR);
+ }
+
+ while (attr_p != NULL) {
+ if (attr_p->type >= SDP_MAX_ATTR_TYPES) {
+ CSFLogDebug(logTag, "%s Invalid attribute type to build (%u)",
+ sdp_p->debug_str, (unsigned)attr_p->type);
+ } else {
+ flex_string_sprintf(fs, "a=%s: ", cpar_name);
+
+ result = sdp_attr[attr_p->type].build_func(sdp_p, attr_p, fs);
+
+ if (result == SDP_SUCCESS) {
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Built %s a=%s attribute line",
+ sdp_p->debug_str, cpar_name,
+ sdp_get_attr_name(attr_p->type));
+ }
+ }
+ }
+ attr_p = attr_p->next_p;
+ }
+
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_parse_attr_rtcp (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ sdp_result_e result;
+ char nettype[SDP_MAX_STRING_LEN];
+ sdp_rtcp_t *rtcp_p = &(attr_p->attr.rtcp);
+ int enum_raw;
+
+ memset(rtcp_p, 0, sizeof(sdp_rtcp_t));
+
+ rtcp_p->port = (uint16_t)sdp_getnextnumtok(ptr, &ptr, " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: could not parse port for rtcp attribute",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+
+ return SDP_INVALID_PARAMETER;
+ }
+
+ /* The rest is optional, although it is all-or-nothing */
+ (void)sdp_getnextstrtok(ptr, nettype, sizeof(nettype), " \t", &result);
+ if (result == SDP_EMPTY_TOKEN) {
+ /* Nothing after the port */
+ return SDP_SUCCESS;
+ }
+
+ enum_raw = find_token_enum("Nettype", sdp_p, &ptr, sdp_nettype,
+ SDP_MAX_NETWORK_TYPES, SDP_NT_UNSUPPORTED);
+ if (enum_raw == -1) {
+ return SDP_INVALID_PARAMETER;
+ }
+ rtcp_p->nettype = (sdp_nettype_e)enum_raw;
+
+ enum_raw = find_token_enum("Addrtype", sdp_p, &ptr, sdp_addrtype,
+ SDP_MAX_ADDR_TYPES, SDP_AT_UNSUPPORTED);
+ if (enum_raw == -1) {
+ return SDP_INVALID_PARAMETER;
+ }
+ rtcp_p->addrtype = (sdp_addrtype_e)enum_raw;
+
+ ptr = sdp_getnextstrtok(ptr, rtcp_p->addr, sizeof(rtcp_p->addr), " \t",
+ &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: could not parse addr for rtcp attribute",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+
+ return SDP_INVALID_PARAMETER;
+ }
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_build_attr_rtcp (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ /* We should not be serializing SDP anyway, but we need this function until
+ * Bug 1112737 is resolved. */
+ return SDP_FAILURE;
+}
+
+sdp_result_e sdp_parse_attr_rtr (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ sdp_result_e result;
+ char tmp[SDP_MAX_STRING_LEN];
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsing a=%s", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type));
+ }
+ /*Default confirm to FALSE. */
+ attr_p->attr.rtr.confirm = FALSE;
+
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS){ // No confirm tag specified is not an error
+ return (SDP_SUCCESS);
+ } else {
+ /* See if confirm was specified. Defaults to FALSE. */
+ if (cpr_strncasecmp(tmp, "confirm", sizeof("confirm")) == 0) {
+ attr_p->attr.rtr.confirm = TRUE;
+ }
+ if (attr_p->attr.rtr.confirm == FALSE) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: RTR confirm parameter invalid (%s)",
+ sdp_p->debug_str, tmp);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, %s", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type),
+ tmp);
+ }
+ return (SDP_SUCCESS);
+ }
+}
+
+sdp_result_e sdp_build_attr_rtr (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ flex_string_sprintf(fs, "a=%s%s\r\n",
+ sdp_attr[attr_p->type].name,
+ attr_p->attr.rtr.confirm ? ":confirm" : "");
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_comediadir (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ int i;
+ sdp_result_e result;
+ tinybool type_found = FALSE;
+ char tmp[SDP_MAX_STRING_LEN];
+
+ attr_p->attr.comediadir.role = SDP_MEDIADIR_ROLE_PASSIVE;
+ attr_p->attr.comediadir.conn_info_present = FALSE;
+ attr_p->attr.comediadir.conn_info.nettype = SDP_NT_INVALID;
+ attr_p->attr.comediadir.src_port = 0;
+
+ /* Find the media direction role. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), ": \t", &result);
+
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No role parameter specified for "
+ "comediadir attribute.", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ attr_p->attr.comediadir.role = SDP_MEDIADIR_ROLE_UNSUPPORTED;
+ for (i=0; i < SDP_MAX_MEDIADIR_ROLES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_mediadir_role[i].name,
+ sdp_mediadir_role[i].strlen) == 0) {
+ type_found = TRUE;
+ attr_p->attr.comediadir.role = (sdp_mediadir_role_e)i;
+ break;
+ }
+ }
+ if (attr_p->attr.comediadir.role == SDP_MEDIADIR_ROLE_UNSUPPORTED) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Invalid role type specified for "
+ "comediadir attribute (%s).", sdp_p->debug_str, tmp);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* If the role is passive, we don't expect any more params. */
+ if (attr_p->attr.comediadir.role == SDP_MEDIADIR_ROLE_PASSIVE) {
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, passive",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type));
+ }
+ return (SDP_SUCCESS);
+ }
+
+ /* Find the connection information if present */
+ /* parse to get the nettype */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No network type specified in comediadir "
+ "attribute.", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_SUCCESS); /* as the optional parameters are not there */
+ }
+ attr_p->attr.comediadir.conn_info.nettype = SDP_NT_UNSUPPORTED;
+ for (i=0; i < SDP_MAX_NETWORK_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_nettype[i].name,
+ sdp_nettype[i].strlen) == 0) {
+ type_found = TRUE;
+ }
+ if (type_found == TRUE) {
+ if (sdp_p->conf_p->nettype_supported[i] == TRUE) {
+ attr_p->attr.comediadir.conn_info.nettype = (sdp_nettype_e)i;
+ }
+ type_found = FALSE;
+ }
+ }
+ if (attr_p->attr.comediadir.conn_info.nettype == SDP_NT_UNSUPPORTED) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: ConnInfo in Comediadir: network type "
+ "unsupported (%s).", sdp_p->debug_str, tmp);
+ sdp_p->conf_p->num_invalid_param++;
+ }
+
+ /* Find the comedia address type. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No address type specified in comediadir"
+ " attribute.", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ }
+ attr_p->attr.comediadir.conn_info.addrtype = SDP_AT_UNSUPPORTED;
+ for (i=0; i < SDP_MAX_ADDR_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_addrtype[i].name,
+ sdp_addrtype[i].strlen) == 0) {
+ type_found = TRUE;
+ }
+ if (type_found == TRUE) {
+ if (sdp_p->conf_p->addrtype_supported[i] == TRUE) {
+ attr_p->attr.comediadir.conn_info.addrtype = (sdp_addrtype_e)i;
+ }
+ type_found = FALSE;
+ }
+ }
+ if (attr_p->attr.comediadir.conn_info.addrtype == SDP_AT_UNSUPPORTED) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Conninfo address type unsupported "
+ "(%s).", sdp_p->debug_str, tmp);
+ sdp_p->conf_p->num_invalid_param++;
+ }
+
+ /* Find the conninfo address. */
+ ptr = sdp_getnextstrtok(ptr, attr_p->attr.comediadir.conn_info.conn_addr,
+ sizeof(attr_p->attr.comediadir.conn_info.conn_addr), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No conninfo address specified in "
+ "comediadir attribute.", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ }
+
+ /* Find the src port info , if any */
+ attr_p->attr.comediadir.src_port = sdp_getnextnumtok(ptr, &ptr, " \t",
+ &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No src port specified in "
+ "comediadir attribute.", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, network %s, addr type %s, address %s "
+ "srcport %u ",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type),
+ sdp_get_network_name(attr_p->attr.comediadir.conn_info.nettype),
+ sdp_get_address_name(attr_p->attr.comediadir.conn_info.addrtype),
+ attr_p->attr.comediadir.conn_info.conn_addr,
+ (unsigned int)attr_p->attr.comediadir.src_port);
+ }
+
+ if (sdp_p->conf_p->num_invalid_param > 0) {
+ return (SDP_INVALID_PARAMETER);
+ }
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e
+sdp_build_attr_comediadir (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ flex_string_sprintf(fs, "a=%s:%s\r\n",
+ sdp_attr[attr_p->type].name,
+ sdp_get_mediadir_role_name(attr_p->attr.comediadir.role));
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_silencesupp (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ int i;
+ sdp_result_e result;
+ char tmp[SDP_MAX_STRING_LEN];
+
+ /* Find silenceSuppEnable */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s No silenceSupp enable value specified, parse failed.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ if (cpr_strncasecmp(tmp, "on", sizeof("on")) == 0) {
+ attr_p->attr.silencesupp.enabled = TRUE;
+ } else if (cpr_strncasecmp(tmp, "off", sizeof("off")) == 0) {
+ attr_p->attr.silencesupp.enabled = FALSE;
+ } else if (cpr_strncasecmp(tmp, "-", sizeof("-")) == 0) {
+ attr_p->attr.silencesupp.enabled = FALSE;
+ } else {
+ sdp_parse_error(sdp_p,
+ "%s Warning: silenceSuppEnable parameter invalid (%s)",
+ sdp_p->debug_str, tmp);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Find silenceTimer -- uint16_t or "-" */
+
+ attr_p->attr.silencesupp.timer =
+ (uint16_t)sdp_getnextnumtok_or_null(ptr, &ptr, " \t",
+ &attr_p->attr.silencesupp.timer_null,
+ &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Invalid timer value specified for "
+ "silenceSupp attribute.", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Find suppPref */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No silenceSupp pref specified.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ attr_p->attr.silencesupp.pref = SDP_SILENCESUPP_PREF_UNKNOWN;
+ for (i=0; i < SDP_MAX_SILENCESUPP_PREF; i++) {
+ if (cpr_strncasecmp(tmp, sdp_silencesupp_pref[i].name,
+ sdp_silencesupp_pref[i].strlen) == 0) {
+ attr_p->attr.silencesupp.pref = (sdp_silencesupp_pref_e)i;
+ }
+ }
+ if (attr_p->attr.silencesupp.pref == SDP_SILENCESUPP_PREF_UNKNOWN) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: silenceSupp pref unrecognized (%s)",
+ sdp_p->debug_str, tmp);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Find sidUse */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No silenceSupp sidUse specified.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ attr_p->attr.silencesupp.siduse = SDP_SILENCESUPP_SIDUSE_UNKNOWN;
+ for (i=0; i < SDP_MAX_SILENCESUPP_SIDUSE; i++) {
+ if (cpr_strncasecmp(tmp, sdp_silencesupp_siduse[i].name,
+ sdp_silencesupp_siduse[i].strlen) == 0) {
+ attr_p->attr.silencesupp.siduse = (sdp_silencesupp_siduse_e)i;
+ }
+ }
+ if (attr_p->attr.silencesupp.siduse == SDP_SILENCESUPP_SIDUSE_UNKNOWN) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: silenceSupp sidUse unrecognized (%s)",
+ sdp_p->debug_str, tmp);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Find fxnslevel -- uint8_t or "-" */
+ attr_p->attr.silencesupp.fxnslevel =
+ (uint8_t)sdp_getnextnumtok_or_null(ptr, &ptr, " \t",
+ &attr_p->attr.silencesupp.fxnslevel_null,
+ &result);
+
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Invalid fxnslevel value specified for "
+ "silenceSupp attribute.", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, enabled %s",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type),
+ (attr_p->attr.silencesupp.enabled ? "on" : "off"));
+ if (attr_p->attr.silencesupp.timer_null) {
+ SDP_PRINT(" timer=-");
+ } else {
+ SDP_PRINT(" timer=%u,", attr_p->attr.silencesupp.timer);
+ }
+ SDP_PRINT(" pref=%s, siduse=%s,",
+ sdp_get_silencesupp_pref_name(attr_p->attr.silencesupp.pref),
+ sdp_get_silencesupp_siduse_name(
+ attr_p->attr.silencesupp.siduse));
+ if (attr_p->attr.silencesupp.fxnslevel_null) {
+ SDP_PRINT(" fxnslevel=-");
+ } else {
+ SDP_PRINT(" fxnslevel=%u,", attr_p->attr.silencesupp.fxnslevel);
+ }
+ }
+
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_attr_silencesupp (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ char temp_timer_string[11];
+ char temp_fxnslevel_string[11];
+
+ if (attr_p->attr.silencesupp.timer_null) {
+ snprintf(temp_timer_string, sizeof(temp_timer_string), "-");
+ } else {
+ snprintf(temp_timer_string, sizeof(temp_timer_string), "%u", attr_p->attr.silencesupp.timer);
+ }
+
+ if (attr_p->attr.silencesupp.fxnslevel_null) {
+ snprintf(temp_fxnslevel_string, sizeof(temp_fxnslevel_string), "-");
+ } else {
+ snprintf(temp_fxnslevel_string, sizeof(temp_fxnslevel_string), "%u", attr_p->attr.silencesupp.fxnslevel);
+ }
+
+ flex_string_sprintf(fs, "a=%s:%s %s %s %s %s\r\n",
+ sdp_attr[attr_p->type].name,
+ (attr_p->attr.silencesupp.enabled ? "on" : "off"),
+ temp_timer_string,
+ sdp_get_silencesupp_pref_name(attr_p->attr.silencesupp.pref),
+ sdp_get_silencesupp_siduse_name(attr_p->attr.silencesupp.siduse),
+ temp_fxnslevel_string);
+
+ return SDP_SUCCESS;
+}
+
+/*
+ * sdp_parse_context_crypto_suite
+ *
+ * This routine parses the crypto suite pointed to by str, stores the crypto suite value into the
+ * srtp context suite component of the LocalConnectionOptions pointed to by lco_node_ptr and stores
+ * pointer to the next crypto parameter in tmp_ptr
+ */
+tinybool sdp_parse_context_crypto_suite(char * str, sdp_attr_t *attr_p, sdp_t *sdp_p) {
+ /*
+ * Three crypto_suites are defined: (Notice no SPACE between "crypto:" and the <crypto-suite>
+ * AES_CM_128_HMAC_SHA1_80
+ * AES_CM_128_HMAC_SHA1_32
+ * F8_128_HMAC_SHA1_80
+ */
+
+ int i;
+
+ /* Check crypto suites */
+ for(i=0; i<SDP_SRTP_MAX_NUM_CRYPTO_SUITES; i++) {
+ if (!cpr_strcasecmp(sdp_srtp_crypto_suite_array[i].crypto_suite_str, str)) {
+ attr_p->attr.srtp_context.suite = sdp_srtp_crypto_suite_array[i].crypto_suite_val;
+ attr_p->attr.srtp_context.master_key_size_bytes =
+ sdp_srtp_crypto_suite_array[i].key_size_bytes;
+ attr_p->attr.srtp_context.master_salt_size_bytes =
+ sdp_srtp_crypto_suite_array[i].salt_size_bytes;
+ return TRUE; /* There is a succesful match so exit */
+ }
+ }
+ /* couldn't find a matching crypto suite */
+ sdp_parse_error(sdp_p,
+ "%s No Matching crypto suite for SRTP Context(%s)-'X-crypto:v1' expected",
+ sdp_p->debug_str, str);
+
+ return FALSE;
+}
+
+
+sdp_result_e sdp_build_attr_srtpcontext (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+#define MAX_BASE64_ENCODE_SIZE_BYTES 60
+ int output_len = MAX_BASE64_ENCODE_SIZE_BYTES;
+ int key_size = attr_p->attr.srtp_context.master_key_size_bytes;
+ int salt_size = attr_p->attr.srtp_context.master_salt_size_bytes;
+ unsigned char base64_encoded_data[MAX_BASE64_ENCODE_SIZE_BYTES];
+ unsigned char base64_encoded_input[MAX_BASE64_ENCODE_SIZE_BYTES];
+ base64_result_t status;
+
+ output_len = MAX_BASE64_ENCODE_SIZE_BYTES;
+
+ /* Append master and salt keys */
+ memcpy(base64_encoded_input,
+ attr_p->attr.srtp_context.master_key,
+ key_size );
+ memcpy(base64_encoded_input + key_size,
+ attr_p->attr.srtp_context.master_salt,
+ salt_size );
+
+ if ((status = base64_encode(base64_encoded_input, key_size + salt_size,
+ base64_encoded_data, &output_len)) != BASE64_SUCCESS) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Error: Failure to Base64 Encoded data (%s) ",
+ sdp_p->debug_str, BASE64_RESULT_TO_STRING(status));
+ }
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ *(base64_encoded_data + output_len) = '\0';
+
+ flex_string_sprintf(fs, "a=%s:%s inline:%s||\r\n",
+ sdp_attr[attr_p->type].name,
+ sdp_srtp_context_crypto_suite[attr_p->attr.srtp_context.suite].name,
+ base64_encoded_data);
+
+ return SDP_SUCCESS;
+}
+
+/*
+ * sdp_parse_attr_mptime
+ * This function parses the a=mptime sdp line. This parameter consists of
+ * one or more numbers or hyphens ("-"). The first parameter must be a
+ * number. The number of parameters must match the number of formats specified
+ * on the m= line. This function is liberal in that it does not match against
+ * the m= line or require a number for the first parameter.
+ */
+sdp_result_e sdp_parse_attr_mptime (
+ sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ uint16_t i; /* loop counter for parameters */
+ sdp_result_e result; /* value returned by this function */
+ tinybool null_ind; /* true if a parameter is "-" */
+
+ /*
+ * Scan the input line up to the maximum number of parameters supported.
+ * Look for numbers or hyphens and store the resulting values. Hyphens
+ * are stored as zeros.
+ */
+ for (i=0; i<SDP_MAX_PAYLOAD_TYPES; i++) {
+ attr_p->attr.mptime.intervals[i] =
+ (ushort)sdp_getnextnumtok_or_null(ptr,&ptr," \t",&null_ind,&result);
+ if (result != SDP_SUCCESS) {
+ break;
+ }
+ attr_p->attr.mptime.num_intervals++;
+ }
+
+ /*
+ * At least one parameter must be supplied. If not, return an error
+ * and optionally log the failure.
+ */
+ if (attr_p->attr.mptime.num_intervals == 0) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No intervals specified for %s attr.",
+ sdp_p->debug_str, sdp_attr[attr_p->type].name);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /*
+ * Here is some debugging code that helps us track what data
+ * is received and parsed.
+ */
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, num intervals %u, intervals: ",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type),
+ attr_p->attr.mptime.num_intervals);
+ for (i=0; i < attr_p->attr.mptime.num_intervals; i++) {
+ SDP_PRINT("%u ", attr_p->attr.mptime.intervals[i]);
+ }
+ }
+
+ return SDP_SUCCESS;
+}
+
+/*
+ * sdp_build_attr_mptime
+ * This function builds the a=mptime sdp line. It reads the selected attribute
+ * from the sdp structure. Parameters with a value of zero are replaced by
+ * hyphens.
+ */
+sdp_result_e sdp_build_attr_mptime (
+ sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ int i;
+
+ flex_string_sprintf(fs, "a=%s:", sdp_attr[attr_p->type].name);
+
+ /*
+ * Run the list of mptime parameter values and write each one
+ * to the sdp line. Replace zeros with hyphens.
+ */
+ for (i=0; i < attr_p->attr.mptime.num_intervals; i++) {
+ if (i > 0) {
+ flex_string_append(fs, " ");
+ }
+
+ if (attr_p->attr.mptime.intervals[i] == 0) {
+ flex_string_append(fs, "-");
+ } else {
+ flex_string_sprintf(fs, "%u", attr_p->attr.mptime.intervals[i]);
+ }
+ }
+
+ flex_string_append(fs, "\r\n");
+
+ return SDP_SUCCESS;
+}
+
+
+
+sdp_result_e sdp_parse_attr_x_sidin (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ sdp_result_e result;
+ attr_p->attr.stream_data.x_sidin[0] = '\0';
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsing a=%s", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type));
+ }
+
+ /* Find the X-sidin value */
+ ptr = sdp_getnextstrtok(ptr, attr_p->attr.stream_data.x_sidin,
+ sizeof(attr_p->attr.stream_data.x_sidin), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No Stream Id incoming specified for X-sidin attribute.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, %s", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type),
+ attr_p->attr.stream_data.x_sidin);
+ }
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_attr_x_sidin (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ flex_string_sprintf(fs, "a=%s:%s\r\n",
+ sdp_attr[attr_p->type].name,
+ attr_p->attr.stream_data.x_sidin);
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_x_sidout (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ sdp_result_e result;
+ attr_p->attr.stream_data.x_sidout[0] = '\0';
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsing a=%s", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type));
+ }
+
+ /* Find the X-sidout value */
+ ptr = sdp_getnextstrtok(ptr, attr_p->attr.stream_data.x_sidout,
+ sizeof(attr_p->attr.stream_data.x_sidout), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No Stream Id outgoing specified for X-sidout attribute.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, %s", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type),
+ attr_p->attr.stream_data.x_sidout);
+ }
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_attr_x_sidout (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ flex_string_sprintf(fs, "a=%s:%s\r\n",
+ sdp_attr[attr_p->type].name,
+ attr_p->attr.stream_data.x_sidout);
+
+ return SDP_SUCCESS;
+}
+
+
+sdp_result_e sdp_parse_attr_x_confid (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ sdp_result_e result;
+ attr_p->attr.stream_data.x_confid[0] = '\0';
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsing a=%s", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type));
+ }
+
+ /* Find the X-confid value */
+ ptr = sdp_getnextstrtok(ptr, attr_p->attr.stream_data.x_confid,
+ sizeof(attr_p->attr.stream_data.x_confid), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No Conf Id incoming specified for "
+ "X-confid attribute.", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, %s", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type),
+ attr_p->attr.stream_data.x_confid);
+ }
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_attr_x_confid (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ if (strlen(attr_p->attr.stream_data.x_confid) <= 0) {
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s X-confid value is not set. Cannot build a=X-confid line\n",
+ sdp_p->debug_str);
+ }
+
+ return SDP_INVALID_PARAMETER;
+ }
+
+ flex_string_sprintf(fs, "a=%s:%s\r\n",
+ sdp_attr[attr_p->type].name,
+ attr_p->attr.stream_data.x_confid);
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_group (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ sdp_result_e result;
+ char tmp[64];
+ int i=0;
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsing a=%s", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type));
+ }
+
+ /* Find the a=group:<attrib> <id1> < id2> ... values */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No group attribute value specified for "
+ "a=group line", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ attr_p->attr.stream_data.group_attr = SDP_GROUP_ATTR_UNSUPPORTED;
+ for (i=0; i < SDP_MAX_GROUP_ATTR_VAL; i++) {
+ if (cpr_strncasecmp(tmp, sdp_group_attr_val[i].name,
+ sdp_group_attr_val[i].strlen) == 0) {
+ attr_p->attr.stream_data.group_attr = (sdp_group_attr_e)i;
+ break;
+ }
+ }
+
+ if (attr_p->attr.stream_data.group_attr == SDP_GROUP_ATTR_UNSUPPORTED) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Group attribute type unsupported (%s).",
+ sdp_p->debug_str, tmp);
+ }
+
+
+ /*
+ * Scan the input line up after group:<attr> to the maximum number
+ * of id available.
+ */
+ attr_p->attr.stream_data.num_group_id =0;
+
+ for (i=0; i<SDP_MAX_MEDIA_STREAMS; i++) {
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+
+ if (result != SDP_SUCCESS) {
+ break;
+ }
+ attr_p->attr.stream_data.group_ids[i] = cpr_strdup(tmp);
+ if (!attr_p->attr.stream_data.group_ids[i]) {
+ break;
+ }
+
+ attr_p->attr.stream_data.num_group_id++;
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s:%s\n", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type),
+ sdp_get_group_attr_name (attr_p->attr.stream_data.group_attr));
+ for (i=0; i < attr_p->attr.stream_data.num_group_id; i++) {
+ SDP_PRINT("%s Parsed group line id : %s\n", sdp_p->debug_str,
+ attr_p->attr.stream_data.group_ids[i]);
+ }
+ }
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_attr_group (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ int i;
+
+ flex_string_sprintf(fs, "a=%s:%s",
+ sdp_attr[attr_p->type].name,
+ sdp_get_group_attr_name(attr_p->attr.stream_data.group_attr));
+
+ for (i=0; i < attr_p->attr.stream_data.num_group_id; i++) {
+ if (attr_p->attr.stream_data.group_ids[i]) {
+ flex_string_sprintf(fs, " %s",
+ attr_p->attr.stream_data.group_ids[i]);
+ }
+ }
+
+ flex_string_append(fs, "\r\n");
+
+ return SDP_SUCCESS;
+}
+
+/* Parse the source-filter attribute
+ * "a=source-filter:<filter-mode><filter-spec>"
+ * <filter-spec> = <nettype><addrtype><dest-addr><src_addr><src_addr>...
+ */
+sdp_result_e sdp_parse_attr_source_filter (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ int i;
+ sdp_result_e result;
+ char tmp[SDP_MAX_STRING_LEN];
+
+ attr_p->attr.source_filter.mode = SDP_FILTER_MODE_NOT_PRESENT;
+ attr_p->attr.source_filter.nettype = SDP_NT_UNSUPPORTED;
+ attr_p->attr.source_filter.addrtype = SDP_AT_UNSUPPORTED;
+ attr_p->attr.source_filter.dest_addr[0] = '\0';
+ attr_p->attr.source_filter.num_src_addr = 0;
+
+ /* Find the filter mode */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No src filter attribute value specified for "
+ "a=source-filter line", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ for (i = 0; i < SDP_MAX_FILTER_MODE; i++) {
+ if (cpr_strncasecmp(tmp, sdp_src_filter_mode_val[i].name,
+ sdp_src_filter_mode_val[i].strlen) == 0) {
+ attr_p->attr.source_filter.mode = (sdp_src_filter_mode_e)i;
+ break;
+ }
+ }
+ if (attr_p->attr.source_filter.mode == SDP_FILTER_MODE_NOT_PRESENT) {
+ /* No point continuing */
+ sdp_parse_error(sdp_p,
+ "%s Warning: Invalid src filter mode for a=source-filter "
+ "line", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Find the network type */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ for (i = 0; i < SDP_MAX_NETWORK_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_nettype[i].name,
+ sdp_nettype[i].strlen) == 0) {
+ if (sdp_p->conf_p->nettype_supported[i] == TRUE) {
+ attr_p->attr.source_filter.nettype = (sdp_nettype_e)i;
+ }
+ }
+ }
+ if (attr_p->attr.source_filter.nettype == SDP_NT_UNSUPPORTED) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Network type unsupported "
+ "(%s) for a=source-filter", sdp_p->debug_str, tmp);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Find the address type */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ for (i = 0; i < SDP_MAX_ADDR_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_addrtype[i].name,
+ sdp_addrtype[i].strlen) == 0) {
+ if (sdp_p->conf_p->addrtype_supported[i] == TRUE) {
+ attr_p->attr.source_filter.addrtype = (sdp_addrtype_e)i;
+ }
+ }
+ }
+ if (attr_p->attr.source_filter.addrtype == SDP_AT_UNSUPPORTED) {
+ if (strncmp(tmp, "*", 1) == 0) {
+ attr_p->attr.source_filter.addrtype = SDP_AT_FQDN;
+ } else {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Address type unsupported "
+ "(%s) for a=source-filter", sdp_p->debug_str, tmp);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ }
+
+ /* Find the destination addr */
+ ptr = sdp_getnextstrtok(ptr, attr_p->attr.source_filter.dest_addr,
+ sizeof(attr_p->attr.source_filter.dest_addr), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s No filter destination address specified for "
+ "a=source-filter", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Find the list of source address to apply the filter */
+ for (i = 0; i < SDP_MAX_SRC_ADDR_LIST; i++) {
+ ptr = sdp_getnextstrtok(ptr, attr_p->attr.source_filter.src_list[i],
+ sizeof(attr_p->attr.source_filter.src_list[i]), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ break;
+ }
+ attr_p->attr.source_filter.num_src_addr++;
+ }
+ if (attr_p->attr.source_filter.num_src_addr == 0) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No source list provided "
+ "for a=source-filter", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_source_filter (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ int i;
+
+ flex_string_sprintf(fs, "a=%s:%s %s %s %s",
+ sdp_get_attr_name(attr_p->type),
+ sdp_get_src_filter_mode_name(attr_p->attr.source_filter.mode),
+ sdp_get_network_name(attr_p->attr.source_filter.nettype),
+ sdp_get_address_name(attr_p->attr.source_filter.addrtype),
+ attr_p->attr.source_filter.dest_addr);
+
+ for (i = 0; i < attr_p->attr.source_filter.num_src_addr; i++) {
+ flex_string_append(fs, " ");
+ flex_string_append(fs, attr_p->attr.source_filter.src_list[i]);
+ }
+
+ flex_string_append(fs, "\r\n");
+
+ return SDP_SUCCESS;
+}
+
+/* Parse the rtcp-unicast attribute
+ * "a=rtcp-unicast:<reflection|rsi>"
+ */
+sdp_result_e sdp_parse_attr_rtcp_unicast (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ sdp_result_e result;
+ uint32_t i;
+ char tmp[SDP_MAX_STRING_LEN];
+
+ attr_p->attr.u32_val = SDP_RTCP_UNICAST_MODE_NOT_PRESENT;
+
+ memset(tmp, 0, sizeof(tmp));
+
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No rtcp unicast mode specified for "
+ "a=rtcp-unicast line", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ for (i = 0; i < SDP_RTCP_MAX_UNICAST_MODE; i++) {
+ if (cpr_strncasecmp(tmp, sdp_rtcp_unicast_mode_val[i].name,
+ sdp_rtcp_unicast_mode_val[i].strlen) == 0) {
+ attr_p->attr.u32_val = i;
+ break;
+ }
+ }
+ if (attr_p->attr.u32_val == SDP_RTCP_UNICAST_MODE_NOT_PRESENT) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Invalid rtcp unicast mode for "
+ "a=rtcp-unicast line", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_attr_rtcp_unicast (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ if (attr_p->attr.u32_val >= SDP_RTCP_MAX_UNICAST_MODE) {
+ return SDP_INVALID_PARAMETER;
+ }
+
+ flex_string_sprintf(fs, "a=%s:%s\r\n",
+ sdp_get_attr_name(attr_p->type),
+ sdp_get_rtcp_unicast_mode_name((sdp_rtcp_unicast_mode_e)attr_p->attr.u32_val));
+
+ return SDP_SUCCESS;
+}
+
+
+/*
+ * store_sdescriptions_mki_or_lifetime
+ *
+ * Verifies the syntax of the MKI or lifetime parameter and stores
+ * it in the sdescriptions attribute struct.
+ *
+ * Inputs:
+ * buf - pointer to MKI or lifetime string assumes string is null
+ * terminated.
+ * attr_p - pointer to attribute struct
+ *
+ * Outputs:
+ * Return TRUE all is good otherwise FALSE for error.
+ */
+
+tinybool
+store_sdescriptions_mki_or_lifetime (char *buf, sdp_attr_t *attr_p)
+{
+
+ tinybool result;
+ uint16_t mkiLen;
+ char mkiValue[SDP_SRTP_MAX_MKI_SIZE_BYTES];
+
+ /* MKI has a colon */
+ if (strstr(buf, ":")) {
+ result = verify_sdescriptions_mki(buf, mkiValue, &mkiLen);
+ if (result) {
+ attr_p->attr.srtp_context.mki_size_bytes = mkiLen;
+ sstrncpy((char*)attr_p->attr.srtp_context.mki, mkiValue,
+ SDP_SRTP_MAX_MKI_SIZE_BYTES);
+ }
+
+ } else {
+ result = verify_sdescriptions_lifetime(buf);
+ if (result) {
+ sstrncpy((char*)attr_p->attr.srtp_context.master_key_lifetime, buf,
+ SDP_SRTP_MAX_LIFETIME_BYTES);
+ }
+ }
+
+ return result;
+
+}
+
+/*
+ * sdp_parse_sdescriptions_key_param
+ *
+ * This routine parses the srtp key-params pointed to by str.
+ *
+ * key-params = <key-method> ":" <key-info>
+ * key-method = "inline" / key-method-ext [note V9 only supports 'inline']
+ * key-info = srtp-key-info
+ * srtp-key-info = key-salt ["|" lifetime] ["|" mki]
+ * key-salt = 1*(base64) ; binary key and salt values
+ * ; concatenated together, and then
+ * ; base64 encoded [section 6.8 of
+ * ; RFC2046]
+ *
+ * lifetime = ["2^"] 1*(DIGIT)
+ * mki = mki-value ":" mki-length
+ * mki-value = 1*DIGIT
+ * mki-length = 1*3DIGIT ; range 1..128.
+ *
+ * Inputs: str - pointer to beginning of key-params and assumes
+ * null terminated string.
+ */
+
+
+tinybool
+sdp_parse_sdescriptions_key_param (const char *str, sdp_attr_t *attr_p,
+ sdp_t *sdp_p)
+{
+ char buf[SDP_MAX_STRING_LEN],
+ base64decodeData[SDP_MAX_STRING_LEN];
+ const char *ptr;
+ sdp_result_e result = SDP_SUCCESS;
+ tinybool keyFound = FALSE;
+ int len,
+ keySize,
+ saltSize;
+ base64_result_t status;
+
+ ptr = str;
+ if (cpr_strncasecmp(ptr, "inline:", 7) != 0) {
+ sdp_parse_error(sdp_p,
+ "%s Could not find keyword inline", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return FALSE;
+ }
+
+ /* advance pass the inline key word */
+ ptr = ptr + 7;
+ ptr = sdp_getnextstrtok(ptr, buf, sizeof(buf), "|", &result);
+ while (result == SDP_SUCCESS) {
+ /* the fist time this loop executes, the key is gotten */
+ if (keyFound == FALSE) {
+ keyFound = TRUE;
+ len = SDP_MAX_STRING_LEN;
+ /* The key is base64 encoded composed of the master key concatenated with the
+ * master salt.
+ */
+ status = base64_decode((unsigned char *)buf, strlen(buf),
+ (unsigned char *)base64decodeData, &len);
+
+ if (status != BASE64_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s key-salt error decoding buffer: %s",
+ sdp_p->debug_str, BASE64_RESULT_TO_STRING(status));
+ return FALSE;
+ }
+
+ keySize = attr_p->attr.srtp_context.master_key_size_bytes;
+ saltSize = attr_p->attr.srtp_context.master_salt_size_bytes;
+
+ if (len != keySize + saltSize) {
+ sdp_parse_error(sdp_p,
+ "%s key-salt size doesn't match: (%d, %d, %d)",
+ sdp_p->debug_str, len, keySize, saltSize);
+ return(FALSE);
+ }
+
+ memcpy(attr_p->attr.srtp_context.master_key,
+ base64decodeData,
+ keySize);
+
+ memcpy(attr_p->attr.srtp_context.master_salt,
+ base64decodeData + keySize,
+ saltSize);
+
+ /* Used only for MGCP */
+ SDP_SRTP_CONTEXT_SET_MASTER_KEY
+ (attr_p->attr.srtp_context.selection_flags);
+ SDP_SRTP_CONTEXT_SET_MASTER_SALT
+ (attr_p->attr.srtp_context.selection_flags);
+
+ } else if (store_sdescriptions_mki_or_lifetime(buf, attr_p) == FALSE) {
+ return FALSE;
+ }
+
+ /* if we haven't reached the end of line, get the next token */
+ ptr = sdp_getnextstrtok(ptr, buf, sizeof(buf), "|", &result);
+ }
+
+ /* if we didn't find the key, error out */
+ if (keyFound == FALSE) {
+ sdp_parse_error(sdp_p,
+ "%s Could not find sdescriptions key", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return FALSE;
+ }
+
+ return TRUE;
+
+}
+
+/*
+ * sdp_build_attr_sdescriptions
+ *
+ * Builds a=crypto line for attribute type SDP_ATTR_SDESCRIPTIONS.
+ *
+ * a=crypto:tag 1*WSP crypto-suite 1*WSP key-params
+ *
+ * Where key-params = inline: <key|salt> ["|"lifetime] ["|" MKI:length]
+ * The key and salt is base64 encoded and lifetime and MKI/length are optional.
+ */
+
+sdp_result_e
+sdp_build_attr_sdescriptions (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+
+ unsigned char base64_encoded_data[MAX_BASE64_STRING_LEN];
+ unsigned char base64_encoded_input[MAX_BASE64_STRING_LEN];
+ int keySize,
+ saltSize,
+ outputLen;
+ base64_result_t status;
+
+ keySize = attr_p->attr.srtp_context.master_key_size_bytes;
+ saltSize = attr_p->attr.srtp_context.master_salt_size_bytes;
+
+ /* concatenate the master key + salt then base64 encode it */
+ memcpy(base64_encoded_input,
+ attr_p->attr.srtp_context.master_key,
+ keySize);
+
+ memcpy(base64_encoded_input + keySize,
+ attr_p->attr.srtp_context.master_salt,
+ saltSize);
+
+ outputLen = MAX_BASE64_STRING_LEN;
+ status = base64_encode(base64_encoded_input, keySize + saltSize,
+ base64_encoded_data, &outputLen);
+
+ if (status != BASE64_SUCCESS) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Error: Failure to Base64 Encoded data (%s) ",
+ sdp_p->debug_str, BASE64_RESULT_TO_STRING(status));
+ }
+ return (SDP_INVALID_PARAMETER);
+
+ }
+
+ base64_encoded_data[outputLen] = 0;
+
+ /* lifetime and MKI parameters are optional. Only inlcude them if
+ * they were set.
+ */
+
+
+ if (attr_p->attr.srtp_context.master_key_lifetime[0] != 0 &&
+ attr_p->attr.srtp_context.mki[0] != 0) {
+ flex_string_sprintf(fs, "a=%s:%d %s inline:%s|%s|%s:%d\r\n",
+ sdp_attr[attr_p->type].name,
+ attr_p->attr.srtp_context.tag,
+ sdp_srtp_context_crypto_suite[attr_p->attr.srtp_context.suite].name,
+ base64_encoded_data,
+ attr_p->attr.srtp_context.master_key_lifetime,
+ attr_p->attr.srtp_context.mki,
+ attr_p->attr.srtp_context.mki_size_bytes);
+
+ return SDP_SUCCESS;
+ }
+
+ /* if we get here, either lifetime is populated and mki and is not or mki is populated
+ * and lifetime is not or neither is populated
+ */
+
+ if (attr_p->attr.srtp_context.master_key_lifetime[0] != 0) {
+ flex_string_sprintf(fs, "a=%s:%d %s inline:%s|%s\r\n",
+ sdp_attr[attr_p->type].name,
+ attr_p->attr.srtp_context.tag,
+ sdp_srtp_context_crypto_suite[attr_p->attr.srtp_context.suite].name,
+ base64_encoded_data,
+ attr_p->attr.srtp_context.master_key_lifetime);
+
+ } else if (attr_p->attr.srtp_context.mki[0] != 0) {
+ flex_string_sprintf(fs, "a=%s:%d %s inline:%s|%s:%d\r\n",
+ sdp_attr[attr_p->type].name,
+ attr_p->attr.srtp_context.tag,
+ sdp_srtp_context_crypto_suite[attr_p->attr.srtp_context.suite].name,
+ base64_encoded_data,
+ attr_p->attr.srtp_context.mki,
+ attr_p->attr.srtp_context.mki_size_bytes);
+
+ } else {
+ flex_string_sprintf(fs, "a=%s:%d %s inline:%s\r\n",
+ sdp_attr[attr_p->type].name,
+ attr_p->attr.srtp_context.tag,
+ sdp_srtp_context_crypto_suite[attr_p->attr.srtp_context.suite].name,
+ base64_encoded_data);
+
+ }
+
+ return SDP_SUCCESS;
+
+}
+
+
+/*
+ * sdp_parse_attr_srtp
+ *
+ * Parses Session Description for Protocol Security Descriptions
+ * version 2 or version 9. Grammar is of the form:
+ *
+ * a=crypto:<tag> <crypto-suite> <key-params> [<session-params>]
+ *
+ * Note session-params is not supported and will not be parsed.
+ * Version 2 does not contain a tag.
+ *
+ * Inputs:
+ * sdp_p - pointer to sdp handle
+ * attr_p - pointer to attribute structure
+ * ptr - pointer to string to be parsed
+ * vtype - version type
+ */
+
+sdp_result_e
+sdp_parse_attr_srtp (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr, sdp_attr_e vtype)
+{
+
+ char tmp[SDP_MAX_STRING_LEN];
+ sdp_result_e result = SDP_FAILURE;
+ int k = 0;
+
+ /* initialize only the optional parameters */
+ attr_p->attr.srtp_context.master_key_lifetime[0] = 0;
+ attr_p->attr.srtp_context.mki[0] = 0;
+
+ /* used only for MGCP */
+ SDP_SRTP_CONTEXT_SET_ENCRYPT_AUTHENTICATE
+ (attr_p->attr.srtp_context.selection_flags);
+
+ /* get the tag only if we are version 9 */
+ if (vtype == SDP_ATTR_SDESCRIPTIONS) {
+ attr_p->attr.srtp_context.tag =
+ sdp_getnextnumtok(ptr, &ptr, " \t", &result);
+
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Could not find sdescriptions tag",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+
+ }
+ }
+
+ /* get the crypto suite */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Could not find sdescriptions crypto suite", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ if (!sdp_parse_context_crypto_suite(tmp, attr_p, sdp_p)) {
+ sdp_parse_error(sdp_p,
+ "%s Unsupported crypto suite", sdp_p->debug_str);
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Could not find sdescriptions key params", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ if (!sdp_parse_sdescriptions_key_param(tmp, attr_p, sdp_p)) {
+ sdp_parse_error(sdp_p,
+ "%s Failed to parse key-params", sdp_p->debug_str);
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* if there are session parameters, scan the session parameters
+ * into tmp until we reach end of line. Currently the sdp parser
+ * does not parse session parameters but if they are present,
+ * we store them for the application.
+ */
+ /*sa_ignore NO_NULL_CHK
+ *{ptr is valid since the pointer was checked earlier and the
+ * function would have exited if NULL.}
+ */
+ while (*ptr && *ptr != '\n' && *ptr != '\r' && k < SDP_MAX_STRING_LEN) {
+ tmp[k++] = *ptr++;
+ }
+
+ if ((k) && (k < SDP_MAX_STRING_LEN)) {
+ tmp[k] = 0;
+ attr_p->attr.srtp_context.session_parameters = cpr_strdup(tmp);
+ }
+
+ return SDP_SUCCESS;
+
+}
+
+/* Parses crypto attribute based on the sdescriptions version
+ * 9 grammar.
+ *
+ */
+
+sdp_result_e
+sdp_parse_attr_sdescriptions (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+
+ return sdp_parse_attr_srtp(sdp_p, attr_p, ptr,
+ SDP_ATTR_SDESCRIPTIONS);
+
+}
+
+/* Parses X-crypto attribute based on the sdescriptions version
+ * 2 grammar.
+ *
+ */
+
+sdp_result_e sdp_parse_attr_srtpcontext (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+
+ return sdp_parse_attr_srtp(sdp_p, attr_p, ptr,
+ SDP_ATTR_SRTP_CONTEXT);
+}
+
+
+sdp_result_e sdp_build_attr_ice_attr (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs) {
+ flex_string_sprintf(fs, "a=%s:%s\r\n",
+ sdp_get_attr_name(attr_p->type),
+ attr_p->attr.ice_attr);
+
+ return SDP_SUCCESS;
+}
+
+
+sdp_result_e sdp_parse_attr_ice_attr (sdp_t *sdp_p, sdp_attr_t *attr_p, const char *ptr) {
+ sdp_result_e result;
+ char tmp[SDP_MAX_STRING_LEN];
+
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), "\r\n", &result);
+ if (result != SDP_SUCCESS){
+ sdp_parse_error(sdp_p,
+ "%s Warning: problem parsing ice attribute ", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ snprintf(attr_p->attr.ice_attr, sizeof(attr_p->attr.ice_attr), "%s", tmp);
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, %s", sdp_p->debug_str, sdp_get_attr_name(attr_p->type), tmp);
+ }
+ return (SDP_SUCCESS);
+}
+
+
+sdp_result_e sdp_build_attr_simple_flag (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs) {
+ flex_string_sprintf(fs, "a=%s\r\n", sdp_get_attr_name(attr_p->type));
+
+ return SDP_SUCCESS;
+}
+
+
+sdp_result_e sdp_parse_attr_simple_flag (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr) {
+ /* No parameters to parse. */
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type));
+ }
+
+ return (SDP_SUCCESS);
+}
+
+static sdp_result_e sdp_parse_attr_line(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr, char *buf, size_t buf_len) {
+ sdp_result_e result;
+
+ (void)sdp_getnextstrtok(ptr, buf, buf_len, "\r\n", &result);
+
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No string token found for %s attribute",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type));
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, %s", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type),
+ buf);
+ }
+ return (SDP_SUCCESS);
+ }
+}
+
+sdp_result_e sdp_parse_attr_complete_line (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ return sdp_parse_attr_line(sdp_p, attr_p, ptr,
+ attr_p->attr.string_val,
+ sizeof(attr_p->attr.string_val));
+}
+
+sdp_result_e sdp_parse_attr_long_line (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ sdp_result_e result;
+ char buffer[SDP_MAX_LONG_STRING_LEN];
+
+ result = sdp_parse_attr_line(sdp_p, attr_p, ptr,
+ buffer, sizeof(buffer));
+ if (result == SDP_SUCCESS) {
+ attr_p->attr.stringp = cpr_strdup(buffer);
+ }
+ return result;
+}
+
+sdp_result_e sdp_build_attr_long_line (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ flex_string_sprintf(fs, "a=%s:%s\r\n", sdp_attr[attr_p->type].name,
+ attr_p->attr.stringp);
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_build_attr_rtcp_fb(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ flex_string_sprintf(fs, "a=%s:", sdp_attr[attr_p->type].name);
+
+ /* Payload Type */
+ if (attr_p->attr.rtcp_fb.payload_num == SDP_ALL_PAYLOADS) {
+ flex_string_sprintf(fs, "* ");
+ } else {
+ flex_string_sprintf(fs, "%d ",attr_p->attr.rtcp_fb.payload_num);
+ }
+
+ /* Feedback Type */
+ if (attr_p->attr.rtcp_fb.feedback_type < SDP_RTCP_FB_UNKNOWN) {
+ flex_string_sprintf(fs, "%s",
+ sdp_rtcp_fb_type_val[attr_p->attr.rtcp_fb.feedback_type].name);
+ }
+
+ /* Feedback Type Parameters */
+ switch (attr_p->attr.rtcp_fb.feedback_type) {
+ case SDP_RTCP_FB_ACK:
+ if (attr_p->attr.rtcp_fb.param.ack < SDP_MAX_RTCP_FB_ACK) {
+ flex_string_sprintf(fs, " %s",
+ sdp_rtcp_fb_ack_type_val[attr_p->attr.rtcp_fb.param.ack]
+ .name);
+ }
+ break;
+ case SDP_RTCP_FB_CCM: /* RFC 5104 */
+ if (attr_p->attr.rtcp_fb.param.ccm < SDP_MAX_RTCP_FB_CCM) {
+ flex_string_sprintf(fs, " %s",
+ sdp_rtcp_fb_ccm_type_val[attr_p->attr.rtcp_fb.param.ccm]
+ .name);
+ }
+ break;
+ case SDP_RTCP_FB_NACK:
+ if (attr_p->attr.rtcp_fb.param.nack > SDP_RTCP_FB_NACK_BASIC
+ && attr_p->attr.rtcp_fb.param.nack < SDP_MAX_RTCP_FB_NACK) {
+ flex_string_sprintf(fs, " %s",
+ sdp_rtcp_fb_nack_type_val[attr_p->attr.rtcp_fb.param.nack]
+ .name);
+ }
+ break;
+ case SDP_RTCP_FB_TRR_INT:
+ flex_string_sprintf(fs, " %u", attr_p->attr.rtcp_fb.param.trr_int);
+ break;
+ case SDP_RTCP_FB_REMB:
+ /* No additional params after REMB */
+ break;
+
+ case SDP_RTCP_FB_UNKNOWN:
+ /* Contents are in the "extra" field */
+ break;
+
+ default:
+ CSFLogError(logTag, "%s Error: Invalid rtcp-fb enum (%d)",
+ sdp_p->debug_str, attr_p->attr.rtcp_fb.feedback_type);
+ return SDP_FAILURE;
+ }
+
+ /* Tack on any information that cannot otherwise be represented by
+ * the sdp_fmtp_fb_t structure. */
+ if (attr_p->attr.rtcp_fb.extra[0]) {
+ flex_string_sprintf(fs, " %s", attr_p->attr.rtcp_fb.extra);
+ }
+
+ /* Line ending */
+ flex_string_sprintf(fs, "\r\n");
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_rtcp_fb (sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ sdp_result_e result = SDP_SUCCESS;
+ sdp_fmtp_fb_t *rtcp_fb_p = &(attr_p->attr.rtcp_fb);
+ int i;
+
+ /* Set up attribute fields */
+ rtcp_fb_p->payload_num = 0;
+ rtcp_fb_p->feedback_type = SDP_RTCP_FB_UNKNOWN;
+ rtcp_fb_p->extra[0] = '\0';
+
+ /* Skip WS (just in case) */
+ while (*ptr == ' ' || *ptr == '\t') {
+ ptr++;
+ }
+
+ /* Look for the special "*" payload type */
+ if (*ptr == '*') {
+ rtcp_fb_p->payload_num = SDP_ALL_PAYLOADS;
+ ptr++;
+ } else {
+ /* If the pt is not '*', parse it out as an integer */
+ rtcp_fb_p->payload_num = (uint16_t)sdp_getnextnumtok(ptr, &ptr,
+ " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: could not parse payload type for rtcp-fb attribute",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+
+ return SDP_INVALID_PARAMETER;
+ }
+ }
+
+ /* Read feedback type */
+ i = find_token_enum("rtcp-fb attribute", sdp_p, &ptr, sdp_rtcp_fb_type_val,
+ SDP_MAX_RTCP_FB, SDP_RTCP_FB_UNKNOWN);
+ if (i < 0) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: could not parse feedback type for rtcp-fb attribute",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_INVALID_PARAMETER;
+ }
+ rtcp_fb_p->feedback_type = (sdp_rtcp_fb_type_e) i;
+
+ switch(rtcp_fb_p->feedback_type) {
+ case SDP_RTCP_FB_ACK:
+ i = find_token_enum("rtcp-fb ack type", sdp_p, &ptr,
+ sdp_rtcp_fb_ack_type_val,
+ SDP_MAX_RTCP_FB_ACK, SDP_RTCP_FB_ACK_UNKNOWN);
+ if (i < 0) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: could not parse ack type for rtcp-fb attribute",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_INVALID_PARAMETER;
+ }
+ rtcp_fb_p->param.ack = (sdp_rtcp_fb_ack_type_e) i;
+ break;
+
+ case SDP_RTCP_FB_CCM:
+ i = find_token_enum("rtcp-fb ccm type", sdp_p, &ptr,
+ sdp_rtcp_fb_ccm_type_val,
+ SDP_MAX_RTCP_FB_CCM, SDP_RTCP_FB_CCM_UNKNOWN);
+ if (i < 0) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: could not parse ccm type for rtcp-fb attribute",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_INVALID_PARAMETER;
+ }
+ rtcp_fb_p->param.ccm = (sdp_rtcp_fb_ccm_type_e) i;
+
+ /* TODO -- We don't currently parse tmmbr parameters or vbcm
+ submessage types. If we decide to support these modes of
+ operation, we probably want to add parsing code for them.
+ For the time being, they'll just end up parsed into "extra"
+ Bug 1097169.
+ */
+ break;
+
+ case SDP_RTCP_FB_NACK:
+ /* Skip any remaining WS -- see
+ http://code.google.com/p/webrtc/issues/detail?id=1922 */
+ while (*ptr == ' ' || *ptr == '\t') {
+ ptr++;
+ }
+ /* Check for empty string */
+ if (*ptr == '\r') {
+ rtcp_fb_p->param.nack = SDP_RTCP_FB_NACK_BASIC;
+ break;
+ }
+ i = find_token_enum("rtcp-fb nack type", sdp_p, &ptr,
+ sdp_rtcp_fb_nack_type_val,
+ SDP_MAX_RTCP_FB_NACK, SDP_RTCP_FB_NACK_UNKNOWN);
+ if (i < 0) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: could not parse nack type for rtcp-fb attribute",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_INVALID_PARAMETER;
+ }
+ rtcp_fb_p->param.nack = (sdp_rtcp_fb_nack_type_e) i;
+ break;
+
+ case SDP_RTCP_FB_TRR_INT:
+ rtcp_fb_p->param.trr_int = sdp_getnextnumtok(ptr, &ptr,
+ " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: could not parse trr-int value for rtcp-fb "
+ "attribute", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_INVALID_PARAMETER;
+ }
+ break;
+
+ case SDP_RTCP_FB_REMB:
+ /* No additional tokens to parse after goog-remb */
+ break;
+
+ case SDP_RTCP_FB_UNKNOWN:
+ /* Handled by "extra", below */
+ break;
+
+ default:
+ /* This is an internal error, not a parsing error */
+ CSFLogError(logTag, "%s Error: Invalid rtcp-fb enum (%d)",
+ sdp_p->debug_str, attr_p->attr.rtcp_fb.feedback_type);
+ return SDP_FAILURE;
+ }
+
+ /* Skip any remaining WS */
+ while (*ptr == ' ' || *ptr == '\t') {
+ ptr++;
+ }
+
+ /* Just store the rest of the line in "extra" -- this will return
+ a failure result if there is no more text, but that's fine. */
+ ptr = sdp_getnextstrtok(ptr, rtcp_fb_p->extra,
+ sizeof(rtcp_fb_p->extra), "\r\n", &result);
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_build_attr_setup(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ switch (attr_p->attr.setup) {
+ case SDP_SETUP_ACTIVE:
+ case SDP_SETUP_PASSIVE:
+ case SDP_SETUP_ACTPASS:
+ case SDP_SETUP_HOLDCONN:
+ flex_string_sprintf(fs, "a=%s:%s\r\n",
+ sdp_attr[attr_p->type].name,
+ sdp_setup_type_val[attr_p->attr.setup].name);
+ break;
+ default:
+ CSFLogError(logTag, "%s Error: Invalid setup enum (%d)",
+ sdp_p->debug_str, attr_p->attr.setup);
+ return SDP_FAILURE;
+ }
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_setup(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ int i = find_token_enum("setup attribute", sdp_p, &ptr,
+ sdp_setup_type_val,
+ SDP_MAX_SETUP, SDP_SETUP_UNKNOWN);
+
+ if (i < 0) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: could not parse setup attribute",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_INVALID_PARAMETER;
+ }
+
+ attr_p->attr.setup = (sdp_setup_type_e) i;
+
+ switch (attr_p->attr.setup) {
+ case SDP_SETUP_ACTIVE:
+ case SDP_SETUP_PASSIVE:
+ case SDP_SETUP_ACTPASS:
+ case SDP_SETUP_HOLDCONN:
+ /* All these values are OK */
+ break;
+ case SDP_SETUP_UNKNOWN:
+ sdp_parse_error(sdp_p,
+ "%s Warning: Unknown setup attribute",
+ sdp_p->debug_str);
+ return SDP_INVALID_PARAMETER;
+ default:
+ /* This is an internal error, not a parsing error */
+ CSFLogError(logTag, "%s Error: Invalid setup enum (%d)",
+ sdp_p->debug_str, attr_p->attr.setup);
+ return SDP_FAILURE;
+ }
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_build_attr_connection(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ switch (attr_p->attr.connection) {
+ case SDP_CONNECTION_NEW:
+ case SDP_CONNECTION_EXISTING:
+ flex_string_sprintf(fs, "a=%s:%s\r\n",
+ sdp_attr[attr_p->type].name,
+ sdp_connection_type_val[attr_p->attr.connection].name);
+ break;
+ default:
+ CSFLogError(logTag, "%s Error: Invalid connection enum (%d)",
+ sdp_p->debug_str, attr_p->attr.connection);
+ return SDP_FAILURE;
+ }
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_connection(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ int i = find_token_enum("connection attribute", sdp_p, &ptr,
+ sdp_connection_type_val,
+ SDP_MAX_CONNECTION, SDP_CONNECTION_UNKNOWN);
+
+ if (i < 0) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: could not parse connection attribute",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_INVALID_PARAMETER;
+ }
+
+ attr_p->attr.connection = (sdp_connection_type_e) i;
+
+ switch (attr_p->attr.connection) {
+ case SDP_CONNECTION_NEW:
+ case SDP_CONNECTION_EXISTING:
+ /* All these values are OK */
+ break;
+ case SDP_CONNECTION_UNKNOWN:
+ sdp_parse_error(sdp_p,
+ "%s Warning: Unknown connection attribute",
+ sdp_p->debug_str);
+ return SDP_INVALID_PARAMETER;
+ default:
+ /* This is an internal error, not a parsing error */
+ CSFLogError(logTag, "%s Error: Invalid connection enum (%d)",
+ sdp_p->debug_str, attr_p->attr.connection);
+ return SDP_FAILURE;
+ }
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_build_attr_extmap(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ flex_string_sprintf(fs, "a=extmap:%d %s\r\n",
+ attr_p->attr.extmap.id,
+ attr_p->attr.extmap.uri);
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_extmap(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ sdp_result_e result;
+
+ attr_p->attr.extmap.id = 0;
+ attr_p->attr.extmap.media_direction = SDP_DIRECTION_SENDRECV;
+ attr_p->attr.extmap.media_direction_specified = FALSE;
+ attr_p->attr.extmap.uri[0] = '\0';
+ attr_p->attr.extmap.extension_attributes[0] = '\0';
+
+ /* Find the payload type number. */
+ attr_p->attr.extmap.id =
+ (uint16_t)sdp_getnextnumtok(ptr, &ptr, "/ \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Invalid extmap id specified for %s attribute.",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type));
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ if (*ptr == '/') {
+ char direction[SDP_MAX_STRING_LEN+1];
+ ++ptr; /* Skip over '/' */
+ ptr = sdp_getnextstrtok(ptr, direction,
+ sizeof(direction), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Invalid direction specified in %s attribute.",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type));
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ if (!cpr_strcasecmp(direction, "sendrecv")) {
+ attr_p->attr.extmap.media_direction = SDP_DIRECTION_SENDRECV;
+ } else if (!cpr_strcasecmp(direction, "sendonly")) {
+ attr_p->attr.extmap.media_direction = SDP_DIRECTION_SENDONLY;
+ } else if (!cpr_strcasecmp(direction, "recvonly")) {
+ attr_p->attr.extmap.media_direction = SDP_DIRECTION_RECVONLY;
+ } else if (!cpr_strcasecmp(direction, "inactive")) {
+ attr_p->attr.extmap.media_direction = SDP_DIRECTION_INACTIVE;
+ } else {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Invalid direction specified in %s attribute.",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type));
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ attr_p->attr.extmap.media_direction_specified = TRUE;
+ }
+
+ ptr = sdp_getnextstrtok(ptr, attr_p->attr.extmap.uri,
+ sizeof(attr_p->attr.extmap.uri), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No uri specified in %s attribute.",
+ sdp_p->debug_str, sdp_get_attr_name(attr_p->type));
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ while (*ptr == ' ' || *ptr == '\t') {
+ ++ptr;
+ }
+
+ /* Grab everything that follows, even if it contains whitespace */
+ ptr = sdp_getnextstrtok(ptr, attr_p->attr.extmap.extension_attributes,
+ sizeof(attr_p->attr.extmap.extension_attributes), "\r\n", &result);
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=%s, id %u, direction %s, "
+ "uri %s, extension %s", sdp_p->debug_str,
+ sdp_get_attr_name(attr_p->type),
+ attr_p->attr.extmap.id,
+ SDP_DIRECTION_PRINT(attr_p->attr.extmap.media_direction),
+ attr_p->attr.extmap.uri,
+ attr_p->attr.extmap.extension_attributes);
+ }
+
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_parse_attr_msid(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ sdp_result_e result;
+
+ ptr = sdp_getnextstrtok(ptr, attr_p->attr.msid.identifier,
+ sizeof(attr_p->attr.msid.identifier), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p, "%s Warning: Bad msid identity value",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_INVALID_PARAMETER;
+ }
+
+ ptr = sdp_getnextstrtok(ptr, attr_p->attr.msid.appdata,
+ sizeof(attr_p->attr.msid.appdata), " \t", &result);
+ if ((result != SDP_SUCCESS) && (result != SDP_EMPTY_TOKEN)) {
+ sdp_parse_error(sdp_p, "%s Warning: Bad msid appdata value",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_INVALID_PARAMETER;
+ }
+ if (result == SDP_EMPTY_TOKEN) {
+ attr_p->attr.msid.appdata[0] = '\0';
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=msid, %s %s", sdp_p->debug_str,
+ attr_p->attr.msid.identifier, attr_p->attr.msid.appdata);
+ }
+
+ return SDP_SUCCESS;
+}
+
+
+sdp_result_e sdp_build_attr_msid(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ flex_string_sprintf(fs, "a=msid:%s%s%s\r\n",
+ attr_p->attr.msid.identifier,
+ attr_p->attr.msid.appdata[0] ? " " : "",
+ attr_p->attr.msid.appdata);
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_msid_semantic(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ sdp_result_e result;
+ int i;
+
+ ptr = sdp_getnextstrtok(ptr,
+ attr_p->attr.msid_semantic.semantic,
+ sizeof(attr_p->attr.msid_semantic.semantic),
+ " \t",
+ &result);
+
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p, "%s Warning: Bad msid-semantic attribute; "
+ "missing semantic",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_INVALID_PARAMETER;
+ }
+
+ for (i = 0; i < SDP_MAX_MEDIA_STREAMS; ++i) {
+ /* msid-id can be up to 64 characters long, plus null terminator */
+ char temp[65];
+ ptr = sdp_getnextstrtok(ptr, temp, sizeof(temp), " \t", &result);
+
+ if (result != SDP_SUCCESS) {
+ break;
+ }
+
+ attr_p->attr.msid_semantic.msids[i] = cpr_strdup(temp);
+ }
+
+ if ((result != SDP_SUCCESS) && (result != SDP_EMPTY_TOKEN)) {
+ sdp_parse_error(sdp_p, "%s Warning: Bad msid-semantic attribute",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_INVALID_PARAMETER;
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed a=msid-semantic, %s", sdp_p->debug_str,
+ attr_p->attr.msid_semantic.semantic);
+ for (i = 0; i < SDP_MAX_MEDIA_STREAMS; ++i) {
+ if (!attr_p->attr.msid_semantic.msids[i]) {
+ break;
+ }
+
+ SDP_PRINT("%s ... msid %s", sdp_p->debug_str,
+ attr_p->attr.msid_semantic.msids[i]);
+ }
+ }
+
+ return SDP_SUCCESS;
+}
+
+
+sdp_result_e sdp_build_attr_msid_semantic(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ int i;
+ flex_string_sprintf(fs, "a=msid-semantic:%s",
+ attr_p->attr.msid_semantic.semantic);
+ for (i = 0; i < SDP_MAX_MEDIA_STREAMS; ++i) {
+ if (!attr_p->attr.msid_semantic.msids[i]) {
+ break;
+ }
+
+ flex_string_sprintf(fs, " %s",
+ attr_p->attr.msid_semantic.msids[i]);
+ }
+ flex_string_sprintf(fs, "\r\n");
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_attr_ssrc(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ const char *ptr)
+{
+ sdp_result_e result;
+
+ attr_p->attr.ssrc.ssrc =
+ (uint32_t)sdp_getnextnumtok(ptr, &ptr, " \t", &result);
+
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p, "%s Warning: Bad ssrc attribute, cannot parse ssrc",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_INVALID_PARAMETER;
+ }
+
+ /* Skip any remaining WS */
+ while (*ptr == ' ' || *ptr == '\t') {
+ ptr++;
+ }
+
+ /* Just store the rest of the line in "attribute" -- this will return
+ a failure result if there is no more text, but that's fine. */
+ ptr = sdp_getnextstrtok(ptr,
+ attr_p->attr.ssrc.attribute,
+ sizeof(attr_p->attr.ssrc.attribute),
+ "\r\n",
+ &result);
+
+ return SDP_SUCCESS;
+}
+
+
+sdp_result_e sdp_build_attr_ssrc(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ flex_string *fs)
+{
+ flex_string_sprintf(fs, "a=ssrc:%s%s%s\r\n",
+ attr_p->attr.ssrc.ssrc,
+ attr_p->attr.ssrc.attribute[0] ? " " : "",
+ attr_p->attr.ssrc.attribute);
+ return SDP_SUCCESS;
+}
diff --git a/media/webrtc/signaling/src/sdp/sipcc/sdp_attr_access.c b/media/webrtc/signaling/src/sdp/sipcc/sdp_attr_access.c
new file mode 100644
index 000000000..0562e537e
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/sdp_attr_access.c
@@ -0,0 +1,6372 @@
+/* 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 "sdp_os_defs.h"
+#include "sdp.h"
+#include "sdp_private.h"
+
+#include "CSFLog.h"
+
+static const char* logTag = "sdp_attr_access";
+
+/* Attribute access routines are all defined by the following parameters.
+ *
+ * sdp_p The SDP handle returned by sdp_init_description.
+ * level The level the attribute is defined. Can be either
+ * SDP_SESSION_LEVEL or 0-n specifying a media line level.
+ * inst_num The instance number of the attribute. Multiple instances
+ * of a particular attribute may exist at each level and so
+ * the inst_num determines the particular attribute at that
+ * level that should be accessed. Note that this is the
+ * instance number of the specified type of attribute, not the
+ * overall attribute number at the level. Also note that the
+ * instance number is 1-based. For example:
+ * v=0
+ * o=mhandley 2890844526 2890842807 IN IP4 126.16.64.4
+ * s=SDP Seminar
+ * c=IN IP4 10.1.0.2
+ * t=0 0
+ * m=audio 1234 RTP/AVP 0 101 102
+ * a=foo 1
+ * a=foo 2
+ * a=bar 1 # This is instance 1 of attribute bar.
+ * a=foo 3 # This is instance 3 of attribute foo.
+ * cap_num Almost all of the attributes may be defined as X-cpar
+ * parameters (with the exception of X-sqn, X-cap, and X-cpar).
+ * If the cap_num is set to zero, then the attribute is not
+ * an X-cpar parameter attribute. If the cap_num is any other
+ * value, it specifies the capability number that the X-cpar
+ * attribute is specified for.
+ */
+
+/* Attribute handling:
+ *
+ * There are two basic types of attributes handled by the SDP library,
+ * those defined by a= token lines, and those embedded with a=X-cpar lines.
+ * The handling for each of these is described here.
+ *
+ * Simple (non X-cpar attributes):
+ *
+ * Attributes not embedded in a=X-cpar lines are referenced by level and
+ * instance number. For these attributes the capability number is always
+ * set to zero.
+ *
+ * An application will typically process these attributes in one of two ways.
+ * With the first method, the application can determine the total number
+ * of attributes defined at a given level and process them one at a time.
+ * For each attribute, the application will query the library to find out
+ * what type of attribute it is and which instance within that type. The
+ * application can then process this particular attribute referencing it
+ * by level and instance number.
+ *
+ * A second method of processing attributes is for applications to determine
+ * each type of attribute they are interested in, query the SDP library to
+ * find out how many of that type of attribute exist at a given level, and
+ * process each one at a time.
+ *
+ * X-cpar attribute processing:
+ *
+ * X-cpar attributes can contain embedded attributes. They are associated
+ * with X-cap attribute lines. An example of X-cap and X-cpar attributes
+ * found in an SDP is as follows:
+ *
+ * v=0
+ * o=- 25678 753849 IN IP4 128.96.41.1
+ * s=-
+ * t=0 0
+ * c=IN IP4 10.1.0.2
+ * m=audio 3456 RTP/AVP 18 96
+ * a=rtpmap:96 telephone-event/8000
+ * a=fmtp:96 0-15,32-35
+ * a=X-sqn: 0
+ * a=X-cap: 1 audio RTP/AVP 0 18 96 97
+ * a=X-cpar: a=fmtp:96 0-16,32-35
+ * a=X-cpar: a=rtpmap:97 X-NSE/8000
+ * a=X-cpar: a=fmtp:97 195-197
+ * a=X-cap: 5 image udptl t38
+ * a=X-cap: 6 application udp X-tmr
+ * a=X-cap: 7 audio RTP/AVP 100 101
+ * a=X-cpar: a=rtpmap:100 g.711/8000
+ * a=X-cpar: a=rtpmap:101 g.729/8000
+ *
+ * X-cap attributes can be defined at the SESSION_LEVEL or any media level.
+ * An X-cap attr is defined by the level and instance number just like
+ * other attributes. In the example above, X-cap attrs are defined at
+ * media level 1 and there are four instances at that level.
+ *
+ * The X-cpar attributes can also be referenced by level and instance number.
+ * However, the embedded attribute within an X-cpar attribute must be
+ * referenced by level, instance number, and capability number. This is
+ * because the X-cpar attribute is associated with a particular X-cap/
+ * capability.
+ * For all attributes that are not embedded within an X-cpar attribute, the
+ * cap_num should be referenced as zero. But for X-cpar attributes, the
+ * cap_num is specified to be one of the capability numbers of the previous
+ * X-cap line. The number of capabilities specified in an X-cap line is
+ * equal to the number of payloads. Thus, in this example, the first X-cap
+ * attr instance specifies capabilities 1-4, the second specifies capability
+ * 5, the third capability 6, and the fourth capabilities 7-8.
+ *
+ * X-cpar attributes can be processed with methods similar to the two
+ * previously mentioned. For each X-cap attribute, the application can
+ * use one of two methods to process the X-cpar attributes. First, it
+ * can query the total number of X-cpar attributes associated with a
+ * given X-cap attribute. The X-cap attribute is here defined by a level
+ * and a capability number. In the example above, the total number of
+ * attributes defined is as follows:
+ * level 1, cap_num 1 - total attrs: 3
+ * level 1, cap_num 5 - total attrs: 0
+ * level 1, cap_num 6 - total attrs: 0
+ * level 1, cap_num 7 - total attrs: 2
+ *
+ * Note that if the application queried the number of attributes for
+ * cap_num 2, 3, or 4, it would also return 3 attrs, and for cap_num
+ * 8 the library would return 2.
+ *
+ * Once the application determines the total number of attributes for
+ * that capability, it can again query the embedded attribute type and
+ * instance. For example, sdp_get_attr_type would return the following:
+ * level 1, cap_num 1, attr 1 -> attr type fmtp, instance 1
+ * level 1, cap_num 1, attr 2 -> attr type rtpmap, instance 1
+ * level 1, cap_num 1, attr 3 -> attr type fmtp, instance 2
+ * level 1, cap_num 7, attr 1 -> attr type rtpmap, instance 1
+ * level 1, cap_num 7, attr 2 -> attr type rtpmap, instance 2
+ *
+ * The individual embedded attributes can then be accessed by level,
+ * cap_num, and instance number.
+ *
+ * With the second method for handling X-cpar attributes, the application
+ * determines the types of attributes it is interested in. It can then
+ * query the SDP library to determine the number of attributes of that
+ * type found for that level and cap_num, and then process each one at
+ * a time. e.g., calling sdp_attr_num_instances would give:
+ * level 1, cap_num 1, attr_type fmtp -> two instances
+ * level 1, cap_num 1, attr_type rtpmap -> one instance
+ * level 1, cap_num 7, attr_type fmtp -> zero instances
+ * level 1, cap_num 7, attr_type rtpmap -> two instances
+ */
+
+
+/* Function: sdp_add_new_attr
+ * Description: Add a new attribute of the specified type at the given
+ * level and capability level or base attribute if cap_num
+ * is zero.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * attr_type The type of attribute to add.
+ * inst_num Pointer to a uint16_t in which to return the instance
+ * number of the newly added attribute.
+ * Returns: SDP_SUCCESS Attribute was added successfully.
+ * SDP_NO_RESOURCE No memory avail for new attribute.
+ * SDP_INVALID_PARAMETER Specified media line is not defined.
+ */
+sdp_result_e sdp_add_new_attr (sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ sdp_attr_e attr_type, uint16_t *inst_num)
+{
+ uint16_t i;
+ sdp_mca_t *mca_p;
+ sdp_mca_t *cap_p;
+ sdp_attr_t *attr_p;
+ sdp_attr_t *new_attr_p;
+ sdp_attr_t *prev_attr_p=NULL;
+ sdp_fmtp_t *fmtp_p;
+ sdp_comediadir_t *comediadir_p;
+
+ *inst_num = 0;
+
+ if ((cap_num != 0) &&
+ ((attr_type == SDP_ATTR_X_CAP) || (attr_type == SDP_ATTR_X_CPAR) ||
+ (attr_type == SDP_ATTR_X_SQN) || (attr_type == SDP_ATTR_CDSC) ||
+ (attr_type == SDP_ATTR_CPAR) || (attr_type == SDP_ATTR_SQN))) {
+ if (sdp_p->debug_flag[SDP_DEBUG_WARNINGS]) {
+ CSFLogDebug(logTag, "%s Warning: Invalid attribute type for X-cpar/cdsc "
+ "parameter.", sdp_p->debug_str);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Some attributes are valid only under media level */
+ if (level == SDP_SESSION_LEVEL) {
+ switch (attr_type) {
+ case SDP_ATTR_RTCP:
+ case SDP_ATTR_LABEL:
+ return (SDP_INVALID_MEDIA_LEVEL);
+
+ default:
+ break;
+ }
+ }
+
+ new_attr_p = (sdp_attr_t *)SDP_MALLOC(sizeof(sdp_attr_t));
+ if (new_attr_p == NULL) {
+ sdp_p->conf_p->num_no_resource++;
+ return (SDP_NO_RESOURCE);
+ }
+
+ new_attr_p->type = attr_type;
+ new_attr_p->next_p = NULL;
+
+ /* Initialize the new attribute structure */
+ if ((new_attr_p->type == SDP_ATTR_X_CAP) ||
+ (new_attr_p->type == SDP_ATTR_CDSC)) {
+ new_attr_p->attr.cap_p = (sdp_mca_t *)SDP_MALLOC(sizeof(sdp_mca_t));
+ if (new_attr_p->attr.cap_p == NULL) {
+ sdp_free_attr(new_attr_p);
+ sdp_p->conf_p->num_no_resource++;
+ return (SDP_NO_RESOURCE);
+ }
+ } else if (new_attr_p->type == SDP_ATTR_FMTP) {
+ fmtp_p = &(new_attr_p->attr.fmtp);
+ fmtp_p->fmtp_format = SDP_FMTP_UNKNOWN_TYPE;
+ // set to invalid value
+ fmtp_p->packetization_mode = SDP_INVALID_PACKETIZATION_MODE_VALUE;
+ fmtp_p->level_asymmetry_allowed = SDP_INVALID_LEVEL_ASYMMETRY_ALLOWED_VALUE;
+ fmtp_p->annexb_required = FALSE;
+ fmtp_p->annexa_required = FALSE;
+ fmtp_p->maxval = 0;
+ fmtp_p->bitrate = 0;
+ fmtp_p->cif = 0;
+ fmtp_p->qcif = 0;
+ fmtp_p->profile = SDP_INVALID_VALUE;
+ fmtp_p->level = SDP_INVALID_VALUE;
+ fmtp_p->parameter_add = SDP_FMTP_UNUSED;
+ fmtp_p->usedtx = SDP_FMTP_UNUSED;
+ fmtp_p->stereo = SDP_FMTP_UNUSED;
+ fmtp_p->useinbandfec = SDP_FMTP_UNUSED;
+ fmtp_p->cbr = SDP_FMTP_UNUSED;
+ for (i=0; i < SDP_NE_NUM_BMAP_WORDS; i++) {
+ fmtp_p->bmap[i] = 0;
+ }
+ } else if ((new_attr_p->type == SDP_ATTR_RTPMAP) ||
+ (new_attr_p->type == SDP_ATTR_SPRTMAP)) {
+ new_attr_p->attr.transport_map.num_chan = 1;
+ } else if (new_attr_p->type == SDP_ATTR_DIRECTION) {
+ comediadir_p = &(new_attr_p->attr.comediadir);
+ comediadir_p->role = SDP_MEDIADIR_ROLE_PASSIVE;
+ comediadir_p->conn_info_present = FALSE;
+ } else if (new_attr_p->type == SDP_ATTR_MPTIME) {
+ sdp_mptime_t *mptime = &(new_attr_p->attr.mptime);
+ mptime->num_intervals = 0;
+ }
+
+ if (cap_num == 0) {
+ /* Add a new attribute. */
+ if (level == SDP_SESSION_LEVEL) {
+ if (sdp_p->sess_attrs_p == NULL) {
+ sdp_p->sess_attrs_p = new_attr_p;
+ } else {
+ for (attr_p = sdp_p->sess_attrs_p;
+ attr_p != NULL;
+ prev_attr_p = attr_p, attr_p = attr_p->next_p) {
+ /* Count the num instances of this type. */
+ if (attr_p->type == attr_type) {
+ (*inst_num)++;
+ }
+ }
+ prev_attr_p->next_p = new_attr_p;
+ }
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ sdp_free_attr(new_attr_p);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ if (mca_p->media_attrs_p == NULL) {
+ mca_p->media_attrs_p = new_attr_p;
+ } else {
+ for (attr_p = mca_p->media_attrs_p;
+ attr_p != NULL;
+ prev_attr_p = attr_p, attr_p = attr_p->next_p) {
+ /* Count the num instances of this type. */
+ if (attr_p->type == attr_type) {
+ (*inst_num)++;
+ }
+ }
+ prev_attr_p->next_p = new_attr_p;
+ }
+ }
+ } else {
+ /* Add a new capability attribute - find the capability attr. */
+ attr_p = sdp_find_capability(sdp_p, level, cap_num);
+ if (attr_p == NULL) {
+ sdp_free_attr(new_attr_p);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ cap_p = attr_p->attr.cap_p;
+ if (cap_p->media_attrs_p == NULL) {
+ cap_p->media_attrs_p = new_attr_p;
+ } else {
+ for (attr_p = cap_p->media_attrs_p;
+ attr_p != NULL;
+ prev_attr_p = attr_p, attr_p = attr_p->next_p) {
+ /* Count the num instances of this type. */
+ if (attr_p->type == attr_type) {
+ (*inst_num)++;
+ }
+ }
+ prev_attr_p->next_p = new_attr_p;
+ }
+ }
+
+ /* Increment the instance num for the attr just added. */
+ (*inst_num)++;
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_attr_num_instances
+ * Description: Get the number of attributes of the specified type at
+ * the given level and capability level.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * attr_type The type of attribute to add.
+ * num_attr_inst Pointer to a uint16_t in which to return the
+ * number of attributes.
+ * Returns: SDP_SUCCESS Attribute was added successfully.
+ * SDP_INVALID_PARAMETER Specified media line is not defined.
+ */
+sdp_result_e sdp_attr_num_instances (sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ sdp_attr_e attr_type, uint16_t *num_attr_inst)
+{
+ sdp_attr_t *attr_p;
+ sdp_result_e rc;
+ static char fname[] = "attr_num_instances";
+
+ *num_attr_inst = 0;
+
+ rc = sdp_find_attr_list(sdp_p, level, cap_num, &attr_p, fname);
+ if (rc == SDP_SUCCESS) {
+ /* Found the attr list. Count the number of attrs of the given
+ * type at this level. */
+ for (; attr_p != NULL; attr_p = attr_p->next_p) {
+ if (attr_p->type == attr_type) {
+ (*num_attr_inst)++;
+ }
+ }
+
+ }
+
+ return (rc);
+}
+
+/* Forward declaration for use in sdp_free_attr */
+static boolean sdp_attr_is_long_string(sdp_attr_e attr_type);
+
+
+/* Internal routine to free the memory associated with an attribute.
+ * Certain attributes allocate additional memory. Free this and then
+ * free the attribute itself.
+ * Note that this routine may be called at any point (i.e., may be
+ * called due to a failure case) and so the additional memory
+ * associated with an attribute may or may not have been already
+ * allocated. This routine should check this carefully.
+ */
+void sdp_free_attr (sdp_attr_t *attr_p)
+{
+ sdp_mca_t *cap_p;
+ sdp_attr_t *cpar_p;
+ sdp_attr_t *next_cpar_p;
+ int i;
+
+ /* If this is an X-cap/cdsc attr, free the cap_p structure and
+ * all X-cpar/cpar attributes. */
+ if ((attr_p->type == SDP_ATTR_X_CAP) ||
+ (attr_p->type == SDP_ATTR_CDSC)) {
+ cap_p = attr_p->attr.cap_p;
+ if (cap_p != NULL) {
+ for (cpar_p = cap_p->media_attrs_p; cpar_p != NULL;) {
+ next_cpar_p = cpar_p->next_p;
+ sdp_free_attr(cpar_p);
+ cpar_p = next_cpar_p;
+ }
+ SDP_FREE(cap_p);
+ }
+ } else if ((attr_p->type == SDP_ATTR_SDESCRIPTIONS) ||
+ (attr_p->type == SDP_ATTR_SRTP_CONTEXT)) {
+ SDP_FREE(attr_p->attr.srtp_context.session_parameters);
+ } else if (sdp_attr_is_long_string(attr_p->type)) {
+ SDP_FREE(attr_p->attr.stringp);
+ }
+
+ if (attr_p->type == SDP_ATTR_GROUP) {
+ for (i = 0; i < attr_p->attr.stream_data.num_group_id; i++) {
+ SDP_FREE(attr_p->attr.stream_data.group_ids[i]);
+ }
+ } else if (attr_p->type == SDP_ATTR_MSID_SEMANTIC) {
+ for (i = 0; i < SDP_MAX_MEDIA_STREAMS; ++i) {
+ SDP_FREE(attr_p->attr.msid_semantic.msids[i]);
+ }
+ }
+
+ /* Now free the actual attribute memory. */
+ SDP_FREE(attr_p);
+
+}
+
+
+/* Function: sdp_find_attr_list
+ * Description: Find the attribute list for the specified level and cap_num.
+ * Note: This is not an API for the application but an internal
+ * routine used by the SDP library.
+ * Parameters: sdp_p Pointer to the SDP to search.
+ * level The level to check for the attribute list.
+ * cap_num The capability number associated with the
+ * attribute list. If none, should be zero.
+ * attr_p Pointer to the attr list pointer. Will be
+ * filled in on return if successful.
+ * fname String function name calling this routine.
+ * Use for printing debug.
+ * Returns: SDP_SUCCESS
+ * SDP_INVALID_MEDIA_LEVEL
+ * SDP_INVALID_CAPABILITY
+ * SDP_FAILURE
+ */
+sdp_result_e sdp_find_attr_list (sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ sdp_attr_t **attr_p, char *fname)
+{
+ sdp_mca_t *mca_p;
+ sdp_mca_t *cap_p;
+ sdp_attr_t *cap_attr_p;
+
+ /* Initialize the attr pointer. */
+ *attr_p = NULL;
+
+ if (cap_num == 0) {
+ /* Find attribute list at the specified level. */
+ if (level == SDP_SESSION_LEVEL) {
+ *attr_p = sdp_p->sess_attrs_p;
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ *attr_p = mca_p->media_attrs_p;
+ }
+ } else {
+ /* Find the attr list for the capability specified. */
+ cap_attr_p = sdp_find_capability(sdp_p, level, cap_num);
+ if (cap_attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s %s, invalid capability %u at "
+ "level %u specified.", sdp_p->debug_str, fname,
+ (unsigned)cap_num, (unsigned)level);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_CAPABILITY);
+ }
+ cap_p = cap_attr_p->attr.cap_p;
+ *attr_p = cap_p->media_attrs_p;
+ }
+
+ return (SDP_SUCCESS);
+}
+
+/* Find fmtp inst_num with correct payload value or -1 for failure */
+int sdp_find_fmtp_inst (sdp_t *sdp_p, uint16_t level, uint16_t payload_num)
+{
+ uint16_t attr_count=0;
+ sdp_mca_t *mca_p;
+ sdp_attr_t *attr_p;
+
+ /* Attr is at a media level */
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (-1);
+ }
+ for (attr_p = mca_p->media_attrs_p; attr_p != NULL;
+ attr_p = attr_p->next_p) {
+ if (attr_p->type == SDP_ATTR_FMTP) {
+ attr_count++;
+ if (attr_p->attr.fmtp.payload_num == payload_num) {
+ return (attr_count);
+ }
+ }
+ }
+
+ return (-1);
+
+}
+
+/* Function: sdp_find_attr
+ * Description: Find the specified attribute in an SDP structure.
+ * Note: This is not an API for the application but an internal
+ * routine used by the SDP library.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * attr_type The type of attribute to find.
+ * inst_num The instance num of the attribute to find.
+ * Range should be (1 - max num insts of this
+ * particular type of attribute at this level).
+ * Returns: Pointer to the attribute or NULL if not found.
+ */
+sdp_attr_t *sdp_find_attr (sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ sdp_attr_e attr_type, uint16_t inst_num)
+{
+ uint16_t attr_count=0;
+ sdp_mca_t *mca_p;
+ sdp_mca_t *cap_p;
+ sdp_attr_t *attr_p;
+
+ if (inst_num < 1) {
+ return (NULL);
+ }
+
+ if (cap_num == 0) {
+ if (level == SDP_SESSION_LEVEL) {
+ for (attr_p = sdp_p->sess_attrs_p; attr_p != NULL;
+ attr_p = attr_p->next_p) {
+ if (attr_p->type == attr_type) {
+ attr_count++;
+ if (attr_count == inst_num) {
+ return (attr_p);
+ }
+ }
+ }
+ } else { /* Attr is at a media level */
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (NULL);
+ }
+ for (attr_p = mca_p->media_attrs_p; attr_p != NULL;
+ attr_p = attr_p->next_p) {
+ if (attr_p->type == attr_type) {
+ attr_count++;
+ if (attr_count == inst_num) {
+ return (attr_p);
+ }
+ }
+ }
+ } /* Attr is at a media level */
+ } else {
+ /* Attr is a capability X-cpar/cpar attribute. */
+ attr_p = sdp_find_capability(sdp_p, level, cap_num);
+ if (attr_p == NULL) {
+ return (NULL);
+ }
+ cap_p = attr_p->attr.cap_p;
+ /* Now find the specific attribute. */
+ for (attr_p = cap_p->media_attrs_p; attr_p != NULL;
+ attr_p = attr_p->next_p) {
+ if (attr_p->type == attr_type) {
+ attr_count++;
+ if (attr_count == inst_num) {
+ return (attr_p);
+ }
+ }
+ }
+ }
+
+ return (NULL);
+}
+
+/* Function: sdp_find_capability
+ * Description: Find the specified capability attribute in an SDP structure.
+ * Note: This is not an API for the application but an internal
+ * routine used by the SDP library.
+ * Parameters: sdp_p The SDP handle.
+ * level The level to check for the capability.
+ * cap_num The capability number to locate.
+ * Returns: Pointer to the capability attribute or NULL if not found.
+ */
+sdp_attr_t *sdp_find_capability (sdp_t *sdp_p, uint16_t level, uint8_t cap_num)
+{
+ uint8_t cur_cap_num=0;
+ sdp_mca_t *mca_p;
+ sdp_mca_t *cap_p;
+ sdp_attr_t *attr_p;
+
+ if (level == SDP_SESSION_LEVEL) {
+ for (attr_p = sdp_p->sess_attrs_p; attr_p != NULL;
+ attr_p = attr_p->next_p) {
+ if ((attr_p->type == SDP_ATTR_X_CAP) ||
+ (attr_p->type == SDP_ATTR_CDSC)) {
+ cap_p = attr_p->attr.cap_p;
+ cur_cap_num += cap_p->num_payloads;
+ if (cap_num <= cur_cap_num) {
+ /* This is the right capability */
+ return (attr_p);
+ }
+ }
+ }
+ } else { /* Capability is at a media level */
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (NULL);
+ }
+ for (attr_p = mca_p->media_attrs_p; attr_p != NULL;
+ attr_p = attr_p->next_p) {
+ if ((attr_p->type == SDP_ATTR_X_CAP) ||
+ (attr_p->type == SDP_ATTR_CDSC)) {
+ cap_p = attr_p->attr.cap_p;
+ cur_cap_num += cap_p->num_payloads;
+ if (cap_num <= cur_cap_num) {
+ /* This is the right capability */
+ return (attr_p);
+ }
+ }
+ }
+ }
+
+ /* We didn't find the specified capability. */
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Unable to find specified capability (level %u, "
+ "cap_num %u).", sdp_p->debug_str, (unsigned)level, (unsigned)cap_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (NULL);
+}
+
+/* Function: sdp_attr_valid(sdp_t *sdp_p)
+ * Description: Returns true or false depending on whether the specified
+ * instance of the given attribute has been defined at the
+ * given level.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * attr_type The attribute type to validate.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: TRUE or FALSE.
+ */
+tinybool sdp_attr_valid (sdp_t *sdp_p, sdp_attr_e attr_type, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ if (sdp_find_attr(sdp_p, level, cap_num, attr_type, inst_num) == NULL) {
+ return (FALSE);
+ } else {
+ return (TRUE);
+ }
+}
+
+/* Function: sdp_attr_line_number(sdp_t *sdp_p)
+ * Description: Returns the line number this attribute appears on.
+ * Only works if the SDP was parsed rather than created
+ * locally.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * attr_type The attribute type to validate.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: line number, or 0 if an error
+ */
+uint32_t sdp_attr_line_number (sdp_t *sdp_p, sdp_attr_e attr_type, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, attr_type, inst_num);
+ if (attr_p == NULL) {
+ return 0;
+ } else {
+ return attr_p->line_number;
+ }
+}
+
+static boolean sdp_attr_is_simple_string(sdp_attr_e attr_type) {
+ if ((attr_type != SDP_ATTR_BEARER) &&
+ (attr_type != SDP_ATTR_CALLED) &&
+ (attr_type != SDP_ATTR_CONN_TYPE) &&
+ (attr_type != SDP_ATTR_DIALED) &&
+ (attr_type != SDP_ATTR_DIALING) &&
+ (attr_type != SDP_ATTR_FRAMING) &&
+ (attr_type != SDP_ATTR_MID) &&
+ (attr_type != SDP_ATTR_X_SIDIN) &&
+ (attr_type != SDP_ATTR_X_SIDOUT)&&
+ (attr_type != SDP_ATTR_X_CONFID) &&
+ (attr_type != SDP_ATTR_LABEL) &&
+ (attr_type != SDP_ATTR_ICE_OPTIONS) &&
+ (attr_type != SDP_ATTR_IMAGEATTR) &&
+ (attr_type != SDP_ATTR_SIMULCAST) &&
+ (attr_type != SDP_ATTR_RID)) {
+ return FALSE;
+ }
+ return TRUE;
+}
+
+/* Function: sdp_attr_get_simple_string
+ * Description: Returns a pointer to a string attribute parameter. This
+ * routine can only be called for attributes that have just
+ * one string parameter. The value is returned as a const
+ * ptr and so cannot be modified by the application. If the
+ * given attribute is not defined, NULL will be returned.
+ * Attributes with a simple string parameter currently include:
+ * bearer, called, connection_type, dialed, dialing, direction
+ * and framing.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * attr_type The simple string attribute type.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Pointer to the parameter value.
+ */
+const char *sdp_attr_get_simple_string (sdp_t *sdp_p, sdp_attr_e attr_type,
+ uint16_t level, uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ if (!sdp_attr_is_simple_string(attr_type)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Attribute type is not a simple string (%s)",
+ sdp_p->debug_str, sdp_get_attr_name(attr_type));
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (NULL);
+ }
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, attr_type, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Attribute %s, level %u instance %u not found.",
+ sdp_p->debug_str, sdp_get_attr_name(attr_type),
+ (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (NULL);
+ } else {
+ return (attr_p->attr.string_val);
+ }
+}
+
+static boolean sdp_attr_is_long_string(sdp_attr_e attr_type) {
+ return (attr_type == SDP_ATTR_IDENTITY || attr_type == SDP_ATTR_DTLS_MESSAGE);
+}
+
+/* Identical in usage to sdp_attr_get_simple_string() */
+const char *sdp_attr_get_long_string (sdp_t *sdp_p, sdp_attr_e attr_type,
+ uint16_t level, uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ if (!sdp_attr_is_long_string(attr_type)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Attribute type is not a long string (%s)",
+ sdp_p->debug_str, sdp_get_attr_name(attr_type));
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (NULL);
+ }
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, attr_type, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Attribute %s, level %u instance %u not found.",
+ sdp_p->debug_str, sdp_get_attr_name(attr_type),
+ (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (NULL);
+ } else {
+ return (attr_p->attr.stringp);
+ }
+}
+
+static boolean sdp_attr_is_simple_u32(sdp_attr_e attr_type) {
+ if ((attr_type != SDP_ATTR_EECID) &&
+ (attr_type != SDP_ATTR_PTIME) &&
+ (attr_type != SDP_ATTR_MAXPTIME) &&
+ (attr_type != SDP_ATTR_T38_VERSION) &&
+ (attr_type != SDP_ATTR_T38_MAXBITRATE) &&
+ (attr_type != SDP_ATTR_T38_MAXBUFFER) &&
+ (attr_type != SDP_ATTR_T38_MAXDGRAM) &&
+ (attr_type != SDP_ATTR_X_SQN) &&
+ (attr_type != SDP_ATTR_TC1_PAYLOAD_BYTES) &&
+ (attr_type != SDP_ATTR_TC1_WINDOW_SIZE) &&
+ (attr_type != SDP_ATTR_TC2_PAYLOAD_BYTES) &&
+ (attr_type != SDP_ATTR_TC2_WINDOW_SIZE) &&
+ (attr_type != SDP_ATTR_FRAMERATE)) {
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+/* Function: sdp_attr_get_simple_u32
+ * Description: Returns an unsigned 32-bit attribute parameter. This
+ * routine can only be called for attributes that have just
+ * one uint32_t parameter. If the given attribute is not defined,
+ * zero will be returned. There is no way for the application
+ * to determine if zero is the actual value or the attribute
+ * wasn't defined, so the application must use the
+ * sdp_attr_valid function to determine this.
+ * Attributes with a simple uint32_t parameter currently include:
+ * eecid, ptime, T38FaxVersion, T38maxBitRate, T38FaxMaxBuffer,
+ * T38FaxMaxDatagram, X-sqn, TC1PayloadBytes, TC1WindowSize,
+ * TC2PayloadBytes, TC2WindowSize, rtcp.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * attr_type The simple uint32_t attribute type.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: uint32_t parameter value.
+ */
+uint32_t sdp_attr_get_simple_u32 (sdp_t *sdp_p, sdp_attr_e attr_type, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ if (!sdp_attr_is_simple_u32(attr_type)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Attribute type is not a simple uint32_t (%s)",
+ sdp_p->debug_str, sdp_get_attr_name(attr_type));
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ }
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, attr_type, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Attribute %s, level %u instance %u not found.",
+ sdp_p->debug_str, sdp_get_attr_name(attr_type),
+ (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ return (attr_p->attr.u32_val);
+ }
+}
+
+/* Function: sdp_attr_get_simple_boolean
+ * Description: Returns a boolean attribute parameter. This
+ * routine can only be called for attributes that have just
+ * one boolean parameter. If the given attribute is not defined,
+ * FALSE will be returned. There is no way for the application
+ * to determine if FALSE is the actual value or the attribute
+ * wasn't defined, so the application must use the
+ * sdp_attr_valid function to determine this.
+ * Attributes with a simple boolean parameter currently include:
+ * T38FaxFillBitRemoval, T38FaxTranscodingMMR,
+ * T38FaxTranscodingJBIG, and TMRGwXid.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * attr_type The simple boolean attribute type.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Boolean value.
+ */
+tinybool sdp_attr_get_simple_boolean (sdp_t *sdp_p, sdp_attr_e attr_type,
+ uint16_t level, uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ if ((attr_type != SDP_ATTR_T38_FILLBITREMOVAL) &&
+ (attr_type != SDP_ATTR_T38_TRANSCODINGMMR) &&
+ (attr_type != SDP_ATTR_T38_TRANSCODINGJBIG) &&
+ (attr_type != SDP_ATTR_TMRGWXID)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Attribute type is not a simple boolean (%s)",
+ sdp_p->debug_str, sdp_get_attr_name(attr_type));
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (FALSE);
+ }
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, attr_type, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Attribute %s, level %u instance %u not found.",
+ sdp_p->debug_str, sdp_get_attr_name(attr_type),
+ (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (FALSE);
+ } else {
+ return (attr_p->attr.boolean_val);
+ }
+}
+
+/*
+ * sdp_attr_get_maxprate
+ *
+ * This function is used by the application layer to get the packet-rate
+ * within the maxprate attribute.
+ *
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * inst_num The attribute instance number to set.
+ *
+ * Returns a pointer to a constant char array that stores the packet-rate,
+ * OR null if the attribute does not exist.
+ */
+const char*
+sdp_attr_get_maxprate (sdp_t *sdp_p, uint16_t level, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, 0, SDP_ATTR_MAXPRATE, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Attribute %s, level %u instance %u not found.",
+ sdp_p->debug_str, sdp_get_attr_name(SDP_ATTR_MAXPRATE),
+ (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (NULL);
+ } else {
+ return (attr_p->attr.string_val);
+ }
+}
+
+/* Function: sdp_attr_get_t38ratemgmt
+ * Description: Returns the value of the t38ratemgmt attribute
+ * parameter specified for the given attribute. If the given
+ * attribute is not defined, SDP_T38_UNKNOWN_RATE is returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Ratemgmt value.
+ */
+sdp_t38_ratemgmt_e sdp_attr_get_t38ratemgmt (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_T38_RATEMGMT, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s t38ratemgmt attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_T38_UNKNOWN_RATE);
+ } else {
+ return (attr_p->attr.t38ratemgmt);
+ }
+}
+
+/* Function: sdp_attr_get_t38udpec
+ * Description: Returns the value of the t38udpec attribute
+ * parameter specified for the given attribute. If the given
+ * attribute is not defined, SDP_T38_UDPEC_UNKNOWN is returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: UDP EC value.
+ */
+sdp_t38_udpec_e sdp_attr_get_t38udpec (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_T38_UDPEC, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s t38udpec attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_T38_UDPEC_UNKNOWN);
+ } else {
+ return (attr_p->attr.t38udpec);
+ }
+}
+
+/* Function: sdp_get_media_direction
+ * Description: Determines the direction defined for a given level. The
+ * direction will be inactive, sendonly, recvonly, or sendrecv
+ * as determined by the last of these attributes specified at
+ * the given level. If none of these attributes are specified,
+ * the direction will be sendrecv by default.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * Returns: An SDP direction enum value.
+ */
+sdp_direction_e sdp_get_media_direction (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num)
+{
+ sdp_mca_t *mca_p;
+ sdp_attr_t *attr_p;
+ sdp_direction_e direction = SDP_DIRECTION_SENDRECV;
+
+ if (cap_num == 0) {
+ /* Find the pointer to the attr list for this level. */
+ if (level == SDP_SESSION_LEVEL) {
+ attr_p = sdp_p->sess_attrs_p;
+ } else { /* Attr is at a media level */
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (direction);
+ }
+ attr_p = mca_p->media_attrs_p;
+ }
+
+ /* Scan for direction oriented attributes. Last one wins. */
+ for (; attr_p != NULL; attr_p = attr_p->next_p) {
+ if (attr_p->type == SDP_ATTR_INACTIVE) {
+ direction = SDP_DIRECTION_INACTIVE;
+ } else if (attr_p->type == SDP_ATTR_SENDONLY) {
+ direction = SDP_DIRECTION_SENDONLY;
+ } else if (attr_p->type == SDP_ATTR_RECVONLY) {
+ direction = SDP_DIRECTION_RECVONLY;
+ } else if (attr_p->type == SDP_ATTR_SENDRECV) {
+ direction = SDP_DIRECTION_SENDRECV;
+ }
+ }
+ } else {
+ if (sdp_p->debug_flag[SDP_DEBUG_WARNINGS]) {
+ CSFLogDebug(logTag, "%s Warning: Invalid cap_num for media direction.",
+ sdp_p->debug_str);
+ }
+ }
+
+ return (direction);
+}
+
+/* Since there are four different attribute names which all have the same
+ * qos parameters, all of these attributes are accessed through this same
+ * set of APIs. To distinguish between specific attributes, the application
+ * must also pass the attribute type. The attribute must be one of:
+ * SDP_ATTR_QOS, SDP_ATTR_SECURE, SDP_ATTR_X_PC_QOS, and SDP_ATTR_X_QOS.
+ */
+tinybool sdp_validate_qos_attr (sdp_attr_e qos_attr)
+{
+ if ((qos_attr == SDP_ATTR_QOS) ||
+ (qos_attr == SDP_ATTR_SECURE) ||
+ (qos_attr == SDP_ATTR_X_PC_QOS) ||
+ (qos_attr == SDP_ATTR_X_QOS) ||
+ (qos_attr == SDP_ATTR_CURR) ||
+ (qos_attr == SDP_ATTR_DES) ||
+ (qos_attr == SDP_ATTR_CONF)){
+ return (TRUE);
+ } else {
+ return (FALSE);
+ }
+}
+
+/* Function: sdp_attr_get_qos_strength
+ * Description: Returns the value of the qos attribute strength
+ * parameter specified for the given attribute. If the given
+ * attribute is not defined, SDP_QOS_STRENGTH_UNKNOWN is
+ * returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * qos_attr The specific type of qos attribute. May be
+ * qos, secure, X-pc-qos, or X-qos.
+ * inst_num The attribute instance number to check.
+ * Returns: Qos strength value.
+ */
+sdp_qos_strength_e sdp_attr_get_qos_strength (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, sdp_attr_e qos_attr, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ if (sdp_validate_qos_attr(qos_attr) == FALSE) {
+ if (sdp_p->debug_flag[SDP_DEBUG_WARNINGS]) {
+ CSFLogDebug(logTag, "%s Warning: Invalid QOS attribute specified for"
+ "get qos strength.", sdp_p->debug_str);
+ }
+ return (SDP_QOS_STRENGTH_UNKNOWN);
+ }
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, qos_attr, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s %s attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str,
+ sdp_get_attr_name(qos_attr), (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_QOS_STRENGTH_UNKNOWN);
+ } else {
+ switch (qos_attr) {
+ case SDP_ATTR_QOS:
+ return (attr_p->attr.qos.strength);
+ case SDP_ATTR_DES:
+ return (attr_p->attr.des.strength);
+ default:
+ return SDP_QOS_STRENGTH_UNKNOWN;
+
+ }
+ }
+}
+
+/* Function: sdp_attr_get_qos_direction
+ * Description: Returns the value of the qos attribute direction
+ * parameter specified for the given attribute. If the given
+ * attribute is not defined, SDP_QOS_DIR_UNKNOWN is
+ * returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * qos_attr The specific type of qos attribute. May be
+ * qos, secure, X-pc-qos, or X-qos.
+ * inst_num The attribute instance number to check.
+ * Returns: Qos direction value.
+ */
+sdp_qos_dir_e sdp_attr_get_qos_direction (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, sdp_attr_e qos_attr, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ if (sdp_validate_qos_attr(qos_attr) == FALSE) {
+ if (sdp_p->debug_flag[SDP_DEBUG_WARNINGS]) {
+ CSFLogDebug(logTag, "%s Warning: Invalid QOS attribute specified "
+ "for get qos direction.", sdp_p->debug_str);
+ }
+ return (SDP_QOS_DIR_UNKNOWN);
+ }
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, qos_attr, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s %s attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str,
+ sdp_get_attr_name(qos_attr), (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_QOS_DIR_UNKNOWN);
+ } else {
+ switch (qos_attr) {
+ case SDP_ATTR_QOS:
+ return (attr_p->attr.qos.direction);
+ case SDP_ATTR_CURR:
+ return (attr_p->attr.curr.direction);
+ case SDP_ATTR_DES:
+ return (attr_p->attr.des.direction);
+ case SDP_ATTR_CONF:
+ return (attr_p->attr.conf.direction);
+ default:
+ return SDP_QOS_DIR_UNKNOWN;
+
+ }
+ }
+}
+
+/* Function: sdp_attr_get_qos_status_type
+ * Description: Returns the value of the qos attribute status_type
+ * parameter specified for the given attribute. If the given
+ * attribute is not defined, SDP_QOS_STATUS_TYPE_UNKNOWN is
+ * returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * qos_attr The specific type of qos attribute. May be
+ * qos, secure, X-pc-qos, or X-qos.
+ * inst_num The attribute instance number to check.
+ * Returns: Qos direction value.
+ */
+sdp_qos_status_types_e sdp_attr_get_qos_status_type (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, sdp_attr_e qos_attr, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ if (sdp_validate_qos_attr(qos_attr) == FALSE) {
+ if (sdp_p->debug_flag[SDP_DEBUG_WARNINGS]) {
+ CSFLogDebug(logTag, "%s Warning: Invalid QOS attribute specified "
+ "for get qos status_type.", sdp_p->debug_str);
+ }
+ return (SDP_QOS_STATUS_TYPE_UNKNOWN);
+ }
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, qos_attr, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s %s attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str,
+ sdp_get_attr_name(qos_attr), (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_QOS_STATUS_TYPE_UNKNOWN);
+ } else {
+ switch (qos_attr) {
+ case SDP_ATTR_CURR:
+ return (attr_p->attr.curr.status_type);
+ case SDP_ATTR_DES:
+ return (attr_p->attr.des.status_type);
+ case SDP_ATTR_CONF:
+ return (attr_p->attr.conf.status_type);
+ default:
+ return SDP_QOS_STATUS_TYPE_UNKNOWN;
+
+ }
+ }
+}
+
+/* Function: sdp_attr_get_qos_confirm
+ * Description: Returns the value of the qos attribute confirm
+ * parameter specified for the given attribute. Returns TRUE if
+ * the confirm parameter is specified.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * qos_attr The specific type of qos attribute. May be
+ * qos, secure, X-pc-qos, or X-qos.
+ * inst_num The attribute instance number to check.
+ * Returns: Boolean value.
+ */
+tinybool sdp_attr_get_qos_confirm (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, sdp_attr_e qos_attr, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ if (sdp_validate_qos_attr(qos_attr) == FALSE) {
+ if (sdp_p->debug_flag[SDP_DEBUG_WARNINGS]) {
+ CSFLogDebug(logTag, "%s Warning: Invalid QOS attribute specified "
+ "for get qos confirm.", sdp_p->debug_str);
+ }
+ return (FALSE);
+ }
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, qos_attr, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s %s attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str,
+ sdp_get_attr_name(qos_attr), (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (FALSE);
+ } else {
+ return (attr_p->attr.qos.confirm);
+ }
+}
+
+/* Function: sdp_attr_get_curr_type
+ * Description: Returns the value of the curr attribute status_type
+ * parameter specified for the given attribute. If the given
+ * attribute is not defined, SDP_CURR_UNKNOWN_TYPE is
+ * returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * qos_attr The specific type of qos attribute. May be
+ * qos, secure, X-pc-qos, or X-qos.
+ * inst_num The attribute instance number to check.
+ * Returns: Curr type value.
+ */
+sdp_curr_type_e sdp_attr_get_curr_type (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, sdp_attr_e qos_attr, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, qos_attr, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s %s attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str,
+ sdp_get_attr_name(qos_attr), (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_CURR_UNKNOWN_TYPE);
+ } else {
+ return (attr_p->attr.curr.type);
+ }
+}
+
+/* Function: sdp_attr_get_des_type
+ * Description: Returns the value of the des attribute status_type
+ * parameter specified for the given attribute. If the given
+ * attribute is not defined, SDP_DES_UNKNOWN_TYPE is
+ * returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * qos_attr The specific type of qos attribute. May be
+ * qos, secure, X-pc-qos, or X-qos.
+ * inst_num The attribute instance number to check.
+ * Returns: DES type value.
+ */
+sdp_des_type_e sdp_attr_get_des_type (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, sdp_attr_e qos_attr, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, qos_attr, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s %s attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str,
+ sdp_get_attr_name(qos_attr), (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_DES_UNKNOWN_TYPE);
+ } else {
+ return (attr_p->attr.des.type);
+ }
+}
+
+/* Function: sdp_attr_get_conf_type
+ * Description: Returns the value of the des attribute status_type
+ * parameter specified for the given attribute. If the given
+ * attribute is not defined, SDP_CONF_UNKNOWN_TYPE is
+ * returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * qos_attr The specific type of qos attribute. May be
+ * qos, secure, X-pc-qos, or X-qos.
+ * inst_num The attribute instance number to check.
+ * Returns: CONF type value.
+ */
+sdp_conf_type_e sdp_attr_get_conf_type (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, sdp_attr_e qos_attr, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, qos_attr, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s %s attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str,
+ sdp_get_attr_name(qos_attr), (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_CONF_UNKNOWN_TYPE);
+ } else {
+ return (attr_p->attr.conf.type);
+ }
+}
+
+/* Function: sdp_attr_get_subnet_nettype
+ * Description: Returns the value of the subnet attribute network type
+ * parameter specified for the given attribute. If the given
+ * attribute is not defined, SDP_NT_INVALID is returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Nettype value.
+ */
+sdp_nettype_e sdp_attr_get_subnet_nettype (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SUBNET, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Subnet attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_NT_INVALID);
+ } else {
+ return (attr_p->attr.subnet.nettype);
+ }
+}
+
+/* Function: sdp_attr_get_subnet_addrtype
+ * Description: Returns the value of the subnet attribute address type
+ * parameter specified for the given attribute. If the given
+ * attribute is not defined, SDP_AT_INVALID is returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Addrtype value.
+ */
+sdp_addrtype_e sdp_attr_get_subnet_addrtype (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SUBNET, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Subnet attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_AT_INVALID);
+ } else {
+ return (attr_p->attr.subnet.addrtype);
+ }
+}
+
+/* Function: sdp_attr_get_subnet_addr
+ * Description: Returns the value of the subnet attribute address
+ * parameter specified for the given attribute. If the given
+ * attribute is not defined, NULL is returned. Value is
+ * returned as a const ptr and so cannot be modified by the
+ * application.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Pointer to address or NULL.
+ */
+const char *sdp_attr_get_subnet_addr (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SUBNET, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Subnet attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (NULL);
+ } else {
+ return (attr_p->attr.subnet.addr);
+ }
+}
+
+/* Function: sdp_attr_get_subnet_prefix
+ * Description: Returns the value of the subnet attribute prefix
+ * parameter specified for the given attribute. If the given
+ * attribute is not defined, SDP_INVALID_PARAM is returned.
+ * Note that this is value is defined to be (-2) and is
+ * different from the return code SDP_INVALID_PARAMETER.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Prefix value or SDP_INVALID_PARAM.
+ */
+int32_t sdp_attr_get_subnet_prefix (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SUBNET, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Subnet attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ } else {
+ return (attr_p->attr.subnet.prefix);
+ }
+}
+
+/* Function: sdp_attr_rtpmap_payload_valid
+ * Description: Returns true or false depending on whether an rtpmap
+ * attribute was specified with the given payload value
+ * at the given level. If it was, the instance number of
+ * that attribute is returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number of the attribute
+ * found is returned via this param.
+ * Returns: TRUE or FALSE.
+ */
+tinybool sdp_attr_rtpmap_payload_valid (sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ uint16_t *inst_num, uint16_t payload_type)
+{
+ uint16_t i;
+ sdp_attr_t *attr_p;
+ uint16_t num_instances;
+
+ *inst_num = 0;
+
+ if (sdp_attr_num_instances(sdp_p, level, cap_num,
+ SDP_ATTR_RTPMAP, &num_instances) != SDP_SUCCESS) {
+ return (FALSE);
+ }
+
+ for (i=1; i <= num_instances; i++) {
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_RTPMAP, i);
+ if ((attr_p != NULL) &&
+ (attr_p->attr.transport_map.payload_num == payload_type)) {
+ *inst_num = i;
+ return (TRUE);
+ }
+ }
+
+ return (FALSE);
+}
+
+/* Function: sdp_attr_get_rtpmap_payload_type
+ * Description: Returns the value of the rtpmap attribute payload type
+ * parameter specified for the given attribute. If the given
+ * attribute is not defined, zero is returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Payload type value.
+ */
+uint16_t sdp_attr_get_rtpmap_payload_type (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_RTPMAP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s rtpmap attribute, level %u instance %u "
+ "not found.",
+ sdp_p->debug_str,
+ (unsigned)level,
+ (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ return (attr_p->attr.transport_map.payload_num);
+ }
+}
+
+/* Function: sdp_attr_get_rtpmap_encname
+ * Description: Returns a pointer to the value of the encoding name
+ * parameter specified for the given attribute. Value is
+ * returned as a const ptr and so cannot be modified by the
+ * application. If the given attribute is not defined, NULL
+ * will be returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Codec value or SDP_CODEC_INVALID.
+ */
+const char *sdp_attr_get_rtpmap_encname (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_RTPMAP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s rtpmap attribute, level %u instance %u "
+ "not found.",
+ sdp_p->debug_str,
+ (unsigned)level,
+ (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (NULL);
+ } else {
+ return (attr_p->attr.transport_map.encname);
+ }
+}
+
+/* Function: sdp_attr_get_rtpmap_clockrate
+ * Description: Returns the value of the rtpmap attribute clockrate
+ * parameter specified for the given attribute. If the given
+ * attribute is not defined, zero is returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Clockrate value.
+ */
+uint32_t sdp_attr_get_rtpmap_clockrate (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_RTPMAP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s rtpmap attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ return (attr_p->attr.transport_map.clockrate);
+ }
+}
+
+/* Function: sdp_attr_get_rtpmap_num_chan
+ * Description: Returns the value of the rtpmap attribute num_chan
+ * parameter specified for the given attribute. If the given
+ * attribute is not defined, zero is returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Number of channels param or zero.
+ */
+uint16_t sdp_attr_get_rtpmap_num_chan (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_RTPMAP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s rtpmap attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ return (attr_p->attr.transport_map.num_chan);
+ }
+}
+
+/* Function: sdp_attr_get_ice_attribute
+ * Description: Returns the value of an ice attribute at a given level
+ *
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * ice_attrib Returns an ice attrib string
+ * Returns:
+ * SDP_SUCCESS Attribute param was set successfully.
+ * SDP_INVALID_SDP_PTR SDP pointer invalid
+ * SDP_INVALID_PARAMETER Specified attribute is not defined.
+ */
+
+sdp_result_e sdp_attr_get_ice_attribute (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, sdp_attr_e sdp_attr, uint16_t inst_num,
+ char **out)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, sdp_attr, inst_num);
+ if (attr_p != NULL) {
+ *out = attr_p->attr.ice_attr;
+ return (SDP_SUCCESS);
+ } else {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s ice attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+}
+
+/* Function: sdp_attr_is_present
+ * Description: Returns a boolean value based on attribute being present or
+ * not
+ *
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * attr_type The attribute type.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * Returns:
+ * Boolean value.
+ */
+
+tinybool sdp_attr_is_present (sdp_t *sdp_p, sdp_attr_e attr_type, uint16_t level,
+ uint8_t cap_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, attr_type, 1);
+ if (attr_p != NULL) {
+ return (TRUE);
+ }
+ if (sdp_p->debug_flag[SDP_DEBUG_WARNINGS]) {
+ CSFLogDebug(logTag, "%s Attribute %s, level %u not found.",
+ sdp_p->debug_str, sdp_get_attr_name(attr_type), level);
+ }
+
+ return (FALSE);
+}
+
+
+
+/* Function: sdp_attr_get_rtcp_mux_attribute
+ * Description: Returns the value of an rtcp-mux attribute at a given level
+ *
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * rtcp_mux Returns an rtcp-mux attrib bool
+ * Returns:
+ * SDP_SUCCESS Attribute param was set successfully.
+ * SDP_INVALID_SDP_PTR SDP pointer invalid
+ * SDP_INVALID_PARAMETER Specified attribute is not defined.
+ */
+sdp_result_e sdp_attr_get_rtcp_mux_attribute (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, sdp_attr_e sdp_attr, uint16_t inst_num,
+ tinybool *rtcp_mux)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, sdp_attr, inst_num);
+ if (attr_p != NULL) {
+ *rtcp_mux = attr_p->attr.boolean_val;
+ return (SDP_SUCCESS);
+ } else {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s rtcp-mux attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+}
+
+/* Function: sdp_attr_get_setup_attribute
+ * Description: Returns the value of a setup attribute at a given level
+ *
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * setup_type Returns sdp_setup_type_e enum
+ * Returns:
+ * SDP_SUCCESS Attribute param was set successfully.
+ * SDP_INVALID_SDP_PTR SDP pointer invalid
+ * SDP_INVALID_PARAMETER Specified attribute is not defined.
+ */
+sdp_result_e sdp_attr_get_setup_attribute (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, sdp_setup_type_e *setup_type)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_SETUP, inst_num);
+ if (!attr_p) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag,
+ "%s setup attribute, level %u instance %u not found.",
+ sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_INVALID_PARAMETER;
+ }
+
+ *setup_type = attr_p->attr.setup;
+ return SDP_SUCCESS;
+}
+
+/* Function: sdp_attr_get_connection_attribute
+ * Description: Returns the value of a connection attribute at a given level
+ *
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * connection_type Returns sdp_connection_type_e enum
+ * Returns:
+ * SDP_SUCCESS Attribute param was set successfully.
+ * SDP_INVALID_SDP_PTR SDP pointer invalid
+ * SDP_INVALID_PARAMETER Specified attribute is not defined.
+ */
+sdp_result_e sdp_attr_get_connection_attribute (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, sdp_connection_type_e *connection_type)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_CONNECTION,
+ inst_num);
+ if (!attr_p) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag,
+ "%s setup attribute, level %u instance %u not found.",
+ sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_INVALID_PARAMETER;
+ }
+
+ *connection_type = attr_p->attr.connection;
+ return SDP_SUCCESS;
+}
+
+/* Function: sdp_attr_get_dtls_fingerprint_attribute
+ * Description: Returns the value of dtls fingerprint attribute at a given level
+ *
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * dtls_fingerprint Returns an dtls fingerprint attrib string
+ * Returns:
+ * SDP_SUCCESS Attribute param was set successfully.
+ * SDP_INVALID_SDP_PTR SDP pointer invalid
+ * SDP_INVALID_PARAMETER Specified attribute is not defined.
+ */
+sdp_result_e sdp_attr_get_dtls_fingerprint_attribute (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, sdp_attr_e sdp_attr, uint16_t inst_num,
+ char **out)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, sdp_attr, inst_num);
+ if (attr_p != NULL) {
+ *out = attr_p->attr.string_val;
+ return (SDP_SUCCESS);
+ } else {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s dtls fingerprint attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+}
+
+/* Function: sdp_attr_sprtmap_payload_valid
+ * Description: Returns true or false depending on whether an sprtmap
+ * attribute was specified with the given payload value
+ * at the given level. If it was, the instance number of
+ * that attribute is returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number of the attribute
+ * found is returned via this param.
+ * Returns: TRUE or FALSE.
+ */
+tinybool sdp_attr_sprtmap_payload_valid (sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ uint16_t *inst_num, uint16_t payload_type)
+{
+ uint16_t i;
+ sdp_attr_t *attr_p;
+ uint16_t num_instances;
+
+ *inst_num = 0;
+
+ if (sdp_attr_num_instances(sdp_p, level, cap_num,
+ SDP_ATTR_SPRTMAP, &num_instances) != SDP_SUCCESS) {
+ return (FALSE);
+ }
+
+ for (i=1; i <= num_instances; i++) {
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_SPRTMAP, i);
+ if ((attr_p != NULL) &&
+ (attr_p->attr.transport_map.payload_num == payload_type)) {
+ *inst_num = i;
+ return (TRUE);
+ }
+ }
+
+ return (FALSE);
+}
+
+/* Function: sdp_attr_get_sprtmap_payload_type
+ * Description: Returns the value of the sprtmap attribute payload type
+ * parameter specified for the given attribute. If the given
+ * attribute is not defined, zero is returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Payload type value.
+ */
+uint16_t sdp_attr_get_sprtmap_payload_type (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_SPRTMAP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s sprtmap attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ return (attr_p->attr.transport_map.payload_num);
+ }
+}
+
+/* Function: sdp_attr_get_sprtmap_encname
+ * Description: Returns a pointer to the value of the encoding name
+ * parameter specified for the given attribute. Value is
+ * returned as a const ptr and so cannot be modified by the
+ * application. If the given attribute is not defined, NULL
+ * will be returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Codec value or SDP_CODEC_INVALID.
+ */
+const char *sdp_attr_get_sprtmap_encname (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_SPRTMAP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s sprtmap attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (NULL);
+ } else {
+ return (attr_p->attr.transport_map.encname);
+ }
+}
+
+/* Function: sdp_attr_get_sprtmap_clockrate
+ * Description: Returns the value of the sprtmap attribute clockrate
+ * parameter specified for the given attribute. If the given
+ * attribute is not defined, zero is returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Clockrate value.
+ */
+uint32_t sdp_attr_get_sprtmap_clockrate (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_SPRTMAP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s sprtmap attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ return (attr_p->attr.transport_map.clockrate);
+ }
+}
+
+/* Function: sdp_attr_get_sprtmap_num_chan
+ * Description: Returns the value of the sprtmap attribute num_chan
+ * parameter specified for the given attribute. If the given
+ * attribute is not defined, zero is returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Number of channels param or zero.
+ */
+uint16_t sdp_attr_get_sprtmap_num_chan (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_SPRTMAP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s sprtmap attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ return (attr_p->attr.transport_map.num_chan);
+ }
+}
+
+/* Note: The fmtp attribute formats currently handled are:
+ * fmtp:<payload type> <event>,<event>...
+ * fmtp:<payload_type> [annexa=yes/no] [annexb=yes/no] [bitrate=<value>]
+ * where "value" is a numeric value > 0
+ * where each event is a single number or a range separated
+ * by a '-'.
+ * Example: fmtp:101 1,3-15,20
+ */
+
+/* Function: tinybool sdp_attr_fmtp_valid(sdp_t *sdp_p)
+ * Description: Returns true or false depending on whether an fmtp
+ * attribute was specified with the given payload value
+ * at the given level. If it was, the instance number of
+ * that attribute is returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: TRUE or FALSE.
+ */
+tinybool sdp_attr_fmtp_payload_valid (sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ uint16_t *inst_num, uint16_t payload_type)
+{
+ uint16_t i;
+ sdp_attr_t *attr_p;
+ uint16_t num_instances;
+
+ if (sdp_attr_num_instances(sdp_p, level, cap_num,
+ SDP_ATTR_FMTP, &num_instances) != SDP_SUCCESS) {
+ return (FALSE);
+ }
+
+ for (i=1; i <= num_instances; i++) {
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP, i);
+ if ((attr_p != NULL) &&
+ (attr_p->attr.fmtp.payload_num == payload_type)) {
+ *inst_num = i;
+ return (TRUE);
+ }
+ }
+
+ return (FALSE);
+}
+
+/* Function: sdp_attr_get_fmtp_payload_type
+ * Description: Returns the value of the fmtp attribute payload type
+ * parameter specified for the given attribute. If the given
+ * attribute is not defined, zero is returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Payload type value.
+ */
+uint16_t sdp_attr_get_fmtp_payload_type (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ return (attr_p->attr.fmtp.payload_num);
+ }
+}
+
+
+/* Function: sdp_attr_fmtp_is_range_set
+ * Description: Determines if a range of events is set in an fmtp attribute.
+ * The overall range for events is 0-255.
+ * This will return either FULL_MATCH, PARTIAL_MATCH, or NO_MATCH
+ * depending on whether all, some, or none of the specified
+ * events are defined. If the given attribute is not defined,
+ * NO_MATCH will be returned. It is up to the appl to verify
+ * the validity of the attribute before calling this routine.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * low_val Low value of the range. Range is 0-255.
+ * high_val High value of the range.
+ * Returns: SDP_FULL_MATCH, SDP_PARTIAL_MATCH, SDP_NO_MATCH
+ */
+sdp_ne_res_e sdp_attr_fmtp_is_range_set (sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ uint16_t inst_num, uint8_t low_val, uint8_t high_val)
+{
+ uint16_t i;
+ uint32_t mapword;
+ uint32_t bmap;
+ uint32_t num_vals = 0;
+ uint32_t num_vals_set = 0;
+ sdp_attr_t *attr_p;
+ sdp_fmtp_t *fmtp_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_NO_MATCH);
+ }
+
+ fmtp_p = &(attr_p->attr.fmtp);
+ for (i = low_val; i <= high_val; i++) {
+ num_vals++;
+ mapword = i/SDP_NE_BITS_PER_WORD;
+ bmap = SDP_NE_BIT_0 << (i%32);
+ if (fmtp_p->bmap[ mapword ] & bmap) {
+ num_vals_set++;
+ }
+ }
+
+ if (num_vals == num_vals_set) {
+ return (SDP_FULL_MATCH);
+ } else if (num_vals_set == 0) {
+ return (SDP_NO_MATCH);
+ } else {
+ return (SDP_PARTIAL_MATCH);
+ }
+}
+
+/* Function: sdp_attr_fmtp_valid
+ * Description: Determines the validity of the events in the fmtp.
+ * The overall range for events is 0-255.
+ * The user passes an event list with valid events supported by Appl.
+ * This routine will do a simple AND comparison and report the result.
+ *
+ * This will return TRUE if ftmp events are valid, and FALSE otherwise.
+ * It is up to the appl to verify the validity of the attribute
+ * before calling this routine.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * appl_maxval Max event value supported by Appl. Range is 0-255.
+ * evt_array Bitmap containing events supported by application.
+ * Returns: TRUE, FALSE
+ */
+tinybool
+sdp_attr_fmtp_valid(sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ uint16_t inst_num, uint16_t appl_maxval, uint32_t* evt_array)
+{
+ uint16_t i;
+ uint32_t mapword;
+ sdp_attr_t *attr_p;
+ sdp_fmtp_t *fmtp_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return FALSE;
+ }
+
+ fmtp_p = &(attr_p->attr.fmtp);
+
+ /* Do quick test. If application max value is lower than fmtp's then error */
+ if (fmtp_p->maxval > appl_maxval)
+ return FALSE;
+
+ /* Ok, events are within range. Now check that only
+ * allowed events have been received
+ */
+ mapword = appl_maxval/SDP_NE_BITS_PER_WORD;
+ for (i=0; i<mapword; i++) {
+ if (fmtp_p->bmap[i] & ~(evt_array[i])) {
+ /* Remote SDP is requesting events not supported by Application */
+ return FALSE;
+ }
+ }
+ return TRUE;
+}
+
+/* Function: sdp_attr_set_fmtp_payload_type
+ * Description: Sets the value of the fmtp attribute payload type parameter
+ * for the given attribute.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * payload_type New payload type value.
+ * Returns: SDP_SUCCESS Attribute param was set successfully.
+ * SDP_INVALID_PARAMETER Specified attribute is not defined.
+ */
+sdp_result_e sdp_attr_set_fmtp_payload_type (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ uint16_t payload_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ attr_p->attr.fmtp.payload_num = payload_num;
+ return (SDP_SUCCESS);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_range
+ * Description: Get a range of named events for an fmtp attribute.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * bmap The 8 word data array holding the bitmap
+ * Returns: SDP_SUCCESS
+ */
+sdp_result_e sdp_attr_get_fmtp_range (sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ uint16_t inst_num, uint32_t *bmap)
+{
+ sdp_attr_t *attr_p;
+ sdp_fmtp_t *fmtp_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ fmtp_p = &(attr_p->attr.fmtp);
+ memcpy(bmap, fmtp_p->bmap, SDP_NE_NUM_BMAP_WORDS * sizeof(uint32_t) );
+
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_attr_clear_fmtp_range
+ * Description: Clear a range of named events for an fmtp attribute. The low
+ * value specified must be <= the high value.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * low_val The low value of the range. Range is 0-255
+ * high_val The high value of the range. May be == low.
+ * Returns: SDP_SUCCESS
+ */
+sdp_result_e sdp_attr_clear_fmtp_range (sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ uint16_t inst_num, uint8_t low_val, uint8_t high_val)
+{
+ uint16_t i;
+ uint32_t mapword;
+ uint32_t bmap;
+ sdp_attr_t *attr_p;
+ sdp_fmtp_t *fmtp_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ fmtp_p = &(attr_p->attr.fmtp);
+ for (i = low_val; i <= high_val; i++) {
+ mapword = i/SDP_NE_BITS_PER_WORD;
+ bmap = SDP_NE_BIT_0 << (i%32);
+ fmtp_p->bmap[ mapword ] &= ~bmap;
+ }
+ if (high_val > fmtp_p->maxval) {
+ fmtp_p->maxval = high_val;
+ }
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_attr_compare_fmtp_ranges
+ * Description: Compare the named events set of two fmtp attributes. If all
+ * events are the same (either set or not), FULL_MATCH will be
+ * returned. If no events match, NO_MATCH will be returned.
+ * Otherwise PARTIAL_MATCH will be returned. If either attr is
+ * invalid, NO_MATCH will be returned.
+ * Parameters: src_sdp_p The SDP handle returned by sdp_init_description.
+ * dst_sdp_p The SDP handle returned by sdp_init_description.
+ * src_level The level of the src fmtp attribute.
+ * dst_level The level to the dst fmtp attribute.
+ * src_cap_num The capability number of the src attr.
+ * dst_cap_num The capability number of the dst attr.
+ * src_inst_numh The attribute instance of the src attr.
+ * dst_inst_numh The attribute instance of the dst attr.
+ * Returns: SDP_FULL_MATCH, SDP_PARTIAL_MATCH, SDP_NO_MATCH.
+ */
+sdp_ne_res_e sdp_attr_compare_fmtp_ranges (sdp_t *src_sdp_p,sdp_t *dst_sdp_p,
+ uint16_t src_level, uint16_t dst_level,
+ uint8_t src_cap_num, uint8_t dst_cap_num,
+ uint16_t src_inst_num, uint16_t dst_inst_num)
+{
+ uint16_t i,j;
+ uint32_t bmap;
+ uint32_t num_vals_match = 0;
+ sdp_attr_t *src_attr_p;
+ sdp_attr_t *dst_attr_p;
+ sdp_fmtp_t *src_fmtp_p;
+ sdp_fmtp_t *dst_fmtp_p;
+
+ src_attr_p = sdp_find_attr(src_sdp_p, src_level, src_cap_num,
+ SDP_ATTR_FMTP, src_inst_num);
+ dst_attr_p = sdp_find_attr(dst_sdp_p, dst_level, dst_cap_num,
+ SDP_ATTR_FMTP, dst_inst_num);
+ if ((src_attr_p == NULL) || (dst_attr_p == NULL)) {
+ if (src_sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s source or destination fmtp attribute for "
+ "compare not found.", src_sdp_p->debug_str);
+ }
+ src_sdp_p->conf_p->num_invalid_param++;
+ return (SDP_NO_MATCH);
+ }
+
+ src_fmtp_p = &(src_attr_p->attr.fmtp);
+ dst_fmtp_p = &(dst_attr_p->attr.fmtp);
+ for (i = 0; i < SDP_NE_NUM_BMAP_WORDS; i++) {
+ for (j = 0; j < SDP_NE_BITS_PER_WORD; j++) {
+ bmap = SDP_NE_BIT_0 << j;
+ if ((src_fmtp_p->bmap[i] & bmap) && (dst_fmtp_p->bmap[i] & bmap)) {
+ num_vals_match++;
+ } else if ((!(src_fmtp_p->bmap[i] & bmap)) &&
+ (!(dst_fmtp_p->bmap[i] & bmap))) {
+ num_vals_match++;
+ }
+ }
+ }
+
+ if (num_vals_match == (SDP_NE_NUM_BMAP_WORDS * SDP_NE_BITS_PER_WORD)) {
+ return (SDP_FULL_MATCH);
+ } else if (num_vals_match == 0) {
+ return (SDP_NO_MATCH);
+ } else {
+ return (SDP_PARTIAL_MATCH);
+ }
+}
+
+/* Function: sdp_attr_copy_fmtp_ranges
+ * Description: Copy the named events set for one fmtp attribute to another.
+ * Parameters: src_sdp_p The SDP handle returned by sdp_init_description.
+ * dst_sdp_p The SDP handle returned by sdp_init_description.
+ * src_level The level of the src fmtp attribute.
+ * dst_level The level to the dst fmtp attribute.
+ * src_cap_num The capability number of the src attr.
+ * dst_cap_num The capability number of the dst attr.
+ * src_inst_numh The attribute instance of the src attr.
+ * dst_inst_numh The attribute instance of the dst attr.
+ * Returns: SDP_SUCCESS
+ */
+sdp_result_e sdp_attr_copy_fmtp_ranges (sdp_t *src_sdp_p, sdp_t *dst_sdp_p,
+ uint16_t src_level, uint16_t dst_level,
+ uint8_t src_cap_num, uint8_t dst_cap_num,
+ uint16_t src_inst_num, uint16_t dst_inst_num)
+{
+ uint16_t i;
+ sdp_attr_t *src_attr_p;
+ sdp_attr_t *dst_attr_p;
+ sdp_fmtp_t *src_fmtp_p;
+ sdp_fmtp_t *dst_fmtp_p;
+
+ if (!src_sdp_p || !dst_sdp_p) {
+ return (SDP_INVALID_SDP_PTR);
+ }
+
+ src_attr_p = sdp_find_attr(src_sdp_p, src_level, src_cap_num,
+ SDP_ATTR_FMTP, src_inst_num);
+ dst_attr_p = sdp_find_attr(dst_sdp_p, dst_level, dst_cap_num,
+ SDP_ATTR_FMTP, dst_inst_num);
+ if ((src_attr_p == NULL) || (dst_attr_p == NULL)) {
+ if (src_sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s source or destination fmtp attribute for "
+ "copy not found.", src_sdp_p->debug_str);
+ }
+ src_sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ src_fmtp_p = &(src_attr_p->attr.fmtp);
+ dst_fmtp_p = &(dst_attr_p->attr.fmtp);
+ dst_fmtp_p->maxval = src_fmtp_p->maxval;
+ for (i = 0; i < SDP_NE_NUM_BMAP_WORDS; i++) {
+ dst_fmtp_p->bmap[i] = src_fmtp_p->bmap[i];
+ }
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_attr_get_fmtp_mode
+ * Description: Gets the value of the fmtp attribute mode parameter
+ * for the given attribute.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * payload_type payload type.
+ * Returns: mode value or zero if mode attribute not found
+ */
+uint32_t sdp_attr_get_fmtp_mode_for_payload_type (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint32_t payload_type)
+{
+ uint16_t num_a_lines = 0;
+ int i;
+ sdp_attr_t *attr_p;
+
+ /*
+ * Get number of FMTP attributes for the AUDIO line
+ */
+ (void) sdp_attr_num_instances(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ &num_a_lines);
+ for (i = 0; i < num_a_lines; i++) {
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP, (uint16_t) (i + 1));
+ if ((attr_p != NULL) &&
+ (attr_p->attr.fmtp.payload_num == (uint16_t)payload_type)) {
+ if (attr_p->attr.fmtp.fmtp_format == SDP_FMTP_MODE) {
+ return attr_p->attr.fmtp.mode;
+ }
+ }
+ }
+ return 0;
+}
+
+sdp_result_e sdp_attr_set_fmtp_max_fs (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ uint32_t max_fs)
+{
+ sdp_attr_t *attr_p;
+ sdp_fmtp_t *fmtp_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ fmtp_p = &(attr_p->attr.fmtp);
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+
+ if (max_fs > 0) {
+ fmtp_p->max_fs = max_fs;
+ return (SDP_SUCCESS);
+ } else {
+ return (SDP_FAILURE);
+ }
+}
+
+sdp_result_e sdp_attr_set_fmtp_max_fr (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ uint32_t max_fr)
+{
+ sdp_attr_t *attr_p;
+ sdp_fmtp_t *fmtp_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ fmtp_p = &(attr_p->attr.fmtp);
+ fmtp_p->fmtp_format = SDP_FMTP_CODEC_INFO;
+
+ if (max_fr > 0) {
+ fmtp_p->max_fr = max_fr;
+ return (SDP_SUCCESS);
+ } else {
+ return (SDP_FAILURE);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_max_average_bitrate
+ * Description: Gets the value of the fmtp attribute- maxaveragebitrate parameter for the OPUS codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: max-br value.
+ */
+
+sdp_result_e sdp_attr_get_fmtp_max_average_bitrate (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint32_t* val)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP, 1);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ *val = attr_p->attr.fmtp.maxaveragebitrate;
+ return (SDP_SUCCESS);
+ }
+}
+
+
+/* Function: sdp_attr_get_fmtp_usedtx
+ * Description: Gets the value of the fmtp attribute- usedtx parameter for the OPUS codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: usedtx value.
+ */
+
+sdp_result_e sdp_attr_get_fmtp_usedtx (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, tinybool* val)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ *val = (tinybool)attr_p->attr.fmtp.usedtx;
+ return (SDP_SUCCESS);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_usedtx
+ * Description: Gets the value of the fmtp attribute- usedtx parameter for the OPUS codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: stereo value.
+ */
+
+sdp_result_e sdp_attr_get_fmtp_stereo (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, tinybool* val)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ *val = (tinybool)attr_p->attr.fmtp.stereo;
+ return (SDP_SUCCESS);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_useinbandfec
+ * Description: Gets the value of the fmtp attribute useinbandfec parameter for the OPUS codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: useinbandfec value.
+ */
+
+sdp_result_e sdp_attr_get_fmtp_useinbandfec (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, tinybool* val)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ *val = (tinybool)attr_p->attr.fmtp.useinbandfec;
+ return (SDP_SUCCESS);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_maxcodedaudiobandwidth
+ * Description: Gets the value of the fmtp attribute maxcodedaudiobandwidth parameter for OPUS codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: maxcodedaudiobandwidth value.
+ */
+char* sdp_attr_get_fmtp_maxcodedaudiobandwidth (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ return (attr_p->attr.fmtp.maxcodedaudiobandwidth);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_cbr
+ * Description: Gets the value of the fmtp attribute cbr parameter for the OPUS codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: cbr value.
+ */
+
+sdp_result_e sdp_attr_get_fmtp_cbr (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, tinybool* val)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ *val = (tinybool)attr_p->attr.fmtp.cbr;
+ return (SDP_SUCCESS);
+ }
+}
+
+uint16_t sdp_attr_get_sctpmap_port(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_SCTPMAP, inst_num);
+ if (!attr_p) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s sctpmap port, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return 0;
+ } else {
+ return attr_p->attr.sctpmap.port;
+ }
+}
+
+sdp_result_e sdp_attr_get_sctpmap_streams (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint32_t* val)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_SCTPMAP, inst_num);
+ if (!attr_p) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s sctpmap streams, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ *val = attr_p->attr.sctpmap.streams;
+ return (SDP_SUCCESS);
+ }
+}
+
+sdp_result_e sdp_attr_get_sctpmap_protocol (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ char* protocol)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_SCTPMAP,
+ inst_num);
+ if (!attr_p) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s sctpmap, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ sstrncpy(protocol, attr_p->attr.sctpmap.protocol, SDP_MAX_STRING_LEN+1);
+ }
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_attr_fmtp_is_annexb_set
+ * Description: Gives the value of the fmtp attribute annexb type parameter
+ * for the given attribute.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ *
+ *
+ * Returns: TRUE or FALSE.
+ */
+tinybool sdp_attr_fmtp_is_annexb_set (sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (FALSE);
+ } else {
+ return (attr_p->attr.fmtp.annexb);
+ }
+}
+
+/* Function: sdp_attr_fmtp_is_annexa_set
+ * Description: Gives the value of the fmtp attribute annexa type parameter
+ * for the given attribute.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ *
+ *
+ * Returns: TRUE or FALSE.
+ */
+tinybool sdp_attr_fmtp_is_annexa_set (sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (FALSE);
+ } else {
+ return (attr_p->attr.fmtp.annexa);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_bitrate_type
+ * Description: Gets the value of the fmtp attribute bitrate type parameter
+ * for the given attribute.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Bitrate type value.
+ */
+int32_t sdp_attr_get_fmtp_bitrate_type (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ } else {
+ return (attr_p->attr.fmtp.bitrate);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_qcif
+ * Description: Gets the value of the fmtp attribute QCIF type parameter
+ * for a given Video codec.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: QCIF value.
+ */
+int32_t sdp_attr_get_fmtp_qcif (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ } else {
+ return (attr_p->attr.fmtp.qcif);
+ }
+}
+/* Function: sdp_attr_get_fmtp_cif
+ * Description: Gets the value of the fmtp attribute CIF type parameter
+ * for a given Video codec.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: CIF value.
+ */
+int32_t sdp_attr_get_fmtp_cif (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ } else {
+ return (attr_p->attr.fmtp.cif);
+ }
+}
+
+
+/* Function: sdp_attr_get_fmtp_sqcif
+ * Description: Gets the value of the fmtp attribute sqcif type parameter
+ * for a given Video codec.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: sqcif value.
+ */
+int32_t sdp_attr_get_fmtp_sqcif (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ } else {
+ return (attr_p->attr.fmtp.sqcif);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_cif4
+ * Description: Gets the value of the fmtp attribute CIF4 type parameter
+ * for a given Video codec.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: CIF4 value.
+ */
+int32_t sdp_attr_get_fmtp_cif4 (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ } else {
+ return (attr_p->attr.fmtp.cif4);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_cif16
+ * Description: Gets the value of the fmtp attribute CIF16 type parameter
+ * for a given Video codec.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: CIF16 value.
+ */
+
+int32_t sdp_attr_get_fmtp_cif16 (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ } else {
+ return (attr_p->attr.fmtp.cif16);
+ }
+}
+
+
+/* Function: sdp_attr_get_fmtp_maxbr
+ * Description: Gets the value of the fmtp attribute MAXBR type parameter
+ * for a given Video codec.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: MAXBR value.
+ */
+int32_t sdp_attr_get_fmtp_maxbr (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ } else {
+ return (attr_p->attr.fmtp.maxbr);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_custom_x
+ * Description: Gets the value of the fmtp attribute CUSTOM type parameter
+ * for a given Video codec.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: CUSTOM x value.
+ */
+
+int32_t sdp_attr_get_fmtp_custom_x (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ } else {
+ return (attr_p->attr.fmtp.custom_x);
+ }
+}
+/* Function: sdp_attr_get_fmtp_custom_y
+ * Description: Gets the value of the fmtp attribute custom_y type parameter
+ * for a given Video codec.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: CUSTOM Y-AXIS value.
+ */
+
+int32_t sdp_attr_get_fmtp_custom_y (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ } else {
+ return (attr_p->attr.fmtp.custom_y);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_custom_mpi
+ * Description: Gets the value of the fmtp attribute CUSTOM type parameter
+ * for a given Video codec.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: CUSTOM MPI value.
+ */
+
+int32_t sdp_attr_get_fmtp_custom_mpi (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ } else {
+ return (attr_p->attr.fmtp.custom_mpi);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_par_width
+ * Description: Gets the value of the fmtp attribute PAR (width) parameter
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: PAR - width value.
+ */
+int32_t sdp_attr_get_fmtp_par_width (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ } else {
+ return (attr_p->attr.fmtp.par_width);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_par_height
+ * Description: Gets the value of the fmtp attribute PAR (height) parameter
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: PAR - height value.
+ */
+int32_t sdp_attr_get_fmtp_par_height (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ } else {
+ return (attr_p->attr.fmtp.par_height);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_cpcf
+ * Description: Gets the value of the fmtp attribute- CPCF parameter
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: CPCF value.
+ */
+int32_t sdp_attr_get_fmtp_cpcf (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ } else {
+ return (attr_p->attr.fmtp.cpcf);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_bpp
+ * Description: Gets the value of the fmtp attribute- BPP parameter
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: BPP value.
+ */
+int32_t sdp_attr_get_fmtp_bpp (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ } else {
+ return (attr_p->attr.fmtp.bpp);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_hrd
+ * Description: Gets the value of the fmtp attribute- HRD parameter
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: HRD value.
+ */
+int32_t sdp_attr_get_fmtp_hrd (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ } else {
+ return (attr_p->attr.fmtp.hrd);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_profile
+ * Description: Gets the value of the fmtp attribute- PROFILE parameter
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: PROFILE value.
+ */
+int32_t sdp_attr_get_fmtp_profile (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ } else {
+ return (attr_p->attr.fmtp.profile);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_level
+ * Description: Gets the value of the fmtp attribute- LEVEL parameter
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: LEVEL value.
+ */
+int32_t sdp_attr_get_fmtp_level (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ } else {
+ return (attr_p->attr.fmtp.level);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_interlace
+ * Description: Checks if INTERLACE parameter is set.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: TRUE if INTERLACE is present and FALSE if INTERLACE is absent.
+ */
+tinybool sdp_attr_get_fmtp_interlace (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return FALSE;
+ } else {
+ return (attr_p->attr.fmtp.is_interlace);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_pack_mode
+ * Description: Gets the value of the fmtp attribute- packetization-mode parameter for H.264 codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: packetization-mode value in the range 0 - 2.
+ */
+
+sdp_result_e sdp_attr_get_fmtp_pack_mode (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint16_t *val)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ if (SDP_INVALID_PACKETIZATION_MODE_VALUE == attr_p->attr.fmtp.packetization_mode) {
+ /* packetization mode unspecified (optional) */
+ *val = SDP_DEFAULT_PACKETIZATION_MODE_VALUE;
+ } else {
+ *val = attr_p->attr.fmtp.packetization_mode;
+ }
+ return (SDP_SUCCESS);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_level_asymmetry_allowed
+ * Description: Gets the value of the fmtp attribute- level-asymmetry-allowed parameter for H.264 codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: level asymmetry allowed value (0 or 1).
+ */
+
+sdp_result_e sdp_attr_get_fmtp_level_asymmetry_allowed (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint16_t *val)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ *val = attr_p->attr.fmtp.level_asymmetry_allowed;
+ return (SDP_SUCCESS);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_profile_id
+ * Description: Gets the value of the fmtp attribute- profile-level-id parameter for H.264 codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: profile-level-id value.
+ */
+const char* sdp_attr_get_fmtp_profile_id (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ return (attr_p->attr.fmtp.profile_level_id);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_param_sets
+ * Description: Gets the value of the fmtp attribute- parameter-sets parameter for H.264 codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: parameter-sets value.
+ */
+const char* sdp_attr_get_fmtp_param_sets (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ return (attr_p->attr.fmtp.parameter_sets);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_interleaving_depth
+ * Description: Gets the value of the fmtp attribute- interleaving_depth parameter for H.264 codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: interleaving_depth value
+ */
+
+sdp_result_e sdp_attr_get_fmtp_interleaving_depth (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint16_t* val)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ *val = attr_p->attr.fmtp.interleaving_depth;
+ return (SDP_SUCCESS);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_deint_buf_req
+ * Description: Gets the value of the fmtp attribute- deint-buf-req parameter for H.264 codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: deint-buf-req value.
+ */
+
+sdp_result_e sdp_attr_get_fmtp_deint_buf_req (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ uint32_t *val)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ if (attr_p->attr.fmtp.flag & SDP_DEINT_BUF_REQ_FLAG) {
+ *val = attr_p->attr.fmtp.deint_buf_req;
+ return (SDP_SUCCESS);
+ } else {
+ return (SDP_FAILURE);
+ }
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_max_don_diff
+ * Description: Gets the value of the fmtp attribute- max-don-diff parameter for H.264 codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: max-don-diff value.
+ */
+sdp_result_e sdp_attr_get_fmtp_max_don_diff (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ uint32_t *val)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ *val = attr_p->attr.fmtp.max_don_diff;
+ return (SDP_SUCCESS);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_init_buf_time
+ * Description: Gets the value of the fmtp attribute- init-buf-time parameter for H.264 codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: init-buf-time value.
+ */
+sdp_result_e sdp_attr_get_fmtp_init_buf_time (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ uint32_t *val)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ if (attr_p->attr.fmtp.flag & SDP_INIT_BUF_TIME_FLAG) {
+ *val = attr_p->attr.fmtp.init_buf_time;
+ return (SDP_SUCCESS);
+ } else {
+ return (SDP_FAILURE);
+ }
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_max_mbps
+ * Description: Gets the value of the fmtp attribute- max-mbps parameter for H.264 codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: max-mbps value.
+ */
+
+sdp_result_e sdp_attr_get_fmtp_max_mbps (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ uint32_t *val)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ *val = attr_p->attr.fmtp.max_mbps;
+ return (SDP_SUCCESS);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_max_fs
+ * Description: Gets the value of the fmtp attribute- max-fs parameter for H.264 codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: max-fs value.
+ */
+
+sdp_result_e sdp_attr_get_fmtp_max_fs (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint32_t *val)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ *val = attr_p->attr.fmtp.max_fs;
+ return (SDP_SUCCESS);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_max_fr
+ * Description: Gets the value of the fmtp attribute- max-fr parameter
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: max-fr value.
+ */
+
+sdp_result_e sdp_attr_get_fmtp_max_fr (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint32_t *val)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ *val = attr_p->attr.fmtp.max_fr;
+ return (SDP_SUCCESS);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_max_cpb
+ * Description: Gets the value of the fmtp attribute- max-cpb parameter for H.264 codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: max-cpb value.
+ */
+
+sdp_result_e sdp_attr_get_fmtp_max_cpb (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint32_t *val)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ *val = attr_p->attr.fmtp.max_cpb;
+ return (SDP_SUCCESS);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_max_dpb
+ * Description: Gets the value of the fmtp attribute- max-dpb parameter for H.264 codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: max-dpb value.
+ */
+
+sdp_result_e sdp_attr_get_fmtp_max_dpb (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint32_t *val)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ *val = attr_p->attr.fmtp.max_dpb;
+ return (SDP_SUCCESS);
+ }
+}
+
+
+/* Function: sdp_attr_get_fmtp_max_br
+ * Description: Gets the value of the fmtp attribute- max-br parameter for H.264 codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: max-br value.
+ */
+
+sdp_result_e sdp_attr_get_fmtp_max_br (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint32_t* val)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ *val = attr_p->attr.fmtp.max_br;
+ return (SDP_SUCCESS);
+ }
+}
+
+/* Function: sdp_attr_fmtp_is_redundant_pic_cap
+ * Description: Gets the value of the fmtp attribute- redundant_pic_cap parameter for H.264 codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: redundant-pic-cap value.
+ */
+tinybool sdp_attr_fmtp_is_redundant_pic_cap (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (FALSE);
+ } else {
+ return (attr_p->attr.fmtp.redundant_pic_cap);
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_deint_buf_cap
+ * Description: Gets the value of the fmtp attribute- deint-buf-cap parameter for H.264 codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: deint-buf-cap value.
+ */
+
+sdp_result_e sdp_attr_get_fmtp_deint_buf_cap (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ uint32_t *val)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ if (attr_p->attr.fmtp.flag & SDP_DEINT_BUF_CAP_FLAG) {
+ *val = attr_p->attr.fmtp.deint_buf_cap;
+ return (SDP_SUCCESS);
+ } else {
+ return (SDP_FAILURE);
+ }
+ }
+}
+
+/* Function: sdp_attr_get_fmtp_max_rcmd_nalu_size
+ * Description: Gets the value of the fmtp attribute- max-rcmd-nalu-size parameter for H.264 codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: max-rcmd-nalu-size value.
+ */
+sdp_result_e sdp_attr_get_fmtp_max_rcmd_nalu_size (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ uint32_t *val)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ if (attr_p->attr.fmtp.flag & SDP_MAX_RCMD_NALU_SIZE_FLAG) {
+ *val = attr_p->attr.fmtp.max_rcmd_nalu_size;
+ return (SDP_SUCCESS);
+ } else {
+ return (SDP_FAILURE);
+ }
+ }
+}
+
+/* Function: sdp_attr_fmtp_is_parameter_add
+ * Description: Gets the value of the fmtp attribute- parameter-add for H.264 codec
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: TRUE/FALSE ( parameter-add is boolean)
+ */
+tinybool sdp_attr_fmtp_is_parameter_add (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (FALSE);
+ } else {
+ /* Both 1 and SDP_FMTP_UNUSED (parameter not present) should be
+ * treated as TRUE, per RFC 3984, page 45 */
+ return (attr_p->attr.fmtp.parameter_add != 0);
+ }
+}
+
+/****** Following functions are get routines for Annex values
+ * For each Annex support, the get routine will return the boolean TRUE/FALSE
+ * Some Annexures for Video codecs have values defined . In those cases,
+ * (e.g Annex K, P ) , the return values are not boolean.
+ *
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Annex value
+ */
+
+tinybool sdp_attr_get_fmtp_annex_d (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (FALSE);
+ } else {
+ return (attr_p->attr.fmtp.annex_d);
+ }
+}
+
+tinybool sdp_attr_get_fmtp_annex_f (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (FALSE);
+ } else {
+ return (attr_p->attr.fmtp.annex_f);
+ }
+}
+
+tinybool sdp_attr_get_fmtp_annex_i (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (FALSE);
+ } else {
+ return (attr_p->attr.fmtp.annex_i);
+ }
+}
+
+tinybool sdp_attr_get_fmtp_annex_j (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (FALSE);
+ } else {
+ return (attr_p->attr.fmtp.annex_j);
+ }
+}
+
+tinybool sdp_attr_get_fmtp_annex_t (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (FALSE);
+ } else {
+ return (attr_p->attr.fmtp.annex_t);
+ }
+}
+
+int32_t sdp_attr_get_fmtp_annex_k_val (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ } else {
+ return (attr_p->attr.fmtp.annex_k_val);
+ }
+}
+
+int32_t sdp_attr_get_fmtp_annex_n_val (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ } else {
+ return (attr_p->attr.fmtp.annex_n_val);
+ }
+}
+
+int32_t sdp_attr_get_fmtp_annex_p_picture_resize (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ } else {
+ return (attr_p->attr.fmtp.annex_p_val_picture_resize);
+ }
+}
+
+int32_t sdp_attr_get_fmtp_annex_p_warp (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ } else {
+ return (attr_p->attr.fmtp.annex_p_val_warp);
+ }
+}
+
+/* Function: sdp_attr_fmtp_get_fmtp_format
+ * Description: Gives the value of the fmtp attribute fmtp_format
+ * type parameter
+ * for the given attribute.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ *
+ *
+ * Returns: Enum type sdp_fmtp_format_type_e
+ */
+sdp_fmtp_format_type_e sdp_attr_fmtp_get_fmtp_format (sdp_t *sdp_p,
+ uint16_t level, uint8_t cap_num,
+ uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_FMTP,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s fmtp attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_FMTP_UNKNOWN_TYPE);
+ } else {
+ return (attr_p->attr.fmtp.fmtp_format);
+ }
+}
+
+/* Function: sdp_attr_get_pccodec_num_payload_types
+ * Description: Returns the number of payload types specified for the
+ * given X-pc-codec attribute. If the given attribute is not
+ * defined, zero is returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Number of payload types.
+ */
+uint16_t sdp_attr_get_pccodec_num_payload_types (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_X_PC_CODEC,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s X-pc-codec attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ return (attr_p->attr.pccodec.num_payloads);
+ }
+}
+
+/* Function: sdp_attr_get_pccodec_payload_type
+ * Description: Returns the value of the specified payload type for the
+ * given X-pc-codec attribute. If the given attribute is not
+ * defined, zero is returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * payload_num The payload number to get. Range is (1 -
+ * max num payloads).
+ * Returns: Payload type.
+ */
+uint16_t sdp_attr_get_pccodec_payload_type (sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ uint16_t inst_num, uint16_t payload_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_X_PC_CODEC,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s X-pc-codec attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ if ((payload_num < 1) ||
+ (payload_num > attr_p->attr.pccodec.num_payloads)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s X-pc-codec attribute, level %u instance %u, "
+ "invalid payload number %u requested.",
+ sdp_p->debug_str, (unsigned)level, (unsigned)inst_num, (unsigned)payload_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ return (attr_p->attr.pccodec.payload_type[payload_num-1]);
+ }
+ }
+}
+
+/* Function: sdp_attr_add_pccodec_payload_type
+ * Description: Add a new value to the list of payload types specified for
+ * the given X-pc-codec attribute. The payload type will be
+ * added to the end of the list so these values should be added
+ * in the order they will be displayed within the attribute.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * payload_type The payload type to add.
+ * Returns: SDP_SUCCESS Payload type was added successfully.
+ * SDP_INVALID_PARAMETER Specified attribute is not defined.
+ */
+sdp_result_e sdp_attr_add_pccodec_payload_type (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ uint16_t payload_type)
+{
+ uint16_t payload_num;
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_X_PC_CODEC,
+ inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s X-pc-codec attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ payload_num = attr_p->attr.pccodec.num_payloads++;
+ attr_p->attr.pccodec.payload_type[payload_num] = payload_type;
+ return (SDP_SUCCESS);
+ }
+}
+
+/* Function: sdp_attr_get_xcap_first_cap_num
+ * Description: Gets the first capability number valid for the specified
+ * X-cap attribute instance. If the capability is not
+ * defined, zero is returned.
+ * Note: cap_num is not specified. It must be zero.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the capability.
+ * inst_num The X-cap instance number to check.
+ * Returns: Capability number or zero.
+ */
+uint16_t sdp_attr_get_xcap_first_cap_num (sdp_t *sdp_p, uint16_t level, uint16_t inst_num)
+{
+ uint16_t cap_num=1;
+ uint16_t attr_count=0;
+ sdp_attr_t *attr_p;
+ sdp_mca_t *mca_p;
+
+ if (level == SDP_SESSION_LEVEL) {
+ for (attr_p = sdp_p->sess_attrs_p; attr_p != NULL;
+ attr_p = attr_p->next_p) {
+ if (attr_p->type == SDP_ATTR_X_CAP) {
+ attr_count++;
+ if (attr_count == inst_num) {
+ return (cap_num);
+ } else {
+ cap_num += attr_p->attr.cap_p->num_payloads;
+ }
+ }
+ }
+ } else { /* Capability is at a media level */
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ }
+ for (attr_p = mca_p->media_attrs_p; attr_p != NULL;
+ attr_p = attr_p->next_p) {
+ if (attr_p->type == SDP_ATTR_X_CAP) {
+ attr_count++;
+ if (attr_count == inst_num) {
+ return (cap_num);
+ } else {
+ cap_num += attr_p->attr.cap_p->num_payloads;
+ }
+ }
+ }
+ } /* Attr is at a media level */
+
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s X-cap attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+}
+
+/* Function: sdp_attr_get_xcap_media_type
+ * Description: Returns the media type specified for the given X-cap
+ * attribute. If the given attribute is not defined,
+ * SDP_MEDIA_INVALID is returned.
+ * Note: cap_num is not specified. It must be zero.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * inst_num The attribute instance number to check.
+ * Returns: Media type or SDP_MEDIA_INVALID.
+ */
+sdp_media_e sdp_attr_get_xcap_media_type (sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+ sdp_mca_t *cap_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, 0, SDP_ATTR_X_CAP, inst_num);
+ if ((attr_p == NULL) || (attr_p->attr.cap_p == NULL)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s X-cap attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_MEDIA_INVALID);
+ } else {
+ cap_p = attr_p->attr.cap_p;
+ return (cap_p->media);
+ }
+}
+
+/* Function: sdp_attr_get_xcap_transport_type
+ * Description: Returns the transport type specified for the given X-cap
+ * attribute. If the given attribute is not defined,
+ * SDP_TRANSPORT_INVALID is returned.
+ * Note: cap_num is not specified. It must be zero.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * inst_num The attribute instance number to check.
+ * Returns: Media type or SDP_TRANSPORT_INVALID.
+ */
+sdp_transport_e sdp_attr_get_xcap_transport_type (sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+ sdp_mca_t *cap_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, 0, SDP_ATTR_X_CAP,
+ inst_num);
+ if ((attr_p == NULL) || (attr_p->attr.cap_p == NULL)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s X-cap attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_TRANSPORT_INVALID);
+ } else {
+ cap_p = attr_p->attr.cap_p;
+ return (cap_p->transport);
+ }
+}
+
+/* Function: sdp_attr_get_xcap_num_payload_types
+ * Description: Returns the number of payload types associated with the
+ * specified X-cap attribute. If the attribute is invalid,
+ * zero will be returned. Application must validate the
+ * attribute line before using this routine.
+ * Note: cap_num is not specified. It must be zero.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Number of payload types or zero.
+ */
+uint16_t sdp_attr_get_xcap_num_payload_types (sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+ sdp_mca_t *cap_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, 0, SDP_ATTR_X_CAP, inst_num);
+ if ((attr_p == NULL) || (attr_p->attr.cap_p == NULL)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s X-cap attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ cap_p = attr_p->attr.cap_p;
+ return (cap_p->num_payloads);
+ }
+}
+
+/* Function: sdp_attr_get_xcap_payload_type
+ * Description: Returns the payload type of the specified payload for the
+ * X-cap attribute line. If the attr line or payload number is
+ * invalid, zero will be returned. Application must validate
+ * the X-cap attr before using this routine.
+ * Note: cap_num is not specified. It must be zero.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * inst_num The attribute instance number to check.
+ * payload_num The payload number to retrieve. Range is
+ * (1 - max num payloads).
+ * Returns: Payload type or zero.
+ */
+uint16_t sdp_attr_get_xcap_payload_type (sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num, uint16_t payload_num,
+ sdp_payload_ind_e *indicator)
+{
+ sdp_attr_t *attr_p;
+ sdp_mca_t *cap_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, 0, SDP_ATTR_X_CAP, inst_num);
+ if ((attr_p == NULL) || (attr_p->attr.cap_p == NULL)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s X-cap attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ cap_p = attr_p->attr.cap_p;
+ if ((payload_num < 1) ||
+ (payload_num > cap_p->num_payloads)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s X-cap attribute, level %u instance %u, "
+ "payload num %u invalid.", sdp_p->debug_str,
+ (unsigned)level, (unsigned)inst_num, (unsigned)payload_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ *indicator = cap_p->payload_indicator[payload_num-1];
+ return (cap_p->payload_type[payload_num-1]);
+ }
+ }
+}
+
+
+/* Function: sdp_attr_add_xcap_payload_type
+ * Description: Add a new payload type for the X-cap attribute line
+ * specified. The new payload type will be added at the end
+ * of the payload type list.
+ * Note: cap_num is not specified. It must be zero.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * inst_num The attribute instance number to check.
+ * payload_type The new payload type.
+ * Returns: SDP_SUCCESS or SDP_INVALID_PARAMETER
+ */
+sdp_result_e sdp_attr_add_xcap_payload_type(sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num, uint16_t payload_type,
+ sdp_payload_ind_e indicator)
+{
+ sdp_attr_t *attr_p;
+ sdp_mca_t *cap_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, 0, SDP_ATTR_X_CAP, inst_num);
+ if ((attr_p == NULL) || (attr_p->attr.cap_p == NULL)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s X-cap attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ cap_p = attr_p->attr.cap_p;
+ cap_p->payload_indicator[cap_p->num_payloads] = indicator;
+ cap_p->payload_type[cap_p->num_payloads++] = payload_type;
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_attr_get_cdsc_first_cap_num
+ * Description: Gets the first capability number valid for the specified
+ * CDSC attribute instance. If the capability is not
+ * defined, zero is returned.
+ * Note: cap_num is not specified. It must be zero.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the capability.
+ * inst_num The CDSC instance number to check.
+ * Returns: Capability number or zero.
+ */
+uint16_t sdp_attr_get_cdsc_first_cap_num(sdp_t *sdp_p, uint16_t level, uint16_t inst_num)
+{
+ uint16_t cap_num=1;
+ uint16_t attr_count=0;
+ sdp_attr_t *attr_p;
+ sdp_mca_t *mca_p;
+
+ if (level == SDP_SESSION_LEVEL) {
+ for (attr_p = sdp_p->sess_attrs_p; attr_p != NULL;
+ attr_p = attr_p->next_p) {
+ if (attr_p->type == SDP_ATTR_CDSC) {
+ attr_count++;
+ if (attr_count == inst_num) {
+ return (cap_num);
+ } else {
+ cap_num += attr_p->attr.cap_p->num_payloads;
+ }
+ }
+ }
+ } else { /* Capability is at a media level */
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ }
+ for (attr_p = mca_p->media_attrs_p; attr_p != NULL;
+ attr_p = attr_p->next_p) {
+ if (attr_p->type == SDP_ATTR_CDSC) {
+ attr_count++;
+ if (attr_count == inst_num) {
+ return (cap_num);
+ } else {
+ cap_num += attr_p->attr.cap_p->num_payloads;
+ }
+ }
+ }
+ } /* Attr is at a media level */
+
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s CDSC attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+}
+
+/* Function: sdp_attr_get_cdsc_media_type
+ * Description: Returns the media type specified for the given CDSC
+ * attribute. If the given attribute is not defined,
+ * SDP_MEDIA_INVALID is returned.
+ * Note: cap_num is not specified. It must be zero.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * inst_num The attribute instance number to check.
+ * Returns: Media type or SDP_MEDIA_INVALID.
+ */
+sdp_media_e sdp_attr_get_cdsc_media_type(sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+ sdp_mca_t *cdsc_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, 0, SDP_ATTR_CDSC, inst_num);
+ if ((attr_p == NULL) || (attr_p->attr.cap_p == NULL)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s CDSC attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_MEDIA_INVALID);
+ } else {
+ cdsc_p = attr_p->attr.cap_p;
+ return (cdsc_p->media);
+ }
+}
+
+/* Function: sdp_attr_get_cdsc_transport_type
+ * Description: Returns the transport type specified for the given CDSC
+ * attribute. If the given attribute is not defined,
+ * SDP_TRANSPORT_INVALID is returned.
+ * Note: cap_num is not specified. It must be zero.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * inst_num The attribute instance number to check.
+ * Returns: Media type or SDP_TRANSPORT_INVALID.
+ */
+sdp_transport_e sdp_attr_get_cdsc_transport_type(sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+ sdp_mca_t *cdsc_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, 0, SDP_ATTR_CDSC,
+ inst_num);
+ if ((attr_p == NULL) || (attr_p->attr.cap_p == NULL)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s CDSC attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_TRANSPORT_INVALID);
+ } else {
+ cdsc_p = attr_p->attr.cap_p;
+ return (cdsc_p->transport);
+ }
+}
+
+/* Function: sdp_attr_get_cdsc_num_payload_types
+ * Description: Returns the number of payload types associated with the
+ * specified CDSC attribute. If the attribute is invalid,
+ * zero will be returned. Application must validate the
+ * attribute line before using this routine.
+ * Note: cap_num is not specified. It must be zero.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Number of payload types or zero.
+ */
+uint16_t sdp_attr_get_cdsc_num_payload_types (sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+ sdp_mca_t *cdsc_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, 0, SDP_ATTR_CDSC, inst_num);
+ if ((attr_p == NULL) || (attr_p->attr.cap_p == NULL)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s CDSC attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ cdsc_p = attr_p->attr.cap_p;
+ return (cdsc_p->num_payloads);
+ }
+}
+
+/* Function: sdp_attr_get_cdsc_payload_type
+ * Description: Returns the payload type of the specified payload for the
+ * CDSC attribute line. If the attr line or payload number is
+ * invalid, zero will be returned. Application must validate
+ * the CDSC attr before using this routine.
+ * Note: cap_num is not specified. It must be zero.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * inst_num The attribute instance number to check.
+ * payload_num The payload number to retrieve. Range is
+ * (1 - max num payloads).
+ * Returns: Payload type or zero.
+ */
+uint16_t sdp_attr_get_cdsc_payload_type (sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num, uint16_t payload_num,
+ sdp_payload_ind_e *indicator)
+{
+ sdp_attr_t *attr_p;
+ sdp_mca_t *cdsc_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, 0, SDP_ATTR_CDSC, inst_num);
+ if ((attr_p == NULL) || (attr_p->attr.cap_p == NULL)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s CDSC attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ cdsc_p = attr_p->attr.cap_p;
+ if ((payload_num < 1) ||
+ (payload_num > cdsc_p->num_payloads)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s CDSC attribute, level %u instance %u, "
+ "payload num %u invalid.", sdp_p->debug_str,
+ (unsigned)level, (unsigned)inst_num, (unsigned)payload_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ *indicator = cdsc_p->payload_indicator[payload_num-1];
+ return (cdsc_p->payload_type[payload_num-1]);
+ }
+ }
+}
+
+/* Function: sdp_attr_add_cdsc_payload_type
+ * Description: Add a new payload type for the CDSC attribute line
+ * specified. The new payload type will be added at the end
+ * of the payload type list.
+ * Note: cap_num is not specified. It must be zero.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * inst_num The attribute instance number to check.
+ * payload_type The new payload type.
+ * Returns: SDP_SUCCESS or SDP_INVALID_PARAMETER
+ */
+sdp_result_e sdp_attr_add_cdsc_payload_type (sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num, uint16_t payload_type,
+ sdp_payload_ind_e indicator)
+{
+ sdp_attr_t *attr_p;
+ sdp_mca_t *cdsc_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, 0, SDP_ATTR_CDSC, inst_num);
+ if ((attr_p == NULL) || (attr_p->attr.cap_p == NULL)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s CDSC attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ cdsc_p = attr_p->attr.cap_p;
+ cdsc_p->payload_indicator[cdsc_p->num_payloads] = indicator;
+ cdsc_p->payload_type[cdsc_p->num_payloads++] = payload_type;
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_media_dynamic_payload_valid
+ * Description: Checks if the dynamic payload type passed in is defined
+ * on the media line m_line
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * payload_type Payload type to be checked
+ *
+ * Returns: TRUE or FALSE. Returns TRUE if payload type is defined on the
+ * media line, else returns FALSE
+ */
+
+tinybool sdp_media_dynamic_payload_valid (sdp_t *sdp_p, uint16_t payload_type,
+ uint16_t m_line)
+{
+ uint16_t p_type,m_ptype;
+ ushort num_payload_types;
+ sdp_payload_ind_e ind;
+ tinybool payload_matches = FALSE;
+ tinybool result = TRUE;
+
+ if ((payload_type < SDP_MIN_DYNAMIC_PAYLOAD) ||
+ (payload_type > SDP_MAX_DYNAMIC_PAYLOAD)) {
+ return FALSE;
+ }
+
+ num_payload_types =
+ sdp_get_media_num_payload_types(sdp_p, m_line);
+
+ for(p_type=1; p_type <=num_payload_types;p_type++){
+
+ m_ptype = (uint16_t)sdp_get_media_payload_type(sdp_p,
+ m_line, p_type, &ind);
+ if (payload_type == m_ptype) {
+ payload_matches = TRUE;
+ break;
+ }
+
+ }
+
+ if (!payload_matches) {
+ return FALSE;
+ }
+
+ return (result);
+
+}
+
+/* Function: sdp_attr_get_rtr_confirm
+ * Description: Returns the value of the rtr attribute confirm
+ * parameter specified for the given attribute. Returns TRUE if
+ * the confirm parameter is specified.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Boolean value.
+ */
+tinybool sdp_attr_get_rtr_confirm (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_RTR, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s %s attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str,
+ sdp_get_attr_name(SDP_ATTR_RTR), (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (FALSE);
+ } else {
+ return (attr_p->attr.rtr.confirm);
+ }
+}
+
+
+
+sdp_mediadir_role_e sdp_attr_get_comediadir_role (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_DIRECTION, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Comediadir role attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_MEDIADIR_ROLE_UNKNOWN);
+ } else {
+ return (attr_p->attr.comediadir.role);
+ }
+}
+
+/* Function: sdp_attr_get_silencesupp_enabled
+ * Description: Returns the value of the silencesupp attribute enable
+ * parameter specified for the given attribute. Returns TRUE if
+ * the confirm parameter is specified.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Boolean value.
+ */
+tinybool sdp_attr_get_silencesupp_enabled (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SILENCESUPP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s silenceSuppEnable attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (FALSE);
+ } else {
+ return (attr_p->attr.silencesupp.enabled);
+ }
+}
+
+/* Function: sdp_attr_get_silencesupp_timer
+ * Description: Returns the value of the silencesupp attribute timer
+ * parameter specified for the given attribute. null_ind
+ * is set to TRUE if no value was specified, but instead the
+ * null "-" value was specified.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: 16-bit timer value
+ * boolean null_ind
+ */
+uint16_t sdp_attr_get_silencesupp_timer (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ tinybool *null_ind)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SILENCESUPP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s silenceTimer attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ *null_ind = attr_p->attr.silencesupp.timer_null;
+ return (attr_p->attr.silencesupp.timer);
+ }
+}
+
+/* Function: sdp_attr_get_silencesupp_pref
+ * Description: Sets the silencesupp supppref value
+ * If this parameter is TRUE, the confirm parameter will be
+ * specified when the SDP description is built.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * confirm New qos confirm parameter.
+ * Returns: SDP_SUCCESS Attribute param was set successfully.
+ * SDP_INVALID_PARAMETER Specified attribute is not defined.
+ */
+sdp_silencesupp_pref_e sdp_attr_get_silencesupp_pref (sdp_t *sdp_p,
+ uint16_t level, uint8_t cap_num,
+ uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SILENCESUPP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s silence suppPref attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_SILENCESUPP_PREF_UNKNOWN);
+ } else {
+ return (attr_p->attr.silencesupp.pref);
+ }
+}
+
+/* Function: sdp_attr_get_silencesupp_siduse
+ * Description: Returns the value of the silencesupp attribute siduse
+ * parameter specified for the given attribute. If the given
+ * attribute is not defined, SDP_QOS_STRENGTH_UNKNOWN is
+ * returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: silencesupp siduse enum.
+ */
+sdp_silencesupp_siduse_e sdp_attr_get_silencesupp_siduse (sdp_t *sdp_p,
+ uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SILENCESUPP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s silence sidUse attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_SILENCESUPP_SIDUSE_UNKNOWN);
+ } else {
+ return (attr_p->attr.silencesupp.siduse);
+ }
+}
+
+/* Function: sdp_attr_get_silencesupp_fxnslevel
+ * Description: Returns the value of the silencesupp attribute fxns
+ * (fixed noise) parameter specified for the given attribute.
+ * null_ind is set to TRUE if no value was specified,
+ * but instead the null "-" value was specified.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: 7-bit fxns value
+ * boolean null_ind
+ */
+uint8_t sdp_attr_get_silencesupp_fxnslevel (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ tinybool *null_ind)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SILENCESUPP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s silence fxnslevel attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ *null_ind = attr_p->attr.silencesupp.fxnslevel_null;
+ return (attr_p->attr.silencesupp.fxnslevel);
+ }
+}
+
+/* Function: sdp_attr_get_mptime_num_intervals
+ * Description: Returns the number of intervals specified for the
+ * given mptime attribute. If the given attribute is not
+ * defined, zero is returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Number of intervals.
+ */
+uint16_t sdp_attr_get_mptime_num_intervals (
+ sdp_t *sdp_p,
+ uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num) {
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_MPTIME, inst_num);
+ if (attr_p != NULL) {
+ return attr_p->attr.mptime.num_intervals;
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s mptime attribute, level %u instance %u not found.",
+ sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return 0;
+}
+
+/* Function: sdp_attr_get_mptime_interval
+ * Description: Returns the value of the specified interval for the
+ * given mptime attribute. If the given attribute is not
+ * defined, zero is returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * interval_num The interval number to get. Range is (1 -
+ * max num payloads).
+ * Returns: Interval.
+ */
+uint16_t sdp_attr_get_mptime_interval (
+ sdp_t *sdp_p,
+ uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num,
+ uint16_t interval_num) {
+
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_MPTIME, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s mptime attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return 0;
+ }
+
+ if ((interval_num<1) || (interval_num>attr_p->attr.mptime.num_intervals)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s mptime attribute, level %u instance %u, "
+ "invalid interval number %u requested.",
+ sdp_p->debug_str, (unsigned)level, (unsigned)inst_num, (unsigned)interval_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return 0;
+ }
+
+ return attr_p->attr.mptime.intervals[interval_num-1];
+}
+
+/* Function: sdp_attr_add_mptime_interval
+ * Description: Add a new value to the list of intervals specified for
+ * the given mptime attribute. The interval will be
+ * added to the end of the list so these values should be added
+ * in the order they will be displayed within the attribute.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * mp_interval The interval to add.
+ * Returns: SDP_SUCCESS Interval was added successfully.
+ * SDP_INVALID_PARAMETER Specified attribute is not defined.
+ * SDP_INVALID_SDP_PTR Supplied SDP pointer is invalid
+ */
+sdp_result_e sdp_attr_add_mptime_interval (
+ sdp_t *sdp_p,
+ uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num,
+ uint16_t mp_interval) {
+
+ uint16_t interval_num;
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num, SDP_ATTR_MPTIME, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s mptime attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_INVALID_PARAMETER;
+ }
+
+ interval_num = attr_p->attr.mptime.num_intervals;
+ if (interval_num>=SDP_MAX_PAYLOAD_TYPES) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s mptime attribute, level %u instance %u "
+ "exceeds maximum length.",
+ sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_INVALID_PARAMETER;
+ }
+
+ attr_p->attr.mptime.intervals[interval_num] = mp_interval;
+ ++attr_p->attr.mptime.num_intervals;
+ return SDP_SUCCESS;
+}
+
+
+
+/* Function: sdp_get_group_attr
+ * Description: Returns the attribute parameter from the a=group:<>
+ * line. If no attrib has been set ,
+ * SDP_GROUP_ATTR_UNSUPPORTED will be returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level SDP_SESSION_LEVEL
+ * Returns: Valid attrib value or SDP_GROUP_ATTR_UNSUPPORTED.
+ */
+sdp_group_attr_e sdp_get_group_attr (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_GROUP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Group (a= group line) attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_GROUP_ATTR_UNSUPPORTED);
+ } else {
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Stream data group attr field is :%s ",
+ sdp_p->debug_str,
+ sdp_get_group_attr_name(attr_p->attr.stream_data.group_attr) );
+ }
+ return (attr_p->attr.stream_data.group_attr);
+ }
+}
+
+/* Function: sdp_get_group_num_id
+ * Description: Returns the number of ids from the a=group:<> line.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level SDP_SESSION_LEVEL
+ * Returns: Num of group ids present or 0 if there is an error.
+ */
+uint16_t sdp_get_group_num_id (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_GROUP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s a=group level attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (0);
+ } else {
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Stream data group attr - num of ids is :%u ",
+ sdp_p->debug_str,
+ (unsigned)attr_p->attr.stream_data.num_group_id);
+ }
+ }
+ return (attr_p->attr.stream_data.num_group_id);
+}
+
+/* Function: sdp_get_group_id
+ * Description: Returns the group id from the a=group:<> line.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level SDP_SESSION_LEVEL
+ * id_num Number of the id to retrieve. The range is (1 -
+ * SDP_MAX_GROUP_STREAM_ID)
+ * Returns: Value of the group id at the index specified or
+ * NULL if an error
+ */
+const char* sdp_get_group_id (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num, uint16_t id_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_GROUP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s a=group level attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (NULL);
+ } else {
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Stream data group attr - num of ids is :%u ",
+ sdp_p->debug_str,
+ (unsigned)attr_p->attr.stream_data.num_group_id);
+ }
+ if ((id_num < 1) || (id_num > attr_p->attr.stream_data.num_group_id)) {
+ return (NULL);
+ }
+ }
+ return (attr_p->attr.stream_data.group_ids[id_num-1]);
+}
+
+/* Function: sdp_attr_get_x_sidin
+ * Description: Returns the attribute parameter from the a=X-sidin:<>
+ * line. If no attrib has been set NULL will be returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level media level index
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Pointer to sidin or NULL.
+ */
+const char* sdp_attr_get_x_sidin (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_X_SIDIN, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s X-sidin attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (NULL);
+ } else {
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Stream X-sidin attr field is :%s ",
+ sdp_p->debug_str,
+ attr_p->attr.stream_data.x_sidin);
+ }
+ return (attr_p->attr.stream_data.x_sidin);
+ }
+}
+
+/* Function: sdp_attr_get_x_sidout
+ * Description: Returns the attribute parameter from the a=X-sidout:<>
+ * line. If no attrib has been set NULL will be returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level media level index
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Pointer to sidout or NULL.
+ */
+const char* sdp_attr_get_x_sidout (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_X_SIDOUT, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s X-sidout attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (NULL);
+ } else {
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Stream X-sidout attr field is :%s ",
+ sdp_p->debug_str,
+ attr_p->attr.stream_data.x_sidout);
+ }
+ return (attr_p->attr.stream_data.x_sidout);
+ }
+}
+
+/* Function: sdp_attr_get_x_confid
+ * Description: Returns the attribute parameter from the a=X-confid:<>
+ * line. If no attrib has been set NULL will be returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level media level index
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Pointer to confid or NULL.
+ */
+const char* sdp_attr_get_x_confid (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_X_CONFID, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s X-confid attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (NULL);
+ } else {
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Stream X-confid attr field is :%s ",
+ sdp_p->debug_str,
+ attr_p->attr.stream_data.x_confid);
+ }
+ return (attr_p->attr.stream_data.x_confid);
+ }
+}
+
+/* Function: sdp_get_source_filter_mode
+ * Description: Gets the filter mode in internal representation
+ * Parameters: sdp_p The SDP handle which contains the attributes
+ * level SDP_SESSION_LEVEL/m-line number
+ * inst_num The attribute instance number
+ * Returns: Filter mode (incl/excl/not present)
+ */
+sdp_src_filter_mode_e
+sdp_get_source_filter_mode (sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SOURCE_FILTER, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Source filter attribute, level %u, "
+ "instance %u not found", sdp_p->debug_str,
+ (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_FILTER_MODE_NOT_PRESENT);
+ }
+ return (attr_p->attr.source_filter.mode);
+}
+
+/* Function: sdp_get_filter_destination_attributes
+ * Description: Gets the destination address parameters
+ * Parameters: Network type (optional), destination address type
+ * (optional), and destination address (mandatory) variables
+ * which gets updated.
+ * Returns: SDP_SUCCESS or SDP_INVALID_PARAMETER/SDP_INVALID_SDP_PTR
+ */
+sdp_result_e
+sdp_get_filter_destination_attributes (sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ uint16_t inst_num, sdp_nettype_e *nettype,
+ sdp_addrtype_e *addrtype,
+ char *dest_addr)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SOURCE_FILTER, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Source filter attribute, level %u instance %u "
+ "not found", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ if (nettype) {
+ *nettype = attr_p->attr.source_filter.nettype;
+ }
+ if (addrtype) {
+ *addrtype = attr_p->attr.source_filter.addrtype;
+ }
+ sstrncpy(dest_addr, attr_p->attr.source_filter.dest_addr,
+ SDP_MAX_STRING_LEN+1);
+
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_get_filter_source_address_count
+ * Description: Gets the number of source addresses in the list
+ * Parameters: sdp_p The SDP handle which contains the attributes
+ * level SDP_SESSION_LEVEL/m-line number
+ * inst_num The attribute instance number
+ * Returns: Source-list count
+ */
+
+int32_t
+sdp_get_filter_source_address_count (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SOURCE_FILTER, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Source filter attribute, level %u instance %u "
+ "not found", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_VALUE);
+ }
+ return (attr_p->attr.source_filter.num_src_addr);
+}
+
+/* Function: sdp_get_filter_source_address
+ * Description: Gets one of the source address that is indexed by the user
+ * Parameters: sdp_p The SDP handle which contains the attributes
+ * level SDP_SESSION_LEVEL/m-line number
+ * inst_num The attribute instance number
+ * src_addr_id User provided index (value in range between
+ * 0 to (SDP_MAX_SRC_ADDR_LIST-1) which obtains
+ * the source addr corresponding to it.
+ * src_addr The user provided variable which gets updated
+ * with source address corresponding to the index
+ */
+sdp_result_e
+sdp_get_filter_source_address (sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ uint16_t inst_num, uint16_t src_addr_id,
+ char *src_addr)
+{
+ sdp_attr_t *attr_p;
+
+ src_addr[0] = '\0';
+
+ if (src_addr_id >= SDP_MAX_SRC_ADDR_LIST) {
+ return (SDP_INVALID_PARAMETER);
+ }
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SOURCE_FILTER, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s Source filter attribute, level %u instance %u "
+ "not found", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ if (src_addr_id >= attr_p->attr.source_filter.num_src_addr) {
+ return (SDP_INVALID_PARAMETER);
+ }
+ sstrncpy(src_addr, attr_p->attr.source_filter.src_list[src_addr_id],
+ SDP_MAX_STRING_LEN+1);
+
+ return (SDP_SUCCESS);
+}
+
+sdp_rtcp_unicast_mode_e
+sdp_get_rtcp_unicast_mode(sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_RTCP_UNICAST, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s RTCP Unicast attribute, level %u, "
+ "instance %u not found", sdp_p->debug_str,
+ (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_RTCP_UNICAST_MODE_NOT_PRESENT);
+ }
+ return ((sdp_rtcp_unicast_mode_e)attr_p->attr.u32_val);
+}
+
+
+/* Function: sdp_attr_get_sdescriptions_tag
+ * Description: Returns the value of the sdescriptions tag
+ * parameter specified for the given attribute.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: Tag value or SDP_INVALID_VALUE (-2) if error encountered.
+ */
+
+int32_t
+sdp_attr_get_sdescriptions_tag (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SDESCRIPTIONS, inst_num);
+
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s srtp attribute tag, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_INVALID_VALUE;
+ } else {
+ return attr_p->attr.srtp_context.tag;
+ }
+}
+
+/* Function: sdp_attr_get_sdescriptions_crypto_suite
+ * Description: Returns the value of the sdescriptions crypto suite
+ * parameter specified for the given attribute. Note that
+ * this is a common api for both version 2 and version 9
+ * sdescriptions. It has no knowledge which version is being
+ * used so it will first try to find if a version 2 sdescriptions
+ * attribute is present. If it is, return the suite. If it's not,
+ * try to find the version 9. This assumes you cannot have both
+ * versions in the same SDP.
+ *
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: SDP_SRTP_UNKNOWN_CRYPTO_SUITE is returned if an error was
+ * encountered otherwise the crypto suite is returned.
+ */
+
+sdp_srtp_crypto_suite_t
+sdp_attr_get_sdescriptions_crypto_suite (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+
+ /* Try version 2 first */
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SRTP_CONTEXT, inst_num);
+
+ if (attr_p == NULL) {
+ /* There's no version 2 so now try version 9 */
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SDESCRIPTIONS, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s srtp attribute suite, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_SRTP_UNKNOWN_CRYPTO_SUITE;
+ }
+ }
+
+ return attr_p->attr.srtp_context.suite;
+
+}
+
+/* Function: sdp_attr_get_sdescriptions_key
+ * Description: Returns the value of the sdescriptions master key
+ * parameter specified for the given attribute. Note that
+ * this is a common api for both version 2 and version 9
+ * sdescriptions. It has no knowledge which version is being
+ * used so it will first try to find if a version 2 sdescriptions
+ * attribute is present. If it is, return the key. If it's not,
+ * try to find the version 9. This assumes you cannot have both
+ * versions in the same SDP.
+ *
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: NULL if error encountered or master key salt string
+ */
+
+const char*
+sdp_attr_get_sdescriptions_key (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ /* Try version 2 first */
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SRTP_CONTEXT, inst_num);
+
+ if (attr_p == NULL) {
+ /* Couldn't find version 2 now try version 9 */
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SDESCRIPTIONS, inst_num);
+
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s srtp attribute key, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return NULL;
+ }
+ }
+
+ return (char*)attr_p->attr.srtp_context.master_key;
+}
+
+
+/* Function: sdp_attr_get_sdescriptions_salt
+ * Description: Returns the value of the sdescriptions master salt
+ * parameter specified for the given attribute. Note that
+ * this is a common api for both version 2 and version 9
+ * sdescriptions. It has no knowledge which version is being
+ * used so it will first try to find if a version 2 sdescriptions
+ * attribute is present. If it is, return the salt. If it's not,
+ * try to find the version 9. This assumes you cannot have both
+ * versions in the same SDP.
+ *
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: NULL if error encountered or master key salt string
+ */
+
+const char*
+sdp_attr_get_sdescriptions_salt (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ /* Try version 2 first */
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SRTP_CONTEXT, inst_num);
+
+ if (attr_p == NULL) {
+ /* Couldn't find version 2 now try version 9 */
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SDESCRIPTIONS, inst_num);
+
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s srtp attribute salt, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return NULL;
+ }
+ }
+
+ return (char*) attr_p->attr.srtp_context.master_salt;
+
+}
+
+
+
+/* Function: sdp_attr_get_sdescriptions_lifetime
+ * Description: Returns the value of the sdescriptions lifetime
+ * parameter specified for the given attribute.Note that
+ * this is a common api for both version 2 and version 9
+ * sdescriptions. It has no knowledge which version is being
+ * used so it will first try to find if a version 2 sdescriptions
+ * attribute is present. If it is, return the lifetime. If it's
+ * not, try to find the version 9. This assumes you cannot have
+ * both versions in the same SDP.
+ *
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: NULL if error encountered or lifetime string
+ */
+
+const char*
+sdp_attr_get_sdescriptions_lifetime (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ /* Try version 2 first. */
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SRTP_CONTEXT, inst_num);
+
+ if (attr_p == NULL) {
+ /* Couldn't find version 2 now try version 9 */
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SDESCRIPTIONS, inst_num);
+
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s srtp attribute lifetime, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return NULL;
+ }
+ }
+
+ return (char*)attr_p->attr.srtp_context.master_key_lifetime;
+
+}
+
+/* Function: sdp_attr_get_sdescriptions_mki
+ * Description: Returns the value of the sdescriptions MKI value and length
+ * parameter of the specified attribute instance. Note that
+ * this is a common api for both version 2 and version 9
+ * sdescriptions. It has no knowledge which version is being
+ * used so it will first try to find if a version 2 sdescriptions
+ * attribute is present. If it is, return the MKI. If it's
+ * not, try to find version 9. This assumes you cannot have
+ * both versions in the same SDP.
+ *
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * mki_value application provided pointer that on exit
+ * is set to the MKI value string if one exists.
+ * mki_length application provided pointer that on exit
+ * is set to the MKI length if one exists.
+ * Returns: SDP_SUCCESS no errors encountered otherwise sdp error
+ * based upon the specific error.
+ */
+
+sdp_result_e
+sdp_attr_get_sdescriptions_mki (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num,
+ const char **mki_value,
+ uint16_t *mki_length)
+{
+ sdp_attr_t *attr_p;
+
+ *mki_value = NULL;
+ *mki_length = 0;
+
+ /* Try version 2 first */
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SRTP_CONTEXT, inst_num);
+
+ if (attr_p == NULL) {
+ /* Couldn't find version 2 now try version 9 */
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SDESCRIPTIONS, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s srtp attribute MKI, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_INVALID_PARAMETER;
+ }
+ }
+
+ *mki_value = (char*)attr_p->attr.srtp_context.mki;
+ *mki_length = attr_p->attr.srtp_context.mki_size_bytes;
+ return SDP_SUCCESS;
+
+}
+
+
+/* Function: sdp_attr_get_sdescriptions_session_params
+ * Description: Returns the unparsed session parameters string. Note that
+ * this is a common api for both version 2 and version 9
+ * sdescriptions. It has no knowledge which version is being
+ * used so it will first try to find if a version 2 sdescriptions
+ * attribute is present. If it is, return session parameters. If
+ * it's not, try to find version 9. This assumes you cannot have
+ * both versions in the same SDP.
+ *
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: NULL if no session parameters were received in the sdp,
+ * otherwise returns a pointer to the start of the session
+ * parameters string. Note that the calling function should
+ * not free the returned pointer.
+ */
+
+const char*
+sdp_attr_get_sdescriptions_session_params (sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ /* Try version 2 first */
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SRTP_CONTEXT, inst_num);
+
+ if (attr_p == NULL) {
+ /* Couldn't find version 2 try version 9 */
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SDESCRIPTIONS, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s srtp attribute session params, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return NULL;
+ }
+ }
+
+ return attr_p->attr.srtp_context.session_parameters;
+}
+
+
+/* Function: sdp_attr_get_sdescriptions_key_size
+ * Description: Returns the master key size. Note that
+ * this is a common api for both version 2 and version 9
+ * sdescriptions. It has no knowledge which version is being
+ * used so it will first try to find if a version 2 sdescriptions
+ * attribute is present. If it is, return key size. If
+ * it's not, try to find version 9. This assumes you cannot have
+ * both versions in the same SDP.
+ *
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: 0 (SDP_SDESCRIPTIONS_KEY_SIZE_UNKNOWN) if error was
+ * encountered, otherwise key size.
+ */
+
+unsigned char
+sdp_attr_get_sdescriptions_key_size (sdp_t *sdp_p,
+ uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ /* Try version 2 first */
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SRTP_CONTEXT, inst_num);
+
+ if (attr_p == NULL) {
+ /* Couldn't find version 2 now try version 9 */
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SDESCRIPTIONS, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s srtp attribute MKI, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_SDESCRIPTIONS_KEY_SIZE_UNKNOWN;
+ }
+ }
+
+ return attr_p->attr.srtp_context.master_key_size_bytes;
+
+}
+
+
+/* Function: sdp_attr_get_sdescriptions_salt_size
+ * Description: Returns the salt key size. Note that
+ * this is a common api for both version 2 and version 9
+ * sdescriptions. It has no knowledge which version is being
+ * used so it will first try to find if a version 2 sdescriptions
+ * attribute is present. If it is, return salt size. If
+ * it's not, try to find version 9. This assumes you cannot have
+ * both versions in the same SDP.
+ *
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: 0 (SDP_SDESCRIPTIONS_KEY_SIZE_UNKNOWN) if error was
+ * encountered, otherwise salt size.
+ */
+
+unsigned char
+sdp_attr_get_sdescriptions_salt_size (sdp_t *sdp_p,
+ uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num)
+{
+
+ sdp_attr_t *attr_p;
+
+ /* Try version 2 first */
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SRTP_CONTEXT, inst_num);
+
+ if (attr_p == NULL) {
+ /* Couldn't find version 2 now try version 9 */
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SDESCRIPTIONS, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s srtp attribute MKI, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_SDESCRIPTIONS_KEY_SIZE_UNKNOWN;
+ }
+ }
+
+ return attr_p->attr.srtp_context.master_salt_size_bytes;
+
+}
+
+
+/* Function: sdp_attr_get_srtp_crypto_selection_flags
+ * Description: Returns the selection flags. Note that
+ * this is a common api for both version 2 and version 9
+ * sdescriptions. It has no knowledge which version is being
+ * used so it will first try to find if a version 2 sdescriptions
+ * attribute is present. If it is, return selection flags. If
+ * it's not, try to find version 9. This assumes you cannot have
+ * both versions in the same SDP.
+ * Currently only necessary for MGCP.
+ *
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * cap_num The capability number associated with the
+ * attribute if any. If none, should be zero.
+ * inst_num The attribute instance number to check.
+ * Returns: 0 (SDP_SRTP_CRYPTO_SELECTION_FLAGS_UNKNOWN) if error was
+ * encountered, otherwise selection flags.
+ */
+
+unsigned long
+sdp_attr_get_srtp_crypto_selection_flags (sdp_t *sdp_p,
+ uint16_t level,
+ uint8_t cap_num,
+ uint16_t inst_num)
+{
+
+
+ sdp_attr_t *attr_p;
+
+ /* Try version 2 first */
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SRTP_CONTEXT, inst_num);
+
+ if (attr_p == NULL) {
+ /* Couldn't find version 2 now try version 9 */
+ attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_SDESCRIPTIONS, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s srtp attribute MKI, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_SRTP_CRYPTO_SELECTION_FLAGS_UNKNOWN;
+ }
+ }
+
+ return attr_p->attr.srtp_context.selection_flags;
+
+}
+
+
+
+/* Function: sdp_find_rtcp_fb_attr
+ * Description: Helper to find the nth instance of a rtcp-fb attribute of
+ * the specified feedback type.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * payload_type The payload to get the attribute for
+ * fb_type The feedback type to look for.
+ * inst_num The attribute instance number to check.
+ * Returns: Pointer to the attribute, or NULL if not found.
+ */
+
+sdp_attr_t *
+sdp_find_rtcp_fb_attr (sdp_t *sdp_p,
+ uint16_t level,
+ uint16_t payload_type,
+ sdp_rtcp_fb_type_e fb_type,
+ uint16_t inst_num)
+{
+ uint16_t attr_count=0;
+ sdp_mca_t *mca_p;
+ sdp_attr_t *attr_p;
+
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (!mca_p) {
+ return (NULL);
+ }
+ for (attr_p = mca_p->media_attrs_p; attr_p; attr_p = attr_p->next_p) {
+ if (attr_p->type == SDP_ATTR_RTCP_FB &&
+ (attr_p->attr.rtcp_fb.payload_num == payload_type ||
+ attr_p->attr.rtcp_fb.payload_num == SDP_ALL_PAYLOADS) &&
+ attr_p->attr.rtcp_fb.feedback_type == fb_type) {
+ attr_count++;
+ if (attr_count == inst_num) {
+ return (attr_p);
+ }
+ }
+ }
+ return NULL;
+}
+
+/* Function: sdp_attr_get_rtcp_fb_ack
+ * Description: Returns the value of the rtcp-fb:...ack attribute
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * payload_type The payload to get the attribute for
+ * inst_num The attribute instance number to check.
+ * Returns: ACK type (SDP_RTCP_FB_ACK_NOT_FOUND if not present)
+ */
+sdp_rtcp_fb_ack_type_e
+sdp_attr_get_rtcp_fb_ack(sdp_t *sdp_p, uint16_t level, uint16_t payload_type, uint16_t inst)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_rtcp_fb_attr(sdp_p, level, payload_type,
+ SDP_RTCP_FB_ACK, inst);
+ if (!attr_p) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s rtcp-fb attribute, level %u, pt %u, "
+ "instance %u not found.", sdp_p->debug_str, (unsigned)level,
+ (unsigned)payload_type, (unsigned)inst);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_RTCP_FB_ACK_NOT_FOUND;
+ }
+ return (attr_p->attr.rtcp_fb.param.ack);
+}
+
+/* Function: sdp_attr_get_rtcp_fb_nack
+ * Description: Returns the value of the rtcp-fb:...nack attribute
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * payload_type The payload to get the attribute for
+ * inst_num The attribute instance number to check.
+ * Returns: NACK type (SDP_RTCP_FB_NACK_NOT_FOUND if not present)
+ */
+sdp_rtcp_fb_nack_type_e
+sdp_attr_get_rtcp_fb_nack(sdp_t *sdp_p, uint16_t level, uint16_t payload_type, uint16_t inst)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_rtcp_fb_attr(sdp_p, level, payload_type,
+ SDP_RTCP_FB_NACK, inst);
+ if (!attr_p) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s rtcp-fb attribute, level %u, pt %u, "
+ "instance %u not found.", sdp_p->debug_str, (unsigned)level,
+ (unsigned)payload_type, (unsigned)inst);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_RTCP_FB_NACK_NOT_FOUND;
+ }
+ return (attr_p->attr.rtcp_fb.param.nack);
+}
+
+/* Function: sdp_attr_get_rtcp_fb_trr_int
+ * Description: Returns the value of the rtcp-fb:...trr-int attribute
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * payload_type The payload to get the attribute for
+ * inst_num The attribute instance number to check.
+ * Returns: trr-int interval (0xFFFFFFFF if not found)
+ */
+uint32_t
+sdp_attr_get_rtcp_fb_trr_int(sdp_t *sdp_p, uint16_t level,
+ uint16_t payload_type, uint16_t inst)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_rtcp_fb_attr(sdp_p, level, payload_type,
+ SDP_RTCP_FB_TRR_INT, inst);
+ if (!attr_p) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s rtcp-fb attribute, level %u, pt %u, "
+ "instance %u not found.", sdp_p->debug_str, (unsigned)level,
+ (unsigned)payload_type, (unsigned)inst);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return 0xFFFFFFFF;
+ }
+ return (attr_p->attr.rtcp_fb.param.trr_int);
+}
+
+/* Function: sdp_attr_get_rtcp_fb_remb_enabled
+ * Description: Returns true if rtcp-fb:...goog-remb attribute exists
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * payload_type The payload to get the attribute for
+ * Returns: true if rtcp-fb:...goog-remb exists
+ */
+tinybool
+sdp_attr_get_rtcp_fb_remb_enabled(sdp_t *sdp_p,
+ uint16_t level,
+ uint16_t payload_type)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_rtcp_fb_attr(sdp_p, level, payload_type,
+ SDP_RTCP_FB_REMB,
+ 1); // always check for 1st instance
+ return (attr_p? TRUE : FALSE); // either exists or not
+}
+
+/* Function: sdp_attr_get_rtcp_fb_ccm
+ * Description: Returns the value of the rtcp-fb:...ccm attribute
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * payload_type The payload to get the attribute for
+ * inst_num The attribute instance number to check.
+ * Returns: CCM type (SDP_RTCP_FB_CCM_NOT_FOUND if not present)
+ */
+sdp_rtcp_fb_ccm_type_e
+sdp_attr_get_rtcp_fb_ccm(sdp_t *sdp_p, uint16_t level, uint16_t payload_type, uint16_t inst)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_rtcp_fb_attr(sdp_p, level, payload_type,
+ SDP_RTCP_FB_CCM, inst);
+ if (!attr_p) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s rtcp-fb attribute, level %u, pt %u, "
+ "instance %u not found.", sdp_p->debug_str, (unsigned)level,
+ (unsigned)payload_type, (unsigned)inst);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_RTCP_FB_CCM_NOT_FOUND;
+ }
+ return (attr_p->attr.rtcp_fb.param.ccm);
+}
+
+/* Function: sdp_attr_set_rtcp_fb_ack
+ * Description: Sets the value of an rtcp-fb:...ack attribute
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to set the attribute.
+ * payload_type The value to set the payload type to for
+ * this attribute. Can be SDP_ALL_PAYLOADS.
+ * inst_num The attribute instance number to check.
+ * type The ack type to indicate
+ * Returns: SDP_SUCCESS Attribute param was set successfully.
+ * SDP_INVALID_PARAMETER Specified attribute is not defined.
+ */
+sdp_result_e
+sdp_attr_set_rtcp_fb_ack(sdp_t *sdp_p, uint16_t level, uint16_t payload_type, uint16_t inst,
+ sdp_rtcp_fb_ack_type_e type)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, 0, SDP_ATTR_RTCP_FB, inst);
+ if (!attr_p) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s rtcp_fb ack attribute, level %u "
+ "instance %u not found.", sdp_p->debug_str, (unsigned)level,
+ (unsigned)inst);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ attr_p->attr.rtcp_fb.payload_num = payload_type;
+ attr_p->attr.rtcp_fb.feedback_type = SDP_RTCP_FB_ACK;
+ attr_p->attr.rtcp_fb.param.ack = type;
+ attr_p->attr.rtcp_fb.extra[0] = '\0';
+ return (SDP_SUCCESS);
+}
+
+
+/* Function: sdp_attr_set_rtcp_fb_nack
+ * Description: Sets the value of an rtcp-fb:...nack attribute
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to set the attribute.
+ * payload_type The value to set the payload type to for
+ * this attribute. Can be SDP_ALL_PAYLOADS.
+ * inst_num The attribute instance number to check.
+ * type The nack type to indicate
+ * Returns: SDP_SUCCESS Attribute param was set successfully.
+ * SDP_INVALID_PARAMETER Specified attribute is not defined.
+ */
+sdp_result_e
+sdp_attr_set_rtcp_fb_nack(sdp_t *sdp_p, uint16_t level, uint16_t payload_type, uint16_t inst,
+ sdp_rtcp_fb_nack_type_e type)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, 0, SDP_ATTR_RTCP_FB, inst);
+ if (!attr_p) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s rtcp_fb nack attribute, level %u "
+ "instance %u not found.", sdp_p->debug_str, (unsigned)level,
+ (unsigned)inst);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ attr_p->attr.rtcp_fb.payload_num = payload_type;
+ attr_p->attr.rtcp_fb.feedback_type = SDP_RTCP_FB_NACK;
+ attr_p->attr.rtcp_fb.param.nack = type;
+ attr_p->attr.rtcp_fb.extra[0] = '\0';
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_attr_set_rtcp_fb_trr_int
+ * Description: Sets the value of an rtcp-fb:...trr-int attribute
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to set the attribute.
+ * payload_type The value to set the payload type to for
+ * this attribute. Can be SDP_ALL_PAYLOADS.
+ * inst_num The attribute instance number to check.
+ * interval The interval time to indicate
+ * Returns: SDP_SUCCESS Attribute param was set successfully.
+ * SDP_INVALID_PARAMETER Specified attribute is not defined.
+ */
+sdp_result_e
+sdp_attr_set_rtcp_fb_trr_int(sdp_t *sdp_p, uint16_t level, uint16_t payload_type,
+ uint16_t inst, uint32_t interval)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, 0, SDP_ATTR_RTCP_FB, inst);
+ if (!attr_p) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s rtcp_fb trr-int attribute, level %u "
+ "instance %u not found.", sdp_p->debug_str, (unsigned)level,
+ (unsigned)inst);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ attr_p->attr.rtcp_fb.payload_num = payload_type;
+ attr_p->attr.rtcp_fb.feedback_type = SDP_RTCP_FB_TRR_INT;
+ attr_p->attr.rtcp_fb.param.trr_int = interval;
+ attr_p->attr.rtcp_fb.extra[0] = '\0';
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_attr_set_rtcp_fb_remb
+ * Description: Sets the value of an rtcp-fb:...goog-remb attribute
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to set the attribute.
+ * payload_type The value to set the payload type to for
+ * this attribute. Can be SDP_ALL_PAYLOADS.
+ * inst_num The attribute instance number to check.
+ * Returns: SDP_SUCCESS Attribute param was set successfully.
+ * SDP_INVALID_PARAMETER Specified attribute is not defined.
+ */
+sdp_result_e
+sdp_attr_set_rtcp_fb_remb(sdp_t *sdp_p, uint16_t level, uint16_t payload_type,
+ uint16_t inst)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, 0, SDP_ATTR_RTCP_FB, inst);
+ if (!attr_p) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s rtcp_fb goog-remb attribute, level %u "
+ "instance %u not found.", sdp_p->debug_str, (unsigned)level,
+ (unsigned)inst);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ attr_p->attr.rtcp_fb.payload_num = payload_type;
+ attr_p->attr.rtcp_fb.feedback_type = SDP_RTCP_FB_REMB;
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_attr_set_rtcp_fb_ccm
+ * Description: Sets the value of an rtcp-fb:...ccm attribute
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to set the attribute.
+ * payload_type The value to set the payload type to for
+ * this attribute. Can be SDP_ALL_PAYLOADS.
+ * inst_num The attribute instance number to check.
+ * type The ccm type to indicate
+ * Returns: SDP_SUCCESS Attribute param was set successfully.
+ * SDP_INVALID_PARAMETER Specified attribute is not defined.
+ */
+sdp_result_e
+sdp_attr_set_rtcp_fb_ccm(sdp_t *sdp_p, uint16_t level, uint16_t payload_type, uint16_t inst,
+ sdp_rtcp_fb_ccm_type_e type)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, 0, SDP_ATTR_RTCP_FB, inst);
+ if (!attr_p) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s rtcp_fb ccm attribute, level %u "
+ "instance %u not found.", sdp_p->debug_str, (unsigned)level,
+ (unsigned)inst);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ attr_p->attr.rtcp_fb.payload_num = payload_type;
+ attr_p->attr.rtcp_fb.feedback_type = SDP_RTCP_FB_CCM;
+ attr_p->attr.rtcp_fb.param.ccm = type;
+ attr_p->attr.rtcp_fb.extra[0] = '\0';
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_attr_get_extmap_uri
+ * Description: Returns a pointer to the value of the encoding name
+ * parameter specified for the given attribute. Value is
+ * returned as a const ptr and so cannot be modified by the
+ * application. If the given attribute is not defined, NULL
+ * will be returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * inst_num The attribute instance number to check.
+ * Returns: Codec value or SDP_CODEC_INVALID.
+ */
+const char *sdp_attr_get_extmap_uri(sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, 0, SDP_ATTR_EXTMAP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s extmap attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (NULL);
+ } else {
+ return (attr_p->attr.extmap.uri);
+ }
+}
+
+/* Function: sdp_attr_get_extmap_id
+ * Description: Returns the id of the extmap specified for the given
+ * attribute. If the given attribute is not defined, 0xFFFF
+ * will be returned.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to check for the attribute.
+ * inst_num The attribute instance number to check.
+ * Returns: The id of the extmap attribute.
+ */
+uint16_t sdp_attr_get_extmap_id(sdp_t *sdp_p, uint16_t level,
+ uint16_t inst_num)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, 0, SDP_ATTR_EXTMAP, inst_num);
+ if (attr_p == NULL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s extmap attribute, level %u instance %u "
+ "not found.", sdp_p->debug_str, (unsigned)level, (unsigned)inst_num);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return 0xFFFF;
+ } else {
+ return (attr_p->attr.extmap.id);
+ }
+}
+
+/* Function: sdp_attr_set_extmap
+ * Description: Sets the value of an rtcp-fb:...ccm attribute
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * level The level to set the attribute.
+ * id The id to set the attribute.
+ * uri The uri to set the attribute.
+ * inst The attribute instance number to check.
+ * Returns: SDP_SUCCESS Attribute param was set successfully.
+ * SDP_INVALID_PARAMETER Specified attribute is not defined.
+ */
+sdp_result_e
+sdp_attr_set_extmap(sdp_t *sdp_p, uint16_t level, uint16_t id, const char* uri, uint16_t inst)
+{
+ sdp_attr_t *attr_p;
+
+ attr_p = sdp_find_attr(sdp_p, level, 0, SDP_ATTR_EXTMAP, inst);
+ if (!attr_p) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s extmap attribute, level %u "
+ "instance %u not found.", sdp_p->debug_str, (unsigned)level,
+ (unsigned)inst);
+ }
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ attr_p->attr.extmap.id = id;
+ sstrncpy(attr_p->attr.extmap.uri, uri, SDP_MAX_STRING_LEN+1);
+ return (SDP_SUCCESS);
+}
+
+const char *sdp_attr_get_msid_identifier(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst)
+{
+ sdp_attr_t *attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_MSID, inst);
+ if (!attr_p) {
+ return NULL;
+ }
+ return attr_p->attr.msid.identifier;
+}
+
+const char *sdp_attr_get_msid_appdata(sdp_t *sdp_p, uint16_t level,
+ uint8_t cap_num, uint16_t inst)
+{
+ sdp_attr_t *attr_p = sdp_find_attr(sdp_p, level, cap_num,
+ SDP_ATTR_MSID, inst);
+ if (!attr_p) {
+ return NULL;
+ }
+ return attr_p->attr.msid.appdata;
+}
diff --git a/media/webrtc/signaling/src/sdp/sipcc/sdp_base64.c b/media/webrtc/signaling/src/sdp/sipcc/sdp_base64.c
new file mode 100644
index 000000000..80f1eb52d
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/sdp_base64.c
@@ -0,0 +1,403 @@
+/* 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 "sdp_base64.h"
+
+/*
+ * Local definitions for Base64 to Raw table entries.
+ */
+#define INVALID_CHAR 0xFF /* Character not in supported Base64 set */
+#define WHITE_SPACE 0xFE /* Space, tab, newline, etc character */
+#define PADDING 0xFD /* The character '=' */
+
+#define PAD_CHAR '=' /* The character '=' */
+
+/* Maximum length of a base64 encoded line */
+#define MAX_BASE64_LINE_LENGTH 76
+
+/*
+ * base64_result_table
+ * String table for translating base64 error codes into human
+ * understanable strings.
+ */
+char *base64_result_table[BASE64_RESULT_MAX] =
+{
+ "Base64 successful",
+ "Base64 Buffer Overrun",
+ "Base64 Bad Data",
+ "Base64 Bad Padding",
+ "Base64 Bad Block Size"
+};
+
+/*
+ * base64_to_raw_table
+ * Heart of the Base64 decoding algorithm. Lookup table to convert
+ * the Base64 characters into their specified representative values.
+ * Invalid characters are marked with 0xFF, white space characters
+ * are marked with 0xFE, and the special pading character is marked
+ * with 0xFD.
+ */
+unsigned char base64_to_raw_table[128] =
+{
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, /* 0-9 */
+ 0xFE, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /* 10-19 */
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /* 20-29 */
+ 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /* 30-39 */
+ 0xFF, 0xFF, 0xFF, 62, 0xFF, 0xFF, 0xFF, 63, 52, 53, /* 40-49 */
+ 54, 55, 56, 57, 58, 59, 60, 61, 0xFF, 0xFF, /* 50-59 */
+ 0xFF, 0xFD, 0xFF, 0xFF, 0xFF, 0, 1, 2, 3, 4, /* 60-69 */
+ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, /* 70-79 */
+ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, /* 80-89 */
+ 25, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 26, 27, 28, /* 90-99 */
+ 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, /* 100-109 */
+ 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, /* 110-119 */
+ 49, 50, 51, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF /* 120-127 */
+};
+
+unsigned char raw_to_base64_table[64] =
+{
+ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', /* 0-9 */
+ 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', /* 10-19 */
+ 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', /* 20-29 */
+ 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', /* 30-39 */
+ 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', /* 40-49 */
+ 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', /* 50-59 */
+ '8', '9', '+', '/' /* 60-63 */
+};
+
+/*
+ * base64_encode_size_bytes
+ *
+ * DESCRIPTION
+ * Estimates the size of buffer required for holding the result of
+ * encoding data of size raw_size_bytes.
+ *
+ * PARAMETERS
+ * raw_size_bytes = Estimated size of the un-encoded data in bytes.
+ *
+ * RETURN VALUE
+ * The size of destination buffer to use for encoding in bytes.
+ */
+int base64_est_encode_size_bytes (int raw_size_bytes)
+{
+ int length;
+
+ /*
+ * Find the number of bytes needed to represent the data
+ * using a 4/3 expansion ratio. That result must be
+ * rounded to the next higher multiple of four to account
+ * for padding. Then add in a term to account for any '\n's
+ * added.
+ */
+ length = ((((raw_size_bytes * 4 + 2)/ 3) + 3) & ~(0x3)) +
+ raw_size_bytes / MAX_BASE64_LINE_LENGTH;
+
+ return length;
+}
+
+/*
+ * base64_decode_size_bytes
+ *
+ * DESCRIPTION
+ * Estimates the size of buffer required for holding the result of
+ * decoding data of size base64_size_bytes.
+ *
+ * PARAMETERS
+ * base64_size_bytes = Estimated size of the Base64 data in bytes.
+ *
+ * RETURN VALUE
+ * The size of destination buffer to use for decoding in bytes.
+ */
+int base64_est_decode_size_bytes (int base64_size_bytes)
+{
+ int length;
+
+ length = (base64_size_bytes * 3 + 3) / 4;
+ return length;
+}
+
+/*
+ * base64_encode
+ *
+ * DESCRIPTION
+ * Encode data pointed to by src into the buffer pointer to by dest
+ * using the Base64 algorithm.
+ *
+ * NOTE: No trailing '\n' character will be added.
+ *
+ * NOTE: As per specification, '\n' will be placed every 76 chars.
+ *
+ * PARAMETERS
+ * src = Pointer to the raw data to base64 encode.
+ * src_bytes = The number of bytes in the src buffer to encode.
+ * dest = Pointer to the destination buffer where the converted data
+ * will reside when complete.
+ * dest_bytes = Initially holds the size of the destination buffer
+ * but at completion holds the number of bytes converted.
+ *
+ * RETURN VALUE
+ * base64_success if the buffer was successfully converted, the
+ * appropriate error code otherwise.
+ *
+ * The dest parameter holds the converted data.
+ *
+ * The dest_bytes parameter holds the actual number of bytes converted.
+ */
+base64_result_t base64_encode(unsigned char *src, int src_bytes, unsigned char *dest, int *dest_bytes)
+{
+ int i, j=0;
+ int line_count = 0;
+ unsigned char index; /* index into base64 lookup table */
+ int smax = src_bytes-2; /* only do full multiples of 3 */
+ int dmax = *dest_bytes; /* destination maximum */
+
+ *dest_bytes = 0;
+
+ /* Do full groups. Base64 must be done in blocks of 3 src bytes */
+ for (i=0; i<smax; i+=3) {
+ /* Check to see if newline should be injected */
+ if (line_count>=MAX_BASE64_LINE_LENGTH) {
+ if (j<dmax){
+ dest[j++] = '\n';
+ } else {
+ return BASE64_BUFFER_OVERRUN;
+ }
+ line_count = 0;
+ }
+
+ line_count += 4;
+
+ if ((j+3) < dmax) {
+
+ /* Find mapping of upper 6 bits */
+ index = (src[i] >> 2) & 0x3F;
+ dest[j++] = raw_to_base64_table[index];
+
+ /* bottom 2 bits of first word, high 4 bits of second word */
+ index = ((src[i] << 4) & 0x30) | ((src[i+1] >> 4) & 0x0F);
+ dest[j++] = raw_to_base64_table[index];
+
+ /* bottom 4 bits of second word, high 2 bits of third word */
+ index = ((src[i+1] << 2) & 0x3C) | ((src[i+2] >> 6) & 0x03);
+ dest[j++] = raw_to_base64_table[index];
+
+ /* bottom 6 bits of third word */
+ index = src[i+2] & 0x3F;
+ dest[j++] = raw_to_base64_table[index];
+ } else {
+ return BASE64_BUFFER_OVERRUN;
+ }
+ }
+
+ /* Check to see if any more work must be done */
+ if (i<src_bytes) {
+
+ /* Check to see if a newline should be output */
+ if (line_count>=MAX_BASE64_LINE_LENGTH) {
+ if (j<dmax){
+ dest[j++] = '\n';
+ } else {
+ return BASE64_BUFFER_OVERRUN;
+ }
+ line_count = 0;
+ }
+
+ line_count += 4;
+
+ /* Must fill another quantum */
+ if (j+4>dmax) {
+ /* No room left in output buffer! */
+ return BASE64_BUFFER_OVERRUN;
+ }
+
+ /* Find mapping of upper 6 bits */
+ index = (src[i] >> 2) & 0x3F;
+ dest[j++] = raw_to_base64_table[index];
+
+ /* check for another stragler */
+ if ((i+1)<src_bytes) {
+ /* bottom 2 bits of first word, high 4 bits of second word */
+ index = ((src[i] << 4) & 0x30) | ((src[i+1] >> 4) & 0x0F);
+ dest[j++] = raw_to_base64_table[index];
+
+ /* bottom 4 bits of second word */
+ index = (src[i+1] << 2) & 0x3C;
+ dest[j++] = raw_to_base64_table[index];
+ dest[j++] = PAD_CHAR;
+ } else {
+ /* bottom 2 bits of first word */
+ index = (src[i] << 4) & 0x30;
+ dest[j++] = raw_to_base64_table[index];
+ dest[j++] = PAD_CHAR;
+ dest[j++] = PAD_CHAR;
+ }
+ }
+
+ *dest_bytes = j;
+
+ return BASE64_SUCCESS;
+}
+
+unsigned char base64_decode_get_raw(unsigned char index)
+{
+ /* only have 128 values, MSB must not be set! */
+ if (index >= 128) {
+ return INVALID_CHAR;
+ }
+ return base64_to_raw_table[index];
+}
+
+/*
+ * base64_decode
+ *
+ * DESCRIPTION
+ * Decode data pointed to by src into the buffer pointer to by dest
+ * using the Base64 algorithm.
+ *
+ * PARAMETERS
+ * src = Pointer to the Base64 data to decode.
+ * src_bytes = The number of bytes in the src buffer to decode.
+ * dest = Pointer to the destination buffer where the converted data
+ * will reside when complete.
+ * dest_bytes = Initially holds the size of the destination buffer
+ * but at completion holds the number of bytes converted.
+ *
+ * RETURN VALUE
+ * base64_success if the buffer was successfully converted, the
+ * appropriate error code otherwise.
+ *
+ * The dest parameter holds the converted data.
+ *
+ * The dest_bytes parameter holds the actual number of bytes converted.
+ */
+base64_result_t base64_decode(unsigned char *src, int src_bytes, unsigned char *dest, int *dest_bytes)
+{
+ int i, j = 0;
+ int sindex = 0; /* Current NON-whitespace source
+ * index */
+ int pad_count=0; /* Number of padding characters
+ * encountered */
+ int dest_size_bytes = *dest_bytes; /* Save size of destination buffer */
+ unsigned char cindex; /* The current Base64 character to
+ * process */
+ unsigned char val; /* The value of the current Base64
+ * character */
+
+ *dest_bytes = 0;
+
+ for (i=0; i<src_bytes; i++) {
+ cindex = src[i];
+
+ val = base64_decode_get_raw(cindex);
+ if (val == INVALID_CHAR) {
+ /* Invalid base64 character */
+ return BASE64_BAD_DATA;
+ }
+
+ if (val == WHITE_SPACE) {
+ /* Ignore white space */
+ continue;
+ }
+
+ if (val == PADDING) {
+ /* we must be at the end-finish up */
+ pad_count++;
+ if (++i<src_bytes) {
+ /* can have up to 2 pad chars */
+ if (base64_decode_get_raw(src[i]) != PADDING) {
+ return BASE64_BAD_PADDING;
+ }
+
+ if (++i<src_bytes) {
+ /* should not have any more padding! */
+ return BASE64_BAD_PADDING;
+ }
+
+ pad_count++;
+ }
+
+ /* DONE! */
+ break;
+ }
+
+ /* Determine which portion of the 3 bytes this data will fill */
+ switch (sindex & 0x3) {
+ case 0:
+ /* Fill upper 6 bits */
+ if (j<dest_size_bytes) {
+ dest[j] = val << 2;
+ } else {
+ return BASE64_BUFFER_OVERRUN;
+ }
+ break;
+ case 1:
+ /* Fill Bottom 2 bits */
+ dest[j++] |= val >> 4;
+
+ if (j<dest_size_bytes) {
+ /* Fill Top 4 bits */
+ dest[j] = (val << 4) & 0xF0;
+ } else {
+ /*
+ * Check to see if there is any more data present.
+ * Next base64 character MUST be a pad character and
+ * the rest of this data MUST be zero.
+ *
+ * If this is not the end of data then a buffer overrun
+ * has occurred
+ */
+ if ((val & 0x0F) ||
+ (i+1>=src_bytes) ||
+ (base64_decode_get_raw(src[i+1]) != PADDING)) {
+ return BASE64_BUFFER_OVERRUN;
+ }
+ }
+ break;
+ case 2:
+ /* Fill Bottom 4 bits */
+ dest[j++] |= val >> 2;
+
+ if (j<dest_size_bytes) {
+ /* Fill Top 2 bits */
+ dest[j] = (val << 6) & 0xC0;
+ } else {
+ /*
+ * Check to see if there is any more data present.
+ * Next base64 character MUST be a pad character and
+ * the rest of this data MUST be zero.
+ *
+ * If this is not the end of data then a buffer overrun
+ * has occurred
+ */
+ if ((val & 0x03) ||
+ (i+1>=src_bytes) ||
+ (base64_decode_get_raw(src[i+1]) != PADDING)) {
+ return BASE64_BUFFER_OVERRUN;
+ }
+ }
+ break;
+ case 3:
+ /*
+ * No need to check for overrun here since the
+ * previous case was already checked. If another
+ * group is present then case 0 will check again.
+ */
+
+ /* Fill Bottom 6 bits */
+ dest[j++] |= val;
+ break;
+ }
+ sindex++;
+ }
+
+ /* Check length for multiple of 3 bytes */
+ if (((j + pad_count)% 3) != 0) {
+ return BASE64_BAD_BLOCK_SIZE;
+ }
+
+ /* Save off the number of bytes converted */
+ *dest_bytes = j;
+
+ return BASE64_SUCCESS;
+}
diff --git a/media/webrtc/signaling/src/sdp/sipcc/sdp_base64.h b/media/webrtc/signaling/src/sdp/sipcc/sdp_base64.h
new file mode 100644
index 000000000..e264245b7
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/sdp_base64.h
@@ -0,0 +1,42 @@
+/* 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/. */
+
+#ifndef _SDP_BASE64_H_
+#define _SDP_BASE64_H_
+
+/*
+ * base64_result_t
+ * Enumeration of the result codes for Base64 conversion.
+ */
+typedef enum base64_result_t_ {
+ BASE64_INVALID=-1,
+ BASE64_SUCCESS=0,
+ BASE64_BUFFER_OVERRUN,
+ BASE64_BAD_DATA,
+ BASE64_BAD_PADDING,
+ BASE64_BAD_BLOCK_SIZE,
+ BASE64_RESULT_MAX
+} base64_result_t;
+
+#define MAX_BASE64_STRING_LEN 60
+
+/* Result code string table */
+extern char *base64_result_table[];
+
+/*
+ * BASE64_RESULT_TO_STRING
+ * Macro to convert a Base64 result code into a human readable string.
+ */
+#define BASE64_RESULT_TO_STRING(_result) (((_result)>=0 && (_result)<BASE64_RESULT_MAX)?(base64_result_table[_result]):("UNKNOWN Result Code"))
+
+/* Prototypes */
+
+int base64_est_encode_size_bytes(int raw_size_bytes);
+int base64_est_decode_size_bytes(int base64_size_bytes);
+
+base64_result_t base64_encode(unsigned char *src, int src_bytes, unsigned char *dest, int *dest_bytes);
+
+base64_result_t base64_decode(unsigned char *src, int src_bytes, unsigned char *dest, int *dest_bytes);
+
+#endif /* _SDP_BASE64_H_ */
diff --git a/media/webrtc/signaling/src/sdp/sipcc/sdp_config.c b/media/webrtc/signaling/src/sdp/sipcc/sdp_config.c
new file mode 100644
index 000000000..74ccf6b32
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/sdp_config.c
@@ -0,0 +1,241 @@
+/* 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 "sdp_os_defs.h"
+#include "sdp.h"
+#include "sdp_private.h"
+
+#include "CSFLog.h"
+
+static const char* logTag = "sdp_config";
+
+/* Function: void *sdp_init_config()
+ * Description: Initialize SDP configuration structure with the
+ * following defaults:
+ * All debug levels turned OFF.
+ * All token lines required per RFC2327.
+ * No media types supported.
+ * No network types supported.
+ * No address types supported.
+ * No transport types supported.
+ * Parameters: None.
+ * Returns: A handle for the configuration as a void ptr.
+ */
+sdp_conf_options_t *sdp_init_config ()
+{
+ int i;
+ sdp_conf_options_t *conf_p;
+
+ conf_p = SDP_MALLOC(sizeof(sdp_conf_options_t));
+
+ if (!conf_p) {
+ CSFLogError(logTag, "SDP: could not allocate configuration object.");
+ return NULL;
+ }
+
+ /* Set default debug flags. */
+ conf_p->debug_flag[SDP_DEBUG_TRACE] = FALSE;
+ conf_p->debug_flag[SDP_DEBUG_WARNINGS] = FALSE;
+ conf_p->debug_flag[SDP_DEBUG_ERRORS] = FALSE;
+
+ /* Set required lines flags. Note: Only need to set those that */
+ /* are questionable. Most lines aren't required by default. */
+ conf_p->version_reqd = TRUE;
+ conf_p->owner_reqd = TRUE;
+ conf_p->session_name_reqd = TRUE;
+ conf_p->timespec_reqd = TRUE;
+
+ /* No media types supported by default. */
+ for (i=0; i < SDP_MAX_MEDIA_TYPES; i++) {
+ conf_p->media_supported[i] = FALSE;
+ }
+
+ /* No network types supported by default. */
+ for (i=0; i < SDP_MAX_NETWORK_TYPES; i++) {
+ conf_p->nettype_supported[i] = FALSE;
+ }
+
+ /* No address types supported by default. */
+ for (i=0; i < SDP_MAX_ADDR_TYPES; i++) {
+ conf_p->addrtype_supported[i] = FALSE;
+ }
+
+ /* No transport types supported by default. */
+ for (i=0; i < SDP_MAX_TRANSPORT_TYPES; i++) {
+ conf_p->transport_supported[i] = FALSE;
+ }
+
+ /* No choose parameters allowed by default. */
+ for (i=0; i < SDP_MAX_CHOOSE_PARAMS; i++) {
+ conf_p->allow_choose[i] = FALSE;
+ }
+
+ /* Initialize statistics counts */
+ conf_p->num_parses = 0;
+ conf_p->num_builds = 0;
+ conf_p->num_not_sdp_desc = 0;
+ conf_p->num_invalid_token_order = 0;
+ conf_p->num_invalid_param = 0;
+ conf_p->num_no_resource = 0;
+
+ /* Parse error handler stuff */
+ conf_p->error_handler = NULL;
+ conf_p->error_handler_context = NULL;
+
+ CSFLogInfo(logTag, "SDP: Initialized config pointer: %p", conf_p);
+
+ return (conf_p);
+}
+
+void sdp_free_config(sdp_conf_options_t* conf_p) {
+ if (conf_p) {
+ SDP_FREE(conf_p);
+ }
+}
+
+/* Function: void sdp_appl_debug(sdp_conf_options_t *conf_p, sdp_debug_e debug_type,
+ * tinybool my_bool);
+ * Description: Define the default type of debug for the application.
+ * Valid debug types are ERRORS, WARNINGS, and TRACE. Each
+ * debug type can be turned on/off individually. The
+ * default debug level can be redefined at any time.
+ * Parameters: conf_p The config handle returned by sdp_init_config.
+ * debug_type Specifies the debug type being enabled/disabled.
+ * debug_flag Defines whether the debug should be enabled or not.
+ * Returns: Nothing.
+ */
+void sdp_appl_debug (sdp_conf_options_t *conf_p, sdp_debug_e debug_type,
+ tinybool debug_flag)
+{
+ if (debug_type < SDP_MAX_DEBUG_TYPES) {
+ conf_p->debug_flag[debug_type] = debug_flag;
+ }
+}
+
+
+/* Functions: void sdp_require_version
+ * void sdp_require_owner
+ * void sdp_require_session_name
+ * void sdp_require_timespec
+ * Description: These functions allow the application to not require several
+ * of the tokens that are specifically required by RFC 2327.
+ * Parameters: conf_p The config handle returned by sdp_init_config.
+ * version_required TRUE or FALSE whether the token should
+ * be required.
+ * Returns: Nothing.
+ */
+void sdp_require_version (sdp_conf_options_t *conf_p, tinybool version_required)
+{
+ conf_p->version_reqd = version_required;
+}
+
+void sdp_require_owner (sdp_conf_options_t *conf_p, tinybool owner_required)
+{
+ conf_p->owner_reqd = owner_required;
+}
+
+void sdp_require_session_name (sdp_conf_options_t *conf_p, tinybool sess_name_required)
+{
+ conf_p->session_name_reqd = sess_name_required;
+}
+
+void sdp_require_timespec (sdp_conf_options_t *conf_p, tinybool timespec_required)
+{
+ conf_p->timespec_reqd = timespec_required;
+}
+
+
+/* Function: sdp_media_supported
+ * Description: These functions allow the application to specify which
+ * media types it supports. The application must set any/all
+ * as required. No media types are supported by default.
+ * Parameters: conf_p The config handle returned by sdp_init_config.
+ * nettype The network type for which support is being set.
+ * media_supported TRUE or FALSE whether the support is provided.
+ * Returns: Nothing.
+ */
+void sdp_media_supported (sdp_conf_options_t *conf_p, sdp_media_e media_type,
+ tinybool media_supported)
+{
+ conf_p->media_supported[media_type] = media_supported;
+}
+
+
+/* Function: sdp_nettype_supported
+ * Description: This function allows the application to specify which
+ * network types it supports. The application must set
+ * any/all as required. No network types are supported by
+ * default.
+ * Parameters: conf_p The config handle returned by sdp_init_config.
+ * nettype The network type for which support is being set.
+ * nettype_supported TRUE or FALSE whether the support is
+ * provided.
+ * Returns: Nothing.
+ */
+void sdp_nettype_supported (sdp_conf_options_t *conf_p, sdp_nettype_e nettype,
+ tinybool nettype_supported)
+{
+ conf_p->nettype_supported[nettype] = nettype_supported;
+}
+
+
+/* Function: sdp_addrtype_supported
+ * Description: This function allows the application to specify which
+ * address types it supports. The application must set
+ * any/all as required. No address types are supported by
+ * default.
+ * Parameters: conf_p The config handle returned by sdp_init_config.
+ * addrtype The address type for which support is being set.
+ * addrtype_supported TRUE or FALSE whether the support is
+ * provided.
+ * Returns: Nothing.
+ */
+void sdp_addrtype_supported (sdp_conf_options_t *conf_p, sdp_addrtype_e addrtype,
+ tinybool addrtype_supported)
+{
+ conf_p->addrtype_supported[addrtype] = addrtype_supported;
+}
+
+
+/* Function: sdp_transport_supported
+ * Description: This function allows the application to specify which
+ * transport types it supports. The application must set
+ * any/all as required. No transport types are supported
+ * by default.
+ * Parameters: conf_p The config handle returned by sdp_init_config.
+ * transport The transport type for which support is being set.
+ * transport_supported TRUE or FALSE whether the support is
+ * provided.
+ * Returns: Nothing.
+ */
+void sdp_transport_supported (sdp_conf_options_t *conf_p, sdp_transport_e transport,
+ tinybool transport_supported)
+{
+ conf_p->transport_supported[transport] = transport_supported;
+}
+
+
+/* Function: sdp_allow_choose
+ * Description: These functions allow the CHOOSE parameter `$' to be
+ * specified in place of certain parameters.
+ * Parameters: conf_p The config handle returned by sdp_init_config.
+ * param The param that may or may not be CHOOSE.
+ * choose_allowed TRUE or FALSE whether the CHOOSE parameter
+ * should be allowed.
+ * Returns: Nothing.
+ */
+void sdp_allow_choose (sdp_conf_options_t *conf_p, sdp_choose_param_e param, tinybool choose_allowed)
+{
+ if (param < SDP_MAX_CHOOSE_PARAMS) {
+ conf_p->allow_choose[param] = choose_allowed;
+ }
+}
+
+void sdp_config_set_error_handler(sdp_conf_options_t *conf_p,
+ sdp_parse_error_handler handler,
+ void *context)
+{
+ conf_p->error_handler = handler;
+ conf_p->error_handler_context = context;
+}
diff --git a/media/webrtc/signaling/src/sdp/sipcc/sdp_main.c b/media/webrtc/signaling/src/sdp/sipcc/sdp_main.c
new file mode 100644
index 000000000..da66c1c07
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/sdp_main.c
@@ -0,0 +1,1342 @@
+/* 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 "sdp_os_defs.h"
+#include "sdp.h"
+#include "sdp_private.h"
+
+#include "CSFLog.h"
+
+static const char* logTag = "sdp_main";
+
+/* Note: These *must* be in the same order as the enum types. */
+const sdp_tokenarray_t sdp_token[SDP_MAX_TOKENS] =
+{
+ {"v=", sdp_parse_version, sdp_build_version },
+ {"o=", sdp_parse_owner, sdp_build_owner },
+ {"s=", sdp_parse_sessname, sdp_build_sessname },
+ {"i=", sdp_parse_sessinfo, sdp_build_sessinfo },
+ {"u=", sdp_parse_uri, sdp_build_uri },
+ {"e=", sdp_parse_email, sdp_build_email },
+ {"p=", sdp_parse_phonenum, sdp_build_phonenum },
+ {"c=", sdp_parse_connection, sdp_build_connection },
+ {"b=", sdp_parse_bandwidth, sdp_build_bandwidth },
+ {"t=", sdp_parse_timespec, sdp_build_timespec },
+ {"r=", sdp_parse_repeat_time, sdp_build_repeat_time },
+ {"z=", sdp_parse_timezone_adj, sdp_build_timezone_adj },
+ {"k=", sdp_parse_encryption, sdp_build_encryption },
+ {"a=", sdp_parse_attribute, sdp_build_attribute },
+ {"m=", sdp_parse_media, sdp_build_media }
+};
+
+
+/* Note: These *must* be in the same order as the enum types. */
+const sdp_attrarray_t sdp_attr[SDP_MAX_ATTR_TYPES] =
+{
+ {"bearer", sizeof("bearer"),
+ sdp_parse_attr_simple_string, sdp_build_attr_simple_string },
+ {"called", sizeof("called"),
+ sdp_parse_attr_simple_string, sdp_build_attr_simple_string },
+ {"connection_type", sizeof("connection_type"),
+ sdp_parse_attr_simple_string, sdp_build_attr_simple_string },
+ {"dialed", sizeof("dialed"),
+ sdp_parse_attr_simple_string, sdp_build_attr_simple_string },
+ {"dialing", sizeof("dialing"),
+ sdp_parse_attr_simple_string, sdp_build_attr_simple_string },
+ {"direction", sizeof("direction"),
+ sdp_parse_attr_comediadir, sdp_build_attr_comediadir },
+ {"eecid", sizeof("eecid"),
+ sdp_parse_attr_simple_u32, sdp_build_attr_simple_u32 },
+ {"fmtp", sizeof("fmtp"),
+ sdp_parse_attr_fmtp, sdp_build_attr_fmtp },
+ {"sctpmap", sizeof("sctpmap"),
+ sdp_parse_attr_sctpmap, sdp_build_attr_sctpmap },
+ {"framing", sizeof("framing"),
+ sdp_parse_attr_simple_string, sdp_build_attr_simple_string },
+ {"inactive", sizeof("inactive"),
+ sdp_parse_attr_direction, sdp_build_attr_direction },
+ {"ptime", sizeof("ptime"),
+ sdp_parse_attr_simple_u32, sdp_build_attr_simple_u32 },
+ {"qos", sizeof("qos"),
+ sdp_parse_attr_qos, sdp_build_attr_qos },
+ {"curr", sizeof("curr"),
+ sdp_parse_attr_curr, sdp_build_attr_curr },
+ {"des", sizeof("des"),
+ sdp_parse_attr_des, sdp_build_attr_des},
+ {"conf", sizeof("conf"),
+ sdp_parse_attr_conf, sdp_build_attr_conf},
+ {"recvonly", sizeof("recvonly"),
+ sdp_parse_attr_direction, sdp_build_attr_direction },
+ {"rtpmap", sizeof("rtpmap"),
+ sdp_parse_attr_transport_map, sdp_build_attr_transport_map },
+ {"secure", sizeof("secure"),
+ sdp_parse_attr_qos, sdp_build_attr_qos },
+ {"sendonly", sizeof("sendonly"),
+ sdp_parse_attr_direction, sdp_build_attr_direction },
+ {"sendrecv", sizeof("sendrecv"),
+ sdp_parse_attr_direction, sdp_build_attr_direction },
+ {"subnet", sizeof("subnet"),
+ sdp_parse_attr_subnet, sdp_build_attr_subnet },
+ {"T38FaxVersion", sizeof("T38FaxVersion"),
+ sdp_parse_attr_simple_u32, sdp_build_attr_simple_u32 },
+ {"T38MaxBitRate", sizeof("T38MaxBitRate"),
+ sdp_parse_attr_simple_u32, sdp_build_attr_simple_u32 },
+ {"T38FaxFillBitRemoval", sizeof("T38FaxFillBitRemoval"),
+ sdp_parse_attr_simple_bool, sdp_build_attr_simple_bool },
+ {"T38FaxTranscodingMMR", sizeof("T38FaxTranscodingMMR"),
+ sdp_parse_attr_simple_bool, sdp_build_attr_simple_bool },
+ {"T38FaxTranscodingJBIG", sizeof("T38FaxTranscodingJBIG"),
+ sdp_parse_attr_simple_bool, sdp_build_attr_simple_bool },
+ {"T38FaxRateManagement", sizeof("T38FaxRateManagement"),
+ sdp_parse_attr_t38_ratemgmt, sdp_build_attr_t38_ratemgmt },
+ {"T38FaxMaxBuffer", sizeof("T38FaxMaxBuffer"),
+ sdp_parse_attr_simple_u32, sdp_build_attr_simple_u32 },
+ {"T38FaxMaxDatagram", sizeof("T38FaxMaxDatagram"),
+ sdp_parse_attr_simple_u32, sdp_build_attr_simple_u32 },
+ {"T38FaxUdpEC", sizeof("T38FaxUdpEC"),
+ sdp_parse_attr_t38_udpec, sdp_build_attr_t38_udpec },
+ {"X-cap", sizeof("X-cap"),
+ sdp_parse_attr_cap, sdp_build_attr_cap },
+ {"X-cpar", sizeof("X-cpar"),
+ sdp_parse_attr_cpar, sdp_build_attr_cpar },
+ {"X-pc-codec", sizeof("X-pc-codec"),
+ sdp_parse_attr_pc_codec, sdp_build_attr_pc_codec },
+ {"X-pc-qos", sizeof("X-pc-qos"),
+ sdp_parse_attr_qos, sdp_build_attr_qos },
+ {"X-qos", sizeof("X-qos"),
+ sdp_parse_attr_qos, sdp_build_attr_qos },
+ {"X-sqn", sizeof("X-sqn"),
+ sdp_parse_attr_simple_u32, sdp_build_attr_simple_u32 },
+ {"TMRGwXid", sizeof("TMRGwXid"),
+ sdp_parse_attr_simple_bool, sdp_build_attr_simple_bool },
+ {"TC1PayloadBytes", sizeof("TC1PayloadBytes"),
+ sdp_parse_attr_simple_u32, sdp_build_attr_simple_u32 },
+ {"TC1WindowSize", sizeof("TC1WindowSize"),
+ sdp_parse_attr_simple_u32, sdp_build_attr_simple_u32 },
+ {"TC2PayloadBytes", sizeof("TC2PayloadBytes"),
+ sdp_parse_attr_simple_u32, sdp_build_attr_simple_u32 },
+ {"TC2WindowSize", sizeof("TC2WindowSize"),
+ sdp_parse_attr_simple_u32, sdp_build_attr_simple_u32 },
+ {"rtcp", sizeof("rtcp"),
+ sdp_parse_attr_rtcp, sdp_build_attr_rtcp },
+ {"rtr", sizeof("rtr"),
+ sdp_parse_attr_rtr, sdp_build_attr_rtr},
+ {"silenceSupp", sizeof("silenceSupp"),
+ sdp_parse_attr_silencesupp, sdp_build_attr_silencesupp },
+ {"X-crypto", sizeof("X-crypto"),
+ sdp_parse_attr_srtpcontext, sdp_build_attr_srtpcontext },
+ {"mptime", sizeof("mptime"),
+ sdp_parse_attr_mptime, sdp_build_attr_mptime },
+ {"X-sidin", sizeof("X-sidin"),
+ sdp_parse_attr_x_sidin, sdp_build_attr_x_sidin },
+ {"X-sidout", sizeof("X-sidout"),
+ sdp_parse_attr_x_sidout, sdp_build_attr_x_sidout },
+ {"X-confid", sizeof("X-confid"),
+ sdp_parse_attr_x_confid, sdp_build_attr_x_confid },
+ {"group", sizeof("group"),
+ sdp_parse_attr_group, sdp_build_attr_group },
+ {"mid", sizeof("mid"),
+ sdp_parse_attr_simple_string, sdp_build_attr_simple_string },
+ {"source-filter", sizeof("source-filter"),
+ sdp_parse_attr_source_filter, sdp_build_source_filter},
+ {"rtcp-unicast", sizeof("rtcp-unicast"),
+ sdp_parse_attr_rtcp_unicast, sdp_build_attr_rtcp_unicast},
+ {"maxprate", sizeof("maxprate"),
+ sdp_parse_attr_maxprate, sdp_build_attr_simple_string},
+ {"sqn", sizeof("sqn"),
+ sdp_parse_attr_simple_u32, sdp_build_attr_simple_u32 },
+ {"cdsc", sizeof("cdsc"),
+ sdp_parse_attr_cap, sdp_build_attr_cap },
+ {"cpar", sizeof("cpar"),
+ sdp_parse_attr_cpar, sdp_build_attr_cpar },
+ {"sprtmap", sizeof("sprtmap"),
+ sdp_parse_attr_transport_map, sdp_build_attr_transport_map },
+ {"crypto", sizeof("crypto"),
+ sdp_parse_attr_sdescriptions, sdp_build_attr_sdescriptions },
+ {"label", sizeof("label"),
+ sdp_parse_attr_simple_string, sdp_build_attr_simple_string },
+ {"framerate", sizeof("framerate"),
+ sdp_parse_attr_simple_u32, sdp_build_attr_simple_u32 },
+ {"candidate", sizeof("candidate"),
+ sdp_parse_attr_ice_attr, sdp_build_attr_ice_attr },
+ {"ice-ufrag", sizeof("ice-ufrag"),
+ sdp_parse_attr_ice_attr, sdp_build_attr_ice_attr },
+ {"ice-pwd", sizeof("ice-pwd"),
+ sdp_parse_attr_ice_attr, sdp_build_attr_ice_attr},
+ {"ice-lite", sizeof("ice-lite"),
+ sdp_parse_attr_simple_flag, sdp_build_attr_simple_flag},
+ {"rtcp-mux", sizeof("rtcp-mux"),
+ sdp_parse_attr_simple_flag, sdp_build_attr_simple_flag},
+ {"fingerprint", sizeof("fingerprint"),
+ sdp_parse_attr_complete_line, sdp_build_attr_simple_string},
+ {"maxptime", sizeof("maxptime"),
+ sdp_parse_attr_simple_u32, sdp_build_attr_simple_u32},
+ {"rtcp-fb", sizeof("rtcp-fb"),
+ sdp_parse_attr_rtcp_fb, sdp_build_attr_rtcp_fb},
+ {"setup", sizeof("setup"),
+ sdp_parse_attr_setup, sdp_build_attr_setup},
+ {"connection", sizeof("connection"),
+ sdp_parse_attr_connection, sdp_build_attr_connection},
+ {"extmap", sizeof("extmap"),
+ sdp_parse_attr_extmap, sdp_build_attr_extmap},
+ {"identity", sizeof("identity"),
+ sdp_parse_attr_long_line, sdp_build_attr_long_line},
+ {"msid", sizeof("msid"),
+ sdp_parse_attr_msid, sdp_build_attr_msid},
+ {"msid-semantic", sizeof("msid-semantic"),
+ sdp_parse_attr_msid_semantic, sdp_build_attr_msid_semantic},
+ {"bundle-only", sizeof("bundle-only"),
+ sdp_parse_attr_simple_flag, sdp_build_attr_simple_flag},
+ {"end-of-candidates", sizeof("end-of-candidates"),
+ sdp_parse_attr_simple_flag, sdp_build_attr_simple_flag},
+ {"ice-options", sizeof("ice-options"),
+ sdp_parse_attr_complete_line, sdp_build_attr_simple_string},
+ {"ssrc", sizeof("ssrc"),
+ sdp_parse_attr_ssrc, sdp_build_attr_ssrc},
+ {"imageattr", sizeof("imageattr"),
+ sdp_parse_attr_complete_line, sdp_build_attr_simple_string},
+ {"simulcast", sizeof("simulcast"),
+ sdp_parse_attr_complete_line, sdp_build_attr_simple_string},
+ {"rid", sizeof("rid"),
+ sdp_parse_attr_complete_line, sdp_build_attr_simple_string},
+ {"dtls-message", sizeof("dtls-message"),
+ sdp_parse_attr_long_line, sdp_build_attr_long_line},
+};
+
+/* Note: These *must* be in the same order as the enum types. */
+const sdp_namearray_t sdp_media[SDP_MAX_MEDIA_TYPES] =
+{
+ {"audio", sizeof("audio")},
+ {"video", sizeof("video")},
+ {"application", sizeof("application")},
+ {"data", sizeof("data")},
+ {"control", sizeof("control")},
+ {"nas/radius", sizeof("nas/radius")},
+ {"nas/tacacs", sizeof("nas/tacacs")},
+ {"nas/diameter", sizeof("nas/diameter")},
+ {"nas/l2tp", sizeof("nas/l2tp")},
+ {"nas/login", sizeof("nas/login")},
+ {"nas/none", sizeof("nas/none")},
+ {"image", sizeof("image")},
+ {"text", sizeof("text")}
+};
+
+
+/* Note: These *must* be in the same order as the enum types. */
+const sdp_namearray_t sdp_nettype[SDP_MAX_NETWORK_TYPES] =
+{
+ {"IN", sizeof("IN")},
+ {"ATM", sizeof("ATM")},
+ {"FR", sizeof("FR")},
+ {"LOCAL", sizeof("LOCAL")}
+};
+
+
+/* Note: These *must* be in the same order as the enum types. */
+const sdp_namearray_t sdp_addrtype[SDP_MAX_ADDR_TYPES] =
+{
+ {"IP4", sizeof("IP4")},
+ {"IP6", sizeof("IP6")},
+ {"NSAP", sizeof("NSAP")},
+ {"EPN", sizeof("EPN")},
+ {"E164", sizeof("E164")},
+ {"GWID", sizeof("GWID")}
+};
+
+
+/* Note: These *must* be in the same order as the enum type. */
+const sdp_namearray_t sdp_transport[SDP_MAX_TRANSPORT_TYPES] =
+{
+ {"RTP/AVP", sizeof("RTP/AVP")},
+ {"udp", sizeof("udp")},
+ {"udptl", sizeof("udptl")},
+ {"ces10", sizeof("ces10")},
+ {"LOCAL", sizeof("LOCAL")},
+ {"AAL2/ITU", sizeof("AAL2/ITU")},
+ {"AAL2/ATMF", sizeof("AAL2/ATMF")},
+ {"AAL2/custom", sizeof("AAL2/custom")},
+ {"AAL1/AVP", sizeof("AAL1/AVP")},
+ {"udpsprt", sizeof("udpsprt")},
+ {"RTP/SAVP", sizeof("RTP/SAVP")},
+ {"tcp", sizeof("tcp")},
+ {"RTP/SAVPF", sizeof("RTP/SAVPF")},
+ {"DTLS/SCTP", sizeof("DTLS/SCTP")},
+ {"RTP/AVPF", sizeof("RTP/AVPF")},
+ {"UDP/TLS/RTP/SAVP", sizeof("UDP/TLS/RTP/SAVP")},
+ {"UDP/TLS/RTP/SAVPF", sizeof("UDP/TLS/RTP/SAVPF")},
+ {"TCP/TLS/RTP/SAVP", sizeof("TCP/TLS/RTP/SAVP")},
+ {"TCP/TLS/RTP/SAVPF", sizeof("TCP/TLS/RTP/SAVPF")},
+};
+
+/* Note: These *must* be in the same order as the enum type. */
+const sdp_namearray_t sdp_encrypt[SDP_MAX_ENCRYPT_TYPES] =
+{
+ {"clear", sizeof("clear")},
+ {"base64", sizeof("base64")},
+ {"uri", sizeof("uri")},
+ {"prompt", sizeof("prompt")}
+};
+
+/* Note: These *must* be in the same order as the enum type. */
+const sdp_namearray_t sdp_payload[SDP_MAX_STRING_PAYLOAD_TYPES] =
+{
+ {"t38", sizeof("t38")},
+ {"X-tmr", sizeof("X-tmr")},
+ {"T120", sizeof("T120")}
+};
+
+/* Note: These *must* be in the same order as the enum type. */
+const sdp_namearray_t sdp_t38_rate[SDP_T38_MAX_RATES] =
+{
+ {"localTCF", sizeof("localTCF")},
+ {"transferredTCF", sizeof("transferredTCF")},
+ {"unknown", sizeof("unknown")}
+};
+
+/* Note: These *must* be in the same order as the enum type. */
+const sdp_namearray_t sdp_t38_udpec[SDP_T38_MAX_UDPEC] =
+{
+ {"t38UDPRedundancy", sizeof("t38UDPRedundancy")},
+ {"t38UDPFEC", sizeof("t38UDPFEC")},
+ {"unknown", sizeof("unknown")}
+};
+
+/* Note: These *must* be in the same order as the enum type. */
+const sdp_namearray_t sdp_qos_strength[SDP_MAX_QOS_STRENGTH] =
+{
+ {"optional", sizeof("optional")},
+ {"mandatory", sizeof("mandatory")},
+ {"success", sizeof("success")},
+ {"failure", sizeof("failure")},
+ {"none", sizeof("none")}
+};
+
+/* Note: These *must* be in the same order as the enum type. */
+const sdp_namearray_t sdp_qos_status_type[SDP_MAX_QOS_STATUS_TYPES] =
+{
+ {"local", sizeof("local")},
+ {"remote", sizeof("remote")},
+ {"e2e", sizeof("e2e")}
+};
+
+/* Note: These *must* be in the same order as the enum type. */
+const sdp_namearray_t sdp_curr_type[SDP_MAX_CURR_TYPES] =
+{
+ {"qos", sizeof("qos")},
+ {"unknown", sizeof("unknown")}
+};
+
+/* Note: These *must* be in the same order as the enum type. */
+const sdp_namearray_t sdp_des_type[SDP_MAX_DES_TYPES] =
+{
+ {"qos", sizeof("qos")},
+ {"unknown", sizeof("unknown")}
+};
+
+/* Note: These *must* be in the same order as the enum type. */
+const sdp_namearray_t sdp_conf_type[SDP_MAX_CONF_TYPES] =
+{
+ {"qos", sizeof("qos")},
+ {"unknown", sizeof("unknown")}
+};
+/* Note: These *must* be in the same order as the enum type. */
+const sdp_namearray_t sdp_qos_direction[SDP_MAX_QOS_DIR] =
+{
+ {"send", sizeof("send")},
+ {"recv", sizeof("recv")},
+ {"sendrecv", sizeof("sendrecv")},
+ {"none", sizeof("none")}
+};
+
+/* Note: These *must* be in the same order as the enum type. */
+const sdp_namearray_t sdp_silencesupp_pref[SDP_MAX_SILENCESUPP_PREF] = {
+ {"standard", sizeof("standard")},
+ {"custom", sizeof("custom")},
+ {"-", sizeof("-")}
+};
+
+/* Note: These *must* be in the same order as the enum type. */
+const sdp_namearray_t sdp_silencesupp_siduse[SDP_MAX_SILENCESUPP_SIDUSE] = {
+ {"No SID", sizeof("No SID")},
+ {"Fixed Noise", sizeof("Fixed Noise")},
+ {"Sampled Noise", sizeof("Sampled Noise")},
+ {"-", sizeof("-")}
+};
+
+/* Note: These *must* be in the same order as the enum type. */
+const sdp_namearray_t sdp_mediadir_role[SDP_MAX_MEDIADIR_ROLES] =
+{
+ {"passive", sizeof("passive")},
+ {"active", sizeof("active")},
+ {"both", sizeof("both")},
+ {"reuse", sizeof("reuse")},
+ {"unknown", sizeof("unknown")}
+};
+
+/* Note: These *must* be in the same order as the enum type. */
+const sdp_namearray_t sdp_fmtp_codec_param[SDP_MAX_FMTP_PARAM] =
+{
+ {"annexa", sizeof("annexa")}, /* 0 */
+ {"annexb", sizeof("annexb")}, /* 1 */
+ {"bitrate", sizeof("bitrate")}, /* 2 */
+ {"QCIF", sizeof("QCIF")}, /* 3 */
+ {"CIF", sizeof("CIF")}, /* 4 */
+ {"MAXBR", sizeof("MAXBR")}, /* 5 */
+ {"SQCIF", sizeof("SQCIF")}, /* 6 */
+ {"CIF4", sizeof("CIF4")}, /* 7 */
+ {"CIF16", sizeof("CIF16")}, /* 8 */
+ {"CUSTOM", sizeof("CUSTOM")}, /* 9 */
+ {"PAR", sizeof("PAR")}, /* 10 */
+ {"CPCF", sizeof("CPCF")}, /* 11 */
+ {"BPP", sizeof("BPP")}, /* 12 */
+ {"HRD", sizeof("HRD")}, /* 13 */
+ {"PROFILE", sizeof("PROFILE")}, /* 14 */
+ {"LEVEL", sizeof("LEVEL")}, /* 15 */
+ {"INTERLACE", sizeof("INTERLACE")}, /* 16 */
+
+ /* H.264 related */
+ {"profile-level-id", sizeof("profile-level-id")}, /* 17 */
+ {"sprop-parameter-sets", sizeof("sprop-parameter-sets")}, /* 18 */
+ {"packetization-mode", sizeof("packetization-mode")}, /* 19 */
+ {"sprop-interleaving-depth", sizeof("sprop-interleaving-depth")}, /* 20 */
+ {"sprop-deint-buf-req", sizeof("sprop-deint-buf-req")}, /* 21 */
+ {"sprop-max-don-diff", sizeof("sprop-max-don-diff")}, /* 22 */
+ {"sprop-init-buf-time", sizeof("sprop-init-buf-time")}, /* 23 */
+
+ {"max-mbps", sizeof("max-mbps")}, /* 24 */
+ {"max-fs", sizeof("max-fs")}, /* 25 */
+ {"max-cpb", sizeof("max-cpb")}, /* 26 */
+ {"max-dpb", sizeof("max-dpb")}, /* 27 */
+ {"max-br", sizeof("max-br")}, /* 28 */
+ {"redundant-pic-cap", sizeof("redundant-pic-cap")}, /* 29 */
+ {"deint-buf-cap", sizeof("deint-buf-cap")}, /* 30 */
+ {"max-rcmd-nalu-size", sizeof("max-rcmd_nali-size")}, /* 31 */
+ {"parameter-add", sizeof("parameter-add")}, /* 32 */
+
+ /* Annexes - require special handling */
+ {"D", sizeof("D")}, /* 33 */
+ {"F", sizeof("F")}, /* 34 */
+ {"I", sizeof("I")}, /* 35 */
+ {"J", sizeof("J")}, /* 36 */
+ {"T", sizeof("T")}, /* 37 */
+ {"K", sizeof("K")}, /* 38 */
+ {"N", sizeof("N")}, /* 39 */
+ {"P", sizeof("P")}, /* 40 */
+
+ {"mode", sizeof("mode")}, /* 41 */
+ {"level-asymmetry-allowed", sizeof("level-asymmetry-allowed")}, /* 42 */
+ {"maxaveragebitrate", sizeof("maxaveragebitrate")}, /* 43 */
+ {"usedtx", sizeof("usedtx")}, /* 44 */
+ {"stereo", sizeof("stereo")}, /* 45 */
+ {"useinbandfec", sizeof("useinbandfec")}, /* 46 */
+ {"maxcodedaudiobandwidth", sizeof("maxcodedaudiobandwidth")}, /* 47 */
+ {"cbr", sizeof("cbr")}, /* 48 */
+ {"max-fr", sizeof("max-fr")}, /* 49 */
+ {"maxplaybackrate", sizeof("maxplaybackrate")} /* 50 */
+} ;
+
+/* Note: These *must* be in the same order as the enum type. */
+const sdp_namearray_t sdp_fmtp_codec_param_val[SDP_MAX_FMTP_PARAM_VAL] =
+{
+ {"yes", sizeof("yes")},
+ {"no", sizeof("no")}
+};
+
+const sdp_namearray_t sdp_bw_modifier_val[SDP_MAX_BW_MODIFIER_VAL] =
+{
+ {"AS", sizeof("AS")},
+ {"CT", sizeof("CT")},
+ {"TIAS", sizeof("TIAS")}
+};
+
+const sdp_namearray_t sdp_group_attr_val[SDP_MAX_GROUP_ATTR_VAL] =
+{
+ {"FID", sizeof("FID")},
+ {"LS", sizeof("LS")},
+ {"ANAT", sizeof("ANAT")},
+ {"BUNDLE", sizeof("BUNDLE")}
+};
+
+const sdp_namearray_t sdp_srtp_context_crypto_suite[SDP_SRTP_MAX_NUM_CRYPTO_SUITES] =
+{
+ {"UNKNOWN_CRYPTO_SUITE", sizeof("UNKNOWN_CRYPTO_SUITE")},
+ {"AES_CM_128_HMAC_SHA1_32", sizeof("AES_CM_128_HMAC_SHA1_32")},
+ {"AES_CM_128_HMAC_SHA1_80", sizeof("AES_CM_128_HMAC_SHA1_80")},
+ {"F8_128_HMAC_SHA1_80", sizeof("F8_128_HMAC_SHA1_80")}
+};
+
+/* Maintain the same order as defined in typedef sdp_src_filter_mode_e */
+const sdp_namearray_t sdp_src_filter_mode_val[SDP_MAX_FILTER_MODE] =
+{
+ {"incl", sizeof("incl")},
+ {"excl", sizeof("excl")}
+};
+
+/* Maintain the same order as defined in typdef sdp_rtcp_unicast_mode_e */
+const sdp_namearray_t sdp_rtcp_unicast_mode_val[SDP_RTCP_MAX_UNICAST_MODE] =
+{
+ {"reflection", sizeof("reflection")},
+ {"rsi", sizeof("rsi")}
+};
+
+#define SDP_NAME(x) {x, sizeof(x)}
+/* Maintain the same order as defined in typdef sdp_rtcp_fb_type_e */
+const sdp_namearray_t sdp_rtcp_fb_type_val[SDP_MAX_RTCP_FB] =
+{
+ SDP_NAME("ack"),
+ SDP_NAME("ccm"),
+ SDP_NAME("nack"),
+ SDP_NAME("trr-int"),
+ SDP_NAME("goog-remb")
+};
+
+/* Maintain the same order as defined in typdef sdp_rtcp_fb_nack_type_e */
+const sdp_namearray_t sdp_rtcp_fb_nack_type_val[SDP_MAX_RTCP_FB_NACK] =
+{
+ SDP_NAME(""),
+ SDP_NAME("sli"),
+ SDP_NAME("pli"),
+ SDP_NAME("rpsi"),
+ SDP_NAME("app"),
+ SDP_NAME("rai"),
+ SDP_NAME("tllei"),
+ SDP_NAME("pslei"),
+ SDP_NAME("ecn")
+};
+
+/* Maintain the same order as defined in typdef sdp_rtcp_fb_ack_type_e */
+const sdp_namearray_t sdp_rtcp_fb_ack_type_val[SDP_MAX_RTCP_FB_ACK] =
+{
+ SDP_NAME("rpsi"),
+ SDP_NAME("app")
+};
+
+/* Maintain the same order as defined in typdef sdp_rtcp_fb_ccm_type_e */
+const sdp_namearray_t sdp_rtcp_fb_ccm_type_val[SDP_MAX_RTCP_FB_CCM] =
+{
+ SDP_NAME("fir"),
+ SDP_NAME("tmmbr"),
+ SDP_NAME("tstr"),
+ SDP_NAME("vbcm")
+};
+
+/* Maintain the same order as defined in typedef sdp_setup_type_e */
+const sdp_namearray_t sdp_setup_type_val[SDP_MAX_SETUP] =
+{
+ SDP_NAME("active"),
+ SDP_NAME("passive"),
+ SDP_NAME("actpass"),
+ SDP_NAME("holdconn")
+};
+
+/* Maintain the same order as defined in typedef sdp_connection_type_e */
+const sdp_namearray_t sdp_connection_type_val[SDP_MAX_CONNECTION] =
+{
+ SDP_NAME("new"),
+ SDP_NAME("existing")
+};
+
+/* Maintain same order as defined in typedef sdp_srtp_crypto_suite_t */
+const sdp_srtp_crypto_suite_list sdp_srtp_crypto_suite_array[SDP_SRTP_MAX_NUM_CRYPTO_SUITES] =
+{
+ {SDP_SRTP_UNKNOWN_CRYPTO_SUITE, UNKNOWN_CRYPTO_SUITE, 0, 0},
+ {SDP_SRTP_AES_CM_128_HMAC_SHA1_32, AES_CM_128_HMAC_SHA1_32,
+ SDP_SRTP_AES_CM_128_HMAC_SHA1_32_KEY_BYTES,
+ SDP_SRTP_AES_CM_128_HMAC_SHA1_32_SALT_BYTES},
+ {SDP_SRTP_AES_CM_128_HMAC_SHA1_80, AES_CM_128_HMAC_SHA1_80,
+ SDP_SRTP_AES_CM_128_HMAC_SHA1_80_KEY_BYTES,
+ SDP_SRTP_AES_CM_128_HMAC_SHA1_80_SALT_BYTES},
+ {SDP_SRTP_F8_128_HMAC_SHA1_80, F8_128_HMAC_SHA1_80,
+ SDP_SRTP_F8_128_HMAC_SHA1_80_KEY_BYTES,
+ SDP_SRTP_F8_128_HMAC_SHA1_80_SALT_BYTES}
+};
+
+const char* sdp_result_name[SDP_MAX_RC] =
+ {"SDP_SUCCESS",
+ "SDP_FAILURE",
+ "SDP_INVALID_SDP_PTR",
+ "SDP_NOT_SDP_DESCRIPTION",
+ "SDP_INVALID_TOKEN_ORDERING",
+ "SDP_INVALID_PARAMETER",
+ "SDP_INVALID_MEDIA_LEVEL",
+ "SDP_INVALID_CAPABILITY",
+ "SDP_NO_RESOURCE",
+ "SDP_UNRECOGNIZED_TOKEN",
+ "SDP_NULL_BUF_PTR",
+ "SDP_POTENTIAL_SDP_OVERFLOW",
+ "SDP_EMPTY_TOKEN"};
+
+const char *sdp_get_result_name ( sdp_result_e rc )
+{
+ if (rc >= SDP_MAX_RC) {
+ return ("Invalid SDP result code");
+ } else {
+ return (sdp_result_name[rc]);
+ }
+}
+
+const char *sdp_get_attr_name ( sdp_attr_e attr_type )
+{
+ if (attr_type >= SDP_MAX_ATTR_TYPES) {
+ return ("Invalid attribute type");
+ } else {
+ return (sdp_attr[attr_type].name);
+ }
+}
+
+const char *sdp_get_media_name ( sdp_media_e media_type )
+{
+ if (media_type == SDP_MEDIA_UNSUPPORTED) {
+ return (SDP_UNSUPPORTED);
+ } else if (media_type >= SDP_MAX_MEDIA_TYPES) {
+ return ("Invalid media type");
+ } else {
+ return (sdp_media[media_type].name);
+ }
+}
+
+const char *sdp_get_network_name ( sdp_nettype_e network_type )
+{
+ if (network_type == SDP_NT_UNSUPPORTED) {
+ return (SDP_UNSUPPORTED);
+ } else if (network_type >= SDP_MAX_NETWORK_TYPES) {
+ return ("Invalid network type");
+ } else {
+ return (sdp_nettype[network_type].name);
+ }
+}
+
+const char *sdp_get_address_name ( sdp_addrtype_e addr_type )
+{
+ if (addr_type == SDP_AT_UNSUPPORTED) {
+ return (SDP_UNSUPPORTED);
+ } else if (addr_type >= SDP_MAX_ADDR_TYPES) {
+ if (addr_type == SDP_AT_FQDN) {
+ return ("*");
+ } else {
+ return ("Invalid address type");
+ }
+ } else {
+ return (sdp_addrtype[addr_type].name);
+ }
+}
+
+const char *sdp_get_transport_name ( sdp_transport_e transport_type )
+{
+ if (transport_type == SDP_TRANSPORT_UNSUPPORTED) {
+ return (SDP_UNSUPPORTED);
+ } else if (transport_type >= SDP_MAX_TRANSPORT_TYPES) {
+ return ("Invalid transport type");
+ } else {
+ return (sdp_transport[transport_type].name);
+ }
+}
+
+const char *sdp_get_encrypt_name ( sdp_encrypt_type_e encrypt_type )
+{
+ if (encrypt_type == SDP_ENCRYPT_UNSUPPORTED) {
+ return (SDP_UNSUPPORTED);
+ } else if (encrypt_type >= SDP_MAX_ENCRYPT_TYPES) {
+ return ("Invalid encryption type");
+ } else {
+ return (sdp_encrypt[encrypt_type].name);
+ }
+}
+
+const char *sdp_get_payload_name ( sdp_payload_e payload )
+{
+ if (payload == SDP_PAYLOAD_UNSUPPORTED) {
+ return (SDP_UNSUPPORTED);
+ } else if (payload >= SDP_MAX_STRING_PAYLOAD_TYPES) {
+ return ("Invalid payload type");
+ } else {
+ return (sdp_payload[payload].name);
+ }
+}
+
+const char *sdp_get_t38_ratemgmt_name ( sdp_t38_ratemgmt_e rate )
+{
+ if (rate >= SDP_T38_MAX_RATES) {
+ return ("Invalid rate");
+ } else {
+ return (sdp_t38_rate[rate].name);
+ }
+}
+
+const char *sdp_get_t38_udpec_name ( sdp_t38_udpec_e udpec )
+{
+ if (udpec >= SDP_T38_MAX_UDPEC) {
+ return ("Invalid udpec");
+ } else {
+ return (sdp_t38_udpec[udpec].name);
+ }
+}
+
+const char *sdp_get_qos_strength_name ( sdp_qos_strength_e strength )
+{
+ if (strength >= SDP_MAX_QOS_STRENGTH) {
+ return ("Invalid qos strength");
+ } else {
+ return (sdp_qos_strength[strength].name);
+ }
+}
+
+const char *sdp_get_qos_direction_name ( sdp_qos_dir_e direction )
+{
+ if (direction >= SDP_MAX_QOS_DIR) {
+ return ("Invalid qos direction");
+ } else {
+ return (sdp_qos_direction[direction].name);
+ }
+}
+
+const char *sdp_get_qos_status_type_name ( sdp_qos_status_types_e status_type )
+{
+ if (status_type >= SDP_MAX_QOS_STATUS_TYPES) {
+ return ("Invalid qos status type");
+ } else {
+ return (sdp_qos_status_type[status_type].name);
+ }
+}
+
+const char *sdp_get_curr_type_name (sdp_curr_type_e curr_type )
+{
+ if (curr_type >= SDP_MAX_CURR_TYPES) {
+ return ("Invalid curr type");
+ } else {
+ return (sdp_curr_type[curr_type].name);
+ }
+}
+
+const char *sdp_get_des_type_name (sdp_des_type_e des_type )
+{
+ if (des_type >= SDP_MAX_DES_TYPES) {
+ return ("Invalid des type");
+ } else {
+ return (sdp_des_type[des_type].name);
+ }
+}
+
+const char *sdp_get_conf_type_name (sdp_conf_type_e conf_type )
+{
+ if (conf_type >= SDP_MAX_CONF_TYPES) {
+ return ("Invalid conf type");
+ } else {
+ return (sdp_conf_type[conf_type].name);
+ }
+}
+
+const char *sdp_get_silencesupp_pref_name (sdp_silencesupp_pref_e pref)
+{
+ if (pref >= SDP_MAX_SILENCESUPP_PREF) {
+ return ("Invalid silencesupp pref");
+ } else {
+ return (sdp_silencesupp_pref[pref].name);
+ }
+}
+
+const char *sdp_get_silencesupp_siduse_name (sdp_silencesupp_siduse_e siduse)
+{
+ if (siduse >= SDP_MAX_SILENCESUPP_SIDUSE) {
+ return ("Invalid silencesupp siduse");
+ } else {
+ return (sdp_silencesupp_siduse[siduse].name);
+ }
+}
+
+const char *sdp_get_mediadir_role_name (sdp_mediadir_role_e role)
+{
+ if (role >= SDP_MEDIADIR_ROLE_UNKNOWN) {
+ return ("Invalid media direction role");
+ } else {
+ return (sdp_mediadir_role[role].name);
+ }
+}
+
+
+const char *sdp_get_bw_modifier_name (sdp_bw_modifier_e bw_modifier_type)
+{
+ if (bw_modifier_type == SDP_BW_MODIFIER_UNSUPPORTED) {
+ return (SDP_UNSUPPORTED);
+ } else if (bw_modifier_type < SDP_BW_MODIFIER_AS ||
+ bw_modifier_type >= SDP_MAX_BW_MODIFIER_VAL) {
+ return ("Invalid bw modifier type");
+ } else {
+ return (sdp_bw_modifier_val[bw_modifier_type].name);
+ }
+}
+
+const char *sdp_get_group_attr_name (sdp_group_attr_e group_attr_type)
+{
+ if (group_attr_type == SDP_GROUP_ATTR_UNSUPPORTED) {
+ return (SDP_UNSUPPORTED);
+ } else if (group_attr_type >= SDP_MAX_GROUP_ATTR_VAL) {
+ return ("Invalid a=group: attribute type");
+ } else {
+ return (sdp_group_attr_val[group_attr_type].name);
+ }
+}
+
+const char *sdp_get_src_filter_mode_name (sdp_src_filter_mode_e type)
+{
+ if (type >= SDP_MAX_FILTER_MODE) {
+ return ("Invalid source filter mode");
+ } else {
+ return (sdp_src_filter_mode_val[type].name);
+ }
+}
+
+const char *sdp_get_rtcp_unicast_mode_name (sdp_rtcp_unicast_mode_e type)
+{
+ if (type >= SDP_RTCP_MAX_UNICAST_MODE) {
+ return ("Invalid rtcp unicast mode");
+ } else {
+ return (sdp_rtcp_unicast_mode_val[type].name);
+ }
+}
+
+/* Function: sdp_init_description
+ * Description: Allocates a new SDP structure that can be used for either
+ * parsing or building an SDP description. This routine
+ * saves the config pointer passed in the SDP structure so
+ * SDP will know how to parse/build based on the options defined.
+ * An SDP structure must be allocated before parsing or building
+ * since the handle must be passed to these routines.
+ * Parameters: config_p The config handle returned by sdp_init_config
+ * Returns: A handle for a new SDP structure as a void ptr.
+*/
+sdp_t *sdp_init_description (sdp_conf_options_t *conf_p)
+{
+ int i;
+ sdp_t *sdp_p;
+
+ if (!conf_p) {
+ return (NULL);
+ }
+
+ sdp_p = (sdp_t *)SDP_MALLOC(sizeof(sdp_t));
+ if (sdp_p == NULL) {
+ return (NULL);
+ }
+
+ sdp_p->conf_p = conf_p;
+ sdp_p->version = SDP_CURRENT_VERSION;
+ sdp_p->owner_name[0] = '\0';
+ sdp_p->owner_sessid[0] = '\0';
+ sdp_p->owner_version[0] = '\0';
+ sdp_p->owner_network_type = SDP_NT_INVALID;
+ sdp_p->owner_addr_type = SDP_AT_INVALID;
+ sdp_p->owner_addr[0] = '\0';
+ sdp_p->sessname[0] = '\0';
+ sdp_p->sessinfo_found = FALSE;
+ sdp_p->uri_found = FALSE;
+
+ sdp_p->default_conn.nettype = SDP_NT_INVALID;
+ sdp_p->default_conn.addrtype = SDP_AT_INVALID;
+ sdp_p->default_conn.conn_addr[0] = '\0';
+ sdp_p->default_conn.is_multicast = FALSE;
+ sdp_p->default_conn.ttl = 0;
+ sdp_p->default_conn.num_of_addresses = 0;
+
+ sdp_p->bw.bw_data_count = 0;
+ sdp_p->bw.bw_data_list = NULL;
+
+ sdp_p->timespec_p = NULL;
+ sdp_p->sess_attrs_p = NULL;
+ sdp_p->mca_p = NULL;
+ sdp_p->mca_count = 0;
+
+ /* Set default debug flags from application config. */
+ for (i=0; i < SDP_MAX_DEBUG_TYPES; i++) {
+ sdp_p->debug_flag[i] = conf_p->debug_flag[i];
+ }
+
+ return (sdp_p);
+}
+
+
+/* Function: void sdp_debug(sdp_t *sdp_p, sdp_debug_e debug_type,
+ * tinybool my_bool);
+ * Description: Define the type of debug for this particular SDP structure.
+ * By default, each SDP description has the settings that are
+ * set for the application.
+ * Valid debug types are ERRORS, WARNINGS, and TRACE. Each
+ * debug type can be turned on/off individually. The
+ * debug level can be redefined at any time.
+ * Parameters: sdp_ptr The SDP handle returned by sdp_init_description.
+ * debug_type Specifies the debug type being enabled/disabled.
+ * my_bool Defines whether the debug should be enabled or not.
+ * Returns: Nothing.
+ */
+void sdp_debug (sdp_t *sdp_p, sdp_debug_e debug_type, tinybool debug_flag)
+{
+ if (!sdp_p) {
+ return;
+ }
+
+ if (debug_type < SDP_MAX_DEBUG_TYPES) {
+ sdp_p->debug_flag[debug_type] = debug_flag;
+ }
+}
+
+
+/* Function: void sdp_set_string_debug(sdp_t *sdp_p, char *debug_str)
+ * Description: Define a string to be associated with all debug output
+ * for this SDP. The string will be copied into the SDP
+ * structure and so the library will not be dependent on
+ * the application's memory for this string.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description.
+ * debug_str Pointer to a string that should be printed out
+ * with every debug msg.
+ * Returns: Nothing.
+ */
+void sdp_set_string_debug (sdp_t *sdp_p, const char *debug_str)
+{
+ if (!sdp_p) {
+ return;
+ }
+
+ sstrncpy(sdp_p->debug_str, debug_str, sizeof(sdp_p->debug_str));
+}
+
+
+/* Function: sdp_validate_sdp
+ * Description: Validate an SDP structure.
+ * Parameters: sdp_p The SDP handle of the struct to validate.
+ * Returns: A result value indicating if the validation was successful.
+ * If not, what type of error was encountered.
+ */
+sdp_result_e sdp_validate_sdp (sdp_t *sdp_p)
+{
+ int i;
+ uint16_t num_media_levels;
+
+ /* Need to validate c= info is specified at session level or
+ * at all m= levels.
+ */
+ if (sdp_connection_valid((void *)sdp_p, SDP_SESSION_LEVEL) == FALSE) {
+ num_media_levels = sdp_get_num_media_lines((void *)sdp_p);
+ for (i=1; i <= num_media_levels; i++) {
+ if (sdp_connection_valid((void *)sdp_p, (unsigned short)i) == FALSE) {
+ sdp_parse_error(sdp_p,
+ "%s c= connection line not specified for "
+ "every media level, validation failed.",
+ sdp_p->debug_str);
+ return (SDP_FAILURE);
+ }
+ }
+ }
+
+ /* Validate required lines were specified */
+ if ((sdp_owner_valid((void *)sdp_p) == FALSE) &&
+ (sdp_p->conf_p->owner_reqd == TRUE)) {
+ sdp_parse_error(sdp_p,
+ "%s o= owner line not specified, validation failed.",
+ sdp_p->debug_str);
+ return (SDP_FAILURE);
+ }
+
+ if ((sdp_session_name_valid((void *)sdp_p) == FALSE) &&
+ (sdp_p->conf_p->session_name_reqd == TRUE)) {
+ sdp_parse_error(sdp_p,
+ "%s s= session name line not specified, validation failed.",
+ sdp_p->debug_str);
+ return (SDP_FAILURE);
+ }
+
+ if ((sdp_timespec_valid((void *)sdp_p) == FALSE) &&
+ (sdp_p->conf_p->timespec_reqd == TRUE)) {
+ sdp_parse_error(sdp_p,
+ "%s t= timespec line not specified, validation failed.",
+ sdp_p->debug_str);
+ return (SDP_FAILURE);
+ }
+
+ return (SDP_SUCCESS);
+}
+
+/* Function: sdp_parse
+ * Description: Parse an SDP description in the specified buffer.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description
+ * bufp Pointer to the buffer containing the SDP
+ * description to parse.
+ * len The length of the buffer.
+ * Returns: A result value indicating if the parse was successful and
+ * if not, what type of error was encountered. The
+ * information from the parse is stored in the sdp_p structure.
+ */
+sdp_result_e sdp_parse (sdp_t *sdp_p, const char *buf, size_t len)
+{
+ uint8_t i;
+ uint16_t cur_level = SDP_SESSION_LEVEL;
+ const char *ptr;
+ const char *next_ptr = NULL;
+ char *line_end;
+ sdp_token_e last_token = SDP_TOKEN_V;
+ sdp_result_e result = SDP_SUCCESS;
+ tinybool parse_done = FALSE;
+ tinybool end_found = FALSE;
+ tinybool first_line = TRUE;
+ tinybool unrec_token = FALSE;
+ const char **bufp = &buf;
+
+ if (!sdp_p) {
+ return (SDP_INVALID_SDP_PTR);
+ }
+
+ if ((bufp == NULL) || (*bufp == NULL)) {
+ return (SDP_NULL_BUF_PTR);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Trace SDP Parse:", sdp_p->debug_str);
+ }
+
+ next_ptr = *bufp;
+ sdp_p->conf_p->num_parses++;
+
+ /* Initialize the last valid capability instance to zero. Used
+ * to help in parsing X-cpar attrs. */
+ sdp_p->cap_valid = FALSE;
+ sdp_p->last_cap_inst = 0;
+
+ sdp_p->parse_line = 0;
+
+ /* We want to try to find the end of the SDP description, even if
+ * we find a parsing error.
+ */
+ while (!end_found) {
+ /* If the last char of this line goes beyond the end of the buffer,
+ * we don't parse it.
+ */
+ ptr = next_ptr;
+ sdp_p->parse_line++;
+ line_end = sdp_findchar(ptr, "\n");
+ if ((line_end >= (*bufp + len)) ||
+ (*line_end == '\0')) {
+ /* As this does not update the result value the SDP up to this point
+ * is still accept as valid. So encountering this is not treated as
+ * an error.
+ */
+ sdp_parse_error(sdp_p,
+ "%s End of line beyond end of buffer.",
+ sdp_p->debug_str);
+ CSFLogError(logTag, "SDP: Invalid SDP, no \\n (len %u): %*s",
+ (unsigned)len, (int)len, *bufp);
+ end_found = TRUE;
+ break;
+ }
+
+ /* Print the line if we're tracing. */
+ if ((parse_done == FALSE) &&
+ (sdp_p->debug_flag[SDP_DEBUG_TRACE])) {
+ SDP_PRINT("%s ", sdp_p->debug_str);
+
+ SDP_PRINT("%*s", (int)(line_end - ptr), ptr);
+
+ }
+
+ /* Find out which token this line has, if any. */
+ for (i=0; i < SDP_MAX_TOKENS; i++) {
+ if (strncmp(ptr, sdp_token[i].name, SDP_TOKEN_LEN) == 0) {
+ break;
+ }
+ }
+ if (i == SDP_MAX_TOKENS) {
+ /* See if the second char on the next line is an '=' char.
+ * If so, we note this as an unrecognized token line. */
+ if (ptr[1] == '=') {
+ unrec_token = TRUE;
+ }
+ if (first_line == TRUE) {
+ sdp_parse_error(sdp_p,
+ "%s Attempt to parse text not recognized as "
+ "SDP text, parse fails.", sdp_p->debug_str);
+ /* If we haven't already printed out the line we
+ * were trying to parse, do it now.
+ */
+ if (!sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s ", sdp_p->debug_str);
+ SDP_PRINT("%*s", (int)(line_end - ptr), ptr);
+ }
+ sdp_p->conf_p->num_not_sdp_desc++;
+ return (SDP_NOT_SDP_DESCRIPTION);
+ } else {
+ end_found = TRUE;
+ break;
+ }
+ }
+
+ /* This is the beginning of a new SDP description. */
+ if ((first_line != TRUE) && (i == SDP_TOKEN_V)) {
+ end_found = TRUE;
+ break;
+ }
+
+ /* Advance the next ptr to one char beyond the end of the line. */
+ next_ptr = line_end + 1;
+ if (next_ptr >= (*bufp + len)) {
+ end_found = TRUE;
+ }
+
+ /* If we've finished parsing and are just looking for the end of
+ * the SDP description, we don't need to do anything else here.
+ */
+ if (parse_done == TRUE) {
+ continue;
+ }
+
+ /* Only certain tokens are valid at the media level. */
+ if (cur_level != SDP_SESSION_LEVEL) {
+ if ((i != SDP_TOKEN_I) && (i != SDP_TOKEN_C) &&
+ (i != SDP_TOKEN_B) && (i != SDP_TOKEN_K) &&
+ (i != SDP_TOKEN_A) && (i != SDP_TOKEN_M)) {
+ sdp_p->conf_p->num_invalid_token_order++;
+ sdp_parse_error(sdp_p,
+ "%s Warning: Invalid token %s found at media level",
+ sdp_p->debug_str, sdp_token[i].name);
+ continue;
+ }
+ }
+
+ /* Verify the token ordering. */
+ if (first_line == TRUE) {
+ if (i != SDP_TOKEN_V) {
+ if (sdp_p->conf_p->version_reqd == TRUE) {
+ sdp_parse_error(sdp_p,
+ "%s First line not v=, parse fails",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_token_order++;
+ result = SDP_INVALID_TOKEN_ORDERING;
+ parse_done = TRUE;
+ } else {
+ last_token = (sdp_token_e)i;
+ }
+ } else {
+ last_token = (sdp_token_e)i;
+ }
+ first_line = FALSE;
+ } else {
+ if (i < last_token) {
+ sdp_p->conf_p->num_invalid_token_order++;
+ sdp_parse_error(sdp_p,
+ "%s Warning: Invalid token ordering detected, "
+ "token %s found after token %s", sdp_p->debug_str,
+ sdp_token[i].name, sdp_token[last_token].name);
+ }
+ }
+
+ /* Finally parse the line. */
+ ptr += SDP_TOKEN_LEN;
+ result = sdp_token[i].parse_func(sdp_p, cur_level, (const char *)ptr);
+ last_token = (sdp_token_e)i;
+ if (last_token == SDP_TOKEN_M) {
+ if (cur_level == SDP_SESSION_LEVEL) {
+ cur_level = 1;
+ } else {
+ cur_level++;
+ }
+ /* The token ordering can start again at i= */
+ last_token = (sdp_token_e)(SDP_TOKEN_I - 1);
+ }
+ if (result != SDP_SUCCESS) {
+ parse_done = TRUE;
+ }
+
+ /* Skip the new line char at the end of this line and see if
+ * this is the end of the buffer.
+ */
+ if ((line_end + 1) == (*bufp + len)) {
+ end_found = TRUE;
+ }
+ }
+
+ /* If we found no valid lines, return an error. */
+ if (first_line == TRUE) {
+ sdp_p->conf_p->num_not_sdp_desc++;
+ return (SDP_NOT_SDP_DESCRIPTION);
+ }
+
+ /* If no errors were found yet, validate the overall sdp. */
+ if (result == SDP_SUCCESS) {
+ result = sdp_validate_sdp(sdp_p);
+ }
+ /* Return the pointer where we left off. */
+ *bufp = next_ptr;
+ /* If the SDP is valid, but the next line following was an
+ * unrecognized <token>= line, indicate this on the return. */
+ if ((result == SDP_SUCCESS) && (unrec_token == TRUE)) {
+ return (SDP_UNRECOGNIZED_TOKEN);
+ } else {
+ return (result);
+ }
+}
+
+
+/* Function: sdp_build
+ * Description: Build an SDP description in the specified buffer based
+ * on the information in the given SDP structure.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description
+ * fs A flex_string where the SDP description should be built.
+ * Returns: A result value indicating if the build was successful and
+ * if not, what type of error was encountered - e.g.,
+ * description was too long for the given buffer.
+ */
+sdp_result_e sdp_build (sdp_t *sdp_p, flex_string *fs)
+{
+ int i, j;
+ sdp_result_e result = SDP_SUCCESS;
+
+ if (!sdp_p) {
+ return (SDP_INVALID_SDP_PTR);
+ }
+
+ if (!fs) {
+ return (SDP_NULL_BUF_PTR);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Trace SDP Build:", sdp_p->debug_str);
+ }
+
+ sdp_p->conf_p->num_builds++;
+
+ for (i=0; ((i < SDP_TOKEN_M) &&
+ (result == SDP_SUCCESS)); i++) {
+ result = sdp_token[i].build_func(sdp_p, SDP_SESSION_LEVEL, fs);
+ /* ok not to check buffer space (yet) as the if() checks it */
+ }
+ /* If the session level was ok, build the media lines. */
+ if (result == SDP_SUCCESS) {
+ for (i=1; ((i <= sdp_p->mca_count) &&
+ (result == SDP_SUCCESS)); i++) {
+ result = sdp_token[SDP_TOKEN_M].build_func(sdp_p, (uint16_t)i, fs);
+
+ /* ok not to check buffer space (yet) as the for() checks it */
+ for (j=SDP_TOKEN_I;
+ ((j < SDP_TOKEN_M) && (result == SDP_SUCCESS));
+ j++) {
+ if ((j == SDP_TOKEN_U) || (j == SDP_TOKEN_E) ||
+ (j == SDP_TOKEN_P) || (j == SDP_TOKEN_T) ||
+ (j == SDP_TOKEN_R) || (j == SDP_TOKEN_Z)) {
+ /* These tokens not valid at media level. */
+ continue;
+ }
+ result = sdp_token[j].build_func(sdp_p, (uint16_t)i, fs);
+ /* ok not to check buffer space (yet) as the for() checks it */
+ }
+ }
+ }
+
+ return (result);
+}
+
+/* Function: sdp_free_description
+ * Description: Free an SDP description and all memory associated with it.
+ * Parameters: sdp_p The SDP handle returned by sdp_init_description
+ * Returns: A result value indicating if the free was successful and
+ * if not, what type of error was encountered - e.g., sdp_p
+ * was invalid and didn't point to an SDP structure.
+*/
+sdp_result_e sdp_free_description (sdp_t *sdp_p)
+{
+ sdp_timespec_t *time_p, *next_time_p;
+ sdp_attr_t *attr_p, *next_attr_p;
+ sdp_mca_t *mca_p, *next_mca_p;
+ sdp_bw_t *bw_p;
+ sdp_bw_data_t *bw_data_p;
+
+ if (!sdp_p) {
+ return (SDP_INVALID_SDP_PTR);
+ }
+
+ /* Free the config structure */
+ sdp_free_config(sdp_p->conf_p);
+
+ /* Free any timespec structures - should be only one since
+ * this is all we currently support.
+ */
+ time_p = sdp_p->timespec_p;
+ while (time_p != NULL) {
+ next_time_p = time_p->next_p;
+ SDP_FREE(time_p);
+ time_p = next_time_p;
+ }
+
+ bw_p = &(sdp_p->bw);
+ bw_data_p = bw_p->bw_data_list;
+ while (bw_data_p != NULL) {
+ bw_p->bw_data_list = bw_data_p->next_p;
+ SDP_FREE(bw_data_p);
+ bw_data_p = bw_p->bw_data_list;
+ }
+
+ /* Free any session attr structures */
+ attr_p = sdp_p->sess_attrs_p;
+ while (attr_p != NULL) {
+ next_attr_p = attr_p->next_p;
+ sdp_free_attr(attr_p);
+ attr_p = next_attr_p;
+ }
+
+ /* Free any mca structures */
+ mca_p = sdp_p->mca_p;
+ while (mca_p != NULL) {
+ next_mca_p = mca_p->next_p;
+
+ /* Free any media attr structures */
+ attr_p = mca_p->media_attrs_p;
+ while (attr_p != NULL) {
+ next_attr_p = attr_p->next_p;
+ sdp_free_attr(attr_p);
+ attr_p = next_attr_p;
+ }
+
+ /* Free the media profiles struct if allocated. */
+ if (mca_p->media_profiles_p != NULL) {
+ SDP_FREE(mca_p->media_profiles_p);
+ }
+
+ bw_p = &(mca_p->bw);
+ bw_data_p = bw_p->bw_data_list;
+ while (bw_data_p != NULL) {
+ bw_p->bw_data_list = bw_data_p->next_p;
+ SDP_FREE(bw_data_p);
+ bw_data_p = bw_p->bw_data_list;
+ }
+
+ SDP_FREE(mca_p);
+ mca_p = next_mca_p;
+ }
+
+ SDP_FREE(sdp_p);
+
+ return (SDP_SUCCESS);
+}
+
+/*
+ * sdp_parse_error
+ * Send SDP parsing errors to log and up to peerconnection
+ */
+void sdp_parse_error(sdp_t* sdp, const char *format, ...) {
+ flex_string fs;
+ va_list ap;
+
+ flex_string_init(&fs);
+
+ va_start(ap, format);
+ flex_string_vsprintf(&fs, format, ap);
+ va_end(ap);
+
+ CSFLogError("SDP Parse", "SDP Parse Error %s, line %u", fs.buffer,
+ sdp->parse_line);
+
+ if (sdp->conf_p->error_handler) {
+ sdp->conf_p->error_handler(sdp->conf_p->error_handler_context,
+ sdp->parse_line,
+ fs.buffer);
+ }
+
+ flex_string_free(&fs);
+}
diff --git a/media/webrtc/signaling/src/sdp/sipcc/sdp_os_defs.h b/media/webrtc/signaling/src/sdp/sipcc/sdp_os_defs.h
new file mode 100644
index 000000000..6e4dd8c64
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/sdp_os_defs.h
@@ -0,0 +1,27 @@
+/* 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/. */
+
+#ifndef _SDP_OS_DEFS_H_
+#define _SDP_OS_DEFS_H_
+
+#include <stdlib.h>
+
+#include "cpr_types.h"
+#include "cpr_string.h"
+
+
+#define SDP_PRINT(format, ...) CSFLogError("sdp" , format , ## __VA_ARGS__ )
+
+/* Use operating system malloc */
+#define SDP_MALLOC(x) calloc(1, (x))
+#define SDP_FREE free
+
+typedef uint8_t tinybool;
+typedef unsigned short ushort;
+typedef unsigned long ulong;
+#ifndef __GNUC_STDC_INLINE__
+#define inline
+#endif
+
+#endif /* _SDP_OS_DEFS_H_ */
diff --git a/media/webrtc/signaling/src/sdp/sipcc/sdp_private.h b/media/webrtc/signaling/src/sdp/sipcc/sdp_private.h
new file mode 100644
index 000000000..a98f4b119
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/sdp_private.h
@@ -0,0 +1,364 @@
+/* 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/. */
+
+#ifndef _SIPCC_SDP_PRIVATE_H_
+#define _SIPCC_SDP_PRIVATE_H_
+
+
+#include "sdp.h"
+
+extern const sdp_attrarray_t sdp_attr[];
+extern const sdp_namearray_t sdp_media[];
+extern const sdp_namearray_t sdp_nettype[];
+extern const sdp_namearray_t sdp_addrtype[];
+extern const sdp_namearray_t sdp_transport[];
+extern const sdp_namearray_t sdp_encrypt[];
+extern const sdp_namearray_t sdp_payload[];
+extern const sdp_namearray_t sdp_t38_rate[];
+extern const sdp_namearray_t sdp_t38_udpec[];
+extern const sdp_namearray_t sdp_qos_strength[];
+extern const sdp_namearray_t sdp_qos_direction[];
+extern const sdp_namearray_t sdp_qos_status_type[];
+extern const sdp_namearray_t sdp_curr_type[];
+extern const sdp_namearray_t sdp_des_type[];
+extern const sdp_namearray_t sdp_conf_type[];
+extern const sdp_namearray_t sdp_mediadir_role[];
+extern const sdp_namearray_t sdp_fmtp_codec_param[];
+extern const sdp_namearray_t sdp_fmtp_codec_param_val[];
+extern const sdp_namearray_t sdp_silencesupp_pref[];
+extern const sdp_namearray_t sdp_silencesupp_siduse[];
+extern const sdp_namearray_t sdp_srtp_context_crypto_suite[];
+extern const sdp_namearray_t sdp_bw_modifier_val[];
+extern const sdp_namearray_t sdp_group_attr_val[];
+extern const sdp_namearray_t sdp_src_filter_mode_val[];
+extern const sdp_namearray_t sdp_rtcp_unicast_mode_val[];
+extern const sdp_namearray_t sdp_rtcp_fb_type_val[];
+extern const sdp_namearray_t sdp_rtcp_fb_nack_type_val[];
+extern const sdp_namearray_t sdp_rtcp_fb_ack_type_val[];
+extern const sdp_namearray_t sdp_rtcp_fb_ccm_type_val[];
+extern const sdp_namearray_t sdp_setup_type_val[];
+extern const sdp_namearray_t sdp_connection_type_val[];
+
+
+extern const sdp_srtp_crypto_suite_list sdp_srtp_crypto_suite_array[];
+/* Function Prototypes */
+
+/* sdp_access.c */
+extern sdp_mca_t *sdp_find_media_level(sdp_t *sdp_p, uint16_t level);
+extern sdp_bw_data_t* sdp_find_bw_line (sdp_t *sdp_ptr, uint16_t level, uint16_t inst_num);
+
+/* sdp_attr.c */
+extern sdp_result_e
+sdp_build_attr_fmtp_params (sdp_t *sdp_p, sdp_fmtp_t *attr_p, flex_string *fs);
+
+extern sdp_result_e sdp_parse_attribute(sdp_t *sdp_p, uint16_t level,
+ const char *ptr);
+extern sdp_result_e sdp_parse_attr_simple_string(sdp_t *sdp_p,
+ sdp_attr_t *attr_p, const char *ptr);
+extern sdp_result_e sdp_build_attr_simple_string(sdp_t *sdp_p,
+ sdp_attr_t *attr_p, flex_string *fs);
+extern sdp_result_e sdp_parse_attr_simple_u32(sdp_t *sdp_p,
+ sdp_attr_t *attr_p, const char *ptr);
+extern sdp_result_e sdp_build_attr_simple_u32(sdp_t *sdp_p,
+ sdp_attr_t *attr_p, flex_string *fs);
+extern sdp_result_e sdp_parse_attr_simple_bool(sdp_t *sdp_p,
+ sdp_attr_t *attr_p, const char *ptr);
+extern sdp_result_e sdp_build_attr_simple_bool(sdp_t *sdp_p,
+ sdp_attr_t *attr_p, flex_string *fs);
+extern sdp_result_e sdp_parse_attr_maxprate(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_parse_attr_fmtp(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_fmtp(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_sctpmap(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_sctpmap(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_msid(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_msid(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_msid_semantic(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_msid_semantic(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_ssrc(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_ssrc(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_direction(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_direction(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_qos(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_qos(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_curr(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_curr (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_des(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_des (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_conf(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_conf (sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_transport_map(sdp_t *sdp_p,
+ sdp_attr_t *attr_p, const char *ptr);
+extern sdp_result_e sdp_build_attr_transport_map(sdp_t *sdp_p,
+ sdp_attr_t *attr_p, flex_string *fs);
+extern sdp_result_e sdp_parse_attr_subnet(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_subnet(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_t38_ratemgmt(sdp_t *sdp_p,
+ sdp_attr_t *attr_p, const char *ptr);
+extern sdp_result_e sdp_build_attr_t38_ratemgmt(sdp_t *sdp_p,
+ sdp_attr_t *attr_p, flex_string *fs);
+extern sdp_result_e sdp_parse_attr_t38_udpec(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_t38_udpec(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_cap(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_cap(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_cpar(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_cpar(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_pc_codec(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_pc_codec(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_xcap(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_xcap(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_xcpar(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_xcpar(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_rtcp(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_rtcp(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_rtr(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_rtr(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_comediadir(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_comediadir(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_silencesupp(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_silencesupp(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_srtpcontext(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_srtpcontext(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_rtcp_fb(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_rtcp_fb(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_setup(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_setup(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_connection(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_connection(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_extmap(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ const char *ptr);
+extern sdp_result_e sdp_build_attr_extmap(sdp_t *sdp_p,
+ sdp_attr_t *attr_p,
+ flex_string *fs);
+extern sdp_result_e sdp_parse_attr_mptime(
+ sdp_t *sdp_p, sdp_attr_t *attr_p, const char *ptr);
+extern sdp_result_e sdp_build_attr_mptime(
+ sdp_t *sdp_p, sdp_attr_t *attr_p, flex_string *fs);
+extern sdp_result_e sdp_parse_attr_x_sidin(
+ sdp_t *sdp_p, sdp_attr_t *attr_p, const char *ptr);
+extern sdp_result_e sdp_build_attr_x_sidin(
+ sdp_t *sdp_p, sdp_attr_t *attr_p, flex_string *fs);
+
+extern sdp_result_e sdp_parse_attr_x_sidout(
+ sdp_t *sdp_p, sdp_attr_t *attr_p, const char *ptr);
+extern sdp_result_e sdp_build_attr_x_sidout(
+ sdp_t *sdp_p, sdp_attr_t *attr_p, flex_string *fs);
+
+extern sdp_result_e sdp_parse_attr_x_confid(
+ sdp_t *sdp_p, sdp_attr_t *attr_p, const char *ptr);
+extern sdp_result_e sdp_build_attr_x_confid(
+ sdp_t *sdp_p, sdp_attr_t *attr_p, flex_string *fs);
+
+extern sdp_result_e sdp_parse_attr_group(
+ sdp_t *sdp_p, sdp_attr_t *attr_p, const char *ptr);
+extern sdp_result_e sdp_build_attr_group(
+ sdp_t *sdp_p, sdp_attr_t *attr_p, flex_string *fs);
+
+extern sdp_result_e sdp_parse_attr_source_filter(
+ sdp_t *sdp_p, sdp_attr_t *attr_p, const char *ptr);
+extern sdp_result_e sdp_build_source_filter(
+ sdp_t *sdp_p, sdp_attr_t *attr_p, flex_string *fs);
+
+extern sdp_result_e sdp_parse_attr_rtcp_unicast(
+ sdp_t *sdp_p, sdp_attr_t *attr_p, const char *ptr);
+extern sdp_result_e sdp_build_attr_rtcp_unicast(
+ sdp_t *sdp_p, sdp_attr_t *attr_p, flex_string *fs);
+
+extern sdp_result_e sdp_build_attr_ice_attr (
+ sdp_t *sdp_p, sdp_attr_t *attr_p, flex_string *fs);
+extern sdp_result_e sdp_parse_attr_ice_attr (
+ sdp_t *sdp_p, sdp_attr_t *attr_p, const char *ptr);
+
+extern sdp_result_e sdp_build_attr_simple_flag (
+ sdp_t *sdp_p, sdp_attr_t *attr_p, flex_string *fs);
+extern sdp_result_e sdp_parse_attr_simple_flag (
+ sdp_t *sdp_p, sdp_attr_t *attr_p, const char *ptr);
+
+extern sdp_result_e sdp_parse_attr_complete_line (
+ sdp_t *sdp_p, sdp_attr_t *attr_p, const char *ptr);
+extern sdp_result_e sdp_parse_attr_long_line(sdp_t *sdp_p,
+ sdp_attr_t *attr_p, const char *ptr);
+extern sdp_result_e sdp_build_attr_long_line(sdp_t *sdp_p,
+ sdp_attr_t *attr_p, flex_string *fs);
+
+/* sdp_attr_access.c */
+extern void sdp_free_attr(sdp_attr_t *attr_p);
+extern sdp_result_e sdp_find_attr_list(sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ sdp_attr_t **attr_p, char *fname);
+extern sdp_attr_t *sdp_find_attr(sdp_t *sdp_p, uint16_t level, uint8_t cap_num,
+ sdp_attr_e attr_type, uint16_t inst_num);
+extern sdp_attr_t *sdp_find_capability(sdp_t *sdp_p, uint16_t level, uint8_t cap_num);
+
+/* sdp_main.c */
+extern const char *sdp_get_attr_name(sdp_attr_e attr_type);
+extern const char *sdp_get_media_name(sdp_media_e media_type);
+extern const char *sdp_get_network_name(sdp_nettype_e network_type);
+extern const char *sdp_get_address_name(sdp_addrtype_e addr_type);
+extern const char *sdp_get_transport_name(sdp_transport_e transport_type);
+extern const char *sdp_get_encrypt_name(sdp_encrypt_type_e encrypt_type);
+extern const char *sdp_get_payload_name(sdp_payload_e payload);
+extern const char *sdp_get_t38_ratemgmt_name(sdp_t38_ratemgmt_e rate);
+extern const char *sdp_get_t38_udpec_name(sdp_t38_udpec_e udpec);
+extern const char *sdp_get_qos_strength_name(sdp_qos_strength_e strength);
+extern const char *sdp_get_qos_direction_name(sdp_qos_dir_e direction);
+extern const char *sdp_get_qos_status_type_name(sdp_qos_status_types_e status_type);
+extern const char *sdp_get_curr_type_name(sdp_curr_type_e curr_type);
+extern const char *sdp_get_des_type_name(sdp_des_type_e des_type);
+extern const char *sdp_get_conf_type_name(sdp_conf_type_e conf_type);
+extern const char *sdp_get_mediadir_role_name (sdp_mediadir_role_e role);
+extern const char *sdp_get_silencesupp_pref_name(sdp_silencesupp_pref_e pref);
+extern const char *sdp_get_silencesupp_siduse_name(sdp_silencesupp_siduse_e
+ siduse);
+
+extern const char *sdp_get_group_attr_name(sdp_group_attr_e group_attr);
+extern const char *sdp_get_src_filter_mode_name(sdp_src_filter_mode_e type);
+extern const char *sdp_get_rtcp_unicast_mode_name(sdp_rtcp_unicast_mode_e type);
+
+/* sdp_tokens.c */
+extern sdp_result_e sdp_parse_version(sdp_t *sdp_p, uint16_t token,
+ const char *ptr);
+extern sdp_result_e sdp_build_version(sdp_t *sdp_p, uint16_t token, flex_string *fs);
+extern sdp_result_e sdp_parse_owner(sdp_t *sdp_p, uint16_t token,
+ const char *ptr);
+extern sdp_result_e sdp_build_owner(sdp_t *sdp_p, uint16_t token, flex_string *fs);
+extern sdp_result_e sdp_parse_sessname(sdp_t *sdp_p, uint16_t token,
+ const char *ptr);
+extern sdp_result_e sdp_build_sessname(sdp_t *sdp_p, uint16_t token, flex_string *fs);
+extern sdp_result_e sdp_parse_sessinfo(sdp_t *sdp_p, uint16_t token,
+ const char *ptr);
+extern sdp_result_e sdp_build_sessinfo(sdp_t *sdp_p, uint16_t token, flex_string *fs);
+extern sdp_result_e sdp_parse_uri(sdp_t *sdp_p, uint16_t token, const char *ptr);
+extern sdp_result_e sdp_build_uri(sdp_t *sdp_p, uint16_t token, flex_string *fs);
+extern sdp_result_e sdp_parse_email(sdp_t *sdp_p, uint16_t token, const char *ptr);
+extern sdp_result_e sdp_build_email(sdp_t *sdp_p, uint16_t token, flex_string *fs);
+extern sdp_result_e sdp_parse_phonenum(sdp_t *sdp_p, uint16_t token,
+ const char *ptr);
+extern sdp_result_e sdp_build_phonenum(sdp_t *sdp_p, uint16_t token, flex_string *fs);
+extern sdp_result_e sdp_parse_connection(sdp_t *sdp_p, uint16_t token,
+ const char *ptr);
+extern sdp_result_e sdp_build_connection(sdp_t *sdp_p, uint16_t token, flex_string *fs);
+extern sdp_result_e sdp_parse_bandwidth(sdp_t *sdp_p, uint16_t token,
+ const char *ptr);
+extern sdp_result_e sdp_build_bandwidth(sdp_t *sdp_p, uint16_t token, flex_string *fs);
+extern sdp_result_e sdp_parse_timespec(sdp_t *sdp_p, uint16_t token,
+ const char *ptr);
+extern sdp_result_e sdp_build_timespec(sdp_t *sdp_p, uint16_t token, flex_string *fs);
+extern sdp_result_e sdp_parse_repeat_time(sdp_t *sdp_p, uint16_t token,
+ const char *ptr);
+extern sdp_result_e sdp_build_repeat_time(sdp_t *sdp_p, uint16_t token, flex_string *fs);
+extern sdp_result_e sdp_parse_timezone_adj(sdp_t *sdp_p, uint16_t token,
+ const char *ptr);
+extern sdp_result_e sdp_build_timezone_adj(sdp_t *sdp_p, uint16_t token, flex_string *fs);
+extern sdp_result_e sdp_parse_encryption(sdp_t *sdp_p, uint16_t token,
+ const char *ptr);
+extern sdp_result_e sdp_build_encryption(sdp_t *sdp_p, uint16_t token, flex_string *fs);
+extern sdp_result_e sdp_parse_media(sdp_t *sdp_p, uint16_t token, const char *ptr);
+extern sdp_result_e sdp_build_media(sdp_t *sdp_p, uint16_t token, flex_string *fs);
+extern sdp_result_e sdp_parse_attribute(sdp_t *sdp_p, uint16_t token,
+ const char *ptr);
+extern sdp_result_e sdp_build_attribute(sdp_t *sdp_p, uint16_t token, flex_string *fs);
+
+extern void sdp_parse_payload_types(sdp_t *sdp_p, sdp_mca_t *mca_p,
+ const char *ptr);
+extern sdp_result_e sdp_parse_multiple_profile_payload_types(sdp_t *sdp_p,
+ sdp_mca_t *mca_p,
+ const char *ptr);
+extern sdp_result_e
+sdp_parse_attr_sdescriptions(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ const char *ptr);
+
+extern sdp_result_e
+sdp_build_attr_sdescriptions(sdp_t *sdp_p, sdp_attr_t *attr_p,
+ flex_string *fs);
+
+
+/* sdp_utils.c */
+extern sdp_mca_t *sdp_alloc_mca(uint32_t line);
+extern tinybool sdp_validate_maxprate(const char *string_parm);
+extern char *sdp_findchar(const char *ptr, char *char_list);
+extern const char *sdp_getnextstrtok(const char *str, char *tokenstr, unsigned tokenstr_len,
+ const char *delim, sdp_result_e *result);
+extern uint32_t sdp_getnextnumtok(const char *str, const char **str_end,
+ const char *delim, sdp_result_e *result);
+extern uint32_t sdp_getnextnumtok_or_null(const char *str, const char **str_end,
+ const char *delim, tinybool *null_ind,
+ sdp_result_e *result);
+extern tinybool sdp_getchoosetok(const char *str, const char **str_end,
+ const char *delim, sdp_result_e *result);
+
+extern
+tinybool verify_sdescriptions_mki(char *buf, char *mkiVal, uint16_t *mkiLen);
+
+extern
+tinybool verify_sdescriptions_lifetime(char *buf);
+
+/* sdp_services_xxx.c */
+extern void sdp_dump_buffer(char *_ptr, int _size_bytes);
+
+tinybool sdp_checkrange(sdp_t *sdp, char *num, ulong* lval);
+
+#endif /* _SDP_PRIVATE_H_ */
diff --git a/media/webrtc/signaling/src/sdp/sipcc/sdp_services_unix.c b/media/webrtc/signaling/src/sdp/sipcc/sdp_services_unix.c
new file mode 100644
index 000000000..8f43adc43
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/sdp_services_unix.c
@@ -0,0 +1,41 @@
+/* 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 "sdp_os_defs.h"
+#include "sdp.h"
+#include "sdp_private.h"
+
+#include "CSFLog.h"
+
+/******************************************************************/
+/* Required Platform Routines */
+/* */
+/* These routines are called from the common SDP code. */
+/* They must be provided for each platform. */
+/* */
+/******************************************************************/
+
+/*
+ * sdp_dump_buffer
+ *
+ * Utility to send _size_bytes of data from the string
+ * pointed to by _ptr to the buginf function. This may make
+ * multiple buginf calls if the buffer is too large for buginf.
+ */
+void sdp_dump_buffer (char * _ptr, int _size_bytes)
+{
+ CSFLogDebug("sdp", "%s", _ptr);
+}
+
+/******************************************************************/
+/* */
+/* Platform Specific Routines */
+/* */
+/* These routines are only used in this particular platform. */
+/* They are called from the required platform specific */
+/* routines provided below, not from the common SDP code. */
+/* */
+/******************************************************************/
+
+/* There are currently no platform specific routines required. */
diff --git a/media/webrtc/signaling/src/sdp/sipcc/sdp_services_win32.c b/media/webrtc/signaling/src/sdp/sipcc/sdp_services_win32.c
new file mode 100644
index 000000000..1815abbfe
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/sdp_services_win32.c
@@ -0,0 +1,40 @@
+/* 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 "sdp_os_defs.h"
+#include "sdp.h"
+#include "sdp_private.h"
+
+
+/******************************************************************/
+/* Required Platform Routines */
+/* */
+/* These routines are called from the common SDP code. */
+/* They must be provided for each platform. */
+/* */
+/******************************************************************/
+
+/*
+ * sdp_dump_buffer
+ *
+ * Utility to send _size_bytes of data from the string
+ * pointed to by _ptr to the buginf function. This may make
+ * multiple buginf calls if the buffer is too large for buginf.
+ */
+void sdp_dump_buffer (char * _ptr, int _size_bytes)
+{
+ CSFLogDebug("sdp", _ptr);
+}
+
+/******************************************************************/
+/* */
+/* Platform Specific Routines */
+/* */
+/* These routines are only used in this particular platform. */
+/* They are called from the required platform specific */
+/* routines provided below, not from the common SDP code. */
+/* */
+/******************************************************************/
+
+/* There are currently no platform specific routines required. */
diff --git a/media/webrtc/signaling/src/sdp/sipcc/sdp_token.c b/media/webrtc/signaling/src/sdp/sipcc/sdp_token.c
new file mode 100644
index 000000000..a002f9a73
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/sdp_token.c
@@ -0,0 +1,1812 @@
+/* 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 <errno.h>
+
+#include "sdp_os_defs.h"
+#include "sdp.h"
+#include "sdp_private.h"
+
+#include "CSFLog.h"
+#include "prprf.h"
+
+static const char *logTag = "sdp_token";
+
+#define MCAST_STRING_LEN 4
+
+
+sdp_result_e sdp_parse_version (sdp_t *sdp_p, uint16_t level, const char *ptr)
+{
+ sdp_result_e result = SDP_FAILURE;
+
+ sdp_p->version = (uint16_t)sdp_getnextnumtok(ptr, &ptr, " \t", &result);
+ if ((result != SDP_SUCCESS) || (sdp_p->version != SDP_CURRENT_VERSION)) {
+ sdp_parse_error(sdp_p,
+ "%s Invalid version (%u) found, parse failed.",
+ sdp_p->debug_str, (unsigned)sdp_p->version);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parse version line successful, version %u",
+ sdp_p->debug_str, (unsigned)sdp_p->version);
+ }
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_version (sdp_t *sdp_p, uint16_t level, flex_string *fs)
+{
+ if (sdp_p->version == SDP_INVALID_VALUE) {
+ if (sdp_p->conf_p->version_reqd == TRUE) {
+ CSFLogError(logTag, "%s Invalid version for v= line, "
+ "build failed.", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ /* v= line is not required. */
+ return (SDP_SUCCESS);
+ }
+ }
+
+ flex_string_sprintf(fs, "v=%u\r\n", (unsigned)sdp_p->version);
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Built v= version line", sdp_p->debug_str);
+ }
+ return (SDP_SUCCESS);
+}
+
+static sdp_result_e sdp_verify_unsigned(const char *ptr, uint64_t max_value)
+{
+ uint64_t numeric_value;
+ /* Checking for only numbers since PR_sscanf will ignore trailing
+ characters */
+ size_t end = strspn(ptr, "0123456789");
+
+ if (ptr[end] != '\0')
+ return SDP_INVALID_PARAMETER;
+
+ if (PR_sscanf(ptr, "%llu", &numeric_value) != 1)
+ return SDP_INVALID_PARAMETER;
+
+ if (numeric_value > max_value)
+ return SDP_INVALID_PARAMETER;
+
+ return SDP_SUCCESS;
+}
+
+sdp_result_e sdp_parse_owner (sdp_t *sdp_p, uint16_t level, const char *ptr)
+{
+ int i;
+ sdp_result_e result;
+ char tmp[SDP_MAX_STRING_LEN];
+ /* The spec says this:
+
+ The numeric value of the session id
+ and version in the o line MUST be representable with a 64 bit signed
+ integer. The initial value of the version MUST be less than
+ (2**62)-1, to avoid rollovers.
+ */
+ const uint64_t max_value_sessid = ((((uint64_t) 1) << 63) - 1);
+ /* Do not check that this is 2^62 - 1; that's just the limit on
+ * the initial version, not every version number. */
+ const uint64_t max_value_version = ((((uint64_t) 1) << 63) - 1);
+
+ if (sdp_p->owner_name[0] != '\0') {
+ sdp_p->conf_p->num_invalid_token_order++;
+ sdp_parse_error(sdp_p,
+ "%s Warning: More than one o= line specified.",
+ sdp_p->debug_str);
+ }
+
+ /* Find the owner name. */
+ ptr = sdp_getnextstrtok(ptr, sdp_p->owner_name, sizeof(sdp_p->owner_name), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s No owner name specified for o=.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Find the owner session id. This is a numeric field but is
+ * stored as a string since it may be 64 bit.
+ */
+ ptr = sdp_getnextstrtok(ptr, sdp_p->owner_sessid, sizeof(sdp_p->owner_sessid), " \t", &result);
+ if (result == SDP_SUCCESS) {
+ /* Make sure the sessid is numeric, even though we store it as
+ * a string.
+ */
+ result = sdp_verify_unsigned(sdp_p->owner_sessid, max_value_sessid);
+ }
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Invalid owner session id specified for o=.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Find the owner version. */
+ ptr = sdp_getnextstrtok(ptr, sdp_p->owner_version, sizeof(sdp_p->owner_version), " \t", &result);
+ if (result == SDP_SUCCESS) {
+ /* Make sure the version is numeric, even though we store it as
+ * a string.
+ */
+ result = sdp_verify_unsigned(sdp_p->owner_version, max_value_version);
+ }
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Invalid owner version specified for o=.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Find the owner network type. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s No owner network type specified for o=.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ sdp_p->owner_network_type = SDP_NT_UNSUPPORTED;
+ for (i=0; i < SDP_MAX_NETWORK_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_nettype[i].name,
+ sdp_nettype[i].strlen) == 0) {
+ if (sdp_p->conf_p->nettype_supported[i] == TRUE) {
+ sdp_p->owner_network_type = (sdp_nettype_e)i;
+ }
+ }
+ }
+ if (sdp_p->owner_network_type == SDP_NT_UNSUPPORTED) {
+ sdp_parse_error(sdp_p,
+ "%s Owner network type unsupported (%s)",
+ sdp_p->debug_str, tmp);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Find the owner address type. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s No owner address type specified for o=.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ sdp_p->owner_addr_type = SDP_AT_UNSUPPORTED;
+ for (i=0; i < SDP_MAX_ADDR_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_addrtype[i].name,
+ sdp_addrtype[i].strlen) == 0) {
+ if (sdp_p->conf_p->addrtype_supported[i] == TRUE) {
+ sdp_p->owner_addr_type = (sdp_addrtype_e)i;
+ }
+ }
+ }
+ if ((sdp_p->owner_addr_type == SDP_AT_UNSUPPORTED) &&
+ (sdp_p->owner_network_type != SDP_NT_ATM)) {
+ sdp_parse_error(sdp_p,
+ "%s Owner address type unsupported (%s)",
+ sdp_p->debug_str, tmp);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Find the owner address. */
+ ptr = sdp_getnextstrtok(ptr, sdp_p->owner_addr, sizeof(sdp_p->owner_addr), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s No owner address specified.", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parse owner: name %s, session id %s, version %s",
+ sdp_p->debug_str, sdp_p->owner_name, sdp_p->owner_sessid,
+ sdp_p->owner_version);
+ SDP_PRINT("%s network %s, address type %s, "
+ "address %s", sdp_p->debug_str,
+ sdp_get_network_name(sdp_p->owner_network_type),
+ sdp_get_address_name(sdp_p->owner_addr_type),
+ sdp_p->owner_addr);
+ }
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_owner (sdp_t *sdp_p, uint16_t level, flex_string *fs)
+{
+ if ((sdp_p->owner_name[0] == '\0') ||
+ (sdp_p->owner_network_type >= SDP_MAX_NETWORK_TYPES) ||
+ (sdp_p->owner_addr_type >= SDP_MAX_ADDR_TYPES) ||
+ (sdp_p->owner_addr[0] == '\0')) {
+
+ if((sdp_p->owner_network_type == SDP_NT_ATM) &&
+ (sdp_p->owner_addr_type == SDP_AT_INVALID)) {
+ flex_string_sprintf(fs, "o=%s %s %s %s - -\r\n",
+ sdp_p->owner_name, sdp_p->owner_sessid,
+ sdp_p->owner_version,
+ sdp_get_network_name(sdp_p->owner_network_type));
+ }
+
+ if (sdp_p->conf_p->owner_reqd == TRUE) {
+ CSFLogError(logTag, "%s Invalid params for o= owner line, "
+ "build failed.", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ /* o= line is not required. */
+ return (SDP_SUCCESS);
+ }
+ }
+
+ flex_string_sprintf(fs, "o=%s %s %s %s %s %s\r\n",
+ sdp_p->owner_name, sdp_p->owner_sessid,
+ sdp_p->owner_version,
+ sdp_get_network_name(sdp_p->owner_network_type),
+ sdp_get_address_name(sdp_p->owner_addr_type),
+ sdp_p->owner_addr);
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Built o= owner line", sdp_p->debug_str);
+ }
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_parse_sessname (sdp_t *sdp_p, uint16_t level, const char *ptr)
+{
+ int str_len;
+ char *endptr;
+
+ if (sdp_p->sessname[0] != '\0') {
+ sdp_p->conf_p->num_invalid_token_order++;
+ sdp_parse_error(sdp_p,
+ "%s Warning: More than one s= line specified.",
+ sdp_p->debug_str);
+ }
+
+ endptr = sdp_findchar(ptr, "\r\n");
+ if (ptr == endptr) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No session name specified.",
+ sdp_p->debug_str);
+ }
+ str_len = MIN(endptr - ptr, SDP_MAX_STRING_LEN);
+ sstrncpy(sdp_p->sessname, ptr, str_len+1);
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parse session name, %s",
+ sdp_p->debug_str, sdp_p->sessname);
+ }
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_sessname (sdp_t *sdp_p, uint16_t level, flex_string *fs)
+{
+ if (sdp_p->sessname[0] == '\0') {
+ if (sdp_p->conf_p->session_name_reqd == TRUE) {
+ CSFLogError(logTag, "%s No param defined for s= session name line, "
+ "build failed.", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ /* s= line is not required. */
+ return (SDP_SUCCESS);
+ }
+ }
+
+ flex_string_sprintf(fs, "s=%s\r\n", sdp_p->sessname);
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Built s= session name line", sdp_p->debug_str);
+ }
+ return (SDP_SUCCESS);
+}
+
+/* We don't want to store the session info, but we do want to validate
+ * that at most one i= line exists at each level and if the line exists
+ * there should be a parameter.
+ */
+sdp_result_e sdp_parse_sessinfo (sdp_t *sdp_p, uint16_t level, const char *ptr)
+{
+ char *endptr;
+ sdp_mca_t *mca_p;
+
+ if (level == SDP_SESSION_LEVEL) {
+ if (sdp_p->sessinfo_found == TRUE) {
+ sdp_p->conf_p->num_invalid_token_order++;
+ sdp_parse_error(sdp_p,
+ "%s Warning: More than one i= line specified.",
+ sdp_p->debug_str);
+ }
+ sdp_p->sessinfo_found = TRUE;
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (SDP_FAILURE);
+ }
+ if (mca_p->sessinfo_found == TRUE) {
+ sdp_p->conf_p->num_invalid_token_order++;
+ sdp_parse_error(sdp_p,
+ "%s Warning: More than one i= line specified"
+ " for media line %u.", sdp_p->debug_str, (unsigned)level);
+ }
+ mca_p->sessinfo_found = TRUE;
+ }
+
+ endptr = sdp_findchar(ptr, "\n");
+ if (ptr == endptr) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No session info specified.",
+ sdp_p->debug_str);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed session info line.", sdp_p->debug_str);
+ }
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_sessinfo (sdp_t *sdp_p, uint16_t level, flex_string *fs)
+{
+ /* Build session info line not supported. */
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_parse_uri (sdp_t *sdp_p, uint16_t level, const char *ptr)
+{
+ char *endptr;
+
+ if (sdp_p->uri_found == TRUE) {
+ sdp_p->conf_p->num_invalid_token_order++;
+ sdp_parse_error(sdp_p,
+ "%s Warning: More than one u= line specified.",
+ sdp_p->debug_str);
+ }
+ sdp_p->uri_found = TRUE;
+
+ endptr = sdp_findchar(ptr, "\n");
+ if (ptr == endptr) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No URI info specified.", sdp_p->debug_str);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed URI line.", sdp_p->debug_str);
+ }
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_uri (sdp_t *sdp_p, uint16_t level, flex_string *fs)
+{
+ /* Build URI line not supported. */
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_parse_email (sdp_t *sdp_p, uint16_t level, const char *ptr)
+{
+ char *endptr;
+
+ endptr = sdp_findchar(ptr, "\n");
+ if (ptr == endptr) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No email info specified.", sdp_p->debug_str);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parse email line", sdp_p->debug_str);
+ }
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_email (sdp_t *sdp_p, uint16_t level, flex_string *fs)
+{
+ /* Build email line not supported. */
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_parse_phonenum (sdp_t *sdp_p, uint16_t level, const char *ptr)
+{
+ char *endptr;
+
+ endptr = sdp_findchar(ptr, "\n");
+ if (ptr == endptr) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No phone number info specified.",
+ sdp_p->debug_str);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parse phone number line", sdp_p->debug_str);
+ }
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_phonenum (sdp_t *sdp_p, uint16_t level, flex_string *fs)
+{
+ /* Build phone number line not supported. */
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_parse_connection (sdp_t *sdp_p, uint16_t level, const char *ptr)
+{
+ int i;
+ const char *slash_ptr;
+ sdp_result_e result;
+ sdp_conn_t *conn_p;
+ sdp_mca_t *mca_p;
+ char tmp[SDP_MAX_STRING_LEN];
+ char mcast_str[MCAST_STRING_LEN];
+ int mcast_bits;
+ unsigned long strtoul_result;
+ char *strtoul_end;
+
+ if (level == SDP_SESSION_LEVEL) {
+ conn_p = &(sdp_p->default_conn);
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (SDP_FAILURE);
+ }
+ conn_p = &(mca_p->conn);
+ }
+
+ /* See if the c= line is already defined at this level. We don't
+ * currently support multihoming and so we only support one c= at
+ * each level.
+ */
+ if (conn_p->nettype != SDP_NT_INVALID) {
+ sdp_p->conf_p->num_invalid_token_order++;
+ sdp_parse_error(sdp_p,
+ "%s c= line specified twice at same level, "
+ "parse failed.", sdp_p->debug_str);
+ return (SDP_INVALID_TOKEN_ORDERING);
+ }
+
+ /* Find the connection network type. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s No connection network type specified for c=.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ conn_p->nettype = SDP_NT_UNSUPPORTED;
+ for (i=0; i < SDP_MAX_NETWORK_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_nettype[i].name,
+ sdp_nettype[i].strlen) == 0) {
+ if (sdp_p->conf_p->nettype_supported[i] == TRUE) {
+ conn_p->nettype = (sdp_nettype_e)i;
+ }
+ }
+ }
+ if (conn_p->nettype == SDP_NT_UNSUPPORTED) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Connection network type unsupported "
+ "(%s) for c=.", sdp_p->debug_str, tmp);
+ }
+
+ /* Find the connection address type. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ if (conn_p->nettype == SDP_NT_ATM) {
+ /* If the nettype is ATM, addr type and addr are not reqd */
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parse connection: network %s", sdp_p->debug_str,
+ sdp_get_network_name(conn_p->nettype));
+ }
+ return (SDP_SUCCESS);
+ } else {
+ sdp_parse_error(sdp_p,
+ "%s No connection address type specified for "
+ "c=.", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ }
+ conn_p->addrtype = SDP_AT_UNSUPPORTED;
+ for (i=0; i < SDP_MAX_ADDR_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_addrtype[i].name,
+ sdp_addrtype[i].strlen) == 0) {
+ if (sdp_p->conf_p->addrtype_supported[i] == TRUE) {
+ conn_p->addrtype = (sdp_addrtype_e)i;
+ }
+ }
+ }
+ if (conn_p->addrtype == SDP_AT_UNSUPPORTED) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Connection address type unsupported "
+ "(%s) for c=.", sdp_p->debug_str, tmp);
+ }
+
+ /* Find the connection address. */
+ ptr = sdp_getnextstrtok(ptr, conn_p->conn_addr, sizeof(conn_p->conn_addr), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s No connection address specified for c=.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ /* We currently only support addrs containing '/'s for EPN addrs.
+ * For other addrs this would indicate multicast addrs. */
+ /* Multicast host group addresses are defined to be the IP addresses
+ * whose high-order four bits are 1110, giving an address range from
+ * 224.0.0.0 through 239.255.255.255
+ */
+ /* multicast addr check */
+ sstrncpy (mcast_str, conn_p->conn_addr, MCAST_STRING_LEN);
+
+ if (conn_p->addrtype == SDP_AT_IP4) {
+ errno = 0;
+ strtoul_result = strtoul(mcast_str, &strtoul_end, 10);
+
+ if (errno || mcast_str == strtoul_end || strtoul_result > 255) {
+ sdp_parse_error(sdp_p,
+ "%s Error parsing address %s for mcast.",
+ sdp_p->debug_str, mcast_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_INVALID_PARAMETER;
+ }
+
+
+ mcast_bits = (int) strtoul_result;
+ if ((mcast_bits >= SDP_MIN_MCAST_ADDR_HI_BIT_VAL ) &&
+ (mcast_bits <= SDP_MAX_MCAST_ADDR_HI_BIT_VAL)) {
+ SDP_PRINT("%s Parsed to be a multicast address with mcast bits %d",
+ sdp_p->debug_str, mcast_bits);
+ conn_p->is_multicast = TRUE;
+ }
+ }
+
+ if (conn_p->addrtype != SDP_AT_EPN) {
+ slash_ptr = sdp_findchar(conn_p->conn_addr, "/");
+ if (slash_ptr[0] != '\0') {
+ /* this used to rely on the above busted multicast check */
+ SDP_PRINT("%s An address with slash %s",
+ sdp_p->debug_str, conn_p->conn_addr);
+ conn_p->conn_addr[slash_ptr - conn_p->conn_addr] = '\0';
+ slash_ptr++;
+ slash_ptr = sdp_getnextstrtok(slash_ptr, tmp, sizeof(tmp),
+ "/", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s No ttl value specified for this multicast addr with a slash",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ errno = 0;
+ strtoul_result = strtoul(tmp, &strtoul_end, 10);
+
+ if (errno || tmp == strtoul_end || conn_p->ttl > SDP_MAX_TTL_VALUE) {
+ sdp_parse_error(sdp_p,
+ "%s Invalid TTL: Value must be in the range 0-255 ",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ conn_p->ttl = (int) strtoul_result;
+
+ /* search for num of addresses */
+ /*sa_ignore NO_NULL_CHK
+ {ptr is valid since the pointer was checked earlier and the
+ function would have exited if NULL.}*/
+ slash_ptr = sdp_findchar(slash_ptr, "/");
+ if (slash_ptr != NULL &&
+ slash_ptr[0] != '\0') {
+ SDP_PRINT("%s Found a num addr field for multicast addr %s ",
+ sdp_p->debug_str,slash_ptr);
+ slash_ptr++;
+
+ errno = 0;
+ strtoul_result = strtoul(slash_ptr, &strtoul_end, 10);
+
+ if (errno || slash_ptr == strtoul_end || strtoul_result == 0) {
+ sdp_parse_error(sdp_p,
+ "%s Invalid Num of addresses: Value must be > 0 ",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return SDP_INVALID_PARAMETER;
+ }
+
+ conn_p->num_of_addresses = (int) strtoul_result;
+ }
+ }
+ }
+
+ /* See if the address is the choose param and if it's allowed. */
+ if ((sdp_p->conf_p->allow_choose[SDP_CHOOSE_CONN_ADDR] == FALSE) &&
+ (strcmp(conn_p->conn_addr, "$") == 0)) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Choose parameter for connection "
+ "address specified but not allowed.", sdp_p->debug_str);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parse connection: network %s, address type %s, "
+ "address %s ttl= %u num of addresses = %u",
+ sdp_p->debug_str,
+ sdp_get_network_name(conn_p->nettype),
+ sdp_get_address_name(conn_p->addrtype),
+ conn_p->conn_addr, (unsigned)conn_p->ttl, (unsigned)conn_p->num_of_addresses);
+ }
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_connection (sdp_t *sdp_p, uint16_t level, flex_string *fs)
+{
+ sdp_mca_t *mca_p;
+ sdp_conn_t *conn_p;
+
+ if (level == SDP_SESSION_LEVEL) {
+ conn_p = &(sdp_p->default_conn);
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (SDP_FAILURE);
+ }
+ conn_p = &(mca_p->conn);
+ }
+
+ if((conn_p->nettype == SDP_NT_ATM ) &&
+ (conn_p->addrtype == SDP_AT_INVALID)) {
+ /*allow c= line to be built without address type and address fields
+ * This is a special case for ATM PVC*/
+ flex_string_sprintf(fs, "c=%s\r\n",
+ sdp_get_network_name(conn_p->nettype));
+ return SDP_SUCCESS;
+ }
+ if ((conn_p->nettype >= SDP_MAX_NETWORK_TYPES) ||
+ (conn_p->addrtype >= SDP_MAX_ADDR_TYPES) ||
+ (conn_p->conn_addr[0] == '\0')) {
+ /* Connection info isn't set - don't need to build the token. */
+ return (SDP_SUCCESS);
+ }
+
+ if (conn_p->is_multicast) {
+ if (conn_p->num_of_addresses > 1) {
+ flex_string_sprintf(fs, "c=%s %s %s/%u/%u\r\n",
+ sdp_get_network_name(conn_p->nettype),
+ sdp_get_address_name(conn_p->addrtype),
+ conn_p->conn_addr,
+ (unsigned)conn_p->ttl,
+ (unsigned)conn_p->num_of_addresses);
+ } else {
+ flex_string_sprintf(fs, "c=%s %s %s/%u\r\n",
+ sdp_get_network_name(conn_p->nettype),
+ sdp_get_address_name(conn_p->addrtype),
+ conn_p->conn_addr,
+ (unsigned)conn_p->ttl);
+ }
+ } else {
+
+ flex_string_sprintf(fs, "c=%s %s %s\r\n",
+ sdp_get_network_name(conn_p->nettype),
+ sdp_get_address_name(conn_p->addrtype),
+ conn_p->conn_addr);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Built c= connection line", sdp_p->debug_str);
+ }
+ return (SDP_SUCCESS);
+}
+
+/*
+ * sdp_parse_bandwidth
+ *
+ * This function parses a bandwidth field. The parsing is done in accordance
+ * to the following ABNF:
+ *
+ * bandwidth-fields = *("b=" bwtype ":" bandwidth CRLF)
+ * bwtype = 1*(alpha-numeric)
+ * bandwidth = 1*(DIGIT)
+ *
+ * It currently supports three types of valid bwtypes - AS, CT and TIAS
+ */
+sdp_result_e sdp_parse_bandwidth (sdp_t *sdp_p, uint16_t level, const char *ptr)
+{
+ int i;
+ sdp_mca_t *mca_p;
+ sdp_bw_t *bw_p;
+ sdp_bw_data_t *bw_data_p;
+ sdp_bw_data_t *new_bw_data_p;
+ sdp_result_e result;
+ char tmp[SDP_MAX_STRING_LEN];
+ sdp_bw_modifier_e bw_modifier = SDP_BW_MODIFIER_UNSUPPORTED;
+ int bw_val = 0;
+
+ if (level == SDP_SESSION_LEVEL) {
+ bw_p = &(sdp_p->bw);
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (SDP_FAILURE);
+ }
+ bw_p = &(mca_p->bw);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parse bandwidth line", sdp_p->debug_str);
+ }
+
+ /* Find the bw type (AS, CT or TIAS) */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), ":", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s No bandwidth type specified for b= ",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ for (i=0; i < SDP_MAX_BW_MODIFIER_VAL; i++) {
+ if (cpr_strncasecmp(tmp, sdp_bw_modifier_val[i].name,
+ sdp_bw_modifier_val[i].strlen) == 0) {
+ bw_modifier = (sdp_bw_modifier_e)i;
+ break;
+ }
+ }
+
+ if (bw_modifier == SDP_BW_MODIFIER_UNSUPPORTED) {
+ /* We don't understand this parameter, so according to RFC4566 sec 5.8
+ * ignore it. */
+ return (SDP_SUCCESS);
+ }
+
+ /* Find the BW type value */
+ /*sa_ignore NO_NULL_CHK
+ {ptr is valid since the pointer was checked earlier and the
+ function would have exited if NULL.}*/
+ if (*ptr == ':') {
+ ptr++;
+ bw_val = sdp_getnextnumtok(ptr, &ptr, " \t", &result);
+ if ((result != SDP_SUCCESS)) {
+ sdp_parse_error(sdp_p,
+ "%s Error: No BW Value specified ",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ }
+
+ /*
+ * Allocate a new sdp_bw_data_t instance and set it's values from the
+ * input parameters.
+ */
+ new_bw_data_p = (sdp_bw_data_t*)SDP_MALLOC(sizeof(sdp_bw_data_t));
+ if (new_bw_data_p == NULL) {
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_NO_RESOURCE);
+ }
+ new_bw_data_p->next_p = NULL;
+ new_bw_data_p->bw_modifier = bw_modifier;
+ new_bw_data_p->bw_val = bw_val;
+
+ /*
+ * Enqueue the sdp_bw_data_t instance at the end of the list of
+ * sdp_bw_data_t instances.
+ */
+ if (bw_p->bw_data_list == NULL) {
+ bw_p->bw_data_list = new_bw_data_p;
+ } else {
+ for (bw_data_p = bw_p->bw_data_list;
+ bw_data_p->next_p != NULL;
+ bw_data_p = bw_data_p->next_p) {
+ ; // Empty For
+ }
+ bw_data_p->next_p = new_bw_data_p;
+ }
+ bw_p->bw_data_count++;
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed bw type %s, value %d", sdp_p->debug_str,
+ sdp_get_bw_modifier_name(new_bw_data_p->bw_modifier),
+ new_bw_data_p->bw_val);
+ }
+
+ return (SDP_SUCCESS);
+}
+
+/*
+ * sdp_build_bandwidth
+ *
+ * Builds *all* the bandwith lines for the specified level.
+ */
+sdp_result_e sdp_build_bandwidth (sdp_t *sdp_p, uint16_t level, flex_string *fs)
+{
+ sdp_bw_t *bw_p;
+ sdp_bw_data_t *bw_data_p;
+ sdp_mca_t *mca_p;
+
+ if (level == SDP_SESSION_LEVEL) {
+ bw_p = &(sdp_p->bw);
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (SDP_FAILURE);
+ }
+ bw_p = &(mca_p->bw);
+ }
+
+ bw_data_p = bw_p->bw_data_list;
+ while (bw_data_p) {
+ flex_string_sprintf(fs, "b=%s:%d\r\n",
+ sdp_get_bw_modifier_name(bw_data_p->bw_modifier),
+ bw_data_p->bw_val);
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Built b=%s:%d bandwidth line", sdp_p->debug_str,
+ sdp_get_bw_modifier_name(bw_data_p->bw_modifier),
+ bw_data_p->bw_val);
+ }
+
+ bw_data_p = bw_data_p->next_p;
+ }
+
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_parse_timespec (sdp_t *sdp_p, uint16_t level, const char *ptr)
+{
+ char *tmpptr;
+ sdp_result_e result;
+ sdp_timespec_t *timespec_p;
+ sdp_timespec_t *next_timespec_p;
+
+ timespec_p = (sdp_timespec_t *)SDP_MALLOC(sizeof(sdp_timespec_t));
+ if (timespec_p == NULL) {
+ sdp_p->conf_p->num_no_resource++;
+ return (SDP_NO_RESOURCE);
+ }
+
+ /* Validate start and stop times. */
+ ptr = sdp_getnextstrtok(ptr, timespec_p->start_time, sizeof(timespec_p->start_time), " \t", &result);
+ if (result == SDP_SUCCESS) {
+ /* Make sure the start_time is numeric, even though we store it as
+ * a string.
+ */
+ (void)sdp_getnextnumtok(timespec_p->start_time,
+ (const char **)&tmpptr, " \t", &result);
+ }
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Invalid timespec start time specified.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ SDP_FREE(timespec_p);
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ ptr = sdp_getnextstrtok(ptr, timespec_p->stop_time, sizeof(timespec_p->stop_time), " \t", &result);
+ if (result == SDP_SUCCESS) {
+ /* Make sure the start_time is numeric, even though we store it as
+ * a string.
+ */
+ (void)sdp_getnextnumtok(timespec_p->stop_time,
+ (const char **)&tmpptr, " \t", &result);
+ }
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s Invalid timespec stop time specified.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ SDP_FREE(timespec_p);
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Link the new timespec in to the end of the list. */
+ if (sdp_p->timespec_p == NULL) {
+ sdp_p->timespec_p = timespec_p;
+ } else {
+ next_timespec_p = sdp_p->timespec_p;
+ while (next_timespec_p->next_p != NULL) {
+ next_timespec_p = next_timespec_p->next_p;
+ }
+ next_timespec_p->next_p = timespec_p;
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed timespec line", sdp_p->debug_str);
+ }
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_timespec (sdp_t *sdp_p, uint16_t level, flex_string *fs)
+{
+ if ((sdp_p->timespec_p == NULL) ||
+ (sdp_p->timespec_p->start_time[0] == '\0') ||
+ (sdp_p->timespec_p->stop_time[0] == '\0')) {
+ if (sdp_p->conf_p->timespec_reqd == TRUE) {
+ CSFLogError(logTag, "%s Invalid params for t= time spec line, "
+ "build failed.", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ /* t= line not required. */
+ return (SDP_SUCCESS);
+ }
+ }
+
+ /* Note: We only support one t= line currently. */
+ flex_string_sprintf(fs, "t=%s %s\r\n", sdp_p->timespec_p->start_time,
+ sdp_p->timespec_p->stop_time);
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Built t= timespec line", sdp_p->debug_str);
+ }
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_parse_repeat_time (sdp_t *sdp_p, uint16_t level, const char *ptr)
+{
+ char *endptr;
+
+ endptr = sdp_findchar(ptr, "\n");
+ if (ptr == endptr) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No repeat time parameters "
+ "specified.", sdp_p->debug_str);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parsed repeat time line", sdp_p->debug_str);
+ }
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_repeat_time (sdp_t *sdp_p, uint16_t level, flex_string *fs)
+{
+ /* Build repeat time line not supported. */
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_parse_timezone_adj (sdp_t *sdp_p, uint16_t level, const char *ptr)
+{
+ char *endptr;
+
+ endptr = sdp_findchar(ptr, "\n");
+ if (ptr == endptr) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No timezone parameters specified.",
+ sdp_p->debug_str);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parse timezone adustment line", sdp_p->debug_str);
+ }
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_timezone_adj (sdp_t *sdp_p, uint16_t level, flex_string *fs)
+{
+ /* Build timezone adjustment line not supported. */
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_parse_encryption (sdp_t *sdp_p, uint16_t level, const char *ptr)
+{
+ int i;
+ sdp_result_e result;
+ sdp_encryptspec_t *encrypt_p;
+ sdp_mca_t *mca_p;
+ char tmp[SDP_MAX_STRING_LEN];
+
+ if (level == SDP_SESSION_LEVEL) {
+ encrypt_p = &(sdp_p->encrypt);
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (SDP_FAILURE);
+ }
+ encrypt_p = &(mca_p->encrypt);
+ }
+ encrypt_p->encrypt_key[0] = '\0';
+
+ /* Find the encryption type. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), ":", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s No encryption type specified for k=.",
+ sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ encrypt_p->encrypt_type = SDP_ENCRYPT_UNSUPPORTED;
+ for (i=0; i < SDP_MAX_ENCRYPT_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_encrypt[i].name,
+ sdp_encrypt[i].strlen) == 0) {
+ encrypt_p->encrypt_type = (sdp_encrypt_type_e)i;
+ break;
+ }
+ }
+ if (encrypt_p->encrypt_type == SDP_ENCRYPT_UNSUPPORTED) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Encryption type unsupported (%s).",
+ sdp_p->debug_str, tmp);
+ }
+
+ /* Find the encryption key. */
+ encrypt_p->encrypt_key[0] = '\0';
+ /*sa_ignore NO_NULL_CHK
+ {ptr is valid since the pointer was checked earlier and the
+ function would have exited if NULL.}*/
+ if (*ptr == ':')
+ ptr++;
+ if (encrypt_p->encrypt_type != SDP_ENCRYPT_PROMPT) {
+ ptr = sdp_getnextstrtok(ptr, encrypt_p->encrypt_key, sizeof(encrypt_p->encrypt_key), " \t", &result);
+ if ((result != SDP_SUCCESS) &&
+ ((encrypt_p->encrypt_type == SDP_ENCRYPT_CLEAR) ||
+ (encrypt_p->encrypt_type == SDP_ENCRYPT_BASE64) ||
+ (encrypt_p->encrypt_type == SDP_ENCRYPT_URI))) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No encryption key specified "
+ "as required.", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Parse encryption type %s, key %s", sdp_p->debug_str,
+ sdp_get_encrypt_name(encrypt_p->encrypt_type),
+ encrypt_p->encrypt_key);
+ }
+ return (SDP_SUCCESS);
+}
+
+/* If the encryption info is valid, we build it. Else skip it. */
+sdp_result_e sdp_build_encryption (sdp_t *sdp_p, uint16_t level, flex_string *fs)
+{
+ sdp_encryptspec_t *encrypt_p;
+ sdp_mca_t *mca_p;
+
+ if (level == SDP_SESSION_LEVEL) {
+ encrypt_p = &(sdp_p->encrypt);
+ } else {
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (SDP_FAILURE);
+ }
+ encrypt_p = &(mca_p->encrypt);
+ }
+
+ if ((encrypt_p->encrypt_type >= SDP_MAX_ENCRYPT_TYPES) ||
+ ((encrypt_p->encrypt_type != SDP_ENCRYPT_PROMPT) &&
+ (encrypt_p->encrypt_key[0] == '\0'))) {
+ /* Encryption info isn't set - don't need to build the token. */
+ return (SDP_SUCCESS);
+ }
+
+ flex_string_sprintf(fs, "k=%s",
+ sdp_get_encrypt_name(encrypt_p->encrypt_type));
+
+ if (encrypt_p->encrypt_type == SDP_ENCRYPT_PROMPT) {
+ /* There is no key to print. */
+ flex_string_sprintf(fs, "\r\n");
+ } else {
+ flex_string_sprintf(fs, ":%s\r\n", encrypt_p->encrypt_key);
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Built k= encryption line", sdp_p->debug_str);
+ }
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_parse_media (sdp_t *sdp_p, uint16_t level, const char *ptr)
+{
+ uint16_t i;
+ uint16_t num_port_params=0;
+ int32_t num[SDP_MAX_PORT_PARAMS];
+ tinybool valid_param = FALSE;
+ sdp_result_e result;
+ sdp_mca_t *mca_p;
+ sdp_mca_t *next_mca_p;
+ char tmp[SDP_MAX_STRING_LEN];
+ char port[SDP_MAX_STRING_LEN];
+ const char *port_ptr;
+ int32_t sctp_port;
+
+ /* Allocate resource for new media stream. */
+ mca_p = sdp_alloc_mca(sdp_p->parse_line);
+ if (mca_p == NULL) {
+ sdp_p->conf_p->num_no_resource++;
+ return (SDP_NO_RESOURCE);
+ }
+
+ /* Find the media type. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s No media type specified, parse failed.",
+ sdp_p->debug_str);
+ SDP_FREE(mca_p);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ mca_p->media = SDP_MEDIA_UNSUPPORTED;
+ for (i=0; i < SDP_MAX_MEDIA_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_media[i].name,
+ sdp_media[i].strlen) == 0) {
+ mca_p->media = (sdp_media_e)i;
+ }
+ }
+ if (mca_p->media == SDP_MEDIA_UNSUPPORTED) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Media type unsupported (%s).",
+ sdp_p->debug_str, tmp);
+ }
+
+ /* Find the port token parameters, but don't process it until
+ * we determine the transport protocol as that determines what
+ * port number formats are valid.
+ */
+ ptr = sdp_getnextstrtok(ptr, port, sizeof(port), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s No port specified in m= media line, "
+ "parse failed.", sdp_p->debug_str);
+ SDP_FREE(mca_p);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ port_ptr = port;
+ for (i=0; i < SDP_MAX_PORT_PARAMS; i++) {
+ if (sdp_getchoosetok(port_ptr, &port_ptr, "/ \t", &result) == TRUE) {
+ num[i] = SDP_CHOOSE_PARAM;
+ } else {
+ num[i] = sdp_getnextnumtok(port_ptr, (const char **)&port_ptr,
+ "/ \t", &result);
+ if (result != SDP_SUCCESS) {
+ break;
+ }
+ }
+ num_port_params++;
+ }
+
+ /* Find the transport protocol type. */
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s No transport protocol type specified, "
+ "parse failed.", sdp_p->debug_str);
+ SDP_FREE(mca_p);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ mca_p->transport = SDP_TRANSPORT_UNSUPPORTED;
+ for (i=0; i < SDP_MAX_TRANSPORT_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_transport[i].name,
+ sdp_transport[i].strlen) == 0) {
+ mca_p->transport = (sdp_transport_e)i;
+ break;
+ }
+ }
+
+ /* TODO(ehugg): Remove this next block when backward
+ compatibility with versions earlier than FF24
+ is no longer required. See Bug 886134 */
+#define DATACHANNEL_OLD_TRANSPORT "SCTP/DTLS"
+ if (mca_p->transport == SDP_TRANSPORT_UNSUPPORTED) {
+ if (cpr_strncasecmp(tmp, DATACHANNEL_OLD_TRANSPORT,
+ strlen(DATACHANNEL_OLD_TRANSPORT)) == 0) {
+ mca_p->transport = SDP_TRANSPORT_DTLSSCTP;
+ }
+ }
+
+ if (mca_p->transport == SDP_TRANSPORT_UNSUPPORTED) {
+ /* If we don't recognize or don't support the transport type,
+ * just store the first num as the port.
+ */
+ mca_p->port = num[0];
+ sdp_parse_error(sdp_p,
+ "%s Warning: Transport protocol type unsupported "
+ "(%s).", sdp_p->debug_str, tmp);
+ }
+
+ /* Check for each of the possible port formats according to the
+ * type of transport protocol specified.
+ */
+ valid_param = FALSE;
+ switch (num_port_params) {
+ case 1:
+ if ((mca_p->transport == SDP_TRANSPORT_RTPAVP) ||
+ (mca_p->transport == SDP_TRANSPORT_RTPSAVP) ||
+ (mca_p->transport == SDP_TRANSPORT_RTPSAVPF) ||
+ (mca_p->transport == SDP_TRANSPORT_UDPTLSRTPSAVP) ||
+ (mca_p->transport == SDP_TRANSPORT_UDPTLSRTPSAVPF) ||
+ (mca_p->transport == SDP_TRANSPORT_TCPTLSRTPSAVP) ||
+ (mca_p->transport == SDP_TRANSPORT_TCPTLSRTPSAVPF) ||
+ (mca_p->transport == SDP_TRANSPORT_UDP) ||
+ (mca_p->transport == SDP_TRANSPORT_TCP) ||
+ (mca_p->transport == SDP_TRANSPORT_UDPTL) ||
+ (mca_p->transport == SDP_TRANSPORT_UDPSPRT) ||
+ (mca_p->transport == SDP_TRANSPORT_LOCAL) ||
+ (mca_p->transport == SDP_TRANSPORT_DTLSSCTP)) {
+ /* Port format is simply <port>. Make sure that either
+ * the choose param is allowed or that the choose value
+ * wasn't specified.
+ */
+ if ((sdp_p->conf_p->allow_choose[SDP_CHOOSE_PORTNUM]) ||
+ (num[0] != SDP_CHOOSE_PARAM)) {
+ mca_p->port = num[0];
+ mca_p->port_format = SDP_PORT_NUM_ONLY;
+ valid_param = TRUE;
+ }
+ } else if (mca_p->transport == SDP_TRANSPORT_AAL1AVP) {
+ /* Port format is simply <vcci>, choose param is not allowed.
+ */
+ if (num[0] != SDP_CHOOSE_PARAM) {
+ mca_p->vcci = num[0];
+ mca_p->port_format = SDP_PORT_VCCI;
+ valid_param = TRUE;
+ }
+ } else if ((mca_p->transport == SDP_TRANSPORT_AAL2_ITU) ||
+ (mca_p->transport == SDP_TRANSPORT_AAL2_ATMF) ||
+ (mca_p->transport == SDP_TRANSPORT_AAL2_CUSTOM)) {
+ /* Port format is simply <port>, and choose param is allowed,
+ * according to AAL2 definitions.
+ */
+ mca_p->port = num[0];
+ mca_p->port_format = SDP_PORT_NUM_ONLY;
+ valid_param = TRUE;
+ }
+ break;
+ case 2:
+ if ((mca_p->transport == SDP_TRANSPORT_RTPAVP) ||
+ (mca_p->transport == SDP_TRANSPORT_RTPSAVP) ||
+ (mca_p->transport == SDP_TRANSPORT_RTPSAVPF) ||
+ (mca_p->transport == SDP_TRANSPORT_UDPTLSRTPSAVP) ||
+ (mca_p->transport == SDP_TRANSPORT_UDPTLSRTPSAVPF) ||
+ (mca_p->transport == SDP_TRANSPORT_TCPTLSRTPSAVP) ||
+ (mca_p->transport == SDP_TRANSPORT_TCPTLSRTPSAVPF) ||
+ (mca_p->transport == SDP_TRANSPORT_UDP) ||
+ (mca_p->transport == SDP_TRANSPORT_LOCAL)) {
+ /* Port format is <port>/<num of ports>. Make sure choose
+ * params were not specified.
+ */
+ if ((num[0] != SDP_CHOOSE_PARAM) &&
+ (num[1] != SDP_CHOOSE_PARAM)) {
+ mca_p->port = num[0];
+ mca_p->num_ports = num[1];
+ mca_p->port_format = SDP_PORT_NUM_COUNT;
+ valid_param = TRUE;
+ }
+ } else if (mca_p->transport == SDP_TRANSPORT_UDPTL) {
+ /* Port format is <port>/<num of ports>. Make sure choose
+ * params were not specified. For UDPTL, only "1" may
+ * be specified for number of ports.
+ */
+ if ((num[0] != SDP_CHOOSE_PARAM) &&
+ (num[1] == 1)) {
+ mca_p->port = num[0];
+ mca_p->num_ports = 1;
+ mca_p->port_format = SDP_PORT_NUM_COUNT;
+ valid_param = TRUE;
+ }
+ } else if (mca_p->transport == SDP_TRANSPORT_CES10) {
+ /* Port format is <vpi>/<vci>. Make sure choose
+ * params were not specified.
+ */
+ if ((num[0] != SDP_CHOOSE_PARAM) &&
+ (num[1] != SDP_CHOOSE_PARAM)) {
+ mca_p->vpi = num[0];
+ mca_p->vci = num[1];
+ mca_p->port_format = SDP_PORT_VPI_VCI;
+ valid_param = TRUE;
+ }
+ } else if ((mca_p->transport == SDP_TRANSPORT_AAL2_ITU) ||
+ (mca_p->transport == SDP_TRANSPORT_AAL2_ATMF) ||
+ (mca_p->transport == SDP_TRANSPORT_AAL2_CUSTOM)) {
+ /* Port format is either <vcci>/<cid> or $/$. If one
+ * param is '$' the other must be also. The choose params
+ * are allowed by default and don't need to be allowed
+ * through the appl config.
+ */
+ if (((num[0] != SDP_CHOOSE_PARAM) &&
+ (num[1] != SDP_CHOOSE_PARAM)) ||
+ ((num[0] == SDP_CHOOSE_PARAM) &&
+ (num[1] == SDP_CHOOSE_PARAM))) {
+ mca_p->vcci = num[0];
+ mca_p->cid = num[1];
+ mca_p->port_format = SDP_PORT_VCCI_CID;
+ valid_param = TRUE;
+ }
+ }
+ break;
+ case 3:
+ if (mca_p->transport == SDP_TRANSPORT_AAL1AVP) {
+ /* Port format is <port>/<vpi>/<vci>. Make sure choose
+ * params were not specified.
+ */
+ if ((num[0] != SDP_CHOOSE_PARAM) &&
+ (num[1] != SDP_CHOOSE_PARAM) &&
+ (num[2] != SDP_CHOOSE_PARAM)) {
+ mca_p->port = num[0];
+ mca_p->vpi = num[1];
+ mca_p->vci = num[2];
+ mca_p->port_format = SDP_PORT_NUM_VPI_VCI;
+ valid_param = TRUE;
+ }
+ }
+ break;
+ case 4:
+ if ((mca_p->transport == SDP_TRANSPORT_AAL2_ITU) ||
+ (mca_p->transport == SDP_TRANSPORT_AAL2_ATMF) ||
+ (mca_p->transport == SDP_TRANSPORT_AAL2_CUSTOM)) {
+ /* Port format is <port>/<vpi>/<vci>/<cid>. Make sure choose
+ * params were not specified.
+ */
+ if ((num[0] != SDP_CHOOSE_PARAM) &&
+ (num[1] != SDP_CHOOSE_PARAM) &&
+ (num[2] != SDP_CHOOSE_PARAM) &&
+ (num[3] != SDP_CHOOSE_PARAM)) {
+ mca_p->port = num[0];
+ mca_p->vpi = num[1];
+ mca_p->vci = num[2];
+ mca_p->cid = num[3];
+ mca_p->port_format = SDP_PORT_NUM_VPI_VCI_CID;
+ valid_param = TRUE;
+ }
+ }
+ break;
+ }
+ if (valid_param == FALSE) {
+ sdp_parse_error(sdp_p,
+ "%s Invalid port format (%s) specified for transport "
+ "protocol (%s), parse failed.", sdp_p->debug_str,
+ port, sdp_get_transport_name(mca_p->transport));
+ sdp_p->conf_p->num_invalid_param++;
+ SDP_FREE(mca_p);
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Find payload formats. AAL2 media lines allow multiple
+ * transport/profile types per line, so these are handled differently. */
+ if ((mca_p->transport == SDP_TRANSPORT_AAL2_ITU) ||
+ (mca_p->transport == SDP_TRANSPORT_AAL2_ATMF) ||
+ (mca_p->transport == SDP_TRANSPORT_AAL2_CUSTOM)) {
+
+ if (sdp_parse_multiple_profile_payload_types(sdp_p, mca_p, ptr) !=
+ SDP_SUCCESS) {
+ sdp_p->conf_p->num_invalid_param++;
+ SDP_FREE(mca_p);
+ return (SDP_INVALID_PARAMETER);
+ }
+ /* Parse DTLS/SCTP port */
+ } else if (mca_p->transport == SDP_TRANSPORT_DTLSSCTP) {
+ ptr = sdp_getnextstrtok(ptr, port, sizeof(port), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s No sctp port specified in m= media line, "
+ "parse failed.", sdp_p->debug_str);
+ SDP_FREE(mca_p);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ port_ptr = port;
+
+ if (sdp_getchoosetok(port_ptr, &port_ptr, "/ \t", &result)) {
+ sctp_port = SDP_CHOOSE_PARAM;
+ } else {
+ sctp_port = sdp_getnextnumtok(port_ptr, (const char **)&port_ptr,
+ "/ \t", &result);
+ if (result != SDP_SUCCESS) {
+ sdp_parse_error(sdp_p,
+ "%s No sctp port specified in m= media line, "
+ "parse failed.", sdp_p->debug_str);
+ SDP_FREE(mca_p);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+ mca_p->sctpport = sctp_port;
+ }
+ } else {
+ /* Transport is a non-AAL2 type and not SCTP. Parse payloads
+ normally. */
+ sdp_parse_payload_types(sdp_p, mca_p, ptr);
+ }
+
+
+ /* Media line params are valid. Add it into the SDP. */
+ sdp_p->mca_count++;
+ if (sdp_p->mca_p == NULL) {
+ sdp_p->mca_p = mca_p;
+ } else {
+ for (next_mca_p = sdp_p->mca_p; next_mca_p->next_p != NULL;
+ next_mca_p = next_mca_p->next_p) {
+ ; // Empty For
+ }
+ next_mca_p->next_p = mca_p;
+ }
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+
+ SDP_PRINT("%s Parsed media type %s, ", sdp_p->debug_str,
+ sdp_get_media_name(mca_p->media));
+ switch (mca_p->port_format) {
+ case SDP_PORT_NUM_ONLY:
+ SDP_PRINT("Port num %d, ", mca_p->port);
+ break;
+
+ case SDP_PORT_NUM_COUNT:
+ SDP_PRINT("Port num %d, count %d, ",
+ mca_p->port, mca_p->num_ports);
+ break;
+ case SDP_PORT_VPI_VCI:
+ SDP_PRINT("VPI/VCI %d/%u, ", mca_p->vpi, mca_p->vci);
+ break;
+ case SDP_PORT_VCCI:
+ SDP_PRINT("VCCI %d, ", mca_p->vcci);
+ break;
+ case SDP_PORT_NUM_VPI_VCI:
+ SDP_PRINT("Port %d, VPI/VCI %d/%u, ", mca_p->port,
+ mca_p->vpi, mca_p->vci);
+ break;
+ case SDP_PORT_VCCI_CID:
+ SDP_PRINT("VCCI %d, CID %d, ", mca_p->vcci, mca_p->cid);
+ break;
+ case SDP_PORT_NUM_VPI_VCI_CID:
+ SDP_PRINT("Port %d, VPI/VCI %d/%u, CID %d, ", mca_p->port,
+ mca_p->vpi, mca_p->vci, mca_p->cid);
+ break;
+ default:
+ SDP_PRINT("Port format not valid, ");
+ break;
+ }
+
+ if ((mca_p->transport >= SDP_TRANSPORT_AAL2_ITU) &&
+ (mca_p->transport <= SDP_TRANSPORT_AAL2_CUSTOM)) {
+ for (i=0; i < mca_p->media_profiles_p->num_profiles; i++) {
+ SDP_PRINT("Profile %s, Num payloads %u ",
+ sdp_get_transport_name(mca_p->media_profiles_p->profile[i]),
+ (unsigned)mca_p->media_profiles_p->num_payloads[i]);
+ }
+ } else {
+ SDP_PRINT("Transport %s, Num payloads %u",
+ sdp_get_transport_name(mca_p->transport),
+ (unsigned)mca_p->num_payloads);
+ }
+ }
+ return (SDP_SUCCESS);
+}
+
+sdp_result_e sdp_build_media (sdp_t *sdp_p, uint16_t level, flex_string *fs)
+{
+ int i, j;
+ sdp_mca_t *mca_p;
+ tinybool invalid_params=FALSE;
+ sdp_media_profiles_t *profile_p;
+
+ /* Find the right media line */
+ mca_p = sdp_find_media_level(sdp_p, level);
+ if (mca_p == NULL) {
+ return (SDP_FAILURE);
+ }
+
+ /* Validate params for this media line */
+ if ((mca_p->media >= SDP_MAX_MEDIA_TYPES) ||
+ (mca_p->port_format >= SDP_MAX_PORT_FORMAT_TYPES) ||
+ (mca_p->transport >= SDP_MAX_TRANSPORT_TYPES)) {
+ invalid_params = TRUE;
+ }
+
+ if (invalid_params == TRUE) {
+ CSFLogError(logTag, "%s Invalid params for m= media line, "
+ "build failed.", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ }
+
+ /* Build the media type */
+ flex_string_sprintf(fs, "m=%s ", sdp_get_media_name(mca_p->media));
+
+ /* Build the port based on the specified port format */
+ if (mca_p->port_format == SDP_PORT_NUM_ONLY) {
+ if (mca_p->port == SDP_CHOOSE_PARAM) {
+ flex_string_sprintf(fs, "$ ");
+ } else {
+ flex_string_sprintf(fs, "%u ", (unsigned)mca_p->port);
+ }
+ } else if (mca_p->port_format == SDP_PORT_NUM_COUNT) {
+ flex_string_sprintf(fs, "%u/%u ", (unsigned)mca_p->port,
+ (unsigned)mca_p->num_ports);
+ } else if (mca_p->port_format == SDP_PORT_VPI_VCI) {
+ flex_string_sprintf(fs, "%u/%u ",
+ (unsigned)mca_p->vpi, (unsigned)mca_p->vci);
+ } else if (mca_p->port_format == SDP_PORT_VCCI) {
+ flex_string_sprintf(fs, "%u ", (unsigned)mca_p->vcci);
+ } else if (mca_p->port_format == SDP_PORT_NUM_VPI_VCI) {
+ flex_string_sprintf(fs, "%u/%u/%u ", (unsigned)mca_p->port,
+ (unsigned)mca_p->vpi, (unsigned)mca_p->vci);
+ } else if (mca_p->port_format == SDP_PORT_VCCI_CID) {
+ if ((mca_p->vcci == SDP_CHOOSE_PARAM) &&
+ (mca_p->cid == SDP_CHOOSE_PARAM)) {
+ flex_string_sprintf(fs, "$/$ ");
+ } else if ((mca_p->vcci == SDP_CHOOSE_PARAM) ||
+ (mca_p->cid == SDP_CHOOSE_PARAM)) {
+ /* If one is set but not the other, this is an error. */
+ CSFLogError(logTag, "%s Invalid params for m= port parameter, "
+ "build failed.", sdp_p->debug_str);
+ sdp_p->conf_p->num_invalid_param++;
+ return (SDP_INVALID_PARAMETER);
+ } else {
+ flex_string_sprintf(fs, "%u/%u ",
+ (unsigned)mca_p->vcci, (unsigned)mca_p->cid);
+ }
+ } else if (mca_p->port_format == SDP_PORT_NUM_VPI_VCI_CID) {
+ flex_string_sprintf(fs, "%u/%u/%u/%u ", (unsigned)mca_p->port,
+ (unsigned)mca_p->vpi, (unsigned)mca_p->vci, (unsigned)mca_p->cid);
+ }
+
+ /* If the media line has AAL2 profiles, build them differently. */
+ if ((mca_p->transport == SDP_TRANSPORT_AAL2_ITU) ||
+ (mca_p->transport == SDP_TRANSPORT_AAL2_ATMF) ||
+ (mca_p->transport == SDP_TRANSPORT_AAL2_CUSTOM)) {
+ profile_p = mca_p->media_profiles_p;
+ for (i=0; i < profile_p->num_profiles; i++) {
+ flex_string_sprintf(fs, "%s",
+ sdp_get_transport_name(profile_p->profile[i]));
+
+ for (j=0; j < profile_p->num_payloads[i]; j++) {
+ flex_string_sprintf(fs, " %u",
+ (unsigned)profile_p->payload_type[i][j]);
+ }
+ flex_string_sprintf(fs, " ");
+ }
+ flex_string_sprintf(fs, "\n");
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Built m= media line", sdp_p->debug_str);
+ }
+ return (SDP_SUCCESS);
+ }
+
+ /* Build the transport name */
+ flex_string_sprintf(fs, "%s",
+ sdp_get_transport_name(mca_p->transport));
+
+ if(mca_p->transport != SDP_TRANSPORT_DTLSSCTP) {
+
+ /* Build the format lists */
+ for (i=0; i < mca_p->num_payloads; i++) {
+ if (mca_p->payload_indicator[i] == SDP_PAYLOAD_ENUM) {
+ flex_string_sprintf(fs, " %s",
+ sdp_get_payload_name((sdp_payload_e)mca_p->payload_type[i]));
+ } else {
+ flex_string_sprintf(fs, " %u", (unsigned)mca_p->payload_type[i]);
+ }
+ }
+ } else {
+ /* Add port to SDP if transport is DTLS/SCTP */
+ flex_string_sprintf(fs, " %u", (unsigned)mca_p->sctpport);
+ }
+
+ flex_string_sprintf(fs, "\r\n");
+
+ if (sdp_p->debug_flag[SDP_DEBUG_TRACE]) {
+ SDP_PRINT("%s Built m= media line", sdp_p->debug_str);
+ }
+ return (SDP_SUCCESS);
+}
+
+
+/* Function: sdp_parse_payload_types
+ * Description: Parse a list of payload types. The list may be part of
+ * a media line or part of a capability line.
+ * Parameters: sdp_ptr The SDP handle returned by sdp_init_description.
+ * mca_p The mca structure the payload types should be
+ * added to.
+ * ptr The pointer to the list of payloads.
+ * Returns: Nothing.
+ */
+void sdp_parse_payload_types (sdp_t *sdp_p, sdp_mca_t *mca_p, const char *ptr)
+{
+ uint16_t i;
+ uint16_t num_payloads;
+ sdp_result_e result;
+ tinybool valid_payload;
+ char tmp[SDP_MAX_STRING_LEN];
+ char *tmp2;
+
+ for (num_payloads = 0; (num_payloads < SDP_MAX_PAYLOAD_TYPES); ) {
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ /* If there are no more payload types, we're finished */
+ break;
+ }
+ mca_p->payload_type[num_payloads] = (uint16_t)sdp_getnextnumtok(tmp,
+ (const char **)&tmp2,
+ " \t", &result);
+ if (result == SDP_SUCCESS) {
+ if ((mca_p->media == SDP_MEDIA_IMAGE) &&
+ (mca_p->transport == SDP_TRANSPORT_UDPTL)) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Numeric payload type not "
+ "valid for media %s with transport %s.",
+ sdp_p->debug_str,
+ sdp_get_media_name(mca_p->media),
+ sdp_get_transport_name(mca_p->transport));
+ } else {
+ mca_p->payload_indicator[num_payloads] = SDP_PAYLOAD_NUMERIC;
+ mca_p->num_payloads++;
+ num_payloads++;
+ }
+ continue;
+ }
+
+ valid_payload = FALSE;
+ for (i=0; i < SDP_MAX_STRING_PAYLOAD_TYPES; i++) {
+ if (cpr_strncasecmp(tmp, sdp_payload[i].name,
+ sdp_payload[i].strlen) == 0) {
+ valid_payload = TRUE;
+ break;
+ }
+ }
+ if (valid_payload == TRUE) {
+ /* We recognized the payload type. Make sure it
+ * is valid for this media line. */
+ valid_payload = FALSE;
+ if ((mca_p->media == SDP_MEDIA_IMAGE) &&
+ (mca_p->transport == SDP_TRANSPORT_UDPTL) &&
+ (i == SDP_PAYLOAD_T38)) {
+ valid_payload = TRUE;
+ } else if ((mca_p->media == SDP_MEDIA_APPLICATION) &&
+ (mca_p->transport == SDP_TRANSPORT_UDP) &&
+ (i == SDP_PAYLOAD_XTMR)) {
+ valid_payload = TRUE;
+ } else if ((mca_p->media == SDP_MEDIA_APPLICATION) &&
+ (mca_p->transport == SDP_TRANSPORT_TCP) &&
+ (i == SDP_PAYLOAD_T120)) {
+ valid_payload = TRUE;
+ }
+
+ if (valid_payload == TRUE) {
+ mca_p->payload_indicator[num_payloads] = SDP_PAYLOAD_ENUM;
+ mca_p->payload_type[num_payloads] = i;
+ mca_p->num_payloads++;
+ num_payloads++;
+ } else {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Payload type %s not valid for "
+ "media %s with transport %s.",
+ sdp_p->debug_str,
+ sdp_get_payload_name((sdp_payload_e)i),
+ sdp_get_media_name(mca_p->media),
+ sdp_get_transport_name(mca_p->transport));
+ }
+ } else {
+ /* Payload type wasn't recognized. */
+ sdp_parse_error(sdp_p,
+ "%s Warning: Payload type "
+ "unsupported (%s).", sdp_p->debug_str, tmp);
+ }
+ }
+ if (mca_p->num_payloads == 0) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No payload types specified.",
+ sdp_p->debug_str);
+ }
+}
+
+
+/* Function: sdp_parse_multiple_profile_payload_types
+ * Description: Parse a list of payload types. The list may be part of
+ * a media line or part of a capability line.
+ * Parameters: sdp_ptr The SDP handle returned by sdp_init_description.
+ * mca_p The mca structure the payload types should be
+ * added to.
+ * ptr The pointer to the list of payloads.
+ * Returns: Nothing.
+ */
+sdp_result_e sdp_parse_multiple_profile_payload_types (sdp_t *sdp_p,
+ sdp_mca_t *mca_p,
+ const char *ptr)
+{
+ uint16_t i;
+ uint16_t prof;
+ uint16_t payload;
+ sdp_result_e result;
+ sdp_media_profiles_t *profile_p;
+ char tmp[SDP_MAX_STRING_LEN];
+ char *tmp2;
+
+ /* If the transport type is any of the AAL2 formats, then we
+ * need to look for multiple AAL2 profiles and their associated
+ * payload lists. */
+ mca_p->media_profiles_p = (sdp_media_profiles_t *) \
+ SDP_MALLOC(sizeof(sdp_media_profiles_t));
+ if (mca_p->media_profiles_p == NULL) {
+ sdp_p->conf_p->num_no_resource++;
+ SDP_FREE(mca_p);
+ return (SDP_NO_RESOURCE);
+ }
+ profile_p = mca_p->media_profiles_p;
+ /* Set the first profile to the one already detected. */
+ profile_p->num_profiles = 1;
+ prof = 0;
+ payload = 0;
+ profile_p->profile[prof] = mca_p->transport;
+ profile_p->num_payloads[prof] = 0;
+
+ /* Now find the payload type lists and any other profile types */
+ while (TRUE) {
+ ptr = sdp_getnextstrtok(ptr, tmp, sizeof(tmp), " \t", &result);
+ if (result != SDP_SUCCESS) {
+ /* If there are no more payload types, we're finished */
+ break;
+ }
+
+ /* See if the next token is a new profile type. */
+ if (prof < SDP_MAX_PROFILES) {
+ profile_p->profile[prof+1] = SDP_TRANSPORT_UNSUPPORTED;
+ for (i=SDP_TRANSPORT_AAL2_ITU;
+ i <= SDP_TRANSPORT_AAL2_CUSTOM; i++) {
+ if (cpr_strncasecmp(tmp, sdp_transport[i].name,
+ sdp_transport[i].strlen) == 0) {
+ profile_p->profile[prof+1] = (sdp_transport_e)i;
+ break;
+ }
+ }
+ /* If we recognized the profile type, start looking for the
+ * next payload list. */
+ if (profile_p->profile[prof+1] != SDP_TRANSPORT_UNSUPPORTED) {
+ /* Now reset the payload counter for the next profile type. */
+ payload = 0;
+ prof++;
+ profile_p->num_profiles++;
+ if (prof < SDP_MAX_PROFILES) {
+ profile_p->num_payloads[prof] = 0;
+ }
+ continue;
+ }
+ }
+
+ /* This token must be a payload type. Make sure there aren't
+ * too many payload types. */
+ if (payload >= SDP_MAX_PAYLOAD_TYPES) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: Too many payload types "
+ "found, truncating.", sdp_p->debug_str);
+ continue;
+ }
+
+ /* See if the payload type is numeric. */
+ if (prof < SDP_MAX_PROFILES && payload < SDP_MAX_PAYLOAD_TYPES) {
+ profile_p->payload_type[prof][payload] = (uint16_t)sdp_getnextnumtok(tmp,
+ (const char **)&tmp2,
+ " \t", &result);
+ if (result == SDP_SUCCESS) {
+ profile_p->payload_indicator[prof][payload] = SDP_PAYLOAD_NUMERIC;
+ profile_p->num_payloads[prof]++;
+ payload++;
+ continue;
+ }
+ }
+
+ /* No string payload types are currently valid for the AAL2
+ * transport types. This support can be added when needed. */
+ sdp_parse_error(sdp_p,
+ "%s Warning: Unsupported payload type "
+ "found (%s).", sdp_p->debug_str, tmp);
+ }
+ for (i=0; i < profile_p->num_profiles; i++) {
+ /* Make sure we have payloads for each profile type. */
+ if (profile_p->num_payloads[i] == 0) {
+ sdp_parse_error(sdp_p,
+ "%s Warning: No payload types specified "
+ "for AAL2 profile %s.", sdp_p->debug_str,
+ sdp_get_transport_name(profile_p->profile[i]));
+ }
+ }
+ return (SDP_SUCCESS);
+}
diff --git a/media/webrtc/signaling/src/sdp/sipcc/sdp_utils.c b/media/webrtc/signaling/src/sdp/sipcc/sdp_utils.c
new file mode 100644
index 000000000..a02035c72
--- /dev/null
+++ b/media/webrtc/signaling/src/sdp/sipcc/sdp_utils.c
@@ -0,0 +1,781 @@
+/* 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 <errno.h>
+#include <limits.h>
+#include <ctype.h>
+#include "sdp_os_defs.h"
+#include "sdp.h"
+#include "sdp_private.h"
+
+#include "CSFLog.h"
+
+#define MKI_BUF_LEN 4
+
+static const char* logTag = "sdp_utils";
+
+sdp_mca_t *sdp_alloc_mca (uint32_t line) {
+ sdp_mca_t *mca_p;
+
+ /* Allocate resource for new media stream. */
+ mca_p = (sdp_mca_t *)SDP_MALLOC(sizeof(sdp_mca_t));
+ if (mca_p == NULL) {
+ return (NULL);
+ }
+ /* Initialize mca structure */
+ mca_p->media = SDP_MEDIA_INVALID;
+ mca_p->conn.nettype = SDP_NT_INVALID;
+ mca_p->conn.addrtype = SDP_AT_INVALID;
+ mca_p->conn.conn_addr[0] = '\0';
+ mca_p->conn.is_multicast = FALSE;
+ mca_p->conn.ttl = 0;
+ mca_p->conn.num_of_addresses = 0;
+ mca_p->transport = SDP_TRANSPORT_INVALID;
+ mca_p->port = SDP_INVALID_VALUE;
+ mca_p->num_ports = SDP_INVALID_VALUE;
+ mca_p->vpi = SDP_INVALID_VALUE;
+ mca_p->vci = 0;
+ mca_p->vcci = SDP_INVALID_VALUE;
+ mca_p->cid = SDP_INVALID_VALUE;
+ mca_p->num_payloads = 0;
+ mca_p->sessinfo_found = FALSE;
+ mca_p->encrypt.encrypt_type = SDP_ENCRYPT_INVALID;
+ mca_p->media_attrs_p = NULL;
+ mca_p->next_p = NULL;
+ mca_p->mid = 0;
+ mca_p->bw.bw_data_count = 0;
+ mca_p->bw.bw_data_list = NULL;
+ mca_p->line_number = line;
+
+ return (mca_p);
+}
+
+/*
+ * next_token
+ *
+ * copy token param with chars from str until null, cr, lf, or one of the delimiters is found.
+ * delimiters at the beginning will be skipped.
+ * The pointer *string_of_tokens is moved forward to the next token on sucess.
+ *
+ */
+static sdp_result_e next_token(const char **string_of_tokens, char *token, unsigned token_max_len, const char *delim)
+{
+ int flag2moveon = 0;
+ const char *str;
+ const char *token_end;
+ const char *next_delim;
+
+ if (!string_of_tokens || !*string_of_tokens || !token || !delim) {
+ return SDP_FAILURE;
+ }
+
+ str = *string_of_tokens;
+ token_end = token + token_max_len - 1;
+
+ /* Locate front of token, skipping any delimiters */
+ for ( ; ((*str != '\0') && (*str != '\n') && (*str != '\r')); str++) {
+ flag2moveon = 1; /* Default to move on unless we find a delimiter */
+ for (next_delim=delim; *next_delim; next_delim++) {
+ if (*str == *next_delim) {
+ flag2moveon = 0;
+ break;
+ }
+ }
+ if( flag2moveon ) {
+ break; /* We're at the beginning of the token */
+ }
+ }
+
+ /* Make sure there's really a token present. */
+ if ((*str == '\0') || (*str == '\n') || (*str == '\r')) {
+ return SDP_EMPTY_TOKEN;
+ }
+
+ /* Now locate end of token */
+ flag2moveon = 0;
+
+ while ((token < token_end) &&
+ (*str != '\0') && (*str != '\n') && (*str != '\r')) {
+ for (next_delim=delim; *next_delim; next_delim++) {
+ if (*str == *next_delim) {
+ flag2moveon = 1;
+ break;
+ }
+ }
+ if( flag2moveon ) {
+ break;
+ } else {
+ *token++ = *str++;
+ }
+ }
+
+ /* mark end of token */
+ *token = '\0';
+
+ /* set the string of tokens to the next token */
+ *string_of_tokens = str;
+
+ return SDP_SUCCESS;
+}
+
+/*
+ * verify_sdescriptions_mki
+ *
+ * Verifies the syntax of the MKI parameter.
+ *
+ * mki = mki-value ":" mki-length
+ * mki-value = 1*DIGIT
+ * mki-length = 1*3DIGIT ; range 1..128
+ *
+ * Inputs:
+ * buf - ptr to start of MKI string assumes NULL
+ * terminated string
+ * mkiValue - buffer to store the MKI value, assumes calling
+ * function has provided memory for this.
+ * mkiLen - integer to store the MKI length
+ *
+ * Outputs:
+ * Returns TRUE if syntax is correct and stores the
+ * MKI value in mkiVal and stores the length in mkiLen.
+ * Returns FALSE otherwise.
+ */
+
+tinybool
+verify_sdescriptions_mki (char *buf, char *mkiVal, uint16_t *mkiLen)
+{
+
+ char *ptr,
+ mkiValBuf[SDP_SRTP_MAX_MKI_SIZE_BYTES],
+ mkiLenBuf[MKI_BUF_LEN];
+ int idx = 0;
+ unsigned long strtoul_result;
+ char *strtoul_end;
+
+ ptr = buf;
+ /* MKI must begin with a digit */
+ if (!ptr || (!isdigit((int) *ptr))) {
+ return FALSE;
+ }
+
+ /* scan until we reach a non-digit or colon */
+ while (*ptr) {
+ if (*ptr == ':') {
+ /* terminate the MKI value */
+ mkiValBuf[idx] = 0;
+ ptr++;
+ break;
+ } else if ((isdigit((int) *ptr) && (idx < SDP_SRTP_MAX_MKI_SIZE_BYTES-1))) {
+ mkiValBuf[idx++] = *ptr;
+ } else {
+ return FALSE;
+ }
+
+ ptr++;
+ }
+
+ /* there has to be a mki length */
+ if (*ptr == 0) {
+ return FALSE;
+ }
+
+ idx = 0;
+
+ /* verify the mki length (max 3 digits) */
+ while (*ptr) {
+ if (isdigit((int) *ptr) && (idx < 3)) {
+ mkiLenBuf[idx++] = *ptr;
+ } else {
+ return FALSE;
+ }
+
+ ptr++;
+ }
+
+ mkiLenBuf[idx] = 0;
+
+ errno = 0;
+ strtoul_result = strtoul(mkiLenBuf, &strtoul_end, 10);
+
+ /* mki len must be between 1..128 */
+ if (errno || mkiLenBuf == strtoul_end || strtoul_result < 1 || strtoul_result > 128) {
+ *mkiLen = 0;
+ return FALSE;
+ }
+
+ *mkiLen = (uint16_t) strtoul_result;
+ sstrncpy(mkiVal, mkiValBuf, MKI_BUF_LEN);
+
+ return TRUE;
+}
+
+/*
+ * verify_srtp_lifetime
+ *
+ * Verifies the Lifetime parameter syntax.
+ *
+ * lifetime = ["2^"] 1*(DIGIT)
+ *
+ * Inputs:
+ * buf - pointer to start of lifetime string. Assumes string is
+ * NULL terminated.
+ * Outputs:
+ * Returns TRUE if syntax is correct. Returns FALSE otherwise.
+ */
+
+tinybool
+verify_sdescriptions_lifetime (char *buf)
+{
+
+ char *ptr;
+ tinybool tokenFound = FALSE;
+
+ ptr = buf;
+ if (!ptr || *ptr == 0) {
+ return FALSE;
+ }
+
+ while (*ptr) {
+ if (*ptr == '^') {
+ if (tokenFound) {
+ /* make sure we don't have multiple ^ */
+ return FALSE;
+ } else {
+ tokenFound = TRUE;
+ /* Lifetime is in power of 2 format, make sure first and second
+ * chars are 2^
+ */
+
+ if (buf[0] != '2' || buf[1] != '^') {
+ return FALSE;
+ }
+ }
+ } else if (!isdigit((int) *ptr)) {
+ return FALSE;
+ }
+
+ ptr++;
+
+ }
+
+ /* Make sure if the format is 2^ that there is a number after the ^. */
+ if (tokenFound) {
+ if (strlen(buf) <= 2) {
+ return FALSE;
+ }
+ }
+
+ return TRUE;
+}
+
+
+/*
+ * sdp_validate_maxprate
+ *
+ * This function validates that the string passed in is of the form:
+ * packet-rate = 1*DIGIT ["." 1*DIGIT]
+ */
+tinybool
+sdp_validate_maxprate(const char *string_parm)
+{
+ tinybool retval = FALSE;
+
+ if (string_parm && (*string_parm)) {
+ while (isdigit((int)*string_parm)) {
+ string_parm++;
+ }
+
+ if (*string_parm == '.') {
+ string_parm++;
+ while (isdigit((int)*string_parm)) {
+ string_parm++;
+ }
+ }
+
+ if (*string_parm == '\0') {
+ retval = TRUE;
+ } else {
+ retval = FALSE;
+ }
+ }
+
+ return retval;
+}
+
+char *sdp_findchar (const char *ptr, char *char_list)
+{
+ int i;
+
+ for (;*ptr != '\0'; ptr++) {
+ for (i=0; char_list[i] != '\0'; i++) {
+ if (*ptr == char_list[i]) {
+ return ((char *)ptr);
+ }
+ }
+ }
+ return ((char *)ptr);
+}
+
+/* Locate the next token in a line. The delim characters are passed in
+ * as a param. The token also will not go past a new line char or the
+ * end of the string. Skip any delimiters before the token.
+ */
+const char *sdp_getnextstrtok (const char *str, char *tokenstr, unsigned tokenstr_len,
+ const char *delim, sdp_result_e *result)
+{
+ const char *token_list = str;
+
+ if (!str || !tokenstr || !delim || !result) {
+ if (result) {
+ *result = SDP_FAILURE;
+ }
+ return str;
+ }
+
+ *result = next_token(&token_list, tokenstr, tokenstr_len, delim);
+
+ return token_list;
+}
+
+
+
+/* Locate the next null ("-") or numeric token in a string. The delim
+ * characters are passed in as a param. The token also will not go past
+ * a new line char or the end of the string. Skip any delimiters before
+ * the token.
+ */
+uint32_t sdp_getnextnumtok_or_null (const char *str, const char **str_end,
+ const char *delim, tinybool *null_ind,
+ sdp_result_e *result)
+{
+ const char *token_list = str;
+ char temp_token[SDP_MAX_STRING_LEN];
+ char *strtoul_end;
+ unsigned long numval;
+
+ if (null_ind) {
+ *null_ind = FALSE;
+ }
+
+ if (!str || !str_end || !delim || !null_ind || !result) {
+ if (result) {
+ *result = SDP_FAILURE;
+ }
+ return 0;
+ }
+
+ *result = next_token(&token_list, temp_token, sizeof(temp_token), delim);
+
+ if (*result != SDP_SUCCESS) {
+ return 0;
+ }
+
+ /* First see if its the null char ("-") */
+ if (temp_token[0] == '-') {
+ *null_ind = TRUE;
+ *result = SDP_SUCCESS;
+ *str_end = str;
+ return 0;
+ }
+
+ errno = 0;
+ numval = strtoul(temp_token, &strtoul_end, 10);
+
+ if (errno || strtoul_end == temp_token || numval > UINT_MAX) {
+ *result = SDP_FAILURE;
+ return 0;
+ }
+
+ *result = SDP_SUCCESS;
+ *str_end = token_list;
+ return (uint32_t) numval;
+}
+
+
+/* Locate the next numeric token in a string. The delim characters are
+ * passed in as a param. The token also will not go past a new line char
+ * or the end of the string. Skip any delimiters before the token.
+ */
+uint32_t sdp_getnextnumtok (const char *str, const char **str_end,
+ const char *delim, sdp_result_e *result)
+{
+ const char *token_list = str;
+ char temp_token[SDP_MAX_STRING_LEN];
+ char *strtoul_end;
+ unsigned long numval;
+
+ if (!str || !str_end || !delim || !result) {
+ if (result) {
+ *result = SDP_FAILURE;
+ }
+ return 0;
+ }
+
+ *result = next_token(&token_list, temp_token, sizeof(temp_token), delim);
+
+ if (*result != SDP_SUCCESS) {
+ return 0;
+ }
+
+ errno = 0;
+ numval = strtoul(temp_token, &strtoul_end, 10);
+
+ if (errno || strtoul_end == temp_token || numval > UINT_MAX) {
+ *result = SDP_FAILURE;
+ return 0;
+ }
+
+ *result = SDP_SUCCESS;
+ *str_end = token_list;
+ return (uint32_t) numval;
+}
+
+
+/* See if the next token in a string is the choose character. The delim
+ * characters are passed in as a param. The check also will not go past
+ * a new line char or the end of the string. Skip any delimiters before
+ * the token.
+ */
+tinybool sdp_getchoosetok (const char *str, const char **str_end,
+ const char *delim, sdp_result_e *result)
+{
+ const char *b;
+ int flag2moveon;
+
+ if ((str == NULL) || (str_end == NULL)) {
+ *result = SDP_FAILURE;
+ return(FALSE);
+ }
+
+ /* Locate front of token, skipping any delimiters */
+ for ( ; ((*str != '\0') && (*str != '\n') && (*str != '\r')); str++) {
+ flag2moveon = 1; /* Default to move on unless we find a delimiter */
+ for (b=delim; *b; b++) {
+ if (*str == *b) {
+ flag2moveon = 0;
+ break;
+ }
+ }
+ if( flag2moveon ) {
+ break; /* We're at the beginning of the token */
+ }
+ }
+
+ /* Make sure there's really a token present. */
+ if ((*str == '\0') || (*str == '\n') || (*str == '\r')) {
+ *result = SDP_FAILURE;
+ *str_end = (char *)str;
+ return(FALSE);
+ }
+
+ /* See if the token is '$' followed by a delimiter char or end of str. */
+ if (*str == '$') {
+ str++;
+ if ((*str == '\0') || (*str == '\n') || (*str == '\r')) {
+ *result = SDP_SUCCESS;
+ /* skip the choose char in the string. */
+ *str_end = (char *)(str+1);
+ return(TRUE);
+ }
+ for (b=delim; *b; b++) {
+ if (*str == *b) {
+ *result = SDP_SUCCESS;
+ /* skip the choose char in the string. */
+ *str_end = (char *)(str+1);
+ return(TRUE);
+ }
+ }
+ }
+
+ /* If the token was not '$' followed by a delim, token is not choose */
+ *result = SDP_SUCCESS;
+ *str_end = (char *)str;
+ return(FALSE);
+
+}
+
+/*
+ * SDP Crypto Utility Functions.
+ *
+ * First a few common definitions.
+ */
+
+/*
+ * Constants
+ *
+ * crypto_string = The string used to identify the start of sensative
+ * crypto data.
+ *
+ * inline_string = The string used to identify the start of key/salt
+ * crypto data.
+ *
+ * star_string = The string used to overwrite sensative data.
+ *
+ * '*_strlen' = The length of '*_string' in bytes (not including '\0')
+ */
+static const char crypto_string[] = "X-crypto:";
+static const int crypto_strlen = sizeof(crypto_string) - 1;
+static const char inline_string[] = "inline:";
+static const int inline_strlen = sizeof(inline_string) - 1;
+/* 40 characters is the current maximum for a Base64 encoded key/salt */
+static const char star_string[] = "****************************************";
+static const int star_strlen = sizeof(star_string) - 1;
+
+/*
+ * MIN_CRYPTO_STRING_SIZE_BYTES = This value defines the minimum
+ * size of a string that could contain a key/salt. This value
+ * is used to skip out of parsing when there is no reasonable
+ * assumption that sensative data will be found. The general
+ * format of a SRTP Key Salt in SDP looks like:
+ *
+ * X-crypto:<crypto_suite_name> inline:<master_key_salt>||
+ *
+ * if <crypto_suite_name> and <master_key_salt> is at least
+ * one character and one space is used before the "inline:",
+ * then this translates to a size of (aligned by collumn from
+ * the format shown above):
+ *
+ * 9+ 1+ 1+7+ 1+ 2 = 21
+ *
+ */
+#define MIN_CRYPTO_STRING_SIZE_BYTES 21
+
+/*
+ * Utility macros
+ *
+ * CHAR_IS_WHITESPACE = macro to determine if the passed _test_char
+ * is whitespace.
+ *
+ * SKIP_WHITESPACE = Macro to advance _cptr to the next non-whitespace
+ * character. _cptr will not be advanced past _max_cptr.
+ *
+ * FIND_WHITESPACE = Macro to advance _cptr until whitespace is found.
+ * _cptr will not be advanced past _max_cptr.
+ */
+#define CHAR_IS_WHITESPACE(_test_char) \
+ ((((_test_char)==' ')||((_test_char)=='\t'))?1:0)
+
+#define SKIP_WHITESPACE(_cptr, _max_cptr) \
+ while ((_cptr)<=(_max_cptr)) { \
+ if (!CHAR_IS_WHITESPACE(*(_cptr))) break; \
+ (_cptr)++; \
+ }
+
+#define FIND_WHITESPACE(_cptr, _max_cptr) \
+ while ((_cptr)<=(_max_cptr)) { \
+ if (CHAR_IS_WHITESPACE(*(_cptr))) break; \
+ (_cptr)++; \
+ }
+
+/* Function: sdp_crypto_debug
+ * Description: Check the passed buffer for sensitive data that should
+ * not be output (such as SRTP Master Key/Salt) and output
+ * the buffer as debug. Sensitive data will be replaced
+ * with the '*' character(s). This function may be used
+ * to display very large buffers so this function ensures
+ * that buginf is not overloaded.
+ * Parameters: buffer pointer to the message buffer to filter.
+ * length_bytes size of message buffer in bytes.
+ * Returns: Nothing.
+ */
+void sdp_crypto_debug (char *buffer, ulong length_bytes)
+{
+ char *current, *start;
+ char *last = buffer + length_bytes;
+ int result;
+
+ /*
+ * For SRTP Master Key/Salt has the form:
+ * X-crypto:<crypto_suite_name> inline:<master_key_salt>||
+ * Where <master_key_salt> is the data to elide (filter).
+ */
+ for (start=current=buffer;
+ current<=last-MIN_CRYPTO_STRING_SIZE_BYTES;
+ current++) {
+ if ((*current == 'x') || (*current == 'X')) {
+ result = cpr_strncasecmp(current, crypto_string, crypto_strlen);
+ if (!result) {
+ current += crypto_strlen;
+ if (current > last) break;
+
+ /* Skip over crypto suite name */
+ FIND_WHITESPACE(current, last);
+
+ /* Skip over whitespace */
+ SKIP_WHITESPACE(current, last);
+
+ /* identify inline keyword */
+ result = cpr_strncasecmp(current, inline_string, inline_strlen);
+ if (!result) {
+ int star_count = 0;
+
+ current += inline_strlen;
+ if (current > last) break;
+
+ sdp_dump_buffer(start, current - start);
+
+ /* Hide sensitive key/salt data */
+ while (current<=last) {
+ if (*current == '|' || *current == '\n') {
+ /* Done, print the stars */
+ while (star_count > star_strlen) {
+ /*
+ * This code is only for the case where
+ * too much base64 data was supplied
+ */
+ sdp_dump_buffer((char*)star_string, star_strlen);
+ star_count -= star_strlen;
+ }
+ sdp_dump_buffer((char*)star_string, star_count);
+ break;
+ } else {
+ star_count++;
+ current++;
+ }
+ }
+ /* Update start pointer */
+ start=current;
+ }
+ }
+ }
+ }
+
+ if (last > start) {
+ /* Display remainder of buffer */
+ sdp_dump_buffer(start, last - start);
+ }
+}
+
+/*
+ * sdp_debug_msg_filter
+ *
+ * DESCRIPTION
+ * Check the passed message buffer for sensitive data that should
+ * not be output (such as SRTP Master Key/Salt). Sensitive data
+ * will be replaced with the '*' character(s).
+ *
+ * PARAMETERS
+ * buffer: pointer to the message buffer to filter.
+ *
+ * length_bytes: size of message buffer in bytes.
+ *
+ * RETURN VALUE
+ * The buffer modified.
+ */
+char * sdp_debug_msg_filter (char *buffer, ulong length_bytes)
+{
+ char *current;
+ char *last = buffer + length_bytes;
+ int result;
+
+ SDP_PRINT("\n%s:%d: Eliding sensitive data from debug output",
+ __FILE__, __LINE__);
+ /*
+ * For SRTP Master Key/Salt has the form:
+ * X-crypto:<crypto_suite_name> inline:<master_key_salt>||
+ * Where <master_key_salt> is the data to elide (filter).
+ */
+ for (current=buffer;
+ current<=last-MIN_CRYPTO_STRING_SIZE_BYTES;
+ current++) {
+ if ((*current == 'x') || (*current == 'X')) {
+ result = cpr_strncasecmp(current, crypto_string, crypto_strlen);
+ if (!result) {
+ current += crypto_strlen;
+ if (current > last) break;
+
+ /* Skip over crypto suite name */
+ FIND_WHITESPACE(current, last);
+
+ /* Skip over whitespace */
+ SKIP_WHITESPACE(current, last);
+
+ /* identify inline keyword */
+ result = cpr_strncasecmp(current, inline_string, inline_strlen);
+ if (!result) {
+ current += inline_strlen;
+ if (current > last) break;
+
+ /* Hide sensitive key/salt data */
+ while (current<=last) {
+ if (*current == '|' || *current == '\n') {
+ /* Done */
+ break;
+ } else {
+ *current = '*';
+ current++;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return buffer;
+}
+
+
+/* Function: sdp_checkrange
+ * Description: This checks the range of a ulong value to make sure its
+ * within the range of 0 and 4Gig. stroul cannot be used since
+ * for values greater greater than 4G, stroul will either wrap
+ * around or return ULONG_MAX.
+ * Parameters: sdp_p Pointer to the sdp structure
+ * num The number to check the range for
+ * u_val This variable get populated with the ulong value
+ * if the number is within the range.
+ * Returns: tinybool - returns TRUE if the number passed is within the
+ * range, FALSE otherwise
+ */
+tinybool sdp_checkrange (sdp_t *sdp_p, char *num, ulong *u_val)
+{
+ ulong l_val;
+ char *endP = NULL;
+ *u_val = 0;
+
+ if (!num || !*num) {
+ return FALSE;
+ }
+
+ if (*num == '-') {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s ERROR: Parameter value is a negative number: %s",
+ sdp_p->debug_str, num);
+ }
+ return FALSE;
+ }
+
+ l_val = strtoul(num, &endP, 10);
+ if (*endP == '\0') {
+
+ if (l_val > 4294967295UL) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s ERROR: Parameter value: %s is greater than 4294967295",
+ sdp_p->debug_str, num);
+ }
+ return FALSE;
+ }
+
+ if (l_val == 4294967295UL) {
+ /*
+ * On certain platforms where ULONG_MAX is equivalent to
+ * 4294967295, strtoul will return ULONG_MAX even if the the
+ * value of the string is greater than 4294967295. To detect
+ * that scenario we make an explicit check here.
+ */
+ if (strcmp("4294967295", num)) {
+ if (sdp_p->debug_flag[SDP_DEBUG_ERRORS]) {
+ CSFLogError(logTag, "%s ERROR: Parameter value: %s is greater than 4294967295",
+ sdp_p->debug_str, num);
+ }
+ return FALSE;
+ }
+ }
+ }
+ *u_val = l_val;
+ return TRUE;
+}
+
+#undef CHAR_IS_WHITESPACE
+#undef SKIP_WHITESPACE
+#undef FIND_WHITESPACE