-
Notifications
You must be signed in to change notification settings - Fork 6
Getting Started
This will be a short walk-through, highlighting the most important controls, indicators, and program states. This tutorial will assume that you have your PC sound system configured properly, with your preferred JACK inputs and outputs routed appropriately. Loopidity will not start the JACK server for you. It will simply refuse to start, unless JACK is already running.
Loopidity is designed, such that the most useful functions can be controlled, using as few buttons as possible (a small number of foot pedals, for example).
NOTE: The current version of Loopidity does not yet have MIDI support. Use the following PC keyboard keys for now as the triggers:
SPACEBAR => Loop Toggle
KP0 => Scene Toggle
ESC => Undo Trigger
< The Loopidity program starts in what will be referred to as the the Idle State >
Before beginning, there are many interesting things on the screen already in the Idle State, that deserve a description.
Note the small grey frame on the left of the Loopidity window, within the larger yellow frame, which surrounds the top-most of three similar large frames. The small grey frame is the Loop Cursor; and the larger yellow frame is the Scene Cursor. Nearer to the bottom of the Loopidity window, are several additional frames, containing VU meters and histograms. The left-most frames are the per-channel output VUs and the mix-out histogram. The right-most frames are the per-channel input VUs and the mix-in histogram.
- The large frames represent "scenes", that are like mix-down tracks, and may each contain up to nine individual loop layers (over-dubs). Scenes can be thought of roughly analogous to the different movements of a song, which may have their own tempos and durations, such as "Verse", "Chorus", and "Bridge". Naturally, all individual tracks or "loops" within a segment, have the same tempo and duration.
- The large yellow frame indicates the scene that will become the next active scene. We will refer to this as the Scene Cursor.
- A large green frame, not visible at start-up, but similar to the yellow one described above, indicates the currently active scene. We will refer to this as the Active Scene Indicator.
- Small frames (like the grey one visible now) represent individual loop slots within a scene.
- One of the small frames (the only one visible at start-up) is special. This frame indicates the loop slot that is to be filled next. It is identified as the only one that may be colored yellow or red; and it will always be colored either yellow or red, except for in this special Idle State. There will only ever be one of them; and it will be always visible. We will refer to this as the Loop Cursor.
NOTE: Just to be clear on the terminology: these terms will be juxtaposed confusingly in this tutorial. The Loop Toggle and the Scene Toggle are some physical buttons (or "actuators") that you press, in order to control the program. The Loop Cursor and the Scene Cursor are the colorful boxes on the computer screen, that react to those toggle buttons. The Arm Flag and Scene-Change Flag are internal variables in the computer program, that store some information about those cursors. The Loop Toggle button controls the Arm Flag, which is represented on-screen by the Loop Cursor. The Scene Toggle button controls the Scene-Change Flag, which is represented on-screen by the Scene Cursor. Refer to the Default Controls Cheat Sheet.
To begin, press the Scene Toggle any number of times in succession, and notice the large yellow frame (the Scene Cursor), cycling over the three scenes in turn. It does not do very much now; because we are in the special Idle State, where there are no loops existing, and so there is nothing to do. This is also the only time that the Loop Cursor will be colored grey. None of this is very relevant right now, but was just to verify that the program is running properly, and the controls are operable.
While in the Idle State, press the Loop Toggle once, and notice that the grey Loop Cursor has changed it's color to red. This indicates that recording has begun, and that the beginning point of the scene pulse has been set. The Active Scene Indicator (the large green frame) should have also appeared, surrounding whichever scene was last selected with the Scene Toggle.
< We are now in the Initialization State - Armed: n/a , Scene-Change: false >
Now, make some noise for about 10 seconds; then press the Loop Toggle once more. Notice now, that the Loop Cursor has jumped ahead of it's original position, into the adjacent "slot", depositing a circle in it's wake. The ending point of the scene has now been set; and one complete loop layer has been saved in the scene. The leading base loop sets the length (or "pulse") for the entire scene. That circle is actually a rotating radial histogram, representing the audio signal of the loop that you just recorded. The small rectangle above that, is a standard linear histogram, which displays the same data, in an "unwrapped" form.
< We are now in the Active State - Armed: true , Scene-Change: false >
Without pressing any buttons, make some more noise while watching the yellow radial line rotating in a clock-like pattern. This line indicates that loop's beginning and ending point (or "seam"), with it's angle representing the progress (time position) of the playing loop, like a clock. In this way, the current playback position is always orientated toward the top "12-o-clock" position. The radial seam indicator has it's counterpart in the linear histogram, above the radial histogram; although that line is not fixed to the loop seam, but sweeps across the histogram, directly indicating the current playback position. Once this line reaches the right-most edge of it's linear histogram, and the rotating line, indicating the loop seam on the radial histogram, reaches the top "12-o-clock" position; something wonderful will happen: the Loop Cursor will jump ahead once more, leaving a new circle behind it. In the Idle State, the Arm Flag was set implicitly; so this new loop began recording automatically, when we exited the Initialization State. This is the auto-record feature in action: a behavior that will continue for as long as the Arm Flag is set (i.e. while the Loop Cursor is colored red).
< We are still in the Active State - Armed: true , Scene-Change: false >
Now, press the Loop Toggle once more, and notice that the color of the frame around the recording loop (the Loop Cursor ) has changed to yellow. This indicates that the auto-record feature has been suspended (i.e. the Arm Flag is reset). In this mode, no more loops will be saved, and the Loop Cursor will remain in it's current slot.
< We are still in the Active State - Armed: false , Scene-Change: false >
In this "disarmed" mode, you can rest on your laurels a bit and jam out; ignoring the computational machinery for the moment. You can toggle the Loop Cursor between yellow and red (setting and resetting the Arm Flag) at any time. It is no longer playing the role of a trigger in the Active State. Precise timing is important, only while recording the initial base loop (the "pulse") of each scene (i.e. in the Initialization State). The Arm Flag (and Loop Cursor color) has no effect nor significance, until the precise moment of the loop seam "rollover". In all states except for the Idle State, Loopidity is always recording, regardless of the color of the Loop Cursor. It is only just at that moment of the rollover, when the state of the Arm Flag determines whether the current buffer will be saved or discarded. The current recording will be saved, if the Loop Cursor was red (the Arm Flag set) during the rollover. The current recording will be discarded, if the Loop Cursor was yellow (the Arm Flag reset) during the rollover.
Most of the time that Loopidity is running, will be in the Active State. The only circumstances, under which it is sensible to change states now, are when switching into an empty scene (to create a new scene), or if you have decided to destroy the active scene and start over, or to stop entirely. Note again, that there is no concept of a "pause" in Loopidity. Loopidity is primarily for live performance; and as we know, life has no pause button. The transport is always synchronized with the pulse, when there is one. With the one caveat regarding the Undo Trigger and the Reset-Scene Trigger, as described in the next section), a Loopidity jam is always fluid (continuous) and linear (no early or late jumps) to minimize the potential for timing errors or "jerkiness" inherent in most loopers. If a spontaneous arbitrary pause is desired, it can be simulated by creating a new silent scene of the pause length.
Press now the Undo Trigger, and you should see that the last saved loop will be erased, and that the Loop Cursor will jump backwards, to occupy the slot that was just vacated. If you press the Undo Trigger repeatedly, the most recent loops will be erased in succession, until there are none remaining in the active scene. At that point, the cursor is in the first slot, the scene is without pulse, and we have necessarily returned to the Initialization State. As such, we have necessarily begun recording a new base loop now, to set a new scene pulse. The loop beginning point is always set upon transition to the Initialization State; but unlike the one and only initial transition from the Idle State, the loop beginning point is now set by the Undo Trigger, rather than the Loop Toggle.
If you press the Undo Trigger again now, it will immediately and silently reset the loop beginning point, discarding anything recorded since switching into the new scene. The Initialization State is the only deviation from the linearity explained above. We will remain in the Initialization State until the Loop Toggle is pressed, restoring linearity and transitioning to the Active State, just as before.
NOTE: There is a convenience feature, for the purpose of erasing an entire scene, and returning to the Initialization State quickly. This is triggered by the Reset-Scene Trigger. There also exists it's sister feature, for the purpose of quickly erasing all loops in all scenes, and returning to the Idle State. This is triggered by the Reset-All Trigger, and is equivalent to shutting down and restarting the program, but maintains audio routing connections.
Undo is not the only way to delete loops. Loops can be deleted at any time and in any order with the Delete Trigger.
You have already met the Scene Toggle when we were in the Idle State; but it can not do much there. You are familiar with the basics enough now to put it to good use. Go back as far as you like, and re-do the steps needed to get a few loops rocking as before. It would be helpful to make this scene a bit longer, say: 30 seconds or more, as to allow ample time to see the process unfold.
Once you have some long loops playing, wait until shortly after a rollover, and then press the Scene Toggle once. Notice that the large yellow frame (the Scene Cursor) has moved; but the large green frame (the Active Scene Indicator) has remained in place. Leave the Scene Cursor here for the moment.
< We are still in the Active State - Armed: false , Scene-Change: true >
Like it's cousin the Loop Toggle, the Scene Toggle has no immediately noticeable effect, other than changing the appearance of it's indicator; but it sets a flag (the Scene-Change Flag), which will be important at the time of the next rollover.
Also like the Loop Toggle, the Scene Toggle can be pressed freely any number of times. It cycles over the three scenes, setting the Scene-Change Flag when an idle scene is selected, and resetting the Scene-Change Flag when the currently active scene is selected. Once the rollover occurs, if the Scene Cursor coincides with the Active Scene Indicator, then nothing special happens; otherwise the scene will change, the Active Scene Indicator will move to the new scene, and the Scene-Change Flag will be reset automatically. Across most scene changes, we remain in the Active State; but there is one circumstance under which we must change states. Namely: the current circumstance, when changing into an empty scene; where we must transition back into the Initialization State, in order to establish a base loop for the new scene. However, linearity is preserved in this circumstance; because we entered the Initialization State automatically, instead of due to a manual trigger.
OK, after reading all of that, it is quite likely that your 30 second scene has rolled-over by now. If you were observing it at that time, you would have witnessed all of the playing loops stopping, and turning grey, and the Active Scene Indicator jumping to meet the Scene Cursor. The Loop Cursor should now be in the first empty slot of your chosen empty scene; and the recording of this scene's base loop, has begun automatically. As stated above, we are now in the Initialization State, awaiting the Loop Toggle to be pressed, before transitioning to the Active State of this new scene. You may notice that the Loop Cursor is red, indicating that the track is armed. Indeed that is true; but in this state, it is unrelated to the Arm Flag (which as you remember, we dis-armed before changing scenes). This will become obvious after the new base loop is recorded. In the Initialization State, it is necessary for the track to be armed, ignoring the Arm Flag; or else we could never create the all-important base loop for this scene (and escape this special state) without breaking linearity.
< We are now in the Initialization State - Armed: n/a , Scene-Change: false >
Press the Loop Toggle once more to save the recording loop, and return once more to the Active State. This time however, we are in a new scene; and the only loops which will play, are those which are recorded while this scene is active, until we change again to another scene. Notice now though, that the Loop Cursor is yellow, representing the state of the Arm Flag once again. If the Arm Flag had been set (the Loop Cursor red) during the scene change, it would still be armed (red) now.
< We are now in the Active State - Armed: false , Scene-Change: false >
These were the essential basics of operating Loopidity. You should be familiar enough now, to start laying down some serious shiznit. If you dig all that jazz about states and flags, you can refer to States and Flags, to gain a deeper understanding of Loopidity's inner workings.