yta-video-opengl 0.0.7__py3-none-any.whl → 0.0.9__py3-none-any.whl

yta_video_opengl/reader/__init__.py

@@ -3,6 +3,7 @@ A video reader using the PyAv (av) library
 that, using ffmpeg, detects the video.
 """
 from yta_video_opengl.reader.cache import VideoFrameCache
+from yta_video_opengl.utils import iterate_stream_frames_demuxing
 from yta_validation import PythonValidator
 from av.video.frame import VideoFrame
 from av.audio.frame import AudioFrame
@@ -285,7 +286,7 @@ class VideoReader:
         The fps of the audio.
         """
         # TODO: What if no audio (?)
-        return self.audio_stream.average_rate
+        return self.audio_stream.rate
     
     @property
     def time_base(
@@ -303,8 +304,38 @@ class VideoReader:
         """
         The time base of the audio.
         """
+        # TODO: What if no audio (?)
         return self.audio_stream.time_base
     
+    @property
+    def duration(
+        self
+    ) -> Union[float, None]:
+        """
+        The duration of the video.
+        """
+        return (
+            float(self.video_stream.duration * self.video_stream.time_base)
+            if self.video_stream.duration else
+            # TODO: What to do in this case (?)
+            None
+        )
+
+    @property
+    def audio_duration(
+        self
+    ) -> Union[float, None]:
+        """
+        The duration of the audio.
+        """
+        # TODO: What if no audio (?)
+        return (
+            float(self.audio_stream.duration * self.audio_stream.time_base)
+            if self.audio_stream.duration else
+            # TODO: What to do in this case (?)
+            None
+        )
+    
     @property
     def size(
         self
@@ -367,9 +398,14 @@ class VideoReader:
         """
         The stream that includes the audio.
         """
-        self.cache: VideoFrameCache = None
+        self.video_cache: VideoFrameCache = None
         """
-        The frame cache system to optimize
+        The video frame cache system to optimize
+        the way we access to the frames.
+        """
+        self.audio_cache: VideoFrameCache = None
+        """
+        The audio frame cache system to optimize
         the way we access to the frames.
         """
 
@@ -403,7 +439,28 @@ class VideoReader:
             self.video_stream.thread_type = 'AUTO'
             self.audio_stream = self.container.streams.audio[0]
             self.audio_stream.thread_type = 'AUTO'
-            self.cache = VideoFrameCache(self)
+            self.video_cache = VideoFrameCache(self.container, self.video_stream)
+            self.audio_cache = VideoFrameCache(self.container, self.audio_stream)
+
+    def seek(
+        self,
+        pts,
+        stream = None
+    ) -> 'VideoReader':
+        """
+        Call the container '.seek()' method with
+        the given 'pts' packet time stamp.
+        """
+        stream = (
+            self.video_stream
+            if stream is None else
+            stream
+        )
+
+        # TODO: Is 'offset' actually a 'pts' (?)
+        self.container.seek(pts, stream = stream)
+
+        return self
 
     def iterate(
         self
@@ -454,7 +511,58 @@ class VideoReader:
                     yield VideoReaderFrame(frame)
             else:
                 # Return the packet as it is
-                yield VideoReaderPacket(packet)
+                yield VideoReaderPacket(packet)        
+
+    # These methods below are using the demux
+    def iterate_video_frames(
+        self,
+        start_pts: int = 0,
+        end_pts: Union[int, None] = None
+    ):
+        """
+        Iterate over the video stream packets and
+        decode only the ones in the expected range,
+        so only those frames are decoded (which is
+        an expensive process).
+
+        This method returns a tuple of 3 elements:
+        - `frame` as a `VideoFrame` instance
+        - `t` as the frame time moment
+        - `index` as the frame index
+        """
+        for frame in iterate_stream_frames_demuxing(
+            container = self.container,
+            video_stream = self.video_stream,
+            audio_stream = None,
+            start_pts = start_pts,
+            end_pts = end_pts
+        ):
+            yield frame
+
+    def iterate_audio_frames(
+        self,
+        start_pts: int = 0,
+        end_pts: Union[int, None] = None
+    ):
+        """
+        Iterate over the audio stream packets and
+        decode only the ones in the expected range,
+        so only those frames are decoded (which is
+        an expensive process).
+
+        This method returns a tuple of 3 elements:
+        - `frame` as a `AudioFrame` instance
+        - `t` as the frame time moment
+        - `index` as the frame index
+        """
+        for frame in iterate_stream_frames_demuxing(
+            container = self.container,
+            video_stream = None,
+            audio_stream = self.audio_stream,
+            start_pts = start_pts,
+            end_pts = end_pts
+        ):
+            yield frame
 
     # TODO: Will we use this (?)
     def get_frame(
@@ -462,10 +570,45 @@ class VideoReader:
         index: int
     ) -> 'VideoFrame':
         """
-        Get the frame with the given 'index', using
-        the cache system.
+        Get the video frame with the given 'index',
+        using the video cache system.
+        """
+        return self.video_cache.get_frame(index)
+    
+    # TODO: Will we use this (?)
+    def get_audio_frame(
+        self,
+        index: int
+    ) -> 'VideoFrame':
+        """
+        Get the audio frame with the given 'index',
+        using the audio cache system.
+        """
+        return self.video_cache.get_frame(index)
+    
+    def get_frames(
+        self,
+        start: float = 0.0,
+        end: Union[float, None] = None
+    ):
+        """
+        Iterator to get the video frames in between
+        the provided 'start' and 'end' time moments.
+        """
+        for frame in self.video_cache.get_frames(start, end):
+            yield frame
+
+    def get_audio_frames(
+        self,
+        start: float = 0.0,
+        end: Union[float, None] = None
+    ):
+        """
+        Iterator to get the audio frames in between
+        the provided 'start' and 'end' time moments.
         """
-        return self.cache.get_frame(index)
+        for frame in self.audio_cache.get_frames(start, end):
+            yield frame
     
     def close(
         self

yta_video_opengl/reader/cache.py

@@ -16,7 +16,16 @@ 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 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 fractions import Fraction
 from collections import OrderedDict
+from typing import Union
 
 
 class VideoFrameCache:
@@ -26,33 +35,44 @@ class VideoFrameCache:
     """
 
     @property
-    def container(
+    def fps(
         self
-    ) -> 'InputContainer':
+    ) -> float:
         """
-        Shortcut to the video reader instance container.
+        The frames per second as a float.
         """
-        return self.reader_instance.container
+        return (
+            float(self.stream.average_rate)
+            if self.stream.type == 'video' else
+            float(self.stream.rate)
+        )
     
     @property
-    def stream(
+    def time_base(
         self
-    ) -> 'VideoStream':
+    ) -> Union[Fraction, None]:
         """
-        Shortcut to the video reader instance video
-        stream.
+        The time base of the stream.
         """
-        return self.reader_instance.video_stream
+        return self.stream.time_base
 
     def __init__(
         self,
-        reader: 'VideoReader',
+        container: InputContainer,
+        stream: Union[VideoStream, AudioStream],
         size: int = 50
     ):
-        self.reader_instance: 'VideoReader' = reader
+        ParameterValidator.validate_mandatory_instance_of('container', container, InputContainer)
+        ParameterValidator.validate_mandatory_instance_of('stream', stream, [VideoStream, AudioStream])
+        ParameterValidator.validate_mandatory_positive_int('size', size)
+
+        self.container: InputContainer = container
+        """
+        The pyav container.
         """
-        The video reader instance this cache belongs
-        to.
+        self.stream: Union[VideoStream, AudioStream] = stream
+        """
+        The pyav stream.
         """
         self.cache: OrderedDict = OrderedDict()
         """
@@ -69,21 +89,40 @@ class VideoFrameCache:
         end.
         """
 
+        self._prepare()
+
+    def _prepare(
+        self
+    ):
         # Index key frames
         for packet in self.container.demux(self.stream):
             if packet.is_keyframe:
                 self.key_frames_pts.append(packet.pts)
 
         self.container.seek(0)
-        # TODO: Maybe this is better (?)
-        #self.reader_instance.reset()
+
+    def _get_nearest_keyframe_fps(
+        self,
+        pts: int
+    ):
+        """
+        Get the fps of the keyframe that is the
+        nearest to the provided 'pts'. Useful to
+        seek and start decoding frames from that
+        keyframe.
+        """
+        return max([
+            key_frame_pts
+            for key_frame_pts in self.key_frames_pts
+            if key_frame_pts <= pts
+        ])
 
     def _get_frame_by_pts(
         self,
-        target_pts
+        pts: int
     ):
         """
-        Get the frame that has the provided 'target_pts'.
+        Get the frame that has the provided 'pts'.
 
         This method will start decoding frames from the
         most near key frame (the one with the nearer
@@ -94,11 +133,7 @@ class VideoFrameCache:
         requested is not stored in the caché.
         """
         # Look for the most near key frame
-        key_frame_pts = max([
-            key_frame_pts
-            for key_frame_pts in self.key_frames_pts
-            if key_frame_pts <= target_pts
-        ])
+        key_frame_pts = self._get_nearest_keyframe_fps(pts)
 
         # Go to the key frame that includes it
         self.container.seek(key_frame_pts, stream = self.stream)
@@ -106,21 +141,20 @@ class VideoFrameCache:
         decoded = None
         for frame in self.container.decode(self.stream):
             # TODO: Could 'frame' be None (?)
-            pts = frame.pts
-            if pts is None:
+            if frame.pts is None:
                 continue
 
             # Store in cache if needed
-            if pts not in self.cache:
+            if frame.pts not in self.cache:
                 # TODO: The 'format' must be dynamic
-                self.cache[pts] = frame.to_ndarray(format = "rgb24")
+                self.cache[frame.pts] = frame.to_ndarray(format = "rgb24")
 
                 # Clean cache if full
                 if len(self.cache) > self.size:
                     self.cache.popitem(last = False)
 
-            if pts >= target_pts:
-                decoded = self.cache[pts]
+            if frame.pts >= pts:
+                decoded = self.cache[frame.pts]
                 break
 
         return decoded
@@ -128,21 +162,65 @@ class VideoFrameCache:
     def get_frame(
         self,
         index: int
-    ) -> 'VideoFrame':
+    ) -> Union[VideoFrame, AudioFrame]:
         """
         Get the frame with the given 'index' from
         the cache.
         """
-        # convertir frame_number a PTS (timestamps internos)
-        time_base = self.stream.time_base
-        fps = float(self.stream.average_rate)
-        target_pts = int(index / fps / time_base)
+        # TODO: Maybe we can accept 't' and 'pts' also
+        target_pts = int(index / self.fps / self.time_base)
 
         return (
             self.cache[target_pts]
             if target_pts in self.cache else
             self._get_frame_by_pts(target_pts)
         )
+
+    def get_frames(
+        self,
+        start: float = 0,
+        end: Union[float, None] = None
+    ):
+        """
+        Get all the frames in the range between
+        the provided 'start' and 'end' time in
+        seconds.
+        """
+        # 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
+        start = t_to_pts(start, self.time_base)
+        end = (
+            t_to_pts(end, self.time_base)
+            if end is not None else
+            None
+        )
+        key_frame_pts = self._get_nearest_keyframe_fps(start)
+
+        # Go to the nearest key frame to start decoding
+        self.container.seek(key_frame_pts, stream = self.stream)
+
+        for packet in self.container.demux(self.stream):
+            for frame in packet.decode():
+                if frame.pts is None:
+                    continue
+
+                if frame.pts < start:
+                    continue
+
+                if (
+                    end is not None and
+                    frame.pts > end
+                ):
+                    return
+                
+                # TODO: Maybe send a @dataclass instead (?)
+                yield (
+                    frame,
+                    pts_to_t(frame.pts, self.time_base),
+                    pts_to_index(frame.pts, self.time_base, self.fps)
+                )
     
     def clear(
         self

yta_video_opengl/tests.py

@@ -581,6 +581,11 @@ 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
+
+    Video(VIDEO_PATH, 0.25, 0.75).save_as(OUTPUT_PATH)
+
+    return
 
     video = VideoReader(VIDEO_PATH)
     video_writer = (
@@ -636,12 +641,9 @@ def video_modified_stored():
         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)
                 
-                # TODO: Pass the frame as a texture
-                
                 video_writer.mux_video_frame(
                     frame = texture_to_frame(
                         texture = node.process(

yta_video_opengl/utils.py

@@ -1,4 +1,8 @@
 from yta_validation import PythonValidator
+from av.container import InputContainer
+from av.video.stream import VideoStream
+from av.audio.stream import AudioStream
+from av.video.frame import VideoFrame
 from typing import Union
 
 import av
@@ -97,4 +101,243 @@ def get_fullscreen_quad_vao(
         (vbo, '2f 2f', 'in_vert', 'in_texcoord'),
     ]
 
-    return context.vertex_array(program, vao_content, ibo)
+    return context.vertex_array(program, vao_content, ibo)
+
+def iterate_streams_packets(
+    container: 'InputContainer',
+    video_stream: 'VideoStream',
+    audio_stream: 'AudioStream',
+    video_start_pts: int = 0,
+    video_end_pts: Union[int, None] = None,
+    audio_start_pts: int = 0,
+    audio_end_pts: Union[int, None] = None
+):
+    """
+    Iterate over the provided 'stream' packets
+    and yield the ones in the expected range.
+    This is nice when trying to copy a stream
+    without modifications.
+    """
+    # 'video_start_pts' and 'audio_start_pts' must
+    # be 0 or a positive tps
+
+    if (
+        video_stream is None and
+        audio_stream is None
+    ):
+        raise Exception('No streams provided.')
+    
+    # We only need to seek on video
+    if video_stream is not None:
+        container.seek(video_start_pts, stream = video_stream)
+    if audio_stream is not None:
+        container.seek(audio_start_pts, stream = audio_stream)
+    
+    stream = [
+        stream
+        for stream in (video_stream, audio_stream)
+        if stream
+    ]
+
+    """
+    Apparently, if we ignore some packets based
+    on the 'pts', we can be ignoring information
+    that is needed for the next frames to be 
+    decoded, so we need to decode them all...
+
+    If we can find some strategy to seek not for
+    the inmediate but some before and read from
+    that one to avoid reading all of the packets
+    we could save some time, but at what cost? 
+    We cannot skip any crucial frame so we need
+    to know how many we can skip, and that sounds
+    a bit difficult depending on the codec.
+    """
+    stream_finished: str = ''
+    for packet in container.demux(stream):
+        if packet.pts is None:
+            continue
+
+        # TODO: We cannot skip like this, we need to
+        # look for the nearest keyframe to be able 
+        # to decode the frames later. Take a look at
+        # the VideoFrameCache class and use it.
+
+        # start_pts = (
+        #     video_start_pts
+        #     if packet.stream.type == 'video' else
+        #     audio_start_pts
+        # )
+        # end_pts = (
+        #     video_end_pts
+        #     if packet.stream.type == 'video' else
+        #     audio_end_pts
+        # )
+
+        # if packet.pts < start_pts:
+        #     continue
+
+        # if (
+        #     end_pts is not None and
+        #     packet.pts > end_pts
+        # ):
+        #     if (
+        #         stream_finished != '' and
+        #         (
+        #             # Finish if only one stream
+        #             stream_finished != packet.stream.type or
+        #             video_stream is None or
+        #             audio_stream is None
+        #         )
+        #     ):
+        #         # We have yielded all the frames in the
+        #         # expected range, no more needed
+        #         return
+            
+        #     stream_finished = packet.stream.type
+        #     continue
+        
+        yield packet
+
+def iterate_stream_frames_demuxing(
+    container: 'InputContainer',
+    video_stream: 'VideoStream',
+    audio_stream: 'AudioStream',
+    video_start_pts : int = 0,
+    video_end_pts: Union[int, None] = None,
+    audio_start_pts: int = 0,
+    audio_end_pts: Union[int, None] = None
+):
+    """
+    Iterate over the provided 'stream' packets
+    and decode only the ones in the expected
+    range, so only those frames are decoded
+    (which is an expensive process).
+
+    This method returns a tuple of 3 elements:
+    - `frame` as a `VideoFrame` instance
+    - `t` as the frame time moment
+    - `index` as the frame index
+
+    You can easy transform the frame received
+    to a numpy array by using this:
+    - `frame.to_ndarray(format = format)`
+    """
+    # 'start_pts' must be 0 or a positive tps
+    # 'end_pts' must be None or a positive tps
+
+    # We cannot skip packets or we will lose
+    # information needed to build the video
+    for packet in iterate_streams_packets(
+        container = container,
+        video_stream = video_stream,
+        audio_stream = audio_stream,
+        video_start_pts = video_start_pts,
+        video_end_pts = video_end_pts,
+        audio_start_pts = audio_start_pts,
+        audio_end_pts = audio_end_pts
+    ):
+        # Only valid and in range packets here
+        # Here only the accepted ones
+        stream_finished: str = ''
+        for frame in packet.decode():
+            if frame.pts is None:
+                continue
+
+            time_base = (
+                video_stream.time_base
+                if PythonValidator.is_instance_of(frame, VideoFrame) else
+                audio_stream.time_base 
+            )
+
+            average_rate = (
+                video_stream.average_rate
+                if PythonValidator.is_instance_of(frame, VideoFrame) else
+                audio_stream.rate
+            )
+
+            start_pts = (
+                video_start_pts
+                if packet.stream.type == 'video' else
+                audio_start_pts
+            )
+
+            end_pts = (
+                video_end_pts
+                if packet.stream.type == 'video' else
+                audio_end_pts
+            )
+
+            if frame.pts < start_pts:
+                continue
+
+            if (
+                end_pts is not None and
+                frame.pts > end_pts
+            ):
+                if (
+                    stream_finished != '' and
+                    (
+                        # Finish if only one stream
+                        stream_finished != packet.stream.type or
+                        video_stream is None or
+                        audio_stream is None
+                    )
+                ):
+                    # We have yielded all the frames in the
+                    # expected range, no more needed
+                    return
+                
+                stream_finished = packet.stream.type
+                continue
+            
+            time_base = (
+                video_stream.time_base
+                if PythonValidator.is_instance_of(frame, VideoFrame) else
+                audio_stream.time_base 
+            )
+
+            average_rate = (
+                video_stream.average_rate
+                if PythonValidator.is_instance_of(frame, VideoFrame) else
+                audio_stream.rate
+            )
+
+            # TODO: Maybe send a @dataclass instead (?)
+            yield (
+                frame,
+                pts_to_t(frame.pts, time_base),
+                pts_to_index(frame.pts, time_base, average_rate)
+            )
+
+def t_to_pts(
+    t: float,
+    stream_time_base: 'Fraction'
+ ) -> int:
+    """
+    Transform a 't' time moment (in seconds) to
+    a packet timestamp (pts) understandable by
+    the pyav library.
+    """
+    return int((t + 0.000001) / stream_time_base)
+
+def pts_to_index(
+    pts: int,
+    stream_time_base: 'Fraction',
+    fps: float
+) -> int:
+    """
+    Transform a 'pts' packet timestamp to a 
+    frame index.
+    """
+    return int(round(pts_to_t(pts, stream_time_base) * fps))
+
+def pts_to_t(
+    pts: int,
+    stream_time_base: 'Fraction'
+) -> float:
+    """
+    Transform a 'pts' packet timestamp to a 't'
+    time moment.
+    """
+    return pts * stream_time_base

yta_video_opengl/video.py

@@ -0,0 +1,170 @@
+from yta_video_opengl.reader import VideoReader
+from yta_video_opengl.writer import VideoWriter
+from yta_video_opengl.utils import iterate_stream_frames_demuxing
+from yta_validation import PythonValidator
+from typing import Union
+
+
+# TODO: Where can I obtain this dynamically (?)
+PIXEL_FORMAT = 'yuv420p'
+
+# TODO: Maybe rename to 'Media' (?)
+class Video:
+    """
+    Class to wrap the functionality related to
+    handling and modifying a video.
+    """
+
+    @property
+    def start_pts(
+        self
+    ) -> int:
+        """
+        The start packet time stamp (pts), needed 
+        to optimize the packet iteration process.
+        """
+        return int(self.start / self.reader.time_base)
+    
+    @property
+    def end_pts(
+        self
+    ) -> Union[int, None]:
+        """
+        The end packet time stamp (pts), needed to
+        optimize the packet iteration process.
+        """
+        return (
+            int(self.end / self.reader.time_base)
+            # TODO: What do we do if no duration (?)
+            if self.duration is not None else
+            None
+        )
+    
+    @property
+    def audio_start_pts(
+        self
+    ) -> int:
+        """
+        The start packet time stamp (pts), needed 
+        to optimize the packet iteration process.
+        """
+        return int(self.start / self.reader.audio_time_base)
+    
+    @property
+    def audio_end_pts(
+        self
+    ) -> Union[int, None]:
+        """
+        The end packet time stamp (pts), needed to
+        optimize the packet iteration process.
+        """
+        return (
+            int(self.end / self.reader.audio_time_base)
+            # TODO: What do we do if no duration (?)
+            if self.duration is not None else
+            None
+        )
+    
+    @property
+    def duration(
+        self
+    ):
+        """
+        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.
+
+        This method returns a tuple of 3 elements:
+        - `frame` as a `VideoFrame` instance
+        - `t` as the frame time moment
+        - `index` as the frame index
+        """
+        for frame in self.reader.get_frames(self.start, self.end):
+            yield frame
+
+        for frame in self.reader.get_audio_frames(self.start, self.end):
+            yield frame
+
+        # for frame in iterate_stream_frames_demuxing(
+        #     container = self.reader.container,
+        #     video_stream = self.reader.video_stream,
+        #     audio_stream = self.reader.audio_stream,
+        #     video_start_pts = self.start_pts,
+        #     video_end_pts = self.end_pts,
+        #     audio_start_pts = self.audio_start_pts,
+        #     audio_end_pts = self.audio_end_pts
+        # ):
+        #     yield frame
+
+    def __init__(
+        self,
+        filename: str,
+        start: float = 0.0,
+        end: Union[float, None] = None
+    ):
+        self.filename: str = filename
+        """
+        The filename of the original video.
+        """
+        # TODO: Detect the 'pixel_format' from the
+        # extension (?)
+        self.reader: VideoReader = VideoReader(self.filename)
+        """
+        The pyav video reader.
+        """
+        self.start: float = start
+        """
+        The time moment 't' in which the video
+        should start.
+        """
+        self.end: Union[float, None] = (
+            # TODO: Is this 'end' ok (?)
+            self.reader.duration
+            if end is None else
+            end
+        )
+        """
+        The time moment 't' in which the video
+        should end.
+        """
+        
+    def save_as(
+        self,
+        filename: str
+    ) -> 'Video':
+        writer =  VideoWriter(filename)
+        #writer.set_video_stream(self.reader.video_stream.codec.name, self.reader.fps, self.reader.size, PIXEL_FORMAT)
+        writer.set_video_stream_from_template(self.reader.video_stream)
+        writer.set_audio_stream_from_template(self.reader.audio_stream)
+
+        # TODO: I need to process the audio also, so
+        # build a method that do the same but for 
+        # both streams at the same time
+        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)}')
+                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)}')
+                writer.mux_audio_frame(
+                    frame = frame
+                )
+
+        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/writer.py

@@ -114,9 +114,23 @@ class VideoWriter:
         You can pass the audio stream as it was
         obtained from the reader.
         """
+        self.audio_stream: AudioStream = self.output.add_stream(
+            codec_name = template.codec_context.name,
+            rate = template.codec_context.rate
+        )
+        self.audio_stream.codec_context.format = template.codec_context.format
+        self.audio_stream.codec_context.layout = template.codec_context.layout
+        self.audio_stream.time_base = Fraction(1, template.codec_context.rate)
+
+        return self
+
+        # This below is not working
         self.audio_stream: AudioStream = self.output.add_stream_from_template(
             template
         )
+        # TODO: Is this actually needed (?)
+        # Force this 'rate'
+        self.audio_stream.time_base = Fraction(1, template.codec_context.rate)
 
         return self
 

{yta_video_opengl-0.0.7.dist-info → yta_video_opengl-0.0.9.dist-info}/METADATA

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

yta_video_opengl-0.0.9.dist-info/RECORD

@@ -0,0 +1,12 @@
+yta_video_opengl/__init__.py,sha256=ycAx_XYMVDfkuObSvtW6irQ0Wo-fgxEz3fjIRMe8PpY,205
+yta_video_opengl/classes.py,sha256=VUw73kfz8kxYLE0x0LxNHqFekF3CklcyofCNN-z57Lg,37706
+yta_video_opengl/reader/__init__.py,sha256=rAWISZ7OzDnzar0At-LCfDA-MmWzax2jT2l5gySv4aw,16911
+yta_video_opengl/reader/cache.py,sha256=UKhZvgY80ySuOYH52ikco6affsm8bjP656EroVR9Utg,6960
+yta_video_opengl/tests.py,sha256=NZ-W1ak-ygwL9wATzEXtlCeCZX74ij_TZhktetMnOD4,25810
+yta_video_opengl/utils.py,sha256=y0N1mS9FjpB4nFnx00K7sIs5EsqMkTe8C0bzLXZe9YM,10479
+yta_video_opengl/video.py,sha256=Y14-Bsq7AH0GenwbPk61giD9eLHZDmWeZvP_iZn0e7w,5182
+yta_video_opengl/writer.py,sha256=7xglz8xHOXMtWkctzuB21Y-e9xWFXYcklt3jVUN4svQ,8198
+yta_video_opengl-0.0.9.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+yta_video_opengl-0.0.9.dist-info/METADATA,sha256=iYodm7r8DJD5lpPAs92lAClPcJ4dFrS94Dv5WjHcx5Q,670
+yta_video_opengl-0.0.9.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+yta_video_opengl-0.0.9.dist-info/RECORD,,

yta_video_opengl-0.0.7.dist-info/RECORD

@@ -1,11 +0,0 @@
-yta_video_opengl/__init__.py,sha256=ycAx_XYMVDfkuObSvtW6irQ0Wo-fgxEz3fjIRMe8PpY,205
-yta_video_opengl/classes.py,sha256=VUw73kfz8kxYLE0x0LxNHqFekF3CklcyofCNN-z57Lg,37706
-yta_video_opengl/reader/__init__.py,sha256=npLoSfHPCbwAkmrVjOZn-7a9OHXZ6mPKxZj7BiDaFX4,12638
-yta_video_opengl/reader/cache.py,sha256=Y3lQrirQJz7zFeiJQeJnkzyghYeMahkpKzsouzB90VI,4421
-yta_video_opengl/tests.py,sha256=D8Rw0e2J0AbIA1IhinTope-z5tZdW5FQFFasBHBQvm8,25765
-yta_video_opengl/utils.py,sha256=YEsvtZLingxU49-PSPZeESLMz7oMvlQxMBIe_vnyGJc,2939
-yta_video_opengl/writer.py,sha256=fFkAz3r26wud2lJqKiP0EW24Ep6cZ1uTrQkc0tt8RsE,7562
-yta_video_opengl-0.0.7.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
-yta_video_opengl-0.0.7.dist-info/METADATA,sha256=Ga9Avta2a0bHcUwUZ_OvfYTN8rO11O2CtbmFt4btYBk,670
-yta_video_opengl-0.0.7.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-yta_video_opengl-0.0.7.dist-info/RECORD,,