嵌入式音乐播放器

最新推荐文章于 2024-06-03 15:26:03 发布
最新推荐文章于 2024-06-03 15:26:03 发布
阅读量7k 收藏 75
点赞数 9
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_39440759/article/details/82871834
版权

通过madplay命令进行歌曲播放，功能有：
1、实现音乐的开始播放、结束播放、继续播放、暂停播放；
2、实现歌曲上一首、下一首切换；
3、实现歌曲播放模式的选择（顺序播放、随机播放、单曲循环）；
4、实现音量调节（有上限和下限）；

通过两个程序控制这个音乐播放器
客户端用来发一些请求就可以了。
服务器端：至少创建三个进程，父进程，子进程阻塞，等待回收孙进程，孙进程负责播放音乐。
父进程：用于监听按键和socket请求，与孙进程进行通信（通过共享内存），告诉孙进程需要播放的歌曲名，以及发送信号给孙进程。
子进程：一直不停的创建孙进程，然后wait等待孙进程结束，再创建新的孙进程。
孙进程：读共享内存中的歌曲名，execl执行madplay，接收父进程发来的信号（暂停，杀死等信号）。
共享内存：三个进程之间的通信用共享内存实现，歌曲列表通过系统调用的函数写道链表中，再fork父子孙三进程。
音量调节：https://blog.csdn.net/zqixiao_09/article/details/50859302

用到的系统调用函数：
pid_t fork(void);
pid_t waitpid(pid_t pid,int *status, int options);
int execl(const char *pathname, const char *arg, ..., (char *)NULL);
shmid = shmget(SHMKEY, SHMSIZE, IPC_CREAT | IPC_EXCL);   //创建共享内存
shmaddr = shmat(shmid, NULL, 0);    //映射到虚拟地址空间
int ioctl(int handle, int cmd,[int *argdx, int argcx]); //控制I/O设备
 

源码：

 

main.c

#include "server.h"

struct info* shareInfo;
int total = 0;
Node *first = NULL;
pid_t pid;
//extern OnMusic[20];

int main()
{
	int shmid;
	int ret;
	int status;
	
	//初始化链表
	ret = LinkInit(&first);
	if(ret == SUCCESS)
	{
		printf("init success \n");
	}
	else
	{
		printf("init failure \n");
	}
	
	//获取歌曲名，顺便把歌曲名插入到链表中
	GetName();
	printf("total is %d \n",total);

	//显示链表
	ret = LinkShow(first);
	if(ret == SUCCESS)
	{
		printf("show success \n");
	}
	else
	{
		printf("show failure \n");
	}

	//开辟共享内存
	shmid = shmget(SHMKEY, sizeof(struct info), IPC_CREAT | IPC_EXCL);
	if(-1 == shmid)
	{
		perror("shmget");
		exit(1);
	}

	//映射到进程的虚拟内存
	shareInfo = (struct info*)shmat(shmid, NULL, 0);
	if(NULL == shareInfo)
	{
		perror("shmat");
		exit(1);
	}

	//初始化共享内存的一些参数
	strcpy(shareInfo->order, "off");
	strcpy(shareInfo->mode, "order");
	shareInfo->num = 1;
	
	//创建进程 先创建父子两个进程，再在子进程里面再次调用fork就有了孙进程
	pid = fork();
	if(pid < 0)
	{
		perror("fork");
	}
	else if(pid == 0)
	{
		//子进程代码段
		printf("clid process id: %d \n", getpid());
		//不停的创建孙进程
		while(1)
		{
			pid = fork();
			if(pid < 0)
			{
				perror("fork");
			}
			else if(pid == 0)
			{
				//孙进程代码段
				printf("grandson process id: %d \n", getpid() );
				shareInfo->ppid = getpid();
				//音乐播放函数
				MusicPlay();
			}
			else
			{
				printf("clild process id: %d \n", getpid() );
				printf("child in wait \n");
				//等待孙进程结束
				waitpid(pid, &status, 0);
				//判断孙进程结束状态
				//正常退出状态
				if(WIFEXITED(status))
				{
					printf("child exit \n");
					//查看循环模式，如果是顺序播放就把下一首音乐的歌名存到共享内存中
					ret = CheckMode();
					if(ret == SUCCESS)
					{
						printf("on music is %s\n",shareInfo->name);
					}
					else
					{
						printf("on music is %s\n",shareInfo->name);
					}
				}
				//被信号杀死而退出，什么都不做，因为再父进程那接收到socket请求的同时以及把歌曲写到共享内存中了
				else if(WIFSIGNALED(status))
				{
					printf("siganl kill \n");
				}
				else
				{
					printf("......\n");
				}
		
			}
			
		}
	}
	else
	{
		//父进程代码段
		printf("parent process id: %d \n", getpid() );
		//父进程的主函数，一直阻塞接收来自客户端socket的请求
		Parent_Recv();
	}

}





