Man Linux: Main Page and Category List

NAME

       bristol - a synthesiser emulation package.

SYNOPSIS

       startBristol -mini -jack -midi seq [options]

DESCRIPTION

       bristol   is   a  vintage  synthesiser  software  emulator  suite.  The
       application consists of an engine itself called bristol and a graphical
       user  interface  called  brighton.  The graphical interface is a bitmap
       manipulation library to present  the  diverse  synth  devices  such  as
       potentiometers,  buttons, sliders, patch cables and which generates the
       messages  to  configure  the  synth  emulator.   The   engine   is   an
       infrastructure  that  hosts the emulator code that couples together the
       different audio operators required to generate the  audio.  The  engine
       and GUI are started together with the startBristol script which sets up
       the required environment for the two to connect  together.  It  is  not
       generally envisaged that bristol and brighton be started outside of the
       script however there are options to the script to only start one or the
       other.  Bristol  also  has  a  command  line interface that can be used
       rather than the GUI.

       Currently following synthesizers are emulated:

       Emulations

              moog mini
              moog explorer (voyager)
              moog voyager electric blue
              moog memory
              moog sonic 6
              moog/realistic mg-1 concertmate
              hammond module (deprecated, use -b3)
              hammond B3 (default)$
              sequential circuits prophet-5
              sequential circuits prophet-5/fx
              sequential circuits prophet-10
              sequential circuits pro-one
              fender rhodes mark-I stage 73
              fender rhodes bass piano
              crumar roadrunner electric piano
              crumar bit 01
              crumar bit 99
              crumar bit + mods
              crumar stratus synth/organ combo
              crumar trilogy synth/organ/string combo
              oberheim OB-X
              oberheim OB-Xa
              arp axxe
              arp odyssey
              arp 2600
              arp/solina string ensemble
              korg polysix
              korg poly-800
              korg mono/poly
              korg ms20 (unfinished: -libtest only)
              vox continental
              vox continental super/300/II
              roland juno-60
              roland jupiter-8
              baumann bme-700
              bristol bassmaker sequencer
              yamaha dx-7
              yamaha cs-80 (unfinished)
              commodore-64 SID chip synth
              commodore-64 SID polyphonic synth (unfinished)
              granular synthesiser (unfinished)
              ems synthi-a (unfinished)
              16 track mixer (unfinished: -libtest only)

       The connection between the engine and GUI is a TCP socket using a SYSEX
       format  message  taken  from MIDI. The GUI and engine do not need to be
       resident on the same system  if  suitable  parameters  are  given.  The
       engine  can  also accept requests from multiple brighton interfaces and
       run all the emulators at the same time, multitimbraly,  sharing  voices
       between them and pre-empting where necessary. If an emulator is started
       in monophonic mode then it is preallocated a voice that will  never  be
       pre-empted  and  which  runs  continuously, ie, it will continue to run
       even when no piano keys are pressed. The polyphonic code will only  run
       the  voice  algorithms  whilst  the  key  gate  is open, the gate being
       derived from the voice envelope state. The engine supports minimally 32
       voices  per default, if an emulator requests less then its emulation is
       configured with a soft limit. If more are requested  then  more  voices
       are  created. A voice is an engine structure that allows for allocation
       and executing, the actual code run  by  a  voice  can  be  any  of  the
       emulator  algorithms  which is how multitimbral operation is supported.
       The voice allocation process  is  'last  note  precedence'  and  whilst
       others  are  available for the monophonic instruments, this is the only
       polyphonic assignment algorithm.

       This package should be started with the startBristol script. The script
       will  start up the bristol synthesiser binaries, evaluating the correct
       library paths and executable paths. There  are  emulation,  synthesiser
       and operational parameters:

OPTIONS

       Emulation:

              -mini              - moog mini
              -explorer          - moog voyager
              -voyager           - moog voyager electric blue
              -memory            - moog memory
              -sonic6            - moog sonic 6
              -mg1               - moog/realistic mg-1 concertmate
              -hammond           - hammond module (deprecated, use -b3)
              -b3                - hammond B3 (default)
              -prophet           - sequential circuits prophet-5
              -pro52             - sequential circuits prophet-5/fx
              -pro10             - sequential circuits prophet-10
              -pro1              - sequential circuits pro-one
              -rhodes            - fender rhodes mark-I stage 73
              -rhodesbass        - fender rhodes bass piano
              -roadrunner        - crumar roadrunner electric piano
              -bitone            - crumar bit 01
              -bit99             - crumar bit 99
              -bit100            - crumar bit + mods
              -stratus           - crumar stratus synth/organ combo
              -trilogy           - crumar trilogy synth/organ/string combo
              -obx               - oberheim OB-X
              -obxa              - oberheim OB-Xa
              -axxe              - arp axxe
              -odyssey           - arp odyssey
              -arp2600           - arp 2600
              -solina            - arp/solina string ensemble
              -polysix           - korg polysix
              -poly800           - korg poly-800
              -monopoly          - korg mono/poly
              -ms20              - korg ms20 (unfinished: -libtest only)
              -vox               - vox continental
              -voxM2             - vox continental super/300/II
              -juno              - roland juno-60
              -jupiter           - roland jupiter-8
              -bme700            - baumann bme-700
              -bm                - bristol bassmaker sequencer
              -dx                - yamaha dx-7
              -cs80              - yamaha cs-80 (unfinished)
              -sidney            - commodore-64 SID chip synth
              -melbourne         - commodore-64 SID polysynth (unfinished)
              -granular          - granular synthesiser (unfinished)
              -aks               - ems synthi-a (unfinished)
              -mixer             - 16 track mixer (unfinished: -libtest only)

       Synthesiser:

       -voices <n>
              The selected emulator will start with this number of voices. The
              engine will always create  32  voices  but  only  allocate  this
              subset to the emulator. If the selected value is greater than 32
              then the greater number of voices is allocated.

       -mono  Run the emulator in monophonic mode. This is not really an alias
              for '-voices 1' as it additionally configures parameters such as
              '-retrig -lvel -wwf -hnp'.   These  additional  options  can  be
              overridden if desired.

       -lnp   Select   low   note  precedence  logic.  This  only  applies  to
              monophonic synthesisers and all of the  note  precedence  affect
              the legato playing style.

       -hnp   Select   high  note  precedence  logic.  This  only  applies  to
              monophonic synthesisers.

       -nnp   Select no note precedence, this is the default and operates as a
              last note precedence selection.

       -retrig
              Request  a  trigger event for each note that is played AND notes
              that are released. The  trigger  will  cause  the  envelopes  to
              cycle.  They  will not return to zero by default however some of
              the emulations have that as a GUI control.   Without  this  flag
              triggers are only sent for the first pressed note of a sequence.

       -lvel  Configure velocity inheritance for all legato notes - the  first
              note of a sequence will have a velocity value that is applied to
              all subsequent notes.  This option is a toggle:  applying  twice
              will  disable the feature. This is important with regards to the
              emulators as many of the mono synths with set lvel per  default.
              The following options may not work as expected:

              startBristol -mini -lvel

              The  issue  is  that  -mini enables legato velocity so the -lvel
              switch will toggle it off again. The same applies to -retrig.

       -channel <c>
              Start the emulator to respond on this MIDI channel, default 1.

       -lowkey <n>
              Configure the lowest note for which the emulator should respond.
              This  defaults  to  '0' but can be used to define key splits and
              ranges for different synths.

       -highkey <n>
              Configure  the  highest  note  for  which  the  emulator  should
              respond.  This  defaults  to '127' but can be used to define key
              splits and ranges for different synths.

       -detune <%>
              Request  the  emulator  run  with   a   level   of   temperature
              sensitivity.  The  default  value  is  defined  by the emulator,
              typically 100 or 200. The detune is applied to a voice  at  note
              on only and is a random value within the range defined here.

       -gain <gn>
              Output  signal gain level for the emulator. These can be used to
              normalise the signal levels from different  synths  when  played
              together. The default value is defined by the synth itself, this
              is an override.

       -pwd <s>
              Pitch wheel depth in semitones, default 2.

       -velocity <v>
              Velocity curve for the emulator. Default is 520, an  exponential
              curve  for  a  hard  playing  style. Value '0' is flat (no touch
              sensitivity). Values up to 100 are linear scaled maps. Below 200
              are  then  exponential  maps,  below  500  a quadratic maps from
              linear  and  from  500  to  525  are  soft  through  hard  touch
              exponential maps.

       -glide <s>
              Duration of nogte glide in seconds, default 5.

       -emulate <name>
              Search  for  the  named  emulator and invoke it, otherwise exit.
              Invoking an emulation this was  is  currently  the  default,  it
              implies extra parameters for voicecount, gain, glide, pitchwheel
              depth, detune, etc.  The  default  is  hammondB3.  The  -emulate
              option also implies -register to the emulator name.

       -register <name>
              Use  a  specific  name  when  registering with Jack and ALSA. By
              default the engine will use the name 'bristol' however this  can
              be  confusing if multiple engines are being used and this can be
              used to override the default.

       -lwf   Select lightweight filters for the emulator.

       -nwf   Select normalweight filters, the default. These are about  twice
              as expensive as lightweight filters.

       -wwf   Select welterweight filters, this are again about double the CPU
              load as the normal filters.

       -hwf   Select  heavyweight  filters.  These  are  roughly   twice   the
              welterweight  filter.   Whilst  their  is  a  noticable  audible
              difference between -lwf and -nwf, it is  debatable  whether  the
              difference  between -nwf, -wwf and -hwf is other than visible in
              the CPU load. The default filter for any  -mono  synth  is  -wwf
              which  can be overridden with something line '-mini -mono -nwf'.

       -blo <h>
              Number of bandwidth limited harmonics to map. The value of  zero
              will select infintite bandwidth, default is 31.

       -blofraction <f>
              The engine uses precomputed tables for all frequencies where the
              maximum  harmonic  does  not  exceed  this   fraction   of   the
              samplerate.  The  default,  0.8,  is  already above nyquist as a
              tradeoff betweeen content and distortion. Values tending towards
              1.0 are heavily aliased at the higher frequencies naturally.

       -scala <file>
              The  engine  will  read the given scala file and map it into its
              frequency tables.

       User Interface:

       -quality <n>
              The color cache depth will affect the rendering speed. The lower
              values  start  showing  loss of clarity, the higher values start
              using thousands of colors which  is  where  the  performance  is
              affected, value is bpp, default is 6.

       -scale <s>
              Each  of the emulators has a default window sisze, this size can
              be scaled up or downwards if desired.

       -width <n>
              The pixel width defines the smaller of two sizees  that  can  be
              configured.  It  works with the -scale and -autozoom options for
              flipping between different sizes on  mouse  Enter/Leave  of  the
              window.

       -autozoom
              Minimise window on exit, maximise on enter.

       -raise Automatically raise the window on Enter.

       -lower Automatically  lower  the window on Leave. It is noted here that
              the use of  autozoom,  raise  and  lower  may  have  undesirable
              effects with some window managers.

       -rud   Constrain  the  rotary  controller  tracking  to  mouse  up/down
              motion, not to actually track the mouse position. The value will
              be a fraction of the current window size.

       -antialias <%>
              For  some  window sizes there will be pixelation of the rendered
              imagas unless some antialias is applied. With large zoom  values
              this  is automatically set up. Value is a percentage, default is
              30.

       -aliastype <pre/texture/all>
              There are three antialiasing options, 'pre' will apply it to the
              text silkscreens, 'texture' will apply it to the surface bitmaps
              and 'all' will apply it everywhere including  devices  rendered.
              The  default  is  pre  however this parameter is only applied if
              -antialias has a value other than zero.

       -opacity <%>
              Brighton uses a transparency layer for some features such as the
              ARP  2600 patch cables. This is the default transparency. It can
              be adjusted later with the ^o/^O/^t control codes  in  the  GUI.
              Default is 50 percent.

       -pixmap
              Use  the  X11  pixmap  interface  rather than the default XImage
              interface to the server.

       -dct <ms>
              Double click timeout for button events, etc, 250 ms.

       -tracking
              Prevent the GUI piano keyboard image from tracking MIDI  events,
              small reduction in CPU overhead.

       -load <m>
              Initial  memory number to load at startup. Default is 0 for most
              emulators.

       -import <pathname>
              Import a memory from a disk file to the active  patch  at  start
              time.  This  patch  can  then  be  saved to another location and
              allows for interexchange of memories.

       -mbi <m>
              The master bank index allows for access to extra memory ID. This
              value  times  1000 is added to the memory ID saved/loaded by the
              GUI so the GUI can access for example 8 banks of 8 memories  but
              using -mbi you can actually save multiple sets of 64 memories.

       -activesense <ms>
              The  rate at which hello messages are sent from GUI to engine to
              ensure it is still active. If the transmission  fails  then  the
              GUI  will  exit,  if the engine does not receive updates it will
              also exit. Zero will disable active sense.

       -ast <m>
              The engine timeout period on active sense messages.

       -mct <m>
              The MIDI cycle timeout is a busy  waiting  GUI  timer  for  MIDI
              events,  used  when  the  GUI  takes a MIDI interface for direct
              event tracking.

       -ar|-aspect
              All of the emulators will attempt to maintain  an  aspect  ratio
              for  their  windows  so  that they look 'normal'. This conflicts
              with some tiling window managers so can be disabled. It may also
              cause some excessive remapping of windows when they are resized.

       -iconify
              Open the window in the iconified state.

       -window
              Do not map any window.

       -cli   Enable the text based command line interface to the engine. This
              can  be  used  in  connjuction  with -window however if compiled
              without support for any windowing system the -window  option  is
              implied.

       -libtest
              Do not start the engine, nor attempt to connect to it, just post
              the GUI for testing.

       GUI Shortcuts:

              <Ctrl> 's'     - save settings to current memory
              <Ctrl> 'l'     - (re)load current memory
              <Ctrl> 'x'     - exchange current with previous memory
              <Ctrl> '+'     - load next memory
              <Ctrl> '-'     - load previous memory
              <Ctrl> '?'     - show emulator help information
              <Ctrl> 'h'     - show emulator help information
              <Ctrl> 'r'     - show application readme information
              <Ctrl> 'k'     - show keyboard shortcuts
              <Ctrl> 'p'     - screendump to /tmp/<synth>.xpm
              <Ctrl> 't'     - toggle opacity
              <Ctrl> 'o'     - decrease opacity of patch layer
              <Ctrl> 'O'     - increase opacity of patch layer
              <Ctrl> 'w'     - display warranty
              <Ctrl> 'g'     - display GPL (copying conditions)
              <Shift> '+'    - increase window size
              <Shift> '-'    - decrease window size
              <Shift> 'Enter'- toggle window between full screen size
              UpArrow        - controller motion up (shift key accelerator)
              DownArrow      - controller motion down (shift key accelerator)
              RightArrow     - more control motion up (shift accelerator)
              LeftArrow      - more control motion down (shift accelerator)

       Operational options:

       General:

       -engine
              Do not start a new engine. The GUI will attempt to connect to an
              existing  engine on the host and port configuration (cq). If the
              connection is built then the engine will operate both emjulators
              and  voice  allocations  will be shared amongst them. All of the
              emulator outputs are folded back onto the  same  stereo  output,
              excepting where extra Jack control inputs are used.

       -gui   Do  not  start the GUI, only the engine. The GUI will attempt to
              connect to the engine on the configured host and port values. If
              it  does  not  respond  then  the GUI will exit with some rather
              terse messaging.

       -server
              Start the engine as a permanant server that does not  exit  with
              the last emulator.

       -daemon
              Run  the  engine  as  a  daemon  with  disconnected  controlling
              terminal. This does not imply the -server option,  nor  does  it
              imply  the  -log  option  for  logging  to  the file system, nor
              -syslog which might also be applicable to a daemon.

       -log   Redirect  logging  output  to  a  file.  The  default  file   is
              /var/log/bristol.log  and  /var/log/brighton.log and if they are
              not available then $HOME/.bristol/log  directory  is  used.  The
              selection  is  to  prevent logging to root in the event that the
              engine is invoked by this user.

       -syslog
              Redirect logging output to syslog.

       -console
              Maintain  the  controlling  terminal  as  output   for   logging
              messages,  remove the timestampes for readability purposes. This
              can  also  be   configured   with   the   environment   variable
              BRISTOL_LOG_CONSOLE=true.

       -exec  The  final  process  to  be requested by the startBristol script
              will be called as an exec such that it maintains  amongst  other
              things the PID of the parent. This option will override the exec
              and leave the script waiting for the processes to exit.

       -stop  Stop all the  running  bristol  engines.  This  will  indirectly
              result  in termination of any GUI due to active sensing although
              that can be disabled. The  use  case  is  to  stop  any  -server
              -daemon  engines  running in the background. The back end to the
              option is pkill.

       -exit  Stop all the running bristol engines and GUI.

       -kill <-emulator>
              Stop all the running bristol engines  and  GUI  that  have  been
              associated  with the given emulator. If bristol was started with
              '-mini' it can now be killed with -mini so that other  emulators
              are not terminated. If there are multiple mini running they will
              naturally die also. If the engine is  running  multitimbral  GUI
              then  the other associated GUI will also exit in addition to the
              mini.

       -cache <pathname>
              The default location for new memories and emulator profiles, the
              default  is  ~/.bristol  and  it  will  be  searched  before the
              system/factory default directory  /usr/local/share/bristol  when
              emulators  are  started and memories are loaded. If the pathname
              does not exist then it is created if possible.

       -debug <1-16>
              Debug level, values above 12 can be very verbose  and  only  the
              value  0  is arguably realtime safe as it avoids printf() in the
              engine compute thread.

       -readme [-<e>]
              Display the program readme information. Show the readme for just
              a single emulator if desired.

       -glwf  Only allow the use of '-lwf' for all emulators, no overrides.

       -host <hostname>
              Connect  to  the  engine  on the hostname, default is localhost.
              This is used in conjuction with -engine to distribute  the  GUI.
              The  hostname  should accept syntax such as hostname:port as per
              the next option.

       -port <p>
              Connect to the given TCP port for GUI/engine messaging,  default
              5028. If the port is alreeady in use then the startup with fail.
              For starting multiple bristols with GUI then this option  should
              be discarded and the script will look for a free port number for
              each invocation.

       -quiet Redirect debug and diagnostic output to /dev/null.

       -gmc   Open a MIDI interface in the GUI. Per default  the  engine  will
              own  the  only  MIDI interface for bristol and will redistribute
              events to the GUI. It is possible to disable the forwarding  and
              attach both GUI and engine to midi devices if necessary.

       -forward
              Disable  MIDI  event forwarding globally. Per default the engine
              opens  a  MIDI  interface  and  is  connected  to  the  physical
              keyboards,  control  surfaces and/or sequencers. It will forward
              MIDI events to the GUI for tracking. This  option  disables  the
              feature.  When  disabled  the  GUI  will  not  reflect the piano
              keybaord state, nor will it track CC motion unless  the  options
              '-gmc'  is  given  to open a MIDI connection in the GUI and that
              the user connects the same control surfaces to the GUI via  this
              alternative  channel.  This  option  is  logically  identical to
              '-localforward -remoteforward'.

       -localforward
              This will prevent the GUI from forwarding MIDI messages  to  the
              engine.  This  is  not  to  prevent  MIDI  message  loops as the
              forwarding  only  ever  occurs  from  MIDI  interfaces  to   TCP
              connections  between  GUI  and  engine. This option will prevent
              messages from any surfaces that are connected to  the  GUI  from
              forwarding to the engine.

       -remoteforward
              This  will  prevent  the  engine  from forwarding to the GUI but
              still allow the GUI to forward to the  engine.  If  the  GUI  is
              given  a  MIDI  connection  with  the  -gmc  option, and control
              surfaces are applied to both processes then the -forward  option
              should be used to globally prevent event redistribution. Failure
              to do so will not result in loops, just one-for-one  duplication
              of  events.  It is possible to connect the control surfaces just
              to the GUI  when  the  -gmc  option  is  used,  this  gives  the
              possibility to have a local keyboard and GUI but drive an engine
              on a remote systems.  Their  is  admittedly  additional  latency
              involved  with  handling  the  MIDI messages from the GUI to the
              remote engine over TCP.

       -oss   Configure OSS defaults for audio and MIDI interfaces

       -alsa  Configure ALSA defaults for audio and MIDI interfaces. The  MIDI
              interface is an ALSA SEQ port.

       -jack  Configure  Jack  defaults  for audio and MIDI interfaces. At the
              time of writing this option causes some  issues  as  it  selects
              Jack MIDI which currently requires a bridging daemon to operate.
              The  options  '-jack  -midi  seq'  would  be  a   more   typical
              configuration.

       -jsmuuid <UUID>
              This is for sole use of the Jack Session Manager

       -jsmfile <path>
              This is for sole use of the Jack Session Manager

       -jsmd <ms>
              Jack session manager delay before session events are distributed
              internally.  Event execution is delayed in the GUI by a  default
              of 5000ms.

       -session
              Disable all session management including JSM and LADI.

       -sleep <n>
              Stall  the  initialisation  process  for 'n' seconds. This is to
              work around what appears to be race a  condition  when  using  a
              session  manager  to initialise multiple bristol clients as they
              all vie for the same TCP port identifier.

       -jdo   Jack Dual Open: let the  audio  and  midi  threads  register  as
              independent clients with Jack. Per default the audio thread will
              open as a jack client and the MIDI connection is piggypbacked as
              another port rather than as another client.

       -o <filename>
              Generate  a  raw  audio  output  of the final stage samples to a
              file. The format will be 16bit stereo interleaved.

       -nrp   Enable support for NRP events in both GUI and engine. This is to
              be  used  with  care  as  NRP  in the engine can have unexpected
              results.

       -enrp  Enable NRP support in the engine only.

       -gnrp  Enable NRP events in the GUI. This is required to allow the  GUI
              (and  hence  the  engine)  to  be  driven from some MIDI control
              surfaces.

       -nrpcc <n>
              Maximum number of NRP to  map.  The  default  is  128,  seen  as
              sufficient  for  any of the current emulators but the mixer will
              require more if it is every released.

       Audio driver:

       -audio [oss|alsa|jack]
              Audio driver overrides. Depending on the order of  the  switches
              it   is   possible   to   set   a   group   of  global  defaults
              (-jack/oss/alsa) then have specific re-selection of  components.

       -audiodev <dev>
              Audio  device  name.  For Jack, this will be the name registered
              with the Jack daemon.

       -count <samples>
              Number of samples/frames in processing period.

       -outgain <gn>
              Output signal normalisation level, per emulator default 4.

       -ingain <gn>
              Input signal normalisation level, per emulator default 4.

       -preload <periods>
              Number of audio buffers to  prewrite  to  the  audio  output  on
              start. This is not active with the Jack drivers.

       -rate <hz>
              Sampling rate, defaults to 44100.

       -priority <p>
              Realtime  priority requested by the engine audio thread, default
              75. Zero will disable RT processing.

       -autoconn
              Automatically connect the engine input and output to  the  first
              Jack  IO  ports  found.  This  can  also  be  achieved  with the
              environment variable BRISTOL_AUTOCONN=true

       -multi <c>
              Multiple IO port requests, only works with  Jack  and  currently
              only the ARP 2600 gives access to these ports.

       -migc <f>
              Input signal normalisation level for the multi IO ports.

       -mogc <f>
              Output signal normalisation level for the multi IO ports.

       Midi driver:

       -midi [oss|[raw]alsa|jack]
              Audio  driver  overrides. Depending on the order of the switches
              it  is  possible   to   set   a   group   of   global   defaults
              (-jack/oss/alsa)  then  have specific re-selection of components
              such as in '-jack -midi seq'. The default MIDI driver is  '-midi
              seq' but that can be overriden with compile time options such as
              --enable-jack-default-midi to ./configure.

       -mididev <dev>
              MIDI device namee to be opened (OSS/ALSA).

       -mididbg
              Request MIDI level 1 debuging.

       -mididbg2
              Request MIDI level 2 debuging. Both can be selected for level 3.

       -sysid <0xXXXXXXXX>
              Configure  an  alternative  SYSEX identifier for the engine. The
              default is the value 0x534C6162 for historical reasons, this  is
              not  a  free development ID but it is not assigned so should not
              cause conflict.

       LADI driver (level 1 compliant):

       -ladi brighton
              Execute LADI messages in the GUI only

       -ladi bristol
              Execute LADI messages in the engine only

       -ladi <memory>
              The LADI state memory for save operations. This should be unique
              for each LADI session.

