Remove VoEFile

voice_engine/transmit_mixer.cc

 /*
  *  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.
  */
 
@@ skipping 49 matching lines @@
                              "CallbackOnError(VE_TYPING_NOISE_OFF_WARNING)");
                 _voiceEngineObserverPtr->CallbackOnError(
                     -1,
                     VE_TYPING_NOISE_OFF_WARNING);
             }
         }
     }
 }
 #endif  // WEBRTC_VOICE_ENGINE_TYPING_DETECTION
 
-void TransmitMixer::PlayNotification(int32_t id,
-                                     uint32_t durationMs)
-{
-    WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1),
-                 "TransmitMixer::PlayNotification(id=%d, durationMs=%d)",
-                 id, durationMs);
-
-    // Not implement yet
-}
-
-void TransmitMixer::RecordNotification(int32_t id,
-                                       uint32_t durationMs)
-{
-    WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,-1),
-                 "TransmitMixer::RecordNotification(id=%d, durationMs=%d)",
-                 id, durationMs);
-
-    // Not implement yet
-}
-
-void TransmitMixer::PlayFileEnded(int32_t id)
-{
-    WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1),
-                 "TransmitMixer::PlayFileEnded(id=%d)", id);
-
-    assert(id == _filePlayerId);
-
-    rtc::CritScope cs(&_critSect);
-
-    _filePlaying = false;
-    WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1),
-                 "TransmitMixer::PlayFileEnded() =>"
-                 "file player module is shutdown");
-}
-
-void
-TransmitMixer::RecordFileEnded(int32_t id)
-{
-    WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1),
-                 "TransmitMixer::RecordFileEnded(id=%d)", id);
-
-    if (id == _fileRecorderId)
-    {
-        rtc::CritScope cs(&_critSect);
-        _fileRecording = false;
-        WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1),
-                     "TransmitMixer::RecordFileEnded() => fileRecorder module"
-                     "is shutdown");
-    } else if (id == _fileCallRecorderId)
-    {
-        rtc::CritScope cs(&_critSect);
-        _fileCallRecording = false;
-        WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1),
-                     "TransmitMixer::RecordFileEnded() => fileCallRecorder"
-                     "module is shutdown");
-    }
-}
-
 int32_t
 TransmitMixer::Create(TransmitMixer*& mixer, uint32_t instanceId)
 {
     WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(instanceId, -1),
                  "TransmitMixer::Create(instanceId=%d)", instanceId);
     mixer = new TransmitMixer(instanceId);
     if (mixer == NULL)
     {
         WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(instanceId, -1),
                      "TransmitMixer::Create() unable to allocate memory"
                      "for mixer");
         return -1;
     }
     return 0;
 }
 
 void
 TransmitMixer::Destroy(TransmitMixer*& mixer)
 {
     if (mixer)
     {
         delete mixer;
         mixer = NULL;
     }
 }
 
 TransmitMixer::TransmitMixer(uint32_t instanceId) :
-    // Avoid conflict with other channels by adding 1024 - 1026,
-    // won't use as much as 1024 channels.
-    _filePlayerId(instanceId + 1024),
-    _fileRecorderId(instanceId + 1025),
-    _fileCallRecorderId(instanceId + 1026),
 #if WEBRTC_VOICE_ENGINE_TYPING_DETECTION
     _monitorModule(this),
 #endif
     _instanceId(instanceId)
 {
     WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::TransmitMixer() - ctor");
 }
 
 TransmitMixer::~TransmitMixer()
 {
     WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::~TransmitMixer() - dtor");
 #if WEBRTC_VOICE_ENGINE_TYPING_DETECTION
     if (_processThreadPtr)
         _processThreadPtr->DeRegisterModule(&_monitorModule);
 #endif
-    {
-        rtc::CritScope cs(&_critSect);
-        if (file_recorder_) {
-          file_recorder_->RegisterModuleFileCallback(NULL);
-          file_recorder_->StopRecording();
-        }
-        if (file_call_recorder_) {
-          file_call_recorder_->RegisterModuleFileCallback(NULL);
-          file_call_recorder_->StopRecording();
-        }
-        if (file_player_) {
-          file_player_->RegisterModuleFileCallback(NULL);
-          file_player_->StopPlayingFile();
-        }
-    }
 }
 
 int32_t
 TransmitMixer::SetEngineInformation(ProcessThread& processThread,
                                     Statistics& engineStatistics,
                                     ChannelManager& channelManager)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::SetEngineInformation()");
 
@@ skipping 86 matching lines @@
 
     if (swap_stereo_channels_ && stereo_codec_)
       // Only bother swapping if we're using a stereo codec.
       AudioFrameOperations::SwapStereoChannels(&_audioFrame);
 
     // --- Annoying typing detection (utilizes the APM/VAD decision)
 #if WEBRTC_VOICE_ENGINE_TYPING_DETECTION
     TypingDetection(keyPressed);
 #endif
 
-    // --- Mix with file (does not affect the mixing frequency)
-    if (_filePlaying)
-    {
-        MixOrReplaceAudioWithFile(_audioFrame.sample_rate_hz_);
-    }
-
-    // --- Record to file
-    bool file_recording = false;
-    {
-        rtc::CritScope cs(&_critSect);
-        file_recording =  _fileRecording;
-    }
-    if (file_recording)
-    {
-        RecordAudioToFile(_audioFrame.sample_rate_hz_);
-    }
-
     // --- Measure audio level of speech after all processing.
     double sample_duration = static_cast<double>(nSamples) / samplesPerSec;
     _audioLevel.ComputeLevel(_audioFrame, sample_duration);
 
     return 0;
 }
 
 void TransmitMixer::ProcessAndEncodeAudio() {
   RTC_DCHECK_GT(_audioFrame.samples_per_channel_, 0);
   for (ChannelManager::Iterator it(_channelManagerPtr); it.IsValid();
@@ skipping 12 matching lines @@
 
 int32_t
 TransmitMixer::StopSend()
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                "TransmitMixer::StopSend()");
     _audioLevel.Clear();
     return 0;
 }
 
