tizen_src/chromium_impl/content/browser/media/tizen_renderer_impl.h

   1 // Copyright 2022 Samsung Electronics Inc. All rights reserved.
   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_RENDERERS_TIZEN_RENDERER_IMPL_H_
   6 #define MEDIA_RENDERERS_TIZEN_RENDERER_IMPL_H_
   7
   8 #include <vector>
   9
  10 #include "base/memory/raw_ptr.h"
  11 #include "content/common/content_export.h"
  12 #include "media/base/demuxer_stream.h"
  13 #include "media/base/media_export.h"
  14 #include "media/base/media_resource.h"
  15 #include "media/base/pipeline_status.h"
  16 #include "media/base/renderer.h"
  17 #include "media/base/renderer_client.h"
  18 #include "media/base/video_renderer_sink.h"
  19 #include "media/base/waiting.h"
  20 #include "media/mojo/mojom/renderer_extensions.mojom.h"
  21 #include "mojo/public/cpp/bindings/pending_receiver.h"
  22 #include "mojo/public/cpp/bindings/pending_remote.h"
  23 #include "mojo/public/cpp/bindings/receiver.h"
  24 #include "mojo/public/cpp/bindings/remote.h"
  25 #include "third_party/abseil-cpp/absl/types/optional.h"
  26 #include "ui/gfx/geometry/size.h"
  27
  28 namespace base {
  29 class SingleThreadTaskRunner;
  30 }
  31
  32 namespace media {
  33 class MediaPlayerTizen;
  34 class MediaResource;
  35 }  // namespace media
  36
  37 namespace content {
  38
  39 class WebContents;
  40 class MediaPlayerRendererWebContentsObserver;
  41
  42 class CONTENT_EXPORT TizenRendererImpl
  43     : public media::Renderer,
  44       public media::mojom::MediaPlayerRendererExtension {
  45  public:
  46   using RendererExtension = media::mojom::MediaPlayerRendererExtension;
  47   using ClientExtension = media::mojom::MediaPlayerRendererClientExtension;
  48
  49   TizenRendererImpl(
  50       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
  51       media::VideoRendererSink* sink);
  52   TizenRendererImpl(
  53       int process_id,
  54       int routing_id,
  55       WebContents* web_contents,
  56       mojo::PendingReceiver<RendererExtension> renderer_extension_receiver,
  57       mojo::PendingRemote<ClientExtension> client_extension_remote);
  58   TizenRendererImpl(const TizenRendererImpl&) = delete;
  59   TizenRendererImpl& operator=(const TizenRendererImpl&) = delete;
  60   ~TizenRendererImpl();
  61
  62   // Renderer implementation.
  63   void Initialize(media::MediaResource* media_resource,
  64                   media::RendererClient* client,
  65                   media::PipelineStatusCallback init_cb) override;
  66   void SetCdm(media::CdmContext* cdm_context,
  67               CdmAttachedCB cdm_attached_cb) override;
  68   void SetLatencyHint(absl::optional<base::TimeDelta> latency_hint) override;
  69   void SetPreservesPitch(bool preserves_pitch) override;
  70   void Flush(base::OnceClosure flush_cb) override;
  71   void StartPlayingFrom(base::TimeDelta time) override;
  72   void SetPlaybackRate(double playback_rate) override;
  73   void SetVolume(float volume) override;
  74   base::TimeDelta GetMediaTime() override;
  75   media::RendererType GetRendererType() override;
  76   void OnSelectedVideoTracksChanged(
  77       const std::vector<media::DemuxerStream*>& enabled_tracks,
  78       base::OnceClosure change_completed_cb) override;
  79   void OnEnabledAudioTracksChanged(
  80       const std::vector<media::DemuxerStream*>& enabled_tracks,
  81       base::OnceClosure change_completed_cb) override;
  82   void InitiateScopedSurfaceRequest(
  83       InitiateScopedSurfaceRequestCallback callback) override;
  84   void OnUpdateAudioMutingState(bool muted) {}
  85   void OnWebContentsDestroyed();
  86
  87   // Should be removed.
  88   void Seek(base::TimeDelta time, base::OnceClosure seek_cb);
  89
  90   void Suspend() override;
  91
  92   void ToggleFullscreenMode(bool is_fullscreen, ToggledFullscreenCB cb) final;
  93
  94   // Proxy functions for MediaPlayerRendererClientExtension
  95   void OnVideoSizeChange(const gfx::Size& size);
  96   void OnDurationChange(base::TimeDelta duration);
  97   void OnBufferUpdate(base::TimeDelta time);
  98
  99 #if defined(TIZEN_VIDEO_HOLE)
 100   void SetVideoHole(bool is_video_hole) final;
 101   void SetMediaGeometry(const gfx::RectF& rect) final;
 102
 103   gfx::Rect GetViewportRect() const;
 104 #endif
 105
 106   void OnNewFrameAvailable(uint32_t playerId,
 107                            base::UnsafeSharedMemoryRegion frame,
 108                            uint32_t size,
 109                            base::TimeDelta timestamp,
 110                            uint32_t width,
 111                            uint32_t height);
 112
 113 #if defined(TIZEN_TBM_SUPPORT)
 114   void OnNewTbmFrameAvailable(uint32_t player_id,
 115                               gfx::TbmBufferHandle tbm_handle,
 116                               base::TimeDelta timestamp);
 117   void OnTbmBufferExhausted(const gfx::TbmBufferHandle& tbm_handle) override;
 118 #endif
 119
 120   void OnRequestSuspend(bool resource_conflict);
 121
 122  private:
 123   class RendererClientInternal;
 124   const float kDefaultVolume = 1.0;
 125
 126   enum State {
 127     STATE_UNINITIALIZED,
 128     STATE_INIT_PENDING_CDM,  // Initialization is waiting for the CDM to be set.
 129     STATE_INITIALIZING,      // Initializing audio/video renderers.
 130     STATE_FLUSHING,          // Flushing is in progress.
 131     STATE_FLUSHED,           // After initialization or after flush completed.
 132     STATE_PLAYING,           // After StartPlayingFrom has been called.
 133     STATE_ERROR
 134   };
 135
 136   void SetStreamInfo();
 137   void SetPlayerVolume();
 138 #if defined(TIZEN_VIDEO_HOLE)
 139   void SetPlayerVideoHole();
 140   void SetPlayerMediaGeometry();
 141   void OnWebViewMoved();
 142 #endif
 143   void OnRendererEnded();
 144   void OnError(media::PipelineStatus error);
 145   void OnStatisticsUpdate(const media::PipelineStatistics& stats);
 146   void OnBufferingStateChange(media::BufferingState new_buffering_state,
 147                               media::BufferingStateChangeReason reason);
 148   void OnWaiting(media::WaitingReason reason);
 149   void OnAudioConfigChange(const media::AudioDecoderConfig& config);
 150   void OnVideoConfigChange(const media::VideoDecoderConfig& config);
 151   void OnVideoNaturalSizeChange(const gfx::Size& size);
 152   void OnVideoOpacityChange(bool opaque);
 153   void OnVideoFrameRateChange(absl::optional<int> fps);
 154
 155   void OnRequestSeek(base::TimeDelta time);
 156
 157   media::RendererClient* client_ = nullptr;
 158
 159   State state_ = STATE_UNINITIALIZED;
 160
 161   // Task runner used to execute pipeline tasks.
 162   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 163
 164   media::VideoRendererSink* const sink_ = nullptr;
 165   mojo::Remote<ClientExtension> client_extension_;
 166
 167   int player_id_ = 0;
 168
 169   // Identifiers to find the RenderFrameHost that created |this|.
 170   // NOTE: We store these IDs rather than a RenderFrameHost* because we do not
 171   // know when the RenderFrameHost is destroyed.
 172   int render_process_id_ = 0;
 173   int routing_id_ = 0;
 174
 175   // Temporary callback used for Initialize().
 176   media::PipelineStatusCallback init_cb_;
 177
 178   std::unique_ptr<RendererClientInternal> audio_renderer_client_;
 179   std::unique_ptr<RendererClientInternal> video_renderer_client_;
 180
 181   media::MediaResource* media_resource_ = nullptr;
 182   media::DemuxerStream* audio_stream_ = nullptr;
 183   media::DemuxerStream* video_stream_ = nullptr;
 184
 185   std::unique_ptr<media::MediaPlayerTizen> media_player_;
 186   double volume_ = kDefaultVolume;
 187   double playback_rate_ = 0.0;
 188
 189   // The time to start playback from after starting/seeking has completed.
 190   base::TimeDelta start_time_;
 191
 192   media::BufferingState audio_buffering_state_ = media::BUFFERING_HAVE_NOTHING;
 193   media::BufferingState video_buffering_state_ = media::BUFFERING_HAVE_NOTHING;
 194
 195   // Whether we've received the audio/video ended events.
 196   bool media_ended_ = false;
 197   bool web_contents_muted_ = false;
 198   mojo::Receiver<MediaPlayerRendererExtension> renderer_extension_receiver_;
 199   raw_ptr<content::MediaPlayerRendererWebContentsObserver>
 200       web_contents_observer_ = nullptr;
 201
 202   // Indicates if a serious error has been encountered by the |media_player_|.
 203   bool has_error_ = false;
 204   bool resource_conflicted_ = true;
 205   bool is_suspended_ = false;
 206
 207 #if defined(TIZEN_VIDEO_HOLE)
 208   bool is_video_hole_ = false;
 209   gfx::RectF video_rect_;
 210 #endif
 211
 212   WebContents* web_contents_ = nullptr;
 213
 214   base::WeakPtrFactory<TizenRendererImpl> weak_factory_{this};
 215 };
 216
 217 }  // namespace content
 218
 219 #endif  // MEDIA_RENDERERS_TIZEN_RENDERER_IMPL_H_