Hello. The text is copy from other blog , I delete and
addition some . The blog is : http://blog.csdn.net/heanyu/article/details/6339783 (thanks him).
Audio device(声卡): (说明 与 区别)
/dev/dsp 、/dev/dspW、/dev/audio:读这个设备就相当于录音,写这个设备就相当于放音。
/dev/dsp与/dev/audio之间的区别在于采样的编码不同,
/dev/audio使用μ律编码,
/dev/dsp使用8-bit(无符号)线性编码,
/dev/dspW使用16-bit(有符号)线形编码。
/dev/audio主要是为了与SunOS兼容,所以尽量不要使用。
/dev/dsp is the digital sampling and digital recording
device, and probably the most important for multimedia
applications. Writing to the device accesses the D/A converter to
produce sound. Reading the device activates the A/D converter for
sound recording and analysis.
The name DSP comes from the term digital signal
processor, a specialized processor chip optimized for digital
signal analysis. Sound cards may use a dedicated DSP chip, or may
implement the functions with a number of discrete devices. Other
terms that may be used for this device are digitized voice
and PCM.
Some sounds cards provide more than one digital sampling device;
in this case a second device is available as /dev/dsp1.
Unless noted otherwise, this device operates in the same manner as
/dev/dsp.
The DSP device is really two devices in one. Opening for
read-only access allows you to use the A/D converter for sound
input. Opening for write only will access the D/A converter for
sound output. Generally speaking you should open the device either
for read only or for write only. It is possible to perform both
read and write on the device, albeit with some restrictions; this
will be covered in a later section.
Only one process can have the DSP device open at a time.
Attempts by another process to open it will fail with an error code
of EBUSY.
Reading from the DSP device returns digital sound samples
obtained from the A/D converter. Figure 14-2(a)
shows a conceptual diagram of this process. Analog data is
converted to digital samples by the analog to digital converter
under control of the kernel sound driver and stored in a buffer
internal to the kernel. When an application program invokes the
read system call, the data is transferred to the calling program's
data buffer. It is important to understand that the sampling rate
is dependent on the kernel driver, and not the speed at which the
application program reads it.
访问/dev/dsp时:
1.如果读取太慢(低于采样率),就会抛弃超出的数据,产生空隙。如果太快,就会阻塞进程。
2.Writing a sequence of digital sample values to the DSP device
produces sound output. This process is illustrated in Figure 14-2(b). Again, the format can be defined using ioctl
calls, but defaults to the values given above for the read system
call (8-bit unsigned data, mono, 8 kHz sampling).
写入一系列数字采样就能产生声音。通过ioctl系统调用能够改变数据的格式。
If the data are written too slowly, there will be dropouts or
pauses in the sound output. Writing the data faster than the
sampling rate will simply cause the kernel sound driver to block
the calling process until the sound card hardware is ready to
process the new data. Unlike some devices, there is no support for
non-blocking I/O.
如果写入太慢,声音数据就会有间断。如果写入太快,就会阻塞进程;不像一些设备,没有non-blocking I/O。
When reading from /dev/dsp you will never encounter an
end-of-file condition. If data is read too slowly (less than the
sampling rate), the excess data will be discarded, resulting in
gaps in the digitized sound. If you read the device too quickly,
the kernel sound driver will block your process until the required
amount of data is available.
The input source depends on the mixer setting (which I will look
at shortly); the default is the microphone input. The format of the
digitized data depends on which ioctl calls have been used to set
up the device. Each time the device is opened, its parameters are
set to default values. The default is 8-bit unsigned samples, using
one channel (mono), and an 8 kHz sampling rate.
Writing a sequence of digital sample values to the DSP device
produces sound output. This process is illustrated in Figure 14-2(b).
Again, the format can be defined using ioctl calls, but defaults to
the values given above for the read system call (8-bit unsigned
data, mono, 8 kHz sampling).
If the data are written too slowly, there will be dropouts or
pauses in the sound output. Writing the data faster than the
sampling rate will simply cause the kernel sound driver to block
the calling process until the sound card hardware is ready to
process the new data. Unlike some devices, there is no support for
non-blocking I/O.
If you don't like the defaults, you can change them through
ioctl calls. In general you should set the parameters after
opening the device, and before any calls to read or write.
You should also set the parameters in the order in which they are
described below.
All DSP ioctl calls take a third argument that is a pointer to
an integer. Don't try to pass a constant; you must use a variable.
The call will return -1 if an error occurs, and set the global
variable errno.
If the hardware doesn't support the exact value you call for,
the sound driver will try to set the parameter to the closest
allowable value. For example, with my sound card, selecting a
sampling rate of 9000 Hz will result in an actual rate of 9009 Hz
being used.
If a parameter is out of range, the driver will set it to the
closest value (i.e., the upper or lower limit). For example,
attempting to use 16-bit sampling with an 8-bit sound card will
result in the driver selecting 8 bits, but no error will be
returned. It is up to you, the programmer, to verify that the value
returned is acceptable to your application.
All of the ioctl calls for the DSP device are names starting
with SOUND_PCM. Calls in the form
SOUND_PCM_READ_XXX are used to return just the
current value of a parameter. To change the values, the ioctl calls
are named like SOUND_PCM_WRITE_XXX. As discussed
above, these calls also return the selected value, which is not
necessarily the same as the value passed to the sound driver.
The ioctl constants are defined in the header file
linux/soundcard.h. Let's examine each of them in detail.
SOUND_PCM_WRITE_BITS
Sets the sample size, in bits. Valid choices are 8 and 16, but
some cards do not support 16.
SOUND_PCM_READ_BITS
Returns the current sample size, which should be either 8 or 16
bits.
SOUND_PCM_WRITE_CHANNELS
Sets the number of channels--1 for mono, 2 for stereo. When
running in stereo mode, the data is interleaved when read or
written, in the format left-right-left-right.... Remember that some
sound cards do not support stereo; check the actual number of
channels returned in the argument.
SOUND_PCM_READ_CHANNELS
Returns the current number of channels, either 1 or 2.
SOUND_PCM_WRITE_RATE
Sets the sampling rate in samples per second. Remember that all
sound cards have a limit on the range; the driver will round the
rate to the nearest speed supported by the hardware, returning the
actual (rounded) rate in the argument. Typical lower limits are 4
kHz; upper limits are 13, 15, 22, or 44 kHz.
SOUND_PCM_READ_RATE
Returns just the current sampling rate. This is the rate used by
the kernel, which may not be exactly the rate given in a previous
call to SOUND_PCM_WRITE_RATE, because of the previously discussed
rounding.
你可以通过ioctl控制设备(这是当然的,任何能被系统识别的设备都必须提供这一个接口。要记住操作系统是有这方面的优势的。)如果你所设定的参数不适合,那么会自动选择最为接近的参数。如果超出了范围也会选择上限。不会返回错误。
使用SOUND_PCM_READ_XXX
来读取现在的设备参数。使用SOUND_PCM_WRITE_XXX来设置设备参数。下面介绍几个重要参数:
SOUND_PCM_WRITE_BITS
Sets the sample size, in bits. Valid choices are 8 and 16, but
some cards do not support 16.
设置数据样本的位数,8或16位。
SOUND_PCM_READ_BITS
Returns the current sample size, which should be either 8 or 16
bits.
SOUND_PCM_WRITE_CHANNELS
Sets the number of channels--1 for mono, 2 for stereo. When
running in stereo mode, the data is interleaved when read or
written, in the format left-right-left-right.... Remember that some
sound cards do not support stereo; check the actual number of
channels returned in the argument.
设置声道。
SOUND_PCM_READ_CHANNELS
Returns the current number of channels, either 1 or 2.
SOUND_PCM_WRITE_RATE
Sets the sampling rate in samples per second. Remember that all
sound cards have a limit on the range; the driver will round the
rate to the nearest speed supported by the hardware, returning the
actual (rounded) rate in the argument. Typical lower limits are 4
kHz; upper limits are 13, 15, 22, or 44 kHz.
设置采样率。
SOUND_PCM_READ_RATE
Returns just the current sampling rate. This is the rate used by
the kernel, which may not be exactly the rate given in a previous
call to SOUND_PCM_WRITE_RATE, because of the previously discussed
rounding.
I will now illustrate programming of the DSP device with a short
example. I call the program in Example 14-2
parrot. It records a few seconds of audio, saving it to an
array in memory, then plays it back.Reading and Writing the /dev/dsp Device
#include
#include
#include
#include
#include
#define LENGTH 3
#define RATE 8000
#define SIZE 8
#define CHANNELS 1
unsigned char buf[LENGTH*RATE*SIZE*CHANNELS/8];
int main()
{
int fd;
int arg;
int status;
fd = open("/dev/dsp", O_RDWR);
if (fd < 0) {
perror("open of /dev/dsp failed");
exit(1);
}
arg = SIZE;
status = ioctl(fd, SOUND_PCM_WRITE_BITS, &arg);
if (status == -1)
perror("SOUND_PCM_WRITE_BITS ioctl failed");
if (arg != SIZE)
perror("unable to set sample size");
arg = CHANNELS;
status = ioctl(fd, SOUND_PCM_WRITE_CHANNELS, &arg);
if (status == -1)
perror("SOUND_PCM_WRITE_CHANNELS ioctl failed");
if (arg != CHANNELS)
perror("unable to set number of channels");
arg = RATE;
status = ioctl(fd, SOUND_PCM_WRITE_RATE, &arg);
if (status == -1)
perror("SOUND_PCM_WRITE_WRITE ioctl failed");
while (1) {
printf("Say something:/n");
status = read(fd, buf, sizeof(buf));
if (status != sizeof(buf))
perror("read wrong number of bytes");
printf("You said:/n");
status = write(fd, buf, sizeof(buf));
if (status != sizeof(buf))
perror("wrote wrong number of bytes");
status = ioctl(fd, SOUND_PCM_SYNC, 0);
if (status == -1)
perror("SOUND_PCM_SYNC ioctl failed");
}
}
The source file starts by including a number of standard header
files, including linux/soundcard.h. Then some constants are
defined for the sound card settings used in the program, which
makes it easy to change the values used. A static buffer is defined
to hold the sound data.
I first open the DSP device for both read and write and check
that the open was successful. Next I set the sampling parameters
using ioctl calls. Notice that a variable must be used because the
driver expects a pointer. In each case I check for an error from
the ioctl call (a return value of -1), and that the values actually
used are within range. This programming may appear to be overly
cautious, but I consider it good coding practice that pays off when
trying to debug the code. Note that I do not check that the actual
sampling rate returned matches the selected rate because of the
sampling rate rounding previously described.
I then run in a loop, first prompting the user to speak, then
reading the sound data into the buffer. Once the data is received,
I warn the user, then write the same data back to the DSP device,
where it should be heard. This repeats until the program is
interrupted with Control-C.
The SOUND_PCM_SYNC ioctl has not yet been mentioned. I'll show
what this is used for in the section titled "Advanced Sound
Programming," later in this chapter.
Try compiling and running this program. Then make some
enhancements:
Make the parameters selectable using command-line options
(sample rate, size, time). See the effect on sound quality with
different sampling rates.
Reverse the sound samples (and listen for hidden messages), or
play them back at a different sampling rate from the one at which
they were recorded.
Automatically start recording when the voice starts and stop
when silence occurs (or a maximum time is reached). Hints: for
8-bit unsigned data the zero value is 0x80, but you will likely see
values that vary around this level due to noise. Set a noise
threshold (or better yet, measure the background noise level at the
start of the program).
Bonus question: modify the program so that it can recognize the
words that are spoken.