alsa sample rate跟踪 <4>

最新推荐文章于 2024-10-29 10:17:14 发布

原创最新推荐文章于 2024-10-29 10:17:14 发布 · 2.5k 阅读

3 ·

CC 4.0 BY-SA版权

Linux Audio 专栏收录该内容

5 篇文章

订阅专栏

alsa sample rate跟踪 <4>

接下来，要看看open流程中都往pcm上挂了哪些东东。
aplay的main函数中调用snd_pcm_open函数，并传入了一个snd_pcm_t指针handle的地址：

static snd_pcm_t *handle;
 err = snd_pcm_open(&handle, pcm_name, stream, open_mode);

这个时候handle还是干净的。

snd_pcm_open中将snd_pcm_t指针的地址直接传给了函数snd_pcm_open_noupdate：

 return snd_pcm_open_noupdate(pcmp, snd_config, name, stream, mode, 0);

snd_pcm_open_noupdate中将snd_pcm_t指针的地址直接传给了函数snd_pcm_open_conf：

  err = snd_pcm_open_conf(pcmp, name, root, pcm_conf, stream, mode);

snd_pcm_open_conf中将snd_pcm_t指针的地址直接传给了函数_snd_pcm_plug_open：

  // 此处 open_func 为_snd_pcm_plug_open函数
  err = open_func(pcmp, name, pcm_root, pcm_conf, stream, mode);

_snd_pcm_plug_open中定义了一个snd_pcm_t指针，并将其地址传给了函数snd_pcm_open_slave：

 snd_pcm_t *spcm;
 err = snd_pcm_open_slave(&spcm, root, sconf, stream, mode, conf);

snd_pcm_open_slave中将snd_pcm_t指针的地址直接传给了函数snd_pcm_open_named_slave：

 return snd_pcm_open_named_slave(pcmp, NULL, root, conf, stream,
     mode, parent_conf);

snd_pcm_open_named_slave中将snd_pcm_t指针的地址直接传给了函数snd_pcm_open_noupdate：

  return snd_pcm_open_noupdate(pcmp, root, str, stream, mode,
          hop + 1);

snd_pcm_open_noupdate中将snd_pcm_t指针的地址直接传给了函数snd_pcm_open_conf：

  err = snd_pcm_open_conf(pcmp, name, root, pcm_conf, stream, mode);

snd_pcm_open_conf中将snd_pcm_t指针的地址直接传给了函数_snd_pcm_dmix_open：

  // 此处 open_func 为_snd_pcm_dmix_open函数
  err = open_func(pcmp, name, pcm_root, pcm_conf, stream, mode);

_snd_pcm_dmix_open中处理：
定义slave_params结构体：

 struct slave_params params;

初始化slave_params结构体：

 /* the default settings, it might be invalid for some hardware */
 params.format = SND_PCM_FORMAT_S16;
 params.rate = 48000;  // 原来这儿有个48000，怪不得asound.conf是否指定rate 48000都会调用rate plug。
 params.channels = 2;
 params.period_time = -1;
 params.buffer_time = -1;
 bsize = psize = -1;
 params.periods = 3;

将snd_pcm_t指针的地址和params传给了函数snd_pcm_dmix_open：

 err = snd_pcm_dmix_open(pcmp, name, &dopen, ¶ms,
    root, sconf, stream, mode);

snd_pcm_dmix_open函数中相关处理：
首先定义：

 snd_pcm_t *pcm = NULL, *spcm = NULL;
 snd_pcm_direct_t *dmix = NULL;

为dmix分配空间：

 dmix = calloc(1, sizeof(snd_pcm_direct_t));

对dmix成员进行赋值：

 dmix->ipc_key = opts->ipc_key;
 dmix->ipc_perm = opts->ipc_perm;
 dmix->ipc_gid = opts->ipc_gid;
 dmix->semid = -1;
 dmix->shmid = -1;

