rodolfoap · May 20, 2024 14:22
diff --git a/README.md b/README.md
diff --git a/client.js b/client.js
 var pc = null;

 function negotiate() {
    pc.addTransceiver('video', { direction: 'recvonly' });
    return pc.createOffer().then((offer) => {
        return pc.setLocalDescription(offer);
    }).then(() => {
        // wait for ICE gathering to complete
        return new Promise((resolve) => {
            if (pc.iceGatheringState === 'complete') {
                resolve();
            } else {
                const checkState = () => {
                    if (pc.iceGatheringState === 'complete') {
                        pc.removeEventListener('icegatheringstatechange', checkState);
                        resolve();
                    }
                };
                pc.addEventListener('icegatheringstatechange', checkState);
            }
        });
    }).then(() => {
        var offer = pc.localDescription;
        return fetch('/offer', {
            body: JSON.stringify({
                sdp: offer.sdp,
                type: offer.type,
            }),
            headers: {
                'Content-Type': 'application/json'
            },
            method: 'POST'
        });
    }).then((response) => {
        return response.json();
    }).then((answer) => {
        return pc.setRemoteDescription(answer);
    }).catch((e) => {
        alert(e);
    });
 }

 function start() {
    var config = {
        sdpSemantics: 'unified-plan'
    };
    pc = new RTCPeerConnection(config);
    // connect video
    pc.addEventListener('track', (evt) => {
        document.getElementById('video').srcObject = evt.streams[0];
    });
    negotiate();
 }

 function stop() {
    setTimeout(() => { pc.close(); }, 500);
 }
diff --git a/Dockerfile b/Dockerfile
 FROM ubuntu:noble

 WORKDIR /app
 ENV DEBIAN_FRONTEND=noninteractive
 RUN apt update && apt install -y python3 python3-pip python3-venv python3-dev libavdevice-dev libavfilter-dev libopus-dev libvpx-dev pkg-config libopencv-dev

 RUN python3 -m venv venv
 ENV PATH="/app/venv/bin:$PATH"
 RUN /app/venv/bin/pip install aiohttp==3.9.5 aioice==0.9.0 aiortc==1.8.0 aiosignal==1.3.1 opencv-python==4.9.0.80

 # Uncomment this to use av==12.0.0
 # See https://github.com/aiortc/aiortc/discussions/1088#discussioncomment-9287230
 # RUN ./venv/bin/pip install av==12.0.0

 EXPOSE 3000
 COPY server.py  /app/
 COPY client.js  /app/
 COPY index.html /app/
 COPY myrtc.py /app/

 CMD /app/venv/bin/python3 server.py
diff --git a/index.html b/index.html
 <!DOCTYPE html>
 <html>
 <head>
    <meta charset="UTF-8"/>
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>WebRTC</title>
    <script src="client.js"></script>
 </head>
 <body onload=start()>
 <video id="video" autoplay controls muted></video>
 <script> window.onbeforeunload = function(){ stop(); } </script>
 </body>
 </html>
diff --git a/myrtc.py b/myrtc.py
 import cv2, datetime
 from av import VideoFrame
 from aiortc.contrib.media import MediaStreamTrack

 class VideoResizeTrack(MediaStreamTrack):
    kind = "video"

    def __init__(self, track, width=640):
        super().__init__()
        self.track=track
        self.width=width

    async def recv(self):
        # Call the original recv()
        frame = await self.track.recv()

        # Transform video
        image = frame.to_ndarray(format="bgr24")
        height, width, layers = image.shape
        ratio=width/self.width
        image_resized = cv2.resize(image, (self.width, int(height/ratio)), interpolation = cv2.INTER_AREA)
        frame_resized = VideoFrame.from_ndarray(image_resized, format="bgr24")
        frame_resized.pts = frame.pts
        frame_resized.time_base = frame.time_base
        return frame_resized
diff --git a/ram_monitor.py b/ram_monitor.py
 #!/bin/python3
 import docker, time, json

 client = docker.from_env()
 container = client.containers.get('aiortc')
 stream = container.stats(stream=True)
 max_ram_occupation, delta = 0, 0
 for frame in stream:
 	stats=json.loads(frame.decode('utf-8'))
 	ram_occupation=stats['memory_stats']['usage']/1024/1024
 	if ram_occupation>max_ram_occupation:
 		delta=ram_occupation-max_ram_occupation
 		max_ram_occupation=ram_occupation
 	print(f"aiortc: {ram_occupation:.2f}; max:{max_ram_occupation:.2f}, last_delta:{delta:.2f} Mb")
diff --git a/server.py b/server.py
 import asyncio, json, os, logging
 from aiohttp import web
 from aiortc import RTCPeerConnection, RTCSessionDescription
 from aiortc.contrib.media import MediaPlayer, MediaRelay
 from myrtc import VideoResizeTrack

 ROOT = os.path.dirname(__file__)
 peer_connections = set()
 player = MediaPlayer("/dev/video0")
 relay = MediaRelay()

 async def offer(request):
    params = await request.json()
    offer = RTCSessionDescription(sdp=params["sdp"], type=params["type"])

    peer_connection = RTCPeerConnection()
    peer_connections.add(peer_connection)

    @peer_connection.on("connectionstatechange")
    async def on_connectionstatechange():
        print("Connection state is %s" % peer_connection.connectionState)
        if peer_connection.connectionState in ["failed", "closed"]:
            await peer_connection.close()
            peer_connections.discard(peer_connection)

    # I've resized the video, so the problem is easy to visualize.
    video = VideoResizeTrack(relay.subscribe(player.video), width=800)
    track = peer_connection.addTrack(video)
    await peer_connection.setRemoteDescription(offer)
    answer = await peer_connection.createAnswer()
    await peer_connection.setLocalDescription(answer)
    return web.Response(
        content_type="application/json",
        text=json.dumps(
            {"sdp": peer_connection.localDescription.sdp, "type": peer_connection.localDescription.type}
        ),
    )

 async def on_shutdown(app):
    coroutines = [peer_connection.close() for peer_connection in peer_connections]
    await asyncio.gather(*coroutines)
    peer_connections.clear()

 logging.basicConfig(level=logging.INFO)
 app = web.Application()
 app.router.add_get("/", lambda request: web.Response(
    content_type="text/html", text=open(os.path.join(ROOT, "index.html"), "r").read()
 ))
 app.router.add_get("/client.js", lambda request: web.Response(
    content_type="application/javascript", text=open(os.path.join(ROOT, "client.js"), "r").read()
 ))
 app.router.add_post("/offer", offer)
 app.on_shutdown.append(on_shutdown)
 web.run_app(app, host='0.0.0.0', port=3000, ssl_context=None)
