// Copyright 2018 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/starboard/player/filter/player_components.h"

#include <wrl/client.h>

#include <functional>

#include "starboard/common/device_type.h"
#include "starboard/common/log.h"
#include "starboard/common/ref_counted.h"
#include "starboard/common/scoped_ptr.h"
#include "starboard/common/system_property.h"
#include "starboard/shared/opus/opus_audio_decoder.h"
#include "starboard/shared/starboard/media/media_support_internal.h"
#include "starboard/shared/starboard/media/media_util.h"
#include "starboard/shared/starboard/player/filter/adaptive_audio_decoder_internal.h"
#include "starboard/shared/starboard/player/filter/audio_decoder_internal.h"
#include "starboard/shared/starboard/player/filter/audio_renderer_internal_pcm.h"
#include "starboard/shared/starboard/player/filter/audio_renderer_sink_impl.h"
#include "starboard/shared/starboard/player/filter/media_time_provider_impl.h"
#include "starboard/shared/starboard/player/filter/video_decoder_internal.h"
#include "starboard/shared/starboard/player/filter/video_render_algorithm.h"
#include "starboard/shared/starboard/player/filter/video_render_algorithm_impl.h"
#include "starboard/shared/starboard/player/filter/video_renderer_internal_impl.h"
#include "starboard/shared/starboard/player/filter/video_renderer_sink.h"
#include "starboard/shared/uwp/application_uwp.h"
#include "starboard/shared/uwp/audio_renderer_passthrough.h"
#include "starboard/shared/uwp/extended_resources_manager.h"
#include "starboard/shared/win32/audio_decoder.h"
#include "starboard/xb1/shared/video_decoder_uwp.h"

#if defined(INTERNAL_BUILD)
#include "internal/starboard/xb1/dav1d_video_decoder.h"
#include "internal/starboard/xb1/vpx_video_decoder.h"
#endif  // defined(INTERNAL_BUILD)

namespace starboard {
namespace shared {
namespace starboard {
namespace player {
namespace filter {

namespace {

using ::starboard::shared::uwp::AudioRendererPassthrough;

double GetRefreshRate() {
  return static_cast<double>(uwp::ApplicationUwp::Get()->GetRefreshRate());
}

bool IsHdrVideo(const media::VideoStreamInfo& video_stream_info) {
  const auto& mime = video_stream_info.mime;
  const auto& primaries = video_stream_info.color_metadata.primaries;
  return mime.find("codecs=\"vp9.2") != mime.npos ||
         mime.find("codecs=\"vp09.02") != mime.npos ||
         primaries == kSbMediaPrimaryIdBt2020;
}

class PlayerComponentsPassthrough
    : public ::starboard::shared::starboard::player::filter::PlayerComponents {
 public:
  PlayerComponentsPassthrough(
      scoped_ptr<AudioRendererPassthrough> audio_renderer,
      scoped_ptr<VideoRenderer> video_renderer)
      : audio_renderer_(audio_renderer.Pass()),
        video_renderer_(video_renderer.Pass()) {}

 private:
  // PlayerComponents methods
  MediaTimeProvider* GetMediaTimeProvider() override {
    return audio_renderer_.get();
  }
  AudioRenderer* GetAudioRenderer() override { return audio_renderer_.get(); }
  VideoRenderer* GetVideoRenderer() override { return video_renderer_.get(); }

  scoped_ptr<AudioRendererPassthrough> audio_renderer_;
  scoped_ptr<VideoRenderer> video_renderer_;
};

class PlayerComponentsFactory : public PlayerComponents::Factory {
  using AudioRendererPassthrough =
      ::starboard::shared::uwp::AudioRendererPassthrough;
  scoped_ptr<PlayerComponents> CreateComponents(
      const CreationParameters& creation_parameters,
      std::string* error_message) override {
    SB_DCHECK(creation_parameters.audio_codec() != kSbMediaAudioCodecNone ||
              creation_parameters.video_codec() != kSbMediaVideoCodecNone);
    SB_DCHECK(error_message);

    if (creation_parameters.audio_codec() != kSbMediaAudioCodecAc3 &&
        creation_parameters.audio_codec() != kSbMediaAudioCodecEac3) {
      SB_LOG(INFO) << "Creating non pass-through components.";
      return PlayerComponents::Factory::CreateComponents(creation_parameters,
                                                         error_message);
    }

    SB_LOG(INFO) << "Creating pass-through components.";

    scoped_ptr<AudioDecoder> audio_decoder;
    scoped_ptr<AudioRendererPassthrough> audio_renderer;
    scoped_ptr<AudioRendererSink> audio_renderer_sink;
    scoped_ptr<VideoDecoder> video_decoder;
    scoped_ptr<VideoRenderAlgorithm> video_render_algorithm;
    scoped_refptr<VideoRendererSink> video_renderer_sink;
    scoped_ptr<VideoRendererImpl> video_renderer;

    if (!CreateSubComponents(creation_parameters, &audio_decoder,
                             &audio_renderer_sink, &video_decoder,
                             &video_render_algorithm, &video_renderer_sink,
                             error_message)) {
      return scoped_ptr<PlayerComponents>();
    }
    audio_renderer =
        scoped_ptr<AudioRendererPassthrough>(new AudioRendererPassthrough(
            audio_decoder.Pass(), creation_parameters.audio_stream_info()));
    if (creation_parameters.video_codec() != kSbMediaVideoCodecNone) {
      SB_DCHECK(video_decoder);
      SB_DCHECK(video_render_algorithm);

      MediaTimeProvider* media_time_provider = audio_renderer.get();
      video_renderer.reset(new VideoRendererImpl(
          video_decoder.Pass(), media_time_provider,
          video_render_algorithm.Pass(), video_renderer_sink));
    }

    return scoped_ptr<PlayerComponents>(new PlayerComponentsPassthrough(
        audio_renderer.Pass(), video_renderer.Pass()));
  }

