pre strip down

1 files changed, 770 insertions, 0 deletions

diff --git a/src/opcodes.cpp b/src/opcodes.cpp
new file mode 100644
index 0000000..4e1265c
--- /dev/null
+++ b/src/opcodes.cpp
@@ -0,0 +1,770 @@
+#include "pmparser.h"
+#include "maketable.hpp"
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+#include <string.h>
+#include <limits.h>
+#include <plugin.h>
+#include <functional>
+#include <vector>
+#include <sys/mman.h>
+
+#ifdef USE_X11
+#include <X11/Xlib.h>
+#include <X11/X.h>
+#include <X11/Xutil.h>
+#endif
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+
+#define PROC_DIR "/proc/"
+
+
+
+struct mempsname : csnd::Plugin<1, 1> {
+    static constexpr char const *otypes = "S";
+    static constexpr char const *itypes = "i";
+    int init() {
+        int pid = inargs[0];
+        char* path = (char*) csound->malloc(sizeof(char) * PATH_MAX);
+        sprintf(path, "%s%d/comm", PROC_DIR, pid);
+        
+        FILE* f = fopen(path, "r");
+        char* buffer = (char*) csound->malloc(sizeof(char) * 1024);
+        size_t size = fread(buffer, sizeof(char), 1024, f);
+
+        
+        fclose(f);
+        STRINGDAT &opath = outargs.str_data(0);
+        opath.size = strlen(buffer); 
+        opath.data = buffer;
+        
+        csound->free(path);
+        return OK;
+    }
+};
+
+
+struct memps : csnd::Plugin<1, 0> {
+    static constexpr char const *otypes = "i[]";
+    static constexpr char const *itypes = "";
+    
+    int init() {
+        
+        int* processes = (int*) csound->malloc(sizeof(int) * 1000);
+        int processnum = 0;
+        if (!getPIDs(processes, &processnum)) {
+            return csound->init_error("Cannot read proc directory");
+        }
+        
+        csnd::Vector<MYFLT> &out = outargs.vector_data<MYFLT>(0);
+        out.init(csound, processnum);
+        
+        for (int i = 0; i < processnum; i++) {
+            out[i] = (MYFLT) processes[i];
+        }
+        csound->free(processes);
+        return OK;
+    }
+    
+    bool isNumeric(char* input) {
+        char* p;
+        strtol(input, &p, 10);
+        return *p == 0;
+    }
+    
+    bool getPIDs(int* processes, int* processnum) { 
+        uid_t thisUser = getuid();
+        DIR* dir = opendir(PROC_DIR);
+
+        struct dirent* de = NULL; 
+        if (dir == NULL) { 
+            //return false; // TODO breaks csound, why??
+        } 
+        char* path = (char*) csound->malloc(sizeof(char) * PATH_MAX);
+        while (NULL != (de = readdir(dir))) {
+            if (de->d_type == DT_DIR) {
+                if (isNumeric(de->d_name)) {
+                    
+                    struct stat fileInfo;
+                    strcpy(path, PROC_DIR);
+                    strcat(path, de->d_name);
+                    if (stat(path, &fileInfo) == 0) {
+                        if (fileInfo.st_uid == thisUser) {
+                            (*processnum)++;
+                            *processes = (int)atoi(de->d_name);
+                            processes++;
+                        }
+                    }
+                }
+            }
+        }
+        csound->free(path);
+        return true;
+    }
+    
+};
+
+
+#ifdef USE_X11
+struct winson : csnd::Plugin<1, 1> {
+    static constexpr char const *otypes = "a";
+    static constexpr char const *itypes = "i";
+    Display* display;
+    Window root;
+    int width;
+    int height;
+    MYFLT* buffer;
+    int buffer_size;
+    int buffer_read_position;
+    int buffer_write_position;
+    
+    int init() {
+        display = XOpenDisplay(NULL);
+        //root = DefaultRootWindow(display);
+        root = 0x2200004;
+        XWindowAttributes gwa;
+        XGetWindowAttributes(display, root, &gwa);
+        
+        width = gwa.width;
+        height = gwa.height;
+        buffer_size = width * height;
+        buffer = (MYFLT*) csound->malloc(sizeof(MYFLT) * buffer_size);
+        buffer_read_position = 0;
+        buffer_write_position = 0;
+        refill_buffer();
+        return OK;
+    }
+    
+    int refill_buffer() {
+        buffer_write_position = 0;
+        XImage* image = XGetImage(display, root, 0, 0, width, height, AllPlanes, ZPixmap);
+        for (int x = 0; x < width; x++) {
+            for (int y=0; y < height; y++) {
+                buffer[buffer_write_position] = ((MYFLT) XGetPixel(image,x,y)) / 16777215;
+                buffer_write_position++;
+            }
+        }
+        return OK;
+    }
+    
+    int aperf() {
+        for (int i = 0; i < nsmps; i++) {
+            outargs(0)[i] = buffer[buffer_read_position];
+            if (LIKELY(buffer_read_position + 1 < buffer_size)) {
+                buffer_read_position++;
+            } else {
+                refill_buffer();
+                buffer_read_position = 0;
+            }
+        }
+            
+        return OK;    
+        
+    }
+};
+#endif
+
+
+class MemLocation {
+public:
+    unsigned long start;
+    unsigned long length;
+    unsigned long* content;  // for mmap test..
+    MemLocation(unsigned long start, unsigned long length) {
+        this->start = start;
+        this->length = length;
+    }
+};
+
+
+class MemParser {
+private:
+    csnd::Csound* csound;
+    int fd_mem;
+    int pid;
+    bool skip_zero;
+    int buffer_write_position;
+    std::vector<MemLocation*> locations;
+    
+    /*
+    void iterate_memory(std::function<void (unsigned long, unsigned long)> func) {
+        procmaps_iterator* maps = pmparser_parse(csound, pid);
+        procmaps_struct* maps_tmp = NULL;
+        while ((maps_tmp = pmparser_next(maps)) != NULL) {
+            if (maps_tmp->is_r && maps_tmp->is_w) {
+                func((unsigned long) maps_tmp->addr_start, (unsigned long) maps_tmp->length);
+            }
+        }
+        pmparser_free(csound, maps);
+    }
+     */
+    
+    bool parsed;
+    void parse_memory() {
+        locations.clear();
+        procmaps_iterator* maps = pmparser_parse(csound, pid);
+        procmaps_struct* maps_tmp = NULL;
+        while ((maps_tmp = pmparser_next(maps)) != NULL) {
+            if (maps_tmp->is_r && maps_tmp->is_w) {
+                locations.push_back(
+                    new MemLocation(
+                        (unsigned long) maps_tmp->addr_start, 
+                        (unsigned long) maps_tmp->length
+                    )
+                );
+                std::cout << (unsigned long) maps_tmp->addr_start << "-" << (unsigned long) maps_tmp->length << "\n";
+            }
+        }
+        pmparser_free(csound, maps);
+        parsed = true;
+    }
+    
+    // this idea ends up with more mem locations than expected, whytf? vector malloc not right with csound???
+    void iterate_memory_step(std::function<bool (long, MYFLT)> func) {
+        if (!parsed) parse_memory();
+        long i;
+        MYFLT val; int x = 0;
+        unsigned long* lbuffer = NULL;
+        std::cout << "sz=" << locations.size() << "\n";
+        for (auto &location : locations) {
+            lbuffer = (unsigned long*) csound->malloc(sizeof(unsigned long) * location->length);
+            lseek(fd_mem, location->start, SEEK_SET);
+            read(fd_mem, lbuffer, location->length);
+            std::cout << (unsigned long) location->start << "-" << (unsigned long) location->length << "\n";
+            for (i = 0; i < location->length; i++) {
+                val = ((MYFLT) lbuffer[i]) / ULONG_MAX;
+                if (!skip_zero || (skip_zero && val > 0)) {
+                    if (!(func(i, val))) goto complete;
+                }
+                
+            }
+
+            if (lbuffer != NULL) {
+                csound->free(lbuffer); // causes segfault, WHY???????????
+                lbuffer = NULL;
+            }
+
+        }
+        complete:
+        if (lbuffer != NULL) {
+            csound->free(lbuffer); // causes segfault, WHY???????????
+            lbuffer = NULL;
+        }
+        
+    }
+    
+    // func arguments: index and value ; return false to stop iteration, true to continue
+    void Xiterate_memory_step(std::function<bool (long, MYFLT)> func) {
+        MYFLT val;
+        unsigned long* lbuffer = NULL;
+        procmaps_iterator* maps = pmparser_parse(csound, pid);
+        procmaps_struct* maps_tmp = NULL;
+        while ((maps_tmp = pmparser_next(maps)) != NULL) {
+            if (maps_tmp->is_r && maps_tmp->is_w) {
+                unsigned long start = (unsigned long) maps_tmp->addr_start;
+                unsigned long length = (unsigned long) maps_tmp->length;
+                lbuffer = (unsigned long*) csound->malloc(sizeof(unsigned long) * length);
+                lseek(fd_mem, start, SEEK_SET);
+                read(fd_mem, lbuffer, length);
+                for (long i = 0; i < length; i++) {
+                    val = ((MYFLT) lbuffer[i]) / ULONG_MAX;
+                    if (!skip_zero || (skip_zero && val > 0)) {
+                        if (!(func(i, val))) goto complete;
+                    }
+                }
+                
+                if (lbuffer != NULL) {
+                    //csound->free(lbuffer); // causes segfault, WHY???????????
+                    //lbuffer = NULL;
+                }
+                
+            }
+        }
+    complete:
+        if (lbuffer != NULL) {
+            csound->free(lbuffer); // causes segfault, WHY???????????
+            lbuffer = NULL;
+        }
+        pmparser_free(csound, maps);
+    }
+    
+public:
+    long total_size;
+    MYFLT* buffer;
+    int buffer_size;
+    
+    MemParser(csnd::Csound* csound, int pid, bool skip_zero) {
+        this->csound = csound;
+        this->skip_zero = skip_zero;
+        this->pid = pid;
+        parsed = false;
+        total_size = 0;
+        buffer = NULL;
+        buffer_size = 0;
+        buffer_write_position = 0;
+        char* mem_path = (char*) csound->malloc(sizeof(char) * 50);
+        sprintf(mem_path, "/proc/%d/mem", pid);
+        fd_mem = open(mem_path, O_RDWR);
+        csound->free(mem_path);
+    }
+    
+    ~MemParser() {
+        close(fd_mem);
+        if (buffer != NULL) {
+            csound->free(buffer);
+        }
+    }
+    
+    void allocate_buffer(int buffer_size) {
+        buffer = (MYFLT*) csound->malloc(sizeof(MYFLT) * buffer_size);
+        this->buffer_size = buffer_size;
+    }
+    
+    long get_size() {
+        total_size = 0;
+        iterate_memory_step(
+            [&](long index, MYFLT val) { 
+                total_size ++;
+                return true;
+            }
+        );
+        return total_size;
+    }
+    
+    
+    int fill_buffer(MYFLT offset) {
+        if (total_size == 0) {
+            total_size = get_size();
+        }
+        buffer_write_position = 0;
+        if (offset > 1) offset = 1;
+        long offset_position = total_size * offset;
+        /*if (UNLIKELY(offset_position > total_size - (buffer_size + 1))) {
+            offset_position = total_size - (buffer_size + 1);
+        }*/
+        bool active;
+        
+        iterate_memory_step(
+            [&](long index, MYFLT val) { 
+                if (index < offset_position) return true;
+                //std::cout << index << "-" << offset_position << "\n";
+                buffer[buffer_write_position] = val;
+                if (buffer_write_position < buffer_size) {
+                    buffer_write_position ++;
+                } else {
+                    buffer_write_position = 0;
+                    return false;
+                }
+                return true;
+            }
+        );
+    }
+    
+    void fill_table(FUNC* table, long length) {
+        long write_index = 0;
+        bool active = true;
+        
+        iterate_memory_step(
+            [&](long index, MYFLT val) { 
+                table->ftable[write_index] = val;
+                write_index ++;
+                return true;
+            }
+        );   
+    }
+     
+};
+
+
+// ifn mem2tab ipid, iskipzero=0
+struct mem2tab : csnd::Plugin<1, 2> {
+    static constexpr char const *otypes = "i";
+    static constexpr char const *itypes = "io";
+
+    int init() {
+        FUNC *table;
+        MemParser* mp = new MemParser(csound, (int)inargs[0], (inargs[1] > 0));
+        
+        long length = mp->get_size();
+        if ((maketable(csound, (int)length, &table, 1)) != OK) {
+            return csound->init_error("Cannot create ftable");
+        }
+        mp->fill_table(table, (int)length); 
+        outargs[0] = table->fno;
+        return OK;
+    }
+};
+
+
+// read memory from a given pid as audio
+// aout memson ipid, koffset, kbuffer_readratio, ibuffersize=441000, iskipzero=0
+struct memson : csnd::Plugin<1, 5> {
+    static constexpr char const *otypes = "a";
+    static constexpr char const *itypes = "ikkjo";
+    MemParser* mp;
+    int buffer_read_position;
+    MYFLT last_offset;
+    
+    int init() {
+        mp = new MemParser(csound, (int)inargs[0], (inargs[4] > 0));
+        mp->allocate_buffer((inargs[2] == -1)? 441000: (int) inargs[3]);
+        
+        buffer_read_position = 0;
+        last_offset = inargs[1];
+        mp->fill_buffer(last_offset);
+        
+        return OK;
+    }
+    
+    int aperf() {
+        for (int i = 0; i < nsmps; i++) {
+            outargs(0)[i] = mp->buffer[buffer_read_position];
+            if (LIKELY(buffer_read_position < mp->buffer_size*inargs[2])) {
+                buffer_read_position++;
+            } else {
+                buffer_read_position = 0;
+            }
+        }
+        if (inargs[1] != last_offset) {
+            last_offset = inargs[1];
+            mp->fill_buffer(last_offset);
+        }
+            
+        return OK;    
+        
+    }
+    
+    
+};
+
+
+
+
+
+typedef struct mmap {
+    unsigned long start;
+    unsigned long length;
+} _mmap;
+
+
+// read memory from a given pid as audio
+// aout memson2 ipid, koffset, kbufsize [, iunsafe]
+// where kbufsize is 0 to 1 and koffset is 0 to 1
+struct memson2 : csnd::Plugin<1, 4> {
+    static constexpr char const *otypes = "a";
+    static constexpr char const *itypes = "ikkj";
+    int pid;
+    int buffer_read_position;
+    int buffer_write_position;
+    int buffer_size;
+    int max_buffer_size;
+    unsigned long total_locations;
+    MYFLT* buffer;
+    MYFLT last_buffer_ratio;
+    MYFLT last_offset;
+    char* mem_path;
+	bool unsafe;
+    
+    int init() {
+        max_buffer_size = 441000;
+        buffer_size = (int) (inargs[2] * max_buffer_size);
+        last_buffer_ratio = inargs[2];
+        last_offset = inargs[1];
+		unsafe = (((int)inargs[3]) == 1);
+        csound->plugin_deinit(this);
+        pid = (int) inargs[0];
+        buffer = (MYFLT*) csound->malloc(sizeof(MYFLT) * max_buffer_size);
+        mem_path = (char*) csound->malloc(sizeof(char) * 50);
+        sprintf(mem_path, "/proc/%d/mem", pid);
+      
+        buffer_read_position = 0;
+        buffer_write_position = 0;
+        total_locations = max_locations();
+        refill_buffer(inargs[1], true);
+        
+        return OK;
+    }
+    
+    int deinit() {
+        csound->free(mem_path);        
+        return OK;
+    }
+    
+    unsigned long max_locations() {
+        procmaps_iterator* maps = pmparser_parse(csound, pid);
+        int fd_mem = open(mem_path, O_RDWR);
+        unsigned long len = 0;
+        procmaps_struct* maps_tmp = NULL;
+        while ((maps_tmp = pmparser_next(maps)) != NULL) {
+            if (maps_tmp->is_r && maps_tmp->is_w) {
+                len += maps_tmp->length;
+            }
+        }
+        pmparser_free(csound, maps);
+        close(fd_mem);
+        return len;
+    }
+    
+    int read_mem(int fd_mem, unsigned long start, unsigned long length) {
+        length = length; // 4; // ??????????????????????????????????????????????????????
+        // lbuffer as unsigned char
+        // https://unix.stackexchange.com/questions/6301/how-do-i-read-from-proc-pid-mem-under-linux
+        unsigned long* lbuffer = (unsigned long*) csound->malloc(sizeof(unsigned long) * length);
+        lseek(fd_mem, start, SEEK_SET);
+        read(fd_mem, lbuffer, length);
+
+        int i;
+        for (i = 0; i < length; i++) {
+            //std::cout << "a " << buffer_write_position << "x " << buffer_size << "\n";
+            MYFLT val = ((MYFLT)lbuffer[i]) / ULONG_MAX;
+            buffer[buffer_write_position] = val;
+            if (buffer_write_position + 1 < buffer_size) {
+                buffer_write_position++;
+            } else {
+                return 1;
+            }
+        }
+        return 0;
+    }
+    
+    
+    int refill_buffer(MYFLT offset, bool first) {
+        buffer_write_position = 0;
+        if (offset > 1) offset = 1;
+        long offset_position = total_locations * offset;
+        if (UNLIKELY(offset_position > total_locations - (buffer_size + 1))) {
+            offset_position = total_locations - (buffer_size + 1);
+        }
+        procmaps_iterator* maps = pmparser_parse(csound, pid);
+        
+        if (maps == NULL) {
+            //csound->message("cannot open maps");
+            return NOTOK; //csound->perf_error("cannot open maps", this->insdshead);
+        }
+        
+        int fd_mem = open(mem_path, O_RDWR);
+        if (fd_mem == -1) {
+            //csound->message("cannot open memory");
+            return NOTOK; 
+        }
+        
+        long position = 0;
+        unsigned long aof = 0;
+        procmaps_struct* maps_tmp = NULL;
+        int res = 0;
+        while ((maps_tmp = pmparser_next(maps)) != NULL) {
+            if (maps_tmp->is_r && maps_tmp->is_w) {
+                if (position >= offset_position) {
+                    aof = position - offset_position; // not quite right, length needs sorting
+                    res = read_mem(fd_mem, ((unsigned long) maps_tmp->addr_start) + aof, (unsigned long) maps_tmp->length);
+                }
+                position += maps_tmp->length;
+                if (res == 1) {
+                    break;
+                }
+            }
+        }
+        pmparser_free(csound, maps);
+        close(fd_mem);
+        return OK;
+    }
+    
+    int aperf() {
+        if (last_offset != inargs[1]  || last_buffer_ratio != inargs[2]) {
+            last_offset = inargs[1];
+            last_buffer_ratio = inargs[2];
+            buffer_size = (int) (inargs[2] * max_buffer_size);
+            refill_buffer(inargs[1], false);
+            buffer_read_position = 0;
+            
+        }
+        for (int i = 0; i < nsmps; i++) {
+            outargs(0)[i] = buffer[buffer_read_position];
+            if (LIKELY(buffer_read_position + 1 < buffer_size)) {
+                buffer_read_position++;
+            } else {
+                refill_buffer(inargs[1], false);
+                buffer_read_position = 0;
+            }
+        }
+            
+        return OK;    
+        
+    }
+    
+    
+};
+
+
+
+
+
+// read memory from a given pid as audio
+struct memson3 : csnd::Plugin<1, 3> {
+    static constexpr char const *otypes = "a";
+    static constexpr char const *itypes = "ikk";
+    int pid;
+    int buffer_read_position;
+    int buffer_write_position;
+    int buffer_size;
+    int max_buffer_size;
+    unsigned long total_locations;
+    MYFLT* buffer;
+    unsigned char* lbuffer;
+    MYFLT last_buffer_ratio;
+    MYFLT last_offset;
+    char* mem_path;
+    
+    int init() {
+        max_buffer_size = 441000;
+        buffer_size = (int) (inargs[2] * max_buffer_size);
+        last_buffer_ratio = inargs[2];
+        last_offset = inargs[1];
+        csound->plugin_deinit(this);
+        pid = (int) inargs[0];
+        buffer = (MYFLT*) csound->malloc(sizeof(MYFLT) * max_buffer_size);
+        lbuffer = (unsigned char*) csound->malloc(sizeof(unsigned char) * max_buffer_size);
+        mem_path = (char*) csound->malloc(sizeof(char) * 50);
+        sprintf(mem_path, "/proc/%d/mem", pid);
+      
+        buffer_read_position = 0;
+        buffer_write_position = 0;
+        total_locations = max_locations();
+        refill_buffer(inargs[1]);
+        
+        return OK;
+    }
+    
+    int deinit() {
+        csound->free(mem_path);        
+        return OK;
+    }
+    
+    unsigned long max_locations() {
+        procmaps_iterator* maps = pmparser_parse(csound, pid);
+        int fd_mem = open(mem_path, O_RDWR);
+        unsigned long len = 0;
+        procmaps_struct* maps_tmp = NULL;
+        while ((maps_tmp = pmparser_next(maps)) != NULL) {
+            if (maps_tmp->is_r && maps_tmp->is_w) {
+                len += maps_tmp->length;
+            }
+        }
+        pmparser_free(csound, maps);
+        close(fd_mem);
+        return len;
+    }
+    
+    int read_mem(int fd_mem, unsigned long start, unsigned long length) {
+        length = length; // 4; // ??????????????????????????????????????????????????????
+        // lbuffer as unsigned char
+        // https://unix.stackexchange.com/questions/6301/how-do-i-read-from-proc-pid-mem-under-linux
+        lseek(fd_mem, start, SEEK_SET);
+        read(fd_mem, lbuffer, length);
+
+        int i;
+        for (i = 0; i < length; i++) {
+            //std::cout << "a " << buffer_write_position << "x " << buffer_size << "\n";
+            MYFLT val = ((MYFLT)lbuffer[i]) / UCHAR_MAX;
+            buffer[buffer_write_position] = val;
+            if (buffer_write_position + 1 < buffer_size) {
+                buffer_write_position++;
+            } else {
+                return 1;
+            }
+        }
+        return 0;
+    }
+    
+    
+    int refill_buffer(MYFLT offset) {
+        buffer_write_position = 0;
+        if (offset > 1) offset = 1;
+        long offset_position = total_locations * offset;
+        if (UNLIKELY(offset_position > total_locations - (buffer_size + 1))) {
+            offset_position = total_locations - (buffer_size + 1);
+        }
+        procmaps_iterator* maps = pmparser_parse(csound, pid);
+        
+        if (maps == NULL) {
+            //csound->message("cannot open maps");
+            return NOTOK; //csound->perf_error("cannot open maps", this->insdshead);
+        }
+        
+        int fd_mem = open(mem_path, O_RDWR);
+        if (fd_mem == -1) {
+            //csound->message("cannot open memory");
+            return NOTOK; 
+        }
+        
+        long position = 0;
+        unsigned long aof = 0;
+        procmaps_struct* maps_tmp = NULL;
+        int res = 0;
+        while ((maps_tmp = pmparser_next(maps)) != NULL) {
+            if (maps_tmp->is_r && maps_tmp->is_w) {
+                if (position >= offset_position) {
+                    aof = position - offset_position; // not quite right, length needs sorting
+                    res = read_mem(fd_mem, ((unsigned long) maps_tmp->addr_start) + aof, (unsigned long) maps_tmp->length);
+                }
+                position += maps_tmp->length;
+                if (res == 1) {
+                    break;
+                }
+            }
+        }
+        pmparser_free(csound, maps);
+        close(fd_mem);
+        return OK;
+    }
+    
+    int aperf() {
+        if (last_offset != inargs[1]  || last_buffer_ratio != inargs[2]) {
+            last_offset = inargs[1];
+            last_buffer_ratio = inargs[2];
+            buffer_size = (int) (inargs[2] * max_buffer_size);
+            refill_buffer(inargs[1]);
+            buffer_read_position = 0;
+            
+        }
+        for (int i = 0; i < nsmps; i++) {
+            outargs(0)[i] = buffer[buffer_read_position];
+            if (LIKELY(buffer_read_position + 1 < buffer_size)) {
+                buffer_read_position++;
+            } else {
+                refill_buffer(inargs[1]);
+                buffer_read_position = 0;
+            }
+        }
+            
+        return OK;    
+        
+    }
+    
+    
+};
+
+
+
+#include <modload.h>
+
+void csnd::on_load(csnd::Csound *csound) {
+    csnd::plugin<memson>(csound, "memson", csnd::thread::ia);
+    csnd::plugin<memson2>(csound, "memson2", csnd::thread::ia);
+    csnd::plugin<memson3>(csound, "memson3", csnd::thread::ia);
+    csnd::plugin<memps>(csound, "memps", csnd::thread::i);
+    csnd::plugin<mempsname>(csound, "mempsname", csnd::thread::i);
+    csnd::plugin<mem2tab>(csound, "mem2tab", csnd::thread::i);
+    
+
+#ifdef USE_X11
+	csnd::plugin<winson>(csound, "winson", csnd::thread::ia);
+#endif
+}
+