yta-video-opengl 0.0.15__py3-none-any.whl → 0.0.16__py3-none-any.whl

yta_video_opengl/complete/blend.py

@@ -0,0 +1,83 @@
+"""
+TODO: I don't like the name nor the
+location of this file, but it is here
+to encapsulate some functionality 
+related to combining video frames.
+"""
+import numpy as np
+
+
+def blend_alpha(
+    bottom,
+    top,
+    alpha = 0.5
+):
+    return (alpha * top + (1 - alpha) * bottom).astype(np.uint8)
+
+def blend_add(
+    bottom,
+    top
+):
+    """
+    Aclara la imagen combinada, como si superpusieras dos proyectores de luz.
+    """
+    return np.clip(bottom.astype(np.int16) + top.astype(np.int16), 0, 255).astype(np.uint8)
+
+def blend_multiply(
+    bottom,
+    top
+):
+    """
+    Oscurece, como proyectar dos transparencias juntas.
+    """
+    return ((bottom.astype(np.float32) * top.astype(np.float32)) / 255).astype(np.uint8)
+
+def blend_screen(
+    bottom,
+    top
+):
+    """
+    Hace lo contrario a Multiply, aclara la imagen.
+    """
+    return (255 - ((255 - bottom.astype(np.float32)) * (255 - top.astype(np.float32)) / 255)).astype(np.uint8)
+
+def blend_overlay(
+    bottom,
+    top
+):
+    """
+    Mezcla entre Multiply y Screen según el brillo de cada píxel.
+    """
+    b = bottom.astype(np.float32) / 255
+    t = top.astype(np.float32) / 255
+    mask = b < 0.5
+    result = np.zeros_like(b)
+    result[mask] = 2 * b[mask] * t[mask]
+    result[~mask] = 1 - 2 * (1 - b[~mask]) * (1 - t[~mask])
+    return (result * 255).astype(np.uint8)
+
+def blend_difference(
+    bottom,
+    top
+):
+    """
+    Resalta las diferencias entre los dos frames.
+    """
+    return np.abs(bottom.astype(np.int16) - top.astype(np.int16)).astype(np.uint8)
+
+# TODO: This one needs a mask, thats why
+# it is commented
+# def blend_mask(
+#     bottom,
+#     top,
+#     mask
+# ):
+#     """
+#     En lugar de un alpha fijo, puedes pasar una máscara (por ejemplo, un degradado o un canal alfa real)
+
+#     mask: array float32 entre 0 y 1, mismo tamaño que frame.
+#     """
+#     return (mask * top + (1 - mask) * bottom).astype(np.uint8)
+
+
+

yta_video_opengl/complete/timeline.py

@@ -14,9 +14,14 @@ from yta_video_opengl.complete.track import Track
 from yta_video_opengl.video import Video
 from yta_video_opengl.t import get_ts, fps_to_time_base, T
 from yta_validation.parameter import ParameterValidator
+from av.video.frame import VideoFrame
+from av.audio.frame import AudioFrame
+from av.audio.resampler import AudioResampler
 from quicktions import Fraction
 from typing import Union
 
