【音视频】⾳频处理基本概念及⾳频重采样

一、重采样

1.1 什么是重采样

所谓的重采样，就是改变⾳频的采样率、sample format、声道数等参数，使之按照我们期望的参数输出。

1.2 为什么要重采样

为什么要重采样?

当然是原有的⾳频参数不满⾜我们的需求，⽐如在FFmpeg解码⾳频的时候，不同的⾳源有不同的格式，采样率等，在解码后的数据中的这些参数也会不⼀致(最新FFmpeg 解码⾳频后，⾳频格式为AV_SAMPLE_FMT_FLTP，这个参数应该是⼀致的)，如果我们接下来需要使⽤解码后的⾳频数据做其他操作，⽽这些参数的不⼀致导致会有很多额外⼯作，此时直接对其进⾏重采样，获取我们制定的⾳频参数，这样就会⽅便很多。
再⽐如在将⾳频进⾏SDL播放时候，因为当前的SDL2.0不⽀持planar格式，也不⽀持浮点型的，⽽最新的FFMPEG 16年会将⾳频解码为AV_SAMPLE_FMT_FLTP格式，因此此时就需要我们对其重采样，使之可以在SDL2.0上进⾏播放。

1.3 可调节的参数

通过重采样，我们可以对：

sample rate(采样率)
sample format(采样格式)
channel layout(通道布局，可以通过此参数获取声道数）

二、对应参数解析

2.1 采样率

采样设备每秒抽取样本的次数

2.2 采样格式及量化精度（位宽）

每种⾳频格式有不同的量化精度（位宽），位数越多，表示值就越精确，声⾳表现⾃然就越精准。

FFMpeg中⾳频格式有以下⼏种，每种格式有其占⽤的字节数信息

c 复制代码

enum AVSampleFormat {
AV_SAMPLE_FMT_NONE = -1,
AV_SAMPLE_FMT_U8, ///< unsigned 8 bits
AV_SAMPLE_FMT_S16, ///< signed 16 bits
AV_SAMPLE_FMT_S32, ///< signed 32 bits
AV_SAMPLE_FMT_FLT, ///< float
AV_SAMPLE_FMT_DBL, ///< double
AV_SAMPLE_FMT_U8P, ///< unsigned 8 bits, planar
AV_SAMPLE_FMT_S16P, ///< signed 16 bits, planar
AV_SAMPLE_FMT_S32P, ///< signed 32 bits, planar
AV_SAMPLE_FMT_FLTP, ///< float, planar
AV_SAMPLE_FMT_DBLP, ///< double, planar
AV_SAMPLE_FMT_S64, ///< signed 64 bits
AV_SAMPLE_FMT_S64P, ///< signed 64 bits, planar
AV_SAMPLE_FMT_NB ///< Number of sample formats. DO NOT USE if linking dynamically
};

2.3 分⽚（plane）和打包（packed）

以双声道为例，带P（plane）的数据格式在存储时，其左声道和右声道的数据是分开存储的，左声道的数据存储在data[0]，右声道的数据存储在data[1]，每个声道的所占⽤的字节数为linesize[0]和linesize[1]
不带P（packed）的⾳频数据在存储时，是按照LRLRLR...的格式交替存储在data[0]中，linesize[0]表示总的数据量。

2.4 声道分布（channel_layout)

声道分布在FFmpeg\libavutil\channel_layout.h中有定义，⼀般来说⽤的⽐较多的是AV_CH_LAYOUT_STEREO（双声道）和AV_CH_LAYOUT_SURROUND（三声道）

这两者的定义如下：

c 复制代码

#define AV_CH_LAYOUT_STEREO (AV_CH_FRONT_LEFT|AV_CH_FRONT_RIGHT)
#define AV_CH_LAYOUT_SURROUND (AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER)

2.5 ⾳频帧的数据量计算

⼀帧⾳频的数据量（字节）=channel 数 * nb_samples样本数 * 每个样本占⽤的字节数
如果该⾳频帧是FLTP格式的PCM数据，包含1024个样本，双声道，那么该⾳频帧包含的⾳频数据量是2*1024*4=8192字节。
AV_SAMPLE_FMT_DBL ： 2*1024*8 = 16384

