BEAST/BSE - Better Audio System and Sound Engine  0.9.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
bseprobe.genidl.hh
Go to the documentation of this file.
1 
2 /*-------- begin ../sfi/sfidl generated code --------*/
3 
4 
5 
6 #include <bse/bse-internals.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_tick_stamp;
168 #define BSE_TYPE_SOURCE_GET_TICK_STAMP BSE_CXX_DECLARED_PROC_TYPE (Bse, source_get_tick_stamp)
169 } // Procedure
170 
171 namespace Procedure {
172 class source_get_mix_freq;
173 #define BSE_TYPE_SOURCE_GET_MIX_FREQ BSE_CXX_DECLARED_PROC_TYPE (Bse, source_get_mix_freq)
174 } // Procedure
175 
176 
177 
178 /* class definitions */
179 
180 
181 /* choice implementations */
182 
183 
184 /* record implementations */
186 ProbeFeatures::from_rec (SfiRec *sfi_rec)
187 {
188  GValue *element;
189 
190  if (!sfi_rec)
191  return Sfi::INIT_NULL;
192 
193  ::Bse::ProbeFeaturesHandle rec = Sfi::INIT_DEFAULT;
194  element = sfi_rec_get (sfi_rec, "probe_range");
195  if (element)
196  rec->probe_range = sfi_value_get_bool (element);
197  element = sfi_rec_get (sfi_rec, "probe_energie");
198  if (element)
199  rec->probe_energie = sfi_value_get_bool (element);
200  element = sfi_rec_get (sfi_rec, "probe_samples");
201  if (element)
202  rec->probe_samples = sfi_value_get_bool (element);
203  element = sfi_rec_get (sfi_rec, "probe_fft");
204  if (element)
205  rec->probe_fft = sfi_value_get_bool (element);
206  return rec;
207 }
208 
209 SfiRec *
210 ProbeFeatures::to_rec (const ::Bse::ProbeFeaturesHandle & rec)
211 {
212  SfiRec *sfi_rec;
213  GValue *element;
214 
215  if (!rec)
216  return NULL;
217 
218  sfi_rec = sfi_rec_new ();
219  element = sfi_rec_forced_get (sfi_rec, "probe_range", SFI_TYPE_BOOL);
220  sfi_value_set_bool (element, rec->probe_range);
221  element = sfi_rec_forced_get (sfi_rec, "probe_energie", SFI_TYPE_BOOL);
222  sfi_value_set_bool (element, rec->probe_energie);
223  element = sfi_rec_forced_get (sfi_rec, "probe_samples", SFI_TYPE_BOOL);
224  sfi_value_set_bool (element, rec->probe_samples);
225  element = sfi_rec_forced_get (sfi_rec, "probe_fft", SFI_TYPE_BOOL);
226  sfi_value_set_bool (element, rec->probe_fft);
227  return sfi_rec;
228 }
229 
231 ProbeFeatures::value_get_boxed (const GValue *value)
232 {
233  return ::Bse::ProbeFeaturesHandle::value_get_boxed (value);
234 }
235 
236 void
237 ProbeFeatures::value_set_boxed (GValue *value, const ::Bse::ProbeFeaturesHandle & self)
238 {
239  ::Bse::ProbeFeaturesHandle::value_set_boxed (value, self);
240 }
241 
243 ProbeFeatures::get_fields()
244 {
245  static SfiRecFields rfields = { 0, NULL };
246  if (!rfields.n_fields)
247  {
248  static GParamSpec *fields[4 + 1];
249  rfields.n_fields = 4;
250  fields[0] = sfidl_pspec_Bool_default (NULL,"/opt/src/beast/bse/bseprobe.idl",739,"probe_range");
251  fields[1] = sfidl_pspec_Bool_default (NULL,"/opt/src/beast/bse/bseprobe.idl",740,"probe_energie");
252  fields[2] = sfidl_pspec_Bool_default (NULL,"/opt/src/beast/bse/bseprobe.idl",741,"probe_samples");
253  fields[3] = sfidl_pspec_Bool_default (NULL,"/opt/src/beast/bse/bseprobe.idl",742,"probe_fft");
254  rfields.fields = fields;
255  }
256  return rfields;
257 }
259 Probe::from_rec (SfiRec *sfi_rec)
260 {
261  GValue *element;
262 
263  if (!sfi_rec)
264  return Sfi::INIT_NULL;
265 
266  ::Bse::ProbeHandle rec = Sfi::INIT_DEFAULT;
267  element = sfi_rec_get (sfi_rec, "channel_id");
268  if (element)
269  rec->channel_id = sfi_value_get_int (element);
270  element = sfi_rec_get (sfi_rec, "block_stamp");
271  if (element)
272  rec->block_stamp = sfi_value_get_num (element);
273  element = sfi_rec_get (sfi_rec, "mix_freq");
274  if (element)
275  rec->mix_freq = sfi_value_get_real (element);
276  element = sfi_rec_get (sfi_rec, "probe_features");
277  if (element)
278  rec->probe_features = ::Bse::ProbeFeatures::value_get_boxed (element);
279  element = sfi_rec_get (sfi_rec, "min");
280  if (element)
281  rec->min = sfi_value_get_real (element);
282  element = sfi_rec_get (sfi_rec, "max");
283  if (element)
284  rec->max = sfi_value_get_real (element);
285  element = sfi_rec_get (sfi_rec, "energie");
286  if (element)
287  rec->energie = sfi_value_get_real (element);
288  element = sfi_rec_get (sfi_rec, "sample_data");
289  if (element)
290  rec->sample_data = ::Bse::FloatSeq::value_get_boxed (element);
291  element = sfi_rec_get (sfi_rec, "fft_data");
292  if (element)
293  rec->fft_data = ::Bse::FloatSeq::value_get_boxed (element);
294  return rec;
295 }
296 
297 SfiRec *
298 Probe::to_rec (const ::Bse::ProbeHandle & rec)
299 {
300  SfiRec *sfi_rec;
301  GValue *element;
302 
303  if (!rec)
304  return NULL;
305 
306  sfi_rec = sfi_rec_new ();
307  element = sfi_rec_forced_get (sfi_rec, "channel_id", SFI_TYPE_INT);
308  sfi_value_set_int (element, rec->channel_id);
309  element = sfi_rec_forced_get (sfi_rec, "block_stamp", SFI_TYPE_NUM);
310  sfi_value_set_num (element, rec->block_stamp);
311  element = sfi_rec_forced_get (sfi_rec, "mix_freq", SFI_TYPE_REAL);
312  sfi_value_set_real (element, rec->mix_freq);
313  element = sfi_rec_forced_get (sfi_rec, "probe_features", SFI_TYPE_REC);
314  ::Bse::ProbeFeatures::value_set_boxed (element, rec->probe_features);
315  element = sfi_rec_forced_get (sfi_rec, "min", SFI_TYPE_REAL);
316  sfi_value_set_real (element, rec->min);
317  element = sfi_rec_forced_get (sfi_rec, "max", SFI_TYPE_REAL);
318  sfi_value_set_real (element, rec->max);
319  element = sfi_rec_forced_get (sfi_rec, "energie", SFI_TYPE_REAL);
320  sfi_value_set_real (element, rec->energie);
321  element = sfi_rec_forced_get (sfi_rec, "sample_data", SFI_TYPE_SEQ);
322  ::Bse::FloatSeq::value_set_boxed (element, rec->sample_data);
323  element = sfi_rec_forced_get (sfi_rec, "fft_data", SFI_TYPE_SEQ);
324  ::Bse::FloatSeq::value_set_boxed (element, rec->fft_data);
325  return sfi_rec;
326 }
327 
329 Probe::value_get_boxed (const GValue *value)
330 {
331  return ::Bse::ProbeHandle::value_get_boxed (value);
332 }
333 
334 void
335 Probe::value_set_boxed (GValue *value, const ::Bse::ProbeHandle & self)
336 {
337  ::Bse::ProbeHandle::value_set_boxed (value, self);
338 }
339 
341 Probe::get_fields()
342 {
343  static SfiRecFields rfields = { 0, NULL };
344  if (!rfields.n_fields)
345  {
346  static GParamSpec *fields[9 + 1];
347  rfields.n_fields = 9;
348  fields[0] = sfidl_pspec_Int_default (NULL,"/opt/src/beast/bse/bseprobe.idl",746,"channel_id");
349  fields[1] = sfidl_pspec_Num_default (NULL,"/opt/src/beast/bse/bseprobe.idl",747,"block_stamp");
350  fields[2] = sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bseprobe.idl",748,"mix_freq");
351  fields[3] = sfidl_pspec_Record_default (NULL,"/opt/src/beast/bse/bseprobe.idl",749, "probe_features", Bse::ProbeFeatures::get_fields());
352  fields[4] = sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bseprobe.idl",750,"min");
353  fields[5] = sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bseprobe.idl",751,"max");
354  fields[6] = sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bseprobe.idl",752,"energie");
355  fields[7] = sfidl_pspec_Sequence_default (NULL,"/opt/src/beast/bse/bseprobe.idl",753, "sample_data", Bse::FloatSeq::get_element());
356  fields[8] = sfidl_pspec_Sequence_default (NULL,"/opt/src/beast/bse/bseprobe.idl",754, "fft_data", Bse::FloatSeq::get_element());
357  rfields.fields = fields;
358  }
359  return rfields;
360 }
362 ProbeRequest::from_rec (SfiRec *sfi_rec)
363 {
364  GValue *element;
365 
366  if (!sfi_rec)
367  return Sfi::INIT_NULL;
368 
369  ::Bse::ProbeRequestHandle rec = Sfi::INIT_DEFAULT;
370  element = sfi_rec_get (sfi_rec, "source");
371  if (element)
372  rec->source = ::Bse::CxxBase::value_get_gobject< BseSource> (element);
373  element = sfi_rec_get (sfi_rec, "channel_id");
374  if (element)
375  rec->channel_id = sfi_value_get_int (element);
376  element = sfi_rec_get (sfi_rec, "frequency");
377  if (element)
378  rec->frequency = sfi_value_get_real (element);
379  element = sfi_rec_get (sfi_rec, "probe_features");
380  if (element)
381  rec->probe_features = ::Bse::ProbeFeatures::value_get_boxed (element);
382  return rec;
383 }
384 
385 SfiRec *
386 ProbeRequest::to_rec (const ::Bse::ProbeRequestHandle & rec)
387 {
388  SfiRec *sfi_rec;
389  GValue *element;
390 
391  if (!rec)
392  return NULL;
393 
394  sfi_rec = sfi_rec_new ();
395  element = sfi_rec_forced_get (sfi_rec, "source", SFI_TYPE_PROXY);
396  ::Bse::CxxBase::value_set_gobject (element, rec->source);
397  element = sfi_rec_forced_get (sfi_rec, "channel_id", SFI_TYPE_INT);
398  sfi_value_set_int (element, rec->channel_id);
399  element = sfi_rec_forced_get (sfi_rec, "frequency", SFI_TYPE_REAL);
400  sfi_value_set_real (element, rec->frequency);
401  element = sfi_rec_forced_get (sfi_rec, "probe_features", SFI_TYPE_REC);
402  ::Bse::ProbeFeatures::value_set_boxed (element, rec->probe_features);
403  return sfi_rec;
404 }
405 
407 ProbeRequest::value_get_boxed (const GValue *value)
408 {
409  return ::Bse::ProbeRequestHandle::value_get_boxed (value);
410 }
411 
412 void
413 ProbeRequest::value_set_boxed (GValue *value, const ::Bse::ProbeRequestHandle & self)
414 {
415  ::Bse::ProbeRequestHandle::value_set_boxed (value, self);
416 }
417 
419 ProbeRequest::get_fields()
420 {
421  static SfiRecFields rfields = { 0, NULL };
422  if (!rfields.n_fields)
423  {
424  static GParamSpec *fields[4 + 1];
425  rfields.n_fields = 4;
426  fields[0] = sfidl_pspec_Object_default (NULL,"/opt/src/beast/bse/bseprobe.idl",761,"source");
427  fields[1] = sfidl_pspec_Int_default (NULL,"/opt/src/beast/bse/bseprobe.idl",762,"channel_id");
428  fields[2] = sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bseprobe.idl",763,"frequency");
429  fields[3] = sfidl_pspec_Record_default (NULL,"/opt/src/beast/bse/bseprobe.idl",764, "probe_features", Bse::ProbeFeatures::get_fields());
430  rfields.fields = fields;
431  }
432  return rfields;
433 }
434 
435 
436 /* sequence implementations */
438 ProbeSeq::from_seq (SfiSeq *sfi_seq)
439 {
440  ::Bse::ProbeSeq cseq;
441  guint i, length;
442 
443  if (!sfi_seq)
444  return cseq;
445 
446  length = sfi_seq_length (sfi_seq);
447  cseq.resize (length);
448  for (i = 0; i < length; i++)
449  {
450  GValue *element = sfi_seq_get (sfi_seq, i);
451  cseq[i] = ::Bse::Probe::value_get_boxed (element);
452  }
453  return cseq;
454 }
455 
456 SfiSeq *
457 ProbeSeq::to_seq (const ::Bse::ProbeSeq & cseq)
458 {
459  SfiSeq *sfi_seq = sfi_seq_new ();
460  for (guint i = 0; i < cseq.length(); i++)
461  {
462  GValue *element = sfi_seq_append_empty (sfi_seq, SFI_TYPE_REC);
463  ::Bse::Probe::value_set_boxed (element, cseq[i]);
464  }
465  return sfi_seq;
466 }
467 
469 ProbeSeq::value_get_boxed (const GValue *value)
470 {
471  return ::Sfi::cxx_value_get_boxed_sequence< ProbeSeq> (value);
472 }
473 
474 void
475 ProbeSeq::value_set_boxed (GValue *value, const ::Bse::ProbeSeq & self)
476 {
477  ::Sfi::cxx_value_set_boxed_sequence< ProbeSeq> (value, self);
478 }
479 
480 GParamSpec*
481 ProbeSeq::get_element()
482 {
483  static GParamSpec *element = NULL;
484  if (!element) {
485  element = g_param_spec_ref (sfidl_pspec_Record_default (NULL,"/opt/src/beast/bse/bseprobe.idl",757, "probes", Bse::Probe::get_fields()));
486  g_param_spec_sink (element);
487  }
488  return element;
489 }
490 
492 ProbeRequestSeq::from_seq (SfiSeq *sfi_seq)
493 {
495  guint i, length;
496 
497  if (!sfi_seq)
498  return cseq;
499 
500  length = sfi_seq_length (sfi_seq);
501  cseq.resize (length);
502  for (i = 0; i < length; i++)
503  {
504  GValue *element = sfi_seq_get (sfi_seq, i);
505  cseq[i] = ::Bse::ProbeRequest::value_get_boxed (element);
506  }
507  return cseq;
508 }
509 
510 SfiSeq *
511 ProbeRequestSeq::to_seq (const ::Bse::ProbeRequestSeq & cseq)
512 {
513  SfiSeq *sfi_seq = sfi_seq_new ();
514  for (guint i = 0; i < cseq.length(); i++)
515  {
516  GValue *element = sfi_seq_append_empty (sfi_seq, SFI_TYPE_REC);
517  ::Bse::ProbeRequest::value_set_boxed (element, cseq[i]);
518  }
519  return sfi_seq;
520 }
521 
523 ProbeRequestSeq::value_get_boxed (const GValue *value)
524 {
525  return ::Sfi::cxx_value_get_boxed_sequence< ProbeRequestSeq> (value);
526 }
527 
528 void
529 ProbeRequestSeq::value_set_boxed (GValue *value, const ::Bse::ProbeRequestSeq & self)
530 {
531  ::Sfi::cxx_value_set_boxed_sequence< ProbeRequestSeq> (value, self);
532 }
533 
534 GParamSpec*
535 ProbeRequestSeq::get_element()
536 {
537  static GParamSpec *element = NULL;
538  if (!element) {
539  element = g_param_spec_ref (sfidl_pspec_Record_default (NULL,"/opt/src/beast/bse/bseprobe.idl",767, "probe_requests", Bse::ProbeRequest::get_fields()));
540  g_param_spec_sink (element);
541  }
542  return element;
543 }
544 
545 
546 
547 /* class implementations */
548 
549 
550 /* procedure implementations */
551 namespace Procedure {
552 BSE_CXX_DECLARE_PROC (source_request_probes);
554 public:
555  static inline const unsigned char* pixstream () { return NULL; }
556  static inline const char* options () { return ""; }
557  static inline const char* category () { static const char *c = NULL;
558  return c ? c : c = sfi_category_concat ("/Proc", ""); }
559  static inline const char* i18n_category () { static const char *c = NULL;
560  return c ? c : c = sfi_category_concat ("/Proc", ""); }
561  static inline const char* blurb () { return ""; }
562  static inline const char* authors () { return ""; }
563  static inline const char* license () { return ""; }
564  static inline const char* type_name () { return "bse-source-request-probes"; }
565  static void exec (BseSource* source, Sfi::Int ochannel_id, const ::Bse::ProbeFeaturesHandle & probe_features);
566  static BseErrorType marshal (BseProcedureClass *procedure,
567  const GValue *in_values,
568  GValue *out_values)
569  {
570  try {
571  exec (
572  ::Bse::CxxBase::value_get_gobject< BseSource> (in_values + 0),
573  sfi_value_get_int (in_values + 1),
574  ::Bse::ProbeFeatures::value_get_boxed (in_values + 2)
575  );
576  } catch (std::exception &e) {
577  sfi_diag ("%s: %s", "source_request_probes", e.what());
578  return BSE_ERROR_PROC_EXECUTION;
579  } catch (...) {
580  sfi_diag ("%s: %s", "source_request_probes", "uncaught exception");
581  return BSE_ERROR_PROC_EXECUTION;
582  }
583  return BSE_ERROR_NONE;
584  }
585  static void init (BseProcedureClass *proc,
586  GParamSpec **in_pspecs,
587  GParamSpec **out_pspecs)
588  {
589  *(in_pspecs++) = sfidl_pspec_TypedObject_default (NULL,"/opt/src/beast/bse/bseprobe.idl",0, "source", BSE_TYPE_SOURCE);
590  *(in_pspecs++) = sfidl_pspec_Int_default (NULL,"/opt/src/beast/bse/bseprobe.idl",0,"ochannel_id");
591  *(in_pspecs++) = sfidl_pspec_BoxedRec_default (NULL,"/opt/src/beast/bse/bseprobe.idl",0, "probe_features", BSE_TYPE_PROBE_FEATURES);
592  }
593 };
594 } // Procedure
595 
596 namespace Procedure {
597 BSE_CXX_DECLARE_PROC (source_mass_request);
599 public:
600  static inline const unsigned char* pixstream () { return NULL; }
601  static inline const char* options () { return ""; }
602  static inline const char* category () { static const char *c = NULL;
603  return c ? c : c = sfi_category_concat ("/Proc", ""); }
604  static inline const char* i18n_category () { static const char *c = NULL;
605  return c ? c : c = sfi_category_concat ("/Proc", ""); }
606  static inline const char* blurb () { return ""; }
607  static inline const char* authors () { return ""; }
608  static inline const char* license () { return ""; }
609  static inline const char* type_name () { return "bse-source-mass-request"; }
610  static void exec (const ::Bse::ProbeRequestSeq & prseq);
611  static BseErrorType marshal (BseProcedureClass *procedure,
612  const GValue *in_values,
613  GValue *out_values)
614  {
615  try {
616  exec (
617  ::Bse::ProbeRequestSeq::value_get_boxed (in_values + 0)
618  );
619  } catch (std::exception &e) {
620  sfi_diag ("%s: %s", "source_mass_request", e.what());
621  return BSE_ERROR_PROC_EXECUTION;
622  } catch (...) {
623  sfi_diag ("%s: %s", "source_mass_request", "uncaught exception");
624  return BSE_ERROR_PROC_EXECUTION;
625  }
626  return BSE_ERROR_NONE;
627  }
628  static void init (BseProcedureClass *proc,
629  GParamSpec **in_pspecs,
630  GParamSpec **out_pspecs)
631  {
632  *(in_pspecs++) = sfidl_pspec_BoxedSeq_default (NULL,"/opt/src/beast/bse/bseprobe.idl",0, "prseq", BSE_TYPE_PROBE_REQUEST_SEQ);
633  }
634 };
635 } // Procedure
636 
637 namespace Procedure {
638 BSE_CXX_DECLARE_PROC (source_get_tick_stamp);
640 public:
641  static inline const unsigned char* pixstream () { return NULL; }
642  static inline const char* options () { return ""; }
643  static inline const char* category () { static const char *c = NULL;
644  return c ? c : c = sfi_category_concat ("/Proc", ""); }
645  static inline const char* i18n_category () { static const char *c = NULL;
646  return c ? c : c = sfi_category_concat ("/Proc", ""); }
647  static inline const char* blurb () { return ""; }
648  static inline const char* authors () { return ""; }
649  static inline const char* license () { return ""; }
650  static inline const char* type_name () { return "bse-source-get-tick-stamp"; }
651  static Sfi::Num exec (BseSource* obj);
652  static BseErrorType marshal (BseProcedureClass *procedure,
653  const GValue *in_values,
654  GValue *out_values)
655  {
656  try {
657  Sfi::Num __return_value =
658  exec (
659  ::Bse::CxxBase::value_get_gobject< BseSource> (in_values + 0)
660  );
661  sfi_value_set_num (out_values, __return_value);
662  } catch (std::exception &e) {
663  sfi_diag ("%s: %s", "source_get_tick_stamp", e.what());
664  return BSE_ERROR_PROC_EXECUTION;
665  } catch (...) {
666  sfi_diag ("%s: %s", "source_get_tick_stamp", "uncaught exception");
667  return BSE_ERROR_PROC_EXECUTION;
668  }
669  return BSE_ERROR_NONE;
670  }
671  static void init (BseProcedureClass *proc,
672  GParamSpec **in_pspecs,
673  GParamSpec **out_pspecs)
674  {
675  *(in_pspecs++) = sfidl_pspec_TypedObject_default (NULL,"/opt/src/beast/bse/bseprobe.idl",0, "obj", BSE_TYPE_SOURCE);
676  *(out_pspecs++) = sfidl_pspec_Num_default (NULL,"/opt/src/beast/bse/bseprobe.idl",599052288,"result");
677  }
678 };
679 } // Procedure
680 
681 namespace Procedure {
682 BSE_CXX_DECLARE_PROC (source_get_mix_freq);
684 public:
685  static inline const unsigned char* pixstream () { return NULL; }
686  static inline const char* options () { return ""; }
687  static inline const char* category () { static const char *c = NULL;
688  return c ? c : c = sfi_category_concat ("/Proc", ""); }
689  static inline const char* i18n_category () { static const char *c = NULL;
690  return c ? c : c = sfi_category_concat ("/Proc", ""); }
691  static inline const char* blurb () { return ""; }
692  static inline const char* authors () { return ""; }
693  static inline const char* license () { return ""; }
694  static inline const char* type_name () { return "bse-source-get-mix-freq"; }
695  static Sfi::Int exec (BseSource* obj);
696  static BseErrorType marshal (BseProcedureClass *procedure,
697  const GValue *in_values,
698  GValue *out_values)
699  {
700  try {
701  Sfi::Int __return_value =
702  exec (
703  ::Bse::CxxBase::value_get_gobject< BseSource> (in_values + 0)
704  );
705  sfi_value_set_int (out_values, __return_value);
706  } catch (std::exception &e) {
707  sfi_diag ("%s: %s", "source_get_mix_freq", e.what());
708  return BSE_ERROR_PROC_EXECUTION;
709  } catch (...) {
710  sfi_diag ("%s: %s", "source_get_mix_freq", "uncaught exception");
711  return BSE_ERROR_PROC_EXECUTION;
712  }
713  return BSE_ERROR_NONE;
714  }
715  static void init (BseProcedureClass *proc,
716  GParamSpec **in_pspecs,
717  GParamSpec **out_pspecs)
718  {
719  *(in_pspecs++) = sfidl_pspec_TypedObject_default (NULL,"/opt/src/beast/bse/bseprobe.idl",0, "obj", BSE_TYPE_SOURCE);
720  *(out_pspecs++) = sfidl_pspec_Int_default (NULL,"/opt/src/beast/bse/bseprobe.idl",599052288,"result");
721  }
722 };
723 } // Procedure
724 
725 
726 
727 /* bseprobe.idl type registrations */
728 #define BSE_CXX_REGISTER_ALL_TYPES_FROM_BSEPROBE_IDL() \
729  BSE_CXX_REGISTER_RECORD (ProbeFeatures); \
730  BSE_CXX_REGISTER_RECORD (Probe); \
731  BSE_CXX_REGISTER_RECORD (ProbeRequest); \
732  BSE_CXX_REGISTER_SEQUENCE (ProbeSeq); \
733  BSE_CXX_REGISTER_SEQUENCE (ProbeRequestSeq); \
734  BSE_CXX_REGISTER_PROCEDURE (source_request_probes); \
735  BSE_CXX_REGISTER_PROCEDURE (source_mass_request); \
736  BSE_CXX_REGISTER_PROCEDURE (source_get_tick_stamp); \
737  BSE_CXX_REGISTER_PROCEDURE (source_get_mix_freq); \
738  /* bseprobe.idl type registrations done */
739 } // Bse
740 
741 /*-------- end ../sfi/sfidl generated code --------*/
742 
743 
Definition: bseprobe.genidl.hh:42
Definition: bseprobe.genidl.hh:75
Definition: bseprobe.genidl.hh:639
Definition: bseprobe.genidl.hh:598
Definition: bseprobe.genidl.hh:116
Definition: bseprobe.genidl.hh:57
Definition: sficxx.hh:325
Definition: bseprobe.genidl.hh:683
Definition: sfitypes.hh:32
Definition: bseprobe.genidl.hh:93
Definition: bsesource.hh:84
Definition: bseprobe.genidl.hh:553
Definition: sficxx.hh:142
Definition: bsebasics.genidl.hh:526