#if defined(_USE_QT)

#include <string.h>

#include <fcntl.h>

#if !defined(__WIN32) && !defined(__WIN64)

#include <unistd.h>

#else

#include <io.h>

#include <direct.h>

#endif

#include <sys/types.h>

#include <sys/stat.h>

#include "csp_logger.h"

#include <string>

#include <algorithm>

#include <cctype>

#include <QDir>

#include <QFileInfo>

#elif defined(_WIN32)

#include <shlwapi.h>

#pragma comment(lib, "shlwapi.lib")

#else

#include <time.h>

#endif

#include <math.h>

#include "common.h"

#include "fileio.h"

#if defined(__MINGW32__) || defined(__MINGW64__)

extern DWORD GetLongPathName(LPCTSTR lpszShortPath, LPTSTR lpszLongPath, DWORD cchBuffer);

#endif

#if defined(_USE_QT)

std::string DLL_PREFIX cpp_homedir;

std::string DLL_PREFIX my_procname;

std::string DLL_PREFIX sRssDir;

#endif

void DLL_PREFIX common_initialize()

}

uint32_t DLL_PREFIX EndianToLittle_DWORD(uint32_t x)

}

uint16_t DLL_PREFIX EndianToLittle_WORD(uint16_t x)

}

uint32_t DLL_PREFIX EndianFromLittle_DWORD(uint32_t x)

}

uint16_t DLL_PREFIX EndianFromLittle_WORD(uint16_t x)

}

uint32_t DLL_PREFIX EndianToBig_DWORD(uint32_t x)

}

uint16_t DLL_PREFIX EndianToBig_WORD(uint16_t x)

}

uint32_t DLL_PREFIX EndianFromBig_DWORD(uint32_t x)

}

uint16_t DLL_PREFIX EndianFromBig_WORD(uint16_t x)

}

uint64_t DLL_PREFIX ExchangeEndianU64(uint64_t x)

}

int64_t DLL_PREFIX ExchangeEndianS64(uint64_t x)

}

uint32_t DLL_PREFIX ExchangeEndianU32(uint32_t x)

}

int32_t DLL_PREFIX ExchangeEndianS32(uint32_t x)

}

uint16_t DLL_PREFIX ExchangeEndianU16(uint16_t x)

}

int16_t DLL_PREFIX ExchangeEndianS16(uint16_t x)

}

#ifndef _MSC_VER

int DLL_PREFIX max(int a, int b)

}

unsigned DLL_PREFIX int max(unsigned int a, unsigned int b)

}

unsigned DLL_PREFIX int max(unsigned int a, int b)

}

unsigned DLL_PREFIX int max(int a, unsigned int b)

}

int DLL_PREFIX min(int a, int b)

}

int DLL_PREFIX min(unsigned int a, int b)

}

int DLL_PREFIX min(int a, unsigned int b)

}

unsigned int DLL_PREFIX min(unsigned int a, unsigned int b)

}

#endif

#ifndef SUPPORT_SECURE_FUNCTIONS

errno_t DLL_PREFIX my_tcscat_s(_TCHAR *strDestination, size_t numberOfElements, const _TCHAR *strSource)

}

errno_t DLL_PREFIX my_strcpy_s(char *strDestination, size_t numberOfElements, const char *strSource)

}

errno_t DLL_PREFIX my_tcscpy_s(_TCHAR *strDestination, size_t numberOfElements, const _TCHAR *strSource)

}

errno_t DLL_PREFIX my_tcscpy_s(_TCHAR *strDestination, const _TCHAR *strSource)

}

errno_t DLL_PREFIX my_strncpy_s(char *strDestination, size_t numberOfElements, const char *strSource, size_t count)

}

errno_t DLL_PREFIX my_tcsncpy_s(_TCHAR *strDestination, size_t numberOfElements, const _TCHAR *strSource, size_t count)

}

char *DLL_PREFIX my_strtok_s(char *strToken, const char *strDelimit, char **context)

{

return strtok(strToken, strDelimit);

}

_TCHAR *DLL_PREFIX my_tcstok_s(_TCHAR *strToken, const char *strDelimit, _TCHAR **context)

{

return _tcstok(strToken, strDelimit);

}

int DLL_PREFIX my_sprintf_s(char *buffer, size_t sizeOfBuffer, const char *format, ...)

}

int DLL_PREFIX my_swprintf_s(wchar_t *buffer, size_t sizeOfBuffer, const wchar_t *format, ...)

}

