bse-structures(3)

NAME

BSE-Structures - BSE Structure Reference

Document Revised: Wed May 25 23:38:24 2005

SYNOPSIS

record  BseCategory;
record  BseDot;
record  BseGConfig;
record  BseIcon;
record  BseMessage;
record  BseMidiChannelEvent;
record  BseNoteDescription;
record  BseNoteSequence;
record  BsePartControl;
record  BsePartLink;
record  BsePartNote;
record  BseProbe;
record  BseProbeFeatures;
record  BseProbeRequest;
record  BsePropertyCandidates;
record  BseSampleFileInfo;
record  BseSongTiming;
record  BseThreadInfo;
record  BseThreadTotals;
record  BseTrackPart;
sequence  BseCategorySeq;
sequence  BseDotSeq;
sequence  BseIntSeq;
sequence  BseItemSeq;
sequence  BseNoteSeq;
sequence  BsePartControlSeq;
sequence  BsePartLinkSeq;
sequence  BsePartNoteSeq;
sequence  BseProbeRequestSeq;
sequence  BseProbeSeq;
sequence  BseStringSeq;
sequence  BseThreadInfoSeq;
sequence  BseTrackPartSeq;
sequence  BseTypeSeq;

DESCRIPTION

sequence BseThreadInfoSeq {
guint n_thread_infos; C language
specific number of elements
BseThreadInfo** thread_infos; thread-infos
};
sequence BseTrackPartSeq {
guint n_tparts; C language specific
number of elements
BseTrackPart** tparts; tparts
};
sequence BsePartLinkSeq {
guint n_plinks; C language specific
number of elements
BsePartLink** plinks; plinks
};
sequence BseDotSeq {
guint n_dots; C language specific number of
elements
BseDot** dots; dots
};
sequence BseCategorySeq {
guint n_cats; C language specific num
ber of elements
BseCategory** cats; cats
};
sequence BsePartControlSeq {
guint n_pcontrols; C language spe
cific number of elements
BsePartControl** pcontrols; pcontrols
};

A list of part control events
sequence BsePartNoteSeq {
guint n_pnotes; C language specific
number of elements
BsePartNote** pnotes; pnotes
};

A list of part notes
sequence BseItemSeq {
guint n_items; C language specific number
of elements
SfiProxy* items; items
};

A list of BSE items or derived types.
sequence BseNoteSeq {
guint n_notes; C language specific number of
elements
SfiInt* notes; Note
};
sequence BseStringSeq {
guint n_strings; C language specific
number of elements
const gchar** strings; strings
};
sequence BseTypeSeq {
guint n_types; C language specific
number of elements
const gchar** types; types
};
sequence BseIntSeq {
guint n_ints; C language specific number of
elements
SfiInt* ints; ints
};
record BseGConfig {
const gchar* sample_path; Search path
of directories, seperated by ":", used to find audio samples.
const gchar* effect_path; Search path
of directories, seperated by ":", used to find BSE effect files.
const gchar* instrument_path; Search path
of directories, seperated by ":", used to find BSE instrument
files.
const gchar* script_path; Search path
of directories, seperated by ":", used to find BSE scheme
scripts.
const gchar* plugin_path; Search path
of directories, seperated by ":", used to find BSE plugins. This
path is searched for in addition to the standard BSE plugin loca
tion on this system.
const gchar* ladspa_path; Search path
of directories, seperated by ":", used to find LADSPA plugins.
This path is searched for in addition to the standard LADSPA lo
cation on this system. LADSPA is the Linux Audio Developer's Sim
ple Plugin API, more informations about LADSPA plugins can be
found at http://www.ladspa.org/.
SfiInt synth_latency; Processing
duration between input and output of a single sample, smaller
values increase CPU load
SfiInt synth_mixing_freq; Synthesis
mixing frequency, common values are: 22050, 44100, 48000
SfiInt synth_control_freq; Frequency at
which control values are evaluated, should be much smaller than
Synth Mixing Frequency to reduce CPU load
SfiBool invert_sustain; Invert the
state of sustain (damper) pedal so on/off meanings are reversed
SfiReal step_volume_d_b; Step width
for volume in decibel
SfiInt step_bpm; Step width
for beats per minute
};
record BseThreadTotals {
BseThreadInfo* main; main BseThreadInfo* sequencer; sequencer BseThreadInfoSeq* synthesis; synthesis
};
record BseThreadInfo {
const gchar* name; Thread Name SfiChoice state; The execution state of
the thread
SfiInt thread_id; A unique number iden
tifying this thread
SfiInt priority; The nice value of a
thread, -20 indicates a high priority thread and +19 a low prior
ity one that is 'nice' to others
SfiInt processor; The processor that
this thread is currently being executed on
SfiInt utime; The CPU time spent ex
ecuting instructions of this thread
SfiInt stime; The CPU time spent in
the system for this thread
SfiInt cutime; The CPU time spent ex
ecuting instructions of children of this thread
SfiInt cstime; The CPU time spent in
the system for children of this thread
};
record BseMessage {
const gchar* log_domain; log-domain SfiChoice type; type
const gchar* ident; ident const gchar* label; label const gchar* title; title const gchar* primary; primary const gchar* secondary; secondary const gchar* details; details const gchar* config_check; config-check SfiProxy janitor; janitor const gchar* process; process SfiInt pid; pid
};
record BseSampleFileInfo {
const gchar* file; Filename SfiInt size; File Size
SfiNum mtime; Modification Time const gchar* loader; Loader BseStringSeq* waves; waves SfiInt error; BseErrorType
};
record BseSongTiming {
SfiInt tick; Current tick
SfiReal bpm; Beats per minute
SfiInt numerator; Number of notes per mea
sure
SfiInt denominator; Type of notes counted per
measure
SfiInt tpqn; Ticks per quarter note SfiInt tpt; Ticks per tact
SfiReal stamp_ticks; Ticks per stamp increment
(valid only during playback)
};
record BseTrackPart {
SfiInt tick; Tick
SfiProxy part; part
SfiInt duration; Duration
};
record BsePartLink {
SfiProxy track; track
SfiInt tick; Tick
SfiProxy part; part
SfiInt duration; Duration
};
record BseDot {
SfiReal x; x
SfiReal y; y
};
record BseCategory {
SfiInt category_id; Category ID const gchar* category; category SfiInt mindex; mindex
SfiInt lindex; lindex
const gchar* type; type BseIcon* icon; icon
};
record BseIcon {
SfiInt bytes_per_pixel; Bytes Per Pixel
(3:RGB, 4:RGBA, 0:NONE)
SfiInt width; Width in pixels or
0 for no icon
SfiInt height; Height in pixels
or 0 for no icon
SfiBBlock* pixels; Pixel array of
width*height*bytes_per_pixel bytes
};

