Syping/libragephoto
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

libragephoto: add new ragephotodata functions and improvements

Browse source 
RagePhoto: changed photo(), photoData(), photoSize() and setPhoto() to
jpeg(), jpegData(), jpegSize() and setJpeg()
RagePhoto: setData() now takes takeCopy instead of takeOwnership
RagePhoto: changed static member argument order for easier coding
RagePhotoA: changed photo(), photoData(), photoSize() and setPhoto() to
jpeg(), jpegData(), jpegSize() and setJpeg()
RagePhotoA: setData() now takes takeCopy instead of takeOwnership
RagePhotoA: changed static member argument order for easier coding
RagePhotoA: add new C API functions
RagePhotoC: add ragephotodata_save() and ragephotodata_savef()
RagePhoto-Extract: update for API changes, stop assuming RDR 2 when GTA
V format not found
ragephoto-gtkviewer: update for API changes
ragephoto-qtviewer: update for API changes
This commit is contained in:
Syping 2023-02-23 09:17:53 +01:00
parent 9807f0d696
commit d75eba2a46
9 changed files with 237 additions and 182 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
CMakeLists.txt
View file

@ -139,8 +139,8 @@ if (EMSCRIPTEN)
"SHELL:-s EXPORTED_RUNTIME_METHODS=ccall,cwrap" "SHELL:-s EXPORTED_RUNTIME_METHODS=ccall,cwrap"
) )
target_include_directories(ragephoto-wasm PUBLIC target_include_directories(ragephoto-wasm PUBLIC
${ragephoto_BINARY_DIR}/include "${ragephoto_BINARY_DIR}/include"
${ragephoto_SOURCE_DIR}/src "${ragephoto_SOURCE_DIR}/src"
) )
else() else()
message(WARNING "A useable WebAssembly build needs at least CMake 3.13.0 or newer") message(WARNING "A useable WebAssembly build needs at least CMake 3.13.0 or newer")

4
examples/ragephoto-gtkviewer/src/main.cpp
View file

