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

pytgcalls/methods/stream/play.py

@@ -6,6 +6,7 @@ from typing import Union
 from ntgcalls import ConnectionNotFound
 from ntgcalls import FileError
 from ntgcalls import InvalidParams
+from ntgcalls import StreamMode
 from ntgcalls import TelegramServerError
 
 from ...exceptions import NoActiveGroupCall
@@ -36,6 +37,11 @@ class Play(Scaffold):
         stream: Optional[Stream] = None,
         config: Optional[Union[CallConfig, GroupCallConfig]] = None,
     ):
+        def log_retries(r: int):
+            (py_logger.warning if r >= 1 else py_logger.info)(
+                f'Telegram is having some internal server issues. '
+                f'Retrying {r + 1} of 3',
+            )
         chat_id = await self.resolve_chat_id(chat_id)
         is_p2p = chat_id > 0  # type: ignore
         if config is None:
@@ -50,8 +56,9 @@ class Play(Scaffold):
 
         if chat_id in await self._binding.calls():
             try:
-                return await self._binding.change_stream(
+                return await self._binding.set_stream_sources(
                     chat_id,
+                    StreamMode.CAPTURE,
                     media_description,
                 )
             except FileError as e:
@@ -80,31 +87,36 @@ class Play(Scaffold):
                 try:
                     self._wait_connect[chat_id] = self.loop.create_future()
                     if isinstance(config, GroupCallConfig):
-                        call_params: str = await self._binding.create_call(
+                        payload: str = await self._binding.create_call(
                             chat_id,
                             media_description,
                         )
                         result_params = await self._app.join_group_call(
                             chat_id,
-                            call_params,
+                            payload,
                             config.invite_hash,
-                            media_description.video is None,
+                            media_description.camera is None and
+                            media_description.screen is None,
                             self._cache_user_peer.get(chat_id),
                         )
                         await self._binding.connect(
                             chat_id,
                             result_params,
+                            False,
                         )
                     else:
                         data = self._p2p_configs.setdefault(
                             chat_id,
                             CallData(await self._app.get_dhc(), self.loop),
                         )
-                        data.g_a_or_b = await self._binding.create_p2p_call(
+                        await self._binding.create_p2p_call(
+                            chat_id,
+                            media_description,
+                        )
+                        data.g_a_or_b = await self._binding.init_exchange(
                             chat_id,
                             data.dh_config,
                             data.g_a_or_b,
-                            media_description,
                         )
                         if not data.outgoing:
                             await self._app.accept_call(
@@ -143,7 +155,10 @@ class Play(Scaffold):
                                 result.protocol.p2p_allowed,
                             )
                         except asyncio.TimeoutError:
-                            self._binding.stop(chat_id)
+                            try:
+                                await self._binding.stop(chat_id)
+                            except ConnectionNotFound:
+                                pass
                             raise TimedOutAnswer()
                         finally:
                             self._p2p_configs.pop(chat_id, None)
@@ -152,10 +167,7 @@ class Play(Scaffold):
                 except TelegramServerError:
                     if retries == 3 or is_p2p:
                         raise
-                    (py_logger.warning if retries >= 1 else py_logger.info)(
-                        f'Telegram is having some internal server issues. '
-                        f'Retrying {retries + 1} of 3',
-                    )
+                    log_retries(retries)
                 except Exception:
                     try:
                         await self._binding.stop(chat_id)
@@ -165,11 +177,61 @@ class Play(Scaffold):
                 finally:
                     self._wait_connect.pop(chat_id, None)
 
+            if isinstance(config, GroupCallConfig):
+                if media_description.screen is not None:
+                    for retries in range(4):
+                        try:
+                            self._wait_connect[
+                                chat_id
+                            ] = self.loop.create_future()
+                            payload = await self._binding.init_presentation(
+                                chat_id,
+                            )
+                            result_params = await self._app.join_presentation(
+                                chat_id,
+                                payload,
+                            )
+                            await self._binding.connect(
+                                chat_id,
+                                result_params,
+                                True,
+                            )
+                            await self._wait_connect[chat_id]
+                            self._presentations.add(chat_id)
+                        except TelegramServerError:
+                            if retries == 3:
+                                raise
+                            log_retries(retries)
+                        finally:
+                            self._wait_connect.pop(chat_id, None)
+                elif chat_id in self._presentations:
+                    await self._binding.stop_presentation(chat_id)
+                    await self._app.leave_presentation(chat_id)
+                    self._presentations.discard(chat_id)
+
             if isinstance(config, GroupCallConfig):
                 participants = await self._app.get_group_call_participants(
                     chat_id,
                 )
                 for x in participants:
+                    if x.video_info is not None:
+                        self._videos_id[
+                            chat_id
+                        ] = x.video_info.endpoint
+                        self._binding.add_incoming_video(
+                            chat_id,
+                            x.video_info.endpoint,
+                            x.video_info.sources,
+                        )
+                    if x.presentation_info is not None:
+                        self._presentations_id[
+                            chat_id
+                        ] = x.presentation_info.endpoint
+                        self._binding.add_incoming_video(
+                            chat_id,
+                            x.presentation_info.endpoint,
+                            x.presentation_info.sources,
+                        )
                     if x.user_id == BridgedClient.chat_id(
                         self._cache_local_peer,
                     ) and x.muted_by_admin:

pytgcalls/methods/stream/record.py

@@ -0,0 +1,41 @@
+import logging
+from typing import Optional
+from typing import Union
+
+from ntgcalls import FileError
+from ntgcalls import StreamMode
+
+from ...mtproto_required import mtproto_required
+from ...scaffold import Scaffold
+from ...statictypes import statictypes
+from ...types import CallConfig
+from ...types import GroupCallConfig
+from ...types.raw import Stream
+from ..utilities.stream_params import StreamParams
+
+py_logger = logging.getLogger('pytgcalls')
+
+
+class Record(Scaffold):
+    @statictypes
+    @mtproto_required
+    async def record(
+        self,
+        chat_id: Union[int, str],
+        stream: Optional[Stream] = None,
+        config: Optional[Union[CallConfig, GroupCallConfig]] = None,
+    ):
+        chat_id = await self.resolve_chat_id(chat_id)
+        media_description = await StreamParams.get_record_params(
+            stream,
+        )
+        if chat_id not in await self._binding.calls():
+            await self.play(chat_id, config=config)
+        try:
+            return await self._binding.set_stream_sources(
+                chat_id,
+                StreamMode.PLAYBACK,
+                media_description,
+            )
+        except FileError as e:
+            raise FileNotFoundError(e)

pytgcalls/methods/stream/{played_time.py → time.py}

@@ -1,6 +1,7 @@
 from typing import Union
 
 from ntgcalls import ConnectionNotFound
+from ntgcalls import StreamMode
 
 from ...exceptions import NotInCallError
 from ...mtproto_required import mtproto_required
@@ -8,15 +9,16 @@ from ...scaffold import Scaffold
 from ...statictypes import statictypes
 
 
-class PlayedTime(Scaffold):
+class Time(Scaffold):
     @statictypes
     @mtproto_required
-    async def played_time(
+    async def time(
         self,
         chat_id: Union[int, str],
+        stream_mode: StreamMode = StreamMode.CAPTURE,
     ):
         chat_id = await self.resolve_chat_id(chat_id)
         try:
-            return await self._binding.time(chat_id)
+            return await self._binding.time(chat_id, stream_mode)
         except ConnectionNotFound:
             raise NotInCallError()

pytgcalls/methods/utilities/call_holder.py

@@ -9,7 +9,7 @@ class CallHolder(Scaffold):
     def __init__(self):
         super().__init__()
         self._conversions = {
-            StreamStatus.PLAYING: Call.Status.PLAYING,
+            StreamStatus.ACTIVE: Call.Status.ACTIVE,
             StreamStatus.PAUSED: Call.Status.PAUSED,
             StreamStatus.IDLING: Call.Status.IDLE,
         }
@@ -18,7 +18,10 @@ class CallHolder(Scaffold):
     async def calls(self):
         calls_list = await self._binding.calls()
         return Dict({
-            x: Call(x, self._conversions[calls_list[x]])
+            x: Call(
+                x, self._conversions[calls_list[x].playback],
+                self._conversions[calls_list[x].capture],
+            )
             for x in calls_list
         })
 

pytgcalls/methods/utilities/start.py

@@ -1,10 +1,14 @@
 import asyncio
 import logging
 
+from ntgcalls import CallNetworkState
 from ntgcalls import ConnectionError
 from ntgcalls import ConnectionNotFound
 from ntgcalls import ConnectionState
+from ntgcalls import FrameData
 from ntgcalls import MediaState
+from ntgcalls import StreamDevice
+from ntgcalls import StreamMode
 from ntgcalls import StreamType
 from ntgcalls import TelegramServerError
 
@@ -16,10 +20,12 @@ from ...pytgcalls_session import PyTgCallsSession
 from ...scaffold import Scaffold
 from ...types import CallData
 from ...types import ChatUpdate
+from ...types import Device
+from ...types import Direction
 from ...types import GroupCallParticipant
 from ...types import RawCallUpdate
-from ...types import StreamAudioEnded
-from ...types import StreamVideoEnded
+from ...types import StreamEnded
+from ...types import StreamFrame
 from ...types import Update
 from ...types import UpdatedGroupCallParticipant
 
@@ -84,6 +90,56 @@ class Start(Scaffold):
                 participant = update.participant
                 action = participant.action
                 chat_peer = self._cache_user_peer.get(chat_id)
+                user_id = participant.user_id
+                was_camera = user_id in self._videos_id
+                was_screen = user_id in self._presentations_id
+
+                if was_camera != participant.video_camera:
+                    if participant.video_info:
+                        self._videos_id[
+                            user_id
+                        ] = participant.video_info.endpoint
+                        try:
+                            await self._binding.add_incoming_video(
+                                chat_id,
+                                participant.video_info.endpoint,
+                                participant.video_info.sources,
+                            )
+                        except ConnectionNotFound:
+                            pass
+                    elif user_id in self._videos_id:
+                        try:
+                            await self._binding.remove_incoming_video(
+                                chat_id,
+                                self._videos_id[user_id],
+                            )
+                        except ConnectionNotFound:
+                            pass
+                        self._videos_id.pop(user_id)
+
+                if was_screen != participant.screen_sharing:
+                    if participant.presentation_info:
+                        self._presentations_id[
+                            user_id
+                        ] = participant.presentation_info.endpoint
+                        try:
+                            await self._binding.add_incoming_video(
+                                chat_id,
+                                participant.presentation_info.endpoint,
+                                participant.presentation_info.sources,
+                            )
+                        except ConnectionNotFound:
+                            pass
+                    elif user_id in self._presentations_id:
+                        try:
+                            await self._binding.remove_incoming_video(
+                                chat_id,
+                                self._presentations_id[user_id],
+                            )
+                        except ConnectionNotFound:
+                            pass
+                        self._presentations_id.pop(user_id)
+
                 if chat_peer:
                     is_self = BridgedClient.chat_id(
                         chat_peer,
@@ -141,18 +197,22 @@ class Start(Scaffold):
                     state.muted,
                     state.video_paused,
                     state.video_stopped,
+                    state.presentation_paused,
                     self._cache_user_peer.get(chat_id),
                 )
             except Exception as e:
                 py_logger.debug(f'SetVideoCallStatus: {e}')
 
-        async def stream_ended(chat_id: int, stream: StreamType):
+        async def stream_ended(
+            chat_id: int,
+            stream_type: StreamType,
+            device: StreamDevice,
+        ):
             await self.propagate(
-                StreamAudioEnded(
-                    chat_id,
-                ) if stream == StreamType.AUDIO else
-                StreamVideoEnded(
+                StreamEnded(
                     chat_id,
+                    StreamEnded.Type.from_raw(stream_type),
+                    Device.from_raw(device),
                 ),
                 self,
             )
@@ -166,7 +226,36 @@ class Start(Scaffold):
             except (ConnectionError, ConnectionNotFound):
                 pass
 
-        async def connection_changed(chat_id: int, state: ConnectionState):
+        async def stream_frame(
+            chat_id: int,
+            source_id: int,
+            mode: StreamMode,
+            device: StreamDevice,
+            frame: bytes,
+            frame_info: FrameData,
+        ):
+            await self.propagate(
+                StreamFrame(
+                    chat_id,
+                    source_id,
+                    Direction.from_raw(mode),
+                    Device.from_raw(device),
+                    frame,
+                    StreamFrame.Info(
+                        frame_info.absolute_capture_timestamp_ms,
+                        frame_info.width,
+                        frame_info.height,
+                        frame_info.rotation,
+                    ),
+                ),
+                self,
+            )
+
+        async def connection_changed(
+            chat_id: int,
+            net_state: CallNetworkState,
+        ):
+            state = net_state.connection_state
             if state == ConnectionState.CONNECTING:
                 return
             if chat_id in self._wait_connect:
@@ -209,20 +298,22 @@ class Start(Scaffold):
                 self._handle_mtproto()
 
             self._binding.on_stream_end(
-                lambda chat_id, stream: asyncio.run_coroutine_threadsafe(
-                    stream_ended(chat_id, stream),
+                lambda chat_id, stream_type, device:
+                asyncio.run_coroutine_threadsafe(
+                    stream_ended(chat_id, stream_type, device),
                     self.loop,
                 ),
             )
             self._binding.on_upgrade(
-                lambda chat_id, state: asyncio.run_coroutine_threadsafe(
+                lambda chat_id, state:
+                asyncio.run_coroutine_threadsafe(
                     update_status(chat_id, state),
                     self.loop,
                 ),
             )
             self._binding.on_connection_change(
-                lambda chat_id, state: asyncio.run_coroutine_threadsafe(
-                    connection_changed(chat_id, state),
+                lambda chat_id, net_state: asyncio.run_coroutine_threadsafe(
+                    connection_changed(chat_id, net_state),
                     self.loop,
                 ),
             )
@@ -232,6 +323,20 @@ class Start(Scaffold):
                     self.loop,
                 ),
             )
+            self._binding.on_frame(
+                lambda chat_id, source_id, mode, device, frame, info:
+                asyncio.run_coroutine_threadsafe(
+                    stream_frame(
+                        chat_id,
+                        source_id,
+                        mode,
+                        device,
+                        frame,
+                        info,
+                    ),
+                    self.loop,
+                ),
+            )
             await PyTgCallsSession().start()
         else:
             raise PyTgCallsAlreadyRunning()

pytgcalls/methods/utilities/stream_params.py

@@ -1,42 +1,83 @@
 from typing import Optional
+from typing import Union
 
 from ntgcalls import AudioDescription
 from ntgcalls import MediaDescription
 from ntgcalls import VideoDescription
 
-from ...types.raw.stream import Stream
+from ...types.raw import AudioStream
+from ...types.raw import Stream
+from ...types.raw import VideoStream
 from ...types.stream.media_stream import MediaStream
 
 
 class StreamParams:
     @staticmethod
-    async def get_stream_params(stream: Optional[Stream]) -> MediaDescription:
-        audio_description = None
-        video_description = None
-
+    async def get_stream_params(
+        stream: Optional[Stream],
+    ) -> MediaDescription:
         if stream is not None:
             if isinstance(stream, MediaStream):
                 await stream.check_stream()
 
-            if stream.stream_audio is not None:
-                audio_description = AudioDescription(
-                    input_mode=stream.stream_audio.input_mode,
-                    input=stream.stream_audio.path,
-                    sample_rate=stream.stream_audio.parameters.bitrate,
-                    bits_per_sample=16,
-                    channel_count=stream.stream_audio.parameters.channels,
-                )
+        return MediaDescription(
+            microphone=StreamParams._parse_media_description(
+                None if stream is None else stream.microphone,
+            ),
+            speaker=StreamParams._parse_media_description(
+                None if stream is None else stream.speaker,
+            ),
+            camera=StreamParams._parse_media_description(
+                None if stream is None else stream.camera,
+            ),
+            screen=StreamParams._parse_media_description(
+                None if stream is None else stream.screen,
+            ),
+        )
 
-            if stream.stream_video is not None:
-                video_description = VideoDescription(
-                    input_mode=stream.stream_video.input_mode,
-                    input=stream.stream_video.path,
-                    width=stream.stream_video.parameters.width,
-                    height=stream.stream_video.parameters.height,
-                    fps=stream.stream_video.parameters.frame_rate,
+    @staticmethod
+    def _parse_media_description(
+        media: Optional[Union[AudioStream, VideoStream]],
+    ) -> Optional[Union[AudioDescription, VideoDescription]]:
+        if media is not None:
+            if isinstance(media, AudioStream):
+                return AudioDescription(
+                    media_source=media.media_source,
+                    input=media.path,
+                    sample_rate=media.parameters.bitrate,
+                    channel_count=media.parameters.channels,
                 )
+            elif isinstance(media, VideoStream):
+                return VideoDescription(
+                    media_source=media.media_source,
+                    input=media.path,
+                    width=media.parameters.width,
+                    height=media.parameters.height,
+                    fps=media.parameters.frame_rate,
+                )
+        return None
 
+    @staticmethod
+    async def get_record_params(
+        stream: Optional[Stream],
+    ) -> MediaDescription:
+        if stream is not None:
+            if isinstance(stream, MediaStream):
+                raise ValueError(
+                    'Stream should be an instance of '
+                    'RecordStream or a raw Stream',
+                )
         return MediaDescription(
-            audio=audio_description,
-            video=video_description,
+            microphone=StreamParams._parse_media_description(
+                None if stream is None else stream.microphone,
+            ),
+            speaker=StreamParams._parse_media_description(
+                None if stream is None else stream.speaker,
+            ),
+            camera=StreamParams._parse_media_description(
+                None if stream is None else stream.camera,
+            ),
+            screen=StreamParams._parse_media_description(
+                None if stream is None else stream.screen,
+            ),
         )

pytgcalls/mtproto/bridged_client.py

@@ -6,6 +6,7 @@ from typing import Optional
 
 from ntgcalls import Protocol
 from ntgcalls import RTCServer
+from ntgcalls import SsrcGroup
 
 from ..handlers import HandlersHolder
 from ..types import GroupCallParticipant
@@ -29,6 +30,19 @@ class BridgedClient(HandlersHolder):
     ):
         pass
 
+    async def join_presentation(
+        self,
+        chat_id: int,
+        json_join: str,
+    ):
+        pass
+
+    async def leave_presentation(
+        self,
+        chat_id: int,
+    ):
+        pass
+
     async def request_call(
         self,
         user_id: int,
@@ -97,8 +111,9 @@ class BridgedClient(HandlersHolder):
         self,
         chat_id: int,
         muted_status: Optional[bool],
-        paused_status: Optional[bool],
-        stopped_status: Optional[bool],
+        video_paused: Optional[bool],
+        video_stopped: Optional[bool],
+        presentation_paused: Optional[bool],
         participant: Any,
     ):
         pass
@@ -128,6 +143,21 @@ class BridgedClient(HandlersHolder):
     def package_name(obj):
         return str(obj.__class__.__module__).split('.')[0]
 
+    @staticmethod
+    def parse_source(source) -> Optional[GroupCallParticipant.SourceInfo]:
+        if not source:
+            return None
+        return GroupCallParticipant.SourceInfo(
+            source.endpoint,
+            [
+                SsrcGroup(
+                    source_group.semantics,
+                    [ssrc for ssrc in source_group.sources],
+                )
+                for source_group in source.source_groups
+            ],
+        )
+
     @staticmethod
     def parse_participant(participant):
         return GroupCallParticipant(
@@ -143,6 +173,8 @@ class BridgedClient(HandlersHolder):
             if participant.volume is not None else 100,
             bool(participant.just_joined),
             bool(participant.left),
+            BridgedClient.parse_source(participant.video),
+            BridgedClient.parse_source(participant.presentation),
         )
 
     @staticmethod