Negotiate H264 profiles in SDP

webrtc/media/base/codec.cc

 /*
  *  Copyright (c) 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/media/base/codec.h"
 
 #include <algorithm>
 #include <sstream>
 
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/stringutils.h"
+#include "webrtc/common_video/h264/profile_level_id.h"
 
 namespace cricket {
 
 const int kMaxPayloadId = 127;
 
 bool FeedbackParam::operator==(const FeedbackParam& other) const {
   return _stricmp(other.id().c_str(), id().c_str()) == 0 &&
       _stricmp(other.param().c_str(), param().c_str()) == 0;
 }
 
@@ skipping 181 matching lines @@
 
 VideoCodec::VideoCodec(const VideoCodec& c) = default;
 VideoCodec::VideoCodec(VideoCodec&& c) = default;
 VideoCodec& VideoCodec::operator=(const VideoCodec& c) = default;
 VideoCodec& VideoCodec::operator=(VideoCodec&& c) = default;
 
 bool VideoCodec::operator==(const VideoCodec& c) const {
   return Codec::operator==(c);
 }
 
+bool VideoCodec::Matches(const VideoCodec& other) const {
+  if (!Codec::Matches(other))
+    return false;
+  if (!CodecNamesEq(name.c_str(), kH264CodecName))
+    return true;
+  const rtc::Optional<webrtc::H264::ProfileLevelId> profile_level_id =
+      webrtc::H264::ParseSdpProfileLevelId(params);
+  const rtc::Optional<webrtc::H264::ProfileLevelId> other_profile_level_id =
+      webrtc::H264::ParseSdpProfileLevelId(other.params);
+  // Compare H264 profiles, but not levels.
+  return profile_level_id && other_profile_level_id &&
+         profile_level_id->profile == other_profile_level_id->profile;

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

See comment about matching. This says whether they are the same, not whether an
encoder for one can be decoded by the other.

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

Yes, this function compares whether the codecs are the same (and distinguishes
different H264 profiles). It's not supposed to be used to determine whether an
encoder for one can be decoded by the other. I have updated the function comment
to better reflect this. Since we need to send different H264 profiles as
different payload types, this is the natural extension of the current Matches
function that only compares codec names.

+}
+
 VideoCodec VideoCodec::CreateRtxCodec(int rtx_payload_type,
                                       int associated_payload_type) {
   VideoCodec rtx_codec(rtx_payload_type, kRtxCodecName);
   rtx_codec.SetParam(kCodecParamAssociatedPayloadType, associated_payload_type);
   return rtx_codec;
 }
 
 VideoCodec::CodecType VideoCodec::GetCodecType() const {
   const char* payload_name = name.c_str();
   if (_stricmp(payload_name, kRedCodecName) == 0) {
@@ skipping 83 matching lines @@
   } else if (CodecNamesEq(name.c_str(), kH264CodecName)) {
     return webrtc::kVideoCodecH264;
   }
   return webrtc::kVideoCodecUnknown;
 }
 
 bool IsCodecSupported(const std::vector<VideoCodec>& supported_codecs,
                       const VideoCodec& codec) {
   return std::any_of(supported_codecs.begin(), supported_codecs.end(),
                      [&codec](const VideoCodec& supported_codec) -> bool {
-                       return CodecNamesEq(codec.name, supported_codec.name);
+                       return codec.Matches(supported_codec);
                      });
 }
 
 }  // namespace cricket