fixup! Support time unit type (millisecond, microsecond)

refactoring by introducing immutable TimeConverter class to handle
various time conversion.

Change-Id: I4eb6be8fd7a181bb3a2377ed84ebfd3b97acc9cd

diff --git a/src/include_internal/trackrenderer/trackrenderer.h b/src/include_internal/trackrenderer/trackrenderer.h
index 8afac69c8dbc2c8e7dbc33fc4f01779b23404cae..e769d4eded45a83746f2ae19ca7ef9da1e2be581 100644 (file)
--- a/src/include_internal/trackrenderer/trackrenderer.h
+++ b/src/include_internal/trackrenderer/trackrenderer.h
@@ -209,6 +209,36 @@ class TrackRenderer : public ResourceConflictListener,
     kUs,
   };
 
+  class TimeConverter {
+  public:
+    explicit TimeConverter(TimeUnit timeUnit = TimeUnit::kMs)
+      : unit_(timeUnit) {}
+    ~TimeConverter() = default;
+
+    gint64 timeToNs_(uint64_t time) const {
+      return static_cast<gint64>(time * std::get<0>(timeMap_.at(unit_)));
+    }
+
+    uint64_t nsToTime_(gint64 ns) const {
+      return static_cast<uint64_t>(ns / std::get<0>(timeMap_.at(unit_)));
+    }
+
+    const std::string& timeUnitStr_() const {
+      return std::get<1>(timeMap_.at(unit_));
+    }
+
+    const char* timeUnitCStr_() const {
+      return std::get<1>(timeMap_.at(unit_)).c_str();
+    }
+
+  private:
+    const std::map<TimeUnit, std::pair<GstClockTimeDiff, std::string>> timeMap_ {
+      { TimeUnit::kMs, { GST_MSECOND, "ms" } },
+      { TimeUnit::kUs, { GST_USECOND, "us" } }
+    };
+    const TimeUnit unit_ { TimeUnit::kMs };
+  };
+
   struct TrackContext {
     int index = kInvalidTrackIndex;
     bool is_enough_data = false;
@@ -341,10 +371,6 @@ class TrackRenderer : public ResourceConflictListener,
   void EnableVideoHole_();
   void ApplySoundStreamInfo_();
 
-  const char* ConvertTimeUnitToString_();
-  gint64 ConvertTimeUnitToNS_(uint64_t time);
-  uint64_t ConvertNsToTimeUnit_(gint64 time);
-
  private:
   EventListener* eventlistener_ = nullptr;  // eventlistener is Defaultplayer
   std::mutex resource_m_;
@@ -394,7 +420,7 @@ class TrackRenderer : public ResourceConflictListener,
   std::map<std::string, Config_Setter> config_setter_table_;
   int64_t start_time = -1;
 
-  TimeUnit time_unit_type_ = TimeUnit::kMs;
+  std::unique_ptr<TimeConverter> time_converter_;
 
  private:
   static const Attributes kAttributes_;

diff --git a/src/trackrenderer.cpp b/src/trackrenderer.cpp
index 7faa10b90574c90416aac09bc3a661a03e5ca411..4b659b5f4be638a7a737d79ce177ff07a9f1dd15 100644 (file)
--- a/src/trackrenderer.cpp
+++ b/src/trackrenderer.cpp
@@ -458,6 +458,7 @@ TrackRenderer::TrackRenderer() noexcept : caps_builder_(kCapsRecipes_) {
   playback_info_ = debug::PlayinfoSetter::Create();
   SetDefaultAttributeValue_();
   InitConfigSetterTable_();
+  time_converter_.reset(new TimeConverter());
 }
 
 TrackRenderer::~TrackRenderer() {}
@@ -683,9 +684,9 @@ bool TrackRenderer::Seek(uint64_t time,
                            "async", async);
   }
 
