ALSA的WAV播放和录音程序

最新推荐文章于 2023-03-05 16:24:28 发布
最新推荐文章于 2023-03-05 16:24:28 发布
阅读量2.8k 收藏 4
点赞数 2
分类专栏： linux音频驱动处理

这段时间在探索ALSA架构，从ALSA Core到ALSA Lib，再到Android Audio System。在看ALSA Lib时，写了一个比较典型的基于ALSA的播放录音程序。程序包包含四个部分：WAV Parser、SND Common、Playback和Record。

WAV Parser是对WAV文件的分析和封装，这里只针对Standard WAV File；SND Common是Playback 和Record共同操作，如SetParams、ReadPCM和WritePCM等；Playback和Record就分别是播放录音的主体了。原理很 简单，以Playback为例：从WAV文件读取PCM数据，通过I2S或AC97依次送到Audio Codec。

难点在于对snd_pcm_hw_params_t的设置，尤其要确定每次要送到Audio Codec的数据帧大小(peroid_size)，这个稍后解释。

完整的源代码你可以在这儿下载到：http://bbs.rosoo.net/forum.php?mod=viewthread&tid=6087

1/ 从WAV文件的头信息可以分析出：sample_format、channels number、sample_rate、sample_length，这些参数要通过snd_pcm_hw_params_set_XXX()接口设置到 snd_pcm_hw_params_t中。

2/ 接着我们要设置buffer_time 和peroid_time。通过snd_pcm_hw_params_get_buffer_time_max()接口可以获取该Audio Codec可以支持的最大buffer_time，这里我们设置buffer_time = (MAX_BUFFER_TIME > 500000) ? 500000 : MAX_BUFFER_TIME; peroid_time = buffer_time/4。

【关 于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. 从底层驱动看来，应该是PCM DMA单次传送数据帧的大小。其实真正关注底层驱动的话，它并不是关心peroid_time，它关心的是peroid_size，这两者有转换关系。具 体见struct snd_pcm_hardware结构体。】

3/ 通过snd_pcm_hw_params_get_period_size()取得peroid_size，注意在ALSA中peroid_size是以 frame为单位的。The configured buffer and period sizes are stored in “frames” in the runtime. 1 frame = channels * sample_size. 所以要对peroid_size进行转换：chunk_bytes = peroid_size * sample_length / 8。chunk_bytes就是我们单次从WAV读PCM数据的大小。

之后的过程就乏善可陈了。唯一要留意的是snd_pcm_writei()和snd_pcm_readi()的第三个参数size也是以frame为单位，不要忘记frames和bytes的转换。

wav_parser.h文件：

 
 
  1. //File   : wav_parser.h 
  2. //Author : Loon <sepnic@gmail.com> 
  3.  
  4. #ifndef __WAV_PARSER_H 
  5. #define __WAV_PARSER_H 
  6.  
  7. typedef unsigned char  uint8_t; 
  8. typedef unsigned short uint16_t; 
  9. typedef unsigned int   uint32_t; 
  10.  
  11. #if __BYTE_ORDER == __LITTLE_ENDIAN 
  12. #define COMPOSE_ID(a,b,c,d) ((a) | ((b)<<8) | ((c)<<16) | ((d)<<24)) 
  13. #define LE_SHORT(v)           (v) 
  14. #define LE_INT(v)               (v) 
  15. #define BE_SHORT(v)           bswap_16(v) 
  16. #define BE_INT(v)               bswap_32(v) 
  17. #elif __BYTE_ORDER == __BIG_ENDIAN 
  18. #define COMPOSE_ID(a,b,c,d) ((d) | ((c)<<8) | ((b)<<16) | ((a)<<24)) 
  19. #define LE_SHORT(v)           bswap_16(v) 
  20. #define LE_INT(v)               bswap_32(v) 
  21. #define BE_SHORT(v)           (v) 
  22. #define BE_INT(v)               (v) 
  23. #else 
  24. #error "Wrong endian" 
  25. #endif 
  26.  
  27. #define WAV_RIFF        COMPOSE_ID('R','I','F','F') 
  28. #define WAV_WAVE        COMPOSE_ID('W','A','V','E') 
  29. #define WAV_FMT         COMPOSE_ID('f','m','t',' ') 
  30. #define WAV_DATA        COMPOSE_ID('d','a','t','a') 
  31.  
  32. /* WAVE fmt block constants from Microsoft mmreg.h header */ 
  33. #define WAV_FMT_PCM             0x0001 
  34. #define WAV_FMT_IEEE_FLOAT      0x0003 
  35. #define WAV_FMT_DOLBY_AC3_SPDIF 0x0092 
  36. #define WAV_FMT_EXTENSIBLE      0xfffe 
  37.  
  38. /* Used with WAV_FMT_EXTENSIBLE format */ 
  39. #define WAV_GUID_TAG "/x00/x00/x00/x00/x10/x00/x80/x00/x00/xAA/x00/x38/x9B/x71" 
  40.  
  41. /* it's in chunks like .voc and AMIGA iff, but my source say there 
  42.    are in only in this combination, so I combined them in one header; 
  43.    it works on all WAVE-file I have 
  44.  */ 
  45. typedef struct WAVHeader { 
  46.     uint32_t magic;     /* 'RIFF' */ 
  47.     uint32_t length;        /* filelen */ 
  48.     uint32_t type;      /* 'WAVE' */ 
  49. } WAVHeader_t; 
  50.  
  51. typedef struct WAVFmt { 
  52.     uint32_t magic;  /* 'FMT '*/ 
  53.     uint32_t fmt_size; /* 16 or 18 */ 
  54.     uint16_t format;        /* see WAV_FMT_* */ 
  55.     uint16_t channels; 
  56.     uint32_t sample_rate;   /* frequence of sample */ 
  57.     uint32_t bytes_p_second; 
  58.     uint16_t blocks_align;  /* samplesize; 1 or 2 bytes */ 
  59.     uint16_t sample_length; /* 8, 12 or 16 bit */ 
  60. } WAVFmt_t; 
  61.  
  62. typedef struct WAVFmtExtensible { 
  63.     WAVFmt_t format; 
  64.     uint16_t ext_size; 
  65.     uint16_t bit_p_spl; 
  66.     uint32_t channel_mask; 
  67.     uint16_t guid_format;   /* WAV_FMT_* */ 
  68.     uint8_t guid_tag[14];   /* WAV_GUID_TAG */ 
  69. } WAVFmtExtensible_t; 
  70.  
  71. typedef struct WAVChunkHeader { 
  72.     uint32_t type;      /* 'data' */ 
  73.     uint32_t length;        /* samplecount */ 
  74. } WAVChunkHeader_t; 
  75.  
  76. typedef struct WAVContainer { 
  77.     WAVHeader_t header; 
  78.     WAVFmt_t format; 
  79.     WAVChunkHeader_t chunk; 
  80. } WAVContainer_t; 
  81.  
  82. int WAV_ReadHeader(int fd, WAVContainer_t *container); 
  83.  
  84. int WAV_WriteHeader(int fd, WAVContainer_t *container); 
  85.  
  86. #endif /* #ifndef __WAV_PARSER_H */ 

