Removing `preference` field from `cricket::Codec`.

webrtc/api/webrtcsdp.cc

 /*
  *  Copyright 2011 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/api/webrtcsdp.h"
 
 #include <ctype.h>
 #include <limits.h>
 #include <stdio.h>
 #include <algorithm>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 #include "webrtc/api/jsepicecandidate.h"
 #include "webrtc/api/jsepsessiondescription.h"
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/messagedigest.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/media/base/codec.h"
@@ skipping 234 matching lines @@
     const std::string& message,
     const TransportDescription& session_td,
     const RtpHeaderExtensions& session_extmaps,
     size_t* pos, cricket::SessionDescription* desc,
     std::vector<JsepIceCandidate*>* candidates,
     SdpParseError* error);
 static bool ParseContent(const std::string& message,
                          const MediaType media_type,
                          int mline_index,
                          const std::string& protocol,
-                         const std::vector<int>& codec_preference,
+                         const std::vector<int>& payload_types,
                          size_t* pos,
                          std::string* content_name,
                          MediaContentDescription* media_desc,
                          TransportDescription* transport,
                          std::vector<JsepIceCandidate*>* candidates,
                          SdpParseError* error);
 static bool ParseSsrcAttribute(const std::string& line,
                                SsrcInfoVec* ssrc_infos,
                                SdpParseError* error);
 static bool ParseSsrcGroupAttribute(const std::string& line,
                                     SsrcGroupVec* ssrc_groups,
                                     SdpParseError* error);
 static bool ParseCryptoAttribute(const std::string& line,
                                  MediaContentDescription* media_desc,
                                  SdpParseError* error);
 static bool ParseRtpmapAttribute(const std::string& line,
                                  const MediaType media_type,
-                                 const std::vector<int>& codec_preference,
+                                 const std::vector<int>& payload_types,
                                  MediaContentDescription* media_desc,
                                  SdpParseError* error);
 static bool ParseFmtpAttributes(const std::string& line,
                                 const MediaType media_type,
                                 MediaContentDescription* media_desc,
                                 SdpParseError* error);
 static bool ParseFmtpParam(const std::string& line, std::string* parameter,
                            std::string* value, SdpParseError* error);
 static bool ParseCandidate(const std::string& message, Candidate* candidate,
                            SdpParseError* error, bool is_raw);
@@ skipping 1343 matching lines @@
 }
 
 bool AddSctpDataCodec(DataContentDescription* media_desc,
                       int sctp_port) {
   if (media_desc->HasCodec(cricket::kGoogleSctpDataCodecId)) {
     return ParseFailed("",
                        "Can't have multiple sctp port attributes.",
                        NULL);
   }
   // Add the SCTP Port number as a pseudo-codec "port" parameter
-  cricket::DataCodec codec_port(
-      cricket::kGoogleSctpDataCodecId, cricket::kGoogleSctpDataCodecName,
-      0);
+  cricket::DataCodec codec_port(cricket::kGoogleSctpDataCodecId,
+                                cricket::kGoogleSctpDataCodecName);
   codec_port.SetParam(cricket::kCodecParamPort, sctp_port);
   LOG(INFO) << "AddSctpDataCodec: Got SCTP Port Number "
             << sctp_port;
   media_desc->AddCodec(codec_port);
   return true;
 }
 
 bool GetMinValue(const std::vector<int>& values, int* value) {
   if (values.empty()) {
     return false;
@@ skipping 505 matching lines @@
   { "DVI4", 11025, 1 },
   { "DVI4", 22050, 1 },
   { "G729", 8000, 1 },
 };
 
 void MaybeCreateStaticPayloadAudioCodecs(
     const std::vector<int>& fmts, AudioContentDescription* media_desc) {
   if (!media_desc) {
     return;
   }
-  int preference = static_cast<int>(fmts.size());
+  RTC_DCHECK(media_desc->codecs().empty());
   std::vector<int>::const_iterator it = fmts.begin();
-  bool add_new_codec = false;
   for (; it != fmts.end(); ++it) {
     int payload_type = *it;
     if (!media_desc->HasCodec(payload_type) &&
         payload_type >= 0 &&
         payload_type < arraysize(kStaticPayloadAudioCodecs)) {
       std::string encoding_name = kStaticPayloadAudioCodecs[payload_type].name;
       int clock_rate = kStaticPayloadAudioCodecs[payload_type].clockrate;
       size_t channels = kStaticPayloadAudioCodecs[payload_type].channels;
       media_desc->AddCodec(cricket::AudioCodec(payload_type, encoding_name,
-                                               clock_rate, 0, channels,
-                                               preference));
-      add_new_codec = true;
+                                               clock_rate, 0, channels));
     }
-    --preference;
-  }
-  if (add_new_codec) {
-    media_desc->SortCodecs();
   }
 }
 
 template <class C>
 static C* ParseContentDescription(const std::string& message,
                                   const MediaType media_type,
                                   int mline_index,
                                   const std::string& protocol,
-                                  const std::vector<int>& codec_preference,
+                                  const std::vector<int>& payload_types,
                                   size_t* pos,
                                   std::string* content_name,
                                   TransportDescription* transport,
                                   std::vector<JsepIceCandidate*>* candidates,
                                   webrtc::SdpParseError* error) {
   C* media_desc = new C();
   switch (media_type) {
     case cricket::MEDIA_TYPE_AUDIO:
       *content_name = cricket::CN_AUDIO;
       break;
     case cricket::MEDIA_TYPE_VIDEO:
       *content_name = cricket::CN_VIDEO;
       break;
     case cricket::MEDIA_TYPE_DATA:
       *content_name = cricket::CN_DATA;
       break;
     default:
       ASSERT(false);
       break;
   }
-  if (!ParseContent(message, media_type, mline_index, protocol,
-                    codec_preference, pos, content_name,
-                    media_desc, transport, candidates, error)) {
+  if (!ParseContent(message, media_type, mline_index, protocol, payload_types,
+                    pos, content_name, media_desc, transport, candidates,
+                    error)) {
     delete media_desc;
     return NULL;
   }
   // Sort the codecs according to the m-line fmt list.
-  media_desc->SortCodecs();
+  std::unordered_map<int, int> payload_type_preferences;
+  // "size + 1" so that the lowest preference payload type has a preference of
+  // 1, which is greater than the default (0) for payload types not in the fmt
+  // list.
+  int preference = static_cast<int>(payload_types.size() + 1);
+  for (int pt : payload_types) {
+    payload_type_preferences[pt] = preference--;
+  }
+  std::vector<typename C::CodecType> codecs = media_desc->codecs();
+  std::sort(codecs.begin(), codecs.end(), [&payload_type_preferences](
+                                              const typename C::CodecType& a,
+                                              const typename C::CodecType& b) {
+    return payload_type_preferences[a.id] > payload_type_preferences[b.id];
+  });
+  media_desc->set_codecs(codecs);
   return media_desc;
 }
 
 bool ParseMediaDescription(const std::string& message,
                            const TransportDescription& session_td,
                            const RtpHeaderExtensions& session_extmaps,
                            size_t* pos,
                            cricket::SessionDescription* desc,
                            std::vector<JsepIceCandidate*>* candidates,
                            SdpParseError* error) {
@@ skipping 18 matching lines @@
     // RFC 3264
     // To reject an offered stream, the port number in the corresponding stream
     // in the answer MUST be set to zero.
     if (fields[1] == kMediaPortRejected) {
       rejected = true;
     }
 
     std::string protocol = fields[2];
 
     // <fmt>
-    std::vector<int> codec_preference;
+    std::vector<int> payload_types;
     if (IsRtp(protocol)) {
       for (size_t j = 3 ; j < fields.size(); ++j) {
         // TODO(wu): Remove when below bug is fixed.
         // https://bugzilla.mozilla.org/show_bug.cgi?id=996329
         if (fields[j].empty() && j == fields.size() - 1) {
           continue;
         }
 
         int pl = 0;
         if (!GetPayloadTypeFromString(line, fields[j], &pl, error)) {
           return false;
         }
-        codec_preference.push_back(pl);
+        payload_types.push_back(pl);
       }
     }
 
     // Make a temporary TransportDescription based on |session_td|.
     // Some of this gets overwritten by ParseContent.
     TransportDescription transport(
         session_td.transport_options, session_td.ice_ufrag, session_td.ice_pwd,
         session_td.ice_mode, session_td.connection_role,
         session_td.identity_fingerprint.get());
 
     rtc::scoped_ptr<MediaContentDescription> content;
     std::string content_name;
     if (HasAttribute(line, kMediaTypeVideo)) {
       content.reset(ParseContentDescription<VideoContentDescription>(
-                    message, cricket::MEDIA_TYPE_VIDEO, mline_index, protocol,
-                    codec_preference, pos, &content_name,
-                    &transport, candidates, error));
+          message, cricket::MEDIA_TYPE_VIDEO, mline_index, protocol,
+          payload_types, pos, &content_name, &transport, candidates, error));
     } else if (HasAttribute(line, kMediaTypeAudio)) {
       content.reset(ParseContentDescription<AudioContentDescription>(
-                    message, cricket::MEDIA_TYPE_AUDIO, mline_index, protocol,
-                    codec_preference, pos, &content_name,
-                    &transport, candidates, error));
+          message, cricket::MEDIA_TYPE_AUDIO, mline_index, protocol,
+          payload_types, pos, &content_name, &transport, candidates, error));
     } else if (HasAttribute(line, kMediaTypeData)) {
       DataContentDescription* data_desc =
           ParseContentDescription<DataContentDescription>(
-                    message, cricket::MEDIA_TYPE_DATA, mline_index, protocol,
-                    codec_preference, pos, &content_name,
-                    &transport, candidates, error);
+              message, cricket::MEDIA_TYPE_DATA, mline_index, protocol,
+              payload_types, pos, &content_name, &transport, candidates, error);
       content.reset(data_desc);
 
       int p;
       if (data_desc && IsDtlsSctp(protocol) && rtc::FromString(fields[3], &p)) {
         if (!AddSctpDataCodec(data_desc, p))
           return false;
       }
     } else {
       LOG(LS_WARNING) << "Unsupported media type: " << line;
       continue;
@@ skipping 186 matching lines @@
        iter != codecs.end(); ++iter) {
     iter->params[name] = value;
   }
   audio_desc->set_codecs(codecs);
 }
 
 bool ParseContent(const std::string& message,
                   const MediaType media_type,
                   int mline_index,
                   const std::string& protocol,
-                  const std::vector<int>& codec_preference,
+                  const std::vector<int>& payload_types,
                   size_t* pos,
                   std::string* content_name,
                   MediaContentDescription* media_desc,
                   TransportDescription* transport,
                   std::vector<JsepIceCandidate*>* candidates,
                   SdpParseError* error) {
   ASSERT(media_desc != NULL);
   ASSERT(content_name != NULL);
   ASSERT(transport != NULL);
 
   if (media_type == cricket::MEDIA_TYPE_AUDIO) {
     MaybeCreateStaticPayloadAudioCodecs(
-        codec_preference, static_cast<AudioContentDescription*>(media_desc));
+        payload_types, static_cast<AudioContentDescription*>(media_desc));
   }
 
   // The media level "ice-ufrag" and "ice-pwd".
   // The candidates before update the media level "ice-pwd" and "ice-ufrag".
   Candidates candidates_orig;
   std::string line;
   std::string mline_id;
   // Tracks created out of the ssrc attributes.
   StreamParamsVec tracks;
   SsrcInfoVec ssrc_infos;
@@ skipping 114 matching lines @@
         }
       } else if (HasAttribute(line, kAttributeSsrc)) {
         if (!ParseSsrcAttribute(line, &ssrc_infos, error)) {
           return false;
         }
       } else if (HasAttribute(line, kAttributeCrypto)) {
         if (!ParseCryptoAttribute(line, media_desc, error)) {
           return false;
         }
       } else if (HasAttribute(line, kAttributeRtpmap)) {
-        if (!ParseRtpmapAttribute(line, media_type, codec_preference,
-                                  media_desc, error)) {
+        if (!ParseRtpmapAttribute(line, media_type, payload_types, media_desc,
+                                  error)) {
           return false;
         }
       } else if (HasAttribute(line, kCodecParamMaxPTime)) {
         if (!GetValue(line, kCodecParamMaxPTime, &maxptime_as_string, error)) {
           return false;
         }
       } else if (HasAttribute(line, kAttributeRtcpFb)) {
         if (!ParseRtcpFbAttribute(line, media_type, media_desc, error)) {
           return false;
         }
@@ skipping 235 matching lines @@
   std::string session_params;
   if (fields.size() > 3) {
     session_params = fields[3];
   }
   media_desc->AddCrypto(CryptoParams(tag, crypto_suite, key_params,
                                      session_params));
   return true;
 }
 
 // Updates or creates a new codec entry in the audio description with according
-// to |name|, |clockrate|, |bitrate|, |channels| and |preference|.
-void UpdateCodec(int payload_type, const std::string& name, int clockrate,
-                 int bitrate, size_t channels, int preference,
+// to |name|, |clockrate|, |bitrate|, and |channels|.
+void UpdateCodec(int payload_type,
+                 const std::string& name,
+                 int clockrate,
+                 int bitrate,
+                 size_t channels,
                  AudioContentDescription* audio_desc) {
   // Codec may already be populated with (only) optional parameters
   // (from an fmtp).
   cricket::AudioCodec codec =
       GetCodecWithPayloadType(audio_desc->codecs(), payload_type);
   codec.name = name;
   codec.clockrate = clockrate;
   codec.bitrate = bitrate;
   codec.channels = channels;
-  codec.preference = preference;
   AddOrReplaceCodec<AudioContentDescription, cricket::AudioCodec>(audio_desc,
                                                                   codec);
 }
 
 // Updates or creates a new codec entry in the video description according to
-// |name|, |width|, |height|, |framerate| and |preference|.
-void UpdateCodec(int payload_type, const std::string& name, int width,
-                 int height, int framerate, int preference,
+// |name|, |width|, |height|, and |framerate|.
+void UpdateCodec(int payload_type,
+                 const std::string& name,
+                 int width,
+                 int height,
+                 int framerate,
                  VideoContentDescription* video_desc) {
   // Codec may already be populated with (only) optional parameters
   // (from an fmtp).
   cricket::VideoCodec codec =
       GetCodecWithPayloadType(video_desc->codecs(), payload_type);
   codec.name = name;
   codec.width = width;
   codec.height = height;
   codec.framerate = framerate;
-  codec.preference = preference;
   AddOrReplaceCodec<VideoContentDescription, cricket::VideoCodec>(video_desc,
                                                                   codec);
 }
 
 bool ParseRtpmapAttribute(const std::string& line,
                           const MediaType media_type,
-                          const std::vector<int>& codec_preference,
+                          const std::vector<int>& payload_types,
                           MediaContentDescription* media_desc,
                           SdpParseError* error) {
   std::vector<std::string> fields;
   rtc::split(line.substr(kLinePrefixLength),
                    kSdpDelimiterSpace, &fields);
   // RFC 4566
   // a=rtpmap:<payload type> <encoding name>/<clock rate>[/<encodingparameters>]
   const size_t expected_min_fields = 2;
   if (fields.size() < expected_min_fields) {
     return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
   }
   std::string payload_type_value;
   if (!GetValue(fields[0], kAttributeRtpmap, &payload_type_value, error)) {
     return false;
   }
   int payload_type = 0;
   if (!GetPayloadTypeFromString(line, payload_type_value, &payload_type,
                                 error)) {
     return false;
   }
 
-  // Set the preference order depending on the order of the pl type in the
-  // <fmt> of the m-line.
-  const int preference = codec_preference.end() -
-      std::find(codec_preference.begin(), codec_preference.end(),
-                payload_type);
-  if (preference == 0) {
+  if (std::find(payload_types.begin(), payload_types.end(), payload_type) ==
+      payload_types.end()) {
     LOG(LS_WARNING) << "Ignore rtpmap line that did not appear in the "
                     << "<fmt> of the m-line: " << line;
     return true;
   }
   const std::string& encoder = fields[1];
   std::vector<std::string> codec_params;
   rtc::split(encoder, '/', &codec_params);
   // <encoding name>/<clock rate>[/<encodingparameters>]
   // 2 mandatory fields
   if (codec_params.size() < 2 || codec_params.size() > 3) {
     return ParseFailed(line,
                        "Expected format \"<encoding name>/<clock rate>"
                        "[/<encodingparameters>]\".",
                        error);
   }
   const std::string& encoding_name = codec_params[0];
   int clock_rate = 0;
   if (!GetValueFromString(line, codec_params[1], &clock_rate, error)) {
     return false;
   }
   if (media_type == cricket::MEDIA_TYPE_VIDEO) {
     VideoContentDescription* video_desc =
         static_cast<VideoContentDescription*>(media_desc);
     // TODO: We will send resolution in SDP. For now use
     // JsepSessionDescription::kMaxVideoCodecWidth and kMaxVideoCodecHeight.
     UpdateCodec(payload_type, encoding_name,
                 JsepSessionDescription::kMaxVideoCodecWidth,
                 JsepSessionDescription::kMaxVideoCodecHeight,
                 JsepSessionDescription::kDefaultVideoCodecFramerate,
-                preference, video_desc);
+                video_desc);
   } else if (media_type == cricket::MEDIA_TYPE_AUDIO) {
     // RFC 4566
     // For audio streams, <encoding parameters> indicates the number
     // of audio channels.  This parameter is OPTIONAL and may be
     // omitted if the number of channels is one, provided that no
     // additional parameters are needed.
     size_t channels = 1;
     if (codec_params.size() == 3) {
       if (!GetValueFromString(line, codec_params[2], &channels, error)) {
         return false;
       }
     }
     int bitrate = 0;
     // The default behavior for ISAC (bitrate == 0) in webrtcvoiceengine.cc
     // (specifically FindWebRtcCodec) is bandwidth-adaptive variable bitrate.
     // The bandwidth adaptation doesn't always work well, so this code
     // sets a fixed target bitrate instead.
     if (_stricmp(encoding_name.c_str(), kIsacCodecName) == 0) {
       if (clock_rate <= 16000) {
         bitrate = kIsacWbDefaultRate;
       } else {
         bitrate = kIsacSwbDefaultRate;
       }
     }
     AudioContentDescription* audio_desc =
         static_cast<AudioContentDescription*>(media_desc);
     UpdateCodec(payload_type, encoding_name, clock_rate, bitrate, channels,
-                preference, audio_desc);
+                audio_desc);
   } else if (media_type == cricket::MEDIA_TYPE_DATA) {
     DataContentDescription* data_desc =
         static_cast<DataContentDescription*>(media_desc);
-    data_desc->AddCodec(cricket::DataCodec(payload_type, encoding_name,
-                                           preference));
+    data_desc->AddCodec(cricket::DataCodec(payload_type, encoding_name));
   }
   return true;
 }
 
 bool ParseFmtpParam(const std::string& line, std::string* parameter,
                     std::string* value, SdpParseError* error) {
   if (!rtc::tokenize_first(line, kSdpDelimiterEqual, parameter, value)) {
     ParseFailed(line, "Unable to parse fmtp parameter. \'=\' missing.", error);
     return false;
   }
@@ skipping 100 matching lines @@
     UpdateCodec<AudioContentDescription, cricket::AudioCodec>(
         media_desc, payload_type, feedback_param);
   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
     UpdateCodec<VideoContentDescription, cricket::VideoCodec>(
         media_desc, payload_type, feedback_param);
   }
   return true;
 }
 
 }  // namespace webrtc