The sample rate is the frequency at which samples are taken from the analog signal. Sample rates are measured in hertz (Hz). A sample rate of 1 Hz is equal to one sample per second. For example, when a mono analog audio signal is digitized at a 48 kilohertz (kHz) sample rate, 48,000 digital samples are generated for every second of the signal.

To understand how the sample rate relates to sound quality, consider the fact that a telephone transmits voice-quality audio in a frequency range of about 320 Hz to 3.2 kHz. This frequency range can be represented accurately with a sample rate of 6.4 kHz. The range of human hearing, however, extends up to approximately 18–20 kHz, requiring a sample rate of at least 40 kHz.

The sample rate used for music-quality audio, such as the digital data stored on audio CDs is 44.1 kHz. A 44.1 kHz digital signal can theoretically represent audio frequencies from 0 kHz to 22.05 kHz, which adequately represents sounds within the range of normal human hearing. The most common sample rates used for DATs are 44.1 kHz and 48 kHz. Higher sample rates result in higher-quality digital signals; however, the higher the sample rate, the greater the signal storage requirement.

A sample frame is a set of audio samples that are coincident in time. A sample frame for mono data is a single sample. A sample frame for stereo data consists of a left-right sample pair. A sample frame for 4-channel data has two left-right sample pairs (L₁, R₁, L₂, R₂).

Stereo samples are interleaved; left-channel samples alternate with right-channel samples. 4-channel samples are also interleaved, but each frame has two left-right sample pairs.

Figure 6-1 shows the relationship between the number of channels and the frame size of audio sample data.

Figure 6-1. Audio Samples and Frames

The AL uses a digital data format called linear pulse code modulation (PCM) (see the audio references for a definition of this term) to represent digital audio samples.

The formats supported by the AL and the audio system are:

---

Note: The audio hardware supports 16-bit I/O for analog data and 24-bit I/O for AES/EBU digital data.

---

For floating point data, the application program specifies the desired range of values for the samples; for example, from -1.0 to 1.0.

The native data format used by the audio hardware is 24-bit two's complement integers. The audio hardware sign-extends each 24-bit quantity into a 32-bit word before delivering the samples to the Audio Library.

Audio input samples delivered to the Audio Library from the Indigo, Indigo², and Indy audio hardware have different levels of resolution, depending on the input source that is currently active; the AL provides samples to the application at the desired resolution. You can also write your own conversion routine if desired.

Microphone/line-level input samples come from analog-to-digital (A/D) converters, which have 16-bit resolution. These samples are treated as 24-bit samples with 0's in the low 8 bits.

AES/EBU digital input samples have either 20-bit or 24-bit resolution, depending on the device that is connected to the digital input; for the 20-bit case (the most common), samples are treated as 24-bit samples, with 0's in the least significant 4 bits. The AL passes these samples through to the application if 24-bit two's complement is specified. If two's complement with 8-bit or 16-bit resolution is specified, the AL right-shifts the samples so that they will fit into a smaller word size. For floating point data, the AL converts from the 24-bit format to floating point, using a scale factor specified by the application to map the peak integer values to peak float values.

For audio output, the AL delivers samples to the audio hardware as 24-bit quantities sign-extended to fill 32-bit words. The actual resolution of the samples from a given output port depends on the application program connected to the port. For example, an application may open a 16-bit output port, in which case the 24-bit samples arriving at the audio processor will contain 0's in their least significant 8 bits.

The Audio Library is responsible for converting between the output sample format specified by an application and the 24-bit native format of the audio hardware. For 8-bit or 16-bit integer samples, this conversion is accomplished by left-shifting each sample written to the output port by 16 bits and 8 bits, respectively. For 32-bit or 64-bit floating point samples, this con version is accomplished by rescaling each sample from the range of floating point values that is specified by the application to the full 24-bit range and then rounding the sample to the nearest integer value.

To create a new ALconfig structure that is initialized to the default settings, call ALnewconfig(). Its function prototype is:

ALconfig ALnewconfig ( void )

The ALconfig that is returned can be used to open a default ALport, or you can modify its settings to create the configuration you need. In Example 6-1, the channel, queue size, sample format, and floating point data range settings of an ALconfig named audioconfig are changed.

ALnewconfig() returns an ALconfig structure upon successful completion; otherwise, it returns 0 and sets an error code that you can retrieve by calling oserror(3C). Possible errors include:

