Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 6 additions & 0 deletions docs/features.md
Original file line number Diff line number Diff line change
Expand Up @@ -858,6 +858,12 @@ area.
fails. *All*, 2026-10-17. Issue
[#1347](https://github.com/obs-rust/obs-studio/issues/1347), PR
[#1353](https://github.com/obs-rust/obs-studio/pull/1353).
- Stop Streaming stops an SRT listener stream that is waiting for its caller
to come back, and OBS quits while a listener waits; before, the stream
never stopped and OBS never finished quitting. *All*, 2026-10-18. Issue
[#1421](https://github.com/obs-rust/obs-studio/issues/1421), PR
[#1422](https://github.com/obs-rust/obs-studio/pull/1422), upstream
[obsproject/obs-studio#12250](https://github.com/obsproject/obs-studio/issues/12250).

### Sources and filters

Expand Down
20 changes: 19 additions & 1 deletion plugins/obs-ffmpeg/obs-ffmpeg-mpegts.c.h
Original file line number Diff line number Diff line change
Expand Up @@ -264,6 +264,12 @@ int ff_network_init(void)
return 1;
}

static int connect_interrupted(void *opaque)
{
struct ffmpeg_output *stream = opaque;
return os_atomic_load_bool(&stream->abort_connect);
}

static inline int connect_mpegts_url(struct ffmpeg_output *stream, bool is_rist)
{
int err = 0;
Expand All @@ -281,6 +287,11 @@ static inline int connect_mpegts_url(struct ffmpeg_output *stream, bool is_rist)
}

uc->url = (char *)(uintptr_t)url;
/* Without it, nothing can end the wait of an SRT listener for its
* caller (no listen_timeout by default): every stop joins the start
* thread and would wait as long. */
uc->interrupt_callback.callback = connect_interrupted;
uc->interrupt_callback.opaque = stream;
uc->max_packet_size = is_rist ? RIST_MAX_PAYLOAD_SIZE : SRT_LIVE_DEFAULT_PAYLOAD_SIZE;

if (stream->ff_data.config.srt_pkt_size)
Expand Down Expand Up @@ -1031,7 +1042,11 @@ static bool set_config(struct ffmpeg_output *stream)

return true;
fail:
obs_output_signal_stop(stream->output, code);
/* A connect that a stop ended is no failure; the stop signals it. While
* reconnecting, libobs would also take the failure as a reason to
* reconnect again. */
if (!os_atomic_load_bool(&stream->abort_connect))
obs_output_signal_stop(stream->output, code);
stop(stream, false, 0);
return false;
}
Expand Down Expand Up @@ -1113,6 +1128,8 @@ static void ffmpeg_mpegts_stop_internal(void *data, uint64_t ts, bool signal)
bool have_to_join = false;
pthread_t to_join;

os_atomic_set_bool(&stream->abort_connect, true);

/* macOS fix: handover of pthread; for some reason, maybe related to srt sockets, if the pthread joining is
* done within the mutex, there can be a stall. So we just copy it and join out of the mutex. */
pthread_mutex_lock(&stream->start_stop_mutex);
Expand Down Expand Up @@ -1171,6 +1188,7 @@ static bool ffmpeg_mpegts_start(void *data)
stream->video_start_ts = 0;
stream->total_bytes = 0;
stream->got_headers = false;
os_atomic_set_bool(&stream->abort_connect, false);

pthread_create(&stream->start_stop_thread, NULL, start_stop_thread_fn, cmd);
os_atomic_set_bool(&stream->start_stop_thread_active, true);
Expand Down
3 changes: 3 additions & 0 deletions plugins/obs-ffmpeg/obs-ffmpeg-output.h
Original file line number Diff line number Diff line change
Expand Up @@ -126,6 +126,9 @@ struct ffmpeg_output {
pthread_mutex_t start_stop_mutex;
volatile bool start_stop_thread_active;
bool has_connected;
/* set by a stop: ends a connect that is still waiting (an SRT
* listener waiting for its caller) */
volatile bool abort_connect;
#endif
};

Expand Down
179 changes: 177 additions & 2 deletions test/websocket-tier4/run_tier4.py
Original file line number Diff line number Diff line change
Expand Up @@ -1438,6 +1438,132 @@ def test_sigterm_during_startup_dialog(server):
("OBS crashed" if crashed else "no clean shutdown in the log"))


def srt_udp_port():
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
sock.bind(("127.0.0.1", 0))
return sock.getsockname()[1]


def ffmpeg_with_srt():
"""The host ffmpeg, if it can call an SRT listener; else None."""
ffmpeg = shutil.which("ffmpeg")
if not ffmpeg:
return None
out = subprocess.run([ffmpeg, "-hide_banner", "-protocols"],
capture_output=True, text=True).stdout
return ffmpeg if any(l.strip() == "srt" for l in out.splitlines()) else None


async def srt_stream_status(c):
r = await c.request("GetStreamStatus")
return r.get("d", {}).get("responseData", {})


async def start_srt_listener(c, port):
"""Settings > Stream: Custom, srt://127.0.0.1:port?mode=listener."""
for _ in range(120):
r = await c.request("SetStreamServiceSettings", {
"streamServiceType": "rtmp_custom",
"streamServiceSettings": {
"server": f"srt://127.0.0.1:{port}?mode=listener", "key": ""}})
if resp_status(r).get("code") != 207:
break
await asyncio.sleep(0.5)
r = await c.request("StartStream")
return resp_status(r).get("code") == STATUS_SUCCESS, r


async def test_srt_listener_stop_while_reconnecting():
"""An SRT listener whose caller went away waits for the next caller
(RECONNECTING). Stop Streaming there must stop the stream, and the UI
thread must keep running. The stop joined the start thread, which waited
for a caller with no way to be interrupted: the stream never stopped
(upstream obsproject/obs-studio#12250)."""
ffmpeg = ffmpeg_with_srt()
if not ffmpeg:
print(" (no ffmpeg with srt: SRT reconnect check skipped)", flush=True)
return
c, _ = await new_identified_client(subscriptions=SUB_NONE)
port = srt_udp_port()
ok, r = await start_srt_listener(c, port)
check("srt:StartStream on a listener", ok, json.dumps(r)[:300])
caller = subprocess.Popen(
[ffmpeg, "-hide_banner", "-nostdin", "-loglevel", "error",
"-i", f"srt://127.0.0.1:{port}?mode=caller", "-map", "0",
"-c", "copy", "-f", "mpegts", "-y", os.devnull],
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
start_new_session=True)
try:
active = False
deadline = time.time() + 20
while time.time() < deadline and not active:
active = (await srt_stream_status(c)).get("outputActive")
await asyncio.sleep(0.25)
check("srt:the stream starts when a caller connects", active,
"outputActive never became true")
await asyncio.sleep(2)
finally:
caller.kill()
caller.wait()
reconnecting = False
deadline = time.time() + 30
while time.time() < deadline and not reconnecting:
reconnecting = (await srt_stream_status(c)).get("outputReconnecting")
await asyncio.sleep(0.25)
check("srt:the listener reconnects after the caller left", reconnecting,
"outputReconnecting never became true")
# Let the reconnect start waiting for a caller again.
await asyncio.sleep(4)
r = await c.request("StopStream")
check("srt:StopStream while reconnecting",
resp_status(r).get("code") == STATUS_SUCCESS, json.dumps(r)[:300])
stopped = False
deadline = time.time() + 10
while time.time() < deadline and not stopped:
try:
st = await c.request("GetStreamStatus", timeout=2.0)
except TimeoutError:
continue
data = st.get("d", {}).get("responseData", {})
stopped = data.get("outputActive") is False and not data.get("outputReconnecting")
await asyncio.sleep(0.25)
check("srt:the stream stops within 10 s", stopped,
"still active or reconnecting 10 s after StopStream")
try:
r = await c.request("GetSceneList", timeout=5.0)
answers = resp_status(r).get("code") == STATUS_SUCCESS
except TimeoutError:
answers = False
check("srt:UI thread still answers after the stop", answers,
"GetSceneList timed out: the UI thread is stuck")
await c.close_conn()


async def test_srt_listener_quit_while_waiting(server):
"""OBS must quit on SIGTERM while an SRT listener waits for its first
caller. Destroying the output joined the start thread, which waited for
a caller forever: OBS never quit."""
c, _ = await new_identified_client(subscriptions=SUB_NONE)
ok, r = await start_srt_listener(c, srt_udp_port())
check("srt-quit:StartStream on a listener", ok, json.dumps(r)[:300])
await asyncio.sleep(2)
await c.close_conn()
pids = obs_pids(server)
check("srt-quit:OBS process found", bool(pids), f"no {server.obs_bin} process")
for pid in pids:
os.kill(pid, signal.SIGTERM)
deadline = time.time() + 30
while time.time() < deadline and obs_pids(server):
time.sleep(0.2)
left = obs_pids(server)
time.sleep(1)
with open(server.log, errors="replace") as f:
log = f.read()
check("srt-quit:OBS quits on SIGTERM while the listener waits",
not left and "Number of memory leaks" in log,
"still running 30 s after SIGTERM" if left else "no clean shutdown in the log")


async def run_shutdown_phase(obs_bin):
"""Simple output recording into a fresh folder, exit confirmation on."""
home = tempfile.mkdtemp(prefix="obs-tier4-")
Expand Down Expand Up @@ -1606,6 +1732,48 @@ async def run_scripts_only(obs_bin):
return 1 if failed else 0


async def run_srt_phase(obs_bin):
"""Simple output streaming to an SRT listener (srt:// Custom server)."""
profile = {
"Video": {"BaseCX": "640", "BaseCY": "360", "OutputCX": "640",
"OutputCY": "360", "FPSType": "0", "FPSCommon": "30"},
"Output": {"Mode": "Simple"},
"SimpleOutput": {"StreamEncoder": "x264", "VBitrate": "800"},
}
server = ObsServer(obs_bin, PORT, password=None, profile=profile)
server.start()
try:
print("== SRT listener: stop while reconnecting ==", flush=True)
await test_srt_listener_stop_while_reconnecting()
except BaseException:
server.report_failure()
raise
finally:
server.stop()

wait_for_port_closed(PORT)
server = ObsServer(obs_bin, PORT, password=None, profile=profile)
server.start()
try:
print("== SRT listener: quit while waiting for a caller ==", flush=True)
await test_srt_listener_quit_while_waiting(server)
except BaseException:
server.report_failure()
raise
finally:
server.stop()


async def run_srt_only(obs_bin):
await run_srt_phase(obs_bin)
failed = [n for n, ok, _ in RESULTS if not ok]
print("=" * 60)
print(f"checks: {len(RESULTS) - len(failed)}/{len(RESULTS)} passed")
for n, _, detail in (r for r in RESULTS if not r[1]):
print(f" - {n}: {detail}")
return 1 if failed else 0


async def run_gpu_phase(obs_bin):
"""OBS forced onto llvmpipe: GetStats.gpuAcceleration and the startup
warning (obs-rust/obs-studio#846, #940); and one libsrt in the
Expand Down Expand Up @@ -1713,6 +1881,10 @@ async def run_all(obs_bin, skip_obs, skip_auth_phase):
wait_for_port_closed(PORT)
await run_shutdown_phase(obs_bin)

if not skip_obs:
wait_for_port_closed(PORT)
await run_srt_phase(obs_bin)

total = len(RESULTS)
passed = sum(1 for _, ok, _ in RESULTS if ok)
failed = [n for n, ok, _ in RESULTS if not ok]
Expand Down Expand Up @@ -1743,19 +1915,22 @@ def main():
"mainly for debugging)")
ap.add_argument("--skip-auth-phase", action="store_true",
help="with --no-spawn only: skip the auth-required phase")
ap.add_argument("--only", choices=["gpu", "shutdown", "scripts"],
ap.add_argument("--only", choices=["gpu", "shutdown", "scripts", "srt"],
help="run one group: gpu = GetStats.gpuAcceleration and the "
"startup warning with OpenGL forced onto llvmpipe; "
"shutdown = SIGTERM while recording and during a "
"startup dialog; scripts = a Lua script switching "
"scenes from a timer")
"scenes from a timer; srt = stopping an SRT listener "
"and quitting while one waits")
args = ap.parse_args()
if args.only == "gpu":
sys.exit(asyncio.run(run_gpu_only(args.obs)))
if args.only == "shutdown":
sys.exit(asyncio.run(run_shutdown_only(args.obs)))
if args.only == "scripts":
sys.exit(asyncio.run(run_scripts_only(args.obs)))
if args.only == "srt":
sys.exit(asyncio.run(run_srt_only(args.obs)))
sys.exit(asyncio.run(
run_all(args.obs, args.no_spawn, args.skip_auth_phase)))

Expand Down
Loading