media/mojo/clients/mojo_renderer.h

   1 // Copyright 2014 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_MOJO_CLIENTS_MOJO_RENDERER_H_
   6 #define MEDIA_MOJO_CLIENTS_MOJO_RENDERER_H_
   7
   8 #include <stdint.h>
   9
  10 #include <memory>
  11 #include <vector>
  12
  13 #include "base/memory/raw_ptr.h"
  14 #include "base/task/sequenced_task_runner.h"
  15 #include "base/time/default_tick_clock.h"
  16 #include "base/unguessable_token.h"
  17 #include "media/base/demuxer_stream.h"
  18 #include "media/base/renderer.h"
  19 #include "media/base/time_delta_interpolator.h"
  20 #include "media/mojo/mojom/renderer.mojom.h"
  21 #include "mojo/public/cpp/bindings/associated_receiver.h"
  22 #include "mojo/public/cpp/bindings/pending_remote.h"
  23 #include "mojo/public/cpp/bindings/remote.h"
  24 #include "third_party/abseil-cpp/absl/types/optional.h"
  25
  26 namespace media {
  27
  28 class MediaResource;
  29 class MojoDemuxerStreamImpl;
  30 class VideoOverlayFactory;
  31 class VideoRendererSink;
  32
  33 // A media::Renderer that proxies to a mojom::Renderer. That
  34 // mojom::Renderer proxies back to the MojoRenderer via the
  35 // mojom::RendererClient interface.
  36 //
  37 // This class can be created on any thread, where the |remote_renderer| is
  38 // connected and passed in the constructor. Then Initialize() will be called on
  39 // the |task_runner| and starting from that point this class is bound to the
  40 // |task_runner|*. That means all Renderer and RendererClient methods will be
  41 // called/dispached on the |task_runner|. The only exception is GetMediaTime(),
  42 // which can be called on any thread.
  43 class MojoRenderer : public Renderer, public mojom::RendererClient {
  44  public:
  45   MojoRenderer(const scoped_refptr<base::SequencedTaskRunner>& task_runner,
  46                std::unique_ptr<VideoOverlayFactory> video_overlay_factory,
  47                VideoRendererSink* video_renderer_sink,
  48                mojo::PendingRemote<mojom::Renderer> remote_renderer);
  49
  50   MojoRenderer(const MojoRenderer&) = delete;
  51   MojoRenderer& operator=(const MojoRenderer&) = delete;
  52
  53   ~MojoRenderer() override;
  54
  55   // Renderer implementation.
  56   void Initialize(MediaResource* media_resource,
  57                   media::RendererClient* client,
  58                   PipelineStatusCallback init_cb) override;
  59   void SetCdm(CdmContext* cdm_context, CdmAttachedCB cdm_attached_cb) override;
  60   void SetLatencyHint(absl::optional<base::TimeDelta> latency_hint) override;
  61   void Flush(base::OnceClosure flush_cb) override;
  62 #if defined(TIZEN_MULTIMEDIA)
  63   void Seek(base::TimeDelta time, base::OnceClosure seek_cb) override;
  64   void Suspend() override;
  65   void ToggleFullscreenMode(bool is_fullscreen,
  66                             ToggledFullscreenCB cb) override;
  67 #endif
  68   void StartPlayingFrom(base::TimeDelta time) override;
  69   void SetPlaybackRate(double playback_rate) override;
  70   void SetVolume(float volume) override;
  71   base::TimeDelta GetMediaTime() override;
  72   RendererType GetRendererType() override;
  73
  74 #if defined(TIZEN_VIDEO_HOLE)
  75   void SetVideoHole(bool is_video_hole) override;
  76   void SetMediaGeometry(const gfx::RectF& rect) override;
  77 #endif
  78
  79 #if BUILDFLAG(IS_TIZEN_TV)
  80   void SetContentMimeType(const std::string& mime_type) override;
  81   void SetParentalRatingResult(bool is_pass) override;
  82   void SetActiveTextTrack(int id, bool is_in_band) override;
  83   void SetActiveAudioTrack(int index) override;
  84   void SetActiveVideoTrack(int index) override;
  85   void SetPreferTextLanguage(const std::string& lang) override;
  86 #endif
  87
  88  private:
  89   // mojom::RendererClient implementation, dispatched on the |task_runner_|.
  90   void OnTimeUpdate(base::TimeDelta time,
  91                     base::TimeDelta max_time,
  92                     base::TimeTicks capture_time) override;
  93   void OnBufferingStateChange(BufferingState state,
  94                               BufferingStateChangeReason reason) override;
  95   void OnEnded() override;
  96   void OnError(const PipelineStatus& status) override;
  97   void OnAudioConfigChange(const AudioDecoderConfig& config) override;
  98   void OnVideoConfigChange(const VideoDecoderConfig& config) override;
  99   void OnVideoNaturalSizeChange(const gfx::Size& size) override;
 100   void OnVideoOpacityChange(bool opaque) override;
 101   void OnWaiting(WaitingReason reason) override;
 102   void OnStatisticsUpdate(const PipelineStatistics& stats) override;
 103 #if defined(TIZEN_MULTIMEDIA)
 104   void OnRequestSuspend(bool resource_conflicted) override;
 105   void OnRequestSeek(base::TimeDelta time) override;
 106   void OnSeekableTimeChange(base::TimeDelta min_time,
 107                             base::TimeDelta max_time,
 108                             bool is_live) override;
 109   void OnLivePlaybackComplete() override;
 110 #endif
 111
 112   // Binds |remote_renderer_| to the mojo message pipe. Can be called multiple
 113   // times. If an error occurs during connection, OnConnectionError will be
 114   // called asynchronously.
 115   void BindRemoteRendererIfNeeded();
 116
 117   // Initialize the remote renderer when |media_resource| is of type
 118   // MediaResource::Type::STREAM.
 119   void InitializeRendererFromStreams(media::RendererClient* client);
 120
 121   // Initialize the remote renderer when |media_resource| is of type
 122   // MediaResource::Type::URL.
 123   void InitializeRendererFromUrl(media::RendererClient* client);
 124
 125   // Callback for connection error on |remote_renderer_|.
 126   void OnConnectionError();
 127
 128   // Callback for connection error on any of |streams_|. The |stream| parameter
 129   // indicates which stream the error happened on.
 130   void OnDemuxerStreamConnectionError(MojoDemuxerStreamImpl* stream);
 131
 132   // Callbacks for |remote_renderer_| methods.
 133   void OnInitialized(media::RendererClient* client, bool success);
 134   void OnFlushed();
 135   void OnCdmAttached(bool success);
 136
 137 #if defined(TIZEN_MULTIMEDIA)
 138   void OnSeekCompleted();
 139 #endif
 140
 141   void CancelPendingCallbacks();
 142
 143   // |task_runner| on which all methods are invoked, except for GetMediaTime(),
 144   // which can be called on any thread.
 145   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 146
 147   // Overlay factory used to create overlays for video frames rendered
 148   // by the remote renderer.
 149   std::unique_ptr<VideoOverlayFactory> video_overlay_factory_;
 150
 151   // Video frame overlays are rendered onto this sink.
 152   // Rendering of a new overlay is only needed when video natural size changes.
 153   raw_ptr<VideoRendererSink> video_renderer_sink_ = nullptr;
 154
 155   // Provider of audio/video DemuxerStreams. Must be valid throughout the
 156   // lifetime of |this|.
 157   raw_ptr<MediaResource> media_resource_ = nullptr;
 158
 159   // Client of |this| renderer passed in Initialize.
 160   raw_ptr<media::RendererClient> client_ = nullptr;
 161
 162   // Mojo demuxer streams.
 163   // Owned by MojoRenderer instead of remote mojom::Renderer
 164   // because these demuxer streams need to be destroyed as soon as |this| is
 165   // destroyed. The local demuxer streams returned by MediaResource cannot be
 166   // used after |this| is destroyed.
 167   // TODO(alokp): Add tests for MojoDemuxerStreamImpl.
 168   std::vector<std::unique_ptr<MojoDemuxerStreamImpl>> streams_;
 169
 170   // This class is constructed on one thread and used exclusively on another
 171   // thread. This member is used to safely pass the PendingRemote from one
 172   // thread to another. It is set in the constructor and is consumed in
 173   // Initialize().
 174   mojo::PendingRemote<mojom::Renderer> remote_renderer_pending_remote_;
 175
 176   // Remote Renderer, bound to |task_runner_| during Initialize().
 177   mojo::Remote<mojom::Renderer> remote_renderer_;
 178
 179   // Receiver for RendererClient, bound to the |task_runner_|.
 180   mojo::AssociatedReceiver<RendererClient> client_receiver_{this};
 181
 182   bool encountered_error_ = false;
 183
 184   PipelineStatusCallback init_cb_;
 185   base::OnceClosure flush_cb_;
 186   CdmAttachedCB cdm_attached_cb_;
 187
 188 #if defined(TIZEN_MULTIMEDIA)
 189   base::OnceClosure seek_cb_;
 190 #endif
 191
 192   float volume_ = 1.0f;
 193
 194   // Lock used to serialize access for |time_interpolator_|.
 195   mutable base::Lock lock_;
 196   media::TimeDeltaInterpolator media_time_interpolator_;
 197
 198   absl::optional<PipelineStatistics> pending_stats_;
 199 };
 200
 201 }  // namespace media
 202
 203 #endif  // MEDIA_MOJO_CLIENTS_MOJO_RENDERER_H_