ALSA之PCM分析

最新推荐文章于 2024-01-29 17:37:30 发布
最新推荐文章于 2024-01-29 17:37:30 发布
阅读量708 收藏 2
点赞数
分类专栏： audio

http://blog.youkuaiyun.com/crycheng/article/details/7095899

CODEC ：音频芯片的控制，比如静音、打开（关闭）ADC（DAC）、设置ADC（DAC）的增益、耳机模式的检测等操作。
I2S   ：数字音频接口，用于CPU和Codec之间的数字音频流raw data的传输。每当有playback或record操作时，snd_soc_dai_ops.prepare()会被调用，启动I2S总线。
PCM   ：我不知道为什么会取这个模块名，它其实是定义DMA操作的，用于将音频数据通过DMA传到I2S控制器的FIFO中。

这里的PCM实际是就是更新和管理音频数据流的地址，分配DMA等等，将RAM中存放的音频数据的地址传给I2S，不是PCM协议。
音频数据流向：
     | DMA |                     | I2S/PCM/AC97 |
RAM --------> I2SControllerFIFO -----------------> CODEC ----> SPK/Headset


PCM模块初始化：

[html] view plain copy print ?
  1. struct snd_soc_platform rk29_soc_platform = { 
  2.     .name       = "rockchip-audio", 
  3.     .pcm_ops    = &rockchip_pcm_ops, 
  4.     .pcm_new    = rockchip_pcm_new, 
  5.     .pcm_free   = rockchip_pcm_free_dma_buffers, 
  6. }; 
  7. EXPORT_SYMBOL_GPL(rk29_soc_platform); 
  8.  
  9. static int __init rockchip_soc_platform_init(void) 
  10. { 
  11.         DBG("Enter::%s, %d\n", __FUNCTION__, __LINE__); 
  12.     return snd_soc_register_platform(&rk29_soc_platform); 
  13. } 
  14. module_init(rockchip_soc_platform_init); 
  15.  
  16. static void __exit rockchip_soc_platform_exit(void) 
  17. { 
  18.     snd_soc_unregister_platform(&rk29_soc_platform); 
  19. }  
struct snd_soc_platform rk29_soc_platform = {
	.name		= "rockchip-audio",
	.pcm_ops 	= &rockchip_pcm_ops,
	.pcm_new	= rockchip_pcm_new,
	.pcm_free	= rockchip_pcm_free_dma_buffers,
};
EXPORT_SYMBOL_GPL(rk29_soc_platform);

static int __init rockchip_soc_platform_init(void)
{
        DBG("Enter::%s, %d\n", __FUNCTION__, __LINE__);
	return snd_soc_register_platform(&rk29_soc_platform);
}
module_init(rockchip_soc_platform_init);

static void __exit rockchip_soc_platform_exit(void)
{
	snd_soc_unregister_platform(&rk29_soc_platform);
}

调用snd_soc_register_platform()向ALSA core注册一个snd_soc_platform结构体。


成员pcm_new需要调用dma_alloc_writecombine()给DMA分配一块write-combining的内存空间，并把这块缓冲区的相关信息保存到substream->dma_buffer中，相当于构造函数。pcm_free则相反。这些成员函数都还算简单，看看代码即可以理解其流程。


snd_pcm_ops

接着我们看一下snd_pcm_ops结构体，该结构体的操作函数集的实现是本模块的主体。

[html] view plain copy print ?
  1. struct snd_pcm_ops { 
  2.     int (*open)(struct snd_pcm_substream *substream); 
  3.     int (*close)(struct snd_pcm_substream *substream); 
  4.     int (*ioctl)(struct snd_pcm_substream * substream, 
  5.              unsigned int cmd, void *arg); 
  6.     int (*hw_params)(struct snd_pcm_substream *substream, 
  7.              struct snd_pcm_hw_params *params); 
  8.     int (*hw_free)(struct snd_pcm_substream *substream); 
  9.     int (*prepare)(struct snd_pcm_substream *substream); 
  10.     int (*trigger)(struct snd_pcm_substream *substream, int cmd); 
  11.     snd_pcm_uframes_t (*pointer)(struct snd_pcm_substream *substream); 
  12.     int (*copy)(struct snd_pcm_substream *substream, int channel, 
  13.             snd_pcm_uframes_t pos, 
  14.             void __user *buf, snd_pcm_uframes_t count); 
  15.     int (*silence)(struct snd_pcm_substream *substream, int channel,  
  16.                snd_pcm_uframes_t pos, snd_pcm_uframes_t count); 
  17.     struct page *(*page)(struct snd_pcm_substream *substream, 
  18.                  unsigned long offset); 
  19.     int (*mmap)(struct snd_pcm_substream *substream, struct vm_area_struct *vma); 
  20.     int (*ack)(struct snd_pcm_substream *substream); 
  21. };  
