libdatachannel
libpeer
Our great sponsors
libdatachannel | libpeer | |
---|---|---|
27 | 11 | |
1,543 | 774 | |
- | - | |
9.3 | 8.1 | |
about 9 hours ago | 4 months ago | |
C++ | C | |
Mozilla Public License 2.0 | MIT License |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
libdatachannel
- VoRS: Vo(IP) Simple Alternative to Mumble
-
Simplicity of IRC
You can use https://github.com/paullouisageneau/libdatachannel for your C/C++ integration needs. It's 10k lines. So the answer is 0. Its required dependencies (I assume this as they are git submodules in deps) are more than 100k lines, though, srtp support making the bulk of it. On my machine it took 11 seconds to compile it.
Irssi is 64k lines (plus its dependencies), so I guess that makes WebRTC complicated.
Can't argue that DCC isn't simple, but perhaps the protocol deviced decades ago is a bit too simple.
-
OBS merges AV1 support for WebRTC
Most of the work happened in the libdatachannel! You can check out my PR here[0]
[0] https://github.com/paullouisageneau/libdatachannel/commit/a6...
-
Pure C WebRTC
I am really excited about https://github.com/sepfy/libpeer. It has examples ready for ESP32 etc....
When working on KVS I wasn't familiar with the embedded space at all. I saw 'heavyweight' embedded where you were running on Linux. Then you had RTOS/No OS at all. I wasn't prepared for these devices at all. If we can make WebRTC work in the embedded space I think it will really accelerate what developers are able to build!
Remotely driven cars, security cameras, robots in hospitals that bring iPads to infectious patients etc... Creative people are building amazing things. The WebRTC/video space needs to work harder and support them :)
-----
I love how diverse the WebRTC space is now. Outside of this implementation you have plenty of other options!
* https://github.com/shinyoshiaki/werift-webrtc (Typescript)
* https://github.com/pion/webrtc (Golang)
* https://github.com/webrtc-rs/webrtc (Rust)
* https://github.com/algesten/str0m (Rust)
* hhttps://github.com/sepfy/libpeer (C/Embedded)
* https://webrtc.googlesource.com/src/ (C++)
* https://github.com/sipsorcery-org/sipsorcery (C#)
* https://github.com/paullouisageneau/libdatachannel (C++)
* https://github.com/elixir-webrtc (Elixir)
* https://github.com/aiortc/aiortc (Python)
* GStreamer’s webrtcbin (C)
See https://github.com/sipsorcery/webrtc-echoes for examples of some running against each other.
- WebRTC for the Curious
-
Building WebRTC server implementation for Erlang
This is not true, there are actually multiple WebRTC implementations in different languages besides the reference library: aiortc (python), libdatachannel (C++), sipsorcery (C#),webrtc-rs (rust), werift (Typescript), and Amazon Kinesis (C)
-
I spent two years building a desktop environment that runs in the browser, it's finally in beta!
Use any means necessary to transfer your data across devices. Could be IPFS, could be FTP, could be EventSource, WebSocket, WebTransport, Fetch, whatever. See https://github.com/guest271314/secure-file-transfer; offscreen-webrtc, https://github.com/paullouisageneau/libdatachannel.
-
Client side Rest server?
I've successfully used libdatachannel to Web pages to connect native applications and stream data to the browser.
-
Security Framework
Alternatively you can use your server as a signaling server for WebRTC (Insertable Streams ("Breakout Box"), or data channels https://github.com/paullouisageneau/libdatachannel), then users (peers) can exchange data themselves and you don't need to store anything, see True End-to-End Encryption with WebRTC Insertable Streams, A complete example for a WebRTC datachannel with manual signaling.
-
Datachannel video streaming?
there is also a c++ library that can be used to open a data channel connection, I think a number of SFU “servers?” use this library (I wish I had) https://libdatachannel.org/
libpeer
- VoRS: Vo(IP) Simple Alternative to Mumble
-
Pure C WebRTC
I am really excited about https://github.com/sepfy/libpeer. It has examples ready for ESP32 etc....
When working on KVS I wasn't familiar with the embedded space at all. I saw 'heavyweight' embedded where you were running on Linux. Then you had RTOS/No OS at all. I wasn't prepared for these devices at all. If we can make WebRTC work in the embedded space I think it will really accelerate what developers are able to build!
Remotely driven cars, security cameras, robots in hospitals that bring iPads to infectious patients etc... Creative people are building amazing things. The WebRTC/video space needs to work harder and support them :)
-----
I love how diverse the WebRTC space is now. Outside of this implementation you have plenty of other options!
* https://github.com/shinyoshiaki/werift-webrtc (Typescript)
* https://github.com/pion/webrtc (Golang)
* https://github.com/webrtc-rs/webrtc (Rust)
* https://github.com/algesten/str0m (Rust)
* hhttps://github.com/sepfy/libpeer (C/Embedded)
* https://webrtc.googlesource.com/src/ (C++)
* https://github.com/sipsorcery-org/sipsorcery (C#)
* https://github.com/paullouisageneau/libdatachannel (C++)
* https://github.com/elixir-webrtc (Elixir)
* https://github.com/aiortc/aiortc (Python)
* GStreamer’s webrtcbin (C)
See https://github.com/sipsorcery/webrtc-echoes for examples of some running against each other.
- WebRTC for the Curious
- Show HN: Bring phone calls into the browser (sip-to-WebRTC)
-
Drop packet
I am experimenting based on the pear project (https://github.com/sepfy/pear) and using the clumsy tool to simulate the case of dropping packets.
- Pear - A WebRTC Toolkit for IoT/Embedded Devices (a work-in-progress)
-
Hacker News top posts: Apr 8, 2021
A simple C implementation to stream H.264 to browser using WebRTC\ (61 comments)
-
A simple C implementation to stream H.264 to browser using WebRTC
I think there's some truth in what as-j is saying. Rust binaries (and C++ ones) tend to be larger than C ones. I think the major reasons are (a) Rust dependencies being statically linked due to a lack of ABI stability, (b) inclusion of portions of the (statically linked, see a) Rust standard library used by the program where C code uses libc, (c) code bloat due to monomorphization, (d) the ease of just using a full-featured library where someone writing in C might cheat a little bit. As an example of what I mean by the last point, see sdp_attribute_get_answer in this codebase. [1] It's writing JSON, but it doesn't use a JSON library that actually escapes the included string. It just assumes the included string doesn't have a quote character in it. Is that assumption valid? Will it always be valid? I'm not sure on quick inspection.
There are ways around all of these:
* a. Static vs dynamic linkage: in an embedded system, it'd be reasonable to just produce a single userspace binary that does everything. It can change its behavior based on argv[0]. I think this is not too unusual for constrained systems even with C binaries. Eg busybox does it. If you only have one binary, you don't need dynamic linking. Also, I think it's not strictly true that Rust doesn't support dynamic linking. I think you can dynamically link everything if you ensure the whole system is built with the same compiler version.
* b. Standard library. You don't have to use it at all, or you can use it sparingly, paying only for what you use.
* c. Monomorphization. You could write (for example) a Go-like map [2] rather than relying so heavily on monomorphization. I'd love to see someone take this idea as far as possible; it might be a good idea for a lot of non-inner-loop code in general, not just on tight embedded systems.
* d. Using full-featured libraries. Obviously no one is making you do this; the same cheats available in C are available in Rust.
but in fairness, the further you go down this path, the further you are from just being able to just take advantage of the whole Rust ecosystem.
Personally, I'd still rather develop or use a #![no_std] Rust codebase than a C one. Memory safety is important to me. IOT devices are no exception to that. Their security is historically horrible but I'd like to change that.
[1] https://github.com/sepfy/pear/blob/b984c8dccaafdcdd1b181786a...
[2] https://dave.cheney.net/2018/05/29/how-the-go-runtime-implem...
What are some alternatives?
libjuice - JUICE is a UDP Interactive Connectivity Establishment library
openmiko - Open source firmware for Ingenic T20 based devices such as WyzeCam V2, Xiaomi Xiaofang 1S, iSmartAlarm's Spot+ and others.
Pion WebRTC - Pure Go implementation of the WebRTC API
tiny-webrtc-gw - tiny/fast webRTC video conferencing gateway
aiortc - WebRTC and ORTC implementation for Python using asyncio
spchcat - Speech recognition tool to convert audio to text transcripts, for Linux and Raspberry Pi.
sora-unity-sdk - WebRTC SFU Sora Unity SDK
cpufetch - Simple yet fancy CPU architecture fetching tool
janus-gateway - Janus WebRTC Server
Ory Keto - Open Source (Go) implementation of "Zanzibar: Google's Consistent, Global Authorization System". Ships gRPC, REST APIs, newSQL, and an easy and granular permission language. Supports ACL, RBAC, and other access models.
µWebSockets - Simple, secure & standards compliant web server for the most demanding of applications