[detector] Remove is_processing_required

Author: Breakthrough

scenedetect/detectors/content_detector.py

@@ -142,9 +142,6 @@ def __init__(
     def get_metrics(self):
         return ContentDetector.METRIC_KEYS
 
-    def is_processing_required(self, frame_num):
-        return True
-
     def _calculate_frame_score(self, frame_num: int, frame_img: numpy.ndarray) -> float:
         """Calculate score representing relative amount of motion in `frame_img` compared to
         the last time the function was called (returns 0.0 on the first call)."""

scenedetect/detectors/hash_detector.py

@@ -82,25 +82,10 @@ def __init__(
     def get_metrics(self):
         return [self._metric_key]
 
-    def is_processing_required(self, frame_num):
-        return True
-
-    def process_frame(self, frame_num, frame_img):
+    def process_frame(self, frame_num: int, frame_img: numpy.ndarray):
         """Similar to ContentDetector, but using a perceptual hashing algorithm
         to calculate a hash for each frame and then calculate a hash difference
-        frame to frame.
-
-        Arguments:
-            frame_num (int): Frame number of frame that is being passed.
-
-            frame_img (Optional[int]): Decoded frame image (numpy.ndarray) to perform scene
-                detection on. Can be None *only* if the self.is_processing_required() method
-                (inhereted from the base SceneDetector class) returns True.
-
-        Returns:
-           ty.List[int]: List of frames where scene cuts have been detected. There may be 0
-            or more frames in the list, and not necessarily the same as frame_num.
-        """
+        frame to frame."""
 
         cut_list = []
 

scenedetect/detectors/histogram_detector.py

@@ -160,8 +160,5 @@ def calculate_histogram(
 
         return hist
 
-    def is_processing_required(self, frame_num: int) -> bool:
-        return True
-
     def get_metrics(self) -> ty.List[str]:
         return [self._metric_key]

scenedetect/scene_detector.py

@@ -50,29 +50,6 @@ class SceneDetector:
     """Optional :class:`StatsManager <scenedetect.stats_manager.StatsManager>` to
     use for caching frame metrics to and from."""
 
-    # TODO(v1.0): Remove - this is a rarely used case for what is now a neglegible performance gain.
-    def is_processing_required(self, frame_num: int) -> bool:
-        """[DEPRECATED] DO NOT USE
-
-        Test if all calculations for a given frame are already done.
-
-        Returns:
-            False if the SceneDetector has assigned _metric_keys, and the
-            stats_manager property is set to a valid StatsManager object containing
-            the required frame metrics/calculations for the given frame - thus, not
-            needing the frame to perform scene detection.
-
-            True otherwise (i.e. the frame_img passed to process_frame is required
-            to be passed to process_frame for the given frame_num).
-
-        :meta private:
-        """
-        metric_keys = self.get_metrics()
-        return not metric_keys or not (
-            self.stats_manager is not None
-            and self.stats_manager.metrics_exist(frame_num, metric_keys)
-        )
-
     def stats_manager_required(self) -> bool:
         """Stats Manager Required: Prototype indicating if detector requires stats.
 

scenedetect/scene_manager.py

@@ -1369,53 +1369,47 @@ def _decode_thread(
                 # We don't do any kind of locking here since the worst-case of this being wrong
                 # is that we do some extra work, and this function should never mutate any data
                 # (all of which should be modified under the GIL).
-                # TODO(v1.0): This optimization should be removed as it is an uncommon use case and
-                # greatly increases the complexity of detection algorithms using it.
-                if self._is_processing_required(video.position._frame_num):
-                    frame_im = video.read()
-                    if frame_im is False:
-                        break
-                    # Verify the decoded frame size against the video container's reported
-                    # resolution, and also verify that consecutive frames have the correct size.
-                    decoded_size = (frame_im.shape[1], frame_im.shape[0])
-                    if self._frame_size is None:
-                        self._frame_size = decoded_size
-                        if video.frame_size != decoded_size:
-                            logger.warn(
-                                f"WARNING: Decoded frame size ({decoded_size}) does not match "
-                                f" video resolution {video.frame_size}, possible corrupt input."
-                            )
-                    elif self._frame_size != decoded_size:
-                        self._frame_size_errors += 1
-                        if self._frame_size_errors <= MAX_FRAME_SIZE_ERRORS:
-                            logger.error(
-                                f"ERROR: Frame at {str(video.position)} has incorrect size and "
-                                f"cannot be processed: decoded size = {decoded_size}, "
-                                f"expected = {self._frame_size}. Video may be corrupt."
-                            )
-                        if self._frame_size_errors == MAX_FRAME_SIZE_ERRORS:
-                            logger.warn(
-                                "WARNING: Too many errors emitted, skipping future messages."
-                            )
-                        # Skip processing frames that have an incorrect size.
-                        continue
-
-                    if self._crop:
-                        (x0, y0, x1, y1) = self._crop
-                        frame_im = frame_im[y0:y1, x0:x1]
-
-                    if downscale_factor > 1.0:
-                        frame_im = cv2.resize(
-                            frame_im,
-                            (
-                                max(1, round(frame_im.shape[1] / downscale_factor)),
-                                max(1, round(frame_im.shape[0] / downscale_factor)),
-                            ),
-                            interpolation=self._interpolation.value,
+                frame_im = video.read()
+                if frame_im is False:
+                    break
+                # Verify the decoded frame size against the video container's reported
+                # resolution, and also verify that consecutive frames have the correct size.
+                decoded_size = (frame_im.shape[1], frame_im.shape[0])
+                if self._frame_size is None:
+                    self._frame_size = decoded_size
+                    if video.frame_size != decoded_size:
+                        logger.warn(
+                            f"WARNING: Decoded frame size ({decoded_size}) does not match "
+                            f" video resolution {video.frame_size}, possible corrupt input."
                         )
-                else:
-                    if video.read(decode=False) is False:
-                        break
+                elif self._frame_size != decoded_size:
+                    self._frame_size_errors += 1
+                    if self._frame_size_errors <= MAX_FRAME_SIZE_ERRORS:
+                        logger.error(
+                            f"ERROR: Frame at {str(video.position)} has incorrect size and "
+                            f"cannot be processed: decoded size = {decoded_size}, "
+                            f"expected = {self._frame_size}. Video may be corrupt."
+                        )
+                    if self._frame_size_errors == MAX_FRAME_SIZE_ERRORS:
+                        logger.warn(
+                            "WARNING: Too many errors emitted, skipping future messages."
+                        )
+                    # Skip processing frames that have an incorrect size.
+                    continue
+
+                if self._crop:
+                    (x0, y0, x1, y1) = self._crop
+                    frame_im = frame_im[y0:y1, x0:x1]
+
+                if downscale_factor > 1.0:
+                    frame_im = cv2.resize(
+                        frame_im,
+                        (
+                            max(1, round(frame_im.shape[1] / downscale_factor)),
+                            max(1, round(frame_im.shape[0] / downscale_factor)),
+                        ),
+                        interpolation=self._interpolation.value,
+                    )
 
                 # Set the start position now that we decoded at least the first frame.
                 if self._start_pos is None:
@@ -1505,9 +1499,3 @@ def get_event_list(self, base_timecode: ty.Optional[FrameTimecode] = None) -> Sc
         # TODO(v0.7): Use the warnings module to turn this into a warning.
         logger.error("`get_event_list()` is deprecated and will be removed in a future release.")
         return self._get_event_list()
-
-    def _is_processing_required(self, frame_num: int) -> bool:
-        """True if frame metrics not in StatsManager, False otherwise."""
-        if self.stats_manager is None:
-            return True
-        return all([detector.is_processing_required(frame_num) for detector in self._detector_list])

website/pages/changelog.md

@@ -659,8 +659,10 @@ Development
 
 #### Breaking
 
-- `FrameTimecode` fields `frame_num` and `framerate` are now read-only properties, construct a new `FrameTimecode` to change them
-- Remove `FrameTimecode.previous_frame()` method
+ - `FrameTimecode` fields `frame_num` and `framerate` are now read-only properties, construct a new `FrameTimecode` to change them
+ - Remove `FrameTimecode.previous_frame()` method
+ - Remove `SceneDetector.is_processing_required()` method, already had no effect in v0.6 as part of deprecation
+ - `SceneDetector` instances can now assume they always have frame data to process when `process_frame` is called
 
 #### Deprecation