enum AVSampleFormat {

    AV_SAMPLE_FMT_NONE = -,

    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

};

#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)

int main(int argc, char **argv)

{
    // 设置数据源src和dst声道布局

    int64_t src_ch_layout = AV_CH_LAYOUT_STEREO, dst_ch_layout = AV_CH_LAYOUT_SURROUND;
    // 设置src和dst采样率

    int src_rate = , dst_rate = ;

    uint8_t **src_data = NULL, **dst_data = NULL;

    int src_nb_channels = , dst_nb_channels = ;

    int src_linesize, dst_linesize;

    int src_nb_samples = , dst_nb_samples, max_dst_nb_samples;
    // 设置src和dst音频格式

    enum AVSampleFormat src_sample_fmt = AV_SAMPLE_FMT_DBL, dst_sample_fmt = AV_SAMPLE_FMT_S16;

    const char *dst_filename = NULL;

    FILE *dst_file;

    int dst_bufsize;

    const char *fmt;
    // 重采样上下文，包含resample信息

    struct SwrContext *swr_ctx;

    double t;

    int ret;

    if (argc != ) {

        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[]);

        exit();

    }
    // resample后的数据保存到本地文件

    dst_filename = argv[];

    dst_file = fopen(dst_filename, "wb");

    if (!dst_file) {

        fprintf(stderr, "Could not open destination file %s\n", dst_filename);

        exit();

    }

    /* 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 */

    // 将resample信息写入resample上下文
    av_opt_set_int(swr_ctx, "in_channel_layout",    src_ch_layout, );

    av_opt_set_int(swr_ctx, "in_sample_rate",       src_rate, );

    av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt", src_sample_fmt, );

    av_opt_set_int(swr_ctx, "out_channel_layout",    dst_ch_layout, );

    av_opt_set_int(swr_ctx, "out_sample_rate",       dst_rate, );

    av_opt_set_sample_fmt(swr_ctx, "out_sample_fmt", dst_sample_fmt, );

    /* initialize the resampling context */

    if ((ret = swr_init(swr_ctx)) < ) {

        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, );

    if (ret < ) {

        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);

    /* 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, );

    if (ret < ) {

        fprintf(stderr, "Could not allocate destination samples\n");

        goto end;

    }

    t = ;

    do {

        /* generate synthetic audio */
        // 这里是自行生成源数据帧，实际工程中应该将解码后的PCM数据填入src_data中

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

        /* compute destination number of samples */

        dst_nb_samples = av_rescale_rnd(swr_get_delay(swr_ctx, src_rate) +

                                        src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);

        if (dst_nb_samples > max_dst_nb_samples) {

            av_freep(&dst_data[]);

            ret = av_samples_alloc(dst_data, &dst_linesize, dst_nb_channels,

                                   dst_nb_samples, dst_sample_fmt, );

            if (ret < )

                break;

            max_dst_nb_samples = dst_nb_samples;

        }

        /* convert to destination format */

        // 重采样操作
        ret = swr_convert(swr_ctx, dst_data, dst_nb_samples, (const uint8_t **)src_data, src_nb_samples);

        if (ret < ) {

            fprintf(stderr, "Error while converting\n");

            goto end;

        }

        dst_bufsize = av_samples_get_buffer_size(&dst_linesize, dst_nb_channels,

                                                 ret, dst_sample_fmt, );

        if (dst_bufsize < ) {

            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[], , dst_bufsize, dst_file);

    } while (t < );

    if ((ret = get_format_from_sample_fmt(&fmt, dst_sample_fmt)) < )

        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[]);

    av_freep(&src_data);

    if (dst_data)

        av_freep(&dst_data[]);

    av_freep(&dst_data);

    swr_free(&swr_ctx);

    return ret < ;

}