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:
