DISTRHO
/
DPF-Max-Gen
mirror of https://github.com/DISTRHO/DPF-Max-Gen
1
0
Fork 0
Code Releases 0 Activity
Browse Source

gen_dsp deleted

pull/1/head
nino de wit 9 years ago
parent
58f89b0f9a
commit
2f64a55677
6 changed files with 0 additions and 1937 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +0
    -362
      plugins/shiroverb/gen_dsp/genlib.cpp
  2. +0
    -152
      plugins/shiroverb/gen_dsp/genlib.h
  3. +0
    -104
      plugins/shiroverb/gen_dsp/genlib_common.h
  4. +0
    -43
      plugins/shiroverb/gen_dsp/genlib_common_win.h
  5. +0
    -38
      plugins/shiroverb/gen_dsp/genlib_exportfunctions.h
  6. +0
    -1238
      plugins/shiroverb/gen_dsp/genlib_ops.h

+ 0
- 362
plugins/shiroverb/gen_dsp/genlib.cpp View File

@@ -1,362 +0,0 @@
/*******************************************************************************************************************
Copyright (c) 2012 Cycling '74

Permission is hereby granted, free of charge, to any person obtaining a copy of this software
and associated documentation files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies
or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************************************************************************/


#include "genlib.h"
#include "genlib_exportfunctions.h"
#include "stdlib.h"
#include "stdio.h"
#include "string.h"
#ifndef GEN_WINDOWS
#include "malloc/malloc.h"
#endif

// DATA_MAXIMUM_ELEMENTS * 8 bytes = 256 mb limit
#define DATA_MAXIMUM_ELEMENTS (33554432)

//////////// export_genlib.cpp ////////////
// export version

void my_memset(void *p, int c, long size);
void my_memcpy(void *dst, const void *src, long size);

t_ptr sysmem_newptr(t_ptr_size size)
{
return (t_ptr)malloc(size);
}

t_ptr sysmem_newptrclear(t_ptr_size size)
{
t_ptr p = (t_ptr)malloc(size);
if (p)
my_memset(p, 0, size);
return p;
}

t_ptr sysmem_resizeptr(void *ptr, t_ptr_size newsize)
{
return (t_ptr)realloc(ptr, newsize);
}

t_ptr sysmem_resizeptrclear(void *ptr, t_ptr_size newsize)
{
long oldsize = malloc_size(ptr);
t_ptr p = (t_ptr)realloc(ptr, newsize);
if (p) {
if (newsize > oldsize)
my_memset((char *)p + oldsize, 0, newsize - oldsize);
}
return p;
}

t_ptr_size sysmem_ptrsize(void *ptr)
{
return malloc_size(ptr);
}

void sysmem_freeptr(void *ptr)
{
free(ptr);
}

void sysmem_copyptr(const void *src, void *dst, t_ptr_size bytes)
{
my_memcpy(dst, src, bytes);
}

void my_memset(void *p, int c, long size)
{
char *p2 = (char *)p;
int i;
for (i = 0; i < size; i++, p2++)
*p2 = c;
}

void my_memcpy(void *dst, const void *src, long size)
{
char *s2 = (char *)src;
char *d2 = (char *)dst;
int i;
for (i = 0; i < size; i++, s2++, d2++)
*d2 = *s2;
}

void set_zero64(double *memory, long size)
{
long i;
for (i = 0; i < size; i++, memory++) {
*memory = 0.;
}
}

void genlib_report_error(const char *s)
{
fprintf(stderr, "%s\n", s);
}

void genlib_report_message(const char *s)
{
fprintf(stdout, "%s\n", s);
}

unsigned long systime_ticks(void)
{
return 0; // Gen code can deal with this
}

// NEED THIS FOR WINDOWS:
void *operator new(size_t size) { return sysmem_newptr(size); }
void operator delete(void *p) { sysmem_freeptr(p); }
void *operator new[](size_t size) { return sysmem_newptr(size); }
void operator delete[](void *p) { sysmem_freeptr(p); }

void * genlib_obtain_reference_from_string(const char * name) {
return 0; // to be implemented
}

// the rest is stuff to isolate gensym, attrs, atoms, buffers etc.
t_genlib_buffer * genlib_obtain_buffer_from_reference(void *ref)
{
return 0; // to be implemented
}

t_genlib_err genlib_buffer_edit_begin(t_genlib_buffer *b)
{
return 0; // to be implemented
}

t_genlib_err genlib_buffer_edit_end(t_genlib_buffer *b, long valid)
{
return 0; // to be implemented
}

t_genlib_err genlib_buffer_getinfo(t_genlib_buffer *b, t_genlib_buffer_info *info)
{
return 0; // to be implemented
}

char *genlib_reference_getname(void *ref)
{
return 0; // to be implemented
}

void genlib_buffer_dirty(t_genlib_buffer *b)
{
// to be implemented
}

t_genlib_err genlib_buffer_perform_begin(t_genlib_buffer *b)
{
return 0; // to be implemented
}
void genlib_buffer_perform_end(t_genlib_buffer *b)
{
// to be implemented
}

#ifdef pow
#undef pow
#endif
#include "math.h"

double gen_msp_pow(double value, double power)
{
return pow(value, power);
}

void genlib_data_setbuffer(t_genlib_data *b, void *ref) {
genlib_report_error("not supported for export targets\n");
}

typedef struct {
t_genlib_data_info info;
double cursor; // used by Delay
//t_symbol * name;
} t_dsp_gen_data;

t_genlib_data * genlib_obtain_data_from_reference(void *ref)
{
t_dsp_gen_data * self = (t_dsp_gen_data *)malloc(sizeof(t_dsp_gen_data));
self->info.dim = 0;
self->info.channels = 0;
self->info.data = 0;
self->cursor = 0;
return (t_genlib_data *)self;
}

t_genlib_err genlib_data_getinfo(t_genlib_data *b, t_genlib_data_info *info) {
t_dsp_gen_data * self = (t_dsp_gen_data *)b;
info->dim = self->info.dim;
info->channels = self->info.channels;
info->data = self->info.data;
return GENLIB_ERR_NONE;
}

void genlib_data_release(t_genlib_data *b) {
t_dsp_gen_data * self = (t_dsp_gen_data *)b;
if (self->info.data) {
genlib_sysmem_freeptr(self->info.data);
self->info.data = 0;
}
}

long genlib_data_getcursor(t_genlib_data *b) {
t_dsp_gen_data * self = (t_dsp_gen_data *)b;
return self->cursor;
}

void genlib_data_setcursor(t_genlib_data *b, long cursor) {
t_dsp_gen_data * self = (t_dsp_gen_data *)b;
self->cursor = cursor;
}

