yta-video-opengl 0.0.10__py3-none-any.whl → 0.0.11__py3-none-any.whl

yta_video_opengl/complete/timeline.py

@@ -0,0 +1,179 @@
+from yta_video_opengl.complete.track import Track
+from yta_video_opengl.video import Video
+from yta_validation.parameter import ParameterValidator
+from typing import Union
+from fractions import Fraction
+
+import numpy as np
+import av
+
+
+class Timeline:
+    """
+    Class to represent all the tracks that
+    exist on the project and to handle the
+    combination of all their frames.
+    """
+
+    @property
+    def end(
+        self
+    ) -> float:
+        """
+        The end of the last video of the track
+        that lasts longer. This is the last time
+        moment that has to be rendered.
+        """
+        return max(track.end for track in self.tracks)
+
+    def __init__(
+        self,
+        size: tuple[int, int] = (1920, 1080),
+        fps: float = 60.0
+    ):
+        # TODO: By now we are using just two video
+        # tracks to test the composition
+        # TODO: We need to be careful with the
+        # priority, by now its defined by its
+        # position in the array
+        self.tracks: list[Track] = [Track(), Track()]
+        """
+        All the video tracks we are handling.
+        """
+        # TODO: Handle size and fps
+        self.size = size
+        self.fps = fps
+
+    # TODO: Create 'add_track' method, but by now
+    # we hare handling only one
+    def add_video(
+        self,
+        video: Video,
+        t: float,
+        # TODO: This is for testing, it has to
+        # disappear
+        do_use_second_track: bool = False
+    ) -> 'Timeline':
+        """
+        Add the provided 'video' to the timeline,
+        starting at the provided 't' time moment.
+
+        TODO: The 'do_use_second_track' parameter
+        is temporary.
+        """
+        index = 1 * do_use_second_track
+
+        self.tracks[index].add_video(video, t)
+
+        return self
+
+    # TODO: This method is not for the Track but
+    # for the timeline, as one track can only
+    # have consecutive elements
+    def get_frame_at(
+        self,
+        t: float
+    ) -> Union['VideoFrame', None]:
+        """
+        Get all the frames that are played at the
+        't' time provided, but combined in one.
+        """
+        frames = (
+            track.get_frame_at(t)
+            for track in self.tracks
+        )
+
+        frames = [
+            frame
+            for frame in frames
+            if frame is not None
+        ]
+
+        return (
+            # TODO: Combinate them, I send first by now
+            frames[0]
+            if len(frames) > 0 else
+            # TODO: Should I send None or a full
+            # black (or transparent) frame? I think
+            # None is better because I don't know
+            # the size here (?)
+            None
+        )
+    
+    def render(
+        self,
+        filename: str,
+        start: float = 0.0,
+        end: Union[float, None] = None
+    ) -> 'Timeline':
+        """
+        Render the time range in between the given
+        'start' and 'end' and store the result with
+        the also provided 'fillename'.
+
+        If no 'start' and 'end' provided, the whole
+        project will be rendered.
+        """
+        ParameterValidator.validate_mandatory_string('filename', filename, do_accept_empty = False)
+        ParameterValidator.validate_mandatory_positive_number('start', start, do_include_zero = True)
+        ParameterValidator.validate_positive_number('end', end, do_include_zero = False)
+
+        # TODO: Limitate 'end' a bit...
+        end = (
+            self.end
+            if end is None else
+            end
+        )
+
+        if start >= end:
+            raise Exception('The provided "start" cannot be greater or equal to the "end" provided.')
+        # TODO: Obtain all the 't', based on 'fps'
+        # that we need to render from 'start' to
+        # 'end'
+        # TODO: I don't want to have this here
+        def generate_times(start: float, end: float, fps: int):
+            dt = 1.0 / fps
+            times = []
+
+            t = start
+            while t <= end:
+                times.append(t + 0.000001)
+                t += dt
+
+            return times
+
+        from yta_video_opengl.writer import VideoWriter
+
+        writer = VideoWriter('test_files/output_render.mp4')
+        # TODO: This has to be dynamic according to the
+        # video we are writing
+        writer.set_video_stream(
+            codec_name = 'h264',
+            fps = 60,
+            size = (1920, 1080),
+            pixel_format = 'yuv420p'
+        )
+        
+        for t in generate_times(start, end, self.fps):
+            frame = self.get_frame_at(t)
+
+            if frame is None:
+                # Replace with black background if no frame
+                frame = av.VideoFrame.from_ndarray(
+                    array = np.zeros((1920, 1080, 3), dtype = np.uint8),
+                    format = 'rgb24'
+                )
+
+            # We need to adjust our output elements to be
+            # consecutive and with the right values
+            # TODO: We are using int() for fps but its float...
+            frame.time_base = Fraction(1, int(self.fps))
+            frame.pts = int(t / frame.time_base)
+
+            # TODO: We need to handle the audio
+            writer.mux_video_frame(
+                frame = frame
+            )
+
+        writer.mux_video_frame(None)
+        writer.output.close()

