rtsp | Ruby library to allow RTSP | Stream Processing library

The trivial solution would be:

I found out it has been resolved in

https://git.videolan.org/?p=ffmpeg.git;a=commitdiff;h=a74428921f8bfb33cbe0340bfd810b6945e432d2#patch1

and it works fine in ffmpeg 5.0. You can also apply this patch to 4.4.

I think this error occurs when the speed of writing and reading is difference. So when you add some delay after saving and loading the numpy array doesn't work after certain time. Solution is: add flag "done" when finish save process. And load process only execute when the flag is "done".

Electron already includes ffmpeg (unlike stock Node.js) leaving you no other choice but to link with the included version - otherwise you will get symbol clashes and weird behavior - which is your case - because some symbols will be resolved to your version, others to the built-in version.

Maybe there is a possible workaround which is to build ffmpeg statically into your addon.

The streaming options need to be passed in an array, not a single string with the separator as you have used.

This is a fragment of what you have:

Near as I can tell, there's no video player (for web) that supports RTSP or even HLS right now. Even the official video_player package from the flutter dev team doesn't seem to support that on web, yet. I can offer a workaround though....

If you implement a decent webrtc package and a media server, you can bypass the need to receive RTSP directly on your client. I've been using the flutter_webrtc package for a while now via the livekit_client package. Livekit has a SFU that could be used to proxy RTSP streams for communication to WebRTC enabled clients. I've seen a lot of people use ant media server for that sort of thing as well, and I'm pretty sure you can use the community edition of Ant for free.

People tend to use media servers for aggregating video streams so that instead of 1 client subscribing to 15 streams from various sources, instead a media server somewhere with a very good Internet connection and decent hardware subscribes to those streams and then generates a new video stream (or streams) such that your phone, or tablet, or laptop client somewhere on a 4G network, only has to receive (a) WebRTC stream(s) that can be optimized on the server in various ways.

EDIT: I had another thought, I don't know if this would work very well, but you could dynamically generate an HTML page inside an IFrame and use HTMLElementView. This would let you use a JavaScript/HTML5 video player to play your RTSP stream, however it comes with a heavy cost and you'd want to do a platform check to make sure you're running on web before using it.

Thanks to @Gyran I was able to resolve it.

My FFmpeg version was 4.2.2 so I updated it to 4.3.1.

Command should be just e.g.

Try adding the arguments '-bsf:v', 'dump_extra'.

According to FFmpeg Bitstream Filters Documentation:

dump_extra
Add extradata to the beginning of the filtered packets except when said packets already exactly begin with the extradata that is intended to be added.

The filter supposed to add SPS and PPS NAL units with every key frame.

Here is a complete code sample:

The error message—I'm using dummy URLs and origins below—from the browser can be a bit confusing:

Access to XMLHttpRequest at 'https://api.example.com/' (redirected from 'https://media.example.com/') from origin 'https://example.com' has been blocked by CORS policy: Response to preflight request doesn't pass access control check: The 'Access-Control-Allow-Origin' header has a value 'https://example.com' that is not equal to the supplied origin.

The key here is that, as sideshowbarker hinted at in his comment, because your first preflighted request to https://media.example.com/ responds with a cross-origin redirect to https://api.example.com/, the browser performs another whole CORS access-control check for that resource. However, because the redirect resulting from the first preflighted request happens to be cross-origin, the browser sets the origin of the second preflight request (which the error message refers to as the "supplied origin"), not as https://example.com, but as the null origin!

Here's a rundown of what is likely happening:

Because https://api.example.com likely doesn't (and shouldn't!) allow the null, the second access-control check fails and you get that annoying CORS error.

Resist the temptation to allow the null origin on https://api.example.com/, as doing so has serious security ramifications: it amount to voiding the protection that the Same-Origin Policy provides.

Instead, you should get rid of that redirect from https://media.example.com/ to https://api.example.com/ and make your frontend request the https://api.example.com/ resource directly.

Alternatively, if you cannot completely get rid of the redirect but you can change its destination, make it a same-origin redirect (from somewhere https://media.example.org to elsewhere on https://media.example.org).