def test_audio_and_video(self):
recorder = MediaRecorder(path='foo.mp4')
recorder.addTrack(AudioStreamTrack())
recorder.addTrack(VideoStreamTrack())
recorder.start()
run(asyncio.sleep(2))
recorder.stop()
def test_audio_and_video(self):
recorder = MediaRecorder(self.temporary_path('test.mp4'))
recorder.addTrack(AudioStreamTrack())
recorder.addTrack(VideoStreamTrack())
run(recorder.start())
run(asyncio.sleep(2))
run(recorder.stop())
def test_audio_wav_ended(self):
track = AudioStreamTrack()
recorder = MediaRecorder(self.temporary_path("test.wav"))
recorder.addTrack(track)
run(recorder.start())
run(asyncio.sleep(1))
track.stop()
run(asyncio.sleep(1))
run(recorder.stop())
def test_audio_wav(self):
path = self.temporary_path("test.wav")
recorder = MediaRecorder(path)
recorder.addTrack(AudioStreamTrack())
run(recorder.start())
run(asyncio.sleep(2))
run(recorder.stop())
# check output media
container = av.open(path, "r")
self.assertEqual(len(container.streams), 1)
self.assertEqual(container.streams[0].codec.name, "pcm_s16le")
self.assertGreater(
float(container.streams[0].duration * container.streams[0].time_base), 0
)
def test_audio_mp3(self):
path = self.temporary_path('test.mp3')
recorder = MediaRecorder(path)
recorder.addTrack(AudioStreamTrack())
run(recorder.start())
run(asyncio.sleep(2))
run(recorder.stop())
# check output media
container = av.open(path, 'r')
self.assertEqual(len(container.streams), 1)
self.assertIn(container.streams[0].codec.name, ('mp3', 'mp3float'))
self.assertGreater(
float(container.streams[0].duration *
container.streams[0].time_base), 0)
def test_video_mp4(self):
path = self.temporary_path("test.mp4")
recorder = MediaRecorder(path)
recorder.addTrack(VideoStreamTrack())
run(recorder.start())
run(asyncio.sleep(2))
run(recorder.stop())
# check output media
container = av.open(path, "r")
self.assertEqual(len(container.streams), 1)
self.assertEqual(container.streams[0].codec.name, "h264")
self.assertGreater(
float(container.streams[0].duration * container.streams[0].time_base), 0
)
self.assertEqual(container.streams[0].width, 640)
self.assertEqual(container.streams[0].height, 480)
def test_audio_and_video(self):
path = self.temporary_path('test.mp4')
recorder = MediaRecorder(path)
recorder.addTrack(AudioStreamTrack())
recorder.addTrack(VideoStreamTrack())
run(recorder.start())
run(asyncio.sleep(2))
run(recorder.stop())
# check output media
container = av.open(path, 'r')
self.assertEqual(len(container.streams), 2)
self.assertEqual(container.streams[0].codec.name, 'aac')
self.assertGreater(
float(container.streams[0].duration *
container.streams[0].time_base), 0)
self.assertEqual(container.streams[1].codec.name, 'h264')
self.assertEqual(container.streams[1].width, 640)
self.assertEqual(container.streams[1].height, 480)
self.assertGreater(
float(container.streams[1].duration *
container.streams[1].time_base), 0)
args = parser.parse_args()
if args.verbose:
logging.basicConfig(level=logging.DEBUG)
# create signaling and peer connection
signaling = create_signaling(args)
pc = RTCPeerConnection()
# create media sink
if args.record_to:
recorder = MediaRecorder(args.record_to)
else:
recorder = MediaBlackhole()
# run event loop
loop = asyncio.get_event_loop()
try:
loop.run_until_complete(run(
pc=pc,
recorder=recorder,
role=args.role,
signaling=signaling))
except KeyboardInterrupt:
pass
finally:
# cleanup
loop.run_until_complete(recorder.stop())
loop.run_until_complete(signaling.close())
loop.run_until_complete(pc.close())
def test_video_png(self):
recorder = MediaRecorder(self.temporary_path('test-%3d.png'))
recorder.addTrack(VideoStreamTrack())
run(recorder.start())
run(asyncio.sleep(2))
run(recorder.stop())
def test_audio_wav(self):
recorder = MediaRecorder(self.temporary_path('test.wav'))
recorder.addTrack(AudioStreamTrack())
run(recorder.start())
run(asyncio.sleep(2))
run(recorder.stop())
async def join_room(room, play_from, record_to):
# fetch room parameters
async with aiohttp.ClientSession() as session:
async with session.post('https://appr.tc/join/' + room) as response:
# we cannot use response.json() due to:
# https://github.com/webrtc/apprtc/issues/562
data = json.loads(await response.text())
assert data['result'] == 'SUCCESS'
params = data['params']
# create peer conection
pc = RTCPeerConnection()
# setup media source
if play_from:
player = MediaPlayer(play_from)
else:
player = None
if player and player.audio:
pc.addTrack(player.audio)
else:
pc.addTrack(AudioStreamTrack())
if player and player.video:
pc.addTrack(player.video)
else:
pc.addTrack(VideoImageTrack())
# setup media sink
if record_to:
recorder = MediaRecorder(record_to)
else:
recorder = MediaBlackhole()
@pc.on('track')
def on_track(track):
print('Track %s received' % track.kind)
recorder.addTrack(track)
def on_ended():
print('Track %s ended' % track.kind)
# connect to websocket and join
signaling = Signaling()
await signaling.connect(params)
await signaling.send({
'clientid': params['client_id'],
'cmd': 'register',
'roomid': params['room_id'],
})
if params['is_initiator'] == 'true':
# send offer
await pc.setLocalDescription(await pc.createOffer())
await signaling.send_message(description_to_dict(pc.localDescription))
print('Please point a browser at %s' % params['room_link'])
def start_media():
if player:
player.start()
recorder.start()
# receive 60s of media
try:
await asyncio.wait_for(consume_signaling(signaling, pc, params, start_media), timeout=60)
except asyncio.TimeoutError:
pass
# shutdown
print('Shutting down')
if player:
player.stop()
recorder.stop()
await signaling.send_message({'type': 'bye'})
await pc.close()
def test_video_jpg(self):
recorder = MediaRecorder(path='foo-%3d.jpg')
recorder.addTrack(VideoStreamTrack())
recorder.start()
run(asyncio.sleep(2))
recorder.stop()
def test_audio_wav(self):
recorder = MediaRecorder(path='foo.wav')
recorder.addTrack(AudioStreamTrack())
recorder.start()
run(asyncio.sleep(2))
recorder.stop()
video_player = None
audio_player = None
# create media sink
if args.record_to:
audio_recorder = MediaRecorder(args.record_to)
video_recorder = MediaBlackhole()
else:
video_recorder = MediaBlackhole()
audio_recorder = MediaBlackhole()
# run event loop
loop = asyncio.get_event_loop()
try:
loop.run_until_complete(
run(pc=pc,
audio_player=audio_player,
audio_recorder=audio_recorder,
video_recorder=video_recorder,
signaling=signaling,
role=args.role,
video_player=video_player,
sio=sio))
except KeyboardInterrupt:
pass
finally:
# cleanup
if audio_recorder and video_recorder:
loop.run_until_complete(audio_recorder.stop())
loop.run_until_complete(video_recorder.stop())
loop.run_until_complete(signaling.close())
loop.run_until_complete(pc.close())
