嵌入式MP3应用程序

1. /*
   
2. *     mp3播放器控制程序
   
3. *           功能：
   
4. *                 k1:播放、暂停
   
5. *                 k2:停止播放
   
6. *                 k3:上一首
   
7. *                 k4:下一首
   
8. *     附加：歌曲自动循环播放
   
9. */
   
10. #include <stdio.h>
    
11. #include <stdlib.h>
    
12. #include <unistd.h>
    
13. #include <sys/ioctl.h>
    
14. #include <sys/types.h>
    
15. #include <sys/stat.h>
    
16. #include <fcntl.h>
    
17. #include <signal.h>
    
18. #include <sys/select.h>
    
19. #include <sys/time.h>
    
20. #include <errno.h>
    
21. #include <sys/wait.h>
    
22. #include <string.h>
    
23. #include <sys/ipc.h>
    
24. #include <sys/shm.h>
    
25. 
    
26. /*共享内存申请标记*/
    
27. #define PERM S_IRUSR|S_IWUSR         //定义模式为可读可写                                                                                               
    
28. 
    
29. /*双向循环列表：存放歌曲名*/
    
30. struct song                               
    
31. {
    
32.         char songname[20];  //歌名
    
33.         struct song *prev;   //
    
34.         struct song *next;
    
35. };
    
36. 
    
37. /*孙子进程id号*/
    
38. pid_t gradchild;
    
39. 
    
40. /*子进程id号*/
    
41. pid_t pid;
    
42. 
    
43. /*共享内存描述标记*/
    
44. int shmid;
    
45. 
    
46. char *p_addr;
    
47. 
    
48. /*播放标记*/
    
49. int first_key=1;
    
50. int play_flag=0;
    
51. 
    
52. /*************************************************
    
53. Function name: play
    
54. Parameter    : struct song *
    
55. Description         : 播放函数
    
56. Return                 : void
    
57. Argument     : void
    
58. Autor & date : ada 09,12,07
    
59. **************************************************/
    
60. void play(struct song *currentsong)
    
61. {
    
62.         pid_t fd;
    
63.         char *c_addr;
    
64.         char *p;
    
65.         int len;
    
66.         char my_song[30]="/mp3/song/";   //存放歌曲的路径
    
67.         while(currentsong)
    
68.         {
    
69.                 /*创建子进程，即孙子进程*/
    
70.                 fd = fork();
    
71.                 if(fd == -1)  //先判断是否创建成功
    
72.                 {       
    
73.                         perror("fork");
    
74.                         exit(1);
    
75.                 }
    
76.                 else if(fd == 0)  
    
77.                 {
    
78.                         /*把歌曲名加上根路径*/
    
79.                         strcat(my_song,currentsong->songname);
    
80.                         p = my_song;
    
81.                         len = strlen(p);
    
82. 
    
83.                         /*去掉文件名最后的'\n'*/
    
84.                         my_song[len-1]='\0';
    
85. 
    
86.                         printf("THIS SONG IS %s\n",my_song);
    
87.                         execl("/usr/bin/madplay","madplay",my_song,NULL);  //孙子进程调用execl函数，执行madplay程序
    
88.                         printf("\n\n\n");
    
89.                 }
    
90.                 else
    
91.                 {
    
92.                         /*内存映射*/
    
93.                         c_addr = shmat(shmid,0,0);
    
94. 
    
95.                         /*把孙子进程的id和当前播放歌曲的节点指针传入共享内存*/
    
96.                         memcpy(c_addr,&fd,sizeof(pid_t));
    
97.                         memcpy(c_addr + sizeof(pid_t)+1,¤tsong,4);
    
98.                         /*使用wait阻塞孙子进程，直到孙子进程播放完才能被唤醒；
    
99.                           当被唤醒时，表示播放MP3期间没有按键按下，则继续顺序播放下一首MP3*/
    
100.                         if(fd == wait(NULL))  //等待进程结束
     
101.                         {
     
102.                                 currentsong = currentsong->next;  //歌曲链表移向下一首歌
     
103.                                 printf("THE NEXT SONG IS %s\n",currentsong->songname);
     
104.                         }
     
105.                 }
     
106.         }
     
107. }
     