An ALport can be configured for one, two, or four audio channels. The channel setting remains in effect as long as the port is open.

---

Note: Configuring an ALport to use four channels does not depend on the hardware configuration of the system on which the application is running. See “Querying and Controlling the Global Audio Device State” for information on configuring the hardware for 4-channel mode.

---

To set the number of channels for an ALconfig structure, call ALsetchannels(). Its function prototype is:

int ALsetchannels ( ALconfig config, long channels )

where:

Any ALport that you open with this config will have the number of channels that you set in channels.

ALsetchannels() returns 0 upon successful completion; otherwise, it returns -1 and sets an error code that you can retrieve by calling oserror(3C). Possible errors include:

To retrieve the channel setting of a given ALconfig structure, call ALgetchannels(). Its function prototype is:

long ALgetchannels ( ALconfig config )

where:

ALgetchannels() returns the channel setting of config, upon successful completion; otherwise, it returns -1 and sets an error code that you can retrieve by calling oserror(3C). Possible errors include:

Selecting the proper size for the sample queue is very important, because continuous sound output depends on the ability of the application to fill the queue at least as fast as the hardware empties it. For example, if the queue is too small, the application may take too long supply new samples, resulting in audible breaks that sound like pops or clicks. The size of the queue determines the maximum delay that can be tolerated while waiting for the application to get more samples at the given sample rate. To determine how much space to allocate for the sample queue, consider the data type and rate. For example, the default queue size of 100,000 samples provides buffer space for slightly more than one second of 48 kHz stereo audio data, and a little more than three seconds of 32 kHz mono data. To better understand these phenomena, see Figure 6-2 on page 91 for an illustration of a sample queue and read the associated discussion.

---

Tip: The main point to be concerned about is how full to keep the queue, regardless of its size. If the queue is full, more time passes before samples are played. The ideal situation is to keep enough samples in the queue to allow for the longest possible delay that will be experienced in retrieving the next batch of samples. See “Real-time Programming Techniques for Audio” for an explanation of how to set the fill threshold for a queue.

---

The noninclusive values for minimum and maximum allowable queue sizes for ALports on Indigo, Indigo², and Indy workstations are listed in Table 6-1

To specify an ALconfig with a sample queue size other than the default for an ALport, call ALsetqueuesize(). Its function prototype is:

int ALsetqueuesize ( ALconfig config, const long size )

where:

Any ALport that you open with this config will have a queue size of size.

ALsetqueuesize() returns 0 upon successful completion; otherwise, it returns -1 and sets an error code that you can retrieve by calling oserror(3C). Possible errors include:

To retrieve the size of the sample queue in a given ALconfig structure, call ALgetqueuesize(). Its function prototype is:

long ALgetqueuesize ( ALconfig config )

where:

ALgetqueuesize() returns the queuesize of config upon successful completion; otherwise, it returns -1 and sets an error code that you can retrieve by calling oserror(3C). Possible errors include:

The AL allows you to choose between three sample formats:

To set the sample format type of a given ALconfig structure, call ALsetsampfmt(). Its function prototype is:

int ALsetsampfmt ( Alconfig config, long sampleformat )

where:

Any ALport that you open with this config will have a sample format of sampleformat.

ALsetsampfmt() returns 0 upon successful completion; otherwise, it returns -1 and sets an error code that you can retrieve by calling oserror(3C). Possible errors include:

To retrieve the sample format of a given ALconfig structure, call ALgetsampfmt(). Its function prototype is:

long ALgetsampfmt ( ALconfig config )

where:

ALgetsampfmt() returns the sampleformat setting of config upon successful completion; otherwise, it returns -1 and sets an error code that you can retrieve by calling oserror(3C). Possible errors include:

The sample width represents the degree of precision to which the full-scale range of an audio signal can be sampled. You can specify the width of two's complement integer sample data, but you can't specify the width of floating point samples. Thus, setting the sample width has no effect when the sample format is AL_SAMPFMT_FLOAT or AL_SAMPFMT_DOUBLE; however, the width setting does have an effect if the sample format is subsequently changed to AL_SAMPFMT_TWOSCOMP.

The sample width also determines which data type the AL uses when reading and writing samples. The sample widths available for two's complement data, and their associated resolutions and data types, are:

For all sample widths, sample values map linearly to intermediate signal amplitudes.

To specify the sample width setting of two's complement data for an ALconfig structure, call ALsetwidth(). Its function prototype is:

int ALsetwidth ( ALconfig config, long samplesize )

where:

Any ALport that you open with this config will have a sample width of samplesize.

ALsetwidth() returns 0 upon successful completion; otherwise it returns -1 and sets an error code that you can retrieve by calling oserror(3C). Possible errors include:

To retrieve the current sample width setting of an ALconfig structure, call ALgetwidth(). Its function prototype is:

long ALgetwidth ( ALconfig config )

where:

ALgetwidth() returns the samplesize of config upon successful completion; otherwise, it returns -1 and sets an error code that you can retrieve by calling oserror(3C). Possible errors include:

If you configure an ALport to use floating point data (a sample format of either AL_SAMPFMT_FLOAT or AL_SAMPFMT_DOUBLE), you need to define a maximum value in order to set the upper and lower bounds of the samples that pass through that port. Setting the floating point maximum value specifies a symmetrical range that is centered about zero.

---

Tip: To have more control over the scaling, you can program your application to perform its own floating point-to-integer conversion before passing samples through the ALport.

---

To set the maximum value of floating point data, call ALsetfloatmax(). Its function prototype is:

int ALsetfloatmax ( ALconfig config, double maximum_value )

where:

Samples read into any ALport that you open with this config are scaled to the range [-μαξιμυμ_ϖαλυε, maximum_value]. Samples output from this ALport should be in the range [-μαξιμυμ_ϖαλυε, maximum_value] to avoid limiting. The default maximum value is 1.0.

---

Note: The number of quantization steps that can be represented by floating point samples is a function of the value of maximum_value. If maximum_value is too small, you will not be able to represent 216 evenly spaced amplitude levels.

---

ALsetfloatmax() has no function when the sample format is AL_SAMPFMT_TWOSCOMP; however, the maximum_value setting takes effect if the sample format is subsequently changed to AL_SAMPFMT_FLOAT or AL_SAMPFMT_DOUBLE.

ALsetfloatmax() returns 0 upon successful completion; otherwise, it returns -1 and sets an error code that you can retrieve by calling oserror(3C). Possible errors include:

To retrieve the floating point maximum value, call ALgetfloatmax(). Its function prototype is:

double ALgetfloatmax ( Alconfig config )

where:

ALgetfloatmax() returns the maximum_value of config upon successful completion; otherwise, it returns 0 and sets an error code that you can retrieve by calling oserror(3C). Possible errors include:

You can retrieve an ALconfig whose settings match those of an existing ALport. This is an easy way to create an ALconfig to use for changing the dynamic settings of an ALport, as described next in “Modifying the Audio Data Attributes of an Open ALport”.

To retrieve a new ALconfig structure that is a clone of an existing ALconfig structure already in use by an existing audio port, call ALgetconfig(). Its function prototype is:

ALconfig ALgetconfig ( ALport port )

where:

You should call ALfreeconfig() to deallocate the ALconfig when it is no longer needed.

ALgetconfig() returns an ALconfig structure upon successful completion; otherwise, it returns 0 and sets an error code that you can retrieve by calling oserror(3C). Possible errors include:

In general, you don't change the settings for an ALport while it is open, but sometimes you might need to modify the audio data attributes of an ALport while it is open. For example, to create continuous output from multiple sound files that have different sample widths, such as 8-bit and 16-bit data, an application might need to change the sample width of the output port to match the output data, without closing and reopening the port, in order to prevent interruptions in the output.

To change the data attributes of an ALport instantaneously, use ALsetsampfmt(), ALsetfloatmax(), and ALsetwidth() as needed to define the settings of an ALconfig, which you then pass to the ALsetconfig() routine. The only settings that can be modified with this method are the sample format, the sample width, and the maximum floating point value. You can't use this method to change the audio device, the queue size, or the number of channels in an ALport.

ALsetconfig() changes an audio port's ALconfig structure to match that of a given ALconfig. Its function prototype is:

int ALsetconfig ( ALport port, ALconfig config )

where:

ALsetconfig() returns 0 upon successful completion; otherwise, it returns -1 and sets an error code that you can retrieve by calling oserror(3C). Possible errors include:

