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   void OnLivePlaybackComplete() override;
 128 #endif
 129
 130 #if defined(TIZEN_TBM_SUPPORT)
 131   void OnNewTbmFrameAvailable(uint32_t player_id,
 132                               gfx::TbmBufferHandle tbm_handle,
 133                               base::TimeDelta timestamp) override;
 134   void OnTbmBufferExhausted(const gfx::TbmBufferHandle& tbm_handle) override;
 135 #else
 136   void OnNewFrameAvailable(uint32_t playerId,
 137                            base::UnsafeSharedMemoryRegion frame,
 138                            uint32_t size,
 139                            base::TimeDelta timestamp,
 140                            uint32_t width,
 141                            uint32_t height) override;
 142 #endif
 143
 144 #if BUILDFLAG(IS_TIZEN_TV)
 145   content::WebContentsDelegate* GetWebContentsDelegate() const override;
 146 #endif
 147
 148 #if defined(TIZEN_VIDEO_HOLE)
 149   void SetVideoHole(bool is_video_hole) final;
 150   void SetMediaGeometry(const gfx::RectF& rect) final;
 151   gfx::Rect GetViewportRect() const;
 152 #endif
 153
 154 #if BUILDFLAG(IS_TIZEN_TV)
 155   void SetContentMimeType(const std::string& mime_type) override;
 156   void SetParentalRatingResult(bool is_pass) override;
 157 #endif
 158
 159  private:
 160   const float kDefaultVolume = 1.0;
 161
 162   enum State {
 163     STATE_UNINITIALIZED,
 164     STATE_INIT_PENDING_CDM,  // Initialization is waiting for the CDM to be set.
 165     STATE_INITIALIZING,      // Initializing audio/video renderers.
 166     STATE_FLUSHING,          // Flushing is in progress.
 167     STATE_FLUSHED,           // After initialization or after flush completed.
 168     STATE_PLAYING,           // After StartPlayingFrom has been called.
 169     STATE_ERROR
 170   };
 171
 172   void SetStreamInfo();
 173   void SetPlayerVolume();
 174   void SetPlayerInitialize();
 175   void SetPlayerPrepare();
 176 #if defined(TIZEN_VIDEO_HOLE)
 177   void SetPlayerVideoHole();
 178   void SetPlayerMediaGeometry();
 179   void OnWebViewMoved();
 180 #endif
 181   content::WebContents* GetWebContents() const;
 182
 183   media::RendererClient* client_ = nullptr;
 184
 185   State state_ = STATE_UNINITIALIZED;
 186
 187   // Task runner used to execute pipeline tasks.
 188   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 189
 190   media::VideoRendererSink* const sink_ = nullptr;
 191   mojo::Remote<ClientExtension> client_extension_;
 192
 193   int player_id_ = 0;
 194
 195   // Identifiers to find the RenderFrameHost that created |this|.
 196   // NOTE: We store these IDs rather than a RenderFrameHost* because we do not
 197   // know when the RenderFrameHost is destroyed.
 198   int render_process_id_ = 0;
 199   int routing_id_ = 0;
 200
 201   // Temporary callback used for Initialize().
 202   media::PipelineStatusCallback init_cb_;
 203
 204   media::MediaResource* media_resource_ = nullptr;
 205   media::DemuxerStream* audio_stream_ = nullptr;
 206   media::DemuxerStream* video_stream_ = nullptr;
 207
 208   std::unique_ptr<media::MediaPlayerTizen> media_player_;
 209   double volume_ = kDefaultVolume;
 210   double playback_rate_ = 0.0;
 211
 212   // The time to start playback from after starting/seeking has completed.
 213   base::TimeDelta start_time_;
 214
 215   media::BufferingState audio_buffering_state_ = media::BUFFERING_HAVE_NOTHING;
 216   media::BufferingState video_buffering_state_ = media::BUFFERING_HAVE_NOTHING;
 217
 218   // Whether we've received the audio/video ended events.
 219   bool media_ended_ = false;
 220   bool web_contents_muted_ = false;
 221   mojo::Receiver<MediaPlayerRendererExtension> renderer_extension_receiver_;
 222   raw_ptr<content::MediaPlayerRendererWebContentsObserver>
 223       web_contents_observer_ = nullptr;
 224
 225   // Indicates if a serious error has been encountered by the |media_player_|.
 226   bool has_error_ = false;
 227   bool resource_conflicted_ = true;
 228   bool is_suspended_ = false;
 229
 230 #if defined(TIZEN_VIDEO_HOLE)
 231   bool is_video_hole_ = false;
 232   gfx::RectF video_rect_;
 233 #endif
 234
 235 #if BUILDFLAG(IS_TIZEN_TV)
 236   int notify_playback_state_;
 237   // Stores the mime type.  Required for URL streams which are DASH
 238   // content, so that we can set it to the media_player_ before calling
 239   // initialize / prepare.
 240   std::string mime_type_;
 241 #endif
 242
 243   WebContents* web_contents_ = nullptr;
 244
 245   base::WeakPtrFactory<TizenRendererImpl> weak_factory_{this};
 246 };
 247
 248 }  // namespace content
 249
 250 #endif  // MEDIA_RENDERERS_TIZEN_RENDERER_IMPL_H_