struct snd_pcm_ops {
	int (*open)(struct snd_pcm_substream *substream);
	int (*close)(struct snd_pcm_substream *substream);
	int (*ioctl)(struct snd_pcm_substream * substream,
		     unsigned int cmd, void *arg);
	int (*hw_params)(struct snd_pcm_substream *substream,
			 struct snd_pcm_hw_params *params);
	int (*hw_free)(struct snd_pcm_substream *substream);
	int (*prepare)(struct snd_pcm_substream *substream);
	int (*trigger)(struct snd_pcm_substream *substream, int cmd);
	snd_pcm_uframes_t (*pointer)(struct snd_pcm_substream *substream);
	int (*copy)(struct snd_pcm_substream *substream, int channel,
		    snd_pcm_uframes_t pos,
		    void __user *buf, snd_pcm_uframes_t count);
	int (*silence)(struct snd_pcm_substream *substream, int channel, 
		       snd_pcm_uframes_t pos, snd_pcm_uframes_t count);
	struct page *(*page)(struct snd_pcm_substream *substream,
			     unsigned long offset);
	int (*mmap)(struct snd_pcm_substream *substream, struct vm_area_struct *vma);
	int (*ack)(struct snd_pcm_substream *substream);
};


我们主要实现open、close、hw_params、hw_free、prepare和trigger接口。


open

open函数为PCM模块设定支持的传输模式、数据格式、通道数、period等参数，并为playback/capture stream分配相应的DMA通道。其一般实现如下：

[html] view plain copy print ?
  1. static int rockchip_pcm_open(struct snd_pcm_substream *substream) 
  2. { 
  3.     struct snd_pcm_runtime *runtime = substream->runtime; 
  4.     struct rockchip_runtime_data *prtd; 
  5.  
  6.     DBG("Enter::%s----%d\n",__FUNCTION__,__LINE__); 
  7.  
  8.     snd_soc_set_runtime_hwparams(substream, &rockchip_pcm_hardware); 
  9.  
  10.     prtd = kzalloc(sizeof(struct rockchip_runtime_data), GFP_KERNEL); 
  11.     if (prtd == NULL) 
  12.         return -ENOMEM; 
  13.  
  14.     spin_lock_init(&prtd->lock); 
  15.  
  16.     runtime->private_data = prtd; 
  17.     return 0; 
  18. }  
static int rockchip_pcm_open(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct rockchip_runtime_data *prtd;

	DBG("Enter::%s----%d\n",__FUNCTION__,__LINE__);

	snd_soc_set_runtime_hwparams(substream, &rockchip_pcm_hardware);

	prtd = kzalloc(sizeof(struct rockchip_runtime_data), GFP_KERNEL);
	if (prtd == NULL)
		return -ENOMEM;

	spin_lock_init(&prtd->lock);

	runtime->private_data = prtd;
	return 0;
}


其中硬件参数要根据芯片的数据手册来定义，如：

[html] view plain copy print ?
  1. int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream, 
  2.     const struct snd_pcm_hardware *hw) 
  3. { 
  4.     struct snd_pcm_runtime *runtime = substream->runtime; 
  5.     runtime->hw.info = hw->info; 
  6.     runtime->hw.formats = hw->formats; 
  7.     runtime->hw.period_bytes_min = hw->period_bytes_min; 
  8.     runtime->hw.period_bytes_max = hw->period_bytes_max; 
  9.     runtime->hw.periods_min = hw->periods_min; 
  10.     runtime->hw.periods_max = hw->periods_max; 
  11.     runtime->hw.buffer_bytes_max = hw->buffer_bytes_max; 
  12.     runtime->hw.fifo_size = hw->fifo_size; 
  13.     return 0; 
  14. }  
int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
	const struct snd_pcm_hardware *hw)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	runtime->hw.info = hw->info;
	runtime->hw.formats = hw->formats;
	runtime->hw.period_bytes_min = hw->period_bytes_min;
	runtime->hw.period_bytes_max = hw->period_bytes_max;
	runtime->hw.periods_min = hw->periods_min;
	runtime->hw.periods_max = hw->periods_max;
	runtime->hw.buffer_bytes_max = hw->buffer_bytes_max;
	runtime->hw.fifo_size = hw->fifo_size;
	return 0;
}


 

关于peroid的概念有这样的描述：The “period” is a term that corresponds to a fragment in the OSS world. The period defines the size at which a PCM interrupt is generated. peroid的概念很重要，建议去alsa官网找相关详细说明了解一下。

上层ALSA lib可以通过接口来获得这些参数的，如snd_pcm_hw_params_get_buffer_size_max()来取得buffer_bytes_max。

hw_free是hw_params的相反操作，调用snd_pcm_set_runtime_buffer(substream, NULL)即可。
注：代码中的dma_buffer是DMA缓冲区，它通过4个字段定义：dma_area、dma_addr、dma_bytes和dma_private。其中dma_area是缓冲区逻辑地址，dma_addr是缓冲区的物理地址，dma_bytes是缓冲区的大小，dma_private是ALSA的DMA管理用到的。dma_buffer是在pcm_new()中初始化的；当然也可以把分配dma缓冲区的工作放到这部分来实现，但考虑到减少碎片，故还是在pcm_new中以最大size（即buffer_bytes_max）来分配。

关于DMA的中断处理

另外留意open函数中的audio_dma_request(&s[0], audio_dma_callback);中的audio_dma_callback，这是dma的中断函数，这里以callback的形式存在，其实到dma的底层还是这样的形式：static irqreturn_t dma_irq_handler(int irq, void *dev_id)，在DMA中断处理dma_irq_handler()中调用callback。这些跟具体硬件平台的DMA实现相关，如果没有类似的机制，那么还是要在pcm模块中实现这个中断。


 

[html] view plain copy print ?
  1. void rockchip_pcm_dma_irq(s32 ch, void *data) 
  2. {     
  3.         struct snd_pcm_substream *substream = data; 
  4.     struct rockchip_runtime_data *prtd; 
  5.     unsigned long flags; 
  6.      
  7.     DBG("Enter::%s----%d\n",__FUNCTION__,__LINE__); 
  8.  
  9.     prtd = substream->runtime->private_data; 
  10.     if (substream) 
  11.         snd_pcm_period_elapsed(substream); 
  12.     spin_lock(&prtd->lock); 
  13.     prtd->dma_loaded--; 
  14.     if (prtd->state & ST_RUNNING) { 
  15.         rockchip_pcm_enqueue(substream); 
  16.     } 
  17.         spin_unlock(&prtd->lock); 
  18.         local_irq_save(flags); 
  19.     if (prtd->state & ST_RUNNING) { 
  20.         if (prtd->dma_loaded) { 
  21.             if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 
  22.                 audio_start_dma(substream, DMA_MODE_WRITE); 
  23.             else 
  24.                 audio_start_dma(substream, DMA_MODE_READ); 
  25.         } 
  26.     } 
  27.     local_irq_restore(flags);    
  28. }  
void rockchip_pcm_dma_irq(s32 ch, void *data)
{    
        struct snd_pcm_substream *substream = data;
	struct rockchip_runtime_data *prtd;
	unsigned long flags;
	
	DBG("Enter::%s----%d\n",__FUNCTION__,__LINE__);

	prtd = substream->runtime->private_data;
	if (substream)
		snd_pcm_period_elapsed(substream);
	spin_lock(&prtd->lock);
	prtd->dma_loaded--;
	if (prtd->state & ST_RUNNING) {
		rockchip_pcm_enqueue(substream);
	}
        spin_unlock(&prtd->lock);
        local_irq_save(flags);
	if (prtd->state & ST_RUNNING) {
		if (prtd->dma_loaded) {
			if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
				audio_start_dma(substream, DMA_MODE_WRITE);
			else
				audio_start_dma(substream, DMA_MODE_READ);
		}
	}
	local_irq_restore(flags);   
}

prepare

当pcm“准备好了”调用该函数。在这里根据channels、buffer_bytes等来设定DMA传输参数，跟具体硬件平台相关。注：每次调用snd_pcm_prepare()的时候均会调用prepare函数。


trigger

当pcm开始、停止、暂停的时候都会调用trigger函数。


 

