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

Run "git cl format" on some files before I start to modify them

Browse Source 
This CL does literally nothing else but run "git cl format --full"
on the touched files.

NOPRESUBMIT=true

Review-Url: https://codereview.webrtc.org/2035663002
Cr-Commit-Position: refs/heads/master@{#13782}
This commit is contained in:
kwiberg 2016-08-16 05:35:24 -07:00 committed by Commit bot
parent b789439b23
commit a06ce499d6
7 changed files with 539 additions and 683 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -19,68 +19,62 @@
namespace webrtc { namespace webrtc {
class FileCallback; class FileCallback;
class FilePlayer class FilePlayer {
{ public:
public: // The largest decoded frame size in samples (60ms with 32kHz sample rate).
// The largest decoded frame size in samples (60ms with 32kHz sample rate). enum { MAX_AUDIO_BUFFER_IN_SAMPLES = 60 * 32 };
enum {MAX_AUDIO_BUFFER_IN_SAMPLES = 60*32}; enum { MAX_AUDIO_BUFFER_IN_BYTES = MAX_AUDIO_BUFFER_IN_SAMPLES * 2 };
enum {MAX_AUDIO_BUFFER_IN_BYTES = MAX_AUDIO_BUFFER_IN_SAMPLES*2};
// Note: will return NULL for unsupported formats. // Note: will return NULL for unsupported formats.
static FilePlayer* CreateFilePlayer(const uint32_t instanceID, static FilePlayer* CreateFilePlayer(const uint32_t instanceID,
const FileFormats fileFormat); const FileFormats fileFormat);
static void DestroyFilePlayer(FilePlayer* player); static void DestroyFilePlayer(FilePlayer* player);
// Read 10 ms of audio at |frequencyInHz| to |outBuffer|. |lengthInSamples| // 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 // will be set to the number of samples read (not the number of samples per
// channel). // channel).
virtual int Get10msAudioFromFile( virtual int Get10msAudioFromFile(int16_t* outBuffer,
int16_t* outBuffer, size_t& lengthInSamples,
size_t& lengthInSamples, int frequencyInHz) = 0;
int frequencyInHz) = 0;
// Register callback for receiving file playing notifications. // Register callback for receiving file playing notifications.
virtual int32_t RegisterModuleFileCallback( virtual int32_t RegisterModuleFileCallback(FileCallback* callback) = 0;
FileCallback* callback) = 0;
// API for playing audio from fileName to channel. // API for playing audio from fileName to channel.
// Note: codecInst is used for pre-encoded files. // Note: codecInst is used for pre-encoded files.
virtual int32_t StartPlayingFile( virtual int32_t StartPlayingFile(const char* fileName,
const char* fileName, bool loop,
bool loop, uint32_t startPosition,
uint32_t startPosition, float volumeScaling,
float volumeScaling, uint32_t notification,
uint32_t notification, uint32_t stopPosition = 0,
uint32_t stopPosition = 0, const CodecInst* codecInst = NULL) = 0;
const CodecInst* codecInst = NULL) = 0;
// Note: codecInst is used for pre-encoded files. // Note: codecInst is used for pre-encoded files.
virtual int32_t StartPlayingFile( virtual int32_t StartPlayingFile(InStream& sourceStream,
InStream& sourceStream, uint32_t startPosition,
uint32_t startPosition, float volumeScaling,
float volumeScaling, uint32_t notification,
uint32_t notification, uint32_t stopPosition = 0,
uint32_t stopPosition = 0, const CodecInst* codecInst = NULL) = 0;
const CodecInst* codecInst = NULL) = 0;
virtual int32_t StopPlayingFile() = 0; virtual int32_t StopPlayingFile() = 0;
virtual bool IsPlayingFile() const = 0; virtual bool IsPlayingFile() const = 0;
virtual int32_t GetPlayoutPosition(uint32_t& durationMs) = 0; virtual int32_t GetPlayoutPosition(uint32_t& durationMs) = 0;
// Set audioCodec to the currently used audio codec. // Set audioCodec to the currently used audio codec.
virtual int32_t AudioCodec(CodecInst& audioCodec) const = 0; virtual int32_t AudioCodec(CodecInst& audioCodec) const = 0;
virtual int32_t Frequency() const = 0; virtual int32_t Frequency() const = 0;
// Note: scaleFactor is in the range [0.0 - 2.0] // Note: scaleFactor is in the range [0.0 - 2.0]
virtual int32_t SetAudioScaling(float scaleFactor) = 0; virtual int32_t SetAudioScaling(float scaleFactor) = 0;
protected:
virtual ~FilePlayer() {}
protected:
virtual ~FilePlayer() {}
}; };
} // namespace webrtc } // namespace webrtc
#endif // WEBRTC_MODULES_UTILITY_INCLUDE_FILE_PLAYER_H_ #endif // WEBRTC_MODULES_UTILITY_INCLUDE_FILE_PLAYER_H_

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

@ -19,46 +19,39 @@
namespace webrtc { namespace webrtc {
class FileRecorder class FileRecorder {
{ public:
public: // Note: will return NULL for unsupported formats.
static FileRecorder* CreateFileRecorder(const uint32_t instanceID,
const FileFormats fileFormat);
// Note: will return NULL for unsupported formats. static void DestroyFileRecorder(FileRecorder* recorder);
static FileRecorder* CreateFileRecorder(const uint32_t instanceID,
const FileFormats fileFormat);
static void DestroyFileRecorder(FileRecorder* recorder); virtual int32_t RegisterModuleFileCallback(FileCallback* callback) = 0;
virtual int32_t RegisterModuleFileCallback( virtual FileFormats RecordingFileFormat() const = 0;
FileCallback* callback) = 0;
virtual FileFormats RecordingFileFormat() const = 0; virtual int32_t StartRecordingAudioFile(const char* fileName,
const CodecInst& codecInst,
uint32_t notification) = 0;
virtual int32_t StartRecordingAudioFile( virtual int32_t StartRecordingAudioFile(OutStream& destStream,
const char* fileName, const CodecInst& codecInst,
const CodecInst& codecInst, uint32_t notification) = 0;
uint32_t notification) = 0;
virtual int32_t StartRecordingAudioFile( // Stop recording.
OutStream& destStream, virtual int32_t StopRecording() = 0;
const CodecInst& codecInst,
uint32_t notification) = 0;
// Stop recording. // Return true if recording.
virtual int32_t StopRecording() = 0; virtual bool IsRecording() const = 0;
// Return true if recording. virtual int32_t codec_info(CodecInst& codecInst) const = 0;
virtual bool IsRecording() const = 0;
virtual int32_t codec_info(CodecInst& codecInst) const = 0; // Write frame to file. Frame should contain 10ms of un-ecoded audio data.
virtual int32_t RecordAudioToFile(const AudioFrame& frame) = 0;
// Write frame to file. Frame should contain 10ms of un-ecoded audio data.
virtual int32_t RecordAudioToFile(
const AudioFrame& frame) = 0;
protected:
virtual ~FileRecorder() {}
protected:
virtual ~FileRecorder() {}
}; };
} // namespace webrtc } // namespace webrtc
#endif // WEBRTC_MODULES_UTILITY_INCLUDE_FILE_RECORDER_H_ #endif // WEBRTC_MODULES_UTILITY_INCLUDE_FILE_RECORDER_H_

577
webrtc/modules/utility/source/file_player_impl.cc
View File

@ -13,27 +13,24 @@
namespace webrtc { namespace webrtc {
FilePlayer* FilePlayer::CreateFilePlayer(uint32_t instanceID, FilePlayer* FilePlayer::CreateFilePlayer(uint32_t instanceID,
FileFormats fileFormat) FileFormats fileFormat) {
{ switch (fileFormat) {
switch(fileFormat)
{
case kFileFormatWavFile: case kFileFormatWavFile:
case kFileFormatCompressedFile: case kFileFormatCompressedFile:
case kFileFormatPreencodedFile: case kFileFormatPreencodedFile:
case kFileFormatPcm16kHzFile: case kFileFormatPcm16kHzFile:
case kFileFormatPcm8kHzFile: case kFileFormatPcm8kHzFile:
case kFileFormatPcm32kHzFile: case kFileFormatPcm32kHzFile:
// audio formats // audio formats
return new FilePlayerImpl(instanceID, fileFormat); return new FilePlayerImpl(instanceID, fileFormat);
default: default:
assert(false); assert(false);
return NULL; return NULL;
} }
} }
void FilePlayer::DestroyFilePlayer(FilePlayer* player) void FilePlayer::DestroyFilePlayer(FilePlayer* player) {
{ delete player;
delete player;
} }
FilePlayerImpl::FilePlayerImpl(const uint32_t instanceID, FilePlayerImpl::FilePlayerImpl(const uint32_t instanceID,
@ -47,158 +44,125 @@ FilePlayerImpl::FilePlayerImpl(const uint32_t instanceID,
_numberOf10MsPerFrame(0), _numberOf10MsPerFrame(0),
_numberOf10MsInDecoder(0), _numberOf10MsInDecoder(0),
_resampler(), _resampler(),
_scaling(1.0) _scaling(1.0) {
{ _codec.plfreq = 0;
_codec.plfreq = 0;
} }
FilePlayerImpl::~FilePlayerImpl() FilePlayerImpl::~FilePlayerImpl() {
{ MediaFile::DestroyMediaFile(&_fileModule);
MediaFile::DestroyMediaFile(&_fileModule);
} }
int32_t FilePlayerImpl::Frequency() const int32_t FilePlayerImpl::Frequency() const {
{ if (_codec.plfreq == 0) {
if(_codec.plfreq == 0)
{
return -1;
}
// Make sure that sample rate is 8,16 or 32 kHz. E.g. WAVE files may have
// other sampling rates.
if(_codec.plfreq == 11000)
{
return 16000;
}
else if(_codec.plfreq == 22000)
{
return 32000;
}
else if(_codec.plfreq == 44000)
{
return 32000;
}
else if(_codec.plfreq == 48000)
{
return 32000;
}
else
{
return _codec.plfreq;
}
}
int32_t FilePlayerImpl::AudioCodec(CodecInst& audioCodec) const
{
audioCodec = _codec;
return 0;
}
int32_t FilePlayerImpl::Get10msAudioFromFile(
int16_t* outBuffer,
size_t& lengthInSamples,
int frequencyInHz)
{
if(_codec.plfreq == 0)
{
LOG(LS_WARNING) << "Get10msAudioFromFile() playing not started!"
<< " codec freq = " << _codec.plfreq
<< ", wanted freq = " << frequencyInHz;
return -1;
}
AudioFrame unresampledAudioFrame;
if(STR_CASE_CMP(_codec.plname, "L16") == 0)
{
unresampledAudioFrame.sample_rate_hz_ = _codec.plfreq;
// L16 is un-encoded data. Just pull 10 ms.
size_t lengthInBytes =
sizeof(unresampledAudioFrame.data_);
if (_fileModule.PlayoutAudioData(
(int8_t*)unresampledAudioFrame.data_,
lengthInBytes) == -1)
{
// End of file reached.
return -1;
}
if(lengthInBytes == 0)
{
lengthInSamples = 0;
return 0;
}
// One sample is two bytes.
unresampledAudioFrame.samples_per_channel_ = lengthInBytes >> 1;
} else {
// Decode will generate 10 ms of audio data. PlayoutAudioData(..)
// expects a full frame. If the frame size is larger than 10 ms,
// PlayoutAudioData(..) data should be called proportionally less often.
int16_t encodedBuffer[MAX_AUDIO_BUFFER_IN_SAMPLES];
size_t encodedLengthInBytes = 0;
if(++_numberOf10MsInDecoder >= _numberOf10MsPerFrame)
{
_numberOf10MsInDecoder = 0;
size_t bytesFromFile = sizeof(encodedBuffer);
if (_fileModule.PlayoutAudioData((int8_t*)encodedBuffer,
bytesFromFile) == -1)
{
// End of file reached.
return -1;
}
encodedLengthInBytes = bytesFromFile;
}
if(_audioDecoder.Decode(unresampledAudioFrame,frequencyInHz,
(int8_t*)encodedBuffer,
encodedLengthInBytes) == -1)
{
return -1;
}
}
size_t outLen = 0;
if(_resampler.ResetIfNeeded(unresampledAudioFrame.sample_rate_hz_,
frequencyInHz, 1))
{
LOG(LS_WARNING) << "Get10msAudioFromFile() unexpected codec.";
// New sampling frequency. Update state.
outLen = static_cast<size_t>(frequencyInHz / 100);
memset(outBuffer, 0, outLen * sizeof(int16_t));
return 0;
}
_resampler.Push(unresampledAudioFrame.data_,
unresampledAudioFrame.samples_per_channel_,
outBuffer,
MAX_AUDIO_BUFFER_IN_SAMPLES,
outLen);
lengthInSamples = outLen;
if(_scaling != 1.0)
{
for (size_t i = 0;i < outLen; i++)
{
outBuffer[i] = (int16_t)(outBuffer[i] * _scaling);
}
}
_decodedLengthInMS += 10;
return 0;
}
int32_t FilePlayerImpl::RegisterModuleFileCallback(FileCallback* callback)
{
return _fileModule.SetModuleFileCallback(callback);
}
int32_t FilePlayerImpl::SetAudioScaling(float scaleFactor)
{
if((scaleFactor >= 0)&&(scaleFactor <= 2.0))
{
_scaling = scaleFactor;
return 0;
}
LOG(LS_WARNING) << "SetAudioScaling() non-allowed scale factor.";
return -1; return -1;
}
// Make sure that sample rate is 8,16 or 32 kHz. E.g. WAVE files may have
// other sampling rates.
if (_codec.plfreq == 11000) {
return 16000;
} else if (_codec.plfreq == 22000) {
return 32000;
} else if (_codec.plfreq == 44000) {
return 32000;
} else if (_codec.plfreq == 48000) {
return 32000;
} else {
return _codec.plfreq;
}
}
int32_t FilePlayerImpl::AudioCodec(CodecInst& audioCodec) const {
audioCodec = _codec;
return 0;
}
int32_t FilePlayerImpl::Get10msAudioFromFile(int16_t* outBuffer,
size_t& lengthInSamples,
int frequencyInHz) {
if (_codec.plfreq == 0) {
LOG(LS_WARNING) << "Get10msAudioFromFile() playing not started!"
<< " codec freq = " << _codec.plfreq
<< ", wanted freq = " << frequencyInHz;
return -1;
}
AudioFrame unresampledAudioFrame;
if (STR_CASE_CMP(_codec.plname, "L16") == 0) {
unresampledAudioFrame.sample_rate_hz_ = _codec.plfreq;
// L16 is un-encoded data. Just pull 10 ms.
size_t lengthInBytes = sizeof(unresampledAudioFrame.data_);
if (_fileModule.PlayoutAudioData((int8_t*)unresampledAudioFrame.data_,
lengthInBytes) == -1) {
// End of file reached.
return -1;
}
if (lengthInBytes == 0) {
lengthInSamples = 0;
return 0;
}
// One sample is two bytes.
unresampledAudioFrame.samples_per_channel_ = lengthInBytes >> 1;
} else {
// Decode will generate 10 ms of audio data. PlayoutAudioData(..)
// expects a full frame. If the frame size is larger than 10 ms,
// PlayoutAudioData(..) data should be called proportionally less often.
int16_t encodedBuffer[MAX_AUDIO_BUFFER_IN_SAMPLES];
size_t encodedLengthInBytes = 0;
if (++_numberOf10MsInDecoder >= _numberOf10MsPerFrame) {
_numberOf10MsInDecoder = 0;
size_t bytesFromFile = sizeof(encodedBuffer);
if (_fileModule.PlayoutAudioData((int8_t*)encodedBuffer, bytesFromFile) ==
-1) {
// End of file reached.
return -1;
}
encodedLengthInBytes = bytesFromFile;
}
if (_audioDecoder.Decode(unresampledAudioFrame, frequencyInHz,
(int8_t*)encodedBuffer,
encodedLengthInBytes) == -1) {
return -1;
}
}
size_t outLen = 0;
if (_resampler.ResetIfNeeded(unresampledAudioFrame.sample_rate_hz_,
frequencyInHz, 1)) {
LOG(LS_WARNING) << "Get10msAudioFromFile() unexpected codec.";
// New sampling frequency. Update state.
outLen = static_cast<size_t>(frequencyInHz / 100);
memset(outBuffer, 0, outLen * sizeof(int16_t));
return 0;
}
_resampler.Push(unresampledAudioFrame.data_,
unresampledAudioFrame.samples_per_channel_, outBuffer,
MAX_AUDIO_BUFFER_IN_SAMPLES, outLen);
lengthInSamples = outLen;
if (_scaling != 1.0) {
for (size_t i = 0; i < outLen; i++) {
outBuffer[i] = (int16_t)(outBuffer[i] * _scaling);
}
}
_decodedLengthInMS += 10;
return 0;
}
int32_t FilePlayerImpl::RegisterModuleFileCallback(FileCallback* callback) {
return _fileModule.SetModuleFileCallback(callback);
}
int32_t FilePlayerImpl::SetAudioScaling(float scaleFactor) {
if ((scaleFactor >= 0) && (scaleFactor <= 2.0)) {
_scaling = scaleFactor;
return 0;
}
LOG(LS_WARNING) << "SetAudioScaling() non-allowed scale factor.";
return -1;
} }
int32_t FilePlayerImpl::StartPlayingFile(const char* fileName, int32_t FilePlayerImpl::StartPlayingFile(const char* fileName,
@ -207,80 +171,66 @@ int32_t FilePlayerImpl::StartPlayingFile(const char* fileName,
float volumeScaling, float volumeScaling,
uint32_t notification, uint32_t notification,
uint32_t stopPosition, uint32_t stopPosition,
const CodecInst* codecInst) const CodecInst* codecInst) {
{ if (_fileFormat == kFileFormatPcm16kHzFile ||
if (_fileFormat == kFileFormatPcm16kHzFile || _fileFormat == kFileFormatPcm8kHzFile ||
_fileFormat == kFileFormatPcm8kHzFile|| _fileFormat == kFileFormatPcm32kHzFile) {
_fileFormat == kFileFormatPcm32kHzFile ) CodecInst codecInstL16;
{ strncpy(codecInstL16.plname, "L16", 32);
CodecInst codecInstL16; codecInstL16.pltype = 93;
strncpy(codecInstL16.plname,"L16",32); codecInstL16.channels = 1;
codecInstL16.pltype = 93;
codecInstL16.channels = 1;
if (_fileFormat == kFileFormatPcm8kHzFile) if (_fileFormat == kFileFormatPcm8kHzFile) {
{ codecInstL16.rate = 128000;
codecInstL16.rate = 128000; codecInstL16.plfreq = 8000;
codecInstL16.plfreq = 8000; codecInstL16.pacsize = 80;
codecInstL16.pacsize = 80;
} else if(_fileFormat == kFileFormatPcm16kHzFile) } else if (_fileFormat == kFileFormatPcm16kHzFile) {
{ codecInstL16.rate = 256000;
codecInstL16.rate = 256000; codecInstL16.plfreq = 16000;
codecInstL16.plfreq = 16000; codecInstL16.pacsize = 160;
codecInstL16.pacsize = 160;
}else if(_fileFormat == kFileFormatPcm32kHzFile) } else if (_fileFormat == kFileFormatPcm32kHzFile) {
{ codecInstL16.rate = 512000;
codecInstL16.rate = 512000; codecInstL16.plfreq = 32000;
codecInstL16.plfreq = 32000; codecInstL16.pacsize = 160;
codecInstL16.pacsize = 160; } else {
} else LOG(LS_ERROR) << "StartPlayingFile() sample frequency not "
{ << "supported for PCM format.";
LOG(LS_ERROR) << "StartPlayingFile() sample frequency not " return -1;
<< "supported for PCM format.";
return -1;
}
if (_fileModule.StartPlayingAudioFile(fileName, notification, loop,
_fileFormat, &codecInstL16,
startPosition,
stopPosition) == -1)
{
LOG(LS_WARNING) << "StartPlayingFile() failed to initialize "
<< "pcm file " << fileName;
return -1;
}
SetAudioScaling(volumeScaling);
}else if(_fileFormat == kFileFormatPreencodedFile)
{
if (_fileModule.StartPlayingAudioFile(fileName, notification, loop,
_fileFormat, codecInst) == -1)
{
LOG(LS_WARNING) << "StartPlayingFile() failed to initialize "
<< "pre-encoded file " << fileName;
return -1;
}
} else
{
CodecInst* no_inst = NULL;
if (_fileModule.StartPlayingAudioFile(fileName, notification, loop,
_fileFormat, no_inst,
startPosition,
stopPosition) == -1)
{
LOG(LS_WARNING) << "StartPlayingFile() failed to initialize file "
<< fileName;
return -1;
}
SetAudioScaling(volumeScaling);
} }
if (SetUpAudioDecoder() == -1)
{ if (_fileModule.StartPlayingAudioFile(fileName, notification, loop,
StopPlayingFile(); _fileFormat, &codecInstL16,
return -1; startPosition, stopPosition) == -1) {
LOG(LS_WARNING) << "StartPlayingFile() failed to initialize "
<< "pcm file " << fileName;
return -1;
} }
return 0; SetAudioScaling(volumeScaling);
} else if (_fileFormat == kFileFormatPreencodedFile) {
if (_fileModule.StartPlayingAudioFile(fileName, notification, loop,
_fileFormat, codecInst) == -1) {
LOG(LS_WARNING) << "StartPlayingFile() failed to initialize "
<< "pre-encoded file " << fileName;
return -1;
}
} else {
CodecInst* no_inst = NULL;
if (_fileModule.StartPlayingAudioFile(fileName, notification, loop,
_fileFormat, no_inst, startPosition,
stopPosition) == -1) {
LOG(LS_WARNING) << "StartPlayingFile() failed to initialize file "
<< fileName;
return -1;
}
SetAudioScaling(volumeScaling);
}
if (SetUpAudioDecoder() == -1) {
StopPlayingFile();
return -1;
}
return 0;
} }
int32_t FilePlayerImpl::StartPlayingFile(InStream& sourceStream, int32_t FilePlayerImpl::StartPlayingFile(InStream& sourceStream,
@ -288,115 +238,96 @@ int32_t FilePlayerImpl::StartPlayingFile(InStream& sourceStream,
float volumeScaling, float volumeScaling,
uint32_t notification, uint32_t notification,
uint32_t stopPosition, uint32_t stopPosition,
const CodecInst* codecInst) const CodecInst* codecInst) {
{ if (_fileFormat == kFileFormatPcm16kHzFile ||
if (_fileFormat == kFileFormatPcm16kHzFile || _fileFormat == kFileFormatPcm32kHzFile ||
_fileFormat == kFileFormatPcm32kHzFile || _fileFormat == kFileFormatPcm8kHzFile) {
_fileFormat == kFileFormatPcm8kHzFile) CodecInst codecInstL16;
{ strncpy(codecInstL16.plname, "L16", 32);
CodecInst codecInstL16; codecInstL16.pltype = 93;
strncpy(codecInstL16.plname,"L16",32); codecInstL16.channels = 1;
codecInstL16.pltype = 93;
codecInstL16.channels = 1;
if (_fileFormat == kFileFormatPcm8kHzFile) if (_fileFormat == kFileFormatPcm8kHzFile) {
{ codecInstL16.rate = 128000;
codecInstL16.rate = 128000; codecInstL16.plfreq = 8000;
codecInstL16.plfreq = 8000; codecInstL16.pacsize = 80;
codecInstL16.pacsize = 80;
}else if (_fileFormat == kFileFormatPcm16kHzFile) } else if (_fileFormat == kFileFormatPcm16kHzFile) {
{ codecInstL16.rate = 256000;
codecInstL16.rate = 256000; codecInstL16.plfreq = 16000;
codecInstL16.plfreq = 16000; codecInstL16.pacsize = 160;
codecInstL16.pacsize = 160;
}else if (_fileFormat == kFileFormatPcm32kHzFile) } else if (_fileFormat == kFileFormatPcm32kHzFile) {
{ codecInstL16.rate = 512000;
codecInstL16.rate = 512000; codecInstL16.plfreq = 32000;
codecInstL16.plfreq = 32000; codecInstL16.pacsize = 160;
codecInstL16.pacsize = 160;
}else
{
LOG(LS_ERROR) << "StartPlayingFile() sample frequency not "
<< "supported for PCM format.";
return -1;
}
if (_fileModule.StartPlayingAudioStream(sourceStream, notification,
_fileFormat, &codecInstL16,
startPosition,
stopPosition) == -1)
{
LOG(LS_ERROR) << "StartPlayingFile() failed to initialize stream "
<< "playout.";
return -1;
}
}else if(_fileFormat == kFileFormatPreencodedFile)
{
if (_fileModule.StartPlayingAudioStream(sourceStream, notification,
_fileFormat, codecInst) == -1)
{
LOG(LS_ERROR) << "StartPlayingFile() failed to initialize stream "
<< "playout.";
return -1;
}
} else { } else {
CodecInst* no_inst = NULL; LOG(LS_ERROR) << "StartPlayingFile() sample frequency not "
if (_fileModule.StartPlayingAudioStream(sourceStream, notification, << "supported for PCM format.";
_fileFormat, no_inst, return -1;
startPosition, }
stopPosition) == -1) if (_fileModule.StartPlayingAudioStream(
{ sourceStream, notification, _fileFormat, &codecInstL16,
LOG(LS_ERROR) << "StartPlayingFile() failed to initialize stream " startPosition, stopPosition) == -1) {
<< "playout."; LOG(LS_ERROR) << "StartPlayingFile() failed to initialize stream "
return -1; << "playout.";
} return -1;
} }
SetAudioScaling(volumeScaling);
if (SetUpAudioDecoder() == -1) } else if (_fileFormat == kFileFormatPreencodedFile) {
{ if (_fileModule.StartPlayingAudioStream(sourceStream, notification,
StopPlayingFile(); _fileFormat, codecInst) == -1) {
return -1; LOG(LS_ERROR) << "StartPlayingFile() failed to initialize stream "
<< "playout.";
return -1;
} }
return 0; } else {
CodecInst* no_inst = NULL;
if (_fileModule.StartPlayingAudioStream(sourceStream, notification,
_fileFormat, no_inst, startPosition,
stopPosition) == -1) {
LOG(LS_ERROR) << "StartPlayingFile() failed to initialize stream "
<< "playout.";
return -1;
}
}
SetAudioScaling(volumeScaling);
if (SetUpAudioDecoder() == -1) {
StopPlayingFile();
return -1;
}
return 0;
} }
int32_t FilePlayerImpl::StopPlayingFile() int32_t FilePlayerImpl::StopPlayingFile() {
{ memset(&_codec, 0, sizeof(CodecInst));
memset(&_codec, 0, sizeof(CodecInst)); _numberOf10MsPerFrame = 0;
_numberOf10MsPerFrame = 0; _numberOf10MsInDecoder = 0;
_numberOf10MsInDecoder = 0; return _fileModule.StopPlaying();
return _fileModule.StopPlaying();
} }
bool FilePlayerImpl::IsPlayingFile() const bool FilePlayerImpl::IsPlayingFile() const {
{ return _fileModule.IsPlaying();
return _fileModule.IsPlaying();
} }
int32_t FilePlayerImpl::GetPlayoutPosition(uint32_t& durationMs) int32_t FilePlayerImpl::GetPlayoutPosition(uint32_t& durationMs) {
{ return _fileModule.PlayoutPositionMs(durationMs);
return _fileModule.PlayoutPositionMs(durationMs);
} }
int32_t FilePlayerImpl::SetUpAudioDecoder() int32_t FilePlayerImpl::SetUpAudioDecoder() {
{ if ((_fileModule.codec_info(_codec) == -1)) {
if ((_fileModule.codec_info(_codec) == -1)) LOG(LS_WARNING) << "Failed to retrieve codec info of file data.";
{ return -1;
LOG(LS_WARNING) << "Failed to retrieve codec info of file data."; }
return -1; if (STR_CASE_CMP(_codec.plname, "L16") != 0 &&
} _audioDecoder.SetDecodeCodec(_codec) == -1) {
if( STR_CASE_CMP(_codec.plname, "L16") != 0 && LOG(LS_WARNING) << "SetUpAudioDecoder() codec " << _codec.plname
_audioDecoder.SetDecodeCodec(_codec) == -1) << " not supported.";
{ return -1;
LOG(LS_WARNING) << "SetUpAudioDecoder() codec " << _codec.plname }
<< " not supported."; _numberOf10MsPerFrame = _codec.pacsize / (_codec.plfreq / 100);
return -1; _numberOf10MsInDecoder = 0;
} return 0;
_numberOf10MsPerFrame = _codec.pacsize / (_codec.plfreq / 100);
_numberOf10MsInDecoder = 0;
return 0;
} }
} // namespace webrtc } // namespace webrtc

86
webrtc/modules/utility/source/file_player_impl.h
View File

@ -22,57 +22,53 @@
#include "webrtc/typedefs.h" #include "webrtc/typedefs.h"
namespace webrtc { namespace webrtc {
class FilePlayerImpl : public FilePlayer class FilePlayerImpl : public FilePlayer {
{ public:
public: FilePlayerImpl(uint32_t instanceID, FileFormats fileFormat);
FilePlayerImpl(uint32_t instanceID, FileFormats fileFormat); ~FilePlayerImpl();
~FilePlayerImpl();
virtual int Get10msAudioFromFile( virtual int Get10msAudioFromFile(int16_t* outBuffer,
int16_t* outBuffer, size_t& lengthInSamples,
size_t& lengthInSamples, int frequencyInHz);
int frequencyInHz); virtual int32_t RegisterModuleFileCallback(FileCallback* callback);
virtual int32_t RegisterModuleFileCallback(FileCallback* callback); virtual int32_t StartPlayingFile(const char* fileName,
virtual int32_t StartPlayingFile( bool loop,
const char* fileName, uint32_t startPosition,
bool loop, float volumeScaling,
uint32_t startPosition, uint32_t notification,
float volumeScaling, uint32_t stopPosition = 0,
uint32_t notification, const CodecInst* codecInst = NULL);
uint32_t stopPosition = 0, virtual int32_t StartPlayingFile(InStream& sourceStream,
const CodecInst* codecInst = NULL); uint32_t startPosition,
virtual int32_t StartPlayingFile( float volumeScaling,
InStream& sourceStream, uint32_t notification,
uint32_t startPosition, uint32_t stopPosition = 0,
float volumeScaling, const CodecInst* codecInst = NULL);
uint32_t notification, virtual int32_t StopPlayingFile();
uint32_t stopPosition = 0, virtual bool IsPlayingFile() const;
const CodecInst* codecInst = NULL); virtual int32_t GetPlayoutPosition(uint32_t& durationMs);
virtual int32_t StopPlayingFile(); virtual int32_t AudioCodec(CodecInst& audioCodec) const;
virtual bool IsPlayingFile() const; virtual int32_t Frequency() const;
virtual int32_t GetPlayoutPosition(uint32_t& durationMs); virtual int32_t SetAudioScaling(float scaleFactor);
virtual int32_t AudioCodec(CodecInst& audioCodec) const;
virtual int32_t Frequency() const;
virtual int32_t SetAudioScaling(float scaleFactor);
protected: protected:
int32_t SetUpAudioDecoder(); int32_t SetUpAudioDecoder();
uint32_t _instanceID; uint32_t _instanceID;
const FileFormats _fileFormat; const FileFormats _fileFormat;
MediaFile& _fileModule; MediaFile& _fileModule;
uint32_t _decodedLengthInMS; uint32_t _decodedLengthInMS;
private: private:
AudioCoder _audioDecoder; AudioCoder _audioDecoder;
CodecInst _codec; CodecInst _codec;
int32_t _numberOf10MsPerFrame; int32_t _numberOf10MsPerFrame;
int32_t _numberOf10MsInDecoder; int32_t _numberOf10MsInDecoder;
Resampler _resampler; Resampler _resampler;
float _scaling; float _scaling;
}; };
} // namespace webrtc } // namespace webrtc
#endif // WEBRTC_MODULES_UTILITY_SOURCE_FILE_PLAYER_IMPL_H_ #endif // WEBRTC_MODULES_UTILITY_SOURCE_FILE_PLAYER_IMPL_H_

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

@ -55,9 +55,8 @@ class FilePlayerTest : public ::testing::Test {
const std::string& ref_checksum, const std::string& ref_checksum,
int output_length_ms) { int output_length_ms) {
const float kScaling = 1; const float kScaling = 1;
ASSERT_EQ(0, ASSERT_EQ(0, player_->StartPlayingFile(input_file.c_str(), false, 0,
player_->StartPlayingFile( kScaling, 0, 0, NULL));
input_file.c_str(), false, 0, kScaling, 0, 0, NULL));
rtc::Md5Digest checksum; rtc::Md5Digest checksum;
for (int i = 0; i < output_length_ms / 10; ++i) { for (int i = 0; i < output_length_ms / 10; ++i) {
int16_t out[10 * kSampleRateHz / 1000] = {0}; int16_t out[10 * kSampleRateHz / 1000] = {0};

339
webrtc/modules/utility/source/file_recorder_impl.cc
View File

@ -15,245 +15,192 @@
namespace webrtc { namespace webrtc {
FileRecorder* FileRecorder::CreateFileRecorder(uint32_t instanceID, FileRecorder* FileRecorder::CreateFileRecorder(uint32_t instanceID,
FileFormats fileFormat) FileFormats fileFormat) {
{ return new FileRecorderImpl(instanceID, fileFormat);
return new FileRecorderImpl(instanceID, fileFormat);
} }
void FileRecorder::DestroyFileRecorder(FileRecorder* recorder) void FileRecorder::DestroyFileRecorder(FileRecorder* recorder) {
{ delete recorder;
delete recorder;
} }
FileRecorderImpl::FileRecorderImpl(uint32_t instanceID, FileRecorderImpl::FileRecorderImpl(uint32_t instanceID, FileFormats fileFormat)
FileFormats fileFormat)
: _instanceID(instanceID), : _instanceID(instanceID),
_fileFormat(fileFormat), _fileFormat(fileFormat),
_moduleFile(MediaFile::CreateMediaFile(_instanceID)), _moduleFile(MediaFile::CreateMediaFile(_instanceID)),
codec_info_(), codec_info_(),
_audioBuffer(), _audioBuffer(),
_audioEncoder(instanceID), _audioEncoder(instanceID),
_audioResampler() _audioResampler() {}
{
FileRecorderImpl::~FileRecorderImpl() {
MediaFile::DestroyMediaFile(_moduleFile);
} }
FileRecorderImpl::~FileRecorderImpl() FileFormats FileRecorderImpl::RecordingFileFormat() const {
{ return _fileFormat;
MediaFile::DestroyMediaFile(_moduleFile);
} }
FileFormats FileRecorderImpl::RecordingFileFormat() const int32_t FileRecorderImpl::RegisterModuleFileCallback(FileCallback* callback) {
{ if (_moduleFile == NULL) {
return _fileFormat; return -1;
}
return _moduleFile->SetModuleFileCallback(callback);
} }
int32_t FileRecorderImpl::RegisterModuleFileCallback( int32_t FileRecorderImpl::StartRecordingAudioFile(const char* fileName,
FileCallback* callback) const CodecInst& codecInst,
{ uint32_t notificationTimeMs) {
if(_moduleFile == NULL) if (_moduleFile == NULL) {
{ return -1;
return -1; }
codec_info_ = codecInst;
int32_t retVal = 0;
retVal = _moduleFile->StartRecordingAudioFile(fileName, _fileFormat,
codecInst, notificationTimeMs);
if (retVal == 0) {
retVal = SetUpAudioEncoder();
}
if (retVal != 0) {
LOG(LS_WARNING) << "Failed to initialize file " << fileName
<< " for recording.";
if (IsRecording()) {
StopRecording();
} }
return _moduleFile->SetModuleFileCallback(callback); }
return retVal;
} }
int32_t FileRecorderImpl::StartRecordingAudioFile( int32_t FileRecorderImpl::StartRecordingAudioFile(OutStream& destStream,
const char* fileName, const CodecInst& codecInst,
const CodecInst& codecInst, uint32_t notificationTimeMs) {
uint32_t notificationTimeMs) codec_info_ = codecInst;
{ int32_t retVal = _moduleFile->StartRecordingAudioStream(
if(_moduleFile == NULL) destStream, _fileFormat, codecInst, notificationTimeMs);
{
return -1;
}
codec_info_ = codecInst;
int32_t retVal = 0;
retVal =_moduleFile->StartRecordingAudioFile(fileName, _fileFormat,
codecInst,
notificationTimeMs);
if( retVal == 0) if (retVal == 0) {
{ retVal = SetUpAudioEncoder();
retVal = SetUpAudioEncoder(); }
} if (retVal != 0) {
if( retVal != 0) LOG(LS_WARNING) << "Failed to initialize outStream for recording.";
{
LOG(LS_WARNING) << "Failed to initialize file " << fileName
<< " for recording.";
if(IsRecording()) if (IsRecording()) {
{ StopRecording();
StopRecording();
}
} }
return retVal; }
return retVal;
} }
int32_t FileRecorderImpl::StartRecordingAudioFile( int32_t FileRecorderImpl::StopRecording() {
OutStream& destStream, memset(&codec_info_, 0, sizeof(CodecInst));
const CodecInst& codecInst, return _moduleFile->StopRecording();
uint32_t notificationTimeMs)
{
codec_info_ = codecInst;
int32_t retVal = _moduleFile->StartRecordingAudioStream(
destStream,
_fileFormat,
codecInst,
notificationTimeMs);
if( retVal == 0)
{
retVal = SetUpAudioEncoder();
}
if( retVal != 0)
{
LOG(LS_WARNING) << "Failed to initialize outStream for recording.";
if(IsRecording())
{
StopRecording();
}
}
return retVal;
} }
int32_t FileRecorderImpl::StopRecording() bool FileRecorderImpl::IsRecording() const {
{ return _moduleFile->IsRecording();
memset(&codec_info_, 0, sizeof(CodecInst));
return _moduleFile->StopRecording();
}
bool FileRecorderImpl::IsRecording() const
{
return _moduleFile->IsRecording();
} }
int32_t FileRecorderImpl::RecordAudioToFile( int32_t FileRecorderImpl::RecordAudioToFile(
const AudioFrame& incomingAudioFrame) const AudioFrame& incomingAudioFrame) {
{ if (codec_info_.plfreq == 0) {
if (codec_info_.plfreq == 0) LOG(LS_WARNING) << "RecordAudioToFile() recording audio is not "
{ << "turned on.";
LOG(LS_WARNING) << "RecordAudioToFile() recording audio is not " return -1;
<< "turned on."; }
return -1; AudioFrame tempAudioFrame;
tempAudioFrame.samples_per_channel_ = 0;
if (incomingAudioFrame.num_channels_ == 2 && !_moduleFile->IsStereo()) {
// Recording mono but incoming audio is (interleaved) stereo.
tempAudioFrame.num_channels_ = 1;
tempAudioFrame.sample_rate_hz_ = incomingAudioFrame.sample_rate_hz_;
tempAudioFrame.samples_per_channel_ =
incomingAudioFrame.samples_per_channel_;
for (size_t i = 0; i < (incomingAudioFrame.samples_per_channel_); i++) {
// Sample value is the average of left and right buffer rounded to
// closest integer value. Note samples can be either 1 or 2 byte.
tempAudioFrame.data_[i] = ((incomingAudioFrame.data_[2 * i] +
incomingAudioFrame.data_[(2 * i) + 1] + 1) >>
1);
} }
AudioFrame tempAudioFrame; } else if (incomingAudioFrame.num_channels_ == 1 && _moduleFile->IsStereo()) {
tempAudioFrame.samples_per_channel_ = 0; // Recording stereo but incoming audio is mono.
if( incomingAudioFrame.num_channels_ == 2 && tempAudioFrame.num_channels_ = 2;
!_moduleFile->IsStereo()) tempAudioFrame.sample_rate_hz_ = incomingAudioFrame.sample_rate_hz_;
{ tempAudioFrame.samples_per_channel_ =
// Recording mono but incoming audio is (interleaved) stereo. incomingAudioFrame.samples_per_channel_;
tempAudioFrame.num_channels_ = 1; for (size_t i = 0; i < (incomingAudioFrame.samples_per_channel_); i++) {
tempAudioFrame.sample_rate_hz_ = incomingAudioFrame.sample_rate_hz_; // Duplicate sample to both channels
tempAudioFrame.samples_per_channel_ = tempAudioFrame.data_[2 * i] = incomingAudioFrame.data_[i];
incomingAudioFrame.samples_per_channel_; tempAudioFrame.data_[2 * i + 1] = incomingAudioFrame.data_[i];
for (size_t i = 0;
i < (incomingAudioFrame.samples_per_channel_); i++)
{
// Sample value is the average of left and right buffer rounded to
// closest integer value. Note samples can be either 1 or 2 byte.
tempAudioFrame.data_[i] =
((incomingAudioFrame.data_[2 * i] +
incomingAudioFrame.data_[(2 * i) + 1] + 1) >> 1);
}
}
else if( incomingAudioFrame.num_channels_ == 1 &&
_moduleFile->IsStereo())
{
// Recording stereo but incoming audio is mono.
tempAudioFrame.num_channels_ = 2;
tempAudioFrame.sample_rate_hz_ = incomingAudioFrame.sample_rate_hz_;
tempAudioFrame.samples_per_channel_ =
incomingAudioFrame.samples_per_channel_;
for (size_t i = 0;
i < (incomingAudioFrame.samples_per_channel_); i++)
{
// Duplicate sample to both channels
tempAudioFrame.data_[2*i] =
incomingAudioFrame.data_[i];
tempAudioFrame.data_[2*i+1] =
incomingAudioFrame.data_[i];
}
} }
}
const AudioFrame* ptrAudioFrame = &incomingAudioFrame; const AudioFrame* ptrAudioFrame = &incomingAudioFrame;
if(tempAudioFrame.samples_per_channel_ != 0) if (tempAudioFrame.samples_per_channel_ != 0) {
{ // If ptrAudioFrame is not empty it contains the audio to be recorded.
// If ptrAudioFrame is not empty it contains the audio to be recorded. ptrAudioFrame = &tempAudioFrame;
ptrAudioFrame = &tempAudioFrame; }
}
// Encode the audio data before writing to file. Don't encode if the codec // Encode the audio data before writing to file. Don't encode if the codec
// is PCM. // is PCM.
// NOTE: stereo recording is only supported for WAV files. // NOTE: stereo recording is only supported for WAV files.
// TODO (hellner): WAV expect PCM in little endian byte order. Not // TODO (hellner): WAV expect PCM in little endian byte order. Not
// "encoding" with PCM coder should be a problem for big endian systems. // "encoding" with PCM coder should be a problem for big endian systems.
size_t encodedLenInBytes = 0; size_t encodedLenInBytes = 0;
if (_fileFormat == kFileFormatPreencodedFile || if (_fileFormat == kFileFormatPreencodedFile ||
STR_CASE_CMP(codec_info_.plname, "L16") != 0) STR_CASE_CMP(codec_info_.plname, "L16") != 0) {
{ if (_audioEncoder.Encode(*ptrAudioFrame, _audioBuffer, encodedLenInBytes) ==
if (_audioEncoder.Encode(*ptrAudioFrame, _audioBuffer, -1) {
encodedLenInBytes) == -1) LOG(LS_WARNING) << "RecordAudioToFile() codec " << codec_info_.plname
{ << " not supported or failed to encode stream.";
LOG(LS_WARNING) << "RecordAudioToFile() codec " return -1;
<< codec_info_.plname
<< " not supported or failed to encode stream.";
return -1;
}
} else {
size_t outLen = 0;
_audioResampler.ResetIfNeeded(ptrAudioFrame->sample_rate_hz_,
codec_info_.plfreq,
ptrAudioFrame->num_channels_);
_audioResampler.Push(ptrAudioFrame->data_,
ptrAudioFrame->samples_per_channel_ *
ptrAudioFrame->num_channels_,
(int16_t*)_audioBuffer,
MAX_AUDIO_BUFFER_IN_BYTES, outLen);
encodedLenInBytes = outLen * sizeof(int16_t);
} }
} else {
size_t outLen = 0;
_audioResampler.ResetIfNeeded(ptrAudioFrame->sample_rate_hz_,
codec_info_.plfreq,
ptrAudioFrame->num_channels_);
_audioResampler.Push(
ptrAudioFrame->data_,
ptrAudioFrame->samples_per_channel_ * ptrAudioFrame->num_channels_,
(int16_t*)_audioBuffer, MAX_AUDIO_BUFFER_IN_BYTES, outLen);
encodedLenInBytes = outLen * sizeof(int16_t);
}
// Codec may not be operating at a frame rate of 10 ms. Whenever enough // Codec may not be operating at a frame rate of 10 ms. Whenever enough
// 10 ms chunks of data has been pushed to the encoder an encoded frame // 10 ms chunks of data has been pushed to the encoder an encoded frame
// will be available. Wait until then. // will be available. Wait until then.
if (encodedLenInBytes) if (encodedLenInBytes) {
{ if (WriteEncodedAudioData(_audioBuffer, encodedLenInBytes) == -1) {
if (WriteEncodedAudioData(_audioBuffer, encodedLenInBytes) == -1) return -1;
{
return -1;
}
} }
return 0; }
return 0;
} }
int32_t FileRecorderImpl::SetUpAudioEncoder() int32_t FileRecorderImpl::SetUpAudioEncoder() {
{ if (_fileFormat == kFileFormatPreencodedFile ||
if (_fileFormat == kFileFormatPreencodedFile || STR_CASE_CMP(codec_info_.plname, "L16") != 0) {
STR_CASE_CMP(codec_info_.plname, "L16") != 0) if (_audioEncoder.SetEncodeCodec(codec_info_) == -1) {
{ LOG(LS_ERROR) << "SetUpAudioEncoder() codec " << codec_info_.plname
if(_audioEncoder.SetEncodeCodec(codec_info_) == -1) << " not supported.";
{ return -1;
LOG(LS_ERROR) << "SetUpAudioEncoder() codec "
<< codec_info_.plname << " not supported.";
return -1;
}
} }
return 0; }
return 0;
} }
int32_t FileRecorderImpl::codec_info(CodecInst& codecInst) const int32_t FileRecorderImpl::codec_info(CodecInst& codecInst) const {
{ if (codec_info_.plfreq == 0) {
if(codec_info_.plfreq == 0) return -1;
{ }
return -1; codecInst = codec_info_;
} return 0;
codecInst = codec_info_;
return 0;
} }
int32_t FileRecorderImpl::WriteEncodedAudioData(const int8_t* audioBuffer, int32_t FileRecorderImpl::WriteEncodedAudioData(const int8_t* audioBuffer,
size_t bufferLength) size_t bufferLength) {
{ return _moduleFile->IncomingAudioData(audioBuffer, bufferLength);
return _moduleFile->IncomingAudioData(audioBuffer, bufferLength);
} }
} // namespace webrtc } // namespace webrtc

66
webrtc/modules/utility/source/file_recorder_impl.h
View File

@ -31,49 +31,45 @@
namespace webrtc { namespace webrtc {
// The largest decoded frame size in samples (60ms with 32kHz sample rate). // The largest decoded frame size in samples (60ms with 32kHz sample rate).
enum { MAX_AUDIO_BUFFER_IN_SAMPLES = 60*32}; enum { MAX_AUDIO_BUFFER_IN_SAMPLES = 60 * 32 };
enum { MAX_AUDIO_BUFFER_IN_BYTES = MAX_AUDIO_BUFFER_IN_SAMPLES*2}; enum { MAX_AUDIO_BUFFER_IN_BYTES = MAX_AUDIO_BUFFER_IN_SAMPLES * 2 };
enum { kMaxAudioBufferQueueLength = 100 }; enum { kMaxAudioBufferQueueLength = 100 };
class CriticalSectionWrapper; class CriticalSectionWrapper;
class FileRecorderImpl : public FileRecorder class FileRecorderImpl : public FileRecorder {
{ public:
public: FileRecorderImpl(uint32_t instanceID, FileFormats fileFormat);
FileRecorderImpl(uint32_t instanceID, FileFormats fileFormat); virtual ~FileRecorderImpl();
virtual ~FileRecorderImpl();
// FileRecorder functions. // FileRecorder functions.
int32_t RegisterModuleFileCallback(FileCallback* callback) override; int32_t RegisterModuleFileCallback(FileCallback* callback) override;
FileFormats RecordingFileFormat() const override; FileFormats RecordingFileFormat() const override;
int32_t StartRecordingAudioFile( int32_t StartRecordingAudioFile(const char* fileName,
const char* fileName, const CodecInst& codecInst,
const CodecInst& codecInst, uint32_t notificationTimeMs) override;
uint32_t notificationTimeMs) override; int32_t StartRecordingAudioFile(OutStream& destStream,
int32_t StartRecordingAudioFile( const CodecInst& codecInst,
OutStream& destStream, uint32_t notificationTimeMs) override;
const CodecInst& codecInst, int32_t StopRecording() override;
uint32_t notificationTimeMs) override; bool IsRecording() const override;
int32_t StopRecording() override; int32_t codec_info(CodecInst& codecInst) const override;
bool IsRecording() const override; int32_t RecordAudioToFile(const AudioFrame& frame) override;
int32_t codec_info(CodecInst& codecInst) const override;
int32_t RecordAudioToFile(const AudioFrame& frame) override;
protected: protected:
int32_t WriteEncodedAudioData(const int8_t* audioBuffer, int32_t WriteEncodedAudioData(const int8_t* audioBuffer, size_t bufferLength);
size_t bufferLength);
int32_t SetUpAudioEncoder(); int32_t SetUpAudioEncoder();
uint32_t _instanceID; uint32_t _instanceID;
FileFormats _fileFormat; FileFormats _fileFormat;
MediaFile* _moduleFile; MediaFile* _moduleFile;
private: private:
CodecInst codec_info_; CodecInst codec_info_;
int8_t _audioBuffer[MAX_AUDIO_BUFFER_IN_BYTES]; int8_t _audioBuffer[MAX_AUDIO_BUFFER_IN_BYTES];
AudioCoder _audioEncoder; AudioCoder _audioEncoder;
Resampler _audioResampler; Resampler _audioResampler;
}; };
} // namespace webrtc } // namespace webrtc
#endif // WEBRTC_MODULES_UTILITY_SOURCE_FILE_RECORDER_IMPL_H_ #endif // WEBRTC_MODULES_UTILITY_SOURCE_FILE_RECORDER_IMPL_H_