2.6 ⾳频播放时间计算

以采样率44100Hz来计算，每秒44100个sample，⽽正常⼀帧为1024个sample，可知每帧播放时间/1024=1000ms/44100，得到每帧播放时间=1024*1000/44100=23.2ms （更精确的是23.21995464852608）。
⼀帧播放时间（毫秒） = nb_samples样本数 *1000/采样率
（1）1024*1000/44100=23.21995464852608ms ->约等于 23.2ms，精度损失了0.011995464852608ms，如果累计10万帧，误差>1199毫秒，如果有视频⼀起的就会有⾳视频同步的问题。如果按着23.2去计算pts（0 23.2 46.4 ）就会有累积误差。
（2）1024*1000/48000=21.33333333333333ms

三、FFmpeg重采样API

分配⾳频重采样的上下⽂

c 复制代码

struct SwrContext *swr_alloc(void)

当设置好相关的参数后，使⽤此函数来初始化SwrContext结构体

c 复制代码

int swr_init(struct SwrContext *s);

分配SwrContext并设置/重置常⽤的参数。

c 复制代码

struct SwrContext *swr_alloc_set_opts(struct SwrContext *s, // ⾳频重采样上下⽂
	int64_t out_ch_layout, // 输出的layout, 如：5.1声道
	enum AVSampleFormat out_sample_fmt, // 输出的采样格式。Float, S16,⼀般选⽤是s16 绝⼤部分声卡⽀持
	int out_sample_rate, //输出采样率
	int64_t in_ch_layout, // 输⼊的layout
	enum AVSampleFormat in_sample_fmt, // 输⼊的采样格式
	int in_sample_rate, // 输⼊的采样率
	int log_offset, // ⽇志相关，不⽤管先，直接为0
	void *log_ctx // ⽇志相关，不⽤管先，直接为NULL
);

将输⼊的⾳频按照定义的参数进⾏转换并输出

返回值 <= out_count，
in和in_count可以设置为0，以最后刷新最后⼏个样本。

c 复制代码

int swr_convert(struct SwrContext *s, // ⾳频重采样的上下⽂
	uint8_t **out, // 输出的指针。传递的输出的数组
	int out_count, //输出的样本数量，不是字节数。单通道的样本数量。
	const uint8_t **in , //输⼊的数组，AVFrame解码出来的DATA
	int in_count // 输⼊的单通道的样本数量。
);

释放掉SwrContext结构体并将此结构体置为NULL

c 复制代码

void swr_free(struct SwrContext **s);

与lswr的交互是通过SwrContext完成的，SwrContext被分配给swr_alloc（）或

swr_alloc_set_opts（）。它是不透明的，所以所有参数必须使⽤AVOptions API设置。
为了使⽤lswr，你需要做的第⼀件事就是分配SwrContext。这可以使⽤swr_alloc（）或swr_alloc_set_opts（）来完成。如果您使⽤前者，则必须通过AVOptions API设置选项。后⼀个函数提供了相同的功能，但它允许您在同⼀语句中设置⼀些常⽤选项。
例如，以下代码将设置从平⾯浮动样本格式到交织的带符号16位整数的转换，从48kHz到44.1kHz的下采样，以及从5.1声道到⽴体声的下混合（使⽤默认混合矩阵）。这是使⽤swr_alloc（）函数。

c 复制代码

SwrContext *swr = swr_alloc();
av_opt_set_channel_layout(swr, "in_channel_layout", AV_CH_LAYOUT_POINT1, 0);
av_opt_set_channel_layout(swr, "out_channel_layout", AV_CH_LAYOUT_STEREO, 0);

av_opt_set_int(swr, "in_sample_rate", 48000, 0);
av_opt_set_int(swr, "out_sample_rate", 44100, 0);
av_opt_set_sample_fmt(swr, "in_sample_fmt", AV_SAMPLE_FMT_FLTP, 0);
av_opt_set_sample_fmt(swr, "out_sample_fmt", AV_SAMPLE_FMT_S16, 0);