diff --git a/start.bash b/start.bash
 #!/bin/bash

 # Build the image
 [ $(docker image ls -q -f reference=aiortc|wc -l) == 1 ] || docker build -t aiortc .

 # Create a docker network:
 [ $(docker network ls -f name=net_oia -q|wc -l) == '1' ] || docker network create net_oia;

 # Launch the server
 docker run -ti --rm --name aiortc --network net_oia \
 	--device=/dev/video0:/dev/video0 \
 	-p 3000:3000 \
 	aiortc;

 # Now, open your browser, press F12 to open the developer tools, select the "CONSOLE" tab and browse to http://localhost:3000
	var pc = null;

	function negotiate() {
	pc.addTransceiver('video', { direction: 'recvonly' });
	return pc.createOffer().then((offer) => {
	return pc.setLocalDescription(offer);
	}).then(() => {
	// wait for ICE gathering to complete
	return new Promise((resolve) => {
	if (pc.iceGatheringState === 'complete') {
	resolve();
	} else {
	const checkState = () => {
	if (pc.iceGatheringState === 'complete') {
	pc.removeEventListener('icegatheringstatechange', checkState);
	resolve();
	}
	};
	pc.addEventListener('icegatheringstatechange', checkState);
	}
	});
	}).then(() => {
	var offer = pc.localDescription;
	return fetch('/offer', {
	body: JSON.stringify({
	sdp: offer.sdp,
	type: offer.type,
	}),
	headers: {
	'Content-Type': 'application/json'
	},
	method: 'POST'
	});
	}).then((response) => {
	return response.json();
	}).then((answer) => {
	return pc.setRemoteDescription(answer);
	}).catch((e) => {
	alert(e);
	});
	}

	function start() {
	var config = {
	sdpSemantics: 'unified-plan'
	};
	pc = new RTCPeerConnection(config);
	// connect video
	pc.addEventListener('track', (evt) => {
	document.getElementById('video').srcObject = evt.streams[0];
	});
	negotiate();
	}

	function stop() {
	setTimeout(() => { pc.close(); }, 500);
	}
	FROM ubuntu:noble

	WORKDIR /app
	ENV DEBIAN_FRONTEND=noninteractive
	RUN apt update && apt install -y python3 python3-pip python3-venv python3-dev libavdevice-dev libavfilter-dev libopus-dev libvpx-dev pkg-config libopencv-dev

	RUN python3 -m venv venv
	ENV PATH="/app/venv/bin:$PATH"
	RUN /app/venv/bin/pip install aiohttp==3.9.5 aioice==0.9.0 aiortc==1.8.0 aiosignal==1.3.1 opencv-python==4.9.0.80

	# Uncomment this to use av==12.0.0
	# See https://github.com/aiortc/aiortc/discussions/1088#discussioncomment-9287230
	# RUN ./venv/bin/pip install av==12.0.0

	EXPOSE 3000
	COPY server.py /app/
	COPY client.js /app/
	COPY index.html /app/
	COPY myrtc.py /app/

	CMD /app/venv/bin/python3 server.py
	<!DOCTYPE html>
	<html>
	<head>
	<meta charset="UTF-8"/>
	<meta name="viewport" content="width=device-width, initial-scale=1.0" />
	<title>WebRTC</title>
	<script src="client.js"></script>
	</head>
	<body onload=start()>
	<video id="video" autoplay controls muted></video>
	<script> window.onbeforeunload = function(){ stop(); } </script>
	</body>
	</html>
	import cv2, datetime
	from av import VideoFrame
	from aiortc.contrib.media import MediaStreamTrack

	class VideoResizeTrack(MediaStreamTrack):
	kind = "video"

	def __init__(self, track, width=640):
	super().__init__()
	self.track=track
	self.width=width

	async def recv(self):
	# Call the original recv()
	frame = await self.track.recv()

	# Transform video
	image = frame.to_ndarray(format="bgr24")
	height, width, layers = image.shape
	ratio=width/self.width
	image_resized = cv2.resize(image, (self.width, int(height/ratio)), interpolation = cv2.INTER_AREA)
	frame_resized = VideoFrame.from_ndarray(image_resized, format="bgr24")
	frame_resized.pts = frame.pts
	frame_resized.time_base = frame.time_base
	return frame_resized
	#!/bin/python3
	import docker, time, json

	client = docker.from_env()
	container = client.containers.get('aiortc')
	stream = container.stats(stream=True)
	max_ram_occupation, delta = 0, 0
	for frame in stream:
	stats=json.loads(frame.decode('utf-8'))
	ram_occupation=stats['memory_stats']['usage']/1024/1024
	if ram_occupation>max_ram_occupation:
	delta=ram_occupation-max_ram_occupation
	max_ram_occupation=ram_occupation
	print(f"aiortc: {ram_occupation:.2f}; max:{max_ram_occupation:.2f}, last_delta:{delta:.2f} Mb")
	import asyncio, json, os, logging
	from aiohttp import web
	from aiortc import RTCPeerConnection, RTCSessionDescription
	from aiortc.contrib.media import MediaPlayer, MediaRelay
	from myrtc import VideoResizeTrack

	ROOT = os.path.dirname(__file__)
	peer_connections = set()
	player = MediaPlayer("/dev/video0")
	relay = MediaRelay()

	async def offer(request):
	params = await request.json()
	offer = RTCSessionDescription(sdp=params["sdp"], type=params["type"])

	peer_connection = RTCPeerConnection()
	peer_connections.add(peer_connection)

	@peer_connection.on("connectionstatechange")
	async def on_connectionstatechange():
	print("Connection state is %s" % peer_connection.connectionState)
	if peer_connection.connectionState in ["failed", "closed"]:
	await peer_connection.close()
	peer_connections.discard(peer_connection)

	# I've resized the video, so the problem is easy to visualize.
	video = VideoResizeTrack(relay.subscribe(player.video), width=800)
	track = peer_connection.addTrack(video)
	await peer_connection.setRemoteDescription(offer)
	answer = await peer_connection.createAnswer()
	await peer_connection.setLocalDescription(answer)
	return web.Response(
	content_type="application/json",
	text=json.dumps(
	{"sdp": peer_connection.localDescription.sdp, "type": peer_connection.localDescription.type}
	),
	)

	async def on_shutdown(app):
	coroutines = [peer_connection.close() for peer_connection in peer_connections]
	await asyncio.gather(*coroutines)
	peer_connections.clear()

	logging.basicConfig(level=logging.INFO)
	app = web.Application()
	app.router.add_get("/", lambda request: web.Response(
	content_type="text/html", text=open(os.path.join(ROOT, "index.html"), "r").read()
	))
	app.router.add_get("/client.js", lambda request: web.Response(
	content_type="application/javascript", text=open(os.path.join(ROOT, "client.js"), "r").read()
	))
	app.router.add_post("/offer", offer)
	app.on_shutdown.append(on_shutdown)
	web.run_app(app, host='0.0.0.0', port=3000, ssl_context=None)
	#!/bin/bash

	# Build the image
	[ $(docker image ls -q -f reference=aiortc\|wc -l) == 1 ] \|\| docker build -t aiortc .

	# Create a docker network:
	[ $(docker network ls -f name=net_oia -q\|wc -l) == '1' ] \|\| docker network create net_oia;

	# Launch the server
	docker run -ti --rm --name aiortc --network net_oia \
	--device=/dev/video0:/dev/video0 \
	-p 3000:3000 \
	aiortc;

	# Now, open your browser, press F12 to open the developer tools, select the "CONSOLE" tab and browse to http://localhost:3000