To minimize memory consumption, you should free the memory associated with an ALconfig that is no longer needed. An ALconfig is no longer needed if the application is not going to open any more ports with it.

To deallocate an ALconfig structure, call ALfreeconfig(). Its function prototype is:

int ALfreeconfig ( ALconfig config )

where:

ALfreeconfig() returns 0 on successful completion; otherwise, it returns -1 and sets an error code that you can retrieve by calling oserror(3C). Possible errors include:

This section explains how to use the AL routines for monitoring the status of an ALport's sample queue.

The AL maintains the following status information about the queue:

The sum of the empty locations and the full locations is the total size of the queue:

filled + fillable = queuesize

Checking the filled and fillable statuses before reading and writing prevents blocking and helps prevent overflow and underflow errors.

ALgetfillable() and ALgetfilled() provide instantaneous information on the state of an audio port's queue.

To prevent blocking during output, you can determine how many samples will fit into the queue by calling ALgetfillable() before writing any samples, and then write only that many samples to the queue.

To get the number of empty queue locations in a given ALport, call ALgetfillable(). Its function prototype is:

long ALgetfillable ( ALport port )

where:

The value returned indicates how many samples can still be written without blocking.

To prevent blocking during input, you can determine how many samples are in the queue by calling ALgetfilled() before reading any samples, then read only that many samples from the queue. You can also periodically check ALgetfilled() to find out whether all of your output data has drained before you shut down a port by calling ALcloseport().

To find out how many queue locations in a given audio port currently have valid samples in them at a given instant, call ALgetfilled(). Its function prototype is:

long ALgetfilled ( ALport port )

where:

The value returned indicates how many samples can still be read without blocking if port is an input port or how many samples have yet to be played if it is an output port.

Besides using these routines, you can use ALgetstatus() to check for underflow and overflow errors, as described in “Detecting Errors in the Audio Stream”.

“Real-time Programming Techniques for Audio” discusses how to use several other routines that allow an application to view and modify the dynamic state of an audio port. These routines are most useful in developing real-time audio applications.

ALreadsamps() reads a specified number of samples from an input port to a sample data buffer, blocking until the requested number of samples have been read from the port. Its function prototype is:

int ALreadsamps( const ALport port, void *samples,
                 const long samplecount )

where:

To prevent blocking, samplecount must be less than the return value of ALgetfilled().

---

Note: When the application is reading samples into an ALport that has channels set to 4, samplecount must be an integer multiple of the frame size, or an error will be returned and no samples will be transferred.

---

When 4-channel data is input on systems that do not support 4 line-level electrical connections, that is, when setting AL_CHANNEL_MODE to AL_4CHANNEL is not possible, ALreadsamps() will provide 4 samples per frame, but the second pair of samples will be set to 0.

Table 6-2 shows the input conversions that are applied when reading mono, stereo, and 4-channel input in stereo mode (default) and in 4-channel mode hardware configurations. Each entry in the table represents a sample frame.

---

Note: If the summed signal is greater than the maximum allowed by the audio system, it is clipped (limited) to that maximum, as indicated by the Clip function.

---

Samples placed in an output queue are played by the audio hardware after a specific amount of time, which is equal to the number of samples that were present in the queue before the new samples were written, divided by the (sample rate × number of channels) settings of the ALport.

ALwritesamps() writes a specified number of samples to an output port from a sample data buffer, blocking until the requested number of samples have been written to the port. Its function prototype is:

int ALwritesamps ( ALport port, void *samples,
                   long samplecount )

where:

---

Note: When the application is writing samples from an ALport that has channels set to 4, samplecount must be an integer multiple of the frame size, or an error will be returned and no samples will be transferred.

---

Table 6-3 shows the output conversions that are applied when writing mono, stereo, and 4-channel data to stereo mode (default) and 4-channel mode hardware configurations.

ALqueryparams() asks the audio device to supply a list of descriptors and corresponding descriptions for all the currently available global state variables. Its function prototype is:

long ALqueryparams ( long device, long *PVbuffer,
                     long bufferlength )

where:

ALqueryparams() returns a long value representing the buffer size necessary to hold all parameters and their values. If your PVbuffer is of smaller dimensions than this value, you have not received a complete set of descriptor/description pairs for device. See Table 6-5 for a list of currently supported core global parameters. See Table 6-6 for a list of special global parameters that are not supported on all systems.

