Initial asymmetric codec support in MediaSessionDescription

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.
  */
 
@@ skipping 32 matching lines @@
   func(&crypto_suites);
   for (const auto crypto : crypto_suites) {
     names->push_back(rtc::SrtpCryptoSuiteToName(crypto));
   }
 #endif
 }
 }  // namespace
 
 namespace cricket {
 
-
 // RTP Profile names
 // http://www.iana.org/assignments/rtp-parameters/rtp-parameters.xml
 // RFC4585
 const char kMediaProtocolAvpf[] = "RTP/AVPF";
 // RFC5124
 const char kMediaProtocolDtlsSavpf[] = "UDP/TLS/RTP/SAVPF";
 
 // We always generate offers with "UDP/TLS/RTP/SAVPF" when using DTLS-SRTP,
 // but we tolerate "RTP/SAVPF" in offers we receive, for compatibility.
 const char kMediaProtocolSavpf[] = "RTP/SAVPF";
 
 const char kMediaProtocolRtpPrefix[] = "RTP/";
 
 const char kMediaProtocolSctp[] = "SCTP";
 const char kMediaProtocolDtlsSctp[] = "DTLS/SCTP";
 const char kMediaProtocolUdpDtlsSctp[] = "UDP/DTLS/SCTP";
 const char kMediaProtocolTcpDtlsSctp[] = "TCP/DTLS/SCTP";
 
+RtpTransceiverDirection RtpTransceiverDirection::FromMediaContentDirection(
+    MediaContentDirection md) {
+  const bool send = (md == MD_SENDRECV || md == MD_SENDONLY);
+  const bool recv = (md == MD_SENDRECV || md == MD_RECVONLY);
+  return RtpTransceiverDirection(send, recv);
+}
+
+MediaContentDirection RtpTransceiverDirection::ToMediaContentDirection() const {
+  if (send && recv) {
+    return MD_SENDRECV;
+  } else if (send) {
+    return MD_SENDONLY;
+  } else if (recv) {
+    return MD_RECVONLY;
+  }
+
+  return MD_INACTIVE;
+}
+
+RtpTransceiverDirection
+NegotiateRtpTransceiverDirection(RtpTransceiverDirection offer,
+                                 RtpTransceiverDirection wants) {
+  return RtpTransceiverDirection(offer.recv && wants.send,
+                                 offer.send && wants.recv);
+}
+
 static bool IsMediaContentOfType(const ContentInfo* content,
                                  MediaType media_type) {
   if (!IsMediaContent(content)) {
     return false;
   }
 
   const MediaContentDescription* mdesc =
       static_cast<const MediaContentDescription*>(content->description);
   return mdesc && mdesc->type() == media_type;
 }
@@ skipping 678 matching lines @@
       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;

[ossu, 2016/06/10 13:15:19]

Essentially I added this because it broke my SetAudioCodecs test. However, I
think it makes sense in general: if the offer spells the codec one way, and
we're able to understand that, why not use the same spelling as in the offer,
rather than correct it. It seems rude! :) (and could possibly confuse the other
side, if it's implemented poorly).

       negotiated_codecs->push_back(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) {
@@ skipping 243 matching lines @@
     return false;
   }
 
   if (!AddStreamParams(answer->type(), options, current_streams, answer,
                        add_legacy_stream)) {
     return false;  // Something went seriously wrong.
   }
 
   // Make sure the answer media content direction is per default set as
   // described in RFC3264 section 6.1.
-  switch (offer->direction()) {
-    case MD_INACTIVE:
-      answer->set_direction(MD_INACTIVE);
-      break;
-    case MD_SENDONLY:
-      answer->set_direction(MD_RECVONLY);
-      break;
-    case MD_RECVONLY:
-      answer->set_direction(IsRtpProtocol(answer->protocol()) &&
-                                    answer->streams().empty()
-                                ? MD_INACTIVE
-                                : MD_SENDONLY);
-      break;
-    case MD_SENDRECV:
-      answer->set_direction(IsRtpProtocol(answer->protocol()) &&
-                                    answer->streams().empty()
-                                ? MD_RECVONLY
-                                : MD_SENDRECV);
-      break;
-    default:
-      RTC_DCHECK(false && "MediaContentDescription has unexpected direction.");
-      break;
-  }
+  const bool is_data = !IsRtpProtocol(answer->protocol());
+  const bool has_send_streams = !answer->streams().empty();
+  const bool wants_send = has_send_streams || is_data;
+  const bool recv_audio =
+      answer->type() == cricket::MEDIA_TYPE_AUDIO && options.recv_audio;
+  const bool recv_video =
+      answer->type() == cricket::MEDIA_TYPE_VIDEO && options.recv_video;
+  const bool recv_data =
+      answer->type() == cricket::MEDIA_TYPE_DATA;
+  const bool wants_receive = recv_audio || recv_video || recv_data;
 
+  auto offer_rtd =
+      RtpTransceiverDirection::FromMediaContentDirection(offer->direction());
+  auto wants_rtd = RtpTransceiverDirection(wants_send, wants_receive);
+  answer->set_direction(NegotiateRtpTransceiverDirection(offer_rtd, wants_rtd)
+                        .ToMediaContentDirection());
   return true;
 }
 
 static bool IsDtlsRtp(const std::string& protocol) {
   // Most-likely values first.
   return protocol == "UDP/TLS/RTP/SAVPF" || protocol == "TCP/TLS/RTP/SAVPF" ||
          protocol == "UDP/TLS/RTP/SAVP" || protocol == "TCP/TLS/RTP/SAVP";
 }
 
 static bool IsPlainRtp(const std::string& protocol) {
@@ skipping 99 matching lines @@
     case MEDIA_TYPE_DATA:
       type_str = "data";
       break;
     default:
       ASSERT(false);
       break;
   }
   return type_str;
 }
 
+std::string MediaContentDirectionToString(MediaContentDirection direction) {
+  std::string dir_str;
+  switch (direction) {
+    case MD_INACTIVE:
+      dir_str = "inactive";
+      break;
+    case MD_SENDONLY:
+      dir_str = "sendonly";
+      break;
+    case MD_RECVONLY:
+      dir_str = "recvonly";
+      break;
+    case MD_SENDRECV:
+      dir_str = "sendrecv";
+      break;
+    default:
+      ASSERT(false);
+      break;
+  }
+
+  return dir_str;
+}
+
 void MediaSessionOptions::AddSendStream(MediaType type,
                                     const std::string& id,
                                     const std::string& sync_label) {
   AddSendStreamInternal(type, id, sync_label, 1);
 }
 
 void MediaSessionOptions::AddSendVideoStream(
     const std::string& id,
     const std::string& sync_label,
     int num_sim_layers) {
@@ skipping 41 matching lines @@
       add_legacy_(true),
       transport_desc_factory_(transport_desc_factory) {
 }
 
 MediaSessionDescriptionFactory::MediaSessionDescriptionFactory(
     ChannelManager* channel_manager,
     const TransportDescriptionFactory* transport_desc_factory)
     : secure_(SEC_DISABLED),
       add_legacy_(true),
       transport_desc_factory_(transport_desc_factory) {
-  channel_manager->GetSupportedAudioCodecs(&audio_codecs_);
+  channel_manager->GetSupportedAudioCodecs(&audio_sendrecv_codecs_);
   channel_manager->GetSupportedAudioRtpHeaderExtensions(&audio_rtp_extensions_);
   channel_manager->GetSupportedVideoCodecs(&video_codecs_);
   channel_manager->GetSupportedVideoRtpHeaderExtensions(&video_rtp_extensions_);
   channel_manager->GetSupportedDataCodecs(&data_codecs_);
+  audio_send_codecs_ = audio_sendrecv_codecs_;
+  audio_recv_codecs_ = audio_sendrecv_codecs_;
+}
+
+const AudioCodecs& MediaSessionDescriptionFactory::audio_codecs() const {
+  return audio_sendrecv_codecs_;
+}
+
+const AudioCodecs& MediaSessionDescriptionFactory::audio_send_codecs() const {
+  return audio_send_codecs_;
+}
+
+const AudioCodecs& MediaSessionDescriptionFactory::audio_recv_codecs() const {
+  return audio_recv_codecs_;
+}
+
+void MediaSessionDescriptionFactory::set_audio_codecs(
+    const AudioCodecs& send_codecs, const AudioCodecs& recv_codecs) {
+  audio_send_codecs_ = send_codecs;
+  audio_recv_codecs_ = recv_codecs;
+  audio_sendrecv_codecs_.clear();
+  // Use NegotiateCodecs to merge our codec lists, since the operation is
+  // essentially the same. Put send_codecs as the offered_codecs, which is the
+  // order we'd like to follow. The reasoning is that encoding is usually more
+  // expensive than decoding, and prioritizing a codec in the send list probably
+  // means it's a codec we can handle efficiently.
+  NegotiateCodecs(recv_codecs, send_codecs, &audio_sendrecv_codecs_);

[ossu, 2016/06/10 13:15:19]

I repurposed NegotiateCodecs to merge these codecs lists as well. The operation
is exactly the same, as far as I can see.

 }
 
 SessionDescription* MediaSessionDescriptionFactory::CreateOffer(
     const MediaSessionOptions& options,
     const SessionDescription* current_description) const {
   std::unique_ptr<SessionDescription> offer(new SessionDescription());
 
   StreamParamsVec current_streams;
   GetCurrentStreamParams(current_description, &current_streams);
 
+  const bool wants_send =
+      options.HasSendMediaStream(MEDIA_TYPE_AUDIO) || add_legacy_;
+  const AudioCodecs& supported_audio_codecs =
+      GetAudioCodecsForOffer({wants_send, options.recv_audio});
+
   AudioCodecs audio_codecs;
   VideoCodecs video_codecs;
   DataCodecs data_codecs;
-  GetCodecsToOffer(current_description, &audio_codecs, &video_codecs,
-                   &data_codecs);
+  GetCodecsToOffer(current_description, supported_audio_codecs,
+                   video_codecs_, data_codecs_,
+                   &audio_codecs, &video_codecs, &data_codecs);
 
   if (!options.vad_enabled) {
     // If application doesn't want CN codecs in offer.
     StripCNCodecs(&audio_codecs);
   }
 
   RtpHeaderExtensions audio_rtp_extensions;
   RtpHeaderExtensions video_rtp_extensions;
   GetRtpHdrExtsToOffer(current_description, &audio_rtp_extensions,
                        &video_rtp_extensions);
@@ skipping 138 matching lines @@
       if (!UpdateCryptoParamsForBundle(answer_bundle, answer.get())) {
         LOG(LS_ERROR) << "CreateAnswer failed to UpdateCryptoParamsForBundle.";
         return NULL;
       }
     }
   }
 
   return answer.release();
 }
 