wav_parser.c

 
 
  1. //File   : wav_parser.c 
  2. //Author : Loon <sepnic@gmail.com> 
  3.  
  4. #include <assert.h> 
  5. #include <stdio.h> 
  6. #include <stdlib.h> 
  7. #include <unistd.h> 
  8. #include <fcntl.h> 
  9.  
  10. #include "wav_parser.h" 
  11.  
  12. #define WAV_PRINT_MSG 
  13.  
  14. char *WAV_P_FmtString(uint16_t fmt) 
  15. { 
  16.     switch (fmt) { 
  17.     case WAV_FMT_PCM: 
  18.         return "PCM"; 
  19.         break; 
  20.     case WAV_FMT_IEEE_FLOAT: 
  21.         return "IEEE FLOAT"; 
  22.         break; 
  23.     case WAV_FMT_DOLBY_AC3_SPDIF: 
  24.         return "DOLBY AC3 SPDIF"; 
  25.         break; 
  26.     case WAV_FMT_EXTENSIBLE: 
  27.         return "EXTENSIBLE"; 
  28.         break; 
  29.     default: 
  30.         break; 
  31.     } 
  32.  
  33.     return "NON Support Fmt"; 
  34. } 
  35.  
  36. void WAV_P_PrintHeader(WAVContainer_t *container) 
  37. { 
  38.     printf("+++++++++++++++++++++++++++/n"); 
  39.     printf("/n"); 
  40.      
  41.     printf("File Magic:         [%c%c%c%c]/n",  
  42.         (char)(container->header.magic),  
  43.         (char)(container->header.magic>>8),  
  44.         (char)(container->header.magic>>16),  
  45.         (char)(container->header.magic>>24)); 
  46. printf("File Length:        [%d]/n", container->header.length); 
  47. printf("File Type:          [%c%c%c%c]/n", 
  48.   (char)(container->header.type),  
  49.   (char)(container->header.type>>8),  
  50.   (char)(container->header.type>>16),  
  51.   (char)(container->header.type>>24));
  52. printf("/n"); 
  53. printf("Fmt Magic:          [%c%c%c%c]/n", 
  54.   (char)(container->format.magic),  
  55.   (char)(container->format.magic>>8),  
  56.   (char)(container->format.magic>>16),  
  57.   (char)(container->format.magic>>24)); 
  58. printf("Fmt Size:           [%d]/n", container->format.fmt_size); 
  59. printf("Fmt Format:         [%s]/n", WAV_P_FmtString(container->format.format)); 
  60. printf("Fmt Channels:       [%d]/n", container->format.channels); 
  61. printf("Fmt Sample_rate:    [%d](HZ)/n", container->format.sample_rate); 
  62. printf("Fmt Bytes_p_second: [%d]/n", container->format.bytes_p_second); 
  63. printf("Fmt Blocks_align:   [%d]/n", container->format.blocks_align); 
  64. printf("Fmt Sample_length:  [%d]/n", container->format.sample_length); 
  65.      
  66.     printf("/n"); 
  67.  
  68.     printf("Chunk Type:         [%c%c%c%c]/n", 
  69.         (char)(container->chunk.type),  
  70.         (char)(container->chunk.type>>8),  
  71.         (char)(container->chunk.type>>16),  
  72.         (char)(container->chunk.type>>24)); 
  73.     printf("Chunk Length: [%d]/n", container->chunk.length); 
  74.      
  75.     printf("/n"); 
  76.     printf("++++++++++++++++++++++++++++++++++++++/n"); 
  77. } 
  78.  
  79. int WAV_P_CheckValid(WAVContainer_t *container) 
  80. { 
  81.     if (container->header.magic != WAV_RIFF || 
  82.         container->header.type != WAV_WAVE || 
  83.         container->format.magic != WAV_FMT || 
  84.         container->format.fmt_size != LE_INT(16) || 
  85. (container->format.channels != LE_SHORT(1) && container->format.channels != LE_SHORT(2))
  86.  || container->chunk.type != WAV_DATA) {
  87.         fprintf(stderr, "non standard wav file./n"); 
  88.         return -1; 
  89.     } 
  90.  
  91.     return 0; 
  92. } 
  93.  
  94. int WAV_ReadHeader(int fd, WAVContainer_t *container) 
  95. { 
  96.     assert((fd >=0) && container); 
  97.  
  98. if (read(fd,&container->header,sizeof(container->header))!=sizeof(container->header)
  99. ||read(fd,&container->format,sizeof(container->format))!=sizeof(container->format)
  100. ||read(fd,&container->chunk,sizeof(container->chunk))!=sizeof(container->chunk)){
  101.  
  102.         fprintf(stderr, "Error WAV_ReadHeader/n"); 
  103.         return -1; 
  104.     } 
  105.  
  106.     if (WAV_P_CheckValid(container) < 0) 
  107.         return -1; 
  108.  
  109. #ifdef WAV_PRINT_MSG 
  110.     WAV_P_PrintHeader(container); 
  111. #endif 
  112.  
  113.     return 0; 
  114. } 
  115.  
  116. int WAV_WriteHeader(int fd, WAVContainer_t *container) 
  117. { 
  118.     assert((fd >=0) && container); 
  119.      
  120.     if (WAV_P_CheckValid(container) < 0) 
  121.         return -1; 
  122.  
  123. if (write(fd,&container->header,sizeof(container->header))!=sizeof(container->header)
  124. ||write(fd,&container->format,sizeof(container->format))!=sizeof(container->format)
  125. ||write(fd,&container->chunk,sizeof(container->chunk))!=sizeof(container->chunk)) { 
  126.         fprintf(stderr, "Error WAV_WriteHeader/n"); 
  127.         return -1; 
  128.     } 
  129.  
  130. #ifdef WAV_PRINT_MSG 
  131.     WAV_P_PrintHeader(container); 
  132. #endif 
  133.  
  134.     return 0; 
  135. } 

