Linux驱动——ALSA

已于 2023-02-02 19:22:35 修改
阅读量2.3k 收藏 5
点赞数
分类专栏： Linux内核 文章标签： alsa linux 音频
于 2022-05-03 18:41:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaolangyangyang/article/details/124559425
版权

Linux驱动——ALSA

小狼@http://blog.csdn.net/xiaolangyangyang

 Control宏定义：

SOC_SINGLE_VALUE
SOC_SINGLE_VALUE_EXT
SOC_SINGLE
SOC_SINGLE_TLV
SOC_DOUBLE
SOC_DOUBLE_R
SOC_DOUBLE_TLV
SOC_DOUBLE_R_TLV
SOC_DOUBLE_S8_TLV
SOC_ENUM_DOUBLE
SOC_ENUM_SINGLE
SOC_ENUM_SINGLE_EXT
SOC_VALUE_ENUM_DOUBLE
SOC_VALUE_ENUM_SINGLE
SOC_ENUM
SOC_VALUE_ENUM
SOC_SINGLE_EXT
SOC_DOUBLE_EXT
SOC_SINGLE_EXT_TLV
SOC_DOUBLE_EXT_TLV
SOC_DOUBLE_R_EXT_TLV
SOC_SINGLE_BOOL_EXT
SOC_ENUM_EXT
SOC_DOUBLE_R_SX_TLV
SOC_ENUM_DOUBLE_DECL
SOC_ENUM_SINGLE_DECL
SOC_ENUM_SINGLE_EXT_DECL
SOC_VALUE_ENUM_DOUBLE_DECL
SOC_VALUE_ENUM_SINGLE_DECL

DAPM宏定义：

SND_SOC_DAPM_VMID
SND_SOC_DAPM_INPUT
SND_SOC_DAPM_OUTPUT
SND_SOC_DAPM_MIC
SND_SOC_DAPM_HP
SND_SOC_DAPM_SPK
SND_SOC_DAPM_LINE
SND_SOC_DAPM_PGA
SND_SOC_DAPM_OUT_DRV
SND_SOC_DAPM_MIXER
SND_SOC_DAPM_MIXER_NAMED_CTL
SND_SOC_DAPM_MICBIAS
SND_SOC_DAPM_SWITCH
SND_SOC_DAPM_MUX
SND_SOC_DAPM_VIRT_MUX
SND_SOC_DAPM_VALUE_MUX
SOC_PGA_ARRAY
SOC_MIXER_ARRAY
SOC_MIXER_NAMED_CTL_ARRAY
SND_SOC_DAPM_PGA_E
SND_SOC_DAPM_OUT_DRV_E
SND_SOC_DAPM_MIXER_E
SND_SOC_DAPM_MIXER_NAMED_CTL_E
SND_SOC_DAPM_MICBIAS_E
SND_SOC_DAPM_SWITCH_E
SND_SOC_DAPM_MUX_E
SND_SOC_DAPM_VIRT_MUX_E
SND_SOC_DAPM_PGA_S
SND_SOC_DAPM_SUPPLY_S
SOC_PGA_E_ARRAY
SOC_MIXER_E_ARRAY
SOC_MIXER_NAMED_CTL_E_ARRAY
SND_SOC_DAPM_PRE
SND_SOC_DAPM_POST
SND_SOC_DAPM_AIF_IN
SND_SOC_DAPM_AIF_IN_E
SND_SOC_DAPM_AIF_OUT
SND_SOC_DAPM_AIF_OUT_E
SND_SOC_DAPM_DAC
SND_SOC_DAPM_DAC_E
SND_SOC_DAPM_ADC
SND_SOC_DAPM_ADC_E
SND_SOC_DAPM_REG
SND_SOC_DAPM_SUPPLY
SOC_DAPM_SINGLE
SOC_DAPM_SINGLE_TLV
SOC_DAPM_ENUM
SOC_DAPM_ENUM_VIRT
SOC_DAPM_VALUE_ENUM
SOC_DAPM_PIN_SWITCH

