// Copyright 2022 The Cobalt Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "starboard/shared/libfdkaac/fdk_aac_audio_decoder.h"

#include "starboard/common/log.h"
#include "starboard/common/string.h"
#include "starboard/shared/libfdkaac/libfdkaac_library_loader.h"

namespace starboard {
namespace shared {
namespace libfdkaac {

FdkAacAudioDecoder::FdkAacAudioDecoder() {
  static_assert(sizeof(INT_PCM) == sizeof(int16_t),
                "sizeof(INT_PCM) has to be the same as sizeof(int16_t).");
  InitializeCodec();
}

FdkAacAudioDecoder::~FdkAacAudioDecoder() {
  TeardownCodec();
}

void FdkAacAudioDecoder::Initialize(const OutputCB& output_cb,
                                    const ErrorCB& error_cb) {
  SB_DCHECK(BelongsToCurrentThread());
  SB_DCHECK(output_cb);
  SB_DCHECK(!output_cb_);
  SB_DCHECK(error_cb);
  SB_DCHECK(!error_cb_);

  output_cb_ = output_cb;
  error_cb_ = error_cb;
}

void FdkAacAudioDecoder::Decode(const InputBuffers& input_buffers,
                                const ConsumedCB& consumed_cb) {
  SB_DCHECK(BelongsToCurrentThread());
  SB_DCHECK(input_buffers.size() == 1);
  SB_DCHECK(input_buffers[0]);
  SB_DCHECK(output_cb_);
  SB_DCHECK(decoder_ != NULL);

  if (stream_ended_) {
    SB_LOG(ERROR) << "Decode() is called after WriteEndOfStream() is called.";
    return;
  }
  const auto& input_buffer = input_buffers[0];
  if (!WriteToFdkDecoder(input_buffer)) {
    return;
  }

  decoding_input_buffers_.push(input_buffer);
  Schedule(consumed_cb);
  ReadFromFdkDecoder(kDecodeModeDoNotFlush);
}

scoped_refptr<FdkAacAudioDecoder::DecodedAudio> FdkAacAudioDecoder::Read(
    int* samples_per_second) {
  SB_DCHECK(BelongsToCurrentThread());
  SB_DCHECK(output_cb_);
  SB_DCHECK(!decoded_audios_.empty());

  scoped_refptr<DecodedAudio> result;
  if (!decoded_audios_.empty()) {
    result = decoded_audios_.front();
    decoded_audios_.pop();
  }
  *samples_per_second = samples_per_second_;
  return result;
}

void FdkAacAudioDecoder::Reset() {
  SB_DCHECK(decoder_ != NULL);
  SB_DCHECK(BelongsToCurrentThread());

  TeardownCodec();
  InitializeCodec();

  stream_ended_ = false;
  decoded_audios_ = std::queue<scoped_refptr<DecodedAudio>>();  // clear
  partially_decoded_audio_ = nullptr;
  partially_decoded_audio_data_in_bytes_ = 0;
  decoding_input_buffers_ = decltype(decoding_input_buffers_)();  // clear
  // Clean up stream information and deduced results.
  has_stream_info_ = false;
  num_channels_ = 0;
  samples_per_second_ = 0;
  decoded_audio_size_in_bytes_ = 0;
  audio_data_to_discard_in_bytes_ = 0;
  CancelPendingJobs();
}

void FdkAacAudioDecoder::WriteEndOfStream() {
  SB_DCHECK(decoder_ != NULL);
  SB_DCHECK(BelongsToCurrentThread());
  SB_DCHECK(output_cb_);

  while (!decoding_input_buffers_.empty()) {
    if (!ReadFromFdkDecoder(kDecodeModeFlush)) {
      return;
    }
  }
  stream_ended_ = true;
  // Put EOS into the queue.
  decoded_audios_.push(new DecodedAudio);
  Schedule(output_cb_);
}

void FdkAacAudioDecoder::InitializeCodec() {
  SB_DCHECK(decoder_ == NULL);
  decoder_ = aacDecoder_Open(TT_MP4_ADTS, 1);
  SB_DCHECK(decoder_ != NULL);

  // Set AAC_PCM_MAX_OUTPUT_CHANNELS to 0 to disable downmixing feature.
  // It makes the decoder output contain the same number of channels as the
  // encoded bitstream.
  AAC_DECODER_ERROR error =
      aacDecoder_SetParam(decoder_, AAC_PCM_MAX_OUTPUT_CHANNELS, 0);
  SB_DCHECK(error == AAC_DEC_OK);
}

void FdkAacAudioDecoder::TeardownCodec() {
  if (decoder_) {
    aacDecoder_Close(decoder_);
    decoder_ = nullptr;
  }
}

bool FdkAacAudioDecoder::WriteToFdkDecoder(
    const scoped_refptr<InputBuffer>& input_buffer) {
  SB_DCHECK(BelongsToCurrentThread());
  SB_DCHECK(input_buffer);

  unsigned char* data = const_cast<unsigned char*>(input_buffer->data());
  const unsigned int data_size_in_bytes = input_buffer->size();
  unsigned int left_to_decode_in_bytes = input_buffer->size();
  AAC_DECODER_ERROR error = aacDecoder_Fill(
      decoder_, &data, &data_size_in_bytes, &left_to_decode_in_bytes);
  if (error != AAC_DEC_OK) {
    SB_LOG(ERROR) << "aacDecoder_Fill() failed with result : " << error;
    error_cb_(kSbPlayerErrorDecode,
              FormatString("aacDecoder_Fill() failed with result %d.", error));
    return false;
  }

  // Returned |left_to_decode_in_bytes| should always be 0 as DecodeFrame() will
  // be called immediately on the same thread.
  SB_DCHECK(left_to_decode_in_bytes == 0);
  return true;
}

bool FdkAacAudioDecoder::ReadFromFdkDecoder(DecodeMode mode) {
  SB_DCHECK(mode == kDecodeModeFlush || mode == kDecodeModeDoNotFlush);
  int flags = mode == kDecodeModeFlush ? AACDEC_FLUSH : 0;

  AAC_DECODER_ERROR error = aacDecoder_DecodeFrame(
      decoder_, reinterpret_cast<INT_PCM*>(output_buffer_),
      kMaxOutputBufferSizeInBytes / sizeof(INT_PCM), flags);
  if (error != AAC_DEC_OK) {
    error_cb_(
        kSbPlayerErrorDecode,
        FormatString("aacDecoder_DecodeFrame() failed with result %d.", error));
    return false;
  }

  TryToUpdateStreamInfo();
  SB_DCHECK(has_stream_info_);
  if (audio_data_to_discard_in_bytes_ >= decoded_audio_size_in_bytes_) {
    // Discard all decoded data in |output_buffer_|.
    audio_data_to_discard_in_bytes_ -= decoded_audio_size_in_bytes_;
    return true;
  }

  // Discard the initial |audio_data_to_discard_in_bytes_| in |output_buffer_|.
  int offset_in_bytes = audio_data_to_discard_in_bytes_;
  audio_data_to_discard_in_bytes_ = 0;
  TryToOutputDecodedAudio(output_buffer_ + offset_in_bytes,
                          decoded_audio_size_in_bytes_ - offset_in_bytes);
  return true;
}

void FdkAacAudioDecoder::TryToUpdateStreamInfo() {
  if (has_stream_info_) {
    return;
  }
  CStreamInfo* stream_info = aacDecoder_GetStreamInfo(decoder_);
  SB_DCHECK(stream_info);

  num_channels_ = stream_info->numChannels;
  samples_per_second_ = stream_info->sampleRate;
  decoded_audio_size_in_bytes_ =
      sizeof(int16_t) * stream_info->frameSize * num_channels_;
  audio_data_to_discard_in_bytes_ =
      sizeof(int16_t) * stream_info->outputDelay * num_channels_;
  has_stream_info_ = true;
}

void FdkAacAudioDecoder::TryToOutputDecodedAudio(const uint8_t* data,
                                                 int size_in_bytes) {
  SB_DCHECK(BelongsToCurrentThread());
  SB_DCHECK(has_stream_info_);

  while (size_in_bytes > 0 && !decoding_input_buffers_.empty()) {
    if (!partially_decoded_audio_) {
      SB_DCHECK(partially_decoded_audio_data_in_bytes_ == 0);
      partially_decoded_audio_ = new DecodedAudio(
          num_channels_, kSbMediaAudioSampleTypeInt16Deprecated,
          kSbMediaAudioFrameStorageTypeInterleaved,
          decoding_input_buffers_.front()->timestamp(),
          decoded_audio_size_in_bytes_);
    }
    int freespace =
        static_cast<int>(partially_decoded_audio_->size_in_bytes()) -
        partially_decoded_audio_data_in_bytes_;
    if (size_in_bytes >= freespace) {
      memcpy(partially_decoded_audio_->data() +
                 partially_decoded_audio_data_in_bytes_,
             data, freespace);
      data += freespace;
      size_in_bytes -= freespace;
      SB_DCHECK(decoding_input_buffers_.front()->timestamp() ==
                partially_decoded_audio_->timestamp());

      const auto& sample_info =
          decoding_input_buffers_.front()->audio_sample_info();
      partially_decoded_audio_->AdjustForDiscardedDurations(
          samples_per_second_, sample_info.discarded_duration_from_front,
          sample_info.discarded_duration_from_back);
      decoding_input_buffers_.pop();
      decoded_audios_.push(partially_decoded_audio_);
      Schedule(output_cb_);
      partially_decoded_audio_ = nullptr;
      partially_decoded_audio_data_in_bytes_ = 0;
      continue;
    }
    memcpy(partially_decoded_audio_->data() +
               partially_decoded_audio_data_in_bytes_,
           data, size_in_bytes);
    partially_decoded_audio_data_in_bytes_ += size_in_bytes;
    return;
  }
}

}  // namespace libfdkaac
}  // namespace shared
}  // namespace starboard