  bool CreateSubComponents(
      const CreationParameters& creation_parameters,
      scoped_ptr<AudioDecoder>* audio_decoder,
      scoped_ptr<AudioRendererSink>* audio_renderer_sink,
      scoped_ptr<VideoDecoder>* video_decoder,
      scoped_ptr<VideoRenderAlgorithm>* video_render_algorithm,
      scoped_refptr<VideoRendererSink>* video_renderer_sink,
      std::string* error_message) override {
    SB_DCHECK(error_message);

    if (creation_parameters.audio_codec() != kSbMediaAudioCodecNone) {
      SB_DCHECK(audio_decoder);
      SB_DCHECK(audio_renderer_sink);

      auto decoder_creator = [](const media::AudioStreamInfo& audio_stream_info,
                                SbDrmSystem drm_system) {
        using AacAudioDecoder = ::starboard::shared::win32::AudioDecoder;
        using OpusAudioDecoder = ::starboard::shared::opus::OpusAudioDecoder;

        if (audio_stream_info.codec == kSbMediaAudioCodecAac) {
          return scoped_ptr<AudioDecoder>(
              new AacAudioDecoder(audio_stream_info, drm_system));
        } else if (audio_stream_info.codec == kSbMediaAudioCodecOpus) {
          scoped_ptr<OpusAudioDecoder> audio_decoder_impl(
              new OpusAudioDecoder(audio_stream_info));
          if (audio_decoder_impl->is_valid()) {
            return audio_decoder_impl.PassAs<AudioDecoder>();
          }
        } else {
          SB_NOTREACHED();
        }
        return scoped_ptr<AudioDecoder>();
      };

      auto audio_codec = creation_parameters.audio_stream_info().codec;
      if (audio_codec != kSbMediaAudioCodecAc3 &&
          audio_codec != kSbMediaAudioCodecEac3) {
        audio_decoder->reset(new AdaptiveAudioDecoder(
            creation_parameters.audio_stream_info(),
            creation_parameters.drm_system(), decoder_creator));
      } else {
        // Use win32::AudioDecoder to decrypt and reformat the bitstream for the
        // passthrough AudioRenderer.
        audio_decoder->reset(new ::starboard::shared::win32::AudioDecoder(
            creation_parameters.audio_stream_info(),
            creation_parameters.drm_system()));
      }
      audio_renderer_sink->reset(new AudioRendererSinkImpl);
    }

    const auto video_codec = creation_parameters.video_codec();
    if (video_codec == kSbMediaVideoCodecNone) {
      return true;
    }

    using MftVideoDecoder = ::starboard::xb1::shared::VideoDecoderUwp;

    const auto output_mode = creation_parameters.output_mode();
    const auto is_hdr_video =
        IsHdrVideo(creation_parameters.video_stream_info());

    if (video_codec == kSbMediaVideoCodecH264 ||
        (video_codec == kSbMediaVideoCodecVp9 &&
         MftVideoDecoder::IsHardwareVp9DecoderSupported()) ||
        (video_codec == kSbMediaVideoCodecAv1 &&
         MftVideoDecoder::IsHardwareAv1DecoderSupported())) {
      video_render_algorithm->reset(
          new VideoRenderAlgorithmImpl(std::bind(GetRefreshRate)));
      video_decoder->reset(new MftVideoDecoder(
          video_codec, output_mode,
          creation_parameters.decode_target_graphics_context_provider(),
          creation_parameters.drm_system()));
      return true;
    }

#if !SB_HAS(GPU_DECODERS_ON_DESKTOP)
#if SB_API_VERSION < 15
    if (SbSystemGetDeviceType() == kSbSystemDeviceTypeDesktopPC) {
      SB_LOG(WARNING) << "GPU decoder disabled on Desktop.";
      return false;
    }
#else
    if (GetSystemPropertyString(kSbSystemPropertyDeviceType) ==
        kSystemDeviceTypeDesktopPC) {
      SB_LOG(WARNING) << "GPU decoder disabled on Desktop.";
      return false;
    }
#endif
#endif  // !SB_HAS(GPU_DECODERS_ON_DESKTOP)
    if (video_codec != kSbMediaVideoCodecVp9 &&
        video_codec != kSbMediaVideoCodecAv1) {
      return false;
    }
    SB_DCHECK(output_mode == kSbPlayerOutputModeDecodeToTexture);

    Microsoft::WRL::ComPtr<ID3D12Device> d3d12device;
    Microsoft::WRL::ComPtr<ID3D12Heap> d3d12buffer_heap;
    void* d3d12queue = nullptr;
    if (!uwp::ExtendedResourcesManager::GetInstance()->GetD3D12Objects(
            &d3d12device, &d3d12buffer_heap, &d3d12queue)) {
      // Somehow extended resources get lost.  Returns directly to trigger an
      // error to the player.
      *error_message =
          "Failed to obtain D3D12Device and/or D3D12queue required for "
          "instantiating GPU based decoders.";
      SB_LOG(ERROR) << *error_message;
      return false;
    }
    SB_DCHECK(d3d12device);
    SB_DCHECK(d3d12buffer_heap);
    SB_DCHECK(d3d12queue);

#if defined(INTERNAL_BUILD)
    using GpuVp9VideoDecoder = ::starboard::xb1::shared::VpxVideoDecoder;
    using GpuAv1VideoDecoder = ::starboard::xb1::shared::Dav1dVideoDecoder;

    if (video_codec == kSbMediaVideoCodecVp9) {
      video_decoder->reset(new GpuVp9VideoDecoder(
          creation_parameters.decode_target_graphics_context_provider(),
          creation_parameters.video_stream_info(), is_hdr_video, d3d12device,
          d3d12buffer_heap, d3d12queue));
    }

    if (video_codec == kSbMediaVideoCodecAv1) {
      video_decoder->reset(new GpuAv1VideoDecoder(
          creation_parameters.decode_target_graphics_context_provider(),
          creation_parameters.video_stream_info(), is_hdr_video, d3d12device,
          d3d12buffer_heap, d3d12queue));
    }
#endif  // defined(INTERNAL_BUILD)

    if (video_decoder) {
      video_render_algorithm->reset(
          new VideoRenderAlgorithmImpl(std::bind(GetRefreshRate)));
      return true;
    }

    *error_message = FormatString(
        "Unsupported video codec %d or insufficient resources to its creation.",
        video_codec);
    SB_LOG(ERROR) << *error_message;
    return false;
  }
};

}  // namespace

// static
scoped_ptr<PlayerComponents::Factory> PlayerComponents::Factory::Create() {
  return make_scoped_ptr<PlayerComponents::Factory>(
      new PlayerComponentsFactory);
}

// static
bool PlayerComponents::Factory::OutputModeSupported(
    SbPlayerOutputMode output_mode,
    SbMediaVideoCodec codec,
    SbDrmSystem drm_system) {
  return output_mode == kSbPlayerOutputModeDecodeToTexture;
}

}  // namespace filter
}  // namespace player
}  // namespace starboard
}  // namespace shared
}  // namespace starboard