yta-video-opengl 0.0.19__py3-none-any.whl → 0.0.21__py3-none-any.whl

yta_video_opengl/audio.py

@@ -0,0 +1,219 @@
+"""
+TODO: This class has not been refactored nor
+tested. I need to put some love on it to make
+it work and test that it is working properly.
+"""
+from yta_video_opengl.reader import VideoReader
+from yta_video_opengl.writer import VideoWriter
+from yta_video_opengl.t import T
+from yta_validation import PythonValidator
+from quicktions import Fraction
+from typing import Union
+
+
+# TODO: Where can I obtain this dynamically (?)
+PIXEL_FORMAT = 'yuv420p'
+
+# TODO: Maybe create a _Media(ABC) to put
+# some code shared with the Video class
+class Audio:
+    """
+    Class to wrap the functionality related to
+    handling and modifying a video.
+    """
+
+    @property
+    def audio_start_pts(
+        self
+    ) -> int:
+        """
+        The start packet time stamp (pts), needed 
+        to optimize the packet iteration process.
+        """
+        # TODO: What if 'audio_time_base' is None (?)
+        return T(self.start, self.reader.audio_time_base).truncated_pts
+    
+    @property
+    def audio_end_pts(
+        self
+    ) -> Union[int, None]:
+        """
+        The end packet time stamp (pts), needed to
+        optimize the packet iteration process.
+        """
+        return (
+            # TODO: What if 'audio_time_base' is None (?)
+            T(self.end, self.reader.audio_time_base).truncated_pts
+            # TODO: What do we do if no duration (?)
+            if self.duration is not None else
+            None
+        )
+    
+    @property
+    def duration(
+        self
+    ) -> Fraction:
+        """
+        The duration of the video.
+        """
+        return self.end - self.start
+    
+    @property
+    def frames(
+        self
+    ):
+        """
+        Iterator to yield all the frames, one by
+        one, within the range defined by the
+        'start' and 'end' parameters provided when
+        instantiating it.
+
+        The iterator will iterate first over the
+        audio frames.
+        """
+        for frame in self.reader.get_audio_frames(self.start, self.end):
+            yield frame
+
+    def __init__(
+        self,
+        filename: str,
+        start: Union[int, float, Fraction] = 0.0,
+        end: Union[int, float, Fraction, None] = None
+    ):
+        self.filename: str = filename
+        """
+        The filename of the original audio.
+        """
+        # TODO: Detect the 'pixel_format' from the
+        # extension (?)
+        self.reader: VideoReader = VideoReader(self.filename)
+        """
+        The pyav audio reader.
+        """
+        self.start: Fraction = Fraction(start)
+        """
+        The time moment 't' in which the audio
+        should start.
+        """
+        self.end: Union[Fraction, None] = Fraction(
+            # TODO: Is this 'end' ok (?)
+            self.reader.duration
+            if end is None else
+            end
+        )
+        """
+        The time moment 't' in which the audio
+        should end.
+        """
+
+    def _get_t(
+        self,
+        t: Union[int, float, Fraction]
+    ) -> Fraction:
+        """
+        Get the real 't' time moment based on the
+        audio 'start' and 'end'. If they were 
+        asking for the t=0.5s but our audio was
+        subclipped to [1.0, 2.0), the 0.5s must be
+        actually the 1.5s of the audio because of
+        the subclipped time range.
+        """
+        t += self.start
+        
+        print(f'Audio real t is {str(float(t))}')
+        if t >= self.end:
+            raise Exception(f'The "t" ({str(t)}) provided is out of range. This audio lasts from [{str(self.start)}, {str(self.end)}).')
+        
+        return t
+
+    def get_audio_frame_from_t(
+        self,
+        t: Union[int, float, Fraction]
+    ) -> 'AudioFrame':
+        """
+        Get the audio frame with the given 't' time
+        moment, using the audio cache system. This
+        method is useful when we need to combine 
+        many different frames so we can obtain them
+        one by one.
+
+        TODO: Is this actually necessary (?)
+        """
+        return self.reader.get_audio_frame_from_t(self._get_t(t))
+    
+    def get_audio_frames_from_t(
+        self,
+        t: Union[int, float, Fraction]
+    ):
+        """
+        Get the sequence of audio frames for a 
+        given video 't' time moment, using the
+        audio cache system.
+
+        This is useful when we want to write a
+        video frame with its audio, so we obtain
+        all the audio frames associated to it
+        (remember that a video frame is associated
+        with more than 1 audio frame).
+        """
+        print(f'Getting audio frames from {str(float(t))} that is actually {str(float(self._get_t(t)))}')
+        for frame in self.reader.get_audio_frames_from_t(self._get_t(t)):
+            yield frame
+
+    def save_as(
+        self,
+        filename: str
+    ) -> 'Video':
+        """
+        Save the audio locally as the given 'filename'.
+
+        TODO: By now we are doing tests inside so the
+        functionality is a manual test. Use it 
+        carefully.
+        """
+        writer = VideoWriter(filename)
+        writer.set_audio_stream_from_template(self.reader.audio_stream)
+
+        from yta_video_opengl.nodes.audio import VolumeAudioNode
+        # Audio from 0 to 1
+        # TODO: This effect 'fn' is shitty
+        def fade_in_fn(t, index, start=0.5, end=1.0):
+            if t < start or t > end:
+                # fuera de la franja: no tocar nada → volumen original (1.0)
+                progress = 1.0
+            else:
+                # dentro de la franja: interpolar linealmente entre 0 → 1
+                progress = (t - start) / (end - start)
+
+            return progress
+
+        #fade_in = SetVolumeAudioNode(lambda t, i: min(1, t / self.duration))
+        fade_in = VolumeAudioNode(lambda t, i: fade_in_fn(t, i, 0.5, 1.0))
+
+        for frame, t, index in self.frames:
+            if PythonValidator.is_instance_of(frame, 'VideoFrame'):
+                print(f'Saving video frame {str(index)}, with t = {str(t)}')
+
+                # TODO: Process any video frame change
+
+                writer.mux_video_frame(
+                    frame = frame
+                )
+            else:
+                print(f'Saving audio frame {str(index)} ({str(round(float(t * self.reader.fps), 2))}), with t = {str(t)}')
+
+                # TODO: Process any audio frame change
+                # Test setting audio
+                frame = fade_in.process(frame, t)
+
+                writer.mux_audio_frame(
+                    frame = frame
+                )
+
+        # Flush the remaining frames to write
+        writer.mux_audio_frame(None)
+        writer.mux_video_frame(None)
+
+        # TODO: Maybe move this to the '__del__' (?)
+        writer.output.close()
+        self.reader.container.close()