sndwav_common.h

 
 
  1. //File   : sndwav_common.h 
  2. //Author : Loon <sepnic@gmail.com> 
  3.  
  4. #ifndef __SNDWAV_COMMON_H 
  5. #define __SNDWAV_COMMON_H 
  6.  
  7. #include <stdio.h> 
  8. #include <stdlib.h> 
  9. #include <unistd.h> 
  10. #include <fcntl.h> 
  11. #include "wav_parser.h" 
  12.  
  13. typedef long long off64_t; 
  14.  
  15. typedef struct SNDPCMContainer { 
  16.     snd_pcm_t *handle; 
  17.     snd_output_t *log; 
  18.     snd_pcm_uframes_t chunk_size; 
  19.     snd_pcm_uframes_t buffer_size; 
  20.     snd_pcm_format_t format; 
  21.     uint16_t channels; 
  22.     size_t chunk_bytes; 
  23.     size_t bits_per_sample; 
  24.     size_t bits_per_frame; 
  25.  
  26.     uint8_t *data_buf; 
  27. } SNDPCMContainer_t; 
  28.  
  29. ssize_t SNDWAV_ReadPcm(SNDPCMContainer_t *sndpcm, size_t rcount); 
  30.  
  31. ssize_t SNDWAV_WritePcm(SNDPCMContainer_t *sndpcm, size_t wcount); 
  32.  
  33. int SNDWAV_SetParams(SNDPCMContainer_t *sndpcm, WAVContainer_t *wav); 
  34. #endif /* #ifndef __SNDWAV_COMMON_H */ 

