deffcode 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

deffcode/ffdecoder.py

@@ -19,6 +19,7 @@ limitations under the License.
 """
 
 # import the necessary packages
+import platform
 import logging
 import numpy as np
 import subprocess as sp
@@ -106,10 +107,16 @@ class FFdecoder:
         # handles user-defined parameters
         self.__extra_params = {}
 
-        # handle process to be frames written
+        # handles process to be frames written
         self.__process = None
 
-        # handle exclusive metadata
+        # handles disabling window for ffmpeg subprocess on Windows
+        self.__ffmpeg_window_disabler_patch = False
+
+        # checks machine OS
+        self.__machine_OS = platform.system()
+
+        # handles exclusive metadata
         self.__ff_pixfmt_metadata = None  # metadata
         self.__raw_frame_num = None  # raw-frame number
         self.__raw_frame_pixfmt = None  # raw-frame pixformat
@@ -127,23 +134,26 @@ class FFdecoder:
         # operation mode variable
         self.__opmode = None
 
-        # handle termination
+        # handles termination
         self.__terminate_stream = False
 
         # cleans and reformat user-defined parameters
         self.__extra_params = {
-            str(k).strip(): str(v).strip()
-            if not (v is None) and not isinstance(v, (dict, list, int, float, tuple))
-            else v
+            str(k).strip(): (
+                str(v).strip()
+                if not (v is None)
+                and not isinstance(v, (dict, list, int, float, tuple))
+                else v
+            )
             for k, v in ffparams.items()
         }
 
-        # handle custom Sourcer API params
+        # handles custom Sourcer API params
         sourcer_params = self.__extra_params.pop("-custom_sourcer_params", {})
         # reset improper values
         sourcer_params = {} if not isinstance(sourcer_params, dict) else sourcer_params
 
-        # handle user ffmpeg pre-headers(parameters such as `-re`) parameters (must be a list)
+        # handles user ffmpeg pre-headers(parameters such as `-re`) parameters (must be a list)
         self.__ffmpeg_prefixes = self.__extra_params.pop("-ffprefixes", [])
         # check if not valid type
         if not isinstance(self.__ffmpeg_prefixes, list):
@@ -199,6 +209,35 @@ class FFdecoder:
         # handle valid FFmpeg assets location
         self.__ffmpeg = self.__sourcer_metadata["ffmpeg_binary_path"]
 
+        # handle YUV pixel formats(such as `yuv420p`, `yuv444p`, `nv12`, `nv21` etc.)
+        # patch for compatibility with OpenCV APIs.
+        self.__cv_patch = self.__extra_params.pop("-enforce_cv_patch", False)
+        if not (isinstance(self.__cv_patch, bool)):
+            self.__cv_patch = False
+            self.__verbose_logs and logger.critical(
+                "Enforcing OpenCV compatibility patch for YUV/NV video frames."
+            )
+
+        # handle disabling window for ffmpeg subprocess on Windows OS
+        # this patch prevents ffmpeg creation window from opening when
+        # building exe files
+        ffmpeg_window_disabler_patch = self.__extra_params.pop(
+            "-disable_ffmpeg_window", False
+        )
+        if ffmpeg_window_disabler_patch and isinstance(
+            ffmpeg_window_disabler_patch, bool
+        ):
+            # check if value is valid
+            if self.__machine_OS != "Windows" or self.__verbose_logs:
+                logger.warning(
+                    "Optional `-disable_ffmpeg_window` flag is only available on Windows OS with `verbose=False`. Discarding!"
+                )
+            else:
+                self.__ffmpeg_window_disabler_patch = ffmpeg_window_disabler_patch
+        else:
+            # handle improper values
+            self.__ffmpeg_window_disabler_patch = False
+
         # handle pass-through audio mode works in conjunction with WriteGear [TODO]
         self.__passthrough_mode = self.__extra_params.pop("-passthrough_audio", False)
         if not (isinstance(self.__passthrough_mode, bool)):
@@ -279,7 +318,6 @@ class FFdecoder:
             self.__custom_resolution = None
 
     def formulate(self):
-
         """
         This method formulates all necessary FFmpeg pipeline arguments and executes it inside the FFmpeg `subprocess` pipe.
 