@ -1,6 +1,6 @@
/***************************************************************************** /*****************************************************************************
* libragephoto RAGE Photo Parser * libragephoto RAGE Photo Parser
* Copyright (C) 2021-2022 Syping * Copyright (C) 2021-2023 Syping
* *
* Redistribution and use in source and binary forms, with or without modification, * Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met: * are permitted provided that the following conditions are met:
@ -48,7 +48,7 @@ bool readPhotoFile(const std::string &filename, Gtk::Window *win, Gtk::Image *im
} }
} }
GdkPixbufLoader *pixbuf_loader = gdk_pixbuf_loader_new(); GdkPixbufLoader *pixbuf_loader = gdk_pixbuf_loader_new();
gdk_pixbuf_loader_write(pixbuf_loader, reinterpret_cast<const guchar*>(ragePhoto.photoData()), ragePhoto.photoSize(), NULL); gdk_pixbuf_loader_write(pixbuf_loader, reinterpret_cast<const guchar*>(ragePhoto.jpegData()), ragePhoto.jpegSize(), NULL);
GdkPixbuf *pixbuf = gdk_pixbuf_loader_get_pixbuf(pixbuf_loader); GdkPixbuf *pixbuf = gdk_pixbuf_loader_get_pixbuf(pixbuf_loader);
gdk_pixbuf_loader_close(pixbuf_loader, NULL); gdk_pixbuf_loader_close(pixbuf_loader, NULL);
image->set(Glib::wrap(pixbuf)); image->set(Glib::wrap(pixbuf));

6
examples/ragephoto-qtviewer/src/main.cpp
View file

@ -1,6 +1,6 @@
/***************************************************************************** /*****************************************************************************
* libragephoto RAGE Photo Parser * libragephoto RAGE Photo Parser
* Copyright (C) 2021-2022 Syping * Copyright (C) 2021-2023 Syping
* *
* Redistribution and use in source and binary forms, with or without modification, * Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met: * are permitted provided that the following conditions are met:
@ -44,8 +44,8 @@ bool readPhotoFile(const QString &filename, QMainWindow *mainWindow, QLabel *pho
return false; return false;
} }
} }
const QByteArray photoData = QByteArray::fromRawData(ragePhoto.photoData(), ragePhoto.photoSize()); const QByteArray jpegData = QByteArray::fromRawData(ragePhoto.jpegData(), ragePhoto.jpegSize());
const QImage image = QImage::fromData(photoData, "JPEG"); const QImage image = QImage::fromData(jpegData, "JPEG");
photoLabel->setPixmap(QPixmap::fromImage(image)); photoLabel->setPixmap(QPixmap::fromImage(image));
mainWindow->setWindowTitle(QStringLiteral("RagePhoto Qt Photo Viewer - ") + QString::fromUtf8(ragePhoto.title())); mainWindow->setWindowTitle(QStringLiteral("RagePhoto Qt Photo Viewer - ") + QString::fromUtf8(ragePhoto.title()));
return true; return true;

16
src/RagePhoto-Extract.c
View file

@ -35,10 +35,12 @@ int main(int argc, char *argv[])
if (loaded != 1) { if (loaded != 1) {
if (ragephoto_error(ragephoto_in) == 0) { if (ragephoto_error(ragephoto_in) == 0) {
printf("Failed to open file: %s\n", argv[1]); printf("Failed to open file: %s\n", argv[1]);
ragephoto_close(ragephoto_in);
return 1; return 1;
} }
else if (ragephoto_getphotosize(ragephoto_in) <= 0) { else if (ragephoto_getphotosize(ragephoto_in) <= 0) {
printf("Failed to load photo\n"); printf("Failed to load photo\n");
ragephoto_close(ragephoto_in);
return 1; return 1;
} }
} }
@ -52,20 +54,26 @@ int main(int argc, char *argv[])
#endif #endif
if (!file) { if (!file) {
printf("Failed to write file: %s\n", argv[2]); printf("Failed to write file: %s\n", argv[2]);
ragephoto_close(ragephoto_in);
return 1; return 1;
} }
const size_t size = fwrite(ragephoto_getphotojpeg(ragephoto_in), sizeof(char), ragephoto_getphotosize(ragephoto_in), file); const size_t jpegSize = ragephoto_getphotosize(ragephoto_in);
const size_t fileSize = fwrite(ragephoto_getphotojpeg(ragephoto_in), sizeof(char), jpegSize, file);
fclose(file); fclose(file);
if (size != ragephoto_getphotosize(ragephoto_in)) { if (fileSize != jpegSize) {
printf("Failed to write file: %s\n", argv[2]); printf("Failed to write file: %s\n", argv[2]);
ragephoto_close(ragephoto_in);
return 1; return 1;
} }
if (ragephoto_getphotoformat(ragephoto_in) == ragephoto_format_gta5()) const uint32_t photoFormat = ragephoto_getphotoformat(ragephoto_in);
if (photoFormat == ragephoto_format_gta5())
printf("GTA V Photo successfully exported\n"); printf("GTA V Photo successfully exported\n");
else else if (photoFormat == ragephoto_format_rdr2())
printf("RDR 2 Photo successfully exported\n"); printf("RDR 2 Photo successfully exported\n");
else
printf("Photo successfully exported\n");
ragephoto_close(ragephoto_in); ragephoto_close(ragephoto_in);

14
src/RagePhoto-Extract.cpp
View file

@ -33,11 +33,12 @@ int main(int argc, char *argv[])
const bool loaded = ragePhoto.loadFile(argv[1]); const bool loaded = ragePhoto.loadFile(argv[1]);
if (!loaded) { if (!loaded) {
if (ragePhoto.error() == RagePhoto::Uninitialised) { const int32_t error = ragePhoto.error();
if (error == RagePhoto::Uninitialised) {
std::cout << "Failed to open file: " << argv[1] << std::endl; std::cout << "Failed to open file: " << argv[1] << std::endl;
return 1; return 1;
} }
else if (ragePhoto.error() <= RagePhoto::PhotoReadError) { else if (error <= RagePhoto::PhotoReadError) {
std::cout << "Failed to load photo" << std::endl; std::cout << "Failed to load photo" << std::endl;
return 1; return 1;
} }
@ -49,7 +50,7 @@ int main(int argc, char *argv[])
std::cout << "Failed to write file: " << argv[2] << std::endl; std::cout << "Failed to write file: " << argv[2] << std::endl;
return 1; return 1;
} }
ofs << ragePhoto.photo(); ofs << ragePhoto.jpeg();
const bool ok = ofs.good(); const bool ok = ofs.good();
ofs.close(); ofs.close();
@ -58,10 +59,13 @@ int main(int argc, char *argv[])
return 1; return 1;
} }
if (ragePhoto.format() == RagePhoto::GTA5) const uint32_t photoFormat = ragePhoto.format();
if (photoFormat == RagePhoto::GTA5)
std::cout << "GTA V Photo successfully exported" << std::endl; std::cout << "GTA V Photo successfully exported" << std::endl;
else else if (photoFormat == RagePhoto::RDR2)
std::cout << "RDR 2 Photo successfully exported" << std::endl; std::cout << "RDR 2 Photo successfully exported" << std::endl;
else
std::cout << "Photo successfully exported" << std::endl;
return 0; return 0;
} }

282
src/RagePhoto.cpp
View file

@ -133,7 +133,7 @@ RagePhoto::RagePhoto()
if (!m_parser) if (!m_parser)
throw std::runtime_error("RagePhotoFormatParser parser struct can't be allocated"); throw std::runtime_error("RagePhotoFormatParser parser struct can't be allocated");
std::memset(m_parser, 0, sizeof(RagePhotoFormatParser)); std::memset(m_parser, 0, sizeof(RagePhotoFormatParser));
setBufferDefault(); setBufferDefault(m_data);
} }
RagePhoto::~RagePhoto() RagePhoto::~RagePhoto()
@ -185,7 +185,7 @@ RagePhotoData* RagePhoto::data()
return m_data; return m_data;
} }
bool RagePhoto::load(RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser, const char *data, size_t length) bool RagePhoto::load(const char *data, size_t length, RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser)
{ {
#ifdef RAGEPHOTO_BENCHMARK #ifdef RAGEPHOTO_BENCHMARK
auto benchmark_parse_start = std::chrono::high_resolution_clock::now(); auto benchmark_parse_start = std::chrono::high_resolution_clock::now();
@ -560,14 +560,14 @@ bool RagePhoto::load(RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser, c
return false; return false;
} }
bool RagePhoto::load(const char *data, size_t length) bool RagePhoto::load(const char *data, size_t size)
{ {
return load(m_data, m_parser, data, length); return load(data, size, m_data, m_parser);
} }
bool RagePhoto::load(const std::string &data) bool RagePhoto::load(const std::string &data)
{ {
return load(data.data(), data.size()); return load(data.data(), data.size(), m_data, m_parser);
} }
bool RagePhoto::loadFile(const std::string &filename) bool RagePhoto::loadFile(const std::string &filename)
@ -594,7 +594,7 @@ uint32_t RagePhoto::format() const
return m_data->photoFormat; return m_data->photoFormat;
} }
const std::string RagePhoto::photo() const const std::string RagePhoto::jpeg() const
{ {
if (m_data->jpeg) if (m_data->jpeg)
return std::string(m_data->jpeg, m_data->jpegSize); return std::string(m_data->jpeg, m_data->jpegSize);
@ -602,12 +602,12 @@ const std::string RagePhoto::photo() const
return std::string(); return std::string();
} }
const char* RagePhoto::photoData() const const char* RagePhoto::jpegData() const
{ {
return m_data->jpeg; return m_data->jpeg;
} }
uint32_t RagePhoto::photoSize() const uint32_t RagePhoto::jpegSize() const
{ {
if (m_data->jpeg) if (m_data->jpeg)
return m_data->jpegSize; return m_data->jpegSize;
@ -640,75 +640,75 @@ const char* RagePhoto::version()
return RAGEPHOTO_VERSION; return RAGEPHOTO_VERSION;
} }
bool RagePhoto::save(char *data, uint32_t photoFormat) bool RagePhoto::save(char *data, uint32_t photoFormat, RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser)
{ {
if (photoFormat == PhotoFormat::GTA5 || photoFormat == PhotoFormat::RDR2) { if (photoFormat == PhotoFormat::GTA5 || photoFormat == PhotoFormat::RDR2) {
#if defined UNICODE_ICONV || defined UNICODE_CODECVT || defined UNICODE_WINCVT #if defined UNICODE_ICONV || defined UNICODE_CODECVT || defined UNICODE_WINCVT
#if defined UNICODE_CODECVT #if defined UNICODE_CODECVT
std::wstring_convert<std::codecvt_utf8_utf16<char16_t>,char16_t> convert; 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(rp_data->header);
if (convert.converted() == 0) { if (convert.converted() == 0) {
m_data->error = Error::UnicodeHeaderError; // 6 rp_data->error = Error::UnicodeHeaderError; // 6
return false; return false;
} }
const size_t photoHeader_size = photoHeader_string.size() * 2; const size_t photoHeader_size = photoHeader_string.size() * 2;
if (photoHeader_size > 256) { if (photoHeader_size > 256) {
m_data->error = Error::HeaderBufferTight; // 35 rp_data->error = Error::HeaderBufferTight; // 35
return false; return false;
} }
const char *photoHeader = reinterpret_cast<const char*>(photoHeader_string.data()); const char *photoHeader = reinterpret_cast<const char*>(photoHeader_string.data());
#elif defined UNICODE_ICONV #elif defined UNICODE_ICONV
iconv_t iconv_in = iconv_open("UTF-16LE", "UTF-8"); iconv_t iconv_in = iconv_open("UTF-16LE", "UTF-8");
if (iconv_in == (iconv_t)-1) { if (iconv_in == (iconv_t)-1) {
m_data->error = Error::UnicodeInitError; // 4 rp_data->error = Error::UnicodeInitError; // 4
return false; return false;
} }
char photoHeader[256]{}; char photoHeader[256]{};
size_t src_s = strlen(m_data->header); size_t src_s = strlen(rp_data->header);
size_t dst_s = sizeof(photoHeader); size_t dst_s = sizeof(photoHeader);
char *src = m_data->header; char *src = rp_data->header;
char *dst = photoHeader; char *dst = photoHeader;
const size_t ret = iconv(iconv_in, &src, &src_s, &dst, &dst_s); const size_t ret = iconv(iconv_in, &src, &src_s, &dst, &dst_s);
iconv_close(iconv_in); iconv_close(iconv_in);
if (ret == static_cast<size_t>(-1)) { if (ret == static_cast<size_t>(-1)) {
m_data->error = Error::UnicodeHeaderError; // 6 rp_data->error = Error::UnicodeHeaderError; // 6
return false; return false;
} }
const size_t photoHeader_size = 256; const size_t photoHeader_size = 256;
#elif defined UNICODE_WINCVT #elif defined UNICODE_WINCVT
char photoHeader[256]{}; char photoHeader[256]{};
const int converted = MultiByteToWideChar(CP_UTF8, 0, m_data->header, static_cast<int>(strlen(m_data->header)), reinterpret_cast<wchar_t*>(photoHeader), 256 / sizeof(wchar_t)); const int converted = MultiByteToWideChar(CP_UTF8, 0, rp_data->header, static_cast<int>(strlen(rp_data->header)), reinterpret_cast<wchar_t*>(photoHeader), 256 / sizeof(wchar_t));
if (converted == 0) { if (converted == 0) {
m_data->error = Error::UnicodeHeaderError; // 6 rp_data->error = Error::UnicodeHeaderError; // 6
return false; return false;
} }
const size_t photoHeader_size = 256; const size_t photoHeader_size = 256;
#endif #endif
if (m_data->jpegSize > m_data->jpegBuffer) { if (rp_data->jpegSize > rp_data->jpegBuffer) {
m_data->error = Error::PhotoBufferTight; // 36 rp_data->error = Error::PhotoBufferTight; // 36
return false; return false;
} }
const size_t jsonString_size = strlen(m_data->json) + 1; const size_t jsonString_size = strlen(rp_data->json) + 1;
if (jsonString_size > m_data->jsonBuffer) { if (jsonString_size > rp_data->jsonBuffer) {
m_data->error = Error::JsonBufferTight; // 37 rp_data->error = Error::JsonBufferTight; // 37
return false; return false;
} }
const size_t titlString_size = strlen(m_data->title) + 1; const size_t titlString_size = strlen(rp_data->title) + 1;
if (titlString_size > m_data->titlBuffer) { if (titlString_size > rp_data->titlBuffer) {
m_data->error = Error::TitleBufferTight; // 38 rp_data->error = Error::TitleBufferTight; // 38
return false; return false;
} }
const size_t descString_size = strlen(m_data->description) + 1; const size_t descString_size = strlen(rp_data->description) + 1;
if (descString_size > m_data->descBuffer) { if (descString_size > rp_data->descBuffer) {
m_data->error = Error::DescBufferTight; // 39 rp_data->error = Error::DescBufferTight; // 39
return false; return false;
} }
const size_t length = saveSize(photoFormat); const size_t length = saveSize(photoFormat, rp_data, rp_parser);
size_t pos = 0; size_t pos = 0;
char uInt32Buffer[4]; char uInt32Buffer[4];
@ -725,163 +725,173 @@ bool RagePhoto::save(char *data, uint32_t photoFormat)
} }
#if __BYTE_ORDER == __LITTLE_ENDIAN #if __BYTE_ORDER == __LITTLE_ENDIAN
std::memcpy(uInt32Buffer, &m_data->headerSum, 4); std::memcpy(uInt32Buffer, &rp_data->headerSum, 4);
#else #else
uInt32ToCharLE(m_data->headerSum, uInt32Buffer); uInt32ToCharLE(rp_data->headerSum, uInt32Buffer);
#endif #endif
writeBuffer(uInt32Buffer, data, &pos, length, 4); writeBuffer(uInt32Buffer, data, &pos, length, 4);
if (photoFormat == PhotoFormat::RDR2) { if (photoFormat == PhotoFormat::RDR2) {
#if __BYTE_ORDER == __LITTLE_ENDIAN #if __BYTE_ORDER == __LITTLE_ENDIAN
std::memcpy(uInt32Buffer, &m_data->unnamedSum1, 4); std::memcpy(uInt32Buffer, &rp_data->unnamedSum1, 4);
#else #else
uInt32ToCharLE(m_data->unnamedSum1, uInt32Buffer); uInt32ToCharLE(rp_data->unnamedSum1, uInt32Buffer);
#endif #endif
writeBuffer(uInt32Buffer, data, &pos, length, 4); writeBuffer(uInt32Buffer, data, &pos, length, 4);
#if __BYTE_ORDER == __LITTLE_ENDIAN #if __BYTE_ORDER == __LITTLE_ENDIAN
std::memcpy(uInt32Buffer, &m_data->unnamedSum2, 4); std::memcpy(uInt32Buffer, &rp_data->unnamedSum2, 4);
#else #else
uInt32ToCharLE(m_data->unnamedSum2, uInt32Buffer); uInt32ToCharLE(rp_data->unnamedSum2, uInt32Buffer);
#endif #endif
writeBuffer(uInt32Buffer, data, &pos, length, 4); writeBuffer(uInt32Buffer, data, &pos, length, 4);
} }
const size_t headerSize = pos; const size_t headerSize = pos;
#if __BYTE_ORDER == __LITTLE_ENDIAN #if __BYTE_ORDER == __LITTLE_ENDIAN
std::memcpy(uInt32Buffer, &m_data->endOfFile, 4); std::memcpy(uInt32Buffer, &rp_data->endOfFile, 4);
#else #else
uInt32ToCharLE(m_data->endOfFile, uInt32Buffer); uInt32ToCharLE(rp_data->endOfFile, uInt32Buffer);
#endif #endif
writeBuffer(uInt32Buffer, data, &pos, length, 4); writeBuffer(uInt32Buffer, data, &pos, length, 4);
#if __BYTE_ORDER == __LITTLE_ENDIAN #if __BYTE_ORDER == __LITTLE_ENDIAN
std::memcpy(uInt32Buffer, &m_data->jsonOffset, 4); std::memcpy(uInt32Buffer, &rp_data->jsonOffset, 4);
#else #else
uInt32ToCharLE(m_data->jsonOffset, uInt32Buffer); uInt32ToCharLE(rp_data->jsonOffset, uInt32Buffer);
#endif #endif
writeBuffer(uInt32Buffer, data, &pos, length, 4); writeBuffer(uInt32Buffer, data, &pos, length, 4);
#if __BYTE_ORDER == __LITTLE_ENDIAN #if __BYTE_ORDER == __LITTLE_ENDIAN
std::memcpy(uInt32Buffer, &m_data->titlOffset, 4); std::memcpy(uInt32Buffer, &rp_data->titlOffset, 4);
#else #else
uInt32ToCharLE(m_data->titlOffset, uInt32Buffer); uInt32ToCharLE(rp_data->titlOffset, uInt32Buffer);
#endif #endif
writeBuffer(uInt32Buffer, data, &pos, length, 4); writeBuffer(uInt32Buffer, data, &pos, length, 4);
#if __BYTE_ORDER == __LITTLE_ENDIAN #if __BYTE_ORDER == __LITTLE_ENDIAN
std::memcpy(uInt32Buffer, &m_data->descOffset, 4); std::memcpy(uInt32Buffer, &rp_data->descOffset, 4);
#else #else
uInt32ToCharLE(m_data->descOffset, uInt32Buffer); uInt32ToCharLE(rp_data->descOffset, uInt32Buffer);
#endif #endif
writeBuffer(uInt32Buffer, data, &pos, length, 4); writeBuffer(uInt32Buffer, data, &pos, length, 4);
writeBuffer("JPEG", data, &pos, length, 4); writeBuffer("JPEG", data, &pos, length, 4);
#if __BYTE_ORDER == __LITTLE_ENDIAN #if __BYTE_ORDER == __LITTLE_ENDIAN
std::memcpy(uInt32Buffer, &m_data->jpegBuffer, 4); std::memcpy(uInt32Buffer, &rp_data->jpegBuffer, 4);
#else #else
uInt32ToCharLE(m_data->jpegBuffer, uInt32Buffer); uInt32ToCharLE(rp_data->jpegBuffer, uInt32Buffer);
#endif #endif
writeBuffer(uInt32Buffer, data, &pos, length, 4); writeBuffer(uInt32Buffer, data, &pos, length, 4);
#if __BYTE_ORDER == __LITTLE_ENDIAN #if __BYTE_ORDER == __LITTLE_ENDIAN
std::memcpy(uInt32Buffer, &m_data->jpegSize, 4); std::memcpy(uInt32Buffer, &rp_data->jpegSize, 4);
#else #else
uInt32ToCharLE(m_data->jpegSize, uInt32Buffer); uInt32ToCharLE(rp_data->jpegSize, uInt32Buffer);
#endif #endif
writeBuffer(uInt32Buffer, data, &pos, length, 4); writeBuffer(uInt32Buffer, data, &pos, length, 4);
writeBuffer(m_data->jpeg, data, &pos, length, m_data->jpegSize); writeBuffer(rp_data->jpeg, data, &pos, length, rp_data->jpegSize);
for (size_t i = m_data->jpegSize; i < m_data->jpegBuffer; i++) { for (size_t i = rp_data->jpegSize; i < rp_data->jpegBuffer; i++) {
writeBuffer("\0", data, &pos, length, 1); writeBuffer("\0", data, &pos, length, 1);
} }
pos = m_data->jsonOffset + headerSize; pos = rp_data->jsonOffset + headerSize;
writeBuffer("JSON", data, &pos, length, 4); writeBuffer("JSON", data, &pos, length, 4);
#if __BYTE_ORDER == __LITTLE_ENDIAN #if __BYTE_ORDER == __LITTLE_ENDIAN
std::memcpy(uInt32Buffer, &m_data->jsonBuffer, 4); std::memcpy(uInt32Buffer, &rp_data->jsonBuffer, 4);
#else #else
uInt32ToCharLE(m_data->jsonBuffer, uInt32Buffer); uInt32ToCharLE(rp_data->jsonBuffer, uInt32Buffer);
#endif #endif
writeBuffer(uInt32Buffer, data, &pos, length, 4); writeBuffer(uInt32Buffer, data, &pos, length, 4);
writeBuffer(m_data->json, data, &pos, length, jsonString_size); writeBuffer(rp_data->json, data, &pos, length, jsonString_size);
for (size_t i = jsonString_size; i < m_data->jsonBuffer; i++) { for (size_t i = jsonString_size; i < rp_data->jsonBuffer; i++) {
writeBuffer("\0", data, &pos, length, 1); writeBuffer("\0", data, &pos, length, 1);
} }
pos = m_data->titlOffset + headerSize; pos = rp_data->titlOffset + headerSize;
writeBuffer("TITL", data, &pos, length, 4); writeBuffer("TITL", data, &pos, length, 4);
#if __BYTE_ORDER == __LITTLE_ENDIAN #if __BYTE_ORDER == __LITTLE_ENDIAN
std::memcpy(uInt32Buffer, &m_data->titlBuffer, 4); std::memcpy(uInt32Buffer, &rp_data->titlBuffer, 4);
#else #else
uInt32ToCharLE(m_data->titlBuffer, uInt32Buffer); uInt32ToCharLE(rp_data->titlBuffer, uInt32Buffer);
#endif #endif
writeBuffer(uInt32Buffer, data, &pos, length, 4); writeBuffer(uInt32Buffer, data, &pos, length, 4);
writeBuffer(m_data->title, data, &pos, length, titlString_size); writeBuffer(rp_data->title, data, &pos, length, titlString_size);
for (size_t i = titlString_size; i < m_data->titlBuffer; i++) { for (size_t i = titlString_size; i < rp_data->titlBuffer; i++) {
writeBuffer("\0", data, &pos, length, 1); writeBuffer("\0", data, &pos, length, 1);
} }
pos = m_data->descOffset + headerSize; pos = rp_data->descOffset + headerSize;
writeBuffer("DESC", data, &pos, length, 4); writeBuffer("DESC", data, &pos, length, 4);
#if __BYTE_ORDER == __LITTLE_ENDIAN #if __BYTE_ORDER == __LITTLE_ENDIAN
std::memcpy(uInt32Buffer, &m_data->descBuffer, 4); std::memcpy(uInt32Buffer, &rp_data->descBuffer, 4);
#else #else
uInt32ToCharLE(m_data->descBuffer, uInt32Buffer); uInt32ToCharLE(rp_data->descBuffer, uInt32Buffer);
#endif #endif
writeBuffer(uInt32Buffer, data, &pos, length, 4); writeBuffer(uInt32Buffer, data, &pos, length, 4);
writeBuffer(m_data->description, data, &pos, length, descString_size); writeBuffer(rp_data->description, data, &pos, length, descString_size);
for (size_t i = descString_size; i < m_data->descBuffer; i++) { for (size_t i = descString_size; i < rp_data->descBuffer; i++) {
writeBuffer("\0", data, &pos, length, 1); writeBuffer("\0", data, &pos, length, 1);
} }
pos = m_data->endOfFile + headerSize - 4; pos = rp_data->endOfFile + headerSize - 4;
writeBuffer("JEND", data, &pos, length, 4); writeBuffer("JEND", data, &pos, length, 4);
m_data->error = Error::NoError; // 255 rp_data->error = Error::NoError; // 255
return true; return true;
#else #else
std::cout << "UTF-16LE encoding support missing" << std::endl; std::cout << "UTF-16LE encoding support missing" << std::endl;
m_data->error = Error::UnicodeInitError; // 4 rp_data->error = Error::UnicodeInitError; // 4
return false; return false;
#endif #endif
} }
else if (m_parser) { else if (rp_parser) {
RagePhotoFormatParser n_parser[1]{}; RagePhotoFormatParser n_parser[1]{};
for (size_t i = 0; std::memcmp(&n_parser[0], &m_parser[i], sizeof(RagePhotoFormatParser)); i++) { for (size_t i = 0; std::memcmp(&n_parser[0], &rp_parser[i], sizeof(RagePhotoFormatParser)); i++) {
if (photoFormat == m_parser[i].photoFormat) if (photoFormat == rp_parser[i].photoFormat)
if (m_parser[i].funcSave) if (rp_parser[i].funcSave)
return (m_parser[i].funcSave)(m_data, data, photoFormat); return (rp_parser[i].funcSave)(rp_data, data, photoFormat);
} }
} }
m_data->error = Error::IncompatibleFormat; // 2 rp_data->error = Error::IncompatibleFormat; // 2
return false; return false;
} }
bool RagePhoto::save(char *data, RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser)
{
return save(data, rp_data->photoFormat, rp_data, rp_parser);
}
bool RagePhoto::save(char *data, uint32_t photoFormat)
{
return save(data, photoFormat, m_data, m_parser);
}
bool RagePhoto::save(char *data) bool RagePhoto::save(char *data)
{ {
return save(data, m_data->photoFormat); return save(data, m_data->photoFormat, m_data, m_parser);
} }
const std::string RagePhoto::save(uint32_t photoFormat, bool *ok) const std::string RagePhoto::save(uint32_t photoFormat, bool *ok)
{ {
std::string sdata; std::string sdata;
const size_t size = saveSize(photoFormat); const size_t size = saveSize(photoFormat, m_data, m_parser);
if (size == 0) { if (size == 0) {
if (ok) if (ok)
*ok = false; *ok = false;
return sdata; return sdata;
} }
sdata.resize(size); sdata.resize(size);
const bool saved = save(&sdata[0], photoFormat); const bool saved = save(&sdata[0], photoFormat, m_data, m_parser);
if (ok) if (ok)
*ok = saved; *ok = saved;
return sdata; return sdata;
@ -916,7 +926,7 @@ bool RagePhoto::saveFile(const std::string &filename)
return saveFile(filename, m_data->photoFormat); return saveFile(filename, m_data->photoFormat);
} }
size_t RagePhoto::saveSize(RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser, uint32_t photoFormat) size_t RagePhoto::saveSize(uint32_t photoFormat, RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser)
{ {
if (photoFormat == PhotoFormat::GTA5) if (photoFormat == PhotoFormat::GTA5)
return (rp_data->jpegBuffer + rp_data->jsonBuffer + rp_data->titlBuffer + rp_data->descBuffer + GTA5_HEADERSIZE + 56UL); return (rp_data->jpegBuffer + rp_data->jsonBuffer + rp_data->titlBuffer + rp_data->descBuffer + GTA5_HEADERSIZE + 56UL);
@ -935,17 +945,17 @@ size_t RagePhoto::saveSize(RagePhotoData *rp_data, RagePhotoFormatParser *rp_par
size_t RagePhoto::saveSize(RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser) size_t RagePhoto::saveSize(RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser)
{ {
return saveSize(rp_data, rp_parser, rp_data->photoFormat); return saveSize(rp_data->photoFormat, rp_data, rp_parser);
} }
size_t RagePhoto::saveSize(uint32_t photoFormat) size_t RagePhoto::saveSize(uint32_t photoFormat)
{ {
return saveSize(m_data, m_parser, photoFormat); return saveSize(photoFormat, m_data, m_parser);
} }
size_t RagePhoto::saveSize() size_t RagePhoto::saveSize()
{ {
return saveSize(m_data->photoFormat); return saveSize(m_data->photoFormat, m_data, m_parser);
} }
void RagePhoto::setBufferDefault(RagePhotoData *rp_data) void RagePhoto::setBufferDefault(RagePhotoData *rp_data)
@ -974,24 +984,13 @@ void RagePhoto::setBufferOffsets()
setBufferOffsets(m_data); setBufferOffsets(m_data);
} }
bool RagePhoto::setData(RagePhotoData *rp_data, bool takeOwnership) bool RagePhoto::setData(RagePhotoData *rp_data, bool takeCopy)
{ {
if (m_data == rp_data) if (m_data == rp_data)
return true; return true;
if (takeOwnership) { if (takeCopy) {
std::free(m_data->jpeg); clear(m_data);
std::free(m_data->description);
std::free(m_data->json);
std::free(m_data->header);
std::free(m_data->title);
std::free(m_data);
m_data = rp_data;
}
else {
clear();
m_data->photoFormat = rp_data->photoFormat; m_data->photoFormat = rp_data->photoFormat;
if (rp_data->header) { if (rp_data->header) {
@ -1041,8 +1040,17 @@ bool RagePhoto::setData(RagePhotoData *rp_data, bool takeOwnership)
m_data->unnamedSum1 = rp_data->unnamedSum1; m_data->unnamedSum1 = rp_data->unnamedSum1;
m_data->unnamedSum2 = rp_data->unnamedSum2; m_data->unnamedSum2 = rp_data->unnamedSum2;
setBufferOffsets(m_data);
}
else {
std::free(m_data->jpeg);
std::free(m_data->description);
std::free(m_data->json);
std::free(m_data->header);
std::free(m_data->title);
std::free(m_data);
setBufferOffsets(); m_data = rp_data;
} }
return true; return true;
@ -1056,7 +1064,7 @@ void RagePhoto::setDescription(const char *description, uint32_t bufferSize)
} }
if (bufferSize != 0) { if (bufferSize != 0) {
m_data->descBuffer = bufferSize; m_data->descBuffer = bufferSize;
setBufferOffsets(); setBufferOffsets(m_data);
} }
m_data->error = Error::NoError; // 255 m_data->error = Error::NoError; // 255
} }
@ -1066,30 +1074,7 @@ void RagePhoto::setFormat(uint32_t photoFormat)
m_data->photoFormat = photoFormat; m_data->photoFormat = photoFormat;
} }
void RagePhoto::setJson(const char *json, uint32_t bufferSize) bool RagePhoto::setJpeg(const char *data, uint32_t size, uint32_t bufferSize)
{
if (!writeDataChar(json, &m_data->json)) {
m_data->error = Error::JsonMallocError; // 21
return;
}
if (bufferSize != 0) {
m_data->jsonBuffer = bufferSize;
setBufferOffsets();
}
m_data->error = Error::NoError; // 255
}
void RagePhoto::setHeader(const char *header, uint32_t headerSum)
{
if (!writeDataChar(header, &m_data->header)) {
m_data->error = Error::HeaderMallocError; // 4
return;
}
m_data->headerSum = headerSum;
m_data->error = Error::NoError; // 255
}
bool RagePhoto::setPhoto(const char *data, uint32_t size, uint32_t bufferSize)
{ {
if (m_data->jpeg) { if (m_data->jpeg) {
if (m_data->jpegSize > size) { if (m_data->jpegSize > size) {
@ -1128,16 +1113,39 @@ bool RagePhoto::setPhoto(const char *data, uint32_t size, uint32_t bufferSize)
if (bufferSize != 0) { if (bufferSize != 0) {
m_data->jpegBuffer = bufferSize; m_data->jpegBuffer = bufferSize;
setBufferOffsets(); setBufferOffsets(m_data);
} }
m_data->error = Error::NoError; // 255 m_data->error = Error::NoError; // 255
return true; return true;
} }
bool RagePhoto::setPhoto(const std::string &data, uint32_t bufferSize) bool RagePhoto::setJpeg(const std::string &data, uint32_t bufferSize)
{ {
return setPhoto(data.data(), static_cast<uint32_t>(data.size()), bufferSize); return setJpeg(data.data(), static_cast<uint32_t>(data.size()), bufferSize);
}
void RagePhoto::setJson(const char *json, uint32_t bufferSize)
{
if (!writeDataChar(json, &m_data->json)) {
m_data->error = Error::JsonMallocError; // 21
return;
}
if (bufferSize != 0) {
m_data->jsonBuffer = bufferSize;
setBufferOffsets(m_data);
}
m_data->error = Error::NoError; // 255
}
void RagePhoto::setHeader(const char *header, uint32_t headerSum)
{
if (!writeDataChar(header, &m_data->header)) {
m_data->error = Error::HeaderMallocError; // 4
return;
}
m_data->headerSum = headerSum;
m_data->error = Error::NoError; // 255
} }
void RagePhoto::setTitle(const char *title, uint32_t bufferSize) void RagePhoto::setTitle(const char *title, uint32_t bufferSize)
@ -1148,7 +1156,7 @@ void RagePhoto::setTitle(const char *title, uint32_t bufferSize)
} }
if (bufferSize != 0) { if (bufferSize != 0) {
m_data->titlBuffer = bufferSize; m_data->titlBuffer = bufferSize;
setBufferOffsets(); setBufferOffsets(m_data);
} }
m_data->error = Error::NoError; // 255 m_data->error = Error::NoError; // 255
} }
@ -1184,7 +1192,7 @@ ragephoto_bool_t ragephoto_load(ragephoto_t instance, const char *data, size_t s
ragephoto_bool_t ragephotodata_load(RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser, const char *data, size_t size) ragephoto_bool_t ragephotodata_load(RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser, const char *data, size_t size)
{ {
return RagePhoto::load(rp_data, rp_parser, data, size); return RagePhoto::load(data, size, rp_data, rp_parser);
} }
ragephoto_bool_t ragephoto_loadfile(ragephoto_t instance, const char *filename) ragephoto_bool_t ragephoto_loadfile(ragephoto_t instance, const char *filename)
@ -1240,7 +1248,7 @@ uint32_t ragephoto_getphotoformat(ragephoto_t instance)
const char* ragephoto_getphotojpeg(ragephoto_t instance) const char* ragephoto_getphotojpeg(ragephoto_t instance)
{ {
RagePhoto *ragePhoto = static_cast<RagePhoto*>(instance); RagePhoto *ragePhoto = static_cast<RagePhoto*>(instance);
return ragePhoto->photoData(); return ragePhoto->jpegData();
} }
const char* ragephoto_getphotojson(ragephoto_t instance) const char* ragephoto_getphotojson(ragephoto_t instance)
@ -1258,7 +1266,7 @@ const char* ragephoto_getphotoheader(ragephoto_t instance)
uint32_t ragephoto_getphotosize(ragephoto_t instance) uint32_t ragephoto_getphotosize(ragephoto_t instance)
{ {
RagePhoto *ragePhoto = static_cast<RagePhoto*>(instance); RagePhoto *ragePhoto = static_cast<RagePhoto*>(instance);
return ragePhoto->photoSize(); return ragePhoto->jpegSize();
} }
const char* ragephoto_getphototitle(ragephoto_t instance) const char* ragephoto_getphototitle(ragephoto_t instance)
@ -1286,7 +1294,7 @@ size_t ragephoto_getsavesizef(ragephoto_t instance, uint32_t photoFormat)
size_t ragephotodata_getsavesizef(RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser, uint32_t photoFormat) size_t ragephotodata_getsavesizef(RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser, uint32_t photoFormat)
{ {
return RagePhoto::saveSize(rp_data, rp_parser, photoFormat); return RagePhoto::saveSize(photoFormat, rp_data, rp_parser);
} }
ragephoto_bool_t ragephoto_save(ragephoto_t instance, char *data) ragephoto_bool_t ragephoto_save(ragephoto_t instance, char *data)
@ -1295,12 +1303,22 @@ ragephoto_bool_t ragephoto_save(ragephoto_t instance, char *data)
return ragePhoto->save(data); return ragePhoto->save(data);
} }
ragephoto_bool_t ragephotodata_save(RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser, char *data)
{
return RagePhoto::save(data, rp_data->photoFormat, rp_data, rp_parser);
}
ragephoto_bool_t ragephoto_savef(ragephoto_t instance, char *data, uint32_t photoFormat) ragephoto_bool_t ragephoto_savef(ragephoto_t instance, char *data, uint32_t photoFormat)
{ {
RagePhoto *ragePhoto = static_cast<RagePhoto*>(instance); RagePhoto *ragePhoto = static_cast<RagePhoto*>(instance);
return ragePhoto->save(data, photoFormat); return ragePhoto->save(data, photoFormat);
} }
ragephoto_bool_t ragephotodata_savef(RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser, char *data, uint32_t photoFormat)
{
return RagePhoto::save(data, photoFormat, rp_data, rp_parser);
}
ragephoto_bool_t ragephoto_savefile(ragephoto_t instance, const char *filename) ragephoto_bool_t ragephoto_savefile(ragephoto_t instance, const char *filename)
{ {
RagePhoto *ragePhoto = static_cast<RagePhoto*>(instance); RagePhoto *ragePhoto = static_cast<RagePhoto*>(instance);
@ -1338,13 +1356,13 @@ void ragephotodata_setbufferoffsets(RagePhotoData *rp_data)
ragephoto_bool_t ragephoto_setphotodata(ragephoto_t instance, RagePhotoData *rp_data) ragephoto_bool_t ragephoto_setphotodata(ragephoto_t instance, RagePhotoData *rp_data)
{ {
RagePhoto *ragePhoto = static_cast<RagePhoto*>(instance); RagePhoto *ragePhoto = static_cast<RagePhoto*>(instance);
return ragePhoto->setData(rp_data, true); return ragePhoto->setData(rp_data, false);
} }
ragephoto_bool_t ragephoto_setphotodatac(ragephoto_t instance, RagePhotoData *rp_data) ragephoto_bool_t ragephoto_setphotodatac(ragephoto_t instance, RagePhotoData *rp_data)
{ {
RagePhoto *ragePhoto = static_cast<RagePhoto*>(instance); RagePhoto *ragePhoto = static_cast<RagePhoto*>(instance);
return ragePhoto->setData(rp_data, false); return ragePhoto->setData(rp_data, true);
} }
void ragephoto_setphotodesc(ragephoto_t instance, const char *description, uint32_t bufferSize) void ragephoto_setphotodesc(ragephoto_t instance, const char *description, uint32_t bufferSize)
@ -1362,7 +1380,7 @@ void ragephoto_setphotoformat(ragephoto_t instance, uint32_t photoFormat)
ragephoto_bool_t ragephoto_setphotojpeg(ragephoto_t instance, const char *data, uint32_t size, uint32_t bufferSize) ragephoto_bool_t ragephoto_setphotojpeg(ragephoto_t instance, const char *data, uint32_t size, uint32_t bufferSize)
{ {
RagePhoto *ragePhoto = static_cast<RagePhoto*>(instance); RagePhoto *ragePhoto = static_cast<RagePhoto*>(instance);
return ragePhoto->setPhoto(data, size, bufferSize); return ragePhoto->setJpeg(data, size, bufferSize);
} }
void ragephoto_setphotojson(ragephoto_t instance, const char *json, uint32_t bufferSize) void ragephoto_setphotojson(ragephoto_t instance, const char *json, uint32_t bufferSize)

22
src/RagePhoto.h
View file

@ -98,7 +98,7 @@ public:
static void clear(RagePhotoData *rp_data); /**< Resets the RagePhotoData object to default values. */ static void clear(RagePhotoData *rp_data); /**< Resets the RagePhotoData object to default values. */
void clear(); /**< Resets the RagePhotoData object to default values. */ void clear(); /**< Resets the RagePhotoData object to default values. */
RagePhotoData* data(); /**< Returns the internal RagePhotoData object. */ RagePhotoData* data(); /**< Returns the internal RagePhotoData object. */
static bool load(RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser, const char *data, size_t size); /**< Loads a Photo from a const char*. */ static bool load(const char *data, size_t size, RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser); /**< Loads a Photo from a const char*. */
/** Loads a Photo from a const char*. /** Loads a Photo from a const char*.
* \param data Photo data * \param data Photo data
* \param size Photo data size * \param size Photo data size
@ -114,14 +114,16 @@ public:
bool loadFile(const std::string &filename); bool loadFile(const std::string &filename);
int32_t error() const; /**< Returns the last error occurred. */ int32_t error() const; /**< Returns the last error occurred. */
uint32_t format() const; /**< Returns the Photo Format (GTA V or RDR 2). */ uint32_t format() const; /**< Returns the Photo Format (GTA V or RDR 2). */
const std::string photo() const; /**< Returns the Photo JPEG data. */ const std::string jpeg() const; /**< Returns the Photo JPEG data. */
const char *photoData() const; /**< Returns the Photo JPEG data. */ const char *jpegData() const; /**< Returns the Photo JPEG data. */
uint32_t photoSize() const; /**< Returns the Photo JPEG data size. */ uint32_t jpegSize() const; /**< Returns the Photo JPEG data size. */
const char* description() const; /**< Returns the Photo description. */ const char* description() const; /**< Returns the Photo description. */
const char* json() const; /**< Returns the Photo JSON data. */ const char* json() const; /**< Returns the Photo JSON data. */
const char* header() const; /**< Returns the Photo header. */ const char* header() const; /**< Returns the Photo header. */
const char* title() const; /**< Returns the Photo title. */ const char* title() const; /**< Returns the Photo title. */
static const char* version(); /**< Returns the library version. */ static const char* version(); /**< Returns the library version. */
static bool save(char *data, uint32_t photoFormat, RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser); /**< Saves a Photo to a char*. */
static bool save(char *data, RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser); /**< Saves a Photo to a char*. */
/** Saves a Photo to a char*. /** Saves a Photo to a char*.
* \param data Photo data * \param data Photo data
* \param photoFormat Photo Format (GTA V or RDR 2) * \param photoFormat Photo Format (GTA V or RDR 2)
@ -142,7 +144,7 @@ public:
const std::string save(bool *ok = nullptr); const std::string save(bool *ok = nullptr);
bool saveFile(const std::string &filename, uint32_t photoFormat); /**< Saves a Photo to a file. */ bool saveFile(const std::string &filename, uint32_t photoFormat); /**< Saves a Photo to a file. */
bool saveFile(const std::string &filename); /**< Saves a Photo to a file. */ bool saveFile(const std::string &filename); /**< Saves a Photo to a file. */
static size_t saveSize(RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser, uint32_t photoFormat); /**< Returns the Photo save file size. */ static size_t saveSize(uint32_t photoFormat, RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser); /**< Returns the Photo save file size. */
static size_t saveSize(RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser); /**< Returns the Photo save file size. */ static size_t saveSize(RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser); /**< Returns the Photo save file size. */
size_t saveSize(uint32_t photoFormat); /**< Returns the Photo save file size. */ size_t saveSize(uint32_t photoFormat); /**< Returns the Photo save file size. */
size_t saveSize(); /**< Returns the Photo save file size. */ size_t saveSize(); /**< Returns the Photo save file size. */
@ -150,22 +152,22 @@ public:
void setBufferDefault(); /**< Sets all cross-format Buffer to default size. */ void setBufferDefault(); /**< Sets all cross-format Buffer to default size. */
static void setBufferOffsets(RagePhotoData *rp_data); /**< Moves all Buffer offsets to correct position. */ static void setBufferOffsets(RagePhotoData *rp_data); /**< Moves all Buffer offsets to correct position. */
void setBufferOffsets(); /**< Moves all Buffer offsets to correct position. */ void setBufferOffsets(); /**< Moves all Buffer offsets to correct position. */
bool setData(RagePhotoData *rp_data, bool takeOwnership = true); /**< Sets the internal RagePhotoData object. */ bool setData(RagePhotoData *rp_data, bool takeCopy = true); /**< Sets the internal RagePhotoData object. */
void setDescription(const char *description, uint32_t bufferSize = 0); /**< Sets the Photo description. */ void setDescription(const char *description, uint32_t bufferSize = 0); /**< Sets the Photo description. */
void setFormat(uint32_t photoFormat); /**< Sets the Photo Format (GTA V or RDR 2). */ void setFormat(uint32_t photoFormat); /**< Sets the Photo Format (GTA V or RDR 2). */
void setJson(const char *json, uint32_t bufferSize = 0); /**< Sets the Photo JSON data. */
void setHeader(const char *header, uint32_t headerSum); /**< Sets the Photo header. (EXPERT ONLY) */
/** Sets the Photo JPEG data. /** Sets the Photo JPEG data.
* \param data JPEG data * \param data JPEG data
* \param size JPEG data size * \param size JPEG data size
* \param bufferSize JPEG buffer size * \param bufferSize JPEG buffer size
*/ */
bool setPhoto(const char *data, uint32_t size, uint32_t bufferSize = 0); bool setJpeg(const char *data, uint32_t size, uint32_t bufferSize = 0);
/** Sets the Photo JPEG data. /** Sets the Photo JPEG data.
* \param data JPEG data * \param data JPEG data
* \param bufferSize JPEG buffer size * \param bufferSize JPEG buffer size
*/ */
bool setPhoto(const std::string &data, uint32_t bufferSize = 0); bool setJpeg(const std::string &data, uint32_t bufferSize = 0);
void setJson(const char *json, uint32_t bufferSize = 0); /**< Sets the Photo JSON data. */
void setHeader(const char *header, uint32_t headerSum); /**< Sets the Photo header. (EXPERT ONLY) */
void setTitle(const char *title, uint32_t bufferSize = 0); /**< Sets the Photo title. */ void setTitle(const char *title, uint32_t bufferSize = 0); /**< Sets the Photo title. */
private: private:

56
src/RagePhotoA.h
View file

@ -115,7 +115,7 @@ public:
return ragephoto_getphotodata(instance); return ragephoto_getphotodata(instance);
} }
/** Loads a Photo from a const char*. */ /** Loads a Photo from a const char*. */
static bool load(RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser, const char *data, size_t size) { static bool load(const char *data, size_t size, RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser) {
return ragephotodata_load(rp_data, rp_parser, data, size); return ragephotodata_load(rp_data, rp_parser, data, size);
} }
/** Loads a Photo from a const char*. /** Loads a Photo from a const char*.
@ -146,15 +146,15 @@ public:
return ragephoto_getphotoformat(instance); return ragephoto_getphotoformat(instance);
} }
/** Returns the Photo JPEG data. */ /** Returns the Photo JPEG data. */
const std::string photo() const { const std::string jpeg() const {
return std::string(ragephoto_getphotojpeg(instance), ragephoto_getphotosize(instance)); return std::string(ragephoto_getphotojpeg(instance), ragephoto_getphotosize(instance));
} }
/** Returns the Photo JPEG data. */ /** Returns the Photo JPEG data. */
const char *photoData() const { const char *jpegData() const {
return ragephoto_getphotojpeg(instance); return ragephoto_getphotojpeg(instance);
} }
/** Returns the Photo JPEG data size. */ /** Returns the Photo JPEG data size. */
uint32_t photoSize() const { uint32_t jpegSize() const {
return ragephoto_getphotosize(instance); return ragephoto_getphotosize(instance);
} }
/** Returns the Photo description. */ /** Returns the Photo description. */
@ -177,6 +177,14 @@ public:
static const char* version() { static const char* version() {
return ragephoto_version(); return ragephoto_version();
} }
/** Saves a Photo to a char*. */
static bool save(char *data, uint32_t photoFormat, RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser) {
return ragephotodata_savef(rp_data, rp_parser, data, photoFormat);
}
/** Saves a Photo to a char*. */
static bool save(char *data, RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser) {
return ragephotodata_save(rp_data, rp_parser, data);
}
/** Saves a Photo to a char*. /** Saves a Photo to a char*.
* \param data Photo data * \param data Photo data
* \param photoFormat Photo Format (GTA V or RDR 2) * \param photoFormat Photo Format (GTA V or RDR 2)
@ -223,7 +231,7 @@ public:
return ragephoto_savefile(instance, filename); return ragephoto_savefile(instance, filename);
} }
/** Returns the Photo save file size. */ /** Returns the Photo save file size. */
static size_t saveSize(RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser, uint32_t photoFormat) { static size_t saveSize(uint32_t photoFormat, RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser) {
return ragephotodata_getsavesizef(rp_data, rp_parser, photoFormat); return ragephotodata_getsavesizef(rp_data, rp_parser, photoFormat);
} }
/** Returns the Photo save file size. */ /** Returns the Photo save file size. */
@ -255,11 +263,11 @@ public:
ragephoto_setbufferoffsets(instance); ragephoto_setbufferoffsets(instance);
} }
/** Sets the internal RagePhotoData object. */ /** Sets the internal RagePhotoData object. */
bool setData(RagePhotoData *ragePhotoData, bool takeOwnership = true) { bool setData(RagePhotoData *ragePhotoData, bool takeCopy = true) {
if (takeOwnership) if (takeCopy)
return ragephoto_setphotodata(&instance, ragePhotoData);
else
return ragephoto_setphotodatac(instance, ragePhotoData); return ragephoto_setphotodatac(instance, ragePhotoData);
else
return ragephoto_setphotodata(&instance, ragePhotoData);
} }
/** Sets the Photo description. */ /** Sets the Photo description. */
void setDescription(const char *description, uint32_t bufferSize = 0) { void setDescription(const char *description, uint32_t bufferSize = 0) {
@ -269,6 +277,21 @@ public:
void setFormat(uint32_t photoFormat) { void setFormat(uint32_t photoFormat) {
ragephoto_setphotoformat(instance, photoFormat); ragephoto_setphotoformat(instance, photoFormat);
} }
/** Sets the Photo JPEG data.
* \param data JPEG data
* \param size JPEG data size
* \param bufferSize JPEG buffer size
*/
bool setJpeg(const char *data, uint32_t size, uint32_t bufferSize = 0) {
return ragephoto_setphotojpeg(instance, data, size, bufferSize);
}
/** Sets the Photo JPEG data.
* \param data JPEG data
* \param bufferSize JPEG buffer size
*/
bool setJpeg(const std::string &data, uint32_t bufferSize = 0) {
return ragephoto_setphotojpeg(instance, data.data(), static_cast<uint32_t>(data.size()), bufferSize);
}
/** Sets the Photo JSON data. */ /** Sets the Photo JSON data. */
void setJson(const char *json, uint32_t bufferSize = 0) { void setJson(const char *json, uint32_t bufferSize = 0) {
ragephoto_setphotojson(instance, json, bufferSize); ragephoto_setphotojson(instance, json, bufferSize);
@ -277,21 +300,6 @@ public:
void setHeader(const char *header, uint32_t headerSum) { void setHeader(const char *header, uint32_t headerSum) {
ragephoto_setphotoheader(instance, header, headerSum); ragephoto_setphotoheader(instance, header, headerSum);
} }
/** Sets the Photo JPEG data.
* \param data JPEG data
* \param size JPEG data size
* \param bufferSize JPEG buffer size
*/
bool setPhoto(const char *data, uint32_t size, uint32_t bufferSize = 0) {
return ragephoto_setphotojpeg(instance, data, size, bufferSize);
}
/** Sets the Photo JPEG data.
* \param data JPEG data
* \param bufferSize JPEG buffer size
*/
bool setPhoto(const std::string &data, uint32_t bufferSize = 0) {
return ragephoto_setphotojpeg(instance, data.data(), static_cast<uint32_t>(data.size()), bufferSize);
}
/** Sets the Photo title. */ /** Sets the Photo title. */
void setTitle(const char *title, uint32_t bufferSize = 0) { void setTitle(const char *title, uint32_t bufferSize = 0) {
ragephoto_setphototitle(instance, title, bufferSize); ragephoto_setphototitle(instance, title, bufferSize);

15
src/RagePhotoC.h
View file

@ -163,6 +163,13 @@ LIBRAGEPHOTO_C_BINDING size_t ragephotodata_getsavesizef(RagePhotoData *rp_data,
*/ */
LIBRAGEPHOTO_C_BINDING ragephoto_bool_t ragephoto_save(ragephoto_t instance, char *data); LIBRAGEPHOTO_C_BINDING ragephoto_bool_t ragephoto_save(ragephoto_t instance, char *data);
/** Saves a Photo to a char*.
* \param rp_data RagePhotoData object
* \param rp_parser RagePhotoFormatParser parser array
* \param data Photo data
*/
LIBRAGEPHOTO_C_BINDING ragephoto_bool_t ragephotodata_save(RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser, char *data);
/** Saves a Photo to a char*. /** Saves a Photo to a char*.
* \param instance \p ragephoto_t instance * \param instance \p ragephoto_t instance
* \param data Photo data * \param data Photo data
@ -170,6 +177,14 @@ LIBRAGEPHOTO_C_BINDING ragephoto_bool_t ragephoto_save(ragephoto_t instance, cha
*/ */
LIBRAGEPHOTO_C_BINDING ragephoto_bool_t ragephoto_savef(ragephoto_t instance, char *data, uint32_t photoFormat); LIBRAGEPHOTO_C_BINDING ragephoto_bool_t ragephoto_savef(ragephoto_t instance, char *data, uint32_t photoFormat);
/** Saves a Photo to a char*.
* \param rp_data RagePhotoData object
* \param rp_parser RagePhotoFormatParser parser array
* \param data Photo data
* \param photoFormat Photo Format (GTA V or RDR 2)
*/
LIBRAGEPHOTO_C_BINDING ragephoto_bool_t ragephotodata_savef(RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser, char *data, uint32_t photoFormat);
/** Saves a Photo to a file. /** Saves a Photo to a file.
* \param instance \p ragephoto_t instance * \param instance \p ragephoto_t instance
* \param filename File to save * \param filename File to save