Jamoma API  0.6.0.a19
j.stencil.cpp
Go to the documentation of this file.
1 /** @file
2  *
3  * @ingroup implementationMaxExternalsJitter
4  *
5  * @brief j.stencil% : Perform operations on a stencil of points in a matrix
6  *
7  * @details This is the actual Jitter object
8  *
9  * @authors Tim Place, Trond Lossius
10  *
11  * @copyright © 2011 by Timothy Place @n
12  * This code is licensed under the terms of the "New BSD License" @n
13  * http://creativecommons.org/licenses/BSD/
14  */
15 
16 
17 #include "jit.common.h"
18 #include "TTClassWrapperMax.h"
19 
20 
21 // types and structures
22 typedef struct _j_stencil {
23  t_object obj;
24  TTMatrixPtr x; // Jamoma matrix object for input
25  TTMatrixPtr y; // Jamoma matrix object for output
26  TTDataObjectBasePtr stencilObject; // Jamoma object performing matrix operations
27 } StencilObject;
28 
29 typedef StencilObject* StencilObjectPtr;
30 
31 
32 // method prototypes
33 t_jit_err StencilClassInit (void);
34 StencilObjectPtr StencilNew (void);
35 void StencilFree (StencilObjectPtr self);
36 t_jit_err StencilMatrixCalc (StencilObjectPtr self, void *inputs, void *outputs);
37 t_jit_err StencilGetStepSize (StencilObjectPtr self, Ptr attr, AtomCount* ac, AtomPtr* av);
38 t_jit_err StencilSetStepSize (StencilObjectPtr self, Ptr attr, AtomCount ac, AtomPtr av);
39 t_jit_err StencilGetEdges (StencilObjectPtr self, Ptr attr, AtomCount* ac, AtomPtr* av);
40 t_jit_err StencilSetEdges (StencilObjectPtr self, Ptr attr, AtomCount ac, AtomPtr av);
41 
42 
43 // globals
44 static ClassPtr sStencilClass = NULL;
45 
46 
47 /************************************************************************************/
48 
49 t_jit_err StencilClassInit(void)
50 {
51  long attrflags = 0;// = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
52  t_jit_object *attr;
53  t_jit_object *mop;
54 
55  sStencilClass = (ClassPtr)jit_class_new((char*)"j_stencil", (method)StencilNew, (method)StencilFree, sizeof(StencilObject), 0);
56 
57  // add matrix operator (mop)
58  mop = (t_jit_object*)jit_object_new(_jit_sym_jit_mop, 1, 1); // args are num inputs and num outputs
59  jit_class_addadornment(sStencilClass, mop);
60 
61  // add method(s)
62  jit_class_addmethod(sStencilClass, (method)StencilMatrixCalc, (char*)"matrix_calc", A_CANT, 0);
63 
64  // add attribute(s)
65  attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset_array,
66  "stepSize",
67  _jit_sym_long,
68  JIT_MATRIX_MAX_PLANECOUNT,
69  attrflags,
70  (method)StencilGetStepSize, (method)StencilSetStepSize,
71  NULL, NULL);
72  jit_class_addattr(sStencilClass, attr);
73 
74  attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset,
75  "edges",
76  _jit_sym_symbol,
77  attrflags,
78  (method)StencilGetEdges, (method)StencilSetEdges,
79  NULL);
80  jit_class_addattr(sStencilClass, attr);
81 
82 
83  // finalize class
84  jit_class_register(sStencilClass);
85  return JIT_ERR_NONE;
86 }
87 
88 
89 /************************************************************************************/
90 // Object Life Cycle
91 
92 StencilObjectPtr StencilNew(void)
93 {
94  StencilObjectPtr self = (StencilObjectPtr)jit_object_alloc(sStencilClass);
95  TTErr err;
96  TTValue none;
97 
98  if (self) {
99  err = TTObjectBaseInstantiate(kTTSym_matrix, (TTObjectBasePtr*)&self->x, none);
100  err = TTObjectBaseInstantiate(kTTSym_matrix, (TTObjectBasePtr*)&self->y, none);
101  err = TTObjectBaseInstantiate(TT("matrix.stencil"), (TTObjectBasePtr*)&self->stencilObject, none);
102  }
103  return self;
104 }
105 
106 
107 void StencilFree(StencilObjectPtr self)
108 {
109  TTErr err;
110 
111  err = TTObjectBaseRelease((TTObjectBasePtr*)&self->x);
112  err = TTObjectBaseRelease((TTObjectBasePtr*)&self->y);
113  err = TTObjectBaseRelease((TTObjectBasePtr*)&self->stencilObject);
114 }
115 
116 
117 /************************************************************************************/
118 // Methods bound to input/inlets
119 
120 t_jit_err StencilMatrixCalc(StencilObjectPtr self, void *inputs, void *outputs)
121 {
122  t_jit_err err = JIT_ERR_NONE;
123  long in_savelock;
124  long out_savelock;
125  void *in_matrix;
126  void *out_matrix;
127 
128  in_matrix = jit_object_method(inputs,_jit_sym_getindex,0);
129  out_matrix = jit_object_method(outputs,_jit_sym_getindex,0);
130 
131  if (self && in_matrix && out_matrix) {
132  in_savelock = TTMatrixReferenceJitterMatrix(self->x, in_matrix);
133  out_savelock = TTMatrixReferenceJitterMatrix(self->y, out_matrix);
134 
135  TTMatrixCopyDataFromJitterMatrix(self->x, in_matrix);
136  self->stencilObject->calculate(self->x, self->y);
137  TTMatrixCopyDataToJitterMatrix(self->y, out_matrix);
138 
139  jit_object_method(out_matrix, _jit_sym_lock, out_savelock);
140  jit_object_method(in_matrix, _jit_sym_lock, in_savelock);
141  }
142  else
143  return JIT_ERR_INVALID_PTR;
144 
145  return err;
146 }
147 
148 
149 /************************************************************************************/
150 // Attribute Accessors
151 
152 t_jit_err StencilGetStepSize(StencilObjectPtr self, Ptr attr, AtomCount* ac, AtomPtr* av)
153 {
154  TTValue v;
155 
156  if (*ac && *av) {
157  ; // memory passed-in, use it
158  }
159  else {
160  *av = (AtomPtr)sysmem_newptr(sizeof(Atom)*2);
161  }
162  *ac = 2;
163 
164  self->stencilObject->getAttributeValue(TT("stepSize"), v);
165  for (AtomCount k=0; k < *ac; k++) {
166  TTInt32 step;
167 
168  v.get(k, step);
169  atom_setlong((*av)+k, step);
170  }
171  return JIT_ERR_NONE;
172 }
173 
174 
175 t_jit_err StencilSetStepSize(StencilObjectPtr self, Ptr attr, AtomCount ac, AtomPtr av)
176 {
177  TTValue v;
178 
179  v.setSize(ac);
180  for (AtomCount k=0; k<ac; k++)
181  v.set(k, (int)atom_getlong(av+k));
182 
183  self->stencilObject->setAttributeValue(TT("stepSize"), v);
184  return JIT_ERR_NONE;
185 }
186 
187 
188 t_jit_err StencilGetEdges(StencilObjectPtr self, Ptr attr, AtomCount* ac, AtomPtr* av)
189 {
190  TTValue v;
191  TTSymbol s;
192 
193  if (*ac && *av) {
194  ; // memory passed-in, use it
195  }
196  else {
197  *av = (AtomPtr)sysmem_newptr(sizeof(Atom));
198  }
199  *ac = 1;
200 
201  self->stencilObject->getAttributeValue(TT("edges"), v);
202  v.get(0, s);
203  atom_setsym(*av, gensym(s.c_str()));
204  return JIT_ERR_NONE;
205 }
206 
207 
208 t_jit_err StencilSetEdges(StencilObjectPtr self, Ptr attr, AtomCount ac, AtomPtr av)
209 {
210  self->stencilObject->setAttributeValue(TT("edges"), TT(atom_getsym(av)->s_name));
211  return JIT_ERR_NONE;
212 }
213 
TTErr TTObjectBaseRelease(TTObjectBasePtr *anObject)
DEPRECATED.
TTDataObjectBase is the base class for all data generating and processing objects.
Base class for all first-class Jamoma objects.
Definition: TTObjectBase.h:109
#define TT
This macro is defined as a shortcut for doing a lookup in the symbol table.
Definition: TTSymbol.h:155
void setSize(const TTUInt16 arg)
DEPRECATED.
Definition: TTValue.h:528
The TTSymbol class is used to represent a string and efficiently pass and compare that string...
Definition: TTSymbol.h:26
TTErr TTObjectBaseInstantiate(const TTSymbol className, TTObjectBasePtr *returnedObjectPtr, const TTValue arguments)
DEPRECATED.
void get(const TTUInt16 index, T &returnedElementValue) const
DEPRECATED.
Definition: TTValue.h:591
const char * c_str() const
Return a pointer to the internal string as a C-string.
Definition: TTSymbol.h:77
std::int32_t TTInt32
32 bit signed integer
Definition: TTBase.h:177
void set(const TTUInt16 index, const T &anElementValue)
DEPRECATED.
Definition: TTValue.h:569
TTErr
Jamoma Error Codes Enumeration of error codes that might be returned by any of the TTBlue functions a...
Definition: TTBase.h:342
[doxygenAppendixC_copyExample]
Definition: TTValue.h:34