Contact Digidesign's customer support. You should not notice any latency. The average latency is like 5-50 millionths of a second.
Pasted from a search:
Testing Latency
Latency is one of the lesser known, but nevertheless critical
issues in real-time digital audio systems. It can be tested quite
simply in SC2.
Digital audio systems deal with signals not as continous voltages,
but as numerical values that represent the signal for a given timespan.
This timespan depends on the sampling rate used; in fact, it is the
reciprocal of the sampling rate, so for for 44.1 kHz it would equal
1/44100 sec or 1/44.1 = 0.0226757 msec.
Theoretically this is the minimum time for the system to react to audio
input signals. However, in practice signals are calculated in blocks of
several numbers at a time, as this makes calculations much more
efficient. The default block size in SC2 is 64 samples, though it can be
changed if desired. 64 samples go by in (64/44.1) = 1.45125 msec,
so the system would only know about an input event with a time
delay of 1.45 msec! If it is to calculate a sound signal as a reaction to it,
this may take again as long.
This still is not the whole story, because the operating system (which is
the simplest way an application like SC2 can "talk" to the audio hardware)
may send even larger blocks (a.k.a. buffers) at a time. Buffer sizes are
usually powers of two, and 1024 to 4096 are common values for them.
OS programmers care more for efficiency than for musicians' realtime
needs. (Calculate how much delay a buffer of 4096 samples would introduce,
then try speaking with that much delay before hearing yourself.)
This is a problem for two reasons:
First, if you mix the live sound and sound processed through SC2 together,
the time lag will introduce phasing problems tha are likely to be quite audible.
(Short time delays in the 1-10 msec range are actually used for chorus and
flanger effects, see [5.2 Delays]).
And second, (10-200 msec) the system may respond too slowly to sound
input, which is potentially very distracting to musicians performing with this
system.
So how can you test the time delay (or latency) a system introduces?
Simply create an output impulse,
(physically!) connect it to an input,
record both input and output to different channels,
and compare them in a sound editor.
Lines 1 and 3 are actually a complete description for a patch, so you could
just go ahead and program it yourself for exercise.
Some hints: Before you start debugging your program, check the Audio Setup.
(Right hardware, Sound Input on...)
If necessary, write a little input test patch.
My program for this one is one line long. See below (later, of course).
When it works, you may also want to try different blockSizes, number of buffers,
etc. to see how much difference these changes make.
Some of my results for comparison:
I measured 28 msec for the Korg 1212 I/O card with block sizes 2 - 128.
How many samples are equivalent to that?
Using 4 buffers (also in the Audio Setup panel), I 'managed' to slow it down to 98 msec.
That would feel slow but be usable for e.g. tablet controlled synthesis, (as the delay
would only be half as long), but impossible for live effects or MIDI keyboard sounds.
Using 48 kHz instead of 44.1 resulted in slightly less:26 msec.
Also note how the unit impulse is modified by the conversion: its frequency Spectrum
goes above the audio range, and it is bandlimited by the analog filters after the
D/A conversion in the output and before A/D conversion in the input.
Try using a bandlimited signal just for comparison...
The Apple Hardware on my machine (G3/266) introduces a little more delay:
a little over 50 msec; try yours too, it may be different.
Solutions:
Synth.record(
{ [Pulse.ar(5, 1), AudioIn.ar(1)] }, // plug left output into left input,
// but record left input to right output!
// There is more than one way to do this.
duration: 2,
pathName: "LatencyTest"); // change the name for every new test,
// or SC2 will write over it...
(The reason I plug the left output back into the left input is simply because the Korg
1212 card that I use has a 1/4 inch TRS output for stereo, and a simple 1/4 inch
mono guitar cable will plug the left out back in most easily.)
The same patch as a one-liner:
Synth.record({ [Impulse.ar(5, 1), AudioIn.ar(1)] } , 2, "LatencyTest 48K");
Check audio input if necessary:
{ AudioIn.ar([1, 2]) }.scope;
Try a bandlimited Signal for comparison:
Synth.scope({Saw.ar(100, 0.5)}, 0.1);
Synth.record({ [Saw.ar(20, 0.2), AudioIn.ar(1) ] } , 2, "LatencyTest 48K");
More Exercises:
You can actually use that patch structure to test your
analog components and see how they handle signals:
Generate a test signal, patch it through e.g. an effects box,
patch the effects box output to the other channel,
and compare the two signals.
Or maybe go into an amplifier and loudspeaker, capture the sound
output with a high quality microphone and patch it back in for comparison.
