chromecast/media/audio/cast_audio_renderer.h

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

#ifndef CHROMECAST_MEDIA_AUDIO_CAST_AUDIO_RENDERER_H_
#define CHROMECAST_MEDIA_AUDIO_CAST_AUDIO_RENDERER_H_

#include <memory>
#include <vector>

#include "base/memory/scoped_refptr.h"
#include "base/memory/weak_ptr.h"
#include "base/sequence_checker.h"
#include "base/threading/sequence_bound.h"
#include "base/time/time.h"
#include "base/timer/timer.h"
#include "chromecast/common/mojom/audio_socket.mojom.h"
#include "chromecast/media/audio/audio_output_service/output_stream_connection.h"
#include "media/base/audio_renderer.h"
#include "media/base/buffering_state.h"
#include "media/base/demuxer_stream.h"
#include "media/base/time_source.h"
#include "media/base/waiting.h"
#include "media/mojo/mojom/cast_application_media_info_manager.mojom.h"
#include "mojo/public/cpp/bindings/remote.h"

namespace base {
class SequencedTaskRunner;
}  // namespace base

namespace blink {
class BrowserInterfaceBrokerProxy;
}  // namespace blink

namespace media {
class AudioDecoderConfig;
class DecoderBuffer;
class DecryptingDemuxerStream;
class MediaLog;
}  // namespace media

namespace chromecast {
namespace media {

// Cast implementation of ::media::AudioRenderer which sends decrypted audio
// buffers to the audio output service for decoding and rendering.
// Threading model: after constructed, ::media::AudioRenderer methods will be
// called on the main thread. ::media::TimeSource methods will be called from
// multiple threads (so lock is required for timeline related fields/methods).
// audio_output_service::OutputStreamConnection::Delegate methods will be called
// from an IO thread.
class CastAudioRenderer
    : public ::media::AudioRenderer,
      public ::media::TimeSource,
      public audio_output_service::OutputStreamConnection::Delegate {
 public:
  CastAudioRenderer(scoped_refptr<base::SequencedTaskRunner> media_task_runner,
                    ::media::MediaLog* media_log,
                    blink::BrowserInterfaceBrokerProxy* interface_broker);
  CastAudioRenderer(const CastAudioRenderer&) = delete;
  CastAudioRenderer& operator=(const CastAudioRenderer&) = delete;
  ~CastAudioRenderer() override;

 private:
  enum class PlaybackState {
    kStopped,

    // We've called Start(), but haven't received updated state. |start_time_|
    // should not be used yet.
    kStarting,

    // Playback is active. When the stream reaches EOS it stays in the kPlaying
    // state.
    kPlaying,
  };

  // ::media::AudioRenderer implementation:
  void Initialize(::media::DemuxerStream* stream,
                  ::media::CdmContext* cdm_context,
                  ::media::RendererClient* client,
                  ::media::PipelineStatusCallback init_cb) override;
  ::media::TimeSource* GetTimeSource() override;
  void Flush(base::OnceClosure callback) override;
  void StartPlaying() override;
  void SetVolume(float volume) override;
  void SetLatencyHint(absl::optional<base::TimeDelta> latency_hint) override;
  void SetPreservesPitch(bool preserves_pitch) override;
  void SetWasPlayedWithUserActivation(
      bool was_played_with_user_activation) override;

  // ::media::TimeSource implementation:
  void StartTicking() override;
  void StopTicking() override;
  void SetPlaybackRate(double playback_rate) override;
  void SetMediaTime(base::TimeDelta time) override;
  base::TimeDelta CurrentMediaTime() override;
  bool GetWallClockTimes(
      const std::vector<base::TimeDelta>& media_timestamps,
      std::vector<base::TimeTicks>* wall_clock_times) override;

  // audio_output_service::OutputStreamConnection::Delegate implementation:
  void OnBackendInitialized(
      const audio_output_service::BackendInitializationStatus& status) override;
  void OnNextBuffer(int64_t media_timestamp_microseconds,
                    int64_t reference_timestamp_microseconds,
                    int64_t delay_microseconds,
                    int64_t delay_timestamp_microseconds) override;

  void ScheduleFetchNextBuffer();
  void FetchNextBuffer();
  void OnEndOfStream();

  // Returns current PlaybackState.
  PlaybackState GetPlaybackState() EXCLUSIVE_LOCKS_REQUIRED(timeline_lock_);

  // Helper function used with DCHECKs to hold |timeline_lock_|.
  bool CurrentPlaybackStateEquals(PlaybackState playback_state);

  // Used to update |state_|.
  void SetPlaybackState(PlaybackState state)
      EXCLUSIVE_LOCKS_REQUIRED(timeline_lock_);

  // Returns true if media clock is ticking and the rate is above 0.0.
  bool IsTimeMoving() EXCLUSIVE_LOCKS_REQUIRED(timeline_lock_);

  // Updates TimelineFunction parameters after StopTicking() or
  // SetPlaybackRate(0.0). Normally these parameters are provided by
  // the audio output service, but this happens asynchronously and we need to
  // make sure that StopTicking() and SetPlaybackRate(0.0) stop the media clock
  // synchronously. Must be called before updating the |state_|.
  void UpdateTimelineOnStop() EXCLUSIVE_LOCKS_REQUIRED(timeline_lock_);

  void UpdateAudioDecoderConfig(const ::media::AudioDecoderConfig& config);

  base::TimeDelta CurrentMediaTimeLocked()
      EXCLUSIVE_LOCKS_REQUIRED(timeline_lock_);

  // Updates buffer state and notifies the |client_| if necessary.
  void SetBufferState(::media::BufferingState buffer_state);

  void OnNewBuffer(::media::DemuxerStream::Status read_status,
                   scoped_refptr<::media::DecoderBuffer> buffer);
  void OnError(::media::PipelineStatus pipeline_status);
  void OnDecryptingDemuxerInitialized(::media::PipelineStatus pipeline_status);
  void OnWaiting(::media::WaitingReason reason);
  void OnApplicationMediaInfoReceived(
      ::media::mojom::CastApplicationMediaInfoPtr application_media_info);
  void FlushInternal();

  const scoped_refptr<base::SequencedTaskRunner> media_task_runner_;
  ::media::MediaLog* const media_log_;

  scoped_refptr<base::SequencedTaskRunner> main_task_runner_;
  ::media::DemuxerStream* demuxer_stream_ = nullptr;
  std::unique_ptr<::media::DecryptingDemuxerStream> decrypting_stream_;
  ::media::RendererClient* renderer_client_ = nullptr;
  base::SequenceBound<audio_output_service::OutputStreamConnection>
      output_connection_;

  bool is_pending_demuxer_read_ = false;
  ::media::PipelineStatusCallback init_cb_;
  base::OnceClosure flush_cb_;

  float volume_ = 1.0f;

  ::media::BufferingState buffer_state_ = ::media::BUFFERING_HAVE_NOTHING;

  base::TimeDelta last_pushed_timestamp_ = base::TimeDelta::Min();
  base::OneShotTimer read_timer_;

  // Indicates that StartPlaying() has been called. Note that playback doesn't
  // start until StartTicking() is called.
  bool renderer_started_ = false;

  // Indicates that StartTicking() has been called.
  bool ticking_ = false;

  bool is_at_end_of_stream_ = false;

  // TimeSource interface is not single-threaded. The lock is used to guard
  // fields that are accessed in the TimeSource implementation.
  base::Lock timeline_lock_;

  float playback_rate_ GUARDED_BY(timeline_lock_) = 0.0f;

  // Should be changed by calling SetPlaybackState() on the main thread.
  PlaybackState state_ GUARDED_BY(timeline_lock_) = PlaybackState::kStopped;

  base::TimeTicks reference_time_ GUARDED_BY(timeline_lock_);
  base::TimeDelta media_pos_ GUARDED_BY(timeline_lock_);

  // TODO(b/173250111): update these values based on whether the media session
  // is multiroom.
  base::TimeDelta min_lead_time_ = base::Milliseconds(100);
  base::TimeDelta max_lead_time_ = base::Milliseconds(500);

  mojo::PendingRemote<::media::mojom::CastApplicationMediaInfoManager>
      application_media_info_manager_pending_remote_;
  mojo::Remote<::media::mojom::CastApplicationMediaInfoManager>
      application_media_info_manager_remote_;
  mojo::PendingRemote<mojom::AudioSocketBroker>
      audio_socket_broker_pending_remote_;

  SEQUENCE_CHECKER(sequence_checker_);

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

}  // namespace media
}  // namespace chromecast

#endif  // CHROMECAST_MEDIA_AUDIO_CAST_AUDIO_RENDERER_H_