// Copyright 2015 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 "cobalt/audio/audio_buffer_source_node.h"

#include <algorithm>

#include "cobalt/audio/audio_context.h"
#include "cobalt/audio/audio_node_output.h"

namespace cobalt {
namespace audio {

#if defined(COBALT_MEDIA_SOURCE_2016)
typedef media::ShellAudioBus ShellAudioBus;
#else   // defined(COBALT_MEDIA_SOURCE_2016)
typedef ::media::ShellAudioBus ShellAudioBus;
#endif  // defined(COBALT_MEDIA_SOURCE_2016)

// numberOfInputs  : 0
// numberOfOutputs : 1
AudioBufferSourceNode::AudioBufferSourceNode(AudioContext* context)
    : AudioNode(context), state_(kNone), read_index_(0) {
  AudioLock::AutoLock lock(audio_lock());

  AddOutput(new AudioNodeOutput(this));
}

AudioBufferSourceNode::~AudioBufferSourceNode() {
  AudioLock::AutoLock lock(audio_lock());

  DCHECK_EQ(number_of_inputs(), 0u);
  RemoveAllOutputs();
}

void AudioBufferSourceNode::set_buffer(
    const scoped_refptr<AudioBuffer>& buffer) {
  AudioLock::AutoLock lock(audio_lock());

  buffer_ = buffer;
}

void AudioBufferSourceNode::Start(double when, double offset,
                                  script::ExceptionState* exception_state) {
  Start(when, offset, 0, exception_state);
}

// TODO: Fully implement start and stop method. The starting time is
// based on the current time of AudioContext. We only support start at 0 and
// stop at 0 currently.
void AudioBufferSourceNode::Start(double when, double offset, double duration,
                                  script::ExceptionState* exception_state) {
  AudioLock::AutoLock lock(audio_lock());

  if (when != 0 || offset != 0 || duration != 0) {
    dom::DOMException::Raise(dom::DOMException::kInvalidStateErr,
                             exception_state);
    return;
  }

  if (state_ != kNone) {
    dom::DOMException::Raise(dom::DOMException::kInvalidStateErr,
                             exception_state);
    return;
  }
  state_ = kStarted;
}

void AudioBufferSourceNode::Stop(double when,
                                 script::ExceptionState* exception_state) {
  AudioLock::AutoLock lock(audio_lock());

  if (when != 0) {
    dom::DOMException::Raise(dom::DOMException::kInvalidStateErr,
                             exception_state);
    return;
  }

  if (state_ != kStarted) {
    dom::DOMException::Raise(dom::DOMException::kInvalidStateErr,
                             exception_state);
    return;
  }
  state_ = kStoped;
}

scoped_ptr<ShellAudioBus> AudioBufferSourceNode::PassAudioBusFromSource(
    int32 number_of_frames, SampleType sample_type) {
  // This is called by Audio thread.
  audio_lock()->AssertLocked();

  if (state_ != kStarted || !buffer_ || buffer_->length() == read_index_) {
    return scoped_ptr<ShellAudioBus>();
  }

  DCHECK_GT(number_of_frames, 0);
  int32 frames_to_end = buffer_->length() - read_index_;
  number_of_frames = std::min(number_of_frames, frames_to_end);

  size_t channels = static_cast<size_t>(buffer_->number_of_channels());

  if (sample_type == kSampleTypeFloat32) {
    std::vector<scoped_refptr<dom::Float32Array>> audio_buffer_storages(
        channels);
    std::vector<float*> audio_buffers(channels, NULL);
    for (size_t i = 0; i < channels; ++i) {
      scoped_refptr<dom::Float32Array> buffer_data =
          buffer_->GetChannelData(static_cast<uint32>(i), NULL);
      audio_buffer_storages[i] = buffer_data->Subarray(
          NULL, read_index_, read_index_ + number_of_frames);
      audio_buffers[i] = audio_buffer_storages[i]->data();
    }

    read_index_ += number_of_frames;

    scoped_ptr<ShellAudioBus> audio_bus(new ShellAudioBus(
        static_cast<size_t>(number_of_frames), audio_buffers));

    return audio_bus.Pass();
  } else if (sample_type == kSampleTypeInt16) {
    std::vector<scoped_refptr<dom::Int16Array>> audio_buffer_storages(channels);
    std::vector<int16*> audio_buffers(channels, NULL);
    for (size_t i = 0; i < channels; ++i) {
      scoped_refptr<dom::Int16Array> buffer_data =
          buffer_->GetChannelDataInt16(static_cast<uint32>(i), NULL);
      audio_buffer_storages[i] = buffer_data->Subarray(
          NULL, read_index_, read_index_ + number_of_frames);
      audio_buffers[i] = audio_buffer_storages[i]->data();
    }

    read_index_ += number_of_frames;

    scoped_ptr<ShellAudioBus> audio_bus(new ShellAudioBus(
        static_cast<size_t>(number_of_frames), audio_buffers));

    return audio_bus.Pass();
  }

  NOTREACHED();
  return scoped_ptr<ShellAudioBus>();
}

void AudioBufferSourceNode::TraceMembers(script::Tracer* tracer) {
  AudioNode::TraceMembers(tracer);

  tracer->Trace(buffer_);
}

}  // namespace audio
}  // namespace cobalt