ffmpeg混音代码

要使用FFmpeg进行音频混音，可以使用以下代码：

ffmpeg -i input1.mp3 -i input2.mp3 -filter_complex amix=inputs=2:duration=longest output.mp3

这个命令会将两个输入音频文件（`input1.mp3`和`input2.mp3`）进行混音，并将结果保存为`output.mp3`文件。`amix`过滤器用于实现音频混音，`inputs=2`表示有两个输入流，`duration=longest`表示输出音频的长度与最长的输入流的长度相同。

请注意，你需要将输入文件名替换为你自己的文件名，并确保FFmpeg已正确安装并在系统路径中可用。

相关问题

ffmpeg 混音代码

以下是使用FFmpeg混音的示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <unistd.h>
#include <libavformat/avformat.h>
#include <libavutil/opt.h>
int main(int argc, char *argv[]) {
    AVFormatContext *formatCtx1 = NULL;
    AVFormatContext *formatCtx2 = NULL;
    AVFormatContext *outputFormatCtx = NULL;
    AVStream *audioStream1 = NULL;
    AVStream *audioStream2 = NULL;
    AVCodecContext *audioCodecCtx1 = NULL;
    AVCodecContext *audioCodecCtx2 = NULL;
    AVCodec *audioCodec = NULL;
    AVFrame *frame1 = NULL;
    AVFrame *frame2 = NULL;
    AVPacket packet;

    const char *inputFile1 = "input1.mp3";
    const char *inputFile2 = "input2.mp3";
    const char *outputFile = "output.mp3";

    int ret;

    av_register_all();

    // 打开第一个输入文件
    ret = avformat_open_input(&formatCtx1, inputFile1, NULL, NULL);
    if (ret < 0) {
        fprintf(stderr, "Could not open input file '%s'\n", inputFile1);
        return 1;
    }

    // 获取音频流信息
    ret = avformat_find_stream_info(formatCtx1, NULL);
    if (ret < 0) {
        fprintf(stderr, "Could not find stream information\n");
        return 1;
    }

    // 打开第二个输入文件
    ret = avformat_open_input(&formatCtx2, inputFile2, NULL, NULL);
    if (ret < 0) {
        fprintf(stderr, "Could not open input file '%s'\n", inputFile2);
        return 1;
    }

    // 获取音频流信息
    ret = avformat_find_stream_info(formatCtx2, NULL);
    if (ret < 0) {
        fprintf(stderr, "Could not find stream information\n");
        return 1;
    }

    // 创建输出文件上下文
    ret = avformat_alloc_output_context2(&outputFormatCtx, NULL, NULL, outputFile);
    if (ret < 0) {
        fprintf(stderr, "Could not create output context\n");
        return 1;
    }

    // 查找音频流
    for (int i = 0; i < formatCtx1->nb_streams; i++) {
        if (formatCtx1->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
            audioStream1 = formatCtx1->streams[i];
            audioCodecCtx1 = avcodec_alloc_context3(NULL);
            ret = avcodec_parameters_to_context(audioCodecCtx1, audioStream1->codecpar);
            if (ret < 0) {
                fprintf(stderr, "Failed to copy codec parameters to decoder context\n");
                return 1;
            }

            // 打开解码器
            audioCodec = avcodec_find_decoder(audioCodecCtx1->codec_id);
            if (!audioCodec) {
                fprintf(stderr, "Unsupported codec\n");
                return 1;
            }

            ret = avcodec_open2(audioCodecCtx1, audioCodec, NULL);
            if (ret < 0) {
                fprintf(stderr, "Could not open codec\n");
                return 1;
            }
            
            break;
        }
    }

    // 查找音频流
    for (int i = 0; i < formatCtx2->nb_streams; i++) {
        if (formatCtx2->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
            audioStream2 = formatCtx2->streams[i];
            audioCodecCtx2 = avcodec_alloc_context3(NULL);
            ret = avcodec_parameters_to_context(audioCodecCtx2, audioStream2->codecpar);
            if (ret < 0) {
                fprintf(stderr, "Failed to copy codec parameters to decoder context\n");
                return 1;
            }

            // 打开解码器
            audioCodec = avcodec_find_decoder(audioCodecCtx2->codec_id);
            if (!audioCodec) {
                fprintf(stderr, "Unsupported codec\n");
                return 1;
            }

            ret = avcodec_open2(audioCodecCtx2, audioCodec, NULL);
            if (ret < 0) {
                fprintf(stderr, "Could not open codec\n");
                return 1;
            }
            
            break;
        }
    }

    // 创建输出流
    AVStream *outputStream = avformat_new_stream(outputFormatCtx, NULL);
    if (!outputStream) {
        fprintf(stderr, "Failed to create output stream\n");
        return 1;
    }

    // 复制音频流参数
    ret = avcodec_parameters_copy(outputStream->codecpar, audioStream1->codecpar);
    if (ret < 0) {
        fprintf(stderr, "Failed to copy codec parameters\n");
        return 1;
    }

    // 打开输出文件
    ret = avio_open(&outputFormatCtx->pb, outputFile, AVIO_FLAG_WRITE);
    if (ret < 0) {
        fprintf(stderr, "Could not open output file '%s'\n", outputFile);
        return 1;
    }

    // 写文件头
    ret = avformat_write_header(outputFormatCtx, NULL);
    if (ret < 0) {
        fprintf(stderr, "Error occurred when writing header\n");
        return 1;
    }

    // 初始化帧和数据包
    frame1 = av_frame_alloc();
    frame2 = av_frame_alloc();
    av_init_packet(&packet);
    packet.data = NULL;
    packet.size = 0;

    // 读取第一个输入文件的音频帧
    while (av_read_frame(formatCtx1, &packet) >= 0) {
        if (packet.stream_index == audioStream1->index) {
            ret = avcodec_send_packet(audioCodecCtx1, &packet);
            if (ret < 0) {
                fprintf(stderr, "Error sending a packet to the decoder\n");
                break;
            }

            while (ret >= 0) {
                ret = avcodec_receive_frame(audioCodecCtx1, frame1);
                if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                    break;
                } else if (ret < 0) {
                    fprintf(stderr, "Error during decoding\n");
                    return 1;
                }

                // 读取第二个输入文件的音频帧
                if (av_read_frame(formatCtx2, &packet) >= 0 && packet.stream_index == audioStream2->index) {
                    ret = avcodec_send_packet(audioCodecCtx2, &packet);
                    if (ret < 0) {
                        fprintf(stderr, "Error sending a packet to the decoder\n");
                        break;
                    }

                    while (ret >= 0) {
                        ret = avcodec_receive_frame(audioCodecCtx2, frame2);
                        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                            break;
                        } else if (ret < 0) {
                            fprintf(stderr, "Error during decoding\n");
                            return 1;
                        }

                        // 混音
                        for (int i = 0; i < frame1->nb_samples; i++) {
                            for (int ch = 0; ch < audioCodecCtx1->channels; ch++) {
                                ((int16_t *)frame1->data[ch])[i] += ((int16_t *)frame2->data[ch])[i];
                            }
                        }

                        // 编码并写入输出文件
                        ret = avcodec_send_frame(audioCodecCtx1, frame1);
                        if (ret < 0) {
                            fprintf(stderr, "Error sending a frame for encoding\n");
                            return 1;
                        }

                        while (ret >= 0) {
                            ret = avcodec_receive_packet(audioCodecCtx1, &packet);
                            if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                                break;
                            } else if (ret < 0) {
                                fprintf(stderr, "Error during encoding\n");
                                return 1;
                            }

                            packet.stream_index = outputStream->index;
                            av_packet_rescale_ts(&packet, audioCodecCtx1->time_base, outputStream->time_base);
                            ret = av_write_frame(outputFormatCtx, &packet);
                            av_packet_unref(&packet);

                            if (ret < 0) {
                                fprintf(stderr, "Error writing frame\n");
                                return 1;
                            }
                        }
                    }

                    av_packet_unref(&packet);
                }
            }
        }

        av_packet_unref(&packet);
    }

    // 写文件尾
    ret = av_write_trailer(outputFormatCtx);
    if (ret < 0) {
        fprintf(stderr, "Error occurred when writing trailer\n");
        return 1;
    }

    // 清理资源
    avcodec_free_context(&audioCodecCtx1);
    avcodec_free_context(&audioCodecCtx2);
    avformat_close_input(&formatCtx1);
    avformat_close_input(&formatCtx2);
    av_frame_free(&frame1);
    av_frame_free(&frame2);
    avformat_free_context(outputFormatCtx);

    return 0;
}

