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

yta_video_opengl/reader/cache.py

@@ -166,7 +166,7 @@ class VideoFrameCache:
 
         return frame
 
-    def _get_frame_by_pts(
+    def get_frame_from_pts(
         self,
         pts: int
     ) -> Union[VideoFrame, AudioFrame, None]:
@@ -181,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)
 
@@ -218,7 +221,7 @@ class VideoFrameCache:
         return (
             self.cache[pts]
             if pts in self.cache else
-            self._get_frame_by_pts(pts)
+            self.get_frame_from_pts(pts)
         )
     
     def get_frame_from_t(
@@ -229,7 +232,13 @@ class VideoFrameCache:
         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))
+        pts = t_to_pts(t, self.time_base)
+
+        return (
+            self.cache[pts]
+            if pts in self.cache else
+            self.get_frame_from_pts(pts)
+        )
 
     def get_frames(
         self,
@@ -240,20 +249,46 @@ 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
-        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]
+        # 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
+        """
+
+        # 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
@@ -276,16 +311,82 @@ class VideoFrameCache:
                 # We store all the frames in cache
                 self._store_frame_in_cache(frame)
 
-                if frame.pts < start:
+                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),
@@ -300,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/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
@@ -351,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,7 +55,7 @@ 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
         )
 
@@ -91,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

{yta_video_opengl-0.0.11.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.11
+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,,

yta_video_opengl-0.0.11.dist-info/RECORD

@@ -1,20 +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/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,,