音频处理基本概念及音频重采样

左手的ㄟ右手 2022-11-14 14:45 425阅读 0赞

# 音频处理基本概念及音频重采样 #

--------------------

# 目录 #

1.  重点问题
2.  重采样
    
    1.  什么是重采样
    2.  为什么要重采样
    3.  可调节的参数
3.  对应参数解析
    
    1.  采样率
    2.  采样格式及量化精度（位宽）
    3.  分⽚（plane）和打包（packed）
    4.  声道分布（channel\_layout)
    5.  ⾳频帧的数据量计算
    6.  ⾳频播放时间计算
4.  FFmpeg重采样API
5.  ⾳频重采样⼯程范例
    
    1.  简单范例（resample）
    2.  复杂范例

--------------------

### 1. 重点问题 ###

1.  如何进⾏重采样
2.  采样率不⼀样的时候pts怎么处理
3.  官⽅参考⽂档：[http://ffmpeg.org/doxygen/trunk/group\_\_lswr.html][http_ffmpeg.org_doxygen_trunk_group_lswr.html]

--------------------

### 2. 重采样 ###

#### 1. 什么是重采样 ####

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

#### 2. 为什么要重采样 ####

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

#### 3. 可调节的参数 ####

1.  通过重采样，我们可以对：
    
    1.  sample rate(采样率)
    2.  sample format(采样格式)
    3.  channel layout(通道布局，可以通过此参数获取声道数

--------------------

### 3. 对应参数解析 ###

#### 1. 采样率 ####

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

#### 2. 采样格式及量化精度（位宽） ####

1.  每种⾳频格式有不同的量化精度（位宽），位数越多，表示值就越精确，声⾳表现⾃然就越精准。FFMpeg中⾳频格式有以下⼏种，每种格式有其占⽤的字节数信息（libavutil/samplefmt.h）：

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

#### 3. 分⽚（plane）和打包（packed） ####

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

#### 4. 声道分布（channel\_layout) ####

1.  声道分布在FFmpeg\\libavutil\\channel\_layout.h中有定义，⼀般来说⽤的⽐较多的是AV\_CH\_LAYOUT\_STEREO（双声道）和AV\_CH\_LAYOUT\_SURROUND（三声道），这两者的定义如下：

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

#### 5. ⾳频帧的数据量计算 ####

1.  ⼀帧⾳频的数据量（字节）=channel数 \* nb\_samples样本数 \* 每个样本占⽤的字节数
2.  如果该⾳频帧是FLTP格式的PCM数据，包含1024个样本，双声道，那么该⾳频帧包含的⾳频数据量是2*1024*4=8192字节。
3.  AV\_SAMPLE\_FMT\_DBL ： 2*1024*8 = 16384

#### 6. ⾳频播放时间计算 ####

1.  以采样率44100Hz来计算，每秒44100个sample，⽽正常⼀帧为1024个sample，可知每帧播放时间/1024=1000ms/44100，得到每帧播放时间=1024\*1000/44100=23.2ms （更精确的是23.21995464852608）。
2.  ⼀帧播放时间（毫秒） = 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

--------------------

### 4. FFmpeg重采样API ###

1.  分配⾳频重采样的上下⽂

struct SwrContext *swr_alloc(void);

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

int swr_init(struct SwrContext *s);

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

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

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

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

1.  返回值 <= out\_count
2.  in和in\_count可以设置为0，以最后刷新最后⼏个样本。
3.  释放掉SwrContext结构体并将此结构体置为NULL;

void swr_free(struct SwrContext **s);

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

SwrContext *swr = swr_alloc();
    av_opt_set_channel_layout(swr, "in_channel_layout", AV_CH_LAYOUT_5POINT1, 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);

1.  同样的⼯作也可以使⽤swr\_alloc\_set\_opts（）：

SwrContext *swr = swr_alloc_set_opts(NULL, // we're allocating anew 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

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

--------------------

### 5. ⾳频重采样⼯程范例 ###

#### 1. 简单范例（resample） ####

/*
     * 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 = "/Users/lijinwang/Downloads/course/study/believe.pcm";
    
        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);
    
        /* 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);
        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("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;
    }

#### 2. 复杂范例 ####

1.  比较多就不上传了

[http_ffmpeg.org_doxygen_trunk_group_lswr.html]: http://ffmpeg.org/doxygen/trunk/group__lswr.html