OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "media/cast/sender/audio_sender.h" | 5 #include "media/cast/sender/audio_sender.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 #include <utility> | 8 #include <utility> |
9 | 9 |
10 #include "base/bind.h" | 10 #include "base/bind.h" |
(...skipping 17 matching lines...) Expand all Loading... |
28 | 28 |
29 namespace { | 29 namespace { |
30 | 30 |
31 void SaveOperationalStatus(OperationalStatus* out_status, | 31 void SaveOperationalStatus(OperationalStatus* out_status, |
32 OperationalStatus in_status) { | 32 OperationalStatus in_status) { |
33 DVLOG(1) << "OperationalStatus transitioning from " << *out_status << " to " | 33 DVLOG(1) << "OperationalStatus transitioning from " << *out_status << " to " |
34 << in_status; | 34 << in_status; |
35 *out_status = in_status; | 35 *out_status = in_status; |
36 } | 36 } |
37 | 37 |
| 38 class TransportClient : public CastTransportSender::Client { |
| 39 public: |
| 40 TransportClient() {} |
| 41 |
| 42 void OnStatusChanged(CastTransportStatus status) final { |
| 43 EXPECT_EQ(TRANSPORT_AUDIO_INITIALIZED, status); |
| 44 }; |
| 45 void OnLoggingEventsReceived( |
| 46 scoped_ptr<std::vector<FrameEvent>> frame_events, |
| 47 scoped_ptr<std::vector<PacketEvent>> packet_events) final{}; |
| 48 void ProcessRtpPacket(scoped_ptr<Packet> packet) final{}; |
| 49 |
| 50 DISALLOW_COPY_AND_ASSIGN(TransportClient); |
| 51 }; |
| 52 |
38 } // namespace | 53 } // namespace |
39 | 54 |
40 class TestPacketSender : public PacketSender { | 55 class TestPacketSender : public PacketSender { |
41 public: | 56 public: |
42 TestPacketSender() : number_of_rtp_packets_(0), number_of_rtcp_packets_(0) {} | 57 TestPacketSender() : number_of_rtp_packets_(0), number_of_rtcp_packets_(0) {} |
43 | 58 |
44 bool SendPacket(PacketRef packet, const base::Closure& cb) final { | 59 bool SendPacket(PacketRef packet, const base::Closure& cb) final { |
45 if (IsRtcpPacket(&packet->data[0], packet->data.size())) { | 60 if (IsRtcpPacket(&packet->data[0], packet->data.size())) { |
46 ++number_of_rtcp_packets_; | 61 ++number_of_rtcp_packets_; |
47 } else { | 62 } else { |
48 // Check that at least one RTCP packet was sent before the first RTP | 63 // Check that at least one RTCP packet was sent before the first RTP |
49 // packet. This confirms that the receiver will have the necessary lip | 64 // packet. This confirms that the receiver will have the necessary lip |
50 // sync info before it has to calculate the playout time of the first | 65 // sync info before it has to calculate the playout time of the first |
51 // frame. | 66 // frame. |
52 if (number_of_rtp_packets_ == 0) | 67 if (number_of_rtp_packets_ == 0) |
53 EXPECT_LE(1, number_of_rtcp_packets_); | 68 EXPECT_LE(1, number_of_rtcp_packets_); |
54 ++number_of_rtp_packets_; | 69 ++number_of_rtp_packets_; |
55 } | 70 } |
56 return true; | 71 return true; |
57 } | 72 } |
58 | 73 |
59 int64_t GetBytesSent() final { return 0; } | 74 int64_t GetBytesSent() final { return 0; } |
60 | 75 |
| 76 void StartReceiving( |
| 77 const PacketReceiverCallbackWithStatus& packet_receiver) final {} |
| 78 |
| 79 void StopReceiving() final {} |
| 80 |
61 int number_of_rtp_packets() const { return number_of_rtp_packets_; } | 81 int number_of_rtp_packets() const { return number_of_rtp_packets_; } |
62 | 82 |
63 int number_of_rtcp_packets() const { return number_of_rtcp_packets_; } | 83 int number_of_rtcp_packets() const { return number_of_rtcp_packets_; } |
64 | 84 |
65 private: | 85 private: |
66 int number_of_rtp_packets_; | 86 int number_of_rtp_packets_; |
67 int number_of_rtcp_packets_; | 87 int number_of_rtcp_packets_; |
68 | 88 |
69 DISALLOW_COPY_AND_ASSIGN(TestPacketSender); | 89 DISALLOW_COPY_AND_ASSIGN(TestPacketSender); |
70 }; | 90 }; |
71 | 91 |
72 class AudioSenderTest : public ::testing::Test { | 92 class AudioSenderTest : public ::testing::Test { |
73 protected: | 93 protected: |
74 AudioSenderTest() { | 94 AudioSenderTest() { |
75 InitializeMediaLibrary(); | 95 InitializeMediaLibrary(); |
76 testing_clock_ = new base::SimpleTestTickClock(); | 96 testing_clock_ = new base::SimpleTestTickClock(); |
77 testing_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks()); | 97 testing_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks()); |
78 task_runner_ = new test::FakeSingleThreadTaskRunner(testing_clock_); | 98 task_runner_ = new test::FakeSingleThreadTaskRunner(testing_clock_); |
79 cast_environment_ = | 99 cast_environment_ = |
80 new CastEnvironment(scoped_ptr<base::TickClock>(testing_clock_), | 100 new CastEnvironment(scoped_ptr<base::TickClock>(testing_clock_), |
81 task_runner_, task_runner_, task_runner_); | 101 task_runner_, task_runner_, task_runner_); |
82 audio_config_.codec = CODEC_AUDIO_OPUS; | 102 audio_config_.codec = CODEC_AUDIO_OPUS; |
83 audio_config_.use_external_encoder = false; | 103 audio_config_.use_external_encoder = false; |
84 audio_config_.frequency = kDefaultAudioSamplingRate; | 104 audio_config_.frequency = kDefaultAudioSamplingRate; |
85 audio_config_.channels = 2; | 105 audio_config_.channels = 2; |
86 audio_config_.bitrate = kDefaultAudioEncoderBitrate; | 106 audio_config_.bitrate = kDefaultAudioEncoderBitrate; |
87 audio_config_.rtp_payload_type = 127; | 107 audio_config_.rtp_payload_type = 127; |
88 | 108 |
89 net::IPEndPoint dummy_endpoint; | 109 transport_ = new TestPacketSender(); |
90 | 110 transport_sender_.reset( |
91 transport_sender_.reset(new CastTransportSenderImpl( | 111 new CastTransportSenderImpl(testing_clock_, base::TimeDelta(), |
92 NULL, | 112 make_scoped_ptr(new TransportClient()), |
93 testing_clock_, | 113 make_scoped_ptr(transport_), task_runner_)); |
94 net::IPEndPoint(), | |
95 dummy_endpoint, | |
96 make_scoped_ptr(new base::DictionaryValue), | |
97 base::Bind(&UpdateCastTransportStatus), | |
98 BulkRawEventsCallback(), | |
99 base::TimeDelta(), | |
100 task_runner_, | |
101 PacketReceiverCallback(), | |
102 &transport_)); | |
103 OperationalStatus operational_status = STATUS_UNINITIALIZED; | 114 OperationalStatus operational_status = STATUS_UNINITIALIZED; |
104 audio_sender_.reset(new AudioSender( | 115 audio_sender_.reset(new AudioSender( |
105 cast_environment_, | 116 cast_environment_, |
106 audio_config_, | 117 audio_config_, |
107 base::Bind(&SaveOperationalStatus, &operational_status), | 118 base::Bind(&SaveOperationalStatus, &operational_status), |
108 transport_sender_.get())); | 119 transport_sender_.get())); |
109 task_runner_->RunTasks(); | 120 task_runner_->RunTasks(); |
110 CHECK_EQ(STATUS_INITIALIZED, operational_status); | 121 CHECK_EQ(STATUS_INITIALIZED, operational_status); |
111 } | 122 } |
112 | 123 |
113 ~AudioSenderTest() override {} | 124 ~AudioSenderTest() override {} |
114 | 125 |
115 static void UpdateCastTransportStatus(CastTransportStatus status) { | |
116 EXPECT_EQ(TRANSPORT_AUDIO_INITIALIZED, status); | |
117 } | |
118 | |
119 base::SimpleTestTickClock* testing_clock_; // Owned by CastEnvironment. | 126 base::SimpleTestTickClock* testing_clock_; // Owned by CastEnvironment. |
120 TestPacketSender transport_; | 127 TestPacketSender* transport_; // Owned by CastTransportSender. |
121 scoped_ptr<CastTransportSenderImpl> transport_sender_; | 128 scoped_ptr<CastTransportSenderImpl> transport_sender_; |
122 scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_; | 129 scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_; |
123 scoped_ptr<AudioSender> audio_sender_; | 130 scoped_ptr<AudioSender> audio_sender_; |
124 scoped_refptr<CastEnvironment> cast_environment_; | 131 scoped_refptr<CastEnvironment> cast_environment_; |
125 AudioSenderConfig audio_config_; | 132 AudioSenderConfig audio_config_; |
126 }; | 133 }; |
127 | 134 |
128 TEST_F(AudioSenderTest, Encode20ms) { | 135 TEST_F(AudioSenderTest, Encode20ms) { |
129 const base::TimeDelta kDuration = base::TimeDelta::FromMilliseconds(20); | 136 const base::TimeDelta kDuration = base::TimeDelta::FromMilliseconds(20); |
130 scoped_ptr<AudioBus> bus( | 137 scoped_ptr<AudioBus> bus( |
131 TestAudioBusFactory(audio_config_.channels, | 138 TestAudioBusFactory(audio_config_.channels, |
132 audio_config_.frequency, | 139 audio_config_.frequency, |
133 TestAudioBusFactory::kMiddleANoteFreq, | 140 TestAudioBusFactory::kMiddleANoteFreq, |
134 0.5f).NextAudioBus(kDuration)); | 141 0.5f).NextAudioBus(kDuration)); |
135 | 142 |
136 audio_sender_->InsertAudio(std::move(bus), testing_clock_->NowTicks()); | 143 audio_sender_->InsertAudio(std::move(bus), testing_clock_->NowTicks()); |
137 task_runner_->RunTasks(); | 144 task_runner_->RunTasks(); |
138 EXPECT_LE(1, transport_.number_of_rtp_packets()); | 145 EXPECT_LE(1, transport_->number_of_rtp_packets()); |
139 EXPECT_LE(1, transport_.number_of_rtcp_packets()); | 146 EXPECT_LE(1, transport_->number_of_rtcp_packets()); |
140 } | 147 } |
141 | 148 |
142 TEST_F(AudioSenderTest, RtcpTimer) { | 149 TEST_F(AudioSenderTest, RtcpTimer) { |
143 const base::TimeDelta kDuration = base::TimeDelta::FromMilliseconds(20); | 150 const base::TimeDelta kDuration = base::TimeDelta::FromMilliseconds(20); |
144 scoped_ptr<AudioBus> bus( | 151 scoped_ptr<AudioBus> bus( |
145 TestAudioBusFactory(audio_config_.channels, | 152 TestAudioBusFactory(audio_config_.channels, |
146 audio_config_.frequency, | 153 audio_config_.frequency, |
147 TestAudioBusFactory::kMiddleANoteFreq, | 154 TestAudioBusFactory::kMiddleANoteFreq, |
148 0.5f).NextAudioBus(kDuration)); | 155 0.5f).NextAudioBus(kDuration)); |
149 | 156 |
150 audio_sender_->InsertAudio(std::move(bus), testing_clock_->NowTicks()); | 157 audio_sender_->InsertAudio(std::move(bus), testing_clock_->NowTicks()); |
151 task_runner_->RunTasks(); | 158 task_runner_->RunTasks(); |
152 | 159 |
153 // Make sure that we send at least one RTCP packet. | 160 // Make sure that we send at least one RTCP packet. |
154 base::TimeDelta max_rtcp_timeout = | 161 base::TimeDelta max_rtcp_timeout = |
155 base::TimeDelta::FromMilliseconds(1 + kRtcpReportIntervalMs * 3 / 2); | 162 base::TimeDelta::FromMilliseconds(1 + kRtcpReportIntervalMs * 3 / 2); |
156 testing_clock_->Advance(max_rtcp_timeout); | 163 testing_clock_->Advance(max_rtcp_timeout); |
157 task_runner_->RunTasks(); | 164 task_runner_->RunTasks(); |
158 EXPECT_LE(1, transport_.number_of_rtp_packets()); | 165 EXPECT_LE(1, transport_->number_of_rtp_packets()); |
159 EXPECT_LE(1, transport_.number_of_rtcp_packets()); | 166 EXPECT_LE(1, transport_->number_of_rtcp_packets()); |
160 } | 167 } |
161 | 168 |
162 } // namespace cast | 169 } // namespace cast |
163 } // namespace media | 170 } // namespace media |
OLD | NEW |