sndwav_common.c

 
 
  1. //File   : sndwav_common.c 
  2. //Author : Loon <sepnic@gmail.com> 
  3.  
  4. #include <assert.h> 
  5. #include <stdio.h> 
  6. #include <stdlib.h> 
  7. #include <unistd.h> 
  8. #include <fcntl.h> 
  9. #include <alsa/asoundlib.h> 
  10.  
  11. #include "sndwav_common.h" 
  12.  
  13. int SNDWAV_P_GetFormat(WAVContainer_t *wav, snd_pcm_format_t *snd_format) 
  14. {    
  15.     if (LE_SHORT(wav->format.format) != WAV_FMT_PCM) 
  16.         return -1; 
  17.      
  18.     switch (LE_SHORT(wav->format.sample_length)) { 
  19.     case 16: 
  20.         *snd_format = SND_PCM_FORMAT_S16_LE; 
  21.         break; 
  22.     case 8: 
  23.         *snd_format = SND_PCM_FORMAT_U8; 
  24.         break; 
  25.     default: 
  26.         *snd_format = SND_PCM_FORMAT_UNKNOWN; 
  27.         break; 
  28.     } 
  29.  
  30.     return 0; 
  31. } 
  32.  
  33. ssize_t SNDWAV_ReadPcm(SNDPCMContainer_t *sndpcm, size_t rcount) 
  34. { 
  35.     ssize_t r; 
  36.     size_t result = 0; 
  37.     size_t count = rcount; 
  38.     uint8_t *data = sndpcm->data_buf; 
  39.  
  40.     if (count != sndpcm->chunk_size) { 
  41.         count = sndpcm->chunk_size; 
  42.     } 
  43.  
  44.     while (count > 0) { 
  45.         r = snd_pcm_readi(sndpcm->handle, data, count); 
  46.         if (r == -EAGAIN || (r >= 0 && (size_t)r < count)) { 
  47. snd_pcm_wait(sndpcm->handle, 1000); 
  48.         } else if (r == -EPIPE) { 
  49. snd_pcm_prepare(sndpcm->handle); 
  50. fprintf(stderr, "<<<<<<<<<<<<<<< Buffer Underrun >>>>>>>>>>>>>>>/n"); 
  51.         } else if (r == -ESTRPIPE) { 
  52. fprintf(stderr, "<<<<<<<<<<<<<<< Need suspend >>>>>>>>>>>>>>>/n"); 
  53.         } else if (r < 0) { 
  54. fprintf(stderr, "Error snd_pcm_writei: [%s]", snd_strerror(r)); 
  55. exit(-1); 
  56.         } 
  57.          
  58.         if (r > 0) { 
  59.             result += r; 
  60.             count -= r; 
  61.             data += r * sndpcm->bits_per_frame / 8; 
  62.         } 
  63.     } 
  64.     return rcount; 
  65. } 
  66.  
  67. ssize_t SNDWAV_WritePcm(SNDPCMContainer_t *sndpcm, size_t wcount) 
  68. { 
  69.     ssize_t r; 
  70.     ssize_t result = 0; 
  71.     uint8_t *data = sndpcm->data_buf; 
  72.  
  73.     if (wcount < sndpcm->chunk_size) { 
  74.         snd_pcm_format_set_silence(sndpcm->format,  
  75.             data + wcount * sndpcm->bits_per_frame / 8,  
  76.             (sndpcm->chunk_size - wcount) * sndpcm->channels); 
  77.         wcount = sndpcm->chunk_size; 
  78.     } 
  79.     while (wcount > 0) { 
  80.         r = snd_pcm_writei(sndpcm->handle, data, wcount); 
  81.         if (r == -EAGAIN || (r >= 0 && (size_t)r < wcount)) { 
  82. snd_pcm_wait(sndpcm->handle, 1000); 
  83.         } else if (r == -EPIPE) { 
  84. snd_pcm_prepare(sndpcm->handle); 
  85. fprintf(stderr, "<<<<<<<<<<<<<<< Buffer Underrun >>>>>>>>>>>>>>>/n"); 
  86.         } else if (r == -ESTRPIPE) {             
  87. fprintf(stderr, "<<<<<<<<<<<<<<< Need suspend >>>>>>>>>>>>>>>/n");       
  88.         } else if (r < 0) { 
  89. fprintf(stderr, "Error snd_pcm_writei: [%s]", snd_strerror(r)); 
  90. exit(-1); 
  91.         } 
  92.         if (r > 0) { 
  93.             result += r; 
  94.             wcount -= r; 
  95.             data += r * sndpcm->bits_per_frame / 8; 
  96.         } 
  97.     } 
  98.     return result; 
  99. } 
  100.  
  101. int SNDWAV_SetParams(SNDPCMContainer_t *sndpcm, WAVContainer_t *wav) 
  102. { 
  103.     snd_pcm_hw_params_t *hwparams; 
  104.     snd_pcm_format_t format; 
  105.     uint32_t exact_rate; 
  106.     uint32_t buffer_time, period_time; 
  107.  
  108.     /* Allocate the snd_pcm_hw_params_t structure on the stack. */ 
  109.     snd_pcm_hw_params_alloca(&hwparams); 
  110.      
  111.     /* Init hwparams with full configuration space */ 
  112.     if (snd_pcm_hw_params_any(sndpcm->handle, hwparams) < 0) { 
  113.         fprintf(stderr, "Error snd_pcm_hw_params_any/n"); 
  114.         goto ERR_SET_PARAMS; 
  115.     } 
  116.  
  117.     if (snd_pcm_hw_params_set_access(sndpcm->handle, hwparams
  118. , SND_PCM_ACCESS_RW_INTERLEAVED) < 0) { 
  119.         fprintf(stderr, "Error snd_pcm_hw_params_set_access/n"); 
  120.         goto ERR_SET_PARAMS; 
  121.     } 
  122.  
  123.     /* Set sample format */ 
  124.     if (SNDWAV_P_GetFormat(wav, &format) < 0) { 
  125.         fprintf(stderr, "Error get_snd_pcm_format/n"); 
  126.         goto ERR_SET_PARAMS; 
  127.     } 
  128.     if (snd_pcm_hw_params_set_format(sndpcm->handle, hwparams, format) < 0) { 
  129.         fprintf(stderr, "Error snd_pcm_hw_params_set_format/n"); 
  130.         goto ERR_SET_PARAMS; 
  131.     } 
  132.     sndpcm->format = format; 
  133.  
  134.     /* Set number of channels */ 
  135.     if (snd_pcm_hw_params_set_channels(sndpcm->handle, hwparams
  136. , LE_SHORT(wav->format.channels)) < 0) { 
  137.         fprintf(stderr, "Error snd_pcm_hw_params_set_channels/n"); 
  138.         goto ERR_SET_PARAMS; 
  139.     } 
  140.     sndpcm->channels = LE_SHORT(wav->format.channels); 
  141.  
  142.     /* Set sample rate. If the exact rate is not supported */ 
  143.     /* by the hardware, use nearest possible rate.         */  
  144.     exact_rate = LE_INT(wav->format.sample_rate); 
  145. if (snd_pcm_hw_params_set_rate_near(sndpcm->handle, hwparams, &exact_rate, 0) < 0) { 
  146.         fprintf(stderr, "Error snd_pcm_hw_params_set_rate_near/n"); 
  147.         goto ERR_SET_PARAMS; 
  148.     } 
  149.     if (LE_INT(wav->format.sample_rate) != exact_rate) { 
  150.         fprintf(stderr
  151. , "The rate %d Hz is not supported by your hardware./n ==> Using %d Hz instead./n",  
  152.             LE_INT(wav->format.sample_rate), exact_rate); 
  153.     } 
  154.  
  155.     if (snd_pcm_hw_params_get_buffer_time_max(hwparams, &buffer_time, 0) < 0) { 
  156.         fprintf(stderr, "Error snd_pcm_hw_params_get_buffer_time_max/n"); 
  157.         goto ERR_SET_PARAMS; 
  158.     } 
  159.     if (buffer_time > 500000) buffer_time = 500000; 
  160.     period_time = buffer_time / 4; 
  161.  
  162.     if (snd_pcm_hw_params_set_buffer_time_near(sndpcm->handle, hwparams
  163. , &buffer_time, 0) < 0) { 
  164.         fprintf(stderr, "Error snd_pcm_hw_params_set_buffer_time_near/n"); 
  165.         goto ERR_SET_PARAMS; 
  166.     } 
  167.  
  168.     if (snd_pcm_hw_params_set_period_time_near(sndpcm->handle, hwparams
  169. , &period_time, 0) < 0) { 
  170.         fprintf(stderr, "Error snd_pcm_hw_params_set_period_time_near/n"); 
  171.         goto ERR_SET_PARAMS; 
  172.     } 
  173.  
  174.     /* Set hw params */ 
  175.     if (snd_pcm_hw_params(sndpcm->handle, hwparams) < 0) { 
  176.         fprintf(stderr, "Error snd_pcm_hw_params(handle, params)/n"); 
  177.         goto ERR_SET_PARAMS; 
  178.     } 
  179.  
  180.     snd_pcm_hw_params_get_period_size(hwparams, &sndpcm->chunk_size, 0);     
  181.     snd_pcm_hw_params_get_buffer_size(hwparams, &sndpcm->buffer_size); 
  182.     if (sndpcm->chunk_size == sndpcm->buffer_size) {         
  183.         fprintf(stderr, ("Can't use period equal to buffer size (%lu == %lu)/n")
  184. , sndpcm->chunk_size, sndpcm->buffer_size);      
  185.         goto ERR_SET_PARAMS; 
  186.     } 
  187.  
  188.     sndpcm->bits_per_sample = snd_pcm_format_physical_width(format); 
  189.     sndpcm->bits_per_frame = sndpcm->bits_per_sample * LE_SHORT(wav->format.channels); 
  190.      
  191.     sndpcm->chunk_bytes = sndpcm->chunk_size * sndpcm->bits_per_frame / 8; 
  192.  
  193.     /* Allocate audio data buffer */ 
  194.     sndpcm->data_buf = (uint8_t *)malloc(sndpcm->chunk_bytes); 
  195.     if (!sndpcm->data_buf) { 
  196.         fprintf(stderr, "Error malloc: [data_buf]/n"); 
  197.         goto ERR_SET_PARAMS; 
  198.     } 
  199.  
  200.     return 0; 
  201.  
  202. ERR_SET_PARAMS: 
  203.     return -1; 
  204. } 

