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

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 _get_frame_by_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_from_pts(
         self,
         pts: int
-    ):
+    ) -> Union[VideoFrame, AudioFrame, None]:
         """
         Get the frame that has the provided 'pts'.
 
@@ -132,6 +181,9 @@ class VideoFrameCache:
         This method must be called when the frame 
         requested is not stored in the caché.
         """
+        if pts in self.cache:
+            return self.cache[pts]
+        
         # Look for the most near key frame
         key_frame_pts = self._get_nearest_keyframe_fps(pts)
 
@@ -145,18 +197,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,13 +215,29 @@ 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[pts]
+            if pts in self.cache else
+            self.get_frame_from_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.
+        """
+        pts = t_to_pts(t, self.time_base)
 
         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_from_pts(pts)
         )
 
     def get_frames(
@@ -185,11 +249,49 @@ class VideoFrameCache:
         Get all the frames in the range between
         the provided 'start' and 'end' time in
         seconds.
+
+        This method is an iterator that yields
+        the frame, its t and its index.
+        """
+        # We use the cache as iterator if all the frames
+        # requested are stored there
+        # TODO: I think this is not ok... I will never
+        # have all the pts form here stored, as they come
+        # from 't' that is different...
+
+        """
+        Feel free to move this explanation to other
+        place, its about the duration.
+
+        The stream 'duration' parameter is measured
+        on ticks, the amount of ticks that the
+        stream lasts. Here below is an example:
+
+        - Duration raw: 529200
+        - Time base: 1/44100
+        - Duration (seconds): 12.0
         """
-        # 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
+
+        # The 'duration' is on pts ticks
+        duration = float(self.stream.duration * self.stream.time_base)
+        print(f'duration of the whole stream: {str(duration)}s, asking for [{str(start)}, {str(end)})')
+        # TODO: I think it would be better to
+        # receive and work with pts instead of
+        # 't' time moments...
+        # pts_list = [
+        #     t_to_pts(t, self.time_base)
+        #     for t in T.get_frame_indexes(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,16 +308,85 @@ class VideoFrameCache:
                 if frame.pts is None:
                     continue
 
-                if frame.pts < start:
+                # We store all the frames in cache
+                self._store_frame_in_cache(frame)
+
+                print(frame)
+                frame_end_pts = frame.pts + int(frame.samples * (1 / self.stream.sample_rate) / self.time_base)
+                #frame_end_pts = frame.pts + int(frame.samples)
+                #frame_end_pts = frame.pts + int(frame.samples / (self.stream.sample_rate * self.time_base))
+                print(f'    Frame from [{str(frame.pts)}, {str(frame_end_pts)}] and looking for [{str(start)}, {str(end)}]')
+
+                # For the next comments imagine we are looking
+                # for the [1.0, 2.0) audio time range
+                # Previous frame and nothing is inside
+                if frame_end_pts <= start:
+                    # From 0.25 to 1.0
                     continue
 
+                # We finished, nothing is inside and its after
                 if (
                     end is not None and
-                    frame.pts > end
+                    frame.pts >= end
                 ):
+                    # From 2.0 to 2.75
                     return
+
+                # We need: from 1 to 2
+                # Audio is:
+                #   - from 0 to 0.75    (Not included, omit)
+                #   - from 0.5 to 1.5   (Included, take 1.0 to 1.5)
+                #   - from 0.5 to 2.5   (Included, take 1.0 to 2.0)
+                #   - from 1.25 to 1.5  (Included, take 1.25 to 1.5)
+                #   - from 1.25 to 2.5  (Included, take 1.25 to 2.0)
+                #   - from 2.5 to 3.5   (Not included, omit)
+                
+                # Here below, at least a part is inside
+                if (
+                    frame.pts < start and
+                    frame_end_pts > start
+                ):
+                    # A part at the end is included
+                    end_time = (
+                        # From 0.5 to 1.5 0> take 1.0 to 1.5
+                        frame_end_pts
+                        if frame_end_pts <= end else
+                        # From 0.5 to 2.5 => take 1.0 to 2.0
+                        end
+                    )
+                    print('A part at the end is included.')
+                    # TODO: I'm using too much 'pts_to_t'
+                    frame = trim_audio_frame_pts(
+                        frame = frame,
+                        start_pts = start,
+                        end_pts = end_time,
+                        time_base = self.time_base
+                    )
+                elif (
+                    frame.pts >= start and
+                    frame.pts < end
+                ):
+                    end_time = (
+                        # From 1.25 to 1.5 => take 1.25 to 1.5
+                        frame_end_pts
+                        if frame_end_pts <= end else
+                        # From 1.25 to 2.5 => take 1.25 to 2.0
+                        end
+                    )
+                    # A part at the begining is included
+                    print('A part at the begining is included.')
+                    # TODO: I'm using too much 'pts_to_t'
+                    frame = trim_audio_frame_pts(
+                        frame = frame,
+                        start_pts = frame.pts,
+                        end_pts = end_time,
+                        time_base = self.time_base
+                    )
+
+                # If the whole frame is in, past as it is
                 
                 # TODO: Maybe send a @dataclass instead (?)