yta_video_opengl/complete/track.py

@@ -0,0 +1,136 @@
+from yta_video_opengl.complete.video_on_track import VideoOnTrack
+from yta_video_opengl.video import Video
+from yta_validation.parameter import ParameterValidator
+from typing import Union
+
+
+# TODO: This is called Track but it is
+# handling videos only. Should I have
+# VideoTrack and AudioTrack (?)
+class Track:
+    """
+    Class to represent a track in which we place
+    videos, images and audio to build a video
+    project.
+    """
+
+    @property
+    def end(
+        self
+    ) -> float:
+        """
+        The end of the last video of this track,
+        which is also the end of the track. This
+        is the last time moment that has to be
+        rendered.
+        """
+        return (
+            0.0
+            if len(self.videos) == 0 else
+            max(
+                video.end
+                for video in self.videos
+            )
+        )
+
+    def __init__(
+        self
+    ):
+        self.videos: list[VideoOnTrack] = []
+        """
+        The list of 'VideoOnTrack' instances that
+        must play on this track.
+        """
+
+    def _is_free(
+        self,
+        start: float,
+        end: float
+    ) -> bool:
+        """
+        Check if the time range in between the 
+        'start' and 'end' time given is free or
+        there is some video playing at any moment.
+        """
+        return not any(
+            (
+                video.video.start < end and
+                video.video.end > start
+            )
+            for video in self.videos
+        )
+    
+    def _get_video_at_t(
+        self,
+        t: float
+    ) -> Union[VideoOnTrack, None]:
+        """
+        Get the video that is being played at
+        the 't' time moment provided.
+        """
+        for video in self.videos:
+            if video.start <= t < video.end:
+                return video
+            
+        return None
+    
+    def get_frame_at(
+        self,
+        t: float
+    ) -> Union['VideoFrame', None]:
+        """
+        Get the frame that must be displayed at
+        the 't' time moment provided, which is
+        a frame from the video that is being
+        played at that time moment.
+
+        Remember, this 't' time moment provided
+        is about the track, and we make the
+        conversion to the actual video 't' to
+        get the frame.
+        """
+        video = self._get_video_at_t(t)
+
+        return (
+            video.get_frame_at(t)
+            if video is not None else
+            None
+        )
+
+    def add_video(
+        self,
+        video: Video,
+        t: Union[float, None] = None
+    ) -> 'Track':
+        """
+        Add the 'video' provided to the track. If
+        a 't' time moment is provided, the video
+        will be added to that time moment if 
+        possible. If there is no other video 
+        placed in the time gap between the given
+        't' and the provided 'video' duration, it
+        will be added succesfully. In the other
+        case, an exception will be raised.
+
+        If 't' is None, the first available 't'
+        time moment will be used, that will be 0.0
+        if no video, or the end of the last video.
+        """
+        ParameterValidator.validate_mandatory_instance_of('video', video, Video)
+        ParameterValidator.validate_positive_float('t', t, do_include_zero = True)
+
+        if t is not None:
+            # TODO: We can have many different strategies
+            # that we could define in the '__init__' maybe
+            if not self._is_free(t, (t + video.end)):
+                raise Exception('The video cannot be added at the "t" time moment, something blocks it.')
+        else:
+            t = self.end
+        
+        self.videos.append(VideoOnTrack(
+            video,
+            t
+        ))
+
+        # TODO: Maybe return the VideoOnTrack instead (?)
+        return self

yta_video_opengl/complete/video_on_track.py

