BSE Interface Reference

/opt/src/beast/bse/bsecxxmodule.hh

SYNOPSIS

class  Bse::Effect;
struct  Bse::EffectBase;
struct  Bse::IStream;
struct  Bse::JStream;
struct  Bse::OStream;
class  Bse::SynthesisModule;
struct  Bse::SynthesisModule::AutoUpdateData;
class  Bse::SynthesisModule::Closure;
class  Bse::SynthesisModule::ClosureP1;
struct  Bse::SynthesisModule::NeedAutoUpdateTag;
class  Bse::SynthesisModule::Trampoline;
class  P, NeedAutoUpdateTag >,Bse::SynthesisModule::Trampoline< M, P, NeedAutoUpdateTag >;
class  P, void >,Bse::SynthesisModule::Trampoline< M, P, void >;
   
guint64  bse_module_tick_stamp  ();

DESCRIPTION

Bse::Effect

 /opt/src/beast/bse/bsecxxmodule.hh:107
class Bse::Effect
{
  guint64 last_module_update;
    Effect  ();
  void  set_property  (prop_id, value, pspec);
  void  get_property  (prop_id, value, pspec);
  bool  is_prepared  ();
  guint  n_ichannels  ();
  guint  n_joint_ichannels  ();
  guint  n_ochannels  ();
  bool  is_joint_ichannel  (i);
  guint  ichannels_istream  (i);
  guint  ichannels_jstream  (i);
  guint  ochannels_ostream  (i);
  const gchar*  ichannel_ident  (i);
  const gchar*  ichannel_label  (i);
  const gchar*  ichannel_blurb  (i);
  const gchar*  ochannel_ident  (i);
  const gchar*  ochannel_label  (i);
  const gchar*  ochannel_blurb  (i);
  SynthesisModule*  create_module  (context_handle, trans);
  SynthesisModule::Closure*  make_module_config_closure  ();
  SynthesisModule::AutoUpdate  get_module_auto_update  ();
  void  update_modules  (trans);
  guint64  module_update_tick_stamp  ();
  void  prepare1  ();
  void  prepare2  ();
  void  reset1  ();
  void  reset2  ();
  void  class_init  (klass);
  const BseModuleClass*  create_engine_class  (sample_module, cost, n_istreams, n_jstreams, n_ostreams);
  BseModule*  integrate_engine_module  (context_handle, trans);
  void  dismiss_engine_module  (engine_module, context_handle, trans);
  unsigned int  block_size  ();
  unsigned int  max_block_size  ();
};

   
  Effect  
();

void  set_property  
(guint         prop_id,
 const Value  &value,
 GParamSpec   *pspec);

void  get_property  
(guint       prop_id,
 Value      &value,
 GParamSpec *pspec);

bool  is_prepared  
();

guint  n_ichannels  
();

guint  n_joint_ichannels  
();

guint  n_ochannels  
();

bool  is_joint_ichannel  
(guint i);

guint  ichannels_istream  
(guint i);

guint  ichannels_jstream  
(guint i);

guint  ochannels_ostream  
(guint i);

const gchar*  ichannel_ident  
(guint i);

const gchar*  ichannel_label  
(guint i);

const gchar*  ichannel_blurb  
(guint i);

const gchar*  ochannel_ident  
(guint i);

const gchar*  ochannel_label  
(guint i);

const gchar*  ochannel_blurb  
(guint i);

SynthesisModule*  create_module  
(unsigned int context_handle,
 BseTrans    *trans);

SynthesisModule::Closure*  make_module_config_closure  
();

SynthesisModule::AutoUpdate  get_module_auto_update  
();

void  update_modules  
(BseTrans *trans);

guint64  module_update_tick_stamp  
();

void  prepare1  
();

void  prepare2  
();

void  reset1  
();

void  reset2  
();

void  class_init  
(CxxBaseClass *klass);

const BseModuleClass*  create_engine_class  
(SynthesisModule *sample_module,
 int              cost,
 int              n_istreams,
 int              n_jstreams,
 int              n_ostreams);

BseModule*  integrate_engine_module  
(unsigned int context_handle,
 BseTrans    *trans);

void  dismiss_engine_module  
(BseModule *engine_module,
 guint      context_handle,
 BseTrans  *trans);

unsigned int  block_size  
();

unsigned int  max_block_size  
();

