Moved codec-specific audio packet splitting into decoders.

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,
+              rtc::Buffer&& payload,
               bool is_primary_payload)
       : decoder_(decoder), is_primary_payload_(is_primary_payload) {
     using std::swap;
-    swap(this->payload_, *payload);
+    swap(this->payload_, 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());
     }
@@ skipping 37 matching lines @@
 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));
+  std::vector<PacketSplit> splits = SplitPacket(*payload);
+
+  // Just take the payload if we don't have to split.
+  if (splits.size() == 1 &&
+      splits[0].byte_offset == 0 &&
+      splits[0].num_bytes == payload->size() &&
+      splits[0].timestamp_offset == 0) {
+    std::unique_ptr<Frame> frame(
+        new LegacyFrame(this, std::move(*payload), is_primary));
+    results.emplace_back(timestamp + splits[0].timestamp_offset, is_primary,
+                         std::move(frame));
+  } else {
+    for (const auto& split : splits) {
+      RTC_CHECK(split.byte_offset + split.num_bytes <= payload->size());

[hlundin-webrtc, 2016/09/09 12:52:52]

RTC_CHECK_LE

[ossu, 2016/09/12 11:26:37]

Acknowledged.

+      rtc::Buffer new_payload(payload->data() + split.byte_offset,
+                              split.num_bytes);
+      std::unique_ptr<Frame> frame(
+          new LegacyFrame(this, std::move(new_payload), is_primary));
+      results.emplace_back(timestamp + split.timestamp_offset, is_primary,
+                           std::move(frame));
+    }
+  }

[kwiberg-webrtc, 2016/09/12 02:11:01]

If you processed the pieces in the reverse order, could you steal the buffer
from the first (but last to be processed) piece? That would both let you
eliminate the special case for size() == 1 and apply the corresponding
optimization to the size() > 1 case.

[ossu, 2016/09/12 11:26:37]

It doesn't really matter which of the packets get the stolen payload. I can take
a look at an optimization where the last split always steals the payload,
though. However, I see this as temporary code. Once all the restructuring CLs
have landed, there will be a pass where I updated all of the codecs
individually, rather than relying on this base class. Then, they can provide a
more fitting implementation without going through the SplitAudio interface.

[kwiberg-webrtc, 2016/09/13 12:23:37]

Well, if the first one gets it, you won't have to move its contents, just
truncate it.
OK, then this is good enough for now.

+
   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 &&
@@ skipping 33 matching lines @@
 }
 
 int AudioDecoder::IncomingPacket(const uint8_t* payload,
                                  size_t payload_len,
                                  uint16_t rtp_sequence_number,
                                  uint32_t rtp_timestamp,
                                  uint32_t arrival_timestamp) {
   return 0;
 }
 
+std::vector<AudioDecoder::PacketSplit> AudioDecoder::SplitPacket(
+    rtc::ArrayView<const uint8_t> payload) const {
+  return {PacketSplit{0, payload.size(), 0}};
+}
+
 int AudioDecoder::ErrorCode() { return 0; }
 
 int AudioDecoder::PacketDuration(const uint8_t* encoded,
                                  size_t encoded_len) const {
   return kNotImplemented;
 }
 
 int AudioDecoder::PacketDurationRedundant(const uint8_t* encoded,
                                           size_t encoded_len) const {
   return kNotImplemented;
@@ skipping 11 matching lines @@
       return kSpeech;
     case 2:
       return kComfortNoise;
     default:
       assert(false);
       return kSpeech;
   }
 }
 
 }  // namespace webrtc