[html] view plain copy print ?
  1. static int rockchip_pcm_trigger(struct snd_pcm_substream *substream, int cmd) 
  2. { 
  3.     struct rockchip_runtime_data *prtd = substream->runtime->private_data; 
  4.     int ret = 0; 
  5.     /**************add by qiuen for volume*****/ 
  6.     struct snd_soc_pcm_runtime *rtd = substream->private_data; 
  7.     struct snd_soc_dai *pCodec_dai = rtd->dai->codec_dai; 
  8.     int vol = 0; 
  9.     int streamType = 0; 
  10.      
  11.     DBG("Enter::%s----%d\n",__FUNCTION__,__LINE__); 
  12.      
  13.     if(cmd==SNDRV_PCM_TRIGGER_VOLUME){ 
  14.         vol = substream->number % 100; 
  15.         streamType = (substream->number / 100) % 100; 
  16.         DBG("enter:vol=%d,streamType=%d\n",vol,streamType); 
  17.         if(pCodec_dai->ops->set_volume) 
  18.             pCodec_dai->ops->set_volume(streamType, vol); 
  19.     } 
  20.     /****************************************************/ 
  21.     spin_lock(&prtd->lock); 
  22.  
  23.     switch (cmd) { 
  24.     case SNDRV_PCM_TRIGGER_START: 
  25.             DBG(" START \n"); 
  26.         prtd->state |= ST_RUNNING; 
  27.         rk29_dma_ctrl(prtd->params->channel, RK29_DMAOP_START); 
  28.         /* 
  29.         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 
  30.             audio_start_dma(substream, DMA_MODE_WRITE); 
  31.         } else { 
  32.             audio_start_dma(substream, DMA_MODE_READ); 
  33.         } 
  34.         */ 
  35. #ifdef CONFIG_ANDROID_POWER         
  36.         android_lock_suspend(&audio_lock); 
  37.         DBG("%s::start audio , lock system suspend\n" , __func__ ); 
  38. #endif       
  39.         break; 
  40.     case SNDRV_PCM_TRIGGER_RESUME: 
  41.         DBG(" RESUME \n"); 
  42.         break; 
  43.     case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 
  44.         DBG(" RESTART \n"); 
  45.         break; 
  46.  
  47.     case SNDRV_PCM_TRIGGER_STOP: 
  48.     case SNDRV_PCM_TRIGGER_SUSPEND: 
  49.     case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 
  50.         DBG(" STOPS \n"); 
  51.         prtd->state &= ~ST_RUNNING; 
  52.         rk29_dma_ctrl(prtd->params->channel, RK29_DMAOP_STOP); 
  53.         //disable_dma(prtd->params->channel); 
  54. #ifdef CONFIG_ANDROID_POWER         
  55.         android_unlock_suspend(&audio_lock ); 
  56.         DBG("%s::stop audio , unlock system suspend\n" , __func__ ); 
  57. #endif 
  58.          
  59.         break; 
  60.     default: 
  61.         ret = -EINVAL; 
  62.         break; 
  63.     } 
  64.  
  65.     spin_unlock(&prtd->lock); 
  66.     return ret; 
  67. }  
static int rockchip_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
{
	struct rockchip_runtime_data *prtd = substream->runtime->private_data;
	int ret = 0;
	/**************add by qiuen for volume*****/
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct snd_soc_dai *pCodec_dai = rtd->dai->codec_dai;
	int vol = 0;
	int streamType = 0;
	
	DBG("Enter::%s----%d\n",__FUNCTION__,__LINE__);
	
	if(cmd==SNDRV_PCM_TRIGGER_VOLUME){
		vol = substream->number % 100;
		streamType = (substream->number / 100) % 100;
		DBG("enter:vol=%d,streamType=%d\n",vol,streamType);
		if(pCodec_dai->ops->set_volume)
			pCodec_dai->ops->set_volume(streamType, vol);
	}
	/****************************************************/
	spin_lock(&prtd->lock);

	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
	        DBG(" START \n");
	    prtd->state |= ST_RUNNING;
	    rk29_dma_ctrl(prtd->params->channel, RK29_DMAOP_START);
	    /*
	    if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
		    audio_start_dma(substream, DMA_MODE_WRITE);
		} else {
		    audio_start_dma(substream, DMA_MODE_READ);
		}
		*/
#ifdef CONFIG_ANDROID_POWER        
        android_lock_suspend(&audio_lock);
        DBG("%s::start audio , lock system suspend\n" , __func__ );
#endif		
		break;
	case SNDRV_PCM_TRIGGER_RESUME:
	    DBG(" RESUME \n");
	    break;
	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
		DBG(" RESTART \n");
		break;

	case SNDRV_PCM_TRIGGER_STOP:
	case SNDRV_PCM_TRIGGER_SUSPEND:
	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
	    DBG(" STOPS \n");
		prtd->state &= ~ST_RUNNING;
		rk29_dma_ctrl(prtd->params->channel, RK29_DMAOP_STOP);
		//disable_dma(prtd->params->channel);
#ifdef CONFIG_ANDROID_POWER        
        android_unlock_suspend(&audio_lock );
        DBG("%s::stop audio , unlock system suspend\n" , __func__ );
#endif
		
		break;
	default:
		ret = -EINVAL;
		break;
	}

	spin_unlock(&prtd->lock);
	return ret;
}


 

