Back to start page
[Introduction] [Developers] [Links] [Manual] [Screenshots]
[This page is only available in English.]

The GLAME Manual

Next: , Up: (dir)

The GLAME Manual

This text documents GNU/Linux Audio Mechanics (GLAME) Version 2.0.1 (28 March 2005), a capable and easily extensible free sound editor. It describes the various frontends from a user's perspective.

More recent versions of this document as well as additional information about GLAME might be available via the project's homepage at

This document is also available as a PDF file:

Copyright © 2000-2005 Richard Günther, Daniel Kobras, Alexander Ehlert, Johannes Hirche. See Copying, for details.

==How to handle the various GLAME frontends==


Next: , Previous: Top, Up: Top

1 Copying

Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies.

Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also that the sections entitled “Copying” and “GNU General Public License” are included exactly as in the original, and provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one.

Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Free Software Foundation.

Next: , Previous: Copying, Up: Top

2 Quick Start Guide

Moi Mr. Newcomer, hi Mrs. Impatient!

Welcome to GLAME, the GNU/Linux Audio Mechanics. This is the Quick Start Guide for all those who loathe reading lengthy documentation. So I won't fuzz with details but try to get you going on basic tasks as fast as possible.

GLAME comes in two flavours, the graphical interface glame and the console frontend called cglame. You'll have to be able to grok Scheme in order to deal with cglame. It's extremely cool and powerful but it's probably not what you are looking for when reading a quick start guide. So let's talk about the graphical interface in the following, and send those Schemers off to poke through the proper documentation.

Next: , Up: Quick Start Guide

2.1 A Quick Start to Editing Files

