media/remoting/receiver.h

   1 // Copyright 2017 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef MEDIA_REMOTING_RECEIVER_H_
   6 #define MEDIA_REMOTING_RECEIVER_H_
   7
   8 #include <memory>
   9
  10 #include "base/functional/callback_forward.h"
  11 #include "base/memory/raw_ptr.h"
  12 #include "base/memory/scoped_refptr.h"
  13 #include "base/memory/weak_ptr.h"
  14 #include "base/task/sequenced_task_runner.h"
  15 #include "base/task/single_thread_task_runner.h"
  16 #include "base/timer/timer.h"
  17 #include "media/base/buffering_state.h"
  18 #include "media/base/demuxer_stream.h"
  19 #include "media/base/renderer.h"
  20 #include "media/base/renderer_client.h"
  21 #include "media/cast/openscreen/rpc_call_message_handler.h"
  22 #include "third_party/openscreen/src/cast/streaming/remoting.pb.h"
  23 #include "third_party/openscreen/src/cast/streaming/rpc_messenger.h"
  24
  25 namespace openscreen {
  26 namespace cast {
  27 class RpcMessenger;
  28 }
  29 }  // namespace openscreen
  30
  31 namespace base {
  32 class SingleThreadTaskRunner;
  33 }  // namespace base
  34
  35 namespace media {
  36 namespace remoting {
  37
  38 class ReceiverController;
  39
  40 // Receiver runs on a remote device, and forwards the information sent from a
  41 // CourierRenderer to |renderer_|, which actually renders the media.
  42 //
  43 // Receiver implements media::Renderer to be able to work with
  44 // WebMediaPlayerImpl. However, most of the APIs of media::Renderer are dummy
  45 // functions, because the media playback of the remoting media is not controlled
  46 // by the local pipeline of WMPI. It should be controlled by the remoting sender
  47 // via RPC calls. When Receiver receives RPC calls, it will call the
  48 // corresponding functions of |renderer_| to control the media playback of
  49 // the remoting media.
  50 class Receiver final : public Renderer,
  51                        public RendererClient,
  52                        public media::cast::RpcRendererCallMessageHandler {
  53  public:
  54   Receiver(int rpc_handle,
  55            int remote_handle,
  56            ReceiverController* receiver_controller,
  57            const scoped_refptr<base::SequencedTaskRunner>& media_task_runner,
  58            std::unique_ptr<Renderer> renderer,
  59            base::OnceCallback<void(int)> acquire_renderer_done_cb);
  60   ~Receiver() override;
  61
  62   // Renderer implementation
  63   void Initialize(MediaResource* media_resource,
  64                   RendererClient* client,
  65                   PipelineStatusCallback init_cb) override;
  66   void SetCdm(CdmContext* cdm_context, CdmAttachedCB cdm_attached_cb) override;
  67   void SetLatencyHint(absl::optional<base::TimeDelta> latency_hint) override;
  68   void Flush(base::OnceClosure flush_cb) override;
  69   void StartPlayingFrom(base::TimeDelta time) override;
  70   void SetPlaybackRate(double playback_rate) override;
  71   void SetVolume(float volume) override;
  72   base::TimeDelta GetMediaTime() override;
  73   RendererType GetRendererType() override;
  74
  75   // RendererClient implementation.
  76   void OnError(PipelineStatus status) override;
  77   void OnFallback(PipelineStatus status) override;
  78   void OnEnded() override;
  79   void OnStatisticsUpdate(const PipelineStatistics& stats) override;
  80   void OnBufferingStateChange(BufferingState state,
  81                               BufferingStateChangeReason reason) override;
  82   void OnWaiting(WaitingReason reason) override;
  83   void OnAudioConfigChange(const AudioDecoderConfig& config) override;
  84   void OnVideoConfigChange(const VideoDecoderConfig& config) override;
  85   void OnVideoNaturalSizeChange(const gfx::Size& size) override;
  86   void OnVideoOpacityChange(bool opaque) override;
  87   void OnVideoFrameRateChange(absl::optional<int>) override;
  88
  89   // Used to set |remote_handle_| after Receiver is created, because the remote
  90   // handle might be received after Receiver is created.
  91   void SetRemoteHandle(int remote_handle);
  92
  93   base::WeakPtr<Receiver> GetWeakPtr() { return weak_factory_.GetWeakPtr(); }
  94
  95  private:
  96   // media::cast::RpcCallMessageHandler overrides.
  97   void OnRpcInitialize() override;
  98   void OnRpcSetPlaybackRate(double playback_rate) override;
  99   void OnRpcFlush(uint32_t audio_count, uint32_t video_count) override;
 100   void OnRpcStartPlayingFrom(base::TimeDelta time) override;
 101   void OnRpcSetVolume(double volume) override;
 102
 103   // Send RPC message on |main_task_runner_|.
 104   void SendRpcMessageOnMainThread(
 105       std::unique_ptr<openscreen::cast::RpcMessage> message);
 106
 107   // Callback function when RPC message is received.
 108   void OnReceivedRpc(std::unique_ptr<openscreen::cast::RpcMessage> message);
 109
 110   void ShouldInitializeRenderer();
 111   void OnRendererInitialized(PipelineStatus status);
 112   void VerifyAcquireRendererDone();
 113   void OnFlushDone();
 114
 115   // Periodically send the UpdateTime RPC message to update the media time.
 116   void ScheduleMediaTimeUpdates();
 117   void SendMediaTimeUpdate();
 118
 119   // The callback function to call when |this| is initialized.
 120   PipelineStatusCallback init_cb_;
 121
 122   // Indicates whether |this| received RPC_R_INITIALIZE message or not.
 123   bool rpc_initialize_received_ = false;
 124
 125   // Owns by the WebMediaPlayerImpl instance.
 126   raw_ptr<MediaResource> demuxer_ = nullptr;
 127
 128   // The handle of |this| for listening RPC messages.
 129   const int rpc_handle_;
 130
 131   // The CourierRenderer handle on sender side. |remote_handle_| could be set
 132   // through the ctor or SetRemoteHandle().
 133   int remote_handle_;
 134
 135   const raw_ptr<ReceiverController>
 136       receiver_controller_;  // Outlives this class.
 137   const raw_ptr<openscreen::cast::RpcMessenger>
 138       rpc_messenger_;  // Outlives this class.
 139
 140   // Calling SendMessageCallback() of |rpc_messenger_| should be on main thread.
 141   const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
 142
 143   // Media tasks should run on media thread.
 144   const scoped_refptr<base::SequencedTaskRunner> media_task_runner_;
 145
 146   // |renderer_| is the real renderer to render media.
 147   std::unique_ptr<Renderer> renderer_;
 148
 149   // The callback function to send RPC_ACQUIRE_RENDERER_DONE.
 150   base::OnceCallback<void(int)> acquire_renderer_done_cb_;
 151
 152   // The timer to periodically update the media time.
 153   base::RepeatingTimer time_update_timer_;
 154
 155   base::WeakPtrFactory<Receiver> weak_factory_{this};
 156 };
 157
 158 }  // namespace remoting
 159 }  // namespace media
 160
 161 #endif  // MEDIA_REMOTING_RECEIVER_H_