?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed a resource (file descriptor) leak: If a QFile object was created from a C Runti...
[LameXP.git] / src / Global.cpp
blob51cfce37acbe2d46501b84ad5f0ba6e4bff48294
1 ///////////////////////////////////////////////////////////////////////////////
2 // LameXP - Audio Encoder Front-End
3 // Copyright (C) 2004-2013 LoRd_MuldeR <MuldeR2@GMX.de>
4 //
5 // This program is free software; you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation; either version 2 of the License, or
8 // (at your option) any later version, but always including the *additional*
9 // restrictions defined in the "License.txt" file.
10 //
11 // This program is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 //
16 // You should have received a copy of the GNU General Public License along
17 // with this program; if not, write to the Free Software Foundation, Inc.,
18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 //
20 // http://www.gnu.org/licenses/gpl-2.0.txt
21 ///////////////////////////////////////////////////////////////////////////////
22
23 #include "Global.h"
24
25 //Windows includes
26 #define NOMINMAX
27 #define WIN32_LEAN_AND_MEAN
28 #include <Windows.h>
29 #include <MMSystem.h>
30 #include <ShellAPI.h>
31 #include <SensAPI.h>
32
33 //Qt includes
34 #include <QApplication>
35 #include <QMessageBox>
36 #include <QDir>
37 #include <QUuid>
38 #include <QMap>
39 #include <QDate>
40 #include <QIcon>
41 #include <QPlastiqueStyle>
42 #include <QImageReader>
43 #include <QSharedMemory>
44 #include <QSysInfo>
45 #include <QStringList>
46 #include <QSystemSemaphore>
47 #include <QMutex>
48 #include <QTextCodec>
49 #include <QLibrary>
50 #include <QRegExp>
51 #include <QResource>
52 #include <QTranslator>
53 #include <QEventLoop>
54 #include <QTimer>
55 #include <QLibraryInfo>
56 #include <QEvent>
57 #include <QReadWriteLock>
58 #include <QReadLocker>
59 #include <QWriteLocker>
60 #include <QProcess>
61
62 //LameXP includes
63 #define LAMEXP_INC_CONFIG
64 #include "Resource.h"
65 #include "Config.h"
66 #include "LockedFile.h"
67 #include "strnatcmp.h"
68
69 //CRT includes
70 #include <iostream>
71 #include <fstream>
72 #include <io.h>
73 #include <fcntl.h>
74 #include <intrin.h>
75 #include <math.h>
76 #include <time.h>
77 #include <process.h>
78
79 //Shell API
80 #include <Shellapi.h>
81
82 //COM includes
83 #include <Objbase.h>
84 #include <PowrProf.h>
85
86 //Process API
87 #include <Psapi.h>
88
89 //Initialize static Qt plugins
90 #ifdef QT_NODLL
91 #if QT_VERSION < QT_VERSION_CHECK(5,0,0)
92 Q_IMPORT_PLUGIN(qico)
93 Q_IMPORT_PLUGIN(qsvg)
94 #else
95 Q_IMPORT_PLUGIN(QWindowsIntegrationPlugin)
96 Q_IMPORT_PLUGIN(QICOPlugin)
97 #endif
98 #endif
99
100 #define LAMEXP_ZERO_MEMORY(X) SecureZeroMemory(&X, sizeof(X))
101
102 //Helper macros
103 #define _LAMEXP_MAKE_STR(STR) #STR
104 #define LAMEXP_MAKE_STR(STR) _LAMEXP_MAKE_STR(STR)
105
106 //String helper
107 #define CLEAN_OUTPUT_STRING(STR) do \
108 { \
109 const char CTRL_CHARS[3] = { '\r', '\n', '\t' }; \
110 for(size_t i = 0; i < 3; i++) \
111 { \
112 while(char *pos = strchr((STR), CTRL_CHARS[i])) *pos = char(0x20); \
113 } \
114 } \
115 while(0)
116
117 //String helper
118 #define TRIM_LEFT(STR) do \
119 { \
120 const char WHITE_SPACE[4] = { char(0x20), '\r', '\n', '\t' }; \
121 for(size_t i = 0; i < 4; i++) \
122 { \
123 while(*(STR) == WHITE_SPACE[i]) (STR)++; \
124 } \
125 } \
126 while(0)
127
128 ///////////////////////////////////////////////////////////////////////////////
129 // TYPES
130 ///////////////////////////////////////////////////////////////////////////////
131
132 static const size_t g_lamexp_ipc_slots = 128;
133
134 typedef struct
135 {
136 unsigned int command;
137 unsigned int reserved_1;
138 unsigned int reserved_2;
139 char parameter[4096];
140 }
141 lamexp_ipc_data_t;
142
143 typedef struct
144 {
145 unsigned int pos_write;
146 unsigned int pos_read;
147 lamexp_ipc_data_t data[g_lamexp_ipc_slots];
148 }
149 lamexp_ipc_t;
150
151 ///////////////////////////////////////////////////////////////////////////////
152 // GLOBAL VARS
153 ///////////////////////////////////////////////////////////////////////////////
154
155 //Build version
156 static const struct
157 {
158 unsigned int ver_major;
159 unsigned int ver_minor;
160 unsigned int ver_build;
161 unsigned int ver_confg;
162 char *ver_release_name;
163 }
164 g_lamexp_version =
165 {
166 VER_LAMEXP_MAJOR,
167 (10 * VER_LAMEXP_MINOR_HI) + VER_LAMEXP_MINOR_LO,
168 VER_LAMEXP_BUILD,
169 VER_LAMEXP_CONFG,
170 VER_LAMEXP_RNAME,
171 };
172
173 //Build date
174 static QDate g_lamexp_version_date;
175 static const char *g_lamexp_months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
176 static const char *g_lamexp_version_raw_date = __DATE__;
177 static const char *g_lamexp_version_raw_time = __TIME__;
178
179 //Console attached flag
180 static bool g_lamexp_console_attached = false;
181
182 //Official web-site URL
183 static const char *g_lamexp_website_url = "http://lamexp.sourceforge.net/";
184 static const char *g_lamexp_support_url = "http://forum.doom9.org/showthread.php?t=157726";
185 static const char *g_lamexp_mulders_url = "http://muldersoft.com/";
186
187 //Tool versions (expected versions!)
188 static const unsigned int g_lamexp_toolver_neroaac = VER_LAMEXP_TOOL_NEROAAC;
189 static const unsigned int g_lamexp_toolver_fhgaacenc = VER_LAMEXP_TOOL_FHGAACENC;
190 static const unsigned int g_lamexp_toolver_qaacenc = VER_LAMEXP_TOOL_QAAC;
191 static const unsigned int g_lamexp_toolver_coreaudio = VER_LAMEXP_TOOL_COREAUDIO;
192
193 //Special folders
194 static struct
195 {
196 QMap<size_t, QString> *knownFolders;
197 QReadWriteLock lock;
198 }
199 g_lamexp_known_folder;
200
201 //%TEMP% folder
202 static struct
203 {
204 QString *path;
205 QReadWriteLock lock;
206 }
207 g_lamexp_temp_folder;
208
209 //Tools
210 static struct
211 {
212 QMap<QString, LockedFile*> *registry;
213 QMap<QString, unsigned int> *versions;
214 QMap<QString, QString> *tags;
215 QReadWriteLock lock;
216 }
217 g_lamexp_tools;
218
219 //Languages
220 static struct
221 {
222 QMap<QString, QString> *files;
223 QMap<QString, QString> *names;
224 QMap<QString, unsigned int> *sysid;
225 QMap<QString, unsigned int> *cntry;
226 QReadWriteLock lock;
227 }
228 g_lamexp_translation;
229
230 //Translator
231 static struct
232 {
233 QTranslator *instance;
234 QReadWriteLock lock;
235 }
236 g_lamexp_currentTranslator;
237
238 //CLI Arguments
239 static struct
240 {
241 QStringList *list;
242 QReadWriteLock lock;
243 }
244 g_lamexp_argv;
245
246 //OS Version
247 static struct
248 {
249 bool bInitialized;
250 lamexp_os_version_t version;
251 QReadWriteLock lock;
252 }
253 g_lamexp_os_version;
254
255 //Portable Mode
256 static struct
257 {
258 bool bInitialized;
259 bool bPortableModeEnabled;
260 QReadWriteLock lock;
261 }
262 g_lamexp_portable;
263
264 //Win32 Theme support
265 static struct
266 {
267 bool bInitialized;
268 bool bThemesEnabled;
269 QReadWriteLock lock;
270 }
271 g_lamexp_themes_enabled;
272
273 //Shared memory
274 static const struct
275 {
276 char *sharedmem;
277 char *semaphore_read;
278 char *semaphore_read_mutex;
279 char *semaphore_write;
280 char *semaphore_write_mutex;
281 }
282 g_lamexp_ipc_uuid =
283 {
284 "{21A68A42-6923-43bb-9CF6-64BF151942EE}",
285 "{7A605549-F58C-4d78-B4E5-06EFC34F405B}",
286 "{60AA8D04-F6B8-497d-81EB-0F600F4A65B5}",
287 "{726061D5-1615-4B82-871C-75FD93458E46}",
288 "{1A616023-AA6A-4519-8AF3-F7736E899977}"
289 };
290 static struct
291 {
292 QSharedMemory *sharedmem;
293 QSystemSemaphore *semaphore_read;
294 QSystemSemaphore *semaphore_read_mutex;
295 QSystemSemaphore *semaphore_write;
296 QSystemSemaphore *semaphore_write_mutex;
297 QReadWriteLock lock;
298 }
299 g_lamexp_ipc_ptr;
300
301 //Image formats
302 static const char *g_lamexp_imageformats[] = {"bmp", "png", "jpg", "gif", "ico", "xpm", NULL}; //"svg"
303
304 //Global locks
305 static QMutex g_lamexp_message_mutex;
306
307 //Main thread ID
308 static const DWORD g_main_thread_id = GetCurrentThreadId();
309
310 //Log file
311 static FILE *g_lamexp_log_file = NULL;
312
313 //Localization
314 const char* LAMEXP_DEFAULT_LANGID = "en";
315 const char* LAMEXP_DEFAULT_TRANSLATION = "LameXP_EN.qm";
316
317 //Known Windows versions - maps marketing names to the actual Windows NT versions
318 const lamexp_os_version_t lamexp_winver_win2k = {5,0};
319 const lamexp_os_version_t lamexp_winver_winxp = {5,1};
320 const lamexp_os_version_t lamexp_winver_xpx64 = {5,2};
321 const lamexp_os_version_t lamexp_winver_vista = {6,0};
322 const lamexp_os_version_t lamexp_winver_win70 = {6,1};
323 const lamexp_os_version_t lamexp_winver_win80 = {6,2};
324 const lamexp_os_version_t lamexp_winver_win81 = {6,3};
325
326 //GURU MEDITATION
327 static const char *GURU_MEDITATION = "\n\nGURU MEDITATION !!!\n\n";
328
329 ///////////////////////////////////////////////////////////////////////////////
330 // COMPILER INFO
331 ///////////////////////////////////////////////////////////////////////////////
332
333 /*
334 * Disclaimer: Parts of the following code were borrowed from MPC-HC project: http://mpc-hc.sf.net/
335 */
336
337 //Compiler detection
338 #if defined(__INTEL_COMPILER)
339 #if (__INTEL_COMPILER >= 1300)
340 static const char *g_lamexp_version_compiler = "ICL 13." LAMEXP_MAKE_STR(__INTEL_COMPILER_BUILD_DATE);
341 #elif (__INTEL_COMPILER >= 1200)
342 static const char *g_lamexp_version_compiler = "ICL 12." LAMEXP_MAKE_STR(__INTEL_COMPILER_BUILD_DATE);
343 #elif (__INTEL_COMPILER >= 1100)
344 static const char *g_lamexp_version_compiler = "ICL 11.x";
345 #elif (__INTEL_COMPILER >= 1000)
346 static const char *g_lamexp_version_compiler = "ICL 10.x";
347 #else
348 #error Compiler is not supported!
349 #endif
350 #elif defined(_MSC_VER)
351 #if (_MSC_VER == 1800)
352 #if (_MSC_FULL_VER < 180021005)
353 static const char *g_lamexp_version_compiler = "MSVC 2013-Beta";
354 #elif (_MSC_FULL_VER == 180021005)
355 static const char *g_lamexp_version_compiler = "MSVC 2013";
356 #else
357 #error Compiler version is not supported yet!
358 #endif
359 #elif (_MSC_VER == 1700)
360 #if (_MSC_FULL_VER < 170050727)
361 static const char *g_lamexp_version_compiler = "MSVC 2012-Beta";
362 #elif (_MSC_FULL_VER < 170051020)
363 static const char *g_lamexp_version_compiler = "MSVC 2012";
364 #elif (_MSC_FULL_VER < 170051106)
365 static const char *g_lamexp_version_compiler = "MSVC 2012.1-CTP";
366 #elif (_MSC_FULL_VER < 170060315)
367 static const char *g_lamexp_version_compiler = "MSVC 2012.1";
368 #elif (_MSC_FULL_VER < 170060610)
369 static const char *g_lamexp_version_compiler = "MSVC 2012.2";
370 #elif (_MSC_FULL_VER == 170060610)
371 static const char *g_lamexp_version_compiler = "MSVC 2012.3";
372 #else
373 #error Compiler version is not supported yet!
374 #endif
375 #elif (_MSC_VER == 1600)
376 #if (_MSC_FULL_VER < 160040219)
377 static const char *g_lamexp_version_compiler = "MSVC 2010";
378 #elif (_MSC_FULL_VER == 160040219)
379 static const char *g_lamexp_version_compiler = "MSVC 2010-SP1";
380 #else
381 #error Compiler version is not supported yet!
382 #endif
383 #elif (_MSC_VER == 1500)
384 #if (_MSC_FULL_VER >= 150030729)
385 static const char *g_lamexp_version_compiler = "MSVC 2008-SP1";
386 #else
387 static const char *g_lamexp_version_compiler = "MSVC 2008";
388 #endif
389 #else
390 #error Compiler is not supported!
391 #endif
392
393 // Note: /arch:SSE and /arch:SSE2 are only available for the x86 platform
394 #if !defined(_M_X64) && defined(_M_IX86_FP)
395 #if (_M_IX86_FP == 1)
396 LAMEXP_COMPILER_WARNING("SSE instruction set is enabled!")
397 #elif (_M_IX86_FP == 2)
398 LAMEXP_COMPILER_WARNING("SSE2 (or higher) instruction set is enabled!")
399 #endif
400 #endif
401 #else
402 #error Compiler is not supported!
403 #endif
404
405 //Architecture detection
406 #if defined(_M_X64)
407 static const char *g_lamexp_version_arch = "x64";
408 #elif defined(_M_IX86)
409 static const char *g_lamexp_version_arch = "x86";
410 #else
411 #error Architecture is not supported!
412 #endif
413
414 ///////////////////////////////////////////////////////////////////////////////
415 // GLOBAL FUNCTIONS
416 ///////////////////////////////////////////////////////////////////////////////
417
418 /*
419 * Version getters
420 */
421 unsigned int lamexp_version_major(void) { return g_lamexp_version.ver_major; }
422 unsigned int lamexp_version_minor(void) { return g_lamexp_version.ver_minor; }
423 unsigned int lamexp_version_build(void) { return g_lamexp_version.ver_build; }
424 unsigned int lamexp_version_confg(void) { return g_lamexp_version.ver_confg; }
425 const char *lamexp_version_release(void) { return g_lamexp_version.ver_release_name; }
426 const char *lamexp_version_time(void) { return g_lamexp_version_raw_time; }
427 const char *lamexp_version_compiler(void) { return g_lamexp_version_compiler; }
428 const char *lamexp_version_arch(void) { return g_lamexp_version_arch; }
429 unsigned int lamexp_toolver_neroaac(void) { return g_lamexp_toolver_neroaac; }
430 unsigned int lamexp_toolver_fhgaacenc(void) { return g_lamexp_toolver_fhgaacenc; }
431 unsigned int lamexp_toolver_qaacenc(void) { return g_lamexp_toolver_qaacenc; }
432 unsigned int lamexp_toolver_coreaudio(void) { return g_lamexp_toolver_coreaudio; }
433
434 /*
435 * URL getters
436 */
437 const char *lamexp_website_url(void) { return g_lamexp_website_url; }
438 const char *lamexp_mulders_url(void) { return g_lamexp_mulders_url; }
439 const char *lamexp_support_url(void) { return g_lamexp_support_url; }
440
441 /*
442 * Check for Demo (pre-release) version
443 */
444 bool lamexp_version_demo(void)
445 {
446 char buffer[128];
447 bool releaseVersion = false;
448 if(!strncpy_s(buffer, 128, g_lamexp_version.ver_release_name, _TRUNCATE))
449 {
450 char *context, *prefix = strtok_s(buffer, "-,; ", &context);
451 if(prefix)
452 {
453 releaseVersion = (!_stricmp(prefix, "Final")) || (!_stricmp(prefix, "Hotfix"));
454 }
455 }
456 return (!releaseVersion);
457 }
458
459 /*
460 * Calculate expiration date
461 */
462 QDate lamexp_version_expires(void)
463 {
464 return lamexp_version_date().addDays(LAMEXP_DEBUG ? 7 : 30);
465 }
466
467 /*
468 * Convert month string to integer value
469 */
470 static int lamexp_month2int(const char *str)
471 {
472 int ret = 0;
473
474 for(int j = 0; j < 12; j++)
475 {
476 if(!_strcmpi(str, g_lamexp_months[j]))
477 {
478 ret = j+1;
479 break;
480 }
481 }
482
483 return ret;
484 }
485
486 /*
487 * Get build date date
488 */
489 const QDate &lamexp_version_date(void)
490 {
491 //Format of __DATE__ is defined as: "MMM DD YYYY"
492 if(!g_lamexp_version_date.isValid())
493 {
494 int date[3] = {0, 0, 0};
495 char temp_m[4], temp_d[3], temp_y[5];
496
497 temp_m[0] = g_lamexp_version_raw_date[0x0];
498 temp_m[1] = g_lamexp_version_raw_date[0x1];
499 temp_m[2] = g_lamexp_version_raw_date[0x2];
500 temp_m[3] = 0x00;
501
502 temp_d[0] = g_lamexp_version_raw_date[0x4];
503 temp_d[1] = g_lamexp_version_raw_date[0x5];
504 temp_d[2] = 0x00;
505
506 temp_y[0] = g_lamexp_version_raw_date[0x7];
507 temp_y[1] = g_lamexp_version_raw_date[0x8];
508 temp_y[2] = g_lamexp_version_raw_date[0x9];
509 temp_y[3] = g_lamexp_version_raw_date[0xA];
510 temp_y[4] = 0x00;
511
512 date[0] = atoi(temp_y);
513 date[1] = lamexp_month2int(temp_m);
514 date[2] = atoi(temp_d);
515
516 if((date[0] > 0) && (date[1] > 0) && (date[2] > 0))
517 {
518
519 g_lamexp_version_date = QDate(date[0], date[1], date[2]);
520 }
521 else
522 {
523 THROW("Internal error: Date format could not be recognized!");
524 }
525 }
526
527 return g_lamexp_version_date;
528 }
529
530 static bool lamexp_verify_os_version(const DWORD major, const DWORD minor)
531 {
532 OSVERSIONINFOEXW osvi;
533 DWORDLONG dwlConditionMask = 0;
534
535 //Initialize the OSVERSIONINFOEX structure
536 memset(&osvi, 0, sizeof(OSVERSIONINFOEXW));
537 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXW);
538 osvi.dwMajorVersion = major;
539 osvi.dwMinorVersion = minor;
540 osvi.dwPlatformId = VER_PLATFORM_WIN32_NT;
541
542 //Initialize the condition mask
543 VER_SET_CONDITION(dwlConditionMask, VER_MAJORVERSION, VER_GREATER_EQUAL);
544 VER_SET_CONDITION(dwlConditionMask, VER_MINORVERSION, VER_GREATER_EQUAL);
545 VER_SET_CONDITION(dwlConditionMask, VER_PLATFORMID, VER_EQUAL);
546
547 // Perform the test
548 const BOOL ret = VerifyVersionInfoW(&osvi, VER_MAJORVERSION | VER_MINORVERSION | VER_PLATFORMID, dwlConditionMask);
549
550 //Error checking
551 if(!ret)
552 {
553 if(GetLastError() != ERROR_OLD_WIN_VERSION)
554 {
555 qWarning("VerifyVersionInfo() system call has failed!");
556 }
557 }
558
559 return (ret != FALSE);
560 }
561
562 /*
563 * Determine the *real* Windows version
564 */
565 static bool lamexp_get_real_os_version(unsigned int *major, unsigned int *minor, bool *pbOverride)
566 {
567 *major = *minor = 0;
568 *pbOverride = false;
569
570 //Initialize local variables
571 OSVERSIONINFOEXW osvi;
572 memset(&osvi, 0, sizeof(OSVERSIONINFOEXW));
573 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXW);
574
575 //Try GetVersionEx() first
576 if(GetVersionExW((LPOSVERSIONINFOW)&osvi) == FALSE)
577 {
578 qWarning("GetVersionEx() has failed, cannot detect Windows version!");
579 return false;
580 }
581
582 //Make sure we are running on NT
583 if(osvi.dwPlatformId == VER_PLATFORM_WIN32_NT)
584 {
585 *major = osvi.dwMajorVersion;
586 *minor = osvi.dwMinorVersion;
587 }
588 else
589 {
590 qWarning("Not running on Windows NT, unsupported operating system!");
591 return false;
592 }
593
594 //Determine the real *major* version first
595 forever
596 {
597 const DWORD nextMajor = (*major) + 1;
598 if(lamexp_verify_os_version(nextMajor, 0))
599 {
600 *pbOverride = true;
601 *major = nextMajor;
602 *minor = 0;
603 continue;
604 }
605 break;
606 }
607
608 //Now also determine the real *minor* version
609 forever
610 {
611 const DWORD nextMinor = (*minor) + 1;
612 if(lamexp_verify_os_version((*major), nextMinor))
613 {
614 *pbOverride = true;
615 *minor = nextMinor;
616 continue;
617 }
618 break;
619 }
620
621 return true;
622 }
623
624 /*
625 * Get the native operating system version
626 */
627 const lamexp_os_version_t &lamexp_get_os_version(void)
628 {
629 QReadLocker readLock(&g_lamexp_os_version.lock);
630
631 //Already initialized?
632 if(g_lamexp_os_version.bInitialized)
633 {
634 return g_lamexp_os_version.version;
635 }
636
637 readLock.unlock();
638 QWriteLocker writeLock(&g_lamexp_os_version.lock);
639
640 //Detect OS version
641 if(!g_lamexp_os_version.bInitialized)
642 {
643 unsigned int major, minor; bool oflag;
644 if(lamexp_get_real_os_version(&major, &minor, &oflag))
645 {
646 g_lamexp_os_version.version.versionMajor = major;
647 g_lamexp_os_version.version.versionMinor = minor;
648 g_lamexp_os_version.version.overrideFlag = oflag;
649 g_lamexp_os_version.bInitialized = true;
650 }
651 else
652 {
653 qWarning("Failed to determin the operating system version!");
654 }
655 }
656
657 return g_lamexp_os_version.version;
658 }
659
660 /*
661 * Check if we are running under wine
662 */
663 bool lamexp_detect_wine(void)
664 {
665 static bool isWine = false;
666 static bool isWine_initialized = false;
667
668 if(!isWine_initialized)
669 {
670 QLibrary ntdll("ntdll.dll");
671 if(ntdll.load())
672 {
673 if(ntdll.resolve("wine_nt_to_unix_file_name") != NULL) isWine = true;
674 if(ntdll.resolve("wine_get_version") != NULL) isWine = true;
675 ntdll.unload();
676 }
677 isWine_initialized = true;
678 }
679
680 return isWine;
681 }
682
683 /*
684 * Global exception handler
685 */
686 LONG WINAPI lamexp_exception_handler(__in struct _EXCEPTION_POINTERS *ExceptionInfo)
687 {
688 lamexp_fatal_exit(L"Unhandeled exception handler invoked, application will exit!");
689 return LONG_MAX;
690 }
691
692 /*
693 * Invalid parameters handler
694 */
695 void lamexp_invalid_param_handler(const wchar_t* exp, const wchar_t* fun, const wchar_t* fil, unsigned int, uintptr_t)
696 {
697 lamexp_fatal_exit(L"Invalid parameter handler invoked, application will exit!");
698 }
699
700 /*
701 * Change console text color
702 */
703 static void lamexp_console_color(FILE* file, WORD attributes)
704 {
705 const HANDLE hConsole = (HANDLE)(_get_osfhandle(_fileno(file)));
706 if((hConsole != NULL) && (hConsole != INVALID_HANDLE_VALUE))
707 {
708 SetConsoleTextAttribute(hConsole, attributes);
709 }
710 }
711
712 /*
713 * Output logging message to console
714 */
715 static void lamexp_write_console(const int type, const char *msg)
716 {
717 __try
718 {
719 if(_isatty(_fileno(stderr)))
720 {
721 UINT oldOutputCP = GetConsoleOutputCP();
722 if(oldOutputCP != CP_UTF8) SetConsoleOutputCP(CP_UTF8);
723
724 switch(type)
725 {
726 case QtCriticalMsg:
727 case QtFatalMsg:
728 lamexp_console_color(stderr, FOREGROUND_RED | FOREGROUND_INTENSITY);
729 fprintf(stderr, GURU_MEDITATION);
730 fprintf(stderr, "%s\n", msg);
731 fflush(stderr);
732 break;
733 case QtWarningMsg:
734 lamexp_console_color(stderr, FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY);
735 fprintf(stderr, "%s\n", msg);
736 fflush(stderr);
737 break;
738 default:
739 lamexp_console_color(stderr, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY);
740 fprintf(stderr, "%s\n", msg);
741 fflush(stderr);
742 break;
743 }
744
745 lamexp_console_color(stderr, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED);
746 if(oldOutputCP != CP_UTF8) SetConsoleOutputCP(oldOutputCP);
747 }
748 }
749 __except(1)
750 {
751 /*ignore any exception that might occur here!*/
752 }
753 }
754
755 /*
756 * Output logging message to debugger
757 */
758 static void lamexp_write_dbg_out(const int type, const char *msg)
759 {
760 const char *FORMAT = "[LameXP][%c] %s\n";
761
762 __try
763 {
764 char buffer[512];
765 const char* input = msg;
766 TRIM_LEFT(input);
767
768 switch(type)
769 {
770 case QtCriticalMsg:
771 case QtFatalMsg:
772 _snprintf_s(buffer, 512, _TRUNCATE, FORMAT, 'C', input);
773 break;
774 case QtWarningMsg:
775 _snprintf_s(buffer, 512, _TRUNCATE, FORMAT, 'W', input);
776 break;
777 default:
778 _snprintf_s(buffer, 512, _TRUNCATE, FORMAT, 'I', input);
779 break;
780 }
781
782 char *temp = &buffer[0];
783 CLEAN_OUTPUT_STRING(temp);
784 OutputDebugStringA(temp);
785 }
786 __except(1)
787 {
788 /*ignore any exception that might occur here!*/
789 }
790 }
791
792 /*
793 * Output logging message to logfile
794 */
795 static void lamexp_write_logfile(const int type, const char *msg)
796 {
797 const char *FORMAT = "[%c][%04u] %s\r\n";
798
799 __try
800 {
801 if(g_lamexp_log_file)
802 {
803 char buffer[512];
804 strncpy_s(buffer, 512, msg, _TRUNCATE);
805
806 char *temp = &buffer[0];
807 TRIM_LEFT(temp);
808 CLEAN_OUTPUT_STRING(temp);
809
810 const unsigned int timestamp = static_cast<unsigned int>(_time64(NULL) % 3600I64);
811
812 switch(type)
813 {
814 case QtCriticalMsg:
815 case QtFatalMsg:
816 fprintf(g_lamexp_log_file, FORMAT, 'C', timestamp, temp);
817 break;
818 case QtWarningMsg:
819 fprintf(g_lamexp_log_file, FORMAT, 'W', timestamp, temp);
820 break;
821 default:
822 fprintf(g_lamexp_log_file, FORMAT, 'I', timestamp, temp);
823 break;
824 }
825
826 fflush(g_lamexp_log_file);
827 }
828 }
829 __except(1)
830 {
831 /*ignore any exception that might occur here!*/
832 }
833 }
834
835 /*
836 * Qt message handler
837 */
838 void lamexp_message_handler(QtMsgType type, const char *msg)
839 {
840 if((!msg) || (!(msg[0])))
841 {
842 return;
843 }
844
845 QMutexLocker lock(&g_lamexp_message_mutex);
846
847 if(g_lamexp_log_file)
848 {
849 lamexp_write_logfile(type, msg);
850 }
851
852 if(g_lamexp_console_attached)
853 {
854 lamexp_write_console(type, msg);
855 }
856 else
857 {
858 lamexp_write_dbg_out(type, msg);
859 }
860
861 if((type == QtCriticalMsg) || (type == QtFatalMsg))
862 {
863 lock.unlock();
864 lamexp_fatal_exit(L"The application has encountered a critical error and will exit now!", QWCHAR(QString::fromUtf8(msg)));
865 }
866 }
867
868 /*
869 * Initialize the console
870 */
871 void lamexp_init_console(const QStringList &argv)
872 {
873 bool enableConsole = (LAMEXP_DEBUG) || ((VER_LAMEXP_CONSOLE_ENABLED) && lamexp_version_demo());
874
875 if(_environ)
876 {
877 wchar_t *logfile = NULL;
878 size_t logfile_len = 0;
879 if(!_wdupenv_s(&logfile, &logfile_len, L"LAMEXP_LOGFILE"))
880 {
881 if(logfile && (logfile_len > 0))
882 {
883 FILE *temp = NULL;
884 if(!_wfopen_s(&temp, logfile, L"wb"))
885 {
886 fprintf(temp, "%c%c%c", char(0xEF), char(0xBB), char(0xBF));
887 g_lamexp_log_file = temp;
888 }
889 free(logfile);
890 }
891 }
892 }
893
894 if(!LAMEXP_DEBUG)
895 {
896 for(int i = 0; i < argv.count(); i++)
897 {
898 if(!argv.at(i).compare("--console", Qt::CaseInsensitive))
899 {
900 enableConsole = true;
901 }
902 else if(!argv.at(i).compare("--no-console", Qt::CaseInsensitive))
903 {
904 enableConsole = false;
905 }
906 }
907 }
908
909 if(enableConsole)
910 {
911 if(!g_lamexp_console_attached)
912 {
913 if(AllocConsole() != FALSE)
914 {
915 SetConsoleCtrlHandler(NULL, TRUE);
916 SetConsoleTitle(L"LameXP - Audio Encoder Front-End | Debug Console");
917 SetConsoleOutputCP(CP_UTF8);
918 g_lamexp_console_attached = true;
919 }
920 }
921
922 if(g_lamexp_console_attached)
923 {
924 //-------------------------------------------------------------------
925 //See: http://support.microsoft.com/default.aspx?scid=kb;en-us;105305
926 //-------------------------------------------------------------------
927 const int flags = _O_WRONLY | _O_U8TEXT;
928 int hCrtStdOut = _open_osfhandle((intptr_t) GetStdHandle(STD_OUTPUT_HANDLE), flags);
929 int hCrtStdErr = _open_osfhandle((intptr_t) GetStdHandle(STD_ERROR_HANDLE), flags);
930 FILE *hfStdOut = (hCrtStdOut >= 0) ? _fdopen(hCrtStdOut, "wb") : NULL;
931 FILE *hfStdErr = (hCrtStdErr >= 0) ? _fdopen(hCrtStdErr, "wb") : NULL;
932 if(hfStdOut) { *stdout = *hfStdOut; std::cout.rdbuf(new std::filebuf(hfStdOut)); }
933 if(hfStdErr) { *stderr = *hfStdErr; std::cerr.rdbuf(new std::filebuf(hfStdErr)); }
934 }
935
936 HWND hwndConsole = GetConsoleWindow();
937
938 if((hwndConsole != NULL) && (hwndConsole != INVALID_HANDLE_VALUE))
939 {
940 HMENU hMenu = GetSystemMenu(hwndConsole, 0);
941 EnableMenuItem(hMenu, SC_CLOSE, MF_BYCOMMAND | MF_GRAYED);
942 RemoveMenu(hMenu, SC_CLOSE, MF_BYCOMMAND);
943
944 SetWindowPos(hwndConsole, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_FRAMECHANGED);
945 SetWindowLong(hwndConsole, GWL_STYLE, GetWindowLong(hwndConsole, GWL_STYLE) & (~WS_MAXIMIZEBOX) & (~WS_MINIMIZEBOX));
946 SetWindowPos(hwndConsole, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_FRAMECHANGED);
947 }
948 }
949 }
950
951 /*
952 * Detect CPU features
953 */
954 lamexp_cpu_t lamexp_detect_cpu_features(const QStringList &argv)
955 {
956 typedef BOOL (WINAPI *IsWow64ProcessFun)(__in HANDLE hProcess, __out PBOOL Wow64Process);
957
958 lamexp_cpu_t features;
959 SYSTEM_INFO systemInfo;
960 int CPUInfo[4] = {-1};
961 char CPUIdentificationString[0x40];
962 char CPUBrandString[0x40];
963
964 memset(&features, 0, sizeof(lamexp_cpu_t));
965 memset(&systemInfo, 0, sizeof(SYSTEM_INFO));
966 memset(CPUIdentificationString, 0, sizeof(CPUIdentificationString));
967 memset(CPUBrandString, 0, sizeof(CPUBrandString));
968
969 __cpuid(CPUInfo, 0);
970 memcpy(CPUIdentificationString, &CPUInfo[1], sizeof(int));
971 memcpy(CPUIdentificationString + 4, &CPUInfo[3], sizeof(int));
972 memcpy(CPUIdentificationString + 8, &CPUInfo[2], sizeof(int));
973 features.intel = (_stricmp(CPUIdentificationString, "GenuineIntel") == 0);
974 strncpy_s(features.vendor, 0x40, CPUIdentificationString, _TRUNCATE);
975
976 if(CPUInfo[0] >= 1)
977 {
978 __cpuid(CPUInfo, 1);
979 features.mmx = (CPUInfo[3] & 0x800000) || false;
980 features.sse = (CPUInfo[3] & 0x2000000) || false;
981 features.sse2 = (CPUInfo[3] & 0x4000000) || false;
982 features.ssse3 = (CPUInfo[2] & 0x200) || false;
983 features.sse3 = (CPUInfo[2] & 0x1) || false;
984 features.ssse3 = (CPUInfo[2] & 0x200) || false;
985 features.stepping = CPUInfo[0] & 0xf;
986 features.model = ((CPUInfo[0] >> 4) & 0xf) + (((CPUInfo[0] >> 16) & 0xf) << 4);
987 features.family = ((CPUInfo[0] >> 8) & 0xf) + ((CPUInfo[0] >> 20) & 0xff);
988 }
989
990 __cpuid(CPUInfo, 0x80000000);
991 int nExIds = qMax<int>(qMin<int>(CPUInfo[0], 0x80000004), 0x80000000);
992
993 for(int i = 0x80000002; i <= nExIds; ++i)
994 {
995 __cpuid(CPUInfo, i);
996 switch(i)
997 {
998 case 0x80000002:
999 memcpy(CPUBrandString, CPUInfo, sizeof(CPUInfo));
1000 break;
1001 case 0x80000003:
1002 memcpy(CPUBrandString + 16, CPUInfo, sizeof(CPUInfo));
1003 break;
1004 case 0x80000004:
1005 memcpy(CPUBrandString + 32, CPUInfo, sizeof(CPUInfo));
1006 break;
1007 }
1008 }
1009
1010 strncpy_s(features.brand, 0x40, CPUBrandString, _TRUNCATE);
1011
1012 if(strlen(features.brand) < 1) strncpy_s(features.brand, 0x40, "Unknown", _TRUNCATE);
1013 if(strlen(features.vendor) < 1) strncpy_s(features.vendor, 0x40, "Unknown", _TRUNCATE);
1014
1015 #if (!(defined(_M_X64) || defined(_M_IA64)))
1016 QLibrary Kernel32Lib("kernel32.dll");
1017 if(IsWow64ProcessFun IsWow64ProcessPtr = (IsWow64ProcessFun) Kernel32Lib.resolve("IsWow64Process"))
1018 {
1019 BOOL x64flag = FALSE;
1020 if(IsWow64ProcessPtr(GetCurrentProcess(), &x64flag))
1021 {
1022 features.x64 = (x64flag == TRUE);
1023 }
1024 }
1025 #else
1026 features.x64 = true;
1027 #endif
1028
1029 DWORD_PTR procAffinity, sysAffinity;
1030 if(GetProcessAffinityMask(GetCurrentProcess(), &procAffinity, &sysAffinity))
1031 {
1032 for(DWORD_PTR mask = 1; mask; mask <<= 1)
1033 {
1034 features.count += ((sysAffinity & mask) ? (1) : (0));
1035 }
1036 }
1037 if(features.count < 1)
1038 {
1039 GetNativeSystemInfo(&systemInfo);
1040 features.count = qBound(1UL, systemInfo.dwNumberOfProcessors, 64UL);
1041 }
1042
1043 if(argv.count() > 0)
1044 {
1045 bool flag = false;
1046 for(int i = 0; i < argv.count(); i++)
1047 {
1048 if(!argv[i].compare("--force-cpu-no-64bit", Qt::CaseInsensitive)) { flag = true; features.x64 = false; }
1049 if(!argv[i].compare("--force-cpu-no-sse", Qt::CaseInsensitive)) { flag = true; features.sse = features.sse2 = features.sse3 = features.ssse3 = false; }
1050 if(!argv[i].compare("--force-cpu-no-intel", Qt::CaseInsensitive)) { flag = true; features.intel = false; }
1051 }
1052 if(flag) qWarning("CPU flags overwritten by user-defined parameters. Take care!\n");
1053 }
1054
1055 return features;
1056 }
1057
1058 /*
1059 * Check for debugger (detect routine)
1060 */
1061 static __forceinline bool lamexp_check_for_debugger(void)
1062 {
1063 __try
1064 {
1065 CloseHandle((HANDLE)((DWORD_PTR)-3));
1066 }
1067 __except(1)
1068 {
1069 return true;
1070 }
1071 __try
1072 {
1073 __debugbreak();
1074 }
1075 __except(1)
1076 {
1077 return IsDebuggerPresent();
1078 }
1079 return true;
1080 }
1081
1082 /*
1083 * Check for debugger (thread proc)
1084 */
1085 static unsigned int __stdcall lamexp_debug_thread_proc(LPVOID lpParameter)
1086 {
1087 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_LOWEST);
1088 forever
1089 {
1090 if(lamexp_check_for_debugger())
1091 {
1092 lamexp_fatal_exit(L"Not a debug build. Please unload debugger and try again!");
1093 return 666;
1094 }
1095 lamexp_sleep(100);
1096 }
1097 }
1098
1099 /*
1100 * Check for debugger (startup routine)
1101 */
1102 static HANDLE lamexp_debug_thread_init()
1103 {
1104 if(lamexp_check_for_debugger())
1105 {
1106 lamexp_fatal_exit(L"Not a debug build. Please unload debugger and try again!");
1107 }
1108 const uintptr_t h = _beginthreadex(NULL, 0, lamexp_debug_thread_proc, NULL, 0, NULL);
1109 return (HANDLE)(h^0xdeadbeef);
1110 }
1111
1112 /*
1113 * Computus according to H. Lichtenberg
1114 */
1115 static bool lamexp_computus(const QDate &date)
1116 {
1117 int X = date.year();
1118 int A = X % 19;
1119 int K = X / 100;
1120 int M = 15 + (3*K + 3) / 4 - (8*K + 13) / 25;
1121 int D = (19*A + M) % 30;
1122 int S = 2 - (3*K + 3) / 4;
1123 int R = D / 29 + (D / 28 - D / 29) * (A / 11);
1124 int OG = 21 + D - R;
1125 int SZ = 7 - (X + X / 4 + S) % 7;
1126 int OE = 7 - (OG - SZ) % 7;
1127 int OS = (OG + OE);
1128
1129 if(OS > 31)
1130 {
1131 return (date.month() == 4) && (date.day() == (OS - 31));
1132 }
1133 else
1134 {
1135 return (date.month() == 3) && (date.day() == OS);
1136 }
1137 }
1138
1139 /*
1140 * Check for Thanksgiving
1141 */
1142 static bool lamexp_thanksgiving(const QDate &date)
1143 {
1144 int day = 0;
1145
1146 switch(QDate(date.year(), 11, 1).dayOfWeek())
1147 {
1148 case 1: day = 25; break;
1149 case 2: day = 24; break;
1150 case 3: day = 23; break;
1151 case 4: day = 22; break;
1152 case 5: day = 28; break;
1153 case 6: day = 27; break;
1154 case 7: day = 26; break;
1155 }
1156
1157 return (date.month() == 11) && (date.day() == day);
1158 }
1159
1160 /*
1161 * Initialize app icon
1162 */
1163 QIcon lamexp_app_icon(const QDate *date, const QTime *time)
1164 {
1165 QDate currentDate = (date) ? QDate(*date) : QDate::currentDate();
1166 QTime currentTime = (time) ? QTime(*time) : QTime::currentTime();
1167
1168 if(lamexp_thanksgiving(currentDate))
1169 {
1170 return QIcon(":/MainIcon6.png");
1171 }
1172 else if(((currentDate.month() == 12) && (currentDate.day() == 31) && (currentTime.hour() >= 20)) || ((currentDate.month() == 1) && (currentDate.day() == 1) && (currentTime.hour() <= 19)))
1173 {
1174 return QIcon(":/MainIcon5.png");
1175 }
1176 else if(((currentDate.month() == 10) && (currentDate.day() == 31) && (currentTime.hour() >= 12)) || ((currentDate.month() == 11) && (currentDate.day() == 1) && (currentTime.hour() <= 11)))
1177 {
1178 return QIcon(":/MainIcon4.png");
1179 }
1180 else if((currentDate.month() == 12) && (currentDate.day() >= 24) && (currentDate.day() <= 26))
1181 {
1182 return QIcon(":/MainIcon3.png");
1183 }
1184 else if(lamexp_computus(currentDate))
1185 {
1186 return QIcon(":/MainIcon2.png");
1187 }
1188 else
1189 {
1190 return QIcon(":/MainIcon1.png");
1191 }
1192 }
1193
1194 /*
1195 * Broadcast event to all windows
1196 */
1197 static bool lamexp_broadcast(int eventType, bool onlyToVisible)
1198 {
1199 if(QApplication *app = dynamic_cast<QApplication*>(QApplication::instance()))
1200 {
1201 qDebug("Broadcasting %d", eventType);
1202
1203 bool allOk = true;
1204 QEvent poEvent(static_cast<QEvent::Type>(eventType));
1205 QWidgetList list = app->topLevelWidgets();
1206
1207 while(!list.isEmpty())
1208 {
1209 QWidget *widget = list.takeFirst();
1210 if(!onlyToVisible || widget->isVisible())
1211 {
1212 if(!app->sendEvent(widget, &poEvent))
1213 {
1214 allOk = false;
1215 }
1216 }
1217 }
1218
1219 qDebug("Broadcast %d done (%s)", eventType, (allOk ? "OK" : "Stopped"));
1220 return allOk;
1221 }
1222 else
1223 {
1224 qWarning("Broadcast failed, could not get QApplication instance!");
1225 return false;
1226 }
1227 }
1228
1229 /*
1230 * Qt event filter
1231 */
1232 static bool lamexp_event_filter(void *message, long *result)
1233 {
1234 if((!(LAMEXP_DEBUG)) && lamexp_check_for_debugger())
1235 {
1236 lamexp_fatal_exit(L"Not a debug build. Please unload debugger and try again!");
1237 }
1238
1239 switch(reinterpret_cast<MSG*>(message)->message)
1240 {
1241 case WM_QUERYENDSESSION:
1242 qWarning("WM_QUERYENDSESSION message received!");
1243 *result = lamexp_broadcast(lamexp_event_queryendsession, false) ? TRUE : FALSE;
1244 return true;
1245 case WM_ENDSESSION:
1246 qWarning("WM_ENDSESSION message received!");
1247 if(reinterpret_cast<MSG*>(message)->wParam == TRUE)
1248 {
1249 lamexp_broadcast(lamexp_event_endsession, false);
1250 if(QApplication *app = reinterpret_cast<QApplication*>(QApplication::instance()))
1251 {
1252 app->closeAllWindows();
1253 app->quit();
1254 }
1255 lamexp_finalization();
1256 exit(1);
1257 }
1258 *result = 0;
1259 return true;
1260 default:
1261 /*ignore this message and let Qt handle it*/
1262 return false;
1263 }
1264 }
1265
1266 /*
1267 * Check for process elevation
1268 */
1269 static bool lamexp_check_elevation(void)
1270 {
1271 typedef enum { lamexp_token_elevationType_class = 18, lamexp_token_elevation_class = 20 } LAMEXP_TOKEN_INFORMATION_CLASS;
1272 typedef enum { lamexp_elevationType_default = 1, lamexp_elevationType_full, lamexp_elevationType_limited } LAMEXP_TOKEN_ELEVATION_TYPE;
1273
1274 HANDLE hToken = NULL;
1275 bool bIsProcessElevated = false;
1276
1277 if(OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
1278 {
1279 LAMEXP_TOKEN_ELEVATION_TYPE tokenElevationType;
1280 DWORD returnLength;
1281 if(GetTokenInformation(hToken, (TOKEN_INFORMATION_CLASS) lamexp_token_elevationType_class, &tokenElevationType, sizeof(LAMEXP_TOKEN_ELEVATION_TYPE), &returnLength))
1282 {
1283 if(returnLength == sizeof(LAMEXP_TOKEN_ELEVATION_TYPE))
1284 {
1285 switch(tokenElevationType)
1286 {
1287 case lamexp_elevationType_default:
1288 qDebug("Process token elevation type: Default -> UAC is disabled.\n");
1289 break;
1290 case lamexp_elevationType_full:
1291 qWarning("Process token elevation type: Full -> potential security risk!\n");
1292 bIsProcessElevated = true;
1293 break;
1294 case lamexp_elevationType_limited:
1295 qDebug("Process token elevation type: Limited -> not elevated.\n");
1296 break;
1297 }
1298 }
1299 }
1300 CloseHandle(hToken);
1301 }
1302 else
1303 {
1304 qWarning("Failed to open process token!");
1305 }
1306
1307 return !bIsProcessElevated;
1308 }
1309
1310 /*
1311 * Initialize Qt framework
1312 */
1313 bool lamexp_init_qt(int argc, char* argv[])
1314 {
1315 static bool qt_initialized = false;
1316 typedef BOOL (WINAPI *SetDllDirectoryProc)(WCHAR *lpPathName);
1317 const QStringList &arguments = lamexp_arguments();
1318
1319 //Don't initialized again, if done already
1320 if(qt_initialized)
1321 {
1322 return true;
1323 }
1324
1325 //Secure DLL loading
1326 QLibrary kernel32("kernel32.dll");
1327 if(kernel32.load())
1328 {
1329 SetDllDirectoryProc pSetDllDirectory = (SetDllDirectoryProc) kernel32.resolve("SetDllDirectoryW");
1330 if(pSetDllDirectory != NULL) pSetDllDirectory(L"");
1331 }
1332
1333 //Extract executable name from argv[] array
1334 QString executableName = QLatin1String("LameXP.exe");
1335 if(arguments.count() > 0)
1336 {
1337 static const char *delimiters = "\\/:?";
1338 executableName = arguments[0].trimmed();
1339 for(int i = 0; delimiters[i]; i++)
1340 {
1341 int temp = executableName.lastIndexOf(QChar(delimiters[i]));
1342 if(temp >= 0) executableName = executableName.mid(temp + 1);
1343 }
1344 executableName = executableName.trimmed();
1345 if(executableName.isEmpty())
1346 {
1347 executableName = QLatin1String("LameXP.exe");
1348 }
1349 }
1350
1351 //Check Qt version
1352 #ifdef QT_BUILD_KEY
1353 qDebug("Using Qt v%s [%s], %s, %s", qVersion(), QLibraryInfo::buildDate().toString(Qt::ISODate).toLatin1().constData(), (qSharedBuild() ? "DLL" : "Static"), QLibraryInfo::buildKey().toLatin1().constData());
1354 qDebug("Compiled with Qt v%s [%s], %s\n", QT_VERSION_STR, QT_PACKAGEDATE_STR, QT_BUILD_KEY);
1355 if(_stricmp(qVersion(), QT_VERSION_STR))
1356 {
1357 qFatal("%s", QApplication::tr("Executable '%1' requires Qt v%2, but found Qt v%3.").arg(executableName, QString::fromLatin1(QT_VERSION_STR), QString::fromLatin1(qVersion())).toLatin1().constData());
1358 return false;
1359 }
1360 if(QLibraryInfo::buildKey().compare(QString::fromLatin1(QT_BUILD_KEY), Qt::CaseInsensitive))
1361 {
1362 qFatal("%s", QApplication::tr("Executable '%1' was built for Qt '%2', but found Qt '%3'.").arg(executableName, QString::fromLatin1(QT_BUILD_KEY), QLibraryInfo::buildKey()).toLatin1().constData());
1363 return false;
1364 }
1365 #else
1366 qDebug("Using Qt v%s [%s], %s", qVersion(), QLibraryInfo::buildDate().toString(Qt::ISODate).toLatin1().constData(), (qSharedBuild() ? "DLL" : "Static"));
1367 qDebug("Compiled with Qt v%s [%s]\n", QT_VERSION_STR, QT_PACKAGEDATE_STR);
1368 #endif
1369
1370 //Check the Windows version
1371 const lamexp_os_version_t &osVersionNo = lamexp_get_os_version();
1372 if(osVersionNo < lamexp_winver_winxp)
1373 {
1374 qFatal("%s", QApplication::tr("Executable '%1' requires Windows XP or later.").arg(executableName).toLatin1().constData());
1375 }
1376
1377 //Supported Windows version?
1378 if(osVersionNo == lamexp_winver_winxp)
1379 {
1380 qDebug("Running on Windows XP or Windows XP Media Center Edition.\n"); //lamexp_check_compatibility_mode("GetLargePageMinimum", executableName);
1381 }
1382 else if(osVersionNo == lamexp_winver_xpx64)
1383 {
1384 qDebug("Running on Windows Server 2003, Windows Server 2003 R2 or Windows XP x64.\n"); //lamexp_check_compatibility_mode("GetLocaleInfoEx", executableName);
1385 }
1386 else if(osVersionNo == lamexp_winver_vista)
1387 {
1388 qDebug("Running on Windows Vista or Windows Server 2008.\n"); //lamexp_check_compatibility_mode("CreateRemoteThreadEx", executableName*/);
1389 }
1390 else if(osVersionNo == lamexp_winver_win70)
1391 {
1392 qDebug("Running on Windows 7 or Windows Server 2008 R2.\n"); //lamexp_check_compatibility_mode("CreateFile2", executableName);
1393 }
1394 else if(osVersionNo == lamexp_winver_win80)
1395 {
1396 qDebug("Running on Windows 8 or Windows Server 2012.\n"); //lamexp_check_compatibility_mode("FindPackagesByPackageFamily", executableName);
1397 }
1398 else if(osVersionNo == lamexp_winver_win81)
1399 {
1400 qDebug("Running on Windows 8.1 or Windows Server 2012 R2.\n"); //lamexp_check_compatibility_mode(NULL, executableName);
1401 }
1402 else
1403 {
1404 const QString message = QString().sprintf("Running on an unknown WindowsNT-based system (v%u.%u).", osVersionNo.versionMajor, osVersionNo.versionMinor);
1405 qWarning("%s\n", QUTF8(message));
1406 MessageBoxW(NULL, QWCHAR(message), L"LameXP", MB_OK | MB_TOPMOST | MB_ICONWARNING);
1407 }
1408
1409 //Check for compat mode
1410 if(osVersionNo.overrideFlag && (osVersionNo <= lamexp_winver_win81))
1411 {
1412 qWarning("Windows compatibility mode detected!");
1413 if(!arguments.contains("--ignore-compat-mode", Qt::CaseInsensitive))
1414 {
1415 qFatal("%s", QApplication::tr("Executable '%1' doesn't support Windows compatibility mode.").arg(executableName).toLatin1().constData());
1416 return false;
1417 }
1418 }
1419
1420 //Check for Wine
1421 if(lamexp_detect_wine())
1422 {
1423 qWarning("It appears we are running under Wine, unexpected things might happen!\n");
1424 }
1425
1426 //Set text Codec for locale
1427 QTextCodec::setCodecForLocale(QTextCodec::codecForName("UTF-8"));
1428
1429 //Create Qt application instance
1430 QApplication *application = new QApplication(argc, argv);
1431
1432 //Load plugins from application directory
1433 QCoreApplication::setLibraryPaths(QStringList() << QApplication::applicationDirPath());
1434 qDebug("Library Path:\n%s\n", QUTF8(QApplication::libraryPaths().first()));
1435
1436 //Set application properties
1437 application->setApplicationName("LameXP - Audio Encoder Front-End");
1438 application->setApplicationVersion(QString().sprintf("%d.%02d.%04d", lamexp_version_major(), lamexp_version_minor(), lamexp_version_build()));
1439 application->setOrganizationName("LoRd_MuldeR");
1440 application->setOrganizationDomain("mulder.at.gg");
1441 application->setWindowIcon(lamexp_app_icon());
1442 application->setEventFilter(lamexp_event_filter);
1443
1444 //Check for supported image formats
1445 QList<QByteArray> supportedFormats = QImageReader::supportedImageFormats();
1446 for(int i = 0; g_lamexp_imageformats[i]; i++)
1447 {
1448 if(!supportedFormats.contains(g_lamexp_imageformats[i]))
1449 {
1450 qFatal("Qt initialization error: QImageIOHandler for '%s' missing!", g_lamexp_imageformats[i]);
1451 return false;
1452 }
1453 }
1454
1455 //Add default translations
1456 QWriteLocker writeLockTranslations(&g_lamexp_translation.lock);
1457 if(!g_lamexp_translation.files) g_lamexp_translation.files = new QMap<QString, QString>();
1458 if(!g_lamexp_translation.names) g_lamexp_translation.names = new QMap<QString, QString>();
1459 g_lamexp_translation.files->insert(LAMEXP_DEFAULT_LANGID, "");
1460 g_lamexp_translation.names->insert(LAMEXP_DEFAULT_LANGID, "English");
1461 writeLockTranslations.unlock();
1462
1463 //Check for process elevation
1464 if((!lamexp_check_elevation()) && (!lamexp_detect_wine()))
1465 {
1466 QMessageBox messageBox(QMessageBox::Warning, "LameXP", "<nobr>LameXP was started with 'elevated' rights, altough LameXP does not need these rights.<br>Running an applications with unnecessary rights is a potential security risk!</nobr>", QMessageBox::NoButton, NULL, Qt::Dialog | Qt::MSWindowsFixedSizeDialogHint | Qt::WindowStaysOnTopHint);
1467 messageBox.addButton("Quit Program (Recommended)", QMessageBox::NoRole);
1468 messageBox.addButton("Ignore", QMessageBox::NoRole);
1469 if(messageBox.exec() == 0)
1470 {
1471 return false;
1472 }
1473 }
1474
1475 //Update console icon, if a console is attached
1476 #if QT_VERSION < QT_VERSION_CHECK(5,0,0)
1477 if(g_lamexp_console_attached && (!lamexp_detect_wine()))
1478 {
1479 typedef DWORD (__stdcall *SetConsoleIconFun)(HICON);
1480 QLibrary kernel32("kernel32.dll");
1481 if(kernel32.load())
1482 {
1483 SetConsoleIconFun SetConsoleIconPtr = (SetConsoleIconFun) kernel32.resolve("SetConsoleIcon");
1484 if(SetConsoleIconPtr != NULL) SetConsoleIconPtr(QIcon(":/icons/sound.png").pixmap(16, 16).toWinHICON());
1485 kernel32.unload();
1486 }
1487 }
1488 #endif
1489
1490 //Done
1491 qt_initialized = true;
1492 return true;
1493 }
1494
1495 /*
1496 * Initialize IPC
1497 */
1498 int lamexp_init_ipc(void)
1499 {
1500 QWriteLocker writeLock(&g_lamexp_ipc_ptr.lock);
1501
1502 if(g_lamexp_ipc_ptr.sharedmem && g_lamexp_ipc_ptr.semaphore_read && g_lamexp_ipc_ptr.semaphore_write && g_lamexp_ipc_ptr.semaphore_read_mutex && g_lamexp_ipc_ptr.semaphore_write_mutex)
1503 {
1504 return 0;
1505 }
1506
1507 g_lamexp_ipc_ptr.semaphore_read = new QSystemSemaphore(QString(g_lamexp_ipc_uuid.semaphore_read), 0);
1508 g_lamexp_ipc_ptr.semaphore_write = new QSystemSemaphore(QString(g_lamexp_ipc_uuid.semaphore_write), 0);
1509 g_lamexp_ipc_ptr.semaphore_read_mutex = new QSystemSemaphore(QString(g_lamexp_ipc_uuid.semaphore_read_mutex), 0);
1510 g_lamexp_ipc_ptr.semaphore_write_mutex = new QSystemSemaphore(QString(g_lamexp_ipc_uuid.semaphore_write_mutex), 0);
1511
1512 if(g_lamexp_ipc_ptr.semaphore_read->error() != QSystemSemaphore::NoError)
1513 {
1514 QString errorMessage = g_lamexp_ipc_ptr.semaphore_read->errorString();
1515 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_read);
1516 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_write);
1517 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_read_mutex);
1518 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_write_mutex);
1519 qFatal("Failed to create system smaphore: %s", QUTF8(errorMessage));
1520 return -1;
1521 }
1522 if(g_lamexp_ipc_ptr.semaphore_write->error() != QSystemSemaphore::NoError)
1523 {
1524 QString errorMessage = g_lamexp_ipc_ptr.semaphore_write->errorString();
1525 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_read);
1526 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_write);
1527 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_read_mutex);
1528 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_write_mutex);
1529 qFatal("Failed to create system smaphore: %s", QUTF8(errorMessage));
1530 return -1;
1531 }
1532 if(g_lamexp_ipc_ptr.semaphore_read_mutex->error() != QSystemSemaphore::NoError)
1533 {
1534 QString errorMessage = g_lamexp_ipc_ptr.semaphore_read_mutex->errorString();
1535 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_read);
1536 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_write);
1537 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_read_mutex);
1538 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_write_mutex);
1539 qFatal("Failed to create system smaphore: %s", QUTF8(errorMessage));
1540 return -1;
1541 }
1542 if(g_lamexp_ipc_ptr.semaphore_write_mutex->error() != QSystemSemaphore::NoError)
1543 {
1544 QString errorMessage = g_lamexp_ipc_ptr.semaphore_write_mutex->errorString();
1545 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_read);
1546 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_write);
1547 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_read_mutex);
1548 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_write_mutex);
1549 qFatal("Failed to create system smaphore: %s", QUTF8(errorMessage));
1550 return -1;
1551 }
1552
1553 g_lamexp_ipc_ptr.sharedmem = new QSharedMemory(QString(g_lamexp_ipc_uuid.sharedmem), NULL);
1554
1555 if(!g_lamexp_ipc_ptr.sharedmem->create(sizeof(lamexp_ipc_t)))
1556 {
1557 if(g_lamexp_ipc_ptr.sharedmem->error() == QSharedMemory::AlreadyExists)
1558 {
1559 g_lamexp_ipc_ptr.sharedmem->attach();
1560 if(g_lamexp_ipc_ptr.sharedmem->error() == QSharedMemory::NoError)
1561 {
1562 return 1;
1563 }
1564 else
1565 {
1566 QString errorMessage = g_lamexp_ipc_ptr.sharedmem->errorString();
1567 LAMEXP_DELETE(g_lamexp_ipc_ptr.sharedmem);
1568 qFatal("Failed to attach to shared memory: %s", QUTF8(errorMessage));
1569 return -1;
1570 }
1571 }
1572 else
1573 {
1574 QString errorMessage = g_lamexp_ipc_ptr.sharedmem->errorString();
1575 LAMEXP_DELETE(g_lamexp_ipc_ptr.sharedmem);
1576 qFatal("Failed to create shared memory: %s", QUTF8(errorMessage));
1577 return -1;
1578 }
1579 }
1580
1581 memset(g_lamexp_ipc_ptr.sharedmem->data(), 0, sizeof(lamexp_ipc_t));
1582 g_lamexp_ipc_ptr.semaphore_write->release(g_lamexp_ipc_slots);
1583 g_lamexp_ipc_ptr.semaphore_read_mutex->release();
1584 g_lamexp_ipc_ptr.semaphore_write_mutex->release();
1585
1586 return 0;
1587 }
1588
1589 /*
1590 * IPC send message
1591 */
1592 void lamexp_ipc_send(unsigned int command, const char* message)
1593 {
1594 QReadLocker readLock(&g_lamexp_ipc_ptr.lock);
1595
1596 if(!g_lamexp_ipc_ptr.sharedmem || !g_lamexp_ipc_ptr.semaphore_read || !g_lamexp_ipc_ptr.semaphore_write || !g_lamexp_ipc_ptr.semaphore_read_mutex || !g_lamexp_ipc_ptr.semaphore_write_mutex)
1597 {
1598 THROW("Shared memory for IPC not initialized yet.");
1599 }
1600
1601 lamexp_ipc_data_t ipc_data;
1602 memset(&ipc_data, 0, sizeof(lamexp_ipc_data_t));
1603 ipc_data.command = command;
1604
1605 if(message)
1606 {
1607 strncpy_s(ipc_data.parameter, 4096, message, _TRUNCATE);
1608 }
1609
1610 if(g_lamexp_ipc_ptr.semaphore_write->acquire())
1611 {
1612 if(g_lamexp_ipc_ptr.semaphore_write_mutex->acquire())
1613 {
1614 lamexp_ipc_t *ptr = reinterpret_cast<lamexp_ipc_t*>(g_lamexp_ipc_ptr.sharedmem->data());
1615 memcpy(&ptr->data[ptr->pos_write], &ipc_data, sizeof(lamexp_ipc_data_t));
1616 ptr->pos_write = (ptr->pos_write + 1) % g_lamexp_ipc_slots;
1617 g_lamexp_ipc_ptr.semaphore_read->release();
1618 g_lamexp_ipc_ptr.semaphore_write_mutex->release();
1619 }
1620 }
1621 }
1622
1623 /*
1624 * IPC read message
1625 */
1626 void lamexp_ipc_read(unsigned int *command, char* message, size_t buffSize)
1627 {
1628 QReadLocker readLock(&g_lamexp_ipc_ptr.lock);
1629
1630 *command = 0;
1631 message[0] = '\0';
1632
1633 if(!g_lamexp_ipc_ptr.sharedmem || !g_lamexp_ipc_ptr.semaphore_read || !g_lamexp_ipc_ptr.semaphore_write || !g_lamexp_ipc_ptr.semaphore_read_mutex || !g_lamexp_ipc_ptr.semaphore_write_mutex)
1634 {
1635 THROW("Shared memory for IPC not initialized yet.");
1636 }
1637
1638 lamexp_ipc_data_t ipc_data;
1639 memset(&ipc_data, 0, sizeof(lamexp_ipc_data_t));
1640
1641 if(g_lamexp_ipc_ptr.semaphore_read->acquire())
1642 {
1643 if(g_lamexp_ipc_ptr.semaphore_read_mutex->acquire())
1644 {
1645 lamexp_ipc_t *ptr = reinterpret_cast<lamexp_ipc_t*>(g_lamexp_ipc_ptr.sharedmem->data());
1646 memcpy(&ipc_data, &ptr->data[ptr->pos_read], sizeof(lamexp_ipc_data_t));
1647 ptr->pos_read = (ptr->pos_read + 1) % g_lamexp_ipc_slots;
1648 g_lamexp_ipc_ptr.semaphore_write->release();
1649 g_lamexp_ipc_ptr.semaphore_read_mutex->release();
1650
1651 if(!(ipc_data.reserved_1 || ipc_data.reserved_2))
1652 {
1653 *command = ipc_data.command;
1654 strncpy_s(message, buffSize, ipc_data.parameter, _TRUNCATE);
1655 }
1656 else
1657 {
1658 qWarning("Malformed IPC message, will be ignored");
1659 }
1660 }
1661 }
1662 }
1663
1664 /*
1665 * Check for LameXP "portable" mode
1666 */
1667 bool lamexp_portable_mode(void)
1668 {
1669 QReadLocker readLock(&g_lamexp_portable.lock);
1670
1671 if(g_lamexp_portable.bInitialized)
1672 {
1673 return g_lamexp_portable.bPortableModeEnabled;
1674 }
1675
1676 readLock.unlock();
1677 QWriteLocker writeLock(&g_lamexp_portable.lock);
1678
1679 if(!g_lamexp_portable.bInitialized)
1680 {
1681 if(VER_LAMEXP_PORTABLE_EDITION)
1682 {
1683 qWarning("LameXP portable edition!\n");
1684 g_lamexp_portable.bPortableModeEnabled = true;
1685 }
1686 else
1687 {
1688 QString baseName = QFileInfo(QApplication::applicationFilePath()).completeBaseName();
1689 int idx1 = baseName.indexOf("lamexp", 0, Qt::CaseInsensitive);
1690 int idx2 = baseName.lastIndexOf("portable", -1, Qt::CaseInsensitive);
1691 g_lamexp_portable.bPortableModeEnabled = (idx1 >= 0) && (idx2 >= 0) && (idx1 < idx2);
1692 }
1693 g_lamexp_portable.bInitialized = true;
1694 }
1695
1696 return g_lamexp_portable.bPortableModeEnabled;
1697 }
1698
1699 /*
1700 * Get a random string
1701 */
1702 QString lamexp_rand_str(const bool bLong)
1703 {
1704 const QUuid uuid = QUuid::createUuid().toString();
1705
1706 const unsigned int u1 = uuid.data1;
1707 const unsigned int u2 = (((unsigned int)(uuid.data2)) << 16) | ((unsigned int)(uuid.data3));
1708 const unsigned int u3 = (((unsigned int)(uuid.data4[0])) << 24) | (((unsigned int)(uuid.data4[1])) << 16) | (((unsigned int)(uuid.data4[2])) << 8) | ((unsigned int)(uuid.data4[3]));
1709 const unsigned int u4 = (((unsigned int)(uuid.data4[4])) << 24) | (((unsigned int)(uuid.data4[5])) << 16) | (((unsigned int)(uuid.data4[6])) << 8) | ((unsigned int)(uuid.data4[7]));
1710
1711 return bLong ? QString().sprintf("%08x%08x%08x%08x", u1, u2, u3, u4) : QString().sprintf("%08x%08x", (u1 ^ u2), (u3 ^ u4));
1712 }
1713
1714
1715 /*
1716 * Try to initialize the folder (with *write* access)
1717 */
1718 static QString lamexp_try_init_folder(const QString &folderPath)
1719 {
1720 bool success = false;
1721
1722 const QFileInfo folderInfo(folderPath);
1723 const QDir folderDir(folderInfo.absoluteFilePath());
1724
1725 //Create folder, if it does *not* exist yet
1726 if(!folderDir.exists())
1727 {
1728 folderDir.mkpath(".");
1729 }
1730
1731 //Make sure folder exists now *and* is writable
1732 if(folderDir.exists())
1733 {
1734 QFile testFile(folderDir.absoluteFilePath(QString("~%1.tmp").arg(lamexp_rand_str())));
1735 if(testFile.open(QIODevice::ReadWrite))
1736 {
1737 const QByteArray testData = QByteArray("Lorem ipsum dolor sit amet, consectetur, adipisci velit!");
1738 if(testFile.write(testData) >= strlen(testData))
1739 {
1740 success = true;
1741 testFile.remove();
1742 }
1743 testFile.close();
1744 }
1745 }
1746
1747 return (success ? folderDir.canonicalPath() : QString());
1748 }
1749
1750 /*
1751 * Initialize LameXP temp folder
1752 */
1753 #define INIT_TEMP_FOLDER(OUT,TMP) do \
1754 { \
1755 (OUT) = lamexp_try_init_folder(QString("%1/%2").arg((TMP), lamexp_rand_str())); \
1756 } \
1757 while(0)
1758
1759 /*
1760 * Get LameXP temp folder
1761 */
1762 const QString &lamexp_temp_folder2(void)
1763 {
1764 QReadLocker readLock(&g_lamexp_temp_folder.lock);
1765
1766 //Already initialized?
1767 if(g_lamexp_temp_folder.path && (!g_lamexp_temp_folder.path->isEmpty()))
1768 {
1769 if(QDir(*g_lamexp_temp_folder.path).exists())
1770 {
1771 return *g_lamexp_temp_folder.path;
1772 }
1773 }
1774
1775 //Obtain the write lock to initilaize
1776 readLock.unlock();
1777 QWriteLocker writeLock(&g_lamexp_temp_folder.lock);
1778
1779 //Still uninitilaized?
1780 if(g_lamexp_temp_folder.path && (!g_lamexp_temp_folder.path->isEmpty()))
1781 {
1782 if(QDir(*g_lamexp_temp_folder.path).exists())
1783 {
1784 return *g_lamexp_temp_folder.path;
1785 }
1786 }
1787
1788 //Create the string, if not done yet
1789 if(!g_lamexp_temp_folder.path)
1790 {
1791 g_lamexp_temp_folder.path = new QString();
1792 }
1793
1794 g_lamexp_temp_folder.path->clear();
1795
1796 //Try the %TMP% or %TEMP% directory first
1797 QString tempPath = lamexp_try_init_folder(QDir::temp().absolutePath());
1798 if(!tempPath.isEmpty())
1799 {
1800 INIT_TEMP_FOLDER(*g_lamexp_temp_folder.path, tempPath);
1801 }
1802
1803 //Otherwise create TEMP folder in %LOCALAPPDATA%
1804 if(g_lamexp_temp_folder.path->isEmpty())
1805 {
1806 tempPath = lamexp_try_init_folder(QString("%1/Temp").arg(lamexp_known_folder(lamexp_folder_localappdata)));
1807 if(!tempPath.isEmpty())
1808 {
1809 INIT_TEMP_FOLDER(*g_lamexp_temp_folder.path, tempPath);
1810 }
1811 }
1812
1813 //Failed to create TEMP folder?
1814 if(g_lamexp_temp_folder.path->isEmpty())
1815 {
1816 qFatal("Temporary directory could not be initialized !!!");
1817 }
1818
1819 return *g_lamexp_temp_folder.path;
1820 }
1821
1822 /*
1823 * Clean folder
1824 */
1825 bool lamexp_clean_folder(const QString &folderPath)
1826 {
1827 QDir tempFolder(folderPath);
1828 if(tempFolder.exists())
1829 {
1830 QFileInfoList entryList = tempFolder.entryInfoList(QDir::AllEntries | QDir::NoDotAndDotDot);
1831
1832 for(int i = 0; i < entryList.count(); i++)
1833 {
1834 if(entryList.at(i).isDir())
1835 {
1836 lamexp_clean_folder(entryList.at(i).canonicalFilePath());
1837 }
1838 else
1839 {
1840 for(int j = 0; j < 3; j++)
1841 {
1842 if(lamexp_remove_file(entryList.at(i).canonicalFilePath()))
1843 {
1844 break;
1845 }
1846 }
1847 }
1848 }
1849 return tempFolder.rmdir(".");
1850 }
1851 return true;
1852 }
1853
1854 /*
1855 * Register tool
1856 */
1857 void lamexp_register_tool(const QString &toolName, LockedFile *file, unsigned int version, const QString *tag)
1858 {
1859 QWriteLocker writeLock(&g_lamexp_tools.lock);
1860
1861 if(!g_lamexp_tools.registry) g_lamexp_tools.registry = new QMap<QString, LockedFile*>();
1862 if(!g_lamexp_tools.versions) g_lamexp_tools.versions = new QMap<QString, unsigned int>();
1863 if(!g_lamexp_tools.tags) g_lamexp_tools.tags = new QMap<QString, QString>();
1864
1865 if(g_lamexp_tools.registry->contains(toolName.toLower()))
1866 {
1867 THROW("lamexp_register_tool: Tool is already registered!");
1868 }
1869
1870 g_lamexp_tools.registry->insert(toolName.toLower(), file);
1871 g_lamexp_tools.versions->insert(toolName.toLower(), version);
1872 g_lamexp_tools.tags->insert(toolName.toLower(), (tag) ? (*tag) : QString());
1873 }
1874
1875 /*
1876 * Check for tool
1877 */
1878 bool lamexp_check_tool(const QString &toolName)
1879 {
1880 QReadLocker readLock(&g_lamexp_tools.lock);
1881 return (g_lamexp_tools.registry) ? g_lamexp_tools.registry->contains(toolName.toLower()) : false;
1882 }
1883
1884 /*
1885 * Lookup tool path
1886 */
1887 const QString lamexp_lookup_tool(const QString &toolName)
1888 {
1889 QReadLocker readLock(&g_lamexp_tools.lock);
1890
1891 if(g_lamexp_tools.registry)
1892 {
1893 if(g_lamexp_tools.registry->contains(toolName.toLower()))
1894 {
1895 return g_lamexp_tools.registry->value(toolName.toLower())->filePath();
1896 }
1897 else
1898 {
1899 return QString();
1900 }
1901 }
1902 else
1903 {
1904 return QString();
1905 }
1906 }
1907
1908 /*
1909 * Lookup tool version
1910 */
1911 unsigned int lamexp_tool_version(const QString &toolName, QString *tag)
1912 {
1913 QReadLocker readLock(&g_lamexp_tools.lock);
1914 if(tag) tag->clear();
1915
1916 if(g_lamexp_tools.versions)
1917 {
1918 if(g_lamexp_tools.versions->contains(toolName.toLower()))
1919 {
1920 if(tag)
1921 {
1922 if(g_lamexp_tools.tags->contains(toolName.toLower())) *tag = g_lamexp_tools.tags->value(toolName.toLower());
1923 }
1924 return g_lamexp_tools.versions->value(toolName.toLower());
1925 }
1926 else
1927 {
1928 return UINT_MAX;
1929 }
1930 }
1931 else
1932 {
1933 return UINT_MAX;
1934 }
1935 }
1936
1937 /*
1938 * Version number to human-readable string
1939 */
1940 const QString lamexp_version2string(const QString &pattern, unsigned int version, const QString &defaultText, const QString *tag)
1941 {
1942 if(version == UINT_MAX)
1943 {
1944 return defaultText;
1945 }
1946
1947 QString result = pattern;
1948 int digits = result.count("?", Qt::CaseInsensitive);
1949
1950 if(digits < 1)
1951 {
1952 return result;
1953 }
1954
1955 int pos = 0;
1956 QString versionStr = QString().sprintf(QString().sprintf("%%0%du", digits).toLatin1().constData(), version);
1957 int index = result.indexOf("?", Qt::CaseInsensitive);
1958
1959 while(index >= 0 && pos < versionStr.length())
1960 {
1961 result[index] = versionStr[pos++];
1962 index = result.indexOf("?", Qt::CaseInsensitive);
1963 }
1964
1965 if(tag)
1966 {
1967 result.replace(QChar('#'), *tag, Qt::CaseInsensitive);
1968 }
1969
1970 return result;
1971 }
1972
1973 /*
1974 * Register a new translation
1975 */
1976 bool lamexp_translation_register(const QString &langId, const QString &qmFile, const QString &langName, unsigned int &systemId, unsigned int &country)
1977 {
1978 QWriteLocker writeLockTranslations(&g_lamexp_translation.lock);
1979
1980 if(qmFile.isEmpty() || langName.isEmpty() || systemId < 1)
1981 {
1982 return false;
1983 }
1984
1985 if(!g_lamexp_translation.files) g_lamexp_translation.files = new QMap<QString, QString>();
1986 if(!g_lamexp_translation.names) g_lamexp_translation.names = new QMap<QString, QString>();
1987 if(!g_lamexp_translation.sysid) g_lamexp_translation.sysid = new QMap<QString, unsigned int>();
1988 if(!g_lamexp_translation.cntry) g_lamexp_translation.cntry = new QMap<QString, unsigned int>();
1989
1990 g_lamexp_translation.files->insert(langId, qmFile);
1991 g_lamexp_translation.names->insert(langId, langName);
1992 g_lamexp_translation.sysid->insert(langId, systemId);
1993 g_lamexp_translation.cntry->insert(langId, country);
1994
1995 return true;
1996 }
1997
1998 /*
1999 * Get list of all translations
2000 */
2001 QStringList lamexp_query_translations(void)
2002 {
2003 QReadLocker readLockTranslations(&g_lamexp_translation.lock);
2004 return (g_lamexp_translation.files) ? g_lamexp_translation.files->keys() : QStringList();
2005 }
2006
2007 /*
2008 * Get translation name
2009 */
2010 QString lamexp_translation_name(const QString &langId)
2011 {
2012 QReadLocker readLockTranslations(&g_lamexp_translation.lock);
2013 return (g_lamexp_translation.names) ? g_lamexp_translation.names->value(langId.toLower(), QString()) : QString();
2014 }
2015
2016 /*
2017 * Get translation system id
2018 */
2019 unsigned int lamexp_translation_sysid(const QString &langId)
2020 {
2021 QReadLocker readLockTranslations(&g_lamexp_translation.lock);
2022 return (g_lamexp_translation.sysid) ? g_lamexp_translation.sysid->value(langId.toLower(), 0) : 0;
2023 }
2024
2025 /*
2026 * Get translation script id
2027 */
2028 unsigned int lamexp_translation_country(const QString &langId)
2029 {
2030 QReadLocker readLockTranslations(&g_lamexp_translation.lock);
2031 return (g_lamexp_translation.cntry) ? g_lamexp_translation.cntry->value(langId.toLower(), 0) : 0;
2032 }
2033
2034 /*
2035 * Install a new translator
2036 */
2037 bool lamexp_install_translator(const QString &langId)
2038 {
2039 bool success = false;
2040 const QString qmFileToPath(":/localization/%1");
2041
2042 if(langId.isEmpty() || langId.toLower().compare(LAMEXP_DEFAULT_LANGID) == 0)
2043 {
2044 success = lamexp_install_translator_from_file(qmFileToPath.arg(LAMEXP_DEFAULT_TRANSLATION));
2045 }
2046 else
2047 {
2048 QReadLocker readLock(&g_lamexp_translation.lock);
2049 QString qmFile = (g_lamexp_translation.files) ? g_lamexp_translation.files->value(langId.toLower(), QString()) : QString();
2050 readLock.unlock();
2051
2052 if(!qmFile.isEmpty())
2053 {
2054 success = lamexp_install_translator_from_file(qmFileToPath.arg(qmFile));
2055 }
2056 else
2057 {
2058 qWarning("Translation '%s' not available!", langId.toLatin1().constData());
2059 }
2060 }
2061
2062 return success;
2063 }
2064
2065 /*
2066 * Install a new translator from file
2067 */
2068 bool lamexp_install_translator_from_file(const QString &qmFile)
2069 {
2070 QWriteLocker writeLock(&g_lamexp_currentTranslator.lock);
2071 bool success = false;
2072
2073 if(!g_lamexp_currentTranslator.instance)
2074 {
2075 g_lamexp_currentTranslator.instance = new QTranslator();
2076 }
2077
2078 if(!qmFile.isEmpty())
2079 {
2080 QString qmPath = QFileInfo(qmFile).canonicalFilePath();
2081 QApplication::removeTranslator(g_lamexp_currentTranslator.instance);
2082 if(success = g_lamexp_currentTranslator.instance->load(qmPath))
2083 {
2084 QApplication::installTranslator(g_lamexp_currentTranslator.instance);
2085 }
2086 else
2087 {
2088 qWarning("Failed to load translation:\n\"%s\"", qmPath.toLatin1().constData());
2089 }
2090 }
2091 else
2092 {
2093 QApplication::removeTranslator(g_lamexp_currentTranslator.instance);
2094 success = true;
2095 }
2096
2097 return success;
2098 }
2099
2100 const QStringList &lamexp_arguments(void)
2101 {
2102 QReadLocker readLock(&g_lamexp_argv.lock);
2103
2104 if(!g_lamexp_argv.list)
2105 {
2106 readLock.unlock();
2107 QWriteLocker writeLock(&g_lamexp_argv.lock);
2108
2109 g_lamexp_argv.list = new QStringList;
2110
2111 int nArgs = 0;
2112 LPWSTR *szArglist = CommandLineToArgvW(GetCommandLineW(), &nArgs);
2113
2114 if(NULL != szArglist)
2115 {
2116 for(int i = 0; i < nArgs; i++)
2117 {
2118 (*g_lamexp_argv.list) << WCHAR2QSTR(szArglist[i]);
2119 }
2120 LocalFree(szArglist);
2121 }
2122 else
2123 {
2124 qWarning("CommandLineToArgvW() has failed !!!");
2125 }
2126 }
2127
2128 return (*g_lamexp_argv.list);
2129 }
2130
2131 /*
2132 * Locate known folder on local system
2133 */
2134 const QString &lamexp_known_folder(lamexp_known_folder_t folder_id)
2135 {
2136 typedef HRESULT (WINAPI *SHGetKnownFolderPathFun)(__in const GUID &rfid, __in DWORD dwFlags, __in HANDLE hToken, __out PWSTR *ppszPath);
2137 typedef HRESULT (WINAPI *SHGetFolderPathFun)(__in HWND hwndOwner, __in int nFolder, __in HANDLE hToken, __in DWORD dwFlags, __out LPWSTR pszPath);
2138
2139 static const int CSIDL_LOCAL_APPDATA = 0x001c;
2140 static const int CSIDL_PROGRAM_FILES = 0x0026;
2141 static const int CSIDL_SYSTEM_FOLDER = 0x0025;
2142 static const GUID GUID_LOCAL_APPDATA = {0xF1B32785,0x6FBA,0x4FCF,{0x9D,0x55,0x7B,0x8E,0x7F,0x15,0x70,0x91}};
2143 static const GUID GUID_LOCAL_APPDATA_LOW = {0xA520A1A4,0x1780,0x4FF6,{0xBD,0x18,0x16,0x73,0x43,0xC5,0xAF,0x16}};
2144 static const GUID GUID_PROGRAM_FILES = {0x905e63b6,0xc1bf,0x494e,{0xb2,0x9c,0x65,0xb7,0x32,0xd3,0xd2,0x1a}};
2145 static const GUID GUID_SYSTEM_FOLDER = {0x1AC14E77,0x02E7,0x4E5D,{0xB7,0x44,0x2E,0xB1,0xAE,0x51,0x98,0xB7}};
2146
2147 QReadLocker readLock(&g_lamexp_known_folder.lock);
2148
2149 int folderCSIDL = -1;
2150 GUID folderGUID = {0x0000,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}};
2151 size_t folderCacheId = size_t(-1);
2152
2153 switch(folder_id)
2154 {
2155 case lamexp_folder_localappdata:
2156 folderCacheId = 0;
2157 folderCSIDL = CSIDL_LOCAL_APPDATA;
2158 folderGUID = GUID_LOCAL_APPDATA;
2159 break;
2160 case lamexp_folder_programfiles:
2161 folderCacheId = 1;
2162 folderCSIDL = CSIDL_PROGRAM_FILES;
2163 folderGUID = GUID_PROGRAM_FILES;
2164 break;
2165 case lamexp_folder_systemfolder:
2166 folderCacheId = 2;
2167 folderCSIDL = CSIDL_SYSTEM_FOLDER;
2168 folderGUID = GUID_SYSTEM_FOLDER;
2169 break;
2170 default:
2171 qWarning("Invalid 'known' folder was requested!");
2172 return *reinterpret_cast<QString*>(NULL);
2173 break;
2174 }
2175
2176 //Already in cache?
2177 if(g_lamexp_known_folder.knownFolders)
2178 {
2179 if(g_lamexp_known_folder.knownFolders->contains(folderCacheId))
2180 {
2181 return (*g_lamexp_known_folder.knownFolders)[folderCacheId];
2182 }
2183 }
2184
2185 //Obtain write lock to initialize
2186 readLock.unlock();
2187 QWriteLocker writeLock(&g_lamexp_known_folder.lock);
2188
2189 //Still not in cache?
2190 if(g_lamexp_known_folder.knownFolders)
2191 {
2192 if(g_lamexp_known_folder.knownFolders->contains(folderCacheId))
2193 {
2194 return (*g_lamexp_known_folder.knownFolders)[folderCacheId];
2195 }
2196 }
2197
2198 static SHGetKnownFolderPathFun SHGetKnownFolderPathPtr = NULL;
2199 static SHGetFolderPathFun SHGetFolderPathPtr = NULL;
2200
2201 //Lookup functions
2202 if((!SHGetKnownFolderPathPtr) && (!SHGetFolderPathPtr))
2203 {
2204 QLibrary kernel32Lib("shell32.dll");
2205 if(kernel32Lib.load())
2206 {
2207 SHGetKnownFolderPathPtr = (SHGetKnownFolderPathFun) kernel32Lib.resolve("SHGetKnownFolderPath");
2208 SHGetFolderPathPtr = (SHGetFolderPathFun) kernel32Lib.resolve("SHGetFolderPathW");
2209 }
2210 }
2211
2212 QString folder;
2213
2214 //Now try to get the folder path!
2215 if(SHGetKnownFolderPathPtr)
2216 {
2217 WCHAR *path = NULL;
2218 if(SHGetKnownFolderPathPtr(folderGUID, 0x00008000, NULL, &path) == S_OK)
2219 {
2220 //MessageBoxW(0, path, L"SHGetKnownFolderPath", MB_TOPMOST);
2221 QDir folderTemp = QDir(QDir::fromNativeSeparators(QString::fromUtf16(reinterpret_cast<const unsigned short*>(path))));
2222 if(!folderTemp.exists())
2223 {
2224 folderTemp.mkpath(".");
2225 }
2226 if(folderTemp.exists())
2227 {
2228 folder = folderTemp.canonicalPath();
2229 }
2230 CoTaskMemFree(path);
2231 }
2232 }
2233 else if(SHGetFolderPathPtr)
2234 {
2235 WCHAR *path = new WCHAR[4096];
2236 if(SHGetFolderPathPtr(NULL, folderCSIDL, NULL, NULL, path) == S_OK)
2237 {
2238 //MessageBoxW(0, path, L"SHGetFolderPathW", MB_TOPMOST);
2239 QDir folderTemp = QDir(QDir::fromNativeSeparators(QString::fromUtf16(reinterpret_cast<const unsigned short*>(path))));
2240 if(!folderTemp.exists())
2241 {
2242 folderTemp.mkpath(".");
2243 }
2244 if(folderTemp.exists())
2245 {
2246 folder = folderTemp.canonicalPath();
2247 }
2248 }
2249 delete [] path;
2250 }
2251
2252 //Create cache
2253 if(!g_lamexp_known_folder.knownFolders)
2254 {
2255 g_lamexp_known_folder.knownFolders = new QMap<size_t, QString>();
2256 }
2257
2258 //Update cache
2259 g_lamexp_known_folder.knownFolders->insert(folderCacheId, folder);
2260 return (*g_lamexp_known_folder.knownFolders)[folderCacheId];
2261 }
2262
2263 /*
2264 * Safely remove a file
2265 */
2266 bool lamexp_remove_file(const QString &filename)
2267 {
2268 if(!QFileInfo(filename).exists() || !QFileInfo(filename).isFile())
2269 {
2270 return true;
2271 }
2272 else
2273 {
2274 if(!QFile::remove(filename))
2275 {
2276 DWORD attributes = GetFileAttributesW(QWCHAR(filename));
2277 SetFileAttributesW(QWCHAR(filename), (attributes & (~FILE_ATTRIBUTE_READONLY)));
2278 if(!QFile::remove(filename))
2279 {
2280 qWarning("Could not delete \"%s\"", filename.toLatin1().constData());
2281 return false;
2282 }
2283 else
2284 {
2285 return true;
2286 }
2287 }
2288 else
2289 {
2290 return true;
2291 }
2292 }
2293 }
2294
2295 /*
2296 * Check if visual themes are enabled (WinXP and later)
2297 */
2298 bool lamexp_themes_enabled(void)
2299 {
2300 typedef int (WINAPI *IsAppThemedFun)(void);
2301
2302 QReadLocker readLock(&g_lamexp_themes_enabled.lock);
2303 if(g_lamexp_themes_enabled.bInitialized)
2304 {
2305 return g_lamexp_themes_enabled.bThemesEnabled;
2306 }
2307
2308 readLock.unlock();
2309 QWriteLocker writeLock(&g_lamexp_themes_enabled.lock);
2310
2311 if(!g_lamexp_themes_enabled.bInitialized)
2312 {
2313 g_lamexp_themes_enabled.bThemesEnabled = false;
2314 const lamexp_os_version_t &osVersion = lamexp_get_os_version();
2315 if(osVersion >= lamexp_winver_winxp)
2316 {
2317 IsAppThemedFun IsAppThemedPtr = NULL;
2318 QLibrary uxTheme(QString("%1/UxTheme.dll").arg(lamexp_known_folder(lamexp_folder_systemfolder)));
2319 if(uxTheme.load())
2320 {
2321 IsAppThemedPtr = (IsAppThemedFun) uxTheme.resolve("IsAppThemed");
2322 }
2323 if(IsAppThemedPtr)
2324 {
2325 g_lamexp_themes_enabled.bThemesEnabled = IsAppThemedPtr();
2326 if(!g_lamexp_themes_enabled.bThemesEnabled)
2327 {
2328 qWarning("Theme support is disabled for this process!");
2329 }
2330 }
2331 }
2332 g_lamexp_themes_enabled.bInitialized = true;
2333 }
2334
2335 return g_lamexp_themes_enabled.bThemesEnabled;
2336 }
2337
2338 /*
2339 * Get number of free bytes on disk
2340 */
2341 unsigned __int64 lamexp_free_diskspace(const QString &path, bool *ok)
2342 {
2343 ULARGE_INTEGER freeBytesAvailable, totalNumberOfBytes, totalNumberOfFreeBytes;
2344 if(GetDiskFreeSpaceExW(reinterpret_cast<const wchar_t*>(QDir::toNativeSeparators(path).utf16()), &freeBytesAvailable, &totalNumberOfBytes, &totalNumberOfFreeBytes))
2345 {
2346 if(ok) *ok = true;
2347 return freeBytesAvailable.QuadPart;
2348 }
2349 else
2350 {
2351 if(ok) *ok = false;
2352 return 0;
2353 }
2354 }
2355
2356 /*
2357 * Check if computer does support hibernation
2358 */
2359 bool lamexp_is_hibernation_supported(void)
2360 {
2361 bool hibernationSupported = false;
2362
2363 SYSTEM_POWER_CAPABILITIES pwrCaps;
2364 SecureZeroMemory(&pwrCaps, sizeof(SYSTEM_POWER_CAPABILITIES));
2365
2366 if(GetPwrCapabilities(&pwrCaps))
2367 {
2368 hibernationSupported = pwrCaps.SystemS4 && pwrCaps.HiberFilePresent;
2369 }
2370
2371 return hibernationSupported;
2372 }
2373
2374 /*
2375 * Shutdown the computer
2376 */
2377 bool lamexp_shutdown_computer(const QString &message, const unsigned long timeout, const bool forceShutdown, const bool hibernate)
2378 {
2379 HANDLE hToken = NULL;
2380
2381 if(OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
2382 {
2383 TOKEN_PRIVILEGES privileges;
2384 memset(&privileges, 0, sizeof(TOKEN_PRIVILEGES));
2385 privileges.PrivilegeCount = 1;
2386 privileges.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
2387
2388 if(LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, &privileges.Privileges[0].Luid))
2389 {
2390 if(AdjustTokenPrivileges(hToken, FALSE, &privileges, NULL, NULL, NULL))
2391 {
2392 if(hibernate)
2393 {
2394 if(SetSuspendState(TRUE, TRUE, TRUE))
2395 {
2396 return true;
2397 }
2398 }
2399 const DWORD reason = SHTDN_REASON_MAJOR_APPLICATION | SHTDN_REASON_FLAG_PLANNED;
2400 return InitiateSystemShutdownEx(NULL, const_cast<wchar_t*>(QWCHAR(message)), timeout, forceShutdown ? TRUE : FALSE, FALSE, reason);
2401 }
2402 }
2403 }
2404
2405 return false;
2406 }
2407
2408 /*
2409 * Make a window blink (to draw user's attention)
2410 */
2411 void lamexp_blink_window(QWidget *poWindow, unsigned int count, unsigned int delay)
2412 {
2413 static QMutex blinkMutex;
2414
2415 const double maxOpac = 1.0;
2416 const double minOpac = 0.3;
2417 const double delOpac = 0.1;
2418
2419 if(!blinkMutex.tryLock())
2420 {
2421 qWarning("Blinking is already in progress, skipping!");
2422 return;
2423 }
2424
2425 try
2426 {
2427 const int steps = static_cast<int>(ceil(maxOpac - minOpac) / delOpac);
2428 const int sleep = static_cast<int>(floor(static_cast<double>(delay) / static_cast<double>(steps)));
2429 const double opacity = poWindow->windowOpacity();
2430
2431 for(unsigned int i = 0; i < count; i++)
2432 {
2433 for(double x = maxOpac; x >= minOpac; x -= delOpac)
2434 {
2435 poWindow->setWindowOpacity(x);
2436 QApplication::processEvents();
2437 Sleep(sleep);
2438 }
2439
2440 for(double x = minOpac; x <= maxOpac; x += delOpac)
2441 {
2442 poWindow->setWindowOpacity(x);
2443 QApplication::processEvents();
2444 Sleep(sleep);
2445 }
2446 }
2447
2448 poWindow->setWindowOpacity(opacity);
2449 QApplication::processEvents();
2450 blinkMutex.unlock();
2451 }
2452 catch(...)
2453 {
2454 blinkMutex.unlock();
2455 qWarning("Exception error while blinking!");
2456 }
2457 }
2458
2459 /*
2460 * Remove forbidden characters from a filename
2461 */
2462 const QString lamexp_clean_filename(const QString &str)
2463 {
2464 QString newStr(str);
2465 QRegExp rx("\"(.+)\"");
2466 rx.setMinimal(true);
2467
2468 newStr.replace("\\", "-");
2469 newStr.replace(" / ", ", ");
2470 newStr.replace("/", ",");
2471 newStr.replace(":", "-");
2472 newStr.replace("*", "x");
2473 newStr.replace("?", "");
2474 newStr.replace("<", "[");
2475 newStr.replace(">", "]");
2476 newStr.replace("|", "!");
2477 newStr.replace(rx, "`\\1´");
2478 newStr.replace("\"", "'");
2479
2480 return newStr.simplified();
2481 }
2482
2483 /*
2484 * Remove forbidden characters from a file path
2485 */
2486 const QString lamexp_clean_filepath(const QString &str)
2487 {
2488 QStringList parts = QString(str).replace("\\", "/").split("/");
2489
2490 for(int i = 0; i < parts.count(); i++)
2491 {
2492 parts[i] = lamexp_clean_filename(parts[i]);
2493 }
2494
2495 return parts.join("/");
2496 }
2497
2498 /*
2499 * Get a list of all available Qt Text Codecs
2500 */
2501 QStringList lamexp_available_codepages(bool noAliases)
2502 {
2503 QStringList codecList;
2504
2505 QList<QByteArray> availableCodecs = QTextCodec::availableCodecs();
2506 while(!availableCodecs.isEmpty())
2507 {
2508 QByteArray current = availableCodecs.takeFirst();
2509 if(!(current.startsWith("system") || current.startsWith("System")))
2510 {
2511 codecList << QString::fromLatin1(current.constData(), current.size());
2512 if(noAliases)
2513 {
2514 if(QTextCodec *currentCodec = QTextCodec::codecForName(current.constData()))
2515 {
2516
2517 QList<QByteArray> aliases = currentCodec->aliases();
2518 while(!aliases.isEmpty()) availableCodecs.removeAll(aliases.takeFirst());
2519 }
2520 }
2521 }
2522 }
2523
2524 return codecList;
2525 }
2526
2527 /*
2528 * Robert Jenkins' 96 bit Mix Function
2529 * Source: http://www.concentric.net/~Ttwang/tech/inthash.htm
2530 */
2531 static unsigned int lamexp_mix(const unsigned int x, const unsigned int y, const unsigned int z)
2532 {
2533 unsigned int a = x;
2534 unsigned int b = y;
2535 unsigned int c = z;
2536
2537 a=a-b; a=a-c; a=a^(c >> 13);
2538 b=b-c; b=b-a; b=b^(a << 8);
2539 c=c-a; c=c-b; c=c^(b >> 13);
2540 a=a-b; a=a-c; a=a^(c >> 12);
2541 b=b-c; b=b-a; b=b^(a << 16);
2542 c=c-a; c=c-b; c=c^(b >> 5);
2543 a=a-b; a=a-c; a=a^(c >> 3);
2544 b=b-c; b=b-a; b=b^(a << 10);
2545 c=c-a; c=c-b; c=c^(b >> 15);
2546
2547 return c;
2548 }
2549
2550 /*
2551 * Seeds the random number generator
2552 * Note: Altough rand_s() doesn't need a seed, this must be called pripr to lamexp_rand(), just to to be sure!
2553 */
2554 void lamexp_seed_rand(void)
2555 {
2556 qsrand(lamexp_mix(clock(), time(NULL), _getpid()));
2557 }
2558
2559 /*
2560 * Returns a randum number
2561 * Note: This function uses rand_s() if available, but falls back to qrand() otherwise
2562 */
2563 unsigned int lamexp_rand(void)
2564 {
2565 quint32 rnd = 0;
2566
2567 if(rand_s(&rnd) == 0)
2568 {
2569 return rnd;
2570 }
2571
2572 for(size_t i = 0; i < sizeof(unsigned int); i++)
2573 {
2574 rnd = (rnd << 8) ^ qrand();
2575 }
2576
2577 return rnd;
2578 }
2579
2580 /*
2581 * Determines the current date, resistant against certain manipulations
2582 */
2583 QDate lamexp_current_date_safe(void)
2584 {
2585 const DWORD MAX_PROC = 1024;
2586 DWORD *processes = new DWORD[MAX_PROC];
2587 DWORD bytesReturned = 0;
2588
2589 if(!EnumProcesses(processes, sizeof(DWORD) * MAX_PROC, &bytesReturned))
2590 {
2591 LAMEXP_DELETE_ARRAY(processes);
2592 return QDate::currentDate();
2593 }
2594
2595 const DWORD procCount = bytesReturned / sizeof(DWORD);
2596 ULARGE_INTEGER lastStartTime;
2597 memset(&lastStartTime, 0, sizeof(ULARGE_INTEGER));
2598
2599 for(DWORD i = 0; i < procCount; i++)
2600 {
2601 HANDLE hProc = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, processes[i]);
2602 if(hProc)
2603 {
2604 FILETIME processTime[4];
2605 if(GetProcessTimes(hProc, &processTime[0], &processTime[1], &processTime[2], &processTime[3]))
2606 {
2607 ULARGE_INTEGER timeCreation;
2608 timeCreation.LowPart = processTime[0].dwLowDateTime;
2609 timeCreation.HighPart = processTime[0].dwHighDateTime;
2610 if(timeCreation.QuadPart > lastStartTime.QuadPart)
2611 {
2612 lastStartTime.QuadPart = timeCreation.QuadPart;
2613 }
2614 }
2615 CloseHandle(hProc);
2616 }
2617 }
2618
2619 LAMEXP_DELETE_ARRAY(processes);
2620
2621 FILETIME lastStartTime_fileTime;
2622 lastStartTime_fileTime.dwHighDateTime = lastStartTime.HighPart;
2623 lastStartTime_fileTime.dwLowDateTime = lastStartTime.LowPart;
2624
2625 FILETIME lastStartTime_localTime;
2626 if(!FileTimeToLocalFileTime(&lastStartTime_fileTime, &lastStartTime_localTime))
2627 {
2628 memcpy(&lastStartTime_localTime, &lastStartTime_fileTime, sizeof(FILETIME));
2629 }
2630
2631 SYSTEMTIME lastStartTime_system;
2632 if(!FileTimeToSystemTime(&lastStartTime_localTime, &lastStartTime_system))
2633 {
2634 memset(&lastStartTime_system, 0, sizeof(SYSTEMTIME));
2635 lastStartTime_system.wYear = 1970; lastStartTime_system.wMonth = lastStartTime_system.wDay = 1;
2636 }
2637
2638 const QDate currentDate = QDate::currentDate();
2639 const QDate processDate = QDate(lastStartTime_system.wYear, lastStartTime_system.wMonth, lastStartTime_system.wDay);
2640 return (currentDate >= processDate) ? currentDate : processDate;
2641 }
2642
2643
2644 /*
2645 * Natural Order String Comparison - the 'lessThan' helper function
2646 */
2647 static bool lamexp_natural_string_sort_helper(const QString &str1, const QString &str2)
2648 {
2649 return (strnatcmp(QWCHAR(str1), QWCHAR(str2)) < 0);
2650 }
2651
2652 /*
2653 * Natural Order String Comparison - the 'lessThan' helper function *with* case folding
2654 */
2655 static bool lamexp_natural_string_sort_helper_fold_case(const QString &str1, const QString &str2)
2656 {
2657 return (strnatcasecmp(QWCHAR(str1), QWCHAR(str2)) < 0);
2658 }
2659
2660 /*
2661 * Natural Order String Comparison - the main sorting function
2662 */
2663 void lamexp_natural_string_sort(QStringList &list, const bool bIgnoreCase)
2664 {
2665 qSort(list.begin(), list.end(), bIgnoreCase ? lamexp_natural_string_sort_helper_fold_case : lamexp_natural_string_sort_helper);
2666 }
2667
2668 /*
2669 * Suspend calling thread for N milliseconds
2670 */
2671 inline void lamexp_sleep(const unsigned int delay)
2672 {
2673 Sleep(delay);
2674 }
2675
2676 bool lamexp_beep(int beepType)
2677 {
2678 switch(beepType)
2679 {
2680 case lamexp_beep_info: return MessageBeep(MB_ICONASTERISK) == TRUE; break;
2681 case lamexp_beep_warning: return MessageBeep(MB_ICONEXCLAMATION) == TRUE; break;
2682 case lamexp_beep_error: return MessageBeep(MB_ICONHAND) == TRUE; break;
2683 default: return false;
2684 }
2685 }
2686
2687 /*
2688 * Play a sound (from resources)
2689 */
2690 bool lamexp_play_sound(const unsigned short uiSoundIdx, const bool bAsync, const wchar_t *alias)
2691 {
2692 if(alias)
2693 {
2694 return PlaySound(alias, GetModuleHandle(NULL), (SND_ALIAS | (bAsync ? SND_ASYNC : SND_SYNC))) == TRUE;
2695 }
2696 else
2697 {
2698 return PlaySound(MAKEINTRESOURCE(uiSoundIdx), GetModuleHandle(NULL), (SND_RESOURCE | (bAsync ? SND_ASYNC : SND_SYNC))) == TRUE;
2699 }
2700 }
2701
2702 /*
2703 * Play a sound (from resources)
2704 */
2705 bool lamexp_play_sound_file(const QString &library, const unsigned short uiSoundIdx, const bool bAsync)
2706 {
2707 bool result = false;
2708 HMODULE module = NULL;
2709
2710 QFileInfo libraryFile(library);
2711 if(!libraryFile.isAbsolute())
2712 {
2713 unsigned int buffSize = GetSystemDirectoryW(NULL, NULL) + 1;
2714 wchar_t *buffer = (wchar_t*) _malloca(buffSize * sizeof(wchar_t));
2715 unsigned int result = GetSystemDirectory(buffer, buffSize);
2716 if(result > 0 && result < buffSize)
2717 {
2718 libraryFile.setFile(QString("%1/%2").arg(QDir::fromNativeSeparators(QString::fromUtf16(reinterpret_cast<const unsigned short*>(buffer))), library));
2719 }
2720 _freea(buffer);
2721 }
2722
2723 module = LoadLibraryW(QWCHAR(QDir::toNativeSeparators(libraryFile.absoluteFilePath())));
2724 if(module)
2725 {
2726 result = (PlaySound(MAKEINTRESOURCE(uiSoundIdx), module, (SND_RESOURCE | (bAsync ? SND_ASYNC : SND_SYNC))) == TRUE);
2727 FreeLibrary(module);
2728 }
2729
2730 return result;
2731 }
2732
2733 /*
2734 * Open file using the shell
2735 */
2736 bool lamexp_exec_shell(const QWidget *win, const QString &url, const bool explore)
2737 {
2738 return lamexp_exec_shell(win, url, QString(), QString(), explore);
2739 }
2740
2741 /*
2742 * Open file using the shell (with parameters)
2743 */
2744 bool lamexp_exec_shell(const QWidget *win, const QString &url, const QString &parameters, const QString &directory, const bool explore)
2745 {
2746 return ((int) ShellExecuteW(((win) ? win->winId() : NULL), (explore ? L"explore" : L"open"), QWCHAR(url), ((!parameters.isEmpty()) ? QWCHAR(parameters) : NULL), ((!directory.isEmpty()) ? QWCHAR(directory) : NULL), SW_SHOW)) > 32;
2747 }
2748
2749 /*
2750 * Query value of the performance counter
2751 */
2752 __int64 lamexp_perfcounter_value(void)
2753 {
2754 LARGE_INTEGER counter;
2755 if(QueryPerformanceCounter(&counter) == TRUE)
2756 {
2757 return counter.QuadPart;
2758 }
2759 return -1;
2760 }
2761
2762 /*
2763 * Query frequency of the performance counter
2764 */
2765 __int64 lamexp_perfcounter_frequ(void)
2766 {
2767 LARGE_INTEGER frequency;
2768 if(QueryPerformanceFrequency(&frequency) == TRUE)
2769 {
2770 return frequency.QuadPart;
2771 }
2772 return -1;
2773 }
2774
2775 /*
2776 * Insert entry to the window's system menu
2777 */
2778 bool lamexp_append_sysmenu(const QWidget *win, const unsigned int identifier, const QString &text)
2779 {
2780 bool ok = false;
2781
2782 if(HMENU hMenu = GetSystemMenu(win->winId(), FALSE))
2783 {
2784 ok = (AppendMenuW(hMenu, MF_SEPARATOR, 0, 0) == TRUE);
2785 ok = (AppendMenuW(hMenu, MF_STRING, identifier, QWCHAR(text)) == TRUE);
2786 }
2787
2788 return ok;
2789 }
2790
2791 /*
2792 * Insert entry to the window's system menu
2793 */
2794 bool lamexp_check_sysmenu_msg(void *message, const unsigned int identifier)
2795 {
2796 return (((MSG*)message)->message == WM_SYSCOMMAND) && ((((MSG*)message)->wParam & 0xFFF0) == identifier);
2797 }
2798
2799 /*
2800 * Update system menu entry
2801 */
2802 bool lamexp_update_sysmenu(const QWidget *win, const unsigned int identifier, const QString &text)
2803 {
2804 bool ok = false;
2805
2806 if(HMENU hMenu = ::GetSystemMenu(win->winId(), FALSE))
2807 {
2808 ok = (ModifyMenu(hMenu, identifier, MF_STRING | MF_BYCOMMAND, identifier, QWCHAR(text)) == TRUE);
2809 }
2810 return ok;
2811 }
2812
2813 /*
2814 * Display the window's close button
2815 */
2816 bool lamexp_enable_close_button(const QWidget *win, const bool bEnable)
2817 {
2818 bool ok = false;
2819
2820 if(HMENU hMenu = GetSystemMenu(win->winId(), FALSE))
2821 {
2822 ok = (EnableMenuItem(hMenu, SC_CLOSE, MF_BYCOMMAND | (bEnable ? MF_ENABLED : MF_GRAYED)) == TRUE);
2823 }
2824
2825 return ok;
2826 }
2827
2828 /*
2829 * Check whether ESC key has been pressed since the previous call to this function
2830 */
2831 bool lamexp_check_escape_state(void)
2832 {
2833 return (GetAsyncKeyState(VK_ESCAPE) & 0x0001) != 0;
2834 }
2835
2836 /*
2837 * Set the process priority class for current process
2838 */
2839 bool lamexp_change_process_priority(const int priority)
2840 {
2841 return lamexp_change_process_priority(GetCurrentProcess(), priority);
2842 }
2843
2844 /*
2845 * Set the process priority class for specified process
2846 */
2847 bool lamexp_change_process_priority(const QProcess *proc, const int priority)
2848 {
2849 if(Q_PID qPid = proc->pid())
2850 {
2851 return lamexp_change_process_priority(qPid->hProcess, priority);
2852 }
2853 else
2854 {
2855 return false;
2856 }
2857 }
2858
2859 /*
2860 * Set the process priority class for specified process
2861 */
2862 bool lamexp_change_process_priority(void *hProcess, const int priority)
2863 {
2864 bool ok = false;
2865
2866 switch(qBound(-2, priority, 2))
2867 {
2868 case 2:
2869 ok = (SetPriorityClass(hProcess, HIGH_PRIORITY_CLASS) == TRUE);
2870 break;
2871 case 1:
2872 if(!(ok = (SetPriorityClass(hProcess, ABOVE_NORMAL_PRIORITY_CLASS) == TRUE)))
2873 {
2874 ok = (SetPriorityClass(hProcess, HIGH_PRIORITY_CLASS) == TRUE);
2875 }
2876 break;
2877 case 0:
2878 ok = (SetPriorityClass(hProcess, NORMAL_PRIORITY_CLASS) == TRUE);
2879 break;
2880 case -1:
2881 if(!(ok = (SetPriorityClass(hProcess, BELOW_NORMAL_PRIORITY_CLASS) == TRUE)))
2882 {
2883 ok = (SetPriorityClass(hProcess, IDLE_PRIORITY_CLASS) == TRUE);
2884 }
2885 break;
2886 case -2:
2887 ok = (SetPriorityClass(hProcess, IDLE_PRIORITY_CLASS) == TRUE);
2888 break;
2889 }
2890
2891 return ok;
2892 }
2893
2894 /*
2895 * Returns the current file time
2896 */
2897 unsigned __int64 lamexp_current_file_time(void)
2898 {
2899 FILETIME fileTime;
2900 GetSystemTimeAsFileTime(&fileTime);
2901
2902 ULARGE_INTEGER temp;
2903 temp.HighPart = fileTime.dwHighDateTime;
2904 temp.LowPart = fileTime.dwLowDateTime;
2905
2906 return temp.QuadPart;
2907 }
2908
2909 /*
2910 * Bring the specifed window to the front
2911 */
2912 bool lamexp_bring_to_front(const QWidget *win)
2913 {
2914 const bool ret = (SetForegroundWindow(win->winId()) == TRUE);
2915 SwitchToThisWindow(win->winId(), TRUE);
2916 return ret;
2917 }
2918
2919 /*
2920 * Bring window of the specifed process to the front (callback)
2921 */
2922 static BOOL CALLBACK lamexp_bring_process_to_front_helper(HWND hwnd, LPARAM lParam)
2923 {
2924 DWORD processId = *reinterpret_cast<WORD*>(lParam);
2925 DWORD windowProcessId = NULL;
2926 GetWindowThreadProcessId(hwnd, &windowProcessId);
2927 if(windowProcessId == processId)
2928 {
2929 SwitchToThisWindow(hwnd, TRUE);
2930 SetForegroundWindow(hwnd);
2931 return FALSE;
2932 }
2933
2934 return TRUE;
2935 }
2936
2937 /*
2938 * Bring window of the specifed process to the front
2939 */
2940 bool lamexp_bring_process_to_front(const unsigned long pid)
2941 {
2942 return EnumWindows(lamexp_bring_process_to_front_helper, reinterpret_cast<LPARAM>(&pid)) == TRUE;
2943 }
2944
2945 /*
2946 * Check the network connection status
2947 */
2948 int lamexp_network_status(void)
2949 {
2950 DWORD dwFlags;
2951 const BOOL ret = (IsNetworkAlive(&dwFlags) == TRUE);
2952 if(GetLastError() == 0)
2953 {
2954 return (ret == TRUE) ? lamexp_network_yes : lamexp_network_non;
2955 }
2956 return lamexp_network_err;
2957 }
2958
2959 /*
2960 * Retrun the process ID of the given QProcess
2961 */
2962 unsigned long lamexp_process_id(const QProcess *proc)
2963 {
2964 PROCESS_INFORMATION *procInf = proc->pid();
2965 return (procInf) ? procInf->dwProcessId : NULL;
2966 }
2967
2968 /*
2969 * Convert long path to short path
2970 */
2971 QString lamexp_path_to_short(const QString &longPath)
2972 {
2973 QString shortPath;
2974 DWORD buffSize = GetShortPathNameW(reinterpret_cast<const wchar_t*>(longPath.utf16()), NULL, NULL);
2975
2976 if(buffSize > 0)
2977 {
2978 wchar_t *buffer = new wchar_t[buffSize];
2979 DWORD result = GetShortPathNameW(reinterpret_cast<const wchar_t*>(longPath.utf16()), buffer, buffSize);
2980
2981 if(result > 0 && result < buffSize)
2982 {
2983 shortPath = QString::fromUtf16(reinterpret_cast<const unsigned short*>(buffer));
2984 }
2985
2986 delete[] buffer;
2987 }
2988
2989 return (shortPath.isEmpty() ? longPath : shortPath);
2990 }
2991
2992 /*
2993 * Open media file in external player
2994 */
2995 bool lamexp_open_media_file(const QString &mediaFilePath)
2996 {
2997 const static wchar_t *registryPrefix[2] = { L"SOFTWARE\\", L"SOFTWARE\\Wow6432Node\\" };
2998 const static wchar_t *registryKeys[3] =
2999 {
3000 L"Microsoft\\Windows\\CurrentVersion\\Uninstall\\{97D341C8-B0D1-4E4A-A49A-C30B52F168E9}",
3001 L"Microsoft\\Windows\\CurrentVersion\\Uninstall\\{DB9E4EAB-2717-499F-8D56-4CC8A644AB60}",
3002 L"foobar2000"
3003 };
3004 const static wchar_t *appNames[4] = { L"smplayer_portable.exe", L"smplayer.exe", L"MPUI.exe", L"foobar2000.exe" };
3005 const static wchar_t *valueNames[2] = { L"InstallLocation", L"InstallDir" };
3006
3007 for(size_t i = 0; i < 3; i++)
3008 {
3009 for(size_t j = 0; j < 2; j++)
3010 {
3011 QString mplayerPath;
3012 HKEY registryKeyHandle = NULL;
3013
3014 const QString currentKey = WCHAR2QSTR(registryPrefix[j]).append(WCHAR2QSTR(registryKeys[i]));
3015 if(RegOpenKeyExW(HKEY_LOCAL_MACHINE, QWCHAR(currentKey), 0, KEY_READ, &registryKeyHandle) == ERROR_SUCCESS)
3016 {
3017 for(size_t k = 0; k < 2; k++)
3018 {
3019 wchar_t Buffer[4096];
3020 DWORD BuffSize = sizeof(wchar_t*) * 4096;
3021 DWORD DataType = REG_NONE;
3022 if(RegQueryValueExW(registryKeyHandle, valueNames[k], 0, &DataType, reinterpret_cast<BYTE*>(Buffer), &BuffSize) == ERROR_SUCCESS)
3023 {
3024 if((DataType == REG_SZ) || (DataType == REG_EXPAND_SZ) || (DataType == REG_LINK))
3025 {
3026 mplayerPath = WCHAR2QSTR(Buffer);
3027 break;
3028 }
3029 }
3030 }
3031 RegCloseKey(registryKeyHandle);
3032 }
3033
3034 if(!mplayerPath.isEmpty())
3035 {
3036 QDir mplayerDir(mplayerPath);
3037 if(mplayerDir.exists())
3038 {
3039 for(size_t k = 0; k < 4; k++)
3040 {
3041 if(mplayerDir.exists(WCHAR2QSTR(appNames[k])))
3042 {
3043 qDebug("Player found at:\n%s\n", QUTF8(mplayerDir.absoluteFilePath(WCHAR2QSTR(appNames[k]))));
3044 QProcess::startDetached(mplayerDir.absoluteFilePath(WCHAR2QSTR(appNames[k])), QStringList() << QDir::toNativeSeparators(mediaFilePath));
3045 return true;
3046 }
3047 }
3048 }
3049 }
3050 }
3051 }
3052 return false;
3053 }
3054
3055 /*
3056 * Setup QPorcess object
3057 */
3058 void lamexp_init_process(QProcess &process, const QString &wokringDir)
3059 {
3060 //Environment variable names
3061 static const char *const s_envvar_names[] =
3062 {
3063 "WGETRC", "SYSTEM_WGETRC", "HTTP_PROXY", "FTP_PROXY", "NO_PROXY", "GNUPGHOME", "LC_ALL", "LC_COLLATE", "LC_CTYPE", "LC_MESSAGES", "LC_MONETARY", "LC_NUMERIC", "LC_TIME", "LANG", NULL
3064 };
3065
3066 const QString tempDir = QDir::toNativeSeparators(lamexp_temp_folder2());
3067
3068 QProcessEnvironment env = process.processEnvironment();
3069 if(env.isEmpty()) env = QProcessEnvironment::systemEnvironment();
3070
3071 //Setup TEMP directory
3072 env.insert("TEMP", tempDir);
3073 env.insert("TMP", tempDir);
3074 env.insert("TMPDIR", tempDir);
3075 env.insert("HOME", tempDir);
3076 env.insert("USERPROFILE", tempDir);
3077 env.insert("HOMEPATH", tempDir);
3078
3079 //Setup PATH variable
3080 const QString path = env.value("PATH", QString());
3081 env.insert("PATH", path.isEmpty() ? tempDir : QString("%1;%2").arg(tempDir, path));
3082
3083 //Clean a number of enviroment variables that might affect our tools
3084 for(size_t i = 0; s_envvar_names[i]; i++)
3085 {
3086 env.remove(QString::fromLatin1(s_envvar_names[i]));
3087 env.remove(QString::fromLatin1(s_envvar_names[i]).toLower());
3088 }
3089
3090 process.setWorkingDirectory(wokringDir);
3091 process.setProcessChannelMode(QProcess::MergedChannels);
3092 process.setReadChannel(QProcess::StandardOutput);
3093 process.setProcessEnvironment(env);
3094 }
3095
3096 /*
3097 * Entry point checks
3098 */
3099 static DWORD lamexp_entry_check(void);
3100 static DWORD g_lamexp_entry_check_result = lamexp_entry_check();
3101 static DWORD g_lamexp_entry_check_flag = 0x789E09B2;
3102 static DWORD lamexp_entry_check(void)
3103 {
3104 volatile DWORD retVal = 0xA199B5AF;
3105 if(g_lamexp_entry_check_flag != 0x8761F64D)
3106 {
3107 lamexp_fatal_exit(L"Application initialization has failed, take care!");
3108 }
3109 return retVal;
3110 }
3111
3112 /*
3113 * Application entry point (runs before static initializers)
3114 */
3115 extern "C"
3116 {
3117 int WinMainCRTStartup(void);
3118
3119 int lamexp_entry_point(void)
3120 {
3121 if((!LAMEXP_DEBUG) && lamexp_check_for_debugger())
3122 {
3123 lamexp_fatal_exit(L"Not a debug build. Please unload debugger and try again!");
3124 }
3125 if(g_lamexp_entry_check_flag != 0x789E09B2)
3126 {
3127 lamexp_fatal_exit(L"Application initialization has failed, take care!");
3128 }
3129
3130 //Zero *before* constructors are called
3131 LAMEXP_ZERO_MEMORY(g_lamexp_argv);
3132 LAMEXP_ZERO_MEMORY(g_lamexp_tools);
3133 LAMEXP_ZERO_MEMORY(g_lamexp_currentTranslator);
3134 LAMEXP_ZERO_MEMORY(g_lamexp_translation);
3135 LAMEXP_ZERO_MEMORY(g_lamexp_known_folder);
3136 LAMEXP_ZERO_MEMORY(g_lamexp_temp_folder);
3137 LAMEXP_ZERO_MEMORY(g_lamexp_ipc_ptr);
3138 LAMEXP_ZERO_MEMORY(g_lamexp_os_version);
3139 LAMEXP_ZERO_MEMORY(g_lamexp_themes_enabled);
3140 LAMEXP_ZERO_MEMORY(g_lamexp_portable);
3141
3142 //Make sure we will pass the check
3143 g_lamexp_entry_check_flag = ~g_lamexp_entry_check_flag;
3144
3145 //Now initialize the C Runtime library!
3146 return WinMainCRTStartup();
3147 }
3148 }
3149
3150 /*
3151 * Fatal application exit
3152 */
3153 #pragma intrinsic(_InterlockedExchange)
3154 void lamexp_fatal_exit(const wchar_t* exitMessage, const wchar_t* errorBoxMessage)
3155 {
3156 static volatile long bFatalFlag = 0L;
3157
3158 if(_InterlockedExchange(&bFatalFlag, 1L) == 0L)
3159 {
3160 if(GetCurrentThreadId() != g_main_thread_id)
3161 {
3162 HANDLE mainThread = OpenThread(THREAD_TERMINATE, FALSE, g_main_thread_id);
3163 if(mainThread) TerminateThread(mainThread, ULONG_MAX);
3164 }
3165
3166 if(errorBoxMessage)
3167 {
3168 MessageBoxW(NULL, errorBoxMessage, L"LameXP - GURU MEDITATION", MB_ICONERROR | MB_TOPMOST | MB_TASKMODAL);
3169 }
3170
3171 for(;;)
3172 {
3173 FatalAppExit(0, exitMessage);
3174 TerminateProcess(GetCurrentProcess(), -1);
3175 }
3176 }
3177
3178 TerminateThread(GetCurrentThread(), -1);
3179 Sleep(INFINITE);
3180 }
3181
3182 /*
3183 * Finalization function (final clean-up)
3184 */
3185 void lamexp_finalization(void)
3186 {
3187 qDebug("lamexp_finalization()");
3188
3189 //Free all tools
3190 if(g_lamexp_tools.registry)
3191 {
3192 QStringList keys = g_lamexp_tools.registry->keys();
3193 for(int i = 0; i < keys.count(); i++)
3194 {
3195 LAMEXP_DELETE((*g_lamexp_tools.registry)[keys.at(i)]);
3196 }
3197 LAMEXP_DELETE(g_lamexp_tools.registry);
3198 LAMEXP_DELETE(g_lamexp_tools.versions);
3199 LAMEXP_DELETE(g_lamexp_tools.tags);
3200 }
3201
3202 //Delete temporary files
3203 if(g_lamexp_temp_folder.path)
3204 {
3205 if(!g_lamexp_temp_folder.path->isEmpty())
3206 {
3207 bool success = false;
3208 for(int i = 0; i < 100; i++)
3209 {
3210 if(lamexp_clean_folder(*g_lamexp_temp_folder.path))
3211 {
3212 success = true;
3213 break;
3214 }
3215 lamexp_sleep(100);
3216 }
3217 if(!success)
3218 {
3219 MessageBoxW(NULL, L"Sorry, LameXP was unable to clean up all temporary files. Some residual files in your TEMP directory may require manual deletion!", L"LameXP", MB_ICONEXCLAMATION|MB_TOPMOST);
3220 lamexp_exec_shell(NULL, *g_lamexp_temp_folder.path, QString(), QString(), true);
3221 }
3222 }
3223 LAMEXP_DELETE(g_lamexp_temp_folder.path);
3224 }
3225
3226 //Clear folder cache
3227 LAMEXP_DELETE(g_lamexp_known_folder.knownFolders);
3228
3229 //Clear languages
3230 if(g_lamexp_currentTranslator.instance)
3231 {
3232 QApplication::removeTranslator(g_lamexp_currentTranslator.instance);
3233 LAMEXP_DELETE(g_lamexp_currentTranslator.instance);
3234 }
3235 LAMEXP_DELETE(g_lamexp_translation.files);
3236 LAMEXP_DELETE(g_lamexp_translation.names);
3237 LAMEXP_DELETE(g_lamexp_translation.cntry);
3238 LAMEXP_DELETE(g_lamexp_translation.sysid);
3239
3240 //Destroy Qt application object
3241 QApplication *application = dynamic_cast<QApplication*>(QApplication::instance());
3242 LAMEXP_DELETE(application);
3243
3244 //Detach from shared memory
3245 if(g_lamexp_ipc_ptr.sharedmem) g_lamexp_ipc_ptr.sharedmem->detach();
3246 LAMEXP_DELETE(g_lamexp_ipc_ptr.sharedmem);
3247 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_read);
3248 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_write);
3249 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_read_mutex);
3250 LAMEXP_DELETE(g_lamexp_ipc_ptr.semaphore_write_mutex);
3251
3252 //Free STDOUT and STDERR buffers
3253 if(g_lamexp_console_attached)
3254 {
3255 if(std::filebuf *tmp = dynamic_cast<std::filebuf*>(std::cout.rdbuf()))
3256 {
3257 std::cout.rdbuf(NULL);
3258 LAMEXP_DELETE(tmp);
3259 }
3260 if(std::filebuf *tmp = dynamic_cast<std::filebuf*>(std::cerr.rdbuf()))
3261 {
3262 std::cerr.rdbuf(NULL);
3263 LAMEXP_DELETE(tmp);
3264 }
3265 }
3266
3267 //Close log file
3268 if(g_lamexp_log_file)
3269 {
3270 fclose(g_lamexp_log_file);
3271 g_lamexp_log_file = NULL;
3272 }
3273
3274 //Free CLI Arguments
3275 LAMEXP_DELETE(g_lamexp_argv.list);
3276 }
3277
3278 /*
3279 * Initialize debug thread
3280 */
3281 static const HANDLE g_debug_thread1 = LAMEXP_DEBUG ? NULL : lamexp_debug_thread_init();
3282
3283 /*
3284 * Get number private bytes [debug only]
3285 */
3286 unsigned long lamexp_dbg_private_bytes(void)
3287 {
3288 #if LAMEXP_DEBUG
3289 for(int i = 0; i < 8; i++) _heapmin();
3290 PROCESS_MEMORY_COUNTERS_EX memoryCounters;
3291 memoryCounters.cb = sizeof(PROCESS_MEMORY_COUNTERS_EX);
3292 GetProcessMemoryInfo(GetCurrentProcess(), (PPROCESS_MEMORY_COUNTERS) &memoryCounters, sizeof(PROCESS_MEMORY_COUNTERS_EX));
3293 return memoryCounters.PrivateUsage;
3294 #else
3295 THROW("Cannot call this function in a non-debug build!");
3296 #endif //LAMEXP_DEBUG
3297 }
Audio Encoder Front-End (Qt)