Negotiate H264 profiles in SDP

webrtc/pc/mediasession.cc

 /*
  *  Copyright 2004 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/pc/mediasession.h"
 
 #include <algorithm>  // For std::find_if, std::sort.
 #include <functional>
 #include <map>
 #include <memory>
 #include <set>
 #include <unordered_map>
 #include <utility>
 
 #include "webrtc/base/base64.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/stringutils.h"
+#include "webrtc/common_video/h264/profile_level_id.h"
 #include "webrtc/media/base/cryptoparams.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/p2p/base/p2pconstants.h"
 #include "webrtc/pc/channelmanager.h"
 #include "webrtc/pc/srtpfilter.h"
 
 namespace {
 const char kInline[] = "inline:";
 
 void GetSupportedCryptoSuiteNames(void (*func)(const rtc::CryptoOptions&,
@@ skipping 727 matching lines @@
   if (!rtc::FromString(codec1_id_str, &codec1_id) ||
       !rtc::FromString(codec2_id_str, &codec2_id) ||
       !FindCodecById(codecs1, codec1_id, &codec1) ||
       !FindCodecById(codecs2, codec2_id, &codec2)) {
     return false;
   }
   return codec1.Matches(codec2);
 }
 
 template <class C>
+static rtc::Optional<C> IntersectCodecs(const C& local, const C& remote) {
+  C intersected = local;
+
+  if (CodecNamesEq(local.name.c_str(), kH264CodecName)) {
+    const rtc::Optional<webrtc::H264::ProfileLevelId> intersected_profile =
+        webrtc::H264::NegotiateProfileLevelId(local.params, remote.params);

[hta-webrtc, 2016/11/08 13:59:53]

Illustrates my point about Negotiate being misnamed in the CL that introduced it
- "Intersect" would be a better name.

[magjed_webrtc, 2016/11/08 16:18:26]

Yeah, I'm not that happy with either the name intersect or negotiate here.

+    if (!intersected_profile)
+      return rtc::Optional<C>();
+    intersected.params["profile-level-id"] =
+        *webrtc::H264::ProfileLevelIdToString(*intersected_profile);
+  }
+
+  intersected.IntersectFeedbackParams(remote);
+  if (IsRtxCodec(remote)) {
+    const auto apt_it = remote.params.find(kCodecParamAssociatedPayloadType);
+    RTC_DCHECK(apt_it != remote.params.end());
+    intersected.SetParam(kCodecParamAssociatedPayloadType, apt_it->second);
+  }
+  intersected.id = remote.id;
+  intersected.name = remote.name;
+  return rtc::Optional<C>(std::move(intersected));
+}
+
+template <class C>
 static void NegotiateCodecs(const std::vector<C>& local_codecs,
                             const std::vector<C>& offered_codecs,
                             std::vector<C>* negotiated_codecs) {
   for (const C& ours : local_codecs) {
     C theirs;
     // Note that we intentionally only find one matching codec for each of our
     // local codecs, in case the remote offer contains duplicate codecs.
     if (FindMatchingCodec(local_codecs, offered_codecs, ours, &theirs)) {
-      C negotiated = ours;
-      negotiated.IntersectFeedbackParams(theirs);
-      if (IsRtxCodec(negotiated)) {
-        std::string offered_apt_value;
-        theirs.GetParam(kCodecParamAssociatedPayloadType, &offered_apt_value);
-        // FindMatchingCodec shouldn't return something with no apt value.
-        RTC_DCHECK(!offered_apt_value.empty());
-        negotiated.SetParam(kCodecParamAssociatedPayloadType,
-                            offered_apt_value);
-      }
-      negotiated.id = theirs.id;
-      negotiated.name = theirs.name;
-      negotiated_codecs->push_back(negotiated);
+      rtc::Optional<C> negotiated = IntersectCodecs(ours, theirs);
+      if (negotiated)
+        negotiated_codecs->push_back(std::move(*negotiated));
     }
   }
   // RFC3264: Although the answerer MAY list the formats in their desired
   // order of preference, it is RECOMMENDED that unless there is a
   // specific reason, the answerer list formats in the same relative order
   // they were present in the offer.
   std::unordered_map<int, int> payload_type_preferences;
   int preference = static_cast<int>(offered_codecs.size() + 1);
   for (const C& codec : offered_codecs) {
     payload_type_preferences[codec.id] = preference--;
@@ skipping 1358 matching lines @@
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_VIDEO));
 }
 
 DataContentDescription* GetFirstDataContentDescription(
     SessionDescription* sdesc) {
   return static_cast<DataContentDescription*>(
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_DATA));
 }
 
 }  // namespace cricket