I’m organising an SRS origin-edge cluster utilizing Docker. I need to publish a single RTMP stream to the origin and play it again on the proxy utilizing HTTP-FLV, HLS, and WebRTC. My motivation is that once I stream a number of cameras with WebRTC via my AWS server, the second digicam experiences latency. From my understanding, SRS works on a single thread which may create points. Thus, I made a decision to make use of multi-containers system (Please let me know if there are higher methods to do!). For now, I’m simply attempting two containers:
- origin that receives the stream
- proxy that pulls the stream from origin and stream on an html web page
I used to be capable of:
- Setup a single-container setup works completely for all protocols (FLV, HLS, and WebRTC).
- Create a multi-container setup, HTTP-FLV and HLS playback works accurately, which proves the stream is being pulled from the origin to the proxy.
My drawback:
WebRTC playback is the one factor that fails. The browser makes a profitable connection to the proxy (logs present connection established), however no video ever seems. The proxy log exhibits it connects to the origin to tug the stream, however the connection then instances out or fails with a video parsing error (avc demux annexb : not annexb).
My docker-compose.yml:
model: '3.8'
networks:
srs-net:
driver: bridge
companies:
srs-origin:
picture: ossrs/srs:6
container_name: srs-origin
networks: [srs-net]
ports: ["1936:1935"]
expose:
- "1935"
volumes: ["./origin.conf:/usr/local/srs/conf/srs.conf:ro"]
command: ["./objs/srs", "-c", "conf/srs.conf"]
restart: unless-stopped
srs-proxy:
picture: ossrs/srs:6
container_name: srs-proxy
networks: ["srs-net"]
ports:
- "1935:1935"
- "1985:1985"
- "8000:8000/udp"
- "8080:8080"
depends_on:
- srs-origin
volumes:
- "./proxy.conf:/usr/native/srs/conf/srs.conf:ro"
- "./html:/usr/native/srs/html"
command: ["./objs/srs", "-c", "conf/srs.conf"]
restart: unless-stopped
origin.conf:
hear 1935;
daemon off;
srs_log_tank console;
srs_log_level hint;
vhost __defaultVhost__ {
}
proxy.conf:
hear 1935;
max_connections 1000;
daemon off;
srs_log_tank console;
srs_log_level hint;
http_server {
enabled on;
hear 8080;
dir ./html;
crossdomain on;
}
http_api {
enabled on;
hear 1985;
crossdomain on;
}
rtc_server {
enabled on;
hear 8000;
candidate xxx.xxx.xxx.xxx; # IP tackle
}
vhost __defaultVhost__ {
enabled on;
# Allow cluster mode to tug from the origin server
cluster {
mode distant;
origin srs-origin:1935;
}
# Low latency settings
play {
gop_cache off;
queue_length 1;
mw_latency 50;
}
# WebRTC configuration (Not working)
rtc {
enabled on;
rtmp_to_rtc on;
rtc_to_rtmp off;
# Essential for SRS v6
bframe discard;
keep_bframe off;
}
# HTTP-FLV (working)
http_remux {
enabled on;
mount /[app]/[stream].flv;
}
# HLS (working)
hls {
enabled on;
hls_path ./html;
hls_fragment 3;
hls_window 9;
}
}
The ffmpeg pipe I exploit in my python code from my host machine to push video frames to my AWS server:
IP_ADDRESS = ip_address
RTMP_SERVER_URL = f"rtmp://{IP_ADDRESS}:1936/reside/Camera_0"
BITRATE_KBPS = bitrate # Goal bitrate for the output stream (2 Mbps)
# Threading and queue for body processing
ffmpeg_cmd = [
'ffmpeg',
'-y',
'-f', 'rawvideo',
'-vcodec', 'rawvideo',
'-pix_fmt', 'bgr24',
'-s', f'{self.frame_width}x{self.frame_height}',
'-r', str(self.camera_fps),
'-i', '-',
# Add audio source (silent audio if no mic)
'-f', 'lavfi',
'-i', 'anullsrc=channel_layout=stereo:sample_rate=44100',
# Video encoding
'-c:v', 'libx264',
'-preset', 'ultrafast',
'-tune', 'zerolatency',
'-pix_fmt', 'yuv420p',
# Keyframe interval: 1 second. Consider 0.5s if still high, but increases bitrate.
'-g', str(2*self.camera_fps),
# Force no B-frames (zerolatency should handle this, but explicit is sometimes better)
'-bf', '0',
'-profile:v', 'baseline', # Necessary for apple devices
# Specific libx264 options for latency (often implied by zerolatency, but can be explicit)
# Add options to explicitly disable features not in Baseline profile,
# ensuring maximum compatibility and avoiding implicit enabling by preset.
'-x264-params', 'cabac=0:ref=1:nal-hrd=cbr:force-cfr=1:no-mbtree=1:slice-max-size=1500',
# Force keyframes only if input allows (might not be practical for camera input)
'-keyint_min', str(self.camera_fps), # Ensure minimum distance is also 1 second
# Rate control and buffering for low latency
'-b:v', f'{BITRATE_KBPS}k', # Your target bitrate (e.g., 1000k)
'-maxrate', f'{BITRATE_KBPS * 1.2}k', # Slightly higher maxrate than bitrate
'-bufsize', f'{BITRATE_KBPS * 1.5}k', # Buffer size related to maxrate
'-f', 'flv',
RTMP_SERVER_URL
]
self.ffmpeg_process = subprocess.Popen(ffmpeg_cmd, stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, bufsize=10**5)
