Enable path to use videohole

[Version] 0.0.15
[Issue Type] Add

Change-Id: I289a680f374b0fb0eab78739e7e83d306171949e

diff --git a/include/trackrenderer_capi/trackrenderer_capi.h b/include/trackrenderer_capi/trackrenderer_capi.h
index 5e71b913af992ca8e38fdf11a6e18c1ec6595ab5..9ee31565248bdf7a054d4c799fd6bcb4259cf39d 100644 (file)
--- a/include/trackrenderer_capi/trackrenderer_capi.h
+++ b/include/trackrenderer_capi/trackrenderer_capi.h
@@ -315,7 +315,7 @@ int trackrenderer_destroy(TrackRendererHandle handle);
  *               media contents.
  * @param        [in] handle : trackrenderer handle
  * @return       Return 0 if no problem.
- *               Otherewise -1 if the trackrenderer is not even set up.
+ *               Otherwise -1 if the trackrenderer is not even set up.
  * @pre          The trackrenderer must be at least created and set up.
  *               trackrenderer_create()
  *               trackrenderer_prepare()
@@ -1069,7 +1069,7 @@ void trackrenderer_get_attribute(TrackRendererHandle handle,
  * @param        [in] handle : trackrenderer handle ptr.
  * @param        [in] color_info : matroska color info
  * @return       Return 0 if no problem.
- *               Otherewise -1 if the trackrenderer is not even set up.
+ *               Otherwise -1 if the trackrenderer is not even set up.
  * @pre          The trackrenderer must be at least created and set up.
  *               trackrenderer_create()
  *               trackrenderer_prepare()
@@ -1097,7 +1097,7 @@ void trackrenderer_set_video_frame_buffer_type(
  * @param        [in] handle : trackrenderer handle ptr.
  * @param        [in] volume : volume level(0 ~ 100)
  * @return       Return 0 if no problem.
- *               Otherewise -1 if the trackrenderer is not created.
+ *               Otherwise -1 if the trackrenderer is not created.
  * @pre          The trackrenderer must be at least created.
  *               trackrenderer_create()
  * @post         None
@@ -1111,7 +1111,7 @@ int trackrenderer_set_volume(TrackRendererHandle handle, const int volume);
  * @param        [in] handle : trackrenderer handle ptr.
  * @param        [out] volume : volume ptr
  * @return       Return 0 if no problem.
- *               Otherewise -1 if the trackrenderer is not created.
+ *               Otherwise -1 if the trackrenderer is not created.
  * @pre          The trackrenderer must be at least created.
  *               trackrenderer_create()
  * @post         None
@@ -1120,6 +1120,21 @@ int trackrenderer_set_volume(TrackRendererHandle handle, const int volume);
  */
 int trackrenderer_get_volume(TrackRendererHandle handle, int* volume);
 
+/**
+ * @brief        Enable videohole from trackrenderer
+ * @param        [in] handle : trackrenderer handle ptr.
+ * @param        [in] value : videohole\n
+ *               (@c true = enabled, @c false = disabled)
+ * @return       Return 0 if no problem.
+ *               Otherwise -1 if the trackrenderer is not created.
+ * @pre          The trackrenderer must be at least created.
+ *               trackrenderer_create()
+ * @post         None
+ * @exception    None
+ */
+int trackrenderer_enable_video_hole(TrackRendererHandle handle, const bool value);
+
+
 /* CALL back*/
 
 /**

diff --git a/src/include_internal/trackrenderer/trackrenderer.h b/src/include_internal/trackrenderer/trackrenderer.h
index 9675f774533d29623ed0439dfc1528909bfe0a73..887d936ebbd32b81e46c6e0bf5edf42ac35828c0 100644 (file)
--- a/src/include_internal/trackrenderer/trackrenderer.h
+++ b/src/include_internal/trackrenderer/trackrenderer.h
@@ -136,6 +136,7 @@ class TrackRenderer : public ResourceConflictListener,
   void SetVideoFrameBufferType(DecodedVideoFrameBufferType type) {
     decoded_buffer_type_ = type;
   }
+  bool EnableVideoHole(bool value);
 
  private:
   enum class Elements {
@@ -282,7 +283,6 @@ class TrackRenderer : public ResourceConflictListener,
   bool CreatePipeline_();
   void CreateAppSrc_(TrackType type, const std::string& mimetype);
   bool CreateVideoPipeline_(const Track* track);
-  bool CreateDecodedVideoPipeline_(const Track* track);
   bool CreateAudioPipeline_(const Track* track);
   bool CreateRawAudioPipeline_(const Track* track);
   bool CreateSubtitlePipeline_(const Track* track);
@@ -319,6 +319,7 @@ class TrackRenderer : public ResourceConflictListener,
   bool HasSubtitleOnly_() const;
   bool ActivateAudioPipeline(GstCaps* caps);
   void SetOpusChannelMappingFamily(const GstCapsWrapper& caps);
+  void EnableVideoHole_();
 
  private:
   EventListener* eventlistener_ = nullptr;  // eventlistener is Defaultplayer
@@ -360,6 +361,7 @@ class TrackRenderer : public ResourceConflictListener,
   bool is_audioactivated_ = true;
   std::unique_ptr<TbmBufferManager> tbm_buffer_manager_;
   double playback_rate_ = kDefaultPlaybackRate;
+  bool is_video_hole_enabled_ = false;
 
   SubState target_substate_ = SubState::kUnknown;
 

diff --git a/src/trackrenderer.cpp b/src/trackrenderer.cpp
index 95b2329e0e7457e3dcc000b6b689805c4a51d99c..8bb1feeb2b039ca4c13495e8996c9a7f4a953e3f 100644 (file)
--- a/src/trackrenderer.cpp
+++ b/src/trackrenderer.cpp
@@ -629,14 +629,8 @@ bool TrackRenderer::SetTrack(const std::vector<Track>& trackinfo) {
     trackctx_[track.type].track = &track;
     LOGD("track.type : %d", track.type);
     if ((int)track.type == (int)kTrackTypeVideo) {
-      if (internal::IsVideoDecodedBufferNeeded(decoded_buffer_type_))
-        trackctx_[track.type].create_pipeline =
-            std::bind(&TrackRenderer::CreateDecodedVideoPipeline_, this,
-                      std::placeholders::_1);
-      else
-        trackctx_[track.type].create_pipeline = std::bind(
-            &TrackRenderer::CreateVideoPipeline_, this, std::placeholders::_1);
-
+      trackctx_[track.type].create_pipeline = std::bind(
+          &TrackRenderer::CreateVideoPipeline_, this, std::placeholders::_1);
     } else if ((int)track.type == (int)kTrackTypeAudio) {
       if (internal::IsDecoderElementNecessary(track.mimetype)) {
         trackctx_[track.type].create_pipeline =
@@ -1077,8 +1071,23 @@ bool TrackRenderer::CreateVideoPipeline_(const Track* track) {
     return false;
   }
 
-  pipeline_->FactoryMake(Elements::kSinkVideo,
-                         internal::GetVideoSinkPluginName(ini_elements_, track->use_swdecoder), NULL);
+  auto videosink_name = internal::GetVideoSinkPluginName(ini_elements_, track->use_swdecoder);
+  pipeline_->FactoryMake(Elements::kSinkVideo, videosink_name, NULL);
+
+  if (strstr(videosink_name, "tizenwlsink")) {
+    pipeline_->SignalConnect(Elements::kSinkVideo, "handoff",
+                             G_CALLBACK(GstDecodedVideoBufferCb_), this);
+    if (internal::IsVideoDecodedBufferNeeded(decoded_buffer_type_)) {
+      TRACKRENDERER_INFO("set signal-handoffs to FALSE");
+      CreateTbmBufferManager_(track);
+      EnableVideoHole(true);
+      pipeline_->SetProperty(Elements::kSinkVideo, "sync", TRUE, "async", TRUE);
+    } else {
+      TRACKRENDERER_INFO("didn't set signal-handoffs");
+    }
+  } else {
+    TRACKRENDERER_ERROR("video sink is not tizenwlsink. => %s", videosink_name);
+  }
 
   pipeline_->FactoryMake(Elements::kCCExtractor, "ccextractor", "ccextractor");
 
@@ -1128,11 +1137,13 @@ bool TrackRenderer::CreateVideoPipeline_(const Track* track) {
                       Elements::kSinkVideo);
   } else {
     if (pipeline_->IsFactoryListType(Elements::kDecVideo, GST_ELEMENT_FACTORY_TYPE_HARDWARE)) {
+      TRACKRENDERER_INFO("HW codec");
       pipeline_->SetProperty(Elements::kSinkVideo, "use-tbm", true);
       pipeline_->BinAdd(Elements::kBinVideo, Elements::kAppSrcVideo, Elements::kParseVideo,
                   Elements::kDecVideo, Elements::kCCExtractor, Elements::kSinkVideo);
 
     } else { /* sw */
+      TRACKRENDERER_INFO("SW codec");
       pipeline_->FactoryMake(Elements::kVideoQueue, "queue", NULL);
       pipeline_->SetProperty(Elements::kVideoQueue, "max-size-buffers", 2);
 
@@ -1156,86 +1167,6 @@ bool TrackRenderer::CreateVideoPipeline_(const Track* track) {
   return true;
 }
 
-bool TrackRenderer::CreateDecodedVideoPipeline_(const Track* track) {
-  TRACKRENDERER_ENTER;
-  CreateTbmBufferManager_(track);
-  auto caps = caps_builder_.Build(*track, internal::IsDrmEmeElementNecessary(
-                                              drm_property_, track->mimetype));
-
-  CreateAppSrc_(kTrackTypeVideo, track->mimetype);
-
-  pipeline_->FactoryMake(Elements::kParseVideo, (GstCaps*)caps.GetCaps_(),
-                          GST_ELEMENT_FACTORY_TYPE_PARSER, NULL);
-  auto parse_caps =
-      gstguard::make_guard(pipeline_->GetSrcPadCaps(Elements::kParseVideo));
-
-  if (!pipeline_->FactoryMake(Elements::kDecVideo, (GstCaps*)parse_caps.get(),
-                           GST_ELEMENT_FACTORY_TYPE_DECODER, NULL)) {
-    const ErrorType err = ErrorType::kNotSupportedVideoCodec;
-    eventlistener_->OnError(err);
-    return false;
-  }
-
-  pipeline_->FactoryMake(Elements::kSinkVideo, "fakesink", "fakesink");
-
-  pipeline_->CreateBin(Elements::kBinVideo, "videobin");
-
-  pipeline_->SignalConnect(Elements::kAppSrcVideo, "need-data",
-                           G_CALLBACK(GstVideoNeedDataCb_), this);
-  pipeline_->SignalConnect(Elements::kAppSrcVideo, "enough-data",
-                           G_CALLBACK(GstVideoEnoughDataCb_), this);
-  pipeline_->SignalConnect(Elements::kAppSrcVideo, "seek-data",
-                           G_CALLBACK(GstVideoSeekDataCb_), this);
-  pipeline_->SetProperty(Elements::kAppSrcVideo, "format", GST_FORMAT_TIME);
-
-  if (internal::IsDrmEmeElementNecessary(drm_property_, track->mimetype)) {
-    pipeline_->FactoryMake(Elements::kDrmVideo, "drm_eme", "video_drm");
-    pipeline_->SetProperty(Elements::kDrmVideo, "plus-player-eme", TRUE);
-    if (internal::IsExternalDecryptionCase(drm_property_) == false) {
-      pipeline_->SetProperty(Elements::kDrmVideo, "getrights-complete-cb",
-                             GstVideoDrmInitDataCb_);
-      pipeline_->SetProperty(Elements::kDrmVideo, "getrights-complete-cb-data",
-                             this);
-    }
-
-    pipeline_->BinAdd(Elements::kBinVideo, Elements::kAppSrcVideo,
-                      Elements::kDrmVideo, Elements::kDecVideo,
-                      Elements::kSinkVideo);
-  } else {
-    if (pipeline_->IsFactoryListType(Elements::kDecVideo, GST_ELEMENT_FACTORY_TYPE_HARDWARE)) {
-      TRACKRENDERER_INFO("HW codec");
-      pipeline_->BinAdd(Elements::kBinVideo, Elements::kAppSrcVideo, Elements::kParseVideo,
-                  Elements::kDecVideo, Elements::kSinkVideo);
-    } else {
-      TRACKRENDERER_INFO("SW codec");
-      pipeline_->FactoryMake(Elements::kVideoQueue, "queue", NULL);
-      pipeline_->SetProperty(Elements::kVideoQueue, "max-size-buffers", 2);
-
-      pipeline_->FactoryMake(Elements::kVideoConvert, "videoconvert", NULL);
-      pipeline_->SetProperty(Elements::kVideoConvert, "n-threads", 2);
-
-      pipeline_->BinAdd(Elements::kBinVideo, Elements::kAppSrcVideo, Elements::kParseVideo,
-                  Elements::kDecVideo, Elements::kVideoQueue, Elements::kVideoConvert, Elements::kSinkVideo);
-    }
-  }
-
-  pipeline_->BinAddSimple(Elements::kPipeline, Elements::kBinVideo);
-
-  pipeline_->SetAppSrcCaps(Elements::kAppSrcVideo, caps);
-
-  pipeline_->SetProperty(Elements::kAppSrcVideo, "stream-type",
-                         GST_APP_STREAM_TYPE_SEEKABLE);
-
-  pipeline_->SetProperty(Elements::kSinkVideo, "signal-handoffs", TRUE, "sync", TRUE, "async", TRUE);
-
-  pipeline_->SignalConnect(Elements::kSinkVideo, "handoff",
-                           G_CALLBACK(GstDecodedVideoBufferCb_),
-                           this);
-
-  TRACKRENDERER_LEAVE;
-  return true;
-}
-
 void TrackRenderer::SetOpusChannelMappingFamily(const GstCapsWrapper& caps) {
   auto p = gst_caps_get_structure((GstCaps*)caps.GetCaps_(), 0);
   gint channels = 0;
@@ -2870,6 +2801,30 @@ bool TrackRenderer::DeactivateAudio_() {
   return true;
 }
 
+bool TrackRenderer::EnableVideoHole(bool value) {
+  TRACKRENDERER_DEBUG("EnableVideoHole : %d", value);
+  std::lock_guard<std::mutex> lk(resource_m_);
+  is_video_hole_enabled_ = value;
+  if (!pipeline_) return true;
+  EnableVideoHole_();
+  return true;
+}
+
+void TrackRenderer::EnableVideoHole_() {
+  const gchar* sink_name = nullptr;
+  pipeline_->GetProperty(Elements::kSinkVideo, "name", &sink_name);
+  if (sink_name == nullptr) {
+    TRACKRENDERER_WARN("no video sink");
+    return;
+  }
+  if (strstr(sink_name, "tizenwlsink")) {
+    pipeline_->SetProperty(Elements::kSinkVideo, "signal-handoffs", is_video_hole_enabled_ ? false : true);
+    TRACKRENDERER_DEBUG("value: %d", is_video_hole_enabled_);
+  } else {
+    TRACKRENDERER_WARN("sink name: %s", sink_name);
+  }
+}
+
 }  // namespace trackrenderer
 
 }  // namespace plusplayer

diff --git a/src/trackrenderer_capi.cpp b/src/trackrenderer_capi.cpp
index 96f448df666cebdd265ef6f8577f36bb280e2ed8..ff9cad24f507ea86ebe27d3762e432f5e4a1ccb8 100644 (file)
--- a/src/trackrenderer_capi.cpp
+++ b/src/trackrenderer_capi.cpp
@@ -1043,6 +1043,15 @@ int trackrenderer_flush(TrackRendererHandle handle,
   return kSuccess;
 }
 
+int trackrenderer_enable_video_hole(TrackRendererHandle handle, const bool value) {
+  auto priv = static_cast<TrackRendererPrivPtr>(handle);
+  if (!priv) return kFailed;
+  if (!priv->renderer->EnableVideoHole(value)) {
+    return kFailed;
+  }
+  return kSuccess;
+}
+
 /* CALL back*/
 void trackrenderer_set_error_cb(TrackRendererHandle handle,
                                 trackrenderer_error_cb callback,