admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove usage of INFO alias for LS_INFO in log messages

Browse Source 
Bug: webrtc:13362
Change-Id: Ifda893861a036a85c045cd366f9eab33c62ebde0
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/237221
Reviewed-by: Niels Moller <nisse@webrtc.org>
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#35310}
This commit is contained in:
Harald Alvestrand 2021-11-04 12:01:23 +00:00 committed by WebRTC LUCI CQ
parent bd9106d88f
commit 97597c0f51
70 changed files with 1140 additions and 1125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
api/video_codecs/video_encoder_software_fallback_wrapper.cc
View File

@ -358,7 +358,7 @@ int32_t VideoEncoderSoftwareFallbackWrapper::EncodeWithMainEncoder(
fallback_encoder_->GetEncoderInfo().supports_native_handle) { fallback_encoder_->GetEncoderInfo().supports_native_handle) {
return fallback_encoder_->Encode(frame, frame_types); return fallback_encoder_->Encode(frame, frame_types);
} else { } else {
RTC_LOG(INFO) << "Fallback encoder does not support native handle - " RTC_LOG(LS_INFO) << "Fallback encoder does not support native handle - "
"converting frame to I420"; "converting frame to I420";
rtc::scoped_refptr<I420BufferInterface> src_buffer = rtc::scoped_refptr<I420BufferInterface> src_buffer =
frame.video_frame_buffer()->ToI420(); frame.video_frame_buffer()->ToI420();

2
api/voip/voip_engine_factory.cc
View File

@ -24,7 +24,7 @@ std::unique_ptr<VoipEngine> CreateVoipEngine(VoipEngineConfig config) {
RTC_CHECK(config.audio_device_module); RTC_CHECK(config.audio_device_module);
if (!config.audio_processing) { if (!config.audio_processing) {
RTC_DLOG(INFO) << "No audio processing functionality provided."; RTC_DLOG(LS_INFO) << "No audio processing functionality provided.";
} }
return std::make_unique<VoipCore>(std::move(config.encoder_factory), return std::make_unique<VoipCore>(std::move(config.encoder_factory),

4
audio/audio_state.cc
View File

@ -123,7 +123,7 @@ void AudioState::RemoveSendingStream(webrtc::AudioSendStream* stream) {
} }
void AudioState::SetPlayout(bool enabled) { void AudioState::SetPlayout(bool enabled) {
RTC_LOG(INFO) << "SetPlayout(" << enabled << ")"; RTC_LOG(LS_INFO) << "SetPlayout(" << enabled << ")";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
if (playout_enabled_ != enabled) { if (playout_enabled_ != enabled) {
playout_enabled_ = enabled; playout_enabled_ = enabled;
@ -140,7 +140,7 @@ void AudioState::SetPlayout(bool enabled) {
} }
void AudioState::SetRecording(bool enabled) { void AudioState::SetRecording(bool enabled) {
RTC_LOG(INFO) << "SetRecording(" << enabled << ")"; RTC_LOG(LS_INFO) << "SetRecording(" << enabled << ")";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
if (recording_enabled_ != enabled) { if (recording_enabled_ != enabled) {
recording_enabled_ = enabled; recording_enabled_ = enabled;

11
call/adaptation/resource_adaptation_processor.cc
View File

@ -129,7 +129,7 @@ void ResourceAdaptationProcessor::AddResource(
resources_.push_back(resource); resources_.push_back(resource);
} }
resource->SetResourceListener(resource_listener_delegate_); resource->SetResourceListener(resource_listener_delegate_);
RTC_LOG(INFO) << "Registered resource \"" << resource->Name() << "\"."; RTC_LOG(LS_INFO) << "Registered resource \"" << resource->Name() << "\".";
} }
std::vector<rtc::scoped_refptr<Resource>> std::vector<rtc::scoped_refptr<Resource>>
@ -141,7 +141,7 @@ ResourceAdaptationProcessor::GetResources() const {
void ResourceAdaptationProcessor::RemoveResource( void ResourceAdaptationProcessor::RemoveResource(
rtc::scoped_refptr<Resource> resource) { rtc::scoped_refptr<Resource> resource) {
RTC_DCHECK(resource); RTC_DCHECK(resource);
RTC_LOG(INFO) << "Removing resource \"" << resource->Name() << "\"."; RTC_LOG(LS_INFO) << "Removing resource \"" << resource->Name() << "\".";
resource->SetResourceListener(nullptr); resource->SetResourceListener(nullptr);
{ {
MutexLock crit(&resources_lock_); MutexLock crit(&resources_lock_);
@ -188,7 +188,8 @@ void ResourceAdaptationProcessor::RemoveLimitationsImposedByResource(
RTC_DCHECK_EQ(adapt_to.status(), Adaptation::Status::kValid); RTC_DCHECK_EQ(adapt_to.status(), Adaptation::Status::kValid);
stream_adapter_->ApplyAdaptation(adapt_to, nullptr); stream_adapter_->ApplyAdaptation(adapt_to, nullptr);
RTC_LOG(INFO) << "Most limited resource removed. Restoring restrictions to " RTC_LOG(LS_INFO)
<< "Most limited resource removed. Restoring restrictions to "
"next most limited restrictions: " "next most limited restrictions: "
<< most_limited.restrictions.ToString() << " with counters " << most_limited.restrictions.ToString() << " with counters "
<< most_limited.counters.ToString(); << most_limited.counters.ToString();
@ -204,7 +205,7 @@ void ResourceAdaptationProcessor::OnResourceUsageStateMeasured(
{ {
MutexLock crit(&resources_lock_); MutexLock crit(&resources_lock_);
if (absl::c_find(resources_, resource) == resources_.end()) { if (absl::c_find(resources_, resource) == resources_.end()) {
RTC_LOG(INFO) << "Ignoring signal from removed resource \"" RTC_LOG(LS_INFO) << "Ignoring signal from removed resource \""
<< resource->Name() << "\"."; << resource->Name() << "\".";
return; return;
} }
@ -226,7 +227,7 @@ void ResourceAdaptationProcessor::OnResourceUsageStateMeasured(
// successfully adapted since - don't log to avoid spam. // successfully adapted since - don't log to avoid spam.
return; return;
} }
RTC_LOG(INFO) << "Resource \"" << resource->Name() << "\" signalled " RTC_LOG(LS_INFO) << "Resource \"" << resource->Name() << "\" signalled "
<< ResourceUsageStateToString(usage_state) << ". " << ResourceUsageStateToString(usage_state) << ". "
<< result_and_message.message; << result_and_message.message;
if (result_and_message.result == MitigationResult::kAdaptationApplied) { if (result_and_message.result == MitigationResult::kAdaptationApplied) {

4
call/adaptation/video_stream_adapter.cc
View File

@ -234,7 +234,7 @@ const VideoAdaptationCounters& VideoStreamAdapter::adaptation_counters() const {
void VideoStreamAdapter::ClearRestrictions() { void VideoStreamAdapter::ClearRestrictions() {
RTC_DCHECK_RUN_ON(&sequence_checker_); RTC_DCHECK_RUN_ON(&sequence_checker_);
// Invalidate any previously returned Adaptation. // Invalidate any previously returned Adaptation.
RTC_LOG(INFO) << "Resetting restrictions"; RTC_LOG(LS_INFO) << "Resetting restrictions";
++adaptation_validation_id_; ++adaptation_validation_id_;
current_restrictions_ = {VideoSourceRestrictions(), current_restrictions_ = {VideoSourceRestrictions(),
VideoAdaptationCounters()}; VideoAdaptationCounters()};
@ -333,7 +333,7 @@ Adaptation VideoStreamAdapter::GetAdaptationUp(
if (!constraint->IsAdaptationUpAllowed(input_state, if (!constraint->IsAdaptationUpAllowed(input_state,
current_restrictions_.restrictions, current_restrictions_.restrictions,
restrictions.restrictions)) { restrictions.restrictions)) {
RTC_LOG(INFO) << "Not adapting up because constraint \"" RTC_LOG(LS_INFO) << "Not adapting up because constraint \""
<< constraint->Name() << "\" disallowed it"; << constraint->Name() << "\" disallowed it";
step = Adaptation::Status::kRejectedByConstraint; step = Adaptation::Status::kRejectedByConstraint;
} }

50
examples/peerconnection/client/conductor.cc
View File

@ -61,9 +61,9 @@ class DummySetSessionDescriptionObserver
static DummySetSessionDescriptionObserver* Create() { static DummySetSessionDescriptionObserver* Create() {
return new rtc::RefCountedObject<DummySetSessionDescriptionObserver>(); return new rtc::RefCountedObject<DummySetSessionDescriptionObserver>();
} }
virtual void OnSuccess() { RTC_LOG(INFO) << __FUNCTION__; } virtual void OnSuccess() { RTC_LOG(LS_INFO) << __FUNCTION__; }
virtual void OnFailure(webrtc::RTCError error) { virtual void OnFailure(webrtc::RTCError error) {
RTC_LOG(INFO) << __FUNCTION__ << " " << ToString(error.type()) << ": " RTC_LOG(LS_INFO) << __FUNCTION__ << " " << ToString(error.type()) << ": "
<< error.message(); << error.message();
} }
}; };
@ -221,23 +221,23 @@ void Conductor::OnAddTrack(
rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver, rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver,
const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>& const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&
streams) { streams) {
RTC_LOG(INFO) << __FUNCTION__ << " " << receiver->id(); RTC_LOG(LS_INFO) << __FUNCTION__ << " " << receiver->id();
main_wnd_->QueueUIThreadCallback(NEW_TRACK_ADDED, main_wnd_->QueueUIThreadCallback(NEW_TRACK_ADDED,
receiver->track().release()); receiver->track().release());
} }
void Conductor::OnRemoveTrack( void Conductor::OnRemoveTrack(
rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver) { rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver) {
RTC_LOG(INFO) << __FUNCTION__ << " " << receiver->id(); RTC_LOG(LS_INFO) << __FUNCTION__ << " " << receiver->id();
main_wnd_->QueueUIThreadCallback(TRACK_REMOVED, receiver->track().release()); main_wnd_->QueueUIThreadCallback(TRACK_REMOVED, receiver->track().release());
} }
void Conductor::OnIceCandidate(const webrtc::IceCandidateInterface* candidate) { void Conductor::OnIceCandidate(const webrtc::IceCandidateInterface* candidate) {
RTC_LOG(INFO) << __FUNCTION__ << " " << candidate->sdp_mline_index(); RTC_LOG(LS_INFO) << __FUNCTION__ << " " << candidate->sdp_mline_index();
// For loopback test. To save some connecting delay. // For loopback test. To save some connecting delay.
if (loopback_) { if (loopback_) {
if (!peer_connection_->AddIceCandidate(candidate)) { if (!peer_connection_->AddIceCandidate(candidate)) {
RTC_LOG(WARNING) << "Failed to apply the received candidate"; RTC_LOG(LS_WARNING) << "Failed to apply the received candidate";
} }
return; return;
} }
@ -261,12 +261,12 @@ void Conductor::OnIceCandidate(const webrtc::IceCandidateInterface* candidate) {
// //
void Conductor::OnSignedIn() { void Conductor::OnSignedIn() {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
main_wnd_->SwitchToPeerList(client_->peers()); main_wnd_->SwitchToPeerList(client_->peers());
} }
void Conductor::OnDisconnected() { void Conductor::OnDisconnected() {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
DeletePeerConnection(); DeletePeerConnection();
@ -275,16 +275,16 @@ void Conductor::OnDisconnected() {
} }
void Conductor::OnPeerConnected(int id, const std::string& name) { void Conductor::OnPeerConnected(int id, const std::string& name) {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
// Refresh the list if we're showing it. // Refresh the list if we're showing it.
if (main_wnd_->current_ui() == MainWindow::LIST_PEERS) if (main_wnd_->current_ui() == MainWindow::LIST_PEERS)
main_wnd_->SwitchToPeerList(client_->peers()); main_wnd_->SwitchToPeerList(client_->peers());
} }
void Conductor::OnPeerDisconnected(int id) { void Conductor::OnPeerDisconnected(int id) {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
if (id == peer_id_) { if (id == peer_id_) {
RTC_LOG(INFO) << "Our peer disconnected"; RTC_LOG(LS_INFO) << "Our peer disconnected";
main_wnd_->QueueUIThreadCallback(PEER_CONNECTION_CLOSED, NULL); main_wnd_->QueueUIThreadCallback(PEER_CONNECTION_CLOSED, NULL);
} else { } else {
// Refresh the list if we're showing it. // Refresh the list if we're showing it.
@ -308,7 +308,7 @@ void Conductor::OnMessageFromPeer(int peer_id, const std::string& message) {
} }
} else if (peer_id != peer_id_) { } else if (peer_id != peer_id_) {
RTC_DCHECK(peer_id_ != -1); RTC_DCHECK(peer_id_ != -1);
RTC_LOG(WARNING) RTC_LOG(LS_WARNING)
<< "Received a message from unknown peer while already in a " << "Received a message from unknown peer while already in a "
"conversation with a different peer."; "conversation with a different peer.";
return; return;
@ -317,7 +317,7 @@ void Conductor::OnMessageFromPeer(int peer_id, const std::string& message) {
Json::Reader reader; Json::Reader reader;
Json::Value jmessage; Json::Value jmessage;
if (!reader.parse(message, jmessage)) { if (!reader.parse(message, jmessage)) {
RTC_LOG(WARNING) << "Received unknown message. " << message; RTC_LOG(LS_WARNING) << "Received unknown message. " << message;
return; return;
} }
std::string type_str; std::string type_str;
@ -346,19 +346,21 @@ void Conductor::OnMessageFromPeer(int peer_id, const std::string& message) {
std::string sdp; std::string sdp;
if (!rtc::GetStringFromJsonObject(jmessage, kSessionDescriptionSdpName, if (!rtc::GetStringFromJsonObject(jmessage, kSessionDescriptionSdpName,
&sdp)) { &sdp)) {
RTC_LOG(WARNING) << "Can't parse received session description message."; RTC_LOG(LS_WARNING)
<< "Can't parse received session description message.";
return; return;
} }
webrtc::SdpParseError error; webrtc::SdpParseError error;
std::unique_ptr<webrtc::SessionDescriptionInterface> session_description = std::unique_ptr<webrtc::SessionDescriptionInterface> session_description =
webrtc::CreateSessionDescription(type, sdp, &error); webrtc::CreateSessionDescription(type, sdp, &error);
if (!session_description) { if (!session_description) {
RTC_LOG(WARNING) << "Can't parse received session description message. " RTC_LOG(LS_WARNING)
<< "Can't parse received session description message. "
"SdpParseError was: " "SdpParseError was: "
<< error.description; << error.description;
return; return;
} }
RTC_LOG(INFO) << " Received session description :" << message; RTC_LOG(LS_INFO) << " Received session description :" << message;
peer_connection_->SetRemoteDescription( peer_connection_->SetRemoteDescription(
DummySetSessionDescriptionObserver::Create(), DummySetSessionDescriptionObserver::Create(),
session_description.release()); session_description.release());
@ -375,23 +377,23 @@ void Conductor::OnMessageFromPeer(int peer_id, const std::string& message) {
!rtc::GetIntFromJsonObject(jmessage, kCandidateSdpMlineIndexName, !rtc::GetIntFromJsonObject(jmessage, kCandidateSdpMlineIndexName,
&sdp_mlineindex) || &sdp_mlineindex) ||
!rtc::GetStringFromJsonObject(jmessage, kCandidateSdpName, &sdp)) { !rtc::GetStringFromJsonObject(jmessage, kCandidateSdpName, &sdp)) {
RTC_LOG(WARNING) << "Can't parse received message."; RTC_LOG(LS_WARNING) << "Can't parse received message.";
return; return;
} }
webrtc::SdpParseError error; webrtc::SdpParseError error;
std::unique_ptr<webrtc::IceCandidateInterface> candidate( std::unique_ptr<webrtc::IceCandidateInterface> candidate(
webrtc::CreateIceCandidate(sdp_mid, sdp_mlineindex, sdp, &error)); webrtc::CreateIceCandidate(sdp_mid, sdp_mlineindex, sdp, &error));
if (!candidate.get()) { if (!candidate.get()) {
RTC_LOG(WARNING) << "Can't parse received candidate message. " RTC_LOG(LS_WARNING) << "Can't parse received candidate message. "
"SdpParseError was: " "SdpParseError was: "
<< error.description; << error.description;
return; return;
} }
if (!peer_connection_->AddIceCandidate(candidate.get())) { if (!peer_connection_->AddIceCandidate(candidate.get())) {
RTC_LOG(WARNING) << "Failed to apply the received candidate"; RTC_LOG(LS_WARNING) << "Failed to apply the received candidate";
return; return;
} }
RTC_LOG(INFO) << " Received candidate :" << message; RTC_LOG(LS_INFO) << " Received candidate :" << message;
} }
} }
@ -475,7 +477,7 @@ void Conductor::AddTracks() {
} }
void Conductor::DisconnectFromCurrentPeer() { void Conductor::DisconnectFromCurrentPeer() {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
if (peer_connection_.get()) { if (peer_connection_.get()) {
client_->SendHangUp(peer_id_); client_->SendHangUp(peer_id_);
DeletePeerConnection(); DeletePeerConnection();
@ -488,7 +490,7 @@ void Conductor::DisconnectFromCurrentPeer() {
void Conductor::UIThreadCallback(int msg_id, void* data) { void Conductor::UIThreadCallback(int msg_id, void* data) {
switch (msg_id) { switch (msg_id) {
case PEER_CONNECTION_CLOSED: case PEER_CONNECTION_CLOSED:
RTC_LOG(INFO) << "PEER_CONNECTION_CLOSED"; RTC_LOG(LS_INFO) << "PEER_CONNECTION_CLOSED";
DeletePeerConnection(); DeletePeerConnection();
if (main_wnd_->IsWindow()) { if (main_wnd_->IsWindow()) {
@ -503,7 +505,7 @@ void Conductor::UIThreadCallback(int msg_id, void* data) {
break; break;
case SEND_MESSAGE_TO_PEER: { case SEND_MESSAGE_TO_PEER: {
RTC_LOG(INFO) << "SEND_MESSAGE_TO_PEER"; RTC_LOG(LS_INFO) << "SEND_MESSAGE_TO_PEER";
std::string* msg = reinterpret_cast<std::string*>(data); std::string* msg = reinterpret_cast<std::string*>(data);
if (msg) { if (msg) {
// For convenience, we always run the message through the queue. // For convenience, we always run the message through the queue.
@ -579,7 +581,7 @@ void Conductor::OnSuccess(webrtc::SessionDescriptionInterface* desc) {
} }
void Conductor::OnFailure(webrtc::RTCError error) { void Conductor::OnFailure(webrtc::RTCError error) {
RTC_LOG(LERROR) << ToString(error.type()) << ": " << error.message(); RTC_LOG(LS_ERROR) << ToString(error.type()) << ": " << error.message();
} }
void Conductor::SendMessage(const std::string& json_object) { void Conductor::SendMessage(const std::string& json_object) {

6
examples/peerconnection/client/linux/main_wnd.cc
View File

@ -252,7 +252,7 @@ bool GtkMainWnd::Destroy() {
} }
void GtkMainWnd::SwitchToConnectUI() { void GtkMainWnd::SwitchToConnectUI() {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK(IsWindow()); RTC_DCHECK(IsWindow());
RTC_DCHECK(vbox_ == NULL); RTC_DCHECK(vbox_ == NULL);
@ -308,7 +308,7 @@ void GtkMainWnd::SwitchToConnectUI() {
} }
void GtkMainWnd::SwitchToPeerList(const Peers& peers) { void GtkMainWnd::SwitchToPeerList(const Peers& peers) {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
if (!peer_list_) { if (!peer_list_) {
gtk_container_set_border_width(GTK_CONTAINER(window_), 0); gtk_container_set_border_width(GTK_CONTAINER(window_), 0);
@ -345,7 +345,7 @@ void GtkMainWnd::SwitchToPeerList(const Peers& peers) {
} }
void GtkMainWnd::SwitchToStreamingUI() { void GtkMainWnd::SwitchToStreamingUI() {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK(draw_area_ == NULL); RTC_DCHECK(draw_area_ == NULL);

6
examples/peerconnection/client/peer_connection_client.cc
View File

@ -297,7 +297,7 @@ bool PeerConnectionClient::ReadIntoBuffer(rtc::Socket* socket,
bool ret = false; bool ret = false;
size_t i = data->find("\r\n\r\n"); size_t i = data->find("\r\n\r\n");
if (i != std::string::npos) { if (i != std::string::npos) {
RTC_LOG(INFO) << "Headers received"; RTC_LOG(LS_INFO) << "Headers received";
if (GetHeaderValue(*data, i, "\r\nContent-Length: ", content_length)) { if (GetHeaderValue(*data, i, "\r\nContent-Length: ", content_length)) {
size_t total_response_size = (i + 4) + *content_length; size_t total_response_size = (i + 4) + *content_length;
if (data->length() >= total_response_size) { if (data->length() >= total_response_size) {
@ -374,7 +374,7 @@ void PeerConnectionClient::OnRead(rtc::Socket* socket) {
} }
void PeerConnectionClient::OnHangingGetRead(rtc::Socket* socket) { void PeerConnectionClient::OnHangingGetRead(rtc::Socket* socket) {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
size_t content_length = 0; size_t content_length = 0;
if (ReadIntoBuffer(socket, &notification_data_, &content_length)) { if (ReadIntoBuffer(socket, &notification_data_, &content_length)) {
size_t peer_id = 0, eoh = 0; size_t peer_id = 0, eoh = 0;
@ -472,7 +472,7 @@ bool PeerConnectionClient::ParseServerResponse(const std::string& response,
} }
void PeerConnectionClient::OnClose(rtc::Socket* socket, int err) { void PeerConnectionClient::OnClose(rtc::Socket* socket, int err) {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
socket->Close(); socket->Close();

12
examples/unityplugin/simple_peer_connection.cc
View File

@ -101,9 +101,9 @@ class DummySetSessionDescriptionObserver
static DummySetSessionDescriptionObserver* Create() { static DummySetSessionDescriptionObserver* Create() {
return new rtc::RefCountedObject<DummySetSessionDescriptionObserver>(); return new rtc::RefCountedObject<DummySetSessionDescriptionObserver>();
} }
virtual void OnSuccess() { RTC_LOG(INFO) << __FUNCTION__; } virtual void OnSuccess() { RTC_LOG(LS_INFO) << __FUNCTION__; }
virtual void OnFailure(webrtc::RTCError error) { virtual void OnFailure(webrtc::RTCError error) {
RTC_LOG(INFO) << __FUNCTION__ << " " << ToString(error.type()) << ": " RTC_LOG(LS_INFO) << __FUNCTION__ << " " << ToString(error.type()) << ": "
<< error.message(); << error.message();
} }
@ -278,7 +278,7 @@ void SimplePeerConnection::OnFailure(webrtc::RTCError error) {
void SimplePeerConnection::OnIceCandidate( void SimplePeerConnection::OnIceCandidate(
const webrtc::IceCandidateInterface* candidate) { const webrtc::IceCandidateInterface* candidate) {
RTC_LOG(INFO) << __FUNCTION__ << " " << candidate->sdp_mline_index(); RTC_LOG(LS_INFO) << __FUNCTION__ << " " << candidate->sdp_mline_index();
std::string sdp; std::string sdp;
if (!candidate->ToString(&sdp)) { if (!candidate->ToString(&sdp)) {
@ -348,7 +348,7 @@ bool SimplePeerConnection::SetRemoteDescription(const char* type,
<< error.description; << error.description;
return false; return false;
} }
RTC_LOG(INFO) << " Received session description :" << remote_desc; RTC_LOG(LS_INFO) << " Received session description :" << remote_desc;
peer_connection_->SetRemoteDescription( peer_connection_->SetRemoteDescription(
DummySetSessionDescriptionObserver::Create(), session_description); DummySetSessionDescriptionObserver::Create(), session_description);
@ -374,7 +374,7 @@ bool SimplePeerConnection::AddIceCandidate(const char* candidate,
RTC_LOG(WARNING) << "Failed to apply the received candidate"; RTC_LOG(WARNING) << "Failed to apply the received candidate";
return false; return false;
} }
RTC_LOG(INFO) << " Received candidate :" << candidate; RTC_LOG(LS_INFO) << " Received candidate :" << candidate;
return true; return true;
} }
@ -409,7 +409,7 @@ void SimplePeerConnection::SetAudioControl() {
void SimplePeerConnection::OnAddStream( void SimplePeerConnection::OnAddStream(
rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) { rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
RTC_LOG(INFO) << __FUNCTION__ << " " << stream->id(); RTC_LOG(LS_INFO) << __FUNCTION__ << " " << stream->id();
remote_stream_ = stream; remote_stream_ = stream;
if (remote_video_observer_ && !remote_stream_->GetVideoTracks().empty()) { if (remote_video_observer_ && !remote_stream_->GetVideoTracks().empty()) {
remote_stream_->GetVideoTracks()[0]->AddOrUpdateSink( remote_stream_->GetVideoTracks()[0]->AddOrUpdateSink(

2
logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.cc
View File

@ -674,7 +674,7 @@ std::string RtcEventLogEncoderLegacy::EncodeVideoSendStreamConfig(
encoder->set_payload_type(codec.payload_type); encoder->set_payload_type(codec.payload_type);
if (event.config().codecs.size() > 1) { if (event.config().codecs.size() > 1) {
RTC_LOG(WARNING) RTC_LOG(LS_WARNING)
<< "LogVideoSendStreamConfig currently only supports one " << "LogVideoSendStreamConfig currently only supports one "
"codec. Logging codec :" "codec. Logging codec :"
<< codec.payload_name; << codec.payload_name;

2
media/sctp/usrsctp_transport_reliability_unittest.cc
View File

@ -259,7 +259,7 @@ class SctpDataReceiver final : public sigslot::has_slots<> {
} }
if (num_messages_received_ % kLogPerMessagesCount == 0) { if (num_messages_received_ % kLogPerMessagesCount == 0) {
RTC_LOG(INFO) << receiver_id_ << " receiver got " RTC_LOG(LS_INFO) << receiver_id_ << " receiver got "
<< num_messages_received_ << " messages"; << num_messages_received_ << " messages";
} }
} }

24
modules/audio_device/android/aaudio_player.cc
View File

@ -27,19 +27,19 @@ enum AudioDeviceMessageType : uint32_t {
AAudioPlayer::AAudioPlayer(AudioManager* audio_manager) AAudioPlayer::AAudioPlayer(AudioManager* audio_manager)
: main_thread_(rtc::Thread::Current()), : main_thread_(rtc::Thread::Current()),
aaudio_(audio_manager, AAUDIO_DIRECTION_OUTPUT, this) { aaudio_(audio_manager, AAUDIO_DIRECTION_OUTPUT, this) {
RTC_LOG(INFO) << "ctor"; RTC_LOG(LS_INFO) << "ctor";
thread_checker_aaudio_.Detach(); thread_checker_aaudio_.Detach();
} }
AAudioPlayer::~AAudioPlayer() { AAudioPlayer::~AAudioPlayer() {
RTC_LOG(INFO) << "dtor"; RTC_LOG(LS_INFO) << "dtor";
RTC_DCHECK_RUN_ON(&main_thread_checker_); RTC_DCHECK_RUN_ON(&main_thread_checker_);
Terminate(); Terminate();
RTC_LOG(INFO) << "#detected underruns: " << underrun_count_; RTC_LOG(LS_INFO) << "#detected underruns: " << underrun_count_;
} }
int AAudioPlayer::Init() { int AAudioPlayer::Init() {
RTC_LOG(INFO) << "Init"; RTC_LOG(LS_INFO) << "Init";
RTC_DCHECK_RUN_ON(&main_thread_checker_); RTC_DCHECK_RUN_ON(&main_thread_checker_);
if (aaudio_.audio_parameters().channels() == 2) { if (aaudio_.audio_parameters().channels() == 2) {
RTC_DLOG(LS_WARNING) << "Stereo mode is enabled"; RTC_DLOG(LS_WARNING) << "Stereo mode is enabled";
@ -48,14 +48,14 @@ int AAudioPlayer::Init() {
} }
int AAudioPlayer::Terminate() { int AAudioPlayer::Terminate() {
RTC_LOG(INFO) << "Terminate"; RTC_LOG(LS_INFO) << "Terminate";
RTC_DCHECK_RUN_ON(&main_thread_checker_); RTC_DCHECK_RUN_ON(&main_thread_checker_);
StopPlayout(); StopPlayout();
return 0; return 0;
} }
int AAudioPlayer::InitPlayout() { int AAudioPlayer::InitPlayout() {
RTC_LOG(INFO) << "InitPlayout"; RTC_LOG(LS_INFO) << "InitPlayout";
RTC_DCHECK_RUN_ON(&main_thread_checker_); RTC_DCHECK_RUN_ON(&main_thread_checker_);
RTC_DCHECK(!initialized_); RTC_DCHECK(!initialized_);
RTC_DCHECK(!playing_); RTC_DCHECK(!playing_);
@ -72,7 +72,7 @@ bool AAudioPlayer::PlayoutIsInitialized() const {
} }
int AAudioPlayer::StartPlayout() { int AAudioPlayer::StartPlayout() {
RTC_LOG(INFO) << "StartPlayout"; RTC_LOG(LS_INFO) << "StartPlayout";
RTC_DCHECK_RUN_ON(&main_thread_checker_); RTC_DCHECK_RUN_ON(&main_thread_checker_);
RTC_DCHECK(!playing_); RTC_DCHECK(!playing_);
if (!initialized_) { if (!initialized_) {
@ -93,7 +93,7 @@ int AAudioPlayer::StartPlayout() {
} }
int AAudioPlayer::StopPlayout() { int AAudioPlayer::StopPlayout() {
RTC_LOG(INFO) << "StopPlayout"; RTC_LOG(LS_INFO) << "StopPlayout";
RTC_DCHECK_RUN_ON(&main_thread_checker_); RTC_DCHECK_RUN_ON(&main_thread_checker_);
if (!initialized_ || !playing_) { if (!initialized_ || !playing_) {
return 0; return 0;
@ -114,7 +114,7 @@ bool AAudioPlayer::Playing() const {
} }
void AAudioPlayer::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) { void AAudioPlayer::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
RTC_DLOG(INFO) << "AttachAudioBuffer"; RTC_DLOG(LS_INFO) << "AttachAudioBuffer";
RTC_DCHECK_RUN_ON(&main_thread_checker_); RTC_DCHECK_RUN_ON(&main_thread_checker_);
audio_device_buffer_ = audioBuffer; audio_device_buffer_ = audioBuffer;
const AudioParameters audio_parameters = aaudio_.audio_parameters(); const AudioParameters audio_parameters = aaudio_.audio_parameters();
@ -157,7 +157,7 @@ aaudio_data_callback_result_t AAudioPlayer::OnDataCallback(void* audio_data,
// Log device id in first data callback to ensure that a valid device is // Log device id in first data callback to ensure that a valid device is
// utilized. // utilized.
if (first_data_callback_) { if (first_data_callback_) {
RTC_LOG(INFO) << "--- First output data callback: " RTC_LOG(LS_INFO) << "--- First output data callback: "
"device id=" "device id="
<< aaudio_.device_id(); << aaudio_.device_id();
first_data_callback_ = false; first_data_callback_ = false;
@ -179,7 +179,7 @@ aaudio_data_callback_result_t AAudioPlayer::OnDataCallback(void* audio_data,
latency_millis_ = aaudio_.EstimateLatencyMillis(); latency_millis_ = aaudio_.EstimateLatencyMillis();
// TODO(henrika): use for development only. // TODO(henrika): use for development only.
if (aaudio_.frames_written() % (1000 * aaudio_.frames_per_burst()) == 0) { if (aaudio_.frames_written() % (1000 * aaudio_.frames_per_burst()) == 0) {
RTC_DLOG(INFO) << "output latency: " << latency_millis_ RTC_DLOG(LS_INFO) << "output latency: " << latency_millis_
<< ", num_frames: " << num_frames; << ", num_frames: " << num_frames;
} }
@ -215,7 +215,7 @@ void AAudioPlayer::OnMessage(rtc::Message* msg) {
void AAudioPlayer::HandleStreamDisconnected() { void AAudioPlayer::HandleStreamDisconnected() {
RTC_DCHECK_RUN_ON(&main_thread_checker_); RTC_DCHECK_RUN_ON(&main_thread_checker_);
RTC_DLOG(INFO) << "HandleStreamDisconnected"; RTC_DLOG(LS_INFO) << "HandleStreamDisconnected";
if (!initialized_ || !playing_) { if (!initialized_ || !playing_) {
return; return;
} }

32
modules/audio_device/android/aaudio_recorder.cc
View File

@ -28,19 +28,19 @@ enum AudioDeviceMessageType : uint32_t {
AAudioRecorder::AAudioRecorder(AudioManager* audio_manager) AAudioRecorder::AAudioRecorder(AudioManager* audio_manager)
: main_thread_(rtc::Thread::Current()), : main_thread_(rtc::Thread::Current()),
aaudio_(audio_manager, AAUDIO_DIRECTION_INPUT, this) { aaudio_(audio_manager, AAUDIO_DIRECTION_INPUT, this) {
RTC_LOG(INFO) << "ctor"; RTC_LOG(LS_INFO) << "ctor";
thread_checker_aaudio_.Detach(); thread_checker_aaudio_.Detach();
} }
AAudioRecorder::~AAudioRecorder() { AAudioRecorder::~AAudioRecorder() {
RTC_LOG(INFO) << "dtor"; RTC_LOG(LS_INFO) << "dtor";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
Terminate(); Terminate();
RTC_LOG(INFO) << "detected owerflows: " << overflow_count_; RTC_LOG(LS_INFO) << "detected owerflows: " << overflow_count_;
} }
int AAudioRecorder::Init() { int AAudioRecorder::Init() {
RTC_LOG(INFO) << "Init"; RTC_LOG(LS_INFO) << "Init";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
if (aaudio_.audio_parameters().channels() == 2) { if (aaudio_.audio_parameters().channels() == 2) {
RTC_DLOG(LS_WARNING) << "Stereo mode is enabled"; RTC_DLOG(LS_WARNING) << "Stereo mode is enabled";
@ -49,14 +49,14 @@ int AAudioRecorder::Init() {
} }
int AAudioRecorder::Terminate() { int AAudioRecorder::Terminate() {
RTC_LOG(INFO) << "Terminate"; RTC_LOG(LS_INFO) << "Terminate";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
StopRecording(); StopRecording();
return 0; return 0;
} }
int AAudioRecorder::InitRecording() { int AAudioRecorder::InitRecording() {
RTC_LOG(INFO) << "InitRecording"; RTC_LOG(LS_INFO) << "InitRecording";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!initialized_); RTC_DCHECK(!initialized_);
RTC_DCHECK(!recording_); RTC_DCHECK(!recording_);
@ -68,7 +68,7 @@ int AAudioRecorder::InitRecording() {
} }
int AAudioRecorder::StartRecording() { int AAudioRecorder::StartRecording() {
RTC_LOG(INFO) << "StartRecording"; RTC_LOG(LS_INFO) << "StartRecording";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(initialized_); RTC_DCHECK(initialized_);
RTC_DCHECK(!recording_); RTC_DCHECK(!recording_);
@ -85,7 +85,7 @@ int AAudioRecorder::StartRecording() {
} }
int AAudioRecorder::StopRecording() { int AAudioRecorder::StopRecording() {
RTC_LOG(INFO) << "StopRecording"; RTC_LOG(LS_INFO) << "StopRecording";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
if (!initialized_ || !recording_) { if (!initialized_ || !recording_) {
return 0; return 0;
@ -100,7 +100,7 @@ int AAudioRecorder::StopRecording() {
} }
void AAudioRecorder::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) { void AAudioRecorder::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
RTC_LOG(INFO) << "AttachAudioBuffer"; RTC_LOG(LS_INFO) << "AttachAudioBuffer";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
audio_device_buffer_ = audioBuffer; audio_device_buffer_ = audioBuffer;
const AudioParameters audio_parameters = aaudio_.audio_parameters(); const AudioParameters audio_parameters = aaudio_.audio_parameters();
@ -114,19 +114,19 @@ void AAudioRecorder::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
} }
int AAudioRecorder::EnableBuiltInAEC(bool enable) { int AAudioRecorder::EnableBuiltInAEC(bool enable) {
RTC_LOG(INFO) << "EnableBuiltInAEC: " << enable; RTC_LOG(LS_INFO) << "EnableBuiltInAEC: " << enable;
RTC_LOG(LS_ERROR) << "Not implemented"; RTC_LOG(LS_ERROR) << "Not implemented";
return -1; return -1;
} }
int AAudioRecorder::EnableBuiltInAGC(bool enable) { int AAudioRecorder::EnableBuiltInAGC(bool enable) {
RTC_LOG(INFO) << "EnableBuiltInAGC: " << enable; RTC_LOG(LS_INFO) << "EnableBuiltInAGC: " << enable;
RTC_LOG(LS_ERROR) << "Not implemented"; RTC_LOG(LS_ERROR) << "Not implemented";
return -1; return -1;
} }
int AAudioRecorder::EnableBuiltInNS(bool enable) { int AAudioRecorder::EnableBuiltInNS(bool enable) {
RTC_LOG(INFO) << "EnableBuiltInNS: " << enable; RTC_LOG(LS_INFO) << "EnableBuiltInNS: " << enable;
RTC_LOG(LS_ERROR) << "Not implemented"; RTC_LOG(LS_ERROR) << "Not implemented";
return -1; return -1;
} }
@ -154,12 +154,12 @@ aaudio_data_callback_result_t AAudioRecorder::OnDataCallback(
int32_t num_frames) { int32_t num_frames) {
// TODO(henrika): figure out why we sometimes hit this one. // TODO(henrika): figure out why we sometimes hit this one.
// RTC_DCHECK(thread_checker_aaudio_.IsCurrent()); // RTC_DCHECK(thread_checker_aaudio_.IsCurrent());
// RTC_LOG(INFO) << "OnDataCallback: " << num_frames; // RTC_LOG(LS_INFO) << "OnDataCallback: " << num_frames;
// Drain the input buffer at first callback to ensure that it does not // Drain the input buffer at first callback to ensure that it does not
// contain any old data. Will also ensure that the lowest possible latency // contain any old data. Will also ensure that the lowest possible latency
// is obtained. // is obtained.
if (first_data_callback_) { if (first_data_callback_) {
RTC_LOG(INFO) << "--- First input data callback: " RTC_LOG(LS_INFO) << "--- First input data callback: "
"device id=" "device id="
<< aaudio_.device_id(); << aaudio_.device_id();
aaudio_.ClearInputStream(audio_data, num_frames); aaudio_.ClearInputStream(audio_data, num_frames);
@ -177,7 +177,7 @@ aaudio_data_callback_result_t AAudioRecorder::OnDataCallback(
latency_millis_ = aaudio_.EstimateLatencyMillis(); latency_millis_ = aaudio_.EstimateLatencyMillis();
// TODO(henrika): use for development only. // TODO(henrika): use for development only.
if (aaudio_.frames_read() % (1000 * aaudio_.frames_per_burst()) == 0) { if (aaudio_.frames_read() % (1000 * aaudio_.frames_per_burst()) == 0) {
RTC_DLOG(INFO) << "input latency: " << latency_millis_ RTC_DLOG(LS_INFO) << "input latency: " << latency_millis_
<< ", num_frames: " << num_frames; << ", num_frames: " << num_frames;
} }
// Copy recorded audio in `audio_data` to the WebRTC sink using the // Copy recorded audio in `audio_data` to the WebRTC sink using the
@ -204,7 +204,7 @@ void AAudioRecorder::OnMessage(rtc::Message* msg) {
void AAudioRecorder::HandleStreamDisconnected() { void AAudioRecorder::HandleStreamDisconnected() {
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RTC_LOG(INFO) << "HandleStreamDisconnected"; RTC_LOG(LS_INFO) << "HandleStreamDisconnected";
if (!initialized_ || !recording_) { if (!initialized_ || !recording_) {
return; return;
} }

40
modules/audio_device/android/aaudio_wrapper.cc
View File

@ -134,23 +134,23 @@ AAudioWrapper::AAudioWrapper(AudioManager* audio_manager,
aaudio_direction_t direction, aaudio_direction_t direction,
AAudioObserverInterface* observer) AAudioObserverInterface* observer)
: direction_(direction), observer_(observer) { : direction_(direction), observer_(observer) {
RTC_LOG(INFO) << "ctor"; RTC_LOG(LS_INFO) << "ctor";
RTC_DCHECK(observer_); RTC_DCHECK(observer_);
direction_ == AAUDIO_DIRECTION_OUTPUT direction_ == AAUDIO_DIRECTION_OUTPUT
? audio_parameters_ = audio_manager->GetPlayoutAudioParameters() ? audio_parameters_ = audio_manager->GetPlayoutAudioParameters()
: audio_parameters_ = audio_manager->GetRecordAudioParameters(); : audio_parameters_ = audio_manager->GetRecordAudioParameters();
aaudio_thread_checker_.Detach(); aaudio_thread_checker_.Detach();
RTC_LOG(INFO) << audio_parameters_.ToString(); RTC_LOG(LS_INFO) << audio_parameters_.ToString();
} }
AAudioWrapper::~AAudioWrapper() { AAudioWrapper::~AAudioWrapper() {
RTC_LOG(INFO) << "dtor"; RTC_LOG(LS_INFO) << "dtor";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!stream_); RTC_DCHECK(!stream_);
} }
bool AAudioWrapper::Init() { bool AAudioWrapper::Init() {
RTC_LOG(INFO) << "Init"; RTC_LOG(LS_INFO) << "Init";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
// Creates a stream builder which can be used to open an audio stream. // Creates a stream builder which can be used to open an audio stream.
ScopedStreamBuilder builder; ScopedStreamBuilder builder;
@ -174,7 +174,7 @@ bool AAudioWrapper::Init() {
} }
bool AAudioWrapper::Start() { bool AAudioWrapper::Start() {
RTC_LOG(INFO) << "Start"; RTC_LOG(LS_INFO) << "Start";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
// TODO(henrika): this state check might not be needed. // TODO(henrika): this state check might not be needed.
aaudio_stream_state_t current_state = AAudioStream_getState(stream_); aaudio_stream_state_t current_state = AAudioStream_getState(stream_);
@ -190,7 +190,7 @@ bool AAudioWrapper::Start() {
} }
bool AAudioWrapper::Stop() { bool AAudioWrapper::Stop() {
RTC_LOG(INFO) << "Stop: " << DirectionToString(direction()); RTC_LOG(LS_INFO) << "Stop: " << DirectionToString(direction());
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
// Asynchronous request for the stream to stop. // Asynchronous request for the stream to stop.
RETURN_ON_ERROR(AAudioStream_requestStop(stream_), false); RETURN_ON_ERROR(AAudioStream_requestStop(stream_), false);
@ -240,7 +240,7 @@ double AAudioWrapper::EstimateLatencyMillis() const {
// Returns new buffer size or a negative error value if buffer size could not // Returns new buffer size or a negative error value if buffer size could not
// be increased. // be increased.
bool AAudioWrapper::IncreaseOutputBufferSize() { bool AAudioWrapper::IncreaseOutputBufferSize() {
RTC_LOG(INFO) << "IncreaseBufferSize"; RTC_LOG(LS_INFO) << "IncreaseBufferSize";
RTC_DCHECK(stream_); RTC_DCHECK(stream_);
RTC_DCHECK(aaudio_thread_checker_.IsCurrent()); RTC_DCHECK(aaudio_thread_checker_.IsCurrent());
RTC_DCHECK_EQ(direction(), AAUDIO_DIRECTION_OUTPUT); RTC_DCHECK_EQ(direction(), AAUDIO_DIRECTION_OUTPUT);
@ -255,7 +255,7 @@ bool AAudioWrapper::IncreaseOutputBufferSize() {
<< ") is higher than max: " << max_buffer_size; << ") is higher than max: " << max_buffer_size;
return false; return false;
} }
RTC_LOG(INFO) << "Updating buffer size to: " << buffer_size RTC_LOG(LS_INFO) << "Updating buffer size to: " << buffer_size
<< " (max=" << max_buffer_size << ")"; << " (max=" << max_buffer_size << ")";
buffer_size = AAudioStream_setBufferSizeInFrames(stream_, buffer_size); buffer_size = AAudioStream_setBufferSizeInFrames(stream_, buffer_size);
if (buffer_size < 0) { if (buffer_size < 0) {
@ -263,12 +263,12 @@ bool AAudioWrapper::IncreaseOutputBufferSize() {
<< AAudio_convertResultToText(buffer_size); << AAudio_convertResultToText(buffer_size);
return false; return false;
} }
RTC_LOG(INFO) << "Buffer size changed to: " << buffer_size; RTC_LOG(LS_INFO) << "Buffer size changed to: " << buffer_size;
return true; return true;
} }
void AAudioWrapper::ClearInputStream(void* audio_data, int32_t num_frames) { void AAudioWrapper::ClearInputStream(void* audio_data, int32_t num_frames) {
RTC_LOG(INFO) << "ClearInputStream"; RTC_LOG(LS_INFO) << "ClearInputStream";
RTC_DCHECK(stream_); RTC_DCHECK(stream_);
RTC_DCHECK(aaudio_thread_checker_.IsCurrent()); RTC_DCHECK(aaudio_thread_checker_.IsCurrent());
RTC_DCHECK_EQ(direction(), AAUDIO_DIRECTION_INPUT); RTC_DCHECK_EQ(direction(), AAUDIO_DIRECTION_INPUT);
@ -357,7 +357,7 @@ int64_t AAudioWrapper::frames_read() const {
} }
void AAudioWrapper::SetStreamConfiguration(AAudioStreamBuilder* builder) { void AAudioWrapper::SetStreamConfiguration(AAudioStreamBuilder* builder) {
RTC_LOG(INFO) << "SetStreamConfiguration"; RTC_LOG(LS_INFO) << "SetStreamConfiguration";
RTC_DCHECK(builder); RTC_DCHECK(builder);
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
// Request usage of default primary output/input device. // Request usage of default primary output/input device.
@ -390,7 +390,7 @@ void AAudioWrapper::SetStreamConfiguration(AAudioStreamBuilder* builder) {
} }
bool AAudioWrapper::OpenStream(AAudioStreamBuilder* builder) { bool AAudioWrapper::OpenStream(AAudioStreamBuilder* builder) {
RTC_LOG(INFO) << "OpenStream"; RTC_LOG(LS_INFO) << "OpenStream";
RTC_DCHECK(builder); RTC_DCHECK(builder);
AAudioStream* stream = nullptr; AAudioStream* stream = nullptr;
RETURN_ON_ERROR(AAudioStreamBuilder_openStream(builder, &stream), false); RETURN_ON_ERROR(AAudioStreamBuilder_openStream(builder, &stream), false);
@ -400,7 +400,7 @@ bool AAudioWrapper::OpenStream(AAudioStreamBuilder* builder) {
} }
void AAudioWrapper::CloseStream() { void AAudioWrapper::CloseStream() {
RTC_LOG(INFO) << "CloseStream"; RTC_LOG(LS_INFO) << "CloseStream";
RTC_DCHECK(stream_); RTC_DCHECK(stream_);
LOG_ON_ERROR(AAudioStream_close(stream_)); LOG_ON_ERROR(AAudioStream_close(stream_));
stream_ = nullptr; stream_ = nullptr;
@ -419,16 +419,16 @@ void AAudioWrapper::LogStreamConfiguration() {
ss << ", direction=" << DirectionToString(direction()); ss << ", direction=" << DirectionToString(direction());
ss << ", device id=" << AAudioStream_getDeviceId(stream_); ss << ", device id=" << AAudioStream_getDeviceId(stream_);
ss << ", frames per callback=" << frames_per_callback(); ss << ", frames per callback=" << frames_per_callback();
RTC_LOG(INFO) << ss.str(); RTC_LOG(LS_INFO) << ss.str();
} }
void AAudioWrapper::LogStreamState() { void AAudioWrapper::LogStreamState() {
RTC_LOG(INFO) << "AAudio stream state: " RTC_LOG(LS_INFO) << "AAudio stream state: "
<< AAudio_convertStreamStateToText(stream_state()); << AAudio_convertStreamStateToText(stream_state());
} }
bool AAudioWrapper::VerifyStreamConfiguration() { bool AAudioWrapper::VerifyStreamConfiguration() {
RTC_LOG(INFO) << "VerifyStreamConfiguration"; RTC_LOG(LS_INFO) << "VerifyStreamConfiguration";
RTC_DCHECK(stream_); RTC_DCHECK(stream_);
// TODO(henrika): should we verify device ID as well? // TODO(henrika): should we verify device ID as well?
if (AAudioStream_getSampleRate(stream_) != audio_parameters().sample_rate()) { if (AAudioStream_getSampleRate(stream_) != audio_parameters().sample_rate()) {
@ -466,15 +466,15 @@ bool AAudioWrapper::VerifyStreamConfiguration() {
} }
bool AAudioWrapper::OptimizeBuffers() { bool AAudioWrapper::OptimizeBuffers() {
RTC_LOG(INFO) << "OptimizeBuffers"; RTC_LOG(LS_INFO) << "OptimizeBuffers";
RTC_DCHECK(stream_); RTC_DCHECK(stream_);
// Maximum number of frames that can be filled without blocking. // Maximum number of frames that can be filled without blocking.
RTC_LOG(INFO) << "max buffer capacity in frames: " RTC_LOG(LS_INFO) << "max buffer capacity in frames: "
<< buffer_capacity_in_frames(); << buffer_capacity_in_frames();
// Query the number of frames that the application should read or write at // Query the number of frames that the application should read or write at
// one time for optimal performance. // one time for optimal performance.
int32_t frames_per_burst = AAudioStream_getFramesPerBurst(stream_); int32_t frames_per_burst = AAudioStream_getFramesPerBurst(stream_);
RTC_LOG(INFO) << "frames per burst for optimal performance: " RTC_LOG(LS_INFO) << "frames per burst for optimal performance: "
<< frames_per_burst; << frames_per_burst;
frames_per_burst_ = frames_per_burst; frames_per_burst_ = frames_per_burst;
if (direction() == AAUDIO_DIRECTION_INPUT) { if (direction() == AAUDIO_DIRECTION_INPUT) {
@ -492,7 +492,7 @@ bool AAudioWrapper::OptimizeBuffers() {
return false; return false;
} }
// Maximum number of frames that can be filled without blocking. // Maximum number of frames that can be filled without blocking.
RTC_LOG(INFO) << "buffer burst size in frames: " << buffer_size; RTC_LOG(LS_INFO) << "buffer burst size in frames: " << buffer_size;
return true; return true;
} }

84
modules/audio_device/android/audio_device_template.h
View File

@ -39,22 +39,22 @@ class AudioDeviceTemplate : public AudioDeviceGeneric {
output_(audio_manager_), output_(audio_manager_),
input_(audio_manager_), input_(audio_manager_),
initialized_(false) { initialized_(false) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_CHECK(audio_manager); RTC_CHECK(audio_manager);
audio_manager_->SetActiveAudioLayer(audio_layer); audio_manager_->SetActiveAudioLayer(audio_layer);
} }
virtual ~AudioDeviceTemplate() { RTC_LOG(INFO) << __FUNCTION__; } virtual ~AudioDeviceTemplate() { RTC_LOG(LS_INFO) << __FUNCTION__; }
int32_t ActiveAudioLayer( int32_t ActiveAudioLayer(
AudioDeviceModule::AudioLayer& audioLayer) const override { AudioDeviceModule::AudioLayer& audioLayer) const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
audioLayer = audio_layer_; audioLayer = audio_layer_;
return 0; return 0;
} }
InitStatus Init() override { InitStatus Init() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!initialized_); RTC_DCHECK(!initialized_);
if (!audio_manager_->Init()) { if (!audio_manager_->Init()) {
@ -74,7 +74,7 @@ class AudioDeviceTemplate : public AudioDeviceGeneric {
} }
int32_t Terminate() override { int32_t Terminate() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
int32_t err = input_.Terminate(); int32_t err = input_.Terminate();
err |= output_.Terminate(); err |= output_.Terminate();
@ -85,18 +85,18 @@ class AudioDeviceTemplate : public AudioDeviceGeneric {
} }
bool Initialized() const override { bool Initialized() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
return initialized_; return initialized_;
} }
int16_t PlayoutDevices() override { int16_t PlayoutDevices() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return 1; return 1;
} }
int16_t RecordingDevices() override { int16_t RecordingDevices() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return 1; return 1;
} }
@ -115,7 +115,7 @@ class AudioDeviceTemplate : public AudioDeviceGeneric {
int32_t SetPlayoutDevice(uint16_t index) override { int32_t SetPlayoutDevice(uint16_t index) override {
// OK to use but it has no effect currently since device selection is // OK to use but it has no effect currently since device selection is
// done using Andoid APIs instead. // done using Andoid APIs instead.
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return 0; return 0;
} }
@ -127,7 +127,7 @@ class AudioDeviceTemplate : public AudioDeviceGeneric {
int32_t SetRecordingDevice(uint16_t index) override { int32_t SetRecordingDevice(uint16_t index) override {
// OK to use but it has no effect currently since device selection is // OK to use but it has no effect currently since device selection is
// done using Andoid APIs instead. // done using Andoid APIs instead.
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return 0; return 0;
} }
@ -137,39 +137,39 @@ class AudioDeviceTemplate : public AudioDeviceGeneric {
} }
int32_t PlayoutIsAvailable(bool& available) override { int32_t PlayoutIsAvailable(bool& available) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
available = true; available = true;
return 0; return 0;
} }
int32_t InitPlayout() override { int32_t InitPlayout() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return output_.InitPlayout(); return output_.InitPlayout();
} }
bool PlayoutIsInitialized() const override { bool PlayoutIsInitialized() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return output_.PlayoutIsInitialized(); return output_.PlayoutIsInitialized();
} }
int32_t RecordingIsAvailable(bool& available) override { int32_t RecordingIsAvailable(bool& available) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
available = true; available = true;
return 0; return 0;
} }
int32_t InitRecording() override { int32_t InitRecording() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return input_.InitRecording(); return input_.InitRecording();
} }
bool RecordingIsInitialized() const override { bool RecordingIsInitialized() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return input_.RecordingIsInitialized(); return input_.RecordingIsInitialized();
} }
int32_t StartPlayout() override { int32_t StartPlayout() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
if (!audio_manager_->IsCommunicationModeEnabled()) { if (!audio_manager_->IsCommunicationModeEnabled()) {
RTC_LOG(WARNING) RTC_LOG(WARNING)
<< "The application should use MODE_IN_COMMUNICATION audio mode!"; << "The application should use MODE_IN_COMMUNICATION audio mode!";
@ -181,18 +181,18 @@ class AudioDeviceTemplate : public AudioDeviceGeneric {
// Avoid using audio manger (JNI/Java cost) if playout was inactive. // Avoid using audio manger (JNI/Java cost) if playout was inactive.
if (!Playing()) if (!Playing())
return 0; return 0;
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
int32_t err = output_.StopPlayout(); int32_t err = output_.StopPlayout();
return err; return err;
} }
bool Playing() const override { bool Playing() const override {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
return output_.Playing(); return output_.Playing();
} }
int32_t StartRecording() override { int32_t StartRecording() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
if (!audio_manager_->IsCommunicationModeEnabled()) { if (!audio_manager_->IsCommunicationModeEnabled()) {
RTC_LOG(WARNING) RTC_LOG(WARNING)
<< "The application should use MODE_IN_COMMUNICATION audio mode!"; << "The application should use MODE_IN_COMMUNICATION audio mode!";
@ -202,7 +202,7 @@ class AudioDeviceTemplate : public AudioDeviceGeneric {
int32_t StopRecording() override { int32_t StopRecording() override {
// Avoid using audio manger (JNI/Java cost) if recording was inactive. // Avoid using audio manger (JNI/Java cost) if recording was inactive.
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
if (!Recording()) if (!Recording())
return 0; return 0;
int32_t err = input_.StopRecording(); int32_t err = input_.StopRecording();
@ -212,47 +212,47 @@ class AudioDeviceTemplate : public AudioDeviceGeneric {
bool Recording() const override { return input_.Recording(); } bool Recording() const override { return input_.Recording(); }
int32_t InitSpeaker() override { int32_t InitSpeaker() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return 0; return 0;
} }
bool SpeakerIsInitialized() const override { bool SpeakerIsInitialized() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return true; return true;
} }
int32_t InitMicrophone() override { int32_t InitMicrophone() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return 0; return 0;
} }
bool MicrophoneIsInitialized() const override { bool MicrophoneIsInitialized() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return true; return true;
} }
int32_t SpeakerVolumeIsAvailable(bool& available) override { int32_t SpeakerVolumeIsAvailable(bool& available) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return output_.SpeakerVolumeIsAvailable(available); return output_.SpeakerVolumeIsAvailable(available);
} }
int32_t SetSpeakerVolume(uint32_t volume) override { int32_t SetSpeakerVolume(uint32_t volume) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return output_.SetSpeakerVolume(volume); return output_.SetSpeakerVolume(volume);
} }
int32_t SpeakerVolume(uint32_t& volume) const override { int32_t SpeakerVolume(uint32_t& volume) const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return output_.SpeakerVolume(volume); return output_.SpeakerVolume(volume);
} }
int32_t MaxSpeakerVolume(uint32_t& maxVolume) const override { int32_t MaxSpeakerVolume(uint32_t& maxVolume) const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return output_.MaxSpeakerVolume(maxVolume); return output_.MaxSpeakerVolume(maxVolume);
} }
int32_t MinSpeakerVolume(uint32_t& minVolume) const override { int32_t MinSpeakerVolume(uint32_t& minVolume) const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return output_.MinSpeakerVolume(minVolume); return output_.MinSpeakerVolume(minVolume);
} }
@ -299,13 +299,13 @@ class AudioDeviceTemplate : public AudioDeviceGeneric {
// Returns true if the audio manager has been configured to support stereo // Returns true if the audio manager has been configured to support stereo
// and false otherwised. Default is mono. // and false otherwised. Default is mono.
int32_t StereoPlayoutIsAvailable(bool& available) override { int32_t StereoPlayoutIsAvailable(bool& available) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
available = audio_manager_->IsStereoPlayoutSupported(); available = audio_manager_->IsStereoPlayoutSupported();
return 0; return 0;
} }
int32_t SetStereoPlayout(bool enable) override { int32_t SetStereoPlayout(bool enable) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
bool available = audio_manager_->IsStereoPlayoutSupported(); bool available = audio_manager_->IsStereoPlayoutSupported();
// Android does not support changes between mono and stero on the fly. // Android does not support changes between mono and stero on the fly.
// Instead, the native audio layer is configured via the audio manager // Instead, the native audio layer is configured via the audio manager
@ -320,13 +320,13 @@ class AudioDeviceTemplate : public AudioDeviceGeneric {
} }
int32_t StereoRecordingIsAvailable(bool& available) override { int32_t StereoRecordingIsAvailable(bool& available) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
available = audio_manager_->IsStereoRecordSupported(); available = audio_manager_->IsStereoRecordSupported();
return 0; return 0;
} }
int32_t SetStereoRecording(bool enable) override { int32_t SetStereoRecording(bool enable) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
bool available = audio_manager_->IsStereoRecordSupported(); bool available = audio_manager_->IsStereoRecordSupported();
// Android does not support changes between mono and stero on the fly. // Android does not support changes between mono and stero on the fly.
// Instead, the native audio layer is configured via the audio manager // Instead, the native audio layer is configured via the audio manager
@ -336,7 +336,7 @@ class AudioDeviceTemplate : public AudioDeviceGeneric {
} }
int32_t StereoRecording(bool& enabled) const override { int32_t StereoRecording(bool& enabled) const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
enabled = audio_manager_->IsStereoRecordSupported(); enabled = audio_manager_->IsStereoRecordSupported();
return 0; return 0;
} }
@ -349,7 +349,7 @@ class AudioDeviceTemplate : public AudioDeviceGeneric {
} }
void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) override { void AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
output_.AttachAudioBuffer(audioBuffer); output_.AttachAudioBuffer(audioBuffer);
input_.AttachAudioBuffer(audioBuffer); input_.AttachAudioBuffer(audioBuffer);
} }
@ -367,13 +367,13 @@ class AudioDeviceTemplate : public AudioDeviceGeneric {
// a "Not Implemented" log will be filed. This non-perfect state will remain // a "Not Implemented" log will be filed. This non-perfect state will remain
// until I have added full support for audio effects based on OpenSL ES APIs. // until I have added full support for audio effects based on OpenSL ES APIs.
bool BuiltInAECIsAvailable() const override { bool BuiltInAECIsAvailable() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return audio_manager_->IsAcousticEchoCancelerSupported(); return audio_manager_->IsAcousticEchoCancelerSupported();
} }
// TODO(henrika): add implementation for OpenSL ES based audio as well. // TODO(henrika): add implementation for OpenSL ES based audio as well.
int32_t EnableBuiltInAEC(bool enable) override { int32_t EnableBuiltInAEC(bool enable) override {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
RTC_CHECK(BuiltInAECIsAvailable()) << "HW AEC is not available"; RTC_CHECK(BuiltInAECIsAvailable()) << "HW AEC is not available";
return input_.EnableBuiltInAEC(enable); return input_.EnableBuiltInAEC(enable);
} }
@ -383,13 +383,13 @@ class AudioDeviceTemplate : public AudioDeviceGeneric {
// TODO(henrika): add implementation for OpenSL ES based audio as well. // TODO(henrika): add implementation for OpenSL ES based audio as well.
// In addition, see comments for BuiltInAECIsAvailable(). // In addition, see comments for BuiltInAECIsAvailable().
bool BuiltInAGCIsAvailable() const override { bool BuiltInAGCIsAvailable() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return audio_manager_->IsAutomaticGainControlSupported(); return audio_manager_->IsAutomaticGainControlSupported();
} }
// TODO(henrika): add implementation for OpenSL ES based audio as well. // TODO(henrika): add implementation for OpenSL ES based audio as well.
int32_t EnableBuiltInAGC(bool enable) override { int32_t EnableBuiltInAGC(bool enable) override {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
RTC_CHECK(BuiltInAGCIsAvailable()) << "HW AGC is not available"; RTC_CHECK(BuiltInAGCIsAvailable()) << "HW AGC is not available";
return input_.EnableBuiltInAGC(enable); return input_.EnableBuiltInAGC(enable);
} }
@ -399,13 +399,13 @@ class AudioDeviceTemplate : public AudioDeviceGeneric {
// TODO(henrika): add implementation for OpenSL ES based audio as well. // TODO(henrika): add implementation for OpenSL ES based audio as well.
// In addition, see comments for BuiltInAECIsAvailable(). // In addition, see comments for BuiltInAECIsAvailable().
bool BuiltInNSIsAvailable() const override { bool BuiltInNSIsAvailable() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return audio_manager_->IsNoiseSuppressorSupported(); return audio_manager_->IsNoiseSuppressorSupported();
} }
// TODO(henrika): add implementation for OpenSL ES based audio as well. // TODO(henrika): add implementation for OpenSL ES based audio as well.
int32_t EnableBuiltInNS(bool enable) override { int32_t EnableBuiltInNS(bool enable) override {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
RTC_CHECK(BuiltInNSIsAvailable()) << "HW NS is not available"; RTC_CHECK(BuiltInNSIsAvailable()) << "HW NS is not available";
return input_.EnableBuiltInNS(enable); return input_.EnableBuiltInNS(enable);
} }

22
modules/audio_device/android/audio_manager.cc
View File

@ -33,11 +33,11 @@ AudioManager::JavaAudioManager::JavaAudioManager(
is_device_blacklisted_for_open_sles_usage_( is_device_blacklisted_for_open_sles_usage_(
native_reg->GetMethodId("isDeviceBlacklistedForOpenSLESUsage", native_reg->GetMethodId("isDeviceBlacklistedForOpenSLESUsage",
"()Z")) { "()Z")) {
RTC_LOG(INFO) << "JavaAudioManager::ctor"; RTC_LOG(LS_INFO) << "JavaAudioManager::ctor";
} }
AudioManager::JavaAudioManager::~JavaAudioManager() { AudioManager::JavaAudioManager::~JavaAudioManager() {
RTC_LOG(INFO) << "JavaAudioManager::~dtor"; RTC_LOG(LS_INFO) << "JavaAudioManager::~dtor";
} }
bool AudioManager::JavaAudioManager::Init() { bool AudioManager::JavaAudioManager::Init() {
@ -68,7 +68,7 @@ AudioManager::AudioManager()
low_latency_playout_(false), low_latency_playout_(false),
low_latency_record_(false), low_latency_record_(false),
delay_estimate_in_milliseconds_(0) { delay_estimate_in_milliseconds_(0) {
RTC_LOG(INFO) << "ctor"; RTC_LOG(LS_INFO) << "ctor";
RTC_CHECK(j_environment_); RTC_CHECK(j_environment_);
JNINativeMethod native_methods[] = { JNINativeMethod native_methods[] = {
{"nativeCacheAudioParameters", "(IIIZZZZZZZIIJ)V", {"nativeCacheAudioParameters", "(IIIZZZZZZZIIJ)V",
@ -83,14 +83,14 @@ AudioManager::AudioManager()
} }
AudioManager::~AudioManager() { AudioManager::~AudioManager() {
RTC_LOG(INFO) << "dtor"; RTC_LOG(LS_INFO) << "dtor";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
Close(); Close();
} }
void AudioManager::SetActiveAudioLayer( void AudioManager::SetActiveAudioLayer(
AudioDeviceModule::AudioLayer audio_layer) { AudioDeviceModule::AudioLayer audio_layer) {
RTC_LOG(INFO) << "SetActiveAudioLayer: " << audio_layer; RTC_LOG(LS_INFO) << "SetActiveAudioLayer: " << audio_layer;
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!initialized_); RTC_DCHECK(!initialized_);
// Store the currently utilized audio layer. // Store the currently utilized audio layer.
@ -103,18 +103,18 @@ void AudioManager::SetActiveAudioLayer(
(audio_layer == AudioDeviceModule::kAndroidJavaAudio) (audio_layer == AudioDeviceModule::kAndroidJavaAudio)
? kHighLatencyModeDelayEstimateInMilliseconds ? kHighLatencyModeDelayEstimateInMilliseconds
: kLowLatencyModeDelayEstimateInMilliseconds; : kLowLatencyModeDelayEstimateInMilliseconds;
RTC_LOG(INFO) << "delay_estimate_in_milliseconds: " RTC_LOG(LS_INFO) << "delay_estimate_in_milliseconds: "
<< delay_estimate_in_milliseconds_; << delay_estimate_in_milliseconds_;
} }
SLObjectItf AudioManager::GetOpenSLEngine() { SLObjectItf AudioManager::GetOpenSLEngine() {
RTC_LOG(INFO) << "GetOpenSLEngine"; RTC_LOG(LS_INFO) << "GetOpenSLEngine";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
// Only allow usage of OpenSL ES if such an audio layer has been specified. // Only allow usage of OpenSL ES if such an audio layer has been specified.
if (audio_layer_ != AudioDeviceModule::kAndroidOpenSLESAudio && if (audio_layer_ != AudioDeviceModule::kAndroidOpenSLESAudio &&
audio_layer_ != audio_layer_ !=
AudioDeviceModule::kAndroidJavaInputAndOpenSLESOutputAudio) { AudioDeviceModule::kAndroidJavaInputAndOpenSLESOutputAudio) {
RTC_LOG(INFO) RTC_LOG(LS_INFO)
<< "Unable to create OpenSL engine for the current audio layer: " << "Unable to create OpenSL engine for the current audio layer: "
<< audio_layer_; << audio_layer_;
return nullptr; return nullptr;
@ -149,7 +149,7 @@ SLObjectItf AudioManager::GetOpenSLEngine() {
} }
bool AudioManager::Init() { bool AudioManager::Init() {
RTC_LOG(INFO) << "Init"; RTC_LOG(LS_INFO) << "Init";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!initialized_); RTC_DCHECK(!initialized_);
RTC_DCHECK_NE(audio_layer_, AudioDeviceModule::kPlatformDefaultAudio); RTC_DCHECK_NE(audio_layer_, AudioDeviceModule::kPlatformDefaultAudio);
@ -162,7 +162,7 @@ bool AudioManager::Init() {
} }
bool AudioManager::Close() { bool AudioManager::Close() {
RTC_LOG(INFO) << "Close"; RTC_LOG(LS_INFO) << "Close";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
if (!initialized_) if (!initialized_)
return true; return true;
@ -273,7 +273,7 @@ void AudioManager::OnCacheAudioParameters(JNIEnv* env,
jboolean a_audio, jboolean a_audio,
jint output_buffer_size, jint output_buffer_size,
jint input_buffer_size) { jint input_buffer_size) {
RTC_LOG(INFO) RTC_LOG(LS_INFO)
<< "OnCacheAudioParameters: " << "OnCacheAudioParameters: "
"hardware_aec: " "hardware_aec: "
<< static_cast<bool>(hardware_aec) << static_cast<bool>(hardware_aec)

36
modules/audio_device/android/audio_record_jni.cc
View File

@ -34,7 +34,7 @@ class ScopedHistogramTimer {
~ScopedHistogramTimer() { ~ScopedHistogramTimer() {
const int64_t life_time_ms = rtc::TimeSince(start_time_ms_); const int64_t life_time_ms = rtc::TimeSince(start_time_ms_);
RTC_HISTOGRAM_COUNTS_1000(histogram_name_, life_time_ms); RTC_HISTOGRAM_COUNTS_1000(histogram_name_, life_time_ms);
RTC_LOG(INFO) << histogram_name_ << ": " << life_time_ms; RTC_LOG(LS_INFO) << histogram_name_ << ": " << life_time_ms;
} }
private: private:
@ -93,7 +93,7 @@ AudioRecordJni::AudioRecordJni(AudioManager* audio_manager)
initialized_(false), initialized_(false),
recording_(false), recording_(false),
audio_device_buffer_(nullptr) { audio_device_buffer_(nullptr) {
RTC_LOG(INFO) << "ctor"; RTC_LOG(LS_INFO) << "ctor";
RTC_DCHECK(audio_parameters_.is_valid()); RTC_DCHECK(audio_parameters_.is_valid());
RTC_CHECK(j_environment_); RTC_CHECK(j_environment_);
JNINativeMethod native_methods[] = { JNINativeMethod native_methods[] = {
@ -115,26 +115,26 @@ AudioRecordJni::AudioRecordJni(AudioManager* audio_manager)
} }
AudioRecordJni::~AudioRecordJni() { AudioRecordJni::~AudioRecordJni() {
RTC_LOG(INFO) << "dtor"; RTC_LOG(LS_INFO) << "dtor";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
Terminate(); Terminate();
} }
int32_t AudioRecordJni::Init() { int32_t AudioRecordJni::Init() {
RTC_LOG(INFO) << "Init"; RTC_LOG(LS_INFO) << "Init";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
return 0; return 0;
} }
int32_t AudioRecordJni::Terminate() { int32_t AudioRecordJni::Terminate() {
RTC_LOG(INFO) << "Terminate"; RTC_LOG(LS_INFO) << "Terminate";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
StopRecording(); StopRecording();
return 0; return 0;
} }
int32_t AudioRecordJni::InitRecording() { int32_t AudioRecordJni::InitRecording() {
RTC_LOG(INFO) << "InitRecording"; RTC_LOG(LS_INFO) << "InitRecording";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!initialized_); RTC_DCHECK(!initialized_);
RTC_DCHECK(!recording_); RTC_DCHECK(!recording_);
@ -147,7 +147,7 @@ int32_t AudioRecordJni::InitRecording() {
return -1; return -1;
} }
frames_per_buffer_ = static_cast<size_t>(frames_per_buffer); frames_per_buffer_ = static_cast<size_t>(frames_per_buffer);
RTC_LOG(INFO) << "frames_per_buffer: " << frames_per_buffer_; RTC_LOG(LS_INFO) << "frames_per_buffer: " << frames_per_buffer_;
const size_t bytes_per_frame = audio_parameters_.channels() * sizeof(int16_t); const size_t bytes_per_frame = audio_parameters_.channels() * sizeof(int16_t);
RTC_CHECK_EQ(direct_buffer_capacity_in_bytes_, RTC_CHECK_EQ(direct_buffer_capacity_in_bytes_,
frames_per_buffer_ * bytes_per_frame); frames_per_buffer_ * bytes_per_frame);
@ -157,7 +157,7 @@ int32_t AudioRecordJni::InitRecording() {
} }
int32_t AudioRecordJni::StartRecording() { int32_t AudioRecordJni::StartRecording() {
RTC_LOG(INFO) << "StartRecording"; RTC_LOG(LS_INFO) << "StartRecording";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!recording_); RTC_DCHECK(!recording_);
if (!initialized_) { if (!initialized_) {
@ -175,7 +175,7 @@ int32_t AudioRecordJni::StartRecording() {
} }
int32_t AudioRecordJni::StopRecording() { int32_t AudioRecordJni::StopRecording() {
RTC_LOG(INFO) << "StopRecording"; RTC_LOG(LS_INFO) << "StopRecording";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
if (!initialized_ || !recording_) { if (!initialized_ || !recording_) {
return 0; return 0;
@ -195,24 +195,24 @@ int32_t AudioRecordJni::StopRecording() {
} }
void AudioRecordJni::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) { void AudioRecordJni::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
RTC_LOG(INFO) << "AttachAudioBuffer"; RTC_LOG(LS_INFO) << "AttachAudioBuffer";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
audio_device_buffer_ = audioBuffer; audio_device_buffer_ = audioBuffer;
const int sample_rate_hz = audio_parameters_.sample_rate(); const int sample_rate_hz = audio_parameters_.sample_rate();
RTC_LOG(INFO) << "SetRecordingSampleRate(" << sample_rate_hz << ")"; RTC_LOG(LS_INFO) << "SetRecordingSampleRate(" << sample_rate_hz << ")";
audio_device_buffer_->SetRecordingSampleRate(sample_rate_hz); audio_device_buffer_->SetRecordingSampleRate(sample_rate_hz);
const size_t channels = audio_parameters_.channels(); const size_t channels = audio_parameters_.channels();
RTC_LOG(INFO) << "SetRecordingChannels(" << channels << ")"; RTC_LOG(LS_INFO) << "SetRecordingChannels(" << channels << ")";
audio_device_buffer_->SetRecordingChannels(channels); audio_device_buffer_->SetRecordingChannels(channels);
total_delay_in_milliseconds_ = total_delay_in_milliseconds_ =
audio_manager_->GetDelayEstimateInMilliseconds(); audio_manager_->GetDelayEstimateInMilliseconds();
RTC_DCHECK_GT(total_delay_in_milliseconds_, 0); RTC_DCHECK_GT(total_delay_in_milliseconds_, 0);
RTC_LOG(INFO) << "total_delay_in_milliseconds: " RTC_LOG(LS_INFO) << "total_delay_in_milliseconds: "
<< total_delay_in_milliseconds_; << total_delay_in_milliseconds_;
} }
int32_t AudioRecordJni::EnableBuiltInAEC(bool enable) { int32_t AudioRecordJni::EnableBuiltInAEC(bool enable) {
RTC_LOG(INFO) << "EnableBuiltInAEC(" << enable << ")"; RTC_LOG(LS_INFO) << "EnableBuiltInAEC(" << enable << ")";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
return j_audio_record_->EnableBuiltInAEC(enable) ? 0 : -1; return j_audio_record_->EnableBuiltInAEC(enable) ? 0 : -1;
} }
@ -223,7 +223,7 @@ int32_t AudioRecordJni::EnableBuiltInAGC(bool enable) {
} }
int32_t AudioRecordJni::EnableBuiltInNS(bool enable) { int32_t AudioRecordJni::EnableBuiltInNS(bool enable) {
RTC_LOG(INFO) << "EnableBuiltInNS(" << enable << ")"; RTC_LOG(LS_INFO) << "EnableBuiltInNS(" << enable << ")";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
return j_audio_record_->EnableBuiltInNS(enable) ? 0 : -1; return j_audio_record_->EnableBuiltInNS(enable) ? 0 : -1;
} }
@ -240,12 +240,12 @@ void JNICALL AudioRecordJni::CacheDirectBufferAddress(JNIEnv* env,
void AudioRecordJni::OnCacheDirectBufferAddress(JNIEnv* env, void AudioRecordJni::OnCacheDirectBufferAddress(JNIEnv* env,
jobject byte_buffer) { jobject byte_buffer) {
RTC_LOG(INFO) << "OnCacheDirectBufferAddress"; RTC_LOG(LS_INFO) << "OnCacheDirectBufferAddress";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!direct_buffer_address_); RTC_DCHECK(!direct_buffer_address_);
direct_buffer_address_ = env->GetDirectBufferAddress(byte_buffer); direct_buffer_address_ = env->GetDirectBufferAddress(byte_buffer);
jlong capacity = env->GetDirectBufferCapacity(byte_buffer); jlong capacity = env->GetDirectBufferCapacity(byte_buffer);
RTC_LOG(INFO) << "direct buffer capacity: " << capacity; RTC_LOG(LS_INFO) << "direct buffer capacity: " << capacity;
direct_buffer_capacity_in_bytes_ = static_cast<size_t>(capacity); direct_buffer_capacity_in_bytes_ = static_cast<size_t>(capacity);
} }
@ -274,7 +274,7 @@ void AudioRecordJni::OnDataIsRecorded(int length) {
// of `playDelayMs` and `recDelayMs`, hence the distributions does not matter. // of `playDelayMs` and `recDelayMs`, hence the distributions does not matter.
audio_device_buffer_->SetVQEData(total_delay_in_milliseconds_, 0); audio_device_buffer_->SetVQEData(total_delay_in_milliseconds_, 0);
if (audio_device_buffer_->DeliverRecordedData() == -1) { if (audio_device_buffer_->DeliverRecordedData() == -1) {
RTC_LOG(INFO) << "AudioDeviceBuffer::DeliverRecordedData failed"; RTC_LOG(LS_INFO) << "AudioDeviceBuffer::DeliverRecordedData failed";
} }
} }

30
modules/audio_device/android/audio_track_jni.cc
View File

@ -103,7 +103,7 @@ AudioTrackJni::AudioTrackJni(AudioManager* audio_manager)
initialized_(false), initialized_(false),
playing_(false), playing_(false),
audio_device_buffer_(nullptr) { audio_device_buffer_(nullptr) {
RTC_LOG(INFO) << "ctor"; RTC_LOG(LS_INFO) << "ctor";
RTC_DCHECK(audio_parameters_.is_valid()); RTC_DCHECK(audio_parameters_.is_valid());
RTC_CHECK(j_environment_); RTC_CHECK(j_environment_);
JNINativeMethod native_methods[] = { JNINativeMethod native_methods[] = {
@ -125,26 +125,26 @@ AudioTrackJni::AudioTrackJni(AudioManager* audio_manager)
} }
AudioTrackJni::~AudioTrackJni() { AudioTrackJni::~AudioTrackJni() {
RTC_LOG(INFO) << "dtor"; RTC_LOG(LS_INFO) << "dtor";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
Terminate(); Terminate();
} }
int32_t AudioTrackJni::Init() { int32_t AudioTrackJni::Init() {
RTC_LOG(INFO) << "Init"; RTC_LOG(LS_INFO) << "Init";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
return 0; return 0;
} }
int32_t AudioTrackJni::Terminate() { int32_t AudioTrackJni::Terminate() {
RTC_LOG(INFO) << "Terminate"; RTC_LOG(LS_INFO) << "Terminate";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
StopPlayout(); StopPlayout();
return 0; return 0;
} }
int32_t AudioTrackJni::InitPlayout() { int32_t AudioTrackJni::InitPlayout() {
RTC_LOG(INFO) << "InitPlayout"; RTC_LOG(LS_INFO) << "InitPlayout";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!initialized_); RTC_DCHECK(!initialized_);
RTC_DCHECK(!playing_); RTC_DCHECK(!playing_);
@ -158,7 +158,7 @@ int32_t AudioTrackJni::InitPlayout() {
} }
int32_t AudioTrackJni::StartPlayout() { int32_t AudioTrackJni::StartPlayout() {
RTC_LOG(INFO) << "StartPlayout"; RTC_LOG(LS_INFO) << "StartPlayout";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!playing_); RTC_DCHECK(!playing_);
if (!initialized_) { if (!initialized_) {
@ -175,7 +175,7 @@ int32_t AudioTrackJni::StartPlayout() {
} }
int32_t AudioTrackJni::StopPlayout() { int32_t AudioTrackJni::StopPlayout() {
RTC_LOG(INFO) << "StopPlayout"; RTC_LOG(LS_INFO) << "StopPlayout";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
if (!initialized_ || !playing_) { if (!initialized_ || !playing_) {
return 0; return 0;
@ -200,7 +200,7 @@ int AudioTrackJni::SpeakerVolumeIsAvailable(bool& available) {
} }
int AudioTrackJni::SetSpeakerVolume(uint32_t volume) { int AudioTrackJni::SetSpeakerVolume(uint32_t volume) {
RTC_LOG(INFO) << "SetSpeakerVolume(" << volume << ")"; RTC_LOG(LS_INFO) << "SetSpeakerVolume(" << volume << ")";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
return j_audio_track_->SetStreamVolume(volume) ? 0 : -1; return j_audio_track_->SetStreamVolume(volume) ? 0 : -1;
} }
@ -220,20 +220,20 @@ int AudioTrackJni::MinSpeakerVolume(uint32_t& min_volume) const {
int AudioTrackJni::SpeakerVolume(uint32_t& volume) const { int AudioTrackJni::SpeakerVolume(uint32_t& volume) const {
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
volume = j_audio_track_->GetStreamVolume(); volume = j_audio_track_->GetStreamVolume();
RTC_LOG(INFO) << "SpeakerVolume: " << volume; RTC_LOG(LS_INFO) << "SpeakerVolume: " << volume;
return 0; return 0;
} }
// TODO(henrika): possibly add stereo support. // TODO(henrika): possibly add stereo support.
void AudioTrackJni::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) { void AudioTrackJni::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
RTC_LOG(INFO) << "AttachAudioBuffer"; RTC_LOG(LS_INFO) << "AttachAudioBuffer";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
audio_device_buffer_ = audioBuffer; audio_device_buffer_ = audioBuffer;
const int sample_rate_hz = audio_parameters_.sample_rate(); const int sample_rate_hz = audio_parameters_.sample_rate();
RTC_LOG(INFO) << "SetPlayoutSampleRate(" << sample_rate_hz << ")"; RTC_LOG(LS_INFO) << "SetPlayoutSampleRate(" << sample_rate_hz << ")";
audio_device_buffer_->SetPlayoutSampleRate(sample_rate_hz); audio_device_buffer_->SetPlayoutSampleRate(sample_rate_hz);
const size_t channels = audio_parameters_.channels(); const size_t channels = audio_parameters_.channels();
RTC_LOG(INFO) << "SetPlayoutChannels(" << channels << ")"; RTC_LOG(LS_INFO) << "SetPlayoutChannels(" << channels << ")";
audio_device_buffer_->SetPlayoutChannels(channels); audio_device_buffer_->SetPlayoutChannels(channels);
} }
@ -249,16 +249,16 @@ void JNICALL AudioTrackJni::CacheDirectBufferAddress(JNIEnv* env,
void AudioTrackJni::OnCacheDirectBufferAddress(JNIEnv* env, void AudioTrackJni::OnCacheDirectBufferAddress(JNIEnv* env,
jobject byte_buffer) { jobject byte_buffer) {
RTC_LOG(INFO) << "OnCacheDirectBufferAddress"; RTC_LOG(LS_INFO) << "OnCacheDirectBufferAddress";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!direct_buffer_address_); RTC_DCHECK(!direct_buffer_address_);
direct_buffer_address_ = env->GetDirectBufferAddress(byte_buffer); direct_buffer_address_ = env->GetDirectBufferAddress(byte_buffer);
jlong capacity = env->GetDirectBufferCapacity(byte_buffer); jlong capacity = env->GetDirectBufferCapacity(byte_buffer);
RTC_LOG(INFO) << "direct buffer capacity: " << capacity; RTC_LOG(LS_INFO) << "direct buffer capacity: " << capacity;
direct_buffer_capacity_in_bytes_ = static_cast<size_t>(capacity); direct_buffer_capacity_in_bytes_ = static_cast<size_t>(capacity);
const size_t bytes_per_frame = audio_parameters_.channels() * sizeof(int16_t); const size_t bytes_per_frame = audio_parameters_.channels() * sizeof(int16_t);
frames_per_buffer_ = direct_buffer_capacity_in_bytes_ / bytes_per_frame; frames_per_buffer_ = direct_buffer_capacity_in_bytes_ / bytes_per_frame;
RTC_LOG(INFO) << "frames_per_buffer: " << frames_per_buffer_; RTC_LOG(LS_INFO) << "frames_per_buffer: " << frames_per_buffer_;
} }
JNI_FUNCTION_ALIGN JNI_FUNCTION_ALIGN

33
modules/audio_device/audio_device_buffer.cc
View File

@ -61,7 +61,7 @@ AudioDeviceBuffer::AudioDeviceBuffer(TaskQueueFactory* task_queue_factory)
play_start_time_(0), play_start_time_(0),
only_silence_recorded_(true), only_silence_recorded_(true),
log_stats_(false) { log_stats_(false) {
RTC_LOG(INFO) << "AudioDeviceBuffer::ctor"; RTC_LOG(LS_INFO) << "AudioDeviceBuffer::ctor";
#ifdef AUDIO_DEVICE_PLAYS_SINUS_TONE #ifdef AUDIO_DEVICE_PLAYS_SINUS_TONE
phase_ = 0.0; phase_ = 0.0;
RTC_LOG(WARNING) << "AUDIO_DEVICE_PLAYS_SINUS_TONE is defined!"; RTC_LOG(WARNING) << "AUDIO_DEVICE_PLAYS_SINUS_TONE is defined!";
@ -72,13 +72,13 @@ AudioDeviceBuffer::~AudioDeviceBuffer() {
RTC_DCHECK_RUN_ON(&main_thread_checker_); RTC_DCHECK_RUN_ON(&main_thread_checker_);
RTC_DCHECK(!playing_); RTC_DCHECK(!playing_);
RTC_DCHECK(!recording_); RTC_DCHECK(!recording_);
RTC_LOG(INFO) << "AudioDeviceBuffer::~dtor"; RTC_LOG(LS_INFO) << "AudioDeviceBuffer::~dtor";
} }
int32_t AudioDeviceBuffer::RegisterAudioCallback( int32_t AudioDeviceBuffer::RegisterAudioCallback(
AudioTransport* audio_callback) { AudioTransport* audio_callback) {
RTC_DCHECK_RUN_ON(&main_thread_checker_); RTC_DCHECK_RUN_ON(&main_thread_checker_);
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
if (playing_ || recording_) { if (playing_ || recording_) {
RTC_LOG(LS_ERROR) << "Failed to set audio transport since media was active"; RTC_LOG(LS_ERROR) << "Failed to set audio transport since media was active";
return -1; return -1;
@ -95,7 +95,7 @@ void AudioDeviceBuffer::StartPlayout() {
if (playing_) { if (playing_) {
return; return;
} }
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
// Clear members tracking playout stats and do it on the task queue. // Clear members tracking playout stats and do it on the task queue.
task_queue_.PostTask([this] { ResetPlayStats(); }); task_queue_.PostTask([this] { ResetPlayStats(); });
// Start a periodic timer based on task queue if not already done by the // Start a periodic timer based on task queue if not already done by the
@ -114,7 +114,7 @@ void AudioDeviceBuffer::StartRecording() {
if (recording_) { if (recording_) {
return; return;
} }
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
// Clear members tracking recording stats and do it on the task queue. // Clear members tracking recording stats and do it on the task queue.
task_queue_.PostTask([this] { ResetRecStats(); }); task_queue_.PostTask([this] { ResetRecStats(); });
// Start a periodic timer based on task queue if not already done by the // Start a periodic timer based on task queue if not already done by the
@ -136,13 +136,14 @@ void AudioDeviceBuffer::StopPlayout() {
if (!playing_) { if (!playing_) {
return; return;
} }
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
playing_ = false; playing_ = false;
// Stop periodic logging if no more media is active. // Stop periodic logging if no more media is active.
if (!recording_) { if (!recording_) {
StopPeriodicLogging(); StopPeriodicLogging();
} }
RTC_LOG(INFO) << "total playout time: " << rtc::TimeSince(play_start_time_); RTC_LOG(LS_INFO) << "total playout time: "
<< rtc::TimeSince(play_start_time_);
} }
void AudioDeviceBuffer::StopRecording() { void AudioDeviceBuffer::StopRecording() {
@ -150,7 +151,7 @@ void AudioDeviceBuffer::StopRecording() {
if (!recording_) { if (!recording_) {
return; return;
} }
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
recording_ = false; recording_ = false;
// Stop periodic logging if no more media is active. // Stop periodic logging if no more media is active.
if (!playing_) { if (!playing_) {
@ -170,20 +171,20 @@ void AudioDeviceBuffer::StopRecording() {
if (time_since_start > kMinValidCallTimeTimeInMilliseconds) { if (time_since_start > kMinValidCallTimeTimeInMilliseconds) {
const int only_zeros = static_cast<int>(only_silence_recorded_); const int only_zeros = static_cast<int>(only_silence_recorded_);
RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.RecordedOnlyZeros", only_zeros); RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.RecordedOnlyZeros", only_zeros);
RTC_LOG(INFO) << "HISTOGRAM(WebRTC.Audio.RecordedOnlyZeros): " RTC_LOG(LS_INFO) << "HISTOGRAM(WebRTC.Audio.RecordedOnlyZeros): "
<< only_zeros; << only_zeros;
} }
RTC_LOG(INFO) << "total recording time: " << time_since_start; RTC_LOG(LS_INFO) << "total recording time: " << time_since_start;
} }
int32_t AudioDeviceBuffer::SetRecordingSampleRate(uint32_t fsHz) { int32_t AudioDeviceBuffer::SetRecordingSampleRate(uint32_t fsHz) {
RTC_LOG(INFO) << "SetRecordingSampleRate(" << fsHz << ")"; RTC_LOG(LS_INFO) << "SetRecordingSampleRate(" << fsHz << ")";
rec_sample_rate_ = fsHz; rec_sample_rate_ = fsHz;
return 0; return 0;
} }
int32_t AudioDeviceBuffer::SetPlayoutSampleRate(uint32_t fsHz) { int32_t AudioDeviceBuffer::SetPlayoutSampleRate(uint32_t fsHz) {
RTC_LOG(INFO) << "SetPlayoutSampleRate(" << fsHz << ")"; RTC_LOG(LS_INFO) << "SetPlayoutSampleRate(" << fsHz << ")";
play_sample_rate_ = fsHz; play_sample_rate_ = fsHz;
return 0; return 0;
} }
@ -197,13 +198,13 @@ uint32_t AudioDeviceBuffer::PlayoutSampleRate() const {
} }
int32_t AudioDeviceBuffer::SetRecordingChannels(size_t channels) { int32_t AudioDeviceBuffer::SetRecordingChannels(size_t channels) {
RTC_LOG(INFO) << "SetRecordingChannels(" << channels << ")"; RTC_LOG(LS_INFO) << "SetRecordingChannels(" << channels << ")";
rec_channels_ = channels; rec_channels_ = channels;
return 0; return 0;
} }
int32_t AudioDeviceBuffer::SetPlayoutChannels(size_t channels) { int32_t AudioDeviceBuffer::SetPlayoutChannels(size_t channels) {
RTC_LOG(INFO) << "SetPlayoutChannels(" << channels << ")"; RTC_LOG(LS_INFO) << "SetPlayoutChannels(" << channels << ")";
play_channels_ = channels; play_channels_ = channels;
return 0; return 0;
} }
@ -408,7 +409,7 @@ void AudioDeviceBuffer::LogStats(LogState state) {
((100.0f * std::abs(rate - rec_sample_rate)) / rec_sample_rate)); ((100.0f * std::abs(rate - rec_sample_rate)) / rec_sample_rate));
RTC_HISTOGRAM_PERCENTAGE("WebRTC.Audio.RecordSampleRateOffsetInPercent", RTC_HISTOGRAM_PERCENTAGE("WebRTC.Audio.RecordSampleRateOffsetInPercent",
abs_diff_rate_in_percent); abs_diff_rate_in_percent);
RTC_LOG(INFO) << "[REC : " << time_since_last << "msec, " RTC_LOG(LS_INFO) << "[REC : " << time_since_last << "msec, "
<< rec_sample_rate / 1000 << "kHz] callbacks: " << rec_sample_rate / 1000 << "kHz] callbacks: "
<< stats.rec_callbacks - last_stats_.rec_callbacks << stats.rec_callbacks - last_stats_.rec_callbacks
<< ", " << ", "
@ -434,7 +435,7 @@ void AudioDeviceBuffer::LogStats(LogState state) {
((100.0f * std::abs(rate - play_sample_rate)) / play_sample_rate)); ((100.0f * std::abs(rate - play_sample_rate)) / play_sample_rate));
RTC_HISTOGRAM_PERCENTAGE("WebRTC.Audio.PlayoutSampleRateOffsetInPercent", RTC_HISTOGRAM_PERCENTAGE("WebRTC.Audio.PlayoutSampleRateOffsetInPercent",
abs_diff_rate_in_percent); abs_diff_rate_in_percent);
RTC_LOG(INFO) << "[PLAY: " << time_since_last << "msec, " RTC_LOG(LS_INFO) << "[PLAY: " << time_since_last << "msec, "
<< play_sample_rate / 1000 << "kHz] callbacks: " << play_sample_rate / 1000 << "kHz] callbacks: "
<< stats.play_callbacks - last_stats_.play_callbacks << stats.play_callbacks - last_stats_.play_callbacks
<< ", " << ", "

236
modules/audio_device/audio_device_impl.cc
View File

@ -73,7 +73,7 @@ namespace webrtc {
rtc::scoped_refptr<AudioDeviceModule> AudioDeviceModule::Create( rtc::scoped_refptr<AudioDeviceModule> AudioDeviceModule::Create(
AudioLayer audio_layer, AudioLayer audio_layer,
TaskQueueFactory* task_queue_factory) { TaskQueueFactory* task_queue_factory) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return AudioDeviceModule::CreateForTest(audio_layer, task_queue_factory); return AudioDeviceModule::CreateForTest(audio_layer, task_queue_factory);
} }
@ -81,7 +81,7 @@ rtc::scoped_refptr<AudioDeviceModule> AudioDeviceModule::Create(
rtc::scoped_refptr<AudioDeviceModuleForTest> AudioDeviceModule::CreateForTest( rtc::scoped_refptr<AudioDeviceModuleForTest> AudioDeviceModule::CreateForTest(
AudioLayer audio_layer, AudioLayer audio_layer,
TaskQueueFactory* task_queue_factory) { TaskQueueFactory* task_queue_factory) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
// The "AudioDeviceModule::kWindowsCoreAudio2" audio layer has its own // The "AudioDeviceModule::kWindowsCoreAudio2" audio layer has its own
// dedicated factory method which should be used instead. // dedicated factory method which should be used instead.
@ -118,28 +118,28 @@ AudioDeviceModuleImpl::AudioDeviceModuleImpl(
AudioLayer audio_layer, AudioLayer audio_layer,
TaskQueueFactory* task_queue_factory) TaskQueueFactory* task_queue_factory)
: audio_layer_(audio_layer), audio_device_buffer_(task_queue_factory) { : audio_layer_(audio_layer), audio_device_buffer_(task_queue_factory) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
} }
int32_t AudioDeviceModuleImpl::CheckPlatform() { int32_t AudioDeviceModuleImpl::CheckPlatform() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
// Ensure that the current platform is supported // Ensure that the current platform is supported
PlatformType platform(kPlatformNotSupported); PlatformType platform(kPlatformNotSupported);
#if defined(_WIN32) #if defined(_WIN32)
platform = kPlatformWin32; platform = kPlatformWin32;
RTC_LOG(INFO) << "current platform is Win32"; RTC_LOG(LS_INFO) << "current platform is Win32";
#elif defined(WEBRTC_ANDROID) #elif defined(WEBRTC_ANDROID)
platform = kPlatformAndroid; platform = kPlatformAndroid;
RTC_LOG(INFO) << "current platform is Android"; RTC_LOG(LS_INFO) << "current platform is Android";
#elif defined(WEBRTC_LINUX) #elif defined(WEBRTC_LINUX)
platform = kPlatformLinux; platform = kPlatformLinux;
RTC_LOG(INFO) << "current platform is Linux"; RTC_LOG(LS_INFO) << "current platform is Linux";
#elif defined(WEBRTC_IOS) #elif defined(WEBRTC_IOS)
platform = kPlatformIOS; platform = kPlatformIOS;
RTC_LOG(INFO) << "current platform is IOS"; RTC_LOG(LS_INFO) << "current platform is IOS";
#elif defined(WEBRTC_MAC) #elif defined(WEBRTC_MAC)
platform = kPlatformMac; platform = kPlatformMac;
RTC_LOG(INFO) << "current platform is Mac"; RTC_LOG(LS_INFO) << "current platform is Mac";
#endif #endif
if (platform == kPlatformNotSupported) { if (platform == kPlatformNotSupported) {
RTC_LOG(LERROR) RTC_LOG(LERROR)
@ -152,19 +152,19 @@ int32_t AudioDeviceModuleImpl::CheckPlatform() {
} }
int32_t AudioDeviceModuleImpl::CreatePlatformSpecificObjects() { int32_t AudioDeviceModuleImpl::CreatePlatformSpecificObjects() {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
// Dummy ADM implementations if build flags are set. // Dummy ADM implementations if build flags are set.
#if defined(WEBRTC_DUMMY_AUDIO_BUILD) #if defined(WEBRTC_DUMMY_AUDIO_BUILD)
audio_device_.reset(new AudioDeviceDummy()); audio_device_.reset(new AudioDeviceDummy());
RTC_LOG(INFO) << "Dummy Audio APIs will be utilized"; RTC_LOG(LS_INFO) << "Dummy Audio APIs will be utilized";
#elif defined(WEBRTC_DUMMY_FILE_DEVICES) #elif defined(WEBRTC_DUMMY_FILE_DEVICES)
audio_device_.reset(FileAudioDeviceFactory::CreateFileAudioDevice()); audio_device_.reset(FileAudioDeviceFactory::CreateFileAudioDevice());
if (audio_device_) { if (audio_device_) {
RTC_LOG(INFO) << "Will use file-playing dummy device."; RTC_LOG(LS_INFO) << "Will use file-playing dummy device.";
} else { } else {
// Create a dummy device instead. // Create a dummy device instead.
audio_device_.reset(new AudioDeviceDummy()); audio_device_.reset(new AudioDeviceDummy());
RTC_LOG(INFO) << "Dummy Audio APIs will be utilized"; RTC_LOG(LS_INFO) << "Dummy Audio APIs will be utilized";
} }
// Real (non-dummy) ADM implementations. // Real (non-dummy) ADM implementations.
@ -174,10 +174,10 @@ int32_t AudioDeviceModuleImpl::CreatePlatformSpecificObjects() {
#if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD) #if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
if ((audio_layer == kWindowsCoreAudio) || if ((audio_layer == kWindowsCoreAudio) ||
(audio_layer == kPlatformDefaultAudio)) { (audio_layer == kPlatformDefaultAudio)) {
RTC_LOG(INFO) << "Attempting to use the Windows Core Audio APIs..."; RTC_LOG(LS_INFO) << "Attempting to use the Windows Core Audio APIs...";
if (AudioDeviceWindowsCore::CoreAudioIsSupported()) { if (AudioDeviceWindowsCore::CoreAudioIsSupported()) {
audio_device_.reset(new AudioDeviceWindowsCore()); audio_device_.reset(new AudioDeviceWindowsCore());
RTC_LOG(INFO) << "Windows Core Audio APIs will be utilized"; RTC_LOG(LS_INFO) << "Windows Core Audio APIs will be utilized";
} }
} }
#endif // defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD) #endif // defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
@ -255,7 +255,7 @@ int32_t AudioDeviceModuleImpl::CreatePlatformSpecificObjects() {
if ((audio_layer == kLinuxAlsaAudio) || if ((audio_layer == kLinuxAlsaAudio) ||
(audio_layer == kPlatformDefaultAudio)) { (audio_layer == kPlatformDefaultAudio)) {
audio_device_.reset(new AudioDeviceLinuxALSA()); audio_device_.reset(new AudioDeviceLinuxALSA());
RTC_LOG(INFO) << "Linux ALSA APIs will be utilized."; RTC_LOG(LS_INFO) << "Linux ALSA APIs will be utilized.";
} }
#else #else
// Build flag 'rtc_include_pulse_audio' is set to true (default). In this // Build flag 'rtc_include_pulse_audio' is set to true (default). In this
@ -263,12 +263,12 @@ int32_t AudioDeviceModuleImpl::CreatePlatformSpecificObjects() {
// - kPlatformDefaultAudio => PulseAudio, and // - kPlatformDefaultAudio => PulseAudio, and
// - kLinuxPulseAudio => PulseAudio, and // - kLinuxPulseAudio => PulseAudio, and
// - kLinuxAlsaAudio => ALSA (supported but not default). // - kLinuxAlsaAudio => ALSA (supported but not default).
RTC_LOG(INFO) << "PulseAudio support is enabled."; RTC_LOG(LS_INFO) << "PulseAudio support is enabled.";
if ((audio_layer == kLinuxPulseAudio) || if ((audio_layer == kLinuxPulseAudio) ||
(audio_layer == kPlatformDefaultAudio)) { (audio_layer == kPlatformDefaultAudio)) {
// Linux PulseAudio implementation is default. // Linux PulseAudio implementation is default.
audio_device_.reset(new AudioDeviceLinuxPulse()); audio_device_.reset(new AudioDeviceLinuxPulse());
RTC_LOG(INFO) << "Linux PulseAudio APIs will be utilized"; RTC_LOG(LS_INFO) << "Linux PulseAudio APIs will be utilized";
} else if (audio_layer == kLinuxAlsaAudio) { } else if (audio_layer == kLinuxAlsaAudio) {
audio_device_.reset(new AudioDeviceLinuxALSA()); audio_device_.reset(new AudioDeviceLinuxALSA());
RTC_LOG(WARNING) << "Linux ALSA APIs will be utilized."; RTC_LOG(WARNING) << "Linux ALSA APIs will be utilized.";
@ -281,7 +281,7 @@ int32_t AudioDeviceModuleImpl::CreatePlatformSpecificObjects() {
if (audio_layer == kPlatformDefaultAudio) { if (audio_layer == kPlatformDefaultAudio) {
audio_device_.reset( audio_device_.reset(
new ios_adm::AudioDeviceIOS(/*bypass_voice_processing=*/false)); new ios_adm::AudioDeviceIOS(/*bypass_voice_processing=*/false));
RTC_LOG(INFO) << "iPhone Audio APIs will be utilized."; RTC_LOG(LS_INFO) << "iPhone Audio APIs will be utilized.";
} }
// END #if defined(WEBRTC_IOS) // END #if defined(WEBRTC_IOS)
@ -289,14 +289,14 @@ int32_t AudioDeviceModuleImpl::CreatePlatformSpecificObjects() {
#elif defined(WEBRTC_MAC) #elif defined(WEBRTC_MAC)
if (audio_layer == kPlatformDefaultAudio) { if (audio_layer == kPlatformDefaultAudio) {
audio_device_.reset(new AudioDeviceMac()); audio_device_.reset(new AudioDeviceMac());
RTC_LOG(INFO) << "Mac OS X Audio APIs will be utilized."; RTC_LOG(LS_INFO) << "Mac OS X Audio APIs will be utilized.";
} }
#endif // WEBRTC_MAC #endif // WEBRTC_MAC
// Dummy ADM implementation. // Dummy ADM implementation.
if (audio_layer == kDummyAudio) { if (audio_layer == kDummyAudio) {
audio_device_.reset(new AudioDeviceDummy()); audio_device_.reset(new AudioDeviceDummy());
RTC_LOG(INFO) << "Dummy Audio APIs will be utilized."; RTC_LOG(LS_INFO) << "Dummy Audio APIs will be utilized.";
} }
#endif // if defined(WEBRTC_DUMMY_AUDIO_BUILD) #endif // if defined(WEBRTC_DUMMY_AUDIO_BUILD)
@ -309,17 +309,17 @@ int32_t AudioDeviceModuleImpl::CreatePlatformSpecificObjects() {
} }
int32_t AudioDeviceModuleImpl::AttachAudioBuffer() { int32_t AudioDeviceModuleImpl::AttachAudioBuffer() {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
audio_device_->AttachAudioBuffer(&audio_device_buffer_); audio_device_->AttachAudioBuffer(&audio_device_buffer_);
return 0; return 0;
} }
AudioDeviceModuleImpl::~AudioDeviceModuleImpl() { AudioDeviceModuleImpl::~AudioDeviceModuleImpl() {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
} }
int32_t AudioDeviceModuleImpl::ActiveAudioLayer(AudioLayer* audioLayer) const { int32_t AudioDeviceModuleImpl::ActiveAudioLayer(AudioLayer* audioLayer) const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
AudioLayer activeAudio; AudioLayer activeAudio;
if (audio_device_->ActiveAudioLayer(activeAudio) == -1) { if (audio_device_->ActiveAudioLayer(activeAudio) == -1) {
return -1; return -1;
@ -329,7 +329,7 @@ int32_t AudioDeviceModuleImpl::ActiveAudioLayer(AudioLayer* audioLayer) const {
} }
int32_t AudioDeviceModuleImpl::Init() { int32_t AudioDeviceModuleImpl::Init() {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
if (initialized_) if (initialized_)
return 0; return 0;
RTC_CHECK(audio_device_); RTC_CHECK(audio_device_);
@ -346,7 +346,7 @@ int32_t AudioDeviceModuleImpl::Init() {
} }
int32_t AudioDeviceModuleImpl::Terminate() { int32_t AudioDeviceModuleImpl::Terminate() {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
if (!initialized_) if (!initialized_)
return 0; return 0;
if (audio_device_->Terminate() == -1) { if (audio_device_->Terminate() == -1) {
@ -357,65 +357,65 @@ int32_t AudioDeviceModuleImpl::Terminate() {
} }
bool AudioDeviceModuleImpl::Initialized() const { bool AudioDeviceModuleImpl::Initialized() const {
RTC_LOG(INFO) << __FUNCTION__ << ": " << initialized_; RTC_LOG(LS_INFO) << __FUNCTION__ << ": " << initialized_;
return initialized_; return initialized_;
} }
int32_t AudioDeviceModuleImpl::InitSpeaker() { int32_t AudioDeviceModuleImpl::InitSpeaker() {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
return audio_device_->InitSpeaker(); return audio_device_->InitSpeaker();
} }
int32_t AudioDeviceModuleImpl::InitMicrophone() { int32_t AudioDeviceModuleImpl::InitMicrophone() {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
return audio_device_->InitMicrophone(); return audio_device_->InitMicrophone();
} }
int32_t AudioDeviceModuleImpl::SpeakerVolumeIsAvailable(bool* available) { int32_t AudioDeviceModuleImpl::SpeakerVolumeIsAvailable(bool* available) {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool isAvailable = false; bool isAvailable = false;
if (audio_device_->SpeakerVolumeIsAvailable(isAvailable) == -1) { if (audio_device_->SpeakerVolumeIsAvailable(isAvailable) == -1) {
return -1; return -1;
} }
*available = isAvailable; *available = isAvailable;
RTC_LOG(INFO) << "output: " << isAvailable; RTC_LOG(LS_INFO) << "output: " << isAvailable;
return 0; return 0;
} }
int32_t AudioDeviceModuleImpl::SetSpeakerVolume(uint32_t volume) { int32_t AudioDeviceModuleImpl::SetSpeakerVolume(uint32_t volume) {
RTC_LOG(INFO) << __FUNCTION__ << "(" << volume << ")"; RTC_LOG(LS_INFO) << __FUNCTION__ << "(" << volume << ")";
CHECKinitialized_(); CHECKinitialized_();
return audio_device_->SetSpeakerVolume(volume); return audio_device_->SetSpeakerVolume(volume);
} }
int32_t AudioDeviceModuleImpl::SpeakerVolume(uint32_t* volume) const { int32_t AudioDeviceModuleImpl::SpeakerVolume(uint32_t* volume) const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
uint32_t level = 0; uint32_t level = 0;
if (audio_device_->SpeakerVolume(level) == -1) { if (audio_device_->SpeakerVolume(level) == -1) {
return -1; return -1;
} }
*volume = level; *volume = level;
RTC_LOG(INFO) << "output: " << *volume; RTC_LOG(LS_INFO) << "output: " << *volume;
return 0; return 0;
} }
bool AudioDeviceModuleImpl::SpeakerIsInitialized() const { bool AudioDeviceModuleImpl::SpeakerIsInitialized() const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized__BOOL(); CHECKinitialized__BOOL();
bool isInitialized = audio_device_->SpeakerIsInitialized(); bool isInitialized = audio_device_->SpeakerIsInitialized();
RTC_LOG(INFO) << "output: " << isInitialized; RTC_LOG(LS_INFO) << "output: " << isInitialized;
return isInitialized; return isInitialized;
} }
bool AudioDeviceModuleImpl::MicrophoneIsInitialized() const { bool AudioDeviceModuleImpl::MicrophoneIsInitialized() const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized__BOOL(); CHECKinitialized__BOOL();
bool isInitialized = audio_device_->MicrophoneIsInitialized(); bool isInitialized = audio_device_->MicrophoneIsInitialized();
RTC_LOG(INFO) << "output: " << isInitialized; RTC_LOG(LS_INFO) << "output: " << isInitialized;
return isInitialized; return isInitialized;
} }
@ -440,110 +440,110 @@ int32_t AudioDeviceModuleImpl::MinSpeakerVolume(uint32_t* minVolume) const {
} }
int32_t AudioDeviceModuleImpl::SpeakerMuteIsAvailable(bool* available) { int32_t AudioDeviceModuleImpl::SpeakerMuteIsAvailable(bool* available) {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool isAvailable = false; bool isAvailable = false;
if (audio_device_->SpeakerMuteIsAvailable(isAvailable) == -1) { if (audio_device_->SpeakerMuteIsAvailable(isAvailable) == -1) {
return -1; return -1;
} }
*available = isAvailable; *available = isAvailable;
RTC_LOG(INFO) << "output: " << isAvailable; RTC_LOG(LS_INFO) << "output: " << isAvailable;
return 0; return 0;
} }
int32_t AudioDeviceModuleImpl::SetSpeakerMute(bool enable) { int32_t AudioDeviceModuleImpl::SetSpeakerMute(bool enable) {
RTC_LOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_LOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
CHECKinitialized_(); CHECKinitialized_();
return audio_device_->SetSpeakerMute(enable); return audio_device_->SetSpeakerMute(enable);
} }
int32_t AudioDeviceModuleImpl::SpeakerMute(bool* enabled) const { int32_t AudioDeviceModuleImpl::SpeakerMute(bool* enabled) const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool muted = false; bool muted = false;
if (audio_device_->SpeakerMute(muted) == -1) { if (audio_device_->SpeakerMute(muted) == -1) {
return -1; return -1;
} }
*enabled = muted; *enabled = muted;
RTC_LOG(INFO) << "output: " << muted; RTC_LOG(LS_INFO) << "output: " << muted;
return 0; return 0;
} }
int32_t AudioDeviceModuleImpl::MicrophoneMuteIsAvailable(bool* available) { int32_t AudioDeviceModuleImpl::MicrophoneMuteIsAvailable(bool* available) {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool isAvailable = false; bool isAvailable = false;
if (audio_device_->MicrophoneMuteIsAvailable(isAvailable) == -1) { if (audio_device_->MicrophoneMuteIsAvailable(isAvailable) == -1) {
return -1; return -1;
} }
*available = isAvailable; *available = isAvailable;
RTC_LOG(INFO) << "output: " << isAvailable; RTC_LOG(LS_INFO) << "output: " << isAvailable;
return 0; return 0;
} }
int32_t AudioDeviceModuleImpl::SetMicrophoneMute(bool enable) { int32_t AudioDeviceModuleImpl::SetMicrophoneMute(bool enable) {
RTC_LOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_LOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
CHECKinitialized_(); CHECKinitialized_();
return (audio_device_->SetMicrophoneMute(enable)); return (audio_device_->SetMicrophoneMute(enable));
} }
int32_t AudioDeviceModuleImpl::MicrophoneMute(bool* enabled) const { int32_t AudioDeviceModuleImpl::MicrophoneMute(bool* enabled) const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool muted = false; bool muted = false;
if (audio_device_->MicrophoneMute(muted) == -1) { if (audio_device_->MicrophoneMute(muted) == -1) {
return -1; return -1;
} }
*enabled = muted; *enabled = muted;
RTC_LOG(INFO) << "output: " << muted; RTC_LOG(LS_INFO) << "output: " << muted;
return 0; return 0;
} }
int32_t AudioDeviceModuleImpl::MicrophoneVolumeIsAvailable(bool* available) { int32_t AudioDeviceModuleImpl::MicrophoneVolumeIsAvailable(bool* available) {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool isAvailable = false; bool isAvailable = false;
if (audio_device_->MicrophoneVolumeIsAvailable(isAvailable) == -1) { if (audio_device_->MicrophoneVolumeIsAvailable(isAvailable) == -1) {
return -1; return -1;
} }
*available = isAvailable; *available = isAvailable;
RTC_LOG(INFO) << "output: " << isAvailable; RTC_LOG(LS_INFO) << "output: " << isAvailable;
return 0; return 0;
} }
int32_t AudioDeviceModuleImpl::SetMicrophoneVolume(uint32_t volume) { int32_t AudioDeviceModuleImpl::SetMicrophoneVolume(uint32_t volume) {
RTC_LOG(INFO) << __FUNCTION__ << "(" << volume << ")"; RTC_LOG(LS_INFO) << __FUNCTION__ << "(" << volume << ")";
CHECKinitialized_(); CHECKinitialized_();
return (audio_device_->SetMicrophoneVolume(volume)); return (audio_device_->SetMicrophoneVolume(volume));
} }
int32_t AudioDeviceModuleImpl::MicrophoneVolume(uint32_t* volume) const { int32_t AudioDeviceModuleImpl::MicrophoneVolume(uint32_t* volume) const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
uint32_t level = 0; uint32_t level = 0;
if (audio_device_->MicrophoneVolume(level) == -1) { if (audio_device_->MicrophoneVolume(level) == -1) {
return -1; return -1;
} }
*volume = level; *volume = level;
RTC_LOG(INFO) << "output: " << *volume; RTC_LOG(LS_INFO) << "output: " << *volume;
return 0; return 0;
} }
int32_t AudioDeviceModuleImpl::StereoRecordingIsAvailable( int32_t AudioDeviceModuleImpl::StereoRecordingIsAvailable(
bool* available) const { bool* available) const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool isAvailable = false; bool isAvailable = false;
if (audio_device_->StereoRecordingIsAvailable(isAvailable) == -1) { if (audio_device_->StereoRecordingIsAvailable(isAvailable) == -1) {
return -1; return -1;
} }
*available = isAvailable; *available = isAvailable;
RTC_LOG(INFO) << "output: " << isAvailable; RTC_LOG(LS_INFO) << "output: " << isAvailable;
return 0; return 0;
} }
int32_t AudioDeviceModuleImpl::SetStereoRecording(bool enable) { int32_t AudioDeviceModuleImpl::SetStereoRecording(bool enable) {
RTC_LOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_LOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
CHECKinitialized_(); CHECKinitialized_();
if (audio_device_->RecordingIsInitialized()) { if (audio_device_->RecordingIsInitialized()) {
RTC_LOG(LERROR) RTC_LOG(LERROR)
@ -565,31 +565,31 @@ int32_t AudioDeviceModuleImpl::SetStereoRecording(bool enable) {
} }
int32_t AudioDeviceModuleImpl::StereoRecording(bool* enabled) const { int32_t AudioDeviceModuleImpl::StereoRecording(bool* enabled) const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool stereo = false; bool stereo = false;
if (audio_device_->StereoRecording(stereo) == -1) { if (audio_device_->StereoRecording(stereo) == -1) {
return -1; return -1;
} }
*enabled = stereo; *enabled = stereo;
RTC_LOG(INFO) << "output: " << stereo; RTC_LOG(LS_INFO) << "output: " << stereo;
return 0; return 0;
} }
int32_t AudioDeviceModuleImpl::StereoPlayoutIsAvailable(bool* available) const { int32_t AudioDeviceModuleImpl::StereoPlayoutIsAvailable(bool* available) const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool isAvailable = false; bool isAvailable = false;
if (audio_device_->StereoPlayoutIsAvailable(isAvailable) == -1) { if (audio_device_->StereoPlayoutIsAvailable(isAvailable) == -1) {
return -1; return -1;
} }
*available = isAvailable; *available = isAvailable;
RTC_LOG(INFO) << "output: " << isAvailable; RTC_LOG(LS_INFO) << "output: " << isAvailable;
return 0; return 0;
} }
int32_t AudioDeviceModuleImpl::SetStereoPlayout(bool enable) { int32_t AudioDeviceModuleImpl::SetStereoPlayout(bool enable) {
RTC_LOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_LOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
CHECKinitialized_(); CHECKinitialized_();
if (audio_device_->PlayoutIsInitialized()) { if (audio_device_->PlayoutIsInitialized()) {
RTC_LOG(LERROR) RTC_LOG(LERROR)
@ -609,38 +609,38 @@ int32_t AudioDeviceModuleImpl::SetStereoPlayout(bool enable) {
} }
int32_t AudioDeviceModuleImpl::StereoPlayout(bool* enabled) const { int32_t AudioDeviceModuleImpl::StereoPlayout(bool* enabled) const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool stereo = false; bool stereo = false;
if (audio_device_->StereoPlayout(stereo) == -1) { if (audio_device_->StereoPlayout(stereo) == -1) {
return -1; return -1;
} }
*enabled = stereo; *enabled = stereo;
RTC_LOG(INFO) << "output: " << stereo; RTC_LOG(LS_INFO) << "output: " << stereo;
return 0; return 0;
} }
int32_t AudioDeviceModuleImpl::PlayoutIsAvailable(bool* available) { int32_t AudioDeviceModuleImpl::PlayoutIsAvailable(bool* available) {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool isAvailable = false; bool isAvailable = false;
if (audio_device_->PlayoutIsAvailable(isAvailable) == -1) { if (audio_device_->PlayoutIsAvailable(isAvailable) == -1) {
return -1; return -1;
} }
*available = isAvailable; *available = isAvailable;
RTC_LOG(INFO) << "output: " << isAvailable; RTC_LOG(LS_INFO) << "output: " << isAvailable;
return 0; return 0;
} }
int32_t AudioDeviceModuleImpl::RecordingIsAvailable(bool* available) { int32_t AudioDeviceModuleImpl::RecordingIsAvailable(bool* available) {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool isAvailable = false; bool isAvailable = false;
if (audio_device_->RecordingIsAvailable(isAvailable) == -1) { if (audio_device_->RecordingIsAvailable(isAvailable) == -1) {
return -1; return -1;
} }
*available = isAvailable; *available = isAvailable;
RTC_LOG(INFO) << "output: " << isAvailable; RTC_LOG(LS_INFO) << "output: " << isAvailable;
return 0; return 0;
} }
@ -665,21 +665,21 @@ int32_t AudioDeviceModuleImpl::MinMicrophoneVolume(uint32_t* minVolume) const {
} }
int16_t AudioDeviceModuleImpl::PlayoutDevices() { int16_t AudioDeviceModuleImpl::PlayoutDevices() {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
uint16_t nPlayoutDevices = audio_device_->PlayoutDevices(); uint16_t nPlayoutDevices = audio_device_->PlayoutDevices();
RTC_LOG(INFO) << "output: " << nPlayoutDevices; RTC_LOG(LS_INFO) << "output: " << nPlayoutDevices;
return (int16_t)(nPlayoutDevices); return (int16_t)(nPlayoutDevices);
} }
int32_t AudioDeviceModuleImpl::SetPlayoutDevice(uint16_t index) { int32_t AudioDeviceModuleImpl::SetPlayoutDevice(uint16_t index) {
RTC_LOG(INFO) << __FUNCTION__ << "(" << index << ")"; RTC_LOG(LS_INFO) << __FUNCTION__ << "(" << index << ")";
CHECKinitialized_(); CHECKinitialized_();
return audio_device_->SetPlayoutDevice(index); return audio_device_->SetPlayoutDevice(index);
} }
int32_t AudioDeviceModuleImpl::SetPlayoutDevice(WindowsDeviceType device) { int32_t AudioDeviceModuleImpl::SetPlayoutDevice(WindowsDeviceType device) {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
return audio_device_->SetPlayoutDevice(device); return audio_device_->SetPlayoutDevice(device);
} }
@ -688,7 +688,7 @@ int32_t AudioDeviceModuleImpl::PlayoutDeviceName(
uint16_t index, uint16_t index,
char name[kAdmMaxDeviceNameSize], char name[kAdmMaxDeviceNameSize],
char guid[kAdmMaxGuidSize]) { char guid[kAdmMaxGuidSize]) {
RTC_LOG(INFO) << __FUNCTION__ << "(" << index << ", ...)"; RTC_LOG(LS_INFO) << __FUNCTION__ << "(" << index << ", ...)";
CHECKinitialized_(); CHECKinitialized_();
if (name == NULL) { if (name == NULL) {
return -1; return -1;
@ -697,10 +697,10 @@ int32_t AudioDeviceModuleImpl::PlayoutDeviceName(
return -1; return -1;
} }
if (name != NULL) { if (name != NULL) {
RTC_LOG(INFO) << "output: name = " << name; RTC_LOG(LS_INFO) << "output: name = " << name;
} }
if (guid != NULL) { if (guid != NULL) {
RTC_LOG(INFO) << "output: guid = " << guid; RTC_LOG(LS_INFO) << "output: guid = " << guid;
} }
return 0; return 0;
} }
@ -709,7 +709,7 @@ int32_t AudioDeviceModuleImpl::RecordingDeviceName(
uint16_t index, uint16_t index,
char name[kAdmMaxDeviceNameSize], char name[kAdmMaxDeviceNameSize],
char guid[kAdmMaxGuidSize]) { char guid[kAdmMaxGuidSize]) {
RTC_LOG(INFO) << __FUNCTION__ << "(" << index << ", ...)"; RTC_LOG(LS_INFO) << __FUNCTION__ << "(" << index << ", ...)";
CHECKinitialized_(); CHECKinitialized_();
if (name == NULL) { if (name == NULL) {
return -1; return -1;
@ -718,137 +718,137 @@ int32_t AudioDeviceModuleImpl::RecordingDeviceName(
return -1; return -1;
} }
if (name != NULL) { if (name != NULL) {
RTC_LOG(INFO) << "output: name = " << name; RTC_LOG(LS_INFO) << "output: name = " << name;
} }
if (guid != NULL) { if (guid != NULL) {
RTC_LOG(INFO) << "output: guid = " << guid; RTC_LOG(LS_INFO) << "output: guid = " << guid;
} }
return 0; return 0;
} }
int16_t AudioDeviceModuleImpl::RecordingDevices() { int16_t AudioDeviceModuleImpl::RecordingDevices() {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
uint16_t nRecordingDevices = audio_device_->RecordingDevices(); uint16_t nRecordingDevices = audio_device_->RecordingDevices();
RTC_LOG(INFO) << "output: " << nRecordingDevices; RTC_LOG(LS_INFO) << "output: " << nRecordingDevices;
return (int16_t)nRecordingDevices; return (int16_t)nRecordingDevices;
} }
int32_t AudioDeviceModuleImpl::SetRecordingDevice(uint16_t index) { int32_t AudioDeviceModuleImpl::SetRecordingDevice(uint16_t index) {
RTC_LOG(INFO) << __FUNCTION__ << "(" << index << ")"; RTC_LOG(LS_INFO) << __FUNCTION__ << "(" << index << ")";
CHECKinitialized_(); CHECKinitialized_();
return audio_device_->SetRecordingDevice(index); return audio_device_->SetRecordingDevice(index);
} }
int32_t AudioDeviceModuleImpl::SetRecordingDevice(WindowsDeviceType device) { int32_t AudioDeviceModuleImpl::SetRecordingDevice(WindowsDeviceType device) {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
return audio_device_->SetRecordingDevice(device); return audio_device_->SetRecordingDevice(device);
} }
int32_t AudioDeviceModuleImpl::InitPlayout() { int32_t AudioDeviceModuleImpl::InitPlayout() {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
if (PlayoutIsInitialized()) { if (PlayoutIsInitialized()) {
return 0; return 0;
} }
int32_t result = audio_device_->InitPlayout(); int32_t result = audio_device_->InitPlayout();
RTC_LOG(INFO) << "output: " << result; RTC_LOG(LS_INFO) << "output: " << result;
RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.InitPlayoutSuccess", RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.InitPlayoutSuccess",
static_cast<int>(result == 0)); static_cast<int>(result == 0));
return result; return result;
} }
int32_t AudioDeviceModuleImpl::InitRecording() { int32_t AudioDeviceModuleImpl::InitRecording() {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
if (RecordingIsInitialized()) { if (RecordingIsInitialized()) {
return 0; return 0;
} }
int32_t result = audio_device_->InitRecording(); int32_t result = audio_device_->InitRecording();
RTC_LOG(INFO) << "output: " << result; RTC_LOG(LS_INFO) << "output: " << result;
RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.InitRecordingSuccess", RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.InitRecordingSuccess",
static_cast<int>(result == 0)); static_cast<int>(result == 0));
return result; return result;
} }
bool AudioDeviceModuleImpl::PlayoutIsInitialized() const { bool AudioDeviceModuleImpl::PlayoutIsInitialized() const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized__BOOL(); CHECKinitialized__BOOL();
return audio_device_->PlayoutIsInitialized(); return audio_device_->PlayoutIsInitialized();
} }
bool AudioDeviceModuleImpl::RecordingIsInitialized() const { bool AudioDeviceModuleImpl::RecordingIsInitialized() const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized__BOOL(); CHECKinitialized__BOOL();
return audio_device_->RecordingIsInitialized(); return audio_device_->RecordingIsInitialized();
} }
int32_t AudioDeviceModuleImpl::StartPlayout() { int32_t AudioDeviceModuleImpl::StartPlayout() {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
if (Playing()) { if (Playing()) {
return 0; return 0;
} }
audio_device_buffer_.StartPlayout(); audio_device_buffer_.StartPlayout();
int32_t result = audio_device_->StartPlayout(); int32_t result = audio_device_->StartPlayout();
RTC_LOG(INFO) << "output: " << result; RTC_LOG(LS_INFO) << "output: " << result;
RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StartPlayoutSuccess", RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StartPlayoutSuccess",
static_cast<int>(result == 0)); static_cast<int>(result == 0));
return result; return result;
} }
int32_t AudioDeviceModuleImpl::StopPlayout() { int32_t AudioDeviceModuleImpl::StopPlayout() {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
int32_t result = audio_device_->StopPlayout(); int32_t result = audio_device_->StopPlayout();
audio_device_buffer_.StopPlayout(); audio_device_buffer_.StopPlayout();
RTC_LOG(INFO) << "output: " << result; RTC_LOG(LS_INFO) << "output: " << result;
RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StopPlayoutSuccess", RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StopPlayoutSuccess",
static_cast<int>(result == 0)); static_cast<int>(result == 0));
return result; return result;
} }
bool AudioDeviceModuleImpl::Playing() const { bool AudioDeviceModuleImpl::Playing() const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized__BOOL(); CHECKinitialized__BOOL();
return audio_device_->Playing(); return audio_device_->Playing();
} }
int32_t AudioDeviceModuleImpl::StartRecording() { int32_t AudioDeviceModuleImpl::StartRecording() {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
if (Recording()) { if (Recording()) {
return 0; return 0;
} }
audio_device_buffer_.StartRecording(); audio_device_buffer_.StartRecording();
int32_t result = audio_device_->StartRecording(); int32_t result = audio_device_->StartRecording();
RTC_LOG(INFO) << "output: " << result; RTC_LOG(LS_INFO) << "output: " << result;
RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StartRecordingSuccess", RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StartRecordingSuccess",
static_cast<int>(result == 0)); static_cast<int>(result == 0));
return result; return result;
} }
int32_t AudioDeviceModuleImpl::StopRecording() { int32_t AudioDeviceModuleImpl::StopRecording() {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
int32_t result = audio_device_->StopRecording(); int32_t result = audio_device_->StopRecording();
audio_device_buffer_.StopRecording(); audio_device_buffer_.StopRecording();
RTC_LOG(INFO) << "output: " << result; RTC_LOG(LS_INFO) << "output: " << result;
RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StopRecordingSuccess", RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StopRecordingSuccess",
static_cast<int>(result == 0)); static_cast<int>(result == 0));
return result; return result;
} }
bool AudioDeviceModuleImpl::Recording() const { bool AudioDeviceModuleImpl::Recording() const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized__BOOL(); CHECKinitialized__BOOL();
return audio_device_->Recording(); return audio_device_->Recording();
} }
int32_t AudioDeviceModuleImpl::RegisterAudioCallback( int32_t AudioDeviceModuleImpl::RegisterAudioCallback(
AudioTransport* audioCallback) { AudioTransport* audioCallback) {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
return audio_device_buffer_.RegisterAudioCallback(audioCallback); return audio_device_buffer_.RegisterAudioCallback(audioCallback);
} }
@ -864,87 +864,87 @@ int32_t AudioDeviceModuleImpl::PlayoutDelay(uint16_t* delayMS) const {
} }
bool AudioDeviceModuleImpl::BuiltInAECIsAvailable() const { bool AudioDeviceModuleImpl::BuiltInAECIsAvailable() const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized__BOOL(); CHECKinitialized__BOOL();
bool isAvailable = audio_device_->BuiltInAECIsAvailable(); bool isAvailable = audio_device_->BuiltInAECIsAvailable();
RTC_LOG(INFO) << "output: " << isAvailable; RTC_LOG(LS_INFO) << "output: " << isAvailable;
return isAvailable; return isAvailable;
} }
int32_t AudioDeviceModuleImpl::EnableBuiltInAEC(bool enable) { int32_t AudioDeviceModuleImpl::EnableBuiltInAEC(bool enable) {
RTC_LOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_LOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
CHECKinitialized_(); CHECKinitialized_();
int32_t ok = audio_device_->EnableBuiltInAEC(enable); int32_t ok = audio_device_->EnableBuiltInAEC(enable);
RTC_LOG(INFO) << "output: " << ok; RTC_LOG(LS_INFO) << "output: " << ok;
return ok; return ok;
} }
bool AudioDeviceModuleImpl::BuiltInAGCIsAvailable() const { bool AudioDeviceModuleImpl::BuiltInAGCIsAvailable() const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized__BOOL(); CHECKinitialized__BOOL();
bool isAvailable = audio_device_->BuiltInAGCIsAvailable(); bool isAvailable = audio_device_->BuiltInAGCIsAvailable();
RTC_LOG(INFO) << "output: " << isAvailable; RTC_LOG(LS_INFO) << "output: " << isAvailable;
return isAvailable; return isAvailable;
} }
int32_t AudioDeviceModuleImpl::EnableBuiltInAGC(bool enable) { int32_t AudioDeviceModuleImpl::EnableBuiltInAGC(bool enable) {
RTC_LOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_LOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
CHECKinitialized_(); CHECKinitialized_();
int32_t ok = audio_device_->EnableBuiltInAGC(enable); int32_t ok = audio_device_->EnableBuiltInAGC(enable);
RTC_LOG(INFO) << "output: " << ok; RTC_LOG(LS_INFO) << "output: " << ok;
return ok; return ok;
} }
bool AudioDeviceModuleImpl::BuiltInNSIsAvailable() const { bool AudioDeviceModuleImpl::BuiltInNSIsAvailable() const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized__BOOL(); CHECKinitialized__BOOL();
bool isAvailable = audio_device_->BuiltInNSIsAvailable(); bool isAvailable = audio_device_->BuiltInNSIsAvailable();
RTC_LOG(INFO) << "output: " << isAvailable; RTC_LOG(LS_INFO) << "output: " << isAvailable;
return isAvailable; return isAvailable;
} }
int32_t AudioDeviceModuleImpl::EnableBuiltInNS(bool enable) { int32_t AudioDeviceModuleImpl::EnableBuiltInNS(bool enable) {
RTC_LOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_LOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
CHECKinitialized_(); CHECKinitialized_();
int32_t ok = audio_device_->EnableBuiltInNS(enable); int32_t ok = audio_device_->EnableBuiltInNS(enable);
RTC_LOG(INFO) << "output: " << ok; RTC_LOG(LS_INFO) << "output: " << ok;
return ok; return ok;
} }
int32_t AudioDeviceModuleImpl::GetPlayoutUnderrunCount() const { int32_t AudioDeviceModuleImpl::GetPlayoutUnderrunCount() const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
int32_t underrunCount = audio_device_->GetPlayoutUnderrunCount(); int32_t underrunCount = audio_device_->GetPlayoutUnderrunCount();
RTC_LOG(INFO) << "output: " << underrunCount; RTC_LOG(LS_INFO) << "output: " << underrunCount;
return underrunCount; return underrunCount;
} }
#if defined(WEBRTC_IOS) #if defined(WEBRTC_IOS)
int AudioDeviceModuleImpl::GetPlayoutAudioParameters( int AudioDeviceModuleImpl::GetPlayoutAudioParameters(
AudioParameters* params) const { AudioParameters* params) const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
int r = audio_device_->GetPlayoutAudioParameters(params); int r = audio_device_->GetPlayoutAudioParameters(params);
RTC_LOG(INFO) << "output: " << r; RTC_LOG(LS_INFO) << "output: " << r;
return r; return r;
} }
int AudioDeviceModuleImpl::GetRecordAudioParameters( int AudioDeviceModuleImpl::GetRecordAudioParameters(
AudioParameters* params) const { AudioParameters* params) const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
int r = audio_device_->GetRecordAudioParameters(params); int r = audio_device_->GetRecordAudioParameters(params);
RTC_LOG(INFO) << "output: " << r; RTC_LOG(LS_INFO) << "output: " << r;
return r; return r;
} }
#endif // WEBRTC_IOS #endif // WEBRTC_IOS
AudioDeviceModuleImpl::PlatformType AudioDeviceModuleImpl::Platform() const { AudioDeviceModuleImpl::PlatformType AudioDeviceModuleImpl::Platform() const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
return platform_type_; return platform_type_;
} }
AudioDeviceModule::AudioLayer AudioDeviceModuleImpl::PlatformAudioLayer() AudioDeviceModule::AudioLayer AudioDeviceModuleImpl::PlatformAudioLayer()
const { const {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
return audio_layer_; return audio_layer_;
} }

12
modules/audio_device/fine_audio_buffer.cc
View File

@ -29,21 +29,21 @@ FineAudioBuffer::FineAudioBuffer(AudioDeviceBuffer* audio_device_buffer)
playout_channels_(audio_device_buffer->PlayoutChannels()), playout_channels_(audio_device_buffer->PlayoutChannels()),
record_channels_(audio_device_buffer->RecordingChannels()) { record_channels_(audio_device_buffer->RecordingChannels()) {
RTC_DCHECK(audio_device_buffer_); RTC_DCHECK(audio_device_buffer_);
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
if (IsReadyForPlayout()) { if (IsReadyForPlayout()) {
RTC_DLOG(INFO) << "playout_samples_per_channel_10ms: " RTC_DLOG(LS_INFO) << "playout_samples_per_channel_10ms: "
<< playout_samples_per_channel_10ms_; << playout_samples_per_channel_10ms_;
RTC_DLOG(INFO) << "playout_channels: " << playout_channels_; RTC_DLOG(LS_INFO) << "playout_channels: " << playout_channels_;
} }
if (IsReadyForRecord()) { if (IsReadyForRecord()) {
RTC_DLOG(INFO) << "record_samples_per_channel_10ms: " RTC_DLOG(LS_INFO) << "record_samples_per_channel_10ms: "
<< record_samples_per_channel_10ms_; << record_samples_per_channel_10ms_;
RTC_DLOG(INFO) << "record_channels: " << record_channels_; RTC_DLOG(LS_INFO) << "record_channels: " << record_channels_;
} }
} }
FineAudioBuffer::~FineAudioBuffer() { FineAudioBuffer::~FineAudioBuffer() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
} }
void FineAudioBuffer::ResetPlayout() { void FineAudioBuffer::ResetPlayout() {

4
modules/audio_device/include/audio_device_factory.cc
View File

@ -27,7 +27,7 @@ namespace webrtc {
rtc::scoped_refptr<AudioDeviceModule> CreateWindowsCoreAudioAudioDeviceModule( rtc::scoped_refptr<AudioDeviceModule> CreateWindowsCoreAudioAudioDeviceModule(
TaskQueueFactory* task_queue_factory, TaskQueueFactory* task_queue_factory,
bool automatic_restart) { bool automatic_restart) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return CreateWindowsCoreAudioAudioDeviceModuleForTest(task_queue_factory, return CreateWindowsCoreAudioAudioDeviceModuleForTest(task_queue_factory,
automatic_restart); automatic_restart);
} }
@ -36,7 +36,7 @@ rtc::scoped_refptr<AudioDeviceModuleForTest>
CreateWindowsCoreAudioAudioDeviceModuleForTest( CreateWindowsCoreAudioAudioDeviceModuleForTest(
TaskQueueFactory* task_queue_factory, TaskQueueFactory* task_queue_factory,
bool automatic_restart) { bool automatic_restart) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
// Returns NULL if Core Audio is not supported or if COM has not been // Returns NULL if Core Audio is not supported or if COM has not been
// initialized correctly using ScopedCOMInitializer. // initialized correctly using ScopedCOMInitializer.
if (!webrtc_win::core_audio_utility::IsSupported()) { if (!webrtc_win::core_audio_utility::IsSupported()) {

8
modules/audio_device/win/audio_device_core_win.cc
View File

@ -1887,7 +1887,7 @@ int32_t AudioDeviceWindowsCore::InitPlayout() {
break; break;
} else { } else {
if (pWfxClosestMatch) { if (pWfxClosestMatch) {
RTC_LOG(INFO) << "nChannels=" << Wfx.nChannels RTC_LOG(LS_INFO) << "nChannels=" << Wfx.nChannels
<< ", nSamplesPerSec=" << Wfx.nSamplesPerSec << ", nSamplesPerSec=" << Wfx.nSamplesPerSec
<< " is not supported. Closest match: " << " is not supported. Closest match: "
"nChannels=" "nChannels="
@ -1896,7 +1896,7 @@ int32_t AudioDeviceWindowsCore::InitPlayout() {
CoTaskMemFree(pWfxClosestMatch); CoTaskMemFree(pWfxClosestMatch);
pWfxClosestMatch = NULL; pWfxClosestMatch = NULL;
} else { } else {
RTC_LOG(INFO) << "nChannels=" << Wfx.nChannels RTC_LOG(LS_INFO) << "nChannels=" << Wfx.nChannels
<< ", nSamplesPerSec=" << Wfx.nSamplesPerSec << ", nSamplesPerSec=" << Wfx.nSamplesPerSec
<< " is not supported. No closest match."; << " is not supported. No closest match.";
} }
@ -2208,7 +2208,7 @@ int32_t AudioDeviceWindowsCore::InitRecording() {
break; break;
} else { } else {
if (pWfxClosestMatch) { if (pWfxClosestMatch) {
RTC_LOG(INFO) << "nChannels=" << Wfx.Format.nChannels RTC_LOG(LS_INFO) << "nChannels=" << Wfx.Format.nChannels
<< ", nSamplesPerSec=" << Wfx.Format.nSamplesPerSec << ", nSamplesPerSec=" << Wfx.Format.nSamplesPerSec
<< " is not supported. Closest match: " << " is not supported. Closest match: "
"nChannels=" "nChannels="
@ -2217,7 +2217,7 @@ int32_t AudioDeviceWindowsCore::InitRecording() {
CoTaskMemFree(pWfxClosestMatch); CoTaskMemFree(pWfxClosestMatch);
pWfxClosestMatch = NULL; pWfxClosestMatch = NULL;
} else { } else {
RTC_LOG(INFO) << "nChannels=" << Wfx.Format.nChannels RTC_LOG(LS_INFO) << "nChannels=" << Wfx.Format.nChannels
<< ", nSamplesPerSec=" << Wfx.Format.nSamplesPerSec << ", nSamplesPerSec=" << Wfx.Format.nSamplesPerSec
<< " is not supported. No closest match."; << " is not supported. No closest match.";
} }

88
modules/audio_device/win/audio_device_module_win.cc
View File

@ -95,12 +95,12 @@ class WindowsAudioDeviceModule : public AudioDeviceModuleForTest {
task_queue_factory_(task_queue_factory) { task_queue_factory_(task_queue_factory) {
RTC_CHECK(input_); RTC_CHECK(input_);
RTC_CHECK(output_); RTC_CHECK(output_);
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
} }
~WindowsAudioDeviceModule() override { ~WindowsAudioDeviceModule() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
Terminate(); Terminate();
} }
@ -110,7 +110,7 @@ class WindowsAudioDeviceModule : public AudioDeviceModuleForTest {
int32_t ActiveAudioLayer( int32_t ActiveAudioLayer(
AudioDeviceModule::AudioLayer* audioLayer) const override { AudioDeviceModule::AudioLayer* audioLayer) const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
// TODO(henrika): it might be possible to remove this unique signature. // TODO(henrika): it might be possible to remove this unique signature.
*audioLayer = AudioDeviceModule::kWindowsCoreAudio2; *audioLayer = AudioDeviceModule::kWindowsCoreAudio2;
@ -118,14 +118,14 @@ class WindowsAudioDeviceModule : public AudioDeviceModuleForTest {
} }
int32_t RegisterAudioCallback(AudioTransport* audioCallback) override { int32_t RegisterAudioCallback(AudioTransport* audioCallback) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK(audio_device_buffer_); RTC_DCHECK(audio_device_buffer_);
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
return audio_device_buffer_->RegisterAudioCallback(audioCallback); return audio_device_buffer_->RegisterAudioCallback(audioCallback);
} }
int32_t Init() override { int32_t Init() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RETURN_IF_OUTPUT_RESTARTS(0); RETURN_IF_OUTPUT_RESTARTS(0);
RETURN_IF_INPUT_RESTARTS(0); RETURN_IF_INPUT_RESTARTS(0);
@ -153,7 +153,7 @@ class WindowsAudioDeviceModule : public AudioDeviceModuleForTest {
} }
int32_t Terminate() override { int32_t Terminate() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RETURN_IF_OUTPUT_RESTARTS(0); RETURN_IF_OUTPUT_RESTARTS(0);
RETURN_IF_INPUT_RESTARTS(0); RETURN_IF_INPUT_RESTARTS(0);
@ -172,14 +172,14 @@ class WindowsAudioDeviceModule : public AudioDeviceModuleForTest {
} }
int16_t PlayoutDevices() override { int16_t PlayoutDevices() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RETURN_IF_OUTPUT_RESTARTS(0); RETURN_IF_OUTPUT_RESTARTS(0);
return output_->NumDevices(); return output_->NumDevices();
} }
int16_t RecordingDevices() override { int16_t RecordingDevices() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RETURN_IF_INPUT_RESTARTS(0); RETURN_IF_INPUT_RESTARTS(0);
return input_->NumDevices(); return input_->NumDevices();
@ -188,7 +188,7 @@ class WindowsAudioDeviceModule : public AudioDeviceModuleForTest {
int32_t PlayoutDeviceName(uint16_t index, int32_t PlayoutDeviceName(uint16_t index,
char name[kAdmMaxDeviceNameSize], char name[kAdmMaxDeviceNameSize],
char guid[kAdmMaxGuidSize]) override { char guid[kAdmMaxGuidSize]) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RETURN_IF_OUTPUT_RESTARTS(0); RETURN_IF_OUTPUT_RESTARTS(0);
std::string name_str, guid_str; std::string name_str, guid_str;
@ -205,7 +205,7 @@ class WindowsAudioDeviceModule : public AudioDeviceModuleForTest {
int32_t RecordingDeviceName(uint16_t index, int32_t RecordingDeviceName(uint16_t index,
char name[kAdmMaxDeviceNameSize], char name[kAdmMaxDeviceNameSize],
char guid[kAdmMaxGuidSize]) override { char guid[kAdmMaxGuidSize]) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RETURN_IF_INPUT_RESTARTS(0); RETURN_IF_INPUT_RESTARTS(0);
std::string name_str, guid_str; std::string name_str, guid_str;
@ -221,7 +221,7 @@ class WindowsAudioDeviceModule : public AudioDeviceModuleForTest {
} }
int32_t SetPlayoutDevice(uint16_t index) override { int32_t SetPlayoutDevice(uint16_t index) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RETURN_IF_OUTPUT_RESTARTS(0); RETURN_IF_OUTPUT_RESTARTS(0);
return output_->SetDevice(index); return output_->SetDevice(index);
@ -229,33 +229,33 @@ class WindowsAudioDeviceModule : public AudioDeviceModuleForTest {
int32_t SetPlayoutDevice( int32_t SetPlayoutDevice(
AudioDeviceModule::WindowsDeviceType device) override { AudioDeviceModule::WindowsDeviceType device) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RETURN_IF_OUTPUT_RESTARTS(0); RETURN_IF_OUTPUT_RESTARTS(0);
return output_->SetDevice(device); return output_->SetDevice(device);
} }
int32_t SetRecordingDevice(uint16_t index) override { int32_t SetRecordingDevice(uint16_t index) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
return input_->SetDevice(index); return input_->SetDevice(index);
} }
int32_t SetRecordingDevice( int32_t SetRecordingDevice(
AudioDeviceModule::WindowsDeviceType device) override { AudioDeviceModule::WindowsDeviceType device) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
return input_->SetDevice(device); return input_->SetDevice(device);
} }
int32_t PlayoutIsAvailable(bool* available) override { int32_t PlayoutIsAvailable(bool* available) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
*available = true; *available = true;
return 0; return 0;
} }
int32_t InitPlayout() override { int32_t InitPlayout() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RETURN_IF_OUTPUT_RESTARTS(0); RETURN_IF_OUTPUT_RESTARTS(0);
RETURN_IF_OUTPUT_IS_INITIALIZED(0); RETURN_IF_OUTPUT_IS_INITIALIZED(0);
@ -263,21 +263,21 @@ class WindowsAudioDeviceModule : public AudioDeviceModuleForTest {
} }
bool PlayoutIsInitialized() const override { bool PlayoutIsInitialized() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RETURN_IF_OUTPUT_RESTARTS(true); RETURN_IF_OUTPUT_RESTARTS(true);
return output_->PlayoutIsInitialized(); return output_->PlayoutIsInitialized();
} }
int32_t RecordingIsAvailable(bool* available) override { int32_t RecordingIsAvailable(bool* available) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
*available = true; *available = true;
return 0; return 0;
} }
int32_t InitRecording() override { int32_t InitRecording() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RETURN_IF_INPUT_RESTARTS(0); RETURN_IF_INPUT_RESTARTS(0);
RETURN_IF_INPUT_IS_INITIALIZED(0); RETURN_IF_INPUT_IS_INITIALIZED(0);
@ -285,14 +285,14 @@ class WindowsAudioDeviceModule : public AudioDeviceModuleForTest {
} }
bool RecordingIsInitialized() const override { bool RecordingIsInitialized() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RETURN_IF_INPUT_RESTARTS(true); RETURN_IF_INPUT_RESTARTS(true);
return input_->RecordingIsInitialized(); return input_->RecordingIsInitialized();
} }
int32_t StartPlayout() override { int32_t StartPlayout() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RETURN_IF_OUTPUT_RESTARTS(0); RETURN_IF_OUTPUT_RESTARTS(0);
RETURN_IF_OUTPUT_IS_ACTIVE(0); RETURN_IF_OUTPUT_IS_ACTIVE(0);
@ -300,21 +300,21 @@ class WindowsAudioDeviceModule : public AudioDeviceModuleForTest {
} }
int32_t StopPlayout() override { int32_t StopPlayout() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RETURN_IF_OUTPUT_RESTARTS(-1); RETURN_IF_OUTPUT_RESTARTS(-1);
return output_->StopPlayout(); return output_->StopPlayout();
} }
bool Playing() const override { bool Playing() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RETURN_IF_OUTPUT_RESTARTS(true); RETURN_IF_OUTPUT_RESTARTS(true);
return output_->Playing(); return output_->Playing();
} }
int32_t StartRecording() override { int32_t StartRecording() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RETURN_IF_INPUT_RESTARTS(0); RETURN_IF_INPUT_RESTARTS(0);
RETURN_IF_INPUT_IS_ACTIVE(0); RETURN_IF_INPUT_IS_ACTIVE(0);
@ -322,41 +322,41 @@ class WindowsAudioDeviceModule : public AudioDeviceModuleForTest {
} }
int32_t StopRecording() override { int32_t StopRecording() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RETURN_IF_INPUT_RESTARTS(-1); RETURN_IF_INPUT_RESTARTS(-1);
return input_->StopRecording(); return input_->StopRecording();
} }
bool Recording() const override { bool Recording() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RETURN_IF_INPUT_RESTARTS(true); RETURN_IF_INPUT_RESTARTS(true);
return input_->Recording(); return input_->Recording();
} }
int32_t InitSpeaker() override { int32_t InitSpeaker() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RTC_DLOG(LS_WARNING) << "This method has no effect"; RTC_DLOG(LS_WARNING) << "This method has no effect";
return initialized_ ? 0 : -1; return initialized_ ? 0 : -1;
} }
bool SpeakerIsInitialized() const override { bool SpeakerIsInitialized() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RTC_DLOG(LS_WARNING) << "This method has no effect"; RTC_DLOG(LS_WARNING) << "This method has no effect";
return initialized_; return initialized_;
} }
int32_t InitMicrophone() override { int32_t InitMicrophone() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RTC_DLOG(LS_WARNING) << "This method has no effect"; RTC_DLOG(LS_WARNING) << "This method has no effect";
return initialized_ ? 0 : -1; return initialized_ ? 0 : -1;
} }
bool MicrophoneIsInitialized() const override { bool MicrophoneIsInitialized() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RTC_DLOG(LS_WARNING) << "This method has no effect"; RTC_DLOG(LS_WARNING) << "This method has no effect";
return initialized_; return initialized_;
@ -364,7 +364,7 @@ class WindowsAudioDeviceModule : public AudioDeviceModuleForTest {
int32_t SpeakerVolumeIsAvailable(bool* available) override { int32_t SpeakerVolumeIsAvailable(bool* available) override {
// TODO(henrika): improve support. // TODO(henrika): improve support.
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
*available = false; *available = false;
return 0; return 0;
@ -377,7 +377,7 @@ class WindowsAudioDeviceModule : public AudioDeviceModuleForTest {
int32_t MicrophoneVolumeIsAvailable(bool* available) override { int32_t MicrophoneVolumeIsAvailable(bool* available) override {
// TODO(henrika): improve support. // TODO(henrika): improve support.
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
*available = false; *available = false;
return 0; return 0;
@ -398,7 +398,7 @@ class WindowsAudioDeviceModule : public AudioDeviceModuleForTest {
int32_t StereoPlayoutIsAvailable(bool* available) const override { int32_t StereoPlayoutIsAvailable(bool* available) const override {
// TODO(henrika): improve support. // TODO(henrika): improve support.
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
*available = true; *available = true;
return 0; return 0;
@ -406,14 +406,14 @@ class WindowsAudioDeviceModule : public AudioDeviceModuleForTest {
int32_t SetStereoPlayout(bool enable) override { int32_t SetStereoPlayout(bool enable) override {
// TODO(henrika): improve support. // TODO(henrika): improve support.
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
return 0; return 0;
} }
int32_t StereoPlayout(bool* enabled) const override { int32_t StereoPlayout(bool* enabled) const override {
// TODO(henrika): improve support. // TODO(henrika): improve support.
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
*enabled = true; *enabled = true;
return 0; return 0;
@ -421,7 +421,7 @@ class WindowsAudioDeviceModule : public AudioDeviceModuleForTest {
int32_t StereoRecordingIsAvailable(bool* available) const override { int32_t StereoRecordingIsAvailable(bool* available) const override {
// TODO(henrika): improve support. // TODO(henrika): improve support.
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
*available = true; *available = true;
return 0; return 0;
@ -429,14 +429,14 @@ class WindowsAudioDeviceModule : public AudioDeviceModuleForTest {
int32_t SetStereoRecording(bool enable) override { int32_t SetStereoRecording(bool enable) override {
// TODO(henrika): improve support. // TODO(henrika): improve support.
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
return 0; return 0;
} }
int32_t StereoRecording(bool* enabled) const override { int32_t StereoRecording(bool* enabled) const override {
// TODO(henrika): improve support. // TODO(henrika): improve support.
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
*enabled = true; *enabled = true;
return 0; return 0;
@ -453,33 +453,33 @@ class WindowsAudioDeviceModule : public AudioDeviceModuleForTest {
int32_t EnableBuiltInNS(bool enable) override { return 0; } int32_t EnableBuiltInNS(bool enable) override { return 0; }
int32_t AttachAudioBuffer() { int32_t AttachAudioBuffer() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
output_->AttachAudioBuffer(audio_device_buffer_.get()); output_->AttachAudioBuffer(audio_device_buffer_.get());
input_->AttachAudioBuffer(audio_device_buffer_.get()); input_->AttachAudioBuffer(audio_device_buffer_.get());
return 0; return 0;
} }
int RestartPlayoutInternally() override { int RestartPlayoutInternally() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RETURN_IF_OUTPUT_RESTARTS(0); RETURN_IF_OUTPUT_RESTARTS(0);
return output_->RestartPlayout(); return output_->RestartPlayout();
} }
int RestartRecordingInternally() override { int RestartRecordingInternally() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
return input_->RestartRecording(); return input_->RestartRecording();
} }
int SetPlayoutSampleRate(uint32_t sample_rate) override { int SetPlayoutSampleRate(uint32_t sample_rate) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
return output_->SetSampleRate(sample_rate); return output_->SetSampleRate(sample_rate);
} }
int SetRecordingSampleRate(uint32_t sample_rate) override { int SetRecordingSampleRate(uint32_t sample_rate) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
return input_->SetSampleRate(sample_rate); return input_->SetSampleRate(sample_rate);
} }
@ -513,7 +513,7 @@ CreateWindowsCoreAudioAudioDeviceModuleFromInputAndOutput(
std::unique_ptr<AudioInput> audio_input, std::unique_ptr<AudioInput> audio_input,
std::unique_ptr<AudioOutput> audio_output, std::unique_ptr<AudioOutput> audio_output,
TaskQueueFactory* task_queue_factory) { TaskQueueFactory* task_queue_factory) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return rtc::make_ref_counted<WindowsAudioDeviceModule>( return rtc::make_ref_counted<WindowsAudioDeviceModule>(
std::move(audio_input), std::move(audio_output), task_queue_factory); std::move(audio_input), std::move(audio_output), task_queue_factory);
} }

79
modules/audio_device/win/core_audio_base_win.cc
View File

@ -125,7 +125,7 @@ const char* SessionDisconnectReasonToString(
bool IsLowLatencySupported(IAudioClient3* client3, bool IsLowLatencySupported(IAudioClient3* client3,
const WAVEFORMATEXTENSIBLE* format, const WAVEFORMATEXTENSIBLE* format,
uint32_t* min_period_in_frames) { uint32_t* min_period_in_frames) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
// Get the range of periodicities supported by the engine for the specified // Get the range of periodicities supported by the engine for the specified
// stream format. // stream format.
@ -143,7 +143,7 @@ bool IsLowLatencySupported(IAudioClient3* client3,
// default engine period. // default engine period.
// TODO(henrika): verify that this assumption is correct. // TODO(henrika): verify that this assumption is correct.
const bool low_latency = min_period < default_period; const bool low_latency = min_period < default_period;
RTC_LOG(INFO) << "low_latency: " << low_latency; RTC_LOG(LS_INFO) << "low_latency: " << low_latency;
*min_period_in_frames = low_latency ? min_period : 0; *min_period_in_frames = low_latency ? min_period : 0;
return low_latency; return low_latency;
} }
@ -161,9 +161,10 @@ CoreAudioBase::CoreAudioBase(Direction direction,
on_error_callback_(error_callback), on_error_callback_(error_callback),
device_index_(kUndefined), device_index_(kUndefined),
is_restarting_(false) { is_restarting_(false) {
RTC_DLOG(INFO) << __FUNCTION__ << "[" << DirectionToString(direction) << "]"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "[" << DirectionToString(direction)
RTC_DLOG(INFO) << "Automatic restart: " << automatic_restart; << "]";
RTC_DLOG(INFO) << "Windows version: " << rtc::rtc_win::GetVersion(); RTC_DLOG(LS_INFO) << "Automatic restart: " << automatic_restart;
RTC_DLOG(LS_INFO) << "Windows version: " << rtc::rtc_win::GetVersion();
// Create the event which the audio engine will signal each time a buffer // Create the event which the audio engine will signal each time a buffer
// becomes ready to be processed by the client. // becomes ready to be processed by the client.
@ -181,7 +182,7 @@ CoreAudioBase::CoreAudioBase(Direction direction,
} }
CoreAudioBase::~CoreAudioBase() { CoreAudioBase::~CoreAudioBase() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_EQ(ref_count_, 1); RTC_DCHECK_EQ(ref_count_, 1);
} }
@ -207,7 +208,7 @@ int CoreAudioBase::NumberOfEnumeratedDevices() const {
} }
void CoreAudioBase::ReleaseCOMObjects() { void CoreAudioBase::ReleaseCOMObjects() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
// ComPtr::Reset() sets the ComPtr to nullptr releasing any previous // ComPtr::Reset() sets the ComPtr to nullptr releasing any previous
// reference. // reference.
if (audio_client_) { if (audio_client_) {
@ -288,14 +289,14 @@ std::string CoreAudioBase::GetDeviceID(int index) const {
} }
int CoreAudioBase::SetDevice(int index) { int CoreAudioBase::SetDevice(int index) {
RTC_DLOG(INFO) << __FUNCTION__ << "[" << DirectionToString(direction()) RTC_DLOG(LS_INFO) << __FUNCTION__ << "[" << DirectionToString(direction())
<< "]: index=" << IndexToString(index); << "]: index=" << IndexToString(index);
if (initialized_) { if (initialized_) {
return -1; return -1;
} }
std::string device_id = GetDeviceID(index); std::string device_id = GetDeviceID(index);
RTC_DLOG(INFO) << "index=" << IndexToString(index) RTC_DLOG(LS_INFO) << "index=" << IndexToString(index)
<< " => device_id: " << device_id; << " => device_id: " << device_id;
device_index_ = index; device_index_ = index;
device_id_ = device_id; device_id_ = device_id;
@ -306,7 +307,7 @@ int CoreAudioBase::SetDevice(int index) {
int CoreAudioBase::DeviceName(int index, int CoreAudioBase::DeviceName(int index,
std::string* name, std::string* name,
std::string* guid) const { std::string* guid) const {
RTC_DLOG(INFO) << __FUNCTION__ << "[" << DirectionToString(direction()) RTC_DLOG(LS_INFO) << __FUNCTION__ << "[" << DirectionToString(direction())
<< "]: index=" << IndexToString(index); << "]: index=" << IndexToString(index);
if (index > NumberOfEnumeratedDevices() - 1) { if (index > NumberOfEnumeratedDevices() - 1) {
RTC_LOG(LS_ERROR) << "Invalid device index"; RTC_LOG(LS_ERROR) << "Invalid device index";
@ -324,16 +325,16 @@ int CoreAudioBase::DeviceName(int index,
} }
*name = device_names[index].device_name; *name = device_names[index].device_name;
RTC_DLOG(INFO) << "name: " << *name; RTC_DLOG(LS_INFO) << "name: " << *name;
if (guid != nullptr) { if (guid != nullptr) {
*guid = device_names[index].unique_id; *guid = device_names[index].unique_id;
RTC_DLOG(INFO) << "guid: " << *guid; RTC_DLOG(LS_INFO) << "guid: " << *guid;
} }
return 0; return 0;
} }
bool CoreAudioBase::Init() { bool CoreAudioBase::Init() {
RTC_DLOG(INFO) << __FUNCTION__ << "[" << DirectionToString(direction()) RTC_DLOG(LS_INFO) << __FUNCTION__ << "[" << DirectionToString(direction())
<< "]"; << "]";
RTC_DCHECK_GE(device_index_, 0); RTC_DCHECK_GE(device_index_, 0);
RTC_DCHECK(!device_id_.empty()); RTC_DCHECK(!device_id_.empty());
@ -360,15 +361,15 @@ bool CoreAudioBase::Init() {
// an audio stream between an audio application and the audio engine. // an audio stream between an audio application and the audio engine.
ComPtr<IAudioClient> audio_client; ComPtr<IAudioClient> audio_client;
if (core_audio_utility::GetAudioClientVersion() == 3) { if (core_audio_utility::GetAudioClientVersion() == 3) {
RTC_DLOG(INFO) << "Using IAudioClient3"; RTC_DLOG(LS_INFO) << "Using IAudioClient3";
audio_client = audio_client =
core_audio_utility::CreateClient3(device_id, GetDataFlow(), role); core_audio_utility::CreateClient3(device_id, GetDataFlow(), role);
} else if (core_audio_utility::GetAudioClientVersion() == 2) { } else if (core_audio_utility::GetAudioClientVersion() == 2) {
RTC_DLOG(INFO) << "Using IAudioClient2"; RTC_DLOG(LS_INFO) << "Using IAudioClient2";
audio_client = audio_client =
core_audio_utility::CreateClient2(device_id, GetDataFlow(), role); core_audio_utility::CreateClient2(device_id, GetDataFlow(), role);
} else { } else {
RTC_DLOG(INFO) << "Using IAudioClient"; RTC_DLOG(LS_INFO) << "Using IAudioClient";
audio_client = audio_client =
core_audio_utility::CreateClient(device_id, GetDataFlow(), role); core_audio_utility::CreateClient(device_id, GetDataFlow(), role);
} }
@ -429,7 +430,7 @@ bool CoreAudioBase::Init() {
format_.dwChannelMask = format_.dwChannelMask =
format->nChannels == 1 ? KSAUDIO_SPEAKER_MONO : KSAUDIO_SPEAKER_STEREO; format->nChannels == 1 ? KSAUDIO_SPEAKER_MONO : KSAUDIO_SPEAKER_STEREO;
format_.SubFormat = KSDATAFORMAT_SUBTYPE_PCM; format_.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
RTC_DLOG(INFO) << core_audio_utility::WaveFormatToString(&format_); RTC_DLOG(LS_INFO) << core_audio_utility::WaveFormatToString(&format_);
// Verify that the format is supported but exclude the test if the default // Verify that the format is supported but exclude the test if the default
// sample rate has been overridden. If so, the WASAPI audio engine will do // sample rate has been overridden. If so, the WASAPI audio engine will do
@ -502,7 +503,7 @@ bool CoreAudioBase::Init() {
1000.0L; 1000.0L;
const int preferred_frames_per_buffer = const int preferred_frames_per_buffer =
static_cast<int>(params.sample_rate() * device_period_in_seconds + 0.5); static_cast<int>(params.sample_rate() * device_period_in_seconds + 0.5);
RTC_DLOG(INFO) << "preferred_frames_per_buffer: " RTC_DLOG(LS_INFO) << "preferred_frames_per_buffer: "
<< preferred_frames_per_buffer; << preferred_frames_per_buffer;
if (preferred_frames_per_buffer % params.frames_per_buffer()) { if (preferred_frames_per_buffer % params.frames_per_buffer()) {
RTC_LOG(WARNING) << "Buffer size of " << params.frames_per_buffer() RTC_LOG(WARNING) << "Buffer size of " << params.frames_per_buffer()
@ -525,7 +526,7 @@ bool CoreAudioBase::Init() {
if (FAILED(audio_session_control->GetState(&state))) { if (FAILED(audio_session_control->GetState(&state))) {
return false; return false;
} }
RTC_DLOG(INFO) << "audio session state: " << SessionStateToString(state); RTC_DLOG(LS_INFO) << "audio session state: " << SessionStateToString(state);
RTC_DCHECK_EQ(state, AudioSessionStateInactive); RTC_DCHECK_EQ(state, AudioSessionStateInactive);
// Register the client to receive notifications of session events, including // Register the client to receive notifications of session events, including
@ -542,7 +543,7 @@ bool CoreAudioBase::Init() {
} }
bool CoreAudioBase::Start() { bool CoreAudioBase::Start() {
RTC_DLOG(INFO) << __FUNCTION__ << "[" << DirectionToString(direction()) RTC_DLOG(LS_INFO) << __FUNCTION__ << "[" << DirectionToString(direction())
<< "]"; << "]";
if (IsRestarting()) { if (IsRestarting()) {
// Audio thread should be alive during internal restart since the restart // Audio thread should be alive during internal restart since the restart
@ -559,7 +560,7 @@ bool CoreAudioBase::Start() {
audio_thread_ = rtc::PlatformThread::SpawnJoinable( audio_thread_ = rtc::PlatformThread::SpawnJoinable(
[this] { ThreadRun(); }, name, [this] { ThreadRun(); }, name,
rtc::ThreadAttributes().SetPriority(rtc::ThreadPriority::kRealtime)); rtc::ThreadAttributes().SetPriority(rtc::ThreadPriority::kRealtime));
RTC_DLOG(INFO) << "Started thread with name: " << name RTC_DLOG(LS_INFO) << "Started thread with name: " << name
<< " and handle: " << *audio_thread_.GetHandle(); << " and handle: " << *audio_thread_.GetHandle();
} }
@ -579,9 +580,9 @@ bool CoreAudioBase::Start() {
} }
bool CoreAudioBase::Stop() { bool CoreAudioBase::Stop() {
RTC_DLOG(INFO) << __FUNCTION__ << "[" << DirectionToString(direction()) RTC_DLOG(LS_INFO) << __FUNCTION__ << "[" << DirectionToString(direction())
<< "]"; << "]";
RTC_DLOG(INFO) << "total activity time: " << TimeSinceStart(); RTC_DLOG(LS_INFO) << "total activity time: " << TimeSinceStart();
// Stop audio streaming. // Stop audio streaming.
_com_error error = audio_client_->Stop(); _com_error error = audio_client_->Stop();
@ -614,7 +615,7 @@ bool CoreAudioBase::Stop() {
// Delete the previous registration by the client to receive notifications // Delete the previous registration by the client to receive notifications
// about audio session events. // about audio session events.
RTC_DLOG(INFO) << "audio session state: " RTC_DLOG(LS_INFO) << "audio session state: "
<< SessionStateToString(GetAudioSessionState()); << SessionStateToString(GetAudioSessionState());
error = audio_session_control_->UnregisterAudioSessionNotification(this); error = audio_session_control_->UnregisterAudioSessionNotification(this);
if (FAILED(error.Error())) { if (FAILED(error.Error())) {
@ -663,7 +664,7 @@ bool CoreAudioBase::IsVolumeControlAvailable(bool* available) const {
<< core_audio_utility::ErrorToString(error); << core_audio_utility::ErrorToString(error);
*available = false; *available = false;
} }
RTC_DLOG(INFO) << "master volume for output audio session: " << volume; RTC_DLOG(LS_INFO) << "master volume for output audio session: " << volume;
*available = true; *available = true;
return false; return false;
@ -674,7 +675,7 @@ bool CoreAudioBase::IsVolumeControlAvailable(bool* available) const {
// device notifications. Hence, the emulated restart sequence covers most parts // device notifications. Hence, the emulated restart sequence covers most parts
// of a real sequence expect the actual device switch. // of a real sequence expect the actual device switch.
bool CoreAudioBase::Restart() { bool CoreAudioBase::Restart() {
RTC_DLOG(INFO) << __FUNCTION__ << "[" << DirectionToString(direction()) RTC_DLOG(LS_INFO) << __FUNCTION__ << "[" << DirectionToString(direction())
<< "]"; << "]";
if (!automatic_restart()) { if (!automatic_restart()) {
return false; return false;
@ -685,12 +686,12 @@ bool CoreAudioBase::Restart() {
} }
void CoreAudioBase::StopThread() { void CoreAudioBase::StopThread() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK(!IsRestarting()); RTC_DCHECK(!IsRestarting());
if (!audio_thread_.empty()) { if (!audio_thread_.empty()) {
RTC_DLOG(INFO) << "Sets stop_event..."; RTC_DLOG(LS_INFO) << "Sets stop_event...";
SetEvent(stop_event_.Get()); SetEvent(stop_event_.Get());
RTC_DLOG(INFO) << "PlatformThread::Finalize..."; RTC_DLOG(LS_INFO) << "PlatformThread::Finalize...";
audio_thread_.Finalize(); audio_thread_.Finalize();
// Ensure that we don't quit the main thread loop immediately next // Ensure that we don't quit the main thread loop immediately next
@ -701,7 +702,7 @@ void CoreAudioBase::StopThread() {
} }
bool CoreAudioBase::HandleRestartEvent() { bool CoreAudioBase::HandleRestartEvent() {
RTC_DLOG(INFO) << __FUNCTION__ << "[" << DirectionToString(direction()) RTC_DLOG(LS_INFO) << __FUNCTION__ << "[" << DirectionToString(direction())
<< "]"; << "]";
RTC_DCHECK_RUN_ON(&thread_checker_audio_); RTC_DCHECK_RUN_ON(&thread_checker_audio_);
RTC_DCHECK(!audio_thread_.empty()); RTC_DCHECK(!audio_thread_.empty());
@ -716,12 +717,12 @@ bool CoreAudioBase::HandleRestartEvent() {
} }
bool CoreAudioBase::SwitchDeviceIfNeeded() { bool CoreAudioBase::SwitchDeviceIfNeeded() {
RTC_DLOG(INFO) << __FUNCTION__ << "[" << DirectionToString(direction()) RTC_DLOG(LS_INFO) << __FUNCTION__ << "[" << DirectionToString(direction())
<< "]"; << "]";
RTC_DCHECK_RUN_ON(&thread_checker_audio_); RTC_DCHECK_RUN_ON(&thread_checker_audio_);
RTC_DCHECK(IsRestarting()); RTC_DCHECK(IsRestarting());
RTC_DLOG(INFO) << "device_index=" << device_index_ RTC_DLOG(LS_INFO) << "device_index=" << device_index_
<< " => device_id: " << device_id_; << " => device_id: " << device_id_;
// Ensure that at least one device exists and can be utilized. The most // Ensure that at least one device exists and can be utilized. The most
@ -746,7 +747,7 @@ bool CoreAudioBase::SwitchDeviceIfNeeded() {
return false; return false;
} }
} else { } else {
RTC_LOG(INFO) RTC_LOG(LS_INFO)
<< "Device configuration has not changed => keeping selected device"; << "Device configuration has not changed => keeping selected device";
} }
return true; return true;
@ -766,14 +767,14 @@ AudioSessionState CoreAudioBase::GetAudioSessionState() const {
// TODO(henrika): only used for debugging purposes currently. // TODO(henrika): only used for debugging purposes currently.
ULONG CoreAudioBase::AddRef() { ULONG CoreAudioBase::AddRef() {
ULONG new_ref = InterlockedIncrement(&ref_count_); ULONG new_ref = InterlockedIncrement(&ref_count_);
// RTC_DLOG(INFO) << "__AddRef => " << new_ref; // RTC_DLOG(LS_INFO) << "__AddRef => " << new_ref;
return new_ref; return new_ref;
} }
// TODO(henrika): does not call delete this. // TODO(henrika): does not call delete this.
ULONG CoreAudioBase::Release() { ULONG CoreAudioBase::Release() {
ULONG new_ref = InterlockedDecrement(&ref_count_); ULONG new_ref = InterlockedDecrement(&ref_count_);
// RTC_DLOG(INFO) << "__Release => " << new_ref; // RTC_DLOG(LS_INFO) << "__Release => " << new_ref;
return new_ref; return new_ref;
} }
@ -792,7 +793,7 @@ HRESULT CoreAudioBase::QueryInterface(REFIID iid, void** object) {
// IAudioSessionEvents::OnStateChanged. // IAudioSessionEvents::OnStateChanged.
HRESULT CoreAudioBase::OnStateChanged(AudioSessionState new_state) { HRESULT CoreAudioBase::OnStateChanged(AudioSessionState new_state) {
RTC_DLOG(INFO) << "___" << __FUNCTION__ << "[" RTC_DLOG(LS_INFO) << "___" << __FUNCTION__ << "["
<< DirectionToString(direction()) << DirectionToString(direction())
<< "] new_state: " << SessionStateToString(new_state); << "] new_state: " << SessionStateToString(new_state);
return S_OK; return S_OK;
@ -806,7 +807,7 @@ HRESULT CoreAudioBase::OnStateChanged(AudioSessionState new_state) {
// same event. // same event.
HRESULT CoreAudioBase::OnSessionDisconnected( HRESULT CoreAudioBase::OnSessionDisconnected(
AudioSessionDisconnectReason disconnect_reason) { AudioSessionDisconnectReason disconnect_reason) {
RTC_DLOG(INFO) << "___" << __FUNCTION__ << "[" RTC_DLOG(LS_INFO) << "___" << __FUNCTION__ << "["
<< DirectionToString(direction()) << "] reason: " << DirectionToString(direction()) << "] reason: "
<< SessionDisconnectReasonToString(disconnect_reason); << SessionDisconnectReasonToString(disconnect_reason);
// Ignore changes in the audio session (don't try to restart) if the user // Ignore changes in the audio session (don't try to restart) if the user
@ -869,7 +870,7 @@ void CoreAudioBase::ThreadRun() {
RTC_LOG(LS_ERROR) << "MMCSS is not supported"; RTC_LOG(LS_ERROR) << "MMCSS is not supported";
return; return;
} }
RTC_DLOG(INFO) << "[" << DirectionToString(direction()) RTC_DLOG(LS_INFO) << "[" << DirectionToString(direction())
<< "] ThreadRun starts..."; << "] ThreadRun starts...";
// TODO(henrika): difference between "Pro Audio" and "Audio"? // TODO(henrika): difference between "Pro Audio" and "Audio"?
ScopedMMCSSRegistration mmcss_registration(L"Pro Audio"); ScopedMMCSSRegistration mmcss_registration(L"Pro Audio");
@ -938,7 +939,7 @@ void CoreAudioBase::ThreadRun() {
// this stream should be destroyed instead of reused in the future. // this stream should be destroyed instead of reused in the future.
} }
RTC_DLOG(INFO) << "[" << DirectionToString(direction()) RTC_DLOG(LS_INFO) << "[" << DirectionToString(direction())
<< "] ...ThreadRun stops"; << "] ...ThreadRun stops";
} }

44
modules/audio_device/win/core_audio_input_win.cc
View File

@ -33,24 +33,24 @@ CoreAudioInput::CoreAudioInput(bool automatic_restart)
automatic_restart, automatic_restart,
[this](uint64_t freq) { return OnDataCallback(freq); }, [this](uint64_t freq) { return OnDataCallback(freq); },
[this](ErrorType err) { return OnErrorCallback(err); }) { [this](ErrorType err) { return OnErrorCallback(err); }) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
thread_checker_audio_.Detach(); thread_checker_audio_.Detach();
} }
CoreAudioInput::~CoreAudioInput() { CoreAudioInput::~CoreAudioInput() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
} }
int CoreAudioInput::Init() { int CoreAudioInput::Init() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
return 0; return 0;
} }
int CoreAudioInput::Terminate() { int CoreAudioInput::Terminate() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
StopRecording(); StopRecording();
return 0; return 0;
@ -62,14 +62,14 @@ int CoreAudioInput::NumDevices() const {
} }
int CoreAudioInput::SetDevice(int index) { int CoreAudioInput::SetDevice(int index) {
RTC_DLOG(INFO) << __FUNCTION__ << ": " << index; RTC_DLOG(LS_INFO) << __FUNCTION__ << ": " << index;
RTC_DCHECK_GE(index, 0); RTC_DCHECK_GE(index, 0);
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
return CoreAudioBase::SetDevice(index); return CoreAudioBase::SetDevice(index);
} }
int CoreAudioInput::SetDevice(AudioDeviceModule::WindowsDeviceType device) { int CoreAudioInput::SetDevice(AudioDeviceModule::WindowsDeviceType device) {
RTC_DLOG(INFO) << __FUNCTION__ << ": " RTC_DLOG(LS_INFO) << __FUNCTION__ << ": "
<< ((device == AudioDeviceModule::kDefaultDevice) << ((device == AudioDeviceModule::kDefaultDevice)
? "Default" ? "Default"
: "DefaultCommunication"); : "DefaultCommunication");
@ -80,26 +80,26 @@ int CoreAudioInput::SetDevice(AudioDeviceModule::WindowsDeviceType device) {
int CoreAudioInput::DeviceName(int index, int CoreAudioInput::DeviceName(int index,
std::string* name, std::string* name,
std::string* guid) { std::string* guid) {
RTC_DLOG(INFO) << __FUNCTION__ << ": " << index; RTC_DLOG(LS_INFO) << __FUNCTION__ << ": " << index;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RTC_DCHECK(name); RTC_DCHECK(name);
return CoreAudioBase::DeviceName(index, name, guid); return CoreAudioBase::DeviceName(index, name, guid);
} }
void CoreAudioInput::AttachAudioBuffer(AudioDeviceBuffer* audio_buffer) { void CoreAudioInput::AttachAudioBuffer(AudioDeviceBuffer* audio_buffer) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
audio_device_buffer_ = audio_buffer; audio_device_buffer_ = audio_buffer;
} }
bool CoreAudioInput::RecordingIsInitialized() const { bool CoreAudioInput::RecordingIsInitialized() const {
RTC_DLOG(INFO) << __FUNCTION__ << ": " << initialized_; RTC_DLOG(LS_INFO) << __FUNCTION__ << ": " << initialized_;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
return initialized_; return initialized_;
} }
int CoreAudioInput::InitRecording() { int CoreAudioInput::InitRecording() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK(!initialized_); RTC_DCHECK(!initialized_);
RTC_DCHECK(!Recording()); RTC_DCHECK(!Recording());
RTC_DCHECK(!audio_capture_client_); RTC_DCHECK(!audio_capture_client_);
@ -155,7 +155,7 @@ int CoreAudioInput::InitRecording() {
} }
int CoreAudioInput::StartRecording() { int CoreAudioInput::StartRecording() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK(!Recording()); RTC_DCHECK(!Recording());
RTC_DCHECK(fine_audio_buffer_); RTC_DCHECK(fine_audio_buffer_);
RTC_DCHECK(audio_device_buffer_); RTC_DCHECK(audio_device_buffer_);
@ -179,7 +179,7 @@ int CoreAudioInput::StartRecording() {
} }
int CoreAudioInput::StopRecording() { int CoreAudioInput::StopRecording() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
if (!initialized_) { if (!initialized_) {
return 0; return 0;
} }
@ -214,7 +214,7 @@ int CoreAudioInput::StopRecording() {
} }
bool CoreAudioInput::Recording() { bool CoreAudioInput::Recording() {
RTC_DLOG(INFO) << __FUNCTION__ << ": " << is_active_; RTC_DLOG(LS_INFO) << __FUNCTION__ << ": " << is_active_;
return is_active_; return is_active_;
} }
@ -222,7 +222,7 @@ bool CoreAudioInput::Recording() {
// are not compatible with the old ADM implementation since it allows accessing // are not compatible with the old ADM implementation since it allows accessing
// the volume control with any active audio output stream. // the volume control with any active audio output stream.
int CoreAudioInput::VolumeIsAvailable(bool* available) { int CoreAudioInput::VolumeIsAvailable(bool* available) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
return IsVolumeControlAvailable(available) ? 0 : -1; return IsVolumeControlAvailable(available) ? 0 : -1;
} }
@ -230,7 +230,7 @@ int CoreAudioInput::VolumeIsAvailable(bool* available) {
// Triggers the restart sequence. Only used for testing purposes to emulate // Triggers the restart sequence. Only used for testing purposes to emulate
// a real event where e.g. an active input device is removed. // a real event where e.g. an active input device is removed.
int CoreAudioInput::RestartRecording() { int CoreAudioInput::RestartRecording() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
if (!Recording()) { if (!Recording()) {
return 0; return 0;
@ -249,14 +249,14 @@ bool CoreAudioInput::Restarting() const {
} }
int CoreAudioInput::SetSampleRate(uint32_t sample_rate) { int CoreAudioInput::SetSampleRate(uint32_t sample_rate) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
sample_rate_ = sample_rate; sample_rate_ = sample_rate;
return 0; return 0;
} }
void CoreAudioInput::ReleaseCOMObjects() { void CoreAudioInput::ReleaseCOMObjects() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CoreAudioBase::ReleaseCOMObjects(); CoreAudioBase::ReleaseCOMObjects();
if (audio_capture_client_.Get()) { if (audio_capture_client_.Get()) {
audio_capture_client_.Reset(); audio_capture_client_.Reset();
@ -273,7 +273,7 @@ bool CoreAudioInput::OnDataCallback(uint64_t device_frequency) {
return false; return false;
} }
if (num_data_callbacks_ == 0) { if (num_data_callbacks_ == 0) {
RTC_LOG(INFO) << "--- Input audio stream is alive ---"; RTC_LOG(LS_INFO) << "--- Input audio stream is alive ---";
} }
UINT32 num_frames_in_next_packet = 0; UINT32 num_frames_in_next_packet = 0;
_com_error error = _com_error error =
@ -328,7 +328,7 @@ bool CoreAudioInput::OnDataCallback(uint64_t device_frequency) {
} }
} }
if (num_data_callbacks_ % 500 == 0) { if (num_data_callbacks_ % 500 == 0) {
RTC_DLOG(INFO) << "latency: " << latency_ms_; RTC_DLOG(LS_INFO) << "latency: " << latency_ms_;
} }
// The data in the packet is not correlated with the previous packet's // The data in the packet is not correlated with the previous packet's
@ -382,7 +382,7 @@ bool CoreAudioInput::OnDataCallback(uint64_t device_frequency) {
} }
bool CoreAudioInput::OnErrorCallback(ErrorType error) { bool CoreAudioInput::OnErrorCallback(ErrorType error) {
RTC_DLOG(INFO) << __FUNCTION__ << ": " << as_integer(error); RTC_DLOG(LS_INFO) << __FUNCTION__ << ": " << as_integer(error);
RTC_DCHECK_RUN_ON(&thread_checker_audio_); RTC_DCHECK_RUN_ON(&thread_checker_audio_);
if (error == CoreAudioBase::ErrorType::kStreamDisconnected) { if (error == CoreAudioBase::ErrorType::kStreamDisconnected) {
HandleStreamDisconnected(); HandleStreamDisconnected();
@ -426,7 +426,7 @@ absl::optional<int> CoreAudioInput::EstimateLatencyMillis(
// safe. // safe.
// TODO(henrika): add more details. // TODO(henrika): add more details.
bool CoreAudioInput::HandleStreamDisconnected() { bool CoreAudioInput::HandleStreamDisconnected() {
RTC_DLOG(INFO) << "<<<--- " << __FUNCTION__; RTC_DLOG(LS_INFO) << "<<<--- " << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_audio_); RTC_DCHECK_RUN_ON(&thread_checker_audio_);
RTC_DCHECK(automatic_restart()); RTC_DCHECK(automatic_restart());
@ -445,7 +445,7 @@ bool CoreAudioInput::HandleStreamDisconnected() {
return false; return false;
} }
RTC_DLOG(INFO) << __FUNCTION__ << " --->>>"; RTC_DLOG(LS_INFO) << __FUNCTION__ << " --->>>";
return true; return true;
} }

46
modules/audio_device/win/core_audio_output_win.cc
View File

@ -29,25 +29,25 @@ CoreAudioOutput::CoreAudioOutput(bool automatic_restart)
automatic_restart, automatic_restart,
[this](uint64_t freq) { return OnDataCallback(freq); }, [this](uint64_t freq) { return OnDataCallback(freq); },
[this](ErrorType err) { return OnErrorCallback(err); }) { [this](ErrorType err) { return OnErrorCallback(err); }) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
thread_checker_audio_.Detach(); thread_checker_audio_.Detach();
} }
CoreAudioOutput::~CoreAudioOutput() { CoreAudioOutput::~CoreAudioOutput() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
Terminate(); Terminate();
} }
int CoreAudioOutput::Init() { int CoreAudioOutput::Init() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
return 0; return 0;
} }
int CoreAudioOutput::Terminate() { int CoreAudioOutput::Terminate() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
StopPlayout(); StopPlayout();
return 0; return 0;
@ -59,14 +59,14 @@ int CoreAudioOutput::NumDevices() const {
} }
int CoreAudioOutput::SetDevice(int index) { int CoreAudioOutput::SetDevice(int index) {
RTC_DLOG(INFO) << __FUNCTION__ << ": " << index; RTC_DLOG(LS_INFO) << __FUNCTION__ << ": " << index;
RTC_DCHECK_GE(index, 0); RTC_DCHECK_GE(index, 0);
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
return CoreAudioBase::SetDevice(index); return CoreAudioBase::SetDevice(index);
} }
int CoreAudioOutput::SetDevice(AudioDeviceModule::WindowsDeviceType device) { int CoreAudioOutput::SetDevice(AudioDeviceModule::WindowsDeviceType device) {
RTC_DLOG(INFO) << __FUNCTION__ << ": " RTC_DLOG(LS_INFO) << __FUNCTION__ << ": "
<< ((device == AudioDeviceModule::kDefaultDevice) << ((device == AudioDeviceModule::kDefaultDevice)
? "Default" ? "Default"
: "DefaultCommunication"); : "DefaultCommunication");
@ -77,26 +77,26 @@ int CoreAudioOutput::SetDevice(AudioDeviceModule::WindowsDeviceType device) {
int CoreAudioOutput::DeviceName(int index, int CoreAudioOutput::DeviceName(int index,
std::string* name, std::string* name,
std::string* guid) { std::string* guid) {
RTC_DLOG(INFO) << __FUNCTION__ << ": " << index; RTC_DLOG(LS_INFO) << __FUNCTION__ << ": " << index;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RTC_DCHECK(name); RTC_DCHECK(name);
return CoreAudioBase::DeviceName(index, name, guid); return CoreAudioBase::DeviceName(index, name, guid);
} }
void CoreAudioOutput::AttachAudioBuffer(AudioDeviceBuffer* audio_buffer) { void CoreAudioOutput::AttachAudioBuffer(AudioDeviceBuffer* audio_buffer) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
audio_device_buffer_ = audio_buffer; audio_device_buffer_ = audio_buffer;
} }
bool CoreAudioOutput::PlayoutIsInitialized() const { bool CoreAudioOutput::PlayoutIsInitialized() const {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
return initialized_; return initialized_;
} }
int CoreAudioOutput::InitPlayout() { int CoreAudioOutput::InitPlayout() {
RTC_DLOG(INFO) << __FUNCTION__ << ": " << IsRestarting(); RTC_DLOG(LS_INFO) << __FUNCTION__ << ": " << IsRestarting();
RTC_DCHECK(!initialized_); RTC_DCHECK(!initialized_);
RTC_DCHECK(!Playing()); RTC_DCHECK(!Playing());
RTC_DCHECK(!audio_render_client_); RTC_DCHECK(!audio_render_client_);
@ -150,7 +150,7 @@ int CoreAudioOutput::InitPlayout() {
} }
int CoreAudioOutput::StartPlayout() { int CoreAudioOutput::StartPlayout() {
RTC_DLOG(INFO) << __FUNCTION__ << ": " << IsRestarting(); RTC_DLOG(LS_INFO) << __FUNCTION__ << ": " << IsRestarting();
RTC_DCHECK(!Playing()); RTC_DCHECK(!Playing());
RTC_DCHECK(fine_audio_buffer_); RTC_DCHECK(fine_audio_buffer_);
RTC_DCHECK(audio_device_buffer_); RTC_DCHECK(audio_device_buffer_);
@ -180,7 +180,7 @@ int CoreAudioOutput::StartPlayout() {
} }
int CoreAudioOutput::StopPlayout() { int CoreAudioOutput::StopPlayout() {
RTC_DLOG(INFO) << __FUNCTION__ << ": " << IsRestarting(); RTC_DLOG(LS_INFO) << __FUNCTION__ << ": " << IsRestarting();
if (!initialized_) { if (!initialized_) {
return 0; return 0;
} }
@ -214,7 +214,7 @@ int CoreAudioOutput::StopPlayout() {
} }
bool CoreAudioOutput::Playing() { bool CoreAudioOutput::Playing() {
RTC_DLOG(INFO) << __FUNCTION__ << ": " << is_active_; RTC_DLOG(LS_INFO) << __FUNCTION__ << ": " << is_active_;
return is_active_; return is_active_;
} }
@ -222,7 +222,7 @@ bool CoreAudioOutput::Playing() {
// are not compatible with the old ADM implementation since it allows accessing // are not compatible with the old ADM implementation since it allows accessing
// the volume control with any active audio output stream. // the volume control with any active audio output stream.
int CoreAudioOutput::VolumeIsAvailable(bool* available) { int CoreAudioOutput::VolumeIsAvailable(bool* available) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
return IsVolumeControlAvailable(available) ? 0 : -1; return IsVolumeControlAvailable(available) ? 0 : -1;
} }
@ -230,7 +230,7 @@ int CoreAudioOutput::VolumeIsAvailable(bool* available) {
// Triggers the restart sequence. Only used for testing purposes to emulate // Triggers the restart sequence. Only used for testing purposes to emulate
// a real event where e.g. an active output device is removed. // a real event where e.g. an active output device is removed.
int CoreAudioOutput::RestartPlayout() { int CoreAudioOutput::RestartPlayout() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
if (!Playing()) { if (!Playing()) {
return 0; return 0;
@ -243,20 +243,20 @@ int CoreAudioOutput::RestartPlayout() {
} }
bool CoreAudioOutput::Restarting() const { bool CoreAudioOutput::Restarting() const {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
return IsRestarting(); return IsRestarting();
} }
int CoreAudioOutput::SetSampleRate(uint32_t sample_rate) { int CoreAudioOutput::SetSampleRate(uint32_t sample_rate) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
sample_rate_ = sample_rate; sample_rate_ = sample_rate;
return 0; return 0;
} }
void CoreAudioOutput::ReleaseCOMObjects() { void CoreAudioOutput::ReleaseCOMObjects() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CoreAudioBase::ReleaseCOMObjects(); CoreAudioBase::ReleaseCOMObjects();
if (audio_render_client_.Get()) { if (audio_render_client_.Get()) {
audio_render_client_.Reset(); audio_render_client_.Reset();
@ -264,7 +264,7 @@ void CoreAudioOutput::ReleaseCOMObjects() {
} }
bool CoreAudioOutput::OnErrorCallback(ErrorType error) { bool CoreAudioOutput::OnErrorCallback(ErrorType error) {
RTC_DLOG(INFO) << __FUNCTION__ << ": " << as_integer(error); RTC_DLOG(LS_INFO) << __FUNCTION__ << ": " << as_integer(error);
RTC_DCHECK_RUN_ON(&thread_checker_audio_); RTC_DCHECK_RUN_ON(&thread_checker_audio_);
if (!initialized_ || !Playing()) { if (!initialized_ || !Playing()) {
return true; return true;
@ -281,7 +281,7 @@ bool CoreAudioOutput::OnErrorCallback(ErrorType error) {
bool CoreAudioOutput::OnDataCallback(uint64_t device_frequency) { bool CoreAudioOutput::OnDataCallback(uint64_t device_frequency) {
RTC_DCHECK_RUN_ON(&thread_checker_audio_); RTC_DCHECK_RUN_ON(&thread_checker_audio_);
if (num_data_callbacks_ == 0) { if (num_data_callbacks_ == 0) {
RTC_LOG(INFO) << "--- Output audio stream is alive ---"; RTC_LOG(LS_INFO) << "--- Output audio stream is alive ---";
} }
// Get the padding value which indicates the amount of valid unread data that // Get the padding value which indicates the amount of valid unread data that
// the endpoint buffer currently contains. // the endpoint buffer currently contains.
@ -329,7 +329,7 @@ bool CoreAudioOutput::OnDataCallback(uint64_t device_frequency) {
// TODO(henrika): note that FineAudioBuffer adds latency as well. // TODO(henrika): note that FineAudioBuffer adds latency as well.
latency_ms_ = EstimateOutputLatencyMillis(device_frequency); latency_ms_ = EstimateOutputLatencyMillis(device_frequency);
if (num_data_callbacks_ % 500 == 0) { if (num_data_callbacks_ % 500 == 0) {
RTC_DLOG(INFO) << "latency: " << latency_ms_; RTC_DLOG(LS_INFO) << "latency: " << latency_ms_;
} }
} }
@ -394,7 +394,7 @@ int CoreAudioOutput::EstimateOutputLatencyMillis(uint64_t device_frequency) {
// safe. // safe.
// TODO(henrika): add more details. // TODO(henrika): add more details.
bool CoreAudioOutput::HandleStreamDisconnected() { bool CoreAudioOutput::HandleStreamDisconnected() {
RTC_DLOG(INFO) << "<<<--- " << __FUNCTION__; RTC_DLOG(LS_INFO) << "<<<--- " << __FUNCTION__;
RTC_DCHECK_RUN_ON(&thread_checker_audio_); RTC_DCHECK_RUN_ON(&thread_checker_audio_);
RTC_DCHECK(automatic_restart()); RTC_DCHECK(automatic_restart());
@ -413,7 +413,7 @@ bool CoreAudioOutput::HandleStreamDisconnected() {
return false; return false;
} }
RTC_DLOG(INFO) << __FUNCTION__ << " --->>>"; RTC_DLOG(LS_INFO) << __FUNCTION__ << " --->>>";
return true; return true;
} }

171
modules/audio_device/win/core_audio_utility_win.cc
View File

@ -205,7 +205,7 @@ bool LoadAudiosesDll() {
L"%WINDIR%\\system32\\audioses.dll"; L"%WINDIR%\\system32\\audioses.dll";
wchar_t path[MAX_PATH] = {0}; wchar_t path[MAX_PATH] = {0};
ExpandEnvironmentStringsW(kAudiosesDLL, path, arraysize(path)); ExpandEnvironmentStringsW(kAudiosesDLL, path, arraysize(path));
RTC_DLOG(INFO) << rtc::ToUtf8(path); RTC_DLOG(LS_INFO) << rtc::ToUtf8(path);
return (LoadLibraryExW(path, nullptr, LOAD_WITH_ALTERED_SEARCH_PATH) != return (LoadLibraryExW(path, nullptr, LOAD_WITH_ALTERED_SEARCH_PATH) !=
nullptr); nullptr);
} }
@ -214,7 +214,7 @@ bool LoadAvrtDll() {
static const wchar_t* const kAvrtDLL = L"%WINDIR%\\system32\\Avrt.dll"; static const wchar_t* const kAvrtDLL = L"%WINDIR%\\system32\\Avrt.dll";
wchar_t path[MAX_PATH] = {0}; wchar_t path[MAX_PATH] = {0};
ExpandEnvironmentStringsW(kAvrtDLL, path, arraysize(path)); ExpandEnvironmentStringsW(kAvrtDLL, path, arraysize(path));
RTC_DLOG(INFO) << rtc::ToUtf8(path); RTC_DLOG(LS_INFO) << rtc::ToUtf8(path);
return (LoadLibraryExW(path, nullptr, LOAD_WITH_ALTERED_SEARCH_PATH) != return (LoadLibraryExW(path, nullptr, LOAD_WITH_ALTERED_SEARCH_PATH) !=
nullptr); nullptr);
} }
@ -283,7 +283,7 @@ bool IsDeviceActive(IMMDevice* device) {
ComPtr<IMMDevice> CreateDeviceInternal(const std::string& device_id, ComPtr<IMMDevice> CreateDeviceInternal(const std::string& device_id,
EDataFlow data_flow, EDataFlow data_flow,
ERole role) { ERole role) {
RTC_DLOG(INFO) << "CreateDeviceInternal: " RTC_DLOG(LS_INFO) << "CreateDeviceInternal: "
"id=" "id="
<< device_id << ", flow=" << FlowToString(data_flow) << device_id << ", flow=" << FlowToString(data_flow)
<< ", role=" << RoleToString(role); << ", role=" << RoleToString(role);
@ -587,9 +587,9 @@ bool GetDeviceNamesInternal(EDataFlow data_flow,
// [2] friendly name: Headset Microphone (2- Arctis 7 Chat) // [2] friendly name: Headset Microphone (2- Arctis 7 Chat)
// [2] unique id : {0.0.1.00000000}.{ff9eed76-196e-467a-b295-26986e69451c} // [2] unique id : {0.0.1.00000000}.{ff9eed76-196e-467a-b295-26986e69451c}
for (size_t i = 0; i < device_names->size(); ++i) { for (size_t i = 0; i < device_names->size(); ++i) {
RTC_DLOG(INFO) << "[" << i RTC_DLOG(LS_INFO) << "[" << i
<< "] friendly name: " << (*device_names)[i].device_name; << "] friendly name: " << (*device_names)[i].device_name;
RTC_DLOG(INFO) << "[" << i RTC_DLOG(LS_INFO) << "[" << i
<< "] unique id : " << (*device_names)[i].unique_id; << "] unique id : " << (*device_names)[i].unique_id;
} }
@ -614,7 +614,7 @@ HRESULT GetPreferredAudioParametersInternal(IAudioClient* client,
// Override default sample rate if `fixed_sample_rate` is set and different // Override default sample rate if `fixed_sample_rate` is set and different
// from the default rate. // from the default rate.
if (fixed_sample_rate > 0 && fixed_sample_rate != sample_rate) { if (fixed_sample_rate > 0 && fixed_sample_rate != sample_rate) {
RTC_DLOG(INFO) << "Using fixed sample rate instead of the preferred: " RTC_DLOG(LS_INFO) << "Using fixed sample rate instead of the preferred: "
<< sample_rate << " is replaced by " << fixed_sample_rate; << sample_rate << " is replaced by " << fixed_sample_rate;
sample_rate = fixed_sample_rate; sample_rate = fixed_sample_rate;
} }
@ -634,7 +634,7 @@ HRESULT GetPreferredAudioParametersInternal(IAudioClient* client,
AudioParameters audio_params(sample_rate, channels, frames_per_buffer); AudioParameters audio_params(sample_rate, channels, frames_per_buffer);
*params = audio_params; *params = audio_params;
RTC_DLOG(INFO) << audio_params.ToString(); RTC_DLOG(LS_INFO) << audio_params.ToString();
return hr; return hr;
} }
@ -669,13 +669,13 @@ size_t WaveFormatWrapper::size() const {
} }
bool IsSupported() { bool IsSupported() {
RTC_DLOG(INFO) << "IsSupported"; RTC_DLOG(LS_INFO) << "IsSupported";
static bool g_is_supported = IsSupportedInternal(); static bool g_is_supported = IsSupportedInternal();
return g_is_supported; return g_is_supported;
} }
bool IsMMCSSSupported() { bool IsMMCSSSupported() {
RTC_DLOG(INFO) << "IsMMCSSSupported"; RTC_DLOG(LS_INFO) << "IsMMCSSSupported";
return LoadAvrtDll(); return LoadAvrtDll();
} }
@ -698,7 +698,7 @@ int NumberOfActiveDevices(EDataFlow data_flow) {
} else if (data_flow == eAll) { } else if (data_flow == eAll) {
str = "Total number of devices: "; str = "Total number of devices: ";
} }
RTC_DLOG(INFO) << str << number_of_active_devices; RTC_DLOG(LS_INFO) << str << number_of_active_devices;
return static_cast<int>(number_of_active_devices); return static_cast<int>(number_of_active_devices);
} }
@ -713,33 +713,33 @@ uint32_t GetAudioClientVersion() {
} }
ComPtr<IMMDeviceEnumerator> CreateDeviceEnumerator() { ComPtr<IMMDeviceEnumerator> CreateDeviceEnumerator() {
RTC_DLOG(INFO) << "CreateDeviceEnumerator"; RTC_DLOG(LS_INFO) << "CreateDeviceEnumerator";
return CreateDeviceEnumeratorInternal(true); return CreateDeviceEnumeratorInternal(true);
} }
std::string GetDefaultInputDeviceID() { std::string GetDefaultInputDeviceID() {
RTC_DLOG(INFO) << "GetDefaultInputDeviceID"; RTC_DLOG(LS_INFO) << "GetDefaultInputDeviceID";
ComPtr<IMMDevice> device( ComPtr<IMMDevice> device(
CreateDevice(AudioDeviceName::kDefaultDeviceId, eCapture, eConsole)); CreateDevice(AudioDeviceName::kDefaultDeviceId, eCapture, eConsole));
return device.Get() ? GetDeviceIdInternal(device.Get()) : std::string(); return device.Get() ? GetDeviceIdInternal(device.Get()) : std::string();
} }
std::string GetDefaultOutputDeviceID() { std::string GetDefaultOutputDeviceID() {
RTC_DLOG(INFO) << "GetDefaultOutputDeviceID"; RTC_DLOG(LS_INFO) << "GetDefaultOutputDeviceID";
ComPtr<IMMDevice> device( ComPtr<IMMDevice> device(
CreateDevice(AudioDeviceName::kDefaultDeviceId, eRender, eConsole)); CreateDevice(AudioDeviceName::kDefaultDeviceId, eRender, eConsole));
return device.Get() ? GetDeviceIdInternal(device.Get()) : std::string(); return device.Get() ? GetDeviceIdInternal(device.Get()) : std::string();
} }
std::string GetCommunicationsInputDeviceID() { std::string GetCommunicationsInputDeviceID() {
RTC_DLOG(INFO) << "GetCommunicationsInputDeviceID"; RTC_DLOG(LS_INFO) << "GetCommunicationsInputDeviceID";
ComPtr<IMMDevice> device(CreateDevice(AudioDeviceName::kDefaultDeviceId, ComPtr<IMMDevice> device(CreateDevice(AudioDeviceName::kDefaultDeviceId,
eCapture, eCommunications)); eCapture, eCommunications));
return device.Get() ? GetDeviceIdInternal(device.Get()) : std::string(); return device.Get() ? GetDeviceIdInternal(device.Get()) : std::string();
} }
std::string GetCommunicationsOutputDeviceID() { std::string GetCommunicationsOutputDeviceID() {
RTC_DLOG(INFO) << "GetCommunicationsOutputDeviceID"; RTC_DLOG(LS_INFO) << "GetCommunicationsOutputDeviceID";
ComPtr<IMMDevice> device(CreateDevice(AudioDeviceName::kDefaultDeviceId, ComPtr<IMMDevice> device(CreateDevice(AudioDeviceName::kDefaultDeviceId,
eRender, eCommunications)); eRender, eCommunications));
return device.Get() ? GetDeviceIdInternal(device.Get()) : std::string(); return device.Get() ? GetDeviceIdInternal(device.Get()) : std::string();
@ -748,24 +748,24 @@ std::string GetCommunicationsOutputDeviceID() {
ComPtr<IMMDevice> CreateDevice(const std::string& device_id, ComPtr<IMMDevice> CreateDevice(const std::string& device_id,
EDataFlow data_flow, EDataFlow data_flow,
ERole role) { ERole role) {
RTC_DLOG(INFO) << "CreateDevice"; RTC_DLOG(LS_INFO) << "CreateDevice";
return CreateDeviceInternal(device_id, data_flow, role); return CreateDeviceInternal(device_id, data_flow, role);
} }
AudioDeviceName GetDeviceName(IMMDevice* device) { AudioDeviceName GetDeviceName(IMMDevice* device) {
RTC_DLOG(INFO) << "GetDeviceName"; RTC_DLOG(LS_INFO) << "GetDeviceName";
RTC_DCHECK(device); RTC_DCHECK(device);
AudioDeviceName device_name(GetDeviceFriendlyNameInternal(device), AudioDeviceName device_name(GetDeviceFriendlyNameInternal(device),
GetDeviceIdInternal(device)); GetDeviceIdInternal(device));
RTC_DLOG(INFO) << "friendly name: " << device_name.device_name; RTC_DLOG(LS_INFO) << "friendly name: " << device_name.device_name;
RTC_DLOG(INFO) << "unique id : " << device_name.unique_id; RTC_DLOG(LS_INFO) << "unique id : " << device_name.unique_id;
return device_name; return device_name;
} }
std::string GetFriendlyName(const std::string& device_id, std::string GetFriendlyName(const std::string& device_id,
EDataFlow data_flow, EDataFlow data_flow,
ERole role) { ERole role) {
RTC_DLOG(INFO) << "GetFriendlyName"; RTC_DLOG(LS_INFO) << "GetFriendlyName";
ComPtr<IMMDevice> audio_device = CreateDevice(device_id, data_flow, role); ComPtr<IMMDevice> audio_device = CreateDevice(device_id, data_flow, role);
if (!audio_device.Get()) if (!audio_device.Get())
return std::string(); return std::string();
@ -775,7 +775,7 @@ std::string GetFriendlyName(const std::string& device_id,
} }
EDataFlow GetDataFlow(IMMDevice* device) { EDataFlow GetDataFlow(IMMDevice* device) {
RTC_DLOG(INFO) << "GetDataFlow"; RTC_DLOG(LS_INFO) << "GetDataFlow";
RTC_DCHECK(device); RTC_DCHECK(device);
ComPtr<IMMEndpoint> endpoint; ComPtr<IMMEndpoint> endpoint;
_com_error error = device->QueryInterface(endpoint.GetAddressOf()); _com_error error = device->QueryInterface(endpoint.GetAddressOf());
@ -796,32 +796,32 @@ EDataFlow GetDataFlow(IMMDevice* device) {
} }
bool GetInputDeviceNames(webrtc::AudioDeviceNames* device_names) { bool GetInputDeviceNames(webrtc::AudioDeviceNames* device_names) {
RTC_DLOG(INFO) << "GetInputDeviceNames"; RTC_DLOG(LS_INFO) << "GetInputDeviceNames";
RTC_DCHECK(device_names); RTC_DCHECK(device_names);
RTC_DCHECK(device_names->empty()); RTC_DCHECK(device_names->empty());
return GetDeviceNamesInternal(eCapture, device_names); return GetDeviceNamesInternal(eCapture, device_names);
} }
bool GetOutputDeviceNames(webrtc::AudioDeviceNames* device_names) { bool GetOutputDeviceNames(webrtc::AudioDeviceNames* device_names) {
RTC_DLOG(INFO) << "GetOutputDeviceNames"; RTC_DLOG(LS_INFO) << "GetOutputDeviceNames";
RTC_DCHECK(device_names); RTC_DCHECK(device_names);
RTC_DCHECK(device_names->empty()); RTC_DCHECK(device_names->empty());
return GetDeviceNamesInternal(eRender, device_names); return GetDeviceNamesInternal(eRender, device_names);
} }
ComPtr<IAudioSessionManager2> CreateSessionManager2(IMMDevice* device) { ComPtr<IAudioSessionManager2> CreateSessionManager2(IMMDevice* device) {
RTC_DLOG(INFO) << "CreateSessionManager2"; RTC_DLOG(LS_INFO) << "CreateSessionManager2";
return CreateSessionManager2Internal(device); return CreateSessionManager2Internal(device);
} }
Microsoft::WRL::ComPtr<IAudioSessionEnumerator> CreateSessionEnumerator( Microsoft::WRL::ComPtr<IAudioSessionEnumerator> CreateSessionEnumerator(
IMMDevice* device) { IMMDevice* device) {
RTC_DLOG(INFO) << "CreateSessionEnumerator"; RTC_DLOG(LS_INFO) << "CreateSessionEnumerator";
return CreateSessionEnumeratorInternal(device); return CreateSessionEnumeratorInternal(device);
} }
int NumberOfActiveSessions(IMMDevice* device) { int NumberOfActiveSessions(IMMDevice* device) {
RTC_DLOG(INFO) << "NumberOfActiveSessions"; RTC_DLOG(LS_INFO) << "NumberOfActiveSessions";
ComPtr<IAudioSessionEnumerator> session_enumerator = ComPtr<IAudioSessionEnumerator> session_enumerator =
CreateSessionEnumerator(device); CreateSessionEnumerator(device);
@ -833,7 +833,7 @@ int NumberOfActiveSessions(IMMDevice* device) {
<< ErrorToString(error); << ErrorToString(error);
return 0; return 0;
} }
RTC_DLOG(INFO) << "Total number of audio sessions: " << session_count; RTC_DLOG(LS_INFO) << "Total number of audio sessions: " << session_count;
int num_active = 0; int num_active = 0;
for (int session = 0; session < session_count; session++) { for (int session = 0; session < session_count; session++) {
@ -849,7 +849,7 @@ int NumberOfActiveSessions(IMMDevice* device) {
// Log the display name of the audio session for debugging purposes. // Log the display name of the audio session for debugging purposes.
LPWSTR display_name; LPWSTR display_name;
if (SUCCEEDED(session_control->GetDisplayName(&display_name))) { if (SUCCEEDED(session_control->GetDisplayName(&display_name))) {
RTC_DLOG(INFO) << "display name: " RTC_DLOG(LS_INFO) << "display name: "
<< rtc::ToUtf8(display_name, wcslen(display_name)); << rtc::ToUtf8(display_name, wcslen(display_name));
CoTaskMemFree(display_name); CoTaskMemFree(display_name);
} }
@ -867,14 +867,14 @@ int NumberOfActiveSessions(IMMDevice* device) {
} }
} }
RTC_DLOG(INFO) << "Number of active audio sessions: " << num_active; RTC_DLOG(LS_INFO) << "Number of active audio sessions: " << num_active;
return num_active; return num_active;
} }
ComPtr<IAudioClient> CreateClient(const std::string& device_id, ComPtr<IAudioClient> CreateClient(const std::string& device_id,
EDataFlow data_flow, EDataFlow data_flow,
ERole role) { ERole role) {
RTC_DLOG(INFO) << "CreateClient"; RTC_DLOG(LS_INFO) << "CreateClient";
ComPtr<IMMDevice> device(CreateDevice(device_id, data_flow, role)); ComPtr<IMMDevice> device(CreateDevice(device_id, data_flow, role));
return CreateClientInternal(device.Get()); return CreateClientInternal(device.Get());
} }
@ -882,7 +882,7 @@ ComPtr<IAudioClient> CreateClient(const std::string& device_id,
ComPtr<IAudioClient2> CreateClient2(const std::string& device_id, ComPtr<IAudioClient2> CreateClient2(const std::string& device_id,
EDataFlow data_flow, EDataFlow data_flow,
ERole role) { ERole role) {
RTC_DLOG(INFO) << "CreateClient2"; RTC_DLOG(LS_INFO) << "CreateClient2";
ComPtr<IMMDevice> device(CreateDevice(device_id, data_flow, role)); ComPtr<IMMDevice> device(CreateDevice(device_id, data_flow, role));
return CreateClient2Internal(device.Get()); return CreateClient2Internal(device.Get());
} }
@ -890,13 +890,13 @@ ComPtr<IAudioClient2> CreateClient2(const std::string& device_id,
ComPtr<IAudioClient3> CreateClient3(const std::string& device_id, ComPtr<IAudioClient3> CreateClient3(const std::string& device_id,
EDataFlow data_flow, EDataFlow data_flow,
ERole role) { ERole role) {
RTC_DLOG(INFO) << "CreateClient3"; RTC_DLOG(LS_INFO) << "CreateClient3";
ComPtr<IMMDevice> device(CreateDevice(device_id, data_flow, role)); ComPtr<IMMDevice> device(CreateDevice(device_id, data_flow, role));
return CreateClient3Internal(device.Get()); return CreateClient3Internal(device.Get());
} }
HRESULT SetClientProperties(IAudioClient2* client) { HRESULT SetClientProperties(IAudioClient2* client) {
RTC_DLOG(INFO) << "SetClientProperties"; RTC_DLOG(LS_INFO) << "SetClientProperties";
RTC_DCHECK(client); RTC_DCHECK(client);
if (GetAudioClientVersion() < 2) { if (GetAudioClientVersion() < 2) {
RTC_LOG(LS_WARNING) << "Requires IAudioClient2 or higher"; RTC_LOG(LS_WARNING) << "Requires IAudioClient2 or higher";
@ -919,10 +919,10 @@ HRESULT SetClientProperties(IAudioClient2* client) {
RTC_LOG(LS_ERROR) << "IAudioClient2::IsOffloadCapable failed: " RTC_LOG(LS_ERROR) << "IAudioClient2::IsOffloadCapable failed: "
<< ErrorToString(error); << ErrorToString(error);
} }
RTC_DLOG(INFO) << "supports_offload: " << supports_offload; RTC_DLOG(LS_INFO) << "supports_offload: " << supports_offload;
props.bIsOffload = false; props.bIsOffload = false;
#if (NTDDI_VERSION < NTDDI_WINBLUE) #if (NTDDI_VERSION < NTDDI_WINBLUE)
RTC_DLOG(INFO) << "options: Not supported in this build"; RTC_DLOG(LS_INFO) << "options: Not supported in this build";
#else #else
// TODO(henrika): pros and cons compared with AUDCLNT_STREAMOPTIONS_NONE? // TODO(henrika): pros and cons compared with AUDCLNT_STREAMOPTIONS_NONE?
props.Options |= AUDCLNT_STREAMOPTIONS_NONE; props.Options |= AUDCLNT_STREAMOPTIONS_NONE;
@ -939,7 +939,7 @@ HRESULT SetClientProperties(IAudioClient2* client) {
// an appropriate interface to use for communications scenarios. // an appropriate interface to use for communications scenarios.
// This interface is mainly meant for pro audio scenarios. // This interface is mainly meant for pro audio scenarios.
// props.Options |= AUDCLNT_STREAMOPTIONS_MATCH_FORMAT; // props.Options |= AUDCLNT_STREAMOPTIONS_MATCH_FORMAT;
RTC_DLOG(INFO) << "options: 0x" << rtc::ToHex(props.Options); RTC_DLOG(LS_INFO) << "options: 0x" << rtc::ToHex(props.Options);
#endif #endif
error = client->SetClientProperties(&props); error = client->SetClientProperties(&props);
if (FAILED(error.Error())) { if (FAILED(error.Error())) {
@ -953,7 +953,7 @@ HRESULT GetBufferSizeLimits(IAudioClient2* client,
const WAVEFORMATEXTENSIBLE* format, const WAVEFORMATEXTENSIBLE* format,
REFERENCE_TIME* min_buffer_duration, REFERENCE_TIME* min_buffer_duration,
REFERENCE_TIME* max_buffer_duration) { REFERENCE_TIME* max_buffer_duration) {
RTC_DLOG(INFO) << "GetBufferSizeLimits"; RTC_DLOG(LS_INFO) << "GetBufferSizeLimits";
RTC_DCHECK(client); RTC_DCHECK(client);
if (GetAudioClientVersion() < 2) { if (GetAudioClientVersion() < 2) {
RTC_LOG(LS_WARNING) << "Requires IAudioClient2 or higher"; RTC_LOG(LS_WARNING) << "Requires IAudioClient2 or higher";
@ -975,15 +975,15 @@ HRESULT GetBufferSizeLimits(IAudioClient2* client,
} else { } else {
*min_buffer_duration = min_duration; *min_buffer_duration = min_duration;
*max_buffer_duration = max_duration; *max_buffer_duration = max_duration;
RTC_DLOG(INFO) << "min_buffer_duration: " << min_buffer_duration; RTC_DLOG(LS_INFO) << "min_buffer_duration: " << min_buffer_duration;
RTC_DLOG(INFO) << "max_buffer_duration: " << max_buffer_duration; RTC_DLOG(LS_INFO) << "max_buffer_duration: " << max_buffer_duration;
} }
return error.Error(); return error.Error();
} }
HRESULT GetSharedModeMixFormat(IAudioClient* client, HRESULT GetSharedModeMixFormat(IAudioClient* client,
WAVEFORMATEXTENSIBLE* format) { WAVEFORMATEXTENSIBLE* format) {
RTC_DLOG(INFO) << "GetSharedModeMixFormat"; RTC_DLOG(LS_INFO) << "GetSharedModeMixFormat";
RTC_DCHECK(client); RTC_DCHECK(client);
// The GetMixFormat method retrieves the stream format that the audio engine // The GetMixFormat method retrieves the stream format that the audio engine
@ -1030,7 +1030,7 @@ HRESULT GetSharedModeMixFormat(IAudioClient* client,
// the returned structure is correctly extended or not. // the returned structure is correctly extended or not.
RTC_CHECK_LE(wrapped_format.size(), sizeof(WAVEFORMATEXTENSIBLE)); RTC_CHECK_LE(wrapped_format.size(), sizeof(WAVEFORMATEXTENSIBLE));
memcpy(format, wrapped_format.get(), wrapped_format.size()); memcpy(format, wrapped_format.get(), wrapped_format.size());
RTC_DLOG(INFO) << WaveFormatToString(format); RTC_DLOG(LS_INFO) << WaveFormatToString(format);
return error.Error(); return error.Error();
} }
@ -1038,7 +1038,7 @@ HRESULT GetSharedModeMixFormat(IAudioClient* client,
bool IsFormatSupported(IAudioClient* client, bool IsFormatSupported(IAudioClient* client,
AUDCLNT_SHAREMODE share_mode, AUDCLNT_SHAREMODE share_mode,
const WAVEFORMATEXTENSIBLE* format) { const WAVEFORMATEXTENSIBLE* format) {
RTC_DLOG(INFO) << "IsFormatSupported"; RTC_DLOG(LS_INFO) << "IsFormatSupported";
RTC_DCHECK(client); RTC_DCHECK(client);
ScopedCoMem<WAVEFORMATEX> closest_match; ScopedCoMem<WAVEFORMATEX> closest_match;
// This method provides a way for a client to determine, before calling // This method provides a way for a client to determine, before calling
@ -1049,22 +1049,22 @@ bool IsFormatSupported(IAudioClient* client,
_com_error error = client->IsFormatSupported( _com_error error = client->IsFormatSupported(
share_mode, reinterpret_cast<const WAVEFORMATEX*>(format), share_mode, reinterpret_cast<const WAVEFORMATEX*>(format),
&closest_match); &closest_match);
RTC_LOG(INFO) << WaveFormatToString( RTC_LOG(LS_INFO) << WaveFormatToString(
const_cast<WAVEFORMATEXTENSIBLE*>(format)); const_cast<WAVEFORMATEXTENSIBLE*>(format));
if ((error.Error() == S_OK) && (closest_match == nullptr)) { if ((error.Error() == S_OK) && (closest_match == nullptr)) {
RTC_DLOG(INFO) RTC_DLOG(LS_INFO)
<< "The audio endpoint device supports the specified stream format"; << "The audio endpoint device supports the specified stream format";
} else if ((error.Error() == S_FALSE) && (closest_match != nullptr)) { } else if ((error.Error() == S_FALSE) && (closest_match != nullptr)) {
// Call succeeded with a closest match to the specified format. This log can // Call succeeded with a closest match to the specified format. This log can
// only be triggered for shared mode. // only be triggered for shared mode.
RTC_LOG(LS_WARNING) RTC_LOG(LS_WARNING)
<< "Exact format is not supported, but a closest match exists"; << "Exact format is not supported, but a closest match exists";
RTC_LOG(INFO) << WaveFormatToString(closest_match.Get()); RTC_LOG(LS_INFO) << WaveFormatToString(closest_match.Get());
} else if ((error.Error() == AUDCLNT_E_UNSUPPORTED_FORMAT) && } else if ((error.Error() == AUDCLNT_E_UNSUPPORTED_FORMAT) &&
(closest_match == nullptr)) { (closest_match == nullptr)) {
// The audio engine does not support the caller-specified format or any // The audio engine does not support the caller-specified format or any
// similar format. // similar format.
RTC_DLOG(INFO) << "The audio endpoint device does not support the " RTC_DLOG(LS_INFO) << "The audio endpoint device does not support the "
"specified stream format"; "specified stream format";
} else { } else {
RTC_LOG(LS_ERROR) << "IAudioClient::IsFormatSupported failed: " RTC_LOG(LS_ERROR) << "IAudioClient::IsFormatSupported failed: "
@ -1077,7 +1077,7 @@ bool IsFormatSupported(IAudioClient* client,
HRESULT GetDevicePeriod(IAudioClient* client, HRESULT GetDevicePeriod(IAudioClient* client,
AUDCLNT_SHAREMODE share_mode, AUDCLNT_SHAREMODE share_mode,
REFERENCE_TIME* device_period) { REFERENCE_TIME* device_period) {
RTC_DLOG(INFO) << "GetDevicePeriod"; RTC_DLOG(LS_INFO) << "GetDevicePeriod";
RTC_DCHECK(client); RTC_DCHECK(client);
// The `default_period` parameter specifies the default scheduling period // The `default_period` parameter specifies the default scheduling period
// for a shared-mode stream. The `minimum_period` parameter specifies the // for a shared-mode stream. The `minimum_period` parameter specifies the
@ -1094,9 +1094,9 @@ HRESULT GetDevicePeriod(IAudioClient* client,
*device_period = (share_mode == AUDCLNT_SHAREMODE_SHARED) ? default_period *device_period = (share_mode == AUDCLNT_SHAREMODE_SHARED) ? default_period
: minimum_period; : minimum_period;
RTC_LOG(INFO) << "device_period: " RTC_LOG(LS_INFO) << "device_period: "
<< ReferenceTimeToTimeDelta(*device_period).ms() << " [ms]"; << ReferenceTimeToTimeDelta(*device_period).ms() << " [ms]";
RTC_LOG(INFO) << "minimum_period: " RTC_LOG(LS_INFO) << "minimum_period: "
<< ReferenceTimeToTimeDelta(minimum_period).ms() << " [ms]"; << ReferenceTimeToTimeDelta(minimum_period).ms() << " [ms]";
return error.Error(); return error.Error();
} }
@ -1107,7 +1107,7 @@ HRESULT GetSharedModeEnginePeriod(IAudioClient3* client3,
uint32_t* fundamental_period_in_frames, uint32_t* fundamental_period_in_frames,
uint32_t* min_period_in_frames, uint32_t* min_period_in_frames,
uint32_t* max_period_in_frames) { uint32_t* max_period_in_frames) {
RTC_DLOG(INFO) << "GetSharedModeEnginePeriod"; RTC_DLOG(LS_INFO) << "GetSharedModeEnginePeriod";
RTC_DCHECK(client3); RTC_DCHECK(client3);
UINT32 default_period = 0; UINT32 default_period = 0;
@ -1125,14 +1125,16 @@ HRESULT GetSharedModeEnginePeriod(IAudioClient3* client3,
WAVEFORMATEX format_ex = format->Format; WAVEFORMATEX format_ex = format->Format;
const WORD sample_rate = format_ex.nSamplesPerSec; const WORD sample_rate = format_ex.nSamplesPerSec;
RTC_LOG(INFO) << "default_period_in_frames: " << default_period << " (" RTC_LOG(LS_INFO) << "default_period_in_frames: " << default_period << " ("
<< FramesToMilliseconds(default_period, sample_rate) << " ms)"; << FramesToMilliseconds(default_period, sample_rate)
RTC_LOG(INFO) << "fundamental_period_in_frames: " << fundamental_period
<< " (" << FramesToMilliseconds(fundamental_period, sample_rate)
<< " ms)"; << " ms)";
RTC_LOG(INFO) << "min_period_in_frames: " << min_period << " (" RTC_LOG(LS_INFO) << "fundamental_period_in_frames: " << fundamental_period
<< " ("
<< FramesToMilliseconds(fundamental_period, sample_rate)
<< " ms)";
RTC_LOG(LS_INFO) << "min_period_in_frames: " << min_period << " ("
<< FramesToMilliseconds(min_period, sample_rate) << " ms)"; << FramesToMilliseconds(min_period, sample_rate) << " ms)";
RTC_LOG(INFO) << "max_period_in_frames: " << max_period << " (" RTC_LOG(LS_INFO) << "max_period_in_frames: " << max_period << " ("
<< FramesToMilliseconds(max_period, sample_rate) << " ms)"; << FramesToMilliseconds(max_period, sample_rate) << " ms)";
*default_period_in_frames = default_period; *default_period_in_frames = default_period;
*fundamental_period_in_frames = fundamental_period; *fundamental_period_in_frames = fundamental_period;
@ -1143,7 +1145,7 @@ HRESULT GetSharedModeEnginePeriod(IAudioClient3* client3,
HRESULT GetPreferredAudioParameters(IAudioClient* client, HRESULT GetPreferredAudioParameters(IAudioClient* client,
AudioParameters* params) { AudioParameters* params) {
RTC_DLOG(INFO) << "GetPreferredAudioParameters"; RTC_DLOG(LS_INFO) << "GetPreferredAudioParameters";
RTC_DCHECK(client); RTC_DCHECK(client);
return GetPreferredAudioParametersInternal(client, params, -1); return GetPreferredAudioParametersInternal(client, params, -1);
} }
@ -1151,7 +1153,7 @@ HRESULT GetPreferredAudioParameters(IAudioClient* client,
HRESULT GetPreferredAudioParameters(IAudioClient* client, HRESULT GetPreferredAudioParameters(IAudioClient* client,
webrtc::AudioParameters* params, webrtc::AudioParameters* params,
uint32_t sample_rate) { uint32_t sample_rate) {
RTC_DLOG(INFO) << "GetPreferredAudioParameters: " << sample_rate; RTC_DLOG(LS_INFO) << "GetPreferredAudioParameters: " << sample_rate;
RTC_DCHECK(client); RTC_DCHECK(client);
return GetPreferredAudioParametersInternal(client, params, sample_rate); return GetPreferredAudioParametersInternal(client, params, sample_rate);
} }
@ -1162,7 +1164,8 @@ HRESULT SharedModeInitialize(IAudioClient* client,
REFERENCE_TIME buffer_duration, REFERENCE_TIME buffer_duration,
bool auto_convert_pcm, bool auto_convert_pcm,
uint32_t* endpoint_buffer_size) { uint32_t* endpoint_buffer_size) {
RTC_DLOG(INFO) << "SharedModeInitialize: buffer_duration=" << buffer_duration RTC_DLOG(LS_INFO) << "SharedModeInitialize: buffer_duration="
<< buffer_duration
<< ", auto_convert_pcm=" << auto_convert_pcm; << ", auto_convert_pcm=" << auto_convert_pcm;
RTC_DCHECK(client); RTC_DCHECK(client);
RTC_DCHECK_GE(buffer_duration, 0); RTC_DCHECK_GE(buffer_duration, 0);
@ -1188,7 +1191,7 @@ HRESULT SharedModeInitialize(IAudioClient* client,
(event_handle != nullptr && event_handle != INVALID_HANDLE_VALUE); (event_handle != nullptr && event_handle != INVALID_HANDLE_VALUE);
if (use_event) { if (use_event) {
stream_flags |= AUDCLNT_STREAMFLAGS_EVENTCALLBACK; stream_flags |= AUDCLNT_STREAMFLAGS_EVENTCALLBACK;
RTC_DLOG(INFO) << "The stream is initialized to be event driven"; RTC_DLOG(LS_INFO) << "The stream is initialized to be event driven";
} }
// Check if sample-rate conversion is requested. // Check if sample-rate conversion is requested.
@ -1197,11 +1200,11 @@ HRESULT SharedModeInitialize(IAudioClient* client,
// from our (the client's) format to the audio engine mix format. // from our (the client's) format to the audio engine mix format.
// Currently only supported for testing, i.e., not possible to enable using // Currently only supported for testing, i.e., not possible to enable using
// public APIs. // public APIs.
RTC_DLOG(INFO) << "The stream is initialized to support rate conversion"; RTC_DLOG(LS_INFO) << "The stream is initialized to support rate conversion";
stream_flags |= AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM; stream_flags |= AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM;
stream_flags |= AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY; stream_flags |= AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY;
} }
RTC_DLOG(INFO) << "stream_flags: 0x" << rtc::ToHex(stream_flags); RTC_DLOG(LS_INFO) << "stream_flags: 0x" << rtc::ToHex(stream_flags);
// Initialize the shared mode client for minimal delay if `buffer_duration` // Initialize the shared mode client for minimal delay if `buffer_duration`
// is 0 or possibly a higher delay (more robust) if `buffer_duration` is // is 0 or possibly a higher delay (more robust) if `buffer_duration` is
@ -1243,14 +1246,14 @@ HRESULT SharedModeInitialize(IAudioClient* client,
} }
*endpoint_buffer_size = buffer_size_in_frames; *endpoint_buffer_size = buffer_size_in_frames;
RTC_DLOG(INFO) << "endpoint buffer size: " << buffer_size_in_frames RTC_DLOG(LS_INFO) << "endpoint buffer size: " << buffer_size_in_frames
<< " [audio frames]"; << " [audio frames]";
const double size_in_ms = static_cast<double>(buffer_size_in_frames) / const double size_in_ms = static_cast<double>(buffer_size_in_frames) /
(format->Format.nSamplesPerSec / 1000.0); (format->Format.nSamplesPerSec / 1000.0);
RTC_DLOG(INFO) << "endpoint buffer size: " RTC_DLOG(LS_INFO) << "endpoint buffer size: "
<< static_cast<int>(size_in_ms + 0.5) << " [ms]"; << static_cast<int>(size_in_ms + 0.5) << " [ms]";
RTC_DLOG(INFO) << "bytes per audio frame: " << format->Format.nBlockAlign; RTC_DLOG(LS_INFO) << "bytes per audio frame: " << format->Format.nBlockAlign;
RTC_DLOG(INFO) << "endpoint buffer size: " RTC_DLOG(LS_INFO) << "endpoint buffer size: "
<< buffer_size_in_frames * format->Format.nChannels * << buffer_size_in_frames * format->Format.nChannels *
(format->Format.wBitsPerSample / 8) (format->Format.wBitsPerSample / 8)
<< " [bytes]"; << " [bytes]";
@ -1258,8 +1261,8 @@ HRESULT SharedModeInitialize(IAudioClient* client,
// TODO(henrika): utilize when delay measurements are added. // TODO(henrika): utilize when delay measurements are added.
REFERENCE_TIME latency = 0; REFERENCE_TIME latency = 0;
error = client->GetStreamLatency(&latency); error = client->GetStreamLatency(&latency);
RTC_DLOG(INFO) << "stream latency: " << ReferenceTimeToTimeDelta(latency).ms() RTC_DLOG(LS_INFO) << "stream latency: "
<< " [ms]"; << ReferenceTimeToTimeDelta(latency).ms() << " [ms]";
return error.Error(); return error.Error();
} }
@ -1269,7 +1272,7 @@ HRESULT SharedModeInitializeLowLatency(IAudioClient3* client,
uint32_t period_in_frames, uint32_t period_in_frames,
bool auto_convert_pcm, bool auto_convert_pcm,
uint32_t* endpoint_buffer_size) { uint32_t* endpoint_buffer_size) {
RTC_DLOG(INFO) << "SharedModeInitializeLowLatency: period_in_frames=" RTC_DLOG(LS_INFO) << "SharedModeInitializeLowLatency: period_in_frames="
<< period_in_frames << period_in_frames
<< ", auto_convert_pcm=" << auto_convert_pcm; << ", auto_convert_pcm=" << auto_convert_pcm;
RTC_DCHECK(client); RTC_DCHECK(client);
@ -1284,13 +1287,13 @@ HRESULT SharedModeInitializeLowLatency(IAudioClient3* client,
(event_handle != nullptr && event_handle != INVALID_HANDLE_VALUE); (event_handle != nullptr && event_handle != INVALID_HANDLE_VALUE);
if (use_event) { if (use_event) {
stream_flags |= AUDCLNT_STREAMFLAGS_EVENTCALLBACK; stream_flags |= AUDCLNT_STREAMFLAGS_EVENTCALLBACK;
RTC_DLOG(INFO) << "The stream is initialized to be event driven"; RTC_DLOG(LS_INFO) << "The stream is initialized to be event driven";
} }
if (auto_convert_pcm) { if (auto_convert_pcm) {
stream_flags |= AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM; stream_flags |= AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM;
stream_flags |= AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY; stream_flags |= AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY;
} }
RTC_DLOG(INFO) << "stream_flags: 0x" << rtc::ToHex(stream_flags); RTC_DLOG(LS_INFO) << "stream_flags: 0x" << rtc::ToHex(stream_flags);
// Initialize the shared mode client for lowest possible latency. // Initialize the shared mode client for lowest possible latency.
// It is assumed that GetSharedModeEnginePeriod() has been used to query the // It is assumed that GetSharedModeEnginePeriod() has been used to query the
@ -1324,14 +1327,14 @@ HRESULT SharedModeInitializeLowLatency(IAudioClient3* client,
} }
*endpoint_buffer_size = buffer_size_in_frames; *endpoint_buffer_size = buffer_size_in_frames;
RTC_DLOG(INFO) << "endpoint buffer size: " << buffer_size_in_frames RTC_DLOG(LS_INFO) << "endpoint buffer size: " << buffer_size_in_frames
<< " [audio frames]"; << " [audio frames]";
const double size_in_ms = static_cast<double>(buffer_size_in_frames) / const double size_in_ms = static_cast<double>(buffer_size_in_frames) /
(format->Format.nSamplesPerSec / 1000.0); (format->Format.nSamplesPerSec / 1000.0);
RTC_DLOG(INFO) << "endpoint buffer size: " RTC_DLOG(LS_INFO) << "endpoint buffer size: "
<< static_cast<int>(size_in_ms + 0.5) << " [ms]"; << static_cast<int>(size_in_ms + 0.5) << " [ms]";
RTC_DLOG(INFO) << "bytes per audio frame: " << format->Format.nBlockAlign; RTC_DLOG(LS_INFO) << "bytes per audio frame: " << format->Format.nBlockAlign;
RTC_DLOG(INFO) << "endpoint buffer size: " RTC_DLOG(LS_INFO) << "endpoint buffer size: "
<< buffer_size_in_frames * format->Format.nChannels * << buffer_size_in_frames * format->Format.nChannels *
(format->Format.wBitsPerSample / 8) (format->Format.wBitsPerSample / 8)
<< " [bytes]"; << " [bytes]";
@ -1343,14 +1346,14 @@ HRESULT SharedModeInitializeLowLatency(IAudioClient3* client,
RTC_LOG(LS_WARNING) << "IAudioClient::GetStreamLatency failed: " RTC_LOG(LS_WARNING) << "IAudioClient::GetStreamLatency failed: "
<< ErrorToString(error); << ErrorToString(error);
} else { } else {
RTC_DLOG(INFO) << "stream latency: " RTC_DLOG(LS_INFO) << "stream latency: "
<< ReferenceTimeToTimeDelta(latency).ms() << " [ms]"; << ReferenceTimeToTimeDelta(latency).ms() << " [ms]";
} }
return error.Error(); return error.Error();
} }
ComPtr<IAudioRenderClient> CreateRenderClient(IAudioClient* client) { ComPtr<IAudioRenderClient> CreateRenderClient(IAudioClient* client) {
RTC_DLOG(INFO) << "CreateRenderClient"; RTC_DLOG(LS_INFO) << "CreateRenderClient";
RTC_DCHECK(client); RTC_DCHECK(client);
// Get access to the IAudioRenderClient interface. This interface // Get access to the IAudioRenderClient interface. This interface
// enables us to write output data to a rendering endpoint buffer. // enables us to write output data to a rendering endpoint buffer.
@ -1366,7 +1369,7 @@ ComPtr<IAudioRenderClient> CreateRenderClient(IAudioClient* client) {
} }
ComPtr<IAudioCaptureClient> CreateCaptureClient(IAudioClient* client) { ComPtr<IAudioCaptureClient> CreateCaptureClient(IAudioClient* client) {
RTC_DLOG(INFO) << "CreateCaptureClient"; RTC_DLOG(LS_INFO) << "CreateCaptureClient";
RTC_DCHECK(client); RTC_DCHECK(client);
// Get access to the IAudioCaptureClient interface. This interface // Get access to the IAudioCaptureClient interface. This interface
// enables us to read input data from a capturing endpoint buffer. // enables us to read input data from a capturing endpoint buffer.
@ -1382,7 +1385,7 @@ ComPtr<IAudioCaptureClient> CreateCaptureClient(IAudioClient* client) {
} }
ComPtr<IAudioClock> CreateAudioClock(IAudioClient* client) { ComPtr<IAudioClock> CreateAudioClock(IAudioClient* client) {
RTC_DLOG(INFO) << "CreateAudioClock"; RTC_DLOG(LS_INFO) << "CreateAudioClock";
RTC_DCHECK(client); RTC_DCHECK(client);
// Get access to the IAudioClock interface. This interface enables us to // Get access to the IAudioClock interface. This interface enables us to
// monitor a stream's data rate and the current position in the stream. // monitor a stream's data rate and the current position in the stream.
@ -1397,7 +1400,7 @@ ComPtr<IAudioClock> CreateAudioClock(IAudioClient* client) {
} }
ComPtr<IAudioSessionControl> CreateAudioSessionControl(IAudioClient* client) { ComPtr<IAudioSessionControl> CreateAudioSessionControl(IAudioClient* client) {
RTC_DLOG(INFO) << "CreateAudioSessionControl"; RTC_DLOG(LS_INFO) << "CreateAudioSessionControl";
RTC_DCHECK(client); RTC_DCHECK(client);
ComPtr<IAudioSessionControl> audio_session_control; ComPtr<IAudioSessionControl> audio_session_control;
_com_error error = client->GetService(IID_PPV_ARGS(&audio_session_control)); _com_error error = client->GetService(IID_PPV_ARGS(&audio_session_control));
@ -1410,7 +1413,7 @@ ComPtr<IAudioSessionControl> CreateAudioSessionControl(IAudioClient* client) {
} }
ComPtr<ISimpleAudioVolume> CreateSimpleAudioVolume(IAudioClient* client) { ComPtr<ISimpleAudioVolume> CreateSimpleAudioVolume(IAudioClient* client) {
RTC_DLOG(INFO) << "CreateSimpleAudioVolume"; RTC_DLOG(LS_INFO) << "CreateSimpleAudioVolume";
RTC_DCHECK(client); RTC_DCHECK(client);
// Get access to the ISimpleAudioVolume interface. This interface enables a // Get access to the ISimpleAudioVolume interface. This interface enables a
// client to control the master volume level of an audio session. // client to control the master volume level of an audio session.
@ -1427,7 +1430,7 @@ ComPtr<ISimpleAudioVolume> CreateSimpleAudioVolume(IAudioClient* client) {
bool FillRenderEndpointBufferWithSilence(IAudioClient* client, bool FillRenderEndpointBufferWithSilence(IAudioClient* client,
IAudioRenderClient* render_client) { IAudioRenderClient* render_client) {
RTC_DLOG(INFO) << "FillRenderEndpointBufferWithSilence"; RTC_DLOG(LS_INFO) << "FillRenderEndpointBufferWithSilence";
RTC_DCHECK(client); RTC_DCHECK(client);
RTC_DCHECK(render_client); RTC_DCHECK(render_client);
UINT32 endpoint_buffer_size = 0; UINT32 endpoint_buffer_size = 0;
@ -1447,11 +1450,11 @@ bool FillRenderEndpointBufferWithSilence(IAudioClient* client,
<< ErrorToString(error); << ErrorToString(error);
return false; return false;
} }
RTC_DLOG(INFO) << "num_queued_frames: " << num_queued_frames; RTC_DLOG(LS_INFO) << "num_queued_frames: " << num_queued_frames;
BYTE* data = nullptr; BYTE* data = nullptr;
int num_frames_to_fill = endpoint_buffer_size - num_queued_frames; int num_frames_to_fill = endpoint_buffer_size - num_queued_frames;
RTC_DLOG(INFO) << "num_frames_to_fill: " << num_frames_to_fill; RTC_DLOG(LS_INFO) << "num_frames_to_fill: " << num_frames_to_fill;
error = render_client->GetBuffer(num_frames_to_fill, &data); error = render_client->GetBuffer(num_frames_to_fill, &data);
if (FAILED(error.Error())) { if (FAILED(error.Error())) {
RTC_LOG(LS_ERROR) << "IAudioRenderClient::GetBuffer failed: " RTC_LOG(LS_ERROR) << "IAudioRenderClient::GetBuffer failed: "

8
modules/audio_device/win/core_audio_utility_win.h
View File

@ -83,7 +83,7 @@ class ScopedMMCSSRegistration {
} }
explicit ScopedMMCSSRegistration(const wchar_t* task_name) { explicit ScopedMMCSSRegistration(const wchar_t* task_name) {
RTC_DLOG(INFO) << "ScopedMMCSSRegistration: " << rtc::ToUtf8(task_name); RTC_DLOG(LS_INFO) << "ScopedMMCSSRegistration: " << rtc::ToUtf8(task_name);
// Register the calling thread with MMCSS for the supplied `task_name`. // Register the calling thread with MMCSS for the supplied `task_name`.
DWORD mmcss_task_index = 0; DWORD mmcss_task_index = 0;
mmcss_handle_ = AvSetMmThreadCharacteristicsW(task_name, &mmcss_task_index); mmcss_handle_ = AvSetMmThreadCharacteristicsW(task_name, &mmcss_task_index);
@ -93,10 +93,10 @@ class ScopedMMCSSRegistration {
} else { } else {
const DWORD priority_class = GetPriorityClass(GetCurrentProcess()); const DWORD priority_class = GetPriorityClass(GetCurrentProcess());
const int priority = GetThreadPriority(GetCurrentThread()); const int priority = GetThreadPriority(GetCurrentThread());
RTC_DLOG(INFO) << "priority class: " RTC_DLOG(LS_INFO) << "priority class: "
<< PriorityClassToString(priority_class) << "(" << PriorityClassToString(priority_class) << "("
<< priority_class << ")"; << priority_class << ")";
RTC_DLOG(INFO) << "priority: " << PriorityToString(priority) << "(" RTC_DLOG(LS_INFO) << "priority: " << PriorityToString(priority) << "("
<< priority << ")"; << priority << ")";
} }
} }
@ -104,7 +104,7 @@ class ScopedMMCSSRegistration {
~ScopedMMCSSRegistration() { ~ScopedMMCSSRegistration() {
if (Succeeded()) { if (Succeeded()) {
// Deregister with MMCSS. // Deregister with MMCSS.
RTC_DLOG(INFO) << "~ScopedMMCSSRegistration"; RTC_DLOG(LS_INFO) << "~ScopedMMCSSRegistration";
AvRevertMmThreadCharacteristics(mmcss_handle_); AvRevertMmThreadCharacteristics(mmcss_handle_);
} }
} }

40
modules/utility/source/jvm_android.cc
View File

@ -38,10 +38,10 @@ struct {
// stack. Consequently, we only look up all classes once in native WebRTC. // stack. Consequently, we only look up all classes once in native WebRTC.
// http://developer.android.com/training/articles/perf-jni.html#faq_FindClass // http://developer.android.com/training/articles/perf-jni.html#faq_FindClass
void LoadClasses(JNIEnv* jni) { void LoadClasses(JNIEnv* jni) {
RTC_LOG(INFO) << "LoadClasses:"; RTC_LOG(LS_INFO) << "LoadClasses:";
for (auto& c : loaded_classes) { for (auto& c : loaded_classes) {
jclass localRef = FindClass(jni, c.name); jclass localRef = FindClass(jni, c.name);
RTC_LOG(INFO) << "name: " << c.name; RTC_LOG(LS_INFO) << "name: " << c.name;
CHECK_EXCEPTION(jni) << "Error during FindClass: " << c.name; CHECK_EXCEPTION(jni) << "Error during FindClass: " << c.name;
RTC_CHECK(localRef) << c.name; RTC_CHECK(localRef) << c.name;
jclass globalRef = reinterpret_cast<jclass>(jni->NewGlobalRef(localRef)); jclass globalRef = reinterpret_cast<jclass>(jni->NewGlobalRef(localRef));
@ -69,12 +69,12 @@ jclass LookUpClass(const char* name) {
// JvmThreadConnector implementation. // JvmThreadConnector implementation.
JvmThreadConnector::JvmThreadConnector() : attached_(false) { JvmThreadConnector::JvmThreadConnector() : attached_(false) {
RTC_LOG(INFO) << "JvmThreadConnector::ctor"; RTC_LOG(LS_INFO) << "JvmThreadConnector::ctor";
JavaVM* jvm = JVM::GetInstance()->jvm(); JavaVM* jvm = JVM::GetInstance()->jvm();
RTC_CHECK(jvm); RTC_CHECK(jvm);
JNIEnv* jni = GetEnv(jvm); JNIEnv* jni = GetEnv(jvm);
if (!jni) { if (!jni) {
RTC_LOG(INFO) << "Attaching thread to JVM"; RTC_LOG(LS_INFO) << "Attaching thread to JVM";
JNIEnv* env = nullptr; JNIEnv* env = nullptr;
jint ret = jvm->AttachCurrentThread(&env, nullptr); jint ret = jvm->AttachCurrentThread(&env, nullptr);
attached_ = (ret == JNI_OK); attached_ = (ret == JNI_OK);
@ -82,10 +82,10 @@ JvmThreadConnector::JvmThreadConnector() : attached_(false) {
} }
JvmThreadConnector::~JvmThreadConnector() { JvmThreadConnector::~JvmThreadConnector() {
RTC_LOG(INFO) << "JvmThreadConnector::dtor"; RTC_LOG(LS_INFO) << "JvmThreadConnector::dtor";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
if (attached_) { if (attached_) {
RTC_LOG(INFO) << "Detaching thread from JVM"; RTC_LOG(LS_INFO) << "Detaching thread from JVM";
jint res = JVM::GetInstance()->jvm()->DetachCurrentThread(); jint res = JVM::GetInstance()->jvm()->DetachCurrentThread();
RTC_CHECK(res == JNI_OK) << "DetachCurrentThread failed: " << res; RTC_CHECK(res == JNI_OK) << "DetachCurrentThread failed: " << res;
} }
@ -94,11 +94,11 @@ JvmThreadConnector::~JvmThreadConnector() {
// GlobalRef implementation. // GlobalRef implementation.
GlobalRef::GlobalRef(JNIEnv* jni, jobject object) GlobalRef::GlobalRef(JNIEnv* jni, jobject object)
: jni_(jni), j_object_(NewGlobalRef(jni, object)) { : jni_(jni), j_object_(NewGlobalRef(jni, object)) {
RTC_LOG(INFO) << "GlobalRef::ctor"; RTC_LOG(LS_INFO) << "GlobalRef::ctor";
} }
GlobalRef::~GlobalRef() { GlobalRef::~GlobalRef() {
RTC_LOG(INFO) << "GlobalRef::dtor"; RTC_LOG(LS_INFO) << "GlobalRef::dtor";
DeleteGlobalRef(jni_, j_object_); DeleteGlobalRef(jni_, j_object_);
} }
@ -131,11 +131,11 @@ void GlobalRef::CallVoidMethod(jmethodID methodID, ...) {
// NativeRegistration implementation. // NativeRegistration implementation.
NativeRegistration::NativeRegistration(JNIEnv* jni, jclass clazz) NativeRegistration::NativeRegistration(JNIEnv* jni, jclass clazz)
: JavaClass(jni, clazz), jni_(jni) { : JavaClass(jni, clazz), jni_(jni) {
RTC_LOG(INFO) << "NativeRegistration::ctor"; RTC_LOG(LS_INFO) << "NativeRegistration::ctor";
} }
NativeRegistration::~NativeRegistration() { NativeRegistration::~NativeRegistration() {
RTC_LOG(INFO) << "NativeRegistration::dtor"; RTC_LOG(LS_INFO) << "NativeRegistration::dtor";
jni_->UnregisterNatives(j_class_); jni_->UnregisterNatives(j_class_);
CHECK_EXCEPTION(jni_) << "Error during UnregisterNatives"; CHECK_EXCEPTION(jni_) << "Error during UnregisterNatives";
} }
@ -143,7 +143,7 @@ NativeRegistration::~NativeRegistration() {
std::unique_ptr<GlobalRef> NativeRegistration::NewObject(const char* name, std::unique_ptr<GlobalRef> NativeRegistration::NewObject(const char* name,
const char* signature, const char* signature,
...) { ...) {
RTC_LOG(INFO) << "NativeRegistration::NewObject"; RTC_LOG(LS_INFO) << "NativeRegistration::NewObject";
va_list args; va_list args;
va_start(args, signature); va_start(args, signature);
jobject obj = jni_->NewObjectV( jobject obj = jni_->NewObjectV(
@ -181,11 +181,11 @@ jint JavaClass::CallStaticIntMethod(jmethodID methodID, ...) {
// JNIEnvironment implementation. // JNIEnvironment implementation.
JNIEnvironment::JNIEnvironment(JNIEnv* jni) : jni_(jni) { JNIEnvironment::JNIEnvironment(JNIEnv* jni) : jni_(jni) {
RTC_LOG(INFO) << "JNIEnvironment::ctor"; RTC_LOG(LS_INFO) << "JNIEnvironment::ctor";
} }
JNIEnvironment::~JNIEnvironment() { JNIEnvironment::~JNIEnvironment() {
RTC_LOG(INFO) << "JNIEnvironment::dtor"; RTC_LOG(LS_INFO) << "JNIEnvironment::dtor";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
} }
@ -193,7 +193,7 @@ std::unique_ptr<NativeRegistration> JNIEnvironment::RegisterNatives(
const char* name, const char* name,
const JNINativeMethod* methods, const JNINativeMethod* methods,
int num_methods) { int num_methods) {
RTC_LOG(INFO) << "JNIEnvironment::RegisterNatives: " << name; RTC_LOG(LS_INFO) << "JNIEnvironment::RegisterNatives: " << name;
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
jclass clazz = LookUpClass(name); jclass clazz = LookUpClass(name);
jni_->RegisterNatives(clazz, methods, num_methods); jni_->RegisterNatives(clazz, methods, num_methods);
@ -216,7 +216,7 @@ std::string JNIEnvironment::JavaToStdString(const jstring& j_string) {
// static // static
void JVM::Initialize(JavaVM* jvm) { void JVM::Initialize(JavaVM* jvm) {
RTC_LOG(INFO) << "JVM::Initialize"; RTC_LOG(LS_INFO) << "JVM::Initialize";
RTC_CHECK(!g_jvm); RTC_CHECK(!g_jvm);
g_jvm = new JVM(jvm); g_jvm = new JVM(jvm);
} }
@ -234,7 +234,7 @@ void JVM::Initialize(JavaVM* jvm, jobject context) {
// static // static
void JVM::Uninitialize() { void JVM::Uninitialize() {
RTC_LOG(INFO) << "JVM::Uninitialize"; RTC_LOG(LS_INFO) << "JVM::Uninitialize";
RTC_DCHECK(g_jvm); RTC_DCHECK(g_jvm);
delete g_jvm; delete g_jvm;
g_jvm = nullptr; g_jvm = nullptr;
@ -247,19 +247,19 @@ JVM* JVM::GetInstance() {
} }
JVM::JVM(JavaVM* jvm) : jvm_(jvm) { JVM::JVM(JavaVM* jvm) : jvm_(jvm) {
RTC_LOG(INFO) << "JVM::JVM"; RTC_LOG(LS_INFO) << "JVM::JVM";
RTC_CHECK(jni()) << "AttachCurrentThread() must be called on this thread."; RTC_CHECK(jni()) << "AttachCurrentThread() must be called on this thread.";
LoadClasses(jni()); LoadClasses(jni());
} }
JVM::~JVM() { JVM::~JVM() {
RTC_LOG(INFO) << "JVM::~JVM"; RTC_LOG(LS_INFO) << "JVM::~JVM";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
FreeClassReferences(jni()); FreeClassReferences(jni());
} }
std::unique_ptr<JNIEnvironment> JVM::environment() { std::unique_ptr<JNIEnvironment> JVM::environment() {
RTC_LOG(INFO) << "JVM::environment"; RTC_LOG(LS_INFO) << "JVM::environment";
; ;
// The JNIEnv is used for thread-local storage. For this reason, we cannot // The JNIEnv is used for thread-local storage. For this reason, we cannot
// share a JNIEnv between threads. If a piece of code has no other way to get // share a JNIEnv between threads. If a piece of code has no other way to get
@ -276,7 +276,7 @@ std::unique_ptr<JNIEnvironment> JVM::environment() {
} }
JavaClass JVM::GetClass(const char* name) { JavaClass JVM::GetClass(const char* name) {
RTC_LOG(INFO) << "JVM::GetClass: " << name; RTC_LOG(LS_INFO) << "JVM::GetClass: " << name;
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
return JavaClass(jni(), LookUpClass(name)); return JavaClass(jni(), LookUpClass(name));
} }

4
modules/video_coding/codecs/h264/h264_encoder_impl.cc
View File

@ -586,7 +586,7 @@ SEncParamExt H264EncoderImpl::CreateEncoderParams(size_t i) const {
// theoretically use all available reference buffers. // theoretically use all available reference buffers.
encoder_params.iNumRefFrame = encoder_params.iTemporalLayerNum - 1; encoder_params.iNumRefFrame = encoder_params.iTemporalLayerNum - 1;
} }
RTC_LOG(INFO) << "OpenH264 version is " << OPENH264_MAJOR << "." RTC_LOG(LS_INFO) << "OpenH264 version is " << OPENH264_MAJOR << "."
<< OPENH264_MINOR; << OPENH264_MINOR;
switch (packetization_mode_) { switch (packetization_mode_) {
case H264PacketizationMode::SingleNalUnit: case H264PacketizationMode::SingleNalUnit:
@ -596,7 +596,7 @@ SEncParamExt H264EncoderImpl::CreateEncoderParams(size_t i) const {
SM_SIZELIMITED_SLICE; SM_SIZELIMITED_SLICE;
encoder_params.sSpatialLayers[0].sSliceArgument.uiSliceSizeConstraint = encoder_params.sSpatialLayers[0].sSliceArgument.uiSliceSizeConstraint =
static_cast<unsigned int>(max_payload_size_); static_cast<unsigned int>(max_payload_size_);
RTC_LOG(INFO) << "Encoder is configured with NALU constraint: " RTC_LOG(LS_INFO) << "Encoder is configured with NALU constraint: "
<< max_payload_size_ << " bytes"; << max_payload_size_ << " bytes";
break; break;
case H264PacketizationMode::NonInterleaved: case H264PacketizationMode::NonInterleaved:

2
modules/video_coding/codecs/vp8/libvpx_vp8_encoder.cc
View File

@ -1293,7 +1293,7 @@ void LibvpxVp8Encoder::MaybeUpdatePixelFormat(vpx_img_fmt fmt) {
<< "Not all raw images had the right format!"; << "Not all raw images had the right format!";
return; return;
} }
RTC_LOG(INFO) << "Updating vp8 encoder pixel format to " RTC_LOG(LS_INFO) << "Updating vp8 encoder pixel format to "
<< (fmt == VPX_IMG_FMT_NV12 ? "NV12" : "I420"); << (fmt == VPX_IMG_FMT_NV12 ? "NV12" : "I420");
for (size_t i = 0; i < raw_images_.size(); ++i) { for (size_t i = 0; i < raw_images_.size(); ++i) {
vpx_image_t& img = raw_images_[i]; vpx_image_t& img = raw_images_[i];

2
modules/video_coding/codecs/vp9/libvpx_vp9_encoder.cc
View File

@ -1930,7 +1930,7 @@ void LibvpxVp9Encoder::MaybeRewrapRawWithFormat(const vpx_img_fmt fmt) {
raw_ = libvpx_->img_wrap(nullptr, fmt, codec_.width, codec_.height, 1, raw_ = libvpx_->img_wrap(nullptr, fmt, codec_.width, codec_.height, 1,
nullptr); nullptr);
} else if (raw_->fmt != fmt) { } else if (raw_->fmt != fmt) {
RTC_LOG(INFO) << "Switching VP9 encoder pixel format to " RTC_LOG(LS_INFO) << "Switching VP9 encoder pixel format to "
<< (fmt == VPX_IMG_FMT_NV12 ? "NV12" : "I420"); << (fmt == VPX_IMG_FMT_NV12 ? "NV12" : "I420");
libvpx_->img_free(raw_); libvpx_->img_free(raw_);
raw_ = libvpx_->img_wrap(nullptr, fmt, codec_.width, codec_.height, 1, raw_ = libvpx_->img_wrap(nullptr, fmt, codec_.width, codec_.height, 1,

6
modules/video_coding/utility/ivf_file_reader.cc
View File

@ -104,9 +104,9 @@ bool IvfFileReader::Reset() {
has_error_ = false; has_error_ = false;
const char* codec_name = CodecTypeToPayloadString(codec_type_); const char* codec_name = CodecTypeToPayloadString(codec_type_);
RTC_LOG(INFO) << "Opened IVF file with codec data of type " << codec_name RTC_LOG(LS_INFO) << "Opened IVF file with codec data of type " << codec_name
<< " at resolution " << width_ << " x " << height_ << ", using " << " at resolution " << width_ << " x " << height_
<< (using_capture_timestamps_ ? "1" : "90") << ", using " << (using_capture_timestamps_ ? "1" : "90")
<< "kHz clock resolution."; << "kHz clock resolution.";
return true; return true;

2
p2p/base/fake_ice_transport.h
View File

@ -364,7 +364,7 @@ class FakeIceTransport : public IceTransportInternal {
if (writable_ == writable) { if (writable_ == writable) {
return; return;
} }
RTC_LOG(INFO) << "Change writable_ to " << writable; RTC_LOG(LS_INFO) << "Change writable_ to " << writable;
writable_ = writable; writable_ = writable;
if (writable_) { if (writable_) {
SignalReadyToSend(this); SignalReadyToSend(this);

10
p2p/base/p2p_transport_channel.cc
View File

@ -1476,7 +1476,7 @@ bool P2PTransportChannel::CreateConnection(PortInterface* port,
// It is not legal to try to change any of the parameters of an existing // It is not legal to try to change any of the parameters of an existing
// connection; however, the other side can send a duplicate candidate. // connection; however, the other side can send a duplicate candidate.
if (!remote_candidate.IsEquivalent(connection->remote_candidate())) { if (!remote_candidate.IsEquivalent(connection->remote_candidate())) {
RTC_LOG(INFO) << "Attempt to change a remote candidate." RTC_LOG(LS_INFO) << "Attempt to change a remote candidate."
" Existing remote candidate: " " Existing remote candidate: "
<< connection->remote_candidate().ToSensitiveString() << connection->remote_candidate().ToSensitiveString()
<< "New remote candidate: " << "New remote candidate: "
@ -1532,7 +1532,7 @@ void P2PTransportChannel::RememberRemoteCandidate(
size_t i = 0; size_t i = 0;
while (i < remote_candidates_.size()) { while (i < remote_candidates_.size()) {
if (remote_candidates_[i].generation() < remote_candidate.generation()) { if (remote_candidates_[i].generation() < remote_candidate.generation()) {
RTC_LOG(INFO) << "Pruning candidate from old generation: " RTC_LOG(LS_INFO) << "Pruning candidate from old generation: "
<< remote_candidates_[i].address().ToSensitiveString(); << remote_candidates_[i].address().ToSensitiveString();
remote_candidates_.erase(remote_candidates_.begin() + i); remote_candidates_.erase(remote_candidates_.begin() + i);
} else { } else {
@ -1542,7 +1542,7 @@ void P2PTransportChannel::RememberRemoteCandidate(
// Make sure this candidate is not a duplicate. // Make sure this candidate is not a duplicate.
if (IsDuplicateRemoteCandidate(remote_candidate)) { if (IsDuplicateRemoteCandidate(remote_candidate)) {
RTC_LOG(INFO) << "Duplicate candidate: " RTC_LOG(LS_INFO) << "Duplicate candidate: "
<< remote_candidate.ToSensitiveString(); << remote_candidate.ToSensitiveString();
return; return;
} }
@ -2147,7 +2147,7 @@ void P2PTransportChannel::OnPortDestroyed(PortInterface* port) {
pruned_ports_.erase( pruned_ports_.erase(
std::remove(pruned_ports_.begin(), pruned_ports_.end(), port), std::remove(pruned_ports_.begin(), pruned_ports_.end(), port),
pruned_ports_.end()); pruned_ports_.end());
RTC_LOG(INFO) << "Removed port because it is destroyed: " << ports_.size() RTC_LOG(LS_INFO) << "Removed port because it is destroyed: " << ports_.size()
<< " remaining"; << " remaining";
} }
@ -2157,7 +2157,7 @@ void P2PTransportChannel::OnPortsPruned(
RTC_DCHECK_RUN_ON(network_thread_); RTC_DCHECK_RUN_ON(network_thread_);
for (PortInterface* port : ports) { for (PortInterface* port : ports) {
if (PrunePort(port)) { if (PrunePort(port)) {
RTC_LOG(INFO) << "Removed port: " << port->ToString() << " " RTC_LOG(LS_INFO) << "Removed port: " << port->ToString() << " "
<< ports_.size() << " remaining"; << ports_.size() << " remaining";
} }
} }

2
p2p/base/port_unittest.cc
View File

@ -350,7 +350,7 @@ class TestChannel : public sigslot::has_slots<> {
void OnDestroyed(Connection* conn) { void OnDestroyed(Connection* conn) {
ASSERT_EQ(conn_, conn); ASSERT_EQ(conn_, conn);
RTC_LOG(INFO) << "OnDestroy connection " << conn << " deleted"; RTC_LOG(LS_INFO) << "OnDestroy connection " << conn << " deleted";
conn_ = NULL; conn_ = NULL;
// When the connection is destroyed, also clear these fields so future // When the connection is destroyed, also clear these fields so future
// connections are possible. // connections are possible.

4
p2p/client/basic_port_allocator.cc
View File

@ -103,9 +103,9 @@ void FilterNetworks(NetworkList* networks, NetworkFilter filter) {
if (start_to_remove == networks->end()) { if (start_to_remove == networks->end()) {
return; return;
} }
RTC_LOG(INFO) << "Filtered out " << filter.description << " networks:"; RTC_LOG(LS_INFO) << "Filtered out " << filter.description << " networks:";
for (auto it = start_to_remove; it != networks->end(); ++it) { for (auto it = start_to_remove; it != networks->end(); ++it) {
RTC_LOG(INFO) << (*it)->ToString(); RTC_LOG(LS_INFO) << (*it)->ToString();
} }
networks->erase(start_to_remove, networks->end()); networks->erase(start_to_remove, networks->end());
} }

2
pc/jsep_transport.cc
View File

@ -365,7 +365,7 @@ webrtc::RTCError JsepTransport::VerifyCertificateFingerprint(
void JsepTransport::SetActiveResetSrtpParams(bool active_reset_srtp_params) { void JsepTransport::SetActiveResetSrtpParams(bool active_reset_srtp_params) {
RTC_DCHECK_RUN_ON(network_thread_); RTC_DCHECK_RUN_ON(network_thread_);
if (dtls_srtp_transport_) { if (dtls_srtp_transport_) {
RTC_LOG(INFO) RTC_LOG(LS_INFO)
<< "Setting active_reset_srtp_params of DtlsSrtpTransport to: " << "Setting active_reset_srtp_params of DtlsSrtpTransport to: "
<< active_reset_srtp_params; << active_reset_srtp_params;
dtls_srtp_transport_->SetActiveResetSrtpParams(active_reset_srtp_params); dtls_srtp_transport_->SetActiveResetSrtpParams(active_reset_srtp_params);

2
pc/jsep_transport_controller.cc
View File

@ -366,7 +366,7 @@ void JsepTransportController::SetActiveResetSrtpParams(
return; return;
} }
RTC_DCHECK_RUN_ON(network_thread_); RTC_DCHECK_RUN_ON(network_thread_);
RTC_LOG(INFO) RTC_LOG(LS_INFO)
<< "Updating the active_reset_srtp_params for JsepTransportController: " << "Updating the active_reset_srtp_params for JsepTransportController: "
<< active_reset_srtp_params; << active_reset_srtp_params;
active_reset_srtp_params_ = active_reset_srtp_params; active_reset_srtp_params_ = active_reset_srtp_params;

2
rtc_base/logging.h
View File

@ -89,6 +89,8 @@ enum LoggingSeverity {
LS_WARNING, LS_WARNING,
LS_ERROR, LS_ERROR,
LS_NONE, LS_NONE,
// Compatibility aliases, to be deleted.
// TODO(bugs.webrtc.org/13362): Remove usage and delete.
INFO = LS_INFO, INFO = LS_INFO,
WARNING = LS_WARNING, WARNING = LS_WARNING,
LERROR = LS_ERROR LERROR = LS_ERROR

4
rtc_base/network_unittest.cc
View File

@ -128,11 +128,11 @@ class FakeNetworkMonitorFactory : public NetworkMonitorFactory {
bool SameNameAndPrefix(const rtc::Network& a, const rtc::Network& b) { bool SameNameAndPrefix(const rtc::Network& a, const rtc::Network& b) {
if (a.name() != b.name()) { if (a.name() != b.name()) {
RTC_LOG(INFO) << "Different interface names."; RTC_LOG(LS_INFO) << "Different interface names.";
return false; return false;
} }
if (a.prefix_length() != b.prefix_length() || a.prefix() != b.prefix()) { if (a.prefix_length() != b.prefix_length() || a.prefix() != b.prefix()) {
RTC_LOG(INFO) << "Different IP prefixes."; RTC_LOG(LS_INFO) << "Different IP prefixes.";
return false; return false;
} }
return true; return true;

2
rtc_base/socket_adapters.cc
View File

@ -105,7 +105,7 @@ void BufferedReadAdapter::OnReadEvent(Socket* socket) {
buffer_size_ - data_len_, nullptr); buffer_size_ - data_len_, nullptr);
if (len < 0) { if (len < 0) {
// TODO: Do something better like forwarding the error to the user. // TODO: Do something better like forwarding the error to the user.
RTC_LOG_ERR(INFO) << "Recv"; RTC_LOG_ERR(LS_INFO) << "Recv";
return; return;
} }

6
rtc_base/win/scoped_com_initializer.cc
View File

@ -16,13 +16,13 @@
namespace webrtc { namespace webrtc {
ScopedCOMInitializer::ScopedCOMInitializer() { ScopedCOMInitializer::ScopedCOMInitializer() {
RTC_DLOG(INFO) << "Single-Threaded Apartment (STA) COM thread"; RTC_DLOG(LS_INFO) << "Single-Threaded Apartment (STA) COM thread";
Initialize(COINIT_APARTMENTTHREADED); Initialize(COINIT_APARTMENTTHREADED);
} }
// Constructor for MTA initialization. // Constructor for MTA initialization.
ScopedCOMInitializer::ScopedCOMInitializer(SelectMTA mta) { ScopedCOMInitializer::ScopedCOMInitializer(SelectMTA mta) {
RTC_DLOG(INFO) << "Multi-Threaded Apartment (MTA) COM thread"; RTC_DLOG(LS_INFO) << "Multi-Threaded Apartment (MTA) COM thread";
Initialize(COINIT_MULTITHREADED); Initialize(COINIT_MULTITHREADED);
} }
@ -46,7 +46,7 @@ void ScopedCOMInitializer::Initialize(COINIT init) {
// successful call to CoInitializeEx, including any call that returns // successful call to CoInitializeEx, including any call that returns
// S_FALSE, must be balanced by a corresponding call to CoUninitialize. // S_FALSE, must be balanced by a corresponding call to CoUninitialize.
if (hr_ == S_OK) { if (hr_ == S_OK) {
RTC_DLOG(INFO) RTC_DLOG(LS_INFO)
<< "The COM library was initialized successfully on this thread"; << "The COM library was initialized successfully on this thread";
} else if (hr_ == S_FALSE) { } else if (hr_ == S_FALSE) {
RTC_DLOG(WARNING) RTC_DLOG(WARNING)

6
rtc_base/win/windows_version_unittest.cc
View File

@ -18,11 +18,11 @@ namespace rtc_win {
namespace { namespace {
void MethodSupportedOnWin10AndLater() { void MethodSupportedOnWin10AndLater() {
RTC_DLOG(INFO) << "MethodSupportedOnWin10AndLater"; RTC_DLOG(LS_INFO) << "MethodSupportedOnWin10AndLater";
} }
void MethodNotSupportedOnWin10AndLater() { void MethodNotSupportedOnWin10AndLater() {
RTC_DLOG(INFO) << "MethodNotSupportedOnWin10AndLater"; RTC_DLOG(LS_INFO) << "MethodNotSupportedOnWin10AndLater";
} }
// Use global GetVersion() and use it in a way a user would typically use it // Use global GetVersion() and use it in a way a user would typically use it
@ -39,7 +39,7 @@ TEST(WindowsVersion, GetVersionGlobalScopeAccessor) {
TEST(WindowsVersion, ProcessorModelName) { TEST(WindowsVersion, ProcessorModelName) {
std::string name = OSInfo::GetInstance()->processor_model_name(); std::string name = OSInfo::GetInstance()->processor_model_name();
EXPECT_FALSE(name.empty()); EXPECT_FALSE(name.empty());
RTC_DLOG(INFO) << "processor_model_name: " << name; RTC_DLOG(LS_INFO) << "processor_model_name: " << name;
} }
} // namespace } // namespace

6
rtc_tools/converter/yuv_to_ivf_converter.cc
View File

@ -81,7 +81,7 @@ class IvfFileWriterEncodedCallback : public EncodedImageCallback {
received_frames_count_++; received_frames_count_++;
RTC_CHECK_LE(received_frames_count_, expected_frames_count_); RTC_CHECK_LE(received_frames_count_, expected_frames_count_);
if (received_frames_count_ % kFrameLogInterval == 0) { if (received_frames_count_ % kFrameLogInterval == 0) {
RTC_LOG(INFO) << received_frames_count_ << " out of " RTC_LOG(LS_INFO) << received_frames_count_ << " out of "
<< expected_frames_count_ << " frames written"; << expected_frames_count_ << " frames written";
} }
next_frame_written_.Set(); next_frame_written_.Set();
@ -231,11 +231,11 @@ void WriteVideoFile(std::string input_file_name,
encoder.WaitNextFrameWritten(kMaxFrameEncodeWaitTimeoutMs); encoder.WaitNextFrameWritten(kMaxFrameEncodeWaitTimeoutMs);
if ((i + 1) % kFrameLogInterval == 0) { if ((i + 1) % kFrameLogInterval == 0) {
RTC_LOG(INFO) << i + 1 << " out of " << frames_count RTC_LOG(LS_INFO) << i + 1 << " out of " << frames_count
<< " frames are sent for encoding"; << " frames are sent for encoding";
} }
} }
RTC_LOG(INFO) << "All " << frames_count << " frame are sent for encoding"; RTC_LOG(LS_INFO) << "All " << frames_count << " frame are sent for encoding";
} }
} // namespace } // namespace

8
sdk/android/native_api/audio_device_module/audio_device_android.cc
View File

@ -57,7 +57,7 @@ void GetDefaultAudioParameters(JNIEnv* env,
rtc::scoped_refptr<AudioDeviceModule> CreateAAudioAudioDeviceModule( rtc::scoped_refptr<AudioDeviceModule> CreateAAudioAudioDeviceModule(
JNIEnv* env, JNIEnv* env,
jobject application_context) { jobject application_context) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
// Get default audio input/output parameters. // Get default audio input/output parameters.
AudioParameters input_parameters; AudioParameters input_parameters;
AudioParameters output_parameters; AudioParameters output_parameters;
@ -76,7 +76,7 @@ rtc::scoped_refptr<AudioDeviceModule> CreateAAudioAudioDeviceModule(
rtc::scoped_refptr<AudioDeviceModule> CreateJavaAudioDeviceModule( rtc::scoped_refptr<AudioDeviceModule> CreateJavaAudioDeviceModule(
JNIEnv* env, JNIEnv* env,
jobject application_context) { jobject application_context) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
// Get default audio input/output parameters. // Get default audio input/output parameters.
const JavaParamRef<jobject> j_context(application_context); const JavaParamRef<jobject> j_context(application_context);
const ScopedJavaLocalRef<jobject> j_audio_manager = const ScopedJavaLocalRef<jobject> j_audio_manager =
@ -104,7 +104,7 @@ rtc::scoped_refptr<AudioDeviceModule> CreateJavaAudioDeviceModule(
rtc::scoped_refptr<AudioDeviceModule> CreateOpenSLESAudioDeviceModule( rtc::scoped_refptr<AudioDeviceModule> CreateOpenSLESAudioDeviceModule(
JNIEnv* env, JNIEnv* env,
jobject application_context) { jobject application_context) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
// Get default audio input/output parameters. // Get default audio input/output parameters.
AudioParameters input_parameters; AudioParameters input_parameters;
AudioParameters output_parameters; AudioParameters output_parameters;
@ -127,7 +127,7 @@ rtc::scoped_refptr<AudioDeviceModule> CreateOpenSLESAudioDeviceModule(
rtc::scoped_refptr<AudioDeviceModule> rtc::scoped_refptr<AudioDeviceModule>
CreateJavaInputAndOpenSLESOutputAudioDeviceModule(JNIEnv* env, CreateJavaInputAndOpenSLESOutputAudioDeviceModule(JNIEnv* env,
jobject application_context) { jobject application_context) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
// Get default audio input/output parameters. // Get default audio input/output parameters.
const JavaParamRef<jobject> j_context(application_context); const JavaParamRef<jobject> j_context(application_context);
const ScopedJavaLocalRef<jobject> j_audio_manager = const ScopedJavaLocalRef<jobject> j_audio_manager =

6
sdk/android/native_unittests/peerconnection/peer_connection_factory_unittest.cc
View File

@ -77,10 +77,10 @@ rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> CreateTestPCF(
TEST(PeerConnectionFactoryTest, NativeToJavaPeerConnectionFactory) { TEST(PeerConnectionFactoryTest, NativeToJavaPeerConnectionFactory) {
JNIEnv* jni = AttachCurrentThreadIfNeeded(); JNIEnv* jni = AttachCurrentThreadIfNeeded();
RTC_LOG(INFO) << "Initializing java peer connection factory."; RTC_LOG(LS_INFO) << "Initializing java peer connection factory.";
jni::Java_PeerConnectionFactoryInitializationHelper_initializeFactoryForTests( jni::Java_PeerConnectionFactoryInitializationHelper_initializeFactoryForTests(
jni); jni);
RTC_LOG(INFO) << "Java peer connection factory initialized."; RTC_LOG(LS_INFO) << "Java peer connection factory initialized.";
auto socket_server = std::make_unique<rtc::PhysicalSocketServer>(); auto socket_server = std::make_unique<rtc::PhysicalSocketServer>();
@ -105,7 +105,7 @@ TEST(PeerConnectionFactoryTest, NativeToJavaPeerConnectionFactory) {
jni, factory, std::move(socket_server), std::move(network_thread), jni, factory, std::move(socket_server), std::move(network_thread),
std::move(worker_thread), std::move(signaling_thread)); std::move(worker_thread), std::move(signaling_thread));
RTC_LOG(INFO) << java_factory; RTC_LOG(LS_INFO) << java_factory;
EXPECT_NE(java_factory, nullptr); EXPECT_NE(java_factory, nullptr);
} }

24
sdk/android/src/jni/audio_device/aaudio_player.cc
View File

@ -28,19 +28,19 @@ enum AudioDeviceMessageType : uint32_t {
AAudioPlayer::AAudioPlayer(const AudioParameters& audio_parameters) AAudioPlayer::AAudioPlayer(const AudioParameters& audio_parameters)
: main_thread_(rtc::Thread::Current()), : main_thread_(rtc::Thread::Current()),
aaudio_(audio_parameters, AAUDIO_DIRECTION_OUTPUT, this) { aaudio_(audio_parameters, AAUDIO_DIRECTION_OUTPUT, this) {
RTC_LOG(INFO) << "ctor"; RTC_LOG(LS_INFO) << "ctor";
thread_checker_aaudio_.Detach(); thread_checker_aaudio_.Detach();
} }
AAudioPlayer::~AAudioPlayer() { AAudioPlayer::~AAudioPlayer() {
RTC_LOG(INFO) << "dtor"; RTC_LOG(LS_INFO) << "dtor";
RTC_DCHECK_RUN_ON(&main_thread_checker_); RTC_DCHECK_RUN_ON(&main_thread_checker_);
Terminate(); Terminate();
RTC_LOG(INFO) << "#detected underruns: " << underrun_count_; RTC_LOG(LS_INFO) << "#detected underruns: " << underrun_count_;
} }
int AAudioPlayer::Init() { int AAudioPlayer::Init() {
RTC_LOG(INFO) << "Init"; RTC_LOG(LS_INFO) << "Init";
RTC_DCHECK_RUN_ON(&main_thread_checker_); RTC_DCHECK_RUN_ON(&main_thread_checker_);
if (aaudio_.audio_parameters().channels() == 2) { if (aaudio_.audio_parameters().channels() == 2) {
RTC_DLOG(LS_WARNING) << "Stereo mode is enabled"; RTC_DLOG(LS_WARNING) << "Stereo mode is enabled";
@ -49,14 +49,14 @@ int AAudioPlayer::Init() {
} }
int AAudioPlayer::Terminate() { int AAudioPlayer::Terminate() {
RTC_LOG(INFO) << "Terminate"; RTC_LOG(LS_INFO) << "Terminate";
RTC_DCHECK_RUN_ON(&main_thread_checker_); RTC_DCHECK_RUN_ON(&main_thread_checker_);
StopPlayout(); StopPlayout();
return 0; return 0;
} }
int AAudioPlayer::InitPlayout() { int AAudioPlayer::InitPlayout() {
RTC_LOG(INFO) << "InitPlayout"; RTC_LOG(LS_INFO) << "InitPlayout";
RTC_DCHECK_RUN_ON(&main_thread_checker_); RTC_DCHECK_RUN_ON(&main_thread_checker_);
RTC_DCHECK(!initialized_); RTC_DCHECK(!initialized_);
RTC_DCHECK(!playing_); RTC_DCHECK(!playing_);
@ -73,7 +73,7 @@ bool AAudioPlayer::PlayoutIsInitialized() const {
} }
int AAudioPlayer::StartPlayout() { int AAudioPlayer::StartPlayout() {
RTC_LOG(INFO) << "StartPlayout"; RTC_LOG(LS_INFO) << "StartPlayout";
RTC_DCHECK_RUN_ON(&main_thread_checker_); RTC_DCHECK_RUN_ON(&main_thread_checker_);
RTC_DCHECK(!playing_); RTC_DCHECK(!playing_);
if (!initialized_) { if (!initialized_) {
@ -94,7 +94,7 @@ int AAudioPlayer::StartPlayout() {
} }
int AAudioPlayer::StopPlayout() { int AAudioPlayer::StopPlayout() {
RTC_LOG(INFO) << "StopPlayout"; RTC_LOG(LS_INFO) << "StopPlayout";
RTC_DCHECK_RUN_ON(&main_thread_checker_); RTC_DCHECK_RUN_ON(&main_thread_checker_);
if (!initialized_ || !playing_) { if (!initialized_ || !playing_) {
return 0; return 0;
@ -115,7 +115,7 @@ bool AAudioPlayer::Playing() const {
} }
void AAudioPlayer::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) { void AAudioPlayer::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
RTC_DLOG(INFO) << "AttachAudioBuffer"; RTC_DLOG(LS_INFO) << "AttachAudioBuffer";
RTC_DCHECK_RUN_ON(&main_thread_checker_); RTC_DCHECK_RUN_ON(&main_thread_checker_);
audio_device_buffer_ = audioBuffer; audio_device_buffer_ = audioBuffer;
const AudioParameters audio_parameters = aaudio_.audio_parameters(); const AudioParameters audio_parameters = aaudio_.audio_parameters();
@ -173,7 +173,7 @@ aaudio_data_callback_result_t AAudioPlayer::OnDataCallback(void* audio_data,
// Log device id in first data callback to ensure that a valid device is // Log device id in first data callback to ensure that a valid device is
// utilized. // utilized.
if (first_data_callback_) { if (first_data_callback_) {
RTC_LOG(INFO) << "--- First output data callback: " RTC_LOG(LS_INFO) << "--- First output data callback: "
"device id=" "device id="
<< aaudio_.device_id(); << aaudio_.device_id();
first_data_callback_ = false; first_data_callback_ = false;
@ -195,7 +195,7 @@ aaudio_data_callback_result_t AAudioPlayer::OnDataCallback(void* audio_data,
latency_millis_ = aaudio_.EstimateLatencyMillis(); latency_millis_ = aaudio_.EstimateLatencyMillis();
// TODO(henrika): use for development only. // TODO(henrika): use for development only.
if (aaudio_.frames_written() % (1000 * aaudio_.frames_per_burst()) == 0) { if (aaudio_.frames_written() % (1000 * aaudio_.frames_per_burst()) == 0) {
RTC_DLOG(INFO) << "output latency: " << latency_millis_ RTC_DLOG(LS_INFO) << "output latency: " << latency_millis_
<< ", num_frames: " << num_frames; << ", num_frames: " << num_frames;
} }
@ -231,7 +231,7 @@ void AAudioPlayer::OnMessage(rtc::Message* msg) {
void AAudioPlayer::HandleStreamDisconnected() { void AAudioPlayer::HandleStreamDisconnected() {
RTC_DCHECK_RUN_ON(&main_thread_checker_); RTC_DCHECK_RUN_ON(&main_thread_checker_);
RTC_DLOG(INFO) << "HandleStreamDisconnected"; RTC_DLOG(LS_INFO) << "HandleStreamDisconnected";
if (!initialized_ || !playing_) { if (!initialized_ || !playing_) {
return; return;
} }

30
sdk/android/src/jni/audio_device/aaudio_recorder.cc
View File

@ -29,19 +29,19 @@ enum AudioDeviceMessageType : uint32_t {
AAudioRecorder::AAudioRecorder(const AudioParameters& audio_parameters) AAudioRecorder::AAudioRecorder(const AudioParameters& audio_parameters)
: main_thread_(rtc::Thread::Current()), : main_thread_(rtc::Thread::Current()),
aaudio_(audio_parameters, AAUDIO_DIRECTION_INPUT, this) { aaudio_(audio_parameters, AAUDIO_DIRECTION_INPUT, this) {
RTC_LOG(INFO) << "ctor"; RTC_LOG(LS_INFO) << "ctor";
thread_checker_aaudio_.Detach(); thread_checker_aaudio_.Detach();
} }
AAudioRecorder::~AAudioRecorder() { AAudioRecorder::~AAudioRecorder() {
RTC_LOG(INFO) << "dtor"; RTC_LOG(LS_INFO) << "dtor";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
Terminate(); Terminate();
RTC_LOG(INFO) << "detected owerflows: " << overflow_count_; RTC_LOG(LS_INFO) << "detected owerflows: " << overflow_count_;
} }
int AAudioRecorder::Init() { int AAudioRecorder::Init() {
RTC_LOG(INFO) << "Init"; RTC_LOG(LS_INFO) << "Init";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
if (aaudio_.audio_parameters().channels() == 2) { if (aaudio_.audio_parameters().channels() == 2) {
RTC_DLOG(LS_WARNING) << "Stereo mode is enabled"; RTC_DLOG(LS_WARNING) << "Stereo mode is enabled";
@ -50,14 +50,14 @@ int AAudioRecorder::Init() {
} }
int AAudioRecorder::Terminate() { int AAudioRecorder::Terminate() {
RTC_LOG(INFO) << "Terminate"; RTC_LOG(LS_INFO) << "Terminate";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
StopRecording(); StopRecording();
return 0; return 0;
} }
int AAudioRecorder::InitRecording() { int AAudioRecorder::InitRecording() {
RTC_LOG(INFO) << "InitRecording"; RTC_LOG(LS_INFO) << "InitRecording";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!initialized_); RTC_DCHECK(!initialized_);
RTC_DCHECK(!recording_); RTC_DCHECK(!recording_);
@ -73,7 +73,7 @@ bool AAudioRecorder::RecordingIsInitialized() const {
} }
int AAudioRecorder::StartRecording() { int AAudioRecorder::StartRecording() {
RTC_LOG(INFO) << "StartRecording"; RTC_LOG(LS_INFO) << "StartRecording";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(initialized_); RTC_DCHECK(initialized_);
RTC_DCHECK(!recording_); RTC_DCHECK(!recording_);
@ -90,7 +90,7 @@ int AAudioRecorder::StartRecording() {
} }
int AAudioRecorder::StopRecording() { int AAudioRecorder::StopRecording() {
RTC_LOG(INFO) << "StopRecording"; RTC_LOG(LS_INFO) << "StopRecording";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
if (!initialized_ || !recording_) { if (!initialized_ || !recording_) {
return 0; return 0;
@ -109,7 +109,7 @@ bool AAudioRecorder::Recording() const {
} }
void AAudioRecorder::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) { void AAudioRecorder::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
RTC_LOG(INFO) << "AttachAudioBuffer"; RTC_LOG(LS_INFO) << "AttachAudioBuffer";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
audio_device_buffer_ = audioBuffer; audio_device_buffer_ = audioBuffer;
const AudioParameters audio_parameters = aaudio_.audio_parameters(); const AudioParameters audio_parameters = aaudio_.audio_parameters();
@ -131,13 +131,13 @@ bool AAudioRecorder::IsNoiseSuppressorSupported() const {
} }
int AAudioRecorder::EnableBuiltInAEC(bool enable) { int AAudioRecorder::EnableBuiltInAEC(bool enable) {
RTC_LOG(INFO) << "EnableBuiltInAEC: " << enable; RTC_LOG(LS_INFO) << "EnableBuiltInAEC: " << enable;
RTC_LOG(LS_ERROR) << "Not implemented"; RTC_LOG(LS_ERROR) << "Not implemented";
return -1; return -1;
} }
int AAudioRecorder::EnableBuiltInNS(bool enable) { int AAudioRecorder::EnableBuiltInNS(bool enable) {
RTC_LOG(INFO) << "EnableBuiltInNS: " << enable; RTC_LOG(LS_INFO) << "EnableBuiltInNS: " << enable;
RTC_LOG(LS_ERROR) << "Not implemented"; RTC_LOG(LS_ERROR) << "Not implemented";
return -1; return -1;
} }
@ -165,12 +165,12 @@ aaudio_data_callback_result_t AAudioRecorder::OnDataCallback(
int32_t num_frames) { int32_t num_frames) {
// TODO(henrika): figure out why we sometimes hit this one. // TODO(henrika): figure out why we sometimes hit this one.
// RTC_DCHECK(thread_checker_aaudio_.IsCurrent()); // RTC_DCHECK(thread_checker_aaudio_.IsCurrent());
// RTC_LOG(INFO) << "OnDataCallback: " << num_frames; // RTC_LOG(LS_INFO) << "OnDataCallback: " << num_frames;
// Drain the input buffer at first callback to ensure that it does not // Drain the input buffer at first callback to ensure that it does not
// contain any old data. Will also ensure that the lowest possible latency // contain any old data. Will also ensure that the lowest possible latency
// is obtained. // is obtained.
if (first_data_callback_) { if (first_data_callback_) {
RTC_LOG(INFO) << "--- First input data callback: " RTC_LOG(LS_INFO) << "--- First input data callback: "
"device id=" "device id="
<< aaudio_.device_id(); << aaudio_.device_id();
aaudio_.ClearInputStream(audio_data, num_frames); aaudio_.ClearInputStream(audio_data, num_frames);
@ -188,7 +188,7 @@ aaudio_data_callback_result_t AAudioRecorder::OnDataCallback(
latency_millis_ = aaudio_.EstimateLatencyMillis(); latency_millis_ = aaudio_.EstimateLatencyMillis();
// TODO(henrika): use for development only. // TODO(henrika): use for development only.
if (aaudio_.frames_read() % (1000 * aaudio_.frames_per_burst()) == 0) { if (aaudio_.frames_read() % (1000 * aaudio_.frames_per_burst()) == 0) {
RTC_DLOG(INFO) << "input latency: " << latency_millis_ RTC_DLOG(LS_INFO) << "input latency: " << latency_millis_
<< ", num_frames: " << num_frames; << ", num_frames: " << num_frames;
} }
// Copy recorded audio in `audio_data` to the WebRTC sink using the // Copy recorded audio in `audio_data` to the WebRTC sink using the
@ -215,7 +215,7 @@ void AAudioRecorder::OnMessage(rtc::Message* msg) {
void AAudioRecorder::HandleStreamDisconnected() { void AAudioRecorder::HandleStreamDisconnected() {
RTC_DCHECK_RUN_ON(&thread_checker_); RTC_DCHECK_RUN_ON(&thread_checker_);
RTC_LOG(INFO) << "HandleStreamDisconnected"; RTC_LOG(LS_INFO) << "HandleStreamDisconnected";
if (!initialized_ || !recording_) { if (!initialized_ || !recording_) {
return; return;
} }

40
sdk/android/src/jni/audio_device/aaudio_wrapper.cc
View File

@ -137,20 +137,20 @@ AAudioWrapper::AAudioWrapper(const AudioParameters& audio_parameters,
: audio_parameters_(audio_parameters), : audio_parameters_(audio_parameters),
direction_(direction), direction_(direction),
observer_(observer) { observer_(observer) {
RTC_LOG(INFO) << "ctor"; RTC_LOG(LS_INFO) << "ctor";
RTC_DCHECK(observer_); RTC_DCHECK(observer_);
aaudio_thread_checker_.Detach(); aaudio_thread_checker_.Detach();
RTC_LOG(INFO) << audio_parameters_.ToString(); RTC_LOG(LS_INFO) << audio_parameters_.ToString();
} }
AAudioWrapper::~AAudioWrapper() { AAudioWrapper::~AAudioWrapper() {
RTC_LOG(INFO) << "dtor"; RTC_LOG(LS_INFO) << "dtor";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!stream_); RTC_DCHECK(!stream_);
} }
bool AAudioWrapper::Init() { bool AAudioWrapper::Init() {
RTC_LOG(INFO) << "Init"; RTC_LOG(LS_INFO) << "Init";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
// Creates a stream builder which can be used to open an audio stream. // Creates a stream builder which can be used to open an audio stream.
ScopedStreamBuilder builder; ScopedStreamBuilder builder;
@ -174,7 +174,7 @@ bool AAudioWrapper::Init() {
} }
bool AAudioWrapper::Start() { bool AAudioWrapper::Start() {
RTC_LOG(INFO) << "Start"; RTC_LOG(LS_INFO) << "Start";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
// TODO(henrika): this state check might not be needed. // TODO(henrika): this state check might not be needed.
aaudio_stream_state_t current_state = AAudioStream_getState(stream_); aaudio_stream_state_t current_state = AAudioStream_getState(stream_);
@ -190,7 +190,7 @@ bool AAudioWrapper::Start() {
} }
bool AAudioWrapper::Stop() { bool AAudioWrapper::Stop() {
RTC_LOG(INFO) << "Stop: " << DirectionToString(direction()); RTC_LOG(LS_INFO) << "Stop: " << DirectionToString(direction());
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
// Asynchronous request for the stream to stop. // Asynchronous request for the stream to stop.
RETURN_ON_ERROR(AAudioStream_requestStop(stream_), false); RETURN_ON_ERROR(AAudioStream_requestStop(stream_), false);
@ -240,7 +240,7 @@ double AAudioWrapper::EstimateLatencyMillis() const {
// Returns new buffer size or a negative error value if buffer size could not // Returns new buffer size or a negative error value if buffer size could not
// be increased. // be increased.
bool AAudioWrapper::IncreaseOutputBufferSize() { bool AAudioWrapper::IncreaseOutputBufferSize() {
RTC_LOG(INFO) << "IncreaseBufferSize"; RTC_LOG(LS_INFO) << "IncreaseBufferSize";
RTC_DCHECK(stream_); RTC_DCHECK(stream_);
RTC_DCHECK(aaudio_thread_checker_.IsCurrent()); RTC_DCHECK(aaudio_thread_checker_.IsCurrent());
RTC_DCHECK_EQ(direction(), AAUDIO_DIRECTION_OUTPUT); RTC_DCHECK_EQ(direction(), AAUDIO_DIRECTION_OUTPUT);
@ -255,7 +255,7 @@ bool AAudioWrapper::IncreaseOutputBufferSize() {
<< ") is higher than max: " << max_buffer_size; << ") is higher than max: " << max_buffer_size;
return false; return false;
} }
RTC_LOG(INFO) << "Updating buffer size to: " << buffer_size RTC_LOG(LS_INFO) << "Updating buffer size to: " << buffer_size
<< " (max=" << max_buffer_size << ")"; << " (max=" << max_buffer_size << ")";
buffer_size = AAudioStream_setBufferSizeInFrames(stream_, buffer_size); buffer_size = AAudioStream_setBufferSizeInFrames(stream_, buffer_size);
if (buffer_size < 0) { if (buffer_size < 0) {
@ -263,12 +263,12 @@ bool AAudioWrapper::IncreaseOutputBufferSize() {
<< AAudio_convertResultToText(buffer_size); << AAudio_convertResultToText(buffer_size);
return false; return false;
} }
RTC_LOG(INFO) << "Buffer size changed to: " << buffer_size; RTC_LOG(LS_INFO) << "Buffer size changed to: " << buffer_size;
return true; return true;
} }
void AAudioWrapper::ClearInputStream(void* audio_data, int32_t num_frames) { void AAudioWrapper::ClearInputStream(void* audio_data, int32_t num_frames) {
RTC_LOG(INFO) << "ClearInputStream"; RTC_LOG(LS_INFO) << "ClearInputStream";
RTC_DCHECK(stream_); RTC_DCHECK(stream_);
RTC_DCHECK(aaudio_thread_checker_.IsCurrent()); RTC_DCHECK(aaudio_thread_checker_.IsCurrent());
RTC_DCHECK_EQ(direction(), AAUDIO_DIRECTION_INPUT); RTC_DCHECK_EQ(direction(), AAUDIO_DIRECTION_INPUT);
@ -357,7 +357,7 @@ int64_t AAudioWrapper::frames_read() const {
} }
void AAudioWrapper::SetStreamConfiguration(AAudioStreamBuilder* builder) { void AAudioWrapper::SetStreamConfiguration(AAudioStreamBuilder* builder) {
RTC_LOG(INFO) << "SetStreamConfiguration"; RTC_LOG(LS_INFO) << "SetStreamConfiguration";
RTC_DCHECK(builder); RTC_DCHECK(builder);
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
// Request usage of default primary output/input device. // Request usage of default primary output/input device.
@ -390,7 +390,7 @@ void AAudioWrapper::SetStreamConfiguration(AAudioStreamBuilder* builder) {
} }
bool AAudioWrapper::OpenStream(AAudioStreamBuilder* builder) { bool AAudioWrapper::OpenStream(AAudioStreamBuilder* builder) {
RTC_LOG(INFO) << "OpenStream"; RTC_LOG(LS_INFO) << "OpenStream";
RTC_DCHECK(builder); RTC_DCHECK(builder);
AAudioStream* stream = nullptr; AAudioStream* stream = nullptr;
RETURN_ON_ERROR(AAudioStreamBuilder_openStream(builder, &stream), false); RETURN_ON_ERROR(AAudioStreamBuilder_openStream(builder, &stream), false);
@ -400,7 +400,7 @@ bool AAudioWrapper::OpenStream(AAudioStreamBuilder* builder) {
} }
void AAudioWrapper::CloseStream() { void AAudioWrapper::CloseStream() {
RTC_LOG(INFO) << "CloseStream"; RTC_LOG(LS_INFO) << "CloseStream";
RTC_DCHECK(stream_); RTC_DCHECK(stream_);
LOG_ON_ERROR(AAudioStream_close(stream_)); LOG_ON_ERROR(AAudioStream_close(stream_));
stream_ = nullptr; stream_ = nullptr;
@ -419,16 +419,16 @@ void AAudioWrapper::LogStreamConfiguration() {
ss << ", direction=" << DirectionToString(direction()); ss << ", direction=" << DirectionToString(direction());
ss << ", device id=" << AAudioStream_getDeviceId(stream_); ss << ", device id=" << AAudioStream_getDeviceId(stream_);
ss << ", frames per callback=" << frames_per_callback(); ss << ", frames per callback=" << frames_per_callback();
RTC_LOG(INFO) << ss.str(); RTC_LOG(LS_INFO) << ss.str();
} }
void AAudioWrapper::LogStreamState() { void AAudioWrapper::LogStreamState() {
RTC_LOG(INFO) << "AAudio stream state: " RTC_LOG(LS_INFO) << "AAudio stream state: "
<< AAudio_convertStreamStateToText(stream_state()); << AAudio_convertStreamStateToText(stream_state());
} }
bool AAudioWrapper::VerifyStreamConfiguration() { bool AAudioWrapper::VerifyStreamConfiguration() {
RTC_LOG(INFO) << "VerifyStreamConfiguration"; RTC_LOG(LS_INFO) << "VerifyStreamConfiguration";
RTC_DCHECK(stream_); RTC_DCHECK(stream_);
// TODO(henrika): should we verify device ID as well? // TODO(henrika): should we verify device ID as well?
if (AAudioStream_getSampleRate(stream_) != audio_parameters().sample_rate()) { if (AAudioStream_getSampleRate(stream_) != audio_parameters().sample_rate()) {
@ -466,15 +466,15 @@ bool AAudioWrapper::VerifyStreamConfiguration() {
} }
bool AAudioWrapper::OptimizeBuffers() { bool AAudioWrapper::OptimizeBuffers() {
RTC_LOG(INFO) << "OptimizeBuffers"; RTC_LOG(LS_INFO) << "OptimizeBuffers";
RTC_DCHECK(stream_); RTC_DCHECK(stream_);
// Maximum number of frames that can be filled without blocking. // Maximum number of frames that can be filled without blocking.
RTC_LOG(INFO) << "max buffer capacity in frames: " RTC_LOG(LS_INFO) << "max buffer capacity in frames: "
<< buffer_capacity_in_frames(); << buffer_capacity_in_frames();
// Query the number of frames that the application should read or write at // Query the number of frames that the application should read or write at
// one time for optimal performance. // one time for optimal performance.
int32_t frames_per_burst = AAudioStream_getFramesPerBurst(stream_); int32_t frames_per_burst = AAudioStream_getFramesPerBurst(stream_);
RTC_LOG(INFO) << "frames per burst for optimal performance: " RTC_LOG(LS_INFO) << "frames per burst for optimal performance: "
<< frames_per_burst; << frames_per_burst;
frames_per_burst_ = frames_per_burst; frames_per_burst_ = frames_per_burst;
if (direction() == AAUDIO_DIRECTION_INPUT) { if (direction() == AAUDIO_DIRECTION_INPUT) {
@ -492,7 +492,7 @@ bool AAudioWrapper::OptimizeBuffers() {
return false; return false;
} }
// Maximum number of frames that can be filled without blocking. // Maximum number of frames that can be filled without blocking.
RTC_LOG(INFO) << "buffer burst size in frames: " << buffer_size; RTC_LOG(LS_INFO) << "buffer burst size in frames: " << buffer_size;
return true; return true;
} }

160
sdk/android/src/jni/audio_device/audio_device_module.cc
View File

@ -70,26 +70,26 @@ class AndroidAudioDeviceModule : public AudioDeviceModule {
initialized_(false) { initialized_(false) {
RTC_CHECK(input_); RTC_CHECK(input_);
RTC_CHECK(output_); RTC_CHECK(output_);
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
thread_checker_.Detach(); thread_checker_.Detach();
} }
~AndroidAudioDeviceModule() override { RTC_DLOG(INFO) << __FUNCTION__; } ~AndroidAudioDeviceModule() override { RTC_DLOG(LS_INFO) << __FUNCTION__; }
int32_t ActiveAudioLayer( int32_t ActiveAudioLayer(
AudioDeviceModule::AudioLayer* audioLayer) const override { AudioDeviceModule::AudioLayer* audioLayer) const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
*audioLayer = audio_layer_; *audioLayer = audio_layer_;
return 0; return 0;
} }
int32_t RegisterAudioCallback(AudioTransport* audioCallback) override { int32_t RegisterAudioCallback(AudioTransport* audioCallback) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return audio_device_buffer_->RegisterAudioCallback(audioCallback); return audio_device_buffer_->RegisterAudioCallback(audioCallback);
} }
int32_t Init() override { int32_t Init() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
audio_device_buffer_ = audio_device_buffer_ =
std::make_unique<AudioDeviceBuffer>(task_queue_factory_.get()); std::make_unique<AudioDeviceBuffer>(task_queue_factory_.get());
@ -118,7 +118,7 @@ class AndroidAudioDeviceModule : public AudioDeviceModule {
} }
int32_t Terminate() override { int32_t Terminate() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
if (!initialized_) if (!initialized_)
return 0; return 0;
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
@ -132,19 +132,19 @@ class AndroidAudioDeviceModule : public AudioDeviceModule {
} }
bool Initialized() const override { bool Initialized() const override {
RTC_DLOG(INFO) << __FUNCTION__ << ":" << initialized_; RTC_DLOG(LS_INFO) << __FUNCTION__ << ":" << initialized_;
return initialized_; return initialized_;
} }
int16_t PlayoutDevices() override { int16_t PlayoutDevices() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_LOG(INFO) << "output: " << 1; RTC_LOG(LS_INFO) << "output: " << 1;
return 1; return 1;
} }
int16_t RecordingDevices() override { int16_t RecordingDevices() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DLOG(INFO) << "output: " << 1; RTC_DLOG(LS_INFO) << "output: " << 1;
return 1; return 1;
} }
@ -163,7 +163,7 @@ class AndroidAudioDeviceModule : public AudioDeviceModule {
int32_t SetPlayoutDevice(uint16_t index) override { int32_t SetPlayoutDevice(uint16_t index) override {
// OK to use but it has no effect currently since device selection is // OK to use but it has no effect currently since device selection is
// done using Andoid APIs instead. // done using Andoid APIs instead.
RTC_DLOG(INFO) << __FUNCTION__ << "(" << index << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << index << ")";
return 0; return 0;
} }
@ -175,7 +175,7 @@ class AndroidAudioDeviceModule : public AudioDeviceModule {
int32_t SetRecordingDevice(uint16_t index) override { int32_t SetRecordingDevice(uint16_t index) override {
// OK to use but it has no effect currently since device selection is // OK to use but it has no effect currently since device selection is
// done using Andoid APIs instead. // done using Andoid APIs instead.
RTC_DLOG(INFO) << __FUNCTION__ << "(" << index << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << index << ")";
return 0; return 0;
} }
@ -185,66 +185,66 @@ class AndroidAudioDeviceModule : public AudioDeviceModule {
} }
int32_t PlayoutIsAvailable(bool* available) override { int32_t PlayoutIsAvailable(bool* available) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
*available = true; *available = true;
RTC_DLOG(INFO) << "output: " << *available; RTC_DLOG(LS_INFO) << "output: " << *available;
return 0; return 0;
} }
int32_t InitPlayout() override { int32_t InitPlayout() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
if (!initialized_) if (!initialized_)
return -1; return -1;
if (PlayoutIsInitialized()) { if (PlayoutIsInitialized()) {
return 0; return 0;
} }
int32_t result = output_->InitPlayout(); int32_t result = output_->InitPlayout();
RTC_DLOG(INFO) << "output: " << result; RTC_DLOG(LS_INFO) << "output: " << result;
RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.InitPlayoutSuccess", RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.InitPlayoutSuccess",
static_cast<int>(result == 0)); static_cast<int>(result == 0));
return result; return result;
} }
bool PlayoutIsInitialized() const override { bool PlayoutIsInitialized() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return output_->PlayoutIsInitialized(); return output_->PlayoutIsInitialized();
} }
int32_t RecordingIsAvailable(bool* available) override { int32_t RecordingIsAvailable(bool* available) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
*available = true; *available = true;
RTC_DLOG(INFO) << "output: " << *available; RTC_DLOG(LS_INFO) << "output: " << *available;
return 0; return 0;
} }
int32_t InitRecording() override { int32_t InitRecording() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
if (!initialized_) if (!initialized_)
return -1; return -1;
if (RecordingIsInitialized()) { if (RecordingIsInitialized()) {
return 0; return 0;
} }
int32_t result = input_->InitRecording(); int32_t result = input_->InitRecording();
RTC_DLOG(INFO) << "output: " << result; RTC_DLOG(LS_INFO) << "output: " << result;
RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.InitRecordingSuccess", RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.InitRecordingSuccess",
static_cast<int>(result == 0)); static_cast<int>(result == 0));
return result; return result;
} }
bool RecordingIsInitialized() const override { bool RecordingIsInitialized() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return input_->RecordingIsInitialized(); return input_->RecordingIsInitialized();
} }
int32_t StartPlayout() override { int32_t StartPlayout() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
if (!initialized_) if (!initialized_)
return -1; return -1;
if (Playing()) { if (Playing()) {
return 0; return 0;
} }
int32_t result = output_->StartPlayout(); int32_t result = output_->StartPlayout();
RTC_DLOG(INFO) << "output: " << result; RTC_DLOG(LS_INFO) << "output: " << result;
RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StartPlayoutSuccess", RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StartPlayoutSuccess",
static_cast<int>(result == 0)); static_cast<int>(result == 0));
if (result == 0) { if (result == 0) {
@ -256,34 +256,34 @@ class AndroidAudioDeviceModule : public AudioDeviceModule {
} }
int32_t StopPlayout() override { int32_t StopPlayout() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
if (!initialized_) if (!initialized_)
return -1; return -1;
if (!Playing()) if (!Playing())
return 0; return 0;
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
audio_device_buffer_->StopPlayout(); audio_device_buffer_->StopPlayout();
int32_t result = output_->StopPlayout(); int32_t result = output_->StopPlayout();
RTC_DLOG(INFO) << "output: " << result; RTC_DLOG(LS_INFO) << "output: " << result;
RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StopPlayoutSuccess", RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StopPlayoutSuccess",
static_cast<int>(result == 0)); static_cast<int>(result == 0));
return result; return result;
} }
bool Playing() const override { bool Playing() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return output_->Playing(); return output_->Playing();
} }
int32_t StartRecording() override { int32_t StartRecording() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
if (!initialized_) if (!initialized_)
return -1; return -1;
if (Recording()) { if (Recording()) {
return 0; return 0;
} }
int32_t result = input_->StartRecording(); int32_t result = input_->StartRecording();
RTC_DLOG(INFO) << "output: " << result; RTC_DLOG(LS_INFO) << "output: " << result;
RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StartRecordingSuccess", RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StartRecordingSuccess",
static_cast<int>(result == 0)); static_cast<int>(result == 0));
if (result == 0) { if (result == 0) {
@ -295,74 +295,74 @@ class AndroidAudioDeviceModule : public AudioDeviceModule {
} }
int32_t StopRecording() override { int32_t StopRecording() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
if (!initialized_) if (!initialized_)
return -1; return -1;
if (!Recording()) if (!Recording())
return 0; return 0;
audio_device_buffer_->StopRecording(); audio_device_buffer_->StopRecording();
int32_t result = input_->StopRecording(); int32_t result = input_->StopRecording();
RTC_DLOG(INFO) << "output: " << result; RTC_DLOG(LS_INFO) << "output: " << result;
RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StopRecordingSuccess", RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StopRecordingSuccess",
static_cast<int>(result == 0)); static_cast<int>(result == 0));
return result; return result;
} }
bool Recording() const override { bool Recording() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return input_->Recording(); return input_->Recording();
} }
int32_t InitSpeaker() override { int32_t InitSpeaker() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return initialized_ ? 0 : -1; return initialized_ ? 0 : -1;
} }
bool SpeakerIsInitialized() const override { bool SpeakerIsInitialized() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return initialized_; return initialized_;
} }
int32_t InitMicrophone() override { int32_t InitMicrophone() override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return initialized_ ? 0 : -1; return initialized_ ? 0 : -1;
} }
bool MicrophoneIsInitialized() const override { bool MicrophoneIsInitialized() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return initialized_; return initialized_;
} }
int32_t SpeakerVolumeIsAvailable(bool* available) override { int32_t SpeakerVolumeIsAvailable(bool* available) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
if (!initialized_) if (!initialized_)
return -1; return -1;
*available = output_->SpeakerVolumeIsAvailable(); *available = output_->SpeakerVolumeIsAvailable();
RTC_DLOG(INFO) << "output: " << *available; RTC_DLOG(LS_INFO) << "output: " << *available;
return 0; return 0;
} }
int32_t SetSpeakerVolume(uint32_t volume) override { int32_t SetSpeakerVolume(uint32_t volume) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
if (!initialized_) if (!initialized_)
return -1; return -1;
return output_->SetSpeakerVolume(volume); return output_->SetSpeakerVolume(volume);
} }
int32_t SpeakerVolume(uint32_t* output_volume) const override { int32_t SpeakerVolume(uint32_t* output_volume) const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
if (!initialized_) if (!initialized_)
return -1; return -1;
absl::optional<uint32_t> volume = output_->SpeakerVolume(); absl::optional<uint32_t> volume = output_->SpeakerVolume();
if (!volume) if (!volume)
return -1; return -1;
*output_volume = *volume; *output_volume = *volume;
RTC_DLOG(INFO) << "output: " << *volume; RTC_DLOG(LS_INFO) << "output: " << *volume;
return 0; return 0;
} }
int32_t MaxSpeakerVolume(uint32_t* output_max_volume) const override { int32_t MaxSpeakerVolume(uint32_t* output_max_volume) const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
if (!initialized_) if (!initialized_)
return -1; return -1;
absl::optional<uint32_t> max_volume = output_->MaxSpeakerVolume(); absl::optional<uint32_t> max_volume = output_->MaxSpeakerVolume();
@ -373,7 +373,7 @@ class AndroidAudioDeviceModule : public AudioDeviceModule {
} }
int32_t MinSpeakerVolume(uint32_t* output_min_volume) const override { int32_t MinSpeakerVolume(uint32_t* output_min_volume) const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
if (!initialized_) if (!initialized_)
return -1; return -1;
absl::optional<uint32_t> min_volume = output_->MinSpeakerVolume(); absl::optional<uint32_t> min_volume = output_->MinSpeakerVolume();
@ -384,71 +384,71 @@ class AndroidAudioDeviceModule : public AudioDeviceModule {
} }
int32_t MicrophoneVolumeIsAvailable(bool* available) override { int32_t MicrophoneVolumeIsAvailable(bool* available) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
*available = false; *available = false;
RTC_DLOG(INFO) << "output: " << *available; RTC_DLOG(LS_INFO) << "output: " << *available;
return -1; return -1;
} }
int32_t SetMicrophoneVolume(uint32_t volume) override { int32_t SetMicrophoneVolume(uint32_t volume) override {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << volume << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << volume << ")";
RTC_CHECK_NOTREACHED(); RTC_CHECK_NOTREACHED();
} }
int32_t MicrophoneVolume(uint32_t* volume) const override { int32_t MicrophoneVolume(uint32_t* volume) const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_CHECK_NOTREACHED(); RTC_CHECK_NOTREACHED();
} }
int32_t MaxMicrophoneVolume(uint32_t* maxVolume) const override { int32_t MaxMicrophoneVolume(uint32_t* maxVolume) const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_CHECK_NOTREACHED(); RTC_CHECK_NOTREACHED();
} }
int32_t MinMicrophoneVolume(uint32_t* minVolume) const override { int32_t MinMicrophoneVolume(uint32_t* minVolume) const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_CHECK_NOTREACHED(); RTC_CHECK_NOTREACHED();
} }
int32_t SpeakerMuteIsAvailable(bool* available) override { int32_t SpeakerMuteIsAvailable(bool* available) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_CHECK_NOTREACHED(); RTC_CHECK_NOTREACHED();
} }
int32_t SetSpeakerMute(bool enable) override { int32_t SetSpeakerMute(bool enable) override {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
RTC_CHECK_NOTREACHED(); RTC_CHECK_NOTREACHED();
} }
int32_t SpeakerMute(bool* enabled) const override { int32_t SpeakerMute(bool* enabled) const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_CHECK_NOTREACHED(); RTC_CHECK_NOTREACHED();
} }
int32_t MicrophoneMuteIsAvailable(bool* available) override { int32_t MicrophoneMuteIsAvailable(bool* available) override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_CHECK_NOTREACHED(); RTC_CHECK_NOTREACHED();
} }
int32_t SetMicrophoneMute(bool enable) override { int32_t SetMicrophoneMute(bool enable) override {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
RTC_CHECK_NOTREACHED(); RTC_CHECK_NOTREACHED();
} }
int32_t MicrophoneMute(bool* enabled) const override { int32_t MicrophoneMute(bool* enabled) const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_CHECK_NOTREACHED(); RTC_CHECK_NOTREACHED();
} }
int32_t StereoPlayoutIsAvailable(bool* available) const override { int32_t StereoPlayoutIsAvailable(bool* available) const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
*available = is_stereo_playout_supported_; *available = is_stereo_playout_supported_;
RTC_DLOG(INFO) << "output: " << *available; RTC_DLOG(LS_INFO) << "output: " << *available;
return 0; return 0;
} }
int32_t SetStereoPlayout(bool enable) override { int32_t SetStereoPlayout(bool enable) override {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
// Android does not support changes between mono and stero on the fly. The // Android does not support changes between mono and stero on the fly. The
// use of stereo or mono is determined by the audio layer. It is allowed // use of stereo or mono is determined by the audio layer. It is allowed
// to call this method if that same state is not modified. // to call this method if that same state is not modified.
@ -461,21 +461,21 @@ class AndroidAudioDeviceModule : public AudioDeviceModule {
} }
int32_t StereoPlayout(bool* enabled) const override { int32_t StereoPlayout(bool* enabled) const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
*enabled = is_stereo_playout_supported_; *enabled = is_stereo_playout_supported_;
RTC_DLOG(INFO) << "output: " << *enabled; RTC_DLOG(LS_INFO) << "output: " << *enabled;
return 0; return 0;
} }
int32_t StereoRecordingIsAvailable(bool* available) const override { int32_t StereoRecordingIsAvailable(bool* available) const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
*available = is_stereo_record_supported_; *available = is_stereo_record_supported_;
RTC_DLOG(INFO) << "output: " << *available; RTC_DLOG(LS_INFO) << "output: " << *available;
return 0; return 0;
} }
int32_t SetStereoRecording(bool enable) override { int32_t SetStereoRecording(bool enable) override {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
// Android does not support changes between mono and stero on the fly. The // Android does not support changes between mono and stero on the fly. The
// use of stereo or mono is determined by the audio layer. It is allowed // use of stereo or mono is determined by the audio layer. It is allowed
// to call this method if that same state is not modified. // to call this method if that same state is not modified.
@ -488,9 +488,9 @@ class AndroidAudioDeviceModule : public AudioDeviceModule {
} }
int32_t StereoRecording(bool* enabled) const override { int32_t StereoRecording(bool* enabled) const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
*enabled = is_stereo_record_supported_; *enabled = is_stereo_record_supported_;
RTC_DLOG(INFO) << "output: " << *enabled; RTC_DLOG(LS_INFO) << "output: " << *enabled;
return 0; return 0;
} }
@ -514,18 +514,18 @@ class AndroidAudioDeviceModule : public AudioDeviceModule {
// a "Not Implemented" log will be filed. This non-perfect state will remain // a "Not Implemented" log will be filed. This non-perfect state will remain
// until I have added full support for audio effects based on OpenSL ES APIs. // until I have added full support for audio effects based on OpenSL ES APIs.
bool BuiltInAECIsAvailable() const override { bool BuiltInAECIsAvailable() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
if (!initialized_) if (!initialized_)
return false; return false;
bool isAvailable = input_->IsAcousticEchoCancelerSupported(); bool isAvailable = input_->IsAcousticEchoCancelerSupported();
RTC_DLOG(INFO) << "output: " << isAvailable; RTC_DLOG(LS_INFO) << "output: " << isAvailable;
return isAvailable; return isAvailable;
} }
// Not implemented for any input device on Android. // Not implemented for any input device on Android.
bool BuiltInAGCIsAvailable() const override { bool BuiltInAGCIsAvailable() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
RTC_DLOG(INFO) << "output: " << false; RTC_DLOG(LS_INFO) << "output: " << false;
return false; return false;
} }
@ -534,38 +534,38 @@ class AndroidAudioDeviceModule : public AudioDeviceModule {
// TODO(henrika): add implementation for OpenSL ES based audio as well. // TODO(henrika): add implementation for OpenSL ES based audio as well.
// In addition, see comments for BuiltInAECIsAvailable(). // In addition, see comments for BuiltInAECIsAvailable().
bool BuiltInNSIsAvailable() const override { bool BuiltInNSIsAvailable() const override {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
if (!initialized_) if (!initialized_)
return false; return false;
bool isAvailable = input_->IsNoiseSuppressorSupported(); bool isAvailable = input_->IsNoiseSuppressorSupported();
RTC_DLOG(INFO) << "output: " << isAvailable; RTC_DLOG(LS_INFO) << "output: " << isAvailable;
return isAvailable; return isAvailable;
} }
// TODO(henrika): add implementation for OpenSL ES based audio as well. // TODO(henrika): add implementation for OpenSL ES based audio as well.
int32_t EnableBuiltInAEC(bool enable) override { int32_t EnableBuiltInAEC(bool enable) override {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
if (!initialized_) if (!initialized_)
return -1; return -1;
RTC_CHECK(BuiltInAECIsAvailable()) << "HW AEC is not available"; RTC_CHECK(BuiltInAECIsAvailable()) << "HW AEC is not available";
int32_t result = input_->EnableBuiltInAEC(enable); int32_t result = input_->EnableBuiltInAEC(enable);
RTC_DLOG(INFO) << "output: " << result; RTC_DLOG(LS_INFO) << "output: " << result;
return result; return result;
} }
int32_t EnableBuiltInAGC(bool enable) override { int32_t EnableBuiltInAGC(bool enable) override {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
RTC_CHECK_NOTREACHED(); RTC_CHECK_NOTREACHED();
} }
// TODO(henrika): add implementation for OpenSL ES based audio as well. // TODO(henrika): add implementation for OpenSL ES based audio as well.
int32_t EnableBuiltInNS(bool enable) override { int32_t EnableBuiltInNS(bool enable) override {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
if (!initialized_) if (!initialized_)
return -1; return -1;
RTC_CHECK(BuiltInNSIsAvailable()) << "HW NS is not available"; RTC_CHECK(BuiltInNSIsAvailable()) << "HW NS is not available";
int32_t result = input_->EnableBuiltInNS(enable); int32_t result = input_->EnableBuiltInNS(enable);
RTC_DLOG(INFO) << "output: " << result; RTC_DLOG(LS_INFO) << "output: " << result;
return result; return result;
} }
@ -576,7 +576,7 @@ class AndroidAudioDeviceModule : public AudioDeviceModule {
} }
int32_t AttachAudioBuffer() { int32_t AttachAudioBuffer() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
output_->AttachAudioBuffer(audio_device_buffer_.get()); output_->AttachAudioBuffer(audio_device_buffer_.get());
input_->AttachAudioBuffer(audio_device_buffer_.get()); input_->AttachAudioBuffer(audio_device_buffer_.get());
return 0; return 0;
@ -640,7 +640,7 @@ rtc::scoped_refptr<AudioDeviceModule> CreateAudioDeviceModuleFromInputAndOutput(
uint16_t playout_delay_ms, uint16_t playout_delay_ms,
std::unique_ptr<AudioInput> audio_input, std::unique_ptr<AudioInput> audio_input,
std::unique_ptr<AudioOutput> audio_output) { std::unique_ptr<AudioOutput> audio_output) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return rtc::make_ref_counted<AndroidAudioDeviceModule>( return rtc::make_ref_counted<AndroidAudioDeviceModule>(
audio_layer, is_stereo_playout_supported, is_stereo_record_supported, audio_layer, is_stereo_playout_supported, is_stereo_record_supported,
playout_delay_ms, std::move(audio_input), std::move(audio_output)); playout_delay_ms, std::move(audio_input), std::move(audio_output));

37
sdk/android/src/jni/audio_device/audio_record_jni.cc
View File

@ -38,7 +38,7 @@ class ScopedHistogramTimer {
~ScopedHistogramTimer() { ~ScopedHistogramTimer() {
const int64_t life_time_ms = rtc::TimeSince(start_time_ms_); const int64_t life_time_ms = rtc::TimeSince(start_time_ms_);
RTC_HISTOGRAM_COUNTS_1000(histogram_name_, life_time_ms); RTC_HISTOGRAM_COUNTS_1000(histogram_name_, life_time_ms);
RTC_LOG(INFO) << histogram_name_ << ": " << life_time_ms; RTC_LOG(LS_INFO) << histogram_name_ << ": " << life_time_ms;
} }
private: private:
@ -68,7 +68,7 @@ AudioRecordJni::AudioRecordJni(JNIEnv* env,
initialized_(false), initialized_(false),
recording_(false), recording_(false),
audio_device_buffer_(nullptr) { audio_device_buffer_(nullptr) {
RTC_LOG(INFO) << "ctor"; RTC_LOG(LS_INFO) << "ctor";
RTC_DCHECK(audio_parameters_.is_valid()); RTC_DCHECK(audio_parameters_.is_valid());
Java_WebRtcAudioRecord_setNativeAudioRecord(env, j_audio_record_, Java_WebRtcAudioRecord_setNativeAudioRecord(env, j_audio_record_,
jni::jlongFromPointer(this)); jni::jlongFromPointer(this));
@ -79,20 +79,20 @@ AudioRecordJni::AudioRecordJni(JNIEnv* env,
} }
AudioRecordJni::~AudioRecordJni() { AudioRecordJni::~AudioRecordJni() {
RTC_LOG(INFO) << "dtor"; RTC_LOG(LS_INFO) << "dtor";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
Terminate(); Terminate();
} }
int32_t AudioRecordJni::Init() { int32_t AudioRecordJni::Init() {
RTC_LOG(INFO) << "Init"; RTC_LOG(LS_INFO) << "Init";
env_ = AttachCurrentThreadIfNeeded(); env_ = AttachCurrentThreadIfNeeded();
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
return 0; return 0;
} }
int32_t AudioRecordJni::Terminate() { int32_t AudioRecordJni::Terminate() {
RTC_LOG(INFO) << "Terminate"; RTC_LOG(LS_INFO) << "Terminate";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
StopRecording(); StopRecording();
thread_checker_.Detach(); thread_checker_.Detach();
@ -100,7 +100,7 @@ int32_t AudioRecordJni::Terminate() {
} }
int32_t AudioRecordJni::InitRecording() { int32_t AudioRecordJni::InitRecording() {
RTC_LOG(INFO) << "InitRecording"; RTC_LOG(LS_INFO) << "InitRecording";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
if (initialized_) { if (initialized_) {
// Already initialized. // Already initialized.
@ -118,7 +118,7 @@ int32_t AudioRecordJni::InitRecording() {
return -1; return -1;
} }
frames_per_buffer_ = static_cast<size_t>(frames_per_buffer); frames_per_buffer_ = static_cast<size_t>(frames_per_buffer);
RTC_LOG(INFO) << "frames_per_buffer: " << frames_per_buffer_; RTC_LOG(LS_INFO) << "frames_per_buffer: " << frames_per_buffer_;
const size_t bytes_per_frame = audio_parameters_.channels() * sizeof(int16_t); const size_t bytes_per_frame = audio_parameters_.channels() * sizeof(int16_t);
RTC_CHECK_EQ(direct_buffer_capacity_in_bytes_, RTC_CHECK_EQ(direct_buffer_capacity_in_bytes_,
frames_per_buffer_ * bytes_per_frame); frames_per_buffer_ * bytes_per_frame);
@ -132,7 +132,7 @@ bool AudioRecordJni::RecordingIsInitialized() const {
} }
int32_t AudioRecordJni::StartRecording() { int32_t AudioRecordJni::StartRecording() {
RTC_LOG(INFO) << "StartRecording"; RTC_LOG(LS_INFO) << "StartRecording";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
if (recording_) { if (recording_) {
// Already recording. // Already recording.
@ -153,7 +153,7 @@ int32_t AudioRecordJni::StartRecording() {
} }
int32_t AudioRecordJni::StopRecording() { int32_t AudioRecordJni::StopRecording() {
RTC_LOG(INFO) << "StopRecording"; RTC_LOG(LS_INFO) << "StopRecording";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
if (!initialized_ || !recording_) { if (!initialized_ || !recording_) {
return 0; return 0;
@ -166,7 +166,8 @@ int32_t AudioRecordJni::StopRecording() {
env_, j_audio_record_); env_, j_audio_record_);
RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.SourceMatchesRecordingSession", RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.SourceMatchesRecordingSession",
session_was_ok); session_was_ok);
RTC_LOG(INFO) << "HISTOGRAM(WebRTC.Audio.SourceMatchesRecordingSession): " RTC_LOG(LS_INFO)
<< "HISTOGRAM(WebRTC.Audio.SourceMatchesRecordingSession): "
<< session_was_ok; << session_was_ok;
} }
if (!Java_WebRtcAudioRecord_stopRecording(env_, j_audio_record_)) { if (!Java_WebRtcAudioRecord_stopRecording(env_, j_audio_record_)) {
@ -188,14 +189,14 @@ bool AudioRecordJni::Recording() const {
} }
void AudioRecordJni::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) { void AudioRecordJni::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
RTC_LOG(INFO) << "AttachAudioBuffer"; RTC_LOG(LS_INFO) << "AttachAudioBuffer";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
audio_device_buffer_ = audioBuffer; audio_device_buffer_ = audioBuffer;
const int sample_rate_hz = audio_parameters_.sample_rate(); const int sample_rate_hz = audio_parameters_.sample_rate();
RTC_LOG(INFO) << "SetRecordingSampleRate(" << sample_rate_hz << ")"; RTC_LOG(LS_INFO) << "SetRecordingSampleRate(" << sample_rate_hz << ")";
audio_device_buffer_->SetRecordingSampleRate(sample_rate_hz); audio_device_buffer_->SetRecordingSampleRate(sample_rate_hz);
const size_t channels = audio_parameters_.channels(); const size_t channels = audio_parameters_.channels();
RTC_LOG(INFO) << "SetRecordingChannels(" << channels << ")"; RTC_LOG(LS_INFO) << "SetRecordingChannels(" << channels << ")";
audio_device_buffer_->SetRecordingChannels(channels); audio_device_buffer_->SetRecordingChannels(channels);
} }
@ -212,7 +213,7 @@ bool AudioRecordJni::IsNoiseSuppressorSupported() const {
} }
int32_t AudioRecordJni::EnableBuiltInAEC(bool enable) { int32_t AudioRecordJni::EnableBuiltInAEC(bool enable) {
RTC_LOG(INFO) << "EnableBuiltInAEC(" << enable << ")"; RTC_LOG(LS_INFO) << "EnableBuiltInAEC(" << enable << ")";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
return Java_WebRtcAudioRecord_enableBuiltInAEC(env_, j_audio_record_, enable) return Java_WebRtcAudioRecord_enableBuiltInAEC(env_, j_audio_record_, enable)
? 0 ? 0
@ -220,7 +221,7 @@ int32_t AudioRecordJni::EnableBuiltInAEC(bool enable) {
} }
int32_t AudioRecordJni::EnableBuiltInNS(bool enable) { int32_t AudioRecordJni::EnableBuiltInNS(bool enable) {
RTC_LOG(INFO) << "EnableBuiltInNS(" << enable << ")"; RTC_LOG(LS_INFO) << "EnableBuiltInNS(" << enable << ")";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
return Java_WebRtcAudioRecord_enableBuiltInNS(env_, j_audio_record_, enable) return Java_WebRtcAudioRecord_enableBuiltInNS(env_, j_audio_record_, enable)
? 0 ? 0
@ -231,12 +232,12 @@ void AudioRecordJni::CacheDirectBufferAddress(
JNIEnv* env, JNIEnv* env,
const JavaParamRef<jobject>& j_caller, const JavaParamRef<jobject>& j_caller,
const JavaParamRef<jobject>& byte_buffer) { const JavaParamRef<jobject>& byte_buffer) {
RTC_LOG(INFO) << "OnCacheDirectBufferAddress"; RTC_LOG(LS_INFO) << "OnCacheDirectBufferAddress";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!direct_buffer_address_); RTC_DCHECK(!direct_buffer_address_);
direct_buffer_address_ = env->GetDirectBufferAddress(byte_buffer.obj()); direct_buffer_address_ = env->GetDirectBufferAddress(byte_buffer.obj());
jlong capacity = env->GetDirectBufferCapacity(byte_buffer.obj()); jlong capacity = env->GetDirectBufferCapacity(byte_buffer.obj());
RTC_LOG(INFO) << "direct buffer capacity: " << capacity; RTC_LOG(LS_INFO) << "direct buffer capacity: " << capacity;
direct_buffer_capacity_in_bytes_ = static_cast<size_t>(capacity); direct_buffer_capacity_in_bytes_ = static_cast<size_t>(capacity);
} }
@ -257,7 +258,7 @@ void AudioRecordJni::DataIsRecorded(JNIEnv* env,
// of `playDelayMs` and `recDelayMs`, hence the distributions does not matter. // of `playDelayMs` and `recDelayMs`, hence the distributions does not matter.
audio_device_buffer_->SetVQEData(total_delay_ms_, 0); audio_device_buffer_->SetVQEData(total_delay_ms_, 0);
if (audio_device_buffer_->DeliverRecordedData() == -1) { if (audio_device_buffer_->DeliverRecordedData() == -1) {
RTC_LOG(INFO) << "AudioDeviceBuffer::DeliverRecordedData failed"; RTC_LOG(LS_INFO) << "AudioDeviceBuffer::DeliverRecordedData failed";
} }
} }

30
sdk/android/src/jni/audio_device/audio_track_jni.cc
View File

@ -44,7 +44,7 @@ AudioTrackJni::AudioTrackJni(JNIEnv* env,
initialized_(false), initialized_(false),
playing_(false), playing_(false),
audio_device_buffer_(nullptr) { audio_device_buffer_(nullptr) {
RTC_LOG(INFO) << "ctor"; RTC_LOG(LS_INFO) << "ctor";
RTC_DCHECK(audio_parameters_.is_valid()); RTC_DCHECK(audio_parameters_.is_valid());
Java_WebRtcAudioTrack_setNativeAudioTrack(env, j_audio_track_, Java_WebRtcAudioTrack_setNativeAudioTrack(env, j_audio_track_,
jni::jlongFromPointer(this)); jni::jlongFromPointer(this));
@ -55,20 +55,20 @@ AudioTrackJni::AudioTrackJni(JNIEnv* env,
} }
AudioTrackJni::~AudioTrackJni() { AudioTrackJni::~AudioTrackJni() {
RTC_LOG(INFO) << "dtor"; RTC_LOG(LS_INFO) << "dtor";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
Terminate(); Terminate();
} }
int32_t AudioTrackJni::Init() { int32_t AudioTrackJni::Init() {
RTC_LOG(INFO) << "Init"; RTC_LOG(LS_INFO) << "Init";
env_ = AttachCurrentThreadIfNeeded(); env_ = AttachCurrentThreadIfNeeded();
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
return 0; return 0;
} }
int32_t AudioTrackJni::Terminate() { int32_t AudioTrackJni::Terminate() {
RTC_LOG(INFO) << "Terminate"; RTC_LOG(LS_INFO) << "Terminate";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
StopPlayout(); StopPlayout();
thread_checker_.Detach(); thread_checker_.Detach();
@ -76,7 +76,7 @@ int32_t AudioTrackJni::Terminate() {
} }
int32_t AudioTrackJni::InitPlayout() { int32_t AudioTrackJni::InitPlayout() {
RTC_LOG(INFO) << "InitPlayout"; RTC_LOG(LS_INFO) << "InitPlayout";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
if (initialized_) { if (initialized_) {
// Already initialized. // Already initialized.
@ -126,7 +126,7 @@ bool AudioTrackJni::PlayoutIsInitialized() const {
} }
int32_t AudioTrackJni::StartPlayout() { int32_t AudioTrackJni::StartPlayout() {
RTC_LOG(INFO) << "StartPlayout"; RTC_LOG(LS_INFO) << "StartPlayout";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
if (playing_) { if (playing_) {
// Already playing. // Already playing.
@ -146,7 +146,7 @@ int32_t AudioTrackJni::StartPlayout() {
} }
int32_t AudioTrackJni::StopPlayout() { int32_t AudioTrackJni::StopPlayout() {
RTC_LOG(INFO) << "StopPlayout"; RTC_LOG(LS_INFO) << "StopPlayout";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
if (!initialized_ || !playing_) { if (!initialized_ || !playing_) {
return 0; return 0;
@ -185,7 +185,7 @@ bool AudioTrackJni::SpeakerVolumeIsAvailable() {
} }
int AudioTrackJni::SetSpeakerVolume(uint32_t volume) { int AudioTrackJni::SetSpeakerVolume(uint32_t volume) {
RTC_LOG(INFO) << "SetSpeakerVolume(" << volume << ")"; RTC_LOG(LS_INFO) << "SetSpeakerVolume(" << volume << ")";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
return Java_WebRtcAudioTrack_setStreamVolume(env_, j_audio_track_, return Java_WebRtcAudioTrack_setStreamVolume(env_, j_audio_track_,
static_cast<int>(volume)) static_cast<int>(volume))
@ -207,7 +207,7 @@ absl::optional<uint32_t> AudioTrackJni::SpeakerVolume() const {
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
const uint32_t volume = const uint32_t volume =
Java_WebRtcAudioTrack_getStreamVolume(env_, j_audio_track_); Java_WebRtcAudioTrack_getStreamVolume(env_, j_audio_track_);
RTC_LOG(INFO) << "SpeakerVolume: " << volume; RTC_LOG(LS_INFO) << "SpeakerVolume: " << volume;
return volume; return volume;
} }
@ -217,30 +217,30 @@ int AudioTrackJni::GetPlayoutUnderrunCount() {
// TODO(henrika): possibly add stereo support. // TODO(henrika): possibly add stereo support.
void AudioTrackJni::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) { void AudioTrackJni::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
RTC_LOG(INFO) << "AttachAudioBuffer"; RTC_LOG(LS_INFO) << "AttachAudioBuffer";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
audio_device_buffer_ = audioBuffer; audio_device_buffer_ = audioBuffer;
const int sample_rate_hz = audio_parameters_.sample_rate(); const int sample_rate_hz = audio_parameters_.sample_rate();
RTC_LOG(INFO) << "SetPlayoutSampleRate(" << sample_rate_hz << ")"; RTC_LOG(LS_INFO) << "SetPlayoutSampleRate(" << sample_rate_hz << ")";
audio_device_buffer_->SetPlayoutSampleRate(sample_rate_hz); audio_device_buffer_->SetPlayoutSampleRate(sample_rate_hz);
const size_t channels = audio_parameters_.channels(); const size_t channels = audio_parameters_.channels();
RTC_LOG(INFO) << "SetPlayoutChannels(" << channels << ")"; RTC_LOG(LS_INFO) << "SetPlayoutChannels(" << channels << ")";
audio_device_buffer_->SetPlayoutChannels(channels); audio_device_buffer_->SetPlayoutChannels(channels);
} }
void AudioTrackJni::CacheDirectBufferAddress( void AudioTrackJni::CacheDirectBufferAddress(
JNIEnv* env, JNIEnv* env,
const JavaParamRef<jobject>& byte_buffer) { const JavaParamRef<jobject>& byte_buffer) {
RTC_LOG(INFO) << "OnCacheDirectBufferAddress"; RTC_LOG(LS_INFO) << "OnCacheDirectBufferAddress";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
RTC_DCHECK(!direct_buffer_address_); RTC_DCHECK(!direct_buffer_address_);
direct_buffer_address_ = env->GetDirectBufferAddress(byte_buffer.obj()); direct_buffer_address_ = env->GetDirectBufferAddress(byte_buffer.obj());
jlong capacity = env->GetDirectBufferCapacity(byte_buffer.obj()); jlong capacity = env->GetDirectBufferCapacity(byte_buffer.obj());
RTC_LOG(INFO) << "direct buffer capacity: " << capacity; RTC_LOG(LS_INFO) << "direct buffer capacity: " << capacity;
direct_buffer_capacity_in_bytes_ = static_cast<size_t>(capacity); direct_buffer_capacity_in_bytes_ = static_cast<size_t>(capacity);
const size_t bytes_per_frame = audio_parameters_.channels() * sizeof(int16_t); const size_t bytes_per_frame = audio_parameters_.channels() * sizeof(int16_t);
frames_per_buffer_ = direct_buffer_capacity_in_bytes_ / bytes_per_frame; frames_per_buffer_ = direct_buffer_capacity_in_bytes_ / bytes_per_frame;
RTC_LOG(INFO) << "frames_per_buffer: " << frames_per_buffer_; RTC_LOG(LS_INFO) << "frames_per_buffer: " << frames_per_buffer_;
} }
// This method is called on a high-priority thread from Java. The name of // This method is called on a high-priority thread from Java. The name of

2
sdk/android/src/jni/audio_device/opensles_common.cc
View File

@ -107,7 +107,7 @@ OpenSLEngineManager::OpenSLEngineManager() {
} }
SLObjectItf OpenSLEngineManager::GetOpenSLEngine() { SLObjectItf OpenSLEngineManager::GetOpenSLEngine() {
RTC_LOG(INFO) << "GetOpenSLEngine"; RTC_LOG(LS_INFO) << "GetOpenSLEngine";
RTC_DCHECK(thread_checker_.IsCurrent()); RTC_DCHECK(thread_checker_.IsCurrent());
// OpenSL ES for Android only supports a single engine per application. // OpenSL ES for Android only supports a single engine per application.
// If one already has been created, return existing object instead of // If one already has been created, return existing object instead of

5
sdk/objc/native/api/audio_device_module.mm
View File

@ -18,12 +18,11 @@
namespace webrtc { namespace webrtc {
rtc::scoped_refptr<AudioDeviceModule> CreateAudioDeviceModule(bool bypass_voice_processing) { rtc::scoped_refptr<AudioDeviceModule> CreateAudioDeviceModule(bool bypass_voice_processing) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
#if defined(WEBRTC_IOS) #if defined(WEBRTC_IOS)
return new rtc::RefCountedObject<ios_adm::AudioDeviceModuleIOS>(bypass_voice_processing); return new rtc::RefCountedObject<ios_adm::AudioDeviceModuleIOS>(bypass_voice_processing);
#else #else
RTC_LOG(LERROR) RTC_LOG(LS_ERROR) << "current platform is not supported => this module will self destruct!";
<< "current platform is not supported => this module will self destruct!";
return nullptr; return nullptr;
#endif #endif
} }

190
sdk/objc/native/src/audio/audio_device_module_ios.mm
View File

@ -43,22 +43,22 @@ namespace ios_adm {
AudioDeviceModuleIOS::AudioDeviceModuleIOS(bool bypass_voice_processing) AudioDeviceModuleIOS::AudioDeviceModuleIOS(bool bypass_voice_processing)
: bypass_voice_processing_(bypass_voice_processing), : bypass_voice_processing_(bypass_voice_processing),
task_queue_factory_(CreateDefaultTaskQueueFactory()) { task_queue_factory_(CreateDefaultTaskQueueFactory()) {
RTC_LOG(INFO) << "current platform is IOS"; RTC_LOG(LS_INFO) << "current platform is IOS";
RTC_LOG(INFO) << "iPhone Audio APIs will be utilized."; RTC_LOG(LS_INFO) << "iPhone Audio APIs will be utilized.";
} }
int32_t AudioDeviceModuleIOS::AttachAudioBuffer() { int32_t AudioDeviceModuleIOS::AttachAudioBuffer() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
audio_device_->AttachAudioBuffer(audio_device_buffer_.get()); audio_device_->AttachAudioBuffer(audio_device_buffer_.get());
return 0; return 0;
} }
AudioDeviceModuleIOS::~AudioDeviceModuleIOS() { AudioDeviceModuleIOS::~AudioDeviceModuleIOS() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
} }
int32_t AudioDeviceModuleIOS::ActiveAudioLayer(AudioLayer* audioLayer) const { int32_t AudioDeviceModuleIOS::ActiveAudioLayer(AudioLayer* audioLayer) const {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
AudioLayer activeAudio; AudioLayer activeAudio;
if (audio_device_->ActiveAudioLayer(activeAudio) == -1) { if (audio_device_->ActiveAudioLayer(activeAudio) == -1) {
return -1; return -1;
@ -68,7 +68,7 @@ AudioDeviceModuleIOS::AudioDeviceModuleIOS(bool bypass_voice_processing)
} }
int32_t AudioDeviceModuleIOS::Init() { int32_t AudioDeviceModuleIOS::Init() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
if (initialized_) if (initialized_)
return 0; return 0;
@ -91,7 +91,7 @@ AudioDeviceModuleIOS::AudioDeviceModuleIOS(bool bypass_voice_processing)
} }
int32_t AudioDeviceModuleIOS::Terminate() { int32_t AudioDeviceModuleIOS::Terminate() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
if (!initialized_) if (!initialized_)
return 0; return 0;
if (audio_device_->Terminate() == -1) { if (audio_device_->Terminate() == -1) {
@ -102,65 +102,65 @@ AudioDeviceModuleIOS::AudioDeviceModuleIOS(bool bypass_voice_processing)
} }
bool AudioDeviceModuleIOS::Initialized() const { bool AudioDeviceModuleIOS::Initialized() const {
RTC_DLOG(INFO) << __FUNCTION__ << ": " << initialized_; RTC_DLOG(LS_INFO) << __FUNCTION__ << ": " << initialized_;
return initialized_; return initialized_;
} }
int32_t AudioDeviceModuleIOS::InitSpeaker() { int32_t AudioDeviceModuleIOS::InitSpeaker() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
return audio_device_->InitSpeaker(); return audio_device_->InitSpeaker();
} }
int32_t AudioDeviceModuleIOS::InitMicrophone() { int32_t AudioDeviceModuleIOS::InitMicrophone() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
return audio_device_->InitMicrophone(); return audio_device_->InitMicrophone();
} }
int32_t AudioDeviceModuleIOS::SpeakerVolumeIsAvailable(bool* available) { int32_t AudioDeviceModuleIOS::SpeakerVolumeIsAvailable(bool* available) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool isAvailable = false; bool isAvailable = false;
if (audio_device_->SpeakerVolumeIsAvailable(isAvailable) == -1) { if (audio_device_->SpeakerVolumeIsAvailable(isAvailable) == -1) {
return -1; return -1;
} }
*available = isAvailable; *available = isAvailable;
RTC_DLOG(INFO) << "output: " << isAvailable; RTC_DLOG(LS_INFO) << "output: " << isAvailable;
return 0; return 0;
} }
int32_t AudioDeviceModuleIOS::SetSpeakerVolume(uint32_t volume) { int32_t AudioDeviceModuleIOS::SetSpeakerVolume(uint32_t volume) {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << volume << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << volume << ")";
CHECKinitialized_(); CHECKinitialized_();
return audio_device_->SetSpeakerVolume(volume); return audio_device_->SetSpeakerVolume(volume);
} }
int32_t AudioDeviceModuleIOS::SpeakerVolume(uint32_t* volume) const { int32_t AudioDeviceModuleIOS::SpeakerVolume(uint32_t* volume) const {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
uint32_t level = 0; uint32_t level = 0;
if (audio_device_->SpeakerVolume(level) == -1) { if (audio_device_->SpeakerVolume(level) == -1) {
return -1; return -1;
} }
*volume = level; *volume = level;
RTC_DLOG(INFO) << "output: " << *volume; RTC_DLOG(LS_INFO) << "output: " << *volume;
return 0; return 0;
} }
bool AudioDeviceModuleIOS::SpeakerIsInitialized() const { bool AudioDeviceModuleIOS::SpeakerIsInitialized() const {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized__BOOL(); CHECKinitialized__BOOL();
bool isInitialized = audio_device_->SpeakerIsInitialized(); bool isInitialized = audio_device_->SpeakerIsInitialized();
RTC_DLOG(INFO) << "output: " << isInitialized; RTC_DLOG(LS_INFO) << "output: " << isInitialized;
return isInitialized; return isInitialized;
} }
bool AudioDeviceModuleIOS::MicrophoneIsInitialized() const { bool AudioDeviceModuleIOS::MicrophoneIsInitialized() const {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized__BOOL(); CHECKinitialized__BOOL();
bool isInitialized = audio_device_->MicrophoneIsInitialized(); bool isInitialized = audio_device_->MicrophoneIsInitialized();
RTC_DLOG(INFO) << "output: " << isInitialized; RTC_DLOG(LS_INFO) << "output: " << isInitialized;
return isInitialized; return isInitialized;
} }
@ -185,110 +185,110 @@ AudioDeviceModuleIOS::AudioDeviceModuleIOS(bool bypass_voice_processing)
} }
int32_t AudioDeviceModuleIOS::SpeakerMuteIsAvailable(bool* available) { int32_t AudioDeviceModuleIOS::SpeakerMuteIsAvailable(bool* available) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool isAvailable = false; bool isAvailable = false;
if (audio_device_->SpeakerMuteIsAvailable(isAvailable) == -1) { if (audio_device_->SpeakerMuteIsAvailable(isAvailable) == -1) {
return -1; return -1;
} }
*available = isAvailable; *available = isAvailable;
RTC_DLOG(INFO) << "output: " << isAvailable; RTC_DLOG(LS_INFO) << "output: " << isAvailable;
return 0; return 0;
} }
int32_t AudioDeviceModuleIOS::SetSpeakerMute(bool enable) { int32_t AudioDeviceModuleIOS::SetSpeakerMute(bool enable) {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
CHECKinitialized_(); CHECKinitialized_();
return audio_device_->SetSpeakerMute(enable); return audio_device_->SetSpeakerMute(enable);
} }
int32_t AudioDeviceModuleIOS::SpeakerMute(bool* enabled) const { int32_t AudioDeviceModuleIOS::SpeakerMute(bool* enabled) const {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool muted = false; bool muted = false;
if (audio_device_->SpeakerMute(muted) == -1) { if (audio_device_->SpeakerMute(muted) == -1) {
return -1; return -1;
} }
*enabled = muted; *enabled = muted;
RTC_DLOG(INFO) << "output: " << muted; RTC_DLOG(LS_INFO) << "output: " << muted;
return 0; return 0;
} }
int32_t AudioDeviceModuleIOS::MicrophoneMuteIsAvailable(bool* available) { int32_t AudioDeviceModuleIOS::MicrophoneMuteIsAvailable(bool* available) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool isAvailable = false; bool isAvailable = false;
if (audio_device_->MicrophoneMuteIsAvailable(isAvailable) == -1) { if (audio_device_->MicrophoneMuteIsAvailable(isAvailable) == -1) {
return -1; return -1;
} }
*available = isAvailable; *available = isAvailable;
RTC_DLOG(INFO) << "output: " << isAvailable; RTC_DLOG(LS_INFO) << "output: " << isAvailable;
return 0; return 0;
} }
int32_t AudioDeviceModuleIOS::SetMicrophoneMute(bool enable) { int32_t AudioDeviceModuleIOS::SetMicrophoneMute(bool enable) {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
CHECKinitialized_(); CHECKinitialized_();
return (audio_device_->SetMicrophoneMute(enable)); return (audio_device_->SetMicrophoneMute(enable));
} }
int32_t AudioDeviceModuleIOS::MicrophoneMute(bool* enabled) const { int32_t AudioDeviceModuleIOS::MicrophoneMute(bool* enabled) const {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool muted = false; bool muted = false;
if (audio_device_->MicrophoneMute(muted) == -1) { if (audio_device_->MicrophoneMute(muted) == -1) {
return -1; return -1;
} }
*enabled = muted; *enabled = muted;
RTC_DLOG(INFO) << "output: " << muted; RTC_DLOG(LS_INFO) << "output: " << muted;
return 0; return 0;
} }
int32_t AudioDeviceModuleIOS::MicrophoneVolumeIsAvailable(bool* available) { int32_t AudioDeviceModuleIOS::MicrophoneVolumeIsAvailable(bool* available) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool isAvailable = false; bool isAvailable = false;
if (audio_device_->MicrophoneVolumeIsAvailable(isAvailable) == -1) { if (audio_device_->MicrophoneVolumeIsAvailable(isAvailable) == -1) {
return -1; return -1;
} }
*available = isAvailable; *available = isAvailable;
RTC_DLOG(INFO) << "output: " << isAvailable; RTC_DLOG(LS_INFO) << "output: " << isAvailable;
return 0; return 0;
} }
int32_t AudioDeviceModuleIOS::SetMicrophoneVolume(uint32_t volume) { int32_t AudioDeviceModuleIOS::SetMicrophoneVolume(uint32_t volume) {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << volume << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << volume << ")";
CHECKinitialized_(); CHECKinitialized_();
return (audio_device_->SetMicrophoneVolume(volume)); return (audio_device_->SetMicrophoneVolume(volume));
} }
int32_t AudioDeviceModuleIOS::MicrophoneVolume(uint32_t* volume) const { int32_t AudioDeviceModuleIOS::MicrophoneVolume(uint32_t* volume) const {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
uint32_t level = 0; uint32_t level = 0;
if (audio_device_->MicrophoneVolume(level) == -1) { if (audio_device_->MicrophoneVolume(level) == -1) {
return -1; return -1;
} }
*volume = level; *volume = level;
RTC_DLOG(INFO) << "output: " << *volume; RTC_DLOG(LS_INFO) << "output: " << *volume;
return 0; return 0;
} }
int32_t AudioDeviceModuleIOS::StereoRecordingIsAvailable( int32_t AudioDeviceModuleIOS::StereoRecordingIsAvailable(
bool* available) const { bool* available) const {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool isAvailable = false; bool isAvailable = false;
if (audio_device_->StereoRecordingIsAvailable(isAvailable) == -1) { if (audio_device_->StereoRecordingIsAvailable(isAvailable) == -1) {
return -1; return -1;
} }
*available = isAvailable; *available = isAvailable;
RTC_DLOG(INFO) << "output: " << isAvailable; RTC_DLOG(LS_INFO) << "output: " << isAvailable;
return 0; return 0;
} }
int32_t AudioDeviceModuleIOS::SetStereoRecording(bool enable) { int32_t AudioDeviceModuleIOS::SetStereoRecording(bool enable) {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
CHECKinitialized_(); CHECKinitialized_();
if (enable) { if (enable) {
RTC_LOG(WARNING) << "recording in stereo is not supported"; RTC_LOG(WARNING) << "recording in stereo is not supported";
@ -297,31 +297,31 @@ AudioDeviceModuleIOS::AudioDeviceModuleIOS(bool bypass_voice_processing)
} }
int32_t AudioDeviceModuleIOS::StereoRecording(bool* enabled) const { int32_t AudioDeviceModuleIOS::StereoRecording(bool* enabled) const {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool stereo = false; bool stereo = false;
if (audio_device_->StereoRecording(stereo) == -1) { if (audio_device_->StereoRecording(stereo) == -1) {
return -1; return -1;
} }
*enabled = stereo; *enabled = stereo;
RTC_DLOG(INFO) << "output: " << stereo; RTC_DLOG(LS_INFO) << "output: " << stereo;
return 0; return 0;
} }
int32_t AudioDeviceModuleIOS::StereoPlayoutIsAvailable(bool* available) const { int32_t AudioDeviceModuleIOS::StereoPlayoutIsAvailable(bool* available) const {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool isAvailable = false; bool isAvailable = false;
if (audio_device_->StereoPlayoutIsAvailable(isAvailable) == -1) { if (audio_device_->StereoPlayoutIsAvailable(isAvailable) == -1) {
return -1; return -1;
} }
*available = isAvailable; *available = isAvailable;
RTC_DLOG(INFO) << "output: " << isAvailable; RTC_DLOG(LS_INFO) << "output: " << isAvailable;
return 0; return 0;
} }
int32_t AudioDeviceModuleIOS::SetStereoPlayout(bool enable) { int32_t AudioDeviceModuleIOS::SetStereoPlayout(bool enable) {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
CHECKinitialized_(); CHECKinitialized_();
if (audio_device_->PlayoutIsInitialized()) { if (audio_device_->PlayoutIsInitialized()) {
RTC_LOG(LERROR) RTC_LOG(LERROR)
@ -341,38 +341,38 @@ AudioDeviceModuleIOS::AudioDeviceModuleIOS(bool bypass_voice_processing)
} }
int32_t AudioDeviceModuleIOS::StereoPlayout(bool* enabled) const { int32_t AudioDeviceModuleIOS::StereoPlayout(bool* enabled) const {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool stereo = false; bool stereo = false;
if (audio_device_->StereoPlayout(stereo) == -1) { if (audio_device_->StereoPlayout(stereo) == -1) {
return -1; return -1;
} }
*enabled = stereo; *enabled = stereo;
RTC_DLOG(INFO) << "output: " << stereo; RTC_DLOG(LS_INFO) << "output: " << stereo;
return 0; return 0;
} }
int32_t AudioDeviceModuleIOS::PlayoutIsAvailable(bool* available) { int32_t AudioDeviceModuleIOS::PlayoutIsAvailable(bool* available) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool isAvailable = false; bool isAvailable = false;
if (audio_device_->PlayoutIsAvailable(isAvailable) == -1) { if (audio_device_->PlayoutIsAvailable(isAvailable) == -1) {
return -1; return -1;
} }
*available = isAvailable; *available = isAvailable;
RTC_DLOG(INFO) << "output: " << isAvailable; RTC_DLOG(LS_INFO) << "output: " << isAvailable;
return 0; return 0;
} }
int32_t AudioDeviceModuleIOS::RecordingIsAvailable(bool* available) { int32_t AudioDeviceModuleIOS::RecordingIsAvailable(bool* available) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
bool isAvailable = false; bool isAvailable = false;
if (audio_device_->RecordingIsAvailable(isAvailable) == -1) { if (audio_device_->RecordingIsAvailable(isAvailable) == -1) {
return -1; return -1;
} }
*available = isAvailable; *available = isAvailable;
RTC_DLOG(INFO) << "output: " << isAvailable; RTC_DLOG(LS_INFO) << "output: " << isAvailable;
return 0; return 0;
} }
@ -397,21 +397,21 @@ AudioDeviceModuleIOS::AudioDeviceModuleIOS(bool bypass_voice_processing)
} }
int16_t AudioDeviceModuleIOS::PlayoutDevices() { int16_t AudioDeviceModuleIOS::PlayoutDevices() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
uint16_t nPlayoutDevices = audio_device_->PlayoutDevices(); uint16_t nPlayoutDevices = audio_device_->PlayoutDevices();
RTC_DLOG(INFO) << "output: " << nPlayoutDevices; RTC_DLOG(LS_INFO) << "output: " << nPlayoutDevices;
return (int16_t)(nPlayoutDevices); return (int16_t)(nPlayoutDevices);
} }
int32_t AudioDeviceModuleIOS::SetPlayoutDevice(uint16_t index) { int32_t AudioDeviceModuleIOS::SetPlayoutDevice(uint16_t index) {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << index << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << index << ")";
CHECKinitialized_(); CHECKinitialized_();
return audio_device_->SetPlayoutDevice(index); return audio_device_->SetPlayoutDevice(index);
} }
int32_t AudioDeviceModuleIOS::SetPlayoutDevice(WindowsDeviceType device) { int32_t AudioDeviceModuleIOS::SetPlayoutDevice(WindowsDeviceType device) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
return audio_device_->SetPlayoutDevice(device); return audio_device_->SetPlayoutDevice(device);
} }
@ -420,7 +420,7 @@ AudioDeviceModuleIOS::AudioDeviceModuleIOS(bool bypass_voice_processing)
uint16_t index, uint16_t index,
char name[kAdmMaxDeviceNameSize], char name[kAdmMaxDeviceNameSize],
char guid[kAdmMaxGuidSize]) { char guid[kAdmMaxGuidSize]) {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << index << ", ...)"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << index << ", ...)";
CHECKinitialized_(); CHECKinitialized_();
if (name == NULL) { if (name == NULL) {
return -1; return -1;
@ -429,10 +429,10 @@ AudioDeviceModuleIOS::AudioDeviceModuleIOS(bool bypass_voice_processing)
return -1; return -1;
} }
if (name != NULL) { if (name != NULL) {
RTC_DLOG(INFO) << "output: name = " << name; RTC_DLOG(LS_INFO) << "output: name = " << name;
} }
if (guid != NULL) { if (guid != NULL) {
RTC_DLOG(INFO) << "output: guid = " << guid; RTC_DLOG(LS_INFO) << "output: guid = " << guid;
} }
return 0; return 0;
} }
@ -441,7 +441,7 @@ AudioDeviceModuleIOS::AudioDeviceModuleIOS(bool bypass_voice_processing)
uint16_t index, uint16_t index,
char name[kAdmMaxDeviceNameSize], char name[kAdmMaxDeviceNameSize],
char guid[kAdmMaxGuidSize]) { char guid[kAdmMaxGuidSize]) {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << index << ", ...)"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << index << ", ...)";
CHECKinitialized_(); CHECKinitialized_();
if (name == NULL) { if (name == NULL) {
return -1; return -1;
@ -450,137 +450,137 @@ AudioDeviceModuleIOS::AudioDeviceModuleIOS(bool bypass_voice_processing)
return -1; return -1;
} }
if (name != NULL) { if (name != NULL) {
RTC_DLOG(INFO) << "output: name = " << name; RTC_DLOG(LS_INFO) << "output: name = " << name;
} }
if (guid != NULL) { if (guid != NULL) {
RTC_DLOG(INFO) << "output: guid = " << guid; RTC_DLOG(LS_INFO) << "output: guid = " << guid;
} }
return 0; return 0;
} }
int16_t AudioDeviceModuleIOS::RecordingDevices() { int16_t AudioDeviceModuleIOS::RecordingDevices() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
uint16_t nRecordingDevices = audio_device_->RecordingDevices(); uint16_t nRecordingDevices = audio_device_->RecordingDevices();
RTC_DLOG(INFO) << "output: " << nRecordingDevices; RTC_DLOG(LS_INFO) << "output: " << nRecordingDevices;
return (int16_t)nRecordingDevices; return (int16_t)nRecordingDevices;
} }
int32_t AudioDeviceModuleIOS::SetRecordingDevice(uint16_t index) { int32_t AudioDeviceModuleIOS::SetRecordingDevice(uint16_t index) {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << index << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << index << ")";
CHECKinitialized_(); CHECKinitialized_();
return audio_device_->SetRecordingDevice(index); return audio_device_->SetRecordingDevice(index);
} }
int32_t AudioDeviceModuleIOS::SetRecordingDevice(WindowsDeviceType device) { int32_t AudioDeviceModuleIOS::SetRecordingDevice(WindowsDeviceType device) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
return audio_device_->SetRecordingDevice(device); return audio_device_->SetRecordingDevice(device);
} }
int32_t AudioDeviceModuleIOS::InitPlayout() { int32_t AudioDeviceModuleIOS::InitPlayout() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
if (PlayoutIsInitialized()) { if (PlayoutIsInitialized()) {
return 0; return 0;
} }
int32_t result = audio_device_->InitPlayout(); int32_t result = audio_device_->InitPlayout();
RTC_DLOG(INFO) << "output: " << result; RTC_DLOG(LS_INFO) << "output: " << result;
RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.InitPlayoutSuccess", RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.InitPlayoutSuccess",
static_cast<int>(result == 0)); static_cast<int>(result == 0));
return result; return result;
} }
int32_t AudioDeviceModuleIOS::InitRecording() { int32_t AudioDeviceModuleIOS::InitRecording() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
if (RecordingIsInitialized()) { if (RecordingIsInitialized()) {
return 0; return 0;
} }
int32_t result = audio_device_->InitRecording(); int32_t result = audio_device_->InitRecording();
RTC_DLOG(INFO) << "output: " << result; RTC_DLOG(LS_INFO) << "output: " << result;
RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.InitRecordingSuccess", RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.InitRecordingSuccess",
static_cast<int>(result == 0)); static_cast<int>(result == 0));
return result; return result;
} }
bool AudioDeviceModuleIOS::PlayoutIsInitialized() const { bool AudioDeviceModuleIOS::PlayoutIsInitialized() const {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized__BOOL(); CHECKinitialized__BOOL();
return audio_device_->PlayoutIsInitialized(); return audio_device_->PlayoutIsInitialized();
} }
bool AudioDeviceModuleIOS::RecordingIsInitialized() const { bool AudioDeviceModuleIOS::RecordingIsInitialized() const {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized__BOOL(); CHECKinitialized__BOOL();
return audio_device_->RecordingIsInitialized(); return audio_device_->RecordingIsInitialized();
} }
int32_t AudioDeviceModuleIOS::StartPlayout() { int32_t AudioDeviceModuleIOS::StartPlayout() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
if (Playing()) { if (Playing()) {
return 0; return 0;
} }
audio_device_buffer_.get()->StartPlayout(); audio_device_buffer_.get()->StartPlayout();
int32_t result = audio_device_->StartPlayout(); int32_t result = audio_device_->StartPlayout();
RTC_DLOG(INFO) << "output: " << result; RTC_DLOG(LS_INFO) << "output: " << result;
RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StartPlayoutSuccess", RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StartPlayoutSuccess",
static_cast<int>(result == 0)); static_cast<int>(result == 0));
return result; return result;
} }
int32_t AudioDeviceModuleIOS::StopPlayout() { int32_t AudioDeviceModuleIOS::StopPlayout() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
int32_t result = audio_device_->StopPlayout(); int32_t result = audio_device_->StopPlayout();
audio_device_buffer_.get()->StopPlayout(); audio_device_buffer_.get()->StopPlayout();
RTC_DLOG(INFO) << "output: " << result; RTC_DLOG(LS_INFO) << "output: " << result;
RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StopPlayoutSuccess", RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StopPlayoutSuccess",
static_cast<int>(result == 0)); static_cast<int>(result == 0));
return result; return result;
} }
bool AudioDeviceModuleIOS::Playing() const { bool AudioDeviceModuleIOS::Playing() const {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized__BOOL(); CHECKinitialized__BOOL();
return audio_device_->Playing(); return audio_device_->Playing();
} }
int32_t AudioDeviceModuleIOS::StartRecording() { int32_t AudioDeviceModuleIOS::StartRecording() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
if (Recording()) { if (Recording()) {
return 0; return 0;
} }
audio_device_buffer_.get()->StartRecording(); audio_device_buffer_.get()->StartRecording();
int32_t result = audio_device_->StartRecording(); int32_t result = audio_device_->StartRecording();
RTC_DLOG(INFO) << "output: " << result; RTC_DLOG(LS_INFO) << "output: " << result;
RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StartRecordingSuccess", RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StartRecordingSuccess",
static_cast<int>(result == 0)); static_cast<int>(result == 0));
return result; return result;
} }
int32_t AudioDeviceModuleIOS::StopRecording() { int32_t AudioDeviceModuleIOS::StopRecording() {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized_(); CHECKinitialized_();
int32_t result = audio_device_->StopRecording(); int32_t result = audio_device_->StopRecording();
audio_device_buffer_.get()->StopRecording(); audio_device_buffer_.get()->StopRecording();
RTC_DLOG(INFO) << "output: " << result; RTC_DLOG(LS_INFO) << "output: " << result;
RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StopRecordingSuccess", RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StopRecordingSuccess",
static_cast<int>(result == 0)); static_cast<int>(result == 0));
return result; return result;
} }
bool AudioDeviceModuleIOS::Recording() const { bool AudioDeviceModuleIOS::Recording() const {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized__BOOL(); CHECKinitialized__BOOL();
return audio_device_->Recording(); return audio_device_->Recording();
} }
int32_t AudioDeviceModuleIOS::RegisterAudioCallback( int32_t AudioDeviceModuleIOS::RegisterAudioCallback(
AudioTransport* audioCallback) { AudioTransport* audioCallback) {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
return audio_device_buffer_.get()->RegisterAudioCallback(audioCallback); return audio_device_buffer_.get()->RegisterAudioCallback(audioCallback);
} }
@ -596,50 +596,50 @@ AudioDeviceModuleIOS::AudioDeviceModuleIOS(bool bypass_voice_processing)
} }
bool AudioDeviceModuleIOS::BuiltInAECIsAvailable() const { bool AudioDeviceModuleIOS::BuiltInAECIsAvailable() const {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized__BOOL(); CHECKinitialized__BOOL();
bool isAvailable = audio_device_->BuiltInAECIsAvailable(); bool isAvailable = audio_device_->BuiltInAECIsAvailable();
RTC_DLOG(INFO) << "output: " << isAvailable; RTC_DLOG(LS_INFO) << "output: " << isAvailable;
return isAvailable; return isAvailable;
} }
int32_t AudioDeviceModuleIOS::EnableBuiltInAEC(bool enable) { int32_t AudioDeviceModuleIOS::EnableBuiltInAEC(bool enable) {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
CHECKinitialized_(); CHECKinitialized_();
int32_t ok = audio_device_->EnableBuiltInAEC(enable); int32_t ok = audio_device_->EnableBuiltInAEC(enable);
RTC_DLOG(INFO) << "output: " << ok; RTC_DLOG(LS_INFO) << "output: " << ok;
return ok; return ok;
} }
bool AudioDeviceModuleIOS::BuiltInAGCIsAvailable() const { bool AudioDeviceModuleIOS::BuiltInAGCIsAvailable() const {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized__BOOL(); CHECKinitialized__BOOL();
bool isAvailable = audio_device_->BuiltInAGCIsAvailable(); bool isAvailable = audio_device_->BuiltInAGCIsAvailable();
RTC_DLOG(INFO) << "output: " << isAvailable; RTC_DLOG(LS_INFO) << "output: " << isAvailable;
return isAvailable; return isAvailable;
} }
int32_t AudioDeviceModuleIOS::EnableBuiltInAGC(bool enable) { int32_t AudioDeviceModuleIOS::EnableBuiltInAGC(bool enable) {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
CHECKinitialized_(); CHECKinitialized_();
int32_t ok = audio_device_->EnableBuiltInAGC(enable); int32_t ok = audio_device_->EnableBuiltInAGC(enable);
RTC_DLOG(INFO) << "output: " << ok; RTC_DLOG(LS_INFO) << "output: " << ok;
return ok; return ok;
} }
bool AudioDeviceModuleIOS::BuiltInNSIsAvailable() const { bool AudioDeviceModuleIOS::BuiltInNSIsAvailable() const {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
CHECKinitialized__BOOL(); CHECKinitialized__BOOL();
bool isAvailable = audio_device_->BuiltInNSIsAvailable(); bool isAvailable = audio_device_->BuiltInNSIsAvailable();
RTC_DLOG(INFO) << "output: " << isAvailable; RTC_DLOG(LS_INFO) << "output: " << isAvailable;
return isAvailable; return isAvailable;
} }
int32_t AudioDeviceModuleIOS::EnableBuiltInNS(bool enable) { int32_t AudioDeviceModuleIOS::EnableBuiltInNS(bool enable) {
RTC_DLOG(INFO) << __FUNCTION__ << "(" << enable << ")"; RTC_DLOG(LS_INFO) << __FUNCTION__ << "(" << enable << ")";
CHECKinitialized_(); CHECKinitialized_();
int32_t ok = audio_device_->EnableBuiltInNS(enable); int32_t ok = audio_device_->EnableBuiltInNS(enable);
RTC_DLOG(INFO) << "output: " << ok; RTC_DLOG(LS_INFO) << "output: " << ok;
return ok; return ok;
} }
@ -653,17 +653,17 @@ AudioDeviceModuleIOS::AudioDeviceModuleIOS(bool bypass_voice_processing)
#if defined(WEBRTC_IOS) #if defined(WEBRTC_IOS)
int AudioDeviceModuleIOS::GetPlayoutAudioParameters( int AudioDeviceModuleIOS::GetPlayoutAudioParameters(
AudioParameters* params) const { AudioParameters* params) const {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
int r = audio_device_->GetPlayoutAudioParameters(params); int r = audio_device_->GetPlayoutAudioParameters(params);
RTC_DLOG(INFO) << "output: " << r; RTC_DLOG(LS_INFO) << "output: " << r;
return r; return r;
} }
int AudioDeviceModuleIOS::GetRecordAudioParameters( int AudioDeviceModuleIOS::GetRecordAudioParameters(
AudioParameters* params) const { AudioParameters* params) const {
RTC_DLOG(INFO) << __FUNCTION__; RTC_DLOG(LS_INFO) << __FUNCTION__;
int r = audio_device_->GetRecordAudioParameters(params); int r = audio_device_->GetRecordAudioParameters(params);
RTC_DLOG(INFO) << "output: " << r; RTC_DLOG(LS_INFO) << "output: " << r;
return r; return r;
} }
#endif // WEBRTC_IOS #endif // WEBRTC_IOS

4
test/network/cross_traffic_unittest.cc
View File

@ -87,7 +87,7 @@ TEST(CrossTrafficTest, PulsedPeaksCrossTraffic) {
fixture.clock.AdvanceTimeMilliseconds(1); fixture.clock.AdvanceTimeMilliseconds(1);
} }
RTC_LOG(INFO) << fixture.counter.packets_count_ << " packets; " RTC_LOG(LS_INFO) << fixture.counter.packets_count_ << " packets; "
<< fixture.counter.total_packets_size_ << " bytes"; << fixture.counter.total_packets_size_ << " bytes";
// Using 50% duty cycle. // Using 50% duty cycle.
const auto kExpectedDataSent = kRunTime * config.peak_rate * 0.5; const auto kExpectedDataSent = kRunTime * config.peak_rate * 0.5;
@ -115,7 +115,7 @@ TEST(CrossTrafficTest, RandomWalkCrossTraffic) {
fixture.clock.AdvanceTimeMilliseconds(1); fixture.clock.AdvanceTimeMilliseconds(1);
} }
RTC_LOG(INFO) << fixture.counter.packets_count_ << " packets; " RTC_LOG(LS_INFO) << fixture.counter.packets_count_ << " packets; "
<< fixture.counter.total_packets_size_ << " bytes"; << fixture.counter.total_packets_size_ << " bytes";
// Sending at peak rate since bias = 1. // Sending at peak rate since bias = 1.
const auto kExpectedDataSent = kRunTime * config.peak_rate; const auto kExpectedDataSent = kRunTime * config.peak_rate;

4
test/network/fake_network_socket_server.cc
View File

@ -132,7 +132,7 @@ int FakeNetworkSocket::Bind(const rtc::SocketAddress& addr) {
endpoint_ = socket_server_->GetEndpointNode(local_addr_.ipaddr()); endpoint_ = socket_server_->GetEndpointNode(local_addr_.ipaddr());
if (!endpoint_) { if (!endpoint_) {
local_addr_.Clear(); local_addr_.Clear();
RTC_LOG(INFO) << "No endpoint for address: " << ToString(addr); RTC_LOG(LS_INFO) << "No endpoint for address: " << ToString(addr);
error_ = EADDRNOTAVAIL; error_ = EADDRNOTAVAIL;
return 2; return 2;
} }
@ -140,7 +140,7 @@ int FakeNetworkSocket::Bind(const rtc::SocketAddress& addr) {
endpoint_->BindReceiver(local_addr_.port(), this); endpoint_->BindReceiver(local_addr_.port(), this);
if (!port) { if (!port) {
local_addr_.Clear(); local_addr_.Clear();
RTC_LOG(INFO) << "Cannot bind to in-use address: " << ToString(addr); RTC_LOG(LS_INFO) << "Cannot bind to in-use address: " << ToString(addr);
error_ = EADDRINUSE; error_ = EADDRINUSE;
return 1; return 1;
} }

21
test/network/network_emulation.cc
View File

@ -477,7 +477,7 @@ EmulatedEndpointImpl::EmulatedEndpointImpl(const Options& options,
network_->AddIP(options_.ip); network_->AddIP(options_.ip);
enabled_state_checker_.Detach(); enabled_state_checker_.Detach();
RTC_LOG(INFO) << "Created emulated endpoint " << options_.log_name RTC_LOG(LS_INFO) << "Created emulated endpoint " << options_.log_name
<< "; id=" << options_.id; << "; id=" << options_.id;
} }
EmulatedEndpointImpl::~EmulatedEndpointImpl() = default; EmulatedEndpointImpl::~EmulatedEndpointImpl() = default;
@ -546,12 +546,12 @@ absl::optional<uint16_t> EmulatedEndpointImpl::BindReceiverInternal(
bool result = bool result =
port_to_receiver_.insert({port, {receiver, is_one_shot}}).second; port_to_receiver_.insert({port, {receiver, is_one_shot}}).second;
if (!result) { if (!result) {
RTC_LOG(INFO) << "Can't bind receiver to used port " << desired_port RTC_LOG(LS_INFO) << "Can't bind receiver to used port " << desired_port
<< " in endpoint " << options_.log_name << " in endpoint " << options_.log_name
<< "; id=" << options_.id; << "; id=" << options_.id;
return absl::nullopt; return absl::nullopt;
} }
RTC_LOG(INFO) << "New receiver is binded to endpoint " << options_.log_name RTC_LOG(LS_INFO) << "New receiver is binded to endpoint " << options_.log_name
<< "; id=" << options_.id << " on port " << port; << "; id=" << options_.id << " on port " << port;
return port; return port;
} }
@ -568,8 +568,9 @@ uint16_t EmulatedEndpointImpl::NextPort() {
void EmulatedEndpointImpl::UnbindReceiver(uint16_t port) { void EmulatedEndpointImpl::UnbindReceiver(uint16_t port) {
MutexLock lock(&receiver_lock_); MutexLock lock(&receiver_lock_);
RTC_LOG(INFO) << "Receiver is removed on port " << port << " from endpoint " RTC_LOG(LS_INFO) << "Receiver is removed on port " << port
<< options_.log_name << "; id=" << options_.id; << " from endpoint " << options_.log_name
<< "; id=" << options_.id;
port_to_receiver_.erase(port); port_to_receiver_.erase(port);
} }
@ -579,14 +580,14 @@ void EmulatedEndpointImpl::BindDefaultReceiver(
RTC_CHECK(!default_receiver_.has_value()) RTC_CHECK(!default_receiver_.has_value())
<< "Endpoint " << options_.log_name << "; id=" << options_.id << "Endpoint " << options_.log_name << "; id=" << options_.id
<< " already has default receiver"; << " already has default receiver";
RTC_LOG(INFO) << "Default receiver is binded to endpoint " RTC_LOG(LS_INFO) << "Default receiver is binded to endpoint "
<< options_.log_name << "; id=" << options_.id; << options_.log_name << "; id=" << options_.id;
default_receiver_ = receiver; default_receiver_ = receiver;
} }
void EmulatedEndpointImpl::UnbindDefaultReceiver() { void EmulatedEndpointImpl::UnbindDefaultReceiver() {
MutexLock lock(&receiver_lock_); MutexLock lock(&receiver_lock_);
RTC_LOG(INFO) << "Default receiver is removed from endpoint " RTC_LOG(LS_INFO) << "Default receiver is removed from endpoint "
<< options_.log_name << "; id=" << options_.id; << options_.log_name << "; id=" << options_.id;
default_receiver_ = absl::nullopt; default_receiver_ = absl::nullopt;
} }
@ -616,9 +617,9 @@ void EmulatedEndpointImpl::OnPacketReceived(EmulatedIpPacket packet) {
// It can happen, that remote peer closed connection, but there still some // It can happen, that remote peer closed connection, but there still some
// packets, that are going to it. It can happen during peer connection close // packets, that are going to it. It can happen during peer connection close
// process: one peer closed connection, second still sending data. // process: one peer closed connection, second still sending data.
RTC_LOG(INFO) << "Drop packet: no receiver registered in " RTC_LOG(LS_INFO) << "Drop packet: no receiver registered in "
<< options_.log_name << "; id=" << options_.id << " on port " << options_.log_name << "; id=" << options_.id
<< packet.to.port(); << " on port " << packet.to.port();
stats_builder_.OnPacketDropped(packet.from.ipaddr(), stats_builder_.OnPacketDropped(packet.from.ipaddr(),
DataSize::Bytes(packet.ip_packet_size()), DataSize::Bytes(packet.ip_packet_size()),
options_.stats_gathering_mode); options_.stats_gathering_mode);

44
test/pc/e2e/analyzer/video/default_video_quality_analyzer.cc
View File

@ -39,13 +39,13 @@ constexpr absl::string_view kSkipRenderedFrameReasonDropped =
"considered dropped"; "considered dropped";
void LogFrameCounters(const std::string& name, const FrameCounters& counters) { void LogFrameCounters(const std::string& name, const FrameCounters& counters) {
RTC_LOG(INFO) << "[" << name << "] Captured : " << counters.captured; RTC_LOG(LS_INFO) << "[" << name << "] Captured : " << counters.captured;
RTC_LOG(INFO) << "[" << name << "] Pre encoded : " << counters.pre_encoded; RTC_LOG(LS_INFO) << "[" << name << "] Pre encoded : " << counters.pre_encoded;
RTC_LOG(INFO) << "[" << name << "] Encoded : " << counters.encoded; RTC_LOG(LS_INFO) << "[" << name << "] Encoded : " << counters.encoded;
RTC_LOG(INFO) << "[" << name << "] Received : " << counters.received; RTC_LOG(LS_INFO) << "[" << name << "] Received : " << counters.received;
RTC_LOG(INFO) << "[" << name << "] Decoded : " << counters.decoded; RTC_LOG(LS_INFO) << "[" << name << "] Decoded : " << counters.decoded;
RTC_LOG(INFO) << "[" << name << "] Rendered : " << counters.rendered; RTC_LOG(LS_INFO) << "[" << name << "] Rendered : " << counters.rendered;
RTC_LOG(INFO) << "[" << name << "] Dropped : " << counters.dropped; RTC_LOG(LS_INFO) << "[" << name << "] Dropped : " << counters.dropped;
} }
absl::string_view ToString(FrameDropPhase phase) { absl::string_view ToString(FrameDropPhase phase) {
@ -67,7 +67,7 @@ void LogStreamInternalStats(const std::string& name,
const StreamStats& stats, const StreamStats& stats,
Timestamp start_time) { Timestamp start_time) {
for (const auto& entry : stats.dropped_by_phase) { for (const auto& entry : stats.dropped_by_phase) {
RTC_LOG(INFO) << "[" << name << "] Dropped at " << ToString(entry.first) RTC_LOG(LS_INFO) << "[" << name << "] Dropped at " << ToString(entry.first)
<< ": " << entry.second; << ": " << entry.second;
} }
Timestamp first_encoded_frame_time = Timestamp::PlusInfinity(); Timestamp first_encoded_frame_time = Timestamp::PlusInfinity();
@ -77,12 +77,12 @@ void LogStreamInternalStats(const std::string& name,
if (first_encoded_frame_time.IsInfinite()) { if (first_encoded_frame_time.IsInfinite()) {
first_encoded_frame_time = encoder.switched_on_at; first_encoded_frame_time = encoder.switched_on_at;
} }
RTC_LOG(INFO) << "[" << name << "] Used encoder: \"" << encoder.codec_name RTC_LOG(LS_INFO)
<< "[" << name << "] Used encoder: \"" << encoder.codec_name
<< "\" used from (frame_id=" << encoder.first_frame_id << "\" used from (frame_id=" << encoder.first_frame_id
<< "; from_stream_start=" << "; from_stream_start="
<< (encoder.switched_on_at - stats.stream_started_time).ms() << (encoder.switched_on_at - stats.stream_started_time).ms()
<< "ms, from_call_start=" << "ms, from_call_start=" << (encoder.switched_on_at - start_time).ms()
<< (encoder.switched_on_at - start_time).ms()
<< "ms) until (frame_id=" << encoder.last_frame_id << "ms) until (frame_id=" << encoder.last_frame_id
<< "; from_stream_start=" << "; from_stream_start="
<< (encoder.switched_from_at - stats.stream_started_time).ms() << (encoder.switched_from_at - stats.stream_started_time).ms()
@ -92,12 +92,12 @@ void LogStreamInternalStats(const std::string& name,
for (const StreamCodecInfo& decoder : stats.decoders) { for (const StreamCodecInfo& decoder : stats.decoders) {
RTC_DCHECK(decoder.switched_on_at.IsFinite()); RTC_DCHECK(decoder.switched_on_at.IsFinite());
RTC_DCHECK(decoder.switched_from_at.IsFinite()); RTC_DCHECK(decoder.switched_from_at.IsFinite());
RTC_LOG(INFO) << "[" << name << "] Used decoder: \"" << decoder.codec_name RTC_LOG(LS_INFO)
<< "[" << name << "] Used decoder: \"" << decoder.codec_name
<< "\" used from (frame_id=" << decoder.first_frame_id << "\" used from (frame_id=" << decoder.first_frame_id
<< "; from_stream_start=" << "; from_stream_start="
<< (decoder.switched_on_at - stats.stream_started_time).ms() << (decoder.switched_on_at - stats.stream_started_time).ms()
<< "ms, from_call_start=" << "ms, from_call_start=" << (decoder.switched_on_at - start_time).ms()
<< (decoder.switched_on_at - start_time).ms()
<< "ms) until (frame_id=" << decoder.last_frame_id << "ms) until (frame_id=" << decoder.last_frame_id
<< "; from_stream_start=" << "; from_stream_start="
<< (decoder.switched_from_at - stats.stream_started_time).ms() << (decoder.switched_from_at - stats.stream_started_time).ms()
@ -668,7 +668,7 @@ std::set<StatsKey> DefaultVideoQualityAnalyzer::GetKnownVideoStreams() const {
MutexLock lock(&mutex_); MutexLock lock(&mutex_);
std::set<StatsKey> out; std::set<StatsKey> out;
for (auto& item : frames_comparator_.stream_stats()) { for (auto& item : frames_comparator_.stream_stats()) {
RTC_LOG(INFO) << item.first.ToString() << " ==> " RTC_LOG(LS_INFO) << item.first.ToString() << " ==> "
<< ToStatsKey(item.first).ToString(); << ToStatsKey(item.first).ToString();
out.insert(ToStatsKey(item.first)); out.insert(ToStatsKey(item.first));
} }
@ -722,16 +722,18 @@ void DefaultVideoQualityAnalyzer::ReportResults() {
start_time_); start_time_);
} }
if (!analyzer_stats_.comparisons_queue_size.IsEmpty()) { if (!analyzer_stats_.comparisons_queue_size.IsEmpty()) {
RTC_LOG(INFO) << "comparisons_queue_size min=" RTC_LOG(LS_INFO) << "comparisons_queue_size min="
<< analyzer_stats_.comparisons_queue_size.GetMin() << analyzer_stats_.comparisons_queue_size.GetMin()
<< "; max=" << analyzer_stats_.comparisons_queue_size.GetMax() << "; max="
<< analyzer_stats_.comparisons_queue_size.GetMax()
<< "; 99%=" << "; 99%="
<< analyzer_stats_.comparisons_queue_size.GetPercentile(0.99); << analyzer_stats_.comparisons_queue_size.GetPercentile(
0.99);
} }
RTC_LOG(INFO) << "comparisons_done=" << analyzer_stats_.comparisons_done; RTC_LOG(LS_INFO) << "comparisons_done=" << analyzer_stats_.comparisons_done;
RTC_LOG(INFO) << "cpu_overloaded_comparisons_done=" RTC_LOG(LS_INFO) << "cpu_overloaded_comparisons_done="
<< analyzer_stats_.cpu_overloaded_comparisons_done; << analyzer_stats_.cpu_overloaded_comparisons_done;
RTC_LOG(INFO) << "memory_overloaded_comparisons_done=" RTC_LOG(LS_INFO) << "memory_overloaded_comparisons_done="
<< analyzer_stats_.memory_overloaded_comparisons_done; << analyzer_stats_.memory_overloaded_comparisons_done;
} }

4
test/pc/e2e/analyzer/video/example_video_quality_analyzer.cc
View File

@ -66,7 +66,7 @@ void ExampleVideoQualityAnalyzer::OnFrameEncoded(
void ExampleVideoQualityAnalyzer::OnFrameDropped( void ExampleVideoQualityAnalyzer::OnFrameDropped(
absl::string_view peer_name, absl::string_view peer_name,
webrtc::EncodedImageCallback::DropReason reason) { webrtc::EncodedImageCallback::DropReason reason) {
RTC_LOG(INFO) << "Frame dropped by encoder"; RTC_LOG(LS_INFO) << "Frame dropped by encoder";
MutexLock lock(&lock_); MutexLock lock(&lock_);
++frames_dropped_; ++frames_dropped_;
} }
@ -112,7 +112,7 @@ void ExampleVideoQualityAnalyzer::OnDecoderError(absl::string_view peer_name,
void ExampleVideoQualityAnalyzer::Stop() { void ExampleVideoQualityAnalyzer::Stop() {
MutexLock lock(&lock_); MutexLock lock(&lock_);
RTC_LOG(INFO) << "There are " << frames_in_flight_.size() RTC_LOG(LS_INFO) << "There are " << frames_in_flight_.size()
<< " frames in flight, assuming all of them are dropped"; << " frames in flight, assuming all of them are dropped";
frames_dropped_ += frames_in_flight_.size(); frames_dropped_ += frames_in_flight_.size();
} }

2
test/pc/e2e/echo/echo_emulation.cc
View File

@ -57,7 +57,7 @@ void EchoEmulatingCapturer::OnAudioRendered(
} }
queue_input_.assign(data.begin(), data.end()); queue_input_.assign(data.begin(), data.end());
if (!renderer_queue_.Insert(&queue_input_)) { if (!renderer_queue_.Insert(&queue_input_)) {
RTC_LOG(WARNING) << "Echo queue is full"; RTC_LOG(LS_WARNING) << "Echo queue is full";
} }
} }

2
test/pc/e2e/media/media_helper.cc
View File

@ -67,7 +67,7 @@ MediaHelper::MaybeAddVideo(TestPeer* peer) {
rtc::make_ref_counted<TestVideoCapturerVideoTrackSource>( rtc::make_ref_counted<TestVideoCapturerVideoTrackSource>(
std::move(capturer), is_screencast); std::move(capturer), is_screencast);
out.push_back(source); out.push_back(source);
RTC_LOG(INFO) << "Adding video with video_config.stream_label=" RTC_LOG(LS_INFO) << "Adding video with video_config.stream_label="
<< video_config.stream_label.value(); << video_config.stream_label.value();
rtc::scoped_refptr<VideoTrackInterface> track = rtc::scoped_refptr<VideoTrackInterface> track =
peer->pc_factory()->CreateVideoTrack(video_config.stream_label.value(), peer->pc_factory()->CreateVideoTrack(video_config.stream_label.value(),

31
test/pc/e2e/peer_connection_quality_test.cc
View File

@ -202,13 +202,14 @@ void PeerConnectionE2EQualityTest::Run(RunParams run_params) {
test::ScopedFieldTrials field_trials(GetFieldTrials(run_params)); test::ScopedFieldTrials field_trials(GetFieldTrials(run_params));
// Print test summary // Print test summary
RTC_LOG(INFO) << "Media quality test: " << *alice_configurer->params()->name RTC_LOG(LS_INFO) << "Media quality test: "
<< *alice_configurer->params()->name
<< " will make a call to " << *bob_configurer->params()->name << " will make a call to " << *bob_configurer->params()->name
<< " with media video=" << " with media video="
<< !alice_configurer->params()->video_configs.empty() << !alice_configurer->params()->video_configs.empty()
<< "; audio=" << "; audio="
<< alice_configurer->params()->audio_config.has_value() << ". " << alice_configurer->params()->audio_config.has_value()
<< *bob_configurer->params()->name << ". " << *bob_configurer->params()->name
<< " will respond with media video=" << " will respond with media video="
<< !bob_configurer->params()->video_configs.empty() << !bob_configurer->params()->video_configs.empty()
<< "; audio=" << "; audio="
@ -276,7 +277,7 @@ void PeerConnectionE2EQualityTest::Run(RunParams run_params) {
} }
video_analyzer_threads = video_analyzer_threads =
std::min(video_analyzer_threads, kMaxVideoAnalyzerThreads); std::min(video_analyzer_threads, kMaxVideoAnalyzerThreads);
RTC_LOG(INFO) << "video_analyzer_threads=" << video_analyzer_threads; RTC_LOG(LS_INFO) << "video_analyzer_threads=" << video_analyzer_threads;
quality_metrics_reporters_.push_back( quality_metrics_reporters_.push_back(
std::make_unique<VideoQualityMetricsReporter>( std::make_unique<VideoQualityMetricsReporter>(
time_controller_.GetClock())); time_controller_.GetClock()));
@ -315,7 +316,7 @@ void PeerConnectionE2EQualityTest::Run(RunParams run_params) {
return kAliveMessageLogInterval; return kAliveMessageLogInterval;
}); });
RTC_LOG(INFO) << "Configuration is done. Now " << *alice_->params()->name RTC_LOG(LS_INFO) << "Configuration is done. Now " << *alice_->params()->name
<< " is calling to " << *bob_->params()->name << "..."; << " is calling to " << *bob_->params()->name << "...";
// Setup stats poller. // Setup stats poller.
@ -359,7 +360,7 @@ void PeerConnectionE2EQualityTest::Run(RunParams run_params) {
time_controller_.AdvanceTime(run_params.run_duration); time_controller_.AdvanceTime(run_params.run_duration);
} }
RTC_LOG(INFO) << "Test is done, initiating disconnect sequence."; RTC_LOG(LS_INFO) << "Test is done, initiating disconnect sequence.";
// Stop all client started tasks to prevent their access to any call related // Stop all client started tasks to prevent their access to any call related
// objects after these objects will be destroyed during call tear down. // objects after these objects will be destroyed during call tear down.
@ -382,7 +383,7 @@ void PeerConnectionE2EQualityTest::Run(RunParams run_params) {
[this] { TearDownCallOnSignalingThread(); }); [this] { TearDownCallOnSignalingThread(); });
Timestamp end_time = Now(); Timestamp end_time = Now();
RTC_LOG(INFO) << "All peers are disconnected."; RTC_LOG(LS_INFO) << "All peers are disconnected.";
{ {
MutexLock lock(&lock_); MutexLock lock(&lock_);
real_test_duration_ = end_time - start_time; real_test_duration_ = end_time - start_time;
@ -619,13 +620,13 @@ void PeerConnectionE2EQualityTest::ExchangeOfferAnswer(
auto offer = alice_->CreateOffer(); auto offer = alice_->CreateOffer();
RTC_CHECK(offer); RTC_CHECK(offer);
offer->ToString(&log_output); offer->ToString(&log_output);
RTC_LOG(INFO) << "Original offer: " << log_output; RTC_LOG(LS_INFO) << "Original offer: " << log_output;
LocalAndRemoteSdp patch_result = signaling_interceptor->PatchOffer( LocalAndRemoteSdp patch_result = signaling_interceptor->PatchOffer(
std::move(offer), alice_->params()->video_codecs[0]); std::move(offer), alice_->params()->video_codecs[0]);
patch_result.local_sdp->ToString(&log_output); patch_result.local_sdp->ToString(&log_output);
RTC_LOG(INFO) << "Offer to set as local description: " << log_output; RTC_LOG(LS_INFO) << "Offer to set as local description: " << log_output;
patch_result.remote_sdp->ToString(&log_output); patch_result.remote_sdp->ToString(&log_output);
RTC_LOG(INFO) << "Offer to set as remote description: " << log_output; RTC_LOG(LS_INFO) << "Offer to set as remote description: " << log_output;
bool set_local_offer = bool set_local_offer =
alice_->SetLocalDescription(std::move(patch_result.local_sdp)); alice_->SetLocalDescription(std::move(patch_result.local_sdp));
@ -636,13 +637,13 @@ void PeerConnectionE2EQualityTest::ExchangeOfferAnswer(
auto answer = bob_->CreateAnswer(); auto answer = bob_->CreateAnswer();
RTC_CHECK(answer); RTC_CHECK(answer);
answer->ToString(&log_output); answer->ToString(&log_output);
RTC_LOG(INFO) << "Original answer: " << log_output; RTC_LOG(LS_INFO) << "Original answer: " << log_output;
patch_result = signaling_interceptor->PatchAnswer( patch_result = signaling_interceptor->PatchAnswer(
std::move(answer), bob_->params()->video_codecs[0]); std::move(answer), bob_->params()->video_codecs[0]);
patch_result.local_sdp->ToString(&log_output); patch_result.local_sdp->ToString(&log_output);
RTC_LOG(INFO) << "Answer to set as local description: " << log_output; RTC_LOG(LS_INFO) << "Answer to set as local description: " << log_output;
patch_result.remote_sdp->ToString(&log_output); patch_result.remote_sdp->ToString(&log_output);
RTC_LOG(INFO) << "Answer to set as remote description: " << log_output; RTC_LOG(LS_INFO) << "Answer to set as remote description: " << log_output;
bool set_local_answer = bool set_local_answer =
bob_->SetLocalDescription(std::move(patch_result.local_sdp)); bob_->SetLocalDescription(std::move(patch_result.local_sdp));
@ -661,7 +662,7 @@ void PeerConnectionE2EQualityTest::ExchangeIceCandidates(
for (auto& candidate : alice_candidates) { for (auto& candidate : alice_candidates) {
std::string candidate_str; std::string candidate_str;
RTC_CHECK(candidate->ToString(&candidate_str)); RTC_CHECK(candidate->ToString(&candidate_str));
RTC_LOG(INFO) << *alice_->params()->name RTC_LOG(LS_INFO) << *alice_->params()->name
<< " ICE candidate(mid= " << candidate->sdp_mid() << " ICE candidate(mid= " << candidate->sdp_mid()
<< "): " << candidate_str; << "): " << candidate_str;
} }
@ -672,7 +673,7 @@ void PeerConnectionE2EQualityTest::ExchangeIceCandidates(
for (auto& candidate : bob_candidates) { for (auto& candidate : bob_candidates) {
std::string candidate_str; std::string candidate_str;
RTC_CHECK(candidate->ToString(&candidate_str)); RTC_CHECK(candidate->ToString(&candidate_str));
RTC_LOG(INFO) << *bob_->params()->name RTC_LOG(LS_INFO) << *bob_->params()->name
<< " ICE candidate(mid= " << candidate->sdp_mid() << " ICE candidate(mid= " << candidate->sdp_mid()
<< "): " << candidate_str; << "): " << candidate_str;
} }

2
test/pc/e2e/stats_based_network_quality_metrics_reporter.cc
View File

@ -378,7 +378,7 @@ void StatsBasedNetworkQualityMetricsReporter::LogNetworkLayerStats(
} }
} }
RTC_LOG(INFO) << log.str(); RTC_LOG(LS_INFO) << log.str();
} }
} // namespace webrtc_pc_e2e } // namespace webrtc_pc_e2e

4
video/video_quality_test.cc
View File

@ -1342,7 +1342,7 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
rtc::scoped_refptr<AudioDeviceModule> VideoQualityTest::CreateAudioDevice() { rtc::scoped_refptr<AudioDeviceModule> VideoQualityTest::CreateAudioDevice() {
#ifdef WEBRTC_WIN #ifdef WEBRTC_WIN
RTC_LOG(INFO) << "Using latest version of ADM on Windows"; RTC_LOG(LS_INFO) << "Using latest version of ADM on Windows";
// We must initialize the COM library on a thread before we calling any of // We must initialize the COM library on a thread before we calling any of
// the library functions. All COM functions in the ADM will return // the library functions. All COM functions in the ADM will return
// CO_E_NOTINITIALIZED otherwise. The legacy ADM for Windows used internal // CO_E_NOTINITIALIZED otherwise. The legacy ADM for Windows used internal
@ -1433,7 +1433,7 @@ void VideoQualityTest::SetupAudio(Transport* transport) {
} }
void VideoQualityTest::RunWithRenderers(const Params& params) { void VideoQualityTest::RunWithRenderers(const Params& params) {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(LS_INFO) << __FUNCTION__;
num_video_streams_ = params.call.dual_video ? 2 : 1; num_video_streams_ = params.call.dual_video ? 2 : 1;
std::unique_ptr<test::LayerFilteringTransport> send_transport; std::unique_ptr<test::LayerFilteringTransport> send_transport;
std::unique_ptr<test::DirectTransport> recv_transport; std::unique_ptr<test::DirectTransport> recv_transport;

3
video/video_source_sink_controller.cc
View File

@ -80,7 +80,8 @@ void VideoSourceSinkController::PushSourceSinkSettings() {
if (!source_) if (!source_)
return; return;
rtc::VideoSinkWants wants = CurrentSettingsToSinkWants(); rtc::VideoSinkWants wants = CurrentSettingsToSinkWants();
RTC_LOG(INFO) << "Pushing SourceSink restrictions: " << WantsToString(wants); RTC_LOG(LS_INFO) << "Pushing SourceSink restrictions: "
<< WantsToString(wants);
source_->AddOrUpdateSink(sink_, wants); source_->AddOrUpdateSink(sink_, wants);
} }

6
video/video_stream_encoder.cc
View File

@ -2173,9 +2173,9 @@ void VideoStreamEncoder::OnVideoSourceRestrictionsUpdated(
rtc::scoped_refptr<Resource> reason, rtc::scoped_refptr<Resource> reason,
const VideoSourceRestrictions& unfiltered_restrictions) { const VideoSourceRestrictions& unfiltered_restrictions) {
RTC_DCHECK_RUN_ON(&encoder_queue_); RTC_DCHECK_RUN_ON(&encoder_queue_);
RTC_LOG(INFO) << "Updating sink restrictions from " RTC_LOG(LS_INFO) << "Updating sink restrictions from "
<< (reason ? reason->Name() : std::string("<null>")) << " to " << (reason ? reason->Name() : std::string("<null>"))
<< restrictions.ToString(); << " to " << restrictions.ToString();
worker_queue_->PostTask(ToQueuedTask( worker_queue_->PostTask(ToQueuedTask(
task_safety_, [this, restrictions = std::move(restrictions)]() { task_safety_, [this, restrictions = std::move(restrictions)]() {
RTC_DCHECK_RUN_ON(worker_queue_); RTC_DCHECK_RUN_ON(worker_queue_);

6
video/video_stream_encoder_unittest.cc
View File

@ -510,7 +510,7 @@ class AdaptingFrameForwarder : public test::FrameForwarder {
int out_width = 0; int out_width = 0;
int out_height = 0; int out_height = 0;
if (adaption_enabled()) { if (adaption_enabled()) {
RTC_DLOG(INFO) << "IncomingCapturedFrame: AdaptFrameResolution()" RTC_DLOG(LS_INFO) << "IncomingCapturedFrame: AdaptFrameResolution()"
<< "w=" << video_frame.width() << "w=" << video_frame.width()
<< "h=" << video_frame.height(); << "h=" << video_frame.height();
if (adapter_.AdaptFrameResolution( if (adapter_.AdaptFrameResolution(
@ -540,7 +540,7 @@ class AdaptingFrameForwarder : public test::FrameForwarder {
last_height_ = absl::nullopt; last_height_ = absl::nullopt;
} }
} else { } else {
RTC_DLOG(INFO) << "IncomingCapturedFrame: adaptation not enabled"; RTC_DLOG(LS_INFO) << "IncomingCapturedFrame: adaptation not enabled";
test::FrameForwarder::IncomingCapturedFrame(video_frame); test::FrameForwarder::IncomingCapturedFrame(video_frame);
last_width_.emplace(video_frame.width()); last_width_.emplace(video_frame.width());
last_height_.emplace(video_frame.height()); last_height_.emplace(video_frame.height());
@ -1352,7 +1352,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
} }
log << "]"; log << "]";
} }
RTC_DLOG(INFO) << "OnVideoLayersAllocationUpdated " << log.str(); RTC_DLOG(LS_INFO) << "OnVideoLayersAllocationUpdated " << log.str();
} }
TimeController* const time_controller_; TimeController* const time_controller_;