py-tgcalls 2.0.6__py3-none-any.whl → 2.1.0.dev2__py3-none-any.whl

pytgcalls/types/raw/video_stream.py

@@ -1,17 +1,18 @@
-from ntgcalls import InputMode
+from ntgcalls import MediaSource
 
 from ...statictypes import statictypes
+from ..py_object import PyObject
 from .video_parameters import VideoParameters
 
 
-class VideoStream:
+class VideoStream(PyObject):
     @statictypes
     def __init__(
         self,
-        input_mode: InputMode,
+        media_source: MediaSource,
         path: str,
         parameters: VideoParameters = VideoParameters(),
     ):
-        self.input_mode: InputMode = input_mode
+        self.media_source: MediaSource = media_source
         self.path: str = path
         self.parameters: VideoParameters = parameters

pytgcalls/types/stream/__init__.py

@@ -1,13 +1,19 @@
 from .audio_quality import AudioQuality
+from .device import Device
+from .direction import Direction
 from .media_stream import MediaStream
-from .stream_audio_ended import StreamAudioEnded
-from .stream_video_ended import StreamVideoEnded
+from .record_stream import RecordStream
+from .stream_ended import StreamEnded
+from .stream_frame import StreamFrame
 from .video_quality import VideoQuality
 
 __all__ = (
     'AudioQuality',
+    'Device',
+    'Direction',
     'MediaStream',
-    'StreamAudioEnded',
-    'StreamVideoEnded',
+    'RecordStream',
+    'StreamEnded',
+    'StreamFrame',
     'VideoQuality',
 )

pytgcalls/types/stream/device.py

@@ -0,0 +1,24 @@
+from enum import auto
+
+from ntgcalls import StreamDevice
+
+from ..flag import Flag
+
+
+class Device(Flag):
+    MICROPHONE = auto()
+    SPEAKER = auto()
+    CAMERA = auto()
+    SCREEN = auto()
+
+    @staticmethod
+    def from_raw(device: StreamDevice):
+        if device == StreamDevice.MICROPHONE:
+            return Device.MICROPHONE
+        if device == StreamDevice.SPEAKER:
+            return Device.SPEAKER
+        if device == StreamDevice.CAMERA:
+            return Device.CAMERA
+        if device == StreamDevice.SCREEN:
+            return Device.SCREEN
+        return None

pytgcalls/types/stream/direction.py

@@ -0,0 +1,18 @@
+from enum import auto
+
+from ntgcalls import StreamMode
+
+from ..flag import Flag
+
+
+class Direction(Flag):
+    OUTGOING = auto()
+    INCOMING = auto()
+
+    @staticmethod
+    def from_raw(direction: StreamMode):
+        if direction == StreamMode.OUTGOING:
+            return Direction.OUTGOING
+        if direction == StreamMode.INCOMING:
+            return Direction.INCOMING
+        return None

pytgcalls/types/stream/media_stream.py

@@ -4,7 +4,7 @@ from typing import Dict
 from typing import Optional
 from typing import Union
 
-from ntgcalls import InputMode
+from ntgcalls import MediaSource
 
 from ...exceptions import ImageSourceFound
 from ...exceptions import LiveStreamFound
@@ -12,8 +12,8 @@ from ...exceptions import NoAudioSourceFound
 from ...exceptions import NoVideoSourceFound
 from ...ffmpeg import build_command
 from ...ffmpeg import check_stream
-from ...media_devices import DeviceInfo
-from ...media_devices import ScreenInfo
+from ...media_devices.input_device import InputDevice
+from ...media_devices.screen_device import ScreenDevice
 from ...statictypes import statictypes
 from ...ytdlp import YtDlp
 from ..flag import Flag
@@ -31,12 +31,11 @@ class MediaStream(Stream):
         AUTO_DETECT = auto()
         REQUIRED = auto()
         IGNORE = auto()
