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

FileRecorder + FilePlayer: Let Create functions return unique_ptr

Browse Source 
Because passing ownership in raw pointers makes kittens cry.

This also means we can ditch the Destroy functions and the protected
destructors. (Well, almost. We need to keep the old CreateFilePlayer
and DestroyFilePlayer around for a little while longer because of an
external caller.)

Review-Url: https://codereview.webrtc.org/2049683003
Cr-Commit-Position: refs/heads/master@{#13797}
This commit is contained in:
kwiberg 2016-08-17 07:31:12 -07:00 committed by Commit bot
parent 4466782ae4
commit 5a25d9504a
13 changed files with 368 additions and 484 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
webrtc/modules/audio_mixer/audio_mixer.cc
View File

@ -78,7 +78,6 @@ AudioMixer::AudioMixer(uint32_t instanceId)
_panLeft(1.0f),
_panRight(1.0f),
_mixingFrequencyHz(8000),
_outputFileRecorderPtr(NULL),
_outputFileRecording(false) {
WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, -1),
"AudioMixer::AudioMixer() - ctor");
@ -102,8 +101,6 @@ AudioMixer::~AudioMixer() {
if (_outputFileRecorderPtr) {
_outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
_outputFileRecorderPtr->StopRecording();
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
}
}
delete &_mixerModule;
@ -226,11 +223,8 @@ int AudioMixer::StartRecordingPlayout(const char* fileName,
rtc::CritScope cs(&_fileCritSect);
// Destroy the old instance
if (_outputFileRecorderPtr) {
_outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
}
_outputFileRecorderPtr =
@ -248,8 +242,7 @@ int AudioMixer::StartRecordingPlayout(const char* fileName,
VE_BAD_FILE, kTraceError,
"StartRecordingAudioFile() failed to start file recording");
_outputFileRecorderPtr->StopRecording();
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
_outputFileRecorderPtr.reset();
return -1;
}
_outputFileRecorderPtr->RegisterModuleFileCallback(this);
@ -292,11 +285,8 @@ int AudioMixer::StartRecordingPlayout(OutStream* stream,
rtc::CritScope cs(&_fileCritSect);
// Destroy the old instance
if (_outputFileRecorderPtr) {
_outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
}
_outputFileRecorderPtr =
@ -314,8 +304,7 @@ int AudioMixer::StartRecordingPlayout(OutStream* stream,
VE_BAD_FILE, kTraceError,
"StartRecordingAudioFile() failed to start file recording");
_outputFileRecorderPtr->StopRecording();
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
_outputFileRecorderPtr.reset();
return -1;
}
@ -344,8 +333,7 @@ int AudioMixer::StopRecordingPlayout() {
return -1;
}
_outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
_outputFileRecorderPtr.reset();
_outputFileRecording = false;
return 0;

4
webrtc/modules/audio_mixer/audio_mixer.h
View File

@ -11,6 +11,8 @@
#ifndef WEBRTC_MODULES_AUDIO_MIXER_AUDIO_MIXER_H_
#define WEBRTC_MODULES_AUDIO_MIXER_AUDIO_MIXER_H_
#include <memory>
#include "webrtc/base/criticalsection.h"
#include "webrtc/common_audio/resampler/include/push_resampler.h"
#include "webrtc/common_types.h"
@ -107,7 +109,7 @@ class AudioMixer : public FileCallback {
float _panLeft;
float _panRight;
int _mixingFrequencyHz;
FileRecorder* _outputFileRecorderPtr;
std::unique_ptr<FileRecorder> _outputFileRecorderPtr;
bool _outputFileRecording;
};

14
webrtc/modules/utility/include/file_player.h
View File