ALsetparams() lets you modify the values of many of these global parameters, though you should take care in using these functions. See the description of ALsetparams() at the end of this section for details.

ALgetminmax() obtains maximum and minimum values for a given global parameter. Its function prototype is:

int ALgetminmax( long device, long param, long *minparam,
                 long *maxparam )

where:

ALgetdefault() returns the default value for a given audio hardware device state parameter. Its function prototype is:

long ALgetdefault ( long device, long parameter )

where:

ALgetname() returns a pointer to a null-terminated string that can be used to label an audio hardware device state parameter. Treat this string as a read-only string. Its function prototype is:

char* ALgetname ( long device, long parameter )

Table 6-7 lists the global parameter name strings.

ALgetparams() gets the current value(s) of the device parameters referenced in the PVbuffer. Its function prototype is:

int ALgetparams ( long device, long *PVbuffer,
                  long bufferlength )

where:

ALgetparams() fills the odd (1, 3, 5, …) entries in the PVbuffer array with the current values associated with each corresponding parameter.

See Table 6-5 for a description of the currently supported core global parameters. See Table 6-6 for a list of special global parameters that are not supported on all systems.

ALsetparams() sets the current value(s) of one or more audio hardware device parameters. Its function prototype is:

int ALsetparams ( long device, long *PVbuffer,
                  long bufferlength )

where:

See Table 6-5 for a description of the currently supported core global parameters. See Table 6-6 for a list of special global parameters that are not supported on all systems.

When an application program modifies a global state parameter such as the output sample rate, it may affect other processes on the system that are also engaged in audio processing. For example, if one application is playing a 44.1 kHz recording through an output port, and a second application changes the global output sample rate from 44.1 kHz to 16 kHz, the output of the original application will be distorted.

To determine whether other audio applications are running, query the system for open input or output ports. To determine the total number of ports available on your system, add the values returned for AL_INPUT_COUNT, AL_OUTPUT_COUNT, and AL_UNUSED_COUNT.

Example 6-3 demonstrates querying for other active audio output.

/*
 * 'Nonrude' behavior is defined as follows: before modifying global values, first check
 * to see whether any other output ports are currently active; if any other processes have
 * open output ports, don't modify anything.
 */
...
rude = 0;
...
/*
 * Need to determine whether audio is in use. If not, then we
 * can just go ahead and be "rude."
 */
pvbuf[0] = AL_OUTPUT_COUNT;
pvbuf[2] = AL_MONITOR_CTL;
if (ALgetparams(AL_DEFAULT_DEVICE, pvbuf, 4) < 0) {
    if (oserror() == AL_BAD_DEVICE_ACCESS) {
    fprintf(stderr,"%s: Can't play -- could not access audio hardware.\n");
    return -1;
    }
}
if ((pvbuf[1] == 0) && (pvbuf[3] == AL_MONITOR_OFF)) {
    rude = 1;
    }

Querying the system for an input or output rate must be done carefully in order to obtain a valid result. Example 6-4 contains two routines, get_input_rate() and get_output_rate(), each of which returns a rate either in Hz or AL_RATE_UNDEFINED if the rate cannot be determined. A minimal main() program calls the routines. See ratequery.c in /usr/people/4Dgifts/examples/dmedia/audio for another example of rate querying.

#include <audio.h>
...
/*
 * These routines expect to be run with the AL error handler shut off.
 * (call ALseterrorhandler(0)).
 */