-        NO_LATENCY = auto()
 
     @statictypes
     def __init__(
         self,
-        media_path: Union[str, Path, ScreenInfo, DeviceInfo],
+        media_path: Union[str, Path, InputDevice],
         audio_parameters: Union[
             AudioParameters,
             AudioQuality,
@@ -45,7 +44,7 @@ class MediaStream(Stream):
             VideoParameters,
             VideoQuality,
         ] = VideoQuality.SD_480p,
-        audio_path: Optional[Union[str, Path, DeviceInfo]] = None,
+        audio_path: Optional[Union[str, Path, InputDevice]] = None,
         audio_flags: Optional[Flags] = Flags.AUTO_DETECT,
         video_flags: Optional[Flags] = Flags.AUTO_DETECT,
         headers: Optional[Dict[str, str]] = None,
@@ -69,35 +68,47 @@ class MediaStream(Stream):
 
         self._media_path: Optional[str] = None
         self._audio_path: Optional[str] = None
+        self._is_media_device: bool = False
+        self._is_audio_device: bool = False
         if isinstance(media_path, str):
             self._media_path = media_path
         elif isinstance(media_path, Path):
             self._media_path = str(media_path)
-        elif isinstance(media_path, DeviceInfo):
-            self._media_path = media_path.build_ffmpeg_command()
-        elif isinstance(media_path, ScreenInfo):
-            self._media_path = media_path.build_ffmpeg_command(
-                self._video_parameters.frame_rate,
-            )
+        elif isinstance(media_path, (InputDevice, ScreenDevice)):
+            print('MediaStream', media_path.is_video)
+            if media_path.is_video:
+                self._media_path = media_path.metadata
+                self._is_media_device = True
+            else:
+                self._audio_path = media_path.metadata
+                self._is_audio_device = True
 
         if isinstance(audio_path, str):
             self._audio_path = audio_path
         elif isinstance(audio_path, Path):
             self._audio_path = str(audio_path)
-        elif isinstance(audio_path, DeviceInfo):
-            self._audio_path = audio_path.build_ffmpeg_command()
+        elif isinstance(audio_path, (InputDevice, ScreenDevice)):
+            if audio_path.is_video:
+                raise ValueError('Audio path must be an audio device')
+            self._audio_path = audio_path.metadata
+            self._is_audio_device = True
 
         self._audio_flags = self._filter_flags(audio_flags)
         self._video_flags = self._filter_flags(video_flags)
         self._ffmpeg_parameters = ffmpeg_parameters
         self._ytdlp_parameters = ytdlp_parameters
         self._headers = headers
-
         super().__init__(
-            stream_audio=None
+            microphone=None
             if self._audio_flags & MediaStream.Flags.IGNORE else
             AudioStream(
-                self._flags(self._audio_flags),
+                MediaSource.DEVICE,
+                self._audio_path,
+                self._audio_parameters,
+            )
+            if self._is_audio_device else
+            AudioStream(
+                MediaSource.SHELL,
                 ' '.join(
                     build_command(
                         'ffmpeg',
@@ -111,10 +122,17 @@ class MediaStream(Stream):
                 ),
                 self._audio_parameters,
             ),
-            stream_video=None
+            camera=None
             if self._video_flags & MediaStream.Flags.IGNORE else
             VideoStream(
-                self._flags(self._video_flags),
+                MediaSource.DESKTOP if isinstance(media_path, ScreenDevice)
+                else MediaSource.DEVICE,
+                self._media_path,
+                self._video_parameters,
+            )
+            if self._is_media_device else
+            VideoStream(
+                MediaSource.SHELL,
                 ' '.join(
                     build_command(
                         'ffmpeg',
@@ -132,91 +150,104 @@ class MediaStream(Stream):
 
     async def check_stream(self):
         if not self._video_flags & MediaStream.Flags.IGNORE:
-            if YtDlp.is_valid(self._media_path):
-                links = await YtDlp.extract(
-                    self._media_path,
-                    self._video_parameters,
-                    self._ytdlp_parameters,
-                )
-                self._media_path = links[0]
-                if not self._audio_path:
-                    self._audio_path = links[1]
-            try:
-                image_commands = []
-                live_stream = False
-                try:
-                    await check_stream(
-                        self._ffmpeg_parameters,
+            if self._is_media_device:
+                if not self._media_path:
+                    self.camera = None
+            elif self._media_path:
+                if YtDlp.is_valid(self._media_path):
+                    links = await YtDlp.extract(
                         self._media_path,
                         self._video_parameters,
-                        [],
-                        self._headers,
+                        self._ytdlp_parameters,
                     )
-                except ImageSourceFound:
-                    image_commands = [
-                        '-loop',
-                        '1',
-                        '-framerate',
-                        '1',
-                    ]
-                except LiveStreamFound:
-                    live_stream = True
-                self.stream_video.path = ' '.join(
-                    build_command(
-                        'ffmpeg',
-                        self._ffmpeg_parameters,
-                        self._media_path,
-                        self._video_parameters,
-                        image_commands,
-                        self._headers,
-                        live_stream,
-                    ),
-                )
-            except NoVideoSourceFound as e:
-                if self._video_flags & MediaStream.Flags.REQUIRED:
-                    raise e
-                self.stream_video = None
+                    self._media_path = links[0]
+                    if not self._audio_path:
+                        self._audio_path = links[1]
+                try:
+                    image_commands = []
+                    live_stream = False
+                    try:
+                        await check_stream(
+                            self._ffmpeg_parameters,
+                            self._media_path,
+                            self._video_parameters,
+                            [],
+                            self._headers,
+                        )
+                    except ImageSourceFound:
+                        image_commands = [
+                            '-loop',
+                            '1',
+                            '-framerate',
+                            '1',
+                        ]
+                    except LiveStreamFound:
+                        live_stream = True
+                    self.camera.path = ' '.join(
+                        build_command(
+                            'ffmpeg',
+                            self._ffmpeg_parameters,
+                            self._media_path,
+                            self._video_parameters,
+                            image_commands,
+                            self._headers,
+                            live_stream,
+                        ),
+                    )
+                except NoVideoSourceFound as e:
+                    if self._video_flags & MediaStream.Flags.REQUIRED:
+                        raise e
+                    self.camera = None
+            else:
+                self.camera = None
 
-        self._audio_path = self._audio_path \
-            if self._audio_path else self._media_path
+        if not self._is_media_device:
+            self._audio_path = self._audio_path \
+                if self._audio_path else self._media_path
 
         if not self._audio_flags & MediaStream.Flags.IGNORE:
-            if YtDlp.is_valid(self._audio_path):
-                self._audio_path = (
-                    await YtDlp.extract(
-                        self._audio_path,
-                        self._video_parameters,
-                        self._ytdlp_parameters,
-                    )
-                )[1]
+            if self._is_audio_device:
+                if not self._audio_path:
+                    self.microphone = None
+            elif self._audio_path:
+                if YtDlp.is_valid(self._audio_path):
+                    self._audio_path = (
+                        await YtDlp.extract(
+                            self._audio_path,
+                            self._video_parameters,
+                            self._ytdlp_parameters,
+                        )
+                    )[1]
 
-            try:
-                live_stream = False
                 try:
-                    await check_stream(
-                        self._ffmpeg_parameters,
-                        self._audio_path,
-                        self._audio_parameters,
-                        [],
-                        self._headers,
+                    live_stream = False
+                    try:
+                        await check_stream(
+                            self._ffmpeg_parameters,
+                            self._audio_path,
+                            self._audio_parameters,
+                            [],
+                            self._headers,
+                        )
+                    except LiveStreamFound:
+                        live_stream = True
+                    self.microphone.path = ' '.join(
+                        build_command(
+                            'ffmpeg',
+                            self._ffmpeg_parameters,
+                            self._audio_path,
+                            self._audio_parameters,
+                            [],
+                            self._headers,
+                            live_stream,
+                        ),
                     )
-                except LiveStreamFound:
-                    live_stream = True
-                self.stream_audio.path = ' '.join(
-                    build_command(
-                        'ffmpeg',
-                        self._ffmpeg_parameters,
-                        self._audio_path,
-                        self._audio_parameters,
-                        [],
-                        self._headers,
-                        live_stream,
-                    ),
-                )
-            except NoAudioSourceFound as e:
-                if self._audio_flags & MediaStream.Flags.REQUIRED:
-                    raise e
-                self.stream_audio = None
+                except NoAudioSourceFound as e:
+                    if self._audio_flags & MediaStream.Flags.REQUIRED:
+                        raise e
+                    self.microphone = None
+            else:
+                self.microphone = None
 
     @staticmethod
     def _filter_flags(flags: Optional[Flags]) -> Flags:
@@ -236,10 +267,3 @@ class MediaStream(Stream):
             key=lambda flag: flag.value,
         )
         return flags & ~combined_flags_value | potential_flag
-
-    @staticmethod
-    def _flags(flags: Flags) -> InputMode:
-        new_flags = InputMode.SHELL
-        if flags & MediaStream.Flags.NO_LATENCY:
-            new_flags |= InputMode.NO_LATENCY
-        return new_flags

pytgcalls/types/stream/record_stream.py

@@ -0,0 +1,93 @@
+from typing import Union
+
+from ntgcalls import MediaSource
+
+from ...media_devices.speaker_device import SpeakerDevice
+from ...statictypes import statictypes
+from ..raw.audio_parameters import AudioParameters
+from ..raw.audio_stream import AudioStream
+from ..raw.stream import Stream
+from ..raw.video_parameters import VideoParameters
+from ..raw.video_stream import VideoStream
+from ..stream.audio_quality import AudioQuality
+
+
+class RecordStream(Stream):
+    @statictypes
+    def __init__(
+        self,
+        audio: Union[bool, str, SpeakerDevice] = False,
+        audio_parameters: Union[
+            AudioParameters,
+            AudioQuality,
+        ] = AudioQuality.HIGH,
+        camera: bool = False,
+        screen: bool = False,
+    ):
+        raw_audio_parameters = (
+            audio_parameters
+            if isinstance(audio_parameters, AudioParameters)
+            else AudioParameters(*audio_parameters.value)
+            if isinstance(audio_parameters, AudioQuality)
+            else ValueError('Invalid audio parameters')
+        )
+        super().__init__(
+            microphone=self._get_audio_stream(audio, raw_audio_parameters),
+            speaker=None,
+            camera=self._get_video_stream(camera),
+            screen=self._get_video_stream(screen),
+        )
+
+    @staticmethod
+    def _get_audio_stream(audio, raw_audio_parameters):
+        if isinstance(audio, bool) and audio:
+            return AudioStream(
+                media_source=MediaSource.EXTERNAL,
+                path='',
+                parameters=raw_audio_parameters,
+            )
+        if isinstance(audio, str):
+            is_lossless = raw_audio_parameters.bitrate > 48000
+            commands = [
+                'ffmpeg',
+                '-loglevel',
+                'quiet',
+                '-f',
+                's16le',
+                '-ar',
+                str(raw_audio_parameters.bitrate),
+                '-ac',
+                str(raw_audio_parameters.channels),
+                '-i',
+                'pipe:0',
+                '-codec:a',
+                'flac' if is_lossless else 'libmp3lame',
+                audio,
+            ]
+            return AudioStream(
+                media_source=MediaSource.SHELL,
+                path=' '.join(commands),
+                parameters=raw_audio_parameters,
+            )
+        if isinstance(audio, SpeakerDevice):
+            return AudioStream(
+                media_source=MediaSource.DEVICE,
+                path=audio.metadata,
+                parameters=raw_audio_parameters,
+            )
+
+    @staticmethod
+    def _get_video_stream(enable):
+        return (
+            VideoStream(
+                media_source=MediaSource.EXTERNAL,
+                path='',
+                parameters=VideoParameters(
+                    width=-1,
+                    height=-1,
+                    frame_rate=-1,
+                ),
+            )
+            if enable
+            else None
+        )

pytgcalls/types/stream/stream_ended.py

@@ -0,0 +1,32 @@
+from enum import auto
+
+from ntgcalls import StreamType
+
+from ...types.update import Update
+from ..flag import Flag
+from .device import Device
+
+
+class StreamEnded(Update):
+
+    class Type(Flag):
+        AUDIO = auto()
+        VIDEO = auto()
+
+        @staticmethod
+        def from_raw(kind: StreamType):
+            if kind == StreamType.AUDIO:
+                return StreamEnded.Type.AUDIO
+            if kind == StreamType.VIDEO:
+                return StreamEnded.Type.VIDEO
+            return None
+
+    def __init__(
+        self,
+        chat_id: int,
+        stream_type: Type,
+        device: Device,
+    ):
+        super().__init__(chat_id)
+        self.stream_type = stream_type
+        self.device = device

pytgcalls/types/stream/stream_frame.py

@@ -0,0 +1,35 @@
+from ...types.update import Update
+from .device import Device
+from .direction import Direction
+
+
+class StreamFrame(Update):
+
+    class Info:
+        def __init__(
+            self,
+            capture_time: int,
+            width: int,
+            height: int,
+            rotation: int,
+        ):
+            self.capture_time = capture_time
+            self.width = width
+            self.height = height
+            self.rotation = rotation
+
+    def __init__(
+        self,
+        chat_id: int,
+        ssrc: int,
+        direction: Direction,
+        device: Device,
+        frame: bytes,
+        info: Info,
+    ):
+        super().__init__(chat_id)
+        self.ssrc = ssrc
+        self.direction = direction
+        self.device = device
+        self.frame = frame
+        self.info = info

pytgcalls/media_devices/screen_info.py

@@ -1,45 +0,0 @@
-from sys import platform
-
-from ..types.py_object import PyObject
-
-
-class ScreenInfo(PyObject):
-    def __init__(
-        self,
-        x: int,
-        y: int,
-        width: int,
-        height: int,
-        is_primary: bool,
-        title: str,
-    ):
-        self.offset_x = x
-        self.offset_y = y
-        self.width = width
-        self.height = height
-        self.is_primary = is_primary
-        self.title = title
-        self.ffmpeg_parameters = ['-f']
-
-    def build_ffmpeg_command(self, frame_rate: int):
-        if platform == 'win32':
-            path = 'desktop'
-
-            self.ffmpeg_parameters += [
-                'gdigrab',
-                '-offset_x',
-                str(self.offset_x),
-                '-offset_y',
-                str(self.offset_y),
-            ]
-        else:
-            path = f':0.0+{self.offset_x},{self.offset_y}'
-            self.ffmpeg_parameters += ['x11grab']
-
-        self.ffmpeg_parameters += [
-            '-video_size',
-            f'{self.width}x{self.height}',
-            '-framerate',
-            str(frame_rate),
-        ]
-        return path

pytgcalls/types/stream/stream_audio_ended.py

@@ -1,9 +0,0 @@
-from ...types.update import Update
-
-
-class StreamAudioEnded(Update):
-    def __init__(
-        self,
-        chat_id: int,
-    ):
-        super().__init__(chat_id)

pytgcalls/types/stream/stream_video_ended.py

@@ -1,9 +0,0 @@
-from ...types.update import Update
-
-
-class StreamVideoEnded(Update):
-    def __init__(
-        self,
-        chat_id: int,
-    ):
-        super().__init__(chat_id)