-int TransmitMixer::StartPlayingFileAsMicrophone(const char* fileName,
-                                                bool loop,
-                                                FileFormats format,
-                                                int startPosition,
-                                                float volumeScaling,
-                                                int stopPosition,
-                                                const CodecInst* codecInst)
-{
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
-                 "TransmitMixer::StartPlayingFileAsMicrophone("
-                 "fileNameUTF8[]=%s,loop=%d, format=%d, volumeScaling=%5.3f,"
-                 " startPosition=%d, stopPosition=%d)", fileName, loop,
-                 format, volumeScaling, startPosition, stopPosition);
-
-    if (_filePlaying)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_ALREADY_PLAYING, kTraceWarning,
-            "StartPlayingFileAsMicrophone() is already playing");
-        return 0;
-    }
-
-    rtc::CritScope cs(&_critSect);
-
-    // Destroy the old instance
-    if (file_player_) {
-      file_player_->RegisterModuleFileCallback(NULL);
-      file_player_.reset();
-    }
-
-    // Dynamically create the instance
-    file_player_ =
-        FilePlayer::CreateFilePlayer(_filePlayerId, (const FileFormats)format);
-
-    if (!file_player_) {
-      _engineStatisticsPtr->SetLastError(
-          VE_INVALID_ARGUMENT, kTraceError,
-          "StartPlayingFileAsMicrophone() filePlayer format isnot correct");
-      return -1;
-    }
-
-    const uint32_t notificationTime(0);
-
-    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;
-    }
-
-    file_player_->RegisterModuleFileCallback(this);
-    _filePlaying = true;
-
-    return 0;
-}
-
-int TransmitMixer::StartPlayingFileAsMicrophone(InStream* stream,
-                                                FileFormats format,
-                                                int startPosition,
-                                                float volumeScaling,
-                                                int stopPosition,
-                                                const CodecInst* codecInst)
-{
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1),
-                 "TransmitMixer::StartPlayingFileAsMicrophone(format=%d,"
-                 " volumeScaling=%5.3f, startPosition=%d, stopPosition=%d)",
-                 format, volumeScaling, startPosition, stopPosition);
-
-    if (stream == NULL)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_BAD_FILE, kTraceError,
-            "StartPlayingFileAsMicrophone() NULL as input stream");
-        return -1;
-    }
-
-    if (_filePlaying)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_ALREADY_PLAYING, kTraceWarning,
-            "StartPlayingFileAsMicrophone() is already playing");
-        return 0;
-    }
-
-    rtc::CritScope cs(&_critSect);
-
-    // Destroy the old instance
-    if (file_player_) {
-      file_player_->RegisterModuleFileCallback(NULL);
-      file_player_.reset();
-    }
-
-    // Dynamically create the instance
-    file_player_ =
-        FilePlayer::CreateFilePlayer(_filePlayerId, (const FileFormats)format);
-
-    if (!file_player_) {
-      _engineStatisticsPtr->SetLastError(
-          VE_INVALID_ARGUMENT, kTraceWarning,
-          "StartPlayingFileAsMicrophone() filePlayer format isnot correct");
-      return -1;
-    }
-
-    const uint32_t notificationTime(0);
-
-    if (file_player_->StartPlayingFile(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;
-    }
-    file_player_->RegisterModuleFileCallback(this);
-    _filePlaying = true;
-
-    return 0;
-}
-
-int TransmitMixer::StopPlayingFileAsMicrophone()
-{
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1),
-                 "TransmitMixer::StopPlayingFileAsMicrophone()");
-
-    if (!_filePlaying)
-    {
-        return 0;
-    }
-
-    rtc::CritScope cs(&_critSect);
-
-    if (file_player_->StopPlayingFile() != 0) {
-      _engineStatisticsPtr->SetLastError(
-          VE_CANNOT_STOP_PLAYOUT, kTraceError,
-          "StopPlayingFile() couldnot stop playing file");
-      return -1;
-    }
-
-    file_player_->RegisterModuleFileCallback(NULL);
-    file_player_.reset();
-    _filePlaying = false;
-
-    return 0;
-}
-
-int TransmitMixer::IsPlayingFileAsMicrophone() const
-{
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
-                 "TransmitMixer::IsPlayingFileAsMicrophone()");
-    return _filePlaying;
-}
-
-int TransmitMixer::StartRecordingMicrophone(const char* fileName,
-                                            const CodecInst* codecInst)
-{
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
-                 "TransmitMixer::StartRecordingMicrophone(fileName=%s)",
-                 fileName);
-
-    rtc::CritScope cs(&_critSect);
-
-    if (_fileRecording)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
-                     "StartRecordingMicrophone() is already recording");
-        return 0;
-    }
-
-    FileFormats format;
-    const uint32_t notificationTime(0); // Not supported in VoE
-    CodecInst dummyCodec = { 100, "L16", 16000, 320, 1, 320000 };
-
-    if (codecInst != NULL && codecInst->channels > 2)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_BAD_ARGUMENT, kTraceError,
-            "StartRecordingMicrophone() invalid compression");
-        return (-1);
-    }
-    if (codecInst == NULL)
-    {
-        format = kFileFormatPcm16kHzFile;
-        codecInst = &dummyCodec;
-    } else if ((STR_CASE_CMP(codecInst->plname,"L16") == 0) ||
-        (STR_CASE_CMP(codecInst->plname,"PCMU") == 0) ||
-        (STR_CASE_CMP(codecInst->plname,"PCMA") == 0))
-    {
-        format = kFileFormatWavFile;
-    } else
-    {
-        format = kFileFormatCompressedFile;
-    }
-
-    // Destroy the old instance
-    if (file_recorder_) {
-      file_recorder_->RegisterModuleFileCallback(NULL);
-      file_recorder_.reset();
-    }
-
-    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 (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;
-    }
-    file_recorder_->RegisterModuleFileCallback(this);
-    _fileRecording = true;
-
-    return 0;
-}
-
-int TransmitMixer::StartRecordingMicrophone(OutStream* stream,
-                                            const CodecInst* codecInst)
-{
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
-               "TransmitMixer::StartRecordingMicrophone()");
-
-    rtc::CritScope cs(&_critSect);
-
-    if (_fileRecording)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
-                   "StartRecordingMicrophone() is already recording");
-        return 0;
-    }
-
-    FileFormats format;
-    const uint32_t notificationTime(0); // Not supported in VoE
-    CodecInst dummyCodec = { 100, "L16", 16000, 320, 1, 320000 };
-
-    if (codecInst != NULL && codecInst->channels != 1)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_BAD_ARGUMENT, kTraceError,
-            "StartRecordingMicrophone() invalid compression");
-        return (-1);
-    }
-    if (codecInst == NULL)
-    {
-        format = kFileFormatPcm16kHzFile;
-        codecInst = &dummyCodec;
-    } else if ((STR_CASE_CMP(codecInst->plname,"L16") == 0) ||
-        (STR_CASE_CMP(codecInst->plname,"PCMU") == 0) ||
-        (STR_CASE_CMP(codecInst->plname,"PCMA") == 0))
-    {
-        format = kFileFormatWavFile;
-    } else
-    {
-        format = kFileFormatCompressedFile;
-    }
-
-    // Destroy the old instance
-    if (file_recorder_) {
-      file_recorder_->RegisterModuleFileCallback(NULL);
-      file_recorder_.reset();
-    }
-
-    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 (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;
-    }
-
-    file_recorder_->RegisterModuleFileCallback(this);
-    _fileRecording = true;
-
-    return 0;
-}
-
-
-int TransmitMixer::StopRecordingMicrophone()
-{
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
-                 "TransmitMixer::StopRecordingMicrophone()");
-
-    rtc::CritScope cs(&_critSect);
-
-    if (!_fileRecording)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
-                   "StopRecordingMicrophone() isnot recording");
-        return 0;
-    }
-
-    if (file_recorder_->StopRecording() != 0) {
-      _engineStatisticsPtr->SetLastError(
-          VE_STOP_RECORDING_FAILED, kTraceError,
-          "StopRecording(), could not stop recording");
-      return -1;
-    }
-    file_recorder_->RegisterModuleFileCallback(NULL);
-    file_recorder_.reset();
-    _fileRecording = false;
-
-    return 0;
-}
-
-int TransmitMixer::StartRecordingCall(const char* fileName,
-                                      const CodecInst* codecInst)
-{
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
-                 "TransmitMixer::StartRecordingCall(fileName=%s)", fileName);
-
-    if (_fileCallRecording)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
-                     "StartRecordingCall() is already recording");
-        return 0;
-    }
-
-    FileFormats format;
-    const uint32_t notificationTime(0); // Not supported in VoE
-    CodecInst dummyCodec = { 100, "L16", 16000, 320, 1, 320000 };
-
-    if (codecInst != NULL && codecInst->channels != 1)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_BAD_ARGUMENT, kTraceError,
-            "StartRecordingCall() invalid compression");
-        return (-1);
-    }
-    if (codecInst == NULL)
-    {
-        format = kFileFormatPcm16kHzFile;
-        codecInst = &dummyCodec;
-    } else if ((STR_CASE_CMP(codecInst->plname,"L16") == 0) ||
-        (STR_CASE_CMP(codecInst->plname,"PCMU") == 0) ||
-        (STR_CASE_CMP(codecInst->plname,"PCMA") == 0))
-    {
-        format = kFileFormatWavFile;
-    } else
-    {
-        format = kFileFormatCompressedFile;
-    }
-
-    rtc::CritScope cs(&_critSect);
-
-    // Destroy the old instance
-    if (file_call_recorder_) {
-      file_call_recorder_->RegisterModuleFileCallback(NULL);
-      file_call_recorder_.reset();
-    }
-
-    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 (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;
-    }
-    file_call_recorder_->RegisterModuleFileCallback(this);
-    _fileCallRecording = true;
-
-    return 0;
-}
-
-int TransmitMixer::StartRecordingCall(OutStream* stream,
-                                      const  CodecInst* codecInst)
-{
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
-                 "TransmitMixer::StartRecordingCall()");
-
-    if (_fileCallRecording)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
-                     "StartRecordingCall() is already recording");
-        return 0;
-    }
-
-    FileFormats format;
-    const uint32_t notificationTime(0); // Not supported in VoE
-    CodecInst dummyCodec = { 100, "L16", 16000, 320, 1, 320000 };
-
-    if (codecInst != NULL && codecInst->channels != 1)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_BAD_ARGUMENT, kTraceError,
-            "StartRecordingCall() invalid compression");
-        return (-1);
-    }
-    if (codecInst == NULL)
-    {
-        format = kFileFormatPcm16kHzFile;
-        codecInst = &dummyCodec;
-    } else if ((STR_CASE_CMP(codecInst->plname,"L16") == 0) ||
-        (STR_CASE_CMP(codecInst->plname,"PCMU") == 0) ||
-        (STR_CASE_CMP(codecInst->plname,"PCMA") == 0))
-    {
-        format = kFileFormatWavFile;
-    } else
-    {
-        format = kFileFormatCompressedFile;
-    }
-
-    rtc::CritScope cs(&_critSect);
-
-    // Destroy the old instance
-    if (file_call_recorder_) {
-      file_call_recorder_->RegisterModuleFileCallback(NULL);
-      file_call_recorder_.reset();
-    }
-
-    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 (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;
-    }
-
-    file_call_recorder_->RegisterModuleFileCallback(this);
-    _fileCallRecording = true;
-
-    return 0;
-}
-
-int TransmitMixer::StopRecordingCall()
-{
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
-                 "TransmitMixer::StopRecordingCall()");
-
-    if (!_fileCallRecording)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, -1),
-                     "StopRecordingCall() file isnot recording");
-        return -1;
-    }
-
-    rtc::CritScope cs(&_critSect);
-
-    if (file_call_recorder_->StopRecording() != 0) {
-      _engineStatisticsPtr->SetLastError(
-          VE_STOP_RECORDING_FAILED, kTraceError,
-          "StopRecording(), could not stop recording");
-      return -1;
-    }
-
-    file_call_recorder_->RegisterModuleFileCallback(NULL);
-    file_call_recorder_.reset();
-    _fileCallRecording = false;
-
-    return 0;
-}
-
-void
-TransmitMixer::SetMixWithMicStatus(bool mix)
-{
-    _mixFileWithMicrophone = mix;
-}
-
 int8_t TransmitMixer::AudioLevel() const
 {
     // Speech + file level [0,9]
     return _audioLevel.Level();
 }
 
 int16_t TransmitMixer::AudioLevelFullRange() const
 {
     // Speech + file level [0,32767]
     return _audioLevel.LevelFullRange();
 }
 
 double TransmitMixer::GetTotalInputEnergy() const {
   return _audioLevel.TotalEnergy();
 }
 
 double TransmitMixer::GetTotalInputDuration() const {
   return _audioLevel.TotalDuration();
 }
 
