A simple C implementation to stream H.264 to browser using WebRTC

This page summarizes the projects mentioned and recommended in the original post on news.ycombinator.com

Our great sponsors
  • Scout APM - Less time debugging, more time building
  • SonarLint - Deliver Cleaner and Safer Code - Right in Your IDE of Choice!
  • OPS - Build and Run Open Source Unikernels
  • GitHub repo pear

    WebRTC Library for IoT/Embedded Device using C (by sepfy)

    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...

  • GitHub repo openmiko

    Open source firmware for Ingenic T20 based devices such as WyzeCam V2, Xiaomi Xiaofang 1S, iSmartAlarm's Spot+ and others.

    This would be interesting to integrate into https://github.com/openmiko/openmiko which is a firmware for the T20 based ip-cameras.

    Right now, I am not aware of any cheap ip camera that can stream its H264 video to a regular web browser, with sub 500 ms latency. All manufacturers seem to have moved to an app, I guess they can show an RTSP stream in that way.

    Older ip cameras had MJPEG which you could view in the browser, but that is really inefficient w.r.t. bandwidth.

  • Scout APM

    Less time debugging, more time building. Scout APM allows you to find and fix performance issues with no hassle. Now with error monitoring and external services monitoring, Scout is a developer's best friend when it comes to application development.

  • GitHub repo CppCoreGuidelines

    The C++ Core Guidelines are a set of tried-and-true guidelines, rules, and best practices about coding in C++

  • GitHub repo libjuice

    JUICE is a UDP Interactive Connectivity Establishment library

    Nice, this looks like a simple and clear proof of concept!

    In practice, the dependency on glib, which depends in glib, can become a practical problem for embedded devices.

    That's actually why I developped libjuice [0] as the default ICE backend of libdatachannel [1].

    [0] https://github.com/paullouisageneau/libjuice

  • GitHub repo libdatachannel

    C/C++ WebRTC network library featuring Data Channels, Media Transport, and WebSockets

NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a more popular project.

Suggest a related project

Related posts