c语言如何实现录音功能

C语言实现录音功能的核心步骤是：使用音频库、初始化设备、设置音频参数、开始录音、保存音频数据。本文将详细介绍如何通过C语言实现录音功能，并推荐一些常用的音频库和工具。

一、使用音频库

C语言本身并不直接提供音频处理的功能，因此我们需要借助一些音频库来实现录音功能。常用的音频库有PortAudio和ALSA（Advanced Linux Sound Architecture）。

PortAudio

PortAudio是一个跨平台的音频库，支持Windows、Mac OS和Linux等操作系统。以下是使用PortAudio进行录音的基本步骤：

安装PortAudio：你可以通过下载源码或者使用包管理器进行安装。
初始化PortAudio：在程序开始时调用Pa_Initialize()函数。
打开音频流：使用Pa_OpenStream()函数打开输入音频流。
开始录音：调用Pa_StartStream()开始录音。
读取音频数据：通过Pa_ReadStream()函数读取音频数据。
停止和关闭音频流：使用Pa_StopStream()和Pa_CloseStream()函数。
终止PortAudio：在程序结束时调用Pa_Terminate()函数。

以下是一个简单的录音示例代码：

#include <stdio.h>
#include <stdlib.h>
#include "portaudio.h"
#define SAMPLE_RATE 44100
#define FRAMES_PER_BUFFER 512
#define NUM_SECONDS 5
#define NUM_CHANNELS 2
typedef struct {
    int frameIndex;
    int maxFrameIndex;
    float *recordedSamples;
} paTestData;
static int recordCallback(const void *inputBuffer, void *outputBuffer,
                          unsigned long framesPerBuffer,
                          const PaStreamCallbackTimeInfo* timeInfo,
                          PaStreamCallbackFlags statusFlags,
                          void *userData) {
    paTestData *data = (paTestData*)userData;
    const float *rptr = (const float*)inputBuffer;
    float *wptr = &data->recordedSamples[data->frameIndex * NUM_CHANNELS];
    long framesToCalc;
    long i;
    int finished;
    (void) outputBuffer; /* Prevent unused variable warnings. */
    (void) timeInfo;
    (void) statusFlags;
    if (data->frameIndex + framesPerBuffer > data->maxFrameIndex) {
        framesToCalc = data->maxFrameIndex - data->frameIndex;
        finished = paComplete;
    } else {
        framesToCalc = framesPerBuffer;
        finished = paContinue;
    }
    if (inputBuffer == NULL) {
        for (i = 0; i < framesToCalc; i++) {
            *wptr++ = 0.0f; /* left */
            if (NUM_CHANNELS == 2) *wptr++ = 0.0f; /* right */
        }
    } else {
        for (i = 0; i < framesToCalc; i++) {
            *wptr++ = *rptr++; /* left */
            if (NUM_CHANNELS == 2) *wptr++ = *rptr++; /* right */
        }
    }
    data->frameIndex += framesToCalc;
    return finished;
}
int main(void) {
    PaStreamParameters inputParameters;
    PaStream *stream;
    PaError err;
    paTestData data;
    int i;
    int totalFrames;
    int numSamples;
    int numBytes;
    float max, val;
    double average;
    data.maxFrameIndex = totalFrames = NUM_SECONDS * SAMPLE_RATE; /* Record for a few seconds. */
    data.frameIndex = 0;
    numSamples = totalFrames * NUM_CHANNELS;
    numBytes = numSamples * sizeof(float);
    data.recordedSamples = (float *) malloc(numBytes); /* From now on, recordedSamples is initialised. */
    if (data.recordedSamples == NULL) {
        printf("Could not allocate record array.n");
        return 1;
    }
    for (i = 0; i < numSamples; i++) data.recordedSamples[i] = 0;
    err = Pa_Initialize();
    if (err != paNoError) goto error;
    inputParameters.device = Pa_GetDefaultInputDevice();
    if (inputParameters.device == paNoDevice) {
        fprintf(stderr, "Error: No default input device.n");
        goto error;
    }
    inputParameters.channelCount = 2;
    inputParameters.sampleFormat = paFloat32;
    inputParameters.suggestedLatency = Pa_GetDeviceInfo(inputParameters.device)->defaultLowInputLatency;
    inputParameters.hostApiSpecificStreamInfo = NULL;
    err = Pa_OpenStream(
              &stream,
              &inputParameters,
              NULL, /* &outputParameters, */
              SAMPLE_RATE,
              FRAMES_PER_BUFFER,
              paClipOff,
              recordCallback,
              &data);
    if (err != paNoError) goto error;
    err = Pa_StartStream(stream);
    if (err != paNoError) goto error;
    printf("Now recording!!n"); fflush(stdout);
    while ((err = Pa_IsStreamActive(stream)) == 1) {
        Pa_Sleep(1000);
        printf("index = %dn", data.frameIndex); fflush(stdout);
    }
    if (err < 0) goto error;
    err = Pa_CloseStream(stream);
    if (err != paNoError) goto error;
    Pa_Terminate();
    max = 0;
    average = 0.0;
    for (i = 0; i < numSamples; i++) {
        val = data.recordedSamples[i];
        if (val < 0) val = -val;
        if (val > max) {
            max = val;
        }
        average += val;
    }
    average = average / (double)numSamples;
    printf("Sample max amplitude = %fn", max);
    printf("Sample average = %lfn", average);
    free(data.recordedSamples);
    printf("Done.n");
    return 0;
error:
    Pa_Terminate();
    fprintf(stderr, "An error occurred while using the portaudio streamn");
    fprintf(stderr, "Error number: %dn", err);
    fprintf(stderr, "Error message: %sn", Pa_GetErrorText(err));
    return -1;
}