+                # TODO: Do I really need these 't' and 'index' (?)
                 yield (
                     frame,
                     pts_to_t(frame.pts, self.time_base),
@@ -230,4 +401,107 @@ class VideoFrameCache:
         """
         self.cache.clear()
 
-        return self
+        return self
+    
+
+
+import av
+import numpy as np
+
+import av
+
+
+
+def trim_audio_frame_pts(
+    frame: av.AudioFrame,
+    start_pts: int,
+    end_pts: int,
+    time_base
+) -> av.AudioFrame:
+    """
+    Recorta un AudioFrame para quedarse solo con la parte entre [start_pts, end_pts] en ticks (PTS).
+    """
+    samples = frame.to_ndarray()  # (channels, n_samples)
+    n_channels, n_samples = samples.shape
+    sr = frame.sample_rate
+
+    #frame_end_pts = frame.pts + int((n_samples / sr) / time_base)
+    # TODO: This could be wrong
+    frame_end_pts = frame.pts + int(frame.samples)
+
+    # solapamiento en PTS
+    cut_start_pts = max(frame.pts, start_pts)
+    cut_end_pts = min(frame_end_pts, end_pts)
+
+    if cut_start_pts >= cut_end_pts:
+        raise Exception('Oops...')
+        return None  # no hay solapamiento
+
+    # convertir a índices de samples (en ticks → segundos → samples)
+    cut_start_time = (cut_start_pts - frame.pts) * time_base
+    cut_end_time = (cut_end_pts - frame.pts) * time_base
+
+    start_idx = int(cut_start_time * sr)
+    end_idx = int(cut_end_time * sr)
+
+    print(
+        f"cutting [{frame.pts}, {frame_end_pts}] "
+        f"to [{cut_start_pts}, {cut_end_pts}] "
+        f"({start_idx}:{end_idx} / {frame.samples})"
+        #f"({start_idx}:{end_idx} / {n_samples})"
+    )
+
+    cut_samples = samples[:, start_idx:end_idx]
+
+    # crear nuevo AudioFrame
+    new_frame = av.AudioFrame.from_ndarray(cut_samples, format=frame.format, layout=frame.layout)
+    new_frame.sample_rate = sr
+
+    # ajustar PTS → corresponde al inicio real del recorte
+    new_frame.pts = cut_start_pts
+    new_frame.time_base = time_base
+
+    return new_frame
+
+
+
+def trim_audio_frame_t(
+    frame: av.AudioFrame,
+    start_time: float,
+    end_time: float,
+    time_base
+) -> av.AudioFrame:
+    """
+    Recorta un AudioFrame para quedarse solo con la parte entre [start_time, end_time] en segundos.
+    """
+    samples = frame.to_ndarray()  # (channels, n_samples)
+    n_channels, n_samples = samples.shape
+    sr = frame.sample_rate
+
+    frame_start = float(frame.pts * time_base)
+    frame_end = frame_start + (n_samples / sr)
+
+    # calcular solapamiento en segundos
+    cut_start = max(frame_start, start_time)
+    cut_end = min(frame_end, end_time)
+
+    if cut_start >= cut_end:
+        return None  # no hay solapamiento
+
+    # convertir a índices de samples
+    start_idx = int((cut_start - frame_start) * sr)
+    end_idx = int((cut_end - frame_start) * sr)
+
+    print(f'cutting [{str(frame_start)}, {str(frame_end)}] to [{str(float(start_time))}, {str(float(end_time))}] from {str(start_idx)} to {str(end_idx)} of {str(int((frame_end - frame_start) * sr))}')
+    cut_samples = samples[:, start_idx:end_idx]
+
+    # crear nuevo AudioFrame
+    new_frame = av.AudioFrame.from_ndarray(cut_samples, format = frame.format, layout = frame.layout)
+    new_frame.sample_rate = sr
+
+    # ajustar PTS → corresponde al inicio real del recorte
+    new_pts = int(cut_start / time_base)
+    new_frame.pts = new_pts
+    new_frame.time_base = time_base
+
+    return new_frame

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

@@ -4,6 +4,7 @@ from av.video.stream import VideoStream
 from av.audio.stream import AudioStream
 from av.video.frame import VideoFrame
 from typing import Union
+from fractions import Fraction
 
 import av
 import numpy as np
@@ -332,6 +333,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'
@@ -340,4 +352,142 @@ def pts_to_t(
     Transform a 'pts' packet timestamp to a 't'
     time moment.
     """
-    return pts * stream_time_base
+    return pts * stream_time_base
+
+
+# TODO: Move this to another utils
+def get_silent_audio_frame(
+    sample_rate,
+    layout="stereo",
+    nb_samples=1024,
+    format="s16"
+):
+    # Número de canales
+    channels = len(av.AudioLayout(layout).channels)
+    
+    # Creamos un array de ceros (silencio)
+    # dtype depende del formato
+    # if format in ('s16', 's16p'):
+    #     dtype = np.int16
+    # elif format in ('flt', 'fltp'):
+    #     dtype = np.float32
+    # else:
+    #     raise ValueError(f"Formato no soportado: {format}")
+    
+    if format == "s16":
+        dtype = np.int16
+    elif format in ('flt', 'fltp'):
+        dtype = np.float32
+    else:
+        raise ValueError(f"Formato no soportado: {format}")
+
+     # Para formatos packed → (1, samples * channels)
+    
+    if layout == 'stereo':
+        silent_array = np.zeros((2, nb_samples), dtype = dtype)
+    else:
+        silent_array = np.zeros((1, nb_samples), dtype = dtype)
+
+    # # Si es planar: (channels, samples) | Si es packed: (samples, channels)
+    # if format.endswith("p"):  # planar
+    #     silent_array = np.zeros((channels, nb_samples), dtype=dtype)
+    # else:  # packed
+    #     silent_array = np.zeros((nb_samples, channels), dtype=dtype)
+    
+    # Crear frame de audio
+    frame = av.AudioFrame.from_ndarray(silent_array, format=format, layout=layout)
+    frame.sample_rate = sample_rate
+    
+    return frame
+
+def get_black_background_video_frame(
+    size: tuple[int, int] = (1920, 1080),
+    format: str = 'rgb24'
+):
+    return av.VideoFrame.from_ndarray(
+        # TODO: What if we want alpha (?)
+        array = np.zeros((size[0], size[1], 3), dtype = np.uint8),
+        format = format
+    )
+
+def get_audio_frame_pts_range(
+    frame: av.AudioFrame,
+    do_in_seconds: bool = False
+):
+    """
+    Get the [start_pts, end_pts) range of the
+    pyav AudioFrame, or in seconds if the
+    'do_in_seconds' parameter is True.
+    """
+    if frame.pts is None:
+        raise Exception('No "pts" found.')
+
+    # First and last sample. Remember that
+    # the last one is not included
+    start_pts = frame.pts
+    end_pts = frame.pts + frame.samples
+
+    # Time base for the seconds conversion
+    time_base = (
+        frame.time_base
+        if frame.time_base else
+        Fraction(1, frame.sample_rate)
+    )
+
+    start_time = (
+        float(start_pts * time_base)
+        if do_in_seconds else
+        start_time
+    )
+    end_time = (
+        float(end_pts * time_base)
+        if do_in_seconds else
+        end_time
+    )
+
+    return (
+        start_time,
+        end_time
+    )
+
+def audio_frames_and_remainder_per_video_frame(
+    fps: float,
+    sample_rate: int,
+    nb_samples: int
+):
+    """
+    Calcula cuántos audio frames completos y cuántas muestras sobrantes
+    corresponden a la duración de 1 frame de vídeo.
+    
+    Args:
+        fps (float): Frames por segundo del vídeo
+        sample_rate (int): Frecuencia de muestreo del audio (Hz)
+        nb_samples (int): Número de samples por AudioFrame (PyAV)
+    
+    Returns:
+        (int, int): (frames_completos, muestras_restantes)
+    """
+    # Duración de un frame de vídeo en segundos
+    video_frame_duration = 1.0 / fps
+    
+    # Total de samples de audio necesarios
+    samples_needed = round(sample_rate * video_frame_duration)
+    
+    # Cuántos audio frames completos de nb_samples
+    full_frames = samples_needed // nb_samples
+    
+    # Restante que no completa un audio frame
+    remainder = samples_needed % nb_samples
+    
+    return full_frames, remainder
+
+    # # Usage below:
+    # fps = 30
+    # sample_rate = 44100
+    # nb_samples = 1024
+
+    # full, rem = audio_frames_and_remainder_per_video_frame(fps, sample_rate, nb_samples)
+    # # This will return (1, 446)
+
+
+

yta_video_opengl/writer.py

@@ -55,10 +55,13 @@ class VideoWriter:
         self.video_stream: VideoStream = self.output.add_stream(
             # TODO: Maybe 'libx264' as default 'codec_name' (?)
             codec_name = codec_name,
-            rate = fps,
+            rate = int(fps),
             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]
@@ -88,17 +91,27 @@ class VideoWriter:
 
     def set_audio_stream(
         self,
-        codec_name: Union[str, None]
+        codec_name: Union[str, None],
+        fps: float = 44_100.0
         # TODO: Add more if needed
     ) -> 'VideoWriter':
         """
         Set the audio stream, that will overwrite any other
         previous audio stream set.
         """
+        # TODO: Check what else we can set
         self.audio_stream: AudioStream = self.output.add_stream(
-            codec_name = codec_name
+            codec_name = codec_name,
+            rate = int(fps)
         )
 
+        # audio_stream = output.add_stream("aac", rate=48000)  # codec AAC, 48kHz
+        # # Configurar stream
+        # audio_stream.channels = 2                # número de canales
+        # audio_stream.layout = "stereo"           # layout
+        # audio_stream.sample_rate = 48000         # sample rate
+        # audio_stream.format = "s16"              # formato de las muestras (PCM signed 16-bit)
+
         # TODO: Add more if needed
 
         return self
@@ -190,6 +203,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.12.dist-info}/METADATA

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

