基于ALSA的WAV播放和录音程序

最新推荐文章于 2024-09-09 00:30:48 发布
最新推荐文章于 2024-09-09 00:30:48 发布
阅读量7.7k 收藏 6
点赞数
分类专栏： linux C编程
在看ALSA Lib时，写了一个比较典型的基于ALSA的播放录音程序。程序包包含四个部分：WAV Parser、SND Common、Playback和Record。WAV Parser是对WAV文件的分析和封装，这里只针对Standard WAV File；SND Common是Playback 和Record共同操作，如SetParams、ReadPCM和Write
TAG:  录音   ALSA  
 

这段时间在探索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

RopenYuan
关注
专栏目录
jetson nano (ubutu18.04)基于alsa的录音播放python程序
网络架构
12-22 2192
取消声卡独占或者卸载pulseaudio（占用问题） 播放音频 录制音频 边录制边播放 python管道处理arecord 数据可代替pyaudio(无需多余的包，无需修改配置) [pyaudio 声音处理](https://blog.csdn.net/qq_26696715/article/details/121856007) 声音强度检查 录音_播放_写到文件 自动断句录音播放
基于Alsa的语音录放程序
06-07
基于linux系统下的alsa音频架构，实现语音的录制生成.wav文件，并播放录制内容的功能。
嵌入式linux下基于ALSA架构的语音录制和播放
01-12
本资源是基于嵌入式硬件Devkit8600和嵌入式linux系统软件的QT开发环境下编写的基于ALSA架构的语音录制和播放的源代码，源代码编译时需要asoundlib库，网络上有下载。本资源可适用于基于ALSA架构的嵌入式linux语音开发任务。
Linux 下 alsa 库录音并保存为 WAV 格式
最新发布
大道之行，始于足下
09-09 455
alsa 库录音并保存为 WAV 格式
Linux 音频编程 -- 如何使用ALSE库播放wav文件
my_angle2016的博客
04-21 521
/** *test.c * *注意：这个例子在Ubuntu 12.04.1环境下编译运行成功。 * */ #include <stdio.h> #include <stdlib.h> #include <alsa/asoundlib.h> int main(int argc, char *argv[]) { int i; int ret; int buf[128]; unsigned int val; int dir=0; .
ALSA WAV播放与录音程序源码解析及使用指南
本资源包提供了基于ALSA的WAV文件播放和录音程序的完整源码，涉及了音频处理的基本知识和应用。程序包主要由四个部分组成：WAV Parser、SND Common、Playback和Record。 1. WAV Parser WAV Parser部分负责对WAV格式...
基于alsa实现音频录制 音频播放
06-20
本文将深入探讨如何使用C语言来实现基于ALSA的音频录制和播放功能，结合提供的`recording.c`和`playback.c`源代码文件。 **ALSA基本概念** 1. **PCM（Pulse Code Modulation）**: 是ALSA处理音频数据的主要方式，它...
linux系统下基于alsa驱动声卡设备的录音播音程序
11-05
linux系统下基于alsa驱动声卡设备的录音播音程序，播音程序仅能播放WAV格式文件，录音程序本人没试过，播音程序好使！该程序转载至https://blog.csdn.net/azloong/article/details/6140824，这里仅做整理。
alsa录音程序
08-13
linux下用alsa声卡进行录音的程序，使用者可以根据自己需求修改参数以获得相应的效果。
alsa本地录音并播放程序
01-02
解压后，make生成可执行文件，执行即可，需要提前安装alsa的库文件
alsa 录音 linux 精华代码
11-10
alsa 录音程序代码 可实现实时录音调用。
Alsa-lib实现播放wav音频
南大侠的博客
06-09 1029
alsa lib应用
alsa 应用层 demo---播放wav文件
weixin_43835377的博客
03-29 966
测试环境 ubuntu14.04 64bit 安装库 $ sudo apt-get install libasound2-dev 编译命令 $ gcc alsaDemo.c -lasound 测试命令 $ ./a.out 1.wav #include <stdio.h> #include <stdlib.h> #include <string.h> #inclu...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值