lplay.c

 
 
  1. //File   : lplay.c 
  2. //Author : Loon <sepnic@gmail.com> 
  3.  
  4. #include <stdio.h> 
  5. #include <malloc.h> 
  6. #include <unistd.h> 
  7. #include <stdlib.h> 
  8. #include <string.h> 
  9. #include <getopt.h> 
  10. #include <fcntl.h> 
  11. #include <ctype.h> 
  12. #include <errno.h> 
  13. #include <limits.h> 
  14. #include <time.h> 
  15. #include <locale.h> 
  16. #include <sys/unistd.h> 
  17. #include <sys/stat.h> 
  18. #include <sys/types.h> 
  19. #include <alsa/asoundlib.h> 
  20. #include <assert.h> 
  21. #include "wav_parser.h" 
  22. #include "sndwav_common.h" 
  23.  
  24. ssize_t SNDWAV_P_SaveRead(int fd, void *buf, size_t count) 
  25. { 
  26.     ssize_t result = 0, res; 
  27.  
  28.     while (count > 0) { 
  29.         if ((res = read(fd, buf, count)) == 0) 
  30.             break; 
  31.         if (res < 0) 
  32.             return result > 0 ? result : res; 
  33.         count -= res; 
  34.         result += res; 
  35.         buf = (char *)buf + res; 
  36.     } 
  37.     return result; 
  38. } 
  39.  
  40. void SNDWAV_Play(SNDPCMContainer_t *sndpcm, WAVContainer_t *wav, int fd) 
  41. { 
  42.     int load, ret; 
  43.     off64_t written = 0; 
  44.     off64_t c; 
  45.     off64_t count = LE_INT(wav->chunk.length); 
  46.  
  47.     load = 0; 
  48.     while (written < count) { 
  49.         /* Must read [chunk_bytes] bytes data enough. */ 
  50.         do { 
  51.             c = count - written; 
  52.             if (c > sndpcm->chunk_bytes) 
  53.                 c = sndpcm->chunk_bytes; 
  54.             c -= load; 
  55.  
  56.             if (c == 0) 
  57.                 break; 
  58.             ret = SNDWAV_P_SaveRead(fd, sndpcm->data_buf + load, c); 
  59.             if (ret < 0) { 
  60.                 fprintf(stderr, "Error safe_read/n"); 
  61.                 exit(-1); 
  62.             } 
  63.             if (ret == 0) 
  64.                 break; 
  65.             load += ret; 
  66.         } while ((size_t)load < sndpcm->chunk_bytes); 
  67.  
  68.         /* Transfer to size frame */ 
  69.         load = load * 8 / sndpcm->bits_per_frame; 
  70.         ret = SNDWAV_WritePcm(sndpcm, load); 
  71.         if (ret != load) 
  72.             break; 
  73.          
  74.         ret = ret * sndpcm->bits_per_frame / 8; 
  75.         written += ret; 
  76.         load = 0; 
  77.     } 
  78. } 
  79.  
  80. int main(int argc, char *argv[]) 
  81. { 
  82.     char *filename; 
  83.     char *devicename = "default"; 
  84.     int fd; 
  85.     WAVContainer_t wav; 
  86.     SNDPCMContainer_t playback; 
  87.      
  88.     if (argc != 2) { 
  89.         fprintf(stderr, "Usage: ./lplay <FILENAME>/n"); 
  90.         return -1; 
  91.     } 
  92.      
  93.     memset(&playback, 0x0, sizeof(playback)); 
  94.  
  95.     filename = argv[1]; 
  96.     fd = open(filename, O_RDONLY); 
  97.     if (fd < 0) { 
  98.         fprintf(stderr, "Error open [%s]/n", filename); 
  99.         return -1; 
  100.     } 
  101.      
  102.     if (WAV_ReadHeader(fd, &wav) < 0) { 
  103.         fprintf(stderr, "Error WAV_Parse [%s]/n", filename); 
  104.         goto Err; 
  105.     } 
  106.  
  107.     if (snd_output_stdio_attach(&playback.log, stderr, 0) < 0) {
  108.         fprintf(stderr, "Error snd_output_stdio_attach/n"); 
  109.         goto Err; 
  110.     } 
  111.  
  112.     if (snd_pcm_open(&playback.handle, devicename, SND_PCM_STREAM_PLAYBACK, 0) < 0) { 
  113.         fprintf(stderr, "Error snd_pcm_open [ %s]/n", devicename); 
  114.         goto Err; 
  115.     } 
  116.  
  117.     if (SNDWAV_SetParams(&playback, &wav) < 0) { 
  118.         fprintf(stderr, "Error set_snd_pcm_params/n"); 
  119.         goto Err; 
  120.     } 
  121.     snd_pcm_dump(playback.handle, playback.log); 
  122.  
  123.     SNDWAV_Play(&playback, &wav, fd); 
  124.  
  125.     snd_pcm_drain(playback.handle); 
  126.  
  127.     close(fd); 
  128.     free(playback.data_buf); 
  129.     snd_output_close(playback.log); 
  130.     snd_pcm_close(playback.handle); 
  131.     return 0; 
  132.  
  133. Err: 
  134.     close(fd); 
  135.     if (playback.data_buf) free(playback.data_buf); 
  136.     if (playback.log) snd_output_close(playback.log); 
  137.     if (playback.handle) snd_pcm_close(playback.handle); 
  138.     return -1; 
  139. } 

