Moved Opus-specific payload splitting into AudioDecoderOpus.

webrtc/modules/audio_coding/codecs/opus/audio_decoder_opus.cc

 /*
  *  Copyright (c) 2015 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/modules/audio_coding/codecs/opus/audio_decoder_opus.h"
 
+#include <utility>
+
 #include "webrtc/base/checks.h"
 
 namespace webrtc {
 
+namespace {
+class OpusFrame : public AudioDecoder::EncodedAudioFrame {
+ public:
+  OpusFrame(AudioDecoderOpus* decoder,
+            rtc::Buffer&& payload,
+            bool is_primary_payload)
+      : decoder_(decoder),
+        payload_(std::move(payload)),
+        is_primary_payload_(is_primary_payload) {}
+
+  size_t Duration() const override {
+    int ret;
+    if (is_primary_payload_) {
+      ret = decoder_->PacketDuration(payload_.data(), payload_.size());
+    } else {
+      ret = decoder_->PacketDurationRedundant(payload_.data(), payload_.size());
+    }
+    return (ret < 0) ? 0 : static_cast<size_t>(ret);
+  }
+
+  rtc::Optional<DecodeResult> Decode(
+      rtc::ArrayView<int16_t> decoded) const override {
+    AudioDecoder::SpeechType speech_type = AudioDecoder::kSpeech;
+    int ret;
+    if (is_primary_payload_) {
+      ret = decoder_->Decode(
+          payload_.data(), payload_.size(), decoder_->SampleRateHz(),
+          decoded.size() * sizeof(int16_t), decoded.data(), &speech_type);
+    } else {
+      ret = decoder_->DecodeRedundant(
+          payload_.data(), payload_.size(), decoder_->SampleRateHz(),
+          decoded.size() * sizeof(int16_t), decoded.data(), &speech_type);
+    }

[kwiberg-webrtc, 2016/09/20 09:14:45]

That's a lot of duplicated function arguments. Consider the simplification you
suggested to me earlier:

using DT = decltype(decoder_);
const auto dec_fun = is_primary_payload_ ? &DT::PacketDuration
                                         : &DT::PacketDurationRedundant;
const int ret = (decoder_->*dec_fun)(
    payload_.data(), payload_.size(), decoder_->SampleRateHz(),
    decoded.size() * sizeof(int16_t), decoded.data(), &speech_type);

Not having to repeat all those arguments is worth a lot.

[ossu, 2016/09/20 13:51:56]

I'll be leaving this as-is for now, since I expect to be reworking AudioDecoder
some more in the near future.

[kwiberg-webrtc, 2016/09/20 14:56:22]

Acknowledged.

But expect me to keep badgering you about constructs like these until you've
seen the light.

[ossu, 2016/09/20 15:45:21]

Badger? Badger, badger, badger!

+
+    if (ret < 0)
+      return rtc::Optional<DecodeResult>();
+
+    return rtc::Optional<DecodeResult>({static_cast<size_t>(ret), speech_type});
+  }
+
+ private:
+  AudioDecoderOpus* const decoder_;
+  const rtc::Buffer payload_;
+  const bool is_primary_payload_;
+};
+
+}  // namespace
+
 AudioDecoderOpus::AudioDecoderOpus(size_t num_channels)
     : channels_(num_channels) {
   RTC_DCHECK(num_channels == 1 || num_channels == 2);
   WebRtcOpus_DecoderCreate(&dec_state_, channels_);
   WebRtcOpus_DecoderInit(dec_state_);
 }
 
 AudioDecoderOpus::~AudioDecoderOpus() {
   WebRtcOpus_DecoderFree(dec_state_);
 }
 
+std::vector<AudioDecoder::ParseResult> AudioDecoderOpus::ParsePayload(
+    rtc::Buffer&& payload,
+    uint32_t timestamp) {
+  std::vector<ParseResult> results;
+
+  if (PacketHasFec(payload.data(), payload.size())) {
+    const int duration =
+        PacketDurationRedundant(payload.data(), payload.size());
+    RTC_DCHECK_GE(duration, 0);
+    rtc::Buffer payload_copy(payload.data(), payload.size());
+    std::unique_ptr<EncodedAudioFrame> fec_frame(
+        new OpusFrame(this, std::move(payload_copy), false));
+    results.emplace_back(timestamp - duration, 1, std::move(fec_frame));
+  }
+  std::unique_ptr<EncodedAudioFrame> frame(
+      new OpusFrame(this, std::move(payload), true));
+  results.emplace_back(timestamp, 0, std::move(frame));
+  return results;
+}
+
 int AudioDecoderOpus::DecodeInternal(const uint8_t* encoded,
                                      size_t encoded_len,
                                      int sample_rate_hz,
                                      int16_t* decoded,
                                      SpeechType* speech_type) {
   RTC_DCHECK_EQ(sample_rate_hz, 48000);
   int16_t temp_type = 1;  // Default is speech.
   int ret =
       WebRtcOpus_Decode(dec_state_, encoded, encoded_len, decoded, &temp_type);
   if (ret > 0)
@@ skipping 51 matching lines @@
 
 int AudioDecoderOpus::SampleRateHz() const {
   return 48000;
 }
 
 size_t AudioDecoderOpus::Channels() const {
   return channels_;
 }
 
 }  // namespace webrtc