extern "C" {
#endif
-/**
- * @brief Player app id, version, type information
- */
-typedef struct {
- /**
- * @description App id for controlling resource.
- */
- char* id;
- /**
- * @description When there is playback market issue, KPI logger will
- * send the version.
- */
- char* version;
- /**
- * @description RunningApps.InformationTicker will use this type to show
- * stream information. ex) "MSE", "HTML5", etc..
- */
- char* type;
-} TrackRendererAppInfo;
-
/**
* @brief
*/
*/
int trackrenderer_get_playing_time(TrackRendererHandle handle,
uint64_t* time_millisecond);
-/**
- * @brief Get dropped frame counts in videosink
- * @description In this function trackrenderer get currently dropped frames in
- * sink.
- * @param [in] handle : trackrenderer handle ptr.
- * @param [out] counts : dropped counts
- * @return Return 0 if trackrenderer successfully get frame counts.
- * Otherwise -1.
- * @pre The trackrenderer must be at least created and set up.
- * trackrenderer_create()
- * trackrenderer_prepare()
- * @post None
- * @exception None.
- * @version 2.0
- * @remark None
- */
-int trackrenderer_get_dropped_frames(TrackRendererHandle handle, void* counts);
/**
* @brief Flush buffers for a trackrenderer.
*/
void trackrenderer_get_display_mode(TrackRendererHandle handle,
TrackRendererDisplayMode* mode);
-
-/**
- * @brief Set app id to resource manager
- * @description In this fuction trackrenderer set app id to resource
- * manager. In future resource manager will control the
- * rendering resources using this app id.
- * @param [in] handle : trackrenderer handle ptr.
- * @param [in] app_id : application id
- * @pre None
- * @post None
- * @exception None
- */
-void trackrenderer_set_app_id(TrackRendererHandle handle, const char* app_id);
-
-/**
- * @brief Set App id to player for resource manager
- * @param [in] handle : trackrenderer handle ptr.
- * @param [in] app_info : application id, version, type.
- * @return @c true on success, otherwise @c false.
- * @pre The trackrenderer must be at least created.
- * trackrenderer_create()
- * @post None
- * @exception None
- * @version 2.0
- */
-void trackrenderer_set_app_info(TrackRendererHandle handle,
- const TrackRendererAppInfo* app_info);
-
/**
* @brief Set mute on off the audio sound.
* @description In this function trackrenderer can set audio sound on off
*/
int trackrenderer_get_volume(TrackRendererHandle handle, int* volume);
-/**
- * @brief Provided api for rendering a video frame which is holded by
- * video frame peek mode.
- * @param [in] handle : trackrenderer handle ptr.
- * @return Return 0 if no problem.
- * @pre The trackrenderer must be at least created and set up.
- * trackrenderer_create()
- * trackrenderer_prepare() or after trackrenderer_seekdone_cb() is
- * called.
- * @post None
- * @version 2.0
- * @exception None
- * @remark esplusplayer_set_video_frame_peek_mode().
- */
-int trackrenderer_render_video_frame(TrackRendererHandle handle);
-
/* CALL back*/
/**
+++ /dev/null
-//
-// @ Copyright [2018] <S/W Platform, Visual Display, Samsung Electronics>
-//
-
-#ifndef __PLUSPLAYER_TRACKRENDERER_CORE_APPINFO_H__
-#define __PLUSPLAYER_TRACKRENDERER_CORE_APPINFO_H__
-
-namespace plusplayer {
-
-namespace trackrenderer {
-
-/**
-* @brief Player app information.
-*/
-struct PlayerAppInfo {
- std::string id; /**< App id */
- std::string version; /**< App version */
- std::string type; /**< App type. ex)"MSE", "HTML5", etc.. */
-};
-
-} // namespace trackrenderer
-
-} // namespace plusplayer
-
-#endif // __PLUSPLAYER_TRACKRENDERER_CORE_APPINFO_H__
\ No newline at end of file
bool Seek(uint64_t time_millisecond, double playback_rate, bool audio_mute);
bool SetPlaybackRate(double playback_rate, bool audio_mute);
bool GetPlayingTime(uint64_t* curtime_in_msec);
- bool GetDroppedFrames(void* frame_counts);
bool Deactivate(TrackType type);
bool Activate(TrackType type, const Track& track);
bool SubmitPacket(const DecoderInputBufferPtr& data,
void GetAttribute(const Attribute& attr, boost::any* value);
void SetConfig(const std::string, const boost::any& value);
State GetState() { return state_; }
- void SetAppId(const std::string& app_id);
- void SetAppInfo(const PlayerAppInfo& app_info);
void FlushAppsrc(TrackType type);
void SetVideoFrameBufferType(DecodedVideoFrameBufferType type) {
decoded_buffer_type_ = type;
}
- bool RenderVideoFrame();
private:
enum class Elements {
static GstPadProbeReturn GstSrcPadProbeIdleCb_(GstPad* pad,
GstPadProbeInfo* info,
gpointer userdata);
- static GstPadProbeReturn GstPadProbeVideoPeekBlockCb_(GstPad* pad,
- GstPadProbeInfo* info,
- gpointer userdata);
static GstPadProbeReturn GstPadProbeCapsEventCb_(GstPad* pad,
GstPadProbeInfo* info,
gpointer userdata);
bool SetAccurateSeekMode_(const boost::any& value);
bool SetLowLatencyMode_(const boost::any& value);
bool SetWindowStandAloneMode_(const boost::any& value);
- bool SetVideoFramePeekMode_(const boost::any& value);
void GstElementLowLatency_(const TrackType& type);
void CreateTbmBufferManager_(const Track* track);
- void SetSequentialMode_(const std::string& app_id);
void GetResolutionInfo_(EventMsg* event_msg);
bool SetUnlimitedMaxBufferMode_(const boost::any& value);
bool SetVideoPreDisplayMode_(const boost::any& value);
bool SetStartRenderingTime_(const boost::any& value);
- bool SetFmmMode_(const boost::any& value);
void SetVideoQualityInfo_();
void CompleteSeeking_(void);
bool HasSubtitleOnly_() const;
bool is_accurate_seek_ = false;
bool is_async_done_ = false;
bool window_stand_alone_mode_ = false;
- bool is_video_frame_peek_ = false;
std::uint32_t low_latency_mode_ = 0;
bool unlimited_max_buffer_mode_ = 0;
bool video_pre_display_mode_ = false;
- bool fmm_mode_ = false;
RenderingStartTime rendering_start_time_;
int volume_ = kVolumeNone;
uint64_t last_position_ = 0;
DecodedVideoFrameBufferType::kNone;
bool is_audioactivated_ = true;
std::unique_ptr<TbmBufferManager> tbm_buffer_manager_;
- int use_seq_mode_ = 0;
double playback_rate_ = kDefaultPlaybackRate;
SubState target_substate_ = SubState::kUnknown;
constexpr char ConfigNameAccurateSeekMode[] = "accurate-seek-mode";
constexpr char ConfigNameLowLatencyMode[] = "low-latency-mode";
constexpr char ConfigNameWindowStandAloneMode[] = "window-stand-alone-mode";
-constexpr char ConfigNameVideoFramePeekMode[] = "video-frame-peek-mode";
constexpr char ConfigNameUnlimitedMaxBufferMode[] = "unlimited-max-buffer-mode";
constexpr char ConfigNameVideoPreDisplayMode[] = "video-pre-display-mode";
constexpr char ConfigNameStartRenderingTime[] = "start-rendering-time";
-constexpr char ConfigNameFmmMode[] = "fmm-mode";
struct TrackRendererAttrInfo {
const ValueType value_type;
{ConfigNameAccurateSeekMode, ValueType::kUInt32},
{ConfigNameLowLatencyMode, ValueType::kUInt32},
{ConfigNameWindowStandAloneMode, ValueType::kUInt32},
- {ConfigNameVideoFramePeekMode, ValueType::kUInt32},
{ConfigNameUnlimitedMaxBufferMode, ValueType::kUInt32},
{ConfigNameVideoPreDisplayMode, ValueType::kUInt32},
- {ConfigNameStartRenderingTime, ValueType::kUInt64},
- {ConfigNameFmmMode, ValueType::kUInt32}};
+ {ConfigNameStartRenderingTime, ValueType::kUInt64}};
} // namespace trackrenderer
#include <memory>
#include <vector>
-#include "trackrenderer/core/appinfo.h"
#include "trackrenderer/core/buffer.h"
#include "trackrenderer/core/display.h"
#include "trackrenderer/core/drm.h"
void MakeTrackRendererSubtitleAttr(TrackRendererSubtitleAttr* attr,
const SubtitleAttr& input_attr);
#endif
-void MakePlayerAppInfo(const TrackRendererAppInfo* app_attr,
- PlayerAppInfo& app_info);
-
DisplayMode ConvertToDisplayMode(TrackRendererDisplayMode typevalue);
DisplayRotation ConvertToDisplayRotate(TrackRendererDisplayRotate rotate);
DisplayType ConvertToDisplayType(const TrackRendererDisplayType typevalue);
#include "trackrenderer/core/drm.h"
#include "trackrenderer/core/track.h"
-#include "trackrenderer/core/appinfo.h"
namespace plusplayer {
public:
virtual ~PlayinfoSetter() {}
- virtual void SetAppInfo(const PlayerAppInfo& app_info) = 0;
virtual bool SetStreamInfo(GstCaps* v_sink_caps, GstCaps* v_decoder_caps,
GstCaps* a_decoder_caps,
const std::vector<Track>& tracks,
const char kPadProbeAudioBlock[] = "AUDIO_BLOCK_DOWNSTREAM";
const char kPadProbeVideoBlock[] = "VIDEO_BLOCK_DOWNSTREAM";
const char kPadProbeSubtitleBlock[] = "SUBTITLE_BLOCK_DOWNSTREAM";
-const char kPadProbeVideoPeekBlock[] = "VIDEO_PEEK_BLOCK_DOWNSTREAM";
const char kPadProbeCapsEvent[] = "CAPS_EVENT_DOWNSTREAM";
const char kPadProbeAppsrcEvent[] = "APPSRC_EVENT_DOWNSTREAM";
pipeline_->SetProperty(Elements::kSinkVideo, "still-mode", FALSE);
}
*/
- pipeline_->PadRemoveProbe(kPadProbeVideoPeekBlock);
if (state_ < State::kWorking) return false;
target_substate_ = SubState::kPlaying;
pipeline_->SetState(Elements::kPipeline, GST_STATE_PLAYING);
}
*/
TRACKRENDERER_INFO("Set pipeline state to GST_STATE_NULL.");
- pipeline_->PadRemoveProbe(kPadProbeVideoPeekBlock);
pipeline_->SetState(Elements::kPipeline, GST_STATE_NULL);
ReleaseResource_();
playback_info_->VconfSetMsgHide();
return false;
}
- if (is_video_frame_peek_) {
- pipeline_->PadRemoveProbe(kPadProbeVideoPeekBlock);
- }
-
target_substate_ = SubState::kPlaying;
pipeline_->SetState(Elements::kPipeline, GST_STATE_PLAYING);
TRACKRENDERER_LEAVE;
}
is_seeking_ = true;
- if (is_video_frame_peek_) {
- pipeline_->PadRemoveProbe(kPadProbeVideoPeekBlock);
- pipeline_->PadAddProbe(Elements::kSinkVideo, kPadProbeVideoPeekBlock,
- "sink", GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
- GstPadProbeVideoPeekBlockCb_, this, nullptr);
- }
if (playback_rate > 0) {
for (int i = 0; i < kTrackTypeMax; ++i) {
trackctx_[i].is_enough_data = false;
} else
pipeline_->SetProperty(Elements::kSinkVideo, "is-trickplay", FALSE);
- if (is_video_frame_peek_) {
- pipeline_->PadRemoveProbe(kPadProbeVideoPeekBlock);
- pipeline_->PadAddProbe(Elements::kSinkVideo, kPadProbeVideoPeekBlock,
- "sink", GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
- GstPadProbeVideoPeekBlockCb_, this, nullptr);
- }
-
for (int i = 0; i < kTrackTypeMax; ++i) {
trackctx_[i].is_enough_data = false;
trackctx_[i].need_update_segment = true;
return true;
}
-void TrackRenderer::SetSequentialMode_(const std::string& app_id) {
- bool is_supporting_seq_mode = false;
- int ret = system_info_get_custom_bool(
- "com.samsung/featureconf/media.support_seq_mode",
- &is_supporting_seq_mode);
- if (SYSTEM_INFO_ERROR_NONE != ret) {
- TRACKRENDERER_ERROR("system_info_get_custom_bool() return error [%d]", ret);
- return;
- }
- if (!is_supporting_seq_mode) {
- TRACKRENDERER_ERROR("is_supporting_seq_mode [%d]", is_supporting_seq_mode);
- return;
- }
- if (strstr(app_id.c_str(), "cobalt") || strstr(app_id.c_str(), "netflix")) {
- use_seq_mode_ = 1;
- }
-}
-
-void TrackRenderer::SetAppId(const std::string& app_id) {
- PlayerAppInfo app_info;
- app_info.id = app_id;
- SetAppInfo(app_info);
-}
-
-void TrackRenderer::SetAppInfo(const PlayerAppInfo& app_info) {
-#ifndef DISABLE_SEQ_MODE
- SetSequentialMode_(app_info.id);
-#endif
- /* Remark : public RM does not need the app information */
- playback_info_->SetAppInfo(app_info);
-}
-
bool TrackRenderer::GetResource_() {
assert(!trackinfo_.empty());
std::list<ResourceProperty> properties;
return GST_PAD_PROBE_OK;
}
-GstPadProbeReturn TrackRenderer::GstPadProbeVideoPeekBlockCb_(
- GstPad* pad, GstPadProbeInfo* info, gpointer userdata) {
- TRACKRENDERER_ENTER;
- if (GST_PAD_PROBE_INFO_TYPE(info) & GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM) {
- GstEvent* event = GST_PAD_PROBE_INFO_EVENT(info);
-
- if (!GST_EVENT_IS_SERIALIZED(event)) {
- TRACKRENDERER_DEBUG("pass non-serialized event");
- return GST_PAD_PROBE_PASS;
- }
-
- if (GST_EVENT_IS_STICKY(event) && GST_EVENT_TYPE(event) != GST_EVENT_EOS) {
- TRACKRENDERER_DEBUG("pass sticky event");
- return GST_PAD_PROBE_PASS;
- }
- }
-
- GstBuffer* buffer = gst_pad_probe_info_get_buffer(info);
- if (!buffer) {
- TRACKRENDERER_ERROR("buffer is null maybe EOS event");
- return GST_PAD_PROBE_PASS;
- }
- auto trackrenderer = static_cast<TrackRenderer*>(userdata);
- trackrenderer->last_position_ = GST_BUFFER_PTS(buffer) / GST_MSECOND;
- TRACKRENDERER_ERROR("Update last position for playing time [%" PRIu64 "ms]",
- trackrenderer->last_position_);
-
- if (trackrenderer->is_seeking_ && trackrenderer->state_ == State::kWorking) {
- TRACKRENDERER_ERROR("Seek Done");
- trackrenderer->eventlistener_->OnSeekDone();
- trackrenderer->is_seeking_ = false;
- return GST_PAD_PROBE_OK;
- }
- return GST_PAD_PROBE_OK;
-}
-
GstPadProbeReturn TrackRenderer::GstPadProbeAppsrcEventCb_(GstPad* pad,
GstPadProbeInfo* info,
gpointer userdata) {
internal::GetVideoSinkPluginName(ini_elements_,
track.use_swdecoder), NULL);
pipeline_->SetProperty(Elements::kSinkVideo, "async", FALSE);
- pipeline_->SetProperty(Elements::kSinkVideo, "use-seq-mode", use_seq_mode_);
if (internal::IsDecryptorElementNecessary(drm_property_)) {
pipeline_->FactoryMake(Elements::kDrmVideo, "cencdecrypt", NULL);
pipeline_->SetProperty(Elements::kDrmVideo, "getrights-complete-cb",
return true;
}
-bool TrackRenderer::GetDroppedFrames(void* frame_counts) {
- std::lock_guard<std::mutex> lk(resource_m_);
- if (state_ == State::kStopped) return false;
- if (!pipeline_) return false;
- int64_t drop_count = 0;
- Elements element = Elements::kSinkVideo;
- bool ret = false;
- if (playback_rate_ == kDefaultPlaybackRate && use_seq_mode_)
- ret = pipeline_->GetProperty(element, "dropped-frames-count", &drop_count);
- else
- ret = pipeline_->GetProperty(element, "dropped-frames", &drop_count);
- if (ret) {
- *(int64_t*)frame_counts = drop_count;
- return true;
- }
- return false;
-}
-
bool TrackRenderer::SetDisplayMode(const DisplayMode& mode) {
std::lock_guard<std::mutex> lk(resource_m_);
if (state_ == State::kStopped) return false;
display_->GetDisplayRotate(rotation);
}
-bool TrackRenderer::RenderVideoFrame() {
- TRACKRENDERER_ENTER;
- if (!is_video_frame_peek_) return false;
- pipeline_->PadRemoveProbe(kPadProbeVideoPeekBlock);
- return true;
-}
-
void TrackRenderer::SetAttribute_(const TrackRendererAttributeBinder& binder,
const boost::any& original_value,
const boost::any& new_value) {
&TrackRenderer::SetLowLatencyMode_, this, std::placeholders::_1);
config_setter_table_[ConfigNameWindowStandAloneMode] = std::bind(
&TrackRenderer::SetWindowStandAloneMode_, this, std::placeholders::_1);
- config_setter_table_[ConfigNameVideoFramePeekMode] = std::bind(
- &TrackRenderer::SetVideoFramePeekMode_, this, std::placeholders::_1);
config_setter_table_[ConfigNameUnlimitedMaxBufferMode] = std::bind(
&TrackRenderer::SetUnlimitedMaxBufferMode_, this, std::placeholders::_1);
config_setter_table_[ConfigNameVideoPreDisplayMode] = std::bind(
&TrackRenderer::SetVideoPreDisplayMode_, this, std::placeholders::_1);
config_setter_table_[ConfigNameStartRenderingTime] = std::bind(
&TrackRenderer::SetStartRenderingTime_, this, std::placeholders::_1);
- config_setter_table_[ConfigNameFmmMode] =
- std::bind(&TrackRenderer::SetFmmMode_, this, std::placeholders::_1);
}
bool TrackRenderer::SetAccurateSeekMode_(const boost::any& value) {
return true;
}
-bool TrackRenderer::SetVideoFramePeekMode_(const boost::any& value) {
- std::uint32_t val = boost::any_cast<std::uint32_t>(value);
- TRACKRENDERER_ERROR(" Mode [%s]", (val != 0) ? "TRUE" : "FALSE");
- is_video_frame_peek_ = (val != 0) ? true : false;
- return true;
-}
-
bool TrackRenderer::SetUnlimitedMaxBufferMode_(const boost::any& value) {
std::uint32_t val = boost::any_cast<std::uint32_t>(value);
TRACKRENDERER_ERROR(" Mode [%s]", (val != 0) ? "TRUE" : "FALSE");
rendering_start_time_.time = val * GST_MSECOND;
return true;
}
-bool TrackRenderer::SetFmmMode_(const boost::any& value) {
- std::uint32_t val = boost::any_cast<std::uint32_t>(value);
- TRACKRENDERER_ERROR(" Mode [%s]", (val != 0) ? "TRUE" : "FALSE");
- fmm_mode_ = (val != 0) ? true : false;
- return true;
-}
void TrackRenderer::GstElementLowLatency_(const TrackType& type) {
if (low_latency_mode_ == 0) return;
return kSuccess;
}
-int trackrenderer_get_dropped_frames(TrackRendererHandle handle, void* counts) {
- auto priv = static_cast<TrackRendererPrivPtr>(handle);
- if (!priv) return kFailed;
- if (priv->renderer->GetDroppedFrames(counts) == false) {
- return kFailed;
- }
- return kSuccess;
-}
-
int trackrenderer_deactivate(TrackRendererHandle handle,
TrackRendererTrackType type) {
auto priv = static_cast<TrackRendererPrivPtr>(handle);
return kSuccess;
}
-void trackrenderer_set_app_id(TrackRendererHandle handle, const char* app_id) {
- auto priv = static_cast<TrackRendererPrivPtr>(handle);
- if (!priv) return;
- std::string appid{app_id};
- priv->renderer->SetAppId(appid);
-}
-
-void trackrenderer_set_app_info(TrackRendererHandle handle,
- const TrackRendererAppInfo* app_info) {
- auto priv = static_cast<TrackRendererPrivPtr>(handle);
- if (!priv) return;
- plusplayer::trackrenderer::PlayerAppInfo info;
- plusplayer::trackrenderer::capi_utils::MakePlayerAppInfo(app_info, info);
- priv->renderer->SetAppInfo(info);
-}
-
int trackrenderer_set_audio_mute(TrackRendererHandle handle, bool is_mute) {
auto priv = static_cast<TrackRendererPrivPtr>(handle);
if (!priv) return kFailed;
return kSuccess;
}
-int trackrenderer_render_video_frame(TrackRendererHandle handle) {
- auto priv = static_cast<TrackRendererPrivPtr>(handle);
- if (!priv) return kFailed;
- if (!priv->renderer->RenderVideoFrame()) {
- return kFailed;
- }
- return kSuccess;
-}
-
/* CALL back*/
void trackrenderer_set_error_cb(TrackRendererHandle handle,
trackrenderer_error_cb callback,
}
#endif
-void MakePlayerAppInfo(const TrackRendererAppInfo* app_attr,
- PlayerAppInfo& app_info) {
- if (app_attr->id) app_info.id = app_attr->id;
- if (app_attr->version) app_info.version = app_attr->version;
- if (app_attr->type) app_info.type = app_attr->type;
-}
-
DisplayMode ConvertToDisplayMode(TrackRendererDisplayMode typevalue) {
switch (typevalue) {
case kTrackRendererDisplayModeLetterBox: {
ConcretePlayinfoSetter() noexcept {}
~ConcretePlayinfoSetter() {}
- void SetAppInfo(const PlayerAppInfo& app_info) override;
bool SetStreamInfo(GstCaps* v_sink_caps, GstCaps* v_decoder_caps,
GstCaps* a_decoder_caps, const std::vector<Track>& tracks,
drm::Type drm_type) override;
private:
bool is_shown_ = false;
StreamInfo stream_info_;
- PlayerAppInfo app_info_;
};
static const char* VCONF_KEY_FOR_PLAYBACK_INFO = "memory/mm/playinfo";
return;
}
-void FillMsgWithAppInfo(const PlayerAppInfo& app_info,
- std::stringstream* out_message) {
- if (app_info.id.empty())
- *out_message << "appid="
- << "_";
- else
- *out_message << "appid=" << app_info.id.c_str();
-
- if (app_info.version.empty())
- *out_message << "&app_version="
- << "_";
- else
- *out_message << "&app_version=" << app_info.version.c_str();
-
- if (app_info.type.empty())
- *out_message << "&app_type="
- << "_";
- else
- *out_message << "&app_type=" << app_info.type.c_str();
-
- return;
-}
-
void FillMsgWithStreamInfo(const StreamInfo& in_info,
std::stringstream* out_message) {
// InformationTicker will parse the keys by this delimeter '&'
return PlayinfoSetter::Ptr(new ConcretePlayinfoSetter);
}
-void ConcretePlayinfoSetter::SetAppInfo(const PlayerAppInfo& app_info) {
- app_info_ = app_info;
-}
-
bool ConcretePlayinfoSetter::SetStreamInfo(GstCaps* v_sink_caps,
GstCaps* v_decoder_caps,
GstCaps* a_decoder_caps,
void ConcretePlayinfoSetter::VconfSetMsgShow() {
auto message = std::unique_ptr<std::stringstream>(new std::stringstream);
- FillMsgWithAppInfo(app_info_, message.get());
*message.get() << "&display_mode=show";
FillMsgWithStreamInfo(stream_info_, message.get());
if (!is_shown_) return;
auto message = std::unique_ptr<std::stringstream>(new std::stringstream);
- FillMsgWithAppInfo(app_info_, message.get());
*message.get() << "&display_mode=update";
FillMsgWithStreamInfo(stream_info_, message.get());
void ConcretePlayinfoSetter::VconfSetMsgHide() {
if (!is_shown_) return;
auto message = std::unique_ptr<std::stringstream>(new std::stringstream);
- FillMsgWithAppInfo(app_info_, message.get());
*message.get() << "&display_mode=hide";
TRACKRENDERER_INFO("display : %s", message.get()->str().c_str());
projects / platform / core / multimedia / trackrenderer.git / commitdiff