static const struct snd_kcontrol_new wmxx_mix1_controls[] = {
	SOC_DAPM_SINGLE("SW1", WMXX_REG_SW, 1, 1, 0),
	SOC_DAPM_SINGLE("SW2", WMXX_REG_SW, 2, 0, 0),
	SOC_DAPM_SINGLE("SW3", WMXX_REG_SW, 3, 0, 0),
	SOC_DAPM_SINGLE("SW4", WMXX_REG_SW, 4, 0, 0)
};
	
static const struct snd_kcontrol_new wmxx_mix2_controls[] = {
	SOC_DAPM_SINGLE("SW5", WMXX_REG_SW, 5, 1, 0),
	SOC_DAPM_SINGLE("SW6", WMXX_REG_SW, 6, 0, 0),
	SOC_DAPM_SINGLE("SW7", WMXX_REG_SW, 7, 0, 0),
	SOC_DAPM_SINGLE("SW8", WMXX_REG_SW, 8, 0, 0)
};

static const struct snd_soc_dapm_widget wm8900_dapm_widgets[] = {
	SND_SOC_DAPM_MIXER("MIX1", WMXX_REG_MIX, 1, 0, wmxx_mix1_controls, ARRAY_SIZE(wmxx_mix1_controls)),
	SND_SOC_DAPM_MIXER("MIX2", WMXX_REG_MIX, 2, 0, wmxx_mix2_controls, ARRAY_SIZE(wmxx_mix2_controls))
};

static const struct snd_soc_dapm_route audio_map[] = {
	{"MIX1", "SW2", "ADC"},
	{"MIX2", "SW6", "MIX1"},
};

 播放器代码

#include <alsa/asoundlib.h>
#include <stdio.h>
#include <termios.h> 
#include <unistd.h>
#include <stdlib.h>

#define int8_t		char
#define int16_t		short
#define int32_t		int
#define int64_t		long
#define uint8_t		unsigned char
#define uint16_t	unsigned short
#define uint32_t	unsigned int
#define uint64_t	unsigned long

/* para of wav file */
typedef struct {
	uint32_t dwSize;
	uint16_t wFormatTag;
	uint16_t wChannels;
	uint32_t dwSamplesPerSec;
	uint32_t dwAvgBytesPerSec;
	uint16_t wBlockAlign;
	uint16_t wBitsPerSample;
} WAVEFORMAT;

/* format of wav file header */
typedef struct {
	uint8_t RiffID [4];
	uint32_t RiffSize;
	uint8_t WaveID[4];
	uint8_t FmtID[4];
	uint32_t FmtSize;
	uint16_t wFormatTag;
	uint16_t nChannels;
	uint32_t nSamplesPerSec;
	uint32_t nAvgBytesPerSec;
	uint16_t nBlockAlign;
	uint16_t wBitsPerSample;
	uint8_t DataID[4];
	uint32_t nDataBytes;
} WAVE_HEADER;

