yta-video-opengl 0.0.22__py3-none-any.whl → 0.0.24__py3-none-any.whl

yta_video_opengl/tests.py

@@ -16,16 +16,12 @@ Interesting information:
 | RBO     | Render Buffer Object       | Almacén intermedio (profundidad, etc.) |
 
 """
-from yta_validation import PythonValidator
 from yta_validation.parameter import ParameterValidator
-from yta_video_opengl.reader import VideoReader
-from yta_video_opengl.writer import VideoWriter
-from yta_timer import Timer
-from yta_video_frame_time import T
+# from yta_video_opengl.reader import VideoReader
+# from yta_video_opengl.writer import VideoWriter
 from abc import abstractmethod
 from typing import Union
 
-import av
 import moderngl
 import numpy as np
 
@@ -333,232 +329,241 @@ class WavingEffectProgram(OpenglEffectProgram):
             1,  1, 1.0, 1.0,
         ], dtype = 'f4')
 
-NUMPY_FORMAT = 'rgb24'
 
-# TODO: Maybe rename as ContextHandler (?)
-class VideoProcessor:
-    """
-    Class to read a video, process it (maybe
-    applying some effects) and writing the 
-    results in a new video.
-    """
 
-    @property
-    def fbo(
-        self
-    ) -> moderngl.Framebuffer:
-        """
-        The frame buffer object for the video frame
-        size.
-        """
-        if not hasattr(self, '_fbo'):
-            self._fbo = self.context.fbo(self.reader.size)
 
-        return self._fbo
-    
-    @property
-    def vao(
-        self
-    ) -> moderngl.VertexArray:
-        """
-        Shortcut to the program vao.
-        """
-        return self.program.vao
+# TODO: This code below was using the pyav
+# reading library that has been moved, that
+# is why it is commented by now
 
-    @property
-    def first_frame(
-        self
-    ) -> Union['VideoFrame', None]:
-        """
-        The first frame of the video as a VideoFrame.
-        """
-        if not hasattr(self, '_first_frame'):
-            # Framebuffer to render
-            self.fbo.use()
-            self._first_frame = self.reader.next_frame
-            # Reset the reader
-            self.reader.reset()
+NUMPY_FORMAT = 'rgb24'
 
-        return self._first_frame
+# # TODO: Maybe rename as ContextHandler (?)
+# class VideoProcessor:
+#     """
+#     Class to read a video, process it (maybe
+#     applying some effects) and writing the 
+#     results in a new video.
+#     """
+
+#     @property
+#     def fbo(
+#         self
+#     ) -> moderngl.Framebuffer:
+#         """
+#         The frame buffer object for the video frame
+#         size.
+#         """
+#         if not hasattr(self, '_fbo'):
+#             self._fbo = self.context.fbo(self.reader.size)
+
+#         return self._fbo
     
-    @property
-    def first_frame_as_texture(
-        self
-    ) -> moderngl.Texture:
-        """
-        The first frame of the video as a texture.
-        This is needed to start the process.
-        """
-        if not hasattr(self, '_first_frame_as_texture'):
-            self._first_frame_as_texture = self.frame_to_texture(self.first_frame, NUMPY_FORMAT)
-            self._first_frame_as_texture.build_mipmaps()
-
-        return self._first_frame_as_texture
+#     @property
+#     def vao(
+#         self
+#     ) -> moderngl.VertexArray:
+#         """
+#         Shortcut to the program vao.
+#         """
+#         return self.program.vao
+
+#     @property
+#     def first_frame(
+#         self
+#     ) -> Union['VideoFrame', None]:
+#         """
+#         The first frame of the video as a VideoFrame.
+#         """
+#         if not hasattr(self, '_first_frame'):
+#             # Framebuffer to render
+#             self.fbo.use()
+#             self._first_frame = self.reader.next_frame
+#             # Reset the reader
+#             self.reader.reset()
+
+#         return self._first_frame
     
