id
int64 0
755k
| file_name
stringlengths 3
109
| file_path
stringlengths 13
185
| content
stringlengths 31
9.38M
| size
int64 31
9.38M
| language
stringclasses 1
value | extension
stringclasses 11
values | total_lines
int64 1
340k
| avg_line_length
float64 2.18
149k
| max_line_length
int64 7
2.22M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 6
65
| repo_stars
int64 100
47.3k
| repo_forks
int64 0
12k
| repo_open_issues
int64 0
3.4k
| repo_license
stringclasses 9
values | repo_extraction_date
stringclasses 92
values | exact_duplicates_redpajama
bool 2
classes | near_duplicates_redpajama
bool 2
classes | exact_duplicates_githubcode
bool 2
classes | exact_duplicates_stackv2
bool 1
class | exact_duplicates_stackv1
bool 2
classes | near_duplicates_githubcode
bool 2
classes | near_duplicates_stackv1
bool 2
classes | near_duplicates_stackv2
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
6,220
|
NullPadHandler.h
|
RPCS3_rpcs3/rpcs3/Emu/Io/Null/NullPadHandler.h
|
#pragma once
#include "Emu/Io/PadHandler.h"
class NullPadHandler final : public PadHandlerBase
{
public:
NullPadHandler() : PadHandlerBase(pad_handler::null)
{
b_has_pressure_intensity_button = false;
}
bool Init() override
{
return true;
}
void init_config(cfg_pad* cfg) override
{
if (!cfg) return;
// Reset default button mapping
cfg->ls_left.def = "";
cfg->ls_down.def = "";
cfg->ls_right.def = "";
cfg->ls_up.def = "";
cfg->rs_left.def = "";
cfg->rs_down.def = "";
cfg->rs_right.def = "";
cfg->rs_up.def = "";
cfg->start.def = "";
cfg->select.def = "";
cfg->ps.def = "";
cfg->square.def = "";
cfg->cross.def = "";
cfg->circle.def = "";
cfg->triangle.def = "";
cfg->left.def = "";
cfg->down.def = "";
cfg->right.def = "";
cfg->up.def = "";
cfg->r1.def = "";
cfg->r2.def = "";
cfg->r3.def = "";
cfg->l1.def = "";
cfg->l2.def = "";
cfg->l3.def = "";
cfg->pressure_intensity_button.def = "";
cfg->analog_limiter_button.def = "";
// Apply defaults
cfg->from_default();
}
std::vector<pad_list_entry> list_devices() override
{
std::vector<pad_list_entry> nulllist;
nulllist.emplace_back("Default Null Device", false);
return nulllist;
}
bool bindPadToDevice(std::shared_ptr<Pad> /*pad*/) override
{
return true;
}
void process() override
{
}
};
| 1,426
|
C++
|
.h
| 61
| 20.704918
| 60
| 0.583026
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,221
|
NullKeyboardHandler.h
|
RPCS3_rpcs3/rpcs3/Emu/Io/Null/NullKeyboardHandler.h
|
#pragma once
#include "Emu/Io/KeyboardHandler.h"
class NullKeyboardHandler final : public KeyboardHandlerBase
{
using KeyboardHandlerBase::KeyboardHandlerBase;
public:
void Init(keyboard_consumer& consumer, const u32 max_connect) override
{
KbInfo& info = consumer.GetInfo();
std::vector<Keyboard>& keyboards = consumer.GetKeyboards();
info = {};
info.max_connect = max_connect;
info.is_null_handler = true;
keyboards.clear();
for (u32 i = 0; i < max_connect; i++)
{
keyboards.emplace_back(Keyboard());
}
}
};
| 539
|
C++
|
.h
| 20
| 24.5
| 71
| 0.739806
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,222
|
NullMouseHandler.h
|
RPCS3_rpcs3/rpcs3/Emu/Io/Null/NullMouseHandler.h
|
#pragma once
#include "Emu/Io/MouseHandler.h"
class NullMouseHandler final : public MouseHandlerBase
{
using MouseHandlerBase::MouseHandlerBase;
public:
void Init(const u32 max_connect) override
{
m_info = {};
m_info.max_connect = max_connect;
m_info.is_null_handler = true;
m_mice.clear();
}
};
| 311
|
C++
|
.h
| 14
| 20.142857
| 54
| 0.755102
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,223
|
null_camera_handler.h
|
RPCS3_rpcs3/rpcs3/Emu/Io/Null/null_camera_handler.h
|
#pragma once
#include "Emu/Io/camera_handler_base.h"
class null_camera_handler final : public camera_handler_base
{
public:
null_camera_handler() : camera_handler_base() {}
void open_camera() override { m_state = camera_handler_state::open; }
void close_camera() override { m_state = camera_handler_state::closed; }
void start_camera() override { m_state = camera_handler_state::running; }
void stop_camera() override { m_state = camera_handler_state::open; }
void set_format(s32 format, u32 bytesize) override
{
m_format = format;
m_bytesize = bytesize;
}
void set_frame_rate(u32 frame_rate) override
{
m_frame_rate = frame_rate;
}
void set_resolution(u32 width, u32 height) override
{
m_width = width;
m_height = height;
};
void set_mirrored(bool mirrored) override
{
m_mirrored = mirrored;
}
u64 frame_number() const override
{
return 0;
}
camera_handler_state get_image(u8* /*buf*/, u64 /*size*/, u32& width, u32& height, u64& frame_number, u64& bytes_read) override
{
width = 0;
height = 0;
frame_number = 0;
bytes_read = 0;
return m_state;
}
};
| 1,107
|
C++
|
.h
| 41
| 24.634146
| 128
| 0.710501
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,224
|
audio_device_enumerator.h
|
RPCS3_rpcs3/rpcs3/Emu/Audio/audio_device_enumerator.h
|
#pragma once
#include "util/types.hpp"
#include <vector>
#include <string>
class audio_device_enumerator
{
public:
static constexpr std::string_view DEFAULT_DEV_ID = "@@@default@@@";
struct audio_device
{
std::string id{};
std::string name{};
usz max_ch{};
};
audio_device_enumerator() {};
virtual ~audio_device_enumerator() = default;
// Enumerate available output devices.
virtual std::vector<audio_device> get_output_devices() = 0;
};
| 459
|
C++
|
.h
| 19
| 22.052632
| 68
| 0.725173
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,225
|
AudioBackend.h
|
RPCS3_rpcs3/rpcs3/Emu/Audio/AudioBackend.h
|
#pragma once
#include "util/types.hpp"
#include "util/logs.hpp"
#include "Utilities/mutex.h"
#include "Utilities/StrFmt.h"
#include "Emu/system_config_types.h"
#include <numbers>
enum : u32
{
DEFAULT_AUDIO_SAMPLING_RATE = 48000,
MAX_AUDIO_BUFFERS = 64,
AUDIO_BUFFER_SAMPLES = 256,
AUDIO_MAX_CHANNELS = 8,
};
enum class AudioFreq : u32
{
FREQ_32K = 32000,
FREQ_44K = 44100,
FREQ_48K = 48000,
FREQ_88K = 88200,
FREQ_96K = 96000,
FREQ_176K = 176400,
FREQ_192K = 192000,
};
enum class AudioSampleSize : u32
{
FLOAT = sizeof(float),
S16 = sizeof(s16),
};
// This enum is only used for emulation
enum class AudioChannelCnt : u32
{
STEREO = 2,
SURROUND_5_1 = 6,
SURROUND_7_1 = 8,
};
enum class AudioStateEvent : u32
{
UNSPECIFIED_ERROR,
DEFAULT_DEVICE_MAYBE_CHANGED,
};
class AudioBackend
{
public:
struct VolumeParam
{
f32 initial_volume = 1.0f;
f32 current_volume = 1.0f;
f32 target_volume = 1.0f;
u32 freq = 48000;
u32 ch_cnt = 2;
};
AudioBackend();
virtual ~AudioBackend() = default;
/*
* Virtual methods
*/
virtual std::string_view GetName() const = 0;
// (Re)create output stream with new parameters. Blocks until data callback returns.
// If dev_id is empty, then default device will be selected.
// May override channel count if device has smaller number of channels.
// Should return 'true' on success.
virtual bool Open(std::string_view dev_id, AudioFreq freq, AudioSampleSize sample_size, AudioChannelCnt ch_cnt, audio_channel_layout layout) = 0;
// Reset backend state. Blocks until data callback returns.
virtual void Close() = 0;
// Sets write callback. It's called when backend requests new data to be sent.
// Callback should return number of submitted bytes. Calling other backend functions from callback is unsafe.
virtual void SetWriteCallback(std::function<u32(u32 /* byte_cnt */, void* /* buffer */)> cb);
// Sets error callback. It's called when backend detects event in audio chain that needs immediate attention.
// Calling other backend functions from callback is unsafe.
virtual void SetStateCallback(std::function<void(AudioStateEvent)> cb);
/*
* All functions below require that Open() was called prior.
*/
// Returns length of one write callback frame in seconds. Open() must be called prior.
virtual f64 GetCallbackFrameLen() = 0;
// Returns true if audio is currently being played, false otherwise. Reflects end result of Play() and Pause() calls.
virtual bool IsPlaying() { return m_playing; }
// Start playing enqueued data.
virtual void Play() = 0;
// Pause playing enqueued data. No additional callbacks will be issued. Blocks until data callback returns.
virtual void Pause() = 0;
/*
* This virtual method should be reimplemented if backend can fail to be initialized under non-error conditions
* eg. when there is no audio devices attached
*/
virtual bool Initialized() { return true; }
/*
* This virtual method should be reimplemented if backend can fail during normal operation
*/
virtual bool Operational() { return true; }
/*
* This virtual method should be reimplemented if backend can report device changes
*/
virtual bool DefaultDeviceChanged() { return false; }
/*
* Helper methods
*/
u32 get_sampling_rate() const;
u32 get_sample_size() const;
u32 get_channels() const;
audio_channel_layout get_channel_layout() const;
bool get_convert_to_s16() const;
/*
* Convert float buffer to s16 one. src and dst could be the same. cnt is number of buffer elements.
*/
static void convert_to_s16(u32 cnt, const f32* src, void* dst);
/*
* Apply volume parameters to the buffer. Gradually changes volume. src and dst could be the same.
* Number of channels must be >1 and multiple of 2.
* sample_cnt is number of buffer elements. Returns current volume.
*/
static f32 apply_volume(const VolumeParam& param, u32 sample_cnt, const f32* src, f32* dst);
/*
* Apply volume value to the buffer. src and dst could be the same. sample_cnt is number of buffer elements.
* Returns current volume.
*/
static void apply_volume_static(f32 vol, u32 sample_cnt, const f32* src, f32* dst);
/*
* Normalize float samples in range from -1.0 to 1.0.
*/
static void normalize(u32 sample_cnt, const f32* src, f32* dst);
/*
* Returns the output channel count and downmix mode.
*/
static std::pair<AudioChannelCnt, AudioChannelCnt> get_channel_count_and_downmixer(u32 device_index);
/*
* Returns the max supported channel count.
*/
static AudioChannelCnt get_max_channel_count(u32 device_index);
/*
* Get default channel count for a layout
*/
static u32 default_layout_channel_count(audio_channel_layout layout);
/*
* Converts raw channel count to value usable by backends
*/
static u32 layout_channel_count(u32 channels, audio_channel_layout layout);
/*
* Get the default layout for raw channel count
*/
static audio_channel_layout default_layout(u32 channels);
/*
* Downmix audio stream.
*/
template<AudioChannelCnt src_ch_cnt, audio_channel_layout dst_layout>
static void downmix(u32 sample_cnt, const f32* src, f32* dst)
{
const u32 dst_ch_cnt = default_layout_channel_count(dst_layout);
if (static_cast<u32>(src_ch_cnt) <= dst_ch_cnt) fmt::throw_exception("src channel count must be bigger than dst channel count");
static constexpr f32 center_coef = std::numbers::sqrt2_v<f32> / 2;
static constexpr f32 surround_coef = std::numbers::sqrt2_v<f32> / 2;
for (u32 src_sample = 0, dst_sample = 0; src_sample < sample_cnt; src_sample += static_cast<u32>(src_ch_cnt), dst_sample += dst_ch_cnt)
{
const f32 left = src[src_sample + 0];
const f32 right = src[src_sample + 1];
if constexpr (src_ch_cnt == AudioChannelCnt::STEREO)
{
if constexpr (dst_layout == audio_channel_layout::mono)
{
dst[dst_sample + 0] = left + right;
}
}
else if constexpr (src_ch_cnt == AudioChannelCnt::SURROUND_5_1)
{
const f32 center = src[src_sample + 2];
const f32 low_freq = src[src_sample + 3];
const f32 side_left = src[src_sample + 4];
const f32 side_right = src[src_sample + 5];
if constexpr (dst_layout == audio_channel_layout::quadraphonic || dst_layout == audio_channel_layout::quadraphonic_lfe)
{
const f32 mid = center * center_coef;
dst[dst_sample + 0] = left + mid;
dst[dst_sample + 1] = right + mid;
dst[dst_sample + 2] = side_left;
dst[dst_sample + 3] = side_right;
if constexpr (dst_layout == audio_channel_layout::quadraphonic_lfe)
{
dst[dst_sample + 4] = low_freq;
}
}
else if constexpr (dst_layout == audio_channel_layout::stereo || dst_layout == audio_channel_layout::stereo_lfe)
{
const f32 mid = center * center_coef;
dst[dst_sample + 0] = left + mid + side_left * surround_coef;
dst[dst_sample + 1] = right + mid + side_right * surround_coef;
if constexpr (dst_layout == audio_channel_layout::stereo_lfe)
{
dst[dst_sample + 2] = low_freq;
}
}
else if constexpr (dst_layout == audio_channel_layout::mono)
{
dst[dst_sample + 0] = left + right + center + side_left + side_right;
}
}
else if constexpr (src_ch_cnt == AudioChannelCnt::SURROUND_7_1)
{
const f32 center = src[src_sample + 2];
const f32 low_freq = src[src_sample + 3];
const f32 rear_left = src[src_sample + 4];
const f32 rear_right = src[src_sample + 5];
const f32 side_left = src[src_sample + 6];
const f32 side_right = src[src_sample + 7];
if constexpr (dst_layout == audio_channel_layout::surround_5_1)
{
dst[dst_sample + 0] = left;
dst[dst_sample + 1] = right;
dst[dst_sample + 2] = center;
dst[dst_sample + 3] = low_freq;
dst[dst_sample + 4] = side_left + rear_left;
dst[dst_sample + 5] = side_right + rear_right;
}
else if constexpr (dst_layout == audio_channel_layout::quadraphonic || dst_layout == audio_channel_layout::quadraphonic_lfe)
{
const f32 mid = center * center_coef;
dst[dst_sample + 0] = left + mid;
dst[dst_sample + 1] = right + mid;
dst[dst_sample + 2] = side_left + rear_left;
dst[dst_sample + 3] = side_right + rear_right;
if constexpr (dst_layout == audio_channel_layout::quadraphonic_lfe)
{
dst[dst_sample + 4] = low_freq;
}
}
else if constexpr (dst_layout == audio_channel_layout::stereo || dst_layout == audio_channel_layout::stereo_lfe)
{
const f32 mid = center * center_coef;
dst[dst_sample + 0] = left + mid + (side_left + rear_left) * surround_coef;
dst[dst_sample + 1] = right + mid + (side_right + rear_right) * surround_coef;
if constexpr (dst_layout == audio_channel_layout::stereo_lfe)
{
dst[dst_sample + 2] = low_freq;
}
}
else if constexpr (dst_layout == audio_channel_layout::mono)
{
dst[dst_sample + 0] = left + right + center + side_left + rear_left + side_right + rear_right;
}
}
}
}
static void downmix(u32 sample_cnt, u32 src_ch_cnt, audio_channel_layout dst_layout, const f32* src, f32* dst)
{
const u32 dst_ch_cnt = default_layout_channel_count(dst_layout);
if (src_ch_cnt <= dst_ch_cnt)
{
return;
}
switch (src_ch_cnt)
{
case static_cast<u32>(AudioChannelCnt::SURROUND_7_1):
{
switch (dst_layout)
{
case audio_channel_layout::mono:
AudioBackend::downmix<AudioChannelCnt::SURROUND_7_1, audio_channel_layout::mono>(sample_cnt, src, dst);
break;
case audio_channel_layout::stereo:
AudioBackend::downmix<AudioChannelCnt::SURROUND_7_1, audio_channel_layout::stereo>(sample_cnt, src, dst);
break;
case audio_channel_layout::stereo_lfe:
AudioBackend::downmix<AudioChannelCnt::SURROUND_7_1, audio_channel_layout::stereo_lfe>(sample_cnt, src, dst);
break;
case audio_channel_layout::quadraphonic:
AudioBackend::downmix<AudioChannelCnt::SURROUND_7_1, audio_channel_layout::quadraphonic>(sample_cnt, src, dst);
break;
case audio_channel_layout::quadraphonic_lfe:
AudioBackend::downmix<AudioChannelCnt::SURROUND_7_1, audio_channel_layout::quadraphonic_lfe>(sample_cnt, src, dst);
break;
case audio_channel_layout::surround_5_1:
AudioBackend::downmix<AudioChannelCnt::SURROUND_7_1, audio_channel_layout::surround_5_1>(sample_cnt, src, dst);
break;
default:
fmt::throw_exception("Invalid downmix combination: %u -> %s", src_ch_cnt, dst_layout);
}
break;
}
case static_cast<u32>(AudioChannelCnt::SURROUND_5_1):
{
switch (dst_layout)
{
case audio_channel_layout::mono:
AudioBackend::downmix<AudioChannelCnt::SURROUND_5_1, audio_channel_layout::mono>(sample_cnt, src, dst);
break;
case audio_channel_layout::stereo:
AudioBackend::downmix<AudioChannelCnt::SURROUND_5_1, audio_channel_layout::stereo>(sample_cnt, src, dst);
break;
case audio_channel_layout::stereo_lfe:
AudioBackend::downmix<AudioChannelCnt::SURROUND_5_1, audio_channel_layout::stereo_lfe>(sample_cnt, src, dst);
break;
case audio_channel_layout::quadraphonic:
AudioBackend::downmix<AudioChannelCnt::SURROUND_5_1, audio_channel_layout::quadraphonic>(sample_cnt, src, dst);
break;
case audio_channel_layout::quadraphonic_lfe:
AudioBackend::downmix<AudioChannelCnt::SURROUND_5_1, audio_channel_layout::quadraphonic_lfe>(sample_cnt, src, dst);
break;
default:
fmt::throw_exception("Invalid downmix combination: %u -> %s", src_ch_cnt, dst_layout);
}
break;
}
case static_cast<u32>(AudioChannelCnt::STEREO):
{
switch (dst_layout)
{
case audio_channel_layout::mono:
AudioBackend::downmix<AudioChannelCnt::STEREO, audio_channel_layout::mono>(sample_cnt, src, dst);
break;
default:
fmt::throw_exception("Invalid downmix combination: %u -> %s", src_ch_cnt, dst_layout);
}
break;
}
default:
{
fmt::throw_exception("Invalid downmix combination: %u -> %s", src_ch_cnt, dst_layout);
}
}
}
protected:
void setup_channel_layout(u32 input_channel_count, u32 output_channel_count, audio_channel_layout layout, logs::channel& log);
AudioSampleSize m_sample_size = AudioSampleSize::FLOAT;
AudioFreq m_sampling_rate = AudioFreq::FREQ_48K;
u32 m_channels = 2;
audio_channel_layout m_layout = audio_channel_layout::automatic;
std::timed_mutex m_cb_mutex{};
std::function<u32(u32, void *)> m_write_callback{};
shared_mutex m_state_cb_mutex{};
std::function<void(AudioStateEvent)> m_state_callback{};
bool m_playing = false;
private:
static constexpr f32 VOLUME_CHANGE_DURATION = 0.016f; // sec
};
| 12,637
|
C++
|
.h
| 334
| 34.254491
| 146
| 0.700588
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,226
|
AudioDumper.h
|
RPCS3_rpcs3/rpcs3/Emu/Audio/AudioDumper.h
|
#pragma once
#include "util/types.hpp"
#include "Utilities/File.h"
#include "Emu/Audio/AudioBackend.h"
struct WAVHeader
{
struct RIFFHeader
{
u8 ID[4] = { 'R', 'I', 'F', 'F' };
le_t<u32> Size{}; // FileSize - 8
u8 WAVE[4] = { 'W', 'A', 'V', 'E' };
RIFFHeader() = default;
RIFFHeader(u32 size)
: Size(size)
{
}
} RIFF;
struct FMTHeader
{
u8 ID[4] = { 'f', 'm', 't', ' ' };
le_t<u32> Size = 16;
le_t<u16> AudioFormat{}; // 1 for PCM, 3 for IEEE Floating Point
le_t<u16> NumChannels{}; // 1, 2, 6, 8
le_t<u32> SampleRate{}; // 44100-192000
le_t<u32> ByteRate{}; // SampleRate * NumChannels * BitsPerSample/8
le_t<u16> BlockAlign{}; // NumChannels * BitsPerSample/8
le_t<u16> BitsPerSample{}; // SampleSize * 8
FMTHeader() = default;
FMTHeader(AudioChannelCnt ch, AudioFreq sample_rate, AudioSampleSize sample_size)
: AudioFormat(sample_size == AudioSampleSize::FLOAT ? 3 : 1)
, NumChannels(static_cast<u16>(ch))
, SampleRate(static_cast<u32>(sample_rate))
, ByteRate(SampleRate * NumChannels * static_cast<u32>(sample_size))
, BlockAlign(NumChannels * static_cast<u32>(sample_size))
, BitsPerSample(static_cast<u32>(sample_size) * 8)
{
}
} FMT;
struct FACTChunk
{
u8 ID[4] = { 'f', 'a', 'c', 't' };
le_t<u32> ChunkLength = 4;
le_t<u32> SampleLength = 0; // total samples per channel
FACTChunk() = default;
FACTChunk(u32 sample_len)
: SampleLength(sample_len)
{
}
} FACT;
u8 ID[4] = { 'd', 'a', 't', 'a' };
le_t<u32> Size{}; // size of data (256 * NumChannels * sizeof(f32))
WAVHeader() = default;
WAVHeader(AudioChannelCnt ch, AudioFreq sample_rate, AudioSampleSize sample_size)
: RIFF(sizeof(RIFFHeader) + sizeof(FMTHeader))
, FMT(ch, sample_rate, sample_size)
, FACT(0)
, Size(0)
{
}
};
class AudioDumper
{
WAVHeader m_header{};
fs::file m_output{};
public:
AudioDumper();
~AudioDumper();
void Open(AudioChannelCnt ch, AudioFreq sample_rate, AudioSampleSize sample_size);
void Close();
void WriteData(const void* buffer, u32 size);
u16 GetCh() const { return m_header.FMT.NumChannels; }
u16 GetSampleSize() const { return m_header.FMT.BitsPerSample / 8; }
};
| 2,183
|
C++
|
.h
| 73
| 27.191781
| 83
| 0.666985
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,227
|
audio_resampler.h
|
RPCS3_rpcs3/rpcs3/Emu/Audio/audio_resampler.h
|
#pragma once
#include "util/types.hpp"
#include "Emu/Audio/AudioBackend.h"
#ifndef _MSC_VER
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsuggest-override"
#pragma GCC diagnostic ignored "-Wold-style-cast"
#endif
#include "SoundTouch.h"
#ifndef _MSC_VER
#pragma GCC diagnostic pop
#endif
constexpr f64 RESAMPLER_MAX_FREQ_VAL = 1.0;
constexpr f64 RESAMPLER_MIN_FREQ_VAL = 0.1;
class audio_resampler
{
public:
audio_resampler();
~audio_resampler();
void set_params(AudioChannelCnt ch_cnt, AudioFreq freq);
f64 set_tempo(f64 new_tempo);
void put_samples(const f32* buf, u32 sample_cnt);
std::pair<f32* /* buffer */, u32 /* samples */> get_samples(u32 sample_cnt);
u32 samples_available() const;
f64 get_resample_ratio();
void flush();
private:
soundtouch::SoundTouch resampler{};
};
| 815
|
C++
|
.h
| 29
| 26.448276
| 77
| 0.765766
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,228
|
NullAudioBackend.h
|
RPCS3_rpcs3/rpcs3/Emu/Audio/Null/NullAudioBackend.h
|
#pragma once
#include "Emu/Audio/AudioBackend.h"
class NullAudioBackend final : public AudioBackend
{
public:
NullAudioBackend() {}
~NullAudioBackend() {}
std::string_view GetName() const override { return "Null"sv; }
bool Open(std::string_view /* dev_id */, AudioFreq /* freq */, AudioSampleSize /* sample_size */, AudioChannelCnt /* ch_cnt */, audio_channel_layout /*layout*/) override
{
Close();
return true;
}
void Close() override { m_playing = false; }
f64 GetCallbackFrameLen() override { return 0.01; };
void Play() override { m_playing = true; }
void Pause() override { m_playing = false; }
bool IsPlaying() override { return m_playing; }
private:
bool m_playing = false;
};
| 707
|
C++
|
.h
| 21
| 31.571429
| 170
| 0.709867
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,229
|
null_enumerator.h
|
RPCS3_rpcs3/rpcs3/Emu/Audio/Null/null_enumerator.h
|
#pragma once
#include "Emu/Audio/audio_device_enumerator.h"
class null_enumerator final : public audio_device_enumerator
{
public:
null_enumerator() {};
~null_enumerator() override {};
std::vector<audio_device> get_output_devices() override { return {}; }
};
| 266
|
C++
|
.h
| 9
| 27.777778
| 71
| 0.750988
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,230
|
CubebBackend.h
|
RPCS3_rpcs3/rpcs3/Emu/Audio/Cubeb/CubebBackend.h
|
#pragma once
#include <memory>
#include "Utilities/mutex.h"
#include "util/atomic.hpp"
#include "Emu/Audio/AudioBackend.h"
#include "cubeb/cubeb.h"
class CubebBackend final : public AudioBackend
{
public:
CubebBackend();
~CubebBackend() override;
CubebBackend(const CubebBackend&) = delete;
CubebBackend& operator=(const CubebBackend&) = delete;
std::string_view GetName() const override { return "Cubeb"sv; }
bool Initialized() override;
bool Operational() override;
bool DefaultDeviceChanged() override;
bool Open(std::string_view dev_id, AudioFreq freq, AudioSampleSize sample_size, AudioChannelCnt ch_cnt, audio_channel_layout layout) override;
void Close() override;
f64 GetCallbackFrameLen() override;
void Play() override;
void Pause() override;
private:
static constexpr f64 AUDIO_MIN_LATENCY = 512.0 / 48000; // 10ms
cubeb* m_ctx = nullptr;
cubeb_stream* m_stream = nullptr;
#ifdef _WIN32
bool m_com_init_success = false;
#endif
std::array<u8, sizeof(float) * static_cast<u32>(AudioChannelCnt::SURROUND_7_1)> m_last_sample{};
atomic_t<u8> full_sample_size = 0;
atomic_t<bool> m_reset_req = false;
// Protected by callback mutex
std::string m_default_device{};
bool m_dev_collection_cb_enabled = false;
// Cubeb callbacks
static long data_cb(cubeb_stream* stream, void* user_ptr, void const* input_buffer, void* output_buffer, long nframes);
static void state_cb(cubeb_stream* stream, void* user_ptr, cubeb_state state);
static void device_collection_changed_cb(cubeb* context, void* user_ptr);
struct device_handle
{
cubeb_devid handle{};
std::string id;
u32 ch_cnt{};
};
device_handle GetDevice(std::string_view dev_id = "");
device_handle GetDefaultDeviceAlt(AudioFreq freq, AudioSampleSize sample_size, u32 ch_cnt);
};
| 1,787
|
C++
|
.h
| 48
| 35.0625
| 143
| 0.761185
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,231
|
cubeb_enumerator.h
|
RPCS3_rpcs3/rpcs3/Emu/Audio/Cubeb/cubeb_enumerator.h
|
#pragma once
#include "Emu/Audio/audio_device_enumerator.h"
#include "cubeb/cubeb.h"
class cubeb_enumerator final : public audio_device_enumerator
{
public:
cubeb_enumerator();
~cubeb_enumerator() override;
std::vector<audio_device> get_output_devices() override;
private:
cubeb* ctx{};
#ifdef _WIN32
bool com_init_success = false;
#endif
};
| 354
|
C++
|
.h
| 15
| 21.8
| 61
| 0.777108
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,232
|
XAudio2Backend.h
|
RPCS3_rpcs3/rpcs3/Emu/Audio/XAudio2/XAudio2Backend.h
|
#pragma once
#ifndef _WIN32
#error "XAudio2 can only be built on Windows."
#endif
#include <memory>
#include "Utilities/mutex.h"
#include "Emu/Audio/AudioBackend.h"
#include <initguid.h>
#include <xaudio2.h>
#include <wrl/client.h>
#include <MMDeviceAPI.h>
class XAudio2Backend final : public AudioBackend, public IXAudio2VoiceCallback, public IXAudio2EngineCallback, public IMMNotificationClient
{
public:
XAudio2Backend();
~XAudio2Backend() override;
XAudio2Backend(const XAudio2Backend&) = delete;
XAudio2Backend& operator=(const XAudio2Backend&) = delete;
std::string_view GetName() const override { return "XAudio2"sv; }
bool Initialized() override;
bool Operational() override;
bool DefaultDeviceChanged() override;
bool Open(std::string_view dev_id, AudioFreq freq, AudioSampleSize sample_size, AudioChannelCnt ch_cnt, audio_channel_layout layout) override;
void Close() override;
f64 GetCallbackFrameLen() override;
void Play() override;
void Pause() override;
private:
static constexpr u32 INTERNAL_BUF_SIZE_MS = 25;
Microsoft::WRL::ComPtr<IXAudio2> m_xaudio2_instance{};
IXAudio2MasteringVoice* m_master_voice{};
IXAudio2SourceVoice* m_source_voice{};
bool m_com_init_success = false;
Microsoft::WRL::ComPtr<IMMDeviceEnumerator> m_device_enumerator{};
// Protected by state callback mutex
std::string m_current_device{};
bool m_default_dev_changed = false;
std::vector<u8> m_data_buf{};
std::array<u8, sizeof(float) * static_cast<u32>(AudioChannelCnt::SURROUND_7_1)> m_last_sample{};
atomic_t<bool> m_reset_req = false;
// XAudio voice callbacks
void OnVoiceProcessingPassStart(UINT32 BytesRequired) override;
void OnVoiceProcessingPassEnd() override {}
void OnStreamEnd() override {}
void OnBufferStart(void* /* pBufferContext */) override {}
void OnBufferEnd(void* /* pBufferContext*/) override {}
void OnLoopEnd(void* /* pBufferContext */) override {}
void OnVoiceError(void* /* pBufferContext */, HRESULT /* Error */) override {}
// XAudio engine callbacks
void OnProcessingPassStart() override {};
void OnProcessingPassEnd() override {};
void OnCriticalError(HRESULT Error) override;
// IMMNotificationClient callbacks
IFACEMETHODIMP_(ULONG) AddRef() override { return 1; };
IFACEMETHODIMP_(ULONG) Release() override { return 1; };
IFACEMETHODIMP QueryInterface(REFIID /*iid*/, void** /*object*/) override { return E_NOINTERFACE; };
IFACEMETHODIMP OnPropertyValueChanged(LPCWSTR /*device_id*/, const PROPERTYKEY /*key*/) override { return S_OK; };
IFACEMETHODIMP OnDeviceAdded(LPCWSTR /*device_id*/) override { return S_OK; };
IFACEMETHODIMP OnDeviceRemoved(LPCWSTR /*device_id*/) override { return S_OK; };
IFACEMETHODIMP OnDeviceStateChanged(LPCWSTR /*device_id*/, DWORD /*new_state*/) override { return S_OK; };
IFACEMETHODIMP OnDefaultDeviceChanged(EDataFlow flow, ERole role, LPCWSTR new_default_device_id) override;
void CloseUnlocked();
};
| 2,929
|
C++
|
.h
| 63
| 44.428571
| 143
| 0.773717
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,233
|
xaudio2_enumerator.h
|
RPCS3_rpcs3/rpcs3/Emu/Audio/XAudio2/xaudio2_enumerator.h
|
#pragma once
#ifndef _WIN32
#error "XAudio2 can only be built on Windows."
#endif
#include "Emu/Audio/audio_device_enumerator.h"
class xaudio2_enumerator final : public audio_device_enumerator
{
public:
xaudio2_enumerator();
~xaudio2_enumerator() override;
std::vector<audio_device> get_output_devices() override;
};
| 325
|
C++
|
.h
| 12
| 25.416667
| 63
| 0.792208
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,234
|
faudio_enumerator.h
|
RPCS3_rpcs3/rpcs3/Emu/Audio/FAudio/faudio_enumerator.h
|
#pragma once
#ifndef HAVE_FAUDIO
#error "FAudio support disabled but still being built."
#endif
#include "Emu/Audio/audio_device_enumerator.h"
#include "FAudio.h"
class faudio_enumerator final : public audio_device_enumerator
{
public:
faudio_enumerator();
~faudio_enumerator() override;
std::vector<audio_device> get_output_devices() override;
private:
FAudio* instance{};
};
| 388
|
C++
|
.h
| 15
| 24.133333
| 62
| 0.79235
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,235
|
FAudioBackend.h
|
RPCS3_rpcs3/rpcs3/Emu/Audio/FAudio/FAudioBackend.h
|
#pragma once
#ifndef HAVE_FAUDIO
#error "FAudio support disabled but still being built."
#endif
#include <memory>
#include "Utilities/mutex.h"
#include "Emu/Audio/AudioBackend.h"
#include "FAudio.h"
class FAudioBackend final : public AudioBackend, public FAudioVoiceCallback, public FAudioEngineCallback
{
public:
FAudioBackend();
~FAudioBackend() override;
FAudioBackend(const FAudioBackend&) = delete;
FAudioBackend& operator=(const FAudioBackend&) = delete;
std::string_view GetName() const override { return "FAudio"sv; }
bool Initialized() override;
bool Operational() override;
bool Open(std::string_view dev_id, AudioFreq freq, AudioSampleSize sample_size, AudioChannelCnt ch_cnt, audio_channel_layout layout) override;
void Close() override;
f64 GetCallbackFrameLen() override;
void Play() override;
void Pause() override;
private:
static constexpr u32 INTERNAL_BUF_SIZE_MS = 25;
FAudio* m_instance{};
FAudioMasteringVoice* m_master_voice{};
FAudioSourceVoice* m_source_voice{};
std::vector<u8> m_data_buf{};
std::array<u8, sizeof(float) * static_cast<u32>(AudioChannelCnt::SURROUND_7_1)> m_last_sample{};
atomic_t<bool> m_reset_req = false;
// FAudio voice callbacks
static void OnVoiceProcessingPassStart_func(FAudioVoiceCallback *cb_obj, u32 BytesRequired);
// FAudio engine callbacks
static void OnCriticalError_func(FAudioEngineCallback *cb_obj, u32 Error);
void CloseUnlocked();
};
| 1,437
|
C++
|
.h
| 37
| 36.72973
| 143
| 0.787419
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,236
|
upnp_config.h
|
RPCS3_rpcs3/rpcs3/Emu/NP/upnp_config.h
|
#pragma once
#include "Utilities/Config.h"
struct cfg_upnp : cfg::node
{
cfg::string device_url{this, "DeviceUrl", ""};
void load();
void save() const;
std::string get_device_url() const;
void set_device_url(std::string_view url);
private:
static std::string get_path();
};
| 286
|
C++
|
.h
| 12
| 21.833333
| 47
| 0.716418
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,237
|
fb_helpers.h
|
RPCS3_rpcs3/rpcs3/Emu/NP/fb_helpers.h
|
#pragma once
namespace np
{
void BinAttr_to_SceNpMatching2BinAttr(event_data& edata, const BinAttr* bin_attr, SceNpMatching2BinAttr* binattr_info);
void BinAttrs_to_SceNpMatching2BinAttrs(event_data& edata, const flatbuffers::Vector<flatbuffers::Offset<BinAttr>>* fb_attr, SceNpMatching2BinAttr* binattr_info);
void RoomMemberBinAttrInternal_to_SceNpMatching2RoomMemberBinAttrInternal(event_data& edata, const RoomMemberBinAttrInternal* fb_attr, SceNpMatching2RoomMemberBinAttrInternal* binattr_info);
void RoomBinAttrInternal_to_SceNpMatching2RoomBinAttrInternal(event_data& edata, const BinAttrInternal* fb_attr, SceNpMatching2RoomBinAttrInternal* binattr_info);
void RoomGroup_to_SceNpMatching2RoomGroup(const RoomGroup* fb_group, SceNpMatching2RoomGroup* sce_group);
void RoomGroups_to_SceNpMatching2RoomGroups(const flatbuffers::Vector<flatbuffers::Offset<RoomGroup>>* fb_groups, SceNpMatching2RoomGroup* sce_groups);
void UserInfo_to_SceNpUserInfo(const UserInfo* user, SceNpUserInfo* user_info);
void UserInfo_to_SceNpUserInfo2(event_data& edata, const UserInfo* user, SceNpUserInfo2* user_info, bool include_onlinename, bool include_avatarurl);
void RoomDataExternal_to_SceNpMatching2RoomDataExternal(event_data& edata, const RoomDataExternal* room, SceNpMatching2RoomDataExternal* room_info, bool include_onlinename, bool include_avatarurl);
void SearchRoomResponse_to_SceNpMatching2SearchRoomResponse(event_data& edata, const SearchRoomResponse* resp, SceNpMatching2SearchRoomResponse* search_resp);
void GetRoomDataExternalListResponse_to_SceNpMatching2GetRoomDataExternalListResponse(event_data& edata, const GetRoomDataExternalListResponse* resp, SceNpMatching2GetRoomDataExternalListResponse* get_resp, bool include_onlinename, bool include_avatarurl);
u16 RoomDataInternal_to_SceNpMatching2RoomDataInternal(event_data& edata, const RoomDataInternal* resp, SceNpMatching2RoomDataInternal* room_resp, const SceNpId& npid, bool include_onlinename, bool include_avatarurl);
void RoomMemberDataInternal_to_SceNpMatching2RoomMemberDataInternal(event_data& edata, const RoomMemberDataInternal* member_data, const SceNpMatching2RoomDataInternal* room_info, SceNpMatching2RoomMemberDataInternal* sce_member_data, bool include_onlinename, bool include_avatarurl);
void RoomMemberUpdateInfo_to_SceNpMatching2RoomMemberUpdateInfo(event_data& edata, const RoomMemberUpdateInfo* resp, SceNpMatching2RoomMemberUpdateInfo* room_info, bool include_onlinename, bool include_avatarurl);
void RoomUpdateInfo_to_SceNpMatching2RoomUpdateInfo(const RoomUpdateInfo* update_info, SceNpMatching2RoomUpdateInfo* sce_update_info);
void GetPingInfoResponse_to_SceNpMatching2SignalingGetPingInfoResponse(const GetPingInfoResponse* resp, SceNpMatching2SignalingGetPingInfoResponse* sce_resp);
void RoomMessageInfo_to_SceNpMatching2RoomMessageInfo(event_data& edata, const RoomMessageInfo* mi, SceNpMatching2RoomMessageInfo* sce_mi, bool include_onlinename, bool include_avatarurl);
void RoomDataInternalUpdateInfo_to_SceNpMatching2RoomDataInternalUpdateInfo(event_data& edata, const RoomDataInternalUpdateInfo* update_info, SceNpMatching2RoomDataInternalUpdateInfo* sce_update_info, const SceNpId& npid, bool include_onlinename, bool include_avatarurl);
void RoomMemberDataInternalUpdateInfo_to_SceNpMatching2RoomMemberDataInternalUpdateInfo(event_data& edata, const RoomMemberDataInternalUpdateInfo* update_info, SceNpMatching2RoomMemberDataInternalUpdateInfo* sce_update_info, bool include_onlinename, bool include_avatarurl);
void MatchingRoomStatus_to_SceNpMatchingRoomStatus(event_data& edata, const MatchingRoomStatus* resp, SceNpMatchingRoomStatus* room_status);
void MatchingRoomStatus_to_SceNpMatchingJoinedRoomInfo(event_data& edata, const MatchingRoomStatus* resp, SceNpMatchingJoinedRoomInfo* room_info);
void MatchingRoom_to_SceNpMatchingRoom(event_data& edata, const MatchingRoom* resp, SceNpMatchingRoom* room);
void MatchingRoomList_to_SceNpMatchingRoomList(event_data& edata, const MatchingRoomList* resp, SceNpMatchingRoomList* room_list);
void MatchingSearchJoinRoomInfo_to_SceNpMatchingSearchJoinRoomInfo(event_data& edata, const MatchingSearchJoinRoomInfo* resp, SceNpMatchingSearchJoinRoomInfo* room_info);
} // namespace np
| 4,256
|
C++
|
.h
| 28
| 150.107143
| 284
| 0.862314
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,238
|
np_cache.h
|
RPCS3_rpcs3/rpcs3/Emu/NP/np_cache.h
|
#pragma once
#include <map>
#include <optional>
#include "Utilities/mutex.h"
#include "Emu/Cell/Modules/sceNp.h"
#include "Emu/Cell/Modules/sceNp2.h"
namespace np
{
struct userinfo_cache
{
SceNpId npId{};
std::optional<SceNpOnlineName> onlineName;
std::optional<SceNpAvatarUrl> avatarUrl;
};
struct memberbin_cache
{
memberbin_cache(const SceNpMatching2RoomMemberBinAttrInternal* sce_memberbin);
SceNpMatching2AttributeId id;
CellRtcTick updateDate;
std::vector<u8> data;
};
struct member_cache
{
member_cache(const SceNpMatching2RoomMemberDataInternal* sce_member);
userinfo_cache userInfo;
CellRtcTick joinDate;
SceNpMatching2RoomMemberId memberId;
SceNpMatching2TeamId teamId;
SceNpMatching2RoomGroupId group_id;
SceNpMatching2NatType natType;
SceNpMatching2FlagAttr flagAttr;
std::map<SceNpMatching2AttributeId, memberbin_cache> bins;
};
struct password_info_cache
{
bool with_password = false;
SceNpMatching2SessionPassword password{};
};
struct room_cache
{
void update(const SceNpMatching2RoomDataInternal* sce_roomdata);
u32 num_slots = 0;
SceNpMatching2RoomPasswordSlotMask mask_password = 0;
std::optional<SceNpMatching2SessionPassword> password;
std::map<SceNpMatching2RoomGroupId, SceNpMatching2RoomGroup> groups;
std::map<SceNpMatching2RoomMemberId, member_cache> members;
bool owner = false;
};
class cache_manager
{
public:
cache_manager() = default;
void insert_room(const SceNpMatching2RoomDataInternal* sce_roomdata);
bool add_member(SceNpMatching2RoomId room_id, const SceNpMatching2RoomMemberDataInternal* sce_roommemberdata);
bool del_member(SceNpMatching2RoomId room_id, SceNpMatching2RoomMemberId member_id);
void update_password(SceNpMatching2RoomId room_id, const std::optional<SceNpMatching2SessionPassword>& password);
std::pair<error_code, std::optional<SceNpMatching2RoomSlotInfo>> get_slots(SceNpMatching2RoomId room_id);
std::pair<error_code, std::vector<SceNpMatching2RoomMemberId>> get_memberids(u64 room_id, s32 sort_method);
std::pair<error_code, std::optional<SceNpMatching2SessionPassword>> get_password(SceNpMatching2RoomId room_id);
error_code get_member_and_attrs(SceNpMatching2RoomId room_id, SceNpMatching2RoomMemberId member_id, const std::vector<SceNpMatching2AttributeId>& binattrs_list, SceNpMatching2RoomMemberDataInternal* ptr_member, u32 addr_data, u32 size_data, bool include_onlinename, bool include_avatarurl);
std::pair<error_code, std::optional<SceNpId>> get_npid(u64 room_id, u16 member_id);
std::optional<u16> get_memberid(u64 room_id, const SceNpId& npid);
private:
shared_mutex mutex;
std::map<SceNpMatching2RoomId, room_cache> rooms;
};
} // namespace np
| 2,763
|
C++
|
.h
| 67
| 38.537313
| 292
| 0.799104
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,239
|
rpcn_config.h
|
RPCS3_rpcs3/rpcs3/Emu/NP/rpcn_config.h
|
#pragma once
#include "Utilities/Config.h"
struct cfg_rpcn : cfg::node
{
cfg::uint32 version{this, "Version", 1};
cfg::string host{this, "Host", "np.rpcs3.net"};
cfg::string npid{this, "NPID", ""};
cfg::string password{this, "Password", ""};
cfg::string token{this, "Token", ""};
cfg::string hosts{this, "Hosts", "Official RPCN Server|np.rpcs3.net|||RPCN Test Server|test-np.rpcs3.net"};
void load();
void save() const;
std::string get_host() const;
std::string get_npid(); // not const because it can save if npid is requested and it has never been set
std::string get_password() const;
std::string get_token() const;
std::vector<std::pair<std::string, std::string>> get_hosts(); // saves default if no valid server in the list
void set_host(std::string_view host);
void set_npid(std::string_view npid);
void set_password(std::string_view password);
void set_token(std::string_view token);
bool add_host(std::string_view description, std::string_view host);
bool del_host(std::string_view description, std::string_view host);
private:
static std::string get_path();
static std::string generate_npid();
void set_hosts(const std::vector<std::pair<std::string, std::string>>& vec_hosts);
};
extern cfg_rpcn g_cfg_rpcn;
| 1,246
|
C++
|
.h
| 29
| 40.965517
| 110
| 0.719008
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,240
|
rpcn_client.h
|
RPCS3_rpcs3/rpcs3/Emu/NP/rpcn_client.h
|
#pragma once
#include <unordered_map>
#include <chrono>
#include <thread>
#include <semaphore>
#include "Utilities/mutex.h"
#include "Emu/localized_string.h"
#include "util/asm.hpp"
#ifdef _WIN32
#include <winsock2.h>
#else
#ifdef __clang__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wold-style-cast"
#endif
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#ifdef __clang__
#pragma GCC diagnostic pop
#endif
#endif
#include "Emu/Cell/Modules/sceNp.h"
#include "Emu/Cell/Modules/sceNp2.h"
#include "Emu/Cell/Modules/sceNpTus.h"
#include "generated/np2_structs_generated.h"
#ifdef __clang__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wold-style-cast"
#endif
#include <wolfssl/ssl.h>
#ifdef __clang__
#pragma GCC diagnostic pop
#endif
// COMID is sent as 9 chars - + '_' + 2 digits
constexpr usz COMMUNICATION_ID_COMID_COMPONENT_SIZE = 9;
constexpr usz COMMUNICATION_ID_SUBID_COMPONENT_SIZE = 2;
constexpr usz COMMUNICATION_ID_SIZE = COMMUNICATION_ID_COMID_COMPONENT_SIZE + COMMUNICATION_ID_SUBID_COMPONENT_SIZE + 1;
class vec_stream
{
public:
vec_stream() = delete;
vec_stream(std::vector<u8>& _vec, usz initial_index = 0)
: vec(_vec), i(initial_index) {}
bool is_error() const
{
return error;
}
void dump() const;
// Getters
template <typename T>
T get()
{
if (sizeof(T) + i > vec.size() || error)
{
error = true;
return static_cast<T>(0);
}
T res = read_from_ptr<le_t<T>>(&vec[i]);
i += sizeof(T);
return res;
}
std::string get_string(bool empty)
{
std::string res{};
while (i < vec.size() && vec[i] != 0)
{
res.push_back(vec[i]);
i++;
}
i++;
if (!empty && res.empty())
{
error = true;
}
return res;
}
std::vector<u8> get_rawdata()
{
u32 size = get<u32>();
if (i + size > vec.size())
{
error = true;
return {};
}
std::vector<u8> ret;
std::copy(vec.begin() + i, vec.begin() + i + size, std::back_inserter(ret));
i += size;
return ret;
}
SceNpCommunicationId get_com_id()
{
if (i + COMMUNICATION_ID_SIZE > vec.size() || error)
{
error = true;
return {};
}
SceNpCommunicationId com_id{};
std::memcpy(&com_id.data[0], &vec[i], COMMUNICATION_ID_COMID_COMPONENT_SIZE);
const std::string sub_id(reinterpret_cast<const char*>(&vec[i + COMMUNICATION_ID_COMID_COMPONENT_SIZE + 1]), COMMUNICATION_ID_SUBID_COMPONENT_SIZE);
const unsigned long result_num = std::strtoul(sub_id.c_str(), nullptr, 10);
if (result_num > 99)
{
error = true;
return {};
}
com_id.num = static_cast<u8>(result_num);
i += COMMUNICATION_ID_SIZE;
return com_id;
}
template <typename T>
const T* get_flatbuffer()
{
auto rawdata_vec = get_rawdata();
if (error)
return nullptr;
if (vec.empty())
{
error = true;
return nullptr;
}
const T* ret = flatbuffers::GetRoot<T>(rawdata_vec.data());
flatbuffers::Verifier verifier(rawdata_vec.data(), rawdata_vec.size());
if (!ret->Verify(verifier))
{
error = true;
return nullptr;
}
aligned_bufs.push_back(std::move(rawdata_vec));
return ret;
}
// Setters
template <typename T>
void insert(T value)
{
value = std::bit_cast<le_t<T>, T>(value);
// resize + memcpy instead?
for (usz index = 0; index < sizeof(T); index++)
{
vec.push_back(*(reinterpret_cast<u8*>(&value) + index));
}
}
void insert_string(const std::string& str) const
{
std::copy(str.begin(), str.end(), std::back_inserter(vec));
vec.push_back(0);
}
protected:
std::vector<u8>& vec;
std::vector<std::vector<u8>> aligned_bufs;
usz i = 0;
bool error = false;
};
namespace rpcn
{
enum CommandType : u16
{
Login,
Terminate,
Create,
SendToken,
SendResetToken,
ResetPassword,
AddFriend,
RemoveFriend,
AddBlock,
RemoveBlock,
GetServerList,
GetWorldList,
CreateRoom,
JoinRoom,
LeaveRoom,
SearchRoom,
GetRoomDataExternalList,
SetRoomDataExternal,
GetRoomDataInternal,
SetRoomDataInternal,
GetRoomMemberDataInternal,
SetRoomMemberDataInternal,
SetUserInfo,
PingRoomOwner,
SendRoomMessage,
RequestSignalingInfos,
RequestTicket,
SendMessage,
GetBoardInfos,
RecordScore,
RecordScoreData,
GetScoreData,
GetScoreRange,
GetScoreFriends,
GetScoreNpid,
GetNetworkTime,
TusSetMultiSlotVariable,
TusGetMultiSlotVariable,
TusGetMultiUserVariable,
TusGetFriendsVariable,
TusAddAndGetVariable,
TusTryAndSetVariable,
TusDeleteMultiSlotVariable,
TusSetData,
TusGetData,
TusGetMultiSlotDataStatus,
TusGetMultiUserDataStatus,
TusGetFriendsDataStatus,
TusDeleteMultiSlotData,
ClearPresence,
SetPresence,
CreateRoomGUI,
JoinRoomGUI,
LeaveRoomGUI,
GetRoomListGUI,
SetRoomSearchFlagGUI,
GetRoomSearchFlagGUI,
SetRoomInfoGUI,
GetRoomInfoGUI,
QuickMatchGUI,
SearchJoinRoomGUI,
};
enum NotificationType : u16
{
UserJoinedRoom,
UserLeftRoom,
RoomDestroyed,
UpdatedRoomDataInternal,
UpdatedRoomMemberDataInternal,
SignalP2PConnect,
_SignalP2PDisconnect,
FriendQuery, // Other user sent a friend request
FriendNew, // Add a friend to the friendlist(either accepted a friend request or friend accepted it)
FriendLost, // Remove friend from the friendlist(user removed friend or friend removed friend)
FriendStatus, // Set status of friend to Offline or Online
RoomMessageReceived,
MessageReceived,
FriendPresenceChanged,
SignalingInfo,
MemberJoinedRoomGUI,
MemberLeftRoomGUI,
RoomDisappearedGUI,
RoomOwnerChangedGUI,
UserKickedGUI,
QuickMatchCompleteGUI,
};
enum class rpcn_state
{
failure_no_failure,
failure_input,
failure_wolfssl,
failure_resolve,
failure_connect,
failure_id,
failure_id_already_logged_in,
failure_id_username,
failure_id_password,
failure_id_token,
failure_protocol,
failure_other,
};
enum PacketType : u8
{
Request,
Reply,
Notification,
ServerInfo,
};
enum ErrorType : u8
{
NoError, // No error
Malformed, // Query was malformed, critical error that should close the connection
Invalid, // The request type is invalid(wrong stage?)
InvalidInput, // The Input doesn't fit the constraints of the request
TooSoon, // Time limited operation attempted too soon
LoginError, // An error happened related to login
LoginAlreadyLoggedIn, // Can't log in because you're already logged in
LoginInvalidUsername, // Invalid username
LoginInvalidPassword, // Invalid password
LoginInvalidToken, // Invalid token
CreationError, // An error happened related to account creation
CreationExistingUsername, // Specific to Account Creation: username exists already
CreationBannedEmailProvider, // Specific to Account Creation: the email provider is banned
CreationExistingEmail, // Specific to Account Creation: that email is already registered to an account
RoomMissing, // User tried to join a non existing room
RoomAlreadyJoined, // User tried to join a room he's already part of
RoomFull, // User tried to join a full room
Unauthorized, // User attempted an unauthorized operation
DbFail, // Generic failure on db side
EmailFail, // Generic failure related to email
NotFound, // Object of the query was not found(room, user, etc)
Blocked, // The operation can't complete because you've been blocked
AlreadyFriend, // Can't add friend because already friend
ScoreNotBest, // A better score is already registered for that user/character_id
ScoreInvalid, // Score for player was found but wasn't what was expected
ScoreHasData, // Score already has data
CondFail, // Condition related to query failed
Unsupported,
__error_last
};
using friend_cb_func = void (*)(void* param, NotificationType ntype, const std::string& username, bool status);
using message_cb_func = void (*)(void* param, const std::shared_ptr<std::pair<std::string, message_data>> new_msg, u64 msg_id);
struct friend_online_data
{
friend_online_data(bool online, SceNpCommunicationId&& pr_com_id, std::string&& pr_title, std::string&& pr_status, std::string&& pr_comment, std::vector<u8>&& pr_data)
: online(online), timestamp(0), pr_com_id(pr_com_id), pr_title(pr_title), pr_status(pr_status), pr_comment(pr_comment), pr_data(pr_data) {}
friend_online_data(bool online, u64 timestamp)
: online(online), timestamp(timestamp) {}
void dump() const;
bool online = false;
u64 timestamp = 0;
SceNpCommunicationId pr_com_id{};
std::string pr_title;
std::string pr_status;
std::string pr_comment;
std::vector<u8> pr_data;
};
struct friend_data
{
std::map<std::string, friend_online_data> friends;
std::set<std::string> requests_sent;
std::set<std::string> requests_received;
std::set<std::string> blocked;
};
localized_string_id rpcn_state_to_localized_string_id(rpcn::rpcn_state state);
std::string rpcn_state_to_string(rpcn::rpcn_state state);
bool is_error(ErrorType err);
class rpcn_client
{
private:
static inline std::weak_ptr<rpcn_client> instance;
static inline shared_mutex inst_mutex;
atomic_t<bool> connected = false;
atomic_t<bool> authentified = false;
atomic_t<bool> want_conn = false;
atomic_t<bool> want_auth = false;
std::binary_semaphore sem_connected, sem_authentified;
std::mutex mutex_connected, mutex_authentified;
std::binary_semaphore sem_reader, sem_writer, sem_rpcn;
std::mutex mutex_read, mutex_write;
std::thread thread_rpcn, thread_rpcn_reader, thread_rpcn_writer;
atomic_t<bool> terminate = false;
atomic_t<u32> num_failures = 0;
atomic_t<rpcn_state> state = rpcn_state::failure_no_failure;
std::vector<std::vector<u8>> packets_to_send;
std::mutex mutex_packets_to_send;
// Friends related
shared_mutex mutex_friends;
std::set<std::pair<friend_cb_func, void*>> friend_cbs;
friend_data friend_infos;
void handle_friend_notification(u16 command, std::vector<u8> data);
void handle_message(std::vector<u8> data);
private:
rpcn_client();
void rpcn_reader_thread();
void rpcn_writer_thread();
void rpcn_thread();
bool handle_input();
bool handle_output();
void add_packet(std::vector<u8> packet);
private:
enum class recvn_result
{
recvn_success,
recvn_nodata,
recvn_timeout,
recvn_noconn,
recvn_terminate,
recvn_fatal,
};
recvn_result recvn(u8* buf, usz n);
bool send_packet(const std::vector<u8>& packet);
private:
bool connect(const std::string& host);
bool login(const std::string& npid, const std::string& password, const std::string& token);
void disconnect();
public:
~rpcn_client();
rpcn_client(rpcn_client& other) = delete;
void operator=(const rpcn_client&) = delete;
static std::shared_ptr<rpcn_client> get_instance(bool check_config = false);
rpcn_state wait_for_connection();
rpcn_state wait_for_authentified();
bool terminate_connection();
void get_friends(friend_data& friend_infos);
void get_friends_and_register_cb(friend_data& friend_infos, friend_cb_func cb_func, void* cb_param);
void register_friend_cb(friend_cb_func, void* cb_param);
void remove_friend_cb(friend_cb_func, void* cb_param);
ErrorType create_user(std::string_view npid, std::string_view password, std::string_view online_name, std::string_view avatar_url, std::string_view email);
ErrorType resend_token(const std::string& npid, const std::string& password);
ErrorType send_reset_token(std::string_view npid, std::string_view email);
ErrorType reset_password(std::string_view npid, std::string_view token, std::string_view password);
bool add_friend(const std::string& friend_username);
bool remove_friend(const std::string& friend_username);
u32 get_num_friends();
u32 get_num_blocks();
std::optional<std::string> get_friend_by_index(u32 index);
std::optional<std::pair<std::string, friend_online_data>> get_friend_presence_by_index(u32 index);
std::optional<std::pair<std::string, friend_online_data>> get_friend_presence_by_npid(const std::string& npid);
std::vector<std::pair<u16, std::vector<u8>>> get_notifications();
std::unordered_map<u32, std::pair<u16, std::vector<u8>>> get_replies();
std::unordered_map<std::string, friend_online_data> get_presence_updates();
std::map<std::string, friend_online_data> get_presence_states();
std::vector<u64> get_new_messages();
std::optional<std::shared_ptr<std::pair<std::string, message_data>>> get_message(u64 id);
std::vector<std::pair<u64, std::shared_ptr<std::pair<std::string, message_data>>>> get_messages_and_register_cb(SceNpBasicMessageMainType type, bool include_bootable, message_cb_func cb_func, void* cb_param);
void remove_message_cb(message_cb_func cb_func, void* cb_param);
void mark_message_used(u64 id);
bool is_connected() const;
bool is_authentified() const;
rpcn_state get_rpcn_state() const;
void server_infos_updated();
// Synchronous requests
bool get_server_list(u32 req_id, const SceNpCommunicationId& communication_id, std::vector<u16>& server_list);
u64 get_network_time(u32 req_id);
// Asynchronous requests
bool get_world_list(u32 req_id, const SceNpCommunicationId& communication_id, u16 server_id);
bool createjoin_room(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpMatching2CreateJoinRoomRequest* req);
bool join_room(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpMatching2JoinRoomRequest* req);
bool leave_room(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpMatching2LeaveRoomRequest* req);
bool search_room(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpMatching2SearchRoomRequest* req);
bool get_roomdata_external_list(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpMatching2GetRoomDataExternalListRequest* req);
bool set_roomdata_external(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpMatching2SetRoomDataExternalRequest* req);
bool get_roomdata_internal(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpMatching2GetRoomDataInternalRequest* req);
bool set_roomdata_internal(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpMatching2SetRoomDataInternalRequest* req);
bool get_roommemberdata_internal(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpMatching2GetRoomMemberDataInternalRequest* req);
bool set_roommemberdata_internal(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpMatching2SetRoomMemberDataInternalRequest* req);
bool set_userinfo(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpMatching2SetUserInfoRequest* req);
bool ping_room_owner(u32 req_id, const SceNpCommunicationId& communication_id, u64 room_id);
bool send_room_message(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpMatching2SendRoomMessageRequest* req);
bool req_sign_infos(u32 req_id, const std::string& npid);
bool req_ticket(u32 req_id, const std::string& service_id, const std::vector<u8>& cookie);
bool send_message(const message_data& msg_data, const std::set<std::string>& npids);
bool get_board_infos(u32 req_id, const SceNpCommunicationId& communication_id, SceNpScoreBoardId board_id);
bool record_score(u32 req_id, const SceNpCommunicationId& communication_id, SceNpScoreBoardId board_id, SceNpScorePcId char_id, SceNpScoreValue score, const std::optional<std::string> comment, const std::optional<std::vector<u8>> score_data);
bool get_score_range(u32 req_id, const SceNpCommunicationId& communication_id, SceNpScoreBoardId board_id, u32 start_rank, u32 num_rank, bool with_comment, bool with_gameinfo);
bool get_score_npid(u32 req_id, const SceNpCommunicationId& communication_id, SceNpScoreBoardId board_id, const std::vector<std::pair<SceNpId, s32>>& npids, bool with_comment, bool with_gameinfo);
bool get_score_friend(u32 req_id, const SceNpCommunicationId& communication_id, SceNpScoreBoardId board_id, bool include_self, bool with_comment, bool with_gameinfo, u32 max_entries);
bool record_score_data(u32 req_id, const SceNpCommunicationId& communication_id, SceNpScorePcId pc_id, SceNpScoreBoardId board_id, s64 score, const std::vector<u8>& score_data);
bool get_score_data(u32 req_id, const SceNpCommunicationId& communication_id, SceNpScorePcId pc_id, SceNpScoreBoardId board_id, const SceNpId& npid);
bool tus_set_multislot_variable(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpOnlineId& targetNpId, vm::cptr<SceNpTusSlotId> slotIdArray, vm::cptr<s64> variableArray, s32 arrayNum, bool vuser);
bool tus_get_multislot_variable(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpOnlineId& targetNpId, vm::cptr<SceNpTusSlotId> slotIdArray, s32 arrayNum, bool vuser);
bool tus_get_multiuser_variable(u32 req_id, const SceNpCommunicationId& communication_id, const std::vector<SceNpOnlineId>& targetNpIdArray, SceNpTusSlotId slotId, s32 arrayNum, bool vuser);
bool tus_get_friends_variable(u32 req_id, const SceNpCommunicationId& communication_id, SceNpTusSlotId slotId, bool includeSelf, s32 sortType, s32 arrayNum);
bool tus_add_and_get_variable(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpOnlineId& targetNpId, SceNpTusSlotId slotId, s64 inVariable, vm::ptr<SceNpTusAddAndGetVariableOptParam> option, bool vuser);
bool tus_try_and_set_variable(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpOnlineId& targetNpId, SceNpTusSlotId slotId, s32 opeType, s64 variable, vm::ptr<SceNpTusTryAndSetVariableOptParam> option, bool vuser);
bool tus_delete_multislot_variable(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpOnlineId& targetNpId, vm::cptr<SceNpTusSlotId> slotIdArray, s32 arrayNum, bool vuser);
bool tus_set_data(u32 req_id, SceNpCommunicationId& communication_id, const SceNpOnlineId& targetNpId, SceNpTusSlotId slotId, const std::vector<u8>& tus_data, vm::cptr<SceNpTusDataInfo> info, vm::ptr<SceNpTusSetDataOptParam> option, bool vuser);
bool tus_get_data(u32 req_id, SceNpCommunicationId& communication_id, const SceNpOnlineId& targetNpId, SceNpTusSlotId slotId, bool vuser);
bool tus_get_multislot_data_status(u32 req_id, SceNpCommunicationId& communication_id, const SceNpOnlineId& targetNpId, vm::cptr<SceNpTusSlotId> slotIdArray, s32 arrayNum, bool vuser);
bool tus_get_multiuser_data_status(u32 req_id, SceNpCommunicationId& communication_id, const std::vector<SceNpOnlineId>& targetNpIdArray, SceNpTusSlotId slotId, s32 arrayNum, bool vuser);
bool tus_get_friends_data_status(u32 req_id, SceNpCommunicationId& communication_id, SceNpTusSlotId slotId, bool includeSelf, s32 sortType, s32 arrayNum);
bool tus_delete_multislot_data(u32 req_id, SceNpCommunicationId& communication_id, const SceNpOnlineId& targetNpId, vm::cptr<SceNpTusSlotId> slotIdArray, s32 arrayNum, bool vuser);
bool send_presence(const SceNpCommunicationId& pr_com_id, const std::string& pr_title, const std::string& pr_status, const std::string& pr_comment, const std::vector<u8>& pr_data);
bool createjoin_room_gui(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpMatchingAttr* attr_list);
bool join_room_gui(u32 req_id, const SceNpRoomId& room_id);
bool leave_room_gui(u32 req_id, const SceNpRoomId& room_id);
bool get_room_list_gui(u32 req_id, const SceNpCommunicationId& communication_id, const SceNpMatchingReqRange* range, vm::ptr<SceNpMatchingSearchCondition> cond, vm::ptr<SceNpMatchingAttr> attr);
bool set_room_search_flag_gui(u32 req_id, const SceNpRoomId& room_id, bool stealth);
bool get_room_search_flag_gui(u32 req_id, const SceNpRoomId& room_id);
bool set_room_info_gui(u32 req_id, const SceNpRoomId& room_id, vm::ptr<SceNpMatchingAttr> attrs);
bool get_room_info_gui(u32 req_id, const SceNpRoomId& room_id, vm::ptr<SceNpMatchingAttr> attrs);
bool quickmatch_gui(u32 req_id, const SceNpCommunicationId& com_id, vm::cptr<SceNpMatchingSearchCondition> cond, s32 available_num);
bool searchjoin_gui(u32 req_id, const SceNpCommunicationId& com_id, vm::cptr<SceNpMatchingSearchCondition> cond, vm::cptr<SceNpMatchingAttr> attr);
const std::string& get_online_name() const;
const std::string& get_avatar_url() const;
u32 get_addr_sig() const;
u16 get_port_sig() const;
u32 get_addr_local() const;
void update_local_addr(u32 addr);
private:
bool get_reply(u64 expected_id, std::vector<u8>& data);
static void write_communication_id(const SceNpCommunicationId& com_id, std::vector<u8>& data);
std::vector<u8> forge_request(u16 command, u64 packet_id, const std::vector<u8>& data) const;
bool forge_send(u16 command, u64 packet_id, const std::vector<u8>& data);
bool forge_request_with_com_id(const flatbuffers::FlatBufferBuilder& builder, const SceNpCommunicationId& com_id, CommandType command, u64 packet_id);
bool forge_request_with_data(const flatbuffers::FlatBufferBuilder& builder, CommandType command, u64 packet_id);
bool forge_send_reply(u16 command, u64 packet_id, const std::vector<u8>& data, std::vector<u8>& reply_data);
bool error_and_disconnect(const std::string& error_mgs);
bool error_and_disconnect_notice(const std::string& error_msg);
std::string get_wolfssl_error(WOLFSSL* wssl, int error) const;
private:
WOLFSSL_CTX* wssl_ctx = nullptr;
WOLFSSL* read_wssl = nullptr;
WOLFSSL* write_wssl = nullptr;
atomic_t<bool> server_info_received = false;
u32 received_version = 0;
// UDP Signaling related
steady_clock::time_point last_ping_time{}, last_pong_time{};
sockaddr_in addr_rpcn{};
sockaddr_in addr_rpcn_udp{};
#ifdef _WIN32
SOCKET sockfd = 0;
#else
int sockfd = 0;
#endif
atomic_t<u64> rpcn_request_counter = 0x100000001; // Counter used for commands whose result is not forwarded to NP handler(login, create, sendmessage, etc)
shared_mutex mutex_notifs, mutex_replies, mutex_replies_sync, mutex_presence_updates;
std::vector<std::pair<u16, std::vector<u8>>> notifications; // notif type / data
std::unordered_map<u32, std::pair<u16, std::vector<u8>>> replies; // req id / (command / data)
std::unordered_map<u64, std::pair<u16, std::vector<u8>>> replies_sync; // same but for sync replies(see handle_input())
std::unordered_map<std::string, friend_online_data> presence_updates; // npid / presence data
// Messages
struct message_cb_t
{
message_cb_func cb_func;
void* cb_param;
SceNpBasicMessageMainType type_filter;
bool inc_bootable;
bool operator<(const message_cb_t& other) const
{
const void* void_cb_func = reinterpret_cast<const void*>(cb_func);
const void* void_other_cb_func = reinterpret_cast<const void*>(other.cb_func);
return (void_cb_func < void_other_cb_func) || ((!(void_other_cb_func < void_cb_func)) && (cb_param < other.cb_param));
}
};
shared_mutex mutex_messages;
std::set<message_cb_t> message_cbs;
std::unordered_map<u64, std::shared_ptr<std::pair<std::string, message_data>>> messages; // msg id / (sender / message)
std::set<u64> active_messages; // msg id of messages that have not been discarded
std::vector<u64> new_messages; // list of msg_id used to inform np_handler of new messages
u64 message_counter = 3; // id counter
std::string online_name{};
std::string avatar_url{};
s64 user_id = 0;
atomic_t<u32> addr_sig = 0;
atomic_t<u32> port_sig = 0; // Stores an u16, u32 is used for atomic_t::wait convenience
atomic_t<u32> local_addr_sig = 0;
static constexpr int RPCN_TIMEOUT_INTERVAL = 50; // 50ms
static constexpr int RPCN_TIMEOUT = 10'000; // 10s
};
} // namespace rpcn
| 24,190
|
C++
|
.h
| 529
| 42.812854
| 247
| 0.736277
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,241
|
np_dnshook.h
|
RPCS3_rpcs3/rpcs3/Emu/NP/np_dnshook.h
|
#pragma once
#include <unordered_map>
#include <queue>
#include <vector>
#include <optional>
#include "util/types.hpp"
#include "Utilities/mutex.h"
namespace np
{
class dnshook
{
public:
dnshook();
void add_dns_spy(u32 sock);
void remove_dns_spy(u32 sock);
bool is_dns(u32 sock);
bool is_dns_queue(u32 sock);
std::vector<u8> get_dns_packet(u32 sock);
s32 analyze_dns_packet(s32 s, const u8* buf, u32 len);
private:
std::optional<u32> get_redir(const std::string& hostname);
private:
shared_mutex mutex;
std::unordered_map<s32, std::queue<std::vector<u8>>> m_dns_spylist;
std::vector<std::pair<std::string, u32>> m_redirs;
};
} // namespace np
| 679
|
C++
|
.h
| 27
| 22.814815
| 69
| 0.718944
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,242
|
np_helpers.h
|
RPCS3_rpcs3/rpcs3/Emu/NP/np_helpers.h
|
#pragma once
#include "util/types.hpp"
#include "Emu/Cell/Modules/sceNp.h"
#include "Emu/Cell/Modules/sceNp2.h"
#include "rpcn_client.h"
namespace np
{
std::string ip_to_string(u32 addr);
std::string ether_to_string(std::array<u8, 6>& ether);
std::string communication_id_to_string(const SceNpCommunicationId& communicationId);
void string_to_npid(std::string_view str, SceNpId& npid);
void string_to_online_name(std::string_view str, SceNpOnlineName& online_name);
void string_to_avatar_url(std::string_view str, SceNpAvatarUrl& avatar_url);
void string_to_communication_id(std::string_view str, SceNpCommunicationId& comm_id);
void strings_to_userinfo(std::string_view npid, std::string_view online_name, std::string_view avatar_url, SceNpUserInfo& user_info);
template <typename T>
void onlinedata_to_presencedetails(const rpcn::friend_online_data& data, bool same_context, T& details);
bool is_valid_npid(const SceNpId& npid);
bool is_same_npid(const SceNpId& npid_1, const SceNpId& npid_2);
}
| 1,015
|
C++
|
.h
| 20
| 48.9
| 134
| 0.774747
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,243
|
np_event_data.h
|
RPCS3_rpcs3/rpcs3/Emu/NP/np_event_data.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
#include "util/asm.hpp"
namespace np
{
class event_data
{
public:
event_data(u32 vm_addr, u32 initial_size, u32 max_size)
: m_max_size(max_size), m_cur_size(utils::align(initial_size, 4))
{
m_data_ptr.set(vm_addr);
}
event_data()
{
}
u8* data()
{
return m_data_ptr.get_ptr();
}
const u8* data() const
{
return m_data_ptr.get_ptr();
}
u32 size() const
{
return m_cur_size;
}
u32 addr() const
{
return m_data_ptr.addr();
}
template <typename T>
void add_relocation(vm::bptr<T>& dest)
{
u8* dest_ptr = reinterpret_cast<u8*>(&dest);
ensure(dest_ptr >= m_data_ptr.get_ptr() && dest_ptr < (m_data_ptr.get_ptr() + m_cur_size), "event_data::allocate: dest is out of bounds!");
m_relocs.push_back(static_cast<u32>(dest_ptr - m_data_ptr.get_ptr()));
}
template <typename T>
T* allocate(u32 size, vm::bptr<T>& dest)
{
const u32 to_alloc = utils::align(size, 4);
ensure((m_cur_size + to_alloc) <= m_max_size, "event_data::allocate: size would overflow the allocated buffer!");
u8* dest_ptr = reinterpret_cast<u8*>(&dest);
ensure(dest_ptr >= m_data_ptr.get_ptr() && dest_ptr < (m_data_ptr.get_ptr() + m_cur_size), "event_data::allocate: dest is out of bounds!");
const u32 offset_alloc = m_cur_size;
// Set the vm::bptr to new allocated portion of memory
dest.set(m_data_ptr.addr() + offset_alloc);
// Save the relocation offset
m_relocs.push_back(static_cast<u32>(dest_ptr - m_data_ptr.get_ptr()));
// Update currently allocated space
m_cur_size += to_alloc;
// Return actual pointer to allocated
return reinterpret_cast<T*>(m_data_ptr.get_ptr() + offset_alloc);
}
template <typename T>
void allocate_ptr_array(u32 num_pointers, vm::bpptr<T>& dest)
{
const u32 to_alloc = num_pointers * sizeof(u32);
ensure((m_cur_size + to_alloc) <= m_max_size, "event_data::allocate: size would overflow the allocated buffer!");
u8* dest_ptr = reinterpret_cast<u8*>(&dest);
ensure(dest_ptr >= m_data_ptr.get_ptr() && dest_ptr < (m_data_ptr.get_ptr() + m_cur_size), "event_data::allocate_ptr_array: dest is out of bounds!");
const u32 offset_alloc = m_cur_size;
// Set the vm::bpptr to relative offset
dest.set(m_data_ptr.addr() + offset_alloc);
// Save the relocation offset
m_relocs.push_back(static_cast<u32>(dest_ptr - m_data_ptr.get_ptr()));
// Add all the pointers to the relocation
for (u32 i = 0; i < num_pointers; i++)
{
m_relocs.push_back(offset_alloc + (i * 4));
}
// Update currently allocated space
m_cur_size += to_alloc;
}
void apply_relocations(u32 new_addr)
{
u32 diff_offset = new_addr - m_data_ptr.addr();
for (const auto offset : m_relocs)
{
auto* ptr = reinterpret_cast<be_t<u32>*>(m_data_ptr.get_ptr() + offset);
*ptr += diff_offset;
}
}
private:
vm::bptr<u8> m_data_ptr{};
u32 m_max_size = 0, m_cur_size = 0;
std::vector<u32> m_relocs;
};
} // namespace np
| 3,027
|
C++
|
.h
| 91
| 29.725275
| 152
| 0.652383
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,244
|
np_allocator.h
|
RPCS3_rpcs3/rpcs3/Emu/NP/np_allocator.h
|
#pragma once
#include <map>
#include "Emu/Memory/vm_ptr.h"
#include "Utilities/mutex.h"
#include "util/asm.hpp"
#include "util/logs.hpp"
LOG_CHANNEL(np_mem_allocator);
namespace np
{
class memory_allocator
{
public:
memory_allocator() = default;
memory_allocator(utils::serial& ar) noexcept { save(ar); }
memory_allocator(const memory_allocator&) = delete;
memory_allocator& operator=(const memory_allocator&) = delete;
void save(utils::serial& ar);
void setup(vm::ptr<void> ptr_pool, u32 size)
{
std::lock_guard lock(m_mutex);
m_pool = ptr_pool;
m_size = size;
m_avail = size;
m_allocs.clear();
}
void release()
{
std::lock_guard lock(m_mutex);
m_pool = vm::null;
m_size = 0;
m_avail = 0;
m_allocs.clear();
}
u32 allocate(u32 size)
{
std::lock_guard lock(m_mutex);
if (!size)
{
np_mem_allocator.error("Can't allocate 0 size buffer!");
return 0;
}
// Align allocs
const u32 alloc_size = utils::align(size, 4);
if (alloc_size > m_avail)
{
np_mem_allocator.error("Not enough memory available in NP pool!");
return 0;
}
u32 last_free = 0;
bool found_space = false;
for (auto& a : m_allocs)
{
if ((a.first - last_free) >= alloc_size)
{
found_space = true;
break;
}
last_free = a.first + a.second;
}
if (!found_space)
{
if ((m_size - last_free) < alloc_size)
{
np_mem_allocator.error("Not enough memory available in NP pool(continuous block)!");
return 0;
}
}
m_allocs.emplace(last_free, alloc_size);
m_avail -= alloc_size;
memset((static_cast<u8*>(m_pool.get_ptr())) + last_free, 0, alloc_size);
np_mem_allocator.trace("Allocation off:%d size:%d psize:%d, pavail:%d", last_free, alloc_size, m_size, m_avail);
return m_pool.addr() + last_free;
}
void free(u32 addr)
{
std::lock_guard lock(m_mutex);
ensure(addr >= m_pool.addr() && addr < (m_pool.addr() + m_size), "memory_allocator::free: addr is out of bounds!");
const u32 offset = addr - m_pool.addr();
ensure(m_allocs.contains(offset), "memory_allocator::free: m_allocs doesn't contain the allocation!");
m_avail += ::at32(m_allocs, offset);
m_allocs.erase(offset);
}
void shrink_allocation(u32 addr, u32 new_size)
{
std::lock_guard lock(m_mutex);
ensure(addr >= m_pool.addr() && addr < (m_pool.addr() + m_size), "memory_allocator::reduce_allocation: addr is out of bounds!");
const u32 offset = addr - m_pool.addr();
ensure(m_allocs.contains(offset), "memory_allocator::reduce_allocation: m_allocs doesn't contain the allocation!");
ensure(m_allocs[offset] >= new_size, "memory_allocator::reduce_allocation: New size is bigger than current allocation!");
m_avail += (::at32(m_allocs, offset) - new_size);
m_allocs[offset] = new_size;
}
private:
shared_mutex m_mutex;
vm::ptr<void> m_pool{};
u32 m_size = 0;
u32 m_avail = 0;
std::map<u32, u32> m_allocs{}; // offset/size
};
} // namespace np
| 3,029
|
C++
|
.h
| 100
| 26.49
| 131
| 0.650362
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,245
|
rpcn_countries.h
|
RPCS3_rpcs3/rpcs3/Emu/NP/rpcn_countries.h
|
#pragma once
#include <array>
#include <string>
namespace countries
{
struct country_code
{
std::string_view name;
std::string_view ccode;
};
extern const std::array<country_code, 72> g_countries;
} // namespace countries
| 233
|
C++
|
.h
| 12
| 17.5
| 55
| 0.756881
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,246
|
np_gui_cache.h
|
RPCS3_rpcs3/rpcs3/Emu/NP/np_gui_cache.h
|
#pragma once
#include <map>
#include <optional>
#include "Utilities/mutex.h"
#include "Emu/Cell/Modules/sceNp.h"
#include "Emu/Cell/Modules/sceNp2.h"
template <>
struct std::less<SceNpRoomId>
{
bool operator()(const SceNpRoomId& a, const SceNpRoomId& b) const
{
return (std::memcmp(a.opt, b.opt, sizeof(a.opt)) < 0);
}
};
template <>
struct std::less<SceNpId>
{
bool operator()(const SceNpId& a, const SceNpId& b) const
{
return (std::memcmp(a.handle.data, b.handle.data, sizeof(a.handle.data)) < 0);
}
};
namespace np
{
struct gui_room_member
{
SceNpUserInfo info;
bool owner;
};
struct gui_room_cache
{
std::map<SceNpId, gui_room_member> members;
};
class gui_cache_manager
{
public:
gui_cache_manager() = default;
void add_room(const SceNpRoomId& room_id);
void del_room(const SceNpRoomId& room_id);
void add_member(const SceNpRoomId& room_id, const SceNpMatchingRoomMember* user_info, bool new_member);
void del_member(const SceNpRoomId& room_id, const SceNpMatchingRoomMember* user_info);
error_code get_room_member_list(const SceNpRoomId& room_id, u32 buf_len, vm::ptr<void> data);
private:
shared_mutex mutex;
std::map<SceNpRoomId, gui_room_cache> rooms;
};
} // namespace np
| 1,237
|
C++
|
.h
| 47
| 24.170213
| 105
| 0.737065
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,247
|
np_structs_extra.h
|
RPCS3_rpcs3/rpcs3/Emu/NP/np_structs_extra.h
|
#pragma once
#include "Emu/Cell/Modules/sceNp2.h"
namespace extra_nps
{
void print_SceNpUserInfo2(const SceNpUserInfo2* user);
void print_SceNpMatching2SignalingOptParam(const SceNpMatching2SignalingOptParam* opt);
void print_SceNpMatching2BinAttr(const SceNpMatching2BinAttr* bin);
void print_SceNpMatching2PresenceOptionData(const SceNpMatching2PresenceOptionData* opt);
void print_SceNpMatching2RangeFilter(const SceNpMatching2RangeFilter* filt);
void print_SceNpMatching2RoomDataInternal(const SceNpMatching2RoomDataInternal* room);
void print_SceNpMatching2RoomDataExternal(const SceNpMatching2RoomDataExternal* room);
void print_SceNpMatching2RoomMemberDataInternal(const SceNpMatching2RoomMemberDataInternal* member);
void print_SceNpMatching2CreateJoinRoomRequest(const SceNpMatching2CreateJoinRoomRequest* req);
void print_SceNpMatching2CreateJoinRoomResponse(const SceNpMatching2CreateJoinRoomResponse* resp);
void print_SceNpMatching2JoinRoomRequest(const SceNpMatching2JoinRoomRequest* req);
void print_SceNpMatching2SearchRoomRequest(const SceNpMatching2SearchRoomRequest* req);
void print_SceNpMatching2SearchRoomResponse(const SceNpMatching2SearchRoomResponse* resp);
void print_SceNpMatching2SetRoomDataExternalRequest(const SceNpMatching2SetRoomDataExternalRequest* req);
void print_SceNpMatching2SetRoomDataInternalRequest(const SceNpMatching2SetRoomDataInternalRequest* req);
void print_SceNpMatching2GetRoomMemberDataInternalRequest(const SceNpMatching2GetRoomMemberDataInternalRequest* req);
void print_SceNpMatching2SetRoomMemberDataInternalRequest(const SceNpMatching2SetRoomMemberDataInternalRequest* req);
void print_SceNpMatching2GetRoomDataExternalListRequest(const SceNpMatching2GetRoomDataExternalListRequest* req);
void print_SceNpMatching2GetRoomDataExternalListResponse(const SceNpMatching2GetRoomDataExternalListResponse* resp);
void print_SceNpMatching2GetLobbyInfoListRequest(const SceNpMatching2GetLobbyInfoListRequest* resp);
void print_SceNpBasicAttachmentData(const SceNpBasicAttachmentData* data);
void print_SceNpBasicExtendedAttachmentData(const SceNpBasicExtendedAttachmentData* data);
void print_SceNpScoreRankData(const SceNpScoreRankData* data);
void print_SceNpScoreRankData_deprecated(const SceNpScoreRankData_deprecated* data);
void print_SceNpRoomId(const SceNpRoomId& room_id);
void print_SceNpMatchingAttr(const SceNpMatchingAttr* data);
void print_SceNpMatchingSearchCondition(const SceNpMatchingSearchCondition* data);
void print_SceNpMatchingRoom(const SceNpMatchingRoom* data);
void print_SceNpMatchingRoomList(const SceNpMatchingRoomList* data);
void print_SceNpMatchingRoomStatus(const SceNpMatchingRoomStatus* data);
void print_SceNpMatchingJoinedRoomInfo(const SceNpMatchingJoinedRoomInfo* data);
void print_SceNpMatchingSearchJoinRoomInfo(const SceNpMatchingSearchJoinRoomInfo* data);
} // namespace extra_nps
| 2,910
|
C++
|
.h
| 37
| 76.594595
| 118
| 0.891486
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,248
|
np_handler.h
|
RPCS3_rpcs3/rpcs3/Emu/NP/np_handler.h
|
#pragma once
#include <queue>
#include <map>
#include <unordered_map>
#include "Emu/Memory/vm_ptr.h"
#include "Emu/Cell/Modules/sceNp.h"
#include "Emu/Cell/Modules/sceNp2.h"
#include "Emu/Cell/Modules/cellSysutil.h"
#include "Emu/NP/rpcn_client.h"
#include "Emu/NP/generated/np2_structs_generated.h"
#include "Emu/NP/signaling_handler.h"
#include "Emu/NP/np_allocator.h"
#include "Emu/NP/np_cache.h"
#include "Emu/NP/np_gui_cache.h"
#include "Emu/NP/np_event_data.h"
#include "Emu/NP/np_contexts.h"
#include "Emu/NP/upnp_handler.h"
namespace np
{
constexpr usz MAX_SceNpMatchingAttr_list_SIZE = ((SCE_NP_MATCHING_ATTR_ID_MAX * 2) * sizeof(SceNpMatchingAttr))
+ (SCE_NP_MATCHING_ATTR_BIN_BIG_SIZE_ID_MAX * SCE_NP_MATCHING_ATTR_BIN_MAX_SIZE_BIG) +
+ ((SCE_NP_MATCHING_ATTR_ID_MAX - SCE_NP_MATCHING_ATTR_BIN_BIG_SIZE_ID_MAX) * SCE_NP_MATCHING_ATTR_BIN_MAX_SIZE_SMALL);
constexpr usz MAX_MEMBERS_PER_ROOM = 64;
constexpr usz MAX_ROOMS_PER_GET_ROOM_LIST = 20;
constexpr usz MAX_SceNpMatchingRoomStatus_SIZE = sizeof(SceNpMatchingRoomStatus) + (MAX_MEMBERS_PER_ROOM * sizeof(SceNpMatchingRoomMember)) + sizeof(SceNpId);
constexpr usz MAX_SceNpMatchingJoinedRoomInfo_SIZE = sizeof(SceNpMatchingJoinedRoomInfo) + (MAX_MEMBERS_PER_ROOM * sizeof(SceNpMatchingRoomMember)) + sizeof(SceNpId);
constexpr usz MAX_SceNpMatchingRoomList_SIZE = sizeof(SceNpMatchingRoomList) + MAX_ROOMS_PER_GET_ROOM_LIST * (sizeof(SceNpMatchingRoom) + MAX_SceNpMatchingAttr_list_SIZE);
constexpr usz MAX_SceNpMatchingRoom_SIZE = sizeof(SceNpMatchingRoom) + MAX_SceNpMatchingAttr_list_SIZE;
constexpr usz MAX_SceNpMatchingSearchJoinRoomInfo_SIZE = sizeof(SceNpMatchingSearchJoinRoomInfo) + MAX_SceNpMatchingAttr_list_SIZE;
enum class REQUEST_ID_HIGH : u16
{
MISC = 0x3333,
SCORE = 0x3334,
TUS = 0x3335,
GUI = 0x3336,
};
struct ticket_data
{
u16 id{}, len{};
struct
{
u32 data_u32{};
u64 data_u64{};
std::vector<u8> data_vec;
std::vector<ticket_data> data_nodes;
} data;
};
struct player_history
{
u64 timestamp{};
std::set<std::string> communication_ids;
std::string description;
};
class ticket
{
public:
ticket() = default;
ticket(std::vector<u8>&& raw_data);
std::size_t size() const;
const u8* data() const;
bool empty() const;
bool get_value(s32 param_id, vm::ptr<SceNpTicketParam> param) const;
private:
std::optional<ticket_data> parse_node(std::size_t index) const;
void parse();
private:
static constexpr std::size_t MIN_TICKET_DATA_SIZE = 4;
std::vector<u8> raw_data;
bool parse_success = false;
u32 version{};
std::vector<ticket_data> nodes;
};
struct basic_event
{
s32 event = 0;
SceNpUserInfo from{};
std::vector<u8> data;
};
class np_handler
{
public:
SAVESTATE_INIT_POS(5);
np_handler();
~np_handler();
np_handler(utils::serial& ar);
void save(utils::serial& ar);
void init_np_handler_dependencies();
const std::array<u8, 6>& get_ether_addr() const;
const std::string& get_hostname() const;
u32 get_local_ip_addr() const;
u32 get_public_ip_addr() const;
u32 get_dns_ip() const;
u32 get_bind_ip() const;
s32 get_psn_status() const;
s32 get_net_status() const;
s32 get_upnp_status() const;
const SceNpId& get_npid() const;
const SceNpOnlineId& get_online_id() const;
const SceNpOnlineName& get_online_name() const;
const SceNpAvatarUrl& get_avatar_url() const;
// handles async messages from server(only needed for RPCN)
void operator()();
void init_NP(u32 poolsize, vm::ptr<void> poolptr);
void terminate_NP();
atomic_t<bool> is_netctl_init = false;
atomic_t<bool> is_NP_init = false;
atomic_t<bool> is_NP_Lookup_init = false;
atomic_t<bool> is_NP_Score_init = false;
atomic_t<bool> is_NP2_init = false;
atomic_t<bool> is_NP2_Match2_init = false;
atomic_t<bool> is_NP_Auth_init = false;
atomic_t<bool> is_NP_TUS_init = false; // TODO: savestate
atomic_t<bool> is_NP_Com2_init = false; // TODO: savestate
// NP Handlers/Callbacks
// Seems to be global
vm::ptr<SceNpManagerCallback> manager_cb{}; // Connection status and tickets
vm::ptr<void> manager_cb_arg{};
atomic_t<bool> basic_handler_registered = false;
void register_basic_handler(vm::cptr<SceNpCommunicationId> context, vm::ptr<SceNpBasicEventHandler> handler, vm::ptr<void> arg, bool context_sensitive);
SceNpCommunicationId get_basic_handler_context();
void queue_basic_event(basic_event to_queue);
bool send_basic_event(s32 event, s32 retCode, u32 reqId);
error_code get_basic_event(vm::ptr<s32> event, vm::ptr<SceNpUserInfo> from, vm::ptr<u8> data, vm::ptr<u32> size);
// Messages-related functions
std::optional<std::shared_ptr<std::pair<std::string, message_data>>> get_message(u64 id);
void set_message_selected(SceNpBasicAttachmentDataId id, u64 msg_id);
std::optional<std::shared_ptr<std::pair<std::string, message_data>>> get_message_selected(SceNpBasicAttachmentDataId id);
void clear_message_selected(SceNpBasicAttachmentDataId id);
void send_message(const message_data& msg_data, const std::set<std::string>& npids);
// Those should probably be under match2 ctx
vm::ptr<SceNpMatching2RoomEventCallback> room_event_cb{}; // Room events
u16 room_event_cb_ctx = 0;
vm::ptr<void> room_event_cb_arg{};
vm::ptr<SceNpMatching2RoomMessageCallback> room_msg_cb{};
u16 room_msg_cb_ctx = 0;
vm::ptr<void> room_msg_cb_arg{};
// Synchronous requests
std::vector<SceNpMatching2ServerId> get_match2_server_list(SceNpMatching2ContextId);
u64 get_network_time();
// Asynchronous requests
u32 get_server_status(SceNpMatching2ContextId ctx_id, vm::cptr<SceNpMatching2RequestOptParam> optParam, u16 server_id);
u32 create_server_context(SceNpMatching2ContextId ctx_id, vm::cptr<SceNpMatching2RequestOptParam> optParam, u16 server_id);
u32 delete_server_context(SceNpMatching2ContextId ctx_id, vm::cptr<SceNpMatching2RequestOptParam> optParam, u16 server_id);
u32 get_world_list(SceNpMatching2ContextId ctx_id, vm::cptr<SceNpMatching2RequestOptParam> optParam, u16 server_id);
u32 create_join_room(SceNpMatching2ContextId ctx_id, vm::cptr<SceNpMatching2RequestOptParam> optParam, const SceNpMatching2CreateJoinRoomRequest* req);
u32 join_room(SceNpMatching2ContextId ctx_id, vm::cptr<SceNpMatching2RequestOptParam> optParam, const SceNpMatching2JoinRoomRequest* req);
u32 leave_room(SceNpMatching2ContextId ctx_id, vm::cptr<SceNpMatching2RequestOptParam> optParam, const SceNpMatching2LeaveRoomRequest* req);
u32 search_room(SceNpMatching2ContextId ctx_id, vm::cptr<SceNpMatching2RequestOptParam> optParam, const SceNpMatching2SearchRoomRequest* req);
u32 get_roomdata_external_list(SceNpMatching2ContextId ctx_id, vm::cptr<SceNpMatching2RequestOptParam> optParam, const SceNpMatching2GetRoomDataExternalListRequest* req);
u32 set_roomdata_external(SceNpMatching2ContextId ctx_id, vm::cptr<SceNpMatching2RequestOptParam> optParam, const SceNpMatching2SetRoomDataExternalRequest* req);
u32 get_roomdata_internal(SceNpMatching2ContextId ctx_id, vm::cptr<SceNpMatching2RequestOptParam> optParam, const SceNpMatching2GetRoomDataInternalRequest* req);
u32 set_roomdata_internal(SceNpMatching2ContextId ctx_id, vm::cptr<SceNpMatching2RequestOptParam> optParam, const SceNpMatching2SetRoomDataInternalRequest* req);
u32 get_roommemberdata_internal(SceNpMatching2ContextId ctx_id, vm::cptr<SceNpMatching2RequestOptParam> optParam, const SceNpMatching2GetRoomMemberDataInternalRequest* req);
u32 set_roommemberdata_internal(SceNpMatching2ContextId ctx_id, vm::cptr<SceNpMatching2RequestOptParam> optParam, const SceNpMatching2SetRoomMemberDataInternalRequest* req);
u32 set_userinfo(SceNpMatching2ContextId ctx_id, vm::cptr<SceNpMatching2RequestOptParam> optParam, const SceNpMatching2SetUserInfoRequest* req);
u32 get_ping_info(SceNpMatching2ContextId ctx_id, vm::cptr<SceNpMatching2RequestOptParam> optParam, const SceNpMatching2SignalingGetPingInfoRequest* req);
u32 send_room_message(SceNpMatching2ContextId ctx_id, vm::cptr<SceNpMatching2RequestOptParam> optParam, const SceNpMatching2SendRoomMessageRequest* req);
u32 get_lobby_info_list(SceNpMatching2ContextId ctx_id, vm::cptr<SceNpMatching2RequestOptParam> optParam, const SceNpMatching2GetLobbyInfoListRequest* req);
u32 get_match2_event(SceNpMatching2EventKey event_key, u32 dest_addr, u32 size);
// Old GUI Matching requests
error_code get_matching_result(u32 ctx_id, u32 req_id, vm::ptr<void> buf, vm::ptr<u32> size, vm::ptr<s32> event);
error_code get_result_gui(vm::ptr<void> buf, vm::ptr<u32> size, vm::ptr<s32> event);
error_code create_room_gui(u32 ctx_id, vm::cptr<SceNpCommunicationId> communicationId, vm::cptr<SceNpMatchingAttr> attr, vm::ptr<SceNpMatchingGUIHandler> handler, vm::ptr<void> arg);
error_code join_room_gui(u32 ctx_id, vm::ptr<SceNpRoomId> roomid, vm::ptr<SceNpMatchingGUIHandler> handler, vm::ptr<void> arg);
error_code leave_room_gui(u32 ctx_id, vm::cptr<SceNpRoomId> roomid);
error_code get_room_list_gui(u32 ctx_id, vm::cptr<SceNpCommunicationId> communicationId, vm::ptr<SceNpMatchingReqRange> range, vm::ptr<SceNpMatchingSearchCondition> cond, vm::ptr<SceNpMatchingAttr> attr, vm::ptr<SceNpMatchingGUIHandler> handler, vm::ptr<void> arg, bool limit);
error_code set_room_search_flag_gui(u32 ctx_id, vm::ptr<SceNpLobbyId> lobby_id, vm::ptr<SceNpRoomId> room_id, s32 flag);
error_code get_room_search_flag_gui(u32 ctx_id, vm::ptr<SceNpLobbyId> lobby_id, vm::ptr<SceNpRoomId> room_id);
error_code set_room_info_gui(u32 ctx_id, vm::ptr<SceNpLobbyId> lobby_id, vm::ptr<SceNpRoomId> room_id, vm::ptr<SceNpMatchingAttr> attr);
error_code get_room_info_gui(u32 ctx_id, vm::ptr<SceNpLobbyId> lobby_id, vm::ptr<SceNpRoomId> room_id, vm::ptr<SceNpMatchingAttr> attr);
error_code quickmatch_gui(u32 ctx_id, vm::cptr<SceNpCommunicationId> communicationId, vm::cptr<SceNpMatchingSearchCondition> cond, s32 available_num, s32 timeout, vm::ptr<SceNpMatchingGUIHandler> handler, vm::ptr<void> arg);
error_code searchjoin_gui(u32 ctx_id, vm::cptr<SceNpCommunicationId> communicationId, vm::cptr<SceNpMatchingSearchCondition> cond, vm::cptr<SceNpMatchingAttr> attr, vm::ptr<SceNpMatchingGUIHandler> handler, vm::ptr<void> arg);
void set_current_gui_ctx_id(u32 id);
// Score requests
void transaction_async_handler(std::unique_lock<shared_mutex> lock, const std::shared_ptr<generic_async_transaction_context>& trans_ctx, u32 req_id, bool async);
void get_board_infos(std::shared_ptr<score_transaction_ctx>& trans_ctx, SceNpScoreBoardId boardId, vm::ptr<SceNpScoreBoardInfo> boardInfo, bool async);
void record_score(std::shared_ptr<score_transaction_ctx>& trans_ctx, SceNpScoreBoardId boardId, SceNpScoreValue score, vm::cptr<SceNpScoreComment> scoreComment, const u8* data, u32 data_size, vm::ptr<SceNpScoreRankNumber> tmpRank, bool async);
void record_score_data(std::shared_ptr<score_transaction_ctx>& trans_ctx, SceNpScoreBoardId boardId, SceNpScoreValue score, u32 totalSize, u32 sendSize, const u8* score_data, bool async);
void get_score_data(std::shared_ptr<score_transaction_ctx>& trans_ctx, SceNpScoreBoardId boardId, const SceNpId& npId, vm::ptr<u32> totalSize, u32 recvSize, vm::ptr<void> score_data, bool async);
void get_score_range(std::shared_ptr<score_transaction_ctx>& trans_ctx, SceNpScoreBoardId boardId, SceNpScoreRankNumber startSerialRank, vm::ptr<SceNpScoreRankData> rankArray, u32 rankArraySize, vm::ptr<SceNpScoreComment> commentArray, u32 commentArraySize, vm::ptr<void> infoArray, u32 infoArraySize, u32 arrayNum, vm::ptr<CellRtcTick> lastSortDate, vm::ptr<SceNpScoreRankNumber> totalRecord, bool async, bool deprecated);
void get_score_npid(std::shared_ptr<score_transaction_ctx>& trans_ctx, SceNpScoreBoardId boardId, const std::vector<std::pair<SceNpId, s32>>& npid_vec, vm::ptr<SceNpScorePlayerRankData> rankArray, u32 rankArraySize, vm::ptr<SceNpScoreComment> commentArray, u32 commentArraySize, vm::ptr<void> infoArray, u32 infoArraySize, u32 arrayNum, vm::ptr<CellRtcTick> lastSortDate, vm::ptr<SceNpScoreRankNumber> totalRecord, bool async, bool deprecated);
void get_score_friend(std::shared_ptr<score_transaction_ctx>& trans_ctx, SceNpScoreBoardId boardId, bool include_self, vm::ptr<SceNpScoreRankData> rankArray, u32 rankArraySize, vm::ptr<SceNpScoreComment> commentArray, u32 commentArraySize, vm::ptr<void> infoArray, u32 infoArraySize, u32 arrayNum, vm::ptr<CellRtcTick> lastSortDate, vm::ptr<SceNpScoreRankNumber> totalRecord, bool async, bool deprecated);
// TUS requests
void tus_set_multislot_variable(std::shared_ptr<tus_transaction_ctx>& trans_ctx, const SceNpOnlineId& targetNpId, vm::cptr<SceNpTusSlotId> slotIdArray, vm::cptr<s64> variableArray, s32 arrayNum, bool vuser, bool async);
void tus_get_multislot_variable(std::shared_ptr<tus_transaction_ctx>& trans_ctx, const SceNpOnlineId& targetNpId, vm::cptr<SceNpTusSlotId> slotIdArray, vm::ptr<SceNpTusVariable> variableArray, s32 arrayNum, bool vuser, bool async);
void tus_get_multiuser_variable(std::shared_ptr<tus_transaction_ctx>& trans_ctx, std::vector<SceNpOnlineId> targetNpIdArray, SceNpTusSlotId slotId, vm::ptr<SceNpTusVariable> variableArray, s32 arrayNum, bool vuser, bool async);
void tus_get_friends_variable(std::shared_ptr<tus_transaction_ctx>& trans_ctx, SceNpTusSlotId slotId, s32 includeSelf, s32 sortType, vm::ptr<SceNpTusVariable> variableArray,s32 arrayNum, bool async);
void tus_add_and_get_variable(std::shared_ptr<tus_transaction_ctx>& trans_ctx, const SceNpOnlineId& targetNpId, SceNpTusSlotId slotId, s64 inVariable, vm::ptr<SceNpTusVariable> outVariable, vm::ptr<SceNpTusAddAndGetVariableOptParam> option, bool vuser, bool async);
void tus_try_and_set_variable(std::shared_ptr<tus_transaction_ctx>& trans_ctx, const SceNpOnlineId& targetNpId, SceNpTusSlotId slotId, s32 opeType, s64 variable, vm::ptr<SceNpTusVariable> resultVariable, vm::ptr<SceNpTusTryAndSetVariableOptParam> option, bool vuser, bool async);
void tus_delete_multislot_variable(std::shared_ptr<tus_transaction_ctx>& trans_ctx, const SceNpOnlineId& targetNpId, vm::cptr<SceNpTusSlotId> slotIdArray, s32 arrayNum, bool vuser, bool async);
void tus_set_data(std::shared_ptr<tus_transaction_ctx>& trans_ctx, const SceNpOnlineId& targetNpId, SceNpTusSlotId slotId, u32 totalSize, u32 sendSize, vm::cptr<void> data, vm::cptr<SceNpTusDataInfo> info, vm::ptr<SceNpTusSetDataOptParam> option, bool vuser, bool async);
void tus_get_data(std::shared_ptr<tus_transaction_ctx>& trans_ctx, const SceNpOnlineId& targetNpId, SceNpTusSlotId slotId, vm::ptr<SceNpTusDataStatus> dataStatus, vm::ptr<void> data, u32 recvSize, bool vuser, bool async);
void tus_get_multislot_data_status(std::shared_ptr<tus_transaction_ctx>& trans_ctx, const SceNpOnlineId& targetNpId, vm::cptr<SceNpTusSlotId> slotIdArray, vm::ptr<SceNpTusDataStatus> statusArray, s32 arrayNum, bool vuser, bool async);
void tus_get_multiuser_data_status(std::shared_ptr<tus_transaction_ctx>& trans_ctx, std::vector<SceNpOnlineId> targetNpIdArray, SceNpTusSlotId slotId, vm::ptr<SceNpTusDataStatus> statusArray, s32 arrayNum, bool vuser, bool async);
void tus_get_friends_data_status(std::shared_ptr<tus_transaction_ctx>& trans_ctx, SceNpTusSlotId slotId, s32 includeSelf, s32 sortType, vm::ptr<SceNpTusDataStatus> statusArray, s32 arrayNum, bool async);
void tus_delete_multislot_data(std::shared_ptr<tus_transaction_ctx>& trans_ctx, const SceNpOnlineId& targetNpId, vm::cptr<SceNpTusSlotId> slotIdArray, s32 arrayNum, bool vuser, bool async);
// Local functions
std::pair<error_code, std::optional<SceNpId>> local_get_npid(u64 room_id, u16 member_id);
std::pair<error_code, std::optional<SceNpMatching2RoomSlotInfo>> local_get_room_slots(SceNpMatching2RoomId room_id);
std::pair<error_code, std::optional<SceNpMatching2SessionPassword>> local_get_room_password(SceNpMatching2RoomId room_id);
std::pair<error_code, std::vector<SceNpMatching2RoomMemberId>> local_get_room_memberids(SceNpMatching2RoomId room_id, s32 sort_method);
error_code local_get_room_member_data(SceNpMatching2RoomId room_id, SceNpMatching2RoomMemberId member_id, const std::vector<SceNpMatching2AttributeId>& binattrs_list, SceNpMatching2RoomMemberDataInternal* ptr_member, u32 addr_data, u32 size_data, u32 ctx_id);
// Local GUI functions
error_code get_room_member_list_local_gui(u32 ctx_id, vm::ptr<SceNpRoomId> room_id, vm::ptr<u32> buflen, vm::ptr<void> buf);
// Friend stuff
u32 get_num_friends();
u32 get_num_blocks();
std::pair<error_code, std::optional<SceNpId>> get_friend_by_index(u32 index);
void set_presence(std::optional<std::string> status, std::optional<std::vector<u8>> data);
template <typename T>
error_code get_friend_presence_by_index(u32 index, SceNpUserInfo* user, T* pres);
template <typename T>
error_code get_friend_presence_by_npid(const SceNpId& npid, T* pres);
// Misc stuff
void req_ticket(u32 version, const SceNpId* npid, const char* service_id, const u8* cookie, u32 cookie_size, const char* entitlement_id, u32 consumed_count);
const ticket& get_ticket() const;
void add_player_to_history(const SceNpId* npid, const char* description);
u32 add_players_to_history(const SceNpId* npids, const char* description, u32 count);
u32 get_players_history_count(u32 options);
bool get_player_history_entry(u32 options, u32 index, SceNpId* npid);
bool abort_request(u32 req_id);
// For signaling
void req_sign_infos(const std::string& npid, u32 conn_id);
// For UPNP
void upnp_add_port_mapping(u16 internal_port, std::string_view protocol);
void upnp_remove_port_mapping(u16 internal_port, std::string_view protocol);
// For custom menu
struct custom_menu_action
{
s32 id = 0;
u32 mask = SCE_NP_CUSTOM_MENU_ACTION_MASK_ME;
std::string name;
};
shared_mutex mutex_custom_menu;
bool custom_menu_registered = false;
vm::ptr<SceNpCustomMenuEventHandler> custom_menu_handler{};
vm::ptr<void> custom_menu_user_arg{};
std::vector<custom_menu_action> custom_menu_actions;
SceNpCustomMenuIndexArray custom_menu_activation{};
std::vector<SceNpCustomMenuActionExceptions> custom_menu_exception_list{};
// Mutex for NP status change
shared_mutex mutex_status;
static constexpr std::string_view thread_name = "NP Handler Thread";
private:
// Various generic helpers
bool discover_ip_address();
bool discover_ether_address();
bool error_and_disconnect(const std::string& error_msg);
// Notification handlers
void notif_user_joined_room(std::vector<u8>& data);
void notif_user_left_room(std::vector<u8>& data);
void notif_room_destroyed(std::vector<u8>& data);
void notif_updated_room_data_internal(std::vector<u8>& data);
void notif_updated_room_member_data_internal(std::vector<u8>& data);
void notif_p2p_connect(std::vector<u8>& data);
void notif_signaling_info(std::vector<u8>& data);
void notif_room_message_received(std::vector<u8>& data);
void generic_gui_notification_handler(std::vector<u8>& data, std::string_view name, s32 notification_type);
void notif_member_joined_room_gui(std::vector<u8>& data);
void notif_member_left_room_gui(std::vector<u8>& data);
void notif_room_disappeared_gui(std::vector<u8>& data);
void notif_room_owner_changed_gui(std::vector<u8>& data);
void notif_user_kicked_gui(std::vector<u8>& data);
void notif_quickmatch_complete_gui(std::vector<u8>& data);
// Reply handlers
bool reply_get_world_list(u32 req_id, std::vector<u8>& reply_data);
bool reply_create_join_room(u32 req_id, std::vector<u8>& reply_data);
bool reply_join_room(u32 req_id, std::vector<u8>& reply_data);
bool reply_leave_room(u32 req_id, std::vector<u8>& reply_data);
bool reply_search_room(u32 req_id, std::vector<u8>& reply_data);
bool reply_get_roomdata_external_list(u32 req_id, std::vector<u8>& reply_data);
bool reply_set_roomdata_external(u32 req_id, std::vector<u8>& reply_data);
bool reply_get_roomdata_internal(u32 req_id, std::vector<u8>& reply_data);
bool reply_set_roomdata_internal(u32 req_id, std::vector<u8>& reply_data);
bool reply_set_roommemberdata_internal(u32 req_id, std::vector<u8>& reply_data);
bool reply_get_roommemberdata_internal(u32 req_id, std::vector<u8>& reply_data);
bool reply_set_userinfo(u32 req_id, std::vector<u8>& reply_data);
bool reply_get_ping_info(u32 req_id, std::vector<u8>& reply_data);
bool reply_send_room_message(u32 req_id, std::vector<u8>& reply_data);
bool reply_req_sign_infos(u32 req_id, std::vector<u8>& reply_data);
bool reply_req_ticket(u32 req_id, std::vector<u8>& reply_data);
bool reply_get_board_infos(u32 req_id, std::vector<u8>& reply_data);
bool reply_record_score(u32 req_id, std::vector<u8>& reply_data);
bool reply_record_score_data(u32 req_id, std::vector<u8>& reply_data);
bool reply_get_score_data(u32 req_id, std::vector<u8>& reply_data);
bool reply_get_score_range(u32 req_id, std::vector<u8>& reply_data);
bool reply_get_score_friends(u32 req_id, std::vector<u8>& reply_data);
bool reply_get_score_npid(u32 req_id, std::vector<u8>& reply_data);
bool reply_tus_set_multislot_variable(u32 req_id, std::vector<u8>& reply_data);
bool reply_tus_get_multislot_variable(u32 req_id, std::vector<u8>& reply_data);
bool reply_tus_get_multiuser_variable(u32 req_id, std::vector<u8>& reply_data);
bool reply_tus_get_friends_variable(u32 req_id, std::vector<u8>& reply_data);
bool reply_tus_add_and_get_variable(u32 req_id, std::vector<u8>& reply_data);
bool reply_tus_try_and_set_variable(u32 req_id, std::vector<u8>& reply_data);
bool reply_tus_delete_multislot_variable(u32 req_id, std::vector<u8>& reply_data);
bool reply_tus_set_data(u32 req_id, std::vector<u8>& reply_data);
bool reply_tus_get_data(u32 req_id, std::vector<u8>& reply_data);
bool reply_tus_get_multislot_data_status(u32 req_id, std::vector<u8>& reply_data);
bool reply_tus_get_multiuser_data_status(u32 req_id, std::vector<u8>& reply_data);
bool reply_tus_get_friends_data_status(u32 req_id, std::vector<u8>& reply_data);
bool reply_tus_delete_multislot_data(u32 req_id, std::vector<u8>& reply_data);
bool reply_create_room_gui(u32 req_id, std::vector<u8>& reply_data);
bool reply_join_room_gui(u32 req_id, std::vector<u8>& reply_data);
bool reply_leave_room_gui(u32 req_id, std::vector<u8>& reply_data);
bool reply_get_room_list_gui(u32 req_id, std::vector<u8>& reply_data);
bool reply_set_room_search_flag_gui(u32 req_id, std::vector<u8>& reply_data);
bool reply_get_room_search_flag_gui(u32 req_id, std::vector<u8>& reply_data);
bool reply_set_room_info_gui(u32 req_id, std::vector<u8>& reply_data);
bool reply_get_room_info_gui(u32 req_id, std::vector<u8>& reply_data);
bool reply_quickmatch_gui(u32 req_id, std::vector<u8>& reply_data);
bool reply_searchjoin_gui(u32 req_id, std::vector<u8>& reply_data);
// Helper functions
std::pair<bool, bool> get_match2_context_options(u32 ctx_id);
bool handle_GetScoreResponse(u32 req_id, std::vector<u8>& reply_data, bool simple_result = false);
bool handle_tus_no_data(u32 req_id, std::vector<u8>& reply_data);
bool handle_TusVarResponse(u32 req_id, std::vector<u8>& reply_data);
bool handle_TusVariable(u32 req_id, std::vector<u8>& reply_data);
bool handle_TusDataStatusResponse(u32 req_id, std::vector<u8>& reply_data);
struct callback_info
{
SceNpMatching2ContextId ctx_id;
vm::ptr<SceNpMatching2RequestCallback> cb;
vm::ptr<void> cb_arg;
SceNpMatching2Event event_type;
void queue_callback(u32 req_id, u32 event_key, s32 error_code, u32 data_size) const
{
if (cb)
{
sysutil_register_cb([=, ctx_id = this->ctx_id, event_type = this->event_type, cb = this->cb, cb_arg = this->cb_arg](ppu_thread& cb_ppu) -> s32
{
cb(cb_ppu, ctx_id, req_id, event_type, event_key, error_code, data_size, cb_arg);
return 0;
});
}
}
};
u32 generate_callback_info(SceNpMatching2ContextId ctx_id, vm::cptr<SceNpMatching2RequestOptParam> optParam, SceNpMatching2Event event_type);
std::optional<callback_info> take_pending_request(u32 req_id);
private:
shared_mutex mutex_pending_requests;
std::unordered_map<u32, callback_info> pending_requests;
shared_mutex mutex_pending_sign_infos_requests;
std::unordered_map<u32, u32> pending_sign_infos_requests;
shared_mutex mutex_queue_basic_events;
std::queue<basic_event> queue_basic_events;
bool m_inited_np_handler_dependencies = false;
// Basic event handler;
struct
{
shared_mutex mutex;
SceNpCommunicationId context{};
vm::ptr<SceNpBasicEventHandler> handler_func;
vm::ptr<void> handler_arg;
bool context_sensitive = false;
} basic_handler;
bool is_connected = false;
bool is_psn_active = false;
ticket current_ticket;
// IP & DNS info
std::string hostname = "localhost";
std::array<u8, 6> ether_address{};
be_t<u32> local_ip_addr{};
be_t<u32> public_ip_addr{};
be_t<u32> dns_ip = 0x08080808;
be_t<u32> bind_ip = 0x00000000;
// User infos
SceNpId npid{};
SceNpOnlineName online_name{};
SceNpAvatarUrl avatar_url{};
// Memory pool for sceNp/sceNp2
memory_allocator np_memory;
// Cache related
std::optional<SceNpMatching2SessionPassword> cached_cj_password;
cache_manager np_cache;
gui_cache_manager gui_cache;
// Messages related
std::optional<u64> selected_invite_id{};
std::optional<u64> selected_message_id{};
// Misc
s64 network_time_offset = 0;
// Requests(reqEventKey : data)
shared_mutex mutex_match2_req_results;
std::unordered_map<u32, event_data> match2_req_results;
atomic_t<u16> match2_low_reqid_cnt = 1;
atomic_t<u32> match2_event_cnt = 1;
u32 get_req_id(u16 app_req)
{
return ((app_req << 16) | match2_low_reqid_cnt.fetch_add(1));
}
u32 get_req_id(REQUEST_ID_HIGH int_req)
{
return ((static_cast<u16>(int_req) << 16) | match2_low_reqid_cnt.fetch_add(1));
}
u32 get_event_key()
{
return match2_event_cnt.fetch_add(1);
}
event_data& allocate_req_result(u32 event_key, u32 max_size, u32 initial_size);
// GUI result
struct
{
shared_mutex mutex;
s32 event = 0;
event_data data;
} gui_result;
void set_gui_result(s32 event, event_data data);
// GUI notifications
struct gui_notification
{
s32 event = 0;
event_data edata;
};
struct
{
shared_mutex mutex;
std::map<std::pair<u32, u32>, gui_notification> list; // (ctx_id, req_id), notif
u32 counter_req_id = 1;
u32 current_gui_ctx_id = 0;
} gui_notifications;
// Async transaction threads
shared_mutex mutex_async_transactions;
std::unordered_map<u32, std::shared_ptr<generic_async_transaction_context>> async_transactions; // (req_id, transaction_ctx)
// RPCN
shared_mutex mutex_rpcn;
std::shared_ptr<rpcn::rpcn_client> rpcn;
std::shared_ptr<rpcn::rpcn_client> get_rpcn();
// UPNP
upnp_handler upnp;
// Presence
struct
{
SceNpCommunicationId pr_com_id;
std::string pr_title;
std::string pr_status;
std::string pr_comment;
std::vector<u8> pr_data;
} presence_self;
player_history& get_player_and_set_timestamp(const SceNpId& npid, u64 timestamp);
void save_players_history();
shared_mutex mutex_history;
std::map<std::string, player_history> players_history; // npid / history
struct
{
shared_mutex mutex;
std::map<u32, u32> list; // req_id / ctx_id
} gui_requests;
void add_gui_request(u32 req_id, u32 ctx_id);
void remove_gui_request(u32 req_id);
u32 take_gui_request(u32 req_id);
std::shared_ptr<matching_ctx> take_pending_gui_request(u32 req_id);
shared_mutex mutex_quickmatching;
std::map<SceNpRoomId, u32> pending_quickmatching;
};
} // namespace np
| 27,766
|
C++
|
.h
| 454
| 58
| 446
| 0.757428
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,249
|
upnp_handler.h
|
RPCS3_rpcs3/rpcs3/Emu/NP/upnp_handler.h
|
#pragma once
#include <unordered_map>
#include <miniupnpc.h>
#include "upnp_config.h"
#include "Utilities/mutex.h"
class upnp_handler
{
public:
~upnp_handler();
void upnp_enable();
void add_port_redir(std::string_view addr, u16 internal_port, std::string_view protocol);
void remove_port_redir(u16 internal_port, std::string_view protocol);
bool is_active() const;
private:
void remove_port_redir_external(u16 external_port, std::string_view protocol, bool verbose = true);
private:
atomic_t<bool> m_active = false;
shared_mutex m_mutex;
cfg_upnp m_cfg;
IGDdatas m_igd_data{};
UPNPUrls m_igd_urls{};
std::unordered_map<std::string, std::unordered_map<u16, u16>> m_bindings;
};
| 698
|
C++
|
.h
| 23
| 28.434783
| 100
| 0.755255
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,250
|
np_contexts.h
|
RPCS3_rpcs3/rpcs3/Emu/NP/np_contexts.h
|
#pragma once
#include <optional>
#include <condition_variable>
#include <thread>
#include <variant>
#include <queue>
#include "Utilities/mutex.h"
#include "Emu/IdManager.h"
#include "Emu/Memory/vm_ptr.h"
#include "Emu/Cell/Modules/sceNp.h"
#include "Emu/Cell/Modules/sceNp2.h"
#include "Emu/Cell/Modules/sceNpCommerce2.h"
#include "Emu/Cell/Modules/sceNpTus.h"
#include "Emu/NP/np_event_data.h"
#include "Utilities/Thread.h"
// Used By Score and Tus
struct generic_async_transaction_context
{
virtual ~generic_async_transaction_context();
generic_async_transaction_context(const SceNpCommunicationId& communicationId, const SceNpCommunicationPassphrase& passphrase, u64 timeout);
std::optional<s32> get_transaction_status();
void abort_transaction();
error_code wait_for_completion();
bool set_result_and_wake(error_code err);
shared_mutex mutex;
std::condition_variable_any wake_cond, completion_cond;
std::optional<error_code> result;
SceNpCommunicationId communicationId;
SceNpCommunicationPassphrase passphrase;
u64 timeout;
std::thread thread;
};
struct tdata_invalid
{
};
// Score transaction data
struct tdata_get_board_infos
{
vm::ptr<SceNpScoreBoardInfo> boardInfo;
};
struct tdata_record_score
{
vm::ptr<SceNpScoreRankNumber> tmpRank;
};
struct tdata_record_score_data
{
u32 game_data_size = 0;
std::vector<u8> game_data;
};
struct tdata_get_score_data
{
vm::ptr<u32> totalSize;
u32 recvSize = 0;
vm::ptr<void> score_data;
u32 game_data_size = 0;
std::vector<u8> game_data;
};
struct tdata_get_score_generic
{
vm::ptr<void> rankArray;
u32 rankArraySize = 0;
vm::ptr<SceNpScoreComment> commentArray;
vm::ptr<void> infoArray;
u32 infoArraySize = 0;
u32 arrayNum = 0;
vm::ptr<CellRtcTick> lastSortDate;
vm::ptr<SceNpScoreRankNumber> totalRecord;
bool player_rank_data = false;
bool deprecated = false;
};
// TUS transaction data
struct tdata_tus_get_variables_generic
{
vm::ptr<SceNpTusVariable> variableArray;
s32 arrayNum;
};
struct tdata_tus_get_variable_generic
{
vm::ptr<SceNpTusVariable> outVariable;
};
struct tdata_tus_set_data
{
u32 tus_data_size;
std::vector<u8> tus_data;
};
struct tdata_tus_get_data
{
u32 recvSize = 0;
vm::ptr<SceNpTusDataStatus> dataStatus;
vm::ptr<void> data;
std::vector<u8> tus_data;
};
struct tdata_tus_get_datastatus_generic
{
vm::ptr<SceNpTusDataStatus> statusArray;
s32 arrayNum;
};
// TUS related
struct tus_ctx
{
tus_ctx(vm::cptr<SceNpCommunicationId> communicationId, vm::cptr<SceNpCommunicationPassphrase> passphrase);
static const u32 id_base = 0x7001;
static const u32 id_step = 1;
static const u32 id_count = SCE_NP_TUS_MAX_CTX_NUM;
SAVESTATE_INIT_POS(50);
shared_mutex mutex;
u64 timeout = 60'000'000; // 60 seconds
SceNpCommunicationId communicationId{};
SceNpCommunicationPassphrase passphrase{};
};
s32 create_tus_context(vm::cptr<SceNpCommunicationId> communicationId, vm::cptr<SceNpCommunicationPassphrase> passphrase);
bool destroy_tus_context(s32 ctx_id);
struct tus_transaction_ctx : public generic_async_transaction_context
{
tus_transaction_ctx(const std::shared_ptr<tus_ctx>& tus);
virtual ~tus_transaction_ctx() = default;
static const u32 id_base = 0x8001;
static const u32 id_step = 1;
static const u32 id_count = SCE_NP_TUS_MAX_CTX_NUM;
SAVESTATE_INIT_POS(51);
std::variant<tdata_invalid, tdata_tus_get_variables_generic, tdata_tus_get_variable_generic, tdata_tus_set_data, tdata_tus_get_data, tdata_tus_get_datastatus_generic> tdata;
};
s32 create_tus_transaction_context(const std::shared_ptr<tus_ctx>& tus);
bool destroy_tus_transaction_context(s32 ctx_id);
// Score related
struct score_ctx
{
score_ctx(vm::cptr<SceNpCommunicationId> communicationId, vm::cptr<SceNpCommunicationPassphrase> passphrase);
static const u32 id_base = 0x2001;
static const u32 id_step = 1;
static const u32 id_count = SCE_NP_SCORE_MAX_CTX_NUM;
SAVESTATE_INIT_POS(25);
shared_mutex mutex;
u64 timeout = 60'000'000; // 60 seconds
SceNpCommunicationId communicationId{};
SceNpCommunicationPassphrase passphrase{};
s32 pcId = 0;
};
s32 create_score_context(vm::cptr<SceNpCommunicationId> communicationId, vm::cptr<SceNpCommunicationPassphrase> passphrase);
bool destroy_score_context(s32 ctx_id);
struct score_transaction_ctx : public generic_async_transaction_context
{
score_transaction_ctx(const std::shared_ptr<score_ctx>& score);
virtual ~score_transaction_ctx() = default;
static const u32 id_base = 0x1001;
static const u32 id_step = 1;
static const u32 id_count = SCE_NP_SCORE_MAX_CTX_NUM;
SAVESTATE_INIT_POS(26);
std::variant<tdata_invalid, tdata_get_board_infos, tdata_record_score, tdata_record_score_data, tdata_get_score_data, tdata_get_score_generic> tdata;
s32 pcId = 0;
};
s32 create_score_transaction_context(const std::shared_ptr<score_ctx>& score);
bool destroy_score_transaction_context(s32 ctx_id);
// Match2 related
struct match2_ctx
{
match2_ctx(vm::cptr<SceNpCommunicationId> communicationId, vm::cptr<SceNpCommunicationPassphrase> passphrase, s32 option);
static const u32 id_base = 1;
static const u32 id_step = 1;
static const u32 id_count = 255; // TODO: constant here?
SAVESTATE_INIT_POS(27);
atomic_t<u32> started = 0;
shared_mutex mutex;
SceNpCommunicationId communicationId{};
SceNpCommunicationPassphrase passphrase{};
bool include_onlinename = false, include_avatarurl = false;
vm::ptr<SceNpMatching2ContextCallback> context_callback{};
vm::ptr<void> context_callback_param{};
SceNpMatching2RequestOptParam default_match2_optparam{};
vm::ptr<SceNpMatching2SignalingCallback> signaling_cb{};
vm::ptr<void> signaling_cb_arg{};
};
u16 create_match2_context(vm::cptr<SceNpCommunicationId> communicationId, vm::cptr<SceNpCommunicationPassphrase> passphrase, s32 option);
bool check_match2_context(u16 ctx_id);
std::shared_ptr<match2_ctx> get_match2_context(u16 ctx_id);
bool destroy_match2_context(u16 ctx_id);
struct lookup_title_ctx
{
lookup_title_ctx(vm::cptr<SceNpCommunicationId> communicationId);
static const u32 id_base = 0x3001;
static const u32 id_step = 1;
static const u32 id_count = SCE_NP_LOOKUP_MAX_CTX_NUM;
SAVESTATE_INIT_POS(28);
SceNpCommunicationId communicationId{};
SceNpCommunicationPassphrase passphrase{};
};
s32 create_lookup_title_context(vm::cptr<SceNpCommunicationId> communicationId);
bool destroy_lookup_title_context(s32 ctx_id);
struct lookup_transaction_ctx
{
lookup_transaction_ctx(s32 lt_ctx);
static const u32 id_base = 0x4001;
static const u32 id_step = 1;
static const u32 id_count = SCE_NP_LOOKUP_MAX_CTX_NUM;
SAVESTATE_INIT_POS(29);
s32 lt_ctx = 0;
};
s32 create_lookup_transaction_context(s32 lt_ctx);
bool destroy_lookup_transaction_context(s32 ctx_id);
struct commerce2_ctx
{
commerce2_ctx(u32 version, vm::cptr<SceNpId> npid, vm::ptr<SceNpCommerce2Handler> handler, vm::ptr<void> arg);
static const u32 id_base = 0x5001;
static const u32 id_step = 1;
static const u32 id_count = SCE_NP_COMMERCE2_CTX_MAX;
SAVESTATE_INIT_POS(30);
u32 version{};
SceNpId npid{};
vm::ptr<SceNpCommerce2Handler> context_callback{};
vm::ptr<void> context_callback_param{};
};
s32 create_commerce2_context(u32 version, vm::cptr<SceNpId> npid, vm::ptr<SceNpCommerce2Handler> handler, vm::ptr<void> arg);
std::shared_ptr<commerce2_ctx> get_commerce2_context(u16 ctx_id);
bool destroy_commerce2_context(u32 ctx_id);
struct signaling_ctx
{
signaling_ctx(vm::ptr<SceNpId> npid, vm::ptr<SceNpSignalingHandler> handler, vm::ptr<void> arg);
static const u32 id_base = 0x6001;
static const u32 id_step = 1;
static const u32 id_count = SCE_NP_SIGNALING_CTX_MAX;
SAVESTATE_INIT_POS(31);
shared_mutex mutex;
SceNpId npid{};
vm::ptr<SceNpSignalingHandler> handler{};
vm::ptr<void> arg{};
vm::ptr<SceNpSignalingHandler> ext_handler{};
vm::ptr<void> ext_arg{};
};
s32 create_signaling_context(vm::ptr<SceNpId> npid, vm::ptr<SceNpSignalingHandler> handler, vm::ptr<void> arg);
std::shared_ptr<signaling_ctx> get_signaling_context(u32 ctx_id);
bool destroy_signaling_context(u32 ctx_id);
struct matching_ctx
{
matching_ctx(vm::ptr<SceNpId> npid, vm::ptr<SceNpMatchingHandler> handler, vm::ptr<void> arg);
void queue_callback(u32 req_id, s32 event, s32 error_code);
void queue_gui_callback(s32 event, s32 error_code);
static const u32 id_base = 0x9001;
static const u32 id_step = 1;
static const u32 id_count = 1;
SAVESTATE_INIT_POS(32);
SceNpId npid{};
vm::ptr<SceNpMatchingHandler> handler{};
vm::ptr<void> arg{};
atomic_t<u32> busy = 0;
u32 ctx_id = 0;
vm::ptr<SceNpMatchingGUIHandler> gui_handler{};
vm::ptr<void> gui_arg{};
// Used by QuickMatchGUI
u64 timeout = 0;
std::unique_ptr<named_thread<std::function<void(SceNpRoomId)>>> thread;
atomic_t<u32> wakey = 0;
// To keep track of which callback to use for sceNpMatchingGetRoomListWithoutGUI / sceNpMatchingGetRoomListGUI / sceNpMatchingGetRoomListLimitGUI
atomic_t<bool> get_room_limit_version = false;
};
s32 create_matching_context(vm::ptr<SceNpId> npid, vm::ptr<SceNpMatchingHandler> handler, vm::ptr<void> arg);
std::shared_ptr<matching_ctx> get_matching_context(u32 ctx_id);
bool destroy_matching_context(u32 ctx_id);
| 9,182
|
C++
|
.h
| 257
| 33.922179
| 174
| 0.77784
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,251
|
vport0.h
|
RPCS3_rpcs3/rpcs3/Emu/NP/vport0.h
|
#pragma once
#include <vector>
#ifdef _WIN32
#include <winsock2.h>
#else
#include <netinet/in.h>
#endif
#include "Emu/Cell/lv2/sys_net/nt_p2p_port.h"
s32 send_packet_from_p2p_port(const std::vector<u8>& data, const sockaddr_in& addr);
std::vector<signaling_message> get_sign_msgs();
std::vector<std::vector<u8>> get_rpcn_msgs();
constexpr s32 VPORT_0_HEADER_SIZE = sizeof(u16) + sizeof(u8);
// VPort 0 is invalid for sys_net so we use it for:
// Subset 0: Messages from RPCN server, IP retrieval / UDP hole punching
// Subset 1: Signaling
enum VPORT_0_SUBSET : u8
{
SUBSET_RPCN = 0,
SUBSET_SIGNALING = 1,
};
| 621
|
C++
|
.h
| 20
| 29.65
| 84
| 0.731092
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,252
|
signaling_handler.h
|
RPCS3_rpcs3/rpcs3/Emu/NP/signaling_handler.h
|
#pragma once
#include "Emu/Memory/vm.h"
#include "Emu/Memory/vm_ptr.h"
#include "Emu/Cell/Modules/sceNp.h"
#include "Emu/Cell/Modules/sceNp2.h"
#include "Utilities/Thread.h"
#include <unordered_map>
#include <chrono>
#include <optional>
struct signaling_info
{
s32 conn_status = SCE_NP_SIGNALING_CONN_STATUS_INACTIVE;
u32 addr = 0;
u16 port = 0;
// User seen from that peer
u32 mapped_addr = 0;
u16 mapped_port = 0;
// For handler
steady_clock::time_point time_last_msg_recvd = steady_clock::now();
bool self = false;
SceNpId npid{};
// Signaling
u32 conn_id = 0;
bool op_activated = false;
u32 info_counter = 10;
// Matching2
u64 room_id = 0;
u16 member_id = 0;
// Stats
u64 last_rtts[6] = {};
usz rtt_counters = 0;
u32 rtt = 0;
u32 pings_sent = 1, lost_pings = 0;
u32 packet_loss = 0;
};
enum SignalingCommand : u32
{
signal_ping,
signal_pong,
signal_connect,
signal_connect_ack,
signal_confirm,
signal_finished,
signal_finished_ack,
signal_info,
};
class signaling_handler
{
public:
signaling_handler();
void operator()();
void wake_up();
signaling_handler& operator=(thread_state);
void set_self_sig_info(SceNpId& npid);
u32 init_sig1(const SceNpId& npid);
u32 init_sig2(const SceNpId& npid, u64 room_id, u16 member_id);
std::optional<signaling_info> get_sig_infos(u32 conn_id);
std::optional<u32> get_conn_id_from_npid(const SceNpId& npid);
std::optional<u32> get_conn_id_from_addr(u32 addr, u16 port);
void add_sig_ctx(u32 ctx_id);
void remove_sig_ctx(u32 ctx_id);
void clear_sig_ctx();
void add_match2_ctx(u16 ctx_id);
void remove_match2_ctx(u16 ctx_id);
void clear_match2_ctx();
void start_sig(u32 conn_id, u32 addr, u16 port);
void stop_sig(u32 conn_id, bool forceful);
void send_information_packets(u32 addr, u16 port, const SceNpId& npid);
void disconnect_sig2_users(u64 room_id);
static constexpr auto thread_name = "Signaling Manager Thread"sv;
private:
static constexpr auto REPEAT_CONNECT_DELAY = std::chrono::milliseconds(200);
static constexpr auto REPEAT_PING_DELAY = std::chrono::milliseconds(500);
static constexpr auto REPEAT_FINISHED_DELAY = std::chrono::milliseconds(500);
static constexpr auto REPEAT_INFO_DELAY = std::chrono::milliseconds(200);
static constexpr be_t<u32> SIGNALING_SIGNATURE = (static_cast<u32>('S') << 24 | static_cast<u32>('I') << 16 | static_cast<u32>('G') << 8 | static_cast<u32>('N'));
static constexpr le_t<u32> SIGNALING_VERSION = 3;
struct signaling_packet
{
be_t<u32> signature = SIGNALING_SIGNATURE;
le_t<u32> version = SIGNALING_VERSION;
le_t<u64> timestamp_sender;
le_t<u64> timestamp_receiver;
le_t<SignalingCommand> command;
le_t<u32> sent_addr;
le_t<u16> sent_port;
SceNpId npid;
};
struct queued_packet
{
signaling_packet packet{};
std::shared_ptr<signaling_info> sig_info;
};
std::set<u32> sig_ctx_lst;
std::set<u16> match2_ctx_lst;
static u64 get_micro_timestamp(const std::chrono::steady_clock::time_point& time_point);
u32 get_always_conn_id(const SceNpId& npid);
static void update_si_addr(std::shared_ptr<signaling_info>& si, u32 new_addr, u16 new_port);
static void update_si_mapped_addr(std::shared_ptr<signaling_info>& si, u32 new_addr, u16 new_port);
void update_si_status(std::shared_ptr<signaling_info>& si, s32 new_status, s32 error_code);
void update_ext_si_status(std::shared_ptr<signaling_info>& si, bool op_activated);
void signal_sig_callback(u32 conn_id, s32 event, s32 error_code);
void signal_ext_sig_callback(u32 conn_id, s32 event, s32 error_code) const;
void signal_sig2_callback(u64 room_id, u16 member_id, SceNpMatching2Event event, s32 error_code) const;
static bool validate_signaling_packet(const signaling_packet* sp);
void reschedule_packet(std::shared_ptr<signaling_info>& si, SignalingCommand cmd, steady_clock::time_point new_timepoint);
void retire_packet(std::shared_ptr<signaling_info>& si, SignalingCommand cmd);
void retire_all_packets(std::shared_ptr<signaling_info>& si);
void stop_sig_nl(u32 conn_id, bool forceful);
shared_mutex data_mutex;
atomic_t<u32> wakey = 0;
signaling_packet sig_packet{};
std::map<steady_clock::time_point, queued_packet> qpackets; // (wakeup time, packet)
u32 cur_conn_id = 1;
std::unordered_map<std::string, u32> npid_to_conn_id; // (npid, conn_id)
std::unordered_map<u32, std::shared_ptr<signaling_info>> sig_peers; // (conn_id, sig_info)
void process_incoming_messages();
std::shared_ptr<signaling_info> get_signaling_ptr(const signaling_packet* sp);
void send_signaling_packet(signaling_packet& sp, u32 addr, u16 port) const;
void queue_signaling_packet(signaling_packet& sp, std::shared_ptr<signaling_info> si, steady_clock::time_point wakeup_time);
};
| 4,736
|
C++
|
.h
| 121
| 37.008264
| 163
| 0.740466
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,253
|
np2_structs_generated.h
|
RPCS3_rpcs3/rpcs3/Emu/NP/generated/np2_structs_generated.h
|
// automatically generated by the FlatBuffers compiler, do not modify
#ifndef FLATBUFFERS_GENERATED_NP2STRUCTS_H_
#define FLATBUFFERS_GENERATED_NP2STRUCTS_H_
#include "flatbuffers/flatbuffers.h"
// Ensure the included flatbuffers.h is the same version as when this file was
// generated, otherwise it may not be compatible.
static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
FLATBUFFERS_VERSION_MINOR == 3 &&
FLATBUFFERS_VERSION_REVISION == 25,
"Non-compatible flatbuffers version included");
struct BinAttr;
struct BinAttrBuilder;
struct IntAttr;
struct IntAttrBuilder;
struct RoomMemberBinAttrInternal;
struct RoomMemberBinAttrInternalBuilder;
struct BinAttrInternal;
struct BinAttrInternalBuilder;
struct OptParam;
struct OptParamBuilder;
struct GroupConfig;
struct GroupConfigBuilder;
struct UserInfo;
struct UserInfoBuilder;
struct RoomMemberDataInternal;
struct RoomMemberDataInternalBuilder;
struct RoomGroup;
struct RoomGroupBuilder;
struct RoomDataInternal;
struct RoomDataInternalBuilder;
struct RoomDataExternal;
struct RoomDataExternalBuilder;
struct IntSearchFilter;
struct IntSearchFilterBuilder;
struct BinSearchFilter;
struct BinSearchFilterBuilder;
struct PresenceOptionData;
struct PresenceOptionDataBuilder;
struct RoomGroupPasswordConfig;
struct RoomGroupPasswordConfigBuilder;
struct SearchRoomRequest;
struct SearchRoomRequestBuilder;
struct SearchRoomResponse;
struct SearchRoomResponseBuilder;
struct CreateJoinRoomRequest;
struct CreateJoinRoomRequestBuilder;
struct JoinRoomRequest;
struct JoinRoomRequestBuilder;
struct LeaveRoomRequest;
struct LeaveRoomRequestBuilder;
struct GetRoomDataExternalListRequest;
struct GetRoomDataExternalListRequestBuilder;
struct GetRoomDataExternalListResponse;
struct GetRoomDataExternalListResponseBuilder;
struct SetRoomDataExternalRequest;
struct SetRoomDataExternalRequestBuilder;
struct SetRoomDataInternalRequest;
struct SetRoomDataInternalRequestBuilder;
struct GetRoomMemberDataInternalRequest;
struct GetRoomMemberDataInternalRequestBuilder;
struct SetRoomMemberDataInternalRequest;
struct SetRoomMemberDataInternalRequestBuilder;
struct SetUserInfo;
struct SetUserInfoBuilder;
struct GetRoomDataInternalRequest;
struct GetRoomDataInternalRequestBuilder;
struct RoomMemberUpdateInfo;
struct RoomMemberUpdateInfoBuilder;
struct RoomUpdateInfo;
struct RoomUpdateInfoBuilder;
struct RoomDataInternalUpdateInfo;
struct RoomDataInternalUpdateInfoBuilder;
struct RoomMemberDataInternalUpdateInfo;
struct RoomMemberDataInternalUpdateInfoBuilder;
struct GetPingInfoResponse;
struct GetPingInfoResponseBuilder;
struct SendRoomMessageRequest;
struct SendRoomMessageRequestBuilder;
struct RoomMessageInfo;
struct RoomMessageInfoBuilder;
struct MessageDetails;
struct MessageDetailsBuilder;
struct SendMessageRequest;
struct SendMessageRequestBuilder;
struct BoardInfo;
struct BoardInfoBuilder;
struct RecordScoreRequest;
struct RecordScoreRequestBuilder;
struct GetScoreRangeRequest;
struct GetScoreRangeRequestBuilder;
struct ScoreNpIdPcId;
struct ScoreNpIdPcIdBuilder;
struct GetScoreNpIdRequest;
struct GetScoreNpIdRequestBuilder;
struct GetScoreFriendsRequest;
struct GetScoreFriendsRequestBuilder;
struct ScoreRankData;
struct ScoreRankDataBuilder;
struct ScoreInfo;
struct ScoreInfoBuilder;
struct GetScoreResponse;
struct GetScoreResponseBuilder;
struct RecordScoreGameDataRequest;
struct RecordScoreGameDataRequestBuilder;
struct GetScoreGameDataRequest;
struct GetScoreGameDataRequestBuilder;
struct TusUser;
struct TusUserBuilder;
struct TusVariable;
struct TusVariableBuilder;
struct TusVarResponse;
struct TusVarResponseBuilder;
struct TusSetMultiSlotVariableRequest;
struct TusSetMultiSlotVariableRequestBuilder;
struct TusGetMultiSlotVariableRequest;
struct TusGetMultiSlotVariableRequestBuilder;
struct TusGetMultiUserVariableRequest;
struct TusGetMultiUserVariableRequestBuilder;
struct TusGetFriendsVariableRequest;
struct TusGetFriendsVariableRequestBuilder;
struct TusAddAndGetVariableRequest;
struct TusAddAndGetVariableRequestBuilder;
struct TusTryAndSetVariableRequest;
struct TusTryAndSetVariableRequestBuilder;
struct TusDeleteMultiSlotVariableRequest;
struct TusDeleteMultiSlotVariableRequestBuilder;
struct TusSetDataRequest;
struct TusSetDataRequestBuilder;
struct TusDataStatus;
struct TusDataStatusBuilder;
struct TusData;
struct TusDataBuilder;
struct TusDataStatusResponse;
struct TusDataStatusResponseBuilder;
struct TusGetDataRequest;
struct TusGetDataRequestBuilder;
struct TusGetMultiSlotDataStatusRequest;
struct TusGetMultiSlotDataStatusRequestBuilder;
struct TusGetMultiUserDataStatusRequest;
struct TusGetMultiUserDataStatusRequestBuilder;
struct TusGetFriendsDataStatusRequest;
struct TusGetFriendsDataStatusRequestBuilder;
struct TusDeleteMultiSlotDataRequest;
struct TusDeleteMultiSlotDataRequestBuilder;
struct SetPresenceRequest;
struct SetPresenceRequestBuilder;
struct MatchingSearchCondition;
struct MatchingSearchConditionBuilder;
struct MatchingAttr;
struct MatchingAttrBuilder;
struct CreateRoomGUIRequest;
struct CreateRoomGUIRequestBuilder;
struct GUIUserInfo;
struct GUIUserInfoBuilder;
struct MatchingRoomStatus;
struct MatchingRoomStatusBuilder;
struct GetRoomListGUIRequest;
struct GetRoomListGUIRequestBuilder;
struct MatchingRoom;
struct MatchingRoomBuilder;
struct MatchingRoomList;
struct MatchingRoomListBuilder;
struct MatchingGuiRoomId;
struct MatchingGuiRoomIdBuilder;
struct SetRoomSearchFlagGUI;
struct SetRoomSearchFlagGUIBuilder;
struct QuickMatchGUIRequest;
struct QuickMatchGUIRequestBuilder;
struct SearchJoinRoomGUIRequest;
struct SearchJoinRoomGUIRequestBuilder;
struct MatchingSearchJoinRoomInfo;
struct MatchingSearchJoinRoomInfoBuilder;
struct BinAttr FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef BinAttrBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ID = 4,
VT_DATA = 6
};
uint16_t id() const {
return GetField<uint16_t>(VT_ID, 0);
}
const ::flatbuffers::Vector<uint8_t> *data() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint16_t>(verifier, VT_ID, 2) &&
VerifyOffset(verifier, VT_DATA) &&
verifier.VerifyVector(data()) &&
verifier.EndTable();
}
};
struct BinAttrBuilder {
typedef BinAttr Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_id(uint16_t id) {
fbb_.AddElement<uint16_t>(BinAttr::VT_ID, id, 0);
}
void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
fbb_.AddOffset(BinAttr::VT_DATA, data);
}
explicit BinAttrBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<BinAttr> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<BinAttr>(end);
return o;
}
};
inline ::flatbuffers::Offset<BinAttr> CreateBinAttr(
::flatbuffers::FlatBufferBuilder &_fbb,
uint16_t id = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
BinAttrBuilder builder_(_fbb);
builder_.add_data(data);
builder_.add_id(id);
return builder_.Finish();
}
inline ::flatbuffers::Offset<BinAttr> CreateBinAttrDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint16_t id = 0,
const std::vector<uint8_t> *data = nullptr) {
auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
return CreateBinAttr(
_fbb,
id,
data__);
}
struct IntAttr FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef IntAttrBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ID = 4,
VT_NUM = 6
};
uint16_t id() const {
return GetField<uint16_t>(VT_ID, 0);
}
uint32_t num() const {
return GetField<uint32_t>(VT_NUM, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint16_t>(verifier, VT_ID, 2) &&
VerifyField<uint32_t>(verifier, VT_NUM, 4) &&
verifier.EndTable();
}
};
struct IntAttrBuilder {
typedef IntAttr Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_id(uint16_t id) {
fbb_.AddElement<uint16_t>(IntAttr::VT_ID, id, 0);
}
void add_num(uint32_t num) {
fbb_.AddElement<uint32_t>(IntAttr::VT_NUM, num, 0);
}
explicit IntAttrBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<IntAttr> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<IntAttr>(end);
return o;
}
};
inline ::flatbuffers::Offset<IntAttr> CreateIntAttr(
::flatbuffers::FlatBufferBuilder &_fbb,
uint16_t id = 0,
uint32_t num = 0) {
IntAttrBuilder builder_(_fbb);
builder_.add_num(num);
builder_.add_id(id);
return builder_.Finish();
}
struct RoomMemberBinAttrInternal FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef RoomMemberBinAttrInternalBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_UPDATEDATE = 4,
VT_DATA = 6
};
uint64_t updateDate() const {
return GetField<uint64_t>(VT_UPDATEDATE, 0);
}
const BinAttr *data() const {
return GetPointer<const BinAttr *>(VT_DATA);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_UPDATEDATE, 8) &&
VerifyOffset(verifier, VT_DATA) &&
verifier.VerifyTable(data()) &&
verifier.EndTable();
}
};
struct RoomMemberBinAttrInternalBuilder {
typedef RoomMemberBinAttrInternal Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_updateDate(uint64_t updateDate) {
fbb_.AddElement<uint64_t>(RoomMemberBinAttrInternal::VT_UPDATEDATE, updateDate, 0);
}
void add_data(::flatbuffers::Offset<BinAttr> data) {
fbb_.AddOffset(RoomMemberBinAttrInternal::VT_DATA, data);
}
explicit RoomMemberBinAttrInternalBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<RoomMemberBinAttrInternal> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<RoomMemberBinAttrInternal>(end);
return o;
}
};
inline ::flatbuffers::Offset<RoomMemberBinAttrInternal> CreateRoomMemberBinAttrInternal(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t updateDate = 0,
::flatbuffers::Offset<BinAttr> data = 0) {
RoomMemberBinAttrInternalBuilder builder_(_fbb);
builder_.add_updateDate(updateDate);
builder_.add_data(data);
return builder_.Finish();
}
struct BinAttrInternal FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef BinAttrInternalBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_UPDATEDATE = 4,
VT_UPDATEMEMBERID = 6,
VT_DATA = 8
};
uint64_t updateDate() const {
return GetField<uint64_t>(VT_UPDATEDATE, 0);
}
uint16_t updateMemberId() const {
return GetField<uint16_t>(VT_UPDATEMEMBERID, 0);
}
const BinAttr *data() const {
return GetPointer<const BinAttr *>(VT_DATA);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_UPDATEDATE, 8) &&
VerifyField<uint16_t>(verifier, VT_UPDATEMEMBERID, 2) &&
VerifyOffset(verifier, VT_DATA) &&
verifier.VerifyTable(data()) &&
verifier.EndTable();
}
};
struct BinAttrInternalBuilder {
typedef BinAttrInternal Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_updateDate(uint64_t updateDate) {
fbb_.AddElement<uint64_t>(BinAttrInternal::VT_UPDATEDATE, updateDate, 0);
}
void add_updateMemberId(uint16_t updateMemberId) {
fbb_.AddElement<uint16_t>(BinAttrInternal::VT_UPDATEMEMBERID, updateMemberId, 0);
}
void add_data(::flatbuffers::Offset<BinAttr> data) {
fbb_.AddOffset(BinAttrInternal::VT_DATA, data);
}
explicit BinAttrInternalBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<BinAttrInternal> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<BinAttrInternal>(end);
return o;
}
};
inline ::flatbuffers::Offset<BinAttrInternal> CreateBinAttrInternal(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t updateDate = 0,
uint16_t updateMemberId = 0,
::flatbuffers::Offset<BinAttr> data = 0) {
BinAttrInternalBuilder builder_(_fbb);
builder_.add_updateDate(updateDate);
builder_.add_data(data);
builder_.add_updateMemberId(updateMemberId);
return builder_.Finish();
}
struct OptParam FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef OptParamBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_TYPE = 4,
VT_FLAG = 6,
VT_HUBMEMBERID = 8
};
uint8_t type() const {
return GetField<uint8_t>(VT_TYPE, 0);
}
uint8_t flag() const {
return GetField<uint8_t>(VT_FLAG, 0);
}
uint16_t hubMemberId() const {
return GetField<uint16_t>(VT_HUBMEMBERID, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_TYPE, 1) &&
VerifyField<uint8_t>(verifier, VT_FLAG, 1) &&
VerifyField<uint16_t>(verifier, VT_HUBMEMBERID, 2) &&
verifier.EndTable();
}
};
struct OptParamBuilder {
typedef OptParam Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_type(uint8_t type) {
fbb_.AddElement<uint8_t>(OptParam::VT_TYPE, type, 0);
}
void add_flag(uint8_t flag) {
fbb_.AddElement<uint8_t>(OptParam::VT_FLAG, flag, 0);
}
void add_hubMemberId(uint16_t hubMemberId) {
fbb_.AddElement<uint16_t>(OptParam::VT_HUBMEMBERID, hubMemberId, 0);
}
explicit OptParamBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<OptParam> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<OptParam>(end);
return o;
}
};
inline ::flatbuffers::Offset<OptParam> CreateOptParam(
::flatbuffers::FlatBufferBuilder &_fbb,
uint8_t type = 0,
uint8_t flag = 0,
uint16_t hubMemberId = 0) {
OptParamBuilder builder_(_fbb);
builder_.add_hubMemberId(hubMemberId);
builder_.add_flag(flag);
builder_.add_type(type);
return builder_.Finish();
}
struct GroupConfig FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef GroupConfigBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SLOTNUM = 4,
VT_WITHLABEL = 6,
VT_LABEL = 8,
VT_WITHPASSWORD = 10
};
uint32_t slotNum() const {
return GetField<uint32_t>(VT_SLOTNUM, 0);
}
bool withLabel() const {
return GetField<uint8_t>(VT_WITHLABEL, 0) != 0;
}
const ::flatbuffers::Vector<uint8_t> *label() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_LABEL);
}
bool withPassword() const {
return GetField<uint8_t>(VT_WITHPASSWORD, 0) != 0;
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_SLOTNUM, 4) &&
VerifyField<uint8_t>(verifier, VT_WITHLABEL, 1) &&
VerifyOffset(verifier, VT_LABEL) &&
verifier.VerifyVector(label()) &&
VerifyField<uint8_t>(verifier, VT_WITHPASSWORD, 1) &&
verifier.EndTable();
}
};
struct GroupConfigBuilder {
typedef GroupConfig Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_slotNum(uint32_t slotNum) {
fbb_.AddElement<uint32_t>(GroupConfig::VT_SLOTNUM, slotNum, 0);
}
void add_withLabel(bool withLabel) {
fbb_.AddElement<uint8_t>(GroupConfig::VT_WITHLABEL, static_cast<uint8_t>(withLabel), 0);
}
void add_label(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> label) {
fbb_.AddOffset(GroupConfig::VT_LABEL, label);
}
void add_withPassword(bool withPassword) {
fbb_.AddElement<uint8_t>(GroupConfig::VT_WITHPASSWORD, static_cast<uint8_t>(withPassword), 0);
}
explicit GroupConfigBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<GroupConfig> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<GroupConfig>(end);
return o;
}
};
inline ::flatbuffers::Offset<GroupConfig> CreateGroupConfig(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t slotNum = 0,
bool withLabel = false,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> label = 0,
bool withPassword = false) {
GroupConfigBuilder builder_(_fbb);
builder_.add_label(label);
builder_.add_slotNum(slotNum);
builder_.add_withPassword(withPassword);
builder_.add_withLabel(withLabel);
return builder_.Finish();
}
inline ::flatbuffers::Offset<GroupConfig> CreateGroupConfigDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t slotNum = 0,
bool withLabel = false,
const std::vector<uint8_t> *label = nullptr,
bool withPassword = false) {
auto label__ = label ? _fbb.CreateVector<uint8_t>(*label) : 0;
return CreateGroupConfig(
_fbb,
slotNum,
withLabel,
label__,
withPassword);
}
struct UserInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef UserInfoBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NPID = 4,
VT_ONLINENAME = 6,
VT_AVATARURL = 8
};
const ::flatbuffers::String *npId() const {
return GetPointer<const ::flatbuffers::String *>(VT_NPID);
}
const ::flatbuffers::String *onlineName() const {
return GetPointer<const ::flatbuffers::String *>(VT_ONLINENAME);
}
const ::flatbuffers::String *avatarUrl() const {
return GetPointer<const ::flatbuffers::String *>(VT_AVATARURL);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_NPID) &&
verifier.VerifyString(npId()) &&
VerifyOffset(verifier, VT_ONLINENAME) &&
verifier.VerifyString(onlineName()) &&
VerifyOffset(verifier, VT_AVATARURL) &&
verifier.VerifyString(avatarUrl()) &&
verifier.EndTable();
}
};
struct UserInfoBuilder {
typedef UserInfo Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_npId(::flatbuffers::Offset<::flatbuffers::String> npId) {
fbb_.AddOffset(UserInfo::VT_NPID, npId);
}
void add_onlineName(::flatbuffers::Offset<::flatbuffers::String> onlineName) {
fbb_.AddOffset(UserInfo::VT_ONLINENAME, onlineName);
}
void add_avatarUrl(::flatbuffers::Offset<::flatbuffers::String> avatarUrl) {
fbb_.AddOffset(UserInfo::VT_AVATARURL, avatarUrl);
}
explicit UserInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<UserInfo> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<UserInfo>(end);
return o;
}
};
inline ::flatbuffers::Offset<UserInfo> CreateUserInfo(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::String> npId = 0,
::flatbuffers::Offset<::flatbuffers::String> onlineName = 0,
::flatbuffers::Offset<::flatbuffers::String> avatarUrl = 0) {
UserInfoBuilder builder_(_fbb);
builder_.add_avatarUrl(avatarUrl);
builder_.add_onlineName(onlineName);
builder_.add_npId(npId);
return builder_.Finish();
}
inline ::flatbuffers::Offset<UserInfo> CreateUserInfoDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const char *npId = nullptr,
const char *onlineName = nullptr,
const char *avatarUrl = nullptr) {
auto npId__ = npId ? _fbb.CreateString(npId) : 0;
auto onlineName__ = onlineName ? _fbb.CreateString(onlineName) : 0;
auto avatarUrl__ = avatarUrl ? _fbb.CreateString(avatarUrl) : 0;
return CreateUserInfo(
_fbb,
npId__,
onlineName__,
avatarUrl__);
}
struct RoomMemberDataInternal FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef RoomMemberDataInternalBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_USERINFO = 4,
VT_JOINDATE = 6,
VT_MEMBERID = 8,
VT_TEAMID = 10,
VT_ROOMGROUP = 12,
VT_NATTYPE = 14,
VT_FLAGATTR = 16,
VT_ROOMMEMBERBINATTRINTERNAL = 18
};
const UserInfo *userInfo() const {
return GetPointer<const UserInfo *>(VT_USERINFO);
}
uint64_t joinDate() const {
return GetField<uint64_t>(VT_JOINDATE, 0);
}
uint16_t memberId() const {
return GetField<uint16_t>(VT_MEMBERID, 0);
}
uint8_t teamId() const {
return GetField<uint8_t>(VT_TEAMID, 0);
}
const RoomGroup *roomGroup() const {
return GetPointer<const RoomGroup *>(VT_ROOMGROUP);
}
uint8_t natType() const {
return GetField<uint8_t>(VT_NATTYPE, 0);
}
uint32_t flagAttr() const {
return GetField<uint32_t>(VT_FLAGATTR, 0);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<RoomMemberBinAttrInternal>> *roomMemberBinAttrInternal() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<RoomMemberBinAttrInternal>> *>(VT_ROOMMEMBERBINATTRINTERNAL);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_USERINFO) &&
verifier.VerifyTable(userInfo()) &&
VerifyField<uint64_t>(verifier, VT_JOINDATE, 8) &&
VerifyField<uint16_t>(verifier, VT_MEMBERID, 2) &&
VerifyField<uint8_t>(verifier, VT_TEAMID, 1) &&
VerifyOffset(verifier, VT_ROOMGROUP) &&
verifier.VerifyTable(roomGroup()) &&
VerifyField<uint8_t>(verifier, VT_NATTYPE, 1) &&
VerifyField<uint32_t>(verifier, VT_FLAGATTR, 4) &&
VerifyOffset(verifier, VT_ROOMMEMBERBINATTRINTERNAL) &&
verifier.VerifyVector(roomMemberBinAttrInternal()) &&
verifier.VerifyVectorOfTables(roomMemberBinAttrInternal()) &&
verifier.EndTable();
}
};
struct RoomMemberDataInternalBuilder {
typedef RoomMemberDataInternal Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_userInfo(::flatbuffers::Offset<UserInfo> userInfo) {
fbb_.AddOffset(RoomMemberDataInternal::VT_USERINFO, userInfo);
}
void add_joinDate(uint64_t joinDate) {
fbb_.AddElement<uint64_t>(RoomMemberDataInternal::VT_JOINDATE, joinDate, 0);
}
void add_memberId(uint16_t memberId) {
fbb_.AddElement<uint16_t>(RoomMemberDataInternal::VT_MEMBERID, memberId, 0);
}
void add_teamId(uint8_t teamId) {
fbb_.AddElement<uint8_t>(RoomMemberDataInternal::VT_TEAMID, teamId, 0);
}
void add_roomGroup(::flatbuffers::Offset<RoomGroup> roomGroup) {
fbb_.AddOffset(RoomMemberDataInternal::VT_ROOMGROUP, roomGroup);
}
void add_natType(uint8_t natType) {
fbb_.AddElement<uint8_t>(RoomMemberDataInternal::VT_NATTYPE, natType, 0);
}
void add_flagAttr(uint32_t flagAttr) {
fbb_.AddElement<uint32_t>(RoomMemberDataInternal::VT_FLAGATTR, flagAttr, 0);
}
void add_roomMemberBinAttrInternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomMemberBinAttrInternal>>> roomMemberBinAttrInternal) {
fbb_.AddOffset(RoomMemberDataInternal::VT_ROOMMEMBERBINATTRINTERNAL, roomMemberBinAttrInternal);
}
explicit RoomMemberDataInternalBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<RoomMemberDataInternal> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<RoomMemberDataInternal>(end);
return o;
}
};
inline ::flatbuffers::Offset<RoomMemberDataInternal> CreateRoomMemberDataInternal(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<UserInfo> userInfo = 0,
uint64_t joinDate = 0,
uint16_t memberId = 0,
uint8_t teamId = 0,
::flatbuffers::Offset<RoomGroup> roomGroup = 0,
uint8_t natType = 0,
uint32_t flagAttr = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomMemberBinAttrInternal>>> roomMemberBinAttrInternal = 0) {
RoomMemberDataInternalBuilder builder_(_fbb);
builder_.add_joinDate(joinDate);
builder_.add_roomMemberBinAttrInternal(roomMemberBinAttrInternal);
builder_.add_flagAttr(flagAttr);
builder_.add_roomGroup(roomGroup);
builder_.add_userInfo(userInfo);
builder_.add_memberId(memberId);
builder_.add_natType(natType);
builder_.add_teamId(teamId);
return builder_.Finish();
}
inline ::flatbuffers::Offset<RoomMemberDataInternal> CreateRoomMemberDataInternalDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<UserInfo> userInfo = 0,
uint64_t joinDate = 0,
uint16_t memberId = 0,
uint8_t teamId = 0,
::flatbuffers::Offset<RoomGroup> roomGroup = 0,
uint8_t natType = 0,
uint32_t flagAttr = 0,
const std::vector<::flatbuffers::Offset<RoomMemberBinAttrInternal>> *roomMemberBinAttrInternal = nullptr) {
auto roomMemberBinAttrInternal__ = roomMemberBinAttrInternal ? _fbb.CreateVector<::flatbuffers::Offset<RoomMemberBinAttrInternal>>(*roomMemberBinAttrInternal) : 0;
return CreateRoomMemberDataInternal(
_fbb,
userInfo,
joinDate,
memberId,
teamId,
roomGroup,
natType,
flagAttr,
roomMemberBinAttrInternal__);
}
struct RoomGroup FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef RoomGroupBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_GROUPID = 4,
VT_WITHPASSWORD = 6,
VT_WITHLABEL = 8,
VT_LABEL = 10,
VT_SLOTNUM = 12,
VT_CURGROUPMEMBERNUM = 14
};
uint8_t groupId() const {
return GetField<uint8_t>(VT_GROUPID, 0);
}
bool withPassword() const {
return GetField<uint8_t>(VT_WITHPASSWORD, 0) != 0;
}
bool withLabel() const {
return GetField<uint8_t>(VT_WITHLABEL, 0) != 0;
}
const ::flatbuffers::Vector<uint8_t> *label() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_LABEL);
}
uint32_t slotNum() const {
return GetField<uint32_t>(VT_SLOTNUM, 0);
}
uint32_t curGroupMemberNum() const {
return GetField<uint32_t>(VT_CURGROUPMEMBERNUM, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_GROUPID, 1) &&
VerifyField<uint8_t>(verifier, VT_WITHPASSWORD, 1) &&
VerifyField<uint8_t>(verifier, VT_WITHLABEL, 1) &&
VerifyOffset(verifier, VT_LABEL) &&
verifier.VerifyVector(label()) &&
VerifyField<uint32_t>(verifier, VT_SLOTNUM, 4) &&
VerifyField<uint32_t>(verifier, VT_CURGROUPMEMBERNUM, 4) &&
verifier.EndTable();
}
};
struct RoomGroupBuilder {
typedef RoomGroup Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_groupId(uint8_t groupId) {
fbb_.AddElement<uint8_t>(RoomGroup::VT_GROUPID, groupId, 0);
}
void add_withPassword(bool withPassword) {
fbb_.AddElement<uint8_t>(RoomGroup::VT_WITHPASSWORD, static_cast<uint8_t>(withPassword), 0);
}
void add_withLabel(bool withLabel) {
fbb_.AddElement<uint8_t>(RoomGroup::VT_WITHLABEL, static_cast<uint8_t>(withLabel), 0);
}
void add_label(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> label) {
fbb_.AddOffset(RoomGroup::VT_LABEL, label);
}
void add_slotNum(uint32_t slotNum) {
fbb_.AddElement<uint32_t>(RoomGroup::VT_SLOTNUM, slotNum, 0);
}
void add_curGroupMemberNum(uint32_t curGroupMemberNum) {
fbb_.AddElement<uint32_t>(RoomGroup::VT_CURGROUPMEMBERNUM, curGroupMemberNum, 0);
}
explicit RoomGroupBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<RoomGroup> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<RoomGroup>(end);
return o;
}
};
inline ::flatbuffers::Offset<RoomGroup> CreateRoomGroup(
::flatbuffers::FlatBufferBuilder &_fbb,
uint8_t groupId = 0,
bool withPassword = false,
bool withLabel = false,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> label = 0,
uint32_t slotNum = 0,
uint32_t curGroupMemberNum = 0) {
RoomGroupBuilder builder_(_fbb);
builder_.add_curGroupMemberNum(curGroupMemberNum);
builder_.add_slotNum(slotNum);
builder_.add_label(label);
builder_.add_withLabel(withLabel);
builder_.add_withPassword(withPassword);
builder_.add_groupId(groupId);
return builder_.Finish();
}
inline ::flatbuffers::Offset<RoomGroup> CreateRoomGroupDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint8_t groupId = 0,
bool withPassword = false,
bool withLabel = false,
const std::vector<uint8_t> *label = nullptr,
uint32_t slotNum = 0,
uint32_t curGroupMemberNum = 0) {
auto label__ = label ? _fbb.CreateVector<uint8_t>(*label) : 0;
return CreateRoomGroup(
_fbb,
groupId,
withPassword,
withLabel,
label__,
slotNum,
curGroupMemberNum);
}
struct RoomDataInternal FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef RoomDataInternalBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SERVERID = 4,
VT_WORLDID = 6,
VT_LOBBYID = 8,
VT_ROOMID = 10,
VT_PASSWORDSLOTMASK = 12,
VT_MAXSLOT = 14,
VT_MEMBERLIST = 16,
VT_OWNERID = 18,
VT_ROOMGROUP = 20,
VT_FLAGATTR = 22,
VT_ROOMBINATTRINTERNAL = 24
};
uint16_t serverId() const {
return GetField<uint16_t>(VT_SERVERID, 0);
}
uint32_t worldId() const {
return GetField<uint32_t>(VT_WORLDID, 0);
}
uint64_t lobbyId() const {
return GetField<uint64_t>(VT_LOBBYID, 0);
}
uint64_t roomId() const {
return GetField<uint64_t>(VT_ROOMID, 0);
}
uint64_t passwordSlotMask() const {
return GetField<uint64_t>(VT_PASSWORDSLOTMASK, 0);
}
uint32_t maxSlot() const {
return GetField<uint32_t>(VT_MAXSLOT, 0);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<RoomMemberDataInternal>> *memberList() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<RoomMemberDataInternal>> *>(VT_MEMBERLIST);
}
uint16_t ownerId() const {
return GetField<uint16_t>(VT_OWNERID, 0);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<RoomGroup>> *roomGroup() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<RoomGroup>> *>(VT_ROOMGROUP);
}
uint32_t flagAttr() const {
return GetField<uint32_t>(VT_FLAGATTR, 0);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttrInternal>> *roomBinAttrInternal() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttrInternal>> *>(VT_ROOMBINATTRINTERNAL);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint16_t>(verifier, VT_SERVERID, 2) &&
VerifyField<uint32_t>(verifier, VT_WORLDID, 4) &&
VerifyField<uint64_t>(verifier, VT_LOBBYID, 8) &&
VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
VerifyField<uint64_t>(verifier, VT_PASSWORDSLOTMASK, 8) &&
VerifyField<uint32_t>(verifier, VT_MAXSLOT, 4) &&
VerifyOffset(verifier, VT_MEMBERLIST) &&
verifier.VerifyVector(memberList()) &&
verifier.VerifyVectorOfTables(memberList()) &&
VerifyField<uint16_t>(verifier, VT_OWNERID, 2) &&
VerifyOffset(verifier, VT_ROOMGROUP) &&
verifier.VerifyVector(roomGroup()) &&
verifier.VerifyVectorOfTables(roomGroup()) &&
VerifyField<uint32_t>(verifier, VT_FLAGATTR, 4) &&
VerifyOffset(verifier, VT_ROOMBINATTRINTERNAL) &&
verifier.VerifyVector(roomBinAttrInternal()) &&
verifier.VerifyVectorOfTables(roomBinAttrInternal()) &&
verifier.EndTable();
}
};
struct RoomDataInternalBuilder {
typedef RoomDataInternal Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_serverId(uint16_t serverId) {
fbb_.AddElement<uint16_t>(RoomDataInternal::VT_SERVERID, serverId, 0);
}
void add_worldId(uint32_t worldId) {
fbb_.AddElement<uint32_t>(RoomDataInternal::VT_WORLDID, worldId, 0);
}
void add_lobbyId(uint64_t lobbyId) {
fbb_.AddElement<uint64_t>(RoomDataInternal::VT_LOBBYID, lobbyId, 0);
}
void add_roomId(uint64_t roomId) {
fbb_.AddElement<uint64_t>(RoomDataInternal::VT_ROOMID, roomId, 0);
}
void add_passwordSlotMask(uint64_t passwordSlotMask) {
fbb_.AddElement<uint64_t>(RoomDataInternal::VT_PASSWORDSLOTMASK, passwordSlotMask, 0);
}
void add_maxSlot(uint32_t maxSlot) {
fbb_.AddElement<uint32_t>(RoomDataInternal::VT_MAXSLOT, maxSlot, 0);
}
void add_memberList(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomMemberDataInternal>>> memberList) {
fbb_.AddOffset(RoomDataInternal::VT_MEMBERLIST, memberList);
}
void add_ownerId(uint16_t ownerId) {
fbb_.AddElement<uint16_t>(RoomDataInternal::VT_OWNERID, ownerId, 0);
}
void add_roomGroup(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomGroup>>> roomGroup) {
fbb_.AddOffset(RoomDataInternal::VT_ROOMGROUP, roomGroup);
}
void add_flagAttr(uint32_t flagAttr) {
fbb_.AddElement<uint32_t>(RoomDataInternal::VT_FLAGATTR, flagAttr, 0);
}
void add_roomBinAttrInternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttrInternal>>> roomBinAttrInternal) {
fbb_.AddOffset(RoomDataInternal::VT_ROOMBINATTRINTERNAL, roomBinAttrInternal);
}
explicit RoomDataInternalBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<RoomDataInternal> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<RoomDataInternal>(end);
return o;
}
};
inline ::flatbuffers::Offset<RoomDataInternal> CreateRoomDataInternal(
::flatbuffers::FlatBufferBuilder &_fbb,
uint16_t serverId = 0,
uint32_t worldId = 0,
uint64_t lobbyId = 0,
uint64_t roomId = 0,
uint64_t passwordSlotMask = 0,
uint32_t maxSlot = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomMemberDataInternal>>> memberList = 0,
uint16_t ownerId = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomGroup>>> roomGroup = 0,
uint32_t flagAttr = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttrInternal>>> roomBinAttrInternal = 0) {
RoomDataInternalBuilder builder_(_fbb);
builder_.add_passwordSlotMask(passwordSlotMask);
builder_.add_roomId(roomId);
builder_.add_lobbyId(lobbyId);
builder_.add_roomBinAttrInternal(roomBinAttrInternal);
builder_.add_flagAttr(flagAttr);
builder_.add_roomGroup(roomGroup);
builder_.add_memberList(memberList);
builder_.add_maxSlot(maxSlot);
builder_.add_worldId(worldId);
builder_.add_ownerId(ownerId);
builder_.add_serverId(serverId);
return builder_.Finish();
}
inline ::flatbuffers::Offset<RoomDataInternal> CreateRoomDataInternalDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint16_t serverId = 0,
uint32_t worldId = 0,
uint64_t lobbyId = 0,
uint64_t roomId = 0,
uint64_t passwordSlotMask = 0,
uint32_t maxSlot = 0,
const std::vector<::flatbuffers::Offset<RoomMemberDataInternal>> *memberList = nullptr,
uint16_t ownerId = 0,
const std::vector<::flatbuffers::Offset<RoomGroup>> *roomGroup = nullptr,
uint32_t flagAttr = 0,
const std::vector<::flatbuffers::Offset<BinAttrInternal>> *roomBinAttrInternal = nullptr) {
auto memberList__ = memberList ? _fbb.CreateVector<::flatbuffers::Offset<RoomMemberDataInternal>>(*memberList) : 0;
auto roomGroup__ = roomGroup ? _fbb.CreateVector<::flatbuffers::Offset<RoomGroup>>(*roomGroup) : 0;
auto roomBinAttrInternal__ = roomBinAttrInternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttrInternal>>(*roomBinAttrInternal) : 0;
return CreateRoomDataInternal(
_fbb,
serverId,
worldId,
lobbyId,
roomId,
passwordSlotMask,
maxSlot,
memberList__,
ownerId,
roomGroup__,
flagAttr,
roomBinAttrInternal__);
}
struct RoomDataExternal FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef RoomDataExternalBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SERVERID = 4,
VT_WORLDID = 6,
VT_PUBLICSLOTNUM = 8,
VT_PRIVATESLOTNUM = 10,
VT_LOBBYID = 12,
VT_ROOMID = 14,
VT_OPENPUBLICSLOTNUM = 16,
VT_MAXSLOT = 18,
VT_OPENPRIVATESLOTNUM = 20,
VT_CURMEMBERNUM = 22,
VT_PASSWORDSLOTMASK = 24,
VT_OWNER = 26,
VT_ROOMGROUP = 28,
VT_FLAGATTR = 30,
VT_ROOMSEARCHABLEINTATTREXTERNAL = 32,
VT_ROOMSEARCHABLEBINATTREXTERNAL = 34,
VT_ROOMBINATTREXTERNAL = 36
};
uint16_t serverId() const {
return GetField<uint16_t>(VT_SERVERID, 0);
}
uint32_t worldId() const {
return GetField<uint32_t>(VT_WORLDID, 0);
}
uint16_t publicSlotNum() const {
return GetField<uint16_t>(VT_PUBLICSLOTNUM, 0);
}
uint16_t privateSlotNum() const {
return GetField<uint16_t>(VT_PRIVATESLOTNUM, 0);
}
uint64_t lobbyId() const {
return GetField<uint64_t>(VT_LOBBYID, 0);
}
uint64_t roomId() const {
return GetField<uint64_t>(VT_ROOMID, 0);
}
uint16_t openPublicSlotNum() const {
return GetField<uint16_t>(VT_OPENPUBLICSLOTNUM, 0);
}
uint16_t maxSlot() const {
return GetField<uint16_t>(VT_MAXSLOT, 0);
}
uint16_t openPrivateSlotNum() const {
return GetField<uint16_t>(VT_OPENPRIVATESLOTNUM, 0);
}
uint16_t curMemberNum() const {
return GetField<uint16_t>(VT_CURMEMBERNUM, 0);
}
uint64_t passwordSlotMask() const {
return GetField<uint64_t>(VT_PASSWORDSLOTMASK, 0);
}
const UserInfo *owner() const {
return GetPointer<const UserInfo *>(VT_OWNER);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<RoomGroup>> *roomGroup() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<RoomGroup>> *>(VT_ROOMGROUP);
}
uint32_t flagAttr() const {
return GetField<uint32_t>(VT_FLAGATTR, 0);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>> *roomSearchableIntAttrExternal() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>> *>(VT_ROOMSEARCHABLEINTATTREXTERNAL);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *roomSearchableBinAttrExternal() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_ROOMSEARCHABLEBINATTREXTERNAL);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *roomBinAttrExternal() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_ROOMBINATTREXTERNAL);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint16_t>(verifier, VT_SERVERID, 2) &&
VerifyField<uint32_t>(verifier, VT_WORLDID, 4) &&
VerifyField<uint16_t>(verifier, VT_PUBLICSLOTNUM, 2) &&
VerifyField<uint16_t>(verifier, VT_PRIVATESLOTNUM, 2) &&
VerifyField<uint64_t>(verifier, VT_LOBBYID, 8) &&
VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
VerifyField<uint16_t>(verifier, VT_OPENPUBLICSLOTNUM, 2) &&
VerifyField<uint16_t>(verifier, VT_MAXSLOT, 2) &&
VerifyField<uint16_t>(verifier, VT_OPENPRIVATESLOTNUM, 2) &&
VerifyField<uint16_t>(verifier, VT_CURMEMBERNUM, 2) &&
VerifyField<uint64_t>(verifier, VT_PASSWORDSLOTMASK, 8) &&
VerifyOffset(verifier, VT_OWNER) &&
verifier.VerifyTable(owner()) &&
VerifyOffset(verifier, VT_ROOMGROUP) &&
verifier.VerifyVector(roomGroup()) &&
verifier.VerifyVectorOfTables(roomGroup()) &&
VerifyField<uint32_t>(verifier, VT_FLAGATTR, 4) &&
VerifyOffset(verifier, VT_ROOMSEARCHABLEINTATTREXTERNAL) &&
verifier.VerifyVector(roomSearchableIntAttrExternal()) &&
verifier.VerifyVectorOfTables(roomSearchableIntAttrExternal()) &&
VerifyOffset(verifier, VT_ROOMSEARCHABLEBINATTREXTERNAL) &&
verifier.VerifyVector(roomSearchableBinAttrExternal()) &&
verifier.VerifyVectorOfTables(roomSearchableBinAttrExternal()) &&
VerifyOffset(verifier, VT_ROOMBINATTREXTERNAL) &&
verifier.VerifyVector(roomBinAttrExternal()) &&
verifier.VerifyVectorOfTables(roomBinAttrExternal()) &&
verifier.EndTable();
}
};
struct RoomDataExternalBuilder {
typedef RoomDataExternal Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_serverId(uint16_t serverId) {
fbb_.AddElement<uint16_t>(RoomDataExternal::VT_SERVERID, serverId, 0);
}
void add_worldId(uint32_t worldId) {
fbb_.AddElement<uint32_t>(RoomDataExternal::VT_WORLDID, worldId, 0);
}
void add_publicSlotNum(uint16_t publicSlotNum) {
fbb_.AddElement<uint16_t>(RoomDataExternal::VT_PUBLICSLOTNUM, publicSlotNum, 0);
}
void add_privateSlotNum(uint16_t privateSlotNum) {
fbb_.AddElement<uint16_t>(RoomDataExternal::VT_PRIVATESLOTNUM, privateSlotNum, 0);
}
void add_lobbyId(uint64_t lobbyId) {
fbb_.AddElement<uint64_t>(RoomDataExternal::VT_LOBBYID, lobbyId, 0);
}
void add_roomId(uint64_t roomId) {
fbb_.AddElement<uint64_t>(RoomDataExternal::VT_ROOMID, roomId, 0);
}
void add_openPublicSlotNum(uint16_t openPublicSlotNum) {
fbb_.AddElement<uint16_t>(RoomDataExternal::VT_OPENPUBLICSLOTNUM, openPublicSlotNum, 0);
}
void add_maxSlot(uint16_t maxSlot) {
fbb_.AddElement<uint16_t>(RoomDataExternal::VT_MAXSLOT, maxSlot, 0);
}
void add_openPrivateSlotNum(uint16_t openPrivateSlotNum) {
fbb_.AddElement<uint16_t>(RoomDataExternal::VT_OPENPRIVATESLOTNUM, openPrivateSlotNum, 0);
}
void add_curMemberNum(uint16_t curMemberNum) {
fbb_.AddElement<uint16_t>(RoomDataExternal::VT_CURMEMBERNUM, curMemberNum, 0);
}
void add_passwordSlotMask(uint64_t passwordSlotMask) {
fbb_.AddElement<uint64_t>(RoomDataExternal::VT_PASSWORDSLOTMASK, passwordSlotMask, 0);
}
void add_owner(::flatbuffers::Offset<UserInfo> owner) {
fbb_.AddOffset(RoomDataExternal::VT_OWNER, owner);
}
void add_roomGroup(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomGroup>>> roomGroup) {
fbb_.AddOffset(RoomDataExternal::VT_ROOMGROUP, roomGroup);
}
void add_flagAttr(uint32_t flagAttr) {
fbb_.AddElement<uint32_t>(RoomDataExternal::VT_FLAGATTR, flagAttr, 0);
}
void add_roomSearchableIntAttrExternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>>> roomSearchableIntAttrExternal) {
fbb_.AddOffset(RoomDataExternal::VT_ROOMSEARCHABLEINTATTREXTERNAL, roomSearchableIntAttrExternal);
}
void add_roomSearchableBinAttrExternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomSearchableBinAttrExternal) {
fbb_.AddOffset(RoomDataExternal::VT_ROOMSEARCHABLEBINATTREXTERNAL, roomSearchableBinAttrExternal);
}
void add_roomBinAttrExternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomBinAttrExternal) {
fbb_.AddOffset(RoomDataExternal::VT_ROOMBINATTREXTERNAL, roomBinAttrExternal);
}
explicit RoomDataExternalBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<RoomDataExternal> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<RoomDataExternal>(end);
return o;
}
};
inline ::flatbuffers::Offset<RoomDataExternal> CreateRoomDataExternal(
::flatbuffers::FlatBufferBuilder &_fbb,
uint16_t serverId = 0,
uint32_t worldId = 0,
uint16_t publicSlotNum = 0,
uint16_t privateSlotNum = 0,
uint64_t lobbyId = 0,
uint64_t roomId = 0,
uint16_t openPublicSlotNum = 0,
uint16_t maxSlot = 0,
uint16_t openPrivateSlotNum = 0,
uint16_t curMemberNum = 0,
uint64_t passwordSlotMask = 0,
::flatbuffers::Offset<UserInfo> owner = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomGroup>>> roomGroup = 0,
uint32_t flagAttr = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>>> roomSearchableIntAttrExternal = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomSearchableBinAttrExternal = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomBinAttrExternal = 0) {
RoomDataExternalBuilder builder_(_fbb);
builder_.add_passwordSlotMask(passwordSlotMask);
builder_.add_roomId(roomId);
builder_.add_lobbyId(lobbyId);
builder_.add_roomBinAttrExternal(roomBinAttrExternal);
builder_.add_roomSearchableBinAttrExternal(roomSearchableBinAttrExternal);
builder_.add_roomSearchableIntAttrExternal(roomSearchableIntAttrExternal);
builder_.add_flagAttr(flagAttr);
builder_.add_roomGroup(roomGroup);
builder_.add_owner(owner);
builder_.add_worldId(worldId);
builder_.add_curMemberNum(curMemberNum);
builder_.add_openPrivateSlotNum(openPrivateSlotNum);
builder_.add_maxSlot(maxSlot);
builder_.add_openPublicSlotNum(openPublicSlotNum);
builder_.add_privateSlotNum(privateSlotNum);
builder_.add_publicSlotNum(publicSlotNum);
builder_.add_serverId(serverId);
return builder_.Finish();
}
inline ::flatbuffers::Offset<RoomDataExternal> CreateRoomDataExternalDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint16_t serverId = 0,
uint32_t worldId = 0,
uint16_t publicSlotNum = 0,
uint16_t privateSlotNum = 0,
uint64_t lobbyId = 0,
uint64_t roomId = 0,
uint16_t openPublicSlotNum = 0,
uint16_t maxSlot = 0,
uint16_t openPrivateSlotNum = 0,
uint16_t curMemberNum = 0,
uint64_t passwordSlotMask = 0,
::flatbuffers::Offset<UserInfo> owner = 0,
const std::vector<::flatbuffers::Offset<RoomGroup>> *roomGroup = nullptr,
uint32_t flagAttr = 0,
const std::vector<::flatbuffers::Offset<IntAttr>> *roomSearchableIntAttrExternal = nullptr,
const std::vector<::flatbuffers::Offset<BinAttr>> *roomSearchableBinAttrExternal = nullptr,
const std::vector<::flatbuffers::Offset<BinAttr>> *roomBinAttrExternal = nullptr) {
auto roomGroup__ = roomGroup ? _fbb.CreateVector<::flatbuffers::Offset<RoomGroup>>(*roomGroup) : 0;
auto roomSearchableIntAttrExternal__ = roomSearchableIntAttrExternal ? _fbb.CreateVector<::flatbuffers::Offset<IntAttr>>(*roomSearchableIntAttrExternal) : 0;
auto roomSearchableBinAttrExternal__ = roomSearchableBinAttrExternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*roomSearchableBinAttrExternal) : 0;
auto roomBinAttrExternal__ = roomBinAttrExternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*roomBinAttrExternal) : 0;
return CreateRoomDataExternal(
_fbb,
serverId,
worldId,
publicSlotNum,
privateSlotNum,
lobbyId,
roomId,
openPublicSlotNum,
maxSlot,
openPrivateSlotNum,
curMemberNum,
passwordSlotMask,
owner,
roomGroup__,
flagAttr,
roomSearchableIntAttrExternal__,
roomSearchableBinAttrExternal__,
roomBinAttrExternal__);
}
struct IntSearchFilter FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef IntSearchFilterBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SEARCHOPERATOR = 4,
VT_ATTR = 6
};
uint8_t searchOperator() const {
return GetField<uint8_t>(VT_SEARCHOPERATOR, 0);
}
const IntAttr *attr() const {
return GetPointer<const IntAttr *>(VT_ATTR);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_SEARCHOPERATOR, 1) &&
VerifyOffset(verifier, VT_ATTR) &&
verifier.VerifyTable(attr()) &&
verifier.EndTable();
}
};
struct IntSearchFilterBuilder {
typedef IntSearchFilter Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_searchOperator(uint8_t searchOperator) {
fbb_.AddElement<uint8_t>(IntSearchFilter::VT_SEARCHOPERATOR, searchOperator, 0);
}
void add_attr(::flatbuffers::Offset<IntAttr> attr) {
fbb_.AddOffset(IntSearchFilter::VT_ATTR, attr);
}
explicit IntSearchFilterBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<IntSearchFilter> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<IntSearchFilter>(end);
return o;
}
};
inline ::flatbuffers::Offset<IntSearchFilter> CreateIntSearchFilter(
::flatbuffers::FlatBufferBuilder &_fbb,
uint8_t searchOperator = 0,
::flatbuffers::Offset<IntAttr> attr = 0) {
IntSearchFilterBuilder builder_(_fbb);
builder_.add_attr(attr);
builder_.add_searchOperator(searchOperator);
return builder_.Finish();
}
struct BinSearchFilter FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef BinSearchFilterBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SEARCHOPERATOR = 4,
VT_ATTR = 6
};
uint8_t searchOperator() const {
return GetField<uint8_t>(VT_SEARCHOPERATOR, 0);
}
const BinAttr *attr() const {
return GetPointer<const BinAttr *>(VT_ATTR);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_SEARCHOPERATOR, 1) &&
VerifyOffset(verifier, VT_ATTR) &&
verifier.VerifyTable(attr()) &&
verifier.EndTable();
}
};
struct BinSearchFilterBuilder {
typedef BinSearchFilter Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_searchOperator(uint8_t searchOperator) {
fbb_.AddElement<uint8_t>(BinSearchFilter::VT_SEARCHOPERATOR, searchOperator, 0);
}
void add_attr(::flatbuffers::Offset<BinAttr> attr) {
fbb_.AddOffset(BinSearchFilter::VT_ATTR, attr);
}
explicit BinSearchFilterBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<BinSearchFilter> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<BinSearchFilter>(end);
return o;
}
};
inline ::flatbuffers::Offset<BinSearchFilter> CreateBinSearchFilter(
::flatbuffers::FlatBufferBuilder &_fbb,
uint8_t searchOperator = 0,
::flatbuffers::Offset<BinAttr> attr = 0) {
BinSearchFilterBuilder builder_(_fbb);
builder_.add_attr(attr);
builder_.add_searchOperator(searchOperator);
return builder_.Finish();
}
struct PresenceOptionData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef PresenceOptionDataBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_DATA = 4,
VT_LEN = 6
};
const ::flatbuffers::Vector<uint8_t> *data() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
}
uint32_t len() const {
return GetField<uint32_t>(VT_LEN, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_DATA) &&
verifier.VerifyVector(data()) &&
VerifyField<uint32_t>(verifier, VT_LEN, 4) &&
verifier.EndTable();
}
};
struct PresenceOptionDataBuilder {
typedef PresenceOptionData Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
fbb_.AddOffset(PresenceOptionData::VT_DATA, data);
}
void add_len(uint32_t len) {
fbb_.AddElement<uint32_t>(PresenceOptionData::VT_LEN, len, 0);
}
explicit PresenceOptionDataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<PresenceOptionData> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<PresenceOptionData>(end);
return o;
}
};
inline ::flatbuffers::Offset<PresenceOptionData> CreatePresenceOptionData(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0,
uint32_t len = 0) {
PresenceOptionDataBuilder builder_(_fbb);
builder_.add_len(len);
builder_.add_data(data);
return builder_.Finish();
}
inline ::flatbuffers::Offset<PresenceOptionData> CreatePresenceOptionDataDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *data = nullptr,
uint32_t len = 0) {
auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
return CreatePresenceOptionData(
_fbb,
data__,
len);
}
struct RoomGroupPasswordConfig FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef RoomGroupPasswordConfigBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_GROUPID = 4,
VT_WITHPASSWORD = 6
};
const ::flatbuffers::Vector<uint8_t> *groupId() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_GROUPID);
}
bool withPassword() const {
return GetField<uint8_t>(VT_WITHPASSWORD, 0) != 0;
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_GROUPID) &&
verifier.VerifyVector(groupId()) &&
VerifyField<uint8_t>(verifier, VT_WITHPASSWORD, 1) &&
verifier.EndTable();
}
};
struct RoomGroupPasswordConfigBuilder {
typedef RoomGroupPasswordConfig Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_groupId(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> groupId) {
fbb_.AddOffset(RoomGroupPasswordConfig::VT_GROUPID, groupId);
}
void add_withPassword(bool withPassword) {
fbb_.AddElement<uint8_t>(RoomGroupPasswordConfig::VT_WITHPASSWORD, static_cast<uint8_t>(withPassword), 0);
}
explicit RoomGroupPasswordConfigBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<RoomGroupPasswordConfig> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<RoomGroupPasswordConfig>(end);
return o;
}
};
inline ::flatbuffers::Offset<RoomGroupPasswordConfig> CreateRoomGroupPasswordConfig(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> groupId = 0,
bool withPassword = false) {
RoomGroupPasswordConfigBuilder builder_(_fbb);
builder_.add_groupId(groupId);
builder_.add_withPassword(withPassword);
return builder_.Finish();
}
inline ::flatbuffers::Offset<RoomGroupPasswordConfig> CreateRoomGroupPasswordConfigDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *groupId = nullptr,
bool withPassword = false) {
auto groupId__ = groupId ? _fbb.CreateVector<uint8_t>(*groupId) : 0;
return CreateRoomGroupPasswordConfig(
_fbb,
groupId__,
withPassword);
}
struct SearchRoomRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef SearchRoomRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_OPTION = 4,
VT_WORLDID = 6,
VT_LOBBYID = 8,
VT_RANGEFILTER_STARTINDEX = 10,
VT_RANGEFILTER_MAX = 12,
VT_FLAGFILTER = 14,
VT_FLAGATTR = 16,
VT_INTFILTER = 18,
VT_BINFILTER = 20,
VT_ATTRID = 22
};
int32_t option() const {
return GetField<int32_t>(VT_OPTION, 0);
}
uint32_t worldId() const {
return GetField<uint32_t>(VT_WORLDID, 0);
}
uint64_t lobbyId() const {
return GetField<uint64_t>(VT_LOBBYID, 0);
}
uint32_t rangeFilter_startIndex() const {
return GetField<uint32_t>(VT_RANGEFILTER_STARTINDEX, 0);
}
uint32_t rangeFilter_max() const {
return GetField<uint32_t>(VT_RANGEFILTER_MAX, 0);
}
uint32_t flagFilter() const {
return GetField<uint32_t>(VT_FLAGFILTER, 0);
}
uint32_t flagAttr() const {
return GetField<uint32_t>(VT_FLAGATTR, 0);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<IntSearchFilter>> *intFilter() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<IntSearchFilter>> *>(VT_INTFILTER);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<BinSearchFilter>> *binFilter() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinSearchFilter>> *>(VT_BINFILTER);
}
const ::flatbuffers::Vector<uint16_t> *attrId() const {
return GetPointer<const ::flatbuffers::Vector<uint16_t> *>(VT_ATTRID);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_OPTION, 4) &&
VerifyField<uint32_t>(verifier, VT_WORLDID, 4) &&
VerifyField<uint64_t>(verifier, VT_LOBBYID, 8) &&
VerifyField<uint32_t>(verifier, VT_RANGEFILTER_STARTINDEX, 4) &&
VerifyField<uint32_t>(verifier, VT_RANGEFILTER_MAX, 4) &&
VerifyField<uint32_t>(verifier, VT_FLAGFILTER, 4) &&
VerifyField<uint32_t>(verifier, VT_FLAGATTR, 4) &&
VerifyOffset(verifier, VT_INTFILTER) &&
verifier.VerifyVector(intFilter()) &&
verifier.VerifyVectorOfTables(intFilter()) &&
VerifyOffset(verifier, VT_BINFILTER) &&
verifier.VerifyVector(binFilter()) &&
verifier.VerifyVectorOfTables(binFilter()) &&
VerifyOffset(verifier, VT_ATTRID) &&
verifier.VerifyVector(attrId()) &&
verifier.EndTable();
}
};
struct SearchRoomRequestBuilder {
typedef SearchRoomRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_option(int32_t option) {
fbb_.AddElement<int32_t>(SearchRoomRequest::VT_OPTION, option, 0);
}
void add_worldId(uint32_t worldId) {
fbb_.AddElement<uint32_t>(SearchRoomRequest::VT_WORLDID, worldId, 0);
}
void add_lobbyId(uint64_t lobbyId) {
fbb_.AddElement<uint64_t>(SearchRoomRequest::VT_LOBBYID, lobbyId, 0);
}
void add_rangeFilter_startIndex(uint32_t rangeFilter_startIndex) {
fbb_.AddElement<uint32_t>(SearchRoomRequest::VT_RANGEFILTER_STARTINDEX, rangeFilter_startIndex, 0);
}
void add_rangeFilter_max(uint32_t rangeFilter_max) {
fbb_.AddElement<uint32_t>(SearchRoomRequest::VT_RANGEFILTER_MAX, rangeFilter_max, 0);
}
void add_flagFilter(uint32_t flagFilter) {
fbb_.AddElement<uint32_t>(SearchRoomRequest::VT_FLAGFILTER, flagFilter, 0);
}
void add_flagAttr(uint32_t flagAttr) {
fbb_.AddElement<uint32_t>(SearchRoomRequest::VT_FLAGATTR, flagAttr, 0);
}
void add_intFilter(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<IntSearchFilter>>> intFilter) {
fbb_.AddOffset(SearchRoomRequest::VT_INTFILTER, intFilter);
}
void add_binFilter(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinSearchFilter>>> binFilter) {
fbb_.AddOffset(SearchRoomRequest::VT_BINFILTER, binFilter);
}
void add_attrId(::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> attrId) {
fbb_.AddOffset(SearchRoomRequest::VT_ATTRID, attrId);
}
explicit SearchRoomRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<SearchRoomRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<SearchRoomRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<SearchRoomRequest> CreateSearchRoomRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
int32_t option = 0,
uint32_t worldId = 0,
uint64_t lobbyId = 0,
uint32_t rangeFilter_startIndex = 0,
uint32_t rangeFilter_max = 0,
uint32_t flagFilter = 0,
uint32_t flagAttr = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<IntSearchFilter>>> intFilter = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinSearchFilter>>> binFilter = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> attrId = 0) {
SearchRoomRequestBuilder builder_(_fbb);
builder_.add_lobbyId(lobbyId);
builder_.add_attrId(attrId);
builder_.add_binFilter(binFilter);
builder_.add_intFilter(intFilter);
builder_.add_flagAttr(flagAttr);
builder_.add_flagFilter(flagFilter);
builder_.add_rangeFilter_max(rangeFilter_max);
builder_.add_rangeFilter_startIndex(rangeFilter_startIndex);
builder_.add_worldId(worldId);
builder_.add_option(option);
return builder_.Finish();
}
inline ::flatbuffers::Offset<SearchRoomRequest> CreateSearchRoomRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
int32_t option = 0,
uint32_t worldId = 0,
uint64_t lobbyId = 0,
uint32_t rangeFilter_startIndex = 0,
uint32_t rangeFilter_max = 0,
uint32_t flagFilter = 0,
uint32_t flagAttr = 0,
const std::vector<::flatbuffers::Offset<IntSearchFilter>> *intFilter = nullptr,
const std::vector<::flatbuffers::Offset<BinSearchFilter>> *binFilter = nullptr,
const std::vector<uint16_t> *attrId = nullptr) {
auto intFilter__ = intFilter ? _fbb.CreateVector<::flatbuffers::Offset<IntSearchFilter>>(*intFilter) : 0;
auto binFilter__ = binFilter ? _fbb.CreateVector<::flatbuffers::Offset<BinSearchFilter>>(*binFilter) : 0;
auto attrId__ = attrId ? _fbb.CreateVector<uint16_t>(*attrId) : 0;
return CreateSearchRoomRequest(
_fbb,
option,
worldId,
lobbyId,
rangeFilter_startIndex,
rangeFilter_max,
flagFilter,
flagAttr,
intFilter__,
binFilter__,
attrId__);
}
struct SearchRoomResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef SearchRoomResponseBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_STARTINDEX = 4,
VT_TOTAL = 6,
VT_ROOMS = 8
};
uint32_t startIndex() const {
return GetField<uint32_t>(VT_STARTINDEX, 0);
}
uint32_t total() const {
return GetField<uint32_t>(VT_TOTAL, 0);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<RoomDataExternal>> *rooms() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<RoomDataExternal>> *>(VT_ROOMS);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_STARTINDEX, 4) &&
VerifyField<uint32_t>(verifier, VT_TOTAL, 4) &&
VerifyOffset(verifier, VT_ROOMS) &&
verifier.VerifyVector(rooms()) &&
verifier.VerifyVectorOfTables(rooms()) &&
verifier.EndTable();
}
};
struct SearchRoomResponseBuilder {
typedef SearchRoomResponse Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_startIndex(uint32_t startIndex) {
fbb_.AddElement<uint32_t>(SearchRoomResponse::VT_STARTINDEX, startIndex, 0);
}
void add_total(uint32_t total) {
fbb_.AddElement<uint32_t>(SearchRoomResponse::VT_TOTAL, total, 0);
}
void add_rooms(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomDataExternal>>> rooms) {
fbb_.AddOffset(SearchRoomResponse::VT_ROOMS, rooms);
}
explicit SearchRoomResponseBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<SearchRoomResponse> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<SearchRoomResponse>(end);
return o;
}
};
inline ::flatbuffers::Offset<SearchRoomResponse> CreateSearchRoomResponse(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t startIndex = 0,
uint32_t total = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomDataExternal>>> rooms = 0) {
SearchRoomResponseBuilder builder_(_fbb);
builder_.add_rooms(rooms);
builder_.add_total(total);
builder_.add_startIndex(startIndex);
return builder_.Finish();
}
inline ::flatbuffers::Offset<SearchRoomResponse> CreateSearchRoomResponseDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t startIndex = 0,
uint32_t total = 0,
const std::vector<::flatbuffers::Offset<RoomDataExternal>> *rooms = nullptr) {
auto rooms__ = rooms ? _fbb.CreateVector<::flatbuffers::Offset<RoomDataExternal>>(*rooms) : 0;
return CreateSearchRoomResponse(
_fbb,
startIndex,
total,
rooms__);
}
struct CreateJoinRoomRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef CreateJoinRoomRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_WORLDID = 4,
VT_LOBBYID = 6,
VT_MAXSLOT = 8,
VT_FLAGATTR = 10,
VT_ROOMBINATTRINTERNAL = 12,
VT_ROOMSEARCHABLEINTATTREXTERNAL = 14,
VT_ROOMSEARCHABLEBINATTREXTERNAL = 16,
VT_ROOMBINATTREXTERNAL = 18,
VT_ROOMPASSWORD = 20,
VT_GROUPCONFIG = 22,
VT_PASSWORDSLOTMASK = 24,
VT_ALLOWEDUSER = 26,
VT_BLOCKEDUSER = 28,
VT_JOINROOMGROUPLABEL = 30,
VT_ROOMMEMBERBINATTRINTERNAL = 32,
VT_TEAMID = 34,
VT_SIGOPTPARAM = 36
};
uint32_t worldId() const {
return GetField<uint32_t>(VT_WORLDID, 0);
}
uint64_t lobbyId() const {
return GetField<uint64_t>(VT_LOBBYID, 0);
}
uint32_t maxSlot() const {
return GetField<uint32_t>(VT_MAXSLOT, 0);
}
uint32_t flagAttr() const {
return GetField<uint32_t>(VT_FLAGATTR, 0);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *roomBinAttrInternal() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_ROOMBINATTRINTERNAL);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>> *roomSearchableIntAttrExternal() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>> *>(VT_ROOMSEARCHABLEINTATTREXTERNAL);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *roomSearchableBinAttrExternal() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_ROOMSEARCHABLEBINATTREXTERNAL);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *roomBinAttrExternal() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_ROOMBINATTREXTERNAL);
}
const ::flatbuffers::Vector<uint8_t> *roomPassword() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_ROOMPASSWORD);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<GroupConfig>> *groupConfig() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<GroupConfig>> *>(VT_GROUPCONFIG);
}
uint64_t passwordSlotMask() const {
return GetField<uint64_t>(VT_PASSWORDSLOTMASK, 0);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *allowedUser() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_ALLOWEDUSER);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *blockedUser() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_BLOCKEDUSER);
}
const ::flatbuffers::Vector<uint8_t> *joinRoomGroupLabel() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_JOINROOMGROUPLABEL);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *roomMemberBinAttrInternal() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_ROOMMEMBERBINATTRINTERNAL);
}
uint8_t teamId() const {
return GetField<uint8_t>(VT_TEAMID, 0);
}
const OptParam *sigOptParam() const {
return GetPointer<const OptParam *>(VT_SIGOPTPARAM);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_WORLDID, 4) &&
VerifyField<uint64_t>(verifier, VT_LOBBYID, 8) &&
VerifyField<uint32_t>(verifier, VT_MAXSLOT, 4) &&
VerifyField<uint32_t>(verifier, VT_FLAGATTR, 4) &&
VerifyOffset(verifier, VT_ROOMBINATTRINTERNAL) &&
verifier.VerifyVector(roomBinAttrInternal()) &&
verifier.VerifyVectorOfTables(roomBinAttrInternal()) &&
VerifyOffset(verifier, VT_ROOMSEARCHABLEINTATTREXTERNAL) &&
verifier.VerifyVector(roomSearchableIntAttrExternal()) &&
verifier.VerifyVectorOfTables(roomSearchableIntAttrExternal()) &&
VerifyOffset(verifier, VT_ROOMSEARCHABLEBINATTREXTERNAL) &&
verifier.VerifyVector(roomSearchableBinAttrExternal()) &&
verifier.VerifyVectorOfTables(roomSearchableBinAttrExternal()) &&
VerifyOffset(verifier, VT_ROOMBINATTREXTERNAL) &&
verifier.VerifyVector(roomBinAttrExternal()) &&
verifier.VerifyVectorOfTables(roomBinAttrExternal()) &&
VerifyOffset(verifier, VT_ROOMPASSWORD) &&
verifier.VerifyVector(roomPassword()) &&
VerifyOffset(verifier, VT_GROUPCONFIG) &&
verifier.VerifyVector(groupConfig()) &&
verifier.VerifyVectorOfTables(groupConfig()) &&
VerifyField<uint64_t>(verifier, VT_PASSWORDSLOTMASK, 8) &&
VerifyOffset(verifier, VT_ALLOWEDUSER) &&
verifier.VerifyVector(allowedUser()) &&
verifier.VerifyVectorOfStrings(allowedUser()) &&
VerifyOffset(verifier, VT_BLOCKEDUSER) &&
verifier.VerifyVector(blockedUser()) &&
verifier.VerifyVectorOfStrings(blockedUser()) &&
VerifyOffset(verifier, VT_JOINROOMGROUPLABEL) &&
verifier.VerifyVector(joinRoomGroupLabel()) &&
VerifyOffset(verifier, VT_ROOMMEMBERBINATTRINTERNAL) &&
verifier.VerifyVector(roomMemberBinAttrInternal()) &&
verifier.VerifyVectorOfTables(roomMemberBinAttrInternal()) &&
VerifyField<uint8_t>(verifier, VT_TEAMID, 1) &&
VerifyOffset(verifier, VT_SIGOPTPARAM) &&
verifier.VerifyTable(sigOptParam()) &&
verifier.EndTable();
}
};
struct CreateJoinRoomRequestBuilder {
typedef CreateJoinRoomRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_worldId(uint32_t worldId) {
fbb_.AddElement<uint32_t>(CreateJoinRoomRequest::VT_WORLDID, worldId, 0);
}
void add_lobbyId(uint64_t lobbyId) {
fbb_.AddElement<uint64_t>(CreateJoinRoomRequest::VT_LOBBYID, lobbyId, 0);
}
void add_maxSlot(uint32_t maxSlot) {
fbb_.AddElement<uint32_t>(CreateJoinRoomRequest::VT_MAXSLOT, maxSlot, 0);
}
void add_flagAttr(uint32_t flagAttr) {
fbb_.AddElement<uint32_t>(CreateJoinRoomRequest::VT_FLAGATTR, flagAttr, 0);
}
void add_roomBinAttrInternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomBinAttrInternal) {
fbb_.AddOffset(CreateJoinRoomRequest::VT_ROOMBINATTRINTERNAL, roomBinAttrInternal);
}
void add_roomSearchableIntAttrExternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>>> roomSearchableIntAttrExternal) {
fbb_.AddOffset(CreateJoinRoomRequest::VT_ROOMSEARCHABLEINTATTREXTERNAL, roomSearchableIntAttrExternal);
}
void add_roomSearchableBinAttrExternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomSearchableBinAttrExternal) {
fbb_.AddOffset(CreateJoinRoomRequest::VT_ROOMSEARCHABLEBINATTREXTERNAL, roomSearchableBinAttrExternal);
}
void add_roomBinAttrExternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomBinAttrExternal) {
fbb_.AddOffset(CreateJoinRoomRequest::VT_ROOMBINATTREXTERNAL, roomBinAttrExternal);
}
void add_roomPassword(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> roomPassword) {
fbb_.AddOffset(CreateJoinRoomRequest::VT_ROOMPASSWORD, roomPassword);
}
void add_groupConfig(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<GroupConfig>>> groupConfig) {
fbb_.AddOffset(CreateJoinRoomRequest::VT_GROUPCONFIG, groupConfig);
}
void add_passwordSlotMask(uint64_t passwordSlotMask) {
fbb_.AddElement<uint64_t>(CreateJoinRoomRequest::VT_PASSWORDSLOTMASK, passwordSlotMask, 0);
}
void add_allowedUser(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> allowedUser) {
fbb_.AddOffset(CreateJoinRoomRequest::VT_ALLOWEDUSER, allowedUser);
}
void add_blockedUser(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> blockedUser) {
fbb_.AddOffset(CreateJoinRoomRequest::VT_BLOCKEDUSER, blockedUser);
}
void add_joinRoomGroupLabel(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> joinRoomGroupLabel) {
fbb_.AddOffset(CreateJoinRoomRequest::VT_JOINROOMGROUPLABEL, joinRoomGroupLabel);
}
void add_roomMemberBinAttrInternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomMemberBinAttrInternal) {
fbb_.AddOffset(CreateJoinRoomRequest::VT_ROOMMEMBERBINATTRINTERNAL, roomMemberBinAttrInternal);
}
void add_teamId(uint8_t teamId) {
fbb_.AddElement<uint8_t>(CreateJoinRoomRequest::VT_TEAMID, teamId, 0);
}
void add_sigOptParam(::flatbuffers::Offset<OptParam> sigOptParam) {
fbb_.AddOffset(CreateJoinRoomRequest::VT_SIGOPTPARAM, sigOptParam);
}
explicit CreateJoinRoomRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<CreateJoinRoomRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<CreateJoinRoomRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<CreateJoinRoomRequest> CreateCreateJoinRoomRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t worldId = 0,
uint64_t lobbyId = 0,
uint32_t maxSlot = 0,
uint32_t flagAttr = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomBinAttrInternal = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>>> roomSearchableIntAttrExternal = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomSearchableBinAttrExternal = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomBinAttrExternal = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> roomPassword = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<GroupConfig>>> groupConfig = 0,
uint64_t passwordSlotMask = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> allowedUser = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> blockedUser = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> joinRoomGroupLabel = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomMemberBinAttrInternal = 0,
uint8_t teamId = 0,
::flatbuffers::Offset<OptParam> sigOptParam = 0) {
CreateJoinRoomRequestBuilder builder_(_fbb);
builder_.add_passwordSlotMask(passwordSlotMask);
builder_.add_lobbyId(lobbyId);
builder_.add_sigOptParam(sigOptParam);
builder_.add_roomMemberBinAttrInternal(roomMemberBinAttrInternal);
builder_.add_joinRoomGroupLabel(joinRoomGroupLabel);
builder_.add_blockedUser(blockedUser);
builder_.add_allowedUser(allowedUser);
builder_.add_groupConfig(groupConfig);
builder_.add_roomPassword(roomPassword);
builder_.add_roomBinAttrExternal(roomBinAttrExternal);
builder_.add_roomSearchableBinAttrExternal(roomSearchableBinAttrExternal);
builder_.add_roomSearchableIntAttrExternal(roomSearchableIntAttrExternal);
builder_.add_roomBinAttrInternal(roomBinAttrInternal);
builder_.add_flagAttr(flagAttr);
builder_.add_maxSlot(maxSlot);
builder_.add_worldId(worldId);
builder_.add_teamId(teamId);
return builder_.Finish();
}
inline ::flatbuffers::Offset<CreateJoinRoomRequest> CreateCreateJoinRoomRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t worldId = 0,
uint64_t lobbyId = 0,
uint32_t maxSlot = 0,
uint32_t flagAttr = 0,
const std::vector<::flatbuffers::Offset<BinAttr>> *roomBinAttrInternal = nullptr,
const std::vector<::flatbuffers::Offset<IntAttr>> *roomSearchableIntAttrExternal = nullptr,
const std::vector<::flatbuffers::Offset<BinAttr>> *roomSearchableBinAttrExternal = nullptr,
const std::vector<::flatbuffers::Offset<BinAttr>> *roomBinAttrExternal = nullptr,
const std::vector<uint8_t> *roomPassword = nullptr,
const std::vector<::flatbuffers::Offset<GroupConfig>> *groupConfig = nullptr,
uint64_t passwordSlotMask = 0,
const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *allowedUser = nullptr,
const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *blockedUser = nullptr,
const std::vector<uint8_t> *joinRoomGroupLabel = nullptr,
const std::vector<::flatbuffers::Offset<BinAttr>> *roomMemberBinAttrInternal = nullptr,
uint8_t teamId = 0,
::flatbuffers::Offset<OptParam> sigOptParam = 0) {
auto roomBinAttrInternal__ = roomBinAttrInternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*roomBinAttrInternal) : 0;
auto roomSearchableIntAttrExternal__ = roomSearchableIntAttrExternal ? _fbb.CreateVector<::flatbuffers::Offset<IntAttr>>(*roomSearchableIntAttrExternal) : 0;
auto roomSearchableBinAttrExternal__ = roomSearchableBinAttrExternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*roomSearchableBinAttrExternal) : 0;
auto roomBinAttrExternal__ = roomBinAttrExternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*roomBinAttrExternal) : 0;
auto roomPassword__ = roomPassword ? _fbb.CreateVector<uint8_t>(*roomPassword) : 0;
auto groupConfig__ = groupConfig ? _fbb.CreateVector<::flatbuffers::Offset<GroupConfig>>(*groupConfig) : 0;
auto allowedUser__ = allowedUser ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*allowedUser) : 0;
auto blockedUser__ = blockedUser ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*blockedUser) : 0;
auto joinRoomGroupLabel__ = joinRoomGroupLabel ? _fbb.CreateVector<uint8_t>(*joinRoomGroupLabel) : 0;
auto roomMemberBinAttrInternal__ = roomMemberBinAttrInternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*roomMemberBinAttrInternal) : 0;
return CreateCreateJoinRoomRequest(
_fbb,
worldId,
lobbyId,
maxSlot,
flagAttr,
roomBinAttrInternal__,
roomSearchableIntAttrExternal__,
roomSearchableBinAttrExternal__,
roomBinAttrExternal__,
roomPassword__,
groupConfig__,
passwordSlotMask,
allowedUser__,
blockedUser__,
joinRoomGroupLabel__,
roomMemberBinAttrInternal__,
teamId,
sigOptParam);
}
struct JoinRoomRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef JoinRoomRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ROOMID = 4,
VT_ROOMPASSWORD = 6,
VT_JOINROOMGROUPLABEL = 8,
VT_ROOMMEMBERBINATTRINTERNAL = 10,
VT_OPTDATA = 12,
VT_TEAMID = 14
};
uint64_t roomId() const {
return GetField<uint64_t>(VT_ROOMID, 0);
}
const ::flatbuffers::Vector<uint8_t> *roomPassword() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_ROOMPASSWORD);
}
const ::flatbuffers::Vector<uint8_t> *joinRoomGroupLabel() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_JOINROOMGROUPLABEL);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *roomMemberBinAttrInternal() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_ROOMMEMBERBINATTRINTERNAL);
}
const PresenceOptionData *optData() const {
return GetPointer<const PresenceOptionData *>(VT_OPTDATA);
}
uint8_t teamId() const {
return GetField<uint8_t>(VT_TEAMID, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
VerifyOffset(verifier, VT_ROOMPASSWORD) &&
verifier.VerifyVector(roomPassword()) &&
VerifyOffset(verifier, VT_JOINROOMGROUPLABEL) &&
verifier.VerifyVector(joinRoomGroupLabel()) &&
VerifyOffset(verifier, VT_ROOMMEMBERBINATTRINTERNAL) &&
verifier.VerifyVector(roomMemberBinAttrInternal()) &&
verifier.VerifyVectorOfTables(roomMemberBinAttrInternal()) &&
VerifyOffset(verifier, VT_OPTDATA) &&
verifier.VerifyTable(optData()) &&
VerifyField<uint8_t>(verifier, VT_TEAMID, 1) &&
verifier.EndTable();
}
};
struct JoinRoomRequestBuilder {
typedef JoinRoomRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_roomId(uint64_t roomId) {
fbb_.AddElement<uint64_t>(JoinRoomRequest::VT_ROOMID, roomId, 0);
}
void add_roomPassword(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> roomPassword) {
fbb_.AddOffset(JoinRoomRequest::VT_ROOMPASSWORD, roomPassword);
}
void add_joinRoomGroupLabel(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> joinRoomGroupLabel) {
fbb_.AddOffset(JoinRoomRequest::VT_JOINROOMGROUPLABEL, joinRoomGroupLabel);
}
void add_roomMemberBinAttrInternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomMemberBinAttrInternal) {
fbb_.AddOffset(JoinRoomRequest::VT_ROOMMEMBERBINATTRINTERNAL, roomMemberBinAttrInternal);
}
void add_optData(::flatbuffers::Offset<PresenceOptionData> optData) {
fbb_.AddOffset(JoinRoomRequest::VT_OPTDATA, optData);
}
void add_teamId(uint8_t teamId) {
fbb_.AddElement<uint8_t>(JoinRoomRequest::VT_TEAMID, teamId, 0);
}
explicit JoinRoomRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<JoinRoomRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<JoinRoomRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<JoinRoomRequest> CreateJoinRoomRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t roomId = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> roomPassword = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> joinRoomGroupLabel = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomMemberBinAttrInternal = 0,
::flatbuffers::Offset<PresenceOptionData> optData = 0,
uint8_t teamId = 0) {
JoinRoomRequestBuilder builder_(_fbb);
builder_.add_roomId(roomId);
builder_.add_optData(optData);
builder_.add_roomMemberBinAttrInternal(roomMemberBinAttrInternal);
builder_.add_joinRoomGroupLabel(joinRoomGroupLabel);
builder_.add_roomPassword(roomPassword);
builder_.add_teamId(teamId);
return builder_.Finish();
}
inline ::flatbuffers::Offset<JoinRoomRequest> CreateJoinRoomRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t roomId = 0,
const std::vector<uint8_t> *roomPassword = nullptr,
const std::vector<uint8_t> *joinRoomGroupLabel = nullptr,
const std::vector<::flatbuffers::Offset<BinAttr>> *roomMemberBinAttrInternal = nullptr,
::flatbuffers::Offset<PresenceOptionData> optData = 0,
uint8_t teamId = 0) {
auto roomPassword__ = roomPassword ? _fbb.CreateVector<uint8_t>(*roomPassword) : 0;
auto joinRoomGroupLabel__ = joinRoomGroupLabel ? _fbb.CreateVector<uint8_t>(*joinRoomGroupLabel) : 0;
auto roomMemberBinAttrInternal__ = roomMemberBinAttrInternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*roomMemberBinAttrInternal) : 0;
return CreateJoinRoomRequest(
_fbb,
roomId,
roomPassword__,
joinRoomGroupLabel__,
roomMemberBinAttrInternal__,
optData,
teamId);
}
struct LeaveRoomRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef LeaveRoomRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ROOMID = 4,
VT_OPTDATA = 6
};
uint64_t roomId() const {
return GetField<uint64_t>(VT_ROOMID, 0);
}
const PresenceOptionData *optData() const {
return GetPointer<const PresenceOptionData *>(VT_OPTDATA);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
VerifyOffset(verifier, VT_OPTDATA) &&
verifier.VerifyTable(optData()) &&
verifier.EndTable();
}
};
struct LeaveRoomRequestBuilder {
typedef LeaveRoomRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_roomId(uint64_t roomId) {
fbb_.AddElement<uint64_t>(LeaveRoomRequest::VT_ROOMID, roomId, 0);
}
void add_optData(::flatbuffers::Offset<PresenceOptionData> optData) {
fbb_.AddOffset(LeaveRoomRequest::VT_OPTDATA, optData);
}
explicit LeaveRoomRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<LeaveRoomRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<LeaveRoomRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<LeaveRoomRequest> CreateLeaveRoomRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t roomId = 0,
::flatbuffers::Offset<PresenceOptionData> optData = 0) {
LeaveRoomRequestBuilder builder_(_fbb);
builder_.add_roomId(roomId);
builder_.add_optData(optData);
return builder_.Finish();
}
struct GetRoomDataExternalListRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef GetRoomDataExternalListRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ROOMIDS = 4,
VT_ATTRIDS = 6
};
const ::flatbuffers::Vector<uint64_t> *roomIds() const {
return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_ROOMIDS);
}
const ::flatbuffers::Vector<uint16_t> *attrIds() const {
return GetPointer<const ::flatbuffers::Vector<uint16_t> *>(VT_ATTRIDS);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_ROOMIDS) &&
verifier.VerifyVector(roomIds()) &&
VerifyOffset(verifier, VT_ATTRIDS) &&
verifier.VerifyVector(attrIds()) &&
verifier.EndTable();
}
};
struct GetRoomDataExternalListRequestBuilder {
typedef GetRoomDataExternalListRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_roomIds(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> roomIds) {
fbb_.AddOffset(GetRoomDataExternalListRequest::VT_ROOMIDS, roomIds);
}
void add_attrIds(::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> attrIds) {
fbb_.AddOffset(GetRoomDataExternalListRequest::VT_ATTRIDS, attrIds);
}
explicit GetRoomDataExternalListRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<GetRoomDataExternalListRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<GetRoomDataExternalListRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<GetRoomDataExternalListRequest> CreateGetRoomDataExternalListRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> roomIds = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> attrIds = 0) {
GetRoomDataExternalListRequestBuilder builder_(_fbb);
builder_.add_attrIds(attrIds);
builder_.add_roomIds(roomIds);
return builder_.Finish();
}
inline ::flatbuffers::Offset<GetRoomDataExternalListRequest> CreateGetRoomDataExternalListRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint64_t> *roomIds = nullptr,
const std::vector<uint16_t> *attrIds = nullptr) {
auto roomIds__ = roomIds ? _fbb.CreateVector<uint64_t>(*roomIds) : 0;
auto attrIds__ = attrIds ? _fbb.CreateVector<uint16_t>(*attrIds) : 0;
return CreateGetRoomDataExternalListRequest(
_fbb,
roomIds__,
attrIds__);
}
struct GetRoomDataExternalListResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef GetRoomDataExternalListResponseBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ROOMS = 4
};
const ::flatbuffers::Vector<::flatbuffers::Offset<RoomDataExternal>> *rooms() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<RoomDataExternal>> *>(VT_ROOMS);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_ROOMS) &&
verifier.VerifyVector(rooms()) &&
verifier.VerifyVectorOfTables(rooms()) &&
verifier.EndTable();
}
};
struct GetRoomDataExternalListResponseBuilder {
typedef GetRoomDataExternalListResponse Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_rooms(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomDataExternal>>> rooms) {
fbb_.AddOffset(GetRoomDataExternalListResponse::VT_ROOMS, rooms);
}
explicit GetRoomDataExternalListResponseBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<GetRoomDataExternalListResponse> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<GetRoomDataExternalListResponse>(end);
return o;
}
};
inline ::flatbuffers::Offset<GetRoomDataExternalListResponse> CreateGetRoomDataExternalListResponse(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomDataExternal>>> rooms = 0) {
GetRoomDataExternalListResponseBuilder builder_(_fbb);
builder_.add_rooms(rooms);
return builder_.Finish();
}
inline ::flatbuffers::Offset<GetRoomDataExternalListResponse> CreateGetRoomDataExternalListResponseDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<::flatbuffers::Offset<RoomDataExternal>> *rooms = nullptr) {
auto rooms__ = rooms ? _fbb.CreateVector<::flatbuffers::Offset<RoomDataExternal>>(*rooms) : 0;
return CreateGetRoomDataExternalListResponse(
_fbb,
rooms__);
}
struct SetRoomDataExternalRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef SetRoomDataExternalRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ROOMID = 4,
VT_ROOMSEARCHABLEINTATTREXTERNAL = 6,
VT_ROOMSEARCHABLEBINATTREXTERNAL = 8,
VT_ROOMBINATTREXTERNAL = 10
};
uint64_t roomId() const {
return GetField<uint64_t>(VT_ROOMID, 0);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>> *roomSearchableIntAttrExternal() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>> *>(VT_ROOMSEARCHABLEINTATTREXTERNAL);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *roomSearchableBinAttrExternal() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_ROOMSEARCHABLEBINATTREXTERNAL);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *roomBinAttrExternal() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_ROOMBINATTREXTERNAL);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
VerifyOffset(verifier, VT_ROOMSEARCHABLEINTATTREXTERNAL) &&
verifier.VerifyVector(roomSearchableIntAttrExternal()) &&
verifier.VerifyVectorOfTables(roomSearchableIntAttrExternal()) &&
VerifyOffset(verifier, VT_ROOMSEARCHABLEBINATTREXTERNAL) &&
verifier.VerifyVector(roomSearchableBinAttrExternal()) &&
verifier.VerifyVectorOfTables(roomSearchableBinAttrExternal()) &&
VerifyOffset(verifier, VT_ROOMBINATTREXTERNAL) &&
verifier.VerifyVector(roomBinAttrExternal()) &&
verifier.VerifyVectorOfTables(roomBinAttrExternal()) &&
verifier.EndTable();
}
};
struct SetRoomDataExternalRequestBuilder {
typedef SetRoomDataExternalRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_roomId(uint64_t roomId) {
fbb_.AddElement<uint64_t>(SetRoomDataExternalRequest::VT_ROOMID, roomId, 0);
}
void add_roomSearchableIntAttrExternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>>> roomSearchableIntAttrExternal) {
fbb_.AddOffset(SetRoomDataExternalRequest::VT_ROOMSEARCHABLEINTATTREXTERNAL, roomSearchableIntAttrExternal);
}
void add_roomSearchableBinAttrExternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomSearchableBinAttrExternal) {
fbb_.AddOffset(SetRoomDataExternalRequest::VT_ROOMSEARCHABLEBINATTREXTERNAL, roomSearchableBinAttrExternal);
}
void add_roomBinAttrExternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomBinAttrExternal) {
fbb_.AddOffset(SetRoomDataExternalRequest::VT_ROOMBINATTREXTERNAL, roomBinAttrExternal);
}
explicit SetRoomDataExternalRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<SetRoomDataExternalRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<SetRoomDataExternalRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<SetRoomDataExternalRequest> CreateSetRoomDataExternalRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t roomId = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>>> roomSearchableIntAttrExternal = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomSearchableBinAttrExternal = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomBinAttrExternal = 0) {
SetRoomDataExternalRequestBuilder builder_(_fbb);
builder_.add_roomId(roomId);
builder_.add_roomBinAttrExternal(roomBinAttrExternal);
builder_.add_roomSearchableBinAttrExternal(roomSearchableBinAttrExternal);
builder_.add_roomSearchableIntAttrExternal(roomSearchableIntAttrExternal);
return builder_.Finish();
}
inline ::flatbuffers::Offset<SetRoomDataExternalRequest> CreateSetRoomDataExternalRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t roomId = 0,
const std::vector<::flatbuffers::Offset<IntAttr>> *roomSearchableIntAttrExternal = nullptr,
const std::vector<::flatbuffers::Offset<BinAttr>> *roomSearchableBinAttrExternal = nullptr,
const std::vector<::flatbuffers::Offset<BinAttr>> *roomBinAttrExternal = nullptr) {
auto roomSearchableIntAttrExternal__ = roomSearchableIntAttrExternal ? _fbb.CreateVector<::flatbuffers::Offset<IntAttr>>(*roomSearchableIntAttrExternal) : 0;
auto roomSearchableBinAttrExternal__ = roomSearchableBinAttrExternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*roomSearchableBinAttrExternal) : 0;
auto roomBinAttrExternal__ = roomBinAttrExternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*roomBinAttrExternal) : 0;
return CreateSetRoomDataExternalRequest(
_fbb,
roomId,
roomSearchableIntAttrExternal__,
roomSearchableBinAttrExternal__,
roomBinAttrExternal__);
}
struct SetRoomDataInternalRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef SetRoomDataInternalRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ROOMID = 4,
VT_FLAGFILTER = 6,
VT_FLAGATTR = 8,
VT_ROOMBINATTRINTERNAL = 10,
VT_PASSWORDCONFIG = 12,
VT_PASSWORDSLOTMASK = 14,
VT_OWNERPRIVILEGERANK = 16
};
uint64_t roomId() const {
return GetField<uint64_t>(VT_ROOMID, 0);
}
uint32_t flagFilter() const {
return GetField<uint32_t>(VT_FLAGFILTER, 0);
}
uint32_t flagAttr() const {
return GetField<uint32_t>(VT_FLAGATTR, 0);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *roomBinAttrInternal() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_ROOMBINATTRINTERNAL);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<RoomGroupPasswordConfig>> *passwordConfig() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<RoomGroupPasswordConfig>> *>(VT_PASSWORDCONFIG);
}
uint64_t passwordSlotMask() const {
return GetField<uint64_t>(VT_PASSWORDSLOTMASK, 0);
}
const ::flatbuffers::Vector<uint16_t> *ownerPrivilegeRank() const {
return GetPointer<const ::flatbuffers::Vector<uint16_t> *>(VT_OWNERPRIVILEGERANK);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
VerifyField<uint32_t>(verifier, VT_FLAGFILTER, 4) &&
VerifyField<uint32_t>(verifier, VT_FLAGATTR, 4) &&
VerifyOffset(verifier, VT_ROOMBINATTRINTERNAL) &&
verifier.VerifyVector(roomBinAttrInternal()) &&
verifier.VerifyVectorOfTables(roomBinAttrInternal()) &&
VerifyOffset(verifier, VT_PASSWORDCONFIG) &&
verifier.VerifyVector(passwordConfig()) &&
verifier.VerifyVectorOfTables(passwordConfig()) &&
VerifyField<uint64_t>(verifier, VT_PASSWORDSLOTMASK, 8) &&
VerifyOffset(verifier, VT_OWNERPRIVILEGERANK) &&
verifier.VerifyVector(ownerPrivilegeRank()) &&
verifier.EndTable();
}
};
struct SetRoomDataInternalRequestBuilder {
typedef SetRoomDataInternalRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_roomId(uint64_t roomId) {
fbb_.AddElement<uint64_t>(SetRoomDataInternalRequest::VT_ROOMID, roomId, 0);
}
void add_flagFilter(uint32_t flagFilter) {
fbb_.AddElement<uint32_t>(SetRoomDataInternalRequest::VT_FLAGFILTER, flagFilter, 0);
}
void add_flagAttr(uint32_t flagAttr) {
fbb_.AddElement<uint32_t>(SetRoomDataInternalRequest::VT_FLAGATTR, flagAttr, 0);
}
void add_roomBinAttrInternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomBinAttrInternal) {
fbb_.AddOffset(SetRoomDataInternalRequest::VT_ROOMBINATTRINTERNAL, roomBinAttrInternal);
}
void add_passwordConfig(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomGroupPasswordConfig>>> passwordConfig) {
fbb_.AddOffset(SetRoomDataInternalRequest::VT_PASSWORDCONFIG, passwordConfig);
}
void add_passwordSlotMask(uint64_t passwordSlotMask) {
fbb_.AddElement<uint64_t>(SetRoomDataInternalRequest::VT_PASSWORDSLOTMASK, passwordSlotMask, 0);
}
void add_ownerPrivilegeRank(::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> ownerPrivilegeRank) {
fbb_.AddOffset(SetRoomDataInternalRequest::VT_OWNERPRIVILEGERANK, ownerPrivilegeRank);
}
explicit SetRoomDataInternalRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<SetRoomDataInternalRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<SetRoomDataInternalRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<SetRoomDataInternalRequest> CreateSetRoomDataInternalRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t roomId = 0,
uint32_t flagFilter = 0,
uint32_t flagAttr = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomBinAttrInternal = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomGroupPasswordConfig>>> passwordConfig = 0,
uint64_t passwordSlotMask = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> ownerPrivilegeRank = 0) {
SetRoomDataInternalRequestBuilder builder_(_fbb);
builder_.add_passwordSlotMask(passwordSlotMask);
builder_.add_roomId(roomId);
builder_.add_ownerPrivilegeRank(ownerPrivilegeRank);
builder_.add_passwordConfig(passwordConfig);
builder_.add_roomBinAttrInternal(roomBinAttrInternal);
builder_.add_flagAttr(flagAttr);
builder_.add_flagFilter(flagFilter);
return builder_.Finish();
}
inline ::flatbuffers::Offset<SetRoomDataInternalRequest> CreateSetRoomDataInternalRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t roomId = 0,
uint32_t flagFilter = 0,
uint32_t flagAttr = 0,
const std::vector<::flatbuffers::Offset<BinAttr>> *roomBinAttrInternal = nullptr,
const std::vector<::flatbuffers::Offset<RoomGroupPasswordConfig>> *passwordConfig = nullptr,
uint64_t passwordSlotMask = 0,
const std::vector<uint16_t> *ownerPrivilegeRank = nullptr) {
auto roomBinAttrInternal__ = roomBinAttrInternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*roomBinAttrInternal) : 0;
auto passwordConfig__ = passwordConfig ? _fbb.CreateVector<::flatbuffers::Offset<RoomGroupPasswordConfig>>(*passwordConfig) : 0;
auto ownerPrivilegeRank__ = ownerPrivilegeRank ? _fbb.CreateVector<uint16_t>(*ownerPrivilegeRank) : 0;
return CreateSetRoomDataInternalRequest(
_fbb,
roomId,
flagFilter,
flagAttr,
roomBinAttrInternal__,
passwordConfig__,
passwordSlotMask,
ownerPrivilegeRank__);
}
struct GetRoomMemberDataInternalRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef GetRoomMemberDataInternalRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ROOMID = 4,
VT_MEMBERID = 6,
VT_ATTRID = 8
};
uint64_t roomId() const {
return GetField<uint64_t>(VT_ROOMID, 0);
}
uint16_t memberId() const {
return GetField<uint16_t>(VT_MEMBERID, 0);
}
const ::flatbuffers::Vector<uint16_t> *attrId() const {
return GetPointer<const ::flatbuffers::Vector<uint16_t> *>(VT_ATTRID);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
VerifyField<uint16_t>(verifier, VT_MEMBERID, 2) &&
VerifyOffset(verifier, VT_ATTRID) &&
verifier.VerifyVector(attrId()) &&
verifier.EndTable();
}
};
struct GetRoomMemberDataInternalRequestBuilder {
typedef GetRoomMemberDataInternalRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_roomId(uint64_t roomId) {
fbb_.AddElement<uint64_t>(GetRoomMemberDataInternalRequest::VT_ROOMID, roomId, 0);
}
void add_memberId(uint16_t memberId) {
fbb_.AddElement<uint16_t>(GetRoomMemberDataInternalRequest::VT_MEMBERID, memberId, 0);
}
void add_attrId(::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> attrId) {
fbb_.AddOffset(GetRoomMemberDataInternalRequest::VT_ATTRID, attrId);
}
explicit GetRoomMemberDataInternalRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<GetRoomMemberDataInternalRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<GetRoomMemberDataInternalRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<GetRoomMemberDataInternalRequest> CreateGetRoomMemberDataInternalRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t roomId = 0,
uint16_t memberId = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> attrId = 0) {
GetRoomMemberDataInternalRequestBuilder builder_(_fbb);
builder_.add_roomId(roomId);
builder_.add_attrId(attrId);
builder_.add_memberId(memberId);
return builder_.Finish();
}
inline ::flatbuffers::Offset<GetRoomMemberDataInternalRequest> CreateGetRoomMemberDataInternalRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t roomId = 0,
uint16_t memberId = 0,
const std::vector<uint16_t> *attrId = nullptr) {
auto attrId__ = attrId ? _fbb.CreateVector<uint16_t>(*attrId) : 0;
return CreateGetRoomMemberDataInternalRequest(
_fbb,
roomId,
memberId,
attrId__);
}
struct SetRoomMemberDataInternalRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef SetRoomMemberDataInternalRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ROOMID = 4,
VT_MEMBERID = 6,
VT_TEAMID = 8,
VT_ROOMMEMBERBINATTRINTERNAL = 10
};
uint64_t roomId() const {
return GetField<uint64_t>(VT_ROOMID, 0);
}
uint16_t memberId() const {
return GetField<uint16_t>(VT_MEMBERID, 0);
}
uint8_t teamId() const {
return GetField<uint8_t>(VT_TEAMID, 0);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *roomMemberBinAttrInternal() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_ROOMMEMBERBINATTRINTERNAL);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
VerifyField<uint16_t>(verifier, VT_MEMBERID, 2) &&
VerifyField<uint8_t>(verifier, VT_TEAMID, 1) &&
VerifyOffset(verifier, VT_ROOMMEMBERBINATTRINTERNAL) &&
verifier.VerifyVector(roomMemberBinAttrInternal()) &&
verifier.VerifyVectorOfTables(roomMemberBinAttrInternal()) &&
verifier.EndTable();
}
};
struct SetRoomMemberDataInternalRequestBuilder {
typedef SetRoomMemberDataInternalRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_roomId(uint64_t roomId) {
fbb_.AddElement<uint64_t>(SetRoomMemberDataInternalRequest::VT_ROOMID, roomId, 0);
}
void add_memberId(uint16_t memberId) {
fbb_.AddElement<uint16_t>(SetRoomMemberDataInternalRequest::VT_MEMBERID, memberId, 0);
}
void add_teamId(uint8_t teamId) {
fbb_.AddElement<uint8_t>(SetRoomMemberDataInternalRequest::VT_TEAMID, teamId, 0);
}
void add_roomMemberBinAttrInternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomMemberBinAttrInternal) {
fbb_.AddOffset(SetRoomMemberDataInternalRequest::VT_ROOMMEMBERBINATTRINTERNAL, roomMemberBinAttrInternal);
}
explicit SetRoomMemberDataInternalRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<SetRoomMemberDataInternalRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<SetRoomMemberDataInternalRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<SetRoomMemberDataInternalRequest> CreateSetRoomMemberDataInternalRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t roomId = 0,
uint16_t memberId = 0,
uint8_t teamId = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomMemberBinAttrInternal = 0) {
SetRoomMemberDataInternalRequestBuilder builder_(_fbb);
builder_.add_roomId(roomId);
builder_.add_roomMemberBinAttrInternal(roomMemberBinAttrInternal);
builder_.add_memberId(memberId);
builder_.add_teamId(teamId);
return builder_.Finish();
}
inline ::flatbuffers::Offset<SetRoomMemberDataInternalRequest> CreateSetRoomMemberDataInternalRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t roomId = 0,
uint16_t memberId = 0,
uint8_t teamId = 0,
const std::vector<::flatbuffers::Offset<BinAttr>> *roomMemberBinAttrInternal = nullptr) {
auto roomMemberBinAttrInternal__ = roomMemberBinAttrInternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*roomMemberBinAttrInternal) : 0;
return CreateSetRoomMemberDataInternalRequest(
_fbb,
roomId,
memberId,
teamId,
roomMemberBinAttrInternal__);
}
struct SetUserInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef SetUserInfoBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SERVERID = 4,
VT_USERBINATTR = 6
};
uint16_t serverId() const {
return GetField<uint16_t>(VT_SERVERID, 0);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *userBinAttr() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_USERBINATTR);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint16_t>(verifier, VT_SERVERID, 2) &&
VerifyOffset(verifier, VT_USERBINATTR) &&
verifier.VerifyVector(userBinAttr()) &&
verifier.VerifyVectorOfTables(userBinAttr()) &&
verifier.EndTable();
}
};
struct SetUserInfoBuilder {
typedef SetUserInfo Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_serverId(uint16_t serverId) {
fbb_.AddElement<uint16_t>(SetUserInfo::VT_SERVERID, serverId, 0);
}
void add_userBinAttr(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> userBinAttr) {
fbb_.AddOffset(SetUserInfo::VT_USERBINATTR, userBinAttr);
}
explicit SetUserInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<SetUserInfo> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<SetUserInfo>(end);
return o;
}
};
inline ::flatbuffers::Offset<SetUserInfo> CreateSetUserInfo(
::flatbuffers::FlatBufferBuilder &_fbb,
uint16_t serverId = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> userBinAttr = 0) {
SetUserInfoBuilder builder_(_fbb);
builder_.add_userBinAttr(userBinAttr);
builder_.add_serverId(serverId);
return builder_.Finish();
}
inline ::flatbuffers::Offset<SetUserInfo> CreateSetUserInfoDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint16_t serverId = 0,
const std::vector<::flatbuffers::Offset<BinAttr>> *userBinAttr = nullptr) {
auto userBinAttr__ = userBinAttr ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*userBinAttr) : 0;
return CreateSetUserInfo(
_fbb,
serverId,
userBinAttr__);
}
struct GetRoomDataInternalRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef GetRoomDataInternalRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ROOMID = 4,
VT_ATTRID = 6
};
uint64_t roomId() const {
return GetField<uint64_t>(VT_ROOMID, 0);
}
const ::flatbuffers::Vector<uint16_t> *attrId() const {
return GetPointer<const ::flatbuffers::Vector<uint16_t> *>(VT_ATTRID);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
VerifyOffset(verifier, VT_ATTRID) &&
verifier.VerifyVector(attrId()) &&
verifier.EndTable();
}
};
struct GetRoomDataInternalRequestBuilder {
typedef GetRoomDataInternalRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_roomId(uint64_t roomId) {
fbb_.AddElement<uint64_t>(GetRoomDataInternalRequest::VT_ROOMID, roomId, 0);
}
void add_attrId(::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> attrId) {
fbb_.AddOffset(GetRoomDataInternalRequest::VT_ATTRID, attrId);
}
explicit GetRoomDataInternalRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<GetRoomDataInternalRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<GetRoomDataInternalRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<GetRoomDataInternalRequest> CreateGetRoomDataInternalRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t roomId = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> attrId = 0) {
GetRoomDataInternalRequestBuilder builder_(_fbb);
builder_.add_roomId(roomId);
builder_.add_attrId(attrId);
return builder_.Finish();
}
inline ::flatbuffers::Offset<GetRoomDataInternalRequest> CreateGetRoomDataInternalRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t roomId = 0,
const std::vector<uint16_t> *attrId = nullptr) {
auto attrId__ = attrId ? _fbb.CreateVector<uint16_t>(*attrId) : 0;
return CreateGetRoomDataInternalRequest(
_fbb,
roomId,
attrId__);
}
struct RoomMemberUpdateInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef RoomMemberUpdateInfoBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ROOMMEMBERDATAINTERNAL = 4,
VT_EVENTCAUSE = 6,
VT_OPTDATA = 8
};
const RoomMemberDataInternal *roomMemberDataInternal() const {
return GetPointer<const RoomMemberDataInternal *>(VT_ROOMMEMBERDATAINTERNAL);
}
uint8_t eventCause() const {
return GetField<uint8_t>(VT_EVENTCAUSE, 0);
}
const PresenceOptionData *optData() const {
return GetPointer<const PresenceOptionData *>(VT_OPTDATA);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_ROOMMEMBERDATAINTERNAL) &&
verifier.VerifyTable(roomMemberDataInternal()) &&
VerifyField<uint8_t>(verifier, VT_EVENTCAUSE, 1) &&
VerifyOffset(verifier, VT_OPTDATA) &&
verifier.VerifyTable(optData()) &&
verifier.EndTable();
}
};
struct RoomMemberUpdateInfoBuilder {
typedef RoomMemberUpdateInfo Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_roomMemberDataInternal(::flatbuffers::Offset<RoomMemberDataInternal> roomMemberDataInternal) {
fbb_.AddOffset(RoomMemberUpdateInfo::VT_ROOMMEMBERDATAINTERNAL, roomMemberDataInternal);
}
void add_eventCause(uint8_t eventCause) {
fbb_.AddElement<uint8_t>(RoomMemberUpdateInfo::VT_EVENTCAUSE, eventCause, 0);
}
void add_optData(::flatbuffers::Offset<PresenceOptionData> optData) {
fbb_.AddOffset(RoomMemberUpdateInfo::VT_OPTDATA, optData);
}
explicit RoomMemberUpdateInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<RoomMemberUpdateInfo> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<RoomMemberUpdateInfo>(end);
return o;
}
};
inline ::flatbuffers::Offset<RoomMemberUpdateInfo> CreateRoomMemberUpdateInfo(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<RoomMemberDataInternal> roomMemberDataInternal = 0,
uint8_t eventCause = 0,
::flatbuffers::Offset<PresenceOptionData> optData = 0) {
RoomMemberUpdateInfoBuilder builder_(_fbb);
builder_.add_optData(optData);
builder_.add_roomMemberDataInternal(roomMemberDataInternal);
builder_.add_eventCause(eventCause);
return builder_.Finish();
}
struct RoomUpdateInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef RoomUpdateInfoBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_EVENTCAUSE = 4,
VT_ERRORCODE = 6,
VT_OPTDATA = 8
};
uint8_t eventCause() const {
return GetField<uint8_t>(VT_EVENTCAUSE, 0);
}
int32_t errorCode() const {
return GetField<int32_t>(VT_ERRORCODE, 0);
}
const PresenceOptionData *optData() const {
return GetPointer<const PresenceOptionData *>(VT_OPTDATA);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_EVENTCAUSE, 1) &&
VerifyField<int32_t>(verifier, VT_ERRORCODE, 4) &&
VerifyOffset(verifier, VT_OPTDATA) &&
verifier.VerifyTable(optData()) &&
verifier.EndTable();
}
};
struct RoomUpdateInfoBuilder {
typedef RoomUpdateInfo Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_eventCause(uint8_t eventCause) {
fbb_.AddElement<uint8_t>(RoomUpdateInfo::VT_EVENTCAUSE, eventCause, 0);
}
void add_errorCode(int32_t errorCode) {
fbb_.AddElement<int32_t>(RoomUpdateInfo::VT_ERRORCODE, errorCode, 0);
}
void add_optData(::flatbuffers::Offset<PresenceOptionData> optData) {
fbb_.AddOffset(RoomUpdateInfo::VT_OPTDATA, optData);
}
explicit RoomUpdateInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<RoomUpdateInfo> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<RoomUpdateInfo>(end);
return o;
}
};
inline ::flatbuffers::Offset<RoomUpdateInfo> CreateRoomUpdateInfo(
::flatbuffers::FlatBufferBuilder &_fbb,
uint8_t eventCause = 0,
int32_t errorCode = 0,
::flatbuffers::Offset<PresenceOptionData> optData = 0) {
RoomUpdateInfoBuilder builder_(_fbb);
builder_.add_optData(optData);
builder_.add_errorCode(errorCode);
builder_.add_eventCause(eventCause);
return builder_.Finish();
}
struct RoomDataInternalUpdateInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef RoomDataInternalUpdateInfoBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NEWROOMDATAINTERNAL = 4,
VT_PREVFLAGATTR = 6,
VT_PREVROOMPASSWORDSLOTMASK = 8,
VT_NEWROOMGROUP = 10,
VT_NEWROOMBINATTRINTERNAL = 12
};
const RoomDataInternal *newRoomDataInternal() const {
return GetPointer<const RoomDataInternal *>(VT_NEWROOMDATAINTERNAL);
}
uint32_t prevFlagAttr() const {
return GetField<uint32_t>(VT_PREVFLAGATTR, 0);
}
uint64_t prevRoomPasswordSlotMask() const {
return GetField<uint64_t>(VT_PREVROOMPASSWORDSLOTMASK, 0);
}
const ::flatbuffers::Vector<uint8_t> *newRoomGroup() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_NEWROOMGROUP);
}
const ::flatbuffers::Vector<uint16_t> *newRoomBinAttrInternal() const {
return GetPointer<const ::flatbuffers::Vector<uint16_t> *>(VT_NEWROOMBINATTRINTERNAL);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_NEWROOMDATAINTERNAL) &&
verifier.VerifyTable(newRoomDataInternal()) &&
VerifyField<uint32_t>(verifier, VT_PREVFLAGATTR, 4) &&
VerifyField<uint64_t>(verifier, VT_PREVROOMPASSWORDSLOTMASK, 8) &&
VerifyOffset(verifier, VT_NEWROOMGROUP) &&
verifier.VerifyVector(newRoomGroup()) &&
VerifyOffset(verifier, VT_NEWROOMBINATTRINTERNAL) &&
verifier.VerifyVector(newRoomBinAttrInternal()) &&
verifier.EndTable();
}
};
struct RoomDataInternalUpdateInfoBuilder {
typedef RoomDataInternalUpdateInfo Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_newRoomDataInternal(::flatbuffers::Offset<RoomDataInternal> newRoomDataInternal) {
fbb_.AddOffset(RoomDataInternalUpdateInfo::VT_NEWROOMDATAINTERNAL, newRoomDataInternal);
}
void add_prevFlagAttr(uint32_t prevFlagAttr) {
fbb_.AddElement<uint32_t>(RoomDataInternalUpdateInfo::VT_PREVFLAGATTR, prevFlagAttr, 0);
}
void add_prevRoomPasswordSlotMask(uint64_t prevRoomPasswordSlotMask) {
fbb_.AddElement<uint64_t>(RoomDataInternalUpdateInfo::VT_PREVROOMPASSWORDSLOTMASK, prevRoomPasswordSlotMask, 0);
}
void add_newRoomGroup(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> newRoomGroup) {
fbb_.AddOffset(RoomDataInternalUpdateInfo::VT_NEWROOMGROUP, newRoomGroup);
}
void add_newRoomBinAttrInternal(::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> newRoomBinAttrInternal) {
fbb_.AddOffset(RoomDataInternalUpdateInfo::VT_NEWROOMBINATTRINTERNAL, newRoomBinAttrInternal);
}
explicit RoomDataInternalUpdateInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<RoomDataInternalUpdateInfo> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<RoomDataInternalUpdateInfo>(end);
return o;
}
};
inline ::flatbuffers::Offset<RoomDataInternalUpdateInfo> CreateRoomDataInternalUpdateInfo(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<RoomDataInternal> newRoomDataInternal = 0,
uint32_t prevFlagAttr = 0,
uint64_t prevRoomPasswordSlotMask = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> newRoomGroup = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> newRoomBinAttrInternal = 0) {
RoomDataInternalUpdateInfoBuilder builder_(_fbb);
builder_.add_prevRoomPasswordSlotMask(prevRoomPasswordSlotMask);
builder_.add_newRoomBinAttrInternal(newRoomBinAttrInternal);
builder_.add_newRoomGroup(newRoomGroup);
builder_.add_prevFlagAttr(prevFlagAttr);
builder_.add_newRoomDataInternal(newRoomDataInternal);
return builder_.Finish();
}
inline ::flatbuffers::Offset<RoomDataInternalUpdateInfo> CreateRoomDataInternalUpdateInfoDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<RoomDataInternal> newRoomDataInternal = 0,
uint32_t prevFlagAttr = 0,
uint64_t prevRoomPasswordSlotMask = 0,
const std::vector<uint8_t> *newRoomGroup = nullptr,
const std::vector<uint16_t> *newRoomBinAttrInternal = nullptr) {
auto newRoomGroup__ = newRoomGroup ? _fbb.CreateVector<uint8_t>(*newRoomGroup) : 0;
auto newRoomBinAttrInternal__ = newRoomBinAttrInternal ? _fbb.CreateVector<uint16_t>(*newRoomBinAttrInternal) : 0;
return CreateRoomDataInternalUpdateInfo(
_fbb,
newRoomDataInternal,
prevFlagAttr,
prevRoomPasswordSlotMask,
newRoomGroup__,
newRoomBinAttrInternal__);
}
struct RoomMemberDataInternalUpdateInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef RoomMemberDataInternalUpdateInfoBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NEWROOMMEMBERDATAINTERNAL = 4,
VT_PREVFLAGATTR = 6,
VT_PREVTEAMID = 8,
VT_NEWROOMMEMBERBINATTRINTERNAL = 10
};
const RoomMemberDataInternal *newRoomMemberDataInternal() const {
return GetPointer<const RoomMemberDataInternal *>(VT_NEWROOMMEMBERDATAINTERNAL);
}
uint32_t prevFlagAttr() const {
return GetField<uint32_t>(VT_PREVFLAGATTR, 0);
}
uint8_t prevTeamId() const {
return GetField<uint8_t>(VT_PREVTEAMID, 0);
}
const ::flatbuffers::Vector<uint16_t> *newRoomMemberBinAttrInternal() const {
return GetPointer<const ::flatbuffers::Vector<uint16_t> *>(VT_NEWROOMMEMBERBINATTRINTERNAL);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_NEWROOMMEMBERDATAINTERNAL) &&
verifier.VerifyTable(newRoomMemberDataInternal()) &&
VerifyField<uint32_t>(verifier, VT_PREVFLAGATTR, 4) &&
VerifyField<uint8_t>(verifier, VT_PREVTEAMID, 1) &&
VerifyOffset(verifier, VT_NEWROOMMEMBERBINATTRINTERNAL) &&
verifier.VerifyVector(newRoomMemberBinAttrInternal()) &&
verifier.EndTable();
}
};
struct RoomMemberDataInternalUpdateInfoBuilder {
typedef RoomMemberDataInternalUpdateInfo Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_newRoomMemberDataInternal(::flatbuffers::Offset<RoomMemberDataInternal> newRoomMemberDataInternal) {
fbb_.AddOffset(RoomMemberDataInternalUpdateInfo::VT_NEWROOMMEMBERDATAINTERNAL, newRoomMemberDataInternal);
}
void add_prevFlagAttr(uint32_t prevFlagAttr) {
fbb_.AddElement<uint32_t>(RoomMemberDataInternalUpdateInfo::VT_PREVFLAGATTR, prevFlagAttr, 0);
}
void add_prevTeamId(uint8_t prevTeamId) {
fbb_.AddElement<uint8_t>(RoomMemberDataInternalUpdateInfo::VT_PREVTEAMID, prevTeamId, 0);
}
void add_newRoomMemberBinAttrInternal(::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> newRoomMemberBinAttrInternal) {
fbb_.AddOffset(RoomMemberDataInternalUpdateInfo::VT_NEWROOMMEMBERBINATTRINTERNAL, newRoomMemberBinAttrInternal);
}
explicit RoomMemberDataInternalUpdateInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<RoomMemberDataInternalUpdateInfo> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<RoomMemberDataInternalUpdateInfo>(end);
return o;
}
};
inline ::flatbuffers::Offset<RoomMemberDataInternalUpdateInfo> CreateRoomMemberDataInternalUpdateInfo(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<RoomMemberDataInternal> newRoomMemberDataInternal = 0,
uint32_t prevFlagAttr = 0,
uint8_t prevTeamId = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> newRoomMemberBinAttrInternal = 0) {
RoomMemberDataInternalUpdateInfoBuilder builder_(_fbb);
builder_.add_newRoomMemberBinAttrInternal(newRoomMemberBinAttrInternal);
builder_.add_prevFlagAttr(prevFlagAttr);
builder_.add_newRoomMemberDataInternal(newRoomMemberDataInternal);
builder_.add_prevTeamId(prevTeamId);
return builder_.Finish();
}
inline ::flatbuffers::Offset<RoomMemberDataInternalUpdateInfo> CreateRoomMemberDataInternalUpdateInfoDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<RoomMemberDataInternal> newRoomMemberDataInternal = 0,
uint32_t prevFlagAttr = 0,
uint8_t prevTeamId = 0,
const std::vector<uint16_t> *newRoomMemberBinAttrInternal = nullptr) {
auto newRoomMemberBinAttrInternal__ = newRoomMemberBinAttrInternal ? _fbb.CreateVector<uint16_t>(*newRoomMemberBinAttrInternal) : 0;
return CreateRoomMemberDataInternalUpdateInfo(
_fbb,
newRoomMemberDataInternal,
prevFlagAttr,
prevTeamId,
newRoomMemberBinAttrInternal__);
}
struct GetPingInfoResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef GetPingInfoResponseBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SERVERID = 4,
VT_WORLDID = 6,
VT_ROOMID = 8,
VT_RTT = 10
};
uint16_t serverId() const {
return GetField<uint16_t>(VT_SERVERID, 0);
}
uint32_t worldId() const {
return GetField<uint32_t>(VT_WORLDID, 0);
}
uint64_t roomId() const {
return GetField<uint64_t>(VT_ROOMID, 0);
}
uint32_t rtt() const {
return GetField<uint32_t>(VT_RTT, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint16_t>(verifier, VT_SERVERID, 2) &&
VerifyField<uint32_t>(verifier, VT_WORLDID, 4) &&
VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
VerifyField<uint32_t>(verifier, VT_RTT, 4) &&
verifier.EndTable();
}
};
struct GetPingInfoResponseBuilder {
typedef GetPingInfoResponse Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_serverId(uint16_t serverId) {
fbb_.AddElement<uint16_t>(GetPingInfoResponse::VT_SERVERID, serverId, 0);
}
void add_worldId(uint32_t worldId) {
fbb_.AddElement<uint32_t>(GetPingInfoResponse::VT_WORLDID, worldId, 0);
}
void add_roomId(uint64_t roomId) {
fbb_.AddElement<uint64_t>(GetPingInfoResponse::VT_ROOMID, roomId, 0);
}
void add_rtt(uint32_t rtt) {
fbb_.AddElement<uint32_t>(GetPingInfoResponse::VT_RTT, rtt, 0);
}
explicit GetPingInfoResponseBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<GetPingInfoResponse> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<GetPingInfoResponse>(end);
return o;
}
};
inline ::flatbuffers::Offset<GetPingInfoResponse> CreateGetPingInfoResponse(
::flatbuffers::FlatBufferBuilder &_fbb,
uint16_t serverId = 0,
uint32_t worldId = 0,
uint64_t roomId = 0,
uint32_t rtt = 0) {
GetPingInfoResponseBuilder builder_(_fbb);
builder_.add_roomId(roomId);
builder_.add_rtt(rtt);
builder_.add_worldId(worldId);
builder_.add_serverId(serverId);
return builder_.Finish();
}
struct SendRoomMessageRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef SendRoomMessageRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ROOMID = 4,
VT_CASTTYPE = 6,
VT_DST = 8,
VT_MSG = 10,
VT_OPTION = 12
};
uint64_t roomId() const {
return GetField<uint64_t>(VT_ROOMID, 0);
}
uint8_t castType() const {
return GetField<uint8_t>(VT_CASTTYPE, 0);
}
const ::flatbuffers::Vector<uint16_t> *dst() const {
return GetPointer<const ::flatbuffers::Vector<uint16_t> *>(VT_DST);
}
const ::flatbuffers::Vector<uint8_t> *msg() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_MSG);
}
uint8_t option() const {
return GetField<uint8_t>(VT_OPTION, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
VerifyField<uint8_t>(verifier, VT_CASTTYPE, 1) &&
VerifyOffset(verifier, VT_DST) &&
verifier.VerifyVector(dst()) &&
VerifyOffset(verifier, VT_MSG) &&
verifier.VerifyVector(msg()) &&
VerifyField<uint8_t>(verifier, VT_OPTION, 1) &&
verifier.EndTable();
}
};
struct SendRoomMessageRequestBuilder {
typedef SendRoomMessageRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_roomId(uint64_t roomId) {
fbb_.AddElement<uint64_t>(SendRoomMessageRequest::VT_ROOMID, roomId, 0);
}
void add_castType(uint8_t castType) {
fbb_.AddElement<uint8_t>(SendRoomMessageRequest::VT_CASTTYPE, castType, 0);
}
void add_dst(::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> dst) {
fbb_.AddOffset(SendRoomMessageRequest::VT_DST, dst);
}
void add_msg(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> msg) {
fbb_.AddOffset(SendRoomMessageRequest::VT_MSG, msg);
}
void add_option(uint8_t option) {
fbb_.AddElement<uint8_t>(SendRoomMessageRequest::VT_OPTION, option, 0);
}
explicit SendRoomMessageRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<SendRoomMessageRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<SendRoomMessageRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<SendRoomMessageRequest> CreateSendRoomMessageRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t roomId = 0,
uint8_t castType = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> dst = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> msg = 0,
uint8_t option = 0) {
SendRoomMessageRequestBuilder builder_(_fbb);
builder_.add_roomId(roomId);
builder_.add_msg(msg);
builder_.add_dst(dst);
builder_.add_option(option);
builder_.add_castType(castType);
return builder_.Finish();
}
inline ::flatbuffers::Offset<SendRoomMessageRequest> CreateSendRoomMessageRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint64_t roomId = 0,
uint8_t castType = 0,
const std::vector<uint16_t> *dst = nullptr,
const std::vector<uint8_t> *msg = nullptr,
uint8_t option = 0) {
auto dst__ = dst ? _fbb.CreateVector<uint16_t>(*dst) : 0;
auto msg__ = msg ? _fbb.CreateVector<uint8_t>(*msg) : 0;
return CreateSendRoomMessageRequest(
_fbb,
roomId,
castType,
dst__,
msg__,
option);
}
struct RoomMessageInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef RoomMessageInfoBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_FILTERED = 4,
VT_CASTTYPE = 6,
VT_DST = 8,
VT_SRCMEMBER = 10,
VT_MSG = 12
};
bool filtered() const {
return GetField<uint8_t>(VT_FILTERED, 0) != 0;
}
uint8_t castType() const {
return GetField<uint8_t>(VT_CASTTYPE, 0);
}
const ::flatbuffers::Vector<uint16_t> *dst() const {
return GetPointer<const ::flatbuffers::Vector<uint16_t> *>(VT_DST);
}
const UserInfo *srcMember() const {
return GetPointer<const UserInfo *>(VT_SRCMEMBER);
}
const ::flatbuffers::Vector<uint8_t> *msg() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_MSG);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_FILTERED, 1) &&
VerifyField<uint8_t>(verifier, VT_CASTTYPE, 1) &&
VerifyOffset(verifier, VT_DST) &&
verifier.VerifyVector(dst()) &&
VerifyOffset(verifier, VT_SRCMEMBER) &&
verifier.VerifyTable(srcMember()) &&
VerifyOffset(verifier, VT_MSG) &&
verifier.VerifyVector(msg()) &&
verifier.EndTable();
}
};
struct RoomMessageInfoBuilder {
typedef RoomMessageInfo Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_filtered(bool filtered) {
fbb_.AddElement<uint8_t>(RoomMessageInfo::VT_FILTERED, static_cast<uint8_t>(filtered), 0);
}
void add_castType(uint8_t castType) {
fbb_.AddElement<uint8_t>(RoomMessageInfo::VT_CASTTYPE, castType, 0);
}
void add_dst(::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> dst) {
fbb_.AddOffset(RoomMessageInfo::VT_DST, dst);
}
void add_srcMember(::flatbuffers::Offset<UserInfo> srcMember) {
fbb_.AddOffset(RoomMessageInfo::VT_SRCMEMBER, srcMember);
}
void add_msg(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> msg) {
fbb_.AddOffset(RoomMessageInfo::VT_MSG, msg);
}
explicit RoomMessageInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<RoomMessageInfo> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<RoomMessageInfo>(end);
return o;
}
};
inline ::flatbuffers::Offset<RoomMessageInfo> CreateRoomMessageInfo(
::flatbuffers::FlatBufferBuilder &_fbb,
bool filtered = false,
uint8_t castType = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> dst = 0,
::flatbuffers::Offset<UserInfo> srcMember = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> msg = 0) {
RoomMessageInfoBuilder builder_(_fbb);
builder_.add_msg(msg);
builder_.add_srcMember(srcMember);
builder_.add_dst(dst);
builder_.add_castType(castType);
builder_.add_filtered(filtered);
return builder_.Finish();
}
inline ::flatbuffers::Offset<RoomMessageInfo> CreateRoomMessageInfoDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
bool filtered = false,
uint8_t castType = 0,
const std::vector<uint16_t> *dst = nullptr,
::flatbuffers::Offset<UserInfo> srcMember = 0,
const std::vector<uint8_t> *msg = nullptr) {
auto dst__ = dst ? _fbb.CreateVector<uint16_t>(*dst) : 0;
auto msg__ = msg ? _fbb.CreateVector<uint8_t>(*msg) : 0;
return CreateRoomMessageInfo(
_fbb,
filtered,
castType,
dst__,
srcMember,
msg__);
}
struct MessageDetails FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef MessageDetailsBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_COMMUNICATIONID = 4,
VT_MSGID = 6,
VT_MAINTYPE = 8,
VT_SUBTYPE = 10,
VT_MSGFEATURES = 12,
VT_SUBJECT = 14,
VT_BODY = 16,
VT_DATA = 18
};
const ::flatbuffers::String *communicationId() const {
return GetPointer<const ::flatbuffers::String *>(VT_COMMUNICATIONID);
}
uint64_t msgId() const {
return GetField<uint64_t>(VT_MSGID, 0);
}
uint16_t mainType() const {
return GetField<uint16_t>(VT_MAINTYPE, 0);
}
uint16_t subType() const {
return GetField<uint16_t>(VT_SUBTYPE, 0);
}
uint32_t msgFeatures() const {
return GetField<uint32_t>(VT_MSGFEATURES, 0);
}
const ::flatbuffers::String *subject() const {
return GetPointer<const ::flatbuffers::String *>(VT_SUBJECT);
}
const ::flatbuffers::String *body() const {
return GetPointer<const ::flatbuffers::String *>(VT_BODY);
}
const ::flatbuffers::Vector<uint8_t> *data() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_COMMUNICATIONID) &&
verifier.VerifyString(communicationId()) &&
VerifyField<uint64_t>(verifier, VT_MSGID, 8) &&
VerifyField<uint16_t>(verifier, VT_MAINTYPE, 2) &&
VerifyField<uint16_t>(verifier, VT_SUBTYPE, 2) &&
VerifyField<uint32_t>(verifier, VT_MSGFEATURES, 4) &&
VerifyOffset(verifier, VT_SUBJECT) &&
verifier.VerifyString(subject()) &&
VerifyOffset(verifier, VT_BODY) &&
verifier.VerifyString(body()) &&
VerifyOffset(verifier, VT_DATA) &&
verifier.VerifyVector(data()) &&
verifier.EndTable();
}
};
struct MessageDetailsBuilder {
typedef MessageDetails Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_communicationId(::flatbuffers::Offset<::flatbuffers::String> communicationId) {
fbb_.AddOffset(MessageDetails::VT_COMMUNICATIONID, communicationId);
}
void add_msgId(uint64_t msgId) {
fbb_.AddElement<uint64_t>(MessageDetails::VT_MSGID, msgId, 0);
}
void add_mainType(uint16_t mainType) {
fbb_.AddElement<uint16_t>(MessageDetails::VT_MAINTYPE, mainType, 0);
}
void add_subType(uint16_t subType) {
fbb_.AddElement<uint16_t>(MessageDetails::VT_SUBTYPE, subType, 0);
}
void add_msgFeatures(uint32_t msgFeatures) {
fbb_.AddElement<uint32_t>(MessageDetails::VT_MSGFEATURES, msgFeatures, 0);
}
void add_subject(::flatbuffers::Offset<::flatbuffers::String> subject) {
fbb_.AddOffset(MessageDetails::VT_SUBJECT, subject);
}
void add_body(::flatbuffers::Offset<::flatbuffers::String> body) {
fbb_.AddOffset(MessageDetails::VT_BODY, body);
}
void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
fbb_.AddOffset(MessageDetails::VT_DATA, data);
}
explicit MessageDetailsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<MessageDetails> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<MessageDetails>(end);
return o;
}
};
inline ::flatbuffers::Offset<MessageDetails> CreateMessageDetails(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::String> communicationId = 0,
uint64_t msgId = 0,
uint16_t mainType = 0,
uint16_t subType = 0,
uint32_t msgFeatures = 0,
::flatbuffers::Offset<::flatbuffers::String> subject = 0,
::flatbuffers::Offset<::flatbuffers::String> body = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
MessageDetailsBuilder builder_(_fbb);
builder_.add_msgId(msgId);
builder_.add_data(data);
builder_.add_body(body);
builder_.add_subject(subject);
builder_.add_msgFeatures(msgFeatures);
builder_.add_communicationId(communicationId);
builder_.add_subType(subType);
builder_.add_mainType(mainType);
return builder_.Finish();
}
inline ::flatbuffers::Offset<MessageDetails> CreateMessageDetailsDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const char *communicationId = nullptr,
uint64_t msgId = 0,
uint16_t mainType = 0,
uint16_t subType = 0,
uint32_t msgFeatures = 0,
const char *subject = nullptr,
const char *body = nullptr,
const std::vector<uint8_t> *data = nullptr) {
auto communicationId__ = communicationId ? _fbb.CreateString(communicationId) : 0;
auto subject__ = subject ? _fbb.CreateString(subject) : 0;
auto body__ = body ? _fbb.CreateString(body) : 0;
auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
return CreateMessageDetails(
_fbb,
communicationId__,
msgId,
mainType,
subType,
msgFeatures,
subject__,
body__,
data__);
}
struct SendMessageRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef SendMessageRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_MESSAGE = 4,
VT_NPIDS = 6
};
const ::flatbuffers::Vector<uint8_t> *message() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_MESSAGE);
}
const MessageDetails *message_nested_root() const {
const auto _f = message();
return _f ? ::flatbuffers::GetRoot<MessageDetails>(_f->Data())
: nullptr;
}
const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *npids() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_NPIDS);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_MESSAGE) &&
verifier.VerifyVector(message()) &&
verifier.VerifyNestedFlatBuffer<MessageDetails>(message(), nullptr) &&
VerifyOffset(verifier, VT_NPIDS) &&
verifier.VerifyVector(npids()) &&
verifier.VerifyVectorOfStrings(npids()) &&
verifier.EndTable();
}
};
struct SendMessageRequestBuilder {
typedef SendMessageRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_message(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> message) {
fbb_.AddOffset(SendMessageRequest::VT_MESSAGE, message);
}
void add_npids(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> npids) {
fbb_.AddOffset(SendMessageRequest::VT_NPIDS, npids);
}
explicit SendMessageRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<SendMessageRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<SendMessageRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<SendMessageRequest> CreateSendMessageRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> message = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> npids = 0) {
SendMessageRequestBuilder builder_(_fbb);
builder_.add_npids(npids);
builder_.add_message(message);
return builder_.Finish();
}
inline ::flatbuffers::Offset<SendMessageRequest> CreateSendMessageRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *message = nullptr,
const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *npids = nullptr) {
auto message__ = message ? _fbb.CreateVector<uint8_t>(*message) : 0;
auto npids__ = npids ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*npids) : 0;
return CreateSendMessageRequest(
_fbb,
message__,
npids__);
}
struct BoardInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef BoardInfoBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_RANKLIMIT = 4,
VT_UPDATEMODE = 6,
VT_SORTMODE = 8,
VT_UPLOADNUMLIMIT = 10,
VT_UPLOADSIZELIMIT = 12
};
uint32_t rankLimit() const {
return GetField<uint32_t>(VT_RANKLIMIT, 0);
}
uint32_t updateMode() const {
return GetField<uint32_t>(VT_UPDATEMODE, 0);
}
uint32_t sortMode() const {
return GetField<uint32_t>(VT_SORTMODE, 0);
}
uint32_t uploadNumLimit() const {
return GetField<uint32_t>(VT_UPLOADNUMLIMIT, 0);
}
uint32_t uploadSizeLimit() const {
return GetField<uint32_t>(VT_UPLOADSIZELIMIT, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_RANKLIMIT, 4) &&
VerifyField<uint32_t>(verifier, VT_UPDATEMODE, 4) &&
VerifyField<uint32_t>(verifier, VT_SORTMODE, 4) &&
VerifyField<uint32_t>(verifier, VT_UPLOADNUMLIMIT, 4) &&
VerifyField<uint32_t>(verifier, VT_UPLOADSIZELIMIT, 4) &&
verifier.EndTable();
}
};
struct BoardInfoBuilder {
typedef BoardInfo Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_rankLimit(uint32_t rankLimit) {
fbb_.AddElement<uint32_t>(BoardInfo::VT_RANKLIMIT, rankLimit, 0);
}
void add_updateMode(uint32_t updateMode) {
fbb_.AddElement<uint32_t>(BoardInfo::VT_UPDATEMODE, updateMode, 0);
}
void add_sortMode(uint32_t sortMode) {
fbb_.AddElement<uint32_t>(BoardInfo::VT_SORTMODE, sortMode, 0);
}
void add_uploadNumLimit(uint32_t uploadNumLimit) {
fbb_.AddElement<uint32_t>(BoardInfo::VT_UPLOADNUMLIMIT, uploadNumLimit, 0);
}
void add_uploadSizeLimit(uint32_t uploadSizeLimit) {
fbb_.AddElement<uint32_t>(BoardInfo::VT_UPLOADSIZELIMIT, uploadSizeLimit, 0);
}
explicit BoardInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<BoardInfo> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<BoardInfo>(end);
return o;
}
};
inline ::flatbuffers::Offset<BoardInfo> CreateBoardInfo(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t rankLimit = 0,
uint32_t updateMode = 0,
uint32_t sortMode = 0,
uint32_t uploadNumLimit = 0,
uint32_t uploadSizeLimit = 0) {
BoardInfoBuilder builder_(_fbb);
builder_.add_uploadSizeLimit(uploadSizeLimit);
builder_.add_uploadNumLimit(uploadNumLimit);
builder_.add_sortMode(sortMode);
builder_.add_updateMode(updateMode);
builder_.add_rankLimit(rankLimit);
return builder_.Finish();
}
struct RecordScoreRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef RecordScoreRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_BOARDID = 4,
VT_PCID = 6,
VT_SCORE = 8,
VT_COMMENT = 10,
VT_DATA = 12
};
uint32_t boardId() const {
return GetField<uint32_t>(VT_BOARDID, 0);
}
int32_t pcId() const {
return GetField<int32_t>(VT_PCID, 0);
}
int64_t score() const {
return GetField<int64_t>(VT_SCORE, 0);
}
const ::flatbuffers::String *comment() const {
return GetPointer<const ::flatbuffers::String *>(VT_COMMENT);
}
const ::flatbuffers::Vector<uint8_t> *data() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_BOARDID, 4) &&
VerifyField<int32_t>(verifier, VT_PCID, 4) &&
VerifyField<int64_t>(verifier, VT_SCORE, 8) &&
VerifyOffset(verifier, VT_COMMENT) &&
verifier.VerifyString(comment()) &&
VerifyOffset(verifier, VT_DATA) &&
verifier.VerifyVector(data()) &&
verifier.EndTable();
}
};
struct RecordScoreRequestBuilder {
typedef RecordScoreRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_boardId(uint32_t boardId) {
fbb_.AddElement<uint32_t>(RecordScoreRequest::VT_BOARDID, boardId, 0);
}
void add_pcId(int32_t pcId) {
fbb_.AddElement<int32_t>(RecordScoreRequest::VT_PCID, pcId, 0);
}
void add_score(int64_t score) {
fbb_.AddElement<int64_t>(RecordScoreRequest::VT_SCORE, score, 0);
}
void add_comment(::flatbuffers::Offset<::flatbuffers::String> comment) {
fbb_.AddOffset(RecordScoreRequest::VT_COMMENT, comment);
}
void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
fbb_.AddOffset(RecordScoreRequest::VT_DATA, data);
}
explicit RecordScoreRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<RecordScoreRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<RecordScoreRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<RecordScoreRequest> CreateRecordScoreRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t boardId = 0,
int32_t pcId = 0,
int64_t score = 0,
::flatbuffers::Offset<::flatbuffers::String> comment = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
RecordScoreRequestBuilder builder_(_fbb);
builder_.add_score(score);
builder_.add_data(data);
builder_.add_comment(comment);
builder_.add_pcId(pcId);
builder_.add_boardId(boardId);
return builder_.Finish();
}
inline ::flatbuffers::Offset<RecordScoreRequest> CreateRecordScoreRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t boardId = 0,
int32_t pcId = 0,
int64_t score = 0,
const char *comment = nullptr,
const std::vector<uint8_t> *data = nullptr) {
auto comment__ = comment ? _fbb.CreateString(comment) : 0;
auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
return CreateRecordScoreRequest(
_fbb,
boardId,
pcId,
score,
comment__,
data__);
}
struct GetScoreRangeRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef GetScoreRangeRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_BOARDID = 4,
VT_STARTRANK = 6,
VT_NUMRANKS = 8,
VT_WITHCOMMENT = 10,
VT_WITHGAMEINFO = 12
};
uint32_t boardId() const {
return GetField<uint32_t>(VT_BOARDID, 0);
}
uint32_t startRank() const {
return GetField<uint32_t>(VT_STARTRANK, 0);
}
uint32_t numRanks() const {
return GetField<uint32_t>(VT_NUMRANKS, 0);
}
bool withComment() const {
return GetField<uint8_t>(VT_WITHCOMMENT, 0) != 0;
}
bool withGameInfo() const {
return GetField<uint8_t>(VT_WITHGAMEINFO, 0) != 0;
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_BOARDID, 4) &&
VerifyField<uint32_t>(verifier, VT_STARTRANK, 4) &&
VerifyField<uint32_t>(verifier, VT_NUMRANKS, 4) &&
VerifyField<uint8_t>(verifier, VT_WITHCOMMENT, 1) &&
VerifyField<uint8_t>(verifier, VT_WITHGAMEINFO, 1) &&
verifier.EndTable();
}
};
struct GetScoreRangeRequestBuilder {
typedef GetScoreRangeRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_boardId(uint32_t boardId) {
fbb_.AddElement<uint32_t>(GetScoreRangeRequest::VT_BOARDID, boardId, 0);
}
void add_startRank(uint32_t startRank) {
fbb_.AddElement<uint32_t>(GetScoreRangeRequest::VT_STARTRANK, startRank, 0);
}
void add_numRanks(uint32_t numRanks) {
fbb_.AddElement<uint32_t>(GetScoreRangeRequest::VT_NUMRANKS, numRanks, 0);
}
void add_withComment(bool withComment) {
fbb_.AddElement<uint8_t>(GetScoreRangeRequest::VT_WITHCOMMENT, static_cast<uint8_t>(withComment), 0);
}
void add_withGameInfo(bool withGameInfo) {
fbb_.AddElement<uint8_t>(GetScoreRangeRequest::VT_WITHGAMEINFO, static_cast<uint8_t>(withGameInfo), 0);
}
explicit GetScoreRangeRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<GetScoreRangeRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<GetScoreRangeRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<GetScoreRangeRequest> CreateGetScoreRangeRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t boardId = 0,
uint32_t startRank = 0,
uint32_t numRanks = 0,
bool withComment = false,
bool withGameInfo = false) {
GetScoreRangeRequestBuilder builder_(_fbb);
builder_.add_numRanks(numRanks);
builder_.add_startRank(startRank);
builder_.add_boardId(boardId);
builder_.add_withGameInfo(withGameInfo);
builder_.add_withComment(withComment);
return builder_.Finish();
}
struct ScoreNpIdPcId FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef ScoreNpIdPcIdBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NPID = 4,
VT_PCID = 6
};
const ::flatbuffers::String *npid() const {
return GetPointer<const ::flatbuffers::String *>(VT_NPID);
}
int32_t pcId() const {
return GetField<int32_t>(VT_PCID, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_NPID) &&
verifier.VerifyString(npid()) &&
VerifyField<int32_t>(verifier, VT_PCID, 4) &&
verifier.EndTable();
}
};
struct ScoreNpIdPcIdBuilder {
typedef ScoreNpIdPcId Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_npid(::flatbuffers::Offset<::flatbuffers::String> npid) {
fbb_.AddOffset(ScoreNpIdPcId::VT_NPID, npid);
}
void add_pcId(int32_t pcId) {
fbb_.AddElement<int32_t>(ScoreNpIdPcId::VT_PCID, pcId, 0);
}
explicit ScoreNpIdPcIdBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<ScoreNpIdPcId> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<ScoreNpIdPcId>(end);
return o;
}
};
inline ::flatbuffers::Offset<ScoreNpIdPcId> CreateScoreNpIdPcId(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::String> npid = 0,
int32_t pcId = 0) {
ScoreNpIdPcIdBuilder builder_(_fbb);
builder_.add_pcId(pcId);
builder_.add_npid(npid);
return builder_.Finish();
}
inline ::flatbuffers::Offset<ScoreNpIdPcId> CreateScoreNpIdPcIdDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const char *npid = nullptr,
int32_t pcId = 0) {
auto npid__ = npid ? _fbb.CreateString(npid) : 0;
return CreateScoreNpIdPcId(
_fbb,
npid__,
pcId);
}
struct GetScoreNpIdRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef GetScoreNpIdRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_BOARDID = 4,
VT_NPIDS = 6,
VT_WITHCOMMENT = 8,
VT_WITHGAMEINFO = 10
};
uint32_t boardId() const {
return GetField<uint32_t>(VT_BOARDID, 0);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<ScoreNpIdPcId>> *npids() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<ScoreNpIdPcId>> *>(VT_NPIDS);
}
bool withComment() const {
return GetField<uint8_t>(VT_WITHCOMMENT, 0) != 0;
}
bool withGameInfo() const {
return GetField<uint8_t>(VT_WITHGAMEINFO, 0) != 0;
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_BOARDID, 4) &&
VerifyOffset(verifier, VT_NPIDS) &&
verifier.VerifyVector(npids()) &&
verifier.VerifyVectorOfTables(npids()) &&
VerifyField<uint8_t>(verifier, VT_WITHCOMMENT, 1) &&
VerifyField<uint8_t>(verifier, VT_WITHGAMEINFO, 1) &&
verifier.EndTable();
}
};
struct GetScoreNpIdRequestBuilder {
typedef GetScoreNpIdRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_boardId(uint32_t boardId) {
fbb_.AddElement<uint32_t>(GetScoreNpIdRequest::VT_BOARDID, boardId, 0);
}
void add_npids(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<ScoreNpIdPcId>>> npids) {
fbb_.AddOffset(GetScoreNpIdRequest::VT_NPIDS, npids);
}
void add_withComment(bool withComment) {
fbb_.AddElement<uint8_t>(GetScoreNpIdRequest::VT_WITHCOMMENT, static_cast<uint8_t>(withComment), 0);
}
void add_withGameInfo(bool withGameInfo) {
fbb_.AddElement<uint8_t>(GetScoreNpIdRequest::VT_WITHGAMEINFO, static_cast<uint8_t>(withGameInfo), 0);
}
explicit GetScoreNpIdRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<GetScoreNpIdRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<GetScoreNpIdRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<GetScoreNpIdRequest> CreateGetScoreNpIdRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t boardId = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<ScoreNpIdPcId>>> npids = 0,
bool withComment = false,
bool withGameInfo = false) {
GetScoreNpIdRequestBuilder builder_(_fbb);
builder_.add_npids(npids);
builder_.add_boardId(boardId);
builder_.add_withGameInfo(withGameInfo);
builder_.add_withComment(withComment);
return builder_.Finish();
}
inline ::flatbuffers::Offset<GetScoreNpIdRequest> CreateGetScoreNpIdRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t boardId = 0,
const std::vector<::flatbuffers::Offset<ScoreNpIdPcId>> *npids = nullptr,
bool withComment = false,
bool withGameInfo = false) {
auto npids__ = npids ? _fbb.CreateVector<::flatbuffers::Offset<ScoreNpIdPcId>>(*npids) : 0;
return CreateGetScoreNpIdRequest(
_fbb,
boardId,
npids__,
withComment,
withGameInfo);
}
struct GetScoreFriendsRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef GetScoreFriendsRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_BOARDID = 4,
VT_INCLUDE_SELF = 6,
VT_MAX = 8,
VT_WITHCOMMENT = 10,
VT_WITHGAMEINFO = 12
};
uint32_t boardId() const {
return GetField<uint32_t>(VT_BOARDID, 0);
}
bool include_self() const {
return GetField<uint8_t>(VT_INCLUDE_SELF, 0) != 0;
}
uint32_t max() const {
return GetField<uint32_t>(VT_MAX, 0);
}
bool withComment() const {
return GetField<uint8_t>(VT_WITHCOMMENT, 0) != 0;
}
bool withGameInfo() const {
return GetField<uint8_t>(VT_WITHGAMEINFO, 0) != 0;
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_BOARDID, 4) &&
VerifyField<uint8_t>(verifier, VT_INCLUDE_SELF, 1) &&
VerifyField<uint32_t>(verifier, VT_MAX, 4) &&
VerifyField<uint8_t>(verifier, VT_WITHCOMMENT, 1) &&
VerifyField<uint8_t>(verifier, VT_WITHGAMEINFO, 1) &&
verifier.EndTable();
}
};
struct GetScoreFriendsRequestBuilder {
typedef GetScoreFriendsRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_boardId(uint32_t boardId) {
fbb_.AddElement<uint32_t>(GetScoreFriendsRequest::VT_BOARDID, boardId, 0);
}
void add_include_self(bool include_self) {
fbb_.AddElement<uint8_t>(GetScoreFriendsRequest::VT_INCLUDE_SELF, static_cast<uint8_t>(include_self), 0);
}
void add_max(uint32_t max) {
fbb_.AddElement<uint32_t>(GetScoreFriendsRequest::VT_MAX, max, 0);
}
void add_withComment(bool withComment) {
fbb_.AddElement<uint8_t>(GetScoreFriendsRequest::VT_WITHCOMMENT, static_cast<uint8_t>(withComment), 0);
}
void add_withGameInfo(bool withGameInfo) {
fbb_.AddElement<uint8_t>(GetScoreFriendsRequest::VT_WITHGAMEINFO, static_cast<uint8_t>(withGameInfo), 0);
}
explicit GetScoreFriendsRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<GetScoreFriendsRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<GetScoreFriendsRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<GetScoreFriendsRequest> CreateGetScoreFriendsRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t boardId = 0,
bool include_self = false,
uint32_t max = 0,
bool withComment = false,
bool withGameInfo = false) {
GetScoreFriendsRequestBuilder builder_(_fbb);
builder_.add_max(max);
builder_.add_boardId(boardId);
builder_.add_withGameInfo(withGameInfo);
builder_.add_withComment(withComment);
builder_.add_include_self(include_self);
return builder_.Finish();
}
struct ScoreRankData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef ScoreRankDataBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NPID = 4,
VT_ONLINENAME = 6,
VT_PCID = 8,
VT_RANK = 10,
VT_SCORE = 12,
VT_HASGAMEDATA = 14,
VT_RECORDDATE = 16
};
const ::flatbuffers::String *npId() const {
return GetPointer<const ::flatbuffers::String *>(VT_NPID);
}
const ::flatbuffers::String *onlineName() const {
return GetPointer<const ::flatbuffers::String *>(VT_ONLINENAME);
}
int32_t pcId() const {
return GetField<int32_t>(VT_PCID, 0);
}
uint32_t rank() const {
return GetField<uint32_t>(VT_RANK, 0);
}
int64_t score() const {
return GetField<int64_t>(VT_SCORE, 0);
}
bool hasGameData() const {
return GetField<uint8_t>(VT_HASGAMEDATA, 0) != 0;
}
uint64_t recordDate() const {
return GetField<uint64_t>(VT_RECORDDATE, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_NPID) &&
verifier.VerifyString(npId()) &&
VerifyOffset(verifier, VT_ONLINENAME) &&
verifier.VerifyString(onlineName()) &&
VerifyField<int32_t>(verifier, VT_PCID, 4) &&
VerifyField<uint32_t>(verifier, VT_RANK, 4) &&
VerifyField<int64_t>(verifier, VT_SCORE, 8) &&
VerifyField<uint8_t>(verifier, VT_HASGAMEDATA, 1) &&
VerifyField<uint64_t>(verifier, VT_RECORDDATE, 8) &&
verifier.EndTable();
}
};
struct ScoreRankDataBuilder {
typedef ScoreRankData Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_npId(::flatbuffers::Offset<::flatbuffers::String> npId) {
fbb_.AddOffset(ScoreRankData::VT_NPID, npId);
}
void add_onlineName(::flatbuffers::Offset<::flatbuffers::String> onlineName) {
fbb_.AddOffset(ScoreRankData::VT_ONLINENAME, onlineName);
}
void add_pcId(int32_t pcId) {
fbb_.AddElement<int32_t>(ScoreRankData::VT_PCID, pcId, 0);
}
void add_rank(uint32_t rank) {
fbb_.AddElement<uint32_t>(ScoreRankData::VT_RANK, rank, 0);
}
void add_score(int64_t score) {
fbb_.AddElement<int64_t>(ScoreRankData::VT_SCORE, score, 0);
}
void add_hasGameData(bool hasGameData) {
fbb_.AddElement<uint8_t>(ScoreRankData::VT_HASGAMEDATA, static_cast<uint8_t>(hasGameData), 0);
}
void add_recordDate(uint64_t recordDate) {
fbb_.AddElement<uint64_t>(ScoreRankData::VT_RECORDDATE, recordDate, 0);
}
explicit ScoreRankDataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<ScoreRankData> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<ScoreRankData>(end);
return o;
}
};
inline ::flatbuffers::Offset<ScoreRankData> CreateScoreRankData(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::String> npId = 0,
::flatbuffers::Offset<::flatbuffers::String> onlineName = 0,
int32_t pcId = 0,
uint32_t rank = 0,
int64_t score = 0,
bool hasGameData = false,
uint64_t recordDate = 0) {
ScoreRankDataBuilder builder_(_fbb);
builder_.add_recordDate(recordDate);
builder_.add_score(score);
builder_.add_rank(rank);
builder_.add_pcId(pcId);
builder_.add_onlineName(onlineName);
builder_.add_npId(npId);
builder_.add_hasGameData(hasGameData);
return builder_.Finish();
}
inline ::flatbuffers::Offset<ScoreRankData> CreateScoreRankDataDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const char *npId = nullptr,
const char *onlineName = nullptr,
int32_t pcId = 0,
uint32_t rank = 0,
int64_t score = 0,
bool hasGameData = false,
uint64_t recordDate = 0) {
auto npId__ = npId ? _fbb.CreateString(npId) : 0;
auto onlineName__ = onlineName ? _fbb.CreateString(onlineName) : 0;
return CreateScoreRankData(
_fbb,
npId__,
onlineName__,
pcId,
rank,
score,
hasGameData,
recordDate);
}
struct ScoreInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef ScoreInfoBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_DATA = 4
};
const ::flatbuffers::Vector<uint8_t> *data() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_DATA) &&
verifier.VerifyVector(data()) &&
verifier.EndTable();
}
};
struct ScoreInfoBuilder {
typedef ScoreInfo Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
fbb_.AddOffset(ScoreInfo::VT_DATA, data);
}
explicit ScoreInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<ScoreInfo> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<ScoreInfo>(end);
return o;
}
};
inline ::flatbuffers::Offset<ScoreInfo> CreateScoreInfo(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
ScoreInfoBuilder builder_(_fbb);
builder_.add_data(data);
return builder_.Finish();
}
inline ::flatbuffers::Offset<ScoreInfo> CreateScoreInfoDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *data = nullptr) {
auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
return CreateScoreInfo(
_fbb,
data__);
}
struct GetScoreResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef GetScoreResponseBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_RANKARRAY = 4,
VT_COMMENTARRAY = 6,
VT_INFOARRAY = 8,
VT_LASTSORTDATE = 10,
VT_TOTALRECORD = 12
};
const ::flatbuffers::Vector<::flatbuffers::Offset<ScoreRankData>> *rankArray() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<ScoreRankData>> *>(VT_RANKARRAY);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *commentArray() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_COMMENTARRAY);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<ScoreInfo>> *infoArray() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<ScoreInfo>> *>(VT_INFOARRAY);
}
uint64_t lastSortDate() const {
return GetField<uint64_t>(VT_LASTSORTDATE, 0);
}
uint32_t totalRecord() const {
return GetField<uint32_t>(VT_TOTALRECORD, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_RANKARRAY) &&
verifier.VerifyVector(rankArray()) &&
verifier.VerifyVectorOfTables(rankArray()) &&
VerifyOffset(verifier, VT_COMMENTARRAY) &&
verifier.VerifyVector(commentArray()) &&
verifier.VerifyVectorOfStrings(commentArray()) &&
VerifyOffset(verifier, VT_INFOARRAY) &&
verifier.VerifyVector(infoArray()) &&
verifier.VerifyVectorOfTables(infoArray()) &&
VerifyField<uint64_t>(verifier, VT_LASTSORTDATE, 8) &&
VerifyField<uint32_t>(verifier, VT_TOTALRECORD, 4) &&
verifier.EndTable();
}
};
struct GetScoreResponseBuilder {
typedef GetScoreResponse Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_rankArray(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<ScoreRankData>>> rankArray) {
fbb_.AddOffset(GetScoreResponse::VT_RANKARRAY, rankArray);
}
void add_commentArray(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> commentArray) {
fbb_.AddOffset(GetScoreResponse::VT_COMMENTARRAY, commentArray);
}
void add_infoArray(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<ScoreInfo>>> infoArray) {
fbb_.AddOffset(GetScoreResponse::VT_INFOARRAY, infoArray);
}
void add_lastSortDate(uint64_t lastSortDate) {
fbb_.AddElement<uint64_t>(GetScoreResponse::VT_LASTSORTDATE, lastSortDate, 0);
}
void add_totalRecord(uint32_t totalRecord) {
fbb_.AddElement<uint32_t>(GetScoreResponse::VT_TOTALRECORD, totalRecord, 0);
}
explicit GetScoreResponseBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<GetScoreResponse> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<GetScoreResponse>(end);
return o;
}
};
inline ::flatbuffers::Offset<GetScoreResponse> CreateGetScoreResponse(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<ScoreRankData>>> rankArray = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> commentArray = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<ScoreInfo>>> infoArray = 0,
uint64_t lastSortDate = 0,
uint32_t totalRecord = 0) {
GetScoreResponseBuilder builder_(_fbb);
builder_.add_lastSortDate(lastSortDate);
builder_.add_totalRecord(totalRecord);
builder_.add_infoArray(infoArray);
builder_.add_commentArray(commentArray);
builder_.add_rankArray(rankArray);
return builder_.Finish();
}
inline ::flatbuffers::Offset<GetScoreResponse> CreateGetScoreResponseDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<::flatbuffers::Offset<ScoreRankData>> *rankArray = nullptr,
const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *commentArray = nullptr,
const std::vector<::flatbuffers::Offset<ScoreInfo>> *infoArray = nullptr,
uint64_t lastSortDate = 0,
uint32_t totalRecord = 0) {
auto rankArray__ = rankArray ? _fbb.CreateVector<::flatbuffers::Offset<ScoreRankData>>(*rankArray) : 0;
auto commentArray__ = commentArray ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*commentArray) : 0;
auto infoArray__ = infoArray ? _fbb.CreateVector<::flatbuffers::Offset<ScoreInfo>>(*infoArray) : 0;
return CreateGetScoreResponse(
_fbb,
rankArray__,
commentArray__,
infoArray__,
lastSortDate,
totalRecord);
}
struct RecordScoreGameDataRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef RecordScoreGameDataRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_BOARDID = 4,
VT_PCID = 6,
VT_SCORE = 8
};
uint32_t boardId() const {
return GetField<uint32_t>(VT_BOARDID, 0);
}
int32_t pcId() const {
return GetField<int32_t>(VT_PCID, 0);
}
int64_t score() const {
return GetField<int64_t>(VT_SCORE, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_BOARDID, 4) &&
VerifyField<int32_t>(verifier, VT_PCID, 4) &&
VerifyField<int64_t>(verifier, VT_SCORE, 8) &&
verifier.EndTable();
}
};
struct RecordScoreGameDataRequestBuilder {
typedef RecordScoreGameDataRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_boardId(uint32_t boardId) {
fbb_.AddElement<uint32_t>(RecordScoreGameDataRequest::VT_BOARDID, boardId, 0);
}
void add_pcId(int32_t pcId) {
fbb_.AddElement<int32_t>(RecordScoreGameDataRequest::VT_PCID, pcId, 0);
}
void add_score(int64_t score) {
fbb_.AddElement<int64_t>(RecordScoreGameDataRequest::VT_SCORE, score, 0);
}
explicit RecordScoreGameDataRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<RecordScoreGameDataRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<RecordScoreGameDataRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<RecordScoreGameDataRequest> CreateRecordScoreGameDataRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t boardId = 0,
int32_t pcId = 0,
int64_t score = 0) {
RecordScoreGameDataRequestBuilder builder_(_fbb);
builder_.add_score(score);
builder_.add_pcId(pcId);
builder_.add_boardId(boardId);
return builder_.Finish();
}
struct GetScoreGameDataRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef GetScoreGameDataRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_BOARDID = 4,
VT_NPID = 6,
VT_PCID = 8
};
uint32_t boardId() const {
return GetField<uint32_t>(VT_BOARDID, 0);
}
const ::flatbuffers::String *npId() const {
return GetPointer<const ::flatbuffers::String *>(VT_NPID);
}
int32_t pcId() const {
return GetField<int32_t>(VT_PCID, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_BOARDID, 4) &&
VerifyOffset(verifier, VT_NPID) &&
verifier.VerifyString(npId()) &&
VerifyField<int32_t>(verifier, VT_PCID, 4) &&
verifier.EndTable();
}
};
struct GetScoreGameDataRequestBuilder {
typedef GetScoreGameDataRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_boardId(uint32_t boardId) {
fbb_.AddElement<uint32_t>(GetScoreGameDataRequest::VT_BOARDID, boardId, 0);
}
void add_npId(::flatbuffers::Offset<::flatbuffers::String> npId) {
fbb_.AddOffset(GetScoreGameDataRequest::VT_NPID, npId);
}
void add_pcId(int32_t pcId) {
fbb_.AddElement<int32_t>(GetScoreGameDataRequest::VT_PCID, pcId, 0);
}
explicit GetScoreGameDataRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<GetScoreGameDataRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<GetScoreGameDataRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<GetScoreGameDataRequest> CreateGetScoreGameDataRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t boardId = 0,
::flatbuffers::Offset<::flatbuffers::String> npId = 0,
int32_t pcId = 0) {
GetScoreGameDataRequestBuilder builder_(_fbb);
builder_.add_pcId(pcId);
builder_.add_npId(npId);
builder_.add_boardId(boardId);
return builder_.Finish();
}
inline ::flatbuffers::Offset<GetScoreGameDataRequest> CreateGetScoreGameDataRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t boardId = 0,
const char *npId = nullptr,
int32_t pcId = 0) {
auto npId__ = npId ? _fbb.CreateString(npId) : 0;
return CreateGetScoreGameDataRequest(
_fbb,
boardId,
npId__,
pcId);
}
struct TusUser FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TusUserBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_VUSER = 4,
VT_NPID = 6
};
bool vuser() const {
return GetField<uint8_t>(VT_VUSER, 0) != 0;
}
const ::flatbuffers::String *npid() const {
return GetPointer<const ::flatbuffers::String *>(VT_NPID);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_VUSER, 1) &&
VerifyOffset(verifier, VT_NPID) &&
verifier.VerifyString(npid()) &&
verifier.EndTable();
}
};
struct TusUserBuilder {
typedef TusUser Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_vuser(bool vuser) {
fbb_.AddElement<uint8_t>(TusUser::VT_VUSER, static_cast<uint8_t>(vuser), 0);
}
void add_npid(::flatbuffers::Offset<::flatbuffers::String> npid) {
fbb_.AddOffset(TusUser::VT_NPID, npid);
}
explicit TusUserBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TusUser> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<TusUser>(end);
return o;
}
};
inline ::flatbuffers::Offset<TusUser> CreateTusUser(
::flatbuffers::FlatBufferBuilder &_fbb,
bool vuser = false,
::flatbuffers::Offset<::flatbuffers::String> npid = 0) {
TusUserBuilder builder_(_fbb);
builder_.add_npid(npid);
builder_.add_vuser(vuser);
return builder_.Finish();
}
inline ::flatbuffers::Offset<TusUser> CreateTusUserDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
bool vuser = false,
const char *npid = nullptr) {
auto npid__ = npid ? _fbb.CreateString(npid) : 0;
return CreateTusUser(
_fbb,
vuser,
npid__);
}
struct TusVariable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TusVariableBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_OWNERID = 4,
VT_HASDATA = 6,
VT_LASTCHANGEDDATE = 8,
VT_LASTCHANGEDAUTHORID = 10,
VT_VARIABLE = 12,
VT_OLDVARIABLE = 14
};
const ::flatbuffers::String *ownerId() const {
return GetPointer<const ::flatbuffers::String *>(VT_OWNERID);
}
bool hasData() const {
return GetField<uint8_t>(VT_HASDATA, 0) != 0;
}
uint64_t lastChangedDate() const {
return GetField<uint64_t>(VT_LASTCHANGEDDATE, 0);
}
const ::flatbuffers::String *lastChangedAuthorId() const {
return GetPointer<const ::flatbuffers::String *>(VT_LASTCHANGEDAUTHORID);
}
int64_t variable() const {
return GetField<int64_t>(VT_VARIABLE, 0);
}
int64_t oldVariable() const {
return GetField<int64_t>(VT_OLDVARIABLE, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_OWNERID) &&
verifier.VerifyString(ownerId()) &&
VerifyField<uint8_t>(verifier, VT_HASDATA, 1) &&
VerifyField<uint64_t>(verifier, VT_LASTCHANGEDDATE, 8) &&
VerifyOffset(verifier, VT_LASTCHANGEDAUTHORID) &&
verifier.VerifyString(lastChangedAuthorId()) &&
VerifyField<int64_t>(verifier, VT_VARIABLE, 8) &&
VerifyField<int64_t>(verifier, VT_OLDVARIABLE, 8) &&
verifier.EndTable();
}
};
struct TusVariableBuilder {
typedef TusVariable Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_ownerId(::flatbuffers::Offset<::flatbuffers::String> ownerId) {
fbb_.AddOffset(TusVariable::VT_OWNERID, ownerId);
}
void add_hasData(bool hasData) {
fbb_.AddElement<uint8_t>(TusVariable::VT_HASDATA, static_cast<uint8_t>(hasData), 0);
}
void add_lastChangedDate(uint64_t lastChangedDate) {
fbb_.AddElement<uint64_t>(TusVariable::VT_LASTCHANGEDDATE, lastChangedDate, 0);
}
void add_lastChangedAuthorId(::flatbuffers::Offset<::flatbuffers::String> lastChangedAuthorId) {
fbb_.AddOffset(TusVariable::VT_LASTCHANGEDAUTHORID, lastChangedAuthorId);
}
void add_variable(int64_t variable) {
fbb_.AddElement<int64_t>(TusVariable::VT_VARIABLE, variable, 0);
}
void add_oldVariable(int64_t oldVariable) {
fbb_.AddElement<int64_t>(TusVariable::VT_OLDVARIABLE, oldVariable, 0);
}
explicit TusVariableBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TusVariable> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<TusVariable>(end);
return o;
}
};
inline ::flatbuffers::Offset<TusVariable> CreateTusVariable(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::String> ownerId = 0,
bool hasData = false,
uint64_t lastChangedDate = 0,
::flatbuffers::Offset<::flatbuffers::String> lastChangedAuthorId = 0,
int64_t variable = 0,
int64_t oldVariable = 0) {
TusVariableBuilder builder_(_fbb);
builder_.add_oldVariable(oldVariable);
builder_.add_variable(variable);
builder_.add_lastChangedDate(lastChangedDate);
builder_.add_lastChangedAuthorId(lastChangedAuthorId);
builder_.add_ownerId(ownerId);
builder_.add_hasData(hasData);
return builder_.Finish();
}
inline ::flatbuffers::Offset<TusVariable> CreateTusVariableDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const char *ownerId = nullptr,
bool hasData = false,
uint64_t lastChangedDate = 0,
const char *lastChangedAuthorId = nullptr,
int64_t variable = 0,
int64_t oldVariable = 0) {
auto ownerId__ = ownerId ? _fbb.CreateString(ownerId) : 0;
auto lastChangedAuthorId__ = lastChangedAuthorId ? _fbb.CreateString(lastChangedAuthorId) : 0;
return CreateTusVariable(
_fbb,
ownerId__,
hasData,
lastChangedDate,
lastChangedAuthorId__,
variable,
oldVariable);
}
struct TusVarResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TusVarResponseBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_VARS = 4
};
const ::flatbuffers::Vector<::flatbuffers::Offset<TusVariable>> *vars() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<TusVariable>> *>(VT_VARS);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_VARS) &&
verifier.VerifyVector(vars()) &&
verifier.VerifyVectorOfTables(vars()) &&
verifier.EndTable();
}
};
struct TusVarResponseBuilder {
typedef TusVarResponse Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_vars(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusVariable>>> vars) {
fbb_.AddOffset(TusVarResponse::VT_VARS, vars);
}
explicit TusVarResponseBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TusVarResponse> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<TusVarResponse>(end);
return o;
}
};
inline ::flatbuffers::Offset<TusVarResponse> CreateTusVarResponse(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusVariable>>> vars = 0) {
TusVarResponseBuilder builder_(_fbb);
builder_.add_vars(vars);
return builder_.Finish();
}
inline ::flatbuffers::Offset<TusVarResponse> CreateTusVarResponseDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<::flatbuffers::Offset<TusVariable>> *vars = nullptr) {
auto vars__ = vars ? _fbb.CreateVector<::flatbuffers::Offset<TusVariable>>(*vars) : 0;
return CreateTusVarResponse(
_fbb,
vars__);
}
struct TusSetMultiSlotVariableRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TusSetMultiSlotVariableRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_USER = 4,
VT_SLOTIDARRAY = 6,
VT_VARIABLEARRAY = 8
};
const TusUser *user() const {
return GetPointer<const TusUser *>(VT_USER);
}
const ::flatbuffers::Vector<int32_t> *slotIdArray() const {
return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SLOTIDARRAY);
}
const ::flatbuffers::Vector<int64_t> *variableArray() const {
return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_VARIABLEARRAY);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_USER) &&
verifier.VerifyTable(user()) &&
VerifyOffset(verifier, VT_SLOTIDARRAY) &&
verifier.VerifyVector(slotIdArray()) &&
VerifyOffset(verifier, VT_VARIABLEARRAY) &&
verifier.VerifyVector(variableArray()) &&
verifier.EndTable();
}
};
struct TusSetMultiSlotVariableRequestBuilder {
typedef TusSetMultiSlotVariableRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_user(::flatbuffers::Offset<TusUser> user) {
fbb_.AddOffset(TusSetMultiSlotVariableRequest::VT_USER, user);
}
void add_slotIdArray(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray) {
fbb_.AddOffset(TusSetMultiSlotVariableRequest::VT_SLOTIDARRAY, slotIdArray);
}
void add_variableArray(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> variableArray) {
fbb_.AddOffset(TusSetMultiSlotVariableRequest::VT_VARIABLEARRAY, variableArray);
}
explicit TusSetMultiSlotVariableRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TusSetMultiSlotVariableRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<TusSetMultiSlotVariableRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<TusSetMultiSlotVariableRequest> CreateTusSetMultiSlotVariableRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<TusUser> user = 0,
::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray = 0,
::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> variableArray = 0) {
TusSetMultiSlotVariableRequestBuilder builder_(_fbb);
builder_.add_variableArray(variableArray);
builder_.add_slotIdArray(slotIdArray);
builder_.add_user(user);
return builder_.Finish();
}
inline ::flatbuffers::Offset<TusSetMultiSlotVariableRequest> CreateTusSetMultiSlotVariableRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<TusUser> user = 0,
const std::vector<int32_t> *slotIdArray = nullptr,
const std::vector<int64_t> *variableArray = nullptr) {
auto slotIdArray__ = slotIdArray ? _fbb.CreateVector<int32_t>(*slotIdArray) : 0;
auto variableArray__ = variableArray ? _fbb.CreateVector<int64_t>(*variableArray) : 0;
return CreateTusSetMultiSlotVariableRequest(
_fbb,
user,
slotIdArray__,
variableArray__);
}
struct TusGetMultiSlotVariableRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TusGetMultiSlotVariableRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_USER = 4,
VT_SLOTIDARRAY = 6
};
const TusUser *user() const {
return GetPointer<const TusUser *>(VT_USER);
}
const ::flatbuffers::Vector<int32_t> *slotIdArray() const {
return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SLOTIDARRAY);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_USER) &&
verifier.VerifyTable(user()) &&
VerifyOffset(verifier, VT_SLOTIDARRAY) &&
verifier.VerifyVector(slotIdArray()) &&
verifier.EndTable();
}
};
struct TusGetMultiSlotVariableRequestBuilder {
typedef TusGetMultiSlotVariableRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_user(::flatbuffers::Offset<TusUser> user) {
fbb_.AddOffset(TusGetMultiSlotVariableRequest::VT_USER, user);
}
void add_slotIdArray(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray) {
fbb_.AddOffset(TusGetMultiSlotVariableRequest::VT_SLOTIDARRAY, slotIdArray);
}
explicit TusGetMultiSlotVariableRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TusGetMultiSlotVariableRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<TusGetMultiSlotVariableRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<TusGetMultiSlotVariableRequest> CreateTusGetMultiSlotVariableRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<TusUser> user = 0,
::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray = 0) {
TusGetMultiSlotVariableRequestBuilder builder_(_fbb);
builder_.add_slotIdArray(slotIdArray);
builder_.add_user(user);
return builder_.Finish();
}
inline ::flatbuffers::Offset<TusGetMultiSlotVariableRequest> CreateTusGetMultiSlotVariableRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<TusUser> user = 0,
const std::vector<int32_t> *slotIdArray = nullptr) {
auto slotIdArray__ = slotIdArray ? _fbb.CreateVector<int32_t>(*slotIdArray) : 0;
return CreateTusGetMultiSlotVariableRequest(
_fbb,
user,
slotIdArray__);
}
struct TusGetMultiUserVariableRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TusGetMultiUserVariableRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_USERS = 4,
VT_SLOTID = 6
};
const ::flatbuffers::Vector<::flatbuffers::Offset<TusUser>> *users() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<TusUser>> *>(VT_USERS);
}
int32_t slotId() const {
return GetField<int32_t>(VT_SLOTID, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_USERS) &&
verifier.VerifyVector(users()) &&
verifier.VerifyVectorOfTables(users()) &&
VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
verifier.EndTable();
}
};
struct TusGetMultiUserVariableRequestBuilder {
typedef TusGetMultiUserVariableRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_users(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusUser>>> users) {
fbb_.AddOffset(TusGetMultiUserVariableRequest::VT_USERS, users);
}
void add_slotId(int32_t slotId) {
fbb_.AddElement<int32_t>(TusGetMultiUserVariableRequest::VT_SLOTID, slotId, 0);
}
explicit TusGetMultiUserVariableRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TusGetMultiUserVariableRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<TusGetMultiUserVariableRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<TusGetMultiUserVariableRequest> CreateTusGetMultiUserVariableRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusUser>>> users = 0,
int32_t slotId = 0) {
TusGetMultiUserVariableRequestBuilder builder_(_fbb);
builder_.add_slotId(slotId);
builder_.add_users(users);
return builder_.Finish();
}
inline ::flatbuffers::Offset<TusGetMultiUserVariableRequest> CreateTusGetMultiUserVariableRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<::flatbuffers::Offset<TusUser>> *users = nullptr,
int32_t slotId = 0) {
auto users__ = users ? _fbb.CreateVector<::flatbuffers::Offset<TusUser>>(*users) : 0;
return CreateTusGetMultiUserVariableRequest(
_fbb,
users__,
slotId);
}
struct TusGetFriendsVariableRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TusGetFriendsVariableRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SLOTID = 4,
VT_INCLUDESELF = 6,
VT_SORTTYPE = 8,
VT_ARRAYNUM = 10
};
int32_t slotId() const {
return GetField<int32_t>(VT_SLOTID, 0);
}
bool includeSelf() const {
return GetField<uint8_t>(VT_INCLUDESELF, 0) != 0;
}
int32_t sortType() const {
return GetField<int32_t>(VT_SORTTYPE, 0);
}
uint32_t arrayNum() const {
return GetField<uint32_t>(VT_ARRAYNUM, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
VerifyField<uint8_t>(verifier, VT_INCLUDESELF, 1) &&
VerifyField<int32_t>(verifier, VT_SORTTYPE, 4) &&
VerifyField<uint32_t>(verifier, VT_ARRAYNUM, 4) &&
verifier.EndTable();
}
};
struct TusGetFriendsVariableRequestBuilder {
typedef TusGetFriendsVariableRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_slotId(int32_t slotId) {
fbb_.AddElement<int32_t>(TusGetFriendsVariableRequest::VT_SLOTID, slotId, 0);
}
void add_includeSelf(bool includeSelf) {
fbb_.AddElement<uint8_t>(TusGetFriendsVariableRequest::VT_INCLUDESELF, static_cast<uint8_t>(includeSelf), 0);
}
void add_sortType(int32_t sortType) {
fbb_.AddElement<int32_t>(TusGetFriendsVariableRequest::VT_SORTTYPE, sortType, 0);
}
void add_arrayNum(uint32_t arrayNum) {
fbb_.AddElement<uint32_t>(TusGetFriendsVariableRequest::VT_ARRAYNUM, arrayNum, 0);
}
explicit TusGetFriendsVariableRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TusGetFriendsVariableRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<TusGetFriendsVariableRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<TusGetFriendsVariableRequest> CreateTusGetFriendsVariableRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
int32_t slotId = 0,
bool includeSelf = false,
int32_t sortType = 0,
uint32_t arrayNum = 0) {
TusGetFriendsVariableRequestBuilder builder_(_fbb);
builder_.add_arrayNum(arrayNum);
builder_.add_sortType(sortType);
builder_.add_slotId(slotId);
builder_.add_includeSelf(includeSelf);
return builder_.Finish();
}
struct TusAddAndGetVariableRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TusAddAndGetVariableRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_USER = 4,
VT_SLOTID = 6,
VT_INVARIABLE = 8,
VT_ISLASTCHANGEDDATE = 10,
VT_ISLASTCHANGEDAUTHORID = 12
};
const TusUser *user() const {
return GetPointer<const TusUser *>(VT_USER);
}
int32_t slotId() const {
return GetField<int32_t>(VT_SLOTID, 0);
}
int64_t inVariable() const {
return GetField<int64_t>(VT_INVARIABLE, 0);
}
const ::flatbuffers::Vector<uint64_t> *isLastChangedDate() const {
return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_ISLASTCHANGEDDATE);
}
const ::flatbuffers::String *isLastChangedAuthorId() const {
return GetPointer<const ::flatbuffers::String *>(VT_ISLASTCHANGEDAUTHORID);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_USER) &&
verifier.VerifyTable(user()) &&
VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
VerifyField<int64_t>(verifier, VT_INVARIABLE, 8) &&
VerifyOffset(verifier, VT_ISLASTCHANGEDDATE) &&
verifier.VerifyVector(isLastChangedDate()) &&
VerifyOffset(verifier, VT_ISLASTCHANGEDAUTHORID) &&
verifier.VerifyString(isLastChangedAuthorId()) &&
verifier.EndTable();
}
};
struct TusAddAndGetVariableRequestBuilder {
typedef TusAddAndGetVariableRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_user(::flatbuffers::Offset<TusUser> user) {
fbb_.AddOffset(TusAddAndGetVariableRequest::VT_USER, user);
}
void add_slotId(int32_t slotId) {
fbb_.AddElement<int32_t>(TusAddAndGetVariableRequest::VT_SLOTID, slotId, 0);
}
void add_inVariable(int64_t inVariable) {
fbb_.AddElement<int64_t>(TusAddAndGetVariableRequest::VT_INVARIABLE, inVariable, 0);
}
void add_isLastChangedDate(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> isLastChangedDate) {
fbb_.AddOffset(TusAddAndGetVariableRequest::VT_ISLASTCHANGEDDATE, isLastChangedDate);
}
void add_isLastChangedAuthorId(::flatbuffers::Offset<::flatbuffers::String> isLastChangedAuthorId) {
fbb_.AddOffset(TusAddAndGetVariableRequest::VT_ISLASTCHANGEDAUTHORID, isLastChangedAuthorId);
}
explicit TusAddAndGetVariableRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TusAddAndGetVariableRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<TusAddAndGetVariableRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<TusAddAndGetVariableRequest> CreateTusAddAndGetVariableRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<TusUser> user = 0,
int32_t slotId = 0,
int64_t inVariable = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> isLastChangedDate = 0,
::flatbuffers::Offset<::flatbuffers::String> isLastChangedAuthorId = 0) {
TusAddAndGetVariableRequestBuilder builder_(_fbb);
builder_.add_inVariable(inVariable);
builder_.add_isLastChangedAuthorId(isLastChangedAuthorId);
builder_.add_isLastChangedDate(isLastChangedDate);
builder_.add_slotId(slotId);
builder_.add_user(user);
return builder_.Finish();
}
inline ::flatbuffers::Offset<TusAddAndGetVariableRequest> CreateTusAddAndGetVariableRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<TusUser> user = 0,
int32_t slotId = 0,
int64_t inVariable = 0,
const std::vector<uint64_t> *isLastChangedDate = nullptr,
const char *isLastChangedAuthorId = nullptr) {
auto isLastChangedDate__ = isLastChangedDate ? _fbb.CreateVector<uint64_t>(*isLastChangedDate) : 0;
auto isLastChangedAuthorId__ = isLastChangedAuthorId ? _fbb.CreateString(isLastChangedAuthorId) : 0;
return CreateTusAddAndGetVariableRequest(
_fbb,
user,
slotId,
inVariable,
isLastChangedDate__,
isLastChangedAuthorId__);
}
struct TusTryAndSetVariableRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TusTryAndSetVariableRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_USER = 4,
VT_SLOTID = 6,
VT_OPETYPE = 8,
VT_VARIABLE = 10,
VT_ISLASTCHANGEDDATE = 12,
VT_ISLASTCHANGEDAUTHORID = 14,
VT_COMPAREVALUE = 16
};
const TusUser *user() const {
return GetPointer<const TusUser *>(VT_USER);
}
int32_t slotId() const {
return GetField<int32_t>(VT_SLOTID, 0);
}
int32_t opeType() const {
return GetField<int32_t>(VT_OPETYPE, 0);
}
int64_t variable() const {
return GetField<int64_t>(VT_VARIABLE, 0);
}
const ::flatbuffers::Vector<uint64_t> *isLastChangedDate() const {
return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_ISLASTCHANGEDDATE);
}
const ::flatbuffers::String *isLastChangedAuthorId() const {
return GetPointer<const ::flatbuffers::String *>(VT_ISLASTCHANGEDAUTHORID);
}
const ::flatbuffers::Vector<int64_t> *compareValue() const {
return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_COMPAREVALUE);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_USER) &&
verifier.VerifyTable(user()) &&
VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
VerifyField<int32_t>(verifier, VT_OPETYPE, 4) &&
VerifyField<int64_t>(verifier, VT_VARIABLE, 8) &&
VerifyOffset(verifier, VT_ISLASTCHANGEDDATE) &&
verifier.VerifyVector(isLastChangedDate()) &&
VerifyOffset(verifier, VT_ISLASTCHANGEDAUTHORID) &&
verifier.VerifyString(isLastChangedAuthorId()) &&
VerifyOffset(verifier, VT_COMPAREVALUE) &&
verifier.VerifyVector(compareValue()) &&
verifier.EndTable();
}
};
struct TusTryAndSetVariableRequestBuilder {
typedef TusTryAndSetVariableRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_user(::flatbuffers::Offset<TusUser> user) {
fbb_.AddOffset(TusTryAndSetVariableRequest::VT_USER, user);
}
void add_slotId(int32_t slotId) {
fbb_.AddElement<int32_t>(TusTryAndSetVariableRequest::VT_SLOTID, slotId, 0);
}
void add_opeType(int32_t opeType) {
fbb_.AddElement<int32_t>(TusTryAndSetVariableRequest::VT_OPETYPE, opeType, 0);
}
void add_variable(int64_t variable) {
fbb_.AddElement<int64_t>(TusTryAndSetVariableRequest::VT_VARIABLE, variable, 0);
}
void add_isLastChangedDate(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> isLastChangedDate) {
fbb_.AddOffset(TusTryAndSetVariableRequest::VT_ISLASTCHANGEDDATE, isLastChangedDate);
}
void add_isLastChangedAuthorId(::flatbuffers::Offset<::flatbuffers::String> isLastChangedAuthorId) {
fbb_.AddOffset(TusTryAndSetVariableRequest::VT_ISLASTCHANGEDAUTHORID, isLastChangedAuthorId);
}
void add_compareValue(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> compareValue) {
fbb_.AddOffset(TusTryAndSetVariableRequest::VT_COMPAREVALUE, compareValue);
}
explicit TusTryAndSetVariableRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TusTryAndSetVariableRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<TusTryAndSetVariableRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<TusTryAndSetVariableRequest> CreateTusTryAndSetVariableRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<TusUser> user = 0,
int32_t slotId = 0,
int32_t opeType = 0,
int64_t variable = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> isLastChangedDate = 0,
::flatbuffers::Offset<::flatbuffers::String> isLastChangedAuthorId = 0,
::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> compareValue = 0) {
TusTryAndSetVariableRequestBuilder builder_(_fbb);
builder_.add_variable(variable);
builder_.add_compareValue(compareValue);
builder_.add_isLastChangedAuthorId(isLastChangedAuthorId);
builder_.add_isLastChangedDate(isLastChangedDate);
builder_.add_opeType(opeType);
builder_.add_slotId(slotId);
builder_.add_user(user);
return builder_.Finish();
}
inline ::flatbuffers::Offset<TusTryAndSetVariableRequest> CreateTusTryAndSetVariableRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<TusUser> user = 0,
int32_t slotId = 0,
int32_t opeType = 0,
int64_t variable = 0,
const std::vector<uint64_t> *isLastChangedDate = nullptr,
const char *isLastChangedAuthorId = nullptr,
const std::vector<int64_t> *compareValue = nullptr) {
auto isLastChangedDate__ = isLastChangedDate ? _fbb.CreateVector<uint64_t>(*isLastChangedDate) : 0;
auto isLastChangedAuthorId__ = isLastChangedAuthorId ? _fbb.CreateString(isLastChangedAuthorId) : 0;
auto compareValue__ = compareValue ? _fbb.CreateVector<int64_t>(*compareValue) : 0;
return CreateTusTryAndSetVariableRequest(
_fbb,
user,
slotId,
opeType,
variable,
isLastChangedDate__,
isLastChangedAuthorId__,
compareValue__);
}
struct TusDeleteMultiSlotVariableRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TusDeleteMultiSlotVariableRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_USER = 4,
VT_SLOTIDARRAY = 6
};
const TusUser *user() const {
return GetPointer<const TusUser *>(VT_USER);
}
const ::flatbuffers::Vector<int32_t> *slotIdArray() const {
return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SLOTIDARRAY);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_USER) &&
verifier.VerifyTable(user()) &&
VerifyOffset(verifier, VT_SLOTIDARRAY) &&
verifier.VerifyVector(slotIdArray()) &&
verifier.EndTable();
}
};
struct TusDeleteMultiSlotVariableRequestBuilder {
typedef TusDeleteMultiSlotVariableRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_user(::flatbuffers::Offset<TusUser> user) {
fbb_.AddOffset(TusDeleteMultiSlotVariableRequest::VT_USER, user);
}
void add_slotIdArray(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray) {
fbb_.AddOffset(TusDeleteMultiSlotVariableRequest::VT_SLOTIDARRAY, slotIdArray);
}
explicit TusDeleteMultiSlotVariableRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TusDeleteMultiSlotVariableRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<TusDeleteMultiSlotVariableRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<TusDeleteMultiSlotVariableRequest> CreateTusDeleteMultiSlotVariableRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<TusUser> user = 0,
::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray = 0) {
TusDeleteMultiSlotVariableRequestBuilder builder_(_fbb);
builder_.add_slotIdArray(slotIdArray);
builder_.add_user(user);
return builder_.Finish();
}
inline ::flatbuffers::Offset<TusDeleteMultiSlotVariableRequest> CreateTusDeleteMultiSlotVariableRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<TusUser> user = 0,
const std::vector<int32_t> *slotIdArray = nullptr) {
auto slotIdArray__ = slotIdArray ? _fbb.CreateVector<int32_t>(*slotIdArray) : 0;
return CreateTusDeleteMultiSlotVariableRequest(
_fbb,
user,
slotIdArray__);
}
struct TusSetDataRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TusSetDataRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_USER = 4,
VT_SLOTID = 6,
VT_DATA = 8,
VT_INFO = 10,
VT_ISLASTCHANGEDDATE = 12,
VT_ISLASTCHANGEDAUTHORID = 14
};
const TusUser *user() const {
return GetPointer<const TusUser *>(VT_USER);
}
int32_t slotId() const {
return GetField<int32_t>(VT_SLOTID, 0);
}
const ::flatbuffers::Vector<uint8_t> *data() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
}
const ::flatbuffers::Vector<uint8_t> *info() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_INFO);
}
const ::flatbuffers::Vector<uint64_t> *isLastChangedDate() const {
return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_ISLASTCHANGEDDATE);
}
const ::flatbuffers::String *isLastChangedAuthorId() const {
return GetPointer<const ::flatbuffers::String *>(VT_ISLASTCHANGEDAUTHORID);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_USER) &&
verifier.VerifyTable(user()) &&
VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
VerifyOffset(verifier, VT_DATA) &&
verifier.VerifyVector(data()) &&
VerifyOffset(verifier, VT_INFO) &&
verifier.VerifyVector(info()) &&
VerifyOffset(verifier, VT_ISLASTCHANGEDDATE) &&
verifier.VerifyVector(isLastChangedDate()) &&
VerifyOffset(verifier, VT_ISLASTCHANGEDAUTHORID) &&
verifier.VerifyString(isLastChangedAuthorId()) &&
verifier.EndTable();
}
};
struct TusSetDataRequestBuilder {
typedef TusSetDataRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_user(::flatbuffers::Offset<TusUser> user) {
fbb_.AddOffset(TusSetDataRequest::VT_USER, user);
}
void add_slotId(int32_t slotId) {
fbb_.AddElement<int32_t>(TusSetDataRequest::VT_SLOTID, slotId, 0);
}
void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
fbb_.AddOffset(TusSetDataRequest::VT_DATA, data);
}
void add_info(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> info) {
fbb_.AddOffset(TusSetDataRequest::VT_INFO, info);
}
void add_isLastChangedDate(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> isLastChangedDate) {
fbb_.AddOffset(TusSetDataRequest::VT_ISLASTCHANGEDDATE, isLastChangedDate);
}
void add_isLastChangedAuthorId(::flatbuffers::Offset<::flatbuffers::String> isLastChangedAuthorId) {
fbb_.AddOffset(TusSetDataRequest::VT_ISLASTCHANGEDAUTHORID, isLastChangedAuthorId);
}
explicit TusSetDataRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TusSetDataRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<TusSetDataRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<TusSetDataRequest> CreateTusSetDataRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<TusUser> user = 0,
int32_t slotId = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> info = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> isLastChangedDate = 0,
::flatbuffers::Offset<::flatbuffers::String> isLastChangedAuthorId = 0) {
TusSetDataRequestBuilder builder_(_fbb);
builder_.add_isLastChangedAuthorId(isLastChangedAuthorId);
builder_.add_isLastChangedDate(isLastChangedDate);
builder_.add_info(info);
builder_.add_data(data);
builder_.add_slotId(slotId);
builder_.add_user(user);
return builder_.Finish();
}
inline ::flatbuffers::Offset<TusSetDataRequest> CreateTusSetDataRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<TusUser> user = 0,
int32_t slotId = 0,
const std::vector<uint8_t> *data = nullptr,
const std::vector<uint8_t> *info = nullptr,
const std::vector<uint64_t> *isLastChangedDate = nullptr,
const char *isLastChangedAuthorId = nullptr) {
auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
auto info__ = info ? _fbb.CreateVector<uint8_t>(*info) : 0;
auto isLastChangedDate__ = isLastChangedDate ? _fbb.CreateVector<uint64_t>(*isLastChangedDate) : 0;
auto isLastChangedAuthorId__ = isLastChangedAuthorId ? _fbb.CreateString(isLastChangedAuthorId) : 0;
return CreateTusSetDataRequest(
_fbb,
user,
slotId,
data__,
info__,
isLastChangedDate__,
isLastChangedAuthorId__);
}
struct TusDataStatus FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TusDataStatusBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_OWNERID = 4,
VT_HASDATA = 6,
VT_LASTCHANGEDDATE = 8,
VT_LASTCHANGEDAUTHORID = 10,
VT_INFO = 12
};
const ::flatbuffers::String *ownerId() const {
return GetPointer<const ::flatbuffers::String *>(VT_OWNERID);
}
bool hasData() const {
return GetField<uint8_t>(VT_HASDATA, 0) != 0;
}
uint64_t lastChangedDate() const {
return GetField<uint64_t>(VT_LASTCHANGEDDATE, 0);
}
const ::flatbuffers::String *lastChangedAuthorId() const {
return GetPointer<const ::flatbuffers::String *>(VT_LASTCHANGEDAUTHORID);
}
const ::flatbuffers::Vector<uint8_t> *info() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_INFO);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_OWNERID) &&
verifier.VerifyString(ownerId()) &&
VerifyField<uint8_t>(verifier, VT_HASDATA, 1) &&
VerifyField<uint64_t>(verifier, VT_LASTCHANGEDDATE, 8) &&
VerifyOffset(verifier, VT_LASTCHANGEDAUTHORID) &&
verifier.VerifyString(lastChangedAuthorId()) &&
VerifyOffset(verifier, VT_INFO) &&
verifier.VerifyVector(info()) &&
verifier.EndTable();
}
};
struct TusDataStatusBuilder {
typedef TusDataStatus Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_ownerId(::flatbuffers::Offset<::flatbuffers::String> ownerId) {
fbb_.AddOffset(TusDataStatus::VT_OWNERID, ownerId);
}
void add_hasData(bool hasData) {
fbb_.AddElement<uint8_t>(TusDataStatus::VT_HASDATA, static_cast<uint8_t>(hasData), 0);
}
void add_lastChangedDate(uint64_t lastChangedDate) {
fbb_.AddElement<uint64_t>(TusDataStatus::VT_LASTCHANGEDDATE, lastChangedDate, 0);
}
void add_lastChangedAuthorId(::flatbuffers::Offset<::flatbuffers::String> lastChangedAuthorId) {
fbb_.AddOffset(TusDataStatus::VT_LASTCHANGEDAUTHORID, lastChangedAuthorId);
}
void add_info(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> info) {
fbb_.AddOffset(TusDataStatus::VT_INFO, info);
}
explicit TusDataStatusBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TusDataStatus> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<TusDataStatus>(end);
return o;
}
};
inline ::flatbuffers::Offset<TusDataStatus> CreateTusDataStatus(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::String> ownerId = 0,
bool hasData = false,
uint64_t lastChangedDate = 0,
::flatbuffers::Offset<::flatbuffers::String> lastChangedAuthorId = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> info = 0) {
TusDataStatusBuilder builder_(_fbb);
builder_.add_lastChangedDate(lastChangedDate);
builder_.add_info(info);
builder_.add_lastChangedAuthorId(lastChangedAuthorId);
builder_.add_ownerId(ownerId);
builder_.add_hasData(hasData);
return builder_.Finish();
}
inline ::flatbuffers::Offset<TusDataStatus> CreateTusDataStatusDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const char *ownerId = nullptr,
bool hasData = false,
uint64_t lastChangedDate = 0,
const char *lastChangedAuthorId = nullptr,
const std::vector<uint8_t> *info = nullptr) {
auto ownerId__ = ownerId ? _fbb.CreateString(ownerId) : 0;
auto lastChangedAuthorId__ = lastChangedAuthorId ? _fbb.CreateString(lastChangedAuthorId) : 0;
auto info__ = info ? _fbb.CreateVector<uint8_t>(*info) : 0;
return CreateTusDataStatus(
_fbb,
ownerId__,
hasData,
lastChangedDate,
lastChangedAuthorId__,
info__);
}
struct TusData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TusDataBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_STATUS = 4,
VT_DATA = 6
};
const TusDataStatus *status() const {
return GetPointer<const TusDataStatus *>(VT_STATUS);
}
const ::flatbuffers::Vector<uint8_t> *data() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_STATUS) &&
verifier.VerifyTable(status()) &&
VerifyOffset(verifier, VT_DATA) &&
verifier.VerifyVector(data()) &&
verifier.EndTable();
}
};
struct TusDataBuilder {
typedef TusData Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_status(::flatbuffers::Offset<TusDataStatus> status) {
fbb_.AddOffset(TusData::VT_STATUS, status);
}
void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
fbb_.AddOffset(TusData::VT_DATA, data);
}
explicit TusDataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TusData> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<TusData>(end);
return o;
}
};
inline ::flatbuffers::Offset<TusData> CreateTusData(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<TusDataStatus> status = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
TusDataBuilder builder_(_fbb);
builder_.add_data(data);
builder_.add_status(status);
return builder_.Finish();
}
inline ::flatbuffers::Offset<TusData> CreateTusDataDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<TusDataStatus> status = 0,
const std::vector<uint8_t> *data = nullptr) {
auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
return CreateTusData(
_fbb,
status,
data__);
}
struct TusDataStatusResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TusDataStatusResponseBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_STATUS = 4
};
const ::flatbuffers::Vector<::flatbuffers::Offset<TusDataStatus>> *status() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<TusDataStatus>> *>(VT_STATUS);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_STATUS) &&
verifier.VerifyVector(status()) &&
verifier.VerifyVectorOfTables(status()) &&
verifier.EndTable();
}
};
struct TusDataStatusResponseBuilder {
typedef TusDataStatusResponse Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_status(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusDataStatus>>> status) {
fbb_.AddOffset(TusDataStatusResponse::VT_STATUS, status);
}
explicit TusDataStatusResponseBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TusDataStatusResponse> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<TusDataStatusResponse>(end);
return o;
}
};
inline ::flatbuffers::Offset<TusDataStatusResponse> CreateTusDataStatusResponse(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusDataStatus>>> status = 0) {
TusDataStatusResponseBuilder builder_(_fbb);
builder_.add_status(status);
return builder_.Finish();
}
inline ::flatbuffers::Offset<TusDataStatusResponse> CreateTusDataStatusResponseDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<::flatbuffers::Offset<TusDataStatus>> *status = nullptr) {
auto status__ = status ? _fbb.CreateVector<::flatbuffers::Offset<TusDataStatus>>(*status) : 0;
return CreateTusDataStatusResponse(
_fbb,
status__);
}
struct TusGetDataRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TusGetDataRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_USER = 4,
VT_SLOTID = 6
};
const TusUser *user() const {
return GetPointer<const TusUser *>(VT_USER);
}
int32_t slotId() const {
return GetField<int32_t>(VT_SLOTID, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_USER) &&
verifier.VerifyTable(user()) &&
VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
verifier.EndTable();
}
};
struct TusGetDataRequestBuilder {
typedef TusGetDataRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_user(::flatbuffers::Offset<TusUser> user) {
fbb_.AddOffset(TusGetDataRequest::VT_USER, user);
}
void add_slotId(int32_t slotId) {
fbb_.AddElement<int32_t>(TusGetDataRequest::VT_SLOTID, slotId, 0);
}
explicit TusGetDataRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TusGetDataRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<TusGetDataRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<TusGetDataRequest> CreateTusGetDataRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<TusUser> user = 0,
int32_t slotId = 0) {
TusGetDataRequestBuilder builder_(_fbb);
builder_.add_slotId(slotId);
builder_.add_user(user);
return builder_.Finish();
}
struct TusGetMultiSlotDataStatusRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TusGetMultiSlotDataStatusRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_USER = 4,
VT_SLOTIDARRAY = 6
};
const TusUser *user() const {
return GetPointer<const TusUser *>(VT_USER);
}
const ::flatbuffers::Vector<int32_t> *slotIdArray() const {
return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SLOTIDARRAY);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_USER) &&
verifier.VerifyTable(user()) &&
VerifyOffset(verifier, VT_SLOTIDARRAY) &&
verifier.VerifyVector(slotIdArray()) &&
verifier.EndTable();
}
};
struct TusGetMultiSlotDataStatusRequestBuilder {
typedef TusGetMultiSlotDataStatusRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_user(::flatbuffers::Offset<TusUser> user) {
fbb_.AddOffset(TusGetMultiSlotDataStatusRequest::VT_USER, user);
}
void add_slotIdArray(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray) {
fbb_.AddOffset(TusGetMultiSlotDataStatusRequest::VT_SLOTIDARRAY, slotIdArray);
}
explicit TusGetMultiSlotDataStatusRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TusGetMultiSlotDataStatusRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<TusGetMultiSlotDataStatusRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<TusGetMultiSlotDataStatusRequest> CreateTusGetMultiSlotDataStatusRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<TusUser> user = 0,
::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray = 0) {
TusGetMultiSlotDataStatusRequestBuilder builder_(_fbb);
builder_.add_slotIdArray(slotIdArray);
builder_.add_user(user);
return builder_.Finish();
}
inline ::flatbuffers::Offset<TusGetMultiSlotDataStatusRequest> CreateTusGetMultiSlotDataStatusRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<TusUser> user = 0,
const std::vector<int32_t> *slotIdArray = nullptr) {
auto slotIdArray__ = slotIdArray ? _fbb.CreateVector<int32_t>(*slotIdArray) : 0;
return CreateTusGetMultiSlotDataStatusRequest(
_fbb,
user,
slotIdArray__);
}
struct TusGetMultiUserDataStatusRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TusGetMultiUserDataStatusRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_USERS = 4,
VT_SLOTID = 6
};
const ::flatbuffers::Vector<::flatbuffers::Offset<TusUser>> *users() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<TusUser>> *>(VT_USERS);
}
int32_t slotId() const {
return GetField<int32_t>(VT_SLOTID, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_USERS) &&
verifier.VerifyVector(users()) &&
verifier.VerifyVectorOfTables(users()) &&
VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
verifier.EndTable();
}
};
struct TusGetMultiUserDataStatusRequestBuilder {
typedef TusGetMultiUserDataStatusRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_users(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusUser>>> users) {
fbb_.AddOffset(TusGetMultiUserDataStatusRequest::VT_USERS, users);
}
void add_slotId(int32_t slotId) {
fbb_.AddElement<int32_t>(TusGetMultiUserDataStatusRequest::VT_SLOTID, slotId, 0);
}
explicit TusGetMultiUserDataStatusRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TusGetMultiUserDataStatusRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<TusGetMultiUserDataStatusRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<TusGetMultiUserDataStatusRequest> CreateTusGetMultiUserDataStatusRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusUser>>> users = 0,
int32_t slotId = 0) {
TusGetMultiUserDataStatusRequestBuilder builder_(_fbb);
builder_.add_slotId(slotId);
builder_.add_users(users);
return builder_.Finish();
}
inline ::flatbuffers::Offset<TusGetMultiUserDataStatusRequest> CreateTusGetMultiUserDataStatusRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<::flatbuffers::Offset<TusUser>> *users = nullptr,
int32_t slotId = 0) {
auto users__ = users ? _fbb.CreateVector<::flatbuffers::Offset<TusUser>>(*users) : 0;
return CreateTusGetMultiUserDataStatusRequest(
_fbb,
users__,
slotId);
}
struct TusGetFriendsDataStatusRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TusGetFriendsDataStatusRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SLOTID = 4,
VT_INCLUDESELF = 6,
VT_SORTTYPE = 8,
VT_ARRAYNUM = 10
};
int32_t slotId() const {
return GetField<int32_t>(VT_SLOTID, 0);
}
bool includeSelf() const {
return GetField<uint8_t>(VT_INCLUDESELF, 0) != 0;
}
int32_t sortType() const {
return GetField<int32_t>(VT_SORTTYPE, 0);
}
uint32_t arrayNum() const {
return GetField<uint32_t>(VT_ARRAYNUM, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
VerifyField<uint8_t>(verifier, VT_INCLUDESELF, 1) &&
VerifyField<int32_t>(verifier, VT_SORTTYPE, 4) &&
VerifyField<uint32_t>(verifier, VT_ARRAYNUM, 4) &&
verifier.EndTable();
}
};
struct TusGetFriendsDataStatusRequestBuilder {
typedef TusGetFriendsDataStatusRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_slotId(int32_t slotId) {
fbb_.AddElement<int32_t>(TusGetFriendsDataStatusRequest::VT_SLOTID, slotId, 0);
}
void add_includeSelf(bool includeSelf) {
fbb_.AddElement<uint8_t>(TusGetFriendsDataStatusRequest::VT_INCLUDESELF, static_cast<uint8_t>(includeSelf), 0);
}
void add_sortType(int32_t sortType) {
fbb_.AddElement<int32_t>(TusGetFriendsDataStatusRequest::VT_SORTTYPE, sortType, 0);
}
void add_arrayNum(uint32_t arrayNum) {
fbb_.AddElement<uint32_t>(TusGetFriendsDataStatusRequest::VT_ARRAYNUM, arrayNum, 0);
}
explicit TusGetFriendsDataStatusRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TusGetFriendsDataStatusRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<TusGetFriendsDataStatusRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<TusGetFriendsDataStatusRequest> CreateTusGetFriendsDataStatusRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
int32_t slotId = 0,
bool includeSelf = false,
int32_t sortType = 0,
uint32_t arrayNum = 0) {
TusGetFriendsDataStatusRequestBuilder builder_(_fbb);
builder_.add_arrayNum(arrayNum);
builder_.add_sortType(sortType);
builder_.add_slotId(slotId);
builder_.add_includeSelf(includeSelf);
return builder_.Finish();
}
struct TusDeleteMultiSlotDataRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TusDeleteMultiSlotDataRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_USER = 4,
VT_SLOTIDARRAY = 6
};
const TusUser *user() const {
return GetPointer<const TusUser *>(VT_USER);
}
const ::flatbuffers::Vector<int32_t> *slotIdArray() const {
return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SLOTIDARRAY);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_USER) &&
verifier.VerifyTable(user()) &&
VerifyOffset(verifier, VT_SLOTIDARRAY) &&
verifier.VerifyVector(slotIdArray()) &&
verifier.EndTable();
}
};
struct TusDeleteMultiSlotDataRequestBuilder {
typedef TusDeleteMultiSlotDataRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_user(::flatbuffers::Offset<TusUser> user) {
fbb_.AddOffset(TusDeleteMultiSlotDataRequest::VT_USER, user);
}
void add_slotIdArray(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray) {
fbb_.AddOffset(TusDeleteMultiSlotDataRequest::VT_SLOTIDARRAY, slotIdArray);
}
explicit TusDeleteMultiSlotDataRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<TusDeleteMultiSlotDataRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<TusDeleteMultiSlotDataRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<TusDeleteMultiSlotDataRequest> CreateTusDeleteMultiSlotDataRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<TusUser> user = 0,
::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray = 0) {
TusDeleteMultiSlotDataRequestBuilder builder_(_fbb);
builder_.add_slotIdArray(slotIdArray);
builder_.add_user(user);
return builder_.Finish();
}
inline ::flatbuffers::Offset<TusDeleteMultiSlotDataRequest> CreateTusDeleteMultiSlotDataRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<TusUser> user = 0,
const std::vector<int32_t> *slotIdArray = nullptr) {
auto slotIdArray__ = slotIdArray ? _fbb.CreateVector<int32_t>(*slotIdArray) : 0;
return CreateTusDeleteMultiSlotDataRequest(
_fbb,
user,
slotIdArray__);
}
struct SetPresenceRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef SetPresenceRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_TITLE = 4,
VT_STATUS = 6,
VT_COMMENT = 8,
VT_DATA = 10
};
const ::flatbuffers::String *title() const {
return GetPointer<const ::flatbuffers::String *>(VT_TITLE);
}
const ::flatbuffers::String *status() const {
return GetPointer<const ::flatbuffers::String *>(VT_STATUS);
}
const ::flatbuffers::String *comment() const {
return GetPointer<const ::flatbuffers::String *>(VT_COMMENT);
}
const ::flatbuffers::Vector<uint8_t> *data() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_TITLE) &&
verifier.VerifyString(title()) &&
VerifyOffset(verifier, VT_STATUS) &&
verifier.VerifyString(status()) &&
VerifyOffset(verifier, VT_COMMENT) &&
verifier.VerifyString(comment()) &&
VerifyOffset(verifier, VT_DATA) &&
verifier.VerifyVector(data()) &&
verifier.EndTable();
}
};
struct SetPresenceRequestBuilder {
typedef SetPresenceRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_title(::flatbuffers::Offset<::flatbuffers::String> title) {
fbb_.AddOffset(SetPresenceRequest::VT_TITLE, title);
}
void add_status(::flatbuffers::Offset<::flatbuffers::String> status) {
fbb_.AddOffset(SetPresenceRequest::VT_STATUS, status);
}
void add_comment(::flatbuffers::Offset<::flatbuffers::String> comment) {
fbb_.AddOffset(SetPresenceRequest::VT_COMMENT, comment);
}
void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
fbb_.AddOffset(SetPresenceRequest::VT_DATA, data);
}
explicit SetPresenceRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<SetPresenceRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<SetPresenceRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<SetPresenceRequest> CreateSetPresenceRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::String> title = 0,
::flatbuffers::Offset<::flatbuffers::String> status = 0,
::flatbuffers::Offset<::flatbuffers::String> comment = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
SetPresenceRequestBuilder builder_(_fbb);
builder_.add_data(data);
builder_.add_comment(comment);
builder_.add_status(status);
builder_.add_title(title);
return builder_.Finish();
}
inline ::flatbuffers::Offset<SetPresenceRequest> CreateSetPresenceRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const char *title = nullptr,
const char *status = nullptr,
const char *comment = nullptr,
const std::vector<uint8_t> *data = nullptr) {
auto title__ = title ? _fbb.CreateString(title) : 0;
auto status__ = status ? _fbb.CreateString(status) : 0;
auto comment__ = comment ? _fbb.CreateString(comment) : 0;
auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
return CreateSetPresenceRequest(
_fbb,
title__,
status__,
comment__,
data__);
}
struct MatchingSearchCondition FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef MatchingSearchConditionBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ATTR_TYPE = 4,
VT_ATTR_ID = 6,
VT_COMP_OP = 8,
VT_COMP_VALUE = 10
};
uint32_t attr_type() const {
return GetField<uint32_t>(VT_ATTR_TYPE, 0);
}
uint32_t attr_id() const {
return GetField<uint32_t>(VT_ATTR_ID, 0);
}
uint32_t comp_op() const {
return GetField<uint32_t>(VT_COMP_OP, 0);
}
uint32_t comp_value() const {
return GetField<uint32_t>(VT_COMP_VALUE, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_ATTR_TYPE, 4) &&
VerifyField<uint32_t>(verifier, VT_ATTR_ID, 4) &&
VerifyField<uint32_t>(verifier, VT_COMP_OP, 4) &&
VerifyField<uint32_t>(verifier, VT_COMP_VALUE, 4) &&
verifier.EndTable();
}
};
struct MatchingSearchConditionBuilder {
typedef MatchingSearchCondition Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_attr_type(uint32_t attr_type) {
fbb_.AddElement<uint32_t>(MatchingSearchCondition::VT_ATTR_TYPE, attr_type, 0);
}
void add_attr_id(uint32_t attr_id) {
fbb_.AddElement<uint32_t>(MatchingSearchCondition::VT_ATTR_ID, attr_id, 0);
}
void add_comp_op(uint32_t comp_op) {
fbb_.AddElement<uint32_t>(MatchingSearchCondition::VT_COMP_OP, comp_op, 0);
}
void add_comp_value(uint32_t comp_value) {
fbb_.AddElement<uint32_t>(MatchingSearchCondition::VT_COMP_VALUE, comp_value, 0);
}
explicit MatchingSearchConditionBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<MatchingSearchCondition> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<MatchingSearchCondition>(end);
return o;
}
};
inline ::flatbuffers::Offset<MatchingSearchCondition> CreateMatchingSearchCondition(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t attr_type = 0,
uint32_t attr_id = 0,
uint32_t comp_op = 0,
uint32_t comp_value = 0) {
MatchingSearchConditionBuilder builder_(_fbb);
builder_.add_comp_value(comp_value);
builder_.add_comp_op(comp_op);
builder_.add_attr_id(attr_id);
builder_.add_attr_type(attr_type);
return builder_.Finish();
}
struct MatchingAttr FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef MatchingAttrBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ATTR_TYPE = 4,
VT_ATTR_ID = 6,
VT_NUM = 8,
VT_DATA = 10
};
uint32_t attr_type() const {
return GetField<uint32_t>(VT_ATTR_TYPE, 0);
}
uint32_t attr_id() const {
return GetField<uint32_t>(VT_ATTR_ID, 0);
}
uint32_t num() const {
return GetField<uint32_t>(VT_NUM, 0);
}
const ::flatbuffers::Vector<uint8_t> *data() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_ATTR_TYPE, 4) &&
VerifyField<uint32_t>(verifier, VT_ATTR_ID, 4) &&
VerifyField<uint32_t>(verifier, VT_NUM, 4) &&
VerifyOffset(verifier, VT_DATA) &&
verifier.VerifyVector(data()) &&
verifier.EndTable();
}
};
struct MatchingAttrBuilder {
typedef MatchingAttr Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_attr_type(uint32_t attr_type) {
fbb_.AddElement<uint32_t>(MatchingAttr::VT_ATTR_TYPE, attr_type, 0);
}
void add_attr_id(uint32_t attr_id) {
fbb_.AddElement<uint32_t>(MatchingAttr::VT_ATTR_ID, attr_id, 0);
}
void add_num(uint32_t num) {
fbb_.AddElement<uint32_t>(MatchingAttr::VT_NUM, num, 0);
}
void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
fbb_.AddOffset(MatchingAttr::VT_DATA, data);
}
explicit MatchingAttrBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<MatchingAttr> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<MatchingAttr>(end);
return o;
}
};
inline ::flatbuffers::Offset<MatchingAttr> CreateMatchingAttr(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t attr_type = 0,
uint32_t attr_id = 0,
uint32_t num = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
MatchingAttrBuilder builder_(_fbb);
builder_.add_data(data);
builder_.add_num(num);
builder_.add_attr_id(attr_id);
builder_.add_attr_type(attr_type);
return builder_.Finish();
}
inline ::flatbuffers::Offset<MatchingAttr> CreateMatchingAttrDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t attr_type = 0,
uint32_t attr_id = 0,
uint32_t num = 0,
const std::vector<uint8_t> *data = nullptr) {
auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
return CreateMatchingAttr(
_fbb,
attr_type,
attr_id,
num,
data__);
}
struct CreateRoomGUIRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef CreateRoomGUIRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_TOTAL_SLOTS = 4,
VT_PRIVATE_SLOTS = 6,
VT_PRIVILEGE_GRANT = 8,
VT_STEALTH = 10,
VT_GAME_ATTRS = 12
};
uint32_t total_slots() const {
return GetField<uint32_t>(VT_TOTAL_SLOTS, 0);
}
uint32_t private_slots() const {
return GetField<uint32_t>(VT_PRIVATE_SLOTS, 0);
}
bool privilege_grant() const {
return GetField<uint8_t>(VT_PRIVILEGE_GRANT, 0) != 0;
}
bool stealth() const {
return GetField<uint8_t>(VT_STEALTH, 0) != 0;
}
const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>> *game_attrs() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>> *>(VT_GAME_ATTRS);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_TOTAL_SLOTS, 4) &&
VerifyField<uint32_t>(verifier, VT_PRIVATE_SLOTS, 4) &&
VerifyField<uint8_t>(verifier, VT_PRIVILEGE_GRANT, 1) &&
VerifyField<uint8_t>(verifier, VT_STEALTH, 1) &&
VerifyOffset(verifier, VT_GAME_ATTRS) &&
verifier.VerifyVector(game_attrs()) &&
verifier.VerifyVectorOfTables(game_attrs()) &&
verifier.EndTable();
}
};
struct CreateRoomGUIRequestBuilder {
typedef CreateRoomGUIRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_total_slots(uint32_t total_slots) {
fbb_.AddElement<uint32_t>(CreateRoomGUIRequest::VT_TOTAL_SLOTS, total_slots, 0);
}
void add_private_slots(uint32_t private_slots) {
fbb_.AddElement<uint32_t>(CreateRoomGUIRequest::VT_PRIVATE_SLOTS, private_slots, 0);
}
void add_privilege_grant(bool privilege_grant) {
fbb_.AddElement<uint8_t>(CreateRoomGUIRequest::VT_PRIVILEGE_GRANT, static_cast<uint8_t>(privilege_grant), 0);
}
void add_stealth(bool stealth) {
fbb_.AddElement<uint8_t>(CreateRoomGUIRequest::VT_STEALTH, static_cast<uint8_t>(stealth), 0);
}
void add_game_attrs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> game_attrs) {
fbb_.AddOffset(CreateRoomGUIRequest::VT_GAME_ATTRS, game_attrs);
}
explicit CreateRoomGUIRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<CreateRoomGUIRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<CreateRoomGUIRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<CreateRoomGUIRequest> CreateCreateRoomGUIRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t total_slots = 0,
uint32_t private_slots = 0,
bool privilege_grant = false,
bool stealth = false,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> game_attrs = 0) {
CreateRoomGUIRequestBuilder builder_(_fbb);
builder_.add_game_attrs(game_attrs);
builder_.add_private_slots(private_slots);
builder_.add_total_slots(total_slots);
builder_.add_stealth(stealth);
builder_.add_privilege_grant(privilege_grant);
return builder_.Finish();
}
inline ::flatbuffers::Offset<CreateRoomGUIRequest> CreateCreateRoomGUIRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t total_slots = 0,
uint32_t private_slots = 0,
bool privilege_grant = false,
bool stealth = false,
const std::vector<::flatbuffers::Offset<MatchingAttr>> *game_attrs = nullptr) {
auto game_attrs__ = game_attrs ? _fbb.CreateVector<::flatbuffers::Offset<MatchingAttr>>(*game_attrs) : 0;
return CreateCreateRoomGUIRequest(
_fbb,
total_slots,
private_slots,
privilege_grant,
stealth,
game_attrs__);
}
struct GUIUserInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef GUIUserInfoBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_INFO = 4,
VT_OWNER = 6
};
const UserInfo *info() const {
return GetPointer<const UserInfo *>(VT_INFO);
}
bool owner() const {
return GetField<uint8_t>(VT_OWNER, 0) != 0;
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_INFO) &&
verifier.VerifyTable(info()) &&
VerifyField<uint8_t>(verifier, VT_OWNER, 1) &&
verifier.EndTable();
}
};
struct GUIUserInfoBuilder {
typedef GUIUserInfo Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_info(::flatbuffers::Offset<UserInfo> info) {
fbb_.AddOffset(GUIUserInfo::VT_INFO, info);
}
void add_owner(bool owner) {
fbb_.AddElement<uint8_t>(GUIUserInfo::VT_OWNER, static_cast<uint8_t>(owner), 0);
}
explicit GUIUserInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<GUIUserInfo> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<GUIUserInfo>(end);
return o;
}
};
inline ::flatbuffers::Offset<GUIUserInfo> CreateGUIUserInfo(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<UserInfo> info = 0,
bool owner = false) {
GUIUserInfoBuilder builder_(_fbb);
builder_.add_info(info);
builder_.add_owner(owner);
return builder_.Finish();
}
struct MatchingRoomStatus FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef MatchingRoomStatusBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ID = 4,
VT_MEMBERS = 6,
VT_KICK_ACTOR = 8,
VT_OPT = 10
};
const ::flatbuffers::Vector<uint8_t> *id() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_ID);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<GUIUserInfo>> *members() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<GUIUserInfo>> *>(VT_MEMBERS);
}
const ::flatbuffers::String *kick_actor() const {
return GetPointer<const ::flatbuffers::String *>(VT_KICK_ACTOR);
}
const ::flatbuffers::Vector<uint8_t> *opt() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_OPT);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_ID) &&
verifier.VerifyVector(id()) &&
VerifyOffset(verifier, VT_MEMBERS) &&
verifier.VerifyVector(members()) &&
verifier.VerifyVectorOfTables(members()) &&
VerifyOffset(verifier, VT_KICK_ACTOR) &&
verifier.VerifyString(kick_actor()) &&
VerifyOffset(verifier, VT_OPT) &&
verifier.VerifyVector(opt()) &&
verifier.EndTable();
}
};
struct MatchingRoomStatusBuilder {
typedef MatchingRoomStatus Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_id(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> id) {
fbb_.AddOffset(MatchingRoomStatus::VT_ID, id);
}
void add_members(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<GUIUserInfo>>> members) {
fbb_.AddOffset(MatchingRoomStatus::VT_MEMBERS, members);
}
void add_kick_actor(::flatbuffers::Offset<::flatbuffers::String> kick_actor) {
fbb_.AddOffset(MatchingRoomStatus::VT_KICK_ACTOR, kick_actor);
}
void add_opt(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> opt) {
fbb_.AddOffset(MatchingRoomStatus::VT_OPT, opt);
}
explicit MatchingRoomStatusBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<MatchingRoomStatus> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<MatchingRoomStatus>(end);
return o;
}
};
inline ::flatbuffers::Offset<MatchingRoomStatus> CreateMatchingRoomStatus(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> id = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<GUIUserInfo>>> members = 0,
::flatbuffers::Offset<::flatbuffers::String> kick_actor = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> opt = 0) {
MatchingRoomStatusBuilder builder_(_fbb);
builder_.add_opt(opt);
builder_.add_kick_actor(kick_actor);
builder_.add_members(members);
builder_.add_id(id);
return builder_.Finish();
}
inline ::flatbuffers::Offset<MatchingRoomStatus> CreateMatchingRoomStatusDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *id = nullptr,
const std::vector<::flatbuffers::Offset<GUIUserInfo>> *members = nullptr,
const char *kick_actor = nullptr,
const std::vector<uint8_t> *opt = nullptr) {
auto id__ = id ? _fbb.CreateVector<uint8_t>(*id) : 0;
auto members__ = members ? _fbb.CreateVector<::flatbuffers::Offset<GUIUserInfo>>(*members) : 0;
auto kick_actor__ = kick_actor ? _fbb.CreateString(kick_actor) : 0;
auto opt__ = opt ? _fbb.CreateVector<uint8_t>(*opt) : 0;
return CreateMatchingRoomStatus(
_fbb,
id__,
members__,
kick_actor__,
opt__);
}
struct GetRoomListGUIRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef GetRoomListGUIRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_RANGE_START = 4,
VT_RANGE_MAX = 6,
VT_CONDS = 8,
VT_ATTRS = 10
};
uint32_t range_start() const {
return GetField<uint32_t>(VT_RANGE_START, 0);
}
uint32_t range_max() const {
return GetField<uint32_t>(VT_RANGE_MAX, 0);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>> *conds() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>> *>(VT_CONDS);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>> *attrs() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>> *>(VT_ATTRS);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_RANGE_START, 4) &&
VerifyField<uint32_t>(verifier, VT_RANGE_MAX, 4) &&
VerifyOffset(verifier, VT_CONDS) &&
verifier.VerifyVector(conds()) &&
verifier.VerifyVectorOfTables(conds()) &&
VerifyOffset(verifier, VT_ATTRS) &&
verifier.VerifyVector(attrs()) &&
verifier.VerifyVectorOfTables(attrs()) &&
verifier.EndTable();
}
};
struct GetRoomListGUIRequestBuilder {
typedef GetRoomListGUIRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_range_start(uint32_t range_start) {
fbb_.AddElement<uint32_t>(GetRoomListGUIRequest::VT_RANGE_START, range_start, 0);
}
void add_range_max(uint32_t range_max) {
fbb_.AddElement<uint32_t>(GetRoomListGUIRequest::VT_RANGE_MAX, range_max, 0);
}
void add_conds(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>> conds) {
fbb_.AddOffset(GetRoomListGUIRequest::VT_CONDS, conds);
}
void add_attrs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attrs) {
fbb_.AddOffset(GetRoomListGUIRequest::VT_ATTRS, attrs);
}
explicit GetRoomListGUIRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<GetRoomListGUIRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<GetRoomListGUIRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<GetRoomListGUIRequest> CreateGetRoomListGUIRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t range_start = 0,
uint32_t range_max = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>> conds = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attrs = 0) {
GetRoomListGUIRequestBuilder builder_(_fbb);
builder_.add_attrs(attrs);
builder_.add_conds(conds);
builder_.add_range_max(range_max);
builder_.add_range_start(range_start);
return builder_.Finish();
}
inline ::flatbuffers::Offset<GetRoomListGUIRequest> CreateGetRoomListGUIRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t range_start = 0,
uint32_t range_max = 0,
const std::vector<::flatbuffers::Offset<MatchingSearchCondition>> *conds = nullptr,
const std::vector<::flatbuffers::Offset<MatchingAttr>> *attrs = nullptr) {
auto conds__ = conds ? _fbb.CreateVector<::flatbuffers::Offset<MatchingSearchCondition>>(*conds) : 0;
auto attrs__ = attrs ? _fbb.CreateVector<::flatbuffers::Offset<MatchingAttr>>(*attrs) : 0;
return CreateGetRoomListGUIRequest(
_fbb,
range_start,
range_max,
conds__,
attrs__);
}
struct MatchingRoom FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef MatchingRoomBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ID = 4,
VT_ATTR = 6
};
const ::flatbuffers::Vector<uint8_t> *id() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_ID);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>> *attr() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>> *>(VT_ATTR);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_ID) &&
verifier.VerifyVector(id()) &&
VerifyOffset(verifier, VT_ATTR) &&
verifier.VerifyVector(attr()) &&
verifier.VerifyVectorOfTables(attr()) &&
verifier.EndTable();
}
};
struct MatchingRoomBuilder {
typedef MatchingRoom Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_id(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> id) {
fbb_.AddOffset(MatchingRoom::VT_ID, id);
}
void add_attr(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attr) {
fbb_.AddOffset(MatchingRoom::VT_ATTR, attr);
}
explicit MatchingRoomBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<MatchingRoom> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<MatchingRoom>(end);
return o;
}
};
inline ::flatbuffers::Offset<MatchingRoom> CreateMatchingRoom(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> id = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attr = 0) {
MatchingRoomBuilder builder_(_fbb);
builder_.add_attr(attr);
builder_.add_id(id);
return builder_.Finish();
}
inline ::flatbuffers::Offset<MatchingRoom> CreateMatchingRoomDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *id = nullptr,
const std::vector<::flatbuffers::Offset<MatchingAttr>> *attr = nullptr) {
auto id__ = id ? _fbb.CreateVector<uint8_t>(*id) : 0;
auto attr__ = attr ? _fbb.CreateVector<::flatbuffers::Offset<MatchingAttr>>(*attr) : 0;
return CreateMatchingRoom(
_fbb,
id__,
attr__);
}
struct MatchingRoomList FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef MatchingRoomListBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_START = 4,
VT_TOTAL = 6,
VT_ROOMS = 8
};
uint32_t start() const {
return GetField<uint32_t>(VT_START, 0);
}
uint32_t total() const {
return GetField<uint32_t>(VT_TOTAL, 0);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingRoom>> *rooms() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingRoom>> *>(VT_ROOMS);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint32_t>(verifier, VT_START, 4) &&
VerifyField<uint32_t>(verifier, VT_TOTAL, 4) &&
VerifyOffset(verifier, VT_ROOMS) &&
verifier.VerifyVector(rooms()) &&
verifier.VerifyVectorOfTables(rooms()) &&
verifier.EndTable();
}
};
struct MatchingRoomListBuilder {
typedef MatchingRoomList Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_start(uint32_t start) {
fbb_.AddElement<uint32_t>(MatchingRoomList::VT_START, start, 0);
}
void add_total(uint32_t total) {
fbb_.AddElement<uint32_t>(MatchingRoomList::VT_TOTAL, total, 0);
}
void add_rooms(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingRoom>>> rooms) {
fbb_.AddOffset(MatchingRoomList::VT_ROOMS, rooms);
}
explicit MatchingRoomListBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<MatchingRoomList> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<MatchingRoomList>(end);
return o;
}
};
inline ::flatbuffers::Offset<MatchingRoomList> CreateMatchingRoomList(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t start = 0,
uint32_t total = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingRoom>>> rooms = 0) {
MatchingRoomListBuilder builder_(_fbb);
builder_.add_rooms(rooms);
builder_.add_total(total);
builder_.add_start(start);
return builder_.Finish();
}
inline ::flatbuffers::Offset<MatchingRoomList> CreateMatchingRoomListDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint32_t start = 0,
uint32_t total = 0,
const std::vector<::flatbuffers::Offset<MatchingRoom>> *rooms = nullptr) {
auto rooms__ = rooms ? _fbb.CreateVector<::flatbuffers::Offset<MatchingRoom>>(*rooms) : 0;
return CreateMatchingRoomList(
_fbb,
start,
total,
rooms__);
}
struct MatchingGuiRoomId FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef MatchingGuiRoomIdBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ID = 4
};
const ::flatbuffers::Vector<uint8_t> *id() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_ID);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_ID) &&
verifier.VerifyVector(id()) &&
verifier.EndTable();
}
};
struct MatchingGuiRoomIdBuilder {
typedef MatchingGuiRoomId Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_id(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> id) {
fbb_.AddOffset(MatchingGuiRoomId::VT_ID, id);
}
explicit MatchingGuiRoomIdBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<MatchingGuiRoomId> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<MatchingGuiRoomId>(end);
return o;
}
};
inline ::flatbuffers::Offset<MatchingGuiRoomId> CreateMatchingGuiRoomId(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> id = 0) {
MatchingGuiRoomIdBuilder builder_(_fbb);
builder_.add_id(id);
return builder_.Finish();
}
inline ::flatbuffers::Offset<MatchingGuiRoomId> CreateMatchingGuiRoomIdDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *id = nullptr) {
auto id__ = id ? _fbb.CreateVector<uint8_t>(*id) : 0;
return CreateMatchingGuiRoomId(
_fbb,
id__);
}
struct SetRoomSearchFlagGUI FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef SetRoomSearchFlagGUIBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ROOMID = 4,
VT_STEALTH = 6
};
const ::flatbuffers::Vector<uint8_t> *roomid() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_ROOMID);
}
bool stealth() const {
return GetField<uint8_t>(VT_STEALTH, 0) != 0;
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_ROOMID) &&
verifier.VerifyVector(roomid()) &&
VerifyField<uint8_t>(verifier, VT_STEALTH, 1) &&
verifier.EndTable();
}
};
struct SetRoomSearchFlagGUIBuilder {
typedef SetRoomSearchFlagGUI Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_roomid(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> roomid) {
fbb_.AddOffset(SetRoomSearchFlagGUI::VT_ROOMID, roomid);
}
void add_stealth(bool stealth) {
fbb_.AddElement<uint8_t>(SetRoomSearchFlagGUI::VT_STEALTH, static_cast<uint8_t>(stealth), 0);
}
explicit SetRoomSearchFlagGUIBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<SetRoomSearchFlagGUI> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<SetRoomSearchFlagGUI>(end);
return o;
}
};
inline ::flatbuffers::Offset<SetRoomSearchFlagGUI> CreateSetRoomSearchFlagGUI(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> roomid = 0,
bool stealth = false) {
SetRoomSearchFlagGUIBuilder builder_(_fbb);
builder_.add_roomid(roomid);
builder_.add_stealth(stealth);
return builder_.Finish();
}
inline ::flatbuffers::Offset<SetRoomSearchFlagGUI> CreateSetRoomSearchFlagGUIDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *roomid = nullptr,
bool stealth = false) {
auto roomid__ = roomid ? _fbb.CreateVector<uint8_t>(*roomid) : 0;
return CreateSetRoomSearchFlagGUI(
_fbb,
roomid__,
stealth);
}
struct QuickMatchGUIRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef QuickMatchGUIRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_CONDS = 4,
VT_AVAILABLE_NUM = 6
};
const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>> *conds() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>> *>(VT_CONDS);
}
uint32_t available_num() const {
return GetField<uint32_t>(VT_AVAILABLE_NUM, 0);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_CONDS) &&
verifier.VerifyVector(conds()) &&
verifier.VerifyVectorOfTables(conds()) &&
VerifyField<uint32_t>(verifier, VT_AVAILABLE_NUM, 4) &&
verifier.EndTable();
}
};
struct QuickMatchGUIRequestBuilder {
typedef QuickMatchGUIRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_conds(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>> conds) {
fbb_.AddOffset(QuickMatchGUIRequest::VT_CONDS, conds);
}
void add_available_num(uint32_t available_num) {
fbb_.AddElement<uint32_t>(QuickMatchGUIRequest::VT_AVAILABLE_NUM, available_num, 0);
}
explicit QuickMatchGUIRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<QuickMatchGUIRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<QuickMatchGUIRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<QuickMatchGUIRequest> CreateQuickMatchGUIRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>> conds = 0,
uint32_t available_num = 0) {
QuickMatchGUIRequestBuilder builder_(_fbb);
builder_.add_available_num(available_num);
builder_.add_conds(conds);
return builder_.Finish();
}
inline ::flatbuffers::Offset<QuickMatchGUIRequest> CreateQuickMatchGUIRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<::flatbuffers::Offset<MatchingSearchCondition>> *conds = nullptr,
uint32_t available_num = 0) {
auto conds__ = conds ? _fbb.CreateVector<::flatbuffers::Offset<MatchingSearchCondition>>(*conds) : 0;
return CreateQuickMatchGUIRequest(
_fbb,
conds__,
available_num);
}
struct SearchJoinRoomGUIRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef SearchJoinRoomGUIRequestBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_CONDS = 4,
VT_ATTRS = 6
};
const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>> *conds() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>> *>(VT_CONDS);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>> *attrs() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>> *>(VT_ATTRS);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_CONDS) &&
verifier.VerifyVector(conds()) &&
verifier.VerifyVectorOfTables(conds()) &&
VerifyOffset(verifier, VT_ATTRS) &&
verifier.VerifyVector(attrs()) &&
verifier.VerifyVectorOfTables(attrs()) &&
verifier.EndTable();
}
};
struct SearchJoinRoomGUIRequestBuilder {
typedef SearchJoinRoomGUIRequest Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_conds(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>> conds) {
fbb_.AddOffset(SearchJoinRoomGUIRequest::VT_CONDS, conds);
}
void add_attrs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attrs) {
fbb_.AddOffset(SearchJoinRoomGUIRequest::VT_ATTRS, attrs);
}
explicit SearchJoinRoomGUIRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<SearchJoinRoomGUIRequest> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<SearchJoinRoomGUIRequest>(end);
return o;
}
};
inline ::flatbuffers::Offset<SearchJoinRoomGUIRequest> CreateSearchJoinRoomGUIRequest(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>> conds = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attrs = 0) {
SearchJoinRoomGUIRequestBuilder builder_(_fbb);
builder_.add_attrs(attrs);
builder_.add_conds(conds);
return builder_.Finish();
}
inline ::flatbuffers::Offset<SearchJoinRoomGUIRequest> CreateSearchJoinRoomGUIRequestDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<::flatbuffers::Offset<MatchingSearchCondition>> *conds = nullptr,
const std::vector<::flatbuffers::Offset<MatchingAttr>> *attrs = nullptr) {
auto conds__ = conds ? _fbb.CreateVector<::flatbuffers::Offset<MatchingSearchCondition>>(*conds) : 0;
auto attrs__ = attrs ? _fbb.CreateVector<::flatbuffers::Offset<MatchingAttr>>(*attrs) : 0;
return CreateSearchJoinRoomGUIRequest(
_fbb,
conds__,
attrs__);
}
struct MatchingSearchJoinRoomInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef MatchingSearchJoinRoomInfoBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ROOM = 4,
VT_ATTR = 6
};
const MatchingRoomStatus *room() const {
return GetPointer<const MatchingRoomStatus *>(VT_ROOM);
}
const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>> *attr() const {
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>> *>(VT_ATTR);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_ROOM) &&
verifier.VerifyTable(room()) &&
VerifyOffset(verifier, VT_ATTR) &&
verifier.VerifyVector(attr()) &&
verifier.VerifyVectorOfTables(attr()) &&
verifier.EndTable();
}
};
struct MatchingSearchJoinRoomInfoBuilder {
typedef MatchingSearchJoinRoomInfo Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_room(::flatbuffers::Offset<MatchingRoomStatus> room) {
fbb_.AddOffset(MatchingSearchJoinRoomInfo::VT_ROOM, room);
}
void add_attr(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attr) {
fbb_.AddOffset(MatchingSearchJoinRoomInfo::VT_ATTR, attr);
}
explicit MatchingSearchJoinRoomInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<MatchingSearchJoinRoomInfo> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<MatchingSearchJoinRoomInfo>(end);
return o;
}
};
inline ::flatbuffers::Offset<MatchingSearchJoinRoomInfo> CreateMatchingSearchJoinRoomInfo(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<MatchingRoomStatus> room = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attr = 0) {
MatchingSearchJoinRoomInfoBuilder builder_(_fbb);
builder_.add_attr(attr);
builder_.add_room(room);
return builder_.Finish();
}
inline ::flatbuffers::Offset<MatchingSearchJoinRoomInfo> CreateMatchingSearchJoinRoomInfoDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
::flatbuffers::Offset<MatchingRoomStatus> room = 0,
const std::vector<::flatbuffers::Offset<MatchingAttr>> *attr = nullptr) {
auto attr__ = attr ? _fbb.CreateVector<::flatbuffers::Offset<MatchingAttr>>(*attr) : 0;
return CreateMatchingSearchJoinRoomInfo(
_fbb,
room,
attr__);
}
#endif // FLATBUFFERS_GENERATED_NP2STRUCTS_H_
| 272,153
|
C++
|
.h
| 6,750
| 35.821333
| 165
| 0.72216
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,254
|
PUP.h
|
RPCS3_rpcs3/rpcs3/Loader/PUP.h
|
#pragma once
#include "util/types.hpp"
#include "../../Utilities/File.h"
#include <vector>
struct PUPHeader
{
le_t<u64> magic;
be_t<u64> package_version;
be_t<u64> image_version;
be_t<u64> file_count;
be_t<u64> header_length;
be_t<u64> data_length;
};
struct PUPFileEntry
{
be_t<u64> entry_id;
be_t<u64> data_offset;
be_t<u64> data_length;
u8 padding[8];
};
struct PUPHashEntry
{
be_t<u64> entry_id;
u8 hash[20];
u8 padding[4];
};
// PUP loading error
enum class pup_error : u32
{
ok,
stream,
header_read,
header_magic,
header_file_count,
expected_size,
file_entries,
hash_mismatch,
};
class pup_object
{
fs::file m_file{};
pup_error m_error{};
std::string m_formatted_error{};
std::vector<PUPFileEntry> m_file_tbl{};
std::vector<PUPHashEntry> m_hash_tbl{};
pup_error validate_hashes();
public:
pup_object(fs::file&& file);
explicit operator pup_error() const { return m_error; }
const std::string& get_formatted_error() const { return m_formatted_error; }
fs::file get_file(u64 entry_id) const;
};
| 1,044
|
C++
|
.h
| 52
| 18.211538
| 77
| 0.721881
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,255
|
ELF.h
|
RPCS3_rpcs3/rpcs3/Loader/ELF.h
|
#pragma once
#include "util/types.hpp"
#include "../../Utilities/File.h"
#include "../../Utilities/bit_set.h"
#include <span>
enum class elf_os : u8
{
none = 0,
lv2 = 0x66,
};
enum class elf_type : u16
{
none = 0,
rel = 1,
exec = 2,
dyn = 3,
core = 4,
prx = 0xffa4,
psv1 = 0xfe00, // ET_SCE_EXEC
psv2 = 0xfe04, // ET_SCE_RELEXEC (vitasdk)
};
enum class elf_machine : u16
{
ppc64 = 0x15,
spu = 0x17,
arm = 0x28,
mips = 0x08,
};
enum class sec_type : u32
{
sht_null = 0,
sht_progbits = 1,
sht_symtab = 2,
sht_strtab = 3,
sht_rela = 4,
sht_hash = 5,
sht_dynamic = 6,
sht_note = 7,
sht_nobits = 8,
sht_rel = 9,
};
enum class sh_flag : u32
{
shf_write,
shf_alloc,
shf_execinstr,
__bitset_enum_max
};
constexpr bool is_memorizable_section(sec_type type, bs_t<sh_flag> flags)
{
switch (type)
{
case sec_type::sht_null:
case sec_type::sht_nobits:
{
return false;
}
case sec_type::sht_progbits:
{
return flags.all_of(sh_flag::shf_alloc);
}
default:
{
if (type > sec_type::sht_rel)
{
return false;
}
return true;
}
}
}
template<typename T>
using elf_be = be_t<T>;
template<typename T>
using elf_le = le_t<T>;
template<template<typename T> class en_t, typename sz_t>
struct elf_ehdr
{
nse_t<u32> e_magic;
u8 e_class;
u8 e_data;
u8 e_curver;
elf_os e_os_abi;
u8 e_abi_ver;
u8 e_pad[7];
en_t<elf_type> e_type;
en_t<elf_machine> e_machine;
en_t<u32> e_version;
en_t<sz_t> e_entry;
en_t<sz_t> e_phoff;
en_t<sz_t> e_shoff;
en_t<u32> e_flags;
en_t<u16> e_ehsize;
en_t<u16> e_phentsize;
en_t<u16> e_phnum;
en_t<u16> e_shentsize;
en_t<u16> e_shnum;
en_t<u16> e_shstrndx;
};
template<template<typename T> class en_t, typename sz_t>
struct elf_phdr
{
static_assert(!sizeof(sz_t), "Invalid elf size type (must be u32 or u64)");
};
template<template<typename T> class en_t>
struct elf_phdr<en_t, u64>
{
en_t<u32> p_type;
en_t<u32> p_flags;
en_t<u64> p_offset;
en_t<u64> p_vaddr;
en_t<u64> p_paddr;
en_t<u64> p_filesz;
en_t<u64> p_memsz;
en_t<u64> p_align;
};
template<template<typename T> class en_t>
struct elf_phdr<en_t, u32>
{
en_t<u32> p_type;
en_t<u32> p_offset;
en_t<u32> p_vaddr;
en_t<u32> p_paddr;
en_t<u32> p_filesz;
en_t<u32> p_memsz;
en_t<u32> p_flags;
en_t<u32> p_align;
};
template<template<typename T> class en_t, typename sz_t>
struct elf_prog final : elf_phdr<en_t, sz_t>
{
std::vector<uchar> bin{};
using base = elf_phdr<en_t, sz_t>;
elf_prog() = default;
elf_prog(u32 type, u32 flags, sz_t vaddr, sz_t memsz, sz_t align, std::vector<uchar>&& bin)
: bin(std::move(bin))
{
base::p_type = type;
base::p_flags = flags;
base::p_vaddr = vaddr;
base::p_memsz = memsz;
base::p_align = align;
base::p_filesz = static_cast<sz_t>(this->bin.size());
base::p_paddr = 0;
base::p_offset = -1;
}
};
template<template<typename T> class en_t, typename sz_t>
struct elf_shdr
{
en_t<u32> sh_name;
en_t<sec_type> sh_type;
en_t<sz_t> _sh_flags;
en_t<sz_t> sh_addr;
en_t<sz_t> sh_offset;
en_t<sz_t> sh_size;
en_t<u32> sh_link;
en_t<u32> sh_info;
en_t<sz_t> sh_addralign;
en_t<sz_t> sh_entsize;
bs_t<sh_flag> sh_flags() const
{
return std::bit_cast<bs_t<sh_flag>>(static_cast<u32>(+_sh_flags));
}
};
template<template<typename T> class en_t, typename sz_t>
struct elf_shdata final : elf_shdr<en_t, sz_t>
{
std::vector<uchar> bin{};
std::span<const uchar> bin_view{};
using base = elf_shdr<en_t, sz_t>;
elf_shdata() = default;
std::span<const uchar> get_bin() const
{
if (!bin_view.empty())
{
return bin_view;
}
return {bin.data(), bin.size()};
}
};
// ELF loading options
enum class elf_opt : u32
{
no_programs, // Don't load phdrs, implies no_data
no_sections, // Don't load shdrs
no_data, // Load phdrs without data
__bitset_enum_max
};
// ELF loading error
enum class elf_error
{
ok = 0,
stream,
stream_header,
stream_phdrs,
stream_shdrs,
stream_data,
header_magic,
header_version,
header_class,
header_machine,
header_endianness,
header_type,
header_os,
};
// ELF object with specified parameters.
// en_t: endianness (elf_le or elf_be)
// sz_t: size (u32 for ELF32, u64 for ELF64)
template<template<typename T> class en_t, typename sz_t, elf_machine Machine, elf_os OS, elf_type Type>
class elf_object
{
elf_error m_error = elf_error::stream; // Set initial error to "file not found" error
public:
using ehdr_t = elf_ehdr<en_t, sz_t>;
using phdr_t = elf_phdr<en_t, sz_t>;
using shdr_t = elf_shdr<en_t, sz_t>;
using prog_t = elf_prog<en_t, sz_t>;
using shdata_t = elf_shdata<en_t, sz_t>;
ehdr_t header{};
std::vector<prog_t> progs{};
std::vector<shdata_t> shdrs{};
usz highest_offset = 0;
public:
elf_object() = default;
elf_object(const fs::file& stream, u64 offset = 0, bs_t<elf_opt> opts = {})
{
open(stream, offset, opts);
}
elf_error open(const fs::file& stream, u64 offset = 0, bs_t<elf_opt> opts = {})
{
highest_offset = 0;
// Check stream
if (!stream)
return set_error(elf_error::stream);
// Read ELF header
highest_offset = sizeof(header);
if (sizeof(header) != stream.read_at(offset, &header, sizeof(header)))
return set_error(elf_error::stream_header);
// Check magic
if (header.e_magic != "\177ELF"_u32)
return set_error(elf_error::header_magic);
// Check class
if (header.e_class != (std::is_same_v<sz_t, u32> ? 1 : 2))
return set_error(elf_error::header_class);
// Check endianness
if (header.e_data != (std::is_same_v<en_t<u32>, le_t<u32>> ? 1 : 2))
return set_error(elf_error::header_endianness);
// Check machine
if (header.e_machine != Machine)
return set_error(elf_error::header_machine);
// Check OS only if specified (hack)
if (OS != elf_os::none && header.e_os_abi != OS)
return set_error(elf_error::header_os);
// Check type only if specified (hack)
if (Type != elf_type::none && header.e_type != Type)
return set_error(elf_error::header_type);
// Check version and other params
if (header.e_curver != 1 || header.e_version != 1u || header.e_ehsize != u16{sizeof(ehdr_t)})
return set_error(elf_error::header_version);
if (header.e_phnum && header.e_phentsize != u16{sizeof(phdr_t)})
return set_error(elf_error::header_version);
if (header.e_shnum && header.e_shentsize != u16{sizeof(shdr_t)})
return set_error(elf_error::header_version);
// Load program headers
std::vector<phdr_t> _phdrs;
std::vector<shdr_t> _shdrs;
u64 seek_pos = 0;
if (!(opts & elf_opt::no_programs))
{
seek_pos = offset + header.e_phoff;
highest_offset = std::max<usz>(highest_offset, seek_pos);
if (!stream.read(_phdrs, header.e_phnum, true, seek_pos))
return set_error(elf_error::stream_phdrs);
}
if (!(opts & elf_opt::no_sections))
{
seek_pos = offset + header.e_shoff;
highest_offset = std::max<usz>(highest_offset, seek_pos);
if (!stream.read(_shdrs, header.e_shnum, true, seek_pos))
return set_error(elf_error::stream_shdrs);
}
progs.clear();
progs.reserve(_phdrs.size());
for (const auto& hdr : _phdrs)
{
static_cast<phdr_t&>(progs.emplace_back()) = hdr;
if (!(opts & elf_opt::no_data))
{
seek_pos = offset + hdr.p_offset;
highest_offset = std::max<usz>(highest_offset, seek_pos);
if (!stream.read(progs.back().bin, hdr.p_filesz, true, seek_pos))
return set_error(elf_error::stream_data);
}
}
shdrs.clear();
shdrs.reserve(_shdrs.size());
for (const auto& shdr : _shdrs)
{
static_cast<shdr_t&>(shdrs.emplace_back()) = shdr;
if (!(opts & elf_opt::no_data) && is_memorizable_section(shdr.sh_type, shdr.sh_flags()))
{
usz p_index = umax;
for (const auto& hdr : _phdrs)
{
// Try to find it in phdr data instead of allocating new section
p_index++;
if (hdr.p_offset <= shdr.sh_offset && shdr.sh_offset + shdr.sh_size - 1 <= hdr.p_offset + hdr.p_filesz - 1)
{
const auto& prog = ::at32(progs, p_index);
shdrs.back().bin_view = {prog.bin.data() + shdr.sh_offset - hdr.p_offset, shdr.sh_size};
}
}
if (!shdrs.back().bin_view.empty())
{
// Optimized
continue;
}
seek_pos = offset + shdr.sh_offset;
highest_offset = std::max<usz>(highest_offset, seek_pos);
if (!stream.read(shdrs.back().bin, shdr.sh_size, true, seek_pos))
return set_error(elf_error::stream_data);
}
}
shdrs.shrink_to_fit();
progs.shrink_to_fit();
return m_error = elf_error::ok;
}
std::vector<u8> save(std::vector<u8>&& init = std::vector<u8>{}) const
{
if (get_error() != elf_error::ok)
{
return std::move(init);
}
fs::file stream = fs::make_stream<std::vector<u8>>(std::move(init));
const bool fixup_shdrs = shdrs.empty() || shdrs[0].sh_type != sec_type::sht_null;
// Write header
ehdr_t header{};
header.e_magic = "\177ELF"_u32;
header.e_class = std::is_same_v<sz_t, u32> ? 1 : 2;
header.e_data = std::is_same_v<en_t<u32>, le_t<u32>> ? 1 : 2;
header.e_curver = 1;
header.e_os_abi = OS != elf_os::none ? OS : this->header.e_os_abi;
header.e_abi_ver = this->header.e_abi_ver;
header.e_type = Type != elf_type::none ? Type : static_cast<elf_type>(this->header.e_type);
header.e_machine = Machine;
header.e_version = 1;
header.e_entry = this->header.e_entry;
header.e_phoff = u32{sizeof(ehdr_t)};
header.e_shoff = u32{sizeof(ehdr_t)} + u32{sizeof(phdr_t)} * ::size32(progs);
header.e_flags = this->header.e_flags;
header.e_ehsize = u32{sizeof(ehdr_t)};
header.e_phentsize = u32{sizeof(phdr_t)};
header.e_phnum = ::size32(progs);
header.e_shentsize = u32{sizeof(shdr_t)};
header.e_shnum = ::size32(shdrs) + u32{fixup_shdrs};
header.e_shstrndx = this->header.e_shstrndx;
stream.write(header);
sz_t off = header.e_shoff + u32{sizeof(shdr_t)} * ::size32(shdrs);
for (phdr_t phdr : progs)
{
phdr.p_offset = std::exchange(off, off + phdr.p_filesz);
stream.write(phdr);
}
if (fixup_shdrs)
{
// Insert a must-have empty section at the start
stream.write(shdr_t{});
}
for (const auto& shdr : shdrs)
{
shdr_t out = static_cast<shdr_t>(shdr);
if (is_memorizable_section(shdr.sh_type, shdr.sh_flags()))
{
usz p_index = umax;
usz data_base = header.e_shoff + u32{sizeof(shdr_t)} * ::size32(shdrs);
bool result = false;
for (const auto& hdr : progs)
{
if (shdr.bin_view.empty())
{
break;
}
// Try to find it in phdr data instead of writing new section
p_index++;
// Rely on previous sh_offset value!
if (hdr.p_offset <= shdr.sh_offset && shdr.sh_offset + shdr.sh_size - 1 <= hdr.p_offset + hdr.p_filesz - 1)
{
out.sh_offset = ::narrow<sz_t>(data_base + static_cast<usz>(shdr.sh_offset - hdr.p_offset));
result = true;
break;
}
data_base += ::at32(progs, p_index).p_filesz;
}
if (result)
{
// Optimized
}
else
{
out.sh_offset = std::exchange(off, off + shdr.sh_size);
}
}
stream.write(static_cast<shdr_t>(out));
}
// Write data
for (const auto& prog : progs)
{
stream.write(prog.bin);
}
for (const auto& shdr : shdrs)
{
if (!is_memorizable_section(shdr.sh_type, shdr.sh_flags()) || !shdr.bin_view.empty())
{
continue;
}
stream.write(shdr.bin);
}
return std::move(static_cast<fs::container_stream<std::vector<u8>>*>(stream.release().get())->obj);
}
elf_object& clear()
{
// Do not use clear() in order to dealloc memory
progs = {};
shdrs = {};
header.e_magic = 0;
m_error = elf_error::stream;
return *this;
}
elf_object& set_error(elf_error error)
{
// Setting an error causes the state to clear if there was no error before
if (m_error == elf_error::ok && error != elf_error::ok)
clear();
m_error = error;
return *this;
}
// Return error code
operator elf_error() const
{
return m_error;
}
elf_error get_error() const
{
return m_error;
}
};
using ppu_exec_object = elf_object<elf_be, u64, elf_machine::ppc64, elf_os::none, elf_type::exec>;
using ppu_prx_object = elf_object<elf_be, u64, elf_machine::ppc64, elf_os::lv2, elf_type::prx>;
using ppu_rel_object = elf_object<elf_be, u64, elf_machine::ppc64, elf_os::lv2, elf_type::rel>;
using spu_exec_object = elf_object<elf_be, u32, elf_machine::spu, elf_os::none, elf_type::exec>;
using spu_rel_object = elf_object<elf_be, u32, elf_machine::spu, elf_os::none, elf_type::rel>;
using arm_exec_object = elf_object<elf_le, u32, elf_machine::arm, elf_os::none, elf_type::none>;
| 12,525
|
C++
|
.h
| 453
| 24.708609
| 112
| 0.653278
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,256
|
TRP.h
|
RPCS3_rpcs3/rpcs3/Loader/TRP.h
|
#pragma once
struct TRPHeader
{
be_t<u32> trp_magic;
be_t<u32> trp_version;
be_t<u64> trp_file_size;
be_t<u32> trp_files_count;
be_t<u32> trp_element_size;
be_t<u32> trp_dev_flag;
unsigned char sha1[20];
unsigned char padding[16];
};
struct TRPEntry
{
char name[32];
be_t<u64> offset;
be_t<u64> size;
be_t<u32> unknown;
char padding[12];
};
class TRPLoader final
{
const fs::file& trp_f;
TRPHeader m_header{};
std::vector<TRPEntry> m_entries{};
public:
TRPLoader(const fs::file& f);
bool Install(std::string_view dest, bool show = false);
bool LoadHeader(bool show = false);
u64 GetRequiredSpace() const;
bool ContainsEntry(std::string_view filename);
void RemoveEntry(std::string_view filename);
void RenameEntry(std::string_view oldname, std::string_view newname);
};
| 799
|
C++
|
.h
| 34
| 21.647059
| 70
| 0.73913
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,257
|
TAR.h
|
RPCS3_rpcs3/rpcs3/Loader/TAR.h
|
#pragma once
#include "util/types.hpp"
#include <map>
struct TARHeader
{
char name[100];
char dontcare[24];
char size[12];
char mtime[12];
char chksum[8];
char filetype;
char linkname[100];
char magic[6];
char dontcare2[82];
char prefix[155];
char padding[12]; // atime for RPCS3
ENABLE_BITWISE_SERIALIZATION;
};
namespace fs
{
class file;
struct dir_entry;
}
namespace utils
{
struct serial;
}
class tar_object
{
const fs::file* m_file;
utils::serial* m_ar;
const usz m_ar_tar_start;
usz largest_offset = 0; // We store the largest offset so we can continue to scan from there.
std::map<std::string, std::pair<u64, TARHeader>> m_map{}; // Maps path to offset of file data and its header
TARHeader read_header(u64 offset) const;
public:
tar_object(const fs::file& file);
tar_object(utils::serial& ar);
std::vector<std::string> get_filenames();
std::unique_ptr<utils::serial> get_file(const std::string& path, std::string* new_file_path = nullptr);
using process_func = std::function<bool(const fs::file&, std::string&, utils::serial&)>;
// Extract all files in archive to destination (as VFS if is_vfs is true)
// Allow to optionally specify explicit mount point (which may be directory meant for extraction)
bool extract(const std::string& prefix_path = {}, bool is_vfs = false);
static void save_directory(const std::string& src_dir, utils::serial& ar, const process_func& func = {}, std::vector<fs::dir_entry>&& = std::vector<fs::dir_entry>{}, bool has_evaluated_results = false, usz src_dir_pos = umax);
};
bool extract_tar(const std::string& file_path, const std::string& dir_path, fs::file file = {});
| 1,654
|
C++
|
.h
| 47
| 33.212766
| 227
| 0.727216
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,258
|
disc.h
|
RPCS3_rpcs3/rpcs3/Loader/disc.h
|
#pragma once
namespace disc
{
enum class disc_type
{
invalid,
unknown,
ps1,
ps2,
ps3
};
disc_type get_disc_type(const std::string& path, std::string& disc_root, std::string& ps3_game_dir);
}
| 207
|
C++
|
.h
| 13
| 13.692308
| 101
| 0.708333
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,259
|
PSF.h
|
RPCS3_rpcs3/rpcs3/Loader/PSF.h
|
#pragma once
#include "util/types.hpp"
#include <map>
#include <string>
#include <string_view>
namespace fs
{
class file;
}
namespace psf
{
enum sound_format_flag : s32
{
lpcm_2 = 1 << 0, // Linear PCM 2 Ch.
lpcm_5_1 = 1 << 2, // Linear PCM 5.1 Ch.
lpcm_7_1 = 1 << 4, // Linear PCM 7.1 Ch.
ac3 = 1 << 8, // Dolby Digital 5.1 Ch.
dts = 1 << 9, // DTS 5.1 Ch.
};
enum resolution_flag : s32
{
_480 = 1 << 0,
_576 = 1 << 1,
_720 = 1 << 2,
_1080 = 1 << 3,
_480_16_9 = 1 << 4,
_576_16_9 = 1 << 5,
};
enum class format : u16
{
array = 0x0004, // claimed to be a non-NTS string (char array)
string = 0x0204,
integer = 0x0404,
};
enum class error
{
ok,
stream,
not_psf,
corrupt,
};
class entry final
{
format m_type{};
u32 m_max_size{}; // Entry max size (supplementary info, stored in PSF format)
u32 m_value_integer{}; // TODO: is it really unsigned?
std::string m_value_string{};
public:
// Construct string entry, assign the value
entry(format type, u32 max_size, std::string_view value, bool allow_truncate = false) noexcept;
// Construct integer entry, assign the value
entry(u32 value) noexcept;
~entry() = default;
const std::string& as_string() const;
u32 as_integer() const;
entry& operator =(std::string_view value);
entry& operator =(u32 value);
format type() const { return m_type; }
u32 max(bool with_nts) const { return m_max_size - (!with_nts && m_type == format::string ? 1 : 0); }
u32 size() const;
bool is_valid() const;
};
// Define PSF registry as a sorted map of entries:
using registry = std::map<std::string, entry, std::less<>>;
struct load_result_t
{
registry sfo;
error errc;
explicit operator bool() const
{
return !sfo.empty();
}
};
// Load PSF registry from SFO binary format
load_result_t load(const fs::file&, std::string_view filename);
load_result_t load(const std::string& filename);
inline registry load_object(const fs::file& f, std::string_view filename) { return load(f, filename).sfo; }
inline registry load_object(const std::string& filename) { return load(filename).sfo; }
// Convert PSF registry to SFO binary format
std::vector<u8> save_object(const registry&, std::vector<u8>&& init = std::vector<u8>{});
// Get string value or default value
std::string_view get_string(const registry& psf, std::string_view key, std::string_view def = ""sv);
// Get integer value or default value
u32 get_integer(const registry& psf, std::string_view key, u32 def = 0);
bool check_registry(const registry& psf, std::function<bool(bool ok, const std::string& key, const entry& value)> validate = {}, std::source_location src_loc = std::source_location::current());
// Assign new entry
inline void assign(registry& psf, std::string_view key, entry&& _entry)
{
const auto found = psf.find(key);
if (found == psf.end())
{
psf.emplace(key, std::move(_entry));
return;
}
found->second = std::move(_entry);
return;
}
// Make string entry
inline entry string(u32 max_size, std::string_view value, bool allow_truncate = false)
{
return {format::string, max_size, value, allow_truncate};
}
// Make string entry (from char[N])
template <usz CharN>
inline entry string(u32 max_size, char (&value_array)[CharN], bool allow_truncate = false)
{
std::string_view value{value_array, CharN};
value = value.substr(0, std::min<usz>(value.find_first_of('\0'), value.size()));
return string(max_size, value, allow_truncate);
}
// Make array entry
inline entry array(u32 max_size, std::string_view value)
{
return {format::array, max_size, value};
}
// Checks if of HDD catgeory (assumes a valid category is being passed)
constexpr bool is_cat_hdd(std::string_view cat)
{
return cat.size() == 2u && cat[1] != 'D' && cat != "DG"sv && cat != "MS"sv;
}
}
| 3,879
|
C++
|
.h
| 121
| 29.438017
| 194
| 0.669973
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,260
|
mself.hpp
|
RPCS3_rpcs3/rpcs3/Loader/mself.hpp
|
#pragma once
#include "util/types.hpp"
#include "util/endian.hpp"
struct mself_record
{
char name[0x20];
be_t<u64> off;
be_t<u64> size;
u8 reserved[0x10];
u64 get_pos(u64 file_size) const
{
// Fast sanity check
if (off < file_size && file_size - off >= size) [[likely]]
return off;
return 0;
}
};
struct mself_header
{
nse_t<u32> magic; // "MSF\x00"
be_t<u32> ver; // 1
be_t<u64> size; // File size
be_t<u32> count; // Number of records
be_t<u32> header_size; // ???
u8 reserved[0x28];
u32 get_count(u64 file_size) const
{
// Fast sanity check
if (magic != "MSF"_u32 || ver != u32{1} || (file_size - sizeof(mself_header)) / sizeof(mself_record) < count || this->size != file_size) [[unlikely]]
return 0;
return count;
}
};
CHECK_SIZE(mself_header, 0x40);
CHECK_SIZE(mself_record, 0x40);
bool extract_mself(const std::string& file, const std::string& extract_to);
| 907
|
C++
|
.h
| 36
| 22.972222
| 151
| 0.66899
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| false
| true
| false
| false
|
6,261
|
TROPUSR.h
|
RPCS3_rpcs3/rpcs3/Loader/TROPUSR.h
|
#pragma once
#include "stdafx.h"
#include "Utilities/rXml.h"
#include "Utilities/File.h"
struct TROPUSRHeader
{
be_t<u32> magic; // 81 8F 54 AD
be_t<u32> unk1;
be_t<u32> tables_count;
be_t<u32> unk2;
char reserved[32];
};
struct TROPUSRTableHeader
{
be_t<u32> type;
be_t<u32> entries_size;
be_t<u32> unk1; // Seems to be 1
be_t<u32> entries_count;
be_t<u64> offset;
be_t<u64> reserved;
};
struct TROPUSREntry4
{
// Entry Header
be_t<u32> entry_type; // Always 0x4
be_t<u32> entry_size; // Always 0x50
be_t<u32> entry_id; // Entry ID
be_t<u32> entry_unk1; // Just zeroes?
// Entry Contents
be_t<u32> trophy_id; // Trophy ID
be_t<u32> trophy_grade; // This seems interesting
be_t<u32> trophy_pid; // (Assuming that this is the platinum link id) FF FF FF FF (-1) = SCE_NP_TROPHY_INVALID_TROPHY_ID
char unk6[68]; // Just zeroes?
};
struct TROPUSREntry6
{
// Entry Header
be_t<u32> entry_type; // Always 6
be_t<u32> entry_size; // Always 0x60
be_t<u32> entry_id; // Entry ID
be_t<u32> entry_unk1; // Just zeroes?
// Entry Contents
be_t<u32> trophy_id; // Trophy ID
be_t<u32> trophy_state; // Wild guess: 00 00 00 00 = Locked, 00 00 00 01 = Unlocked
be_t<u32> unk4; // This seems interesting
be_t<u32> unk5; // Just zeroes?
be_t<u64> timestamp1;
be_t<u64> timestamp2;
char unk6[64]; // Just zeroes?
// Note: One of the fields should hold a flag showing whether the trophy is hidden or not
};
struct trophy_xml_document : public rXmlDocument
{
trophy_xml_document() : rXmlDocument() {}
std::shared_ptr<rXmlNode> GetRoot() override;
};
class TROPUSRLoader
{
enum trophy_grade : u32
{
unknown = 0, // SCE_NP_TROPHY_GRADE_UNKNOWN
platinum = 1, // SCE_NP_TROPHY_GRADE_PLATINUM
gold = 2, // SCE_NP_TROPHY_GRADE_GOLD
silver = 3, // SCE_NP_TROPHY_GRADE_SILVER
bronze = 4 // SCE_NP_TROPHY_GRADE_BRONZE
};
fs::file m_file;
TROPUSRHeader m_header{};
std::vector<TROPUSRTableHeader> m_tableHeaders;
std::vector<TROPUSREntry4> m_table4;
std::vector<TROPUSREntry6> m_table6;
[[nodiscard]] bool Generate(std::string_view filepath, std::string_view configpath);
[[nodiscard]] bool LoadHeader();
[[nodiscard]] bool LoadTableHeaders();
[[nodiscard]] bool LoadTables();
public:
virtual ~TROPUSRLoader() = default;
struct load_result
{
bool discarded_existing;
bool success;
};
[[nodiscard]] load_result Load(std::string_view filepath, std::string_view configpath);
[[nodiscard]] bool Save(std::string_view filepath);
[[nodiscard]] u32 GetTrophiesCount() const;
[[nodiscard]] u32 GetUnlockedTrophiesCount() const;
[[nodiscard]] u32 GetUnlockedPlatinumID(u32 trophy_id, const std::string& config_path);
[[nodiscard]] u32 GetTrophyGrade(u32 id) const;
[[nodiscard]] u32 GetTrophyUnlockState(u32 id) const;
[[nodiscard]] u64 GetTrophyTimestamp(u32 id) const;
[[nodiscard]] bool UnlockTrophy(u32 id, u64 timestamp1, u64 timestamp2);
[[nodiscard]] bool LockTrophy(u32 id);
};
| 3,047
|
C++
|
.h
| 93
| 30.731183
| 124
| 0.695741
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,262
|
mutex.h
|
RPCS3_rpcs3/Utilities/mutex.h
|
#pragma once
#include <mutex>
#include "util/types.hpp"
#include "util/atomic.hpp"
// Shared mutex with small size (u32).
class shared_mutex final
{
enum : u32
{
c_one = 1u << 14, // Fixed-point 1.0 value (one writer, max_readers = c_one - 1)
c_sig = 1u << 30,
c_err = 1u << 31,
};
atomic_t<u32> m_value{};
void imp_lock_shared(u32 val);
void imp_unlock_shared(u32 old);
void imp_wait();
void imp_signal();
void imp_lock(u32 val);
void imp_unlock(u32 old);
void imp_lock_upgrade();
void imp_lock_unlock();
public:
constexpr shared_mutex() = default;
bool try_lock_shared()
{
const u32 value = m_value.load();
// Conditional increment
return value < c_one - 1 && m_value.compare_and_swap_test(value, value + 1);
}
void lock_shared()
{
const u32 value = m_value.load();
if (value >= c_one - 1 || !m_value.compare_and_swap_test(value, value + 1)) [[unlikely]]
{
imp_lock_shared(value);
}
}
void lock_shared_hle()
{
const u32 value = m_value.load();
if (value < c_one - 1) [[likely]]
{
u32 old = value;
if (atomic_storage<u32>::compare_exchange_hle_acq(m_value.raw(), old, value + 1)) [[likely]]
{
return;
}
}
imp_lock_shared(value);
}
void unlock_shared()
{
// Unconditional decrement (can result in broken state)
const u32 value = m_value.fetch_sub(1);
if (value >= c_one) [[unlikely]]
{
imp_unlock_shared(value);
}
}
void unlock_shared_hle()
{
const u32 value = atomic_storage<u32>::fetch_add_hle_rel(m_value.raw(), -1);
if (value >= c_one) [[unlikely]]
{
imp_unlock_shared(value);
}
}
bool try_lock()
{
return m_value.compare_and_swap_test(0, c_one);
}
void lock()
{
const u32 value = m_value.compare_and_swap(0, c_one);
if (value) [[unlikely]]
{
imp_lock(value);
}
}
void lock_hle()
{
u32 value = 0;
if (!atomic_storage<u32>::compare_exchange_hle_acq(m_value.raw(), value, c_one)) [[unlikely]]
{
imp_lock(value);
}
}
void unlock()
{
// Unconditional decrement (can result in broken state)
const u32 value = m_value.fetch_sub(c_one);
if (value != c_one) [[unlikely]]
{
imp_unlock(value);
}
}
void unlock_hle()
{
const u32 value = atomic_storage<u32>::fetch_add_hle_rel(m_value.raw(), 0u - c_one);
if (value != c_one) [[unlikely]]
{
imp_unlock(value);
}
}
bool try_lock_upgrade()
{
const u32 value = m_value.load();
// Conditional increment, try to convert a single reader into a writer, ignoring other writers
return (value + c_one - 1) % c_one == 0 && m_value.compare_and_swap_test(value, value + c_one - 1);
}
void lock_upgrade()
{
if (!try_lock_upgrade()) [[unlikely]]
{
imp_lock_upgrade();
}
}
void lock_downgrade()
{
// Convert to reader lock (can result in broken state)
m_value -= c_one - 1;
}
// Optimized wait for lockability without locking, relaxed
void lock_unlock()
{
if (m_value != 0) [[unlikely]]
{
imp_lock_unlock();
}
}
// Check whether can immediately obtain an exclusive (writer) lock
bool is_free() const
{
return m_value.load() == 0;
}
// Check whether can immediately obtain a shared (reader) lock
bool is_lockable() const
{
return m_value.load() < c_one - 1;
}
bool has_waiters() const
{
return m_value.load() > c_one;
}
};
// Simplified shared (reader) lock implementation.
class reader_lock final
{
shared_mutex& m_mutex;
bool m_upgraded = false;
public:
reader_lock(const reader_lock&) = delete;
reader_lock& operator=(const reader_lock&) = delete;
explicit reader_lock(shared_mutex& mutex)
: m_mutex(mutex)
{
m_mutex.lock_shared();
}
// One-way lock upgrade; note that the observed state could have been changed
void upgrade()
{
if (!m_upgraded)
{
m_mutex.lock_upgrade();
m_upgraded = true;
}
}
// Try to upgrade; if it succeeds, the observed state has NOT been changed
bool try_upgrade()
{
return m_upgraded || (m_upgraded = m_mutex.try_lock_upgrade());
}
~reader_lock()
{
m_upgraded ? m_mutex.unlock() : m_mutex.unlock_shared();
}
};
| 4,063
|
C++
|
.h
| 178
| 20.140449
| 101
| 0.660338
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,263
|
version.h
|
RPCS3_rpcs3/Utilities/version.h
|
#pragma once
#include "util/types.hpp"
#include <string>
namespace utils
{
enum class version_type : uint
{
pre_alpha,
alpha,
beta,
release_candidate,
release
};
std::string to_string(version_type type);
class version
{
uint m_hi;
uint m_mid;
uint m_lo;
version_type m_type = version_type::release;
uint m_type_index = 1;
const char* m_postfix;
public:
constexpr version(uint hi, uint mid, uint lo, version_type type, uint type_index, const char* postfix)
: m_hi(hi)
, m_mid(mid)
, m_lo(lo)
, m_type(type)
, m_type_index(type_index)
, m_postfix(postfix)
{
}
uint hi() const
{
return m_hi;
}
uint mid() const
{
return m_mid;
}
uint lo() const
{
return m_lo;
}
version_type type() const
{
return m_type;
}
std::string postfix() const
{
return m_postfix;
}
uint type_index() const
{
return m_type_index;
}
uint to_hex() const;
std::string to_string() const;
};
// Generic version comparison (e.g. 0.0.5 vs 1.3)
int compare_versions(const std::string& v1, const std::string& v2, bool& ok);
}
| 1,115
|
C++
|
.h
| 62
| 14.935484
| 104
| 0.657692
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,265
|
transactional_storage.h
|
RPCS3_rpcs3/Utilities/transactional_storage.h
|
#include "util/types.hpp"
#include <vector>
#include <mutex>
// Thread-safe object pool with garbage collection
class universal_pool
{
public:
universal_pool(u32 gc_interval = 10000) : gc_interval(gc_interval)
{
}
~universal_pool()
{
std::lock_guard lock(mutex);
storage.clear();
}
universal_pool(const universal_pool&) = delete;
universal_pool& operator=(const universal_pool&) = delete;
void set_gc_interval(u32 new_val)
{
gc_interval = new_val;
}
template <typename F>
requires (std::invocable<F&> && std::is_same_v<std::invoke_result_t<F&>, std::shared_ptr<void>>)
void add_op(F func)
{
std::lock_guard lock(mutex);
if (std::shared_ptr<void> new_val = std::invoke(func); new_val)
{
storage.push_back(new_val);
}
delete_unused();
}
void force_gc()
{
std::lock_guard lock(mutex);
delete_unused();
}
private:
void delete_unused()
{
const u32 gc_int = gc_interval.observe();
if (u64 crnt_time = get_system_time(); gc_int == 0 || crnt_time > gc_last_time + gc_int)
{
gc_last_time = crnt_time;
storage.erase
(
std::remove_if(storage.begin(), storage.end(), [](auto& obj) { return obj.use_count() <= 1; }),
storage.end()
);
}
}
shared_mutex mutex{};
std::vector<std::shared_ptr<void>> storage{};
u64 gc_last_time = get_system_time();
atomic_t<u32> gc_interval = 0;
};
template<typename T>
class transactional_storage
{
public:
transactional_storage(std::shared_ptr<universal_pool> pool, std::shared_ptr<T> obj = std::make_shared<T>())
{
ensure(pool && obj);
this->pool = pool;
add(obj);
}
transactional_storage(const transactional_storage&) = delete;
transactional_storage& operator=(const transactional_storage&) = delete;
transactional_storage(transactional_storage&& other)
{
pool = std::move(other.pool);
std::unique_lock lock_other{other.current_mutex};
const std::shared_ptr<T> other_current = other.current;
other.current = nullptr;
lock_other.unlock();
std::lock_guard lock{current_mutex};
current = other_current;
}
transactional_storage& operator=(transactional_storage&& other)
{
if (this == &other) return *this;
pool = std::move(other.pool);
std::unique_lock lock_other{other.current_mutex};
const std::shared_ptr<T> other_current = other.current;
other.current = nullptr;
lock_other.unlock();
std::lock_guard lock{current_mutex};
current = other_current;
return *this;
}
std::shared_ptr<const T> get_current()
{
reader_lock lock(current_mutex);
return current;
}
void add(std::shared_ptr<T> obj)
{
if (!obj)
{
return;
}
pool->add_op([&]() -> std::shared_ptr<void>
{
{
std::lock_guard lock{current_mutex};
current = obj;
}
return std::move(obj);
});
}
template <typename F>
requires (std::invocable<F&> && std::is_same_v<std::invoke_result_t<F&>, std::shared_ptr<T>>)
void add_op(F func)
{
pool->add_op([&]() -> std::shared_ptr<void>
{
std::shared_ptr<T> obj = std::invoke(func);
if (obj)
{
std::lock_guard lock{current_mutex};
current = obj;
}
return obj;
});
}
private:
shared_mutex current_mutex{};
std::shared_ptr<T> current{};
std::shared_ptr<universal_pool> pool{};
};
| 3,219
|
C++
|
.h
| 130
| 21.961538
| 108
| 0.681373
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,266
|
stack_trace.h
|
RPCS3_rpcs3/Utilities/stack_trace.h
|
#pragma once
#include <util/types.hpp>
#include <util/logs.hpp>
namespace utils
{
namespace stack_trace
{
// Printing utilities
template <typename T>
concept Logger = requires (T& t, const std::string& msg)
{
{ t.print(msg) };
};
struct print_to_log
{
logs::channel& log;
public:
print_to_log(logs::channel& chan)
: log(chan)
{}
void print(const std::string& s)
{
log.error("%s", s);
}
};
}
std::vector<void*> get_backtrace(int max_depth = 255);
std::vector<std::string> get_backtrace_symbols(const std::vector<void*>& stack);
FORCE_INLINE void print_trace(stack_trace::Logger auto& logger, int max_depth = 255)
{
const auto trace = get_backtrace(max_depth);
const auto lines = get_backtrace_symbols(trace);
for (const auto& line : lines)
{
logger.print(line);
}
}
}
| 889
|
C++
|
.h
| 38
| 19.184211
| 86
| 0.643114
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,267
|
address_range.h
|
RPCS3_rpcs3/Utilities/address_range.h
|
#pragma once
#include "util/types.hpp"
#include "util/vm.hpp"
#include "StrFmt.h"
#include <vector>
#include <algorithm>
namespace utils
{
class address_range_vector;
/**
* Helpers
*/
static inline u32 page_start(u32 addr)
{
return addr & ~(c_page_size - 1);
}
static inline u32 next_page(u32 addr)
{
return page_start(addr) + c_page_size;
}
static inline u32 page_end(u32 addr)
{
return next_page(addr) - 1;
}
static inline u32 is_page_aligned(u32 val)
{
return (val & (c_page_size - 1)) == 0;
}
/**
* Address Range utility class
*/
class address_range
{
public:
u32 start = umax; // First address in range
u32 end = 0; // Last address
private:
// Helper constexprs
static constexpr inline bool range_overlaps(u32 start1, u32 end1, u32 start2, u32 end2)
{
return (start1 <= end2 && start2 <= end1);
}
static constexpr inline bool address_overlaps(u32 address, u32 start, u32 end)
{
return (start <= address && address <= end);
}
static constexpr inline bool range_inside_range(u32 start1, u32 end1, u32 start2, u32 end2)
{
return (start1 >= start2 && end1 <= end2);
}
constexpr address_range(u32 _start, u32 _end) : start(_start), end(_end) {}
public:
// Constructors
constexpr address_range() = default;
static constexpr address_range start_length(u32 _start, u32 _length)
{
if (!_length)
{
return {};
}
return {_start, _start + (_length - 1)};
}
static constexpr address_range start_end(u32 _start, u32 _end)
{
return {_start, _end};
}
// Length
u32 length() const
{
AUDIT(valid());
return end - start + 1;
}
void set_length(const u32 new_length)
{
end = start + new_length - 1;
ensure(valid());
}
u32 next_address() const
{
return end + 1;
}
u32 prev_address() const
{
return start - 1;
}
// Overlapping checks
bool overlaps(const address_range &other) const
{
AUDIT(valid() && other.valid());
return range_overlaps(start, end, other.start, other.end);
}
bool overlaps(const u32 addr) const
{
AUDIT(valid());
return address_overlaps(addr, start, end);
}
bool inside(const address_range &other) const
{
AUDIT(valid() && other.valid());
return range_inside_range(start, end, other.start, other.end);
}
inline bool inside(const address_range_vector &vec) const;
inline bool overlaps(const address_range_vector &vec) const;
bool touches(const address_range &other) const
{
AUDIT(valid() && other.valid());
// returns true if there is overlap, or if sections are side-by-side
return overlaps(other) || other.start == next_address() || other.end == prev_address();
}
// Utilities
s32 signed_distance(const address_range &other) const
{
if (touches(other))
{
return 0;
}
// other after this
if (other.start > end)
{
return static_cast<s32>(other.start - end - 1);
}
// this after other
AUDIT(start > other.end);
return -static_cast<s32>(start - other.end - 1);
}
u32 distance(const address_range &other) const
{
if (touches(other))
{
return 0;
}
// other after this
if (other.start > end)
{
return (other.start - end - 1);
}
// this after other
AUDIT(start > other.end);
return (start - other.end - 1);
}
address_range get_min_max(const address_range &other) const
{
return {
std::min(valid() ? start : umax, other.valid() ? other.start : umax),
std::max(valid() ? end : 0, other.valid() ? other.end : 0)
};
}
void set_min_max(const address_range &other)
{
*this = get_min_max(other);
}
bool is_page_range() const
{
return (valid() && is_page_aligned(start) && is_page_aligned(length()));
}
address_range to_page_range() const
{
AUDIT(valid());
return { page_start(start), page_end(end) };
}
void page_align()
{
AUDIT(valid());
start = page_start(start);
end = page_end(end);
AUDIT(is_page_range());
}
address_range get_intersect(const address_range &clamp) const
{
if (!valid() || !clamp.valid())
{
return {};
}
return { std::max(start, clamp.start), std::min(end, clamp.end) };
}
void intersect(const address_range &clamp)
{
if (!clamp.valid())
{
invalidate();
}
else
{
start = std::max(start, clamp.start);
end = std::min(end, clamp.end);
}
}
// Validity
bool valid() const
{
return (start <= end);
}
void invalidate()
{
start = umax;
end = 0;
}
// Comparison Operators
bool operator ==(const address_range& other) const
{
return (start == other.start && end == other.end);
}
/**
* Debug
*/
std::string str() const
{
return fmt::format("{0x%x->0x%x}", start, end);
}
};
static inline address_range page_for(u32 addr)
{
return address_range::start_end(page_start(addr), page_end(addr));
}
/**
* Address Range Vector utility class
*
* Collection of address_range objects. Allows for merging and removing ranges from the set.
*/
class address_range_vector
{
public:
using vector_type = std::vector<address_range>;
using iterator = vector_type::iterator;
using const_iterator = vector_type::const_iterator;
using size_type = vector_type::size_type;
private:
vector_type data;
public:
// Wrapped functions
inline void reserve(usz nr) { data.reserve(nr); }
inline void clear() { data.clear(); }
inline size_type size() const { return data.size(); }
inline bool empty() const { return data.empty(); }
inline address_range& operator[](size_type n) { return data[n]; }
inline const address_range& operator[](size_type n) const { return data[n]; }
inline iterator begin() { return data.begin(); }
inline const_iterator begin() const { return data.begin(); }
inline iterator end() { return data.end(); }
inline const_iterator end() const { return data.end(); }
// Search for ranges that touch new_range. If found, merge instead of adding new_range.
// When adding a new range, re-use invalid ranges whenever possible
void merge(const address_range &new_range)
{
// Note the case where we have
// AAAA BBBB
// CCCC
// If we have data={A,B}, and new_range=C, we have to merge A with C, then B with A and invalidate B
if (!new_range.valid())
{
return;
}
address_range *found = nullptr;
address_range *invalid = nullptr;
for (auto &existing : data)
{
if (!existing.valid())
{
invalid = &existing;
continue;
}
// range1 overlaps, is immediately before, or is immediately after range2
if (existing.touches(new_range))
{
if (found != nullptr)
{
// Already found a match, merge and invalidate "existing"
found->set_min_max(existing);
existing.invalidate();
}
else
{
// First match, merge "new_range"
existing.set_min_max(new_range);
found = &existing;
}
}
}
if (found != nullptr)
{
return;
}
if (invalid != nullptr)
{
*invalid = new_range;
}
else
{
data.push_back(new_range);
}
AUDIT(check_consistency());
}
void merge(const address_range_vector &other)
{
for (const address_range &new_range : other)
{
merge(new_range);
}
}
// Exclude a given range from data
void exclude(const address_range &exclusion)
{
// Note the case where we have
// AAAAAAA
// EEE
// where data={A} and exclusion=E.
// In this case, we need to reduce A to the head (before E starts), and then create a new address_range B for the tail (after E ends), i.e.
// AA BB
// EEE
if (!exclusion.valid())
{
return;
}
address_range *invalid = nullptr; // try to re-use an invalid range instead of calling push_back
// We use index access because we might have to push_back within the loop, which could invalidate the iterators
size_type _size = data.size();
for (size_type n = 0; n < _size; ++n)
{
address_range &existing = data[n];
if (!existing.valid())
{
// Null
invalid = &existing;
continue;
}
if (!existing.overlaps(exclusion))
{
// No overlap, skip
continue;
}
const bool head_excluded = exclusion.overlaps(existing.start); // This section has its start inside excluded range
const bool tail_excluded = exclusion.overlaps(existing.end); // This section has its end inside excluded range
if (head_excluded && tail_excluded)
{
// Cannot be salvaged, fully excluded
existing.invalidate();
invalid = &existing;
}
else if (head_excluded)
{
// Head overlaps, truncate head
existing.start = exclusion.next_address();
}
else if (tail_excluded)
{
// Tail overlaps, truncate tail
existing.end = exclusion.prev_address();
}
else
{
// Section sits in the middle (see comment above function header)
AUDIT(exclusion.inside(existing));
const auto tail_end = existing.end;
// Head
existing.end = exclusion.prev_address();
// Tail
if (invalid != nullptr)
{
invalid->start = exclusion.next_address();
invalid->end = tail_end;
invalid = nullptr;
}
else
{
// IMPORTANT: adding to data invalidates "existing". This must be done last!
data.push_back(address_range::start_end(exclusion.next_address(), tail_end));
}
}
}
AUDIT(check_consistency());
AUDIT(!overlaps(exclusion));
}
void exclude(const address_range_vector &other)
{
for (const address_range &exclusion : other)
{
exclude(exclusion);
}
}
// Checks the consistency of this vector.
// Will fail if ranges within the vector overlap our touch each-other
bool check_consistency() const
{
const usz _size = data.size();
for (usz i = 0; i < _size; ++i)
{
const auto &r1 = data[i];
if (!r1.valid())
{
continue;
}
for (usz j = i + 1; j < _size; ++j)
{
const auto &r2 = data[j];
if (!r2.valid())
{
continue;
}
if (r1.touches(r2))
{
return false;
}
}
}
return true;
}
// Test for overlap with a given range
bool overlaps(const address_range &range) const
{
return std::any_of(data.cbegin(), data.cend(), [&range](const address_range& cur)
{
return cur.valid() && cur.overlaps(range);
});
}
// Test for overlap with a given address_range vector
bool overlaps(const address_range_vector &other) const
{
for (const address_range &rng1 : data)
{
if (!rng1.valid())
{
continue;
}
for (const address_range &rng2 : other.data)
{
if (!rng2.valid())
{
continue;
}
if (rng1.overlaps(rng2))
{
return true;
}
}
}
return false;
}
// Test if a given range is fully contained inside this vector
bool contains(const address_range &range) const
{
return std::any_of(this->begin(), this->end(), [&range](const address_range& cur)
{
return cur.valid() && cur.inside(range);
});
}
// Test if all ranges in this vector are full contained inside a specific range
bool inside(const address_range &range) const
{
return std::all_of(this->begin(), this->end(), [&range](const address_range& cur)
{
return !cur.valid() || cur.inside(range);
});
}
};
// These declarations must be done after address_range_vector has been defined
bool address_range::inside(const address_range_vector &vec) const
{
return vec.contains(*this);
}
bool address_range::overlaps(const address_range_vector &vec) const
{
return vec.overlaps(*this);
}
} // namespace utils
namespace std
{
static_assert(sizeof(usz) >= 2 * sizeof(u32), "usz must be at least twice the size of u32");
template <>
struct hash<utils::address_range>
{
usz operator()(const utils::address_range& k) const
{
// we can guarantee a unique hash since our type is 64 bits and usz as well
return (usz{ k.start } << 32) | usz{ k.end };
}
};
}
| 12,102
|
C++
|
.h
| 477
| 21.366876
| 142
| 0.642894
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,268
|
bit_set.h
|
RPCS3_rpcs3/Utilities/bit_set.h
|
#pragma once
/*
This header implements bs_t<> class for scoped enum types (enum class).
To enable bs_t<>, enum scope must contain `__bitset_enum_max` entry.
enum class flagzz : u32
{
flag1, // Bit indices start from zero
flag2,
__bitset_enum_max // It must be the last value
};
This also enables helper operators for this enum type.
Examples:
`+flagzz::flag1` - unary `+` operator convert flagzz value to bs_t<flagzz>
`flagzz::flag1 + flagzz::flag2` - bitset union
`flagzz::flag1 - flagzz::flag2` - bitset difference
Intersection (&) and symmetric difference (^) is also available.
*/
#include "util/types.hpp"
#include "util/atomic.hpp"
#include "Utilities/StrFmt.h"
template <typename T>
concept BitSetEnum = std::is_enum_v<T> && requires(T x)
{
T::__bitset_enum_max;
};
template <BitSetEnum T>
class atomic_bs_t;
// Bitset type for enum class with available bits [0, T::__bitset_enum_max)
template <BitSetEnum T>
class bs_t final
{
public:
// Underlying type
using under = std::underlying_type_t<T>;
ENABLE_BITWISE_SERIALIZATION;
private:
// Underlying value
under m_data;
friend class atomic_bs_t<T>;
// Value constructor
constexpr explicit bs_t(int, under data) noexcept
: m_data(data)
{
}
public:
static constexpr usz bitmax = sizeof(T) * 8;
static constexpr usz bitsize = static_cast<under>(T::__bitset_enum_max);
static_assert(std::is_enum_v<T>, "bs_t<> error: invalid type (must be enum)");
static_assert(bitsize <= bitmax, "bs_t<> error: invalid __bitset_enum_max");
static_assert(bitsize != bitmax || std::is_unsigned_v<under>, "bs_t<> error: invalid __bitset_enum_max (sign bit)");
// Helper function
static constexpr under shift(T value)
{
return static_cast<under>(1) << static_cast<under>(value);
}
bs_t() = default;
// Construct from a single bit
constexpr bs_t(T bit) noexcept
: m_data(shift(bit))
{
}
// Test for empty bitset
constexpr explicit operator bool() const noexcept
{
return m_data != 0;
}
// Extract underlying data
constexpr explicit operator under() const noexcept
{
return m_data;
}
// Copy
constexpr bs_t operator +() const
{
return *this;
}
constexpr bs_t& operator +=(bs_t rhs)
{
m_data |= static_cast<under>(rhs);
return *this;
}
constexpr bs_t& operator -=(bs_t rhs)
{
m_data &= ~static_cast<under>(rhs);
return *this;
}
constexpr bs_t& operator &=(bs_t rhs)
{
m_data &= static_cast<under>(rhs);
return *this;
}
constexpr bs_t& operator ^=(bs_t rhs)
{
m_data ^= static_cast<under>(rhs);
return *this;
}
friend constexpr bs_t operator +(bs_t lhs, bs_t rhs)
{
return bs_t(0, lhs.m_data | rhs.m_data);
}
friend constexpr bs_t operator -(bs_t lhs, bs_t rhs)
{
return bs_t(0, lhs.m_data & ~rhs.m_data);
}
friend constexpr bs_t operator &(bs_t lhs, bs_t rhs)
{
return bs_t(0, lhs.m_data & rhs.m_data);
}
friend constexpr bs_t operator ^(bs_t lhs, bs_t rhs)
{
return bs_t(0, lhs.m_data ^ rhs.m_data);
}
constexpr bool operator ==(bs_t rhs) const noexcept
{
return m_data == rhs.m_data;
}
constexpr bool test_and_set(T bit)
{
bool r = (m_data & shift(bit)) != 0;
m_data |= shift(bit);
return r;
}
constexpr bool test_and_reset(T bit)
{
bool r = (m_data & shift(bit)) != 0;
m_data &= ~shift(bit);
return r;
}
constexpr bool test_and_complement(T bit)
{
bool r = (m_data & shift(bit)) != 0;
m_data ^= shift(bit);
return r;
}
constexpr bool all_of(bs_t arg) const
{
return (m_data & arg.m_data) == arg.m_data;
}
constexpr bool none_of(bs_t arg) const
{
return (m_data & arg.m_data) == 0;
}
};
// Unary '+' operator: promote plain enum value to bitset value
template <BitSetEnum T>
constexpr bs_t<T> operator +(T bit)
{
return bs_t<T>(bit);
}
// Binary '+' operator: bitset union
template <BitSetEnum T, typename U> requires (std::is_constructible_v<bs_t<T>, U>)
constexpr bs_t<T> operator +(T lhs, const U& rhs)
{
return bs_t<T>(lhs) + bs_t<T>(rhs);
}
// Binary '+' operator: bitset union
template <typename U, BitSetEnum T> requires (std::is_constructible_v<bs_t<T>, U> && !std::is_enum_v<U>)
constexpr bs_t<T> operator +(const U& lhs, T rhs)
{
return bs_t<T>(lhs) + bs_t<T>(rhs);
}
// Binary '-' operator: bitset difference
template <BitSetEnum T, typename U> requires (std::is_constructible_v<bs_t<T>, U>)
constexpr bs_t<T> operator -(T lhs, const U& rhs)
{
return bs_t<T>(lhs) - bs_t<T>(rhs);
}
// Binary '-' operator: bitset difference
template <typename U, BitSetEnum T> requires (std::is_constructible_v<bs_t<T>, U> && !std::is_enum_v<U>)
constexpr bs_t<T> operator -(const U& lhs, T rhs)
{
return bs_t<T>(lhs) - bs_t<T>(rhs);
}
// Binary '&' operator: bitset intersection
template <BitSetEnum T, typename U> requires (std::is_constructible_v<bs_t<T>, U>)
constexpr bs_t<T> operator &(T lhs, const U& rhs)
{
return bs_t<T>(lhs) & bs_t<T>(rhs);
}
// Binary '&' operator: bitset intersection
template <typename U, BitSetEnum T> requires (std::is_constructible_v<bs_t<T>, U> && !std::is_enum_v<U>)
constexpr bs_t<T> operator &(const U& lhs, T rhs)
{
return bs_t<T>(lhs) & bs_t<T>(rhs);
}
// Binary '^' operator: bitset symmetric difference
template <BitSetEnum T, typename U> requires (std::is_constructible_v<bs_t<T>, U>)
constexpr bs_t<T> operator ^(T lhs, const U& rhs)
{
return bs_t<T>(lhs) ^ bs_t<T>(rhs);
}
// Binary '^' operator: bitset symmetric difference
template <typename U, BitSetEnum T> requires (std::is_constructible_v<bs_t<T>, U> && !std::is_enum_v<U>)
constexpr bs_t<T> operator ^(const U& lhs, T rhs)
{
return bs_t<T>(lhs) ^ bs_t<T>(rhs);
}
// Atomic bitset specialization with optimized operations
template <BitSetEnum T>
class atomic_bs_t : public atomic_t<::bs_t<T>>
{
// Corresponding bitset type
using bs_t = ::bs_t<T>;
// Base class
using base = atomic_t<::bs_t<T>>;
// Use underlying m_data
using base::m_data;
public:
// Underlying type
using under = typename bs_t::under;
atomic_bs_t() = default;
atomic_bs_t(const atomic_bs_t&) = delete;
atomic_bs_t& operator =(const atomic_bs_t&) = delete;
explicit constexpr atomic_bs_t(bs_t value)
: base(value)
{
}
explicit constexpr atomic_bs_t(T bit)
: base(bit)
{
}
using base::operator bs_t;
explicit operator bool() const
{
return static_cast<bool>(base::load());
}
explicit operator under() const
{
return static_cast<under>(base::load());
}
bs_t operator +() const
{
return base::load();
}
bs_t fetch_add(const bs_t& rhs)
{
return bs_t(0, atomic_storage<under>::fetch_or(m_data.m_data, rhs.m_data));
}
bs_t add_fetch(const bs_t& rhs)
{
return bs_t(0, atomic_storage<under>::or_fetch(m_data.m_data, rhs.m_data));
}
bs_t operator +=(const bs_t& rhs)
{
return add_fetch(rhs);
}
bs_t fetch_sub(const bs_t& rhs)
{
return bs_t(0, atomic_storage<under>::fetch_and(m_data.m_data, ~rhs.m_data));
}
bs_t sub_fetch(const bs_t& rhs)
{
return bs_t(0, atomic_storage<under>::and_fetch(m_data.m_data, ~rhs.m_data));
}
bs_t operator -=(const bs_t& rhs)
{
return sub_fetch(rhs);
}
bs_t fetch_and(const bs_t& rhs)
{
return bs_t(0, atomic_storage<under>::fetch_and(m_data.m_data, rhs.m_data));
}
bs_t and_fetch(const bs_t& rhs)
{
return bs_t(0, atomic_storage<under>::and_fetch(m_data.m_data, rhs.m_data));
}
bs_t operator &=(const bs_t& rhs)
{
return and_fetch(rhs);
}
bs_t fetch_xor(const bs_t& rhs)
{
return bs_t(0, atomic_storage<under>::fetch_xor(m_data.m_data, rhs.m_data));
}
bs_t xor_fetch(const bs_t& rhs)
{
return bs_t(0, atomic_storage<under>::xor_fetch(m_data.m_data, rhs.m_data));
}
bs_t operator ^=(const bs_t& rhs)
{
return xor_fetch(rhs);
}
auto fetch_or(const bs_t&) = delete;
auto or_fetch(const bs_t&) = delete;
auto operator |=(const bs_t&) = delete;
bool test_and_set(T rhs)
{
return atomic_storage<under>::bts(m_data.m_data, static_cast<uint>(static_cast<under>(rhs)));
}
bool test_and_reset(T rhs)
{
return atomic_storage<under>::btr(m_data.m_data, static_cast<uint>(static_cast<under>(rhs)));
}
bool test_and_invert(T rhs)
{
return atomic_storage<under>::btc(m_data.m_data, static_cast<uint>(static_cast<under>(rhs)));
}
bool bit_test_set(uint bit) = delete;
bool bit_test_reset(uint bit) = delete;
bool bit_test_invert(uint bit) = delete;
bool all_of(bs_t arg) const
{
return base::load().all_of(arg);
}
bool none_of(bs_t arg) const
{
return base::load().none_of(arg);
}
};
template <typename T>
struct fmt_unveil<bs_t<T>, void>
{
// Format as is
using type = bs_t<T>;
static inline u64 get(const bs_t<T>& bitset)
{
return static_cast<std::underlying_type_t<T>>(bitset);
}
};
| 8,650
|
C++
|
.h
| 319
| 24.974922
| 117
| 0.682903
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,269
|
sync.h
|
RPCS3_rpcs3/Utilities/sync.h
|
#pragma once
/* For internal use. Don't include. */
#include "util/types.hpp"
#include "util/dyn_lib.hpp"
#ifdef _WIN32
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include <Windows.h>
#include <ctime>
#elif __linux__
#include <errno.h>
#include <sys/syscall.h>
#include <linux/futex.h>
#include <sys/time.h>
#include <unistd.h>
#include <fcntl.h>
#endif
#include <algorithm>
#include <chrono>
#include <mutex>
#include <condition_variable>
#include <unordered_map>
#ifdef _WIN32
DYNAMIC_IMPORT("ntdll.dll", NtWaitForKeyedEvent, NTSTATUS(HANDLE, PVOID Key, BOOLEAN Alertable, PLARGE_INTEGER Timeout));
DYNAMIC_IMPORT("ntdll.dll", NtReleaseKeyedEvent, NTSTATUS(HANDLE, PVOID Key, BOOLEAN Alertable, PLARGE_INTEGER Timeout));
DYNAMIC_IMPORT("ntdll.dll", NtWaitForSingleObject, NTSTATUS(HANDLE Handle, BOOLEAN Alertable, PLARGE_INTEGER Timeout));
DYNAMIC_IMPORT("ntdll.dll", NtDelayExecution, NTSTATUS(BOOLEAN Alertable, PLARGE_INTEGER DelayInterval));
DYNAMIC_IMPORT("ntdll.dll", NtWaitForAlertByThreadId, NTSTATUS(PVOID Address, PLARGE_INTEGER Timeout));
DYNAMIC_IMPORT("ntdll.dll", NtAlertThreadByThreadId, NTSTATUS(DWORD_PTR ThreadId));
constexpr NTSTATUS NTSTATUS_SUCCESS = 0;
constexpr NTSTATUS NTSTATUS_ALERTED = 0x101;
constexpr NTSTATUS NTSTATUS_TIMEOUT = 0x102;
#endif
#ifdef __linux__
#ifndef SYS_futex_waitv
#if defined(ARCH_X64) || defined(ARCH_ARM64)
#define SYS_futex_waitv 449
#endif
#endif
#ifndef FUTEX_32
#define FUTEX_32 2
#endif
#ifndef FUTEX_WAITV_MAX
#define FUTEX_WAITV_MAX 128
struct futex_waitv
{
__u64 val;
__u64 uaddr;
__u32 flags;
__u32 __reserved;
};
#endif
#else
enum
{
FUTEX_PRIVATE_FLAG = 0,
FUTEX_WAIT = 0,
FUTEX_WAIT_PRIVATE = FUTEX_WAIT,
FUTEX_WAKE = 1,
FUTEX_WAKE_PRIVATE = FUTEX_WAKE,
FUTEX_BITSET = 2,
FUTEX_WAIT_BITSET = FUTEX_WAIT | FUTEX_BITSET,
FUTEX_WAIT_BITSET_PRIVATE = FUTEX_WAIT_BITSET,
FUTEX_WAKE_BITSET = FUTEX_WAKE | FUTEX_BITSET,
FUTEX_WAKE_BITSET_PRIVATE = FUTEX_WAKE_BITSET,
};
#endif
inline int futex(volatile void* uaddr, int futex_op, uint val, const timespec* timeout = nullptr, uint mask = 0)
{
#ifdef __linux__
return syscall(SYS_futex, uaddr, futex_op, static_cast<int>(val), timeout, nullptr, static_cast<int>(mask));
#else
static struct futex_manager
{
struct waiter
{
uint val;
uint mask;
std::condition_variable cv;
};
std::mutex mutex;
std::unordered_multimap<volatile void*, waiter*> map;
int operator()(volatile void* uaddr, int futex_op, uint val, const timespec* timeout, uint mask)
{
std::unique_lock lock(mutex);
switch (futex_op)
{
case FUTEX_WAIT_PRIVATE:
{
mask = -1;
[[fallthrough]];
}
case FUTEX_WAIT_BITSET_PRIVATE:
{
if (*reinterpret_cast<volatile uint*>(uaddr) != val)
{
errno = EAGAIN;
return -1;
}
waiter rec;
rec.val = val;
rec.mask = mask;
const auto& ref = *map.emplace(uaddr, &rec);
int res = 0;
if (!timeout)
{
rec.cv.wait(lock, FN(!rec.mask));
}
else if (futex_op == FUTEX_WAIT)
{
const auto nsec = std::chrono::nanoseconds(timeout->tv_nsec + timeout->tv_sec * 1000000000ull);
if (!rec.cv.wait_for(lock, nsec, FN(!rec.mask)))
{
res = -1;
errno = ETIMEDOUT;
}
}
else
{
// TODO: absolute timeout
}
map.erase(std::find(map.find(uaddr), map.end(), ref));
return res;
}
case FUTEX_WAKE_PRIVATE:
{
mask = -1;
[[fallthrough]];
}
case FUTEX_WAKE_BITSET_PRIVATE:
{
int res = 0;
for (auto range = map.equal_range(uaddr); val && range.first != range.second; range.first++)
{
auto& entry = *range.first->second;
if (entry.mask & mask)
{
entry.cv.notify_one();
entry.mask = 0;
res++;
val--;
}
}
return res;
}
}
errno = EINVAL;
return -1;
}
} g_futex;
return g_futex(uaddr, futex_op, val, timeout, mask);
#endif
}
| 3,914
|
C++
|
.h
| 154
| 22.25974
| 121
| 0.691196
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,270
|
StrUtil.h
|
RPCS3_rpcs3/Utilities/StrUtil.h
|
#pragma once
#include <cstring>
#include <string>
#include <vector>
#include <functional>
#include <string_view>
#include "util/types.hpp"
std::wstring utf8_to_wchar(std::string_view src);
std::string wchar_to_utf8(std::wstring_view src);
std::string utf16_to_utf8(std::u16string_view src);
std::u16string utf8_to_utf16(std::string_view src);
// Copy null-terminated string from a std::string or a char array to a char array with truncation
template <typename D, typename T>
inline void strcpy_trunc(D&& dst, const T& src)
{
const usz count = std::size(src) >= std::size(dst) ? std::max<usz>(std::size(dst), 1) - 1 : std::size(src);
std::memcpy(std::data(dst), std::data(src), count);
std::memset(std::data(dst) + count, 0, std::size(dst) - count);
}
// Convert string to signed integer
bool try_to_int64(s64* out, std::string_view value, s64 min, s64 max);
// Convert string to unsigned integer
bool try_to_uint64(u64* out, std::string_view value, u64 min, u64 max);
// Convert string to float
bool try_to_float(f64* out, std::string_view value, f64 min, f64 max);
// Convert float to string locale independent
bool try_to_string(std::string* out, const f64& value);
// Get the file extension of a file path ("png", "jpg", etc.)
std::string get_file_extension(const std::string& file_path);
namespace fmt
{
std::string replace_all(std::string_view src, std::string_view from, std::string_view to, usz count = -1);
template <usz list_size>
std::string replace_all(std::string src, const std::pair<std::string_view, std::string> (&list)[list_size])
{
for (usz pos = 0; pos < src.length(); ++pos)
{
for (usz i = 0; i < list_size; ++i)
{
const usz comp_length = list[i].first.length();
if (src.length() - pos < comp_length)
{
continue;
}
if (src.substr(pos, comp_length) == list[i].first)
{
src.erase(pos, comp_length);
src.insert(pos, list[i].second.data(), list[i].second.length());
pos += list[i].second.length() - 1;
break;
}
}
}
return src;
}
template <usz list_size>
std::string replace_all(std::string src, const std::pair<std::string_view, std::function<std::string()>> (&list)[list_size])
{
for (usz pos = 0; pos < src.length(); ++pos)
{
for (usz i = 0; i < list_size; ++i)
{
const usz comp_length = list[i].first.length();
if (src.length() - pos < comp_length)
{
continue;
}
if (src.substr(pos, comp_length) == list[i].first)
{
src.erase(pos, comp_length);
auto replacement = list[i].second();
src.insert(pos, replacement);
pos += replacement.length() - 1;
break;
}
}
}
return src;
}
static inline
std::string replace_all(std::string src, const std::vector<std::pair<std::string, std::string>>& list)
{
for (usz pos = 0; pos < src.length(); ++pos)
{
for (usz i = 0; i < list.size(); ++i)
{
const usz comp_length = list[i].first.length();
if (src.length() - pos < comp_length)
{
continue;
}
if (src.substr(pos, comp_length) == list[i].first)
{
src.erase(pos, comp_length);
src.insert(pos, list[i].second);
pos += list[i].second.length() - 1;
break;
}
}
}
return src;
}
std::vector<std::string> split(std::string_view source, std::initializer_list<std::string_view> separators, bool is_skip_empty = true);
std::string trim(const std::string& source, std::string_view values = " \t");
std::string trim_front(const std::string& source, std::string_view values = " \t");
void trim_back(std::string& source, std::string_view values = " \t");
template <typename T>
std::string merge(const T& source, const std::string& separator)
{
if (source.empty())
{
return {};
}
std::string result;
auto it = source.begin();
auto end = source.end();
for (--end; it != end; ++it)
{
result += std::string{*it} + separator;
}
return result + std::string{source.back()};
}
template <typename T>
std::string merge(std::initializer_list<T> sources, const std::string& separator)
{
if (!sources.size())
{
return {};
}
std::string result;
bool first = true;
for (auto& v : sources)
{
if (first)
{
result = fmt::merge(v, separator);
first = false;
}
else
{
result += separator + fmt::merge(v, separator);
}
}
return result;
}
std::string to_upper(std::string_view string);
std::string to_lower(std::string_view string);
std::string truncate(std::string_view src, usz length);
bool match(const std::string& source, const std::string& mask);
struct buf_to_hexstring
{
buf_to_hexstring(const u8* buf, usz len, usz line_length = 16, bool with_prefix = false)
: buf(buf), len(len), line_length(line_length), with_prefix(with_prefix) {}
const u8* buf;
usz len;
usz line_length;
bool with_prefix;
};
struct string_hash
{
using hash_type = std::hash<std::string_view>;
using is_transparent = void;
std::size_t operator()(const char* str) const
{
return hash_type{}(str);
}
std::size_t operator()(std::string_view str) const
{
return hash_type{}(str);
}
std::size_t operator()(std::string const& str) const
{
return hash_type{}(str);
}
};
}
| 5,225
|
C++
|
.h
| 176
| 26.346591
| 136
| 0.653363
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,271
|
cheat_info.h
|
RPCS3_rpcs3/Utilities/cheat_info.h
|
#pragma once
#include "util/types.hpp"
#include <string>
enum class cheat_type : u8
{
unsigned_8_cheat,
unsigned_16_cheat,
unsigned_32_cheat,
unsigned_64_cheat,
signed_8_cheat,
signed_16_cheat,
signed_32_cheat,
signed_64_cheat,
max
};
constexpr u8 cheat_type_max = static_cast<u8>(cheat_type::max);
struct cheat_info
{
std::string game{};
std::string description{};
cheat_type type = cheat_type::max;
u32 offset{};
std::string red_script{};
bool from_str(const std::string& cheat_line);
std::string to_str() const;
};
| 540
|
C++
|
.h
| 26
| 18.923077
| 63
| 0.738189
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,272
|
lockless.h
|
RPCS3_rpcs3/Utilities/lockless.h
|
#pragma once
#include "util/types.hpp"
#include "util/atomic.hpp"
#include "util/bless.hpp"
//! Simple unshrinkable array base for concurrent access. Only growths automatically.
//! There is no way to know the current size. The smaller index is, the faster it's accessed.
//!
//! T is the type of elements. Currently, default constructor of T shall be constexpr.
//! N is initial element count, available without any memory allocation and only stored contiguously.
template <typename T, usz N>
class lf_array
{
// Data (default-initialized)
T m_data[N]{};
// Next array block
atomic_t<lf_array*> m_next{};
public:
constexpr lf_array() = default;
~lf_array()
{
for (auto ptr = m_next.raw(); ptr;)
{
delete std::exchange(ptr, std::exchange(ptr->m_next.raw(), nullptr));
}
}
T& operator [](usz index)
{
if (index < N) [[likely]]
{
return m_data[index];
}
else if (!m_next) [[unlikely]]
{
// Create new array block. It's not a full-fledged once-synchronization, unlikely needed.
for (auto _new = new lf_array, ptr = this; ptr;)
{
// Install the pointer. If failed, go deeper.
ptr = ptr->m_next.compare_and_swap(nullptr, _new);
}
}
// Access recursively
return (*m_next)[index - N];
}
u64 size() const
{
u64 size_n = 0;
for (auto ptr = this; ptr; ptr = ptr->m_next)
{
size_n += N;
}
return size_n;
}
};
//! Simple lock-free FIFO queue base. Based on lf_array<T, N> itself. Currently uses 32-bit counters.
//! There is no "push_end" or "pop_begin" provided, the queue element must signal its state on its own.
template<typename T, usz N>
class lf_fifo : public lf_array<T, N>
{
// LSB 32-bit: push, MSB 32-bit: pop
atomic_t<u64> m_ctrl{};
public:
constexpr lf_fifo() = default;
// Get number of elements in the queue
u32 size() const
{
const u64 ctrl = m_ctrl.load();
return static_cast<u32>(ctrl - (ctrl >> 32));
}
// Acquire the place for one or more elements.
u32 push_begin(u32 count = 1)
{
return static_cast<u32>(m_ctrl.fetch_add(count));
}
// Get current "pop" position
u32 peek() const
{
return static_cast<u32>(m_ctrl >> 32);
}
// Acknowledge processed element, return number of the next one.
// Perform clear if possible, zero is returned in this case.
u32 pop_end(u32 count = 1)
{
return m_ctrl.atomic_op([&](u64& ctrl)
{
ctrl += u64{count} << 32;
if (ctrl >> 32 == static_cast<u32>(ctrl))
{
// Clean if possible
ctrl = 0;
}
return static_cast<u32>(ctrl >> 32);
});
}
};
// Helper type, linked list element
template <typename T>
class lf_queue_item final
{
lf_queue_item* m_link = nullptr;
T m_data;
template <typename U>
friend class lf_queue_iterator;
template <typename U>
friend class lf_queue_slice;
template <typename U>
friend class lf_queue;
template <typename U>
friend class lf_bunch;
constexpr lf_queue_item() = default;
template <typename... Args>
constexpr lf_queue_item(lf_queue_item* link, Args&&... args)
: m_link(link)
, m_data(std::forward<Args>(args)...)
{
}
public:
lf_queue_item(const lf_queue_item&) = delete;
lf_queue_item& operator=(const lf_queue_item&) = delete;
~lf_queue_item()
{
for (lf_queue_item* ptr = m_link; ptr;)
{
delete std::exchange(ptr, std::exchange(ptr->m_link, nullptr));
}
}
};
// Forward iterator: non-owning pointer to the list element in lf_queue_slice<>
template <typename T>
class lf_queue_iterator
{
lf_queue_item<T>* m_ptr = nullptr;
template <typename U>
friend class lf_queue_slice;
template <typename U>
friend class lf_bunch;
public:
constexpr lf_queue_iterator() = default;
bool operator ==(const lf_queue_iterator& rhs) const
{
return m_ptr == rhs.m_ptr;
}
T& operator *() const
{
return m_ptr->m_data;
}
T* operator ->() const
{
return &m_ptr->m_data;
}
lf_queue_iterator& operator ++()
{
m_ptr = m_ptr->m_link;
return *this;
}
lf_queue_iterator operator ++(int)
{
lf_queue_iterator result;
result.m_ptr = m_ptr;
m_ptr = m_ptr->m_link;
return result;
}
};
// Owning pointer to the linked list taken from the lf_queue<>
template <typename T>
class lf_queue_slice
{
lf_queue_item<T>* m_head = nullptr;
template <typename U>
friend class lf_queue;
public:
constexpr lf_queue_slice() = default;
lf_queue_slice(const lf_queue_slice&) = delete;
lf_queue_slice(lf_queue_slice&& r) noexcept
: m_head(r.m_head)
{
r.m_head = nullptr;
}
lf_queue_slice& operator =(const lf_queue_slice&) = delete;
lf_queue_slice& operator =(lf_queue_slice&& r) noexcept
{
if (this != &r)
{
delete m_head;
m_head = r.m_head;
r.m_head = nullptr;
}
return *this;
}
~lf_queue_slice()
{
delete m_head;
}
T& operator *() const
{
return m_head->m_data;
}
T* operator ->() const
{
return &m_head->m_data;
}
explicit operator bool() const
{
return m_head != nullptr;
}
T* get() const
{
return m_head ? &m_head->m_data : nullptr;
}
lf_queue_iterator<T> begin() const
{
lf_queue_iterator<T> result;
result.m_ptr = m_head;
return result;
}
lf_queue_iterator<T> end() const
{
return {};
}
const T& operator[](usz index) const noexcept
{
lf_queue_iterator<T> result = begin();
while (--index != umax)
{
result++;
}
return *result;
}
T& operator[](usz index) noexcept
{
lf_queue_iterator<T> result = begin();
while (--index != umax)
{
result++;
}
return *result;
}
lf_queue_slice& pop_front()
{
delete std::exchange(m_head, std::exchange(m_head->m_link, nullptr));
return *this;
}
};
// Linked list-based multi-producer queue (the consumer drains the whole queue at once)
template <typename T>
class lf_queue final
{
atomic_t<u64> m_head{0};
lf_queue_item<T>* load(u64 value) const noexcept
{
return reinterpret_cast<lf_queue_item<T>*>(value >> 16);
}
// Extract all elements and reverse element order (FILO to FIFO)
lf_queue_item<T>* reverse() noexcept
{
if (auto* head = load(m_head) ? load(m_head.exchange(0)) : nullptr)
{
if (auto* prev = head->m_link)
{
head->m_link = nullptr;
do
{
auto* pprev = prev->m_link;
prev->m_link = head;
head = std::exchange(prev, pprev);
}
while (prev);
}
return head;
}
return nullptr;
}
public:
constexpr lf_queue() = default;
lf_queue(lf_queue&& other) noexcept
{
m_head.release(other.m_head.exchange(0));
}
lf_queue& operator=(lf_queue&& other) noexcept
{
if (this == std::addressof(other))
{
return *this;
}
delete load(m_head);
m_head.release(other.m_head.exchange(0));
return *this;
}
~lf_queue()
{
delete load(m_head);
}
void wait(std::nullptr_t /*null*/ = nullptr) noexcept
{
if (m_head == 0)
{
utils::bless<atomic_t<u32>>(&m_head)[1].wait(0);
}
}
const volatile void* observe() const noexcept
{
return load(m_head);
}
explicit operator bool() const noexcept
{
return m_head != 0;
}
template <bool Notify = true, typename... Args>
bool push(Args&&... args)
{
auto oldv = m_head.load();
auto item = new lf_queue_item<T>(load(oldv), std::forward<Args>(args)...);
while (!m_head.compare_exchange(oldv, reinterpret_cast<u64>(item) << 16))
{
item->m_link = load(oldv);
}
if (!oldv && Notify)
{
// Notify only if queue was empty
notify(true);
}
return !oldv;
}
void notify(bool force = false)
{
if (force || operator bool())
{
utils::bless<atomic_t<u32>>(&m_head)[1].notify_one();
}
}
// Withdraw the list, supports range-for loop: for (auto&& x : y.pop_all()) ...
lf_queue_slice<T> pop_all()
{
lf_queue_slice<T> result;
result.m_head = reverse();
return result;
}
// Withdraw the list in reverse order (LIFO/FILO)
lf_queue_slice<T> pop_all_reversed()
{
lf_queue_slice<T> result;
result.m_head = load(m_head.exchange(0));
return result;
}
// Apply func(data) to each element, return the total length
template <typename F>
usz apply(F func)
{
usz count = 0;
for (auto slice = pop_all(); slice; slice.pop_front())
{
std::invoke(func, *slice);
}
return count;
}
};
// Concurrent linked list, elements remain until destroyed.
template <typename T>
class lf_bunch final
{
atomic_t<lf_queue_item<T>*> m_head{nullptr};
public:
constexpr lf_bunch() noexcept = default;
~lf_bunch()
{
delete m_head.load();
}
// Add unconditionally
template <typename... Args>
T* push(Args&&... args) noexcept
{
auto _old = m_head.load();
auto item = new lf_queue_item<T>(_old, std::forward<Args>(args)...);
while (!m_head.compare_exchange(_old, item))
{
item->m_link = _old;
}
return &item->m_data;
}
// Add if pred(item, all_items) is true for all existing items
template <typename F, typename... Args>
T* push_if(F pred, Args&&... args) noexcept
{
auto _old = m_head.load();
auto _chk = _old;
auto item = new lf_queue_item<T>(_old, std::forward<Args>(args)...);
_chk = nullptr;
do
{
item->m_link = _old;
// Check all items in the queue
for (auto ptr = _old; ptr != _chk; ptr = ptr->m_link)
{
if (!pred(item->m_data, ptr->m_data))
{
item->m_link = nullptr;
delete item;
return nullptr;
}
}
// Set to not check already checked items
_chk = _old;
}
while (!m_head.compare_exchange(_old, item));
return &item->m_data;
}
lf_queue_iterator<T> begin() const
{
lf_queue_iterator<T> result;
result.m_ptr = m_head.load();
return result;
}
lf_queue_iterator<T> end() const
{
return {};
}
};
| 9,549
|
C++
|
.h
| 416
| 20.204327
| 103
| 0.661538
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,273
|
cond.h
|
RPCS3_rpcs3/Utilities/cond.h
|
#pragma once
#include "util/types.hpp"
#include "util/atomic.hpp"
// Lightweight condition variable
class cond_variable
{
// Internal waiter counter
atomic_t<u32> m_value{0};
enum : u32
{
c_waiter_mask = 0x1fff,
c_signal_mask = 0xffffffff & ~c_waiter_mask,
};
protected:
// Increment waiter count
u32 add_waiter() noexcept
{
return m_value.atomic_op([](u32& value) -> u32
{
if ((value & c_signal_mask) == c_signal_mask || (value & c_waiter_mask) == c_waiter_mask)
{
// Signal or waiter overflow, return immediately
return 0;
}
// Add waiter (c_waiter_mask)
value += 1;
return value;
});
}
// Internal waiting function
void imp_wait(u32 _old, u64 _timeout) noexcept;
// Try to notify up to _count threads
void imp_wake(u32 _count) noexcept;
public:
constexpr cond_variable() = default;
// Intrusive wait algorithm for lockable objects
template <typename T>
void wait(T& object, u64 usec_timeout = -1) noexcept
{
const u32 _old = add_waiter();
if (!_old)
{
return;
}
object.unlock();
imp_wait(_old, usec_timeout);
object.lock();
}
// Unlock all specified objects but don't lock them again
template <typename... Locks>
void wait_unlock(u64 usec_timeout, Locks&&... locks)
{
const u32 _old = add_waiter();
(..., std::forward<Locks>(locks).unlock());
if (!_old)
{
return;
}
imp_wait(_old, usec_timeout);
}
// Wake one thread
void notify_one() noexcept
{
if (m_value)
{
imp_wake(1);
}
}
// Wake all threads
void notify_all() noexcept
{
if (m_value)
{
imp_wake(-1);
}
}
static constexpr u64 max_timeout = u64{umax} / 1000;
};
| 1,655
|
C++
|
.h
| 78
| 18.474359
| 92
| 0.669231
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,274
|
sema.h
|
RPCS3_rpcs3/Utilities/sema.h
|
#pragma once
#include "util/types.hpp"
#include "util/atomic.hpp"
// Lightweight semaphore helper class
class semaphore_base
{
// Semaphore value
atomic_t<u32> m_value;
enum : u32
{
c_value = 1u << 0,
c_value_mask = +c_value * 0xffff,
c_waiter = 1u << 16,
c_waiter_mask = +c_waiter * 0xffff,
};
void imp_wait();
void imp_post(u32 _old);
protected:
explicit constexpr semaphore_base(u32 value) noexcept
: m_value{value}
{
}
void wait()
{
// Load value
const u32 value = m_value.load();
// Conditional decrement
if ((value & c_value_mask) == 0 || !m_value.compare_and_swap_test(value, value - c_value)) [[unlikely]]
{
imp_wait();
}
}
bool try_wait()
{
return m_value.fetch_op([](u32& value)
{
if (value & c_value_mask)
{
value -= c_value;
return true;
}
return false;
}).second;
}
void post(u32 _max)
{
// Unconditional increment
const u32 value = m_value.fetch_add(c_value);
if (value & c_waiter_mask || (value & c_value_mask) >= std::min<u32>(c_value_mask, _max)) [[unlikely]]
{
imp_post(value);
}
}
bool try_post(u32 _max);
public:
// Get current semaphore value
s32 get() const
{
// Load value
const u32 raw_value = m_value;
const u32 waiters = (raw_value & c_waiter_mask) / c_waiter;
const u32 value = (raw_value & c_value_mask) / c_value;
// Return only positive value
return static_cast<s32>(waiters >= value ? 0 : value - waiters);
}
};
// Lightweight semaphore template (default arguments define binary semaphore and Def == Max)
template <s16 Max = 1, s16 Def = Max>
class semaphore final : public semaphore_base
{
static_assert(Max >= 0, "semaphore<>: Max is out of bounds");
static_assert(Def >= 0, "semaphore<>: Def is out of bounds");
static_assert(Def <= Max, "semaphore<>: Def is too big");
using base = semaphore_base;
public:
// Default constructor (recommended)
constexpr semaphore() noexcept
: base(Def)
{
}
// Explicit value constructor (not recommended)
explicit constexpr semaphore(s16 value) noexcept
: base(value)
{
}
// Obtain a semaphore
void lock()
{
return base::wait();
}
// Try to obtain a semaphore
bool try_lock()
{
return base::try_wait();
}
// Return a semaphore
void unlock()
{
return base::post(Max);
}
// Try to return a semaphore
bool try_unlock()
{
return base::try_post(Max);
}
// Get max semaphore value
static constexpr s32 size()
{
return Max;
}
};
| 2,460
|
C++
|
.h
| 111
| 19.630631
| 105
| 0.674839
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,275
|
StrFmt.h
|
RPCS3_rpcs3/Utilities/StrFmt.h
|
#pragma once // No BOM and only basic ASCII in this header, or a neko will die
#include "util/types.hpp"
#include <string>
namespace fmt
{
template <typename CharT, usz N, typename... Args>
static std::string format(const CharT(&)[N], const Args&...);
#ifdef _WIN32
struct win_error
{
unsigned long error{};
void* module_handle{};
};
// Get a string for a windows error (DWORD). Optionally a module HANDLE can be passed.
std::string win_error_to_string(unsigned long error, void* module_handle = nullptr);
std::string win_error_to_string(const win_error& error);
#endif
}
template <typename T, typename = void>
struct fmt_unveil
{
static_assert(sizeof(T) > 0, "fmt_unveil<> error: incomplete type");
using type = T;
static inline u64 get(const T& arg)
{
return reinterpret_cast<uptr>(&arg);
}
// Temporary value container (can possibly be created by other fmt_unveil<> specializations)
struct u64_wrapper
{
T arg;
// Allow implicit conversion
operator u64() const
{
return reinterpret_cast<uptr>(&arg);
}
};
// This overload resolution takes the precedence
static inline u64_wrapper get(T&& arg)
{
return u64_wrapper{std::move(arg)};
}
};
template <typename T>
struct fmt_unveil<T, std::enable_if_t<std::is_integral_v<T> && sizeof(T) <= 8 && alignof(T) <= 8>>
{
using type = T;
static inline u64 get(T arg)
{
return static_cast<T>(arg);
}
};
template <typename T>
struct fmt_unveil<T, std::enable_if_t<std::is_floating_point_v<T> && sizeof(T) <= 8 && alignof(T) <= 8>>
{
using type = T;
// Convert FP to f64 and reinterpret as u64
static inline u64 get(const f64& arg)
{
return std::bit_cast<u64>(arg);
}
};
template <typename T>
struct fmt_unveil<T, std::enable_if_t<std::is_enum_v<T>>>
{
using type = T;
static inline u64 get(T arg)
{
return static_cast<std::underlying_type_t<T>>(arg);
}
};
template <typename T>
struct fmt_unveil<T*, void>
{
using type = std::add_const_t<T>*;
static inline u64 get(type arg)
{
return reinterpret_cast<uptr>(arg);
}
};
namespace fmt
{
template <typename T>
concept CharT = (std::is_same_v<const T, const char> || std::is_same_v<const T, const char8_t>);
}
template <fmt::CharT T, usz N>
struct fmt_unveil<T[N], void>
{
using type = std::add_const_t<T>*;
static inline u64 get(type arg)
{
return reinterpret_cast<uptr>(arg);
}
};
template <typename T, bool Se, usz Align>
struct fmt_unveil<se_t<T, Se, Align>, void>
{
using type = typename fmt_unveil<T>::type;
static inline auto get(const se_t<T, Se, Align>& arg)
{
return fmt_unveil<T>::get(arg);
}
};
// String type format provider, also type classifier (format() called if an argument is formatted as "%s")
template <typename T, typename = void>
struct fmt_class_string
{
// Formatting function (must be explicitly specialized)
static void format(std::string& out, u64 arg);
// Helper typedef (visible in format())
using type = T;
// Helper function (converts arg to object reference)
static FORCE_INLINE SAFE_BUFFERS(const T&) get_object(u64 arg)
{
return *reinterpret_cast<const T*>(static_cast<uptr>(arg));
}
// Enum -> string function type
using convert_t = const char*(*)(T value);
// Helper function (safely converts arg to enum value)
static FORCE_INLINE SAFE_BUFFERS(void) format_enum(std::string& out, u64 arg, convert_t convert)
{
const auto value = static_cast<std::underlying_type_t<T>>(arg);
// Check narrowing
if (static_cast<u64>(value) == arg)
{
if (const char* str = convert(static_cast<T>(value)))
{
out += str;
return;
}
}
// Fallback to underlying type formatting
fmt_class_string<std::underlying_type_t<T>>::format(out, static_cast<u64>(value));
}
// Helper function (bitset formatting)
static FORCE_INLINE SAFE_BUFFERS(void) format_bitset(std::string& out, u64 arg, const char* prefix, const char* delim, const char* suffix, void (*fmt)(std::string&, u64))
{
// Start from raw value
fmt_class_string<u64>::format(out, arg);
out += prefix;
for (u64 i = 0; i < 63; i++)
{
const u64 mask = 1ull << i;
if (arg & mask)
{
fmt(out, i);
if (arg >> (i + 1))
{
out += delim;
}
}
}
if (arg & (1ull << 63))
{
fmt(out, 63);
}
out += suffix;
}
// Helper constant (may be used in format_enum as lambda return value)
static constexpr const char* unknown = nullptr;
};
template <>
struct fmt_class_string<const void*, void>
{
static void format(std::string& out, u64 arg);
};
template <typename T>
struct fmt_class_string<T*, void> : fmt_class_string<const void*, void>
{
// Classify all pointers as const void*
};
template <>
struct fmt_class_string<const char*, void>
{
static void format(std::string& out, u64 arg);
};
template <>
struct fmt_class_string<char*, void> : fmt_class_string<const char*>
{
// Classify char* as const char*
};
template <>
struct fmt_class_string<const char8_t*, void> : fmt_class_string<const char*>
{
};
template <>
struct fmt_class_string<char8_t*, void> : fmt_class_string<const char8_t*>
{
};
template <>
struct fmt_class_string<const wchar_t*, void>
{
static void format(std::string& out, u64 arg);
};
template <>
struct fmt_class_string<wchar_t*, void> : fmt_class_string<const wchar_t*>
{
};
namespace fmt
{
template <typename T>
concept StringConvertible = requires (T & t)
{
{ t.to_string() } -> std::convertible_to<std::string>;
};
}
template <fmt::StringConvertible T>
struct fmt_class_string<T, void>
{
static FORCE_INLINE SAFE_BUFFERS(const T&) get_object(u64 arg)
{
return *reinterpret_cast<const T*>(static_cast<uptr>(arg));
}
static void format(std::string& out, u64 arg)
{
out += get_object(arg).to_string();
}
};
namespace fmt
{
// Both uchar and std::byte are allowed
template <typename T>
concept ByteArray = requires (T& t) { const_cast<std::conditional_t<std::is_same_v<decltype(std::as_const(t[0])), const std::byte&>, std::byte, uchar>&>(std::data(t)[0]); };
}
template <fmt::ByteArray T>
struct fmt_class_string<T, void>
{
static FORCE_INLINE SAFE_BUFFERS(const T&) get_object(u64 arg)
{
return *reinterpret_cast<const T*>(static_cast<uptr>(arg));
}
static void format(std::string& out, u64 arg)
{
const auto& obj = get_object(arg);
void format_byte_array(std::string&, const uchar*, usz);
format_byte_array(out, reinterpret_cast<const uchar*>(std::data(obj)), std::size(obj));
}
};
struct fmt_type_info
{
decltype(&fmt_class_string<int>::format) fmt_string;
template <typename T>
static constexpr fmt_type_info make()
{
return fmt_type_info
{
&fmt_class_string<T>::format,
};
}
};
// Argument array type (each element generated via fmt_unveil<>)
template <typename... Args>
using fmt_args_t = const u64(&&)[sizeof...(Args) + 1];
template <typename Arg>
using fmt_unveil_t = typename fmt_unveil<Arg>::type;
namespace fmt
{
// Base-57 format helper
struct base57
{
const uchar* data;
usz size;
base57() = default;
template <typename T>
base57(const T& arg) noexcept
: data(reinterpret_cast<const uchar*>(std::addressof(arg)))
, size(sizeof(T))
{
}
base57(const uchar* data, usz size) noexcept
: data(data)
, size(size)
{
}
};
struct base57_result : public base57
{
std::unique_ptr<uchar[]> memory;
base57_result() noexcept = default;
base57_result(base57_result&&) = default;
base57_result& operator=(base57_result&&) = default;
explicit base57_result(usz size) noexcept
: base57(size ? new uchar[size] : nullptr, size)
, memory(const_cast<uchar*>(this->data))
{
}
static base57_result from_string(std::string_view str);
};
template <typename... Args>
constexpr const fmt_type_info type_info_v[sizeof...(Args) + 1]{fmt_type_info::make<fmt_unveil_t<Args>>()...};
// Internal formatting function
void raw_append(std::string& out, const char*, const fmt_type_info*, const u64*) noexcept;
// Formatting function
template <typename CharT, usz N, typename... Args>
FORCE_INLINE SAFE_BUFFERS(void) append(std::string& out, const CharT(&fmt)[N], const Args&... args)
{
raw_append(out, reinterpret_cast<const char*>(fmt), type_info_v<Args...>, fmt_args_t<Args...>{fmt_unveil<Args>::get(args)...});
}
// Formatting function
template <typename CharT, usz N, typename... Args>
FORCE_INLINE SAFE_BUFFERS(std::string) format(const CharT(&fmt)[N], const Args&... args)
{
std::string result;
append(result, fmt, args...);
return result;
}
// Internal exception message formatting template, must be explicitly specialized or instantiated in cpp to minimize code bloat
[[noreturn]] void raw_throw_exception(std::source_location, const char*, const fmt_type_info*, const u64*);
// Throw exception with formatting
template <typename CharT, usz N, typename... Args>
struct throw_exception
{
struct args_break_t {};
[[noreturn]] FORCE_INLINE SAFE_BUFFERS() throw_exception(const CharT(&fmt)[N], const Args&... args,
args_break_t = args_break_t{}, std::source_location src_loc = std::source_location::current())
{
raw_throw_exception(src_loc, reinterpret_cast<const char*>(fmt), type_info_v<Args...>, fmt_args_t<Args...>{fmt_unveil<Args>::get(args)...});
}
#ifndef _MSC_VER
[[noreturn]] ~throw_exception();
#endif
};
template <typename CharT, usz N, typename... Args>
throw_exception(const CharT(&)[N], const Args&...) -> throw_exception<CharT, N, Args...>;
// Helper template: pack format variables
template <typename Arg = void, typename... Args>
struct tie
{
// Universal reference
std::add_rvalue_reference_t<Arg> arg;
tie<Args...> next;
// Store only references, unveil op is postponed
tie(Arg&& arg, Args&&... args) noexcept
: arg(std::forward<Arg>(arg))
, next(std::forward<Args>(args)...)
{
}
using type = std::remove_cvref_t<Arg>;
// Storage for fmt_unveil (deferred initialization)
decltype(fmt_unveil<type>::get(std::declval<Arg>())) value;
void init(u64 to[])
{
value = fmt_unveil<type>::get(arg);
to[0] = value;
next.init(to + 1);
}
};
template <>
struct tie<void>
{
void init(u64 to[]) const
{
// Isn't really null terminated, this value has no meaning
to[0] = 0;
}
};
template <typename... Args>
tie(Args&&... args) -> tie<Args...>;
// Ensure with formatting
template <typename T, typename CharT, usz N, typename... Args>
decltype(auto) ensure(T&& arg, const CharT(&fmt)[N], tie<Args...> args, std::source_location src_loc = std::source_location::current()) noexcept
{
if (std::forward<T>(arg)) [[likely]]
{
return std::forward<T>(arg);
}
// Prepare u64 array
u64 data[sizeof...(Args) + 1];
args.init(data);
raw_throw_exception(src_loc, reinterpret_cast<const char*>(fmt), type_info_v<std::remove_cvref_t<Args>...>, +data);
}
}
| 10,792
|
C++
|
.h
| 372
| 26.607527
| 174
| 0.693342
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,277
|
bin_patch.h
|
RPCS3_rpcs3/Utilities/bin_patch.h
|
#pragma once
#include <vector>
#include <string>
#include <unordered_map>
#include <functional>
#include "util/types.hpp"
#include "util/yaml.hpp"
namespace patch_key
{
static const std::string all = "All";
static const std::string anchors = "Anchors";
static const std::string author = "Author";
static const std::string games = "Games";
static const std::string group = "Group";
static const std::string notes = "Notes";
static const std::string patch = "Patch";
static const std::string patch_version = "Patch Version";
static const std::string version = "Version";
static const std::string enabled = "Enabled";
static const std::string config_values = "Configurable Values";
static const std::string value = "Value";
static const std::string type = "Type";
static const std::string min = "Min";
static const std::string max = "Max";
static const std::string allowed_values = "Allowed Values";
}
inline static const std::string patch_engine_version = "1.2";
enum class patch_type
{
invalid,
load,
alloc, // Allocate memory at address (zeroized executable memory)
code_alloc,// Allocate memory somewhere, saves branch to memory at specfied address (filled with PPU NOP and branch for returning)
jump, // Install special 32-bit jump instruction (PPU only atm)
jump_link, // jump + set link (PPU only atm)
jump_func, // jump to exported function (PPU only, forever)
byte,
le16,
le32,
le64,
lef32,
lef64,
be16,
be32,
bd32, // be32 with data hint (non-code)
be64,
bd64, // be64 with data hint (non-code)
bef32,
bef64,
bp_exec, // Execution Breakpoint
utf8, // Text of string (not null-terminated automatically)
c_utf8, // Text of string (null-terminated automatically)
move_file, // Move file
hide_file, // Hide file
};
static constexpr bool patch_type_uses_hex_offset(patch_type type)
{
return type >= patch_type::alloc && type <= patch_type::c_utf8;
}
enum class patch_configurable_type
{
double_range,
double_enum,
long_range,
long_enum
};
class patch_engine
{
public:
struct patch_data
{
patch_type type = patch_type::load;
u32 offset = 0;
std::string original_offset{}; // Used for specifying paths
std::string original_value{}; // Used for import consistency (avoid rounding etc.)
union
{
u64 long_value;
f64 double_value;
} value{0};
mutable u32 alloc_addr = 0; // Used to save optional allocation address (if occured)
};
struct patch_allowed_value
{
std::string label;
f64 value{};
bool operator==(const patch_allowed_value& other) const
{
return value == other.value && label == other.label;
}
};
struct patch_config_value
{
f64 value{};
f64 min{};
f64 max{};
patch_configurable_type type{};
std::vector<patch_allowed_value> allowed_values;
bool operator==(const patch_config_value& other) const
{
return value == other.value && min == other.min && max == other.max && type == other.type && allowed_values == other.allowed_values;
}
void set_and_check_value(f64 new_value, std::string_view name);
};
struct patch_config_values
{
bool enabled{};
std::map<std::string, patch_config_value> config_values;
};
using patch_app_versions = std::unordered_map<std::string /*app_version*/, patch_config_values>;
using patch_serials = std::unordered_map<std::string /*serial*/, patch_app_versions>;
using patch_titles = std::unordered_map<std::string /*serial*/, patch_serials>;
struct patch_info
{
// Patch information
std::vector<patch_data> data_list{};
patch_titles titles{};
std::string description{};
std::string patch_version{};
std::string patch_group{};
std::string author{};
std::string notes{};
std::string source_path{};
std::map<std::string, patch_config_value> default_config_values;
// Redundant information for accessibility (see patch_container)
std::string hash{};
std::string version{};
std::map<std::string, patch_config_value> actual_config_values;
};
struct patch_container
{
std::unordered_map<std::string /*description*/, patch_info> patch_info_map{};
std::string hash{};
std::string version{};
};
enum mem_protection : u8
{
wx = 0, // Read + Write + Execute (default)
ro = 1, // Read
rx = 2, // Read + Execute
rw = 3, // Read + Write
mask = 3,
};
using patch_map = std::unordered_map<std::string /*hash*/, patch_container>;
patch_engine();
patch_engine(const patch_engine&) = delete;
patch_engine& operator=(const patch_engine&) = delete;
// Returns the directory in which patch_config.yml is located
static std::string get_patch_config_path();
// Returns the directory in which patches are located
static std::string get_patches_path();
// Returns the filepath for the imported_patch.yml
static std::string get_imported_patch_path();
// Load from file and append to specified patches map
static bool load(patch_map& patches, const std::string& path, std::string content = "", bool importing = false, std::stringstream* log_messages = nullptr);
// Read and add a patch node to the patch info
static bool read_patch_node(patch_info& info, YAML::Node node, const YAML::Node& root, std::string_view path, std::stringstream* log_messages = nullptr);
// Get the patch type from a string
static patch_type get_patch_type(std::string_view text);
// Get the patch type of a patch node
static patch_type get_patch_type(YAML::Node node);
// Add the data of a patch node
static bool add_patch_data(YAML::Node node, patch_info& info, u32 modifier, const YAML::Node& root, std::string_view path, std::stringstream* log_messages = nullptr);
// Save to patch_config.yml
static void save_config(const patch_map& patches_map);
// Save a patch file
static bool save_patches(const patch_map& patches, const std::string& path, std::stringstream* log_messages = nullptr);
// Create or append patches to a file
static bool import_patches(const patch_map& patches, const std::string& path, usz& count, usz& total, std::stringstream* log_messages = nullptr);
// Remove a patch from a file
static bool remove_patch(const patch_info& info);
// Load patch_config.yml
static patch_map load_config();
// Load from file and append to member patches map
void append_global_patches();
// Load from title relevant files and append to member patches map
void append_title_patches(std::string_view title_id);
// Apply patch (returns the number of entries applied)
void apply(std::vector<u32>& applied_total, const std::string& name, std::function<u8*(u32, u32)> mem_translate, u32 filesz = -1, u32 min_addr = 0);
// Deallocate memory used by patches
void unload(const std::string& name);
private:
// Database
patch_map m_map{};
// Only one patch per patch group can be applied
std::set<std::string> m_applied_groups{};
};
| 6,767
|
C++
|
.h
| 187
| 33.802139
| 167
| 0.726675
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,278
|
geometry.h
|
RPCS3_rpcs3/Utilities/geometry.h
|
#pragma once
#include <cmath>
#include <type_traits>
template<typename T>
struct size2_base
{
T width, height;
constexpr size2_base() : width{}, height{}
{
}
constexpr size2_base(T width, T height) : width{ width }, height{ height }
{
}
constexpr size2_base operator -(const size2_base& rhs) const
{
return{ width - rhs.width, height - rhs.height };
}
constexpr size2_base operator -(T rhs) const
{
return{ width - rhs, height - rhs };
}
constexpr size2_base operator +(const size2_base& rhs) const
{
return{ width + rhs.width, height + rhs.height };
}
constexpr size2_base operator +(T rhs) const
{
return{ width + rhs, height + rhs };
}
constexpr size2_base operator /(const size2_base& rhs) const
{
return{ width / rhs.width, height / rhs.height };
}
constexpr size2_base operator /(T rhs) const
{
return{ width / rhs, height / rhs };
}
constexpr size2_base operator *(const size2_base& rhs) const
{
return{ width * rhs.width, height * rhs.height };
}
constexpr size2_base operator *(T rhs) const
{
return{ width * rhs, height * rhs };
}
size2_base& operator -=(const size2_base& rhs)
{
width -= rhs.width;
height -= rhs.height;
return *this;
}
size2_base& operator -=(T rhs)
{
width -= rhs;
height -= rhs;
return *this;
}
size2_base& operator +=(const size2_base& rhs)
{
width += rhs.width;
height += rhs.height;
return *this;
}
size2_base& operator +=(T rhs)
{
width += rhs;
height += rhs;
return *this;
}
size2_base& operator /=(const size2_base& rhs)
{
width /= rhs.width;
height /= rhs.height;
return *this;
}
size2_base& operator /=(T rhs)
{
width /= rhs;
height /= rhs;
return *this;
}
size2_base& operator *=(const size2_base& rhs)
{
width *= rhs.width;
height *= rhs.height;
return *this;
}
size2_base& operator *=(T rhs)
{
width *= rhs;
height *= rhs;
return *this;
}
constexpr bool operator ==(const size2_base& rhs) const
{
return width == rhs.width && height == rhs.height;
}
template<typename NT>
explicit constexpr operator size2_base<NT>() const
{
return{ static_cast<NT>(width), static_cast<NT>(height) };
}
};
template<typename T>
struct position1_base
{
T x;
position1_base operator -(const position1_base& rhs) const
{
return{ x - rhs.x };
}
position1_base operator -(T rhs) const
{
return{ x - rhs };
}
position1_base operator +(const position1_base& rhs) const
{
return{ x + rhs.x };
}
position1_base operator +(T rhs) const
{
return{ x + rhs };
}
template<typename RhsT>
position1_base operator *(RhsT rhs) const
{
return{ static_cast<T>(x * rhs) };
}
position1_base operator *(const position1_base& rhs) const
{
return{ static_cast<T>(x * rhs.x) };
}
template<typename RhsT>
position1_base operator /(RhsT rhs) const
{
return{ x / rhs };
}
position1_base operator /(const position1_base& rhs) const
{
return{ x / rhs.x };
}
position1_base& operator -=(const position1_base& rhs)
{
x -= rhs.x;
return *this;
}
position1_base& operator -=(T rhs)
{
x -= rhs;
return *this;
}
position1_base& operator +=(const position1_base& rhs)
{
x += rhs.x;
return *this;
}
position1_base& operator +=(T rhs)
{
x += rhs;
return *this;
}
template<typename RhsT>
position1_base& operator *=(RhsT rhs) const
{
x *= rhs;
return *this;
}
position1_base& operator *=(const position1_base& rhs) const
{
x *= rhs.x;
return *this;
}
template<typename RhsT>
position1_base& operator /=(RhsT rhs) const
{
x /= rhs;
return *this;
}
position1_base& operator /=(const position1_base& rhs) const
{
x /= rhs.x;
return *this;
}
bool operator ==(const position1_base& rhs) const
{
return x == rhs.x;
}
bool operator ==(T rhs) const
{
return x == rhs;
}
template<typename NT>
explicit operator position1_base<NT>() const
{
return{ static_cast<NT>(x) };
}
double distance(const position1_base& to)
{
return abs(x - to.x);
}
};
template<typename T>
struct position2_base
{
T x, y;
constexpr position2_base() : x{}, y{}
{
}
constexpr position2_base(T x, T y) : x{ x }, y{ y }
{
}
constexpr bool operator >(const position2_base& rhs) const
{
return x > rhs.x && y > rhs.y;
}
constexpr bool operator >(T rhs) const
{
return x > rhs && y > rhs;
}
constexpr bool operator <(const position2_base& rhs) const
{
return x < rhs.x && y < rhs.y;
}
constexpr bool operator <(T rhs) const
{
return x < rhs && y < rhs;
}
constexpr bool operator >=(const position2_base& rhs) const
{
return x >= rhs.x && y >= rhs.y;
}
constexpr bool operator >=(T rhs) const
{
return x >= rhs && y >= rhs;
}
constexpr bool operator <=(const position2_base& rhs) const
{
return x <= rhs.x && y <= rhs.y;
}
constexpr bool operator <=(T rhs) const
{
return x <= rhs && y <= rhs;
}
constexpr position2_base operator -(const position2_base& rhs) const
{
return{ x - rhs.x, y - rhs.y };
}
constexpr position2_base operator -(T rhs) const
{
return{ x - rhs, y - rhs };
}
constexpr position2_base operator +(const position2_base& rhs) const
{
return{ x + rhs.x, y + rhs.y };
}
constexpr position2_base operator +(T rhs) const
{
return{ x + rhs, y + rhs };
}
template<typename RhsT>
constexpr position2_base operator *(RhsT rhs) const
{
return{ static_cast<T>(x * rhs), static_cast<T>(y * rhs) };
}
constexpr position2_base operator *(const position2_base& rhs) const
{
return{ static_cast<T>(x * rhs.x), static_cast<T>(y * rhs.y) };
}
template<typename RhsT>
constexpr position2_base operator /(RhsT rhs) const
{
return{ x / rhs, y / rhs };
}
constexpr position2_base operator /(const position2_base& rhs) const
{
return{ x / rhs.x, y / rhs.y };
}
constexpr position2_base operator /(const size2_base<T>& rhs) const
{
return{ x / rhs.width, y / rhs.height };
}
position2_base& operator -=(const position2_base& rhs)
{
x -= rhs.x;
y -= rhs.y;
return *this;
}
position2_base& operator -=(T rhs)
{
x -= rhs;
y -= rhs;
return *this;
}
position2_base& operator +=(const position2_base& rhs)
{
x += rhs.x;
y += rhs.y;
return *this;
}
position2_base& operator +=(T rhs)
{
x += rhs;
y += rhs;
return *this;
}
template<typename RhsT>
position2_base& operator *=(RhsT rhs)
{
x *= rhs;
y *= rhs;
return *this;
}
position2_base& operator *=(const position2_base& rhs)
{
x *= rhs.x;
y *= rhs.y;
return *this;
}
template<typename RhsT>
position2_base& operator /=(RhsT rhs)
{
x /= rhs;
y /= rhs;
return *this;
}
position2_base& operator /=(const position2_base& rhs)
{
x /= rhs.x;
y /= rhs.y;
return *this;
}
constexpr bool operator ==(const position2_base& rhs) const
{
return x == rhs.x && y == rhs.y;
}
constexpr bool operator ==(T rhs) const
{
return x == rhs && y == rhs;
}
template<typename NT>
explicit constexpr operator position2_base<NT>() const
{
return{ static_cast<NT>(x), static_cast<NT>(y) };
}
double distance(const position2_base& to) const
{
return std::sqrt((x - to.x) * (x - to.x) + (y - to.y) * (y - to.y));
}
};
template<typename T>
struct position3_base
{
T x, y, z;
/*
position3_base() : x{}, y{}, z{}
{
}
position3_base(T x, T y, T z) : x{ x }, y{ y }, z{ z }
{
}
*/
position3_base operator -(const position3_base& rhs) const
{
return{ x - rhs.x, y - rhs.y, z - rhs.z };
}
position3_base operator -(T rhs) const
{
return{ x - rhs, y - rhs, z - rhs };
}
position3_base operator +(const position3_base& rhs) const
{
return{ x + rhs.x, y + rhs.y, z + rhs.z };
}
position3_base operator +(T rhs) const
{
return{ x + rhs, y + rhs, z + rhs };
}
position3_base& operator -=(const position3_base& rhs)
{
x -= rhs.x;
y -= rhs.y;
z -= rhs.z;
return *this;
}
position3_base& operator -=(T rhs)
{
x -= rhs;
y -= rhs;
z -= rhs;
return *this;
}
position3_base& operator +=(const position3_base& rhs)
{
x += rhs.x;
y += rhs.y;
z += rhs.z;
return *this;
}
position3_base& operator +=(T rhs)
{
x += rhs;
y += rhs;
z += rhs;
return *this;
}
bool operator ==(const position3_base& rhs) const
{
return x == rhs.x && y == rhs.y && z == rhs.z;
}
bool operator ==(T rhs) const
{
return x == rhs && y == rhs && z == rhs;
}
template<typename NT>
explicit operator position3_base<NT>() const
{
return{ static_cast<NT>(x), static_cast<NT>(y), static_cast<NT>(z) };
}
};
template<typename T>
struct position4_base
{
T x, y, z, w;
constexpr position4_base() : x{}, y{}, z{}, w{}
{
}
constexpr position4_base(T x, T y = {}, T z = {}, T w = { T(1) }) : x{ x }, y{ y }, z{ z }, w{ w }
{
}
constexpr position4_base operator -(const position4_base& rhs) const
{
return{ x - rhs.x, y - rhs.y, z - rhs.z, w - rhs.w };
}
constexpr position4_base operator -(T rhs) const
{
return{ x - rhs, y - rhs, z - rhs, w - rhs };
}
constexpr position4_base operator +(const position4_base& rhs) const
{
return{ x + rhs.x, y + rhs.y, z + rhs.z, w + rhs.w };
}
constexpr position4_base operator +(T rhs) const
{
return{ x + rhs, y + rhs, z + rhs, w + rhs };
}
position4_base& operator -=(const position4_base& rhs)
{
x -= rhs.x;
y -= rhs.y;
z -= rhs.z;
w -= rhs.w;
return *this;
}
position4_base& operator -=(T rhs)
{
x -= rhs;
y -= rhs;
z -= rhs;
w -= rhs;
return *this;
}
position4_base& operator +=(const position4_base& rhs)
{
x += rhs.x;
y += rhs.y;
z += rhs.z;
w += rhs.w;
return *this;
}
position4_base& operator +=(T rhs)
{
x += rhs;
y += rhs;
z += rhs;
w += rhs;
return *this;
}
constexpr bool operator ==(const position4_base& rhs) const
{
return x == rhs.x && y == rhs.y && z == rhs.z && w == rhs.w;
}
constexpr bool operator ==(T rhs) const
{
return x == rhs && y == rhs && z == rhs && w == rhs;
}
template<typename NT>
explicit constexpr operator position4_base<NT>() const
{
return{ static_cast<NT>(x), static_cast<NT>(y), static_cast<NT>(z), static_cast<NT>(w) };
}
};
template<typename T>
using position_base = position2_base<T>;
template<typename T>
struct coord_base
{
union
{
position_base<T> position;
struct { T x, y; };
};
union
{
size2_base<T> size;
struct { T width, height; };
};
constexpr coord_base() : position{}, size{}
{
}
constexpr coord_base(const position_base<T>& position, const size2_base<T>& size)
: position{ position }, size{ size }
{
}
constexpr coord_base(T x, T y, T width, T height)
: x{ x }, y{ y }, width{ width }, height{ height }
{
}
constexpr bool test(const position_base<T>& position) const
{
if (position.x < x || position.x >= x + width)
return false;
if (position.y < y || position.y >= y + height)
return false;
return true;
}
constexpr bool operator == (const coord_base& rhs) const
{
return position == rhs.position && size == rhs.size;
}
template<typename NT>
explicit constexpr operator coord_base<NT>() const
{
return{ static_cast<NT>(x), static_cast<NT>(y), static_cast<NT>(width), static_cast<NT>(height) };
}
};
template<typename T>
struct area_base
{
T x1, x2;
T y1, y2;
constexpr area_base() : x1{}, x2{}, y1{}, y2{}
{
}
constexpr area_base(T x1, T y1, T x2, T y2) : x1{ x1 }, x2{ x2 }, y1{ y1 }, y2{ y2 }
{
}
template<typename N>
constexpr area_base(const coord_base<N>& coord) : x1{ T(coord.x) }, x2{ T(coord.x + coord.width) }, y1{ T(coord.y) }, y2{ T(coord.y + coord.height) }
{
}
constexpr operator coord_base<T>() const
{
return{ x1, y1, x2 - x1, y2 - y1 };
}
constexpr T width() const
{
return (x1 < x2) ? (x2 - x1) : (x1 - x2);
}
constexpr T height() const
{
return (y1 < y2) ? (y2 - y1) : (y1 - y2);
}
void flip_vertical()
{
T _y = y1; y1 = y2; y2 = _y;
}
void flip_horizontal()
{
T _x = x1; x1 = x2; x2 = _x;
}
constexpr area_base flipped_vertical() const
{
return{ x1, y2, x2, y1 };
}
constexpr area_base flipped_horizontal() const
{
return{ x2, y1, x1, y2 };
}
constexpr bool is_flipped() const
{
return (x1 > x2 || y1 > y2);
}
constexpr bool operator == (const area_base& rhs) const
{
return x1 == rhs.x1 && x2 == rhs.x2 && y1 == rhs.y1 && y2 == rhs.y2;
}
constexpr area_base operator - (const size2_base<T>& size) const
{
return{ x1 - size.width, y1 - size.height, x2 - size.width, y2 - size.height };
}
constexpr area_base operator - (const T& value) const
{
return{ x1 - value, y1 - value, x2 - value, y2 - value };
}
constexpr area_base operator + (const size2_base<T>& size) const
{
return{ x1 + size.width, y1 + size.height, x2 + size.width, y2 + size.height };
}
constexpr area_base operator + (const T& value) const
{
return{ x1 + value, y1 + value, x2 + value, y2 + value };
}
constexpr area_base operator / (const size2_base<T>& size) const
{
return{ x1 / size.width, y1 / size.height, x2 / size.width, y2 / size.height };
}
template <typename U> requires (std::is_arithmetic_v<U>)
constexpr area_base operator / (const U& value) const
{
return area_base{static_cast<T>(x1 / value), static_cast<T>(y1 / value), static_cast<T>(x2 / value), static_cast<T>(y2 / value)};
}
constexpr area_base operator * (const size2_base<T>& size) const
{
return{ x1 * size.width, y1 * size.height, x2 * size.width, y2 * size.height };
}
template <typename U> requires (std::is_arithmetic_v<U>)
constexpr area_base operator * (const U& value) const
{
return area_base{static_cast<T>(x1 * value), static_cast<T>(y1 * value), static_cast<T>(x2 * value), static_cast<T>(y2 * value)};
}
template<typename NT>
explicit constexpr operator area_base<NT>() const
{
return{ static_cast<NT>(x1), static_cast<NT>(y1), static_cast<NT>(x2), static_cast<NT>(y2) };
}
};
template<typename T>
struct size3_base
{
T width, height, depth;
template<typename NT>
explicit constexpr operator size3_base<NT>() const
{
return{ static_cast<NT>(width), static_cast<NT>(height), static_cast<NT>(depth) };
}
};
template<typename T>
struct coord3_base
{
union
{
position3_base<T> position;
struct { T x, y, z; };
};
union
{
size3_base<T> size;
struct { T width, height, depth; };
};
constexpr coord3_base() : position{}, size{}
{
}
constexpr coord3_base(const position3_base<T>& position, const size3_base<T>& size) : position{ position }, size{ size }
{
}
constexpr coord3_base(T x, T y, T z, T width, T height, T depth) : x{ x }, y{ y }, z{ z }, width{ width }, height{ height }, depth{ depth }
{
}
constexpr bool test(const position3_base<T>& position) const
{
if (position.x < x || position.x >= x + width)
return false;
if (position.y < y || position.y >= y + height)
return false;
if (position.z < z || position.z >= z + depth)
return false;
return true;
}
template<typename NT>
explicit constexpr operator coord3_base<NT>() const
{
return{ static_cast<NT>(x), static_cast<NT>(y), static_cast<NT>(z), static_cast<NT>(width), static_cast<NT>(height), static_cast<NT>(depth) };
}
};
template<typename T>
struct color4_base
{
union
{
struct
{
T r, g, b, a;
};
struct
{
T x, y, z, w;
};
T rgba[4];
T xyzw[4];
};
constexpr color4_base()
: x{ T{0} }
, y{ T{0} }
, z{ T{0} }
, w{ T(1) }
{
}
constexpr color4_base(T x, T y, T z, T w)
: x(x)
, y(y)
, z(z)
, w(w)
{
}
constexpr color4_base(T value)
: x(value)
, y(value)
, z(value)
, w(value)
{
}
constexpr bool operator ==(const color4_base& rhs) const
{
return r == rhs.r && g == rhs.g && b == rhs.b && a == rhs.a;
}
void operator *= (const color4_base<T>& rhs)
{
r *= rhs.r;
g *= rhs.g;
b *= rhs.b;
a *= rhs.a;
}
void operator *= (const T& rhs)
{
r *= rhs;
g *= rhs;
b *= rhs;
a *= rhs;
}
constexpr color4_base<T> operator * (const color4_base<T>& rhs) const
{
return { r * rhs.r, g * rhs.g, b * rhs.b, a * rhs.a };
}
constexpr color4_base<T> operator * (const T& rhs) const
{
return { r * rhs, g * rhs, b * rhs, a * rhs };
}
constexpr color4_base<T> operator + (const color4_base<T>& rhs) const
{
return { r + rhs.r, g + rhs.g, b + rhs.b, a + rhs.a };
}
template<typename NT>
explicit constexpr operator color4_base<NT>() const
{
return{ static_cast<NT>(x), static_cast<NT>(y), static_cast<NT>(z), static_cast<NT>(w) };
}
};
template<typename T>
struct color3_base
{
union
{
struct
{
T r, g, b;
};
struct
{
T x, y, z;
};
T rgb[3];
T xyz[3];
};
constexpr color3_base(T x = {}, T y = {}, T z = {})
: x(x)
, y(y)
, z(z)
{
}
constexpr bool operator ==(const color3_base& rhs) const
{
return r == rhs.r && g == rhs.g && b == rhs.b;
}
template<typename NT>
explicit constexpr operator color3_base<NT>() const
{
return{ static_cast<NT>(x), static_cast<NT>(y), static_cast<NT>(z) };
}
};
template<typename T>
struct color2_base
{
union
{
struct
{
T r, g;
};
struct
{
T x, y;
};
T rg[2];
T xy[2];
};
constexpr color2_base(T x = {}, T y = {})
: x(x)
, y(y)
{
}
constexpr bool operator ==(const color2_base& rhs) const
{
return r == rhs.r && g == rhs.g;
}
template<typename NT>
explicit constexpr operator color2_base<NT>() const
{
return{ static_cast<NT>(x), static_cast<NT>(y) };
}
};
template<typename T>
struct color1_base
{
union
{
T r;
T x;
};
constexpr color1_base(T x = {})
: x(x)
{
}
constexpr bool operator ==(const color1_base& rhs) const
{
return r == rhs.r;
}
template<typename NT>
explicit constexpr operator color1_base<NT>() const
{
return{ static_cast<NT>(x) };
}
};
//specializations
using positionu = position_base<unsigned int>;
using positioni = position_base<int>;
using positionf = position_base<float>;
using positiond = position_base<double>;
using coordu = coord_base<unsigned int>;
using coordi = coord_base<int>;
using coordf = coord_base<float>;
using coordd = coord_base<double>;
using areau = area_base<unsigned int>;
using areai = area_base<int>;
using areaf = area_base<float>;
using aread = area_base<double>;
using position1u = position1_base<unsigned int>;
using position1i = position1_base<int>;
using position1f = position1_base<float>;
using position1d = position1_base<double>;
using position2u = position2_base<unsigned int>;
using position2i = position2_base<int>;
using position2f = position2_base<float>;
using position2d = position2_base<double>;
using position3u = position3_base<unsigned int>;
using position3i = position3_base<int>;
using position3f = position3_base<float>;
using position3d = position3_base<double>;
using position4u = position4_base<unsigned int>;
using position4i = position4_base<int>;
using position4f = position4_base<float>;
using position4d = position4_base<double>;
using size2u = size2_base<unsigned int>;
using size2i = size2_base<int>;
using size2f = size2_base<float>;
using size2d = size2_base<double>;
using sizeu = size2u;
using sizei = size2i;
using sizef = size2f;
using sized = size2d;
using size3u = size3_base<unsigned int>;
using size3i = size3_base<int>;
using size3f = size3_base<float>;
using size3d = size3_base<double>;
using coord3u = coord3_base<unsigned int>;
using coord3i = coord3_base<int>;
using coord3f = coord3_base<float>;
using coord3d = coord3_base<double>;
using color4u = color4_base<unsigned int>;
using color4i = color4_base<int>;
using color4f = color4_base<float>;
using color4d = color4_base<double>;
using color3u = color3_base<unsigned int>;
using color3i = color3_base<int>;
using color3f = color3_base<float>;
using color3d = color3_base<double>;
using color2u = color2_base<unsigned int>;
using color2i = color2_base<int>;
using color2f = color2_base<float>;
using color2d = color2_base<double>;
using color1u = color1_base<unsigned int>;
using color1i = color1_base<int>;
using color1f = color1_base<float>;
using color1d = color1_base<double>;
| 19,936
|
C++
|
.h
| 893
| 19.99888
| 150
| 0.651546
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,279
|
BitField.h
|
RPCS3_rpcs3/Utilities/BitField.h
|
#pragma once
#include "util/types.hpp"
#include "Utilities/StrFmt.h"
#ifndef _MSC_VER
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#endif
template <typename T, uint N>
struct bf_base
{
using type = T;
using vtype = std::common_type_t<type>;
using utype = std::make_unsigned_t<vtype>;
static constexpr bool can_be_packed = N < (sizeof(int) * 8 + (std::is_unsigned_v<vtype> ? 1 : 0)) && sizeof(vtype) > sizeof(int);
using compact_type = std::conditional_t<can_be_packed, std::conditional_t<std::is_unsigned_v<vtype>, uint, int>, vtype>;
// Datatype bitsize
static constexpr uint bitmax = sizeof(T) * 8; static_assert(N - 1 < bitmax, "bf_base<> error: N out of bounds");
// Field bitsize
static constexpr uint bitsize = N;
// All ones mask
static constexpr utype mask1 = static_cast<utype>(~static_cast<utype>(0));
// Value mask
static constexpr utype vmask = mask1 >> (bitmax - bitsize);
protected:
type m_data;
};
// Bitfield accessor (N bits from I position, 0 is LSB)
template <typename T, uint I, uint N>
struct bf_t : bf_base<T, N>
{
using type = typename bf_t::type;
using vtype = typename bf_t::vtype;
using utype = typename bf_t::utype;
using compact_type = typename bf_t::compact_type;
// Field offset
static constexpr uint bitpos = I; static_assert(bitpos + N <= bf_t::bitmax, "bf_t<> error: I out of bounds");
// Get bitmask of size N, at I pos
static constexpr utype data_mask()
{
return static_cast<utype>(static_cast<utype>(bf_t::mask1 >> (bf_t::bitmax - bf_t::bitsize)) << bitpos);
}
// Bitfield extraction
static constexpr compact_type extract(const T& data) noexcept
{
if constexpr (std::is_signed_v<T>)
{
// Load signed value (sign-extended)
return static_cast<compact_type>(static_cast<vtype>(static_cast<utype>(data) << (bf_t::bitmax - bitpos - N)) >> (bf_t::bitmax - N));
}
else
{
// Load unsigned value
return static_cast<compact_type>((static_cast<utype>(data) >> bitpos) & bf_t::vmask);
}
}
// Bitfield insertion
static constexpr vtype insert(compact_type value)
{
return static_cast<vtype>((value & bf_t::vmask) << bitpos);
}
// Load bitfield value
constexpr operator compact_type() const noexcept
{
return extract(this->m_data);
}
// Load raw data with mask applied
constexpr T unshifted() const
{
return static_cast<T>(this->m_data & data_mask());
}
// Optimized bool conversion (must be removed if inappropriate)
explicit constexpr operator bool() const noexcept
{
return unshifted() != 0u;
}
// Store bitfield value
bf_t& operator =(compact_type value) noexcept
{
this->m_data = static_cast<vtype>((this->m_data & ~data_mask()) | insert(value));
return *this;
}
compact_type operator ++(int)
{
compact_type result = *this;
*this = static_cast<compact_type>(result + 1u);
return result;
}
bf_t& operator ++()
{
return *this = static_cast<compact_type>(*this + 1u);
}
compact_type operator --(int)
{
compact_type result = *this;
*this = static_cast<compact_type>(result - 1u);
return result;
}
bf_t& operator --()
{
return *this = static_cast<compact_type>(*this - 1u);
}
bf_t& operator +=(compact_type right)
{
return *this = static_cast<compact_type>(*this + right);
}
bf_t& operator -=(compact_type right)
{
return *this = static_cast<compact_type>(*this - right);
}
bf_t& operator *=(compact_type right)
{
return *this = static_cast<compact_type>(*this * right);
}
bf_t& operator &=(compact_type right)
{
this->m_data &= static_cast<vtype>(((static_cast<utype>(right + 0u) & bf_t::vmask) << bitpos) | ~(bf_t::vmask << bitpos));
return *this;
}
bf_t& operator |=(compact_type right)
{
this->m_data |= static_cast<vtype>((static_cast<utype>(right + 0u) & bf_t::vmask) << bitpos);
return *this;
}
bf_t& operator ^=(compact_type right)
{
this->m_data ^= static_cast<vtype>((static_cast<utype>(right + 0u) & bf_t::vmask) << bitpos);
return *this;
}
};
template <typename T, uint I, uint N>
struct std::common_type<bf_t<T, I, N>, bf_t<T, I, N>> : std::common_type<T> {};
template <typename T, uint I, uint N, typename T2>
struct std::common_type<bf_t<T, I, N>, T2> : std::common_type<T2, std::common_type_t<T>> {};
template <typename T, uint I, uint N, typename T2>
struct std::common_type<T2, bf_t<T, I, N>> : std::common_type<std::common_type_t<T>, T2> {};
// Field pack (concatenated from left to right)
template <typename F = void, typename... Fields>
struct cf_t : bf_base<typename F::type, F::bitsize + cf_t<Fields...>::bitsize>
{
using type = typename cf_t::type;
using vtype = typename cf_t::vtype;
using utype = typename cf_t::utype;
using compact_type = typename cf_t::compact_type;
// Get disjunction of all "data" masks of concatenated values
static constexpr vtype data_mask()
{
return static_cast<vtype>(F::data_mask() | cf_t<Fields...>::data_mask());
}
// Extract all bitfields and concatenate
static constexpr compact_type extract(const type& data)
{
return static_cast<compact_type>(static_cast<utype>(F::extract(data)) << cf_t<Fields...>::bitsize | cf_t<Fields...>::extract(data));
}
// Split bitfields and insert them
static constexpr vtype insert(compact_type value)
{
return static_cast<vtype>(F::insert(value >> cf_t<Fields...>::bitsize) | cf_t<Fields...>::insert(value));
}
// Load value
constexpr operator compact_type() const noexcept
{
return extract(this->m_data);
}
// Store value
cf_t& operator =(compact_type value) noexcept
{
this->m_data = (this->m_data & ~data_mask()) | insert(value);
return *this;
}
};
// Empty field pack (recursion terminator)
template <>
struct cf_t<void>
{
static constexpr uint bitsize = 0;
static constexpr uint data_mask()
{
return 0;
}
template <typename T>
static constexpr auto extract(const T&) -> decltype(+T())
{
return 0;
}
template <typename T>
static constexpr T insert(T /*value*/)
{
return 0;
}
};
// Fixed field (provides constant values in field pack)
template <typename T, T V, uint N>
struct ff_t : bf_base<T, N>
{
using type = typename ff_t::type;
using vtype = typename ff_t::vtype;
// Return constant value
static constexpr vtype extract(const type&)
{
static_assert((V & ff_t::vmask) == V, "ff_t<> error: V out of bounds");
return V;
}
// Get value
constexpr operator vtype() const noexcept
{
return V;
}
};
#ifndef _MSC_VER
#pragma GCC diagnostic pop
#endif
template <typename T, uint I, uint N>
struct fmt_unveil<bf_t<T, I, N>, void>
{
using type = typename fmt_unveil<std::common_type_t<T>>::type;
static inline auto get(const bf_t<T, I, N>& bf)
{
return fmt_unveil<type>::get(bf);
}
};
template <typename F, typename... Fields>
struct fmt_unveil<cf_t<F, Fields...>, void>
{
using type = typename fmt_unveil<std::common_type_t<typename F::type>>::type;
static inline auto get(const cf_t<F, Fields...>& cf)
{
return fmt_unveil<type>::get(cf);
}
};
template <typename T, T V, uint N>
struct fmt_unveil<ff_t<T, V, N>, void>
{
using type = typename fmt_unveil<std::common_type_t<T>>::type;
static inline auto get(const ff_t<T, V, N>& ff)
{
return fmt_unveil<type>::get(ff);
}
};
| 7,193
|
C++
|
.h
| 238
| 28.008403
| 135
| 0.688007
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,280
|
date_time.h
|
RPCS3_rpcs3/Utilities/date_time.h
|
#pragma once
#include <ctime>
#include <string>
namespace date_time
{
static inline tm get_time(time_t* _time)
{
tm buf;
time_t t = time(_time);
#ifdef _MSC_VER
localtime_s(&buf, &t);
#else
buf = *localtime(&t);
#endif
return buf;
}
static inline std::string fmt_time(const char* fmt, const s64 time)
{
tm buf;
time_t t = time;
#ifdef _MSC_VER
localtime_s(&buf, &t);
#else
buf = *localtime(&t);
#endif
char str[80];
strftime(str, sizeof(str), fmt, &buf);
return str;
}
static inline std::string current_time()
{
char str[80];
tm now = get_time(nullptr);
strftime(str, sizeof(str), "%c", &now);
return str;
}
template<char separator = 0>
static inline std::string current_time_narrow()
{
char str[80];
tm now = get_time(nullptr);
std::string parse_buf;
if constexpr(separator != 0)
parse_buf = std::string("%Y") + separator + "%m" + separator + "%d" + separator + "%H" + separator + "%M" + separator + "%S";
else
parse_buf = "%Y%m%d%H%M%S";
strftime(str, sizeof(str), parse_buf.c_str(), &now);
return str;
}
}
| 1,082
|
C++
|
.h
| 50
| 19.18
| 128
| 0.648438
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,281
|
rXml.h
|
RPCS3_rpcs3/Utilities/rXml.h
|
#pragma once
#ifdef _MSC_VER
#pragma warning(push, 0)
#include <pugixml.hpp>
#pragma warning(pop)
#else
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wall"
#pragma GCC diagnostic ignored "-Wextra"
#pragma GCC diagnostic ignored "-Wold-style-cast"
#pragma GCC diagnostic ignored "-Weffc++"
#include <pugixml.hpp>
#pragma GCC diagnostic pop
#endif
#include <memory>
struct rXmlNode
{
rXmlNode();
rXmlNode(const pugi::xml_node& node);
std::shared_ptr<rXmlNode> GetChildren();
std::shared_ptr<rXmlNode> GetNext();
std::string GetName();
std::string GetAttribute(const std::string& name);
std::string GetNodeContent();
pugi::xml_node handle{};
};
struct rXmlDocument
{
rXmlDocument();
rXmlDocument(const rXmlDocument& other) = delete;
rXmlDocument &operator=(const rXmlDocument& other) = delete;
pugi::xml_parse_result Read(const std::string& data);
virtual std::shared_ptr<rXmlNode> GetRoot();
pugi::xml_document handle{};
};
| 957
|
C++
|
.h
| 35
| 25.771429
| 61
| 0.768559
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,282
|
cfmt.h
|
RPCS3_rpcs3/Utilities/cfmt.h
|
#pragma once
#include "util/types.hpp"
#include <string>
#include <vector>
#include <algorithm>
#include "util/asm.hpp"
/*
C-style format parser. Appends formatted string to `out`, returns number of characters written.
`out`: mutable reference to std::string, std::vector<char> or other compatible container
`fmt`: null-terminated string of `Char` type (char or constructible from char)
`src`: rvalue reference to argument provider.
*/
template<typename Dst, typename Char, typename Src>
usz cfmt_append(Dst& out, const Char* fmt, Src&& src)
{
ensure(fmt);
const usz start_pos = out.size();
struct cfmt_context
{
usz size; // Size of current format sequence
u8 args; // Number of extra args used
u8 type; // Integral type bytesize
bool dot; // Precision enabled
bool left;
bool sign;
bool space;
bool alter;
bool zeros;
uint width;
uint prec;
};
cfmt_context ctx{0};
// Error handling: print untouched sequence, stop further formatting
const auto drop_sequence = [&]
{
out.insert(out.end(), fmt - ctx.size, fmt);
ctx.size = umax;
};
const auto read_decimal = [&](uint result) -> uint
{
while (fmt[0] >= '0' && fmt[0] <= '9' && result <= (uint{umax} / 10))
{
result = result * 10 + (fmt[0] - '0');
fmt++, ctx.size++;
}
return result;
};
const auto write_octal = [&](auto value, u64 min_num)
{
if constexpr (sizeof(value) == 16)
{
out.resize(out.size() + std::max<u64>(min_num, 129 / 3 - (utils::clz128(value | 1) + 1) / 3), '0');
}
else
{
out.resize(out.size() + std::max<u64>(min_num, 66 / 3 - (std::countl_zero<u64>(value | 1) + 2) / 3), '0');
}
// Write in reversed order
for (auto i = out.rbegin(); value; i++, value >>= 3)
{
*i = static_cast<char>(static_cast<u64>(value) & 7) + '0';
}
};
const auto write_hex = [&](auto value, bool upper, u64 min_num)
{
if constexpr (sizeof(value) == 16)
{
out.resize(out.size() + std::max<u64>(min_num, 128 / 4 - utils::clz128(value | 1) / 4), '0');
}
else
{
out.resize(out.size() + std::max<u64>(min_num, 64 / 4 - std::countl_zero<u64>(value | 1) / 4), '0');
}
// Write in reversed order
for (auto i = out.rbegin(); value; i++, value >>= 4)
{
*i = (upper ? "0123456789ABCDEF" : "0123456789abcdef")[static_cast<usz>(value & 0xf)];
}
};
const auto write_decimal = [&](auto value, s64 min_size)
{
const usz start = out.size();
do
{
if constexpr (sizeof(value) == 16)
{
const u128 v0 = value;
value >>= 1;
constexpr u128 by_five = 0x3333'3333'3333'3333;
const u128 v1 = (value >> 64) * by_five;
const u128 v2 = ((value >> 64) * by_five) >> 64;
const u128 v3 = (static_cast<u64>(value) * by_five) >> 64;
value = v1 + v2 + v3;
out.push_back(static_cast<char>(static_cast<u64>(v0 - (value * 10))) + '0');
}
else
{
out.push_back(value % 10 + '0');
value /= 10;
}
}
while (0 < --min_size || value);
// Revert written characters
for (usz i = start, j = out.size() - 1; i < j; i++, j--)
{
std::swap(out[i], out[j]);
}
};
// Single pass over fmt string (null-terminated), TODO: check correct order
while (const Char ch = *fmt++) if (ctx.size == 0)
{
if (ch == '%')
{
ctx.size = 1;
}
else
{
out.push_back(ch);
}
}
else if (ctx.size == 1 && ch == '%')
{
ctx = {0};
out.push_back(ch);
}
else if (ctx.size == umax)
{
out.push_back(ch);
}
else switch (ctx.size++, ch)
{
case '-': ctx.left = true; break;
case '+': ctx.sign = true; break;
case ' ': ctx.space = true; break;
case '#': ctx.alter = true; break;
case '0': ctx.zeros = true; break;
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
if (ctx.width) [[unlikely]]
{
drop_sequence();
}
else
{
ctx.width = read_decimal(ch - '0');
}
break;
}
case '*':
{
if (ctx.width || !src.test(ctx.args)) [[unlikely]]
{
drop_sequence();
}
else
{
const int warg = src.template get<int>(ctx.args++);
ctx.width = std::abs(warg);
ctx.left |= warg < 0;
}
break;
}
case '.':
{
if (ctx.dot || ctx.prec) [[unlikely]]
{
drop_sequence();
}
else if (*fmt >= '0' && *fmt <= '9') // TODO: does it allow '0'?
{
ctx.prec = read_decimal(0);
ctx.dot = true;
}
else if (*fmt == '*')
{
if (!src.test(ctx.args)) [[unlikely]]
{
drop_sequence();
}
else
{
fmt++, ctx.size++;
const int parg = src.template get<int>(ctx.args++);
ctx.prec = std::max(parg, 0);
ctx.dot = parg >= 0;
}
}
else
{
ctx.prec = 0;
ctx.dot = true;
}
break;
}
case 'h':
{
if (ctx.type) [[unlikely]]
{
drop_sequence();
}
else if (fmt[0] == 'h')
{
fmt++, ctx.size++;
ctx.type = src.size_char;
}
else
{
ctx.type = src.size_short;
}
break;
}
case 'l':
{
if (ctx.type) [[unlikely]]
{
drop_sequence();
}
else if (fmt[0] == 'l')
{
fmt++, ctx.size++;
ctx.type = src.size_llong;
}
else
{
ctx.type = src.size_long;
}
break;
}
case 'z':
{
if (ctx.type) [[unlikely]]
{
drop_sequence();
}
else
{
ctx.type = src.size_size;
}
break;
}
case 'j':
{
if (ctx.type) [[unlikely]]
{
drop_sequence();
}
else
{
ctx.type = src.size_max;
}
break;
}
case 't':
{
if (ctx.type) [[unlikely]]
{
drop_sequence();
}
else
{
ctx.type = src.size_diff;
}
break;
}
case 'c':
{
if (ctx.type || !src.test(ctx.args)) [[unlikely]]
{
drop_sequence();
break;
}
const usz start = out.size();
out.push_back(src.template get<Char>(ctx.args));
if (1 < ctx.width)
{
// Add spaces if necessary
out.insert(out.begin() + start + ctx.left, ctx.width - 1, ' ');
}
src.skip(ctx.args);
ctx = {0};
break;
}
case 's':
{
if (ctx.type || !src.test(ctx.args)) [[unlikely]]
{
drop_sequence();
break;
}
const usz start = out.size();
const usz size1 = src.fmt_string(out, ctx.args);
if (ctx.dot && size1 > ctx.prec)
{
// Shrink if necessary
out.resize(start + ctx.prec);
}
const usz size2 = out.size() - start;
if (size2 < ctx.width)
{
// Add spaces if necessary
out.insert(ctx.left ? out.end() : out.begin() + start, ctx.width - size2, ' ');
}
src.skip(ctx.args);
ctx = {0};
break;
}
case 'd':
case 'i':
{
if (!src.test(ctx.args)) [[unlikely]]
{
drop_sequence();
break;
}
const usz src_type = src.type(ctx.args);
if (!ctx.type || src_type > 8)
{
ctx.type = static_cast<u8>(src_type);
if (!ctx.type)
{
ctx.type = src.size_int;
}
}
// Sign-extended argument expected
const u64 val = src.template get<u64>(ctx.args);
bool negative = ctx.type && ctx.type <= 8 && static_cast<s64>(val) < 0;
if (ctx.type == 16)
{
u128 val2 = *reinterpret_cast<const u128*>(val);
negative = !!(val2 & (u128{1} << 127));
}
const usz start = out.size();
if (!ctx.dot || ctx.prec)
{
if (negative)
{
out.push_back('-');
}
else if (ctx.sign)
{
out.push_back('+');
}
else if (ctx.space)
{
out.push_back(' ');
}
if (ctx.type >= 16)
{
u128 val2 = *reinterpret_cast<const u128*>(val);
write_decimal(negative ? u128{} - val2 : val2, ctx.prec);
}
else
{
write_decimal(negative ? u64{} - val : val, ctx.prec);
}
}
const usz size2 = out.size() - start;
if (size2 < ctx.width)
{
// Add padding if necessary
if (ctx.zeros && !ctx.left && !ctx.dot)
{
out.insert(out.begin() + start + (negative || ctx.sign || ctx.space), ctx.width - size2, '0');
}
else
{
out.insert(ctx.left ? out.end() : out.begin() + start, ctx.width - size2, ' ');
}
}
src.skip(ctx.args);
ctx = {0};
break;
}
case 'o':
{
if (!src.test(ctx.args)) [[unlikely]]
{
drop_sequence();
break;
}
const usz src_type = src.type(ctx.args);
if (!ctx.type || src_type > 8)
{
ctx.type = static_cast<u8>(src_type);
if (!ctx.type)
{
ctx.type = src.size_int;
}
}
const u64 mask =
ctx.type == 1 ? 0xff :
ctx.type == 2 ? 0xffff :
ctx.type == 4 ? 0xffff'ffffu :
0xffff'ffff'ffff'ffffu;
// Trunc sign-extended signed types
const u64 val = src.template get<u64>(ctx.args) & mask;
const usz start = out.size();
if (ctx.alter)
{
out.push_back('0');
if (ctx.prec)
{
ctx.prec--;
}
}
if ((ctx.alter && val) || !ctx.dot || ctx.prec)
{
if (ctx.type >= 16)
{
u128 val2 = *reinterpret_cast<const u128*>(val);
write_octal(val2, ctx.prec);
}
else
{
write_octal(val, ctx.prec);
}
}
const usz size2 = out.size() - start;
if (size2 < ctx.width)
{
// Add padding if necessary
out.insert(ctx.left ? out.end() : out.begin() + start, ctx.width - size2, ctx.zeros && !ctx.left && !ctx.dot ? '0' : ' ');
}
src.skip(ctx.args);
ctx = {0};
break;
}
case 'x':
case 'X':
{
if (!src.test(ctx.args)) [[unlikely]]
{
drop_sequence();
break;
}
const usz src_type = src.type(ctx.args);
if (!ctx.type || src_type > 8)
{
ctx.type = static_cast<u8>(src_type);
if (!ctx.type)
{
ctx.type = src.size_int;
}
}
const u64 mask =
ctx.type == 1 ? 0xff :
ctx.type == 2 ? 0xffff :
ctx.type == 4 ? 0xffff'ffffu :
0xffff'ffff'ffff'ffffu;
// Trunc sign-extended signed types
const u64 val = src.template get<u64>(ctx.args) & mask;
const usz start = out.size();
if (ctx.alter)
{
out.push_back('0');
if (val)
{
out.push_back(ch); // Prepend 0x or 0X
}
}
if ((ctx.alter && val) || !ctx.dot || ctx.prec)
{
if (ctx.type >= 16)
{
u128 val2 = *reinterpret_cast<const u128*>(val);
write_hex(val2, ch == 'X', ctx.prec);
}
else
{
write_hex(val, ch == 'X', ctx.prec);
}
}
const usz size2 = out.size() - start;
if (size2 < ctx.width)
{
// Add padding if necessary
if (ctx.zeros && !ctx.left && !ctx.dot)
{
out.insert(out.begin() + start + (ctx.alter && val ? 2 : 0), ctx.width - size2, '0');
}
else
{
out.insert(ctx.left ? out.end() : out.begin() + start, ctx.width - size2, ' ');
}
}
src.skip(ctx.args);
ctx = {0};
break;
}
case 'u':
{
if (!src.test(ctx.args)) [[unlikely]]
{
drop_sequence();
break;
}
const usz src_type = src.type(ctx.args);
if (!ctx.type || src_type > 8)
{
ctx.type = static_cast<u8>(src_type);
if (!ctx.type)
{
ctx.type = src.size_int;
}
}
const u64 mask =
ctx.type == 1 ? 0xff :
ctx.type == 2 ? 0xffff :
ctx.type == 4 ? 0xffff'ffffu :
0xffff'ffff'ffff'ffffu;
// Trunc sign-extended signed types
const u64 val = src.template get<u64>(ctx.args) & mask;
const usz start = out.size();
if (!ctx.dot || ctx.prec)
{
if (ctx.type >= 16)
{
u128 val2 = *reinterpret_cast<const u128*>(val);
write_decimal(val2, ctx.prec);
}
else
{
write_decimal(val, ctx.prec);
}
}
const usz size2 = out.size() - start;
if (size2 < ctx.width)
{
// Add padding if necessary
out.insert(ctx.left ? out.end() : out.begin() + start, ctx.width - size2, ctx.zeros && !ctx.left && !ctx.dot ? '0' : ' ');
}
src.skip(ctx.args);
ctx = {0};
break;
}
case 'p':
{
if (!src.test(ctx.args) || ctx.type) [[unlikely]]
{
drop_sequence();
break;
}
const u64 val = src.template get<u64>(ctx.args);
const usz start = out.size();
write_hex(val, false, sizeof(void*) * 2);
const usz size2 = out.size() - start;
if (size2 < ctx.width)
{
// Add padding if necessary
out.insert(ctx.left ? out.end() : out.begin() + start, ctx.width - size2, ' ');
}
src.skip(ctx.args);
ctx = {0};
break;
}
case 'f':
case 'F':
case 'e':
case 'E':
case 'a':
case 'A':
case 'g':
case 'G':
{
if (!src.test(ctx.args) || ctx.type) [[unlikely]]
{
drop_sequence();
break;
}
// Fallback (TODO)
const std::string _fmt(fmt - ctx.size, fmt);
const f64 arg0 = src.template get<f64>(0);
const u64 arg1 = ctx.args >= 1 ? src.template get<u64>(1) : 0;
const u64 arg2 = ctx.args >= 2 ? src.template get<u64>(2) : 0;
if (const usz _size = std::snprintf(nullptr, 0, _fmt.c_str(), arg0, arg1, arg2))
{
out.resize(out.size() + _size);
std::snprintf(&out.front() + out.size() - _size, _size + 1, _fmt.c_str(), arg0, arg1, arg2);
}
src.skip(ctx.args);
ctx = {0};
break;
}
case 'L': // long double, not supported
case 'n': // writeback, not supported
default:
{
drop_sequence();
}
}
// Handle unfinished sequence
if (ctx.size && ctx.size != umax)
{
fmt--, drop_sequence();
}
return out.size() - start_pos;
}
| 12,690
|
C++
|
.h
| 605
| 17.634711
| 125
| 0.579457
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,283
|
Config.h
|
RPCS3_rpcs3/Utilities/Config.h
|
#pragma once
#include "util/types.hpp"
#include "Utilities/StrUtil.h"
#include "util/logs.hpp"
#include "util/atomic.hpp"
#include "util/shared_ptr.hpp"
#include <algorithm>
#include <utility>
#include <string>
#include <vector>
#include <set>
#include <map>
namespace cfg
{
// Format min and max values
std::vector<std::string> make_int_range(s64 min, s64 max);
// Format min and max unsigned values
std::vector<std::string> make_uint_range(u64 min, u64 max);
// Format min and max float values
std::vector<std::string> make_float_range(f64 min, f64 max);
// Internal hack
bool try_to_enum_value(u64* out, decltype(&fmt_class_string<int>::format) func, std::string_view);
// Internal hack
std::vector<std::string> try_to_enum_list(decltype(&fmt_class_string<int>::format) func);
// Config tree entry type.
enum class type : unsigned
{
node = 0, // cfg::node type
_bool, // cfg::_bool type
_enum, // cfg::_enum type
_int, // cfg::_int type
uint, // cfg::uint type
string, // cfg::string type
set, // cfg::set_entry type
map, // cfg::map_entry type
log, // cfg::log_entry type
device, // cfg::device_entry type
};
// Config tree entry abstract base class
class _base
{
const type m_type{};
protected:
_base* m_parent = nullptr;
bool m_dynamic = true;
const std::string m_name{};
static u32 id_counter;
u32 m_id = 0;
// Ownerless entry constructor
_base(type _type);
// Owned entry constructor
_base(type _type, class node* owner, std::string name, bool dynamic);
public:
_base(const _base&) = delete;
_base& operator=(const _base&) = delete;
virtual ~_base() = default;
// Get unique ID
u32 get_id() const { return m_id; }
// Get parent
_base* get_parent() const { return m_parent; }
// Get type
type get_type() const { return m_type; }
// Get name
const std::string& get_name() const { return m_name; }
// Get dynamic property for reloading configs during games
bool get_is_dynamic() const { return m_dynamic; }
// Reset defaults
virtual void from_default() = 0;
// Convert to string (optional)
virtual std::string to_string() const
{
return {};
}
// Convert default to string (optional)
virtual std::string def_to_string() const
{
return {};
}
// Try to convert from string (optional)
virtual bool from_string(std::string_view, bool /*dynamic*/ = false);
// Get string list (optional)
virtual std::vector<std::string> to_list() const
{
return {};
}
// Set multiple values. Implementation-specific, optional.
virtual bool from_list(std::vector<std::string>&&);
bool save(std::string_view cfg_name) const;
};
// Config tree node which contains another nodes
class node : public _base
{
std::vector<_base*> m_nodes{};
friend class _base;
public:
// Root node constructor
node()
: _base(type::node)
{
}
// Registered node constructor
node(node* owner, std::string name, bool dynamic = true)
: _base(type::node, owner, std::move(name), dynamic)
{
}
// Get child nodes
const auto& get_nodes() const
{
return m_nodes;
}
// Serialize node
std::string to_string() const override;
// Deserialize node
bool from_string(std::string_view value, bool dynamic = false) override;
// Set default values
void from_default() override;
};
class _bool final : public _base
{
atomic_t<bool> m_value;
public:
bool def;
_bool(node* owner, std::string name, bool def = false, bool dynamic = false)
: _base(type::_bool, owner, std::move(name), dynamic)
, m_value(def)
, def(def)
{
}
explicit operator bool() const
{
return m_value;
}
bool get() const
{
return m_value;
}
void from_default() override;
std::string to_string() const override
{
return m_value ? "true" : "false";
}
std::string def_to_string() const override
{
return def ? "true" : "false";
}
bool from_string(std::string_view value, bool /*dynamic*/ = false) override
{
if (value.size() != 4 && value.size() != 5)
{
return false;
}
char copy[5];
std::transform(value.begin(), value.end(), std::begin(copy), ::tolower);
if (value.size() == 5 && std::string_view{copy, 5} == "false")
m_value = false;
else if (value.size() == 4 && std::string_view{copy, 4} == "true")
m_value = true;
else
return false;
return true;
}
void set(const bool& value)
{
m_value = value;
}
};
// Value node with fixed set of possible values, each maps to an enum value of type T.
template <typename T>
class _enum : public _base
{
atomic_t<T> m_value;
public:
const T def;
_enum(node* owner, const std::string& name, T value = {}, bool dynamic = false)
: _base(type::_enum, owner, name, dynamic)
, m_value(value)
, def(value)
{
}
operator T() const
{
return m_value;
}
T get() const
{
return m_value;
}
T get_default() const
{
return def;
}
void set(T value)
{
m_value = value;
}
void from_default() override
{
m_value = def;
}
std::string to_string() const override
{
std::string result;
fmt_class_string<T>::format(result, fmt_unveil<T>::get(m_value.load()));
return result; // TODO: ???
}
std::string def_to_string() const override
{
std::string result;
fmt_class_string<T>::format(result, fmt_unveil<T>::get(def));
return result; // TODO: ???
}
bool from_string(std::string_view value, bool /*dynamic*/ = false) override
{
u64 result;
if (try_to_enum_value(&result, &fmt_class_string<T>::format, value))
{
// No narrowing check, it's hard to do right there
m_value = static_cast<T>(static_cast<std::underlying_type_t<T>>(result));
return true;
}
return false;
}
std::vector<std::string> to_list() const override
{
return try_to_enum_list(&fmt_class_string<T>::format);
}
};
// Signed 32/64-bit integer entry with custom Min/Max range.
template <s64 Min, s64 Max>
class _int final : public _base
{
static_assert(Min < Max, "Invalid cfg::_int range");
// Prefer 32 bit type if possible
using int_type = std::conditional_t<Min >= s32{smin} && Max <= s32{smax}, s32, s64>;
atomic_t<int_type> m_value;
public:
int_type def;
// Expose range
static constexpr s64 max = Max;
static constexpr s64 min = Min;
_int(node* owner, const std::string& name, int_type def = std::min<int_type>(Max, std::max<int_type>(Min, 0)), bool dynamic = false)
: _base(type::_int, owner, name, dynamic)
, m_value(def)
, def(def)
{
}
operator int_type() const
{
return m_value;
}
int_type get() const
{
return m_value;
}
void from_default() override
{
m_value = def;
}
std::string to_string() const override
{
return std::to_string(m_value);
}
std::string def_to_string() const override
{
return std::to_string(def);
}
bool from_string(std::string_view value, bool /*dynamic*/ = false) override
{
s64 result;
if (try_to_int64(&result, value, Min, Max))
{
m_value = static_cast<int_type>(result);
return true;
}
return false;
}
void set(const s64& value)
{
ensure(value >= Min && value <= Max);
m_value = static_cast<int_type>(value);
}
std::vector<std::string> to_list() const override
{
return make_int_range(Min, Max);
}
};
// Float entry with custom Min/Max range.
template <s32 Min, s32 Max>
class _float final : public _base
{
static_assert(Min < Max, "Invalid cfg::_float range");
using float_type = f64;
atomic_t<float_type> m_value;
public:
float_type def;
// Expose range
static constexpr float_type max = Max;
static constexpr float_type min = Min;
_float(node* owner, const std::string& name, float_type def = std::min<float_type>(Max, std::max<float_type>(Min, 0)), bool dynamic = false)
: _base(type::_int, owner, name, dynamic)
, m_value(def)
, def(def)
{
}
operator float_type() const
{
return m_value;
}
float_type get() const
{
return m_value;
}
void from_default() override
{
m_value = def;
}
std::string to_string() const override
{
std::string result;
if (try_to_string(&result, m_value))
{
return result;
}
return "0.0";
}
std::string def_to_string() const override
{
std::string result;
if (try_to_string(&result, def))
{
return result;
}
return "0.0";
}
bool from_string(std::string_view value, bool /*dynamic*/ = false) override
{
f64 result;
if (try_to_float(&result, value, Min, Max))
{
m_value = static_cast<float_type>(result);
return true;
}
return false;
}
void set(const f64& value)
{
ensure(value >= Min && value <= Max);
m_value = static_cast<float_type>(value);
}
std::vector<std::string> to_list() const override
{
return make_float_range(Min, Max);
}
};
// Alias for 32 bit int
using int32 = _int<s32{smin}, s32{smax}>;
// Alias for 64 bit int
using int64 = _int<s64{smin}, s64{smax}>;
// Unsigned 32/64-bit integer entry with custom Min/Max range.
template <u64 Min, u64 Max>
class uint final : public _base
{
static_assert(Min < Max, "Invalid cfg::uint range");
// Prefer 32 bit type if possible
using int_type = std::conditional_t<Max <= u32{umax}, u32, u64>;
atomic_t<int_type> m_value;
public:
int_type def;
// Expose range
static constexpr u64 max = Max;
static constexpr u64 min = Min;
uint(node* owner, const std::string& name, int_type def = std::max<int_type>(Min, 0), bool dynamic = false)
: _base(type::uint, owner, name, dynamic)
, m_value(def)
, def(def)
{
}
operator int_type() const
{
return m_value;
}
int_type get() const
{
return m_value;
}
void from_default() override
{
m_value = def;
}
std::string to_string() const override
{
return std::to_string(m_value);
}
std::string def_to_string() const override
{
return std::to_string(def);
}
bool from_string(std::string_view value, bool /*dynamic*/ = false) override
{
u64 result;
if (try_to_uint64(&result, value, Min, Max))
{
m_value = static_cast<int_type>(result);
return true;
}
return false;
}
void set(const u64& value)
{
ensure(value >= Min && value <= Max);
m_value = static_cast<int_type>(value);
}
std::vector<std::string> to_list() const override
{
return make_uint_range(Min, Max);
}
};
// Alias for 32 bit uint
using uint32 = uint<0, u32{umax}>;
// Alias for 64 bit int
using uint64 = uint<0, u64{umax}>;
// Simple string entry with mutex
class string : public _base
{
atomic_ptr<std::string> m_value;
public:
std::string def;
string(node* owner, std::string name, std::string def = {}, bool dynamic = false)
: _base(type::string, owner, name, dynamic)
, m_value(def)
, def(std::move(def))
{
}
operator std::string() const
{
return *m_value.load().get();
}
std::pair<const std::string&, shared_ptr<std::string>> get() const
{
auto v = m_value.load();
if (auto s = v.get())
{
return {*s, std::move(v)};
}
else
{
static const std::string _empty;
return {_empty, {}};
}
}
void from_default() override;
std::string to_string() const override
{
return *m_value.load().get();
}
std::string def_to_string() const override
{
return def;
}
bool from_string(std::string_view value, bool /*dynamic*/ = false) override
{
m_value = std::string(value);
return true;
}
};
// Simple set entry (TODO: template for various types)
class set_entry final : public _base
{
std::set<std::string> m_set{};
public:
// Default value is empty list in current implementation
set_entry(node* owner, const std::string& name)
: _base(type::set, owner, name, false)
{
}
const std::set<std::string>& get_set() const
{
return m_set;
}
void set_set(std::set<std::string>&& set)
{
m_set = std::move(set);
}
void from_default() override;
std::vector<std::string> to_list() const override
{
return { m_set.begin(), m_set.end() };
}
bool from_list(std::vector<std::string>&& list) override
{
m_set = { std::make_move_iterator(list.begin()), std::make_move_iterator(list.end()) };
return true;
}
};
template<typename T>
using map_of_type = std::map<std::string, T, std::less<>>;
class map_entry final : public _base
{
map_of_type<std::string> m_map{};
public:
map_entry(node* owner, const std::string& name)
: _base(type::map, owner, name, true)
{
}
const map_of_type<std::string>& get_map() const
{
return m_map;
}
std::string get_value(std::string_view key);
void set_value(std::string key, std::string value);
void set_map(map_of_type<std::string>&& map);
void erase(std::string_view key);
void from_default() override;
};
class log_entry final : public _base
{
map_of_type<logs::level> m_map{};
public:
log_entry(node* owner, const std::string& name)
: _base(type::log, owner, name, true)
{
}
const map_of_type<logs::level>& get_map() const
{
return m_map;
}
void set_map(map_of_type<logs::level>&& map);
void from_default() override;
};
struct device_info
{
std::string path;
std::string serial;
std::string vid;
std::string pid;
std::pair<u16, u16> get_usb_ids() const;
};
class device_entry final : public _base
{
map_of_type<device_info> m_map{};
map_of_type<device_info> m_default{};
public:
device_entry(node* owner, const std::string& name, map_of_type<device_info> def = {})
: _base(type::device, owner, name, true)
, m_map(std::move(def))
{
m_default = m_map;
}
const map_of_type<device_info>& get_map() const
{
return m_map;
}
const map_of_type<device_info>& get_default() const
{
return m_default;
}
void set_map(map_of_type<device_info>&& map);
void from_default() override;
};
}
| 13,980
|
C++
|
.h
| 560
| 21.610714
| 142
| 0.652574
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,285
|
Thread.h
|
RPCS3_rpcs3/Utilities/Thread.h
|
#pragma once
#include "util/types.hpp"
#include "util/atomic.hpp"
#include "util/shared_ptr.hpp"
#include <string>
#include <concepts>
#include "mutex.h"
#include "lockless.h"
// Hardware core layout
enum class native_core_arrangement : u32
{
undefined,
generic,
intel_ht,
amd_ccx
};
enum class thread_class : u32
{
general = 0,
ppu = 1,
spu = 2,
rsx = 0x55,
};
enum class thread_state : u32
{
created = 0, // Initial state
aborting = 1, // The thread has been joined in the destructor or explicitly aborted
errored = 2, // Set after the emergency_exit call
finished = 3, // Final state, always set at the end of thread execution
mask = 3
};
template <class Context>
class named_thread;
class thread_base;
template <typename Ctx, typename... Args>
struct result_storage
{
static constexpr bool empty = true;
using type = void;
};
template <typename Ctx, typename... Args> requires (!std::is_void_v<std::invoke_result_t<Ctx, Args&&...>>)
struct result_storage<Ctx, Args...>
{
using T = std::invoke_result_t<Ctx, Args&&...>;
static_assert(std::is_default_constructible_v<T>);
alignas(T) std::byte data[sizeof(T)];
static constexpr bool empty = false;
using type = T;
T* _get()
{
return reinterpret_cast<T*>(&data);
}
const T* _get() const
{
return reinterpret_cast<const T*>(&data);
}
void init() noexcept
{
new (data) T();
}
void destroy() noexcept
{
_get()->~T();
}
};
template <typename T>
concept NamedThreadName = requires (const T&)
{
std::string(T::thread_name);
};
// Base class for task queue (linked list)
class thread_future
{
friend class thread_base;
shared_ptr<thread_future> next{};
thread_future* prev{};
protected:
atomic_t<void(*)(thread_base*, thread_future*)> exec{};
atomic_t<u32> done{0};
public:
// Get reference to the atomic variable for inspection and waiting for
const auto& get_wait() const
{
return done;
}
// Wait (preset)
void wait() const
{
done.wait(0);
}
};
// Thread base class
class thread_base
{
public:
// Native thread entry point function type
#ifdef _WIN32
using native_entry = uint(__stdcall*)(void* arg);
#else
using native_entry = void*(*)(void* arg);
#endif
const native_entry entry_point;
// Set name for debugger
static void set_name(std::string);
private:
// Thread handle (platform-specific)
atomic_t<u64> m_thread{0};
// Thread cycles
atomic_t<u64> m_cycles{0};
atomic_t<u32> m_dummy{0};
// Thread state
atomic_t<u32> m_sync{0};
// Thread name
atomic_ptr<std::string> m_tname;
// Thread task queue (reversed linked list)
atomic_ptr<thread_future> m_taskq{};
// Start thread
void start();
// Called at the thread start
void initialize(void (*error_cb)());
// Called at the thread end, returns self handle
u64 finalize(thread_state result) noexcept;
// Cleanup after possibly deleting the thread instance
static native_entry finalize(u64 _self) noexcept;
// Make entry point
static native_entry make_trampoline(u64(*entry)(thread_base* _base));
friend class thread_ctrl;
template <class Context>
friend class named_thread;
protected:
thread_base(native_entry, std::string name);
~thread_base();
public:
// Get CPU cycles since last time this function was called. First call returns 0.
u64 get_cycles();
// Wait for the thread (it does NOT change thread state, and can be called from multiple threads)
bool join(bool dtor = false) const;
// Notify the thread
void notify();
// Get thread id
u64 get_native_id() const;
// Add work to the queue
void push(shared_ptr<thread_future>);
private:
// Clear task queue (execute unless aborting)
void exec();
};
// Collection of global function for current thread
class thread_ctrl final
{
// Current thread
static thread_local thread_base* g_tls_this_thread;
// Error handling details
static thread_local void(*g_tls_error_callback)();
// Target cpu core layout
static atomic_t<native_core_arrangement> g_native_core_layout;
friend class thread_base;
// Optimized get_name() for logging
static std::string get_name_cached();
public:
// Get current thread name
static std::string get_name()
{
if (!g_tls_this_thread)
{
return "not named_thread";
}
return *g_tls_this_thread->m_tname.load();
}
// Get thread name
template <typename T>
static std::string get_name(const named_thread<T>& thread)
{
return *static_cast<const thread_base&>(thread).m_tname.load();
}
// Set current thread name (not recommended)
static void set_name(std::string name)
{
g_tls_this_thread->m_tname.store(make_single<std::string>(name));
g_tls_this_thread->set_name(std::move(name));
}
// Set thread name (not recommended)
template <typename T>
static void set_name(named_thread<T>& thread, std::string name)
{
static_cast<thread_base&>(thread).m_tname.store(make_single<std::string>(name));
if (g_tls_this_thread == std::addressof(static_cast<thread_base&>(thread)))
{
g_tls_this_thread->set_name(std::move(name));
}
}
template <typename T>
static u64 get_cycles(named_thread<T>& thread)
{
return static_cast<thread_base&>(thread).get_cycles();
}
template <typename T>
static void notify(named_thread<T>& thread)
{
static_cast<thread_base&>(thread).notify();
}
template <typename T>
static u64 get_native_id(named_thread<T>& thread)
{
return static_cast<thread_base&>(thread).get_native_id();
}
// Read current state, possibly executing some tasks
static thread_state state();
// Wait once with timeout. Infinite value is -1.
static void wait_for(u64 usec, bool alert = true);
// Wait once with time point, add_time is added to the time point.
static void wait_until(u64* wait_time, u64 add_time = 0, u64 min_wait = 0, bool update_to_current_time = true);
// Waiting with accurate timeout
static void wait_for_accurate(u64 usec);
// Wait.
static inline void wait()
{
wait_for(-1, true);
}
// Wait for both thread sync var and provided atomic var
template <uint Max, typename Func>
static inline void wait_on_custom(Func&& setter, u64 usec = -1)
{
auto _this = g_tls_this_thread;
if (_this->m_sync.bit_test_reset(2) || _this->m_taskq)
{
return;
}
atomic_wait::list<Max + 2> list{};
list.template set<Max>(_this->m_sync, 0);
list.template set<Max + 1>(_this->m_taskq);
setter(list);
list.wait(atomic_wait_timeout{usec <= 0xffff'ffff'ffff'ffff / 1000 ? usec * 1000 : 0xffff'ffff'ffff'ffff});
}
template <typename T, typename U>
static inline void wait_on(T& wait, U old, u64 usec = -1)
{
wait_on_custom<1>([&](atomic_wait::list<3>& list) { list.template set<0>(wait, old); }, usec);
}
template <typename T>
static inline void wait_on(T& wait)
{
wait_on_custom<1>([&](atomic_wait::list<3>& list) { list.template set<0>(wait); });
}
// Exit.
[[noreturn]] static void emergency_exit(std::string_view reason);
// Get current thread (may be nullptr)
static thread_base* get_current()
{
return g_tls_this_thread;
}
// Detect layout
static void detect_cpu_layout();
// Returns a core affinity mask. Set whether to generate the high priority set or not
static u64 get_affinity_mask(thread_class group);
// Sets the native thread priority
static void set_native_priority(int priority);
// Sets the preferred affinity mask for this thread
static void set_thread_affinity_mask(u64 mask);
// Get process affinity mask
static u64 get_process_affinity_mask();
// Miscellaneous
static u64 get_thread_affinity_mask();
// Get current thread stack addr and size
static std::pair<void*, usz> get_thread_stack();
// Sets the native thread priority and returns it to zero at destructor
struct scoped_priority
{
explicit scoped_priority(int prio)
{
set_native_priority(prio);
}
scoped_priority(const scoped_priority&) = delete;
scoped_priority& operator=(const scoped_priority&) = delete;
~scoped_priority()
{
set_native_priority(0);
}
};
// Get thread ID (works for all threads)
static u64 get_tid();
// Check whether current thread is main thread (usually Qt GUI)
static bool is_main();
private:
// Miscellaneous
static const u64 process_affinity_mask;
};
// Used internally
template <bool Discard, typename Ctx, typename... Args>
class thread_future_t : public thread_future, result_storage<Ctx, std::conditional_t<Discard, int, void>, Args...>
{
[[no_unique_address]] decltype(std::make_tuple(std::forward<Args>(std::declval<Args>())...)) m_args;
[[no_unique_address]] Ctx m_func;
using future = thread_future_t;
public:
thread_future_t(Ctx&& func, Args&&... args)
: m_args(std::forward<Args>(args)...)
, m_func(std::forward<Ctx>(func))
{
thread_future::exec.raw() = +[](thread_base* tb, thread_future* tf)
{
const auto _this = static_cast<future*>(tf);
if (!tb) [[unlikely]]
{
if constexpr (!future::empty && !Discard)
{
_this->init();
}
return;
}
if constexpr (future::empty || Discard)
{
std::apply(_this->m_func, std::move(_this->m_args));
}
else
{
new (_this->_get()) decltype(auto)(std::apply(_this->m_func, std::move(_this->m_args)));
}
};
}
~thread_future_t()
{
if constexpr (!future::empty && !Discard)
{
if (!this->exec)
{
this->destroy();
}
}
}
decltype(auto) get()
{
while (this->exec)
{
this->wait();
}
if constexpr (!future::empty && !Discard)
{
return *this->_get();
}
}
decltype(auto) get() const
{
while (this->exec)
{
this->wait();
}
if constexpr (!future::empty && !Discard)
{
return *this->_get();
}
}
};
namespace stx
{
struct launch_retainer;
}
// Derived from the callable object Context, possibly a lambda
template <class Context>
class named_thread final : public Context, result_storage<Context>, thread_base
{
using result = result_storage<Context>;
using thread = thread_base;
static u64 entry_point(thread_base* _base)
{
return static_cast<named_thread*>(_base)->entry_point2();
}
u64 entry_point2()
{
thread::initialize([]()
{
if constexpr (!result::empty)
{
// Construct using default constructor in the case of failure
static_cast<result*>(static_cast<named_thread*>(thread_ctrl::get_current()))->init();
}
});
if constexpr (result::empty)
{
// No result
if constexpr (std::is_invocable_v<Context>)
{
Context::operator()();
}
else
{
// Default event loop
while (thread_ctrl::state() != thread_state::aborting)
{
thread_ctrl::wait();
}
}
}
else
{
// Construct the result using placement new (copy elision should happen)
new (result::_get()) decltype(auto)(Context::operator()());
}
return thread::finalize(thread_state::finished);
}
#if defined(ARCH_X64)
static inline thread::native_entry trampoline = thread::make_trampoline(entry_point);
#else
#ifdef _WIN32
static uint trampoline(void* arg)
#else
static void* trampoline(void* arg)
#endif
{
if (const auto next = thread_base::finalize(entry_point(static_cast<thread_base*>(arg))))
{
return next(thread_ctrl::get_current());
}
return {};
}
#endif
friend class thread_ctrl;
public:
// Forwarding constructor with default name (also potentially the default constructor)
template <typename... Args> requires (std::is_constructible_v<Context, Args&&...>) && (!(std::is_same_v<std::remove_cvref_t<Args>, stx::launch_retainer> || ...)) && (NamedThreadName<Context>)
named_thread(Args&&... args) noexcept
: Context(std::forward<Args>(args)...)
, thread(trampoline, std::string(Context::thread_name))
{
thread::start();
}
// Forwarding constructor with default name, does not automatically run the thread
template <typename... Args> requires (std::is_constructible_v<Context, Args&&...>) && (NamedThreadName<Context>)
named_thread(const stx::launch_retainer&, Args&&... args) noexcept
: Context(std::forward<Args>(args)...)
, thread(trampoline, std::string(Context::thread_name))
{
// Create a stand-by thread context
m_sync |= static_cast<u32>(thread_state::finished);
}
// Normal forwarding constructor
template <typename... Args> requires (std::is_constructible_v<Context, Args&&...>) && (!NamedThreadName<Context>)
named_thread(std::string name, Args&&... args) noexcept
: Context(std::forward<Args>(args)...)
, thread(trampoline, std::move(name))
{
thread::start();
}
// Lambda constructor, also the implicit deduction guide candidate
named_thread(std::string_view name, Context&& f) noexcept requires (!NamedThreadName<Context>)
: Context(std::forward<Context>(f))
, thread(trampoline, std::string(name))
{
thread::start();
}
named_thread(const named_thread&) = delete;
named_thread& operator=(const named_thread&) = delete;
// Wait for the completion and access result (if not void)
[[nodiscard]] decltype(auto) operator()()
{
thread::join();
if constexpr (!result::empty)
{
return *result::_get();
}
}
// Wait for the completion and access result (if not void)
[[nodiscard]] decltype(auto) operator()() const
{
thread::join();
if constexpr (!result::empty)
{
return *result::_get();
}
}
// Send command to the thread to invoke directly (references should be passed via std::ref())
template <bool Discard = true, typename Arg, typename... Args>
auto operator()(Arg&& arg, Args&&... args)
{
// Overloaded operator() of the Context.
constexpr bool v1 = std::is_invocable_v<Context, Arg&&, Args&&...>;
// Anything invocable, not necessarily involving the Context.
constexpr bool v2 = std::is_invocable_v<Arg&&, Args&&...>;
// Could be pointer to a non-static member function (or data member) of the Context.
constexpr bool v3 = std::is_member_pointer_v<std::decay_t<Arg>> && std::is_invocable_v<Arg, Context&, Args&&...>;
// Only one invocation type shall be valid, otherwise we don't know.
static_assert((v1 + v2 + v3) == 1, "Ambiguous or invalid named_thread call.");
if constexpr (v1)
{
using future = thread_future_t<Discard, Context&, Arg, Args...>;
single_ptr<future> target = make_single<future>(*static_cast<Context*>(this), std::forward<Arg>(arg), std::forward<Args>(args)...);
if constexpr (!Discard)
{
shared_ptr<future> result = std::move(target);
// Copy result
thread::push(result);
return result;
}
else
{
// Move target
thread::push(std::move(target));
return;
}
}
else if constexpr (v2)
{
using future = thread_future_t<Discard, Arg, Args...>;
single_ptr<future> target = make_single<future>(std::forward<Arg>(arg), std::forward<Args>(args)...);
if constexpr (!Discard)
{
shared_ptr<future> result = std::move(target);
thread::push(result);
return result;
}
else
{
thread::push(std::move(target));
return;
}
}
else if constexpr (v3)
{
using future = thread_future_t<Discard, Arg, Context&, Args...>;
single_ptr<future> target = make_single<future>(std::forward<Arg>(arg), std::ref(*static_cast<Context*>(this)), std::forward<Args>(args)...);
if constexpr (!Discard)
{
shared_ptr<future> result = std::move(target);
thread::push(result);
return result;
}
else
{
thread::push(std::move(target));
return;
}
}
}
// Access thread state
operator thread_state() const
{
return static_cast<thread_state>(thread::m_sync.load() & 3);
}
named_thread& operator=(thread_state s)
{
if (s == thread_state::created)
{
// Run thread
ensure(operator thread_state() == thread_state::finished);
thread::start();
return *this;
}
bool notify_sync = false;
// Try to abort by assigning thread_state::aborting/finished
// Join thread by thread_state::finished
if (s >= thread_state::aborting && thread::m_sync.fetch_op([](u32& v) { return !(v & 3) && (v |= 1); }).second)
{
notify_sync = true;
}
if constexpr (std::is_assignable_v<Context&, thread_state>)
{
static_cast<Context&>(*this) = s;
}
if (notify_sync)
{
// Notify after context abortion has been made so all conditions for wake-up be satisfied by the time of notification
thread::m_sync.notify_all();
}
if (s == thread_state::finished)
{
// This participates in emulation stopping, use destruction-alike semantics
thread::join(true);
}
return *this;
}
// Context type doesn't need virtual destructor
~named_thread()
{
// Assign aborting state forcefully and join thread
operator=(thread_state::finished);
if constexpr (!result::empty)
{
result::destroy();
}
}
};
// Group of named threads, similar to named_thread
template <class Context>
class named_thread_group final
{
using Thread = named_thread<Context>;
u32 m_count = 0;
Thread* m_threads;
void init_threads()
{
m_threads = static_cast<Thread*>(::operator new(sizeof(Thread) * m_count, std::align_val_t{alignof(Thread)}));
}
public:
// Lambda constructor, also the implicit deduction guide candidate
named_thread_group(std::string_view name, u32 count, Context&& f) noexcept
: m_count(count)
, m_threads(nullptr)
{
if (count == 0)
{
return;
}
init_threads();
// Create all threads
for (u32 i = 0; i < m_count - 1; i++)
{
// Copy the context
new (static_cast<void*>(m_threads + i)) Thread(std::string(name) + std::to_string(i + 1), static_cast<const Context&>(f));
}
// Move the context (if movable)
new (static_cast<void*>(m_threads + m_count - 1)) Thread(std::string(name) + std::to_string(m_count - 1), std::forward<Context>(f));
}
// Constructor with a function performed before adding more threads
template <typename CheckAndPrepare>
named_thread_group(std::string_view name, u32 count, Context&& f, CheckAndPrepare&& check) noexcept
: m_count(count)
, m_threads(nullptr)
{
if (count == 0)
{
return;
}
init_threads();
m_count = 0;
// Create all threads
for (u32 i = 0; i < count - 1; i++)
{
// Copy the context
std::remove_cvref_t<Context> context(static_cast<const Context&>(f));
// Perform the check and additional preparations for each context
if (!std::invoke(std::forward<CheckAndPrepare>(check), i, context))
{
return;
}
m_count++;
new (static_cast<void*>(m_threads + i)) Thread(std::string(name) + std::to_string(i + 1), std::move(context));
}
// Move the context (if movable)
std::remove_cvref_t<Context> context(std::forward<Context>(f));
if (!std::invoke(std::forward<CheckAndPrepare>(check), m_count - 1, context))
{
return;
}
m_count++;
new (static_cast<void*>(m_threads + m_count - 1)) Thread(std::string(name) + std::to_string(m_count - 1), std::move(context));
}
// Default constructor
named_thread_group(std::string_view name, u32 count) noexcept
: m_count(count)
, m_threads(nullptr)
{
if (count == 0)
{
return;
}
init_threads();
// Create all threads
for (u32 i = 0; i < m_count; i++)
{
new (static_cast<void*>(m_threads + i)) Thread(std::string(name) + std::to_string(i + 1));
}
}
named_thread_group(const named_thread_group&) = delete;
named_thread_group& operator=(const named_thread_group&) = delete;
// Wait for completion
bool join() const
{
bool result = true;
for (u32 i = 0; i < m_count; i++)
{
std::as_const(*std::launder(m_threads + i))();
if (std::as_const(*std::launder(m_threads + i)) != thread_state::finished)
result = false;
}
return result;
}
// Join and access specific thread
auto operator[](u32 index) const
{
return std::as_const(*std::launder(m_threads + index))();
}
// Join and access specific thread
auto operator[](u32 index)
{
return (*std::launder(m_threads + index))();
}
// Dumb iterator
auto begin()
{
return std::launder(m_threads);
}
// Dumb iterator
auto end()
{
return m_threads + m_count;
}
u32 size() const
{
return m_count;
}
~named_thread_group() noexcept
{
// Destroy all threads in reverse order (it should join them)
for (u32 i = 0; i < m_count; i++)
{
std::launder(m_threads + (m_count - i - 1))->~Thread();
}
::operator delete(static_cast<void*>(m_threads), std::align_val_t{alignof(Thread)});
}
};
| 20,180
|
C++
|
.h
| 710
| 25.614085
| 192
| 0.689126
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,286
|
JIT.h
|
RPCS3_rpcs3/Utilities/JIT.h
|
#pragma once
#include "util/types.hpp"
#include "util/atomic.hpp"
// Include asmjit with warnings ignored
#define ASMJIT_EMBED
#define ASMJIT_STATIC
#define ASMJIT_BUILD_DEBUG
#undef Bool
#ifdef _MSC_VER
#pragma warning(push, 0)
#include <asmjit/asmjit.h>
#pragma warning(pop)
#else
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wall"
#pragma GCC diagnostic ignored "-Wextra"
#pragma GCC diagnostic ignored "-Wold-style-cast"
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#pragma GCC diagnostic ignored "-Wredundant-decls"
#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
#pragma GCC diagnostic ignored "-Weffc++"
#ifdef __clang__
#pragma GCC diagnostic ignored "-Wdeprecated-anon-enum-enum-conversion"
#pragma GCC diagnostic ignored "-Wcast-qual"
#else
#pragma GCC diagnostic ignored "-Wduplicated-branches"
#pragma GCC diagnostic ignored "-Wdeprecated-enum-enum-conversion"
#endif
#include <asmjit/asmjit.h>
#if defined(ARCH_ARM64)
#include <asmjit/a64.h>
#endif
#pragma GCC diagnostic pop
#endif
#include <array>
#include <functional>
#include <memory>
#include <string>
#include <string_view>
#include <unordered_map>
#include <util/v128.hpp>
#if defined(ARCH_X64)
using native_asm = asmjit::x86::Assembler;
using native_args = std::array<asmjit::x86::Gp, 4>;
#elif defined(ARCH_ARM64)
using native_asm = asmjit::a64::Assembler;
using native_args = std::array<asmjit::a64::Gp, 4>;
#endif
void jit_announce(uptr func, usz size, std::string_view name);
void jit_announce(auto* func, usz size, std::string_view name)
{
jit_announce(uptr(func), size, name);
}
enum class jit_class
{
ppu_code,
ppu_data,
spu_code,
spu_data,
};
struct jit_runtime_base
{
jit_runtime_base() noexcept = default;
virtual ~jit_runtime_base() = default;
jit_runtime_base(const jit_runtime_base&) = delete;
jit_runtime_base& operator=(const jit_runtime_base&) = delete;
const asmjit::Environment& environment() const noexcept;
void* _add(asmjit::CodeHolder* code) noexcept;
virtual uchar* _alloc(usz size, usz align) noexcept = 0;
};
// ASMJIT runtime for emitting code in a single 2G region
struct jit_runtime final : jit_runtime_base
{
jit_runtime();
~jit_runtime() override;
// Allocate executable memory
uchar* _alloc(usz size, usz align) noexcept override;
// Allocate memory
static u8* alloc(usz size, usz align, bool exec = true) noexcept;
// Should be called at least once after global initialization
static void initialize();
// Deallocate all memory
static void finalize() noexcept;
};
namespace asmjit
{
// Should only be used to build global functions
jit_runtime_base& get_global_runtime();
// Don't use directly
class inline_runtime : public jit_runtime_base
{
uchar* m_data;
usz m_size;
public:
inline_runtime(uchar* data, usz size);
~inline_runtime();
uchar* _alloc(usz size, usz align) noexcept override;
};
// Emit xbegin and adjacent loop, return label at xbegin (don't use xabort please)
template <typename F>
[[nodiscard]] inline asmjit::Label build_transaction_enter(asmjit::x86::Assembler& c, asmjit::Label fallback, F func)
{
Label fall = c.newLabel();
Label begin = c.newLabel();
c.jmp(begin);
c.bind(fall);
// Don't repeat on zero status (may indicate syscall or interrupt)
c.test(x86::eax, x86::eax);
c.jz(fallback);
// First invoked after failure (can fallback to proceed, or jump anywhere else)
func();
// Other bad statuses are ignored regardless of repeat flag (TODO)
c.align(AlignMode::kCode, 16);
c.bind(begin);
return fall;
// xbegin should be issued manually, allows to add more check before entering transaction
}
// Helper to spill RDX (EDX) register for RDTSC
inline void build_swap_rdx_with(asmjit::x86::Assembler& c, std::array<x86::Gp, 4>& args, const asmjit::x86::Gp& with)
{
#ifdef _WIN32
c.xchg(args[1], with);
args[1] = with;
#else
c.xchg(args[2], with);
args[2] = with;
#endif
}
// Get full RDTSC value into chosen register (clobbers rax/rdx or saves only rax with other target)
inline void build_get_tsc(asmjit::x86::Assembler& c, const asmjit::x86::Gp& to = asmjit::x86::rax)
{
if (&to != &x86::rax && &to != &x86::rdx)
{
// Swap to save its contents
c.xchg(x86::rax, to);
}
c.rdtsc();
c.shl(x86::rdx, 32);
if (&to == &x86::rax)
{
c.or_(x86::rax, x86::rdx);
}
else if (&to == &x86::rdx)
{
c.or_(x86::rdx, x86::rax);
}
else
{
// Swap back, maybe there is more effective way to do it
c.xchg(x86::rax, to);
c.mov(to.r32(), to.r32());
c.or_(to.r64(), x86::rdx);
}
}
inline void build_init_args_from_ghc(native_asm& c, native_args& args)
{
#if defined(ARCH_X64)
// TODO: handle case when args don't overlap with r13/rbp/r12/rbx
c.mov(args[0], x86::r13);
c.mov(args[1], x86::rbp);
c.mov(args[2], x86::r12);
c.mov(args[3], x86::rbx);
#else
static_cast<void>(c);
static_cast<void>(args);
#endif
}
inline void build_init_ghc_args(native_asm& c, native_args& args)
{
#if defined(ARCH_X64)
// TODO: handle case when args don't overlap with r13/rbp/r12/rbx
c.mov(x86::r13, args[0]);
c.mov(x86::rbp, args[1]);
c.mov(x86::r12, args[2]);
c.mov(x86::rbx, args[3]);
#else
static_cast<void>(c);
static_cast<void>(args);
#endif
}
#if defined(ARCH_X64)
struct simd_builder : native_asm
{
std::unordered_map<v128, Label> consts;
Operand v0, v1, v2, v3, v4, v5;
uint vsize = 16;
uint vmask = 0;
simd_builder(CodeHolder* ch) noexcept;
~simd_builder();
void operator()() noexcept;
void _init(uint new_vsize = 0);
void vec_cleanup_ret();
void vec_set_all_zeros(const Operand& v);
void vec_set_all_ones(const Operand& v);
void vec_set_const(const Operand& v, const v128& value);
void vec_clobbering_test(u32 esize, const Operand& v, const Operand& rhs);
void vec_broadcast_gpr(u32 esize, const Operand& v, const x86::Gp& r);
// return x86::ptr(base, ctr, X, 0) where X is set for esize accordingly
x86::Mem ptr_scale_for_vec(u32 esize, const x86::Gp& base, const x86::Gp& index);
void vec_load_unaligned(u32 esize, const Operand& v, const x86::Mem& src);
void vec_store_unaligned(u32 esize, const Operand& v, const x86::Mem& dst);
void vec_partial_move(u32 esize, const Operand& dst, const Operand& src);
void _vec_binary_op(x86::Inst::Id sse_op, x86::Inst::Id vex_op, x86::Inst::Id evex_op, const Operand& dst, const Operand& lhs, const Operand& rhs);
void vec_shuffle_xi8(const Operand& dst, const Operand& lhs, const Operand& rhs)
{
using enum x86::Inst::Id;
_vec_binary_op(kIdPshufb, kIdVpshufb, kIdVpshufb, dst, lhs, rhs);
}
void vec_xor(u32, const Operand& dst, const Operand& lhs, const Operand& rhs)
{
using enum x86::Inst::Id;
_vec_binary_op(kIdPxor, kIdVpxor, kIdVpxord, dst, lhs, rhs);
}
void vec_or(u32, const Operand& dst, const Operand& lhs, const Operand& rhs)
{
using enum x86::Inst::Id;
_vec_binary_op(kIdPor, kIdVpor, kIdVpord, dst, lhs, rhs);
}
void vec_andn(u32, const Operand& dst, const Operand& lhs, const Operand& rhs)
{
using enum x86::Inst::Id;
_vec_binary_op(kIdPandn, kIdVpandn, kIdVpandnd, dst, lhs, rhs);
}
void vec_umin(u32 esize, const Operand& dst, const Operand& lhs, const Operand& rhs);
void vec_umax(u32 esize, const Operand& dst, const Operand& lhs, const Operand& rhs);
void vec_cmp_eq(u32 esize, const Operand& dst, const Operand& lhs, const Operand& rhs);
void vec_extract_high(u32 esize, const Operand& dst, const Operand& src);
void vec_extract_gpr(u32 esize, const x86::Gp& dst, const Operand& src);
simd_builder& keep_if_not_masked()
{
if (vmask && vmask < 8)
{
this->k(x86::KReg(vmask));
}
return *this;
}
simd_builder& zero_if_not_masked()
{
if (vmask && vmask < 8)
{
this->k(x86::KReg(vmask));
this->z();
}
return *this;
}
void build_loop(u32 esize, const x86::Gp& reg_ctr, const x86::Gp& reg_cnt, auto&& build, auto&& reduce)
{
ensure((esize & (esize - 1)) == 0);
ensure(esize <= vsize);
Label body = this->newLabel();
Label next = this->newLabel();
Label exit = this->newLabel();
const u32 step = vsize / esize;
this->xor_(reg_ctr.r32(), reg_ctr.r32()); // Reset counter reg
this->cmp(reg_cnt, step);
this->jb(next); // If count < step, skip main loop body
this->align(AlignMode::kCode, 16);
this->bind(body);
this->sub(reg_cnt, step);
build();
this->add(reg_ctr, step);
this->cmp(reg_cnt, step);
this->jae(body);
this->bind(next);
if (vmask)
{
// Build single last iteration (masked)
this->test(reg_cnt, reg_cnt);
this->jz(exit);
if (esize == 1 && vsize == 64)
{
this->bzhi(reg_cnt.r64(), x86::Mem(consts[~u128()], 0), reg_cnt.r64());
this->kmovq(x86::k7, reg_cnt.r64());
}
else
{
this->bzhi(reg_cnt.r32(), x86::Mem(consts[~u128()], 0), reg_cnt.r32());
this->kmovd(x86::k7, reg_cnt.r32());
}
vmask = 7;
build();
// Rollout reduction step
this->bind(exit);
while (true)
{
vsize /= 2;
if (vsize < esize)
break;
this->_init(vsize);
reduce();
}
}
else
{
// Build unrolled loop tail (reduced vector width)
while (true)
{
vsize /= 2;
if (vsize < esize)
break;
// Shall not clobber flags
this->_init(vsize);
reduce();
if (vsize == esize)
{
// Last "iteration"
this->test(reg_cnt, reg_cnt);
this->jz(exit);
build();
}
else
{
const u32 step = vsize / esize;
Label next = this->newLabel();
this->cmp(reg_cnt, step);
this->jb(next);
build();
this->add(reg_ctr, step);
this->sub(reg_cnt, step);
this->bind(next);
}
}
this->bind(exit);
}
this->_init(0);
}
};
// for (; count > 0; ctr++, count--)
inline void build_loop(native_asm& c, auto ctr, auto count, auto&& build)
{
asmjit::Label body = c.newLabel();
asmjit::Label exit = c.newLabel();
c.test(count, count);
c.jz(exit);
c.align(asmjit::AlignMode::kCode, 16);
c.bind(body);
build();
c.inc(ctr);
c.sub(count, 1);
c.ja(body);
c.bind(exit);
}
inline void maybe_flush_lbr(native_asm& c, uint count = 2)
{
// Workaround for bad LBR callstacks which happen in some situations (mainly TSX) - execute additional RETs
Label next = c.newLabel();
c.lea(x86::rcx, x86::qword_ptr(next));
for (u32 i = 0; i < count; i++)
{
c.push(x86::rcx);
c.sub(x86::rcx, 16);
}
for (u32 i = 0; i < count; i++)
{
c.ret();
c.align(asmjit::AlignMode::kCode, 16);
}
c.bind(next);
}
#endif
}
// Build runtime function with asmjit::X86Assembler
template <typename FT, typename Asm = native_asm, typename F>
inline FT build_function_asm(std::string_view name, F&& builder, ::jit_runtime* custom_runtime = nullptr)
{
#ifdef __APPLE__
pthread_jit_write_protect_np(false);
#endif
using namespace asmjit;
auto& rt = custom_runtime ? *custom_runtime : get_global_runtime();
CodeHolder code;
code.init(rt.environment());
#if defined(ARCH_X64)
native_args args;
#ifdef _WIN32
args[0] = x86::rcx;
args[1] = x86::rdx;
args[2] = x86::r8;
args[3] = x86::r9;
#else
args[0] = x86::rdi;
args[1] = x86::rsi;
args[2] = x86::rdx;
args[3] = x86::rcx;
#endif
#elif defined(ARCH_ARM64)
native_args args;
args[0] = a64::x0;
args[1] = a64::x1;
args[2] = a64::x2;
args[3] = a64::x3;
#endif
Asm compiler(&code);
compiler.addEncodingOptions(EncodingOptions::kOptimizedAlign);
if constexpr (std::is_invocable_r_v<bool, F, Asm&, native_args&>)
{
if (!builder(compiler, args))
return nullptr;
}
else
{
builder(compiler, args);
}
if constexpr (std::is_invocable_r_v<void, Asm>)
{
// Finalization
compiler();
}
const auto result = rt._add(&code);
jit_announce(result, code.codeSize(), name);
return reinterpret_cast<FT>(uptr(result));
}
#ifdef LLVM_AVAILABLE
namespace llvm
{
class LLVMContext;
class ExecutionEngine;
class Module;
class StringRef;
}
// Temporary compiler interface
class jit_compiler final
{
// Local LLVM context
std::unique_ptr<llvm::LLVMContext> m_context{};
// Execution instance
std::unique_ptr<llvm::ExecutionEngine> m_engine{};
// Arch
std::string m_cpu{};
// Disk Space left
atomic_t<usz> m_disk_space = umax;
public:
jit_compiler(const std::unordered_map<std::string, u64>& _link, const std::string& _cpu, u32 flags = 0);
~jit_compiler();
// Get LLVM context
auto& get_context()
{
return *m_context;
}
auto& get_engine() const
{
return *m_engine;
}
// Add module (path to obj cache dir)
void add(std::unique_ptr<llvm::Module> _module, const std::string& path);
// Add module (not cached)
void add(std::unique_ptr<llvm::Module> _module);
// Add object (path to obj file)
bool add(const std::string& path);
// Update global mapping for a single value
void update_global_mapping(const std::string& name, u64 addr);
// Check object file
static bool check(const std::string& path);
// Finalize
void fin();
// Get compiled function address
u64 get(const std::string& name);
// Get CPU info
static std::string cpu(const std::string& _cpu);
// Get system triple (PPU)
static std::string triple1();
// Get system triple (SPU)
static std::string triple2();
bool add_sub_disk_space(ssz space);
};
llvm::StringRef fallback_cpu_detection();
#endif // LLVM_AVAILABLE
| 13,493
|
C++
|
.h
| 468
| 25.880342
| 149
| 0.681906
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,287
|
ppu_patch.h
|
RPCS3_rpcs3/Utilities/ppu_patch.h
|
#pragma once
#include <util/types.hpp>
#include <unordered_set>
#include <vector>
#include <string>
// Patch utilities specific to PPU code
struct ppu_patch_block_registry_t
{
ppu_patch_block_registry_t() = default;
ppu_patch_block_registry_t(const ppu_patch_block_registry_t&) = delete;
ppu_patch_block_registry_t& operator=(const ppu_patch_block_registry_t&) = delete;
std::unordered_set<u32> block_addresses{};
};
void ppu_register_range(u32 addr, u32 size);
bool ppu_form_branch_to_code(u32 entry, u32 target, bool link = false, bool with_toc = false, std::string module_name = {});
u32 ppu_generate_id(std::string_view name);
| 651
|
C++
|
.h
| 16
| 38.4375
| 124
| 0.740095
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,288
|
simple_ringbuf.h
|
RPCS3_rpcs3/Utilities/simple_ringbuf.h
|
#pragma once
#include "util/types.hpp"
#include "util/atomic.hpp"
#include <vector>
// Single reader/writer simple ringbuffer.
class simple_ringbuf
{
public:
simple_ringbuf(u64 size = 0);
virtual ~simple_ringbuf();
simple_ringbuf(const simple_ringbuf& other);
simple_ringbuf& operator=(const simple_ringbuf& other);
// Thread unsafe functions.
simple_ringbuf(simple_ringbuf&& other);
simple_ringbuf& operator=(simple_ringbuf&& other);
void set_buf_size(u64 size);
// Helper functions
u64 get_free_size() const;
u64 get_used_size() const;
u64 get_total_size() const;
// Writer functions
u64 push(const void* data, u64 size, bool force = false);
void writer_flush(u64 cnt = umax);
// Reader functions
u64 pop(void* data, u64 size, bool force = false);
void reader_flush(u64 cnt = umax);
private:
struct ctr_state
{
alignas(sizeof(u64) * 2)
u64 read_ptr = 0;
u64 write_ptr = 0;
auto operator<=>(const ctr_state& other) const = default;
};
static_assert(sizeof(ctr_state) == sizeof(u64) * 2);
atomic_t<ctr_state> rw_ptr{};
std::vector<u8> buf{};
u64 get_free_size(ctr_state val) const;
u64 get_used_size(ctr_state val) const;
};
| 1,173
|
C++
|
.h
| 40
| 27.125
| 59
| 0.728329
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,289
|
File.h
|
RPCS3_rpcs3/Utilities/File.h
|
#pragma once // No BOM and only basic ASCII in this header, or a neko will die
#include "util/types.hpp"
#include "util/shared_ptr.hpp"
#include "bit_set.h"
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
namespace fs
{
#ifdef _WIN32
static constexpr auto& delim = "/\\";
static constexpr auto& wdelim = L"/\\";
using native_handle = void*;
#else
static constexpr auto& delim = "/";
static constexpr auto& wdelim = L"/";
using native_handle = int;
#endif
// File open mode flags
enum class open_mode : u32
{
read,
write,
append,
create,
trunc,
excl,
lock,
unread,
isfile,
__bitset_enum_max
};
constexpr auto read = +open_mode::read; // Enable reading
constexpr auto write = +open_mode::write; // Enable writing
constexpr auto append = +open_mode::append; // Always append to the end of the file
constexpr auto create = +open_mode::create; // Create file if it doesn't exist
constexpr auto trunc = +open_mode::trunc; // Clear opened file if it's not empty
constexpr auto excl = +open_mode::excl; // Failure if the file already exists (used with `create`)
constexpr auto lock = +open_mode::lock; // Prevent opening the file more than once
constexpr auto unread = +open_mode::unread; // Aggressively prevent reading the opened file (do not use)
constexpr auto isfile = +open_mode::isfile; // Ensure valid fs::file handle is not of directory
constexpr auto write_new = write + create + excl;
constexpr auto rewrite = write + create + trunc;
// File seek mode
enum class seek_mode : u32
{
seek_set,
seek_cur,
seek_end,
};
constexpr auto seek_set = seek_mode::seek_set; // From beginning
constexpr auto seek_cur = seek_mode::seek_cur; // From current position
constexpr auto seek_end = seek_mode::seek_end; // From end
// File attributes (TODO)
struct stat_t
{
bool is_directory;
bool is_symlink;
bool is_writable;
u64 size;
s64 atime;
s64 mtime;
s64 ctime;
using enable_bitcopy = std::true_type;
constexpr bool operator==(const stat_t&) const = default;
};
// Helper, layout is equal to iovec struct
struct iovec_clone
{
const void* iov_base;
usz iov_len;
};
struct file_id
{
std::string type;
std::vector<u8> data;
explicit operator bool() const;
bool is_mirror_of(const file_id&) const;
bool is_coherent_with(const file_id&) const;
};
// File handle base
struct file_base
{
virtual ~file_base();
[[noreturn]] virtual stat_t get_stat();
virtual void sync();
virtual bool trunc(u64 length) = 0;
virtual u64 read(void* buffer, u64 size) = 0;
virtual u64 read_at(u64 offset, void* buffer, u64 size) = 0;
virtual u64 write(const void* buffer, u64 size) = 0;
virtual u64 seek(s64 offset, seek_mode whence) = 0;
virtual u64 size() = 0;
virtual native_handle get_handle();
virtual file_id get_id();
virtual u64 write_gather(const iovec_clone* buffers, u64 buf_count);
};
// Directory entry (TODO)
struct dir_entry : stat_t
{
std::string name{};
dir_entry()
: stat_t{}
{
}
using enable_bitcopy = std::false_type;
};
// Directory handle base
struct dir_base
{
virtual ~dir_base();
virtual bool read(dir_entry&) = 0;
virtual void rewind() = 0;
};
// Device information
struct device_stat
{
u64 block_size;
u64 total_size;
u64 total_free; // Total size of free space
u64 avail_free; // Free space available to unprivileged user
};
// Virtual device
struct device_base
{
const std::string fs_prefix;
device_base();
virtual ~device_base();
virtual bool stat(const std::string& path, stat_t& info) = 0;
virtual bool statfs(const std::string& path, device_stat& info) = 0;
virtual bool remove_dir(const std::string& path);
virtual bool create_dir(const std::string& path);
virtual bool create_symlink(const std::string& path);
virtual bool rename(const std::string& from, const std::string& to);
virtual bool remove(const std::string& path);
virtual bool trunc(const std::string& path, u64 length);
virtual bool utime(const std::string& path, s64 atime, s64 mtime);
virtual std::unique_ptr<file_base> open(const std::string& path, bs_t<open_mode> mode) = 0;
virtual std::unique_ptr<dir_base> open_dir(const std::string& path) = 0;
};
[[noreturn]] void xnull(std::source_location);
[[noreturn]] void xfail(std::source_location);
[[noreturn]] void xovfl();
constexpr struct pod_tag_t{} pod_tag;
// Get virtual device for specified path (nullptr for real path)
shared_ptr<device_base> get_virtual_device(const std::string& path);
// Set virtual device with specified name (nullptr for deletion)
shared_ptr<device_base> set_virtual_device(const std::string& name, shared_ptr<device_base> device);
// Try to get parent directory
std::string_view get_parent_dir_view(std::string_view path, u32 parent_level = 1);
// String (typical use) version
inline std::string get_parent_dir(std::string_view path, u32 parent_level = 1)
{
return std::string{get_parent_dir_view(path, parent_level)};
}
// Get file information
bool get_stat(const std::string& path, stat_t& info);
// Check whether a file or a directory exists (not recommended, use is_file() or is_dir() instead)
bool exists(const std::string& path);
// Check whether the file exists and is NOT a directory
bool is_file(const std::string& path);
// Check whether the directory exists and is NOT a file
bool is_dir(const std::string& path);
// Check whether the path points to an existing symlink
bool is_symlink(const std::string& path);
// Get filesystem information
bool statfs(const std::string& path, device_stat& info);
// Delete empty directory
bool remove_dir(const std::string& path);
// Create directory
bool create_dir(const std::string& path);
// Create directories
bool create_path(const std::string& path);
// Create symbolic link
bool create_symlink(const std::string& path, const std::string& target);
// Rename (move) file or directory
bool rename(const std::string& from, const std::string& to, bool overwrite);
// Copy file contents
bool copy_file(const std::string& from, const std::string& to, bool overwrite);
// Delete file
bool remove_file(const std::string& path);
// Change file size (possibly appending zeros)
bool truncate_file(const std::string& path, u64 length);
// Set file access/modification time
bool utime(const std::string& path, s64 atime, s64 mtime);
// Synchronize filesystems (TODO)
void sync();
class file final
{
std::unique_ptr<file_base> m_file{};
public:
// Default constructor
file() = default;
// Open file with specified mode
explicit file(const std::string& path, bs_t<open_mode> mode = ::fs::read);
// Open memory for read
explicit file(const void* ptr, usz size);
// Open file with specified args (forward to constructor)
template <typename... Args>
bool open(Args&&... args)
{
m_file.reset();
*this = fs::file(std::forward<Args>(args)...);
return m_file.operator bool();
}
// Check whether the handle is valid (opened file)
explicit operator bool() const
{
return m_file.operator bool();
}
// Close the file explicitly
void close()
{
m_file.reset();
}
void reset(std::unique_ptr<file_base>&& ptr)
{
m_file = std::move(ptr);
}
std::unique_ptr<file_base> release()
{
return std::move(m_file);
}
// Change file size (possibly appending zero bytes)
bool trunc(u64 length, std::source_location src_loc = std::source_location::current()) const
{
if (!m_file) xnull(src_loc);
return m_file->trunc(length);
}
// Get file information
stat_t get_stat(std::source_location src_loc = std::source_location::current()) const
{
if (!m_file) xnull(src_loc);
return m_file->get_stat();
}
// Sync file buffers
void sync(std::source_location src_loc = std::source_location::current()) const
{
if (!m_file) xnull(src_loc);
return m_file->sync();
}
// Check if the handle is capable of reading (size * type_size) of bytes at the time of calling
bool strict_read_check(u64 offset, u64 size, u64 type_size) const;
// Read the data from the file and return the amount of data written in buffer
u64 read(void* buffer, u64 count, std::source_location src_loc = std::source_location::current()) const
{
if (!m_file) xnull(src_loc);
return m_file->read(buffer, count);
}
// Read the data from the file at specified offset in thread-safe manner
u64 read_at(u64 offset, void* buffer, u64 count, std::source_location src_loc = std::source_location::current()) const
{
if (!m_file) xnull(src_loc);
return m_file->read_at(offset, buffer, count);
}
// Write the data to the file and return the amount of data actually written
u64 write(const void* buffer, u64 count, std::source_location src_loc = std::source_location::current()) const
{
if (!m_file) xnull(src_loc);
return m_file->write(buffer, count);
}
// Change current position, returns resulting position
u64 seek(s64 offset, seek_mode whence = seek_set, std::source_location src_loc = std::source_location::current()) const
{
if (!m_file) xnull(src_loc);
return m_file->seek(offset, whence);
}
// Get file size
u64 size(std::source_location src_loc = std::source_location::current()) const
{
if (!m_file) xnull(src_loc);
return m_file->size();
}
// Get current position
u64 pos(std::source_location src_loc = std::source_location::current()) const
{
if (!m_file) xnull(src_loc);
return m_file->seek(0, seek_cur);
}
// Write std::basic_string unconditionally
template <typename T> requires (std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>)
const file& write(const std::basic_string<T>& str, std::source_location src_loc = std::source_location::current()) const
{
if (write(str.data(), str.size() * sizeof(T), src_loc) != str.size() * sizeof(T)) xfail(src_loc);
return *this;
}
// Write POD unconditionally
template <typename T> requires (std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>)
const file& write(const T& data, std::source_location src_loc = std::source_location::current()) const
{
if (write(std::addressof(data), sizeof(T), src_loc) != sizeof(T)) xfail(src_loc);
return *this;
}
// Write POD std::vector unconditionally
template <typename T> requires (std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>)
const file& write(const std::vector<T>& vec, std::source_location src_loc = std::source_location::current()) const
{
if (write(vec.data(), vec.size() * sizeof(T), src_loc) != vec.size() * sizeof(T)) xfail(src_loc);
return *this;
}
// Read std::basic_string
template <typename T> requires (std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>)
bool read(std::basic_string<T>& str, usz _size = umax, std::source_location src_loc = std::source_location::current()) const
{
if (!m_file) xnull(src_loc);
if (_size != umax)
{
// If _size arg is too high std::bad_alloc may happen during resize and then we cannot error check
if ((_size >= 0x10'0000 / sizeof(T)) && !strict_read_check(pos(), _size, sizeof(T)))
{
return false;
}
str.resize(_size);
}
return read(str.data(), sizeof(T) * str.size(), src_loc) == sizeof(T) * str.size();
}
// Read POD, sizeof(T) is used
template <typename T> requires (std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>)
bool read(T& data,
pod_tag_t = pod_tag, std::source_location src_loc = std::source_location::current()) const
{
return read(std::addressof(data), sizeof(T), src_loc) == sizeof(T);
}
// Read POD std::vector
template <typename T> requires (std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>)
bool read(std::vector<T>& vec, usz _size = umax, bool use_offs = false, usz offset = umax, std::source_location src_loc = std::source_location::current()) const
{
if (!m_file) xnull(src_loc);
if (_size != umax)
{
// If _size arg is too high std::bad_alloc may happen during resize and then we cannot error check
if ((_size >= 0x10'0000 / sizeof(T)) && !strict_read_check(use_offs ? offset : pos(), _size, sizeof(T)))
{
return false;
}
vec.resize(_size);
}
if (use_offs)
{
return read_at(offset, vec.data(), sizeof(T) * vec.size(), src_loc) == sizeof(T) * vec.size();
}
return read(vec.data(), sizeof(T) * vec.size(), src_loc) == sizeof(T) * vec.size();
}
// Read POD (experimental)
template <typename T> requires (std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>)
T read(pod_tag_t = pod_tag, std::source_location src_loc = std::source_location::current()) const
{
T result;
if (!read(result, pod_tag, src_loc)) xfail(src_loc);
return result;
}
// Read full file to std::basic_string
template <typename T = char>
std::basic_string<T> to_string(std::source_location src_loc = std::source_location::current()) const
{
std::basic_string<T> result;
result.resize(size() / sizeof(T));
seek(0);
if (!read(result, result.size(), src_loc)) xfail(src_loc);
return result;
}
// Read full file to std::vector
template<typename T> requires (std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>)
std::vector<T> to_vector(std::source_location src_loc = std::source_location::current()) const
{
std::vector<T> result;
result.resize(size() / sizeof(T));
if (!read(result, result.size(), true, 0, src_loc)) xfail(src_loc);
return result;
}
// Get native handle if available
native_handle get_handle() const;
// Get file ID information (custom ID)
file_id get_id() const;
// Gathered write
u64 write_gather(const iovec_clone* buffers, u64 buf_count, std::source_location src_loc = std::source_location::current()) const
{
if (!m_file) xnull(src_loc);
return m_file->write_gather(buffers, buf_count);
}
};
class dir final
{
std::unique_ptr<dir_base> m_dir{};
public:
dir() = default;
// Open dir handle
explicit dir(const std::string& path)
{
open(path);
}
// Open specified directory
bool open(const std::string& path);
// Check whether the handle is valid (opened directory)
explicit operator bool() const
{
return m_dir.operator bool();
}
// Close the directory explicitly
void close()
{
m_dir.reset();
}
void reset(std::unique_ptr<dir_base>&& ptr)
{
m_dir = std::move(ptr);
}
std::unique_ptr<dir_base> release()
{
return std::move(m_dir);
}
// Get next directory entry
bool read(dir_entry& out, std::source_location src_loc = std::source_location::current()) const
{
if (!m_dir) xnull(src_loc);
return m_dir->read(out);
}
// Reset to the beginning
void rewind(std::source_location src_loc = std::source_location::current()) const
{
if (!m_dir) xnull(src_loc);
return m_dir->rewind();
}
class iterator
{
const dir* m_parent;
dir_entry m_entry{};
public:
enum class mode
{
from_first,
from_current
};
iterator(const dir* parent, mode mode_ = mode::from_first)
: m_parent(parent)
{
if (!m_parent)
{
return;
}
if (mode_ == mode::from_first)
{
m_parent->rewind();
}
if (!m_parent->read(m_entry))
{
m_parent = nullptr;
}
}
iterator(const iterator&) = default;
iterator(iterator&&) = default;
iterator& operator=(const iterator&) = default;
iterator& operator=(iterator&&) = default;
dir_entry& operator *()
{
return m_entry;
}
iterator& operator++()
{
*this = {m_parent, mode::from_current};
return *this;
}
bool operator !=(const iterator& rhs) const
{
return m_parent != rhs.m_parent;
}
};
iterator begin() const
{
return {m_dir ? this : nullptr};
}
iterator end() const
{
return {nullptr};
}
};
// Get executable path
std::string get_executable_path();
// Get executable containing directory
std::string get_executable_dir();
// Get configuration directory
const std::string& get_config_dir();
// Get common cache directory
const std::string& get_cache_dir();
// Temporary directory
const std::string& get_temp_dir();
std::string generate_neighboring_path(std::string_view source, u64 seed);
// Unique pending file creation destined to be renamed to the destination file
struct pending_file
{
fs::file file{};
// This is meant to modify files atomically, overwriting is likely
bool commit(bool overwrite = true);
bool open(std::string_view path);
pending_file() noexcept = default;
pending_file(std::string_view path) noexcept
{
open(path);
}
pending_file(const pending_file&) = delete;
pending_file& operator=(const pending_file&) = delete;
~pending_file();
const std::string& get_temp_path() const
{
return m_path;
}
private:
std::string m_path{}; // Pending file path
std::string m_dest{}; // Destination file path
};
// Delete directory and all its contents recursively
bool remove_all(const std::string& path, bool remove_root = true, bool is_no_dir_ok = false);
// Get size of all files recursively
u64 get_dir_size(const std::string& path, u64 rounding_alignment = 1, atomic_t<bool>* cancel_flag = nullptr);
enum class error : uint
{
ok = 0,
inval,
noent,
exist,
acces,
notempty,
readonly,
isdir,
toolong,
nospace,
xdev,
unknown
};
// Error code returned
extern thread_local error g_tls_error;
template <typename T>
struct container_stream final : file_base
{
// T can be a reference, but this is not recommended
using value_type = typename std::remove_reference_t<T>::value_type;
T obj;
u64 pos;
container_stream(T&& obj, const stat_t& init_stat = {})
: obj(std::forward<T>(obj))
, pos(0)
, m_stat(init_stat)
{
}
~container_stream() override
{
}
bool trunc(u64 length) override
{
obj.resize(length);
update_time(true);
return true;
}
u64 read(void* buffer, u64 size) override
{
const u64 end = obj.size();
if (pos < end)
{
// Get readable size
if (const u64 max = std::min<u64>(size, end - pos))
{
std::copy(obj.cbegin() + pos, obj.cbegin() + pos + max, static_cast<value_type*>(buffer));
pos = pos + max;
update_time();
return max;
}
}
return 0;
}
u64 read_at(u64 offset, void* buffer, u64 size) override
{
const u64 end = obj.size();
if (offset < end)
{
// Get readable size
if (const u64 max = std::min<u64>(size, end - offset))
{
std::copy(obj.cbegin() + offset, obj.cbegin() + offset + max, static_cast<value_type*>(buffer));
update_time();
return max;
}
}
return 0;
}
u64 write(const void* buffer, u64 size) override
{
const u64 old_size = obj.size();
if (old_size + size < old_size || pos + size < pos)
{
xovfl();
}
if (pos > old_size)
{
// Reserve memory
obj.reserve(pos + size);
// Fill gap if necessary (default-initialized)
obj.resize(pos);
}
const auto src = static_cast<const value_type*>(buffer);
// Overwrite existing part
const u64 overlap = std::min<u64>(obj.size() - pos, size);
std::copy(src, src + overlap, obj.begin() + pos);
// Append new data
obj.insert(obj.end(), src + overlap, src + size);
pos += size;
if (size) update_time(true);
return size;
}
u64 seek(s64 offset, seek_mode whence) override
{
const s64 new_pos =
whence == fs::seek_set ? offset :
whence == fs::seek_cur ? offset + pos :
whence == fs::seek_end ? offset + size() : -1;
if (new_pos < 0)
{
fs::g_tls_error = fs::error::inval;
return -1;
}
pos = new_pos;
return pos;
}
u64 size() override
{
return obj.size();
}
stat_t get_stat() override
{
return m_stat;
}
private:
stat_t m_stat{};
void update_time(bool write = false)
{
// TODO: Accurate timestamps
m_stat.atime++;
if (write)
{
m_stat.mtime++;
m_stat.mtime = std::max(m_stat.atime, m_stat.mtime);
m_stat.ctime = m_stat.mtime;
}
}
};
template <typename T>
file make_stream(T&& container = T{}, const stat_t& stat = stat_t{})
{
file result;
result.reset(std::make_unique<container_stream<T>>(std::forward<T>(container), stat));
return result;
}
template <bool Flush = false, typename... Args>
bool write_file(const std::string& path, bs_t<fs::open_mode> mode, const Args&... args)
{
// Always use write flag, remove read flag
if (fs::file f{path, mode + fs::write - fs::read})
{
if constexpr (sizeof...(args) == 2u && (std::is_pointer_v<Args> || ...))
{
// Specialization for [const void*, usz] args
f.write(args...);
}
else
{
// Write args sequentially
(f.write(args), ...);
}
if constexpr (Flush)
{
f.sync();
}
return true;
}
return false;
}
file make_gather(std::vector<file>);
stx::generator<dir_entry&> list_dir_recursively(const std::string& path);
}
| 21,068
|
C++
|
.h
| 678
| 27.668142
| 162
| 0.67405
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,290
|
fsr_ffx_fsr1_flattened.inc
|
RPCS3_rpcs3/rpcs3/Emu/RSX/Program/Upscalers/FSR1/fsr_ffx_fsr1_flattened.inc
|
// Proprocessed version of ffx_a.h from FSR package
// For original source, see 3rdParty/GPUOpen/Include/ffx_fsr1.h
// Modifications are required to meet MSVC's strict limitations on string length. No single string literal (concatenated or otherwise) can exceed 64K
// * Removed CPU section as we do not need it
// * Stripped all comment-only lines, the original source is still readable for this purpose
// * Stripped all unnecessary whitespace
R"--RPCS3--(
#if defined(A_GPU)&&defined(FSR_EASU_F)
AF4 FsrEasuRF(AF2 p);
AF4 FsrEasuGF(AF2 p);
AF4 FsrEasuBF(AF2 p);
void FsrEasuTapF(
inout AF3 aC, // Accumulated color, with negative lobe.
inout AF1 aW, // Accumulated weight.
AF2 off, // Pixel offset from resolve position to tap.
AF2 dir, // Gradient direction.
AF2 len, // Length.
AF1 lob, // Negative lobe strength.
AF1 clp, // Clipping point.
AF3 c){ // Tap color.
AF2 v;
v.x=(off.x*( dir.x))+(off.y*dir.y);
v.y=(off.x*(-dir.y))+(off.y*dir.x);
v*=len;
AF1 d2=v.x*v.x+v.y*v.y;
d2=min(d2,clp);
AF1 wB=AF1_(2.0/5.0)*d2+AF1_(-1.0);
AF1 wA=lob*d2+AF1_(-1.0);
wB*=wB;
wA*=wA;
wB=AF1_(25.0/16.0)*wB+AF1_(-(25.0/16.0-1.0));
AF1 w=wB*wA;
aC+=c*w;aW+=w;}
void FsrEasuSetF(
inout AF2 dir,
inout AF1 len,
AF2 pp,
AP1 biS,AP1 biT,AP1 biU,AP1 biV,
AF1 lA,AF1 lB,AF1 lC,AF1 lD,AF1 lE){
AF1 w = AF1_(0.0);
if(biS)w=(AF1_(1.0)-pp.x)*(AF1_(1.0)-pp.y);
if(biT)w= pp.x *(AF1_(1.0)-pp.y);
if(biU)w=(AF1_(1.0)-pp.x)* pp.y ;
if(biV)w= pp.x * pp.y ;
AF1 dc=lD-lC;
AF1 cb=lC-lB;
AF1 lenX=max(abs(dc),abs(cb));
lenX=APrxLoRcpF1(lenX);
AF1 dirX=lD-lB;
dir.x+=dirX*w;
lenX=ASatF1(abs(dirX)*lenX);
lenX*=lenX;
len+=lenX*w;
AF1 ec=lE-lC;
AF1 ca=lC-lA;
AF1 lenY=max(abs(ec),abs(ca));
lenY=APrxLoRcpF1(lenY);
AF1 dirY=lE-lA;
dir.y+=dirY*w;
lenY=ASatF1(abs(dirY)*lenY);
lenY*=lenY;
len+=lenY*w;}
void FsrEasuF(
out AF3 pix,
AU2 ip, // Integer pixel position in output.
AU4 con0, // Constants generated by FsrEasuCon().
AU4 con1,
AU4 con2,
AU4 con3){
AF2 pp=AF2(ip)*AF2_AU2(con0.xy)+AF2_AU2(con0.zw);
AF2 fp=floor(pp);
pp-=fp;
AF2 p0=fp*AF2_AU2(con1.xy)+AF2_AU2(con1.zw);
AF2 p1=p0+AF2_AU2(con2.xy);
AF2 p2=p0+AF2_AU2(con2.zw);
AF2 p3=p0+AF2_AU2(con3.xy);
AF4 bczzR=FsrEasuRF(p0);
AF4 bczzG=FsrEasuGF(p0);
AF4 bczzB=FsrEasuBF(p0);
AF4 ijfeR=FsrEasuRF(p1);
AF4 ijfeG=FsrEasuGF(p1);
AF4 ijfeB=FsrEasuBF(p1);
AF4 klhgR=FsrEasuRF(p2);
AF4 klhgG=FsrEasuGF(p2);
AF4 klhgB=FsrEasuBF(p2);
AF4 zzonR=FsrEasuRF(p3);
AF4 zzonG=FsrEasuGF(p3);
AF4 zzonB=FsrEasuBF(p3);
AF4 bczzL=bczzB*AF4_(0.5)+(bczzR*AF4_(0.5)+bczzG);
AF4 ijfeL=ijfeB*AF4_(0.5)+(ijfeR*AF4_(0.5)+ijfeG);
AF4 klhgL=klhgB*AF4_(0.5)+(klhgR*AF4_(0.5)+klhgG);
AF4 zzonL=zzonB*AF4_(0.5)+(zzonR*AF4_(0.5)+zzonG);
AF1 bL=bczzL.x;
AF1 cL=bczzL.y;
AF1 iL=ijfeL.x;
AF1 jL=ijfeL.y;
AF1 fL=ijfeL.z;
AF1 eL=ijfeL.w;
AF1 kL=klhgL.x;
AF1 lL=klhgL.y;
AF1 hL=klhgL.z;
AF1 gL=klhgL.w;
AF1 oL=zzonL.z;
AF1 nL=zzonL.w;
AF2 dir=AF2_(0.0);
AF1 len=AF1_(0.0);
FsrEasuSetF(dir,len,pp,true, false,false,false,bL,eL,fL,gL,jL);
FsrEasuSetF(dir,len,pp,false,true ,false,false,cL,fL,gL,hL,kL);
FsrEasuSetF(dir,len,pp,false,false,true ,false,fL,iL,jL,kL,nL);
FsrEasuSetF(dir,len,pp,false,false,false,true ,gL,jL,kL,lL,oL);
AF2 dir2=dir*dir;
AF1 dirR=dir2.x+dir2.y;
AP1 zro=dirR<AF1_(1.0/32768.0);
dirR=APrxLoRsqF1(dirR);
dirR=zro?AF1_(1.0):dirR;
dir.x=zro?AF1_(1.0):dir.x;
dir*=AF2_(dirR);
len=len*AF1_(0.5);
len*=len;
AF1 stretch=(dir.x*dir.x+dir.y*dir.y)*APrxLoRcpF1(max(abs(dir.x),abs(dir.y)));
AF2 len2=AF2(AF1_(1.0)+(stretch-AF1_(1.0))*len,AF1_(1.0)+AF1_(-0.5)*len);
AF1 lob=AF1_(0.5)+AF1_((1.0/4.0-0.04)-0.5)*len;
AF1 clp=APrxLoRcpF1(lob);
AF3 min4=min(AMin3F3(AF3(ijfeR.z,ijfeG.z,ijfeB.z),AF3(klhgR.w,klhgG.w,klhgB.w),AF3(ijfeR.y,ijfeG.y,ijfeB.y)),
AF3(klhgR.x,klhgG.x,klhgB.x));
AF3 max4=max(AMax3F3(AF3(ijfeR.z,ijfeG.z,ijfeB.z),AF3(klhgR.w,klhgG.w,klhgB.w),AF3(ijfeR.y,ijfeG.y,ijfeB.y)),
AF3(klhgR.x,klhgG.x,klhgB.x));
AF3 aC=AF3_(0.0);
AF1 aW=AF1_(0.0);
FsrEasuTapF(aC,aW,AF2( 0.0,-1.0)-pp,dir,len2,lob,clp,AF3(bczzR.x,bczzG.x,bczzB.x)); // b
FsrEasuTapF(aC,aW,AF2( 1.0,-1.0)-pp,dir,len2,lob,clp,AF3(bczzR.y,bczzG.y,bczzB.y)); // c
FsrEasuTapF(aC,aW,AF2(-1.0, 1.0)-pp,dir,len2,lob,clp,AF3(ijfeR.x,ijfeG.x,ijfeB.x)); // i
FsrEasuTapF(aC,aW,AF2( 0.0, 1.0)-pp,dir,len2,lob,clp,AF3(ijfeR.y,ijfeG.y,ijfeB.y)); // j
FsrEasuTapF(aC,aW,AF2( 0.0, 0.0)-pp,dir,len2,lob,clp,AF3(ijfeR.z,ijfeG.z,ijfeB.z)); // f
FsrEasuTapF(aC,aW,AF2(-1.0, 0.0)-pp,dir,len2,lob,clp,AF3(ijfeR.w,ijfeG.w,ijfeB.w)); // e
FsrEasuTapF(aC,aW,AF2( 1.0, 1.0)-pp,dir,len2,lob,clp,AF3(klhgR.x,klhgG.x,klhgB.x)); // k
FsrEasuTapF(aC,aW,AF2( 2.0, 1.0)-pp,dir,len2,lob,clp,AF3(klhgR.y,klhgG.y,klhgB.y)); // l
FsrEasuTapF(aC,aW,AF2( 2.0, 0.0)-pp,dir,len2,lob,clp,AF3(klhgR.z,klhgG.z,klhgB.z)); // h
FsrEasuTapF(aC,aW,AF2( 1.0, 0.0)-pp,dir,len2,lob,clp,AF3(klhgR.w,klhgG.w,klhgB.w)); // g
FsrEasuTapF(aC,aW,AF2( 1.0, 2.0)-pp,dir,len2,lob,clp,AF3(zzonR.z,zzonG.z,zzonB.z)); // o
FsrEasuTapF(aC,aW,AF2( 0.0, 2.0)-pp,dir,len2,lob,clp,AF3(zzonR.w,zzonG.w,zzonB.w)); // n
pix=min(max4,max(min4,aC*AF3_(ARcpF1(aW))));}
#endif
#if defined(A_GPU)&&defined(A_HALF)&&defined(FSR_EASU_H)
AH4 FsrEasuRH(AF2 p);
AH4 FsrEasuGH(AF2 p);
AH4 FsrEasuBH(AF2 p);
void FsrEasuTapH(
inout AH2 aCR,inout AH2 aCG,inout AH2 aCB,
inout AH2 aW,
AH2 offX,AH2 offY,
AH2 dir,
AH2 len,
AH1 lob,
AH1 clp,
AH2 cR,AH2 cG,AH2 cB){
AH2 vX,vY;
vX=offX* dir.xx +offY*dir.yy;
vY=offX*(-dir.yy)+offY*dir.xx;
vX*=len.x;vY*=len.y;
AH2 d2=vX*vX+vY*vY;
d2=min(d2,AH2_(clp));
AH2 wB=AH2_(2.0/5.0)*d2+AH2_(-1.0);
AH2 wA=AH2_(lob)*d2+AH2_(-1.0);
wB*=wB;
wA*=wA;
wB=AH2_(25.0/16.0)*wB+AH2_(-(25.0/16.0-1.0));
AH2 w=wB*wA;
aCR+=cR*w;aCG+=cG*w;aCB+=cB*w;aW+=w;}
void FsrEasuSetH(
inout AH2 dirPX,inout AH2 dirPY,
inout AH2 lenP,
AH2 pp,
AP1 biST,AP1 biUV,
AH2 lA,AH2 lB,AH2 lC,AH2 lD,AH2 lE){
AH2 w = AH2_(0.0);
if(biST)w=(AH2(1.0,0.0)+AH2(-pp.x,pp.x))*AH2_(AH1_(1.0)-pp.y);
if(biUV)w=(AH2(1.0,0.0)+AH2(-pp.x,pp.x))*AH2_( pp.y);
AH2 dc=lD-lC;
AH2 cb=lC-lB;
AH2 lenX=max(abs(dc),abs(cb));
lenX=ARcpH2(lenX);
AH2 dirX=lD-lB;
dirPX+=dirX*w;
lenX=ASatH2(abs(dirX)*lenX);
lenX*=lenX;
lenP+=lenX*w;
AH2 ec=lE-lC;
AH2 ca=lC-lA;
AH2 lenY=max(abs(ec),abs(ca));
lenY=ARcpH2(lenY);
AH2 dirY=lE-lA;
dirPY+=dirY*w;
lenY=ASatH2(abs(dirY)*lenY);
lenY*=lenY;
lenP+=lenY*w;}
void FsrEasuH(
out AH3 pix,
AU2 ip,
AU4 con0,
AU4 con1,
AU4 con2,
AU4 con3){
AF2 pp=AF2(ip)*AF2_AU2(con0.xy)+AF2_AU2(con0.zw);
AF2 fp=floor(pp);
pp-=fp;
AH2 ppp=AH2(pp);
AF2 p0=fp*AF2_AU2(con1.xy)+AF2_AU2(con1.zw);
AF2 p1=p0+AF2_AU2(con2.xy);
AF2 p2=p0+AF2_AU2(con2.zw);
AF2 p3=p0+AF2_AU2(con3.xy);
AH4 bczzR=FsrEasuRH(p0);
AH4 bczzG=FsrEasuGH(p0);
AH4 bczzB=FsrEasuBH(p0);
AH4 ijfeR=FsrEasuRH(p1);
AH4 ijfeG=FsrEasuGH(p1);
AH4 ijfeB=FsrEasuBH(p1);
AH4 klhgR=FsrEasuRH(p2);
AH4 klhgG=FsrEasuGH(p2);
AH4 klhgB=FsrEasuBH(p2);
AH4 zzonR=FsrEasuRH(p3);
AH4 zzonG=FsrEasuGH(p3);
AH4 zzonB=FsrEasuBH(p3);
AH4 bczzL=bczzB*AH4_(0.5)+(bczzR*AH4_(0.5)+bczzG);
AH4 ijfeL=ijfeB*AH4_(0.5)+(ijfeR*AH4_(0.5)+ijfeG);
AH4 klhgL=klhgB*AH4_(0.5)+(klhgR*AH4_(0.5)+klhgG);
AH4 zzonL=zzonB*AH4_(0.5)+(zzonR*AH4_(0.5)+zzonG);
AH1 bL=bczzL.x;
AH1 cL=bczzL.y;
AH1 iL=ijfeL.x;
AH1 jL=ijfeL.y;
AH1 fL=ijfeL.z;
AH1 eL=ijfeL.w;
AH1 kL=klhgL.x;
AH1 lL=klhgL.y;
AH1 hL=klhgL.z;
AH1 gL=klhgL.w;
AH1 oL=zzonL.z;
AH1 nL=zzonL.w;
AH2 dirPX=AH2_(0.0);
AH2 dirPY=AH2_(0.0);
AH2 lenP=AH2_(0.0);
FsrEasuSetH(dirPX,dirPY,lenP,ppp,true, false,AH2(bL,cL),AH2(eL,fL),AH2(fL,gL),AH2(gL,hL),AH2(jL,kL));
FsrEasuSetH(dirPX,dirPY,lenP,ppp,false,true ,AH2(fL,gL),AH2(iL,jL),AH2(jL,kL),AH2(kL,lL),AH2(nL,oL));
AH2 dir=AH2(dirPX.r+dirPX.g,dirPY.r+dirPY.g);
AH1 len=lenP.r+lenP.g;
AH2 dir2=dir*dir;
AH1 dirR=dir2.x+dir2.y;
AP1 zro=dirR<AH1_(1.0/32768.0);
dirR=APrxLoRsqH1(dirR);
dirR=zro?AH1_(1.0):dirR;
dir.x=zro?AH1_(1.0):dir.x;
dir*=AH2_(dirR);
len=len*AH1_(0.5);
len*=len;
AH1 stretch=(dir.x*dir.x+dir.y*dir.y)*APrxLoRcpH1(max(abs(dir.x),abs(dir.y)));
AH2 len2=AH2(AH1_(1.0)+(stretch-AH1_(1.0))*len,AH1_(1.0)+AH1_(-0.5)*len);
AH1 lob=AH1_(0.5)+AH1_((1.0/4.0-0.04)-0.5)*len;
AH1 clp=APrxLoRcpH1(lob);
AH2 bothR=max(max(AH2(-ijfeR.z,ijfeR.z),AH2(-klhgR.w,klhgR.w)),max(AH2(-ijfeR.y,ijfeR.y),AH2(-klhgR.x,klhgR.x)));
AH2 bothG=max(max(AH2(-ijfeG.z,ijfeG.z),AH2(-klhgG.w,klhgG.w)),max(AH2(-ijfeG.y,ijfeG.y),AH2(-klhgG.x,klhgG.x)));
AH2 bothB=max(max(AH2(-ijfeB.z,ijfeB.z),AH2(-klhgB.w,klhgB.w)),max(AH2(-ijfeB.y,ijfeB.y),AH2(-klhgB.x,klhgB.x)));
AH2 pR=AH2_(0.0);
AH2 pG=AH2_(0.0);
AH2 pB=AH2_(0.0);
AH2 pW=AH2_(0.0);
FsrEasuTapH(pR,pG,pB,pW,AH2( 0.0, 1.0)-ppp.xx,AH2(-1.0,-1.0)-ppp.yy,dir,len2,lob,clp,bczzR.xy,bczzG.xy,bczzB.xy);
FsrEasuTapH(pR,pG,pB,pW,AH2(-1.0, 0.0)-ppp.xx,AH2( 1.0, 1.0)-ppp.yy,dir,len2,lob,clp,ijfeR.xy,ijfeG.xy,ijfeB.xy);
FsrEasuTapH(pR,pG,pB,pW,AH2( 0.0,-1.0)-ppp.xx,AH2( 0.0, 0.0)-ppp.yy,dir,len2,lob,clp,ijfeR.zw,ijfeG.zw,ijfeB.zw);
FsrEasuTapH(pR,pG,pB,pW,AH2( 1.0, 2.0)-ppp.xx,AH2( 1.0, 1.0)-ppp.yy,dir,len2,lob,clp,klhgR.xy,klhgG.xy,klhgB.xy);
FsrEasuTapH(pR,pG,pB,pW,AH2( 2.0, 1.0)-ppp.xx,AH2( 0.0, 0.0)-ppp.yy,dir,len2,lob,clp,klhgR.zw,klhgG.zw,klhgB.zw);
FsrEasuTapH(pR,pG,pB,pW,AH2( 1.0, 0.0)-ppp.xx,AH2( 2.0, 2.0)-ppp.yy,dir,len2,lob,clp,zzonR.zw,zzonG.zw,zzonB.zw);
AH3 aC=AH3(pR.x+pR.y,pG.x+pG.y,pB.x+pB.y);
AH1 aW=pW.x+pW.y;
pix=min(AH3(bothR.y,bothG.y,bothB.y),max(-AH3(bothR.x,bothG.x,bothB.x),aC*AH3_(ARcpH1(aW))));}
#endif
#define FSR_RCAS_LIMIT (0.25-(1.0/16.0))
A_STATIC void FsrRcasCon(
outAU4 con,
AF1 sharpness){
sharpness=AExp2F1(-sharpness);
varAF2(hSharp)=initAF2(sharpness,sharpness);
con[0]=AU1_AF1(sharpness);
con[1]=AU1_AH2_AF2(hSharp);
con[2]=0;
con[3]=0;}
#if defined(A_GPU)&&defined(FSR_RCAS_F)
AF4 FsrRcasLoadF(ASU2 p);
void FsrRcasInputF(inout AF1 r,inout AF1 g,inout AF1 b);
void FsrRcasF(
out AF1 pixR, // Output values, non-vector so port between RcasFilter() and RcasFilterH() is easy.
out AF1 pixG,
out AF1 pixB,
#ifdef FSR_RCAS_PASSTHROUGH_ALPHA
out AF1 pixA,
#endif
AU2 ip, // Integer pixel position in output.
AU4 con){ // Constant generated by RcasSetup().
ASU2 sp=ASU2(ip);
AF3 b=FsrRcasLoadF(sp+ASU2( 0,-1)).rgb;
AF3 d=FsrRcasLoadF(sp+ASU2(-1, 0)).rgb;
#ifdef FSR_RCAS_PASSTHROUGH_ALPHA
AF4 ee=FsrRcasLoadF(sp);
AF3 e=ee.rgb;pixA=ee.a;
#else
AF3 e=FsrRcasLoadF(sp).rgb;
#endif
)--RPCS3--"
R"--RPCS3--(
AF3 f=FsrRcasLoadF(sp+ASU2( 1, 0)).rgb;
AF3 h=FsrRcasLoadF(sp+ASU2( 0, 1)).rgb;
AF1 bR=b.r;
AF1 bG=b.g;
AF1 bB=b.b;
AF1 dR=d.r;
AF1 dG=d.g;
AF1 dB=d.b;
AF1 eR=e.r;
AF1 eG=e.g;
AF1 eB=e.b;
AF1 fR=f.r;
AF1 fG=f.g;
AF1 fB=f.b;
AF1 hR=h.r;
AF1 hG=h.g;
AF1 hB=h.b;
FsrRcasInputF(bR,bG,bB);
FsrRcasInputF(dR,dG,dB);
FsrRcasInputF(eR,eG,eB);
FsrRcasInputF(fR,fG,fB);
FsrRcasInputF(hR,hG,hB);
AF1 bL=bB*AF1_(0.5)+(bR*AF1_(0.5)+bG);
AF1 dL=dB*AF1_(0.5)+(dR*AF1_(0.5)+dG);
AF1 eL=eB*AF1_(0.5)+(eR*AF1_(0.5)+eG);
AF1 fL=fB*AF1_(0.5)+(fR*AF1_(0.5)+fG);
AF1 hL=hB*AF1_(0.5)+(hR*AF1_(0.5)+hG);
AF1 nz=AF1_(0.25)*bL+AF1_(0.25)*dL+AF1_(0.25)*fL+AF1_(0.25)*hL-eL;
nz=ASatF1(abs(nz)*APrxMedRcpF1(AMax3F1(AMax3F1(bL,dL,eL),fL,hL)-AMin3F1(AMin3F1(bL,dL,eL),fL,hL)));
nz=AF1_(-0.5)*nz+AF1_(1.0);
AF1 mn4R=min(AMin3F1(bR,dR,fR),hR);
AF1 mn4G=min(AMin3F1(bG,dG,fG),hG);
AF1 mn4B=min(AMin3F1(bB,dB,fB),hB);
AF1 mx4R=max(AMax3F1(bR,dR,fR),hR);
AF1 mx4G=max(AMax3F1(bG,dG,fG),hG);
AF1 mx4B=max(AMax3F1(bB,dB,fB),hB);
AF2 peakC=AF2(1.0,-1.0*4.0);
AF1 hitMinR=mn4R*ARcpF1(AF1_(4.0)*mx4R);
AF1 hitMinG=mn4G*ARcpF1(AF1_(4.0)*mx4G);
AF1 hitMinB=mn4B*ARcpF1(AF1_(4.0)*mx4B);
AF1 hitMaxR=(peakC.x-mx4R)*ARcpF1(AF1_(4.0)*mn4R+peakC.y);
AF1 hitMaxG=(peakC.x-mx4G)*ARcpF1(AF1_(4.0)*mn4G+peakC.y);
AF1 hitMaxB=(peakC.x-mx4B)*ARcpF1(AF1_(4.0)*mn4B+peakC.y);
AF1 lobeR=max(-hitMinR,hitMaxR);
AF1 lobeG=max(-hitMinG,hitMaxG);
AF1 lobeB=max(-hitMinB,hitMaxB);
AF1 lobe=max(AF1_(-FSR_RCAS_LIMIT),min(AMax3F1(lobeR,lobeG,lobeB),AF1_(0.0)))*AF1_AU1(con.x);
#ifdef FSR_RCAS_DENOISE
lobe*=nz;
#endif
AF1 rcpL=APrxMedRcpF1(AF1_(4.0)*lobe+AF1_(1.0));
pixR=(lobe*bR+lobe*dR+lobe*hR+lobe*fR+eR)*rcpL;
pixG=(lobe*bG+lobe*dG+lobe*hG+lobe*fG+eG)*rcpL;
pixB=(lobe*bB+lobe*dB+lobe*hB+lobe*fB+eB)*rcpL;
return;}
#endif
#if defined(A_GPU)&&defined(A_HALF)&&defined(FSR_RCAS_H)
AH4 FsrRcasLoadH(ASW2 p);
void FsrRcasInputH(inout AH1 r,inout AH1 g,inout AH1 b);
void FsrRcasH(
out AH1 pixR, // Output values, non-vector so port between RcasFilter() and RcasFilterH() is easy.
out AH1 pixG,
out AH1 pixB,
#ifdef FSR_RCAS_PASSTHROUGH_ALPHA
out AH1 pixA,
#endif
AU2 ip, // Integer pixel position in output.
AU4 con){ // Constant generated by RcasSetup().
ASW2 sp=ASW2(ip);
AH3 b=FsrRcasLoadH(sp+ASW2( 0,-1)).rgb;
AH3 d=FsrRcasLoadH(sp+ASW2(-1, 0)).rgb;
#ifdef FSR_RCAS_PASSTHROUGH_ALPHA
AH4 ee=FsrRcasLoadH(sp);
AH3 e=ee.rgb;pixA=ee.a;
#else
AH3 e=FsrRcasLoadH(sp).rgb;
#endif
AH3 f=FsrRcasLoadH(sp+ASW2( 1, 0)).rgb;
AH3 h=FsrRcasLoadH(sp+ASW2( 0, 1)).rgb;
AH1 bR=b.r;
AH1 bG=b.g;
AH1 bB=b.b;
AH1 dR=d.r;
AH1 dG=d.g;
AH1 dB=d.b;
AH1 eR=e.r;
AH1 eG=e.g;
AH1 eB=e.b;
AH1 fR=f.r;
AH1 fG=f.g;
AH1 fB=f.b;
AH1 hR=h.r;
AH1 hG=h.g;
AH1 hB=h.b;
FsrRcasInputH(bR,bG,bB);
FsrRcasInputH(dR,dG,dB);
FsrRcasInputH(eR,eG,eB);
FsrRcasInputH(fR,fG,fB);
FsrRcasInputH(hR,hG,hB);
AH1 bL=bB*AH1_(0.5)+(bR*AH1_(0.5)+bG);
AH1 dL=dB*AH1_(0.5)+(dR*AH1_(0.5)+dG);
AH1 eL=eB*AH1_(0.5)+(eR*AH1_(0.5)+eG);
AH1 fL=fB*AH1_(0.5)+(fR*AH1_(0.5)+fG);
AH1 hL=hB*AH1_(0.5)+(hR*AH1_(0.5)+hG);
AH1 nz=AH1_(0.25)*bL+AH1_(0.25)*dL+AH1_(0.25)*fL+AH1_(0.25)*hL-eL;
nz=ASatH1(abs(nz)*APrxMedRcpH1(AMax3H1(AMax3H1(bL,dL,eL),fL,hL)-AMin3H1(AMin3H1(bL,dL,eL),fL,hL)));
nz=AH1_(-0.5)*nz+AH1_(1.0);
AH1 mn4R=min(AMin3H1(bR,dR,fR),hR);
AH1 mn4G=min(AMin3H1(bG,dG,fG),hG);
AH1 mn4B=min(AMin3H1(bB,dB,fB),hB);
AH1 mx4R=max(AMax3H1(bR,dR,fR),hR);
AH1 mx4G=max(AMax3H1(bG,dG,fG),hG);
AH1 mx4B=max(AMax3H1(bB,dB,fB),hB);
AH2 peakC=AH2(1.0,-1.0*4.0);
AH1 hitMinR=mn4R*ARcpH1(AH1_(4.0)*mx4R);
AH1 hitMinG=mn4G*ARcpH1(AH1_(4.0)*mx4G);
AH1 hitMinB=mn4B*ARcpH1(AH1_(4.0)*mx4B);
AH1 hitMaxR=(peakC.x-mx4R)*ARcpH1(AH1_(4.0)*mn4R+peakC.y);
AH1 hitMaxG=(peakC.x-mx4G)*ARcpH1(AH1_(4.0)*mn4G+peakC.y);
AH1 hitMaxB=(peakC.x-mx4B)*ARcpH1(AH1_(4.0)*mn4B+peakC.y);
AH1 lobeR=max(-hitMinR,hitMaxR);
AH1 lobeG=max(-hitMinG,hitMaxG);
AH1 lobeB=max(-hitMinB,hitMaxB);
AH1 lobe=max(AH1_(-FSR_RCAS_LIMIT),min(AMax3H1(lobeR,lobeG,lobeB),AH1_(0.0)))*AH2_AU1(con.y).x;
#ifdef FSR_RCAS_DENOISE
lobe*=nz;
#endif
AH1 rcpL=APrxMedRcpH1(AH1_(4.0)*lobe+AH1_(1.0));
pixR=(lobe*bR+lobe*dR+lobe*hR+lobe*fR+eR)*rcpL;
pixG=(lobe*bG+lobe*dG+lobe*hG+lobe*fG+eG)*rcpL;
pixB=(lobe*bB+lobe*dB+lobe*hB+lobe*fB+eB)*rcpL;}
#endif
#if defined(A_GPU)&&defined(A_HALF)&&defined(FSR_RCAS_HX2)
AH4 FsrRcasLoadHx2(ASW2 p);
void FsrRcasInputHx2(inout AH2 r,inout AH2 g,inout AH2 b);
void FsrRcasDepackHx2(out AH4 pix0,out AH4 pix1,AH2 pixR,AH2 pixG,AH2 pixB){
#ifdef A_HLSL
pix0.a=pix1.a=0.0;
#endif
pix0.rgb=AH3(pixR.x,pixG.x,pixB.x);
pix1.rgb=AH3(pixR.y,pixG.y,pixB.y);}
void FsrRcasHx2(
out AH2 pixR,
out AH2 pixG,
out AH2 pixB,
#ifdef FSR_RCAS_PASSTHROUGH_ALPHA
out AH2 pixA,
#endif
AU2 ip, // Integer pixel position in output.
AU4 con){ // Constant generated by RcasSetup().
ASW2 sp0=ASW2(ip);
AH3 b0=FsrRcasLoadHx2(sp0+ASW2( 0,-1)).rgb;
AH3 d0=FsrRcasLoadHx2(sp0+ASW2(-1, 0)).rgb;
#ifdef FSR_RCAS_PASSTHROUGH_ALPHA
AH4 ee0=FsrRcasLoadHx2(sp0);
AH3 e0=ee0.rgb;pixA.r=ee0.a;
#else
AH3 e0=FsrRcasLoadHx2(sp0).rgb;
#endif
AH3 f0=FsrRcasLoadHx2(sp0+ASW2( 1, 0)).rgb;
AH3 h0=FsrRcasLoadHx2(sp0+ASW2( 0, 1)).rgb;
ASW2 sp1=sp0+ASW2(8,0);
AH3 b1=FsrRcasLoadHx2(sp1+ASW2( 0,-1)).rgb;
AH3 d1=FsrRcasLoadHx2(sp1+ASW2(-1, 0)).rgb;
#ifdef FSR_RCAS_PASSTHROUGH_ALPHA
AH4 ee1=FsrRcasLoadHx2(sp1);
AH3 e1=ee1.rgb;pixA.g=ee1.a;
#else
AH3 e1=FsrRcasLoadHx2(sp1).rgb;
#endif
AH3 f1=FsrRcasLoadHx2(sp1+ASW2( 1, 0)).rgb;
AH3 h1=FsrRcasLoadHx2(sp1+ASW2( 0, 1)).rgb;
AH2 bR=AH2(b0.r,b1.r);
AH2 bG=AH2(b0.g,b1.g);
AH2 bB=AH2(b0.b,b1.b);
AH2 dR=AH2(d0.r,d1.r);
AH2 dG=AH2(d0.g,d1.g);
AH2 dB=AH2(d0.b,d1.b);
AH2 eR=AH2(e0.r,e1.r);
AH2 eG=AH2(e0.g,e1.g);
AH2 eB=AH2(e0.b,e1.b);
AH2 fR=AH2(f0.r,f1.r);
AH2 fG=AH2(f0.g,f1.g);
AH2 fB=AH2(f0.b,f1.b);
AH2 hR=AH2(h0.r,h1.r);
AH2 hG=AH2(h0.g,h1.g);
AH2 hB=AH2(h0.b,h1.b);
FsrRcasInputHx2(bR,bG,bB);
FsrRcasInputHx2(dR,dG,dB);
FsrRcasInputHx2(eR,eG,eB);
FsrRcasInputHx2(fR,fG,fB);
FsrRcasInputHx2(hR,hG,hB);
AH2 bL=bB*AH2_(0.5)+(bR*AH2_(0.5)+bG);
AH2 dL=dB*AH2_(0.5)+(dR*AH2_(0.5)+dG);
AH2 eL=eB*AH2_(0.5)+(eR*AH2_(0.5)+eG);
AH2 fL=fB*AH2_(0.5)+(fR*AH2_(0.5)+fG);
AH2 hL=hB*AH2_(0.5)+(hR*AH2_(0.5)+hG);
AH2 nz=AH2_(0.25)*bL+AH2_(0.25)*dL+AH2_(0.25)*fL+AH2_(0.25)*hL-eL;
nz=ASatH2(abs(nz)*APrxMedRcpH2(AMax3H2(AMax3H2(bL,dL,eL),fL,hL)-AMin3H2(AMin3H2(bL,dL,eL),fL,hL)));
nz=AH2_(-0.5)*nz+AH2_(1.0);
AH2 mn4R=min(AMin3H2(bR,dR,fR),hR);
AH2 mn4G=min(AMin3H2(bG,dG,fG),hG);
AH2 mn4B=min(AMin3H2(bB,dB,fB),hB);
AH2 mx4R=max(AMax3H2(bR,dR,fR),hR);
AH2 mx4G=max(AMax3H2(bG,dG,fG),hG);
AH2 mx4B=max(AMax3H2(bB,dB,fB),hB);
AH2 peakC=AH2(1.0,-1.0*4.0);
AH2 hitMinR=mn4R*ARcpH2(AH2_(4.0)*mx4R);
AH2 hitMinG=mn4G*ARcpH2(AH2_(4.0)*mx4G);
AH2 hitMinB=mn4B*ARcpH2(AH2_(4.0)*mx4B);
AH2 hitMaxR=(peakC.x-mx4R)*ARcpH2(AH2_(4.0)*mn4R+peakC.y);
AH2 hitMaxG=(peakC.x-mx4G)*ARcpH2(AH2_(4.0)*mn4G+peakC.y);
AH2 hitMaxB=(peakC.x-mx4B)*ARcpH2(AH2_(4.0)*mn4B+peakC.y);
AH2 lobeR=max(-hitMinR,hitMaxR);
AH2 lobeG=max(-hitMinG,hitMaxG);
AH2 lobeB=max(-hitMinB,hitMaxB);
AH2 lobe=max(AH2_(-FSR_RCAS_LIMIT),min(AMax3H2(lobeR,lobeG,lobeB),AH2_(0.0)))*AH2_(AH2_AU1(con.y).x);
#ifdef FSR_RCAS_DENOISE
lobe*=nz;
#endif
AH2 rcpL=APrxMedRcpH2(AH2_(4.0)*lobe+AH2_(1.0));
pixR=(lobe*bR+lobe*dR+lobe*hR+lobe*fR+eR)*rcpL;
pixG=(lobe*bG+lobe*dG+lobe*hG+lobe*fG+eG)*rcpL;
pixB=(lobe*bB+lobe*dB+lobe*hB+lobe*fB+eB)*rcpL;}
#endif
#if defined(A_GPU)
void FsrLfgaF(inout AF3 c,AF3 t,AF1 a){c+=(t*AF3_(a))*min(AF3_(1.0)-c,c);}
#endif
#if defined(A_GPU)&&defined(A_HALF)
void FsrLfgaH(inout AH3 c,AH3 t,AH1 a){c+=(t*AH3_(a))*min(AH3_(1.0)-c,c);}
void FsrLfgaHx2(inout AH2 cR,inout AH2 cG,inout AH2 cB,AH2 tR,AH2 tG,AH2 tB,AH1 a){
cR+=(tR*AH2_(a))*min(AH2_(1.0)-cR,cR);cG+=(tG*AH2_(a))*min(AH2_(1.0)-cG,cG);cB+=(tB*AH2_(a))*min(AH2_(1.0)-cB,cB);}
#endif
#if defined(A_GPU)
void FsrSrtmF(inout AF3 c){c*=AF3_(ARcpF1(AMax3F1(c.r,c.g,c.b)+AF1_(1.0)));}
void FsrSrtmInvF(inout AF3 c){c*=AF3_(ARcpF1(max(AF1_(1.0/32768.0),AF1_(1.0)-AMax3F1(c.r,c.g,c.b))));}
#endif
#if defined(A_GPU)&&defined(A_HALF)
void FsrSrtmH(inout AH3 c){c*=AH3_(ARcpH1(AMax3H1(c.r,c.g,c.b)+AH1_(1.0)));}
void FsrSrtmInvH(inout AH3 c){c*=AH3_(ARcpH1(max(AH1_(1.0/32768.0),AH1_(1.0)-AMax3H1(c.r,c.g,c.b))));}
void FsrSrtmHx2(inout AH2 cR,inout AH2 cG,inout AH2 cB){
AH2 rcp=ARcpH2(AMax3H2(cR,cG,cB)+AH2_(1.0));cR*=rcp;cG*=rcp;cB*=rcp;}
void FsrSrtmInvHx2(inout AH2 cR,inout AH2 cG,inout AH2 cB){
AH2 rcp=ARcpH2(max(AH2_(1.0/32768.0),AH2_(1.0)-AMax3H2(cR,cG,cB)));cR*=rcp;cG*=rcp;cB*=rcp;}
#endif
#if defined(A_GPU)
AF1 FsrTepdDitF(AU2 p,AU1 f){
AF1 x=AF1_(p.x+f);
AF1 y=AF1_(p.y);
AF1 a=AF1_((1.0+sqrt(5.0))/2.0);
AF1 b=AF1_(1.0/3.69);
x=x*a+(y*b);
return AFractF1(x);}
void FsrTepdC8F(inout AF3 c,AF1 dit){
AF3 n=sqrt(c);
n=floor(n*AF3_(255.0))*AF3_(1.0/255.0);
AF3 a=n*n;
AF3 b=n+AF3_(1.0/255.0);b=b*b;
AF3 r=(c-b)*APrxMedRcpF3(a-b);
c=ASatF3(n+AGtZeroF3(AF3_(dit)-r)*AF3_(1.0/255.0));}
void FsrTepdC10F(inout AF3 c,AF1 dit){
AF3 n=sqrt(c);
n=floor(n*AF3_(1023.0))*AF3_(1.0/1023.0);
AF3 a=n*n;
AF3 b=n+AF3_(1.0/1023.0);b=b*b;
AF3 r=(c-b)*APrxMedRcpF3(a-b);
c=ASatF3(n+AGtZeroF3(AF3_(dit)-r)*AF3_(1.0/1023.0));}
#endif
#if defined(A_GPU)&&defined(A_HALF)
AH1 FsrTepdDitH(AU2 p,AU1 f){
AF1 x=AF1_(p.x+f);
AF1 y=AF1_(p.y);
AF1 a=AF1_((1.0+sqrt(5.0))/2.0);
AF1 b=AF1_(1.0/3.69);
x=x*a+(y*b);
return AH1(AFractF1(x));}
void FsrTepdC8H(inout AH3 c,AH1 dit){
AH3 n=sqrt(c);
n=floor(n*AH3_(255.0))*AH3_(1.0/255.0);
AH3 a=n*n;
AH3 b=n+AH3_(1.0/255.0);b=b*b;
AH3 r=(c-b)*APrxMedRcpH3(a-b);
c=ASatH3(n+AGtZeroH3(AH3_(dit)-r)*AH3_(1.0/255.0));}
void FsrTepdC10H(inout AH3 c,AH1 dit){
AH3 n=sqrt(c);
n=floor(n*AH3_(1023.0))*AH3_(1.0/1023.0);
AH3 a=n*n;
AH3 b=n+AH3_(1.0/1023.0);b=b*b;
AH3 r=(c-b)*APrxMedRcpH3(a-b);
c=ASatH3(n+AGtZeroH3(AH3_(dit)-r)*AH3_(1.0/1023.0));}
AH2 FsrTepdDitHx2(AU2 p,AU1 f){
AF2 x;
x.x=AF1_(p.x+f);
x.y=x.x+AF1_(8.0);
AF1 y=AF1_(p.y);
AF1 a=AF1_((1.0+sqrt(5.0))/2.0);
AF1 b=AF1_(1.0/3.69);
x=x*AF2_(a)+AF2_(y*b);
return AH2(AFractF2(x));}
void FsrTepdC8Hx2(inout AH2 cR,inout AH2 cG,inout AH2 cB,AH2 dit){
AH2 nR=sqrt(cR);
AH2 nG=sqrt(cG);
AH2 nB=sqrt(cB);
nR=floor(nR*AH2_(255.0))*AH2_(1.0/255.0);
nG=floor(nG*AH2_(255.0))*AH2_(1.0/255.0);
nB=floor(nB*AH2_(255.0))*AH2_(1.0/255.0);
AH2 aR=nR*nR;
AH2 aG=nG*nG;
AH2 aB=nB*nB;
AH2 bR=nR+AH2_(1.0/255.0);bR=bR*bR;
AH2 bG=nG+AH2_(1.0/255.0);bG=bG*bG;
AH2 bB=nB+AH2_(1.0/255.0);bB=bB*bB;
AH2 rR=(cR-bR)*APrxMedRcpH2(aR-bR);
AH2 rG=(cG-bG)*APrxMedRcpH2(aG-bG);
AH2 rB=(cB-bB)*APrxMedRcpH2(aB-bB);
cR=ASatH2(nR+AGtZeroH2(dit-rR)*AH2_(1.0/255.0));
cG=ASatH2(nG+AGtZeroH2(dit-rG)*AH2_(1.0/255.0));
cB=ASatH2(nB+AGtZeroH2(dit-rB)*AH2_(1.0/255.0));}
void FsrTepdC10Hx2(inout AH2 cR,inout AH2 cG,inout AH2 cB,AH2 dit){
AH2 nR=sqrt(cR);
AH2 nG=sqrt(cG);
AH2 nB=sqrt(cB);
nR=floor(nR*AH2_(1023.0))*AH2_(1.0/1023.0);
nG=floor(nG*AH2_(1023.0))*AH2_(1.0/1023.0);
nB=floor(nB*AH2_(1023.0))*AH2_(1.0/1023.0);
AH2 aR=nR*nR;
AH2 aG=nG*nG;
AH2 aB=nB*nB;
AH2 bR=nR+AH2_(1.0/1023.0);bR=bR*bR;
AH2 bG=nG+AH2_(1.0/1023.0);bG=bG*bG;
AH2 bB=nB+AH2_(1.0/1023.0);bB=bB*bB;
AH2 rR=(cR-bR)*APrxMedRcpH2(aR-bR);
AH2 rG=(cG-bG)*APrxMedRcpH2(aG-bG);
AH2 rB=(cB-bB)*APrxMedRcpH2(aB-bB);
cR=ASatH2(nR+AGtZeroH2(dit-rR)*AH2_(1.0/1023.0));
cG=ASatH2(nG+AGtZeroH2(dit-rG)*AH2_(1.0/1023.0));
cB=ASatH2(nB+AGtZeroH2(dit-rB)*AH2_(1.0/1023.0));}
#endif
)--RPCS3--"
| 21,948
|
C++
|
.inc
| 648
| 31.867284
| 150
| 0.672082
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,291
|
fsr_ffx_a_flattened.inc
|
RPCS3_rpcs3/rpcs3/Emu/RSX/Program/Upscalers/FSR1/fsr_ffx_a_flattened.inc
|
R"--RPCS3--(
#define A_2PI 6.28318530718
#if defined(A_GLSL) && defined(A_GPU)
#ifndef A_SKIP_EXT
#ifdef A_HALF
#extension GL_EXT_shader_16bit_storage:require
#extension GL_EXT_shader_explicit_arithmetic_types:require
#endif
#ifdef A_LONG
#extension GL_ARB_gpu_shader_int64:require
#extension GL_NV_shader_atomic_int64:require
#endif
#ifdef A_WAVE
#extension GL_KHR_shader_subgroup_arithmetic:require
#extension GL_KHR_shader_subgroup_ballot:require
#extension GL_KHR_shader_subgroup_quad:require
#extension GL_KHR_shader_subgroup_shuffle:require
#endif
#endif
#define AP1 bool
#define AP2 bvec2
#define AP3 bvec3
#define AP4 bvec4
#define AF1 float
#define AF2 vec2
#define AF3 vec3
#define AF4 vec4
#define AU1 uint
#define AU2 uvec2
#define AU3 uvec3
#define AU4 uvec4
#define ASU1 int
#define ASU2 ivec2
#define ASU3 ivec3
#define ASU4 ivec4
#define AF1_AU1(x) uintBitsToFloat(AU1(x))
#define AF2_AU2(x) uintBitsToFloat(AU2(x))
#define AF3_AU3(x) uintBitsToFloat(AU3(x))
#define AF4_AU4(x) uintBitsToFloat(AU4(x))
#define AU1_AF1(x) floatBitsToUint(AF1(x))
#define AU2_AF2(x) floatBitsToUint(AF2(x))
#define AU3_AF3(x) floatBitsToUint(AF3(x))
#define AU4_AF4(x) floatBitsToUint(AF4(x))
AU1 AU1_AH1_AF1_x(AF1 a){return packHalf2x16(AF2(a,0.0));}
#define AU1_AH1_AF1(a) AU1_AH1_AF1_x(AF1(a))
#define AU1_AH2_AF2 packHalf2x16
#define AU1_AW2Unorm_AF2 packUnorm2x16
#define AU1_AB4Unorm_AF4 packUnorm4x8
#define AF2_AH2_AU1 unpackHalf2x16
#define AF2_AW2Unorm_AU1 unpackUnorm2x16
#define AF4_AB4Unorm_AU1 unpackUnorm4x8
AF1 AF1_x(AF1 a){return AF1(a);}
AF2 AF2_x(AF1 a){return AF2(a,a);}
AF3 AF3_x(AF1 a){return AF3(a,a,a);}
AF4 AF4_x(AF1 a){return AF4(a,a,a,a);}
#define AF1_(a) AF1_x(AF1(a))
#define AF2_(a) AF2_x(AF1(a))
#define AF3_(a) AF3_x(AF1(a))
#define AF4_(a) AF4_x(AF1(a))
AU1 AU1_x(AU1 a){return AU1(a);}
AU2 AU2_x(AU1 a){return AU2(a,a);}
AU3 AU3_x(AU1 a){return AU3(a,a,a);}
AU4 AU4_x(AU1 a){return AU4(a,a,a,a);}
#define AU1_(a) AU1_x(AU1(a))
#define AU2_(a) AU2_x(AU1(a))
#define AU3_(a) AU3_x(AU1(a))
#define AU4_(a) AU4_x(AU1(a))
AU1 AAbsSU1(AU1 a){return AU1(abs(ASU1(a)));}
AU2 AAbsSU2(AU2 a){return AU2(abs(ASU2(a)));}
AU3 AAbsSU3(AU3 a){return AU3(abs(ASU3(a)));}
AU4 AAbsSU4(AU4 a){return AU4(abs(ASU4(a)));}
AU1 ABfe(AU1 src,AU1 off,AU1 bits){return bitfieldExtract(src,ASU1(off),ASU1(bits));}
AU1 ABfi(AU1 src,AU1 ins,AU1 mask){return (ins&mask)|(src&(~mask));}
AU1 ABfiM(AU1 src,AU1 ins,AU1 bits){return bitfieldInsert(src,ins,0,ASU1(bits));}
AF1 AClampF1(AF1 x,AF1 n,AF1 m){return clamp(x,n,m);}
AF2 AClampF2(AF2 x,AF2 n,AF2 m){return clamp(x,n,m);}
AF3 AClampF3(AF3 x,AF3 n,AF3 m){return clamp(x,n,m);}
AF4 AClampF4(AF4 x,AF4 n,AF4 m){return clamp(x,n,m);}
AF1 AFractF1(AF1 x){return fract(x);}
AF2 AFractF2(AF2 x){return fract(x);}
AF3 AFractF3(AF3 x){return fract(x);}
AF4 AFractF4(AF4 x){return fract(x);}
AF1 ALerpF1(AF1 x,AF1 y,AF1 a){return mix(x,y,a);}
AF2 ALerpF2(AF2 x,AF2 y,AF2 a){return mix(x,y,a);}
AF3 ALerpF3(AF3 x,AF3 y,AF3 a){return mix(x,y,a);}
AF4 ALerpF4(AF4 x,AF4 y,AF4 a){return mix(x,y,a);}
AF1 AMax3F1(AF1 x,AF1 y,AF1 z){return max(x,max(y,z));}
AF2 AMax3F2(AF2 x,AF2 y,AF2 z){return max(x,max(y,z));}
AF3 AMax3F3(AF3 x,AF3 y,AF3 z){return max(x,max(y,z));}
AF4 AMax3F4(AF4 x,AF4 y,AF4 z){return max(x,max(y,z));}
AU1 AMax3SU1(AU1 x,AU1 y,AU1 z){return AU1(max(ASU1(x),max(ASU1(y),ASU1(z))));}
AU2 AMax3SU2(AU2 x,AU2 y,AU2 z){return AU2(max(ASU2(x),max(ASU2(y),ASU2(z))));}
AU3 AMax3SU3(AU3 x,AU3 y,AU3 z){return AU3(max(ASU3(x),max(ASU3(y),ASU3(z))));}
AU4 AMax3SU4(AU4 x,AU4 y,AU4 z){return AU4(max(ASU4(x),max(ASU4(y),ASU4(z))));}
AU1 AMax3U1(AU1 x,AU1 y,AU1 z){return max(x,max(y,z));}
AU2 AMax3U2(AU2 x,AU2 y,AU2 z){return max(x,max(y,z));}
AU3 AMax3U3(AU3 x,AU3 y,AU3 z){return max(x,max(y,z));}
AU4 AMax3U4(AU4 x,AU4 y,AU4 z){return max(x,max(y,z));}
AU1 AMaxSU1(AU1 a,AU1 b){return AU1(max(ASU1(a),ASU1(b)));}
AU2 AMaxSU2(AU2 a,AU2 b){return AU2(max(ASU2(a),ASU2(b)));}
AU3 AMaxSU3(AU3 a,AU3 b){return AU3(max(ASU3(a),ASU3(b)));}
AU4 AMaxSU4(AU4 a,AU4 b){return AU4(max(ASU4(a),ASU4(b)));}
AF1 AMed3F1(AF1 x,AF1 y,AF1 z){return max(min(x,y),min(max(x,y),z));}
AF2 AMed3F2(AF2 x,AF2 y,AF2 z){return max(min(x,y),min(max(x,y),z));}
AF3 AMed3F3(AF3 x,AF3 y,AF3 z){return max(min(x,y),min(max(x,y),z));}
AF4 AMed3F4(AF4 x,AF4 y,AF4 z){return max(min(x,y),min(max(x,y),z));}
AF1 AMin3F1(AF1 x,AF1 y,AF1 z){return min(x,min(y,z));}
AF2 AMin3F2(AF2 x,AF2 y,AF2 z){return min(x,min(y,z));}
AF3 AMin3F3(AF3 x,AF3 y,AF3 z){return min(x,min(y,z));}
AF4 AMin3F4(AF4 x,AF4 y,AF4 z){return min(x,min(y,z));}
AU1 AMin3SU1(AU1 x,AU1 y,AU1 z){return AU1(min(ASU1(x),min(ASU1(y),ASU1(z))));}
AU2 AMin3SU2(AU2 x,AU2 y,AU2 z){return AU2(min(ASU2(x),min(ASU2(y),ASU2(z))));}
AU3 AMin3SU3(AU3 x,AU3 y,AU3 z){return AU3(min(ASU3(x),min(ASU3(y),ASU3(z))));}
AU4 AMin3SU4(AU4 x,AU4 y,AU4 z){return AU4(min(ASU4(x),min(ASU4(y),ASU4(z))));}
AU1 AMin3U1(AU1 x,AU1 y,AU1 z){return min(x,min(y,z));}
AU2 AMin3U2(AU2 x,AU2 y,AU2 z){return min(x,min(y,z));}
AU3 AMin3U3(AU3 x,AU3 y,AU3 z){return min(x,min(y,z));}
AU4 AMin3U4(AU4 x,AU4 y,AU4 z){return min(x,min(y,z));}
AU1 AMinSU1(AU1 a,AU1 b){return AU1(min(ASU1(a),ASU1(b)));}
AU2 AMinSU2(AU2 a,AU2 b){return AU2(min(ASU2(a),ASU2(b)));}
AU3 AMinSU3(AU3 a,AU3 b){return AU3(min(ASU3(a),ASU3(b)));}
AU4 AMinSU4(AU4 a,AU4 b){return AU4(min(ASU4(a),ASU4(b)));}
AF1 ANCosF1(AF1 x){return cos(x*AF1_(A_2PI));}
AF2 ANCosF2(AF2 x){return cos(x*AF2_(A_2PI));}
AF3 ANCosF3(AF3 x){return cos(x*AF3_(A_2PI));}
AF4 ANCosF4(AF4 x){return cos(x*AF4_(A_2PI));}
AF1 ANSinF1(AF1 x){return sin(x*AF1_(A_2PI));}
AF2 ANSinF2(AF2 x){return sin(x*AF2_(A_2PI));}
AF3 ANSinF3(AF3 x){return sin(x*AF3_(A_2PI));}
AF4 ANSinF4(AF4 x){return sin(x*AF4_(A_2PI));}
AF1 ARcpF1(AF1 x){return AF1_(1.0)/x;}
AF2 ARcpF2(AF2 x){return AF2_(1.0)/x;}
AF3 ARcpF3(AF3 x){return AF3_(1.0)/x;}
AF4 ARcpF4(AF4 x){return AF4_(1.0)/x;}
AF1 ARsqF1(AF1 x){return AF1_(1.0)/sqrt(x);}
AF2 ARsqF2(AF2 x){return AF2_(1.0)/sqrt(x);}
AF3 ARsqF3(AF3 x){return AF3_(1.0)/sqrt(x);}
AF4 ARsqF4(AF4 x){return AF4_(1.0)/sqrt(x);}
AF1 ASatF1(AF1 x){return clamp(x,AF1_(0.0),AF1_(1.0));}
AF2 ASatF2(AF2 x){return clamp(x,AF2_(0.0),AF2_(1.0));}
AF3 ASatF3(AF3 x){return clamp(x,AF3_(0.0),AF3_(1.0));}
AF4 ASatF4(AF4 x){return clamp(x,AF4_(0.0),AF4_(1.0));}
AU1 AShrSU1(AU1 a,AU1 b){return AU1(ASU1(a)>>ASU1(b));}
AU2 AShrSU2(AU2 a,AU2 b){return AU2(ASU2(a)>>ASU2(b));}
AU3 AShrSU3(AU3 a,AU3 b){return AU3(ASU3(a)>>ASU3(b));}
AU4 AShrSU4(AU4 a,AU4 b){return AU4(ASU4(a)>>ASU4(b));}
#ifdef A_BYTE
#define AB1 uint8_t
#define AB2 u8vec2
#define AB3 u8vec3
#define AB4 u8vec4
#define ASB1 int8_t
#define ASB2 i8vec2
#define ASB3 i8vec3
#define ASB4 i8vec4
AB1 AB1_x(AB1 a){return AB1(a);}
AB2 AB2_x(AB1 a){return AB2(a,a);}
AB3 AB3_x(AB1 a){return AB3(a,a,a);}
AB4 AB4_x(AB1 a){return AB4(a,a,a,a);}
#define AB1_(a) AB1_x(AB1(a))
#define AB2_(a) AB2_x(AB1(a))
#define AB3_(a) AB3_x(AB1(a))
#define AB4_(a) AB4_x(AB1(a))
#endif
#ifdef A_HALF
#define AH1 float16_t
#define AH2 f16vec2
#define AH3 f16vec3
#define AH4 f16vec4
#define AW1 uint16_t
#define AW2 u16vec2
#define AW3 u16vec3
#define AW4 u16vec4
#define ASW1 int16_t
#define ASW2 i16vec2
#define ASW3 i16vec3
#define ASW4 i16vec4
#define AH2_AU1(x) unpackFloat2x16(AU1(x))
AH4 AH4_AU2_x(AU2 x){return AH4(unpackFloat2x16(x.x),unpackFloat2x16(x.y));}
#define AH4_AU2(x) AH4_AU2_x(AU2(x))
#define AW2_AU1(x) unpackUint2x16(AU1(x))
#define AW4_AU2(x) unpackUint4x16(pack64(AU2(x)))
#define AU1_AH2(x) packFloat2x16(AH2(x))
AU2 AU2_AH4_x(AH4 x){return AU2(packFloat2x16(x.xy),packFloat2x16(x.zw));}
#define AU2_AH4(x) AU2_AH4_x(AH4(x))
#define AU1_AW2(x) packUint2x16(AW2(x))
#define AU2_AW4(x) unpack32(packUint4x16(AW4(x)))
#define AW1_AH1(x) halfBitsToUint16(AH1(x))
#define AW2_AH2(x) halfBitsToUint16(AH2(x))
#define AW3_AH3(x) halfBitsToUint16(AH3(x))
#define AW4_AH4(x) halfBitsToUint16(AH4(x))
#define AH1_AW1(x) uint16BitsToHalf(AW1(x))
#define AH2_AW2(x) uint16BitsToHalf(AW2(x))
#define AH3_AW3(x) uint16BitsToHalf(AW3(x))
#define AH4_AW4(x) uint16BitsToHalf(AW4(x))
AH1 AH1_x(AH1 a){return AH1(a);}
AH2 AH2_x(AH1 a){return AH2(a,a);}
AH3 AH3_x(AH1 a){return AH3(a,a,a);}
AH4 AH4_x(AH1 a){return AH4(a,a,a,a);}
#define AH1_(a) AH1_x(AH1(a))
#define AH2_(a) AH2_x(AH1(a))
#define AH3_(a) AH3_x(AH1(a))
#define AH4_(a) AH4_x(AH1(a))
AW1 AW1_x(AW1 a){return AW1(a);}
AW2 AW2_x(AW1 a){return AW2(a,a);}
AW3 AW3_x(AW1 a){return AW3(a,a,a);}
AW4 AW4_x(AW1 a){return AW4(a,a,a,a);}
#define AW1_(a) AW1_x(AW1(a))
#define AW2_(a) AW2_x(AW1(a))
#define AW3_(a) AW3_x(AW1(a))
#define AW4_(a) AW4_x(AW1(a))
AW1 AAbsSW1(AW1 a){return AW1(abs(ASW1(a)));}
AW2 AAbsSW2(AW2 a){return AW2(abs(ASW2(a)));}
AW3 AAbsSW3(AW3 a){return AW3(abs(ASW3(a)));}
AW4 AAbsSW4(AW4 a){return AW4(abs(ASW4(a)));}
AH1 AClampH1(AH1 x,AH1 n,AH1 m){return clamp(x,n,m);}
AH2 AClampH2(AH2 x,AH2 n,AH2 m){return clamp(x,n,m);}
AH3 AClampH3(AH3 x,AH3 n,AH3 m){return clamp(x,n,m);}
AH4 AClampH4(AH4 x,AH4 n,AH4 m){return clamp(x,n,m);}
AH1 AFractH1(AH1 x){return fract(x);}
AH2 AFractH2(AH2 x){return fract(x);}
AH3 AFractH3(AH3 x){return fract(x);}
AH4 AFractH4(AH4 x){return fract(x);}
AH1 ALerpH1(AH1 x,AH1 y,AH1 a){return mix(x,y,a);}
AH2 ALerpH2(AH2 x,AH2 y,AH2 a){return mix(x,y,a);}
AH3 ALerpH3(AH3 x,AH3 y,AH3 a){return mix(x,y,a);}
AH4 ALerpH4(AH4 x,AH4 y,AH4 a){return mix(x,y,a);}
AH1 AMax3H1(AH1 x,AH1 y,AH1 z){return max(x,max(y,z));}
AH2 AMax3H2(AH2 x,AH2 y,AH2 z){return max(x,max(y,z));}
AH3 AMax3H3(AH3 x,AH3 y,AH3 z){return max(x,max(y,z));}
AH4 AMax3H4(AH4 x,AH4 y,AH4 z){return max(x,max(y,z));}
AW1 AMaxSW1(AW1 a,AW1 b){return AW1(max(ASU1(a),ASU1(b)));}
AW2 AMaxSW2(AW2 a,AW2 b){return AW2(max(ASU2(a),ASU2(b)));}
AW3 AMaxSW3(AW3 a,AW3 b){return AW3(max(ASU3(a),ASU3(b)));}
AW4 AMaxSW4(AW4 a,AW4 b){return AW4(max(ASU4(a),ASU4(b)));}
AH1 AMin3H1(AH1 x,AH1 y,AH1 z){return min(x,min(y,z));}
AH2 AMin3H2(AH2 x,AH2 y,AH2 z){return min(x,min(y,z));}
AH3 AMin3H3(AH3 x,AH3 y,AH3 z){return min(x,min(y,z));}
AH4 AMin3H4(AH4 x,AH4 y,AH4 z){return min(x,min(y,z));}
AW1 AMinSW1(AW1 a,AW1 b){return AW1(min(ASU1(a),ASU1(b)));}
AW2 AMinSW2(AW2 a,AW2 b){return AW2(min(ASU2(a),ASU2(b)));}
AW3 AMinSW3(AW3 a,AW3 b){return AW3(min(ASU3(a),ASU3(b)));}
AW4 AMinSW4(AW4 a,AW4 b){return AW4(min(ASU4(a),ASU4(b)));}
AH1 ARcpH1(AH1 x){return AH1_(1.0)/x;}
AH2 ARcpH2(AH2 x){return AH2_(1.0)/x;}
AH3 ARcpH3(AH3 x){return AH3_(1.0)/x;}
AH4 ARcpH4(AH4 x){return AH4_(1.0)/x;}
AH1 ARsqH1(AH1 x){return AH1_(1.0)/sqrt(x);}
AH2 ARsqH2(AH2 x){return AH2_(1.0)/sqrt(x);}
AH3 ARsqH3(AH3 x){return AH3_(1.0)/sqrt(x);}
AH4 ARsqH4(AH4 x){return AH4_(1.0)/sqrt(x);}
AH1 ASatH1(AH1 x){return clamp(x,AH1_(0.0),AH1_(1.0));}
AH2 ASatH2(AH2 x){return clamp(x,AH2_(0.0),AH2_(1.0));}
AH3 ASatH3(AH3 x){return clamp(x,AH3_(0.0),AH3_(1.0));}
AH4 ASatH4(AH4 x){return clamp(x,AH4_(0.0),AH4_(1.0));}
AW1 AShrSW1(AW1 a,AW1 b){return AW1(ASW1(a)>>ASW1(b));}
AW2 AShrSW2(AW2 a,AW2 b){return AW2(ASW2(a)>>ASW2(b));}
AW3 AShrSW3(AW3 a,AW3 b){return AW3(ASW3(a)>>ASW3(b));}
AW4 AShrSW4(AW4 a,AW4 b){return AW4(ASW4(a)>>ASW4(b));}
#endif
)--RPCS3--"
R"--RPCS3--(
#ifdef A_DUBL
#define AD1 double
#define AD2 dvec2
#define AD3 dvec3
#define AD4 dvec4
AD1 AD1_x(AD1 a){return AD1(a);}
AD2 AD2_x(AD1 a){return AD2(a,a);}
AD3 AD3_x(AD1 a){return AD3(a,a,a);}
AD4 AD4_x(AD1 a){return AD4(a,a,a,a);}
#define AD1_(a) AD1_x(AD1(a))
#define AD2_(a) AD2_x(AD1(a))
#define AD3_(a) AD3_x(AD1(a))
#define AD4_(a) AD4_x(AD1(a))
AD1 AFractD1(AD1 x){return fract(x);}
AD2 AFractD2(AD2 x){return fract(x);}
AD3 AFractD3(AD3 x){return fract(x);}
AD4 AFractD4(AD4 x){return fract(x);}
AD1 ALerpD1(AD1 x,AD1 y,AD1 a){return mix(x,y,a);}
AD2 ALerpD2(AD2 x,AD2 y,AD2 a){return mix(x,y,a);}
AD3 ALerpD3(AD3 x,AD3 y,AD3 a){return mix(x,y,a);}
AD4 ALerpD4(AD4 x,AD4 y,AD4 a){return mix(x,y,a);}
AD1 ARcpD1(AD1 x){return AD1_(1.0)/x;}
AD2 ARcpD2(AD2 x){return AD2_(1.0)/x;}
AD3 ARcpD3(AD3 x){return AD3_(1.0)/x;}
AD4 ARcpD4(AD4 x){return AD4_(1.0)/x;}
AD1 ARsqD1(AD1 x){return AD1_(1.0)/sqrt(x);}
AD2 ARsqD2(AD2 x){return AD2_(1.0)/sqrt(x);}
AD3 ARsqD3(AD3 x){return AD3_(1.0)/sqrt(x);}
AD4 ARsqD4(AD4 x){return AD4_(1.0)/sqrt(x);}
AD1 ASatD1(AD1 x){return clamp(x,AD1_(0.0),AD1_(1.0));}
AD2 ASatD2(AD2 x){return clamp(x,AD2_(0.0),AD2_(1.0));}
AD3 ASatD3(AD3 x){return clamp(x,AD3_(0.0),AD3_(1.0));}
AD4 ASatD4(AD4 x){return clamp(x,AD4_(0.0),AD4_(1.0));}
#endif
#ifdef A_LONG
#define AL1 uint64_t
#define AL2 u64vec2
#define AL3 u64vec3
#define AL4 u64vec4
#define ASL1 int64_t
#define ASL2 i64vec2
#define ASL3 i64vec3
#define ASL4 i64vec4
#define AL1_AU2(x) packUint2x32(AU2(x))
#define AU2_AL1(x) unpackUint2x32(AL1(x))
AL1 AL1_x(AL1 a){return AL1(a);}
AL2 AL2_x(AL1 a){return AL2(a,a);}
AL3 AL3_x(AL1 a){return AL3(a,a,a);}
AL4 AL4_x(AL1 a){return AL4(a,a,a,a);}
#define AL1_(a) AL1_x(AL1(a))
#define AL2_(a) AL2_x(AL1(a))
#define AL3_(a) AL3_x(AL1(a))
#define AL4_(a) AL4_x(AL1(a))
AL1 AAbsSL1(AL1 a){return AL1(abs(ASL1(a)));}
AL2 AAbsSL2(AL2 a){return AL2(abs(ASL2(a)));}
AL3 AAbsSL3(AL3 a){return AL3(abs(ASL3(a)));}
AL4 AAbsSL4(AL4 a){return AL4(abs(ASL4(a)));}
AL1 AMaxSL1(AL1 a,AL1 b){return AL1(max(ASU1(a),ASU1(b)));}
AL2 AMaxSL2(AL2 a,AL2 b){return AL2(max(ASU2(a),ASU2(b)));}
AL3 AMaxSL3(AL3 a,AL3 b){return AL3(max(ASU3(a),ASU3(b)));}
AL4 AMaxSL4(AL4 a,AL4 b){return AL4(max(ASU4(a),ASU4(b)));}
AL1 AMinSL1(AL1 a,AL1 b){return AL1(min(ASU1(a),ASU1(b)));}
AL2 AMinSL2(AL2 a,AL2 b){return AL2(min(ASU2(a),ASU2(b)));}
AL3 AMinSL3(AL3 a,AL3 b){return AL3(min(ASU3(a),ASU3(b)));}
AL4 AMinSL4(AL4 a,AL4 b){return AL4(min(ASU4(a),ASU4(b)));}
#endif
#ifdef A_WAVE
AF1 AWaveXorF1(AF1 v,AU1 x){return subgroupShuffleXor(v,x);}
AF2 AWaveXorF2(AF2 v,AU1 x){return subgroupShuffleXor(v,x);}
AF3 AWaveXorF3(AF3 v,AU1 x){return subgroupShuffleXor(v,x);}
AF4 AWaveXorF4(AF4 v,AU1 x){return subgroupShuffleXor(v,x);}
AU1 AWaveXorU1(AU1 v,AU1 x){return subgroupShuffleXor(v,x);}
AU2 AWaveXorU2(AU2 v,AU1 x){return subgroupShuffleXor(v,x);}
AU3 AWaveXorU3(AU3 v,AU1 x){return subgroupShuffleXor(v,x);}
AU4 AWaveXorU4(AU4 v,AU1 x){return subgroupShuffleXor(v,x);}
#ifdef A_HALF
AH2 AWaveXorH2(AH2 v,AU1 x){return AH2_AU1(subgroupShuffleXor(AU1_AH2(v),x));}
AH4 AWaveXorH4(AH4 v,AU1 x){return AH4_AU2(subgroupShuffleXor(AU2_AH4(v),x));}
AW2 AWaveXorW2(AW2 v,AU1 x){return AW2_AU1(subgroupShuffleXor(AU1_AW2(v),x));}
AW4 AWaveXorW4(AW4 v,AU1 x){return AW4_AU2(subgroupShuffleXor(AU2_AW4(v),x));}
#endif
#endif
#endif
#if defined(A_HLSL) && defined(A_GPU)
#ifdef A_HLSL_6_2
#define AP1 bool
#define AP2 bool2
#define AP3 bool3
#define AP4 bool4
#define AF1 float32_t
#define AF2 float32_t2
#define AF3 float32_t3
#define AF4 float32_t4
#define AU1 uint32_t
#define AU2 uint32_t2
#define AU3 uint32_t3
#define AU4 uint32_t4
#define ASU1 int32_t
#define ASU2 int32_t2
#define ASU3 int32_t3
#define ASU4 int32_t4
#else
#define AP1 bool
#define AP2 bool2
#define AP3 bool3
#define AP4 bool4
#define AF1 float
#define AF2 float2
#define AF3 float3
#define AF4 float4
#define AU1 uint
#define AU2 uint2
#define AU3 uint3
#define AU4 uint4
#define ASU1 int
#define ASU2 int2
#define ASU3 int3
#define ASU4 int4
#endif
#define AF1_AU1(x) asfloat(AU1(x))
#define AF2_AU2(x) asfloat(AU2(x))
#define AF3_AU3(x) asfloat(AU3(x))
#define AF4_AU4(x) asfloat(AU4(x))
#define AU1_AF1(x) asuint(AF1(x))
#define AU2_AF2(x) asuint(AF2(x))
#define AU3_AF3(x) asuint(AF3(x))
#define AU4_AF4(x) asuint(AF4(x))
AU1 AU1_AH1_AF1_x(AF1 a){return f32tof16(a);}
#define AU1_AH1_AF1(a) AU1_AH1_AF1_x(AF1(a))
AU1 AU1_AH2_AF2_x(AF2 a){return f32tof16(a.x)|(f32tof16(a.y)<<16);}
#define AU1_AH2_AF2(a) AU1_AH2_AF2_x(AF2(a))
#define AU1_AB4Unorm_AF4(x) D3DCOLORtoUBYTE4(AF4(x))
AF2 AF2_AH2_AU1_x(AU1 x){return AF2(f16tof32(x&0xFFFF),f16tof32(x>>16));}
#define AF2_AH2_AU1(x) AF2_AH2_AU1_x(AU1(x))
AF1 AF1_x(AF1 a){return AF1(a);}
AF2 AF2_x(AF1 a){return AF2(a,a);}
AF3 AF3_x(AF1 a){return AF3(a,a,a);}
AF4 AF4_x(AF1 a){return AF4(a,a,a,a);}
#define AF1_(a) AF1_x(AF1(a))
#define AF2_(a) AF2_x(AF1(a))
#define AF3_(a) AF3_x(AF1(a))
#define AF4_(a) AF4_x(AF1(a))
AU1 AU1_x(AU1 a){return AU1(a);}
AU2 AU2_x(AU1 a){return AU2(a,a);}
AU3 AU3_x(AU1 a){return AU3(a,a,a);}
AU4 AU4_x(AU1 a){return AU4(a,a,a,a);}
#define AU1_(a) AU1_x(AU1(a))
#define AU2_(a) AU2_x(AU1(a))
#define AU3_(a) AU3_x(AU1(a))
#define AU4_(a) AU4_x(AU1(a))
AU1 AAbsSU1(AU1 a){return AU1(abs(ASU1(a)));}
AU2 AAbsSU2(AU2 a){return AU2(abs(ASU2(a)));}
AU3 AAbsSU3(AU3 a){return AU3(abs(ASU3(a)));}
AU4 AAbsSU4(AU4 a){return AU4(abs(ASU4(a)));}
AU1 ABfe(AU1 src,AU1 off,AU1 bits){AU1 mask=(1u<<bits)-1;return (src>>off)&mask;}
AU1 ABfi(AU1 src,AU1 ins,AU1 mask){return (ins&mask)|(src&(~mask));}
AU1 ABfiM(AU1 src,AU1 ins,AU1 bits){AU1 mask=(1u<<bits)-1;return (ins&mask)|(src&(~mask));}
AF1 AClampF1(AF1 x,AF1 n,AF1 m){return max(n,min(x,m));}
AF2 AClampF2(AF2 x,AF2 n,AF2 m){return max(n,min(x,m));}
AF3 AClampF3(AF3 x,AF3 n,AF3 m){return max(n,min(x,m));}
AF4 AClampF4(AF4 x,AF4 n,AF4 m){return max(n,min(x,m));}
AF1 AFractF1(AF1 x){return x-floor(x);}
AF2 AFractF2(AF2 x){return x-floor(x);}
AF3 AFractF3(AF3 x){return x-floor(x);}
AF4 AFractF4(AF4 x){return x-floor(x);}
AF1 ALerpF1(AF1 x,AF1 y,AF1 a){return lerp(x,y,a);}
AF2 ALerpF2(AF2 x,AF2 y,AF2 a){return lerp(x,y,a);}
AF3 ALerpF3(AF3 x,AF3 y,AF3 a){return lerp(x,y,a);}
AF4 ALerpF4(AF4 x,AF4 y,AF4 a){return lerp(x,y,a);}
AF1 AMax3F1(AF1 x,AF1 y,AF1 z){return max(x,max(y,z));}
AF2 AMax3F2(AF2 x,AF2 y,AF2 z){return max(x,max(y,z));}
AF3 AMax3F3(AF3 x,AF3 y,AF3 z){return max(x,max(y,z));}
AF4 AMax3F4(AF4 x,AF4 y,AF4 z){return max(x,max(y,z));}
AU1 AMax3SU1(AU1 x,AU1 y,AU1 z){return AU1(max(ASU1(x),max(ASU1(y),ASU1(z))));}
AU2 AMax3SU2(AU2 x,AU2 y,AU2 z){return AU2(max(ASU2(x),max(ASU2(y),ASU2(z))));}
AU3 AMax3SU3(AU3 x,AU3 y,AU3 z){return AU3(max(ASU3(x),max(ASU3(y),ASU3(z))));}
AU4 AMax3SU4(AU4 x,AU4 y,AU4 z){return AU4(max(ASU4(x),max(ASU4(y),ASU4(z))));}
AU1 AMax3U1(AU1 x,AU1 y,AU1 z){return max(x,max(y,z));}
AU2 AMax3U2(AU2 x,AU2 y,AU2 z){return max(x,max(y,z));}
AU3 AMax3U3(AU3 x,AU3 y,AU3 z){return max(x,max(y,z));}
AU4 AMax3U4(AU4 x,AU4 y,AU4 z){return max(x,max(y,z));}
AU1 AMaxSU1(AU1 a,AU1 b){return AU1(max(ASU1(a),ASU1(b)));}
AU2 AMaxSU2(AU2 a,AU2 b){return AU2(max(ASU2(a),ASU2(b)));}
AU3 AMaxSU3(AU3 a,AU3 b){return AU3(max(ASU3(a),ASU3(b)));}
AU4 AMaxSU4(AU4 a,AU4 b){return AU4(max(ASU4(a),ASU4(b)));}
AF1 AMed3F1(AF1 x,AF1 y,AF1 z){return max(min(x,y),min(max(x,y),z));}
AF2 AMed3F2(AF2 x,AF2 y,AF2 z){return max(min(x,y),min(max(x,y),z));}
AF3 AMed3F3(AF3 x,AF3 y,AF3 z){return max(min(x,y),min(max(x,y),z));}
AF4 AMed3F4(AF4 x,AF4 y,AF4 z){return max(min(x,y),min(max(x,y),z));}
AF1 AMin3F1(AF1 x,AF1 y,AF1 z){return min(x,min(y,z));}
AF2 AMin3F2(AF2 x,AF2 y,AF2 z){return min(x,min(y,z));}
AF3 AMin3F3(AF3 x,AF3 y,AF3 z){return min(x,min(y,z));}
AF4 AMin3F4(AF4 x,AF4 y,AF4 z){return min(x,min(y,z));}
AU1 AMin3SU1(AU1 x,AU1 y,AU1 z){return AU1(min(ASU1(x),min(ASU1(y),ASU1(z))));}
AU2 AMin3SU2(AU2 x,AU2 y,AU2 z){return AU2(min(ASU2(x),min(ASU2(y),ASU2(z))));}
AU3 AMin3SU3(AU3 x,AU3 y,AU3 z){return AU3(min(ASU3(x),min(ASU3(y),ASU3(z))));}
AU4 AMin3SU4(AU4 x,AU4 y,AU4 z){return AU4(min(ASU4(x),min(ASU4(y),ASU4(z))));}
AU1 AMin3U1(AU1 x,AU1 y,AU1 z){return min(x,min(y,z));}
AU2 AMin3U2(AU2 x,AU2 y,AU2 z){return min(x,min(y,z));}
AU3 AMin3U3(AU3 x,AU3 y,AU3 z){return min(x,min(y,z));}
AU4 AMin3U4(AU4 x,AU4 y,AU4 z){return min(x,min(y,z));}
AU1 AMinSU1(AU1 a,AU1 b){return AU1(min(ASU1(a),ASU1(b)));}
AU2 AMinSU2(AU2 a,AU2 b){return AU2(min(ASU2(a),ASU2(b)));}
AU3 AMinSU3(AU3 a,AU3 b){return AU3(min(ASU3(a),ASU3(b)));}
AU4 AMinSU4(AU4 a,AU4 b){return AU4(min(ASU4(a),ASU4(b)));}
AF1 ANCosF1(AF1 x){return cos(x*AF1_(A_2PI));}
AF2 ANCosF2(AF2 x){return cos(x*AF2_(A_2PI));}
AF3 ANCosF3(AF3 x){return cos(x*AF3_(A_2PI));}
AF4 ANCosF4(AF4 x){return cos(x*AF4_(A_2PI));}
AF1 ANSinF1(AF1 x){return sin(x*AF1_(A_2PI));}
AF2 ANSinF2(AF2 x){return sin(x*AF2_(A_2PI));}
AF3 ANSinF3(AF3 x){return sin(x*AF3_(A_2PI));}
AF4 ANSinF4(AF4 x){return sin(x*AF4_(A_2PI));}
AF1 ARcpF1(AF1 x){return rcp(x);}
AF2 ARcpF2(AF2 x){return rcp(x);}
AF3 ARcpF3(AF3 x){return rcp(x);}
AF4 ARcpF4(AF4 x){return rcp(x);}
AF1 ARsqF1(AF1 x){return rsqrt(x);}
AF2 ARsqF2(AF2 x){return rsqrt(x);}
AF3 ARsqF3(AF3 x){return rsqrt(x);}
AF4 ARsqF4(AF4 x){return rsqrt(x);}
AF1 ASatF1(AF1 x){return saturate(x);}
AF2 ASatF2(AF2 x){return saturate(x);}
AF3 ASatF3(AF3 x){return saturate(x);}
AF4 ASatF4(AF4 x){return saturate(x);}
AU1 AShrSU1(AU1 a,AU1 b){return AU1(ASU1(a)>>ASU1(b));}
AU2 AShrSU2(AU2 a,AU2 b){return AU2(ASU2(a)>>ASU2(b));}
AU3 AShrSU3(AU3 a,AU3 b){return AU3(ASU3(a)>>ASU3(b));}
AU4 AShrSU4(AU4 a,AU4 b){return AU4(ASU4(a)>>ASU4(b));}
#ifdef A_BYTE
#endif
#ifdef A_HALF
#ifdef A_HLSL_6_2
#define AH1 float16_t
#define AH2 float16_t2
#define AH3 float16_t3
#define AH4 float16_t4
#define AW1 uint16_t
#define AW2 uint16_t2
#define AW3 uint16_t3
#define AW4 uint16_t4
#define ASW1 int16_t
#define ASW2 int16_t2
#define ASW3 int16_t3
#define ASW4 int16_t4
#else
#define AH1 min16float
#define AH2 min16float2
#define AH3 min16float3
#define AH4 min16float4
#define AW1 min16uint
#define AW2 min16uint2
#define AW3 min16uint3
#define AW4 min16uint4
#define ASW1 min16int
#define ASW2 min16int2
#define ASW3 min16int3
#define ASW4 min16int4
#endif
AH2 AH2_AU1_x(AU1 x){AF2 t=f16tof32(AU2(x&0xFFFF,x>>16));return AH2(t);}
AH4 AH4_AU2_x(AU2 x){return AH4(AH2_AU1_x(x.x),AH2_AU1_x(x.y));}
AW2 AW2_AU1_x(AU1 x){AU2 t=AU2(x&0xFFFF,x>>16);return AW2(t);}
AW4 AW4_AU2_x(AU2 x){return AW4(AW2_AU1_x(x.x),AW2_AU1_x(x.y));}
#define AH2_AU1(x) AH2_AU1_x(AU1(x))
#define AH4_AU2(x) AH4_AU2_x(AU2(x))
#define AW2_AU1(x) AW2_AU1_x(AU1(x))
#define AW4_AU2(x) AW4_AU2_x(AU2(x))
AU1 AU1_AH2_x(AH2 x){return f32tof16(x.x)+(f32tof16(x.y)<<16);}
AU2 AU2_AH4_x(AH4 x){return AU2(AU1_AH2_x(x.xy),AU1_AH2_x(x.zw));}
AU1 AU1_AW2_x(AW2 x){return AU1(x.x)+(AU1(x.y)<<16);}
AU2 AU2_AW4_x(AW4 x){return AU2(AU1_AW2_x(x.xy),AU1_AW2_x(x.zw));}
#define AU1_AH2(x) AU1_AH2_x(AH2(x))
#define AU2_AH4(x) AU2_AH4_x(AH4(x))
#define AU1_AW2(x) AU1_AW2_x(AW2(x))
#define AU2_AW4(x) AU2_AW4_x(AW4(x))
#if defined(A_HLSL_6_2) && !defined(A_NO_16_BIT_CAST)
#define AW1_AH1(x) asuint16(x)
#define AW2_AH2(x) asuint16(x)
#define AW3_AH3(x) asuint16(x)
#define AW4_AH4(x) asuint16(x)
#else
#define AW1_AH1(a) AW1(f32tof16(AF1(a)))
#define AW2_AH2(a) AW2(AW1_AH1((a).x),AW1_AH1((a).y))
#define AW3_AH3(a) AW3(AW1_AH1((a).x),AW1_AH1((a).y),AW1_AH1((a).z))
#define AW4_AH4(a) AW4(AW1_AH1((a).x),AW1_AH1((a).y),AW1_AH1((a).z),AW1_AH1((a).w))
#endif
#if defined(A_HLSL_6_2) && !defined(A_NO_16_BIT_CAST)
#define AH1_AW1(x) asfloat16(x)
#define AH2_AW2(x) asfloat16(x)
#define AH3_AW3(x) asfloat16(x)
#define AH4_AW4(x) asfloat16(x)
#else
#define AH1_AW1(a) AH1(f16tof32(AU1(a)))
#define AH2_AW2(a) AH2(AH1_AW1((a).x),AH1_AW1((a).y))
#define AH3_AW3(a) AH3(AH1_AW1((a).x),AH1_AW1((a).y),AH1_AW1((a).z))
#define AH4_AW4(a) AH4(AH1_AW1((a).x),AH1_AW1((a).y),AH1_AW1((a).z),AH1_AW1((a).w))
#endif
AH1 AH1_x(AH1 a){return AH1(a);}
AH2 AH2_x(AH1 a){return AH2(a,a);}
AH3 AH3_x(AH1 a){return AH3(a,a,a);}
AH4 AH4_x(AH1 a){return AH4(a,a,a,a);}
#define AH1_(a) AH1_x(AH1(a))
#define AH2_(a) AH2_x(AH1(a))
#define AH3_(a) AH3_x(AH1(a))
#define AH4_(a) AH4_x(AH1(a))
AW1 AW1_x(AW1 a){return AW1(a);}
AW2 AW2_x(AW1 a){return AW2(a,a);}
AW3 AW3_x(AW1 a){return AW3(a,a,a);}
AW4 AW4_x(AW1 a){return AW4(a,a,a,a);}
#define AW1_(a) AW1_x(AW1(a))
#define AW2_(a) AW2_x(AW1(a))
#define AW3_(a) AW3_x(AW1(a))
#define AW4_(a) AW4_x(AW1(a))
AW1 AAbsSW1(AW1 a){return AW1(abs(ASW1(a)));}
AW2 AAbsSW2(AW2 a){return AW2(abs(ASW2(a)));}
AW3 AAbsSW3(AW3 a){return AW3(abs(ASW3(a)));}
AW4 AAbsSW4(AW4 a){return AW4(abs(ASW4(a)));}
AH1 AClampH1(AH1 x,AH1 n,AH1 m){return max(n,min(x,m));}
AH2 AClampH2(AH2 x,AH2 n,AH2 m){return max(n,min(x,m));}
AH3 AClampH3(AH3 x,AH3 n,AH3 m){return max(n,min(x,m));}
AH4 AClampH4(AH4 x,AH4 n,AH4 m){return max(n,min(x,m));}
AH1 AFractH1(AH1 x){return x-floor(x);}
AH2 AFractH2(AH2 x){return x-floor(x);}
AH3 AFractH3(AH3 x){return x-floor(x);}
AH4 AFractH4(AH4 x){return x-floor(x);}
AH1 ALerpH1(AH1 x,AH1 y,AH1 a){return lerp(x,y,a);}
AH2 ALerpH2(AH2 x,AH2 y,AH2 a){return lerp(x,y,a);}
AH3 ALerpH3(AH3 x,AH3 y,AH3 a){return lerp(x,y,a);}
AH4 ALerpH4(AH4 x,AH4 y,AH4 a){return lerp(x,y,a);}
AH1 AMax3H1(AH1 x,AH1 y,AH1 z){return max(x,max(y,z));}
AH2 AMax3H2(AH2 x,AH2 y,AH2 z){return max(x,max(y,z));}
AH3 AMax3H3(AH3 x,AH3 y,AH3 z){return max(x,max(y,z));}
AH4 AMax3H4(AH4 x,AH4 y,AH4 z){return max(x,max(y,z));}
AW1 AMaxSW1(AW1 a,AW1 b){return AW1(max(ASU1(a),ASU1(b)));}
AW2 AMaxSW2(AW2 a,AW2 b){return AW2(max(ASU2(a),ASU2(b)));}
AW3 AMaxSW3(AW3 a,AW3 b){return AW3(max(ASU3(a),ASU3(b)));}
AW4 AMaxSW4(AW4 a,AW4 b){return AW4(max(ASU4(a),ASU4(b)));}
AH1 AMin3H1(AH1 x,AH1 y,AH1 z){return min(x,min(y,z));}
AH2 AMin3H2(AH2 x,AH2 y,AH2 z){return min(x,min(y,z));}
AH3 AMin3H3(AH3 x,AH3 y,AH3 z){return min(x,min(y,z));}
AH4 AMin3H4(AH4 x,AH4 y,AH4 z){return min(x,min(y,z));}
AW1 AMinSW1(AW1 a,AW1 b){return AW1(min(ASU1(a),ASU1(b)));}
AW2 AMinSW2(AW2 a,AW2 b){return AW2(min(ASU2(a),ASU2(b)));}
AW3 AMinSW3(AW3 a,AW3 b){return AW3(min(ASU3(a),ASU3(b)));}
AW4 AMinSW4(AW4 a,AW4 b){return AW4(min(ASU4(a),ASU4(b)));}
AH1 ARcpH1(AH1 x){return rcp(x);}
AH2 ARcpH2(AH2 x){return rcp(x);}
AH3 ARcpH3(AH3 x){return rcp(x);}
AH4 ARcpH4(AH4 x){return rcp(x);}
AH1 ARsqH1(AH1 x){return rsqrt(x);}
AH2 ARsqH2(AH2 x){return rsqrt(x);}
AH3 ARsqH3(AH3 x){return rsqrt(x);}
AH4 ARsqH4(AH4 x){return rsqrt(x);}
AH1 ASatH1(AH1 x){return saturate(x);}
AH2 ASatH2(AH2 x){return saturate(x);}
AH3 ASatH3(AH3 x){return saturate(x);}
AH4 ASatH4(AH4 x){return saturate(x);}
AW1 AShrSW1(AW1 a,AW1 b){return AW1(ASW1(a)>>ASW1(b));}
AW2 AShrSW2(AW2 a,AW2 b){return AW2(ASW2(a)>>ASW2(b));}
AW3 AShrSW3(AW3 a,AW3 b){return AW3(ASW3(a)>>ASW3(b));}
AW4 AShrSW4(AW4 a,AW4 b){return AW4(ASW4(a)>>ASW4(b));}
#endif
)--RPCS3--"
R"--RPCS3--(
#ifdef A_DUBL
#ifdef A_HLSL_6_2
#define AD1 float64_t
#define AD2 float64_t2
#define AD3 float64_t3
#define AD4 float64_t4
#else
#define AD1 double
#define AD2 double2
#define AD3 double3
#define AD4 double4
#endif
AD1 AD1_x(AD1 a){return AD1(a);}
AD2 AD2_x(AD1 a){return AD2(a,a);}
AD3 AD3_x(AD1 a){return AD3(a,a,a);}
AD4 AD4_x(AD1 a){return AD4(a,a,a,a);}
#define AD1_(a) AD1_x(AD1(a))
#define AD2_(a) AD2_x(AD1(a))
#define AD3_(a) AD3_x(AD1(a))
#define AD4_(a) AD4_x(AD1(a))
AD1 AFractD1(AD1 a){return a-floor(a);}
AD2 AFractD2(AD2 a){return a-floor(a);}
AD3 AFractD3(AD3 a){return a-floor(a);}
AD4 AFractD4(AD4 a){return a-floor(a);}
AD1 ALerpD1(AD1 x,AD1 y,AD1 a){return lerp(x,y,a);}
AD2 ALerpD2(AD2 x,AD2 y,AD2 a){return lerp(x,y,a);}
AD3 ALerpD3(AD3 x,AD3 y,AD3 a){return lerp(x,y,a);}
AD4 ALerpD4(AD4 x,AD4 y,AD4 a){return lerp(x,y,a);}
AD1 ARcpD1(AD1 x){return rcp(x);}
AD2 ARcpD2(AD2 x){return rcp(x);}
AD3 ARcpD3(AD3 x){return rcp(x);}
AD4 ARcpD4(AD4 x){return rcp(x);}
AD1 ARsqD1(AD1 x){return rsqrt(x);}
AD2 ARsqD2(AD2 x){return rsqrt(x);}
AD3 ARsqD3(AD3 x){return rsqrt(x);}
AD4 ARsqD4(AD4 x){return rsqrt(x);}
AD1 ASatD1(AD1 x){return saturate(x);}
AD2 ASatD2(AD2 x){return saturate(x);}
AD3 ASatD3(AD3 x){return saturate(x);}
AD4 ASatD4(AD4 x){return saturate(x);}
#endif
#ifdef A_WAVE
AF1 AWaveXorF1(AF1 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
AF2 AWaveXorF2(AF2 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
AF3 AWaveXorF3(AF3 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
AF4 AWaveXorF4(AF4 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
AU1 AWaveXorU1(AU1 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
AU2 AWaveXorU1(AU2 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
AU3 AWaveXorU1(AU3 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
AU4 AWaveXorU1(AU4 v,AU1 x){return WaveReadLaneAt(v,WaveGetLaneIndex()^x);}
#ifdef A_HALF
AH2 AWaveXorH2(AH2 v,AU1 x){return AH2_AU1(WaveReadLaneAt(AU1_AH2(v),WaveGetLaneIndex()^x));}
AH4 AWaveXorH4(AH4 v,AU1 x){return AH4_AU2(WaveReadLaneAt(AU2_AH4(v),WaveGetLaneIndex()^x));}
AW2 AWaveXorW2(AW2 v,AU1 x){return AW2_AU1(WaveReadLaneAt(AU1_AW2(v),WaveGetLaneIndex()^x));}
AW4 AWaveXorW4(AW4 v,AU1 x){return AW4_AU1(WaveReadLaneAt(AU1_AW4(v),WaveGetLaneIndex()^x));}
#endif
#endif
#endif
#ifdef A_GPU
#define A_INFP_F AF1_AU1(0x7f800000u)
#define A_INFN_F AF1_AU1(0xff800000u)
AF1 ACpySgnF1(AF1 d,AF1 s){return AF1_AU1(AU1_AF1(d)|(AU1_AF1(s)&AU1_(0x80000000u)));}
AF2 ACpySgnF2(AF2 d,AF2 s){return AF2_AU2(AU2_AF2(d)|(AU2_AF2(s)&AU2_(0x80000000u)));}
AF3 ACpySgnF3(AF3 d,AF3 s){return AF3_AU3(AU3_AF3(d)|(AU3_AF3(s)&AU3_(0x80000000u)));}
AF4 ACpySgnF4(AF4 d,AF4 s){return AF4_AU4(AU4_AF4(d)|(AU4_AF4(s)&AU4_(0x80000000u)));}
AF1 ASignedF1(AF1 m){return ASatF1(m*AF1_(A_INFN_F));}
AF2 ASignedF2(AF2 m){return ASatF2(m*AF2_(A_INFN_F));}
AF3 ASignedF3(AF3 m){return ASatF3(m*AF3_(A_INFN_F));}
AF4 ASignedF4(AF4 m){return ASatF4(m*AF4_(A_INFN_F));}
AF1 AGtZeroF1(AF1 m){return ASatF1(m*AF1_(A_INFP_F));}
AF2 AGtZeroF2(AF2 m){return ASatF2(m*AF2_(A_INFP_F));}
AF3 AGtZeroF3(AF3 m){return ASatF3(m*AF3_(A_INFP_F));}
AF4 AGtZeroF4(AF4 m){return ASatF4(m*AF4_(A_INFP_F));}
#ifdef A_HALF
#ifdef A_HLSL_6_2
#define A_INFP_H AH1_AW1((uint16_t)0x7c00u)
#define A_INFN_H AH1_AW1((uint16_t)0xfc00u)
#else
#define A_INFP_H AH1_AW1(0x7c00u)
#define A_INFN_H AH1_AW1(0xfc00u)
#endif
AH1 ACpySgnH1(AH1 d,AH1 s){return AH1_AW1(AW1_AH1(d)|(AW1_AH1(s)&AW1_(0x8000u)));}
AH2 ACpySgnH2(AH2 d,AH2 s){return AH2_AW2(AW2_AH2(d)|(AW2_AH2(s)&AW2_(0x8000u)));}
AH3 ACpySgnH3(AH3 d,AH3 s){return AH3_AW3(AW3_AH3(d)|(AW3_AH3(s)&AW3_(0x8000u)));}
AH4 ACpySgnH4(AH4 d,AH4 s){return AH4_AW4(AW4_AH4(d)|(AW4_AH4(s)&AW4_(0x8000u)));}
AH1 ASignedH1(AH1 m){return ASatH1(m*AH1_(A_INFN_H));}
AH2 ASignedH2(AH2 m){return ASatH2(m*AH2_(A_INFN_H));}
AH3 ASignedH3(AH3 m){return ASatH3(m*AH3_(A_INFN_H));}
AH4 ASignedH4(AH4 m){return ASatH4(m*AH4_(A_INFN_H));}
AH1 AGtZeroH1(AH1 m){return ASatH1(m*AH1_(A_INFP_H));}
AH2 AGtZeroH2(AH2 m){return ASatH2(m*AH2_(A_INFP_H));}
AH3 AGtZeroH3(AH3 m){return ASatH3(m*AH3_(A_INFP_H));}
AH4 AGtZeroH4(AH4 m){return ASatH4(m*AH4_(A_INFP_H));}
#endif
AU1 AFisToU1(AU1 x){return x^(( AShrSU1(x,AU1_(31)))|AU1_(0x80000000));}
AU1 AFisFromU1(AU1 x){return x^((~AShrSU1(x,AU1_(31)))|AU1_(0x80000000));}
AU1 AFisToHiU1(AU1 x){return x^(( AShrSU1(x,AU1_(15)))|AU1_(0x80000000));}
AU1 AFisFromHiU1(AU1 x){return x^((~AShrSU1(x,AU1_(15)))|AU1_(0x80000000));}
#ifdef A_HALF
AW1 AFisToW1(AW1 x){return x^(( AShrSW1(x,AW1_(15)))|AW1_(0x8000));}
AW1 AFisFromW1(AW1 x){return x^((~AShrSW1(x,AW1_(15)))|AW1_(0x8000));}
AW2 AFisToW2(AW2 x){return x^(( AShrSW2(x,AW2_(15)))|AW2_(0x8000));}
AW2 AFisFromW2(AW2 x){return x^((~AShrSW2(x,AW2_(15)))|AW2_(0x8000));}
#endif
#ifdef A_HALF
AU1 APerm0E0A(AU2 i){return((i.x )&0xffu)|((i.y<<16)&0xff0000u);}
AU1 APerm0F0B(AU2 i){return((i.x>> 8)&0xffu)|((i.y<< 8)&0xff0000u);}
AU1 APerm0G0C(AU2 i){return((i.x>>16)&0xffu)|((i.y )&0xff0000u);}
AU1 APerm0H0D(AU2 i){return((i.x>>24)&0xffu)|((i.y>> 8)&0xff0000u);}
AU1 APermHGFA(AU2 i){return((i.x )&0x000000ffu)|(i.y&0xffffff00u);}
AU1 APermHGFC(AU2 i){return((i.x>>16)&0x000000ffu)|(i.y&0xffffff00u);}
AU1 APermHGAE(AU2 i){return((i.x<< 8)&0x0000ff00u)|(i.y&0xffff00ffu);}
AU1 APermHGCE(AU2 i){return((i.x>> 8)&0x0000ff00u)|(i.y&0xffff00ffu);}
AU1 APermHAFE(AU2 i){return((i.x<<16)&0x00ff0000u)|(i.y&0xff00ffffu);}
AU1 APermHCFE(AU2 i){return((i.x )&0x00ff0000u)|(i.y&0xff00ffffu);}
AU1 APermAGFE(AU2 i){return((i.x<<24)&0xff000000u)|(i.y&0x00ffffffu);}
AU1 APermCGFE(AU2 i){return((i.x<< 8)&0xff000000u)|(i.y&0x00ffffffu);}
AU1 APermGCEA(AU2 i){return((i.x)&0x00ff00ffu)|((i.y<<8)&0xff00ff00u);}
AU1 APermGECA(AU2 i){return(((i.x)&0xffu)|((i.x>>8)&0xff00u)|((i.y<<16)&0xff0000u)|((i.y<<8)&0xff000000u));}
#endif
#define A_BUC_32 (255.0)
#define A_BUC_16 (255.0/512.0)
#if 1
AU1 ABuc0ToU1(AU1 d,AF1 i){return (d&0xffffff00u)|((min(AU1(i),255u) )&(0x000000ffu));}
AU1 ABuc1ToU1(AU1 d,AF1 i){return (d&0xffff00ffu)|((min(AU1(i),255u)<< 8)&(0x0000ff00u));}
AU1 ABuc2ToU1(AU1 d,AF1 i){return (d&0xff00ffffu)|((min(AU1(i),255u)<<16)&(0x00ff0000u));}
AU1 ABuc3ToU1(AU1 d,AF1 i){return (d&0x00ffffffu)|((min(AU1(i),255u)<<24)&(0xff000000u));}
AF1 ABuc0FromU1(AU1 i){return AF1((i )&255u);}
AF1 ABuc1FromU1(AU1 i){return AF1((i>> 8)&255u);}
AF1 ABuc2FromU1(AU1 i){return AF1((i>>16)&255u);}
AF1 ABuc3FromU1(AU1 i){return AF1((i>>24)&255u);}
#endif
#ifdef A_HALF
AW2 ABuc01ToW2(AH2 x,AH2 y){x*=AH2_(1.0/32768.0);y*=AH2_(1.0/32768.0);
return AW2_AU1(APermGCEA(AU2(AU1_AW2(AW2_AH2(x)),AU1_AW2(AW2_AH2(y)))));}
AU2 ABuc0ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)));
return AU2(APermHGFA(AU2(d.x,b)),APermHGFC(AU2(d.y,b)));}
AU2 ABuc1ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)));
return AU2(APermHGAE(AU2(d.x,b)),APermHGCE(AU2(d.y,b)));}
AU2 ABuc2ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)));
return AU2(APermHAFE(AU2(d.x,b)),APermHCFE(AU2(d.y,b)));}
AU2 ABuc3ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)));
return AU2(APermAGFE(AU2(d.x,b)),APermCGFE(AU2(d.y,b)));}
AH2 ABuc0FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0E0A(i)))*AH2_(32768.0);}
AH2 ABuc1FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0F0B(i)))*AH2_(32768.0);}
AH2 ABuc2FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0G0C(i)))*AH2_(32768.0);}
AH2 ABuc3FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0H0D(i)))*AH2_(32768.0);}
#endif
#define A_BSC_32 (127.0)
#define A_BSC_16 (127.0/512.0)
#if 1
AU1 ABsc0ToU1(AU1 d,AF1 i){return (d&0xffffff00u)|((min(AU1(i+128.0),255u) )&(0x000000ffu));}
AU1 ABsc1ToU1(AU1 d,AF1 i){return (d&0xffff00ffu)|((min(AU1(i+128.0),255u)<< 8)&(0x0000ff00u));}
AU1 ABsc2ToU1(AU1 d,AF1 i){return (d&0xff00ffffu)|((min(AU1(i+128.0),255u)<<16)&(0x00ff0000u));}
AU1 ABsc3ToU1(AU1 d,AF1 i){return (d&0x00ffffffu)|((min(AU1(i+128.0),255u)<<24)&(0xff000000u));}
AU1 ABsc0ToZbU1(AU1 d,AF1 i){return ((d&0xffffff00u)|((min(AU1(trunc(i)+128.0),255u) )&(0x000000ffu)))^0x00000080u;}
AU1 ABsc1ToZbU1(AU1 d,AF1 i){return ((d&0xffff00ffu)|((min(AU1(trunc(i)+128.0),255u)<< 8)&(0x0000ff00u)))^0x00008000u;}
AU1 ABsc2ToZbU1(AU1 d,AF1 i){return ((d&0xff00ffffu)|((min(AU1(trunc(i)+128.0),255u)<<16)&(0x00ff0000u)))^0x00800000u;}
AU1 ABsc3ToZbU1(AU1 d,AF1 i){return ((d&0x00ffffffu)|((min(AU1(trunc(i)+128.0),255u)<<24)&(0xff000000u)))^0x80000000u;}
AF1 ABsc0FromU1(AU1 i){return AF1((i )&255u)-128.0;}
AF1 ABsc1FromU1(AU1 i){return AF1((i>> 8)&255u)-128.0;}
AF1 ABsc2FromU1(AU1 i){return AF1((i>>16)&255u)-128.0;}
AF1 ABsc3FromU1(AU1 i){return AF1((i>>24)&255u)-128.0;}
AF1 ABsc0FromZbU1(AU1 i){return AF1(((i )&255u)^0x80u)-128.0;}
AF1 ABsc1FromZbU1(AU1 i){return AF1(((i>> 8)&255u)^0x80u)-128.0;}
AF1 ABsc2FromZbU1(AU1 i){return AF1(((i>>16)&255u)^0x80u)-128.0;}
AF1 ABsc3FromZbU1(AU1 i){return AF1(((i>>24)&255u)^0x80u)-128.0;}
#endif
#ifdef A_HALF
AW2 ABsc01ToW2(AH2 x,AH2 y){x=x*AH2_(1.0/32768.0)+AH2_(0.25/32768.0);y=y*AH2_(1.0/32768.0)+AH2_(0.25/32768.0);
return AW2_AU1(APermGCEA(AU2(AU1_AW2(AW2_AH2(x)),AU1_AW2(AW2_AH2(y)))));}
AU2 ABsc0ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0)));
return AU2(APermHGFA(AU2(d.x,b)),APermHGFC(AU2(d.y,b)));}
AU2 ABsc1ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0)));
return AU2(APermHGAE(AU2(d.x,b)),APermHGCE(AU2(d.y,b)));}
AU2 ABsc2ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0)));
return AU2(APermHAFE(AU2(d.x,b)),APermHCFE(AU2(d.y,b)));}
AU2 ABsc3ToU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0)));
return AU2(APermAGFE(AU2(d.x,b)),APermCGFE(AU2(d.y,b)));}
AU2 ABsc0ToZbU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0)))^0x00800080u;
return AU2(APermHGFA(AU2(d.x,b)),APermHGFC(AU2(d.y,b)));}
AU2 ABsc1ToZbU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0)))^0x00800080u;
return AU2(APermHGAE(AU2(d.x,b)),APermHGCE(AU2(d.y,b)));}
AU2 ABsc2ToZbU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0)))^0x00800080u;
return AU2(APermHAFE(AU2(d.x,b)),APermHCFE(AU2(d.y,b)));}
AU2 ABsc3ToZbU2(AU2 d,AH2 i){AU1 b=AU1_AW2(AW2_AH2(i*AH2_(1.0/32768.0)+AH2_(0.25/32768.0)))^0x00800080u;
return AU2(APermAGFE(AU2(d.x,b)),APermCGFE(AU2(d.y,b)));}
AH2 ABsc0FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0E0A(i)))*AH2_(32768.0)-AH2_(0.25);}
AH2 ABsc1FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0F0B(i)))*AH2_(32768.0)-AH2_(0.25);}
AH2 ABsc2FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0G0C(i)))*AH2_(32768.0)-AH2_(0.25);}
AH2 ABsc3FromU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0H0D(i)))*AH2_(32768.0)-AH2_(0.25);}
AH2 ABsc0FromZbU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0E0A(i)^0x00800080u))*AH2_(32768.0)-AH2_(0.25);}
AH2 ABsc1FromZbU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0F0B(i)^0x00800080u))*AH2_(32768.0)-AH2_(0.25);}
AH2 ABsc2FromZbU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0G0C(i)^0x00800080u))*AH2_(32768.0)-AH2_(0.25);}
AH2 ABsc3FromZbU2(AU2 i){return AH2_AW2(AW2_AU1(APerm0H0D(i)^0x00800080u))*AH2_(32768.0)-AH2_(0.25);}
#endif
#ifdef A_HALF
AH1 APrxLoSqrtH1(AH1 a){return AH1_AW1((AW1_AH1(a)>>AW1_(1))+AW1_(0x1de2));}
AH2 APrxLoSqrtH2(AH2 a){return AH2_AW2((AW2_AH2(a)>>AW2_(1))+AW2_(0x1de2));}
AH3 APrxLoSqrtH3(AH3 a){return AH3_AW3((AW3_AH3(a)>>AW3_(1))+AW3_(0x1de2));}
AH4 APrxLoSqrtH4(AH4 a){return AH4_AW4((AW4_AH4(a)>>AW4_(1))+AW4_(0x1de2));}
AH1 APrxLoRcpH1(AH1 a){return AH1_AW1(AW1_(0x7784)-AW1_AH1(a));}
AH2 APrxLoRcpH2(AH2 a){return AH2_AW2(AW2_(0x7784)-AW2_AH2(a));}
AH3 APrxLoRcpH3(AH3 a){return AH3_AW3(AW3_(0x7784)-AW3_AH3(a));}
AH4 APrxLoRcpH4(AH4 a){return AH4_AW4(AW4_(0x7784)-AW4_AH4(a));}
AH1 APrxMedRcpH1(AH1 a){AH1 b=AH1_AW1(AW1_(0x778d)-AW1_AH1(a));return b*(-b*a+AH1_(2.0));}
AH2 APrxMedRcpH2(AH2 a){AH2 b=AH2_AW2(AW2_(0x778d)-AW2_AH2(a));return b*(-b*a+AH2_(2.0));}
AH3 APrxMedRcpH3(AH3 a){AH3 b=AH3_AW3(AW3_(0x778d)-AW3_AH3(a));return b*(-b*a+AH3_(2.0));}
AH4 APrxMedRcpH4(AH4 a){AH4 b=AH4_AW4(AW4_(0x778d)-AW4_AH4(a));return b*(-b*a+AH4_(2.0));}
AH1 APrxLoRsqH1(AH1 a){return AH1_AW1(AW1_(0x59a3)-(AW1_AH1(a)>>AW1_(1)));}
AH2 APrxLoRsqH2(AH2 a){return AH2_AW2(AW2_(0x59a3)-(AW2_AH2(a)>>AW2_(1)));}
AH3 APrxLoRsqH3(AH3 a){return AH3_AW3(AW3_(0x59a3)-(AW3_AH3(a)>>AW3_(1)));}
AH4 APrxLoRsqH4(AH4 a){return AH4_AW4(AW4_(0x59a3)-(AW4_AH4(a)>>AW4_(1)));}
#endif
)--RPCS3--"
R"--RPCS3--(
AF1 APrxLoSqrtF1(AF1 a){return AF1_AU1((AU1_AF1(a)>>AU1_(1))+AU1_(0x1fbc4639));}
AF1 APrxLoRcpF1(AF1 a){return AF1_AU1(AU1_(0x7ef07ebb)-AU1_AF1(a));}
AF1 APrxMedRcpF1(AF1 a){AF1 b=AF1_AU1(AU1_(0x7ef19fff)-AU1_AF1(a));return b*(-b*a+AF1_(2.0));}
AF1 APrxLoRsqF1(AF1 a){return AF1_AU1(AU1_(0x5f347d74)-(AU1_AF1(a)>>AU1_(1)));}
AF2 APrxLoSqrtF2(AF2 a){return AF2_AU2((AU2_AF2(a)>>AU2_(1))+AU2_(0x1fbc4639));}
AF2 APrxLoRcpF2(AF2 a){return AF2_AU2(AU2_(0x7ef07ebb)-AU2_AF2(a));}
AF2 APrxMedRcpF2(AF2 a){AF2 b=AF2_AU2(AU2_(0x7ef19fff)-AU2_AF2(a));return b*(-b*a+AF2_(2.0));}
AF2 APrxLoRsqF2(AF2 a){return AF2_AU2(AU2_(0x5f347d74)-(AU2_AF2(a)>>AU2_(1)));}
AF3 APrxLoSqrtF3(AF3 a){return AF3_AU3((AU3_AF3(a)>>AU3_(1))+AU3_(0x1fbc4639));}
AF3 APrxLoRcpF3(AF3 a){return AF3_AU3(AU3_(0x7ef07ebb)-AU3_AF3(a));}
AF3 APrxMedRcpF3(AF3 a){AF3 b=AF3_AU3(AU3_(0x7ef19fff)-AU3_AF3(a));return b*(-b*a+AF3_(2.0));}
AF3 APrxLoRsqF3(AF3 a){return AF3_AU3(AU3_(0x5f347d74)-(AU3_AF3(a)>>AU3_(1)));}
AF4 APrxLoSqrtF4(AF4 a){return AF4_AU4((AU4_AF4(a)>>AU4_(1))+AU4_(0x1fbc4639));}
AF4 APrxLoRcpF4(AF4 a){return AF4_AU4(AU4_(0x7ef07ebb)-AU4_AF4(a));}
AF4 APrxMedRcpF4(AF4 a){AF4 b=AF4_AU4(AU4_(0x7ef19fff)-AU4_AF4(a));return b*(-b*a+AF4_(2.0));}
AF4 APrxLoRsqF4(AF4 a){return AF4_AU4(AU4_(0x5f347d74)-(AU4_AF4(a)>>AU4_(1)));}
AF1 Quart(AF1 a) { a = a * a; return a * a;}
AF1 Oct(AF1 a) { a = a * a; a = a * a; return a * a; }
AF2 Quart(AF2 a) { a = a * a; return a * a; }
AF2 Oct(AF2 a) { a = a * a; a = a * a; return a * a; }
AF3 Quart(AF3 a) { a = a * a; return a * a; }
AF3 Oct(AF3 a) { a = a * a; a = a * a; return a * a; }
AF4 Quart(AF4 a) { a = a * a; return a * a; }
AF4 Oct(AF4 a) { a = a * a; a = a * a; return a * a; }
AF1 APrxPQToGamma2(AF1 a) { return Quart(a); }
AF1 APrxPQToLinear(AF1 a) { return Oct(a); }
AF1 APrxLoGamma2ToPQ(AF1 a) { return AF1_AU1((AU1_AF1(a) >> AU1_(2)) + AU1_(0x2F9A4E46)); }
AF1 APrxMedGamma2ToPQ(AF1 a) { AF1 b = AF1_AU1((AU1_AF1(a) >> AU1_(2)) + AU1_(0x2F9A4E46)); AF1 b4 = Quart(b); return b - b * (b4 - a) / (AF1_(4.0) * b4); }
AF1 APrxHighGamma2ToPQ(AF1 a) { return sqrt(sqrt(a)); }
AF1 APrxLoLinearToPQ(AF1 a) { return AF1_AU1((AU1_AF1(a) >> AU1_(3)) + AU1_(0x378D8723)); }
AF1 APrxMedLinearToPQ(AF1 a) { AF1 b = AF1_AU1((AU1_AF1(a) >> AU1_(3)) + AU1_(0x378D8723)); AF1 b8 = Oct(b); return b - b * (b8 - a) / (AF1_(8.0) * b8); }
AF1 APrxHighLinearToPQ(AF1 a) { return sqrt(sqrt(sqrt(a))); }
AF2 APrxPQToGamma2(AF2 a) { return Quart(a); }
AF2 APrxPQToLinear(AF2 a) { return Oct(a); }
AF2 APrxLoGamma2ToPQ(AF2 a) { return AF2_AU2((AU2_AF2(a) >> AU2_(2)) + AU2_(0x2F9A4E46)); }
AF2 APrxMedGamma2ToPQ(AF2 a) { AF2 b = AF2_AU2((AU2_AF2(a) >> AU2_(2)) + AU2_(0x2F9A4E46)); AF2 b4 = Quart(b); return b - b * (b4 - a) / (AF1_(4.0) * b4); }
AF2 APrxHighGamma2ToPQ(AF2 a) { return sqrt(sqrt(a)); }
AF2 APrxLoLinearToPQ(AF2 a) { return AF2_AU2((AU2_AF2(a) >> AU2_(3)) + AU2_(0x378D8723)); }
AF2 APrxMedLinearToPQ(AF2 a) { AF2 b = AF2_AU2((AU2_AF2(a) >> AU2_(3)) + AU2_(0x378D8723)); AF2 b8 = Oct(b); return b - b * (b8 - a) / (AF1_(8.0) * b8); }
AF2 APrxHighLinearToPQ(AF2 a) { return sqrt(sqrt(sqrt(a))); }
AF3 APrxPQToGamma2(AF3 a) { return Quart(a); }
AF3 APrxPQToLinear(AF3 a) { return Oct(a); }
AF3 APrxLoGamma2ToPQ(AF3 a) { return AF3_AU3((AU3_AF3(a) >> AU3_(2)) + AU3_(0x2F9A4E46)); }
AF3 APrxMedGamma2ToPQ(AF3 a) { AF3 b = AF3_AU3((AU3_AF3(a) >> AU3_(2)) + AU3_(0x2F9A4E46)); AF3 b4 = Quart(b); return b - b * (b4 - a) / (AF1_(4.0) * b4); }
AF3 APrxHighGamma2ToPQ(AF3 a) { return sqrt(sqrt(a)); }
AF3 APrxLoLinearToPQ(AF3 a) { return AF3_AU3((AU3_AF3(a) >> AU3_(3)) + AU3_(0x378D8723)); }
AF3 APrxMedLinearToPQ(AF3 a) { AF3 b = AF3_AU3((AU3_AF3(a) >> AU3_(3)) + AU3_(0x378D8723)); AF3 b8 = Oct(b); return b - b * (b8 - a) / (AF1_(8.0) * b8); }
AF3 APrxHighLinearToPQ(AF3 a) { return sqrt(sqrt(sqrt(a))); }
AF4 APrxPQToGamma2(AF4 a) { return Quart(a); }
AF4 APrxPQToLinear(AF4 a) { return Oct(a); }
AF4 APrxLoGamma2ToPQ(AF4 a) { return AF4_AU4((AU4_AF4(a) >> AU4_(2)) + AU4_(0x2F9A4E46)); }
AF4 APrxMedGamma2ToPQ(AF4 a) { AF4 b = AF4_AU4((AU4_AF4(a) >> AU4_(2)) + AU4_(0x2F9A4E46)); AF4 b4 = Quart(b); return b - b * (b4 - a) / (AF1_(4.0) * b4); }
AF4 APrxHighGamma2ToPQ(AF4 a) { return sqrt(sqrt(a)); }
AF4 APrxLoLinearToPQ(AF4 a) { return AF4_AU4((AU4_AF4(a) >> AU4_(3)) + AU4_(0x378D8723)); }
AF4 APrxMedLinearToPQ(AF4 a) { AF4 b = AF4_AU4((AU4_AF4(a) >> AU4_(3)) + AU4_(0x378D8723)); AF4 b8 = Oct(b); return b - b * (b8 - a) / (AF1_(8.0) * b8); }
AF4 APrxHighLinearToPQ(AF4 a) { return sqrt(sqrt(sqrt(a))); }
#if 1
AF1 APSinF1(AF1 x){return x*abs(x)-x;} // MAD.
AF2 APSinF2(AF2 x){return x*abs(x)-x;}
AF1 APCosF1(AF1 x){x=AFractF1(x*AF1_(0.5)+AF1_(0.75));x=x*AF1_(2.0)-AF1_(1.0);return APSinF1(x);} // 3x MAD, FRACT
AF2 APCosF2(AF2 x){x=AFractF2(x*AF2_(0.5)+AF2_(0.75));x=x*AF2_(2.0)-AF2_(1.0);return APSinF2(x);}
AF2 APSinCosF1(AF1 x){AF1 y=AFractF1(x*AF1_(0.5)+AF1_(0.75));y=y*AF1_(2.0)-AF1_(1.0);return APSinF2(AF2(x,y));}
#endif
#ifdef A_HALF
AH1 APSinH1(AH1 x){return x*abs(x)-x;}
AH2 APSinH2(AH2 x){return x*abs(x)-x;} // AND,FMA
AH1 APCosH1(AH1 x){x=AFractH1(x*AH1_(0.5)+AH1_(0.75));x=x*AH1_(2.0)-AH1_(1.0);return APSinH1(x);}
AH2 APCosH2(AH2 x){x=AFractH2(x*AH2_(0.5)+AH2_(0.75));x=x*AH2_(2.0)-AH2_(1.0);return APSinH2(x);} // 3x FMA, 2xFRACT, AND
AH2 APSinCosH1(AH1 x){AH1 y=AFractH1(x*AH1_(0.5)+AH1_(0.75));y=y*AH1_(2.0)-AH1_(1.0);return APSinH2(AH2(x,y));}
#endif
#if 1
AU1 AZolAndU1(AU1 x,AU1 y){return min(x,y);}
AU2 AZolAndU2(AU2 x,AU2 y){return min(x,y);}
AU3 AZolAndU3(AU3 x,AU3 y){return min(x,y);}
AU4 AZolAndU4(AU4 x,AU4 y){return min(x,y);}
AU1 AZolNotU1(AU1 x){return x^AU1_(1);}
AU2 AZolNotU2(AU2 x){return x^AU2_(1);}
AU3 AZolNotU3(AU3 x){return x^AU3_(1);}
AU4 AZolNotU4(AU4 x){return x^AU4_(1);}
AU1 AZolOrU1(AU1 x,AU1 y){return max(x,y);}
AU2 AZolOrU2(AU2 x,AU2 y){return max(x,y);}
AU3 AZolOrU3(AU3 x,AU3 y){return max(x,y);}
AU4 AZolOrU4(AU4 x,AU4 y){return max(x,y);}
AU1 AZolF1ToU1(AF1 x){return AU1(x);}
AU2 AZolF2ToU2(AF2 x){return AU2(x);}
AU3 AZolF3ToU3(AF3 x){return AU3(x);}
AU4 AZolF4ToU4(AF4 x){return AU4(x);}
AU1 AZolNotF1ToU1(AF1 x){return AU1(AF1_(1.0)-x);}
AU2 AZolNotF2ToU2(AF2 x){return AU2(AF2_(1.0)-x);}
AU3 AZolNotF3ToU3(AF3 x){return AU3(AF3_(1.0)-x);}
AU4 AZolNotF4ToU4(AF4 x){return AU4(AF4_(1.0)-x);}
AF1 AZolU1ToF1(AU1 x){return AF1(x);}
AF2 AZolU2ToF2(AU2 x){return AF2(x);}
AF3 AZolU3ToF3(AU3 x){return AF3(x);}
AF4 AZolU4ToF4(AU4 x){return AF4(x);}
AF1 AZolAndF1(AF1 x,AF1 y){return min(x,y);}
AF2 AZolAndF2(AF2 x,AF2 y){return min(x,y);}
AF3 AZolAndF3(AF3 x,AF3 y){return min(x,y);}
AF4 AZolAndF4(AF4 x,AF4 y){return min(x,y);}
AF1 ASolAndNotF1(AF1 x,AF1 y){return (-x)*y+AF1_(1.0);}
AF2 ASolAndNotF2(AF2 x,AF2 y){return (-x)*y+AF2_(1.0);}
AF3 ASolAndNotF3(AF3 x,AF3 y){return (-x)*y+AF3_(1.0);}
AF4 ASolAndNotF4(AF4 x,AF4 y){return (-x)*y+AF4_(1.0);}
AF1 AZolAndOrF1(AF1 x,AF1 y,AF1 z){return ASatF1(x*y+z);}
AF2 AZolAndOrF2(AF2 x,AF2 y,AF2 z){return ASatF2(x*y+z);}
AF3 AZolAndOrF3(AF3 x,AF3 y,AF3 z){return ASatF3(x*y+z);}
AF4 AZolAndOrF4(AF4 x,AF4 y,AF4 z){return ASatF4(x*y+z);}
AF1 AZolGtZeroF1(AF1 x){return ASatF1(x*AF1_(A_INFP_F));}
AF2 AZolGtZeroF2(AF2 x){return ASatF2(x*AF2_(A_INFP_F));}
AF3 AZolGtZeroF3(AF3 x){return ASatF3(x*AF3_(A_INFP_F));}
AF4 AZolGtZeroF4(AF4 x){return ASatF4(x*AF4_(A_INFP_F));}
AF1 AZolNotF1(AF1 x){return AF1_(1.0)-x;}
AF2 AZolNotF2(AF2 x){return AF2_(1.0)-x;}
AF3 AZolNotF3(AF3 x){return AF3_(1.0)-x;}
AF4 AZolNotF4(AF4 x){return AF4_(1.0)-x;}
AF1 AZolOrF1(AF1 x,AF1 y){return max(x,y);}
AF2 AZolOrF2(AF2 x,AF2 y){return max(x,y);}
AF3 AZolOrF3(AF3 x,AF3 y){return max(x,y);}
AF4 AZolOrF4(AF4 x,AF4 y){return max(x,y);}
AF1 AZolSelF1(AF1 x,AF1 y,AF1 z){AF1 r=(-x)*z+z;return x*y+r;}
AF2 AZolSelF2(AF2 x,AF2 y,AF2 z){AF2 r=(-x)*z+z;return x*y+r;}
AF3 AZolSelF3(AF3 x,AF3 y,AF3 z){AF3 r=(-x)*z+z;return x*y+r;}
AF4 AZolSelF4(AF4 x,AF4 y,AF4 z){AF4 r=(-x)*z+z;return x*y+r;}
AF1 AZolSignedF1(AF1 x){return ASatF1(x*AF1_(A_INFN_F));}
AF2 AZolSignedF2(AF2 x){return ASatF2(x*AF2_(A_INFN_F));}
AF3 AZolSignedF3(AF3 x){return ASatF3(x*AF3_(A_INFN_F));}
AF4 AZolSignedF4(AF4 x){return ASatF4(x*AF4_(A_INFN_F));}
AF1 AZolZeroPassF1(AF1 x,AF1 y){return AF1_AU1((AU1_AF1(x)!=AU1_(0))?AU1_(0):AU1_AF1(y));}
AF2 AZolZeroPassF2(AF2 x,AF2 y){return AF2_AU2((AU2_AF2(x)!=AU2_(0))?AU2_(0):AU2_AF2(y));}
AF3 AZolZeroPassF3(AF3 x,AF3 y){return AF3_AU3((AU3_AF3(x)!=AU3_(0))?AU3_(0):AU3_AF3(y));}
AF4 AZolZeroPassF4(AF4 x,AF4 y){return AF4_AU4((AU4_AF4(x)!=AU4_(0))?AU4_(0):AU4_AF4(y));}
#endif
#ifdef A_HALF
AW1 AZolAndW1(AW1 x,AW1 y){return min(x,y);}
AW2 AZolAndW2(AW2 x,AW2 y){return min(x,y);}
AW3 AZolAndW3(AW3 x,AW3 y){return min(x,y);}
AW4 AZolAndW4(AW4 x,AW4 y){return min(x,y);}
AW1 AZolNotW1(AW1 x){return x^AW1_(1);}
AW2 AZolNotW2(AW2 x){return x^AW2_(1);}
AW3 AZolNotW3(AW3 x){return x^AW3_(1);}
AW4 AZolNotW4(AW4 x){return x^AW4_(1);}
AW1 AZolOrW1(AW1 x,AW1 y){return max(x,y);}
AW2 AZolOrW2(AW2 x,AW2 y){return max(x,y);}
AW3 AZolOrW3(AW3 x,AW3 y){return max(x,y);}
AW4 AZolOrW4(AW4 x,AW4 y){return max(x,y);}
AW1 AZolH1ToW1(AH1 x){return AW1_AH1(x*AH1_AW1(AW1_(1)));}
AW2 AZolH2ToW2(AH2 x){return AW2_AH2(x*AH2_AW2(AW2_(1)));}
AW3 AZolH3ToW3(AH3 x){return AW3_AH3(x*AH3_AW3(AW3_(1)));}
AW4 AZolH4ToW4(AH4 x){return AW4_AH4(x*AH4_AW4(AW4_(1)));}
AH1 AZolW1ToH1(AW1 x){return AH1_AW1(x*AW1_AH1(AH1_(1.0)));}
AH2 AZolW2ToH2(AW2 x){return AH2_AW2(x*AW2_AH2(AH2_(1.0)));}
AH3 AZolW1ToH3(AW3 x){return AH3_AW3(x*AW3_AH3(AH3_(1.0)));}
AH4 AZolW2ToH4(AW4 x){return AH4_AW4(x*AW4_AH4(AH4_(1.0)));}
AH1 AZolAndH1(AH1 x,AH1 y){return min(x,y);}
AH2 AZolAndH2(AH2 x,AH2 y){return min(x,y);}
AH3 AZolAndH3(AH3 x,AH3 y){return min(x,y);}
AH4 AZolAndH4(AH4 x,AH4 y){return min(x,y);}
AH1 ASolAndNotH1(AH1 x,AH1 y){return (-x)*y+AH1_(1.0);}
AH2 ASolAndNotH2(AH2 x,AH2 y){return (-x)*y+AH2_(1.0);}
AH3 ASolAndNotH3(AH3 x,AH3 y){return (-x)*y+AH3_(1.0);}
AH4 ASolAndNotH4(AH4 x,AH4 y){return (-x)*y+AH4_(1.0);}
AH1 AZolAndOrH1(AH1 x,AH1 y,AH1 z){return ASatH1(x*y+z);}
AH2 AZolAndOrH2(AH2 x,AH2 y,AH2 z){return ASatH2(x*y+z);}
AH3 AZolAndOrH3(AH3 x,AH3 y,AH3 z){return ASatH3(x*y+z);}
AH4 AZolAndOrH4(AH4 x,AH4 y,AH4 z){return ASatH4(x*y+z);}
AH1 AZolGtZeroH1(AH1 x){return ASatH1(x*AH1_(A_INFP_H));}
AH2 AZolGtZeroH2(AH2 x){return ASatH2(x*AH2_(A_INFP_H));}
AH3 AZolGtZeroH3(AH3 x){return ASatH3(x*AH3_(A_INFP_H));}
AH4 AZolGtZeroH4(AH4 x){return ASatH4(x*AH4_(A_INFP_H));}
AH1 AZolNotH1(AH1 x){return AH1_(1.0)-x;}
AH2 AZolNotH2(AH2 x){return AH2_(1.0)-x;}
AH3 AZolNotH3(AH3 x){return AH3_(1.0)-x;}
AH4 AZolNotH4(AH4 x){return AH4_(1.0)-x;}
AH1 AZolOrH1(AH1 x,AH1 y){return max(x,y);}
AH2 AZolOrH2(AH2 x,AH2 y){return max(x,y);}
AH3 AZolOrH3(AH3 x,AH3 y){return max(x,y);}
AH4 AZolOrH4(AH4 x,AH4 y){return max(x,y);}
AH1 AZolSelH1(AH1 x,AH1 y,AH1 z){AH1 r=(-x)*z+z;return x*y+r;}
AH2 AZolSelH2(AH2 x,AH2 y,AH2 z){AH2 r=(-x)*z+z;return x*y+r;}
AH3 AZolSelH3(AH3 x,AH3 y,AH3 z){AH3 r=(-x)*z+z;return x*y+r;}
AH4 AZolSelH4(AH4 x,AH4 y,AH4 z){AH4 r=(-x)*z+z;return x*y+r;}
AH1 AZolSignedH1(AH1 x){return ASatH1(x*AH1_(A_INFN_H));}
AH2 AZolSignedH2(AH2 x){return ASatH2(x*AH2_(A_INFN_H));}
AH3 AZolSignedH3(AH3 x){return ASatH3(x*AH3_(A_INFN_H));}
AH4 AZolSignedH4(AH4 x){return ASatH4(x*AH4_(A_INFN_H));}
#endif
#if 1
AF1 ATo709F1(AF1 c){AF3 j=AF3(0.018*4.5,4.5,0.45);AF2 k=AF2(1.099,-0.099);
return clamp(j.x ,c*j.y ,pow(c,j.z )*k.x +k.y );}
AF2 ATo709F2(AF2 c){AF3 j=AF3(0.018*4.5,4.5,0.45);AF2 k=AF2(1.099,-0.099);
return clamp(j.xx ,c*j.yy ,pow(c,j.zz )*k.xx +k.yy );}
AF3 ATo709F3(AF3 c){AF3 j=AF3(0.018*4.5,4.5,0.45);AF2 k=AF2(1.099,-0.099);
return clamp(j.xxx,c*j.yyy,pow(c,j.zzz)*k.xxx+k.yyy);}
AF1 AToGammaF1(AF1 c,AF1 rcpX){return pow(c,AF1_(rcpX));}
AF2 AToGammaF2(AF2 c,AF1 rcpX){return pow(c,AF2_(rcpX));}
AF3 AToGammaF3(AF3 c,AF1 rcpX){return pow(c,AF3_(rcpX));}
AF1 AToPqF1(AF1 x){AF1 p=pow(x,AF1_(0.159302));
return pow((AF1_(0.835938)+AF1_(18.8516)*p)/(AF1_(1.0)+AF1_(18.6875)*p),AF1_(78.8438));}
AF2 AToPqF1(AF2 x){AF2 p=pow(x,AF2_(0.159302));
return pow((AF2_(0.835938)+AF2_(18.8516)*p)/(AF2_(1.0)+AF2_(18.6875)*p),AF2_(78.8438));}
AF3 AToPqF1(AF3 x){AF3 p=pow(x,AF3_(0.159302));
return pow((AF3_(0.835938)+AF3_(18.8516)*p)/(AF3_(1.0)+AF3_(18.6875)*p),AF3_(78.8438));}
AF1 AToSrgbF1(AF1 c){AF3 j=AF3(0.0031308*12.92,12.92,1.0/2.4);AF2 k=AF2(1.055,-0.055);
return clamp(j.x ,c*j.y ,pow(c,j.z )*k.x +k.y );}
AF2 AToSrgbF2(AF2 c){AF3 j=AF3(0.0031308*12.92,12.92,1.0/2.4);AF2 k=AF2(1.055,-0.055);
return clamp(j.xx ,c*j.yy ,pow(c,j.zz )*k.xx +k.yy );}
AF3 AToSrgbF3(AF3 c){AF3 j=AF3(0.0031308*12.92,12.92,1.0/2.4);AF2 k=AF2(1.055,-0.055);
return clamp(j.xxx,c*j.yyy,pow(c,j.zzz)*k.xxx+k.yyy);}
AF1 AToTwoF1(AF1 c){return sqrt(c);}
AF2 AToTwoF2(AF2 c){return sqrt(c);}
AF3 AToTwoF3(AF3 c){return sqrt(c);}
AF1 AToThreeF1(AF1 c){return pow(c,AF1_(1.0/3.0));}
AF2 AToThreeF2(AF2 c){return pow(c,AF2_(1.0/3.0));}
AF3 AToThreeF3(AF3 c){return pow(c,AF3_(1.0/3.0));}
#endif
#if 1
AF1 AFrom709F1(AF1 c){AF3 j=AF3(0.081/4.5,1.0/4.5,1.0/0.45);AF2 k=AF2(1.0/1.099,0.099/1.099);
return AZolSelF1(AZolSignedF1(c-j.x ),c*j.y ,pow(c*k.x +k.y ,j.z ));}
AF2 AFrom709F2(AF2 c){AF3 j=AF3(0.081/4.5,1.0/4.5,1.0/0.45);AF2 k=AF2(1.0/1.099,0.099/1.099);
return AZolSelF2(AZolSignedF2(c-j.xx ),c*j.yy ,pow(c*k.xx +k.yy ,j.zz ));}
AF3 AFrom709F3(AF3 c){AF3 j=AF3(0.081/4.5,1.0/4.5,1.0/0.45);AF2 k=AF2(1.0/1.099,0.099/1.099);
return AZolSelF3(AZolSignedF3(c-j.xxx),c*j.yyy,pow(c*k.xxx+k.yyy,j.zzz));}
AF1 AFromGammaF1(AF1 c,AF1 x){return pow(c,AF1_(x));}
AF2 AFromGammaF2(AF2 c,AF1 x){return pow(c,AF2_(x));}
AF3 AFromGammaF3(AF3 c,AF1 x){return pow(c,AF3_(x));}
AF1 AFromPqF1(AF1 x){AF1 p=pow(x,AF1_(0.0126833));
return pow(ASatF1(p-AF1_(0.835938))/(AF1_(18.8516)-AF1_(18.6875)*p),AF1_(6.27739));}
AF2 AFromPqF1(AF2 x){AF2 p=pow(x,AF2_(0.0126833));
return pow(ASatF2(p-AF2_(0.835938))/(AF2_(18.8516)-AF2_(18.6875)*p),AF2_(6.27739));}
AF3 AFromPqF1(AF3 x){AF3 p=pow(x,AF3_(0.0126833));
return pow(ASatF3(p-AF3_(0.835938))/(AF3_(18.8516)-AF3_(18.6875)*p),AF3_(6.27739));}
AF1 AFromSrgbF1(AF1 c){AF3 j=AF3(0.04045/12.92,1.0/12.92,2.4);AF2 k=AF2(1.0/1.055,0.055/1.055);
return AZolSelF1(AZolSignedF1(c-j.x ),c*j.y ,pow(c*k.x +k.y ,j.z ));}
AF2 AFromSrgbF2(AF2 c){AF3 j=AF3(0.04045/12.92,1.0/12.92,2.4);AF2 k=AF2(1.0/1.055,0.055/1.055);
return AZolSelF2(AZolSignedF2(c-j.xx ),c*j.yy ,pow(c*k.xx +k.yy ,j.zz ));}
AF3 AFromSrgbF3(AF3 c){AF3 j=AF3(0.04045/12.92,1.0/12.92,2.4);AF2 k=AF2(1.0/1.055,0.055/1.055);
return AZolSelF3(AZolSignedF3(c-j.xxx),c*j.yyy,pow(c*k.xxx+k.yyy,j.zzz));}
AF1 AFromTwoF1(AF1 c){return c*c;}
AF2 AFromTwoF2(AF2 c){return c*c;}
AF3 AFromTwoF3(AF3 c){return c*c;}
AF1 AFromThreeF1(AF1 c){return c*c*c;}
AF2 AFromThreeF2(AF2 c){return c*c*c;}
AF3 AFromThreeF3(AF3 c){return c*c*c;}
#endif
#ifdef A_HALF
AH1 ATo709H1(AH1 c){AH3 j=AH3(0.018*4.5,4.5,0.45);AH2 k=AH2(1.099,-0.099);
return clamp(j.x ,c*j.y ,pow(c,j.z )*k.x +k.y );}
AH2 ATo709H2(AH2 c){AH3 j=AH3(0.018*4.5,4.5,0.45);AH2 k=AH2(1.099,-0.099);
return clamp(j.xx ,c*j.yy ,pow(c,j.zz )*k.xx +k.yy );}
AH3 ATo709H3(AH3 c){AH3 j=AH3(0.018*4.5,4.5,0.45);AH2 k=AH2(1.099,-0.099);
return clamp(j.xxx,c*j.yyy,pow(c,j.zzz)*k.xxx+k.yyy);}
AH1 AToGammaH1(AH1 c,AH1 rcpX){return pow(c,AH1_(rcpX));}
AH2 AToGammaH2(AH2 c,AH1 rcpX){return pow(c,AH2_(rcpX));}
AH3 AToGammaH3(AH3 c,AH1 rcpX){return pow(c,AH3_(rcpX));}
AH1 AToSrgbH1(AH1 c){AH3 j=AH3(0.0031308*12.92,12.92,1.0/2.4);AH2 k=AH2(1.055,-0.055);
return clamp(j.x ,c*j.y ,pow(c,j.z )*k.x +k.y );}
AH2 AToSrgbH2(AH2 c){AH3 j=AH3(0.0031308*12.92,12.92,1.0/2.4);AH2 k=AH2(1.055,-0.055);
return clamp(j.xx ,c*j.yy ,pow(c,j.zz )*k.xx +k.yy );}
AH3 AToSrgbH3(AH3 c){AH3 j=AH3(0.0031308*12.92,12.92,1.0/2.4);AH2 k=AH2(1.055,-0.055);
return clamp(j.xxx,c*j.yyy,pow(c,j.zzz)*k.xxx+k.yyy);}
AH1 AToTwoH1(AH1 c){return sqrt(c);}
AH2 AToTwoH2(AH2 c){return sqrt(c);}
AH3 AToTwoH3(AH3 c){return sqrt(c);}
AH1 AToThreeF1(AH1 c){return pow(c,AH1_(1.0/3.0));}
AH2 AToThreeF2(AH2 c){return pow(c,AH2_(1.0/3.0));}
AH3 AToThreeF3(AH3 c){return pow(c,AH3_(1.0/3.0));}
#endif
)--RPCS3--"
R"--RPCS3--(
#ifdef A_HALF
AH1 AFrom709H1(AH1 c){AH3 j=AH3(0.081/4.5,1.0/4.5,1.0/0.45);AH2 k=AH2(1.0/1.099,0.099/1.099);
return AZolSelH1(AZolSignedH1(c-j.x ),c*j.y ,pow(c*k.x +k.y ,j.z ));}
AH2 AFrom709H2(AH2 c){AH3 j=AH3(0.081/4.5,1.0/4.5,1.0/0.45);AH2 k=AH2(1.0/1.099,0.099/1.099);
return AZolSelH2(AZolSignedH2(c-j.xx ),c*j.yy ,pow(c*k.xx +k.yy ,j.zz ));}
AH3 AFrom709H3(AH3 c){AH3 j=AH3(0.081/4.5,1.0/4.5,1.0/0.45);AH2 k=AH2(1.0/1.099,0.099/1.099);
return AZolSelH3(AZolSignedH3(c-j.xxx),c*j.yyy,pow(c*k.xxx+k.yyy,j.zzz));}
AH1 AFromGammaH1(AH1 c,AH1 x){return pow(c,AH1_(x));}
AH2 AFromGammaH2(AH2 c,AH1 x){return pow(c,AH2_(x));}
AH3 AFromGammaH3(AH3 c,AH1 x){return pow(c,AH3_(x));}
AH1 AHromSrgbF1(AH1 c){AH3 j=AH3(0.04045/12.92,1.0/12.92,2.4);AH2 k=AH2(1.0/1.055,0.055/1.055);
return AZolSelH1(AZolSignedH1(c-j.x ),c*j.y ,pow(c*k.x +k.y ,j.z ));}
AH2 AHromSrgbF2(AH2 c){AH3 j=AH3(0.04045/12.92,1.0/12.92,2.4);AH2 k=AH2(1.0/1.055,0.055/1.055);
return AZolSelH2(AZolSignedH2(c-j.xx ),c*j.yy ,pow(c*k.xx +k.yy ,j.zz ));}
AH3 AHromSrgbF3(AH3 c){AH3 j=AH3(0.04045/12.92,1.0/12.92,2.4);AH2 k=AH2(1.0/1.055,0.055/1.055);
return AZolSelH3(AZolSignedH3(c-j.xxx),c*j.yyy,pow(c*k.xxx+k.yyy,j.zzz));}
AH1 AFromTwoH1(AH1 c){return c*c;}
AH2 AFromTwoH2(AH2 c){return c*c;}
AH3 AFromTwoH3(AH3 c){return c*c;}
AH1 AFromThreeH1(AH1 c){return c*c*c;}
AH2 AFromThreeH2(AH2 c){return c*c*c;}
AH3 AFromThreeH3(AH3 c){return c*c*c;}
#endif
AU2 ARmp8x8(AU1 a){return AU2(ABfe(a,1u,3u),ABfiM(ABfe(a,3u,3u),a,1u));}
AU2 ARmpRed8x8(AU1 a){return AU2(ABfiM(ABfe(a,2u,3u),a,1u),ABfiM(ABfe(a,3u,3u),ABfe(a,1u,2u),2u));}
#ifdef A_HALF
AW2 ARmp8x8H(AU1 a){return AW2(ABfe(a,1u,3u),ABfiM(ABfe(a,3u,3u),a,1u));}
AW2 ARmpRed8x8H(AU1 a){return AW2(ABfiM(ABfe(a,2u,3u),a,1u),ABfiM(ABfe(a,3u,3u),ABfe(a,1u,2u),2u));}
#endif
#endif
#ifdef A_GPU
#define A_TRUE true
#define A_FALSE false
#define A_STATIC
#define retAD2 AD2
#define retAD3 AD3
#define retAD4 AD4
#define retAF2 AF2
#define retAF3 AF3
#define retAF4 AF4
#define retAL2 AL2
#define retAL3 AL3
#define retAL4 AL4
#define retAU2 AU2
#define retAU3 AU3
#define retAU4 AU4
#define inAD2 in AD2
#define inAD3 in AD3
#define inAD4 in AD4
#define inAF2 in AF2
#define inAF3 in AF3
#define inAF4 in AF4
#define inAL2 in AL2
#define inAL3 in AL3
#define inAL4 in AL4
#define inAU2 in AU2
#define inAU3 in AU3
#define inAU4 in AU4
#define inoutAD2 inout AD2
#define inoutAD3 inout AD3
#define inoutAD4 inout AD4
#define inoutAF2 inout AF2
#define inoutAF3 inout AF3
#define inoutAF4 inout AF4
#define inoutAL2 inout AL2
#define inoutAL3 inout AL3
#define inoutAL4 inout AL4
#define inoutAU2 inout AU2
#define inoutAU3 inout AU3
#define inoutAU4 inout AU4
#define outAD2 out AD2
#define outAD3 out AD3
#define outAD4 out AD4
#define outAF2 out AF2
#define outAF3 out AF3
#define outAF4 out AF4
#define outAL2 out AL2
#define outAL3 out AL3
#define outAL4 out AL4
#define outAU2 out AU2
#define outAU3 out AU3
#define outAU4 out AU4
#define varAD2(x) AD2 x
#define varAD3(x) AD3 x
#define varAD4(x) AD4 x
#define varAF2(x) AF2 x
#define varAF3(x) AF3 x
#define varAF4(x) AF4 x
#define varAL2(x) AL2 x
#define varAL3(x) AL3 x
#define varAL4(x) AL4 x
#define varAU2(x) AU2 x
#define varAU3(x) AU3 x
#define varAU4(x) AU4 x
#define initAD2(x,y) AD2(x,y)
#define initAD3(x,y,z) AD3(x,y,z)
#define initAD4(x,y,z,w) AD4(x,y,z,w)
#define initAF2(x,y) AF2(x,y)
#define initAF3(x,y,z) AF3(x,y,z)
#define initAF4(x,y,z,w) AF4(x,y,z,w)
#define initAL2(x,y) AL2(x,y)
#define initAL3(x,y,z) AL3(x,y,z)
#define initAL4(x,y,z,w) AL4(x,y,z,w)
#define initAU2(x,y) AU2(x,y)
#define initAU3(x,y,z) AU3(x,y,z)
#define initAU4(x,y,z,w) AU4(x,y,z,w)
#define AAbsD1(a) abs(AD1(a))
#define AAbsF1(a) abs(AF1(a))
#define ACosD1(a) cos(AD1(a))
#define ACosF1(a) cos(AF1(a))
#define ADotD2(a,b) dot(AD2(a),AD2(b))
#define ADotD3(a,b) dot(AD3(a),AD3(b))
#define ADotD4(a,b) dot(AD4(a),AD4(b))
#define ADotF2(a,b) dot(AF2(a),AF2(b))
#define ADotF3(a,b) dot(AF3(a),AF3(b))
#define ADotF4(a,b) dot(AF4(a),AF4(b))
#define AExp2D1(a) exp2(AD1(a))
#define AExp2F1(a) exp2(AF1(a))
#define AFloorD1(a) floor(AD1(a))
#define AFloorF1(a) floor(AF1(a))
#define ALog2D1(a) log2(AD1(a))
#define ALog2F1(a) log2(AF1(a))
#define AMaxD1(a,b) max(a,b)
#define AMaxF1(a,b) max(a,b)
#define AMaxL1(a,b) max(a,b)
#define AMaxU1(a,b) max(a,b)
#define AMinD1(a,b) min(a,b)
#define AMinF1(a,b) min(a,b)
#define AMinL1(a,b) min(a,b)
#define AMinU1(a,b) min(a,b)
#define ASinD1(a) sin(AD1(a))
#define ASinF1(a) sin(AF1(a))
#define ASqrtD1(a) sqrt(AD1(a))
#define ASqrtF1(a) sqrt(AF1(a))
#define APowD1(a,b) pow(AD1(a),AF1(b))
#define APowF1(a,b) pow(AF1(a),AF1(b))
#ifdef A_DUBL
AD2 opAAbsD2(outAD2 d,inAD2 a){d=abs(a);return d;}
AD3 opAAbsD3(outAD3 d,inAD3 a){d=abs(a);return d;}
AD4 opAAbsD4(outAD4 d,inAD4 a){d=abs(a);return d;}
AD2 opAAddD2(outAD2 d,inAD2 a,inAD2 b){d=a+b;return d;}
AD3 opAAddD3(outAD3 d,inAD3 a,inAD3 b){d=a+b;return d;}
AD4 opAAddD4(outAD4 d,inAD4 a,inAD4 b){d=a+b;return d;}
AD2 opAAddOneD2(outAD2 d,inAD2 a,AD1 b){d=a+AD2_(b);return d;}
AD3 opAAddOneD3(outAD3 d,inAD3 a,AD1 b){d=a+AD3_(b);return d;}
AD4 opAAddOneD4(outAD4 d,inAD4 a,AD1 b){d=a+AD4_(b);return d;}
AD2 opACpyD2(outAD2 d,inAD2 a){d=a;return d;}
AD3 opACpyD3(outAD3 d,inAD3 a){d=a;return d;}
AD4 opACpyD4(outAD4 d,inAD4 a){d=a;return d;}
AD2 opALerpD2(outAD2 d,inAD2 a,inAD2 b,inAD2 c){d=ALerpD2(a,b,c);return d;}
AD3 opALerpD3(outAD3 d,inAD3 a,inAD3 b,inAD3 c){d=ALerpD3(a,b,c);return d;}
AD4 opALerpD4(outAD4 d,inAD4 a,inAD4 b,inAD4 c){d=ALerpD4(a,b,c);return d;}
AD2 opALerpOneD2(outAD2 d,inAD2 a,inAD2 b,AD1 c){d=ALerpD2(a,b,AD2_(c));return d;}
AD3 opALerpOneD3(outAD3 d,inAD3 a,inAD3 b,AD1 c){d=ALerpD3(a,b,AD3_(c));return d;}
AD4 opALerpOneD4(outAD4 d,inAD4 a,inAD4 b,AD1 c){d=ALerpD4(a,b,AD4_(c));return d;}
AD2 opAMaxD2(outAD2 d,inAD2 a,inAD2 b){d=max(a,b);return d;}
AD3 opAMaxD3(outAD3 d,inAD3 a,inAD3 b){d=max(a,b);return d;}
AD4 opAMaxD4(outAD4 d,inAD4 a,inAD4 b){d=max(a,b);return d;}
AD2 opAMinD2(outAD2 d,inAD2 a,inAD2 b){d=min(a,b);return d;}
AD3 opAMinD3(outAD3 d,inAD3 a,inAD3 b){d=min(a,b);return d;}
AD4 opAMinD4(outAD4 d,inAD4 a,inAD4 b){d=min(a,b);return d;}
AD2 opAMulD2(outAD2 d,inAD2 a,inAD2 b){d=a*b;return d;}
AD3 opAMulD3(outAD3 d,inAD3 a,inAD3 b){d=a*b;return d;}
AD4 opAMulD4(outAD4 d,inAD4 a,inAD4 b){d=a*b;return d;}
AD2 opAMulOneD2(outAD2 d,inAD2 a,AD1 b){d=a*AD2_(b);return d;}
AD3 opAMulOneD3(outAD3 d,inAD3 a,AD1 b){d=a*AD3_(b);return d;}
AD4 opAMulOneD4(outAD4 d,inAD4 a,AD1 b){d=a*AD4_(b);return d;}
AD2 opANegD2(outAD2 d,inAD2 a){d=-a;return d;}
AD3 opANegD3(outAD3 d,inAD3 a){d=-a;return d;}
AD4 opANegD4(outAD4 d,inAD4 a){d=-a;return d;}
AD2 opARcpD2(outAD2 d,inAD2 a){d=ARcpD2(a);return d;}
AD3 opARcpD3(outAD3 d,inAD3 a){d=ARcpD3(a);return d;}
AD4 opARcpD4(outAD4 d,inAD4 a){d=ARcpD4(a);return d;}
#endif
AF2 opAAbsF2(outAF2 d,inAF2 a){d=abs(a);return d;}
AF3 opAAbsF3(outAF3 d,inAF3 a){d=abs(a);return d;}
AF4 opAAbsF4(outAF4 d,inAF4 a){d=abs(a);return d;}
AF2 opAAddF2(outAF2 d,inAF2 a,inAF2 b){d=a+b;return d;}
AF3 opAAddF3(outAF3 d,inAF3 a,inAF3 b){d=a+b;return d;}
AF4 opAAddF4(outAF4 d,inAF4 a,inAF4 b){d=a+b;return d;}
AF2 opAAddOneF2(outAF2 d,inAF2 a,AF1 b){d=a+AF2_(b);return d;}
AF3 opAAddOneF3(outAF3 d,inAF3 a,AF1 b){d=a+AF3_(b);return d;}
AF4 opAAddOneF4(outAF4 d,inAF4 a,AF1 b){d=a+AF4_(b);return d;}
AF2 opACpyF2(outAF2 d,inAF2 a){d=a;return d;}
AF3 opACpyF3(outAF3 d,inAF3 a){d=a;return d;}
AF4 opACpyF4(outAF4 d,inAF4 a){d=a;return d;}
AF2 opALerpF2(outAF2 d,inAF2 a,inAF2 b,inAF2 c){d=ALerpF2(a,b,c);return d;}
AF3 opALerpF3(outAF3 d,inAF3 a,inAF3 b,inAF3 c){d=ALerpF3(a,b,c);return d;}
AF4 opALerpF4(outAF4 d,inAF4 a,inAF4 b,inAF4 c){d=ALerpF4(a,b,c);return d;}
AF2 opALerpOneF2(outAF2 d,inAF2 a,inAF2 b,AF1 c){d=ALerpF2(a,b,AF2_(c));return d;}
AF3 opALerpOneF3(outAF3 d,inAF3 a,inAF3 b,AF1 c){d=ALerpF3(a,b,AF3_(c));return d;}
AF4 opALerpOneF4(outAF4 d,inAF4 a,inAF4 b,AF1 c){d=ALerpF4(a,b,AF4_(c));return d;}
AF2 opAMaxF2(outAF2 d,inAF2 a,inAF2 b){d=max(a,b);return d;}
AF3 opAMaxF3(outAF3 d,inAF3 a,inAF3 b){d=max(a,b);return d;}
AF4 opAMaxF4(outAF4 d,inAF4 a,inAF4 b){d=max(a,b);return d;}
AF2 opAMinF2(outAF2 d,inAF2 a,inAF2 b){d=min(a,b);return d;}
AF3 opAMinF3(outAF3 d,inAF3 a,inAF3 b){d=min(a,b);return d;}
AF4 opAMinF4(outAF4 d,inAF4 a,inAF4 b){d=min(a,b);return d;}
AF2 opAMulF2(outAF2 d,inAF2 a,inAF2 b){d=a*b;return d;}
AF3 opAMulF3(outAF3 d,inAF3 a,inAF3 b){d=a*b;return d;}
AF4 opAMulF4(outAF4 d,inAF4 a,inAF4 b){d=a*b;return d;}
AF2 opAMulOneF2(outAF2 d,inAF2 a,AF1 b){d=a*AF2_(b);return d;}
AF3 opAMulOneF3(outAF3 d,inAF3 a,AF1 b){d=a*AF3_(b);return d;}
AF4 opAMulOneF4(outAF4 d,inAF4 a,AF1 b){d=a*AF4_(b);return d;}
AF2 opANegF2(outAF2 d,inAF2 a){d=-a;return d;}
AF3 opANegF3(outAF3 d,inAF3 a){d=-a;return d;}
AF4 opANegF4(outAF4 d,inAF4 a){d=-a;return d;}
AF2 opARcpF2(outAF2 d,inAF2 a){d=ARcpF2(a);return d;}
AF3 opARcpF3(outAF3 d,inAF3 a){d=ARcpF3(a);return d;}
AF4 opARcpF4(outAF4 d,inAF4 a){d=ARcpF4(a);return d;}
#endif
)--RPCS3--"
| 64,540
|
C++
|
.inc
| 1,323
| 46.783069
| 157
| 0.676986
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,292
|
spl_api.os.horizon.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/spl/spl_api.os.horizon.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
namespace ams::spl {
namespace {
enum class InitializeMode {
None,
General,
Crypto,
Ssl,
Es,
Fs,
Manu
};
constinit os::SdkMutex g_mutex;
constinit s32 g_initialize_count = 0;
constinit InitializeMode g_initialize_mode = InitializeMode::None;
Result AllocateAesKeySlotImpl(s32 *out) {
R_RETURN(serviceDispatchOut(splCryptoGetServiceSession(), 21, *out));
}
Result DeallocateAesKeySlotImpl(s32 slot) {
R_RETURN(serviceDispatchIn(splCryptoGetServiceSession(), 22, slot));
}
Result GetAesKeySlotAvailableEventImpl(os::NativeHandle *out) {
R_RETURN(serviceDispatch(splCryptoGetServiceSession(), 23,
.out_handle_attrs = { SfOutHandleAttr_HipcCopy },
.out_handles = out,
));
}
void GetAesKeySlotAvailableEvent(os::SystemEvent *out) {
/* Get event handle. */
os::NativeHandle handle;
R_ABORT_UNLESS(GetAesKeySlotAvailableEventImpl(std::addressof(handle)));
/* Attach to event. */
out->AttachReadableHandle(handle, true, os::EventClearMode_ManualClear);
}
template<typename F>
Result WaitAvailableKeySlotAndExecute(F f) {
os::SystemEvent event;
auto is_event_initialized = false;
while (true) {
R_TRY_CATCH(static_cast<::ams::Result>(f())) {
R_CATCH(spl::ResultNoAvailableKeySlot) {
if (!is_event_initialized) {
GetAesKeySlotAvailableEvent(std::addressof(event));
is_event_initialized = true;
}
event.Wait();
continue;
}
} R_END_TRY_CATCH;
R_SUCCEED();
}
}
template<typename F>
void Initialize(InitializeMode mode, F f) {
std::scoped_lock lk(g_mutex);
AMS_ASSERT(g_initialize_count >= 0);
AMS_ABORT_UNLESS(mode != InitializeMode::None);
if (g_initialize_count == 0) {
AMS_ABORT_UNLESS(g_initialize_mode == InitializeMode::None);
f();
g_initialize_mode = mode;
} else {
AMS_ABORT_UNLESS(g_initialize_mode == mode);
}
++g_initialize_count;
}
}
void Initialize() {
return Initialize(InitializeMode::General, [&]() {
R_ABORT_UNLESS(splInitialize());
});
}
void InitializeForCrypto() {
return Initialize(InitializeMode::Crypto, [&]() {
R_ABORT_UNLESS(splCryptoInitialize());
});
}
void InitializeForSsl() {
return Initialize(InitializeMode::Ssl, [&]() {
R_ABORT_UNLESS(splSslInitialize());
});
}
void InitializeForEs() {
return Initialize(InitializeMode::Es, [&]() {
R_ABORT_UNLESS(splEsInitialize());
});
}
void InitializeForFs() {
return Initialize(InitializeMode::Fs, [&]() {
R_ABORT_UNLESS(splFsInitialize());
});
}
void InitializeForManu() {
return Initialize(InitializeMode::Manu, [&]() {
R_ABORT_UNLESS(splManuInitialize());
});
}
void Finalize() {
std::scoped_lock lk(g_mutex);
AMS_ASSERT(g_initialize_count > 0);
AMS_ABORT_UNLESS(g_initialize_mode != InitializeMode::None);
if ((--g_initialize_count) == 0) {
switch (g_initialize_mode) {
case InitializeMode::General: splExit(); break;
case InitializeMode::Crypto: splCryptoExit(); break;
case InitializeMode::Ssl: splSslExit(); break;
case InitializeMode::Es: splEsExit(); break;
case InitializeMode::Fs: splFsExit(); break;
case InitializeMode::Manu: splManuExit(); break;
AMS_UNREACHABLE_DEFAULT_CASE();
}
g_initialize_mode = InitializeMode::None;
}
}
Result AllocateAesKeySlot(s32 *out_slot) {
R_RETURN(WaitAvailableKeySlotAndExecute([&]() -> Result {
R_RETURN(AllocateAesKeySlotImpl(out_slot));
}));
}
Result DeallocateAesKeySlot(s32 slot) {
R_RETURN(DeallocateAesKeySlotImpl(slot));
}
Result GenerateAesKek(AccessKey *access_key, const void *key_source, size_t key_source_size, s32 generation, u32 option) {
AMS_ASSERT(key_source_size == sizeof(KeySource));
AMS_UNUSED(key_source_size);
R_RETURN(splCryptoGenerateAesKek(key_source, generation, option, static_cast<void *>(access_key)));
}
Result LoadAesKey(s32 slot, const AccessKey &access_key, const void *key_source, size_t key_source_size) {
AMS_ASSERT(key_source_size == sizeof(KeySource));
AMS_UNUSED(key_source_size);
R_RETURN(splCryptoLoadAesKey(std::addressof(access_key), key_source, static_cast<u32>(slot)));
}
Result GenerateAesKey(void *dst, size_t dst_size, const AccessKey &access_key, const void *key_source, size_t key_source_size) {
AMS_ASSERT(dst_size >= crypto::AesEncryptor128::KeySize);
AMS_ASSERT(key_source_size == sizeof(KeySource));
AMS_UNUSED(dst_size, key_source_size);
R_RETURN(WaitAvailableKeySlotAndExecute([&]() -> Result {
R_RETURN(splCryptoGenerateAesKey(std::addressof(access_key), key_source, dst));
}));
}
Result GenerateSpecificAesKey(void *dst, size_t dst_size, const void *key_source, size_t key_source_size, s32 generation, u32 option) {
AMS_ASSERT(dst_size >= crypto::AesEncryptor128::KeySize);
AMS_ASSERT(key_source_size == sizeof(KeySource));
AMS_UNUSED(dst_size, key_source_size);
R_RETURN(splFsGenerateSpecificAesKey(key_source, static_cast<u32>(generation), option, dst));
}
Result ComputeCtr(void *dst, size_t dst_size, s32 slot, const void *src, size_t src_size, const void *iv, size_t iv_size) {
AMS_ASSERT(iv_size >= 0x10);
AMS_ASSERT(dst_size >= src_size);
AMS_UNUSED(dst_size, iv_size);
R_RETURN(splCryptoCryptAesCtr(src, dst, src_size, static_cast<s32>(slot), iv));
}
Result DecryptAesKey(void *dst, size_t dst_size, const void *key_source, size_t key_source_size, s32 generation, u32 option) {
AMS_ASSERT(dst_size >= crypto::AesEncryptor128::KeySize);
AMS_ASSERT(key_source_size == sizeof(KeySource));
AMS_UNUSED(dst_size, key_source_size);
R_RETURN(WaitAvailableKeySlotAndExecute([&]() -> Result {
R_RETURN(splCryptoDecryptAesKey(key_source, static_cast<u32>(generation), option, dst));
}));
}
Result GetConfig(u64 *out, ConfigItem item) {
R_RETURN(splGetConfig(static_cast<::SplConfigItem>(item), out));
}
Result SetConfig(ConfigItem item, u64 v) {
R_RETURN(splSetConfig(static_cast<::SplConfigItem>(item), v));
}
bool IsDevelopment() {
bool is_dev;
R_ABORT_UNLESS(splIsDevelopment(std::addressof(is_dev)));
return is_dev;
}
MemoryArrangement GetMemoryArrangement() {
u64 mode = 0;
R_ABORT_UNLESS(spl::GetConfig(std::addressof(mode), spl::ConfigItem::MemoryMode));
switch (mode & 0x3F) {
case 2:
return MemoryArrangement_StandardForAppletDev;
case 3:
return MemoryArrangement_StandardForSystemDev;
case 17:
return MemoryArrangement_Expanded;
case 18:
return MemoryArrangement_ExpandedForAppletDev;
default:
return MemoryArrangement_Standard;
}
}
Result SetBootReason(BootReasonValue boot_reason) {
static_assert(sizeof(boot_reason) == sizeof(u32));
u32 v;
std::memcpy(std::addressof(v), std::addressof(boot_reason), sizeof(v));
R_RETURN(splSetBootReason(v));
}
Result GetBootReason(BootReasonValue *out) {
static_assert(sizeof(*out) == sizeof(u32));
u32 v;
R_TRY(splGetBootReason(std::addressof(v)));
std::memcpy(out, std::addressof(v), sizeof(*out));
R_SUCCEED();
}
SocType GetSocType() {
switch (GetHardwareType()) {
case HardwareType::Icosa:
case HardwareType::Copper:
return SocType_Erista;
case HardwareType::Hoag:
case HardwareType::Iowa:
case HardwareType::Aula:
return SocType_Mariko;
AMS_UNREACHABLE_DEFAULT_CASE();
}
}
Result GetPackage2Hash(void *dst, size_t dst_size) {
AMS_ASSERT(dst_size >= crypto::Sha256Generator::HashSize);
AMS_UNUSED(dst_size);
R_RETURN(splFsGetPackage2Hash(dst));
}
Result GenerateRandomBytes(void *out, size_t buffer_size) {
R_RETURN(splGetRandomBytes(out, buffer_size));
}
Result LoadPreparedAesKey(s32 slot, const AccessKey &access_key) {
if (g_initialize_mode == InitializeMode::Fs) {
R_RETURN(splFsLoadTitlekey(std::addressof(access_key), static_cast<u32>(slot)));
} else {
/* TODO: libnx binding not available. */
/* R_RETURN(splEsLoadTitlekey(std::addressof(access_key), static_cast<u32>(slot))); */
AMS_ABORT_UNLESS(false);
}
}
}
| 10,321
|
C++
|
.cpp
| 245
| 32.134694
| 139
| 0.603013
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,293
|
spl_api.os.generic.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/spl/spl_api.os.generic.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
namespace ams::spl {
namespace {
bool InitializeImpl() {
/* Initialize implementation api. */
impl::Initialize();
return true;
}
void EnsureInitialized() {
AMS_FUNCTION_LOCAL_STATIC(bool, s_initialized, InitializeImpl());
AMS_ABORT_UNLESS(s_initialized);
}
Result WaitAvailableKeySlotAndExecute(auto f) {
os::SystemEvent *event = nullptr;
while (true) {
R_TRY_CATCH(static_cast<::ams::Result>(f())) {
R_CATCH(spl::ResultNoAvailableKeySlot) {
if (event == nullptr) {
event = impl::GetAesKeySlotAvailableEvent();
}
event->Wait();
continue;
}
} R_END_TRY_CATCH;
R_SUCCEED();
}
}
}
Result AllocateAesKeySlot(s32 *out_slot) {
EnsureInitialized();
R_RETURN(WaitAvailableKeySlotAndExecute([&]() -> Result {
R_RETURN(impl::AllocateAesKeySlot(out_slot));
}));
}
Result DeallocateAesKeySlot(s32 slot) {
EnsureInitialized();
R_RETURN(impl::DeallocateAesKeySlot(slot));
}
Result GenerateAesKek(AccessKey *out_access_key, const void *key_source, size_t key_source_size, s32 generation, u32 option) {
EnsureInitialized();
/* Check key size (assumed valid). */
AMS_ASSERT(key_source_size == sizeof(KeySource));
AMS_UNUSED(key_source_size);
/* AccessKey *out_access_key, const KeySource &key_source, u32 generation, u32 option */
R_RETURN(impl::GenerateAesKek(out_access_key, *static_cast<const KeySource *>(key_source), generation, option));
}
Result LoadAesKey(s32 slot, const AccessKey &access_key, const void *key_source, size_t key_source_size) {
EnsureInitialized();
AMS_ASSERT(key_source_size == sizeof(KeySource));
AMS_UNUSED(key_source_size);
R_RETURN(impl::LoadAesKey(slot, access_key, *static_cast<const KeySource *>(key_source)));
}
Result GenerateAesKey(void *dst, size_t dst_size, const AccessKey &access_key, const void *key_source, size_t key_source_size) {
EnsureInitialized();
AMS_ASSERT(dst_size >= sizeof(AesKey));
AMS_ASSERT(key_source_size == sizeof(KeySource));
AMS_UNUSED(dst_size, key_source_size);
R_RETURN(WaitAvailableKeySlotAndExecute([&]() -> Result {
R_RETURN(impl::GenerateAesKey(static_cast<AesKey *>(dst), access_key, *static_cast<const KeySource *>(key_source)));
}));
}
Result ComputeCtr(void *dst, size_t dst_size, s32 slot, const void *src, size_t src_size, const void *iv, size_t iv_size) {
EnsureInitialized();
AMS_ASSERT(iv_size >= sizeof(IvCtr));
AMS_UNUSED(iv_size);
AMS_ASSERT(dst_size >= src_size);
R_RETURN(impl::ComputeCtr(dst, dst_size, slot, src, src_size, *static_cast<const IvCtr *>(iv)));
}
Result DecryptAesKey(void *dst, size_t dst_size, const void *key_source, size_t key_source_size, s32 generation, u32 option) {
EnsureInitialized();
AMS_ASSERT(dst_size >= crypto::AesEncryptor128::KeySize);
AMS_ASSERT(key_source_size == sizeof(KeySource));
AMS_UNUSED(dst_size, key_source_size);
R_RETURN(WaitAvailableKeySlotAndExecute([&]() -> Result {
R_RETURN(impl::DecryptAesKey(static_cast<AesKey *>(dst), *static_cast<const KeySource *>(key_source), static_cast<u32>(generation), option));
}));
}
Result LoadPreparedAesKey(s32 slot, const AccessKey &access_key) {
EnsureInitialized();
R_RETURN(impl::LoadPreparedAesKey(slot, access_key));
}
Result PrepareCommonEsTitleKey(AccessKey *out, const void *key_source, const size_t key_source_size, int generation) {
EnsureInitialized();
AMS_ASSERT(key_source_size == sizeof(KeySource));
AMS_UNUSED(key_source_size);
R_RETURN(impl::PrepareCommonEsTitleKey(out, *static_cast<const KeySource *>(key_source), generation));
}
}
| 4,870
|
C++
|
.cpp
| 103
| 38.300971
| 153
| 0.635058
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,294
|
spl_api_impl.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/spl/impl/spl_api_impl.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "spl_ctr_drbg.hpp"
#include "spl_device_address_mapper.hpp"
#include "spl_key_slot_cache.hpp"
namespace ams::hos {
void InitializeVersionInternal(bool allow_approximate);
}
namespace ams::spl::impl {
namespace {
/* Drbg type. */
using Drbg = CtrDrbg<crypto::AesEncryptor128, AesKeySize, false>;
/* Convenient defines. */
#if defined(ATMOSPHERE_OS_HORIZON)
constexpr size_t DeviceAddressSpaceAlign = 4_MB;
constexpr u32 WorkBufferBase = 0x80000000u;
constexpr u32 ComputeAesInMapBase = 0x90000000u;
constexpr u32 ComputeAesOutMapBase = 0xC0000000u;
constexpr size_t ComputeAesSizeMax = static_cast<size_t>(ComputeAesOutMapBase - ComputeAesInMapBase);
#endif
constexpr size_t DeviceUniqueDataIvSize = 0x10;
constexpr size_t DeviceUniqueDataPaddingSize = 0x08;
constexpr size_t DeviceUniqueDataDeviceIdSize = 0x08;
constexpr size_t DeviceUniqueDataGmacSize = 0x10;
constexpr size_t DeviceUniqueDataPlainMetaDataSize = DeviceUniqueDataIvSize + DeviceUniqueDataGmacSize;
constexpr size_t DeviceUniqueDataMetaDataSize = DeviceUniqueDataPlainMetaDataSize + DeviceUniqueDataPaddingSize + DeviceUniqueDataDeviceIdSize;
constexpr size_t Rsa2048BlockSize = 0x100;
constexpr size_t LabelDigestSizeMax = 0x20;
constexpr size_t WorkBufferSizeMax = 0x800;
constexpr const KeySource KeyGenerationSource = {
.data = { 0x89, 0x61, 0x5E, 0xE0, 0x5C, 0x31, 0xB6, 0x80, 0x5F, 0xE5, 0x8F, 0x3D, 0xA2, 0x4F, 0x7A, 0xA8 }
};
constexpr const KeySource AesKeyDecryptionSource = {
.data = { 0x11, 0x70, 0x24, 0x2B, 0x48, 0x69, 0x11, 0xF1, 0x11, 0xB0, 0x0C, 0x47, 0x7C, 0xC3, 0xEF, 0x7E }
};
constexpr s32 PhysicalAesKeySlotCount = 6;
/* KeySlot management. */
constinit AesKeySlotCache g_aes_keyslot_cache;
constinit util::optional<AesKeySlotCacheEntry> g_aes_keyslot_cache_entry[PhysicalAesKeySlotCount] = {};
constinit bool g_is_physical_keyslot_allowed = false;
constinit bool g_is_modern_device_unique_data = true;
constexpr inline bool IsVirtualAesKeySlot(s32 keyslot) {
return AesKeySlotMin <= keyslot && keyslot <= AesKeySlotMax;
}
constexpr inline bool IsPhysicalAesKeySlot(s32 keyslot) {
return keyslot < PhysicalAesKeySlotCount;
}
constexpr inline s32 GetVirtualAesKeySlotIndex(s32 keyslot) {
AMS_ASSERT(IsVirtualAesKeySlot(keyslot));
return keyslot - AesKeySlotMin;
}
constexpr inline s32 MakeVirtualAesKeySlot(s32 index) {
const s32 virt_slot = index + AesKeySlotMin;
AMS_ASSERT(IsVirtualAesKeySlot(virt_slot));
return virt_slot;
}
enum class AesKeySlotContentType {
None = 0,
AesKey = 1,
PreparedKey = 2,
};
struct AesKeySlotContents {
AesKeySlotContentType type;
union {
struct {
AccessKey access_key;
KeySource key_source;
} aes_key;
struct {
AccessKey access_key;
} prepared_key;
};
};
constinit bool g_is_aes_keyslot_allocated[AesKeySlotCount];
constinit AesKeySlotContents g_aes_keyslot_contents[AesKeySlotCount] = {};
constinit AesKeySlotContents g_aes_physical_keyslot_contents_for_backwards_compatibility[PhysicalAesKeySlotCount] = {};
void ClearPhysicalAesKeySlot(s32 keyslot) {
AMS_ASSERT(IsPhysicalAesKeySlot(keyslot));
AccessKey access_key = {};
KeySource key_source = {};
smc::LoadAesKey(keyslot, access_key, key_source);
}
s32 GetPhysicalAesKeySlot(s32 keyslot, bool load) {
s32 phys_slot = -1;
AesKeySlotContents *contents = nullptr;
if (g_is_physical_keyslot_allowed && IsPhysicalAesKeySlot(keyslot)) {
/* On 1.0.0, we allow the use of physical keyslots. */
phys_slot = keyslot;
contents = std::addressof(g_aes_physical_keyslot_contents_for_backwards_compatibility[phys_slot]);
/* If the physical slot is already loaded, we're good. */
if (g_aes_keyslot_cache.FindPhysical(phys_slot)) {
return phys_slot;
}
} else {
/* This should be a virtual keyslot. */
AMS_ASSERT(IsVirtualAesKeySlot(keyslot));
/* Try to find a physical slot in the cache. */
if (g_aes_keyslot_cache.Find(std::addressof(phys_slot), keyslot)) {
return phys_slot;
}
/* Allocate a physical slot. */
phys_slot = g_aes_keyslot_cache.Allocate(keyslot);
contents = std::addressof(g_aes_keyslot_contents[GetVirtualAesKeySlotIndex(keyslot)]);
}
/* Ensure the contents of the keyslot. */
if (load) {
switch (contents->type) {
case AesKeySlotContentType::None:
ClearPhysicalAesKeySlot(phys_slot);
break;
case AesKeySlotContentType::AesKey:
R_ABORT_UNLESS(smc::ConvertResult(smc::LoadAesKey(phys_slot, contents->aes_key.access_key, contents->aes_key.key_source)));
break;
case AesKeySlotContentType::PreparedKey:
R_ABORT_UNLESS(smc::ConvertResult(smc::LoadPreparedAesKey(phys_slot, contents->prepared_key.access_key)));
break;
AMS_UNREACHABLE_DEFAULT_CASE();
}
}
return phys_slot;
}
/* Type definitions. */
class ScopedAesKeySlot {
private:
s32 m_slot_index;
bool m_allocated;
public:
ScopedAesKeySlot() : m_slot_index(-1), m_allocated(false) {
/* ... */
}
~ScopedAesKeySlot() {
if (m_allocated) {
DeallocateAesKeySlot(m_slot_index);
}
}
s32 GetIndex() const {
return m_slot_index;
}
Result Allocate() {
R_TRY(AllocateAesKeySlot(std::addressof(m_slot_index)));
m_allocated = true;
R_SUCCEED();
}
};
struct SeLinkedListEntry {
u32 num_entries;
u32 address;
u32 size;
};
struct SeCryptContext {
SeLinkedListEntry in;
SeLinkedListEntry out;
};
/* Global variables. */
alignas(os::MemoryPageSize) constinit u8 g_work_buffer[WorkBufferSizeMax];
constinit util::TypedStorage<Drbg> g_drbg = {};
constinit os::InterruptName g_interrupt_name;
constinit os::InterruptEventType g_interrupt = {};
constinit util::TypedStorage<os::SystemEvent> g_aes_keyslot_available_event = {};
constinit os::SdkMutex g_operation_lock;
constinit dd::DeviceAddressSpaceType g_device_address_space = {};
#if defined(ATMOSPHERE_OS_HORIZON)
constinit u32 g_work_buffer_mapped_address;
#else
constinit uintptr_t g_work_buffer_mapped_address;
#endif
constinit BootReasonValue g_boot_reason;
constinit bool g_is_boot_reason_initialized;
/* Initialization functionality. */
void InitializeAsyncOperation() {
#if defined(ATMOSPHERE_OS_HORIZON)
u64 interrupt_number;
impl::GetConfig(std::addressof(interrupt_number), ConfigItem::SecurityEngineInterruptNumber);
g_interrupt_name = static_cast<os::InterruptName>(interrupt_number);
os::InitializeInterruptEvent(std::addressof(g_interrupt), g_interrupt_name, os::EventClearMode_AutoClear);
#else
AMS_UNUSED(g_interrupt_name, g_interrupt);
#endif
}
void InitializeDeviceAddressSpace() {
#if defined(ATMOSPHERE_OS_HORIZON)
/* Create device address space. */
R_ABORT_UNLESS(dd::CreateDeviceAddressSpace(std::addressof(g_device_address_space), 0, (1ul << 32)));
/* Attach to the security engine. */
R_ABORT_UNLESS(dd::AttachDeviceAddressSpace(std::addressof(g_device_address_space), dd::DeviceName_Se));
/* Map work buffer into the device. */
const uintptr_t work_buffer_address = reinterpret_cast<uintptr_t>(g_work_buffer);
g_work_buffer_mapped_address = WorkBufferBase + (work_buffer_address % DeviceAddressSpaceAlign);
R_ABORT_UNLESS(dd::MapDeviceAddressSpaceAligned(std::addressof(g_device_address_space), dd::GetCurrentProcessHandle(), work_buffer_address, dd::DeviceAddressSpaceMemoryRegionAlignment, g_work_buffer_mapped_address, dd::MemoryPermission_ReadWrite));
#else
/* Just set the work buffer address directly. */
AMS_UNUSED(g_device_address_space);
g_work_buffer_mapped_address = reinterpret_cast<uintptr_t>(g_work_buffer);
#endif
}
void InitializeCtrDrbg() {
u8 seed[Drbg::SeedSize];
AMS_ABORT_UNLESS(smc::GenerateRandomBytes(seed, sizeof(seed)) == smc::Result::Success);
util::ConstructAt(g_drbg);
util::GetReference(g_drbg).Initialize(seed, sizeof(seed), nullptr, 0, nullptr, 0);
}
void InitializeKeySlots() {
const auto fw_ver = hos::GetVersion();
g_is_physical_keyslot_allowed = fw_ver < hos::Version_2_0_0;
g_is_modern_device_unique_data = fw_ver >= hos::Version_5_0_0;
for (s32 i = 0; i < PhysicalAesKeySlotCount; i++) {
g_aes_keyslot_cache_entry[i].emplace(i);
g_aes_keyslot_cache.AddEntry(std::addressof(g_aes_keyslot_cache_entry[i].value()));
}
util::ConstructAt(g_aes_keyslot_available_event, os::EventClearMode_ManualClear, true);
util::GetReference(g_aes_keyslot_available_event).Signal();
}
void WaitOperation() {
#if defined(ATMOSPHERE_OS_HORIZON)
os::WaitInterruptEvent(std::addressof(g_interrupt));
#endif
}
smc::Result WaitAndGetResult(smc::AsyncOperationKey op_key) {
WaitOperation();
smc::Result async_res;
if (const smc::Result res = smc::GetResult(std::addressof(async_res), op_key); res != smc::Result::Success) {
return res;
}
return async_res;
}
smc::Result WaitAndGetResultData(void *dst, size_t size, smc::AsyncOperationKey op_key) {
WaitOperation();
smc::Result async_res;
if (const smc::Result res = smc::GetResultData(std::addressof(async_res), dst, size, op_key); res != smc::Result::Success) {
return res;
}
return async_res;
}
smc::Result DecryptAes(void *dst, s32 keyslot, const void *src) {
struct DecryptAesLayout {
SeCryptContext crypt_ctx;
u8 padding[8];
u8 in_buffer[crypto::AesEncryptor128::BlockSize];
u8 out_buffer[crypto::AesEncryptor128::BlockSize];
};
#if defined(ATMOSPHERE_OS_HORIZON)
auto &layout = *reinterpret_cast<DecryptAesLayout *>(g_work_buffer);
layout.crypt_ctx.in.num_entries = 0;
layout.crypt_ctx.in.address = g_work_buffer_mapped_address + AMS_OFFSETOF(DecryptAesLayout, in_buffer);
layout.crypt_ctx.in.size = sizeof(layout.in_buffer);
layout.crypt_ctx.out.num_entries = 0;
layout.crypt_ctx.out.address = g_work_buffer_mapped_address + AMS_OFFSETOF(DecryptAesLayout, out_buffer);
layout.crypt_ctx.out.size = sizeof(layout.out_buffer);
std::memcpy(layout.in_buffer, src, sizeof(layout.in_buffer));
os::FlushDataCache(std::addressof(layout), sizeof(layout));
{
std::scoped_lock lk(g_operation_lock);
smc::AsyncOperationKey op_key;
const IvCtr iv_ctr = {};
const u32 mode = smc::GetComputeAesMode(smc::CipherMode::CbcDecrypt, GetPhysicalAesKeySlot(keyslot, true));
const u32 dst_ll_addr = g_work_buffer_mapped_address + AMS_OFFSETOF(DecryptAesLayout, crypt_ctx.out);
const u32 src_ll_addr = g_work_buffer_mapped_address + AMS_OFFSETOF(DecryptAesLayout, crypt_ctx.in);
smc::Result res = smc::ComputeAes(std::addressof(op_key), dst_ll_addr, mode, iv_ctr, src_ll_addr, sizeof(layout.out_buffer));
if (res != smc::Result::Success) {
return res;
}
res = WaitAndGetResult(op_key);
if (res != smc::Result::Success) {
return res;
}
}
os::FlushDataCache(std::addressof(layout.out_buffer), sizeof(layout.out_buffer));
std::memcpy(dst, layout.out_buffer, sizeof(layout.out_buffer));
#else
{
/* Set up buffers. */
u8 in_buffer[crypto::AesEncryptor128::BlockSize];
u8 out_buffer[crypto::AesEncryptor128::BlockSize];
std::memcpy(in_buffer, src, sizeof(in_buffer));
std::scoped_lock lk(g_operation_lock);
/* On generic os, we don't worry about the security engine. */
smc::AsyncOperationKey op_key;
const IvCtr iv_ctr = {};
const u32 mode = smc::GetComputeAesMode(smc::CipherMode::CbcDecrypt, GetPhysicalAesKeySlot(keyslot, true));
smc::Result res = smc::ComputeAes(std::addressof(op_key), reinterpret_cast<uintptr_t>(out_buffer), mode, iv_ctr, reinterpret_cast<uintptr_t>(in_buffer), sizeof(in_buffer));
if (res != smc::Result::Success) {
return res;
}
res = WaitAndGetResult(op_key);
if (res != smc::Result::Success) {
return res;
}
std::memcpy(dst, out_buffer, sizeof(out_buffer));
}
#endif
return smc::Result::Success;
}
Result GenerateRandomBytesImpl(void *out, size_t size) {
AMS_ASSERT(size <= Drbg::RequestSizeMax);
if (!util::GetReference(g_drbg).Generate(out, size, nullptr, 0)) {
/* We need to reseed. */
{
u8 seed[Drbg::SeedSize];
if (smc::Result res = smc::GenerateRandomBytes(seed, sizeof(seed)); res != smc::Result::Success) {
R_RETURN(smc::ConvertResult(res));
}
util::GetReference(g_drbg).Reseed(seed, sizeof(seed), nullptr, 0);
}
util::GetReference(g_drbg).Generate(out, size, nullptr, 0);
}
R_SUCCEED();
}
Result DecryptAndStoreDeviceUniqueKey(const void *src, size_t src_size, const AccessKey &access_key, const KeySource &key_source, u32 option) {
struct DecryptAndStoreDeviceUniqueKeyLayout {
u8 data[DeviceUniqueDataMetaDataSize + 2 * Rsa2048BlockSize + 0x10];
};
auto &layout = *reinterpret_cast<DecryptAndStoreDeviceUniqueKeyLayout *>(g_work_buffer);
/* Validate size. */
R_UNLESS(src_size <= sizeof(DecryptAndStoreDeviceUniqueKeyLayout), spl::ResultInvalidBufferSize());
std::memcpy(layout.data, src, src_size);
if (g_is_modern_device_unique_data) {
R_RETURN(smc::ConvertResult(smc::DecryptDeviceUniqueData(layout.data, src_size, access_key, key_source, static_cast<smc::DeviceUniqueDataMode>(option))));
} else {
R_RETURN(smc::ConvertResult(smc::DecryptAndStoreGcKey(layout.data, src_size, access_key, key_source, option)));
}
}
Result ModularExponentiateWithStorageKey(void *out, size_t out_size, const void *base, size_t base_size, const void *mod, size_t mod_size, smc::ModularExponentiateWithStorageKeyMode mode) {
struct ModularExponentiateWithStorageKeyLayout {
u8 base[Rsa2048BlockSize];
u8 mod[Rsa2048BlockSize];
};
auto &layout = *reinterpret_cast<ModularExponentiateWithStorageKeyLayout *>(g_work_buffer);
/* Validate sizes. */
R_UNLESS(base_size <= sizeof(layout.base), spl::ResultInvalidBufferSize());
R_UNLESS(mod_size <= sizeof(layout.mod), spl::ResultInvalidBufferSize());
R_UNLESS(out_size <= sizeof(g_work_buffer), spl::ResultInvalidBufferSize());
/* Copy data into work buffer. */
const size_t base_ofs = sizeof(layout.base) - base_size;
const size_t mod_ofs = sizeof(layout.mod) - mod_size;
std::memset(layout.base, 0, sizeof(layout.base));
std::memset(layout.mod, 0, sizeof(layout.mod));
std::memcpy(layout.base + base_ofs, base, base_size);
std::memcpy(layout.mod + mod_ofs, mod, mod_size);
/* Do exp mod operation. */
{
std::scoped_lock lk(g_operation_lock);
smc::AsyncOperationKey op_key;
smc::Result res = smc::ModularExponentiateWithStorageKey(std::addressof(op_key), layout.base, layout.mod, mode);
if (res != smc::Result::Success) {
R_RETURN(smc::ConvertResult(res));
}
res = WaitAndGetResultData(g_work_buffer, out_size, op_key);
if (res != smc::Result::Success) {
R_RETURN(smc::ConvertResult(res));
}
}
/* Copy result. */
if (out != g_work_buffer) {
std::memcpy(out, g_work_buffer, out_size);
}
R_SUCCEED();
}
Result PrepareEsDeviceUniqueKey(AccessKey *out_access_key, const void *base, size_t base_size, const void *mod, size_t mod_size, const void *label_digest, size_t label_digest_size, smc::EsDeviceUniqueKeyType type, u32 generation) {
struct PrepareEsDeviceUniqueKeyLayout {
u8 base[Rsa2048BlockSize];
u8 mod[Rsa2048BlockSize];
};
auto &layout = *reinterpret_cast<PrepareEsDeviceUniqueKeyLayout *>(g_work_buffer);
/* Validate sizes. */
R_UNLESS(base_size <= sizeof(layout.base), spl::ResultInvalidBufferSize());
R_UNLESS(mod_size <= sizeof(layout.mod), spl::ResultInvalidBufferSize());
R_UNLESS(label_digest_size <= LabelDigestSizeMax, spl::ResultInvalidBufferSize());
/* Copy data into work buffer. */
const size_t base_ofs = sizeof(layout.base) - base_size;
const size_t mod_ofs = sizeof(layout.mod) - mod_size;
std::memset(layout.base, 0, sizeof(layout.base));
std::memset(layout.mod, 0, sizeof(layout.mod));
std::memcpy(layout.base + base_ofs, base, base_size);
std::memcpy(layout.mod + mod_ofs, mod, mod_size);
/* Do exp mod operation. */
{
std::scoped_lock lk(g_operation_lock);
smc::AsyncOperationKey op_key;
smc::Result res = smc::PrepareEsDeviceUniqueKey(std::addressof(op_key), layout.base, layout.mod, label_digest, label_digest_size, smc::GetPrepareEsDeviceUniqueKeyOption(type, generation));
if (res != smc::Result::Success) {
R_RETURN(smc::ConvertResult(res));
}
res = WaitAndGetResultData(g_work_buffer, sizeof(*out_access_key), op_key);
if (res != smc::Result::Success) {
R_RETURN(smc::ConvertResult(res));
}
}
std::memcpy(out_access_key, g_work_buffer, sizeof(*out_access_key));
R_SUCCEED();
}
}
/* Initialization. */
void Initialize() {
/* Initialize async operation. */
InitializeAsyncOperation();
/* Initialize device address space for the SE. */
InitializeDeviceAddressSpace();
/* Initialize the Drbg. */
InitializeCtrDrbg();
/* Initialize the keyslot cache. */
InitializeKeySlots();
}
/* General. */
Result GetConfig(u64 *out, ConfigItem key) {
/* Nintendo explicitly blacklists package2 hash, which must be gotten via bespoke api. */
R_UNLESS(key != ConfigItem::Package2Hash, spl::ResultInvalidArgument());
smc::Result res = smc::GetConfig(out, 1, key);
/* Nintendo has some special handling here for hardware type/hardware state. */
if (key == ConfigItem::HardwareType && res == smc::Result::InvalidArgument) {
*out = static_cast<u64>(HardwareType::Icosa);
res = smc::Result::Success;
}
if (key == ConfigItem::HardwareState && res == smc::Result::InvalidArgument) {
*out = HardwareState_Development;
res = smc::Result::Success;
}
R_RETURN(smc::ConvertResult(res));
}
Result ModularExponentiate(void *out, size_t out_size, const void *base, size_t base_size, const void *exp, size_t exp_size, const void *mod, size_t mod_size) {
struct ModularExponentiateLayout {
u8 base[Rsa2048BlockSize];
u8 exp[Rsa2048BlockSize];
u8 mod[Rsa2048BlockSize];
};
auto &layout = *reinterpret_cast<ModularExponentiateLayout *>(g_work_buffer);
/* Validate sizes. */
R_UNLESS(base_size <= sizeof(layout.base), spl::ResultInvalidBufferSize());
R_UNLESS(exp_size <= sizeof(layout.exp), spl::ResultInvalidBufferSize());
R_UNLESS(mod_size <= sizeof(layout.mod), spl::ResultInvalidBufferSize());
R_UNLESS(out_size <= sizeof(g_work_buffer), spl::ResultInvalidBufferSize());
/* Copy data into work buffer. */
const size_t base_ofs = sizeof(layout.base) - base_size;
const size_t mod_ofs = sizeof(layout.mod) - mod_size;
std::memset(layout.base, 0, sizeof(layout.base));
std::memset(layout.mod, 0, sizeof(layout.mod));
std::memcpy(layout.base + base_ofs, base, base_size);
std::memcpy(layout.mod + mod_ofs, mod, mod_size);
std::memcpy(layout.exp, exp, exp_size);
/* Do exp mod operation. */
{
std::scoped_lock lk(g_operation_lock);
smc::AsyncOperationKey op_key;
smc::Result res = smc::ModularExponentiate(std::addressof(op_key), layout.base, layout.exp, exp_size, layout.mod);
if (res != smc::Result::Success) {
R_RETURN(smc::ConvertResult(res));
}
res = WaitAndGetResultData(g_work_buffer, out_size, op_key);
if (res != smc::Result::Success) {
R_RETURN(smc::ConvertResult(res));
}
}
std::memcpy(out, g_work_buffer, out_size);
R_SUCCEED();
}
Result SetConfig(ConfigItem key, u64 value) {
R_TRY(smc::ConvertResult(smc::SetConfig(key, value)));
/* Work around for temporary version. */
if (key == ConfigItem::ExosphereApiVersion) {
hos::InitializeVersionInternal(false);
}
R_SUCCEED();
}
Result GenerateRandomBytes(void *out, size_t size) {
for (size_t offset = 0; offset < size; offset += Drbg::RequestSizeMax) {
R_TRY(GenerateRandomBytesImpl(static_cast<u8 *>(out) + offset, std::min(size - offset, Drbg::RequestSizeMax)));
}
R_SUCCEED();
}
Result IsDevelopment(bool *out) {
u64 hardware_state;
R_TRY(impl::GetConfig(std::addressof(hardware_state), ConfigItem::HardwareState));
*out = (hardware_state == HardwareState_Development);
R_SUCCEED();
}
Result SetBootReason(BootReasonValue boot_reason) {
R_UNLESS(!g_is_boot_reason_initialized, spl::ResultBootReasonAlreadyInitialized());
g_boot_reason = boot_reason;
g_is_boot_reason_initialized = true;
R_SUCCEED();
}
Result GetBootReason(BootReasonValue *out) {
R_UNLESS(g_is_boot_reason_initialized, spl::ResultBootReasonNotInitialized());
*out = g_boot_reason;
R_SUCCEED();
}
/* Crypto. */
Result GenerateAesKek(AccessKey *out_access_key, const KeySource &key_source, u32 generation, u32 option) {
R_RETURN(smc::ConvertResult(smc::GenerateAesKek(out_access_key, key_source, generation, option)));
}
Result LoadAesKey(s32 keyslot, const AccessKey &access_key, const KeySource &key_source) {
/* Ensure we can load into the slot. */
const s32 phys_slot = GetPhysicalAesKeySlot(keyslot, false);
R_TRY(smc::ConvertResult(smc::LoadAesKey(phys_slot, access_key, key_source)));
/* Update our contents. */
const s32 index = GetVirtualAesKeySlotIndex(keyslot);
g_aes_keyslot_contents[index].type = AesKeySlotContentType::AesKey;
g_aes_keyslot_contents[index].aes_key.access_key = access_key;
g_aes_keyslot_contents[index].aes_key.key_source = key_source;
R_SUCCEED();
}
Result GenerateAesKey(AesKey *out_key, const AccessKey &access_key, const KeySource &key_source) {
ScopedAesKeySlot keyslot_holder;
R_TRY(keyslot_holder.Allocate());
R_TRY(LoadAesKey(keyslot_holder.GetIndex(), access_key, KeyGenerationSource));
R_RETURN(smc::ConvertResult(DecryptAes(out_key, keyslot_holder.GetIndex(), std::addressof(key_source))));
}
Result DecryptAesKey(AesKey *out_key, const KeySource &key_source, u32 generation, u32 option) {
AccessKey access_key;
R_TRY(GenerateAesKek(std::addressof(access_key), AesKeyDecryptionSource, generation, option));
R_RETURN(GenerateAesKey(out_key, access_key, key_source));
}
Result ComputeCtr(void *dst, size_t dst_size, s32 keyslot, const void *src, size_t src_size, const IvCtr &iv_ctr) {
/* Succeed immediately if there's nothing to compute. */
R_SUCCEED_IF(src_size == 0);
/* Validate sizes. */
R_UNLESS(src_size <= dst_size, spl::ResultInvalidBufferSize());
R_UNLESS(util::IsAligned(src_size, AesBlockSize), spl::ResultInvalidBufferSize());
#if defined(ATMOSPHERE_OS_HORIZON)
/* We can only map 4_MB aligned buffers for the SE, so determine where to map our buffers. */
const uintptr_t src_addr = reinterpret_cast<uintptr_t>(src);
const uintptr_t dst_addr = reinterpret_cast<uintptr_t>(dst);
const uintptr_t src_addr_aligned = util::AlignDown(src_addr, dd::DeviceAddressSpaceMemoryRegionAlignment);
const uintptr_t dst_addr_aligned = util::AlignDown(dst_addr, dd::DeviceAddressSpaceMemoryRegionAlignment);
const size_t src_size_aligned = util::AlignUp(src_addr + src_size, dd::DeviceAddressSpaceMemoryRegionAlignment) - src_addr_aligned;
const size_t dst_size_aligned = util::AlignUp(dst_addr + dst_size, dd::DeviceAddressSpaceMemoryRegionAlignment) - dst_addr_aligned;
const u32 src_se_map_addr = ComputeAesInMapBase + (src_addr_aligned % DeviceAddressSpaceAlign);
const u32 dst_se_map_addr = ComputeAesOutMapBase + (dst_addr_aligned % DeviceAddressSpaceAlign);
const u32 src_se_addr = ComputeAesInMapBase + (src_addr % DeviceAddressSpaceAlign);
const u32 dst_se_addr = ComputeAesOutMapBase + (dst_addr % DeviceAddressSpaceAlign);
/* Validate aligned sizes. */
R_UNLESS(src_size_aligned <= ComputeAesSizeMax, spl::ResultInvalidBufferSize());
R_UNLESS(dst_size_aligned <= ComputeAesSizeMax, spl::ResultInvalidBufferSize());
/* Helpers for mapping/unmapping. */
DeviceAddressMapper src_mapper(std::addressof(g_device_address_space), src_addr_aligned, src_size_aligned, src_se_map_addr, dd::MemoryPermission_ReadOnly);
DeviceAddressMapper dst_mapper(std::addressof(g_device_address_space), dst_addr_aligned, dst_size_aligned, dst_se_map_addr, dd::MemoryPermission_WriteOnly);
/* Setup SE linked list entries. */
auto &crypt_ctx = *reinterpret_cast<SeCryptContext *>(g_work_buffer);
crypt_ctx.in.num_entries = 0;
crypt_ctx.in.address = src_se_addr;
crypt_ctx.in.size = src_size;
crypt_ctx.out.num_entries = 0;
crypt_ctx.out.address = dst_se_addr;
crypt_ctx.out.size = dst_size;
os::FlushDataCache(std::addressof(crypt_ctx), sizeof(crypt_ctx));
os::FlushDataCache(src, src_size);
os::FlushDataCache(dst, dst_size);
{
std::scoped_lock lk(g_operation_lock);
const u32 mode = smc::GetComputeAesMode(smc::CipherMode::Ctr, GetPhysicalAesKeySlot(keyslot, true));
const u32 dst_ll_addr = g_work_buffer_mapped_address + AMS_OFFSETOF(SeCryptContext, out);
const u32 src_ll_addr = g_work_buffer_mapped_address + AMS_OFFSETOF(SeCryptContext, in);
smc::AsyncOperationKey op_key;
smc::Result res = smc::ComputeAes(std::addressof(op_key), dst_ll_addr, mode, iv_ctr, src_ll_addr, src_size);
if (res != smc::Result::Success) {
R_RETURN(smc::ConvertResult(res));
}
res = WaitAndGetResult(op_key);
if (res != smc::Result::Success) {
R_RETURN(smc::ConvertResult(res));
}
}
os::FlushDataCache(dst, dst_size);
#else
{
std::scoped_lock lk(g_operation_lock);
const u32 mode = smc::GetComputeAesMode(smc::CipherMode::Ctr, GetPhysicalAesKeySlot(keyslot, true));
/* On generic os, we don't worry about the security engine. */
smc::AsyncOperationKey op_key;
smc::Result res = smc::ComputeAes(std::addressof(op_key), reinterpret_cast<uintptr_t>(dst), mode, iv_ctr, reinterpret_cast<uintptr_t>(src), src_size);
if (res != smc::Result::Success) {
R_RETURN(smc::ConvertResult(res));
}
res = WaitAndGetResult(op_key);
if (res != smc::Result::Success) {
R_RETURN(smc::ConvertResult(res));
}
}
#endif
R_SUCCEED();
}
Result ComputeCmac(Cmac *out_cmac, s32 keyslot, const void *data, size_t size) {
R_UNLESS(size <= sizeof(g_work_buffer), spl::ResultInvalidBufferSize());
std::memcpy(g_work_buffer, data, size);
R_RETURN(smc::ConvertResult(smc::ComputeCmac(out_cmac, GetPhysicalAesKeySlot(keyslot, true), g_work_buffer, size)));
}
Result AllocateAesKeySlot(s32 *out_keyslot) {
/* Find an unused keyslot. */
for (s32 i = 0; i < AesKeySlotCount; ++i) {
if (!g_is_aes_keyslot_allocated[i]) {
g_is_aes_keyslot_allocated[i] = true;
g_aes_keyslot_contents[i].type = AesKeySlotContentType::None;
*out_keyslot = MakeVirtualAesKeySlot(i);
R_SUCCEED();
}
}
util::GetReference(g_aes_keyslot_available_event).Clear();
R_THROW(spl::ResultNoAvailableKeySlot());
}
Result DeallocateAesKeySlot(s32 keyslot) {
/* Only virtual keyslots can be freed. */
R_UNLESS(IsVirtualAesKeySlot(keyslot), spl::ResultInvalidKeySlot());
/* Check that the virtual keyslot is allocated. */
const s32 index = GetVirtualAesKeySlotIndex(keyslot);
R_UNLESS(g_is_aes_keyslot_allocated[index], spl::ResultInvalidKeySlot());
/* Clear the physical keyslot, if we're cached. */
s32 phys_slot;
if (g_aes_keyslot_cache.Release(std::addressof(phys_slot), keyslot)) {
ClearPhysicalAesKeySlot(phys_slot);
}
/* Clear the virtual keyslot. */
g_aes_keyslot_contents[index].type = AesKeySlotContentType::None;
g_is_aes_keyslot_allocated[index] = false;
util::GetReference(g_aes_keyslot_available_event).Signal();
R_SUCCEED();
}
Result TestAesKeySlot(s32 *out_index, bool *out_virtual, s32 keyslot) {
if (g_is_physical_keyslot_allowed && IsPhysicalAesKeySlot(keyslot)) {
*out_index = keyslot;
*out_virtual = false;
R_SUCCEED();
}
R_UNLESS(IsVirtualAesKeySlot(keyslot), spl::ResultInvalidKeySlot());
const s32 index = GetVirtualAesKeySlotIndex(keyslot);
R_UNLESS(g_is_aes_keyslot_allocated[index], spl::ResultInvalidKeySlot());
*out_index = index;
*out_virtual = true;
R_SUCCEED();
}
os::SystemEvent *GetAesKeySlotAvailableEvent() {
return util::GetPointer(g_aes_keyslot_available_event);
}
/* RSA. */
Result DecryptDeviceUniqueData(void *dst, size_t dst_size, const void *src, size_t src_size, const AccessKey &access_key, const KeySource &key_source, u32 option) {
struct DecryptDeviceUniqueDataLayout {
u8 data[Rsa2048BlockSize + DeviceUniqueDataMetaDataSize];
};
auto &layout = *reinterpret_cast<DecryptDeviceUniqueDataLayout *>(g_work_buffer);
/* Validate size. */
R_UNLESS(src_size >= DeviceUniqueDataMetaDataSize, spl::ResultInvalidBufferSize());
R_UNLESS(src_size <= sizeof(DecryptDeviceUniqueDataLayout), spl::ResultInvalidBufferSize());
std::memcpy(layout.data, src, src_size);
smc::Result smc_res;
size_t copy_size = 0;
if (g_is_modern_device_unique_data) {
copy_size = std::min(dst_size, src_size - DeviceUniqueDataMetaDataSize);
smc_res = smc::DecryptDeviceUniqueData(layout.data, src_size, access_key, key_source, static_cast<smc::DeviceUniqueDataMode>(option));
} else {
smc_res = smc::DecryptDeviceUniqueData(std::addressof(copy_size), layout.data, src_size, access_key, key_source, option);
copy_size = std::min(dst_size, copy_size);
}
if (smc_res == smc::Result::Success) {
std::memcpy(dst, layout.data, copy_size);
}
R_RETURN(smc::ConvertResult(smc_res));
}
/* SSL */
Result DecryptAndStoreSslClientCertKey(const void *src, size_t src_size, const AccessKey &access_key, const KeySource &key_source) {
R_RETURN(DecryptAndStoreDeviceUniqueKey(src, src_size, access_key, key_source, static_cast<u32>(smc::DeviceUniqueDataMode::DecryptAndStoreSslKey)));
}
Result ModularExponentiateWithSslClientCertKey(void *out, size_t out_size, const void *base, size_t base_size, const void *mod, size_t mod_size) {
R_RETURN(ModularExponentiateWithStorageKey(out, out_size, base, base_size, mod, mod_size, smc::ModularExponentiateWithStorageKeyMode::Ssl));
}
/* ES */
Result LoadEsDeviceKey(const void *src, size_t src_size, const AccessKey &access_key, const KeySource &key_source, u32 option) {
if (g_is_modern_device_unique_data) {
R_RETURN(DecryptAndStoreDeviceUniqueKey(src, src_size, access_key, key_source, option));
} else {
struct LoadEsDeviceKeyLayout {
u8 data[DeviceUniqueDataMetaDataSize + 2 * Rsa2048BlockSize + 0x10];
};
auto &layout = *reinterpret_cast<LoadEsDeviceKeyLayout *>(g_work_buffer);
/* Validate size. */
R_UNLESS(src_size <= sizeof(layout.data), spl::ResultInvalidBufferSize());
std::memcpy(layout.data, src, src_size);
R_RETURN(smc::ConvertResult(smc::LoadEsDeviceKey(layout.data, src_size, access_key, key_source, option)));
}
}
Result PrepareEsTitleKey(AccessKey *out_access_key, const void *base, size_t base_size, const void *mod, size_t mod_size, const void *label_digest, size_t label_digest_size, u32 generation) {
R_RETURN(PrepareEsDeviceUniqueKey(out_access_key, base, base_size, mod, mod_size, label_digest, label_digest_size, smc::EsDeviceUniqueKeyType::TitleKey, generation));
}
Result PrepareCommonEsTitleKey(AccessKey *out_access_key, const KeySource &key_source, u32 generation) {
R_RETURN(smc::ConvertResult(smc::PrepareCommonEsTitleKey(out_access_key, key_source, generation)));
}
Result DecryptAndStoreDrmDeviceCertKey(const void *src, size_t src_size, const AccessKey &access_key, const KeySource &key_source) {
R_RETURN(DecryptAndStoreDeviceUniqueKey(src, src_size, access_key, key_source, static_cast<u32>(smc::DeviceUniqueDataMode::DecryptAndStoreDrmDeviceCertKey)));
}
Result ModularExponentiateWithDrmDeviceCertKey(void *out, size_t out_size, const void *base, size_t base_size, const void *mod, size_t mod_size) {
R_RETURN(ModularExponentiateWithStorageKey(out, out_size, base, base_size, mod, mod_size, smc::ModularExponentiateWithStorageKeyMode::DrmDeviceCert));
}
Result PrepareEsArchiveKey(AccessKey *out_access_key, const void *base, size_t base_size, const void *mod, size_t mod_size, const void *label_digest, size_t label_digest_size, u32 generation) {
R_RETURN(PrepareEsDeviceUniqueKey(out_access_key, base, base_size, mod, mod_size, label_digest, label_digest_size, smc::EsDeviceUniqueKeyType::ArchiveKey, generation));
}
Result PrepareEsUnknown2Key(AccessKey *out_access_key, const void *base, size_t base_size, const void *mod, size_t mod_size, const void *label_digest, size_t label_digest_size, u32 generation) {
R_RETURN(PrepareEsDeviceUniqueKey(out_access_key, base, base_size, mod, mod_size, label_digest, label_digest_size, smc::EsDeviceUniqueKeyType::Unknown2, generation));
}
/* FS */
Result DecryptAndStoreGcKey(const void *src, size_t src_size, const AccessKey &access_key, const KeySource &key_source, u32 option) {
R_RETURN(DecryptAndStoreDeviceUniqueKey(src, src_size, access_key, key_source, option));
}
Result DecryptGcMessage(u32 *out_size, void *dst, size_t dst_size, const void *base, size_t base_size, const void *mod, size_t mod_size, const void *label_digest, size_t label_digest_size) {
/* Validate sizes. */
R_UNLESS(dst_size <= sizeof(g_work_buffer), spl::ResultInvalidBufferSize());
R_UNLESS(label_digest_size == LabelDigestSizeMax, spl::ResultInvalidBufferSize());
/* Nintendo doesn't check this result code, but we will. */
R_TRY(ModularExponentiateWithStorageKey(g_work_buffer, Rsa2048BlockSize, base, base_size, mod, mod_size, smc::ModularExponentiateWithStorageKeyMode::Gc));
const auto data_size = crypto::DecodeRsa2048OaepSha256(dst, dst_size, label_digest, label_digest_size, g_work_buffer, Rsa2048BlockSize);
R_UNLESS(data_size > 0, spl::ResultDecryptionFailed());
*out_size = static_cast<u32>(data_size);
R_SUCCEED();
}
Result GenerateSpecificAesKey(AesKey *out_key, const KeySource &key_source, u32 generation, u32 which) {
R_RETURN(smc::ConvertResult(smc::GenerateSpecificAesKey(out_key, key_source, generation, which)));
}
Result LoadPreparedAesKey(s32 keyslot, const AccessKey &access_key) {
/* Ensure we can load into the slot. */
const s32 phys_slot = GetPhysicalAesKeySlot(keyslot, false);
R_TRY(smc::ConvertResult(smc::LoadPreparedAesKey(phys_slot, access_key)));
/* Update our contents. */
const s32 index = GetVirtualAesKeySlotIndex(keyslot);
g_aes_keyslot_contents[index].type = AesKeySlotContentType::PreparedKey;
g_aes_keyslot_contents[index].prepared_key.access_key = access_key;
R_SUCCEED();
}
Result GetPackage2Hash(void *dst, const size_t size) {
u64 hash[4];
R_UNLESS(size >= sizeof(hash), spl::ResultInvalidBufferSize());
const smc::Result smc_res = smc::GetConfig(hash, 4, ConfigItem::Package2Hash);
if (smc_res != smc::Result::Success) {
R_RETURN(smc::ConvertResult(smc_res));
}
std::memcpy(dst, hash, sizeof(hash));
R_SUCCEED();
}
/* Manu. */
Result ReencryptDeviceUniqueData(void *dst, size_t dst_size, const void *src, size_t src_size, const AccessKey &access_key_dec, const KeySource &source_dec, const AccessKey &access_key_enc, const KeySource &source_enc, u32 option) {
struct ReencryptDeviceUniqueDataLayout {
u8 data[DeviceUniqueDataMetaDataSize + 2 * Rsa2048BlockSize + 0x10];
AccessKey access_key_dec;
KeySource source_dec;
AccessKey access_key_enc;
KeySource source_enc;
};
auto &layout = *reinterpret_cast<ReencryptDeviceUniqueDataLayout *>(g_work_buffer);
/* Validate size. */
R_UNLESS(src_size > DeviceUniqueDataMetaDataSize, spl::ResultInvalidBufferSize());
R_UNLESS(src_size <= sizeof(layout.data), spl::ResultInvalidBufferSize());
std::memcpy(layout.data, src, src_size);
layout.access_key_dec = access_key_dec;
layout.source_dec = source_dec;
layout.access_key_enc = access_key_enc;
layout.source_enc = source_enc;
const smc::Result smc_res = smc::ReencryptDeviceUniqueData(layout.data, src_size, layout.access_key_dec, layout.source_dec, layout.access_key_enc, layout.source_enc, option);
if (smc_res == smc::Result::Success) {
std::memcpy(dst, layout.data, std::min(dst_size, src_size));
}
R_RETURN(smc::ConvertResult(smc_res));
}
}
| 43,228
|
C++
|
.cpp
| 772
| 44.525907
| 260
| 0.620242
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,295
|
spl_secure_monitor_api.os.horizon.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/spl/smc/spl_secure_monitor_api.os.horizon.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
namespace ams::spl::smc {
Result SetConfig(AsyncOperationKey *out_op, spl::ConfigItem key, const u64 *value, size_t num_qwords, const void *sign) {
svc::SecureMonitorArguments args;
args.r[0] = static_cast<u64>(FunctionId::SetConfig);
args.r[1] = static_cast<u64>(key);
args.r[2] = reinterpret_cast<u64>(sign);
for (size_t i = 0; i < std::min(static_cast<size_t>(4), num_qwords); i++) {
args.r[3 + i] = value[i];
}
svc::CallSecureMonitor(std::addressof(args));
out_op->value = args.r[1];
return static_cast<Result>(args.r[0]);
}
Result GetConfig(u64 *out, size_t num_qwords, spl::ConfigItem key) {
svc::SecureMonitorArguments args;
args.r[0] = static_cast<u64>(FunctionId::GetConfig);
args.r[1] = static_cast<u64>(key);
svc::CallSecureMonitor(std::addressof(args));
for (size_t i = 0; i < std::min(static_cast<size_t>(4), num_qwords); i++) {
out[i] = args.r[1 + i];
}
return static_cast<Result>(args.r[0]);
}
Result GetResult(Result *out, AsyncOperationKey op) {
svc::SecureMonitorArguments args;
args.r[0] = static_cast<u64>(FunctionId::GetResult);
args.r[1] = op.value;
svc::CallSecureMonitor(std::addressof(args));
*out = static_cast<Result>(args.r[1]);
return static_cast<Result>(args.r[0]);
}
Result GetResultData(Result *out, void *out_buf, size_t out_buf_size, AsyncOperationKey op) {
svc::SecureMonitorArguments args;
args.r[0] = static_cast<u64>(FunctionId::GetResultData);
args.r[1] = op.value;
args.r[2] = reinterpret_cast<u64>(out_buf);
args.r[3] = out_buf_size;
svc::CallSecureMonitor(std::addressof(args));
*out = static_cast<Result>(args.r[1]);
return static_cast<Result>(args.r[0]);
}
Result ModularExponentiate(AsyncOperationKey *out_op, const void *base, const void *exp, size_t exp_size, const void *mod) {
svc::SecureMonitorArguments args;
args.r[0] = static_cast<u64>(FunctionId::ModularExponentiate);
args.r[1] = reinterpret_cast<u64>(base);
args.r[2] = reinterpret_cast<u64>(exp);
args.r[3] = reinterpret_cast<u64>(mod);
args.r[4] = exp_size;
svc::CallSecureMonitor(std::addressof(args));
out_op->value = args.r[1];
return static_cast<Result>(args.r[0]);
}
Result GenerateRandomBytes(void *out, size_t size) {
svc::SecureMonitorArguments args;
args.r[0] = static_cast<u64>(FunctionId::GenerateRandomBytes);
args.r[1] = size;
svc::CallSecureMonitor(std::addressof(args));
if (args.r[0] == static_cast<u64>(Result::Success) && (size <= sizeof(args) - sizeof(args.r[0]))) {
std::memcpy(out, std::addressof(args.r[1]), size);
}
return static_cast<Result>(args.r[0]);
}
Result GenerateAesKek(AccessKey *out, const KeySource &source, u32 generation, u32 option) {
svc::SecureMonitorArguments args;
args.r[0] = static_cast<u64>(FunctionId::GenerateAesKek);
args.r[1] = source.data64[0];
args.r[2] = source.data64[1];
args.r[3] = generation;
args.r[4] = option;
svc::CallSecureMonitor(std::addressof(args));
out->data64[0] = args.r[1];
out->data64[1] = args.r[2];
return static_cast<Result>(args.r[0]);
}
Result LoadAesKey(u32 keyslot, const AccessKey &access_key, const KeySource &source) {
svc::SecureMonitorArguments args;
args.r[0] = static_cast<u64>(FunctionId::LoadAesKey);
args.r[1] = keyslot;
args.r[2] = access_key.data64[0];
args.r[3] = access_key.data64[1];
args.r[4] = source.data64[0];
args.r[5] = source.data64[1];
svc::CallSecureMonitor(std::addressof(args));
return static_cast<Result>(args.r[0]);
}
Result ComputeAes(AsyncOperationKey *out_op, u64 dst_addr, u32 mode, const IvCtr &iv_ctr, u64 src_addr, size_t size) {
svc::SecureMonitorArguments args;
args.r[0] = static_cast<u64>(FunctionId::ComputeAes);
args.r[1] = mode;
args.r[2] = iv_ctr.data64[0];
args.r[3] = iv_ctr.data64[1];
args.r[4] = static_cast<u32>(src_addr);
args.r[5] = static_cast<u32>(dst_addr);
args.r[6] = size;
svc::CallSecureMonitor(std::addressof(args));
out_op->value = args.r[1];
return static_cast<Result>(args.r[0]);
}
Result GenerateSpecificAesKey(AesKey *out_key, const KeySource &source, u32 generation, u32 which) {
svc::SecureMonitorArguments args;
args.r[0] = static_cast<u64>(FunctionId::GenerateSpecificAesKey);
args.r[1] = source.data64[0];
args.r[2] = source.data64[1];
args.r[3] = generation;
args.r[4] = which;
svc::CallSecureMonitor(std::addressof(args));
out_key->data64[0] = args.r[1];
out_key->data64[1] = args.r[2];
return static_cast<Result>(args.r[0]);
}
Result ComputeCmac(Cmac *out_mac, u32 keyslot, const void *data, size_t size) {
svc::SecureMonitorArguments args;
args.r[0] = static_cast<u64>(FunctionId::ComputeCmac);
args.r[1] = keyslot;
args.r[2] = reinterpret_cast<u64>(data);
args.r[3] = size;
svc::CallSecureMonitor(std::addressof(args));
out_mac->data64[0] = args.r[1];
out_mac->data64[1] = args.r[2];
return static_cast<Result>(args.r[0]);
}
Result ReencryptDeviceUniqueData(void *data, size_t size, const AccessKey &access_key_dec, const KeySource &source_dec, const AccessKey &access_key_enc, const KeySource &source_enc, u32 option) {
svc::SecureMonitorArguments args;
args.r[0] = static_cast<u64>(FunctionId::ReencryptDeviceUniqueData);
args.r[1] = reinterpret_cast<u64>(std::addressof(access_key_dec));
args.r[2] = reinterpret_cast<u64>(std::addressof(access_key_enc));
args.r[3] = option;
args.r[4] = reinterpret_cast<u64>(data);
args.r[5] = size;
args.r[6] = reinterpret_cast<u64>(std::addressof(source_dec));
args.r[7] = reinterpret_cast<u64>(std::addressof(source_enc));
svc::CallSecureMonitor(std::addressof(args));
return static_cast<Result>(args.r[0]);
}
Result DecryptDeviceUniqueData(void *data, size_t size, const AccessKey &access_key, const KeySource &source, DeviceUniqueDataMode mode) {
svc::SecureMonitorArguments args;
args.r[0] = static_cast<u64>(FunctionId::DecryptDeviceUniqueData);
args.r[1] = access_key.data64[0];
args.r[2] = access_key.data64[1];
args.r[3] = static_cast<u32>(mode);
args.r[4] = reinterpret_cast<u64>(data);
args.r[5] = size;
args.r[6] = source.data64[0];
args.r[7] = source.data64[1];
svc::CallSecureMonitor(std::addressof(args));
return static_cast<Result>(args.r[0]);
}
Result ModularExponentiateWithStorageKey(AsyncOperationKey *out_op, const void *base, const void *mod, ModularExponentiateWithStorageKeyMode mode) {
svc::SecureMonitorArguments args;
args.r[0] = static_cast<u64>(FunctionId::ModularExponentiateWithStorageKey);
args.r[1] = reinterpret_cast<u64>(base);
args.r[2] = reinterpret_cast<u64>(mod);
args.r[3] = static_cast<u32>(mode);
svc::CallSecureMonitor(std::addressof(args));
out_op->value = args.r[1];
return static_cast<Result>(args.r[0]);
}
Result PrepareEsDeviceUniqueKey(AsyncOperationKey *out_op, const void *base, const void *mod, const void *label_digest, size_t label_digest_size, u32 option) {
svc::SecureMonitorArguments args;
args.r[0] = static_cast<u64>(FunctionId::PrepareEsDeviceUniqueKey);
args.r[1] = reinterpret_cast<u64>(base);
args.r[2] = reinterpret_cast<u64>(mod);
std::memset(std::addressof(args.r[3]), 0, 4 * sizeof(args.r[3]));
std::memcpy(std::addressof(args.r[3]), label_digest, std::min(static_cast<size_t>(4 * sizeof(args.r[3])), label_digest_size));
args.r[7] = option;
svc::CallSecureMonitor(std::addressof(args));
out_op->value = args.r[1];
return static_cast<Result>(args.r[0]);
}
Result LoadPreparedAesKey(u32 keyslot, const AccessKey &access_key) {
svc::SecureMonitorArguments args;
args.r[0] = static_cast<u64>(FunctionId::LoadPreparedAesKey);
args.r[1] = keyslot;
args.r[2] = access_key.data64[0];
args.r[3] = access_key.data64[1];
svc::CallSecureMonitor(std::addressof(args));
return static_cast<Result>(args.r[0]);
}
Result PrepareCommonEsTitleKey(AccessKey *out, const KeySource &source, u32 generation) {
svc::SecureMonitorArguments args;
args.r[0] = static_cast<u64>(FunctionId::PrepareCommonEsTitleKey);
args.r[1] = source.data64[0];
args.r[2] = source.data64[1];
args.r[3] = generation;
svc::CallSecureMonitor(std::addressof(args));
out->data64[0] = args.r[1];
out->data64[1] = args.r[2];
return static_cast<Result>(args.r[0]);
}
/* Deprecated functions. */
Result LoadEsDeviceKey(const void *data, size_t size, const AccessKey &access_key, const KeySource &source, u32 option) {
svc::SecureMonitorArguments args;
args.r[0] = static_cast<u64>(FunctionId::LoadEsDeviceKey);
args.r[1] = access_key.data64[0];
args.r[2] = access_key.data64[1];
args.r[3] = option;
args.r[4] = reinterpret_cast<u64>(data);
args.r[5] = size;
args.r[6] = source.data64[0];
args.r[7] = source.data64[1];
svc::CallSecureMonitor(std::addressof(args));
return static_cast<Result>(args.r[0]);
}
Result DecryptDeviceUniqueData(size_t *out_size, void *data, size_t size, const AccessKey &access_key, const KeySource &source, u32 option) {
svc::SecureMonitorArguments args;
args.r[0] = static_cast<u64>(FunctionId::DecryptDeviceUniqueData);
args.r[1] = access_key.data64[0];
args.r[2] = access_key.data64[1];
args.r[3] = option;
args.r[4] = reinterpret_cast<u64>(data);
args.r[5] = size;
args.r[6] = source.data64[0];
args.r[7] = source.data64[1];
svc::CallSecureMonitor(std::addressof(args));
*out_size = static_cast<size_t>(args.r[1]);
return static_cast<Result>(args.r[0]);
}
Result DecryptAndStoreGcKey(const void *data, size_t size, const AccessKey &access_key, const KeySource &source, u32 option) {
svc::SecureMonitorArguments args;
args.r[0] = static_cast<u64>(FunctionId::DecryptAndStoreGcKey);
args.r[1] = access_key.data64[0];
args.r[2] = access_key.data64[1];
args.r[3] = option;
args.r[4] = reinterpret_cast<u64>(data);
args.r[5] = size;
args.r[6] = source.data64[0];
args.r[7] = source.data64[1];
svc::CallSecureMonitor(std::addressof(args));
return static_cast<Result>(args.r[0]);
}
/* Atmosphere functions. */
namespace {
enum class IramCopyDirection {
FromIram = 0,
ToIram = 1,
};
inline Result AtmosphereIramCopy(uintptr_t dram_address, uintptr_t iram_address, size_t size, IramCopyDirection direction) {
svc::SecureMonitorArguments args;
args.r[0] = static_cast<u64>(FunctionId::AtmosphereIramCopy);
args.r[1] = dram_address;
args.r[2] = iram_address;
args.r[3] = size;
args.r[4] = static_cast<u64>(direction);
svc::CallSecureMonitor(std::addressof(args));
return static_cast<Result>(args.r[0]);
}
}
Result AtmosphereCopyToIram(uintptr_t iram_dst, const void *dram_src, size_t size) {
return AtmosphereIramCopy(reinterpret_cast<uintptr_t>(dram_src), iram_dst, size, IramCopyDirection::ToIram);
}
Result AtmosphereCopyFromIram(void *dram_dst, uintptr_t iram_src, size_t size) {
return AtmosphereIramCopy(reinterpret_cast<uintptr_t>(dram_dst), iram_src, size, IramCopyDirection::FromIram);
}
Result AtmosphereReadWriteRegister(uint64_t address, uint32_t mask, uint32_t value, uint32_t *out_value) {
svc::SecureMonitorArguments args;
args.r[0] = static_cast<u64>(FunctionId::AtmosphereReadWriteRegister);
args.r[1] = address;
args.r[2] = mask;
args.r[3] = value;
svc::CallSecureMonitor(std::addressof(args));
*out_value = static_cast<uint32_t>(args.r[1]);
return static_cast<Result>(args.r[0]);
}
Result AtmosphereGetEmummcConfig(void *out_config, void *out_paths, u32 storage_id) {
const u64 paths = reinterpret_cast<u64>(out_paths);
AMS_ABORT_UNLESS(util::IsAligned(paths, os::MemoryPageSize));
svc::SecureMonitorArguments args = {};
args.r[0] = static_cast<u64>(FunctionId::AtmosphereGetEmummcConfig);
args.r[1] = storage_id;
args.r[2] = paths;
svc::CallSecureMonitor(std::addressof(args));
std::memcpy(out_config, std::addressof(args.r[1]), sizeof(args) - sizeof(args.r[0]));
return static_cast<Result>(args.r[0]);
}
}
| 14,124
|
C++
|
.cpp
| 291
| 40.257732
| 199
| 0.633423
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,296
|
spl_secure_monitor_api.os.generic.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/spl/smc/spl_secure_monitor_api.os.generic.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include <exosphere/pkg1.hpp>
namespace ams::spl::smc {
#define SMC_R_SUCCEEEDED(res) (res == smc::Result::Success)
#define SMC_R_FAILED(res) (res != smc::Result::Success)
#define SMC_R_TRY(res_expr) ({ const auto _tmp_r_try_rc = (res_expr); if (SMC_R_FAILED(_tmp_r_try_rc)) { return _tmp_r_try_rc; } })
#define SMC_R_UNLESS(cond, RES) ({ if (!(cond)) { return smc::Result::RES; }})
namespace {
enum SealKey {
SealKey_LoadAesKey = 0,
SealKey_DecryptDeviceUniqueData = 1,
SealKey_ImportLotusKey = 2,
SealKey_ImportEsDeviceKey = 3,
SealKey_ReencryptDeviceUniqueData = 4,
SealKey_ImportSslKey = 5,
SealKey_ImportEsClientCertKey = 6,
SealKey_Count,
};
enum KeyType {
KeyType_Default = 0,
KeyType_NormalOnly = 1,
KeyType_RecoveryOnly = 2,
KeyType_NormalAndRecovery = 3,
KeyType_Count,
};
enum EsCommonKeyType {
EsCommonKeyType_TitleKey = 0,
EsCommonKeyType_ArchiveKey = 1,
EsCommonKeyType_Unknown2 = 2,
EsCommonKeyType_Count,
};
struct GenerateAesKekOption {
using IsDeviceUnique = util::BitPack32::Field<0, 1, bool>;
using KeyTypeIndex = util::BitPack32::Field<1, 4, KeyType>;
using SealKeyIndex = util::BitPack32::Field<5, 3, SealKey>;
using Reserved = util::BitPack32::Field<8, 24, u32>;
};
struct ComputeAesOption {
using KeySlot = util::BitPack32::Field<0, 3, int>;
using CipherModeIndex = util::BitPack32::Field<4, 2, CipherMode>;
};
constexpr const u8 KeyTypeSources[KeyType_Count][crypto::AesEncryptor128::KeySize] = {
[KeyType_Default] = { 0x4D, 0x87, 0x09, 0x86, 0xC4, 0x5D, 0x20, 0x72, 0x2F, 0xBA, 0x10, 0x53, 0xDA, 0x92, 0xE8, 0xA9 },
[KeyType_NormalOnly] = { 0x25, 0x03, 0x31, 0xFB, 0x25, 0x26, 0x0B, 0x79, 0x8C, 0x80, 0xD2, 0x69, 0x98, 0xE2, 0x22, 0x77 },
[KeyType_RecoveryOnly] = { 0x76, 0x14, 0x1D, 0x34, 0x93, 0x2D, 0xE1, 0x84, 0x24, 0x7B, 0x66, 0x65, 0x55, 0x04, 0x65, 0x81 },
[KeyType_NormalAndRecovery] = { 0xAF, 0x3D, 0xB7, 0xF3, 0x08, 0xA2, 0xD8, 0xA2, 0x08, 0xCA, 0x18, 0xA8, 0x69, 0x46, 0xC9, 0x0B },
};
constexpr const u8 SealKeyMasks[SealKey_Count][crypto::AesEncryptor128::KeySize] = {
[SealKey_LoadAesKey] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
[SealKey_DecryptDeviceUniqueData] = { 0xA2, 0xAB, 0xBF, 0x9C, 0x92, 0x2F, 0xBB, 0xE3, 0x78, 0x79, 0x9B, 0xC0, 0xCC, 0xEA, 0xA5, 0x74 },
[SealKey_ImportLotusKey] = { 0x57, 0xE2, 0xD9, 0x45, 0xE4, 0x92, 0xF4, 0xFD, 0xC3, 0xF9, 0x86, 0x38, 0x89, 0x78, 0x9F, 0x3C },
[SealKey_ImportEsDeviceKey] = { 0xE5, 0x4D, 0x9A, 0x02, 0xF0, 0x4F, 0x5F, 0xA8, 0xAD, 0x76, 0x0A, 0xF6, 0x32, 0x95, 0x59, 0xBB },
[SealKey_ReencryptDeviceUniqueData] = { 0x59, 0xD9, 0x31, 0xF4, 0xA7, 0x97, 0xB8, 0x14, 0x40, 0xD6, 0xA2, 0x60, 0x2B, 0xED, 0x15, 0x31 },
[SealKey_ImportSslKey] = { 0xFD, 0x6A, 0x25, 0xE5, 0xD8, 0x38, 0x7F, 0x91, 0x49, 0xDA, 0xF8, 0x59, 0xA8, 0x28, 0xE6, 0x75 },
[SealKey_ImportEsClientCertKey] = { 0x89, 0x96, 0x43, 0x9A, 0x7C, 0xD5, 0x59, 0x55, 0x24, 0xD5, 0x24, 0x18, 0xAB, 0x6C, 0x04, 0x61 },
};
constexpr const u8 EsCommonKeySources[EsCommonKeyType_Count][AesKeySize] = {
[EsCommonKeyType_TitleKey] = { 0x1E, 0xDC, 0x7B, 0x3B, 0x60, 0xE6, 0xB4, 0xD8, 0x78, 0xB8, 0x17, 0x15, 0x98, 0x5E, 0x62, 0x9B },
[EsCommonKeyType_ArchiveKey] = { 0x3B, 0x78, 0xF2, 0x61, 0x0F, 0x9D, 0x5A, 0xE2, 0x7B, 0x4E, 0x45, 0xAF, 0xCB, 0x0B, 0x67, 0x4D },
[EsCommonKeyType_Unknown2] = { 0x42, 0x64, 0x0B, 0xE3, 0x5F, 0xC6, 0xBE, 0x47, 0xC7, 0xB4, 0x84, 0xC5, 0xEB, 0x63, 0xAA, 0x02 },
};
constexpr u64 InvalidAsyncKey = 0;
constinit os::SdkMutex g_crypto_lock;
constinit u64 g_async_key = InvalidAsyncKey;
constinit u8 g_async_result_buffer[1_KB];
u64 GenerateRandomU64() {
u64 v = -1;
crypto::GenerateCryptographicallyRandomBytes(std::addressof(v), sizeof(v));
return v;
}
constinit u8 g_master_keys[pkg1::KeyGeneration_Max][crypto::AesEncryptor128::KeySize]{};
constinit u8 g_device_keys[pkg1::KeyGeneration_Max][crypto::AesEncryptor128::KeySize]{};
class KeySlotManager {
private:
u8 m_key_slot_contents[pkg1::AesKeySlot_Count][crypto::AesEncryptor256::KeySize];
public:
constexpr KeySlotManager() : m_key_slot_contents{} { /* ... */ }
public:
const u8 *GetKey(s32 slot) const {
return m_key_slot_contents[slot];
}
void LoadAesKey(s32 slot, const AccessKey &access_key, const KeySource &key_source) {
crypto::AesDecryptor128 aes;
aes.Initialize(std::addressof(access_key), sizeof(access_key));
aes.DecryptBlock(m_key_slot_contents[slot], crypto::AesEncryptor128::KeySize, std::addressof(key_source), sizeof(key_source));
}
void LoadPreparedAesKey(s32 slot, const AccessKey &access_key) {
this->SetAesKey128(slot, std::addressof(access_key), sizeof(access_key));
}
s32 PrepareDeviceMasterKey(s32 generation) {
constexpr s32 Slot = pkg1::AesKeySlot_Smc;
this->SetAesKey128(Slot, g_device_keys[generation], crypto::AesEncryptor128::KeySize);
return Slot;
}
s32 PrepareMasterKey(s32 generation) {
constexpr s32 Slot = pkg1::AesKeySlot_Smc;
this->SetAesKey128(Slot, g_master_keys[generation], crypto::AesEncryptor128::KeySize);
return Slot;
}
void SetAesKey128(s32 slot, const void *key, size_t key_size) {
std::memcpy(m_key_slot_contents[slot], key, key_size);
}
void SetEncryptedAesKey128(s32 dst, s32 src, const void *key_source, size_t key_source_size) {
crypto::AesDecryptor128 aes;
aes.Initialize(this->GetKey(src), crypto::AesDecryptor128::KeySize);
aes.DecryptBlock(m_key_slot_contents[dst], crypto::AesEncryptor128::KeySize, key_source, key_source_size);
}
void DecryptAes128(void *dst, size_t dst_size, s32 slot, const void *src, size_t src_size) {
crypto::AesDecryptor128 aes;
aes.Initialize(this->GetKey(slot), crypto::AesDecryptor128::KeySize);
aes.DecryptBlock(dst, dst_size, src, src_size);
}
};
constexpr bool IsUserAesKeySlot(s32 slot) {
return pkg1::IsUserAesKeySlot(slot);
}
constinit KeySlotManager g_key_slot_manager;
void DecryptWithEsCommonKey(void *dst, size_t dst_size, const void *src, size_t src_size, EsCommonKeyType type, int generation) {
/* Validate pre-conditions. */
AMS_ASSERT(dst_size == crypto::AesEncryptor128::KeySize);
AMS_ASSERT(src_size == crypto::AesEncryptor128::KeySize);
AMS_ASSERT(0 <= type && type < EsCommonKeyType_Count);
/* Prepare the master key for the generation. */
const int slot = g_key_slot_manager.PrepareMasterKey(generation);
/* Derive the es common key. */
g_key_slot_manager.SetEncryptedAesKey128(pkg1::AesKeySlot_Smc, slot, EsCommonKeySources[type], crypto::AesEncryptor128::KeySize);
/* Decrypt the input using the common key. */
g_key_slot_manager.DecryptAes128(dst, dst_size, pkg1::AesKeySlot_Smc, src, src_size);
}
}
void PresetInternalKey(const AesKey *key, u32 generation, bool device) {
if (device) {
std::memcpy(g_device_keys[generation], key, sizeof(*key));
} else {
std::memcpy(g_master_keys[generation], key, sizeof(*key));
}
}
//Result SetConfig(AsyncOperationKey *out_op, spl::ConfigItem key, const u64 *value, size_t num_qwords, const void *sign) {
// svc::SecureMonitorArguments args;
//
// args.r[0] = static_cast<u64>(FunctionId::SetConfig);
// args.r[1] = static_cast<u64>(key);
// args.r[2] = reinterpret_cast<u64>(sign);
//
// for (size_t i = 0; i < std::min(static_cast<size_t>(4), num_qwords); i++) {
// args.r[3 + i] = value[i];
// }
// svc::CallSecureMonitor(std::addressof(args));
//
// out_op->value = args.r[1];
// return static_cast<Result>(args.r[0]);
//}
//Result GetConfig(u64 *out, size_t num_qwords, spl::ConfigItem key) {
// svc::SecureMonitorArguments args;
//
// args.r[0] = static_cast<u64>(FunctionId::GetConfig);
// args.r[1] = static_cast<u64>(key);
// svc::CallSecureMonitor(std::addressof(args));
//
// for (size_t i = 0; i < std::min(static_cast<size_t>(4), num_qwords); i++) {
// out[i] = args.r[1 + i];
// }
// return static_cast<Result>(args.r[0]);
//}
Result GetResult(Result *out, AsyncOperationKey op) {
SMC_R_UNLESS(g_async_key != InvalidAsyncKey, NoAsyncOperation);
SMC_R_UNLESS(g_async_key == op.value, InvalidAsyncOperation);
g_async_key = InvalidAsyncKey;
*out = smc::Result::Success;
return smc::Result::Success;
}
Result GetResultData(Result *out, void *out_buf, size_t out_buf_size, AsyncOperationKey op) {
SMC_R_UNLESS(g_async_key != InvalidAsyncKey, NoAsyncOperation);
SMC_R_UNLESS(g_async_key == op.value, InvalidAsyncOperation);
SMC_R_UNLESS(out_buf_size <= sizeof(g_async_result_buffer), InvalidArgument);
g_async_key = InvalidAsyncKey;
std::memcpy(out_buf, g_async_result_buffer, out_buf_size);
*out = smc::Result::Success;
return smc::Result::Success;
}
//Result ModularExponentiate(AsyncOperationKey *out_op, const void *base, const void *exp, size_t exp_size, const void *mod) {
// svc::SecureMonitorArguments args;
//
// args.r[0] = static_cast<u64>(FunctionId::ModularExponentiate);
// args.r[1] = reinterpret_cast<u64>(base);
// args.r[2] = reinterpret_cast<u64>(exp);
// args.r[3] = reinterpret_cast<u64>(mod);
// args.r[4] = exp_size;
// svc::CallSecureMonitor(std::addressof(args));
//
// out_op->value = args.r[1];
// return static_cast<Result>(args.r[0]);
//}
Result GenerateRandomBytes(void *out, size_t size) {
crypto::GenerateCryptographicallyRandomBytes(out, size);
return smc::Result::Success;
}
Result GenerateAesKek(AccessKey *out, const KeySource &source, u32 user_generation, u32 option_value) {
std::scoped_lock lk(g_crypto_lock);
const int pkg1_generation = std::max<int>(static_cast<int>(user_generation) - 1, pkg1::KeyGeneration_1_0_0);
const util::BitPack32 option = { option_value };
const bool is_device_unique = option.Get<GenerateAesKekOption::IsDeviceUnique>();
const auto key_type = option.Get<GenerateAesKekOption::KeyTypeIndex>();
const auto seal_key = option.Get<GenerateAesKekOption::SealKeyIndex>();
const u32 reserved = option.Get<GenerateAesKekOption::Reserved>();
/* Validate arguments. */
SMC_R_UNLESS(reserved == 0, InvalidArgument);
if (is_device_unique) {
SMC_R_UNLESS(pkg1::IsValidDeviceUniqueKeyGeneration(pkg1_generation), InvalidArgument);
} else {
SMC_R_UNLESS(pkg1_generation < pkg1::KeyGeneration_Max, InvalidArgument);
}
SMC_R_UNLESS(0 <= key_type && key_type < KeyType_Count, InvalidArgument);
SMC_R_UNLESS(0 <= seal_key && seal_key < SealKey_Count, InvalidArgument);
/* Here N might check if key type is normal or recovery only, but we're not going to enforce that. */
u8 static_source[crypto::AesEncryptor128::KeySize];
/* Derive the static source. */
for (size_t i = 0; i < sizeof(static_source); ++i) {
static_source[i] = KeyTypeSources[key_type][i] ^ SealKeyMasks[seal_key][i];
}
/* Get the slot. */
const int slot = is_device_unique ? g_key_slot_manager.PrepareDeviceMasterKey(pkg1_generation) : g_key_slot_manager.PrepareMasterKey(pkg1_generation);
/* Derive a static generation kek. */
g_key_slot_manager.SetEncryptedAesKey128(pkg1::AesKeySlot_Smc, slot, static_source, sizeof(static_source));
/* Decrypt the input using the static-derived key. */
g_key_slot_manager.DecryptAes128(out, sizeof(*out), pkg1::AesKeySlot_Smc, std::addressof(source), sizeof(source));
return smc::Result::Success;
}
Result LoadAesKey(u32 keyslot, const AccessKey &access_key, const KeySource &source) {
std::scoped_lock lk(g_crypto_lock);
/* Check args. */
SMC_R_UNLESS(IsUserAesKeySlot(keyslot), InvalidArgument);
/* Unseal the access key. */
g_key_slot_manager.SetAesKey128(pkg1::AesKeySlot_Smc, std::addressof(access_key), sizeof(access_key));
/* Derive the key. */
g_key_slot_manager.SetEncryptedAesKey128(keyslot, pkg1::AesKeySlot_Smc, std::addressof(source), sizeof(source));
return smc::Result::Success;
}
Result ComputeAes(AsyncOperationKey *out_op, u64 dst_addr, u32 mode, const IvCtr &iv_ctr, u64 src_addr, size_t size) {
std::scoped_lock lk(g_crypto_lock);
/* Check size. */
SMC_R_UNLESS(util::IsAligned(size, crypto::AesEncryptor128::BlockSize), InvalidArgument);
const util::BitPack32 option = { mode };
const int slot = option.Get<ComputeAesOption::KeySlot>();
const auto cipher_mode = option.Get<ComputeAesOption::CipherModeIndex>();
SMC_R_UNLESS(IsUserAesKeySlot(slot), InvalidArgument);
/* Set a random async key. */
g_async_key = GenerateRandomU64();
switch (cipher_mode) {
case CipherMode::CbcEncrypt: crypto::EncryptAes128Cbc(reinterpret_cast<void *>(dst_addr), size, g_key_slot_manager.GetKey(slot), crypto::AesEncryptor128::KeySize, iv_ctr.data, sizeof(iv_ctr.data), reinterpret_cast<const void *>(src_addr), size); break;
case CipherMode::CbcDecrypt: crypto::DecryptAes128Cbc(reinterpret_cast<void *>(dst_addr), size, g_key_slot_manager.GetKey(slot), crypto::AesEncryptor128::KeySize, iv_ctr.data, sizeof(iv_ctr.data), reinterpret_cast<const void *>(src_addr), size); break;
case CipherMode::Ctr: crypto::EncryptAes128Ctr(reinterpret_cast<void *>(dst_addr), size, g_key_slot_manager.GetKey(slot), crypto::AesEncryptor128::KeySize, iv_ctr.data, sizeof(iv_ctr.data), reinterpret_cast<const void *>(src_addr), size); break;
default:
return smc::Result::InvalidArgument;
}
*out_op = AsyncOperationKey{g_async_key};
return smc::Result::Success;
}
//Result GenerateSpecificAesKey(AesKey *out_key, const KeySource &source, u32 generation, u32 which) {
// svc::SecureMonitorArguments args;
//
// args.r[0] = static_cast<u64>(FunctionId::GenerateSpecificAesKey);
// args.r[1] = source.data64[0];
// args.r[2] = source.data64[1];
// args.r[3] = generation;
// args.r[4] = which;
// svc::CallSecureMonitor(std::addressof(args));
//
// out_key->data64[0] = args.r[1];
// out_key->data64[1] = args.r[2];
// return static_cast<Result>(args.r[0]);
//}
//Result ComputeCmac(Cmac *out_mac, u32 keyslot, const void *data, size_t size) {
// svc::SecureMonitorArguments args;
//
// args.r[0] = static_cast<u64>(FunctionId::ComputeCmac);
// args.r[1] = keyslot;
// args.r[2] = reinterpret_cast<u64>(data);
// args.r[3] = size;
// svc::CallSecureMonitor(std::addressof(args));
//
// out_mac->data64[0] = args.r[1];
// out_mac->data64[1] = args.r[2];
// return static_cast<Result>(args.r[0]);
//}
//Result ReencryptDeviceUniqueData(void *data, size_t size, const AccessKey &access_key_dec, const KeySource &source_dec, const AccessKey &access_key_enc, const KeySource &source_enc, u32 option) {
// svc::SecureMonitorArguments args;
//
// args.r[0] = static_cast<u64>(FunctionId::ReencryptDeviceUniqueData);
// args.r[1] = reinterpret_cast<u64>(std::addressof(access_key_dec));
// args.r[2] = reinterpret_cast<u64>(std::addressof(access_key_enc));
// args.r[3] = option;
// args.r[4] = reinterpret_cast<u64>(data);
// args.r[5] = size;
// args.r[6] = reinterpret_cast<u64>(std::addressof(source_dec));
// args.r[7] = reinterpret_cast<u64>(std::addressof(source_enc));
// svc::CallSecureMonitor(std::addressof(args));
//
// return static_cast<Result>(args.r[0]);
//}
//Result DecryptDeviceUniqueData(void *data, size_t size, const AccessKey &access_key, const KeySource &source, DeviceUniqueDataMode mode) {
// svc::SecureMonitorArguments args;
//
// args.r[0] = static_cast<u64>(FunctionId::DecryptDeviceUniqueData);
// args.r[1] = access_key.data64[0];
// args.r[2] = access_key.data64[1];
// args.r[3] = static_cast<u32>(mode);
// args.r[4] = reinterpret_cast<u64>(data);
// args.r[5] = size;
// args.r[6] = source.data64[0];
// args.r[7] = source.data64[1];
// svc::CallSecureMonitor(std::addressof(args));
//
// return static_cast<Result>(args.r[0]);
//}
//Result ModularExponentiateWithStorageKey(AsyncOperationKey *out_op, const void *base, const void *mod, ModularExponentiateWithStorageKeyMode mode) {
// svc::SecureMonitorArguments args;
//
// args.r[0] = static_cast<u64>(FunctionId::ModularExponentiateWithStorageKey);
// args.r[1] = reinterpret_cast<u64>(base);
// args.r[2] = reinterpret_cast<u64>(mod);
// args.r[3] = static_cast<u32>(mode);
// svc::CallSecureMonitor(std::addressof(args));
//
// out_op->value = args.r[1];
// return static_cast<Result>(args.r[0]);
//}
//Result PrepareEsDeviceUniqueKey(AsyncOperationKey *out_op, const void *base, const void *mod, const void *label_digest, size_t label_digest_size, u32 option) {
// svc::SecureMonitorArguments args;
//
// args.r[0] = static_cast<u64>(FunctionId::PrepareEsDeviceUniqueKey);
// args.r[1] = reinterpret_cast<u64>(base);
// args.r[2] = reinterpret_cast<u64>(mod);
// std::memset(std::addressof(args.r[3]), 0, 4 * sizeof(args.r[3]));
// std::memcpy(std::addressof(args.r[3]), label_digest, std::min(static_cast<size_t>(4 * sizeof(args.r[3])), label_digest_size));
// args.r[7] = option;
// svc::CallSecureMonitor(std::addressof(args));
//
// out_op->value = args.r[1];
// return static_cast<Result>(args.r[0]);
//}
Result LoadPreparedAesKey(u32 keyslot, const AccessKey &access_key) {
std::scoped_lock lk(g_crypto_lock);
/* Check args. */
SMC_R_UNLESS(IsUserAesKeySlot(keyslot), InvalidArgument);
/* Unseal the key. */
g_key_slot_manager.SetAesKey128(keyslot, std::addressof(access_key), sizeof(access_key));
return smc::Result::Success;
}
Result PrepareCommonEsTitleKey(AccessKey *out, const KeySource &source, u32 generation) {
/* Decode arguments. */
const int pkg1_gen = std::max<int>(pkg1::KeyGeneration_1_0_0, static_cast<int>(generation) - 1);
/* Validate arguments. */
SMC_R_UNLESS(pkg1_gen < pkg1::KeyGeneration_Max, InvalidArgument);
/* Derive the key. */
u8 key[crypto::AesEncryptor128::KeySize];
DecryptWithEsCommonKey(key, sizeof(key), std::addressof(source), sizeof(source), EsCommonKeyType_TitleKey, pkg1_gen);
/* Copy the access key to the output. */
std::memcpy(out, key, sizeof(key));
return smc::Result::Success;
}
//
///* Deprecated functions. */
//Result LoadEsDeviceKey(const void *data, size_t size, const AccessKey &access_key, const KeySource &source, u32 option) {
// svc::SecureMonitorArguments args;
//
// args.r[0] = static_cast<u64>(FunctionId::LoadEsDeviceKey);
// args.r[1] = access_key.data64[0];
// args.r[2] = access_key.data64[1];
// args.r[3] = option;
// args.r[4] = reinterpret_cast<u64>(data);
// args.r[5] = size;
// args.r[6] = source.data64[0];
// args.r[7] = source.data64[1];
// svc::CallSecureMonitor(std::addressof(args));
//
// return static_cast<Result>(args.r[0]);
//}
//Result DecryptDeviceUniqueData(size_t *out_size, void *data, size_t size, const AccessKey &access_key, const KeySource &source, u32 option) {
// svc::SecureMonitorArguments args;
//
// args.r[0] = static_cast<u64>(FunctionId::DecryptDeviceUniqueData);
// args.r[1] = access_key.data64[0];
// args.r[2] = access_key.data64[1];
// args.r[3] = option;
// args.r[4] = reinterpret_cast<u64>(data);
// args.r[5] = size;
// args.r[6] = source.data64[0];
// args.r[7] = source.data64[1];
// svc::CallSecureMonitor(std::addressof(args));
//
// *out_size = static_cast<size_t>(args.r[1]);
// return static_cast<Result>(args.r[0]);
//}
//Result DecryptAndStoreGcKey(const void *data, size_t size, const AccessKey &access_key, const KeySource &source, u32 option) {
// svc::SecureMonitorArguments args;
//
// args.r[0] = static_cast<u64>(FunctionId::DecryptAndStoreGcKey);
// args.r[1] = access_key.data64[0];
// args.r[2] = access_key.data64[1];
// args.r[3] = option;
// args.r[4] = reinterpret_cast<u64>(data);
// args.r[5] = size;
// args.r[6] = source.data64[0];
// args.r[7] = source.data64[1];
// svc::CallSecureMonitor(std::addressof(args));
//
// return static_cast<Result>(args.r[0]);
//}
Result AtmosphereCopyToIram(uintptr_t, const void *, size_t ) {
AMS_ABORT("AtmosphereCopyToIram not supported on generic SecureMonitor api.");
}
Result AtmosphereCopyFromIram(void *, uintptr_t, size_t) {
AMS_ABORT("AtmosphereCopyToIram not supported on generic SecureMonitor api.");
}
Result AtmosphereReadWriteRegister(uint64_t, uint32_t, uint32_t, uint32_t *) {
AMS_ABORT("AtmosphereReadWriteRegister not supported on generic SecureMonitor api.");
}
Result AtmosphereGetEmummcConfig(void *out_config, void *out_paths, u32 storage_id) {
/* TODO: We actually probably should support this one on generic? */
AMS_UNUSED(out_config, out_paths, storage_id);
AMS_ABORT("AtmosphereGetEmummcConfig not supported on generic SecureMonitor api.");
}
}
| 24,404
|
C++
|
.cpp
| 439
| 47.134396
| 264
| 0.615188
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,297
|
htclow_manager.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/htclow_manager.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_manager.hpp"
#include "htclow_manager_impl.hpp"
namespace ams::htclow {
HtclowManager::HtclowManager(mem::StandardAllocator *allocator) : m_allocator(allocator), m_impl(static_cast<HtclowManagerImpl *>(allocator->Allocate(sizeof(HtclowManagerImpl), alignof(HtclowManagerImpl)))) {
std::construct_at(m_impl, m_allocator);
}
HtclowManager::~HtclowManager() {
std::destroy_at(m_impl);
m_allocator->Free(m_impl);
}
Result HtclowManager::OpenDriver(impl::DriverType driver_type) {
R_RETURN(m_impl->OpenDriver(driver_type));
}
void HtclowManager::CloseDriver() {
return m_impl->CloseDriver();
}
Result HtclowManager::Open(impl::ChannelInternalType channel) {
R_RETURN(m_impl->Open(channel));
}
Result HtclowManager::Close(impl::ChannelInternalType channel) {
R_RETURN(m_impl->Close(channel));
}
void HtclowManager::Resume() {
return m_impl->Resume();
}
void HtclowManager::Suspend() {
return m_impl->Suspend();
}
Result HtclowManager::ConnectBegin(u32 *out_task_id, impl::ChannelInternalType channel) {
R_RETURN(m_impl->ConnectBegin(out_task_id, channel));
}
Result HtclowManager::ConnectEnd(impl::ChannelInternalType channel, u32 task_id) {
R_RETURN(m_impl->ConnectEnd(channel, task_id));
}
void HtclowManager::Disconnect() {
return m_impl->Disconnect();
}
Result HtclowManager::FlushBegin(u32 *out_task_id, impl::ChannelInternalType channel) {
R_RETURN(m_impl->FlushBegin(out_task_id, channel));
}
Result HtclowManager::FlushEnd(u32 task_id) {
R_RETURN(m_impl->FlushEnd(task_id));
}
ChannelState HtclowManager::GetChannelState(impl::ChannelInternalType channel) {
return m_impl->GetChannelState(channel);
}
os::EventType *HtclowManager::GetChannelStateEvent(impl::ChannelInternalType channel) {
return m_impl->GetChannelStateEvent(channel);
}
impl::DriverType HtclowManager::GetDriverType() {
return m_impl->GetDriverType();
}
os::EventType *HtclowManager::GetTaskEvent(u32 task_id) {
return m_impl->GetTaskEvent(task_id);
}
void HtclowManager::NotifyAsleep() {
return m_impl->NotifyAsleep();
}
void HtclowManager::NotifyAwake() {
return m_impl->NotifyAwake();
}
Result HtclowManager::ReceiveBegin(u32 *out_task_id, impl::ChannelInternalType channel, size_t size) {
R_RETURN(m_impl->ReceiveBegin(out_task_id, channel, size));
}
Result HtclowManager::ReceiveEnd(size_t *out, void *dst, size_t dst_size, impl::ChannelInternalType channel, u32 task_id) {
R_RETURN(m_impl->ReceiveEnd(out, dst, dst_size, channel, task_id));
}
Result HtclowManager::SendBegin(u32 *out_task_id, size_t *out, const void *src, size_t src_size, impl::ChannelInternalType channel) {
R_RETURN(m_impl->SendBegin(out_task_id, out, src, src_size, channel));
}
Result HtclowManager::SendEnd(u32 task_id) {
R_RETURN(m_impl->SendEnd(task_id));
}
Result HtclowManager::WaitReceiveBegin(u32 *out_task_id, impl::ChannelInternalType channel, size_t size) {
R_RETURN(m_impl->WaitReceiveBegin(out_task_id, channel, size));
}
Result HtclowManager::WaitReceiveEnd(u32 task_id) {
R_RETURN(m_impl->WaitReceiveEnd(task_id));
}
void HtclowManager::SetConfig(impl::ChannelInternalType channel, const ChannelConfig &config) {
return m_impl->SetConfig(channel, config);
}
void HtclowManager::SetDebugDriver(driver::IDriver *driver) {
return m_impl->SetDebugDriver(driver);
}
void HtclowManager::SetReceiveBuffer(impl::ChannelInternalType channel, void *buf, size_t buf_size) {
return m_impl->SetReceiveBuffer(channel, buf, buf_size);
}
void HtclowManager::SetSendBuffer(impl::ChannelInternalType channel, void *buf, size_t buf_size) {
return m_impl->SetSendBuffer(channel, buf, buf_size);
}
void HtclowManager::SetSendBufferWithData(impl::ChannelInternalType channel, const void *buf, size_t buf_size) {
return m_impl->SetSendBufferWithData(channel, buf, buf_size);
}
Result HtclowManager::Shutdown(impl::ChannelInternalType channel) {
R_RETURN(m_impl->Shutdown(channel));
}
}
| 5,041
|
C++
|
.cpp
| 114
| 38.385965
| 212
| 0.70188
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,298
|
htclow_manager_impl.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/htclow_manager_impl.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_manager_impl.hpp"
#include "htclow_default_channel_config.hpp"
namespace ams::htclow {
HtclowManagerImpl::HtclowManagerImpl(mem::StandardAllocator *allocator)
: m_packet_factory(allocator), m_driver_manager(allocator), m_mux(std::addressof(m_packet_factory), std::addressof(m_ctrl_state_machine)),
m_ctrl_packet_factory(allocator), m_ctrl_state_machine(), m_ctrl_service(std::addressof(m_ctrl_packet_factory), std::addressof(m_ctrl_state_machine), std::addressof(m_mux)),
m_worker(allocator, std::addressof(m_mux), std::addressof(m_ctrl_service)),
m_listener(allocator, std::addressof(m_mux), std::addressof(m_ctrl_service), std::addressof(m_worker)),
m_is_driver_open(false)
{
/* ... */
}
HtclowManagerImpl::~HtclowManagerImpl() {
/* ... */
}
Result HtclowManagerImpl::OpenDriver(impl::DriverType driver_type) {
/* Set the driver type. */
m_ctrl_service.SetDriverType(driver_type);
/* Ensure that we don't end up in an invalid state. */
auto drv_guard = SCOPE_GUARD { m_ctrl_service.SetDriverType(impl::DriverType::Unknown); };
/* Try to open the driver. */
R_TRY(m_driver_manager.OpenDriver(driver_type));
/* Start the listener. */
m_listener.Start(m_driver_manager.GetCurrentDriver());
/* Note the driver as open. */
m_is_driver_open = true;
drv_guard.Cancel();
R_SUCCEED();
}
void HtclowManagerImpl::CloseDriver() {
/* Close the driver, if we're open. */
if (m_is_driver_open) {
/* Cancel the driver. */
m_driver_manager.Cancel();
/* Stop our listener. */
m_listener.Cancel();
m_listener.Wait();
/* Close the driver. */
m_driver_manager.CloseDriver();
/* Set the driver type to unknown. */
m_ctrl_service.SetDriverType(impl::DriverType::Unknown);
/* Note the driver as closed. */
m_is_driver_open = false;
}
}
Result HtclowManagerImpl::Open(impl::ChannelInternalType channel) {
R_RETURN(m_mux.Open(channel));
}
Result HtclowManagerImpl::Close(impl::ChannelInternalType channel) {
R_RETURN(m_mux.Close(channel));
}
void HtclowManagerImpl::Resume() {
/* Get our driver. */
auto *driver = m_driver_manager.GetCurrentDriver();
/* Resume our driver. */
driver->Resume();
/* Start the listener. */
m_listener.Start(driver);
/* Resume our control service. */
m_ctrl_service.Resume();
}
void HtclowManagerImpl::Suspend() {
/* Suspend our control service. */
m_ctrl_service.Suspend();
/* Stop our listener. */
m_listener.Cancel();
m_listener.Wait();
/* Suspend our driver. */
m_driver_manager.GetCurrentDriver()->Suspend();
}
Result HtclowManagerImpl::ConnectBegin(u32 *out_task_id, impl::ChannelInternalType channel) {
/* Begin connecting. */
R_TRY(m_mux.ConnectBegin(out_task_id, channel));
/* Try to ready ourselves. */
m_ctrl_service.TryReady();
R_SUCCEED();
}
Result HtclowManagerImpl::ConnectEnd(impl::ChannelInternalType channel, u32 task_id) {
R_RETURN(m_mux.ConnectEnd(channel, task_id));
}
void HtclowManagerImpl::Disconnect() {
return m_ctrl_service.Disconnect();
}
Result HtclowManagerImpl::FlushBegin(u32 *out_task_id, impl::ChannelInternalType channel) {
R_RETURN(m_mux.FlushBegin(out_task_id, channel));
}
Result HtclowManagerImpl::FlushEnd(u32 task_id) {
R_RETURN(m_mux.FlushEnd(task_id));
}
ChannelState HtclowManagerImpl::GetChannelState(impl::ChannelInternalType channel) {
return m_mux.GetChannelState(channel);
}
os::EventType *HtclowManagerImpl::GetChannelStateEvent(impl::ChannelInternalType channel) {
return m_mux.GetChannelStateEvent(channel);
}
impl::DriverType HtclowManagerImpl::GetDriverType() {
return m_driver_manager.GetDriverType();
}
os::EventType *HtclowManagerImpl::GetTaskEvent(u32 task_id) {
return m_mux.GetTaskEvent(task_id);
}
void HtclowManagerImpl::NotifyAsleep() {
return m_ctrl_service.NotifyAsleep();
}
void HtclowManagerImpl::NotifyAwake() {
return m_ctrl_service.NotifyAwake();
}
Result HtclowManagerImpl::ReceiveBegin(u32 *out_task_id, impl::ChannelInternalType channel, size_t size) {
R_RETURN(m_mux.ReceiveBegin(out_task_id, channel, size));
}
Result HtclowManagerImpl::ReceiveEnd(size_t *out, void *dst, size_t dst_size, impl::ChannelInternalType channel, u32 task_id) {
R_RETURN(m_mux.ReceiveEnd(out, dst, dst_size, channel, task_id));
}
Result HtclowManagerImpl::SendBegin(u32 *out_task_id, size_t *out, const void *src, size_t src_size, impl::ChannelInternalType channel) {
R_RETURN(m_mux.SendBegin(out_task_id, out, src, src_size, channel));
}
Result HtclowManagerImpl::SendEnd(u32 task_id) {
R_RETURN(m_mux.SendEnd(task_id));
}
Result HtclowManagerImpl::WaitReceiveBegin(u32 *out_task_id, impl::ChannelInternalType channel, size_t size) {
R_RETURN(m_mux.WaitReceiveBegin(out_task_id, channel, size));
}
Result HtclowManagerImpl::WaitReceiveEnd(u32 task_id) {
R_RETURN(m_mux.WaitReceiveEnd(task_id));
}
void HtclowManagerImpl::SetConfig(impl::ChannelInternalType channel, const ChannelConfig &config) {
return m_mux.SetConfig(channel, config);
}
void HtclowManagerImpl::SetDebugDriver(driver::IDriver *driver) {
m_driver_manager.SetDebugDriver(driver);
}
void HtclowManagerImpl::SetReceiveBuffer(impl::ChannelInternalType channel, void *buf, size_t buf_size) {
return m_mux.SetReceiveBuffer(channel, buf, buf_size);
}
void HtclowManagerImpl::SetSendBuffer(impl::ChannelInternalType channel, void *buf, size_t buf_size) {
return m_mux.SetSendBuffer(channel, buf, buf_size, m_driver_manager.GetDriverType() == impl::DriverType::Usb ? sizeof(PacketBody) : DefaultChannelConfig.max_packet_size);
}
void HtclowManagerImpl::SetSendBufferWithData(impl::ChannelInternalType channel, const void *buf, size_t buf_size) {
return m_mux.SetSendBufferWithData(channel, buf, buf_size, m_driver_manager.GetDriverType() == impl::DriverType::Usb ? sizeof(PacketBody) : DefaultChannelConfig.max_packet_size);
}
Result HtclowManagerImpl::Shutdown(impl::ChannelInternalType channel) {
R_RETURN(m_mux.Shutdown(channel));
}
}
| 7,403
|
C++
|
.cpp
| 160
| 39.13125
| 186
| 0.673662
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,299
|
htclow_worker.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/htclow_worker.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_worker.hpp"
namespace ams::htclow {
namespace {
constexpr inline size_t ThreadStackSize = 4_KB;
}
Worker::Worker(mem::StandardAllocator *allocator, mux::Mux *mux, ctrl::HtcctrlService *ctrl_srv)
: m_thread_stack_size(ThreadStackSize), m_allocator(allocator), m_mux(mux), m_service(ctrl_srv), m_driver(nullptr), m_event(os::EventClearMode_ManualClear), m_cancelled(false)
{
/* Allocate stacks. */
m_receive_thread_stack = m_allocator->Allocate(m_thread_stack_size, os::ThreadStackAlignment);
m_send_thread_stack = m_allocator->Allocate(m_thread_stack_size, os::ThreadStackAlignment);
}
void Worker::SetDriver(driver::IDriver *driver) {
m_driver = driver;
}
void Worker::Start() {
/* Clear our cancelled state. */
m_cancelled = false;
/* Clear our event. */
m_event.Clear();
/* Create our threads. */
R_ABORT_UNLESS(os::CreateThread(std::addressof(m_receive_thread), ReceiveThreadEntry, this, m_receive_thread_stack, ThreadStackSize, AMS_GET_SYSTEM_THREAD_PRIORITY(htc, HtclowReceive)));
R_ABORT_UNLESS(os::CreateThread(std::addressof(m_send_thread), SendThreadEntry, this, m_send_thread_stack, ThreadStackSize, AMS_GET_SYSTEM_THREAD_PRIORITY(htc, HtclowSend)));
/* Set thread names. */
os::SetThreadNamePointer(std::addressof(m_receive_thread), AMS_GET_SYSTEM_THREAD_NAME(htc, HtclowReceive));
os::SetThreadNamePointer(std::addressof(m_send_thread), AMS_GET_SYSTEM_THREAD_NAME(htc, HtclowSend));
/* Start our threads. */
os::StartThread(std::addressof(m_receive_thread));
os::StartThread(std::addressof(m_send_thread));
}
void Worker::Wait() {
os::WaitThread(std::addressof(m_receive_thread));
os::WaitThread(std::addressof(m_send_thread));
os::DestroyThread(std::addressof(m_receive_thread));
os::DestroyThread(std::addressof(m_send_thread));
}
void Worker::ReceiveThread() {
this->ProcessReceive();
m_driver->CancelSendReceive();
this->Cancel();
}
void Worker::SendThread() {
this->ProcessSend();
m_driver->CancelSendReceive();
this->Cancel();
}
void Worker::Cancel() {
/* Set ourselves as cancelled, and signal. */
m_cancelled = true;
m_event.Signal();
}
Result Worker::ProcessReceive() {
/* Forever receive packets. */
constexpr size_t MaxPacketHeaderSize = std::max(sizeof(PacketHeader), sizeof(ctrl::HtcctrlPacketHeader));
u8 packet_header_storage[MaxPacketHeaderSize];
while (true) {
/* Receive the packet header. */
R_TRY(m_driver->Receive(packet_header_storage, sizeof(packet_header_storage)));
/* Check if the packet is a control packet. */
if (ctrl::HtcctrlPacketHeader *ctrl_header = reinterpret_cast<ctrl::HtcctrlPacketHeader *>(packet_header_storage); ctrl_header->signature == ctrl::HtcctrlSignature) {
/* Process the packet. */
R_TRY(this->ProcessReceive(*ctrl_header));
} else {
/* Otherwise, we must have a normal packet. */
PacketHeader *header = reinterpret_cast<PacketHeader *>(packet_header_storage);
R_UNLESS(header->signature == HtcGen2Signature, htclow::ResultProtocolError());
/* Process the packet. */
R_TRY(this->ProcessReceive(*header));
}
}
}
Result Worker::ProcessReceive(const ctrl::HtcctrlPacketHeader &header) {
/* Check the header. */
R_TRY(m_service->CheckReceivedHeader(header));
/* Receive the body, if we have one. */
if (header.body_size > 0) {
R_TRY(m_driver->Receive(m_receive_packet_body, header.body_size));
}
/* Process the received packet. */
m_service->ProcessReceivePacket(header, m_receive_packet_body, header.body_size);
R_SUCCEED();
}
Result Worker::ProcessReceive(const PacketHeader &header) {
/* Check the header. */
R_TRY(m_mux->CheckReceivedHeader(header));
/* Receive the body, if we have one. */
if (header.body_size > 0) {
R_TRY(m_driver->Receive(m_receive_packet_body, header.body_size));
}
/* Process the received packet. */
m_mux->ProcessReceivePacket(header, m_receive_packet_body, header.body_size);
R_SUCCEED();
}
Result Worker::ProcessSend() {
/* Forever process packets. */
while (true) {
const auto index = os::WaitAny(m_service->GetSendPacketEvent(), m_mux->GetSendPacketEvent(), m_event.GetBase());
if (index == 0) {
/* HtcctrlService packet. */
/* Clear the packet event. */
os::ClearEvent(m_service->GetSendPacketEvent());
/* While we have packets, send them. */
auto *packet_header = reinterpret_cast<ctrl::HtcctrlPacketHeader *>(m_send_buffer);
auto *packet_body = reinterpret_cast<ctrl::HtcctrlPacketBody *>(m_send_buffer + sizeof(*packet_header));
int body_size;
while (m_service->QuerySendPacket(packet_header, packet_body, std::addressof(body_size))) {
m_service->RemovePacket(*packet_header);
R_TRY(m_driver->Send(packet_header, body_size + sizeof(*packet_header)));
}
} else if (index == 1) {
/* Mux packet. */
/* Clear the packet event. */
os::ClearEvent(m_mux->GetSendPacketEvent());
/* While we have packets, send them. */
auto *packet_header = reinterpret_cast<PacketHeader *>(m_send_buffer);
auto *packet_body = reinterpret_cast<PacketBody *>(m_send_buffer + sizeof(*packet_header));
int body_size;
while (m_mux->QuerySendPacket(packet_header, packet_body, std::addressof(body_size))) {
R_TRY(m_driver->Send(packet_header, body_size + sizeof(*packet_header)));
m_mux->RemovePacket(*packet_header);
}
} else {
/* Our event. */
/* Check if we're cancelled. */
if (m_cancelled) {
R_THROW(htclow::ResultCancelled());
}
}
}
}
}
| 7,207
|
C++
|
.cpp
| 147
| 39.07483
| 194
| 0.613293
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,300
|
htclow_packet_factory.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/htclow_packet_factory.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_packet_factory.hpp"
namespace ams::htclow {
void PacketFactory::Delete(Packet *packet) {
PacketDeleter{m_allocator}(packet);
}
std::unique_ptr<Packet, PacketDeleter> PacketFactory::MakeSendPacketCommon(impl::ChannelInternalType channel, s16 version, int body_size) {
/* Allocate memory for the packet. */
if (void *buffer = m_allocator->Allocate(sizeof(Packet), alignof(Packet)); buffer != nullptr) {
/* Convert the buffer to a packet. */
Packet *packet = static_cast<Packet *>(buffer);
/* Construct the packet. */
std::construct_at(packet, m_allocator, body_size + sizeof(PacketHeader));
/* Create the unique pointer. */
std::unique_ptr<Packet, PacketDeleter> ptr(packet, PacketDeleter{m_allocator});
/* Set packet header fields. */
if (ptr && ptr->IsAllocationSucceeded()) {
PacketHeader *header = ptr->GetHeader();
header->signature = HtcGen2Signature;
header->offset = 0;
header->reserved = 0;
header->body_size = body_size;
header->version = version;
header->channel = channel;
header->share = 0;
}
return ptr;
} else {
return std::unique_ptr<Packet, PacketDeleter>(nullptr, PacketDeleter{m_allocator});
}
}
std::unique_ptr<Packet, PacketDeleter> PacketFactory::MakeDataPacket(impl::ChannelInternalType channel, s16 version, const void *body, int body_size, u64 share, u32 offset) {
auto packet = this->MakeSendPacketCommon(channel, version, body_size);
if (packet) {
PacketHeader *header = packet->GetHeader();
header->packet_type = PacketType_Data;
header->offset = offset;
header->share = share;
packet->CopyBody(body, body_size);
AMS_ASSERT(packet->GetBodySize() == body_size);
}
return packet;
}
std::unique_ptr<Packet, PacketDeleter> PacketFactory::MakeMaxDataPacket(impl::ChannelInternalType channel, s16 version, u64 share) {
auto packet = this->MakeSendPacketCommon(channel, version, 0);
if (packet) {
PacketHeader *header = packet->GetHeader();
header->packet_type = PacketType_MaxData;
header->share = share;
}
return packet;
}
std::unique_ptr<Packet, PacketDeleter> PacketFactory::MakeErrorPacket(impl::ChannelInternalType channel) {
auto packet = this->MakeSendPacketCommon(channel, 0, 0);
if (packet) {
PacketHeader *header = packet->GetHeader();
header->packet_type = PacketType_Error;
}
return packet;
}
}
| 3,525
|
C++
|
.cpp
| 76
| 37.447368
| 178
| 0.633022
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,301
|
htclow_manager_holder.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/htclow_manager_holder.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_manager.hpp"
namespace ams::htclow::HtclowManagerHolder {
namespace {
constinit os::SdkMutex g_holder_mutex;
constinit int g_holder_reference_count = 0;
mem::StandardAllocator g_allocator;
constinit HtclowManager *g_manager = nullptr;
constinit htclow::impl::DriverType g_default_driver_type = htclow::impl::DriverType::Socket;
alignas(os::MemoryPageSize) u8 g_heap_buffer[928_KB];
}
void AddReference() {
std::scoped_lock lk(g_holder_mutex);
if ((g_holder_reference_count++) == 0) {
/* Initialize the allocator for the manager. */
g_allocator.Initialize(g_heap_buffer, sizeof(g_heap_buffer));
/* Allocate the manager. */
g_manager = static_cast<HtclowManager *>(g_allocator.Allocate(sizeof(HtclowManager), alignof(HtclowManager)));
/* Construct the manager. */
std::construct_at(g_manager, std::addressof(g_allocator));
/* Open the driver. */
R_ABORT_UNLESS(g_manager->OpenDriver(g_default_driver_type));
}
AMS_ASSERT(g_holder_reference_count > 0);
}
void Release() {
std::scoped_lock lk(g_holder_mutex);
AMS_ASSERT(g_holder_reference_count > 0);
if ((--g_holder_reference_count) == 0) {
/* Disconnect. */
g_manager->Disconnect();
/* Close the driver. */
g_manager->CloseDriver();
/* Destroy the manager. */
std::destroy_at(g_manager);
g_allocator.Free(g_manager);
g_manager = nullptr;
/* Finalize the allocator. */
g_allocator.Finalize();
}
}
HtclowManager *GetHtclowManager() {
std::scoped_lock lk(g_holder_mutex);
return g_manager;
}
void SetDefaultDriver(htclow::impl::DriverType driver_type) {
g_default_driver_type = driver_type;
}
}
| 2,637
|
C++
|
.cpp
| 64
| 33.484375
| 122
| 0.639859
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,302
|
htclow_channel.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/htclow_channel.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_channel.hpp"
namespace ams::htclow {
Result Channel::Open(const Module *module, ChannelId id) {
/* Check we're not already initialized. */
AMS_ASSERT(!module->GetBase()->_is_initialized);
/* Set our channel type. */
m_channel = {
._is_initialized = true,
._module_id = module->GetBase()->_id,
._channel_id = id,
};
/* Open the channel. */
R_RETURN(m_manager->Open(impl::ConvertChannelType(m_channel)));
}
void Channel::Close() {
m_manager->Close(impl::ConvertChannelType(m_channel));
}
ChannelState Channel::GetChannelState() {
return m_manager->GetChannelState(impl::ConvertChannelType(m_channel));
}
os::EventType *Channel::GetChannelStateEvent() {
return m_manager->GetChannelStateEvent(impl::ConvertChannelType(m_channel));
}
Result Channel::Connect() {
const auto channel = impl::ConvertChannelType(m_channel);
/* Begin the flush. */
u32 task_id{};
R_TRY(m_manager->ConnectBegin(std::addressof(task_id), channel));
/* Wait for the task to finish. */
this->WaitEvent(m_manager->GetTaskEvent(task_id), false);
/* End the flush. */
R_RETURN(m_manager->ConnectEnd(channel, task_id));
}
Result Channel::Flush() {
/* Begin the flush. */
u32 task_id{};
R_TRY(m_manager->FlushBegin(std::addressof(task_id), impl::ConvertChannelType(m_channel)));
/* Wait for the task to finish. */
this->WaitEvent(m_manager->GetTaskEvent(task_id), true);
/* End the flush. */
R_RETURN(m_manager->FlushEnd(task_id));
}
void Channel::Shutdown() {
m_manager->Shutdown(impl::ConvertChannelType(m_channel));
}
Result Channel::Receive(s64 *out, void *dst, s64 size, ReceiveOption option) {
/* Check pre-conditions. */
AMS_ABORT_UNLESS(util::IsIntValueRepresentable<size_t>(size));
/* Determine the minimum allowable receive size. */
s64 min_size;
switch (option) {
case htclow::ReceiveOption_NonBlocking: min_size = 0; break;
case htclow::ReceiveOption_ReceiveAnyData: min_size = 1; break;
case htclow::ReceiveOption_ReceiveAllData: min_size = size; break;
AMS_UNREACHABLE_DEFAULT_CASE();
}
/* Repeatedly receive. */
s64 received = 0;
do {
s64 cur_received;
const Result result = this->ReceiveInternal(std::addressof(cur_received), static_cast<u8 *>(dst) + received, size - received, option);
if (R_FAILED(result)) {
if (htclow::ResultChannelReceiveBufferEmpty::Includes(result)) {
R_UNLESS(option != htclow::ReceiveOption_NonBlocking, htclow::ResultNonBlockingReceiveFailed());
}
if (htclow::ResultChannelNotExist::Includes(result)) {
*out = received;
}
R_RETURN(result);
}
received += static_cast<size_t>(cur_received);
} while (received < min_size);
/* Set output size. */
AMS_ASSERT(received <= size);
*out = received;
R_SUCCEED();
}
Result Channel::Send(s64 *out, const void *src, s64 size) {
/* Check pre-conditions. */
AMS_ASSERT(util::IsIntValueRepresentable<size_t>(size));
/* Convert channel. */
const auto channel = impl::ConvertChannelType(m_channel);
/* Loop sending. */
s64 total_sent;
size_t cur_sent;
for (total_sent = 0; total_sent < size; total_sent += cur_sent) {
AMS_ASSERT(util::IsIntValueRepresentable<size_t>(size - total_sent));
/* Begin the send. */
u32 task_id{};
const auto begin_result = m_manager->SendBegin(std::addressof(task_id), std::addressof(cur_sent), static_cast<const u8 *>(src) + total_sent, size - total_sent, channel);
if (R_FAILED(begin_result)) {
if (total_sent != 0) {
break;
} else {
R_RETURN(begin_result);
}
}
/* Wait for the task to finish. */
this->WaitEvent(m_manager->GetTaskEvent(task_id), true);
/* Finish the send. */
R_ABORT_UNLESS(m_manager->SendEnd(task_id));
}
/* Set output size. */
AMS_ASSERT(total_sent <= size);
*out = total_sent;
R_SUCCEED();
}
void Channel::SetConfig(const ChannelConfig &config) {
m_manager->SetConfig(impl::ConvertChannelType(m_channel), config);
}
void Channel::SetReceiveBuffer(void *buf, size_t size) {
m_manager->SetReceiveBuffer(impl::ConvertChannelType(m_channel), buf, size);
}
void Channel::SetSendBuffer(void *buf, size_t size) {
m_manager->SetSendBuffer(impl::ConvertChannelType(m_channel), buf, size);
}
void Channel::SetSendBufferWithData(const void *buf, size_t size) {
m_manager->SetSendBufferWithData(impl::ConvertChannelType(m_channel), buf, size);
}
Result Channel::WaitReceive(s64 size) {
/* Check pre-conditions. */
AMS_ASSERT(util::IsIntValueRepresentable<size_t>(size));
R_RETURN(this->WaitReceiveInternal(size, nullptr));
}
Result Channel::WaitReceive(s64 size, os::EventType *event) {
/* Check pre-conditions. */
AMS_ASSERT(util::IsIntValueRepresentable<size_t>(size));
AMS_ASSERT(event != nullptr);
R_RETURN(this->WaitReceiveInternal(size, event));
}
void Channel::WaitEvent(os::EventType *event, bool) {
return os::WaitEvent(event);
}
Result Channel::ReceiveInternal(s64 *out, void *dst, s64 size, ReceiveOption option) {
const auto channel = impl::ConvertChannelType(m_channel);
const bool blocking = option != ReceiveOption_NonBlocking;
/* Begin the receive. */
u32 task_id{};
R_TRY(m_manager->ReceiveBegin(std::addressof(task_id), channel, blocking ? 1 : 0));
/* Wait for the task to finish. */
this->WaitEvent(m_manager->GetTaskEvent(task_id), false);
/* Receive the data. */
size_t received;
AMS_ASSERT(util::IsIntValueRepresentable<size_t>(size));
R_TRY(m_manager->ReceiveEnd(std::addressof(received), dst, static_cast<size_t>(size), channel, task_id));
/* Set the output size. */
AMS_ASSERT(util::IsIntValueRepresentable<s64>(received));
*out = static_cast<s64>(received);
R_SUCCEED();
}
Result Channel::WaitReceiveInternal(s64 size, os::EventType *event) {
const auto channel = impl::ConvertChannelType(m_channel);
/* Begin the wait. */
u32 task_id{};
R_TRY(m_manager->WaitReceiveBegin(std::addressof(task_id), channel, size));
/* Perform the wait. */
if (event != nullptr) {
if (os::WaitAny(event, m_manager->GetTaskEvent(task_id)) == 0) {
m_manager->WaitReceiveEnd(task_id);
R_THROW(htclow::ResultChannelWaitCancelled());
}
} else {
this->WaitEvent(m_manager->GetTaskEvent(task_id), false);
}
/* End the wait. */
R_RETURN(m_manager->WaitReceiveEnd(task_id));
}
}
| 8,103
|
C++
|
.cpp
| 184
| 35.054348
| 181
| 0.611083
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,303
|
htclow_listener.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/htclow_listener.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_listener.hpp"
namespace ams::htclow {
namespace {
constexpr inline size_t ThreadStackSize = 4_KB;
}
Listener::Listener(mem::StandardAllocator *allocator, mux::Mux *mux, ctrl::HtcctrlService *ctrl_srv, Worker *worker)
: m_thread_stack_size(ThreadStackSize), m_allocator(allocator), m_mux(mux), m_service(ctrl_srv), m_worker(worker), m_event(os::EventClearMode_ManualClear), m_driver(nullptr), m_thread_running(false), m_cancelled(false)
{
/* Allocate stack. */
m_listen_thread_stack = m_allocator->Allocate(m_thread_stack_size, os::ThreadStackAlignment);
}
void Listener::Start(driver::IDriver *driver) {
/* Check pre-conditions. */
AMS_ASSERT(!m_thread_running);
/* Create the thread. */
R_ABORT_UNLESS(os::CreateThread(std::addressof(m_listen_thread), ListenThreadEntry, this, m_listen_thread_stack, ThreadStackSize, AMS_GET_SYSTEM_THREAD_PRIORITY(htc, HtclowListen)));
/* Set the thread name. */
os::SetThreadNamePointer(std::addressof(m_listen_thread), AMS_GET_SYSTEM_THREAD_NAME(htc, HtclowListen));
/* Set our driver. */
m_driver = driver;
/* Set state. */
m_thread_running = true;
m_cancelled = false;
/* Clear our event. */
m_event.Clear();
/* Start the thread. */
os::StartThread(std::addressof(m_listen_thread));
}
void Listener::Cancel() {
/* Mark ourselves as cancelled. */
m_cancelled = true;
/* Cancel our worker. */
m_worker->Cancel();
/* Signal our event. */
m_event.Signal();
/* Cancel our driver. */
m_driver->CancelSendReceive();
}
void Listener::Wait() {
/* Wait for our listen thread to exit. */
os::WaitThread(std::addressof(m_listen_thread));
/* Destroy our listen thread. */
os::DestroyThread(std::addressof(m_listen_thread));
/* Clear our driver. */
m_driver = nullptr;
/* Mark our thread as not running. */
m_thread_running = false;
}
void Listener::ListenThread() {
/* Check pre-conditions. */
AMS_ASSERT(m_driver != nullptr);
AMS_ASSERT(m_worker != nullptr);
/* Set the worker's driver. */
m_worker->SetDriver(m_driver);
/* Loop forever, while we're not cancelled. */
while (!m_cancelled) {
/* Connect. */
if (R_FAILED(m_driver->Connect(m_event.GetBase()))) {
return;
}
/* Notify that we're connected. */
R_ABORT_UNLESS(m_service->NotifyDriverConnected());
/* Start the worker. */
m_worker->Start();
/* Wait for the worker to end. */
m_worker->Wait();
/* Shutdown the driver. */
m_driver->Shutdown();
/* Notify that we're disconnected. */
R_ABORT_UNLESS(m_service->NotifyDriverDisconnected());
}
}
}
| 3,709
|
C++
|
.cpp
| 89
| 33.808989
| 226
| 0.617655
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,304
|
htclow_ctrl_settings_holder.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/ctrl/htclow_ctrl_settings_holder.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_ctrl_settings_holder.hpp"
namespace ams::htclow::ctrl {
void SettingsHolder::LoadSettings() {
/* Load configuration id. */
{
settings::factory::ConfigurationId1 cfg_id;
settings::factory::GetConfigurationId1(std::addressof(cfg_id));
if (cfg_id.str[0]) {
util::Strlcpy(m_hardware_type, cfg_id.str, sizeof(m_hardware_type));
} else {
util::Strlcpy(m_hardware_type, "Unknown", sizeof(m_hardware_type));
}
}
/* Load device name. */
{
char device_name[0x40];
settings::fwdbg::GetSettingsItemValue(device_name, sizeof(device_name), "target_manager", "device_name");
util::Strlcpy(m_target_name, device_name, sizeof(m_target_name));
}
/* Load serial number. */
{
settings::factory::SerialNumber sn;
if (R_SUCCEEDED(settings::factory::GetSerialNumber(std::addressof(sn)))) {
util::Strlcpy(m_serial_number, sn.str, sizeof(m_serial_number));
} else {
m_serial_number[0] = '\x00';
}
}
/* Load firmware version. */
{
settings::system::FirmwareVersion fw_ver;
settings::system::GetFirmwareVersion(std::addressof(fw_ver));
util::Strlcpy(m_firmware_version, fw_ver.display_name, sizeof(m_firmware_version));
}
}
}
| 2,134
|
C++
|
.cpp
| 52
| 32.942308
| 117
| 0.626024
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,305
|
htclow_ctrl_state_machine.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/ctrl/htclow_ctrl_state_machine.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_ctrl_state_machine.hpp"
#include "htclow_ctrl_service_channels.hpp"
namespace ams::htclow::ctrl {
HtcctrlStateMachine::HtcctrlStateMachine() : m_map(), m_state(HtcctrlState_DriverDisconnected), m_prev_state(HtcctrlState_DriverDisconnected), m_mutex() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Initialize our map. */
m_map.Initialize(MaxChannelCount, m_map_buffer, sizeof(m_map_buffer));
/* Insert each service channel the map. */
for (const auto &channel : ServiceChannels) {
m_map.insert(std::make_pair<impl::ChannelInternalType, ServiceChannelState>(impl::ChannelInternalType{channel}, ServiceChannelState{}));
}
}
HtcctrlState HtcctrlStateMachine::GetHtcctrlState() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
return m_state;
}
Result HtcctrlStateMachine::SetHtcctrlState(bool *out_transitioned, HtcctrlState state) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Check that the transition is allowed. */
R_UNLESS(ctrl::IsStateTransitionAllowed(m_state, state), htclow::ResultHtcctrlStateTransitionNotAllowed());
/* Get the state pre-transition. */
const auto old_state = m_state;
/* Set the state. */
this->SetStateWithoutCheckInternal(state);
/* Note whether we transitioned. */
*out_transitioned = state != old_state;
R_SUCCEED();
}
bool HtcctrlStateMachine::IsInformationNeeded() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
return !ctrl::IsDisconnected(m_state) && m_state != HtcctrlState_DriverConnected;
}
bool HtcctrlStateMachine::IsDisconnectionNeeded() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
return !ctrl::IsDisconnected(m_state) && m_state != HtcctrlState_Sleep && m_state != HtcctrlState_DriverConnected;
}
bool HtcctrlStateMachine::IsConnected() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
return ctrl::IsConnected(m_state);
}
bool HtcctrlStateMachine::IsReadied() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
return ctrl::IsReadied(m_state);
}
bool HtcctrlStateMachine::IsUnconnectable() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
return !ctrl::IsConnected(m_state);
}
bool HtcctrlStateMachine::IsDisconnected() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
return ctrl::IsDisconnected(m_state);
}
bool HtcctrlStateMachine::IsSleeping() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
return ctrl::IsSleeping(m_state);
}
bool HtcctrlStateMachine::IsConnectedStatusChanged() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
return ctrl::IsConnected(m_prev_state) ^ ctrl::IsConnected(m_state);
}
bool HtcctrlStateMachine::IsSleepingStatusChanged() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
return ctrl::IsSleeping(m_prev_state) ^ ctrl::IsSleeping(m_state);
}
void HtcctrlStateMachine::SetStateWithoutCheckInternal(HtcctrlState state) {
if (m_state != state) {
/* Clear service channel states, if we should. */
if (ctrl::IsDisconnected(state)) {
this->ClearServiceChannelStates();
}
/* Transition our state. */
m_prev_state = m_state;
m_state = state;
}
}
void HtcctrlStateMachine::ClearServiceChannelStates() {
/* Clear all values in our map. */
for (auto &pair : m_map) {
pair.second = {};
}
}
bool HtcctrlStateMachine::IsPossibleToSendReady() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
return m_state == HtcctrlState_SentReadyFromHost && this->AreServiceChannelsConnecting();
}
bool HtcctrlStateMachine::IsUnsupportedServiceChannelToShutdown(const impl::ChannelInternalType &channel) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
auto it = m_map.find(channel);
return it != m_map.end() && it->second.connect == ServiceChannelConnect_ConnectingChecked && it->second.support == ServiceChannelSupport_Unsupported;
}
bool HtcctrlStateMachine::IsConnectable(const impl::ChannelInternalType &channel) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
auto it = m_map.find(channel);
return ctrl::IsConnected(m_state) && (it == m_map.end() || it->second.connect != ServiceChannelConnect_ConnectingChecked);
}
void HtcctrlStateMachine::SetConnecting(const impl::ChannelInternalType &channel) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
auto it = m_map.find(channel);
if (it != m_map.end() && it->second.connect != ServiceChannelConnect_ConnectingChecked) {
it->second.connect = ServiceChannelConnect_Connecting;
}
}
void HtcctrlStateMachine::SetNotConnecting(const impl::ChannelInternalType &channel) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
auto it = m_map.find(channel);
if (it != m_map.end() && it->second.connect != ServiceChannelConnect_ConnectingChecked) {
it->second.connect = ServiceChannelConnect_NotConnecting;
}
}
void HtcctrlStateMachine::SetConnectingChecked() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
for (auto &pair : m_map) {
pair.second.connect = ServiceChannelConnect_ConnectingChecked;
}
}
void HtcctrlStateMachine::NotifySupportedServiceChannels(const impl::ChannelInternalType *channels, int num_channels) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
auto IsSupportedServiceChannel = [](const impl::ChannelInternalType &channel, const impl::ChannelInternalType *supported, int num_supported) ALWAYS_INLINE_LAMBDA -> bool {
for (auto i = 0; i < num_supported; ++i) {
if (channel.module_id == supported[i].module_id && channel.channel_id == supported[i].channel_id) {
return true;
}
}
return false;
};
for (auto &pair : m_map) {
if (IsSupportedServiceChannel(pair.first, channels, num_channels)) {
pair.second.support = ServiceChannelSupport_Suppported;
} else {
pair.second.support = ServiceChannelSupport_Unsupported;
}
}
}
bool HtcctrlStateMachine::AreServiceChannelsConnecting() {
for (auto &pair : m_map) {
if (pair.second.connect != ServiceChannelConnect_Connecting) {
return false;
}
}
return true;
}
}
| 7,676
|
C++
|
.cpp
| 177
| 35.129944
| 179
| 0.640709
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,306
|
htclow_ctrl_service.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/ctrl/htclow_ctrl_service.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_ctrl_service.hpp"
#include "htclow_ctrl_state.hpp"
#include "htclow_ctrl_state_machine.hpp"
#include "htclow_ctrl_packet_factory.hpp"
#include "htclow_service_channel_parser.hpp"
#include "htclow_ctrl_service_channels.hpp"
#include "../mux/htclow_mux.hpp"
namespace ams::htclow::ctrl {
namespace {
constexpr const char BeaconPacketResponseTemplate[] =
"{\r\n"
" \"Spec\" : \"%s\",\r\n"
" \"Conn\" : \"%s\",\r\n"
" \"HW\" : \"%s\",\r\n"
" \"Name\" : \"%s\",\r\n"
" \"SN\" : \"%s\",\r\n"
" \"FW\" : \"%s\",\r\n"
" \"Prot\" : \"%d\"\r\n"
"}\r\n";
}
HtcctrlService::HtcctrlService(HtcctrlPacketFactory *pf, HtcctrlStateMachine *sm, mux::Mux *mux)
: m_settings_holder(), m_beacon_response(), m_information_body(), m_packet_factory(pf), m_state_machine(sm), m_mux(mux), m_event(os::EventClearMode_ManualClear),
m_send_buffer(pf), m_mutex(), m_condvar(), m_service_channels_packet(), m_version(ProtocolVersion)
{
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Set the mux version. */
m_mux->SetVersion(m_version);
/* Update our beacon response. */
this->UpdateBeaconResponse(this->GetConnectionType(impl::DriverType::Unknown));
}
const char *HtcctrlService::GetConnectionType(impl::DriverType driver_type) const {
switch (driver_type) {
case impl::DriverType::Socket: return "TCP";
case impl::DriverType::Usb: return "USB-gen2";
case impl::DriverType::PlainChannel: return "HBPC-gen2";
default: return "Unknown";
}
}
void HtcctrlService::UpdateBeaconResponse(const char *connection) {
/* Load settings into the holder. */
m_settings_holder.LoadSettings();
/* Print our beacon response. */
util::SNPrintf(m_beacon_response, sizeof(m_beacon_response), BeaconPacketResponseTemplate,
m_settings_holder.GetSpec(),
connection,
m_settings_holder.GetHardwareType(),
m_settings_holder.GetTargetName(),
m_settings_holder.GetSerialNumber(),
m_settings_holder.GetFirmwareVersion(),
ProtocolVersion
);
}
void HtcctrlService::UpdateInformationBody(const char *status) {
util::SNPrintf(m_information_body, sizeof(m_information_body), "{\r\n \"Status\" : \"%s\"\r\n}\r\n", status);
}
void HtcctrlService::SetDriverType(impl::DriverType driver_type) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Update our beacon response. */
this->UpdateBeaconResponse(this->GetConnectionType(driver_type));
}
Result HtcctrlService::CheckReceivedHeader(const HtcctrlPacketHeader &header) const {
/* Check the packet signature. */
AMS_ASSERT(header.signature == HtcctrlSignature);
/* Validate version. */
R_UNLESS(header.version == 1, htclow::ResultProtocolError());
/* Switch on the packet type. */
switch (header.packet_type) {
case HtcctrlPacketType_ConnectFromHost:
case HtcctrlPacketType_SuspendFromHost:
case HtcctrlPacketType_ResumeFromHost:
case HtcctrlPacketType_DisconnectFromHost:
case HtcctrlPacketType_BeaconQuery:
R_UNLESS(header.body_size == 0, htclow::ResultProtocolError());
break;
case HtcctrlPacketType_ReadyFromHost:
R_UNLESS(header.body_size <= sizeof(HtcctrlPacketBody), htclow::ResultProtocolError());
break;
default:
R_THROW(htclow::ResultProtocolError());
}
R_SUCCEED();
}
Result HtcctrlService::ProcessReceivePacket(const HtcctrlPacketHeader &header, const void *body, size_t body_size) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
switch (header.packet_type) {
case HtcctrlPacketType_ConnectFromHost:
R_RETURN(this->ProcessReceiveConnectPacket());
case HtcctrlPacketType_ReadyFromHost:
R_RETURN(this->ProcessReceiveReadyPacket(body, body_size));
case HtcctrlPacketType_SuspendFromHost:
R_RETURN(this->ProcessReceiveSuspendPacket());
case HtcctrlPacketType_ResumeFromHost:
R_RETURN(this->ProcessReceiveResumePacket());
case HtcctrlPacketType_DisconnectFromHost:
R_RETURN(this->ProcessReceiveDisconnectPacket());
case HtcctrlPacketType_BeaconQuery:
R_RETURN(this->ProcessReceiveBeaconQueryPacket());
default:
R_RETURN(this->ProcessReceiveUnexpectedPacket());
}
}
Result HtcctrlService::ProcessReceiveConnectPacket() {
/* Try to transition to sent connect state. */
if (R_FAILED(this->SetState(HtcctrlState_SentConnectFromHost))) {
/* We couldn't transition to sent connect. */
R_RETURN(this->ProcessReceiveUnexpectedPacket());
}
/* Send a connect packet. */
m_send_buffer.AddPacket(m_packet_factory->MakeConnectPacket(m_beacon_response, util::Strnlen(m_beacon_response, sizeof(m_beacon_response)) + 1));
/* Signal our event. */
m_event.Signal();
R_SUCCEED();
}
Result HtcctrlService::ProcessReceiveReadyPacket(const void *body, size_t body_size) {
/* Update our service channels. */
this->UpdateServiceChannels(body, body_size);
/* Check that our version is correct. */
if (m_version < ProtocolVersion) {
R_RETURN(this->ProcessReceiveUnexpectedPacket());
}
/* Set our version. */
m_version = ProtocolVersion;
m_mux->SetVersion(m_version);
/* Set our state. */
if (R_FAILED(this->SetState(HtcctrlState_SentReadyFromHost))) {
R_RETURN(this->ProcessReceiveUnexpectedPacket());
}
/* Ready ourselves. */
this->TryReadyInternal();
R_SUCCEED();
}
Result HtcctrlService::ProcessReceiveSuspendPacket() {
/* Try to set our state to enter sleep. */
if (R_FAILED(this->SetState(HtcctrlState_EnterSleep))) {
/* We couldn't transition to sleep. */
R_RETURN(this->ProcessReceiveUnexpectedPacket());
}
R_SUCCEED();
}
Result HtcctrlService::ProcessReceiveResumePacket() {
/* If our state is sent-resume, change to readied. */
if (m_state_machine->GetHtcctrlState() != HtcctrlState_SentResumeFromTarget || R_FAILED(this->SetState(HtcctrlState_Ready))) {
/* We couldn't perform a valid resume transition. */
R_RETURN(this->ProcessReceiveUnexpectedPacket());
}
R_SUCCEED();
}
Result HtcctrlService::ProcessReceiveDisconnectPacket() {
/* Set our state. */
R_TRY(this->SetState(HtcctrlState_Disconnected));
R_SUCCEED();
}
Result HtcctrlService::ProcessReceiveBeaconQueryPacket() {
/* Send a beacon response packet. */
m_send_buffer.AddPacket(m_packet_factory->MakeBeaconResponsePacket(m_beacon_response, util::Strnlen(m_beacon_response, sizeof(m_beacon_response)) + 1));
/* Signal our event. */
m_event.Signal();
R_SUCCEED();
}
Result HtcctrlService::ProcessReceiveUnexpectedPacket() {
/* Set our state. */
R_TRY(this->SetState(HtcctrlState_Error));
/* Send a disconnection packet. */
m_send_buffer.AddPacket(m_packet_factory->MakeDisconnectPacket());
/* Signal our event. */
m_event.Signal();
/* Return unexpected packet error. */
R_THROW(htclow::ResultHtcctrlReceiveUnexpectedPacket());
}
void HtcctrlService::ProcessSendConnectPacket() {
/* Set our state. */
const Result result = this->SetState(HtcctrlState_Connected);
R_ASSERT(result);
}
void HtcctrlService::ProcessSendReadyPacket() {
/* Set our state. */
if (m_state_machine->GetHtcctrlState() == HtcctrlState_SentReadyFromHost) {
const Result result = this->SetState(HtcctrlState_Ready);
R_ASSERT(result);
}
/* Update channel states. */
m_mux->UpdateChannelState();
}
void HtcctrlService::ProcessSendSuspendPacket() {
/* Set our state. */
const Result result = this->SetState(HtcctrlState_SentSuspendFromTarget);
R_ASSERT(result);
}
void HtcctrlService::ProcessSendResumePacket() {
/* Set our state. */
const Result result = this->SetState(HtcctrlState_SentResumeFromTarget);
R_ASSERT(result);
}
void HtcctrlService::ProcessSendDisconnectPacket() {
/* Set our state. */
const Result result = this->SetState(HtcctrlState_Disconnected);
R_ASSERT(result);
}
void HtcctrlService::UpdateServiceChannels(const void *body, size_t body_size) {
/* Copy the packet body to our member. */
std::memcpy(m_service_channels_packet, body, body_size);
/* Parse service channels. */
impl::ChannelInternalType channels[10];
int num_channels;
s16 version = m_version;
ctrl::ParseServiceChannel(std::addressof(version), channels, std::addressof(num_channels), util::size(channels), m_service_channels_packet, body_size);
/* Update version. */
m_version = version;
/* Notify state machine of supported channels. */
m_state_machine->NotifySupportedServiceChannels(channels, num_channels);
}
void HtcctrlService::TryReadyInternal() {
/* If we can send ready, do so. */
if (m_state_machine->IsPossibleToSendReady()) {
/* Print the channels. */
char channel_str[0x100];
this->PrintServiceChannels(channel_str, sizeof(channel_str));
/* Send a ready packet. */
m_send_buffer.AddPacket(m_packet_factory->MakeReadyPacket(channel_str, util::Strnlen(channel_str, sizeof(channel_str)) + 1));
/* Signal our event. */
m_event.Signal();
/* Set connecting checked in state machine. */
m_state_machine->SetConnectingChecked();
}
}
bool HtcctrlService::QuerySendPacket(HtcctrlPacketHeader *header, HtcctrlPacketBody *body, int *out_body_size) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
return m_send_buffer.QueryNextPacket(header, body, out_body_size);
}
void HtcctrlService::RemovePacket(const HtcctrlPacketHeader &header) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Remove the packet from our buffer. */
m_send_buffer.RemovePacket(header);
/* Switch on the packet type. */
switch (header.packet_type) {
case HtcctrlPacketType_ConnectFromTarget:
this->ProcessSendConnectPacket();
break;
case HtcctrlPacketType_ReadyFromTarget:
this->ProcessSendReadyPacket();
break;
case HtcctrlPacketType_SuspendFromTarget:
this->ProcessSendSuspendPacket();
break;
case HtcctrlPacketType_ResumeFromTarget:
this->ProcessSendResumePacket();
break;
case HtcctrlPacketType_DisconnectFromTarget:
this->ProcessSendDisconnectPacket();
break;
case HtcctrlPacketType_BeaconResponse:
case HtcctrlPacketType_InformationFromTarget:
break;
default:
AMS_ABORT("Send unsupported packet 0x%04x\n", static_cast<u32>(header.packet_type));
}
}
void HtcctrlService::TryReady() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
this->TryReadyInternal();
}
void HtcctrlService::Disconnect() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
this->DisconnectInternal();
}
void HtcctrlService::DisconnectInternal() {
/* Disconnect, if we need to. */
if (m_state_machine->IsDisconnectionNeeded()) {
/* Send a disconnect packet. */
m_send_buffer.AddPacket(m_packet_factory->MakeDisconnectPacket());
/* Signal our event. */
m_event.Signal();
/* Wait for us to be disconnected. */
while (!m_state_machine->IsDisconnected()) {
m_condvar.Wait(m_mutex);
}
}
}
void HtcctrlService::Resume() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Send resume packet, if we can. */
if (const auto state = m_state_machine->GetHtcctrlState(); state == HtcctrlState_Sleep || state == HtcctrlState_ExitSleep) {
/* Send a resume packet. */
m_send_buffer.AddPacket(m_packet_factory->MakeResumePacket());
/* Signal our event. */
m_event.Signal();
}
}
void HtcctrlService::Suspend() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* If we can, perform a suspend. */
if (m_state_machine->GetHtcctrlState() == HtcctrlState_Ready) {
/* Send a suspend packet. */
m_send_buffer.AddPacket(m_packet_factory->MakeSuspendPacket());
/* Signal our event. */
m_event.Signal();
/* Wait for our state to transition. */
for (auto state = m_state_machine->GetHtcctrlState(); state == HtcctrlState_Ready || state == HtcctrlState_SentSuspendFromTarget; state = m_state_machine->GetHtcctrlState()) {
m_condvar.Wait(m_mutex);
}
} else {
/* Otherwise, just disconnect. */
this->DisconnectInternal();
}
}
void HtcctrlService::NotifyAwake() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Update our information. */
this->UpdateInformationBody("Awake");
/* Send information to host. */
this->SendInformation();
}
void HtcctrlService::NotifyAsleep() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Update our information. */
this->UpdateInformationBody("Asleep");
/* Send information to host. */
this->SendInformation();
}
void HtcctrlService::SendInformation() {
/* If we need information, send information. */
if (m_state_machine->IsInformationNeeded()) {
/* Send an information packet. */
m_send_buffer.AddPacket(m_packet_factory->MakeInformationPacket(m_information_body, util::Strnlen(m_information_body, sizeof(m_information_body)) + 1));
/* Signal our event. */
m_event.Signal();
}
}
Result HtcctrlService::NotifyDriverConnected() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
if (m_state_machine->GetHtcctrlState() == HtcctrlState_Sleep) {
R_TRY(this->SetState(HtcctrlState_ExitSleep));
} else {
R_TRY(this->SetState(HtcctrlState_DriverConnected));
}
R_SUCCEED();
}
Result HtcctrlService::NotifyDriverDisconnected() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
if (m_state_machine->GetHtcctrlState() == HtcctrlState_EnterSleep) {
R_TRY(this->SetState(HtcctrlState_Sleep));
} else {
R_TRY(this->SetState(HtcctrlState_DriverDisconnected));
}
R_SUCCEED();
}
Result HtcctrlService::SetState(HtcctrlState state) {
/* Set the state. */
bool did_transition;
R_TRY(m_state_machine->SetHtcctrlState(std::addressof(did_transition), state));
/* Reflect the state transition, if one occurred. */
if (did_transition) {
this->ReflectState();
}
R_SUCCEED();
}
void HtcctrlService::ReflectState() {
/* If our connected status changed, update. */
if (m_state_machine->IsConnectedStatusChanged()) {
m_mux->UpdateChannelState();
}
/* If our sleeping status changed, update. */
if (m_state_machine->IsSleepingStatusChanged()) {
m_mux->UpdateMuxState();
}
/* Broadcast our state transition. */
m_condvar.Broadcast();
}
void HtcctrlService::PrintServiceChannels(char *dst, size_t dst_size) {
size_t ofs = 0;
ofs += util::SNPrintf(dst + ofs, dst_size - ofs, "{\r\n \"Chan\" : [\r\n \"%d:%d:%d\"", static_cast<int>(ServiceChannels[0].module_id), ServiceChannels[0].reserved, static_cast<int>(ServiceChannels[0].channel_id));
for (size_t i = 1; i < util::size(ServiceChannels); ++i) {
ofs += util::SNPrintf(dst + ofs, dst_size - ofs, ",\r\n \"%d:%d:%d\"", static_cast<int>(ServiceChannels[i].module_id), ServiceChannels[i].reserved, static_cast<int>(ServiceChannels[i].channel_id));
}
ofs += util::SNPrintf(dst + ofs, dst_size - ofs, "\r\n],\r\n \"Prot\" : %d\r\n}\r\n", ProtocolVersion);
}
}
| 18,041
|
C++
|
.cpp
| 406
| 34.963054
| 223
| 0.615086
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,307
|
htclow_ctrl_send_buffer.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/ctrl/htclow_ctrl_send_buffer.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_ctrl_send_buffer.hpp"
#include "htclow_ctrl_packet_factory.hpp"
namespace ams::htclow::ctrl {
bool HtcctrlSendBuffer::IsPriorPacket(HtcctrlPacketType packet_type) const {
return packet_type == HtcctrlPacketType_DisconnectFromTarget;
}
bool HtcctrlSendBuffer::IsPosteriorPacket(HtcctrlPacketType packet_type) const {
switch (packet_type) {
case HtcctrlPacketType_ConnectFromTarget:
case HtcctrlPacketType_ReadyFromTarget:
case HtcctrlPacketType_SuspendFromTarget:
case HtcctrlPacketType_ResumeFromTarget:
case HtcctrlPacketType_BeaconResponse:
case HtcctrlPacketType_InformationFromTarget:
return true;
default:
return false;
}
}
void HtcctrlSendBuffer::AddPacket(std::unique_ptr<HtcctrlPacket, HtcctrlPacketDeleter> ptr) {
/* Get the packet. */
HtcctrlPacket *packet = ptr.release();
/* Get the packet type. */
const auto packet_type = packet->GetHeader()->packet_type;
/* Add the packet to the appropriate list. */
if (this->IsPriorPacket(packet_type)) {
m_prior_packet_list.push_back(*packet);
} else {
AMS_ABORT_UNLESS(this->IsPosteriorPacket(packet_type));
m_posterior_packet_list.push_back(*packet);
}
}
void HtcctrlSendBuffer::RemovePacket(const HtcctrlPacketHeader &header) {
/* Get the packet type. */
const auto packet_type = header.packet_type;
/* Remove the front from the appropriate list. */
HtcctrlPacket *packet;
if (this->IsPriorPacket(packet_type)) {
packet = std::addressof(m_prior_packet_list.front());
m_prior_packet_list.pop_front();
} else {
AMS_ABORT_UNLESS(this->IsPosteriorPacket(packet_type));
packet = std::addressof(m_posterior_packet_list.front());
m_posterior_packet_list.pop_front();
}
/* Delete the packet. */
m_packet_factory->Delete(packet);
}
bool HtcctrlSendBuffer::QueryNextPacket(HtcctrlPacketHeader *header, HtcctrlPacketBody *body, int *out_body_size) {
if (!m_prior_packet_list.empty()) {
this->CopyPacket(header, body, out_body_size, m_prior_packet_list.front());
return true;
} else if (!m_posterior_packet_list.empty()) {
this->CopyPacket(header, body, out_body_size, m_posterior_packet_list.front());
return true;
} else {
return false;
}
}
void HtcctrlSendBuffer::CopyPacket(HtcctrlPacketHeader *header, HtcctrlPacketBody *body, int *out_body_size, const HtcctrlPacket &packet) {
/* Get the body size. */
const int body_size = packet.GetBodySize();
AMS_ASSERT(0 <= body_size && body_size <= static_cast<int>(sizeof(*body)));
/* Copy the header. */
std::memcpy(header, packet.GetHeader(), sizeof(*header));
/* Copy the body. */
std::memcpy(body, packet.GetBody(), body_size);
/* Set the output body size. */
*out_body_size = body_size;
}
}
| 3,864
|
C++
|
.cpp
| 87
| 36.367816
| 143
| 0.654173
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,308
|
htclow_json.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/ctrl/htclow_json.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_json.hpp"
namespace ams::htclow::ctrl {
namespace {
constexpr const char ChannelKey[] = "Chan";
constexpr const char ProtocolVersionKey[] = "Prot";
}
bool JsonHandler::Key(const Ch *str, rapidjson::SizeType len, bool copy) {
AMS_UNUSED(len, copy);
if (m_state == State::ParseObject) {
if (!util::Strncmp(str, ChannelKey, sizeof(ChannelKey))) {
m_state = State::ParseServiceChannels;
}
if (!util::Strncmp(str, ProtocolVersionKey, sizeof(ProtocolVersionKey))) {
m_state = State::ParseProtocolVersion;
}
}
return true;
}
bool JsonHandler::Uint(unsigned val) {
if (m_state == State::ParseProtocolVersion) {
*m_version = val;
}
return true;
}
bool JsonHandler::String(const Ch *str, rapidjson::SizeType len, bool copy) {
AMS_UNUSED(len, copy);
if (m_state == State::ParseServiceChannelsArray && *m_num_strings < m_max_strings) {
m_strings[(*m_num_strings)++] = str;
}
return true;
}
bool JsonHandler::StartObject() {
if (m_state == State::Begin) {
m_state = State::ParseObject;
}
return true;
}
bool JsonHandler::EndObject(rapidjson::SizeType) {
m_state = State::End;
return true;
}
bool JsonHandler::StartArray() {
if (m_state == State::ParseServiceChannels) {
m_state = State::ParseServiceChannelsArray;
}
return true;
}
bool JsonHandler::EndArray(rapidjson::SizeType len) {
if (m_state == State::ParseServiceChannelsArray && len) {
m_state = State::ParseObject;
}
return true;
}
}
| 2,469
|
C++
|
.cpp
| 70
| 28.214286
| 92
| 0.626415
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,309
|
htclow_service_channel_parser.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/ctrl/htclow_service_channel_parser.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_json.hpp"
#include "htclow_service_channel_parser.hpp"
namespace ams::htclow::ctrl {
namespace {
constexpr auto JsonParseFlags = rapidjson::kParseTrailingCommasFlag | rapidjson::kParseInsituFlag;
void ParseBody(s16 *out_version, const char **out_channels, int *out_num_channels, int max_channels, void *str, size_t str_size) {
AMS_UNUSED(str_size);
/* Create JSON handler. */
JsonHandler json_handler(out_version, out_channels, out_num_channels, max_channels);
/* Create reader. */
rapidjson::Reader json_reader;
/* Create stream. */
rapidjson::InsituStringStream json_stream(static_cast<char *>(str));
/* Parse the json. */
json_reader.Parse<JsonParseFlags>(json_stream, json_handler);
}
constexpr bool IsNumericCharacter(char c) {
return '0' <= c && c <= '9';
}
constexpr bool IsValidCharacter(char c) {
return IsNumericCharacter(c) || c == ':';
}
bool IntegerToModuleId(ModuleId *out, int id) {
switch (id) {
case 0:
case 1:
case 3:
case 4:
*out = static_cast<ModuleId>(id);
return true;
default:
return false;
}
}
bool StringToChannel(impl::ChannelInternalType *out, char *str, size_t size) {
enum class State {
Begin,
ModuleId,
Sep1,
Reserved,
Sep2,
ChannelId
};
State state = State::Begin;
const char * cur = nullptr;
const char * const str_end = str + size;
while (str < str_end && IsValidCharacter(*str)) {
const char c = *str;
switch (state) {
case State::Begin:
if (IsNumericCharacter(c)) {
cur = str;
state = State::ModuleId;
}
break;
case State::ModuleId:
if (c == ':') {
*str = 0;
if (!IntegerToModuleId(std::addressof(out->module_id), atoi(cur))) {
return false;
}
state = State::Sep1;
} else if (!IsNumericCharacter(c)) {
return false;
}
break;
case State::Sep1:
if (IsNumericCharacter(c)) {
cur = str;
state = State::Reserved;
}
break;
case State::Reserved:
if (c == ':') {
*str = 0;
out->reserved = 0;
state = State::Sep2;
} else if (!IsNumericCharacter(c)) {
return false;
}
break;
case State::Sep2:
if (IsNumericCharacter(c)) {
cur = str;
state = State::ChannelId;
}
break;
case State::ChannelId:
if (!IsNumericCharacter(c)) {
return false;
}
break;
}
++str;
}
if (str != str_end) {
return false;
}
out->channel_id = atoi(cur);
return true;
}
}
void ParseServiceChannel(s16 *out_version, impl::ChannelInternalType *out_channels, int *out_num_channels, int max_channels, void *str, size_t str_size) {
/* Parse the JSON. */
const char *channel_strs[0x20];
int num_channels = 0;
ParseBody(out_version, channel_strs, std::addressof(num_channels), util::size(channel_strs), str, str_size);
/* Parse the channel strings. */
char * const str_end = static_cast<char *>(str) + str_size;
int parsed_channels = 0;
for (auto i = 0; i < num_channels && i < max_channels; ++i) {
impl::ChannelInternalType channel;
if (StringToChannel(std::addressof(channel), const_cast<char *>(channel_strs[i]), util::Strnlen(channel_strs[i], str_end - channel_strs[i]))) {
out_channels[parsed_channels++] = channel;
}
}
*out_num_channels = parsed_channels;
}
}
| 5,582
|
C++
|
.cpp
| 135
| 25.837037
| 158
| 0.474179
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,310
|
htclow_ctrl_packet_factory.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/ctrl/htclow_ctrl_packet_factory.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_ctrl_packet_factory.hpp"
namespace ams::htclow::ctrl {
std::unique_ptr<HtcctrlPacket, HtcctrlPacketDeleter> HtcctrlPacketFactory::MakeSendPacketCommon(int body_size) {
/* Allocate memory for the packet. */
if (void *buffer = m_allocator->Allocate(sizeof(HtcctrlPacket), alignof(HtcctrlPacket)); buffer != nullptr) {
/* Convert the buffer to a packet. */
HtcctrlPacket *packet = static_cast<HtcctrlPacket *>(buffer);
/* Construct the packet. */
std::construct_at(packet, m_allocator, body_size + sizeof(HtcctrlPacketHeader));
/* Create the unique pointer. */
std::unique_ptr<HtcctrlPacket, HtcctrlPacketDeleter> ptr(packet, HtcctrlPacketDeleter{m_allocator});
/* Set packet header fields. */
if (ptr && ptr->IsAllocationSucceeded()) {
HtcctrlPacketHeader *header = ptr->GetHeader();
header->signature = HtcctrlSignature;
header->sequence_id = m_sequence_id++;
header->reserved = 0;
header->body_size = body_size;
header->version = 1;
header->channel = {};
header->share = 0;
}
return ptr;
} else {
return std::unique_ptr<HtcctrlPacket, HtcctrlPacketDeleter>(nullptr, HtcctrlPacketDeleter{m_allocator});
}
}
std::unique_ptr<HtcctrlPacket, HtcctrlPacketDeleter> HtcctrlPacketFactory::MakeSuspendPacket() {
auto packet = this->MakeSendPacketCommon(0);
if (packet && packet->IsAllocationSucceeded()) {
packet->GetHeader()->packet_type = HtcctrlPacketType_SuspendFromTarget;
}
return packet;
}
std::unique_ptr<HtcctrlPacket, HtcctrlPacketDeleter> HtcctrlPacketFactory::MakeResumePacket() {
auto packet = this->MakeSendPacketCommon(0);
if (packet && packet->IsAllocationSucceeded()) {
packet->GetHeader()->packet_type = HtcctrlPacketType_ResumeFromTarget;
}
return packet;
}
std::unique_ptr<HtcctrlPacket, HtcctrlPacketDeleter> HtcctrlPacketFactory::MakeReadyPacket(const void *body, int body_size) {
auto packet = this->MakeSendPacketCommon(body_size);
if (packet && packet->IsAllocationSucceeded()) {
packet->GetHeader()->packet_type = HtcctrlPacketType_ReadyFromTarget;
std::memcpy(packet->GetBody(), body, packet->GetBodySize());
}
return packet;
}
std::unique_ptr<HtcctrlPacket, HtcctrlPacketDeleter> HtcctrlPacketFactory::MakeInformationPacket(const void *body, int body_size) {
auto packet = this->MakeSendPacketCommon(body_size);
if (packet && packet->IsAllocationSucceeded()) {
packet->GetHeader()->packet_type = HtcctrlPacketType_InformationFromTarget;
std::memcpy(packet->GetBody(), body, packet->GetBodySize());
}
return packet;
}
std::unique_ptr<HtcctrlPacket, HtcctrlPacketDeleter> HtcctrlPacketFactory::MakeDisconnectPacket() {
auto packet = this->MakeSendPacketCommon(0);
if (packet) {
packet->GetHeader()->packet_type = HtcctrlPacketType_DisconnectFromTarget;
}
return packet;
}
std::unique_ptr<HtcctrlPacket, HtcctrlPacketDeleter> HtcctrlPacketFactory::MakeConnectPacket(const void *body, int body_size) {
auto packet = this->MakeSendPacketCommon(body_size);
if (packet && packet->IsAllocationSucceeded()) {
packet->GetHeader()->packet_type = HtcctrlPacketType_ConnectFromTarget;
std::memcpy(packet->GetBody(), body, packet->GetBodySize());
}
return packet;
}
std::unique_ptr<HtcctrlPacket, HtcctrlPacketDeleter> HtcctrlPacketFactory::MakeBeaconResponsePacket(const void *body, int body_size) {
auto packet = this->MakeSendPacketCommon(body_size);
if (packet && packet->IsAllocationSucceeded()) {
packet->GetHeader()->packet_type = HtcctrlPacketType_BeaconResponse;
std::memcpy(packet->GetBody(), body, packet->GetBodySize());
}
return packet;
}
void HtcctrlPacketFactory::Delete(HtcctrlPacket *packet) {
HtcctrlPacketDeleter{m_allocator}(packet);
}
}
| 5,019
|
C++
|
.cpp
| 100
| 41.5
| 138
| 0.66619
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,311
|
htclow_socket_driver.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/driver/htclow_socket_driver.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_socket_driver.hpp"
#include "htclow_socket_discovery_util.hpp"
namespace ams::htclow::driver {
Result SocketDriver::ConnectThread() {
/* Do auto connect, if we should. */
if (m_auto_connect_reserved) {
this->DoAutoConnect();
}
/* Get the socket's name. */
socket::SockAddrIn sockaddr;
socket::SockLenT sockaddr_len = sizeof(sockaddr);
R_UNLESS(socket::GetSockName(m_server_socket, reinterpret_cast<socket::SockAddr *>(std::addressof(sockaddr)), std::addressof(sockaddr_len)) == 0, htclow::ResultSocketGetSockNameError());
/* Accept. */
m_discovery_manager.OnSocketAcceptBegin(sockaddr.sin_port);
sockaddr_len = sizeof(m_server_sockaddr);
const auto client_desc = socket::Accept(m_server_socket, reinterpret_cast<socket::SockAddr *>(std::addressof(m_server_sockaddr)), std::addressof(sockaddr_len));
m_discovery_manager.OnSocketAcceptEnd();
/* Check accept result. */
R_UNLESS(client_desc >= 0, htclow::ResultSocketAcceptError());
/* Setup client socket. */
R_TRY(this->SetupClientSocket(client_desc));
R_SUCCEED();
}
Result SocketDriver::CreateServerSocket() {
/* Check that we don't have a server socket. */
AMS_ASSERT(!m_server_socket_valid);
/* Create the socket. */
const auto desc = socket::SocketExempt(socket::Family::Af_Inet, socket::Type::Sock_Stream, socket::Protocol::IpProto_Tcp);
R_UNLESS(desc != -1, htclow::ResultSocketSocketExemptError());
/* Be sure that we close the socket if we don't succeed. */
auto socket_guard = SCOPE_GUARD { socket::Close(desc); };
/* Create sockaddr for our socket. */
const socket::SockAddrIn sockaddr = {
.sin_len = 0,
.sin_family = socket::Family::Af_Inet,
.sin_port = socket::InetHtons(20180),
.sin_addr = { socket::InetHtonl(0) },
};
/* Enable local address reuse. */
{
u32 enable = 1;
const auto res = socket::SetSockOpt(desc, socket::Level::Sol_Socket, socket::Option::So_ReuseAddr, std::addressof(enable), sizeof(enable));
AMS_ABORT_UNLESS(res == 0);
}
/* Bind the socket. */
const auto bind_res = socket::Bind(desc, reinterpret_cast<const socket::SockAddr *>(std::addressof(sockaddr)), sizeof(sockaddr));
R_UNLESS(bind_res == 0, htclow::ResultSocketBindError());
/* Listen on the socket. */
const auto listen_res = socket::Listen(desc, 1);
R_UNLESS(listen_res == 0, htclow::ResultSocketListenError());
/* We succeeded. */
socket_guard.Cancel();
m_server_socket = desc;
m_server_socket_valid = true;
R_SUCCEED();
}
void SocketDriver::DestroyServerSocket() {
if (m_server_socket_valid) {
socket::Shutdown(m_server_socket, socket::ShutdownMethod::Shut_RdWr);
socket::Close(m_server_socket);
m_server_socket_valid = false;
}
}
Result SocketDriver::SetupClientSocket(s32 desc) {
std::scoped_lock lk(m_mutex);
/* Check that we don't have a client socket. */
AMS_ASSERT(!m_client_socket_valid);
/* Be sure that we close the socket if we don't succeed. */
auto socket_guard = SCOPE_GUARD { socket::Close(desc); };
/* Enable debug logging for the socket. */
u32 debug = 1;
const auto res = socket::SetSockOpt(desc, socket::Level::Sol_Tcp, socket::Option::So_Debug, std::addressof(debug), sizeof(debug));
R_UNLESS(res >= 0, htclow::ResultSocketSetSockOptError());
/* We succeeded. */
socket_guard.Cancel();
m_client_socket = desc;
m_client_socket_valid = true;
R_SUCCEED();
}
bool SocketDriver::IsAutoConnectReserved() {
return m_auto_connect_reserved;
}
void SocketDriver::ReserveAutoConnect() {
std::scoped_lock lk(m_mutex);
if (m_client_socket_valid) {
/* Save our client sockaddr. */
socket::SockLenT sockaddr_len = sizeof(m_saved_client_sockaddr);
if (socket::GetSockName(m_server_socket, reinterpret_cast<socket::SockAddr *>(std::addressof(m_saved_client_sockaddr)), std::addressof(sockaddr_len)) != 0) {
return;
}
/* Save our server sockaddr. */
m_saved_server_sockaddr = m_server_sockaddr;
/* Mark auto-connect reserved. */
m_auto_connect_reserved = true;
}
}
void SocketDriver::DoAutoConnect() {
/* Clear auto-connect reserved. */
m_auto_connect_reserved = false;
/* Create udb socket. */
const auto desc = socket::SocketExempt(socket::Family::Af_Inet, socket::Type::Sock_Dgram, socket::Protocol::IpProto_Udp);
if (desc == -1) {
return;
}
/* Clean up the desc when we're done. */
ON_SCOPE_EXIT { socket::Close(desc); };
/* Create auto-connect packet. */
char auto_connect_packet[0x120];
s32 len;
{
const socket::SockAddrIn sockaddr = {
.sin_family = socket::Family::Af_Inet,
.sin_port = m_saved_client_sockaddr.sin_port,
.sin_addr = m_saved_client_sockaddr.sin_addr,
};
len = htclow::driver::MakeAutoConnectIpv4RequestPacket(auto_connect_packet, sizeof(auto_connect_packet), sockaddr);
}
/* Send the auto-connect packet to the host on port 20181. */
const socket::SockAddrIn sockaddr = {
.sin_family = socket::Family::Af_Inet,
.sin_port = socket::InetHtons(20181),
.sin_addr = m_saved_server_sockaddr.sin_addr,
};
/* Send the auto-connect packet. */
socket::SendTo(desc, auto_connect_packet, len, socket::MsgFlag::Msg_None, reinterpret_cast<const socket::SockAddr *>(std::addressof(sockaddr)), sizeof(sockaddr));
}
Result SocketDriver::Open() {
m_discovery_manager.OnDriverOpen();
R_SUCCEED();
}
void SocketDriver::Close() {
m_discovery_manager.OnDriverClose();
}
Result SocketDriver::Connect(os::EventType *event) {
/* Allocate a temporary thread stack. */
void *stack = m_allocator->Allocate(os::MemoryPageSize, os::ThreadStackAlignment);
ON_SCOPE_EXIT { m_allocator->Free(stack); };
/* Try to create a server socket. */
R_TRY(this->CreateServerSocket());
/* Prepare to run our connect thread. */
m_event.Clear();
/* Run our connect thread. */
{
/* Create the thread. */
os::ThreadType connect_thread;
R_ABORT_UNLESS(os::CreateThread(std::addressof(connect_thread), ConnectThreadEntry, this, stack, os::MemoryPageSize, AMS_GET_SYSTEM_THREAD_PRIORITY(htc, HtclowTcpServer)));
/* Set the thread's name. */
os::SetThreadNamePointer(std::addressof(connect_thread), AMS_GET_SYSTEM_THREAD_NAME(htc, HtclowTcpServer));
/* Start the thread. */
os::StartThread(std::addressof(connect_thread));
/* Check if we should cancel the connection. */
if (os::WaitAny(event, m_event.GetBase()) == 0) {
this->DestroyServerSocket();
}
/* Wait for the connect thread to finish. */
os::WaitThread(std::addressof(connect_thread));
/* Destroy the connection thread. */
os::DestroyThread(std::addressof(connect_thread));
/* Destroy the server socket. */
this->DestroyServerSocket();
}
/* Return our connection result. */
R_RETURN(m_connect_result);
}
void SocketDriver::Shutdown() {
std::scoped_lock lk(m_mutex);
/* Shut down our client socket, if we need to. */
if (m_client_socket_valid) {
socket::Shutdown(m_client_socket, socket::ShutdownMethod::Shut_RdWr);
socket::Close(m_client_socket);
m_client_socket_valid = 0;
}
}
Result SocketDriver::Send(const void *src, int src_size) {
/* Check the input size. */
R_UNLESS(src_size >= 0, htclow::ResultInvalidArgument());
/* Repeatedly send data until it's all sent. */
ssize_t cur_sent;
for (ssize_t sent = 0; sent < src_size; sent += cur_sent) {
cur_sent = socket::Send(m_client_socket, static_cast<const u8 *>(src) + sent, src_size - sent, socket::MsgFlag::Msg_None);
R_UNLESS(cur_sent > 0, htclow::ResultSocketSendError());
}
R_SUCCEED();
}
Result SocketDriver::Receive(void *dst, int dst_size) {
/* Check the input size. */
R_UNLESS(dst_size >= 0, htclow::ResultInvalidArgument());
/* Repeatedly receive data until it's all sent. */
ssize_t cur_recv;
for (ssize_t received = 0; received < dst_size; received += cur_recv) {
cur_recv = socket::Recv(m_client_socket, static_cast<u8 *>(dst) + received, dst_size - received, socket::MsgFlag::Msg_None);
R_UNLESS(cur_recv > 0, htclow::ResultSocketReceiveError());
}
R_SUCCEED();
}
void SocketDriver::CancelSendReceive() {
this->Shutdown();
}
void SocketDriver::Suspend() {
this->ReserveAutoConnect();
}
void SocketDriver::Resume() {
/* ... */
}
}
| 10,256
|
C++
|
.cpp
| 221
| 37.298643
| 194
| 0.61125
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,312
|
htclow_usb_driver.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/driver/htclow_usb_driver.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_usb_driver.hpp"
#include "htclow_usb_impl.hpp"
namespace ams::htclow::driver {
void UsbDriver::OnUsbAvailabilityChange(UsbAvailability availability, void *param) {
/* Convert the argument to a driver. */
UsbDriver *driver = static_cast<UsbDriver *>(param);
/* Handle the change. */
switch (availability) {
case UsbAvailability_Unavailable:
CancelUsbSendReceive();
break;
case UsbAvailability_Available:
driver->m_event.Signal();
break;
case UsbAvailability_Unknown:
driver->CancelSendReceive();
break;
}
}
Result UsbDriver::Open() {
/* Clear our event. */
m_event.Clear();
/* Set the availability change callback. */
SetUsbAvailabilityChangeCallback(OnUsbAvailabilityChange, this);
/* Initialize the interface. */
R_RETURN(InitializeUsbInterface());
}
void UsbDriver::Close() {
/* Finalize the interface. */
FinalizeUsbInterface();
/* Clear the availability callback. */
ClearUsbAvailabilityChangeCallback();
}
Result UsbDriver::Connect(os::EventType *event) {
/* We must not already be connected. */
AMS_ABORT_UNLESS(!m_connected);
/* Perform a wait on our event. */
const int idx = os::WaitAny(m_event.GetBase(), event);
R_UNLESS(idx == 0, htclow::ResultCancelled());
/* Clear our event. */
m_event.Clear();
/* We're connected. */
m_connected = true;
R_SUCCEED();
}
void UsbDriver::Shutdown() {
/* If we're connected, cancel anything we're doing. */
if (m_connected) {
this->CancelSendReceive();
m_connected = false;
}
}
Result UsbDriver::Send(const void *src, int src_size) {
/* Check size. */
R_UNLESS(src_size >= 0, htclow::ResultInvalidArgument());
/* Send until we've sent everything. */
for (auto transferred = 0; transferred < src_size; /* ... */) {
int cur;
R_TRY(SendUsb(std::addressof(cur), reinterpret_cast<const void *>(reinterpret_cast<uintptr_t>(src) + transferred), src_size - transferred));
transferred += cur;
}
R_SUCCEED();
}
Result UsbDriver::Receive(void *dst, int dst_size) {
/* Check size. */
R_UNLESS(dst_size >= 0, htclow::ResultInvalidArgument());
/* Send until we've sent everything. */
for (auto transferred = 0; transferred < dst_size; /* ... */) {
int cur;
R_TRY(ReceiveUsb(std::addressof(cur), reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(dst) + transferred), dst_size - transferred));
transferred += cur;
}
R_SUCCEED();
}
void UsbDriver::CancelSendReceive() {
CancelUsbSendReceive();
}
void UsbDriver::Suspend() {
this->Close();
}
void UsbDriver::Resume() {
R_ABORT_UNLESS(this->Open());
}
}
| 3,790
|
C++
|
.cpp
| 100
| 29.99
| 152
| 0.610641
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,313
|
htclow_driver_memory_management.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/driver/htclow_driver_memory_management.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_driver_memory_management.hpp"
namespace ams::htclow::driver {
namespace {
constexpr inline size_t RequiredAlignment = std::max(os::ThreadStackAlignment, os::MemoryPageSize);
using SocketConfigType = socket::SystemConfigDefault;
/* TODO: If we ever use resolvers, increase this. */
constexpr inline size_t SocketAllocatorSize = 4_KB;
constexpr inline size_t SocketMemoryPoolSize = util::AlignUp(SocketConfigType::PerTcpSocketWorstCaseMemoryPoolSize + SocketConfigType::PerUdpSocketWorstCaseMemoryPoolSize, os::MemoryPageSize);
constexpr inline size_t SocketRequiredSize = util::AlignUp(SocketMemoryPoolSize + SocketAllocatorSize, os::MemoryPageSize);
constexpr inline size_t UsbRequiredSize = 2 * UsbDmaBufferSize + UsbIndicationThreadStackSize;
static_assert(util::IsAligned(UsbDmaBufferSize, RequiredAlignment));
constexpr inline size_t RequiredSize = std::max(SocketRequiredSize, UsbRequiredSize);
static_assert(util::IsAligned(RequiredSize, os::MemoryPageSize));
/* Declare the memory pool. */
alignas(RequiredAlignment) constinit u8 g_driver_memory[RequiredSize];
constexpr inline const socket::SystemConfigDefault SocketConfig(g_driver_memory, RequiredSize, SocketAllocatorSize, 2);
}
void *GetUsbReceiveBuffer() {
return g_driver_memory;
}
void *GetUsbSendBuffer() {
return g_driver_memory + UsbDmaBufferSize;
}
void *GetUsbIndicationThreadStack() {
return g_driver_memory + 2 * UsbDmaBufferSize;
}
void InitializeSocketApiForSocketDriver() {
R_ABORT_UNLESS(socket::Initialize(SocketConfig));
}
}
| 2,382
|
C++
|
.cpp
| 46
| 46.326087
| 200
| 0.743645
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,314
|
htclow_driver_manager.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/driver/htclow_driver_manager.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_driver_manager.hpp"
namespace ams::htclow::driver {
Result DriverManager::OpenDriver(impl::DriverType driver_type) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Check that we're not already open. */
R_UNLESS(m_open_driver == nullptr, htclow::ResultDriverOpened());
/* Open the driver. */
switch (driver_type) {
case impl::DriverType::Debug:
R_TRY(m_debug_driver->Open());
m_open_driver = m_debug_driver;
break;
case impl::DriverType::Socket:
m_socket_driver.Open();
m_open_driver = std::addressof(m_socket_driver);
break;
case impl::DriverType::Usb:
m_usb_driver.Open();
m_open_driver = std::addressof(m_usb_driver);
break;
case impl::DriverType::PlainChannel:
//m_plain_channel_driver.Open();
//m_open_driver = std::addressof(m_plain_channel_driver);
//break;
R_THROW(htclow::ResultUnknownDriverType());
default:
R_THROW(htclow::ResultUnknownDriverType());
}
/* Set the driver type. */
m_driver_type = driver_type;
R_SUCCEED();
}
void DriverManager::CloseDriver() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Clear our driver type. */
m_driver_type = util::nullopt;
/* Close our driver. */
if (m_open_driver != nullptr) {
m_open_driver->Close();
m_open_driver = nullptr;
}
}
impl::DriverType DriverManager::GetDriverType() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
return m_driver_type.value_or(impl::DriverType::Unknown);
}
IDriver *DriverManager::GetCurrentDriver() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
return m_open_driver;
}
void DriverManager::Cancel() {
m_open_driver->CancelSendReceive();
}
void DriverManager::SetDebugDriver(IDriver *driver) {
m_debug_driver = driver;
m_driver_type = impl::DriverType::Debug;
}
}
| 2,936
|
C++
|
.cpp
| 78
| 29.025641
| 76
| 0.599226
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,315
|
htclow_socket_discovery_util.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/driver/htclow_socket_discovery_util.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_socket_discovery_util.hpp"
#include "../ctrl/htclow_ctrl_settings_holder.hpp"
namespace ams::htclow::driver {
namespace {
constexpr inline u32 AutoConnectIpv4RequestServiceId = 0x834C775A;
constexpr inline u32 BeaconResponseServiceId = 0xA6F7FA96;
constexpr const char MakeAutoConnectIpv4RequestPacketFormat[] =
"{\r\n"
" \"Address\" : \"%u.%u.%u.%u\",\r\n"
" \"Port\" : %u,\r\n"
" \"HW\" : \"%s\",\r\n"
" \"SN\" : \"%s\"\r\n"
"}\r\n";
constexpr const char BeaconResponsePacketFormat[] =
"{\r\n"
" \"Gen\" : 2,\r\n"
" \"Spec \": \"%s\",\r\n"
" \"MAC\" : \"00:00:00:00:00:00\",\r\n"
" \"Conn\" : \"TCP\",\r\n"
" \"HW\" : \"%s\",\r\n"
" \"Name\" : \"%s\",\r\n"
" \"SN\" : \"%s\",\r\n"
" \"FW\" : \"%s\"\r\n"
"}\r\n";
constinit os::SdkMutex g_settings_holder_mutex;
constinit bool g_settings_holder_initialized = false;
constinit htclow::ctrl::SettingsHolder g_settings_holder;
void InitializeSettingsHolder() {
std::scoped_lock lk(g_settings_holder_mutex);
if (!g_settings_holder_initialized) {
g_settings_holder.LoadSettings();
g_settings_holder_initialized = true;
}
}
}
s32 MakeAutoConnectIpv4RequestPacket(char *dst, size_t dst_size, const socket::SockAddrIn &sockaddr) {
/* Initialize the settings holder. */
InitializeSettingsHolder();
/* Create the packet header. */
TmipcHeader header = {
.service_id = AutoConnectIpv4RequestServiceId,
.version = TmipcVersion,
};
/* Create the packet body. */
std::scoped_lock lk(g_settings_holder_mutex);
const auto addr = sockaddr.sin_addr.s_addr;
char packet_body[0x100];
const auto ideal_len = util::SNPrintf(packet_body, sizeof(packet_body), MakeAutoConnectIpv4RequestPacketFormat,
(addr >> 0) & 0xFF, (addr >> 8) & 0xFF, (addr >> 16) & 0xFF, (addr >> 24) & 0xFF,
socket::InetNtohs(sockaddr.sin_port),
g_settings_holder.GetHardwareType(),
"" /* Nintendo passes empty string as serial number here. */
);
/* Determine actual usable body length. */
header.data_len = std::max<u32>(ideal_len, sizeof(packet_body));
/* Check that the packet will fit. */
AMS_ABORT_UNLESS(sizeof(header) + header.data_len <= dst_size);
/* Copy the formatted header. */
std::memcpy(dst, std::addressof(header), sizeof(header));
std::memcpy(dst + sizeof(header), packet_body, header.data_len);
return header.data_len;
}
s32 MakeBeaconResponsePacket(char *dst, size_t dst_size) {
/* Initialize the settings holder. */
InitializeSettingsHolder();
/* Create the packet header. */
TmipcHeader header = {
.service_id = BeaconResponseServiceId,
.version = TmipcVersion,
};
/* Create the packet body. */
std::scoped_lock lk(g_settings_holder_mutex);
char packet_body[0x100];
const auto ideal_len = util::SNPrintf(packet_body, sizeof(packet_body), BeaconResponsePacketFormat,
g_settings_holder.GetSpec(),
g_settings_holder.GetHardwareType(),
g_settings_holder.GetTargetName(),
g_settings_holder.GetSerialNumber(),
g_settings_holder.GetFirmwareVersion()
);
/* Determine actual usable body length. */
header.data_len = std::max<u32>(ideal_len, sizeof(packet_body));
/* Check that the packet will fit. */
AMS_ABORT_UNLESS(sizeof(header) + header.data_len <= dst_size);
/* Copy the formatted header. */
std::memcpy(dst, std::addressof(header), sizeof(header));
std::memcpy(dst + sizeof(header), packet_body, header.data_len);
return header.data_len;
}
}
| 5,152
|
C++
|
.cpp
| 106
| 36.301887
| 127
| 0.556773
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,316
|
htclow_usb_impl.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/driver/htclow_usb_impl.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_usb_impl.hpp"
#include "htclow_driver_memory_management.hpp"
namespace ams::htclow::driver {
namespace {
/* TODO: Should we identify differently than Nintendo does? */
/* It's kind of silly to identify as "NintendoSDK DevKit", but it's also kind of amusing. */
/* TBD */
constinit usb::UsbStringDescriptor LanguageStringDescriptor = { 4, usb::UsbDescriptorType_String, {0x0409}};
constinit usb::UsbStringDescriptor ManufacturerStringDescriptor = {18, usb::UsbDescriptorType_String, {'N', 'i', 'n', 't', 'e', 'n', 'd', 'o'}};
constinit usb::UsbStringDescriptor ProductStringFullSpeedDescriptor = {38, usb::UsbDescriptorType_String, {'N', 'i', 'n', 't', 'e', 'n', 'd', 'o', 'S', 'D', 'K', ' ', 'D', 'e', 'v', 'K', 'i', 't'}};
constinit usb::UsbStringDescriptor SerialNumberStringDescriptor = { 0, usb::UsbDescriptorType_String, {}};
constinit usb::UsbStringDescriptor InterfaceStringDescriptor = {16, usb::UsbDescriptorType_String, {'h', 't', 'c', ' ', 'u', 's', 'b'}};
constinit usb::UsbDeviceDescriptor UsbDeviceDescriptorFullSpeed = {
.bLength = usb::UsbDescriptorSize_Device,
.bDescriptorType = usb::UsbDescriptorType_Device,
.bcdUSB = 0x0110,
.bDeviceClass = 0x00,
.bDeviceSubClass = 0x00,
.bDeviceProtocol = 0x00,
.bMaxPacketSize0 = 0x40,
.idVendor = 0x057E,
.idProduct = 0x3005,
.bcdDevice = 0x0100,
.iManufacturer = 0x01,
.iProduct = 0x02,
.iSerialNumber = 0x03,
.bNumConfigurations = 0x01,
};
constinit usb::UsbDeviceDescriptor UsbDeviceDescriptorHighSpeed = {
.bLength = usb::UsbDescriptorSize_Device,
.bDescriptorType = usb::UsbDescriptorType_Device,
.bcdUSB = 0x0200,
.bDeviceClass = 0x00,
.bDeviceSubClass = 0x00,
.bDeviceProtocol = 0x00,
.bMaxPacketSize0 = 0x40,
.idVendor = 0x057E,
.idProduct = 0x3005,
.bcdDevice = 0x0100,
.iManufacturer = 0x01,
.iProduct = 0x02,
.iSerialNumber = 0x03,
.bNumConfigurations = 0x01,
};
constinit usb::UsbDeviceDescriptor UsbDeviceDescriptorSuperSpeed = {
.bLength = usb::UsbDescriptorSize_Device,
.bDescriptorType = usb::UsbDescriptorType_Device,
.bcdUSB = 0x0300,
.bDeviceClass = 0x00,
.bDeviceSubClass = 0x00,
.bDeviceProtocol = 0x00,
.bMaxPacketSize0 = 0x09,
.idVendor = 0x057E,
.idProduct = 0x3005,
.bcdDevice = 0x0100,
.iManufacturer = 0x01,
.iProduct = 0x02,
.iSerialNumber = 0x03,
.bNumConfigurations = 0x01,
};
constinit u8 BinaryObjectStore[] = {
0x05,
usb::UsbDescriptorType_Bos,
0x16, 0x00,
0x02,
0x07,
usb::UsbDescriptorType_DeviceCapability,
0x02,
0x02, 0x00, 0x00, 0x00,
0x0A,
usb::UsbDescriptorType_DeviceCapability,
0x03,
0x00,
0x0E, 0x00,
0x03,
0x00,
0x00, 0x00,
};
constinit usb::UsbInterfaceDescriptor UsbInterfaceDescriptor = {
.bLength = usb::UsbDescriptorSize_Interface,
.bDescriptorType = usb::UsbDescriptorType_Interface,
.bInterfaceNumber = 0x00,
.bAlternateSetting = 0x00,
.bNumEndpoints = 0x02,
.bInterfaceClass = 0xFF,
.bInterfaceSubClass = 0xFF,
.bInterfaceProtocol = 0xFF,
.iInterface = 0x04,
};
constinit usb::UsbEndpointDescriptor UsbEndpointDescriptorsFullSpeed[2] = {
{
.bLength = usb::UsbDescriptorSize_Endpoint,
.bDescriptorType = usb::UsbDescriptorType_Endpoint,
.bEndpointAddress = 0x81,
.bmAttributes = usb::UsbEndpointAttributeMask_XferTypeBulk,
.wMaxPacketSize = 0x40,
.bInterval = 0x00,
},
{
.bLength = usb::UsbDescriptorSize_Endpoint,
.bDescriptorType = usb::UsbDescriptorType_Endpoint,
.bEndpointAddress = 0x01,
.bmAttributes = usb::UsbEndpointAttributeMask_XferTypeBulk,
.wMaxPacketSize = 0x40,
.bInterval = 0x00,
}
};
constinit usb::UsbEndpointDescriptor UsbEndpointDescriptorsHighSpeed[2] = {
{
.bLength = usb::UsbDescriptorSize_Endpoint,
.bDescriptorType = usb::UsbDescriptorType_Endpoint,
.bEndpointAddress = 0x81,
.bmAttributes = usb::UsbEndpointAttributeMask_XferTypeBulk,
.wMaxPacketSize = 0x200,
.bInterval = 0x00,
},
{
.bLength = usb::UsbDescriptorSize_Endpoint,
.bDescriptorType = usb::UsbDescriptorType_Endpoint,
.bEndpointAddress = 0x01,
.bmAttributes = usb::UsbEndpointAttributeMask_XferTypeBulk,
.wMaxPacketSize = 0x200,
.bInterval = 0x00,
}
};
constinit usb::UsbEndpointDescriptor UsbEndpointDescriptorsSuperSpeed[2] = {
{
.bLength = usb::UsbDescriptorSize_Endpoint,
.bDescriptorType = usb::UsbDescriptorType_Endpoint,
.bEndpointAddress = 0x81,
.bmAttributes = usb::UsbEndpointAttributeMask_XferTypeBulk,
.wMaxPacketSize = 0x400,
.bInterval = 0x00,
},
{
.bLength = usb::UsbDescriptorSize_Endpoint,
.bDescriptorType = usb::UsbDescriptorType_Endpoint,
.bEndpointAddress = 0x01,
.bmAttributes = usb::UsbEndpointAttributeMask_XferTypeBulk,
.wMaxPacketSize = 0x400,
.bInterval = 0x00,
}
};
constinit usb::UsbEndpointCompanionDescriptor UsbEndpointCompanionDescriptor = {
.bLength = usb::UsbDescriptorSize_EndpointCompanion,
.bDescriptorType = usb::UsbDescriptorType_EndpointCompanion,
.bMaxBurst = 0x0F,
.bmAttributes = 0x00,
.wBytesPerInterval = 0x0000,
};
constinit void *g_usb_receive_buffer = nullptr;
constinit void *g_usb_send_buffer = nullptr;
constinit UsbAvailabilityChangeCallback g_availability_change_callback = nullptr;
constinit void *g_availability_change_param = nullptr;
constinit bool g_usb_interface_initialized = false;
os::Event g_usb_break_event(os::EventClearMode_ManualClear);
constinit os::ThreadType g_usb_indication_thread = {};
constinit os::SdkMutex g_usb_driver_mutex;
usb::DsClient g_ds_client;
usb::DsInterface g_ds_interface;
usb::DsEndpoint g_ds_endpoints[2];
void InvokeAvailabilityChangeCallback(UsbAvailability availability) {
if (g_availability_change_callback) {
g_availability_change_callback(availability, g_availability_change_param);
}
}
Result ConvertUsbDriverResult(Result result) {
if (result.GetModule() == R_NAMESPACE_MODULE_ID(usb)) {
if (usb::ResultResourceBusy::Includes(result)) {
R_THROW(htclow::ResultUsbDriverBusyError());
} else if (usb::ResultMemAllocFailure::Includes(result)) {
R_THROW(htclow::ResultOutOfMemory());
} else {
R_THROW(htclow::ResultUsbDriverUnknownError());
}
} else {
R_RETURN(result);
}
}
Result InitializeDsClient() {
/* Initialize the client. */
R_TRY(ConvertUsbDriverResult(g_ds_client.Initialize(usb::ComplexId_Tegra21x)));
/* Clear device data. */
R_ABORT_UNLESS(g_ds_client.ClearDeviceData());
/* Add string descriptors. */
u8 index;
R_TRY(g_ds_client.AddUsbStringDescriptor(std::addressof(index), std::addressof(LanguageStringDescriptor)));
R_TRY(g_ds_client.AddUsbStringDescriptor(std::addressof(index), std::addressof(ManufacturerStringDescriptor)));
R_TRY(g_ds_client.AddUsbStringDescriptor(std::addressof(index), std::addressof(ProductStringFullSpeedDescriptor)));
R_TRY(g_ds_client.AddUsbStringDescriptor(std::addressof(index), std::addressof(SerialNumberStringDescriptor)));
R_TRY(g_ds_client.AddUsbStringDescriptor(std::addressof(index), std::addressof(InterfaceStringDescriptor)));
/* Add device descriptors. */
R_TRY(g_ds_client.SetUsbDeviceDescriptor(std::addressof(UsbDeviceDescriptorFullSpeed), usb::UsbDeviceSpeed_Full));
R_TRY(g_ds_client.SetUsbDeviceDescriptor(std::addressof(UsbDeviceDescriptorHighSpeed), usb::UsbDeviceSpeed_High));
R_TRY(g_ds_client.SetUsbDeviceDescriptor(std::addressof(UsbDeviceDescriptorSuperSpeed), usb::UsbDeviceSpeed_Super));
/* Set binary object store. */
R_TRY(g_ds_client.SetBinaryObjectStore(BinaryObjectStore, sizeof(BinaryObjectStore)));
R_SUCCEED();
}
Result InitializeDsInterface() {
/* Initialize the interface. */
R_TRY(ConvertUsbDriverResult(g_ds_interface.Initialize(std::addressof(g_ds_client), 0)));
/* Append the interface descriptors for all speeds. */
R_TRY(g_ds_interface.AppendConfigurationData(usb::UsbDeviceSpeed_Full, std::addressof(UsbInterfaceDescriptor), sizeof(usb::UsbInterfaceDescriptor)));
R_TRY(g_ds_interface.AppendConfigurationData(usb::UsbDeviceSpeed_Full, std::addressof(UsbEndpointDescriptorsFullSpeed[0]), sizeof(usb::UsbEndpointDescriptor)));
R_TRY(g_ds_interface.AppendConfigurationData(usb::UsbDeviceSpeed_Full, std::addressof(UsbEndpointDescriptorsFullSpeed[1]), sizeof(usb::UsbEndpointDescriptor)));
R_TRY(g_ds_interface.AppendConfigurationData(usb::UsbDeviceSpeed_High, std::addressof(UsbInterfaceDescriptor), sizeof(usb::UsbInterfaceDescriptor)));
R_TRY(g_ds_interface.AppendConfigurationData(usb::UsbDeviceSpeed_High, std::addressof(UsbEndpointDescriptorsHighSpeed[0]), sizeof(usb::UsbEndpointDescriptor)));
R_TRY(g_ds_interface.AppendConfigurationData(usb::UsbDeviceSpeed_High, std::addressof(UsbEndpointDescriptorsHighSpeed[1]), sizeof(usb::UsbEndpointDescriptor)));
R_TRY(g_ds_interface.AppendConfigurationData(usb::UsbDeviceSpeed_Super, std::addressof(UsbInterfaceDescriptor), sizeof(usb::UsbInterfaceDescriptor)));
R_TRY(g_ds_interface.AppendConfigurationData(usb::UsbDeviceSpeed_Super, std::addressof(UsbEndpointDescriptorsSuperSpeed[0]), sizeof(usb::UsbEndpointDescriptor)));
R_TRY(g_ds_interface.AppendConfigurationData(usb::UsbDeviceSpeed_Super, std::addressof(UsbEndpointCompanionDescriptor), sizeof(usb::UsbEndpointCompanionDescriptor)));
R_TRY(g_ds_interface.AppendConfigurationData(usb::UsbDeviceSpeed_Super, std::addressof(UsbEndpointDescriptorsSuperSpeed[1]), sizeof(usb::UsbEndpointDescriptor)));
R_TRY(g_ds_interface.AppendConfigurationData(usb::UsbDeviceSpeed_Super, std::addressof(UsbEndpointCompanionDescriptor), sizeof(usb::UsbEndpointCompanionDescriptor)));
R_SUCCEED();
}
Result InitializeDsEndpoints() {
R_TRY(g_ds_endpoints[0].Initialize(std::addressof(g_ds_interface), 0x81));
R_TRY(g_ds_endpoints[1].Initialize(std::addressof(g_ds_interface), 0x01));
R_SUCCEED();
}
void UsbIndicationThreadFunction(void *) {
/* Get the state change event. */
os::SystemEventType *state_change_event = g_ds_client.GetStateChangeEvent();
/* Setup multi wait. */
os::MultiWaitType multi_wait;
os::InitializeMultiWait(std::addressof(multi_wait));
/* Link multi wait holders. */
os::MultiWaitHolderType state_change_holder;
os::MultiWaitHolderType break_holder;
os::InitializeMultiWaitHolder(std::addressof(state_change_holder), state_change_event);
os::LinkMultiWaitHolder(std::addressof(multi_wait), std::addressof(state_change_holder));
os::InitializeMultiWaitHolder(std::addressof(break_holder), g_usb_break_event.GetBase());
os::LinkMultiWaitHolder(std::addressof(multi_wait), std::addressof(break_holder));
/* Loop forever. */
while (true) {
/* If we should break, do so. */
if (os::WaitAny(std::addressof(multi_wait)) == std::addressof(break_holder)) {
break;
}
/* Clear the state change event. */
os::ClearSystemEvent(state_change_event);
/* Get the new state. */
usb::UsbState usb_state;
R_ABORT_UNLESS(g_ds_client.GetState(std::addressof(usb_state)));
switch (usb_state) {
case usb::UsbState_Detached:
case usb::UsbState_Suspended:
InvokeAvailabilityChangeCallback(UsbAvailability_Unavailable);
break;
case usb::UsbState_Configured:
InvokeAvailabilityChangeCallback(UsbAvailability_Available);
break;
default:
/* Nothing to do. */
break;
}
}
/* Clear the break event. */
g_usb_break_event.Clear();
/* Unlink all holders. */
os::UnlinkAllMultiWaitHolder(std::addressof(multi_wait));
/* Finalize the multi wait/holders. */
os::FinalizeMultiWaitHolder(std::addressof(break_holder));
os::FinalizeMultiWaitHolder(std::addressof(state_change_holder));
os::FinalizeMultiWait(std::addressof(multi_wait));
}
}
void SetUsbAvailabilityChangeCallback(UsbAvailabilityChangeCallback callback, void *param) {
g_availability_change_callback = callback;
g_availability_change_param = param;
}
void ClearUsbAvailabilityChangeCallback() {
g_availability_change_callback = nullptr;
g_availability_change_param = nullptr;
}
Result InitializeUsbInterface() {
/* Set the interface as initialized. */
g_usb_interface_initialized = true;
/* Get the dma buffers. */
g_usb_receive_buffer = GetUsbReceiveBuffer();
g_usb_send_buffer = GetUsbSendBuffer();
/* If we fail somewhere, finalize. */
auto init_guard = SCOPE_GUARD { FinalizeUsbInterface(); };
/* Get the serial number. */
{
settings::factory::SerialNumber serial_number;
serial_number.str[0] = '\x00';
if (R_FAILED(settings::factory::GetSerialNumber(std::addressof(serial_number))) || serial_number.str[0] == '\x00') {
std::strcpy(serial_number.str, "Corrupted S/N");
}
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Waddress-of-packed-member"
u16 *dst = SerialNumberStringDescriptor.wData;
u8 *src = reinterpret_cast<u8 *>(serial_number.str);
u8 count = 0;
#pragma GCC diagnostic pop
while (*src) {
*dst++ = static_cast<u16>(*src++);
++count;
}
SerialNumberStringDescriptor.bLength = 2 + (2 * count);
}
/* Initialize the client. */
R_TRY(InitializeDsClient());
/* Initialize the interface. */
R_TRY(InitializeDsInterface());
/* Initialize the endpoints. */
R_TRY(ConvertUsbDriverResult(InitializeDsEndpoints()));
/* Create the indication thread. */
R_ABORT_UNLESS(os::CreateThread(std::addressof(g_usb_indication_thread), &UsbIndicationThreadFunction, nullptr, GetUsbIndicationThreadStack(), UsbIndicationThreadStackSize, AMS_GET_SYSTEM_THREAD_PRIORITY(htc, HtclowUsbIndication)));
/* Set the thread name. */
os::SetThreadNamePointer(std::addressof(g_usb_indication_thread), AMS_GET_SYSTEM_THREAD_NAME(htc, HtclowUsbIndication));
/* Start the indication thread. */
os::StartThread(std::addressof(g_usb_indication_thread));
/* Enable the usb device. */
R_TRY(g_ds_client.EnableDevice());
/* We succeeded! */
init_guard.Cancel();
R_SUCCEED();
}
void FinalizeUsbInterface() {
g_usb_break_event.Signal();
os::WaitThread(std::addressof(g_usb_indication_thread));
os::DestroyThread(std::addressof(g_usb_indication_thread));
g_ds_client.DisableDevice();
g_ds_endpoints[1].Finalize();
g_ds_endpoints[0].Finalize();
g_ds_interface.Finalize();
g_ds_client.Finalize();
g_usb_interface_initialized = false;
}
Result SendUsb(int *out_transferred, const void *src, int src_size) {
/* Acquire exclusive access to the driver. */
std::scoped_lock lk(g_usb_driver_mutex);
/* Check that we can send the data. */
R_UNLESS(src_size <= static_cast<int>(UsbDmaBufferSize), htclow::ResultInvalidArgument());
/* Copy the data to the dma buffer. */
std::memcpy(g_usb_send_buffer, src, src_size);
/* Transfer data. */
u32 transferred;
R_UNLESS(R_SUCCEEDED(g_ds_endpoints[0].PostBuffer(std::addressof(transferred), g_usb_send_buffer, src_size)), htclow::ResultUsbDriverSendError());
R_UNLESS(transferred == static_cast<u32>(src_size), htclow::ResultUsbDriverSendError());
/* Set output transferred size. */
*out_transferred = src_size;
R_SUCCEED();
}
Result ReceiveUsb(int *out_transferred, void *dst, int dst_size) {
/* Check that we can send the data. */
R_UNLESS(dst_size <= static_cast<int>(UsbDmaBufferSize), htclow::ResultInvalidArgument());
/* Transfer data. */
u32 transferred;
R_UNLESS(R_SUCCEEDED(g_ds_endpoints[1].PostBuffer(std::addressof(transferred), g_usb_receive_buffer, dst_size)), htclow::ResultUsbDriverReceiveError());
R_UNLESS(transferred == static_cast<u32>(dst_size), htclow::ResultUsbDriverReceiveError());
/* Copy the data. */
std::memcpy(dst, g_usb_receive_buffer, dst_size);
/* Set output transferred size. */
*out_transferred = dst_size;
R_SUCCEED();
}
void CancelUsbSendReceive() {
if (g_usb_interface_initialized) {
g_ds_endpoints[0].Cancel();
g_ds_endpoints[1].Cancel();
}
}
}
| 20,605
|
C++
|
.cpp
| 383
| 41.882507
| 240
| 0.597875
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,317
|
htclow_socket_discovery_manager.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/driver/htclow_socket_discovery_manager.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_socket_discovery_manager.hpp"
#include "htclow_socket_discovery_util.hpp"
namespace ams::htclow::driver {
namespace {
constexpr inline u32 BeaconQueryServiceId = 0xB48F5C51;
}
void SocketDiscoveryManager::OnDriverOpen() {
/* Create our socket. */
m_socket = socket::SocketExempt(socket::Family::Af_Inet, socket::Type::Sock_Dgram, socket::Protocol::IpProto_Udp);
AMS_ABORT_UNLESS(m_socket != -1);
/* Mark driver open. */
m_driver_closed = false;
/* Create our thread. */
R_ABORT_UNLESS(os::CreateThread(std::addressof(m_discovery_thread), ThreadEntry, this, m_thread_stack, os::MemoryPageSize, AMS_GET_SYSTEM_THREAD_PRIORITY(htc, HtclowDiscovery)));
/* Set our thread name. */
os::SetThreadNamePointer(std::addressof(m_discovery_thread), AMS_GET_SYSTEM_THREAD_NAME(htc, HtclowDiscovery));
/* Start our thread. */
os::StartThread(std::addressof(m_discovery_thread));
}
void SocketDiscoveryManager::OnDriverClose() {
/* Mark driver closed. */
m_driver_closed = true;
/* Shutdown our socket. */
socket::Shutdown(m_socket, socket::ShutdownMethod::Shut_RdWr);
/* Close our socket. */
socket::Close(m_socket);
/* Destroy our thread. */
os::WaitThread(std::addressof(m_discovery_thread));
os::DestroyThread(std::addressof(m_discovery_thread));
}
void SocketDiscoveryManager::OnSocketAcceptBegin(u16 port) {
AMS_UNUSED(port);
}
void SocketDiscoveryManager::OnSocketAcceptEnd() {
/* ... */
}
void SocketDiscoveryManager::ThreadFunc() {
for (this->DoDiscovery(); !m_driver_closed; this->DoDiscovery()) {
/* Check if the driver is closed five times. */
for (size_t i = 0; i < 5; ++i) {
os::SleepThread(TimeSpan::FromSeconds(1));
if (m_driver_closed) {
return;
}
}
}
}
Result SocketDiscoveryManager::DoDiscovery() {
/* Ensure we close our socket if we fail. */
auto socket_guard = SCOPE_GUARD { socket::Close(m_socket); };
/* Create sockaddr for our socket. */
const socket::SockAddrIn sockaddr = {
.sin_len = 0,
.sin_family = socket::Family::Af_Inet,
.sin_port = socket::InetHtons(20181),
.sin_addr = { socket::InetHtonl(0) },
};
/* Bind our socket. */
const auto bind_res = socket::Bind(m_socket, reinterpret_cast<const socket::SockAddr *>(std::addressof(sockaddr)), sizeof(sockaddr));
R_UNLESS(bind_res != 0, htclow::ResultSocketBindError());
/* Loop processing beacon queries. */
while (true) {
/* Receive a tmipc query header. */
TmipcHeader header;
socket::SockAddr recv_sockaddr;
socket::SockLenT recv_sockaddr_len = sizeof(recv_sockaddr);
const auto recv_res = socket::RecvFrom(m_socket, std::addressof(header), sizeof(header), socket::MsgFlag::Msg_None, std::addressof(recv_sockaddr), std::addressof(recv_sockaddr_len));
/* Check that our receive was valid. */
R_UNLESS(recv_res >= 0, htclow::ResultSocketReceiveFromError());
R_UNLESS(recv_sockaddr_len == sizeof(recv_sockaddr), htclow::ResultSocketReceiveFromError());
/* Check we received a packet header. */
if (recv_res != sizeof(header)) {
continue;
}
/* Check that we received a correctly versioned BeaconQuery packet. */
/* NOTE: Nintendo checks this *after* the following receive, but this seems saner. */
if (header.version != TmipcVersion || header.service_id != BeaconQueryServiceId) {
continue;
}
/* Receive the packet body, if there is one. */
char packet_data[0x120];
/* NOTE: Nintendo does not check this... */
if (header.data_len > sizeof(packet_data)) {
continue;
}
if (header.data_len > 0) {
const auto body_res = socket::RecvFrom(m_socket, packet_data, header.data_len, socket::MsgFlag::Msg_None, std::addressof(recv_sockaddr), std::addressof(recv_sockaddr_len));
R_UNLESS(body_res >= 0, htclow::ResultSocketReceiveFromError());
R_UNLESS(recv_sockaddr_len == sizeof(recv_sockaddr), htclow::ResultSocketReceiveFromError());
if (body_res != header.data_len) {
continue;
}
}
/* Make our beacon response packet. */
const auto len = MakeBeaconResponsePacket(packet_data, sizeof(packet_data));
/* Send the beacon response data. */
const auto send_res = socket::SendTo(m_socket, packet_data, len, socket::MsgFlag::Msg_None, std::addressof(recv_sockaddr), sizeof(recv_sockaddr));
R_UNLESS(send_res >= 0, htclow::ResultSocketSendToError());
}
/* This can never happen, as the above loop should be infinite, but completion logic is here for posterity. */
socket_guard.Cancel();
R_SUCCEED();
}
}
| 5,989
|
C++
|
.cpp
| 120
| 40.266667
| 194
| 0.616478
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,318
|
htclow_mux_ring_buffer.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/mux/htclow_mux_ring_buffer.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_mux_ring_buffer.hpp"
namespace ams::htclow::mux {
void RingBuffer::Initialize(void *buffer, size_t buffer_size) {
/* Validate pre-conditions. */
AMS_ASSERT(m_buffer == nullptr);
AMS_ASSERT(m_read_only_buffer == nullptr);
/* Set our fields. */
m_buffer = buffer;
m_buffer_size = buffer_size;
m_is_read_only = false;
}
void RingBuffer::InitializeForReadOnly(const void *buffer, size_t buffer_size) {
/* Validate pre-conditions. */
AMS_ASSERT(m_buffer == nullptr);
AMS_ASSERT(m_read_only_buffer == nullptr);
/* Set our fields. */
m_read_only_buffer = const_cast<void *>(buffer);
m_buffer_size = buffer_size;
m_data_size = buffer_size;
m_is_read_only = true;
}
void RingBuffer::Clear() {
m_data_size = 0;
m_offset = 0;
m_can_discard = false;
}
Result RingBuffer::Read(void *dst, size_t size) {
/* Copy the data. */
R_TRY(this->Copy(dst, size));
/* Discard. */
R_TRY(this->Discard(size));
R_SUCCEED();
}
Result RingBuffer::Write(const void *data, size_t size) {
/* Validate pre-conditions. */
AMS_ASSERT(!m_is_read_only);
/* Check that our buffer can hold the data. */
R_UNLESS(m_buffer != nullptr, htclow::ResultChannelBufferOverflow());
R_UNLESS(m_data_size + size <= m_buffer_size, htclow::ResultChannelBufferOverflow());
/* Determine position and copy sizes. */
const size_t pos = (m_data_size + m_offset) % m_buffer_size;
const size_t left = std::min(m_buffer_size - pos, size);
const size_t over = size - left;
/* Copy. */
if (left != 0) {
std::memcpy(static_cast<u8 *>(m_buffer) + pos, data, left);
}
if (over != 0) {
std::memcpy(m_buffer, static_cast<const u8 *>(data) + left, over);
}
/* Update our data size. */
m_data_size += size;
R_SUCCEED();
}
Result RingBuffer::Copy(void *dst, size_t size) {
/* Select buffer to discard from. */
void *buffer = m_is_read_only ? m_read_only_buffer : m_buffer;
R_UNLESS(buffer != nullptr, htclow::ResultChannelBufferHasNotEnoughData());
/* Verify that we have enough data. */
R_UNLESS(m_data_size >= size, htclow::ResultChannelBufferHasNotEnoughData());
/* Determine position and copy sizes. */
const size_t pos = m_offset;
const size_t left = std::min(m_buffer_size - pos, size);
const size_t over = size - left;
/* Copy. */
if (left != 0) {
std::memcpy(dst, static_cast<const u8 *>(buffer) + pos, left);
}
if (over != 0) {
std::memcpy(static_cast<u8 *>(dst) + left, buffer, over);
}
/* Mark that we can discard. */
m_can_discard = true;
R_SUCCEED();
}
Result RingBuffer::Discard(size_t size) {
/* Select buffer to discard from. */
void *buffer = m_is_read_only ? m_read_only_buffer : m_buffer;
R_UNLESS(buffer != nullptr, htclow::ResultChannelBufferHasNotEnoughData());
/* Verify that the data we're discarding has been read. */
R_UNLESS(m_can_discard, htclow::ResultChannelCannotDiscard());
/* Verify that we have enough data. */
R_UNLESS(m_data_size >= size, htclow::ResultChannelBufferHasNotEnoughData());
/* Discard. */
m_offset = (m_offset + size) % m_buffer_size;
m_data_size -= size;
m_can_discard = false;
R_SUCCEED();
}
}
| 4,395
|
C++
|
.cpp
| 106
| 33.886792
| 93
| 0.59573
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,319
|
htclow_mux.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/mux/htclow_mux.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_mux.hpp"
#include "../htclow_packet_factory.hpp"
#include "../ctrl/htclow_ctrl_state_machine.hpp"
namespace ams::htclow::mux {
Mux::Mux(PacketFactory *pf, ctrl::HtcctrlStateMachine *sm)
: m_packet_factory(pf), m_state_machine(sm), m_task_manager(), m_event(os::EventClearMode_ManualClear),
m_channel_impl_map(pf, sm, std::addressof(m_task_manager), std::addressof(m_event)), m_global_send_buffer(pf),
m_mutex(), m_state(MuxState::Normal), m_version(ProtocolVersion)
{
/* ... */
}
void Mux::SetVersion(u16 version) {
/* Set our version. */
m_version = version;
/* Set all entries in our map. */
/* NOTE: Nintendo does this highly inefficiently... */
for (auto &pair : m_channel_impl_map.GetMap()) {
m_channel_impl_map[pair.second].SetVersion(m_version);
}
}
Result Mux::CheckReceivedHeader(const PacketHeader &header) const {
/* Check the packet signature. */
AMS_ASSERT(header.signature == HtcGen2Signature);
/* Switch on the packet type. */
switch (header.packet_type) {
case PacketType_Data:
R_UNLESS(header.version == m_version, htclow::ResultProtocolError());
R_UNLESS(header.body_size <= sizeof(PacketBody), htclow::ResultProtocolError());
break;
case PacketType_MaxData:
R_UNLESS(header.version == m_version, htclow::ResultProtocolError());
R_UNLESS(header.body_size == 0, htclow::ResultProtocolError());
break;
case PacketType_Error:
R_UNLESS(header.body_size == 0, htclow::ResultProtocolError());
break;
AMS_UNREACHABLE_DEFAULT_CASE();
}
R_SUCCEED();
}
Result Mux::ProcessReceivePacket(const PacketHeader &header, const void *body, size_t body_size) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Process for the channel. */
if (auto it = m_channel_impl_map.GetMap().find(header.channel); it != m_channel_impl_map.GetMap().end()) {
R_RETURN(m_channel_impl_map[it->second].ProcessReceivePacket(header, body, body_size));
} else {
if (header.packet_type == PacketType_Data || header.packet_type == PacketType_MaxData) {
this->SendErrorPacket(header.channel);
}
R_THROW(htclow::ResultChannelNotExist());
}
}
bool Mux::QuerySendPacket(PacketHeader *header, PacketBody *body, int *out_body_size) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Check for an error packet. */
/* NOTE: Nintendo checks this once per iteration of the below loop. */
/* The extra checks are unnecessary, because we hold our mutex. */
if (auto *error_packet = m_global_send_buffer.GetNextPacket(); error_packet != nullptr) {
std::memcpy(header, error_packet->GetHeader(), sizeof(*header));
*out_body_size = 0;
return true;
}
/* Iterate the map, checking each channel for a valid valid packet. */
for (auto &pair : m_channel_impl_map.GetMap()) {
/* Get the current channel impl. */
/* See if the channel has something for us to send. */
if (m_channel_impl_map[pair.second].QuerySendPacket(header, body, out_body_size)) {
return this->IsSendable(header->packet_type);
}
}
return false;
}
void Mux::RemovePacket(const PacketHeader &header) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Remove the packet from the appropriate source. */
if (header.packet_type == PacketType_Error) {
m_global_send_buffer.RemovePacket();
} else if (auto it = m_channel_impl_map.GetMap().find(header.channel); it != m_channel_impl_map.GetMap().end()) {
m_channel_impl_map[it->second].RemovePacket(header);
}
/* Notify the task manager. */
m_task_manager.NotifySendReady();
}
void Mux::UpdateChannelState() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Update the state of all channels in our map. */
/* NOTE: Nintendo does this highly inefficiently... */
for (auto pair : m_channel_impl_map.GetMap()) {
m_channel_impl_map[pair.second].UpdateState();
}
}
void Mux::UpdateMuxState() {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Update whether we're sleeping. */
if (m_state_machine->IsSleeping()) {
m_state = MuxState::Sleep;
} else {
m_state = MuxState::Normal;
m_event.Signal();
}
}
Result Mux::CheckChannelExist(impl::ChannelInternalType channel) {
R_UNLESS(m_channel_impl_map.Exists(channel), htclow::ResultChannelNotExist());
R_SUCCEED();
}
Result Mux::SendErrorPacket(impl::ChannelInternalType channel) {
/* Create and send the packet. */
R_TRY(m_global_send_buffer.AddPacket(m_packet_factory->MakeErrorPacket(channel)));
/* Signal our event. */
m_event.Signal();
R_SUCCEED();
}
bool Mux::IsSendable(PacketType packet_type) const {
AMS_UNUSED(packet_type);
switch (m_state) {
case MuxState::Normal:
return true;
case MuxState::Sleep:
return false;
AMS_UNREACHABLE_DEFAULT_CASE();
}
}
Result Mux::Open(impl::ChannelInternalType channel) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Check that the channel doesn't already exist. */
R_UNLESS(!m_channel_impl_map.Exists(channel), htclow::ResultChannelAlreadyExist());
/* Add the channel. */
R_TRY(m_channel_impl_map.AddChannel(channel));
/* Set the channel version. */
m_channel_impl_map.GetChannelImpl(channel).SetVersion(m_version);
R_SUCCEED();
}
Result Mux::Close(impl::ChannelInternalType channel) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* If we have the channel, close it. */
if (auto it = m_channel_impl_map.GetMap().find(channel); it != m_channel_impl_map.GetMap().end()) {
/* Shut down the channel. */
m_channel_impl_map[it->second].ShutdownForce();
/* Remove the channel. */
R_ABORT_UNLESS(m_channel_impl_map.RemoveChannel(channel));
}
R_SUCCEED();
}
Result Mux::ConnectBegin(u32 *out_task_id, impl::ChannelInternalType channel) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Find the channel. */
auto it = m_channel_impl_map.GetMap().find(channel);
R_UNLESS(it != m_channel_impl_map.GetMap().end(), htclow::ResultChannelNotExist());
/* Perform the connection. */
R_RETURN(m_channel_impl_map[it->second].DoConnectBegin(out_task_id));
}
Result Mux::ConnectEnd(impl::ChannelInternalType channel, u32 task_id) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Get the trigger for the task. */
const auto trigger = m_task_manager.GetTrigger(task_id);
/* Free the task. */
m_task_manager.FreeTask(task_id);
/* Check that we didn't hit a disconnect. */
R_UNLESS(trigger != EventTrigger_Disconnect, htclow::ResultInvalidChannelStateDisconnected());
/* Find the channel. */
auto it = m_channel_impl_map.GetMap().find(channel);
R_UNLESS(it != m_channel_impl_map.GetMap().end(), htclow::ResultChannelNotExist());
/* Perform the disconnection. */
R_RETURN(m_channel_impl_map[it->second].DoConnectEnd());
}
ChannelState Mux::GetChannelState(impl::ChannelInternalType channel) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
return m_channel_impl_map.GetChannelImpl(channel).GetChannelState();
}
os::EventType *Mux::GetChannelStateEvent(impl::ChannelInternalType channel) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
return m_channel_impl_map.GetChannelImpl(channel).GetChannelStateEvent();
}
Result Mux::FlushBegin(u32 *out_task_id, impl::ChannelInternalType channel) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Find the channel. */
auto it = m_channel_impl_map.GetMap().find(channel);
R_UNLESS(it != m_channel_impl_map.GetMap().end(), htclow::ResultChannelNotExist());
/* Perform the connection. */
R_RETURN(m_channel_impl_map[it->second].DoFlush(out_task_id));
}
Result Mux::FlushEnd(u32 task_id) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Get the trigger for the task. */
const auto trigger = m_task_manager.GetTrigger(task_id);
/* Free the task. */
m_task_manager.FreeTask(task_id);
/* Check that we didn't hit a disconnect. */
R_UNLESS(trigger != EventTrigger_Disconnect, htclow::ResultInvalidChannelStateDisconnected());
R_SUCCEED();
}
os::EventType *Mux::GetTaskEvent(u32 task_id) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
return m_task_manager.GetTaskEvent(task_id);
}
Result Mux::ReceiveBegin(u32 *out_task_id, impl::ChannelInternalType channel, size_t size) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Find the channel. */
auto it = m_channel_impl_map.GetMap().find(channel);
R_UNLESS(it != m_channel_impl_map.GetMap().end(), htclow::ResultChannelNotExist());
/* Perform the connection. */
R_RETURN(m_channel_impl_map[it->second].DoReceiveBegin(out_task_id, size));
}
Result Mux::ReceiveEnd(size_t *out, void *dst, size_t dst_size, impl::ChannelInternalType channel, u32 task_id) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Free the task. */
m_task_manager.FreeTask(task_id);
/* If we have data, perform the receive. */
if (dst_size > 0) {
/* Find the channel. */
auto it = m_channel_impl_map.GetMap().find(channel);
R_UNLESS(it != m_channel_impl_map.GetMap().end(), htclow::ResultChannelNotExist());
/* Perform the receive. */
R_RETURN(m_channel_impl_map[it->second].DoReceiveEnd(out, dst, dst_size));
} else {
*out = 0;
R_SUCCEED();
}
}
Result Mux::SendBegin(u32 *out_task_id, size_t *out, const void *src, size_t src_size, impl::ChannelInternalType channel) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Find the channel. */
auto it = m_channel_impl_map.GetMap().find(channel);
R_UNLESS(it != m_channel_impl_map.GetMap().end(), htclow::ResultChannelNotExist());
/* Perform the connection. */
R_RETURN(m_channel_impl_map[it->second].DoSend(out_task_id, out, src, src_size));
}
Result Mux::SendEnd(u32 task_id) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Get the trigger for the task. */
const auto trigger = m_task_manager.GetTrigger(task_id);
/* Free the task. */
m_task_manager.FreeTask(task_id);
/* Check that we didn't hit a disconnect. */
R_UNLESS(trigger != EventTrigger_Disconnect, htclow::ResultInvalidChannelStateDisconnected());
R_SUCCEED();
}
Result Mux::WaitReceiveBegin(u32 *out_task_id, impl::ChannelInternalType channel, size_t size) {
R_RETURN(this->ReceiveBegin(out_task_id, channel, size));
}
Result Mux::WaitReceiveEnd(u32 task_id) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Get the trigger for the task. */
const auto trigger = m_task_manager.GetTrigger(task_id);
/* Free the task. */
m_task_manager.FreeTask(task_id);
/* Check that we didn't hit a disconnect. */
R_UNLESS(trigger != EventTrigger_Disconnect, htclow::ResultInvalidChannelStateDisconnected());
R_SUCCEED();
}
void Mux::SetConfig(impl::ChannelInternalType channel, const ChannelConfig &config) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Find the channel. */
auto it = m_channel_impl_map.GetMap().find(channel);
AMS_ABORT_UNLESS(it != m_channel_impl_map.GetMap().end());
/* Perform the connection. */
return m_channel_impl_map[it->second].SetConfig(config);
}
void Mux::SetSendBuffer(impl::ChannelInternalType channel, void *buf, size_t buf_size, size_t max_packet_size) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Find the channel. */
auto it = m_channel_impl_map.GetMap().find(channel);
AMS_ABORT_UNLESS(it != m_channel_impl_map.GetMap().end());
/* Set the send buffer. */
m_channel_impl_map[it->second].SetSendBuffer(buf, buf_size, max_packet_size);
}
void Mux::SetSendBufferWithData(impl::ChannelInternalType channel, const void *buf, size_t buf_size, size_t max_packet_size) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Find the channel. */
auto it = m_channel_impl_map.GetMap().find(channel);
AMS_ABORT_UNLESS(it != m_channel_impl_map.GetMap().end());
/* Set the send buffer. */
m_channel_impl_map[it->second].SetSendBufferWithData(buf, buf_size, max_packet_size);
}
void Mux::SetReceiveBuffer(impl::ChannelInternalType channel, void *buf, size_t buf_size) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Find the channel. */
auto it = m_channel_impl_map.GetMap().find(channel);
AMS_ABORT_UNLESS(it != m_channel_impl_map.GetMap().end());
/* Set the send buffer. */
m_channel_impl_map[it->second].SetReceiveBuffer(buf, buf_size);
}
Result Mux::Shutdown(impl::ChannelInternalType channel) {
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Find the channel. */
auto it = m_channel_impl_map.GetMap().find(channel);
R_UNLESS(it != m_channel_impl_map.GetMap().end(), htclow::ResultChannelNotExist());
/* Perform the shutdown. */
R_RETURN(m_channel_impl_map[it->second].DoShutdown());
}
}
| 15,361
|
C++
|
.cpp
| 331
| 37.610272
| 130
| 0.612454
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,320
|
htclow_mux_channel_impl_map.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/mux/htclow_mux_channel_impl_map.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_mux_channel_impl_map.hpp"
namespace ams::htclow::mux {
ChannelImplMap::ChannelImplMap(PacketFactory *pf, ctrl::HtcctrlStateMachine *sm, TaskManager *tm, os::Event *ev)
: m_packet_factory(pf), m_state_machine(sm), m_task_manager(tm), m_event(ev), m_map()
{
/* Initialize the map. */
m_map.Initialize(MaxChannelCount, m_map_buffer, sizeof(m_map_buffer));
/* Set all storages as invalid. */
for (auto i = 0; i < MaxChannelCount; ++i) {
m_storage_valid[i] = false;
}
}
ChannelImpl &ChannelImplMap::GetChannelImpl(int index) {
return GetReference(m_channel_storage[index]);
}
ChannelImpl &ChannelImplMap::GetChannelImpl(impl::ChannelInternalType channel) {
/* Find the channel. */
auto it = m_map.find(channel);
AMS_ASSERT(it != m_map.end());
/* Return the implementation object. */
return this->GetChannelImpl(it->second);
}
Result ChannelImplMap::AddChannel(impl::ChannelInternalType channel) {
/* Find a free storage. */
int idx;
for (idx = 0; idx < MaxChannelCount; ++idx) {
if (!m_storage_valid[idx]) {
break;
}
}
/* Validate that the storage is free. */
R_UNLESS(idx < MaxChannelCount, htclow::ResultOutOfChannel());
/* Create the channel impl. */
util::ConstructAt(m_channel_storage[idx], channel, m_packet_factory, m_state_machine, m_task_manager, m_event);
/* Mark the storage valid. */
m_storage_valid[idx] = true;
/* Insert into our map. */
m_map.insert(std::pair<const impl::ChannelInternalType, int>{channel, idx});
R_SUCCEED();
}
Result ChannelImplMap::RemoveChannel(impl::ChannelInternalType channel) {
/* Find the storage. */
auto it = m_map.find(channel);
AMS_ASSERT(it != m_map.end());
/* Get the channel index. */
const auto index = it->second;
AMS_ASSERT(0 <= index && index < MaxChannelCount);
/* Get the channel impl. */
auto *channel_impl = GetPointer(m_channel_storage[index]);
/* Mark the storage as invalid. */
m_storage_valid[index] = false;
/* Erase the channel from the map. */
m_map.erase(channel);
/* Destroy the channel. */
std::destroy_at(channel_impl);
R_SUCCEED();
}
}
| 3,115
|
C++
|
.cpp
| 74
| 35.013514
| 119
| 0.636544
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,321
|
htclow_mux_send_buffer.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/mux/htclow_mux_send_buffer.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_mux_channel_impl.hpp"
#include "../htclow_packet_factory.hpp"
#include "../htclow_default_channel_config.hpp"
namespace ams::htclow::mux {
SendBuffer::SendBuffer(impl::ChannelInternalType channel, PacketFactory *pf)
: m_channel(channel), m_packet_factory(pf), m_ring_buffer(), m_packet_list(),
m_version(ProtocolVersion), m_flow_control_enabled(true), m_max_packet_size(DefaultChannelConfig.max_packet_size)
{
/* ... */
}
SendBuffer::~SendBuffer() {
m_ring_buffer.Clear();
this->Clear();
}
bool SendBuffer::IsPriorPacket(PacketType packet_type) const {
return packet_type == PacketType_MaxData;
}
void SendBuffer::SetVersion(s16 version) {
/* Set version. */
m_version = version;
}
void SendBuffer::SetFlowControlEnabled(bool en) {
/* Set flow control enabled. */
m_flow_control_enabled = en;
}
void SendBuffer::MakeDataPacketHeader(PacketHeader *header, int body_size, s16 version, u64 share, u32 offset) const {
/* Set all packet fields. */
header->signature = HtcGen2Signature;
header->offset = offset;
header->reserved = 0;
header->version = version;
header->body_size = body_size;
header->channel = m_channel;
header->packet_type = PacketType_Data;
header->share = share;
}
void SendBuffer::CopyPacket(PacketHeader *header, PacketBody *body, int *out_body_size, const Packet &packet) {
/* Get the body size. */
const int body_size = packet.GetBodySize();
AMS_ASSERT(0 <= body_size && body_size <= static_cast<int>(sizeof(*body)));
/* Copy the header. */
std::memcpy(header, packet.GetHeader(), sizeof(*header));
/* Copy the body. */
std::memcpy(body, packet.GetBody(), body_size);
/* Set the output body size. */
*out_body_size = body_size;
}
bool SendBuffer::QueryNextPacket(PacketHeader *header, PacketBody *body, int *out_body_size, u64 max_data, u64 total_send_size, bool has_share, u64 share) {
/* Check for a max data packet. */
if (!m_packet_list.empty()) {
this->CopyPacket(header, body, out_body_size, m_packet_list.front());
return true;
}
/* Check that we have data. */
const auto ring_buffer_data_size = m_ring_buffer.GetDataSize();
if (ring_buffer_data_size == 0) {
return false;
}
/* Check that we're valid for flow control. */
if (m_flow_control_enabled && !has_share) {
return false;
}
/* Determine the sendable size. */
const auto offset = total_send_size - ring_buffer_data_size;
const auto sendable_size = m_flow_control_enabled ? std::min<size_t>(share - offset, ring_buffer_data_size) : ring_buffer_data_size;
if (sendable_size == 0) {
return false;
}
/* We're additionally bound by the actual packet size. */
const auto data_size = std::min(sendable_size, m_max_packet_size);
/* Make data packet header. */
this->MakeDataPacketHeader(header, data_size, m_version, max_data, offset);
/* Copy the data. */
R_ABORT_UNLESS(m_ring_buffer.Copy(body, data_size));
/* Set output body size. */
*out_body_size = data_size;
return true;
}
void SendBuffer::AddPacket(std::unique_ptr<Packet, PacketDeleter> ptr) {
/* Get the packet. */
auto *packet = ptr.release();
/* Check the packet type. */
AMS_ABORT_UNLESS(this->IsPriorPacket(packet->GetHeader()->packet_type));
/* Add the packet. */
m_packet_list.push_back(*packet);
}
void SendBuffer::RemovePacket(const PacketHeader &header) {
/* Get the packet type. */
const auto packet_type = header.packet_type;
if (this->IsPriorPacket(packet_type)) {
/* Packet will be using our list. */
auto *packet = std::addressof(m_packet_list.front());
m_packet_list.pop_front();
m_packet_factory->Delete(packet);
} else {
/* Packet managed by ring buffer. */
AMS_ABORT_UNLESS(packet_type == PacketType_Data);
/* Discard the packet's data. */
const Result result = m_ring_buffer.Discard(header.body_size);
if (!htclow::ResultChannelCannotDiscard::Includes(result)) {
R_ABORT_UNLESS(result);
}
}
}
size_t SendBuffer::AddData(const void *data, size_t size) {
/* Determine how much to actually add. */
size = std::min(size, m_ring_buffer.GetBufferSize() - m_ring_buffer.GetDataSize());
/* Write the data. */
R_ABORT_UNLESS(m_ring_buffer.Write(data, size));
/* Return the size we wrote. */
return size;
}
void SendBuffer::SetBuffer(void *buffer, size_t buffer_size) {
m_ring_buffer.Initialize(buffer, buffer_size);
}
void SendBuffer::SetReadOnlyBuffer(const void *buffer, size_t buffer_size) {
m_ring_buffer.InitializeForReadOnly(buffer, buffer_size);
}
void SendBuffer::SetMaxPacketSize(size_t max_packet_size) {
m_max_packet_size = max_packet_size;
}
bool SendBuffer::Empty() {
return m_packet_list.empty() && m_ring_buffer.GetDataSize() == 0;
}
void SendBuffer::Clear() {
while (!m_packet_list.empty()) {
auto *packet = std::addressof(m_packet_list.front());
m_packet_list.pop_front();
m_packet_factory->Delete(packet);
}
}
}
| 6,381
|
C++
|
.cpp
| 148
| 35.263514
| 160
| 0.622358
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
6,322
|
htclow_mux_channel_impl.cpp
|
Atmosphere-NX_Atmosphere/libraries/libstratosphere/source/htclow/mux/htclow_mux_channel_impl.cpp
|
/*
* Copyright (c) Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "htclow_mux_channel_impl.hpp"
#include "../ctrl/htclow_ctrl_state_machine.hpp"
#include "../htclow_default_channel_config.hpp"
#include "../htclow_packet_factory.hpp"
namespace ams::htclow::mux {
ChannelImpl::ChannelImpl(impl::ChannelInternalType channel, PacketFactory *pf, ctrl::HtcctrlStateMachine *sm, TaskManager *tm, os::Event *ev)
: m_channel(channel), m_packet_factory(pf), m_state_machine(sm), m_task_manager(tm), m_event(ev),
m_send_buffer(m_channel, pf), m_receive_buffer(), m_version(ProtocolVersion), m_config(DefaultChannelConfig),
m_offset(0), m_total_send_size(0), m_cur_max_data(0), m_prev_max_data(0), m_share(),
m_state_change_event(os::EventClearMode_ManualClear), m_state(ChannelState_Unconnectable)
{
this->UpdateState();
}
void ChannelImpl::SetVersion(s16 version) {
/* Sanity check the version. */
AMS_ASSERT(version <= ProtocolVersion);
/* Set version. */
m_version = version;
m_send_buffer.SetVersion(version);
}
Result ChannelImpl::CheckState(std::initializer_list<ChannelState> states) const {
/* Determine if we have a matching state. */
bool match = false;
for (const auto &state : states) {
match |= m_state == state;
}
/* If we do, we're good. */
R_SUCCEED_IF(match);
/* Otherwise, return appropriate failure error. */
if (m_state == ChannelState_Disconnected) {
R_THROW(htclow::ResultInvalidChannelStateDisconnected());
} else {
R_THROW(htclow::ResultInvalidChannelState());
}
}
Result ChannelImpl::CheckPacketVersion(s16 version) const {
R_UNLESS(version == m_version, htclow::ResultChannelVersionNotMatched());
R_SUCCEED();
}
Result ChannelImpl::ProcessReceivePacket(const PacketHeader &header, const void *body, size_t body_size) {
switch (header.packet_type) {
case PacketType_Data:
R_RETURN(this->ProcessReceiveDataPacket(header.version, header.share, header.offset, body, body_size));
case PacketType_MaxData:
R_RETURN(this->ProcessReceiveMaxDataPacket(header.version, header.share));
case PacketType_Error:
R_RETURN(this->ProcessReceiveErrorPacket());
default:
R_THROW(htclow::ResultProtocolError());
}
}
Result ChannelImpl::ProcessReceiveDataPacket(s16 version, u64 share, u32 offset, const void *body, size_t body_size) {
/* Check our state. */
R_TRY(this->CheckState({ChannelState_Connectable, ChannelState_Connected}));
/* Check the packet version. */
R_TRY(this->CheckPacketVersion(version));
/* Check that offset matches. */
R_UNLESS(offset == static_cast<u32>(m_offset), htclow::ResultProtocolError());
/* Check for flow control, if we should. */
if (m_config.flow_control_enabled) {
/* Check that the share increases monotonically. */
if (m_share.has_value()) {
R_UNLESS(m_share.value() <= share, htclow::ResultProtocolError());
}
/* Update our share. */
m_share = share;
/* Signal our event. */
this->SignalSendPacketEvent();
}
/* Update our offset. */
m_offset += body_size;
/* Write the packet body. */
R_ABORT_UNLESS(m_receive_buffer.Write(body, body_size));
/* Notify the data was received. */
m_task_manager->NotifyReceiveData(m_channel, m_receive_buffer.GetDataSize());
R_SUCCEED();
}
Result ChannelImpl::ProcessReceiveMaxDataPacket(s16 version, u64 share) {
/* Check our state. */
R_TRY(this->CheckState({ChannelState_Connectable, ChannelState_Connected}));
/* Check the packet version. */
R_TRY(this->CheckPacketVersion(version));
/* Check for flow control, if we should. */
if (m_config.flow_control_enabled) {
/* Check that the share increases monotonically. */
if (m_share.has_value()) {
R_UNLESS(m_share.value() <= share, htclow::ResultProtocolError());
}
/* Update our share. */
m_share = share;
/* Signal our event. */
this->SignalSendPacketEvent();
}
R_SUCCEED();
}
Result ChannelImpl::ProcessReceiveErrorPacket() {
if (m_state == ChannelState_Connected || m_state == ChannelState_Disconnected) {
this->ShutdownForce();
}
R_SUCCEED();
}
bool ChannelImpl::QuerySendPacket(PacketHeader *header, PacketBody *body, int *out_body_size) {
/* Check our send buffer. */
if (m_send_buffer.QueryNextPacket(header, body, out_body_size, m_cur_max_data, m_total_send_size, m_share.has_value(), m_share.value_or(0))) {
/* Update tracking variables. */
if (header->packet_type == PacketType_Data) {
m_prev_max_data = m_cur_max_data;
}
return true;
} else {
return false;
}
}
void ChannelImpl::RemovePacket(const PacketHeader &header) {
/* Remove the packet. */
m_send_buffer.RemovePacket(header);
/* Check if the send buffer is now empty. */
if (m_send_buffer.Empty()) {
m_task_manager->NotifySendBufferEmpty(m_channel);
}
}
void ChannelImpl::UpdateState() {
/* Check if shutdown must be forced. */
if (m_state_machine->IsUnsupportedServiceChannelToShutdown(m_channel)) {
this->ShutdownForce();
}
/* Check if we're readied. */
if (m_state_machine->IsReadied()) {
m_task_manager->NotifyConnectReady();
}
/* Update our state transition. */
if (m_state_machine->IsConnectable(m_channel)) {
if (m_state == ChannelState_Unconnectable) {
this->SetState(ChannelState_Connectable);
}
} else if (m_state_machine->IsUnconnectable()) {
if (m_state == ChannelState_Connectable) {
this->SetState(ChannelState_Unconnectable);
m_state_machine->SetNotConnecting(m_channel);
} else if (m_state == ChannelState_Connected) {
this->ShutdownForce();
}
}
}
void ChannelImpl::ShutdownForce() {
/* Clear our send buffer. */
m_send_buffer.Clear();
/* Set our state to shutdown. */
this->SetState(ChannelState_Disconnected);
}
void ChannelImpl::SetState(ChannelState state) {
/* Check that we can perform the transition. */
AMS_ABORT_UNLESS(IsStateTransitionAllowed(m_state, state));
/* Perform the transition. */
this->SetStateWithoutCheck(state);
}
void ChannelImpl::SetStateWithoutCheck(ChannelState state) {
/* Change our state. */
if (m_state != state) {
m_state = state;
m_state_change_event.Signal();
}
/* If relevant, notify disconnect. */
if (m_state == ChannelState_Disconnected) {
m_task_manager->NotifyDisconnect(m_channel);
}
}
void ChannelImpl::SignalSendPacketEvent() {
if (m_event != nullptr) {
m_event->Signal();
}
}
Result ChannelImpl::DoConnectBegin(u32 *out_task_id) {
/* Check our state. */
R_TRY(this->CheckState({ChannelState_Connectable}));
/* Set ourselves as connecting. */
m_state_machine->SetConnecting(m_channel);
/* Allocate a task. */
u32 task_id{};
R_TRY(m_task_manager->AllocateTask(std::addressof(task_id), m_channel));
/* Configure the task. */
m_task_manager->ConfigureConnectTask(task_id);
/* If we're ready, complete the task immediately. */
if (m_state_machine->IsReadied()) {
m_task_manager->CompleteTask(task_id, EventTrigger_ConnectReady);
}
/* Set the output task id. */
*out_task_id = task_id;
R_SUCCEED();
}
Result ChannelImpl::DoConnectEnd() {
/* Check our state. */
R_TRY(this->CheckState({ChannelState_Connectable}));
/* Perform handshake, if we should. */
if (m_config.handshake_enabled) {
/* Set our current max data. */
m_cur_max_data = m_receive_buffer.GetBufferSize();
/* Make a max data packet. */
auto packet = m_packet_factory->MakeMaxDataPacket(m_channel, m_version, m_cur_max_data);
R_UNLESS(packet, htclow::ResultOutOfMemory());
/* Send the packet. */
m_send_buffer.AddPacket(std::move(packet));
/* Signal that we have an packet to send. */
this->SignalSendPacketEvent();
/* Set our prev max data. */
m_prev_max_data = m_cur_max_data;
} else {
/* Set our share. */
m_share = m_config.initial_counter_max_data;
/* If we're not empty, signal. */
if (!m_send_buffer.Empty()) {
this->SignalSendPacketEvent();
}
}
/* Set our state as connected. */
this->SetState(ChannelState_Connected);
R_SUCCEED();
}
Result ChannelImpl::DoFlush(u32 *out_task_id) {
/* Check our state. */
R_TRY(this->CheckState({ChannelState_Connected}));
/* Allocate a task. */
u32 task_id{};
R_TRY(m_task_manager->AllocateTask(std::addressof(task_id), m_channel));
/* Configure the task. */
m_task_manager->ConfigureFlushTask(task_id);
/* If we're already flushed, complete the task immediately. */
if (m_send_buffer.Empty()) {
m_task_manager->CompleteTask(task_id, EventTrigger_SendBufferEmpty);
}
/* Set the output task id. */
*out_task_id = task_id;
R_SUCCEED();
}
Result ChannelImpl::DoReceiveBegin(u32 *out_task_id, size_t size) {
/* Check our state. */
R_TRY(this->CheckState({ChannelState_Connected, ChannelState_Disconnected}));
/* Allocate a task. */
u32 task_id{};
R_TRY(m_task_manager->AllocateTask(std::addressof(task_id), m_channel));
/* Configure the task. */
m_task_manager->ConfigureReceiveTask(task_id, size);
/* Check if the task is already complete. */
if (m_receive_buffer.GetDataSize() >= size) {
m_task_manager->CompleteTask(task_id, EventTrigger_ReceiveData);
} else if (m_state == ChannelState_Disconnected) {
m_task_manager->CompleteTask(task_id, EventTrigger_Disconnect);
}
/* Set the output task id. */
*out_task_id = task_id;
R_SUCCEED();
}
Result ChannelImpl::DoReceiveEnd(size_t *out, void *dst, size_t dst_size) {
/* Check our state. */
R_TRY(this->CheckState({ChannelState_Connected, ChannelState_Disconnected}));
/* If we have nowhere to receive, we're done. */
if (dst_size == 0) {
*out = 0;
R_SUCCEED();
}
/* Get the amount of receivable data. */
const size_t receivable = m_receive_buffer.GetDataSize();
const size_t received = std::min(dst_size, receivable);
/* Read the data. */
R_ABORT_UNLESS(m_receive_buffer.Read(dst, received));
/* Handle flow control, if we should. */
if (m_config.flow_control_enabled) {
/* Read our fields. */
const auto prev_max_data = m_prev_max_data;
const auto next_max_data = m_cur_max_data + received;
const auto max_packet_size = m_config.max_packet_size;
const auto offset = m_offset;
/* Update our current max data. */
m_cur_max_data = next_max_data;
/* If we can, send a max data packet. */
if (prev_max_data - offset < max_packet_size + sizeof(PacketHeader)) {
/* Make a max data packet. */
auto packet = m_packet_factory->MakeMaxDataPacket(m_channel, m_version, next_max_data);
R_UNLESS(packet, htclow::ResultOutOfMemory());
/* Send the packet. */
m_send_buffer.AddPacket(std::move(packet));
/* Signal that we have an packet to send. */
this->SignalSendPacketEvent();
/* Set our prev max data. */
m_prev_max_data = m_cur_max_data;
}
}
/* Set the output size. */
*out = received;
R_SUCCEED();
}
Result ChannelImpl::DoSend(u32 *out_task_id, size_t *out, const void *src, size_t src_size) {
/* Check our state. */
R_TRY(this->CheckState({ChannelState_Connected}));
/* Allocate a task. */
u32 task_id{};
R_TRY(m_task_manager->AllocateTask(std::addressof(task_id), m_channel));
/* Send the data. */
const size_t sent = m_send_buffer.AddData(src, src_size);
/* Add the size to our total. */
m_total_send_size += sent;
/* Signal our event. */
this->SignalSendPacketEvent();
/* Configure the task. */
m_task_manager->ConfigureSendTask(task_id);
/* If we sent all the data, we're done. */
if (sent == src_size) {
m_task_manager->CompleteTask(task_id, EventTrigger_SendComplete);
}
/* Set the output. */
*out_task_id = task_id;
*out = sent;
R_SUCCEED();
}
Result ChannelImpl::DoShutdown() {
/* Check our state. */
R_TRY(this->CheckState({ChannelState_Connected}));
/* Set our state. */
this->SetState(ChannelState_Disconnected);
R_SUCCEED();
}
void ChannelImpl::SetConfig(const ChannelConfig &config) {
/* Check our state. */
R_ABORT_UNLESS(this->CheckState({ChannelState_Unconnectable, ChannelState_Connectable}));
/* Set our config. */
m_config = config;
/* Set flow control for our send buffer. */
m_send_buffer.SetFlowControlEnabled(m_config.flow_control_enabled);
}
void ChannelImpl::SetSendBuffer(void *buf, size_t buf_size, size_t max_packet_size) {
/* Set buffer. */
m_send_buffer.SetBuffer(buf, buf_size);
/* Determine true max packet size. */
if (m_config.flow_control_enabled) {
max_packet_size = std::min(max_packet_size, m_config.max_packet_size);
}
/* Set max packet size. */
m_send_buffer.SetMaxPacketSize(max_packet_size);
}
void ChannelImpl::SetReceiveBuffer(void *buf, size_t buf_size) {
/* Set the buffer. */
m_receive_buffer.Initialize(buf, buf_size);
}
void ChannelImpl::SetSendBufferWithData(const void *buf, size_t buf_size, size_t max_packet_size) {
/* Set buffer. */
m_send_buffer.SetReadOnlyBuffer(buf, buf_size);
/* Determine true max packet size. */
if (m_config.flow_control_enabled) {
max_packet_size = std::min(max_packet_size, m_config.max_packet_size);
}
/* Set max packet size. */
m_send_buffer.SetMaxPacketSize(max_packet_size);
/* Set our total send size. */
m_total_send_size = buf_size;
}
}
| 16,195
|
C++
|
.cpp
| 372
| 34.005376
| 150
| 0.595535
|
Atmosphere-NX/Atmosphere
| 14,324
| 1,207
| 54
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.