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.
  */
 
@@ skipping 312 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(
+              &packet->payload, packet->header.timestamp, packet->primary);
+
+      // Reuse the packet if possible
+      if (results.size() == 1) {
+        auto& result = results[0];
+        RTC_DCHECK(result.frame);
+        packet->header.timestamp = result.timestamp;
+        packet->primary = result.primary;
+        packet->frame = std::move(result.frame);
+        parsed_packet_list.push_back(packet.release());
+      } else {
+        for (auto& result : results) {
+          // If you can't parse, return an empty list instead!

[kwiberg-webrtc, 2016/09/15 12:00:59]

Not sure I understand this comment.

[ossu, 2016/09/15 13:07:55]

Me neither.

+          RTC_DCHECK(result.frame);
+          std::unique_ptr<Packet> parsed_packet(new Packet);
+          parsed_packet->header = packet->header;
+          parsed_packet->header.timestamp = result.timestamp;
+          // TODO(ossu): Move from primary to some sort of priority level.
+          parsed_packet->primary = result.primary;
+          parsed_packet->frame = std::move(result.frame);
+          parsed_packet_list.push_back(parsed_packet.release());
+        }
+      }

[kwiberg-webrtc, 2016/09/15 12:00:59]

Can you eliminate the special case? E.g. by checking whether packet is non-null
in the beginning of the loop, and reusing it if so? That would let the
optimization trigger when there are multiple results.

[ossu, 2016/09/15 13:07:55]

Acknowledged.

+    }
+  }
+
   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 += 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_)) {
       // Guard against overflow.
       LOG(LS_WARNING) << "Decoded too much.";
       PacketBuffer::DeleteAllPackets(packet_list);
       return kDecodedTooMuch;
     }
@@ skipping 442 matching lines @@
     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());
+    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(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;
@@ skipping 116 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