同样的⼯作也可以使⽤swr_alloc_set_opts（）：

c 复制代码

SwrContext *swr = swr_alloc_set_opts(NULL, // we're allocating a new_context
	AV_CH_LAYOUT_STEREO, // out_ch_layout
	AV_SAMPLE_FMT_S16, // out_sample_fmt
	44100, // out_sample_rate
	AV_CH_LAYOUT_5POINT1, // in_ch_layout
	AV_SAMPLE_FMT_FLTP, // in_sample_fmt
	48000, // in_sample_rate
	0, // log_offset
	NULL); // log_ctx

⼀旦设置了所有值，它必须⽤swr_init（）初始化。如果需要更改转换参数，可以使⽤AVOptions来更改参数，如上⾯第⼀个例⼦所述; 或者使⽤swr_alloc_set_opts（），但是第⼀个参数是分配的上下⽂。您必须再次调⽤swr_init（）。
转换本身通过重复调⽤swr_convert（）来完成。请注意，如果提供的输出空间不⾜或采样率转换完成后，样本可能会在swr中缓冲，这需要"未来"样本。可以随时通过使⽤swr_convert（）（in_count可以设置为0）来检索不需要将来输⼊的样本。在转换结束时，可以通过调⽤具有NULL in和in incount的swr_convert（）来刷新重采样缓冲区。

实现流程

添加输出文件

在main函数参数中加入输出文件，这里设置为out.pcm

打开输出文件

二进制写方式打开

c 复制代码

FILE *dst_file;
dst_filename = argv[1];
dst_file = fopen(dst_filename, "wb");

设置输入参数和输出参数

这里的输入源是我们手动生成了，生成的是一个正弦波
手动设置一下输入源的参数信息

c 复制代码

// 输入参数
int64_t src_ch_layout = AV_CH_LAYOUT_STEREO;
int src_rate = 48000;
enum AVSampleFormat src_sample_fmt = AV_SAMPLE_FMT_DBL;
int src_nb_channels = 0;
uint8_t **src_data = NULL;  // 二级指针
int src_linesize;
int src_nb_samples = 1024;

设置输出参数，改变采样率和采样格式

c 复制代码

// 输出参数
int64_t dst_ch_layout = AV_CH_LAYOUT_STEREO;
int dst_rate = 44100;
enum AVSampleFormat dst_sample_fmt = AV_SAMPLE_FMT_S16;
int dst_nb_channels = 0;
uint8_t **dst_data = NULL;  //二级指针
int dst_linesize;
int dst_nb_samples;
int max_dst_nb_samples;

创建重采样上下文对象
分配重采样上下文内存
设置重采样参数
初始化重采样

c 复制代码

struct SwrContext *swr_ctx;
swr_ctx = swr_alloc();
av_opt_set_int(swr_ctx, "in_channel_layout",    src_ch_layout, 0);
av_opt_set_int(swr_ctx, "in_sample_rate",       src_rate, 0);
av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt", src_sample_fmt, 0);

    /* initialize the resampling context */
if ((ret = swr_init(swr_ctx)) < 0) {
	fprintf(stderr, "Failed to initialize the resampling context\n");
	goto end;
}

需要根据通道格式获取通道的数量

c 复制代码

src_nb_channels = av_get_channel_layout_nb_channels(src_ch_layout);

dst_nb_channels = av_get_channel_layout_nb_channels(dst_ch_layout);

根据输入（输出）参数（采样率、音频格式、通道数）分配内存

c 复制代码

ret = av_samples_alloc_array_and_samples(&src_data, &src_linesize, src_nb_channels,
										 src_nb_samples, src_sample_fmt, 0);

dst_nb_channels = av_get_channel_layout_nb_channels(dst_ch_layout);
// 分配输出缓存内存
ret = av_samples_alloc_array_and_samples(&dst_data, &dst_linesize, dst_nb_channels,
										 dst_nb_samples, dst_sample_fmt, 0);