给pcm分配空间并初始化：

 ret = snd_pcm_new(&pcm, dmix->type = SND_PCM_TYPE_DMIX, name, stream, mode);

将snd_pcm_dmix_ops赋值给pcm的ops，并将dmix赋值给pcm的private_data：

 pcm->ops = &snd_pcm_dmix_ops;
 pcm->fast_ops = &snd_pcm_dmix_fast_ops;
 pcm->private_data = dmix;

初始化dmix另外一些成员：

 dmix->state = SND_PCM_STATE_OPEN;
 dmix->slowptr = opts->slowptr;
 dmix->max_periods = opts->max_periods;
 dmix->sync_ptr = snd_pcm_dmix_sync_ptr;

以spcm为参数调用snd_pcm_open_slave：

  ret = snd_pcm_open_slave(&spcm, root, sconf, stream,
      mode | SND_PCM_NONBLOCK, NULL);

snd_pcm_open_slave的调用过程见上面_snd_pcm_plug_open的分析。
最终调用到了下面这一步：
snd_pcm_open_conf中将snd_pcm_t指针的地址直接传给了函数_snd_pcm_hw_open：

  // 此处 open_func 为_snd_pcm_hw_open函数
  err = open_func(pcmp, name, pcm_root, pcm_conf, stream, mode);

_snd_pcm_hw_open中将snd_pcm_t指针的地址直接传给了函数snd_pcm_hw_open：

 err = snd_pcm_hw_open(pcmp, name, card, device, subdevice, stream,
         mode | (nonblock ? SND_PCM_NONBLOCK : 0),
         0, sync_ptr_ioctl);

snd_pcm_hw_open中的处理：
调用snd_open_device打开设备：（snd_open_device中调用open实现设备打开）

 fd = snd_open_device(filename, fmode);  // 这儿的filename是dev目录下的设备文件，如：/dev/snd/pcmC1D1p

将snd_pcm_t指针的地址直接传给了函数snd_pcm_hw_open_fd：

 return snd_pcm_hw_open_fd(pcmp, name, fd, 0, sync_ptr_ioctl);

snd_pcm_hw_open_fd中的处理：
定义：

 snd_pcm_t *pcm = NULL;
 snd_pcm_hw_t *hw = NULL;

通过ioctl对fd进行一些操作。
为hw分配空间：

 hw = calloc(1, sizeof(snd_pcm_hw_t));

初始化hw成员：

 hw->version = ver;
 hw->card = info.card;
 hw->device = info.device;
 hw->subdevice = info.subdevice;
 hw->fd = fd;
 hw->sync_ptr_ioctl = sync_ptr_ioctl;
 /* no restriction */
 hw->format = SND_PCM_FORMAT_UNKNOWN;
 hw->rate = 0;
 hw->channels = 0;

给pcm分配空间并初始化：

 ret = snd_pcm_new(&pcm, SND_PCM_TYPE_HW, name, info.stream, mode);

将snd_pcm_hw_ops赋值给pcm的ops，将hw赋值给pcm的private_data：

 pcm->ops = &snd_pcm_hw_ops;
 pcm->fast_ops = &snd_pcm_hw_fast_ops;
 pcm->private_data = hw;
 pcm->poll_fd = fd;
 pcm->poll_events = info.stream == SND_PCM_STREAM_PLAYBACK ? POLLOUT : POLLIN;
 pcm->monotonic = monotonic;

将pcm赋值给传入的snd_pcm_t指针的地址：

 *pcmp = pcm;

从snd_pcm_open_slave出来。
回到snd_pcm_dmix_open：

调用snd_pcm_direct_initialize_slave函数进行初始化：

  // params是_snd_pcm_dmix_open中定义并初始化的结构体
  ret = snd_pcm_direct_initialize_slave(dmix, spcm, params);

函数snd_pcm_direct_initialize_slave的注释：

