OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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 "remoting/client/audio_player.h" | 5 #include "remoting/client/audio_player.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <string> | |
8 | 9 |
9 #include "base/logging.h" | 10 #include "base/logging.h" |
10 #include "base/stl_util.h" | 11 #include "base/stl_util.h" |
11 | 12 |
12 // If queue grows bigger than 150ms we start dropping packets. | 13 // If queue grows bigger than 150ms we start dropping packets. |
13 const int kMaxQueueLatencyMs = 150; | 14 const int kMaxQueueLatencyMs = 150; |
14 | 15 |
15 namespace remoting { | 16 namespace remoting { |
16 | 17 |
17 AudioPlayer::AudioPlayer() | 18 AudioPlayer::AudioPlayer() |
18 : sampling_rate_(AudioPacket::SAMPLING_RATE_INVALID), | 19 : sampling_rate_(AudioPacket::SAMPLING_RATE_INVALID), |
19 start_failed_(false), | 20 start_failed_(false), |
20 queued_bytes_(0), | 21 queued_bytes_(0), |
21 bytes_consumed_(0) { | 22 bytes_consumed_(0) { |
22 } | 23 } |
23 | 24 |
24 AudioPlayer::~AudioPlayer() { | 25 AudioPlayer::~AudioPlayer() { |
25 base::AutoLock auto_lock(lock_); | |
26 ResetQueue(); | |
27 } | 26 } |
Sergey Ulanov
2016/06/18 00:43:38
Please run "git cl format"
nicholss
2016/06/20 17:47:52
I have many times. it did not change this...
| |
28 | 27 |
29 void AudioPlayer::ProcessAudioPacket(std::unique_ptr<AudioPacket> packet) { | 28 void AudioPlayer::AddAudioPacket(std::unique_ptr<AudioPacket> packet) { |
30 CHECK_EQ(1, packet->data_size()); | 29 CHECK_EQ(1, packet->data_size()); |
31 DCHECK_EQ(AudioPacket::ENCODING_RAW, packet->encoding()); | 30 DCHECK_EQ(AudioPacket::ENCODING_RAW, packet->encoding()); |
32 DCHECK_NE(AudioPacket::SAMPLING_RATE_INVALID, packet->sampling_rate()); | 31 DCHECK_NE(AudioPacket::SAMPLING_RATE_INVALID, packet->sampling_rate()); |
33 DCHECK_EQ(kSampleSizeBytes, static_cast<int>(packet->bytes_per_sample())); | 32 DCHECK_EQ(kSampleSizeBytes, static_cast<int>(packet->bytes_per_sample())); |
34 DCHECK_EQ(kChannels, static_cast<int>(packet->channels())); | 33 DCHECK_EQ(kChannels, static_cast<int>(packet->channels())); |
35 DCHECK_EQ(packet->data(0).size() % (kChannels * kSampleSizeBytes), 0u); | 34 DCHECK_EQ(packet->data(0).size() % (kChannels * kSampleSizeBytes), 0u); |
36 | 35 |
37 // No-op if the Pepper player won't start. | 36 // No-op if the Pepper player won't start. |
38 if (start_failed_) { | 37 if (start_failed_) { |
39 return; | 38 return; |
(...skipping 12 matching lines...) Expand all Loading... | |
52 bool success = ResetAudioPlayer(sampling_rate_); | 51 bool success = ResetAudioPlayer(sampling_rate_); |
53 if (!success) { | 52 if (!success) { |
54 start_failed_ = true; | 53 start_failed_ = true; |
55 return; | 54 return; |
56 } | 55 } |
57 } | 56 } |
58 | 57 |
59 base::AutoLock auto_lock(lock_); | 58 base::AutoLock auto_lock(lock_); |
60 | 59 |
61 queued_bytes_ += packet->data(0).size(); | 60 queued_bytes_ += packet->data(0).size(); |
62 queued_packets_.push_back(packet.release()); | 61 queued_packets_.push_back(std::move(packet)); |
63 | 62 |
64 int max_buffer_size_ = | 63 int max_buffer_size_ = |
65 kMaxQueueLatencyMs * sampling_rate_ * kSampleSizeBytes * kChannels / | 64 kMaxQueueLatencyMs * sampling_rate_ * kSampleSizeBytes * kChannels / |
66 base::Time::kMillisecondsPerSecond; | 65 base::Time::kMillisecondsPerSecond; |
67 while (queued_bytes_ > max_buffer_size_) { | 66 while (queued_bytes_ > max_buffer_size_) { |
68 queued_bytes_ -= queued_packets_.front()->data(0).size() - bytes_consumed_; | 67 queued_bytes_ -= queued_packets_.front()->data(0).size() - bytes_consumed_; |
69 DCHECK_GE(queued_bytes_, 0); | 68 DCHECK_GE(queued_bytes_, 0); |
70 delete queued_packets_.front(); | |
71 queued_packets_.pop_front(); | 69 queued_packets_.pop_front(); |
72 bytes_consumed_ = 0; | 70 bytes_consumed_ = 0; |
73 } | 71 } |
74 } | 72 } |
75 | 73 |
74 void AudioPlayer::ProcessAudioPacket(std::unique_ptr<AudioPacket> packet) { | |
75 AddAudioPacket(std::move(packet)); | |
76 } | |
77 | |
76 // static | 78 // static |
77 void AudioPlayer::AudioPlayerCallback(void* samples, | 79 void AudioPlayer::AudioPlayerCallback(void* samples, |
78 uint32_t buffer_size, | 80 uint32_t buffer_size, |
79 void* data) { | 81 void* data) { |
80 AudioPlayer* audio_player = static_cast<AudioPlayer*>(data); | 82 AudioPlayer* audio_player = static_cast<AudioPlayer*>(data); |
81 audio_player->FillWithSamples(samples, buffer_size); | 83 audio_player->FillWithSamples(samples, buffer_size); |
82 } | 84 } |
83 | 85 |
84 void AudioPlayer::ResetQueue() { | 86 void AudioPlayer::ResetQueue() { |
85 lock_.AssertAcquired(); | 87 lock_.AssertAcquired(); |
86 STLDeleteElements(&queued_packets_); | 88 queued_packets_.clear(); |
87 queued_bytes_ = 0; | 89 queued_bytes_ = 0; |
88 bytes_consumed_ = 0; | 90 bytes_consumed_ = 0; |
89 } | 91 } |
90 | 92 |
91 void AudioPlayer::FillWithSamples(void* samples, uint32_t buffer_size) { | 93 void AudioPlayer::FillWithSamples(void* samples, uint32_t buffer_size) { |
92 base::AutoLock auto_lock(lock_); | 94 base::AutoLock auto_lock(lock_); |
93 | 95 |
94 const size_t bytes_needed = kChannels * kSampleSizeBytes * | 96 const size_t bytes_needed = kChannels * kSampleSizeBytes * |
95 GetSamplesPerFrame(); | 97 GetSamplesPerFrame(); |
96 | 98 |
97 // Make sure we don't overrun the buffer. | 99 // Make sure we don't overrun the buffer. |
98 CHECK_EQ(buffer_size, bytes_needed); | 100 CHECK_EQ(buffer_size, bytes_needed); |
99 | 101 |
100 char* next_sample = static_cast<char*>(samples); | 102 char* next_sample = static_cast<char*>(samples); |
101 size_t bytes_extracted = 0; | 103 size_t bytes_extracted = 0; |
102 | 104 |
103 while (bytes_extracted < bytes_needed) { | 105 while (bytes_extracted < bytes_needed) { |
104 // Check if we've run out of samples for this packet. | 106 // Check if we've run out of samples for this packet. |
105 if (queued_packets_.empty()) { | 107 if (queued_packets_.empty()) { |
106 memset(next_sample, 0, bytes_needed - bytes_extracted); | 108 memset(next_sample, 0, bytes_needed - bytes_extracted); |
107 return; | 109 return; |
108 } | 110 } |
109 | 111 |
110 // Pop off the packet if we've already consumed all its bytes. | 112 // Pop off the packet if we've already consumed all its bytes. |
111 if (queued_packets_.front()->data(0).size() == bytes_consumed_) { | 113 if (queued_packets_.front()->data(0).size() == bytes_consumed_) { |
112 delete queued_packets_.front(); | |
113 queued_packets_.pop_front(); | 114 queued_packets_.pop_front(); |
114 bytes_consumed_ = 0; | 115 bytes_consumed_ = 0; |
115 continue; | 116 continue; |
116 } | 117 } |
117 | 118 |
118 const std::string& packet_data = queued_packets_.front()->data(0); | 119 const std::string& packet_data = queued_packets_.front()->data(0); |
119 size_t bytes_to_copy = std::min( | 120 size_t bytes_to_copy = std::min( |
120 packet_data.size() - bytes_consumed_, | 121 packet_data.size() - bytes_consumed_, |
121 bytes_needed - bytes_extracted); | 122 bytes_needed - bytes_extracted); |
122 memcpy(next_sample, packet_data.data() + bytes_consumed_, bytes_to_copy); | 123 memcpy(next_sample, packet_data.data() + bytes_consumed_, bytes_to_copy); |
123 | 124 |
124 next_sample += bytes_to_copy; | 125 next_sample += bytes_to_copy; |
125 bytes_consumed_ += bytes_to_copy; | 126 bytes_consumed_ += bytes_to_copy; |
126 bytes_extracted += bytes_to_copy; | 127 bytes_extracted += bytes_to_copy; |
127 queued_bytes_ -= bytes_to_copy; | 128 queued_bytes_ -= bytes_to_copy; |
128 DCHECK_GE(queued_bytes_, 0); | 129 DCHECK_GE(queued_bytes_, 0); |
129 } | 130 } |
130 } | 131 } |
131 | 132 |
132 } // namespace remoting | 133 } // namespace remoting |
OLD | NEW |