根据输入的采样率和输入的采样点计算出输出文件的总采样数量
这里的采样点指的是一帧采样的总采样点，是循环进行这样每一帧的采样
AV_ROUND_UP是上取整，因为存在小数

c 复制代码

max_dst_nb_samples = dst_nb_samples =
		av_rescale_rnd(src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);

生成输入输出数据

生成输入源，因为输入格式使用的是packet模式的格式
每次生成数据计算时间t，我们只生成10s数据

c 复制代码

fill_samples((double *)src_data[0], src_nb_samples, src_nb_channels, src_rate, &t);

fill_samples函数用于生成一个440Hz频率的正弦波
这里是打包模式，只有src_data[0]有数据，并且每个采样点依次输入到每个channel中

c 复制代码

static void fill_samples(double *dst, int nb_samples, int nb_channels, int sample_rate, double *t)
{
    int i, j;
    double tincr = 1.0 / sample_rate, *dstp = dst;
    const double c = 2 * M_PI * 440.0;

    /* generate sin tone with 440Hz frequency and duplicated channels */
    for (i = 0; i < nb_samples; i++) {
        *dstp =sin(c * *t);
        for (j = 1; j < nb_channels; j++)
            dstp[j] = dstp[0];
        dstp += nb_channels;
        *t += tincr;
    }
}

计算采样点偏差

由于我们转换后的采样点不能整除，因此会在重采样器中缓存一部分采样点
我们就需要动态拿出这个缓存的采样点，如果采样点大于之前的最大采样点，那么我就需要重新分配输出样本的内存，并且重新设置最大采样点

