BEAST - Free Software Audio Synthesizer and Tracker  0.10.0
bseprobe.genidl.hh
Go to the documentation of this file.
1 
2 /*-------- begin ../sfi/sfidl generated code --------*/
3 
4 
5 
6 #include <bse/effectbase.hh>
7 
8 
9 /* enum prototypes */
10 
11 
12 /* choice prototypes */
13 
14 
15 /* record prototypes */
16 namespace Bse {
17 class ProbeFeatures;
18 typedef Sfi::RecordHandle<ProbeFeatures> ProbeFeaturesHandle;
19 #define BSE_TYPE_PROBE_FEATURES BSE_CXX_DECLARED_RECORD_TYPE (Bse, ProbeFeatures)
20 class Probe;
21 typedef Sfi::RecordHandle<Probe> ProbeHandle;
22 #define BSE_TYPE_PROBE BSE_CXX_DECLARED_RECORD_TYPE (Bse, Probe)
23 class ProbeRequest;
24 typedef Sfi::RecordHandle<ProbeRequest> ProbeRequestHandle;
25 #define BSE_TYPE_PROBE_REQUEST BSE_CXX_DECLARED_RECORD_TYPE (Bse, ProbeRequest)
26 
27 
28 /* sequence prototypes */
29 class ProbeSeq;
30 #define BSE_TYPE_PROBE_SEQ BSE_CXX_DECLARED_SEQUENCE_TYPE (Bse, ProbeSeq)
31 class ProbeRequestSeq;
32 #define BSE_TYPE_PROBE_REQUEST_SEQ BSE_CXX_DECLARED_SEQUENCE_TYPE (Bse, ProbeRequestSeq)
33 
34 
35 /* class prototypes */
36 
37 
38 /* enum definitions */
39 
40 
41 /* sequence definitions */
42 class ProbeSeq : public Sfi::Sequence< ::Bse::ProbeHandle > {
43 public:
44  ProbeSeq (unsigned int n = 0) : Sfi::Sequence< ::Bse::ProbeHandle > (n) {}
45  static inline ::Bse::ProbeSeq from_seq (SfiSeq *seq);
46  static inline SfiSeq *to_seq (const ::Bse::ProbeSeq & seq);
47  static inline ::Bse::ProbeSeq value_get_boxed (const GValue *value);
48  static inline void value_set_boxed (GValue *value, const ::Bse::ProbeSeq & self);
49  static inline const char* options () { return ""; }
50  static inline const char* blurb () { return ""; }
51  static inline const char* authors () { return ""; }
52  static inline const char* license () { return ""; }
53  static inline const char* type_name () { return "BseProbeSeq"; }
54  static inline GParamSpec* get_element ();
55 };
56 
57 class ProbeRequestSeq : public Sfi::Sequence< ::Bse::ProbeRequestHandle > {
58 public:
60  static inline ::Bse::ProbeRequestSeq from_seq (SfiSeq *seq);
61  static inline SfiSeq *to_seq (const ::Bse::ProbeRequestSeq & seq);
62  static inline ::Bse::ProbeRequestSeq value_get_boxed (const GValue *value);
63  static inline void value_set_boxed (GValue *value, const ::Bse::ProbeRequestSeq & self);
64  static inline const char* options () { return ""; }
65  static inline const char* blurb () { return ""; }
66  static inline const char* authors () { return ""; }
67  static inline const char* license () { return ""; }
68  static inline const char* type_name () { return "BseProbeRequestSeq"; }
69  static inline GParamSpec* get_element ();
70 };
71 
72 
73 
74 /* record definitions */
76 public:
77  bool probe_range;
78  bool probe_energie;
79  bool probe_samples;
80  bool probe_fft;
81  static inline ::Bse::ProbeFeaturesHandle from_rec (SfiRec *rec);
82  static inline SfiRec *to_rec (const ::Bse::ProbeFeaturesHandle & ptr);
83  static inline ::Bse::ProbeFeaturesHandle value_get_boxed (const GValue *value);
84  static inline void value_set_boxed (GValue *value, const ::Bse::ProbeFeaturesHandle & self);
85  static inline const char* options () { return ""; }
86  static inline const char* blurb () { return ""; }
87  static inline const char* authors () { return ""; }
88  static inline const char* license () { return ""; }
89  static inline const char* type_name () { return "BseProbeFeatures"; }
90  static inline SfiRecFields get_fields ();
91 };
92 
93 class Probe : public ::Sfi::GNewable {
94 public:
95  Sfi::Int channel_id;
96  Sfi::Num block_stamp;
97  Sfi::Real mix_freq;
98  ::Bse::ProbeFeaturesHandle probe_features;
99  Sfi::Real min;
100  Sfi::Real max;
101  Sfi::Real energie;
102  ::Bse::FloatSeq sample_data;
103  ::Bse::FloatSeq fft_data;
104  static inline ::Bse::ProbeHandle from_rec (SfiRec *rec);
105  static inline SfiRec *to_rec (const ::Bse::ProbeHandle & ptr);
106  static inline ::Bse::ProbeHandle value_get_boxed (const GValue *value);
107  static inline void value_set_boxed (GValue *value, const ::Bse::ProbeHandle & self);
108  static inline const char* options () { return ""; }
109  static inline const char* blurb () { return ""; }
110  static inline const char* authors () { return ""; }
111  static inline const char* license () { return ""; }
112  static inline const char* type_name () { return "BseProbe"; }
113  static inline SfiRecFields get_fields ();
114 };
115 
117 public:
118  BseSource* source;
119  Sfi::Int channel_id;
120  Sfi::Real frequency;
121  ::Bse::ProbeFeaturesHandle probe_features;
122  static inline ::Bse::ProbeRequestHandle from_rec (SfiRec *rec);
123  static inline SfiRec *to_rec (const ::Bse::ProbeRequestHandle & ptr);
124  static inline ::Bse::ProbeRequestHandle value_get_boxed (const GValue *value);
125  static inline void value_set_boxed (GValue *value, const ::Bse::ProbeRequestHandle & self);
126  static inline const char* options () { return ""; }
127  static inline const char* blurb () { return ""; }
128  static inline const char* authors () { return ""; }
129  static inline const char* license () { return ""; }
130  static inline const char* type_name () { return "BseProbeRequest"; }
131  static inline SfiRecFields get_fields ();
132 };
133 
134 
135 
136 /* enum declarations */
137 
138 
139 /* sequence type declarations */
140 BSE_CXX_DECLARE_SEQUENCE (ProbeSeq);
141 
142 BSE_CXX_DECLARE_SEQUENCE (ProbeRequestSeq);
143 
144 
145 
146 /* record type declarations */
147 BSE_CXX_DECLARE_RECORD (ProbeFeatures);
148 
149 BSE_CXX_DECLARE_RECORD (Probe);
150 
151 BSE_CXX_DECLARE_RECORD (ProbeRequest);
152 
153 
154 
155 /* procedure prototypes */
156 namespace Procedure {
157 class source_request_probes;
158 #define BSE_TYPE_SOURCE_REQUEST_PROBES BSE_CXX_DECLARED_PROC_TYPE (Bse, source_request_probes)
159 } // Procedure
160 
161 namespace Procedure {
162 class source_mass_request;
163 #define BSE_TYPE_SOURCE_MASS_REQUEST BSE_CXX_DECLARED_PROC_TYPE (Bse, source_mass_request)
164 } // Procedure
165 
166 namespace Procedure {
167 class source_get_mix_freq;
168 #define BSE_TYPE_SOURCE_GET_MIX_FREQ BSE_CXX_DECLARED_PROC_TYPE (Bse, source_get_mix_freq)
169 } // Procedure
170 
171 
172 
173 /* class definitions */
174 
175 
176 /* choice implementations */
177 
178 
179 /* record implementations */
181 ProbeFeatures::from_rec (SfiRec *sfi_rec)
182 {
183  GValue *element;
184 
185  if (!sfi_rec)
186  return Sfi::INIT_NULL;
187 
188  ::Bse::ProbeFeaturesHandle rec = Sfi::INIT_DEFAULT;
189  element = sfi_rec_get (sfi_rec, "probe_range");
190  if (element)
191  rec->probe_range = sfi_value_get_bool (element);
192  element = sfi_rec_get (sfi_rec, "probe_energie");
193  if (element)
194  rec->probe_energie = sfi_value_get_bool (element);
195  element = sfi_rec_get (sfi_rec, "probe_samples");
196  if (element)
197  rec->probe_samples = sfi_value_get_bool (element);
198  element = sfi_rec_get (sfi_rec, "probe_fft");
199  if (element)
200  rec->probe_fft = sfi_value_get_bool (element);
201  return rec;
202 }
203 
204 SfiRec *
205 ProbeFeatures::to_rec (const ::Bse::ProbeFeaturesHandle & rec)
206 {
207  SfiRec *sfi_rec;
208  GValue *element;
209 
210  if (!rec)
211  return NULL;
212 
213  sfi_rec = sfi_rec_new ();
214  element = sfi_rec_forced_get (sfi_rec, "probe_range", SFI_TYPE_BOOL);
215  sfi_value_set_bool (element, rec->probe_range);
216  element = sfi_rec_forced_get (sfi_rec, "probe_energie", SFI_TYPE_BOOL);
217  sfi_value_set_bool (element, rec->probe_energie);
218  element = sfi_rec_forced_get (sfi_rec, "probe_samples", SFI_TYPE_BOOL);
219  sfi_value_set_bool (element, rec->probe_samples);
220  element = sfi_rec_forced_get (sfi_rec, "probe_fft", SFI_TYPE_BOOL);
221  sfi_value_set_bool (element, rec->probe_fft);
222  return sfi_rec;
223 }
224 
226 ProbeFeatures::value_get_boxed (const GValue *value)
227 {
228  return ::Bse::ProbeFeaturesHandle::value_get_boxed (value);
229 }
230 
231 void
232 ProbeFeatures::value_set_boxed (GValue *value, const ::Bse::ProbeFeaturesHandle & self)
233 {
234  ::Bse::ProbeFeaturesHandle::value_set_boxed (value, self);
235 }
236 
238 ProbeFeatures::get_fields()
239 {
240  static SfiRecFields rfields = { 0, NULL };
241  if (!rfields.n_fields)
242  {
243  static GParamSpec *fields[4 + 1];
244  rfields.n_fields = 4;
245  fields[0] = sfidl_pspec_Bool_default (NULL,"/opt/src/beast/bse/bseprobe.idl",378,"probe_range");
246  fields[1] = sfidl_pspec_Bool_default (NULL,"/opt/src/beast/bse/bseprobe.idl",379,"probe_energie");
247  fields[2] = sfidl_pspec_Bool_default (NULL,"/opt/src/beast/bse/bseprobe.idl",380,"probe_samples");
248  fields[3] = sfidl_pspec_Bool_default (NULL,"/opt/src/beast/bse/bseprobe.idl",381,"probe_fft");
249  rfields.fields = fields;
250  }
251  return rfields;
252 }
254 Probe::from_rec (SfiRec *sfi_rec)
255 {
256  GValue *element;
257 
258  if (!sfi_rec)
259  return Sfi::INIT_NULL;
260 
261  ::Bse::ProbeHandle rec = Sfi::INIT_DEFAULT;
262  element = sfi_rec_get (sfi_rec, "channel_id");
263  if (element)
264  rec->channel_id = sfi_value_get_int (element);
265  element = sfi_rec_get (sfi_rec, "block_stamp");
266  if (element)
267  rec->block_stamp = sfi_value_get_num (element);
268  element = sfi_rec_get (sfi_rec, "mix_freq");
269  if (element)
270  rec->mix_freq = sfi_value_get_real (element);
271  element = sfi_rec_get (sfi_rec, "probe_features");
272  if (element)
273  rec->probe_features = ::Bse::ProbeFeatures::value_get_boxed (element);
274  element = sfi_rec_get (sfi_rec, "min");
275  if (element)
276  rec->min = sfi_value_get_real (element);
277  element = sfi_rec_get (sfi_rec, "max");
278  if (element)
279  rec->max = sfi_value_get_real (element);
280  element = sfi_rec_get (sfi_rec, "energie");
281  if (element)
282  rec->energie = sfi_value_get_real (element);
283  element = sfi_rec_get (sfi_rec, "sample_data");
284  if (element)
285  rec->sample_data = ::Bse::FloatSeq::value_get_boxed (element);
286  element = sfi_rec_get (sfi_rec, "fft_data");
287  if (element)
288  rec->fft_data = ::Bse::FloatSeq::value_get_boxed (element);
289  return rec;
290 }
291 
292 SfiRec *
293 Probe::to_rec (const ::Bse::ProbeHandle & rec)
294 {
295  SfiRec *sfi_rec;
296  GValue *element;
297 
298  if (!rec)
299  return NULL;
300 
301  sfi_rec = sfi_rec_new ();
302  element = sfi_rec_forced_get (sfi_rec, "channel_id", SFI_TYPE_INT);
303  sfi_value_set_int (element, rec->channel_id);
304  element = sfi_rec_forced_get (sfi_rec, "block_stamp", SFI_TYPE_NUM);
305  sfi_value_set_num (element, rec->block_stamp);
306  element = sfi_rec_forced_get (sfi_rec, "mix_freq", SFI_TYPE_REAL);
307  sfi_value_set_real (element, rec->mix_freq);
308  element = sfi_rec_forced_get (sfi_rec, "probe_features", SFI_TYPE_REC);
309  ::Bse::ProbeFeatures::value_set_boxed (element, rec->probe_features);
310  element = sfi_rec_forced_get (sfi_rec, "min", SFI_TYPE_REAL);
311  sfi_value_set_real (element, rec->min);
312  element = sfi_rec_forced_get (sfi_rec, "max", SFI_TYPE_REAL);
313  sfi_value_set_real (element, rec->max);
314  element = sfi_rec_forced_get (sfi_rec, "energie", SFI_TYPE_REAL);
315  sfi_value_set_real (element, rec->energie);
316  element = sfi_rec_forced_get (sfi_rec, "sample_data", SFI_TYPE_SEQ);
317  ::Bse::FloatSeq::value_set_boxed (element, rec->sample_data);
318  element = sfi_rec_forced_get (sfi_rec, "fft_data", SFI_TYPE_SEQ);
319  ::Bse::FloatSeq::value_set_boxed (element, rec->fft_data);
320  return sfi_rec;
321 }
322 
324 Probe::value_get_boxed (const GValue *value)
325 {
326  return ::Bse::ProbeHandle::value_get_boxed (value);
327 }
328 
329 void
330 Probe::value_set_boxed (GValue *value, const ::Bse::ProbeHandle & self)
331 {
332  ::Bse::ProbeHandle::value_set_boxed (value, self);
333 }
334 
336 Probe::get_fields()
337 {
338  static SfiRecFields rfields = { 0, NULL };
339  if (!rfields.n_fields)
340  {
341  static GParamSpec *fields[9 + 1];
342  rfields.n_fields = 9;
343  fields[0] = sfidl_pspec_Int_default (NULL,"/opt/src/beast/bse/bseprobe.idl",385,"channel_id");
344  fields[1] = sfidl_pspec_Num_default (NULL,"/opt/src/beast/bse/bseprobe.idl",386,"block_stamp");
345  fields[2] = sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bseprobe.idl",387,"mix_freq");
346  fields[3] = sfidl_pspec_Record_default (NULL,"/opt/src/beast/bse/bseprobe.idl",388, "probe_features", Bse::ProbeFeatures::get_fields());
347  fields[4] = sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bseprobe.idl",389,"min");
348  fields[5] = sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bseprobe.idl",390,"max");
349  fields[6] = sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bseprobe.idl",391,"energie");
350  fields[7] = sfidl_pspec_Sequence_default (NULL,"/opt/src/beast/bse/bseprobe.idl",392, "sample_data", Bse::FloatSeq::get_element());
351  fields[8] = sfidl_pspec_Sequence_default (NULL,"/opt/src/beast/bse/bseprobe.idl",393, "fft_data", Bse::FloatSeq::get_element());
352  rfields.fields = fields;
353  }
354  return rfields;
355 }
357 ProbeRequest::from_rec (SfiRec *sfi_rec)
358 {
359  GValue *element;
360 
361  if (!sfi_rec)
362  return Sfi::INIT_NULL;
363 
364  ::Bse::ProbeRequestHandle rec = Sfi::INIT_DEFAULT;
365  element = sfi_rec_get (sfi_rec, "source");
366  if (element)
367  rec->source = ::Bse::CxxBase::value_get_gobject< BseSource> (element);
368  element = sfi_rec_get (sfi_rec, "channel_id");
369  if (element)
370  rec->channel_id = sfi_value_get_int (element);
371  element = sfi_rec_get (sfi_rec, "frequency");
372  if (element)
373  rec->frequency = sfi_value_get_real (element);
374  element = sfi_rec_get (sfi_rec, "probe_features");
375  if (element)
376  rec->probe_features = ::Bse::ProbeFeatures::value_get_boxed (element);
377  return rec;
378 }
379 
380 SfiRec *
381 ProbeRequest::to_rec (const ::Bse::ProbeRequestHandle & rec)
382 {
383  SfiRec *sfi_rec;
384  GValue *element;
385 
386  if (!rec)
387  return NULL;
388 
389  sfi_rec = sfi_rec_new ();
390  element = sfi_rec_forced_get (sfi_rec, "source", SFI_TYPE_PROXY);
391  ::Bse::CxxBase::value_set_gobject (element, rec->source);
392  element = sfi_rec_forced_get (sfi_rec, "channel_id", SFI_TYPE_INT);
393  sfi_value_set_int (element, rec->channel_id);
394  element = sfi_rec_forced_get (sfi_rec, "frequency", SFI_TYPE_REAL);
395  sfi_value_set_real (element, rec->frequency);
396  element = sfi_rec_forced_get (sfi_rec, "probe_features", SFI_TYPE_REC);
397  ::Bse::ProbeFeatures::value_set_boxed (element, rec->probe_features);
398  return sfi_rec;
399 }
400 
402 ProbeRequest::value_get_boxed (const GValue *value)
403 {
404  return ::Bse::ProbeRequestHandle::value_get_boxed (value);
405 }
406 
407 void
408 ProbeRequest::value_set_boxed (GValue *value, const ::Bse::ProbeRequestHandle & self)
409 {
410  ::Bse::ProbeRequestHandle::value_set_boxed (value, self);
411 }
412 
414 ProbeRequest::get_fields()
415 {
416  static SfiRecFields rfields = { 0, NULL };
417  if (!rfields.n_fields)
418  {
419  static GParamSpec *fields[4 + 1];
420  rfields.n_fields = 4;
421  fields[0] = sfidl_pspec_Object_default (NULL,"/opt/src/beast/bse/bseprobe.idl",400,"source");
422  fields[1] = sfidl_pspec_Int_default (NULL,"/opt/src/beast/bse/bseprobe.idl",401,"channel_id");
423  fields[2] = sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bseprobe.idl",402,"frequency");
424  fields[3] = sfidl_pspec_Record_default (NULL,"/opt/src/beast/bse/bseprobe.idl",403, "probe_features", Bse::ProbeFeatures::get_fields());
425  rfields.fields = fields;
426  }
427  return rfields;
428 }
429 
430 
431 /* sequence implementations */
433 ProbeSeq::from_seq (SfiSeq *sfi_seq)
434 {
435  ::Bse::ProbeSeq cseq;
436  guint i, length;
437 
438  if (!sfi_seq)
439  return cseq;
440 
441  length = sfi_seq_length (sfi_seq);
442  cseq.resize (length);
443  for (i = 0; i < length; i++)
444  {
445  GValue *element = sfi_seq_get (sfi_seq, i);
446  cseq[i] = ::Bse::Probe::value_get_boxed (element);
447  }
448  return cseq;
449 }
450 
451 SfiSeq *
452 ProbeSeq::to_seq (const ::Bse::ProbeSeq & cseq)
453 {
454  SfiSeq *sfi_seq = sfi_seq_new ();
455  for (guint i = 0; i < cseq.length(); i++)
456  {
457  GValue *element = sfi_seq_append_empty (sfi_seq, SFI_TYPE_REC);
458  ::Bse::Probe::value_set_boxed (element, cseq[i]);
459  }
460  return sfi_seq;
461 }
462 
464 ProbeSeq::value_get_boxed (const GValue *value)
465 {
466  return ::Sfi::cxx_value_get_boxed_sequence< ProbeSeq> (value);
467 }
468 
469 void
470 ProbeSeq::value_set_boxed (GValue *value, const ::Bse::ProbeSeq & self)
471 {
472  ::Sfi::cxx_value_set_boxed_sequence< ProbeSeq> (value, self);
473 }
474 
475 GParamSpec*
476 ProbeSeq::get_element()
477 {
478  static GParamSpec *element = NULL;
479  if (!element) {
480  element = g_param_spec_ref (sfidl_pspec_Record_default (NULL,"/opt/src/beast/bse/bseprobe.idl",396, "probes", Bse::Probe::get_fields()));
481  g_param_spec_sink (element);
482  }
483  return element;
484 }
485 
487 ProbeRequestSeq::from_seq (SfiSeq *sfi_seq)
488 {
490  guint i, length;
491 
492  if (!sfi_seq)
493  return cseq;
494 
495  length = sfi_seq_length (sfi_seq);
496  cseq.resize (length);
497  for (i = 0; i < length; i++)
498  {
499  GValue *element = sfi_seq_get (sfi_seq, i);
500  cseq[i] = ::Bse::ProbeRequest::value_get_boxed (element);
501  }
502  return cseq;
503 }
504 
505 SfiSeq *
506 ProbeRequestSeq::to_seq (const ::Bse::ProbeRequestSeq & cseq)
507 {
508  SfiSeq *sfi_seq = sfi_seq_new ();
509  for (guint i = 0; i < cseq.length(); i++)
510  {
511  GValue *element = sfi_seq_append_empty (sfi_seq, SFI_TYPE_REC);
512  ::Bse::ProbeRequest::value_set_boxed (element, cseq[i]);
513  }
514  return sfi_seq;
515 }
516 
518 ProbeRequestSeq::value_get_boxed (const GValue *value)
519 {
520  return ::Sfi::cxx_value_get_boxed_sequence< ProbeRequestSeq> (value);
521 }
522 
523 void
524 ProbeRequestSeq::value_set_boxed (GValue *value, const ::Bse::ProbeRequestSeq & self)
525 {
526  ::Sfi::cxx_value_set_boxed_sequence< ProbeRequestSeq> (value, self);
527 }
528 
529 GParamSpec*
530 ProbeRequestSeq::get_element()
531 {
532  static GParamSpec *element = NULL;
533  if (!element) {
534  element = g_param_spec_ref (sfidl_pspec_Record_default (NULL,"/opt/src/beast/bse/bseprobe.idl",406, "probe_requests", Bse::ProbeRequest::get_fields()));
535  g_param_spec_sink (element);
536  }
537  return element;
538 }
539 
540 
541 
542 /* class implementations */
543 
544 
545 /* procedure implementations */
546 namespace Procedure {
547 BSE_CXX_DECLARE_PROC (source_request_probes);
549 public:
550  static inline const unsigned char* pixstream () { return NULL; }
551  static inline const char* options () { return ""; }
552  static inline const char* category () { static const char *c = NULL;
553  return c ? c : c = sfi_category_concat ("/Proc", ""); }
554  static inline const char* i18n_category () { static const char *c = NULL;
555  return c ? c : c = sfi_category_concat ("/Proc", ""); }
556  static inline const char* blurb () { return ""; }
557  static inline const char* authors () { return ""; }
558  static inline const char* license () { return ""; }
559  static inline const char* type_name () { return "bse-source-request-probes"; }
560  static void exec (BseSource* source, Sfi::Int ochannel_id, const ::Bse::ProbeFeaturesHandle & probe_features);
561  static Bse::Error marshal (BseProcedureClass *procedure,
562  const GValue *in_values,
563  GValue *out_values)
564  {
565  try {
566  exec (
567  ::Bse::CxxBase::value_get_gobject< BseSource> (in_values + 0),
568  sfi_value_get_int (in_values + 1),
569  ::Bse::ProbeFeatures::value_get_boxed (in_values + 2)
570  );
571  } catch (std::exception &e) {
572  sfi_diag ("%s: %s", "source_request_probes", e.what());
573  return Bse::Error::PROC_EXECUTION;
574  } catch (...) {
575  sfi_diag ("%s: %s", "source_request_probes", "uncaught exception");
576  return Bse::Error::PROC_EXECUTION;
577  }
578  return Bse::Error::NONE;
579  }
580  static void init (BseProcedureClass *proc,
581  GParamSpec **in_pspecs,
582  GParamSpec **out_pspecs)
583  {
584  *(in_pspecs++) = sfidl_pspec_TypedObject_default (NULL,"/opt/src/beast/bse/bseprobe.idl",-1106920381, "source", BSE_TYPE_SOURCE);
585  *(in_pspecs++) = sfidl_pspec_Int_default (NULL,"/opt/src/beast/bse/bseprobe.idl",-1106920381,"ochannel_id");
586  *(in_pspecs++) = sfidl_pspec_BoxedRec_default (NULL,"/opt/src/beast/bse/bseprobe.idl",-1106920381, "probe_features", BSE_TYPE_PROBE_FEATURES);
587  }
588 };
589 } // Procedure
590 
591 namespace Procedure {
592 BSE_CXX_DECLARE_PROC (source_mass_request);
594 public:
595  static inline const unsigned char* pixstream () { return NULL; }
596  static inline const char* options () { return ""; }
597  static inline const char* category () { static const char *c = NULL;
598  return c ? c : c = sfi_category_concat ("/Proc", ""); }
599  static inline const char* i18n_category () { static const char *c = NULL;
600  return c ? c : c = sfi_category_concat ("/Proc", ""); }
601  static inline const char* blurb () { return ""; }
602  static inline const char* authors () { return ""; }
603  static inline const char* license () { return ""; }
604  static inline const char* type_name () { return "bse-source-mass-request"; }
605  static void exec (const ::Bse::ProbeRequestSeq & prseq);
606  static Bse::Error marshal (BseProcedureClass *procedure,
607  const GValue *in_values,
608  GValue *out_values)
609  {
610  try {
611  exec (
612  ::Bse::ProbeRequestSeq::value_get_boxed (in_values + 0)
613  );
614  } catch (std::exception &e) {
615  sfi_diag ("%s: %s", "source_mass_request", e.what());
616  return Bse::Error::PROC_EXECUTION;
617  } catch (...) {
618  sfi_diag ("%s: %s", "source_mass_request", "uncaught exception");
619  return Bse::Error::PROC_EXECUTION;
620  }
621  return Bse::Error::NONE;
622  }
623  static void init (BseProcedureClass *proc,
624  GParamSpec **in_pspecs,
625  GParamSpec **out_pspecs)
626  {
627  *(in_pspecs++) = sfidl_pspec_BoxedSeq_default (NULL,"/opt/src/beast/bse/bseprobe.idl",-1106920381, "prseq", BSE_TYPE_PROBE_REQUEST_SEQ);
628  }
629 };
630 } // Procedure
631 
632 namespace Procedure {
633 BSE_CXX_DECLARE_PROC (source_get_mix_freq);
635 public:
636  static inline const unsigned char* pixstream () { return NULL; }
637  static inline const char* options () { return ""; }
638  static inline const char* category () { static const char *c = NULL;
639  return c ? c : c = sfi_category_concat ("/Proc", ""); }
640  static inline const char* i18n_category () { static const char *c = NULL;
641  return c ? c : c = sfi_category_concat ("/Proc", ""); }
642  static inline const char* blurb () { return ""; }
643  static inline const char* authors () { return ""; }
644  static inline const char* license () { return ""; }
645  static inline const char* type_name () { return "bse-source-get-mix-freq"; }
646  static Sfi::Int exec (BseSource* obj);
647  static Bse::Error marshal (BseProcedureClass *procedure,
648  const GValue *in_values,
649  GValue *out_values)
650  {
651  try {
652  Sfi::Int __return_value =
653  exec (
654  ::Bse::CxxBase::value_get_gobject< BseSource> (in_values + 0)
655  );
656  sfi_value_set_int (out_values, __return_value);
657  } catch (std::exception &e) {
658  sfi_diag ("%s: %s", "source_get_mix_freq", e.what());
659  return Bse::Error::PROC_EXECUTION;
660  } catch (...) {
661  sfi_diag ("%s: %s", "source_get_mix_freq", "uncaught exception");
662  return Bse::Error::PROC_EXECUTION;
663  }
664  return Bse::Error::NONE;
665  }
666  static void init (BseProcedureClass *proc,
667  GParamSpec **in_pspecs,
668  GParamSpec **out_pspecs)
669  {
670  *(in_pspecs++) = sfidl_pspec_TypedObject_default (NULL,"/opt/src/beast/bse/bseprobe.idl",-1106920381, "obj", BSE_TYPE_SOURCE);
671  *(out_pspecs++) = sfidl_pspec_Int_default (NULL,"/opt/src/beast/bse/bseprobe.idl",23656460,"result");
672  }
673 };
674 } // Procedure
675 
676 
677 
678 /* bseprobe.idl type registrations */
679 #define BSE_CXX_REGISTER_ALL_TYPES_FROM_BSEPROBE_IDL() \
680  BSE_CXX_REGISTER_RECORD (ProbeFeatures); \
681  BSE_CXX_REGISTER_RECORD (Probe); \
682  BSE_CXX_REGISTER_RECORD (ProbeRequest); \
683  BSE_CXX_REGISTER_SEQUENCE (ProbeSeq); \
684  BSE_CXX_REGISTER_SEQUENCE (ProbeRequestSeq); \
685  BSE_CXX_REGISTER_PROCEDURE (source_request_probes); \
686  BSE_CXX_REGISTER_PROCEDURE (source_mass_request); \
687  BSE_CXX_REGISTER_PROCEDURE (source_get_mix_freq); \
688  /* bseprobe.idl type registrations done */
689 } // Bse
690 
691 /*-------- end ../sfi/sfidl generated code --------*/
692 
693 
Definition: bseprobe.genidl.hh:42
Definition: bseprobe.genidl.hh:75
The Bse namespace contains all functions of the synthesis engine.
Definition: bstbseutils.cc:88
Definition: bseprobe.genidl.hh:593
Definition: bseprobe.genidl.hh:116
Definition: bseprobe.genidl.hh:57
T what(T...args)
Definition: sficxx.hh:326
Definition: bseprobe.genidl.hh:634
STL class.
Definition: sfitypes.hh:31
Definition: bseprobe.genidl.hh:93
Definition: bsesource.hh:84
Definition: bseprobe.genidl.hh:548
Definition: sficxx.hh:143
Definition: bsebasics.genidl.hh:265