yta_video_opengl-0.0.12.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=mf5QH7pFHvQCfDFpZd4HhyHSinvU-RDtvRhXaKOTNuY,9096
+yta_video_opengl/complete/track.py,sha256=vDGjkMxYY9y_KHFZb-kvN0K1Yt3_foiR_eTB3fIJxVY,12923
+yta_video_opengl/complete/video_on_track.py,sha256=jbRXX6KMwtvshcW1ce2FRAVKlVRHYxyyY-IOzKSO8-I,4364
+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=da4Jqtqi7xjbjgfzwJpXIMkILz0SKLedt8KDFqmy0Is,20848
+yta_video_opengl/reader/cache.py,sha256=KOFU3BtymZeel3FIvgxrWm9siUlakfNZdJzQUbFxavg,16657
+yta_video_opengl/tests.py,sha256=p2Pq4o2H0DMZkV7HNNNAlebSjrDMHKTKk0d_weiiPHQ,26221
+yta_video_opengl/utils.py,sha256=znlkvL5xjQeeN37cqFHNILBgop4W1PQTfFFudyt8-60,14614
+yta_video_opengl/video.py,sha256=3n7jgZab7PUSOpODoaH4iNg0sy7NMRo_OaJ4Zj8u0NM,5855
+yta_video_opengl/writer.py,sha256=wcDVL6Av-16kgx1X_LCAgKboa1eGnKvXaKuGPOsky-s,8880
+yta_video_opengl-0.0.12.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+yta_video_opengl-0.0.12.dist-info/METADATA,sha256=Q-stok3ZF1NXMjfNxzSA8GBjPs6-yb4BnrPg1cxjTds,671
+yta_video_opengl-0.0.12.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+yta_video_opengl-0.0.12.dist-info/RECORD,,