ffmpeg录制音频mp4

ffmpeg是一个开源的多媒体处理工具，它具有强大的音频录制功能，可以用来录制音频为mp4格式。

要录制音频为mp4格式，首先需要安装ffmpeg工具，并确保系统环境中已经配置好了ffmpeg。然后在命令行中输入录制音频的命令。

在命令行中输入以下命令来录制音频为mp4格式：

ffmpeg -f alsa -i default -t 60 output.mp4

其中，-f alsa表示指定录制的音频设备为alsa，-i default表示采集默认的音频输入设备，-t 60表示录制时长为60秒，output.mp4表示输出的文件名为output.mp4。

执行以上命令后，ffmpeg就会开始录制系统默认的音频输入设备的音频，并将其保存为mp4格式的文件。在录制过程中，可以根据需要设置录制的时长。

通过以上步骤，就可以使用ffmpeg录制音频为mp4格式了。在录制完成后，可以在当前目录下找到所保存的output.mp4文件，即为录制的音频文件。

相关问题

ffmpeg录制音频

FFmpeg是一个功能强大的音视频处理工具，可以用于录制音频。根据引用的内容，有几种命令可以使用FFmpeg录制音频。首先，使用以下命令来录制带声音的视频：

ffmpeg -f alsa -ac 1 -ar 44100 -i front:CARD=U0x46d0x825,DEV=0 -f video4linux2 -i /dev/video0 out.mpg
ffmpeg -f alsa -ac 1 -ar 16000 -i front:CARD=U0x46d0x825,DEV=0 -f video4linux2 -i /dev/video0 out.mp4

这些命令将从指定的音频设备（`front:CARD=U0x46d0x825,DEV=0`）和视频设备（`/dev/video0`）捕获音视频数据，并将其保存为MPG或MP4格式的文件。

另外，可以使用以下命令来仅捕获声卡数据并保存为音频文件：

ffmpeg -f alsa -ac 2 -ar 44100 -i default out.wav
ffmpeg -f alsa -ac 1 -ar 44100 -i default -t 30 out.wav
ffmpeg -f alsa -ac 1 -ar 16000 -i hw:0 -t 10 out.wav

这些命令中，`-i`参数指定了要捕获的声卡设备名称，`-f`参数指定了音频驱动类型（`alsa`表示Linux下的音频驱动框架），`-ar`参数设置音频采样率，`-ac`参数设置音频通道数，`-t`参数设置录制的时长。

除了上述命令，FFmpeg还提供了其他的音频选项，可以根据需要进行调整，例如设置音频质量、音频编解码器等。可以通过`ffmpeg --help`命令查看更多的音频选项。

C++ ffmpeg录制音频

要使用C++和FFmpeg来录制音频，你需要使用FFmpeg库中的AVFormatContext和AVCodecContext结构体。下面是一个示例代码，可以进行音频录制：

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>

#include <signal.h>
#include <pthread.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/mathematics.h>
#include <libavutil/samplefmt.h>
#include <libavutil/channel_layout.h>
#include <libavutil/opt.h>
#include <libavutil/time.h>
}

#define AUDIO_INBUF_SIZE 20480
#define AUDIO_REFILL_THRESH 4096

volatile int stop = 0;

static void sigterm_handler(int sig)
{
    stop = 1;
}

int main(int argc, char **argv)
{
    AVFormatContext *oc;
    AVCodecContext *audio_ctx;
    AVStream *audio_st;
    AVCodec *audio_codec;
    AVFrame *audio_frame;
    uint8_t audio_inbuf[AUDIO_INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
    uint8_t *audio_data;
    int audio_data_size;
    int ret;
    int fd;
    int64_t start_time;

    if (argc != 2) {
        fprintf(stderr, "Usage: %s <output file>\n", argv[0]);
        exit(1);
    }

    // 打开输出文件
    if (avformat_alloc_output_context2(&oc, NULL, NULL, argv[1]) < 0) {
        fprintf(stderr, "Could not allocate output context\n");
        return -1;
    }

    // 打开音频输入设备
    if ((fd = open("/dev/dsp", O_RDONLY)) < 0) {
        fprintf(stderr, "Could not open audio device\n");
        return -1;
    }

    // 创建音频流
    audio_st = avformat_new_stream(oc, NULL);
    if (!audio_st) {
        fprintf(stderr, "Could not create audio stream\n");
        return -1;
    }

    // 设置音频编码器
    audio_codec = avcodec_find_encoder(oc->audio_codec_id);
    if (!audio_codec) {
        fprintf(stderr, "Could not find encoder for %s\n", avcodec_get_name(oc->audio_codec_id));
        return -1;
    }
    audio_ctx = avcodec_alloc_context3(audio_codec);
    if (!audio_ctx) {
        fprintf(stderr, "Could not allocate audio codec context\n");
        return -1;
    }
    audio_ctx->sample_fmt  = audio_codec->sample_fmts[0];
    audio_ctx->bit_rate    = 64000;
    audio_ctx->sample_rate = 44100;
    audio_ctx->channels    = 2;
    audio_ctx->channel_layout = av_get_default_channel_layout(2);
    audio_st->time_base    = (AVRational){1, audio_ctx->sample_rate};
    if (avcodec_open2(audio_ctx, audio_codec, NULL) < 0) {
        fprintf(stderr, "Could not open audio codec\n");
        return -1;
    }
    avcodec_parameters_from_context(audio_st->codecpar, audio_ctx);

    // 初始化音频帧
    audio_frame = av_frame_alloc();
    if (!audio_frame) {
        fprintf(stderr, "Could not allocate audio frame\n");
        return -1;
    }
    audio_frame->format = audio_ctx->sample_fmt;
    audio_frame->channel_layout = audio_ctx->channel_layout;
    audio_frame->sample_rate = audio_ctx->sample_rate;
    audio_frame->nb_samples = audio_ctx->frame_size;
    if (av_frame_get_buffer(audio_frame, 0) < 0) {
        fprintf(stderr, "Could not allocate audio data buffers\n");
        return -1;
    }

    // 开始录制
    av_dump_format(oc, 0, argv[1], 1);
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
        if (avio_open(&oc->pb, argv[1], AVIO_FLAG_WRITE) < 0) {
            fprintf(stderr, "Could not open output file '%s'\n", argv[1]);
            return -1;
        }
    }
    if (avformat_write_header(oc, NULL) < 0) {
        fprintf(stderr, "Error occurred when writing header to output file\n");
        return -1;
    }
    start_time = av_gettime_relative();

    // 信号处理程序
    signal(SIGINT, sigterm_handler);
    signal(SIGTERM, sigterm_handler);

    // 录制音频
    while (!stop) {
        audio_data_size = read(fd, audio_inbuf, AUDIO_INBUF_SIZE);
        if (audio_data_size <= 0) {
            break;
        }

        audio_data = audio_inbuf;
        while (audio_data_size > 0) {
            int len1, got_frame;
            AVPacket pkt;
            av_init_packet(&pkt);
            pkt.data = NULL;
            pkt.size = 0;

            len1 = avcodec_decode_audio4(audio_ctx, audio_frame, &got_frame, &pkt);
            if (len1 < 0) {
                fprintf(stderr, "Error decoding audio frame\n");
                break;
            }
            if (got_frame) {
                AVRational tb = (AVRational){1, audio_ctx->sample_rate};
                int64_t pts = av_rescale_q(audio_frame->pts, tb, audio_st->time_base);
                int64_t now = av_gettime_relative() - start_time;
                if (pts > now) {
                    av_usleep(pts - now);
                }

                audio_frame->pts = av_rescale_q(now, (AVRational){1, AV_TIME_BASE}, audio_st->time_base);

                ret = avcodec_send_frame(audio_ctx, audio_frame);
                if (ret < 0) {
                    fprintf(stderr, "Error sending audio frame\n");
                    break;
                }

                while (ret >= 0) {
                    AVPacket pkt_out;
                    av_init_packet(&pkt_out);
                    pkt_out.data = NULL;
                    pkt_out.size = 0;

                    ret = avcodec_receive_packet(audio_ctx, &pkt_out);
                    if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                        break;
                    } else if (ret < 0) {
                        fprintf(stderr, "Error encoding audio frame\n");
                        break;
                    }

                    pkt_out.stream_index = audio_st->index;
                    pkt_out.pts = av_rescale_q(pkt_out.pts, audio_st->time_base, oc->streams[pkt_out.stream_index]->time_base);
                    pkt_out.dts = av_rescale_q(pkt_out.dts, audio_st->time_base, oc->streams[pkt_out.stream_index]->time_base);
                    pkt_out.duration = av_rescale_q(pkt_out.duration, audio_st->time_base, oc->streams[pkt_out.stream_index]->time_base);

                    ret = av_interleaved_write_frame(oc, &pkt_out);
                    if (ret < 0) {
                        fprintf(stderr, "Error writing audio frame\n");
                        break;
                    }
                }
            }
            audio_data += len1;
            audio_data_size -= len1;
            if (pkt.data) {
                av_packet_unref(&pkt);
            }
        }
    }

    // 结束录制
    av_write_trailer(oc);
    if (oc && !(oc->oformat->flags & AVFMT_NOFILE)) {
        avio_closep(&oc->pb);
    }
    avcodec_free_context(&audio_ctx);
    av_frame_free(&audio_frame);
    avformat_free_context(oc);

    return 0;
}

该示例程序会打开Linux系统上的 `/dev/dsp` 音频设备来进行录制，你可以根据需要修改打开的设备路径。录制的音频编码格式为MP3，可以根据需要修改相关参数。你需要将上述代码保存到一个C++源文件中，并使用FFmpeg库进行编译链接。