-bool TransmitMixer::IsRecordingCall()
-{
-    return _fileCallRecording;
-}
-
-bool TransmitMixer::IsRecordingMic()
-{
-    rtc::CritScope cs(&_critSect);
-    return _fileRecording;
-}
-
 void TransmitMixer::GenerateAudioFrame(const int16_t* audio,
                                        size_t samples_per_channel,
                                        size_t num_channels,
                                        int sample_rate_hz) {
   int codec_rate;
   size_t num_codec_channels;
   GetSendCodecInfo(&codec_rate, &num_codec_channels);
   stereo_codec_ = num_codec_channels == 2;
 
   // We want to process at the lowest rate possible without losing information.
   // Choose the lowest native rate at least equal to the input and codec rates.
   const int min_processing_rate = std::min(sample_rate_hz, codec_rate);
   for (size_t i = 0; i < AudioProcessing::kNumNativeSampleRates; ++i) {
     _audioFrame.sample_rate_hz_ = AudioProcessing::kNativeSampleRatesHz[i];
     if (_audioFrame.sample_rate_hz_ >= min_processing_rate) {
       break;
     }
   }
   _audioFrame.num_channels_ = std::min(num_channels, num_codec_channels);
   RemixAndResample(audio, samples_per_channel, num_channels, sample_rate_hz,
                    &resampler_, &_audioFrame);
 }
 
