namespace content {
-class TizenRendererImpl::RendererClientInternal final
- : public media::RendererClient,
- public media::MediaPlayerTizenClientExtension {
- public:
- RendererClientInternal(media::DemuxerStream::Type type,
- TizenRendererImpl* renderer)
- : type_(type), renderer_(renderer) {
- DCHECK((type_ == media::DemuxerStream::AUDIO) ||
- (type_ == media::DemuxerStream::VIDEO));
- }
-
- void OnError(media::PipelineStatus error) override {
- renderer_->OnError(error);
- }
-
- // Callback executed when there is a fallback somewhere in the pipeline which
- // should be recorded for metrics analysis.
- void OnFallback(media::PipelineStatus fallback) override {}
-
- void OnEnded() override { renderer_->OnRendererEnded(); }
-
- void OnStatisticsUpdate(const media::PipelineStatistics& stats) override {
- renderer_->OnStatisticsUpdate(stats);
- }
-
- void OnBufferingStateChange(
- media::BufferingState state,
- media::BufferingStateChangeReason reason) override {
- renderer_->OnBufferingStateChange(state, reason);
- }
-
- void OnWaiting(media::WaitingReason reason) override {
- renderer_->OnWaiting(reason);
- }
-
- void OnAudioConfigChange(const media::AudioDecoderConfig& config) override {
- renderer_->OnAudioConfigChange(config);
- }
-
- void OnVideoConfigChange(const media::VideoDecoderConfig& config) override {
- renderer_->OnVideoConfigChange(config);
- }
-
- void OnVideoNaturalSizeChange(const gfx::Size& size) override {
- DCHECK(type_ == media::DemuxerStream::VIDEO);
- renderer_->OnVideoNaturalSizeChange(size);
- }
-
- void OnVideoOpacityChange(bool opaque) override {
- DCHECK(type_ == media::DemuxerStream::VIDEO);
- renderer_->OnVideoOpacityChange(opaque);
- }
-
- void OnVideoFrameRateChange(absl::optional<int> fps) override {
- DCHECK(type_ == media::DemuxerStream::VIDEO);
- renderer_->OnVideoFrameRateChange(fps);
- }
-
- // MediaPlayerTizenClientExtension implementation
- void OnVideoSizeChange(const gfx::Size& size) override {
- renderer_->OnVideoSizeChange(size);
- }
-
- void OnDurationChange(base::TimeDelta duration) override {
- renderer_->OnDurationChange(duration);
- }
-
- void OnBufferUpdate(base::TimeDelta time) override {
- renderer_->OnBufferUpdate(time);
- }
-
-#if defined(TIZEN_TBM_SUPPORT)
- void OnNewTbmFrameAvailable(uint32_t player_id,
- const gfx::TbmBufferHandle& tbm_handle,
- base::TimeDelta timestamp) override {
- DCHECK(type_ == media::DemuxerStream::VIDEO);
- renderer_->OnNewTbmFrameAvailable(player_id, tbm_handle, timestamp);
- }
-#else
- void OnNewFrameAvailable(uint32_t playerId,
- base::UnsafeSharedMemoryRegion frame,
- uint32_t size,
- base::TimeDelta timestamp,
- uint32_t width,
- uint32_t height) override {
- renderer_->OnNewFrameAvailable(playerId, std::move(frame), size, timestamp,
- width, height);
- }
-#endif
-
- private:
- media::DemuxerStream::Type type_;
- TizenRendererImpl* renderer_;
-};
-
TizenRendererImpl::TizenRendererImpl(
int process_id,
int routing_id,
media::MediaPlayerRegistry::GetInstance()->UnregisterMediaPlayer(player_id_);
- if (media_player_)
+ if (media_player_) {
media_player_->Release();
+ media_player_->SetMediaPlayerClient(nullptr);
+ }
if (web_contents_observer_)
web_contents_observer_->RemoveMediaPlayerRenderer(this);
// TODO: return unsupported error for CDM.
std::move(init_cb_).Run(media::PIPELINE_OK);
+
+ media_player_->SetMediaPlayerClient(this);
media_player_->SetTaskRunner(task_runner_.get());
}
void TizenRendererImpl::SetStreamInfo() {
if (media_resource_->GetType() == media::MediaResource::Type::KUrl) {
- video_renderer_client_ = std::make_unique<RendererClientInternal>(
- media::DemuxerStream::VIDEO, this);
- media_player_->SetStreamInfo(media::DemuxerStream::VIDEO, 0,
- video_renderer_client_.get());
- media_player_->SetRendererClientExtension(video_renderer_client_.get());
+ media_player_->SetStreamInfo(media::DemuxerStream::VIDEO, 0);
return;
}
- if (audio_stream_) {
- audio_renderer_client_ = std::make_unique<RendererClientInternal>(
- media::DemuxerStream::AUDIO, this);
- media_player_->SetStreamInfo(media::DemuxerStream::AUDIO, audio_stream_,
- audio_renderer_client_.get());
- }
-
- if (video_stream_) {
- video_renderer_client_ = std::make_unique<RendererClientInternal>(
- media::DemuxerStream::VIDEO, this);
- media_player_->SetStreamInfo(media::DemuxerStream::VIDEO, video_stream_,
- video_renderer_client_.get());
-
- // Will be removed later by using |ClientExtention| interface.
-#if defined(TIZEN_TBM_SUPPORT)
- media_player_->SetFrameAvailableCallback(base::BindRepeating(
- &TizenRendererImpl::OnNewTbmFrameAvailable, base::Unretained(this)));
-#else
- media_player_->SetFrameAvailableCallback(base::BindRepeating(
- &TizenRendererImpl::OnNewFrameAvailable, base::Unretained(this)));
-#endif
- }
-
- media_player_->SetRequestSuspendCallback(base::BindRepeating(
- &TizenRendererImpl::OnRequestSuspend, base::Unretained(this)));
-
- media_player_->SetRequestSeekCallback(base::BindRepeating(
- &TizenRendererImpl::OnRequestSeek, base::Unretained(this)));
+ if (audio_stream_)
+ media_player_->SetStreamInfo(media::DemuxerStream::AUDIO, audio_stream_);
+ if (video_stream_)
+ media_player_->SetStreamInfo(media::DemuxerStream::VIDEO, video_stream_);
}
void TizenRendererImpl::SetCdm(media::CdmContext* cdm_context,
NOTIMPLEMENTED();
}
-void TizenRendererImpl::OnNewFrameAvailable(
- uint32_t playerId,
- base::UnsafeSharedMemoryRegion frame,
- uint32_t size,
- base::TimeDelta timestamp,
- uint32_t width,
- uint32_t height) {
- client_extension_->OnNewFrameAvailable(playerId, std::move(frame), size,
- timestamp, width, height);
-}
-
void TizenRendererImpl::Flush(base::OnceClosure flush_cb) {
DCHECK(task_runner_->BelongsToCurrentThread());
TRACE_EVENT_ASYNC_BEGIN0("media", "TizenRendererImpl::Flush", this);
std::move(cb).Run();
}
-void TizenRendererImpl::OnRequestSuspend(bool resource_conflicted) {
- LOG(INFO) << "(" << static_cast<void*>(this) << ") " << __func__;
- resource_conflicted_ = resource_conflicted;
- media::MediaPlayerRegistry::GetInstance()->DeactivateMediaPlayer(
- player_id_, !resource_conflicted_);
- is_suspended_ = true;
- client_->OnRequestSuspend();
-}
-
void TizenRendererImpl::StartPlayingFrom(base::TimeDelta time) {
LOG(INFO) << "(" << static_cast<void*>(this) << ") " << __func__
<< " time : " << time.InMicroseconds();
web_contents_observer_ = nullptr;
}
-void TizenRendererImpl::OnRendererEnded() {
+void TizenRendererImpl::OnEnded() {
playback_rate_ = 0.0;
client_->OnEnded();
}
client_->OnRequestSeek(time);
}
+void TizenRendererImpl::OnRequestSuspend(bool resource_conflicted) {
+ LOG(INFO) << "(" << static_cast<void*>(this) << ") " << __func__;
+ resource_conflicted_ = resource_conflicted;
+ media::MediaPlayerRegistry::GetInstance()->DeactivateMediaPlayer(
+ player_id_, !resource_conflicted_);
+ is_suspended_ = true;
+ client_->OnRequestSuspend();
+}
+
#if defined(TIZEN_TBM_SUPPORT)
void TizenRendererImpl::OnNewTbmFrameAvailable(uint32_t player_id,
gfx::TbmBufferHandle tbm_handle,
media_player_->DestroyMediaPacket(
reinterpret_cast<void*>(tbm_handle.media_packet));
}
+#else
+void TizenRendererImpl::OnNewFrameAvailable(
+ uint32_t playerId,
+ base::UnsafeSharedMemoryRegion frame,
+ uint32_t size,
+ base::TimeDelta timestamp,
+ uint32_t width,
+ uint32_t height) {
+ client_extension_->OnNewFrameAvailable(playerId, std::move(frame), size,
+ timestamp, width, height);
+}
#endif
} // namespace content
#include "mojo/public/cpp/bindings/receiver.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "tizen_src/chromium_impl/media/filters/media_player_tizen_client.h"
#include "ui/gfx/geometry/size.h"
namespace base {
class CONTENT_EXPORT TizenRendererImpl
: public media::Renderer,
- public media::mojom::MediaPlayerRendererExtension {
+ public media::mojom::MediaPlayerRendererExtension,
+ public media::MediaPlayerTizenClient {
public:
using RendererExtension = media::mojom::MediaPlayerRendererExtension;
using ClientExtension = media::mojom::MediaPlayerRendererClientExtension;
void OnUpdateAudioMutingState(bool muted) {}
void OnWebContentsDestroyed();
- // Should be removed.
void Seek(base::TimeDelta time, base::OnceClosure seek_cb);
void Suspend() override;
void ToggleFullscreenMode(bool is_fullscreen, ToggledFullscreenCB cb) final;
- // Proxy functions for MediaPlayerRendererClientExtension
- void OnVideoSizeChange(const gfx::Size& size);
- void OnDurationChange(base::TimeDelta duration);
- void OnBufferUpdate(base::TimeDelta time);
-
-#if defined(TIZEN_VIDEO_HOLE)
- void SetVideoHole(bool is_video_hole) final;
- void SetMediaGeometry(const gfx::RectF& rect) final;
-
- gfx::Rect GetViewportRect() const;
-#endif
-
+ // MediaPlayerTizenClient implementation.
+ void OnError(media::PipelineStatus error) override;
+ void OnFallback(media::PipelineStatus fallback) override {}
+ void OnEnded() override;
+ void OnStatisticsUpdate(const media::PipelineStatistics& stats) override;
+ void OnBufferingStateChange(
+ media::BufferingState new_buffering_state,
+ media::BufferingStateChangeReason reason) override;
+ void OnWaiting(media::WaitingReason reason) override;
+ void OnAudioConfigChange(const media::AudioDecoderConfig& config) override;
+ void OnVideoConfigChange(const media::VideoDecoderConfig& config) override;
+ void OnVideoNaturalSizeChange(const gfx::Size& size) override;
+ void OnVideoOpacityChange(bool opaque) override;
+ void OnVideoFrameRateChange(absl::optional<int> fps) override;
+ void OnRequestSeek(base::TimeDelta time) override;
+ void OnRequestSuspend(bool resource_conflict) override;
+ void OnVideoSizeChange(const gfx::Size& size) override;
+ void OnDurationChange(base::TimeDelta duration) override;
+ void OnBufferUpdate(base::TimeDelta time) override;
+#if defined(TIZEN_TBM_SUPPORT)
+ void OnNewTbmFrameAvailable(uint32_t player_id,
+ gfx::TbmBufferHandle tbm_handle,
+ base::TimeDelta timestamp) override;
+ void OnTbmBufferExhausted(const gfx::TbmBufferHandle& tbm_handle) override;
+#else
void OnNewFrameAvailable(uint32_t playerId,
base::UnsafeSharedMemoryRegion frame,
uint32_t size,
base::TimeDelta timestamp,
uint32_t width,
- uint32_t height);
-
-#if defined(TIZEN_TBM_SUPPORT)
- void OnNewTbmFrameAvailable(uint32_t player_id,
- gfx::TbmBufferHandle tbm_handle,
- base::TimeDelta timestamp);
- void OnTbmBufferExhausted(const gfx::TbmBufferHandle& tbm_handle) override;
+ uint32_t height) override;
#endif
- void OnRequestSuspend(bool resource_conflict);
+#if defined(TIZEN_VIDEO_HOLE)
+ void SetVideoHole(bool is_video_hole) final;
+ void SetMediaGeometry(const gfx::RectF& rect) final;
+ gfx::Rect GetViewportRect() const;
+#endif
private:
- class RendererClientInternal;
const float kDefaultVolume = 1.0;
enum State {
void SetPlayerMediaGeometry();
void OnWebViewMoved();
#endif
- void OnRendererEnded();
- void OnError(media::PipelineStatus error);
- void OnStatisticsUpdate(const media::PipelineStatistics& stats);
- void OnBufferingStateChange(media::BufferingState new_buffering_state,
- media::BufferingStateChangeReason reason);
- void OnWaiting(media::WaitingReason reason);
- void OnAudioConfigChange(const media::AudioDecoderConfig& config);
- void OnVideoConfigChange(const media::VideoDecoderConfig& config);
- void OnVideoNaturalSizeChange(const gfx::Size& size);
- void OnVideoOpacityChange(bool opaque);
- void OnVideoFrameRateChange(absl::optional<int> fps);
-
- void OnRequestSeek(base::TimeDelta time);
media::RendererClient* client_ = nullptr;
// Temporary callback used for Initialize().
media::PipelineStatusCallback init_cb_;
- std::unique_ptr<RendererClientInternal> audio_renderer_client_;
- std::unique_ptr<RendererClientInternal> video_renderer_client_;
-
media::MediaResource* media_resource_ = nullptr;
media::DemuxerStream* audio_stream_ = nullptr;
media::DemuxerStream* video_stream_ = nullptr;
#include "media/base/buffering_state.h"
#include "media/base/efl/media_player_util_efl.h"
#include "third_party/libyuv/include/libyuv/planar_functions.h"
+#include "tizen_src/chromium_impl/media/filters/media_player_tizen_client.h"
#include "ui/gfx/geometry/size.h"
#if defined(TIZEN_VIDEO_HOLE)
StopCurrentTimeUpdateTimer();
OnTimeUpdate(player_id_, GetCurrentTime());
OnTimeChanged(player_id_);
- renderer_client_->OnEnded();
+ GetMediaPlayerClient()->OnEnded();
}
void MediaPlayerBridgeCapi::SeekCompleteUpdate() {
default:
NOTREACHED();
}
- renderer_client_->OnBufferingStateChange(buffer_state, reason);
+ GetMediaPlayerClient()->OnBufferingStateChange(buffer_state, reason);
}
void MediaPlayerBridgeCapi::OnNetworkStateChange(
<< " width : " << width << " ; height : " << height;
width_ = width;
height_ = height;
- renderer_client_->OnVideoNaturalSizeChange(gfx::Size(width, height));
+ GetMediaPlayerClient()->OnVideoNaturalSizeChange(gfx::Size(width, height));
}
void MediaPlayerBridgeCapi::OnTimeChanged(int player_id) {}
void MediaPlayerBridgeCapi::OnTimeUpdate(int player_id,
base::TimeDelta current_time) {
// Move to OnSeekStateChange?
- renderer_client_->OnBufferingStateChange(
+ GetMediaPlayerClient()->OnBufferingStateChange(
media::BUFFERING_HAVE_ENOUGH, media::BUFFERING_CHANGE_REASON_UNKNOWN);
}
void MediaPlayerBridgeCapi::OnDurationChange(int player_id, double duration) {
- client_extension_->OnDurationChange(base::Seconds(duration));
+ GetMediaPlayerClient()->OnDurationChange(base::Seconds(duration));
}
void MediaPlayerBridgeCapi::OnBufferUpdate(
int player_id,
std::vector<TimeRanges> buffer_range) {
TimeRanges range = buffer_range.at(0);
- client_extension_->OnBufferUpdate(base::Microseconds(range.end));
+ GetMediaPlayerClient()->OnBufferUpdate(base::Microseconds(range.end));
}
void MediaPlayerBridgeCapi::SetMediaType(DemuxerStream::Type type) {
SetMediaType(GetMediaType() | MediaType::Video);
}
-void MediaPlayerBridgeCapi::SetStreamInfo(DemuxerStream::Type /*type*/,
- DemuxerStream* /*stream*/,
- RendererClient* client) {
- renderer_client_ = client;
-}
-
-void MediaPlayerBridgeCapi::SetRendererClientExtension(
- media::MediaPlayerTizenClientExtension* client_extension) {
- client_extension_ = client_extension;
-}
-
PlayerRoleFlags MediaPlayerBridgeCapi::GetRoles() const noexcept {
return PlayerRole::UrlBased;
}
int player_id,
gfx::TbmBufferHandle tbm_handle,
base::TimeDelta timestamp) {
- DCHECK(client_extension_);
+ DCHECK(GetMediaPlayerClient());
void* media_packet = reinterpret_cast<void*>(tbm_handle.media_packet);
tbm_handle.media_packet = reinterpret_cast<uint64_t>(media_packet);
tbm_handle.width = width_;
tbm_handle.height = height_;
- client_extension_->OnNewTbmFrameAvailable(player_id, tbm_handle, timestamp);
+ GetMediaPlayerClient()->OnNewTbmFrameAvailable(player_id, tbm_handle,
+ timestamp);
}
#else
void MediaPlayerBridgeCapi::OnNewFrameAvailable(
typedef struct media_packet_s* media_packet_h;
namespace media {
-class RendererClient;
+class MediaPlayerTizenClient;
class MEDIA_EXPORT MediaPlayerBridgeCapi : public MediaPlayerTizen {
public:
void SetRate(double rate) override;
void Seek(base::TimeDelta time, base::OnceClosure seek_cb) override;
void SetVolume(double volume) override;
- void SetStreamInfo(DemuxerStream::Type type,
- DemuxerStream* stream,
- RendererClient* client) override;
- void SetRendererClientExtension(
- media::MediaPlayerTizenClientExtension* client_extension) override;
+ void SetStreamInfo(DemuxerStream::Type type, DemuxerStream* stream) override {
+ }
base::TimeDelta GetCurrentTime() override;
MediaTypeFlags GetMediaType() const override { return media_type_; }
void SetMediaType(DemuxerStream::Type type) override;
PlayerRoleFlags GetRoles() const noexcept override;
void SetTaskRunner(
const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) override;
- void SetFrameAvailableCallback(const DataRequestCB& datacb) override{};
+ void SetMediaPlayerClient(MediaPlayerTizenClient* client) override {
+ client_ = client;
+ }
#if defined(TIZEN_VIDEO_HOLE)
void SetVideoHole(bool is_video_hole) override;
uint32_t length,
base::TimeDelta timestamp);
#endif
+ MediaPlayerTizenClient* GetMediaPlayerClient() const { return client_; }
private:
// |duration_update_timer_| related
player_state_e GetPlayerState();
- private:
scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
- RendererClient* renderer_client_ = nullptr;
- MediaPlayerTizenClientExtension* client_extension_ = nullptr;
+ MediaPlayerTizenClient* client_ = nullptr;
player_h player_{nullptr};
GURL url_;
#include "base/functional/callback.h"
#include "base/location.h"
#include "base/logging.h"
+#include "media/base/buffering_state.h"
#include "media/base/decoder_buffer.h"
-#include "media/base/renderer_client.h"
#include "third_party/libyuv/include/libyuv/convert.h"
#include "tizen_src/chromium_impl/media/filters/esplusplayer_buffer_observer_impl.h"
+#include "tizen_src/chromium_impl/media/filters/media_player_tizen_client.h"
#if defined(TIZEN_VIDEO_HOLE)
#include <Ecore_Wl2.h>
}
void MediaPlayerESPlusPlayer::SetStreamInfo(DemuxerStream::Type type,
- DemuxerStream* stream,
- RendererClient* client) {
+ DemuxerStream* stream) {
if (!esplayer_) {
LOG(ERROR) << "Invalid player handle. Send error to client.";
- client->OnError(PIPELINE_ERROR_INITIALIZATION_FAILED);
+ GetMediaPlayerClient()->OnError(PIPELINE_ERROR_INITIALIZATION_FAILED);
return;
}
SetDemuxerStream(type, stream);
- SetRendererClient(type, client);
InitializeStreamConfig(type);
}
-void MediaPlayerESPlusPlayer::SetRendererClientExtension(
- media::MediaPlayerTizenClientExtension* client_extension) {
- NOTIMPLEMENTED();
-}
-
void MediaPlayerESPlusPlayer::Prepare() {
LOG(INFO) << "(" << static_cast<void*>(this) << ") " << __func__;
if (is_prepared_ || is_preparing_)
<< esplusplayer_get_error_string(
static_cast<esplusplayer_error_type>(error));
- if (IsValid(DemuxerStream::AUDIO))
- GetRendererClient(DemuxerStream::AUDIO)
- ->OnError(PIPELINE_ERROR_INITIALIZATION_FAILED);
- else if (IsValid(DemuxerStream::VIDEO))
- GetRendererClient(DemuxerStream::VIDEO)
- ->OnError(PIPELINE_ERROR_INITIALIZATION_FAILED);
+ GetMediaPlayerClient()->OnError(PIPELINE_ERROR_INITIALIZATION_FAILED);
return;
}
is_preparing_ = true;
GetBufferQueue(DemuxerStream::VIDEO).clear();
GetBufferQueue(DemuxerStream::AUDIO).clear();
- data_cb_.Reset();
- request_suspend_cb_.Reset();
- request_seek_cb_.Reset();
sink_ = nullptr;
if (GetPlayerState() == ESPLUSPLAYER_STATE_NONE) {
if (error != ESPLUSPLAYER_ERROR_TYPE_NONE) {
LOG(ERROR) << "esplusplayer_set_audio_stream_info failed. error code "
<< error;
- GetRendererClient(type)->OnError(PIPELINE_ERROR_INITIALIZATION_FAILED);
+ GetMediaPlayerClient()->OnError(PIPELINE_ERROR_INITIALIZATION_FAILED);
return;
}
buffer_observer_->SetMediaStreamStatusCallback(DemuxerStream::AUDIO);
SetMediaType(GetMediaType() | MediaType::Audio);
SetIsValid(type, true);
- GetRendererClient(type)->OnAudioConfigChange(audio_config);
+ GetMediaPlayerClient()->OnAudioConfigChange(audio_config);
}
if (type == DemuxerStream::VIDEO) {
if (error != ESPLUSPLAYER_ERROR_TYPE_NONE) {
LOG(ERROR) << "esplusplayer_set_video_stream_info failed. error code "
<< error;
- GetRendererClient(type)->OnError(PIPELINE_ERROR_INITIALIZATION_FAILED);
+ GetMediaPlayerClient()->OnError(PIPELINE_ERROR_INITIALIZATION_FAILED);
return;
}
buffer_observer_->SetMediaStreamStatusCallback(DemuxerStream::VIDEO);
SetMediaType(GetMediaType() | MediaType::Video);
SetIsValid(type, true);
- GetRendererClient(type)->OnVideoConfigChange(video_config);
+ GetMediaPlayerClient()->OnVideoConfigChange(video_config);
}
}
// related state changes are commented for the same (in Play and
// RequestStateChange).
if (status != kBufferNone) {
- GetRendererClient(type)->OnBufferingStateChange(
+ GetMediaPlayerClient()->OnBufferingStateChange(
BUFFERING_HAVE_ENOUGH, BUFFERING_CHANGE_REASON_UNKNOWN);
}
}
if (!result) {
LOG(ERROR) << "OnPrepareComplete prepare_async failed.";
- if (IsValid(DemuxerStream::AUDIO))
- GetRendererClient(DemuxerStream::AUDIO)
- ->OnError(PIPELINE_ERROR_INITIALIZATION_FAILED);
- else if (IsValid(DemuxerStream::VIDEO))
- GetRendererClient(DemuxerStream::VIDEO)
- ->OnError(PIPELINE_ERROR_INITIALIZATION_FAILED);
+ GetMediaPlayerClient()->OnError(PIPELINE_ERROR_INITIALIZATION_FAILED);
return;
}
is_prepared_ = true;
if (pending_seek_) {
- request_seek_cb_.Run(pending_seek_position_);
+ GetMediaPlayerClient()->OnRequestSeek(pending_seek_position_);
} else if (!is_paused_) {
Play();
}
}
LOG(INFO) << "(" << static_cast<void*>(this) << ") " << __func__;
- if (IsValid(DemuxerStream::VIDEO))
- GetRendererClient(DemuxerStream::VIDEO)->OnEnded();
- else if (IsValid(DemuxerStream::AUDIO))
- GetRendererClient(DemuxerStream::AUDIO)->OnEnded();
+ GetMediaPlayerClient()->OnEnded();
Release();
}
tbm_handle.player_id = player_id_;
tbm_handle.width = width;
tbm_handle.height = height;
- data_cb_.Run(0, tbm_handle, timestamp);
+
+ GetMediaPlayerClient()->OnNewTbmFrameAvailable(0, tbm_handle, timestamp);
#else
base::UnsafeSharedMemoryRegion shared_memory;
uint32_t shared_memory_size =
if (!sink_) {
esplusplayer_decoded_buffer_destroy(
esplayer_, const_cast<esplusplayer_decoded_video_packet*>(packet));
- data_cb_.Run(0, std::move(shared_memory), shared_memory_size, timestamp,
- width, height);
+ GetMediaPlayerClient()->OnNewFrameAvailable(0, std::move(shared_memory),
+ shared_memory_size, timestamp,
+ width, height);
} else {
uint8_t* const yuv_buffer = static_cast<uint8_t*>(memory_mapping.memory());
scoped_refptr<VideoFrame> video_frame = VideoFrame::CreateFrame(
}
LOG(INFO) << "(" << static_cast<void*>(this) << ") " << __func__;
- request_suspend_cb_.Run(true);
+ GetMediaPlayerClient()->OnRequestSuspend(true);
}
void MediaPlayerESPlusPlayer::OnError(const esplusplayer_error_type error) {
<< esplusplayer_get_error_string(
static_cast<esplusplayer_error_type>(error));
- if (IsValid(DemuxerStream::VIDEO))
- GetRendererClient(DemuxerStream::VIDEO)->OnError(GetPipelineError(error));
- else if (IsValid(DemuxerStream::AUDIO))
- GetRendererClient(DemuxerStream::AUDIO)->OnError(GetPipelineError(error));
+ GetMediaPlayerClient()->OnError(GetPipelineError(error));
Release();
}
GetElementryStream(type).input_stream_ = stream;
}
-RendererClient* MediaPlayerESPlusPlayer::GetRendererClient(
- DemuxerStream::Type type) const {
- return GetElementryStream(type).renderer_client_;
-}
-
-void MediaPlayerESPlusPlayer::SetRendererClient(DemuxerStream::Type type,
- RendererClient* client) {
- GetElementryStream(type).renderer_client_ = client;
-}
-
Queue& MediaPlayerESPlusPlayer::GetBufferQueue(DemuxerStream::Type type) {
return GetElementryStream(type).pending_buffers_;
}
-void MediaPlayerESPlusPlayer::SetFrameAvailableCallback(
- const DataRequestCB& datacb) {
- data_cb_ = datacb;
-}
-
-void MediaPlayerESPlusPlayer::SetRequestSuspendCallback(
- const RequestSuspendCB& request_suspend_cb) {
- request_suspend_cb_ = request_suspend_cb;
-}
-
-void MediaPlayerESPlusPlayer::SetRequestSeekCallback(
- const RequestSeekCB& request_seek_cb) {
- request_seek_cb_ = request_seek_cb;
-}
-
#if defined(TIZEN_VIDEO_HOLE)
void MediaPlayerESPlusPlayer::SetVideoHole(bool is_video_hole) {
LOG(INFO) << "(" << static_cast<void*>(this) << ") " << __func__
void MediaPlayerESPlusPlayer::RequestSuspend() {
LOG(INFO) << "(" << static_cast<void*>(this) << ") " << __func__;
- request_suspend_cb_.Run(true);
+ GetMediaPlayerClient()->OnRequestSuspend(true);
Release();
}
namespace media {
class DemuxerStream;
-class RendererClient;
+class MediaPlayerTizenClient;
class VideoPlaneController;
using Queue = base::circular_deque<scoped_refptr<DecoderBuffer>>;
MediaPlayerESPlusPlayer();
~MediaPlayerESPlusPlayer() override;
-#if defined(TIZEN_TBM_SUPPORT)
- using DataRequestCB = base::RepeatingCallback<
- void(uint32_t, gfx::TbmBufferHandle, base::TimeDelta)>;
-#else
- using DataRequestCB =
- base::RepeatingCallback<void(uint32_t,
- base::UnsafeSharedMemoryRegion,
- uint32_t,
- base::TimeDelta,
- uint32_t,
- uint32_t)>;
-#endif
- using RequestSuspendCB = base::RepeatingCallback<void(bool)>;
- using RequestSeekCB = base::RepeatingCallback<void(base::TimeDelta)>;
-
bool CreatePlayer(int player_id) override;
void Initialize(VideoRendererSink* sink) override;
bool IsInitialized() override;
void SetTaskRunner(
const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) override;
- void SetStreamInfo(DemuxerStream::Type type,
- DemuxerStream* stream,
- RendererClient* client) override;
+ void SetStreamInfo(DemuxerStream::Type type, DemuxerStream* stream) override;
- void SetRendererClientExtension(
- media::MediaPlayerTizenClientExtension* client_extension) override;
+ void SetMediaPlayerClient(MediaPlayerTizenClient* client) override {
+ client_ = client;
+ }
bool Play() override;
void Pause(bool is_media_related_action = false) override;
void SetVolume(double volume) override;
base::TimeDelta GetCurrentTime() override;
- void SetFrameAvailableCallback(const DataRequestCB& datacb) override;
-
- void SetRequestSuspendCallback(
- const RequestSuspendCB& request_suspend_cb) override;
- void SetRequestSeekCallback(const RequestSeekCB& request_seek_cb) override;
-
#if defined(TIZEN_VIDEO_HOLE)
void SetVideoHole(bool is_video_hole) override;
void SetMediaGeometry(const gfx::Rect& viewport_rect,
const media::AudioDecoderConfig& audio_config,
esplusplayer_audio_stream_info* audio_stream_info);
virtual bool ReadFromBufferQueue(DemuxerStream::Type type);
+ MediaPlayerTizenClient* GetMediaPlayerClient() const { return client_; }
virtual esplusplayer_submit_status SubmitEsPacket(
DemuxerStream::Type type,
scoped_refptr<DecoderBuffer> buffer);
bool read_requested_ = false;
BufferStatus buffer_status_ = kBufferNone; // Not used!
DemuxerStream* input_stream_ = nullptr;
- RendererClient* renderer_client_ = nullptr;
base::circular_deque<scoped_refptr<DecoderBuffer>> pending_buffers_;
};
void SetBufferStatus(DemuxerStream::Type type, BufferStatus status);
DemuxerStream* GetDemuxerStream(DemuxerStream::Type type) const;
void SetDemuxerStream(DemuxerStream::Type type, DemuxerStream* stream);
- RendererClient* GetRendererClient(DemuxerStream::Type type) const;
- void SetRendererClient(DemuxerStream::Type type, RendererClient* client);
Queue& GetBufferQueue(DemuxerStream::Type type);
double volume_ = 1.0;
MediaTypeFlags media_type_;
- DataRequestCB data_cb_;
- RequestSuspendCB request_suspend_cb_;
- RequestSeekCB request_seek_cb_;
-
VideoRendererSink* sink_ = nullptr;
+ MediaPlayerTizenClient* client_ = nullptr;
+
std::array<ElementryStream, kElementryStreamCount> elementry_stream_;
std::unique_ptr<BufferObserver> buffer_observer_;
#include "media/base/decoder_buffer.h"
#include "media/base/renderer_client.h"
+#include "tizen_src/chromium_impl/media/filters/media_player_tizen_client.h"
namespace media {
namespace media {
class DemuxerStream;
-class RendererClient;
+class MediaPlayerTizenClient;
class VideoRendererSink;
enum class MediaType {
DEFINE_OPERATORS_FOR_FLAGS(MediaTypeFlags)
DEFINE_OPERATORS_FOR_FLAGS(PlayerRoleFlags)
-// We introduce |MediaPlayerTizenClientExtension| to avoid direct relationship
-// with |MediaPlayerRendererClientExtension|.
-// (Generation timing of |MediaPlayerRendererClientExtension| from mojom file
-// is not guaranteed.)
-class MEDIA_EXPORT MediaPlayerTizenClientExtension {
- public:
- virtual void OnDurationChange(base::TimeDelta duration) = 0;
- virtual void OnVideoSizeChange(const gfx::Size& size) = 0;
- virtual void OnBufferUpdate(base::TimeDelta time) = 0;
-#if defined(TIZEN_TBM_SUPPORT)
- virtual void OnNewTbmFrameAvailable(
- uint32_t playerId,
- const gfx::TbmBufferHandle& tbm_buffer_handle,
- base::TimeDelta timestamp) = 0;
-#else
- virtual void OnNewFrameAvailable(uint32_t playerId,
- base::UnsafeSharedMemoryRegion frame,
- uint32_t size,
- base::TimeDelta timestamp,
- uint32_t width,
- uint32_t height) = 0;
-#endif
-};
-
class MEDIA_EXPORT MediaPlayerTizen {
public:
-#if defined(TIZEN_TBM_SUPPORT)
- using DataRequestCB = base::RepeatingCallback<
- void(uint32_t, gfx::TbmBufferHandle, base::TimeDelta)>;
-#else
- using DataRequestCB =
- base::RepeatingCallback<void(uint32_t,
- base::UnsafeSharedMemoryRegion,
- uint32_t,
- base::TimeDelta,
- uint32_t,
- uint32_t)>;
-#endif
-
using RequestSuspendCB = base::RepeatingCallback<void(bool)>;
- using RequestSeekCB = base::RepeatingCallback<void(base::TimeDelta)>;
MediaPlayerTizen() {}
virtual ~MediaPlayerTizen() {}
const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) = 0;
virtual void SetStreamInfo(DemuxerStream::Type type,
- DemuxerStream* stream,
- RendererClient* client) = 0;
+ DemuxerStream* stream) = 0;
- virtual void SetRendererClientExtension(
- MediaPlayerTizenClientExtension* client_extension) = 0;
+ virtual void SetMediaPlayerClient(MediaPlayerTizenClient* client) = 0;
virtual bool Play() = 0;
virtual void Pause(bool is_media_related_action = false) = 0;
virtual void SetVolume(double volume) = 0;
virtual base::TimeDelta GetCurrentTime() = 0;
- virtual void SetRequestSuspendCallback(
- const RequestSuspendCB& request_suspend_cb) {}
- virtual void SetRequestSeekCallback(const RequestSeekCB& pending_seek_cb) {}
-
- // Will be replaced by |ClientExtention| interface.
- virtual void SetFrameAvailableCallback(const DataRequestCB& datacb) = 0;
-
virtual void ToggleFullscreenMode(bool is_fullscreen) {}
#if defined(TIZEN_TBM_SUPPORT)
--- /dev/null
+// Copyright 2023 Samsung Electronics Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef MEDIA_FILTERS_MEDIA_PLAYER_TIZEN_CLIENT_H_
+#define MEDIA_FILTERS_MEDIA_PLAYER_TIZEN_CLIENT_H_
+
+#include "content/public/browser/web_contents.h"
+#include "media/base/audio_decoder_config.h"
+#include "media/base/pipeline_status.h"
+#include "media/base/video_decoder_config.h"
+#include "media/base/waiting.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/tbm_buffer_handle.h"
+
+namespace media {
+
+class MEDIA_EXPORT MediaPlayerTizenClient {
+ public:
+ // RendererClient
+ virtual void OnError(PipelineStatus status) = 0;
+ virtual void OnFallback(PipelineStatus status) = 0;
+ virtual void OnEnded() = 0;
+ virtual void OnStatisticsUpdate(const PipelineStatistics& stats) = 0;
+ virtual void OnBufferingStateChange(BufferingState state,
+ BufferingStateChangeReason reason) = 0;
+ virtual void OnWaiting(WaitingReason reason) = 0;
+ virtual void OnAudioConfigChange(const AudioDecoderConfig& config) = 0;
+ virtual void OnVideoConfigChange(const VideoDecoderConfig& config) = 0;
+ virtual void OnVideoNaturalSizeChange(const gfx::Size& size) = 0;
+ virtual void OnVideoOpacityChange(bool opaque) = 0;
+ virtual void OnVideoFrameRateChange(absl::optional<int> fps) = 0;
+ virtual void OnRequestSeek(base::TimeDelta time) = 0;
+ virtual void OnRequestSuspend(bool resource_conflict) = 0;
+
+ // MediaPlayerRendererClientExtension
+ virtual void OnVideoSizeChange(const gfx::Size& size) = 0;
+ virtual void OnDurationChange(base::TimeDelta duration) = 0;
+ virtual void OnBufferUpdate(base::TimeDelta time) = 0;
+#if defined(TIZEN_TBM_SUPPORT)
+ virtual void OnNewTbmFrameAvailable(uint32_t player_id,
+ gfx::TbmBufferHandle tbm_buffer_handle,
+ base::TimeDelta timestamp) = 0;
+#else
+ virtual void OnNewFrameAvailable(uint32_t playerId,
+ base::UnsafeSharedMemoryRegion frame,
+ uint32_t size,
+ base::TimeDelta timestamp,
+ uint32_t width,
+ uint32_t height) = 0;
+#endif
+};
+
+} // namespace media
+
+#endif // MEDIA_FILTERS_MEDIA_PLAYER_TIZEN_CLIENT_H_
}
external_media_video_decode_sources += [
+ "//tizen_src/chromium_impl/media/base/efl/media_player_util_efl.cc",
+ "//tizen_src/chromium_impl/media/base/efl/media_player_util_efl.h",
"//tizen_src/chromium_impl/media/filters/buffer_observer.h",
"//tizen_src/chromium_impl/media/filters/esplusplayer_buffer_observer_impl.cc",
"//tizen_src/chromium_impl/media/filters/esplusplayer_buffer_observer_impl.h",
"//tizen_src/chromium_impl/media/filters/media_player_registry.cc",
"//tizen_src/chromium_impl/media/filters/media_player_registry.h",
"//tizen_src/chromium_impl/media/filters/media_player_tizen.h",
- "//tizen_src/chromium_impl/media/base/efl/media_player_util_efl.cc",
- "//tizen_src/chromium_impl/media/base/efl/media_player_util_efl.h",
+ "//tizen_src/chromium_impl/media/filters/media_player_tizen_client.h",
"//tizen_src/chromium_impl/media/filters/sequence.h",
]
"//tizen_src/chromium_impl/media/filters/media_player_bridge_capi_tv.h",
"//tizen_src/chromium_impl/media/filters/media_player_esplusplayer_tv.cc",
"//tizen_src/chromium_impl/media/filters/media_player_esplusplayer_tv.h",
- ]
+ ]
} else {
external_media_video_decode_sources += [
"//tizen_src/chromium_impl/media/filters/media_player_esplusplayer_common.cc",
projects / platform / framework / web / chromium-efl.git / commitdiff