void genlib_data_resize(t_genlib_data *b, long s, long c) {
t_dsp_gen_data * self = (t_dsp_gen_data *)b;
size_t sz, oldsz, copysz;
double * old = 0;
double * replaced = 0;
int i, j, copydim, copychannels, olddim, oldchannels;
//printf("data resize %d %d\n", s, c);
// cache old for copying:
old = self->info.data;
olddim = self->info.dim;
oldchannels = self->info.channels;
// limit [data] size:
if (s * c > DATA_MAXIMUM_ELEMENTS) {
s = DATA_MAXIMUM_ELEMENTS/c;
genlib_report_message("warning: constraining [data] to < 256MB");
}
// bytes required:
sz = sizeof(double) * s * c;
oldsz = sizeof(double) * olddim * oldchannels;
if (old && sz == oldsz) {
// no need to re-allocate, just resize
// careful, audio thread may still be using it:
if (s > olddim) {
self->info.channels = c;
self->info.dim = s;
} else {
self->info.dim = s;
self->info.channels = c;
}
set_zero64(self->info.data, s * c);
return;
} else {
// allocate new:
replaced = (double *)sysmem_newptr(sz);
// check allocation:
if (replaced == 0) {
genlib_report_error("allocating [data]: out of memory");
// try to reallocate with a default/minimal size instead:
if (s > 512 || c > 1) {
genlib_data_resize((t_genlib_data *)self, 512, 1);
} else {
// if this fails, then Max is kaput anyway...
genlib_data_resize((t_genlib_data *)self, 4, 1);
}
return;
}
// fill with zeroes:
set_zero64(replaced, s * c);
// copy in old data:
if (old) {
// frames to copy:
// clamped:
copydim = olddim > s ? s : olddim;
// use memcpy if channels haven't changed:
if (c == oldchannels) {
copysz = sizeof(double) * copydim * c;
//post("reset resize (same channels) %p %p, %d", self->info.data, old, copysz);
memcpy(replaced, old, copysz);
} else {
// memcpy won't work if channels have changed,
// because data is interleaved.
// clamp channels copied:
copychannels = oldchannels > c ? c : oldchannels;
//post("reset resize (different channels) %p %p, %d %d", self->info.data, old, copydim, copychannels);
for (i = 0; i<copydim; i++) {
for (j = 0; j<copychannels; j++) {
replaced[j + i*c] = old[j + i*oldchannels];
}
}
}
}
// now update info:
if (old == 0) {
self->info.data = replaced;
self->info.dim = s;
self->info.channels = c;
} else {
// need to be careful; the audio thread may still be using it
// since dsp_gen_data is preserved through edits
// the order of resizing has to be carefully done
// to prevent indexing out of bounds
// (or maybe I'm being too paranoid here...)
if (oldsz > sz) {
// shrink size first
if (s > olddim) {
self->info.channels = c;
self->info.dim = s;
} else {
self->info.dim = s;
self->info.channels = c;
}
self->info.data = replaced;
} else {
// shrink size after
self->info.data = replaced;
if (s > olddim) {
self->info.channels = c;
self->info.dim = s;
} else {
self->info.dim = s;
self->info.channels = c;
}
}
// done with old:
sysmem_freeptr(old);
}
}
}

void genlib_reset_complete(void *data) {}



+ 0
- 152
plugins/shiroverb/gen_dsp/genlib.h View File

@@ -1,152 +0,0 @@
/*******************************************************************************************************************
Copyright (c) 2012 Cycling '74

Permission is hereby granted, free of charge, to any person obtaining a copy of this software
and associated documentation files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies
or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************************************************************************/


#ifndef GENLIB_H
#define GENLIB_H 1

#include "genlib_common.h"

//////////// genlib.h ////////////
// genlib.h -- max (gen~) version

#ifndef GEN_WINDOWS
#ifndef _SIZE_T
#define _SIZE_T
typedef __typeof__(sizeof(int)) size_t;
#endif
#endif

#ifndef __INT32_TYPE__
#define __INT32_TYPE__ int
#endif

#ifdef MSP_ON_CLANG
// gen~ hosted:
typedef unsigned __INT32_TYPE__ uint32_t;
typedef unsigned __INT64_TYPE__ uint64_t;
#else
#ifdef __GNUC__
#include <stdint.h>
#endif
#endif

#define inf (__DBL_MAX__)
#define GEN_UINT_MAX (4294967295)
#define TWO_TO_32 (4294967296.0)

#define C74_CONST const

// max_types.h:
#ifdef C74_X64
typedef unsigned long long t_ptr_uint;
typedef long long t_ptr_int;
typedef double t_atom_float;
typedef t_ptr_uint t_getbytes_size;
#else
typedef unsigned long t_ptr_uint;
typedef long t_ptr_int;
typedef float t_atom_float;
typedef short t_getbytes_size;
#endif

typedef uint32_t t_uint32;
typedef t_ptr_int t_atom_long; // the type that is an A_LONG in an atom

typedef t_ptr_int t_int; ///< an integer @ingroup misc
typedef t_ptr_uint t_ptr_size; ///< unsigned pointer-sized value for counting (like size_t) @ingroup misc
typedef t_ptr_int t_atom_long; ///< the type that is an A_LONG in a #t_atom @ingroup misc
typedef t_atom_long t_max_err; ///< an integer value suitable to be returned as an error code @ingroup misc

