← Back to branch summary

~ppsspp/ppsspp/ppsspp_1.3.0

« back to all changes in this revision

Viewing changes to Windows/EmuThread.cpp

  • Committer: Sérgio Benjamim
  • Date: 2017-01-02 00:12:05 UTC
  • Revision ID: sergio_br2@yahoo.com.br-20170102001205-cxbta9za203nmjwm
1.3.0 source (from ppsspp_1.3.0-r160.p5.l1762.a165.t83~56~ubuntu16.04.1.tar.xz).

Show diffs side-by-side

added added

removed removed

Lines of Context:
Windows/EmuThread.cpp
 
1
// NOTE: Apologies for the quality of this code, this is really from pre-opensource Dolphin - that is, 2003.
 
2
 
 
3
#include "base/timeutil.h"
 
4
#include "base/NativeApp.h"
 
5
#include "base/mutex.h"
 
6
#include "i18n/i18n.h"
 
7
#include "input/input_state.h"
 
8
#include "util/text/utf8.h"
 
9
 
 
10
#include "Common/Log.h"
 
11
#include "Common/StringUtils.h"
 
12
#include "../Globals.h"
 
13
#include "Windows/EmuThread.h"
 
14
#include "Windows/W32Util/Misc.h"
 
15
#include "Windows/MainWindow.h"
 
16
#include "Windows/resource.h"
 
17
#include "Core/Reporting.h"
 
18
#include "Core/MemMap.h"
 
19
#include "Core/Core.h"
 
20
#include "Core/Host.h"
 
21
#include "Core/System.h"
 
22
#include "Core/Config.h"
 
23
#include "thread/threadutil.h"
 
24
 
 
25
#include <tchar.h>
 
26
#include <process.h>
 
27
#include <intrin.h>
 
28
#pragma intrinsic(_InterlockedExchange)
 
29
 
 
30
static recursive_mutex emuThreadLock;
 
31
static HANDLE emuThread;
 
32
static volatile long emuThreadReady;
 
33
 
 
34
InputState input_state;
 
35
 
 
36
extern std::vector<std::wstring> GetWideCmdLine();
 
37
 
 
38
enum EmuThreadStatus : long
 
39
{
 
40
        THREAD_NONE = 0,
 
41
        THREAD_INIT,
 
42
        THREAD_CORE_LOOP,
 
43
        THREAD_SHUTDOWN,
 
44
        THREAD_END,
 
45
};
 
46
 
 
47
HANDLE EmuThread_GetThreadHandle()
 
48
{
 
49
        lock_guard guard(emuThreadLock);
 
50
        return emuThread;
 
51
}
 
52
 
 
53
unsigned int WINAPI TheThread(void *);
 
54
 
 
55
void EmuThread_Start()
 
56
{
 
57
        lock_guard guard(emuThreadLock);
 
58
        emuThread = (HANDLE)_beginthreadex(0, 0, &TheThread, 0, 0, 0);
 
59
}
 
60
 
 
61
void EmuThread_Stop()
 
62
{
 
63
        // Already stopped?
 
64
        {
 
65
                lock_guard guard(emuThreadLock);
 
66
                if (emuThread == NULL || emuThreadReady == THREAD_END)
 
67
                        return;
 
68
        }
 
69
 
 
70
        UpdateUIState(UISTATE_EXIT);
 
71
        Core_Stop();
 
72
        Core_WaitInactive(800);
 
73
        if (WAIT_TIMEOUT == WaitForSingleObject(emuThread, 800))
 
74
        {
 
75
                _dbg_assert_msg_(COMMON, false, "Wait for EmuThread timed out.");
 
76
        }
 
77
        {
 
78
                lock_guard guard(emuThreadLock);
 
79
                CloseHandle(emuThread);
 
80
                emuThread = 0;
 
81
        }
 
82
        host->UpdateUI();
 
83
}
 
84
 
 
85
bool EmuThread_Ready()
 
86
{
 
87
        return emuThreadReady == THREAD_CORE_LOOP;
 
88
}
 
89
 
 
90
unsigned int WINAPI TheThread(void *)
 
