vidformer 0.7.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

vidformer/__init__.py

@@ -1,5 +1,5 @@
 """A Python library for creating and viewing videos with vidformer."""
 
-__version__ = "0.7.0"
+__version__ = "0.9.0"
 
 from .vf import *

vidformer/cv2/vf_cv2.py

@@ -11,6 +11,7 @@ vidformer.cv2 is the cv2 frontend for [vidformer](https://github.com/ixlab/vidfo
 """
 
 from .. import vf
+from .. import igni
 
 try:
     import cv2 as _opencv2
@@ -22,6 +23,8 @@ import numpy as np
 import uuid
 from fractions import Fraction
 from bisect import bisect_right
+import zlib
+import re
 
 CAP_PROP_POS_MSEC = 0
 CAP_PROP_POS_FRAMES = 1
@@ -46,6 +49,9 @@ LINE_8 = 8
 LINE_AA = 16
 
 _inline_mat = vf.Filter("_inline_mat")
+_slice_mat = vf.Filter("_slice_mat")
+_slice_write_mat = vf.Filter("_slice_write_mat")
+
 
 _filter_scale = vf.Filter("Scale")
 _filter_rectangle = vf.Filter("cv2.rectangle")
@@ -75,10 +81,10 @@ def _server():
     return _global_cv2_server
 
 
-def set_cv2_server(server: vf.YrdenServer):
+def set_cv2_server(server):
     """Set the server to use for the cv2 frontend."""
     global _global_cv2_server
-    assert isinstance(server, vf.YrdenServer)
+    assert isinstance(server, vf.YrdenServer) or isinstance(server, igni.IgniServer)
     _global_cv2_server = server
 
 
@@ -119,43 +125,147 @@ class Frame:
         frame = frame[:, :, ::-1]  # convert RGB to BGR
         return frame
 
+    def __getitem__(self, key):
+        if not isinstance(key, tuple):
+            raise NotImplementedError("Only 2D slicing is supported")
+
+        if len(key) != 2:
+            raise NotImplementedError("Only 2D slicing is supported")
+
+        if not all(isinstance(x, slice) for x in key):
+            raise NotImplementedError("Only 2D slicing is supported")
+
+        miny = key[0].start if key[0].start is not None else 0
+        maxy = key[0].stop if key[0].stop is not None else self.shape[0]
+        minx = key[1].start if key[1].start is not None else 0
+        maxx = key[1].stop if key[1].stop is not None else self.shape[1]
+
+        # handle negative indices
+        if miny < 0:
+            miny = self.shape[0] + miny
+        if maxy < 0:
+            maxy = self.shape[0] + maxy
+        if minx < 0:
+            minx = self.shape[1] + minx
+        if maxx < 0:
+            maxx = self.shape[1] + maxx
+
+        if (
+            maxy <= miny
+            or maxx <= minx
+            or miny < 0
+            or minx < 0
+            or maxy > self.shape[0]
+            or maxx > self.shape[1]
+        ):
+            raise NotImplementedError("Invalid slice")
+
+        f = _slice_mat(self._f, miny, maxy, minx, maxx)
+        fmt = self._fmt.copy()
+        fmt["width"] = maxx - minx
+        fmt["height"] = maxy - miny
+        return Frame(f, fmt)
+
+    def __setitem__(self, key, value):
+        value = frameify(value, "value")
+
+        if not isinstance(key, tuple):
+            raise NotImplementedError("Only 2D slicing is supported")
+
+        if len(key) != 2:
+            raise NotImplementedError("Only 2D slicing is supported")
+
+        if not all(isinstance(x, slice) for x in key):
+            raise NotImplementedError("Only 2D slicing is supported")
+
+        miny = key[0].start if key[0].start is not None else 0
+        maxy = key[0].stop if key[0].stop is not None else self.shape[0]
+        minx = key[1].start if key[1].start is not None else 0
+        maxx = key[1].stop if key[1].stop is not None else self.shape[1]
+
+        # handle negative indices
+        if miny < 0:
+            miny = self.shape[0] + miny
+        if maxy < 0:
+            maxy = self.shape[0] + maxy
+        if minx < 0:
+            minx = self.shape[1] + minx
+        if maxx < 0:
+            maxx = self.shape[1] + maxx
+
+        if (
+            maxy <= miny
+            or maxx <= minx
+            or miny < 0
+            or minx < 0
+            or maxy > self.shape[0]
+            or maxx > self.shape[1]
+        ):
+            raise NotImplementedError("Invalid slice")
+
+        if value.shape[0] != maxy - miny or value.shape[1] != maxx - minx:
+            raise NotImplementedError("Shape mismatch")
+
+        self._mut()
+        value._mut()
+
+        self._f = _slice_write_mat(self._f, value._f, miny, maxy, minx, maxx)
+
 
 def _inline_frame(arr):
-    assert arr.dtype == np.uint8
-    assert arr.ndim == 3
-    assert arr.shape[2] == 3
+    if arr.dtype != np.uint8:
+        raise Exception("Only uint8 arrays are supported")
+    if len(arr.shape) != 3:
+        raise Exception("Only 3D arrays are supported")
+    if arr.shape[2] != 3:
+        raise Exception("To inline a frame, the array must have 3 channels")
 
-    # convert BGR to RGB
     arr = arr[:, :, ::-1]
+    if not arr.flags["C_CONTIGUOUS"]:
+        arr = np.ascontiguousarray(arr)
 
     width = arr.shape[1]
     height = arr.shape[0]
     pix_fmt = "rgb24"
 
-    f = _inline_mat(arr.tobytes(), width=width, height=height, pix_fmt=pix_fmt)
-    fmt = {"width": width, "height": height, "pix_fmt": pix_fmt}
-    return Frame(f, fmt)
+    data_gzip = zlib.compress(memoryview(arr), level=1)
 
+    f = _inline_mat(
+        data_gzip, width=width, height=height, pix_fmt=pix_fmt, compression="zlib"
+    )
+    fmt = {"width": width, "height": height, "pix_fmt": pix_fmt}
 
-def _framify(obj, field_name=None):
-    if isinstance(obj, Frame):
-        return obj
-    elif isinstance(obj, np.ndarray):
-        return _inline_frame(obj)
-    else:
-        if field_name is not None:
-            raise Exception(
-                f"Unsupported type for field {field_name}, expected Frame or np.ndarray"
-            )
-        else:
-            raise Exception("Unsupported type, expected Frame or np.ndarray")
+    # Return the resulting Frame object
+    return Frame(f, fmt)
 
 
 class VideoCapture:
     def __init__(self, path):
-        self._path = path
         server = _server()
-        self._source = vf.Source(server, str(uuid.uuid4()), path, 0)
+        if type(path) == str:
+            if isinstance(server, vf.YrdenServer):
+                self._path = path
+                self._source = vf.Source(server, str(uuid.uuid4()), path, 0)
+            else:
+                assert isinstance(server, igni.IgniServer)
+                match = re.match(r"(http|https)://([^/]+)(.*)", path)
+                if match is not None:
+                    endpoint = f"{match.group(1)}://{match.group(2)}"
+                    path = match.group(3)
+                    if path.startswith("/"):
+                        path = path[1:]
+                    self._path = path
+                    self._source = server.source(
+                        path, 0, "http", {"endpoint": endpoint}
+                    )
+                else:
+                    raise Exception(
+                        "Using a VideoCapture source by name only works with http(s) URLs. You need to pass an IgniSource instead."
+                    )
+        elif isinstance(path, igni.IgniSource):
+            assert isinstance(server, igni.IgniServer)
+            self._path = path._name
+            self._source = path
         self._next_frame_idx = 0
 
     def isOpened(self):
@@ -188,7 +298,7 @@ class VideoCapture:
             raise Exception(f"Unsupported property {prop}")
 
     def read(self):
-        if self._next_frame_idx >= len(self._source.ts()):
+        if self._next_frame_idx >= len(self._source):
             return False, None
         frame = self._source.iloc[self._next_frame_idx]
         self._next_frame_idx += 1
@@ -200,6 +310,107 @@ class VideoCapture:
 
 
 class VideoWriter:
+    def __init__(self, *args, **kwargs):
+        server = _server()
+        if isinstance(server, vf.YrdenServer):
+            self._writer = _YrdenVideoWriter(*args, **kwargs)
+        elif isinstance(server, igni.IgniServer):
+            self._writer = _IgniVideoWriter(*args, **kwargs)
+        else:
+            raise Exception("Unsupported server type")
+
+    def spec(self):
+        return self._writer.spec()
+
+    def write(self, *args, **kwargs):
+        return self._writer.write(*args, **kwargs)
+
+    def release(self, *args, **kwargs):
+        return self._writer.release(*args, **kwargs)
+
+    def spec(self, *args, **kwargs):
+        return self._writer.spec(*args, **kwargs)
+
+
+class _IgniVideoWriter:
+    def __init__(
+        self,
+        path,
+        _fourcc,
+        fps,
+        size,
+        batch_size=1024,
+        vod_segment_length=Fraction(2, 1),
+    ):
+        server = _server()
+        assert isinstance(server, igni.IgniServer)
+        if path is not None:
+            raise Exception(
+                "Igni does not support writing to a file. VideoWriter path must be None"
+            )
+        if isinstance(fps, int):
+            self._f_time = Fraction(1, fps)
+        elif isinstance(fps, Fraction):
+            self._f_time = 1 / fps
+        else:
+            raise Exception("fps must be an integer or a Fraction")
+
+        assert isinstance(size, tuple) or isinstance(size, list)
+        assert len(size) == 2
+        width, height = size
+        self._spec = server.create_spec(
+            width, height, "yuv420p", vod_segment_length, 1 / self._f_time
+        )
+        self._batch_size = batch_size
+        self._idx = 0
+        self._frame_buffer = []
+
+    def _flush(self, terminal=False):
+        server = _server()
+        server.push_spec_part(
+            self._spec,
+            self._idx - len(self._frame_buffer),
+            self._frame_buffer,
+            terminal=terminal,
+        )
+        self._frame_buffer = []
+
+    def _explicit_terminate(self):
+        server = _server()
+        server.push_spec_part(self._spec._id, self._idx, [], terminal=True)
+
+    def spec(self):
+        return self._spec
+
+    def write(self, frame):
+        if frame is not None:
+            frame = frameify(frame, "frame")
+            if frame._fmt["width"] != self._spec._fmt["width"]:
+                raise Exception(
+                    f"Frame type error; expected width {self._spec._fmt['width']}, got {frame._fmt['width']}"
+                )
+            if frame._fmt["height"] != self._spec._fmt["height"]:
+                raise Exception(
+                    f"Frame type error; expected height {self._spec._fmt['height']}, got {frame._fmt['height']}"
+                )
+            if frame._fmt["pix_fmt"] != self._spec._fmt["pix_fmt"]:
+                f_obj = _filter_scale(frame._f, pix_fmt=self._spec._fmt["pix_fmt"])
+                frame = Frame(f_obj, self._spec._fmt)
+        t = self._f_time * self._idx
+        self._frame_buffer.append((t, frame._f if frame is not None else None))
+        self._idx += 1
+
+        if len(self._frame_buffer) >= self._batch_size:
+            self._flush()
+
+    def release(self):
+        if len(self._frame_buffer) > 0:
+            self._flush(True)
+        else:
+            self._explicit_terminate()
+
+
+class _YrdenVideoWriter:
     def __init__(self, path, fourcc, fps, size):
         assert isinstance(fourcc, VideoWriter_fourcc)
         if path is not None and not isinstance(path, str):
@@ -213,7 +424,7 @@ class VideoWriter:
         self._pix_fmt = "yuv420p"
 
     def write(self, frame):
-        frame = _framify(frame, "frame")
+        frame = frameify(frame, "frame")
 
         if frame._fmt["pix_fmt"] != self._pix_fmt:
             f_obj = _filter_scale(frame._f, pix_fmt=self._pix_fmt)
@@ -245,6 +456,24 @@ class VideoWriter_fourcc:
         self._args = args
 
 
+def frameify(obj, field_name=None):
+    """
+    Turn an object (e.g., ndarray) into a Frame.
+    """
+
+    if isinstance(obj, Frame):
+        return obj
+    elif isinstance(obj, np.ndarray):
+        return _inline_frame(obj)
+    else:
+        if field_name is not None:
+            raise Exception(
+                f"Unsupported type for field {field_name}, expected Frame or np.ndarray"
+            )
+        else:
+            raise Exception("Unsupported type, expected Frame or np.ndarray")
+
+
 def imread(path, *args):
     if len(args) > 0:
         raise NotImplementedError("imread does not support additional arguments")
@@ -260,7 +489,7 @@ def imwrite(path, img, *args):
     if len(args) > 0:
         raise NotImplementedError("imwrite does not support additional arguments")
 
-    img = _framify(img)
+    img = frameify(img)
 
     fmt = img._fmt.copy()
     width = fmt["width"]
@@ -300,13 +529,18 @@ def vidplay(video, *args, **kwargs):
     Args:
         video: one of [vidformer.Spec, vidformer.Source, vidformer.cv2.VideoWriter]
     """
-
     if isinstance(video, vf.Spec):
         return video.play(_server(), *args, **kwargs)
     elif isinstance(video, vf.Source):
         return video.play(_server(), *args, **kwargs)
     elif isinstance(video, VideoWriter):
+        return vidplay(video._writer, *args, **kwargs)
+    elif isinstance(video, _YrdenVideoWriter):
         return video.spec().play(_server(), *args, **kwargs)
+    elif isinstance(video, _IgniVideoWriter):
+        return video._spec.play(*args, **kwargs)
+    elif isinstance(video, igni.IgniSpec):
+        return video.play(*args, **kwargs)
     else:
         raise Exception("Unsupported video type to vidplay")
 
@@ -316,7 +550,7 @@ def rectangle(img, pt1, pt2, color, thickness=None, lineType=None, shift=None):
     cv.rectangle(	img, pt1, pt2, color[, thickness[, lineType[, shift]]]	)
     """
 
-    img = _framify(img)
+    img = frameify(img)
     img._mut()
 
     assert len(pt1) == 2
@@ -360,7 +594,7 @@ def putText(
     cv.putText(	img, text, org, fontFace, fontScale, color[, thickness[, lineType[, bottomLeftOrigin]]]	)
     """
 
-    img = _framify(img)
+    img = frameify(img)
     img._mut()
 
     assert isinstance(text, str)
@@ -399,7 +633,7 @@ def arrowedLine(
     """
     cv.arrowedLine(	img, pt1, pt2, color[, thickness[, line_type[, shift[, tipLength]]]]	)
     """
-    img = _framify(img)
+    img = frameify(img)
     img._mut()
 
     assert len(pt1) == 2
@@ -433,7 +667,7 @@ def arrowedLine(
 
 
 def line(img, pt1, pt2, color, thickness=None, lineType=None, shift=None):
-    img = _framify(img)
+    img = frameify(img)
     img._mut()
 
     assert len(pt1) == 2
@@ -463,7 +697,7 @@ def line(img, pt1, pt2, color, thickness=None, lineType=None, shift=None):
 
 
 def circle(img, center, radius, color, thickness=None, lineType=None, shift=None):
-    img = _framify(img)
+    img = frameify(img)
     img._mut()
 
     assert len(center) == 2
@@ -514,8 +748,8 @@ def addWeighted(src1, alpha, src2, beta, gamma, dst=None, dtype=-1):
     """
     cv.addWeighted(	src1, alpha, src2, beta, gamma[, dst[, dtype]]	) -> 	dst
     """
-    src1 = _framify(src1, "src1")
-    src2 = _framify(src2, "src2")
+    src1 = frameify(src1, "src1")
+    src2 = frameify(src2, "src2")
     src1._mut()
     src2._mut()
 

vidformer/igni/__init__.py

@@ -0,0 +1 @@
+from .vf_igni import *

vidformer/igni/vf_igni.py

@@ -0,0 +1,285 @@
+from .. import vf
+
+import requests
+from fractions import Fraction
+from urllib.parse import urlparse
+
+
+class IgniServer:
+    def __init__(self, endpoint: str, api_key: str):
+        if not endpoint.startswith("http://") and not endpoint.startswith("https://"):
+            raise Exception("Endpoint must start with http:// or https://")
+        if endpoint.endswith("/"):
+            raise Exception("Endpoint must not end with /")
+        self._endpoint = endpoint
+
+        self._api_key = api_key
+        response = requests.get(
+            f"{self._endpoint}/auth",
+            headers={"Authorization": f"Bearer {self._api_key}"},
+        )
+        if not response.ok:
+            raise Exception(response.text)
+        response = response.json()
+        assert response["status"] == "ok"
+
+    def get_source(self, id: str):
+        assert type(id) == str
+        response = requests.get(
+            f"{self._endpoint}/source/{id}",
+            headers={"Authorization": f"Bearer {self._api_key}"},
+        )
+        if not response.ok:
+            raise Exception(response.text)
+        response = response.json()
+        return IgniSource(response["id"], response)
+
+    def list_sources(self):
+        response = requests.get(
+            f"{self._endpoint}/source",
+            headers={"Authorization": f"Bearer {self._api_key}"},
+        )
+        if not response.ok:
+            raise Exception(response.text)
+        response = response.json()
+        return response
+
+    def delete_source(self, id: str):
+        assert type(id) == str
+        response = requests.delete(
+            f"{self._endpoint}/source/{id}",
+            headers={"Authorization": f"Bearer {self._api_key}"},
+        )
+        if not response.ok:
+            raise Exception(response.text)
+        response = response.json()
+        assert response["status"] == "ok"
+
+    def search_source(self, name, stream_idx, storage_service, storage_config):
+        assert type(name) == str
+        assert type(stream_idx) == int
+        assert type(storage_service) == str
+        assert type(storage_config) == dict
+        for k, v in storage_config.items():
+            assert type(k) == str
+            assert type(v) == str
+        req = {
+            "name": name,
+            "stream_idx": stream_idx,
+            "storage_service": storage_service,
+            "storage_config": storage_config,
+        }
+        response = requests.post(
+            f"{self._endpoint}/source/search",
+            json=req,
+            headers={"Authorization": f"Bearer {self._api_key}"},
+        )
+        if not response.ok:
+            raise Exception(response.text)
+        response = response.json()
+        return response
+
+    def create_source(self, name, stream_idx, storage_service, storage_config):
+        assert type(name) == str
+        assert type(stream_idx) == int
+        assert type(storage_service) == str
+        assert type(storage_config) == dict
+        for k, v in storage_config.items():
+            assert type(k) == str
+            assert type(v) == str
+        req = {
+            "name": name,
+            "stream_idx": stream_idx,
+            "storage_service": storage_service,
+            "storage_config": storage_config,
+        }
+        response = requests.post(
+            f"{self._endpoint}/source",
+            json=req,
+            headers={"Authorization": f"Bearer {self._api_key}"},
+        )
+        if not response.ok:
+            raise Exception(response.text)
+        response = response.json()
+        assert response["status"] == "ok"
+        id = response["id"]
+        return self.get_source(id)
+
+    def source(self, name, stream_idx, storage_service, storage_config):
+        """Convenience function for accessing sources.
+
+        Tries to find a source with the given name, stream_idx, storage_service, and storage_config.
+        If no source is found, creates a new source with the given parameters.
+        """
+
+        sources = self.search_source(name, stream_idx, storage_service, storage_config)
+        if len(sources) == 0:
+            return self.create_source(name, stream_idx, storage_service, storage_config)
+        return self.get_source(sources[0])
+
+    def get_spec(self, id: str):
+        assert type(id) == str
+        response = requests.get(
+            f"{self._endpoint}/spec/{id}",
+            headers={"Authorization": f"Bearer {self._api_key}"},
+        )
+        if not response.ok:
+            raise Exception(response.text)
+        response = response.json()
+        return IgniSpec(response["id"], response)
+
+    def list_specs(self):
+        response = requests.get(
+            f"{self._endpoint}/spec",
+            headers={"Authorization": f"Bearer {self._api_key}"},
+        )
+        if not response.ok:
+            raise Exception(response.text)
+        response = response.json()
+        return response
+
+    def create_spec(
+        self,
+        width,
+        height,
+        pix_fmt,
+        vod_segment_length,
+        frame_rate,
+        ready_hook=None,
+        steer_hook=None,
+    ):
+        assert type(width) == int
+        assert type(height) == int
+        assert type(pix_fmt) == str
+        assert type(vod_segment_length) == Fraction
+        assert type(frame_rate) == Fraction
+        assert type(ready_hook) == str or ready_hook is None
+        assert type(steer_hook) == str or steer_hook is None
+
+        req = {
+            "width": width,
+            "height": height,
+            "pix_fmt": pix_fmt,
+            "vod_segment_length": [
+                vod_segment_length.numerator,
+                vod_segment_length.denominator,
+            ],
+            "frame_rate": [frame_rate.numerator, frame_rate.denominator],
+            "ready_hook": ready_hook,
+            "steer_hook": steer_hook,
+        }
+        response = requests.post(
+            f"{self._endpoint}/spec",
+            json=req,
+            headers={"Authorization": f"Bearer {self._api_key}"},
+        )
+        if not response.ok:
+            raise Exception(response.text)
+        response = response.json()
+        assert response["status"] == "ok"
+        return self.get_spec(response["id"])
+
+    def delete_spec(self, id: str):
+        assert type(id) == str
+        response = requests.delete(
+            f"{self._endpoint}/spec/{id}",
+            headers={"Authorization": f"Bearer {self._api_key}"},
+        )
+        if not response.ok:
+            raise Exception(response.text)
+        response = response.json()
+        assert response["status"] == "ok"
+
+    def push_spec_part(self, spec_id, pos, frames, terminal):
+        if type(spec_id) == IgniSpec:
+            spec_id = spec_id._id
+        assert type(spec_id) == str
+        assert type(pos) == int
+        assert type(frames) == list
+        assert type(terminal) == bool
+
+        req_frames = []
+        for frame in frames:
+            assert type(frame) == tuple
+            assert len(frame) == 2
+            t = frame[0]
+            f = frame[1]
+            assert type(t) == Fraction
+            assert f is None or type(f) == vf.SourceExpr or type(f) == vf.FilterExpr
+            req_frames.append(
+                [
+                    [t.numerator, t.denominator],
+                    f._to_json_spec() if f is not None else None,
+                ]
+            )
+
+        req = {
+            "pos": pos,
+            "frames": req_frames,
+            "terminal": terminal,
+        }
+        response = requests.post(
+            f"{self._endpoint}/spec/{spec_id}/part",
+            json=req,
+            headers={"Authorization": f"Bearer {self._api_key}"},
+        )
+        if not response.ok:
+            raise Exception(response.text)
+        response = response.json()
+        assert response["status"] == "ok"
+
+
+class IgniSource:
+    def __init__(self, id, src):
+        self._name = id
+        self._fmt = {
+            "width": src["width"],
+            "height": src["height"],
+            "pix_fmt": src["pix_fmt"],
+        }
+        self._ts = [Fraction(x[0], x[1]) for x in src["ts"]]
+        self.iloc = vf.SourceILoc(self)
+
+    def id(self):
+        return self._name
+
+    def fmt(self):
+        return {**self._fmt}
+
+    def ts(self):
+        return self._ts.copy()
+
+    def __len__(self):
+        return len(self._ts)
+
+    def __getitem__(self, idx):
+        if type(idx) != Fraction:
+            raise Exception("Source index must be a Fraction")
+        return vf.SourceExpr(self, idx, False)
+
+    def __repr__(self):
+        return f"IgniSource({self._name})"
+
+
+class IgniSpec:
+    def __init__(self, id, src):
+        self._id = id
+        self._fmt = {
+            "width": src["width"],
+            "height": src["height"],
+            "pix_fmt": src["pix_fmt"],
+        }
+        self._vod_endpoint = src["vod_endpoint"]
+        parsed_url = urlparse(self._vod_endpoint)
+        self._hls_js_url = f"{parsed_url.scheme}://{parsed_url.netloc}/hls.js"
+
+    def id(self):
+        return self._id
+
+    def play(self, *args, **kwargs):
+        url = f"{self._vod_endpoint}playlist.m3u8"
+        status_url = f"{self._vod_endpoint}status"
+        hls_js_url = self._hls_js_url
+        return vf._play(
+            self._id, url, hls_js_url, *args, **kwargs, status_url=status_url
+        )

vidformer/vf.py

@@ -52,6 +52,134 @@ def _check_hls_link_exists(url, max_attempts=150, delay=0.1):
     return None
 
 
+def _play(namespace, hls_video_url, hls_js_url, method="html", status_url=None):
+    # The namespace is so multiple videos in one tab don't conflict
+
+    if method == "html":
+        from IPython.display import HTML
+
+        if not status_url:
+            html_code = f"""
+<!DOCTYPE html>
+<html>
+<head>
+    <title>HLS Video Player</title>
+    <!-- Include hls.js library -->
+    <script src="{hls_js_url}"></script>
+</head>
+<body>
+    <video id="video-{namespace}" controls width="640" height="360" autoplay></video>
+    <script>
+        var video = document.getElementById('video-{namespace}');
+        var videoSrc = '{hls_video_url}';
+
+        if (Hls.isSupported()) {{
+            var hls = new Hls();
+            hls.loadSource(videoSrc);
+            hls.attachMedia(video);
+            hls.on(Hls.Events.MANIFEST_PARSED, function() {{
+                video.play();
+            }});
+        }} else if (video.canPlayType('application/vnd.apple.mpegurl')) {{
+            video.src = videoSrc;
+            video.addEventListener('loadedmetadata', function() {{
+                video.play();
+            }});
+        }} else {{
+            console.error('This browser does not appear to support HLS.');
+        }}
+    </script>
+</body>
+</html>
+"""
+            return HTML(data=html_code)
+        else:
+            html_code = f"""
+<!DOCTYPE html>
+<html>
+<head>
+    <title>HLS Video Player</title>
+    <script src="{hls_js_url}"></script>
+</head>
+<body>
+    <div id="container"></div>
+    <script>
+        var statusUrl = '{status_url}';
+        var videoSrc = '{hls_video_url}';
+        var videoNamespace = '{namespace}';
+
+        function showWaiting() {{
+            document.getElementById('container').textContent = 'Waiting...';
+            pollStatus();
+        }}
+
+        function pollStatus() {{
+            setTimeout(function() {{
+                fetch(statusUrl)
+                    .then(r => r.json())
+                    .then(res => {{
+                        if (res.ready) {{
+                            document.getElementById('container').textContent = '';
+                            attachHls();
+                        }} else {{
+                            pollStatus();
+                        }}
+                    }})
+                    .catch(e => {{
+                        console.error(e);
+                        pollStatus();
+                    }});
+            }}, 250);
+        }}
+
+        function attachHls() {{
+            var container = document.getElementById('container');
+            container.textContent = '';
+            var video = document.createElement('video');
+            video.id = 'video-' + videoNamespace;
+            video.controls = true;
+            video.width = 640;
+            video.height = 360;
+            container.appendChild(video);
+            if (Hls.isSupported()) {{
+                var hls = new Hls();
+                hls.loadSource(videoSrc);
+                hls.attachMedia(video);
+                hls.on(Hls.Events.MANIFEST_PARSED, function() {{
+                    video.play();
+                }});
+            }} else if (video.canPlayType('application/vnd.apple.mpegurl')) {{
+                video.src = videoSrc;
+                video.addEventListener('loadedmetadata', function() {{
+                    video.play();
+                }});
+            }}
+        }}
+
+        fetch(statusUrl)
+            .then(r => r.json())
+            .then(res => {{
+                if (res.ready) {{
+                    attachHls();
+                }} else {{
+                    showWaiting();
+                }}
+            }})
+            .catch(e => {{
+                console.error(e);
+                showWaiting();
+            }});
+    </script>
+</body>
+</html>
+"""
+        return HTML(data=html_code)
+    elif method == "link":
+        return hls_video_url
+    else:
+        raise ValueError("Invalid method")
+
+
 class Spec:
     """
     A video transformation specification.

{vidformer-0.7.0.dist-info → vidformer-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: vidformer
-Version: 0.7.0
+Version: 0.9.0
 Summary: A Python library for creating and viewing videos with vidformer.
 Author-email: Dominik Winecki <dominikwinecki@gmail.com>
 Requires-Python: >=3.8

vidformer-0.9.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+vidformer/__init__.py,sha256=5Hd99Yj_iTCdwQPWojDy3XTksRGCQW3BNpWHnrX3l2g,113
+vidformer/vf.py,sha256=Niz3V3tMDL2fWM_xTo3vIn9IFMufbaM8gtIfSR8-FSc,35391
+vidformer/cv2/__init__.py,sha256=wOjDsYyUKlP_Hye8-tyz-msu9xwaPMpN2sGMu3Lh3-w,22
+vidformer/cv2/vf_cv2.py,sha256=RzkRQOmKuEuQo_-8NItSx16b3ZgwZ5-lRR_AHWRiZGE,24460
+vidformer/igni/__init__.py,sha256=a7st8_NVuIu3-weoxE4o8AFtQFyXkkMfUBM_8Lj1bl0,23
+vidformer/igni/vf_igni.py,sha256=QUVURg6EYq-e5ID5X8jt_fKc0OOGnoWOvl3VRNK-bRo,9249
+vidformer-0.9.0.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+vidformer-0.9.0.dist-info/METADATA,sha256=xnIPh-eICQstIrRUu0efurTRN6p62TycHRiW8eh99Ys,1487
+vidformer-0.9.0.dist-info/RECORD,,

vidformer-0.7.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-vidformer/__init__.py,sha256=uCe1BJKzIv5LzLK4TZLlOtw6ru8vCUsf7vJkov5-oCE,113
-vidformer/vf.py,sha256=GjgaKnbk3o75lwrXP3Ue0LDyTxSf-l0njL5X-6QYZvs,31496
-vidformer/cv2/__init__.py,sha256=wOjDsYyUKlP_Hye8-tyz-msu9xwaPMpN2sGMu3Lh3-w,22
-vidformer/cv2/vf_cv2.py,sha256=Rta6wCIVaOAnkGXlpqE06qVjFmnn9FnuP7LUD9xrRHU,16413
-vidformer-0.7.0.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
-vidformer-0.7.0.dist-info/METADATA,sha256=4YKlG7kViJIWONuWeJEkxdIy2iZg4wZJ4NWzaPWATBw,1487
-vidformer-0.7.0.dist-info/RECORD,,