-int32_t TransmitMixer::RecordAudioToFile(
-    uint32_t mixingFrequency)
-{
-    rtc::CritScope cs(&_critSect);
-    if (!file_recorder_) {
-      WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
-                   "TransmitMixer::RecordAudioToFile() filerecorder doesnot"
-                   "exist");
-      return -1;
-    }
-
-    if (file_recorder_->RecordAudioToFile(_audioFrame) != 0) {
-      WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
-                   "TransmitMixer::RecordAudioToFile() file recording"
-                   "failed");
-      return -1;
-    }
-
-    return 0;
-}
-
-int32_t TransmitMixer::MixOrReplaceAudioWithFile(
-    int mixingFrequency)
-{
-    std::unique_ptr<int16_t[]> fileBuffer(new int16_t[640]);
-
-    size_t fileSamples(0);
-    {
-        rtc::CritScope cs(&_critSect);
-        if (!file_player_) {
-          WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
-                       "TransmitMixer::MixOrReplaceAudioWithFile()"
-                       "fileplayer doesnot exist");
-          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;
-        }
-    }
-
-    assert(_audioFrame.samples_per_channel_ == fileSamples);
-
-    if (_mixFileWithMicrophone)
-    {
-        // Currently file stream is always mono.
-        // TODO(xians): Change the code when FilePlayer supports real stereo.
-        MixWithSat(_audioFrame.mutable_data(),
-                   _audioFrame.num_channels_,
-                   fileBuffer.get(),
-                   1,
-                   fileSamples);
-    } else
-    {
-        // Replace ACM audio with file.
-        // Currently file stream is always mono.
-        // TODO(xians): Change the code when FilePlayer supports real stereo.
-        _audioFrame.UpdateFrame(-1,
-                                0xFFFFFFFF,
-                                fileBuffer.get(),
-                                fileSamples,
-                                mixingFrequency,
-                                AudioFrame::kNormalSpeech,
-                                AudioFrame::kVadUnknown,
-                                1);
-    }
-    return 0;
-}
-
 void TransmitMixer::ProcessAudio(int delay_ms, int clock_drift,
                                  int current_mic_level, bool key_pressed) {
   if (audioproc_->set_stream_delay_ms(delay_ms) != 0) {
     // Silently ignore this failure to avoid flooding the logs.
   }
 
   GainControl* agc = audioproc_->gain_control();
   if (agc->set_stream_analog_level(current_mic_level) != 0) {
     LOG(LS_ERROR) << "set_stream_analog_level failed: current_mic_level = "
                   << current_mic_level;
@@ skipping 45 matching lines @@
 void TransmitMixer::EnableStereoChannelSwapping(bool enable) {
   swap_stereo_channels_ = enable;
 }
 
 bool TransmitMixer::IsStereoChannelSwappingEnabled() {
   return swap_stereo_channels_;
 }
 
 }  // namespace voe
 }  // namespace webrtc