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 "content/browser/renderer_host/media/audio_input_sync_writer.h" | 5 #include "content/browser/renderer_host/media/audio_input_sync_writer.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 | 8 |
9 #include "base/memory/shared_memory.h" | 9 #include "base/metrics/histogram.h" |
| 10 #include "base/strings/stringprintf.h" |
10 #include "content/browser/renderer_host/media/media_stream_manager.h" | 11 #include "content/browser/renderer_host/media/media_stream_manager.h" |
11 | 12 |
12 using media::AudioBus; | 13 using media::AudioBus; |
13 | 14 |
14 namespace content { | 15 namespace content { |
15 | 16 |
16 AudioInputSyncWriter::AudioInputSyncWriter(base::SharedMemory* shared_memory, | 17 namespace { |
| 18 |
| 19 // Used to log if any audio glitches have been detected during an audio session. |
| 20 // Elements in this enum should not be added, deleted or rearranged. |
| 21 enum AudioGlitchResult { |
| 22 AUDIO_CAPTURER_NO_AUDIO_GLITCHES = 0, |
| 23 AUDIO_CAPTURER_AUDIO_GLITCHES = 1, |
| 24 AUDIO_CAPTURER_AUDIO_GLITCHES_MAX = AUDIO_CAPTURER_AUDIO_GLITCHES |
| 25 }; |
| 26 |
| 27 } // namespace |
| 28 |
| 29 AudioInputSyncWriter::AudioInputSyncWriter(void* shared_memory, |
| 30 size_t shared_memory_size, |
17 int shared_memory_segment_count, | 31 int shared_memory_segment_count, |
18 const media::AudioParameters& params) | 32 const media::AudioParameters& params) |
19 : shared_memory_(shared_memory), | 33 : shared_memory_(static_cast<uint8*>(shared_memory)), |
20 shared_memory_segment_count_(shared_memory_segment_count), | 34 shared_memory_segment_count_(shared_memory_segment_count), |
21 current_segment_id_(0), | 35 current_segment_id_(0), |
22 creation_time_(base::Time::Now()), | 36 creation_time_(base::Time::Now()), |
23 audio_bus_memory_size_(AudioBus::CalculateMemorySize(params)), | 37 audio_bus_memory_size_(AudioBus::CalculateMemorySize(params)), |
24 next_buffer_id_(0) { | 38 next_buffer_id_(0), |
| 39 next_read_buffer_index_(0), |
| 40 number_of_filled_segments_(0), |
| 41 write_count_(0), |
| 42 write_error_count_(0) { |
25 DCHECK_GT(shared_memory_segment_count, 0); | 43 DCHECK_GT(shared_memory_segment_count, 0); |
26 DCHECK_EQ(shared_memory->requested_size() % shared_memory_segment_count, 0u); | 44 DCHECK_EQ(shared_memory_size % shared_memory_segment_count, 0u); |
27 shared_memory_segment_size_ = | 45 shared_memory_segment_size_ = |
28 shared_memory->requested_size() / shared_memory_segment_count; | 46 shared_memory_size / shared_memory_segment_count; |
29 DVLOG(1) << "SharedMemory::requested_size: " | 47 DVLOG(1) << "shared_memory_size: " << shared_memory_size; |
30 << shared_memory->requested_size(); | |
31 DVLOG(1) << "shared_memory_segment_count: " << shared_memory_segment_count; | 48 DVLOG(1) << "shared_memory_segment_count: " << shared_memory_segment_count; |
32 DVLOG(1) << "audio_bus_memory_size: " << audio_bus_memory_size_; | 49 DVLOG(1) << "audio_bus_memory_size: " << audio_bus_memory_size_; |
33 | 50 |
34 // Create vector of audio buses by wrapping existing blocks of memory. | 51 // Create vector of audio buses by wrapping existing blocks of memory. |
35 uint8* ptr = static_cast<uint8*>(shared_memory_->memory()); | 52 uint8* ptr = shared_memory_; |
36 for (int i = 0; i < shared_memory_segment_count; ++i) { | 53 for (int i = 0; i < shared_memory_segment_count; ++i) { |
37 CHECK((reinterpret_cast<uintptr_t>(ptr) & | 54 CHECK_EQ(0U, reinterpret_cast<uintptr_t>(ptr) & |
38 (media::AudioBus::kChannelAlignment - 1)) == 0U); | 55 (media::AudioBus::kChannelAlignment - 1)); |
39 media::AudioInputBuffer* buffer = | 56 media::AudioInputBuffer* buffer = |
40 reinterpret_cast<media::AudioInputBuffer*>(ptr); | 57 reinterpret_cast<media::AudioInputBuffer*>(ptr); |
41 scoped_ptr<media::AudioBus> audio_bus = | 58 scoped_ptr<media::AudioBus> audio_bus = |
42 media::AudioBus::WrapMemory(params, buffer->audio); | 59 media::AudioBus::WrapMemory(params, buffer->audio); |
43 audio_buses_.push_back(audio_bus.release()); | 60 audio_buses_.push_back(audio_bus.release()); |
44 ptr += shared_memory_segment_size_; | 61 ptr += shared_memory_segment_size_; |
45 } | 62 } |
46 } | 63 } |
47 | 64 |
48 AudioInputSyncWriter::~AudioInputSyncWriter() {} | 65 AudioInputSyncWriter::~AudioInputSyncWriter() { |
| 66 if (write_count_ == 0) |
| 67 return; |
| 68 |
| 69 UMA_HISTOGRAM_PERCENTAGE( |
| 70 "Media.AudioCapturerMissedReadDeadline", |
| 71 100.0 * write_error_count_ / write_count_); |
| 72 |
| 73 UMA_HISTOGRAM_ENUMERATION("Media.AudioCapturerAudioGlitches", |
| 74 write_error_count_ == 0 ? |
| 75 AUDIO_CAPTURER_NO_AUDIO_GLITCHES : |
| 76 AUDIO_CAPTURER_AUDIO_GLITCHES, |
| 77 AUDIO_CAPTURER_AUDIO_GLITCHES_MAX + 1); |
| 78 |
| 79 std::string log_string = base::StringPrintf( |
| 80 #if defined(COMPILER_MSVC) |
| 81 "AISW: number of detected audio glitches: %Iu out of %Iu", |
| 82 #else |
| 83 "AISW: number of detected audio glitches: %zu out of %zu", |
| 84 #endif |
| 85 write_error_count_, |
| 86 write_count_); |
| 87 MediaStreamManager::SendMessageToNativeLog(log_string); |
| 88 DVLOG(1) << log_string; |
| 89 } |
49 | 90 |
50 void AudioInputSyncWriter::Write(const media::AudioBus* data, | 91 void AudioInputSyncWriter::Write(const media::AudioBus* data, |
51 double volume, | 92 double volume, |
52 bool key_pressed, | 93 bool key_pressed, |
53 uint32 hardware_delay_bytes) { | 94 uint32 hardware_delay_bytes) { |
| 95 ++write_count_; |
| 96 |
54 #if !defined(OS_ANDROID) | 97 #if !defined(OS_ANDROID) |
55 static const base::TimeDelta kLogDelayThreadhold = | 98 static const base::TimeDelta kLogDelayThreadhold = |
56 base::TimeDelta::FromMilliseconds(500); | 99 base::TimeDelta::FromMilliseconds(500); |
57 | 100 |
58 std::ostringstream oss; | 101 std::ostringstream oss; |
59 if (last_write_time_.is_null()) { | 102 if (last_write_time_.is_null()) { |
60 // This is the first time Write is called. | 103 // This is the first time Write is called. |
61 base::TimeDelta interval = base::Time::Now() - creation_time_; | 104 base::TimeDelta interval = base::Time::Now() - creation_time_; |
62 oss << "AISW::Write: audio input data received for the first time: delay " | 105 oss << "AISW::Write: audio input data received for the first time: delay " |
63 "= " << interval.InMilliseconds() << "ms"; | 106 "= " << interval.InMilliseconds() << "ms"; |
64 | 107 |
65 } else { | 108 } else { |
66 base::TimeDelta interval = base::Time::Now() - last_write_time_; | 109 base::TimeDelta interval = base::Time::Now() - last_write_time_; |
67 if (interval > kLogDelayThreadhold) { | 110 if (interval > kLogDelayThreadhold) { |
68 oss << "AISW::Write: audio input data delay unexpectedly long: delay = " | 111 oss << "AISW::Write: audio input data delay unexpectedly long: delay = " |
69 << interval.InMilliseconds() << "ms"; | 112 << interval.InMilliseconds() << "ms"; |
70 } | 113 } |
71 } | 114 } |
72 if (!oss.str().empty()) { | 115 if (!oss.str().empty()) { |
73 MediaStreamManager::SendMessageToNativeLog(oss.str()); | 116 AddToNativeLog(oss.str()); |
74 DVLOG(1) << oss.str(); | 117 DVLOG(1) << oss.str(); |
75 } | 118 } |
76 | 119 |
77 last_write_time_ = base::Time::Now(); | 120 last_write_time_ = base::Time::Now(); |
78 #endif | 121 #endif |
79 | 122 |
| 123 // Check that the renderer side has read data so that we don't overwrite data |
| 124 // that hasn't been read yet. The renderer side sends a signal over the socket |
| 125 // each time it has read data. Here, we read those verifications before |
| 126 // writing. We verify that each buffer index is in sequence. |
| 127 size_t number_of_indices_available = socket_->Peek() / sizeof(uint32_t); |
| 128 if (number_of_indices_available > 0) { |
| 129 scoped_ptr<uint32_t[]> indices(new uint32_t[number_of_indices_available]); |
| 130 size_t bytes_received = socket_->Receive( |
| 131 &indices[0], |
| 132 number_of_indices_available * sizeof(indices[0])); |
| 133 DCHECK_EQ(number_of_indices_available * sizeof(indices[0]), bytes_received); |
| 134 for (size_t i = 0; i < number_of_indices_available; ++i) { |
| 135 ++next_read_buffer_index_; |
| 136 CHECK_EQ(indices[i], next_read_buffer_index_); |
| 137 --number_of_filled_segments_; |
| 138 CHECK_GE(number_of_filled_segments_, 0); |
| 139 } |
| 140 } |
| 141 |
| 142 // Check that the ring buffer isn't full, and if it is log error and drop the |
| 143 // buffer. |
| 144 if (number_of_filled_segments_ == |
| 145 static_cast<int>(shared_memory_segment_count_)) { |
| 146 const std::string error_message = |
| 147 "No room in ring buffer to write data to. Dropping the data."; |
| 148 LOG(ERROR) << error_message; |
| 149 AddToNativeLog(error_message); |
| 150 ++write_error_count_; |
| 151 return; |
| 152 } |
| 153 |
80 // Write audio parameters to shared memory. | 154 // Write audio parameters to shared memory. |
81 uint8* ptr = static_cast<uint8*>(shared_memory_->memory()); | 155 uint8* ptr = shared_memory_; |
82 ptr += current_segment_id_ * shared_memory_segment_size_; | 156 ptr += current_segment_id_ * shared_memory_segment_size_; |
83 media::AudioInputBuffer* buffer = | 157 media::AudioInputBuffer* buffer = |
84 reinterpret_cast<media::AudioInputBuffer*>(ptr); | 158 reinterpret_cast<media::AudioInputBuffer*>(ptr); |
85 buffer->params.volume = volume; | 159 buffer->params.volume = volume; |
86 buffer->params.size = audio_bus_memory_size_; | 160 buffer->params.size = audio_bus_memory_size_; |
87 buffer->params.key_pressed = key_pressed; | 161 buffer->params.key_pressed = key_pressed; |
88 buffer->params.hardware_delay_bytes = hardware_delay_bytes; | 162 buffer->params.hardware_delay_bytes = hardware_delay_bytes; |
89 buffer->params.id = next_buffer_id_++; | 163 buffer->params.id = next_buffer_id_++; |
90 | 164 |
91 // Copy data from the native audio layer into shared memory using pre- | 165 // Copy data from the native audio layer into shared memory using pre- |
92 // allocated audio buses. | 166 // allocated audio buses. |
93 media::AudioBus* audio_bus = audio_buses_[current_segment_id_]; | 167 media::AudioBus* audio_bus = audio_buses_[current_segment_id_]; |
94 data->CopyTo(audio_bus); | 168 data->CopyTo(audio_bus); |
95 | 169 |
96 socket_->Send(¤t_segment_id_, sizeof(current_segment_id_)); | 170 socket_->Send(¤t_segment_id_, sizeof(current_segment_id_)); |
97 | 171 |
98 if (++current_segment_id_ >= shared_memory_segment_count_) | 172 if (++current_segment_id_ >= shared_memory_segment_count_) |
99 current_segment_id_ = 0; | 173 current_segment_id_ = 0; |
| 174 |
| 175 ++number_of_filled_segments_; |
| 176 CHECK_LE(number_of_filled_segments_, |
| 177 static_cast<int>(shared_memory_segment_count_)); |
100 } | 178 } |
101 | 179 |
102 void AudioInputSyncWriter::Close() { | 180 void AudioInputSyncWriter::Close() { |
103 socket_->Close(); | 181 socket_->Close(); |
104 } | 182 } |
105 | 183 |
106 bool AudioInputSyncWriter::Init() { | 184 bool AudioInputSyncWriter::Init() { |
107 socket_.reset(new base::CancelableSyncSocket()); | 185 socket_.reset(new base::CancelableSyncSocket()); |
108 foreign_socket_.reset(new base::CancelableSyncSocket()); | 186 foreign_socket_.reset(new base::CancelableSyncSocket()); |
109 return base::CancelableSyncSocket::CreatePair(socket_.get(), | 187 return base::CancelableSyncSocket::CreatePair(socket_.get(), |
110 foreign_socket_.get()); | 188 foreign_socket_.get()); |
111 } | 189 } |
112 | 190 |
113 bool AudioInputSyncWriter::PrepareForeignSocket( | 191 bool AudioInputSyncWriter::PrepareForeignSocket( |
114 base::ProcessHandle process_handle, | 192 base::ProcessHandle process_handle, |
115 base::SyncSocket::TransitDescriptor* descriptor) { | 193 base::SyncSocket::TransitDescriptor* descriptor) { |
116 return foreign_socket_->PrepareTransitDescriptor(process_handle, descriptor); | 194 return foreign_socket_->PrepareTransitDescriptor(process_handle, descriptor); |
117 } | 195 } |
118 | 196 |
| 197 void AudioInputSyncWriter::AddToNativeLog(const std::string& message) { |
| 198 MediaStreamManager::SendMessageToNativeLog(message); |
| 199 } |
119 | 200 |
120 } // namespace content | 201 } // namespace content |
OLD | NEW |