Linux声卡录音程序之——mp3(通过ALSA操作声卡)

本文转载自博客：http://blog.sina.com.cn/s/blog_936739790101b4og.html

————————————————--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

此程序通过ALSA打开声卡设备，和从声卡读取数据，避免直接操作声卡。由于不同主机，不同声卡的名字可能不一样，直接通过设备名操作声卡有局限性，故改进成通过ALSA操作。



#include "lame.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
//#include <signal.h>
//#include <sys/ioctl.h>
#include <memory.h>
//#include <linux/soundcard.h>
#include <alsa/asoundlib.h>
#include <sys/time.h>

#define TIMES 

    10    //录音时间,秒
#define RATE      41000 //采样频率
#define BITS      16    //量化位数
#define CHANNELS 2    //声道数目
#define INBUFF_SIZE 4096
#define MP3BUFF_SIZE (int) (1.25 * INBUFF_SIZE) + 7200

// handle the case of underrun or overrun
int xrun(snd_pcm_t* handle);
// handle the case that device busy
int suspend(snd_pcm_t* handle);
// set alsa params
int SetFormat(snd_pcm_t* handle, unsigned int channels, unsignedint rate)
{
      int ret =0;
     
      ret =snd_pcm_set_params(handle, SND_PCM_FORMAT_S16_LE,SND_PCM_ACCESS_RW_INTERLEAVED, channels, rate, 1, 500000);
      if (ret !=0) {
            printf("Unable to set params,error(%s)\n",snd_strerror(ret));
      }

      returnret;
}

int main(int argc, char **argv)
{
      intfd_dsp;
      FILE*fd_tmp;
      FILE*fd_mp3;
      lame_global_flags* gfp;
      short*input_buff;
      unsignedchar *mp3_buff;

      intsamples;
      intmp3_bytes;
      intwrite_bytes;
      int num =0;
      intch;
      int i =0;
      int ret =0;
      snd_pcm_t*handle;

      if (argc !=2) {
              fprintf(stderr, "Useage: ./mp3_record test.mp3\n");
              return -1;
      }

      if(snd_pcm_open(&handle, "default",SND_PCM_STREAM_CAPTURE, 0) != 0) {
              printf("Failed to open device\n");
              return -1;
      }
      if(SetFormat(handle, CHANNELS, RATE) != 0) {
              printf("Cannot set sound device in bit 16, channel 2, speed44100.\n");
              return -1;
      }

      if ((fd_mp3= fopen(argv[1], "w")) == NULL) {
              fprintf(stderr, "Open file error: %s\n", strerror(errno));
              ret = -1;
              goto CLOSE_DSP;
      }
      gfp =lame_init();
      if (gfp ==NULL) {
              printf("lame_init failed\n");
              ret = -1;
              goto CLOSE_MP3;
      }

      lame_set_in_samplerate(gfp, RATE);
      //lame_set_out_samplerate(gfp, RATE);
      lame_set_num_channels(gfp, CHANNELS);
      //lame_set_brate(gfp, 24);
      //lame_set_VBR_min_bitrate_kbps(gfp, lame_get_brate(gfp));
      //lame_set_quality(gfp,7);
      ret =lame_init_params(gfp);
      if (ret< 0) {
              printf("lame_init_params returned %d\n", ret);
              ret = -1;
              goto CLOSE_LAME;
      }
      ch =lame_get_num_channels(gfp);
      printf("default rate is %d, out rate is %d.\n",lame_get_in_samplerate(gfp), lame_get_out_samplerate(gfp));
      printf("default brate is %d.\n", lame_get_brate(gfp));
      printf("default samples is %lu.\n",lame_get_num_samples(gfp));
      printf("default channel is %d.\n", ch);
      printf("default vbr_mode is %d.\n", lame_get_VBR(gfp));
      printf("default force_ms is %d.\n", lame_get_force_ms(gfp));
      printf("default mode is %d.\n", lame_get_mode(gfp));
      printf("default compression_ratio is %f.\n",lame_get_compression_ratio(gfp));
      printf("default VBR_mean_bitrate is %d.\n",lame_get_VBR_mean_bitrate_kbps(gfp));
      printf("default quality is %d.\n", lame_get_quality(gfp));
     

      input_buff =(short *) malloc(INBUFF_SIZE * CHANNELS);
      mp3_buff =(unsigned char *) malloc(MP3BUFF_SIZE);
      if(input_buff == NULL || mp3_buff == NULL) {
              printf("Failed to malloc.\n");
              goto FREE_BUF;
      }

      if((TIMES*RATE*BITS*CHANNELS/8)%(INBUFF_SIZE * CHANNELS) != 0)
              num = (TIMES*RATE*BITS*CHANNELS/8)/(INBUFF_SIZE * CHANNELS) +1;
      else
              num = (TIMES*RATE*BITS*CHANNELS/8)/(INBUFF_SIZE * CHANNELS);
      for(i = 0; i< num; i++) {
              memset(input_buff, 0, INBUFF_SIZE * CHANNELS);
              memset(mp3_buff, 0, MP3BUFF_SIZE);
#if 0
              samples = read(fd_dsp, input_buff, INBUFF_SIZE * 2);
              if (samples < 0) {
                      perror("Read sound device failed");
                      ret = -1;
                      goto FREE_BUF;
              }
                      printf("samples is %d.\n", samples);
#endif


      samples =ret = snd_pcm_readi(handle, input_buff, INBUFF_SIZE/2);
      if (ret ==-EAGAIN || (ret >= 0&& (size_t)ret <INBUFF_SIZE/2)) {
            snd_pcm_wait(handle, 1000);
              goto FREE_BUF;
      } else if(ret == -EBADFD){      // PCM isnot in the right state
            printf("PCMis not in the right state!\n "); // EPIPE means underrun
              goto FREE_BUF;
      }
      else if(ret== -EPIPE){              // an overrun occurred
            printf("anoverrun occurred. samples = %d\n", samples);
            if(xrun(handle) < 0) {
                      goto FREE_BUF;
            }

      } elseif(ret == -ESTRPIPE) {    // asuspend event occurred
            printf("asuspend event occurred\n");
            if(suspend(handle) < 0) {
                      goto FREE_BUF;
              }
      }

        //printf("samples is %d.\n", samples);

                     
      mp3_bytes =lame_encode_buffer_interleaved(gfp, input_buff, samples, mp3_buff,MP3BUFF_SIZE);
      //mp3_bytes= lame_encode_buffer(gfp, input_buff, NULL, samples, mp3_buff,MP3BUFF_SIZE);
      //printf("mp3_bytes is %d.\n", mp3_bytes);
      if(mp3_bytes < 0) {
              printf("lame_encode_buffer_interleaved returned %d\n",mp3_bytes);
              ret = -1;
              goto FREE_BUF;
      }
      write_bytes= fwrite(mp3_buff, 1, mp3_bytes, fd_mp3);
      if(write_bytes < 0) {
              perror("Write sound data file failed\n");
              ret = -1;
              goto FREE_BUF;
      } elsefflush(fd_mp3);
      }
      mp3_bytes =lame_encode_flush(gfp, mp3_buff, sizeof(mp3_buff));
      if(mp3_bytes > 0) {
              printf("Writing %d mp3 bytes.\n", mp3_bytes);
              if (fwrite(mp3_buff, 1, mp3_bytes, fd_mp3) != (unsignedint)mp3_bytes)
                      printf("'Writing mp3 bytes error.\n");
              else
                      fflush(fd_mp3);
      } else
              printf("Writing mp3 bytes 0.\n");
                     
      FREE_BUF:
      if (mp3_buff!= NULL) { free(mp3_buff);
      mp3_buff =NULL; }
      if(input_buff != NULL) { free(input_buff);
      input_buff =NULL; }
     
      CLOSE_LAME:lame_close(gfp);
      CLOSE_MP3:fclose(fd_mp3);
      CLOSE_DSP:
      snd_pcm_drain(handle);
      snd_pcm_close(handle);

      EXIT: returnret;
}