+const AudioCodecs& MediaSessionDescriptionFactory::GetAudioCodecsForOffer(
+    const RtpTransceiverDirection& direction) const {
+  // If stream is inactive - generate list as if sendrecv.
+  if (direction.send == direction.recv) {
+    return audio_sendrecv_codecs_;
+  } else if (direction.send) {
+    return audio_send_codecs_;
+  } else {
+    return audio_recv_codecs_;
+  }
+}
+
+const AudioCodecs& MediaSessionDescriptionFactory::GetAudioCodecsForAnswer(
+    const RtpTransceiverDirection& offer,
+    const RtpTransceiverDirection& answer) const {
+  // For inactive and sendrecv answers, generate lists as if we were to accept
+  // the offer's direction. See RFC 3264 Section 6.1.
+  if (answer.send == answer.recv) {
+    if (offer.send == offer.recv) {
+      return audio_sendrecv_codecs_;
+    } else if (offer.send) {
+      return audio_recv_codecs_;
+    } else {
+      return audio_send_codecs_;
+    }
+  } else if (answer.send) {
+    return audio_send_codecs_;
+  } else {
+    return audio_recv_codecs_;
+  }
+}
+
 void MediaSessionDescriptionFactory::GetCodecsToOffer(
     const SessionDescription* current_description,
+    const AudioCodecs& supported_audio_codecs,
+    const VideoCodecs& supported_video_codecs,
+    const DataCodecs& supported_data_codecs,
     AudioCodecs* audio_codecs,
     VideoCodecs* video_codecs,
     DataCodecs* data_codecs) const {
   UsedPayloadTypes used_pltypes;
   audio_codecs->clear();
   video_codecs->clear();
   data_codecs->clear();
 
 
   // First - get all codecs from the current description if the media type
@@ skipping 15 matching lines @@
     }
     const DataContentDescription* data =
         GetFirstDataContentDescription(current_description);
     if (data) {
       *data_codecs = data->codecs();
       used_pltypes.FindAndSetIdUsed<DataCodec>(data_codecs);
     }
   }
 
   // Add our codecs that are not in |current_description|.