-    @property
-    def program(
-        self
-    ) -> OpenglProgram:
-        """
-        Shortcut to the context program custom class
-        instance.
-        """
-        return self.context.program
-
-    def __init__(
-        self,
-        filename: str,
-        output_filename: str
-    ):
-        self.filename: str = filename
-        """
-        The filename of the video we want to read and
-        process.
-        """
-        self.output_filename: str = output_filename
-        """
-        The filename of the video we want to generate
-        and store once the original one has been
-        processed.
-        """
-        # TODO: Hardcoded by now
-        effect = WavingEffectProgram()
-        self.context: OpenglContext = OpenglContext(
-            vertex_shader = effect.vertex_shader,
-            fragment_shader = effect.fragment_shader,
-            vertices = effect.vertices
-        )
-        """
-        The headless context as a custom class instance.
-        """
-        self.reader: VideoReader = VideoReader(self.filename)
-        """
-        The video reader instance.
-        """
-        # TODO: This has to be dynamic, but
-        # according to what (?)
+#     @property
+#     def first_frame_as_texture(
+#         self
+#     ) -> moderngl.Texture:
+#         """
+#         The first frame of the video as a texture.
+#         This is needed to start the process.
+#         """
+#         if not hasattr(self, '_first_frame_as_texture'):
+#             self._first_frame_as_texture = self.frame_to_texture(self.first_frame, NUMPY_FORMAT)
+#             self._first_frame_as_texture.build_mipmaps()
+
+#         return self._first_frame_as_texture
+    
+#     @property
+#     def program(
+#         self
+#     ) -> OpenglProgram:
+#         """
+#         Shortcut to the context program custom class
+#         instance.
+#         """
+#         return self.context.program
+
+#     def __init__(
+#         self,
+#         filename: str,
+#         output_filename: str
+#     ):
+#         self.filename: str = filename
+#         """
+#         The filename of the video we want to read and
+#         process.
+#         """
+#         self.output_filename: str = output_filename
+#         """
+#         The filename of the video we want to generate
+#         and store once the original one has been
+#         processed.
+#         """
+#         # TODO: Hardcoded by now
+#         effect = WavingEffectProgram()
+#         self.context: OpenglContext = OpenglContext(
+#             vertex_shader = effect.vertex_shader,
+#             fragment_shader = effect.fragment_shader,
+#             vertices = effect.vertices
+#         )
+#         """
+#         The headless context as a custom class instance.
+#         """
+#         self.reader: VideoReader = VideoReader(self.filename)
+#         """
+#         The video reader instance.
+#         """
+#         # TODO: This has to be dynamic, but
+#         # according to what (?)
         