@@ -411,13 +449,15 @@ class FFdecoder:
                 else:
                     logger.warning(
                         "{} Switching to default `{}` pixel-format!".format(
-                            "Provided FFmpeg does not supports `{}` pixel-format.".format(
-                                self.__sourcer_metadata["output_frames_pixfmt"]
-                                if "output_frames_pixfmt" in self.__sourcer_metadata
-                                else self.__frame_format
-                            )
-                            if self.__frame_format != "null"
-                            else "No usable pixel-format defined.",
+                            (
+                                "Provided FFmpeg does not supports `{}` pixel-format.".format(
+                                    self.__sourcer_metadata["output_frames_pixfmt"]
+                                    if "output_frames_pixfmt" in self.__sourcer_metadata
+                                    else self.__frame_format
+                                )
+                                if self.__frame_format != "null"
+                                else "No usable pixel-format defined."
+                            ),
                             default_pixfmt,
                         )
                     )
@@ -428,7 +468,9 @@ class FFdecoder:
                 for x in self.__ff_pixfmt_metadata
                 if x[0] == rawframe_pixfmt
             ][0]
-            raw_bit_per_component = rawframesbpp // self.__raw_frame_depth
+            raw_bit_per_component = (
+                rawframesbpp // self.__raw_frame_depth if self.__raw_frame_depth else 0
+            )
             if 4 <= raw_bit_per_component <= 8:
                 self.__raw_frame_dtype = np.dtype("u1")
             elif 8 < raw_bit_per_component <= 16 and rawframe_pixfmt.endswith(
@@ -456,9 +498,9 @@ class FFdecoder:
             self.__raw_frame_pixfmt = rawframe_pixfmt
             # also override as metadata(if available)
             if "output_frames_pixfmt" in self.__sourcer_metadata:
-                self.__sourcer_metadata[
-                    "output_frames_pixfmt"
-                ] = self.__raw_frame_pixfmt
+                self.__sourcer_metadata["output_frames_pixfmt"] = (
+                    self.__raw_frame_pixfmt
+                )
 
             # handle raw-frame resolution
             # notify FFmpeg `-s` parameter cannot be assigned directly
@@ -598,7 +640,7 @@ class FFdecoder:
                 self.__raw_frame_num = None
                 # log that number of frames are unknown
                 self.__verbose_logs and logger.info(
-                    "Live/Network Stream detected! Number of frames in given source are not known."
+                    "Number of frames in given source are unknown. Live/Network/Looping stream detected!"
                 )
 
             # log Mode of Operation
@@ -626,11 +668,15 @@ class FFdecoder:
             self.__process is None
         ), "Pipeline is not running! You must call `formulate()` method first."
 
-        # formulated raw frame size
+        # formulated raw frame size and apply YUV pixel formats patch(if applicable)
         raw_frame_size = (
-            self.__raw_frame_depth
-            * self.__raw_frame_resolution[0]
-            * self.__raw_frame_resolution[1]
+            (self.__raw_frame_resolution[0] * (self.__raw_frame_resolution[1] * 3 // 2))
+            if self.__raw_frame_pixfmt.startswith(("yuv", "nv")) and self.__cv_patch
+            else (
+                self.__raw_frame_depth
+                * self.__raw_frame_resolution[0]
+                * self.__raw_frame_resolution[1]
+            )
         )
         # next dataframe as numpy ndarray
         nparray = None
@@ -668,6 +714,12 @@ class FFdecoder:
                     self.__raw_frame_depth,
                 )
             )[:, :, 0]