108. 
     
109. /*************************************************
     
110. Function name: creat_song_list
     
111. Parameter    : void
     
112. Description         : 创建歌曲名的双向循环链表
     
113. Return                 : struct song *
     
114. Argument     : void
     
115. Autor & date : ada 09.12.07
     
116. **************************************************/
     
117. struct song *creat_song_list(void)
     
118. {       
     
119.         FILE *fd;
     
120.         size_t size;
     
121.         size_t len=0;
     
122.         char *line = NULL;
     
123.         struct song *head;
     
124.         struct song *p1;
     
125.         struct song *p2;
     
126.         system("ls /mp3/song >song_list");   //重定向生成song_list文件
     
127.         fd = fopen("song_list","r");  //打开 song_list文件
     
128. 
     
129.         p1 = (struct song *)malloc(sizeof(struct song));
     
130. 
     
131.         printf("==================================song list=====================================\n");
     
132.         system("ls /mp3/song");        //打印所有歌曲名
     
133.         printf("\n");
     
134.         printf("================================================================================\n");
     
135.         size = getline(&line,&len,fd);//读取一首歌曲名，返回size为歌名字符串的长度 ,size大小由系统malloc
     
136. 
     
137.         strncpy(p1->songname,line,strlen(line));//将第一首歌名存入第一个节点
     
138.         head = p1;
     
139.         while((size = getline(&line,&len,fd)) ！= -1)//继续看是否有其他歌曲
     
140.         {       
     
141.                 p2 = p1;   
     
142.                 p1 = (struct song *)malloc(sizeof(struct song));  //创建节点空间
     
143.                 strncpy(p1->songname,line,strlen(line));  //读取歌曲名
     
144.                
     
145.                 p2->next = p1;  //前一个节点的next指向下一节点
     
146.                 p1->prev = p2;        //后一个节点的prev指向上一个节点
     
147.         }
     
148.        
     
149.         p1->next = head; //尾节点的next指向头节点
     
150.         head->prev = p1;  //头节点的prev指向尾节点
     
151.        
     
152.         //链表创建完成，让p1，p2为空指针
     
153.         p1 = NULL;
     
154.         p2 = NULL;
     
155.        
     
156.         system("rm -rf song_list");//把之前重定向生成的文件删除
     
157.        
     
158.         return head;//返回双向循环链表的头节点的指针
     
159. }
     
160. /*************************************************
     
161. Function name: startplay
     
162. Parameter    : pid_t *，struct song *
     
163. Description         : 开始播放函数
     
164. Return                 : void
     
165. Argument     : void
     
166. Autor & date : ada 09.12.07
     
167. **************************************************/
     
168. void startplay(pid_t *childpid,struct song *my_song)
     
169. {
     
170.         pid_t pid;
     
171.         int ret;
     
172.         /*创建子进程*/
     
173.         pid = fork();
     
174. 
     
175.         if(pid > 0)
     
176.         {
     
177.                 *childpid = pid;
     
178.                 play_flag = 1;
     
179.                 sleep(1);  //等待一秒，让孙子进程创建和保存
     
180.                 /*把孙子进程的pid传给父进程*/
     
181.                 memcpy(&gradchild,p_addr,sizeof(pid_t));  //因为使用共享内存，p_addr就是play(my_song)函数中的c_addr
     
182.         }
     
183.         else if(0 == pid)
     
184.         {       
     
185.                 /*子进程播放MP3函数*/
     
186.                 play(my_song);
     
187.         }
     
188. }
     
189. /*************************************************
     
190. Function name: my_pause
     
191. Parameter    : pid_t
     
192. Description         : 暂停函数
     
193. Return                 : void
     
194. Argument     : void
     
195. Autor & date : ada 09,12,07
     
196. **************************************************/
     
