BEAST/BSE - Better Audio System and Sound Engine
0.8.2
|
00001 00002 /*-------- begin ../sfi/sfidl generated code --------*/ 00003 00004 00005 00006 #include <bse/bsecxxplugin.hh> 00007 00008 00009 /* enum prototypes */ 00010 00011 00012 /* choice prototypes */ 00013 00014 00015 /* record prototypes */ 00016 namespace Bse { 00017 class ProbeFeatures; 00018 typedef Sfi::RecordHandle<ProbeFeatures> ProbeFeaturesHandle; 00019 #define BSE_TYPE_PROBE_FEATURES BSE_CXX_DECLARED_RECORD_TYPE (Bse, ProbeFeatures) 00020 class Probe; 00021 typedef Sfi::RecordHandle<Probe> ProbeHandle; 00022 #define BSE_TYPE_PROBE BSE_CXX_DECLARED_RECORD_TYPE (Bse, Probe) 00023 class ProbeRequest; 00024 typedef Sfi::RecordHandle<ProbeRequest> ProbeRequestHandle; 00025 #define BSE_TYPE_PROBE_REQUEST BSE_CXX_DECLARED_RECORD_TYPE (Bse, ProbeRequest) 00026 00027 00028 /* sequence prototypes */ 00029 class ProbeSeq; 00030 #define BSE_TYPE_PROBE_SEQ BSE_CXX_DECLARED_SEQUENCE_TYPE (Bse, ProbeSeq) 00031 class ProbeRequestSeq; 00032 #define BSE_TYPE_PROBE_REQUEST_SEQ BSE_CXX_DECLARED_SEQUENCE_TYPE (Bse, ProbeRequestSeq) 00033 00034 00035 /* class prototypes */ 00036 00037 00038 /* enum definitions */ 00039 00040 00041 /* sequence definitions */ 00042 class ProbeSeq : public Sfi::Sequence< ::Bse::ProbeHandle > { 00043 public: 00044 ProbeSeq (unsigned int n = 0) : Sfi::Sequence< ::Bse::ProbeHandle > (n) {} 00045 static inline ::Bse::ProbeSeq from_seq (SfiSeq *seq); 00046 static inline SfiSeq *to_seq (const ::Bse::ProbeSeq & seq); 00047 static inline ::Bse::ProbeSeq value_get_boxed (const GValue *value); 00048 static inline void value_set_boxed (GValue *value, const ::Bse::ProbeSeq & self); 00049 static inline const char* options () { return ""; } 00050 static inline const char* blurb () { return ""; } 00051 static inline const char* authors () { return ""; } 00052 static inline const char* license () { return ""; } 00053 static inline const char* type_name () { return "BseProbeSeq"; } 00054 static inline GParamSpec* get_element (); 00055 }; 00056 00057 class ProbeRequestSeq : public Sfi::Sequence< ::Bse::ProbeRequestHandle > { 00058 public: 00059 ProbeRequestSeq (unsigned int n = 0) : Sfi::Sequence< ::Bse::ProbeRequestHandle > (n) {} 00060 static inline ::Bse::ProbeRequestSeq from_seq (SfiSeq *seq); 00061 static inline SfiSeq *to_seq (const ::Bse::ProbeRequestSeq & seq); 00062 static inline ::Bse::ProbeRequestSeq value_get_boxed (const GValue *value); 00063 static inline void value_set_boxed (GValue *value, const ::Bse::ProbeRequestSeq & self); 00064 static inline const char* options () { return ""; } 00065 static inline const char* blurb () { return ""; } 00066 static inline const char* authors () { return ""; } 00067 static inline const char* license () { return ""; } 00068 static inline const char* type_name () { return "BseProbeRequestSeq"; } 00069 static inline GParamSpec* get_element (); 00070 }; 00071 00072 00073 00074 /* record definitions */ 00075 class ProbeFeatures : public ::Sfi::GNewable { 00076 public: 00077 bool probe_range; 00078 bool probe_energie; 00079 bool probe_samples; 00080 bool probe_fft; 00081 static inline ::Bse::ProbeFeaturesHandle from_rec (SfiRec *rec); 00082 static inline SfiRec *to_rec (const ::Bse::ProbeFeaturesHandle & ptr); 00083 static inline ::Bse::ProbeFeaturesHandle value_get_boxed (const GValue *value); 00084 static inline void value_set_boxed (GValue *value, const ::Bse::ProbeFeaturesHandle & self); 00085 static inline const char* options () { return ""; } 00086 static inline const char* blurb () { return ""; } 00087 static inline const char* authors () { return ""; } 00088 static inline const char* license () { return ""; } 00089 static inline const char* type_name () { return "BseProbeFeatures"; } 00090 static inline SfiRecFields get_fields (); 00091 }; 00092 00093 class Probe : public ::Sfi::GNewable { 00094 public: 00095 Sfi::Int channel_id; 00096 Sfi::Num block_stamp; 00097 Sfi::Real mix_freq; 00098 ::Bse::ProbeFeaturesHandle probe_features; 00099 Sfi::Real min; 00100 Sfi::Real max; 00101 Sfi::Real energie; 00102 ::Bse::FloatSeq sample_data; 00103 ::Bse::FloatSeq fft_data; 00104 static inline ::Bse::ProbeHandle from_rec (SfiRec *rec); 00105 static inline SfiRec *to_rec (const ::Bse::ProbeHandle & ptr); 00106 static inline ::Bse::ProbeHandle value_get_boxed (const GValue *value); 00107 static inline void value_set_boxed (GValue *value, const ::Bse::ProbeHandle & self); 00108 static inline const char* options () { return ""; } 00109 static inline const char* blurb () { return ""; } 00110 static inline const char* authors () { return ""; } 00111 static inline const char* license () { return ""; } 00112 static inline const char* type_name () { return "BseProbe"; } 00113 static inline SfiRecFields get_fields (); 00114 }; 00115 00116 class ProbeRequest : public ::Sfi::GNewable { 00117 public: 00118 BseSource* source; 00119 Sfi::Int channel_id; 00120 Sfi::Real frequency; 00121 ::Bse::ProbeFeaturesHandle probe_features; 00122 static inline ::Bse::ProbeRequestHandle from_rec (SfiRec *rec); 00123 static inline SfiRec *to_rec (const ::Bse::ProbeRequestHandle & ptr); 00124 static inline ::Bse::ProbeRequestHandle value_get_boxed (const GValue *value); 00125 static inline void value_set_boxed (GValue *value, const ::Bse::ProbeRequestHandle & self); 00126 static inline const char* options () { return ""; } 00127 static inline const char* blurb () { return ""; } 00128 static inline const char* authors () { return ""; } 00129 static inline const char* license () { return ""; } 00130 static inline const char* type_name () { return "BseProbeRequest"; } 00131 static inline SfiRecFields get_fields (); 00132 }; 00133 00134 00135 00136 /* enum declarations */ 00137 00138 00139 /* sequence type declarations */ 00140 BSE_CXX_DECLARE_SEQUENCE (ProbeSeq); 00141 00142 BSE_CXX_DECLARE_SEQUENCE (ProbeRequestSeq); 00143 00144 00145 00146 /* record type declarations */ 00147 BSE_CXX_DECLARE_RECORD (ProbeFeatures); 00148 00149 BSE_CXX_DECLARE_RECORD (Probe); 00150 00151 BSE_CXX_DECLARE_RECORD (ProbeRequest); 00152 00153 00154 00155 /* procedure prototypes */ 00156 namespace Procedure { 00157 class source_request_probes; 00158 #define BSE_TYPE_SOURCE_REQUEST_PROBES BSE_CXX_DECLARED_PROC_TYPE (Bse, source_request_probes) 00159 } // Procedure 00160 00161 namespace Procedure { 00162 class source_mass_request; 00163 #define BSE_TYPE_SOURCE_MASS_REQUEST BSE_CXX_DECLARED_PROC_TYPE (Bse, source_mass_request) 00164 } // Procedure 00165 00166 namespace Procedure { 00167 class source_get_tick_stamp; 00168 #define BSE_TYPE_SOURCE_GET_TICK_STAMP BSE_CXX_DECLARED_PROC_TYPE (Bse, source_get_tick_stamp) 00169 } // Procedure 00170 00171 namespace Procedure { 00172 class source_get_mix_freq; 00173 #define BSE_TYPE_SOURCE_GET_MIX_FREQ BSE_CXX_DECLARED_PROC_TYPE (Bse, source_get_mix_freq) 00174 } // Procedure 00175 00176 00177 00178 /* class definitions */ 00179 00180 00181 /* choice implementations */ 00182 00183 00184 /* record implementations */ 00185 ::Bse::ProbeFeaturesHandle 00186 ProbeFeatures::from_rec (SfiRec *sfi_rec) 00187 { 00188 GValue *element; 00189 00190 if (!sfi_rec) 00191 return Sfi::INIT_NULL; 00192 00193 ::Bse::ProbeFeaturesHandle rec = Sfi::INIT_DEFAULT; 00194 element = sfi_rec_get (sfi_rec, "probe_range"); 00195 if (element) 00196 rec->probe_range = sfi_value_get_bool (element); 00197 element = sfi_rec_get (sfi_rec, "probe_energie"); 00198 if (element) 00199 rec->probe_energie = sfi_value_get_bool (element); 00200 element = sfi_rec_get (sfi_rec, "probe_samples"); 00201 if (element) 00202 rec->probe_samples = sfi_value_get_bool (element); 00203 element = sfi_rec_get (sfi_rec, "probe_fft"); 00204 if (element) 00205 rec->probe_fft = sfi_value_get_bool (element); 00206 return rec; 00207 } 00208 00209 SfiRec * 00210 ProbeFeatures::to_rec (const ::Bse::ProbeFeaturesHandle & rec) 00211 { 00212 SfiRec *sfi_rec; 00213 GValue *element; 00214 00215 if (!rec) 00216 return NULL; 00217 00218 sfi_rec = sfi_rec_new (); 00219 element = sfi_rec_forced_get (sfi_rec, "probe_range", SFI_TYPE_BOOL); 00220 sfi_value_set_bool (element, rec->probe_range); 00221 element = sfi_rec_forced_get (sfi_rec, "probe_energie", SFI_TYPE_BOOL); 00222 sfi_value_set_bool (element, rec->probe_energie); 00223 element = sfi_rec_forced_get (sfi_rec, "probe_samples", SFI_TYPE_BOOL); 00224 sfi_value_set_bool (element, rec->probe_samples); 00225 element = sfi_rec_forced_get (sfi_rec, "probe_fft", SFI_TYPE_BOOL); 00226 sfi_value_set_bool (element, rec->probe_fft); 00227 return sfi_rec; 00228 } 00229 00230 ::Bse::ProbeFeaturesHandle 00231 ProbeFeatures::value_get_boxed (const GValue *value) 00232 { 00233 return ::Bse::ProbeFeaturesHandle::value_get_boxed (value); 00234 } 00235 00236 void 00237 ProbeFeatures::value_set_boxed (GValue *value, const ::Bse::ProbeFeaturesHandle & self) 00238 { 00239 ::Bse::ProbeFeaturesHandle::value_set_boxed (value, self); 00240 } 00241 00242 SfiRecFields 00243 ProbeFeatures::get_fields() 00244 { 00245 static SfiRecFields rfields = { 0, NULL }; 00246 if (!rfields.n_fields) 00247 { 00248 static GParamSpec *fields[4 + 1]; 00249 rfields.n_fields = 4; 00250 fields[0] = sfidl_pspec_Bool_default (NULL,"/opt/src/beast/bse/bseprobe.idl",739,"probe_range"); 00251 fields[1] = sfidl_pspec_Bool_default (NULL,"/opt/src/beast/bse/bseprobe.idl",740,"probe_energie"); 00252 fields[2] = sfidl_pspec_Bool_default (NULL,"/opt/src/beast/bse/bseprobe.idl",741,"probe_samples"); 00253 fields[3] = sfidl_pspec_Bool_default (NULL,"/opt/src/beast/bse/bseprobe.idl",742,"probe_fft"); 00254 rfields.fields = fields; 00255 } 00256 return rfields; 00257 } 00258 ::Bse::ProbeHandle 00259 Probe::from_rec (SfiRec *sfi_rec) 00260 { 00261 GValue *element; 00262 00263 if (!sfi_rec) 00264 return Sfi::INIT_NULL; 00265 00266 ::Bse::ProbeHandle rec = Sfi::INIT_DEFAULT; 00267 element = sfi_rec_get (sfi_rec, "channel_id"); 00268 if (element) 00269 rec->channel_id = sfi_value_get_int (element); 00270 element = sfi_rec_get (sfi_rec, "block_stamp"); 00271 if (element) 00272 rec->block_stamp = sfi_value_get_num (element); 00273 element = sfi_rec_get (sfi_rec, "mix_freq"); 00274 if (element) 00275 rec->mix_freq = sfi_value_get_real (element); 00276 element = sfi_rec_get (sfi_rec, "probe_features"); 00277 if (element) 00278 rec->probe_features = ::Bse::ProbeFeatures::value_get_boxed (element); 00279 element = sfi_rec_get (sfi_rec, "min"); 00280 if (element) 00281 rec->min = sfi_value_get_real (element); 00282 element = sfi_rec_get (sfi_rec, "max"); 00283 if (element) 00284 rec->max = sfi_value_get_real (element); 00285 element = sfi_rec_get (sfi_rec, "energie"); 00286 if (element) 00287 rec->energie = sfi_value_get_real (element); 00288 element = sfi_rec_get (sfi_rec, "sample_data"); 00289 if (element) 00290 rec->sample_data = ::Bse::FloatSeq::value_get_boxed (element); 00291 element = sfi_rec_get (sfi_rec, "fft_data"); 00292 if (element) 00293 rec->fft_data = ::Bse::FloatSeq::value_get_boxed (element); 00294 return rec; 00295 } 00296 00297 SfiRec * 00298 Probe::to_rec (const ::Bse::ProbeHandle & rec) 00299 { 00300 SfiRec *sfi_rec; 00301 GValue *element; 00302 00303 if (!rec) 00304 return NULL; 00305 00306 sfi_rec = sfi_rec_new (); 00307 element = sfi_rec_forced_get (sfi_rec, "channel_id", SFI_TYPE_INT); 00308 sfi_value_set_int (element, rec->channel_id); 00309 element = sfi_rec_forced_get (sfi_rec, "block_stamp", SFI_TYPE_NUM); 00310 sfi_value_set_num (element, rec->block_stamp); 00311 element = sfi_rec_forced_get (sfi_rec, "mix_freq", SFI_TYPE_REAL); 00312 sfi_value_set_real (element, rec->mix_freq); 00313 element = sfi_rec_forced_get (sfi_rec, "probe_features", SFI_TYPE_REC); 00314 ::Bse::ProbeFeatures::value_set_boxed (element, rec->probe_features); 00315 element = sfi_rec_forced_get (sfi_rec, "min", SFI_TYPE_REAL); 00316 sfi_value_set_real (element, rec->min); 00317 element = sfi_rec_forced_get (sfi_rec, "max", SFI_TYPE_REAL); 00318 sfi_value_set_real (element, rec->max); 00319 element = sfi_rec_forced_get (sfi_rec, "energie", SFI_TYPE_REAL); 00320 sfi_value_set_real (element, rec->energie); 00321 element = sfi_rec_forced_get (sfi_rec, "sample_data", SFI_TYPE_SEQ); 00322 ::Bse::FloatSeq::value_set_boxed (element, rec->sample_data); 00323 element = sfi_rec_forced_get (sfi_rec, "fft_data", SFI_TYPE_SEQ); 00324 ::Bse::FloatSeq::value_set_boxed (element, rec->fft_data); 00325 return sfi_rec; 00326 } 00327 00328 ::Bse::ProbeHandle 00329 Probe::value_get_boxed (const GValue *value) 00330 { 00331 return ::Bse::ProbeHandle::value_get_boxed (value); 00332 } 00333 00334 void 00335 Probe::value_set_boxed (GValue *value, const ::Bse::ProbeHandle & self) 00336 { 00337 ::Bse::ProbeHandle::value_set_boxed (value, self); 00338 } 00339 00340 SfiRecFields 00341 Probe::get_fields() 00342 { 00343 static SfiRecFields rfields = { 0, NULL }; 00344 if (!rfields.n_fields) 00345 { 00346 static GParamSpec *fields[9 + 1]; 00347 rfields.n_fields = 9; 00348 fields[0] = sfidl_pspec_Int_default (NULL,"/opt/src/beast/bse/bseprobe.idl",746,"channel_id"); 00349 fields[1] = sfidl_pspec_Num_default (NULL,"/opt/src/beast/bse/bseprobe.idl",747,"block_stamp"); 00350 fields[2] = sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bseprobe.idl",748,"mix_freq"); 00351 fields[3] = sfidl_pspec_Record_default (NULL,"/opt/src/beast/bse/bseprobe.idl",749, "probe_features", Bse::ProbeFeatures::get_fields()); 00352 fields[4] = sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bseprobe.idl",750,"min"); 00353 fields[5] = sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bseprobe.idl",751,"max"); 00354 fields[6] = sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bseprobe.idl",752,"energie"); 00355 fields[7] = sfidl_pspec_Sequence_default (NULL,"/opt/src/beast/bse/bseprobe.idl",753, "sample_data", Bse::FloatSeq::get_element()); 00356 fields[8] = sfidl_pspec_Sequence_default (NULL,"/opt/src/beast/bse/bseprobe.idl",754, "fft_data", Bse::FloatSeq::get_element()); 00357 rfields.fields = fields; 00358 } 00359 return rfields; 00360 } 00361 ::Bse::ProbeRequestHandle 00362 ProbeRequest::from_rec (SfiRec *sfi_rec) 00363 { 00364 GValue *element; 00365 00366 if (!sfi_rec) 00367 return Sfi::INIT_NULL; 00368 00369 ::Bse::ProbeRequestHandle rec = Sfi::INIT_DEFAULT; 00370 element = sfi_rec_get (sfi_rec, "source"); 00371 if (element) 00372 rec->source = ::Bse::CxxBase::value_get_gobject< BseSource> (element); 00373 element = sfi_rec_get (sfi_rec, "channel_id"); 00374 if (element) 00375 rec->channel_id = sfi_value_get_int (element); 00376 element = sfi_rec_get (sfi_rec, "frequency"); 00377 if (element) 00378 rec->frequency = sfi_value_get_real (element); 00379 element = sfi_rec_get (sfi_rec, "probe_features"); 00380 if (element) 00381 rec->probe_features = ::Bse::ProbeFeatures::value_get_boxed (element); 00382 return rec; 00383 } 00384 00385 SfiRec * 00386 ProbeRequest::to_rec (const ::Bse::ProbeRequestHandle & rec) 00387 { 00388 SfiRec *sfi_rec; 00389 GValue *element; 00390 00391 if (!rec) 00392 return NULL; 00393 00394 sfi_rec = sfi_rec_new (); 00395 element = sfi_rec_forced_get (sfi_rec, "source", SFI_TYPE_PROXY); 00396 ::Bse::CxxBase::value_set_gobject (element, rec->source); 00397 element = sfi_rec_forced_get (sfi_rec, "channel_id", SFI_TYPE_INT); 00398 sfi_value_set_int (element, rec->channel_id); 00399 element = sfi_rec_forced_get (sfi_rec, "frequency", SFI_TYPE_REAL); 00400 sfi_value_set_real (element, rec->frequency); 00401 element = sfi_rec_forced_get (sfi_rec, "probe_features", SFI_TYPE_REC); 00402 ::Bse::ProbeFeatures::value_set_boxed (element, rec->probe_features); 00403 return sfi_rec; 00404 } 00405 00406 ::Bse::ProbeRequestHandle 00407 ProbeRequest::value_get_boxed (const GValue *value) 00408 { 00409 return ::Bse::ProbeRequestHandle::value_get_boxed (value); 00410 } 00411 00412 void 00413 ProbeRequest::value_set_boxed (GValue *value, const ::Bse::ProbeRequestHandle & self) 00414 { 00415 ::Bse::ProbeRequestHandle::value_set_boxed (value, self); 00416 } 00417 00418 SfiRecFields 00419 ProbeRequest::get_fields() 00420 { 00421 static SfiRecFields rfields = { 0, NULL }; 00422 if (!rfields.n_fields) 00423 { 00424 static GParamSpec *fields[4 + 1]; 00425 rfields.n_fields = 4; 00426 fields[0] = sfidl_pspec_Object_default (NULL,"/opt/src/beast/bse/bseprobe.idl",761,"source"); 00427 fields[1] = sfidl_pspec_Int_default (NULL,"/opt/src/beast/bse/bseprobe.idl",762,"channel_id"); 00428 fields[2] = sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bseprobe.idl",763,"frequency"); 00429 fields[3] = sfidl_pspec_Record_default (NULL,"/opt/src/beast/bse/bseprobe.idl",764, "probe_features", Bse::ProbeFeatures::get_fields()); 00430 rfields.fields = fields; 00431 } 00432 return rfields; 00433 } 00434 00435 00436 /* sequence implementations */ 00437 ::Bse::ProbeSeq 00438 ProbeSeq::from_seq (SfiSeq *sfi_seq) 00439 { 00440 ::Bse::ProbeSeq cseq; 00441 guint i, length; 00442 00443 if (!sfi_seq) 00444 return cseq; 00445 00446 length = sfi_seq_length (sfi_seq); 00447 cseq.resize (length); 00448 for (i = 0; i < length; i++) 00449 { 00450 GValue *element = sfi_seq_get (sfi_seq, i); 00451 cseq[i] = ::Bse::Probe::value_get_boxed (element); 00452 } 00453 return cseq; 00454 } 00455 00456 SfiSeq * 00457 ProbeSeq::to_seq (const ::Bse::ProbeSeq & cseq) 00458 { 00459 SfiSeq *sfi_seq = sfi_seq_new (); 00460 for (guint i = 0; i < cseq.length(); i++) 00461 { 00462 GValue *element = sfi_seq_append_empty (sfi_seq, SFI_TYPE_REC); 00463 ::Bse::Probe::value_set_boxed (element, cseq[i]); 00464 } 00465 return sfi_seq; 00466 } 00467 00468 ::Bse::ProbeSeq 00469 ProbeSeq::value_get_boxed (const GValue *value) 00470 { 00471 return ::Sfi::cxx_value_get_boxed_sequence< ProbeSeq> (value); 00472 } 00473 00474 void 00475 ProbeSeq::value_set_boxed (GValue *value, const ::Bse::ProbeSeq & self) 00476 { 00477 ::Sfi::cxx_value_set_boxed_sequence< ProbeSeq> (value, self); 00478 } 00479 00480 GParamSpec* 00481 ProbeSeq::get_element() 00482 { 00483 static GParamSpec *element = NULL; 00484 if (!element) { 00485 element = g_param_spec_ref (sfidl_pspec_Record_default (NULL,"/opt/src/beast/bse/bseprobe.idl",757, "probes", Bse::Probe::get_fields())); 00486 g_param_spec_sink (element); 00487 } 00488 return element; 00489 } 00490 00491 ::Bse::ProbeRequestSeq 00492 ProbeRequestSeq::from_seq (SfiSeq *sfi_seq) 00493 { 00494 ::Bse::ProbeRequestSeq cseq; 00495 guint i, length; 00496 00497 if (!sfi_seq) 00498 return cseq; 00499 00500 length = sfi_seq_length (sfi_seq); 00501 cseq.resize (length); 00502 for (i = 0; i < length; i++) 00503 { 00504 GValue *element = sfi_seq_get (sfi_seq, i); 00505 cseq[i] = ::Bse::ProbeRequest::value_get_boxed (element); 00506 } 00507 return cseq; 00508 } 00509 00510 SfiSeq * 00511 ProbeRequestSeq::to_seq (const ::Bse::ProbeRequestSeq & cseq) 00512 { 00513 SfiSeq *sfi_seq = sfi_seq_new (); 00514 for (guint i = 0; i < cseq.length(); i++) 00515 { 00516 GValue *element = sfi_seq_append_empty (sfi_seq, SFI_TYPE_REC); 00517 ::Bse::ProbeRequest::value_set_boxed (element, cseq[i]); 00518 } 00519 return sfi_seq; 00520 } 00521 00522 ::Bse::ProbeRequestSeq 00523 ProbeRequestSeq::value_get_boxed (const GValue *value) 00524 { 00525 return ::Sfi::cxx_value_get_boxed_sequence< ProbeRequestSeq> (value); 00526 } 00527 00528 void 00529 ProbeRequestSeq::value_set_boxed (GValue *value, const ::Bse::ProbeRequestSeq & self) 00530 { 00531 ::Sfi::cxx_value_set_boxed_sequence< ProbeRequestSeq> (value, self); 00532 } 00533 00534 GParamSpec* 00535 ProbeRequestSeq::get_element() 00536 { 00537 static GParamSpec *element = NULL; 00538 if (!element) { 00539 element = g_param_spec_ref (sfidl_pspec_Record_default (NULL,"/opt/src/beast/bse/bseprobe.idl",767, "probe_requests", Bse::ProbeRequest::get_fields())); 00540 g_param_spec_sink (element); 00541 } 00542 return element; 00543 } 00544 00545 00546 00547 /* class implementations */ 00548 00549 00550 /* procedure implementations */ 00551 namespace Procedure { 00552 BSE_CXX_DECLARE_PROC (source_request_probes); 00553 class source_request_probes { 00554 public: 00555 static inline const unsigned char* pixstream () { return NULL; } 00556 static inline const char* options () { return ""; } 00557 static inline const char* category () { static const char *c = NULL; 00558 return c ? c : c = sfi_category_concat ("/Proc", ""); } 00559 static inline const char* i18n_category () { static const char *c = NULL; 00560 return c ? c : c = sfi_category_concat ("/Proc", ""); } 00561 static inline const char* blurb () { return ""; } 00562 static inline const char* authors () { return ""; } 00563 static inline const char* license () { return ""; } 00564 static inline const char* type_name () { return "bse-source-request-probes"; } 00565 static void exec (BseSource* source, Sfi::Int ochannel_id, const ::Bse::ProbeFeaturesHandle & probe_features); 00566 static BseErrorType marshal (BseProcedureClass *procedure, 00567 const GValue *in_values, 00568 GValue *out_values) 00569 { 00570 try { 00571 exec ( 00572 ::Bse::CxxBase::value_get_gobject< BseSource> (in_values + 0), 00573 sfi_value_get_int (in_values + 1), 00574 ::Bse::ProbeFeatures::value_get_boxed (in_values + 2) 00575 ); 00576 } catch (std::exception &e) { 00577 sfi_diag ("%s: %s", "source_request_probes", e.what()); 00578 return BSE_ERROR_PROC_EXECUTION; 00579 } catch (...) { 00580 sfi_diag ("%s: %s", "source_request_probes", "uncaught exception"); 00581 return BSE_ERROR_PROC_EXECUTION; 00582 } 00583 return BSE_ERROR_NONE; 00584 } 00585 static void init (BseProcedureClass *proc, 00586 GParamSpec **in_pspecs, 00587 GParamSpec **out_pspecs) 00588 { 00589 *(in_pspecs++) = sfidl_pspec_TypedObject_default (NULL,"/opt/src/beast/bse/bseprobe.idl",0, "source", BSE_TYPE_SOURCE); 00590 *(in_pspecs++) = sfidl_pspec_Int_default (NULL,"/opt/src/beast/bse/bseprobe.idl",0,"ochannel_id"); 00591 *(in_pspecs++) = sfidl_pspec_BoxedRec_default (NULL,"/opt/src/beast/bse/bseprobe.idl",0, "probe_features", BSE_TYPE_PROBE_FEATURES); 00592 } 00593 }; 00594 } // Procedure 00595 00596 namespace Procedure { 00597 BSE_CXX_DECLARE_PROC (source_mass_request); 00598 class source_mass_request { 00599 public: 00600 static inline const unsigned char* pixstream () { return NULL; } 00601 static inline const char* options () { return ""; } 00602 static inline const char* category () { static const char *c = NULL; 00603 return c ? c : c = sfi_category_concat ("/Proc", ""); } 00604 static inline const char* i18n_category () { static const char *c = NULL; 00605 return c ? c : c = sfi_category_concat ("/Proc", ""); } 00606 static inline const char* blurb () { return ""; } 00607 static inline const char* authors () { return ""; } 00608 static inline const char* license () { return ""; } 00609 static inline const char* type_name () { return "bse-source-mass-request"; } 00610 static void exec (const ::Bse::ProbeRequestSeq & prseq); 00611 static BseErrorType marshal (BseProcedureClass *procedure, 00612 const GValue *in_values, 00613 GValue *out_values) 00614 { 00615 try { 00616 exec ( 00617 ::Bse::ProbeRequestSeq::value_get_boxed (in_values + 0) 00618 ); 00619 } catch (std::exception &e) { 00620 sfi_diag ("%s: %s", "source_mass_request", e.what()); 00621 return BSE_ERROR_PROC_EXECUTION; 00622 } catch (...) { 00623 sfi_diag ("%s: %s", "source_mass_request", "uncaught exception"); 00624 return BSE_ERROR_PROC_EXECUTION; 00625 } 00626 return BSE_ERROR_NONE; 00627 } 00628 static void init (BseProcedureClass *proc, 00629 GParamSpec **in_pspecs, 00630 GParamSpec **out_pspecs) 00631 { 00632 *(in_pspecs++) = sfidl_pspec_BoxedSeq_default (NULL,"/opt/src/beast/bse/bseprobe.idl",0, "prseq", BSE_TYPE_PROBE_REQUEST_SEQ); 00633 } 00634 }; 00635 } // Procedure 00636 00637 namespace Procedure { 00638 BSE_CXX_DECLARE_PROC (source_get_tick_stamp); 00639 class source_get_tick_stamp { 00640 public: 00641 static inline const unsigned char* pixstream () { return NULL; } 00642 static inline const char* options () { return ""; } 00643 static inline const char* category () { static const char *c = NULL; 00644 return c ? c : c = sfi_category_concat ("/Proc", ""); } 00645 static inline const char* i18n_category () { static const char *c = NULL; 00646 return c ? c : c = sfi_category_concat ("/Proc", ""); } 00647 static inline const char* blurb () { return ""; } 00648 static inline const char* authors () { return ""; } 00649 static inline const char* license () { return ""; } 00650 static inline const char* type_name () { return "bse-source-get-tick-stamp"; } 00651 static Sfi::Num exec (BseSource* obj); 00652 static BseErrorType marshal (BseProcedureClass *procedure, 00653 const GValue *in_values, 00654 GValue *out_values) 00655 { 00656 try { 00657 Sfi::Num __return_value = 00658 exec ( 00659 ::Bse::CxxBase::value_get_gobject< BseSource> (in_values + 0) 00660 ); 00661 sfi_value_set_num (out_values, __return_value); 00662 } catch (std::exception &e) { 00663 sfi_diag ("%s: %s", "source_get_tick_stamp", e.what()); 00664 return BSE_ERROR_PROC_EXECUTION; 00665 } catch (...) { 00666 sfi_diag ("%s: %s", "source_get_tick_stamp", "uncaught exception"); 00667 return BSE_ERROR_PROC_EXECUTION; 00668 } 00669 return BSE_ERROR_NONE; 00670 } 00671 static void init (BseProcedureClass *proc, 00672 GParamSpec **in_pspecs, 00673 GParamSpec **out_pspecs) 00674 { 00675 *(in_pspecs++) = sfidl_pspec_TypedObject_default (NULL,"/opt/src/beast/bse/bseprobe.idl",0, "obj", BSE_TYPE_SOURCE); 00676 *(out_pspecs++) = sfidl_pspec_Num_default (NULL,"/opt/src/beast/bse/bseprobe.idl",20247104,"result"); 00677 } 00678 }; 00679 } // Procedure 00680 00681 namespace Procedure { 00682 BSE_CXX_DECLARE_PROC (source_get_mix_freq); 00683 class source_get_mix_freq { 00684 public: 00685 static inline const unsigned char* pixstream () { return NULL; } 00686 static inline const char* options () { return ""; } 00687 static inline const char* category () { static const char *c = NULL; 00688 return c ? c : c = sfi_category_concat ("/Proc", ""); } 00689 static inline const char* i18n_category () { static const char *c = NULL; 00690 return c ? c : c = sfi_category_concat ("/Proc", ""); } 00691 static inline const char* blurb () { return ""; } 00692 static inline const char* authors () { return ""; } 00693 static inline const char* license () { return ""; } 00694 static inline const char* type_name () { return "bse-source-get-mix-freq"; } 00695 static Sfi::Int exec (BseSource* obj); 00696 static BseErrorType marshal (BseProcedureClass *procedure, 00697 const GValue *in_values, 00698 GValue *out_values) 00699 { 00700 try { 00701 Sfi::Int __return_value = 00702 exec ( 00703 ::Bse::CxxBase::value_get_gobject< BseSource> (in_values + 0) 00704 ); 00705 sfi_value_set_int (out_values, __return_value); 00706 } catch (std::exception &e) { 00707 sfi_diag ("%s: %s", "source_get_mix_freq", e.what()); 00708 return BSE_ERROR_PROC_EXECUTION; 00709 } catch (...) { 00710 sfi_diag ("%s: %s", "source_get_mix_freq", "uncaught exception"); 00711 return BSE_ERROR_PROC_EXECUTION; 00712 } 00713 return BSE_ERROR_NONE; 00714 } 00715 static void init (BseProcedureClass *proc, 00716 GParamSpec **in_pspecs, 00717 GParamSpec **out_pspecs) 00718 { 00719 *(in_pspecs++) = sfidl_pspec_TypedObject_default (NULL,"/opt/src/beast/bse/bseprobe.idl",0, "obj", BSE_TYPE_SOURCE); 00720 *(out_pspecs++) = sfidl_pspec_Int_default (NULL,"/opt/src/beast/bse/bseprobe.idl",20247104,"result"); 00721 } 00722 }; 00723 } // Procedure 00724 00725 00726 00727 /* bseprobe.idl type registrations */ 00728 #define BSE_CXX_REGISTER_ALL_TYPES_FROM_BSEPROBE_IDL() \ 00729 BSE_CXX_REGISTER_RECORD (ProbeFeatures); \ 00730 BSE_CXX_REGISTER_RECORD (Probe); \ 00731 BSE_CXX_REGISTER_RECORD (ProbeRequest); \ 00732 BSE_CXX_REGISTER_SEQUENCE (ProbeSeq); \ 00733 BSE_CXX_REGISTER_SEQUENCE (ProbeRequestSeq); \ 00734 BSE_CXX_REGISTER_PROCEDURE (source_request_probes); \ 00735 BSE_CXX_REGISTER_PROCEDURE (source_mass_request); \ 00736 BSE_CXX_REGISTER_PROCEDURE (source_get_tick_stamp); \ 00737 BSE_CXX_REGISTER_PROCEDURE (source_get_mix_freq); \ 00738 /* bseprobe.idl type registrations done */ 00739 } // Bse 00740 00741 /*-------- end ../sfi/sfidl generated code --------*/ 00742 00743