-  FindCodecsToOffer<AudioCodec>(audio_codecs_, audio_codecs, &used_pltypes);
-  FindCodecsToOffer<VideoCodec>(video_codecs_, video_codecs, &used_pltypes);
-  FindCodecsToOffer<DataCodec>(data_codecs_, data_codecs, &used_pltypes);
+  FindCodecsToOffer<AudioCodec>(supported_audio_codecs, audio_codecs,
+                                &used_pltypes);
+  FindCodecsToOffer<VideoCodec>(supported_video_codecs, video_codecs,
+                                &used_pltypes);
+  FindCodecsToOffer<DataCodec>(supported_data_codecs, data_codecs,
+                               &used_pltypes);
 }
 
 void MediaSessionDescriptionFactory::GetRtpHdrExtsToOffer(
     const SessionDescription* current_description,
     RtpHeaderExtensions* audio_extensions,
     RtpHeaderExtensions* video_extensions) const {
   // All header extensions allocated from the same range to avoid potential
   // issues when using BUNDLE.
   UsedRtpHeaderExtensionIds used_ids;
   RtpHeaderExtensions all_extensions;
@@ skipping 105 matching lines @@
           add_legacy_,
           current_streams,
           audio.get())) {
     return false;
   }
   audio->set_lang(lang_);
 
   bool secure_transport = (transport_desc_factory_->secure() != SEC_DISABLED);
   SetMediaProtocol(secure_transport, audio.get());
 
-  if (!audio->streams().empty()) {
-    if (options.recv_audio) {
-      audio->set_direction(MD_SENDRECV);
-    } else {
-      audio->set_direction(MD_SENDONLY);
-    }
-  } else {
-    if (options.recv_audio) {
-      audio->set_direction(MD_RECVONLY);
-    } else {
-      audio->set_direction(MD_INACTIVE);
-    }
-  }
+  auto offer_rtd =
+      RtpTransceiverDirection(!audio->streams().empty(), options.recv_audio);
+  audio->set_direction(offer_rtd.ToMediaContentDirection());
 
   desc->AddContent(content_name, NS_JINGLE_RTP, audio.release());
   if (!AddTransportOffer(content_name,
                          GetTransportOptions(options, content_name),
                          current_description, desc)) {
     return false;
   }
 
   return true;
 }
@@ skipping 123 matching lines @@
   return true;
 }
 
 bool MediaSessionDescriptionFactory::AddAudioContentForAnswer(
     const SessionDescription* offer,
     const MediaSessionOptions& options,
     const SessionDescription* current_description,
     StreamParamsVec* current_streams,
     SessionDescription* answer) const {
   const ContentInfo* audio_content = GetFirstAudioContent(offer);
+  const AudioContentDescription* offer_audio =
+      static_cast<const AudioContentDescription*>(audio_content->description);
 
   std::unique_ptr<TransportDescription> audio_transport(CreateTransportAnswer(
       audio_content->name, offer,
       GetTransportOptions(options, audio_content->name), current_description));
   if (!audio_transport) {
     return false;
   }
 
-  AudioCodecs audio_codecs = audio_codecs_;
+  // Pick codecs based on the requested communications direction in the offer.
+  const bool wants_send =
+      options.HasSendMediaStream(MEDIA_TYPE_AUDIO) || add_legacy_;
+  auto wants_rtd = RtpTransceiverDirection(wants_send, options.recv_audio);
+  auto offer_rtd =
+      RtpTransceiverDirection::FromMediaContentDirection(
+          offer_audio->direction());
+  auto answer_rtd = NegotiateRtpTransceiverDirection(offer_rtd, wants_rtd);
+  AudioCodecs audio_codecs = GetAudioCodecsForAnswer(offer_rtd, answer_rtd);
   if (!options.vad_enabled) {
     StripCNCodecs(&audio_codecs);
   }
 
   bool bundle_enabled =
       offer->HasGroup(GROUP_TYPE_BUNDLE) && options.bundle_enabled;
   std::unique_ptr<AudioContentDescription> audio_answer(
       new AudioContentDescription());
   // Do not require or create SDES cryptos if DTLS is used.
   cricket::SecurePolicy sdes_policy =
       audio_transport->secure() ? cricket::SEC_DISABLED : secure();
   if (!CreateMediaContentAnswer(
-          static_cast<const AudioContentDescription*>(
-              audio_content->description),
+          offer_audio,
           options,
           audio_codecs,
           sdes_policy,
           GetCryptos(GetFirstAudioContentDescription(current_description)),
           audio_rtp_extensions_,
           current_streams,
           add_legacy_,
           bundle_enabled,
           audio_answer.get())) {
     return false;  // Fails the session setup.
@@ skipping 211 matching lines @@
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_VIDEO));
 }
 
 const DataContentDescription* GetFirstDataContentDescription(
     const SessionDescription* sdesc) {
   return static_cast<const DataContentDescription*>(
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_DATA));
 }
 
 }  // namespace cricket