Add m-esr52 at 52.6.0

1 files changed, 292 insertions, 0 deletions

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