// Copyright 2016 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/raspi/shared/open_max/open_max_component.h"

#include <algorithm>

#include "starboard/configuration.h"
#include "starboard/once.h"
#include "starboard/thread.h"

namespace starboard {
namespace raspi {
namespace shared {
namespace open_max {

OpenMaxComponent::OpenMaxComponent(const char* name)
    : OpenMaxComponentBase(name),
      output_setting_changed_(false),
      outstanding_output_buffers_(0),
      output_component_(NULL) {}

void OpenMaxComponent::SetOutputComponent(OpenMaxComponent* component) {
  SB_DCHECK(component != NULL);
  SB_DCHECK(component->input_buffers_.empty());
  SB_DCHECK(output_component_ == NULL);
  SB_DCHECK(output_buffers_.empty());
  output_component_ = component;
}

void OpenMaxComponent::CloseTunnel() {
  OMX_ERRORTYPE error;

  Flush();
  OpenMaxComponent* prev = this;
  OpenMaxComponent* current = output_component_;
  while (current != NULL) {
    current->Flush();

    prev->SendCommand(OMX_CommandPortDisable, prev->output_port_);
    current->SendCommand(OMX_CommandPortDisable, current->input_port_);
    prev->WaitForCommandCompletion();
    current->WaitForCommandCompletion();

    error = OMX_SetupTunnel(prev->handle_, prev->output_port_, NULL, 0);
    SB_DCHECK(error == OMX_ErrorNone)
        << "OMX_SetupTunnel " << prev->output_port_
        << " to 0 failed with error " << std::hex << error;
    error = OMX_SetupTunnel(current->handle_, current->input_port_, NULL, 0);
    SB_DCHECK(error == OMX_ErrorNone)
        << "OMX_SetupTunnel " << current->input_port_
        << " to 0 failed with error " << std::hex << error;

    prev->output_component_ = NULL;
    prev = current;
    current = current->output_component_;
  }
}

void OpenMaxComponent::Start() {
  SendCommandAndWaitForCompletion(OMX_CommandStateSet, OMX_StateIdle);
  EnableInputPortAndAllocateBuffers();
  SendCommandAndWaitForCompletion(OMX_CommandStateSet, OMX_StateExecuting);
}

void OpenMaxComponent::Flush() {
  DisableOutputPort();
  SendCommandAndWaitForCompletion(OMX_CommandFlush, input_port_);
  SendCommandAndWaitForCompletion(OMX_CommandFlush, output_port_);
}

int OpenMaxComponent::WriteData(const void* data, int size, DataType type,
                                SbTime timestamp) {
  int offset = 0;

  while (offset < size) {
    OMX_BUFFERHEADERTYPE* buffer_header = GetUnusedInputBuffer();
    if (buffer_header == NULL) {
      return offset;
    }

    int size_to_append = size - offset;
    if (size_to_append > buffer_header->nAllocLen) {
      size_to_append = buffer_header->nAllocLen;
      buffer_header->nFlags = 0;
    } else if (type == kDataEOS) {
      buffer_header->nFlags = OMX_BUFFERFLAG_EOS;
    } else {
      buffer_header->nFlags = 0;
    }
    buffer_header->nOffset = 0;
    buffer_header->nFilledLen = size_to_append;

    buffer_header->nTimeStamp.nLowPart = timestamp;
    buffer_header->nTimeStamp.nHighPart = timestamp >> 32;

    memcpy(buffer_header->pBuffer, reinterpret_cast<const char*>(data) + offset,
           size_to_append);
    offset += size_to_append;

    OMX_ERRORTYPE error = OMX_EmptyThisBuffer(handle_, buffer_header);
    SB_DCHECK(error == OMX_ErrorNone);
  }

  return offset;
}

bool OpenMaxComponent::WriteEOS() {
  OMX_BUFFERHEADERTYPE* buffer_header;
  if ((buffer_header = GetUnusedInputBuffer()) == NULL) {
    return false;
  }

  buffer_header->nOffset = 0;
  buffer_header->nFilledLen = 0;
  buffer_header->nFlags = OMX_BUFFERFLAG_EOS;

  OMX_ERRORTYPE error = OMX_EmptyThisBuffer(handle_, buffer_header);
  SB_DCHECK(error == OMX_ErrorNone);
  return true;
}

OMX_BUFFERHEADERTYPE* OpenMaxComponent::GetOutputBuffer() {
  bool enable_output_port = false;

  {
    mutex_.Acquire();
    if (!output_setting_changed_ && output_buffers_.empty()) {
      mutex_.Release();
      if (output_component_ == NULL) {
        return NULL;
      } else {
        return output_component_->GetOutputBuffer();
      }
    }

    enable_output_port = output_setting_changed_ &&
                         filled_output_buffers_.empty() &&
                         outstanding_output_buffers_ == 0;
    mutex_.Release();
  }

  if (enable_output_port) {
    EnableOutputPortAndAllocateBuffer();
    output_setting_changed_ = false;
  }

  ScopedLock scoped_lock(mutex_);
  if (filled_output_buffers_.empty()) {
    return NULL;
  }

  SB_DCHECK(output_component_ == NULL);
  OMX_BUFFERHEADERTYPE* buffer = filled_output_buffers_.front();
  filled_output_buffers_.pop();
  ++outstanding_output_buffers_;
  return buffer;
}

void OpenMaxComponent::DropOutputBuffer(OMX_BUFFERHEADERTYPE* buffer) {
  if (output_component_ != NULL) {
    output_component_->DropOutputBuffer(buffer);
    return;
  }

  {
    ScopedLock scoped_lock(mutex_);
    if (output_buffers_.empty()) {
      SB_DCHECK(outstanding_output_buffers_ == 0);
      return;
    }
    SB_DCHECK(outstanding_output_buffers_ > 0);
    --outstanding_output_buffers_;

    if (output_setting_changed_) {
      return;
    }
  }
  buffer->nFilledLen = 0;
  OMX_ERRORTYPE error = OMX_FillThisBuffer(handle_, buffer);
  SB_DCHECK(error == OMX_ErrorNone);
}

OpenMaxComponent::~OpenMaxComponent() {
  if (!handle_) {
    return;
  }

  SendCommandAndWaitForCompletion(OMX_CommandStateSet, OMX_StateIdle);

  SendCommandAndWaitForCompletion(OMX_CommandFlush, input_port_);
  SendCommandAndWaitForCompletion(OMX_CommandFlush, output_port_);

  SendCommand(OMX_CommandPortDisable, input_port_);
  for (size_t i = 0; i < input_buffers_.size(); ++i) {
    OMX_ERRORTYPE error =
        OMX_FreeBuffer(handle_, input_port_, input_buffers_[i]);
    SB_DCHECK(error == OMX_ErrorNone);
  }
  WaitForCommandCompletion();

  DisableOutputPort();

  SendCommandAndWaitForCompletion(OMX_CommandStateSet, OMX_StateLoaded);
}

void OpenMaxComponent::OnErrorEvent(OMX_U32 data1, OMX_U32 data2,
                                    OMX_PTR /* event_data */) {
  SB_NOTREACHED() << "OMX_EventError received with " << std::hex << data1
                  << " " << data2;
}

OMX_BUFFERHEADERTYPE* OpenMaxComponent::AllocateBuffer(int port,
                                                       int index,
                                                       OMX_U32 size) {
  OMX_BUFFERHEADERTYPE* buffer;
  OMX_ERRORTYPE error = OMX_AllocateBuffer(handle_, &buffer, port, NULL, size);
  SB_DCHECK(error == OMX_ErrorNone);
  return buffer;
}

void OpenMaxComponent::DisableOutputPort() {
  if (!output_buffers_.empty()) {
    SendCommandAndWaitForCompletion(OMX_CommandFlush, output_port_);

    SendCommand(OMX_CommandPortDisable, output_port_);
    for (size_t i = 0; i < output_buffers_.size(); ++i) {
      OMX_ERRORTYPE error =
          OMX_FreeBuffer(handle_, output_port_, output_buffers_[i]);
      SB_DCHECK(error == OMX_ErrorNone);
    }
    output_buffers_.clear();
    WaitForCommandCompletion();
    while (!filled_output_buffers_.empty()) {
      filled_output_buffers_.pop();
    }
  }
  outstanding_output_buffers_ = 0;
}

void OpenMaxComponent::EnableInputPortAndAllocateBuffers() {
  SB_DCHECK(input_buffers_.empty());

  OMXParamPortDefinition port_definition;
  GetInputPortParam(&port_definition);
  if (OnEnableInputPort(&port_definition)) {
    SetPortParam(port_definition);
  }

  SendCommand(OMX_CommandPortEnable, input_port_);

  for (int i = 0; i < port_definition.nBufferCountActual; ++i) {
    OMX_BUFFERHEADERTYPE* buffer =
        AllocateBuffer(input_port_, i, port_definition.nBufferSize);
    input_buffers_.push_back(buffer);
    free_input_buffers_.push(buffer);
  }

  WaitForCommandCompletion();
}

void OpenMaxComponent::EnableOutputPortAndAllocateBuffer() {
  DisableOutputPort();

  OMXParamPortDefinition output_port_definition;

  GetOutputPortParam(&output_port_definition);
  if (OnEnableOutputPort(&output_port_definition)) {
    SetPortParam(output_port_definition);
  }

  if (output_component_ != NULL) {
    EnableOutputTunnelling(output_port_definition);
    return;
  }

  // Finish Start() for tunnel components.
  if (input_buffers_.empty()) {
    // Call OnEnableOutputPort() again with the final port settings.
    // This is only meant to notify the component of the settings -- any
    // changes should have been made on the first call.
    GetOutputPortParam(&output_port_definition);
    if (OnEnableOutputPort(&output_port_definition)) {
      SB_NOTREACHED() << "Tunnel port parameters cannot be changed now";
    }
    SendCommandAndWaitForCompletion(OMX_CommandStateSet, OMX_StateExecuting);
  }

  SendCommand(OMX_CommandPortEnable, output_port_);

  output_buffers_.reserve(output_port_definition.nBufferCountActual);
  for (int i = 0; i < output_port_definition.nBufferCountActual; ++i) {
    OMX_BUFFERHEADERTYPE* buffer =
        AllocateBuffer(output_port_, i, output_port_definition.nBufferSize);
    output_buffers_.push_back(buffer);
  }

  WaitForCommandCompletion();

  for (size_t i = 0; i < output_buffers_.size(); ++i) {
    output_buffers_[i]->nFilledLen = 0;
    OMX_ERRORTYPE error = OMX_FillThisBuffer(handle_, output_buffers_[i]);
    SB_DCHECK(error == OMX_ErrorNone);
  }
}

void OpenMaxComponent::EnableOutputTunnelling(
    const OMXParamPortDefinition& port_definition) {
  // Setup tunnelling to output component. Set the output component's
  // input port to look exactly like our output.
  OMXParamPortDefinition input_port = port_definition;
  input_port.nPortIndex = output_component_->input_port_;
  output_component_->OnEnableInputPort(&input_port);
  output_component_->SetPortParam(input_port);

  OMX_ERRORTYPE error =
      OMX_SetupTunnel(handle_, output_port_, output_component_->handle_,
                      output_component_->input_port_);
  SB_DCHECK(error == OMX_ErrorNone) << "OMX_SetupTunnel " << output_port_
                                    << " to " << output_component_->input_port_
                                    << " failed with error " << std::hex
                                    << error;

  // Enable the tunnel. This takes place of output_component_->Start(), but
  // the component will still need to be put into the executing state when
  // its output port is enabled.
  SendCommand(OMX_CommandPortEnable, output_port_);
  output_component_->SendCommand(OMX_CommandPortEnable,
                                 output_component_->input_port_);
  output_component_->WaitForCommandCompletion();
  output_component_->SendCommandAndWaitForCompletion(OMX_CommandStateSet,
                                                     OMX_StateIdle);
  WaitForCommandCompletion();
}

OMX_BUFFERHEADERTYPE* OpenMaxComponent::GetUnusedInputBuffer() {
  ScopedLock scoped_lock(mutex_);
  if (!free_input_buffers_.empty()) {
    OMX_BUFFERHEADERTYPE* buffer_header = free_input_buffers_.front();
    free_input_buffers_.pop();
    return buffer_header;
  }
  return NULL;
}

void OpenMaxComponent::OnOutputSettingChanged() {
  ScopedLock scoped_lock(mutex_);
  output_setting_changed_ = true;
}

OMX_ERRORTYPE OpenMaxComponent::OnEmptyBufferDone(
    OMX_BUFFERHEADERTYPE* buffer) {
  ScopedLock scoped_lock(mutex_);
  free_input_buffers_.push(buffer);
  return OMX_ErrorNone;
}

void OpenMaxComponent::OnFillBufferDone(OMX_BUFFERHEADERTYPE* buffer) {
  ScopedLock scoped_lock(mutex_);
  filled_output_buffers_.push(buffer);
}

}  // namespace open_max
}  // namespace shared
}  // namespace raspi
}  // namespace starboard