Mercurial > foo_out_sdl

comparison foosdk/sdk/foobar2000/helpers/ThreadUtils.cpp @ 1:20d02a178406 default tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
*: check in everything else yay
author Paper <paper@tflc.us>
date Mon, 05 Jan 2026 02:15:46 -0500
parents
children
comparison
equal deleted inserted replaced
0:e9bb126753e7 1:20d02a178406
1 #include "StdAfx.h"
2
3 #include "ThreadUtils.h"
4 #include "rethrow.h"
5
6 #include <exception>
7
8 namespace ThreadUtils {
9 bool CRethrow::exec( std::function<void () > f ) throw() {
10 m_exception = nullptr;
11 bool rv = false;
12 try {
13 f();
14 rv = true;
15 } catch( ... ) {
16 m_exception = std::current_exception();
17 }
18
19 return rv;
20 }
21
22 void CRethrow::rethrow() const {
23 if (m_exception) std::rethrow_exception(m_exception);
24 }
25 }
26 #ifdef _WIN32
27
28 #include "win32_misc.h"
29
30 #ifdef FOOBAR2000_MOBILE
31 #include <pfc/pp-winapi.h>
32 #endif
33
34
35 namespace ThreadUtils {
36 bool WaitAbortable(HANDLE ev, abort_callback & abort, DWORD timeout) {
37 const HANDLE handles[2] = {ev, abort.get_abort_event()};
38 SetLastError(0);
39 const DWORD status = WaitForMultipleObjects(2, handles, FALSE, timeout);
40 switch(status) {
41 case WAIT_TIMEOUT:
42 PFC_ASSERT( timeout != INFINITE );
43 return false;
44 case WAIT_OBJECT_0:
45 return true;
46 case WAIT_OBJECT_0 + 1:
47 throw exception_aborted();
48 case WAIT_FAILED:
49 WIN32_OP_FAIL();
50 default:
51 uBugCheck();
52 }
53 }
54 #ifdef FOOBAR2000_DESKTOP_WINDOWS
55 void ProcessPendingMessagesWithDialog(HWND hDialog) {
56 MSG msg = {};
57 while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
58 if (!IsDialogMessage(hDialog, &msg)) {
59 DispatchMessage(&msg);
60 }
61 }
62 }
63 void ProcessPendingMessages() {
64 MSG msg = {};
65 while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
66 DispatchMessage(&msg);
67 }
68 }
69 void WaitAbortable_MsgLoop(HANDLE ev, abort_callback & abort) {
70 abort.check();
71 const HANDLE handles[2] = {ev, abort.get_abort_event()};
72 MultiWait_MsgLoop(handles, 2);
73 abort.check();
74
75 }
76 t_size MultiWaitAbortable_MsgLoop2(const HANDLE* ev, t_size evCount, abort_callback& abort) {
77 abort.check();
78 const size_t evCountEx = evCount + 1;
79 HANDLE handles1[16];
80 pfc::array_staticsize_t<HANDLE> handles2;
81 HANDLE* pHandles = handles1;
82 if (evCountEx > 16) {
83 handles2.set_size_discard(evCountEx);
84 pHandles = handles2.get_ptr();
85 }
86 pHandles[0] = abort.get_abort_event();
87 pfc::memcpy_t(pHandles + 1, ev, evCount);
88 DWORD status = MultiWait_MsgLoop(pHandles, (DWORD) evCountEx);
89 abort.check();
90 size_t ret = (size_t)(status - WAIT_OBJECT_0 - 1);
91 PFC_ASSERT(ret < evCount);
92 return ret;
93 }
94
95 t_size MultiWaitAbortable_MsgLoop(const HANDLE * ev, t_size evCount, abort_callback & abort) {
96 // Retval is 1-based!
97 // Originally a bug, now kept for compatibility if someone relies on this
98 // Use MultiWaitAbortable_MsgLoop2() instead
99 return MultiWaitAbortable_MsgLoop2(ev, evCount, abort) + 1;
100 }
101
102 void SleepAbortable_MsgLoop(abort_callback & abort, DWORD timeout) {
103 HANDLE handles[] = { abort.get_abort_event() };
104 MultiWait_MsgLoop(handles, 1, timeout);
105 abort.check();
106 }
107
108 bool WaitAbortable_MsgLoop(HANDLE ev, abort_callback & abort, DWORD timeout) {
109 abort.check();
110 HANDLE handles[2] = { abort.get_abort_event(), ev };
111 DWORD status = MultiWait_MsgLoop(handles, 2, timeout);
112 abort.check();
113 return status != WAIT_TIMEOUT;
114 }
115
116 DWORD MultiWait_MsgLoop(const HANDLE* ev, DWORD evCount) {
117 for (;; ) {
118 SetLastError(0);
119 const DWORD status = MsgWaitForMultipleObjects((DWORD) evCount, ev, FALSE, INFINITE, QS_ALLINPUT);
120 if (status == WAIT_FAILED) WIN32_OP_FAIL();
121 if (status == WAIT_OBJECT_0 + evCount) {
122 ProcessPendingMessages();
123 } else if ( status >= WAIT_OBJECT_0 && status < WAIT_OBJECT_0 + evCount ) {
124 return status;
125 } else {
126 uBugCheck();
127 }
128 }
129 }
130
131 DWORD MultiWait_MsgLoop(const HANDLE* ev, DWORD evCount, DWORD timeout) {
132 if (timeout == INFINITE) return MultiWait_MsgLoop(ev, evCount);
133 const DWORD entry = GetTickCount();
134 DWORD now = entry;
135 for (;;) {
136 const DWORD done = now - entry;
137 if (done >= timeout) return WAIT_TIMEOUT;
138 SetLastError(0);
139 const DWORD status = MsgWaitForMultipleObjects((DWORD)evCount, ev, FALSE, timeout - done, QS_ALLINPUT);
140 if (status == WAIT_FAILED) WIN32_OP_FAIL();
141 if (status == WAIT_OBJECT_0 + evCount) {
142 ProcessPendingMessages();
143 } else if (status == WAIT_TIMEOUT || (status >= WAIT_OBJECT_0 && status < WAIT_OBJECT_0 + evCount) ) {
144 return status;
145 } else {
146 uBugCheck();
147 }
148 now = GetTickCount();
149 }
150 }
151
152 bool pfcWaitMsgLoop(HANDLE ev, double timeout) {
153 DWORD ms = pfc::event::g_calculate_wait_time(timeout);
154 DWORD status = MultiWait_MsgLoop(&ev, 1, ms);
155 return status == WAIT_OBJECT_0;
156 }
157
158 #endif // FOOBAR2000_DESKTOP_WINDOWS
159
160 }
161 #endif