-        # TODO: Where do we obtain this from (?)
-        VIDEO_CODEC_NAME = 'libx264'
-        # TODO: Where do we obtain this from (?)
-        PIXEL_FORMAT = 'yuv420p'
-        self.writer: VideoWriter = (
-            VideoWriter(output_filename)
-            .set_video_stream(VIDEO_CODEC_NAME, self.reader.fps, self.reader.size, PIXEL_FORMAT)
-            .set_audio_stream_from_template(self.reader.audio_stream)
-        )
-        """
-        The video writer instance.
-        """
-
-    # TODO: This should be a utils
-    def frame_to_texture(
-        self,
-        frame: 'VideoFrame',
-        numpy_format: str = 'rgb24'
-    ):
-        """
-        Transform the given 'frame' to an opengl
-        texture.
-        """
-        # To numpy RGB inverted for OpenGL
-        # TODO: Maybe we can receive normal frames
-        # here, as np.ndarray, from other libraries
-        frame: np.ndarray = np.flipud(frame.to_ndarray(format = numpy_format))
-
-        return self.context.context.texture((frame.shape[1], frame.shape[0]), 3, frame.tobytes())
-
-    def process(
-        self
-    ):
-        """
-        Process the video and generate the new one.
-
-        TODO: Should I pass some effects to apply (?)
-        """
-        # [ 1 ] Initialize fbo and texture mipmaps
-        self.first_frame_as_texture # This forces it in the code
-
-        # [ 2 ] Set general program uniforms
-        AMP = 0.05
-        FREQ = 10.0
-        SPEED = 2.0
-        (
-            self.context.program
-            .set_value('amp', AMP)
-            .set_value('freq', FREQ)
-            .set_value('speed', SPEED)
-        )
-
-        # [ 3 ] Process the frames
-        frame_index = 0
-        for frame_or_packet in self.reader.iterate_with_audio(
-            do_decode_video = True,
-            do_decode_audio = False
-        ):
-            # This below is because of the parameters we
-            # passed to the method
-            is_video_frame = PythonValidator.is_instance_of(frame_or_packet, 'VideoReaderFrame')
-            is_audio_packet = PythonValidator.is_instance_of(frame_or_packet, 'VideoReaderPacket')
-
-            # To simplify the process
-            if frame_or_packet is not None:
-                frame_or_packet = frame_or_packet.data
-            if is_audio_packet:
-                self.writer.mux(frame_or_packet)
-            elif is_video_frame:
-                with Timer(is_silent_as_context = True) as timer:
-                    # Check this link:
-                    # https://stackoverflow.com/a/63153755
-
-                    def process_frame(
-                        frame: 'VideoFrame'
-                    ):
-                        # [ 4 ] Add specific program uniforms
-                        self.program.set_value('time', T.video_frame_index_to_video_frame_time(frame_index, float(self.reader.fps)))
+#         # TODO: Where do we obtain this from (?)
+#         VIDEO_CODEC_NAME = 'libx264'
+#         # TODO: Where do we obtain this from (?)
+#         PIXEL_FORMAT = 'yuv420p'
+#         self.writer: VideoWriter = (
+#             VideoWriter(output_filename)
+#             .set_video_stream(VIDEO_CODEC_NAME, self.reader.fps, self.reader.size, PIXEL_FORMAT)
+#             .set_audio_stream_from_template(self.reader.audio_stream)
+#         )
+#         """
+#         The video writer instance.
+#         """
+
+#     # TODO: This should be a utils
+#     def frame_to_texture(
+#         self,
+#         frame: 'VideoFrame',
+#         numpy_format: str = 'rgb24'
+#     ):
+#         """
+#         Transform the given 'frame' to an opengl
+#         texture.
+#         """
+#         # To numpy RGB inverted for OpenGL
+#         # TODO: Maybe we can receive normal frames
+#         # here, as np.ndarray, from other libraries
+#         frame: np.ndarray = np.flipud(frame.to_ndarray(format = numpy_format))
+
+#         return self.context.context.texture((frame.shape[1], frame.shape[0]), 3, frame.tobytes())
+
+#     def process(
+#         self
+#     ):
+#         """
+#         Process the video and generate the new one.
+
+#         TODO: Should I pass some effects to apply (?)
+#         """
+#         # [ 1 ] Initialize fbo and texture mipmaps
+#         self.first_frame_as_texture # This forces it in the code
+
+#         # [ 2 ] Set general program uniforms
+#         AMP = 0.05
+#         FREQ = 10.0
+#         SPEED = 2.0
+#         (
+#             self.context.program
+#             .set_value('amp', AMP)
+#             .set_value('freq', FREQ)
+#             .set_value('speed', SPEED)
+#         )
+
+#         # [ 3 ] Process the frames
+#         frame_index = 0
+#         for frame_or_packet in self.reader.iterate_with_audio(
+#             do_decode_video = True,
+#             do_decode_audio = False
+#         ):
+#             # This below is because of the parameters we
+#             # passed to the method
+#             is_video_frame = PythonValidator.is_instance_of(frame_or_packet, 'VideoReaderFrame')
+#             is_audio_packet = PythonValidator.is_instance_of(frame_or_packet, 'VideoReaderPacket')
+
+#             # To simplify the process
+#             if frame_or_packet is not None:
+#                 frame_or_packet = frame_or_packet.data
+#             if is_audio_packet:
+#                 self.writer.mux(frame_or_packet)
+#             elif is_video_frame:
+#                 with Timer(is_silent_as_context = True) as timer:
+#                     # Check this link:
+#                     # https://stackoverflow.com/a/63153755
+
+#                     def process_frame(
+#                         frame: 'VideoFrame'
+#                     ):
+#                         # [ 4 ] Add specific program uniforms
+#                         # TODO: T moved to 'yta_video_pyav'
+#                         self.program.set_value('time', T.video_frame_index_to_video_frame_time(frame_index, float(self.reader.fps)))
                         
-                        # Create texture
-                        texture = self.frame_to_texture(frame)
-                        texture.use()
+#                         # Create texture
+#                         texture = self.frame_to_texture(frame)
+#                         texture.use()
 
-                        # Activate frame buffer
-                        self.fbo.use()
+#                         # Activate frame buffer
+#                         self.fbo.use()
 
-                        # Render, captured by the fbo
-                        self.vao.render(moderngl.TRIANGLE_STRIP)
+#                         # Render, captured by the fbo
+#                         self.vao.render(moderngl.TRIANGLE_STRIP)
 
-                        # Processed GPU result (from fbo) to numpy
-                        processed_data = np.frombuffer(
-                            self.fbo.read(components = 3, alignment = 1), dtype = np.uint8
-                        )
+#                         # Processed GPU result (from fbo) to numpy
+#                         processed_data = np.frombuffer(
+#                             self.fbo.read(components = 3, alignment = 1), dtype = np.uint8
+#                         )
 
-                        # Invert numpy to normal frame
-                        processed_data = np.flipud(
-                            processed_data.reshape((texture.size[1], texture.size[0], 3))
-                        )
+#                         # Invert numpy to normal frame
+#                         processed_data = np.flipud(
+#                             processed_data.reshape((texture.size[1], texture.size[0], 3))
+#                         )
 
-                        # To VideoFrame and to buffer
-                        frame = av.VideoFrame.from_ndarray(processed_data, format = NUMPY_FORMAT)
-                        # TODO: What is this for (?)
-                        #out_frame.pict_type = 'NONE'
+#                         # To VideoFrame and to buffer
+#                         frame = av.VideoFrame.from_ndarray(processed_data, format = NUMPY_FORMAT)
+#                         # TODO: What is this for (?)
+#                         #out_frame.pict_type = 'NONE'
 
-                        return frame
+#                         return frame
 
-                    self.writer.mux_video_frame(process_frame(frame_or_packet))
+#                     self.writer.mux_video_frame(process_frame(frame_or_packet))
 
-                print(f'Frame {str(frame_index)}: {timer.time_elapsed_str}s')
-                frame_index += 1
+#                 print(f'Frame {str(frame_index)}: {timer.time_elapsed_str}s')
+#                 frame_index += 1
 
-        # While this code can be finished, the work in
-        # the muxer could be not finished and have some
-        # packets waiting to be written. Here we tell
-        # the muxer to process all those packets.
-        self.writer.mux_video_frame(None)
+#         # While this code can be finished, the work in
+#         # the muxer could be not finished and have some
+#         # packets waiting to be written. Here we tell
+#         # the muxer to process all those packets.
+#         self.writer.mux_video_frame(None)
+
+#         # TODO: Maybe move this to the '__del__' (?)
+#         self.writer.output.close()
+#         self.reader.container.close()
+#         print(f'Saved as "{self.output_filename}".')
 
-        # TODO: Maybe move this to the '__del__' (?)
-        self.writer.output.close()
-        self.reader.container.close()
-        print(f'Saved as "{self.output_filename}".')
 
 def video_modified_stored():
     # This path below was trimmed in an online platform
@@ -579,96 +584,12 @@ def video_modified_stored():
     # TODO: Where do we obtain this from (?)
     PIXEL_FORMAT = 'yuv420p'
 
