Replace FileWrapper with File (in audio_device)

webrtc/modules/audio_device/dummy/file_audio_device.cc

 /*
  *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #include "webrtc/base/logging.h"
@@ skipping 21 matching lines @@
     _recordingFramesLeft(0),
     _playoutFramesLeft(0),
     _critSect(*CriticalSectionWrapper::CreateCriticalSection()),
     _recordingBufferSizeIn10MS(0),
     _recordingFramesIn10MS(0),
     _playoutFramesIn10MS(0),
     _playing(false),
     _recording(false),
     _lastCallPlayoutMillis(0),
     _lastCallRecordMillis(0),
-    _outputFile(*FileWrapper::Create()),
-    _inputFile(*FileWrapper::Create()),
     _outputFilename(outputFilename),
     _inputFilename(inputFilename),
     _clock(Clock::GetRealTimeClock()) {
 }
 
-FileAudioDevice::~FileAudioDevice() {
-  delete &_outputFile;
-  delete &_inputFile;
-}
-
 int32_t FileAudioDevice::ActiveAudioLayer(
     AudioDeviceModule::AudioLayer& audioLayer) const {
   return -1;
 }
 
 AudioDeviceGeneric::InitStatus FileAudioDevice::Init() {
   return InitStatus::OK;
 }
 
 int32_t FileAudioDevice::Terminate() { return 0; }
@@ skipping 126 matching lines @@
 
   if (!_playoutBuffer) {
       _playoutBuffer = new int8_t[kPlayoutBufferSize];
   }
   if (!_playoutBuffer) {
     _playing = false;
     return -1;
   }
 
   // PLAYOUT
-  if (!_outputFilename.empty() &&
-      !_outputFile.OpenFile(_outputFilename.c_str(), false)) {
-    LOG(LS_ERROR) << "Failed to open playout file: " << _outputFilename;
-    _playing = false;
-    delete [] _playoutBuffer;
-    _playoutBuffer = NULL;
-    return -1;
+  if (!_outputFilename.empty()) {
+    _outputFile = rtc::File::Open(_outputFilename);
+    if (!_outputFile.IsOpen()) {
+      LOG(LS_ERROR) << "Failed to open playout file: " << _outputFilename;
+      _playing = false;
+      delete[] _playoutBuffer;
+      _playoutBuffer = NULL;
+      return -1;
+    }
   }
 
   _ptrThreadPlay.reset(new rtc::PlatformThread(
       PlayThreadFunc, this, "webrtc_audio_module_play_thread"));
   _ptrThreadPlay->Start();
   _ptrThreadPlay->SetPriority(rtc::kRealtimePriority);
 
   LOG(LS_INFO) << "Started playout capture to output file: "
                << _outputFilename;
   return 0;
 }
 
 int32_t FileAudioDevice::StopPlayout() {
   {
       CriticalSectionScoped lock(&_critSect);
       _playing = false;
   }
 
   // stop playout thread first
   if (_ptrThreadPlay) {
       _ptrThreadPlay->Stop();
       _ptrThreadPlay.reset();
   }
 
   CriticalSectionScoped lock(&_critSect);
 
   _playoutFramesLeft = 0;
   delete [] _playoutBuffer;
   _playoutBuffer = NULL;
-  _outputFile.CloseFile();
+  _outputFile.Close();
 
   LOG(LS_INFO) << "Stopped playout capture to output file: "
                << _outputFilename;
   return 0;
 }
 
 bool FileAudioDevice::Playing() const {
   return true;
 }
 
 int32_t FileAudioDevice::StartRecording() {
   _recording = true;
 
   // Make sure we only create the buffer once.
   _recordingBufferSizeIn10MS = _recordingFramesIn10MS *
                                kRecordingNumChannels *
                                2;
   if (!_recordingBuffer) {
       _recordingBuffer = new int8_t[_recordingBufferSizeIn10MS];
   }
 
-  if (!_inputFilename.empty() &&
-      !_inputFile.OpenFile(_inputFilename.c_str(), true)) {
-    LOG(LS_ERROR) << "Failed to open audio input file: " << _inputFilename;
-    _recording = false;
-    delete[] _recordingBuffer;
-    _recordingBuffer = NULL;
-    return -1;
+  if (!_inputFilename.empty()) {
+    _inputFile = rtc::File::Open(_inputFilename);
+    if (!_inputFile.IsOpen()) {
+      LOG(LS_ERROR) << "Failed to open audio input file: " << _inputFilename;
+      _recording = false;
+      delete[] _recordingBuffer;
+      _recordingBuffer = NULL;
+      return -1;
+    }
   }
 
   _ptrThreadRec.reset(new rtc::PlatformThread(
       RecThreadFunc, this, "webrtc_audio_module_capture_thread"));
 
   _ptrThreadRec->Start();
   _ptrThreadRec->SetPriority(rtc::kRealtimePriority);
 
   LOG(LS_INFO) << "Started recording from input file: "
                << _inputFilename;
@@ skipping 12 matching lines @@
       _ptrThreadRec->Stop();
       _ptrThreadRec.reset();
   }
 
   CriticalSectionScoped lock(&_critSect);
   _recordingFramesLeft = 0;
   if (_recordingBuffer) {
       delete [] _recordingBuffer;
       _recordingBuffer = NULL;
   }
-  _inputFile.CloseFile();
+  _inputFile.Close();
 
   LOG(LS_INFO) << "Stopped recording from input file: "
                << _inputFilename;
   return 0;
 }
 
 bool FileAudioDevice::Recording() const {
   return _recording;
 }
 
 int32_t FileAudioDevice::SetAGC(bool enable) { return -1; }
 
 bool FileAudioDevice::AGC() const { return false; }
 
 int32_t FileAudioDevice::SetWaveOutVolume(uint16_t volumeLeft,
-                                           uint16_t volumeRight) {
+                                          uint16_t volumeRight) {
   return -1;
 }
 
 int32_t FileAudioDevice::WaveOutVolume(uint16_t& volumeLeft,
-                                        uint16_t& volumeRight) const {
+                                       uint16_t& volumeRight) const {
   return -1;
 }
 
 int32_t FileAudioDevice::InitSpeaker() { return -1; }
 
 bool FileAudioDevice::SpeakerIsInitialized() const { return false; }
 
 int32_t FileAudioDevice::InitMicrophone() { return 0; }
 
 bool FileAudioDevice::MicrophoneIsInitialized() const { return true; }
@@ skipping 132 matching lines @@
 
   // Inform the AudioBuffer about default settings for this implementation.
   // Set all values to zero here since the actual settings will be done by
   // InitPlayout and InitRecording later.
   _ptrAudioBuffer->SetRecordingSampleRate(0);
   _ptrAudioBuffer->SetPlayoutSampleRate(0);
   _ptrAudioBuffer->SetRecordingChannels(0);
   _ptrAudioBuffer->SetPlayoutChannels(0);
 }
 
-bool FileAudioDevice::PlayThreadFunc(void* pThis)
-{
-    return (static_cast<FileAudioDevice*>(pThis)->PlayThreadProcess());
+bool FileAudioDevice::PlayThreadFunc(void* pThis) {
+  return (static_cast<FileAudioDevice*>(pThis)->PlayThreadProcess());
 }
 
-bool FileAudioDevice::RecThreadFunc(void* pThis)
-{
-    return (static_cast<FileAudioDevice*>(pThis)->RecThreadProcess());
+bool FileAudioDevice::RecThreadFunc(void* pThis) {
+  return (static_cast<FileAudioDevice*>(pThis)->RecThreadProcess());
 }
 
-bool FileAudioDevice::PlayThreadProcess()
-{
-    if(!_playing) {
-        return false;
-    }
-    uint64_t currentTime = _clock->CurrentNtpInMilliseconds();
+bool FileAudioDevice::PlayThreadProcess() {
+  if (!_playing) {
+    return false;
+  }
+  uint64_t currentTime = _clock->CurrentNtpInMilliseconds();
+  _critSect.Enter();
+
+  if (_lastCallPlayoutMillis == 0 ||
+      currentTime - _lastCallPlayoutMillis >= 10) {
+    _critSect.Leave();
+    _ptrAudioBuffer->RequestPlayoutData(_playoutFramesIn10MS);
     _critSect.Enter();
 
-    if (_lastCallPlayoutMillis == 0 ||
-        currentTime - _lastCallPlayoutMillis >= 10) {
-        _critSect.Leave();
-        _ptrAudioBuffer->RequestPlayoutData(_playoutFramesIn10MS);
-        _critSect.Enter();
+    _playoutFramesLeft = _ptrAudioBuffer->GetPlayoutData(_playoutBuffer);
+    assert(_playoutFramesLeft == _playoutFramesIn10MS);
+    if (_outputFile.IsOpen()) {
+      _outputFile.Write(reinterpret_cast<uint8_t*>(_playoutBuffer),
+                        kPlayoutBufferSize);
+    }
+    _lastCallPlayoutMillis = currentTime;
+  }
+  _playoutFramesLeft = 0;
+  _critSect.Leave();
 
-        _playoutFramesLeft = _ptrAudioBuffer->GetPlayoutData(_playoutBuffer);
-        assert(_playoutFramesLeft == _playoutFramesIn10MS);
-        if (_outputFile.is_open()) {
-          _outputFile.Write(_playoutBuffer, kPlayoutBufferSize);
-        }
-        _lastCallPlayoutMillis = currentTime;
-    }
-    _playoutFramesLeft = 0;
-    _critSect.Leave();
+  uint64_t deltaTimeMillis = _clock->CurrentNtpInMilliseconds() - currentTime;
+  if (deltaTimeMillis < 10) {
+    SleepMs(10 - deltaTimeMillis);
+  }
 
-    uint64_t deltaTimeMillis = _clock->CurrentNtpInMilliseconds() - currentTime;
-    if(deltaTimeMillis < 10) {
-      SleepMs(10 - deltaTimeMillis);
-    }
-
-    return true;
+  return true;
 }
 
-bool FileAudioDevice::RecThreadProcess()
-{
-    if (!_recording) {
-        return false;
+bool FileAudioDevice::RecThreadProcess() {
+  if (!_recording) {
+    return false;
+  }
+
+  uint64_t currentTime = _clock->CurrentNtpInMilliseconds();
+  _critSect.Enter();
+
+  if (_lastCallRecordMillis == 0 || currentTime - _lastCallRecordMillis >= 10) {
+    if (_inputFile.IsOpen()) {
+      if (_inputFile.Read(reinterpret_cast<uint8_t*>(_recordingBuffer),
+                          kRecordingBufferSize) > 0) {
+        _ptrAudioBuffer->SetRecordedBuffer(_recordingBuffer,
+                                           _recordingFramesIn10MS);
+      } else {
+        _inputFile.Seek(0);
+      }
+      _lastCallRecordMillis = currentTime;
+      _critSect.Leave();
+      _ptrAudioBuffer->DeliverRecordedData();
+      _critSect.Enter();
     }
+  }
 
-    uint64_t currentTime = _clock->CurrentNtpInMilliseconds();
-    _critSect.Enter();
+  _critSect.Leave();
 
-    if (_lastCallRecordMillis == 0 ||
-        currentTime - _lastCallRecordMillis >= 10) {
-      if (_inputFile.is_open()) {
-        if (_inputFile.Read(_recordingBuffer, kRecordingBufferSize) > 0) {
-          _ptrAudioBuffer->SetRecordedBuffer(_recordingBuffer,
-                                             _recordingFramesIn10MS);
-        } else {
-          _inputFile.Rewind();
-        }
-        _lastCallRecordMillis = currentTime;
-        _critSect.Leave();
-        _ptrAudioBuffer->DeliverRecordedData();
-        _critSect.Enter();
-      }
-    }
+  uint64_t deltaTimeMillis = _clock->CurrentNtpInMilliseconds() - currentTime;
+  if (deltaTimeMillis < 10) {
+    SleepMs(10 - deltaTimeMillis);
+  }
 
-    _critSect.Leave();
-
-    uint64_t deltaTimeMillis = _clock->CurrentNtpInMilliseconds() - currentTime;
-    if(deltaTimeMillis < 10) {
-      SleepMs(10 - deltaTimeMillis);
-    }
-
-    return true;
+  return true;
 }
 
 }  // namespace webrtc