server.c


#include "server.h"

int ret;
int sound = 1;  //音量参数
//int number = 1;
extern struct info* shareInfo; //共享内存地址
extern Node *first; //链表首地址
//char OnMusic[20] = "../music/111.mp3";
int devmask, stereodevs;  //调节音量的
const char *sound_device_names[] = SOUND_DEVICE_NAMES;  //存放可用的音频设备
int devfd; //打开的音频设备的文件描述符
extern int total; //总共的歌曲数目
extern pid; 

//音频设备的初始化
int DeviceInit(char *dev)
{
	int i;
	int status;
	devfd = open("/dev/mixer", O_RDONLY);
	if (devfd == -1) 
	{
		perror("unable to open /dev/mixer");
		return FAILURE;
	}

	status = ioctl(devfd, SOUND_MIXER_READ_DEVMASK, &devmask);
	if (status == -1)
	{
		perror("SOUND_MIXER_READ_DEVMASK ioctl failed");
		return FAILURE;
	}
	status = ioctl(devfd, SOUND_MIXER_READ_STEREODEVS, &stereodevs);
	if (status == -1)
	{
		perror("SOUND_MIXER_READ_STEREODEVS ioctl failed");
  		return FAILURE;
	}

	for (i = 0 ; i < SOUND_MIXER_NRDEVICES ; i++)
	{
		if (((1 << i) & devmask) && !strcmp(dev, sound_device_names[i]))
		{
			break;
		}
	}
	if(i == SOUND_MIXER_NRDEVICES) 
	{ 
		fprintf(stderr, "%s is not a valid mixer device\n", dev);
		return FAILURE;
	}

	return i;
}