-    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
-
-    # 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)
-
-    # # Testing concatenating
-    # timeline = Timeline()
-    # # When you concat like this, some of the
-    # # videos have frames that cannot be accessed
-    # # and I don't know why...
-    # timeline.add_video(Video('test_files/glitch_rgb_frame.mp4'))
-    # timeline.add_video(Video('test_files/output.mp4'))
-    # timeline.add_video(Video('test_files/output_render.mp4'))
-    # timeline.add_video(Video('test_files/strange_tv_frame.mp4'))
-    # timeline.add_video(Video('test_files/test_1.mp4'))
-    # timeline.add_video(Video('test_files/test_1_short_2.mp4'))
-    # timeline.add_video(Video('test_files/test_audio_1st_track_solo_v0_0_15.mp4'))
-    # timeline.add_video(Video('test_files/test_audio_2nd_track_solo_v0_0_15.mp4'))
-    # timeline.add_video(Video('test_files/test_audio_combined_tracks_v0_0_015.mp4'))
-    # timeline.add_video(Video('test_files/test_audio_combined_v0_0_15.mp4'))
-    # timeline.add_video(Video('test_files/test_blend_add_v0_0_16.mp4'))
-    # timeline.add_video(Video('test_files/test_blend_difference_v0_0_16.mp4'))
-    # timeline.add_video(Video('test_files/test_blend_multiply_v0_0_16.mp4'))
-    # timeline.add_video(Video('test_files/test_blend_overlay_v0_0_16.mp4'))
-    # timeline.add_video(Video('test_files/test_blend_screen_v0_0_16.mp4'))
-    # timeline.add_video(Video('test_files/test_combine_skipping_empty_using_priority_v0_0_18.mp4'))
-    # timeline.add_video(Video('test_files/test_ok_v0_0_13.mp4'))
-
-    # timeline.render('test_files/concatenated.mp4')
-
-    from yta_video_opengl.media import ImageMedia, ColorMedia
-
-    image_media = ImageMedia('C:/Users/dania/Desktop/PROYECTOS/RECURSOS/mobile_alpha.png', 0, 1).save_as('test_files/test_image.mp4')
-
-    color_media = ColorMedia('random', 0, 1).save_as('test_files/test_color.mp4')
-
-    return
-
-    # TODO: This test will add videos that
-    # must be played at the same time
-    video = Video(VIDEO_PATH, 0.25, 0.75)
-    timeline = Timeline()
 
-    transitions_30fps = 'C:/Users/dania/Downloads/Y2meta.app-10 Smooth Transitions Green Screen Template For Kinemaster, Alight Motion, Filmora, premiere pro-(1080p).mp4'
-    simpsons_60fps = 'C:/Users/dania/Downloads/Y_una_porra_los_simpsons_castellano_60fps.mp4'
+    #from yta_video_pyav.video import Video
 
-    # Track 1
-    timeline.add_video(Video(VIDEO_PATH, 0.25, 1.0), 0.75, track_index = 0)
-    timeline.add_video(Video(simpsons_60fps, 1.5, 2.0), 3.0, track_index = 0)
-    timeline.add_video(Video(VIDEO_PATH, 0.5, 1.0), 2.0, track_index = 0)
+    #video = Video(VIDEO_PATH)
 
-    #timeline.tracks[0].mute()
-
-    # Track 2
-    timeline.add_video(Video(VIDEO_PATH, 0.5, 1.0), 2.7, track_index = 1)
-    timeline.add_video(Video(simpsons_60fps, 5.8, 7.8), 0.6, track_index = 1)
-    # 30fps
-    # 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)
-    # 29.97fps
-    # timeline.add_video(Video('C:/Users/dania/Downloads/Y_una_porra_los_simpsons_castellano.mp4', 5.8, 6.8), 3.6, do_use_second_track = True)
-    
-    timeline.render(OUTPUT_PATH)
-
-    return
-
-    Video(VIDEO_PATH, 0.25, 0.75).save_as(OUTPUT_PATH)
-
-    return
-
-    video = VideoReader(VIDEO_PATH)
-    video_writer = (
-        VideoWriter(OUTPUT_PATH)
-        #.set_video_stream(VIDEO_CODEC_NAME, video.fps, video.size, PIXEL_FORMAT)
-        .set_video_stream_from_template(video.video_stream)
-        .set_audio_stream_from_template(video.audio_stream)
-    )
-    
     #effect = WavingFrame(size = video.size)
     #effect = BreathingFrame(size = video.size)
     #effect = HandheldFrame(size = video.size)