Trigger函数里面的操作应该是原子的，不要在调用这些操作时进入睡眠，trigger函数应尽量小，甚至仅仅是触发DMA。


pointer

static snd_pcm_uframes_t wmt_pcm_pointer(struct snd_pcm_substream *substream)
PCM中间层通过调用这个函数来获取缓冲区的位置。一般情况下，在中断函数中调用snd_pcm_period_elapsed()或在pcm中间层更新buffer的时候调用它。然后pcm中间层会更新指针位置和计算缓冲区可用空间，唤醒那些在等待的线程。这个函数也是原子的。

snd_pcm_runtime
我们会留意到ops各成员函数均需要取得一个snd_pcm_runtime结构体指针，这个指针可以通过substream->runtime来获得。snd_pcm_runtime是pcm运行时的信息。当打开一个pcm子流时，pcm运行时实例就会分配给这个子流。它拥有很多多种信息：hw_params和sw_params配置拷贝，缓冲区指针，mmap记录，自旋锁等。snd_pcm_runtime对于驱动程序操作集函数是只读的，仅pcm中间层可以改变或更新这些信息。



更多 0

 

QNX系统中播放wav文件
阳光柠檬_的技术笔记
10-26 4882
QNX 中播放音频，用的是libasound 库。 官方提供的 wave.c 的代码，用于播放一个wav格式的音频文件。 但在QNX 6.6 虚拟机里一直播放不了，原因是虚拟机没有/dev/snd/ 而且该目录下也没什么设备。继续看官方的帮助文档，是要运行/sbin/io-audio加载声卡驱动才能播放。The io-audio command can load the following sh
Alsa pcm接口使用方法pcm status反馈
weixin_41786823的博客
07-12 1100
分析Error Code，根据error Code做不同的处理SND_PCM_STATE_OPENThe PCM device is in the open state. After the snd_pcm_open() open call, the device is in this state. Also, when snd_pcm_hw_params() call fails, then this state is entered to force application calling snd_pc
snd_pcm_ops
MyArrow的专栏
11-27 6868
ALSA驱动主要是实现snd_pcm_ops中的相关函数。 1. snd_pcm_ops 接着我们看一下snd_pcm_ops结构体，该结构体的操作函数集的实现是本模块的主体。 struct snd_pcm_ops { int (*open)(struct snd_pcm_substream *substream); int (*close)(struct
Alsa中PCM参数设置
ekenlinbing的专栏
05-31 1554
1) PCM设备的句柄. 2) 指定同时可供回放或截获的PCM流的方向 3) 提供一些关于我们想要使用的设置选项的信息,比如缓冲区大小,采样率,PCM数据格式等 4) 检查硬件是否支持设置选项.    4.1) 初始化PCM变量    4.2) 分配hwparams结构    4.3) 打开PCM设备    4.4) 以声卡的全部设置选项空间来初始化hwparams结构    4.
内核Alsa之pcm
u013531497的专栏
09-08 6856
pcm用来描述alsa中数字音频流。Alsa音频的播放/录制就是通过pcm来实现 的。 名词解释 声音是连续模拟量，计算机将它离散化之后用数字表示，就有了以下几个名词术语。 Frame. 帧是音频流中最小的单位，一段音频数据就是由苦干帧组成的。Channel. 通道表示每帧数据中包含的通道数。单声道音频Mono含有  1个通道，立体声Stereo音频通常为2个通道。Bit Depth.
树莓派上做音频采集，采集pcm数据并直接保存pcm数据_alsa-record-on-raspberrypi.zip
最新发布
09-16
5. 录制和保存PCM数据：将捕获到的音频信号以PCM格式存储到文件中，用于后续的处理或分析。 6. 后期处理：可能需要对PCM数据进行处理，比如编码转换、声音效果添加等。 此外，项目中提到的“alsa-record-on-...
alsa-lib之snd_pcm_open
Fire的博客
04-24 5463
目录 版本获取 前言 snd_pcm_open时序图 代码流程 版本获取 使用版本 alsa 1.2.5.1 release | Changes v1.2.5 v1.2.5.1 https://www.alsa-project.org/wiki/Main_Page https://github.com/alsa-project 前言 我们都知道alsa-lib包含开发人员编译 ALSA 应用程序的用户空间库, 提供接口给应用调用的。前面我们了解过ALSA框架 ，本节我们主要介绍一下alsa-lib中sn
alsa pcm player
05-24
本文将深入探讨如何使用ALSA库进行PCM格式文件的播放和录制，以及相关源码分析。 首先，我们需要理解ALSA的PCM设备模型。在ALSA中，PCM设备分为两种类型：hw和plughw。hw设备直接与硬件交互，而plughw设备则提供...
Linux 音频驱动(五) ALSA音频驱动之PCM逻辑设备
_Modest_的博客
03-08 3959
目录1. 前言2. PCM逻辑设备2.1. 创建 PCM逻辑设备：2.2. PCM逻辑设备文件操作函数集：snd_pcm_f_ops[]2.3. Open PCM逻辑设备2.4. Write/Read PCM逻辑设备2.5. Close PCM逻辑设备3. 结束语 1. 前言 前面几章分析了ASoC音频驱动中Codec、Platform、Machine驱动的组成部分及其注册过程，这三者都是物理设备相关的，大家应该对音频物理链路有了一定的认知。接着分析音频驱动的中间层，由于这些并不是真正的物理设备，故我们称之
QNX_audio_wav.docx
06-16
qnx的音频处理常见接口函数
qnx Audio DDK User Guide.chm
08-07
Audio DDK User Guide.chmAudio DDK User Guide.chmAudio DDK User Guide.chm
QNX audio_wav.docx
07-05
qnx wav 播放，使用自带的alsa库libasound 播放。wav 格式介绍，支持Windows PCM wav，其他wav（例如 Microsoft ADPCM）不支持。
snd_soc_platform 之 ops：snd_pcm_ops 分析
aningxiaoxixi的博客
11-14 587
snd_pcm_ops 注意 其中的 音频数据流向图 就是 dpam 中 流向图
[ALSA架构][ASOC架构][第四话]platform框架里的snd_pcm_ops结构体分析
天天搬砖的秃头程序员的博客
10-05 260
1. 先复习一下架构图 2.snd_pcm_ops结构体分析
QNX声音架构（QSA）入门指南
chuanpeng0130的专栏
01-29 1638
QNX声音架构（QSA）是QNX操作系统中用于处理音频输入和输出的高级、多功能音频框架。它提供了灵活的音频处理功能，包括音频捕获、播放、混音，以及与多种音频硬件的接口支持。QSA的设计旨在满足高性能和低延迟音频处理的需求。
alsa pcm接口之pcm设备的状态STATE
菜鸡搞计算机
10-07 1917
alsa pcm接口之pcm设备的状态STATE
QNX声音架构（翻译）
chuanpeng0130的专栏
01-29 2741
要重新配置音频流，您必须调用 snd_pcm_plugin_params() 或 snd_pcm_channel_params()，然后调用相应的 snd_pcm_plugin_setup() 或 snd_pcm_channel_setup() 函数。因此，请确保在写入音频数据之前，您在进行 snd_pcm_*_params() 调用后，调用 snd_pcm_*_setup() 和 snd_pcm_*_prepare() 函数。随着同时混合的音频流数量的增加，溢出的程度和频率也会增加。
ALSA PCM音频文件播放与录制的测试源码
通过以上分析，我们可以看出alsa_pcm_player这个程序不仅仅是一个简单的音频播放器，它背后涉及到了对Linux音频系统架构的深入理解和对音频编程的熟练掌握。开发者需要有处理底层硬件交互、音频数据处理以及音频文件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值