+import numpy as np
+
 
 class Timeline:
     """
@@ -129,8 +134,25 @@ class Timeline:
         # other frame in other track, or to know if
         # I want them as transparent or something
 
-        # TODO: Combinate them, I send first by now
-        return next(frames)
+        # TODO: This is just a test function
+        from yta_video_opengl.complete.blend import blend_add
+
+        # TODO: Combinate frames, we force them to
+        # rgb24 to obtain them with the same shape,
+        # but maybe we have to change this because
+        # we also need to handle alphas
+        output_frame = next(frames).to_ndarray(format = 'rgb24')
+        for frame in frames:
+            # Combine them
+            # TODO: We need to ignore the frames that
+            # are just empty black frames and use them
+            # not in the combination process
+            output_frame = blend_add(output_frame, frame.to_ndarray(format = 'rgb24'))
+
+        # TODO: How to build this VideoFrame correctly
+        # and what about the 'format' (?)
+        # We don't handle pts here, just the image
+        return VideoFrame.from_ndarray(output_frame, format = 'rgb24')
     
     def get_audio_frames_at(
         self,
@@ -138,20 +160,151 @@ class Timeline:
     ):
         # TODO: What if the different audio streams
         # have also different fps (?)
-        frames = []
+        audio_frames = []
         for track in self.tracks:
             # TODO: Make this work properly
-            audio_frames = track.get_audio_frames_at(t)
+            audio_frames.append(list(track.get_audio_frames_at(t)))
 
             # TODO: Combine them
-            if audio_frames is not None:
-                frames = audio_frames
-                break
+            # TODO: We need to ignore the frames that
+            # are just empty black frames and use them
+            # not in the combination process
+
+        def mix_audio_frames_by_index(
+            tracks_frames,
+            layout = 'stereo'
+        ):
+            """
+            Combine all the columns of the given
+            matrix of audio frames 'tracks_frames'.
+            The rows are the different tracks and
+            the columns are the frame at that 't'
+            moment of each of those tracks.
+
+            The 'tracks_frames' matrix needs to be
+            pre-processed to have only 1 single
+            frame to combine, so we concatenate
+            all the frames if more than 1 per 
+            column.
+            """
+            # TODO: Please, improve and clean all this
+            # code is so sh*tty, and make utils to
+            # combine and those things, not here...
+            # Also the formats, make them dynamic and
+            # based on the output that is defined here
+            # in the Timeline class.
+            mixed_frames = []
+
+            # Iterate by columns (each row is a track)
+            for frames_at_index in zip(*tracks_frames):
+                arrays = []
+                for f in frames_at_index:
+                    # Resample to output expected values
+                    # TODO: This must be dynamic depending
+                    # on the track values
+                    resampler = AudioResampler(format = 'fltp', layout = 'stereo', rate = self.audio_fps)
+                    arr = resampler.resample(f)
+
+                    arr = f.to_ndarray()
+
+                    # TODO: This below must change depending
+                    # on the expected output, for us and now
+                    # it is float32, fltp, stereo, 44_100
+                    # Same format
+                    if arr.dtype == np.int16:
+                        arr = arr.astype(np.float32) / 32768.0
+
+                    # Same layout (number of channels)
+                    if arr.shape[0] == 1:
+                        return np.repeat(arr, 2, axis = 0)
+                    # elif arr.dtype == np.float32:
+                    #     # Ya está en [-1,1], no lo toques
+                    #     pass
+
+                    arrays.append(arr)
+
+                # Alinear longitudes
+                max_len = max(a.shape[1] for a in arrays)
+                stacked = []
+                for a in arrays:
+                    buf = np.zeros((a.shape[0], max_len), dtype = np.float32)
+                    buf[:, :a.shape[1]] = a
+                    stacked.append(buf)
+
+                # Mezcla
+                mix = np.sum(stacked, axis = 0) / len(stacked)
+                #mix = np.sum(stacked, axis = 0) 
+
+                # Limitar al rango [-1,1]
+                mix = np.clip(mix, -1.0, 1.0)
+
+                # Crear frame de salida
+                # TODO: What about the 'format' if they
+                # are all different (?)
+                out = AudioFrame.from_ndarray(mix, format = 'fltp', layout = layout)
+                out.sample_rate = self.audio_fps
+                # TODO: This will be written later when
+                # encoding
+                # out.pts = frames_at_index[0].pts
+                # out.time_base = frames_at_index[0].time_base
+
+                print(mix.min(), mix.max())
+
+                mixed_frames.append(out)
+
+            return mixed_frames
+        
+        def combine_audio_frames(frames):
+            """
+            Combina varios AudioFrames consecutivos en uno solo.
+            - Convierte a float32
+            - Concatena muestras a lo largo del tiempo
+            - Devuelve un AudioFrame nuevo
+            """
+            if not frames:
+                # TODO: This should not happen
+                return None
             
-        #from yta_video_opengl.utils import get_silent_audio_frame
-        #make_silent_audio_frame()
-        for frame in frames:
-            yield frame
+            if len(frames) == 1:
+                return frames
+
+            # Verificamos consistencia básica
+            sample_rate = frames[0].sample_rate
+            layout = frames[0].layout.name
+            channels = frames[0].layout.channels
+
+            arrays = []
+            for f in frames:
+                if f.sample_rate != sample_rate or f.layout.name != layout:
+                    raise ValueError("Los frames deben tener mismo sample_rate y layout")
+
+                # arr = f.to_ndarray()  # (channels, samples)
+                # if arr.dtype == np.int16:
+                #     arr = arr.astype(np.float32) / 32768.0
+                # elif arr.dtype != np.float32:
+                #     arr = arr.astype(np.float32)
+
+                arrays.append(f.to_ndarray())
+
+            # Concatenamos por eje de samples
+            combined = np.concatenate(arrays, axis = 1)
+
+            # Creamos un frame nuevo
+            out = AudioFrame.from_ndarray(combined, format = frames[0].format, layout = layout)
+            out.sample_rate = sample_rate
+
+            return [out]
+
+        # We need only 1 single audio frame per column
+        collapsed = []
+        for frames in audio_frames:
+            collapsed.append(combine_audio_frames(frames))
+
+        # Now, mix column by column (track by track)
+        frames = mix_audio_frames_by_index(collapsed)
+
+        for audio_frame in frames:
+            yield audio_frame
             
     def render(
         self,

yta_video_opengl/complete/track.py

@@ -198,6 +198,17 @@ class Track:
                 for video in self.videos
             )
         )
+    
+    @property
+    def videos(
+        self
+    ) -> list[VideoOnTrack]:
+        """
+        The list of videos we have in the track
+        but ordered using the 'start' attribute
+        from first to last.
+        """
+        return sorted(self._videos, key = lambda video: video.start)
 
     def __init__(
         self,
@@ -210,7 +221,7 @@ class Track:
         # TODO: Where does it come from (?)
         audio_samples_per_frame: int
     ):
-        self.videos: list[VideoOnTrack] = []
+        self._videos: list[VideoOnTrack] = []
         """
         The list of 'VideoOnTrack' instances that
         must play on this track.
