async def offer(self, data): s_server = data['servers'][0].split(":") STUN_SERVER = (s_server[1], int(s_server[2])) self.connection.stun_server = STUN_SERVER self.stun_server = STUN_SERVER await self.connection.gather_candidates() options = {"framerate": "30", "video_size": "1920x1080"} player = MediaPlayer("/dev/video0", format="v4l2", options=options) if player and player.audio: self.pc.addTrack(player.audio) if player and player.video: self.pc.addTrack(player.video) await self.pc.setLocalDescription(await self.pc.createOffer()) data = { "tc": "sdp", "req": 420, "type": "offer", "sdp": self.pc.localDescription.sdp, "handle": 0 } print(data) await self.bot.ws.send(json.dumps(data)) for c in self.connection.local_candidates: data = { "tc": "trickle", "req": 420, "candidate": "candidate:" + aioice.Candidate.to_sdp(c), "handle": self.bot.handle } print(data) await self.bot.ws.send(json.dumps(data))
async def offer(request): params = await request.json() offer = RTCSessionDescription(sdp=params["sdp"], type=params["type"]) pc = RTCPeerConnection() pc_id = "PeerConnection(%s)" % uuid.uuid4() pcs.add(pc) def log_info(msg, *args): logger.info(pc_id + " " + msg, *args) log_info("Created for %s", request.remote) # prepare local media player = MediaPlayer("alsa_input.pci-0000_00_1f.3.analog-stereo", format="pulse") recorder = MediaRecorder("alsa_output.pci-0000_00_1f.3.analog-stereo", format="pulse") @pc.on("datachannel") def on_datachannel(channel): @channel.on("message") def on_message(message): if isinstance(message, str) and message.startswith("ping"): channel.send("pong" + message[4:]) @pc.on("iceconnectionstatechange") async def on_iceconnectionstatechange(): log_info("ICE connection state is %s", pc.iceConnectionState) if pc.iceConnectionState == "failed": await pc.close() pcs.discard(pc) @pc.on("track") def on_track(track): log_info("Track %s received", track.kind) if track.kind == "audio": pc.addTrack(player.audio) recorder.addTrack(track) @track.on("ended") async def on_ended(): log_info("Track %s ended", track.kind) await recorder.stop() # handle offer await pc.setRemoteDescription(offer) await recorder.start() # send answer answer = await pc.createAnswer() await pc.setLocalDescription(answer) return web.Response( content_type="application/json", text=json.dumps( {"sdp": pc.localDescription.sdp, "type": pc.localDescription.type} ), )
async def offer(request): params = await request.json() offer = RTCSessionDescription(sdp=params['sdp'], type=params['type']) pc = RTCPeerConnection() pcs.add(pc) # prepare local media player = MediaPlayer(os.path.join(ROOT, 'demo-instruct.wav')) if args.write_audio: recorder = MediaRecorder(args.write_audio) else: recorder = MediaBlackhole() @pc.on('datachannel') def on_datachannel(channel): @channel.on('message') def on_message(message): if isinstance(message, str) and message.startswith('ping'): channel.send('pong' + message[4:]) @pc.on('iceconnectionstatechange') async def on_iceconnectionstatechange(): print('ICE connection state is %s' % pc.iceConnectionState) if pc.iceConnectionState == 'failed': await pc.close() pcs.discard(pc) @pc.on('track') def on_track(track): print('Track %s received' % track.kind) if track.kind == 'audio': pc.addTrack(player.audio) recorder.addTrack(track) elif track.kind == 'video': local_video = VideoTransformTrack( track, transform=params['video_transform']) pc.addTrack(local_video) @track.on('ended') async def on_ended(): print('Track %s ended' % track.kind) await recorder.stop() # handle offer await pc.setRemoteDescription(offer) await recorder.start() # send answer answer = await pc.createAnswer() await pc.setLocalDescription(answer) return web.Response(content_type='application/json', text=json.dumps({ 'sdp': pc.localDescription.sdp, 'type': pc.localDescription.type }))
async def create_connection(is_caller=True, desc=None): # def add_tracks(): # if player and player.audio: # print("ADD AUDIO") # pc.addTrack(player.audio) # if player and player.video: # print("ADD VIDEO") # pc.addTrack(player.video) pc = RTCPeerConnection(configuration=RTCConfiguration( iceServers=[RTCIceServer(urls=['stun:stun.l.google.com:19302'])])) player = MediaPlayer("output.wav") recorder = MediaRecorder( '/Users/pjc/Server/webrtc-connection-test/result.wav') pc.addTrack(player.audio) @pc.on("track") def on_track(track): print(f"Track received {track.kind}") if track.kind == "audio": recorder.addTrack(track) @track.on("ended") async def on_ended(): print(f"Track {track.kind} ended") await recorder.stop() @pc.on("datachannel") def on_datachannel(channel): @channel.on("message") def on_message(message): if isinstance(message, str) and message.startswith("ping"): channel.send("pong" + message[4:]) @pc.on('icecandidate') def icecandidate(item): print("icecandidate") @pc.on("iceconnectionstatechange") async def on_iceconnectionstatechange(): print(f"ICE connection state is {pc.iceConnectionState}") if pc.iceConnectionState == "failed": await pc.close() if is_caller: print("createOffer With Bind") sd = await pc.createOffer() await pc.setLocalDescription(sd) await recorder.start() else: print("Bind Offer With Create Answer") await pc.setRemoteDescription(desc) sd = await pc.createAnswer() await pc.setLocalDescription(sd) await recorder.start() return pc.localDescription, pc, recorder
async def offer(request): params = await request.json() offer = RTCSessionDescription(sdp=params["sdp"], type=params["type"]) pc = RTCPeerConnection() pcs.add(pc) @pc.on("iceconnectionstatechange") async def on_iceconnectionstatechange(): print("ICE connection state is %s" % pc.iceConnectionState) if pc.iceConnectionState == "failed": await pc.close() pcs.discard(pc) # open media source if args.play_from: player = MediaPlayer(args.play_from) else: options = {"framerate": "30", "video_size": "640x480"} print(f"platform: {platform.system()} ") if platform.system() == "Darwin": player = MediaPlayer("default:none", format="avfoundation", options=options) else: player = MediaPlayer("/dev/video0", format="v4l2", options=options) await pc.setRemoteDescription(offer) for t in pc.getTransceivers(): print(f"transceiver {t} {t.kind}") if t.kind == "audio" and player.audio: pc.addTrack(player.audio) elif t.kind == "video" and player.video: pc.addTrack(player.video) answer = await pc.createAnswer() await pc.setLocalDescription(answer) print(f"SDP: {pc.localDescription.sdp}") return web.Response( content_type="application/json", text=json.dumps({ "sdp": pc.localDescription.sdp, "type": pc.localDescription.type }), )
async def offer(request): params = await request.json() offer = RTCSessionDescription(sdp=params['sdp'], type=params['type']) pc = RTCPeerConnection() pcs.add(pc) @pc.on('iceconnectionstatechange') async def on_iceconnectionstatechange(): print('ICE connection state is %s' % pc.iceConnectionState) if pc.iceConnectionState == 'failed': await pc.close() pcs.discard(pc) # open webcam options = { 'video_size': '640x480', 'frame_rate': '30', } if platform.system() == 'Darwin': player = MediaPlayer('default:none', format='avfoundation', options=options) else: player = MediaPlayer('/dev/video0', format='v4l2', options=options) await pc.setRemoteDescription(offer) for t in pc.getTransceivers(): if t.kind == 'audio' and player.audio: pc.addTrack(player.audio) elif t.kind == 'video' and player.video: pc.addTrack(player.video) answer = await pc.createAnswer() await pc.setLocalDescription(answer) return web.Response(content_type='application/json', text=json.dumps({ 'sdp': pc.localDescription.sdp, 'type': pc.localDescription.type }))
async def __get_tracks(self): if self.bitrate: video_options = { "video_size": self.resolution, "framerate": "30", "b:v": self.bitrate } else: video_options = {"video_size": self.resolution, "framerate": "30"} if platform.system() == "Windows": video_track = MediaPlayer("video=HP TrueVision HD Camera", format="dshow", options=video_options).video else: video_track = MediaPlayer("/dev/video0", format="v4l2", options=video_options).video return video_track
async def offer(request): params = await request.json() offer = RTCSessionDescription(sdp=params['sdp'], type=params['type']) pc = RTCPeerConnection() pcs.add(pc) # prepare local media player = MediaPlayer(os.path.join(ROOT, 'demo-instruct.wav')) if args.write_audio: recorder = MediaRecorder(args.write_audio) else: recorder = MediaBlackhole() @pc.on('datachannel') async def on_datachannel(channel): closed = asyncio.Event() queue = asyncio.Queue() print("Channel opened") @channel.on('close') def on_close(): print("Channel closed") closed.set() @channel.on('message') async def on_message(message): await queue.put(message) #channel.send(message) print(message) await cloud_browser(channel, closed, queue) @pc.on('iceconnectionstatechange') async def on_iceconnectionstatechange(): print('ICE connection state is %s' % pc.iceConnectionState) if pc.iceConnectionState == 'failed': await pc.close() pcs.discard(pc) # handle offer await pc.setRemoteDescription(offer) await recorder.start() # send answer answer = await pc.createAnswer() await pc.setLocalDescription(answer) return web.Response(content_type='application/json', text=json.dumps({ 'sdp': pc.localDescription.sdp, 'type': pc.localDescription.type }))
def create_local_tracks(play_from): global relay, webcam if play_from: #player = MediaPlayer(play_from) return FlagVideoStreamTrack() else: options = {"framerate": "30", "video_size": "640x480"} if relay is None: if platform.system() == "Darwin": webcam = MediaPlayer( "default:none", format="avfoundation", options=options ) elif platform.system() == "Windows": webcam = MediaPlayer( "video=Integrated Camera", format="dshow", options=options ) else: webcam = MediaPlayer("/dev/video0", format="v4l2", options=options) relay = MediaRelay() return None, relay.subscribe(webcam.video)
async def offer(request): params = await request.json() offer = RTCSessionDescription(sdp=params['sdp'], type=params['type']) pc = RTCPeerConnection() pcs.append(pc) player = MediaPlayer('/dev/video0', {'video_size': 'vga'}) pc.addTrack(player.video) await pc.setRemoteDescription(offer) answer = await pc.createAnswer() await pc.setLocalDescription(answer) player.start() return web.Response(content_type='application/json', text=json.dumps({ 'sdp': pc.localDescription.sdp, 'type': pc.localDescription.type }))
def create_local_tracks(play_from=None): if play_from: player = MediaPlayer(play_from) return player.audio, player.video else: options = {"framerate": "30", "video_size": "1920x1080"} # if relay is None: # if platform.system() == "Darwin": # webcam = MediaPlayer( # "default:none", format="avfoundation", options=options # ) # elif platform.system() == "Windows": # webcam = MediaPlayer("video.mp4") webcam = MediaPlayer("video=FULL HD 1080P Webcam", format="dshow", options=options) # else: # webcam = MediaPlayer("/dev/video0", format="v4l2", options=options) # audio, video = VideoTransformTrack(webcam.video, transform="cv") relay = MediaRelay() return None, relay.subscribe(webcam.video)
def get_tracks(): video_options = { "video_size": "1280x720", "vcodec": "h264", "b:v": "1800k" } audio_options = {"acodec": "libmp3lame", "b:a": "128k", "ar": "44100"} audio_track = MediaPlayer( "anullsrc=channel_layout=stereo:sample_rate=44100", format='lavfi', options=audio_options).audio if platform.system() == "Windows": video_track = MediaPlayer("video=HP TrueVision HD Camera", format="dshow", options=video_options).video else: video_track = MediaPlayer("/dev/video0", format="v4l2", options=video_options).video return audio_track, video_track
def __init__(self, serverAddress, peer_type='media-server', id=None, key=None, media_source=None, media_sink=None, frame_generator=None, frame_consumer=None, frame_rate=30, ssl_context=None, datachannel_options=None, media_source_format=None): self.url = serverAddress + '/' + peer_type if id: self.url += '/' + id if key: self.url += '/' + key self.id = str(id) self._ws = None self._pc = None self.readyState = PeerState.STARTING self.disconnection_event = asyncio.Event() self._datachannel = None self._handle_candidates_task = None self._data = None self._data_handlers = [] self._frame_generator = frame_generator self._frame_rate = frame_rate if frame_consumer: self._frame_consumer_feeder = FrameConsumerFeeder(frame_consumer) else: self._frame_consumer_feeder = None self._track_consumer_task = None self._ssl_context = ssl_context self._remote_track_monitor_task = None self._connection_monitor_task = None self._datachannel_options = datachannel_options if media_source != None: if media_source == '': raise Exception('Empty media source path!') else: try: MediaPlayer(media_source) except Exception as av_error: logging.exception('Media source error: ' + str(av_error)) raise self._media_source = media_source self._media_source_format = media_source_format self._player = None
async def offer(request): request_url = request.match_info['stream'] streams = await get_streams(args.nvr_token) if request_url not in streams: raise web.HTTPNotFound(text='No rtsp source related to this url') play_from = streams[request_url] if not play_from: raise web.HTTPBadGateway( text= 'NVR response with cam rtsp link is empty. Contact NVR admins to fix it' ) url = urlparse(play_from) if url.scheme == 'rtsp': await check_rtsp_availability(play_from, timeout=10) params = await request.json() offer = RTCSessionDescription(sdp=params["sdp"], type=params["type"]) pc = RTCPeerConnection() pcs.add(pc) @pc.on("iceconnectionstatechange") async def on_iceconnectionstatechange(): print("ICE connection state is %s" % pc.iceConnectionState) if pc.iceConnectionState == "failed": await pc.close() pcs.discard(pc) player = MediaPlayer(play_from) await pc.setRemoteDescription(offer) for t in pc.getTransceivers(): if t.kind == "audio" and player.audio: pc.addTrack(player.audio) elif t.kind == "video" and player.video: track = VideoTransformTrack(player.video, request_url) pc.addTrack(track) answer = await pc.createAnswer() await pc.setLocalDescription(answer) return web.Response(content_type="application/json", headers=cors_headers, text=json.dumps({ "sdp": pc.localDescription.sdp, "type": pc.localDescription.type }))
async def offer(request): params = await request.json() offer = RTCSessionDescription( sdp=params['sdp'], type=params['type']) pc = RTCPeerConnection() pcs.add(pc) # prepare local media player = MediaPlayer('hw:1', format='alsa', options={'channels': '1'}) recorder = MediaRecorder('plughw:0,0', format='alsa') @pc.on('iceconnectionstatechange') async def on_iceconnectionstatechange(): print('ICE connection state is %s' % pc.iceConnectionState) if pc.iceConnectionState == 'failed': await pc.close() pcs.discard(pc) @pc.on('track') def on_track(track): print('Track %s received' % track.kind) pc.addTrack(player.audio) recorder.addTrack(track) @track.on('ended') async def on_ended(): print('Track %s ended' % track.kind) await recorder.stop() # handle offer await pc.setRemoteDescription(offer) await recorder.start() # send answer answer = await pc.createAnswer() await pc.setLocalDescription(answer) return web.Response( content_type='application/json', text=json.dumps({ 'sdp': pc.localDescription.sdp, 'type': pc.localDescription.type }))
def test_video_file(self): player = MediaPlayer(path=self.video_path) # read all frames player.play() for i in range(20): frame = run(player.video.recv()) self.assertEqual(len(frame.data), 460800) self.assertEqual(frame.width, 640) self.assertEqual(frame.height, 480) player.stop()
def test_video_file_mp4(self): path = self.create_video_file("test.mp4", duration=3) player = MediaPlayer(path) # check tracks self.assertIsNone(player.audio) self.assertIsNotNone(player.video) # read all frames self.assertEqual(player.video.readyState, "live") for i in range(90): frame = run(player.video.recv()) self.assertEqual(frame.width, 640) self.assertEqual(frame.height, 480) with self.assertRaises(MediaStreamError): run(player.video.recv()) self.assertEqual(player.video.readyState, "ended")
def test_audio_file(self): player = MediaPlayer(path=self.audio_path) # read all frames player.play() for i in range(50): frame = run(player.audio.recv()) self.assertEqual(frame.channels, 1) self.assertEqual(len(frame.data), 320) self.assertEqual(frame.sample_rate, 8000) self.assertEqual(frame.sample_width, 2) player.stop()
async def test_audio_file_looping(self): path = self.create_audio_file("test.wav", sample_rate=48000) player = MediaPlayer(path, loop=True) # read all frames, then loop and re-read all frames self.assertEqual(player.audio.readyState, "live") for i in range(100): frame = await player.audio.recv() self.assertEqual(frame.format.name, "s16") self.assertEqual(frame.layout.name, "stereo") self.assertEqual(frame.samples, 960) self.assertEqual(frame.sample_rate, 48000) # read one more time, forcing a second loop await player.audio.recv() self.assertEqual(player.audio.readyState, "live") # stop the player player.audio.stop()
def test_audio_file_48kHz(self): path = self.create_audio_file("test.wav", sample_rate=48000) player = MediaPlayer(path) # check tracks self.assertIsNotNone(player.audio) self.assertIsNone(player.video) # read all frames self.assertEqual(player.audio.readyState, "live") for i in range(50): frame = run(player.audio.recv()) self.assertEqual(frame.format.name, "s16") self.assertEqual(frame.layout.name, "stereo") self.assertEqual(frame.samples, 960) self.assertEqual(frame.sample_rate, 48000) with self.assertRaises(MediaStreamError): run(player.audio.recv()) self.assertEqual(player.audio.readyState, "ended")
def start_peer(room=None, signaling_folder=None, play_from=None, record_to=None, frame_transformer=None, verbose=False, ice_servers=None, multiprocess=False): if verbose: logging.basicConfig(level=logging.DEBUG) else: logging.basicConfig(level=logging.INFO) if ice_servers: logger.debug('Using ICE servers:', ice_servers) servers = [RTCIceServer(*server) if type(server) == tuple else RTCIceServer(server) for server in ice_servers] pc = RTCPeerConnection( configuration=RTCConfiguration(servers)) else: pc = RTCPeerConnection() # room = str(room) if signaling_folder: signaling = ColabSignaling(signaling_folder=signaling_folder, room=room) else: signaling = ColabApprtcSignaling(room=room) # create media source if play_from: player = MediaPlayer(play_from) else: player = None # create media sink if record_to: recorder = MediaRecorder(record_to) else: recorder = MediaBlackhole() if multiprocess: p = Process(target=run_process, args=(pc, player, recorder, signaling, frame_transformer)) p.start() return signaling.room, p else: run_process(pc, player, recorder, signaling, frame_transformer) return signaling.room, None
async def publish(plugin, player): """ Send video to the room. """ # player = MediaPlayer('/home/pi/my_project/car.MP4') player = MediaPlayer('/dev/video0', format='v4l2', options={'video_size': '320x240'}) pc = RTCPeerConnection() pcs.add(pc) # configure media media = {"audio": False, "video": True} if player and player.audio: pc.addTrack(player.audio) media["audio"] = True if player and player.video: pc.addTrack(player.video) time.sleep(0.01) # else: # pc.addTrack(VideoStreamTrack()) # send offer await pc.setLocalDescription(await pc.createOffer()) request = {"request": "configure"} request.update(media) response = await plugin.send({ "body": request, "jsep": { "sdp": pc.localDescription.sdp, "trickle": False, "type": pc.localDescription.type, }, }) # apply answer await pc.setRemoteDescription( RTCSessionDescription(sdp=response["jsep"]["sdp"], type=response["jsep"]["type"]))
def test_video_file_mp4_eagain(self): path = self.create_video_file("test.mp4", duration=3) container = BufferingInputContainer(av.open(path, "r")) with patch("av.open") as mock_open: mock_open.return_value = container player = MediaPlayer(path) # check tracks self.assertIsNone(player.audio) self.assertIsNotNone(player.video) # read all frames self.assertEqual(player.video.readyState, "live") for i in range(90): frame = run(player.video.recv()) self.assertEqual(frame.width, 640) self.assertEqual(frame.height, 480) with self.assertRaises(MediaStreamError): run(player.video.recv()) self.assertEqual(player.video.readyState, "ended")
def test_audio_file_8kHz(self): player = MediaPlayer(path=self.audio_path) # check tracks self.assertIsNotNone(player.audio) self.assertIsNone(player.video) # read all frames player.start() for i in range(49): frame = run(player.audio.recv()) self.assertEqual(frame.channels, 1) self.assertEqual(len(frame.data), 1920) self.assertEqual(frame.sample_rate, 48000) self.assertEqual(frame.sample_width, 2) player.stop()
async def offer(request): params = await request.json() from pprint import pprint pprint(params) offer = RTCSessionDescription(sdp=params["sdp"], type=params["type"]) pc = RTCPeerConnection() ACTIVE_PEERCONNECTIONS.add(pc) @pc.on("iceconnectionstatechange") async def on_iceconnectionstatechange(): print("ICE connection state is %s" % pc.iceConnectionState) if pc.iceConnectionState == "failed": await pc.close() ACTIVE_PEERCONNECTIONS.discard(pc) await pc.setRemoteDescription(offer) options = {"framerate": "30", "video_size": "640x480"} player = MediaPlayer("default:none", format="avfoundation", options=options) for t in pc.getTransceivers(): if t.kind == "audio" and player.audio: pc.addTrack(player.audio) elif t.kind == "video" and player.video: pc.addTrack(player.video) # for t in pc.getTransceivers(): # pprint(t.kind) # if t.kind == "video": # pc.addTrack(FlagVideoStreamTrack()) # print('added') answer = await pc.createAnswer() await pc.setLocalDescription(answer) return UJSONResponse({ "sdp": pc.localDescription.sdp, "type": pc.localDescription.type })
def test_audio_file_8kHz(self): path = self.create_audio_file('test.wav') player = MediaPlayer(path) # check tracks self.assertIsNotNone(player.audio) self.assertIsNone(player.video) # read all frames self.assertEqual(player.audio.readyState, 'live') for i in range(49): frame = run(player.audio.recv()) self.assertEqual(frame.format.name, 's16') self.assertEqual(frame.layout.name, 'mono') self.assertEqual(frame.samples, 960) self.assertEqual(frame.sample_rate, 48000) with self.assertRaises(MediaStreamError): run(player.audio.recv()) self.assertEqual(player.audio.readyState, 'ended') # try reading again with self.assertRaises(MediaStreamError): run(player.audio.recv())
async def run(pc): session = ClientSession() async with session.ws_connect("ws://39.102.116.49:8080") as ws: async for msg in ws: if msg.type == WSMsgType.TEXT: data = json.loads(msg.data) if data["type"] == "offerOrAnswer": await pc.setRemoteDescription( object_from_string(json.dumps(data["msg"])) ) if data["msg"]["type"] == "offer": pc.addTrack( MediaPlayer( "/dev/video0", format="v4l2", options=options ).video ) await pc.setLocalDescription(await pc.createAnswer()) await ws.send_str( json.dumps( { "type": "offerOrAnswer", "msg": json.loads( object_to_string(pc.localDescription) ), } ) ) elif data["type"] == "candidate": try: await pc.addIceCandidate( object_from_string(json.dumps(data["msg"])) ) except: pass
async def offer(request): params = await request.json() offer = RTCSessionDescription(sdp=params["sdp"], type=params["type"]) pc = RTCPeerConnection() pcs.add(pc) @pc.on("iceconnectionstatechange") async def on_iceconnectionstatechange(): print("ICE connection state is %s" % pc.iceConnectionState) if pc.iceConnectionState == "failed": await pc.close() pcs.discard(pc) # open media source if args.play_from: player = MediaPlayer(args.play_from) else: player = None await pc.setRemoteDescription(offer) for t in pc.getTransceivers(): if t.kind == "audio" and player and player.audio: pc.addTrack(player.audio) elif t.kind == "video": pc.addTrack(videoStream) answer = await pc.createAnswer() await pc.setLocalDescription(answer) return web.Response( content_type="application/json", text=json.dumps({ "sdp": pc.localDescription.sdp, "type": pc.localDescription.type }), )
async def offer(request): params = await request.json() offer = RTCSessionDescription(sdp=params["sdp"], type=params["type"]) pc = RTCPeerConnection() pcs.add(pc) @pc.on("iceconnectionstatechange") async def on_iceconnectionstatechange(): print("ICE connection state is %s" % pc.iceConnectionState) if pc.iceConnectionState == "failed": await pc.close() pcs.discard(pc) cam = db.get_camera(int(params['id'])) player = MediaPlayer(cam.url, options={"rtsp_transport": "tcp"}) #frameserver.get_player(cam.name) await pc.setRemoteDescription(offer) for t in pc.getTransceivers(): if t.kind == "audio" and player.audio: pc.addTrack(player.audio) elif t.kind == "video" and player.video: pc.addTrack(player.video) answer = await pc.createAnswer() await pc.setLocalDescription(answer) return web.Response( content_type="application/json", text=json.dumps({ "sdp": pc.localDescription.sdp, "type": pc.localDescription.type }), )
if __name__ == "__main__": parser = argparse.ArgumentParser(description="PyMediaSoup") parser.add_argument("room", nargs="?") parser.add_argument("--play-from", help="Read the media from a file and sent it.") parser.add_argument("--record-to", help="Write received media to a file.") args = parser.parse_args() if not args.room: args.room = secrets.token_urlsafe(8).lower() peerId = secrets.token_urlsafe(8).lower() uri = f'wss://v3demo.mediasoup.org:4443/?roomId={args.room}&peerId={peerId}' if args.play_from: player = MediaPlayer(args.play_from) else: player = None # create media sink if args.record_to: recorder = MediaRecorder(args.record_to) else: recorder = MediaBlackhole() # run event loop loop = asyncio.get_event_loop() try: demo = Demo(uri=uri, player=player, recorder=recorder) loop.run_until_complete(demo.run()) except KeyboardInterrupt: