// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef COMPONENTS_CAST_STREAMING_RENDERER_FRAME_FRAME_INJECTING_DEMUXER_H_
#define COMPONENTS_CAST_STREAMING_RENDERER_FRAME_FRAME_INJECTING_DEMUXER_H_

#include <optional>

#include "base/memory/scoped_refptr.h"
#include "base/memory/weak_ptr.h"
#include "base/task/sequenced_task_runner.h"
#include "components/cast_streaming/common/public/mojom/demuxer_connector.mojom.h"
#include "components/cast_streaming/renderer/frame/demuxer_connector.h"
#include "media/base/demuxer.h"

namespace cast_streaming {

class StreamTimestampOffsetTracker;
class FrameInjectingAudioDemuxerStream;
class FrameInjectingVideoDemuxerStream;
class DemuxerStreamConfigBuffer;

// media::Demuxer implementation for a Cast Streaming Receiver.
// Every method is called on the media thread, whose task runner is
// |media_task_runner_|.
class FrameInjectingDemuxer final : public media::Demuxer {
 public:
  FrameInjectingDemuxer(
      scoped_refptr<DemuxerStreamConfigBuffer> config_buffer,
      scoped_refptr<base::SequencedTaskRunner> media_task_runner);
  ~FrameInjectingDemuxer() override;

  FrameInjectingDemuxer(const FrameInjectingDemuxer&) = delete;
  FrameInjectingDemuxer& operator=(const FrameInjectingDemuxer&) = delete;

 private:
  void OnStreamsInitializedOnMediaThread(
      mojom::AudioStreamInitializationInfoPtr audio_stream_info,
      mojom::VideoStreamInitializationInfoPtr video_stream_info);
  void OnStreamInitializationComplete();

  // media::Demuxer implementation.
  std::vector<raw_ptr<media::DemuxerStream>> GetAllStreams() override;
  std::string GetDisplayName() const override;
  media::DemuxerType GetDemuxerType() const override;
  void Initialize(media::DemuxerHost* host,
                  media::PipelineStatusCallback status_cb) override;
  void AbortPendingReads() override;
  void StartWaitingForSeek(base::TimeDelta seek_time) override;
  void CancelPendingSeek(base::TimeDelta seek_time) override;
  void Seek(base::TimeDelta time,
            media::PipelineStatusCallback status_cb) override;
  bool IsSeekable() const override;
  void Stop() override;
  base::TimeDelta GetStartTime() const override;
  base::Time GetTimelineOffset() const override;
  int64_t GetMemoryUsage() const override;
  std::optional<media::container_names::MediaContainerName>
  GetContainerForMetrics() const override;
  void OnTracksChanged(media::DemuxerStream::Type track_type,
                       std::optional<media::MediaTrack::Id> track_id,
                       base::TimeDelta curr_time,
                       TrackChangeCB change_completed_cb) override;
  void SetPlaybackRate(double rate) override {}

  // The number of initialized streams that have yet to call
  // OnStreamInitializationComplete().
  int pending_stream_initialization_callbacks_ = 0;

  scoped_refptr<base::SequencedTaskRunner> media_task_runner_;
  raw_ptr<media::DemuxerHost> host_ = nullptr;

  scoped_refptr<StreamTimestampOffsetTracker> timestamp_tracker_;
  std::unique_ptr<FrameInjectingAudioDemuxerStream> audio_stream_;
  std::unique_ptr<FrameInjectingVideoDemuxerStream> video_stream_;

  // Set to true if the Demuxer was successfully initialized.
  bool was_initialization_successful_ = false;
  media::PipelineStatusCallback initialized_cb_;
  const scoped_refptr<DemuxerStreamConfigBuffer> config_buffer_;

  base::WeakPtrFactory<FrameInjectingDemuxer> weak_factory_{this};
};

}  // namespace cast_streaming

#endif  // COMPONENTS_CAST_STREAMING_RENDERER_FRAME_FRAME_INJECTING_DEMUXER_H_