rtmp | Server implementation of Adobe 's RTMP 1.0 protocol in Go | HTTP library

Place

I think you have to tweak your syntax a bit to do string concatenation in your react component:

Thank you for this question.

You can get the public IP by declaring globalIp

Please go to /conf/red5.properties

i.e., /usr/local/antmedia/conf/red5.properties

Edit the properties file and Set useGlobalIp=true

save the settings

restart AMS with sudo service antmedia restart

Thank you

antmedia.io

I think the issue might be that zx is using the bash inside WSL. Assuming you also don't want to use ffmpeg in WSL, here is how I fixed it.

1. Install git.
2. Find the bash.exe inside the installed git. In my case, it is located at C:/Program Files/Git/usr/bin/bash.exe.
3. Insert the following line after the shebang: $.shell = `Location to your bash`. In my case, it is $.shell = `C:/Program Files/Git/usr/bin/bash.exe`;.

I am fairly sure this works with other distributions of bash for Windows, but I have not tested.

As you use OriginCluster, then you must get lots of streams to serve, there are lots of encoders to publish streams to your media servers. The key to solve the problem:

1. Never use single server, use cluster for elastic ability, because you might get much more streams in future. So forward is not good, because you must config a special set of streams to foward to, similar to a manually hash algorithm.
2. Beside of bandwidth, the disk IO is also the bottleneck. You definitely need a high performance network storage cluster. But be careful, never let SRS directly write to the storage, it will block SRS coroutine.

So the best solution, as I know, is to:

1. Use SRS Origin Cluster, to write HLS on your local disk, or RAM disk is better, to make sure the disk IO never block the SRS coroutine(driven by state-threads network IO).
2. Use network storage cluster to store the HLS files, for example cloud storage like AWS S3, or NFS/K8S PV/Distributed File System whatever. Use nginx or CDN to deliver the HLS.

Now the problem is: How to move data from memory/disk to a network storage cluster?

You must build a service, by Python or Go:

• Use on_hls callback, to notify your service to move the HLS files.
• Use on_publish callback, to notify your service to start FFmpeg to convert RTMP to HLS.

Note that FFmpeg should pull stream from SRS edge, never from origin server directly.

For OriginCluster, a set of origin works as a cluster to provide services to Edge server, like this:

It looks like -stream_loop is not working as it supposed to work (I don't know the reason).

• Add -f image2 before -i im001.jpg - force FFmpeg to get the input as an image (it supposed to be the default, but I think there is an issue when using -stream_loop).
• Remove the -re from the video input (I think there is an issue when using -re with -stream_loop).
• Add -r 1 for setting the frame rate of the input to 1Hz (it is not a must, but the default framerate is too high for a single image).
• Add -vn before the audio input - make sure FFmpeg doesn't decode the video from the URL (in case there is a video stream).
• I added -vf "setpts=N/1/TB" -af "asetpts=PTS-STARTPTS" -map:v 0:v -map:a 1:a for correcting the timestamps and the mapping (we probably don't need it). The 1 in "setpts=N/1/TB" is the video framerate.
• I added -bsf:v dump_extra (I think we need it for FLV streaming).
• Add -shortest -fflags +shortest for quitting when the audio ends.

I don't know how to stream it to YouTube.
I used localhost and FFplay as a listener (it takes some time for the video to appear).

Here is the complete code sample:

Assuming you actually need to use OpenCV for the video, you have to add the audio directly to FFmpeg as Gyan commented, because OpenCV does not support audio.

-re argument is probably required for live streaming.

For testing, I modified the RTMP URL from YouTube to localhost.
FFplay sub-process is used for capturing the stream (for testing).

Complete code sample:

Closing the stdin pipe is required for "pushing" the sub-process remaining (buffered) data to stdout pipe.

For example, add encoder_p.stdin.close() after finish writing all data to encoder_p.stdin.

I don't understand how your code is working.
In my machine, it gets stack at encoder_buf = encoder_p.stdout.read(COPY_BUFSIZE).

I solved the problem using a "writer thread".
The "writer thread" reads data from yt_dlp_p and write it to encoder_p.stdin.

Note: In your specific case, it could work without a thread (because the data is just passed through FFmpeg, and not being encoded), but usually, the encoded data is not ready right after writing the input to FFmpeg.

My code sample uses FFplay sub-process for playing the video (we need the video player because the RTMP streaming requires a "listener" in order to keep streaming).

Here is a complete code sample: