// Copyright 2016 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "garnet/bin/media/media_service/media_service_impl.h"

#include <zircon/syscalls.h>

#include "garnet/bin/media/media_service/file_reader_impl.h"
#include "garnet/bin/media/media_service/lpcm_reformatter_impl.h"
#include "garnet/bin/media/media_service/media_decoder_impl.h"
#include "garnet/bin/media/media_service/media_demux_impl.h"
#include "garnet/bin/media/media_service/media_player_impl.h"
#include "garnet/bin/media/media_service/media_sink_impl.h"
#include "garnet/bin/media/media_service/media_source_impl.h"
#include "garnet/bin/media/media_service/media_timeline_controller_impl.h"
#include "garnet/bin/media/media_service/network_reader_impl.h"
#include "garnet/bin/media/media_service/video_renderer_impl.h"
#include "garnet/bin/media/util/multiproc_task_runner.h"
#include "lib/fxl/functional/make_copyable.h"
#include "lib/media/fidl/audio_policy_service.fidl.h"
#include "lib/media/fidl/audio_server.fidl.h"

namespace media {

MediaServiceImpl::MediaServiceImpl(
    std::unique_ptr<app::ApplicationContext> context)
    : FactoryServiceBase(std::move(context)) {
  FLOG_INITIALIZE(application_context(), "media_service");

  multiproc_task_runner_ =
      AdoptRef(new MultiprocTaskRunner(zx_system_get_num_cpus()));

  application_context()->outgoing_services()->AddService<MediaService>(
      [this](fidl::InterfaceRequest<MediaService> request) {
        bindings_.AddBinding(this, std::move(request));
      });
}

MediaServiceImpl::~MediaServiceImpl() {
  FLOG_DESTROY();
}

void MediaServiceImpl::CreateFilePlayer(
    zx::channel file_channel,
    fidl::InterfaceHandle<MediaRenderer> audio_renderer,
    fidl::InterfaceHandle<MediaRenderer> video_renderer,
    fidl::InterfaceRequest<MediaPlayer> player) {
  fidl::InterfaceHandle<SeekingReader> reader;
  CreateFileChannelReader(std::move(file_channel), reader.NewRequest());
  AddProduct(MediaPlayerImpl::Create(
      std::move(reader), std::move(audio_renderer), std::move(video_renderer),
      std::move(player), this));
}

void MediaServiceImpl::CreatePlayer(
    fidl::InterfaceHandle<SeekingReader> reader,
    fidl::InterfaceHandle<MediaRenderer> audio_renderer,
    fidl::InterfaceHandle<MediaRenderer> video_renderer,
    fidl::InterfaceRequest<MediaPlayer> player) {
  AddProduct(MediaPlayerImpl::Create(
      std::move(reader), std::move(audio_renderer), std::move(video_renderer),
      std::move(player), this));
}

void MediaServiceImpl::CreateSource(
    fidl::InterfaceHandle<SeekingReader> reader,
    fidl::Array<MediaTypeSetPtr> media_types,
    fidl::InterfaceRequest<MediaSource> source) {
  AddProduct(MediaSourceImpl::Create(std::move(reader), media_types,
                                     std::move(source), this));
}

void MediaServiceImpl::CreateSink(
    fidl::InterfaceHandle<MediaRenderer> renderer,
    fidl::InterfaceRequest<MediaSink> sink_request) {
  AddProduct(MediaSinkImpl::Create(std::move(renderer), std::move(sink_request),
                                   this));
}

void MediaServiceImpl::CreateDemux(
    fidl::InterfaceHandle<SeekingReader> reader,
    fidl::InterfaceRequest<MediaSource> request) {
  CreateProductOnNewThread<MediaDemuxImpl>(fxl::MakeCopyable([
    this, reader = std::move(reader), request = std::move(request)
  ]() mutable {
    return MediaDemuxImpl::Create(std::move(reader), std::move(request), this);
  }));
}

void MediaServiceImpl::CreateDecoder(
    MediaTypePtr input_media_type,
    fidl::InterfaceRequest<MediaTypeConverter> request) {
  CreateProductOnNewThread<MediaDecoderImpl>(fxl::MakeCopyable([
    this, input_media_type = std::move(input_media_type),
    request = std::move(request)
  ]() mutable {
    return MediaDecoderImpl::Create(std::move(input_media_type),
                                    std::move(request), this);
  }));
}

void MediaServiceImpl::CreateNetworkReader(
    const fidl::String& url,
    fidl::InterfaceRequest<SeekingReader> request) {
  CreateProductOnNewThread<NetworkReaderImpl>(fxl::MakeCopyable(
      [ this, url = url, request = std::move(request) ]() mutable {
        return NetworkReaderImpl::Create(url, std::move(request), this);
      }));
}

void MediaServiceImpl::CreateAudioRenderer(
    fidl::InterfaceRequest<AudioRenderer> audio_renderer_request,
    fidl::InterfaceRequest<MediaRenderer> media_renderer_request) {
  AudioServerPtr audio_service =
      application_context()->ConnectToEnvironmentService<media::AudioServer>();

  // Ensure that the audio policy service is running so that the system audio
  // gain is properly set.
  // TODO(dalesat): Remove this when the policy service owns creating renderers.
  application_context()
      ->ConnectToEnvironmentService<media::AudioPolicyService>();

  audio_service->CreateRenderer(std::move(audio_renderer_request),
                                std::move(media_renderer_request));
}

void MediaServiceImpl::CreateVideoRenderer(
    fidl::InterfaceRequest<VideoRenderer> video_renderer_request,
    fidl::InterfaceRequest<MediaRenderer> media_renderer_request) {
  CreateProductOnNewThread<VideoRendererImpl>(fxl::MakeCopyable([
    this, video_renderer_request = std::move(video_renderer_request),
    media_renderer_request = std::move(media_renderer_request)
  ]() mutable {
    return VideoRendererImpl::Create(std::move(video_renderer_request),
                                     std::move(media_renderer_request), this);
  }));
}

void MediaServiceImpl::CreateTimelineController(
    fidl::InterfaceRequest<MediaTimelineController> timeline_controller) {
  AddProduct(MediaTimelineControllerImpl::Create(std::move(timeline_controller),
                                                 this));
}

void MediaServiceImpl::CreateLpcmReformatter(
    MediaTypePtr input_media_type,
    AudioSampleFormat output_sample_format,
    fidl::InterfaceRequest<MediaTypeConverter> request) {
  CreateProductOnNewThread<LpcmReformatterImpl>(fxl::MakeCopyable([
    this, input_media_type = std::move(input_media_type), output_sample_format,
    request = std::move(request)
  ]() mutable {
    return LpcmReformatterImpl::Create(std::move(input_media_type),
                                       output_sample_format, std::move(request),
                                       this);
  }));
}

void MediaServiceImpl::CreateFileChannelReader(
    zx::channel file_channel,
    fidl::InterfaceRequest<SeekingReader> request) {
  CreateProductOnNewThread<FileReaderImpl>(fxl::MakeCopyable([
    this, file_channel = std::move(file_channel), request = std::move(request)
  ]() mutable {
    return FileReaderImpl::Create(std::move(file_channel), std::move(request),
                                  this);
  }));
}

}  // namespace media