refactoring

Author: arch

funscript_editor/algorithms/funscriptgenerator.py

@@ -154,20 +154,14 @@ def drawTime(self, img: np.ndarray, frame_num: int) -> np.ndarray:
             np.ndarray: opencv image with Time Text
         """
         annotated_img = img.copy()
-        current_timestamp = FFmpegStream.millisec_to_timestamp(
-                self.frame_to_millisec(frame_num, self.video_info.fps)
-            )
+        current_timestamp = FFmpegStream.frame_to_timestamp(frame_num, self.video_info.fps)
         current_timestamp = ''.join(current_timestamp[:-4])
 
         if self.params.end_frame < 1:
-            end_timestamp = FFmpegStream.millisec_to_timestamp(
-                    self.frame_to_millisec(self.video_info.length, self.video_info.fps)
-                )
+            end_timestamp = FFmpegStream.frame_to_timestamp(self.video_info.length, self.video_info.fps)
             end_timestamp = ''.join(end_timestamp[:-4])
         else:
-            end_timestamp = FFmpegStream.millisec_to_timestamp(
-                    self.frame_to_millisec(self.params.end_frame, self.video_info.fps)
-                )
+            end_timestamp = FFmpegStream.frame_to_timestamp(self.params.end_frame, self.video_info.fps)
             end_timestamp = ''.join(end_timestamp[:-4])
 
         txt = current_timestamp + ' / ' + end_timestamp
@@ -295,21 +289,6 @@ def calculate_score(self) -> None:
         self.score['y'] = sp.scale_signal(self.score['y'], 0, 100)
 
 
-    @staticmethod
-    def frame_to_millisec(frame: int, fps: float) -> int:
-        """ Convert frame number to timestamp in video
-
-        Args:
-            frame (int): the framenumber to convert to an timestamp
-            fps (float): Video FPS
-
-        Returns:
-            int: the timestamp in milliseconds in video for the given framenumber
-        """
-        if frame < 0: return 0
-        return int(round(float(frame)*float(1000)/fps))
-
-
     def scale_score(self, status: str, direction : str = 'y') -> None:
         """ Scale the score to desired stroke high
 
@@ -814,15 +793,15 @@ def run(self) -> None:
                     min(output_score) \
                             if output_score[idx] < min(output_score) + self.params.bottom_threshold \
                             else round(output_score[idx]),
-                    self.frame_to_millisec(self.apply_shift(idx, 'min'), self.video_info.fps)
+                    FFmpegStream.frame_to_millisec(self.apply_shift(idx, 'min'), self.video_info.fps)
                 )
 
         for idx in idx_dict['max']:
             self.funscript.add_action(
                     max(output_score) \
                             if output_score[idx] > max(output_score) - self.params.top_threshold \
                             else round(output_score[idx]),
-                    self.frame_to_millisec(self.apply_shift(idx, 'max'), self.video_info.fps)
+                    FFmpegStream.frame_to_millisec(self.apply_shift(idx, 'max'), self.video_info.fps)
                 )
 
         self.finished(status, True)

funscript_editor/data/ffmpegstream.py

@@ -162,17 +162,35 @@ def get_projection(
         return projection
 
 
-    def frame_to_millisec(self, frame_number) -> int:
+    @staticmethod
+    def frame_to_timestamp(frame_number: int, fps: float) -> str:
+        """Get timestamp for given frame number
+
+        Args:
+            frame_number (int): frame number
+            fps (float): frames per seconds
+
+        Returns:
+            str: position in video as timestamp with H:M:S.XXX
+        """
+        return FFmpegStream.millisec_to_timestamp(
+                FFmpegStream.frame_to_millisec(frame_number, fps)
+            )
+
+
+    @staticmethod
+    def frame_to_millisec(frame_number: int, fps: float) -> int:
         """Get timestamp for given frame number
 
         Args:
             frame_number (int): frame number
+            fps (float): frames per seconds
 
         Returns:
-            int: timestamp in video
+            int: timestamp in milliseconds
         """
         if frame_number <= 0: return 0
-        return int(round(float(frame_number)*float(1000)/self.video_info.fps))
+        return int(round(float(frame_number)*float(1000)/fps))
 
 
     @staticmethod
@@ -244,9 +262,7 @@ def run(self) -> None:
         for k, v in self.config['parameter'].items():
             video_filter = video_filter.replace('${' + k + '}', str(v))
 
-        seek = self.millisec_to_timestamp(
-                self.frame_to_millisec(self.start_frame)
-            )
+        seek = FFmpegStream.frame_to_timestamp(self.start_frame, self.video_info.fps)
 
         command = [
                 'ffmpeg',