tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

audio_send_stream_tests.cc (8214B)

      1 /*
      2 *  Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
      3 *
      4 *  Use of this source code is governed by a BSD-style license
      5 *  that can be found in the LICENSE file in the root of the source
      6 *  tree. An additional intellectual property rights grant can be found
      7 *  in the file PATENTS.  All contributing project authors may
      8 *  be found in the AUTHORS file in the root of the source tree.
      9 */
     10 
     11 #include <cstddef>
     12 #include <cstdint>
     13 #include <string>
     14 #include <vector>
     15 
     16 #include "api/array_view.h"
     17 #include "api/rtp_headers.h"
     18 #include "api/rtp_parameters.h"
     19 #include "call/audio_receive_stream.h"
     20 #include "call/audio_send_stream.h"
     21 #include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
     22 #include "modules/rtp_rtcp/source/rtp_header_extensions.h"
     23 #include "modules/rtp_rtcp/source/rtp_packet.h"
     24 #include "rtc_base/logging.h"
     25 #include "test/call_test.h"
     26 #include "test/gtest.h"
     27 #include "test/rtcp_packet_parser.h"
     28 #include "test/rtp_rtcp_observer.h"
     29 #include "test/video_test_constants.h"
     30 
     31 namespace webrtc {
     32 namespace test {
     33 namespace {
     34 
     35 enum : int {  // The first valid value is 1.
     36  kAudioLevelExtensionId = 1,
     37  kTransportSequenceNumberExtensionId,
     38 };
     39 
     40 class AudioSendTest : public SendTest {
     41 public:
     42  AudioSendTest() : SendTest(VideoTestConstants::kDefaultTimeout) {}
     43 
     44  size_t GetNumVideoStreams() const override { return 0; }
     45  size_t GetNumAudioStreams() const override { return 1; }
     46  size_t GetNumFlexfecStreams() const override { return 0; }
     47 };
     48 }  // namespace
     49 
     50 using AudioSendStreamCallTest = CallTest;
     51 
     52 TEST_F(AudioSendStreamCallTest, SupportsCName) {
     53  static std::string kCName = "PjqatC14dGfbVwGPUOA9IH7RlsFDbWl4AhXEiDsBizo=";
     54  class CNameObserver : public AudioSendTest {
     55   public:
     56    CNameObserver() = default;
     57 
     58   private:
     59    Action OnSendRtcp(ArrayView<const uint8_t> packet) override {
     60      RtcpPacketParser parser;
     61      EXPECT_TRUE(parser.Parse(packet));
     62      if (parser.sdes()->num_packets() > 0) {
     63        EXPECT_EQ(1u, parser.sdes()->chunks().size());
     64        EXPECT_EQ(kCName, parser.sdes()->chunks()[0].cname);
     65 
     66        observation_complete_.Set();
     67      }
     68 
     69      return SEND_PACKET;
     70    }
     71 
     72    void ModifyAudioConfigs(AudioSendStream::Config* send_config,
     73                            std::vector<AudioReceiveStreamInterface::Config>*
     74                            /* receive_configs */) override {
     75      send_config->rtp.c_name = kCName;
     76    }
     77 
     78    void PerformTest() override {
     79      EXPECT_TRUE(Wait()) << "Timed out while waiting for RTCP with CNAME.";
     80    }
     81  } test;
     82 
     83  RunBaseTest(&test);
     84 }
     85 
     86 TEST_F(AudioSendStreamCallTest, NoExtensionsByDefault) {
     87  class NoExtensionsObserver : public AudioSendTest {
     88   public:
     89    NoExtensionsObserver() = default;
     90 
     91   private:
     92    Action OnSendRtp(ArrayView<const uint8_t> packet) override {
     93      RtpPacket rtp_packet;
     94      EXPECT_TRUE(rtp_packet.Parse(packet));  // rtp packet is valid.
     95      EXPECT_EQ(packet[0] & 0b0001'0000, 0);  // extension bit not set.
     96 
     97      observation_complete_.Set();
     98      return SEND_PACKET;
     99    }
    100 
    101    void ModifyAudioConfigs(AudioSendStream::Config* send_config,
    102                            std::vector<AudioReceiveStreamInterface::Config>*
    103                            /* receive_configs */) override {
    104      send_config->rtp.extensions.clear();
    105    }
    106 
    107    void PerformTest() override {
    108      EXPECT_TRUE(Wait()) << "Timed out while waiting for a single RTP packet.";
    109    }
    110  } test;
    111 
    112  RunBaseTest(&test);
    113 }
    114 
    115 TEST_F(AudioSendStreamCallTest, SupportsAudioLevel) {
    116  class AudioLevelObserver : public AudioSendTest {
    117   public:
    118    AudioLevelObserver() : AudioSendTest() {
    119      extensions_.Register<AudioLevelExtension>(kAudioLevelExtensionId);
    120    }
    121 
    122    Action OnSendRtp(ArrayView<const uint8_t> packet) override {
    123      RtpPacket rtp_packet(&extensions_);
    124      EXPECT_TRUE(rtp_packet.Parse(packet));
    125 
    126      AudioLevel audio_level;
    127      EXPECT_TRUE(rtp_packet.GetExtension<AudioLevelExtension>(&audio_level));
    128      if (audio_level.level() != 0) {
    129        // Wait for at least one packet with a non-zero level.
    130        observation_complete_.Set();
    131      } else {
    132        RTC_LOG(LS_WARNING) << "Got a packet with zero audioLevel - waiting"
    133                               " for another packet...";
    134      }
    135 
    136      return SEND_PACKET;
    137    }
    138 
    139    void ModifyAudioConfigs(AudioSendStream::Config* send_config,
    140                            std::vector<AudioReceiveStreamInterface::Config>*
    141                            /* receive_configs */) override {
    142      send_config->rtp.extensions.clear();
    143      send_config->rtp.extensions.push_back(
    144          RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelExtensionId));
    145    }
    146 
    147    void PerformTest() override {
    148      EXPECT_TRUE(Wait()) << "Timed out while waiting for single RTP packet.";
    149    }
    150 
    151   private:
    152    RtpHeaderExtensionMap extensions_;
    153  } test;
    154 
    155  RunBaseTest(&test);
    156 }
    157 
    158 class TransportWideSequenceNumberObserver : public AudioSendTest {
    159 public:
    160  explicit TransportWideSequenceNumberObserver(bool expect_sequence_number)
    161      : AudioSendTest(), expect_sequence_number_(expect_sequence_number) {
    162    extensions_.Register<TransportSequenceNumber>(
    163        kTransportSequenceNumberExtensionId);
    164  }
    165 
    166 private:
    167  Action OnSendRtp(ArrayView<const uint8_t> packet) override {
    168    RtpPacket rtp_packet(&extensions_);
    169    EXPECT_TRUE(rtp_packet.Parse(packet));
    170 
    171    EXPECT_EQ(rtp_packet.HasExtension<TransportSequenceNumber>(),
    172              expect_sequence_number_);
    173    EXPECT_FALSE(rtp_packet.HasExtension<TransmissionOffset>());
    174    EXPECT_FALSE(rtp_packet.HasExtension<AbsoluteSendTime>());
    175 
    176    observation_complete_.Set();
    177 
    178    return SEND_PACKET;
    179  }
    180 
    181  void ModifyAudioConfigs(AudioSendStream::Config* send_config,
    182                          std::vector<AudioReceiveStreamInterface::Config>*
    183                          /* receive_configs */) override {
    184    send_config->rtp.extensions.clear();
    185    send_config->rtp.extensions.push_back(
    186        RtpExtension(RtpExtension::kTransportSequenceNumberUri,
    187                     kTransportSequenceNumberExtensionId));
    188  }
    189 
    190  void PerformTest() override {
    191    EXPECT_TRUE(Wait()) << "Timed out while waiting for a single RTP packet.";
    192  }
    193  const bool expect_sequence_number_;
    194  RtpHeaderExtensionMap extensions_;
    195 };
    196 
    197 TEST_F(AudioSendStreamCallTest, SendsTransportWideSequenceNumbersInFieldTrial) {
    198  TransportWideSequenceNumberObserver test(/*expect_sequence_number=*/true);
    199  RunBaseTest(&test);
    200 }
    201 
    202 TEST_F(AudioSendStreamCallTest, SendDtmf) {
    203  static const uint8_t kDtmfPayloadType = 120;
    204  static const int kDtmfPayloadFrequency = 8000;
    205  static const int kDtmfEventFirst = 12;
    206  static const int kDtmfEventLast = 31;
    207  static const int kDtmfDuration = 50;
    208  class DtmfObserver : public AudioSendTest {
    209   public:
    210    DtmfObserver() = default;
    211 
    212   private:
    213    Action OnSendRtp(ArrayView<const uint8_t> packet) override {
    214      RtpPacket rtp_packet;
    215      EXPECT_TRUE(rtp_packet.Parse(packet));
    216 
    217      if (rtp_packet.PayloadType() == kDtmfPayloadType) {
    218        EXPECT_EQ(rtp_packet.headers_size(), 12u);
    219        EXPECT_EQ(rtp_packet.size(), 16u);
    220        const int event = rtp_packet.payload()[0];
    221        if (event != expected_dtmf_event_) {
    222          ++expected_dtmf_event_;
    223          EXPECT_EQ(event, expected_dtmf_event_);
    224          if (expected_dtmf_event_ == kDtmfEventLast) {
    225            observation_complete_.Set();
    226          }
    227        }
    228      }
    229 
    230      return SEND_PACKET;
    231    }
    232 
    233    void OnAudioStreamsCreated(AudioSendStream* send_stream,
    234                               const std::vector<AudioReceiveStreamInterface*>&
    235                               /* receive_streams */) override {
    236      // Need to start stream here, else DTMF events are dropped.
    237      send_stream->Start();
    238      for (int event = kDtmfEventFirst; event <= kDtmfEventLast; ++event) {
    239        send_stream->SendTelephoneEvent(kDtmfPayloadType, kDtmfPayloadFrequency,
    240                                        event, kDtmfDuration);
    241      }
    242    }
    243 
    244    void PerformTest() override {
    245      EXPECT_TRUE(Wait()) << "Timed out while waiting for DTMF stream.";
    246    }
    247 
    248    int expected_dtmf_event_ = kDtmfEventFirst;
    249  } test;
    250 
    251  RunBaseTest(&test);
    252 }
    253 
    254 }  // namespace test
    255 }  // namespace webrtc