| /* |
| * 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 <assert.h> |
| |
| #include "modules/media_file/media_file_impl.h" |
| #include "rtc_base/format_macros.h" |
| #include "rtc_base/logging.h" |
| #include "system_wrappers/include/file_wrapper.h" |
| |
| namespace webrtc { |
| MediaFile* MediaFile::CreateMediaFile(const int32_t id) { |
| return new MediaFileImpl(id); |
| } |
| |
| void MediaFile::DestroyMediaFile(MediaFile* module) { |
| delete static_cast<MediaFileImpl*>(module); |
| } |
| |
| MediaFileImpl::MediaFileImpl(const int32_t id) |
| : _id(id), |
| _ptrFileUtilityObj(NULL), |
| codec_info_(), |
| _ptrInStream(NULL), |
| _ptrOutStream(NULL), |
| _fileFormat((FileFormats)-1), |
| _recordDurationMs(0), |
| _playoutPositionMs(0), |
| _notificationMs(0), |
| _playingActive(false), |
| _recordingActive(false), |
| _isStereo(false), |
| _openFile(false), |
| _fileName(), |
| _ptrCallback(NULL) { |
| RTC_LOG(LS_INFO) << "MediaFileImpl()"; |
| |
| codec_info_.plname[0] = '\0'; |
| _fileName[0] = '\0'; |
| } |
| |
| MediaFileImpl::~MediaFileImpl() { |
| RTC_LOG(LS_INFO) << "~MediaFileImpl()"; |
| { |
| rtc::CritScope lock(&_crit); |
| |
| if (_playingActive) { |
| StopPlaying(); |
| } |
| |
| if (_recordingActive) { |
| StopRecording(); |
| } |
| |
| delete _ptrFileUtilityObj; |
| |
| if (_openFile) { |
| delete _ptrInStream; |
| _ptrInStream = NULL; |
| delete _ptrOutStream; |
| _ptrOutStream = NULL; |
| } |
| } |
| } |
| |
| int64_t MediaFileImpl::TimeUntilNextProcess() { |
| RTC_LOG(LS_WARNING) |
| << "TimeUntilNextProcess: This method is not used by MediaFile class."; |
| return -1; |
| } |
| |
| void MediaFileImpl::Process() { |
| RTC_LOG(LS_WARNING) << "Process: This method is not used by MediaFile class."; |
| } |
| |
| int32_t MediaFileImpl::PlayoutAudioData(int8_t* buffer, |
| size_t& dataLengthInBytes) { |
| RTC_LOG(LS_INFO) << "MediaFileImpl::PlayoutData(buffer= " |
| << static_cast<void*>(buffer) |
| << ", bufLen= " << dataLengthInBytes << ")"; |
| |
| const size_t bufferLengthInBytes = dataLengthInBytes; |
| dataLengthInBytes = 0; |
| |
| if (buffer == NULL || bufferLengthInBytes == 0) { |
| RTC_LOG(LS_ERROR) << "Buffer pointer or length is NULL!"; |
| return -1; |
| } |
| |
| int32_t bytesRead = 0; |
| { |
| rtc::CritScope lock(&_crit); |
| |
| if (!_playingActive) { |
| RTC_LOG(LS_WARNING) << "Not currently playing!"; |
| return -1; |
| } |
| |
| if (!_ptrFileUtilityObj) { |
| RTC_LOG(LS_ERROR) << "Playing, but no FileUtility object!"; |
| StopPlaying(); |
| return -1; |
| } |
| |
| switch (_fileFormat) { |
| case kFileFormatPcm48kHzFile: |
| case kFileFormatPcm32kHzFile: |
| case kFileFormatPcm16kHzFile: |
| case kFileFormatPcm8kHzFile: |
| bytesRead = _ptrFileUtilityObj->ReadPCMData(*_ptrInStream, buffer, |
| bufferLengthInBytes); |
| break; |
| case kFileFormatCompressedFile: |
| bytesRead = _ptrFileUtilityObj->ReadCompressedData( |
| *_ptrInStream, buffer, bufferLengthInBytes); |
| break; |
| case kFileFormatWavFile: |
| bytesRead = _ptrFileUtilityObj->ReadWavDataAsMono(*_ptrInStream, buffer, |
| bufferLengthInBytes); |
| break; |
| case kFileFormatPreencodedFile: |
| bytesRead = _ptrFileUtilityObj->ReadPreEncodedData( |
| *_ptrInStream, buffer, bufferLengthInBytes); |
| if (bytesRead > 0) { |
| dataLengthInBytes = static_cast<size_t>(bytesRead); |
| return 0; |
| } |
| break; |
| default: { |
| RTC_LOG(LS_ERROR) << "Invalid file format: " << _fileFormat; |
| assert(false); |
| break; |
| } |
| } |
| |
| if (bytesRead > 0) { |
| dataLengthInBytes = static_cast<size_t>(bytesRead); |
| } |
| } |
| HandlePlayCallbacks(bytesRead); |
| return 0; |
| } |
| |
| void MediaFileImpl::HandlePlayCallbacks(int32_t bytesRead) { |
| bool playEnded = false; |
| uint32_t callbackNotifyMs = 0; |
| |
| if (bytesRead > 0) { |
| // Check if it's time for PlayNotification(..). |
| _playoutPositionMs = _ptrFileUtilityObj->PlayoutPositionMs(); |
| if (_notificationMs) { |
| if (_playoutPositionMs >= _notificationMs) { |
| _notificationMs = 0; |
| callbackNotifyMs = _playoutPositionMs; |
| } |
| } |
| } else { |
| // If no bytes were read assume end of file. |
| StopPlaying(); |
| playEnded = true; |
| } |
| |
| // Only _callbackCrit may and should be taken when making callbacks. |
| rtc::CritScope lock(&_callbackCrit); |
| if (_ptrCallback) { |
| if (callbackNotifyMs) { |
| _ptrCallback->PlayNotification(_id, callbackNotifyMs); |
| } |
| if (playEnded) { |
| _ptrCallback->PlayFileEnded(_id); |
| } |
| } |
| } |
| |
| int32_t MediaFileImpl::PlayoutStereoData(int8_t* bufferLeft, |
| int8_t* bufferRight, |
| size_t& dataLengthInBytes) { |
| RTC_LOG(LS_INFO) << "MediaFileImpl::PlayoutStereoData(Left = " |
| << static_cast<void*>(bufferLeft) |
| << ", Right = " << static_cast<void*>(bufferRight) |
| << ", Len= " << dataLengthInBytes << ")"; |
| |
| const size_t bufferLengthInBytes = dataLengthInBytes; |
| dataLengthInBytes = 0; |
| |
| if (bufferLeft == NULL || bufferRight == NULL || bufferLengthInBytes == 0) { |
| RTC_LOG(LS_ERROR) << "A buffer pointer or the length is NULL!"; |
| return -1; |
| } |
| |
| bool playEnded = false; |
| uint32_t callbackNotifyMs = 0; |
| { |
| rtc::CritScope lock(&_crit); |
| |
| if (!_playingActive || !_isStereo) { |
| RTC_LOG(LS_WARNING) << "Not currently playing stereo!"; |
| return -1; |
| } |
| |
| if (!_ptrFileUtilityObj) { |
| RTC_LOG(LS_ERROR) |
| << "Playing stereo, but the FileUtility objects is NULL!"; |
| StopPlaying(); |
| return -1; |
| } |
| |
| // Stereo playout only supported for WAV files. |
| int32_t bytesRead = 0; |
| switch (_fileFormat) { |
| case kFileFormatWavFile: |
| bytesRead = _ptrFileUtilityObj->ReadWavDataAsStereo( |
| *_ptrInStream, bufferLeft, bufferRight, bufferLengthInBytes); |
| break; |
| default: |
| RTC_LOG(LS_ERROR) |
| << "Trying to read non-WAV as stereo audio (not supported)"; |
| break; |
| } |
| |
| if (bytesRead > 0) { |
| dataLengthInBytes = static_cast<size_t>(bytesRead); |
| |
| // Check if it's time for PlayNotification(..). |
| _playoutPositionMs = _ptrFileUtilityObj->PlayoutPositionMs(); |
| if (_notificationMs) { |
| if (_playoutPositionMs >= _notificationMs) { |
| _notificationMs = 0; |
| callbackNotifyMs = _playoutPositionMs; |
| } |
| } |
| } else { |
| // If no bytes were read assume end of file. |
| StopPlaying(); |
| playEnded = true; |
| } |
| } |
| |
| rtc::CritScope lock(&_callbackCrit); |
| if (_ptrCallback) { |
| if (callbackNotifyMs) { |
| _ptrCallback->PlayNotification(_id, callbackNotifyMs); |
| } |
| if (playEnded) { |
| _ptrCallback->PlayFileEnded(_id); |
| } |
| } |
| return 0; |
| } |
| |
| int32_t MediaFileImpl::StartPlayingAudioFile(const char* fileName, |
| const uint32_t notificationTimeMs, |
| const bool loop, |
| const FileFormats format, |
| const CodecInst* codecInst, |
| const uint32_t startPointMs, |
| const uint32_t stopPointMs) { |
| if (!ValidFileName(fileName)) { |
| return -1; |
| } |
| if (!ValidFileFormat(format, codecInst)) { |
| return -1; |
| } |
| if (!ValidFilePositions(startPointMs, stopPointMs)) { |
| return -1; |
| } |
| |
| // Check that the file will play longer than notificationTimeMs ms. |
| if ((startPointMs && stopPointMs && !loop) && |
| (notificationTimeMs > (stopPointMs - startPointMs))) { |
| RTC_LOG(LS_ERROR) << "specified notification time is longer than amount of" |
| << " ms that will be played"; |
| return -1; |
| } |
| |
| FileWrapper* inputStream = FileWrapper::Create(); |
| if (inputStream == NULL) { |
| RTC_LOG(LS_INFO) << "Failed to allocate input stream for file " << fileName; |
| return -1; |
| } |
| |
| if (!inputStream->OpenFile(fileName, true)) { |
| delete inputStream; |
| RTC_LOG(LS_ERROR) << "Could not open input file " << fileName; |
| return -1; |
| } |
| |
| if (StartPlayingStream(*inputStream, loop, notificationTimeMs, format, |
| codecInst, startPointMs, stopPointMs) == -1) { |
| inputStream->CloseFile(); |
| delete inputStream; |
| return -1; |
| } |
| |
| rtc::CritScope lock(&_crit); |
| _openFile = true; |
| strncpy(_fileName, fileName, sizeof(_fileName)); |
| _fileName[sizeof(_fileName) - 1] = '\0'; |
| return 0; |
| } |
| |
| int32_t MediaFileImpl::StartPlayingAudioStream( |
| InStream& stream, |
| const uint32_t notificationTimeMs, |
| const FileFormats format, |
| const CodecInst* codecInst, |
| const uint32_t startPointMs, |
| const uint32_t stopPointMs) { |
| return StartPlayingStream(stream, false, notificationTimeMs, format, |
| codecInst, startPointMs, stopPointMs); |
| } |
| |
| int32_t MediaFileImpl::StartPlayingStream(InStream& stream, |
| bool loop, |
| const uint32_t notificationTimeMs, |
| const FileFormats format, |
| const CodecInst* codecInst, |
| const uint32_t startPointMs, |
| const uint32_t stopPointMs) { |
| if (!ValidFileFormat(format, codecInst)) { |
| return -1; |
| } |
| |
| if (!ValidFilePositions(startPointMs, stopPointMs)) { |
| return -1; |
| } |
| |
| rtc::CritScope lock(&_crit); |
| if (_playingActive || _recordingActive) { |
| RTC_LOG(LS_ERROR) |
| << "StartPlaying called, but already playing or recording file " |
| << ((_fileName[0] == '\0') ? "(name not set)" : _fileName); |
| return -1; |
| } |
| |
| if (_ptrFileUtilityObj != NULL) { |
| RTC_LOG(LS_ERROR) |
| << "StartPlaying called, but FileUtilityObj already exists!"; |
| StopPlaying(); |
| return -1; |
| } |
| |
| _ptrFileUtilityObj = new ModuleFileUtility(); |
| if (_ptrFileUtilityObj == NULL) { |
| RTC_LOG(LS_INFO) << "Failed to create FileUtilityObj!"; |
| return -1; |
| } |
| |
| switch (format) { |
| case kFileFormatWavFile: { |
| if (_ptrFileUtilityObj->InitWavReading(stream, startPointMs, |
| stopPointMs) == -1) { |
| RTC_LOG(LS_ERROR) << "Not a valid WAV file!"; |
| StopPlaying(); |
| return -1; |
| } |
| _fileFormat = kFileFormatWavFile; |
| break; |
| } |
| case kFileFormatCompressedFile: { |
| if (_ptrFileUtilityObj->InitCompressedReading(stream, startPointMs, |
| stopPointMs) == -1) { |
| RTC_LOG(LS_ERROR) << "Not a valid Compressed file!"; |
| StopPlaying(); |
| return -1; |
| } |
| _fileFormat = kFileFormatCompressedFile; |
| break; |
| } |
| case kFileFormatPcm8kHzFile: |
| case kFileFormatPcm16kHzFile: |
| case kFileFormatPcm32kHzFile: |
| case kFileFormatPcm48kHzFile: { |
| // ValidFileFormat() called in the beginneing of this function |
| // prevents codecInst from being NULL here. |
| assert(codecInst != NULL); |
| if (!ValidFrequency(codecInst->plfreq) || |
| _ptrFileUtilityObj->InitPCMReading(stream, startPointMs, stopPointMs, |
| codecInst->plfreq) == -1) { |
| RTC_LOG(LS_ERROR) << "Not a valid raw 8 or 16 KHz PCM file!"; |
| StopPlaying(); |
| return -1; |
| } |
| |
| _fileFormat = format; |
| break; |
| } |
| case kFileFormatPreencodedFile: { |
| // ValidFileFormat() called in the beginneing of this function |
| // prevents codecInst from being NULL here. |
| assert(codecInst != NULL); |
| if (_ptrFileUtilityObj->InitPreEncodedReading(stream, *codecInst) == -1) { |
| RTC_LOG(LS_ERROR) << "Not a valid PreEncoded file!"; |
| StopPlaying(); |
| return -1; |
| } |
| |
| _fileFormat = kFileFormatPreencodedFile; |
| break; |
| } |
| default: { |
| RTC_LOG(LS_ERROR) << "Invalid file format: " << format; |
| assert(false); |
| break; |
| } |
| } |
| if (_ptrFileUtilityObj->codec_info(codec_info_) == -1) { |
| RTC_LOG(LS_ERROR) << "Failed to retrieve codec info!"; |
| StopPlaying(); |
| return -1; |
| } |
| |
| _isStereo = (codec_info_.channels == 2); |
| if (_isStereo && (_fileFormat != kFileFormatWavFile)) { |
| RTC_LOG(LS_WARNING) << "Stereo is only allowed for WAV files"; |
| StopPlaying(); |
| return -1; |
| } |
| _playingActive = true; |
| _playoutPositionMs = _ptrFileUtilityObj->PlayoutPositionMs(); |
| _ptrInStream = &stream; |
| _notificationMs = notificationTimeMs; |
| |
| return 0; |
| } |
| |
| int32_t MediaFileImpl::StopPlaying() { |
| rtc::CritScope lock(&_crit); |
| _isStereo = false; |
| if (_ptrFileUtilityObj) { |
| delete _ptrFileUtilityObj; |
| _ptrFileUtilityObj = NULL; |
| } |
| if (_ptrInStream) { |
| // If MediaFileImpl opened the InStream it must be reclaimed here. |
| if (_openFile) { |
| delete _ptrInStream; |
| _openFile = false; |
| } |
| _ptrInStream = NULL; |
| } |
| |
| codec_info_.pltype = 0; |
| codec_info_.plname[0] = '\0'; |
| |
| if (!_playingActive) { |
| RTC_LOG(LS_WARNING) << "playing is not active!"; |
| return -1; |
| } |
| |
| _playingActive = false; |
| return 0; |
| } |
| |
| bool MediaFileImpl::IsPlaying() { |
| RTC_LOG(LS_VERBOSE) << "MediaFileImpl::IsPlaying()"; |
| rtc::CritScope lock(&_crit); |
| return _playingActive; |
| } |
| |
| int32_t MediaFileImpl::IncomingAudioData(const int8_t* buffer, |
| const size_t bufferLengthInBytes) { |
| RTC_LOG(LS_INFO) << "MediaFile::IncomingData(buffer= " |
| << static_cast<const void*>(buffer) |
| << ", bufLen= " << bufferLengthInBytes << ")"; |
| |
| if (buffer == NULL || bufferLengthInBytes == 0) { |
| RTC_LOG(LS_ERROR) << "Buffer pointer or length is NULL!"; |
| return -1; |
| } |
| |
| bool recordingEnded = false; |
| uint32_t callbackNotifyMs = 0; |
| { |
| rtc::CritScope lock(&_crit); |
| |
| if (!_recordingActive) { |
| RTC_LOG(LS_WARNING) << "Not currently recording!"; |
| return -1; |
| } |
| if (_ptrOutStream == NULL) { |
| RTC_LOG(LS_ERROR) << "Recording is active, but output stream is NULL!"; |
| assert(false); |
| return -1; |
| } |
| |
| int32_t bytesWritten = 0; |
| uint32_t samplesWritten = codec_info_.pacsize; |
| if (_ptrFileUtilityObj) { |
| switch (_fileFormat) { |
| case kFileFormatPcm8kHzFile: |
| case kFileFormatPcm16kHzFile: |
| case kFileFormatPcm32kHzFile: |
| case kFileFormatPcm48kHzFile: |
| bytesWritten = _ptrFileUtilityObj->WritePCMData( |
| *_ptrOutStream, buffer, bufferLengthInBytes); |
| |
| // Sample size is 2 bytes. |
| if (bytesWritten > 0) { |
| samplesWritten = bytesWritten / sizeof(int16_t); |
| } |
| break; |
| case kFileFormatCompressedFile: |
| bytesWritten = _ptrFileUtilityObj->WriteCompressedData( |
| *_ptrOutStream, buffer, bufferLengthInBytes); |
| break; |
| case kFileFormatWavFile: |
| bytesWritten = _ptrFileUtilityObj->WriteWavData( |
| *_ptrOutStream, buffer, bufferLengthInBytes); |
| if (bytesWritten > 0 && |
| STR_NCASE_CMP(codec_info_.plname, "L16", 4) == 0) { |
| // Sample size is 2 bytes. |
| samplesWritten = bytesWritten / sizeof(int16_t); |
| } |
| break; |
| case kFileFormatPreencodedFile: |
| bytesWritten = _ptrFileUtilityObj->WritePreEncodedData( |
| *_ptrOutStream, buffer, bufferLengthInBytes); |
| break; |
| default: |
| RTC_LOG(LS_ERROR) << "Invalid file format: " << _fileFormat; |
| assert(false); |
| break; |
| } |
| } else { |
| // TODO (hellner): quick look at the code makes me think that this |
| // code is never executed. Remove? |
| if (_ptrOutStream) { |
| if (_ptrOutStream->Write(buffer, bufferLengthInBytes)) { |
| bytesWritten = static_cast<int32_t>(bufferLengthInBytes); |
| } |
| } |
| } |
| |
| _recordDurationMs += samplesWritten / (codec_info_.plfreq / 1000); |
| |
| // Check if it's time for RecordNotification(..). |
| if (_notificationMs) { |
| if (_recordDurationMs >= _notificationMs) { |
| _notificationMs = 0; |
| callbackNotifyMs = _recordDurationMs; |
| } |
| } |
| if (bytesWritten < (int32_t)bufferLengthInBytes) { |
| RTC_LOG(LS_WARNING) << "Failed to write all requested bytes!"; |
| StopRecording(); |
| recordingEnded = true; |
| } |
| } |
| |
| // Only _callbackCrit may and should be taken when making callbacks. |
| rtc::CritScope lock(&_callbackCrit); |
| if (_ptrCallback) { |
| if (callbackNotifyMs) { |
| _ptrCallback->RecordNotification(_id, callbackNotifyMs); |
| } |
| if (recordingEnded) { |
| _ptrCallback->RecordFileEnded(_id); |
| return -1; |
| } |
| } |
| return 0; |
| } |
| |
| int32_t MediaFileImpl::StartRecordingAudioFile( |
| const char* fileName, |
| const FileFormats format, |
| const CodecInst& codecInst, |
| const uint32_t notificationTimeMs, |
| const uint32_t maxSizeBytes) { |
| if (!ValidFileName(fileName)) { |
| return -1; |
| } |
| if (!ValidFileFormat(format, &codecInst)) { |
| return -1; |
| } |
| |
| FileWrapper* outputStream = FileWrapper::Create(); |
| if (outputStream == NULL) { |
| RTC_LOG(LS_INFO) << "Failed to allocate memory for output stream"; |
| return -1; |
| } |
| |
| if (!outputStream->OpenFile(fileName, false)) { |
| delete outputStream; |
| RTC_LOG(LS_ERROR) << "Could not open output file '" << fileName |
| << "' for writing!"; |
| return -1; |
| } |
| |
| if (maxSizeBytes) { |
| outputStream->SetMaxFileSize(maxSizeBytes); |
| } |
| |
| if (StartRecordingAudioStream(*outputStream, format, codecInst, |
| notificationTimeMs) == -1) { |
| outputStream->CloseFile(); |
| delete outputStream; |
| return -1; |
| } |
| |
| rtc::CritScope lock(&_crit); |
| _openFile = true; |
| strncpy(_fileName, fileName, sizeof(_fileName)); |
| _fileName[sizeof(_fileName) - 1] = '\0'; |
| return 0; |
| } |
| |
| int32_t MediaFileImpl::StartRecordingAudioStream( |
| OutStream& stream, |
| const FileFormats format, |
| const CodecInst& codecInst, |
| const uint32_t notificationTimeMs) { |
| // Check codec info |
| if (!ValidFileFormat(format, &codecInst)) { |
| return -1; |
| } |
| |
| rtc::CritScope lock(&_crit); |
| if (_recordingActive || _playingActive) { |
| RTC_LOG(LS_ERROR) |
| << "StartRecording called, but already recording or playing file " |
| << _fileName << "!"; |
| return -1; |
| } |
| |
| if (_ptrFileUtilityObj != NULL) { |
| RTC_LOG(LS_ERROR) |
| << "StartRecording called, but fileUtilityObj already exists!"; |
| StopRecording(); |
| return -1; |
| } |
| |
| _ptrFileUtilityObj = new ModuleFileUtility(); |
| if (_ptrFileUtilityObj == NULL) { |
| RTC_LOG(LS_INFO) << "Cannot allocate fileUtilityObj!"; |
| return -1; |
| } |
| |
| CodecInst tmpAudioCodec; |
| memcpy(&tmpAudioCodec, &codecInst, sizeof(CodecInst)); |
| switch (format) { |
| case kFileFormatWavFile: { |
| if (_ptrFileUtilityObj->InitWavWriting(stream, codecInst) == -1) { |
| RTC_LOG(LS_ERROR) << "Failed to initialize WAV file!"; |
| delete _ptrFileUtilityObj; |
| _ptrFileUtilityObj = NULL; |
| return -1; |
| } |
| _fileFormat = kFileFormatWavFile; |
| break; |
| } |
| case kFileFormatCompressedFile: { |
| // Write compression codec name at beginning of file |
| if (_ptrFileUtilityObj->InitCompressedWriting(stream, codecInst) == -1) { |
| RTC_LOG(LS_ERROR) << "Failed to initialize Compressed file!"; |
| delete _ptrFileUtilityObj; |
| _ptrFileUtilityObj = NULL; |
| return -1; |
| } |
| _fileFormat = kFileFormatCompressedFile; |
| break; |
| } |
| case kFileFormatPcm8kHzFile: |
| case kFileFormatPcm16kHzFile: |
| case kFileFormatPcm32kHzFile: |
| case kFileFormatPcm48kHzFile: { |
| if (!ValidFrequency(codecInst.plfreq) || |
| _ptrFileUtilityObj->InitPCMWriting(stream, codecInst.plfreq) == -1) { |
| RTC_LOG(LS_ERROR) << "Failed to initialize PCM file!"; |
| delete _ptrFileUtilityObj; |
| _ptrFileUtilityObj = NULL; |
| return -1; |
| } |
| _fileFormat = format; |
| break; |
| } |
| case kFileFormatPreencodedFile: { |
| if (_ptrFileUtilityObj->InitPreEncodedWriting(stream, codecInst) == -1) { |
| RTC_LOG(LS_ERROR) << "Failed to initialize Pre-Encoded file!"; |
| delete _ptrFileUtilityObj; |
| _ptrFileUtilityObj = NULL; |
| return -1; |
| } |
| |
| _fileFormat = kFileFormatPreencodedFile; |
| break; |
| } |
| default: { |
| RTC_LOG(LS_ERROR) << "Invalid file format " << format << " specified!"; |
| delete _ptrFileUtilityObj; |
| _ptrFileUtilityObj = NULL; |
| return -1; |
| } |
| } |
| _isStereo = (tmpAudioCodec.channels == 2); |
| if (_isStereo) { |
| if (_fileFormat != kFileFormatWavFile) { |
| RTC_LOG(LS_WARNING) << "Stereo is only allowed for WAV files"; |
| StopRecording(); |
| return -1; |
| } |
| if ((STR_NCASE_CMP(tmpAudioCodec.plname, "L16", 4) != 0) && |
| (STR_NCASE_CMP(tmpAudioCodec.plname, "PCMU", 5) != 0) && |
| (STR_NCASE_CMP(tmpAudioCodec.plname, "PCMA", 5) != 0)) { |
| RTC_LOG(LS_WARNING) |
| << "Stereo is only allowed for codec PCMU, PCMA and L16 "; |
| StopRecording(); |
| return -1; |
| } |
| } |
| memcpy(&codec_info_, &tmpAudioCodec, sizeof(CodecInst)); |
| _recordingActive = true; |
| _ptrOutStream = &stream; |
| _notificationMs = notificationTimeMs; |
| _recordDurationMs = 0; |
| return 0; |
| } |
| |
| int32_t MediaFileImpl::StopRecording() { |
| rtc::CritScope lock(&_crit); |
| if (!_recordingActive) { |
| RTC_LOG(LS_WARNING) << "recording is not active!"; |
| return -1; |
| } |
| |
| _isStereo = false; |
| |
| if (_ptrFileUtilityObj != NULL) { |
| // Both AVI and WAV header has to be updated before closing the stream |
| // because they contain size information. |
| if ((_fileFormat == kFileFormatWavFile) && (_ptrOutStream != NULL)) { |
| _ptrFileUtilityObj->UpdateWavHeader(*_ptrOutStream); |
| } |
| delete _ptrFileUtilityObj; |
| _ptrFileUtilityObj = NULL; |
| } |
| |
| if (_ptrOutStream != NULL) { |
| // If MediaFileImpl opened the OutStream it must be reclaimed here. |
| if (_openFile) { |
| delete _ptrOutStream; |
| _openFile = false; |
| } |
| _ptrOutStream = NULL; |
| } |
| |
| _recordingActive = false; |
| codec_info_.pltype = 0; |
| codec_info_.plname[0] = '\0'; |
| |
| return 0; |
| } |
| |
| bool MediaFileImpl::IsRecording() { |
| RTC_LOG(LS_VERBOSE) << "MediaFileImpl::IsRecording()"; |
| rtc::CritScope lock(&_crit); |
| return _recordingActive; |
| } |
| |
| int32_t MediaFileImpl::RecordDurationMs(uint32_t& durationMs) { |
| rtc::CritScope lock(&_crit); |
| if (!_recordingActive) { |
| durationMs = 0; |
| return -1; |
| } |
| durationMs = _recordDurationMs; |
| return 0; |
| } |
| |
| bool MediaFileImpl::IsStereo() { |
| RTC_LOG(LS_VERBOSE) << "MediaFileImpl::IsStereo()"; |
| rtc::CritScope lock(&_crit); |
| return _isStereo; |
| } |
| |
| int32_t MediaFileImpl::SetModuleFileCallback(FileCallback* callback) { |
| rtc::CritScope lock(&_callbackCrit); |
| |
| _ptrCallback = callback; |
| return 0; |
| } |
| |
| int32_t MediaFileImpl::FileDurationMs(const char* fileName, |
| uint32_t& durationMs, |
| const FileFormats format, |
| const uint32_t freqInHz) { |
| if (!ValidFileName(fileName)) { |
| return -1; |
| } |
| if (!ValidFrequency(freqInHz)) { |
| return -1; |
| } |
| |
| ModuleFileUtility* utilityObj = new ModuleFileUtility(); |
| if (utilityObj == NULL) { |
| RTC_LOG(LS_ERROR) << "failed to allocate utility object!"; |
| return -1; |
| } |
| |
| const int32_t duration = |
| utilityObj->FileDurationMs(fileName, format, freqInHz); |
| delete utilityObj; |
| if (duration == -1) { |
| durationMs = 0; |
| return -1; |
| } |
| |
| durationMs = duration; |
| return 0; |
| } |
| |
| int32_t MediaFileImpl::PlayoutPositionMs(uint32_t& positionMs) const { |
| rtc::CritScope lock(&_crit); |
| if (!_playingActive) { |
| positionMs = 0; |
| return -1; |
| } |
| positionMs = _playoutPositionMs; |
| return 0; |
| } |
| |
| int32_t MediaFileImpl::codec_info(CodecInst& codecInst) const { |
| rtc::CritScope lock(&_crit); |
| if (!_playingActive && !_recordingActive) { |
| RTC_LOG(LS_ERROR) << "Neither playout nor recording has been initialized!"; |
| return -1; |
| } |
| if (codec_info_.pltype == 0 && codec_info_.plname[0] == '\0') { |
| RTC_LOG(LS_ERROR) << "The CodecInst for " |
| << (_playingActive ? "Playback" : "Recording") |
| << " is unknown!"; |
| return -1; |
| } |
| memcpy(&codecInst, &codec_info_, sizeof(CodecInst)); |
| return 0; |
| } |
| |
| bool MediaFileImpl::ValidFileFormat(const FileFormats format, |
| const CodecInst* codecInst) { |
| if (codecInst == NULL) { |
| if (format == kFileFormatPreencodedFile || |
| format == kFileFormatPcm8kHzFile || format == kFileFormatPcm16kHzFile || |
| format == kFileFormatPcm32kHzFile || |
| format == kFileFormatPcm48kHzFile) { |
| RTC_LOG(LS_ERROR) << "Codec info required for file format specified!"; |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| bool MediaFileImpl::ValidFileName(const char* fileName) { |
| if ((fileName == NULL) || (fileName[0] == '\0')) { |
| RTC_LOG(LS_ERROR) << "FileName not specified!"; |
| return false; |
| } |
| return true; |
| } |
| |
| bool MediaFileImpl::ValidFilePositions(const uint32_t startPointMs, |
| const uint32_t stopPointMs) { |
| if (startPointMs == 0 && stopPointMs == 0) // Default values |
| { |
| return true; |
| } |
| if (stopPointMs && (startPointMs >= stopPointMs)) { |
| RTC_LOG(LS_ERROR) << "startPointMs must be less than stopPointMs!"; |
| return false; |
| } |
| if (stopPointMs && ((stopPointMs - startPointMs) < 20)) { |
| RTC_LOG(LS_ERROR) << "minimum play duration for files is 20 ms!"; |
| return false; |
| } |
| return true; |
| } |
| |
| bool MediaFileImpl::ValidFrequency(const uint32_t frequency) { |
| if ((frequency == 8000) || (frequency == 16000) || (frequency == 32000) || |
| (frequency == 48000)) { |
| return true; |
| } |
| RTC_LOG(LS_ERROR) << "Frequency should be 8000, 16000, 32000, or 48000 (Hz)"; |
| return false; |
| } |
| } // namespace webrtc |