...
int
get_input_rate()
{
    long buf[6];
...
    buf[0] = AL_INPUT_RATE;
    buf[2] = AL_INPUT_SOURCE;
    buf[4] = AL_DIGITAL_INPUT_RATE;
    ALgetparams(AL_DEFAULT_DEVICE,buf,6);
...
    if (buf[1] == AL_RATE_AES_1 || buf[3] == AL_INPUT_DIGITAL) {
        /*
         * We are clocked off of the digital input. Find the
         * real input rate, if we can. 
         */
        if (ALgetdefault(AL_DEFAULT_DEVICE,AL_DIGITAL_INPUT_RATE) >= 0) {
            return buf[5];
        }
    }
    else if (buf[1] > 0) {
        /*
         * Input rate is in Hz and we're using an analog input -- return rate.
         */
        return buf[1];
    }
    return AL_RATE_UNDEFINED;
}
...
int
get_output_rate()
{
    long buf[4];

    buf[0] = AL_OUTPUT_RATE;
    buf[2] = AL_DIGITAL_INPUT_RATE;
    ALgetparams(AL_DEFAULT_DEVICE,buf,4);
    if (buf[1] > 0) {
        /*
         * Output rate is in Hz -- return it.
         */
        return buf[1];
    }
    else {
        /*
         * Output rate is a logical rate -- track down what it means.
         */
        if (buf[1] == AL_RATE_AES_1) {
            /*
             * We are clocked off of the digital input. Find the
             * real input rate, if we can. If we can't, return AL_RATE_UNDEFINED
             */
            if (ALgetdefault(AL_DEFAULT_DEVICE,AL_DIGITAL_INPUT_RATE) >= 0) {
                return buf[3];
            }
        }
        else if (buf[1] == AL_RATE_INPUTRATE) {
            return get_input_rate();
        }
    return AL_RATE_UNDEFINED;
    }
}
...
main()
{
    int x;
    ALseterrorhandler(0);
    x = get_output_rate();
    if (x == AL_RATE_UNDEFINED) {
        printf("can't get output rate\n");
    }
    else {
        printf("output rate = %d\n",x);
    }
    x = get_input_rate();
    if (x == AL_RATE_UNDEFINED) {
        printf("can't get input rate\n");
    }
    else {
        printf("input rate = %d\n",x);
    }
}

Although you can open a 4-channel ALport on any system, you cannot change the system's electrical configurations if it does not support 4-channel mode.

To determine whether a system has 4-channel capability, use ALgetminmax(), then verify that the maximum value is 4.

Example 6-5 demonstrates how to query for 4-channel hardware capability.

/*
 * Query to see if we are on a machine with 4-channel
 * HW capability. If so,switch into 4-channel mode.
 * If AL_CHANNEL_MODE both exists (ALgetminmax doesn't
 * fail) AND has a maximum of 4,then we're OK.
 * 
 * If we wanted to be really nice,  we could check, 
 * by querying AL_INPUT_COUNT and AL_OUTPUT_COUNT, to
 * see if any other apps were doing audio. If so,  we
 * might not want to switch to 4-channel mode,  lest
 * we introduce artifacts into their audio streams.
 */
if (ALgetminmax(AL_DEFAULT_DEVICE, AL_CHANNEL_MODE, 
    &min, &max) >= 0 && max == 4) {
    long buf[2];
    buf[0] = AL_CHANNEL_MODE;
    buf[1] = 4;
    ALsetparams(AL_DEFAULT_DEVICE, buf, 2);
}
/*
 * Even if we don't have 4-channel HW capability, 
 * the AL will let us use a 4-channel buffer,  so 
 * we can continue at this point without regard to
 * HW type.
 */

ALgetfd() returns an IRIX file descriptor for a port that may be used with the select() call. Its function prototype is:

int ALgetfd ( ALport port )

where:

When using select(), an input port's file descriptor is used in a read fdset and an output port's file descriptor is used in a write fdset.

When using poll(), an input port's file descriptor is used with the POLLIN event flag and an output port's file descriptor is used with the POLLOUT event flag.

These select() and poll() system calls are used to give up application control of the CPU until the audio port is emptied or filled past a previously set fill point (see the description of ALsetfillpoint() below).

ALsetfillpoint() allows an application to set a threshold level for an input or output port that controls the behavior of the select() function. Its function prototype is:

int ALsetfillpoint ( ALport port, long fillpoint )

where:

For an input port, the fill point is the number of locations in the sample queue that must be filled in order to trigger a return from select(). For an output port, the fill point is the number of locations that must be free in order to wake up from select().

When used in conjunction with ALgetfd() and select() or poll(), ALsetfillpoint() lets you programmatically relinquish control from an audio application to other processes.

---

Note: ALreadsamps() and ALwritesamps() may alter the fill point, so you should (re)set it just before you call select() or poll().

---

ALgetfillpoint() returns the current fill point of a port. Its function prototype is:

long ALgetfillpoint ( ALport port )

where:

Figure 6-4 shows how the relationship between the number of samples and the fill point affects the behavior of the select() call during input and output.

Figure 6-4. Using Fill Points