Revert of 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 = rtc::File::Open(_outputFilename);
-    if (!_outputFile.IsOpen()) {
-      LOG(LS_ERROR) << "Failed to open playout file: " << _outputFilename;
-      _playing = false;
-      delete[] _playoutBuffer;
-      _playoutBuffer = NULL;
-      return -1;
-    }
+  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;
   }
 
   _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.Close();
+  _outputFile.CloseFile();
 
   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 = 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;
-    }
+  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;
   }
 
   _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.Close();
+  _inputFile.CloseFile();
 
   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();
-  _critSect.Enter();
-
-  if (_lastCallPlayoutMillis == 0 ||
-      currentTime - _lastCallPlayoutMillis >= 10) {
-    _critSect.Leave();
-    _ptrAudioBuffer->RequestPlayoutData(_playoutFramesIn10MS);
+bool FileAudioDevice::PlayThreadProcess()
+{
+    if(!_playing) {
+        return false;
+    }
+    uint64_t currentTime = _clock->CurrentNtpInMilliseconds();
     _critSect.Enter();
 
-    _playoutFramesLeft = _ptrAudioBuffer->GetPlayoutData(_playoutBuffer);
-    assert(_playoutFramesLeft == _playoutFramesIn10MS);
-    if (_outputFile.IsOpen()) {
-      _outputFile.Write(reinterpret_cast<uint8_t*>(_playoutBuffer),
-                        kPlayoutBufferSize);
+    if (_lastCallPlayoutMillis == 0 ||
+        currentTime - _lastCallPlayoutMillis >= 10) {
+        _critSect.Leave();
+        _ptrAudioBuffer->RequestPlayoutData(_playoutFramesIn10MS);
+        _critSect.Enter();
+
+        _playoutFramesLeft = _ptrAudioBuffer->GetPlayoutData(_playoutBuffer);
+        assert(_playoutFramesLeft == _playoutFramesIn10MS);
+        if (_outputFile.is_open()) {
+          _outputFile.Write(_playoutBuffer, kPlayoutBufferSize);
+        }
+        _lastCallPlayoutMillis = currentTime;
     }
-    _lastCallPlayoutMillis = currentTime;
-  }
-  _playoutFramesLeft = 0;
-  _critSect.Leave();
+    _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();
+    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);
+    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();
       }
-      _lastCallRecordMillis = currentTime;
-      _critSect.Leave();
-      _ptrAudioBuffer->DeliverRecordedData();
-      _critSect.Enter();
     }
-  }
 
-  _critSect.Leave();
+    _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;
 }
 
 }  // namespace webrtc