Bse::EffectBase

 /opt/src/beast/bse/bsecxxmodule.hh:106
struct Bse::EffectBase
{
};

Bse::IStream

 /opt/src/beast/bse/bsecxxmodule.hh:37
struct Bse::IStream
{
  const float *values;
  gboolean     connected;
};

Bse::JStream

 /opt/src/beast/bse/bsecxxmodule.hh:31
struct Bse::JStream
{
  const float **values;
  unsigned int  n_connections;
  unsigned int  jcount;
};

Bse::OStream

 /opt/src/beast/bse/bsecxxmodule.hh:41
struct Bse::OStream
{
  float   *values;
  gboolean connected;
};

Bse::SynthesisModule

 /opt/src/beast/bse/bsecxxmodule.hh:48
class Bse::SynthesisModule
{
  BseModule *intern_module;
    SynthesisModule  ();
  virtual  ~SynthesisModule  ();
  void  reset  ();
  void  process  (n_values);
  const ProcessCost  cost  ();
  const IStream &  istream  (istream_index);
  const JStream &  jstream  (jstream_index);
  const OStream &  ostream  (ostream_index);
  void  ostream_set  (ostream_index, values);
  const float*  const_values  (value);
  const unsigned int  mix_freq  ();
  const unsigned int  block_size  ();
  guint64  tick_stamp  ();
  BseModule*  engine_module  ();
  void  set_module  (module);
  int  dtoi  (d);
  int  ftoi  (f);
  Closure*  make_closure  (method, data);
};

   
  SynthesisModule  
();

virtual  ~SynthesisModule  
();

void  reset  
();

void  process  
(unsigned int n_values);

const ProcessCost  cost  
();

const IStream &  istream  
(unsigned int istream_index);

const JStream &  jstream  
(unsigned int jstream_index);

const OStream &  ostream  
(unsigned int ostream_index);

void  ostream_set  
(unsigned int ostream_index,
 const float *values);

const float*  const_values  
(float value);

const unsigned int  mix_freq  
();

const unsigned int  block_size  
();

guint64  tick_stamp  
();

BseModule*  engine_module  
();

void  set_module  
(BseModule *module);

int  dtoi  
(double d);

int  ftoi  
(float f);

Closure*  make_closure  
(void(C::*)(D *)method,
 const D       &data);

Bse::SynthesisModule::AutoUpdateData

 /opt/src/beast/bse/bsecxxmodule.hh:83
struct Bse::SynthesisModule::AutoUpdateData
{
  guint       prop_id;
  double      prop_value;
  guint64     tick_stamp;
  GParamSpec *pspec;
  Effect     *effect;
};

Bse::SynthesisModule::Closure

 /opt/src/beast/bse/bsecxxmodule.hh:70
class Bse::SynthesisModule::Closure
{
  void  operator()  ();
  virtual  ~Closure  ();
};

   
void  operator()  
();

virtual  ~Closure  
();

Bse::SynthesisModule::ClosureP1

 /opt/src/beast/bse/bsecxxmodule.hh:252
class Bse::SynthesisModule::ClosureP1
{
  Member func;
  P     *data;
    ClosureP1  (f, p);
  void  operator()  (p);
    ~ClosureP1  ();
};

   
  ClosureP1  
(void(T::*)(P *)f,
 P             *p);

void  operator()  
(SynthesisModule *p);

  ~ClosureP1  
();

Bse::SynthesisModule::NeedAutoUpdateTag

 /opt/src/beast/bse/bsecxxmodule.hh:91
struct Bse::SynthesisModule::NeedAutoUpdateTag
{
};

Bse::SynthesisModule::Trampoline

 /opt/src/beast/bse/bsecxxmodule.hh:93
class Bse::SynthesisModule::Trampoline
{
  void  auto_update_accessor  ();
};

   
void  auto_update_accessor  
();

bse_module_tick_stamp

 /opt/src/beast/bse/bsecxxmodule.hh:211
guint64  bse_module_tick_stamp  
();
Any thread may call this function on a valid engine module. The module specific tick stamp is updated to gsl_tick_stamp() + n_values every time its BseProcessFunc() function was called. See also gsl_tick_stamp(). This function is MT-safe and may be called from any thread.
module: a BSE Engine Module
RETURNS: the module's tick stamp, indicating its process status