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 "tizen_src/chromium_impl/media/filters/media_player_tizen_client.h"
  27 #include "ui/gfx/geometry/size.h"
  28
  29 namespace base {
  30 class SingleThreadTaskRunner;
  31 }
  32
  33 namespace media {
  34 class MediaPlayerTizen;
  35 class MediaResource;
  36 }  // namespace media
  37
  38 namespace content {
  39
  40 class WebContents;
  41 class MediaPlayerRendererWebContentsObserver;
  42
  43 class CONTENT_EXPORT TizenRendererImpl
  44     : public media::Renderer,
  45       public media::mojom::MediaPlayerRendererExtension,
  46       public media::MediaPlayerTizenClient {
  47  public:
  48   using RendererExtension = media::mojom::MediaPlayerRendererExtension;
  49   using ClientExtension = media::mojom::MediaPlayerRendererClientExtension;
  50
  51   TizenRendererImpl(
  52       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
  53       media::VideoRendererSink* sink);
  54   TizenRendererImpl(
  55       int process_id,
  56       int routing_id,
  57       WebContents* web_contents,
  58       mojo::PendingReceiver<RendererExtension> renderer_extension_receiver,
  59       mojo::PendingRemote<ClientExtension> client_extension_remote);
  60   TizenRendererImpl(const TizenRendererImpl&) = delete;
  61   TizenRendererImpl& operator=(const TizenRendererImpl&) = delete;
  62   ~TizenRendererImpl();
  63
  64   // Renderer implementation.
  65   void Initialize(media::MediaResource* media_resource,
  66                   media::RendererClient* client,
  67                   media::PipelineStatusCallback init_cb) override;
  68   void SetCdm(media::CdmContext* cdm_context,
  69               CdmAttachedCB cdm_attached_cb) override;
  70   void SetLatencyHint(absl::optional<base::TimeDelta> latency_hint) override;
  71   void SetPreservesPitch(bool preserves_pitch) override;
  72   void Flush(base::OnceClosure flush_cb) override;
  73   void StartPlayingFrom(base::TimeDelta time) override;
  74   void SetPlaybackRate(double playback_rate) override;
  75   void SetVolume(float volume) override;
  76   base::TimeDelta GetMediaTime() override;
  77   media::RendererType GetRendererType() override;
  78   void OnSelectedVideoTracksChanged(
  79       const std::vector<media::DemuxerStream*>& enabled_tracks,
  80       base::OnceClosure change_completed_cb) override;
  81   void OnEnabledAudioTracksChanged(
  82       const std::vector<media::DemuxerStream*>& enabled_tracks,
  83       base::OnceClosure change_completed_cb) override;
  84   void InitiateScopedSurfaceRequest(
  85       InitiateScopedSurfaceRequestCallback callback) override;
  86   void OnUpdateAudioMutingState(bool muted) {}
  87   void OnWebContentsDestroyed();
  88
  89   void Seek(base::TimeDelta time, base::OnceClosure seek_cb);
  90
  91   void Suspend() override;
  92
  93   void ToggleFullscreenMode(bool is_fullscreen, ToggledFullscreenCB cb) final;
  94
  95   // MediaPlayerTizenClient implementation.
  96   void OnError(media::PipelineStatus error) override;
  97   void OnFallback(media::PipelineStatus fallback) override {}
  98   void OnEnded() override;
  99   void OnStatisticsUpdate(const media::PipelineStatistics& stats) override;
 100   void OnSeekableTimeChange(base::TimeDelta min_time,
 101                             base::TimeDelta max_time,
 102                             bool is_live) override;
 103   void OnBufferingStateChange(
 104       media::BufferingState new_buffering_state,
 105       media::BufferingStateChangeReason reason) override;
 106   void OnWaiting(media::WaitingReason reason) override;
 107   void OnAudioConfigChange(const media::AudioDecoderConfig& config) override;
 108   void OnVideoConfigChange(const media::VideoDecoderConfig& config) override;
 109   void OnVideoNaturalSizeChange(const gfx::Size& size) override;
 110   void OnVideoOpacityChange(bool opaque) override;
 111   void OnVideoFrameRateChange(absl::optional<int> fps) override;
 112   void OnRequestSeek(base::TimeDelta time) override;
 113   void OnRequestSuspend(bool resource_conflict) override;
 114   void OnVideoSizeChange(const gfx::Size& size) override;
 115   void OnDurationChange(base::TimeDelta duration) override;
 116   void OnBufferUpdate(base::TimeDelta time) override;
 117
 118 #if BUILDFLAG(IS_TIZEN_TV)
 119   bool PlaybackNotificationEnabled();
 120   void NotifyPlaybackState(int state,
 121                            int player_id = 0,
 122                            const std::string& url = "",
 123                            const std::string& mime_type = "",
 124                            bool* media_resource_acquired = NULL,
 125                            std::string* translated_url = NULL,
 126                            std::string* drm_info = NULL) override;
 127 #endif
 128
 129 #if defined(TIZEN_TBM_SUPPORT)
 130   void OnNewTbmFrameAvailable(uint32_t player_id,
 131                               gfx::TbmBufferHandle tbm_handle,
 132                               base::TimeDelta timestamp) override;
 133   void OnTbmBufferExhausted(const gfx::TbmBufferHandle& tbm_handle) override;
 134 #else
 135   void OnNewFrameAvailable(uint32_t playerId,
 136                            base::UnsafeSharedMemoryRegion frame,
 137                            uint32_t size,
 138                            base::TimeDelta timestamp,
 139                            uint32_t width,
 140                            uint32_t height) override;
 141 #endif
 142
 143 #if BUILDFLAG(IS_TIZEN_TV)
 144   content::WebContentsDelegate* GetWebContentsDelegate() const override;
 145 #endif
 146
 147 #if defined(TIZEN_VIDEO_HOLE)
 148   void SetVideoHole(bool is_video_hole) final;
 149   void SetMediaGeometry(const gfx::RectF& rect) final;
 150   gfx::Rect GetViewportRect() const;
 151 #endif
 152
 153 #if BUILDFLAG(IS_TIZEN_TV)
 154   void SetContentMimeType(const std::string& mime_type) override;
 155 #endif
 156
 157  private:
 158   const float kDefaultVolume = 1.0;
 159
 160   enum State {
 161     STATE_UNINITIALIZED,
 162     STATE_INIT_PENDING_CDM,  // Initialization is waiting for the CDM to be set.
 163     STATE_INITIALIZING,      // Initializing audio/video renderers.
 164     STATE_FLUSHING,          // Flushing is in progress.
 165     STATE_FLUSHED,           // After initialization or after flush completed.
 166     STATE_PLAYING,           // After StartPlayingFrom has been called.
 167     STATE_ERROR
 168   };
 169
 170   void SetStreamInfo();
 171   void SetPlayerVolume();
 172   void SetPlayerInitialize();
 173   void SetPlayerPrepare();
 174 #if defined(TIZEN_VIDEO_HOLE)
 175   void SetPlayerVideoHole();
 176   void SetPlayerMediaGeometry();
 177   void OnWebViewMoved();
 178 #endif
 179   content::WebContents* GetWebContents() const;
 180
 181   media::RendererClient* client_ = nullptr;
 182
 183   State state_ = STATE_UNINITIALIZED;
 184
 185   // Task runner used to execute pipeline tasks.
 186   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 187
 188   media::VideoRendererSink* const sink_ = nullptr;
 189   mojo::Remote<ClientExtension> client_extension_;
 190
 191   int player_id_ = 0;
 192
 193   // Identifiers to find the RenderFrameHost that created |this|.
 194   // NOTE: We store these IDs rather than a RenderFrameHost* because we do not
 195   // know when the RenderFrameHost is destroyed.
 196   int render_process_id_ = 0;
 197   int routing_id_ = 0;
 198
 199   // Temporary callback used for Initialize().
 200   media::PipelineStatusCallback init_cb_;
 201
 202   media::MediaResource* media_resource_ = nullptr;
 203   media::DemuxerStream* audio_stream_ = nullptr;
 204   media::DemuxerStream* video_stream_ = nullptr;
 205
 206   std::unique_ptr<media::MediaPlayerTizen> media_player_;
 207   double volume_ = kDefaultVolume;
 208   double playback_rate_ = 0.0;
 209
 210   // The time to start playback from after starting/seeking has completed.
 211   base::TimeDelta start_time_;
 212
 213   media::BufferingState audio_buffering_state_ = media::BUFFERING_HAVE_NOTHING;
 214   media::BufferingState video_buffering_state_ = media::BUFFERING_HAVE_NOTHING;
 215
 216   // Whether we've received the audio/video ended events.
 217   bool media_ended_ = false;
 218   bool web_contents_muted_ = false;
 219   mojo::Receiver<MediaPlayerRendererExtension> renderer_extension_receiver_;
 220   raw_ptr<content::MediaPlayerRendererWebContentsObserver>
 221       web_contents_observer_ = nullptr;
 222
 223   // Indicates if a serious error has been encountered by the |media_player_|.
 224   bool has_error_ = false;
 225   bool resource_conflicted_ = true;
 226   bool is_suspended_ = false;
 227
 228 #if defined(TIZEN_VIDEO_HOLE)
 229   bool is_video_hole_ = false;
 230   gfx::RectF video_rect_;
 231 #endif
 232
 233 #if BUILDFLAG(IS_TIZEN_TV)
 234   int notify_playback_state_;
 235   // Stores the mime type.  Required for URL streams which are DASH
 236   // content, so that we can set it to the media_player_ before calling
 237   // initialize / prepare.
 238   std::string mime_type_;
 239 #endif
 240
 241   WebContents* web_contents_ = nullptr;
 242
 243   base::WeakPtrFactory<TizenRendererImpl> weak_factory_{this};
 244 };
 245
 246 }  // namespace content
 247
 248 #endif  // MEDIA_RENDERERS_TIZEN_RENDERER_IMPL_H_