1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
# HG changeset patch
# User Alex Chronopoulos <achronop@gmail.com>
# Parent b7bb31e5a851d6f8e142c39dc077e3774719eced
Bug 1342363 - Uplift wasapi fixes in Beta. r?kinetik
diff --git a/media/libcubeb/src/cubeb_wasapi.cpp b/media/libcubeb/src/cubeb_wasapi.cpp
--- a/media/libcubeb/src/cubeb_wasapi.cpp
+++ b/media/libcubeb/src/cubeb_wasapi.cpp
@@ -807,16 +807,20 @@ wasapi_stream_render_loop(LPVOID stream)
maybe WebRTC. */
mmcss_handle =
stm->context->set_mm_thread_characteristics("Audio", &mmcss_task_index);
if (!mmcss_handle) {
/* This is not fatal, but we might glitch under heavy load. */
LOG("Unable to use mmcss to bump the render thread priority: %x", GetLastError());
}
+ // This has already been nulled out, simply exit.
+ if (!emergency_bailout) {
+ is_playing = false;
+ }
/* WaitForMultipleObjects timeout can trigger in cases where we don't want to
treat it as a timeout, such as across a system sleep/wake cycle. Trigger
the timeout error handling only when the timeout_limit is reached, which is
reset on each successful loop. */
unsigned timeout_count = 0;
const unsigned timeout_limit = 5;
while (is_playing) {
@@ -1158,22 +1162,26 @@ bool stop_and_join_render_thread(cubeb_s
/* Wait five seconds for the rendering thread to return. It's supposed to
* check its event loop very often, five seconds is rather conservative. */
DWORD r = WaitForSingleObject(stm->thread, 5000);
if (r == WAIT_TIMEOUT) {
/* Something weird happened, leak the thread and continue the shutdown
* process. */
*(stm->emergency_bailout) = true;
+ // We give the ownership to the rendering thread.
+ stm->emergency_bailout = nullptr;
LOG("Destroy WaitForSingleObject on thread timed out,"
" leaking the thread: %d", GetLastError());
rv = false;
}
if (r == WAIT_FAILED) {
*(stm->emergency_bailout) = true;
+ // We give the ownership to the rendering thread.
+ stm->emergency_bailout = nullptr;
LOG("Destroy WaitForSingleObject on thread failed: %d", GetLastError());
rv = false;
}
// Only attempts to close and null out the thread and event if the
// WaitForSingleObject above succeeded, so that calling this function again
// attemps to clean up the thread and event each time.
@@ -1798,19 +1806,16 @@ void wasapi_stream_destroy(cubeb_stream
XASSERT(stm);
// Only free stm->emergency_bailout if we could not join the thread.
// If we could not join the thread, stm->emergency_bailout is true
// and is still alive until the thread wakes up and exits cleanly.
if (stop_and_join_render_thread(stm)) {
delete stm->emergency_bailout.load();
stm->emergency_bailout = nullptr;
- } else {
- // If we're leaking, it must be that this is true.
- assert(*(stm->emergency_bailout));
}
unregister_notification_client(stm);
SafeRelease(stm->reconfigure_event);
SafeRelease(stm->refill_event);
SafeRelease(stm->input_available_event);
@@ -1865,21 +1870,21 @@ int stream_start_one_side(cubeb_stream *
return CUBEB_ERROR;
}
return CUBEB_OK;
}
int wasapi_stream_start(cubeb_stream * stm)
{
+ auto_lock lock(stm->stream_reset_lock);
+
XASSERT(stm && !stm->thread && !stm->shutdown_event);
XASSERT(stm->output_client || stm->input_client);
- auto_lock lock(stm->stream_reset_lock);
-
stm->emergency_bailout = new std::atomic<bool>(false);
if (stm->output_client) {
int rv = stream_start_one_side(stm, OUTPUT);
if (rv != CUBEB_OK) {
return rv;
}
}
@@ -1932,16 +1937,17 @@ int wasapi_stream_stop(cubeb_stream * st
}
}
stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_STOPPED);
}
if (stop_and_join_render_thread(stm)) {
+ // This is null if we've given the pointer to the other thread
if (stm->emergency_bailout.load()) {
delete stm->emergency_bailout.load();
stm->emergency_bailout = nullptr;
}
}
return CUBEB_OK;
}
|