@@ -0,0 +1,100 @@
+"""
+If we have a video placed in a timeline,
+starting at the t=2s and the video lasts
+2 seconds, the `t` time range in which the
+video is playing is `[2s, 4s]`, so here 
+you have some examples with global `t` 
+values:
+- `t=1`, the video is not playing because
+it starts at `t=2`
+- `t=3`, the video is playing, it started
+at `t=2` and it has been playing during 1s
+- `t=5`, the video is not playing because
+it started at `t=2`, lasting 2s, so it
+finished at `t=4`
+"""
+from yta_video_opengl.video import Video
+from yta_validation.parameter import ParameterValidator
+from av.video.frame import VideoFrame
+from typing import Union
+
+
+class VideoOnTrack:
+    """
+    A video in the timeline.
+    """
+
+    @property
+    def end(
+        self
+    ) -> float:
+        """
+        The end time moment 't' of the video once
+        once its been placed on the track, which
+        is affected by the video duration and its
+        start time moment on the track.
+
+        This end is different from the video end.
+        """
+        return self.start + self.video.duration
+
+    def __init__(
+        self,
+        video: Video,
+        start: float = 0.0
+    ):
+        ParameterValidator.validate_mandatory_instance_of('video', video, Video)
+        ParameterValidator.validate_mandatory_positive_number('start', start, do_include_zero = True)
+
+        self.video: Video = video
+        """
+        The video source, with all its properties,
+        that is placed in the timeline.
+        """
+        self.start: float = float(start)
+        """
+        The time moment in which the video should
+        start playing, within the timeline.
+
+        This is the time respect to the timeline
+        and its different from the video `start`
+        time, which is related to the file.
+        """
+
+    def _get_video_t(
+        self,
+        t: float
+    ) -> float:
+        """
+        The video 't' time moment for the given
+        global 't' time moment. This 't' is the one
+        to use inside the video content to display
+        its frame.
+        """
+        return t - self.start
+
+    def is_playing(
+        self,
+        t: float
+    ) -> bool:
+        """
+        Check if this video is playing at the general
+        't' time moment, which is a global time moment
+        for the whole project.
+        """
+        return self.start <= t < self.end
+
+    def get_frame_at(
+        self,
+        t: float
+    ) -> Union[VideoFrame, None]:
+        """
+        Get the frame for the 't' time moment provided,
+        that could be None if the video is not playing
+        in that moment.
+        """
+        return (
+            self.video.reader.get_frame_from_t(self._get_video_t(t))
+            if self.is_playing(t) else
+            None
+        )

yta_video_opengl/reader/__init__.py

@@ -575,6 +575,16 @@ class VideoReader:
         """
         return self.video_cache.get_frame(index)
     
+    def get_frame_from_t(
+        self,
+        t: float
+    ) -> 'VideoFrame':
+        """
+        Get the video frame with the given 't' time
+        moment, using the video cache system.
+        """
+        return self.video_cache.get_frame_from_t(t)
+    
     # TODO: Will we use this (?)
     def get_audio_frame(
         self,

yta_video_opengl/reader/cache.py

@@ -16,17 +16,22 @@ memory all those frames to be handled fast. It
 will remove the old frames if needed to use only
 the 'size' we set when creating it.
 """
-from yta_video_opengl.utils import t_to_pts, pts_to_t, pts_to_index
+from yta_video_opengl.utils import t_to_pts, pts_to_t, pts_to_index, index_to_pts
+from yta_video_frame_time import T
 from av.container import InputContainer
 from av.video.stream import VideoStream
 from av.audio.stream import AudioStream
 from av.video.frame import VideoFrame
 from av.audio.frame import AudioFrame
 from yta_validation.parameter import ParameterValidator
+from yta_validation import PythonValidator
 from fractions import Fraction
 from collections import OrderedDict
 from typing import Union
 
+import numpy as np
+import math
+
 
 class VideoFrameCache:
     """
@@ -60,11 +65,11 @@ class VideoFrameCache:
         self,
         container: InputContainer,
         stream: Union[VideoStream, AudioStream],
-        size: int = 50
+        size: Union[int, None] = None
     ):
         ParameterValidator.validate_mandatory_instance_of('container', container, InputContainer)
         ParameterValidator.validate_mandatory_instance_of('stream', stream, [VideoStream, AudioStream])
-        ParameterValidator.validate_mandatory_positive_int('size', size)
+        ParameterValidator.validate_positive_int('size', size)
 
         self.container: InputContainer = container
         """