c 复制代码

 int64_t delay = swr_get_delay(swr_ctx, src_rate);
        dst_nb_samples = av_rescale_rnd(delay + src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);
        if (dst_nb_samples > max_dst_nb_samples) {
            av_freep(&dst_data[0]);
            ret = av_samples_alloc(dst_data, &dst_linesize, dst_nb_channels,
                                   dst_nb_samples, dst_sample_fmt, 1);
            if (ret < 0)
                break;
            max_dst_nb_samples = dst_nb_samples;

重采样转换

根据输入输出的样本数将输入数据重采样转换到输出数据

c 复制代码

ret = swr_convert(swr_ctx, dst_data, dst_nb_samples, (const uint8_t **)src_data, src_nb_samples);
if (ret < 0) {
	fprintf(stderr, "Error while converting\n");
	goto end;
}

写入文件

获取dst数据的大小，要根据通道数、音频格式，以及linesize来推断
获取数据大小后，写入相应大小的数据到文件

c 复制代码

ret = swr_convert(swr_ctx, dst_data, dst_nb_samples, (const uint8_t **)src_data, src_nb_samples);
if (ret < 0) {
	fprintf(stderr, "Error while converting\n");
	goto end;
}
dst_bufsize = av_samples_get_buffer_size(&dst_linesize, dst_nb_channels,
										 ret, dst_sample_fmt, 1);
if (dst_bufsize < 0) {
	fprintf(stderr, "Could not get sample buffer size\n");
	goto end;
}
fwrite(dst_data[0], 1, dst_bufsize, dst_file);

整体转换代码

整体转换的代码如下，只重采样10s的数据

c 复制代码

 t = 0;
    do {
        /* generate synthetic audio */
        // 生成输入源
        fill_samples((double *)src_data[0], src_nb_samples, src_nb_channels, src_rate, &t);

        /* compute destination number of samples */
        int64_t delay = swr_get_delay(swr_ctx, src_rate);
        dst_nb_samples = av_rescale_rnd(delay + src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);
        if (dst_nb_samples > max_dst_nb_samples) {
            av_freep(&dst_data[0]);
            ret = av_samples_alloc(dst_data, &dst_linesize, dst_nb_channels,
                                   dst_nb_samples, dst_sample_fmt, 1);
            if (ret < 0)
                break;
            max_dst_nb_samples = dst_nb_samples;
        }
        //        int fifo_size = swr_get_out_samples(swr_ctx,src_nb_samples);
        //        printf("fifo_size:%d\n", fifo_size);
        //        if(fifo_size < 1024)
        //            continue;

        /* convert to destination format */
        //        ret = swr_convert(swr_ctx, dst_data, dst_nb_samples, (const uint8_t **)src_data, src_nb_samples);
        ret = swr_convert(swr_ctx, dst_data, dst_nb_samples, (const uint8_t **)src_data, src_nb_samples);
        if (ret < 0) {
            fprintf(stderr, "Error while converting\n");
            goto end;
        }
        dst_bufsize = av_samples_get_buffer_size(&dst_linesize, dst_nb_channels,
                                                 ret, dst_sample_fmt, 1);
        if (dst_bufsize < 0) {
            fprintf(stderr, "Could not get sample buffer size\n");
            goto end;
        }
        printf("t:%f in:%d out:%d\n", t, src_nb_samples, ret);
        fwrite(dst_data[0], 1, dst_bufsize, dst_file);
    } while (t < 10);

冲刷重采样器

冲刷重采样，主要是为了将剩余的数据写入到文件中
输入数据写为NULL即可

c 复制代码

ret = swr_convert(swr_ctx, dst_data, dst_nb_samples, NULL, 0);
if (ret < 0) {
	fprintf(stderr, "Error while converting\n");
	goto end;
}
dst_bufsize = av_samples_get_buffer_size(&dst_linesize, dst_nb_channels,
										 ret, dst_sample_fmt, 1);
if (dst_bufsize < 0) {
	fprintf(stderr, "Could not get sample buffer size\n");
	goto end;
}

fwrite(dst_data[0], 1, dst_bufsize, dst_file);

结束工作

释放重采样器内存、释放输入输出缓冲区内存
关闭输出文件

c 复制代码

fclose(dst_file);

if (src_data)
	av_freep(&src_data[0]);
av_freep(&src_data);

if (dst_data)
	av_freep(&dst_data[0]);
av_freep(&dst_data);

swr_free(&swr_ctx);

完整代码

main.c

c 复制代码

/*
 * Copyright (c) 2012 Stefano Sabatini
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

/**
 * @example resampling_audio.c
 * libswresample API use example.
 */

#include <libavutil/opt.h>
#include <libavutil/channel_layout.h>
#include <libavutil/samplefmt.h>
#include <libswresample/swresample.h>

static int get_format_from_sample_fmt(const char **fmt,
                                      enum AVSampleFormat sample_fmt)
{
    int i;
    struct sample_fmt_entry {
        enum AVSampleFormat sample_fmt; const char *fmt_be, *fmt_le;
    } sample_fmt_entries[] = {
    { AV_SAMPLE_FMT_U8,  "u8",    "u8"    },
    { AV_SAMPLE_FMT_S16, "s16be", "s16le" },
    { AV_SAMPLE_FMT_S32, "s32be", "s32le" },
    { AV_SAMPLE_FMT_FLT, "f32be", "f32le" },
    { AV_SAMPLE_FMT_DBL, "f64be", "f64le" },
};
    *fmt = NULL;

    for (i = 0; i < FF_ARRAY_ELEMS(sample_fmt_entries); i++) {
        struct sample_fmt_entry *entry = &sample_fmt_entries[i];
        if (sample_fmt == entry->sample_fmt) {
            *fmt = AV_NE(entry->fmt_be, entry->fmt_le);
            return 0;
        }
    }

    fprintf(stderr,
            "Sample format %s not supported as output format\n",
            av_get_sample_fmt_name(sample_fmt));
    return AVERROR(EINVAL);
}

/**
 * Fill dst buffer with nb_samples, generated starting from t. 交错模式的
 */
static void fill_samples(double *dst, int nb_samples, int nb_channels, int sample_rate, double *t)
{
    int i, j;
    double tincr = 1.0 / sample_rate, *dstp = dst;
    const double c = 2 * M_PI * 440.0;

    /* generate sin tone with 440Hz frequency and duplicated channels */
    for (i = 0; i < nb_samples; i++) {
        *dstp =sin(c * *t);
        for (j = 1; j < nb_channels; j++)
            dstp[j] = dstp[0];
        dstp += nb_channels;
        *t += tincr;
    }
}

int main(int argc, char **argv)
{
    // 输入参数
    int64_t src_ch_layout = AV_CH_LAYOUT_STEREO;
    int src_rate = 48000;
    enum AVSampleFormat src_sample_fmt = AV_SAMPLE_FMT_DBL;
    int src_nb_channels = 0;
    uint8_t **src_data = NULL;  // 二级指针
    int src_linesize;
    int src_nb_samples = 1024;


    // 输出参数
    int64_t dst_ch_layout = AV_CH_LAYOUT_STEREO;
    int dst_rate = 44100;
    enum AVSampleFormat dst_sample_fmt = AV_SAMPLE_FMT_S16;
    int dst_nb_channels = 0;
    uint8_t **dst_data = NULL;  //二级指针
    int dst_linesize;
    int dst_nb_samples;
    int max_dst_nb_samples;

    // 输出文件
    const char *dst_filename = NULL;    // 保存输出的pcm到本地，然后播放验证
    FILE *dst_file;


    int dst_bufsize;
    const char *fmt;

    // 重采样实例
    struct SwrContext *swr_ctx;

    double t;
    int ret;

    if (argc != 2) {
        fprintf(stderr, "Usage: %s output_file\n"
                        "API example program to show how to resample an audio stream with libswresample.\n"
                        "This program generates a series of audio frames, resamples them to a specified "
                        "output format and rate and saves them to an output file named output_file.\n",
                argv[0]);
        exit(1);
    }
    dst_filename = argv[1];

    dst_file = fopen(dst_filename, "wb");
    if (!dst_file) {
        fprintf(stderr, "Could not open destination file %s\n", dst_filename);
        exit(1);
    }

    // 创建重采样器
    /* create resampler context */
    swr_ctx = swr_alloc();
    if (!swr_ctx) {
        fprintf(stderr, "Could not allocate resampler context\n");
        ret = AVERROR(ENOMEM);
        goto end;
    }

    // 设置重采样参数
    /* set options */
    // 输入参数
    av_opt_set_int(swr_ctx, "in_channel_layout",    src_ch_layout, 0);
    av_opt_set_int(swr_ctx, "in_sample_rate",       src_rate, 0);
    av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt", src_sample_fmt, 0);
    // 输出参数
    av_opt_set_int(swr_ctx, "out_channel_layout",    dst_ch_layout, 0);
    av_opt_set_int(swr_ctx, "out_sample_rate",       dst_rate, 0);
    av_opt_set_sample_fmt(swr_ctx, "out_sample_fmt", dst_sample_fmt, 0);

    // 初始化重采样
    /* initialize the resampling context */
    if ((ret = swr_init(swr_ctx)) < 0) {
        fprintf(stderr, "Failed to initialize the resampling context\n");
        goto end;
    }

    /* allocate source and destination samples buffers */
    // 计算出输入源的通道数量
    src_nb_channels = av_get_channel_layout_nb_channels(src_ch_layout);
    // 给输入源分配内存空间
    ret = av_samples_alloc_array_and_samples(&src_data, &src_linesize, src_nb_channels,
                                             src_nb_samples, src_sample_fmt, 0);
    if (ret < 0) {
        fprintf(stderr, "Could not allocate source samples\n");
        goto end;
    }

    /* compute the number of converted samples: buffering is avoided
     * ensuring that the output buffer will contain at least all the
     * converted input samples */
    // 计算输出采样数量
    max_dst_nb_samples = dst_nb_samples =
            av_rescale_rnd(src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);

    printf("max_dst_nb_samples = %d\n",max_dst_nb_samples);
    /* buffer is going to be directly written to a rawaudio file, no alignment */
    dst_nb_channels = av_get_channel_layout_nb_channels(dst_ch_layout);
    // 分配输出缓存内存
    ret = av_samples_alloc_array_and_samples(&dst_data, &dst_linesize, dst_nb_channels,
                                             dst_nb_samples, dst_sample_fmt, 0);

    printf("linesize = %d\n",dst_linesize);
    if (ret < 0) {
        fprintf(stderr, "Could not allocate destination samples\n");
        goto end;
    }

    t = 0;
    do {
        /* generate synthetic audio */
        // 生成输入源
        fill_samples((double *)src_data[0], src_nb_samples, src_nb_channels, src_rate, &t);

        /* compute destination number of samples */
        int64_t delay = swr_get_delay(swr_ctx, src_rate);
        dst_nb_samples = av_rescale_rnd(delay + src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);
        if (dst_nb_samples > max_dst_nb_samples) {
            av_freep(&dst_data[0]);
            ret = av_samples_alloc(dst_data, &dst_linesize, dst_nb_channels,
                                   dst_nb_samples, dst_sample_fmt, 1);
            if (ret < 0)****
                break;
            max_dst_nb_samples = dst_nb_samples;
        }
        //        int fifo_size = swr_get_out_samples(swr_ctx,src_nb_samples);
        //        printf("fifo_size:%d\n", fifo_size);
        //        if(fifo_size < 1024)
        //            continue;

        /* convert to destination format */
        //        ret = swr_convert(swr_ctx, dst_data, dst_nb_samples, (const uint8_t **)src_data, src_nb_samples);
        ret = swr_convert(swr_ctx, dst_data, dst_nb_samples, (const uint8_t **)src_data, src_nb_samples);
        if (ret < 0) {
            fprintf(stderr, "Error while converting\n");
            goto end;
        }
        dst_bufsize = av_samples_get_buffer_size(&dst_linesize, dst_nb_channels,
                                                 ret, dst_sample_fmt, 1);
        if (dst_bufsize < 0) {
            fprintf(stderr, "Could not get sample buffer size\n");
            goto end;
        }
        printf("t:%f in:%d out:%d\n", t, src_nb_samples, ret);
        fwrite(dst_data[0], 1, dst_bufsize, dst_file);
    } while (t < 10);

    ret = swr_convert(swr_ctx, dst_data, dst_nb_samples, NULL, 0);
    if (ret < 0) {
        fprintf(stderr, "Error while converting\n");
        goto end;
    }
    dst_bufsize = av_samples_get_buffer_size(&dst_linesize, dst_nb_channels,
                                             ret, dst_sample_fmt, 1);
    if (dst_bufsize < 0) {
        fprintf(stderr, "Could not get sample buffer size\n");
        goto end;
    }

    printf("dst_bufsize = %d\n",dst_bufsize);
    printf("flush in:%d out:%d\n", 0, ret);
    fwrite(dst_data[0], 1, dst_bufsize, dst_file);


    if ((ret = get_format_from_sample_fmt(&fmt, dst_sample_fmt)) < 0)
        goto end;
    fprintf(stderr, "Resampling succeeded. Play the output file with the command:\n"
                    "ffplay -f %s -channel_layout %"PRId64" -channels %d -ar %d %s\n",
            fmt, dst_ch_layout, dst_nb_channels, dst_rate, dst_filename);

end:
    fclose(dst_file);

    if (src_data)
        av_freep(&src_data[0]);
    av_freep(&src_data);

    if (dst_data)
        av_freep(&dst_data[0]);
    av_freep(&dst_data);

    swr_free(&swr_ctx);
    return ret < 0;
}

更多资料：https://github.com/0voice

【音视频】⾳频处理基本概念及⾳频重采样

一、重采样

1.1 什么是重采样

1.2 为什么要重采样

1.3 可调节的参数

二、 对应参数解析

2.1 采样率

2.2 采样格式及量化精度（位宽）

2.3 分⽚（plane）和打包（packed）

2.4 声道分布（channel_layout)

2.5 ⾳频帧的数据量计算

2.6 ⾳频播放时间计算

三、FFmpeg重采样API

实现流程

添加输出文件

打开输出文件

设置输入参数和输出参数

生成输入输出数据

计算采样点偏差

重采样转换

写入文件

整体转换代码

冲刷重采样器

结束工作

完整代码

二、对应参数解析