From 6bb8843971d104d5bda6bc0d4845e0ecc34ca257 Mon Sep 17 00:00:00 2001 From: Syping Date: Sun, 28 Nov 2021 06:25:31 +0100 Subject: [PATCH] RagePhoto: add RagePhotoPrivate class --- .github/workflows/ubuntu.yml | 4 +- .github/workflows/windows.yml | 4 +- src/RagePhoto.cpp | 490 +++++++++++++++++----------------- src/RagePhoto.h | 11 +- src/RagePhotoData.h | 5 +- src/RagePhoto_p.h | 31 +++ 6 files changed, 289 insertions(+), 256 deletions(-) create mode 100644 src/RagePhoto_p.h diff --git a/.github/workflows/ubuntu.yml b/.github/workflows/ubuntu.yml index a830de8..a19215f 100644 --- a/.github/workflows/ubuntu.yml +++ b/.github/workflows/ubuntu.yml @@ -2,9 +2,9 @@ name: Ubuntu on: push: - branches: [ master ] + branches: [ test ] pull_request: - branches: [ master ] + branches: [ test ] env: BUILD_TYPE: Release diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml index 351964d..cd11735 100644 --- a/.github/workflows/windows.yml +++ b/.github/workflows/windows.yml @@ -2,9 +2,9 @@ name: Windows on: push: - branches: [ master ] + branches: [ test ] pull_request: - branches: [ master ] + branches: [ test ] env: BUILD_TYPE: Release diff --git a/src/RagePhoto.cpp b/src/RagePhoto.cpp index 3993ada..7d288bd 100644 --- a/src/RagePhoto.cpp +++ b/src/RagePhoto.cpp @@ -17,15 +17,16 @@ *****************************************************************************/ #include "RagePhoto.h" +#include "RagePhoto_p.h" #ifdef LIBRAGEPHOTO_C_API #include "RagePhotoC.h" #endif +#include +#include #include #include #include -#include -#include #ifdef RAGEPHOTO_BENCHMARK #include @@ -86,33 +87,34 @@ inline void uInt32ToCharLE(uint32_t x, char *y) /* END OF STATIC LIBRARY FUNCTIONS */ /* BEGIN OF RAGEPHOTO CLASS */ -RagePhoto::RagePhoto() +RagePhoto::RagePhoto() : m_rpp(new RagePhotoPrivate) { - m_data.photoLoaded = false; - m_data.photoData = nullptr; + m_rpp->m_data.photoLoaded = false; + m_rpp->m_data.photoData = nullptr; setBufferDefault(); } RagePhoto::~RagePhoto() { - std::free(m_data.photoData); + std::free(m_rpp->m_data.photoData); + delete m_rpp; } void RagePhoto::clear() { - if (m_data.photoLoaded) { - std::free(m_data.photoData); - m_data.photoData = nullptr; - m_data.photoLoaded = false; + if (m_rpp->m_data.photoLoaded) { + std::free(m_rpp->m_data.photoData); + m_rpp->m_data.photoData = nullptr; + m_rpp->m_data.photoLoaded = false; } - m_data.description.clear(); - m_data.json.clear(); - m_data.header.clear(); - m_data.title.clear(); - m_data.error = 0U; - m_data.photoFormat = 0UL; - m_data.unnamedSum1 = 0UL; - m_data.unnamedSum2 = 0UL; + m_rpp->m_data.description.clear(); + m_rpp->m_data.json.clear(); + m_rpp->m_data.header.clear(); + m_rpp->m_data.title.clear(); + m_rpp->m_data.error = 0U; + m_rpp->m_data.photoFormat = 0UL; + m_rpp->m_data.unnamedSum1 = 0UL; + m_rpp->m_data.unnamedSum2 = 0UL; setBufferDefault(); } @@ -129,35 +131,35 @@ bool RagePhoto::load(const char *data, size_t length) char uInt32Buffer[4]; size_t size = readBuffer(data, uInt32Buffer, &pos, 4, length); if (size != 4) { - m_data.error = static_cast(Error::NoFormatIdentifier); // 1 + m_rpp->m_data.error = static_cast(Error::NoFormatIdentifier); // 1 return false; } #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(&m_data.photoFormat, uInt32Buffer, 4); + std::memcpy(&m_rpp->m_data.photoFormat, uInt32Buffer, 4); #else - m_data.photoFormat = charToUInt32LE(uInt32Buffer); + m_rpp->m_data.photoFormat = charToUInt32LE(uInt32Buffer); #endif - if (m_data.photoFormat == PhotoFormat::GTA5 || m_data.photoFormat == PhotoFormat::RDR2) { + if (m_rpp->m_data.photoFormat == PhotoFormat::GTA5 || m_rpp->m_data.photoFormat == PhotoFormat::RDR2) { #if defined UNICODE_ICONV || defined UNICODE_CODECVT || defined UNICODE_WINCVT char photoHeader[256]; size = readBuffer(data, photoHeader, &pos, 256, length); if (size != 256) { - m_data.error = static_cast(Error::IncompleteHeader); // 3 + m_rpp->m_data.error = static_cast(Error::IncompleteHeader); // 3 return false; } #if defined UNICODE_CODECVT std::wstring_convert,char16_t> convert; - m_data.header = convert.to_bytes(reinterpret_cast(photoHeader)); + m_rpp->m_data.header = convert.to_bytes(reinterpret_cast(photoHeader)); if (convert.converted() == 0) { - m_data.error = static_cast(Error::UnicodeHeaderError); // 5 + m_rpp->m_data.error = static_cast(Error::UnicodeHeaderError); // 5 return false; } #elif defined UNICODE_ICONV iconv_t iconv_in = iconv_open("UTF-8", "UTF-16LE"); if (iconv_in == (iconv_t)-1) { - m_data.error = static_cast(Error::UnicodeInitError); // 4 + m_rpp->m_data.error = static_cast(Error::UnicodeInitError); // 4 return false; } char photoHeader_string[256]; @@ -168,262 +170,262 @@ bool RagePhoto::load(const char *data, size_t length) const size_t ret = iconv(iconv_in, &src, &src_s, &dst, &dst_s); iconv_close(iconv_in); if (ret == static_cast(-1)) { - m_data.error = static_cast(Error::UnicodeHeaderError); // 5 + m_rpp->m_data.error = static_cast(Error::UnicodeHeaderError); // 5 return false; } - m_data.header = std::string(photoHeader_string); + m_rpp->m_data.header = std::string(photoHeader_string); #elif defined UNICODE_WINCVT char photoHeader_string[256]; const int converted = WideCharToMultiByte(CP_UTF8, 0, reinterpret_cast(photoHeader), -1, photoHeader_string, 256, NULL, NULL); if (converted == 0) { - m_data.error = static_cast(Error::UnicodeHeaderError); // 5 + m_rpp->m_data.error = static_cast(Error::UnicodeHeaderError); // 5 return false; } - m_data.header = std::string(photoHeader_string); + m_rpp->m_data.header = std::string(photoHeader_string); #endif size = readBuffer(data, uInt32Buffer, &pos, 4, length); if (size != 4) { - m_data.error = static_cast(Error::IncompleteChecksum); // 6 + m_rpp->m_data.error = static_cast(Error::IncompleteChecksum); // 6 return false; } #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(&m_data.headerSum, uInt32Buffer, 4); + std::memcpy(&m_rpp->m_data.headerSum, uInt32Buffer, 4); #else - m_data.headerSum = charToUInt32LE(uInt32Buffer); + m_rpp->m_data.headerSum = charToUInt32LE(uInt32Buffer); #endif - if (m_data.photoFormat == PhotoFormat::RDR2) { + if (m_rpp->m_data.photoFormat == PhotoFormat::RDR2) { size = readBuffer(data, uInt32Buffer, &pos, 4, length); if (size != 4) { - m_data.error = static_cast(Error::IncompleteChecksum); // 6 + m_rpp->m_data.error = static_cast(Error::IncompleteChecksum); // 6 return false; } #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(&m_data.unnamedSum1, uInt32Buffer, 4); + std::memcpy(&m_rpp->m_data.unnamedSum1, uInt32Buffer, 4); #else - m_data.unnamedSum1 = charToUInt32LE(uInt32Buffer); + m_rpp->m_data.unnamedSum1 = charToUInt32LE(uInt32Buffer); #endif size = readBuffer(data, uInt32Buffer, &pos, 4, length); if (size != 4) { - m_data.error = static_cast(Error::IncompleteChecksum); // 6 + m_rpp->m_data.error = static_cast(Error::IncompleteChecksum); // 6 return false; } #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(&m_data.unnamedSum2, uInt32Buffer, 4); + std::memcpy(&m_rpp->m_data.unnamedSum2, uInt32Buffer, 4); #else - m_data.unnamedSum2 = charToUInt32LE(uInt32Buffer); + m_rpp->m_data.unnamedSum2 = charToUInt32LE(uInt32Buffer); #endif } const size_t headerSize = pos; size = readBuffer(data, uInt32Buffer, &pos, 4, length); if (size != 4) { - m_data.error = static_cast(Error::IncompleteEOF); // 7 + m_rpp->m_data.error = static_cast(Error::IncompleteEOF); // 7 return false; } #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(&m_data.endOfFile, uInt32Buffer, 4); + std::memcpy(&m_rpp->m_data.endOfFile, uInt32Buffer, 4); #else - m_data.endOfFile = charToUInt32LE(uInt32Buffer); + m_rpp->m_data.endOfFile = charToUInt32LE(uInt32Buffer); #endif size = readBuffer(data, uInt32Buffer, &pos, 4, length); if (size != 4) { - m_data.error = static_cast(Error::IncompleteJsonOffset); // 8 + m_rpp->m_data.error = static_cast(Error::IncompleteJsonOffset); // 8 return false; } #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(&m_data.jsonOffset, uInt32Buffer, 4); + std::memcpy(&m_rpp->m_data.jsonOffset, uInt32Buffer, 4); #else - m_data.jsonOffset = charToUInt32LE(uInt32Buffer); + m_rpp->m_data.jsonOffset = charToUInt32LE(uInt32Buffer); #endif size = readBuffer(data, uInt32Buffer, &pos, 4, length); if (size != 4) { - m_data.error = static_cast(Error::IncompleteTitleOffset); // 9 + m_rpp->m_data.error = static_cast(Error::IncompleteTitleOffset); // 9 return false; } #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(&m_data.titlOffset, uInt32Buffer, 4); + std::memcpy(&m_rpp->m_data.titlOffset, uInt32Buffer, 4); #else - m_data.titlOffset = charToUInt32LE(uInt32Buffer); + m_rpp->m_data.titlOffset = charToUInt32LE(uInt32Buffer); #endif size = readBuffer(data, uInt32Buffer, &pos, 4, length); if (size != 4) { - m_data.error = static_cast(Error::IncompleteDescOffset); // 10 + m_rpp->m_data.error = static_cast(Error::IncompleteDescOffset); // 10 return false; } #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(&m_data.descOffset, uInt32Buffer, 4); + std::memcpy(&m_rpp->m_data.descOffset, uInt32Buffer, 4); #else - m_data.descOffset = charToUInt32LE(uInt32Buffer); + m_rpp->m_data.descOffset = charToUInt32LE(uInt32Buffer); #endif char markerBuffer[4]; size = readBuffer(data, markerBuffer, &pos, 4, length); if (size != 4) { - m_data.error = static_cast(Error::IncompleteJpegMarker); // 11 + m_rpp->m_data.error = static_cast(Error::IncompleteJpegMarker); // 11 return false; } if (strncmp(markerBuffer, "JPEG", 4) != 0) { - m_data.error = static_cast(Error::IncorrectJpegMarker); // 12 + m_rpp->m_data.error = static_cast(Error::IncorrectJpegMarker); // 12 return false; } size = readBuffer(data, uInt32Buffer, &pos, 4, length); if (size != 4) { - m_data.error = static_cast(Error::IncompletePhotoBuffer); // 13 + m_rpp->m_data.error = static_cast(Error::IncompletePhotoBuffer); // 13 return false; } #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(&m_data.photoBuffer, uInt32Buffer, 4); + std::memcpy(&m_rpp->m_data.photoBuffer, uInt32Buffer, 4); #else - m_data.photoBuffer = charToUInt32LE(uInt32Buffer); + m_rpp->m_data.photoBuffer = charToUInt32LE(uInt32Buffer); #endif size = readBuffer(data, uInt32Buffer, &pos, 4, length); if (size != 4) { - m_data.error = static_cast(Error::IncompletePhotoSize); // 14 + m_rpp->m_data.error = static_cast(Error::IncompletePhotoSize); // 14 return false; } #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(&m_data.photoSize, uInt32Buffer, 4); + std::memcpy(&m_rpp->m_data.photoSize, uInt32Buffer, 4); #else - m_data.photoSize = charToUInt32LE(uInt32Buffer); + m_rpp->m_data.photoSize = charToUInt32LE(uInt32Buffer); #endif - m_data.photoData = static_cast(std::malloc(m_data.photoSize)); - if (!m_data.photoData) { - m_data.error = static_cast(Error::PhotoMallocError); // 15 + m_rpp->m_data.photoData = static_cast(std::malloc(m_rpp->m_data.photoSize)); + if (!m_rpp->m_data.photoData) { + m_rpp->m_data.error = static_cast(Error::PhotoMallocError); // 15 return false; } - size = readBuffer(data, m_data.photoData, &pos, m_data.photoSize, length); - if (size != m_data.photoSize) { - std::free(m_data.photoData); - m_data.photoData = nullptr; - m_data.error = static_cast(Error::PhotoReadError); // 16 + size = readBuffer(data, m_rpp->m_data.photoData, &pos, m_rpp->m_data.photoSize, length); + if (size != m_rpp->m_data.photoSize) { + std::free(m_rpp->m_data.photoData); + m_rpp->m_data.photoData = nullptr; + m_rpp->m_data.error = static_cast(Error::PhotoReadError); // 16 return false; } - m_data.photoLoaded = true; + m_rpp->m_data.photoLoaded = true; - pos = m_data.jsonOffset + headerSize; + pos = m_rpp->m_data.jsonOffset + headerSize; size = readBuffer(data, markerBuffer, &pos, 4, length); if (size != 4) { - m_data.error = static_cast(Error::IncompleteJsonMarker); // 17 + m_rpp->m_data.error = static_cast(Error::IncompleteJsonMarker); // 17 return false; } if (strncmp(markerBuffer, "JSON", 4) != 0) { - m_data.error = static_cast(Error::IncorrectJsonMarker); // 18 + m_rpp->m_data.error = static_cast(Error::IncorrectJsonMarker); // 18 return false; } size = readBuffer(data, uInt32Buffer, &pos, 4, length); if (size != 4) { - m_data.error = static_cast(Error::IncompleteJsonBuffer); // 19 + m_rpp->m_data.error = static_cast(Error::IncompleteJsonBuffer); // 19 return false; } #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(&m_data.jsonBuffer, uInt32Buffer, 4); + std::memcpy(&m_rpp->m_data.jsonBuffer, uInt32Buffer, 4); #else - m_data.jsonBuffer = charToUInt32LE(uInt32Buffer); + m_rpp->m_data.jsonBuffer = charToUInt32LE(uInt32Buffer); #endif - char *t_jsonData = static_cast(std::malloc(m_data.jsonBuffer)); + char *t_jsonData = static_cast(std::malloc(m_rpp->m_data.jsonBuffer)); if (!t_jsonData) { - m_data.error = static_cast(Error::JsonMallocError); // 20 + m_rpp->m_data.error = static_cast(Error::JsonMallocError); // 20 return false; } - size = readBuffer(data, t_jsonData, &pos, m_data.jsonBuffer, length); - if (size != m_data.jsonBuffer) { + size = readBuffer(data, t_jsonData, &pos, m_rpp->m_data.jsonBuffer, length); + if (size != m_rpp->m_data.jsonBuffer) { std::free(t_jsonData); - m_data.error = static_cast(Error::JsonReadError); // 21 + m_rpp->m_data.error = static_cast(Error::JsonReadError); // 21 return false; } - m_data.json = std::string(t_jsonData); + m_rpp->m_data.json = std::string(t_jsonData); std::free(t_jsonData); - pos = m_data.titlOffset + headerSize; + pos = m_rpp->m_data.titlOffset + headerSize; size = readBuffer(data, markerBuffer, &pos, 4, length); if (size != 4) { - m_data.error = static_cast(Error::IncompleteTitleMarker); // 22 + m_rpp->m_data.error = static_cast(Error::IncompleteTitleMarker); // 22 return false; } if (strncmp(markerBuffer, "TITL", 4) != 0) { - m_data.error = static_cast(Error::IncorrectTitleMarker); // 23 + m_rpp->m_data.error = static_cast(Error::IncorrectTitleMarker); // 23 return false; } size = readBuffer(data, uInt32Buffer, &pos, 4, length); if (size != 4) { - m_data.error = static_cast(Error::IncompleteTitleBuffer); // 24 + m_rpp->m_data.error = static_cast(Error::IncompleteTitleBuffer); // 24 return false; } #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(&m_data.titlBuffer, uInt32Buffer, 4); + std::memcpy(&m_rpp->m_data.titlBuffer, uInt32Buffer, 4); #else - m_data.titlBuffer = charToUInt32LE(uInt32Buffer); + m_rpp->m_data.titlBuffer = charToUInt32LE(uInt32Buffer); #endif - char *t_titlData = static_cast(std::malloc(m_data.titlBuffer)); + char *t_titlData = static_cast(std::malloc(m_rpp->m_data.titlBuffer)); if (!t_titlData) { - m_data.error = static_cast(Error::TitleMallocError); // 25 + m_rpp->m_data.error = static_cast(Error::TitleMallocError); // 25 return false; } - size = readBuffer(data, t_titlData, &pos, m_data.titlBuffer, length); - if (size != m_data.titlBuffer) { + size = readBuffer(data, t_titlData, &pos, m_rpp->m_data.titlBuffer, length); + if (size != m_rpp->m_data.titlBuffer) { std::free(t_titlData); - m_data.error = static_cast(Error::TitleReadError); // 26 + m_rpp->m_data.error = static_cast(Error::TitleReadError); // 26 return false; } - m_data.title = std::string(t_titlData); + m_rpp->m_data.title = std::string(t_titlData); std::free(t_titlData); - pos = m_data.descOffset + headerSize; + pos = m_rpp->m_data.descOffset + headerSize; size = readBuffer(data, markerBuffer, &pos, 4, length); if (size != 4) { - m_data.error = static_cast(Error::IncompleteDescMarker); // 27 + m_rpp->m_data.error = static_cast(Error::IncompleteDescMarker); // 27 return false; } if (strncmp(markerBuffer, "DESC", 4) != 0) { - m_data.error = static_cast(Error::IncorrectDescMarker); // 28 + m_rpp->m_data.error = static_cast(Error::IncorrectDescMarker); // 28 return false; } size = readBuffer(data, uInt32Buffer, &pos, 4, length); if (size != 4) { - m_data.error = static_cast(Error::IncompleteDescBuffer); // 29 + m_rpp->m_data.error = static_cast(Error::IncompleteDescBuffer); // 29 return false; } #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(&m_data.descBuffer, uInt32Buffer, 4); + std::memcpy(&m_rpp->m_data.descBuffer, uInt32Buffer, 4); #else - m_data.descBuffer = charToUInt32LE(uInt32Buffer); + m_rpp->m_data.descBuffer = charToUInt32LE(uInt32Buffer); #endif - char *t_descData = static_cast(std::malloc(m_data.descBuffer)); + char *t_descData = static_cast(std::malloc(m_rpp->m_data.descBuffer)); if (!t_descData) { - m_data.error = static_cast(Error::DescMallocError); // 30 + m_rpp->m_data.error = static_cast(Error::DescMallocError); // 30 return false; } - size = readBuffer(data, t_descData, &pos, m_data.descBuffer, length); - if (size != m_data.descBuffer) { + size = readBuffer(data, t_descData, &pos, m_rpp->m_data.descBuffer, length); + if (size != m_rpp->m_data.descBuffer) { std::free(t_descData); - m_data.error = static_cast(Error::DescReadError); // 31 + m_rpp->m_data.error = static_cast(Error::DescReadError); // 31 return false; } - m_data.description = std::string(t_descData); + m_rpp->m_data.description = std::string(t_descData); std::free(t_descData); - pos = m_data.endOfFile + headerSize - 4; + pos = m_rpp->m_data.endOfFile + headerSize - 4; size = readBuffer(data, markerBuffer, &pos, 4, length); if (size != 4) { - m_data.error = static_cast(Error::IncompleteJendMarker); // 32 + m_rpp->m_data.error = static_cast(Error::IncompleteJendMarker); // 32 return false; } if (strncmp(markerBuffer, "JEND", 4) != 0) { - m_data.error = static_cast(Error::IncorrectJendMarker); // 33 + m_rpp->m_data.error = static_cast(Error::IncorrectJendMarker); // 33 return false; } @@ -434,42 +436,42 @@ bool RagePhoto::load(const char *data, size_t length) #endif #ifdef RAGEPHOTO_DEBUG - std::cout << "header: " << m_data.header << std::endl; - std::cout << "headerSum: " << m_data.headerSum << std::endl; - std::cout << "unnamedSum1: " << m_data.unnamedSum1 << std::endl; - std::cout << "unnamedSum2: " << m_data.unnamedSum2 << std::endl; - std::cout << "photoBuffer: " << m_data.photoBuffer << std::endl; - std::cout << "descBuffer: " << m_data.descBuffer << std::endl; - std::cout << "descOffset: " << m_data.descOffset << std::endl; - std::cout << "jsonBuffer: " << m_data.jsonBuffer << std::endl; - std::cout << "jsonOffset: " << m_data.jsonOffset << std::endl; - std::cout << "titlBuffer: " << m_data.titlBuffer << std::endl; - std::cout << "titlOffset: " << m_data.titlOffset << std::endl; - std::cout << "eofOffset: " << m_data.endOfFile << std::endl; + std::cout << "header: " << m_rpp->m_data.header << std::endl; + std::cout << "headerSum: " << m_rpp->m_data.headerSum << std::endl; + std::cout << "unnamedSum1: " << m_rpp->m_data.unnamedSum1 << std::endl; + std::cout << "unnamedSum2: " << m_rpp->m_data.unnamedSum2 << std::endl; + std::cout << "photoBuffer: " << m_rpp->m_data.photoBuffer << std::endl; + std::cout << "descBuffer: " << m_rpp->m_data.descBuffer << std::endl; + std::cout << "descOffset: " << m_rpp->m_data.descOffset << std::endl; + std::cout << "jsonBuffer: " << m_rpp->m_data.jsonBuffer << std::endl; + std::cout << "jsonOffset: " << m_rpp->m_data.jsonOffset << std::endl; + std::cout << "titlBuffer: " << m_rpp->m_data.titlBuffer << std::endl; + std::cout << "titlOffset: " << m_rpp->m_data.titlOffset << std::endl; + std::cout << "eofOffset: " << m_rpp->m_data.endOfFile << std::endl; std::cout << "setBufferOffsets()" << std::endl; setBufferOffsets(); - std::cout << "descOffset: " << m_data.descOffset << std::endl; - std::cout << "jsonOffset: " << m_data.jsonOffset << std::endl; - std::cout << "titlOffset: " << m_data.titlOffset << std::endl; - std::cout << "eofOffset: " << m_data.endOfFile << std::endl; + std::cout << "descOffset: " << m_rpp->m_data.descOffset << std::endl; + std::cout << "jsonOffset: " << m_rpp->m_data.jsonOffset << std::endl; + std::cout << "titlOffset: " << m_rpp->m_data.titlOffset << std::endl; + std::cout << "eofOffset: " << m_rpp->m_data.endOfFile << std::endl; std::cout << "calc size: " << saveSize() << std::endl; std::cout << "real size: " << length << std::endl; #endif - m_data.error = static_cast(Error::NoError); // 255 + m_rpp->m_data.error = static_cast(Error::NoError); // 255 return true; #else std::cout << "UTF-16LE decoding support missing" << std::endl; - m_data.error = static_cast(Error::UnicodeInitError); // 4 + m_rpp->m_data.error = static_cast(Error::UnicodeInitError); // 4 return false; #endif } else { - auto it = m_loadFuncs.find(m_data.photoFormat); - if (it != m_loadFuncs.end()) - return it->second(data, length, &m_data); + auto it = m_rpp->m_loadFuncs.find(m_rpp->m_data.photoFormat); + if (it != m_rpp->m_loadFuncs.end()) + return it->second(data, length, &m_rpp->m_data); } - m_data.error = static_cast(Error::IncompatibleFormat); // 2 + m_rpp->m_data.error = static_cast(Error::IncompatibleFormat); // 2 return false; } @@ -487,63 +489,63 @@ bool RagePhoto::loadFile(const std::string &filename) return load(sdata); } else { - m_data.error = static_cast(Error::Uninitialised); // 0 + m_rpp->m_data.error = static_cast(Error::Uninitialised); // 0 return false; } } RagePhoto::Error RagePhoto::error() const { - return static_cast(m_data.error); + return static_cast(m_rpp->m_data.error); } uint32_t RagePhoto::format() const { - return m_data.photoFormat; + return m_rpp->m_data.photoFormat; } const std::string RagePhoto::photo() const { - if (m_data.photoLoaded) - return std::string(m_data.photoData, m_data.photoSize); + if (m_rpp->m_data.photoLoaded) + return std::string(m_rpp->m_data.photoData, m_rpp->m_data.photoSize); else return std::string(); } const char* RagePhoto::photoData() const { - if (m_data.photoLoaded) - return m_data.photoData; + if (m_rpp->m_data.photoLoaded) + return m_rpp->m_data.photoData; else return nullptr; } uint32_t RagePhoto::photoSize() const { - if (m_data.photoLoaded) - return m_data.photoSize; + if (m_rpp->m_data.photoLoaded) + return m_rpp->m_data.photoSize; else return 0UL; } const std::string& RagePhoto::description() const { - return m_data.description; + return m_rpp->m_data.description; } const std::string& RagePhoto::json() const { - return m_data.json; + return m_rpp->m_data.json; } const std::string& RagePhoto::header() const { - return m_data.header; + return m_rpp->m_data.header; } const std::string& RagePhoto::title() const { - return m_data.title; + return m_rpp->m_data.title; } const char* RagePhoto::version() @@ -557,67 +559,67 @@ bool RagePhoto::save(char *data, uint32_t photoFormat) #if defined UNICODE_ICONV || defined UNICODE_CODECVT || defined UNICODE_WINCVT #if defined UNICODE_CODECVT std::wstring_convert,char16_t> convert; - std::u16string photoHeader_string = convert.from_bytes(m_data.header); + std::u16string photoHeader_string = convert.from_bytes(m_rpp->m_data.header); if (convert.converted() == 0) { - m_data.error = static_cast(Error::UnicodeHeaderError); // 5 + m_rpp->m_data.error = static_cast(Error::UnicodeHeaderError); // 5 return false; } const size_t photoHeader_size = photoHeader_string.size() * 2; if (photoHeader_size > 256) { - m_data.error = static_cast(Error::HeaderBufferTight); // 34 + m_rpp->m_data.error = static_cast(Error::HeaderBufferTight); // 34 return false; } const char *photoHeader = reinterpret_cast(photoHeader_string.data()); #elif defined UNICODE_ICONV iconv_t iconv_in = iconv_open("UTF-16LE", "UTF-8"); if (iconv_in == (iconv_t)-1) { - m_data.error = static_cast(Error::UnicodeInitError); // 4 + m_rpp->m_data.error = static_cast(Error::UnicodeInitError); // 4 return false; } char photoHeader_string[256]; - std::memcpy(photoHeader_string, m_data.header.data(), m_data.header.size()); + std::memcpy(photoHeader_string, m_rpp->m_data.header.data(), m_rpp->m_data.header.size()); char photoHeader[256]{}; - size_t src_s = m_data.header.size(); + size_t src_s = m_rpp->m_data.header.size(); size_t dst_s = sizeof(photoHeader); char *src = photoHeader_string; char *dst = photoHeader; const size_t ret = iconv(iconv_in, &src, &src_s, &dst, &dst_s); iconv_close(iconv_in); if (ret == static_cast(-1)) { - m_data.error = static_cast(Error::UnicodeHeaderError); // 5 + m_rpp->m_data.error = static_cast(Error::UnicodeHeaderError); // 5 return false; } const size_t photoHeader_size = 256; #elif defined UNICODE_WINCVT char photoHeader[256]{}; - const int converted = MultiByteToWideChar(CP_UTF8, 0, m_data.header.data(), m_data.header.size(), reinterpret_cast(photoHeader), 256 / sizeof(wchar_t)); + const int converted = MultiByteToWideChar(CP_UTF8, 0, m_rpp->m_data.header.data(), m_rpp->m_data.header.size(), reinterpret_cast(photoHeader), 256 / sizeof(wchar_t)); if (converted == 0) { - m_data.error = static_cast(Error::UnicodeHeaderError); // 5 + m_rpp->m_data.error = static_cast(Error::UnicodeHeaderError); // 5 return false; } const size_t photoHeader_size = 256; #endif - if (m_data.photoSize > m_data.photoBuffer) { - m_data.error = static_cast(Error::PhotoBufferTight); // 35 + if (m_rpp->m_data.photoSize > m_rpp->m_data.photoBuffer) { + m_rpp->m_data.error = static_cast(Error::PhotoBufferTight); // 35 return false; } - const size_t jsonString_size = m_data.json.size() + 1; - if (jsonString_size > m_data.jsonBuffer) { - m_data.error = static_cast(Error::JsonBufferTight); // 36 + const size_t jsonString_size = m_rpp->m_data.json.size() + 1; + if (jsonString_size > m_rpp->m_data.jsonBuffer) { + m_rpp->m_data.error = static_cast(Error::JsonBufferTight); // 36 return false; } - const size_t titlString_size = m_data.title.size() + 1; - if (titlString_size > m_data.titlBuffer) { - m_data.error = static_cast(Error::TitleBufferTight); // 37 + const size_t titlString_size = m_rpp->m_data.title.size() + 1; + if (titlString_size > m_rpp->m_data.titlBuffer) { + m_rpp->m_data.error = static_cast(Error::TitleBufferTight); // 37 return false; } - const size_t descString_size = m_data.description.size() + 1; - if (descString_size > m_data.descBuffer) { - m_data.error = static_cast(Error::DescBufferTight); // 38 + const size_t descString_size = m_rpp->m_data.description.size() + 1; + if (descString_size > m_rpp->m_data.descBuffer) { + m_rpp->m_data.error = static_cast(Error::DescBufferTight); // 38 return false; } @@ -638,142 +640,142 @@ bool RagePhoto::save(char *data, uint32_t photoFormat) } #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(uInt32Buffer, &m_data.headerSum, 4); + std::memcpy(uInt32Buffer, &m_rpp->m_data.headerSum, 4); #else - uInt32ToCharLE(m_data.headerSum, uInt32Buffer); + uInt32ToCharLE(m_rpp->m_data.headerSum, uInt32Buffer); #endif writeBuffer(uInt32Buffer, data, &pos, length, 4); if (photoFormat == PhotoFormat::RDR2) { #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(uInt32Buffer, &m_data.unnamedSum1, 4); + std::memcpy(uInt32Buffer, &m_rpp->m_data.unnamedSum1, 4); #else - uInt32ToCharLE(m_data.unnamedSum1, uInt32Buffer); + uInt32ToCharLE(m_rpp->m_data.unnamedSum1, uInt32Buffer); #endif writeBuffer(uInt32Buffer, data, &pos, length, 4); #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(uInt32Buffer, &m_data.unnamedSum2, 4); + std::memcpy(uInt32Buffer, &m_rpp->m_data.unnamedSum2, 4); #else - uInt32ToCharLE(m_data.unnamedSum2, uInt32Buffer); + uInt32ToCharLE(m_rpp->m_data.unnamedSum2, uInt32Buffer); #endif writeBuffer(uInt32Buffer, data, &pos, length, 4); } const size_t headerSize = pos; #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(uInt32Buffer, &m_data.endOfFile, 4); + std::memcpy(uInt32Buffer, &m_rpp->m_data.endOfFile, 4); #else - uInt32ToCharLE(m_data.endOfFile, uInt32Buffer); + uInt32ToCharLE(m_rpp->m_data.endOfFile, uInt32Buffer); #endif writeBuffer(uInt32Buffer, data, &pos, length, 4); #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(uInt32Buffer, &m_data.jsonOffset, 4); + std::memcpy(uInt32Buffer, &m_rpp->m_data.jsonOffset, 4); #else - uInt32ToCharLE(m_data.jsonOffset, uInt32Buffer); + uInt32ToCharLE(m_rpp->m_data.jsonOffset, uInt32Buffer); #endif writeBuffer(uInt32Buffer, data, &pos, length, 4); #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(uInt32Buffer, &m_data.titlOffset, 4); + std::memcpy(uInt32Buffer, &m_rpp->m_data.titlOffset, 4); #else - uInt32ToCharLE(m_data.titlOffset, uInt32Buffer); + uInt32ToCharLE(m_rpp->m_data.titlOffset, uInt32Buffer); #endif writeBuffer(uInt32Buffer, data, &pos, length, 4); #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(uInt32Buffer, &m_data.descOffset, 4); + std::memcpy(uInt32Buffer, &m_rpp->m_data.descOffset, 4); #else - uInt32ToCharLE(m_data.descOffset, uInt32Buffer); + uInt32ToCharLE(m_rpp->m_data.descOffset, uInt32Buffer); #endif writeBuffer(uInt32Buffer, data, &pos, length, 4); writeBuffer("JPEG", data, &pos, length, 4); #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(uInt32Buffer, &m_data.photoBuffer, 4); + std::memcpy(uInt32Buffer, &m_rpp->m_data.photoBuffer, 4); #else - uInt32ToCharLE(m_data.photoBuffer, uInt32Buffer); + uInt32ToCharLE(m_rpp->m_data.photoBuffer, uInt32Buffer); #endif writeBuffer(uInt32Buffer, data, &pos, length, 4); #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(uInt32Buffer, &m_data.photoSize, 4); + std::memcpy(uInt32Buffer, &m_rpp->m_data.photoSize, 4); #else - uInt32ToCharLE(m_data.photoSize, uInt32Buffer); + uInt32ToCharLE(m_rpp->m_data.photoSize, uInt32Buffer); #endif writeBuffer(uInt32Buffer, data, &pos, length, 4); - writeBuffer(m_data.photoData, data, &pos, length, m_data.photoSize); - for (size_t i = m_data.photoSize; i < m_data.photoBuffer; i++) { + writeBuffer(m_rpp->m_data.photoData, data, &pos, length, m_rpp->m_data.photoSize); + for (size_t i = m_rpp->m_data.photoSize; i < m_rpp->m_data.photoBuffer; i++) { writeBuffer("\0", data, &pos, length, 1); } - pos = m_data.jsonOffset + headerSize; + pos = m_rpp->m_data.jsonOffset + headerSize; writeBuffer("JSON", data, &pos, length, 4); #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(uInt32Buffer, &m_data.jsonBuffer, 4); + std::memcpy(uInt32Buffer, &m_rpp->m_data.jsonBuffer, 4); #else - uInt32ToCharLE(m_data.jsonBuffer, uInt32Buffer); + uInt32ToCharLE(m_rpp->m_data.jsonBuffer, uInt32Buffer); #endif writeBuffer(uInt32Buffer, data, &pos, length, 4); - writeBuffer(m_data.json.c_str(), data, &pos, length, jsonString_size); - for (size_t i = jsonString_size; i < m_data.jsonBuffer; i++) { + writeBuffer(m_rpp->m_data.json.c_str(), data, &pos, length, jsonString_size); + for (size_t i = jsonString_size; i < m_rpp->m_data.jsonBuffer; i++) { writeBuffer("\0", data, &pos, length, 1); } - pos = m_data.titlOffset + headerSize; + pos = m_rpp->m_data.titlOffset + headerSize; writeBuffer("TITL", data, &pos, length, 4); #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(uInt32Buffer, &m_data.titlBuffer, 4); + std::memcpy(uInt32Buffer, &m_rpp->m_data.titlBuffer, 4); #else - uInt32ToCharLE(m_data.titlBuffer, uInt32Buffer); + uInt32ToCharLE(m_rpp->m_data.titlBuffer, uInt32Buffer); #endif writeBuffer(uInt32Buffer, data, &pos, length, 4); - writeBuffer(m_data.title.c_str(), data, &pos, length, titlString_size); - for (size_t i = titlString_size; i < m_data.titlBuffer; i++) { + writeBuffer(m_rpp->m_data.title.c_str(), data, &pos, length, titlString_size); + for (size_t i = titlString_size; i < m_rpp->m_data.titlBuffer; i++) { writeBuffer("\0", data, &pos, length, 1); } - pos = m_data.descOffset + headerSize; + pos = m_rpp->m_data.descOffset + headerSize; writeBuffer("DESC", data, &pos, length, 4); #if __BYTE_ORDER == __LITTLE_ENDIAN - std::memcpy(uInt32Buffer, &m_data.descBuffer, 4); + std::memcpy(uInt32Buffer, &m_rpp->m_data.descBuffer, 4); #else - uInt32ToCharLE(m_data.descBuffer, uInt32Buffer); + uInt32ToCharLE(m_rpp->m_data.descBuffer, uInt32Buffer); #endif writeBuffer(uInt32Buffer, data, &pos, length, 4); - writeBuffer(m_data.description.c_str(), data, &pos, length, descString_size); - for (size_t i = descString_size; i < m_data.descBuffer; i++) { + writeBuffer(m_rpp->m_data.description.c_str(), data, &pos, length, descString_size); + for (size_t i = descString_size; i < m_rpp->m_data.descBuffer; i++) { writeBuffer("\0", data, &pos, length, 1); } - pos = m_data.endOfFile + headerSize - 4; + pos = m_rpp->m_data.endOfFile + headerSize - 4; writeBuffer("JEND", data, &pos, length, 4); - m_data.error = static_cast(Error::NoError); // 255 + m_rpp->m_data.error = static_cast(Error::NoError); // 255 return true; #else std::cout << "UTF-16LE encoding support missing" << std::endl; - m_data.error = static_cast(Error::UnicodeInitError); // 4 + m_rpp->m_data.error = static_cast(Error::UnicodeInitError); // 4 return false; #endif } - m_data.error = static_cast(Error::IncompatibleFormat); // 2 + m_rpp->m_data.error = static_cast(Error::IncompatibleFormat); // 2 return false; } bool RagePhoto::save(char *data) { - return save(data, m_data.photoFormat); + return save(data, m_rpp->m_data.photoFormat); } const std::string RagePhoto::save(uint32_t photoFormat, bool *ok) @@ -794,7 +796,7 @@ const std::string RagePhoto::save(uint32_t photoFormat, bool *ok) const std::string RagePhoto::save(bool *ok) { - return save(m_data.photoFormat, ok); + return save(m_rpp->m_data.photoFormat, ok); } bool RagePhoto::saveFile(const std::string &filename, uint32_t photoFormat) @@ -804,7 +806,7 @@ bool RagePhoto::saveFile(const std::string &filename, uint32_t photoFormat) if (ok) { std::ofstream ofs(filename, std::ios::out | std::ios::binary | std::ios::trunc); if (!ofs.is_open()) { - m_data.error = static_cast(Error::Uninitialised); // 0 + m_rpp->m_data.error = static_cast(Error::Uninitialised); // 0 return false; } ofs << sdata; @@ -818,7 +820,7 @@ bool RagePhoto::saveFile(const std::string &filename, uint32_t photoFormat) bool RagePhoto::saveFile(const std::string &filename) { - return saveFile(filename, m_data.photoFormat); + return saveFile(filename, m_rpp->m_data.photoFormat); } inline size_t RagePhoto::saveSize(RagePhotoData *ragePhotoData, uint32_t photoFormat) @@ -838,17 +840,17 @@ inline size_t RagePhoto::saveSize(RagePhotoData *ragePhotoData) inline size_t RagePhoto::saveSize(uint32_t photoFormat) { - return saveSize(&m_data, photoFormat); + return saveSize(&m_rpp->m_data, photoFormat); } inline size_t RagePhoto::saveSize() { - return saveSize(m_data.photoFormat); + return saveSize(m_rpp->m_data.photoFormat); } inline void RagePhoto::setBufferDefault() { - setBufferDefault(&m_data); + setBufferDefault(&m_rpp->m_data); } inline void RagePhoto::setBufferDefault(RagePhotoData *ragePhotoData) @@ -861,7 +863,7 @@ inline void RagePhoto::setBufferDefault(RagePhotoData *ragePhotoData) inline void RagePhoto::setBufferOffsets() { - setBufferOffsets(&m_data); + setBufferOffsets(&m_rpp->m_data); } inline void RagePhoto::setBufferOffsets(RagePhotoData *ragePhotoData) @@ -874,83 +876,83 @@ inline void RagePhoto::setBufferOffsets(RagePhotoData *ragePhotoData) void RagePhoto::setDescription(const std::string &description, uint32_t bufferSize) { - m_data.description = description; + m_rpp->m_data.description = description; if (bufferSize != 0) { - m_data.descBuffer = bufferSize; + m_rpp->m_data.descBuffer = bufferSize; setBufferOffsets(); } } void RagePhoto::setFormat(uint32_t photoFormat) { - m_data.photoFormat = photoFormat; + m_rpp->m_data.photoFormat = photoFormat; } void RagePhoto::setFormatLoadFunction(uint32_t photoFormat, RagePhotoLoadFunc func) { - m_loadFuncs[photoFormat] = func; + m_rpp->m_loadFuncs[photoFormat] = func; } void RagePhoto::setJson(const std::string &json, uint32_t bufferSize) { - m_data.json = json; + m_rpp->m_data.json = json; if (bufferSize != 0) { - m_data.jsonBuffer = bufferSize; + m_rpp->m_data.jsonBuffer = bufferSize; setBufferOffsets(); } } void RagePhoto::setHeader(const std::string &header, uint32_t headerSum) { - m_data.header = header; - m_data.headerSum = headerSum; + m_rpp->m_data.header = header; + m_rpp->m_data.headerSum = headerSum; } bool RagePhoto::setPhoto(const char *data, uint32_t size, uint32_t bufferSize) { - if (m_data.photoLoaded) { - if (m_data.photoSize > size) { - char *t_photoData = static_cast(std::realloc(m_data.photoData, size)); + if (m_rpp->m_data.photoLoaded) { + if (m_rpp->m_data.photoSize > size) { + char *t_photoData = static_cast(std::realloc(m_rpp->m_data.photoData, size)); if (!t_photoData) { - m_data.error = static_cast(Error::PhotoMallocError); // 15 + m_rpp->m_data.error = static_cast(Error::PhotoMallocError); // 15 return false; } - m_data.photoData = t_photoData; - std::memcpy(m_data.photoData, data, size); - m_data.photoSize = size; + m_rpp->m_data.photoData = t_photoData; + std::memcpy(m_rpp->m_data.photoData, data, size); + m_rpp->m_data.photoSize = size; } - else if (m_data.photoSize < size) { - std::free(m_data.photoData); - m_data.photoData = static_cast(std::malloc(size)); - if (!m_data.photoData) { - m_data.error = static_cast(Error::PhotoMallocError); // 15 - m_data.photoLoaded = false; + else if (m_rpp->m_data.photoSize < size) { + std::free(m_rpp->m_data.photoData); + m_rpp->m_data.photoData = static_cast(std::malloc(size)); + if (!m_rpp->m_data.photoData) { + m_rpp->m_data.error = static_cast(Error::PhotoMallocError); // 15 + m_rpp->m_data.photoLoaded = false; return false; } - std::memcpy(m_data.photoData, data, size); - m_data.photoSize = size; + std::memcpy(m_rpp->m_data.photoData, data, size); + m_rpp->m_data.photoSize = size; } else { - std::memcpy(m_data.photoData, data, size); + std::memcpy(m_rpp->m_data.photoData, data, size); } } else { - m_data.photoData = static_cast(std::malloc(size)); - if (!m_data.photoData) { - m_data.error = static_cast(Error::PhotoMallocError); // 15 + m_rpp->m_data.photoData = static_cast(std::malloc(size)); + if (!m_rpp->m_data.photoData) { + m_rpp->m_data.error = static_cast(Error::PhotoMallocError); // 15 return false; } - std::memcpy(m_data.photoData, data, size); - m_data.photoLoaded = true; - m_data.photoSize = size; + std::memcpy(m_rpp->m_data.photoData, data, size); + m_rpp->m_data.photoLoaded = true; + m_rpp->m_data.photoSize = size; } if (bufferSize != 0) { - m_data.photoBuffer = bufferSize; + m_rpp->m_data.photoBuffer = bufferSize; setBufferOffsets(); } - m_data.error = static_cast(Error::NoError); // 255 + m_rpp->m_data.error = static_cast(Error::NoError); // 255 return true; } @@ -961,9 +963,9 @@ bool RagePhoto::setPhoto(const std::string &data, uint32_t bufferSize) void RagePhoto::setTitle(const std::string &title, uint32_t bufferSize) { - m_data.title = title; + m_rpp->m_data.title = title; if (bufferSize != 0) { - m_data.titlBuffer = bufferSize; + m_rpp->m_data.titlBuffer = bufferSize; setBufferOffsets(); } } diff --git a/src/RagePhoto.h b/src/RagePhoto.h index 872ea50..685f294 100644 --- a/src/RagePhoto.h +++ b/src/RagePhoto.h @@ -22,14 +22,12 @@ #ifdef __cplusplus #include "libragephoto_global.h" #include "RagePhotoData.h" -#include -#include -#include -#include #include #include +#include +#include -typedef std::function RagePhotoLoadFunc; +class RagePhotoPrivate; /** * \brief GTA V and RDR 2 Photo Parser. @@ -168,8 +166,7 @@ public: void setTitle(const std::string &title, uint32_t bufferSize = 0); /**< Sets the Photo title. */ private: - std::unordered_map m_loadFuncs; - RagePhotoData m_data; + RagePhotoPrivate *m_rpp; }; #else #include "RagePhotoC.h" diff --git a/src/RagePhotoData.h b/src/RagePhotoData.h index 16773ca..1fdcbab 100644 --- a/src/RagePhotoData.h +++ b/src/RagePhotoData.h @@ -21,8 +21,9 @@ #ifdef __cplusplus #include "libragephoto_global.h" -#include #include +#include +#include struct LIBRAGEPHOTO_CXX_EXPORT RagePhotoData { @@ -47,6 +48,8 @@ struct LIBRAGEPHOTO_CXX_EXPORT RagePhotoData uint32_t unnamedSum1; uint32_t unnamedSum2; }; + +typedef std::function RagePhotoLoadFunc; #endif // __cplusplus #endif // RAGEPHOTODATA_H diff --git a/src/RagePhoto_p.h b/src/RagePhoto_p.h new file mode 100644 index 0000000..f42b300 --- /dev/null +++ b/src/RagePhoto_p.h @@ -0,0 +1,31 @@ +/***************************************************************************** +* libragephoto RAGE Photo Parser +* Copyright (C) 2021 Syping +* +* Redistribution and use in source and binary forms, with or without modification, +* are permitted provided that the following conditions are met: +* +* 1. Redistributions of source code must retain the above copyright notice, +* this list of conditions and the following disclaimer. +* +* 2. Redistributions in binary form must reproduce the above copyright notice, +* this list of conditions and the following disclaimer in the documentation +* and/or other materials provided with the distribution. +* +* This software is provided as-is, no warranties are given to you, we are not +* responsible for anything with use of the software, you are self responsible. +*****************************************************************************/ + +#ifndef RAGEPHOTO_P_H +#define RAGEPHOTO_P_H + +#include "RagePhotoData.h" +#include +#include + +class RagePhotoPrivate { +public: + std::unordered_map m_loadFuncs; + RagePhotoData m_data; +}; +#endif // RAGEPHOTO_P_H