请确保在编译时链接FFmpeg的库。另外，请根据实际情况修改输入文件和输出文件的路径。这个示例代码将两个输入文件的音频流混合到一个输出文件中。

多路pcm混音算法 开源代码

多路PCM混音算法指的是将多个PCM音频流混合到一个音频流中的算法。
在开源社区中，有一些提供多路PCM混音算法开源代码的项目。以下是其中一些常用的开源库和工具。

1. PortAudio：PortAudio是一个跨平台的音频I/O库，它提供了混音、录制和播放多个音频流的能力。它的源代码可以在GitHub上找到，并且提供了多种编程语言的接口，如C、C++、Python等。

2. FFmpeg：FFmpeg是一个广泛使用的开源多媒体框架，它能够处理和转码音视频文件。它提供了强大的音频混合功能，可以将多个PCM音频流混合到一个音频流中。FFmpeg的源代码也可以在GitHub上找到。

3. Web Audio API：Web Audio API 是一个W3C的标准，用于在Web浏览器中处理和播放音频。它提供了多路音频混合的能力，可以通过JavaScript代码混合不同的PCM音频流。Web Audio API的文档和示例可以在W3C的官方网站上找到。

这些开源代码和工具提供了多种实现多路PCM混音算法的方法，并且可以根据具体需求选择合适的工具和库来使用。使用这些工具和库，开发者可以方便地实现多路PCM混音算法，并加以扩展和优化。