/*
 *  Copyright (c) 2014 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 "modules/audio_coding/codecs/red/audio_encoder_copy_red.h"

#include <string.h>

#include <utility>
#include <vector>

#include "rtc_base/byte_order.h"
#include "rtc_base/checks.h"

namespace webrtc {
// RED packets must be less than 1024 bytes to fit the 10 bit block length.
static constexpr const int kRedMaxPacketSize = 1 << 10;
// The typical MTU is 1200 bytes.
static constexpr const size_t kAudioMaxRtpPacketLen = 1200;

AudioEncoderCopyRed::Config::Config() = default;
AudioEncoderCopyRed::Config::Config(Config&&) = default;
AudioEncoderCopyRed::Config::~Config() = default;

AudioEncoderCopyRed::AudioEncoderCopyRed(Config&& config)
    : speech_encoder_(std::move(config.speech_encoder)),
      max_packet_length_(kAudioMaxRtpPacketLen),
      red_payload_type_(config.payload_type) {
  RTC_CHECK(speech_encoder_) << "Speech encoder not provided.";
}

AudioEncoderCopyRed::~AudioEncoderCopyRed() = default;

int AudioEncoderCopyRed::SampleRateHz() const {
  return speech_encoder_->SampleRateHz();
}

size_t AudioEncoderCopyRed::NumChannels() const {
  return speech_encoder_->NumChannels();
}

int AudioEncoderCopyRed::RtpTimestampRateHz() const {
  return speech_encoder_->RtpTimestampRateHz();
}

size_t AudioEncoderCopyRed::Num10MsFramesInNextPacket() const {
  return speech_encoder_->Num10MsFramesInNextPacket();
}

size_t AudioEncoderCopyRed::Max10MsFramesInAPacket() const {
  return speech_encoder_->Max10MsFramesInAPacket();
}

int AudioEncoderCopyRed::GetTargetBitrate() const {
  return speech_encoder_->GetTargetBitrate();
}

size_t AudioEncoderCopyRed::CalculateHeaderLength(size_t encoded_bytes) const {
  size_t header_size = 1;
  size_t bytes_available = max_packet_length_ - encoded_bytes;
  if (secondary_info_.encoded_bytes > 0 &&
      secondary_info_.encoded_bytes < bytes_available) {
    header_size += 4;
    bytes_available -= secondary_info_.encoded_bytes;
  }
  if (tertiary_info_.encoded_bytes > 0 &&
      tertiary_info_.encoded_bytes < bytes_available) {
    header_size += 4;
  }
  return header_size > 1 ? header_size : 0;
}

AudioEncoder::EncodedInfo AudioEncoderCopyRed::EncodeImpl(
    uint32_t rtp_timestamp,
    rtc::ArrayView<const int16_t> audio,
    rtc::Buffer* encoded) {
  rtc::Buffer primary_encoded;
  EncodedInfo info =
      speech_encoder_->Encode(rtp_timestamp, audio, &primary_encoded);
  RTC_CHECK(info.redundant.empty()) << "Cannot use nested redundant encoders.";
  RTC_DCHECK_EQ(primary_encoded.size(), info.encoded_bytes);

  if (info.encoded_bytes == 0 || info.encoded_bytes > kRedMaxPacketSize) {
    return info;
  }
  RTC_DCHECK_GT(max_packet_length_, info.encoded_bytes);

  // Allocate room for RFC 2198 header if there is redundant data.
  // Otherwise this will send the primary payload type without
  // wrapping in RED.
  const size_t header_length_bytes = CalculateHeaderLength(info.encoded_bytes);
  encoded->SetSize(header_length_bytes);

  size_t header_offset = 0;
  size_t bytes_available = max_packet_length_ - info.encoded_bytes;
  if (tertiary_info_.encoded_bytes > 0 &&
      tertiary_info_.encoded_bytes + secondary_info_.encoded_bytes <
          bytes_available) {
    encoded->AppendData(tertiary_encoded_);

    const uint32_t timestamp_delta =
        info.encoded_timestamp - tertiary_info_.encoded_timestamp;

    encoded->data()[header_offset] = tertiary_info_.payload_type | 0x80;
    rtc::SetBE16(static_cast<uint8_t*>(encoded->data()) + header_offset + 1,
                 (timestamp_delta << 2) | (tertiary_info_.encoded_bytes >> 8));
    encoded->data()[header_offset + 3] = tertiary_info_.encoded_bytes & 0xff;
    header_offset += 4;
    bytes_available -= tertiary_info_.encoded_bytes;
  }

  if (secondary_info_.encoded_bytes > 0 &&
      secondary_info_.encoded_bytes < bytes_available) {
    encoded->AppendData(secondary_encoded_);

    const uint32_t timestamp_delta =
        info.encoded_timestamp - secondary_info_.encoded_timestamp;

    encoded->data()[header_offset] = secondary_info_.payload_type | 0x80;
    rtc::SetBE16(static_cast<uint8_t*>(encoded->data()) + header_offset + 1,
                 (timestamp_delta << 2) | (secondary_info_.encoded_bytes >> 8));
    encoded->data()[header_offset + 3] = secondary_info_.encoded_bytes & 0xff;
    header_offset += 4;
    bytes_available -= secondary_info_.encoded_bytes;
  }

  encoded->AppendData(primary_encoded);
  if (header_length_bytes > 0) {
    RTC_DCHECK_EQ(header_offset, header_length_bytes - 1);
    encoded->data()[header_offset] = info.payload_type;
  }

  // |info| will be implicitly cast to an EncodedInfoLeaf struct, effectively
  // discarding the (empty) vector of redundant information. This is
  // intentional.
  info.redundant.push_back(info);
  RTC_DCHECK_EQ(info.redundant.size(), 1);
  RTC_DCHECK_EQ(info.speech, info.redundant[0].speech);
  if (secondary_info_.encoded_bytes > 0) {
    info.redundant.push_back(secondary_info_);
    RTC_DCHECK_EQ(info.redundant.size(), 2);
  }
  if (tertiary_info_.encoded_bytes > 0) {
    info.redundant.push_back(tertiary_info_);
    RTC_DCHECK_EQ(info.redundant.size(),
                  2 + (secondary_info_.encoded_bytes > 0 ? 1 : 0));
  }

  // Save secondary to tertiary.
  tertiary_encoded_.SetData(secondary_encoded_);
  tertiary_info_ = secondary_info_;

  // Save primary to secondary.
  secondary_encoded_.SetData(primary_encoded);
  secondary_info_ = info;

  // Update main EncodedInfo.
  if (header_length_bytes > 0) {
    info.payload_type = red_payload_type_;
  }
  info.encoded_bytes = encoded->size();
  return info;
}

void AudioEncoderCopyRed::Reset() {
  speech_encoder_->Reset();
  secondary_encoded_.Clear();
  secondary_info_.encoded_bytes = 0;
}

bool AudioEncoderCopyRed::SetFec(bool enable) {
  return speech_encoder_->SetFec(enable);
}

bool AudioEncoderCopyRed::SetDtx(bool enable) {
  return speech_encoder_->SetDtx(enable);
}

bool AudioEncoderCopyRed::SetApplication(Application application) {
  return speech_encoder_->SetApplication(application);
}

void AudioEncoderCopyRed::SetMaxPlaybackRate(int frequency_hz) {
  speech_encoder_->SetMaxPlaybackRate(frequency_hz);
}

rtc::ArrayView<std::unique_ptr<AudioEncoder>>
AudioEncoderCopyRed::ReclaimContainedEncoders() {
  return rtc::ArrayView<std::unique_ptr<AudioEncoder>>(&speech_encoder_, 1);
}

void AudioEncoderCopyRed::OnReceivedUplinkPacketLossFraction(
    float uplink_packet_loss_fraction) {
  speech_encoder_->OnReceivedUplinkPacketLossFraction(
      uplink_packet_loss_fraction);
}

void AudioEncoderCopyRed::OnReceivedUplinkBandwidth(
    int target_audio_bitrate_bps,
    absl::optional<int64_t> bwe_period_ms) {
  speech_encoder_->OnReceivedUplinkBandwidth(target_audio_bitrate_bps,
                                             bwe_period_ms);
}

absl::optional<std::pair<TimeDelta, TimeDelta>>
AudioEncoderCopyRed::GetFrameLengthRange() const {
  return speech_encoder_->GetFrameLengthRange();
}

void AudioEncoderCopyRed::OnReceivedOverhead(size_t overhead_bytes_per_packet) {
  max_packet_length_ = kAudioMaxRtpPacketLen - overhead_bytes_per_packet;
  return speech_encoder_->OnReceivedOverhead(overhead_bytes_per_packet);
}

}  // namespace webrtc