/* set hwparams */
static int32_t set_hwparams(snd_pcm_t *handle, snd_pcm_hw_params_t *params, snd_pcm_access_t access, uint32_t ch, snd_pcm_format_t format, uint32_t rate, snd_pcm_sframes_t *period_size)
{
	snd_pcm_uframes_t size;
	uint32_t rrate;
	int32_t err, dir;
	uint32_t buffer_time = 500000;	/* ring buffer length in us */
	uint32_t period_time = 100000;	/* period time in us */
	int32_t resample = 1;	/* enable alsa-lib resampling */

	/* choose all parameters */
	err = snd_pcm_hw_params_any(handle, params);
	if (err < 0)
	{
		printf("Broken configuration for playback: no configurations available: %s\n", snd_strerror(err));
		return err;
	}

	/* set hardware resampling */
	err = snd_pcm_hw_params_set_rate_resample(handle, params, resample);
	if (err < 0)
	{
		printf("Resampling setup failed for playback: %s\n", snd_strerror(err));
		return err;
	}

	/* set the interleaved read/write format */
	err = snd_pcm_hw_params_set_access(handle, params, access);
	if (err < 0)
	{
		printf("Access type not available for playback: %s\n", snd_strerror(err));
		return err;
	}

	/* set the sample format */
	err = snd_pcm_hw_params_set_format(handle, params, format);
	if (err < 0)
	{
		printf("Sample format not available for playback: %s\n", snd_strerror(err));
		return err;
	}

	/* set the count of channels */
	err = snd_pcm_hw_params_set_channels(handle, params, ch);
	if (err < 0)
	{
		printf("Channels count (%u) not available for playbacks: %s\n", ch, snd_strerror(err));
		return err;
	}

	/* set the stream rate */
	rrate = rate;
	err = snd_pcm_hw_params_set_rate_near(handle, params, &rrate, 0);
	if (err < 0)
	{
		printf("Rate %uHz not available for playback: %s\n", rate, snd_strerror(err));
		return err;
	}
	if (rrate != rate)
	{
		printf("Rate doesn't match (requested %uHz, get %iHz)\n", rate, err);
		return -EINVAL;
	}

	/* set the buffer time */
	err = snd_pcm_hw_params_set_buffer_time_near(handle, params, &buffer_time, &dir);
	if (err < 0)
	{
		printf("Unable to set buffer time %u for playback: %s\n", buffer_time, snd_strerror(err));
		return err;
	}
	err = snd_pcm_hw_params_get_buffer_size(params, &size);
	if (err < 0)
	{
		printf("Unable to get buffer size for playback: %s\n", snd_strerror(err));
		return err;
	}
	printf("buffer_size = %ld\n", size);

	/* set the period time */ 
	err = snd_pcm_hw_params_set_period_time_near(handle, params, &period_time, &dir);
	if (err < 0)
	{
		printf("Unable to set period time %u for playback: %s\n", period_time, snd_strerror(err));
		return err;
	}
	err = snd_pcm_hw_params_get_period_size(params, &size, &dir);
	if (err < 0)
	{
		printf("Unable to get period size for playback: %s\n", snd_strerror(err));
		return err;
	}
	*period_size = size;
	printf("period_size = %ld\n", size);

	/* write the parameters to device */
	err = snd_pcm_hw_params(handle, params);
	if (err < 0)
	{
		printf("Unable to set hw params for playback: %s\n", snd_strerror(err));
		return err;
	}

	return 0;
}

/* read wav file header*/
FILE * open_and_print_file_params(int8_t *file_name, WAVE_HEADER *g_wave_header)
{
	FILE * fp = fopen(file_name, "r");
	if (fp == NULL)
	{
		printf("can't open wav file\n");
		return NULL;
	}

	memset(g_wave_header, 0, sizeof(WAVE_HEADER));
	fread(g_wave_header, 1, sizeof(WAVE_HEADER), fp);

	printf(">> RiffID : %c%c%c%c\n", g_wave_header->RiffID[0], g_wave_header->RiffID[1], g_wave_header->RiffID[2], g_wave_header->RiffID[3]);
	printf(">> RiffSize : %d\n", g_wave_header->RiffSize);
	printf(">> WaveID : %c%c%c%c\n", g_wave_header->WaveID[0], g_wave_header->WaveID[1], g_wave_header->WaveID[2], g_wave_header->WaveID[3]);
	printf(">> FmtID : %c%c%c%c\n", g_wave_header->FmtID[0], g_wave_header->FmtID[1], g_wave_header->FmtID[2], g_wave_header->FmtID[3]);
	printf(">> FmtSize : %d\n", g_wave_header->FmtSize);
	printf(">> wFormatTag : %d\n", g_wave_header->wFormatTag);
	printf(">> nChannels : %d\n", g_wave_header->nChannels);
	printf(">> nSamplesPerSec : %d\n", g_wave_header->nSamplesPerSec);
	printf(">> nAvgBytesPerSec : %d\n", g_wave_header->nAvgBytesPerSec);
	printf(">> nBlockAlign : %d\n", g_wave_header->nBlockAlign);
	printf(">> wBitsPerSample : %d\n", g_wave_header->wBitsPerSample);
	printf(">> DataID : %c%c%c%c\n", g_wave_header->DataID[0], g_wave_header->DataID[1], g_wave_header->DataID[2], g_wave_header->DataID[3]);
	printf(">> nDataBytes : %d\n", g_wave_header->nDataBytes);

	return fp;
}