-  gint64 start = ConvertTimeUnitToNS_(time), stop = GST_CLOCK_TIME_NONE;
+  gint64 start = time_converter_->timeToNs_(time), stop = GST_CLOCK_TIME_NONE;
   TRACKRENDERER_INFO("[%p] > target %" PRIu64 " %s  rate [%lf]", this, time,
-                      ConvertTimeUnitToString_(), playback_rate);
+                      time_converter_->timeUnitCStr_(), playback_rate);
 
   if (playback_rate < 0) {
     stop = start;
@@ -737,17 +738,17 @@ bool TrackRenderer::Seek(uint64_t time,
   else
     flags |= GST_SEEK_FLAG_KEY_UNIT;
 
-  auto convert_time = ConvertTimeUnitToNS_(time);
+  auto convert_time = time_converter_->timeToNs_(time);
 
   TRACKRENDERER_INFO("[%p] > target %" PRIu64 " %s  rate [%lf]  mute [%d]",
-                      this, convert_time, ConvertTimeUnitToString_(),
+                      this, convert_time, time_converter_->timeUnitCStr_(),
                       playback_rate, audio_mute);
   if (!pipeline_->Seek(playback_rate, GST_FORMAT_TIME,
                       (GstSeekFlags)(GST_SEEK_FLAG_FLUSH), GST_SEEK_TYPE_SET,
                       convert_time, GST_SEEK_TYPE_NONE,
                       GST_CLOCK_TIME_NONE)) {
     TRACKRENDERER_ERROR("[%p] > Fail to seek to [%" PRIu64 "] %s",
-                        this, convert_time, ConvertTimeUnitToString_());
+                        this, convert_time, time_converter_->timeUnitCStr_());
   }
 
   is_seeking_ = true;
@@ -1685,7 +1686,7 @@ gboolean TrackRenderer::GstSeekDataCb_(GstElement* element, guint64 offset,
     return true;
 
   trackrenderer->eventlistener_->OnSeekData(type,
-      trackrenderer->ConvertNsToTimeUnit_(static_cast<gint64>(offset)));
+      trackrenderer->time_converter_->nsToTime_(static_cast<gint64>(offset)));
 
   TRACKRENDERER_LEAVE;
   return true;
@@ -2274,14 +2275,12 @@ bool TrackRenderer::GetPlayingTime_(uint64_t* curtime) {
   bool ret_audio = pipeline_->QueryPosition(Elements::kSinkAudio,
                                             GST_FORMAT_TIME, &pos_audio);
   if (ret_video || ret_audio) {
-    last_position_ = *curtime = pos_audio > pos_video
-                                          ? (ConvertNsToTimeUnit_(pos_audio))
-                                          : (ConvertNsToTimeUnit_(pos_video));
-  } else {
-    *curtime = last_position_;
+    last_position_ =
+      time_converter_->nsToTime_(pos_audio > pos_video ? pos_audio : pos_video);
   }
+  *curtime = last_position_;
   // TRACKRENDERER_INFO("playing time [%" PRIu64 " %s]",
-  //     *curtime, ConvertTimeUnitToString_());
+  //     *curtime, time_converter_->timeUnitCStr_());
   return true;
 }
 
@@ -2716,12 +2715,12 @@ bool TrackRenderer::SetStartRenderingTime_(const boost::any& value) {
 
 bool TrackRenderer::SetPlayerTimeUnitType_(const boost::any& value) {
   std::uint32_t val = boost::any_cast<std::uint32_t>(value);
+
+  time_converter_.reset(new TimeConverter(val == 0 ? TimeUnit::kMs : TimeUnit::kUs));
+
   TRACKRENDERER_ERROR_P(this, " PlayerTimeUnitType [%s]",
-                        (val == 0) ? "Ms" : "Us");
-  if (val == 0)
-    time_unit_type_ = TimeUnit::kMs;
-  else if (val == 1)
-    time_unit_type_ = TimeUnit::kUs;
+    time_converter_->timeUnitCStr_());
+
   return true;
 }
 
@@ -3067,22 +3066,6 @@ void TrackRenderer::EnableVideoHole_() {
   }
 }
 
-const char* TrackRenderer::ConvertTimeUnitToString_() {
-  return time_unit_type_ == TimeUnit::kUs ? "us" : "ms";
-}
-
-gint64 TrackRenderer::ConvertTimeUnitToNS_(uint64_t time) {
-  return time_unit_type_ == TimeUnit::kUs ?
-      static_cast<gint64>(time * GST_USECOND) :
-      static_cast<gint64>(time * GST_MSECOND);
-}
-
-uint64_t TrackRenderer::ConvertNsToTimeUnit_(gint64 time) {
-  return time_unit_type_ == TimeUnit::kUs ?
-      static_cast<uint64_t>(time / GST_USECOND) :
-      static_cast<uint64_t>(time / GST_MSECOND);
-}
-
 }  // namespace trackrenderer
 
 }  // namespace plusplayer