197. void my_pause(pid_t pid)
     
198. {
     
199.         printf("=======================PAUSE！PRESS K1 TO CONTINUE===================\n");
     
200.         kill(pid,SIGSTOP); //对孙子进程发送SKGSTOP信号
     
201.         play_flag = 0;
     
202. }
     
203. 
     
204. /*************************************************
     
205. Function name: my_pause
     
206. Parameter    : pid_t
     
207. Description         : 停止播放函数
     
208. Return                 : void
     
209. Argument     : void
     
210. Autor & date : ada 09,12,07
     
211. **************************************************/
     
212. void my_stop(pid_t g_pid)
     
213. {
     
214. 
     
215.         printf("=======================STOP！PRESS K1 TO START PLAY===================\n");
     
216.         kill(g_pid,SIGKILL); //对孙子进程发送SKGKILL信号
     
217.         kill(pid,SIGKILL);   //对子进程发送SKGKILL信号
     
218.         first_key=1;
     
219. 
     
220. }
     
221. 
     
222. /*************************************************
     
223. Function name: conti_play
     
224. Parameter    : pid_t
     
225. Description         : 继续函数
     
226. Return                 : void
     
227. Argument     : void
     
228. Autor & date : ada 09,12,07
     
229. **************************************************/
     
230. void conti_play(pid_t pid)
     
231. {
     
232.         printf("===============================CONTINUE=============================\n");
     
233.         kill(pid,SIGCONT); //对孙子进程发送SIGCONT信号
     
234.         play_flag=1;
     
235. }
     
236. 
     
237. /*************************************************
     
238. Function name: next
     
239. Parameter    : pid_t
     
240. Description         : 下一首函数
     
241. Return                 : void
     
242. Argument     : void
     
243. Autor & date : ada 09.12.07
     
244. **************************************************/
     
245. void next(pid_t next_pid)
     
246. {
     
247.         struct song *nextsong;
     
248. 
     
249.         printf("===============================NEXT MP3=============================\n");
     
250.         /*从共享内存获得孙子进程播放歌曲的节点指针*/
     
251.         memcpy(&nextsong,p_addr + sizeof(pid_t)+1,4);
     
252.         /*指向下首歌曲的节点*/
     
253.         nextsong = nextsong->next;
     
254.         /*杀死当前歌曲播放的子进程，孙子进程*/
     
255.         kill(pid,SIGKILL);
     
256.         kill(next_pid,SIGKILL);
     
257.         wait(NULL);
     
258.         startplay(&pid,nextsong);
     
259. }
     
260. 
     
261. /*************************************************
     
262. Function name: prev
     
263. Parameter    : pid_t
     
264. Description         : 上一首函数
     
265. Return                 : void
     
266. Argument     : void
     
267. Autor & date : yuanhui 09.12.08
     
268. **************************************************/
     
269. void prev(pid_t prev_pid)
     
270. {
     
271.         struct song *prevsong;
     
272.         /*从共享内存获得孙子进程播放歌曲的节点指针*/
     
273.         printf("===============================PRIOR MP3=============================\n");
     
274.         memcpy(&prevsong,p_addr + sizeof(pid_t)+1,4);
     
275.         /*指向上首歌曲的节点*/
     
276.         prevsong = prevsong->prev;
     
277.         /*杀死当前歌曲播放的子进程，孙子进程*/
     
278.         kill(pid,SIGKILL);
     
279.         kill(prev_pid,SIGKILL);
     
280.         wait(NULL);
     
281.         startplay(&pid,prevsong);
     
282. }
     
283. 
     
284. /*************************************************
     
285. Function name: main
     
286. Parameter    : void
     
287. Description         : 主函数
     
288. Return                 : int
     
289. Argument     : void
     
290. Autor & date : ada 09.12.07
     
291. **************************************************/
     
292. int main(void)
     