yta_video_opengl/complete/frame_combinator.py

@@ -201,93 +201,4 @@ class AudioFrameCombinator:
         )
         out.sample_rate = sample_rate
 
-        return out
-
-# TODO: This method below has been refactored
-# to the 'sum_tracks_frames', so delete it 
-# when the one above is working well
-def mix_audio_frames_by_index(
-    tracks_frames,
-    sample_rate: int,
-    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 = sample_rate)
-            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 = sample_rate
-        # 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
-
+        return out

yta_video_opengl/complete/frame_generator.py

@@ -28,6 +28,9 @@ class _FrameGenerator:
     Class to generate frames as numpy arrays.
     """
 
+    # TODO: I have some library doing this with
+    # colors and numpy frames, so please refactor
+
     def full_black(
         self,
         size: tuple[int, int] = (1920, 1080),
@@ -62,6 +65,24 @@ class _FrameGenerator:
             dtype = dtype
         )
 
+    def full_red(
+        self,
+        size: tuple[int, int] = (1920, 1080),
+        dtype: np.dtype = np.uint8
+    ):
+        """
+        Get a numpy array that represents a full
+        red frame of the given 'size' and with
+        the given 'dtype'.
+        """
+        # TODO: I think 'ones' only work if dtype
+        # is int
+        return np.full(
+            shape = (size[1], size[0], 3),
+            fill_value = (255, 0, 0),
+            dtype = dtype
+        )
+
 class _BackgroundFrameGenerator:
     """
     Internal class to simplify the way we
@@ -115,6 +136,25 @@ class _BackgroundFrameGenerator:
             time_base = time_base
         )
 
+    def full_red(
+        self,
+        size: tuple[int, int] = (1920, 1080),
+        dtype: np.dtype = np.uint8,
+        format: str = 'rgb24',
+        pts: Union[int, None] = None,
+        time_base: Union['Fraction', None] = None   
+    ) -> VideoFrame:
+        """
+        Get a video frame that is completely red
+        and of the given 'size'.
+        """
+        return numpy_to_video_frame(
+            frame = self._frame_generator.full_red(size, dtype),
+            format = format,
+            pts = pts,
+            time_base = time_base
+        )
+
 class VideoFrameGenerator:
     """
     Class to wrap the functionality related to

yta_video_opengl/complete/frame_wrapper.py

@@ -5,6 +5,12 @@ from typing import Union
 
 
 IS_FROM_EMPTY_PART_METADATA = 'is_from_empty_part'
+"""
+Metadata key to indicate if the frame
+has been generated by an empty part
+and should be ignored when trying to
+combine with others.
+"""
 
 class _FrameWrappedBase:
     """
@@ -35,7 +41,14 @@ class _FrameWrappedBase:
         ParameterValidator.validate_mandatory_dict('metadata', metadata)
 
         self._frame: Union[VideoFrame, AudioFrame] = frame
+        """
+        The VideoFrame or AudioFrame pyav instance.
+        """
         self.metadata: dict = metadata or {}
+        """
+        The metadata we want to include with the
+        frame.
+        """
 
     def __getattr__(
         self,