Remove VoEFile

voice_engine/channel.h

 /*
  *  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 14 matching lines @@
 #include "modules/audio_conference_mixer/include/audio_conference_mixer_defines.h"
 #include "modules/audio_processing/rms_level.h"
 #include "modules/rtp_rtcp/include/remote_ntp_time_estimator.h"
 #include "modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "modules/rtp_rtcp/include/rtp_receiver.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "rtc_base/criticalsection.h"
 #include "rtc_base/event.h"
 #include "rtc_base/thread_checker.h"
 #include "voice_engine/audio_level.h"
-#include "voice_engine/file_player.h"
-#include "voice_engine/file_recorder.h"
 #include "voice_engine/include/voe_base.h"
 #include "voice_engine/include/voe_network.h"
 #include "voice_engine/shared_data.h"
 #include "voice_engine/voice_engine_defines.h"
 
 namespace rtc {
 class TimestampWrapAroundHandler;
 }
 
 namespace webrtc {
 
 class AudioDeviceModule;
-class FileWrapper;
 class PacketRouter;
 class ProcessThread;
 class RateLimiter;
 class ReceiveStatistics;
 class RemoteNtpTimeEstimator;
 class RtcEventLog;
 class RTPPayloadRegistry;
 class RTPReceiverAudio;
 class RtpPacketReceived;
 class RtpRtcp;
@@ skipping 18 matching lines @@
 class VoERtcpObserver;
 
 // Helper class to simplify locking scheme for members that are accessed from
 // multiple threads.
 // Example: a member can be set on thread T1 and read by an internal audio
 // thread T2. Accessing the member via this class ensures that we are
 // safe and also avoid TSan v2 warnings.
 class ChannelState {
  public:
   struct State {
-    bool output_file_playing = false;
-    bool input_file_playing = false;
     bool playing = false;
     bool sending = false;
   };
 
   ChannelState() {}
   virtual ~ChannelState() {}
 
   void Reset() {
     rtc::CritScope lock(&lock_);
     state_ = State();
   }
 
   State Get() const {
     rtc::CritScope lock(&lock_);
     return state_;
   }
 
-  void SetOutputFilePlaying(bool enable) {
-    rtc::CritScope lock(&lock_);
-    state_.output_file_playing = enable;
-  }
-
-  void SetInputFilePlaying(bool enable) {
-    rtc::CritScope lock(&lock_);
-    state_.input_file_playing = enable;
-  }
-
   void SetPlaying(bool enable) {
     rtc::CritScope lock(&lock_);
     state_.playing = enable;
   }
 
   void SetSending(bool enable) {
     rtc::CritScope lock(&lock_);
     state_.sending = enable;
   }
 
  private:
   rtc::CriticalSection lock_;
   State state_;
 };
 
 class Channel
     : public RtpData,
       public RtpFeedback,
-      public FileCallback,  // receiving notification from file player &
-                            // recorder
       public Transport,
       public AudioPacketizationCallback,  // receive encoded packets from the
                                           // ACM
       public MixerParticipant,  // supplies output mixer with audio frames
       public OverheadObserver {
  public:
   friend class VoERtcpObserver;
 
   enum { KNumSocketThreads = 1 };
   enum { KNumberOfSocketBuffers = 8 };
@@ skipping 63 matching lines @@
   // VoENetwork
   int32_t RegisterExternalTransport(Transport* transport);
   int32_t DeRegisterExternalTransport();
   int32_t ReceivedRTPPacket(const uint8_t* received_packet,
                             size_t length,
                             const PacketTime& packet_time);
   // TODO(nisse, solenberg): Delete when VoENetwork is deleted.
   int32_t ReceivedRTCPPacket(const uint8_t* data, size_t length);
   void OnRtpPacket(const RtpPacketReceived& packet);
 
-  // VoEFile
-  int StartPlayingFileLocally(const char* fileName,
-                              bool loop,
-                              FileFormats format,
-                              int startPosition,
-                              float volumeScaling,
-                              int stopPosition,
-                              const CodecInst* codecInst);
-  int StartPlayingFileLocally(InStream* stream,
-                              FileFormats format,
-                              int startPosition,
-                              float volumeScaling,
-                              int stopPosition,
-                              const CodecInst* codecInst);
-  int StopPlayingFileLocally();
-  int IsPlayingFileLocally() const;
-  int RegisterFilePlayingToMixer();
-  int StartPlayingFileAsMicrophone(const char* fileName,
-                                   bool loop,
-                                   FileFormats format,
-                                   int startPosition,
-                                   float volumeScaling,
-                                   int stopPosition,
-                                   const CodecInst* codecInst);
-  int StartPlayingFileAsMicrophone(InStream* stream,
-                                   FileFormats format,
-                                   int startPosition,
-                                   float volumeScaling,
-                                   int stopPosition,
-                                   const CodecInst* codecInst);
-  int StopPlayingFileAsMicrophone();
-  int IsPlayingFileAsMicrophone() const;
-  int StartRecordingPlayout(const char* fileName, const CodecInst* codecInst);
-  int StartRecordingPlayout(OutStream* stream, const CodecInst* codecInst);
-  int StopRecordingPlayout();
-
-  void SetMixWithMicStatus(bool mix);
-
   // Muting, Volume and Level.
   void SetInputMute(bool enable);
   void SetChannelOutputVolumeScaling(float scaling);
   int GetSpeechOutputLevel() const;
   int GetSpeechOutputLevelFullRange() const;
   // See description of "totalAudioEnergy" in the WebRTC stats spec:
   // https://w3c.github.io/webrtc-stats/#dom-rtcmediastreamtrackstats-totalaudioenergy
   double GetTotalOutputEnergy() const;
   double GetTotalOutputDuration() const;
 
@@ skipping 73 matching lines @@
   MixerParticipant::AudioFrameInfo GetAudioFrameWithMuted(
       int32_t id,
       AudioFrame* audioFrame) override;
   int32_t NeededFrequency(int32_t id) const override;
 
   // From AudioMixer::Source.
   AudioMixer::Source::AudioFrameInfo GetAudioFrameWithInfo(
       int sample_rate_hz,
       AudioFrame* audio_frame);
 
-  // From FileCallback
-  void PlayNotification(int32_t id, uint32_t durationMs) override;
-  void RecordNotification(int32_t id, uint32_t durationMs) override;
-  void PlayFileEnded(int32_t id) override;
-  void RecordFileEnded(int32_t id) override;
-
   uint32_t InstanceId() const { return _instanceId; }
   int32_t ChannelId() const { return _channelId; }
   bool Playing() const { return channel_state_.Get().playing; }
   bool Sending() const { return channel_state_.Get().sending; }
   bool ExternalTransport() const {
     rtc::CritScope cs(&_callbackCritSect);
     return _externalTransport;
   }
   RtpRtcp* RtpRtcpModulePtr() const { return _rtpRtcpModule.get(); }
   int8_t OutputEnergyLevel() const { return _outputAudioLevel.Level(); }
@@ skipping 56 matching lines @@
                              RTPHeader *header);
   bool OnRecoveredPacket(const uint8_t* packet, size_t packet_length);
 
   bool ReceivePacket(const uint8_t* packet,
                      size_t packet_length,
                      const RTPHeader& header,
                      bool in_order);
   bool IsPacketInOrder(const RTPHeader& header) const;
   bool IsPacketRetransmitted(const RTPHeader& header, bool in_order) const;
   int ResendPackets(const uint16_t* sequence_numbers, int length);
-  int32_t MixOrReplaceAudioWithFile(AudioFrame* audio_frame);
-  int32_t MixAudioWithFile(AudioFrame& audioFrame, int mixingFrequency);
   void UpdatePlayoutTimestamp(bool rtcp);
   void RegisterReceiveCodecsToRTPModule();
 
   int SetSendRtpHeaderExtension(bool enable,
                                 RTPExtensionType type,
                                 unsigned char id);
 
   void UpdateOverheadForEncoder()
       RTC_EXCLUSIVE_LOCKS_REQUIRED(overhead_per_packet_lock_);
 
   int GetRtpTimestampRateHz() const;
   int64_t GetRTT(bool allow_associate_channel) const;
 
   // Called on the encoder task queue when a new input audio frame is ready
   // for encoding.
   void ProcessAndEncodeAudioOnTaskQueue(AudioFrame* audio_input);
 
   uint32_t _instanceId;
   int32_t _channelId;
 
-  rtc::CriticalSection _fileCritSect;
   rtc::CriticalSection _callbackCritSect;
   rtc::CriticalSection volume_settings_critsect_;
 
   ChannelState channel_state_;
 
   std::unique_ptr<voe::RtcEventLogProxy> event_log_proxy_;
   std::unique_ptr<voe::RtcpRttStatsProxy> rtcp_rtt_stats_proxy_;
 
   std::unique_ptr<RtpHeaderParser> rtp_header_parser_;
   std::unique_ptr<RTPPayloadRegistry> rtp_payload_registry_;
   std::unique_ptr<ReceiveStatistics> rtp_receive_statistics_;
   std::unique_ptr<RtpReceiver> rtp_receiver_;
   TelephoneEventHandler* telephone_event_handler_;
   std::unique_ptr<RtpRtcp> _rtpRtcpModule;
   std::unique_ptr<AudioCodingModule> audio_coding_;
   acm2::CodecManager codec_manager_;
   acm2::RentACodec rent_a_codec_;
   std::unique_ptr<AudioSinkInterface> audio_sink_;
   AudioLevel _outputAudioLevel;
   bool _externalTransport;
   // Downsamples to the codec rate if necessary.
   PushResampler<int16_t> input_resampler_;
-  std::unique_ptr<FilePlayer> input_file_player_;
-  std::unique_ptr<FilePlayer> output_file_player_;
-  std::unique_ptr<FileRecorder> output_file_recorder_;
-  int _inputFilePlayerId;
-  int _outputFilePlayerId;
-  int _outputFileRecorderId;
-  bool _outputFileRecording;
   uint32_t _timeStamp RTC_ACCESS_ON(encoder_queue_);
 
   RemoteNtpTimeEstimator ntp_estimator_ RTC_GUARDED_BY(ts_stats_lock_);
 
   // Timestamp of the audio pulled from NetEq.
   rtc::Optional<uint32_t> jitter_buffer_playout_timestamp_;
 
   rtc::CriticalSection video_sync_lock_;
   uint32_t playout_timestamp_rtp_ RTC_GUARDED_BY(video_sync_lock_);
   uint32_t playout_delay_ms_ RTC_GUARDED_BY(video_sync_lock_);
@@ skipping 13 matching lines @@
   OutputMixer* _outputMixerPtr;
   ProcessThread* _moduleProcessThreadPtr;
   AudioDeviceModule* _audioDeviceModulePtr;
   VoiceEngineObserver* _voiceEngineObserverPtr;  // owned by base
   rtc::CriticalSection* _callbackCritSectPtr;    // owned by base
   Transport* _transportPtr;  // WebRtc socket or external transport
   RmsLevel rms_level_ RTC_ACCESS_ON(encoder_queue_);
   bool input_mute_ RTC_GUARDED_BY(volume_settings_critsect_);
   bool previous_frame_muted_ RTC_ACCESS_ON(encoder_queue_);
   float _outputGain RTC_GUARDED_BY(volume_settings_critsect_);
-  // VoEBase
-  bool _mixFileWithMicrophone;
   // VoeRTP_RTCP
   // TODO(henrika): can today be accessed on the main thread and on the
   // task queue; hence potential race.
   bool _includeAudioLevelIndication;
   size_t transport_overhead_per_packet_
       RTC_GUARDED_BY(overhead_per_packet_lock_);
   size_t rtp_overhead_per_packet_ RTC_GUARDED_BY(overhead_per_packet_lock_);
   rtc::CriticalSection overhead_per_packet_lock_;
   // VoENetwork
   AudioFrame::SpeechType _outputSpeechType;
@@ skipping 23 matching lines @@
 
   bool encoder_queue_is_active_ RTC_GUARDED_BY(encoder_queue_lock_) = false;
 
   rtc::TaskQueue* encoder_queue_ = nullptr;
 };
 
 }  // namespace voe
 }  // namespace webrtc
 
 #endif  // VOICE_ENGINE_CHANNEL_H_