So you recorded this charming little chanson called Angelina, but she ditched you the other day and now dates Ron instead? No need to keep waiting until another Angelina passes your way. GLAME will help you changing your Angelina tune into a hymn on Heather in an instant. (Admit it, you've been after Heather for ages!)

Fire up glame, ignore the crappy splash screen, and what you'll see is the so-called Swapfile GUI. Don't waste your time pondering about the name, it's simply a view of all audio tracks that GLAME knows about. Tracks are kept in a hierarchy of projects and further groups of tracks. To make your sweet angelina.wav known to GLAME, first select New Project from the Project menu. A new entry appears; name it No More Angelina. Then click the right mouse button on the new entry, and a pop-up menu does what its name suggests: it pops up right in front of you. Choose the entry called Import, and select your angelina.wav. It's a stereo file, of course. Therefore the Swapfile GUI now shows two entries within your Angelina project, one for each track. Now you're all set to wipe poor Angelina if not from your life, then at least from your art.

Once again, click on the No More Angelina entry in the Swapfile GUI, press the right mouse button, and select Edit from the pop-up menu. What appears now is the so-called Waveedit GUI, a window containing a graphical view of the audio tracks in your project. (Of course you are tempted now to wipe Angelina from one track only. Well, you could do that by selecting Edit on a single track rather than the whole project. You could even edit one track in multiple windows at the same time. But this is not the road we want to go down now. This Angelina-bitch ditched you, remember? Let's wipe her from your song completely.)

The Waveedit GUI is mostly driven from a pop-up menu attached to the right mouse button. Have a guess what Play All might do? Well, try it out. If you can't hear a single note, check your mixer settings with an external mixer program, and if all seems to be right, go back to the Settings menu in the Swapfile GUI and check your Audio I/O preferences. Working now? Good. Want to know how zoom in and out work? Ah, no, you figured that out yourself. Now you have to identify the places in the song where your voice trembles Angelina. To make it easier for you, during playback a vertical line will mark the region currently playing. Of course you don't have to keep playing the song as a whole over and over. There is Play Selection after all. What's a selection? That's a highlighted region in the editing window. Press the left mouse button, drag the mouse, release the mouse button again, and you'll get the trick. A lot of things can be done with selections from the pop-up menu. They can for example be played, zoomed into, cut, copied, and deleted. The latter is just what we need now. Select each of the passages enchanting Angelina, delete them, and there she goes.

So what about Heather? We'll be with her in an instant, but we have to learn a bit about recording first.

Next: , Previous: Getawaywithher, Up: Quick Start Guide

2.2 A Quick Start to Audio Recording

Back we are at the Swapfile GUI. Let's add a new project, and name it Oh Heather. That's where you're going to record into. Well, not quite. You can't record into a project, of course, you can only record into tracks. So you need to pull a track out of thin air, two of them actually, as you're going to record stereo. The right mouse button again acts as your magic wand. It will present you a menu item Add stereo wave, and that's exactly what you need now. Add the two empty tracks, select your Heather project, and open the Waveedit GUI on it, using the Edit entry in the pop-up menu.

The editing window doesn't look too interesting at the moment but that's what you'd expect from an empty file. It'll change soon, so go launch your favourite mixer application, and prepare your system as well as yourself for recording. Once both of you feel in shape, come back to the editing window. Record at marker is the preferred item in the pop-up menu now. A panel will appear containing the four buttons Record, Pause, Stop, and Cancel. Hitting the first one will start the recording. Finding out about the meaning of the others is left as an exercise to the reader. Don't think too hard about it, though, as now is the time to give a c-sharp Heather in your best tremolo ever. You should've figured out to hit the Stop button by the time you're done.

The rest is easy. In the Heather editing window, mark a selection only containing you singing the name but none of the noise before and after. Pop-up the menu with the right mouse button and hit Copy. Then move over to the Angelina editing window, which should still be open. A click with the left mouse button will mark a position in the song, and selecting Paste from the pop-up menu will insert your Heather at this position. Where to insert the section is entirely up to your artistic talent.

Not fancy enough to woo Heather, you feel? Read on.

Next: , Previous: Getmeinthere, Up: Quick Start Guide

2.3 A Quick Start to Filter Networks

To brush up a selection from the Waveedit GUI, you can apply a single filter on it. Apply Filter from the pop-up menu gets you going. But you can do even better. Select Apply Custom and watch the Filternetwork Editor come up. Here, you can not only apply a single filter, but a whole collection of filters that interact with each other.

Think of the filter network as a factory of waves. It starts out on one or more sources of sound waves, mangles the sound, and finally sends it off to one or several consumers. There is already a source in the network, called swapfile_in, and a consumer called swapfile_out. Don't mess with them, as they were already set up by the Waveedit GUI to work on the selection you marked. It is your task now to build the individual steps in the factory itself. That is, what should be done to your sound, and in which order. To this end, you can insert filters into the network. They are your machines. Just hit the right mouse button, and select one of the entries. A small icon will appear depicting your new filter. Each filter has its inputs to the left, and its outputs to the right. To connect two filters, you draw a line from the output of the first to the input of the second, dragging the mouse with the left button pressed down. Some filters do not possess both inputs and outputs. You'll note this when one side of their icons is greyed out. Inputs and output in general are not limited to a single connection. A filter will accept as many connections as it can take, and reject any further.

For most filters, you want to tune their parameters, or their output will probably not come close to what you intended. Press the right mouse button on top of the filter image, and select the Properties entry. A new window will show up, where you can tune the parameters to your liking. Once all parameters are set, and all filters are connected, hit execute on the icon bar on top. When processing is finished, go to the Waveedit GUI, and watch your modified Heather tracks.

What's left to do? Back to the Swapfile GUI. It's about time to finally rename the No More Angelina project to Hymn to Heather. How? Go figure. You really should have gotten a good feeling of how GLAME works by now. Next, get the pop-up menu up on Hymn to Heather. Select Export..., and save your song as, say, heather.wav. As you may have guessed, by default the suffix determines the type of file Hymn to Heather is stored as. For some additional control, you can explicitly specify the desired file type and sample format via several rather obvious buttons and menus. Want details on that one? Hey, enough is enough! Go read the proper docs if you're that interested. Or try on of the Help entries that will present you a context sensitive entry from the manual.

Well done, you may call yourself a GLAMEr now. A Lamer even, if you don't get up immediately and present your new song to Heather. Off you go. Good luck!

Previous: Gottagetbetter, Up: Quick Start Guide

2.4 A Quick Start to Realtime Effects

Back with us again? Oh rats, Heather finally broke your heart and left you? Cheer up, there's Bozo "The Dragster"'s ultimate party next weekend, and Bozo thinks you'll fit perfect with some of his best friends. Wonder how to break the ice? Don't worry. A microphone and a box running GLAME, that's all you'll need to hook them up.

Let's get the setup straight first. In the preferences dialog... Pardon me? How to get to the preferences? Gee, guess you need a couple of Angelinas and Heathers still, until you're ready for Bozo. Found it now? Fine. In the preferences dialog, there's a little fine-tuning to do on Audio I/O for a spiffy full-duplex setup, meaning that we're going to play and record at the same time. Select OSS and configure /dev/dsp for input, and /dev/dsp1 for output. This'll work if your sound card is fancy enough to offer more than one DSP device. Otherwise, lend your neighbour's for the day. Your smartass neighbour is likely to mention something about ALSA being so much better. "The day ALSA can be considered stable is unlikely to be in the same century that Bozo holds parties," is a good answer. Learn it by heart. The curious of course can try whether there's a GLAME plugin compatible to the ALSA version du jour. If you're lucky, plughw:0,0 and plughw:1,0 might be the correct settings for input and output. Probably they aren't.

Now for some real fun. From the Swapfile GUI, you can launch the Filternetwork Editor. New Filternetwork is the menu entry we're talking about. You are already familiar with the window that pops up–remember the wave factory? This time, however, the factory is completely empty. Two filters, audio_in and audio_out, will make it work just-in-time, though. For kicks, add a flanger filter as well, and connect it to both audio_in and audio_out.


This setup is working but seriously lacking coolness. Let's fiddle with some parameters. Right-click on the flanger icon and select Properties. Set the effect depth to 50ms, the detune range to 25ms, lfo speed to 8Hz, dry/wet balance to 0.0 and the LFO Type to Ramp Up.


Once you click on Execute in the editor window, start talking into the microphone. Voila, you're talking like Mickey Mouse! Now stop the network by clicking on the Execute button again that has in the meantime morphed into Stop. Change the LFO Type to Ramp Down and execute the network again. Coolness factor rising, eh!? Time to fire up your favourite mailer and send a message to, telling him what cool a frood he is. Some of the parameters you can even alter while the network is running. Just go on from here and play around. Once you've found the Bozo killer setting, the Save button is a good one to try next.

Now for a more sophisticated network: A sampler that will record your voice and repeat it in an endless loop. Bozo's dudes are gonna love it, honest. First, wire up the basic network from audio_in, mix, one2n, and audio_out. So far it's just a slightly complicated way of sending all input to the output unmodified. The network gets a lot more interesting when we add a feedback loop. Add a buffer filter, a delay filter, and connect them sort of backwards. That is, draw a second connection from one2n's output to the input of buffer. Connect buffer to delay, and finally hook up delay's output to the input of mix.


Still a little tuning to do. There's a little blob on the connecting line between delay and mix. Right-click on it, and select Destination Properties in the menu that pops up. Set the gain to 1.9. Next, open the properties dialog for the buffer filter and set the time parameter to 1 second. In the delay filter's properties, set the delay time to 500ms. Turn down your amp really low, execute the network and talk something intelligent like "Boh" into your microphone. If a screeching sound hurts your ears, the gain parameter probably is to high. Click on the little blob again and tune it until you're satisfied. If you set it to smaller values, your voice will slowly fade out, if it's to high it will just get louder and louder until your speakers freak out. Obviously, an endlessly repeating "Boh" isn't all that stunning. "Zoh" sounds like a good second line. Talk into the microphone, and wow, here's our vocal percussionist. The party is your's, and hey, it's time to go now. Send our best to Bozo and the drags. Have fun!

Next: , Previous: Quick Start Guide, Up: Top

3 Graphical Frontend (glame)

Nonsurprisingly, GLAME's graphical frontend is called glame. Usually, it will be invoked without any arguments. An optional file name may be given though, indicating an alternative location of GLAME's internal swapfile. See The Main Window, for details.

A note to the DIY folks: When running glame straight from its source tree without prior installation, glame/src/ has to be your current working directory. Otherwise, glame won't be able to find its plugins.

The graphical frontend consists of three parts. The main window, also called the Swapfile GUI, is the only one active right at the beginning. The wave editor and the filternetwork editor can be activated from there. Controlling glame is supposed to be rather intuitive. Should you ever feel lost, just try pressing the right mouse button, and a context sensitive menu will pop up and hopefully present you with the option you were looking for. If you are looking for a list of keybindings for the current window try pressing the F1 key. The context sensitivity buzzword also applies to GLAME's online help. Just push the button and hope for your preferred gnome help browser being able to display texinfo docs. (The standard gnome-help is.)

Next: , Up: Graphical Frontend

3.1 The Main Window

On startup, glame will present you with an application window in well-known GNOME design that contains a tree view of the so-called swapfile currently in use. Representations of all the sound tracks you want to edit will be stored here, so it's certainly a wise idea to put the swapfile on a partition with plenty of free space. By default, the swapfile resides in ~/.glameswap, but you can configure its location in the preferences window available from the Settings menu. Note that you need to restart glame for the change to become active.

Within the swapfile, individual audio tracks are combined to projects. You can create new projects using the entry New Project in the Project menu. This will insert a new item into the tree view of the swapfile and pop up a field where you can edit the project's name. Double-clicking on an item allows you to change the name later as well.

Now you're all set to start importing files into your new project, or to subdivide it further into groups. A context sensitive menu offering operations on groups or items respectively pops up when you press the right mouse button. Those are your options:

3.1.1 Operations on groups

pops up a new window of the wave editor see The Wave Editor containing all items of the group, where you can easily modify them. This operation is not allowed for groups that in turn contain further sub-groups. Opening a wave editor can be done by using the w key, too.
pops up a new window of the timeline see The Timeline containing all items of the group. This operation is not allowed for single items.
deletes the current group and all its items.
Add group
adds a new group to the current group.
Add clipboard
adds the contents of the clipboard as a new group to the current group. The clipboard's contents are populated via the edit operations in the wave editor.
Add mono wave
adds a new mono wave to the current group. This is useful when you want to start recording a new track, or paste some random stuff into a separate location.
Add stereo wav
Same as above, but adds two track for stereo recording instead of a single one.
Link selected
links the selected item into the current group. Linking means that a change on the link will also modify the original and vice versa.
Copy selected
copies the selected item into the current group. Unlike linking, copying creates a distinct group, meaning that a change to the copy will not alter the original and vice versa.
Merge with parent
moves all the current group's children up one level and deletes the current group.
merges all children of the current group into the minimum number of vertically aligned tracks all starting at horizontal position zero and of the same length. From a more practical edge, use this option to render a multi-track recording in, say, two stereo tracks.
Apply operation
applies the selected operation to the whole current item or group. Useful operations include things like normalize.
imports a file as a sub-group into the current group. Import is done through a powerful import dialog which is described in the dialogs section.
exports all children of the group as an ordinary sound file. Export is done through a powerful export dialog which is described in the dialogs section.

3.1.2 Operations on items

pops up a new window of the wave editor see The Wave Editor, where you can modify the selected item. Opening a wave editor can be done by using the w key, too.
deletes the current item.
puts the current item into a new group.
Apply operation
exports all children of the group as an ordinary sound file. Export is done through a powerful export dialog which is described in the dialogs section.
exports the current item as an ordinary sound file. Export is done through a powerful export dialog which is described in the dialogs section.

Sequencing multiple waves in the main window is rather easy. Using drag and drop while pressing some modifier keys, you can move waves between horizontally (hbox) and vertically (vbox) sequenced boxes (groups). See below for a list of available modifier keys.

To move a wave to a different place first hold down the proper modifier to select the mode, then select the item you want to move with the left mouse button and start dragging it. The destination is located just before the wave you drop onto, or at the last position of the group you drop onto respectively.

The following two modes are supported and can be selected via the specified modifier keys:

moves an item into a vbox. Here items are sorted one track per item.
moves an item into a hbox. Here items are sequenced horizontally, all belonging to the same track.

While dragging, you can see the mouse cursor change from a circle (indicating a drop at the current position is not possible which in turn indicates a wrong group type of the current group) to a hand (indicating a drop is possible). You can cancel a drop by dropping back on the original dragged item.

If you want to change a vbox into a hbox or vice versa, you need to go through an intermediate group. First create a dummy group and start moving items there. Then move items back to the original group with the right mode. Note that you can move whole groups at once. So sequencing stereo waves is possible, too, without breaking the stereo groupings.

In the main window's tree view you can use the following keyboard shortcuts to change the waves speaker positions. The active wave is denoted by the item the mouse is pointing at.

associates the active wave with the left channel.
associates the active wave with the right channel.
associates the active wave with both channels (mono).

The following items are present in the Project menu:

New Project
Creates a new project (a toplevel group).
Edit File
Very quick shortcut to edit one file. File selection is done through the import dialog. A waveedit window is popped up with the selected file. Note that the file is not permanently stored in GLAME's swapfile, but instead is removed from it once you close the waveedit window. So you really want to re-export the file once you are finished editing.
Imports a file into the GLAME swapfile without creating a project first. This is useful for quick editing tasks which don't involve multiple files.
Empty [deleted]
Deletes all entries in the [deleted] folder. This operation cannot be undone. Deleted elements are usually just moved to the [deleted] folder so you can undo deletes by just moving items back. Emptying the [deleted] folder can also be done by deleting the [deleted] folder itself.
Show console
By selecting Show console, you get access to the powerful backend of glame that can be controlled via a scheme scripting language. Or just watch the error logs that pop up here as well.
Syncs the metadata of the swapfile to disk. That's mostly a debugging aid that you usually should not need to invoke.
Exits GLAME. The current state of the swapfile is saved and the project tree will persist in its current state.

These are the items of the Filternetwork menu:

New Filternetwork
Opens a new empty window of the filternetwork editor.
Opens a saved filternetwork in a new window of the filternetwork editor.
Load Plugin
You can manually load plugins into glame by using the Load Plugin menu item from the filternetwork menu. This is useful for instance to use external LADSPA plugins or custom filternetworks you didn't put into the default GLAME search directory.

From the Settings menu you can invoke the preferences window, from the Help menu you can invoke a gnome help browser with this documentation, or jump directly to the quick start guide.

Next: , Previous: The Main Window, Up: Graphical Frontend

3.2 The Timeline

The timeline view is highly experimental and may cause other parts of GLAME to fail operating on modified tracks. You can usually recover from this situation by flattening the affected subtree, but this may be not the thing you want to do. Be warned.

The timeline pops up when the Timeline function is applied to a group in the main window. The timeline presents a time vs. track view of the group. At the top of the window there is a ruler which shows the time in seconds.

The active item and group appear highlighted. You can move the active item horizontally (in time) using the mouse by clicking and dragging. You can move items vertically (changing the track an item is in) by using the up and down arrow keys. You can move whole groups vertically by using the up and down arrow keys in conjunction with the shift modifier key.

Like in any other window, the Close and Help toolbar entries close the window, or bring up the gnome help browser with this documentation, respectively.

Next: , Previous: The Timeline, Up: Graphical Frontend

3.3 The Wave Editor

The wave editor pops up when the Edit function is applied to either a group or a single item of the swapfile tree. Editing is done on all items of a particular group at once. Functions to edit and explore the current items can be reached via the right mouse button or the toolbar. The wave editor is also reached through the Edit File menu entry or the w accelerator.

You can find keybindings listed by pressing the F1 key in any wave edit window.

Simple editing can be done using the ordinary Cut, Copy, Paste, Delete, Undo and Redo operations inside the Edit submenu, that work on the current selection in the active wave widget. You can cut and paste between different wave widgets, if the numbers of channels match. When you operate on multiple views of the same wave item at once, they will be kept in sync automatically. Keybindings for Cut, Copy, Paste, Delete, Undo and Redo are Ctrl-x, Ctrl-c, Ctrl-v, Ctrl-k, Ctrl-z and Ctrl-r.

You can export the current selection by choosing the Export selection menu entry from the Edit submenu or by pressing the Ctrl-s keyboard shortcut.

To control the view use the View submenu which contains the items Zoom to selection, Zoom in, Zoom out, View all and Goto marker. The zoom in, zoom out and view all functionalities can also be reached from the appropriate toolbar entries.

To specify the current selection simply use the mouse and drag it with the left mouse-button pressed. Alternatively you can use the Select none or Select all menu items from the Select submenu or the corresponding buttons in the toolbar to remove the actual selection or select the whole wave. Pressing shift and the left mouse-button selects everything starting from the marker position (which you can set using the left mouse-button) to the current position. The selection and the marker position can be changed with dragging the marker or the selections left or right edge (the cursor will change if you move over them).

As usual, the Close and Help menu entries close the window, or bring up the gnome help browser with this documentation, respectively. Those items can also be reached from the toolbar.

Using the Play all and Play selection commands the whole wave or the selected part will be sent to the default audio output device. Using the Record at marker and Record into selection commands you can sample from the default audio input device either starting at the marker position and until you press the STOP button, or just inside the selection. Using the play button from the toolbar will start playing either the current selection or from the marker position if no selection is active and will advance it until you either press the stop button (which will appear at the place of the play button after start) or the wave has ended. Playing can be reached through the Space keyboard shortcut which starts playing from the current marker position. Using Ctrl-Space you can play the current selection or the whole file, if nothing is selected. Pressing Shift-Space will loop the current selection or the whole wave.

The Apply operation submenu allows you to apply operations like normalize or fade to the current selection. Some operations pop up windows for additional arguments.

The Apply filter submenu allows you to apply a pre-existing filter to the active selection. Inside the apply window the list of available parameters for the filter will appear which you may edit. With the preview button you can figure out what the result after applying the filter will sound like. You can abort the preview by pressing the preview button again. Press the apply button if you are satisfied with the setup. Press the cancel button if you don't want to modify the wave.

Alternatively, you can pop up the filternetwork editor see The Filternetwork Editor, where you can construct a custom filter or use Apply custom... which creates a filternetwork framework containing necessary inputs and outputs specified by the current selection.

A shortcut to the export functionality is embedded in the toolbar as a Save item. This is especially useful for waveedits opened through the Edit File menu entry as this one does not show the wave in the swapfile tree.

Next: , Previous: The Wave Editor, Up: Graphical Frontend

3.4 The Filternetwork Editor

The filternetwork editor is opened when you choose one of the custom functions in the wave editor, or the item New Filternetwork in the Filternetwork menu of the main window. The filternetwork editor comprises of a tool bar at the top of the window to execute, save and apply other functions, and a main canvas for connecting and adding new nodes to the network. A preexisting network can be edited by opening it from the Open... item in the Filternetwork menu of the main window.

All functionality in the editing window is controlled via context sensitive menus bound to the right mouse button or configurable shortcuts.

Pressing the right mouse-button over the canvas background will pop up a menu containing the list of available plugins. Plugins are bundled into categories to speed up finding the desired item. Selecting one will add a node cloned from the corresponding plugin to the network. A special item, Paste selected at the bottom of the menu will paste the last copied node collection at the current location. When a new node is added, its icon appears on the editing canvas. It shows its input ports (if available) on the left, and output ports on the right. If no ports of a type are available, the corresponding side bar appears gray.

To connect two plugins, click on the output port using the left mouse button, and drag the appearing pipe to the desired input port. If a connection is possible, a pipe connection will be drawn. To manipulate per-pipe parameters of the connected nodes, a context menu is attached to the small black ball placed in the middle of the pipe.

Clicking with the left mouse button on a item will highlight it with a light blue frame, thus marking it as selected. Alternatively, nodes can be selected by clicking with the left mouse button into empty space in the editor, holding it down and dragging the appearing box over the desired nodes in well known file-manager fashion. You can alter selections by holding down the shift or control modifier keys. Pressing one of the modifier keys while selecting will add the selected icon to the current selection.

Selections may be manipulated in a number of fashions. A selection can be collapsed by either choosing the corresponding context menu in the node menu or the c shortcut. Once a selection is collapsed, a new node appears in place of it. Connections to nodes in the selection to outside nodes are saved and ports appear on the collapsed node. Collapsed selections are real new subnets and may be saved and opened down, and just as any node representing a network expanded in-place using the corresponding menu entry or the e shortcut.

Finally, if you hover over an icon or port or the circle contained in a pipe for a little while, the current parameter settings are shown, and the node is raised to the top. The hovering delay can be adjusted in the preferences window. The same applies for the connection between two nodes.

Pressing the right mouse button over a network node will pop up a menu with the following items:

Opens a property dialog which lets you modify the network node's parameters. If you have selected multiple nodes of the same type and open a property dialog of one, this property dialog will modify all nodes parameters at once, that is they appear linked.
Redirect parameter
Opens a dialog where you can create network-wide parameters (which are visible if you use the network as plugin from inside other networks) which map to parameters of nodes inside the network. You can delete network-wide parameters via the toolbar Properties dialog.
Deletes the current node from the network and kills all connections to/from it.
Copy selected
Copies the set of selected nodes to the clipboard. It can be replicated using the Paste selection menu entry from the node addition menu.
Collapses the current set of selected nodes to a sub-network which will be embedded in the current network. This network can be edited if opened via the Open down menu entry.
Expands the current node, replacing it with its network contents.
Open down
Opens a new network editor window for the current node, exposing its internal structure for editing.
About node
Opens a dialog with the description for the node, its ports and parameters.
Opens a gnome help browser with the documentation for the current node.

Pressing the right mouse button over a port will pop up a menu with the following items:

Redirect port
Creates a new network-wide port which maps to the current one. A dialog will ask you for a name for the new port. You can delete network-wide ports via the toolbar Properties dialog.

Pressing the right mouse-button over the pipe bubble will pop up a menu with the following items:

Source properties
Opens a property dialog which lets you modify the parameters for the source end of the current pipe.
Destination properties
Opens a property dialog which lets you modify the parameters for the destination end of the current pipe.
Kills the current pipe.

There are a few keyboard shortcuts which expose additional features:

Deletes all nodes of the current selection including pipes to/from them.
Groups the current selection. Grouping will let you move the nodes as one item, exposing no additional features.
Ungroups the current selected group.
Collapses the current selection.
Expands the current node.

The created network can be executed with the corresponding button in the toolbar. At execution time this button turns into a stop button which can be used to abort executing the network. If anything is not set up correctly, the malicious plugin will be drawn in red, and the error will be displayed when hovering over it.

Once you found your network to be adequate, you may save it using the Save button in the toolbar. You can also register the network as a new plugin that can be used in other networks. Before that, you have to add ports to your toplevel and/or redirect parameters from nodes. Ports can be redirected by choosing the Connect to external port from the context menu of the port. Parameters are redirected by choosing redirect parameters from the context menu of the node. You can delete or look at the external interface by selecting the properties button.

As a final feature, the zoom level can be adjusted with the zoom in and zoom out buttons. The View all button recenters your view and adjusts the scrollable region.

Previous: The Filternetwork Editor, Up: Graphical Frontend

3.5 Dialogs

Next: , Up: Dialogs

3.5.1 The Preferences Dialog

From within the preferences dialog, which you can reach from the main windows Settings menu, you can change GLAME's configuration including the swapfile setup and your audio setup. Note that some changes take effect only after restarting GLAME.

The preferences dialog presents you with three tabs, namely the Swapfile, Filternetwork, Waveedit and Audio I/O tabs. We're going through them separately.

The first tab is the Swapfile tab which has the following entries:

Swapfile Path
Here you can configure where GLAME should place its internal representation of the audio data. Note that GLAME uses this as a permanent storage to save the complete application state. The swapfile's contents survive a restart. Changes of the swapfile path take place after a GLAME restart only.
Depth of undo stack
Here you can configure the amount of edit steps you want to be able to undo. This is a global number. Remember that each step of undo needs space in the swapfile.
Here you can specify the maximum amount of virtual memory used for caching wave data. Note that the physical caching is done by the operating system as we are using memory map based access. Specifying more than about three quarters of available physical memory does not make sense and will slow things down.

The Filternetwork tab lets you configure some UI parameters which are

Property popup timeout
The time until the description properties pop up.
Mac mode
Maps other-than-left mouse-button operations to multi-clicks on the left button. This is only useful if you are using mice with less than two buttons.

The Waveedit tab lets you configure some UI parameters which are

Wave scrolling
Whether the wave view should scroll while playing. This is usually a good idea, but on slow machines disabling this may fix dropouts during playback.

The Audio I/O tab lets you configure the default audio input and output device.

Default input plugin
Here you can select (or edit) the plugin which should be used for audio input. This should be oss_audio_in or alsa_audio_in for most Linux boxes.
Default input device
Specify the input device corresponding to the sound-card you want to record from. For OSS, this will be one of the /dev/dsp devices, for alsa plughw:0,0 or similar.
Default output plugin
Like for the input case this is the plugin you want to use for audio output.
Default output device
Device settings for audio output.
Size hint for audio buffers
This number specifies the default size of audio fragments that get passed through the audio processing networks of GLAME. Choose large values (1024) for slow machines, low values (128) for low latency networks. The minimum internal latency can be calculated as size hint divided by the samplerate (128 / 44100 Hz = 2.9 ms). Note that the audio fragment size is usually limited by your audio hardware, so this is only a hint and specifying values less than 32 will probably only hurt performance.

Note that if you have certain sound daemons running such as artsd from KDE or esd from GNOME you may need to kill them before you can access your audio devices from within GLAME.

Next: , Previous: The Preferences Dialog, Up: Dialogs

3.5.2 The Import Dialog

The import dialog is spawned by selecting the menu entries "Edit File" or "Import" from the main window. This dialog is mostly self explaining. Select a file by typing its name, or search it with the file browser. There some other buttons you can toggle:

Get RMS & DC Offset
Extract statistic information from the selected audiofile. RMS is the root mean square of the select file, which gives a measure of the file's signal amplitude. DC Offset shows the mean deviation of the signal from zero. For a perfectly symmetric sampler hardware, the dc offset should be zero. In case your soundcard records an asymmetric signal, this is the measure for it. You can remove such a dc offset with a see highpass filter with cutoff frequency set to 0 Hz.
If you check the resample button, you can enter your desired sample frequency. The file is then resampled to this frequency while importing. Note: The current resampling is FFT based. If you select a new frequency whose ratio to the old one is other than a power of 2, resampling can be very slow.
Starts the import of the file.
Cancels the current action.

Next: , Previous: The Import Dialog, Up: Dialogs

3.5.3 The Export Dialog

The export dialog appears in case you select "Export..." from the popup menu or see The Wave Editor. The dialog contains the following buttons:

File Format
You can either select "auto" or a specific filetype supported by libaudiofile. In case you select "auto" the type is chosen by the suffix of the file.
Compression Type
If this button is active, you can choose a compression codec.
Sample Format
Here you can choose the format of a single sample. Note: Not all sample types work with all formats. In case your combination is not supported an error requester will pop up.
Render Options
You have three choices:
The number of channels in your current project is preserved while saving, e.g. you can save a wav file with an arbitrary number of channels. This is in fact supported by the standard. Good luck hunting applications that implement it, though.
The project is rendered into a mono file.
The project is rendered into a stereo file. Channels are panned according to their given position.

Export the current project.
Cancels the current action.

Previous: The Export Dialog, Up: Dialogs

3.5.4 The Apply Filter Dialog

The apply filter dialog is reached from the waveedit window through the right mouse button menu by choosing the Apply filter... entry and operates on the current selection. In the upper part of the dialog, the parameters of the selected filter are displayed and can be edited.

Two switches are available to control behavior of the Apply and the Preview operation:

Lock size
This controls whether applying to the current selection may change its size. Default is on in which case the length of the track doesnt change. If off the operation is like cutting out the selection, applying the filter to create a new track and inserting the result back into the original track at the selections starting position.
Loop previewing
This controls whether the selection should be looped during preview of the apply filter operation. This is useful for tuning filter parameters for short selections. The default is off.

The lower part of the dialog contains a progress bar for both preview and apply operation. The following functions are available:

This button starts previewing of the selected region with the filter with the specified parameters applied. To stop previewing press the preview button again. For most filters you can change parameters while the preview is active, so you can tune them with realtime feedback.
This button starts applying the filter to the selected region and closes the dialog after it is finished.
Cancels the apply filter operation. No changes are made to the current selection.
Pops up the gnome help browser with help on the selected filter.

Next: , Previous: Graphical Frontend, Up: Top

4 Console Frontend (cglame)

cglame is GLAME's console interface. Beware! cglame is not for whimps but for real men and women who dream in Scheme and chomp brackets for breakfast. It's for those who want to feel the ultimate power of GLAME. Thankfully, J. Random User won't have to dive into the perils of cglame and will be all happy with glame, the friendly and intuitive graphical frontend see Graphical Frontend.

Still there? Wheee, you're a tough one! Let's see what's in here for you: This chapter starts with a brief introduction into the cglame user interface. Afterwards, the wrapped midlayer and backend APIs are listed, and an the scheme level API on top will be described.

Next: , Up: Console Frontend

4.1 cglame Introduction

cglame is a scripting engine in the sense that you are presented a glame> command line prompt where you can enter scheme expressions. cglame exposes GLAME's midlayer API and the backend API via scheme wrappers. Extra convenience scripting procedures are defined in the global glame.scm scheme file. You can add customisations via your ~/.glame.scm file or by loading appropriate scheme files at the appropriate time using (load 'filename).

As command line option to cglame you may specify the swapfile to be used like -s path-to-swapfile. A swapfile is necessary if you want to use any of the swapfile API procedures. To make cglame create a swapfile for you use -c path-to-swapfile.

Once started, cglame presents you with a command prompt where you can evaluate scheme expressions. An example session is shown below. Alternatively you may run cglame non-interactively by specifying the filename of a to be executed script as last argument to cglame.

     $ cglame
         CGLAME for GLAME version 0.5.2, Copyright (C) 1999-2001
         Alexander Ehlert, Richard Guenther, Johannes Hirche, Daniel Kobras.
         CGLAME and GLAME come with ABSOLUTELY NO WARRANTY. This is free
         software, and you are welcome to redistribute it under certain
     Quick help:
     (quit) gets you out of here.
     (help) gets you some additional help.
     glame> (play "/var/tmp/short.wav")
     glame> (play-eff "/var/tmp/test.wav" '("echo"))
     glame> (let* ((net (net-new))
     ... (nodes (net-add-nodes net '("read_file" "echo" "audio_out")))
     ... (echo2 (net-add-node net "echo")))
     ... (node-set-param (car nodes) "filename" "/var/tmp/test.wav")
     ... (nodes-connect nodes)
     ... (nodes-connect (list (car nodes) echo2 (caddr nodes)))
     ... (net-run net))
     glame> (quit)

All used scheme procedures which are not documented in the following sections reside in the glame.scm file shipped with glame, usually installed as /usr/share/glame/glame.scm.

Next: , Previous: cglame Introduction, Up: Console Frontend

4.2 Wrapped API

For description of the detailled semantics of the available parts of the APIs please refer to the native documentation.

C functions which return 0 on succcess and -1 on error are converted to scheme procedures evaluating to #unspecified on success and throwing a 'glame-error exception on error. C functions which return an object on success and NULL on error are converted to scheme procedures evaluating to an object and throwing a 'glame-error exception on error. Void functions generally evaluate to #unspecified.

You can catch 'glame-error exceptions by using code like the following:

     glame> (catch 'glame-error
                   (lambda () (filter-connect foo "out" bar "in"))
                   (lambda args (display "Cannot connect\n")))

Next: , Up: Wrapped API

4.2.1 Scheme Filter API

The basic filter subsystem types, filter_t, filter_port_t, filter_pipe_t and filter_param_t exist as native scheme types and such can be type checked.

— Function: filter? obj
— Function: port? obj
— Function: pipe? obj
— Function: param? obj

These procedures check obj for being of the specified type and evaluate to #t if this is the case and #f otherwise.

Out of a filter object you can get information and subobjects using the following procedures:

— Function: filter-name filter
— Function: filter-nodes filter
— Function: filter-ports filter
— Function: filter-params filter

These procedures evaluate to a string containing the filters name or to lists of the specified object type representing the actual subobjects associated with the filter.

Out of a port object you can get information and subobjects using the following procedures:

— Function: port-label port
— Function: port-pipes port
— Function: port-params port

These procedures evaluate to a string containing the ports label or to lists of the specified object type representing the actual subobjects associated with the port.

Out of a param object you can get and modify information using the following procedures:

— Function: param-label param
— Function: param-value param
— Function: param-set! param value

These procedures evaluate to a string containing the label of the param object, the actual value of the param whose type depends on the param objects type or a boolean denoting the success of a param set command.

Out of a pipe object you can get information and subobjects using the following procedures:

— Function: pipe-samplerate pipe
— Function: pipe-position pipe
— Function: pipe-source-params pipe
— Function: pipe-dest-params pipe

These procedures evaluate to an exact number containing the samplerate of the data flowing through the pipe, a number containing the position of the audio stream or to lists of the specified object type representing the actual subobjects associated with the pipe.

Pipe objects can be queried for the actual protocol type using the following procedures:

— Function: pipe-sample? pipe
— Function: pipe-fft? pipe
— Function: pipe-ssp? pipe

These procedures check pipe for being of the specified protocol type and evaluate to #t if this is the case and #f otherwise.

Usually you can attach key/value pairs to a per object database. Those object properties can be queried and modified using the following generic interface:

— Function: set-property! obj key value
— Function: get-property obj key

These procedures evaluate to #unspecified or a string object containing the value associated with the specified key or #f if this key has no associated value. Note that for both key and value only string objects are allowed. Predefined key values are FILTERPARAM_DESCRIPTION, FILTERPARAM_GLADEXML and FILTERPORT_DESCRIPTION.

The following procedures handle object serialization and creation and destruction of objects.

— Function: filter-new [filter|plugin]
— Function: filter-delete filter
— Function: port-delete port
— Function: param-delete param
— Function: pipe-delete pipe

filter-new constructs a new filter object by either cloning from a filter or a plugin object or creating an empty network from scratch. The delete procedures destruct the specified objects.

— Function: filter->string filter
— Function: param->string param

While the first procedure returns a string containing a scheme expression being able to recreate the filter object, the second procedure just evaluates to a string containing the value of the specified param.

— Function: filter-add-node filter filter node-name
— Function: filter-connect filter port-name filter port-name

filter-add-node adds the specified filter (second parameter) to the specified network (first parameter) using the identifier specified as third parameter. filter-connect connects the two specified parameters via the specified ports identified by their port names. filter-connect evaluates to a pipe object.

— Function: filternetwork-add-input filter filter port-name name description
— Function: filternetwork-add-output filter filter port-name name description
— Function: filternetwork-add-param filter filter param-name name description

Procedures to be used for exporting ports and params to the outside world in a macro filter. The first parameter is the actual network, the second parameter is the node that gets exported from. These procedures evaluate to a port or a param object.

— Function: glame_create_plugin filter name
— Function: glame_plugin_define filter name

glame_create_plugin creates and registers a new plugin using the specified name and associate it with the provided filter. Evaluates to a plugin or to #f on error. glame_plugin_define is used internally for transparently registering or filter loading.

— Function: filter-launch filter
— Function: filter-start filter
— Function: filter-pause filter
— Function: filter-wait filter
— Function: filter-terminate filter

These procedures handle filter network execution.

Next: , Previous: Scheme Filter API, Up: Wrapped API

4.2.2 Scheme Swapfile API

The swapfile is a container for data in its raw form. It is modeled after a simple filesystem with a flat namespace (no directories) and names being just cardinal numbers.

— Function: swapfile-open path
— Function: swapfile-close
— Function: swapfile-creat path

These procedures control the swapfile subsystem. swapfile-open initializes the subsystem from the swapfile at the specified location. swapfile-creat tries to create a new swapfile at the specified location, swapfile-close cleans up and closes the subsystem.

— Function: swdir? dir
— Function: sw-opendir
— Function: sw-readdir dir
— Function: sw-closedir dir

These procedures can be used to traverse the swapfile files. Function is like the libc readdir routines, but as the swapfile has a flat namespace you dont specify a subdirectory for sw-opendir. sw-opendir evaluates to a swdir object. sw-readdir returns swapfile filenames as long as they are available and #f upon directory end.

— Function: sw-unlink name

Unlinks the specified file from the swapfile. You cannot recover unlinked swapfiles. Behavior is like unlink(2), i.e. if the file is still open the deletion of the data is postponed until close of the file.

— Function: swfd? fd
— Function: sw-open name flags
— Function: sw-close fd

For working with a swapfile you need to obtain a handle to it. Use sw-open to open the swapfile with the specified name. The flags argument is modeled after open(2), O_CREAT, O_EXCL, O_TRUNC, O_RDWR, O_RDONLY and O_WRONLY are available. Or them together like (+ O_CREAT O_TRUNC O_RDWR). sw-open evaluates to a file descriptor which you can identify using the swfd? predicate. Use sw-close if you are finished with the file.

— Function: sw-fstat fd

sw-fstat obtains information about an open filedescriptor. It evaluates to a list of the form ( name size mode offset cluster-start cluster-end cluster-size ) where all entries are cardinals.

— Function: sw-lseek fd offset whence

To seek inside a file use sw-lseek which works like lseek(2), i.e. it seeks relative to whence offset bytes. For whence SEEK_CUR, SEEK_SET and SEEK_END are available. sw-lseek evaluates to the current file pointer position.

— Function: sw-ftruncate fd size

sw-ftruncate truncates the specified file to the specified size appending zeroes in case of enlarging.

— Function: sw-sendfile dest-fd source-fd size [flags]

sw-sendfile copies (by using copy on write) size bytes from the current filepointer position of the source-fd to the current filepointer position of the dest-fd. Via the optional flags argument you can specify the following

The data is inserted at the filepointer position of the dest-fd instead of overwriting and/or extending the file.
The data is removed from the source-fd after writing to the dest-fd
For both files you can specify SW_NOFILE if it makes sense (i.e. for just cutting out data specify SW_NOFILE as dest-fd and SWSENDFILE_CUT as flag).

— Function: sw-read-floatvec fd size
— Function: sw-read-string fd size
— Function: sw-write fd data

Those are the basic read and write operations. Both strings and float vectors are supported by the scheme interface. For reading you need to specify the type via the procedure name, for writing the type is automatically determined. The read procedures read size number of objects from the current filepointer position. They evaluate to the number of objects read. sw-write writes the whole object to the current filepointer position and evaluates to the number of objects written. All procedures increment the filepointer position by the number of bytes read/written.

Next: , Previous: Scheme Swapfile API, Up: Wrapped API

4.2.3 Scheme Plugin API

The glame plugin midlayer API is wrapped with the following procedures:

— Function: plugin? plugin

This procedure checks, if the specified object represents a plugin and evaluates to #t in this case, else #f.

— Function: plugin-add-path path

This procedure adds the specified path to the plugin shared object search path that is used by the plugin-get procedure.

— Function: plugin-get name

Queries a plugin with the specified name out of the plugin database. Evaluates to a plugin or #f if a plugin with the specified name cannot be found.

— Function: plugin-name plugin
— Function: plugin-query plugin key
— Function: plugin-set! plugin key value

Queries the name or custom properties out of a plugin. Those procedures evaluate to a string, plugin-set! sets the specified property to the specified string. Predefined property keys are PLUGIN_DESCRIPTION, PLUGIN_PIXMAP, PLUGIN_CATEGORY, PLUGIN_GUI_HELP_PATH and PLUGIN_LABEL.

Next: , Previous: Scheme Plugin API, Up: Wrapped API

4.2.4 Scheme GPSM API

The glame gpsm midlayer API is used to represent metadata associated with wave data, i.e. samplerate and positional information. The gpsm API also wraps swapfile modification of wave data.

For global control and initialization the following procedures are available:

— Function: gpsm-init path
— Function: gpsm-sync
— Function: gpsm-close

These procedures handle initialization and cleanup of the gpsm and the swapfile subsystem. As path you need to specify the path to the to be used swapfile. gpsm-sync syncs all gpsm metadata to disk.

The gpsm subsystem builds on a tree of gpsm items which are derived from a generic item type. Available item types are the gpsm group which just contains a list of children, and the gpsm swapfile which represents a wave with its metadata and swapfile representation.

— Function: gpsm-item? item
— Function: gpsm-grp? item
— Function: gpsm-swfile? item

These predicates check if the provided object is an gpsm item, or one of the derived types, a gpsm group or a gpsm swapfile.

— Function: gpsm-item-parent item
— Function: gpsm-item-label item
— Function: gpsm-item-hposition item
— Function: gpsm-item-vposition item
— Function: gpsm-item-hsize item
— Function: gpsm-item-vsize item

These procedures give access to the basic gpsm type, the gpsm item. They evaluate to the items parent item, to its label or its position and extension.

— Function: gpsm-grp-items item

gpsm-grp-items evaluates to the list of childs of the group.

— Function: gpsm-swfile-filename item
— Function: gpsm-swfile-samplerate item
— Function: gpsm-swfile-position item

These procedures give access to the gpsm swapfile type. They evaluate to the wave swapfile metadata, respective the swapfile filename, its samplerate and position in the stereo field.

— Function: gpsm-item-set-label! item label
— Function: gpsm-swfile-set-samplerate! item rate
— Function: gpsm-swfile-set-position! item position

These procedues modify one of the gpsm type properties.

For creating, copying, linking and destroying of items the following procedures are available:

— Function: gpsm-newswfile label
— Function: gpsm-swfile-cow swfile
— Function: gpsm-swfile-link swfile
— Function: gpsm-newgrp label
— Function: gpsm-item-destroy item

For structuring, modifying and traversing of the gpsm tree the following procedures are available:

— Function: gpsm-root

Evaluates to the gpsm tree root item.

— Function: gpsm-grp-hbox? grp
— Function: gpsm-grp-vbox? grp

Predicates that check, if the specified group is a hbox (a set of horizontally sorted, non-overlapping items), or a vbox (a set of vertically sorted, non-overlapping items).

— Function: gpsm-item-can-place? grp item hposition vposition
— Function: gpsm-item-place grp item hposition vposition

Placing happens without moving unaffected items. Placing needs to happen at a position where the needed space is already available.

— Function: gpsm-item-remove item

Removing happens without moving unaffected items and reverses a previous gpsm-item-place operation.

— Function: gpsm-hbox-can-insert? grp item hposition vposition
— Function: gpsm-hbox-insert grp item hposition vposition

Insertion moves adjacend items horizontally by the size of the inserted item. Only the starting position needs to be unoccupied.

— Function: gpsm-vbox-can-insert? grp item hposition vposition
— Function: gpsm-vbox-insert grp item hposition vposition

Insertion moves adjacend items vertically by the size of the inserted item. Only the starting position needs to be unoccupied.

— Function: gpsm-hbox-cut item

Cutting moves adjacend items horizontally by the size of the cutted item, reversing a previous gpsm-hbox-insert operation.

— Function: gpsm-vbox-cut item

Cutting moves adjacend items vertically by the size of the cutted item, reversing a previous gpsm-vbox-insert operation.

For the provided notification facility of changes to the underlying wave object (the swapfile file), the following procedures need to be called, whenever a change is made bypassing the gpsm subsystem. They all take a swapfile filename instead of a gpsm object.

— Function: gpsm-notify-swapfile-change name position size
— Function: gpsm-notify-swapfile-cut name position size
— Function: gpsm-notify-swapfile-insert name position size
— Function: gpsm-invalidate-swapfile name

Via these procedures you signal a change within the specified region of the swapfile with the specified name. Either just data modification or insertion or deletion of the region. Via gpsm-invalidate-swapfile you tell the gpsm subsystem to drop all its knowledge of the data of the swapfile, including its current size.

The gpsm subsystem transparently provides undo and redo operations for swapfiles via the following procedures:

— Function: gpsm-op-prepare item

Prepares the subtree specified by the provided item for later undo, i.e. restoring of the current state.

— Function: gpsm-op-forget item

Forgets the most recent stored state of the subtree specified by the provided item.

— Function: gpsm-op-can-undo? item
— Function: gpsm-op-undo item
— Function: gpsm-op-undo-and-forget item

gpsm-op-can-undo? evaluates to #t if there is a previous state available that can be restored now for the subtree specified by the provided item. gpsm-op-undo restores this state and remembers the current one for later redo. gpsm-op-undo-and-forget does not remember the current state for later redo.

— Function: gpsm-op-can-redo? item
— Function: gpsm-op-redo item
— Function: gpsm-op-redo-and-forget item

gpsm-op-can-redo? evaluates to #t if there is a previous state available created by an gpsm-op-undo operation for the subtree specified by the provided item. gpsm-op-redo restores this state and remembers the current one for later undo. gpsm-op-redo-and-forget does not remember the current state for later undo.

Previous: Scheme GPSM API, Up: Wrapped API

4.2.5 Scheme GUI interaction

FIXME. See various files in src/gui.

Previous: Wrapped API, Up: Console Frontend

4.3 cglame Convenience

For the convenience procedures online help is (maybe) available via (help command) or (help).

Next: , Up: cglame Convenience

4.3.1 Network setup

— Function: net-new

Creates a new filternetwork. net-new evaluates to a filter.

— Function: net-add-node filter node '("label" value) ...
— Function: net-add-nodes filter node '(node '("label" value) ...) ...
— Function: nodes-delete filter ...

net-add-node adds a single node with optional parameters to the network specified by filter. net-add-nodes adds a set of nodes with optional parameters to the network. net-add-node evaluates to a filter, net-add-nodes to a list of filters. Using nodes-delete you can delete nodes from a network.

— Function: nodes-connect nodes ...

nodes-connect linearily connects the specified lists of filters.

— Function: node-set-params filter '("label" value) ...

Using node-set-params you can set the parameters of the specified filter.

— Function: net-run filter
— Function: net-run-bg filter

net-run starts processing of the network and waits until completion. net-run-bg starts processing of the network and returns immediately.

Previous: Network setup, Up: cglame Convenience

4.3.2 Cooked operations

The following procedures can be customised by setting audio-out, read-file or write-file to other filters than their default ones like (set! read-file "read-mp3").

— Function: play filename

Plays the specified file.

— Function: play-eff filename '(effect ("label" value) ...) ...
— Function: save-eff infile outfile '(effect ("label" value) ...) ...

Plays or saves the specified file after applying the specified chain of effects with parameters.

Next: , Previous: Console Frontend, Up: Top

5 Plugin Collection

Available GLAME plugins are listed here with a short description about what they are able to do, their input and output ports, and the parameters they understand. Some ports allow more than one so-called pipe to be connected. Those restrictions will be listed in the port description. Some parameters can be set per plugin, some per pipe. Pipe parameters are listed with the name of the pipe preceeding the parameter name, separated by a double colon, like out::position for parameter position on pipe out. Each parameter is followed by its type–e.g. integer, float, or string–in parentheses.

Next: , Up: Plugin Collection

5.1 In- and Output

GLAME has several ways of importing and exporting audio data: via the sound card, an external file, or an external program. Furthermore, GLAME has its own so-called swapfile that is used as a large internal cache for audio data.

Next: , Up: In- and Output

5.1.1 Audio I/O

The audio-in and audio-out plugins handle communication between GLAME and the sound hardware. audio-in is for recording, audio-out does the playback. Actually, there are several instances of those plugins for different sound systems like ESD, ALSA, OSS, and native SGI. If available on the system, they can be accessed directly via oss-audio-out, esd-audio-in and the like, using the same sets of parameters. Think of audio-in and audio-out as sane default methods dependent on the system's capabilities. Those defaults can be configured via the GUIs preferences dialog, too.

Common parameters
device (string)
Sound device to be used. Note: While audio-in and audio-out are generic plugins, interpretation of the device parameter is dependent on the underlying sound system which the value is passed to unmodified. For example, OSS takes devices parameters like /dev/dsp where ALSA would like 0:0. If device is not set, the sound system's default device is used.
audio-in ports
out (output)
Recorded stream of sample data. Maximum number of allowed out-connections depends on hardware capabilities.
audio-in parameters
rate (integer)
The sample rate in Hertz.
duration (float)
Recording time in seconds. Defaults to no limit.
out::position (float)
Horizontal placement of sample stream in radians from -pi to pi.
audio-out ports
in (input)
Sample stream to play back. Maximum number of allowed in-connections depends on hardware capabilities.

audio-out has no further specific parameters.

Next: , Previous: Audio I/O, Up: In- and Output

5.1.2 File I/O

Transactions from and to files are handled by the plugins read-file and write-file. read-file is guaranteed to be able to read WAV files. Anything else is up to helper libraries that may or may not be installed on a system. write-file so far only second guesses the desired output format from the suffix of the given filename.

Common parameters
filename (string)
Name of the file to be read from or written to. The writer takes the filename suffix as a hint to the desired type of output. The filename parameter has no default and is required to be set.
read-file ports
out (output)
Sample data read in from a sound file. The number of allowed out-connections varies from file to file.
read-file parameters
out::position (float)
Horizontal placement of sample stream in radians from -pi to pi.
write-file ports
in (input)
Sample stream to store to a sound file. Maximum number of allowed in-connections depends on the desired sound format.
write-file parameters
filetype (int)
Type of the file to write. This is a libaudiofile AF_FILE_* constant. People who have libxml installed will see a option menu for the available types. If nothing is given, the type will be deduced from the filename extension.
sampleformat (int)
Sampleformat of the file, as defined by libaudiofiles AF_SAMPFMT_*. Default is signed.
samplewidth (int)
Sample width in bits. 16 is default.
compression (int)
Compression type, as defined by libaudiofiles AF_COMPRESSION_*. Default is no compression.

Next: , Previous: File I/O, Up: In- and Output

5.1.3 Swapfile I/O

The two plugins swapfile-in and swapfile-out are for streaming a swapfile into the network and storing a stream into the swapfile respectively. Both refer to tracks via swapfile filenames which are integer numbers.

Common parameters
filename (int)
Swapfile filename. This parameter is required to be set and there is no default value.
offset (int)
This parameter denotes the offset inside the file to start reading/writing from. The default is 0 which denotes the start of the file. Setting offset to a negative value will throw away samples for swapfile_out and feed in zeroes for swapfile_in.
size (int)
This parameter denotes the number of samples to read/write. The default is -1 which means to read the whole file / write all data. For sizes that in conjunction with offset exceed the file size, zeroes will be streamed in for swapfile_in, for swapfile_out the file will be extended.
swapfile-in ports
out (output)
Sample stream coming out of the swapfile.
swapfile-in parameters
rate (int)
The samplerate the data has.
position (float)
The position of the data in the stereo field.
flags (int)
Flags are 1 to endless stream data by looping the file.
swapfile-out ports
in (input)
Sample stream to be stored in the swapfile.
swapfile-out parameters
flags (int)
Flags are 1 to create the file, if it does not exist, 2 to truncate it before writing, 3 for both.

Previous: Swapfile I/O, Up: In- and Output

5.1.4 Abusing External Apps

This hackish filter allows to stream data coming from an external program that communicates through unix pipes. Note that at the moment neither pipe-in nor pipe-out seem to work reliably, but fail inside libc.

Common parameters
cmd (string)
Command string of the program which should be launched. This parameter is required to be set and there is no default value.
tail (string)
Extra tail to be appended to the command string, usually a filename. It defaults to an empty string.
pipe-in ports
Streams created out of the (possible interleaved) data coming from the external program. You have to ensure to connect two pipes if the external program generates stereo output. Dataformat is signed 16 bit in native endianness only.
pipe-in parameters
Sample rate of the data coming from the external program. Defaults to the compile-time setting of GLAME_DEFAULT_SAMPLERATE which is usually 44100 Hz.
pipe-out ports
Streams created out of the (possible interleaved) data coming from the external program. You have to ensure to connect two pipes if the external program generates stereo output. Dataformat is signed 16 bit in native endianness only.

Next: , Previous: In- and Output, Up: Plugin Collection

5.2 Elementary Plugins

Next: , Up: Elementary Plugins

5.2.1 Generating Waves

GLAME comes with a number of plugins to generate waveforms within a filter network. They can be useful as a debugging aid, but also as control input to other plugins. Imagine a sine wave generator hooked up to the position port of a panning filter... So far there is a sine plugin for generating sine waves, a const plugin yielding a block of constant data, a rect plugin creating a stream of steep pulses, a saw plugin for generating saw waves and a ramp plugin for generating saw waves. pulse generates a single pulse, steepness of the edges can be adjusted. noise generates white noise. wave emits a user editable chunk of wave. All plugins emit but a short chunk of data. For a continuous stream they have to be connected to a repeat node.

Common ports
out (output)
Generated data stream. Only one connection is allowed.
Common parameters
position (float)
Horizontal placement of sample stream in radians from -pi to pi.
rate (int)
Samplerate of generated data stream. Defaults to compile-time setting of GLAME_DEFAULT_SAMPLERATE, usually 44100 Hz.
const ports

const has no further specific ports.

const parameters
value (sample)
Constant signal value. Defaults to 0.
sine ports

sine has no further specific ports.

sine parameters
amplitude (sample)
Amplitude of generated sine wave. Allowed value range is from 0 to 1. Defaults to 0.5.
frequency (float)
Frequency of generated sine wave in Hz. Defaults to 441 Hz.
rect ports

rect has no further specific ports.

rect parameters
amplitude (sample)
Amplitude of generated rectangular wave. Allowed value range is from 0 to 1. Defaults to 1.0.
frequency (float)
Frequency of generated rectangular wave in Hz. Defaults to 440 Hz.
saw ports

saw has no further specific ports.

saw parameters
amplitude (sample)
Amplitude of generated saw wave. Allowed value range is from 0 to 1. Defaults to 1.0.
frequency (float)
Frequency of generated saw wave in Hz. Defaults to 440 Hz.
pulse ports

pluse has no further specific ports.

pulse parameters
time_on (time)
Time to start switching from neutral to on state. Ignored if zero.
time_off (time)
Time to start switching from on to neutral state. Ignored if zero.
duration (time)
Length of complete output in milliseconds.
attack (time)
Time in milliseconds to switch from neutral to on state.
release (time)
Time in milliseconds to switch from on to neutral state.
ramp ports

ramp has no further specific ports.

ramp parameters
amplitude (sample)
Amplitude of generated ramp wave. Allowed value range is from 0 to 1. Defaults to 1.0.
frequency (float)
Frequency of generated ramp wave in Hz. Defaults to 440 Hz.
noise ports

noise has no further specific ports.

noise parameters
amplitude (sample)
Amplitude of generated noise. Allowed value range is from 0 to 1. Defaults to 1.0.
wave ports

wave has no further specific ports.

wave parameters
wave (sample array)
The to be generated wave.

Next: , Previous: Generating Waves, Up: Elementary Plugins

5.2.2 Junctions and Dead Ends

In a filter network, data streams don't get created from nowhere, neither do they disappear into a big black void: there must be a plugin at each endpoint of a connection. These Plugins in turn are allowed to dump data or create new streams.

The drop plugin is used as a sink for data that is no longer needed within the network. Any incoming data is simply discarded. It's the dead end of a network.

If the same stream of data is needed more than once, it cannot simply be applied several times to different ports, it has to be duplicated first. one2n is the plugin to perform this task, it forks the network, so to speak.

mix on the other hand acts as a junction and merges several data streams into one, just like an ordinary mixing desk. mix drops all input data after all non-feedback input streams have terminated.

For some networks you may need intermediate buffering of data to prevent deadlocks. The buffer filter is the one you should consider using.

drop ports
in (input)
Data to be dropped. Any number of input connections is allowed.

drop has no parameters.

one2n ports
in (input)
Stream to be replicated.
out (output)
Replicated stream. Any number of output connections is allowed.

one2n has no parameters.

mix ports
in (input)
Audio streams to be mixed. Any number of input connections is allowed.
out (output)
Mixed audio stream.
mix parameters
in::gain (float)
Gain of the input. Defaults to 1.
in::offset (time)
Start mixing in input stream after relative time offset (in seconds). Defaults to 0.
gain (float)
Gain of the output stream. Defaults to 1.
position (float)
Horizontal placement of sample stream in radians from -pi to pi.
buffer ports
in (input)
Data stream to be buffered. Exactly one connection is allowed.
out (output)
Buffered data stream. Exactly one connection is allowed.
buffer parameters
size (int)
Size in bytes of the buffer.
time (float)
Size in seconds of the buffer. Can be used only for SAMPLE streams.

Next: , Previous: Junctions and Dead Ends, Up: Elementary Plugins

5.2.3 Mangling Data Streams

All the plugins described in this section operate on a single input stream and transform it into a slightly mangled single output stream. volume-adjust scales the amplitude of a data stream. delay and extend prepend and append zero samples to a data stream respectively. repeat resends an input sequence over and over for a fixed time or for ever. invert inverts all data of the input stream, i.e. each sample A is replaced by -A. stretch allows to lengthen or shorten a track in time, while trying to preserve its pitch. Obviously, stretch is no realtime effect.

Common ports
in (input)
Stream of input sample data.
out (output)
Stream of transformed output sample data.
invert parameters

invert has no parameters.

volume-adjust parameters
factor (float)
Value to scale input stream's amplitude with.
delay parameters
delay (time)
Input data stream is prepended with zero samples for delay milliseconds. Defaults to 0ms.
extend parameters
time (time)
Zero samples are appended to input stream for delay milliseconds. Defaults to 0ms.
repeat parameters
duration (time)
The input pattern is repeated until a total time of duration seconds is reached. Defaults to 0s which is endless repetition.
stretch parameters
stretchfactor (float)
Factor by which the duration of the track is changed. Only small deviations from 1 shall preserve an acceptable quality of the original sound. Larger values induce distortions, and are probably only useful for certain artistic effects.
buffersize (int)
A larger buffer size better preserves the pitch of the original sound, but also attenuates its high frequency part.
oversampling (int)
Simply put, the higher the oversampling the better the quality. However, similar to the buffer size parameter above, doing a lot of oversampling attenuates the high frequencies.

Next: , Previous: Mangling Data Streams, Up: Elementary Plugins

5.2.4 Orientation

The pan plugin distributes a mono sample stream to two stereo (left/right) output streams.

pan ports
in (input)
Mono stream to pan. Only a single connection allowed.
left-out (output)
right-out (output)
Left/right stereo output stream. Only one connection per port is allowed.
pan parameters
pan (float)
Pan value (virtual direction) of mono input stream. By default, pan uses the input pipe's position property as pan value. It is overridden if the pan parameter is set. Allowed values range from -pi/2 to pi/2. As the position property ranges from -pi to pi, values with magnitude larger than pi/2 (i.e. positions in the 'back') are mirrored to the front.

The render plugin renders any number of input streams with respect to their position inside the stereo field to any number of output streams with respect of their positions given by the pipe source position parameter of the connections. You can render your multi-track song to a stereo setup for example.

render ports
in (input)
Stream(s) to render. Any number of connections allowed.
out (output)
Output stream(s). Any number of connections allowed.
render parameters
out::position (float)
Parameter controlling the position of the output stream inside the stereo field. By default 0.0 is assumed (which is forward, or mono). The position property ranges from -pi to pi. To render multiple tracks to a stereo speaker setup provide -1.57 (left) and 1.57 (right) to two connected output pipes.

Next: , Previous: Orientation, Up: Elementary Plugins

5.2.5 Arithmetics

The plugins mul and add perform a simple arithmetic operations on several input streams. Basically, mul multiplies and add sums up any number of input sample streams. Operations are performed sample by sample–no check is performed whether sample rates match! If a stream is shorter than others, it is zero- (add) or one-padded (mul) internally.

Each plugin allows one multiplicative and one additive constant to be set. They are interpreted differently for each plugin however, reflecting the different algorithms:

mul calculates each output sample by taking one sample from each input pipe, adding add to it, multiplying the results, and finally multiplying the result by factor.

add calculates each output sample by taking one sample from each input pipe, summing them all up, adding the add parameter, and multiplying the result by factor.

Common ports
in (input)
Input sample stream. Any number of input connections is allowed.
out (out)
Output sample stream of computed data. Only one connection is allowed.
Common parameters
add (float)
Additive constant, see above. Defaults to zero.
factor (float)
Multiplicative constant, see above. Defaults to one.

There are neither further specific ports, nor further specific parameters.

Next: , Previous: Arithmetics, Up: Elementary Plugins

5.2.6 The Sample Analyst

The ssp_streamer plugin offers a gateway between sample and rms data. Streamed rms data can be used later for analyzing via the maxrms plugin. Unfortunately, RMS work within GLAME is still in its early stages, so its not that useful at the moment.

ssp_streamer ports
in (input)
Input sample stream to be converted.
out (output)
RMS data stream generated out of the sample input stream.
ssp_streamer parameters
bsize (samples)
Window size for computing the running average.
maxrms ports
in (input)
Input stream of RMS data.
maxrms parameters.
maxrms (output)
The maximum rms value found in the stream (sofar).

Next: , Previous: The Sample Analyst, Up: Elementary Plugins

5.2.7 Catching Bugs

Ping is a tool familiar to admins to test integrity and latency of a network connection. The ping plugin does the same within a GLAME filter network. It sends out a data packet from its output port and measures the time until the packet arrives at its input port. Obviously, the filter network should have a loop structure or ping will wait endlessly for an input. Debugging output goes to the console.

ping ports
in (input)
Input port packets are received at.
out (output)
Output port packets are sent from.
ping parameters
cnt (integer)
Number of packets to send. Defaults to 10.
dt (integer)
Time in microseconds between successive packets. Defaults to 250000 microseconds (1/4 second).
size (int)
Number of samples in a test packet. Defaults to 128 samples.

Previous: Catching Bugs, Up: Elementary Plugins

5.2.8 How to Code

The null and dup plugins aren't really meant to be used, they are simple reference implementations for developers looking for a quick introduction to plugin programming. null passes an input stream unmodified to its output, dup duplicates an input stream to two output streams. In real life, the more complex one2n plugin can be used to achieve the same results. So use the source, not these plugins.

Next: , Previous: Elementary Plugins, Up: Plugin Collection

5.3 Effects

Next: , Up: Effects

5.3.1 Echo

Guess what! The echo plugin adds an echo to an input stream.

echo ports
in (input)
Stream of input sample data. Only one connection is allowed.
out (output)
Mixed stream of input and echoed data. Only one connection is allowed.
echo parameters
time (time)
Delay time for echo in milliseconds. Defaults to 100 milliseconds.
mix (float)
Mix ratio of echoed to original stream. Defaults to 0.7.

Next: , Previous: Echo, Up: Effects

5.3.2 Noisegate

A noisegate is used to suppress signals below a certain threshold from an input stream. Its operation can be tuned by a number of parameters. When the input signal (its absolute value actually) falls below threshold_on for more than hold time, noisegate suppresses output until the signal goes back up and above threshold_off. Switching from and to zero output is usually not done instantaneously as this would lead to distorted sound. Instead, a fading time can be given by attack and release respectively.

noisegate ports
in (input)
out (output)
noisegate parameters
threshold_on (float)
threshold_off (float)
On and off threshold for sample data between 0 and 1, see above. Default to 0. A noisegating effect is only achieved if threshold_on is equal or less than threshold_off.
hold (time)
Hold time in milliseconds, see above. Defaults to 0.
attack (time)
Attack time in milliseconds, see above. Defaults to 0.
release (time)
Release time in milliseconds, see above. Defaults to 0.

Next: , Previous: Noisegate, Up: Effects

5.4 Spectrum

In the Spectrum category you'll find a collection of filters that alter the spectral composition of a sound. Currently included are a bandpass filter composed of chained Chebyshev lowpass/highpass stages, a one stage bandpass filter and a Chebyshev lowpass/highpass filter.

Next: , Up: Spectrum

5.4.1 bandpass

bandpass ports
in (input)
Input stream of sample data. Only one connection is allowed.
out (output)
Output stream of filtered sample data. Only one connection is allowed.
bandpass parameters
stages (integer)
defines the number of stages used for the low/highpass filter. The more stages you add, the more accurate is the impulse of the filter. Defaults to 1.
center (float)
Defines the center frequency of the passband. Defaults to 1000 Hz.
width (float)
Defines the width of the passband. Defaults to 500 Hz.
ripple (float)
ripple defines the percentage of ripple in the pass band. It defaults to 0.5, and it is best to leave it alone unless you know what you're doing.

Next: , Previous: bandpass, Up: Spectrum

5.4.2 bandpass_a

bandpass_a ports
in (input)
Input stream of sample data. Only one connection is allowed.
out (output)
Output stream of filtered sample data. Only one connection is allowed.
bandpass_a parameters
center (float)
Defines the center frequency of the passband. Defaults to 1000 Hz.
width (float)
Defines the width of the passband. Defaults to 500 Hz.

Next: , Previous: bandpass_a, Up: Spectrum

5.4.3 lowpass

lowpass ports
in (input)
Input stream of sample data. Only one connection is allowed.
out (output)
Output stream of filtered sample data. Only one connection is allowed.
lowpass parameters
stages (integer)
defines the number of stages used for the filter. The more stages you add, the more accurate is the impulse of the filter. Defaults to 1.
cutoff (float)
defines the cutoff frequency. Defaults to 1000 Hz.
ripple (float)
ripple defines the percentage of ripple in the pass band. It defaults to 0.5, and it is best to leave it alone unless you know what you're doing.

Previous: lowpass, Up: Spectrum

5.4.4 highpass

highpass ports
in (input)
Input stream of sample data. Only one connection is allowed.
out (output)
Output stream of filtered sample data. Only one connection is allowed.
highpass parameters
stages (integer)
defines the number of stages used for the filter. The more stages you add, the more accurate is the impulse of the filter. Defaults to 1.
cutoff (float)
defines the cutoff frequency. Defaults to 1000 Hz.
ripple (float)
ripple defines the percentage of ripple in the pass band. It defaults to 0.5, and it is best to leave it alone unless you know what you're doing.

Next: , Previous: Spectrum, Up: Effects

5.4.5 Flanger

The flanger effect is essentially a variable delay, that operates on a comb filtered signal. The variation of the delay is given by a low frequency oscillation (LFO). Dependent on the type of LFO you get different effects. The flanger is especially useful for guitar and voice sounds. With the right settings this implementation of the flanger can be used as a detune effect using a ramp up/down LFO and setting dry gain to zero.

flanger ports
in (input)
Input stream of sample data. Only one connection is allowed.
out (output)
Output stream of processed sample data. Only one connection is allowed.
flanger parameters
effect depth (float)
Size of delay buffer in ms. A larger depth allows for a larger sweep depth and more dramatic effects.
detune range (float)
The detune range defines the maximum oscillation amplitude of the LFO in ms and thereby modifies the intensity of the effect. The maximum value it can take is effect depth/2.
LFO Speed (float)
Specifies the oscillation frequency for the LFO. Good values are between 0.5 and 10 Hz. Higher frequencies generate rather weird sounds.
Dry/Wet Balance (float)
This parameter defines the ration of the dry signal to the effect(wet) signal, e.g. setting it to 0.0 you you only hear the wet signal, setting it to 1.0 you don't hear any effect.
feedback gain (float)
The feedback gain speficies the amount of the mixed dry/wet signal that is mixed to the input signal. Mixing is done according to: (inputsignal + feedbackgain * drywetsignal)
Gain (float)
Defines the amount of preamplification in the input stage of the flanger.
LFO type (int)
At the present time you can choose between three different LFO types:
A sine shaped LFO, which generates a sound sweeping up and down. Use for genuine flanger sound.
ramp up, generate a signal with higher frequency.
ramp down, generate a signal with lower frequency.
A fractal shaped LFO (more or less a random curve) creating a multichorus effect.

Previous: Flanger, Up: Effects

5.4.6 Distortion

The distortion effect simulates a MOSFET preamplifier with adjustable clipping. With a mode parameter one can switch between a halfwave and a fullwave rectifying output stage.

distortion ports
in (input)
Input stream of sample data. Only one connection is allowed.
out (output)
Output stream of processed sample data. Only one connection is allowed.
distortion parameters
pregain (float)
This parameters set the amount of signal gain before the signals enters the distortion stage. The more pregain you set the more dramatic the distortion becomes. Good values are between 10.0 and 20.0, defaults to 10.0
fxgain (float)
The distorted signal and the dry signal are mixed at the output. fxgain sets the amount of effect signal added to the dry signal, defaults to 1.0
clip, asym (float)
asym sets the signal midlevel for clipping. In mode 0 the signal is clipped if it's smaller than asym-clip or greater than asym+clip, e.g. clip=0.5 and asym=0.5 simulates a halfwave rectifier. Setting these values allows you to modify the harmonic content of the distorted signal. In mode 1 the signal is fully rectified and clipped at level <clip>.
mode (int)
0 enables asymmetrical clipping mode
1 enables fullwave rectifying mode

Next: , Previous: Effects, Up: Plugin Collection

5.5 FFT Plugins

Glame provides a simple framework of FFT filters to allow for the application of effects in the frequency domain of sample sounds. The core plugins are fft and ifft using the specially designed FFT protocol which supports adjustable FFT blocksizes and oversampling. All FFT processing is done based on the fftw ( library.

Next: , Up: FFT Plugins

5.5.1 fft

fft ports
in (input)
Input stream of sample data. Only one connection is allowed.
out (output)
Output stream of fft data. Only one connection is allowed.
fft parameters
blocksize (int)
This parameter sets the blocksize for the FFT. The higher the value the better the frequency resolution of the transformation.
oversamp (int)
To enhance the time resolution of the signal and thereby the quality of the resynthesized sound it is necessary to do oversampling. A good factor is the default value of 8.

Next: , Previous: FFT, Up: FFT Plugins

5.5.2 ifft

ifft ports
in (input)
Input stream of fft data. Only one connection is allowed.
out (output)
Output stream of sample data. Only one connection is allowed.
ifft parameters

The ifft plugin doesn't need any parameters. blocksize and oversampling factor are taken from the pipe properties.

Next: , Previous: IFFT, Up: FFT Plugins

5.5.3 fft_resample

Implements a resampler in the frequency domain.

fft_resample ports
in (input)
Input stream of fft data. Only one connection is allowed.
out (output)
Output stream of resampled fft data. Only one connection is allowed.
fft_resample parameters
frequency (int)
Frequency of resampled stream.

Next: , Previous: FFT Resample, Up: FFT Plugins

5.5.4 fft_bandpass

Implements a bandpass filter in the frequency domain.

fft_bandpass ports
in (input)
Input stream of fft data. Only one connection is allowed.
out (output)
Output stream of processed fft data. Only one connection is allowed.
fft_bandpass parameters
band minimum (float)
Minimum of passband in Hz.
band maximum (float)
Maximum of passband in Hz.
gain (float)
Gain in dB of passband.

Previous: FFT Bandpass, Up: FFT Plugins

5.5.5 fft_equalizer

Implements a five band equalizer in the frequency domain. It features a low, midlow, mid, midhigh and high band which are equally distributed over the frequency range. This distribution is not really usable, but it's a proove of concept at the present time..

fft_equalizer ports
in (input)
Input stream of fft data. Only one connection is allowed.
out (output)
Output stream of processed fft data. Only one connection is allowed.
fft_equalizer parameters
low (float)
Gain of low range band (not in dB)
midlow (float)
Gain of midlow range band (not in dB)
mid (float)
Gain of mid range band (not in dB)
midhigh (float)
Gain of midhigh range band (not in dB)
high (float)
Gain of high range band (not in dB)

Previous: FFT Plugins, Up: Plugin Collection

5.6 Operations

Next: , Up: Operations

5.6.1 Normalize

The normalize function can be invoked from the main menu or from the waveeditor widget. Normalize scans all given tracks for the highest peak in amplitude or the highest RMS peak for a given frequency window. You can normalize the signal in three different modes:

The maximum peak is adjusted to 1.0 with a factor given by the 1.0 divided by the max. peak.
The maximum peak is adjusted to the given amplitude(either absolute or dB).
The signal is scanned for the highest RMS energy in the given frequency and then adjusted to the given amplitude (either absolute or dB).
By pressing the analyze button in the normalize GUI, the file is just scanned and the found results are presented in the text box. If you don't press analyze, this step is done automatically after pressing the ok button.

Previous: Normalize, Up: Operations

5.6.2 Fade in/out

The fade in (and out) operations fade in (or out) the current selection linearly. These operations are only useful if invoked through the context menu of the waveedit window.

Previous: Plugin Collection, Up: Top

Function and Type Index

Table of Contents

[This page is only available in English.]
[Introduction] [Developers] [Links] [Manual] [Screenshots]

Created: Jan, 21st, 2000 (dk)
Last changed: Mar, 28th, 2005 (richi)