py-tgcalls 2.0.5__py3-none-any.whl → 2.1.0.dev1__py3-none-any.whl

pytgcalls/types/raw/video_stream.py

@@ -1,4 +1,4 @@
-from ntgcalls import InputMode
+from ntgcalls import MediaSource
 
 from ...statictypes import statictypes
 from .video_parameters import VideoParameters
@@ -8,10 +8,10 @@ class VideoStream:
     @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,
@@ -73,19 +72,20 @@ class MediaStream(Stream):
             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):
+            if media_path.is_video:
+                self._media_path = media_path.metadata
+            else:
+                self._audio_path = media_path.metadata
 
         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):
+            if audio_path.is_video:
+                raise ValueError('Audio path must be an audio device')
+            self._audio_path = audio_path.metadata
 
         self._audio_flags = self._filter_flags(audio_flags)
         self._video_flags = self._filter_flags(video_flags)
@@ -94,10 +94,16 @@ class MediaStream(Stream):
         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 isinstance(audio_path, InputDevice) else
+            AudioStream(
+                MediaSource.SHELL,
                 ' '.join(
                     build_command(
                         'ffmpeg',
@@ -111,10 +117,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(audio_path, ScreenDevice)
+                else MediaSource.DEVICE,
+                self._media_path,
+                self._video_parameters,
+            )
+            if isinstance(audio_path, InputDevice) else
+            VideoStream(
+                MediaSource.SHELL,
                 ' '.join(
                     build_command(
                         'ffmpeg',
@@ -161,7 +174,7 @@ class MediaStream(Stream):
                     ]
                 except LiveStreamFound:
                     live_stream = True
-                self.stream_video.path = ' '.join(
+                self.camera.path = ' '.join(
                     build_command(
                         'ffmpeg',
                         self._ffmpeg_parameters,
@@ -175,7 +188,7 @@ class MediaStream(Stream):
             except NoVideoSourceFound as e:
                 if self._video_flags & MediaStream.Flags.REQUIRED:
                     raise e
-                self.stream_video = None
+                self.camera = None
 
         self._audio_path = self._audio_path \
             if self._audio_path else self._media_path
@@ -202,7 +215,7 @@ class MediaStream(Stream):
                     )
                 except LiveStreamFound:
                     live_stream = True
-                self.stream_audio.path = ' '.join(
+                self.microphone.path = ' '.join(
                     build_command(
                         'ffmpeg',
                         self._ffmpeg_parameters,
@@ -216,7 +229,7 @@ class MediaStream(Stream):
             except NoAudioSourceFound as e:
                 if self._audio_flags & MediaStream.Flags.REQUIRED:
                     raise e
-                self.stream_audio = None
+                self.microphone = None
 
     @staticmethod
     def _filter_flags(flags: Optional[Flags]) -> Flags:
@@ -236,10 +249,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)