+        elif self.__raw_frame_pixfmt.startswith(("yuv", "nv")) and self.__cv_patch:
+            # reconstruct exclusive YUV formats frames for OpenCV APIs
+            frame = frame.reshape(
+                self.__raw_frame_resolution[1] * 3 // 2,
+                self.__raw_frame_resolution[0],
+            )
         else:
             # reconstruct default frames
             frame = frame.reshape(
@@ -783,9 +835,11 @@ class FFdecoder:
                     self.__verbose_logs and logger.info(
                         "Updating `{}`{} metadata property to `{}`.".format(
                             key,
-                            " and its counterpart"
-                            if key in counterpart_prop.values()
-                            else "",
+                            (
+                                " and its counterpart"
+                                if key in counterpart_prop.values()
+                                else ""
+                            ),
                             value[key],
                         )
                     )
@@ -817,7 +871,6 @@ class FFdecoder:
             raise ValueError("Invalid datatype metadata assigned. Aborting!")
 
     def __launch_FFdecoderline(self, input_params, output_params):
-
         """
         This Internal method executes FFmpeg pipeline arguments inside a `subprocess` pipe in a new process.
 
@@ -856,7 +909,13 @@ class FFdecoder:
         else:
             # In silent mode
             self.__process = sp.Popen(
-                cmd, stdin=sp.DEVNULL, stdout=sp.PIPE, stderr=sp.DEVNULL
+                cmd,
+                stdin=sp.DEVNULL,
+                stdout=sp.PIPE,
+                stderr=sp.DEVNULL,
+                creationflags=(  # this prevents ffmpeg creation window from opening when building exe files on Windows
+                    sp.DETACHED_PROCESS if self.__ffmpeg_window_disabler_patch else 0
+                ),
             )
 
     def terminate(self):
@@ -877,9 +936,7 @@ class FFdecoder:
         # close `stdout` output
         self.__process.stdout and self.__process.stdout.close()
         # terminate/kill process if still processing
-        if self.__process.poll() is None:
-            # demuxers prefer kill
-            self.__process.kill()
+        self.__process.poll() is None and self.__process.terminate()
         # wait if not exiting
         self.__process.wait()
         self.__process = None

deffcode/ffhelper.py

@@ -27,8 +27,7 @@ import subprocess as sp
 
 from tqdm import tqdm
 from pathlib import Path
-from requests.adapters import HTTPAdapter
-from requests.packages.urllib3.util.retry import Retry
+from requests.adapters import HTTPAdapter, Retry
 
 # import utils packages
 from .utils import logger_handler, delete_file_safe
@@ -48,7 +47,7 @@ class TimeoutHTTPAdapter(HTTPAdapter):
     A custom Transport Adapter with default timeouts
     """
 
-    def __init__(self, *args, **kwargs): 
+    def __init__(self, *args, **kwargs):
         self.timeout = DEFAULT_TIMEOUT
         if "timeout" in kwargs:
             self.timeout = kwargs["timeout"]
@@ -215,7 +214,11 @@ def download_ffmpeg_binaries(path, os_windows=False, os_bit=""):
                     http.mount("https://", adapter)
                     response = http.get(file_url, stream=True)
                     response.raise_for_status()
-                    total_length = response.headers.get("content-length")
+                    total_length = (
+                        response.headers.get("content-length")
+                        if "content-length" in response.headers
+                        else len(response.content)
+                    )
                     assert not (
                         total_length is None
                     ), "[Helper:ERROR] :: Failed to retrieve files, check your Internet connectivity!"
@@ -339,14 +342,15 @@ def get_supported_demuxers(path):
 
     **Returns:** List of supported demuxers.
     """
+    # extract and clean FFmpeg output
     demuxers = check_sp_output([path, "-hide_banner", "-demuxers"])
     splitted = [x.decode("utf-8").strip() for x in demuxers.split(b"\n")]
-    supported_demuxers = splitted[splitted.index("--") + 1 : len(splitted) - 1]
-    # compile regex
-    finder = re.compile(r"\s\s[a-z0-9_,-]+\s+")
-    # find all outputs
-    outputs = finder.findall("\n".join(supported_demuxers))
-    # return output findings
+    split_index = [idx for idx, s in enumerate(splitted) if "--" in s][0]
+    supported_demuxers = splitted[split_index + 1 : len(splitted) - 1]
+    # search all demuxers
+    outputs = [re.search(r"\s[a-z0-9_,-]{2,}\s", d) for d in supported_demuxers]
+    outputs = [o.group(0) for o in outputs if o]
+    # return demuxers output
     return [o.strip() if not ("," in o) else o.split(",")[-1].strip() for o in outputs]
 
 
@@ -515,10 +519,12 @@ def extract_device_n_demuxer(path, machine_OS=None, verbose=False):
                 logger.info(
                     "[{}]: {}".format(
                         idx,
-                        dev
-                        if machine_OS != "Linux"
-                        else "{} at path `{}`".format(
-                            next(iter(dev.values()))[0], next(iter(dev.keys()))
+                        (
+                            dev
+                            if machine_OS != "Linux"
+                            else "{} at path `{}`".format(
+                                next(iter(dev.values()))[0], next(iter(dev.keys()))
+                            )
                         ),
                     )
                 )
@@ -629,8 +635,11 @@ def is_valid_url(path, url=None, verbose=False):
     protocols = check_sp_output([path, "-hide_banner", "-protocols"])
     splitted = [x.decode("utf-8").strip() for x in protocols.split(b"\n")]
     supported_protocols = splitted[splitted.index("Output:") + 1 : len(splitted) - 1]
-    # rtsp is a demuxer somehow
-    supported_protocols += ["rtsp"] if "rtsp" in get_supported_demuxers(path) else []
+    # RTSP is a demuxer somehow
+    # support both RTSP and RTSPS(over SSL)
+    supported_protocols += (
+        ["rtsp", "rtsps"] if "rtsp" in get_supported_demuxers(path) else []
+    )
     # Test and return result whether scheme is supported
     if extracted_scheme_url and extracted_scheme_url in supported_protocols:
         verbose and logger.debug(
@@ -674,7 +683,7 @@ def check_sp_output(*args, **kwargs):
     retcode = process.poll()
     # handle return code
     if retcode and not (retrieve_stderr):
-        logger.error("[Pipline-Error] :: {}".format(output.decode("utf-8")))
+        logger.error("[Pipeline-Error] :: {}".format(output.decode("utf-8")))
         cmd = kwargs.get("args")
         if cmd is None:
             cmd = args[0]
@@ -683,7 +692,7 @@ def check_sp_output(*args, **kwargs):
         raise error
     # raise error if no output
     bool(output) or bool(stderr) or logger.error(
-        "[Pipline-Error] :: Pipline failed to exact any data from command: {}!".format(
+        "[Pipeline-Error] :: Pipeline failed to exact any data from command: {}!".format(
             args[0] if args else []
         )
     )

deffcode/sourcer.py

@@ -87,7 +87,7 @@ class Sourcer:
             verbose (bool): enables/disables verbose.
             sourcer_params (dict): provides the flexibility to control supported internal and FFmpeg parameters.
         """
-        # checks if machine in-use is running windows os or not
+        # checks machine OS
         self.__machine_OS = platform.system()
 
         # define internal parameters
@@ -100,9 +100,11 @@ class Sourcer:
 
         # sanitize sourcer_params
         self.__sourcer_params = {
-            str(k).strip(): str(v).strip()
-            if not isinstance(v, (dict, list, int, float, tuple))
-            else v
+            str(k).strip(): (
+                str(v).strip()
+                if not isinstance(v, (dict, list, int, float, tuple))
+                else v
+            )
             for k, v in sourcer_params.items()
         }
 
@@ -199,6 +201,7 @@ class Sourcer:
 
         # various source stream params
         self.__default_video_resolution = ""  # handles stream resolution
+        self.__default_video_orientation = ""  # handles stream's video orientation
         self.__default_video_framerate = ""  # handles stream framerate
         self.__default_video_bitrate = ""  # handles stream's video bitrate
         self.__default_video_pixfmt = ""  # handles stream's video pixfmt
@@ -218,6 +221,7 @@ class Sourcer:
         self.__output_frames_resolution = ""  # handles output stream resolution
         self.__output_framerate = ""  # handles output stream framerate
         self.__output_frames_pixfmt = ""  # handles output frame pixel format
+        self.__output_orientation = ""  # handles output frame orientation
 
         # check whether metadata probed or not?
         self.__metadata_probed = False
@@ -251,6 +255,7 @@ class Sourcer:
         if video_rfparams:
             self.__default_video_resolution = video_rfparams["resolution"]
             self.__default_video_framerate = video_rfparams["framerate"]
+            self.__default_video_orientation = video_rfparams["orientation"]
 
         # parse output parameters through filters (if available)
         if not (self.__metadata_output is None):
@@ -261,6 +266,7 @@ class Sourcer:
             if out_video_rfparams:
                 self.__output_frames_resolution = out_video_rfparams["resolution"]
                 self.__output_framerate = out_video_rfparams["framerate"]
+                self.__output_orientation = out_video_rfparams["orientation"]
             # parse output pixel-format
             self.__output_frames_pixfmt = self.__extract_video_pixfmt(
                 default_stream=default_stream_indexes[0], extract_output=True
@@ -357,11 +363,18 @@ class Sourcer:
                 "source_video_resolution": self.__default_video_resolution,
                 "source_video_pixfmt": self.__default_video_pixfmt,
                 "source_video_framerate": self.__default_video_framerate,
+                "source_video_orientation": self.__default_video_orientation,
                 "source_video_decoder": self.__default_video_decoder,
                 "source_duration_sec": self.__default_source_duration,
                 "approx_video_nframes": (
                     int(self.__approx_video_nframes)
                     if self.__approx_video_nframes
+                    and not any(
+                        "loop" in x for x in self.__ffmpeg_prefixes
+                    )  # check if any loops in prefix
+                    and not any(
+                        "loop" in x for x in dict2Args(self.__sourcer_params)
+                    )  # check if any loops in filters
                     else None
                 ),
                 "source_video_bitrate": self.__default_video_bitrate,
@@ -379,6 +392,7 @@ class Sourcer:
                     "output_frames_resolution": self.__output_frames_resolution,
                     "output_frames_pixfmt": self.__output_frames_pixfmt,
                     "output_framerate": self.__output_framerate,
+                    "output_orientation": self.__output_orientation,
                 }
             )
         else:
@@ -391,6 +405,7 @@ class Sourcer:
                     "output_frames_resolution": self.__default_video_resolution,
                     "output_frames_pixfmt": self.__default_video_pixfmt,
                     "output_framerate": self.__default_video_framerate,
+                    "output_orientation": self.__default_video_orientation,
                 }
             )
         # log it
@@ -483,14 +498,18 @@ class Sourcer:
                     self.__source_demuxer = source_demuxer
                     self.__verbose_logs and logger.debug(
                         "Successfully configured device `{}` at index `{}` with demuxer `{}`.".format(
-                            self.__extracted_devices_list[index]
-                            if self.__machine_OS != "Linux"
-                            else next(
-                                iter(self.__extracted_devices_list[index].values())
-                            )[0],
-                            index
-                            if index >= 0
-                            else len(self.__extracted_devices_list) + index,
+                            (
+                                self.__extracted_devices_list[index]
+                                if self.__machine_OS != "Linux"
+                                else next(
+                                    iter(self.__extracted_devices_list[index].values())
+                                )[0]
+                            ),
+                            (
+                                index
+                                if index >= 0
+                                else len(self.__extracted_devices_list) + index
+                            ),
                             self.__source_demuxer,
                         )
                     )
@@ -590,9 +609,11 @@ class Sourcer:
         ]
         if video_bitrate_text:
             selected_stream = video_bitrate_text[
-                default_stream
-                if default_stream > 0 and default_stream < len(video_bitrate_text)
-                else 0
+                (
+                    default_stream
+                    if default_stream > 0 and default_stream < len(video_bitrate_text)
+                    else 0
+                )
             ]
             filtered_bitrate = re.findall(
                 r",\s[0-9]+\s\w\w[\/]s", selected_stream.strip()
@@ -624,9 +645,11 @@ class Sourcer:
         ]
         if meta_text:
             selected_stream = meta_text[
-                default_stream
-                if default_stream > 0 and default_stream < len(meta_text)
-                else 0
+                (
+                    default_stream
+                    if default_stream > 0 and default_stream < len(meta_text)
+                    else 0
+                )
             ]
             filtered_pixfmt = re.findall(
                 r"Video:\s[a-z0-9_-]*", selected_stream.strip()
@@ -660,9 +683,11 @@ class Sourcer:
         )
         if meta_text:
             selected_stream = meta_text[
-                default_stream
-                if default_stream > 0 and default_stream < len(meta_text)
-                else 0
+                (
+                    default_stream
+                    if default_stream > 0 and default_stream < len(meta_text)
+                    else 0
+                )
             ]
             filtered_pixfmt = re.findall(
                 r",\s[a-z][a-z0-9_-]*", selected_stream.strip()
@@ -689,9 +714,11 @@ class Sourcer:
         result = {}
         if meta_text:
             selected_stream = meta_text[
-                default_stream
-                if default_stream > 0 and default_stream < len(meta_text)
-                else 0
+                (
+                    default_stream
+                    if default_stream > 0 and default_stream < len(meta_text)
+                    else 0
+                )
             ]
             # filter data
             filtered_audio_bitrate = re.findall(
@@ -719,7 +746,7 @@ class Sourcer:
 
     def __extract_resolution_framerate(self, default_stream=0, extract_output=False):
         """
-        This Internal method parses default video-stream resolution and framerate from metadata.
+        This Internal method parses default video-stream resolution, orientation, and framerate from metadata.
 
         Parameters:
             default_stream (int): selects specific audio-stream in case of multiple ones.
@@ -742,12 +769,30 @@ class Sourcer:
                 if all(x in line for x in identifiers)
             ]
         )
+        # extract video orientation metadata if available
+        identifiers_orientation = ["displaymatrix:", "rotation"]
+        meta_text_orientation = (
+            [
+                line.strip()
+                for line in self.__ffsp_output.split("\n")
+                if all(x in line for x in identifiers_orientation)
+            ]
+            if not extract_output
+            else [
+                line.strip()
+                for line in self.__metadata_output.split("\n")
+                if all(x in line for x in identifiers_orientation)
+            ]
+        )
+        # use metadata if available
         result = {}
         if meta_text:
             selected_stream = meta_text[
-                default_stream
-                if default_stream > 0 and default_stream < len(meta_text)
-                else 0
+                (
+                    default_stream
+                    if default_stream > 0 and default_stream < len(meta_text)
+                    else 0
+                )
             ]
 
             # filter data
@@ -775,7 +820,23 @@ class Sourcer:
             if filtered_resolution:
                 result["resolution"] = [int(x) for x in filtered_resolution[0]]
 
-        return result if result and (len(result) == 2) else {}
+            # extract video orientation metadata
+            if meta_text_orientation:
+                selected_stream = meta_text_orientation[
+                    (
+                        default_stream
+                        if default_stream > 0 and default_stream < len(meta_text)
+                        else 0
+                    )
+                ]
+                filtered_orientation = re.findall(
+                    r"[-]?\d+\.\d+", selected_stream.strip()
+                )
+                result["orientation"] = float(filtered_orientation[0])
+            else:
+                result["orientation"] = 0.0
+
+        return result if result and (len(result) == 3) else {}
 
     def __extract_duration(self, inseconds=True):
         """

deffcode/version.py

@@ -1 +1 @@
-__version__ = "0.2.4"
+__version__ = "0.2.6"