6b02eea6ac
BUG=3206 R=niklas.enbom@webrtc.org Review URL: https://webrtc-codereview.appspot.com/14429004 git-svn-id: http://webrtc.googlecode.com/svn/trunk@6103 4adac7df-926f-26a2-2b94-8c16560cd09d
597 lines
20 KiB
C++
597 lines
20 KiB
C++
/*
|
|
* Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#include "webrtc/voice_engine/voe_file_impl.h"
|
|
|
|
#include "webrtc/modules/media_file/interface/media_file.h"
|
|
#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
|
|
#include "webrtc/system_wrappers/interface/file_wrapper.h"
|
|
#include "webrtc/system_wrappers/interface/trace.h"
|
|
#include "webrtc/voice_engine/channel.h"
|
|
#include "webrtc/voice_engine/include/voe_errors.h"
|
|
#include "webrtc/voice_engine/output_mixer.h"
|
|
#include "webrtc/voice_engine/transmit_mixer.h"
|
|
#include "webrtc/voice_engine/voice_engine_impl.h"
|
|
|
|
namespace webrtc {
|
|
|
|
VoEFile* VoEFile::GetInterface(VoiceEngine* voiceEngine)
|
|
{
|
|
#ifndef WEBRTC_VOICE_ENGINE_FILE_API
|
|
return NULL;
|
|
#else
|
|
if (NULL == voiceEngine)
|
|
{
|
|
return NULL;
|
|
}
|
|
VoiceEngineImpl* s = static_cast<VoiceEngineImpl*>(voiceEngine);
|
|
s->AddRef();
|
|
return s;
|
|
#endif
|
|
}
|
|
|
|
#ifdef WEBRTC_VOICE_ENGINE_FILE_API
|
|
|
|
VoEFileImpl::VoEFileImpl(voe::SharedData* shared) : _shared(shared)
|
|
{
|
|
WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_shared->instance_id(), -1),
|
|
"VoEFileImpl::VoEFileImpl() - ctor");
|
|
}
|
|
|
|
VoEFileImpl::~VoEFileImpl()
|
|
{
|
|
WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_shared->instance_id(), -1),
|
|
"VoEFileImpl::~VoEFileImpl() - dtor");
|
|
}
|
|
|
|
int VoEFileImpl::StartPlayingFileLocally(
|
|
int channel,
|
|
const char fileNameUTF8[1024],
|
|
bool loop, FileFormats format,
|
|
float volumeScaling,
|
|
int startPointMs,
|
|
int stopPointMs)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
|
|
"StartPlayingFileLocally(channel=%d, fileNameUTF8[]=%s, "
|
|
"loop=%d, format=%d, volumeScaling=%5.3f, startPointMs=%d,"
|
|
" stopPointMs=%d)",
|
|
channel, fileNameUTF8, loop, format, volumeScaling,
|
|
startPointMs, stopPointMs);
|
|
assert(1024 == FileWrapper::kMaxFileNameSize);
|
|
if (!_shared->statistics().Initialized())
|
|
{
|
|
_shared->SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
voe::ChannelOwner ch = _shared->channel_manager().GetChannel(channel);
|
|
voe::Channel* channelPtr = ch.channel();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"StartPlayingFileLocally() failed to locate channel");
|
|
return -1;
|
|
}
|
|
|
|
return channelPtr->StartPlayingFileLocally(fileNameUTF8,
|
|
loop,
|
|
format,
|
|
startPointMs,
|
|
volumeScaling,
|
|
stopPointMs,
|
|
NULL);
|
|
}
|
|
|
|
int VoEFileImpl::StartPlayingFileLocally(int channel,
|
|
InStream* stream,
|
|
FileFormats format,
|
|
float volumeScaling,
|
|
int startPointMs,
|
|
int stopPointMs)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
|
|
"StartPlayingFileLocally(channel=%d, stream, format=%d, "
|
|
"volumeScaling=%5.3f, startPointMs=%d, stopPointMs=%d)",
|
|
channel, format, volumeScaling, startPointMs, stopPointMs);
|
|
|
|
if (!_shared->statistics().Initialized())
|
|
{
|
|
_shared->SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
|
|
voe::ChannelOwner ch = _shared->channel_manager().GetChannel(channel);
|
|
voe::Channel* channelPtr = ch.channel();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"StartPlayingFileLocally() failed to locate channel");
|
|
return -1;
|
|
}
|
|
|
|
return channelPtr->StartPlayingFileLocally(stream,
|
|
format,
|
|
startPointMs,
|
|
volumeScaling,
|
|
stopPointMs,
|
|
NULL);
|
|
}
|
|
|
|
int VoEFileImpl::StopPlayingFileLocally(int channel)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
|
|
"StopPlayingFileLocally()");
|
|
if (!_shared->statistics().Initialized())
|
|
{
|
|
_shared->SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
voe::ChannelOwner ch = _shared->channel_manager().GetChannel(channel);
|
|
voe::Channel* channelPtr = ch.channel();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"StopPlayingFileLocally() failed to locate channel");
|
|
return -1;
|
|
}
|
|
return channelPtr->StopPlayingFileLocally();
|
|
}
|
|
|
|
int VoEFileImpl::IsPlayingFileLocally(int channel)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
|
|
"IsPlayingFileLocally(channel=%d)", channel);
|
|
if (!_shared->statistics().Initialized())
|
|
{
|
|
_shared->SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
voe::ChannelOwner ch = _shared->channel_manager().GetChannel(channel);
|
|
voe::Channel* channelPtr = ch.channel();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"StopPlayingFileLocally() failed to locate channel");
|
|
return -1;
|
|
}
|
|
return channelPtr->IsPlayingFileLocally();
|
|
}
|
|
|
|
int VoEFileImpl::StartPlayingFileAsMicrophone(int channel,
|
|
const char fileNameUTF8[1024],
|
|
bool loop,
|
|
bool mixWithMicrophone,
|
|
FileFormats format,
|
|
float volumeScaling)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
|
|
"StartPlayingFileAsMicrophone(channel=%d, fileNameUTF8=%s, "
|
|
"loop=%d, mixWithMicrophone=%d, format=%d, "
|
|
"volumeScaling=%5.3f)",
|
|
channel, fileNameUTF8, loop, mixWithMicrophone, format,
|
|
volumeScaling);
|
|
assert(1024 == FileWrapper::kMaxFileNameSize);
|
|
if (!_shared->statistics().Initialized())
|
|
{
|
|
_shared->SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
|
|
const uint32_t startPointMs(0);
|
|
const uint32_t stopPointMs(0);
|
|
|
|
if (channel == -1)
|
|
{
|
|
int res = _shared->transmit_mixer()->StartPlayingFileAsMicrophone(
|
|
fileNameUTF8,
|
|
loop,
|
|
format,
|
|
startPointMs,
|
|
volumeScaling,
|
|
stopPointMs,
|
|
NULL);
|
|
if (res)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceVoice,
|
|
VoEId(_shared->instance_id(), -1),
|
|
"StartPlayingFileAsMicrophone() failed to start playing file");
|
|
return(-1);
|
|
}
|
|
else
|
|
{
|
|
_shared->transmit_mixer()->SetMixWithMicStatus(mixWithMicrophone);
|
|
return(0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Add file after demultiplexing <=> affects one channel only
|
|
voe::ChannelOwner ch = _shared->channel_manager().GetChannel(channel);
|
|
voe::Channel* channelPtr = ch.channel();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"StartPlayingFileAsMicrophone() failed to locate channel");
|
|
return -1;
|
|
}
|
|
|
|
int res = channelPtr->StartPlayingFileAsMicrophone(fileNameUTF8,
|
|
loop,
|
|
format,
|
|
startPointMs,
|
|
volumeScaling,
|
|
stopPointMs,
|
|
NULL);
|
|
if (res)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceVoice,
|
|
VoEId(_shared->instance_id(), -1),
|
|
"StartPlayingFileAsMicrophone() failed to start playing file");
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
channelPtr->SetMixWithMicStatus(mixWithMicrophone);
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
int VoEFileImpl::StartPlayingFileAsMicrophone(int channel,
|
|
InStream* stream,
|
|
bool mixWithMicrophone,
|
|
FileFormats format,
|
|
float volumeScaling)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
|
|
"StartPlayingFileAsMicrophone(channel=%d, stream,"
|
|
" mixWithMicrophone=%d, format=%d, volumeScaling=%5.3f)",
|
|
channel, mixWithMicrophone, format, volumeScaling);
|
|
|
|
if (!_shared->statistics().Initialized())
|
|
{
|
|
_shared->SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
|
|
const uint32_t startPointMs(0);
|
|
const uint32_t stopPointMs(0);
|
|
|
|
if (channel == -1)
|
|
{
|
|
int res = _shared->transmit_mixer()->StartPlayingFileAsMicrophone(
|
|
stream,
|
|
format,
|
|
startPointMs,
|
|
volumeScaling,
|
|
stopPointMs,
|
|
NULL);
|
|
if (res)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceVoice,
|
|
VoEId(_shared->instance_id(), -1),
|
|
"StartPlayingFileAsMicrophone() failed to start "
|
|
"playing stream");
|
|
return(-1);
|
|
}
|
|
else
|
|
{
|
|
_shared->transmit_mixer()->SetMixWithMicStatus(mixWithMicrophone);
|
|
return(0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Add file after demultiplexing <=> affects one channel only
|
|
voe::ChannelOwner ch = _shared->channel_manager().GetChannel(channel);
|
|
voe::Channel* channelPtr = ch.channel();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"StartPlayingFileAsMicrophone() failed to locate channel");
|
|
return -1;
|
|
}
|
|
|
|
int res = channelPtr->StartPlayingFileAsMicrophone(
|
|
stream, format, startPointMs, volumeScaling, stopPointMs, NULL);
|
|
if (res)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceVoice,
|
|
VoEId(_shared->instance_id(), -1),
|
|
"StartPlayingFileAsMicrophone() failed to start "
|
|
"playing stream");
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
channelPtr->SetMixWithMicStatus(mixWithMicrophone);
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
int VoEFileImpl::StopPlayingFileAsMicrophone(int channel)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
|
|
"StopPlayingFileAsMicrophone(channel=%d)", channel);
|
|
if (!_shared->statistics().Initialized())
|
|
{
|
|
_shared->SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
if (channel == -1)
|
|
{
|
|
// Stop adding file before demultiplexing <=> affects all channels
|
|
return _shared->transmit_mixer()->StopPlayingFileAsMicrophone();
|
|
}
|
|
else
|
|
{
|
|
// Stop adding file after demultiplexing <=> affects one channel only
|
|
voe::ChannelOwner ch = _shared->channel_manager().GetChannel(channel);
|
|
voe::Channel* channelPtr = ch.channel();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"StopPlayingFileAsMicrophone() failed to locate channel");
|
|
return -1;
|
|
}
|
|
return channelPtr->StopPlayingFileAsMicrophone();
|
|
}
|
|
}
|
|
|
|
int VoEFileImpl::IsPlayingFileAsMicrophone(int channel)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
|
|
"IsPlayingFileAsMicrophone(channel=%d)", channel);
|
|
if (!_shared->statistics().Initialized())
|
|
{
|
|
_shared->SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
if (channel == -1)
|
|
{
|
|
return _shared->transmit_mixer()->IsPlayingFileAsMicrophone();
|
|
}
|
|
else
|
|
{
|
|
// Stop adding file after demultiplexing <=> affects one channel only
|
|
voe::ChannelOwner ch = _shared->channel_manager().GetChannel(channel);
|
|
voe::Channel* channelPtr = ch.channel();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"IsPlayingFileAsMicrophone() failed to locate channel");
|
|
return -1;
|
|
}
|
|
return channelPtr->IsPlayingFileAsMicrophone();
|
|
}
|
|
}
|
|
|
|
int VoEFileImpl::StartRecordingPlayout(
|
|
int channel, const char* fileNameUTF8, CodecInst* compression,
|
|
int maxSizeBytes)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
|
|
"StartRecordingPlayout(channel=%d, fileNameUTF8=%s, "
|
|
"compression, maxSizeBytes=%d)",
|
|
channel, fileNameUTF8, maxSizeBytes);
|
|
assert(1024 == FileWrapper::kMaxFileNameSize);
|
|
|
|
if (!_shared->statistics().Initialized())
|
|
{
|
|
_shared->SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
if (channel == -1)
|
|
{
|
|
return _shared->output_mixer()->StartRecordingPlayout
|
|
(fileNameUTF8, compression);
|
|
}
|
|
else
|
|
{
|
|
// Add file after demultiplexing <=> affects one channel only
|
|
voe::ChannelOwner ch = _shared->channel_manager().GetChannel(channel);
|
|
voe::Channel* channelPtr = ch.channel();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"StartRecordingPlayout() failed to locate channel");
|
|
return -1;
|
|
}
|
|
return channelPtr->StartRecordingPlayout(fileNameUTF8, compression);
|
|
}
|
|
}
|
|
|
|
int VoEFileImpl::StartRecordingPlayout(
|
|
int channel, OutStream* stream, CodecInst* compression)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
|
|
"StartRecordingPlayout(channel=%d, stream, compression)",
|
|
channel);
|
|
if (!_shared->statistics().Initialized())
|
|
{
|
|
_shared->SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
if (channel == -1)
|
|
{
|
|
return _shared->output_mixer()->
|
|
StartRecordingPlayout(stream, compression);
|
|
}
|
|
else
|
|
{
|
|
voe::ChannelOwner ch = _shared->channel_manager().GetChannel(channel);
|
|
voe::Channel* channelPtr = ch.channel();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"StartRecordingPlayout() failed to locate channel");
|
|
return -1;
|
|
}
|
|
return channelPtr->StartRecordingPlayout(stream, compression);
|
|
}
|
|
}
|
|
|
|
int VoEFileImpl::StopRecordingPlayout(int channel)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
|
|
"StopRecordingPlayout(channel=%d)", channel);
|
|
if (!_shared->statistics().Initialized())
|
|
{
|
|
_shared->SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
if (channel == -1)
|
|
{
|
|
return _shared->output_mixer()->StopRecordingPlayout();
|
|
}
|
|
else
|
|
{
|
|
voe::ChannelOwner ch = _shared->channel_manager().GetChannel(channel);
|
|
voe::Channel* channelPtr = ch.channel();
|
|
if (channelPtr == NULL)
|
|
{
|
|
_shared->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
|
|
"StopRecordingPlayout() failed to locate channel");
|
|
return -1;
|
|
}
|
|
return channelPtr->StopRecordingPlayout();
|
|
}
|
|
}
|
|
|
|
int VoEFileImpl::StartRecordingMicrophone(
|
|
const char* fileNameUTF8, CodecInst* compression, int maxSizeBytes)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
|
|
"StartRecordingMicrophone(fileNameUTF8=%s, compression, "
|
|
"maxSizeBytes=%d)", fileNameUTF8, maxSizeBytes);
|
|
assert(1024 == FileWrapper::kMaxFileNameSize);
|
|
|
|
if (!_shared->statistics().Initialized())
|
|
{
|
|
_shared->SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
if (_shared->transmit_mixer()->StartRecordingMicrophone(fileNameUTF8,
|
|
compression))
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceVoice,
|
|
VoEId(_shared->instance_id(), -1),
|
|
"StartRecordingMicrophone() failed to start recording");
|
|
return -1;
|
|
}
|
|
if (_shared->audio_device()->Recording())
|
|
{
|
|
return 0;
|
|
}
|
|
if (!_shared->ext_recording())
|
|
{
|
|
if (_shared->audio_device()->InitRecording() != 0)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceVoice,
|
|
VoEId(_shared->instance_id(), -1),
|
|
"StartRecordingMicrophone() failed to initialize recording");
|
|
return -1;
|
|
}
|
|
if (_shared->audio_device()->StartRecording() != 0)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceVoice,
|
|
VoEId(_shared->instance_id(), -1),
|
|
"StartRecordingMicrophone() failed to start recording");
|
|
return -1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int VoEFileImpl::StartRecordingMicrophone(
|
|
OutStream* stream, CodecInst* compression)
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
|
|
"StartRecordingMicrophone(stream, compression)");
|
|
|
|
if (!_shared->statistics().Initialized())
|
|
{
|
|
_shared->SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
if (_shared->transmit_mixer()->StartRecordingMicrophone(stream,
|
|
compression) == -1)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceVoice,
|
|
VoEId(_shared->instance_id(), -1),
|
|
"StartRecordingMicrophone() failed to start recording");
|
|
return -1;
|
|
}
|
|
if (_shared->audio_device()->Recording())
|
|
{
|
|
return 0;
|
|
}
|
|
if (!_shared->ext_recording())
|
|
{
|
|
if (_shared->audio_device()->InitRecording() != 0)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceVoice,
|
|
VoEId(_shared->instance_id(), -1),
|
|
"StartRecordingMicrophone() failed to initialize recording");
|
|
return -1;
|
|
}
|
|
if (_shared->audio_device()->StartRecording() != 0)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceVoice,
|
|
VoEId(_shared->instance_id(), -1),
|
|
"StartRecordingMicrophone() failed to start recording");
|
|
return -1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int VoEFileImpl::StopRecordingMicrophone()
|
|
{
|
|
WEBRTC_TRACE(kTraceApiCall, kTraceVoice, VoEId(_shared->instance_id(), -1),
|
|
"StopRecordingMicrophone()");
|
|
if (!_shared->statistics().Initialized())
|
|
{
|
|
_shared->SetLastError(VE_NOT_INITED, kTraceError);
|
|
return -1;
|
|
}
|
|
|
|
int err = 0;
|
|
|
|
// TODO(xians): consider removing Start/StopRecording() in
|
|
// Start/StopRecordingMicrophone() if no channel is recording.
|
|
if (_shared->NumOfSendingChannels() == 0 &&
|
|
_shared->audio_device()->Recording())
|
|
{
|
|
// Stop audio-device recording if no channel is recording
|
|
if (_shared->audio_device()->StopRecording() != 0)
|
|
{
|
|
_shared->SetLastError(VE_CANNOT_STOP_RECORDING, kTraceError,
|
|
"StopRecordingMicrophone() failed to stop recording");
|
|
err = -1;
|
|
}
|
|
}
|
|
|
|
if (_shared->transmit_mixer()->StopRecordingMicrophone() != 0)
|
|
{
|
|
WEBRTC_TRACE(kTraceError, kTraceVoice,
|
|
VoEId(_shared->instance_id(), -1),
|
|
"StopRecordingMicrophone() failed to stop recording to mixer");
|
|
err = -1;
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
#endif // #ifdef WEBRTC_VOICE_ENGINE_FILE_API
|
|
|
|
} // namespace webrtc
|