ALSA

ALSA是Linux系统的音频处理框架。以下是使用ALSA进行录音的基本步骤：

安装ALSA库：使用包管理器安装libasound2-dev。
初始化ALSA设备：使用snd_pcm_open()函数打开音频设备。
设置音频参数：通过snd_pcm_set_params()函数设置音频参数。
开始录音：调用snd_pcm_readi()函数读取音频数据。
关闭音频设备：使用snd_pcm_close()函数关闭音频设备。

以下是一个简单的录音示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <alsa/asoundlib.h>
#define PCM_DEVICE "default"
int main() {
    unsigned int pcm, tmp, dir;
    int rate, channels, seconds;
    snd_pcm_t *pcm_handle;
    snd_pcm_hw_params_t *params;
    snd_pcm_uframes_t frames;
    char *buffer;
    int buff_size, loops;
    rate = 44100;
    channels = 2;
    seconds = 5;
    /* Open the PCM device in recording mode */
    if (pcm = snd_pcm_open(&pcm_handle, PCM_DEVICE, SND_PCM_STREAM_CAPTURE, 0) < 0)
        printf("ERROR: Can't open "%s" PCM device. %sn", PCM_DEVICE, snd_strerror(pcm));
    /* Allocate parameters object and fill it with default values*/
    snd_pcm_hw_params_alloca(&params);
    snd_pcm_hw_params_any(pcm_handle, params);
    /* Set parameters */
    if (pcm = snd_pcm_hw_params_set_access(pcm_handle, params, SND_PCM_ACCESS_RW_INTERLEAVED) < 0)
        printf("ERROR: Can't set interleaved mode. %sn", snd_strerror(pcm));
    if (pcm = snd_pcm_hw_params_set_format(pcm_handle, params, SND_PCM_FORMAT_S16_LE) < 0)
        printf("ERROR: Can't set format. %sn", snd_strerror(pcm));
    if (pcm = snd_pcm_hw_params_set_channels(pcm_handle, params, channels) < 0)
        printf("ERROR: Can't set channels number. %sn", snd_strerror(pcm));
    if (pcm = snd_pcm_hw_params_set_rate_near(pcm_handle, params, &rate, 0) < 0)
        printf("ERROR: Can't set rate. %sn", snd_strerror(pcm));
    /* Write parameters */
    if (pcm = snd_pcm_hw_params(pcm_handle, params) < 0)
        printf("ERROR: Can't set harware parameters. %sn", snd_strerror(pcm));
    /* Allocate buffer to hold single period */
    snd_pcm_hw_params_get_period_size(params, &frames, &dir);
    buff_size = frames * channels * 2 /* 2 -> sample size */;
    buffer = (char *) malloc(buff_size);
    snd_pcm_hw_params_get_period_time(params, &tmp, NULL);
    for (loops = (seconds * 1000000) / tmp; loops > 0; loops--) {
        if (pcm = snd_pcm_readi(pcm_handle, buffer, frames) == -EPIPE) {
            printf("XRUN.n");
            snd_pcm_prepare(pcm_handle);
        } else if (pcm < 0) {
            printf("ERROR. Can't read from PCM device. %sn", snd_strerror(pcm));
        } else {
            printf("Read %d framesn", pcm);
        }
    }
    snd_pcm_drain(pcm_handle);
    snd_pcm_close(pcm_handle);
    free(buffer);
    return 0;
}

二、初始化设备

无论使用哪种音频库，都需要首先初始化音频设备。初始化设备包括打开设备、设置设备参数等步骤。

打开设备

在PortAudio中，使用Pa_OpenStream()函数打开音频流。在ALSA中，使用snd_pcm_open()函数打开音频设备。

设置设备参数

设置设备参数包括采样率、通道数、采样格式等。在PortAudio中，通过PaStreamParameters结构体设置参数。在ALSA中，通过snd_pcm_hw_params_set_*()函数设置参数。

三、设置音频参数

音频参数的设置是录音功能实现的关键步骤。常见的音频参数包括采样率、通道数、采样格式、帧大小等。

采样率

采样率决定了每秒钟采集的音频样本数量，常见的采样率有44100 Hz、48000 Hz等。

通道数

通道数决定了录音是单声道还是立体声。单声道的通道数为1，立体声的通道数为2。

采样格式

采样格式决定了每个样本的表示方式，常见的采样格式有16位、32位浮点数等。

帧大小

帧大小决定了每次读取的音频数据块的大小，通常以样本数表示。

四、开始录音

设置好音频参数后，就可以开始录音了。录音的过程包括读取音频数据并将其保存到缓冲区中。

读取音频数据

在PortAudio中，通过Pa_ReadStream()函数读取音频数据。在ALSA中，通过snd_pcm_readi()函数读取音频数据。

保存音频数据

读取的音频数据需要保存到缓冲区中，方便后续处理或保存到文件中。

五、保存音频数据

录音完成后，需要将音频数据保存到文件中。常见的音频文件格式有WAV、MP3等。这里以WAV格式为例，介绍如何保存音频数据。

WAV文件格式

WAV文件格式是最常见的音频文件格式之一，具有简单易用的特点。WAV文件由文件头和音频数据两部分组成。

编写WAV文件头

WAV文件头包含音频文件的基本信息，如采样率、通道数、采样格式、数据大小等。

以下是一个简单的WAV文件头结构体：

typedef struct {
    char riff[4];        // "RIFF"
    int overall_size;    // file size - 8 bytes
    char wave[4];        // "WAVE"
    char fmt_chunk_marker[4]; // "fmt "
    int length_of_fmt;   // length of the format data
    short format_type;   // format type
    short channels;      // number of channels
    int sample_rate;     // sampling rate (blocks per second)
    int byterate;        // SampleRate * NumChannels * BitsPerSample/8
    short block_align;   // NumChannels * BitsPerSample/8
    short bits_per_sample; // bits per sample
    char data_chunk_header[4]; // "data"
    int data_size;       // size of the data section
} WAVHeader;

写入WAV文件

在录音结束后，将音频数据和WAV文件头写入文件中：

FILE *wavFile;
WAVHeader wavHeader;
wavFile = fopen("recording.wav", "wb");
if (wavFile == NULL) {
    printf("Could not open file for writing.n");
    return 1;
}
fwrite(&wavHeader, sizeof(WAVHeader), 1, wavFile);
fwrite(data.recordedSamples, sizeof(float), numSamples, wavFile);
fclose(wavFile);

填写WAV文件头信息

在写入WAV文件头之前，需要填写文件头的各项信息：

memcpy(wavHeader.riff, "RIFF", 4);
wavHeader.overall_size = 36 + numBytes;
memcpy(wavHeader.wave, "WAVE", 4);
memcpy(wavHeader.fmt_chunk_marker, "fmt ", 4);
wavHeader.length_of_fmt = 16;
wavHeader.format_type = 1;
wavHeader.channels = NUM_CHANNELS;
wavHeader.sample_rate = SAMPLE_RATE;
wavHeader.byterate = SAMPLE_RATE * NUM_CHANNELS * sizeof(float);
wavHeader.block_align = NUM_CHANNELS * sizeof(float);
wavHeader.bits_per_sample = sizeof(float) * 8;
memcpy(wavHeader.data_chunk_header, "data", 4);
wavHeader.data_size = numBytes;

六、结论

使用C语言实现录音功能需要借助音频库，如PortAudio和ALSA。本文详细介绍了使用这两种音频库实现录音功能的步骤，包括初始化设备、设置音频参数、开始录音和保存音频数据等。通过这些步骤，可以实现一个简单的录音功能。对于项目管理系统的需求，可以使用研发项目管理系统PingCode和通用项目管理软件Worktile来管理录音项目的开发过程。

通过本文的介绍，希望能够帮助你理解并实现C语言的录音功能。如果你有更高的需求，可以进一步研究音频处理的高级技术，如音频压缩、滤波等。