@@ -680,73 +601,29 @@ def video_modified_stored():
     #     size = video.size,
     #     first_frame = video.next_frame
     # )
-    effect = GlitchRgbFrame(
-        size = video.size,
-        first_frame = video.next_frame
-    )
-    context = moderngl.create_context(standalone = True)
+
+    # effect = GlitchRgbFrame(
+    #     size = video.size,
+    #     first_frame = video.next_frame
+    # )
+    from yta_video_opengl.editor import OpenglEditor
+
+    editor = OpenglEditor()
+    # waving_node_effect = editor.effects.video.waving_node(video.size, amplitude = 0.2, frequency = 9, speed = 3)
+    # chorus_effect = editor.effects.audio.chorus(audio.sample_rate)
+    # print(waving_node_effect)
     
     # New way, with nodes
-    node = WavingNode(context, video.size, amplitude = 0.2, frequency = 9, speed = 3)
+    # context = moderngl.create_context(standalone = True)
+    # node = WavingNode(context, video.size, amplitude = 0.2, frequency = 9, speed = 3)
+    # print(node.process(video.get_frame_from_t(0)))
     # We need to reset it to being again pointing
     # to the first frame...
     # TODO: Improve this by, maybe, storing the first
     # frame in memory so we can append it later, or
     # using the '.seek(0)' even when it could be not
     # accurate
-    video.reset()
-
-    frame_index = 0
-    for frame_or_packet in video.iterate_with_audio(
-        do_decode_video = True,
-        do_decode_audio = False
-    ):
-        # This below is because of the parameters we
-        # passed to the method
-        is_video_frame = PythonValidator.is_instance_of(frame_or_packet, 'VideoReaderFrame')
-        is_audio_packet = PythonValidator.is_instance_of(frame_or_packet, 'VideoReaderPacket')
-
-        # To simplify the process
-        if frame_or_packet is not None:
-            frame_or_packet = frame_or_packet.value
-
-        if is_audio_packet:
-            video_writer.mux(frame_or_packet)
-        elif is_video_frame:
-            with Timer(is_silent_as_context = True) as timer:
-                t = T.video_frame_index_to_video_frame_time(frame_index, float(video.fps))
-                # This is another way of getting 't'
-                #t = float(frame_or_packet.pts * video.time_base)
-                
-                video_writer.mux_video_frame(
-                    frame = texture_to_frame(
-                        texture = node.process(
-                            input = frame_or_packet,
-                            t = t
-                        )
-                    )
-                )
-                
-                # video_writer.mux_video_frame(
-                #     effect.process_frame(
-                #         frame = frame_or_packet,
-                #         t = t,
-                #         numpy_format = NUMPY_FORMAT
-                #     )
-                # )
-
-                frame_index += 1
-
-            print(f'Frame {str(frame_index)}: {timer.time_elapsed_str}s')
-
-    video_writer.mux_video_frame(None)
-
-    # TODO: Maybe move this to the '__del__' (?)
-    video_writer.output.close()
-    video.container.close()
-    print(f'Saved as "{OUTPUT_PATH}".')
-
-    return
+    #video.reset()
 
     # # TODO: By now this is applying an effect
     # # by default
@@ -757,6 +634,7 @@ def video_modified_stored():
 
     # return
 
+    return
     
     AMP = 0.05
     FREQ = 10.0