char * sctrlstr = "Digital Playback Volume";

int32_t main()
{
	int8_t *infile = "Back_to_Earth.wav";
	int8_t *device = "hw:0,0";
	snd_pcm_t *handle;
	snd_pcm_hw_params_t *hwparams;
	WAVE_HEADER g_wave_header;
	snd_pcm_format_t format;
	uint32_t ch;
	uint32_t rate;
	snd_pcm_sframes_t period_size;
	int16_t *samples;
	int32_t music_sec;
	int32_t err;
	int32_t size;
	int32_t rc;

	FILE *fp = open_and_print_file_params(infile, &g_wave_header);
	if (fp == NULL)
	{
		printf("open_and_print_file_params error\n");
		return -1;
	}

	/* set sample rate */
	rate = g_wave_header.nSamplesPerSec;

	/* set sample bit */
	if (8 == g_wave_header.FmtSize)
	{
		format = SND_PCM_FORMAT_U8;
	}
	else if (16 == g_wave_header.FmtSize)
	{
		format = SND_PCM_FORMAT_S16_LE;
	}
	else if (24 == g_wave_header.FmtSize)
	{
		format = SND_PCM_FORMAT_U24_LE;
	}
	else if (32 == g_wave_header.FmtSize)
	{
		format = SND_PCM_FORMAT_U32_LE;
	}
	else
	{
		printf("SND_PCM_FORMAT_UNKNOWN.\n");
		format = SND_PCM_FORMAT_UNKNOWN;
		return -1; 
	}

	/* set channel */
	ch = g_wave_header.nChannels;

	/* music time */
	music_sec = g_wave_header.nDataBytes / g_wave_header.nAvgBytesPerSec;
	printf("music_time : %d : %d\n", (int32_t)music_sec / 60, music_sec % 60);
	printf("Playback device is %s\n", device);
	printf("Stream parameters are %uHz, %s, %u channels\n", rate, snd_pcm_format_name(format), ch);

	err = snd_pcm_open(&handle, device, SND_PCM_STREAM_PLAYBACK, 0);
	if (err < 0) 
	{
		printf("Playback open error: %s\n", snd_strerror(err));
		return 0;
	}

	snd_pcm_hw_params_alloca(&hwparams);
	err = set_hwparams(handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED, ch, format, rate, &period_size);
	if (err < 0) {
		printf("Setting of hwparams failed: %s\n", snd_strerror(err));
		return 0;
	}

	size = (period_size * ch * snd_pcm_format_physical_width(format)) / 8;
	samples = (int16_t *)malloc(size);

	while (1) 
	{
		rc = fread(samples, sizeof(int16_t), size, fp);
		if (rc == 0)
		{
			printf("end of file on input\n");
			break;
		} 
		else if (rc != size)
		{
			printf("short read: read %d bytes\n", rc);
		}

		rc = snd_pcm_writei(handle, samples, size);
		if (rc == -EPIPE)
		{
			printf("underrun occurred\n");
			err = snd_pcm_prepare(handle);
			if( err < 0)
			{
				printf("can not recover from underrun: %s\n", snd_strerror(err));
			}
		} 
		else if (rc < 0)
		{
			printf("error from writei: %s\n", snd_strerror(rc));
		}  
		else if (rc != (int32_t)size)
		{
			printf("short write, write %d frames\n", rc);
		}
	}

	if (samples != NULL)
	{
		free(samples);
	}

	snd_pcm_close(handle);

	return 0;
}

 # arm-fsl-linux-gnueabi-gcc player.c -o player -lasound -lm -I /var/alsa/include/ -L /var/alsa/lib/