/*
 * this function initializes hardware and starts playback operation with
 * no stop threshold (it operates all time without xrun checking)
 * also, the driver silences the unused ring buffer areas for us
 */

snd_pcm_direct_initialize_slave中设置了hw_params的各种参数，然后调用了snd_pcm_hw_params函数：

 ret = snd_pcm_hw_params(spcm, hw_params);

将hw_params的参数保存到snd_pcm_dmix_open的dmix中：

 /* store some hw_params values to shared info */
 dmix->shmptr->hw.format = snd_mask_value(hw_param_mask(hw_params, SND_PCM_HW_PARAM_FORMAT));
 dmix->shmptr->hw.rate = *hw_param_interval(hw_params, SND_PCM_HW_PARAM_RATE);
 dmix->shmptr->hw.buffer_size = *hw_param_interval(hw_params, SND_PCM_HW_PARAM_BUFFER_SIZE);
 dmix->shmptr->hw.buffer_time = *hw_param_interval(hw_params, SND_PCM_HW_PARAM_BUFFER_TIME);
 dmix->shmptr->hw.period_size = *hw_param_interval(hw_params, SND_PCM_HW_PARAM_PERIOD_SIZE);
 dmix->shmptr->hw.period_time = *hw_param_interval(hw_params, SND_PCM_HW_PARAM_PERIOD_TIME);
 dmix->shmptr->hw.periods = *hw_param_interval(hw_params, SND_PCM_HW_PARAM_PERIODS);

然后调用了snd_pcm_sw_params函数：

 ret = snd_pcm_sw_params(spcm, sw_params);

接下来调用了snd_pcm_start：

 ret = snd_pcm_start(spcm);

从snd_pcm_direct_initialize_slave出来。
回到snd_pcm_dmix_open：

将spcm赋值给dmix：

  dmix->spcm = spcm;

给pcm的部分成员赋值：

 pcm->poll_fd = dmix->poll_fd;
 pcm->poll_events = POLLIN; /* it's different than other plugins */
 pcm->mmap_rw = 1;

将pcm赋值给传入的snd_pcm_t指针的地址：

 *pcmp = pcm;

从snd_pcm_open_slave出来。
回到_snd_pcm_plug_open：

_snd_pcm_plug_open中将snd_pcm_t指针的地址和spcm传给了函数snd_pcm_plug_open：

 err = snd_pcm_plug_open(pcmp, name, sformat, schannels, srate, rate_converter,
    route_policy, ttable, ssize, cused, sused, spcm, 1);

snd_pcm_plug_open函数中定义了一个snd_pcm_plug_t指针，并分配了snd_pcm_plug_t对象。
然后初始化snd_pcm_plug_t对象，并将该对象赋值给snd_pcm_t指针的private_data。
并将snd_pcm_plug_ops赋值给snd_pcm_t指针的ops成员。
代码列出来，可能更明了：

/**
 * \brief Creates a new Plug PCM
 * \param pcmp Returns created PCM handle
 * \param name Name of PCM
 * \param sformat Slave (destination) format
 * \param slave Slave PCM handle
 * \param close_slave When set, the slave PCM handle is closed with copy PCM
 * \retval zero on success otherwise a negative error code
 * \warning Using of this function might be dangerous in the sense
 *          of compatibility reasons. The prototype might be freely
 *          changed in future.
 */
