ragephoto_c.hpp

/*****************************************************************************
* libragephoto RAGE Photo Parser
* Copyright (C) 2021-2025 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_C_HPP
#define RAGEPHOTO_C_HPP
 
#ifdef __cplusplus
#include "RagePhoto.h"
#include <cstdlib>
#include <iostream>
 
namespace ragephoto_c {

class photo
{
public:
    enum DefaultSize : uint32_t {
        DEFAULT_GTA5_PHOTOBUFFER = RAGEPHOTO_DEFAULT_GTA5_PHOTOBUFFER, 
        DEFAULT_RDR2_PHOTOBUFFER = RAGEPHOTO_DEFAULT_RDR2_PHOTOBUFFER, 
        DEFAULT_DESCBUFFER = RAGEPHOTO_DEFAULT_DESCBUFFER, 
        DEFAULT_JSONBUFFER = RAGEPHOTO_DEFAULT_JSONBUFFER, 
        DEFAULT_TITLBUFFER = RAGEPHOTO_DEFAULT_TITLBUFFER, 
        GTA5_HEADERSIZE = RAGEPHOTO_GTA5_HEADERSIZE, 
        RDR2_HEADERSIZE = RAGEPHOTO_RDR2_HEADERSIZE 
    };

    enum Error : int32_t {
        DescBufferTight = RAGEPHOTO_ERROR_DESCBUFFERTIGHT, 
        DescMallocError = RAGEPHOTO_ERROR_DESCMALLOCERROR, 
        DescReadError = RAGEPHOTO_ERROR_DESCREADERROR, 
        HeaderBufferTight = RAGEPHOTO_ERROR_HEADERBUFFERTIGHT, 
        HeaderMallocError = RAGEPHOTO_ERROR_HEADERMALLOCERROR, 
        IncompatibleFormat = RAGEPHOTO_ERROR_INCOMPATIBLEFORMAT, 
        IncompleteChecksum = RAGEPHOTO_ERROR_INCOMPLETECHECKSUM, 
        IncompleteDescBuffer = RAGEPHOTO_ERROR_INCOMPLETEDESCBUFFER, 
        IncompleteDescMarker = RAGEPHOTO_ERROR_INCOMPLETEDESCMARKER, 
        IncompleteDescOffset = RAGEPHOTO_ERROR_INCOMPLETEDESCOFFSET, 
        IncompleteEOF = RAGEPHOTO_ERROR_INCOMPLETEEOF, 
        IncompleteHeader = RAGEPHOTO_ERROR_INCOMPLETEHEADER, 
        IncompleteJendMarker = RAGEPHOTO_ERROR_INCOMPLETEJENDMARKER, 
        IncompleteJpegMarker = RAGEPHOTO_ERROR_INCOMPLETEJPEGMARKER, 
        IncompleteJsonBuffer = RAGEPHOTO_ERROR_INCOMPLETEJSONBUFFER, 
        IncompleteJsonMarker = RAGEPHOTO_ERROR_INCOMPLETEJSONMARKER, 
        IncompleteJsonOffset = RAGEPHOTO_ERROR_INCOMPLETEJSONOFFSET, 
        IncompletePhotoBuffer = RAGEPHOTO_ERROR_INCOMPLETEPHOTOBUFFER, 
        IncompletePhotoSize = RAGEPHOTO_ERROR_INCOMPLETEPHOTOSIZE, 
        IncompleteTitleBuffer = RAGEPHOTO_ERROR_INCOMPLETETITLEBUFFER, 
        IncompleteTitleMarker = RAGEPHOTO_ERROR_INCOMPLETETITLEMARKER, 
        IncompleteTitleOffset = RAGEPHOTO_ERROR_INCOMPLETETITLEOFFSET, 
        IncorrectDescMarker = RAGEPHOTO_ERROR_INCORRECTDESCMARKER, 
        IncorrectJendMarker = RAGEPHOTO_ERROR_INCORRECTJENDMARKER, 
        IncorrectJpegMarker = RAGEPHOTO_ERROR_INCORRECTJPEGMARKER, 
        IncorrectJsonMarker = RAGEPHOTO_ERROR_INCORRECTJSONMARKER, 
        IncorrectTitleMarker = RAGEPHOTO_ERROR_INCORRECTTITLEMARKER, 
        JsonBufferTight = RAGEPHOTO_ERROR_JSONBUFFERTIGHT, 
        JsonMallocError = RAGEPHOTO_ERROR_JSONMALLOCERROR, 
        JsonReadError = RAGEPHOTO_ERROR_JSONREADERROR, 
        NoError = RAGEPHOTO_ERROR_NOERROR, 
        NoFormatIdentifier = RAGEPHOTO_ERROR_NOFORMATIDENTIFIER, 
        PhotoBufferTight = RAGEPHOTO_ERROR_PHOTOBUFFERTIGHT, 
        PhotoMallocError = RAGEPHOTO_ERROR_PHOTOMALLOCERROR, 
        PhotoReadError = RAGEPHOTO_ERROR_PHOTOREADERROR, 
        TitleBufferTight = RAGEPHOTO_ERROR_TITLEBUFFERTIGHT, 
        TitleMallocError = RAGEPHOTO_ERROR_TITLEMALLOCERROR, 
        TitleReadError = RAGEPHOTO_ERROR_TITLEREADERROR, 
        UnicodeInitError = RAGEPHOTO_ERROR_UNICODEINITERROR, 
        UnicodeHeaderError = RAGEPHOTO_ERROR_UNICODEHEADERERROR, 
        Uninitialised = RAGEPHOTO_ERROR_UNINITIALISED 
    };

    enum PhotoFormat : uint32_t {
        JPEG = RAGEPHOTO_FORMAT_JPEG, 
        GTA5 = RAGEPHOTO_FORMAT_GTA5, 
        RDR2 = RAGEPHOTO_FORMAT_RDR2 
    };

    enum SignInitials : uint32_t {
        SIGTA5 = RAGEPHOTO_SIGNINITIAL_GTA5, 
        SIRDR2 = RAGEPHOTO_SIGNINITIAL_RDR2 
    };
    photo() {
        instance = ragephoto_open();
        if (!instance)
            throw std::runtime_error("ragephoto_t instance can't be allocated");
    }
    ~photo() {
        ragephoto_close(instance);
    }
    void addParser(RagePhotoFormatParser *rp_parser) {
        ragephoto_addparser(instance, rp_parser);
    }

    static void clear(RagePhotoData *rp_data) {
        ragephotodata_clear(rp_data);
    }

    void clear() {
        ragephoto_clear(instance);
    }

    RagePhotoData* data() {
        return ragephoto_getphotodata(instance);
    }

    static bool load(const char *data, size_t size, RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser) {
        return ragephotodata_load(rp_data, rp_parser, data, size);
    }

    bool load(const char *data, size_t size) {
        return ragephoto_load(instance, data, size);
    }

    bool load(const std::string &data) {
        return ragephoto_load(instance, data.data(), data.size());
    }

    bool loadFile(const char *filename) {
        return ragephoto_loadfile(instance, filename);
    }

    int32_t error() const {
        return ragephoto_error(instance);
    }

    uint32_t format() const {
        return ragephoto_getphotoformat(instance);
    }

    const std::string jpeg() const {
        const char *jpegData = ragephoto_getphotojpeg(instance);
        if (jpegData)
            return std::string(jpegData, ragephoto_getphotosize(instance));
        else
            return std::string();
    }
#if (__cplusplus >= 201703L)
    const std::string_view jpeg_view() const {
        const char *jpegData = ragephoto_getphotojpeg(instance);
        if (jpegData)
            return std::string_view(jpegData, ragephoto_getphotosize(instance));
        else
            return std::string_view();
    }
#endif
    const char* jpegData() const {
        return ragephoto_getphotojpeg(instance);
    }

    static uint64_t jpegSign(uint32_t photoFormat, RagePhotoData *rp_data) {
        return ragephotodata_getphotosignf(rp_data, photoFormat);
    }

    static uint64_t jpegSign(RagePhotoData *rp_data) {
        return ragephotodata_getphotosign(rp_data);
    }

    uint64_t jpegSign(uint32_t photoFormat) const {
        return ragephoto_getphotosignf(instance, photoFormat);
    }

    uint64_t jpegSign() const {
        return ragephoto_getphotosign(instance);
    }

    uint32_t jpegSize() const {
        return ragephoto_getphotosize(instance);
    }

    const char* description() const {
        return ragephoto_getphotodesc(instance);
    }

    const char* header() const {
        return ragephoto_getphotoheader(instance);
    }

    const char* json() const {
        return ragephoto_getphotojson(instance);
    }

    const char* title() const {
        return ragephoto_getphototitle(instance);
    }

    static const char* version() {
        return ragephoto_version();
    }

    static bool save(char *data, uint32_t photoFormat, RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser) {
        return ragephotodata_savef(rp_data, rp_parser, data, photoFormat);
    }

    static bool save(char *data, RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser) {
        return ragephotodata_save(rp_data, rp_parser, data);
    }

    bool save(char *data, uint32_t photoFormat) {
        return ragephoto_savef(instance, data, photoFormat);
    }

    bool save(char *data) {
        return ragephoto_save(instance, data);
    }

    const std::string save(uint32_t photoFormat, bool *ok = nullptr) {
        std::string sdata;
        const size_t size = ragephoto_getsavesizef(instance, photoFormat);
        if (size == 0) {
            if (ok)
                *ok = false;
            return sdata;
        }
        sdata.resize(size);
        const bool saved = ragephoto_savef(instance, &sdata[0], photoFormat);
        if (ok)
            *ok = saved;
        return sdata;
    }

    const std::string save(bool *ok = nullptr) {
        return save(ragephoto_getphotoformat(instance), ok);
    }

    bool saveFile(const char *filename, uint32_t photoFormat) {
        return ragephoto_savefilef(instance, filename, photoFormat);
    }

    bool saveFile(const char *filename) {
        return ragephoto_savefile(instance, filename);
    }

    static size_t saveSize(uint32_t photoFormat, RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser) {
        return ragephotodata_getsavesizef(rp_data, rp_parser, photoFormat);
    }

    static size_t saveSize(RagePhotoData *rp_data, RagePhotoFormatParser *rp_parser) {
        return ragephotodata_getsavesize(rp_data, rp_parser);
    }

    size_t saveSize(uint32_t photoFormat) {
        return ragephoto_getsavesizef(instance, photoFormat);
    }

    size_t saveSize() {
        return ragephoto_getsavesize(instance);
    }

    static void setBufferDefault(RagePhotoData *rp_data) {
        ragephotodata_setbufferdefault(rp_data);
    }

    void setBufferDefault() {
        ragephoto_setbufferdefault(instance);
    }

    static void setBufferOffsets(RagePhotoData *rp_data) {
        ragephotodata_setbufferoffsets(rp_data);
    }

    void setBufferOffsets() {
        ragephoto_setbufferoffsets(instance);
    }

    bool setData(RagePhotoData *ragePhotoData, bool takeCopy = true) {
        if (takeCopy)
            return ragephoto_setphotodatac(instance, ragePhotoData);
        else
            return ragephoto_setphotodata(instance, ragePhotoData);
    }

    void setDescription(const char *description, uint32_t bufferSize = 0) {
        ragephoto_setphotodesc(instance, description, bufferSize);
    }

    void setFormat(uint32_t photoFormat) {
        ragephoto_setphotoformat(instance, photoFormat);
    }

    void setHeader(const char *header, uint32_t headerSum, uint32_t headerSum2 = 0) {
        ragephoto_setphotoheader2(instance, header, headerSum, headerSum2);
    }

    bool setJpeg(const char *data, uint32_t size, uint32_t bufferSize = 0) {
        return ragephoto_setphotojpeg(instance, data, size, bufferSize);
    }

    bool setJpeg(const std::string &data, uint32_t bufferSize = 0) {
        return ragephoto_setphotojpeg(instance, data.data(), static_cast<uint32_t>(data.size()), bufferSize);
    }

    void setJson(const char *json, uint32_t bufferSize = 0) {
        ragephoto_setphotojson(instance, json, bufferSize);
    }

    static void setLibraryFlag(RagePhotoLibraryFlag flag, bool state = true) {
        ragephoto_setlibraryflag(flag, state);
    }

    void setTitle(const char *title, uint32_t bufferSize = 0) {
        ragephoto_setphototitle(instance, title, bufferSize);
    }
 
private:
    ragephoto_t instance;
};
 
} // ragephoto_c
#endif // __cplusplus
 
#endif // RAGEPHOTO_C_HPP