pd-flext-dev 0.6.0+git20161101.1.01318a94-2 / usr / include / flext / flstk.h

This file is indexed.

/usr/include/flext/flstk.h is in pd-flext-dev 0.6.0+git20161101.1.01318a94-2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
/*
flext - C++ layer for Max and Pure Data externals

Copyright (c) 2001-2015 Thomas Grill (gr@grrrr.org)
For information on usage and redistribution, and for a DISCLAIMER OF ALL
WARRANTIES, see the file, "license.txt," in this distribution.
*/

#ifndef __FLEXT_STK_H
#define __FLEXT_STK_H

#include "flext.h"

// PI is defined in the Max/MSP SDK, but clashes with Stk.h
#ifdef PI
#undef PI
#endif

#include <Stk.h>

#include "flpushns.h"

using stk::Stk;
using stk::StkFloat;
using stk::StkFrames;
    
class FLEXT_SHARE flext_stk:
    public flext_dsp
{ 
    FLEXT_HEADER(flext_stk,flext_dsp)
 
public:
    flext_stk();

    // these have to be overridden in child classes
    virtual bool NewObjs() { return true; }
    virtual void FreeObjs() {}
    virtual void ProcessObjs(int blocksize) {}

protected:
    virtual bool Init();
    virtual void Exit();

    //! STK object for reading from inlet buffer
    class Input:
        public Stk
    {
    public:
		Input(const t_sample *b,int v): 
		    buf(b),vecsz(v),
		    index(v-1)
		{}

        inline StkFloat lastOut() const { return (StkFloat)buf[index]; }

        inline StkFloat tick() 
        { 
            if(++index >= vecsz) index = 0; 
            return lastOut(); 
        }

        StkFloat *tick(StkFloat *vector,unsigned int vectorSize);
        
        inline StkFrames &tick(StkFrames &vector)
        {
            FLEXT_ASSERT(vector.channels() == 1);
            tick(&vector[0],vector.frames());
            return vector;
        }

        inline void SetBuf(const t_sample *b) { buf = b; }

    private:
        const t_sample *buf;
        int vecsz,index;
    };

    //! STK object for writing to outlet buffer
    class Output:
        public Stk
    {
    public:
		Output(t_sample *b,int v): 
		    buf(b),vecsz(v),
		    index(0)
		{}

        inline void tick(StkFloat s) 
        { 
            buf[index] = (t_sample)s; 
            if(++index >= vecsz) index = 0; 
        }

        void tick(const StkFloat *vector,unsigned int vectorSize);
        
        inline void tick(const StkFrames &vector)
        {
            FLEXT_ASSERT(vector.channels() == 1);
            // dirty casting due to bug in STK api... operator[] _should_ return const StkFloat &
            tick(&const_cast<StkFrames &>(vector)[0],vector.frames());
        }

        inline void SetBuf(t_sample *b) { buf = b; }

    private:
        t_sample *buf;
        int vecsz,index;
    };

    Input &Inlet(int ix) { return *inobj[ix]; }
    Output &Outlet(int ix) { return *outobj[ix]; }

private:
    virtual bool CbDsp(); 
    virtual void CbSignal(); 

    void ClearObjs();

    int inobjs,outobjs;
    Input **inobj;
    Output **outobj;

    float smprt;
    int blsz;
};

#include "flpopns.h"

#ifdef FLEXT_INLINE
#   include "flstk.cpp"
#endif

#endif

APT Browse - Built by Thomas Orozco.