//父进程的函数
void Parent_Recv()
{
	int fd, sockfd;
	int length = sizeof(client_addr);
	int ppid;
	int device;
	char choise[10];
	Info1 RecvInfo;
	char vol[10] = "vol";

	
	sockfd = SocketInit();

	fd = accept(sockfd, (struct sockaddr *)&client_addr, &length);	
	if(fd == -1)
	{
		perror("accept");
	}
	else
	{
		printf("client connect success \n");
		printf("port is %d fd is %d \n", client_addr.sin_port, fd);	
	}

	ret = MusicCopy(first, 1);
	if(ret == SUCCESS)
	{
		printf("init music copy success \n");
		printf("success on music is %s \n",shareInfo->name);
	}
	else
	{
		printf("init music copy fialure \n");
		printf("failure on music is %s \n",shareInfo->name);
	}

	device = DeviceInit(vol);
	if(device == FAILURE)
	{
		printf("device init failure \n");
	}
	else
	{
		printf("device init success \n");
	}

		
	while(1)
	{
		printf("in parent while\n");
		
		ret = recv(fd ,&RecvInfo, sizeof(RecvInfo), 0);
		if(ret == -1)
		{
			perror("recv");
		}
		if(strcmp(RecvInfo.flag, "on") == 0) 
		{
			printf("recv flag : %s \n", RecvInfo.flag);
			strcpy(shareInfo->order, "on");
			printf("chareinfo order : %s \n", shareInfo->order);
			kill(shareInfo->ppid, SIGCONT);
		}
		else if(strcmp(RecvInfo.flag, "off") == 0) 
		{
			printf("recv flag : %s \n", RecvInfo.flag);
			strcpy(shareInfo->order, "off");
			printf("chareinfo order : %s \n", shareInfo->order);
			kill(shareInfo->ppid, SIGKILL);
		}
		else if(strcmp(RecvInfo.flag, "stop") == 0) 
		{
			printf("recv flag : %s \n", RecvInfo.flag);
			strcpy(shareInfo->order, "stop");
			printf("chareinfo order : %s \n", shareInfo->order);
			kill(shareInfo->ppid, SIGSTOP);
		}
		else if(strcmp(RecvInfo.flag, "next") == 0) 
		{
			printf("recv flag : %s \n", RecvInfo.flag);
			kill(shareInfo->ppid, SIGKILL);
			strcpy(shareInfo->order, "next");
			printf("chareinfo order : %s \n", shareInfo->order);
			(shareInfo->num)++;
			if((shareInfo->num) > total)
			{
				shareInfo->num = 1;
			}
			printf("num is %d \n", shareInfo->num);
			ret = MusicCopy(first, shareInfo->num);
			if(ret == SUCCESS)
			{
				printf("music copy success \n");
				printf("success on music is %s \n",shareInfo->name);
			}
			else
			{
				printf("music copy fialure \n");
				printf(" fial on music is %s \n",shareInfo->name);
			}

		}
		else if(strcmp(RecvInfo.flag, "front") == 0) 
		{
			printf("recv flag : %s \n", RecvInfo.flag);
			kill(shareInfo->ppid, SIGKILL);
			strcpy(shareInfo->order, "front");
			printf("chareinfo order : %s \n", shareInfo->order);
			(shareInfo->num)--;
			if((shareInfo->num) <= 0)
			{
				shareInfo->num = total;
			}
			printf("num is %d \n", shareInfo->num);
			ret = MusicCopy(first, shareInfo->num);
			if(ret == SUCCESS)
			{
				printf("music copy success \n");
				printf("success on music is %s \n",shareInfo->name);
			}
			else
			{
				printf("music copy fialure \n");
				printf("failure on music is %s \n",shareInfo->name);
			}

		}
		else if(strcmp(RecvInfo.flag, "poweron") == 0) 
		{
			printf("recv flag : %s \n", RecvInfo.flag);
			sound++;
			printf("soud is %d \n", sound);
			ret = Sound(device, sound);
			if(ret == SUCCESS)
			{
				printf("soud is %d\n", sound);
			}
			else
			{
				printf("sound failure \n");
			}
		}
		else if(strcmp(RecvInfo.flag, "poweroff") == 0) 
		{
			printf("recv flag : %s \n", RecvInfo.flag);
			sound--;
			printf("soud is %d \n", sound);
			ret = Sound(device, sound);
			if(ret == SUCCESS)
			{
				printf("soud is %d\n", sound);
			}
			else
			{
				printf("sound failure \n");
			}
		}
		else if(strcmp(RecvInfo.flag, "sigal") == 0) 
		{
			printf("recv flag : %s \n", RecvInfo.flag);
			strcpy(shareInfo->mode, "sigal");
		}
		else if(strcmp(RecvInfo.flag, "order") == 0) 
		{
			printf("recv flag : %s \n", RecvInfo.flag);
			strcpy(shareInfo->mode, "order");
		}
		else if(strcmp(RecvInfo.flag, "random") == 0) 
		{
			printf("recv flag : %s \n", RecvInfo.flag);
			strcpy(shareInfo->mode, "random");
		}
		else if(strcmp(RecvInfo.flag, "quit") == 0) 
		{
			printf("recv flag : %s \n", RecvInfo.flag);
			kill(shareInfo->ppid, SIGKILL);
			kill(pid,SIGKILL);
			exit(1);
		}
		else
		{
			sleep(3);
			printf("wait client \n");
		}
	}

}


