NetEq: Deprecate playout modes Fax, Off and Streaming

The playout modes other than Normal have not been reachable for a long
time, other than through tests. It is time to deprecate them.

The only meaningful use was that Fax mode was sometimes set from
tests, in order to avoid time-stretching operations (accelerate and
pre-emptive expand) from messing with the test results. With this CL,
a new config is added instead, which lets the user specify exactly
this: don't do time-stretching.

As a result of Fax and Off modes being removed, the following code
clean-up was done:
- Fold DecisionLogicNormal into DecisionLogic.
- Remove AudioRepetition and AlternativePlc operations, since they can
  no longer be reached.

Bug: webrtc:9421
Change-Id: I651458e9c1931a99f3b07e242817d303bac119df
Reviewed-on: https://webrtc-review.googlesource.com/84123
Commit-Queue: Henrik Lundin <henrik.lundin@webrtc.org>
Reviewed-by: Ivo Creusen <ivoc@webrtc.org>
Reviewed-by: Minyue Li <minyue@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23704}

modules/audio_coding/neteq/tools/neteq_input.cc

@@ -28,5 +28,50 @@ std::string NetEqInput::PacketData::ToString() const {
   return ss.str();
 }
 
+TimeLimitedNetEqInput::TimeLimitedNetEqInput(std::unique_ptr<NetEqInput> input,
+                                             int64_t duration_ms)
+    : input_(std::move(input)),
+      start_time_ms_(input_->NextEventTime()),
+      duration_ms_(duration_ms) {}
+
+rtc::Optional<int64_t> TimeLimitedNetEqInput::NextPacketTime() const {
+  return ended_ ? rtc::Optional<int64_t>() : input_->NextPacketTime();
+}
+
+rtc::Optional<int64_t> TimeLimitedNetEqInput::NextOutputEventTime() const {
+  return ended_ ? rtc::Optional<int64_t>() : input_->NextOutputEventTime();
+}
+
+std::unique_ptr<NetEqInput::PacketData> TimeLimitedNetEqInput::PopPacket() {
+  if (ended_) {
+    return std::unique_ptr<PacketData>();
+  }
+  auto packet = input_->PopPacket();
+  MaybeSetEnded();
+  return packet;
+}
+
+void TimeLimitedNetEqInput::AdvanceOutputEvent() {
+  if (!ended_) {
+    input_->AdvanceOutputEvent();
+    MaybeSetEnded();
+  }
+}
+
+bool TimeLimitedNetEqInput::ended() const {
+  return ended_ || input_->ended();
+}
+
+rtc::Optional<RTPHeader> TimeLimitedNetEqInput::NextHeader() const {
+  return ended_ ? rtc::Optional<RTPHeader>() : input_->NextHeader();
+}
+
+void TimeLimitedNetEqInput::MaybeSetEnded() {
+  if (NextEventTime() && start_time_ms_ &&
+      *NextEventTime() - *start_time_ms_ > duration_ms_) {
+    ended_ = true;
+  }
+}
+
 }  // namespace test
 }  // namespace webrtc

modules/audio_coding/neteq/tools/neteq_input.h

@@ -78,6 +78,28 @@ class NetEqInput {
   virtual absl::optional<RTPHeader> NextHeader() const = 0;
 };
 
+// Wrapper class to impose a time limit on a NetEqInput object, typically
+// another time limit than what the object itself provides. For example, an
+// input taken from a file can be cut shorter by wrapping it in this class.
+class TimeLimitedNetEqInput : public NetEqInput {
+ public:
+  TimeLimitedNetEqInput(std::unique_ptr<NetEqInput> input, int64_t duration_ms);
+  rtc::Optional<int64_t> NextPacketTime() const override;
+  rtc::Optional<int64_t> NextOutputEventTime() const override;
+  std::unique_ptr<PacketData> PopPacket() override;
+  void AdvanceOutputEvent() override;
+  bool ended() const override;
+  rtc::Optional<RTPHeader> NextHeader() const override;
+
+ private:
+  void MaybeSetEnded();
+
+  std::unique_ptr<NetEqInput> input_;
+  const rtc::Optional<int64_t> start_time_ms_;
+  const int64_t duration_ms_;
+  bool ended_ = false;
+};
+
 }  // namespace test
 }  // namespace webrtc
 #endif  // MODULES_AUDIO_CODING_NETEQ_TOOLS_NETEQ_INPUT_H_

modules/audio_coding/neteq/tools/neteq_test.cc

@@ -115,6 +115,34 @@ NetEqLifetimeStatistics NetEqTest::LifetimeStats() const {
   return neteq_->GetLifetimeStatistics();
 }
 
+NetEqTest::DecoderMap NetEqTest::StandardDecoderMap() {
+  DecoderMap codecs = {
+    {0, std::make_pair(NetEqDecoder::kDecoderPCMu, "pcmu")},
+    {8, std::make_pair(NetEqDecoder::kDecoderPCMa, "pcma")},
+    {102, std::make_pair(NetEqDecoder::kDecoderILBC, "ilbc")},
+    {103, std::make_pair(NetEqDecoder::kDecoderISAC, "isac")},
+#if !defined(WEBRTC_ANDROID)
+    {104, std::make_pair(NetEqDecoder::kDecoderISACswb, "isac-swb")},
+#endif
+    {111, std::make_pair(NetEqDecoder::kDecoderOpus, "opus")},
+    {93, std::make_pair(NetEqDecoder::kDecoderPCM16B, "pcm16-nb")},
+    {94, std::make_pair(NetEqDecoder::kDecoderPCM16Bwb, "pcm16-wb")},
+    {95, std::make_pair(NetEqDecoder::kDecoderPCM16Bswb32kHz, "pcm16-swb32")},
+    {96, std::make_pair(NetEqDecoder::kDecoderPCM16Bswb48kHz, "pcm16-swb48")},
+    {9, std::make_pair(NetEqDecoder::kDecoderG722, "g722")},
+    {106, std::make_pair(NetEqDecoder::kDecoderAVT, "avt")},
+    {114, std::make_pair(NetEqDecoder::kDecoderAVT16kHz, "avt-16")},
+    {115, std::make_pair(NetEqDecoder::kDecoderAVT32kHz, "avt-32")},
+    {116, std::make_pair(NetEqDecoder::kDecoderAVT48kHz, "avt-48")},
+    {117, std::make_pair(NetEqDecoder::kDecoderRED, "red")},
+    {13, std::make_pair(NetEqDecoder::kDecoderCNGnb, "cng-nb")},
+    {98, std::make_pair(NetEqDecoder::kDecoderCNGwb, "cng-wb")},
+    {99, std::make_pair(NetEqDecoder::kDecoderCNGswb32kHz, "cng-swb32")},
+    {100, std::make_pair(NetEqDecoder::kDecoderCNGswb48kHz, "cng-swb48")}
+  };
+  return codecs;
+}
+
 void NetEqTest::RegisterDecoders(const DecoderMap& codecs) {
   for (const auto& c : codecs) {
     RTC_CHECK_EQ(

modules/audio_coding/neteq/tools/neteq_test.h

@@ -91,6 +91,8 @@ class NetEqTest {
   NetEqNetworkStatistics SimulationStats();
   NetEqLifetimeStatistics LifetimeStats() const;
 
+  static DecoderMap StandardDecoderMap();
+
  private:
   void RegisterDecoders(const DecoderMap& codecs);
   void RegisterExternalDecoders(const ExtDecoderMap& codecs);