lrecord.c

 
 
  1. //File   : lrecord.c 
  2. //Author : Loon <sepnic@gmail.com> 
  3.  
  4. #include <stdio.h> 
  5. #include <malloc.h> 
  6. #include <unistd.h> 
  7. #include <stdlib.h> 
  8. #include <string.h> 
  9. #include <getopt.h> 
  10. #include <fcntl.h> 
  11. #include <ctype.h> 
  12. #include <errno.h> 
  13. #include <limits.h> 
  14. #include <time.h> 
  15. #include <locale.h> 
  16. #include <sys/unistd.h> 
  17. #include <sys/stat.h> 
  18. #include <sys/types.h> 
  19. #include <alsa/asoundlib.h> 
  20. #include <assert.h> 
  21. #include "wav_parser.h" 
  22. #include "sndwav_common.h" 
  23.  
  24. #define DEFAULT_CHANNELS         (2) 
  25. #define DEFAULT_SAMPLE_RATE      (8000) 
  26. #define DEFAULT_SAMPLE_LENGTH    (16) 
  27. #define DEFAULT_DURATION_TIME    (10) 
  28.  
  29. int SNDWAV_PrepareWAVParams(WAVContainer_t *wav) 
  30. { 
  31.     assert(wav); 
  32.  
  33.     uint16_t channels = DEFAULT_CHANNELS; 
  34.     uint16_t sample_rate = DEFAULT_SAMPLE_RATE; 
  35.     uint16_t sample_length = DEFAULT_SAMPLE_LENGTH; 
  36.     uint32_t duration_time = DEFAULT_DURATION_TIME; 
  37.  
  38.     /* Const */ 
  39.     wav->header.magic = WAV_RIFF; 
  40.     wav->header.type = WAV_WAVE; 
  41.     wav->format.magic = WAV_FMT; 
  42.     wav->format.fmt_size = LE_INT(16); 
  43.     wav->format.format = LE_SHORT(WAV_FMT_PCM); 
  44.     wav->chunk.type = WAV_DATA; 
  45.  
  46.     /* User definition */ 
  47.     wav->format.channels = LE_SHORT(channels); 
  48.     wav->format.sample_rate = LE_INT(sample_rate); 
  49.     wav->format.sample_length = LE_SHORT(sample_length); 
  50.  
  51.     /* See format of wav file */ 
  52. wav->format.blocks_align = LE_SHORT(channels * sample_length / 8); 
  53. wav->format.bytes_p_second = LE_INT((uint16_t)(wav->format.blocks_align) * sample_rate); 
  54.      
  55. wav->chunk.length = LE_INT(duration_time * (uint32_t)(wav->format.bytes_p_second)); 
  56. wav->header.length = LE_INT((uint32_t)(wav->chunk.length) +/ 
  57.         sizeof(wav->chunk) + sizeof(wav->format) + sizeof(wav->header) - 8); 
  58.  
  59.     return 0; 
  60. } 
  61.  
  62. void SNDWAV_Record(SNDPCMContainer_t *sndpcm, WAVContainer_t *wav, int fd) 
  63. { 
  64.     off64_t rest; 
  65.     size_t c, frame_size; 
  66.      
  67.     if (WAV_WriteHeader(fd, wav) < 0) { 
  68.         exit(-1); 
  69.     } 
  70.  
  71.     rest = wav->chunk.length; 
  72.     while (rest > 0) { 
  73.         c = (rest <= (off64_t)sndpcm->chunk_bytes) ? (size_t)rest : sndpcm->chunk_bytes; 
  74.         frame_size = c * 8 / sndpcm->bits_per_frame; 
  75.         if (SNDWAV_ReadPcm(sndpcm, frame_size) != frame_size) 
  76.             break; 
  77.          
  78.         if (write(fd, sndpcm->data_buf, c) != c) { 
  79.             fprintf(stderr, "Error SNDWAV_Record[write]/n"); 
  80.             exit(-1); 
  81.         } 
  82.  
  83.         rest -= c; 
  84.     } 
  85. } 
  86.  
  87. int main(int argc, char *argv[]) 
  88. { 
  89.     char *filename; 
  90.     char *devicename = "default"; 
  91.     int fd; 
  92.     WAVContainer_t wav; 
  93.     SNDPCMContainer_t record; 
  94.      
  95.     if (argc != 2) { 
  96.         fprintf(stderr, "Usage: ./lrecord <FILENAME>/n"); 
  97.         return -1; 
  98.     } 
  99.      
  100.     memset(&record, 0x0, sizeof(record)); 
  101.  
  102.     filename = argv[1]; 
  103.     remove(filename); 
  104.     if ((fd = open(filename, O_WRONLY | O_CREAT, 0644)) == -1) { 
  105.         fprintf(stderr, "Error open: [%s]/n", filename); 
  106.         return -1; 
  107.     } 
  108.  
  109.     if (snd_output_stdio_attach(&record.log, stderr, 0) < 0) { 
  110.         fprintf(stderr, "Error snd_output_stdio_attach/n"); 
  111.         goto Err; 
  112.     } 
  113.  
  114.     if (snd_pcm_open(&record.handle, devicename, SND_PCM_STREAM_CAPTURE, 0) < 0) { 
  115.         fprintf(stderr, "Error snd_pcm_open [ %s]/n", devicename); 
  116.         goto Err; 
  117.     } 
  118.  
  119.     if (SNDWAV_PrepareWAVParams(&wav) < 0) { 
  120.         fprintf(stderr, "Error SNDWAV_PrepareWAVParams/n"); 
  121.         goto Err; 
  122.     } 
  123.  
  124.     if (SNDWAV_SetParams(&record, &wav) < 0) { 
  125.         fprintf(stderr, "Error set_snd_pcm_params/n"); 
  126.         goto Err; 
  127.     } 
  128.     snd_pcm_dump(record.handle, record.log); 
  129.  
  130.     SNDWAV_Record(&record, &wav, fd); 
  131.  
  132.     snd_pcm_drain(record.handle); 
  133.  
  134.     close(fd); 
  135.     free(record.data_buf); 
  136.     snd_output_close(record.log); 
  137.     snd_pcm_close(record.handle); 
  138.     return 0; 
  139.  
  140. Err: 
  141.     close(fd); 
  142.     remove(filename); 
  143.     if (record.data_buf) free(record.data_buf); 
  144.     if (record.log) snd_output_close(record.log); 
  145.     if (record.handle) snd_pcm_close(record.handle); 
  146.     return -1; 
  147. } 

 