@@ -78,7 +83,7 @@ class VideoFrameCache:
         """
         The cache ordered dictionary.
         """
-        self.size = size
+        self.size: Union[int, None] = size
         """
         The size (in number of frames) of the cache.
         """
@@ -99,6 +104,31 @@ class VideoFrameCache:
             if packet.is_keyframe:
                 self.key_frames_pts.append(packet.pts)
 
+        # The cache size will be auto-calculated to
+        # use the amount of frames of the biggest
+        # interval of frames that belongs to a key
+        # frame, or a value by default
+        fps = (
+            float(self.stream.average_rate)
+            if PythonValidator.is_instance_of(self.stream, VideoStream) else
+            float(self.stream.rate)
+        )
+        # Intervals, but in number of frames
+        intervals = np.diff(
+            # Intervals of time between keyframes
+            np.array(self.key_frames_pts) * self.stream.time_base
+        ) * fps
+
+        self.size = (
+            math.ceil(np.max(intervals))
+            if intervals.size > 0 else
+            (
+                self.size or
+                # TODO: Make this 'default_size' a setting or something
+                60
+            )
+        )
+        
         self.container.seek(0)
 
     def _get_nearest_keyframe_fps(
@@ -117,10 +147,29 @@ class VideoFrameCache:
             if key_frame_pts <= pts
         ])
 
+    def _store_frame_in_cache(
+        self,
+        frame: Union[VideoFrame, AudioFrame]
+    ) -> Union[VideoFrame, AudioFrame]:
+        """
+        Store the provided 'frame' in cache if it
+        is not on it, removing the first item of
+        the cache if full.
+        """
+        if frame.pts not in self.cache:
+            # TODO: The 'format' must be dynamic
+            self.cache[frame.pts] = frame
+
+            # Clean cache if full
+            if len(self.cache) > self.size:
+                self.cache.popitem(last = False)
+
+        return frame
+
     def _get_frame_by_pts(
         self,
         pts: int
-    ):
+    ) -> Union[VideoFrame, AudioFrame, None]:
         """
         Get the frame that has the provided 'pts'.
 
@@ -145,18 +194,14 @@ class VideoFrameCache:
                 continue
 
             # Store in cache if needed
-            if frame.pts not in self.cache:
-                # TODO: The 'format' must be dynamic
-                self.cache[frame.pts] = frame.to_ndarray(format = "rgb24")
-
-                # Clean cache if full
-                if len(self.cache) > self.size:
-                    self.cache.popitem(last = False)
+            self._store_frame_in_cache(frame)
 
             if frame.pts >= pts:
                 decoded = self.cache[frame.pts]
                 break
 
+        # TODO: Is this working? We need previous 
+        # frames to be able to decode...
         return decoded
 
     def get_frame(
@@ -167,14 +212,24 @@ class VideoFrameCache:
         Get the frame with the given 'index' from
         the cache.
         """
-        # TODO: Maybe we can accept 't' and 'pts' also
-        target_pts = int(index / self.fps / self.time_base)
+        # TODO: Maybe we can accept 'pts' also
+        pts = index_to_pts(index, self.time_base, self.fps)
 
         return (
-            self.cache[target_pts]
-            if target_pts in self.cache else
-            self._get_frame_by_pts(target_pts)
+            self.cache[pts]
+            if pts in self.cache else
+            self._get_frame_by_pts(pts)
         )