int snd_pcm_plug_open(snd_pcm_t **pcmp,
        const char *name,
        snd_pcm_format_t sformat, int schannels, int srate,
        const snd_config_t *rate_converter,
        enum snd_pcm_plug_route_policy route_policy,
        snd_pcm_route_ttable_entry_t *ttable,
        unsigned int tt_ssize,
        unsigned int tt_cused, unsigned int tt_sused,
        snd_pcm_t *slave, int close_slave)
{
 snd_pcm_t *pcm;
 // 定义指针
 snd_pcm_plug_t *plug;
 int err;
 assert(pcmp && slave);

 // 分配空间
 plug = calloc(1, sizeof(snd_pcm_plug_t));
 if (!plug)
  return -ENOMEM;
 plug->sformat = sformat;
 plug->schannels = schannels;
 plug->srate = srate;
 plug->rate_converter = rate_converter;
 // 将slave pcm赋值过来
 plug->gen.slave = plug->req_slave = slave;
 plug->gen.close_slave = close_slave;
 plug->route_policy = route_policy;
 plug->ttable = ttable;
 plug->tt_ssize = tt_ssize;
 plug->tt_cused = tt_cused;
 plug->tt_sused = tt_sused;
 
 err = snd_pcm_new(&pcm, SND_PCM_TYPE_PLUG, name, slave->stream, slave->mode);
 if (err < 0) {
  free(plug);
  return err;
 }
 pcm->ops = &snd_pcm_plug_ops;
 pcm->fast_ops = slave->fast_ops;
 pcm->fast_op_arg = slave->fast_op_arg;
 // 将plug赋值到pcm的private_data
 pcm->private_data = plug;
 pcm->poll_fd = slave->poll_fd;
 pcm->poll_events = slave->poll_events;
 pcm->mmap_shadow = 1;
 pcm->monotonic = slave->monotonic;
 snd_pcm_link_hw_ptr(pcm, slave);
 snd_pcm_link_appl_ptr(pcm, slave);
 *pcmp = pcm;

 return 0;
}

小结一下。
aplay传入的snd_pcm_t指针地址在snd_pcm_plug_open中被赋值
其中:

 pcm->ops = &snd_pcm_plug_ops;
 pcm->fast_ops = slave->fast_ops;
 pcm->private_data = plug;
 plug->gen.slave = plug->req_slave = slave;

slave在snd_pcm_dmix_open中被赋值：

 pcm->ops = &snd_pcm_dmix_ops;
 pcm->fast_ops = &snd_pcm_dmix_fast_ops;
 pcm->private_data = dmix;
  dmix->spcm = spcm;

spcm在snd_pcm_hw_open_fd中被赋值：

 pcm->ops = &snd_pcm_hw_ops;
 pcm->fast_ops = &snd_pcm_hw_fast_ops;
 pcm->private_data = hw;
 pcm->poll_fd = fd;
 hw->fd = fd;

其中fd是打开的设备文件句柄。

结构体的赋值已经基本清晰。
下面来看看snd_pcm_hw_params的函数调用关系：

                                                                       snd_pcm_hw_params
                                                                          /                         \
                                                                         /                           \
                                          _snd_pcm_hw_params               snd_pcm_prepare
                                                                   /
                                                                  /
                                        snd_pcm_plug_hw_params
                                                    /                        \
                                                   /                          \
                   snd_pcm_plug_insert_plugins        _snd_pcm_hw_params
                                                   /                                       /
                                                  /                                       /
                     snd_pcm_plug_change_rate      snd_pcm_rate_hw_params
                                                /                                           /
                                               /                                           /
                            snd_pcm_rate_open        snd_pcm_hw_params_slave
                                                                                            /
                                                                                           /
                                                                  snd_pcm_generic_hw_params
                                                                                            /
                                                                                           /
                                                                    _snd_pcm_hw_params
                                                                                        /
                                                                                       /
                                                                   snd_pcm_direct_hw_params

开发linux audio driver的同学应该很熟悉hw:x,x设备。
可以aplay -D hw:x,x xxx.wav来指定使用hw:x,x设备播放音频。
这样指定之后，alsa lib将不会对音频进行处理，也就是说除了hw之外，其他的plug都不会被使用。
在open的时候，只调用了_snd_pcm_hw_open。
在set params时，也只调用了snd_pcm_hw_hw_params。
这样的话，声音数据直接扔给了audio driver，alsa lib中不会对采样率，声道，格式等进行处理。