/*
 * Copyright 2014 Google Inc. 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 "media/filters/shell_raw_audio_decoder_linux.h"

#include <memory.h>

#include <list>

#include "base/bind.h"
#include "base/logging.h"
#include "media/base/audio_decoder_config.h"
#include "media/base/audio_timestamp_helper.h"
#include "media/base/decoder_buffer_pool.h"
#include "media/filters/shell_ffmpeg.h"
#include "media/mp4/aac.h"

namespace media {

namespace {

const size_t kSampleSizeInBytes = sizeof(float);

struct QueuedAudioBuffer {
  //  AudioDecoder::Status status;  // status is used to represent decode errors
  scoped_refptr<DecoderBuffer> buffer;
};

bool IsEndOfStream(int result,
                   int decoded_size,
                   scoped_refptr<DecoderBuffer> buffer) {
  return result == 0 && decoded_size == 0 && buffer->IsEndOfStream();
}

void ResampleToInterleavedFloat(int source_sample_format,
                                int channel_layout,
                                int sample_rate,
                                int samples_per_channel,
                                uint8** input_buffer,
                                uint8* output_buffer) {
  AVAudioResampleContext* context = avresample_alloc_context();
  DCHECK(context);

  av_opt_set_int(context, "in_channel_layout", channel_layout, 0);
  av_opt_set_int(context, "out_channel_layout", channel_layout, 0);
  av_opt_set_int(context, "in_sample_rate", sample_rate, 0);
  av_opt_set_int(context, "out_sample_rate", sample_rate, 0);
  av_opt_set_int(context, "in_sample_fmt", source_sample_format, 0);
  av_opt_set_int(context, "out_sample_fmt", AV_SAMPLE_FMT_FLT, 0);
  av_opt_set_int(context, "internal_sample_fmt", source_sample_format, 0);

  int result = avresample_open(context);
  DCHECK(!result);

  int samples_resampled =
      avresample_convert(context, &output_buffer, 1024, samples_per_channel,
                         input_buffer, 0, samples_per_channel);
  DCHECK_EQ(samples_resampled, samples_per_channel);

  avresample_close(context);
  av_free(context);
}

class ShellRawAudioDecoderLinux : public ShellRawAudioDecoder {
 public:
  ShellRawAudioDecoderLinux();
  ~ShellRawAudioDecoderLinux() OVERRIDE;

  int GetBytesPerSample() const OVERRIDE { return kSampleSizeInBytes; }
  // When the input buffer is not NULL, it can be a normal buffer or an EOS
  // buffer. In this case the function will return the decoded buffer if there
  // is any.
  // The input buffer can be NULL, in this case the function will return a
  // queued buffer if there is any or return NULL if there is no queued buffer.
  void Decode(const scoped_refptr<DecoderBuffer>& buffer,
              const DecodeCB& decoder_cb) OVERRIDE;
  bool Flush() OVERRIDE;
  bool UpdateConfig(const AudioDecoderConfig& config) OVERRIDE;

 private:
  void ReleaseResource();
  void ResetTimestampState();
  void RunDecodeLoop(const scoped_refptr<DecoderBuffer>& input,
                     bool skip_eos_append);

  DecoderBufferPool decoder_buffer_pool_;

  AVCodecContext* codec_context_;
  AVFrame* av_frame_;

  // Decoded audio format.
  int bits_per_channel_;
  ChannelLayout channel_layout_;
  int samples_per_second_;

  // Used for computing output timestamps.
  scoped_ptr<AudioTimestampHelper> output_timestamp_helper_;
  int bytes_per_frame_;
  base::TimeDelta last_input_timestamp_;

  // Since multiple frames may be decoded from the same packet we need to
  // queue them up and hand them out as we receive Read() calls.
  std::list<QueuedAudioBuffer> queued_audio_;

  DISALLOW_COPY_AND_ASSIGN(ShellRawAudioDecoderLinux);
};

ShellRawAudioDecoderLinux::ShellRawAudioDecoderLinux()
    : decoder_buffer_pool_(GetBytesPerSample()),
      codec_context_(NULL),
      av_frame_(NULL),
      bits_per_channel_(0),
      channel_layout_(CHANNEL_LAYOUT_NONE),
      samples_per_second_(0),
      bytes_per_frame_(0),
      last_input_timestamp_(kNoTimestamp()) {
  EnsureFfmpegInitialized();
}

ShellRawAudioDecoderLinux::~ShellRawAudioDecoderLinux() {
  ReleaseResource();
}

void ShellRawAudioDecoderLinux::Decode(
    const scoped_refptr<DecoderBuffer>& buffer,
    const DecodeCB& decoder_cb) {
  if (buffer && !buffer->IsEndOfStream()) {
    if (last_input_timestamp_ == kNoTimestamp()) {
      last_input_timestamp_ = buffer->GetTimestamp();
    } else if (buffer->GetTimestamp() != kNoTimestamp()) {
      DCHECK_GE(buffer->GetTimestamp().ToInternalValue(),
                last_input_timestamp_.ToInternalValue());
      last_input_timestamp_ = buffer->GetTimestamp();
    }
  }

  if (buffer && queued_audio_.empty())
    RunDecodeLoop(buffer, false);

  if (queued_audio_.empty()) {
    decoder_cb.Run(NEED_MORE_DATA, NULL);
    return;
  }
  scoped_refptr<DecoderBuffer> result = queued_audio_.front().buffer;
  queued_audio_.pop_front();
  decoder_cb.Run(BUFFER_DECODED, result);
}

bool ShellRawAudioDecoderLinux::Flush() {
  avcodec_flush_buffers(codec_context_);
  ResetTimestampState();
  queued_audio_.clear();

  return true;
}

bool ShellRawAudioDecoderLinux::UpdateConfig(const AudioDecoderConfig& config) {
  if (!config.IsValidConfig()) {
    DLOG(ERROR) << "Invalid audio stream -"
                << " codec: " << config.codec()
                << " channel layout: " << config.channel_layout()
                << " bits per channel: " << config.bits_per_channel()
                << " samples per second: " << config.samples_per_second();
    return false;
  }

  if (codec_context_ && (bits_per_channel_ != config.bits_per_channel() ||
                         channel_layout_ != config.channel_layout() ||
                         samples_per_second_ != config.samples_per_second())) {
    DVLOG(1) << "Unsupported config change :";
    DVLOG(1) << "\tbits_per_channel : " << bits_per_channel_ << " -> "
             << config.bits_per_channel();
    DVLOG(1) << "\tchannel_layout : " << channel_layout_ << " -> "
             << config.channel_layout();
    DVLOG(1) << "\tsample_rate : " << samples_per_second_ << " -> "
             << config.samples_per_second();
    return false;
  }

  ReleaseResource();

  codec_context_ = avcodec_alloc_context3(NULL);
  DCHECK(codec_context_);
  codec_context_->codec_type = AVMEDIA_TYPE_AUDIO;
  codec_context_->codec_id = CODEC_ID_AAC;
  // request_sample_fmt is set by us, but sample_fmt is set by the decoder.
  codec_context_->request_sample_fmt = AV_SAMPLE_FMT_FLT;  // interleaved float

  codec_context_->channels =
      ChannelLayoutToChannelCount(config.channel_layout());
  codec_context_->sample_rate = config.samples_per_second();

  if (config.extra_data()) {
    codec_context_->extradata_size = config.extra_data_size();
    codec_context_->extradata = reinterpret_cast<uint8_t*>(
        av_malloc(config.extra_data_size() + FF_INPUT_BUFFER_PADDING_SIZE));
    memcpy(codec_context_->extradata, config.extra_data(),
           config.extra_data_size());
    memset(codec_context_->extradata + config.extra_data_size(), '\0',
           FF_INPUT_BUFFER_PADDING_SIZE);
  } else {
    codec_context_->extradata = NULL;
    codec_context_->extradata_size = 0;
  }

  AVCodec* codec = avcodec_find_decoder(codec_context_->codec_id);
  DCHECK(codec);

  int rv = avcodec_open2(codec_context_, codec, NULL);
  DCHECK_GE(rv, 0);
  if (rv < 0) {
    DLOG(ERROR) << "Unable to open codec, result = " << rv;
    return false;
  }

  // Ensure avcodec_open2() respected our format request.
  if (codec_context_->sample_fmt != codec_context_->request_sample_fmt) {
    DLOG(INFO) << "Unable to configure a supported sample format,"
               << " sample_fmt = " << codec_context_->sample_fmt
               << " instead of " << codec_context_->request_sample_fmt
               << ". Use libavresample to resample the decoded result to FLT";
    DLOG(INFO) << "Supported formats:";
    const AVSampleFormat* fmt;
    for (fmt = codec_context_->codec->sample_fmts; *fmt != -1; ++fmt) {
      DLOG(INFO) << "  " << *fmt << " (" << av_get_sample_fmt_name(*fmt) << ")";
    }
  }

  av_frame_ = avcodec_alloc_frame();
  DCHECK(av_frame_);

  bits_per_channel_ = config.bits_per_channel();
  channel_layout_ = config.channel_layout();
  samples_per_second_ = config.samples_per_second();
  output_timestamp_helper_.reset(new AudioTimestampHelper(
      kSampleSizeInBytes, config.samples_per_second()));

  ResetTimestampState();

  return true;
}

void ShellRawAudioDecoderLinux::ReleaseResource() {
  if (codec_context_) {
    av_free(codec_context_->extradata);
    avcodec_close(codec_context_);
    av_free(codec_context_);
    codec_context_ = NULL;
  }
  if (av_frame_) {
    av_free(av_frame_);
    av_frame_ = NULL;
  }
}

void ShellRawAudioDecoderLinux::ResetTimestampState() {
  output_timestamp_helper_->SetBaseTimestamp(kNoTimestamp());
  last_input_timestamp_ = kNoTimestamp();
}

void ShellRawAudioDecoderLinux::RunDecodeLoop(
    const scoped_refptr<DecoderBuffer>& input,
    bool skip_eos_append) {
  AVPacket packet;
  av_init_packet(&packet);
  packet.data = input->GetWritableData();
  packet.size = input->GetDataSize();

  do {
    avcodec_get_frame_defaults(av_frame_);
    int frame_decoded = 0;
    int result = avcodec_decode_audio4(codec_context_, av_frame_,
                                       &frame_decoded, &packet);
    DCHECK_GE(result, 0);

    // Update packet size and data pointer in case we need to call the decoder
    // with the remaining bytes from this packet.
    packet.size -= result;
    packet.data += result;

    if (output_timestamp_helper_->base_timestamp() == kNoTimestamp() &&
        !input->IsEndOfStream()) {
      DCHECK_NE(input->GetTimestamp().ToInternalValue(),
                kNoTimestamp().ToInternalValue());
      output_timestamp_helper_->SetBaseTimestamp(input->GetTimestamp());
    }

    const uint8* decoded_audio_data = NULL;
    int decoded_audio_size = 0;
    if (frame_decoded) {
      decoded_audio_data = av_frame_->data[0];
      decoded_audio_size = av_samples_get_buffer_size(
          NULL, codec_context_->channels, av_frame_->nb_samples,
          codec_context_->sample_fmt, 1);
    }

    scoped_refptr<DecoderBuffer> output;

    if (decoded_audio_size > 0) {
      // Copy the audio samples into an output buffer.
      int buffer_size = kSampleSizeInBytes * mp4::AAC::kFramesPerAccessUnit *
                        codec_context_->channels;
      output = decoder_buffer_pool_.Allocate(buffer_size);
      DCHECK(output);
      // Interleave the planar samples to conform to the general decoder
      // requirement. This should eventually be lifted.
      ResampleToInterleavedFloat(
          codec_context_->sample_fmt, codec_context_->channel_layout,
          samples_per_second_, mp4::AAC::kFramesPerAccessUnit,
          av_frame_->extended_data,
          reinterpret_cast<uint8*>(output->GetWritableData()));
      output->SetTimestamp(output_timestamp_helper_->GetTimestamp());
      output->SetDuration(
          output_timestamp_helper_->GetDuration(decoded_audio_size));
      output_timestamp_helper_->AddBytes(decoded_audio_size /
                                         codec_context_->channels);
    } else if (IsEndOfStream(result, decoded_audio_size, input) &&
               !skip_eos_append) {
      DCHECK_EQ(packet.size, 0);
      // Create an end of stream output buffer.
      output = DecoderBuffer::CreateEOSBuffer(kNoTimestamp());
    }

    if (output) {
      QueuedAudioBuffer queue_entry = {output};
      queued_audio_.push_back(queue_entry);
    }

    // TODO: update statistics.
  } while (packet.size > 0);
}

}  // namespace

scoped_ptr<ShellRawAudioDecoder> CreateShellRawAudioDecoderLinux(
    const AudioDecoderConfig& config) {
  scoped_ptr<ShellRawAudioDecoder> decoder(new ShellRawAudioDecoderLinux);
  if (!decoder->UpdateConfig(config)) {
    decoder.reset();
  }
  return decoder.Pass();
}

}  // namespace media