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

yta_video_opengl/reader/cache/__init__.py

@@ -0,0 +1,249 @@
+"""
+The pyav container stores the information based
+on the packets timestamps (called 'pts'). Some
+of the packets are considered key_frames because
+they include those key frames.
+
+Also, this library uses those key frames to start
+decodifying from there to the next one, obtaining
+all the frames in between able to be read and
+modified.
+
+This cache system will look for the range of 
+frames that belong to the key frame related to the
+frame we are requesting in the moment, keeping in
+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.
+
+A stream can have 'fps = 60' but use another
+different time base that make the pts values go 0,
+ 256, 512... for example. The 'time_base' is the
+only accurate way to obtain the pts.
+
+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
+"""
+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 av.packet import Packet
+from yta_validation.parameter import ParameterValidator
+from quicktions import Fraction
+from collections import OrderedDict
+from typing import Union
+from abc import abstractmethod, ABC
+
+import numpy as np
+import math
+
+
+class FrameCache(ABC):
+    """
+    Class to manage the frames cache of a video
+    or audio.
+    """
+
+    @property
+    @abstractmethod
+    def fps(
+        self
+    ) -> Union[int, Fraction, None]:
+        """
+        The frames per second.
+        """
+        pass
+    
+    @property
+    def time_base(
+        self
+    ) -> Union[Fraction, None]:
+        """
+        The time base of the stream.
+        """
+        return self.stream.time_base
+
+    def __init__(
+        self,
+        container: InputContainer,
+        stream: Union[VideoStream, AudioStream],
+        size: Union[int, None] = None
+    ):
+        ParameterValidator.validate_mandatory_instance_of('container', container, InputContainer)
+        ParameterValidator.validate_mandatory_instance_of('stream', stream, [VideoStream, AudioStream])
+        ParameterValidator.validate_number_between('size', size, 1, 120)
+
+        self.container: InputContainer = container
+        """
+        The pyav container.
+        """
+        self.stream: Union[VideoStream, AudioStream] = stream
+        """
+        The pyav stream.
+        """
+        self.cache: OrderedDict = OrderedDict()
+        """
+        The cache ordered dictionary.
+        """
+        self.key_frames_pts: list[int] = []
+        """
+        The list that contains the timestamps of the
+        key frame packets, ordered from begining to
+        end.
+        """
+        self.size: int = size
+        """
+        The size of the cache.
+        """
+
+        self._last_packet_accessed: Union[Packet, None] = None
+        """
+        The last packet that has been accessed
+        """
+
+        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)
+
+        # The cache size will be auto-calculated to
+        # use the amount of frames of the biggest
+        # interval of frames that belongs to a key
+        # frame, or a value by default
+        # TODO: Careful if this is too big
+        # Intervals, but in number of frames
+        intervals = np.diff(
+            # Intervals of time between keyframes
+            np.array(self.key_frames_pts) * self.time_base
+        ) * self.fps
+
+        self.size = (
+            math.ceil(np.max(intervals))
+            if intervals.size > 0 else
+            (
+                self.size
+                if self.size is not None else
+                # TODO: Make this a setting (?)
+                60
+            )
+        )
+        
+        self.container.seek(0)
+
+    def _get_nearest_keyframe_pts(
+        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 _store_frame_in_cache(
+        self,
+        frame: Union[VideoFrame, AudioFrame]
+    ) -> Union[VideoFrame, AudioFrame]:
+        """
+        Store the provided 'frame' in cache if it
+        is not on it, removing the first item of
+        the cache if full.
+        """
+        if frame.pts not in self.cache:
+            self.cache[frame.pts] = frame
+
+            # Clean cache if full
+            if len(self.cache) > self.size:
+                self.cache.popitem(last = False)
+
+        return frame
+    
+    def _seek(
+        self,
+        pts: int
+    ):
+        """
+        Seek to the given 'pts' This is useful
+        when working with 'container.demux' and
+        iterating over packets, not when using
+        'stream.decode' and getting frames 
+        directly.
+        """
+        self.container.seek(
+            offset = pts,
+            stream = self.stream
+        )
+
+    def clear(
+        self
+    ) -> 'VideoFrameCache':
+        """
+        Clear the cache by removing all the items.
+        """
+        self.cache.clear()
+
+        return self
+
+    def get_frame(
+        self,
+        t: Union[int, float, Fraction]
+    ) -> Union[VideoFrame, AudioFrame]:
+        """
+        Get the single frame that is in the 't'
+        time moment provided.
+        """
+        for frame in self.get_frames(t):
+            return frame
+        
+    @abstractmethod
+    def get_frames(
+        self,
+        start: Union[int, float, Fraction],
+        end: Union[int, float, Fraction]
+    ):
+        pass
+
+
+"""
+There is a way of editing videos being
+able to arbitrary access to frames, that
+is transforming the source videos to
+intra-frame videos. This is a ffmpeg
+command that can do it:
+
+- `ffmpeg -i input.mp4 -c:v libx264 -x264opts keyint=1 -preset fast -crf 18 -c:a copy output_intra.mp4`
+
+Once you have the 'output_intra.mp4',
+each packet can decodify its frame 
+depending not on the previous one, being
+able to seek and jump easy.
+
+There are 3 type of video codifications,
+the I-frame (intra-coded), in which any
+frame can be decoded by itself, P-frame
+(predicted), that need one or more 
+previous frames to be decoded, and 
+B-frame (bidirectional predicted), that
+needs previous and future frames.
+"""

yta_video_opengl/reader/cache/audio.py

@@ -0,0 +1,195 @@
+
+from yta_video_opengl.reader.cache import FrameCache
+from yta_video_opengl.reader.cache.utils import trim_audio_frame
+from yta_video_opengl.t import T
+from yta_validation.parameter import ParameterValidator
+from av.container import InputContainer
+from av.audio.stream import AudioStream
+from av.audio.frame import AudioFrame
+from quicktions import Fraction
+from typing import Union
+
+
+class AudioFrameCache(FrameCache):
+    """
+    Cache for the audio frames.
+    """
+
+    @property
+    def fps(
+        self
+    ) -> Union[Fraction, int]:
+        """
+        The frames per second.
+        """
+        return self.stream.rate
+
+    @property
+    def frame_duration(
+        self
+    ) -> int:
+        """
+        The frame duration in ticks, which is the
+        minimum amount of time, 1 / time_base.
+        """
+        return self.stream.frames
+    
+    def __init__(
+        self,
+        container: InputContainer,
+        stream: AudioStream,
+        size: Union[int, None] = None
+    ):
+        ParameterValidator.validate_mandatory_instance_of('stream', stream, AudioStream)
+
+        super().__init__(container, stream, size)
+
+    def _seek(
+        self,
+        pts: int
+    ):
+        """
+        Seek to the given 'pts' only if it is not
+        the next 'pts' to the last read, and it 
+        will also apply a pad to avoid problems
+        when reading audio frames.
+        """
+        # I found that it is recommended to
+        # read ~100ms before the pts we want to
+        # actually read so we obtain the frames
+        # clean (this is important in audio).
+        # This solves a problem I had related
+        # to some artifacts on the audio when
+        # trimming exactly without this pad.
+        pts_pad = int(0.1 / self.time_base)
+        self.container.seek(
+            offset = max(0, pts - pts_pad),
+            stream = self.stream
+        )
+
+    def get_frame(
+        self,
+        t: Union[int, float, Fraction]
+    ) -> AudioFrame:
+        """
+        Get the video frame that is in the 't'
+        time moment provided.
+        """
+        t: T = T.from_fps(t, self.fps)
+        for frame in self.get_frames(t.truncated, t.next(1).truncated):
+            return frame
+
+    def get_frames(
+        self,
+        start: Union[int, float, Fraction],
+        end: Union[int, float, Fraction]
+    ):
+        """
+        Get all the audio 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.
+        """
+        # TODO: Validate 'start' and 'end' are mandatory
+        # positive numbers
+        # Make sure the 'start' and 'end' time moments
+        # provided are truncated values based on the
+        # stream time base
+        start = T(start, self.time_base).truncated
+        end = T(end, self.time_base).truncated
+        
+        if end <= start:
+            raise Exception(f'The time range start:{str(float(start))} - end:{str(float(end))}) is not valid.')
+
+        key_frame_pts = self._get_nearest_keyframe_pts(start / self.time_base)
+
+        if (
+            self._last_packet_accessed is None or
+            self._last_packet_accessed.pts != key_frame_pts
+        ):
+            self._seek(key_frame_pts)
+
+        for packet in self.container.demux(self.stream):
+            if packet.pts is None:
+                continue
+
+            self._last_packet_accessed = packet
+
+            for frame in packet.decode():
+                if frame.pts is None:
+                    continue
+
+                # We store all the frames in cache
+                self._store_frame_in_cache(frame)
+
+                current_frame_time = frame.pts * self.time_base
+                # End is not included, its the start of the
+                # next frame actually
+                frame_end = current_frame_time + (frame.samples / self.stream.sample_rate)
+
+                # 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 <= start:
+                    # From 0.25 to 1.0
+                    continue
+                
+                # We finished, nothing is inside and its after
+                if current_frame_time >= end:
+                    # From 2.0 to 2.75
+                    return
+
+                """
+                If we need audio 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 (
+                    current_frame_time < start and
+                    frame_end > 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
+                        if frame_end <= end else
+                        # From 0.5 to 2.5 => take 1.0 to 2.0
+                        end
+                    )
+                    #print('A part at the end is included.')
+                    frame = trim_audio_frame(
+                        frame = frame,
+                        start = start,
+                        end = end_time,
+                        time_base = self.time_base
+                    )
+                elif (
+                    current_frame_time >= start and
+                    current_frame_time < end
+                ):
+                    end_time = (
+                        # From 1.25 to 1.5 => take 1.25 to 1.5
+                        frame_end
+                        if frame_end <= 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.')
+                    frame = trim_audio_frame(
+                        frame = frame,
+                        start = current_frame_time,
+                        end = end_time,
+                        time_base = self.time_base
+                    )
+
+                # If the whole frame is in, past as it is
+                yield frame

yta_video_opengl/reader/cache/utils.py

@@ -0,0 +1,48 @@
+from av.audio.frame import AudioFrame
+from quicktions import Fraction
+from typing import Union
+
+
+def trim_audio_frame(
+    frame: AudioFrame,
+    start: Union[int, float, Fraction],
+    end: Union[int, float, Fraction],
+    time_base: Fraction
+) -> AudioFrame:
+    """
+    Trim an audio frame to obtain the part between
+    [start, end), that is provided in seconds.
+    """
+    # (channels, n_samples)
+    samples = frame.to_ndarray()  
+    n_samples = samples.shape[1]
+
+    # In seconds
+    frame_start = frame.pts * float(time_base)
+    frame_end = frame_start + (n_samples / frame.sample_rate)
+
+    # Overlapping 
+    cut_start = max(frame_start, float(start))
+    cut_end = min(frame_end, float(end))
+
+    if cut_start >= cut_end:
+        # No overlapping
+        return None  
+
+    # To sample indexes
+    start_index = int(round((cut_start - frame_start) * frame.sample_rate))
+    end_index = int(round((cut_end - frame_start) * frame.sample_rate))
+
+    new_frame = AudioFrame.from_ndarray(
+        # end_index is not included: so [start, end)
+        array = samples[:, start_index:end_index],
+        format = frame.format,
+        layout = frame.layout
+    )
+
+    # Set attributes
+    new_frame.sample_rate = frame.sample_rate
+    new_frame.time_base = time_base
+    new_frame.pts = int(round(cut_start / float(time_base)))
+
+    return new_frame

yta_video_opengl/reader/cache/video.py

@@ -0,0 +1,110 @@
+
+from yta_video_opengl.reader.cache import FrameCache
+from yta_video_opengl.t import T
+from yta_validation.parameter import ParameterValidator
+from av.container import InputContainer
+from av.video.stream import VideoStream
+from av.video.frame import VideoFrame
+from quicktions import Fraction
+from typing import Union
+
+
+class VideoFrameCache(FrameCache):
+    """
+    Cache for the video frames.
+    """
+
+    @property
+    def fps(
+        self
+    ) -> Union[Fraction, None]:
+        """
+        The frames per second.
+        """
+        return self.stream.average_rate
+
+    @property
+    def frame_duration(
+        self
+    ) -> int:
+        """
+        The frame duration in ticks, which is the
+        minimum amount of time, 1 / time_base.
+        """
+        return self.stream.duration / self.stream.frames
+    
+    def __init__(
+        self,
+        container: InputContainer,
+        stream: VideoStream,
+        size: Union[int, None] = None
+    ):
+        ParameterValidator.validate_mandatory_instance_of('stream', stream, VideoStream)
+
+        super().__init__(container, stream, size)
+
+    def get_frame(
+        self,
+        t: Union[int, float, Fraction]
+    ) -> VideoFrame:
+        """
+        Get the video frame that is in the 't'
+        time moment provided.
+        """
+        t: T = T.from_fps(t, self.fps)
+        for frame in self.get_frames(t.truncated, t.next(1).truncated):
+            return frame
+
+    def get_frames(
+        self,
+        start: Union[int, float, Fraction],
+        end: Union[int, float, Fraction]
+    ):
+        """
+        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.
+        """
+        # TODO: Validate 'start' and 'end' are mandatory
+        # positive numbers
+        # Make sure the 'start' and 'end' time moments
+        # provided are truncated values based on the
+        # stream time base
+        start = T(start, self.time_base).truncated
+        end = T(end, self.time_base).truncated
+
+        if end <= start:
+            raise Exception(f'The time range start:{str(float(start))} - end:{str(float(end))}) is not valid.')
+        
+        key_frame_pts = self._get_nearest_keyframe_pts(start / self.time_base)
+
+        if (
+            self._last_packet_accessed is None or
+            self._last_packet_accessed.pts != key_frame_pts
+        ):
+            self._seek(key_frame_pts)
+
+        for packet in self.container.demux(self.stream):
+            if packet.pts is None:
+                continue
+
+            self._last_packet_accessed = packet
+
+            for frame in packet.decode():
+                if frame.pts is None:
+                    continue
+
+                # We store all the frames in cache
+                self._store_frame_in_cache(frame)
+                
+                current_frame_time = frame.pts * self.time_base
+                
+                # We want the range [start, end)
+                if start <= current_frame_time < end:
+                    yield frame
+
+                if current_frame_time >= end:
+                    break

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/video.py

@@ -182,7 +182,7 @@ class Video:
         Get the video frame with the given 't' time
         moment, using the video cache system.
         """
-        return self.reader.video_cache.get_video_frame(self._get_real_t(t))
+        return self.reader.video_cache.get_frame(self._get_real_t(t))
 
     def get_audio_frame_from_t(
         self,
@@ -197,7 +197,7 @@ class Video:
 
         TODO: Is this actually necessary (?)
         """
-        return self.reader.audio_cache.get_frame_from_t(self._get_real_t(t))
+        return self.reader.get_audio_frame_from_t(self._get_real_t(t))
     
     def get_audio_frames_from_t(
         self,

{yta_video_opengl-0.0.14.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.14
+Version: 0.0.16
 Summary: Youtube Autonomous Video OpenGL Module
 Author: danialcala94
 Author-email: danielalcalavalera@gmail.com

yta_video_opengl-0.0.16.dist-info/RECORD

@@ -0,0 +1,25 @@
+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/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
+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=kKvOAEeDjIwAaWtpDEQHdAd_Gwk3Ssz2tv6gpNwVkQo,19644
+yta_video_opengl/reader/cache/__init__.py,sha256=PAfGM2J-8Vv6p6Cd9aAUvyBcw3rjx2gy_2pJO22VtDM,7020
+yta_video_opengl/reader/cache/audio.py,sha256=cm_1D5f5RnmJgaidA1pnEhTPF8DE0mU2MofmwjU_b5k,6781
+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=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.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,,