@ -11,12 +11,15 @@
#ifndef WEBRTC_MODULES_UTILITY_INCLUDE_FILE_PLAYER_H_
#define WEBRTC_MODULES_UTILITY_INCLUDE_FILE_PLAYER_H_
#include <memory>
#include "webrtc/common_types.h"
#include "webrtc/engine_configurations.h"
#include "webrtc/modules/include/module_common_types.h"
#include "webrtc/typedefs.h"
namespace webrtc {
class FileCallback;
class FilePlayer {
@ -26,11 +29,17 @@ class FilePlayer {
enum { MAX_AUDIO_BUFFER_IN_BYTES = MAX_AUDIO_BUFFER_IN_SAMPLES * 2 };
// Note: will return NULL for unsupported formats.
static std::unique_ptr<FilePlayer> NewFilePlayer(
const uint32_t instanceID,
const FileFormats fileFormat);
// Deprecated creation/destruction functions. Use NewFilePlayer instead.
static FilePlayer* CreateFilePlayer(const uint32_t instanceID,
const FileFormats fileFormat);
static void DestroyFilePlayer(FilePlayer* player);
virtual ~FilePlayer() = default;
// Read 10 ms of audio at |frequencyInHz| to |outBuffer|. |lengthInSamples|
// will be set to the number of samples read (not the number of samples per
// channel).
@ -72,9 +81,6 @@ class FilePlayer {
// Note: scaleFactor is in the range [0.0 - 2.0]
virtual int32_t SetAudioScaling(float scaleFactor) = 0;
protected:
virtual ~FilePlayer() {}
};
} // namespace webrtc
#endif // WEBRTC_MODULES_UTILITY_INCLUDE_FILE_PLAYER_H_

13
webrtc/modules/utility/include/file_recorder.h
View File

@ -11,6 +11,8 @@
#ifndef WEBRTC_MODULES_UTILITY_INCLUDE_FILE_RECORDER_H_
#define WEBRTC_MODULES_UTILITY_INCLUDE_FILE_RECORDER_H_
#include <memory>
#include "webrtc/common_types.h"
#include "webrtc/engine_configurations.h"
#include "webrtc/modules/include/module_common_types.h"
@ -22,10 +24,11 @@ namespace webrtc {
class FileRecorder {
public:
// Note: will return NULL for unsupported formats.
static FileRecorder* CreateFileRecorder(const uint32_t instanceID,
const FileFormats fileFormat);
static std::unique_ptr<FileRecorder> CreateFileRecorder(
const uint32_t instanceID,
const FileFormats fileFormat);
static void DestroyFileRecorder(FileRecorder* recorder);
virtual ~FileRecorder() = default;
virtual int32_t RegisterModuleFileCallback(FileCallback* callback) = 0;
@ -49,9 +52,7 @@ class FileRecorder {
// Write frame to file. Frame should contain 10ms of un-ecoded audio data.
virtual int32_t RecordAudioToFile(const AudioFrame& frame) = 0;
protected:
virtual ~FileRecorder() {}
};
} // namespace webrtc
#endif // WEBRTC_MODULES_UTILITY_INCLUDE_FILE_RECORDER_H_

22
webrtc/modules/utility/source/file_player.cc
View File

@ -53,16 +53,14 @@ class FilePlayerImpl : public FilePlayer {
virtual int32_t Frequency() const;
virtual int32_t SetAudioScaling(float scaleFactor);
protected:
private:
int32_t SetUpAudioDecoder();
uint32_t _instanceID;
const FileFormats _fileFormat;
MediaFile& _fileModule;
uint32_t _decodedLengthInMS;
private:
AudioCoder _audioDecoder;
CodecInst _codec;
@ -75,8 +73,7 @@ class FilePlayerImpl : public FilePlayer {
FilePlayerImpl::FilePlayerImpl(const uint32_t instanceID,
const FileFormats fileFormat)
: _instanceID(instanceID),
_fileFormat(fileFormat),
: _fileFormat(fileFormat),
_fileModule(*MediaFile::CreateMediaFile(instanceID)),
_decodedLengthInMS(0),
_audioDecoder(instanceID),
@ -373,8 +370,9 @@ int32_t FilePlayerImpl::SetUpAudioDecoder() {
} // namespace
FilePlayer* FilePlayer::CreateFilePlayer(uint32_t instanceID,
FileFormats fileFormat) {
std::unique_ptr<FilePlayer> FilePlayer::NewFilePlayer(
uint32_t instanceID,
FileFormats fileFormat) {
switch (fileFormat) {
case kFileFormatWavFile:
case kFileFormatCompressedFile:
@ -383,13 +381,19 @@ FilePlayer* FilePlayer::CreateFilePlayer(uint32_t instanceID,
case kFileFormatPcm8kHzFile:
case kFileFormatPcm32kHzFile:
// audio formats
return new FilePlayerImpl(instanceID, fileFormat);
return std::unique_ptr<FilePlayer>(
new FilePlayerImpl(instanceID, fileFormat));
default:
assert(false);
return NULL;
return nullptr;
}
}
FilePlayer* FilePlayer::CreateFilePlayer(uint32_t instanceID,
FileFormats fileFormat) {
return FilePlayer::NewFilePlayer(instanceID, fileFormat).release();
}
void FilePlayer::DestroyFilePlayer(FilePlayer* player) {
delete player;
}

8
webrtc/modules/utility/source/file_player_unittests.cc
View File

@ -13,6 +13,8 @@
#include "webrtc/modules/utility/include/file_player.h"
#include <stdio.h>
#include <memory>
#include <string>
#include "gflags/gflags.h"
@ -32,7 +34,7 @@ class FilePlayerTest : public ::testing::Test {
static const int kSampleRateHz = 8000;
FilePlayerTest()
: player_(FilePlayer::CreateFilePlayer(kId, kFileFormat)),
: player_(FilePlayer::NewFilePlayer(kId, kFileFormat)),
output_file_(NULL) {}
void SetUp() override {
@ -49,8 +51,6 @@ class FilePlayerTest : public ::testing::Test {
fclose(output_file_);
}
~FilePlayerTest() { FilePlayer::DestroyFilePlayer(player_); }
void PlayFileAndCheck(const std::string& input_file,
const std::string& ref_checksum,
int output_length_ms) {
@ -76,7 +76,7 @@ class FilePlayerTest : public ::testing::Test {
rtc::hex_encode(checksum_result, sizeof(checksum_result)));
}
FilePlayer* player_;
std::unique_ptr<FilePlayer> player_;
FILE* output_file_;
};

17
webrtc/modules/utility/source/file_recorder.cc
View File

@ -40,7 +40,7 @@ class CriticalSectionWrapper;
class FileRecorderImpl : public FileRecorder {
public:
FileRecorderImpl(uint32_t instanceID, FileFormats fileFormat);
virtual ~FileRecorderImpl();
~FileRecorderImpl() override;
// FileRecorder functions.
int32_t RegisterModuleFileCallback(FileCallback* callback) override;
@ -56,7 +56,7 @@ class FileRecorderImpl : public FileRecorder {
int32_t codec_info(CodecInst& codecInst) const override;
int32_t RecordAudioToFile(const AudioFrame& frame) override;
protected:
private:
int32_t WriteEncodedAudioData(const int8_t* audioBuffer, size_t bufferLength);
int32_t SetUpAudioEncoder();
@ -65,7 +65,6 @@ class FileRecorderImpl : public FileRecorder {
FileFormats _fileFormat;
MediaFile* _moduleFile;
private:
CodecInst codec_info_;
int8_t _audioBuffer[MAX_AUDIO_BUFFER_IN_BYTES];
AudioCoder _audioEncoder;
@ -255,13 +254,11 @@ int32_t FileRecorderImpl::WriteEncodedAudioData(const int8_t* audioBuffer,
} // namespace
FileRecorder* FileRecorder::CreateFileRecorder(uint32_t instanceID,
FileFormats fileFormat) {
return new FileRecorderImpl(instanceID, fileFormat);
}
void FileRecorder::DestroyFileRecorder(FileRecorder* recorder) {
delete recorder;
std::unique_ptr<FileRecorder> FileRecorder::CreateFileRecorder(
uint32_t instanceID,
FileFormats fileFormat) {
return std::unique_ptr<FileRecorder>(
new FileRecorderImpl(instanceID, fileFormat));
}
} // namespace webrtc

209
webrtc/voice_engine/channel.cc
View File

@ -677,8 +677,8 @@ MixerParticipant::AudioFrameInfo Channel::GetAudioFrameWithMuted(
{
rtc::CritScope cs(&_fileCritSect);
if (_outputFileRecording && _outputFileRecorderPtr) {
_outputFileRecorderPtr->RecordAudioToFile(*audioFrame);
if (_outputFileRecording && output_file_recorder_) {
output_file_recorder_->RecordAudioToFile(*audioFrame);
}
}
@ -742,9 +742,9 @@ int32_t Channel::NeededFrequency(int32_t id) const {
// limit the spectrum anyway.
if (channel_state_.Get().output_file_playing) {
rtc::CritScope cs(&_fileCritSect);
if (_outputFilePlayerPtr) {
if (_outputFilePlayerPtr->Frequency() > highestNeeded) {
highestNeeded = _outputFilePlayerPtr->Frequency();
if (output_file_player_) {
if (output_file_player_->Frequency() > highestNeeded) {
highestNeeded = output_file_player_->Frequency();
}
}
}
@ -847,9 +847,6 @@ Channel::Channel(int32_t channelId,
telephone_event_handler_(rtp_receiver_->GetTelephoneEventHandler()),
_outputAudioLevel(),
_externalTransport(false),
_inputFilePlayerPtr(NULL),
_outputFilePlayerPtr(NULL),
_outputFileRecorderPtr(NULL),
// Avoid conflict with other channels by adding 1024 - 1026,
// won't use as much as 1024 channels.
_inputFilePlayerId(VoEModuleId(instanceId, channelId) + 1024),
@ -970,23 +967,17 @@ Channel::~Channel() {
{
rtc::CritScope cs(&_fileCritSect);
if (_inputFilePlayerPtr) {
_inputFilePlayerPtr->RegisterModuleFileCallback(NULL);
_inputFilePlayerPtr->StopPlayingFile();
FilePlayer::DestroyFilePlayer(_inputFilePlayerPtr);
_inputFilePlayerPtr = NULL;
if (input_file_player_) {
input_file_player_->RegisterModuleFileCallback(NULL);
input_file_player_->StopPlayingFile();
}
if (_outputFilePlayerPtr) {
_outputFilePlayerPtr->RegisterModuleFileCallback(NULL);
_outputFilePlayerPtr->StopPlayingFile();
FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
_outputFilePlayerPtr = NULL;
if (output_file_player_) {
output_file_player_->RegisterModuleFileCallback(NULL);
output_file_player_->StopPlayingFile();
}
if (_outputFileRecorderPtr) {
_outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
_outputFileRecorderPtr->StopRecording();
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
if (output_file_recorder_) {
output_file_recorder_->RegisterModuleFileCallback(NULL);
output_file_recorder_->StopRecording();
}
}
@ -1769,16 +1760,15 @@ int Channel::StartPlayingFileLocally(const char* fileName,
{
rtc::CritScope cs(&_fileCritSect);
if (_outputFilePlayerPtr) {
_outputFilePlayerPtr->RegisterModuleFileCallback(NULL);
FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
_outputFilePlayerPtr = NULL;
if (output_file_player_) {
output_file_player_->RegisterModuleFileCallback(NULL);
output_file_player_.reset();
}
_outputFilePlayerPtr = FilePlayer::CreateFilePlayer(
output_file_player_ = FilePlayer::NewFilePlayer(
_outputFilePlayerId, (const FileFormats)format);
if (_outputFilePlayerPtr == NULL) {
if (!output_file_player_) {
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartPlayingFileLocally() filePlayer format is not correct");
@ -1787,18 +1777,17 @@ int Channel::StartPlayingFileLocally(const char* fileName,
const uint32_t notificationTime(0);
if (_outputFilePlayerPtr->StartPlayingFile(
if (output_file_player_->StartPlayingFile(
fileName, loop, startPosition, volumeScaling, notificationTime,
stopPosition, (const CodecInst*)codecInst) != 0) {
_engineStatisticsPtr->SetLastError(
VE_BAD_FILE, kTraceError,
"StartPlayingFile() failed to start file playout");
_outputFilePlayerPtr->StopPlayingFile();
FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
_outputFilePlayerPtr = NULL;
output_file_player_->StopPlayingFile();
output_file_player_.reset();
return -1;
}
_outputFilePlayerPtr->RegisterModuleFileCallback(this);
output_file_player_->RegisterModuleFileCallback(this);
channel_state_.SetOutputFilePlaying(true);
}
@ -1837,17 +1826,16 @@ int Channel::StartPlayingFileLocally(InStream* stream,
rtc::CritScope cs(&_fileCritSect);
// Destroy the old instance
if (_outputFilePlayerPtr) {
_outputFilePlayerPtr->RegisterModuleFileCallback(NULL);
FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
_outputFilePlayerPtr = NULL;
if (output_file_player_) {
output_file_player_->RegisterModuleFileCallback(NULL);
output_file_player_.reset();
}
// Create the instance
_outputFilePlayerPtr = FilePlayer::CreateFilePlayer(
output_file_player_ = FilePlayer::NewFilePlayer(
_outputFilePlayerId, (const FileFormats)format);
if (_outputFilePlayerPtr == NULL) {
if (!output_file_player_) {
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartPlayingFileLocally() filePlayer format isnot correct");
@ -1856,18 +1844,17 @@ int Channel::StartPlayingFileLocally(InStream* stream,
const uint32_t notificationTime(0);
if (_outputFilePlayerPtr->StartPlayingFile(*stream, startPosition,
volumeScaling, notificationTime,
stopPosition, codecInst) != 0) {
if (output_file_player_->StartPlayingFile(*stream, startPosition,
volumeScaling, notificationTime,
stopPosition, codecInst) != 0) {
_engineStatisticsPtr->SetLastError(VE_BAD_FILE, kTraceError,
"StartPlayingFile() failed to "
"start file playout");
_outputFilePlayerPtr->StopPlayingFile();
FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
_outputFilePlayerPtr = NULL;
output_file_player_->StopPlayingFile();
output_file_player_.reset();
return -1;
}
_outputFilePlayerPtr->RegisterModuleFileCallback(this);
output_file_player_->RegisterModuleFileCallback(this);
channel_state_.SetOutputFilePlaying(true);
}
@ -1888,15 +1875,14 @@ int Channel::StopPlayingFileLocally() {
{
rtc::CritScope cs(&_fileCritSect);
if (_outputFilePlayerPtr->StopPlayingFile() != 0) {
if (output_file_player_->StopPlayingFile() != 0) {
_engineStatisticsPtr->SetLastError(
VE_STOP_RECORDING_FAILED, kTraceError,
"StopPlayingFile() could not stop playing");
return -1;
}
_outputFilePlayerPtr->RegisterModuleFileCallback(NULL);
FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
_outputFilePlayerPtr = NULL;
output_file_player_->RegisterModuleFileCallback(NULL);
output_file_player_.reset();
channel_state_.SetOutputFilePlaying(false);
}
// _fileCritSect cannot be taken while calling
@ -1936,9 +1922,8 @@ int Channel::RegisterFilePlayingToMixer() {
_engineStatisticsPtr->SetLastError(
VE_AUDIO_CONF_MIX_MODULE_ERROR, kTraceError,
"StartPlayingFile() failed to add participant as file to mixer");
_outputFilePlayerPtr->StopPlayingFile();
FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
_outputFilePlayerPtr = NULL;
output_file_player_->StopPlayingFile();
output_file_player_.reset();
return -1;
}
@ -1969,17 +1954,16 @@ int Channel::StartPlayingFileAsMicrophone(const char* fileName,
}
// Destroy the old instance
if (_inputFilePlayerPtr) {
_inputFilePlayerPtr->RegisterModuleFileCallback(NULL);
FilePlayer::DestroyFilePlayer(_inputFilePlayerPtr);
_inputFilePlayerPtr = NULL;
if (input_file_player_) {
input_file_player_->RegisterModuleFileCallback(NULL);
input_file_player_.reset();
}
// Create the instance
_inputFilePlayerPtr = FilePlayer::CreateFilePlayer(_inputFilePlayerId,
(const FileFormats)format);
input_file_player_ = FilePlayer::NewFilePlayer(_inputFilePlayerId,
(const FileFormats)format);
if (_inputFilePlayerPtr == NULL) {
if (!input_file_player_) {
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartPlayingFileAsMicrophone() filePlayer format isnot correct");
@ -1988,18 +1972,17 @@ int Channel::StartPlayingFileAsMicrophone(const char* fileName,
const uint32_t notificationTime(0);
if (_inputFilePlayerPtr->StartPlayingFile(
if (input_file_player_->StartPlayingFile(
fileName, loop, startPosition, volumeScaling, notificationTime,
stopPosition, (const CodecInst*)codecInst) != 0) {
_engineStatisticsPtr->SetLastError(
VE_BAD_FILE, kTraceError,
"StartPlayingFile() failed to start file playout");
_inputFilePlayerPtr->StopPlayingFile();
FilePlayer::DestroyFilePlayer(_inputFilePlayerPtr);
_inputFilePlayerPtr = NULL;
input_file_player_->StopPlayingFile();
input_file_player_.reset();
return -1;
}
_inputFilePlayerPtr->RegisterModuleFileCallback(this);
input_file_player_->RegisterModuleFileCallback(this);
channel_state_.SetInputFilePlaying(true);
return 0;
@ -2033,17 +2016,16 @@ int Channel::StartPlayingFileAsMicrophone(InStream* stream,
}
// Destroy the old instance
if (_inputFilePlayerPtr) {
_inputFilePlayerPtr->RegisterModuleFileCallback(NULL);
FilePlayer::DestroyFilePlayer(_inputFilePlayerPtr);
_inputFilePlayerPtr = NULL;
if (input_file_player_) {
input_file_player_->RegisterModuleFileCallback(NULL);
input_file_player_.reset();
}
// Create the instance
_inputFilePlayerPtr = FilePlayer::CreateFilePlayer(_inputFilePlayerId,
(const FileFormats)format);
input_file_player_ = FilePlayer::NewFilePlayer(_inputFilePlayerId,
(const FileFormats)format);
if (_inputFilePlayerPtr == NULL) {
if (!input_file_player_) {
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartPlayingInputFile() filePlayer format isnot correct");
@ -2052,19 +2034,18 @@ int Channel::StartPlayingFileAsMicrophone(InStream* stream,
const uint32_t notificationTime(0);
if (_inputFilePlayerPtr->StartPlayingFile(*stream, startPosition,
volumeScaling, notificationTime,
stopPosition, codecInst) != 0) {
if (input_file_player_->StartPlayingFile(*stream, startPosition,
volumeScaling, notificationTime,
stopPosition, codecInst) != 0) {
_engineStatisticsPtr->SetLastError(VE_BAD_FILE, kTraceError,
"StartPlayingFile() failed to start "
"file playout");
_inputFilePlayerPtr->StopPlayingFile();
FilePlayer::DestroyFilePlayer(_inputFilePlayerPtr);
_inputFilePlayerPtr = NULL;
input_file_player_->StopPlayingFile();
input_file_player_.reset();
return -1;
}
_inputFilePlayerPtr->RegisterModuleFileCallback(this);
input_file_player_->RegisterModuleFileCallback(this);
channel_state_.SetInputFilePlaying(true);
return 0;
@ -2080,15 +2061,14 @@ int Channel::StopPlayingFileAsMicrophone() {
return 0;
}
if (_inputFilePlayerPtr->StopPlayingFile() != 0) {
if (input_file_player_->StopPlayingFile() != 0) {
_engineStatisticsPtr->SetLastError(
VE_STOP_RECORDING_FAILED, kTraceError,
"StopPlayingFile() could not stop playing");
return -1;
}
_inputFilePlayerPtr->RegisterModuleFileCallback(NULL);
FilePlayer::DestroyFilePlayer(_inputFilePlayerPtr);
_inputFilePlayerPtr = NULL;
input_file_player_->RegisterModuleFileCallback(NULL);
input_file_player_.reset();
channel_state_.SetInputFilePlaying(false);
return 0;
@ -2134,32 +2114,30 @@ int Channel::StartRecordingPlayout(const char* fileName,
rtc::CritScope cs(&_fileCritSect);
// Destroy the old instance
if (_outputFileRecorderPtr) {
_outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
if (output_file_recorder_) {
output_file_recorder_->RegisterModuleFileCallback(NULL);
output_file_recorder_.reset();
}
_outputFileRecorderPtr = FileRecorder::CreateFileRecorder(
output_file_recorder_ = FileRecorder::CreateFileRecorder(
_outputFileRecorderId, (const FileFormats)format);
if (_outputFileRecorderPtr == NULL) {
if (!output_file_recorder_) {
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartRecordingPlayout() fileRecorder format isnot correct");
return -1;
}
if (_outputFileRecorderPtr->StartRecordingAudioFile(
if (output_file_recorder_->StartRecordingAudioFile(
fileName, (const CodecInst&)*codecInst, notificationTime) != 0) {
_engineStatisticsPtr->SetLastError(
VE_BAD_FILE, kTraceError,
"StartRecordingAudioFile() failed to start file recording");
_outputFileRecorderPtr->StopRecording();
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
output_file_recorder_->StopRecording();
output_file_recorder_.reset();
return -1;
}
_outputFileRecorderPtr->RegisterModuleFileCallback(this);
output_file_recorder_->RegisterModuleFileCallback(this);
_outputFileRecording = true;
return 0;
@ -2200,33 +2178,31 @@ int Channel::StartRecordingPlayout(OutStream* stream,
rtc::CritScope cs(&_fileCritSect);
// Destroy the old instance
if (_outputFileRecorderPtr) {
_outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
if (output_file_recorder_) {
output_file_recorder_->RegisterModuleFileCallback(NULL);
output_file_recorder_.reset();
}
_outputFileRecorderPtr = FileRecorder::CreateFileRecorder(
output_file_recorder_ = FileRecorder::CreateFileRecorder(
_outputFileRecorderId, (const FileFormats)format);
if (_outputFileRecorderPtr == NULL) {
if (!output_file_recorder_) {
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartRecordingPlayout() fileRecorder format isnot correct");
return -1;
}
if (_outputFileRecorderPtr->StartRecordingAudioFile(*stream, *codecInst,
notificationTime) != 0) {
if (output_file_recorder_->StartRecordingAudioFile(*stream, *codecInst,
notificationTime) != 0) {
_engineStatisticsPtr->SetLastError(VE_BAD_FILE, kTraceError,
"StartRecordingPlayout() failed to "
"start file recording");
_outputFileRecorderPtr->StopRecording();
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
output_file_recorder_->StopRecording();
output_file_recorder_.reset();
return -1;
}
_outputFileRecorderPtr->RegisterModuleFileCallback(this);
output_file_recorder_->RegisterModuleFileCallback(this);
_outputFileRecording = true;
return 0;
@ -2244,15 +2220,14 @@ int Channel::StopRecordingPlayout() {
rtc::CritScope cs(&_fileCritSect);
if (_outputFileRecorderPtr->StopRecording() != 0) {
if (output_file_recorder_->StopRecording() != 0) {
_engineStatisticsPtr->SetLastError(
VE_STOP_RECORDING_FAILED, kTraceError,
"StopRecording() could not stop recording");
return (-1);
}
_outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
output_file_recorder_->RegisterModuleFileCallback(NULL);
output_file_recorder_.reset();
_outputFileRecording = false;
return 0;
@ -3302,15 +3277,15 @@ int32_t Channel::MixOrReplaceAudioWithFile(int mixingFrequency) {
{
rtc::CritScope cs(&_fileCritSect);
if (_inputFilePlayerPtr == NULL) {
if (!input_file_player_) {
WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
"Channel::MixOrReplaceAudioWithFile() fileplayer"
" doesnt exist");
return -1;
}
if (_inputFilePlayerPtr->Get10msAudioFromFile(fileBuffer.get(), fileSamples,
mixingFrequency) == -1) {
if (input_file_player_->Get10msAudioFromFile(fileBuffer.get(), fileSamples,
mixingFrequency) == -1) {
WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
"Channel::MixOrReplaceAudioWithFile() file mixing "
"failed");
@ -3350,15 +3325,15 @@ int32_t Channel::MixAudioWithFile(AudioFrame& audioFrame, int mixingFrequency) {
{
rtc::CritScope cs(&_fileCritSect);
if (_outputFilePlayerPtr == NULL) {
if (!output_file_player_) {
WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
"Channel::MixAudioWithFile() file mixing failed");
return -1;
}
// We should get the frequency we ask for.
if (_outputFilePlayerPtr->Get10msAudioFromFile(
fileBuffer.get(), fileSamples, mixingFrequency) == -1) {
if (output_file_player_->Get10msAudioFromFile(fileBuffer.get(), fileSamples,
mixingFrequency) == -1) {
WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
"Channel::MixAudioWithFile() file mixing failed");
return -1;

6
webrtc/voice_engine/channel.h
View File

@ -506,9 +506,9 @@ class Channel
AudioFrame _audioFrame;
// Downsamples to the codec rate if necessary.
PushResampler<int16_t> input_resampler_;
FilePlayer* _inputFilePlayerPtr;
FilePlayer* _outputFilePlayerPtr;
FileRecorder* _outputFileRecorderPtr;
std::unique_ptr<FilePlayer> input_file_player_;
std::unique_ptr<FilePlayer> output_file_player_;
std::unique_ptr<FileRecorder> output_file_recorder_;
int _inputFilePlayerId;
int _outputFilePlayerId;
int _outputFileRecorderId;

120
webrtc/voice_engine/output_mixer.cc
View File

@ -99,7 +99,6 @@ OutputMixer::OutputMixer(uint32_t instanceId) :
_panLeft(1.0f),
_panRight(1.0f),
_mixingFrequencyHz(8000),
_outputFileRecorderPtr(NULL),
_outputFileRecording(false)
{
WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId,-1),
@ -133,12 +132,9 @@ OutputMixer::~OutputMixer()
}
{
rtc::CritScope cs(&_fileCritSect);
if (_outputFileRecorderPtr)
{
_outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
_outputFileRecorderPtr->StopRecording();
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
if (output_file_recorder_) {
output_file_recorder_->RegisterModuleFileCallback(NULL);
output_file_recorder_->StopRecording();
}
}
_mixerModule.UnRegisterMixedStreamCallback();
@ -295,38 +291,30 @@ int OutputMixer::StartRecordingPlayout(const char* fileName,
rtc::CritScope cs(&_fileCritSect);
// Destroy the old instance
if (_outputFileRecorderPtr)
{
_outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
if (output_file_recorder_) {
output_file_recorder_->RegisterModuleFileCallback(NULL);
output_file_recorder_.reset();
}
_outputFileRecorderPtr = FileRecorder::CreateFileRecorder(
_instanceId,
(const FileFormats)format);
if (_outputFileRecorderPtr == NULL)
{
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartRecordingPlayout() fileRecorder format isnot correct");
return -1;
output_file_recorder_ = FileRecorder::CreateFileRecorder(
_instanceId, (const FileFormats)format);
if (!output_file_recorder_) {
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartRecordingPlayout() fileRecorder format isnot correct");
return -1;
}
if (_outputFileRecorderPtr->StartRecordingAudioFile(
fileName,
(const CodecInst&)*codecInst,
notificationTime) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_BAD_FILE, kTraceError,
"StartRecordingAudioFile() failed to start file recording");
_outputFileRecorderPtr->StopRecording();
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
return -1;
if (output_file_recorder_->StartRecordingAudioFile(
fileName, (const CodecInst&)*codecInst, notificationTime) != 0) {
_engineStatisticsPtr->SetLastError(
VE_BAD_FILE, kTraceError,
"StartRecordingAudioFile() failed to start file recording");
output_file_recorder_->StopRecording();
output_file_recorder_.reset();
return -1;
}
_outputFileRecorderPtr->RegisterModuleFileCallback(this);
output_file_recorder_->RegisterModuleFileCallback(this);
_outputFileRecording = true;
return 0;
@ -375,37 +363,31 @@ int OutputMixer::StartRecordingPlayout(OutStream* stream,
rtc::CritScope cs(&_fileCritSect);
// Destroy the old instance
if (_outputFileRecorderPtr)
{
_outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
if (output_file_recorder_) {
output_file_recorder_->RegisterModuleFileCallback(NULL);
output_file_recorder_.reset();
}
_outputFileRecorderPtr = FileRecorder::CreateFileRecorder(
_instanceId,
(const FileFormats)format);
if (_outputFileRecorderPtr == NULL)
{
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartRecordingPlayout() fileRecorder format isnot correct");
return -1;
output_file_recorder_ = FileRecorder::CreateFileRecorder(
_instanceId, (const FileFormats)format);
if (!output_file_recorder_) {
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartRecordingPlayout() fileRecorder format isnot correct");
return -1;
}
if (_outputFileRecorderPtr->StartRecordingAudioFile(*stream,
*codecInst,
notificationTime) != 0)
{
_engineStatisticsPtr->SetLastError(VE_BAD_FILE, kTraceError,
"StartRecordingAudioFile() failed to start file recording");
_outputFileRecorderPtr->StopRecording();
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
return -1;
if (output_file_recorder_->StartRecordingAudioFile(*stream, *codecInst,
notificationTime) != 0) {
_engineStatisticsPtr->SetLastError(
VE_BAD_FILE, kTraceError,
"StartRecordingAudioFile() failed to start file recording");
output_file_recorder_->StopRecording();
output_file_recorder_.reset();
return -1;
}
_outputFileRecorderPtr->RegisterModuleFileCallback(this);
output_file_recorder_->RegisterModuleFileCallback(this);
_outputFileRecording = true;
return 0;
@ -425,16 +407,14 @@ int OutputMixer::StopRecordingPlayout()
rtc::CritScope cs(&_fileCritSect);
if (_outputFileRecorderPtr->StopRecording() != 0)
{
_engineStatisticsPtr->SetLastError(
VE_STOP_RECORDING_FAILED, kTraceError,
"StopRecording(), could not stop recording");
return -1;
if (output_file_recorder_->StopRecording() != 0) {
_engineStatisticsPtr->SetLastError(
VE_STOP_RECORDING_FAILED, kTraceError,
"StopRecording(), could not stop recording");
return -1;
}
_outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
_outputFileRecorderPtr = NULL;
output_file_recorder_->RegisterModuleFileCallback(NULL);
output_file_recorder_.reset();
_outputFileRecording = false;
return 0;
@ -451,8 +431,8 @@ int OutputMixer::GetMixedAudio(int sample_rate_hz,
// --- Record playout if enabled
{
rtc::CritScope cs(&_fileCritSect);
if (_outputFileRecording && _outputFileRecorderPtr)
_outputFileRecorderPtr->RecordAudioToFile(_audioFrame);
if (_outputFileRecording && output_file_recorder_)
output_file_recorder_->RecordAudioToFile(_audioFrame);
}
frame->num_channels_ = num_channels;

6
webrtc/voice_engine/output_mixer.h
View File

@ -11,6 +11,8 @@
#ifndef WEBRTC_VOICE_ENGINE_OUTPUT_MIXER_H_
#define WEBRTC_VOICE_ENGINE_OUTPUT_MIXER_H_
#include <memory>
#include "webrtc/base/criticalsection.h"
#include "webrtc/common_audio/resampler/include/push_resampler.h"
#include "webrtc/common_types.h"
@ -104,7 +106,7 @@ private:
AudioProcessing* _audioProcessingModulePtr;
rtc::CriticalSection _callbackCritSect;
// protect the _outputFileRecorderPtr and _outputFileRecording
// Protects output_file_recorder_ and _outputFileRecording.
rtc::CriticalSection _fileCritSect;
AudioConferenceMixer& _mixerModule;
AudioFrame _audioFrame;
@ -119,7 +121,7 @@ private:
float _panLeft;
float _panRight;
int _mixingFrequencyHz;
FileRecorder* _outputFileRecorderPtr;
std::unique_ptr<FileRecorder> output_file_recorder_;
bool _outputFileRecording;
};

407
webrtc/voice_engine/transmit_mixer.cc
View File

@ -182,9 +182,6 @@ TransmitMixer::TransmitMixer(uint32_t instanceId) :
audioproc_(NULL),
_voiceEngineObserverPtr(NULL),
_processThreadPtr(NULL),
_filePlayerPtr(NULL),
_fileRecorderPtr(NULL),
_fileCallRecorderPtr(NULL),
// Avoid conflict with other channels by adding 1024 - 1026,
// won't use as much as 1024 channels.
_filePlayerId(instanceId + 1024),
@ -225,26 +222,17 @@ TransmitMixer::~TransmitMixer()
DeRegisterExternalMediaProcessing(kRecordingPreprocessing);
{
rtc::CritScope cs(&_critSect);
if (_fileRecorderPtr)
{
_fileRecorderPtr->RegisterModuleFileCallback(NULL);
_fileRecorderPtr->StopRecording();
FileRecorder::DestroyFileRecorder(_fileRecorderPtr);
_fileRecorderPtr = NULL;
if (file_recorder_) {
file_recorder_->RegisterModuleFileCallback(NULL);
file_recorder_->StopRecording();
}
if (_fileCallRecorderPtr)
{
_fileCallRecorderPtr->RegisterModuleFileCallback(NULL);
_fileCallRecorderPtr->StopRecording();
FileRecorder::DestroyFileRecorder(_fileCallRecorderPtr);
_fileCallRecorderPtr = NULL;
if (file_call_recorder_) {
file_call_recorder_->RegisterModuleFileCallback(NULL);
file_call_recorder_->StopRecording();
}
if (_filePlayerPtr)
{
_filePlayerPtr->RegisterModuleFileCallback(NULL);
_filePlayerPtr->StopPlayingFile();
FilePlayer::DestroyFilePlayer(_filePlayerPtr);
_filePlayerPtr = NULL;
if (file_player_) {
file_player_->RegisterModuleFileCallback(NULL);
file_player_->StopPlayingFile();
}
}
}
@ -496,47 +484,36 @@ int TransmitMixer::StartPlayingFileAsMicrophone(const char* fileName,
rtc::CritScope cs(&_critSect);
// Destroy the old instance
if (_filePlayerPtr)
{
_filePlayerPtr->RegisterModuleFileCallback(NULL);
FilePlayer::DestroyFilePlayer(_filePlayerPtr);
_filePlayerPtr = NULL;
if (file_player_) {
file_player_->RegisterModuleFileCallback(NULL);
file_player_.reset();
}
// Dynamically create the instance
_filePlayerPtr
= FilePlayer::CreateFilePlayer(_filePlayerId,
(const FileFormats) format);
file_player_ =
FilePlayer::NewFilePlayer(_filePlayerId, (const FileFormats)format);
if (_filePlayerPtr == NULL)
{
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartPlayingFileAsMicrophone() filePlayer format isnot correct");
return -1;
if (!file_player_) {
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartPlayingFileAsMicrophone() filePlayer format isnot correct");
return -1;
}
const uint32_t notificationTime(0);
if (_filePlayerPtr->StartPlayingFile(
fileName,
loop,
startPosition,
volumeScaling,
notificationTime,
stopPosition,
(const CodecInst*) codecInst) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_BAD_FILE, kTraceError,
"StartPlayingFile() failed to start file playout");
_filePlayerPtr->StopPlayingFile();
FilePlayer::DestroyFilePlayer(_filePlayerPtr);
_filePlayerPtr = NULL;
return -1;
if (file_player_->StartPlayingFile(
fileName, loop, startPosition, volumeScaling, notificationTime,
stopPosition, (const CodecInst*)codecInst) != 0) {
_engineStatisticsPtr->SetLastError(
VE_BAD_FILE, kTraceError,
"StartPlayingFile() failed to start file playout");
file_player_->StopPlayingFile();
file_player_.reset();
return -1;
}
_filePlayerPtr->RegisterModuleFileCallback(this);
file_player_->RegisterModuleFileCallback(this);
_filePlaying = true;
return 0;
@ -573,45 +550,35 @@ int TransmitMixer::StartPlayingFileAsMicrophone(InStream* stream,
rtc::CritScope cs(&_critSect);
// Destroy the old instance
if (_filePlayerPtr)
{
_filePlayerPtr->RegisterModuleFileCallback(NULL);
FilePlayer::DestroyFilePlayer(_filePlayerPtr);
_filePlayerPtr = NULL;
if (file_player_) {
file_player_->RegisterModuleFileCallback(NULL);
file_player_.reset();
}
// Dynamically create the instance
_filePlayerPtr
= FilePlayer::CreateFilePlayer(_filePlayerId,
(const FileFormats) format);
file_player_ =
FilePlayer::NewFilePlayer(_filePlayerId, (const FileFormats)format);
if (_filePlayerPtr == NULL)
{
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceWarning,
"StartPlayingFileAsMicrophone() filePlayer format isnot correct");
return -1;
if (!file_player_) {
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceWarning,
"StartPlayingFileAsMicrophone() filePlayer format isnot correct");
return -1;
}
const uint32_t notificationTime(0);
if (_filePlayerPtr->StartPlayingFile(
(InStream&) *stream,
startPosition,
volumeScaling,
notificationTime,
stopPosition,
(const CodecInst*) codecInst) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_BAD_FILE, kTraceError,
"StartPlayingFile() failed to start file playout");
_filePlayerPtr->StopPlayingFile();
FilePlayer::DestroyFilePlayer(_filePlayerPtr);
_filePlayerPtr = NULL;
return -1;
if (file_player_->StartPlayingFile(
(InStream&)*stream, startPosition, volumeScaling, notificationTime,
stopPosition, (const CodecInst*)codecInst) != 0) {
_engineStatisticsPtr->SetLastError(
VE_BAD_FILE, kTraceError,
"StartPlayingFile() failed to start file playout");
file_player_->StopPlayingFile();
file_player_.reset();
return -1;
}
_filePlayerPtr->RegisterModuleFileCallback(this);
file_player_->RegisterModuleFileCallback(this);
_filePlaying = true;
return 0;
@ -629,17 +596,15 @@ int TransmitMixer::StopPlayingFileAsMicrophone()
rtc::CritScope cs(&_critSect);
if (_filePlayerPtr->StopPlayingFile() != 0)
{
_engineStatisticsPtr->SetLastError(
VE_CANNOT_STOP_PLAYOUT, kTraceError,
"StopPlayingFile() couldnot stop playing file");
return -1;
if (file_player_->StopPlayingFile() != 0) {
_engineStatisticsPtr->SetLastError(
VE_CANNOT_STOP_PLAYOUT, kTraceError,
"StopPlayingFile() couldnot stop playing file");
return -1;
}
_filePlayerPtr->RegisterModuleFileCallback(NULL);
FilePlayer::DestroyFilePlayer(_filePlayerPtr);
_filePlayerPtr = NULL;
file_player_->RegisterModuleFileCallback(NULL);
file_player_.reset();
_filePlaying = false;
return 0;
@ -694,38 +659,30 @@ int TransmitMixer::StartRecordingMicrophone(const char* fileName,
}
// Destroy the old instance
if (_fileRecorderPtr)
{
_fileRecorderPtr->RegisterModuleFileCallback(NULL);
FileRecorder::DestroyFileRecorder(_fileRecorderPtr);
_fileRecorderPtr = NULL;
if (file_recorder_) {
file_recorder_->RegisterModuleFileCallback(NULL);
file_recorder_.reset();
}
_fileRecorderPtr =
FileRecorder::CreateFileRecorder(_fileRecorderId,
(const FileFormats) format);
if (_fileRecorderPtr == NULL)
{
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartRecordingMicrophone() fileRecorder format isnot correct");
return -1;
file_recorder_ = FileRecorder::CreateFileRecorder(
_fileRecorderId, (const FileFormats)format);
if (!file_recorder_) {
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartRecordingMicrophone() fileRecorder format isnot correct");
return -1;
}
if (_fileRecorderPtr->StartRecordingAudioFile(
fileName,
(const CodecInst&) *codecInst,
notificationTime) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_BAD_FILE, kTraceError,
"StartRecordingAudioFile() failed to start file recording");
_fileRecorderPtr->StopRecording();
FileRecorder::DestroyFileRecorder(_fileRecorderPtr);
_fileRecorderPtr = NULL;
return -1;
if (file_recorder_->StartRecordingAudioFile(
fileName, (const CodecInst&)*codecInst, notificationTime) != 0) {
_engineStatisticsPtr->SetLastError(
VE_BAD_FILE, kTraceError,
"StartRecordingAudioFile() failed to start file recording");
file_recorder_->StopRecording();
file_recorder_.reset();
return -1;
}
_fileRecorderPtr->RegisterModuleFileCallback(this);
file_recorder_->RegisterModuleFileCallback(this);
_fileRecording = true;
return 0;
@ -772,37 +729,31 @@ int TransmitMixer::StartRecordingMicrophone(OutStream* stream,
}
// Destroy the old instance
if (_fileRecorderPtr)
{
_fileRecorderPtr->RegisterModuleFileCallback(NULL);
FileRecorder::DestroyFileRecorder(_fileRecorderPtr);
_fileRecorderPtr = NULL;
if (file_recorder_) {
file_recorder_->RegisterModuleFileCallback(NULL);
file_recorder_.reset();
}
_fileRecorderPtr =
FileRecorder::CreateFileRecorder(_fileRecorderId,
(const FileFormats) format);
if (_fileRecorderPtr == NULL)
{
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartRecordingMicrophone() fileRecorder format isnot correct");
return -1;
file_recorder_ = FileRecorder::CreateFileRecorder(
_fileRecorderId, (const FileFormats)format);
if (!file_recorder_) {
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartRecordingMicrophone() fileRecorder format isnot correct");
return -1;
}
if (_fileRecorderPtr->StartRecordingAudioFile(*stream,
*codecInst,
notificationTime) != 0)
{
_engineStatisticsPtr->SetLastError(VE_BAD_FILE, kTraceError,
"StartRecordingAudioFile() failed to start file recording");
_fileRecorderPtr->StopRecording();
FileRecorder::DestroyFileRecorder(_fileRecorderPtr);
_fileRecorderPtr = NULL;
return -1;
if (file_recorder_->StartRecordingAudioFile(*stream, *codecInst,
notificationTime) != 0) {
_engineStatisticsPtr->SetLastError(
VE_BAD_FILE, kTraceError,
"StartRecordingAudioFile() failed to start file recording");
file_recorder_->StopRecording();
file_recorder_.reset();
return -1;
}
_fileRecorderPtr->RegisterModuleFileCallback(this);
file_recorder_->RegisterModuleFileCallback(this);
_fileRecording = true;
return 0;
@ -823,16 +774,14 @@ int TransmitMixer::StopRecordingMicrophone()
return 0;
}
if (_fileRecorderPtr->StopRecording() != 0)
{
_engineStatisticsPtr->SetLastError(
VE_STOP_RECORDING_FAILED, kTraceError,
"StopRecording(), could not stop recording");
return -1;
if (file_recorder_->StopRecording() != 0) {
_engineStatisticsPtr->SetLastError(
VE_STOP_RECORDING_FAILED, kTraceError,
"StopRecording(), could not stop recording");
return -1;
}
_fileRecorderPtr->RegisterModuleFileCallback(NULL);
FileRecorder::DestroyFileRecorder(_fileRecorderPtr);
_fileRecorderPtr = NULL;
file_recorder_->RegisterModuleFileCallback(NULL);
file_recorder_.reset();
_fileRecording = false;
return 0;
@ -879,38 +828,30 @@ int TransmitMixer::StartRecordingCall(const char* fileName,
rtc::CritScope cs(&_critSect);
// Destroy the old instance
if (_fileCallRecorderPtr)
{
_fileCallRecorderPtr->RegisterModuleFileCallback(NULL);
FileRecorder::DestroyFileRecorder(_fileCallRecorderPtr);
_fileCallRecorderPtr = NULL;
if (file_call_recorder_) {
file_call_recorder_->RegisterModuleFileCallback(NULL);
file_call_recorder_.reset();
}
_fileCallRecorderPtr
= FileRecorder::CreateFileRecorder(_fileCallRecorderId,
(const FileFormats) format);
if (_fileCallRecorderPtr == NULL)
{
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartRecordingCall() fileRecorder format isnot correct");
return -1;
file_call_recorder_ = FileRecorder::CreateFileRecorder(
_fileCallRecorderId, (const FileFormats)format);
if (!file_call_recorder_) {
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartRecordingCall() fileRecorder format isnot correct");
return -1;
}
if (_fileCallRecorderPtr->StartRecordingAudioFile(
fileName,
(const CodecInst&) *codecInst,
notificationTime) != 0)
{
_engineStatisticsPtr->SetLastError(
VE_BAD_FILE, kTraceError,
"StartRecordingAudioFile() failed to start file recording");
_fileCallRecorderPtr->StopRecording();
FileRecorder::DestroyFileRecorder(_fileCallRecorderPtr);
_fileCallRecorderPtr = NULL;
return -1;
if (file_call_recorder_->StartRecordingAudioFile(
fileName, (const CodecInst&)*codecInst, notificationTime) != 0) {
_engineStatisticsPtr->SetLastError(
VE_BAD_FILE, kTraceError,
"StartRecordingAudioFile() failed to start file recording");
file_call_recorder_->StopRecording();
file_call_recorder_.reset();
return -1;
}
_fileCallRecorderPtr->RegisterModuleFileCallback(this);
file_call_recorder_->RegisterModuleFileCallback(this);
_fileCallRecording = true;
return 0;
@ -957,37 +898,31 @@ int TransmitMixer::StartRecordingCall(OutStream* stream,
rtc::CritScope cs(&_critSect);
// Destroy the old instance
if (_fileCallRecorderPtr)
{
_fileCallRecorderPtr->RegisterModuleFileCallback(NULL);
FileRecorder::DestroyFileRecorder(_fileCallRecorderPtr);
_fileCallRecorderPtr = NULL;
if (file_call_recorder_) {
file_call_recorder_->RegisterModuleFileCallback(NULL);
file_call_recorder_.reset();
}
_fileCallRecorderPtr =
FileRecorder::CreateFileRecorder(_fileCallRecorderId,
(const FileFormats) format);
if (_fileCallRecorderPtr == NULL)
{
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartRecordingCall() fileRecorder format isnot correct");
return -1;
file_call_recorder_ = FileRecorder::CreateFileRecorder(
_fileCallRecorderId, (const FileFormats)format);
if (!file_call_recorder_) {
_engineStatisticsPtr->SetLastError(
VE_INVALID_ARGUMENT, kTraceError,
"StartRecordingCall() fileRecorder format isnot correct");
return -1;
}
if (_fileCallRecorderPtr->StartRecordingAudioFile(*stream,
*codecInst,
notificationTime) != 0)
{
_engineStatisticsPtr->SetLastError(VE_BAD_FILE, kTraceError,
"StartRecordingAudioFile() failed to start file recording");
_fileCallRecorderPtr->StopRecording();
FileRecorder::DestroyFileRecorder(_fileCallRecorderPtr);
_fileCallRecorderPtr = NULL;
return -1;
if (file_call_recorder_->StartRecordingAudioFile(*stream, *codecInst,
notificationTime) != 0) {
_engineStatisticsPtr->SetLastError(
VE_BAD_FILE, kTraceError,
"StartRecordingAudioFile() failed to start file recording");
file_call_recorder_->StopRecording();
file_call_recorder_.reset();
return -1;
}
_fileCallRecorderPtr->RegisterModuleFileCallback(this);
file_call_recorder_->RegisterModuleFileCallback(this);
_fileCallRecording = true;
return 0;
@ -1007,17 +942,15 @@ int TransmitMixer::StopRecordingCall()
rtc::CritScope cs(&_critSect);
if (_fileCallRecorderPtr->StopRecording() != 0)
{
_engineStatisticsPtr->SetLastError(
VE_STOP_RECORDING_FAILED, kTraceError,
"StopRecording(), could not stop recording");
return -1;
if (file_call_recorder_->StopRecording() != 0) {
_engineStatisticsPtr->SetLastError(
VE_STOP_RECORDING_FAILED, kTraceError,
"StopRecording(), could not stop recording");
return -1;
}
_fileCallRecorderPtr->RegisterModuleFileCallback(NULL);
FileRecorder::DestroyFileRecorder(_fileCallRecorderPtr);
_fileCallRecorderPtr = NULL;
file_call_recorder_->RegisterModuleFileCallback(NULL);
file_call_recorder_.reset();
_fileCallRecording = false;
return 0;
@ -1131,20 +1064,18 @@ int32_t TransmitMixer::RecordAudioToFile(
uint32_t mixingFrequency)
{
rtc::CritScope cs(&_critSect);
if (_fileRecorderPtr == NULL)
{
WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
"TransmitMixer::RecordAudioToFile() filerecorder doesnot"
"exist");
return -1;
if (!file_recorder_) {
WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
"TransmitMixer::RecordAudioToFile() filerecorder doesnot"
"exist");
return -1;
}
if (_fileRecorderPtr->RecordAudioToFile(_audioFrame) != 0)
{
WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
"TransmitMixer::RecordAudioToFile() file recording"
"failed");
return -1;
if (file_recorder_->RecordAudioToFile(_audioFrame) != 0) {
WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
"TransmitMixer::RecordAudioToFile() file recording"
"failed");
return -1;
}
return 0;
@ -1158,23 +1089,19 @@ int32_t TransmitMixer::MixOrReplaceAudioWithFile(
size_t fileSamples(0);
{
rtc::CritScope cs(&_critSect);
if (_filePlayerPtr == NULL)
{
WEBRTC_TRACE(kTraceWarning, kTraceVoice,
VoEId(_instanceId, -1),
"TransmitMixer::MixOrReplaceAudioWithFile()"
"fileplayer doesnot exist");
return -1;
if (!file_player_) {
WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
"TransmitMixer::MixOrReplaceAudioWithFile()"
"fileplayer doesnot exist");
return -1;
}
if (_filePlayerPtr->Get10msAudioFromFile(fileBuffer.get(),
fileSamples,
mixingFrequency) == -1)
{
WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
"TransmitMixer::MixOrReplaceAudioWithFile() file"
" mixing failed");
return -1;
if (file_player_->Get10msAudioFromFile(fileBuffer.get(), fileSamples,
mixingFrequency) == -1) {
WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
"TransmitMixer::MixOrReplaceAudioWithFile() file"
" mixing failed");
return -1;
}
}

8
webrtc/voice_engine/transmit_mixer.h
View File

@ -11,6 +11,8 @@
#ifndef WEBRTC_VOICE_ENGINE_TRANSMIT_MIXER_H
#define WEBRTC_VOICE_ENGINE_TRANSMIT_MIXER_H
#include <memory>
#include "webrtc/base/criticalsection.h"
#include "webrtc/common_audio/resampler/include/push_resampler.h"
#include "webrtc/common_types.h"
@ -196,9 +198,9 @@ private:
MonitorModule _monitorModule;
AudioFrame _audioFrame;
PushResampler<int16_t> resampler_; // ADM sample rate -> mixing rate
FilePlayer* _filePlayerPtr;
FileRecorder* _fileRecorderPtr;
FileRecorder* _fileCallRecorderPtr;
std::unique_ptr<FilePlayer> file_player_;
std::unique_ptr<FileRecorder> file_recorder_;
std::unique_ptr<FileRecorder> file_call_recorder_;
int _filePlayerId;
int _fileRecorderId;
int _fileCallRecorderId;