91
{
 
92
        _InterlockedExchange(&emuThreadReady, THREAD_INIT);
 
93
 
 
94
        setCurrentThreadName("Emu");  // And graphics...
 
95
 
 
96
        // Native overwrites host. Can't allow that.
 
97
 
 
98
        Host *oldHost = host;
 
99
 
 
100
        // Convert the command-line arguments to Unicode, then to proper UTF-8 
 
101
        // (the benefit being that we don't have to pollute the UI project with win32 ifdefs and lots of Convert<whatever>To<whatever>).
 
102
        // This avoids issues with PPSSPP inadvertently destroying paths with Unicode glyphs 
 
103
        // (using the ANSI args resulted in Japanese/Chinese glyphs being turned into question marks, at least for me..).
 
104
        // -TheDax
 
105
        std::vector<std::wstring> wideArgs = GetWideCmdLine();
 
106
        std::vector<std::string> argsUTF8;
 
107
        for (auto& string : wideArgs) {
 
108
                argsUTF8.push_back(ConvertWStringToUTF8(string));
 
109
        }
 
110
 
 
111
        std::vector<const char *> args;
 
112
 
 
113
        for (auto& string : argsUTF8) {
 
114
                args.push_back(string.c_str());
 
115
        }
 
116
 
 
117
        NativeInit(static_cast<int>(args.size()), &args[0], "1234", "1234", nullptr);
 
118
 
 
119
        Host *nativeHost = host;
 
120
        host = oldHost;
 
121
 
 
122
        host->UpdateUI();
 
123
 
 
124
        GraphicsContext *graphicsContext;
 
125
 
 
126
        std::string error_string;
 
127
        if (!host->InitGraphics(&error_string, &graphicsContext)) {
 
128
                I18NCategory *err = GetI18NCategory("Error");
 
129
                Reporting::ReportMessage("Graphics init error: %s", error_string.c_str());
 
130
 
 
131
                const char *defaultErrorVulkan = "Failed initializing graphics. Try upgrading your graphics drivers.\n\nWould you like to try switching to OpenGL?\n\nError message:";
 
132
                const char *defaultErrorOpenGL = "Failed initializing graphics. Try upgrading your graphics drivers.\n\nWould you like to try switching to DirectX 9?\n\nError message:";
 
133
                const char *defaultErrorDirect3D9 = "Failed initializing graphics. Try upgrading your graphics drivers and directx 9 runtime.\n\nWould you like to try switching to OpenGL?\n\nError message:";
 
134
                const char *genericError;
 
135
                int nextBackend = GPU_BACKEND_DIRECT3D9;
 
136
                switch (g_Config.iGPUBackend) {
 
137
                case GPU_BACKEND_DIRECT3D9:
 
138
                        nextBackend = GPU_BACKEND_OPENGL;
 
139
                        genericError = err->T("GenericDirect3D9Error", defaultErrorDirect3D9);
 
140
                        break;
 
141
                case GPU_BACKEND_VULKAN:
 
142
                        nextBackend = GPU_BACKEND_OPENGL;
 
143
                        genericError = err->T("GenericVulkanError", defaultErrorVulkan);
 
144
                        break;
 
145
                case GPU_BACKEND_OPENGL:
 
146
                default:
 
147
                        nextBackend = GPU_BACKEND_DIRECT3D9;
 
148
                        genericError = err->T("GenericOpenGLError", defaultErrorOpenGL);
 
149
                        break;
 
150
                }
 
151
                std::string full_error = StringFromFormat("%s\n\n%s", genericError, error_string.c_str());
 
152
                std::wstring title = ConvertUTF8ToWString(err->T("GenericGraphicsError", "Graphics Error"));
 
153
                bool yes = IDYES == MessageBox(0, ConvertUTF8ToWString(full_error).c_str(), title.c_str(), MB_ICONERROR | MB_YESNO);
 
154
                ERROR_LOG(BOOT, full_error.c_str());
 
155
 
 
156
                if (yes) {
 
157
                        // Change the config to the alternative and restart.
 
158
                        g_Config.iGPUBackend = nextBackend;
 
159
                        g_Config.Save();
 
160
 
 
161
                        W32Util::ExitAndRestart();
 
162
                }
 
163
 
 
164
                // No safe way out without graphics.
 
165
                ExitProcess(1);
 
166
        }
 
167
 
 
168
        PSP_CoreParameter().graphicsContext = graphicsContext;
 
169
 
 
170
        NativeInitGraphics(graphicsContext);
 
171
        NativeResized();
 
172
 
 
173
        INFO_LOG(BOOT, "Done.");
 
174
        _dbg_update_();
 
175
 
 
176
        if (coreState == CORE_POWERDOWN) {
 
177
                INFO_LOG(BOOT, "Exit before core loop.");
 
178
                goto shutdown;
 
179
        }
 
180
 
 
181
        _InterlockedExchange(&emuThreadReady, THREAD_CORE_LOOP);
 
182
 
 
183
        if (g_Config.bBrowse)
 
184
                PostMessage(MainWindow::GetHWND(), WM_COMMAND, ID_FILE_LOAD, 0);
 
185
 
 
186
        Core_EnableStepping(FALSE);
 
187
 
 
188
        while (GetUIState() != UISTATE_EXIT)
 
189
        {
 
190
                // We're here again, so the game quit.  Restart Core_Run() which controls the UI.
 
191
                // This way they can load a new game.
 
192
                if (!Core_IsActive())
 
193
                        UpdateUIState(UISTATE_MENU);
 
194
 
 
195
                Core_Run(graphicsContext, &input_state);
 
196
        }
 
197
 
 
198
shutdown:
 
199
        _InterlockedExchange(&emuThreadReady, THREAD_SHUTDOWN);
 
200
 
 
201
        NativeShutdownGraphics();
 
202
 
 
203
        host->ShutdownSound();
 
204
        host = nativeHost;
 
205
        NativeShutdown();
 
206
        host = oldHost;
 
207
        host->ShutdownGraphics();
 
208
        
 
209
        _InterlockedExchange(&emuThreadReady, THREAD_END);
 
210
 
 
211
        return 0;
 
212
}
 
213
 
 
214