Merge branch 'upstream-merge'
This commit is contained in:
commit
109523548e
1 changed files with 72562 additions and 50939 deletions
194
src/raudio.c
194
src/raudio.c
|
|
@ -163,6 +163,11 @@ typedef struct tagBITMAPINFOHEADER {
|
|||
#define MA_MALLOC RL_MALLOC
|
||||
#define MA_FREE RL_FREE
|
||||
|
||||
#if defined(PLATFORM_NX)
|
||||
#define MA_ENABLE_ONLY_SPECIFIC_BACKENDS
|
||||
#define MA_ENABLE_CUSTOM
|
||||
#endif
|
||||
|
||||
#define MA_NO_JACK
|
||||
#define MA_NO_WAV
|
||||
#define MA_NO_FLAC
|
||||
|
|
@ -170,6 +175,9 @@ typedef struct tagBITMAPINFOHEADER {
|
|||
#define MINIAUDIO_IMPLEMENTATION
|
||||
//#define MA_DEBUG_OUTPUT
|
||||
#include "external/miniaudio.h" // Audio device initialization and management
|
||||
#if defined(PLATFORM_NX)
|
||||
#include "external/miniaudio_sdl.h"
|
||||
#endif
|
||||
#undef PlaySound // Win32 API: windows.h > mmsystem.h defines PlaySound macro
|
||||
|
||||
#include <stdlib.h> // Required for: malloc(), free()
|
||||
|
|
@ -247,10 +255,6 @@ typedef struct tagBITMAPINFOHEADER {
|
|||
#include "external/dr_flac.h" // FLAC loading functions
|
||||
#endif
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#undef bool
|
||||
#endif
|
||||
|
||||
//----------------------------------------------------------------------------------
|
||||
// Defines and Macros
|
||||
//----------------------------------------------------------------------------------
|
||||
|
|
@ -311,10 +315,13 @@ typedef enum {
|
|||
AUDIO_BUFFER_USAGE_STREAM
|
||||
} AudioBufferUsage;
|
||||
|
||||
// Audio buffer structure
|
||||
// Audio buffer struct
|
||||
struct rAudioBuffer {
|
||||
ma_data_converter converter; // Audio data converter
|
||||
|
||||
AudioCallback callback; // Audio buffer callback for buffer filling on audio threads
|
||||
rAudioProcessor *processor; // Audio processor
|
||||
|
||||
float volume; // Audio buffer volume
|
||||
float pitch; // Audio buffer pitch
|
||||
float pan; // Audio buffer pan (0.0f to 1.0f)
|
||||
|
|
@ -335,6 +342,14 @@ struct rAudioBuffer {
|
|||
rAudioBuffer *prev; // Previous audio buffer on the list
|
||||
};
|
||||
|
||||
// Audio processor struct
|
||||
// NOTE: Useful to apply effects to an AudioBuffer
|
||||
struct rAudioProcessor {
|
||||
AudioCallback process; // Processor callback function
|
||||
rAudioProcessor *next; // Next audio processor on the list
|
||||
rAudioProcessor *prev; // Previous audio processor on the list
|
||||
};
|
||||
|
||||
#define AudioBuffer rAudioBuffer // HACK: To avoid CoreAudio (macOS) symbol collision
|
||||
|
||||
// Audio data context
|
||||
|
|
@ -372,7 +387,7 @@ static AudioData AUDIO = { // Global AUDIO context
|
|||
//----------------------------------------------------------------------------------
|
||||
// Module specific Functions Declaration
|
||||
//----------------------------------------------------------------------------------
|
||||
static void OnLog(ma_context *pContext, ma_device *pDevice, ma_uint32 logLevel, const char *message);
|
||||
static void OnLog(void *pUserData, ma_uint32 level, const char *pMessage);
|
||||
static void OnSendAudioDataToDevice(ma_device *pDevice, void *pFramesOut, const void *pFramesInput, ma_uint32 frameCount);
|
||||
static void MixAudioFrames(float *framesOut, const float *framesIn, ma_uint32 frameCount, AudioBuffer *buffer);
|
||||
|
||||
|
|
@ -411,9 +426,17 @@ void InitAudioDevice(void)
|
|||
{
|
||||
// Init audio context
|
||||
ma_context_config ctxConfig = ma_context_config_init();
|
||||
ctxConfig.logCallback = OnLog;
|
||||
ma_log_callback_init(OnLog, NULL);
|
||||
|
||||
#if defined(PLATFORM_NX)
|
||||
ma_backend backends[] = {
|
||||
ma_backend_custom
|
||||
};
|
||||
ctxConfig.custom.onContextInit = ma_context_init__sdl;
|
||||
ma_result result = ma_context_init(backends, sizeof(backends)/sizeof(backends[0]), &ctxConfig, &AUDIO.System.context);
|
||||
#else
|
||||
ma_result result = ma_context_init(NULL, 0, &ctxConfig, &AUDIO.System.context);
|
||||
#endif
|
||||
if (result != MA_SUCCESS)
|
||||
{
|
||||
TRACELOG(LOG_WARNING, "AUDIO: Failed to initialize context");
|
||||
|
|
@ -465,8 +488,7 @@ void InitAudioDevice(void)
|
|||
// Init dummy audio buffers pool for multichannel sound playing
|
||||
for (int i = 0; i < MAX_AUDIO_BUFFER_POOL_CHANNELS; i++)
|
||||
{
|
||||
// WARNING: An empty audio buffer is created (data = 0)
|
||||
// AudioBuffer data just points to loaded sound data
|
||||
// WARNING: An empty audio buffer is created (data = 0) and added to list, AudioBuffer data is filled on PlaySoundMulti()
|
||||
AUDIO.MultiChannel.pool[i] = LoadAudioBuffer(AUDIO_DEVICE_FORMAT, AUDIO_DEVICE_CHANNELS, AUDIO.System.device.sampleRate, 0, AUDIO_BUFFER_USAGE_STATIC);
|
||||
}
|
||||
|
||||
|
|
@ -492,7 +514,7 @@ void CloseAudioDevice(void)
|
|||
//UnloadAudioBuffer(AUDIO.MultiChannel.pool[i]);
|
||||
if (AUDIO.MultiChannel.pool[i] != NULL)
|
||||
{
|
||||
ma_data_converter_uninit(&AUDIO.MultiChannel.pool[i]->converter);
|
||||
ma_data_converter_uninit(&AUDIO.MultiChannel.pool[i]->converter, NULL);
|
||||
UntrackAudioBuffer(AUDIO.MultiChannel.pool[i]);
|
||||
//RL_FREE(buffer->data); // Already unloaded by UnloadSound()
|
||||
RL_FREE(AUDIO.MultiChannel.pool[i]);
|
||||
|
|
@ -541,9 +563,9 @@ AudioBuffer *LoadAudioBuffer(ma_format format, ma_uint32 channels, ma_uint32 sam
|
|||
|
||||
// Audio data runs through a format converter
|
||||
ma_data_converter_config converterConfig = ma_data_converter_config_init(format, AUDIO_DEVICE_FORMAT, channels, AUDIO_DEVICE_CHANNELS, sampleRate, AUDIO.System.device.sampleRate);
|
||||
converterConfig.resampling.allowDynamicSampleRate = true; // Pitch shifting
|
||||
converterConfig.allowDynamicSampleRate = true;
|
||||
|
||||
ma_result result = ma_data_converter_init(&converterConfig, &audioBuffer->converter);
|
||||
ma_result result = ma_data_converter_init(&converterConfig, NULL, &audioBuffer->converter);
|
||||
|
||||
if (result != MA_SUCCESS)
|
||||
{
|
||||
|
|
@ -557,9 +579,13 @@ AudioBuffer *LoadAudioBuffer(ma_format format, ma_uint32 channels, ma_uint32 sam
|
|||
audioBuffer->pitch = 1.0f;
|
||||
audioBuffer->pan = 0.5f;
|
||||
|
||||
audioBuffer->callback = NULL;
|
||||
audioBuffer->processor = NULL;
|
||||
|
||||
audioBuffer->playing = false;
|
||||
audioBuffer->paused = false;
|
||||
audioBuffer->looping = false;
|
||||
|
||||
audioBuffer->usage = usage;
|
||||
audioBuffer->frameCursorPos = 0;
|
||||
audioBuffer->sizeInFrames = sizeInFrames;
|
||||
|
|
@ -580,7 +606,7 @@ void UnloadAudioBuffer(AudioBuffer *buffer)
|
|||
{
|
||||
if (buffer != NULL)
|
||||
{
|
||||
ma_data_converter_uninit(&buffer->converter);
|
||||
ma_data_converter_uninit(&buffer->converter, NULL);
|
||||
UntrackAudioBuffer(buffer);
|
||||
RL_FREE(buffer->data);
|
||||
RL_FREE(buffer);
|
||||
|
|
@ -654,8 +680,8 @@ void SetAudioBufferPitch(AudioBuffer *buffer, float pitch)
|
|||
// Note that this changes the duration of the sound:
|
||||
// - higher pitches will make the sound faster
|
||||
// - lower pitches make it slower
|
||||
ma_uint32 outputSampleRate = (ma_uint32)((float)buffer->converter.config.sampleRateOut/pitch);
|
||||
ma_data_converter_set_rate(&buffer->converter, buffer->converter.config.sampleRateIn, outputSampleRate);
|
||||
ma_uint32 outputSampleRate = (ma_uint32)((float)buffer->converter.sampleRateOut/pitch);
|
||||
ma_data_converter_set_rate(&buffer->converter, buffer->converter.sampleRateIn, outputSampleRate);
|
||||
|
||||
buffer->pitch = pitch;
|
||||
}
|
||||
|
|
@ -894,7 +920,7 @@ void UpdateSound(Sound sound, const void *data, int sampleCount)
|
|||
StopAudioBuffer(sound.stream.buffer);
|
||||
|
||||
// TODO: May want to lock/unlock this since this data buffer is read at mixing time
|
||||
memcpy(sound.stream.buffer->data, data, sampleCount*ma_get_bytes_per_frame(sound.stream.buffer->converter.config.formatIn, sound.stream.buffer->converter.config.channelsIn));
|
||||
memcpy(sound.stream.buffer->data, data, sampleCount*ma_get_bytes_per_frame(sound.stream.buffer->converter.formatIn, sound.stream.buffer->converter.channelsIn));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1068,7 +1094,8 @@ void PlaySoundMulti(Sound sound)
|
|||
AUDIO.MultiChannel.pool[index]->isSubBufferProcessed[0] = false;
|
||||
AUDIO.MultiChannel.pool[index]->isSubBufferProcessed[1] = false;
|
||||
AUDIO.MultiChannel.pool[index]->sizeInFrames = sound.stream.buffer->sizeInFrames;
|
||||
AUDIO.MultiChannel.pool[index]->data = sound.stream.buffer->data;
|
||||
|
||||
AUDIO.MultiChannel.pool[index]->data = sound.stream.buffer->data; // Fill dummy track with data for playing
|
||||
|
||||
PlayAudioBuffer(AUDIO.MultiChannel.pool[index]);
|
||||
}
|
||||
|
|
@ -1191,8 +1218,7 @@ Wave WaveCopy(Wave wave)
|
|||
// NOTE: Security check in case of out-of-range
|
||||
void WaveCrop(Wave *wave, int initSample, int finalSample)
|
||||
{
|
||||
if ((initSample >= 0) && (initSample < finalSample) &&
|
||||
(finalSample > 0) && ((unsigned int)finalSample < (wave->frameCount*wave->channels)))
|
||||
if ((initSample >= 0) && (initSample < finalSample) && ((unsigned int)finalSample < (wave->frameCount*wave->channels)))
|
||||
{
|
||||
int sampleCount = finalSample - initSample;
|
||||
|
||||
|
|
@ -1503,16 +1529,14 @@ Music LoadMusicStreamFromMemory(const char *fileType, const unsigned char *data,
|
|||
jar_xm_set_max_loop_count(ctxXm, 0); // Set infinite number of loops
|
||||
|
||||
unsigned int bits = 32;
|
||||
if (AUDIO_DEVICE_FORMAT == ma_format_s16)
|
||||
bits = 16;
|
||||
else if (AUDIO_DEVICE_FORMAT == ma_format_u8)
|
||||
bits = 8;
|
||||
if (AUDIO_DEVICE_FORMAT == ma_format_s16) bits = 16;
|
||||
else if (AUDIO_DEVICE_FORMAT == ma_format_u8) bits = 8;
|
||||
|
||||
// NOTE: Only stereo is supported for XM
|
||||
music.stream = LoadAudioStream(AUDIO.System.device.sampleRate, bits, 2);
|
||||
music.frameCount = (unsigned int)jar_xm_get_remaining_samples(ctxXm); // NOTE: Always 2 channels (stereo)
|
||||
music.looping = true; // Looping enabled by default
|
||||
jar_xm_reset(ctxXm); // make sure we start at the beginning of the song
|
||||
jar_xm_reset(ctxXm); // make sure we start at the beginning of the song
|
||||
|
||||
music.ctxData = ctxXm;
|
||||
musicLoaded = true;
|
||||
|
|
@ -1533,7 +1557,7 @@ Music LoadMusicStreamFromMemory(const char *fileType, const unsigned char *data,
|
|||
for (int i = 0; i < it; i++) newData[i] = data[i];
|
||||
|
||||
// Memory loaded version for jar_mod_load_file()
|
||||
if (dataSize && dataSize < 32*1024*1024)
|
||||
if (dataSize && (dataSize < 32*1024*1024))
|
||||
{
|
||||
ctxMod->modfilesize = dataSize;
|
||||
ctxMod->modfile = newData;
|
||||
|
|
@ -2028,22 +2052,86 @@ void SetAudioStreamBufferSizeDefault(int size)
|
|||
AUDIO.Buffer.defaultSize = size;
|
||||
}
|
||||
|
||||
// Audio thread callback to request new data
|
||||
void SetAudioStreamCallback(AudioStream stream, AudioCallback callback)
|
||||
{
|
||||
if (stream.buffer != NULL) stream.buffer->callback = callback;
|
||||
}
|
||||
|
||||
// Add processor to audio stream. Contrary to buffers, the order of processors is important.
|
||||
// The new processor must be added at the end. As there aren't supposed to be a lot of processors attached to
|
||||
// a given stream, we iterate through the list to find the end. That way we don't need a pointer to the last element.
|
||||
void AttachAudioStreamProcessor(AudioStream stream, AudioCallback process)
|
||||
{
|
||||
ma_mutex_lock(&AUDIO.System.lock);
|
||||
|
||||
rAudioProcessor *processor = (rAudioProcessor *)RL_CALLOC(1, sizeof(rAudioProcessor));
|
||||
processor->process = process;
|
||||
|
||||
rAudioProcessor *last = stream.buffer->processor;
|
||||
|
||||
while (last && last->next)
|
||||
{
|
||||
last = last->next;
|
||||
}
|
||||
if (last)
|
||||
{
|
||||
processor->prev = last;
|
||||
last->next = processor;
|
||||
}
|
||||
else stream.buffer->processor = processor;
|
||||
|
||||
ma_mutex_unlock(&AUDIO.System.lock);
|
||||
}
|
||||
|
||||
void DetachAudioStreamProcessor(AudioStream stream, AudioCallback process)
|
||||
{
|
||||
ma_mutex_lock(&AUDIO.System.lock);
|
||||
|
||||
rAudioProcessor *processor = stream.buffer->processor;
|
||||
|
||||
while (processor)
|
||||
{
|
||||
rAudioProcessor *next = processor->next;
|
||||
rAudioProcessor *prev = processor->prev;
|
||||
|
||||
if (processor->process == process)
|
||||
{
|
||||
if (stream.buffer->processor == processor) stream.buffer->processor = next;
|
||||
if (prev) prev->next = next;
|
||||
if (next) next->prev = prev;
|
||||
|
||||
RL_FREE(processor);
|
||||
}
|
||||
|
||||
processor = next;
|
||||
}
|
||||
|
||||
ma_mutex_unlock(&AUDIO.System.lock);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------------
|
||||
// Module specific Functions Definition
|
||||
//----------------------------------------------------------------------------------
|
||||
|
||||
// Log callback function
|
||||
static void OnLog(ma_context *pContext, ma_device *pDevice, ma_uint32 logLevel, const char *message)
|
||||
static void OnLog(void *pUserData, ma_uint32 level, const char *pMessage)
|
||||
{
|
||||
(void)pContext;
|
||||
(void)pDevice;
|
||||
|
||||
TRACELOG(LOG_WARNING, "miniaudio: %s", message); // All log messages from miniaudio are errors
|
||||
TRACELOG(LOG_WARNING, "miniaudio: %s", pMessage); // All log messages from miniaudio are errors
|
||||
}
|
||||
|
||||
// Reads audio data from an AudioBuffer object in internal format.
|
||||
static ma_uint32 ReadAudioBufferFramesInInternalFormat(AudioBuffer *audioBuffer, void *framesOut, ma_uint32 frameCount)
|
||||
{
|
||||
// Using audio buffer callback
|
||||
if (audioBuffer->callback)
|
||||
{
|
||||
audioBuffer->callback(framesOut, frameCount);
|
||||
audioBuffer->framesProcessed += frameCount;
|
||||
|
||||
return frameCount;
|
||||
}
|
||||
|
||||
ma_uint32 subBufferSizeInFrames = (audioBuffer->sizeInFrames > 1)? audioBuffer->sizeInFrames/2 : audioBuffer->sizeInFrames;
|
||||
ma_uint32 currentSubBufferIndex = audioBuffer->frameCursorPos/subBufferSizeInFrames;
|
||||
|
||||
|
|
@ -2055,7 +2143,7 @@ static ma_uint32 ReadAudioBufferFramesInInternalFormat(AudioBuffer *audioBuffer,
|
|||
isSubBufferProcessed[0] = audioBuffer->isSubBufferProcessed[0];
|
||||
isSubBufferProcessed[1] = audioBuffer->isSubBufferProcessed[1];
|
||||
|
||||
ma_uint32 frameSizeInBytes = ma_get_bytes_per_frame(audioBuffer->converter.config.formatIn, audioBuffer->converter.config.channelsIn);
|
||||
ma_uint32 frameSizeInBytes = ma_get_bytes_per_frame(audioBuffer->converter.formatIn, audioBuffer->converter.channelsIn);
|
||||
|
||||
// Fill out every frame until we find a buffer that's marked as processed. Then fill the remainder with 0
|
||||
ma_uint32 framesRead = 0;
|
||||
|
|
@ -2135,20 +2223,21 @@ static ma_uint32 ReadAudioBufferFramesInMixingFormat(AudioBuffer *audioBuffer, f
|
|||
// detail to remember here is that we never, ever attempt to read more input data than is required for the specified number of output
|
||||
// frames. This can be achieved with ma_data_converter_get_required_input_frame_count().
|
||||
ma_uint8 inputBuffer[4096] = { 0 };
|
||||
ma_uint32 inputBufferFrameCap = sizeof(inputBuffer)/ma_get_bytes_per_frame(audioBuffer->converter.config.formatIn, audioBuffer->converter.config.channelsIn);
|
||||
ma_uint32 inputBufferFrameCap = sizeof(inputBuffer)/ma_get_bytes_per_frame(audioBuffer->converter.formatIn, audioBuffer->converter.channelsIn);
|
||||
|
||||
ma_uint32 totalOutputFramesProcessed = 0;
|
||||
while (totalOutputFramesProcessed < frameCount)
|
||||
{
|
||||
ma_uint64 outputFramesToProcessThisIteration = frameCount - totalOutputFramesProcessed;
|
||||
ma_uint64 inputFramesToProcessThisIteration = 0;
|
||||
|
||||
ma_uint64 inputFramesToProcessThisIteration = ma_data_converter_get_required_input_frame_count(&audioBuffer->converter, outputFramesToProcessThisIteration);
|
||||
ma_result result = ma_data_converter_get_required_input_frame_count(&audioBuffer->converter, outputFramesToProcessThisIteration, &inputFramesToProcessThisIteration);
|
||||
if (inputFramesToProcessThisIteration > inputBufferFrameCap)
|
||||
{
|
||||
inputFramesToProcessThisIteration = inputBufferFrameCap;
|
||||
}
|
||||
|
||||
float *runningFramesOut = framesOut + (totalOutputFramesProcessed*audioBuffer->converter.config.channelsOut);
|
||||
float *runningFramesOut = framesOut + (totalOutputFramesProcessed*audioBuffer->converter.channelsOut);
|
||||
|
||||
/* At this point we can convert the data to our mixing format. */
|
||||
ma_uint64 inputFramesProcessedThisIteration = ReadAudioBufferFramesInInternalFormat(audioBuffer, inputBuffer, (ma_uint32)inputFramesToProcessThisIteration); /* Safe cast. */
|
||||
|
|
@ -2217,6 +2306,14 @@ static void OnSendAudioDataToDevice(ma_device *pDevice, void *pFramesOut, const
|
|||
float *framesOut = (float *)pFramesOut + (framesRead*AUDIO.System.device.playback.channels);
|
||||
float *framesIn = tempBuffer;
|
||||
|
||||
// Apply processors chain if defined
|
||||
rAudioProcessor *processor = audioBuffer->processor;
|
||||
while (processor)
|
||||
{
|
||||
processor->process(framesIn, framesJustRead);
|
||||
processor = processor->next;
|
||||
}
|
||||
|
||||
MixAudioFrames(framesOut, framesIn, framesJustRead, audioBuffer);
|
||||
|
||||
framesToRead -= framesJustRead;
|
||||
|
|
@ -2257,41 +2354,44 @@ static void OnSendAudioDataToDevice(ma_device *pDevice, void *pFramesOut, const
|
|||
ma_mutex_unlock(&AUDIO.System.lock);
|
||||
}
|
||||
|
||||
// This is the main mixing function. Mixing is pretty simple in this project - it's just an accumulation.
|
||||
// NOTE: framesOut is both an input and an output. It will be initially filled with zeros outside of this function.
|
||||
// Main mixing function, pretty simple in this project, just an accumulation
|
||||
// NOTE: framesOut is both an input and an output, it is initially filled with zeros outside of this function
|
||||
static void MixAudioFrames(float *framesOut, const float *framesIn, ma_uint32 frameCount, AudioBuffer *buffer)
|
||||
{
|
||||
const float localVolume = buffer->volume;
|
||||
const ma_uint32 channels = AUDIO.System.device.playback.channels;
|
||||
|
||||
const ma_uint32 nChannels = AUDIO.System.device.playback.channels;
|
||||
if (nChannels == 2)
|
||||
if (channels == 2) // We consider panning
|
||||
{
|
||||
const float left = buffer->pan;
|
||||
const float right = 1.0f - left;
|
||||
|
||||
// fast sine approximation in [0..1] for pan law: y = 0.5f * x * (3 - x * x);
|
||||
const float levels[2] = { localVolume*0.5f*left*(3.0f-left*left), localVolume*0.5f*right*(3.0f-right*right) };
|
||||
// Fast sine approximation in [0..1] for pan law: y = 0.5f*x*(3 - x*x);
|
||||
const float levels[2] = { localVolume*0.5f*left*(3.0f - left*left), localVolume*0.5f*right*(3.0f - right*right) };
|
||||
|
||||
float *frameOut = framesOut;
|
||||
const float *frameIn = framesIn;
|
||||
for (ma_uint32 iFrame = 0; iFrame < frameCount; ++iFrame)
|
||||
|
||||
for (ma_uint32 frame = 0; frame < frameCount; frame++)
|
||||
{
|
||||
frameOut[0] += (frameIn[0]*levels[0]);
|
||||
frameOut[1] += (frameIn[1]*levels[1]);
|
||||
|
||||
frameOut += 2;
|
||||
frameIn += 2;
|
||||
}
|
||||
}
|
||||
else // pan is kinda meaningless
|
||||
else // We do not consider panning
|
||||
{
|
||||
for (ma_uint32 iFrame = 0; iFrame < frameCount; ++iFrame)
|
||||
for (ma_uint32 frame = 0; frame < frameCount; frame++)
|
||||
{
|
||||
for (ma_uint32 iChannel = 0; iChannel < nChannels; ++iChannel)
|
||||
for (ma_uint32 c = 0; c < channels; c++)
|
||||
{
|
||||
float *frameOut = framesOut + (iFrame * nChannels);
|
||||
const float *frameIn = framesIn + (iFrame * nChannels);
|
||||
float *frameOut = framesOut + (frame*channels);
|
||||
const float *frameIn = framesIn + (frame*channels);
|
||||
|
||||
frameOut[iChannel] += (frameIn[iChannel] * localVolume);
|
||||
// Output accumulates input multiplied by volume to provided output (usually 0)
|
||||
frameOut[c] += (frameIn[c]*localVolume);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue