Chinaunix首页 | 论坛 | 博客
  • 博客访问: 2275718
  • 博文数量: 668
  • 博客积分: 10016
  • 博客等级: 上将
  • 技术积分: 8588
  • 用 户 组: 普通用户
  • 注册时间: 2008-05-29 19:22
文章分类

全部博文(668)

文章存档

2011年(1)

2010年(2)

2009年(273)

2008年(392)

分类:

2009-09-20 11:06:11

本章导读
在Linux中,先后出现了音频设备的两种框架OSS和ALSA,本节将在介绍数字音频设备及音频设备硬件接口的基础上,展现OSS和ALSA驱动的结构。
17.1~17.2节讲解了音频设备及PCM、IIS和AC97硬件接口。
17.3节阐述了Linux OSS音频设备驱动的组成、mixer接口、dsp接口及用户空间编程方法。
17.4节阐述了Linux ALSA音频设备驱动的组成、card和组件管理、PCM设备、control接口、AC97 API及用户空间编程方法。
17.5节以S3C2410通过IIS接口外接UDA1341编解码器的实例讲解了OSS驱动。
17.6节以PXA255通过AC97接口外接AC97 编解码器的实例讲解了ALSA驱动。
17.1数字音频设备
目前,手机、PDA、MP3等许多嵌入式设备中包含了数字音频设备,一个典型的数字音频系统的电路组成如图17.1所示。图17.1中的嵌入式微控制器 /DSP中集成了PCM、IIS或AC97音频接口,通过这些接口连接外部的音频编解码器即可实现声音的AD和DA转换,图中的功放完成模拟信号的放大功能。

图17.1 典型的数字音频系统电路
音频编解码器是数字音频系统的核心,衡量它的指标主要有:
• 采样频率
采样的过程就是将通常的模拟音频信号的电信号转换成二进制码0和1的过程,这些0和1便构成了数字音频文件。如图17.2中的正弦曲线代表原始音频曲线,方格代表采样后得到的结果,二者越吻合说明采样结果越好。
采样频率是每秒钟的采样次数,我们常说的 44.1kHz 采样频率就是每秒钟采样44100 次。理论上采样频率越高,转换精度越高,目前主流的采样频率是48kHz。
• 量化精度
量化精度是指对采样数据分析的精度,比如24bit量化精度就是是将标准电平信号按照2的24次方进行分析,也就是说将图17.2中的纵坐标等分为224等分。量化精度越高,声音就越逼真。

图17.2 数字音频采样
17.2音频设备硬件接口
17.2.1 PCM接口
针对不同的数字音频子系统,出现了几种微处理器或DSP与音频器件间用于数字转换的接口。
最简单的音频接口是PCM(脉冲编码调制)接口,该接口由时钟脉冲(BCLK)、帧同步信号(FS)及接收数据(DR)和发送数据(DX)组成。在FS信号的上升沿,数据传输从MSB(Most Significant Bit)字开始,FS频率等于采样率。FS信号之后开始数据字的传输,单个的数据位按顺序进行传输,1个时钟周期传输1个数据字。发送MSB时,信号的等级首先降到最低,以避免在不同终端的接口使用不同的数据方案时造成MSB的丢失。
PCM接口很容易实现,原则上能够支持任何数据方案和任何采样率,但需要每个音频通道获得一个独立的数据队列。
17.2.2 IIS接口
IIS 接口(Inter-IC Sound)在20世纪80年代首先被飞利浦用于消费音频,并在一个称为LRCLK(Left/Right CLOCK)的信号机制中经过多路转换,将两路音频信号变成单一的数据队列。当LRCLK为高时,左声道数据被传输;LRCLK为低时,右声道数据被传输。与PCM相比,IIS更适合于立体声系统。对于多通道系统,在同样的BCLK和LRCLK条件下,并行执行几个数据队列也是可能的。
17.2.3 AC97接口
AC'97(Audio Codec 1997)是以Intel为首的五个PC厂商Intel、Creative Labs、NS、Analog Device与Yamaha共同提出的规格标准。与PCM和IIS不同,AC'97不只是一种数据格式,用于音频编码的内部架构规格,它还具有控制功能。 AC'97采用AC-Link与外部的编解码器相连,AC-Link接口包括位时钟(BITCLK)、同步信号校正(SYNC)和从编码到处理器及从处理器中解码(SDATDIN与SDATAOUT)的数据队列。AC'97数据帧以SYNC脉冲开始,包括12个20位时间段(时间段为标准中定义的不同的目的服务)及16位“tag”段,共计256个数据序列。例如,时间段“1”和“2”用于访问编码的控制寄存器,而时间段“3”和“4”分别负载左、右两个音频通道。“tag”段表示其他段中哪一个包含有效数据。把帧分成时间段使传输控制信号和音频数据仅通过4根线到达9个音频通道或转换成其他数据流成为可能。与具有分离控制接口的IIS方案相比,AC'97明显减少了整体管脚数。一般来说,AC'97 编解码器采用TQFP48封装,如图17.3所示。

图17.3 AC97 Codec芯片
PCM、IIS和AC97各有其优点和应用范围,例如在CD、MD、MP3随身听多采用IIS接口,移动电话会采用PCM接口,具有音频功能的PDA则多使用和PC一样的AC'97编码格式。
17.3 Linux OSS音频设备驱动
17.3.1 OSS驱动的组成
OSS标准中有2个最基本的音频设备:mixer(混音器)和DSP(数字信号处理器)。
在声卡的硬件电路中,mixer是一个很重要的组成部分,它的作用是将多个信号组合或者叠加在一起,对于不同的声卡来说,其混音器的作用可能各不相同。OSS驱动中,/dev/mixer设备文件是应用程序对mixer进行操作的软件接口。
混音器电路通常由两个部分组成:输入混音器(input mixer)和输出混音器(output mixer)。输入混音器负责从多个不同的信号源接收模拟信号,这些信号源有时也被称为混音通道或者混音设备。模拟信号通过增益控制器和由软件控制的音量调节器后,在不同的混音通道中进行级别(level)调制,然后被送到输入混音器中进行声音的合成。混音器上的电子开关可以控制哪些通道中有信号与混音器相连,有些声卡只允许连接一个混音通道作为录音的音源,而有些声卡则允许对混音通道做任意的连接。经过输入混音器处理后的信号仍然为模拟信号,它们将被送到A/D转换器进行数字化处理。
输出混音器的工作原理与输入混音器类似,同样也有多个信号源与混音器相连,并且事先都经过了增益调节。当输出混音器对所有的模拟信号进行了混合之后,通常还会有一个总控增益调节器来控制输出声音的大小,此外还有一些音调控制器来调节输出声音的音调。经过输出混音器处理后的信号也是模拟信号,它们最终会被送给喇叭或者其它的模拟输出设备。对混音器的编程包括如何设置增益控制器的级别,以及怎样在不同的音源间进行切换,这些操作通常来讲是不连续的,而且不会像录音或者放音那样需要占用大量的计算机资源。由于混音器的操作不符合典型的读/写操作模式,因此除了 open()和close()两个系统调用之外,大部分的操作都是通过ioctl()系统调用来完成的。与/dev/dsp不同,/dev/mixer允许多个应用程序同时访问,并且混音器的设置值会一直保持到对应的设备文件被关闭为止。
DSP也称为编解码器,实现录音(录音)和放音(播放),其对应的设备文件是/dev/dsp或/dev/sound/dsp。OSS声卡驱动程序提供的/dev/dsp是用于数字采样和数字录音的设备文件,向该设备写数据即意味着激活声卡上的D/A转换器进行放音,而向该设备读数据则意味着激活声卡上的A/D转换器进行录音。
在从DSP设备读取数据时,从声卡输入的模拟信号经过A/D转换器变成数字采样后的样本,保存在声卡驱动程序的内核缓冲区中,当应用程序通过 read()系统调用从声卡读取数据时,保存在内核缓冲区中的数字采样结果将被复制到应用程序所指定的用户缓冲区中。需要指出的是,声卡采样频率是由内核中的驱动程序所决定的,而不取决于应用程序从声卡读取数据的速度。如果应用程序读取数据的速度过慢,以致低于声卡的采样频率,那么多余的数据将会被丢弃(即overflow);如果读取数据的速度过快,以致高于声卡的采样频率,那么声卡驱动程序将会阻塞那些请求数据的应用程序,直到新的数据到来为止。
在向DSP设备写入数据时,数字信号会经过D/A转换器变成模拟信号,然后产生出声音。应用程序写入数据的速度应该至少等于声卡的采样频率,过慢会产生声音暂停或者停顿的现象(即underflow)。如果用户写入过快的话,它会被内核中的声卡驱动程序阻塞,直到硬件有能力处理新的数据为止。
与其它设备有所不同,声卡通常不需要支持非阻塞(non-blocking)的I/O操作。即便内核OSS驱动提供了非阻塞的I/O支持,用户空间也不宜采用。
无论是从声卡读取数据,或是向声卡写入数据,事实上都具有特定的格式(format),如无符号8位、单声道、8KHz采样率,如果默认值无法达到要求,可以通过ioctl()系统调用来改变它们。通常说来,在应用程序中打开设备文件/dev/dsp之后,接下去就应该为其设置恰当的格式,然后才能从声卡读取或者写入数据。
17.3.2 mixer接口
int register_sound_mixer(struct file_operations *fops, int dev);
上述函数用于注册1个混音器,第1个参数fops即是文件操作接口,第2个参数dev是设备编号,如果填入-1,则系统自动分配1个设备编号。mixer是 1个典型的字符设备,因此编码的主要工作是实现file_operations中的open()、ioctl()等函数。
mixer接口file_operations中的最重要函数是ioctl(),它实现混音器的不同IO控制命令,代码清单17.1给出了1个ioctl()的范例。
代码清单17.1 mixer()接口ioctl()函数范例
1 static int mixdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2 {
3    ...
4    switch (cmd)
5    {
6      case SOUND_MIXER_READ_MIC:
7        ...
8      case SOUND_MIXER_WRITE_MIC:
9        ...
10     case SOUND_MIXER_WRITE_RECSRC:
11       ...
12     case SOUND_MIXER_WRITE_MUTE:
13       ...
14   }
15   //其它命令
16   return mixer_ioctl(codec, cmd, arg);
17 }
17.3.3 DSP接口
int register_sound_dsp(struct file_operations *fops, int dev);
上述函数与register_sound_mixer()类似,它用于注册1个dsp设备,第1个参数fops即是文件操作接口,第2个参数dev是设备编号,如果填入-1,则系统自动分配1个设备编号。dsp也是1个典型的字符设备,因此编码的主要工作是实现file_operations中的 read()、write()、ioctl()等函数。
dsp接口file_operations中的read()和write()函数非常重要,read()函数从音频控制器中获取录音数据到缓冲区并拷贝到用户空间,write()函数从用户空间拷贝音频数据到内核空间缓冲区并最终发送到音频控制器。
dsp接口file_operations中的ioctl()函数处理对采样率、量化精度、DMA缓冲区块大小等参数设置IO控制命令的处理。
在数据从缓冲区拷贝到音频控制器的过程中,通常会使用DMA,DMA对声卡而言非常重要。例如,在放音时,驱动设置完DMA控制器的源数据地址(内存中 DMA缓冲区)、目的地址(音频控制器FIFO)和DMA的数据长度,DMA控制器会自动发送缓冲区的数据填充FIFO,直到发送完相应的数据长度后才中断一次。
在OSS驱动中,建立存放音频数据的环形缓冲区(ring buffer)通常是值得推荐的方法。此外,在OSS驱动中,一般会将1个较大的DMA缓冲区分成若干个大小相同的块(这些块也被称为“段”,即 fragment),驱动程序使用DMA每次在声音缓冲区和声卡之间搬移一个fragment。在用户空间,可以使用ioctl()系统调用来调整块的大小和个数。
除了read()、write()和ioctl()外,dsp接口的poll()函数通常也需要被实现,以向用户反馈目前能否读写DMA缓冲区。
在OSS驱动初始化过程中,会调用register_sound_dsp()和register_sound_mixer()注册dsp和mixer设备;在模块卸载的时候,会调用如代码清单17.2。
代码清单17.2 OSS驱动初始化注册dsp和mixer设备
1 static int xxx_init(void)
2 {
3    struct xxx_state *s = &xxx_state;
4    ...
5    //注册dsp设备
6    if ((audio_dev_dsp = register_sound_dsp(&xxx_audio_fops, - 1)) < 0)
7      goto err_dev1;
8    //设备mixer设备
9    if ((audio_dev_mixer = register_sound_mixer(&xxx_mixer_fops, - 1)) < 0)
10     goto err_dev2;
11   ...
12 }
13
14 void __exit xxx_exit(void)
15 {
16 //注销dsp和mixer设备接口
17 unregister_sound_dsp(audio_dev_dsp);
18 unregister_sound_mixer(audio_dev_mixer);
19 ...
20 }
根据17.3.2和17.3.3节的分析,可以画出一个Linux OSS驱动结构的简图,如图17.4所示。

图17.4 Linux OSS驱动结构
17.3.4 OSS用户空间编程
1、DSP编程
对OSS驱动声卡的编程使用Linux文件接口函数,如图17.5,DSP接口的操作一般包括如下几个步骤:
① 打开设备文件/dev/dsp。
采用何种模式对声卡进行操作也必须在打开设备时指定,对于不支持全双工的声卡来说,应该使用只读或者只写的方式打开,只有那些支持全双工的声卡,才能以读写的方式打开,这还依赖于驱动程序的具体实现。Linux允许应用程序多次打开或者关闭与声卡对应的设备文件,从而能够很方便地在放音状态和录音状态之间进行切换。
② 如果有需要,设置缓冲区大小。
运行在Linux内核中的声卡驱动程序专门维护了一个缓冲区,其大小会影响到放音和录音时的效果,使用ioctl()系统调用可以对它的尺寸进行恰当的设置。调节驱动程序中缓冲区大小的操作不是必须的,如果没有特殊的要求,一般采用默认的缓冲区大小也就可以了。如果想设置缓冲区的大小,则通常应紧跟在设备文件打开之后,这是因为对声卡的其它操作有可能会导致驱动程序无法再修改其缓冲区的大小。
③ 设置声道(channel)数量。
根据硬件设备和驱动程序的具体情况,可以设置为单声道或者立体声。
④ 设置采样格式和采样频率
采样格式包括AFMT_U8(无符号8位)、AFMT_S8(有符号8位)、AFMT_U16_LE(小端模式,无符号16位)、 AFMT_U16_BE(大端模式,无符号16位)、AFMT_MPEG、AFMT_AC3等。使用SNDCTL_DSP_SETFMT IO控制命令可以设置采样格式。
对于大多数声卡来说,其支持的采样频率范围一般为5kHz到44.1kHz或者48kHz,但并不意味着该范围内的所有连续频率都会被硬件支持,在Linux下进行音频编程时最常用到的几种采样频率是11025Hz、16000Hz、22050Hz、32000Hz 和44100Hz。使用SNDCTL_DSP_SPEED IO控制命令可以设置采样频率。
⑤ 读写/dev/dsp实现播放或录音。

图17.5 OSS dsp接口用户空间操作流程
代码清单17.3的程序实现了利用/dev/dsp接口进行声音录制和播放的过程,它的功能是先录制几秒钟音频数据,将其存放在内存缓冲区中,然后再进行放音。
代码清单17.3 OSS DSP接口应用编程范例
1 #include
2 #include
3 #include
4 #include
5 #include
6 #include
7 #include
8 #define LENGTH 3    /* 存储秒数 */
9 #define RATE 8000   /* 采样频率 */
10 #define SIZE 8      /* 量化位数 */
11 #define CHANNELS 1 /* 声道数目 */
12 /* 用于保存数字音频数据的内存缓冲区 */
13 unsigned char buf[LENGTH *RATE * SIZE * CHANNELS / 8];
14 int main()
15 {
16   int fd; /* 声音设备的文件描述符 */
17   int arg; /* 用于ioctl调用的参数 */
18   int status; /* 系统调用的返回值 */
19   /* 打开声音设备 */
20   fd = open("/dev/dsp", O_RDWR);
21   if (fd < 0)
22   {
23     perror("open of /dev/dsp failed");
24     exit(1);
25   }
26   /* 设置采样时的量化位数 */
27   arg = SIZE;
28   status = ioctl(fd, SOUND_PCM_WRITE_BITS, &arg);
29   if (status == - 1)
30     perror("SOUND_PCM_WRITE_BITS ioctl failed");
31   if (arg != SIZE)
32     perror("unable to set sample size");
33   /* 设置采样时的通道数目 */
34   arg = CHANNELS;
35   status = ioctl(fd, SOUND_PCM_WRITE_CHANNELS, &arg);
36   if (status == - 1)
37     perror("SOUND_PCM_WRITE_CHANNELS ioctl failed");
38   if (arg != CHANNELS)
39     perror("unable to set number of channels");
40   /* 设置采样率 */
41   arg = RATE;
42   status = ioctl(fd, SOUND_PCM_WRITE_RATE, &arg);
43   if (status == - 1)
44     perror("SOUND_PCM_WRITE_WRITE ioctl failed");
45   /* 循环,直到按下Control-C */
46   while (1)
47   {
48     printf("Say something:\n");
49     status = read(fd, buf, sizeof(buf)); /* 录音 */
50     if (status != sizeof(buf))
51       perror("read wrong number of bytes");
52     printf("You said:\n");
53     status = write(fd, buf, sizeof(buf)); /* 放音 */
54     if (status != sizeof(buf))
55       perror("wrote wrong number of bytes");
56     /* 在继续录音前等待放音结束 */
57     status = ioctl(fd, SOUND_PCM_SYNC, 0);
58     if (status == - 1)
59       perror("SOUND_PCM_SYNC ioctl failed");
60   }
61 }
2、mixer编程
声卡上的混音器由多个混音通道组成,它们可以通过驱动程序提供的设备文件/dev/mixer进行编程。对混音器的操作一般都通过ioctl()系统调用来完成,所有控制命令都以SOUND_MIXER或者MIXER开头,表17.1列出了常用的混音器控制命令。
表17.1 混音器常用命令
命 令 作 用
SOUND_MIXER_VOLUME 主音量调节
SOUND_MIXER_BASS 低音控制
SOUND_MIXER_TREBLE 高音控制
SOUND_MIXER_SYNTH FM合成器
SOUND_MIXER_PCM 主D/A转换器
SOUND_MIXER_SPEAKER PC喇叭
SOUND_MIXER_LINE 音频线输入
SOUND_MIXER_MIC 麦克风输入
SOUND_MIXER_CD CD输入
SOUND_MIXER_IMIX 放音音量
SOUND_MIXER_ALTPCM 从D/A 转换器
SOUND_MIXER_RECLEV 录音音量
SOUND_MIXER_IGAIN 输入增益
SOUND_MIXER_OGAIN 输出增益
SOUND_MIXER_LINE1 声卡的第1输入
SOUND_MIXER_LINE2 声卡的第2输入
SOUND_MIXER_LINE3 声卡的第3输入
对声卡的输入增益和输出增益进行调节是混音器的一个主要作用,目前大部分声卡采用的是8位或者16位的增益控制器,声卡驱动程序会将它们变换成百分比的形式,也就是说无论是输入增益还是输出增益,其取值范围都是从0到100。
• SOUND_MIXER_READ宏
在进行混音器编程时,可以使用 SOUND_MIXER_READ宏来读取混音通道的增益大小,例如如下代码可以获得麦克风的输入增益:
ioctl(fd, SOUND_MIXER_READ(SOUND_MIXER_MIC), &vol);
对于只有一个混音通道的单声道设备来说,返回的增益大小保存在低位字节中。而对于支持多个混音通道的双声道设备来说,返回的增益大小实际上包括两个部分,分别代表左、右两个声道的值,其中低位字节保存左声道的音量,而高位字节则保存右声道的音量。下面的代码可以从返回值中依次提取左右声道的增益大小:
int left, right;
left = vol & 0xff;
right = (vol & 0xff00) >> 8;
• SOUND_MIXER_WRITE宏
如果想设置混音通道的增益大小,则可以通过SOUND_MIXER_WRITE宏来实现,例如下面的语句可以用来设置麦克风的输入增益:
vol = (right << 8) + left;
ioctl(fd, SOUND_MIXER_WRITE(SOUND_MIXER_MIC), &vol);
• 查询Mixer信息
声卡驱动程序提供了多个ioctl()系统调用来获得混音器的信息,它们通常返回一个整型的位掩码,其中每一位分别代表一个特定的混音通道,如果相应的位为1,则说明与之对应的混音通道是可用的。
通过 SOUND_MIXER_READ_DEVMASK返回的位掩码查询出能够被声卡支持的每一个混音通道,而通过 SOUND_MIXER_READ_RECMAS返回的位掩码则可以查询出能够被当作录音源的每一个通道。例如,如下代码可用来检查CD输入是否是一个有效的混音通道:
ioctl(fd, SOUND_MIXER_READ_DEVMASK, &devmask);
if (devmask & SOUND_MIXER_CD)
printf("The CD input is supported");
如下代码可用来检查CD输入是否是一个有效的录音源:
ioctl(fd, SOUND_MIXER_READ_RECMASK, &recmask);
if (recmask & SOUND_MIXER_CD)
printf("The CD input can be a recording source");
大多数声卡提供了多个录音源,通过 SOUND_MIXER_READ_RECSRC可以查询出当前正在使用的录音源,同一时刻可使用2个或2个以上的录音源,具体由声卡硬件本身决定。相应地,使用 SOUND_MIXER_WRITE_RECSRC可以设置声卡当前使用的录音源,如下代码可以将CD输入作为声卡的录音源使用:
devmask = SOUND_MIXER_CD;
ioctl(fd, SOUND_MIXER_WRITE_RECSRC, &devmask);
此外,所有的混音通道都有单声道和双声道的区别,如果需要知道哪些混音通道提供了对立体声的支持,可以通过SOUND_MIXER_READ_STEREODEVS来获得。
代码清单17.4的程序实现了利用/dev/mixer接口对混音器进行编程的过程,该程序可对各种混音通道的增益进行调节。
代码清单17.4 OSS mixer接口应用编程范例
1   #include
2   #include
3   #include
4   #include
5   #include
6   #include
7   /* 用来存储所有可用混音设备的名称 */
8   const char *sound_device_names[] = SOUND_DEVICE_NAMES;
9   int fd; /* 混音设备所对应的文件描述符 */
10 int devmask, stereodevs; /* 混音器信息对应的bit掩码 */
11 char *name;
12 /* 显示命令的使用方法及所有可用的混音设备 */
13 void usage()
14 {
15    int i;
16    fprintf(stderr, "usage: %s \n"
17      "%s \n\n""Where is one of:\n", name, name);
18    for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
19      if ((1 << i) &devmask)
20     /* 只显示有效的混音设备 */
21        fprintf(stderr, "%s ", sound_device_names[i]);
22    fprintf(stderr, "\n");
23    exit(1);
24 }
25
26 int main(int argc, char *argv[])
27 {
28    int left, right, level; /* 增益设置 */
29    int status; /* 系统调用的返回值 */
30    int device; /* 选用的混音设备 */
31    char *dev; /* 混音设备的名称 */
32    int i;
33    name = argv[0];
34    /* 以只读方式打开混音设备 */
35    fd = open("/dev/mixer", O_RDONLY);
36    if (fd == - 1)
37    {
38      perror("unable to open /dev/mixer");
39      exit(1);
40    }
41
42    /* 获得所需要的信息 */
43    status = ioctl(fd, SOUND_MIXER_READ_DEVMASK, &devmask);
44    if (status == - 1)
45      perror("SOUND_MIXER_READ_DEVMASK ioctl failed");
46    status = ioctl(fd, SOUND_MIXER_READ_STEREODEVS, &stereodevs);
47    if (status == - 1)
48      perror("SOUND_MIXER_READ_STEREODEVS ioctl failed");
49    /* 检查用户输入 */
50    if (argc != 3 && argc != 4)
51      usage();
52    /* 保存用户输入的混音器名称 */
53    dev = argv[1];
54    /* 确定即将用到的混音设备 */
55    for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
56      if (((1 << i) &devmask) && !strcmp(dev, sound_device_names[i]))
57        break;
58    if (i == SOUND_MIXER_NRDEVICES)
59    {
60       /* 没有找到匹配项 */
61      fprintf(stderr, "%s is not a valid mixer device\n", dev);
62      usage();
63    }
64    /* 查找到有效的混音设备 */
65    device = i;
66    /* 获取增益值 */
67    if (argc == 4)
68    {
69      /* 左、右声道均给定 */
70      left = atoi(argv[2]);
71      right = atoi(argv[3]);
72    }
73    else
74    {
75      /* 左、右声道设为相等 */
76      left = atoi(argv[2]);
77      right = atoi(argv[2]);
78    }
79
80    /* 对非立体声设备给出警告信息 */
81    if ((left != right) && !((1 << i) &stereodevs))
82    {
83      fprintf(stderr, "warning: %s is not a stereo device\n", dev);
84    }
85
86    /* 将两个声道的值合到同一变量中 */
87    level = (right << 8) + left;
88
89    /* 设置增益 */
90    status = ioctl(fd, MIXER_WRITE(device), &level);
91    if (status == - 1)
92    {
93      perror("MIXER_WRITE ioctl failed");
94      exit(1);
95    }
96    /* 获得从驱动返回的左右声道的增益 */
97    left = level &0xff;
98    right = (level &0xff00) >> 8;
99    /* 显示实际设置的增益 */
100   fprintf(stderr, "%s gain set to %d%% / %d%%\n", dev, left, right);
101   /* 关闭混音设备 */
102   close(fd);
103   return 0;
104 }
编译上述程序为可执行文件mixer,执行./mixer 或./mixer 可设置增益,device可以是vol、pcm、speaker、line、mic、cd、igain、line1、 phin、video。
17.4 Linux ALSA音频设备驱动
17.4.1 ALSA的组成
虽然OSS已经非常成熟,但它毕竟是一个没有完全开放源代码的商业产品,而ALSA (Advanced Linux Sound Architecture)恰好弥补了这一空白,它符合GPL,是在Linux下进行音频编程时另一种可供选择的声卡驱动体系结构,其官方网站为。ALSA除了像OSS那样提供了一组内核驱动程序模块之外,还专门为简化应用程序的编写提供了相应的函数库,与OSS提供的基于ioctl的原始编程接口相比,ALSA函数库使用起来要更加方便一些。ALSA的主要特点有:
• 支持多种声卡设备
• 模块化的内核驱动程序
• 支持SMP和多线程
• 提供应用开发函数库(alsa-lib)以简化应用程序开发
• 支持OSS API,兼容OSS应用程序
ALSA 具有更加友好的编程接口,并且完全兼容于OSS,对应用程序员来讲无疑是一个更佳的选择。ALSA系统包括驱动包alsa-driver、开发包 alsa-libs、开发包插件alsa-libplugins、设置管理工具包alsa-utils、其他声音相关处理小程序包alsa-tools、特殊音频固件支持包alsa- firmware、OSS接口兼容模拟层工具alsa-oss共7个子项目,其中只有驱动包是必需的。
alsa- driver指内核驱动程序,包括硬件相关的代码和一些公共代码,非常庞大,代码总量达数十万行;alsa-libs指用户空间的函数库,提供给应用程序使用,应用程序应包含头文件asoundlib.h,并使用共享库libasound.so;alsa-utils包含一些基于ALSA的用于控制声卡的应用程序,如alsaconf(侦测系统中声卡并写一个适合的ALSA配置文件)、alsactl(控制ALSA声卡驱动的高级设置)、 alsamixer(基于ncurses的混音器程序)、amidi(用于读写ALSA RawMIDI)、amixer(ALSA声卡混音器的命令行控制)、aplay(基于命令行的声音文件播放)、arecord(基于命令行的声音文件录制)等。
目前ALSA内核提供给用户空间的接口有:
• 信息接口(Information Interface,/proc/asound)
• 控制接口(Control Interface,/dev/snd/controlCX)
• 混音器接口(Mixer Interface,/dev/snd/mixerCXDX)
• PCM接口(PCM Interface,/dev/snd/pcmCXDX)
• Raw迷笛接口(Raw MIDI Interface,/dev/snd/midiCXDX)
• 音序器接口(Sequencer Interface,/dev/snd/seq)
• 定时器接口(Timer Interface,/dev/snd/timer)
和OSS类似,上述接口也以文件的方式被提供,不同的是这些接口被提供给alsa-lib使用,而不是直接给应用程序使用的。应用程序最好使用alsa-lib,或者更高级的接口,比如jack提供的接口。
图17.6给出了ALSA声卡驱动与用户空间体系结构的简图,从中可以看出ALSA内核驱动与用户空间库及OSS之间的关系。

图17.6 ALSA体系结构
17.4.1 card和组件管理
对于每个声卡而言,必须创建1个“card”实例。card是声卡的“总部”,它管理这个声卡上的所有设备(组件),如PCM、mixers、MIDI、synthesizer等。因此,card和组件是ALSA声卡驱动中的主要组成元素。
1、创建card
struct snd_card *snd_card_new(int idx, const char *xid,
    struct module *module, int extra_size);
idx是card索引号、xid是标识字符串、module一般为THIS_MODULE,extra_size是要分配的额外数据的大小,分配的extra_size大小的内存将作为card->private_data。
2、创建组件
int snd_device_new(struct snd_card *card, snd_device_type_t type,
     void *device_data, struct snd_device_ops *ops);
当 card被创建后,设备(组件)能够被创建并关联于该card。第1个参数是snd_card_new()创建的card指针,第2个参数type 指的是device-level即设备类型,形式为SNDRV_DEV_XXX,包括SNDRV_DEV_CODEC、 SNDRV_DEV_CONTROL、SNDRV_DEV_PCM、SNDRV_DEV_RAWMIDI等,用户自定义设备的device-level是 SNDRV_DEV_LOWLEVEL,ops参数是1个函数集(定义为snd_device_ops结构体)的指针,device_data是设备数据指针,注意函数snd_device_new()本身不会分配设备数据的内存,因此应事先分配。
3、组件释放
每个ALSA预定义的组件在构造时需调用snd_device_new(),而每个组件的析构方法则在函数集中被包含。对于PCM、AC97此类预定义组件,我们不需关心它们的析构,而对于自定义的组件,则需要填充snd_device_ops中的析构函数指针dev_free,这样,当snd_card_free()被调用时,组件将自动被释放。
4、芯片特定的数据(Chip-Specific Data)
芯片特定的数据一般以struct xxxchip结构体形式组织,这个结构体中包含芯片相关的I/O端口地址、资源指针、中断号等,其意义等同于字符设备驱动中的 file->private_data。定义芯片特定的数据主要有2种方法,一种方法是将sizeof(struct xxxchip)传入snd_card_new()的extra_size参数,它将自动成员snd_card的private_data成员,如代码清单17.5;另一种方法是在snd_card_new()传入给extra_size参数0,再分配sizeof(struct xxxchip)的内存,将分配内存的地址传入snd_device_new()的device_data的参数,如代码清单17.6。
代码清单17.5 创建芯片特定的数据方法1
1 struct xxxchip //芯片特定的数据结构体
2 {
3    ...
4 };
5 card = snd_card_new(index, id, THIS_MODULE, sizeof(struct
6 xxxchip)); //创建声卡并申请xxx_chi内存作为card-> private_data
7 struct xxxchip *chip = card->private_data;
代码清单17.6 创建芯片特定的数据方法2
1 struct snd_card *card;
2 struct xxxchip *chip;
3 //使用0作为第4个参数,并动态分配xxx_chip的内存:
4 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
5 ...
6 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
7 //在xxxchip结构体中,应该包括声卡指针:
8 struct xxxchip
9 {
10   struct snd_card *card;
11   ...
12 };
13 //并将其card成员赋值为snd_card_new()创建的card指针:
14 chip->card = card;
15 static struct snd_device_ops ops =
16 {
17   .dev_free = snd_xxx_chip_dev_free, //组件析构
18 };
19 ...
20 //创建自定义组件
21 snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
22 //在析构函数中释放xxxchip内存
23 static int snd_xxx_chip_dev_free(struct snd_device *device)
24 {
25   return snd_xxx_chip_free(device->device_data); //释放
26 }
5、注册/释放声卡
当snd_card被准备好以后,可使用snd_card_register()函数注册这个声卡:
int snd_card_register(struct snd_card *card)
对应的snd_card_free()完成相反的功能:
int snd_card_free(struct snd_card *card);
17.4.2 PCM设备
每个声卡最多可以有4个PCM实例,1个PCM实例对应1个设备文件。PCM实例由PCM放音和录音流组成,而每个PCM流又由1个或多个PCM子流组成。有的声卡支持多重放音功能,例如,emu10k1包含1个32个立体声子流的PCM放音设备。
1、PCM实例构造
int snd_pcm_new(struct snd_card *card, char *id, int device,
int playback_count, int capture_count, struct snd_pcm ** rpcm);
第 1个参数是card指针,第2个是标识字符串,第3个是PCM设备索引(0表示第1个PCM设备),第4和第5个分别为放音和录音设备的子流数。当存在多个子流时,需要恰当地处理open()、close()和其它函数。在每个回调函数中,可以通过snd_pcm_substream的number成员得知目前操作的究竟是哪个子流,如:
struct snd_pcm_substream *substream;
int index = substream->number;
一种习惯的做法是在驱动中定义1个PCM“构造函数”,负责PCM实例的创建,如代码清单17.7。
代码清单17.7 PCM设备“构造函数”
1 static int __devinit snd_xxxchip_new_pcm(struct xxxchip *chip)
2 {
3    struct snd_pcm *pcm;
4    int err;
5    //创建PCM实例
6    if ((err = snd_pcm_new(chip->card, "xxx Chip", 0, 1, 1, &pcm)) < 0)
7      return err;
8    pcm->private_data = chip; //置pcm->private_data为芯片特定数据
9    strcpy(pcm->name, "xxx Chip");
10   chip->pcm = pcm;
11   ...
12   return 0;
13 }
2、设置PCM操作
void snd_pcm_set_ops(struct snd_pcm *pcm, int direction, struct snd_pcm_ops *ops);
第1个参数是snd_pcm的指针,第2个参数是SNDRV_PCM_STREAM_PLAYBACK或SNDRV_PCM_STREAM_CAPTURE,而第3个参数是PCM操作结构体snd_pcm_ops,这个结构体的定义如代码清单17.8。
代码清单17.8 snd_pcm_ops结构体
1 struct snd_pcm_ops
2 {
3   int (*open)(struct snd_pcm_substream *substream);//打开
4   int (*close)(struct snd_pcm_substream *substream);//关闭
5   int (*ioctl)(struct snd_pcm_substream * substream,
6         unsigned int cmd, void *arg);//io控制
7   int (*hw_params)(struct snd_pcm_substream *substream,
8      struct snd_pcm_hw_params *params);//硬件参数
9   int (*hw_free)(struct snd_pcm_substream *substream); //资源释放
10 int (*prepare)(struct snd_pcm_substream *substream);//准备
11 //在PCM被开始、停止或暂停时调用
12 int (*trigger)(struct snd_pcm_substream *substream, int cmd);
13 snd_pcm_uframes_t (*pointer)(struct snd_pcm_substream *substream);// 当前缓冲区的硬件位置
14 //缓冲区拷贝
15 int (*copy)(struct snd_pcm_substream *substream, int channel,
16       snd_pcm_uframes_t pos,
17       void __user *buf, snd_pcm_uframes_t count);
18 int (*silence)(struct snd_pcm_substream *substream, int channel,
19          snd_pcm_uframes_t pos, snd_pcm_uframes_t count);
20 struct page *(*page)(struct snd_pcm_substream *substream,
21         unsigned long offset);
22 int (*mmap)(struct snd_pcm_substream *substream, struct vm_area_struct *vma);
23 int (*ack)(struct snd_pcm_substream *substream);
24 };
snd_pcm_ops中的所有操作都需事先通过snd_pcm_substream_chip()获得xxxchip指针,例如:
int xxx()
{
struct xxxchip *chip = snd_pcm_substream_chip(substream);
...
}
当1个PCM子流被打开时,snd_pcm_ops中的open()函数将被调用,在这个函数中,至少需要初始化runtime->hw字段,代码清单17.9给出了open()函数的范例。
代码清单17.9 snd_pcm_ops结构体中open()函数
1 static int snd_xxx_open(struct snd_pcm_substream *substream)
2 {
3    //从子流获得xxxchip指针
4    struct xxxchip *chip = snd_pcm_substream_chip(substream);   
5    //获得PCM运行时信息指针
6    struct snd_pcm_runtime *runtime = substream->runtime;
7    ...
8    //初始化runtime->hw
9    runtime->hw = snd_xxxchip_playback_hw;
10   return 0;
11 }
上述代码中的snd_xxxchip_playback_hw是预先定义的硬件描述。在open()函数中,可以分配1段私有数据。如果硬件配置需要更多的限制,也需设置硬件限制。
当PCM子流被关闭时,close()函数将被调用。如果open()函数中分配了私有数据,则在close()函数中应该释放substream的私有数据,代码清单17.10给出了close()函数的范例。
代码清单17.10 snd_pcm_ops结构体中close()函数
1 static int snd_xxx_close(struct snd_pcm_substream *substream)
2 {
3   //释放子流私有数据
4   kfree(substream->runtime->private_data);
5   //...
6 }
驱动中通常可以给snd_pcm_ops的ioctl()成员函数传递通用的snd_pcm_lib_ioctl()函数。
snd_pcm_ops的hw_params()成员函数将在应用程序设置硬件参数(PCM子流的周期大小、缓冲区大小和格式等)的时候被调用,它的形式如下:
static int snd_xxx_hw_params(struct snd_pcm_substream *substream,struct snd_pcm_hw_params *hw_params);
在这个函数中,将完成大量硬件设置,甚至包括缓冲区分配,这时可调用如下辅助函数:
snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
仅当DMA缓冲区已被预先分配的情况下,上述调用才可成立。
与hw_params()对应的函数是hw_free(),它释放由hw_params()分配的资源,例如,通过如下调用释放snd_pcm_lib_malloc_pages()缓冲区:
snd_pcm_lib_free_pages(substream);
当 PCM被“准备”时,prepare()函数将被调用,在其中可以设置采样率、格式等。prepare()函数与hw_params()函数的不同在于对 prepare()的调用发生在snd_pcm_prepare()每次被调用的时候。prepare()的形式如下:
static int snd_xxx_prepare(struct snd_pcm_substream *substream);
trigger()成员函数在PCM被开始、停止或暂停时调用,函数的形式如下:
static int snd_xxx_trigger(struct snd_pcm_substream *substream, int cmd);
cmd 参数定义了具体的行为,在trigger()成员函数中至少要处理SNDRV_PCM_TRIGGER_START和 SNDRV_PCM_TRIGGER_STOP命令,如果PCM支持暂停,还应处理SNDRV_PCM_TRIGGER_PAUSE_PUSH和 SNDRV_PCM_TRIGGER_PAUSE_RELEASE命令。如果设备支持挂起/恢复,当能量管理状态发生变化时将处理 SNDRV_PCM_TRIGGER_SUSPEND和SNDRV_PCM_TRIGGER_RESUME这2个命令。注意trigger()函数是原子的,中途不能睡眠。代码清单17.11给出了1个trigger()函数的范例。
代码清单17.11 snd_pcm_ops结构体中trigger()函数
1 static int snd_xxx_trigger(struct snd_pcm_substream *substream, int cmd)
2 {
3    switch (cmd)
4    {
5      case SNDRV_PCM_TRIGGER_START:
6        // 开启PCM引擎
7        break;
8      case SNDRV_PCM_TRIGGER_STOP:
9        // 停止PCM引擎
10       break;
11     ...//其它命令
12     default:
13       return - EINVAL;
14   }
15 }
pointer()函数用于PCM中间层查询目前缓冲区的硬件位置,该函数以帧的形式返回0~buffer_size – 1的位置(ALSA 0.5.x中为字节形式),此函数也是原子的。
copy() 和silence()函数一般可以省略,但是,当硬件缓冲区不处于常规内存中时需要。例如,一些设备有自己的不能被映射的硬件缓冲区,这种情况下,我们不得不将数据从内存缓冲区拷贝到硬件缓冲区。例外,当内存缓冲区在物理和虚拟地址上都不连续时,这2个函数也必须被实现。
3、分配缓冲区
分配缓冲区的最简单方法是调用如下函数:
int snd_pcm_lib_preallocate_pages_for_all(struct snd_pcm *pcm,
       int type, void *data, size_t size, size_t max);
type 参数是缓冲区的类型,包含SNDRV_DMA_TYPE_UNKNOWN(未知)、SNDRV_DMA_TYPE_CONTINUOUS(连续的非DMA 内存)、SNDRV_DMA_TYPE_DEV (连续的通用设备),SNDRV_DMA_TYPE_DEV_SG(通用设备SG-buffer)和 SNDRV_DMA_TYPE_SBUS(连续的SBUS)。如下代码将分配64KB的缓冲区:
snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
snd_dma_pci_data(chip->pci),64*1024, 64*1024);
4、设置标志
在构造PCM实例、设置操作集并分配缓冲区之后,如果有需要,应设置PCM的信息标志,例如,如果PCM设备只支持半双工,则这样定义标志:
pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX;
5、PCM实例析构
PCM 实例的“析构函数”并非是必须的,因为PCM实例会被PCM中间层代码自动释放,如果驱动中分配了一些特别的内存空间,则必须定义“析构函数”,代码清单 17.x给出了PCM“析构函数”与对应的“构造函数”,“析构函数”会释放“构造函数”中创建的xxx_private_pcm_data。
代码清单17.12 PCM设备“析构函数”
1 static void xxxchip_pcm_free(struct snd_pcm *pcm)
2 {
3    /* 从pcm实例得到chip */
4    struct xxxchip *chip = snd_pcm_chip(pcm);
5    /* 释放自定义用途的内存 */
6    kfree(chip->xxx_private_pcm_data);
7    ...
8 }
9
10 static int __devinit snd_xxxchip_new_pcm(struct xxxchip *chip)
11 {
12   struct snd_pcm *pcm;
13   ...
14   /* 分配自定义用途的内存 */
15   chip->xxx_private_pcm_data = kmalloc(...);
16   pcm->private_data = chip;
17   /* 设置“析构函数” */
18   pcm->private_free = xxxchip_pcm_free;
19   ...
20 }
上述代码第4行的snd_pcm_chip()从PCM实例指针获得xxxchip指针,实际上它就是返回第16行给PCM实例赋予的xxxchip指针。
6、PCM信息运行时指针
当 PCM子流被打开后,PCM运行时实例(定义为结构体snd_pcm_runtime,如代码清单17.13)将被分配给这个子流,这个指针通过 substream->runtime获得。运行时指针包含各种各样的信息:hw_params及sw_params配置的拷贝、缓冲区指针、 mmap记录、自旋锁等,几乎要控制PCM的所有信息均能从中取得。
代码清单17.13 snd_pcm_runtime结构体
1 struct snd_pcm_runtime
2 {
3    /* 状态 */
4    struct snd_pcm_substream *trigger_master;
5    snd_timestamp_t trigger_tstamp; /* 触发时间戳 */
6    int overrange;
7    snd_pcm_uframes_t avail_max;
8    snd_pcm_uframes_t hw_ptr_base; /* 缓冲区复位时的位置 */
9    snd_pcm_uframes_t hw_ptr_interrupt; /* 中断时的位置*/
10   /* 硬件参数 */
11   snd_pcm_access_t access; /* 存取模式 */
12   snd_pcm_format_t format; /* SNDRV_PCM_FORMAT_* */
13   snd_pcm_subformat_t subformat; /* 子格式 */
14   unsigned int rate; /* rate in Hz */
15   unsigned int channels; /* 通道 */
16   snd_pcm_uframes_t period_size; /* 周期大小 */
17   unsigned int periods; /* 周期数 */
18   snd_pcm_uframes_t buffer_size; /* 缓冲区大小 */
19   unsigned int tick_time; /* tick time */
20   snd_pcm_uframes_t min_align; /* 格式对应的最小对齐*/
21   size_t byte_align;
22   unsigned int frame_bits;
23   unsigned int sample_bits;
24   unsigned int info;
25   unsigned int rate_num;
26   unsigned int rate_den;
27   /* 软件参数 */
28   struct timespec tstamp_mode; /* mmap时间戳被更新*/
29   unsigned int period_step;
30   unsigned int sleep_min; /* 睡眠的最小节拍 */
31   snd_pcm_uframes_t xfer_align;
32   snd_pcm_uframes_t start_threshold;
33   snd_pcm_uframes_t stop_threshold;
34   snd_pcm_uframes_t silence_threshold; /* Silence填充阈值 */
35   snd_pcm_uframes_t silence_size; /* Silence填充大小 */
36   snd_pcm_uframes_t boundary;
37   snd_pcm_uframes_t silenced_start;
38   snd_pcm_uframes_t silenced_size;
39   snd_pcm_sync_id_t sync; /* 硬件同步ID */
40   /* mmap */
41   volatile struct snd_pcm_mmap_status *status;
42   volatile struct snd_pcm_mmap_control *control;
43   atomic_t mmap_count;
44   /* 锁/调度 */
45   spinlock_t lock;
46   wait_queue_head_t sleep;
47   struct timer_list tick_timer;
48   struct fasync_struct *fasync;
49   /* 私有段 */
50   void *private_data;
51   void(*private_free)(struct snd_pcm_runtime *runtime);
52   /* 硬件描述 */
53   struct snd_pcm_hardware hw;
54   struct snd_pcm_hw_constraints hw_constraints;
55   /* 中断回调函数 */
56   void(*transfer_ack_begin)(struct snd_pcm_substream*substream);
57   void(*transfer_ack_end)(struct snd_pcm_substream *substream);
58   /* 定时器 */
59   unsigned int timer_resolution; /* timer resolution */
60   /* DMA */
61   unsigned char *dma_area; /* DMA区域*/
62   dma_addr_t dma_addr; /* 总线物理地址*/
64   size_t dma_bytes; /* DMA区域大小 */
65   struct snd_dma_buffer *dma_buffer_p; /* 被分配的缓冲区 */
66   #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
67     /* OSS信息 */
68     struct snd_pcm_oss_runtime oss;
69   #endif
70 };
snd_pcm_runtime中的大多数记录对被声卡驱动操作集中的函数是只读的,仅仅PCM中间层可更新或修改这些信息,但是硬件描述、中断回调函数、DMA缓冲区信息和私有数据是例外的。
下面解释snd_pcm_runtime结构体中的几个重要成员:
• 硬件描述
硬件描述(snd_pcm_hardware结构体)包含了基本硬件配置的定义,需要在open()函数中赋值。runtime实例保存的是硬件描述的拷贝而非指针,这意味着在open()函数中可以修改被拷贝的描述(runtime->hw),例如:
struct snd_pcm_runtime *runtime = substream->runtime;
...
runtime->hw = snd_xxchip_playback_hw; /* “大众”硬件描述 */
/* 特定的硬件描述 */
if (chip->model == VERY_OLD_ONE)
runtime->hw.channels_max = 1;
snd_pcm_hardware结构体的定义如代码清单17.14。
代码清单17.14 snd_pcm_hardware结构体
1 struct snd_pcm_hardware
2 {
3   unsigned int info; /* SNDRV_PCM_INFO_* /
4   u64 formats;   /* SNDRV_PCM_FMTBIT_* */
5   unsigned int rates; /* SNDRV_PCM_RATE_* */
6   unsigned int rate_min; /* 最小采样率 */
7   unsigned int rate_max; /* 最大采样率 */
8   unsigned int channels_min; /* 最小的通道数 */
9   unsigned int channels_max; /* 最大的通道数 */
10 size_t buffer_bytes_max; /* 最大缓冲区大小 */
11 size_t period_bytes_min; /* 最小周期大小 */
12 size_t period_bytes_max; /* 最大奏曲大小 */
13 unsigned int periods_min; /* 最小周期数 */
14 unsigned int periods_max; /* 最大周期数 */
15 size_t fifo_size; /* FIFO字节数 */
16 };
snd_pcm_hardware 结构体中的info字段标识PCM设备的类型和能力,形式为SNDRV_PCM_INFO_XXX。info字段至少需要定义是否支持mmap,当支持时,应设置SNDRV_PCM_INFO_MMAP标志;当硬件支持interleaved或non-interleaved格式,应设置 SNDRV_PCM_INFO_INTERLEAVED或SNDRV_PCM_INFO_NONINTERLEAVED标志,如果都支持,则二者都可设置;MMAP_VALID和BLOCK_TRANSFER标志针对OSS mmap,只有mmap被真正支持时,才可设置MMAP_VALID;SNDRV_PCM_INFO_PAUSE意味着设备可支持暂停操作,而 SNDRV_PCM_INFO_RESUME意味着设备可支持挂起/恢复操作;当PCM子流能被同步,如同步放音和录音流的start/stop,可设置 SNDRV_PCM_INFO_SYNC_START标志。
formats包含PCM设备支持的格式,形式为SNDRV_PCM_FMTBIT_XXX,如果设备支持多种模式,应将各种模式标志进行“或”操作。
rates包含了PCM设备支持的采样率,形式如SNDRV_PCM_RATE_XXX,如果支持连续的采样率,则传递CONTINUOUS。
rate_min和rate_max分别定义了最大和最小的采样率,注意要与rates字段相符。
channel_min和channel_max定义了最大和最小的通道数量。
buffer_bytes_max定义最大的缓冲区大小,注意没有buffer_bytes_min字段,这是因为它可以通过最小的周期大小和最小的周期数量计算出来。
period信息与OSS中的fragment对应,定义了PCM中断产生的周期。更小的周期大小意味着更多的中断,在录音时,周期大小定义了输入延迟,在放音时,整个缓冲区大小对应着输出延迟。
PCM可被应用程序通过alsa-lib发送hw_params来配置,配置信息将保存在运行时实例中。对缓冲区和周期大小的配置以帧形式存储,而frames_to_bytes()和 bytes_to_frames()可完成帧和字节的转换,如:
period_bytes = frames_to_bytes(runtime, runtime->period_size);
• DMA缓冲区信息
包含dma_area(逻辑地址)、dma_addr(物理地址)、dma_bytes(缓冲区大小)和dma_private(被ALSA DMA分配器使用)。可以由snd_pcm_lib_malloc_pages()实现,ALSA中间层会设置DMA缓冲区信息的相关字段,这种情况下,驱动中不能再写这些信息,只能读取。也就是说,如果使用标准的缓冲区分配函数snd_pcm_lib_malloc_pages()分配缓冲区,则我们不需要自己维护DMA缓冲区信息。如果缓冲区由自己分配,则需在hw_params()函数中管理缓冲区信息,至少需管理dma_bytes和 dma_addr,如果支持mmap,则必须管理dma_area,对dma_private的管理视情况而定。
• 运行状态
通过 runtime->status可以获得运行状态,它是snd_pcm_mmap_status结构体的指针,例如,通过 runtime->status->hw_ptr可以获得目前的DMA硬件指针。此外,通过runtime->control可以获得 DMA应用指针,它指向snd_pcm_mmap_control结构体指针。
• 私有数据
驱动中可以为子流分配一段内存并赋值给runtime->private_data,注意不要与pcm->private_data混淆,后者一般指向xxxchip,而前者是在PCM设备的open()函数中分配的动态数据,如:
static int snd_xxx_open(struct snd_pcm_substream *substream)
{
struct xxx_pcm_data *data;
....
data = kmalloc(sizeof(*data), GFP_KERNEL);
substream->runtime->private_data = data; //赋值runtime->private_data
....
}
• 中断回调函数:
transfer_ack_begin()和transfer_ack_end()函数分别在snd_pcm_period_elapsed()的开始和结束时被调用。
根据以上分析,代码清单17.15给出了一个完整的PCM设备接口模板。
代码清单17.15 PCM设备接口模板
1   #include
2   ....
3   /* 放音设备硬件定义 */
4   static struct snd_pcm_hardware snd_xxxchip_playback_hw =
5   {
6     .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
7       SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID),
8     .formats = SNDRV_PCM_FMTBIT_S16_LE,
9     .rates = SNDRV_PCM_RATE_8000_48000,
10    .rate_min = 8000,
11    .rate_max = 48000,
12    .channels_min = 2,
13    .channels_max = 2,
14    .buffer_bytes_max = 32768,
15    .period_bytes_min = 4096,
16    .period_bytes_max = 32768,
17    .periods_min = 1,
18    .periods_max = 1024,
19 };
20
21 /* 录音设备硬件定义 */
22 static struct snd_pcm_hardware snd_xxxchip_capture_hw =
23 {
24    .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
25      SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID),
26    .formats = SNDRV_PCM_FMTBIT_S16_LE,
27    .rates = SNDRV_PCM_RATE_8000_48000,
28    .rate_min = 8000,
29    .rate_max = 48000,
30    .channels_min = 2,
31    .channels_max = 2,
32    .buffer_bytes_max = 32768,
33    .period_bytes_min = 4096,
34    .period_bytes_max = 32768,
35    .periods_min = 1,
36    .periods_max = 1024,
37 };
38
39 /* 放音:打开函数 */
40 static int snd_xxxchip_playback_open(struct snd_pcm_substream*substream)
41 {
42    struct xxxchip *chip = snd_pcm_substream_chip(substream);
43    struct snd_pcm_runtime *runtime = substream->runtime;
44    runtime->hw = snd_xxxchip_playback_hw;
45    ... // 硬件初始化代码
46    return 0;
47 }
48
49 /* 放音:关闭函数 */
50 static int snd_xxxchip_playback_close(struct snd_pcm_substream*substream)
51 {
52    struct xxxchip *chip = snd_pcm_substream_chip(substream);
53    // 硬件相关的代码
54    return 0;
55 }
56
57 /* 录音:打开函数 */
58 static int snd_xxxchip_capture_open(struct snd_pcm_substream*substream)
59 {
60    struct xxxchip *chip = snd_pcm_substream_chip(substream);
61    struct snd_pcm_runtime *runtime = substream->runtime;
62    runtime->hw = snd_xxxchip_capture_hw;
63    ... // 硬件初始化代码
64    return 0;
65 }
66
67 /* 录音:关闭函数 */
68 static int snd_xxxchip_capture_close(struct snd_pcm_substream*substream)
69 {
70    struct xxxchip *chip = snd_pcm_substream_chip(substream);
71    ... // 硬件相关的代码
72    return 0;
73 }
74 /* hw_params函数 */
75 static int snd_xxxchip_pcm_hw_params(struct snd_pcm_substream*substream, struct
76    snd_pcm_hw_params *hw_params)
77 {
78    return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
79 }
80 /* hw_free函数 */
81 static int snd_xxxchip_pcm_hw_free(struct snd_pcm_substream*substream)
82 {
83    return snd_pcm_lib_free_pages(substream);
84 }
85 /* prepare函数 */
86 static int snd_xxxchip_pcm_prepare(struct snd_pcm_substream*substream)
87 {
88    struct xxxchip *chip = snd_pcm_substream_chip(substream);
89    struct snd_pcm_runtime *runtime = substream->runtime;
90    /* 根据目前的配置信息设置硬件
91     * 例如:
92     */
93    xxxchip_set_sample_format(chip, runtime->format);
94    xxxchip_set_sample_rate(chip, runtime->rate);
95    xxxchip_set_channels(chip, runtime->channels);
96    xxxchip_set_dma_setup(chip, runtime->dma_addr, chip->buffer_size, chip
97      ->period_size);
98    return 0;
99 }
100 /* trigger函数 */
101 static int snd_xxxchip_pcm_trigger(struct snd_pcm_substream*substream, int cmd)
102 {
103   switch (cmd)
104   {
105     case SNDRV_PCM_TRIGGER_START:
106       // do something to start the PCM engine
107       break;
108     case SNDRV_PCM_TRIGGER_STOP:
109       // do something to stop the PCM engine
110       break;
111     default:
112       return - EINVAL;
113   }
114 }
115
116 /* pointer函数 */
117 static snd_pcm_uframes_t snd_xxxchip_pcm_pointer(struct snd_pcm_substream
118   *substream)
119 {
120   struct xxxchip *chip = snd_pcm_substream_chip(substream);
121   unsigned int current_ptr;
122   /*获得当前的硬件指针*/
123   current_ptr = xxxchip_get_hw_pointer(chip);
124   return current_ptr;
125 }
126 /* 放音设备操作集 */
127 static struct snd_pcm_ops snd_xxxchip_playback_ops =
128 {
129   .open = snd_xxxchip_playback_open,
130   .close = snd_xxxchip_playback_close,
131   .ioctl = snd_pcm_lib_ioctl,
132   .hw_params = snd_xxxchip_pcm_hw_params,
133   .hw_free = snd_xxxchip_pcm_hw_free,
134   .prepare = snd_xxxchip_pcm_prepare,
135   .trigger = snd_xxxchip_pcm_trigger,
136   .pointer = snd_xxxchip_pcm_pointer,
137 };
138 /* 录音设备操作集 */
139 static struct snd_pcm_ops snd_xxxchip_capture_ops =
140 {
141   .open = snd_xxxchip_capture_open,
142   .close = snd_xxxchip_capture_close,
143   .ioctl = snd_pcm_lib_ioctl,
144   .hw_params = snd_xxxchip_pcm_hw_params,
145   .hw_free = snd_xxxchip_pcm_hw_free,
146   .prepare = snd_xxxchip_pcm_prepare,
147   .trigger = snd_xxxchip_pcm_trigger,
148   .pointer = snd_xxxchip_pcm_pointer,
149 };
150
151 /* 创建1个PCM设备 */
152 static int __devinit snd_xxxchip_new_pcm(struct xxxchip *chip)
153 {
154   struct snd_pcm *pcm;
155   int err;
156   if ((err = snd_pcm_new(chip->card, "xxx Chip", 0, 1, 1, &pcm)) < 0)
157     return err;
158   pcm->private_data = chip;
159   strcpy(pcm->name, "xxx Chip");
160   chip->pcm = pcm;
161   /* 设置操作集 */
162   snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_xxxchip_playback_ops);
163   snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_xxxchip_capture_ops);
164   /* 分配缓冲区 */
165   snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
166     snd_dma_pci_data(chip - > pci), 64 *1024, 64 *1024);
167   return 0;
168 }
17.4.3控制接口
1、control
控制接口对于许多开关(switch)和调节器(slider)而言应用相当广泛,它能从用户空间被存取。control的最主要用途是mixer,所有的 mixer元素基于control内核API实现,在ALSA中,control用snd_kcontrol结构体描述。
ALSA有一个定义很好的AC97控制模块,对于仅支持AC97的芯片而言,不必实现本节的内容。
创建1个新的control至少需要实现snd_kcontrol_new中的info()、get()和put()这3个成员函数,snd_kcontrol_new结构体的定义如代码清单17.16。
代码清单17.16 snd_kcontrol_new结构体
1 struct snd_kcontrol_new
2 {
3    snd_ctl_elem_iface_t iface; /*接口ID,SNDRV_CTL_ELEM_IFACE_XXX */
4    unsigned int device; /* 设备号 */
5    unsigned int subdevice; /* 子流(子设备)号 */
6    unsigned char *name; /* 名称(ASCII格式) */
7    unsigned int index; /* 索引 */
8    unsigned int access; /* 访问权限 */
9    unsigned int count; /* 享用元素的数量 */
10   snd_kcontrol_info_t *info;
11   snd_kcontrol_get_t *get;
12   snd_kcontrol_put_t *put;
13   unsigned long private_value;
14 };
iface 字段定义了control的类型,形式为SNDRV_CTL_ELEM_IFACE_XXX,通常是MIXER,对于不属于mixer的全局控制,使用 CARD。如果关联于某类设备,则使用HWDEP、 PCM、RAWMIDI、TIMER或SEQUENCER。
name是名称标识字符串,control的名称非常重要,因为control的作用由名称来区分。对于名称相同的control,则使用index区分。name定义的标准是 “SOURCE DIRECTION FUNCTION”即“源 方向功能”,SOURCE定义了control的源,如“Master”、“PCM”、“CD”和“Line”,方向则为“Playback”、 “Capture”、“Bypass Playback”或“Bypass Capture”,如果方向省略,意味着playback和capture双向,第3个参数可以是“Switch”、“Volume”和“Route” 等。
“SOURCE DIRECTION FUNCTION”格式的名称例子如Master Capture Switch、PCM Playback Volume。
下面几种control的命名不采用“SOURCE DIRECTION FUNCTION”格式,属于例外:
• 全局控制
“Capture Source”、 “Capture Switch”和“Capture Volume”用于全局录音源、输入开关和录音音量控制;“Playback Switch”、“Playback Volume”用于全局输出开关和音量控制。
• 音调控制
音调控制名称的形式为“Tone Control – XXX”,例如“Tone Control – Switch”、“Tone Control – Bas”和“Tone Control – Center”。
• 3D控制
3D控制名称的形式为“3D Control – XXX”,例如“3D Control – Switch”、“3D Control – Center”和“3D Control – Space”。
• 麦克风增益(Mic boost)
麦克风增益被设置为“Mic Boost”或“Mic Boost (6dB)”。
snd_kcontrol_new 结构体的access字段是访问控制权限,形式如SNDRV_CTL_ELEM_ACCESS_XXX。 SNDRV_CTL_ELEM_ACCESS_READ意味着只读,这时put()函数不必实现;SNDRV_CTL_ELEM_ACCESS_WRITE意味着只写,这时get()函数不必实现。若control值频繁变化,则需定义 VOLATILE标志。当control处于非激活状态时,应设置INACTIVE标志。
private_value字段包含1个长整型值,可以通过它给info()、get()和put()函数传递参数。
2、info()函数
snd_kcontrol_new结构体中的info()函数用于获得该control的详细信息,该函数必须填充传递给它的第2个参数snd_ctl_elem_info结构体,info()函数的形式如下:
static int snd_xxxctl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo);
snd_ctl_elem_info结构体的定义如代码清单17.17。
代码清单17.17 snd_ctl_elem_info结构体
1 struct snd_ctl_elem_info
2 {
3    struct snd_ctl_elem_id id; /* W: 元素ID */
4    snd_ctl_elem_type_t type; /* R: 值类型 - SNDRV_CTL_ELEM_TYPE_* */
5    unsigned int access; /* R: 值访问权限(位掩码) - SNDRV_CTL_ELEM_ACCESS_* */
6    unsigned int count; /* 值的计数 */
7    pid_t owner; /* 该control的拥有者PID */
8    union
9    {
10     struct
11     {
12       long min; /* R: 最小值 */
13       long max; /* R: 最大值 */
14       long step; /* R: 值步进 (0 可变的) */
15     } integer;
16     struct
17     {
18       long long min; /* R: 最小值 */
19       long long max; /* R: 最大值 */
20       long long step; /* R: 值步进 (0 可变的) */
21     } integer64;
22     struct
23     {
24       unsigned int items; /* R: 项目数 */
25       unsigned int item; /* W: 项目号 */
26       char name[64]; /* R: 值名称 */
27     } enumerated; /* 枚举 */
28     unsigned char reserved[128];
29   }
30   value;
31   union
32   {
33     unsigned short d[4];
34     unsigned short *d_ptr;
35   } dimen;
36   unsigned char reserved[64-4 * sizeof(unsigned short)];
37 };
snd_ctl_elem_info 结构体的type字段定义了control的类型,包括BOOLEAN、INTEGER、ENUMERATED、BYTES、IEC958和 INTEGER64。count字段定义了这个control中包含的元素的数量,例如1个立体声音量control的count = 2。value是1个联合体,其所存储的值的具体类型依赖于type。代码清单17.18给出了1个info()函数填充 snd_ctl_elem_info结构体的范例。
代码清单17.18 snd_ctl_elem_info结构体中info()函数范例
1 static int snd_xxxctl_info(struct snd_kcontrol *kcontrol, struct
2   snd_ctl_elem_info *uinfo)
3 {
4   uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;//类型为BOOLEAN
5   uinfo->count = 1;//数量为1
6   uinfo->value.integer.min = 0;//最小值为0
7   uinfo->value.integer.max = 1;//最大值为1
8   return 0;
9 }
枚举类型和其它类型略有不同,对枚举类型,应为目前项目索引设置名称字符串,如代码清单17.19。
代码清单17.19 填充snd_ctl_elem_info结构体中枚举类型值
1 static int snd_xxxctl_info(struct snd_kcontrol *kcontrol, struct
2    snd_ctl_elem_info *uinfo)
3 {
4    //值名称字符串
5    static char *texts[4] =
6    {
7      "First", "Second", "Third", "Fourth"
8    };
9    uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;//枚举类型
10   uinfo->count = 1;//数量为1
11   uinfo->value.enumerated.items = 4;//项目数量为1
12   //超过3的项目号改为3
13   if (uinfo->value.enumerated.item > 3)
14     uinfo->value.enumerated.item = 3;
15   //为目前项目索引拷贝名称字符串
16   strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
17   return 0;
18 }
3、get()函数
get()函数用于得到control的目前值并返回用户空间,代码清单17.20给出了get()函数的范例。
代码清单17.20 snd_ctl_elem_info结构体中get()函数范例
1 static int snd_xxxctl_get(struct snd_kcontrol *kcontrol, struct
2   snd_ctl_elem_value *ucontrol)
3 {
4   //从snd_kcontrol获得xxxchip指针
5   struct xxxchip *chip = snd_kcontrol_chip(kcontrol);
6   //从xxxchip获得值并写入snd_ctl_elem_value
7   ucontrol->value.integer.value[0] = get_some_value(chip);
8   return 0;
9 }
get() 函数的第2个参数的类型为snd_ctl_elem_value,其定义如代码清单10.21。snd_ctl_elem_value结构体的内部也包含 1个由integer、integer64、enumerated等组成的值联合体,它的具体类型依赖于control的类型和info()函数。
代码清单17.21 snd_ctl_elem_value结构体
1 struct snd_ctl_elem_value
2 {
3    struct snd_ctl_elem_id id; /* W: 元素ID */
4    unsigned int indirect: 1; /* W: 使用间接指针(xxx_ptr成员) */
5    //值联合体
6    union
7    {
8      union
9      {
10       long value[128];
11       long *value_ptr;
12     } integer;
13     union
14     {
15       long long value[64];
16       long long *value_ptr;
17     } integer64;
18     union
19     {
20       unsigned int item[128];
21       unsigned int *item_ptr;
22     } enumerated;
23     union
24     {
25       unsigned char data[512];
26       unsigned char *data_ptr;
27     } bytes;
28     struct snd_aes_iec958 iec958;
29   }
30   value; /* 只读 */
31   struct timespec tstamp;
32   unsigned char reserved[128-sizeof(struct timespec)];
33 };
阅读(2026) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~