BSE icon representation.
record BseNoteSequence {
SfiInt offset; Center/base note BseNoteSeq* notes; Sequence of notes
};
record BseNoteDescription {
SfiInt note; Note
SfiInt octave; Octave SfiReal freq; Frequency SfiInt fine_tune; Fine Tune SfiInt semitone; Semitone SfiBool upshift; upshift SfiInt letter; International ab
breviation letter for this note
const gchar* name; Name SfiInt max_fine_tune; Max Fine Tune SfiInt kammer_note; Kammer Note
};

A note description provides all necessary details
about a specific note. Various procedures exist to retrieve a
note description; given different key values. The max_fine_tune
and kammer_note fields are constants; which are provided for com
patibility reasons and will vanish in future APIs.
record BsePartControl {
SfiInt id; ID
SfiInt tick; Tick
SfiChoice control_type; control-type SfiReal value; Value
SfiBool selected; Selected
};

Part specific control event representation
record BsePartNote {
SfiInt id; ID
SfiInt channel; Channel
SfiInt tick; Tick
SfiInt duration; Duration in number of ticks SfiInt note; Note
SfiInt fine_tune; Fine Tune SfiReal velocity; Velocity
SfiBool selected; Selected
};

Part specific note representation
record BsePropertyCandidates {
const gchar* label; label const gchar* tooltip; tooltip BseItemSeq* items; items BseTypeSeq* partitions; List of types which
may logically partition the list of items by type discrimination
};

A strcuture describing tentative property values.
record BseMidiChannelEvent {
SfiChoice event_type; event-type SfiInt channel; Channel
SfiNum tick_stamp; Time Stamp SfiReal frequency; Frequency SfiReal velocity; Velocity SfiInt control; Control Number SfiReal value; Value
SfiInt program; Program
SfiReal intensity; Intensity SfiReal pitch_bend; Pitch Bend SfiInt song_pointer; Song Pointer SfiInt song_number; Song Number
};
sequence BseProbeRequestSeq {
guint n_probe_requests; C language
specific number of elements
BseProbeRequest** probe_requests; probe-re
quests
};
sequence BseProbeSeq {
guint n_probes; C language specific num
ber of elements
BseProbe** probes; probes
};
record BseProbeRequest {
SfiProxy source; source SfiInt channel_id; channel-id SfiInt block_size; block-size BseProbeFeatures* probe_features; probe-fea
tures
};
record BseProbe {
SfiInt channel_id; channel-id SfiNum block_stamp; block-stamp BseProbeFeatures* probe_features; probe-fea
tures
SfiReal mix_freq; mix-freq SfiReal min; min
SfiReal max; max
SfiReal energie; energie SfiFBlock* sample_data; sample-data SfiFBlock* fft_data; fft-data
};
record BseProbeFeatures {
SfiBool probe_range; probe-range SfiBool probe_energie; probe-energie SfiBool probe_samples; probe-samples SfiBool probe_fft; probe-fft
};

SEE ALSO

BSE Procedures (bse-procs(3))

Document Revised: Wed May 25 23:38:24 2005
BEAST-0.6.6 25 May 2005 BSE

Structures(3)

Copyright © 2010-2025 Platon Technologies, s.r.o.           Index | Man stránky | tLDP | Dokumenty | Utilitky | O projekte
Design by styleshout