Removed sync packet support from NetEq.

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 119 matching lines @@
 
 NetEqImpl::~NetEqImpl() = default;
 
 int NetEqImpl::InsertPacket(const WebRtcRTPHeader& rtp_header,
                             rtc::ArrayView<const uint8_t> payload,
                             uint32_t receive_timestamp) {
   rtc::MsanCheckInitialized(payload);
   TRACE_EVENT0("webrtc", "NetEqImpl::InsertPacket");
   rtc::CritScope lock(&crit_sect_);
   int error =
-      InsertPacketInternal(rtp_header, payload, receive_timestamp, false);
+      InsertPacketInternal(rtp_header, payload, receive_timestamp);
   if (error != 0) {
     error_code_ = error;
     return kFail;
-  }
-  return kOK;
-}
-
-int NetEqImpl::InsertSyncPacket(const WebRtcRTPHeader& rtp_header,
-                                uint32_t receive_timestamp) {
-  rtc::CritScope lock(&crit_sect_);
-  const uint8_t kSyncPayload[] = { 's', 'y', 'n', 'c' };
-  int error =
-      InsertPacketInternal(rtp_header, kSyncPayload, receive_timestamp, true);
-
-  if (error != 0) {
-    error_code_ = error;
-    return kFail;
   }
   return kOK;
 }
 
 namespace {
 void SetAudioFrameActivityAndType(bool vad_enabled,
                                   NetEqImpl::OutputType type,
                                   AudioFrame::VADActivity last_vad_activity,
                                   AudioFrame* audio_frame) {
   switch (type) {
@@ skipping 347 matching lines @@
 
 Operations NetEqImpl::last_operation_for_test() const {
   rtc::CritScope lock(&crit_sect_);
   return last_operation_;
 }
 
 // Methods below this line are private.
 
 int NetEqImpl::InsertPacketInternal(const WebRtcRTPHeader& rtp_header,
                                     rtc::ArrayView<const uint8_t> payload,
-                                    uint32_t receive_timestamp,
-                                    bool is_sync_packet) {
+                                    uint32_t receive_timestamp) {
   if (payload.empty()) {
     LOG_F(LS_ERROR) << "payload is empty";
     return kInvalidPointer;
   }
-  // Sanity checks for sync-packets.
-  if (is_sync_packet) {
-    if (decoder_database_->IsDtmf(rtp_header.header.payloadType) ||
-        decoder_database_->IsRed(rtp_header.header.payloadType) ||
-        decoder_database_->IsComfortNoise(rtp_header.header.payloadType)) {
-      LOG_F(LS_ERROR) << "Sync-packet with an unacceptable payload type "
-                      << static_cast<int>(rtp_header.header.payloadType);
-      return kSyncPacketNotAccepted;
-    }
-    if (first_packet_ || !current_rtp_payload_type_ ||
-        rtp_header.header.payloadType != *current_rtp_payload_type_ ||
-        rtp_header.header.ssrc != ssrc_) {
-      // Even if |current_rtp_payload_type_| is empty, sync-packet isn't
-      // accepted.
-      LOG_F(LS_ERROR)
-          << "Changing codec, SSRC or first packet with sync-packet.";
-      return kSyncPacketNotAccepted;
-    }
-  }
+
   PacketList packet_list;
   RTPHeader main_header;
   {
     // Convert to Packet.
     // Create |packet| within this separate scope, since it should not be used
     // directly once it's been inserted in the packet list. This way, |packet|
     // is not defined outside of this block.
     Packet* packet = new Packet;
     packet->header.markerBit = false;
     packet->header.payloadType = rtp_header.header.payloadType;
     packet->header.sequenceNumber = rtp_header.header.sequenceNumber;
     packet->header.timestamp = rtp_header.header.timestamp;
     packet->header.ssrc = rtp_header.header.ssrc;
     packet->header.numCSRCs = 0;
     packet->payload.SetData(payload.data(), payload.size());
     packet->primary = true;
     // Waiting time will be set upon inserting the packet in the buffer.
     RTC_DCHECK(!packet->waiting_time);
-    packet->sync_packet = is_sync_packet;
     // Insert packet in a packet list.
     packet_list.push_back(packet);
     // Save main payloads header for later.
     memcpy(&main_header, &packet->header, sizeof(main_header));
   }
 
   bool update_sample_rate_and_channels = false;
   // Reinitialize NetEq if it's needed (changed SSRC or first call).
   if ((main_header.ssrc != ssrc_) || first_packet_) {
     // Note: |first_packet_| will be cleared further down in this method, once
@@ skipping 15 matching lines @@
     timestamp_ = main_header.timestamp;
 
     // Reset timestamp scaling.
     timestamp_scaler_->Reset();
 
     // Trigger an update of sampling rate and the number of channels.
     update_sample_rate_and_channels = true;
   }
 
   // Update RTCP statistics, only for regular packets.
-  if (!is_sync_packet)
-    rtcp_.Update(main_header, receive_timestamp);
+  rtcp_.Update(main_header, receive_timestamp);
 
   // Check for RED payload type, and separate payloads into several packets.
   if (decoder_database_->IsRed(main_header.payloadType)) {
-    assert(!is_sync_packet);  // We had a sanity check for this.
     if (payload_splitter_->SplitRed(&packet_list) != PayloadSplitter::kOK) {
       PacketBuffer::DeleteAllPackets(&packet_list);
       return kRedundancySplitError;
     }
     // Only accept a few RED payloads of the same type as the main data,
     // DTMF events and CNG.
     payload_splitter_->CheckRedPayloads(&packet_list, *decoder_database_);
     // Update the stored main payload header since the main payload has now
     // changed.
     memcpy(&main_header, &packet_list.front()->header, sizeof(main_header));
@@ skipping 10 matching lines @@
   timestamp_scaler_->ToInternal(&packet_list);
 
   // Process DTMF payloads. Cycle through the list of packets, and pick out any
   // DTMF payloads found.
   PacketList::iterator it = packet_list.begin();
   while (it != packet_list.end()) {
     Packet* current_packet = (*it);
     assert(current_packet);
     assert(!current_packet->payload.empty());
     if (decoder_database_->IsDtmf(current_packet->header.payloadType)) {
-      assert(!current_packet->sync_packet);  // We had a sanity check for this.
       DtmfEvent event;
       int ret = DtmfBuffer::ParseEvent(current_packet->header.timestamp,
                                        current_packet->payload.data(),
                                        current_packet->payload.size(), &event);
       if (ret != DtmfBuffer::kOK) {
         PacketBuffer::DeleteAllPackets(&packet_list);
         return kDtmfParsingError;
       }
       if (dtmf_buffer_->InsertEvent(event) != DtmfBuffer::kOK) {
         PacketBuffer::DeleteAllPackets(&packet_list);
@@ skipping 12 matching lines @@
     PacketBuffer::DeleteAllPackets(&packet_list);
     switch (ret) {
       case PayloadSplitter::kUnknownPayloadType:
         return kUnknownRtpPayloadType;
       default:
         return kOtherError;
     }
   }
 
   // Split payloads into smaller chunks. This also verifies that all payloads
-  // are of a known payload type. SplitAudio() method is protected against
-  // sync-packets.
+  // are of a known payload type.
   ret = payload_splitter_->SplitAudio(&packet_list, *decoder_database_);
   if (ret != PayloadSplitter::kOK) {
     PacketBuffer::DeleteAllPackets(&packet_list);
     switch (ret) {
       case PayloadSplitter::kUnknownPayloadType:
         return kUnknownRtpPayloadType;
       case PayloadSplitter::kFrameSplitError:
         return kFrameSplitError;
       default:
         return kOtherError;
     }
   }
 
-  // Update bandwidth estimate, if the packet is not sync-packet nor comfort
-  // noise.
-  if (!packet_list.empty() && !packet_list.front()->sync_packet &&
+  // Update bandwidth estimate, if the packet is not comfort noise.
+  if (!packet_list.empty() &&
       !decoder_database_->IsComfortNoise(main_header.payloadType)) {
     // The list can be empty here if we got nothing but DTMF payloads.
     AudioDecoder* decoder =
         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,
@@ skipping 754 matching lines @@
     // 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->sync_packet) {
-      // Decode to silence with the same frame size as the last decode.
-      memset(&decoded_buffer_[*decoded_length], 0,
-             decoder_frame_length_ * decoder->Channels() *
-                 sizeof(decoded_buffer_[0]));
-      decode_length = rtc::checked_cast<int>(decoder_frame_length_);
-    } else if (!packet->primary) {
+    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);
@@ skipping 485 matching lines @@
       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->sync_packet) {
-        packet_duration = rtc::checked_cast<int>(decoder_frame_length_);
+      if (packet->primary) {
+        packet_duration = decoder->PacketDuration(packet->payload.data(),
+                                                  packet->payload.size());
       } else {
-        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);
-        }
+        packet_duration = decoder->PacketDurationRedundant(
+            packet->payload.data(), packet->payload.size());
+        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);
     }
     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_);
@@ skipping 126 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