@@ -352,7 +363,7 @@ class Track:
         else:
             t = self.end
         
-        self.videos.append(VideoOnTrack(
+        self._videos.append(VideoOnTrack(
             video,
             t
         ))

yta_video_opengl/tests.py

@@ -584,14 +584,27 @@ def video_modified_stored():
     from yta_video_opengl.video import Video
     from yta_video_opengl.complete.timeline import Timeline
 
+    # TODO: This test below is just to validate
+    # that it is cropping and placing correctly
+    # but the videos are only in one track
+    # video = Video(VIDEO_PATH, 0.25, 0.75)
+    # timeline = Timeline()
+    # timeline.add_video(Video(VIDEO_PATH, 0.25, 1.0), 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.75)
+    # timeline.add_video(Video('C:/Users/dania/Downloads/Y2meta.app-TOP 12 SIMPLE LIQUID TRANSITION _ GREEN SCREEN TRANSITION PACK-(1080p60).mp4', 4.0, 5.0), 3)
+    # # timeline.add_video(Video('C:/Users/dania/Downloads/Y2meta.app-10 Smooth Transitions Green Screen Template For Kinemaster, Alight Motion, Filmora, premiere pro-(1080p).mp4', 2.25, 3.0), 3)
+    # timeline.render(OUTPUT_PATH)
+
+    # TODO: This test will add videos that
+    # must be played at the same time
     video = Video(VIDEO_PATH, 0.25, 0.75)
     timeline = Timeline()
-    timeline.add_video(Video(VIDEO_PATH, 0.25, 1.0), 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.75)
-    timeline.add_video(Video('C:/Users/dania/Downloads/Y2meta.app-TOP 12 SIMPLE LIQUID TRANSITION _ GREEN SCREEN TRANSITION PACK-(1080p60).mp4', 4.0, 5.0), 3)
-    # timeline.add_video(Video('C:/Users/dania/Downloads/Y2meta.app-10 Smooth Transitions Green Screen Template For Kinemaster, Alight Motion, Filmora, premiere pro-(1080p).mp4', 2.25, 3.0), 3)
+    timeline.add_video(Video(VIDEO_PATH, 0.25, 1.0), 0.75)
+    timeline.add_video(Video(VIDEO_PATH, 0.5, 1.0), 2.0)
+    timeline.add_video(Video(VIDEO_PATH, 0.5, 1.0), 2.1, do_use_second_track = True)
+    timeline.add_video(Video('C:/Users/dania/Downloads/Y2meta.app-TOP 12 SIMPLE LIQUID TRANSITION _ GREEN SCREEN TRANSITION PACK-(1080p60).mp4', 0.25, 1.5), 0.25, do_use_second_track = True)
     timeline.render(OUTPUT_PATH)
 
     return

{yta_video_opengl-0.0.15.dist-info → yta_video_opengl-0.0.16.dist-info}/METADATA

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

{yta_video_opengl-0.0.15.dist-info → yta_video_opengl-0.0.16.dist-info}/RECORD

@@ -1,8 +1,9 @@
 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=y2IPLRlk3ix14zflCsLKWajbqtf6Y8ceStpLs69OqHY,9323
-yta_video_opengl/complete/track.py,sha256=hI1b4EmbXMPB_COxNUs1VlHVPtbiaIgvt37RY-YUz7g,13623
+yta_video_opengl/complete/blend.py,sha256=7qtMlgXM8n1Yfqqdl9SDaDWUk7ZTF4Ui1YuMqce2QlE,2001
+yta_video_opengl/complete/timeline.py,sha256=JWEGgEcO7YkZSNAxnz0JdMQh0ck0AffpCHi1IPhcngc,15429
+yta_video_opengl/complete/track.py,sha256=g6xPAfYl29Ruw1P6ifOZG4j8v_N8kzbFwVaVk25mx6w,13930
 yta_video_opengl/complete/video_on_track.py,sha256=KROAI0bndnfcvKlHGsSEyWg9o1xozW0PI_Rhqp0r9kw,4844
 yta_video_opengl/nodes/__init__.py,sha256=TZ-ZO05PZ0_ABq675E22_PngLWOe-_w5s1cLlV3NbWM,3469
 yta_video_opengl/nodes/audio/__init__.py,sha256=4nKkC70k1UgLcCSPqFWm3cKdaJM0KUmQTwGWv1xFarQ,2926
@@ -14,11 +15,11 @@ yta_video_opengl/reader/cache/audio.py,sha256=cm_1D5f5RnmJgaidA1pnEhTPF8DE0mU2Mo
 yta_video_opengl/reader/cache/utils.py,sha256=9aJ6qyUFRvoh2jRbIvtF_-1MOm_sgQtPiy0WXLCZYcA,1402
 yta_video_opengl/reader/cache/video.py,sha256=CSVgb3Sjqzk22sQkukoakVzms-wwZpXOT61Y6tirhjg,3292
 yta_video_opengl/t.py,sha256=xOhT1xBEwChlXf-Tuy-WxA_08iRJWVlnL_Hyzr-9-sk,6633
-yta_video_opengl/tests.py,sha256=EdTyYtTUd_mj6geWnrvnF-wZSHCKKvhYgiLclkV73O0,26576
+yta_video_opengl/tests.py,sha256=6QvJx9y4kCiq7b9-AKMetzGuJjd__pTBK5r4tJp3aso,27321
 yta_video_opengl/utils.py,sha256=yUi17EjNR4SVpvdDUwUaKl4mBCb1uyFCSGoIX3Zr2F0,15586
 yta_video_opengl/video.py,sha256=JPIWDQcYlLi8eT2LOFQtS1jVu5xVmW4bz1VMtP0gMeA,8626
 yta_video_opengl/writer.py,sha256=QwvjQcEkzn1WAVqVTFiI6tYIXJO67LKKUTJGO_eflFM,8893
-yta_video_opengl-0.0.15.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
-yta_video_opengl-0.0.15.dist-info/METADATA,sha256=nDTKhQqRMXHzjg8kQWvRWKfvDsP7rvsAhpcl8qayl-8,714
-yta_video_opengl-0.0.15.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-yta_video_opengl-0.0.15.dist-info/RECORD,,
+yta_video_opengl-0.0.16.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+yta_video_opengl-0.0.16.dist-info/METADATA,sha256=VYswuzvZl8rQv0OHZuqp5BHjquuh-NhLrRV-mNN1_Xo,714
+yta_video_opengl-0.0.16.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+yta_video_opengl-0.0.16.dist-info/RECORD,,