Linux/Android alsa codec音频路由dapm的配置详解

DAPM之二：audio paths与dapm kcontrol

ALSA声卡16_编写ALSA声卡应用程序_学习笔记

8.声卡驱动06-自己实现alsa驱动-虚拟声卡-widget

ALSA驱动asoc框架之machine(一)

ALSA驱动asoc框架之machine(二)

ALSA驱动asoc框架之Platform

ALSA驱动asoc框架之Codec

Linux ALSA 音频系统：物理链路篇

Linux ALSA 音频系统：逻辑设备篇

Hello Mr.Z
关注
专栏目录
ALSA声卡驱动中的DAPM详解之一：kcontrol
sinat_37817094的博客
11-27 2494
DAPM是Dynamic Audio Power Management的缩写，直译过来就是动态音频电源管理的意思，DAPM是为了使基于linux的移动设备上的音频子系统，在任何时候都工作在最小功耗状态下。DAPM对用户空间的应用程序来说是透明的，所有与电源相关的开关都在ASoc core中完成。用户空间的应用程序无需对代码做出修改，也无需重新编译，DAPM根据当前激活的音频流（playback/c...
linux驱动开发： wm8960 codec代码分析
eydwyz的专栏
05-24 2038
关于alsa架构已经啃了好久好久，但是也卡了好久好久。难说皮毛到底有看懂多少，不管，我们先来啃wm8960 codec的驱动代码： 必要相关函数说明：  //////////////////////////////////////////////////////////////////////////// 1.#define SOC_ENUM_SINGLE(xreg, xshift, x
Linux alsa kcontrol
南大侠的博客
06-22 1017
Control接口主要作用是应用程序（alsa-lib）可以访问kcontrol 来控制音频codec芯片中的多路开关，滑动控件等。对于Mixer（混音）来说，所有的mixer工作都是通过control接口的API来实现的。一个kcontrol可以代表一个mixer（混音器），或者是一个mux（多路开关），又或者是一个Volume （音量控制器）等等。 iface的设备分类 access 类型 kcontrol实例 我们来看一下rk817的codec的kcontrol定义 看一下SOC_ENUM_EXT
kernel\sound\soc\s3c24xx\Valar_wm89xx.c
12-25 1482
android audio driver   kernel\sound\soc\s3c24xx\Valar_wm89xx.c   module_init(smdk64xx_audio_init); static int __init smdk64xx_audio_init(void) {      smdk64xx_snd_device = platfor
audio DAPM----kcontrol
wantingfy的博客
06-07 319
alsa
ALSA声卡驱动中的DAPM详解之三：如何定义各种widget
热门推荐
DroidPhone的专栏
10-24 3万+
/*****************************************************************************************************/ 声明：本博内容均由http://blog.csdn.net/droidphone原创，转载请注明出处，谢谢！ /**************************************
linux——alsa中多个声卡设备时打开某一指定声卡的PCM设备
夜风的博客
09-13 1万+
前言 最近调试板子上的3个ADAU1761音频接口，使用pocketsphinx语音库调用alsa库的API接口打开指定的Mic进行录入语音时出现异常，默认情况只能打开第一个ADAU1761音频接口，想打开第二个或第三个ADAU1761音频接口时却出现错误，本文记录一下调试的过程。 PCM设备选择 移植alsa lib 和alsa utils库后(移植教程见：传送门)可使用以下指令查看声卡设...
Linux-audio-interface.rar_ALSA接口_Audio接口_alsa_linux_linux alsa
09-21
**Linux音频接口——聚焦ALSA** 在Linux操作系统中，音频处理和播放是一个复杂但至关重要的领域，这主要归功于其强大的开源特性。ALSA（Advanced Linux Sound Architecture，高级Linux声音架构）是Linux系统下的...
Linux ALSA 驱动解析：聚焦alsa-uda134x在嵌入式系统中的应用
内容包括ALSA驱动的两种主要形式——alsa和oss，以及alsa的soc子系统ALSASoC层的介绍，强调了解决解码器与处理器紧密结合问题的重要性。" 在Linux操作系统中，音频驱动扮演着至关重要的角色，用于管理硬件音频设备...
alsa-driver-1.0.10.tar.gz_alsa_alsa-driver-rhtV5_linux alsa
09-24
《Linux下Alsa驱动详解——以alsa-driver-1.0.10.tar.gz为例》 在计算机领域，声音系统的管理是操作系统中不可或缺的一部分。在Linux系统中，Alsa（Advanced Linux Sound Architecture，高级Linux音频架构）是核心...
alsa（asoc dapm）框架分析
12-24
alsa（asoc dapm）框架分析，描述了alsa 音频驱动开发过程中一些工具的使用和驱动的分析框架
DAPM之二：音频通路与dapm kcontrol
05-03
从应用到内核系统分析了dapm kcontrol的作用、配置、建立及触发过程，理解这些对于alsa音频通道切换会有较大的帮助。
创新的嵌入式Linux——TenHz Linux.pdf
09-07
《创新的嵌入式Linux——TenHz Linux》 腾思软件在2003年上半年推出的TenHz Linux是一款专为嵌入式系统设计的操作系统，它基于GPL协议，开放全部源代码，无需任何额外的开发和生产许可协议。这一创新使得用户能够在...
audio子系统笔记
ask_true的博客
04-01 761
platform、codec、machine的关系： Linux ALSA音频系统:platform,machine,codec - JavaShuo machine：机器，完整的产品；codec和platform都是该机器下的某个部件。
snd_kcontrol探究
AZURE
01-18 1万+
control控制接口 控制接口对于许多开关(switch)和调节器(slider)应用广泛，它能被用户空间存取，从而读写CODEC相关寄存器。control的主要用于mixer。它用snd_kcontrol_new结构体描述。 snd_kcontrol_new struct snd_kcontrol_new { snd_ctl_elem_ifac
MTK 外部功放的驱动配置
YuZhuQue的博客
11-05 3436
MTK 外部PA功放的驱动设置 使能脚的配置 一般情况下，外部功放都有一个使能脚直接控制 如这里的AUDIO_PA_EN，我们需要将这个引脚配置成GPIO输出模式 dts配置 AUD_pins_extamp_high: audexamphigh { pins_cmd_dat { pins = <PINMUX_GPIO2__FUNC_G...
Linux音频ALSA机制学习笔记<二>
Focus on the Linux kernel
11-04 3679
首先是dapm是什么？就是音频电源动态管理。相信电源管理大家都不会陌生。dapm设计的目的就是只有需要时才打开必要的部件 （widget），不需要时则关闭部件， 达到省电的目的。ALSA通过kcontrol来切换音频通道，当playback或者capture时会更新通道激活下 的widget power,这个是由内核event统一完成的，无须上层干预。 widget 定义widget s
ALSA声卡驱动中的DAPM详解之七：dapm事件机制（dapm event）
DroidPhone的专栏
11-09 2万+
前面的六篇文章，我们已经讨论了dapm关于动态电源管理的有关知识，包括widget的创建和初始化，widget之间的连接以及widget的上下电顺序等等。本章我们准备讨论dapm框架中的另一个机制：事件机制。通过dapm事件机制，widget可以对它所关心的dapm事件做出反应，这种机制对于扩充widget的能力非常有用，例如，对于那些位于codec之外的widget，好像喇叭功放、外部的前置放大
Linux内核中Alsa驱动详解
本文将深入探讨ALSA(Advanced Linux Sound Architecture)驱动的细节，主要集中在2.6.21内核版本。ALSA驱动是Linux操作系统中用于处理音频功能的核心组件，它为用户空间的应用程序提供了与硬件交互的接口。我们将分析...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值