Added a ParsePayload method to AudioDecoder.

webrtc/modules/audio_coding/neteq/neteq_impl.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/neteq/neteq_impl.h"
 
 #include <assert.h>
 #include <memory.h>  // memset
 
 #include <algorithm>
+#include <utility>
 #include <vector>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/safe_conversions.h"
 #include "webrtc/base/sanitizer.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/modules/audio_coding/codecs/audio_decoder.h"
 #include "webrtc/modules/audio_coding/neteq/accelerate.h"
@@ skipping 248 matching lines @@
     }
     return kFail;
   }
   return kOK;
 }
 
 int NetEqImpl::RemovePayloadType(uint8_t rtp_payload_type) {
   rtc::CritScope lock(&crit_sect_);
   int ret = decoder_database_->Remove(rtp_payload_type);
   if (ret == DecoderDatabase::kOK) {
+    packet_buffer_->DiscardPacketsWithPayloadType(rtp_payload_type);
     return kOK;
   } else if (ret == DecoderDatabase::kDecoderNotFound) {
     error_code_ = kDecoderNotFound;
   } else {
     error_code_ = kOtherError;
   }
   return kFail;
 }
 
 bool NetEqImpl::SetMinimumDelay(int delay_ms) {
@@ skipping 28 matching lines @@
   return kNotImplemented;
 }
 
 int NetEqImpl::CurrentDelayMs() const {
   rtc::CritScope lock(&crit_sect_);
   if (fs_hz_ == 0)
     return 0;
   // Sum up the samples in the packet buffer with the future length of the sync
   // buffer, and divide the sum by the sample rate.
   const size_t delay_samples =
-      packet_buffer_->NumSamplesInBuffer(decoder_database_.get(),
-                                         decoder_frame_length_) +
+      packet_buffer_->NumSamplesInBuffer(decoder_frame_length_) +
       sync_buffer_->FutureLength();
   // The division below will truncate.
   const int delay_ms =
       static_cast<int>(delay_samples) / rtc::CheckedDivExact(fs_hz_, 1000);
   return delay_ms;
 }
 
 int NetEqImpl::FilteredCurrentDelayMs() const {
   rtc::CritScope lock(&crit_sect_);
   // Calculate the filtered packet buffer level in samples. The value from
@@ skipping 24 matching lines @@
 // TODO(henrik.lundin) Delete.
 NetEqPlayoutMode NetEqImpl::PlayoutMode() const {
   rtc::CritScope lock(&crit_sect_);
   return playout_mode_;
 }
 
 int NetEqImpl::NetworkStatistics(NetEqNetworkStatistics* stats) {
   rtc::CritScope lock(&crit_sect_);
   assert(decoder_database_.get());
   const size_t total_samples_in_buffers =
-      packet_buffer_->NumSamplesInBuffer(decoder_database_.get(),
-                                         decoder_frame_length_) +
+      packet_buffer_->NumSamplesInBuffer(decoder_frame_length_) +
       sync_buffer_->FutureLength();
   assert(delay_manager_.get());
   assert(decision_logic_.get());
   stats_.GetNetworkStatistics(fs_hz_, total_samples_in_buffers,
                               decoder_frame_length_, *delay_manager_.get(),
                               *decision_logic_.get(), stats);
   return 0;
 }
 
 void NetEqImpl::GetRtcpStatistics(RtcpStatistics* stats) {
@@ skipping 264 matching lines @@
         decoder_database_->GetDecoder(main_header.payloadType);
     assert(decoder);  // Should always get a valid object, since we have
     // already checked that the payload types are known.
     decoder->IncomingPacket(packet_list.front()->payload.data(),
                             packet_list.front()->payload.size(),
                             packet_list.front()->header.sequenceNumber,
                             packet_list.front()->header.timestamp,
                             receive_timestamp);
   }
 
+  PacketList parsed_packet_list;
+  while (!packet_list.empty()) {
+    std::unique_ptr<Packet> packet(packet_list.front());
+    packet_list.pop_front();
+    const DecoderDatabase::DecoderInfo* info =
+        decoder_database_->GetDecoderInfo(packet->header.payloadType);
+    if (!info) {
+      LOG(LS_WARNING) << "SplitAudio unknown payload type";
+      return kUnknownRtpPayloadType;
+    }
+
+    if (info->IsComfortNoise()) {
+      // Carry comfort noise packets along.
+      parsed_packet_list.push_back(packet.release());
+    } else {
+      std::vector<AudioDecoder::ParseResult> results =
+          info->GetDecoder()->ParsePayload(std::move(packet->payload),
+                                           packet->header.timestamp,
+                                           packet->primary);
+      const RTPHeader& original_header = packet->header;
+      for (auto& result : results) {
+        RTC_DCHECK(result.frame);
+        // Reuse the packet if possible
+        if (!packet) {
+          packet.reset(new Packet);
+          packet->header = original_header;
+        }
+        packet->header.timestamp = result.timestamp;
+        // TODO(ossu): Move from primary to some sort of priority level.
+        packet->primary = result.primary;
+        packet->frame = std::move(result.frame);
+        parsed_packet_list.push_back(packet.release());
+      }
+    }
+  }
+
   if (nack_enabled_) {
     RTC_DCHECK(nack_);
     if (update_sample_rate_and_channels) {
       nack_->Reset();
     }
-    nack_->UpdateLastReceivedPacket(packet_list.front()->header.sequenceNumber,
-                                    packet_list.front()->header.timestamp);
+    nack_->UpdateLastReceivedPacket(
+        parsed_packet_list.front()->header.sequenceNumber,
+        parsed_packet_list.front()->header.timestamp);
   }
 
   // Insert packets in buffer.
   const size_t buffer_length_before_insert =
       packet_buffer_->NumPacketsInBuffer();
   ret = packet_buffer_->InsertPacketList(
-      &packet_list,
-      *decoder_database_,
-      &current_rtp_payload_type_,
+      &parsed_packet_list, *decoder_database_, &current_rtp_payload_type_,
       &current_cng_rtp_payload_type_);
   if (ret == PacketBuffer::kFlushed) {
     // Reset DSP timestamp etc. if packet buffer flushed.
     new_codec_ = true;
     update_sample_rate_and_channels = true;
   } else if (ret != PacketBuffer::kOK) {
-    PacketBuffer::DeleteAllPackets(&packet_list);
+    PacketBuffer::DeleteAllPackets(&parsed_packet_list);
     return kOtherError;
   }
 
   if (first_packet_) {
     first_packet_ = false;
     // Update the codec on the next GetAudio call.
     new_codec_ = true;
   }
 
   if (current_rtp_payload_type_) {
@@ skipping 716 matching lines @@
       !decoder_database_->IsComfortNoise(packet->header.payloadType)) {
     assert(decoder);  // At this point, we must have a decoder object.
     // The number of channels in the |sync_buffer_| should be the same as the
     // number decoder channels.
     assert(sync_buffer_->Channels() == decoder->Channels());
     assert(decoded_buffer_length_ >= kMaxFrameSize * decoder->Channels());
     assert(operation == kNormal || operation == kAccelerate ||
            operation == kFastAccelerate || operation == kMerge ||
            operation == kPreemptiveExpand);
     packet_list->pop_front();
-    const size_t payload_length = packet->payload.size();
-    int decode_length;
-    if (!packet->primary) {
-      // This is a redundant payload; call the special decoder method.
-      decode_length = decoder->DecodeRedundant(
-          packet->payload.data(), packet->payload.size(), fs_hz_,
-          (decoded_buffer_length_ - *decoded_length) * sizeof(int16_t),
-          &decoded_buffer_[*decoded_length], speech_type);
-    } else {
-      decode_length = decoder->Decode(
-          packet->payload.data(), packet->payload.size(), fs_hz_,
-          (decoded_buffer_length_ - *decoded_length) * sizeof(int16_t),
-          &decoded_buffer_[*decoded_length], speech_type);
-    }
-
+    auto opt_result = packet->frame->Decode(
+        rtc::ArrayView<int16_t>(&decoded_buffer_[*decoded_length],
+                                decoded_buffer_length_ - *decoded_length));
     delete packet;
     packet = NULL;
-    if (decode_length > 0) {
-      *decoded_length += decode_length;
-      // Update |decoder_frame_length_| with number of samples per channel.
-      decoder_frame_length_ =
-          static_cast<size_t>(decode_length) / decoder->Channels();
-    } else if (decode_length < 0) {
+    if (opt_result) {
+      const auto& result = *opt_result;
+      *speech_type = result.speech_type;
+      if (result.num_decoded_samples > 0) {
+        *decoded_length += rtc::checked_cast<int>(result.num_decoded_samples);
+        // Update |decoder_frame_length_| with number of samples per channel.
+        decoder_frame_length_ =
+            result.num_decoded_samples / decoder->Channels();
+      }
+    } else {
       // Error.
-      LOG(LS_WARNING) << "Decode " << decode_length << " " << payload_length;
+      // TODO(ossu): What to put here?
+      LOG(LS_WARNING) << "Decode error";
       *decoded_length = -1;
       PacketBuffer::DeleteAllPackets(packet_list);
       break;
     }
-    if (*decoded_length > static_cast<int>(decoded_buffer_length_)) {
+    if (*decoded_length > rtc::checked_cast<int>(decoded_buffer_length_)) {
       // Guard against overflow.
       LOG(LS_WARNING) << "Decoded too much.";
       PacketBuffer::DeleteAllPackets(packet_list);
       return kDecodedTooMuch;
     }
     if (!packet_list->empty()) {
       packet = packet_list->front();
     } else {
       packet = NULL;
     }
@@ skipping 421 matching lines @@
   uint16_t prev_sequence_number = 0;
   bool next_packet_available = false;
 
   const RTPHeader* header = packet_buffer_->NextRtpHeader();
   assert(header);
   if (!header) {
     LOG(LS_ERROR) << "Packet buffer unexpectedly empty.";
     return -1;
   }
   uint32_t first_timestamp = header->timestamp;
-  int extracted_samples = 0;
+  size_t extracted_samples = 0;
 
   // Packet extraction loop.
   do {
     timestamp_ = header->timestamp;
     size_t discard_count = 0;
     Packet* packet = packet_buffer_->GetNextPacket(&discard_count);
     // |header| may be invalid after the |packet_buffer_| operation.
     header = NULL;
     if (!packet) {
       LOG(LS_ERROR) << "Should always be able to extract a packet here";
       assert(false);  // Should always be able to extract a packet here.
       return -1;
     }
     stats_.PacketsDiscarded(discard_count);
     stats_.StoreWaitingTime(packet->waiting_time->ElapsedMs());
-    assert(!packet->payload.empty());
+    RTC_DCHECK(!packet->empty());
     packet_list->push_back(packet);  // Store packet in list.
 
     if (first_packet) {
       first_packet = false;
       if (nack_enabled_) {
         RTC_DCHECK(nack_);
         // TODO(henrik.lundin): Should we update this for all decoded packets?
         nack_->UpdateLastDecodedPacket(packet->header.sequenceNumber,
                                        packet->header.timestamp);
       }
       prev_sequence_number = packet->header.sequenceNumber;
       prev_timestamp = packet->header.timestamp;
       prev_payload_type = packet->header.payloadType;
     }
 
     // Store number of extracted samples.
-    int packet_duration = 0;
-    AudioDecoder* decoder = decoder_database_->GetDecoder(
-        packet->header.payloadType);
-    if (decoder) {
-      if (packet->primary) {
-        packet_duration = decoder->PacketDuration(packet->payload.data(),
-                                                  packet->payload.size());
-      } else {
-        packet_duration = decoder->PacketDurationRedundant(
-            packet->payload.data(), packet->payload.size());
-        stats_.SecondaryDecodedSamples(packet_duration);
+    size_t packet_duration = 0;
+    if (packet->frame) {
+      packet_duration = packet->frame->Duration();
+      // TODO(ossu): Is this the correct way to track samples decoded from a
+      // redundant packet?
+      if (packet_duration > 0 && !packet->primary) {
+        stats_.SecondaryDecodedSamples(rtc::checked_cast<int>(packet_duration));
       }
     } else if (!decoder_database_->IsComfortNoise(packet->header.payloadType)) {
       LOG(LS_WARNING) << "Unknown payload type "
                       << static_cast<int>(packet->header.payloadType);
-      assert(false);
+      RTC_NOTREACHED();
     }
-    if (packet_duration <= 0) {
+
+    if (packet_duration == 0) {
       // Decoder did not return a packet duration. Assume that the packet
       // contains the same number of samples as the previous one.
-      packet_duration = rtc::checked_cast<int>(decoder_frame_length_);
+      packet_duration = decoder_frame_length_;
     }
     extracted_samples = packet->header.timestamp - first_timestamp +
         packet_duration;
 
     // Check what packet is available next.
     header = packet_buffer_->NextRtpHeader();
     next_packet_available = false;
     if (header && prev_payload_type == header->payloadType) {
       int16_t seq_no_diff = header->sequenceNumber - prev_sequence_number;
       size_t ts_diff = header->timestamp - prev_timestamp;
       if (seq_no_diff == 1 ||
           (seq_no_diff == 0 && ts_diff == decoder_frame_length_)) {
         // The next sequence number is available, or the next part of a packet
         // that was split into pieces upon insertion.
         next_packet_available = true;
       }
       prev_sequence_number = header->sequenceNumber;
     }
-  } while (extracted_samples < rtc::checked_cast<int>(required_samples) &&
-           next_packet_available);
+  } while (extracted_samples < required_samples && next_packet_available);
 
   if (extracted_samples > 0) {
     // Delete old packets only when we are going to decode something. Otherwise,
     // we could end up in the situation where we never decode anything, since
     // all incoming packets are considered too old but the buffer will also
     // never be flooded and flushed.
     packet_buffer_->DiscardAllOldPackets(timestamp_);
   }
 
-  return extracted_samples;
+  return rtc::checked_cast<int>(extracted_samples);
 }
 
 void NetEqImpl::UpdatePlcComponents(int fs_hz, size_t channels) {
   // Delete objects and create new ones.
   expand_.reset(expand_factory_->Create(background_noise_.get(),
                                         sync_buffer_.get(), &random_vector_,
                                         &stats_, fs_hz, channels));
   merge_.reset(new Merge(fs_hz, channels, expand_.get(), sync_buffer_.get()));
 }
 
@@ skipping 86 matching lines @@
   }
 }
 
 void NetEqImpl::CreateDecisionLogic() {
   decision_logic_.reset(DecisionLogic::Create(
       fs_hz_, output_size_samples_, playout_mode_, decoder_database_.get(),
       *packet_buffer_.get(), delay_manager_.get(), buffer_level_filter_.get(),
       tick_timer_.get()));
 }
 }  // namespace webrtc