+    
+    def get_frame_from_t(
+        self,
+        t: float
+    ) -> Union[VideoFrame, AudioFrame]:
+        """
+        Get the frame with the given 't' time moment
+        from the cache.
+        """
+        return self.get_frame(T.video_frame_time_to_video_frame_index(t, self.fps))
 
     def get_frames(
         self,
@@ -186,10 +241,22 @@ class VideoFrameCache:
         the provided 'start' and 'end' time in
         seconds.
         """
-        # TODO: I create this method by default using
-        # the cache. Think about how to implement it
-        # and apply it here, please.
-        # Go to the nearest key frame
+        # We use the cache as iterator if all the frames
+        # requested are stored there
+        pts_list = [
+            t_to_pts(t, self.time_base)
+            for t in T.get_frame_indexes(self.stream.duration, self.fps, start, end)
+        ]
+
+        if all(
+            pts in self.cache
+            for pts in pts_list
+        ):
+            for pts in pts_list:
+                yield self.cache[pts]
+
+        # If not all, we ignore the cache because we
+        # need to decode and they are all consecutive
         start = t_to_pts(start, self.time_base)
         end = (
             t_to_pts(end, self.time_base)
@@ -206,6 +273,9 @@ class VideoFrameCache:
                 if frame.pts is None:
                     continue
 
+                # We store all the frames in cache
+                self._store_frame_in_cache(frame)
+
                 if frame.pts < start:
                     continue
 

yta_video_opengl/tests.py

@@ -582,6 +582,17 @@ def video_modified_stored():
     from yta_video_opengl.classes import WavingFrame, BreathingFrame, HandheldFrame, OrbitingFrame, RotatingInCenterFrame, StrangeTvFrame, GlitchRgbFrame, WavingNode
     from yta_video_opengl.utils import texture_to_frame, frame_to_texture
     from yta_video_opengl.video import Video
+    from yta_video_opengl.complete.timeline import Timeline
+
+    video = Video(VIDEO_PATH, 0.25, 0.75)
+    timeline = Timeline()
+    timeline.add_video(Video(VIDEO_PATH, 0.25, 0.75), 0.5)
+    # This is successfully raising an exception
+    #timeline.add_video(Video(VIDEO_PATH, 0.25, 0.75), 0.6)
+    timeline.add_video(Video(VIDEO_PATH, 0.25, 0.75), 1.5)
+    timeline.render(OUTPUT_PATH)
+
+    return
 
     Video(VIDEO_PATH, 0.25, 0.75).save_as(OUTPUT_PATH)
 

yta_video_opengl/utils.py

@@ -332,6 +332,17 @@ def pts_to_index(
     """
     return int(round(pts_to_t(pts, stream_time_base) * fps))
 
+def index_to_pts(
+    index: int,
+    stream_time_base: 'Fraction',
+    fps: float
+) -> int:
+    """
+    Transform a frame index into a 'pts' packet
+    timestamp.
+    """
+    return int(index / fps / stream_time_base)
+
 def pts_to_t(
     pts: int,
     stream_time_base: 'Fraction'

yta_video_opengl/writer.py

@@ -59,6 +59,9 @@ class VideoWriter:
             options = options
         )
 
+        # We need to force this or it will not work
+        self.video_stream.time_base = Fraction(1, int(fps))
+
         if size is not None:
             self.video_stream.width = size[0]
             self.video_stream.height = size[1]
@@ -190,6 +193,7 @@ class VideoWriter:
                 # TODO: What strategy should we adopt with
                 # the packets that cannot be handled
                 # properly (?)
+                print('Invalid packet')
                 print(packet)
                 pass
 

{yta_video_opengl-0.0.10.dist-info → yta_video_opengl-0.0.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: yta-video-opengl
-Version: 0.0.10
+Version: 0.0.11
 Summary: Youtube Autonomous Video OpenGL Module
 Author: danialcala94
 Author-email: danielalcalavalera@gmail.com

yta_video_opengl-0.0.11.dist-info/RECORD

@@ -0,0 +1,20 @@
+yta_video_opengl/__init__.py,sha256=ycAx_XYMVDfkuObSvtW6irQ0Wo-fgxEz3fjIRMe8PpY,205
+yta_video_opengl/classes.py,sha256=t5-Tfc7ecvHl8JlVBp_FVzZT6ole6Ly5-FeBBH7wcxo,37742
+yta_video_opengl/complete/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+yta_video_opengl/complete/timeline.py,sha256=o6nAtpkdr6RzYlIEB9kLfNAZiu9eRXyA6QE3TXuNL_I,5465
+yta_video_opengl/complete/track.py,sha256=gPushEuLYIoMBjvS3wTDbOKSV8VEtVTqrEm666ABFUc,3937
+yta_video_opengl/complete/video_on_track.py,sha256=sTSd8gqNwK1wT1uzJEGkJqTbu5qM3wWqk361K7OAbl0,2851
+yta_video_opengl/nodes/__init__.py,sha256=TZ-ZO05PZ0_ABq675E22_PngLWOe-_w5s1cLlV3NbWM,3469
+yta_video_opengl/nodes/audio/__init__.py,sha256=4nKkC70k1UgLcCSPqFWm3cKdaJM0KUmQTwGWv1xFarQ,2926
+yta_video_opengl/nodes/video/__init__.py,sha256=gSoaoEmjdQmyRwH18mf5z3NAhap3S0RgbeBbfBXi4jc,132
+yta_video_opengl/nodes/video/opengl.py,sha256=K2pyCJEd9z4gnZqJetKyGPbtHuBzFsx74ZYyzhSqYPo,8510
+yta_video_opengl/reader/__init__.py,sha256=zqVMMUjWHCsOaWFrnkYdnbO4YEAx3zLIBTuMnzQJRug,17180
+yta_video_opengl/reader/cache.py,sha256=Gtwl2kRLSJn3JJOVI-45Wc2vMPYj5-_g3AR5wPbw8OY,9152
+yta_video_opengl/tests.py,sha256=p2Pq4o2H0DMZkV7HNNNAlebSjrDMHKTKk0d_weiiPHQ,26221
+yta_video_opengl/utils.py,sha256=_89-IrTDFVbY86qLlJzw42MxYAsNAnux_DOO89mul64,10710
+yta_video_opengl/video.py,sha256=3n7jgZab7PUSOpODoaH4iNg0sy7NMRo_OaJ4Zj8u0NM,5855
+yta_video_opengl/writer.py,sha256=rzOfxPtlClLRIVLFyIOoBVcEgse3ISmpKRWHg8OwFHQ,8355
+yta_video_opengl-0.0.11.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+yta_video_opengl-0.0.11.dist-info/METADATA,sha256=8JNEZ05Elie6lMQREjRjGPQQ-kLW-GCW6uZpePTiLgY,671
+yta_video_opengl-0.0.11.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+yta_video_opengl-0.0.11.dist-info/RECORD,,

yta_video_opengl-0.0.10.dist-info/RECORD

@@ -1,16 +0,0 @@
-yta_video_opengl/__init__.py,sha256=ycAx_XYMVDfkuObSvtW6irQ0Wo-fgxEz3fjIRMe8PpY,205
-yta_video_opengl/classes.py,sha256=t5-Tfc7ecvHl8JlVBp_FVzZT6ole6Ly5-FeBBH7wcxo,37742
-yta_video_opengl/nodes/__init__.py,sha256=TZ-ZO05PZ0_ABq675E22_PngLWOe-_w5s1cLlV3NbWM,3469
-yta_video_opengl/nodes/audio/__init__.py,sha256=4nKkC70k1UgLcCSPqFWm3cKdaJM0KUmQTwGWv1xFarQ,2926
-yta_video_opengl/nodes/video/__init__.py,sha256=gSoaoEmjdQmyRwH18mf5z3NAhap3S0RgbeBbfBXi4jc,132
-yta_video_opengl/nodes/video/opengl.py,sha256=K2pyCJEd9z4gnZqJetKyGPbtHuBzFsx74ZYyzhSqYPo,8510
-yta_video_opengl/reader/__init__.py,sha256=rAWISZ7OzDnzar0At-LCfDA-MmWzax2jT2l5gySv4aw,16911
-yta_video_opengl/reader/cache.py,sha256=UKhZvgY80ySuOYH52ikco6affsm8bjP656EroVR9Utg,6960
-yta_video_opengl/tests.py,sha256=NZ-W1ak-ygwL9wATzEXtlCeCZX74ij_TZhktetMnOD4,25810
-yta_video_opengl/utils.py,sha256=y0N1mS9FjpB4nFnx00K7sIs5EsqMkTe8C0bzLXZe9YM,10479
-yta_video_opengl/video.py,sha256=3n7jgZab7PUSOpODoaH4iNg0sy7NMRo_OaJ4Zj8u0NM,5855
-yta_video_opengl/writer.py,sha256=7xglz8xHOXMtWkctzuB21Y-e9xWFXYcklt3jVUN4svQ,8198
-yta_video_opengl-0.0.10.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
-yta_video_opengl-0.0.10.dist-info/METADATA,sha256=YZ81GUO5J78iri9e_GdjUXafQqjEyohcVjwAuknXGhU,671
-yta_video_opengl-0.0.10.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-yta_video_opengl-0.0.10.dist-info/RECORD,,