什么是音频重采样

将音频三元组（采样频率、采样位数和通道数）的值转换成另外一组值
例如：将44100/16/2 转成 48000/16/2

为什么要重采样

  • 从设备采集的音频数据和编码器要求的不一致

  • 扬声器要求的音频数据与要播放的音频数据不一致

    1.           |<---要求的不一致--->|                                |<---要求的不一致-->|<br />采集的数据（PCM）--------- 编码数据 ------ 解码数据（PCM）--------- 扬声器播放

如何知道是否需要进行重采样

  • 要了解音频设备的参数
    • 不同的平台都有设备管理，通过设备管理可以知道
  • 查看ffmpeg源码（最方便的），基本包含了所有的编解码器的实现

重采样的步骤

  • 创建重采样的上下文
  • 设置参数
  • 初始化重采样
  • 进行重采样

API

swr_alloc_set_opts 设置参数，返回上下文
swr_init
swr_convert
swr_free

  2. #include <iostream>
  4. #define __STDC_CONSTANT_MACROS
  6. extern "C"
  7. {
  8. #include "libavutil/avutil.h"
  9. #include "libavdevice/avdevice.h"
  10. #include "libswscale/swscale.h"
  11. #include "libswresample/swresample.h"
  12. #include "libavutil\samplefmt.h"
  13. #include <stdio.h>
  14. #include <strsafe.h>
  15. #include <string.h>
  16. }
  18. #ifdef _MSC_VER
  19. #include <tchar.h>
  20. #include <dshow.h>
  21. #include <atlcomcli.h>
  22. #pragma comment(lib, "Strmiids.lib")
  23. #endif
  25. using namespace std;
  27. void Convert(const char* strIn, char* strOut, int sourceCodepage, int targetCodepage)
  28. {
  29.     //LPCTSTR
  30.     LPCTSTR pStr = (LPCTSTR)strIn;
  31.     int len = lstrlen(pStr);
  32.     int unicodeLen = MultiByteToWideChar(sourceCodepage, 0, strIn, -1, NULL, 0);
  33.     wchar_t* pUnicode = NULL;
  34.     pUnicode = new wchar_t[unicodeLen + 1];
  35.     memset(pUnicode, 0, (unicodeLen + 1) * sizeof(wchar_t));
  36.     MultiByteToWideChar(sourceCodepage, 0, strIn, -1, (LPWSTR)pUnicode, unicodeLen);
  38.     BYTE* pTargetData = NULL;
  39.     int targetLen = WideCharToMultiByte(targetCodepage, 0, (LPWSTR)pUnicode, -1, (char*)pTargetData, 0, NULL, NULL);
  41.     pTargetData = new BYTE[targetLen + 1];
  42.     memset(pTargetData, 0, targetLen + 1);
  43.     WideCharToMultiByte(targetCodepage, 0, (LPWSTR)pUnicode, -1, (char*)pTargetData, targetLen, NULL, NULL);
  44.     lstrcpy((LPSTR)strOut, (LPCSTR)pTargetData);
  46.     delete pUnicode;
  47.     delete pTargetData;
  48. }
  50. void Get_Capture_Audio_Devices_Info(char* name)
  51. {
  53. #ifdef _MSC_VER
  54.     CoInitialize(NULL);
  55.     CComPtr<ICreateDevEnum> pCreateDevEnum;
  56.     HRESULT hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER, IID_ICreateDevEnum, (void**)&pCreateDevEnum);
  57.     CComPtr<IEnumMoniker> pEm;
  58.     hr = pCreateDevEnum->CreateClassEnumerator(CLSID_AudioInputDeviceCategory, &pEm, 0);
  59.     if (hr != NOERROR) {
  60.         return;
  61.     }
  62.     pEm->Reset();
  63.     ULONG cFetched;
  64.     IMoniker* pM = NULL;
  65.     while (hr = pEm->Next(1, &pM, &cFetched), hr == S_OK)
  66.     {
  67.         IPropertyBag* pBag = 0;
  68.         hr = pM->BindToStorage(0, 0, IID_IPropertyBag, (void**)&pBag);
  69.         if (SUCCEEDED(hr))
  70.         {
  71.             VARIANT var;
  72.             var.vt = VT_BSTR;
  73.             hr = pBag->Read(L"FriendlyName", &var, NULL); //还有其他属性,像描述信息等等...
  74.             if (hr == NOERROR)
  75.             {
  76.                 //获取设备名称
  77.                 WideCharToMultiByte(CP_ACP, 0, var.bstrVal, -1, name, 128, "", NULL);
  78.                 SysFreeString(var.bstrVal);
  79.             }
  80.             pBag->Release();
  81.         }
  82.         pM->Release();
  83.     }
  85.     pCreateDevEnum = NULL;
  86.     pEm = NULL;
  87. #else
  88.     memcpy(name, "default", strlen("default") + 1);
  89. #endif
  91. }
  93. int main()
  94. {
  95.     int ret = 0;
  97.     AVFormatContext* fmt_ctx = NULL;
  98.     AVDictionary* options = NULL;
  100.     char errors[1024] = { 0 };
  101.     char device_name[256] = {0};
  102.     char file_name[256] = "collection.pcm";
  103.     char name[128] = { 0 };
  104.     char name_utf8[128] = { 0 };
  106.     int dst_rate = 8000, src_rate = 44100;
  107.     uint8_t** src_data = NULL, ** dst_data = NULL;
  108.     int64_t src_ch_layout = AV_CH_LAYOUT_STEREO, dst_ch_layout = AV_CH_LAYOUT_SURROUND;
  109.     enum AVSampleFormat src_sample_fmt = AV_SAMPLE_FMT_S16, dst_sample_fmt = AV_SAMPLE_FMT_S16;
  110.     int src_nb_channels = 0, dst_nb_channels = 0;
  111.     int src_linesize, dst_linesize;
  112.     int src_nb_samples = 44100/2, dst_nb_samples, max_dst_nb_samples;
  113.     int dst_bufsize;
  115.     av_register_all();
  116.     avdevice_register_all();
  118.     AVInputFormat* in_format = av_find_input_format("dshow");
  119.     if (in_format == NULL)
  120.     {
  121.         printf("av_find_input_format error\n");
  122.     }
  124.     //设置输入的字体，没有这部分会报错 //Immediate exit requested
  125.     Get_Capture_Audio_Devices_Info(name);
  126.     Convert(name, name_utf8, CP_ACP, CP_UTF8);
  127.     sprintf(device_name, "audio=%s", name_utf8);
  128.     printf("device_name:%s\n", device_name);
  130.     if ((ret = avformat_open_input(&fmt_ctx, device_name, in_format, NULL)) != 0)
  131.     {
  132.         av_strerror(ret, errors, 1024);
  133.         printf("Failed to open video device, [%s][%d]\n", errors, ret);
  134.         return -1;
  135.     }
  138.     AVPacket* pkt = av_packet_alloc();
  139.     av_init_packet(pkt);
  140.     FILE* out_file = fopen(file_name, "wb+");
  142.     /*添加音频重采样----start----*/
  143.     SwrContext* swr_ctx = NULL;
  144.     //第一个参数，如果之前有设置好的重采样上下文可以传入，如果没有就传入NULL；
  145.     //2.输出的channel, nunber/layout(一种布局参数,就是把扬声器放置在哪个位置)
  146.     //3.输出的采样位数
  147.     //4.输出的采样频率
  148.     //5.输入的采样通道
  149.     //6.输入的采样位数
  150.     //7.输入的采样频率
  151.     //最后两个是个日志相关的，设成0和NULL就可以了
  152.     swr_ctx = swr_alloc_set_opts(swr_ctx,
  153.         dst_ch_layout, dst_sample_fmt, dst_rate,
  154.         src_ch_layout, src_sample_fmt, src_rate,
  155.         0, NULL);
  157.     if (!swr_ctx)
  158.     {
  159.         return -1;
  160.     }
  162.     /* initialize the resampling context */
  163.     if ((ret = swr_init(swr_ctx)) < 0) 
  164.     {
  165.         fprintf(stderr, "Failed to initialize the resampling context\n");
  166.         return -1;
  167.     }
  169.     //创建输入缓冲区
  170.     src_nb_channels = av_get_channel_layout_nb_channels(src_ch_layout);
  171.     printf("src_nb_channels:%d\n", src_nb_channels);
  172.     ret = av_samples_alloc_array_and_samples(
  173.         &src_data, //输入缓冲区地址
  174.         &src_linesize, //缓冲区大小
  175.         src_nb_channels, //通道个数
  176.         src_nb_samples, //单通道采样个数 number of samples per channel
  177.         src_sample_fmt, //采样格式
  178.         0);
  179.     if (ret < 0) {
  180.         fprintf(stderr, "Could not allocate source samples\n");
  181.         return -1;
  182.     }
  183.     printf("src_linesize:%d\n", src_linesize);
  185.     //创建输出缓冲区
  186.     max_dst_nb_samples = dst_nb_samples = av_rescale_rnd(src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);
  187.     dst_nb_channels = av_get_channel_layout_nb_channels(dst_ch_layout);
  189.     av_samples_alloc_array_and_samples(
  190.         &dst_data, //输出缓冲区地址
  191.         &dst_linesize, //缓冲区大小
  192.         dst_nb_channels, //通道个数
  193.         dst_nb_samples, //单通道采样个数 number of samples per channel
  194.         dst_sample_fmt, //采样格式
  195.         0);
  196.     if (ret < 0) {
  197.         fprintf(stderr, "Could not allocate destination samples\n");
  198.         return -1;
  199.     }
  200.     /*添加音频重采样----end----*/
  202.     av_dump_format(fmt_ctx, 0, device_name, 0);
  204.     while (!av_read_frame(fmt_ctx, pkt))
  205.     {
  206.         /* compute destination number of samples */
  207.         dst_nb_samples = av_rescale_rnd(swr_get_delay(swr_ctx, src_rate) +
  208.             src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);
  210.         if (dst_nb_samples > max_dst_nb_samples) 
  211.         {
  212.             av_freep(&dst_data[0]);
  213.             ret = av_samples_alloc(dst_data, &dst_linesize, dst_nb_channels,
  214.                 dst_nb_samples, dst_sample_fmt, 1);
  215.             if (ret < 0)
  216.                 break;
  217.             max_dst_nb_samples = dst_nb_samples;
  218.         }
  219.        printf("Size of collected data %d\n", pkt->size);
  221.         /*音频重采样*/ //src_data是一个缓冲区数组，只用到第一个缓冲区，所以用0
  222.         memset(src_data[0], 0, pkt->size);
  223.         memcpy(src_data[0], pkt->data, pkt->size);
  224.         printf("dst_nb_samples:%d src_nb_samples:%d\n", dst_nb_samples, src_nb_samples);
  226.         ret = swr_convert(swr_ctx, dst_data, dst_nb_samples, (const uint8_t**)src_data, src_nb_samples);
  227.         if (ret < 0) 
  228.         {
  229.             fprintf(stderr, "Error while converting\n");
  230.             return -1;
  231.         }
  233.         dst_bufsize = av_samples_get_buffer_size(&dst_linesize, dst_nb_channels,
  234.             ret, dst_sample_fmt, 1);
  235.         if (dst_bufsize < 0) 
  236.         {
  237.             fprintf(stderr, "Could not get sample buffer size\n");
  238.             return -1;
  239.         }
  241.         printf("dst_bufsize:%d\n", dst_bufsize);
  242.         fwrite(dst_data[0], 1, dst_bufsize, out_file);
  243.         fflush(out_file);
  244.         av_packet_unref(pkt);
  245.     }
  247.     swr_free(&swr_ctx);
  248.     av_packet_free(&pkt);
  249.     avformat_close_input(&fmt_ctx);
  250.     fclose(out_file);
  252.     // ffplay -video_size 640*480 -pixel_format yuyv422 -framerate 30 collection.yuv
  253.     return 0;
  254. }

问题总结

  • int av_samples_alloc_array_and_samples(uint8_t **audio_data, int linesize, int nb_channels,

    1.                                  int nb_samples, enum AVSampleFormat sample_fmt, int align);<br />函数功能：<br />为采样前后的pcm数据申请缓冲区<br />参数理解：<br />audio_data ----- 缓冲区地址<br />linesize --------- 申请的缓冲区大小。音频的额存放格式，如果是packed，则audio_data[0]存放所有的音频数据，如果是planar，则audio_data[i]存放i通道的音频数据<br />nb_channels ---- 通道个数<br />nb_samples ----- 单个通道的采样个数，因为在采样频率为44100的情况下，双通道采样pcm的输出数据大小为44100*2，故nb_samples  = 44100*2/位深(2个字节)/2(通道个个数)<br />sample_fmt ----- 采样格式<br />align ------------ 直接赋值0