293. {
     
294.        
     
295.      int buttons_fd;//按键设备的文件标识符
     
296.      
     
297.         char buttons[6] = {'0', '0', '0', '0', '0', '0'};  //初始化六个按键，未按下为'0'
     
298.        
     
299.    /*打开设备文件*/
     
300.         buttons_fd = open("/dev/buttons", 0);  
     
301.         if (buttons_fd < 0) {   //判断打开按键设备是否成功
     
302.                 perror("open device buttons");
     
303.                 exit(1);
     
304.         }
     
305.         struct song *head;  //定义歌曲链表头节点
     
306. 
     
307.   /*创建播放列表*/
     
308.         head = creat_song_list();
     
309.         printf("===================================OPTION=======================================\n\n\n\n");
     
310.         printf("        K1:START/PAUSE     K2:STOP   K3:NEXT      K4:PRIOR\n\n\n\n");
     
311.         printf("================================================================================\n");
     
312. 
     
313. 
     
314.   /*共享内存：用于存放子进程ID，播放列表位置*/
     
315.         if((shmid = shmget(IPC_PRIVATE,5,PERM))== -1)//从内存中获取大小5个字节的共享内存，并判断获取是否成功
     
316.                 exit(1);
     
317.         p_addr = shmat(shmid,0,0);//映射共享内存的地址到p_addr
     
318.         memset(p_addr,'\0',1024);  //把该内存的值全部初始化为'\0'
     
319. 
     
320.    for (;;) {
     
321.                 char current_buttons[6];  //定义当前按键的值
     
322.                 int keys_id;
     
323.                 if (read(buttons_fd, current_buttons, sizeof current_buttons) ！= sizeof current_buttons) {
     
324.                         perror("read buttons:");
     
325.                         exit(1);
     
326.                 }
     
327. 
     
328.                 for (keys_id = 0; keys_id < sizeof buttons / sizeof buttons[0]; keys_id++) {
     
329.                         if (buttons[keys_id] ！= current_buttons[keys_id])  //表示有按键按下
     
330.                                  {
     
331.                                
     
332.                                 /*首次播放，必须是按键1*/
     
333.                                 if(first_key){
     
334.                                         switch(keys_id)
     
335.                                         {       
     
336.                                         case 0:
     
337.                                                 startplay(&pid,head);  //开始播放音乐
     
338.                                                 first_key=0;   //按键1已经按下了
     
339.                                                 break;
     
340.                                         case 1:
     
341.                                         case 2:
     
342.                                         case 3:
     
343.                                                 printf("=======================PRESS K1 TO START PLAY===================\n");
     
344.                                                 break;
     
345.                                     default:
     
346.                                                 printf("=======================PRESS K1 TO START PLAY===================\n");
     
347.                                                 break;
     
348.                                         }
     
349.                                 }
     
350.                                 /*若不是首次播放，则根据不同键值处理*/
     
351.                                 else if(！first_key){
     
352.                                     switch(keys_id)
     
353.                                         {
     
354.                                         case 0:      //按键1还可以控制歌曲暂停和播放
     
355.                                                 if(play_flag)
     
356.                                                         my_pause(gradchild);  //暂停
     
357.                                                 else
     
358.                                                         conti_play(gradchild);//继续播放
     
359.                                                 break;
     
360.                                         case 1:
     
361.                                                 my_stop(gradchild);  //关闭当前播放的歌曲
     
362.                                                 break;
     
363.                                         case 2:
     
364.                                                 next(gradchild);  //播放下一首
     
365.                                                 break;
     
366.                                         case 3:
     
367.                                                 prev(gradchild);  //播放上一首
     
368.                                                 break;
     
369.                                         }
     
370.                          }
     
371.                                
     
372.                         }
     
373.                 }
     
374.        
     
375.                
     
376.                
     
377.         }
     
378. 
     
379.         close(buttons_fd);  //关闭按键设备文件
     
380.         return 0;
     
381. }
     

..看了小编的这篇我文章，我再也不害怕指针了  

为什么看了这个代码就不害怕指针呢?