EXAMPLES

       startBristol -mini
              Run  a  minimoog  using ALSA interface for audio and midi (seq).
              The emulator will default to monophonic,  high  note  precedence
              with retrigger and legato velocity.

       startBristol -alsa
              Run a hammondB3 using ALSA interface for audio and midi. This is
              equivalent  to  all  the  following  options:  -b3  -audio  alsa
              -audiodev  plughw:0,0  -midi  seq -mididev plughw:0 -samplecount
              256 -preload 4 -port 5028 -voices 32 -channel 1 -rate 44100

       startBristol -explorer -voices 1
              Run a moog explorer  as  a  monophonic  instrument,  using  ALSA
              interface for audio and midi.

       startBristol -prophet -alsa -channel 3
              Run a prophet-5 using ALSA for audio and midi (on channel 3).

       startBristol -b3 -samplecount 512 -preload 2
              Run a hammond b3 with a 512 samples in a period, and preload two
              such buffers before going active. Some  Live!  cards  need  this
              larger buffer size with ALSA drivers.

       startBristol -oss -audiodev /dev/dsp1 -vox -voices 8
              Run  a  vox  continental  using  OSS  device 1, and default midi
              device /dev/midi0.  Operate with just 8 voices  out  of  the  32
              available.

       startBristol -b3 -audio alsa -audiodev plughw:0,0 -seq -mididev 128.0
              Run  a  B3 emulation over the ALSA PCM plug interface, using the
              ALSA sequencer over client 128, port 0.

       startBristol -juno &

       startBristol -prophet -channel 2 -engine
              Start two synthesisers, a juno and a prophet. Both  synthesisers
              will  will  be  executed  on  one  engine (multitimbral) with 32
              voices between them. The juno will be on  default  midi  channel
              (1),  and the prophet on channel 2. Output over the same default
              ALSA audio device. The 32 voices will  never  all  get  used  as
              these  emulators  will  run per default with a lower soft limit.
              They can be run with more  voices  however  that  would  require
              suitable values to the -voices option.

       startBristol -juno -jack -register juno -voices 32 &

       startBristol -prophet -jack -register prophet -channel 2 -voices 32 &
              Start  two  synthesisers,  a  juno and a prophet5. Each synth is
              totally independent with its own GUI and own engine. Each engine
              will  register  separately  with  the  jack  daemon.  They  will
              respectively register the names 'juno' and 'prophet'  with  Jack
              and  ALSA  so  that they can be differentiated in the respective
              control programmes such as aconnect and  qjackctl.  The  outputs
              will  be  visible  separately  in these control programs and can
              thus be routed independently. Each synth can use up to 32 voices
              and  there  will  only  be  CPU  contention - these are separate
              engine process with 32 voices each.

AUTHOR

       Written by Nicholas Copeland <nickycopeland@hotmail.com>

REPORTING BUGS

       Bugs and enhancement requests can be submitted to the  bristol  project
       page on SourceForge:

       <https://sourceforge.net/tracker/?group_id=157415>

COPYRIGHT

       Copyright   1996,2010  Nick Copeland. License GPLv3+: GNU GPL version 3
       or later <http://gnu.org/licenses/gpl.html>. This is free software: you
       are  free  to  change and redistribute it. There is NO WARRANTY, to the
       extent permitted by law.

                                 May  11, 2010