Add header extension filtering for WebRtcVoiceEngine/MediaChannel.

talk/media/webrtc/webrtcvoiceengine.cc

 /*
  * libjingle
  * Copyright 2004 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 24 matching lines @@
 
 #include <algorithm>
 #include <cstdio>
 #include <string>
 #include <vector>
 
 #include "talk/media/base/audioframe.h"
 #include "talk/media/base/audiorenderer.h"
 #include "talk/media/base/constants.h"
 #include "talk/media/base/streamparams.h"
+#include "talk/media/webrtc/webrtcmediaengine.h"
 #include "talk/media/webrtc/webrtcvoe.h"
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/base64.h"
 #include "webrtc/base/byteorder.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/call/rtc_event_log.h"
@@ skipping 234 matching lines @@
   options.aec_dump = rtc::Optional<bool>(false);
   return options;
 }
 
 webrtc::AudioState::Config MakeAudioStateConfig(VoEWrapper* voe_wrapper) {
   webrtc::AudioState::Config config;
   config.voice_engine = voe_wrapper->engine();
   return config;
 }
 
-std::vector<webrtc::RtpExtension> FindAudioRtpHeaderExtensions(
-    const std::vector<RtpHeaderExtension>& extensions) {
-  std::vector<webrtc::RtpExtension> result;
-  for (const auto& extension : extensions) {
-    if (extension.uri == kRtpAbsoluteSenderTimeHeaderExtension ||
-        extension.uri == kRtpAudioLevelHeaderExtension) {
-      result.push_back({extension.uri, extension.id});
-    } else {
-      LOG(LS_WARNING) << "Unsupported RTP extension: " << extension.ToString();
-    }
-  }
-  return result;
-}
-
 class WebRtcVoiceCodecs final {
  public:
   // TODO(solenberg): Do this filtering once off-line, add a simple AudioCodec
   // list and add a test which verifies VoE supports the listed codecs.
   static std::vector<AudioCodec> SupportedCodecs() {
     LOG(LS_INFO) << "WebRtc VoiceEngine codecs:";
     std::vector<AudioCodec> result;
     for (webrtc::CodecInst voe_codec : webrtc::acm2::RentACodec::Database()) {
       // Change the sample rate of G722 to 8000 to match SDP.
       MaybeFixupG722(&voe_codec, 8000);
@@ skipping 1137 matching lines @@
 bool WebRtcVoiceMediaChannel::SetSendParameters(
     const AudioSendParameters& params) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   // TODO(pthatcher): Refactor this to be more clean now that we have
   // all the information at once.
 
   if (!SetSendCodecs(params.codecs)) {
     return false;
   }
 
-  std::vector<webrtc::RtpExtension> send_rtp_extensions =
-      FindAudioRtpHeaderExtensions(params.extensions);
-  if (send_rtp_extensions_ != send_rtp_extensions) {
-    send_rtp_extensions_.swap(send_rtp_extensions);
+  if (!ValidateRtpExtensions(params.extensions)) {
+    return false;
+  }
+  std::vector<webrtc::RtpExtension> filtered_extensions =
+      FilterRtpExtensions(params.extensions,
+                          webrtc::RtpExtension::IsSupportedForAudio, true);
+  if (send_rtp_extensions_ != filtered_extensions) {
+    send_rtp_extensions_.swap(filtered_extensions);
     for (auto& it : send_streams_) {
       it.second->RecreateAudioSendStream(send_rtp_extensions_);
     }
   }
 
   if (!SetMaxSendBandwidth(params.max_bandwidth_bps)) {
     return false;
   }
   return SetOptions(params.options);
 }
 
 bool WebRtcVoiceMediaChannel::SetRecvParameters(
     const AudioRecvParameters& params) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   // TODO(pthatcher): Refactor this to be more clean now that we have
   // all the information at once.
 
   if (!SetRecvCodecs(params.codecs)) {
     return false;
   }
 
-  std::vector<webrtc::RtpExtension> recv_rtp_extensions =
-      FindAudioRtpHeaderExtensions(params.extensions);
-  if (recv_rtp_extensions_ != recv_rtp_extensions) {
-    recv_rtp_extensions_.swap(recv_rtp_extensions);
+  if (!ValidateRtpExtensions(params.extensions)) {
+    return false;
+  }
+  std::vector<webrtc::RtpExtension> filtered_extensions =
+      FilterRtpExtensions(params.extensions,
+                          webrtc::RtpExtension::IsSupportedForAudio, false);
+  if (recv_rtp_extensions_ != filtered_extensions) {
+    recv_rtp_extensions_.swap(filtered_extensions);
     for (auto& it : recv_streams_) {
       it.second->RecreateAudioReceiveStream(recv_rtp_extensions_);
     }
   }
 
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetOptions(const AudioOptions& options) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
@@ skipping 1153 matching lines @@
     }
   } else {
     LOG(LS_INFO) << "Stopping playout for channel #" << channel;
     engine()->voe()->base()->StopPlayout(channel);
   }
   return true;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE