Below features are not used. Respective code is removed.
- tizen_multimedia_eme_support
- tizen_multimedia_support
Reference :
https://review.tizen.org/gerrit/279396/
https://review.tizen.org/gerrit/279317/
Change-Id: I989a3873cfe785afcff1f7172419c0646510e95c
Signed-off-by: Koyyani Maheswari <m.koyyani@samsung.com>
"//base",
"//third_party/libwebm",
]
-
- if (use_efl && tizen_multimedia_support) {
- deps += external_media_efl_deps
- sources += external_media_efl_sources
- sources -= external_exclude_media_efl_sources
- configs += external_media_efl_config
- }
}
fuzzer_test("cbcs_decryptor_fuzzer") {
if (tizen_tbm_support) {
defines += [ "TIZEN_TBM_SUPPORT" ]
}
- if (tizen_multimedia_support) {
- defines += [
- "TIZEN_MULTIMEDIA_SUPPORT",
- "TIZEN_MULTIMEDIA_USE_CAPI_AUDIO_IO",
- ]
- }
if (tizen_web_speech_recognition) {
defines += [ "TIZEN_WEB_SPEECH_RECOGNITION" ]
}
tizen_pepper_extensions = false
# Tizen multimedia related
- tizen_multimedia_eme_support = false
- tizen_multimedia_support = false
tizen_multimedia = false
tizen_tbm_support = false
tizen_video_hole = false
use_ttrace = true
}
-if (is_tizen && tizen_multimedia_support) {
- tizen_multimedia_eme_support = true
-} else {
- tizen_multimedia_eme_support = false
-}
-
if (use_atk) {
tizen_atk_support = true
if (tizen_product_tv) {
python_ver=\"$(getPythonVersion)\"
is_official_build=true
enable_nacl=false
- enable_basic_printing=true
- enable_print_preview=true
use_xkbcommon=true
target_os="\"tizen\""
target_sysroot=\"/\"
jobs = os.environ['NUMBER_OF_PROCESSORS']
# Use system libraries while building.
-if use_lib64:
_libdir = 'lib64'
-else:
- _libdir = 'lib'
partial_build = False
]
}
-if (tizen_multimedia_support) {
- external_content_browser_efl_configs += [
- "//tizen_src/build:capi-media-player",
- "//tizen_src/build:libcapi-media-player",
- "//tizen_src/build:capi-media-tool",
- "//tizen_src/build:libcapi-media-tool",
- ]
-}
-
if (tizen_web_speech_recognition) {
external_content_browser_efl_configs += [
"//tizen_src/build:stt",
]
}
-if (tizen_multimedia_support) {
- external_content_browser_efl_sources += [
- "//tizen_src/chromium_impl/content/browser/media/efl/browser_demuxer_efl.cc",
- "//tizen_src/chromium_impl/content/browser/media/efl/browser_demuxer_efl.h",
- "//tizen_src/chromium_impl/content/browser/media/efl/browser_media_player_manager_efl.cc",
- "//tizen_src/chromium_impl/content/browser/media/efl/browser_media_player_manager_efl.h",
- "//tizen_src/chromium_impl/content/browser/media/media_web_contents_observer_efl.cc",
- "//tizen_src/chromium_impl/content/browser/media/media_web_contents_observer_efl.h",
- ]
-}
-
if (tizen_atk_support) {
external_content_browser_efl_configs += [
"//tizen_src/build:atk",
+++ /dev/null
-// Copyright 2015 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.
-
-#include "content/browser/media/browser_mediapacket_manager.h"
-
-#include <media_packet.h>
-
-#include "content/common/media/efl/media_player_messages_efl.h"
-#include "content/public/browser/browser_thread.h"
-#include "ipc/ipc_message_macros.h"
-
-namespace {
-
-void DoDestroyMediaPacket(media_packet_h packet) {
- if (MEDIA_PACKET_ERROR_NONE != media_packet_destroy(packet))
- LOG(WARNING) << "Fail to release media_packet";
-}
-
-} // namespace
-
-namespace content {
-
-scoped_refptr<BrowserMessageFilter> CreateBrowserMediapacketManager() {
- return new BrowserMediaPacketManager();
-}
-
-BrowserMediaPacketManager::BrowserMediaPacketManager()
- : BrowserMessageFilter(MediaPlayerMsgStart) {}
-
-BrowserMediaPacketManager::~BrowserMediaPacketManager() {}
-
-bool BrowserMediaPacketManager::OnMessageReceived(
- const IPC::Message& message) {
- bool handled = true;
- IPC_BEGIN_MESSAGE_MAP(BrowserMediaPacketManager, message)
- IPC_MESSAGE_HANDLER(MediaPlayerEflHostMsg_ReleaseTbmBuffer,
- ReleaseMediaPacket)
- IPC_MESSAGE_UNHANDLED(handled = false)
- IPC_END_MESSAGE_MAP()
- return handled;
-}
-
-void BrowserMediaPacketManager::ReleaseMediaPacket(
- gfx::TbmBufferHandle packet) {
- DLOG(INFO) << "ReleaseMediaPacket, media_packet: " << packet.media_packet;
- BrowserThread::PostDelayedTask(
- BrowserThread::IO, FROM_HERE,
- base::BindOnce(&DoDestroyMediaPacket,
- static_cast<media_packet_h>(packet.media_packet)),
- base::TimeDelta::FromMilliseconds(40));
-}
-
-} // namespace content
+++ /dev/null
-// Copyright 2015 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 CONTENT_BROWSER_MEDIA_BROWSER_MEDIAPACKET_MANAGER_H_
-#define CONTENT_BROWSER_MEDIA_BROWSER_MEDIAPACKET_MANAGER_H_
-
-#include "content/public/browser/browser_message_filter.h"
-#include "ui/gfx/gpu_memory_buffer.h"
-
-namespace content {
-
-class CONTENT_EXPORT BrowserMediaPacketManager : public BrowserMessageFilter {
- public:
- BrowserMediaPacketManager();
-
- BrowserMediaPacketManager(const BrowserMediaPacketManager&) = delete;
- BrowserMediaPacketManager& operator=(const BrowserMediaPacketManager&) =
- delete;
-
- bool OnMessageReceived(const IPC::Message& message) override;
-
- protected:
- friend class base::RefCountedThreadSafe<BrowserMediaPacketManager>;
- ~BrowserMediaPacketManager() override;
-
- private:
- void ReleaseMediaPacket(gfx::TbmBufferHandle packet);
-};
-
-} // namespace content
-
-#endif // CONTENT_BROWSER_MEDIA_BROWSER_MEDIAPACKET_MANAGER_H_
+++ /dev/null
-// Copyright 2014 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.
-
-#include "content/browser/media/efl/browser_demuxer_efl.h"
-
-#include "content/common/media/efl/media_player_messages_efl.h"
-
-namespace content {
-
-class BrowserDemuxerEfl::Internal : public media::DemuxerEfl {
- public:
- Internal(const scoped_refptr<BrowserDemuxerEfl>& demuxer,
- int demuxer_client_id)
- : demuxer_(demuxer),
- demuxer_client_id_(demuxer_client_id) {}
-
- ~Internal() override {
- DCHECK(ClientIDExists()) << demuxer_client_id_;
- demuxer_->RemoveDemuxerClient(demuxer_client_id_);
- }
-
- Internal(const Internal&) = delete;
- Internal& operator=(const Internal&) = delete;
-
- // |media::DemuxerEfl| implementation.
- void Initialize(media::DemuxerEflClient* client) override {
- DCHECK(!ClientIDExists()) << demuxer_client_id_;
- demuxer_->AddDemuxerClient(demuxer_client_id_, client);
- }
-
- void RequestDemuxerData(media::DemuxerStream::Type type) override {
- DCHECK(ClientIDExists()) << demuxer_client_id_;
- demuxer_->Send(new MediaPlayerEflMsg_ReadFromDemuxer(
- demuxer_client_id_, type));
- }
-
- void RequestDemuxerSeek(
- const base::TimeDelta& time_to_seek) override {
- DCHECK(ClientIDExists()) << demuxer_client_id_;
- demuxer_->Send(new MediaPlayerEflMsg_DemuxerSeekRequest(
- demuxer_client_id_, time_to_seek));
- }
-
- private:
- // Helper for DCHECKing that the ID is still registered.
- bool ClientIDExists() {
- return demuxer_->demuxer_clients_.Lookup(demuxer_client_id_);
- }
-
- scoped_refptr<BrowserDemuxerEfl> demuxer_;
- int demuxer_client_id_;
-};
-
-scoped_refptr<BrowserMessageFilter> CreateBrowserDemuxerEfl() {
- return new BrowserDemuxerEfl();
-}
-
-BrowserDemuxerEfl::BrowserDemuxerEfl()
- : BrowserMessageFilter(MediaPlayerMsgStart) {}
-
-BrowserDemuxerEfl::~BrowserDemuxerEfl() {}
-
-void BrowserDemuxerEfl::OverrideThreadForMessage(
- const IPC::Message& message,
- BrowserThread::ID* thread) {
- switch (message.type()) {
- case MediaPlayerEflHostMsg_DemuxerReady::ID:
- case MediaPlayerEflHostMsg_ReadFromDemuxerAck::ID:
- case MediaPlayerEflHostMsg_DurationChanged::ID:
- case MediaPlayerEflHostMsg_DemuxerSeekDone::ID:
- *thread = BrowserThread::UI;
- break;
- default:
- break;
- }
-}
-
-bool BrowserDemuxerEfl::OnMessageReceived(const IPC::Message& message) {
- bool handled = true;
- IPC_BEGIN_MESSAGE_MAP(BrowserDemuxerEfl, message)
- IPC_MESSAGE_HANDLER(MediaPlayerEflHostMsg_DemuxerReady,
- OnDemuxerReady)
- IPC_MESSAGE_HANDLER(MediaPlayerEflHostMsg_ReadFromDemuxerAck,
- OnReadFromDemuxerAck)
- IPC_MESSAGE_HANDLER(MediaPlayerEflHostMsg_DurationChanged,
- OnDurationChanged)
- IPC_MESSAGE_HANDLER(MediaPlayerEflHostMsg_DemuxerSeekDone,
- OnDemuxerSeekDone)
- IPC_MESSAGE_UNHANDLED(handled = false)
- IPC_END_MESSAGE_MAP()
- return handled;
-}
-
-scoped_ptr<media::DemuxerEfl> BrowserDemuxerEfl::CreateDemuxer(
- int demuxer_client_id) {
- return scoped_ptr<media::DemuxerEfl>(
- new Internal(this, demuxer_client_id));
-}
-
-void BrowserDemuxerEfl::AddDemuxerClient(
- int demuxer_client_id,
- media::DemuxerEflClient* client) {
- demuxer_clients_.AddWithID(client, demuxer_client_id);
-}
-
-void BrowserDemuxerEfl::RemoveDemuxerClient(int demuxer_client_id) {
- demuxer_clients_.Remove(demuxer_client_id);
-}
-
-void BrowserDemuxerEfl::OnDemuxerReady(
- int demuxer_client_id,
- const media::DemuxerConfigs& configs) {
- media::DemuxerEflClient* client =
- demuxer_clients_.Lookup(demuxer_client_id);
- if (client)
- client->OnDemuxerConfigsAvailable(configs);
-}
-
-void BrowserDemuxerEfl::OnReadFromDemuxerAck(
- int demuxer_client_id,
- base::SharedMemoryHandle foreign_memory_handle,
- const media::DemuxedBufferMetaData& meta_data) {
- media::DemuxerEflClient* client =
- demuxer_clients_.Lookup(demuxer_client_id);
- if (client)
- client->OnDemuxerDataAvailable(foreign_memory_handle, meta_data);
-}
-
-void BrowserDemuxerEfl::OnDemuxerSeekDone(
- int demuxer_client_id,
- const base::TimeDelta& actual_browser_seek_time) {
- media::DemuxerEflClient* client =
- demuxer_clients_.Lookup(demuxer_client_id);
- if (client)
- client->OnDemuxerSeekDone(actual_browser_seek_time);
-}
-
-void BrowserDemuxerEfl::OnDurationChanged(
- int demuxer_client_id,
- const base::TimeDelta& duration) {
- media::DemuxerEflClient* client =
- demuxer_clients_.Lookup(demuxer_client_id);
- if (client)
- client->OnDemuxerDurationChanged(duration);
-}
-
-} // namespace content
+++ /dev/null
-// Copyright 2014 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 CONTENT_BROWSER_MEDIA_EFL_BROWSER_DEMUXER_EFL_H_
-#define CONTENT_BROWSER_MEDIA_EFL_BROWSER_DEMUXER_EFL_H_
-
-#include "base/id_map.h"
-#include "base/memory/shared_memory.h"
-#include "content/public/browser/browser_message_filter.h"
-#include "media/base/efl/demuxer_efl.h"
-
-namespace content {
-
-// Represents the browser process half of an IPC-based demuxer proxy.
-// It vends out media::DemuxerEfl instances that are registered with an
-// end point in the renderer process.
-//
-// Refer to RendererDemuxerEfl for the renderer process half.
-class CONTENT_EXPORT BrowserDemuxerEfl : public BrowserMessageFilter {
- public:
- BrowserDemuxerEfl();
-
- BrowserDemuxerEfl(const BrowserDemuxerEfl&) = delete;
- BrowserDemuxerEfl& operator=(const BrowserDemuxerEfl&) = delete;
-
- // BrowserMessageFilter overrides.
- void OverrideThreadForMessage(
- const IPC::Message& message,
- BrowserThread::ID* thread) override;
- bool OnMessageReceived(const IPC::Message& message) override;
-
- // Returns an uninitialized demuxer implementation associated with
- // |demuxer_client_id|, which can be used to communicate with the real demuxer
- // in the renderer process.
- scoped_ptr<media::DemuxerEfl> CreateDemuxer(int demuxer_client_id);
-
- protected:
- friend class base::RefCountedThreadSafe<BrowserDemuxerEfl>;
- ~BrowserDemuxerEfl() override;
-
- private:
- class Internal;
-
- // Called by internal demuxer implementations to add/remove a client
- // association.
- void AddDemuxerClient(
- int demuxer_client_id,
- media::DemuxerEflClient* client);
- void RemoveDemuxerClient(int demuxer_client_id);
-
- // IPC message handlers.
- void OnDemuxerReady(
- int demuxer_client_id,
- const media::DemuxerConfigs& configs);
- void OnReadFromDemuxerAck(
- int demuxer_client_id,
- base::SharedMemoryHandle foreign_memory_handle,
- const media::DemuxedBufferMetaData& meta_data);
- void OnDemuxerSeekDone(
- int demuxer_client_id,
- const base::TimeDelta& actual_browser_seek_time);
- void OnDurationChanged(
- int demuxer_client_id,
- const base::TimeDelta& duration);
-
- IDMap<media::DemuxerEflClient> demuxer_clients_;
-};
-
-} // namespace content
-
-#endif // CONTENT_BROWSER_MEDIA_EFL_BROWSER_DEMUXER_EFL_H_
+++ /dev/null
-// Copyright 2014 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.
-
-#include "content/browser/media/efl/browser_media_player_manager_efl.h"
-
-#include "base/memory/shared_memory.h"
-#include "content/browser/media/efl/browser_demuxer_efl.h"
-#include "content/browser/renderer_host/render_process_host_impl.h"
-#include "content/common/media/efl/media_player_messages_efl.h"
-#include "content/public/browser/web_contents.h"
-#include "content/public/common/content_client.h"
-#include "ipc/ipc_channel_proxy.h"
-#include "ipc/ipc_logging.h"
-#include "media/base/efl/media_player_efl.h"
-#include "tizen/system_info.h"
-
-#if defined(TIZEN_TBM_SUPPORT)
-#include <media_packet.h>
-#endif
-
-namespace content {
-
-static unsigned int GetMaximumPlayerCount() {
- // Note : In case of Mobile , maximum decoder instance count is depending on
- // contents resolution but to get the resolution of content, player should be
- // prepared. Hence maximum instance count is set as 1.
- // Resolution <= 720P : 2
- // Resolution > 720P : 1
- // Incase of TV : audio & video using H/W decoder , so only support 1.
- if (IsTvProfile())
- return 1;
- else if (IsMobileProfile() || IsWearableProfile())
- return 1;
- else
- return 5;
-}
-
-// GetContentClient() is defined in content_client.cc, but in content_client.h
-// it is hidden by CONTENT_IMPLEMENTATION ifdef. We don't want to define
-// CONTENT_IMPLEMENTATION because it may bring a lot of things we don't need.
-ContentClient* GetContentClient();
-
-BrowserMediaPlayerManagerEfl* BrowserMediaPlayerManagerEfl::Create(
- RenderFrameHost* rfh) {
- return new BrowserMediaPlayerManagerEfl(rfh);
-}
-
-BrowserMediaPlayerManagerEfl::BrowserMediaPlayerManagerEfl(
- RenderFrameHost* render_frame_host)
- : current_player_(-1),
- render_frame_host_(render_frame_host),
- web_contents_(WebContents::FromRenderFrameHost(render_frame_host)) {
-}
-
-BrowserMediaPlayerManagerEfl::~BrowserMediaPlayerManagerEfl() {
- // Players can be destroyed during destruction of BMPM without clear(),
- // but not to make destruction order dependencies with other member variables
- // we explicitly destroy player instances here.
- players_.clear();
-}
-
-media::MediaPlayerEfl* BrowserMediaPlayerManagerEfl::GetPlayer(
- int player_id) {
- for (auto player : players_) {
- if (player->GetPlayerId() == player_id)
- return player;
- }
- return NULL;
-}
-
-void BrowserMediaPlayerManagerEfl::OnInitComplete(
- int player_id, bool success) {
- if (success)
- OnResumeComplete(player_id);
-
- if(init_queue_.empty() || player_id != init_queue_.front())
- return;
-
- init_queue_.pop_front();
- if (!init_queue_.empty())
- InitNextPlayer();
-}
-
-void BrowserMediaPlayerManagerEfl::OnResumeComplete(int player_id) {
- for(auto it = resumed_queue_.begin(); it != resumed_queue_.end(); ++it) {
- if (*it == player_id) {
- return;
- }
- }
-
- if (resumed_queue_.size() < GetMaximumPlayerCount())
- resumed_queue_.push_back(player_id);
-}
-
-void BrowserMediaPlayerManagerEfl::OnSuspendComplete(int player_id) {
- CleanUpResumedQueue();
- RemovePlayerFromResumedQueue(player_id);
-}
-
-void BrowserMediaPlayerManagerEfl::CleanUpResumedQueue() {
- // Clean up invalid player id.
- int size = resumed_queue_.size();
- for (int index = 0 ; index < size ; index++) {
- int id = resumed_queue_.front();
- media::MediaPlayerEfl* player = GetPlayer(id);
- resumed_queue_.pop_front();
- if (player)
- resumed_queue_.push_back(id);
- }
-}
-
-void BrowserMediaPlayerManagerEfl::InitNextPlayer() {
- if (!init_queue_.empty()) {
- SuspendPlayers();
- int player_id = init_queue_.front();
- media::MediaPlayerEfl* player = GetPlayer(player_id);
- if (player)
- player->Initialize();
- }
-}
-
-void BrowserMediaPlayerManagerEfl::OnNewFrameAvailable(
- int player_id,
- base::SharedMemoryHandle foreign_memory_handle,
- uint32_t length, base::TimeDelta timestamp) {
- Send(new MediaPlayerEflMsg_NewFrameAvailable(
- GetRoutingID(), player_id, foreign_memory_handle, length, timestamp));
-}
-
-#if defined(TIZEN_TBM_SUPPORT)
-void BrowserMediaPlayerManagerEfl::OnNewTbmBufferAvailable(
- int player_id, gfx::TbmBufferHandle tbm_handle,
- base::TimeDelta timestamp) {
- DLOG(INFO) << "New media_packet:" << tbm_handle.media_packet;
- Send(new MediaPlayerEflMsg_NewTbmBufferAvailable(
- GetRoutingID(), player_id, tbm_handle, timestamp));
-}
-#endif
-
-void BrowserMediaPlayerManagerEfl::OnTimeChanged(int player_id) {
- Send(new MediaPlayerEflMsg_TimeChanged(GetRoutingID(), player_id));
-}
-
-void BrowserMediaPlayerManagerEfl::OnSeekStateChange(
- int player_id, bool state) {
- Send(new MediaPlayerEflMsg_OnSeekStateChange(
- GetRoutingID(), player_id, state));
-}
-
-void BrowserMediaPlayerManagerEfl::OnPauseStateChange(
- int player_id, bool state) {
- Send(new MediaPlayerEflMsg_PauseStateChanged(
- GetRoutingID(), player_id, state));
-}
-
-void BrowserMediaPlayerManagerEfl::OnRequestSeek(
- int player_id, double seek_time) {
- // To handle internal seek.
- Send(new MediaPlayerEflMsg_SeekRequest(
- GetRoutingID(), player_id, seek_time));
-}
-
-void BrowserMediaPlayerManagerEfl::OnTimeUpdate(
- int player_id, double current_time) {
- Send(new MediaPlayerEflMsg_TimeUpdate(
- GetRoutingID(), player_id, current_time));
-}
-
-void BrowserMediaPlayerManagerEfl::OnBufferUpdate(
- int player_id,
- std::vector<media::MediaPlayerEfl::TimeRanges> buffer_range) {
- Send(new MediaPlayerEflMsg_BufferUpdate(
- GetRoutingID(), player_id, buffer_range));
-}
-
-void BrowserMediaPlayerManagerEfl::OnDurationChange(
- int player_id,
- double duration) {
- Send(new MediaPlayerEflMsg_DurationChanged(
- GetRoutingID(), player_id, duration));
-}
-
-void BrowserMediaPlayerManagerEfl::OnReadyStateChange(
- int player_id,
- blink::WebMediaPlayer::ReadyState state) {
- Send(new MediaPlayerEflMsg_ReadyStateChange(
- GetRoutingID(), player_id, state));
-}
-
-void BrowserMediaPlayerManagerEfl::OnNetworkStateChange(
- int player_id,
- blink::WebMediaPlayer::NetworkState state) {
- Send(new MediaPlayerEflMsg_NetworkStateChange(
- GetRoutingID(), player_id, state));
-}
-
-void BrowserMediaPlayerManagerEfl::OnMediaDataChange(int player_id, int width,
- int height, int media) {
- Send(new MediaPlayerEflMsg_MediaDataChanged(GetRoutingID(), player_id,
- width, height, media));
-}
-
-int BrowserMediaPlayerManagerEfl::GetRoutingID() {
- if (!render_frame_host_)
- return 0;
- return render_frame_host_->GetRoutingID();
-}
-
-bool BrowserMediaPlayerManagerEfl::Send(IPC::Message* msg) {
- if (!render_frame_host_)
- return false;
- return render_frame_host_->Send(msg);
-}
-
-void BrowserMediaPlayerManagerEfl::OnInitialize(
- int player_id,
- MediaPlayerHostMsg_Initialize_Type type,
- const GURL& url,
- double volume,
- int demuxer_client_id) {
- RemovePlayer(player_id);
-
- if (type == MEDIA_PLAYER_TYPE_URL) {
- std::string user_agent = web_contents()->GetUserAgentOverride();
- if (user_agent.empty())
- user_agent = content::GetContentClient()->GetUserAgent();
-
- AddPlayer(media::MediaPlayerEfl::CreatePlayer(
- player_id, url, volume, this, user_agent));
- } else if (type == MEDIA_PLAYER_TYPE_MEDIA_SOURCE) {
- RenderProcessHostImpl* host = static_cast<RenderProcessHostImpl*>(
- web_contents()->GetRenderProcessHost());
- BrowserDemuxerEfl* browser_demuxer_efl =
- static_cast<BrowserDemuxerEfl*>(host->browser_demuxer_efl().get());
- AddPlayer(media::MediaPlayerEfl::CreatePlayer(
- player_id,
- browser_demuxer_efl, demuxer_client_id,
- this));
- } else {
- LOG(ERROR) << __FUNCTION__ << " Load type is wrong!";
- OnNetworkStateChange(
- player_id, blink::WebMediaPlayer::NetworkStateEmpty);
- return;
- }
-
- init_queue_.push_back(player_id);
-
- // Start initialize with first player. Others will be queued.
- if (init_queue_.size() == 1)
- InitNextPlayer();
-}
-
-void BrowserMediaPlayerManagerEfl::OnDestroy(int player_id) {
- RemovePlayer(player_id);
-}
-
-void BrowserMediaPlayerManagerEfl::SuspendPlayers() {
- while (resumed_queue_.size() >= GetMaximumPlayerCount()) {
- media::MediaPlayerEfl* player = GetPlayer(resumed_queue_.front());
- if (player)
- player->Suspend();
- }
-}
-
-void BrowserMediaPlayerManagerEfl::PausePlayers(int player_id) {
- for (auto it = players_.begin(); it != players_.end(); ++it) {
- media::MediaPlayerEfl* player = *it;
- if (player->GetPlayerId() != player_id) {
- player->Pause(false);
- OnPauseStateChange(player->GetPlayerId() , true);
- }
- }
-}
-
-void BrowserMediaPlayerManagerEfl::OnPlay(int player_id) {
- PausePlayers(player_id);
- media::MediaPlayerEfl* player = GetPlayer(player_id);
- if (player) {
- if (current_player_ != player_id && player->IsPlayerSuspended())
- SuspendPlayers();
-
- current_player_ = player_id;
- player->Play();
- }
-}
-
-void BrowserMediaPlayerManagerEfl::OnPause(int player_id) {
- media::MediaPlayerEfl* player = GetPlayer(player_id);
- if (player)
- player->Pause(false);
-}
-
-void BrowserMediaPlayerManagerEfl::OnSetVolume(
- int player_id,
- double volume) {
- media::MediaPlayerEfl* player = GetPlayer(player_id);
- if (player)
- player->SetVolume(volume);
-}
-
-void BrowserMediaPlayerManagerEfl::OnSetRate(int player_id, double rate) {
- media::MediaPlayerEfl* player = GetPlayer(player_id);
- if (player)
- player->SetRate(rate);
-}
-
-void BrowserMediaPlayerManagerEfl::OnSeek(int player_id, double time) {
- media::MediaPlayerEfl* player = GetPlayer(player_id);
- if (player) {
- if (current_player_ != player_id && player->IsPlayerSuspended())
- SuspendPlayers();
- current_player_ = player_id;
- player->Seek(time);
- }
-}
-
-void BrowserMediaPlayerManagerEfl::AddPlayer(
- media::MediaPlayerEfl* player) {
- DCHECK(!GetPlayer(player->GetPlayerId()));
- players_.push_back(player);
-}
-
-void BrowserMediaPlayerManagerEfl::RemovePlayer(int player_id) {
- for (auto it = players_.begin(); it != players_.end(); ++it) {
- media::MediaPlayerEfl* player = *it;
- if (player->GetPlayerId() == player_id) {
- players_.erase(it);
-
- if (!init_queue_.empty()) {
- if(player_id == init_queue_.front()) {
- LOG(ERROR) << "The released Player is under initializing progress";
- init_queue_.pop_front();
- if (!init_queue_.empty())
- InitNextPlayer();
- } else
- RemovePlayerFromInitializeQueue(player_id);
- }
- break;
- }
- }
-}
-
-void BrowserMediaPlayerManagerEfl::RemovePlayerFromInitializeQueue(
- int player_id) {
- for(auto it = init_queue_.begin(); it != init_queue_.end(); ++it) {
- if (*it == player_id) {
- init_queue_.erase(it);
- return;
- }
- }
-}
-
-void BrowserMediaPlayerManagerEfl::RemovePlayerFromResumedQueue(
- int player_id) {
- for(auto it = resumed_queue_.begin(); it != resumed_queue_.end(); ++it) {
- if (*it == player_id) {
- resumed_queue_.erase(it);
- return;
- }
- }
-}
-
-} // namespace content
+++ /dev/null
-// Copyright 2014 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 CONTENT_BROWSER_MEDIA_EFL_BROWSER_MEDIA_PLAYER_MANAGER_EFL_H_
-#define CONTENT_BROWSER_MEDIA_EFL_BROWSER_MEDIA_PLAYER_MANAGER_EFL_H_
-
-#include "base/memory/scoped_vector.h"
-#include "content/common/media/efl/media_player_messages_enums_efl.h"
-#include "content/public/browser/browser_message_filter.h"
-#include "content/public/browser/render_frame_host.h"
-#include "content/public/browser/web_contents_observer.h"
-#include "media/base/efl/media_player_manager_efl.h"
-#include "third_party/blink/public/platform/WebMediaPlayer.h"
-
-namespace content {
-
-// This class manages all the MediaPlayerEfl objects. It receives
-// control operations from the the render process, and forwards
-// them to corresponding MediaPlayerEfl object. Callbacks from
-// MediaPlayerEfl objects are converted to IPCs and then sent to the
-// render process.
-class CONTENT_EXPORT BrowserMediaPlayerManagerEfl
- : public media::MediaPlayerManager {
- public:
- // Returns a new instance using the registered factory if available.
- static BrowserMediaPlayerManagerEfl* Create(RenderFrameHost* rfh);
- ~BrowserMediaPlayerManagerEfl() override;
-
- BrowserMediaPlayerManagerEf(const BrowserMediaPlayerManagerEf&) = delete;
- BrowserMediaPlayerManagerEf& operator=(const BrowserMediaPlayerManagerEf&) =
- delete;
-
- // media::MediaPlayerManager implementation.
- media::MediaPlayerEfl* GetPlayer(int player_id) override;
- void OnTimeChanged(int player_id) override;
- void OnTimeUpdate(int player_id, double current_time) override;
- void OnPauseStateChange(int player_id, bool state) override;
- void OnSeekStateChange(int player_id, bool state) override;
- void OnRequestSeek(int player_id, double seek_time) override;
- void OnBufferUpdate(
- int player_id,
- std::vector<media::MediaPlayerEfl::TimeRanges> buffer_range) override;
- void OnDurationChange(int player_id, double duration) override;
- void OnReadyStateChange(
- int player_id,
- blink::WebMediaPlayer::ReadyState state) override;
- void OnNetworkStateChange(
- int player_id,
- blink::WebMediaPlayer::NetworkState state) override;
- void OnMediaDataChange(int player_id, int width,
- int height, int media) override;
- void OnNewFrameAvailable(
- int player_id,
- base::SharedMemoryHandle foreign_memory_handle,
- uint32_t length, base::TimeDelta timestamp) override;
-
-#if defined(TIZEN_TBM_SUPPORT)
- void OnNewTbmBufferAvailable(
- int player_id, gfx::TbmBufferHandle tbm_handle,
- base::TimeDelta timestamp) override;
-#endif
-
- // Helper function to handle IPC from RenderMediaPlayerMangaerEfl.
- virtual void OnPlay(int player_id);
- virtual void OnPause(int player_id);
- virtual void OnSetVolume(int player_id, double volume);
- virtual void OnSetRate(int player_id, double rate);
- virtual void OnInitialize(
- int player_id,
- MediaPlayerHostMsg_Initialize_Type type,
- const GURL& url,
- double volume,
- int demuxer_client_id);
- virtual void OnDestroy(int player_id);
- virtual void OnSeek(int player_id, double time);
-
- protected:
- // Clients must use Create() or subclass constructor.
- explicit BrowserMediaPlayerManagerEfl(RenderFrameHost* render_frame_host);
-
- void AddPlayer(media::MediaPlayerEfl* player);
- void RemovePlayer(int player_id);
-
- // To continue initializing of other players in queue.
- virtual void OnInitComplete(int player_id, bool success);
-
- // To manage resumed/suspended player id.
- virtual void OnResumeComplete(int player_id);
- virtual void OnSuspendComplete(int player_id);
-
- // Helper function to send messages to RenderFrameObserver.
- bool Send(IPC::Message* msg);
-
- int GetRoutingID();
- WebContents* web_contents() const { return web_contents_; }
-
- private:
- void SuspendPlayers();
- void PausePlayers(int player_id);
- void InitNextPlayer();
- void RemovePlayerFromInitializeQueue(int player_id);
- void RemovePlayerFromResumedQueue(int player_id);
- void CleanUpResumedQueue();
-
- int current_player_;
-
- // An array of managed players.
- ScopedVector<media::MediaPlayerEfl> players_;
- RenderFrameHost* render_frame_host_;
- WebContents* const web_contents_;
-
- // A queue to initialize player including preroll.
- std::deque<int> init_queue_;
- std::deque<int> resumed_queue_;
-};
-
-} // namespace content
-
-#endif // CONTENT_BROWSER_MEDIA_EFL_BROWSER_MEDIA_PLAYER_MANAGER_EFL_H_
+++ /dev/null
-// Copyright 2014 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.
-
-#include "content/browser/media/media_web_contents_observer_efl.h"
-
-#include "content/browser/media/efl/browser_media_player_manager_efl.h"
-#include "content/browser/renderer_host/render_process_host_impl.h"
-#include "content/common/media/efl/media_player_messages_efl.h"
-#include "content/public/browser/render_frame_host.h"
-#include "content/public/browser/web_contents.h"
-#include "ipc/ipc_message_macros.h"
-
-namespace content {
-
-MediaWebContentsObserver* CreateMediaWebContentsObserver(
- WebContents* web_contents) {
- return new MediaWebContentsObserver(web_contents);
-}
-
-MediaWebContentsObserver::MediaWebContentsObserver(WebContents* web_contents)
- : WebContentsObserver(web_contents) {
-}
-
-MediaWebContentsObserver::~MediaWebContentsObserver() {
-}
-
-void MediaWebContentsObserver::RenderFrameDeleted(
- RenderFrameHost* render_frame_host) {
- uintptr_t key = reinterpret_cast<uintptr_t>(render_frame_host);
- media_player_managers_.erase(key);
-}
-
-
-bool MediaWebContentsObserver::OnMessageReceived(
- const IPC::Message& msg, RenderFrameHost* render_frame_host) {
- bool handled = true;
- IPC_BEGIN_MESSAGE_MAP(MediaWebContentsObserver, msg)
- IPC_MESSAGE_FORWARD(MediaPlayerEflHostMsg_Init,
- GetMediaPlayerManager(render_frame_host),
- BrowserMediaPlayerManagerEfl::OnInitialize)
- IPC_MESSAGE_FORWARD(MediaPlayerEflHostMsg_DeInit,
- GetMediaPlayerManager(render_frame_host),
- BrowserMediaPlayerManagerEfl::OnDestroy)
- IPC_MESSAGE_FORWARD(MediaPlayerEflHostMsg_Play,
- GetMediaPlayerManager(render_frame_host),
- BrowserMediaPlayerManagerEfl::OnPlay)
- IPC_MESSAGE_FORWARD(MediaPlayerEflHostMsg_Pause,
- GetMediaPlayerManager(render_frame_host),
- BrowserMediaPlayerManagerEfl::OnPause)
- IPC_MESSAGE_FORWARD(MediaPlayerEflHostMsg_SetVolume,
- GetMediaPlayerManager(render_frame_host),
- BrowserMediaPlayerManagerEfl::OnSetVolume)
- IPC_MESSAGE_FORWARD(MediaPlayerEflHostMsg_SetRate,
- GetMediaPlayerManager(render_frame_host),
- BrowserMediaPlayerManagerEfl::OnSetRate)
- IPC_MESSAGE_FORWARD(MediaPlayerEflHostMsg_Seek,
- GetMediaPlayerManager(render_frame_host),
- BrowserMediaPlayerManagerEfl::OnSeek)
- IPC_MESSAGE_UNHANDLED(handled = false)
- IPC_END_MESSAGE_MAP()
- return handled;
-}
-
-BrowserMediaPlayerManagerEfl*
- MediaWebContentsObserver::GetMediaPlayerManager(
- RenderFrameHost* render_frame_host) {
- uintptr_t key = reinterpret_cast<uintptr_t>(render_frame_host);
- if (!media_player_managers_.contains(key)) {
- media_player_managers_.set(
- key,
- make_scoped_ptr(
- BrowserMediaPlayerManagerEfl::Create(render_frame_host)));
- }
- return media_player_managers_.get(key);
-}
-
-} // namespace content
+++ /dev/null
-// Copyright 2014 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 CONTENT_BROWSER_MEDIA_MEDIA_WEB_CONTENTS_OBSERVER_EFL_H_
-#define CONTENT_BROWSER_MEDIA_MEDIA_WEB_CONTENTS_OBSERVER_EFL_H_
-
-#include "base/compiler_specific.h"
-#include "base/containers/scoped_ptr_hash_map.h"
-#include "content/common/content_export.h"
-#include "content/public/browser/web_contents_observer.h"
-
-namespace content {
-
-class BrowserMediaPlayerManagerEfl;
-
-// This class manages all RenderFrame based media related managers at the
-// browser side. It receives IPC messages from media RenderFrameObservers and
-// forwards them to the corresponding managers. The managers are responsible
-// for sending IPCs back to the RenderFrameObservers at the render side.
-class CONTENT_EXPORT MediaWebContentsObserver : public WebContentsObserver {
- public:
- explicit MediaWebContentsObserver(WebContents* web_contents);
- MediaWebContentsObserver(const MediaWebContentsObserver&) = delete;
- MediaWebContentsObserver& operator=(const MediaWebContentsObserver&) = delete;
- virtual ~MediaWebContentsObserver();
-
- MediaWebContentsObserver(const MediaWebContentsObserver&) = delete;
- MediaWebContentsObserver& operator=(const MediaWebContentsObserver&) = delete;
-
- // WebContentsObserver implementations.
- virtual void RenderFrameDeleted(RenderFrameHost* render_frame_host) override;
- virtual bool OnMessageReceived(const IPC::Message& message,
- RenderFrameHost* render_frame_host) override;
-
- // Gets the media player manager associated with |render_frame_host|. Creates
- // a new one if it doesn't exist. The caller doesn't own the returned pointer.
- BrowserMediaPlayerManagerEfl* GetMediaPlayerManager(
- RenderFrameHost* render_frame_host);
-
- private:
- // Map from RenderFrameHost* to BrowserMediaPlayerManagerEfl.
- typedef base::ScopedPtrHashMap<uintptr_t,
- scoped_ptr<BrowserMediaPlayerManagerEfl>>
- MediaPlayerManagerMap;
- MediaPlayerManagerMap media_player_managers_;
-};
-
-} // namespace content
-
-#endif // CONTENT_BROWSER_MEDIA_MEDIA_WEB_CONTENTS_OBSERVER_EFL_H_
]
}
-if (tizen_multimedia_support) {
- external_content_common_efl_configs += [
- "//tizen_src/build:capi-media-player",
- "//tizen_src/build:libcapi-media-player",
- "//tizen_src/build:gstreamer",
- "//tizen_src/build:libgstreamer",
- ]
-}
-
##############################################################################
# Dependency
##############################################################################
external_content_common_efl_sources = [
"//tizen_src/chromium_impl/content/common/content_client_export.cc",
"//tizen_src/chromium_impl/content/common/content_client_export.h",
+ "//tizen_src/chromium_impl/content/common/cursors/webcursor_efl.cc",
+ "//tizen_src/chromium_impl/content/common/cursors/webcursor_efl.h",
"//tizen_src/chromium_impl/content/common/locale_efl.cc",
"//tizen_src/chromium_impl/content/common/locale_efl.h",
"//tizen_src/chromium_impl/content/common/message_generator_efl.cc",
"//tizen_src/chromium_impl/content/common/message_generator_efl.h",
- "//tizen_src/chromium_impl/content/common/paths_efl.h",
"//tizen_src/chromium_impl/content/common/paths_efl.cc",
+ "//tizen_src/chromium_impl/content/common/paths_efl.h",
"//tizen_src/chromium_impl/content/common/render_messages_efl.h",
- "//tizen_src/chromium_impl/content/common/cursors/webcursor_efl.cc",
- "//tizen_src/chromium_impl/content/common/cursors/webcursor_efl.h",
"//tizen_src/chromium_impl/content/common/wrt/wrt_url_parse.h",
]
"//tizen_src/chromium_impl/content/common/tts_utterance_request_efl.h",
]
}
-
-if (tizen_multimedia_support) {
- external_content_common_efl_sources += [
- "//tizen_src/chromium_impl/content/common/media/efl/media_player_messages_enums_efl.h",
- "//tizen_src/chromium_impl/content/common/media/efl/media_player_messages_efl.h",
- "//tizen_src/chromium_impl/content/common/gpu/media/efl/tizen_video_decode_accelerator.h",
- "//tizen_src/chromium_impl/content/common/gpu/media/efl/tizen_video_decode_accelerator.cc",
- "//tizen_src/chromium_impl/content/common/gpu/media/efl/tizen_video_encode_accelerator.h",
- "//tizen_src/chromium_impl/content/common/gpu/media/efl/tizen_video_encode_accelerator.cc",
- ]
-}
+++ /dev/null
-// Copyright 2014 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.
-
-#include "content/common/gpu/media/efl/tizen_video_decode_accelerator.h"
-
-#include <gst/app/gstappsink.h>
-#include <gst/app/gstappsrc.h>
-#include <gst/gst.h>
-#include <gst/video/gstvideosink.h>
-#include <gst/video/video.h>
-#include <gst/video/videooverlay.h>
-
-#include "base/bind.h"
-#include "base/memory/shared_memory.h"
-#include "base/message_loop/message_loop.h"
-#include "base/process/process.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/thread_task_runner_handle.h"
-#include "base/timer/timer.h"
-#include "media/base/video_frame.h"
-
-using media::VideoFrame;
-
-namespace {
-
-struct GstElementDeleter {
- void operator()(GstElement* ptr) const {
- DCHECK(ptr != NULL);
- gst_object_unref(ptr);
- }
-};
-
-// Gstreamer elements and names.
-const char* kDecoderName = "decoder";
-const char* kParserElement = "h264parse";
-#if defined(TIZEN_MULTIMEDIA_USE_HW_CODEC)
-const char* kDecoderGstElement = "omxh264dec";
-const char* kVideoConvertElement = "fimcconvert";
-const char* kCapsFilterElement = "capsfilter";
-#else
-const char* kDecoderGstElement = "avdec_h264";
-#endif
-
-} // namespace
-
-namespace content {
-
-enum {
- MAX_BITRATE = 2000000, // bps.
- INPUT_BUFFER_SIZE = MAX_BITRATE / 8, // bytes. 1 sec for H.264 HD video.
- ID_LAST = 0x3FFFFFFF, // wrap round ID after this
-};
-
-media::VideoDecodeAccelerator* CreateTizenVideoDecodeAccelerator() {
- return new TizenVideoDecodeAccelerator();
-}
-
-media::VideoDecodeAccelerator::SupportedProfiles GetSupportedTizenProfiles() {
- media::VideoDecodeAccelerator::SupportedProfiles profiles;
- media::VideoDecodeAccelerator::SupportedProfile profile;
- profile.profile = media::H264PROFILE_MAIN;
- profile.min_resolution.SetSize(0, 0);
- profile.max_resolution.SetSize(1920, 1080); // FHD
- profiles.push_back(profile);
-
- return profiles;
-}
-
-struct TizenVideoDecodeAccelerator::BitstreamBufferRef {
- BitstreamBufferRef(
- base::WeakPtr<media::VideoDecodeAccelerator::Client> client,
- const scoped_refptr<base::SingleThreadTaskRunner>& client_task_runner,
- base::SharedMemory* shm,
- size_t size,
- int32_t input_id)
- : client_(client),
- client_task_runner_(client_task_runner),
- shm_(shm),
- size_(size),
- bytes_used_(0),
- input_id_(input_id),
- gst_buffer_(NULL) {}
-
- ~BitstreamBufferRef() {
- if (input_id_ < 0)
- return;
- client_task_runner_->PostTask(
- FROM_HERE,
- base::BindOnce(
- &media::VideoDecodeAccelerator::Client::NotifyEndOfBitstreamBuffer,
- client_, input_id_));
- }
-
- static void Destruct(gpointer data) {
- DCHECK(data != NULL);
- BitstreamBufferRef* pRef = static_cast<BitstreamBufferRef*>(data);
- delete pRef;
- }
-
- base::WeakPtr<media::VideoDecodeAccelerator::Client> client_;
- scoped_refptr<base::SingleThreadTaskRunner> client_task_runner_;
- scoped_ptr<base::SharedMemory> shm_;
- size_t size_;
- off_t bytes_used_;
- int32_t input_id_;
- GstBuffer* gst_buffer_;
-};
-
-struct TizenVideoDecodeAccelerator::Impl {
- Impl()
- : can_feed_(true),
- is_destroying_(false),
- pipeline_(NULL),
- sink_(NULL),
- appsrc_(NULL),
- io_task_runner_(base::ThreadTaskRunnerHandle::Get()),
- gst_thread_("TizenDecoderThreadGst"),
- bitstream_buffer_id_(0),
- caps_width_(0),
- caps_height_(0) {}
-
- void DeliverVideoFrame(GstSample* sample, gfx::Rect frame_size);
- bool CreateAppSrcElement();
- bool CreateAppSinkElement();
- static GstFlowReturn OnDecoded(GstAppSink* sink, gpointer app_data);
- static void OnSinkCapsChanged(GstPad* sink_pad, GParamSpec* gparamspec,
- void* user_data);
-
- static GstBusSyncReply OnBusMessage(
- GstBus* bus, GstMessage* msg, gpointer data) {
- switch (GST_MESSAGE_TYPE(msg)) {
- case GST_MESSAGE_ERROR: {
- gchar* debug = NULL;
- GError* error = NULL;
- gst_message_parse_error(msg, &error, &debug);
- LOG(ERROR) << " GSTError happens from bus at "
- << GST_OBJECT_NAME(msg->src)
- << ":" << error->message;
- LOG(ERROR) << " Debugging Info: "
- << (debug != NULL ? debug : "none");
- g_error_free(error);
- g_free(debug);
- break;
- }
- default:
- break;
- }
- return GST_BUS_PASS;
- }
-
- static void StartFeed(GstAppSrc* source, guint size, gpointer app) {
- DCHECK(source);
- content::TizenVideoDecodeAccelerator::Impl* impl =
- static_cast<content::TizenVideoDecodeAccelerator::Impl*>(app);
- impl->can_feed_ = true;
- }
-
- static void StopFeed(GstAppSrc* source, gpointer app) {
- DCHECK(source);
- content::TizenVideoDecodeAccelerator::Impl* impl =
- static_cast<content::TizenVideoDecodeAccelerator::Impl*>(app);
- impl->can_feed_ = false;
- }
-
- volatile bool can_feed_;
- volatile bool is_destroying_;
- GstElement* pipeline_;
- GstElement* sink_;
- GstElement* appsrc_;
- scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
- scoped_ptr<base::WeakPtrFactory<Client> > io_client_weak_factory_;
- base::Thread gst_thread_;
- int bitstream_buffer_id_;
- int caps_width_;
- int caps_height_;
-};
-
-TizenVideoDecodeAccelerator::TizenVideoDecodeAccelerator()
- : impl_(NULL) {
-}
-
-TizenVideoDecodeAccelerator::~TizenVideoDecodeAccelerator() {
-}
-
-bool TizenVideoDecodeAccelerator::Initialize(const Config& config,
- Client* client) {
- GError* error = NULL;
- GstElement* gst_decoder = NULL;
- GstElement* gst_parser = NULL;
- GstBus* gst_bus = NULL;
- GstPad* video_sink_pad = NULL;
- scoped_ptr<GstElement, GstElementDeleter> gst_pipeline;
- CHECK(impl_ == NULL);
- impl_ = new Impl();
- impl_->io_client_weak_factory_.reset(
- new base::WeakPtrFactory<Client>(client));
-
- switch (config.profile) {
- case media::H264PROFILE_BASELINE:
- DVLOG(1) << "Initialize(): profile -> H264PROFILE_BASELINE";
- break;
- case media::H264PROFILE_MAIN:
- DVLOG(1) << "Initialize(): profile -> H264PROFILE_MAIN";
- break;
- default:
- LOG(ERROR) << "Initialize(): unsupported profile=" << config.profile;
- return false;
- };
-
- if (!gst_is_initialized() && !gst_init_check(NULL, NULL, &error)) {
- LOG(ERROR) << "Cannot initialize gstreamer.";
- g_error_free(error);
- return false;
- }
-
- // pipeline initialization.
- gst_pipeline.reset(gst_pipeline_new("h264_decode"));
- if (!gst_pipeline) {
- LOG(ERROR) << "Cannot initialize gst pipeline.";
- return false;
- }
- if (!(gst_bus = gst_pipeline_get_bus(GST_PIPELINE(gst_pipeline.get())))) {
- return false;
- }
- gst_bus_set_sync_handler(gst_bus, Impl::OnBusMessage, impl_, NULL);
- gst_object_unref(gst_bus);
-
- // appsrc initialization.
- if (!impl_->CreateAppSrcElement()) {
- return false;
- }
- if (!gst_bin_add(GST_BIN(gst_pipeline.get()), impl_->appsrc_)) {
- gst_object_unref(impl_->appsrc_);
- impl_->appsrc_ = NULL;
- return false;
- }
-
- DVLOG(1) << "######################################";
- DVLOG(1) << "USING " << kDecoderGstElement <<" DECODER ";
- DVLOG(1) << "######################################";
-
- // decoder initialization.
- if (!(gst_decoder = gst_element_factory_make(kDecoderGstElement,
- kDecoderName))) {
- LOG(ERROR) << "Cannot create " << kDecoderGstElement << ".";
- return false;
- }
- if (!gst_bin_add(GST_BIN(gst_pipeline.get()), gst_decoder)) {
- LOG(ERROR) << "Cannot add " << kDecoderGstElement << " to pipeline.";
- gst_object_unref(gst_decoder);
- return false;
- }
-
- // parser initialization
- if (!(gst_parser = gst_element_factory_make(kParserElement, "h264parse"))) {
- LOG(ERROR) << "Cannot create " << kParserElement;
- return false;
- }
- if (!gst_bin_add(GST_BIN(gst_pipeline.get()), gst_parser)) {
- LOG(ERROR) << "Cannot add " << kParserElement << " into decoder pipeline.";
- gst_object_unref(gst_parser);
- return false;
- }
-
- // appsink initialization
- if (!impl_->CreateAppSinkElement()) {
- LOG(ERROR) << "Could not create and add appsink element";
- return false;
- }
- if (!gst_bin_add(GST_BIN(gst_pipeline.get()), impl_->sink_)) {
- gst_object_unref(impl_->sink_);
- impl_->sink_ = NULL;
- return false;
- }
-
-#if defined(TIZEN_MULTIMEDIA_USE_HW_CODEC)
- GstElement* video_filter = NULL;
- GstElement* gst_converter = NULL;
- if (!(gst_converter = gst_element_factory_make(kVideoConvertElement,
- kVideoConvertElement))) {
- LOG(ERROR) << "Cannot create "<< kVideoConvertElement;
- return false;
- }
- if (!gst_bin_add(GST_BIN(gst_pipeline.get()), gst_converter)) {
- LOG(ERROR) << "Cannot add " << kVideoConvertElement << " into pipeline.";
- gst_object_unref(gst_converter);
- return false;
- }
- if (!(video_filter = gst_element_factory_make(kCapsFilterElement,
- kCapsFilterElement))) {
- LOG(ERROR) << "Cannot create " << kCapsFilterElement;
- return false;
- }
- if (!gst_bin_add(GST_BIN(gst_pipeline.get()), video_filter)) {
- LOG(ERROR) << "Cannot add " << kCapsFilterElement << " into pipeline.";
- gst_object_unref(video_filter);
- return false;
- }
-#endif
-
- if (!(video_sink_pad =
- gst_element_get_static_pad(impl_->sink_, "sink"))) {
- LOG(ERROR) << "Could not create video sink pad";
- return false;
- }
- g_signal_connect(
- video_sink_pad, "notify::caps",
- G_CALLBACK(&Impl::OnSinkCapsChanged), impl_);
- gst_object_unref(video_sink_pad);
-
- if (!gst_element_link_many(impl_->appsrc_, gst_parser, gst_decoder,
-#if defined(TIZEN_MULTIMEDIA_USE_HW_CODEC)
- gst_converter, video_filter,
-#endif
- impl_->sink_, NULL)) {
- LOG(ERROR) << "Cannot link some elements in decode pipeline";
- return false;
- }
-
-#if defined(USE_OMX_DECODER)
- g_object_set(G_OBJECT(video_filter), "caps",
- gst_caps_new_simple("video/x-raw",
- "format", G_TYPE_STRING, "I420",
- NULL), NULL);
-#endif
-
- if (!impl_->gst_thread_.Start()) {
- LOG(ERROR) << "gst_thread_ failed to start";
- return false;
- }
-
- GST_DEBUG_BIN_TO_DOT_FILE(GST_BIN(gst_pipeline.get()),
- GST_DEBUG_GRAPH_SHOW_ALL,
- "decoder_graph.dot");
-
- impl_->pipeline_ = gst_pipeline.release();
-
- impl_->gst_thread_.message_loop()->PostTask(
- FROM_HERE, base::BindOnce(&TizenVideoDecodeAccelerator::StartDecoder,
- base::Unretained(this)));
- return true;
-}
-
-void TizenVideoDecodeAccelerator::Decode(
- const media::BitstreamBuffer& bitstream_buffer) {
- scoped_ptr<BitstreamBufferRef> buffer_ref;
- scoped_ptr<base::SharedMemory> shm(
- new base::SharedMemory(bitstream_buffer.handle(), true));
-
- if (!shm->Map(bitstream_buffer.size())) {
- LOG(ERROR) << "Could not map bitstream_buffer";
- NotifyError(media::VideoDecodeAccelerator::UNREADABLE_INPUT);
- return;
- }
-
- buffer_ref.reset(new BitstreamBufferRef(
- impl_->io_client_weak_factory_->GetWeakPtr(),
- base::ThreadTaskRunnerHandle::Get(),
- shm.release(),
- bitstream_buffer.size(),
- bitstream_buffer.id()));
-
- if (!buffer_ref) {
- return;
- }
-
- if (impl_->can_feed_ && !impl_->is_destroying_) {
- impl_->gst_thread_.message_loop()->PostTask(
- FROM_HERE,
- base::BindOnce(&TizenVideoDecodeAccelerator::OnDecode,
- base::Unretained(this), base::Passed(&buffer_ref)));
- } else {
- DVLOG(2) << "Frame drop on decoder:"
- << " INPUT Q is FULL";
- }
-}
-
-void TizenVideoDecodeAccelerator::AssignPictureBuffers(
- const std::vector<media::PictureBuffer>& buffers) {
- NOTIMPLEMENTED();
-}
-
-void TizenVideoDecodeAccelerator::ReusePictureBuffer(
- int32_t picture_buffer_id) {
- NOTIMPLEMENTED();
-}
-
-void TizenVideoDecodeAccelerator::Flush() {
- NOTIMPLEMENTED();
-}
-
-void TizenVideoDecodeAccelerator::Reset() {
- NOTIMPLEMENTED();
-}
-
-void TizenVideoDecodeAccelerator::Destroy() {
- if (impl_ != NULL) {
- if (impl_->gst_thread_.IsRunning()) {
- impl_->gst_thread_.Stop();
- }
-
- if (impl_->appsrc_)
- gst_app_src_end_of_stream(GST_APP_SRC(impl_->appsrc_));
-
- impl_->is_destroying_ = true;
- if (impl_->pipeline_) {
- gst_element_set_state(impl_->pipeline_, GST_STATE_NULL);
- gst_object_unref(GST_OBJECT(impl_->pipeline_));
- impl_->pipeline_ = NULL;
- }
- delete impl_;
- impl_ = NULL;
- }
- delete this;
-}
-
-bool TizenVideoDecodeAccelerator::CanDecodeOnIOThread(){
- return false;
-}
-
-void TizenVideoDecodeAccelerator::StartDecoder() {
- gst_element_set_state(impl_->pipeline_, GST_STATE_PLAYING);
-};
-
-void TizenVideoDecodeAccelerator::Impl::OnSinkCapsChanged(
- GstPad* sink_pad, GParamSpec* gparamspec, void* user_data) {
- content::TizenVideoDecodeAccelerator::Impl* impl =
- static_cast<TizenVideoDecodeAccelerator::Impl*>(user_data);
- GstCaps* caps = gst_pad_get_current_caps(GST_PAD(sink_pad));
- if (!caps)
- return;
- GstVideoInfo info;
- gst_video_info_init(&info);
- if (gst_video_info_from_caps(&info, caps)) {
- impl->caps_width_ = info.width;
- impl->caps_height_ = info.height;
- }
- gst_caps_unref(caps);
-}
-
-GstFlowReturn TizenVideoDecodeAccelerator::Impl::OnDecoded(
- GstAppSink* sink, gpointer app_data) {
- content::TizenVideoDecodeAccelerator::Impl* self =
- static_cast<TizenVideoDecodeAccelerator::Impl*>(app_data);
- GstSample* sample = gst_app_sink_pull_sample(GST_APP_SINK(sink));
- if (!sample) {
- LOG(ERROR) << "DECODING FRAME FAILED : frame_id "
- << self->bitstream_buffer_id_;
- return GST_FLOW_ERROR;
- }
- // FIXME: SONAL
- // OnSinkCapsChanged callback is not called for Appsink on Tizen,
- // This is an alternate approach to get sample info.
-#if !BUILDFLAG(IS_TIZEN)
- if (!self->caps_width_ || !self->caps_height_) {
- const GstStructure* str = gst_sample_get_info(sample);
- if (!str ||
- !gst_structure_get_int(str, "width", &self->caps_width_) ||
- !gst_structure_get_int(str, "height", &self->caps_height_)) {
- LOG(ERROR) << "Buffer information could not be obtained";
- gst_sample_unref(sample);
- return GST_FLOW_ERROR;
- }
- }
-#endif
- gfx::Rect frame_size =
- gfx::Rect(self->caps_width_, self->caps_height_);
- self->gst_thread_.message_loop()->PostTask(
- FROM_HERE,
- base::BindOnce(&TizenVideoDecodeAccelerator::Impl::DeliverVideoFrame,
- base::Unretained(self), sample, frame_size));
- return GST_FLOW_OK;
-}
-
-bool TizenVideoDecodeAccelerator::Impl::CreateAppSrcElement() {
- if (!(appsrc_ = gst_element_factory_make("appsrc", "src"))) {
- LOG(ERROR) << "Cannot initialize gst appsrc.";
- return false;
- }
- static GstAppSrcCallbacks appsrc_callbacks =
- {&Impl::StartFeed, &Impl::StopFeed, NULL};
- gst_app_src_set_max_bytes(GST_APP_SRC(appsrc_), INPUT_BUFFER_SIZE);
- gst_app_src_set_callbacks(GST_APP_SRC(appsrc_), &appsrc_callbacks,
- static_cast<gpointer>(this), NULL);
- g_object_set(G_OBJECT(appsrc_),
- "is-live", TRUE,
- "block", FALSE,
- "min-percent", 80, // if buffer below 80%, need-data emits.
- "stream-type", GST_APP_STREAM_TYPE_STREAM,
- NULL);
- GstCaps* video_caps = gst_caps_from_string("video/x-h264,framerate=30/1");
- if (!video_caps) {
- gst_object_unref(appsrc_);
- return false;
- }
- gst_app_src_set_caps(GST_APP_SRC(appsrc_), video_caps);
- gst_caps_unref(video_caps);
- return true;
-}
-
-bool TizenVideoDecodeAccelerator::Impl::CreateAppSinkElement() {
- if (!(sink_ = gst_element_factory_make("appsink", "sink"))) {
- LOG(ERROR) << "Appsink could not be created";
- return false;
- }
-
- GstAppSinkCallbacks appsink_callbacks = {NULL, NULL, &OnDecoded, NULL};
- gst_app_sink_set_callbacks(GST_APP_SINK(sink_),
- &appsink_callbacks,
- static_cast<gpointer>(this),
- NULL);
- gst_app_sink_set_max_buffers(GST_APP_SINK(sink_), 1);
- return true;
-}
-
-void TizenVideoDecodeAccelerator::Impl::DeliverVideoFrame(
- GstSample* sample, gfx::Rect frame_size) {
- base::SharedMemory shared_memory;
- base::SharedMemoryHandle shared_memory_handle;
-
- GstBuffer* buffer = gst_sample_get_buffer(sample);
- GstMapInfo map;
- if (!buffer || !gst_buffer_map(buffer, &map, GST_MAP_READ)) {
- LOG(ERROR) << "No Decoded Buffer or contains invalid info!";
- gst_sample_unref(sample);
- return;
- }
-
- if (!map.data || !(map.size > 0) ||
- !shared_memory.CreateAndMapAnonymous(map.size)) {
- LOG(ERROR) << "Shared Memory creation failed.";
- } else {
- if (!shared_memory.ShareToProcess(base::GetCurrentProcessHandle(),
- &shared_memory_handle)) {
- LOG(ERROR) << "Could not get handle of Shared Memory";
- } else {
- memcpy(shared_memory.memory(), map.data, map.size);
- io_task_runner_->PostTask(
- FROM_HERE,
- base::BindOnce(
- &media::VideoDecodeAccelerator::Client::NotifyDecodeDone,
- io_client_weak_factory_->GetWeakPtr(), shared_memory_handle,
- bitstream_buffer_id_, map.size, frame_size));
- bitstream_buffer_id_ = (bitstream_buffer_id_ + 1) & ID_LAST;
- }
- }
- gst_buffer_unmap(buffer, &map);
- gst_sample_unref(sample);
-}
-
-void TizenVideoDecodeAccelerator::OnDecode(
- scoped_ptr<BitstreamBufferRef> buffer_ref) {
- if (!buffer_ref) {
- return;
- }
- buffer_ref->gst_buffer_ =
- gst_buffer_new_wrapped_full(
- GST_MEMORY_FLAG_READONLY,
- static_cast<guint8*>(buffer_ref->shm_->memory()),
- buffer_ref->size_,
- 0,
- buffer_ref->size_,
- reinterpret_cast<guint8*>(buffer_ref.get()),
- BitstreamBufferRef::Destruct);
- if (!buffer_ref->gst_buffer_ || !GST_IS_BUFFER(buffer_ref->gst_buffer_)) {
- LOG(ERROR) << " gst_buffer_new_wrapped_full failed to allocate memory.!";
- return;
- }
- if (GST_FLOW_OK !=
- gst_app_src_push_buffer(GST_APP_SRC(impl_->appsrc_),
- buffer_ref->gst_buffer_)) {
- LOG(ERROR) << " fail to push buffer into decoder pipeline";
- return;
- }
-
- // lifecycle of buffer_ref will be handled by gstreamer.
- ignore_result(buffer_ref.release());
-}
-
-void TizenVideoDecodeAccelerator::NotifyError(
- media::VideoDecodeAccelerator::Error error) {
- if (impl_->io_client_weak_factory_->GetWeakPtr()) {
- impl_->io_client_weak_factory_->GetWeakPtr()->NotifyError(error);
- }
-}
-
-} // namespace content
-
+++ /dev/null
-// Copyright 2014 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 CONTENT_COMMON_GPU_MEDIA_EFL_TIZEN_VIDEO_DECODE_ACCELERATOR_H_
-#define CONTENT_COMMON_GPU_MEDIA_EFL_TIZEN_VIDEO_DECODE_ACCELERATOR_H_
-
-#include "base/synchronization/lock.h"
-#include "base/threading/thread.h"
-#include "content/common/content_export.h"
-#include "media/video/video_decode_accelerator.h"
-
-namespace content {
-
-class CONTENT_EXPORT TizenVideoDecodeAccelerator
- : public media::VideoDecodeAccelerator {
- public:
- TizenVideoDecodeAccelerator();
- ~TizenVideoDecodeAccelerator() override;
-
- TizenVideoDecodeAccelerator(const TizenVideoDecodeAccelerator&) = delete;
- TizenVideoDecodeAccelerator& operator=(const TizenVideoDecodeAccelerator&) =
- delete;
-
- bool Initialize(const Config& config, Client* client) override;
- void Decode(const media::BitstreamBuffer& bitstream_buffer) override;
- void AssignPictureBuffers(
- const std::vector<media::PictureBuffer>& buffers) override;
- void ReusePictureBuffer(int32_t picture_buffer_id) override;
- void Flush() override;
- void Reset() override;
- void Destroy() override;
- bool CanDecodeOnIOThread() override;
-
- private:
- struct BitstreamBufferRef;
- struct Impl;
-
- void OnDecode(scoped_ptr<BitstreamBufferRef> buffer_ref);
- void NotifyError(media::VideoDecodeAccelerator::Error error);
- void StartDecoder();
-
- Impl* impl_;
-};
-
-} // namespace content
-
-#endif // CONTENT_COMMON_GPU_MEDIA_EFL_TIZEN_VIDEO_DECODE_ACCELERATOR_H_
+++ /dev/null
-// Copyright 2014 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.
-
-#include "content/common/gpu/media/efl/tizen_video_encode_accelerator.h"
-
-#include <gst/app/gstappsink.h>
-#include <gst/app/gstappsrc.h>
-#include <gst/gst.h>
-#include <gst/video/video.h>
-
-#include "base/bind.h"
-#include "base/command_line.h"
-#include "base/logging.h"
-#include "base/message_loop/message_loop.h"
-#include "base/thread_task_runner_handle.h"
-#include "base/timer/timer.h"
-#include "gpu/command_buffer/service/gpu_switches.h"
-#include "media/base/bitstream_buffer.h"
-#include "media/base/video_frame.h"
-#include "third_party/webrtc/common_video/libyuv/include/webrtc_libyuv.h"
-
-using media::VideoFrame;
-
-namespace content {
-
-struct GstElementDeleter {
- inline void operator()(GstElement* ptr) const {
- DCHECK(ptr != NULL);
- gst_object_unref(ptr);
- }
-};
-
-enum {
- // Arbitrary choice.
- INITIAL_FRAMERATE = 30,
- // Until there are non-realtime users, no need for unrequested I-frames.
- INPUT_BUFFER_COUNT = 5, // default input buffer counts of omx_h264enc
- MAX_BUFFERING = 60,
- MAX_FRAME_RATE = 30,
- MAX_BITRATE = 2000000, // Max bitrate in bps
- MAX_OUTPUT_BUFFERS = 30, // Maximum queue size of output buffers
- MAX_WIDTH = 1280,
- MAX_HEIGHT = 720,
-};
-
-// Gstreamer elements and names.
-const char* kEncoderName = "encoder";
-#if BUILDFLAG(IS_TIZEN)
-const char* kEncoderGstElement = "omxh264enc";
-const char* kBitrateProperty = "target-bitrate";
-#else
-const char* kEncoderGstElement = "x264enc";
-const char* kBitrateProperty = "bitrate";
-#endif
-
-media::VideoEncodeAccelerator* CreateTizenVideoEncodeAccelerator() {
- return new TizenVideoEncodeAccelerator();
-}
-
-struct TizenVideoEncodeAccelerator::BitstreamBufferRef {
- BitstreamBufferRef(
- const scoped_refptr<media::VideoFrame>& frame,
- base::WeakPtr<media::VideoEncodeAccelerator::Client> client_delegate,
- const scoped_refptr<base::SingleThreadTaskRunner>& client_task_runner,
- size_t size)
- : frame_(frame),
- client_delegate_(client_delegate),
- client_task_runner_(client_task_runner),
- size_(size),
- bytes_used_(0),
- gst_buffer_(NULL) {}
-
- ~BitstreamBufferRef() {}
-
- static void Destruct(gpointer data) {
- DCHECK(data != NULL);
- BitstreamBufferRef* pRef = static_cast<BitstreamBufferRef*>(data);
- delete pRef;
- }
-
- scoped_refptr<media::VideoFrame> frame_;
- base::WeakPtr<media::VideoEncodeAccelerator::Client> client_delegate_;
- scoped_refptr<base::SingleThreadTaskRunner> client_task_runner_;
- size_t size_;
- off_t bytes_used_;
- GstBuffer* gst_buffer_;
-};
-
-struct TizenVideoEncodeAccelerator::OutputBuffer {
- explicit OutputBuffer(
- GstBuffer* buffer,
- bool key_frame)
- : buffer_(buffer),
- key_frame_(key_frame) {}
-
- virtual ~OutputBuffer() {
- if (buffer_)
- gst_buffer_unref(buffer_);
- buffer_ = NULL;
- }
-
- GstBuffer* buffer_;
- bool key_frame_;
-};
-
-struct TizenVideoEncodeAccelerator::Impl {
- Impl(media::VideoEncodeAccelerator::Client* client,
- scoped_refptr<base::SingleThreadTaskRunner> msg_loop)
- : pipeline_(NULL),
- encoder_(NULL),
- appsrc_(NULL),
- gst_thread_("TizenEncoderThreadGst"),
- enable_framedrop_(false),
- io_client_weak_factory_(client),
- child_task_runner_(msg_loop),
- gst_bitrate_(0),
- is_running_(false),
- is_destroying_(false),
- can_feed_(false) {}
-
- void DeliverVideoFrame();
- bool CreateAppSrcElement();
- static GstFlowReturn OnEncoded(GstAppSink *sink,gpointer data);
- static void StartFeed(GstAppSrc *source, guint size, gpointer data);
- static void StopFeed(GstAppSrc *source, gpointer data);
-
- GstElement* pipeline_;
- GstElement* encoder_;
- GstElement* appsrc_;
- base::Thread gst_thread_;
- bool enable_framedrop_;
- std::vector<media::BitstreamBuffer> encoder_output_queue_;
- base::WeakPtrFactory<
- media::VideoEncodeAccelerator::Client> io_client_weak_factory_;
- const scoped_refptr<base::SingleThreadTaskRunner> child_task_runner_;
- base::Lock destroy_lock_;
- base::ThreadChecker thread_checker_;
- gfx::Size view_size_;
- uint32_t gst_bitrate_;
- volatile bool is_running_;
- volatile bool is_destroying_;
- volatile bool can_feed_;
- base::RepeatingTimer io_timer_;
- std::queue<TizenVideoEncodeAccelerator::OutputBuffer*> output_buffers_;
- base::Lock output_queue_lock_;
-};
-
-void TizenVideoEncodeAccelerator::Impl::DeliverVideoFrame() {
- media::BitstreamBuffer* bs_buffer = NULL;
- bool key_frame = false;
- GstMapInfo map;
- scoped_ptr<base::SharedMemory> shm;
- scoped_ptr<TizenVideoEncodeAccelerator::OutputBuffer> out_buffer = NULL;
-
- if (output_buffers_.empty())
- return;
-
- if (encoder_output_queue_.empty()) {
- // Observed till now that output_buffers_ size does not exceed 4-5.
- // Therefore this code will be called in very rare situations.
- if (output_buffers_.size() >= MAX_OUTPUT_BUFFERS) {
- enable_framedrop_ = true;
- base::AutoLock auto_lock(output_queue_lock_);
- while (!output_buffers_.empty()) {
- out_buffer.reset(output_buffers_.front());
- if (out_buffer->key_frame_)
- break;
- output_buffers_.pop();
- out_buffer.reset(NULL);
- }
- }
- return;
- }
- enable_framedrop_ = false;
- key_frame = output_buffers_.front()->key_frame_;
- bs_buffer = &encoder_output_queue_.back();
- encoder_output_queue_.pop_back();
-
- shm.reset(new base::SharedMemory(bs_buffer->handle(), false));
- if (!shm->Map(bs_buffer->size())) {
- LOG(ERROR) << "Failed to map SHM";
- io_client_weak_factory_.GetWeakPtr()->NotifyError(
- media::VideoEncodeAccelerator::kPlatformFailureError);
- return;
- }
- {
- base::AutoLock auto_lock(output_queue_lock_);
- out_buffer.reset(output_buffers_.front());
- output_buffers_.pop();
- }
-
- if (!gst_buffer_map(out_buffer->buffer_, &map, GST_MAP_READ)) {
- LOG(ERROR) << "Encoded Buffer contains invalid or no info.!";
- return;
- }
-
- if (!map.data && map.size > shm->mapped_size()) {
- LOG(ERROR) << "Encoded buff too large: "
- << map.size << ">" << shm->mapped_size();
- io_client_weak_factory_.GetWeakPtr()->NotifyError(
- media::VideoEncodeAccelerator::kPlatformFailureError);
- } else {
- //copying data to shared memory.
- memcpy(static_cast<uint8_t*>(shm->memory()), map.data, map.size);
- child_task_runner_->PostTask(
- FROM_HERE,
- base::BindOnce(
- &media::VideoEncodeAccelerator::Client::BitstreamBufferReady,
- io_client_weak_factory_.GetWeakPtr(), bs_buffer->id(), map.size,
- key_frame));
- }
- gst_buffer_unmap(out_buffer->buffer_, &map);
-}
-
-bool TizenVideoEncodeAccelerator::Impl::CreateAppSrcElement() {
- if (!(appsrc_ = gst_element_factory_make ("appsrc", "src"))) {
- LOG(ERROR) << "Cannot initialize gst appsrc.";
- return false;
- }
- GstCaps* appsrc_caps = gst_caps_new_simple(
- "video/x-raw",
- "format", G_TYPE_STRING, "I420",
- "width", G_TYPE_INT, view_size_.width(),
- "height", G_TYPE_INT, view_size_.height(),
- "framerate", GST_TYPE_FRACTION, 30, 1,
- "rotate", G_TYPE_INT, 0,
- NULL);
- GstAppSrcCallbacks appsrc_callbacks =
- { &TizenVideoEncodeAccelerator::Impl::StartFeed,
- &TizenVideoEncodeAccelerator::Impl::StopFeed,
- NULL };
-
- guint64 max_input_buffer =
- INPUT_BUFFER_COUNT * VideoFrame::AllocationSize(media::PIXEL_FORMAT_I420,
- view_size_);
- gst_app_src_set_callbacks(GST_APP_SRC(appsrc_), &appsrc_callbacks,
- static_cast<gpointer>(this), NULL);
- gst_app_src_set_max_bytes(GST_APP_SRC(appsrc_), max_input_buffer);
- gst_app_src_set_caps(GST_APP_SRC(appsrc_), appsrc_caps);
-
- g_object_set(G_OBJECT(appsrc_),
- "is-live", TRUE,
- "block", FALSE,
- "do-timestamp", TRUE,
- "min-latency", (gint64)(0),
- "max-latency", (gint64)(0),
- "min-percent", 80, // if buffer below 80%, need-data emits.
- "stream-type", GST_APP_STREAM_TYPE_STREAM,
- "format", GST_FORMAT_DEFAULT,
- NULL);
- gst_caps_unref(appsrc_caps);
- return true;
-}
-
-GstFlowReturn TizenVideoEncodeAccelerator::Impl::OnEncoded(
- GstAppSink *sink, gpointer data) {
- TizenVideoEncodeAccelerator::Impl* impl =
- static_cast<TizenVideoEncodeAccelerator::Impl*>(data);
-
- GstSample* sample = gst_app_sink_pull_sample(GST_APP_SINK(sink));
- GstBuffer* buffer = gst_sample_get_buffer(sample);
- GstMapInfo map;
- if (!buffer || !gst_buffer_map(buffer, &map, GST_MAP_READ)) {
- LOG(ERROR) << "Encoded Buffer contains invalid or no info!";
- gst_sample_unref(sample);
- return GST_FLOW_ERROR;
- }
-
- if (map.data) {
- bool key_frame = false;
- if (!GST_BUFFER_FLAG_IS_SET(buffer, GST_BUFFER_FLAG_DELTA_UNIT)) {
- key_frame = true;
- }
- base::AutoLock auto_lock(impl->output_queue_lock_);
- impl->output_buffers_.push(
- new TizenVideoEncodeAccelerator::OutputBuffer(gst_buffer_ref(buffer),
- key_frame));
- }
- gst_buffer_unmap(buffer, &map);
- gst_sample_unref(sample);
- return GST_FLOW_OK;
-}
-
-void TizenVideoEncodeAccelerator::Impl::StartFeed(
- GstAppSrc* source, guint size, gpointer data) {
- TizenVideoEncodeAccelerator::Impl* impl =
- static_cast<TizenVideoEncodeAccelerator::Impl*>(data);
- DCHECK(impl);
- impl->can_feed_ = true;
-}
-
-void TizenVideoEncodeAccelerator::Impl::StopFeed(
- GstAppSrc* source, gpointer data) {
- TizenVideoEncodeAccelerator::Impl* impl =
- static_cast<TizenVideoEncodeAccelerator::Impl*>(data);
- DCHECK(impl);
- impl->can_feed_ = false;
-}
-
-TizenVideoEncodeAccelerator::TizenVideoEncodeAccelerator()
- : impl_(NULL) {}
-
-TizenVideoEncodeAccelerator::~TizenVideoEncodeAccelerator() {}
-
-std::vector<media::VideoEncodeAccelerator::SupportedProfile>
-TizenVideoEncodeAccelerator::GetSupportedProfiles() {
- std::vector<media::VideoEncodeAccelerator::SupportedProfile> profiles;
- media::VideoEncodeAccelerator::SupportedProfile profile;
- profile.profile = media::H264PROFILE_BASELINE;
- profile.max_resolution.SetSize(MAX_WIDTH, MAX_HEIGHT);
- profile.max_framerate_numerator = MAX_FRAME_RATE;
- profile.max_framerate_denominator = 1;
- profiles.push_back(profile);
-
- return profiles;
-}
-
-bool TizenVideoEncodeAccelerator::Initialize(
- media::VideoPixelFormat input_format,
- const gfx::Size& input_visible_size,
- media::VideoCodecProfile output_profile,
- uint32_t initial_bitrate,
- Client* client) {
- DVLOG(1) << " size :" << input_visible_size.ToString()
- << " max bitrate :" << MAX_BITRATE << "bps";
- DCHECK(impl_ == NULL);
- if (media::H264PROFILE_MIN > output_profile ||
- media::H264PROFILE_MAX < output_profile) {
- NOTREACHED();
- return false;
- }
-
- impl_ = new Impl(client, base::ThreadTaskRunnerHandle::Get());
- impl_->gst_bitrate_ = initial_bitrate;
- impl_->view_size_ = input_visible_size;
- impl_->gst_thread_.Start();
-
- if (!StartEncoder()) {
- delete impl_;
- impl_ = NULL;
- return false;
- }
-
- base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::BindOnce(
- &media::VideoEncodeAccelerator::Client::RequireBitstreamBuffers,
- impl_->io_client_weak_factory_.GetWeakPtr(),
- (unsigned int)INPUT_BUFFER_COUNT, input_visible_size,
- MAX_BITRATE / 8)); // Maximum bytes for a frame by MAX_BITRATE.
- return true;
-}
-
-void TizenVideoEncodeAccelerator::Encode(
- const scoped_refptr<media::VideoFrame>& frame,
- bool force_keyframe) {
- size_t frame_size = VideoFrame::AllocationSize(media::PIXEL_FORMAT_I420,
- frame->coded_size());
- DVLOG(3) << " coded_size :" << frame->coded_size().ToString()
- << " natural_size :" << frame->natural_size().ToString();
-
- scoped_ptr<BitstreamBufferRef> buffer_ref;
-
- buffer_ref.reset(
- new BitstreamBufferRef(frame,
- impl_->io_client_weak_factory_.GetWeakPtr(),
- impl_->child_task_runner_,
- frame_size));
-
- if (!buffer_ref) {
- LOG(ERROR) << "malloc failed";
- return;
- }
-
- if (impl_->can_feed_ && !impl_->is_destroying_) {
- impl_->gst_thread_.message_loop()->PostTask(
- FROM_HERE, base::BindOnce(&TizenVideoEncodeAccelerator::OnEncode,
- base::Unretained(this),
- base::Passed(&buffer_ref), force_keyframe));
- } else {
- DVLOG(2) << " [WEBRTC] . FRAME DROP :"
- << " can_feed_:" << impl_->can_feed_
- << " is_destroying_:" << impl_->is_destroying_;
- }
-}
-
-void TizenVideoEncodeAccelerator::UseOutputBitstreamBuffer(
- const media::BitstreamBuffer& buffer) {
- impl_->gst_thread_.message_loop()->PostTask(
- FROM_HERE,
- base::BindOnce(&TizenVideoEncodeAccelerator::OnUseOutputBitstreamBuffer,
- base::Unretained(this), buffer));
-}
-
-void TizenVideoEncodeAccelerator::RequestEncodingParametersChange(
- uint32_t bitrate, uint32_t framerate) {
- DVLOG(2) << " bitrate: " << bitrate
- << " framerate: " << framerate;
- if (bitrate > 0 && bitrate != impl_->gst_bitrate_) {
- impl_->gst_bitrate_ = bitrate;
- // Omx Encoder expects bitrate in bps whereas ffenc expects bitrate in kbps
- // Information can be gained by gst-inspect
- g_object_set(G_OBJECT(impl_->encoder_), kBitrateProperty,
-#if BUILDFLAG(IS_TIZEN)
- std::min(bitrate, static_cast<uint32_t>(MAX_BITRATE)),
-#else
- std::min(bitrate, static_cast<uint32_t>(MAX_BITRATE)) / 1000,
-#endif
- NULL);
- }
-}
-
-void TizenVideoEncodeAccelerator::Destroy() {
- if (impl_) {
- DCHECK(impl_->thread_checker_.CalledOnValidThread());
- if (impl_->appsrc_)
- gst_app_src_end_of_stream(GST_APP_SRC(impl_->appsrc_));
-
- {
- base::AutoLock auto_lock(impl_->destroy_lock_);
- impl_->is_destroying_ = true;
- }
-
- if (impl_->gst_thread_.IsRunning())
- impl_->gst_thread_.Stop();
- if (impl_->pipeline_) {
- gst_element_set_state(impl_->pipeline_, GST_STATE_NULL);
- gst_object_unref(GST_OBJECT(impl_->pipeline_));
- }
- if (impl_->io_timer_.IsRunning())
- impl_->io_timer_.Stop();
-
- while (!impl_->encoder_output_queue_.empty()) {
- media::BitstreamBuffer bitstream_buffer =
- impl_->encoder_output_queue_.back();
- // created shm and let it go out of scope automatically.
- scoped_ptr<base::SharedMemory> shm(
- new base::SharedMemory(bitstream_buffer.handle(), false));
- impl_->encoder_output_queue_.pop_back();
- }
- scoped_ptr<OutputBuffer> output_buffer = NULL;
- while (!impl_->output_buffers_.empty()) {
- output_buffer.reset(impl_->output_buffers_.front());
- impl_->output_buffers_.pop();
- output_buffer.reset(NULL);
- }
- delete impl_;
- }
- delete this;
-}
-
-void TizenVideoEncodeAccelerator::OnEncode(
- scoped_ptr<BitstreamBufferRef> buffer_ref, bool force_keyframe) {
-
- BitstreamBufferRef* bufref = buffer_ref.release();
- if (bufref == NULL) {
- return;
- }
-
- bufref->gst_buffer_ =
- gst_buffer_new_wrapped_full(
- GST_MEMORY_FLAG_READONLY,
- static_cast<guint8*>(bufref->frame_->data(VideoFrame::kYPlane)),
- bufref->size_,
- 0,
- bufref->size_,
- reinterpret_cast<uint8_t*>(bufref),
- BitstreamBufferRef::Destruct);
- if (!bufref->gst_buffer_ || !GST_IS_BUFFER(bufref->gst_buffer_)) {
- LOG(INFO) << "gst_buffer_new_wrapped_full failed to allocate memory.";
- return;
- }
- if (GST_FLOW_OK !=
- gst_app_src_push_buffer(GST_APP_SRC(impl_->appsrc_),
- bufref->gst_buffer_)) {
- LOG(ERROR) << "Error while pushing buffer int appsrc on encoder.";
- gst_buffer_unref(bufref->gst_buffer_);
- }
-
- return;
-}
-
-void TizenVideoEncodeAccelerator::OnUseOutputBitstreamBuffer(
- const media::BitstreamBuffer& buffer) {
- impl_->encoder_output_queue_.push_back(buffer);
-
- DVLOG(2) << " output buffer is ready to use: " << buffer.id()
- << " out queue size: " << impl_->encoder_output_queue_.size();
-}
-
-bool TizenVideoEncodeAccelerator::StartEncoder() {
- GError* error = NULL;
- GstElement* gst_appsink = NULL;
- scoped_ptr<GstElement, GstElementDeleter> gst_pipeline;
-
- if (!gst_is_initialized() && !gst_init_check(NULL, NULL, &error)) {
- LOG(ERROR) << "Cannot initialize gstreamer.";
- g_error_free(error);
- return false;
- }
-
- // pipeline initialization
- gst_pipeline.reset(gst_pipeline_new("h264_encode"));
- if (!gst_pipeline) {
- LOG(ERROR) << "Cannot initialize gst pipeline.";
- return false;
- }
-
- if (!impl_->CreateAppSrcElement()) {
- return false;
- }
-
- if (!gst_bin_add(GST_BIN(gst_pipeline.get()), impl_->appsrc_)) {
- LOG(ERROR) << "Cannot add gst appsrc to encoder pipeline.";
- gst_object_unref(impl_->appsrc_);
- impl_->appsrc_ = NULL;
- return false;
- }
-
- // appsink initialization
- if (!(gst_appsink = gst_element_factory_make("appsink", "sink"))) {
- LOG(ERROR) << "Cannot create appsink for encoder pipeline.";
- return false;
- }
- if (!gst_bin_add(GST_BIN(gst_pipeline.get()), gst_appsink)) {
- LOG(ERROR) << "Cannot add gst appsink into encoder pipeline.";
- gst_object_unref(gst_appsink);
- return false;
- }
-
- GstAppSinkCallbacks appsink_callbacks =
- { NULL, NULL, &TizenVideoEncodeAccelerator::Impl::OnEncoded, NULL };
- gst_app_sink_set_callbacks(GST_APP_SINK(gst_appsink), &appsink_callbacks,
- static_cast<gpointer>(impl_), NULL);
- gst_app_sink_set_max_buffers(GST_APP_SINK(gst_appsink), 1);
-
- DVLOG(1) << "######################################";
- DVLOG(1) << "USING " << kEncoderGstElement << " ENCODER";
- DVLOG(1) << "######################################";
-
- // encoder initialization
- if (!(impl_->encoder_ = gst_element_factory_make(kEncoderGstElement,
- kEncoderName))) {
- LOG(ERROR) << "Cannot create " << kEncoderGstElement << ".";
- return false;
- }
- if (!gst_bin_add(GST_BIN(gst_pipeline.get()), impl_->encoder_)) {
- LOG(ERROR) << "Cannot add "
- << kEncoderGstElement << "into encoder pipeline.";
- gst_object_unref(impl_->encoder_);
- impl_->encoder_ = NULL;
- return false;
- }
-
-#if BUILDFLAG(IS_TIZEN)
- g_object_set(impl_->encoder_,
- "control-rate", 2, // 1:VBR_CFR 2:CBR_CFR 3:VBR_VFR 4:CBR_VFR
- kBitrateProperty, impl_->gst_bitrate_,
- NULL);
-#else
- // parser initialization
- GstElement* gst_parser = NULL;
- if (!(gst_parser = gst_element_factory_make("videoparse", "parse"))) {
- LOG(ERROR) << "Cannot create videoparse.";
- return false;
- }
- if (!gst_bin_add(GST_BIN(gst_pipeline.get()), gst_parser)) {
- LOG(ERROR) << "Cannot add videoparse to encoder pipeline.";
- gst_object_unref(gst_parser);
- return false;
- }
-
- g_object_set(gst_parser,
- "format", GST_VIDEO_FORMAT_I420,
- "width", impl_->view_size_.width(),
- "height", impl_->view_size_.height(),
- "framerate", INITIAL_FRAMERATE, 1,
- NULL);
-
- g_object_set(impl_->encoder_,
- "byte-stream", TRUE,
- kBitrateProperty, impl_->gst_bitrate_ / 1000, // to kbit/s
- "tune", 0x00000004, NULL);
-#endif
-
- g_object_set(gst_appsink, "sync", FALSE, NULL);
-
- if (!gst_element_link_many(impl_->appsrc_,
-#if !BUILDFLAG(IS_TIZEN)
- gst_parser,
-#endif
- impl_->encoder_, gst_appsink, NULL)) {
- LOG(ERROR) << "Cannot link for encoder pipeline.";
- return false;
- }
-
- if (GST_STATE_CHANGE_FAILURE ==
- gst_element_set_state(gst_pipeline.get(), GST_STATE_PLAYING)) {
- LOG(ERROR) << "Cannot start encoder pipeline.";
- return false;
- }
-
- impl_->io_timer_.Start(FROM_HERE,
- base::TimeDelta::FromMilliseconds(10),
- impl_,
- &TizenVideoEncodeAccelerator::Impl::DeliverVideoFrame);
-
- GST_DEBUG_BIN_TO_DOT_FILE(GST_BIN(gst_pipeline.get()),
- GST_DEBUG_GRAPH_SHOW_ALL,
- "encoder_graph.dot");
-
- impl_->pipeline_ = gst_pipeline.release();
- return true;
-}
-
-} // namespace content
+++ /dev/null
-// Copyright 2014 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 CONTENT_COMMON_GPU_MEDIA_EFL_TIZEN_VIDEO_ENCODE_ACCELERATOR_H_
-#define CONTENT_COMMON_GPU_MEDIA_EFL_TIZEN_VIDEO_ENCODE_ACCELERATOR_H_
-
-#include "base/threading/thread.h"
-#include "base/synchronization/lock.h"
-#include "base/synchronization/waitable_event.h"
-#include "content/common/content_export.h"
-#include "media/video/video_encode_accelerator.h"
-
-namespace content {
-
-class CONTENT_EXPORT TizenVideoEncodeAccelerator
- : public media::VideoEncodeAccelerator {
- public:
- TizenVideoEncodeAccelerator();
- ~TizenVideoEncodeAccelerator() override;
-
- TizenVideoEncodeAccelerator(const TizenVideoEncodeAccelerator&) = delete;
- TizenVideoEncodeAccelerator& operator=(const TizenVideoEncodeAccelerator&) =
- delete;
-
- std::vector<media::VideoEncodeAccelerator::SupportedProfile>
- GetSupportedProfiles() override;
- bool Initialize(media::VideoPixelFormat input_format,
- const gfx::Size& input_visible_size,
- media::VideoCodecProfile output_profile,
- uint32_t initial_bitrate,
- Client* client) override;
- void Encode(const scoped_refptr<media::VideoFrame>& frame,
- bool force_keyframe) override;
- void UseOutputBitstreamBuffer(const media::BitstreamBuffer& buffer) override;
- void RequestEncodingParametersChange(uint32_t bitrate,
- uint32_t framerate) override;
- void Destroy() override;
-
- private:
- struct BitstreamBufferRef;
- struct Impl;
- struct OutputBuffer;
-
- void OnEncode(scoped_ptr<BitstreamBufferRef> buffer_ref, bool force_keyframe);
- void OnUseOutputBitstreamBuffer(const media::BitstreamBuffer& buffer);
- bool StartEncoder();
-
- Impl* impl_;
-};
-
-} // namespace content
-
-#endif // CONTENT_COMMON_GPU_MEDIA_EFL_TIZEN_VIDEO_ENCODE_ACCELERATOR_TIZEN_H_
+++ /dev/null
-// Copyright 2014 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.
-
-// IPC messages for efl media player.
-// Multiply-included message file, hence no include guard.
-
-#include "content/common/content_export.h"
-#include "content/common/media/efl/media_player_messages_enums_efl.h"
-#include "ipc/ipc_message_macros.h"
-#include "media/base/efl/demuxer_stream_player_params_efl.h"
-#include "media/base/efl/media_player_manager_efl.h"
-#include "media/base/media_keys.h"
-#include "third_party/blink/public/platform/WebMediaPlayer.h"
-#include "ui/gfx/geometry/rect_f.h"
-
-#undef IPC_MESSAGE_EXPORT
-#define IPC_MESSAGE_EXPORT CONTENT_EXPORT
-#define IPC_MESSAGE_START MediaPlayerMsgStart
-
-IPC_ENUM_TRAITS(media::AudioCodec)
-IPC_ENUM_TRAITS(blink::WebMediaPlayer::ReadyState)
-IPC_ENUM_TRAITS(blink::WebMediaPlayer::NetworkState)
-IPC_ENUM_TRAITS(media::DemuxerStream::Status)
-IPC_ENUM_TRAITS(media::DemuxerStream::Type)
-IPC_ENUM_TRAITS(media::VideoCodec)
-IPC_ENUM_TRAITS(MediaPlayerHostMsg_Initialize_Type)
-
-IPC_STRUCT_TRAITS_BEGIN(media::DemuxerConfigs)
- IPC_STRUCT_TRAITS_MEMBER(audio_codec)
- IPC_STRUCT_TRAITS_MEMBER(audio_channels)
- IPC_STRUCT_TRAITS_MEMBER(audio_sampling_rate)
- IPC_STRUCT_TRAITS_MEMBER(is_audio_encrypted)
- IPC_STRUCT_TRAITS_MEMBER(audio_extra_data)
-
- IPC_STRUCT_TRAITS_MEMBER(video_codec)
- IPC_STRUCT_TRAITS_MEMBER(video_size)
- IPC_STRUCT_TRAITS_MEMBER(is_video_encrypted)
- IPC_STRUCT_TRAITS_MEMBER(video_extra_data)
-
- IPC_STRUCT_TRAITS_MEMBER(duration_ms)
-IPC_STRUCT_TRAITS_END()
-
-IPC_STRUCT_TRAITS_BEGIN(media::DemuxedBufferMetaData)
- IPC_STRUCT_TRAITS_MEMBER(size)
- IPC_STRUCT_TRAITS_MEMBER(end_of_stream)
- IPC_STRUCT_TRAITS_MEMBER(timestamp)
- IPC_STRUCT_TRAITS_MEMBER(time_duration)
- IPC_STRUCT_TRAITS_MEMBER(type)
- IPC_STRUCT_TRAITS_MEMBER(status)
-IPC_STRUCT_TRAITS_END()
-
-IPC_STRUCT_TRAITS_BEGIN(media::MediaPlayerEfl::TimeRanges)
- IPC_STRUCT_TRAITS_MEMBER(start)
- IPC_STRUCT_TRAITS_MEMBER(end)
-IPC_STRUCT_TRAITS_END()
-
-#if defined(TIZEN_TBM_SUPPORT)
-IPC_STRUCT_TRAITS_BEGIN(gfx::TbmBufferHandle)
- IPC_STRUCT_TRAITS_MEMBER(tbm_surface)
- IPC_STRUCT_TRAITS_MEMBER(media_packet)
-IPC_STRUCT_TRAITS_END()
-#endif
-
-// Initialize Efl player.
-IPC_MESSAGE_ROUTED5(MediaPlayerEflHostMsg_Init,
- int /* player_id */,
- MediaPlayerHostMsg_Initialize_Type /* type */,
- GURL /* URL */,
- double /* volume */,
- int /* demuxer client id */)
-
-// Deinitialize Gst player.
-IPC_MESSAGE_ROUTED1(MediaPlayerEflHostMsg_DeInit,
- int /* player_id */)
-
-// Start playback.
-IPC_MESSAGE_ROUTED1(MediaPlayerEflHostMsg_Play,
- int /* player_id */)
-
-// Pause playback.
-IPC_MESSAGE_ROUTED1(MediaPlayerEflHostMsg_Pause,
- int /* player_id */)
-
-// Set volume.
-IPC_MESSAGE_ROUTED2(MediaPlayerEflHostMsg_SetVolume,
- int /* player_id */,
- double /* volume */)
-
-// Set playback rate.
-IPC_MESSAGE_ROUTED2(MediaPlayerEflHostMsg_SetRate,
- int /* player_id */,
- double /* rate */)
-
-// Playback duration.
-IPC_MESSAGE_ROUTED2(MediaPlayerEflMsg_DurationChanged,
- int /* player_id */,
- double /* time */)
-
-// Current duration.
-IPC_MESSAGE_ROUTED2(MediaPlayerEflMsg_TimeUpdate,
- int /* player_id */,
- double /* time */)
-
-// Pause state.
-IPC_MESSAGE_ROUTED2(MediaPlayerEflMsg_PauseStateChanged,
- int /* player_id */,
- bool /* state */)
-
-// Seek state.
-IPC_MESSAGE_ROUTED2(MediaPlayerEflMsg_OnSeekStateChange,
- int /* player_id */,
- bool /* state */)
-
-// Current buffer range.
-IPC_MESSAGE_ROUTED2(MediaPlayerEflMsg_BufferUpdate,
- int /* player_id */,
- std::vector<media::MediaPlayerEfl::TimeRanges> /*buffer_range*/)
-
-// Playback completed.
-IPC_MESSAGE_ROUTED1(MediaPlayerEflMsg_TimeChanged,
- int /* player_id */)
-
-// Ready state change.
-IPC_MESSAGE_ROUTED2(MediaPlayerEflMsg_ReadyStateChange,
- int /* player_id */,
- blink::WebMediaPlayer::ReadyState /* state */)
-
-// Network state change.
-IPC_MESSAGE_ROUTED2(MediaPlayerEflMsg_NetworkStateChange,
- int /* player_id */,
- blink::WebMediaPlayer::NetworkState /* state */)
-
-// Gst media data has changed.
-IPC_MESSAGE_ROUTED4(MediaPlayerEflMsg_MediaDataChanged,
- int /* player_id */,
- int /* width */,
- int /* height */,
- int /* media */)
-
-// On new frame available.
-IPC_MESSAGE_ROUTED4(MediaPlayerEflMsg_NewFrameAvailable,
- int /* player_id */,
- base::SharedMemoryHandle /* Handle */,
- uint32_t /* length */,
- base::TimeDelta /* time stamp */)
-
-#if defined(TIZEN_TBM_SUPPORT)
-IPC_MESSAGE_ROUTED3(MediaPlayerEflMsg_NewTbmBufferAvailable,
- int /* player_id */,
- gfx::TbmBufferHandle /* Handle */,
- base::TimeDelta /* time stamp */)
-
-// Requests to release tbm buffer.
-IPC_MESSAGE_CONTROL1(MediaPlayerEflHostMsg_ReleaseTbmBuffer,
- gfx::TbmBufferHandle /* Handle */)
-#endif
-
-// Seek.
-IPC_MESSAGE_ROUTED2(MediaPlayerEflHostMsg_Seek,
- int /* player_id */,
- double /* time */)
-
-// For MSE internal seek request.
-IPC_MESSAGE_ROUTED2(MediaPlayerEflMsg_SeekRequest,
- int /* player_id */,
- double /* time_to_seek */)
-
-// Sent after the renderer demuxer has seeked.
-IPC_MESSAGE_CONTROL2(MediaPlayerEflHostMsg_DemuxerSeekDone,
- int /* demuxer_client_id */,
- base::TimeDelta /* actual_browser_seek_time */)
-
-// Inform the media source player that the demuxer is ready.
-IPC_MESSAGE_CONTROL2(MediaPlayerEflHostMsg_DemuxerReady,
- int /* demuxer_client_id */,
- media::DemuxerConfigs /* configs */)
-
-// Sent when the data was read from the ChunkDemuxer.
-IPC_MESSAGE_CONTROL3(MediaPlayerEflHostMsg_ReadFromDemuxerAck,
- int /* demuxer_client_id */,
- base::SharedMemoryHandle /* Handle */,
- media::DemuxedBufferMetaData /* meta data of buffer*/)
-
-// Inform the media source player of changed media duration from demuxer.
-IPC_MESSAGE_CONTROL2(MediaPlayerEflHostMsg_DurationChanged,
- int /* demuxer_client_id */,
- base::TimeDelta /* duration */)
-
-// The media source player reads data from demuxer
-IPC_MESSAGE_CONTROL2(MediaPlayerEflMsg_ReadFromDemuxer,
- int /* demuxer_client_id */,
- media::DemuxerStream::Type /* type */)
-
-// Requests renderer demuxer seek.
-IPC_MESSAGE_CONTROL2(MediaPlayerEflMsg_DemuxerSeekRequest,
- int /* demuxer_client_id */,
- base::TimeDelta /* time_to_seek */)
+++ /dev/null
-// Copyright 2014 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 CONTENT_COMMON_MEDIA_MEDIA_PLAYER_MESSAGES_ENUMS_EFL_H_
-#define CONTENT_COMMON_MEDIA_MEDIA_PLAYER_MESSAGES_ENUMS_EFL_H_
-
-// Dictates which type of media playback is being initialized.
-enum MediaPlayerHostMsg_Initialize_Type {
- MEDIA_PLAYER_TYPE_URL,
- MEDIA_PLAYER_TYPE_MEDIA_SOURCE,
-};
-
-#endif // CONTENT_COMMON_MEDIA_MEDIA_PLAYER_MESSAGES_ENUMS_EFL_H_
#if BUILDFLAG(IS_TIZEN)
#include "content/common/tts_messages_efl.h"
#endif
-
-#if defined(TIZEN_MULTIMEDIA_SUPPORT)
-#include "content/common/media/efl/media_player_messages_efl.h"
-#endif
#include "content/public/common/common_param_traits.h"
#include "ui/gfx/ipc/gfx_param_traits.h"
-#if defined(TIZEN_MULTIMEDIA_SUPPORT)
-#include "base/file_descriptor_posix.h"
-#include "base/memory/shared_memory.h"
-#endif
-
//-----------------------------------------------------------------------------
// RenderView messages
// These are messages sent from the browser to the renderer process.
// so using same message class for these messages.
// but actual messages are different so they shouldn't mess with chrome messages
#define IPC_MESSAGE_START ChromeMsgStart
-
-#if defined(TIZEN_MULTIMEDIA_SUPPORT)
-// This message runs audio decoding for webaudio.
-IPC_MESSAGE_CONTROL3(EflViewHostMsg_WebAudioDecode,
- base::SharedMemoryHandle /* encoded_data_handle */,
- base::FileDescriptor /* pcm_output */,
- uint32_t /* data_size*/)
-#endif
external_content_shell_configs += [ "//tizen_src/build:ecore-wayland" ]
external_content_shell_configs += [ "//tizen_src/build:libecore-wayland" ]
}
-
-if (tizen_multimedia_support) {
- external_content_browser_configs += [
- "//tizen_src/build:capi-media-player",
- "//tizen_src/build:libcapi-media-player",
- "//tizen_src/build:capi-media-tool",
- "//tizen_src/build:libcapi-media-tool",
- ]
- external_content_common_configs += [ "//tizen_src/build:gstreamer" ]
- external_content_common_configs += [ "//tizen_src/build:libgstreamer" ]
-}
+++ /dev/null
-// Copyright 2014 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 CONTENT_RENDERER_MEDIA_EFL_AUDIO_DECODER_EFL_H_
-#define CONTENT_RENDERER_MEDIA_EFL_AUDIO_DECODER_EFL_H_
-
-#include "content/child/thread_safe_sender.h"
-
-namespace blink {
-class WebAudioBus;
-}
-
-namespace content {
-
-bool DecodeAudioFileData(blink::WebAudioBus* destination_bus,
- const char* data,
- size_t data_size,
- scoped_refptr<ThreadSafeSender> sender);
-
-} // namespace content
-#endif // CONTENT_RENDERER_MEDIA_EFL_AUDIO_DECODER_EFL_H_
+++ /dev/null
-// Copyright 2014 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.
-
-#include "content/renderer/media/efl/media_source_delegate_efl.h"
-
-#include "base/process/process.h"
-#include "media/base/bind_to_current_loop.h"
-#include "media/base/efl/demuxer_stream_player_params_efl.h"
-#include "media/base/media_log.h"
-#include "media/blink/webmediaplayer_util.h"
-#include "media/blink/webmediasource_impl.h"
-#include "media/filters/chunk_demuxer.h"
-#include "media/filters/decrypting_demuxer_stream.h"
-#include "third_party/blink/public/web/WebRuntimeFeatures.h"
-
-namespace content {
-
-MediaSourceDelegateEfl::MediaSourceDelegateEfl(
- RendererDemuxerEfl* demuxer_client,
- int demuxer_client_id,
- const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
- media::MediaLog* media_log)
- : main_loop_(base::ThreadTaskRunnerHandle::Get()),
- main_weak_factory_(this),
- main_weak_this_(main_weak_factory_.GetWeakPtr()),
- media_task_runner_(media_task_runner),
- media_weak_factory_(this),
- demuxer_client_(demuxer_client),
- demuxer_client_id_(demuxer_client_id),
- media_log_(media_log),
- audio_stream_(NULL),
- video_stream_(NULL),
- seek_time_(media::kNoTimestamp()),
- pending_seek_(false),
- is_seeking_(false),
- seeking_pending_seek_(false),
- is_demuxer_seek_done_(false),
- pending_seek_time_(media::kNoTimestamp()),
- is_audio_read_fired_(false),
- is_video_read_fired_(false),
- is_demuxer_ready_(false) {
- DCHECK(!chunk_demuxer_);
-}
-
-MediaSourceDelegateEfl::~MediaSourceDelegateEfl() {
- DCHECK(main_loop_->BelongsToCurrentThread());
- DCHECK(!chunk_demuxer_);
- DCHECK(!audio_stream_);
- DCHECK(!video_stream_);
- DCHECK(!audio_decrypting_demuxer_stream_);
- DCHECK(!video_decrypting_demuxer_stream_);
-}
-
-void MediaSourceDelegateEfl::InitializeMediaSource(
- const MediaSourceOpenedCB& media_source_opened_cb,
- const media::Demuxer::EncryptedMediaInitDataCB& emedia_init_data_cb,
- const media::SetCdmReadyCB& set_cdm_ready_cb,
- const UpdateNetworkStateCB& update_network_state_cb,
- const DurationChangeCB& duration_change_cb,
- const base::Closure& waiting_for_decryption_key_cb) {
- DCHECK(main_loop_->BelongsToCurrentThread());
- DCHECK(!media_source_opened_cb.is_null());
- media_source_opened_cb_ = media_source_opened_cb;
- emedia_init_data_cb_ = emedia_init_data_cb;
- set_cdm_ready_cb_ = set_cdm_ready_cb;
- update_network_state_cb_ = media::BindToCurrentLoop(update_network_state_cb);
- duration_change_cb_ = duration_change_cb;
- waiting_for_decryption_key_cb_ =
- media::BindToCurrentLoop(waiting_for_decryption_key_cb);
-
- chunk_demuxer_.reset(new media::ChunkDemuxer(
- media::BindToCurrentLoop(base::BindOnce(
- &MediaSourceDelegateEfl::OnDemuxerOpened, main_weak_this_)),
- media::BindToCurrentLoop(base::BindOnce(
- &MediaSourceDelegateEfl::OnEncryptedMediaInitData, main_weak_this_)),
- media_log_, false));
-
- media_task_runner_->PostTask(
- FROM_HERE, base::BindOnce(&MediaSourceDelegateEfl::InitializeDemuxer,
- base::Unretained(this)));
-}
-
-void MediaSourceDelegateEfl::OnBufferedTimeRangesChanged(
- const media::Ranges<base::TimeDelta>& ranges) {
- buffered_time_ranges_ = ranges;
-}
-
-blink::WebTimeRanges MediaSourceDelegateEfl::Buffered() const {
- return media::ConvertToWebTimeRanges(buffered_time_ranges_);
-}
-
-void MediaSourceDelegateEfl::InitializeDemuxer() {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- demuxer_client_->AddDelegate(demuxer_client_id_, this);
- chunk_demuxer_->Initialize(
- this,
- base::BindOnce(&MediaSourceDelegateEfl::OnDemuxerInitDone,
- media_weak_factory_.GetWeakPtr()),
- false);
-}
-
-void MediaSourceDelegateEfl::OnEncryptedMediaInitData (
- media::EmeInitDataType init_data_type,
- const std::vector<uint8_t>& init_data) {
- DCHECK(main_loop_->BelongsToCurrentThread());
- if (emedia_init_data_cb_.is_null()) {
- return;
- }
- emedia_init_data_cb_.Run(init_data_type, init_data);
-}
-
-void MediaSourceDelegateEfl::OnDemuxerOpened() {
- DCHECK(main_loop_->BelongsToCurrentThread());
- if (media_source_opened_cb_.is_null())
- return;
- media_source_opened_cb_.Run(new media::WebMediaSourceImpl(
- chunk_demuxer_.get(), media_log_));
-}
-
-void MediaSourceDelegateEfl::OnDemuxerError(
- media::PipelineStatus status) {
- if (status != media::PIPELINE_OK && !update_network_state_cb_.is_null())
- update_network_state_cb_.Run(PipelineErrorToNetworkState(status));
-}
-
-void MediaSourceDelegateEfl::AddTextStream(
- media::DemuxerStream* /* text_stream */ ,
- const media::TextTrackConfig& /* config */ ) {
- NOTIMPLEMENTED();
-}
-
-void MediaSourceDelegateEfl::RemoveTextStream(
- media::DemuxerStream* /* text_stream */ ) {
- NOTIMPLEMENTED();
-}
-
-bool MediaSourceDelegateEfl::CanNotifyDemuxerReady() {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- return is_demuxer_ready_;
-}
-
-void MediaSourceDelegateEfl::OnDemuxerInitDone(
- media::PipelineStatus status) {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- DCHECK(chunk_demuxer_);
- if (status != media::PIPELINE_OK) {
- OnDemuxerError(status);
- return;
- }
- audio_stream_ = chunk_demuxer_->GetStream(media::DemuxerStream::AUDIO);
- video_stream_ = chunk_demuxer_->GetStream(media::DemuxerStream::VIDEO);
- if (audio_stream_ && audio_stream_->audio_decoder_config().is_encrypted() &&
- !set_cdm_ready_cb_.is_null()) {
- InitAudioDecryptingDemuxerStream();
- return;
- }
- if (video_stream_ && video_stream_->video_decoder_config().is_encrypted() &&
- !set_cdm_ready_cb_.is_null()) {
- InitVideoDecryptingDemuxerStream();
- return;
- }
- // Notify demuxer ready when both streams are not encrypted.
- is_demuxer_ready_ = true;
- NotifyDemuxerReady();
-}
-
-void MediaSourceDelegateEfl::InitAudioDecryptingDemuxerStream() {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- audio_decrypting_demuxer_stream_.reset(new media::DecryptingDemuxerStream(
- media_task_runner_, media_log_, waiting_for_decryption_key_cb_));
-
- audio_decrypting_demuxer_stream_->Initialize(
- audio_stream_, set_cdm_ready_cb_,
- base::BindOnce(
- &MediaSourceDelegateEfl::OnAudioDecryptingDemuxerStreamInitDone,
- media_weak_factory_.GetWeakPtr()));
-}
-
-void MediaSourceDelegateEfl::InitVideoDecryptingDemuxerStream() {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
-
- video_decrypting_demuxer_stream_.reset(new media::DecryptingDemuxerStream(
- media_task_runner_, media_log_, waiting_for_decryption_key_cb_));
-
- video_decrypting_demuxer_stream_->Initialize(
- video_stream_, set_cdm_ready_cb_,
- base::BindOnce(
- &MediaSourceDelegateEfl::OnVideoDecryptingDemuxerStreamInitDone,
- media_weak_factory_.GetWeakPtr()));
-}
-
-
-void MediaSourceDelegateEfl::OnAudioDecryptingDemuxerStreamInitDone(
- media::PipelineStatus status) {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- DCHECK(chunk_demuxer_);
-
- if (status != media::PIPELINE_OK)
- audio_decrypting_demuxer_stream_.reset();
- else
- audio_stream_ = audio_decrypting_demuxer_stream_.get();
-
- if (video_stream_ && video_stream_->video_decoder_config().is_encrypted()) {
- InitVideoDecryptingDemuxerStream();
- return;
- }
-
- // Try to notify demuxer ready when audio DDS initialization finished and
- // video is not encrypted.
- is_demuxer_ready_ = true;
- NotifyDemuxerReady();
-}
-
-void MediaSourceDelegateEfl::OnVideoDecryptingDemuxerStreamInitDone(
- media::PipelineStatus status) {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- DCHECK(chunk_demuxer_);
-
- if (status != media::PIPELINE_OK)
- video_decrypting_demuxer_stream_.reset();
- else
- video_stream_ = video_decrypting_demuxer_stream_.get();
-
- // Try to notify demuxer ready when video DDS initialization finished.
- is_demuxer_ready_ = true;
- NotifyDemuxerReady();
-}
-
-void MediaSourceDelegateEfl::NotifyDemuxerReady() {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- DCHECK(is_demuxer_ready_);
- if (!demuxer_client_ || (!audio_stream_ && !video_stream_)) {
- OnDemuxerError(media::PIPELINE_ERROR_INITIALIZATION_FAILED);
- return;
- }
- scoped_ptr<media::DemuxerConfigs> configs(new media::DemuxerConfigs());
- if (audio_stream_) {
- media::AudioDecoderConfig audio_config =
- audio_stream_->audio_decoder_config();
- configs->audio_codec = audio_config.codec();
- configs->audio_channels =
- media::ChannelLayoutToChannelCount(audio_config.channel_layout());
- configs->audio_sampling_rate = audio_config.samples_per_second();
- configs->is_audio_encrypted = audio_config.is_encrypted();
- configs->audio_extra_data = audio_config.extra_data();
- }
- if (video_stream_) {
- media::VideoDecoderConfig video_config =
- video_stream_->video_decoder_config();
- configs->video_codec = video_config.codec();
- configs->video_size = video_config.natural_size();
- configs->is_video_encrypted = video_config.is_encrypted();
- configs->video_extra_data = video_config.extra_data();
- }
- demuxer_client_->DemuxerReady(demuxer_client_id_, *configs);
-}
-
-void MediaSourceDelegateEfl::OnReadFromDemuxer(
- media::DemuxerStream::Type type) {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
-
- if (is_seeking_)
- return;
-
- if ((type == media::DemuxerStream::AUDIO) && audio_stream_
- && !is_audio_read_fired_) {
- is_audio_read_fired_ = true;
- audio_stream_->Read(base::BindOnce(&MediaSourceDelegateEfl::OnBufferReady,
- media_weak_factory_.GetWeakPtr(), type));
- }
-
- if ((type == media::DemuxerStream::VIDEO) && video_stream_
- && !is_video_read_fired_) {
- is_video_read_fired_ = true;
- video_stream_->Read(base::BindOnce(&MediaSourceDelegateEfl::OnBufferReady,
- media_weak_factory_.GetWeakPtr(), type));
- }
-}
-
-void MediaSourceDelegateEfl::Stop(const base::Closure& stop_cb) {
- DCHECK(main_loop_->BelongsToCurrentThread());
-
- if (!chunk_demuxer_) {
- DCHECK(!demuxer_client_);
- return;
- }
-
- duration_change_cb_.Reset();
- update_network_state_cb_.Reset();
- media_source_opened_cb_.Reset();
-
- main_weak_factory_.InvalidateWeakPtrs();
- DCHECK(!main_weak_factory_.HasWeakPtrs());
-
- // 1. shutdown demuxer.
- // 2. On media thread, call stop demuxer.
- chunk_demuxer_->Shutdown();
- media_task_runner_->PostTask(
- FROM_HERE, base::BindOnce(&MediaSourceDelegateEfl::StopDemuxer,
- base::Unretained(this), stop_cb));
-}
-
-void MediaSourceDelegateEfl::StopDemuxer(const base::Closure& stop_cb) {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- DCHECK(chunk_demuxer_);
-
- demuxer_client_->RemoveDelegate(demuxer_client_id_);
- demuxer_client_ = NULL;
- audio_stream_ = NULL;
- video_stream_ = NULL;
- audio_decrypting_demuxer_stream_.reset();
- video_decrypting_demuxer_stream_.reset();
-
- media_weak_factory_.InvalidateWeakPtrs();
- DCHECK(!media_weak_factory_.HasWeakPtrs());
-
- chunk_demuxer_->Stop();
- chunk_demuxer_.reset();
-
- stop_cb.Run();
-}
-
-void MediaSourceDelegateEfl::SeekInternal(
- const base::TimeDelta& seek_time) {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- chunk_demuxer_->Seek(
- seek_time, base::BindOnce(&MediaSourceDelegateEfl::OnDemuxerSeekDone,
- media_weak_factory_.GetWeakPtr()));
-}
-
-void MediaSourceDelegateEfl::OnBufferReady(
- media::DemuxerStream::Type type,
- media::DemuxerStream::Status status,
- const scoped_refptr<media::DecoderBuffer>& buffer) {
- uint32_t shared_memory_size = -1;
- base::SharedMemory shared_memory;
- base::SharedMemoryHandle foreign_memory_handle;
-
- scoped_ptr<media::DemuxedBufferMetaData> meta_data(
- new media::DemuxedBufferMetaData());
- meta_data->status = status;
- meta_data->type = type;
-
- if (type == media::DemuxerStream::AUDIO)
- is_audio_read_fired_ = false;
- if (type == media::DemuxerStream::VIDEO)
- is_video_read_fired_ = false;
-
- switch (status) {
- case media::DemuxerStream::kAborted:
- LOG (ERROR) << "[RENDER] : DemuxerStream::kAborted";
- break;
-
- case media::DemuxerStream::kConfigChanged:
- NotifyDemuxerReady();
- break;
-
- case media::DemuxerStream::kOk:
- if (buffer.get()->end_of_stream()) {
- meta_data->end_of_stream = true;
- break;
- }
- shared_memory_size = buffer.get()->data_size();
- if (!shared_memory.CreateAndMapAnonymous(shared_memory_size)) {
- LOG (ERROR) << "Shared Memory creation failed.";
- return;
- }
- if (!shared_memory.ShareToProcess(base::Process::Current().Handle(),
- &foreign_memory_handle)) {
- LOG (ERROR) << "Shared Memory handle could not be obtained";
- return;
- }
- memcpy(shared_memory.memory(), (void*)buffer.get()->writable_data(),
- shared_memory_size);
- meta_data->timestamp = buffer.get()->timestamp();
- meta_data->time_duration = buffer.get()->duration();
- meta_data->size = shared_memory_size;
- break;
- default:
- NOTREACHED();
- }
-
- if (demuxer_client_)
- demuxer_client_->ReadFromDemuxerAck(demuxer_client_id_,
- foreign_memory_handle,
- *meta_data);
-}
-
-void MediaSourceDelegateEfl::StartWaitingForSeek(
- const base::TimeDelta& seek_time) {
- DCHECK(main_loop_->BelongsToCurrentThread());
-
- if (!chunk_demuxer_)
- return;
-
- // Called from |webmediaplayerefl| only.
- is_demuxer_seek_done_ = false;
- seeking_pending_seek_ = false;
- is_seeking_ = true;
- chunk_demuxer_->StartWaitingForSeek(seek_time);
-}
-
-void MediaSourceDelegateEfl::CancelPendingSeek(
- const base::TimeDelta& seek_time) {
- DCHECK(main_loop_->BelongsToCurrentThread());
- if (!chunk_demuxer_)
- return;
- is_seeking_ = true;
- pending_seek_ = true;
- pending_seek_time_ = seek_time;
-
- if (is_demuxer_seek_done_) {
- // Since we already requested gstreamer to seek. And there are no pending
- // seeks in |chunk_demuxer|. Cancelling pending seek makes no sense.
- //
- // This block will handle when |gstreamer| is seeking and new seek came in
- // between.
- is_demuxer_seek_done_ = false;
- pending_seek_ = false;
- chunk_demuxer_->StartWaitingForSeek(seek_time);
- StartSeek(seek_time, true);
- return;
- }
-
- chunk_demuxer_->CancelPendingSeek(seek_time);
-}
-
-void MediaSourceDelegateEfl::StartSeek(
- const base::TimeDelta& seek_time,
- bool is_seeking_pending_seek) {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
-
- if (!chunk_demuxer_)
- return;
-
- is_seeking_ = true;
- is_demuxer_seek_done_ = false;
- if (is_seeking_pending_seek)
- seeking_pending_seek_ = is_seeking_pending_seek;
- else if (seeking_pending_seek_)
- return;
-
- seek_time_ = seek_time;
- SeekInternal(seek_time);
-}
-
-void MediaSourceDelegateEfl::OnDemuxerSeekDone(
- media::PipelineStatus status) {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- if (status != media::PIPELINE_OK) {
- OnDemuxerError(status);
- return;
- }
- if (pending_seek_) {
- pending_seek_ = false;
- StartSeek(pending_seek_time_, true);
- seek_time_ = pending_seek_time_;
- } else {
- seeking_pending_seek_ = false;
- is_seeking_ = false;
- is_demuxer_seek_done_ = true;
- ResetAudioDecryptingDemuxerStream();
- }
-}
-
-void MediaSourceDelegateEfl::ResetAudioDecryptingDemuxerStream() {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- if (audio_decrypting_demuxer_stream_) {
- audio_decrypting_demuxer_stream_->Reset(base::BindOnce(
- &MediaSourceDelegateEfl::ResetVideoDecryptingDemuxerStream,
- media_weak_factory_.GetWeakPtr()));
- return;
- }
- ResetVideoDecryptingDemuxerStream();
-}
-
-void MediaSourceDelegateEfl::ResetVideoDecryptingDemuxerStream() {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- if (video_decrypting_demuxer_stream_) {
- video_decrypting_demuxer_stream_->Reset(base::BindOnce(
- &MediaSourceDelegateEfl::FinishResettingDecryptingDemuxerStreams,
- media_weak_factory_.GetWeakPtr()));
- return;
- }
- FinishResettingDecryptingDemuxerStreams();
-}
-
-void MediaSourceDelegateEfl::FinishResettingDecryptingDemuxerStreams() {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- DCHECK(is_seeking_);
- is_seeking_ = false;
- demuxer_client_->DemuxerSeekDone(demuxer_client_id_, seek_time_);
-}
-
-void MediaSourceDelegateEfl::SetDuration(base::TimeDelta duration) {
- DCHECK(main_loop_->BelongsToCurrentThread());
- main_loop_->PostTask(
- FROM_HERE, base::BindOnce(&MediaSourceDelegateEfl::OnDurationChanged,
- main_weak_this_, duration));
-}
-
-void MediaSourceDelegateEfl::OnDurationChanged(
- const base::TimeDelta& duration) {
- DCHECK(main_loop_->BelongsToCurrentThread());
- if (demuxer_client_)
- demuxer_client_->DurationChanged(demuxer_client_id_, duration);
-
- if (!duration_change_cb_.is_null())
- duration_change_cb_.Run(duration.InSecondsF());
-}
-
-} // namespace content
+++ /dev/null
-// Copyright 2014 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 CONTENT_RENDERER_MEDIA_EFL_MEDIA_SOURCE_DELEGATE_EFL_H_
-#define CONTENT_RENDERER_MEDIA_EFL_MEDIA_SOURCE_DELEGATE_EFL_H_
-
-#include "content/renderer/media/efl/renderer_demuxer_efl.h"
-#include "media/base/decoder_buffer.h"
-#include "media/base/demuxer_stream.h"
-#include "media/base/media_keys.h"
-#include "media/filters/chunk_demuxer.h"
-#include "media/filters/decrypting_demuxer_stream.h"
-#include "third_party/blink/public/platform/WebMediaPlayer.h"
-
-namespace content {
-
-class MediaSourceDelegateEfl
- : public media::DemuxerHost {
- public:
- typedef base::OnceCallback<void(blink::WebMediaSource*)> MediaSourceOpenedCB;
- typedef base::OnceCallback<void(blink::WebMediaPlayer::NetworkState)>
- UpdateNetworkStateCB;
- typedef base::OnceCallback<void(double)> DurationChangeCB;
-
- MediaSourceDelegateEfl(
- RendererDemuxerEfl* demuxer_client,
- int demuxer_client_id,
- const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
- media::MediaLog* media_log);
- ~MediaSourceDelegateEfl();
-
- //DemuxerHost implementation.
- void OnBufferedTimeRangesChanged(
- const media::Ranges<base::TimeDelta>& ranges) override;
-
- // Sets the duration of the media in microseconds.
- // Duration may be kInfiniteDuration() if the duration is not known.
- void SetDuration(base::TimeDelta duration) override;
-
- // Stops execution of the pipeline due to a fatal error. Do not call this
- // method with PIPELINE_OK.
- void OnDemuxerError(media::PipelineStatus error) override;
-
- // Add |text_stream| to the collection managed by the text renderer.
- void AddTextStream(
- media::DemuxerStream* text_stream,
- const media::TextTrackConfig& config) override;
-
- // Remove |text_stream| from the presentation.
- void RemoveTextStream(media::DemuxerStream* text_stream) override;
-
- void InitializeMediaSource(
- const MediaSourceOpenedCB& media_source_opened_cb,
- const media::Demuxer::EncryptedMediaInitDataCB& emedia_init_data_cb,
- const media::SetCdmReadyCB& set_cdm_ready_cb,
- const UpdateNetworkStateCB& update_network_state_cb,
- const DurationChangeCB& duration_change_cb,
- const base::Closure& waiting_for_decryption_key_cb);
-
- blink::WebTimeRanges Buffered() const;
-
- // Called when DemuxerStreamPlayer needs to read data from ChunkDemuxer.
- void OnReadFromDemuxer(media::DemuxerStream::Type type);
-
- // Must be called explicitly before |this| can be destroyed.
- void Stop(const base::Closure& stop_cb);
-
- // In MSE case, calls ChunkDemuxer::StartWaitingForSeek(), sets the
- // expectation that a regular seek will be arriving.
- void StartWaitingForSeek(const base::TimeDelta& seek_time);
-
- // Calls ChunkDemuxer::CancelPendingSeek(). Also sets the
- // expectation that a regular seek will be arriving.
- void CancelPendingSeek(const base::TimeDelta& seek_time);
-
- // Sets the expectation that a regular seek will be arriving.
- void StartSeek(
- const base::TimeDelta& seek_time,
- bool is_seeking_pending_seek);
-
- // Callback for ChunkDemuxer::Seek().
- void OnDemuxerSeekDone(media::PipelineStatus status);
-
- private:
- void OnEncryptedMediaInitData(media::EmeInitDataType init_data_type,
- const std::vector<uint8_t>& init_data);
- void OnDemuxerOpened();
- void InitializeDemuxer();
- void OnDemuxerInitDone(media::PipelineStatus status);
- // Stops and clears objects on the media thread.
- void StopDemuxer(const base::Closure& stop_cb);
- bool CanNotifyDemuxerReady();
- void NotifyDemuxerReady();
- void OnDurationChanged(const base::TimeDelta& duration);
- void OnBufferReady(
- media::DemuxerStream::Type type,
- media::DemuxerStream::Status status,
- const scoped_refptr<media::DecoderBuffer>& buffer);
- void SeekInternal(const base::TimeDelta& seek_time);
-
- // Initializes DecryptingDemuxerStreams if audio/video stream is encrypted.
- void InitAudioDecryptingDemuxerStream();
- void InitVideoDecryptingDemuxerStream();
-
- // Callbacks for DecryptingDemuxerStream::Initialize().
- void OnAudioDecryptingDemuxerStreamInitDone(media::PipelineStatus status);
- void OnVideoDecryptingDemuxerStreamInitDone(media::PipelineStatus status);
-
- // Runs on the media thread.
- void ResetAudioDecryptingDemuxerStream();
- void ResetVideoDecryptingDemuxerStream();
- void FinishResettingDecryptingDemuxerStreams();
-
- // Message loop for main renderer thread and corresponding weak pointer.
- const scoped_refptr<base::SingleThreadTaskRunner> main_loop_;
- base::WeakPtrFactory<MediaSourceDelegateEfl> main_weak_factory_;
- base::WeakPtr<MediaSourceDelegateEfl> main_weak_this_;
-
- // Message loop for media thread and corresponding weak pointer.
- const scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
- base::WeakPtrFactory<MediaSourceDelegateEfl> media_weak_factory_;
- RendererDemuxerEfl* demuxer_client_;
- int demuxer_client_id_;
- scoped_refptr<media::MediaLog> media_log_;
-
- MediaSourceOpenedCB media_source_opened_cb_;
- UpdateNetworkStateCB update_network_state_cb_;
- DurationChangeCB duration_change_cb_;
- base::Closure waiting_for_decryption_key_cb_;
-
- scoped_ptr<media::ChunkDemuxer> chunk_demuxer_;
- media::DemuxerStream* audio_stream_;
- media::DemuxerStream* video_stream_;
- media::Ranges<base::TimeDelta> buffered_time_ranges_;
-
- media::SetCdmReadyCB set_cdm_ready_cb_;
- media::Demuxer::EncryptedMediaInitDataCB emedia_init_data_cb_;
- scoped_ptr<media::DecryptingDemuxerStream> audio_decrypting_demuxer_stream_;
- scoped_ptr<media::DecryptingDemuxerStream> video_decrypting_demuxer_stream_;
-
- base::TimeDelta seek_time_;
- bool pending_seek_;
- bool is_seeking_;
-
- // Will handle internal seek coming from |MediaSourcePlayerGstreamer|
- // if new seek has been fired by |HTMLMediaElement|.
- // Always one should seek to latest time and ignore previous seeks.
- bool seeking_pending_seek_;
-
- // Will handle |seek| request coming after |chunk_demuxer|
- // has requested |gstreamer| to seek.
- bool is_demuxer_seek_done_;
- base::TimeDelta pending_seek_time_;
-
- bool is_audio_read_fired_;
- bool is_video_read_fired_;
-
- bool is_demuxer_ready_;
-};
-
-} // namespace content
-
-#endif // CONTENT_RENDERER_MEDIA_EFL_MEDIA_SOURCE_DELEGATE_EFL_H_
+++ /dev/null
-// Copyright 2014 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.
-
-#include "content/renderer/media/efl/renderer_demuxer_efl.h"
-
-#include "base/bind.h"
-#include "base/message_loop/message_loop.h"
-#include "content/child/thread_safe_sender.h"
-#include "content/common/media/efl/media_player_messages_efl.h"
-#include "content/renderer/media/efl/media_source_delegate_efl.h"
-#include "content/renderer/media/efl/renderer_media_player_manager_efl.h"
-#include "content/renderer/render_thread_impl.h"
-
-namespace content {
-
-scoped_refptr<IPC::MessageFilter> CreateRendererDemuxerEfl() {
- return new RendererDemuxerEfl();
-}
-
-RendererDemuxerEfl::RendererDemuxerEfl()
- : thread_safe_sender_(RenderThreadImpl::current()->thread_safe_sender()),
- media_task_runner_(
- RenderThreadImpl::current()->GetMediaThreadTaskRunner()) {}
-
-RendererDemuxerEfl::~RendererDemuxerEfl() {}
-
-int RendererDemuxerEfl::GetNextDemuxerClientID() {
- // Don't use zero for IDs since it can be interpreted as having no ID.
- return next_demuxer_client_id_.GetNext() + 1;
-}
-
-void RendererDemuxerEfl::AddDelegate(
- int demuxer_client_id,
- MediaSourceDelegateEfl* delegate) {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- delegates_.AddWithID(delegate, demuxer_client_id);
-}
-
-void RendererDemuxerEfl::RemoveDelegate(int demuxer_client_id) {
- DCHECK(media_task_runner_->BelongsToCurrentThread());
- delegates_.Remove(demuxer_client_id);
-}
-
-bool RendererDemuxerEfl::OnMessageReceived(const IPC::Message& message) {
- switch (message.type()) {
- case MediaPlayerEflMsg_ReadFromDemuxer::ID:
- case MediaPlayerEflMsg_DemuxerSeekRequest::ID:
- media_task_runner_->PostTask(
- FROM_HERE,
- base::BindOnce(&RendererDemuxerEfl::DispatchMessage, this, message));
- return true;
- }
- return false;
-}
-
-void RendererDemuxerEfl::DemuxerReady(
- int demuxer_client_id,
- const media::DemuxerConfigs& configs) {
- thread_safe_sender_->Send(new MediaPlayerEflHostMsg_DemuxerReady(
- demuxer_client_id, configs));
-}
-
-void RendererDemuxerEfl::ReadFromDemuxerAck(
- int demuxer_client_id,
- base::SharedMemoryHandle foreign_memory_handle,
- const media::DemuxedBufferMetaData& meta_data) {
- thread_safe_sender_->Send(new MediaPlayerEflHostMsg_ReadFromDemuxerAck(
- demuxer_client_id, foreign_memory_handle, meta_data));
-}
-
-void RendererDemuxerEfl::DemuxerSeekDone(
- int demuxer_client_id,
- const base::TimeDelta& actual_browser_seek_time) {
- thread_safe_sender_->Send(new MediaPlayerEflHostMsg_DemuxerSeekDone(
- demuxer_client_id, actual_browser_seek_time));
-}
-
-void RendererDemuxerEfl::DurationChanged(int demuxer_client_id,
- const base::TimeDelta& duration) {
- thread_safe_sender_->Send(new MediaPlayerEflHostMsg_DurationChanged(
- demuxer_client_id, duration));
-}
-
-void RendererDemuxerEfl::DispatchMessage(const IPC::Message& message) {
- IPC_BEGIN_MESSAGE_MAP(RendererDemuxerEfl, message)
- IPC_MESSAGE_HANDLER(MediaPlayerEflMsg_ReadFromDemuxer, OnReadFromDemuxer)
- IPC_MESSAGE_HANDLER(MediaPlayerEflMsg_DemuxerSeekRequest,
- OnDemuxerSeekRequest)
- IPC_END_MESSAGE_MAP()
-}
-
-void RendererDemuxerEfl::OnReadFromDemuxer(
- int demuxer_client_id,
- media::DemuxerStream::Type type) {
- MediaSourceDelegateEfl* delegate = delegates_.Lookup(demuxer_client_id);
- if (delegate)
- delegate->OnReadFromDemuxer(type);
-}
-
-void RendererDemuxerEfl::OnDemuxerSeekRequest(
- int demuxer_client_id,
- const base::TimeDelta& time_to_seek) {
- MediaSourceDelegateEfl* delegate = delegates_.Lookup(demuxer_client_id);
- if (delegate)
- delegate->StartSeek(time_to_seek, false);
-}
-
-} // namespace content
+++ /dev/null
-// Copyright 2014 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 CONTENT_RENDERER_MEDIA_EFL_RENDERER_DEMUXER_EFL_H_
-#define CONTENT_RENDERER_MEDIA_EFL_RENDERER_DEMUXER_EFL_H_
-
-#include "base/atomic_sequence_num.h"
-#include "base/id_map.h"
-#include "base/memory/shared_memory.h"
-#include "ipc/message_filter.h"
-#include "media/base/efl/demuxer_stream_player_params_efl.h"
-
-namespace base {
-class SingleThreadTaskRunner;
-}
-
-namespace content {
-
-class MediaSourceDelegateEfl;
-class ThreadSafeSender;
-
-// Represents the renderer process half of an IPC-based implementation of
-// media::DemuxerEfl.
-//
-// Refer to BrowserDemuxerEfl for the browser process half.
-class RendererDemuxerEfl : public IPC::MessageFilter {
- public:
- RendererDemuxerEfl();
-
- RendererDemuxerEfl(const RendererDemuxerEfl&) = delete;
- RendererDemuxerEfl& operator=(const RendererDemuxerEfl&) = delete;
-
- // Returns the next available demuxer client ID for use in IPC messages.
- //
- // Safe to call on any thread.
- int GetNextDemuxerClientID();
-
- // Associates |delegate| with |demuxer_client_id| for handling incoming IPC
- // messages.
- //
- // Must be called on media thread.
- void AddDelegate(
- int demuxer_client_id,
- MediaSourceDelegateEfl* delegate);
-
- // Removes the association created by AddDelegate().
- //
- // Must be called on media thread.
- void RemoveDelegate(int demuxer_client_id);
-
- // IPC::ChannelProxy::MessageFilter overrides.
- bool OnMessageReceived(const IPC::Message& message) override;
-
- // media::DemuxerEflClient "implementation".
- void DemuxerReady(
- int demuxer_client_id,
- const media::DemuxerConfigs& configs);
- void ReadFromDemuxerAck(
- int demuxer_client_id,
- base::SharedMemoryHandle foreign_memory_handle,
- const media::DemuxedBufferMetaData& meta_data);
- void DemuxerSeekDone(
- int demuxer_client_id,
- const base::TimeDelta& actual_browser_seek_time);
- void DurationChanged(int demuxer_client_id, const base::TimeDelta& duration);
-
- protected:
- friend class base::RefCountedThreadSafe<RendererDemuxerEfl>;
- ~RendererDemuxerEfl() override;
-
- private:
- void DispatchMessage(const IPC::Message& message);
- void OnReadFromDemuxer(int demuxer_client_id,
- media::DemuxerStream::Type type);
- void OnDemuxerSeekRequest(int demuxer_client_id,
- const base::TimeDelta& time_to_seek);
-
- base::AtomicSequenceNumber next_demuxer_client_id_;
-
- IDMap<MediaSourceDelegateEfl> delegates_;
- scoped_refptr<ThreadSafeSender> thread_safe_sender_;
- scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
-};
-
-} // namespace content
-
-#endif // CONTENT_RENDERER_MEDIA_EFL_RENDERER_DEMUXER_EFL_H_
+++ /dev/null
-// Copyright 2014 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.
-
-#include "content/renderer/media/efl/renderer_media_player_manager_efl.h"
-
-#include "base/bind.h"
-#include "base/message_loop/message_loop.h"
-#include "content/common/media/efl/media_player_messages_efl.h"
-#include "content/public/renderer/render_thread.h"
-#include "content/renderer/media/efl/webmediaplayer_efl.h"
-#include "media/base/bind_to_current_loop.h"
-
-namespace content {
-
-RendererMediaPlayerManager* CreateRendererMediaPlayerManager(
- RenderFrame* render_frame) {
- return new RendererMediaPlayerManager(render_frame);
-}
-
-RendererMediaPlayerManager::RendererMediaPlayerManager(
- RenderFrame* render_frame)
- : RenderFrameObserver(render_frame),
- next_media_player_id_(0) {
-}
-
-RendererMediaPlayerManager::~RendererMediaPlayerManager() {
- DCHECK(media_players_.empty())
- << "RendererMediaPlayerManager is owned by RenderFrameImpl and is "
- "destroyed only after all media players are destroyed.";
-}
-
-void RendererMediaPlayerManager::PausePlayingPlayers() {
- for (auto player_it : media_players_) {
- WebMediaPlayerEfl* player = player_it.second;
- if (player && !player->paused() && player->hasVideo())
- player->RequestPause();
- }
-}
-
-bool RendererMediaPlayerManager::OnMessageReceived(
- const IPC::Message& message) {
- bool handled = true;
- IPC_BEGIN_MESSAGE_MAP(RendererMediaPlayerManager, message)
- IPC_MESSAGE_HANDLER(MediaPlayerEflMsg_MediaDataChanged,
- OnMediaDataChange)
- IPC_MESSAGE_HANDLER(MediaPlayerEflMsg_DurationChanged, OnDurationChange)
- IPC_MESSAGE_HANDLER(MediaPlayerEflMsg_TimeUpdate, OnTimeUpdate)
- IPC_MESSAGE_HANDLER(MediaPlayerEflMsg_BufferUpdate, OnBufferUpdate)
- IPC_MESSAGE_HANDLER(MediaPlayerEflMsg_ReadyStateChange,
- OnReadyStateChange)
- IPC_MESSAGE_HANDLER(MediaPlayerEflMsg_NetworkStateChange,
- OnNetworkStateChange)
- IPC_MESSAGE_HANDLER(MediaPlayerEflMsg_TimeChanged, OnTimeChanged)
- IPC_MESSAGE_HANDLER(MediaPlayerEflMsg_PauseStateChanged,
- OnPauseStateChange)
- IPC_MESSAGE_HANDLER(MediaPlayerEflMsg_OnSeekStateChange,
- OnSeekStateChange)
- IPC_MESSAGE_HANDLER(MediaPlayerEflMsg_SeekRequest, OnRequestSeek)
- IPC_MESSAGE_HANDLER(MediaPlayerEflMsg_NewFrameAvailable,
- OnNewFrameAvailable)
-#if defined(TIZEN_TBM_SUPPORT)
- IPC_MESSAGE_HANDLER(MediaPlayerEflMsg_NewTbmBufferAvailable,
- OnNewTbmBufferAvailable)
-#endif
- IPC_MESSAGE_UNHANDLED(handled = false)
- IPC_END_MESSAGE_MAP()
- return handled;
-}
-
-void RendererMediaPlayerManager::WasHidden() {
- PausePlayingPlayers();
-}
-
-void RendererMediaPlayerManager::OnStop() {
- PausePlayingPlayers();
-}
-
-void RendererMediaPlayerManager::Initialize(
- int player_id,
- MediaPlayerHostMsg_Initialize_Type type,
- const GURL& url,
- double volume,
- int demuxer_client_id) {
- Send(new MediaPlayerEflHostMsg_Init(routing_id(), player_id, type,
- url, volume, demuxer_client_id));
-}
-
-void RendererMediaPlayerManager::OnMediaDataChange(int player_id, int width,
- int height, int media) {
- WebMediaPlayerEfl* player = GetMediaPlayer(player_id);
- if (player)
- player->OnMediaDataChange(width, height, media);
-}
-
-void RendererMediaPlayerManager::OnDurationChange(
- int player_id,
- double duration) {
- WebMediaPlayerEfl* player = GetMediaPlayer(player_id);
- if (player)
- player->OnDurationChange(duration);
-}
-
-void RendererMediaPlayerManager::OnTimeUpdate(
- int player_id,
- double current_time) {
- WebMediaPlayerEfl* player = GetMediaPlayer(player_id);
- if (player)
- player->OnTimeUpdate(current_time);
-}
-
-void RendererMediaPlayerManager::OnBufferUpdate(
- int player_id,
- std::vector<media::MediaPlayerEfl::TimeRanges> buffer_range) {
- WebMediaPlayerEfl* player = GetMediaPlayer(player_id);
- if (player)
- player->OnBufferUpdate(buffer_range);
-}
-
-void RendererMediaPlayerManager::OnReadyStateChange(
- int player_id,
- blink::WebMediaPlayer::ReadyState state) {
- WebMediaPlayerEfl* player = GetMediaPlayer(player_id);
- if (player)
- player->SetReadyState(
- static_cast<blink::WebMediaPlayer::ReadyState>(state));
-}
-
-void RendererMediaPlayerManager::OnNetworkStateChange(
- int player_id,
- blink::WebMediaPlayer::NetworkState state) {
- WebMediaPlayerEfl* player = GetMediaPlayer(player_id);
- if (player)
- player->SetNetworkState(
- static_cast<blink::WebMediaPlayer::NetworkState>(state));
-}
-
-void RendererMediaPlayerManager::OnTimeChanged(int player_id) {
- WebMediaPlayerEfl* player = GetMediaPlayer(player_id);
- if (player)
- player->OnTimeChanged();
-}
-
-void RendererMediaPlayerManager::OnSeekStateChange(int player_id,
- bool state) {
- WebMediaPlayerEfl* player = GetMediaPlayer(player_id);
- if (player)
- player->OnSeekStateChange(state);
-}
-
-void RendererMediaPlayerManager::OnPauseStateChange(int player_id,
- bool state) {
- WebMediaPlayerEfl* player = GetMediaPlayer(player_id);
- if (player)
- player->OnPauseStateChange(state);
-}
-
-void RendererMediaPlayerManager::OnRequestSeek(int player_id,
- double seek_time) {
- WebMediaPlayerEfl* player = GetMediaPlayer(player_id);
- if (player)
- player->OnRequestSeek(seek_time);
-}
-
-void RendererMediaPlayerManager::OnNewFrameAvailable(
- int player_id,
- base::SharedMemoryHandle foreign_memory_handle,
- uint32_t length, base::TimeDelta timestamp) {
- WebMediaPlayerEfl* player = GetMediaPlayer(player_id);
- if (player)
- player->OnNewFrameAvailable(foreign_memory_handle, length, timestamp);
-}
-
-#if defined(TIZEN_TBM_SUPPORT)
-void RendererMediaPlayerManager::OnNewTbmBufferAvailable(
- int player_id, gfx::TbmBufferHandle tbm_handle,
- base::TimeDelta timestamp) {
- WebMediaPlayerEfl* player = GetMediaPlayer(player_id);
-
- if (player)
- player->OnNewTbmBufferAvailable(
- tbm_handle, timestamp,
- media::BindToCurrentLoop(
- base::BindOnce(&RendererMediaPlayerManager::OnTbmBufferRelease,
- base::Unretained(this), tbm_handle)));
-}
-
-void RendererMediaPlayerManager::OnTbmBufferRelease(
- gfx::TbmBufferHandle tbm_handle) {
- RenderThread::Get()->Send(
- new MediaPlayerEflHostMsg_ReleaseTbmBuffer(tbm_handle));
-}
-#endif
-
-WebMediaPlayerEfl* RendererMediaPlayerManager::GetMediaPlayer(
- int player_id) {
- std::map<int, WebMediaPlayerEfl*>::iterator iter =
- media_players_.find(player_id);
- if (iter != media_players_.end())
- return iter->second;
- return NULL;
-}
-
-void RendererMediaPlayerManager::Play(int player_id) {
- Send(new MediaPlayerEflHostMsg_Play(routing_id(), player_id));
-}
-
-void RendererMediaPlayerManager::Pause(int player_id,
- bool is_media_related_action) {
- Send(new MediaPlayerEflHostMsg_Pause(routing_id(), player_id));
-}
-
-void RendererMediaPlayerManager::Seek(int player_id, double time) {
- Send(new MediaPlayerEflHostMsg_Seek(routing_id(), player_id, time));
-}
-
-void RendererMediaPlayerManager::SetVolume(int player_id, double volume) {
- Send(new MediaPlayerEflHostMsg_SetVolume(routing_id(), player_id, volume));
-}
-
-void RendererMediaPlayerManager::SetRate(int player_id, double rate) {
- Send(new MediaPlayerEflHostMsg_SetRate(routing_id(), player_id, rate));
-}
-
-void RendererMediaPlayerManager::DestroyPlayer(int player_id) {
- Send(new MediaPlayerEflHostMsg_DeInit(routing_id(), player_id));
-}
-
-int RendererMediaPlayerManager::RegisterMediaPlayer(
- WebMediaPlayerEfl* player) {
- media_players_[next_media_player_id_] = player;
- return next_media_player_id_++;
-}
-
-void RendererMediaPlayerManager::UnregisterMediaPlayer(int player_id) {
- media_players_.erase(player_id);
-}
-
-} // namespace content
+++ /dev/null
-// Copyright 2014 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 CONTENT_RENDERER_MEDIA_EFL_RENDERER_MEDIA_PLAYER_MANAGER_EFL_H_
-#define CONTENT_RENDERER_MEDIA_EFL_RENDERER_MEDIA_PLAYER_MANAGER_EFL_H_
-
-#include <map>
-
-#include "base/memory/shared_memory.h"
-#include "content/common/media/efl/media_player_messages_enums_efl.h"
-#include "content/public/renderer/render_frame_observer.h"
-#include "media/base/efl/media_player_efl.h"
-#include "third_party/blink/public/platform/WebMediaPlayer.h"
-#include "url/gurl.h"
-#if defined(TIZEN_TBM_SUPPORT)
-#include "ui/gfx/gpu_memory_buffer.h"
-#endif
-
-namespace content {
-class WebMediaPlayerEfl;
-
-class RendererMediaPlayerManager : public RenderFrameObserver {
- public:
- // Constructs a RendererMediaPlayerManager object for the |render_frame|.
- explicit RendererMediaPlayerManager(RenderFrame* render_frame);
- ~RendererMediaPlayerManager() override;
-
- RendererMediaPlayerManager(const RendererMediaPlayerManager&) = delete;
- RendererMediaPlayerManager& operator=(const RendererMediaPlayerManager&) =
- delete;
-
- // Initializes a MediaPlayerEfl object in browser process.
- void Initialize(int player_id, MediaPlayerHostMsg_Initialize_Type type,
- const GURL& url, double volume, int demuxer_client_id);
-
- // Starts the player.
- void Play(int player_id);
-
- // Pauses the player.
- // is_media_related_action should be true if this pause is coming from an
- // an action that explicitly pauses the video (user pressing pause, JS, etc.)
- // Otherwise it should be false if Pause is being called due to other reasons
- // (cleanup, freeing resources, etc.)
- void Pause(int player_id, bool is_media_related_action);
-
- // Performs seek on the player.
- void Seek(int player_id, double time);
-
- // Sets the player volume.
- void SetVolume(int player_id, double volume);
-
- // Sets the playback rate.
- void SetRate(int player_id, double rate);
-
- // Destroys the player in the browser process
- void DestroyPlayer(int player_id);
-
- // Registers and unregisters a WebMediaPlayerEfl object.
- int RegisterMediaPlayer(WebMediaPlayerEfl* player);
- void UnregisterMediaPlayer(int player_id);
-
- // RenderFrameObserver overrides.
- bool OnMessageReceived(const IPC::Message& message) override;
- void WasHidden() override;
- void OnStop() override;
-
- // Pause the playing media players when tab/webpage goes to background
- void PausePlayingPlayers();
-
- private:
- void OnNewFrameAvailable(int player_id,
- base::SharedMemoryHandle foreign_memory_handle,
- uint32_t length, base::TimeDelta timestamp);
-
-#if defined(TIZEN_TBM_SUPPORT)
- void OnNewTbmBufferAvailable(int player_id, gfx::TbmBufferHandle tbm_handle,
- base::TimeDelta timestamp);
- void OnTbmBufferRelease(gfx::TbmBufferHandle tbm_handle);
-#endif
-
- WebMediaPlayerEfl* GetMediaPlayer(int player_id);
- void OnMediaDataChange(int player_id, int width, int height, int media);
- void OnDurationChange(int player_id, double duration);
- void OnTimeUpdate(int player_id, double current_time);
- void OnBufferUpdate(
- int player_id,
- std::vector<media::MediaPlayerEfl::TimeRanges> buffer_range);
- void OnTimeChanged(int player_id);
- void OnPauseStateChange(int player_id, bool state);
- void OnSeekStateChange(int player_id, bool state);
- void OnRequestSeek(int player_id, double seek_time);
- void OnReadyStateChange(int player_id,
- blink::WebMediaPlayer::ReadyState state);
- void OnNetworkStateChange(int player_id,
- blink::WebMediaPlayer::NetworkState state);
-
- private:
- std::map<int, WebMediaPlayerEfl*> media_players_;
- int next_media_player_id_;
-};
-
-} // namespace content
-
-#endif // CONTENT_RENDERER_MEDIA_EFL_RENDERER_MEDIA_PLAYER_MANAGER_EFL_H_
+++ /dev/null
-// Copyright 2015 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.
-
-#include "content/renderer/media/efl/webmediaplayer_efl.h"
-
-#include "cc/blink/web_layer_impl.h"
-#include "cc/layers/video_layer.h"
-#include "content/renderer/media/render_media_log.h"
-#include "content/renderer/media/renderer_gpu_video_accelerator_factories.h"
-#include "content/renderer/render_frame_impl.h"
-#include "content/renderer/render_thread_impl.h"
-#include "media/base/bind_to_current_loop.h"
-#include "media/base/efl/media_player_util_efl.h"
-#include "media/base/video_frame.h"
-#include "media/blink/webmediaplayer_util.h"
-#include "third_party/blink/public/platform/WebMediaPlayer.h"
-#include "third_party/blink/public/platform/WebMediaPlayerClient.h"
-#include "third_party/libyuv/include/libyuv/planar_functions.h"
-
-#define BIND_TO_RENDER_LOOP(function) \
- (DCHECK(main_loop_->BelongsToCurrentThread()), \
- media::BindToCurrentLoop(base::BindOnce(function, AsWeakPtr())))
-
-// Round up 'x' to Multiple of 'a' byte.
-// To properly use planes from tbm, width and height should round up to 16.
-#define ALIGN(x, a) (((x) + (a) - 1) & ~((a) - 1))
-
-using media::VideoFrame;
-
-namespace content {
-
-blink::WebMediaPlayer* CreateWebMediaPlayerEfl(
- content::RendererMediaPlayerManager* manager,
- blink::WebFrame* frame,
- blink::WebMediaPlayerClient* client,
- base::WeakPtr<media::WebMediaPlayerDelegate> delegate,
- const media::WebMediaPlayerParams& params) {
- return new WebMediaPlayerEfl(manager, frame, client, delegate, params);
-}
-
-WebMediaPlayerEfl::WebMediaPlayerEfl(
- RendererMediaPlayerManager* manager,
- blink::WebFrame* frame,
- blink::WebMediaPlayerClient* client,
- base::WeakPtr<media::WebMediaPlayerDelegate> delegate,
- const media::WebMediaPlayerParams& params)
- : frame_(frame),
- network_state_(blink::WebMediaPlayer::NetworkStateEmpty),
- ready_state_(blink::WebMediaPlayer::ReadyStateHaveNothing),
- main_loop_(base::ThreadTaskRunnerHandle::Get()),
- media_task_runner_(params.media_task_runner()),
- manager_(manager),
- client_(client),
- media_log_(params.media_log()),
- delegate_(delegate),
- defer_load_cb_(params.defer_load_cb()),
- // Threaded compositing isn't enabled universally yet.
- compositor_task_runner_(
- params.compositor_task_runner()
- ? params.compositor_task_runner()
- : base::MessageLoop::current()->task_runner()),
- compositor_(new media::VideoFrameCompositor(
- compositor_task_runner_,
- BIND_TO_RENDER_LOOP(&WebMediaPlayerEfl::OnNaturalSizeChanged),
- BIND_TO_RENDER_LOOP(&WebMediaPlayerEfl::OnOpacityChanged))),
- weak_factory_(this),
- video_width_(0),
- video_height_(0),
- audio_(false),
- video_(false),
- current_time_(0),
- duration_(0),
- is_paused_(true),
- is_seeking_(false),
- seek_time_(0),
- pending_seek_(0),
- pending_seek_time_(0),
- opaque_(false),
- natural_size_(0, 0),
- did_loading_progress_(false),
- gpu_factories_(RenderThreadImpl::current()->GetGpuFactories())
-#if defined(TIZEN_MULTIMEDIA_EME_SUPPORT)
- , encrypted_media_support_(
- params.CreateEncryptedMediaPlayerSupport(client))
-#endif
- {
- DCHECK(manager_);
-#if defined(TIZEN_MULTIMEDIA_EME_SUPPORT)
- DCHECK(encrypted_media_support_);
-#endif
-
- player_id_ = manager_->RegisterMediaPlayer(this);
-
- media_log_->AddEvent(
- media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_CREATED));
-}
-
-WebMediaPlayerEfl::~WebMediaPlayerEfl() {
- if (manager_) {
- manager_->DestroyPlayer(player_id_);
- manager_->UnregisterMediaPlayer(player_id_);
- }
-
- compositor_->SetVideoFrameProviderClient(NULL);
- client_->setWebLayer(NULL);
- if (delegate_.get())
- delegate_->PlayerGone(this);
- compositor_task_runner_->DeleteSoon(FROM_HERE, compositor_);
- if (media_source_delegate_) {
- // Part of |media_source_delegate_| needs to be stopped
- // on the media thread.
- // Wait until |media_source_delegate_| is fully stopped
- // before tearing down other objects.
- base::WaitableEvent waiter(false, false);
- media_source_delegate_->Stop(base::BindOnce(&base::WaitableEvent::Signal,
- base::Unretained(&waiter)));
- waiter.Wait();
- }
-}
-
-void WebMediaPlayerEfl::load(LoadType load_type,
- const blink::WebURL& url,
- CORSMode /* cors_mode */) {
- if (!defer_load_cb_.is_null()) {
- defer_load_cb_.Run(base::BindOnce(&WebMediaPlayerEfl::DoLoad, AsWeakPtr(),
- load_type, url));
- return;
- }
- DoLoad(load_type, url);
-}
-
-void WebMediaPlayerEfl::DoLoad(LoadType load_type, const blink::WebURL& url) {
- int demuxer_client_id = 0;
- if (load_type == LoadTypeMediaSource) {
- player_type_ = MEDIA_PLAYER_TYPE_MEDIA_SOURCE;
- RendererDemuxerEfl* demuxer =
- static_cast<RendererDemuxerEfl*>(
- RenderThreadImpl::current()->renderer_demuxer());
- demuxer_client_id = demuxer->GetNextDemuxerClientID();
- media_source_delegate_.reset(new MediaSourceDelegateEfl(
- demuxer, demuxer_client_id, media_task_runner_, media_log_.get()));
- media::SetCdmReadyCB set_cdm_ready_cb;
- media::Demuxer::EncryptedMediaInitDataCB emedia_init_data_cb;
-#if defined(TIZEN_MULTIMEDIA_EME_SUPPORT)
- set_cdm_ready_cb =
- encrypted_media_support_->CreateSetDecryptorReadyCB();
- emedia_init_data_cb =
- encrypted_media_support_->CreateNeedKeyCB();
-#endif
- media_source_delegate_->InitializeMediaSource(
- base::BindOnce(&WebMediaPlayerEfl::OnMediaSourceOpened,
- weak_factory_.GetWeakPtr()),
- emedia_init_data_cb, set_cdm_ready_cb,
- base::BindOnce(&WebMediaPlayerEfl::SetNetworkState,
- weak_factory_.GetWeakPtr()),
- base::BindOnce(&WebMediaPlayerEfl::OnDurationChange,
- weak_factory_.GetWeakPtr()),
- base::BindOnce(&WebMediaPlayerEfl::OnWaitingForDecryptionKey,
- weak_factory_.GetWeakPtr()));
- } else if (load_type == LoadTypeURL) {
- player_type_ = MEDIA_PLAYER_TYPE_URL;
- } else {
- LOG(ERROR) << "Unsupported load type : " << load_type;
- return;
- }
-
- manager_->Initialize(player_id_, player_type_,
- media::GetCleanURL(url.string().utf8()),
- 0, demuxer_client_id);
-}
-
-#if defined(TIZEN_MULTIMEDIA_EME_SUPPORT)
-blink::WebMediaPlayer::MediaKeyException
-WebMediaPlayerEfl::generateKeyRequest(const blink::WebString& key_system,
- const unsigned char* init_data,
- unsigned init_data_length) {
- DCHECK(main_loop_->BelongsToCurrentThread());
-
- return encrypted_media_support_->GenerateKeyRequest(
- frame_, key_system, init_data, init_data_length);
-}
-
-blink::WebMediaPlayer::MediaKeyException WebMediaPlayerEfl::addKey(
- const blink::WebString& key_system,
- const unsigned char* key,
- unsigned key_length,
- const unsigned char* init_data,
- unsigned init_data_length,
- const blink::WebString& session_id) {
- DCHECK(main_loop_->BelongsToCurrentThread());
-
- return encrypted_media_support_->AddKey(
- key_system, key, key_length, init_data, init_data_length, session_id);
-}
-
-blink::WebMediaPlayer::MediaKeyException WebMediaPlayerEfl::cancelKeyRequest(
- const blink::WebString& key_system,
- const blink::WebString& session_id) {
- DCHECK(main_loop_->BelongsToCurrentThread());
-
- return encrypted_media_support_->CancelKeyRequest(key_system, session_id);
-}
-
-void WebMediaPlayerEfl::setContentDecryptionModule(
- blink::WebContentDecryptionModule* cdm) {
- DCHECK(main_loop_->BelongsToCurrentThread());
-
- encrypted_media_support_->SetContentDecryptionModule(cdm);
-}
-
-void WebMediaPlayerEfl::setContentDecryptionModule(
- blink::WebContentDecryptionModule* cdm,
- blink::WebContentDecryptionModuleResult result) {
- DCHECK(main_loop_->BelongsToCurrentThread());
-
- encrypted_media_support_->SetContentDecryptionModule(cdm, result);
-}
-#endif
-
-void WebMediaPlayerEfl::OnMediaSourceOpened(
- blink::WebMediaSource* web_media_source) {
- DCHECK(client_);
- client_->mediaSourceOpened(web_media_source);
-}
-
-void WebMediaPlayerEfl::OnWaitingForDecryptionKey() {
- encrypted_client_->didBlockPlaybackWaitingForKey();
-
- // TODO(jrummell): didResumePlaybackBlockedForKey() should only be called
- // when a key has been successfully added (e.g. OnSessionKeysChange() with
- // |has_additional_usable_key| = true). http://crbug.com/461903
- encrypted_client_->didResumePlaybackBlockedForKey();
-}
-
-void WebMediaPlayerEfl::play() {
- manager_->Play(player_id_);
- // Has to be updated from |MediaPlayerEfl| but IPC causes delay.
- // There are cases were play - pause are fired successively and would fail.
- is_paused_ = false;
-}
-
-void WebMediaPlayerEfl::pause() {
- manager_->Pause(player_id_, true);
- // Has to be updated from |MediaPlayerEfl| but IPC causes delay.
- // There are cases were play - pause are fired successively and would fail.
- is_paused_ = true;
-}
-
-void WebMediaPlayerEfl::RequestPause() {
- switch (network_state_) {
- // Pause the media player and inform Blink if the player is in a good
- // shape.
- case WebMediaPlayer::NetworkStateIdle:
- case WebMediaPlayer::NetworkStateLoading:
- case WebMediaPlayer::NetworkStateLoaded:
- pause();
- client_->playbackStateChanged();
- break;
- // If a WebMediaPlayer instance has entered into other then above states,
- // the internal network state in HTMLMediaElement could be set to empty.
- // And calling playbackStateChanged() could get this object deleted.
- default:
- break;
- }
-}
-
-bool WebMediaPlayerEfl::supportsSave() const {
- return false;
-}
-
-void WebMediaPlayerEfl::seek(double seconds) {
- DCHECK(main_loop_->BelongsToCurrentThread());
-
- if (is_seeking_) {
- if (seconds == seek_time_) {
- if (media_source_delegate_) {
- if (!pending_seek_) {
- // If using media source demuxer, only suppress redundant seeks if
- // there is no pending seek. This enforces that any pending seek that
- // results in a demuxer seek is preceded by matching
- // CancelPendingSeek() and StartSeek() calls.
- return;
- }
- } else {
- // Suppress all redundant seeks if unrestricted by media source
- // demuxer API.
- pending_seek_ = false;
- return;
- }
- }
-
- pending_seek_ = true;
- pending_seek_time_ = seconds;
- if (media_source_delegate_)
- media_source_delegate_->CancelPendingSeek(
- base::TimeDelta::FromSecondsD(pending_seek_time_));
- // Later, OnSeekComplete will trigger the pending seek.
- return;
- }
-
- is_seeking_ = true;
- seek_time_ = seconds;
-
- // Once Chunk demuxer seeks |MediaPlayerEfl| seek will be intiated.
- if (media_source_delegate_)
- media_source_delegate_->StartWaitingForSeek(
- base::TimeDelta::FromSecondsD(seek_time_));
- manager_->Seek(player_id_, seek_time_);
-
- // Draw empty frame during seek.
- if (video_) {
- gfx::Size size(video_width_, video_height_);
- scoped_refptr<VideoFrame> video_frame = VideoFrame::CreateBlackFrame(size);
- FrameReady(video_frame);
- }
-}
-
-void WebMediaPlayerEfl::setRate(double rate) {
- manager_->SetRate(player_id_, rate);
-}
-
-void WebMediaPlayerEfl::setVolume(double volume) {
- manager_->SetVolume(player_id_, volume);
-}
-
-blink::WebTimeRanges WebMediaPlayerEfl::buffered() const {
- if (media_source_delegate_)
- return media_source_delegate_->Buffered();
- return buffered_;
-}
-
-blink::WebTimeRanges WebMediaPlayerEfl::seekable() const {
- const double seekable_end = duration();
- if (std::isinf(seekable_end))
- return blink::WebTimeRanges();
-
- blink::WebTimeRange seekable_range(0.0, seekable_end);
- return blink::WebTimeRanges(&seekable_range, 1);
-}
-
-void WebMediaPlayerEfl::setSinkId(
- const blink::WebString& device_id,
- const blink::WebSecurityOrigin& security_origin,
- blink::WebSetSinkIdCallbacks* web_callback) {
- DCHECK(main_loop_->BelongsToCurrentThread());
- scoped_ptr<blink::WebSetSinkIdCallbacks> callback(web_callback);
- callback->onError(blink::WebSetSinkIdError::NotSupported);
-}
-
-void WebMediaPlayerEfl::paint(blink::WebCanvas* canvas,
- const blink::WebRect& rect,
- unsigned char alpha,
- SkXfermode::Mode mode) {
- scoped_refptr<VideoFrame> video_frame =
- GetCurrentFrameFromCompositor();
-
- gfx::RectF gfx_rect(rect);
- media::Context3D context_3d;
- skcanvas_video_renderer_.Paint(
- video_frame.get(), canvas, gfx_rect, alpha,
- SkXfermode::kSrcOver_Mode, media::VIDEO_ROTATION_0, context_3d);
-}
-
-bool WebMediaPlayerEfl::hasVideo() const {
- return video_;
-}
-
-bool WebMediaPlayerEfl::hasAudio() const {
- return audio_;
-}
-
-blink::WebSize WebMediaPlayerEfl::naturalSize() const {
- return blink::WebSize(natural_size_);
-}
-
-bool WebMediaPlayerEfl::paused() const {
- return is_paused_;
-}
-
-bool WebMediaPlayerEfl::seeking() const {
- return is_seeking_;
-}
-
-double WebMediaPlayerEfl::duration() const {
- return duration_;
-}
-
-double WebMediaPlayerEfl::currentTime() const {
- if (seeking())
- return pending_seek_ ? pending_seek_time_ : seek_time_;
- return current_time_;
-}
-
-blink::WebMediaPlayer::NetworkState WebMediaPlayerEfl::networkState() const {
- return network_state_;
-}
-
-blink::WebMediaPlayer::ReadyState WebMediaPlayerEfl::readyState() const {
- return ready_state_;
-}
-
-bool WebMediaPlayerEfl::didLoadingProgress() {
- if (did_loading_progress_) {
- did_loading_progress_ = false;
- return true;
- }
- return false;
-}
-
-bool WebMediaPlayerEfl::hasSingleSecurityOrigin() const {
- return true;
-}
-
-bool WebMediaPlayerEfl::didPassCORSAccessCheck() const {
- return false;
-}
-
-double WebMediaPlayerEfl::mediaTimeForTimeValue(double timeValue) const {
- return base::TimeDelta::FromSecondsD(timeValue).InSecondsF();
-}
-
-unsigned WebMediaPlayerEfl::decodedFrameCount() const {
- return 0;
-};
-
-unsigned WebMediaPlayerEfl::droppedFrameCount() const {
- return 0;
-};
-
-unsigned WebMediaPlayerEfl::audioDecodedByteCount() const {
- return 0;
-};
-
-unsigned WebMediaPlayerEfl::videoDecodedByteCount() const {
- return 0;
-};
-
-void WebMediaPlayerEfl::SetReadyState(WebMediaPlayer::ReadyState state) {
- ready_state_ = state;
- client_->readyStateChanged();
-}
-
-void WebMediaPlayerEfl::SetNetworkState(WebMediaPlayer::NetworkState state) {
- network_state_ = state;
- client_->networkStateChanged();
-}
-
-#if defined(TIZEN_TBM_SUPPORT)
-void WebMediaPlayerEfl::OnNewTbmBufferAvailable(
- const gfx::TbmBufferHandle& tbm_handle, base::TimeDelta timestamp,
- const base::Closure& cb) {
- gfx::Size size(video_width_, video_height_);
- scoped_refptr<VideoFrame> video_frame =
- VideoFrame::WrapTBMSurface(size, timestamp, tbm_handle);
- video_frame->AddDestructionObserver(cb);
- FrameReady(video_frame);
-}
-#endif
-
-void WebMediaPlayerEfl::OnNewFrameAvailable(base::SharedMemoryHandle handle,
- uint32 yuv_size,
- base::TimeDelta timestamp) {
- base::SharedMemory shared_memory(handle, false);
- if (!shared_memory.Map(yuv_size)) {
- LOG(ERROR) << "Failed to map shared memory for size " << yuv_size;
- return;
- }
-
- uint8* const yuv_buffer = static_cast<uint8*>(shared_memory.memory());
- gfx::Size size(video_width_, video_height_);
- scoped_refptr<VideoFrame> video_frame =
- VideoFrame::CreateFrame(
- media::PIXEL_FORMAT_YV12, size, gfx::Rect(size), size, timestamp);
-
- uint8* video_buf = yuv_buffer;
- const uint c_frm_size = yuv_size / 6;
- const uint y_frm_size = c_frm_size << 2; // * 4;
-
- // U Plane buffer.
- uint8* video_buf_u = video_buf + y_frm_size;
-
- // V Plane buffer.
- uint8* video_buf_v = video_buf_u + c_frm_size;
-
- // Get the videoframe stride size.
- // Calculate the video buffer stride size.
- const uint uv_rows = video_frame.get()->rows(VideoFrame::kUPlane);
- const uint video_stride = c_frm_size / uv_rows;
-
- libyuv::I420Copy(video_buf, 2 * video_stride,
- video_buf_u, video_stride,
- video_buf_v, video_stride,
- video_frame.get()->data(VideoFrame::kYPlane),
- video_frame.get()->stride(VideoFrame::kYPlane),
- video_frame.get()->data(VideoFrame::kUPlane),
- video_frame.get()->stride(VideoFrame::kUPlane),
- video_frame.get()->data(VideoFrame::kVPlane),
- video_frame.get()->stride(VideoFrame::kVPlane),
- video_width_, video_height_);
- FrameReady(video_frame);
-}
-
-void WebMediaPlayerEfl::FrameReady(
- const scoped_refptr<VideoFrame>& frame) {
- compositor_task_runner_->PostTask(
- FROM_HERE,
- base::BindOnce(
- &media::VideoFrameCompositor::PaintFrameUsingOldRenderingPath,
- base::Unretained(compositor_), frame));
-}
-
-void WebMediaPlayerEfl::OnMediaDataChange(int width, int height, int media) {
- video_height_ = height;
- video_width_ = width;
- audio_ = media & media::MEDIA_AUDIO_MASK ? true : false;
- video_ = media & media::MEDIA_VIDEO_MASK ? true : false;
- natural_size_ = gfx::Size(width, height);
- SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
- if (hasVideo() && !video_weblayer_.get()) {
- scoped_refptr<cc::VideoLayer> layer =
- cc::VideoLayer::Create(cc_blink::WebLayerImpl::LayerSettings(),
- compositor_, media::VIDEO_ROTATION_0);
- video_weblayer_.reset(new cc_blink::WebLayerImpl(layer));
- video_weblayer_->setOpaque(opaque_);
- client_->setWebLayer(video_weblayer_.get());
- }
-}
-
-void WebMediaPlayerEfl::OnTimeChanged() {
- is_seeking_ = false;
-
- // Handling pending seek for ME. For MSE |CancelPendingSeek|
- // will handle the pending seeks.
- if (!media_source_delegate_ && pending_seek_) {
- pending_seek_ = false;
- seek(pending_seek_time_);
- return;
- }
- client_->timeChanged();
-}
-
-void WebMediaPlayerEfl::OnDurationChange(double duration) {
- duration_ = duration;
- client_->durationChanged();
-}
-
-void WebMediaPlayerEfl::OnNaturalSizeChanged(gfx::Size size) {
- DCHECK(main_loop_->BelongsToCurrentThread());
- DCHECK_NE(ready_state_, WebMediaPlayer::ReadyStateHaveNothing);
- media_log_->AddEvent(
- media_log_->CreateVideoSizeSetEvent(size.width(), size.height()));
- natural_size_ = size;
-
- client_->sizeChanged();
-}
-
-void WebMediaPlayerEfl::OnOpacityChanged(bool opaque) {
- DCHECK(main_loop_->BelongsToCurrentThread());
- DCHECK_NE(ready_state_, WebMediaPlayer::ReadyStateHaveNothing);
-
- opaque_ = opaque;
- if (video_weblayer_)
- video_weblayer_->setOpaque(opaque_);
-}
-
-static void GetCurrentFrameAndSignal(
- media::VideoFrameCompositor* compositor,
- scoped_refptr<VideoFrame>* video_frame_out,
- base::WaitableEvent* event) {
- *video_frame_out = compositor->GetCurrentFrame();
- event->Signal();
-}
-
-scoped_refptr<VideoFrame>
-WebMediaPlayerEfl::GetCurrentFrameFromCompositor() {
- if (compositor_task_runner_->BelongsToCurrentThread())
- return compositor_->GetCurrentFrame();
-
- // Use a posted task and waitable event instead of a lock otherwise
- // WebGL/Canvas can see different content than what the compositor is seeing.
- scoped_refptr<VideoFrame> video_frame;
- base::WaitableEvent event(false, false);
- compositor_task_runner_->PostTask(
- FROM_HERE,
- base::BindOnce(&GetCurrentFrameAndSignal, base::Unretained(compositor_),
- &video_frame, &event));
- event.Wait();
- return video_frame;
-}
-
-void WebMediaPlayerEfl::OnTimeUpdate(double current_time) {
- current_time_ = current_time;
-}
-
-void WebMediaPlayerEfl::OnBufferUpdate(
- std::vector<media::MediaPlayerEfl::TimeRanges> buffer_range) {
- media::Ranges<base::TimeDelta> time_ranges;
- std::vector<media::MediaPlayerEfl::TimeRanges>::iterator tr_it;
- for (tr_it = buffer_range.begin(); tr_it != buffer_range.end(); ++tr_it) {
- time_ranges.Add(
- base::TimeDelta::FromMicroseconds((*tr_it).start),
- base::TimeDelta::FromMicroseconds((*tr_it).end));
- }
- blink::WebTimeRanges web_ranges(ConvertToWebTimeRanges(time_ranges));
- buffered_.swap(web_ranges);
- did_loading_progress_ = true;
-}
-
-void WebMediaPlayerEfl::OnPauseStateChange(bool state) {
- is_paused_ = state;
- client_->playbackStateChanged();
- if (!delegate_)
- return;
-
- if(is_paused_)
- delegate_->DidPause(this);
- else
- delegate_->DidPlay(this);
-}
-
-void WebMediaPlayerEfl::OnSeekStateChange(bool state) {
- is_seeking_ = state;
- // Draw empty frame during seek.
- if (video_ && is_seeking_) {
- gfx::Size size(video_width_, video_height_);
- scoped_refptr<VideoFrame> video_frame = VideoFrame::CreateBlackFrame(size);
- FrameReady(video_frame);
- }
-}
-
-void WebMediaPlayerEfl::OnRequestSeek(double seek_time) {
- client_->requestSeek(seek_time);
-}
-
-} // namespace content
+++ /dev/null
-// Copyright 2015 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 CONTENT_RENDERER_MEDIA_EFL_WEBMEDIAPLAYER_EFL_H_
-#define CONTENT_RENDERER_MEDIA_EFL_WEBMEDIAPLAYER_EFL_H_
-
-#include <vector>
-
-#include "base/memory/shared_memory.h"
-#include "base/message_loop/message_loop.h"
-#include "cc/layers/video_frame_provider_client_impl.h"
-#include "content/renderer/media/efl/media_source_delegate_efl.h"
-#include "content/renderer/media/efl/renderer_media_player_manager_efl.h"
-#include "media/base/efl/media_player_efl.h"
-#include "media/blink/video_frame_compositor.h"
-#include "media/blink/webmediaplayer_params.h"
-#include "media/blink/webmediaplayer_util.h"
-#include "media/renderers/skcanvas_video_renderer.h"
-#include "third_party/blink/public/platform/WebMediaPlayer.h"
-#include "third_party/blink/public/platform/WebMediaPlayerEncryptedMediaClient.h"
-
-#if defined(TIZEN_MULTIMEDIA_EME_SUPPORT)
-#include "media/blink/encrypted_media_player_support.h"
-#endif
-
-namespace blink {
-class WebFrame;
-class WebMediaPlayerClient;
-}
-
-namespace cc_blink {
-class WebLayerImpl;
-}
-
-namespace media {
-class GpuVideoAcceleratorFactories;
-class MediaLog;
-class MediaPlayerEfl;
-class WebMediaPlayerDelegate;
-class WebMediaPlayerEncryptedMediaClient;
-}
-
-namespace content {
-class RendererMediaPlayerManager;
-
-// This class implements blink::WebMediaPlayer by keeping the efl
-// media player in the browser process. It listens to all the status changes
-// sent from the browser process and sends playback controls to the media
-// player.
-class WebMediaPlayerEfl
- : public blink::WebMediaPlayer,
- public base::SupportsWeakPtr<WebMediaPlayerEfl> {
- public:
- // Construct a WebMediaPlayerEfl object. This class communicates
- // with the WebMediaPlayerEfl object in the browser process through
- // |proxy|.
- WebMediaPlayerEfl(
- RendererMediaPlayerManager* manager,
- blink::WebFrame* frame,
- blink::WebMediaPlayerClient* client,
- base::WeakPtr<media::WebMediaPlayerDelegate> delegate,
- const media::WebMediaPlayerParams& params);
- ~WebMediaPlayerEfl() override;
-
- WebMediaPlayerEfl(const WebMediaPlayerEfl&) = delete;
- WebMediaPlayerEfl& operator=(const WebMediaPlayerEfl&) = delete;
-
- // blink::WebMediaPlayer implementation.
- void load(LoadType load_type,
- const blink::WebURL& url,
- CORSMode cors_mode) override;
-
- // Playback controls.
- void play() override;
- void pause() override;
- bool supportsSave() const override;
- void seek(double seconds) override;
- void setRate(double) override;
- void setVolume(double) override;
- blink::WebTimeRanges buffered() const override;
- blink::WebTimeRanges seekable() const override;
- void setSinkId(const blink::WebString& sink_id,
- const blink::WebSecurityOrigin& security_origin,
- blink::WebSetSinkIdCallbacks* web_callback) override;
-
- void paint(blink::WebCanvas*,
- const blink::WebRect&,
- unsigned char alpha,
- SkXfermode::Mode) override;
-
- // True if the loaded media has a playable video/audio track.
- bool hasVideo() const override;
- bool hasAudio() const override;
-
- // Dimension of the video.
- blink::WebSize naturalSize() const override;
-
- // Getters of playback state.
- bool paused() const override;
- bool seeking() const override;
- double duration() const override;
- double currentTime() const override;
-
- // Internal states of loading and network.
- NetworkState networkState() const override;
- ReadyState readyState() const override;
-
- bool didLoadingProgress() override;
-
- bool hasSingleSecurityOrigin() const override;
- bool didPassCORSAccessCheck() const override;
-
- double mediaTimeForTimeValue(double timeValue) const override;
-
- unsigned decodedFrameCount() const override;
- unsigned droppedFrameCount() const override;
- unsigned audioDecodedByteCount() const override;
- unsigned videoDecodedByteCount() const override;
-
-#if defined(TIZEN_MULTIMEDIA_EME_SUPPORT)
- virtual MediaKeyException generateKeyRequest(
- const blink::WebString& key_system,
- const unsigned char* init_data,
- unsigned init_data_length);
-
- virtual MediaKeyException addKey(const blink::WebString& key_system,
- const unsigned char* key,
- unsigned key_length,
- const unsigned char* init_data,
- unsigned init_data_length,
- const blink::WebString& session_id);
-
- virtual MediaKeyException cancelKeyRequest(
- const blink::WebString& key_system,
- const blink::WebString& session_id);
-
- // TODO(jrummell): Remove this method once Blink updated to use the other
- // method.
- virtual void setContentDecryptionModule(
- blink::WebContentDecryptionModule* cdm);
- virtual void setContentDecryptionModule(
- blink::WebContentDecryptionModule* cdm,
- blink::WebContentDecryptionModuleResult result);
-#endif
-
- void SetReadyState(WebMediaPlayer::ReadyState state);
- void SetNetworkState(WebMediaPlayer::NetworkState state);
-
- void OnNewFrameAvailable(base::SharedMemoryHandle foreign_memory_handle,
- uint32_t length, base::TimeDelta timestamp);
-
-#if defined(TIZEN_TBM_SUPPORT)
- void OnNewTbmBufferAvailable(
- const gfx::TbmBufferHandle& tbm_handle,
- base::TimeDelta timestamp,
- const base::Closure& cb);
-#endif
-
- void OnMediaDataChange(int width, int height, int media);
- void OnDurationChange(double duration);
- void OnTimeUpdate(double current_time);
- void OnBufferUpdate(
- std::vector<media::MediaPlayerEfl::TimeRanges> buffer_range);
- void OnTimeChanged();
- void OnPauseStateChange(bool state);
- void OnSeekStateChange(bool state);
- void OnRequestSeek(double seek_time);
-
- void OnMediaSourceOpened(blink::WebMediaSource* web_media_source);
- void OnDemuxerSeekDone();
-
- void RequestPause();
-
- // Called when a decoder detects that the key needed to decrypt the stream
- // is not available.
- void OnWaitingForDecryptionKey();
-
- private:
- // Called after |defer_load_cb_| has decided to allow the load. If
- // |defer_load_cb_| is null this is called immediately.
- void DoLoad(LoadType load_type, const blink::WebURL& url);
-
- void OnNaturalSizeChanged(gfx::Size size);
- void OnOpacityChanged(bool opaque);
-
- // Returns the current video frame from |compositor_|. Blocks until the
- // compositor can return the frame.
- scoped_refptr<media::VideoFrame> GetCurrentFrameFromCompositor();
-
- // Called whenever there is new frame to be painted.
- void FrameReady(const scoped_refptr<media::VideoFrame>& frame);
-
- blink::WebFrame* frame_;
-
- blink::WebMediaPlayer::NetworkState network_state_;
- blink::WebMediaPlayer::ReadyState ready_state_;
-
- // Message loops for posting tasks on Chrome's main thread. Also used
- // for DCHECKs so methods calls won't execute in the wrong thread.
- const scoped_refptr<base::SingleThreadTaskRunner> main_loop_;
- scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
-
- // Manager for managing this object and for delegating method calls on
- // Render Thread.
- content::RendererMediaPlayerManager* manager_;
-
- blink::WebMediaPlayerClient* client_;
- blink::WebMediaPlayerEncryptedMediaClient* encrypted_client_;
-
- scoped_refptr<media::MediaLog> media_log_;
-
- base::WeakPtr<media::WebMediaPlayerDelegate> delegate_;
-
- media::WebMediaPlayerParams::DeferLoadCB defer_load_cb_;
-
- // The compositor layer for displaying the video content when using
- // composited playback.
- scoped_ptr<cc_blink::WebLayerImpl> video_weblayer_;
-
- // Video rendering members.
- scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
- media::VideoFrameCompositor* compositor_;
- media::SkCanvasVideoRenderer skcanvas_video_renderer_;
-
- base::WeakPtrFactory<WebMediaPlayerEfl> weak_factory_;
- scoped_ptr<content::MediaSourceDelegateEfl> media_source_delegate_;
- MediaPlayerHostMsg_Initialize_Type player_type_;
-
- // Player ID assigned by the |manager_|.
- int player_id_;
-
- int video_width_;
- int video_height_;
-
- bool audio_;
- bool video_;
-
- double current_time_;
- double duration_;
- bool is_paused_;
-
- bool is_seeking_;
- double seek_time_;
- bool pending_seek_;
- double pending_seek_time_;
-
- // Whether the video is known to be opaque or not.
- bool opaque_;
-
- gfx::Size natural_size_;
- blink::WebTimeRanges buffered_;
- mutable bool did_loading_progress_;
-
- // Factories for supporting video accelerators. May be null.
- media::GpuVideoAcceleratorFactories* gpu_factories_;
-#if defined(TIZEN_MULTIMEDIA_EME_SUPPORT)
- scoped_ptr<media::EncryptedMediaPlayerSupport> encrypted_media_support_;
-#endif
-};
-
-} // namespace content
-
-#endif // CONTENT_RENDERER_MEDIA_EFL_WEBMEDIAPLAYER_EFL_H_
+++ /dev/null
-// Copyright 2015 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.
-
-#include "content/renderer/media/efl/audio_decoder_efl.h"
-
-#include "base/memory/shared_memory.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/process/process.h"
-#include "base/strings/string_util.h"
-#include "base/time/time.h"
-#include "content/child/thread_safe_sender.h"
-#include "content/common/render_messages_efl.h"
-#include "media/base/audio_bus.h"
-#include "media/base/efl/webaudio_media_codec_info_efl.h"
-#include "media/base/limits.h"
-#include "public/platform/Platform.h"
-#include "third_party/blink/public/platform/WebAudioBus.h"
-
-namespace content {
-
-const size_t kAudioDataSizeLimit = 0x80000000;
-
-class AudioDecoderIO {
- public:
- AudioDecoderIO(const char* data, size_t data_size);
- virtual ~AudioDecoderIO();
-
- AudioDecoderIO(const AudioDecoderIO&) = delete;
- AudioDecoderIO& operator=(const AudioDecoderIO&) = delete;
-
- bool ShareEncodedDataToProcess(base::SharedMemoryHandle* handle);
-
- // Returns true if |AudioDecoderIO| was successfully created.
- bool IsValid() const;
-
- int GetReadFd() const { return read_fd_; }
- int GetWriteFd() const { return write_fd_; }
-
- private:
- // Shared memory that will hold the encoded audio data. This is
- // used by |MediaCodec| for decoding.
- base::SharedMemory encoded_data_handle_;
-
- // A pipe used to communicate with MediaCodec. MediaCodec owns
- // write_fd_ and writes to it.
- int read_fd_;
- int write_fd_;
-};
-
-AudioDecoderIO::AudioDecoderIO(const char* data, size_t data_size)
- : read_fd_(-1), write_fd_(-1) {
- if (!data || data_size > kAudioDataSizeLimit || data_size <= 0) {
- LOG(ERROR) << " Invalid Data";
- return;
- }
-
- // Create the shared memory and copy our data to it so that
- // |MediaCodec| can access it.
- if(!encoded_data_handle_.CreateAndMapAnonymous(data_size)) {
- LOG(ERROR) << " Creation of shared memory failed";
- return;
- }
-
- if (!encoded_data_handle_.memory()) {
- LOG(ERROR) << " Invalid shared memory";
- return;
- }
-
- memcpy(encoded_data_handle_.memory(), data, data_size);
-
- // Create a pipe for reading/writing the decoded PCM data
- int pipefd[2] = {0};
- if (-1 == pipe(pipefd)) {
- LOG(INFO) <<" Pipe is already created";
- return;
- }
-
- read_fd_ = pipefd[0];
- write_fd_ = pipefd[1];
-}
-
-AudioDecoderIO::~AudioDecoderIO() {
- // Close the read end of the pipe. The write end should have been
- // closed by |MediaCodec|.
- if (read_fd_ >= 0 && close(read_fd_)) {
- LOG(WARNING) << "Cannot close read fd " << read_fd_
- << ": " << strerror(errno);
- }
- read_fd_ = -1;
- write_fd_ = -1;
-}
-
-bool AudioDecoderIO::IsValid() const {
- return read_fd_ >= 0 && write_fd_ >= 0 &&
- encoded_data_handle_.memory();
-}
-
-bool AudioDecoderIO::ShareEncodedDataToProcess(
- base::SharedMemoryHandle* handle) {
- return encoded_data_handle_.ShareToProcess(base::GetCurrentProcessHandle(),
- handle);
-}
-
-static void CopyPcmDataToBus(int input_fd,
- blink::WebAudioBus* destination_bus,
- size_t num_of_frames,
- unsigned number_of_channels,
- double file_sample_rate) {
-
- ssize_t lread = 0;
- float sample = 0;
- size_t samples_in_pipe = 0;
- struct media::WebAudioMediaDataInfoEfl data_info;
- std::vector<float> decoded_samples[number_of_channels];
- while ((lread =
- HANDLE_EINTR(read(input_fd, &data_info, sizeof(data_info)))) > 0) {
- float pipe_data[data_info.size_ / sizeof(float)];
-
- lread = HANDLE_EINTR(read(input_fd, pipe_data, sizeof(pipe_data)));
- samples_in_pipe = lread / sizeof(float);
-
- for (size_t i = 0; i < number_of_channels; i++) {
- if ((decoded_samples[i].size() + samples_in_pipe) >
- decoded_samples[i].capacity()) {
- decoded_samples[i].reserve(
- std::max(samples_in_pipe, 2 * decoded_samples[i].capacity()));
- }
- }
- std::copy(pipe_data, pipe_data + samples_in_pipe,
- back_inserter(decoded_samples[data_info.channel_mask_ - 1]));
- }
- size_t number_of_samples = 0;
- for (size_t i = 0; i < number_of_channels; i++) {
- number_of_samples += decoded_samples[i].size();
- }
- size_t number_of_frames = number_of_samples / number_of_channels;
- size_t decoded_frames = 0;
- destination_bus->initialize(number_of_channels,
- number_of_frames,
- file_sample_rate);
-
- for (size_t frames = 0; frames < number_of_frames; frames++) {
- for (size_t channel = 0; channel < number_of_channels; channel++) {
- sample = decoded_samples[channel][frames];
- destination_bus->channelData(channel)[decoded_frames] = sample;
- }
- ++decoded_frames;
- }
- LOG(INFO) << "decoded_frames : " << decoded_frames
- << " number_of_frames : " << number_of_frames;
- if (decoded_frames < number_of_frames)
- destination_bus->resizeSmaller(decoded_frames);
-}
-
-static void BufferAndCopyPcmDataToBus(int input_fd,
- blink::WebAudioBus* destination_bus,
- unsigned number_of_channels,
- double file_sample_rate) {
- ssize_t lread = 0;
- float sample = 0;
- size_t samples_in_pipe = 0;
- struct media::WebAudioMediaDataInfoEfl data_info;
- std::vector<float> decoded_samples[number_of_channels];
- while ((lread =
- HANDLE_EINTR(read(input_fd, &data_info, sizeof(data_info)))) > 0) {
- float pipe_data[data_info.size_ / sizeof(float)];
-
- lread = HANDLE_EINTR(read(input_fd, pipe_data, sizeof(pipe_data)));
- samples_in_pipe = lread / sizeof(float);
-
- for (size_t i = 0; i < number_of_channels; i++) {
- if ((decoded_samples[i].size() + samples_in_pipe) >
- decoded_samples[i].capacity()) {
- decoded_samples[i].reserve(
- std::max(samples_in_pipe, 2 * decoded_samples[i].capacity()));
- }
- }
- std::copy(pipe_data, pipe_data + samples_in_pipe,
- back_inserter(decoded_samples[data_info.channel_mask_ - 1]));
- }
- size_t number_of_samples = 0;
- for (size_t i = 0; i < number_of_channels; i++) {
- number_of_samples += decoded_samples[i].size();
- }
- size_t number_of_frames = number_of_samples / number_of_channels;
- size_t decoded_frames = 0;
- destination_bus->initialize(number_of_channels,
- number_of_frames,
- file_sample_rate);
-
- for (size_t frames = 0; frames < number_of_frames; frames++) {
- for (size_t channel = 0; channel < number_of_channels; channel++) {
- sample = decoded_samples[channel][frames];
- destination_bus->channelData(channel)[decoded_frames] = sample;
- }
- ++decoded_frames;
- }
- LOG(INFO) << "decoded_frames : " << decoded_frames
- << " number_of_frames : " << number_of_frames;
-
- if (decoded_frames < number_of_frames)
- destination_bus->resizeSmaller(decoded_frames);
-}
-
-// Decode in-memory audio file data.
-bool DecodeAudioFileData(blink::WebAudioBus* destination_bus,
- const char* data, size_t data_size,
- scoped_refptr<ThreadSafeSender> sender) {
- AudioDecoderIO audio_decoder(data, data_size);
-
- if (!audio_decoder.IsValid()) {
- LOG(ERROR) << "Invalid audio_decoder";
- return false;
- }
-
- base::SharedMemoryHandle encoded_data_handle;
- audio_decoder.ShareEncodedDataToProcess(&encoded_data_handle);
- base::FileDescriptor fd(audio_decoder.GetWriteFd(), true);
-
- // Start Decoding in browser process which will read from
- // encoded_data_handle for our shared memory and write the decoded
- // PCM samples (16-bit integer) to our pipe.
-
- sender->Send(new EflViewHostMsg_WebAudioDecode(encoded_data_handle,
- fd, data_size));
-
- int input_fd = audio_decoder.GetReadFd();
- struct media::WebAudioMediaCodecInfoEfl info;
-
- ssize_t nread = HANDLE_EINTR(read(input_fd, &info, sizeof(info)));
-
- if (nread != sizeof(info)) {
- LOG(ERROR) << "Read Failed";
- return false;
- }
-
- double file_sample_rate = static_cast<double>(info.sample_rate_);
-
- // Sanity checks
- if (!info.channel_count_ ||
- info.channel_count_ > media::limits::kMaxChannels ||
- file_sample_rate < media::limits::kMinSampleRate ||
- file_sample_rate > media::limits::kMaxSampleRate) {
- return false;
- }
-
- if (info.number_of_frames_> 0) {
- CopyPcmDataToBus(input_fd, destination_bus, info.number_of_frames_,
- info.channel_count_, file_sample_rate);
- } else {
- BufferAndCopyPcmDataToBus(input_fd, destination_bus,
- info.channel_count_, file_sample_rate);
- }
-
- return true;
-}
-
-} // namespace content
"//tizen_src/build:libtts",
]
-if (tizen_multimedia_support) {
- external_content_renderer_efl_configs += [
- "//tizen_src/build:capi-media-player",
- "//tizen_src/build:libcapi-media-player",
- ]
-}
-
##############################################################################
# Dependency
##############################################################################
"//tizen_src/chromium_impl/content/renderer/common_renderer_client.h",
]
-if (tizen_multimedia_support) {
- #"media/audio_decoder.cc",
- #"media/audio_decoder.h",
- external_content_renderer_efl_sources += [
- "media/efl/audio_decoder_efl.h",
- "media/efl/media_source_delegate_efl.cc",
- "media/efl/media_source_delegate_efl.h",
- "media/efl/renderer_demuxer_efl.cc",
- "media/efl/renderer_demuxer_efl.h",
- "media/efl/renderer_media_player_manager_efl.cc",
- "media/efl/renderer_media_player_manager_efl.h",
- "media/efl/webmediaplayer_efl.cc",
- "media/efl/webmediaplayer_efl.h",
- "media/tizen/audio_decoder_capi.cc",
- ]
-}
-
if (tizen_multimedia) {
external_content_renderer_efl_sources += [
"//tizen_src/chromium_impl/content/renderer/media/tizen/media_player_renderer_client.cc",
+++ /dev/null
-// Copyright (c) 2014 The Samsung Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#if defined(TIZEN_MULTIMEDIA_USE_CAPI_AUDIO_IO)
-#include "media/audio/tizen/audio_manager_capi.h"
-#else
-#include "media/audio/pulse/audio_manager_pulse.h"
-#endif
-
-namespace media {
-
-AudioManager* CreateAudioManager(AudioLogFactory* audio_log_factory) {
-#if defined(TIZEN_MULTIMEDIA_USE_CAPI_AUDIO_IO)
- return media::AudioManagerCapi::Create(audio_log_factory);
-#else
- return AudioManagerPulse::Create(audio_log_factory);
-#endif
-}
-
-} // namespace media
+++ /dev/null
-// Copyright 2014 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_BASE_EFL_DEMUXER_EFL_H_
-#define MEDIA_BASE_EFL_DEMUXER_EFL_H_
-
-#include "media/base/efl/demuxer_stream_player_params_efl.h"
-
-namespace media {
-
-// Defines the client callback interface.
-class MEDIA_EXPORT DemuxerEflClient {
- public:
- // Called when the demuxer has initialized.
- virtual void OnDemuxerConfigsAvailable(const DemuxerConfigs& params) = 0;
-
- // Called in response to RequestDemuxerData().
- virtual void OnDemuxerDataAvailable(
- base::SharedMemoryHandle foreign_memory_handle,
- const media::DemuxedBufferMetaData& meta_data) = 0;
-
- // Called to inform demuxer seek completion.
- virtual void OnDemuxerSeekDone(
- const base::TimeDelta& actual_browser_seek_time) = 0;
-
- // Called whenever the demuxer has detected a duration change.
- virtual void OnDemuxerDurationChanged(base::TimeDelta duration) = 0;
-
- protected:
- virtual ~DemuxerEflClient() {}
-};
-
-// Defines a demuxer with asynchronous operations.
-class MEDIA_EXPORT DemuxerEfl {
- public:
- virtual ~DemuxerEfl() {}
-
- // Initializes this demuxer with |client| as the callback handler.
- // Must be called prior to calling any other methods.
- virtual void Initialize(DemuxerEflClient* client) = 0;
-
- // Called to request demuxer seek.
- virtual void RequestDemuxerSeek(const base::TimeDelta& time_to_seek) = 0;
-
- // Called to request additional data from the demuxer.
- virtual void RequestDemuxerData(media::DemuxerStream::Type type) = 0;
-};
-
-} // namespace media
-
-#endif // MEDIA_BASE_EFL_DEMUXER_EFL_H_
\ No newline at end of file
+++ /dev/null
-// Copyright 2014 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.
-
-#include "media/base/efl/demuxer_stream_player_params_efl.h"
-
-namespace media {
-
-DemuxerConfigs::DemuxerConfigs()
- : audio_codec(kUnknownAudioCodec),
- audio_channels(0),
- audio_sampling_rate(0),
- is_audio_encrypted(false),
- video_codec(kUnknownVideoCodec),
- is_video_encrypted(false),
- duration_ms(0) {}
-
-DemuxerConfigs::~DemuxerConfigs() {}
-
-DemuxedBufferMetaData::DemuxedBufferMetaData()
- : size(0),
- end_of_stream(false),
- type(DemuxerStream::UNKNOWN),
- status(DemuxerStream::kAborted) {}
-
-DemuxedBufferMetaData::~DemuxedBufferMetaData() {}
-
-} // namespace media
+++ /dev/null
-// Copyright 2014 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_BASE_EFL_DEMUXER_STREAM_PLAYER_PARAMS_EFL_H_
-#define MEDIA_BASE_EFL_DEMUXER_STREAM_PLAYER_PARAMS_EFL_H_
-
-#include <vector>
-
-#include "media/base/audio_decoder_config.h"
-#include "media/base/decrypt_config.h"
-#include "media/base/demuxer_stream.h"
-#include "media/base/media_export.h"
-#include "media/base/video_decoder_config.h"
-#include "ui/gfx/geometry/size.h"
-
-namespace media {
-
-struct MEDIA_EXPORT DemuxerConfigs {
- DemuxerConfigs();
- ~DemuxerConfigs();
-
- AudioCodec audio_codec;
- int audio_channels;
- int audio_sampling_rate;
- bool is_audio_encrypted;
- std::vector<uint8_t> audio_extra_data;
-
- VideoCodec video_codec;
- gfx::Size video_size;
- bool is_video_encrypted;
- std::vector<uint8_t> video_extra_data;
-
- int duration_ms;
-};
-
-struct MEDIA_EXPORT DemuxedBufferMetaData {
- DemuxedBufferMetaData();
- ~DemuxedBufferMetaData();
-
- int size;
- bool end_of_stream;
- base::TimeDelta timestamp;
- base::TimeDelta time_duration;
- DemuxerStream::Type type;
- DemuxerStream::Status status;
-};
-
-}; // namespace media
-
-#endif // MEDIA_BASE_EFL_DEMUXER_STREAM_PLAYER_PARAMS_EFL_H_
+++ /dev/null
-// Copyright 2014 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_BASE_EFL_WEBAUDIO_DECODER_EFL_H_
-#define MEDIA_BASE_EFL_WEBAUDIO_DECODER_EFL_H_
-
-#include <string>
-
-#include "base/memory/shared_memory.h"
-#include "media/base/media_export.h"
-
-namespace media {
-
-class MEDIA_EXPORT WebAudioDecoder {
- public:
- static WebAudioDecoder* GetWebAudioDecoder();
- virtual void EncodedDataReceived(base::SharedMemoryHandle memory_handle,
- base::FileDescriptor pcm_output,
- uint32_t data_size) = 0;
-};
-
-} // namespace media
-#endif // MEDIA_BASE_EFL_WEBAUDIO_DECODER_EFL_H_
+++ /dev/null
-// Copyright 2014 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_BASE_EFL_WEBAUDIO_MEDIA_CODEC_INFO_EFL_H_
-#define MEDIA_BASE_EFL_WEBAUDIO_MEDIA_CODEC_INFO_EFL_H_
-
-namespace media {
-
-// This structure holds the information about the audio file
-// determined by MediaCodec that is needed by the audio decoder to
-// create the necessary destination bus.
-struct WebAudioMediaCodecInfoEfl {
- unsigned long channel_count_;
- unsigned long sample_rate_;
- unsigned long number_of_frames_;
- WebAudioMediaCodecInfoEfl(unsigned long channel_count = 0,
- unsigned long sample_rate = 0,
- unsigned long number_of_frames = 0)
- : channel_count_(channel_count),
- sample_rate_(sample_rate),
- number_of_frames_(number_of_frames) {}
-};
-
-struct WebAudioMediaDataInfoEfl {
- int channel_mask_;
- int size_;
- WebAudioMediaDataInfoEfl(int channel_mask = 0, int size = 0)
- : channel_mask_(channel_mask),
- size_(size) {}
-};
-
-} // namespace media
-#endif // MEDIA_BASE_EFL_WEBAUDIO_MEDIA_CODEC_INFO_EFL_H_
+++ /dev/null
-// Copyright 2015 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.
-
-#include "base/process/process.h"
-#include "base/thread_task_runner_handle.h"
-#include "content/browser/media/efl/browser_demuxer_efl.h"
-#include "media/base/efl/media_player_manager_efl.h"
-#include "media/base/tizen/media_source_player_capi.h"
-#include "third_party/libyuv/include/libyuv.h"
-
-namespace {
-const int kDurationUpdateInterval = 100;
-
-// Waiting time for buffering while seeking.
-const double kSeekBufferingWaitInSec = 2;
-
-// CAPI internal appsrc buffer size.
-const uint64 max_size = 2097152; // 2MB
-
-// Appsrc minimum buffering level
-const unsigned int min_threshold = 30;
-
-} // namespace
-
-namespace media {
-void OnCapiPlayerPreparedCB(void* user_data) {
- MediaSourcePlayerCapi* player =
- static_cast<MediaSourcePlayerCapi*>(user_data);
- player->OnPrepareComplete();
-}
-
-void OnSeekCompleteCB(void* user_data) {
- MediaSourcePlayerCapi* player =
- static_cast<MediaSourcePlayerCapi*>(user_data);
- player->OnSeekComplete();
-}
-
-void OnHandleBufferingMessageCB(int percent, void* user_data) {
- MediaSourcePlayerCapi* player =
- static_cast<MediaSourcePlayerCapi*>(user_data);
- player->OnHandleBufferingMessage(percent);
-}
-
-void OnCapiAudioBufStatusCB(player_media_stream_buffer_status_e status,
- void* user_data) {
- MediaSourcePlayerCapi* player =
- static_cast<MediaSourcePlayerCapi*>(user_data);
- if (status == PLAYER_MEDIA_STREAM_BUFFER_UNDERRUN) {
- player->OnUpdateDataStatus(media::DemuxerStream::AUDIO, true);
- } else if (status == PLAYER_MEDIA_STREAM_BUFFER_OVERFLOW) {
- player->OnUpdateDataStatus(media::DemuxerStream::AUDIO, false);
- }
-}
-
-void OnCapiVideoBufStatusCB(player_media_stream_buffer_status_e status,
- void* user_data) {
- MediaSourcePlayerCapi* player =
- static_cast<MediaSourcePlayerCapi*>(user_data);
- if (status == PLAYER_MEDIA_STREAM_BUFFER_UNDERRUN) {
- player->OnUpdateDataStatus(media::DemuxerStream::VIDEO, true);
- } else if (status == PLAYER_MEDIA_STREAM_BUFFER_OVERFLOW) {
- player->OnUpdateDataStatus(media::DemuxerStream::VIDEO, false);
- }
-}
-
-static void OnMediaPacketDecoded(media_packet_h packet, void* data) {
- if (!packet) {
- LOG(ERROR) << "media_packet handle is null";
- return;
- }
-
- MediaSourcePlayerCapi* player = static_cast<MediaSourcePlayerCapi*>(data);
- player->OnMediaPacketUpdated(packet);
-}
-
-void OnPlaybackCompleteCB(void* user_data) {
- LOG(INFO) << "On playback complete Call back";
- MediaSourcePlayerCapi* player =
- static_cast<MediaSourcePlayerCapi*>(user_data);
-
- if (!player)
- return;
-
- player->OnPlaybackComplete();
-}
-
-void OnPlayerErrorCB(int error_code, void* user_data) {
- MediaSourcePlayerCapi* player =
- static_cast<MediaSourcePlayerCapi*>(user_data);
-
- if (!player)
- return;
-
- player->OnHandlePlayerError(error_code, FROM_HERE);
-}
-
-void MediaSourcePlayerCapi::PrepareComplete() {
- player_prepared_ = true;
- manager()->OnReadyStateChange(
- GetPlayerId(), blink::WebMediaPlayer::ReadyStateHaveEnoughData);
- manager()->OnNetworkStateChange(
- GetPlayerId(), blink::WebMediaPlayer::NetworkStateLoaded);
-}
-
-MediaPlayerEfl* MediaPlayerEfl::CreatePlayer(
- int player_id, content::BrowserDemuxerEfl* demuxer,
- int demuxer_id, MediaPlayerManager* manager) {
- LOG(INFO) << "MediaSourceElement is using |CAPI| to play media";
- return new MediaSourcePlayerCapi(player_id,
- demuxer->CreateDemuxer(demuxer_id),
- manager);
-}
-
-MediaSourcePlayerCapi::MediaSourcePlayerCapi(int player_id,
- scoped_ptr<DemuxerEfl> demuxer,
- MediaPlayerManager* manager)
- : MediaPlayerEfl(player_id, manager),
- demuxer_(std::move(demuxer)),
- task_runner_(base::ThreadTaskRunnerHandle::Get()),
- weak_this_(this),
- player_(NULL),
- media_type_(0),
- duration_(0),
- play_rate_(1.0f),
- player_prepared_(false),
- playing_(false),
- is_end_reached_(false),
- eos_audio_(false),
- eos_video_(false),
- error_occured_(false),
- should_feed_audio_(false),
- should_feed_video_(false),
- seek_offset_(0),
- seek_state_(MEDIA_SEEK_NONE),
- media_packet_(NULL),
- audio_format_(NULL),
- video_format_(NULL),
- weak_factory_(this) {
- demuxer_->Initialize(this);
- audio_buffer_queue_.clear();
- video_buffer_queue_.clear();
-
- /*Init Player*/
- int ret = player_create(&player_);
- if (ret != PLAYER_ERROR_NONE) {
- OnHandlePlayerError(ret, FROM_HERE);
- return;
- }
-
- ret = player_set_buffering_cb(player_, OnHandleBufferingMessageCB, this);
- if (ret != PLAYER_ERROR_NONE) {
- OnHandlePlayerError(ret, FROM_HERE);
- return;
- }
-
- ret = player_set_sound_type(player_, SOUND_TYPE_MEDIA);
- if (ret != PLAYER_ERROR_NONE) {
- OnHandlePlayerError(ret, FROM_HERE);
- return;
- }
- ret = player_set_error_cb(player_, OnPlayerErrorCB, this);
- if (ret != PLAYER_ERROR_NONE) {
- OnHandlePlayerError(ret, FROM_HERE);
- return;
- }
- ret = player_set_completed_cb(player_, OnPlaybackCompleteCB, this);
- if (ret != PLAYER_ERROR_NONE) {
- OnHandlePlayerError(ret, FROM_HERE);
- return;
- }
-
- ret = player_set_media_packet_video_frame_decoded_cb(
- player_, OnMediaPacketDecoded, this);
- if (ret != PLAYER_ERROR_NONE) {
- OnHandlePlayerError(ret, FROM_HERE);
- return;
- }
-
- player_set_display_visible(player_, true);
-
- ret = player_set_uri(player_, "es_buff://push_mode");
- if (ret != PLAYER_ERROR_NONE) {
- OnHandlePlayerError(ret, FROM_HERE);
- return;
- }
-}
-
-MediaSourcePlayerCapi::~MediaSourcePlayerCapi() {
- Release();
- player_destroy(player_);
-}
-
-void MediaSourcePlayerCapi::SeekComplete() {
- DCHECK(task_runner_->BelongsToCurrentThread());
- UpdateSeekState(MEDIA_SEEK_NONE);
-
- // Initiate play for internal seeks.
- if (GetPlayerState() != PLAYER_STATE_PLAYING)
- Play();
-
- manager()->OnTimeUpdate(GetPlayerId(), GetCurrentTime());
- manager()->OnTimeChanged(GetPlayerId());
-}
-
-
-void MediaSourcePlayerCapi::UpdateSeekState(MediaSeekState state) {
- switch (state) {
- // Notify manager about player seek complete.
- case MEDIA_SEEK_NONE:
- manager()->OnSeekStateChange(GetPlayerId(), false);
- break;
-
- // Notify manager about player seek start.
- case MEDIA_SEEK_PLAYER:
- manager()->OnSeekStateChange(GetPlayerId(), true);
- break;
-
- // No need to notify manager about seek state change.
- case MEDIA_SEEK_DEMUXER:
- case MEDIA_SEEK_DEMUXER_DONE:
- break;
-
- default:
- NOTREACHED();
- break;
- }
-
- seek_state_ = state;
-}
-
-void MediaSourcePlayerCapi::SetRate(double rate) {
- if (play_rate_ == rate)
- return;
-
- if (rate == 0.0) {
- play_rate_ = rate;
- Pause(true);
- return;
- }
-
- // FIXME: |player_set_playback_rate| is always failing.
- int err = player_set_playback_rate(player_, static_cast<float>(rate));
- if (err != PLAYER_ERROR_NONE) {
- OnHandlePlayerError(err, FROM_HERE);
- return;
- } else {
- // If previous rate was zero and requested rate is non-zero, change the
- // playback rate and call play.
- if (play_rate_ == 0.0) {
- play_rate_ = rate;
- Play();
- } else {
- play_rate_ = rate;
- }
- }
-}
-
-void MediaSourcePlayerCapi::Seek(const double time) {
- UpdateSeekState(MEDIA_SEEK_DEMUXER);
- if (GetPlayerState() == PLAYER_STATE_PLAYING)
- Pause(true);
-
- seek_offset_ = time;
-
- base::TimeDelta seek_time = base::TimeDelta::FromSecondsD(time);
- demuxer_->RequestDemuxerSeek(seek_time);
-}
-
-player_state_e MediaSourcePlayerCapi::GetPlayerState() {
- player_state_e state = PLAYER_STATE_NONE;
- player_get_state(player_, &state);
- LOG(INFO) << __FUNCTION__ << " state " << state;
- return state;
-}
-
-void MediaSourcePlayerCapi::SeekInternal() {
- if (error_occured_)
- return;
-
- int ret = PLAYER_ERROR_NONE;
- ret = player_set_play_position(
- player_, ConvertSecondsToMilliSeconds(seek_offset_),
- true, OnSeekCompleteCB, this);
-
- seek_offset_ = 0.0;
-
- MediaSeekState state = MEDIA_SEEK_PLAYER;
- if (ret != PLAYER_ERROR_NONE) {
- LOG(ERROR) << "Seek to " << " failed";
- OnHandlePlayerError(ret, FROM_HERE);
- state = MEDIA_SEEK_NONE;
- }
- UpdateSeekState(state);
-}
-
-void MediaSourcePlayerCapi::OnDemuxerDurationChanged(
- base::TimeDelta duration) {
- duration_ = duration.InSecondsF();
-}
-
-void MediaSourcePlayerCapi::OnDemuxerSeekDone(
- const base::TimeDelta& actual_browser_seek_time) {
- if (error_occured_)
- return;
-
- seek_offset_ = actual_browser_seek_time.InSecondsF();
- UpdateSeekState(MEDIA_SEEK_DEMUXER_DONE);
-
- audio_buffer_queue_.clear();
- video_buffer_queue_.clear();
-
- OnReadDemuxedData(media::DemuxerStream::AUDIO);
- OnReadDemuxedData(media::DemuxerStream::VIDEO);
-}
-
-void MediaSourcePlayerCapi::OnMediaPacketUpdated(media_packet_h packet) {
- ScopedMediaPacket packet_proxy(packet);
- task_runner_->PostTask(
- FROM_HERE,
- base::BindOnce(&MediaSourcePlayerCapi::DeliverMediaPacket,
- weak_factory_.GetWeakPtr(), base::Passed(&packet_proxy)));
-}
-
-void MediaSourcePlayerCapi::SetVolume(double volume) {
- if (GetPlayerState() <= PLAYER_STATE_IDLE)
- return;
-
- if (player_set_volume(player_, volume, volume) != PLAYER_ERROR_NONE)
- LOG(ERROR) << "|player_set_volume| failed";
-}
-
-double MediaSourcePlayerCapi::GetCurrentTime() {
- if (error_occured_)
- return 0.0;
-
- int position = 0;
- player_get_play_position(player_, &position);
- return ConvertMilliSecondsToSeconds(position);
-}
-
-void MediaSourcePlayerCapi::OnCurrentTimeUpdateTimerFired() {
- manager()->OnTimeUpdate(GetPlayerId(), GetCurrentTime());
-}
-
-void MediaSourcePlayerCapi::StartCurrentTimeUpdateTimer() {
- if (current_time_update_timer_.IsRunning())
- return;
-
- current_time_update_timer_.Start(
- FROM_HERE,
- base::TimeDelta::FromMilliseconds(kDurationUpdateInterval),
- this,
- &MediaSourcePlayerCapi::OnCurrentTimeUpdateTimerFired);
-}
-
-void MediaSourcePlayerCapi::StopCurrentTimeUpdateTimer() {
- if (current_time_update_timer_.IsRunning())
- current_time_update_timer_.Stop();
-}
-
-void MediaSourcePlayerCapi::Play() {
- if (error_occured_ || playing_ || !player_prepared_)
- return;
-
- if (play_rate_ == 0.0) {
- playing_ = true;
- return;
- }
-
- WakeUpDisplayAndAcquireDisplayLock();
-
- int ret = player_start(player_);
- if (ret != PLAYER_ERROR_NONE) {
- OnHandlePlayerError(ret, FROM_HERE);
- return;
- }
- playing_ = true;
- StartCurrentTimeUpdateTimer();
-}
-
-void MediaSourcePlayerCapi::Pause(bool is_media_related_action) {
- if (error_occured_ || !playing_)
- return;
-
- if (GetPlayerState() != PLAYER_STATE_PLAYING) {
- LOG(WARNING) << "Can't PAUSE player";
- return;
- }
-
- int ret = player_pause(player_);
- if (ret != PLAYER_ERROR_NONE) {
- OnHandlePlayerError(ret, FROM_HERE);
- return;
- }
- StopCurrentTimeUpdateTimer();
- if (!is_media_related_action) {
- ReleaseDisplayLock();
- }
- playing_ = false;
-}
-
-void MediaSourcePlayerCapi::PlaybackComplete() {
- double time = GetCurrentTime() != duration_ ? duration_ : GetCurrentTime();
- is_end_reached_ = true;
- StopCurrentTimeUpdateTimer();
- manager()->OnTimeUpdate(GetPlayerId(), time);
- manager()->OnTimeChanged(GetPlayerId());
- ReleaseDisplayLock();
-}
-
-// TODO(sam) : It's worked as bypass now. Need Suspend/Resume/Initialize
-// implementation for MSE multiple instance.
-void MediaSourcePlayerCapi::Initialize() {
- manager()->OnInitComplete(GetPlayerId(), true);
-}
-
-void MediaSourcePlayerCapi::Release() {
- playing_ = false;
- StopCurrentTimeUpdateTimer();
- audio_buffer_queue_.clear();
- video_buffer_queue_.clear();
- if (player_) {
- player_unset_completed_cb(player_);
- player_unset_media_packet_video_frame_decoded_cb(player_);
- player_unprepare(player_);
- }
- manager()->OnSuspendComplete(GetPlayerId());
- if (media_packet_)
- media_packet_destroy(media_packet_);
- media_packet_ = NULL;
-}
-
-void MediaSourcePlayerCapi::OnDemuxerConfigsAvailable(
- const DemuxerConfigs& configs) {
-
- if (!player_)
- return;
- LOG(INFO) << "New width " << configs.video_size.width()
- << " height " << configs.video_size.height();
- if (GetPlayerState() > PLAYER_STATE_IDLE) {
- media_format_set_video_width(video_format_, configs.video_size.width());
- media_format_set_video_height(video_format_, configs.video_size.height());
- return;
- }
- int ret = PLAYER_ERROR_NONE;
-
- if ((configs.video_codec == kUnknownVideoCodec ||
- configs.video_codec != kCodecH264) &&
- (configs.audio_codec == kUnknownAudioCodec ||
- (configs.audio_codec != kCodecAAC &&
- configs.audio_codec != kCodecMP3))) {
- LOG(ERROR) << "Audio and Video codecs not supported for MediaSource";
- OnHandlePlayerError(PLAYER_ERROR_NOT_SUPPORTED_FILE, FROM_HERE);
- return;
- }
- int samplerate = configs.audio_sampling_rate;
- int channel = configs.audio_channels;
- width_ = configs.video_size.width();
- height_ = configs.video_size.height();
-
- ret = media_format_create(&audio_format_);
- if (ret != MEDIA_FORMAT_ERROR_NONE) {
- LOG(ERROR) << "media_format_create : 0x" << ret;
- return;
- }
-
- media_format_mimetype_e audiomimeType = MEDIA_FORMAT_MP3;
- if (configs.audio_codec == kCodecAAC)
- audiomimeType = MEDIA_FORMAT_AAC;
-
- LOG(INFO) << "samplerate: " << samplerate
- << ", channel: " << channel
- << ", audiomimeType: " << audiomimeType;
-
- media_format_set_audio_mime(audio_format_, audiomimeType);
- media_format_set_audio_channel(audio_format_, channel);
- media_format_set_audio_samplerate(audio_format_, samplerate);
-
- ret = player_set_media_stream_info(player_, PLAYER_STREAM_TYPE_AUDIO,
- audio_format_);
- if (ret != PLAYER_ERROR_NONE) {
- LOG(ERROR) << "player_set_audio_stream_info Error: " << ret;
- return;
- }
- ret = player_set_media_stream_buffer_status_cb(player_,
- PLAYER_STREAM_TYPE_AUDIO,
- OnCapiAudioBufStatusCB,
- this);
- if (ret != PLAYER_ERROR_NONE) {
- LOG(ERROR) << "player set audio buffer status cb failed :" << ret;
- return;
- }
-
- ret = media_format_create(&video_format_);
- if (ret != MEDIA_FORMAT_ERROR_NONE) {
- LOG(ERROR) << "media_format_create : 0x" << ret;
- return;
- }
-
- media_format_mimetype_e videomimeType = MEDIA_FORMAT_H264_SP;
-
- media_format_set_video_mime(video_format_, videomimeType);
- media_format_set_video_width(video_format_, width_);
- media_format_set_video_height(video_format_, height_);
-
- LOG(INFO) << "width: " << width_
- << ", height: " << height_
- << ", videomimeType: " << videomimeType;
-
- ret = player_set_media_stream_info(player_,
- PLAYER_STREAM_TYPE_VIDEO,
- video_format_);
- if (ret != PLAYER_ERROR_NONE) {
- LOG(ERROR) << "player_set_video_stream_info Error: " << ret;
- return;
- }
-
- // FIXME(Kodam): This property should be updated based on dynamic
- // resolution change
- player_set_media_stream_buffer_max_size(
- player_, PLAYER_STREAM_TYPE_VIDEO, max_size);
- player_set_media_stream_buffer_min_threshold(
- player_, PLAYER_STREAM_TYPE_VIDEO, min_threshold);
- ret = player_set_media_stream_buffer_status_cb(player_,
- PLAYER_STREAM_TYPE_VIDEO,
- OnCapiVideoBufStatusCB,
- this);
- if (ret != PLAYER_ERROR_NONE) {
- LOG(ERROR) << "player set video buffer status cb failed : 0x" << ret;
- return;
- }
-
- // Audio stream is present if sample rate is valid.
- if (samplerate > 0)
- media_type_ |= MEDIA_AUDIO_MASK;
-
- // Video stream is present if both video width and height are valid.
- if (width_ > 0 && height_ > 0)
- media_type_ |= MEDIA_VIDEO_MASK;
-
- manager()->OnMediaDataChange(GetPlayerId(), width_, height_, media_type_);
- manager()->OnReadyStateChange(
- GetPlayerId(), blink::WebMediaPlayer::ReadyStateHaveMetadata);
-
- if (GetPlayerState() == PLAYER_STATE_IDLE) {
- ret = player_prepare_async(player_, OnCapiPlayerPreparedCB, this);
- if (ret != PLAYER_ERROR_NONE) {
- LOG(ERROR) <<"player prepare failed : 0x " << ret;
- return;
- }
- }
-
- // TODO(Venu): Need to check where is the exact place for this code.
- // For make it work added this below code
- // TODO(max): We have a contradiction here.
- // To Complete preparing the capi-player, we have to get the first frame
- // But to get the first frame we have to set readyState to EnoughData,
- // even we are not ready for play(Setting the Enoughdata make HTML
- // think that player is ready for play)
- // We have to make some hack to get/set the first frame without notifying
- // to HTML.
- manager()->OnReadyStateChange(
- GetPlayerId(), blink::WebMediaPlayer::ReadyStateHaveEnoughData);
-}
-
-// Helper method that prints error occured with CAPI.
-void MediaSourcePlayerCapi::OnMediaError(MediaError error_type) {
- StopCurrentTimeUpdateTimer();
- MediaPlayerEfl::OnMediaError(error_type);
-}
-
-void MediaSourcePlayerCapi::ReadDemuxedData(
- media::DemuxerStream::Type type) {
- demuxer_->RequestDemuxerData(type);
-}
-
-void MediaSourcePlayerCapi::HandleBufferingMessage(int percent) {
- // FIXME: add code if required
- return;
-}
-
-void MediaSourcePlayerCapi::HandleUnderFlowStatus(
- media::DemuxerStream::Type type, bool underflow_status) {
- if (underflow_status) {
- if (type == media::DemuxerStream::VIDEO) {
- should_feed_video_ = underflow_status;
- LOG(INFO) << "Video Underflow " << should_feed_video_
- << " call CAPI Pause";
- } else if (type == media::DemuxerStream::AUDIO) {
- should_feed_audio_ = underflow_status;
- LOG(INFO) << "Audio Underflow " << should_feed_audio_
- << " call CAPI Pause";
- }
- if (player_prepared_) {
- task_runner_->PostTask(FROM_HERE,
- base::BindOnce(&MediaSourcePlayerCapi::Pause,
- weak_factory_.GetWeakPtr(), true));
- }
- task_runner_->PostTask(
- FROM_HERE, base::BindOnce(&MediaSourcePlayerCapi::ReadDemuxedData,
- weak_factory_.GetWeakPtr(), type));
- } else if (!underflow_status) {
- if (type == media::DemuxerStream::VIDEO) {
- should_feed_video_ = underflow_status;
- LOG(INFO) << "Video Overflow " << should_feed_video_
- << " call CAPI Play";
- } else if (type == media::DemuxerStream::AUDIO) {
- should_feed_audio_ = underflow_status;
- LOG(INFO) << "Audio Overflow " << should_feed_audio_
- << " call CAPI Play";
- }
-
- // FIXME(Kodam): Distinguish from user triggered PAUSE.
- if ((!should_feed_audio_ || eos_audio_) &&
- (!should_feed_video_ || eos_video_)) {
- task_runner_->PostTask(FROM_HERE,
- base::BindOnce(&MediaSourcePlayerCapi::Play,
- weak_factory_.GetWeakPtr()));
- }
- }
-}
-
-
-void MediaSourcePlayerCapi::OnDemuxerDataAvailable(
- base::SharedMemoryHandle foreign_memory_handle,
- const media::DemuxedBufferMetaData& meta_data) {
- if (error_occured_) {
- LOG(ERROR) << "error occured";
- return;
- }
-
- if (meta_data.status != media::DemuxerStream::kOk ||
- meta_data.end_of_stream)
- BufferMetaDataAvailable(meta_data);
-
- if (seek_state_ == MEDIA_SEEK_DEMUXER_DONE) {
- // Seek either reached to eos or buffered enough data to seek.
- if (meta_data.end_of_stream ||
- (seek_offset_ + kSeekBufferingWaitInSec) <=
- meta_data.timestamp.InSecondsF()) {
- SeekInternal();
- }
- }
-
- if (meta_data.size <= 0) {
- LOG(ERROR) << "ERROR : Size of shared memory is Zero";
- return;
- }
- ReadFromQueueIfAny(meta_data.type);
-
- if (meta_data.type == media::DemuxerStream::AUDIO && !should_feed_audio_) {
- // Why store the DecoderBuffer? we have requested for buffer
- // from demuxer but gstreamer asked to stop. So need to save
- // this buffer and use it on next |need_data| call.
- SaveDecoderBuffer(foreign_memory_handle, meta_data);
- return;
- }
- if (meta_data.type == media::DemuxerStream::VIDEO && !should_feed_video_) {
- SaveDecoderBuffer(foreign_memory_handle, meta_data);
- return;
- }
-
- // Wrapping each frame and deleting shared memory using callback
- // will not work as possibility of Gstreamer retaining frames (such as
- // 'i' frames) is high. In that case shared memory will crash. So, we
- // copy frames and release shared memory right away.
-
- base::SharedMemory shared_memory(foreign_memory_handle, false);
- if (!shared_memory.Map(meta_data.size)) {
- LOG(ERROR) << "Failed to map shared memory of size " << meta_data.size;
- return;
- }
-
- if (meta_data.type == media::DemuxerStream::AUDIO) {
- if (media_packet_create_from_external_memory(
- audio_format_, static_cast<void*>(shared_memory.memory()),
- meta_data.size, NULL, NULL, &media_packet_)
- != MEDIA_PACKET_ERROR_NONE) {
- LOG(ERROR) << "Audio media_packet_create_from_external_memory failed";
- return;
- }
- } else if (meta_data.type == media::DemuxerStream::VIDEO) {
- if (media_packet_create_from_external_memory(
- video_format_, static_cast<void*>(shared_memory.memory()),
- meta_data.size, NULL, NULL, &media_packet_)
- != MEDIA_PACKET_ERROR_NONE) {
- LOG(ERROR) << "Video media_packet_create_from_external_memory failed";
- return;
- }
- }
-
- if (media_packet_set_pts(media_packet_, meta_data.timestamp.InMilliseconds())
- != MEDIA_PACKET_ERROR_NONE) {
- LOG(ERROR) << "media_packet_set_pts failed";
- return;
- }
- if (player_push_media_stream(player_, media_packet_)
- != MEDIA_PACKET_ERROR_NONE)
- LOG(ERROR) << "player_push_media_stream failed";
-
- if (meta_data.type == media::DemuxerStream::AUDIO)
- media_format_unref(audio_format_);
- else if (meta_data.type == media::DemuxerStream::VIDEO)
- media_format_unref(video_format_);
-
- if (media_packet_)
- media_packet_destroy(media_packet_);
- media_packet_ = NULL;
-
- if (meta_data.type == media::DemuxerStream::AUDIO)
- OnReadDemuxedData(media::DemuxerStream::AUDIO);
- else if (meta_data.type == media::DemuxerStream::VIDEO)
- OnReadDemuxedData(media::DemuxerStream::VIDEO);
- return;
-}
-
-void MediaSourcePlayerCapi::BufferMetaDataAvailable(
- const media::DemuxedBufferMetaData& meta_data) {
- LOG(INFO) << __FUNCTION__ << " meta_data.type " << meta_data.type;
- if (error_occured_) {
- LOG(ERROR) << "Pipeline_ null or error occured";
- return;
- }
-
- switch (meta_data.status) {
- case media::DemuxerStream::kAborted:
- LOG(WARNING) << "[BROWSER] : DemuxerStream::kAborted, Stream type = "
- << meta_data.type;
- case media::DemuxerStream::kConfigChanged:
- if (meta_data.type == media::DemuxerStream::AUDIO)
- OnReadDemuxedData(media::DemuxerStream::AUDIO);
- else if (meta_data.type == media::DemuxerStream::VIDEO)
- OnReadDemuxedData(media::DemuxerStream::VIDEO);
- break;
-
- case media::DemuxerStream::kOk:
- if (meta_data.end_of_stream) {
- ReadFromQueueIfAny(meta_data.type);
- LOG(INFO) <<"[BROWSER] : DemuxerStream::kOk but |end_of_stream|";
- SendEosToCapi(meta_data);
- if (!playing_)
- Play();
- }
- break;
-
- default:
- NOTREACHED();
- }
-}
-
-void MediaSourcePlayerCapi::SendEosToCapi(
- const media::DemuxedBufferMetaData& meta_data) {
- if (meta_data.type == media::DemuxerStream::AUDIO) {
- if (!eos_audio_) {
- if (media_packet_create(audio_format_, NULL, NULL, &media_packet_)
- != MEDIA_PACKET_ERROR_NONE) {
- LOG(ERROR) << "Audio media_packet_create failed";
- return;
- }
- eos_audio_ = true;
- } else {
- LOG(ERROR) << "Audio EOS Already Pushed";
- return;
- }
- } else if (meta_data.type == media::DemuxerStream::VIDEO) {
- if (!eos_video_) {
- if (media_packet_create(video_format_, NULL, NULL, &media_packet_)
- != MEDIA_PACKET_ERROR_NONE) {
- LOG(ERROR) << "Video media_packet_create failed";
- return;
- }
- eos_video_ = true;
- } else {
- LOG(ERROR) << "Video EOS Already Pushed";
- return;
- }
- }
-
- if (media_packet_set_flags(media_packet_, MEDIA_PACKET_END_OF_STREAM)
- != MEDIA_PACKET_ERROR_NONE)
- LOG(ERROR) << "media_packet_set_flags failed";
-
- if (player_push_media_stream(player_, media_packet_)
- != MEDIA_PACKET_ERROR_NONE)
- LOG(ERROR) << "player_push_media_stream failed";
-
- if (meta_data.type == media::DemuxerStream::AUDIO)
- media_format_unref(audio_format_);
- else if (meta_data.type == media::DemuxerStream::VIDEO)
- media_format_unref(video_format_);
-
- if (media_packet_)
- media_packet_destroy(media_packet_);
- media_packet_ = NULL;
-}
-
-void MediaSourcePlayerCapi::ReadFromQueueIfAny(
- DemuxerStream::Type type) {
- if (error_occured_) {
- LOG(ERROR) << "error occured in capi";
- return;
- }
-
- if (type == media::DemuxerStream::AUDIO) {
- if (audio_buffer_queue_.empty() || !should_feed_audio_)
- return;
- }
-
- if (type == media::DemuxerStream::VIDEO) {
- if (video_buffer_queue_.empty() || !should_feed_video_)
- return;
- }
-
- scoped_refptr<DecoderBuffer> decoder_buffer;
-
- if (type == media::DemuxerStream::AUDIO) {
- decoder_buffer = audio_buffer_queue_.front();
- audio_buffer_queue_.pop_front();
- } else if (type == media::DemuxerStream::VIDEO) {
- decoder_buffer = video_buffer_queue_.front();
- video_buffer_queue_.pop_front();
- }
- uint64 size = static_cast<uint64>(decoder_buffer.get()->data_size());
-
- uint64 timestamp =
- static_cast<uint64>(decoder_buffer.get()->timestamp().InMilliseconds());
- if (type == media::DemuxerStream::AUDIO) {
- if (media_packet_create_from_external_memory(
- audio_format_,
- static_cast<void*>(decoder_buffer.get()->writable_data()),
- size, NULL, NULL, &media_packet_)
- != MEDIA_PACKET_ERROR_NONE) {
- LOG(ERROR) << "Audio media_packet_create_from_external_memory failed";
- return;
- }
- } else if (type == media::DemuxerStream::VIDEO) {
- if (media_packet_create_from_external_memory(
- video_format_,
- static_cast<void*>(decoder_buffer.get()->writable_data()),
- size, NULL, NULL, &media_packet_)
- != MEDIA_PACKET_ERROR_NONE) {
- LOG(ERROR) << "Video media_packet_create_from_external_memory failed";
- return;
- }
- }
-
- if (media_packet_set_pts(media_packet_, timestamp)
- != MEDIA_PACKET_ERROR_NONE) {
- LOG(ERROR) << "media_packet_set_pts failed";
- return;
- }
-
- if (player_push_media_stream(player_, media_packet_)
- != MEDIA_PACKET_ERROR_NONE)
- LOG(ERROR) << "player_push_media_stream failed";
-
- if (type == media::DemuxerStream::AUDIO)
- media_format_unref(audio_format_);
- else if (type == media::DemuxerStream::VIDEO)
- media_format_unref(video_format_);
-
- // Empty the Buffer before reading the new buffer from render process.
- if (media_packet_)
- media_packet_destroy(media_packet_);
- media_packet_ = NULL;
-
- ReadFromQueueIfAny(type);
- return;
-}
-
-void MediaSourcePlayerCapi::SaveDecoderBuffer(
- base::SharedMemoryHandle foreign_memory_handle,
- const media::DemuxedBufferMetaData& meta_data) {
- if (error_occured_) {
- LOG(ERROR) << "Error occured in capi";
- return;
- }
-
- base::SharedMemory shared_memory(foreign_memory_handle, false);
- if (!shared_memory.Map(meta_data.size)) {
- LOG(ERROR) << "Failed to map shared memory of size " << meta_data.size;
- return;
- }
- scoped_refptr<DecoderBuffer> buffer;
- buffer = DecoderBuffer::CopyFrom(static_cast<const uint8*> (
- shared_memory.memory()), meta_data.size);
-
- if (!buffer.get()) {
- LOG(ERROR) << "DecoderBuffer::CopyFrom failed";
- return;
- }
-
- buffer->set_timestamp(meta_data.timestamp);
- buffer->set_duration(meta_data.time_duration);
-
- if (meta_data.type == media::DemuxerStream::AUDIO)
- audio_buffer_queue_.push_back(buffer);
- else if (meta_data.type == media::DemuxerStream::VIDEO)
- video_buffer_queue_.push_back(buffer);
-}
-
-void MediaSourcePlayerCapi::OnPrepareComplete() {
- task_runner_->PostTask(FROM_HERE,
- base::BindOnce(&MediaSourcePlayerCapi::PrepareComplete,
- weak_factory_.GetWeakPtr()));
-}
-
-void MediaSourcePlayerCapi::OnPlaybackComplete() {
- task_runner_->PostTask(
- FROM_HERE, base::BindOnce(&MediaSourcePlayerCapi::PlaybackComplete,
- weak_factory_.GetWeakPtr()));
-}
-
-void MediaSourcePlayerCapi::OnSeekComplete() {
- task_runner_->PostTask(FROM_HERE,
- base::BindOnce(&MediaSourcePlayerCapi::SeekComplete,
- weak_factory_.GetWeakPtr()));
-}
-
-void MediaSourcePlayerCapi::OnHandleBufferingMessage(int percent) {
- task_runner_->PostTask(
- FROM_HERE, base::BindOnce(&MediaSourcePlayerCapi::HandleBufferingMessage,
- weak_factory_.GetWeakPtr(), percent));
-}
-
-void MediaSourcePlayerCapi::OnReadDemuxedData(
- media::DemuxerStream::Type type) {
- task_runner_->PostTask(FROM_HERE,
- base::BindOnce(&MediaSourcePlayerCapi::ReadDemuxedData,
- weak_factory_.GetWeakPtr(), type));
-}
-
-void MediaSourcePlayerCapi::OnUpdateDataStatus(
- media::DemuxerStream::Type type, bool underflow_status) {
- task_runner_->PostTask(
- FROM_HERE,
- base::BindOnce(&MediaSourcePlayerCapi::HandleUnderFlowStatus,
- weak_factory_.GetWeakPtr(), type, underflow_status));
-}
-
-void MediaSourcePlayerCapi::OnHandlePlayerError(
- int player_error_code, const tracked_objects::Location& location) {
-
- LOG(ERROR) << GetErrorString(player_error_code) << " from "
- << location.ToString();
-
- OnMediaError(GetMediaError(player_error_code));
-}
-
-} // namespace media
+++ /dev/null
-// Copyright 2015 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_BASE_TIZEN_MEDIA_SOURCE_PLAYER_CAPI_H_
-#define MEDIA_BASE_TIZEN_MEDIA_SOURCE_PLAYER_CAPI_H_
-
-#include <player.h>
-
-#include "base/cancelable_callback.h"
-#include "base/threading/thread.h"
-#include "base/time/default_tick_clock.h"
-#include "base/timer/timer.h"
-#include "media/base/decoder_buffer.h"
-#include "media/base/efl/demuxer_efl.h"
-#include "media/base/efl/media_player_efl.h"
-#include "media/base/efl/media_player_util_efl.h"
-#include "third_party/blink/public/platform/WebMediaPlayer.h"
-
-namespace media {
-
-// This class handles media source extensions for CAPI port.
-class MEDIA_EXPORT MediaSourcePlayerCapi : public MediaPlayerEfl,
- public DemuxerEflClient {
- public:
- // Constructs a player with the given ID and demuxer. |manager| must outlive
- // the lifetime of this object.
- MediaSourcePlayerCapi(int player_id,
- std::unique_ptr<DemuxerEfl> demuxer,
- MediaPlayerManager* manager);
- MediaSourcePlayerCapi(const MediaSourcePlayerCapi&) = delete;
- MediaSourcePlayerCapi& operator=(const MediaSourcePlayerCapi&) = delete;
- ~MediaSourcePlayerCapi() override;
-
- MediaSourcePlayerCapi(const MediaSourcePlayerCapi&) = delete;
- MediaSourcePlayerCapi& operator=(const MediaSourcePlayerCapi&) = delete;
-
- // MediaPlayerEfl implementation.
- void Play() override;
- void Pause(bool is_media_related_action) override;
- void SetRate(double rate) override;
- void Seek(const double time) override;
- void SetVolume(double volume) override;
- double GetCurrentTime() override;
- void Initialize() override;
-
- // DemuxerEflClient implementation.
- void OnDemuxerConfigsAvailable(const DemuxerConfigs& params) override;
- void OnDemuxerDataAvailable(
- base::SharedMemoryHandle foreign_memory_handle,
- const media::DemuxedBufferMetaData& meta_data) override;
- void OnDemuxerSeekDone(
- const base::TimeDelta& actual_browser_seek_time) override;
- void OnDemuxerDurationChanged(base::TimeDelta duration) override;
-
- // To handle CAPI callbacks.
- void OnReadDemuxedData(media::DemuxerStream::Type type);
- void OnUpdateDataStatus(media::DemuxerStream::Type type,
- bool underflow_status);
- void OnSeekComplete();
- void OnHandleBufferingMessage(int percent);
- void OnPlaybackComplete();
- void OnPrepareComplete();
- void OnHandlePlayerError(int player_error_code,
- const tracked_objects::Location& loc);
-
- void OnMediaPacketUpdated(media_packet_h packet);
-
- protected:
- void Release() override;
- void OnMediaError(MediaError error_type) override;
-
- private:
- player_state_e GetPlayerState();
- void PrepareComplete();
-
- // For internal seeks.
- void SeekInternal();
- void UpdateSeekState(MediaSeekState state);
- void SeekComplete();
-
- void BufferMetaDataAvailable(const media::DemuxedBufferMetaData& meta_data);
- void ReadDemuxedData(media::DemuxerStream::Type type);
- void HandleBufferingMessage(int percent);
-
- // To handle buffer underflow CB.
- void HandleUnderFlowStatus(media::DemuxerStream::Type type,
- bool underflow_status);
-
- void PlaybackComplete();
- void SendEosToCapi(const media::DemuxedBufferMetaData& meta_data);
-
- // |current_time_update_timer_| related
- void OnCurrentTimeUpdateTimerFired();
- void StartCurrentTimeUpdateTimer();
- void StopCurrentTimeUpdateTimer();
-
- void ReadFromQueueIfAny(DemuxerStream::Type type);
- void SaveDecoderBuffer(base::SharedMemoryHandle foreign_memory_handle,
- const media::DemuxedBufferMetaData& meta_data);
-
- std::unique_ptr<DemuxerEfl> demuxer_;
- const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
-
- // Weak pointer passed to media decoder jobs for callbacks.
- base::WeakPtrFactory<MediaSourcePlayerCapi> weak_this_;
-
- player_h player_;
- int media_type_;
- double duration_;
- double play_rate_;
-
- bool player_prepared_;
- bool playing_;
- bool is_end_reached_;
- bool eos_audio_;
- bool eos_video_;
- bool error_occured_;
-
- // Will allow to listen to |prepare-xid| message only once.
- bool should_feed_audio_;
- bool should_feed_video_;
-
- double seek_offset_;
- MediaSeekState seek_state_;
-
- media_packet_h media_packet_;
-
- // FIXME(Venu): Make them a smart pointer to avoid leak.
- media_format_h audio_format_;
- media_format_h video_format_;
-
- base::RepeatingTimer current_time_update_timer_;
-
- std::deque<scoped_refptr<DecoderBuffer> > audio_buffer_queue_;
- std::deque<scoped_refptr<DecoderBuffer> > video_buffer_queue_;
-
- base::WeakPtrFactory<MediaSourcePlayerCapi> weak_factory_;
-};
-
-} // namespace media
-
-#endif // MEDIA_BASE_TIZEN_MEDIA_SOURCE_PLAYER_CAPI_H_
+++ /dev/null
-// Copyright 2015 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.
-
-#include "media/base/tizen/webaudio_decoder_browser_capi.h"
-
-#include "base/bind.h"
-#include "base/logging.h"
-#include "media/base/efl/webaudio_media_codec_info_efl.h"
-
-namespace {
-
-const int kChannelCount = 2;
-
-const int kSampleRate = 44100;
-
-struct ErrorList {
- player_error_e error_code;
- std::string error_message;
-};
-
-// FIXME: Move to common place
-const struct ErrorList errorlist[] = {
- {PLAYER_ERROR_OUT_OF_MEMORY, "PLAYER_ERROR_OUT_OF_MEMORY"},
- {PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER"},
- {PLAYER_ERROR_NO_SUCH_FILE, "PLAYER_ERROR_NO_SUCH_FILE"},
- {PLAYER_ERROR_INVALID_OPERATION, "PLAYER_ERROR_INVALID_OPERATION"},
- {PLAYER_ERROR_FILE_NO_SPACE_ON_DEVICE,
- "PLAYER_ERROR_FILE_NO_SPACE_ON_DEVICE"},
- {PLAYER_ERROR_FEATURE_NOT_SUPPORTED_ON_DEVICE,
- "PLAYER_ERROR_FEATURE_NOT_SUPPORTED_ON_DEVICE"},
- {PLAYER_ERROR_SEEK_FAILED, "PLAYER_ERROR_SEEK_FAILED"},
- {PLAYER_ERROR_INVALID_STATE, "PLAYER_ERROR_INVALID_STATE"},
- {PLAYER_ERROR_NOT_SUPPORTED_FILE, "PLAYER_ERROR_NOT_SUPPORTED_FILE"},
- {PLAYER_ERROR_INVALID_URI, "PLAYER_ERROR_INVALID_URI"},
- {PLAYER_ERROR_SOUND_POLICY, "PLAYER_ERROR_SOUND_POLICY"},
- {PLAYER_ERROR_CONNECTION_FAILED, "PLAYER_ERROR_CONNECTION_FAILED"},
- {PLAYER_ERROR_VIDEO_CAPTURE_FAILED, "PLAYER_ERROR_VIDEO_CAPTURE_FAILED"},
- {PLAYER_ERROR_DRM_EXPIRED, "PLAYER_ERROR_DRM_EXPIRED"},
- {PLAYER_ERROR_DRM_NO_LICENSE, "PLAYER_ERROR_DRM_NO_LICENSE"},
- {PLAYER_ERROR_DRM_FUTURE_USE, "PLAYER_ERROR_DRM_FUTURE_USE"},
- {PLAYER_ERROR_DRM_NOT_PERMITTED, "PLAYER_ERROR_DRM_NOT_PERMITTED"},
- {PLAYER_ERROR_RESOURCE_LIMIT, "PLAYER_ERROR_RESOURCE_LIMIT"},
- {PLAYER_ERROR_PERMISSION_DENIED, "PLAYER_ERROR_PERMISSION_DENIED"}};
-
-const int ERROR_MAX = sizeof(errorlist) / sizeof(errorlist[0]);
-
-static void PlayerPreparedCb(void* data) {
- media::AudioDecoderCapi* player =
- static_cast<media::AudioDecoderCapi*>(data);
- if (!player)
- return;
- player->OnPlayerPrepared();
-}
-
-static void PlayerDecodedBufferReadyCb(player_audio_raw_data_s* audio_data,
- void* data) {
- media::AudioDecoderCapi* player =
- static_cast<media::AudioDecoderCapi*>(data);
- if (!player)
- return;
- player->OnPlayerDecodedBufferReady(audio_data);
-}
-
-static void PlayerEosCb(void* data) {
- media::AudioDecoderCapi* player =
- static_cast<media::AudioDecoderCapi*>(data);
- if (!player)
- return;
- player->OnPlayerEos();
-}
-
-static void PlayerErrorCb(int error_code, void* data) {
- media::AudioDecoderCapi* player =
- static_cast<media::AudioDecoderCapi*>(data);
- if (!player)
- return;
- player->OnPlayerError(error_code, "PlayerErrorCb");
-}
-
-} // namespace
-
-namespace media {
-
-struct WAPCMdata{
- uint8_t* data_;
- int rate_;
- int size_;
- int channel_mask_;
- WAPCMdata(int rate, int size, int channel_mask)
- : data_(NULL),
- rate_(rate),
- size_(size),
- channel_mask_(channel_mask) {}
-};
-
-AudioDecoderCapi::AudioDecoderCapi(
- base::FileDescriptor pcm_output,
- uint8_t* data,
- uint32_t data_size)
- : decoder_thread_("CAPIAudioDecoder"),
- player_(NULL),
- pcm_output_(pcm_output.fd),
- data_size_(data_size),
- encoded_data_(data),
- is_new_request_(true),
- is_running_(true) {
-}
-
-AudioDecoderCapi::~AudioDecoderCapi() {
- if (player_) {
- player_unset_error_cb(player_);
- player_unset_completed_cb(player_);
- player_unprepare(player_);
- player_destroy(player_);
- }
- player_ = NULL;
- if (decoder_thread_.IsRunning())
- decoder_thread_.Stop();
-
- close(pcm_output_);
-}
-
-void AudioDecoderCapi::InitializePlayer() {
- int error = player_create(&player_);
- if (error != PLAYER_ERROR_NONE) {
- PlayerError(error, "player_create");
- return;
- }
-
- player_set_completed_cb(player_, PlayerEosCb, this);
- player_set_error_cb(player_, PlayerErrorCb, this);
- player_set_pcm_extraction_mode(player_, false,
- PlayerDecodedBufferReadyCb, this);
-
- player_set_pcm_spec(player_, "F32LE", kSampleRate, kChannelCount);
-
- error = player_set_memory_buffer(player_, encoded_data_, data_size_);
- if (error != PLAYER_ERROR_NONE) {
- PlayerError(error, "player_set_memory_buffer");
- return;
- }
-
- error = player_prepare_async(player_, PlayerPreparedCb, this);
- if (error != PLAYER_ERROR_NONE) {
- PlayerError(error, "player_prepare_async");
- return;
- }
-}
-
-void AudioDecoderCapi::StartDecodeProcess() {
- InitializePlayer();
-}
-
-void AudioDecoderCapi::PlayerPrepared() {
- int error = player_start(player_);
- if (error != PLAYER_ERROR_NONE)
- PlayerError(error, "player_start()");
-}
-
-static void SendData(const int pcm_out, WAPCMdata* audio_data) {
- if (!audio_data)
- return;
- uint8_t* data = audio_data->data_;
- int data_size = audio_data->size_;
- while (data_size > 0) {
- int bytes_to_write = (data_size >= PIPE_BUF) ? PIPE_BUF : data_size;
- media::WebAudioMediaDataInfoEfl data_info(audio_data->channel_mask_,
- bytes_to_write);
- HANDLE_EINTR(write(pcm_out, &data_info, sizeof(data_info)));
- ssize_t bytes_written = HANDLE_EINTR(write(pcm_out, data, bytes_to_write));
- if (bytes_written == -1) {
- LOG(ERROR) << "Write Failed\n";
- break;
- }
- data_size -= bytes_written;
- data += bytes_written;
- }
-}
-
-void AudioDecoderCapi::PlayerDecodedBufferReady(WAPCMdata* audio_data) {
- if (audio_data->size_ <= 0) {
- LOG(ERROR) << "Decoded buffer size is invalid";
- return;
- }
-
- if (is_new_request_) {
- // TODO: How to handle more than 2 channels
- media::WebAudioMediaCodecInfoEfl info(
- static_cast<unsigned long>(kChannelCount),
- static_cast<unsigned long>(audio_data->rate_),
- static_cast<unsigned long>((audio_data->size_ / sizeof(float))));
-
- HANDLE_EINTR(write(pcm_output_, &info, sizeof(info)));
- is_new_request_ = false;
- }
- SendData(pcm_output_, audio_data);
- delete[] (audio_data->data_);
- delete(audio_data);
-}
-
-void AudioDecoderCapi::PlayerEos() {
- is_running_ = false;
-}
-
-void AudioDecoderCapi::PlayerError(int err, char const* from) {
- for (int index = 0; index < ERROR_MAX; ++index) {
- if (errorlist[index].error_code == err) {
- LOG(ERROR) << "Stoping decoding due to error code : " << err
- << " Error message : " << errorlist[index].error_message
- << " from " << from;
- break;
- }
- }
-
- is_running_ = false;
-}
-
-void AudioDecoderCapi::OnPlayerPrepared() {
- decoder_thread_.task_runner()->PostTask(
- FROM_HERE, base::BindOnce(&AudioDecoderCapi::PlayerPrepared,
- base::Unretained(this)));
-}
-
-void AudioDecoderCapi::OnPlayerDecodedBufferReady(
- player_audio_raw_data_s* audio_data) {
- DCHECK(!decoder_thread_.IsRunning());
-
- // The buffer is resued by CAPI in next iteration,
- // this leaves junk data in it hence making local copy.
- WAPCMdata* localdata = new WAPCMdata(audio_data->rate,
- audio_data->size,
- audio_data->channel_mask);
- localdata->data_ = new uint8_t[localdata->size_];
- memcpy(localdata->data_, audio_data->data, localdata->size_);
-
- decoder_thread_.task_runner()->PostTask(
- FROM_HERE, base::BindOnce(&AudioDecoderCapi::PlayerDecodedBufferReady,
- base::Unretained(this), localdata));
-}
-
-void AudioDecoderCapi::OnPlayerEos() {
- decoder_thread_.task_runner()->PostTask(
- FROM_HERE,
- base::BindOnce(&AudioDecoderCapi::PlayerEos, base::Unretained(this)));
-}
-
-void AudioDecoderCapi::OnPlayerError(int error_code, const char* msg) {
- decoder_thread_.task_runner()->PostTask(
- FROM_HERE, base::BindOnce(&AudioDecoderCapi::PlayerError,
- base::Unretained(this), error_code, msg));
-}
-
-void AudioDecoderCapi::OnStartDecodeProcess() {
- if (!decoder_thread_.IsRunning() && !decoder_thread_.Start()) {
- LOG(ERROR) << "Decoder thread start failed";
- return;
- }
-
- decoder_thread_.message_loop()->PostTask(
- FROM_HERE, base::BindOnce(&AudioDecoderCapi::StartDecodeProcess,
- base::Unretained(this)));
-
- // TODO(kodam): Need to refactor this class not to use usleep(10) in here.
- while (is_running_)
- usleep(10);
-}
-
-// WebAudioDecoderCapi class
-WebAudioDecoder* WebAudioDecoder::GetWebAudioDecoder(){
- return WebAudioDecoderCapi::GetInstance();
-}
-
-// static
-WebAudioDecoderCapi* WebAudioDecoderCapi::GetInstance() {
- return base::Singleton<WebAudioDecoderCapi>::get();
-}
-
-WebAudioDecoderCapi::WebAudioDecoderCapi()
- : capi_thread_("CapiThread") {
-}
-
-WebAudioDecoderCapi::~WebAudioDecoderCapi() {
-}
-
-void WebAudioDecoderCapi::DecodeUsingCAPI(
- base::SharedMemoryHandle foreign_memory_handle,
- base::FileDescriptor pcm_output,
- uint32_t data_size) {
- base::SharedMemory shared_memory(foreign_memory_handle, false);
- if (!shared_memory.Map(data_size)) {
- LOG(ERROR) << "Failed to map shared memory for size " << data_size;
- return;
- }
-
- // This will execute until decoding is done
- AudioDecoderCapi capi_Decoder(pcm_output,
- static_cast<uint8_t*>(shared_memory.memory()),
- data_size);
- capi_Decoder.OnStartDecodeProcess();
-}
-
-void WebAudioDecoderCapi::EncodedDataReceived(
- base::SharedMemoryHandle memory_handle,
- base::FileDescriptor pcm_output,
- uint32_t data_size) {
- if (!capi_thread_.IsRunning() && !capi_thread_.Start()) {
- LOG(ERROR) << "Starting capi thread failed";
- return;
- }
-
- capi_thread_.message_loop()->PostTask(
- FROM_HERE, base::BindOnce(&WebAudioDecoderCapi::DecodeUsingCAPI,
- base::Unretained(this), memory_handle,
- pcm_output, data_size));
-}
-
-} // namespace media
+++ /dev/null
-// Copyright 2015 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_BASE_TIZEN_WEBAUDIO_DECODER_BROWSER_CAPI_H_
-#define MEDIA_BASE_TIZEN_WEBAUDIO_DECODER_BROWSER_CAPI_H_
-
-#include <player.h>
-#include <player_internal.h>
-
-#include "base/memory/singleton.h"
-#include "base/memory/shared_memory.h"
-#include "base/threading/thread.h"
-#include "media/base/efl/webaudio_decoder_efl.h"
-#include "media/base/media_export.h"
-
-namespace media {
-
-struct WAPCMdata;
-
-// WebAudioDecoderCapi class
-class MEDIA_EXPORT WebAudioDecoderCapi : public WebAudioDecoder {
- public:
- static WebAudioDecoderCapi* GetInstance();
- virtual ~WebAudioDecoderCapi();
-
- WebAudioDecoderCapi(const WebAudioDecoderCapi&) = delete;
- WebAudioDecoderCapi& operator=(const WebAudioDecoderCapi&) = delete;
-
- // media::WebAudioDecoder implementation.
- void EncodedDataReceived(base::SharedMemoryHandle memory_handle,
- base::FileDescriptor pcm_output,
- uint32_t data_size) override;
-
- private:
- friend struct base::DefaultSingletonTraits<WebAudioDecoderCapi>;
- WebAudioDecoderCapi();
- void DecodeUsingCAPI(base::SharedMemoryHandle foreign_memory_handle,
- base::FileDescriptor pcm_output,
- uint32_t data_size);
-
- base::Thread capi_thread_;
-};
-
-class AudioDecoderCapi {
- public:
- AudioDecoderCapi(base::FileDescriptor pcm_output, uint8_t* data,
- uint32_t data_size);
- virtual ~AudioDecoderCapi();
- void OnPlayerPrepared();
- void OnPlayerDecodedBufferReady(player_audio_raw_data_s* pcm_data);
- void OnPlayerEos();
- void OnPlayerError(int error_code, const char* msg);
- void OnStartDecodeProcess();
-
- private:
- void InitializePlayer();
- void StartDecodeProcess();
-
- void PlayerPrepared();
- void PlayerDecodedBufferReady(WAPCMdata* pcm_data);
- void PlayerEos();
- void PlayerError(int error_code, const char* msg);
-
- private:
- base::Thread decoder_thread_;
-
- // CAPI player handle.
- player_h player_;
-
- // The audio file information and decoded pcm data are written to
- // this file descriptor. We take ownership of this descriptor.
- int pcm_output_;
-
- // The length of the encoded data.
- uint32_t data_size_;
-
- // Encoded audio data.
- uint8_t* encoded_data_;
-
- bool is_new_request_;
- bool is_running_;
-};
-
-} // namespace media
-
-#endif // MEDIA_BASE_TIZEN_WEBAUDIO_DECODER_BROWSER_CAPI_H_
external_media_efl_deps += [ "//tizen_src/chromium_impl/ui/ozone:ozone_efl" ]
}
-if (tizen_multimedia_support) {
- external_media_efl_deps += [
- "//tizen_src/build:capi-media-audio-io",
- "//tizen_src/build:capi-media-camera",
- "//tizen_src/build:capi-media-player",
- "//tizen_src/build:ecore",
- "//tizen_src/build:libcapi-media-audio-io",
- "//tizen_src/build:libcapi-media-camera",
- "//tizen_src/build:libcapi-media-player",
- "//tizen_src/build:libecore",
- "//tizen_src/build:mm_player",
- ]
-
- if (!use_wayland) {
- external_media_efl_deps += [
- "//tizen_src/build:ecore-x",
- "//tizen_src/build:libecore-x",
- "//ui/gl:gl",
- ]
- } else {
- external_media_efl_deps += [ "//tizen_src/build:ecore-wayland" ]
- external_media_efl_deps += [ "//tizen_src/build:libecore-wayland" ]
- }
-
- if (is_tizen) {
- external_media_efl_deps += [ "//tizen_src/build:capi-system-device" ]
- external_media_efl_deps += [ "//tizen_src/build:libcapi-system-device" ]
- }
-
- external_media_efl_sources += [
- "audio/tizen/audio_manager_capi.cc",
- "audio/tizen/audio_manager_capi.h",
- "audio/tizen/audio_manager_tizen.cc",
- "audio/tizen/capi_audio_input.cc",
- "audio/tizen/capi_audio_input.h",
- "audio/tizen/capi_audio_output.cc",
- "audio/tizen/capi_audio_output.h",
- "audio/tizen/capi_util.cc",
- "audio/tizen/capi_util.h",
- "base/efl/demuxer_efl.h",
- "base/efl/demuxer_stream_player_params_efl.cc",
- "base/efl/demuxer_stream_player_params_efl.h",
- "base/efl/media_player_efl.cc",
- "base/efl/media_player_efl.h",
- "base/efl/media_player_manager_efl.h",
- "base/efl/media_player_util_efl.cc",
- "base/efl/media_player_util_efl.h",
- "base/efl/webaudio_decoder_efl.h",
- "base/efl/webaudio_media_codec_info_efl.h",
- "base/tizen/media_player_bridge_capi.cc",
- "base/tizen/media_player_bridge_capi.h",
- "base/tizen/media_source_player_capi.cc",
- "base/tizen/media_source_player_capi.h",
- "base/tizen/webaudio_decoder_browser_capi.cc",
- "base/tizen/webaudio_decoder_browser_capi.h",
- "capture/video/tizen/video_capture_device_factory_tizen.cc",
- "capture/video/tizen/video_capture_device_factory_tizen.h",
- "capture/video/tizen/video_capture_device_tizen.cc",
- "capture/video/tizen/video_capture_device_tizen.h",
- ]
-
- external_exclude_media_efl_sources += [
- "audio/linux/audio_manager_linux.cc",
- "capture/video/linux/video_capture_device_factory_linux.cc",
- "capture/video/linux/video_capture_device_factory_linux.h",
- "capture/video/linux/video_capture_device_linux.cc",
- "capture/video/linux/video_capture_device_linux.h",
- ]
-
- external_media_efl_config += [ ":media_efl_config" ]
-}
-
if (tizen_multimedia) {
external_media_video_decode_config += [
"//tizen_src/build:esplusplayer",
#include "ipc_message_start_ewk.h"
#include "net/url_request/url_request_context_getter.h"
-#if defined(TIZEN_MULTIMEDIA_SUPPORT)
-#include "media/base/efl/webaudio_decoder_efl.h"
-#endif
-
using content::BrowserThread;
using web_contents_utils::WebContentsFromFrameID;
using web_contents_utils::WebViewFromWebContents;
bool RenderMessageFilterEfl::OnMessageReceived(const IPC::Message& message) {
bool handled = true;
IPC_BEGIN_MESSAGE_MAP(RenderMessageFilterEfl, message)
- IPC_MESSAGE_HANDLER(EwkHostMsg_DecideNavigationPolicy,
+ IPC_MESSAGE_HANDLER(EwkHostMsg_DecideNavigationPolicy,
OnDecideNavigationPolicy)
-#if defined(TIZEN_MULTIMEDIA_SUPPORT)
- IPC_MESSAGE_HANDLER(EflViewHostMsg_WebAudioDecode, OnWebAudioDecode)
-#endif
- IPC_MESSAGE_UNHANDLED(handled = false)
+ IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
return handled;
}
->InvokePolicyNavigationCallback(params, handled);
}
}
-
-#if defined(TIZEN_MULTIMEDIA_SUPPORT)
-void RenderMessageFilterEfl::OnWebAudioDecode(
- base::SharedMemoryHandle encoded_data_handle,
- base::FileDescriptor pcm_output,
- uint32_t data_size) {
- media::WebAudioDecoder::GetWebAudioDecoder()->EncodedDataReceived(
- encoded_data_handle, pcm_output, data_size);
-}
-#endif
#include "third_party/blink/public/web/web_navigation_type.h"
#include "url/gurl.h"
-#if defined(TIZEN_MULTIMEDIA_SUPPORT)
-#include "base/file_descriptor_posix.h"
-#include "base/memory/shared_memory.h"
-#endif
-
struct NavigationPolicyParams;
namespace net {
void OnReceivedHitTestData(int view, const _Ewk_Hit_Test& hit_test_data,
const NodeAttributesMap& node_attributes);
-#if defined(TIZEN_MULTIMEDIA_SUPPORT)
- void OnWebAudioDecode(base::SharedMemoryHandle encoded_data_handle,
- base::FileDescriptor pcm_output,
- uint32_t data_size);
-#endif
-
int render_process_id_;
};
-
#endif
if (IsDesktopProfile())
p_command_line->AppendSwitch(switches::kDisableES3GLContext);
-#if defined(TIZEN_MULTIMEDIA_SUPPORT) && defined(ENABLE_WEBRTC)
- p_command_line->AppendSwitch(switches::kEnableWebRtcHWH264Encoding);
-#endif
-
#if BUILDFLAG(IS_TIZEN)
// For optimizing discardable memory. [limit:MB, delay:ms]
if (!p_command_line->HasSwitch(switches::kDiscardableMemoryLimit))
projects / platform / framework / web / chromium-efl.git / commitdiff