//调节音量 dev：设备名 num：音量参数
int Sound(int dev, int num)
{
	int left, right, level;
	int status;
	if(num > 5 || num < 0)
	{
		return FAILURE;
	}
	switch(num)
	{
		case 1:
		left = 50;
		right = 50;
		level = (right << 8) + left;
		status = ioctl(devfd, MIXER_WRITE(dev), &level);
		if (status == -1) 
		{
			perror("MIXER_WRITE ioctl failed");
			return FAILURE;
		}
		left = level & 0xff;
		right = (level & 0xff00) >> 8;
		fprintf(stderr, "%s gain set to %d%% / %d%%\n", dev, left, right);
			break;

		case 2:
		left = 60;
		right = 60;
		level = (right << 8) + left;
		status = ioctl(devfd, MIXER_WRITE(dev), &level);
		if (status == -1) 
		{
			perror("MIXER_WRITE ioctl failed");
			return FAILURE;
		}
		left = level & 0xff;
		right = (level & 0xff00) >> 8;
		fprintf(stderr, "%s gain set to %d%% / %d%%\n", dev, left, right);
			break;

		case 3:
		left = 70;
		right = 70;
		level = (right << 8) + left;
		status = ioctl(devfd, MIXER_WRITE(dev), &level);
		if (status == -1) 
		{
			perror("MIXER_WRITE ioctl failed");
			return FAILURE;
		}
		left = level & 0xff;
		right = (level & 0xff00) >> 8;
		fprintf(stderr, "%s gain set to %d%% / %d%%\n", dev, left, right);
			break;

		case 4:
		left = 80;
		right = 80;
		level = (right << 8) + left;
		status = ioctl(devfd, MIXER_WRITE(dev), &level);
		if (status == -1) 
		{
			perror("MIXER_WRITE ioctl failed");
			return FAILURE;
		}
		left = level & 0xff;
		right = (level & 0xff00) >> 8;
		fprintf(stderr, "%s gain set to %d%% / %d%%\n", dev, left, right);
			break;

		case 5:
		left = 90;
		right = 90;
		level = (right << 8) + left;
		status = ioctl(devfd, MIXER_WRITE(dev), &level);
		if (status == -1) 
		{
			perror("MIXER_WRITE ioctl failed");
			return FAILURE;
		}
		left = level & 0xff;
		right = (level & 0xff00) >> 8;
		fprintf(stderr, "%s gain set to %d%% / %d%%\n", dev, left, right);
			break;

		case 6:
		left = 100;
		right = 100;
		level = (right << 8) + left;
		status = ioctl(devfd, MIXER_WRITE(dev), &level);
		if (status == -1) 
		{
			perror("MIXER_WRITE ioctl failed");
			return FAILURE;
		}
		left = level & 0xff;
		right = (level & 0xff00) >> 8;
		fprintf(stderr, "%s gain set to %d%% / %d%%\n", dev, left, right);
			break;

	}
	return SUCCESS;
}


//把链表中的第num首歌写道共享内存中
int MusicCopy(Node *l, int num)
{
	int k = 1;
	printf("node is %s \n", l);
	if(NULL == l)
	{
		printf("l is null\n");
		return FAILURE;
	}

	Node *p = l;
	
	while(k <= num && p != NULL)
	{
		printf("k < num failure \n");
		p = p->next;
		k++;
	}

	if((k > (num + 1)) || p == NULL)
	{
		printf("k > num failure \n");
		return FAILURE;
	}

	strcpy(shareInfo->name, p->music_name);
	printf("share music name is:%s \n",shareInfo->name);

	return SUCCESS;
}



//socket初始化
int SocketInit()
{
	int sockfd;

	sockfd = socket(PF_INET, SOCK_STREAM, 0);
	if(-1 == sockfd)
	{
		perror("socket");
		//exit(1);
	}

	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = PF_INET;
	server_addr.sin_port = htons(PORT);
	server_addr.sin_addr.s_addr = inet_addr("192.168.162.128");
	ret = bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if(ret < 0)
	{
		perror("bind");
	//	exit(1);
	}

	ret = listen(sockfd, 5);
	if(ret < 0)
	{
		perror("listen");
	//	exit(1);
	}

	return sockfd;
}


//获取歌曲的名字
void GetName()
{
	char name[20];
	char flag[10];
    DIR *dirp;
    struct dirent *dp;
	const char *dirpath = "./music";

    dirp = opendir(dirpath);
    if (dirp  == NULL) 
	{
        printf("opendir failed on '%s'", dirpath);
        return;
    }

	while(1)
	{
        dp = readdir(dirp);
        if (dp == NULL)
		{
			break;
		}
		else if (strcmp(dp->d_name, ".") == 0 || strcmp(dp->d_name, "..") == 0)
		{
			continue;          
		}
        else
		{
			strcpy(name, dirpath);
			strcat(name, "/");
			strcat(name, dp->d_name);
		}

		ret = LinkInsert(first, name);
		if(ret == SUCCESS)
		{
			total++;
			printf("insert success \n");
		}
		else
		{
			printf("insert failure \n");
		}
		printf("total is %d \n",total);
	}
}

//链表初始化
int LinkInit(Node **l)
{
	*l = (Node *)malloc(sizeof(Node));
	if(NULL == *l)
	{
		return FAILURE;
	}

	(*l)->next = NULL;
	
	return SUCCESS;
}


int LinkInsert(Node *l, char *name)
{
	if(l == NULL)
	{
		return FAILURE;
	}
	
	if(name == NULL)
	{
		return FAILURE;
	}

	Node *p = l;
	while(p->next != NULL)
	{
		p = p->next;
	}
	Node *n = (Node *)malloc(sizeof(Node));

	p->next = n;

	strcpy(n->music_name, name);
	
	n->next = NULL;

	return SUCCESS;
}


int LinkShow(Node *l)
{
	if(NULL == l)
	{
		return FAILURE;
	}
	
	Node *p = l;

	while(p->next != NULL)
	{
		p = p->next;
		printf("link info :%s \n", p->music_name);
	}

	return SUCCESS;
}
/*
char* GetLink(Node *l, int num)
{
	char buf[10] = "false";
	char *name;
	name = (char *)malloc(10);
	int k = 1;
	if(NULL == l)
	{
		return buf;
	}

	Node *p = l;
	
	while(k <= num && p != NULL)
	{
		p = p->next;
		k++;
	}

	if(k > num || p == NULL)
	{
		return buf;
	}

	strcpy(name, p->music_name);
	return name;
}
*/


//**********************************

//检查播放模式
int CheckMode()
{
	printf("this mode is %s \n", shareInfo->mode);
	if(strcmp(shareInfo->mode, "sigal") == 0)
	{
		ret = MusicCopy(first, shareInfo->num);
		if(ret == SUCCESS)
		{
			printf("music copy success \n");
			printf("success on music is %s \n",shareInfo->name);
		}
		else
		{
			printf("music copy fialure \n");
			printf("fail on music is %s \n",shareInfo->name);
		}
	}
	else if(strcmp(shareInfo->mode, "order") == 0)
	{
		(shareInfo->num)++;
		if((shareInfo->num) > total)
		{
			shareInfo->num = 1;
		}
		printf("set mode num is %d \n", shareInfo->num);
		ret = MusicCopy(first, shareInfo->num);
		if(ret == SUCCESS)
		{
			printf("music copy success \n");
			printf("success on music is %s \n",shareInfo->name);
		}
		else
		{
			printf("music copy fialure \n");
			printf("fail on music is %s \n",shareInfo->name);
		}
	}
	else if(strcmp(shareInfo->mode, "random") == 0)
	{
		shareInfo->num = rand()%total;
		ret = MusicCopy(first, shareInfo->num);
		if(ret == SUCCESS)
		{
			printf("music copy success \n");
			printf("success on music is %s \n",shareInfo->name);
		}
		else
		{
			printf("music copy fialure \n");
			printf("fail on music is %s \n",shareInfo->name);
		}
	}
	else
	{
		return FAILURE;
	}

	return SUCCESS;
}

void KillPro()
{
	printf("kill signal \n");
}

void StopPro()
{
//	printf("stop signal \n");
}

void ContPro()
{
//	printf("cont signal \n");
}

//孙进程的音乐播放函数
void MusicPlay()
{
	char opt[10] = " ";
	signal(SIGKILL, KillPro);
	signal(SIGSTOP, StopPro);
	signal(SIGCONT, ContPro);
/*	ret = CheckMode();
	if(ret == SUCCESS)
	{
		printf("on music is %s\n",shareInfo->name);
	}
	else
	{
		printf("on music is %s\n",shareInfo->name);
	}
*/
	while(1)
	{

		printf("madplay share info music is : %s \n", shareInfo->name);
		printf("madplay share info order is : %s \n", shareInfo->order);
		printf("madplay No%d \n",shareInfo->num);
		if(strcmp(shareInfo->order, "off") != 0)
		{
			execl("/usr/local/bin/madplay" , opt , shareInfo->name , NULL);
		}
		{
			sleep(3);
			printf("wait client \n");
		}
		
	}
}





















server.h


#ifndef MUSIC_H
#define MUSIC_H

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <unistd.h>
#include <signal.h>
#include <time.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <dirent.h>
#include <sys/ioctl.h>
#include <linux/soundcard.h>



#define SHMKEY		1234
#define PORT 		7777
#define FAILURE		10000
#define SUCCESS		10001
#define TRUE		10002
#define FALSE		10003

struct sockaddr_in server_addr;
struct sockaddr_in client_addr;


struct info
{
	int ppid;
	int num;
	char name[20];
	char order[10];
	char mode[10];
};
typedef struct info Info;

struct info1
{
	char flag[10];
	char music[20];
};
typedef struct info1 Info1;

struct node
{
	char music_name[20];
	struct node *next;

};
typedef struct node Node;

int LinkShow(Node *l);
void Parent_Recv();
int SocketInit();
void Child_Pro();
void GetName();
int LinkInit(Node **l);
int LinkInsert(Node *l, char *name);
void MusicPlay();




#endif

 

海都是水
关注
  • 9
    点赞
  • 踩
  • 75
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
RuneAudio:用于嵌入式硬件的免费开源 Hi-Fi 音乐播放器-开源
05-29
RuneAudio 是一款免费的开源软件，可将嵌入式硬件变成 Hi-Fi 音乐播放器。 我们希望将廉价、低功耗和静音的迷你 PC 用作高保真数字信号源。 RuneAudio 具有定制的 Linux 发行版 (RuneOS) 和网络播放器 (RuneUI)，允许从多个设备（台式电脑、上网本、平板电脑、智能手机）远程控制播放和设置选项。
madplay命令使用（Linux音乐播放器）
佳佳鸽的博客
08-01 1万+
更多资料请点击：我的目录 本篇仅用于记录自己所学知识及应用，代码仍可优化，仅供参考，如果发现有错误的地方，尽管留言于我，谢谢。 madplay命令使用详细参数： -v 获取音乐播放时间 -q 不存在任何打印,但现实警告 -Q 不存在任何打印 –downsample 只采用一半数据 -i 忽略CRC校验错误 -o PATH/xx.wav 可以用来转码，将mp3转为wav，也可以是其他格式。 -a 开启衰减音量 ，增加音量，衰减系统为-175~+18 （当然通过键盘±也可以调整音量） -A 同-
mp3库及madplay 的移植
嵌入式学习之路
06-23 873
mp3库及madplay 的移植kernel版本：2.6.38.6arm运行环境：fs2410gcc交叉工具版本：gcc-3.4.5-glibc-2.3.6mpeg-audio decoder and player准备好源码zlib-1.2.3.tar.tar        =>  文件压缩与解压libid3tag-0.15.1b.tar.gz  => MP3的解码库libmad-0.15.1
基于STM32嵌入式——简单的音乐播放器
最新发布
qq_73285500的博客
06-03 863
无源蜂鸣器。
在linux系统下使用madplay制作音乐播放器
Michelle
07-08 5538
目的 制作一个可以在Linux环境下运行的MP3播放器。要求实现的MP3主要功能包括：播放、暂停、继续、停止、循环播放、上一曲、下一曲、退出、歌曲显示等功能。 本设计是基于madplay库实现的，程序运行时会显示一个字符界面，在该字符界面下输入相应的提示字符即可实现音乐的播放、暂停、继续、停止、上一曲、下一曲、歌词的显示等功能，也可以加入额外的一些功能。编写一个MakeFile文件，make命令来...
嵌入式MP3播放器（madplay）
zxz_Fine的博客
01-01 904
可网络自行下载，下载地址：https://sourceforge.net/projects/mad/files/libid3tag.so.0.3.0和libmad.so.0.2.1在 target-arm/lib/里。交叉编译库文件形成可执行文件后，将编译好的动态库和可执行文件移植到开发板上即可“食用”libid3tag.so.0和libmad.so.0放到/lib目录下。设置音量:-a -175 ~ +18(播放是按+/-调节)再次上一步的./configure后开始编译和安装。上一首/下一首:b/f。
基于madplay库linux应用编程实现音乐播放器
M10F的博客
03-28 3718
基于madplay库linux应用编程实现音乐播放器 该系统可实现：播放、暂停、继续、停止、上一首、下一首、音量调节及退出等功能。 用madplay库实现一个简单的音乐播放器，可以播放本地的音频文件并具备基本的音乐操作处理功能 主菜单效果图： 函数相应功能 文件名 函数名 返回值类型 功能描述 main.c main() int 该程序的主函数 ...
Linux c实现音乐播放器(madplay)
热门推荐
Lawrence_121
08-17 2万+
/* 项目需求： 1.实现音乐基本功能：播放，暂停及继续，下一首，上一首，退出。 2.自动生成歌曲列表文件。(重定向) 3. 实现单曲循环。 思路： 1.由于学了fork(),exec函数，想到在进程里创建一个子进程来播放音乐。 2.暂停及继续，...
linux子进程运行播放器播放,父进程从argv[1]读到的音乐文件
Kongxl64的博客
12-10 45
内容为上课内容,如有错误,还望大神指点!!!!
嵌入式音乐播放器系统的制作
08-29
音乐播放器的详细制作过程，非常好用。希望给你带来帮助。
2音乐播放器设计_音乐播放器_嵌入式单片机_
09-30
在音乐播放器设计领域，尤其是针对嵌入式系统的单片机应用，开发一款能在Proteus环境下模拟运行的音乐播放器是一项技术挑战。这个项目主要关注于如何利用单片机控制音乐播放，实现音乐的切换、播放和停止等功能。...
嵌入式音频播放器
04-23
验证过的可在嵌入式linux环境下运行的，基于命令行的音频播放器，支持mp3，wav等格式
基于w90p710的嵌入式音乐播放器实例
06-24
本案例聚焦于一个基于W90P710的嵌入式音乐播放器实例，该芯片通常用于低功耗、高性能的嵌入式应用，如音频处理。下面将详细解释相关知识点。 1. ARM汇编语言编程： ARM架构是广泛使用的微处理器架构，尤其在嵌入式...
嵌入式实现MP3项目.zip
03-05
这样的系统对于嵌入式设备，如智能家居、车载娱乐系统或者便携式媒体播放器，都具有重要的应用价值。 首先，我们来深入理解MP3编码与解码。MP3是一种有损音频压缩格式，它通过去除人耳难以察觉的高频部分来降低文件...
嵌入式GEC6818_音视频播放器项目.rar
12-06
在这个项目中，我们关注的是基于GEC6818的嵌入式开发板，它被用作一个音视频播放器。GEC6818是一款常见的微处理器，适用于各种嵌入式应用，具有良好的处理能力和低功耗特性，使得它成为构建高效能播放器的理想选择。...
基于linux多线程的MP3播放器小程序
qq_54190360的博客
10-20 392
简单实现音乐播放小程序
Linux多进程实现MP3播放器
weixin_58962299的博客
10-29 382
多进程
Linux下音乐播放器的实现
samson
03-29 1万+
1.项目描述：实现了播放器的页面，并读取出文件中的歌曲名把歌曲列表显示在右侧。可以通过触 摸屏幕上的按钮实现暂停和继续播放、静音和解除静音、调节音量大小、快进和快退、点击进度 条更改歌曲播放进度、点击歌曲名切换歌曲的功能。在歌词随歌曲的播放而同步显示时，页面中 还会展现歌曲名、演唱者、歌曲总长度、歌曲当前播放时间和歌曲进度百分比。 2.项目流程：使用Glade实现了音乐播放器的页面，然后创建无名管...
智能家居实训第六天 音频 视频播放器
零零天
11-09 2426
===============音频================= 一、手机如何播放音乐  1）播放器：   酷狗/QQ音乐/网易云  2）音乐类型： ***.MP3   二、gec6818的开发板怎么播放音乐？   1）播放器：  madplay播放器   2）库：.so        例如：libJPEG.so.9    ***.so  库名   9版本号              ----...
qt嵌入式音乐播放器
07-28
对于嵌入式音乐播放器，你可以使用Qt框架来开发。Qt提供了丰富的功能和工具，可以帮助你轻松开发跨平台的应用程序。 首先，你需要在Qt中创建一个新的项目。你可以选择使用Qt Widgets或Qt Quick来构建界面，具体取决于你的需求和偏好。 然后，你可以使用Qt提供的多媒体模块来处理音乐播放功能。这个模块提供了一些类和函数，可以让你控制音频的播放、暂停、停止等操作。 在界面上，你可以使用Qt的控件来显示音乐列表、播放进度条、音量控制等。你可以使用QListWidget或QListView来展示音乐列表，并通过QMediaPlayer类来实现音乐的播放控制。 另外，如果你需要自定义界面，你可以使用Qt的绘图功能来绘制自己的播放器界面。 总之，使用Qt开发嵌入式音乐播放器是一个相对简单和快速的过程。你可以利用Qt丰富的功能和工具来实现各种音乐播放器的需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值