int xrun(snd_pcm_t* handle)
{
      snd_pcm_status_t *status = NULL;
      intret;
      int verbose= 0;

      snd_pcm_status_alloca(&status);
      if ((ret =snd_pcm_status(handle, status)) < 0) {
            printf("status error: %d \n", ret);
            return-1;
      }

      if(snd_pcm_status_get_state(status) == SND_PCM_STATE_XRUN) {
            structtimeval now, diff, tstamp;
            gettimeofday(&now, 0);
            snd_pcm_status_get_trigger_tstamp(status,&tstamp);
            timersub(&now, &tstamp,&diff);
            fprintf(stderr, "overrun!!! (at least %.3f ms long)\n", diff.tv_sec* 1000 + diff.tv_usec / 1000.0);
            if (verbose){
                  printf("Status:\n");
                  //snd_pcm_status_dump(status, _log);
            }

            if ((ret =snd_pcm_prepare(handle)) < 0) {
                  printf("xrun: prepare error:%d\n", ret);
                  return-1;
            }
            return1;        // ok, data should be accepted again
      }

      if(snd_pcm_status_get_state(status) == SND_PCM_STATE_DRAINING){
            if (verbose){
                  printf("Status(DRAINING):\n");
                  //snd_pcm_status_dump(status, _log);
            }

            printf("capture stream format change? attemptingrecover...\n");
            if ((ret =snd_pcm_prepare(handle)) < 0) {
                  printf("xrun(DRAINING): prepare error: %d\n", ret);
                  return-1;
            }
            return1;
      }
      if (verbose){
            printf("Status(R/W):\n");
            //snd_pcm_status_dump(status, _log);
      }
      printf("read/write error, state = %s\n",snd_pcm_state_name(snd_pcm_status_get_state(status)));
      return-1;
}

// handle the case that device busy
int suspend(snd_pcm_t* handle)
{
      intret;

      while ((ret= snd_pcm_resume(handle)) ==-EAGAIN)      //Resume from suspend.
            sleep(1);        // resume can't be proceed immediately, waituntil suspend flag is released

      if (ret< 0) {    //-ENOSYS hardware doesn't support this feature
            if ((ret =snd_pcm_prepare(handle)) < 0) {
                  printf("suspend: prepare error: %d", ret);
                  return-1;
            }
      }
      return1;

}