From 6bb8843971d104d5bda6bc0d4845e0ecc34ca257 Mon Sep 17 00:00:00 2001
From: Syping <schiedelrafael@keppe.org>
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 <cstdlib>
+#include <cstring>
 #include <fstream>
 #include <iostream>
 #include <iterator>
-#include <cstdlib>
-#include <cstring>
 
 #ifdef RAGEPHOTO_BENCHMARK
 #include <chrono>
@@ -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<uint8_t>(Error::NoFormatIdentifier); // 1
+        m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(Error::IncompleteHeader); // 3
+            m_rpp->m_data.error = static_cast<uint8_t>(Error::IncompleteHeader); // 3
             return false;
         }
 
 #if defined UNICODE_CODECVT
         std::wstring_convert<std::codecvt_utf8_utf16<char16_t>,char16_t> convert;
-        m_data.header = convert.to_bytes(reinterpret_cast<char16_t*>(photoHeader));
+        m_rpp->m_data.header = convert.to_bytes(reinterpret_cast<char16_t*>(photoHeader));
         if (convert.converted() == 0) {
-            m_data.error = static_cast<uint8_t>(Error::UnicodeHeaderError); // 5
+            m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(Error::UnicodeInitError); // 4
+            m_rpp->m_data.error = static_cast<uint8_t>(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<size_t>(-1)) {
-            m_data.error = static_cast<uint8_t>(Error::UnicodeHeaderError); // 5
+            m_rpp->m_data.error = static_cast<uint8_t>(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<wchar_t*>(photoHeader), -1, photoHeader_string, 256, NULL, NULL);
         if (converted == 0) {
-            m_data.error = static_cast<uint8_t>(Error::UnicodeHeaderError); // 5
+            m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(Error::IncompleteChecksum); // 6
+            m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(Error::IncompleteChecksum); // 6
+                m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(Error::IncompleteChecksum); // 6
+                m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(Error::IncompleteEOF); // 7
+            m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(Error::IncompleteJsonOffset); // 8
+            m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(Error::IncompleteTitleOffset); // 9
+            m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(Error::IncompleteDescOffset); // 10
+            m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(Error::IncompleteJpegMarker); // 11
+            m_rpp->m_data.error = static_cast<uint8_t>(Error::IncompleteJpegMarker); // 11
             return false;
         }
         if (strncmp(markerBuffer, "JPEG", 4) != 0) {
-            m_data.error = static_cast<uint8_t>(Error::IncorrectJpegMarker); // 12
+            m_rpp->m_data.error = static_cast<uint8_t>(Error::IncorrectJpegMarker); // 12
             return false;
         }
 
         size = readBuffer(data, uInt32Buffer, &pos, 4, length);
         if (size != 4) {
-            m_data.error = static_cast<uint8_t>(Error::IncompletePhotoBuffer); // 13
+            m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(Error::IncompletePhotoSize); // 14
+            m_rpp->m_data.error = static_cast<uint8_t>(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<char*>(std::malloc(m_data.photoSize));
-        if (!m_data.photoData) {
-            m_data.error = static_cast<uint8_t>(Error::PhotoMallocError); // 15
+        m_rpp->m_data.photoData = static_cast<char*>(std::malloc(m_rpp->m_data.photoSize));
+        if (!m_rpp->m_data.photoData) {
+            m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(Error::IncompleteJsonMarker); // 17
+            m_rpp->m_data.error = static_cast<uint8_t>(Error::IncompleteJsonMarker); // 17
             return false;
         }
         if (strncmp(markerBuffer, "JSON", 4) != 0) {
-            m_data.error = static_cast<uint8_t>(Error::IncorrectJsonMarker); // 18
+            m_rpp->m_data.error = static_cast<uint8_t>(Error::IncorrectJsonMarker); // 18
             return false;
         }
 
         size = readBuffer(data, uInt32Buffer, &pos, 4, length);
         if (size != 4) {
-            m_data.error = static_cast<uint8_t>(Error::IncompleteJsonBuffer); // 19
+            m_rpp->m_data.error = static_cast<uint8_t>(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<char*>(std::malloc(m_data.jsonBuffer));
+        char *t_jsonData = static_cast<char*>(std::malloc(m_rpp->m_data.jsonBuffer));
         if (!t_jsonData) {
-            m_data.error = static_cast<uint8_t>(Error::JsonMallocError); // 20
+            m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(Error::JsonReadError); // 21
+            m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(Error::IncompleteTitleMarker); // 22
+            m_rpp->m_data.error = static_cast<uint8_t>(Error::IncompleteTitleMarker); // 22
             return false;
         }
         if (strncmp(markerBuffer, "TITL", 4) != 0) {
-            m_data.error = static_cast<uint8_t>(Error::IncorrectTitleMarker); // 23
+            m_rpp->m_data.error = static_cast<uint8_t>(Error::IncorrectTitleMarker); // 23
             return false;
         }
 
         size = readBuffer(data, uInt32Buffer, &pos, 4, length);
         if (size != 4) {
-            m_data.error = static_cast<uint8_t>(Error::IncompleteTitleBuffer); // 24
+            m_rpp->m_data.error = static_cast<uint8_t>(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<char*>(std::malloc(m_data.titlBuffer));
+        char *t_titlData = static_cast<char*>(std::malloc(m_rpp->m_data.titlBuffer));
         if (!t_titlData) {
-            m_data.error = static_cast<uint8_t>(Error::TitleMallocError); // 25
+            m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(Error::TitleReadError); // 26
+            m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(Error::IncompleteDescMarker); // 27
+            m_rpp->m_data.error = static_cast<uint8_t>(Error::IncompleteDescMarker); // 27
             return false;
         }
         if (strncmp(markerBuffer, "DESC", 4) != 0) {
-            m_data.error = static_cast<uint8_t>(Error::IncorrectDescMarker); // 28
+            m_rpp->m_data.error = static_cast<uint8_t>(Error::IncorrectDescMarker); // 28
             return false;
         }
 
         size = readBuffer(data, uInt32Buffer, &pos, 4, length);
         if (size != 4) {
-            m_data.error = static_cast<uint8_t>(Error::IncompleteDescBuffer); // 29
+            m_rpp->m_data.error = static_cast<uint8_t>(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<char*>(std::malloc(m_data.descBuffer));
+        char *t_descData = static_cast<char*>(std::malloc(m_rpp->m_data.descBuffer));
         if (!t_descData) {
-            m_data.error = static_cast<uint8_t>(Error::DescMallocError); // 30
+            m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(Error::DescReadError); // 31
+            m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(Error::IncompleteJendMarker); // 32
+            m_rpp->m_data.error = static_cast<uint8_t>(Error::IncompleteJendMarker); // 32
             return false;
         }
         if (strncmp(markerBuffer, "JEND", 4) != 0) {
-            m_data.error = static_cast<uint8_t>(Error::IncorrectJendMarker); // 33
+            m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(Error::NoError); // 255
+        m_rpp->m_data.error = static_cast<uint8_t>(Error::NoError); // 255
         return true;
 #else
         std::cout << "UTF-16LE decoding support missing" << std::endl;
-        m_data.error = static_cast<uint8_t>(Error::UnicodeInitError); // 4
+        m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(Error::IncompatibleFormat); // 2
+    m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(Error::Uninitialised); // 0
+        m_rpp->m_data.error = static_cast<uint8_t>(Error::Uninitialised); // 0
         return false;
     }
 }
 
 RagePhoto::Error RagePhoto::error() const
 {
-    return static_cast<Error>(m_data.error);
+    return static_cast<Error>(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<std::codecvt_utf8_utf16<char16_t>,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<uint8_t>(Error::UnicodeHeaderError); // 5
+            m_rpp->m_data.error = static_cast<uint8_t>(Error::UnicodeHeaderError); // 5
             return false;
         }
         const size_t photoHeader_size = photoHeader_string.size() * 2;
         if (photoHeader_size > 256) {
-            m_data.error = static_cast<uint8_t>(Error::HeaderBufferTight); // 34
+            m_rpp->m_data.error = static_cast<uint8_t>(Error::HeaderBufferTight); // 34
             return false;
         }
         const char *photoHeader = reinterpret_cast<const char*>(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<uint8_t>(Error::UnicodeInitError); // 4
+            m_rpp->m_data.error = static_cast<uint8_t>(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<size_t>(-1)) {
-            m_data.error = static_cast<uint8_t>(Error::UnicodeHeaderError); // 5
+            m_rpp->m_data.error = static_cast<uint8_t>(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<wchar_t*>(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<wchar_t*>(photoHeader), 256 / sizeof(wchar_t));
         if (converted == 0) {
-            m_data.error = static_cast<uint8_t>(Error::UnicodeHeaderError); // 5
+            m_rpp->m_data.error = static_cast<uint8_t>(Error::UnicodeHeaderError); // 5
             return false;
         }
         const size_t photoHeader_size = 256;
 #endif
 
-        if (m_data.photoSize > m_data.photoBuffer) {
-            m_data.error = static_cast<uint8_t>(Error::PhotoBufferTight); // 35
+        if (m_rpp->m_data.photoSize > m_rpp->m_data.photoBuffer) {
+            m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(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<uint8_t>(Error::NoError); // 255
+        m_rpp->m_data.error = static_cast<uint8_t>(Error::NoError); // 255
         return true;
 #else
         std::cout << "UTF-16LE encoding support missing" << std::endl;
-        m_data.error = static_cast<uint8_t>(Error::UnicodeInitError); // 4
+        m_rpp->m_data.error = static_cast<uint8_t>(Error::UnicodeInitError); // 4
         return false;
 #endif
     }
 
-    m_data.error = static_cast<uint8_t>(Error::IncompatibleFormat); // 2
+    m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(Error::Uninitialised); // 0
+            m_rpp->m_data.error = static_cast<uint8_t>(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<char*>(std::realloc(m_data.photoData, size));
+    if (m_rpp->m_data.photoLoaded) {
+        if (m_rpp->m_data.photoSize > size) {
+            char *t_photoData = static_cast<char*>(std::realloc(m_rpp->m_data.photoData, size));
             if (!t_photoData) {
-                m_data.error = static_cast<uint8_t>(Error::PhotoMallocError); // 15
+                m_rpp->m_data.error = static_cast<uint8_t>(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<char*>(std::malloc(size));
-            if (!m_data.photoData) {
-                m_data.error = static_cast<uint8_t>(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<char*>(std::malloc(size));
+            if (!m_rpp->m_data.photoData) {
+                m_rpp->m_data.error = static_cast<uint8_t>(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<char*>(std::malloc(size));
-        if (!m_data.photoData) {
-            m_data.error = static_cast<uint8_t>(Error::PhotoMallocError); // 15
+        m_rpp->m_data.photoData = static_cast<char*>(std::malloc(size));
+        if (!m_rpp->m_data.photoData) {
+            m_rpp->m_data.error = static_cast<uint8_t>(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<uint8_t>(Error::NoError); // 255
+    m_rpp->m_data.error = static_cast<uint8_t>(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 <unordered_map>
-#include <functional>
-#include <iostream>
-#include <cstdlib>
 #include <cstdint>
 #include <cstdio>
+#include <cstdlib>
+#include <iostream>
 
-typedef std::function<bool(const char*, size_t, RagePhotoData*)> 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<uint8_t, RagePhotoLoadFunc> 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 <iostream>
 #include <cstdint>
+#include <iostream>
+#include <functional>
 
 struct LIBRAGEPHOTO_CXX_EXPORT RagePhotoData
 {
@@ -47,6 +48,8 @@ struct LIBRAGEPHOTO_CXX_EXPORT RagePhotoData
     uint32_t unnamedSum1;
     uint32_t unnamedSum2;
 };
+
+typedef std::function<bool(const char*, size_t, RagePhotoData*)> 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 <iostream>
+#include <unordered_map>
+
+class RagePhotoPrivate {
+public:
+    std::unordered_map<uint8_t, RagePhotoLoadFunc> m_loadFuncs;
+    RagePhotoData m_data;
+};
+#endif // RAGEPHOTO_P_H