extern "C" {

// TODO: remove (for debugging only)
//int printf(const char * fmt, ...);
// math.h:
extern double acos( double );
extern double asin( double );
extern double atan( double );
extern double atan2( double, double );
extern double cos( double );
extern double sin( double );
extern double tan( double );
extern double acosh( double );
extern double asinh( double );
extern double atanh( double );
extern double cosh( double );
extern double sinh( double );
extern double tanh( double );
extern double exp ( double );
extern double log ( double );
extern double log10 ( double );
extern double fmod ( double, double );
extern double modf(double, double *);
extern double fabs( double );
extern double hypot ( double, double );
//extern double pow ( double, double );
extern double gen_msp_pow ( double, double );
#define pow gen_msp_pow
extern double sqrt( double );
extern double ceil ( double );
extern double floor ( double );
extern double round ( double );
extern int abs(int);
extern char *strcpy(char *, const char *);
// string reference handling:
void * genlib_obtain_reference_from_string(const char * name);
char *genlib_reference_getname(void *ref);
// buffer handling:
t_genlib_buffer *genlib_obtain_buffer_from_reference(void *ref);
t_genlib_err genlib_buffer_edit_begin(t_genlib_buffer *b);
t_genlib_err genlib_buffer_edit_end(t_genlib_buffer *b, long valid);
t_genlib_err genlib_buffer_getinfo(t_genlib_buffer *b, t_genlib_buffer_info *info);
void genlib_buffer_dirty(t_genlib_buffer *b);
t_genlib_err genlib_buffer_perform_begin(t_genlib_buffer *b);
void genlib_buffer_perform_end(t_genlib_buffer *b);
// data handling:
t_genlib_data *genlib_obtain_data_from_reference(void *ref);
t_genlib_err genlib_data_getinfo(t_genlib_data *b, t_genlib_data_info *info);
void genlib_data_resize(t_genlib_data *b, long dim, long channels);
void genlib_data_setbuffer(t_genlib_data *b, void *ref);
void genlib_data_release(t_genlib_data *b);
void genlib_data_setcursor(t_genlib_data *b, long cursor);
long genlib_data_getcursor(t_genlib_data *b);
// other notification:
void genlib_reset_complete(void *data);

}; // extern "C"
#define genlib_sysmem_newptr(s) sysmem_newptr(s)
#define genlib_sysmem_newptrclear(s) sysmem_newptrclear(s)
#define genlib_sysmem_resizeptr(p, s) sysmem_resizeptr(p, s)
#define genlib_sysmem_resizeptrclear(p, s) sysmem_resizeptrclear(p, s)
#define genlib_sysmem_ptrsize(p) sysmem_ptrsize(p)
#define genlib_sysmem_freeptr(p) sysmem_freeptr(p)
#define genlib_sysmem_copyptr(s, d, b) sysmem_copyptr(s, d, b)
#define genlib_set_zero64(d, n) set_zero64(d, n)
#define genlib_ticks systime_ticks

#endif // GENLIB_H

+ 0
- 104
plugins/shiroverb/gen_dsp/genlib_common.h View File

@@ -1,104 +0,0 @@
/*******************************************************************************************************************
Copyright (c) 2012 Cycling '74

Permission is hereby granted, free of charge, to any person obtaining a copy of this software
and associated documentation files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies
or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************************************************************************/


#ifndef GENLIB_COMMON_H
#define GENLIB_COMMON_H 1

#include "genlib_common_win.h"

//////////// genlib_common.h ////////////
// common data structure header file -- this is the stuff required by the
// common code and accessed by the export and max code
#define DSP_GEN_MAX_SIGNALS 16

typedef double t_sample;
typedef char *t_ptr;
typedef long t_genlib_err;
typedef enum {
GENLIB_ERR_NONE = 0, ///< No error
GENLIB_ERR_GENERIC = -1, ///< Generic error
GENLIB_ERR_INVALID_PTR = -2, ///< Invalid Pointer
GENLIB_ERR_DUPLICATE = -3, ///< Duplicate
GENLIB_ERR_OUT_OF_MEM = -4, ///< Out of memory
GENLIB_ERR_LOOP_OVERFLOW = 100, // too many iterations of loops in perform()
GENLIB_ERR_NULL_BUFFER = 101 // missing signal data in perform()
} e_genlib_errorcodes;