int DLL_PREFIX my_stprintf_s(_TCHAR *buffer, size_t sizeOfBuffer, const _TCHAR *format, ...)

}

int DLL_PREFIX my_vsprintf_s(char *buffer, size_t numberOfElements, const char *format, va_list argptr)

{

return vsprintf(buffer, format, argptr);

}

int DLL_PREFIX my_vstprintf_s(_TCHAR *buffer, size_t numberOfElements, const _TCHAR *format, va_list argptr)

{

return _vstprintf(buffer, format, argptr);

}

#endif

#ifndef _MSC_VER

void DLL_PREFIX *my_memcpy(void *dst, void *src, size_t len)

{

size_t len1;

register size_t len2;

register uint32_t s_align = (uint32_t)(((size_t)src) & 0x1f);

register uint32_t d_align = (uint32_t)(((size_t)dst) & 0x1f);

int i;

if(len == 0) return dst;

if(len < 8) {

return memcpy(dst, src, len);

}

len1 = len;

#if defined(WITHOUT_UNALIGNED_SIMD)

// Using SIMD without un-aligned instructions.

switch(s_align) {

case 0: // Align 256

{

uint64_t b64[4];

register uint64_t *s64 = (uint64_t *)src;

register uint64_t *d64 = (uint64_t *)dst;

switch(d_align) {

case 0: // 256 vs 256

{

len2 = len1 >> 5;

while(len2 > 0) {

for(i = 0; i < 4; i++) b64[i] = s64[i];

for(i = 0; i < 4; i++) d64[i] = b64[i];

s64 += 4;

d64 += 4;

--len2;

}

len1 = len1 & 0x1f;

if(len1 != 0) return memcpy(d64, s64, len1);

return dst;

}

break;

case 0x10: // 256 vs 128

{

len2 = len1 >> 5;

while(len2 > 0) {

for(i = 0; i < 4; i++) b64[i] = s64[i];

for(i = 0; i < 2; i++) d64[i] = b64[i];

d64 += 2;

for(i = 2; i < 4; i++) d64[i - 2] = b64[i];

d64 += 2;

s64 += 4;

--len2;

}

len1 = len1 & 0x1f;

if(len1 != 0) return memcpy(d64, s64, len1);

return dst;

}

break;

case 0x08:

case 0x18: // 256 vs 64

{

len2 = len1 >> 5;

while(len2 > 0) {

for(i = 0; i < 4; ++i) b64[i] = s64[i];

for(i = 0; i < 4; ++i) {

*d64 = b64[i];

++d64;

}

s64 += 4;

--len2;

}

len1 = len1 & 0x1f;

if(len1 != 0) return memcpy(d64, s64, len1);

return dst;

}

break;

case 0x04:

case 0x0c:

case 0x14:

case 0x1c: // 256 vs 32

{

uint32_t b32[8];

register uint32_t *s32 = (uint32_t *)src;

register uint32_t *d32 = (uint32_t *)dst;

len2 = len1 >> 5;

while(len2 > 0) {

for(i = 0; i < 8; ++i) b32[i] = s32[i];

*d32 = b32[0];

++d32;

*d32 = b32[1];

++d32;

*d32 = b32[2];

++d32;

*d32 = b32[3];

++d32;

*d32 = b32[4];

++d32;

*d32 = b32[5];

++d32;

*d32 = b32[6];

++d32;

*d32 = b32[7];

++d32;

s32 += 8;

--len2;

}

len1 = len1 & 0x1f;

if(len1 != 0) return memcpy(d32, s32, len1);

return dst;

}

break;

default:

return memcpy(dst, src, len1);

break;

}

}

break;

case 0x10: // Src alignn to 16.

{

uint32_t b32[4];

register uint32_t *s32 = (uint32_t *)src;

register uint32_t *d32 = (uint32_t *)dst;

switch(d_align) {

case 0: // 128 vs 256/128

case 0x10:

{

len2 = len1 >> 4;

while(len2 > 0) {

for(i = 0; i < 4; i++) b32[i] = s32[i];

for(i = 0; i < 4; i++) d32[i] = b32[i];

s32 += 4;

d32 += 4;

--len2;

}

len1 = len1 & 0x0f;

if(len1 != 0) return memcpy(d32, s32, len1);

return dst;

}

break;

case 0x08:

case 0x18: // 128 vs 64

{

len2 = len1 >> 4;

while(len2 > 0) {

for(i = 0; i < 4; ++i) b32[i] = s32[i];

for(i = 0; i < 2; ++i) {

d32[i] = b32[i];

}

d32 += 2;

for(i = 2; i < 4; ++i) {

d32[i - 2] = b32[i];

}

d32 += 2;

s32 += 4;

--len2;

}

len1 = len1 & 0x0f;

if(len1 != 0) return memcpy(d32, s32, len1);

return dst;

}

break;

case 0x04:

case 0x0c:

case 0x14:

case 0x1c: // 128 vs 32

{

len2 = len1 >> 4;

while(len2 > 0) {

for(i = 0; i < 4; ++i) b32[i] = s32[i];

*d32 = b32[0];

++d32;

*d32 = b32[1];

++d32;

*d32 = b32[2];

++d32;

*d32 = b32[3];

++d32;

s32 += 4;

--len2;

}

len1 = len1 & 0x0f;

if(len1 != 0) return memcpy(d32, s32, len1);

return dst;

}

break;

default:

return memcpy(dst, src, len1);

break;

}

}

break;

case 0x08:

case 0x18: // Src alignn to 64.

{

register uint32_t *s32 = (uint32_t *)src;

register uint32_t *d32 = (uint32_t *)dst;

register uint64_t *s64 = (uint64_t *)src;

register uint64_t *d64 = (uint64_t *)dst;

switch(d_align) {

case 0:

case 0x10: // 64 vs 128

{

uint64_t b128[2];

len2 = len1 >> 4;

while(len2 > 0) {

b128[0] = *s64;

++s64;

b128[1] = *s64;

++s64;

for(i = 0; i < 2; i++) d64[i] = b128[i];

d64 += 2;

--len2;

}

len1 = len1 & 0x0f;

if(len1 != 0) return memcpy(d64, s64, len1);

return dst;

}

break;

case 0x08:

case 0x18: // 64 vs 64

{

len2 = len1 >> 3;

while(len2 > 0) {

*d64 = *s64;

++s64;

++d64;

--len2;

}

len1 = len1 & 0x07;

if(len1 != 0) return memcpy(d64, s64, len1);

return dst;

}

break;

case 0x04:

case 0x0c: // 64 vs 32

case 0x14:

case 0x1c: // 64 vs 32

{

uint32_t b32[2];

len2 = len1 >> 3;

while(len2 > 0) {

for(i = 0; i < 2; ++i) b32[i] = s32[i];

d32[0] = b32[0];

d32[1] = b32[1];

s32 += 2;

d32 += 2;

--len2;

}

len1 = len1 & 0x07;

if(len1 != 0) return memcpy(d32, s32, len1);

return dst;

}

break;

default:

return memcpy(dst, src, len1);

break;

}

}

case 0x04:

case 0x0c:

case 0x14:

case 0x1c: // Src align 32

{

register uint32_t *s32 = (uint32_t *)src;

register uint32_t *d32 = (uint32_t *)dst;

register uint64_t *d64 = (uint64_t *)dst;

switch(d_align) {

case 0:

case 0x10: // 32 vs 128

{

uint32_t b128[4];

len2 = len1 >> 4;

while(len2 > 0) {

b128[0] = *s32;

++s32;

b128[1] = *s32;

++s32;

b128[3] = *s32;

++s32;

b128[4] = *s32;

++s32;

for(i = 0; i < 4; i++) d32[i] = b128[i];

d32 += 4;

--len2;

}

len1 = len1 & 0x0f;

if(len1 != 0) return memcpy(d32, s32, len1);

return dst;

}

break;

case 0x08:

case 0x18: // 32 vs 64

{

uint32_t b64[2];

len2 = len1 >> 3;

while(len2 > 0) {

b64[0] = *s32;

++s32;

b64[1] = *s32;

++s32;

for(i = 0; i < 2; i++) d32[i] = b64[i];

d32 += 2;

--len2;

}

len1 = len1 & 0x07;

if(len1 != 0) return memcpy(d32, s32, len1);

return dst;

}

break;

case 0x04:

case 0x0c:

case 0x14:

case 0x1c: // 32 vs 32

{

len2 = len1 >> 2;

while(len2 > 0) {

*d32 = *s32;

++s32;

++d32;

--len2;

}

len1 = len1 & 0x03;

if(len1 != 0) return memcpy(d32, s32, len1);

return dst;

}

break;

default:

return memcpy(dst, src, len1);

break;

}

}

break;

default:

if(len1 != 0) return memcpy(dst, src, len1);

break;

}

#else

// Using SIMD *with* un-aligned instructions.

register uint32_t *s32 = (uint32_t *)src;

register uint32_t *d32 = (uint32_t *)dst;

if(((s_align & 0x07) != 0x0) && ((d_align & 0x07) != 0x0)) { // None align.

return memcpy(dst, src, len);

}

if((s_align == 0x0) || (d_align == 0x0)) { // Align to 256bit

uint32_t b256[8];

len2 = len1 >> 5;

while(len2 > 0) {

for(i = 0; i < 8; i++) b256[i] = s32[i];

for(i = 0; i < 8; i++) d32[i] = b256[i];

s32 += 8;

d32 += 8;

--len2;

}

len1 = len1 & 0x1f;

if(len1 != 0) return memcpy(d32, s32, len1);

return dst;

}

if(((s_align & 0x0f) == 0x0) || ((d_align & 0x0f) == 0x0)) { // Align to 128bit

uint32_t b128[4];

len2 = len1 >> 4;

while(len2 > 0) {

for(i = 0; i < 4; i++) b128[i] = s32[i];

for(i = 0; i < 4; i++) d32[i] = b128[i];

s32 += 4;

d32 += 4;

--len2;

}

len1 = len1 & 0x0f;

if(len1 != 0) return memcpy(d32, s32, len1);

return dst;

}

if(((s_align & 0x07) == 0x0) || ((d_align & 0x07) == 0x0)) { // Align to 64bit

uint32_t b64[2];

len2 = len1 >> 3;

while(len2 > 0) {

for(i = 0; i < 2; i++) b64[i] = s32[i];

for(i = 0; i < 2; i++) d32[i] = b64[i];

s32 += 2;

d32 += 2;

--len2;

}

len1 = len1 & 0x07;

if(len1 != 0) return memcpy(d32, s32, len1);

return dst;

}

//if(len1 != 0) return memcpy(dst, src, len1);

#endif

// Trap

return dst;

}

#endif

#ifndef _WIN32

BOOL DLL_PREFIX MyWritePrivateProfileString(LPCTSTR lpAppName, LPCTSTR lpKeyName, LPCTSTR lpString, LPCTSTR lpFileName)

}

DWORD DLL_PREFIX MyGetPrivateProfileString(LPCTSTR lpAppName, LPCTSTR lpKeyName, LPCTSTR lpDefault, LPTSTR lpReturnedString, DWORD nSize, LPCTSTR lpFileName)

}

UINT DLL_PREFIX MyGetPrivateProfileInt(LPCTSTR lpAppName, LPCTSTR lpKeyName, INT nDefault, LPCTSTR lpFileName)

}

#endif

#if defined(_RGB555)

scrntype_t DLL_PREFIX RGB_COLOR(uint32_t r, uint32_t g, uint32_t b)

}

scrntype_t DLL_PREFIX RGBA_COLOR(uint32_t r, uint32_t g, uint b, uint32_t a)

{

return RGB_COLOR(r, g, b);

}

uint8_t DLL_PREFIX R_OF_COLOR(scrntype_t c)

}

uint8_t DLL_PREFIX G_OF_COLOR(scrntype_t c)

}

uint8_t DLL_PREFIX B_OF_COLOR(scrntype_t c)

}

uint8_t DLL_PREFIX A_OF_COLOR(scrntype_t c)

{

return 0;

}

#elif defined(_RGB565)

scrntype_t DLL_PREFIX RGB_COLOR(uint32_t r, uint32_t g, uint32_t b)

}

scrntype_t DLL_PREFIX RGBA_COLOR(uint32_t r, uint32_t g, uint32_t b, uint32_t a)

{

return RGB_COLOR(r, g, b);

}

uint8_t DLL_PREFIX R_OF_COLOR(scrntype_t c)

}

uint8_t DLL_PREFIX G_OF_COLOR(scrntype_t c)

}

uint8_t DLL_PREFIX B_OF_COLOR(scrntype_t c)

}

uint8_t DLL_PREFIX A_OF_COLOR(scrntype_t c)

{

return 0;

}

#endif

#ifndef _MSC_VER

struct to_upper { // Refer from documentation of libstdc++, GCC5.

char operator() (char c) const { return std::toupper(c); }

};

#endif

#if defined(_USE_QT)

static void _my_mkdir(std::string t_dir)