makefile



CC =/home/yuanpengjun/ngi/prebuilt/toolchains/arm-fsl-linux-gnueabi/4.6.2/bin/arm-fsl-linux-gnueabi-gcc
CFLAGS = -g -Wall -O0 -I/home/yuanpengjun/ngi/externals/alsa-lib/include
LIBS = -L/home/yuanpengjun/ngi/out/target/product/rome/system/usr/lib -lasound


lplay: lplay.o sndwav_common.o wav_parser.o
 $(CC) $(CFLAGS) lplay.o sndwav_common.o wav_parser.o -o lplay $(LIBS)
lplay.o: lplay.c  sndwav_common.h wav_parser.h
$(CC) $(CFLAGS) -c lplay.c  


lrecord: lrecord.o sndwav_common.o wav_parser.o
 $(CC) $(CFLAGS) lrecord.o sndwav_common.o wav_parser.o -o lrecord $(LIBS)
lrecord.o: lrecord.c sndwav_common.h  wav_parser.h
$(CC) $(CFLAGS) -c lrecord.c 


sndwav_common.o: sndwav_common.c sndwav_common.h
$(CC) $(CFLAGS) -c sndwav_common.c 


wav_parser.o: wav_parser.c wav_parser.h
$(CC) $(CFLAGS) -c wav_parser.c


clean:
rm lplay lrecord *.o

jack_a8
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
alsa 实现wav播放
03-04
alsa 实现wav播放 详细介绍：https://blog.csdn.net/ckg3824278/article/details/135344132?csdn_share_tail=%7B%22type%22%3A%22blog%22%2C%22rType%22%3A%22article%22%2C%22rId%22%3A%22135344132%22%2C%22source%22%3A%22ckg3824278%22%7D
alsa录音程序
03-10
linux下基于alsa编程的录音demo
基于ALSA的WAV播放和录音程序
sunshine
02-05 989
在看ALSA Lib时，写了一个比较典型的基于ALSA的播放录音程序。程序包包含四个部分：WAV Parser、SND Common、Playback和Record。WAV Parser是对WAV文件的分析和封装，这里只针对Standard WAV File；SND Common是Playback 和Record共同操作，如SetParams、ReadPCM和Write 这段
alsa录制pcm音频及fdk-aac编码
fangye945a的博客
08-31 1633
1. 利用alsa库录制PCM音频，并保存为音频文件。 /** * @file record_pcm.c * @brief 进行音频采集，采集pcm数据并直接保存pcm数据到文件 * 音频参数： * 声道数： 2 * 采样位数： 16bit、LE格式 * 采样频率： 44100Hz * @author fangye ([email protected]) * @version 1.0 * @date 2021-01-20 * @copyright Copyright (c) 20
alsa录音demo
李江龙的博客
05-10 3752
git stash 使用/* read from the default PCM device and writes to standard output for 5 seconds of data 修改声音采集配置时候，出了修改声音通道数量，还应该考虑申请的缓冲区时候足够大 */ #define ALSA_PCM_NEW_HW_PARAMS_API #include &lt;alsa/as...
六、ALSA lib库接口
future_sky_word的博客
03-05 2652
使用 ALSA 的 lib 库中的 snd_pcm_xxx 等标准接口函数，操作 /dev/snd/pcmC0D0c或pcmC0D0p 等录放音设备节点，相当于在 OSS 框架下通过 ioctl 设置不同参数去操作 /dev/dsp 设备ALSA功能丰富，可以设置音频参数，DMA buffer 大小、分块数量，buffer 阀值等。
ALSA  lib接口调用简介
佛系程序员
05-26 4750
ALSA lib接口调用简介 ALSA逻辑，在我当前看来，总共有两条线：1、录放音流控，2、amixer cset控件。 录放音流控（自定义名称），相当于操作OSS的/dev/dsp设备，可以设置三大参数等，并且启动录放音。这里，aplay，mplayer等播放器，调用ALSA lib中的sn...
alsa-lib应用层接口分析
sinat_37817094的博客
06-26 9244
ALSA lib接口调用简介 ALSA逻辑，在我当前看来，总共有两条线：1、录放音流控，2、amixer cset控件。 录放音流控（自定义名称），相当于操作OSS的/dev/dsp设备，可以设置三大参数等，并且启动录放音。这里，aplay，mplayer等播放器，调用ALSA lib中的snd_pcm_***等，标准接口函数，再通过该函数，操作/...
Alsa-lib实现播放wav音频
南大侠的博客
06-09 837
alsa lib应用
alsa本地录音并播放程序
01-02
解压后，make生成可执行文件，执行即可，需要提前安装alsa的库文件
alsa 录音程序
06-13
alsa 录音 可用
ALSA.rar_alsa_alsa 播放_linux alsa 录音
09-22
LINUX下的，基于ALSA的录音及放音程序源代码，可录为WAV格式并播放
linux下alsa架构采集声音成wav格式播放（添加）
08-12
linux下C语言的程序，可以实现ALSA架构的声音采集，并且生成wav格式的音频文件，实现播放的功能。
通信原理期末考试试题及答案2份.doc
04-18
通信原理期末考试试题及答案2份.doc
Skeleton-Low Poly 低多边形骨架模型Unity插件美术资源包unitypackage
04-18
Skeleton-Low Poly 低多边形骨架模型Unity插件美术资源包unitypackage 支持Unity版本2019.4.29或更高 直接的低多边形骨架。 特点： - 低多边形（9k tris，8.5） - 适用于 Unity 5 及更高 版本 - 完全装配 - 包括一个 fbx 格式的模型 - PBR 纹理 - 高清纹理
基于ssm+vue学生学籍管理系统源码数据库文档.zip
04-18
基于ssm+vue学生学籍管理系统源码数据库文档.zip
工作汇报 年终总结45.pptx
最新发布
04-18
引言 年度工作回顾 系统进展与亮点 技术创新与应用 市场反馈与用户评价 存在问题与挑战 未来展望与计划 结束语与感谢 一、引言 简要介绍智能家居系统的重要性和发展趋势 回顾本年度的工作目标和重点 二、年度工作回顾 系统建设与维护 完成的项目与里程碑 系统稳定性与可靠性提升 团队建设与培训 团队成员构成与职责 培训与技能提升活动 合作伙伴与资源整合 与供应商、合作伙伴的合作情况 资源整合与利用 三、系统进展与亮点 功能扩展与优化 新增功能介绍与效果评估 现有功能的优化与改进 用户体验提升 界面设计与交互优化 用户反馈与改进措施 四、技术创新与应用 物联网技术的应用 传感器与通信技术的升级 大数据分析与应用 智能家居的智能化管理 自动化控制与节能策略 安全防护与预警系统 五、市场反馈与用户评价 市场反馈分析 市场需求与竞争态势 市场占有率与增长趋势 用户评价总结 用户满意度调查结果
2024年带式输送机市场分析报告.pptx
04-18
行业分析报告
linux alsa 录音wav
07-30
Linux ALSA 是一种用于音频录制和播放的音频接口和驱动程序。要在Linux中使用ALSA录制音频为.wav文件格式，需要按照以下步骤进行操作： 1. 首先，确保已经安装并配置了ALSA驱动程序。可以使用以下命令来检查是否...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值