typedef enum {
GENLIB_PARAMTYPE_FLOAT = 0,
GENLIB_PARAMTYPE_SYM = 1
} e_genlib_paramtypes;

struct ParamInfo
{
double defaultvalue;
void * defaultref;
char hasinputminmax;
char hasminmax;
double inputmin, inputmax;
double outputmin, outputmax;
const char *name;
const char *units;
int paramtype; // 0 -> float64, 1 -> symbol (table name)
double exp; // future, for scaling
};

struct CommonState
{
double sr;
int vs;
int numins;
int numouts;
const char **inputnames;
const char **outputnames;
int numparams;
ParamInfo *params;
void * parammap; // implementation-dependent
void * api; // implementation-dependent
};

// opaque interface to float32 buffer:
typedef struct _genlib_buffer t_genlib_buffer;
typedef struct {
char b_name[256]; ///< name of the buffer
float *b_samples; ///< stored with interleaved channels if multi-channel
long b_frames; ///< number of sample frames (each one is sizeof(float) * b_nchans bytes)
long b_nchans; ///< number of channels
long b_size; ///< size of buffer in floats
float b_sr; ///< sampling rate of the buffer
long b_modtime; ///< last modified time ("dirty" method)
long b_rfu[57]; ///< reserved for future use
} t_genlib_buffer_info;

// opaque interface to float64 buffer:
typedef struct _genlib_data t_genlib_data;
typedef struct {
int dim, channels;
double * data;
} t_genlib_data_info;

#endif // GENLIB_COMMON_H



+ 0
- 43
plugins/shiroverb/gen_dsp/genlib_common_win.h View File

@@ -1,43 +0,0 @@
/*******************************************************************************************************************
Copyright (c) 2012 Cycling '74

Permission is hereby granted, free of charge, to any person obtaining a copy of this software
and associated documentation files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies
or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************************************************************************/

#ifndef GENLIB_COMMON_WIN_H
#define GENLIB_COMMON_WIN_H

#ifdef _MSC_VER
#define GEN_WINDOWS
#endif

#ifdef GEN_WINDOWS

#include <malloc.h>
#include <limits>

typedef __int32 int32_t;
typedef unsigned __int32 uint32_t;
typedef __int64 int64_t;
typedef unsigned __int64 uint64_t;
#define malloc_size _msize
#define __DBL_EPSILON__ (DBL_EPSILON)

#endif

#endif


+ 0
- 38
plugins/shiroverb/gen_dsp/genlib_exportfunctions.h View File

@@ -1,38 +0,0 @@
/*******************************************************************************************************************
Copyright (c) 2012 Cycling '74

Permission is hereby granted, free of charge, to any person obtaining a copy of this software
and associated documentation files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies
or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*******************************************************************************************************************/

#ifndef GENLIB_EXPORT_FUNCTIONS_H
#define GENLIB_EXPORT_FUNCTIONS_H 1

typedef char *t_ptr;

t_ptr sysmem_newptr(t_ptr_size size);
t_ptr sysmem_newptrclear(t_ptr_size size);
t_ptr sysmem_resizeptr(void *ptr, t_ptr_size newsize);
t_ptr sysmem_resizeptrclear(void *ptr, t_ptr_size newsize);
t_ptr_size sysmem_ptrsize(void *ptr);
void sysmem_freeptr(void *ptr);
void sysmem_copyptr(const void *src, void *dst, t_ptr_size bytes);
unsigned long systime_ticks(void);

void genlib_report_error(const char *s);
void genlib_report_message(const char *s);
void set_zero64(double *mem, long size);

#endif // GENLIB_EXPORT_FUNCTIONS_H

+ 0
- 1238
plugins/shiroverb/gen_dsp/genlib_ops.h
File diff suppressed because it is too large
View File


Write Preview
Loading…
Cancel
Save