path: root/webrtc/modules/audio_coding/acm2/initial_delay_manager.cc

/*
 *  Copyright (c) 2013 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/acm2/initial_delay_manager.h"

namespace webrtc {

namespace acm2 {

InitialDelayManager::InitialDelayManager(int initial_delay_ms,
                                         int late_packet_threshold)
    : last_packet_type_(kUndefinedPacket),
      last_receive_timestamp_(0),
      timestamp_step_(0),
      audio_payload_type_(kInvalidPayloadType),
      initial_delay_ms_(initial_delay_ms),
      buffered_audio_ms_(0),
      buffering_(true),
      playout_timestamp_(0),
      late_packet_threshold_(late_packet_threshold) {
  last_packet_rtp_info_.header.payloadType = kInvalidPayloadType;
  last_packet_rtp_info_.header.ssrc = 0;
  last_packet_rtp_info_.header.sequenceNumber = 0;
  last_packet_rtp_info_.header.timestamp = 0;
}

void InitialDelayManager::UpdateLastReceivedPacket(
    const WebRtcRTPHeader& rtp_info,
    uint32_t receive_timestamp,
    PacketType type,
    bool new_codec,
    int sample_rate_hz,
    SyncStream* sync_stream) {
  assert(sync_stream);

  // If payload of audio packets is changing |new_codec| has to be true.
  assert(!(!new_codec && type == kAudioPacket &&
         rtp_info.header.payloadType != audio_payload_type_));

  // Just shorthands.
  const RTPHeader* current_header = &rtp_info.header;
  RTPHeader* last_header = &last_packet_rtp_info_.header;

  // Don't do anything if getting DTMF. The chance of DTMF in applications where
  // initial delay is required is very low (we don't know of any). This avoids a
  // lot of corner cases. The effect of ignoring DTMF packet is minimal. Note
  // that DTMFs are inserted into NetEq just not accounted here.
  if (type == kAvtPacket ||
      (last_packet_type_ != kUndefinedPacket &&
      !IsNewerSequenceNumber(current_header->sequenceNumber,
                             last_header->sequenceNumber))) {
    sync_stream->num_sync_packets = 0;
    return;
  }

  // Either if it is a new packet or the first packet record and set variables.
  if (new_codec ||
      last_packet_rtp_info_.header.payloadType == kInvalidPayloadType) {
    timestamp_step_ = 0;
    if (type == kAudioPacket)
      audio_payload_type_ = rtp_info.header.payloadType;
    else
      audio_payload_type_ = kInvalidPayloadType;  // Invalid.

    RecordLastPacket(rtp_info, receive_timestamp, type);
    sync_stream->num_sync_packets = 0;
    buffered_audio_ms_ = 0;
    buffering_ = true;

    // If |buffering_| is set then |playout_timestamp_| should have correct
    // value.
    UpdatePlayoutTimestamp(*current_header, sample_rate_hz);
    return;
  }

  uint32_t timestamp_increase = current_header->timestamp -
      last_header->timestamp;

  // |timestamp_increase| is invalid if this is the first packet. The effect is
  // that |buffered_audio_ms_| is not increased.
  if (last_packet_type_ == kUndefinedPacket) {
    timestamp_increase = 0;
  }

  if (buffering_) {
    buffered_audio_ms_ += timestamp_increase * 1000 / sample_rate_hz;

    // A timestamp that reflects the initial delay, while buffering.
    UpdatePlayoutTimestamp(*current_header, sample_rate_hz);

    if (buffered_audio_ms_ >= initial_delay_ms_)
      buffering_ = false;
  }

  if (current_header->sequenceNumber == last_header->sequenceNumber + 1) {
    // Two consecutive audio packets, the previous packet-type is audio, so we
    // can update |timestamp_step_|.
    if (last_packet_type_ == kAudioPacket)
      timestamp_step_ = timestamp_increase;
    RecordLastPacket(rtp_info, receive_timestamp, type);
    sync_stream->num_sync_packets = 0;
    return;
  }

  uint16_t packet_gap = current_header->sequenceNumber -
      last_header->sequenceNumber - 1;

  // For smooth transitions leave a gap between audio and sync packets.
  sync_stream->num_sync_packets = last_packet_type_ == kSyncPacket ?
      packet_gap - 1 : packet_gap - 2;

  // Do nothing if we haven't received any audio packet.
  if (sync_stream->num_sync_packets > 0 &&
      audio_payload_type_ != kInvalidPayloadType) {
    if (timestamp_step_ == 0) {
      // Make an estimate for |timestamp_step_| if it is not updated, yet.
      assert(packet_gap > 0);
      timestamp_step_ = timestamp_increase / (packet_gap + 1);
    }
    sync_stream->timestamp_step = timestamp_step_;

    // Build the first sync-packet based on the current received packet.
    memcpy(&sync_stream->rtp_info, &rtp_info, sizeof(rtp_info));
    sync_stream->rtp_info.header.payloadType = audio_payload_type_;

    uint16_t sequence_number_update = sync_stream->num_sync_packets + 1;
    uint32_t timestamp_update = timestamp_step_ * sequence_number_update;

    // Rewind sequence number and timestamps. This will give a more accurate
    // description of the missing packets.
    //
    // Note that we leave a gap between the last packet in sync-stream and the
    // current received packet, so it should be compensated for in the following
    // computation of timestamps and sequence number.
    sync_stream->rtp_info.header.sequenceNumber -= sequence_number_update;
    sync_stream->receive_timestamp = receive_timestamp - timestamp_update;
    sync_stream->rtp_info.header.timestamp -= timestamp_update;
    sync_stream->rtp_info.header.payloadType = audio_payload_type_;
  } else {
    sync_stream->num_sync_packets = 0;
  }

  RecordLastPacket(rtp_info, receive_timestamp, type);
  return;
}

void InitialDelayManager::RecordLastPacket(const WebRtcRTPHeader& rtp_info,
                                           uint32_t receive_timestamp,
                                           PacketType type) {
  last_packet_type_ = type;
  last_receive_timestamp_ = receive_timestamp;
  memcpy(&last_packet_rtp_info_, &rtp_info, sizeof(rtp_info));
}

void InitialDelayManager::LatePackets(
    uint32_t timestamp_now, SyncStream* sync_stream) {
  assert(sync_stream);
  sync_stream->num_sync_packets = 0;

  // If there is no estimate of timestamp increment, |timestamp_step_|, then
  // we cannot estimate the number of late packets.
  // If the last packet has been CNG, estimating late packets is not meaningful,
  // as a CNG packet is on unknown length.
  // We can set a higher threshold if the last packet is CNG and continue
  // execution, but this is how ACM1 code was written.
  if (timestamp_step_ <= 0 ||
      last_packet_type_ == kCngPacket ||
      last_packet_type_ == kUndefinedPacket ||
      audio_payload_type_ == kInvalidPayloadType)  // No audio packet received.
    return;

  int num_late_packets = (timestamp_now - last_receive_timestamp_) /
      timestamp_step_;

  if (num_late_packets < late_packet_threshold_)
    return;

  int sync_offset = 1;  // One gap at the end of the sync-stream.
  if (last_packet_type_ != kSyncPacket) {
    ++sync_offset;  // One more gap at the beginning of the sync-stream.
    --num_late_packets;
  }
  uint32_t timestamp_update = sync_offset * timestamp_step_;

  sync_stream->num_sync_packets = num_late_packets;
  if (num_late_packets == 0)
    return;

  // Build the first sync-packet in the sync-stream.
  memcpy(&sync_stream->rtp_info, &last_packet_rtp_info_,
         sizeof(last_packet_rtp_info_));

  // Increase sequence number and timestamps.
  sync_stream->rtp_info.header.sequenceNumber += sync_offset;
  sync_stream->rtp_info.header.timestamp += timestamp_update;
  sync_stream->receive_timestamp = last_receive_timestamp_ + timestamp_update;
  sync_stream->timestamp_step = timestamp_step_;

  // Sync-packets have audio payload-type.
  sync_stream->rtp_info.header.payloadType = audio_payload_type_;

  uint16_t sequence_number_update = num_late_packets + sync_offset - 1;
  timestamp_update = sequence_number_update * timestamp_step_;

  // Fake the last RTP, assuming the caller will inject the whole sync-stream.
  last_packet_rtp_info_.header.timestamp += timestamp_update;
  last_packet_rtp_info_.header.sequenceNumber += sequence_number_update;
  last_packet_rtp_info_.header.payloadType = audio_payload_type_;
  last_receive_timestamp_ += timestamp_update;

  last_packet_type_ = kSyncPacket;
  return;
}

bool InitialDelayManager::GetPlayoutTimestamp(uint32_t* playout_timestamp) {
  if (!buffering_) {
    return false;
  }
  *playout_timestamp = playout_timestamp_;
  return true;
}

void InitialDelayManager::DisableBuffering() {
  buffering_ = false;
}

void InitialDelayManager::UpdatePlayoutTimestamp(
    const RTPHeader& current_header, int sample_rate_hz) {
  playout_timestamp_ = current_header.timestamp - static_cast<uint32_t>(
      initial_delay_ms_ * sample_rate_hz / 1000);
}

}  // namespace acm2

}  // namespace webrtc