Added a ParsePayload method to AudioDecoder.

webrtc/modules/audio_coding/codecs/audio_decoder.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.
  */
 
 #include "webrtc/modules/audio_coding/codecs/audio_decoder.h"
 
 #include <assert.h>
 
 #include "webrtc/base/array_view.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/sanitizer.h"
 #include "webrtc/base/trace_event.h"
 
 namespace webrtc {
 
+namespace {
+class LegacyFrame : public AudioDecoder::Frame {
+ public:
+  LegacyFrame(AudioDecoder* decoder,
+              rtc::Buffer* payload,
+              bool is_primary_payload)
+      : decoder_(decoder), is_primary_payload_(is_primary_payload) {
+    using std::swap;

[hlundin-webrtc, 2016/09/09 12:11:49]

Why the using statement?

[kwiberg-webrtc, 2016/09/10 07:34:59]

It's the standard idiom for swapping stuff. See e.g.
http://en.cppreference.com/w/cpp/concept/Swappable

[hlundin-webrtc, 2016/09/12 08:07:11]

Acknowledged.

+    swap(this->payload_, *payload);

[hlundin-webrtc, 2016/09/09 12:11:49]

#include what you use.

[kwiberg-webrtc, 2016/09/10 07:34:59]

+1

[ossu, 2016/09/12 10:31:36]

Acknowledged.

+  }

[kwiberg-webrtc, 2016/09/10 07:34:59]

Why not move *payload to payload_ instead of swapping?

[ossu, 2016/09/12 10:31:36]

Hmm. I was thinking of doing this to allow buffer storage to be reused but at
this point, it really doesn't matter, since LegacyFrame::payload_ will always be
created empty. I'll simplify with a move.

+
+  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);
+    }
+
+    if (ret < 0)
+      return rtc::Optional<DecodeResult>();
+
+    return rtc::Optional<DecodeResult>({static_cast<size_t>(ret), speech_type});
+  }
+
+ private:
+  AudioDecoder* decoder_;

[hlundin-webrtc, 2016/09/09 12:11:49]

const

+  rtc::Buffer payload_;
+  bool is_primary_payload_;

[hlundin-webrtc, 2016/09/09 12:11:49]

const

[kwiberg-webrtc, 2016/09/10 07:34:59]

All three could be const, right?

[ossu, 2016/09/12 10:31:36]

Acknowledged.

+};
+}
+
+AudioDecoder::ParseResult::ParseResult() = default;
+AudioDecoder::ParseResult::ParseResult(ParseResult&& b) = default;
+AudioDecoder::ParseResult::ParseResult(uint32_t timestamp,
+                                       bool primary,
+                                       std::unique_ptr<Frame> frame)
+    : timestamp(timestamp), primary(primary), frame(std::move(frame)) {}
+
+AudioDecoder::ParseResult::~ParseResult() = default;
+
+AudioDecoder::ParseResult& AudioDecoder::ParseResult::operator=(
+    ParseResult&& b) = default;
+
+std::vector<AudioDecoder::ParseResult> AudioDecoder::ParsePayload(
+    rtc::Buffer* payload,
+    uint32_t timestamp,
+    bool is_primary) {
+  std::vector<ParseResult> results;
+  std::unique_ptr<Frame> frame(
+      new LegacyFrame(this, payload, is_primary));
+  results.emplace_back(timestamp, is_primary, std::move(frame));
+  return results;
+}
+
 int AudioDecoder::Decode(const uint8_t* encoded, size_t encoded_len,
                          int sample_rate_hz, size_t max_decoded_bytes,
                          int16_t* decoded, SpeechType* speech_type) {
   TRACE_EVENT0("webrtc", "AudioDecoder::Decode");
   rtc::MsanCheckInitialized(rtc::MakeArrayView(encoded, encoded_len));
   int duration = PacketDuration(encoded, encoded_len);
   if (duration >= 0 &&
       duration * Channels() * sizeof(int16_t) > max_decoded_bytes) {
     return -1;
   }
@@ skipping 61 matching lines @@
       return kSpeech;
     case 2:
       return kComfortNoise;
     default:
       assert(false);
       return kSpeech;
   }
 }
 
 }  // namespace webrtc