结论

  • 采集的pcm可以播放，但是编码aac后不能播放
  • 采用的是aac编码器编码，aac编码器需要的是AV_SAMPLE_FMT_FLTP位深才能进行编码，windows下采集到的数据是AV_SAMPLE_FMT_S16，所以需要重采样
  • 编码出来的aac数据没有adts头，在编码一帧的aac数据后，自己添加了adts头（adts头里包含采样率、编码格式、声道数）
  • 因为在pcm采集声道数据的时候，每次从函数av_read_frame(fmt_ctx, pkt)读取到的pcm的大小都是88200，而编码器每次编码需要的数据大小是4096，所以在采集完数据后做了分包处理

代码

  2. #include <iostream>
  3. //#include <WinBase.h>
  5. #define __STDC_CONSTANT_MACROS
  7. extern "C"
  8. {
  9. #include "libavutil/avutil.h"
  10. #include "libavcodec/avcodec.h"
  11. #include "libavdevice/avdevice.h"
  12. #include "libswscale/swscale.h"
  13. #include "libswresample/swresample.h"
  14. #include "libavutil\samplefmt.h"
  15. #include <stdio.h>
  16. #include <strsafe.h>
  17. #include <string.h>
  18. }
  20. #ifdef _MSC_VER
  21. #include <tchar.h>
  22. #include <dshow.h>
  23. #include <atlcomcli.h>
  24. #pragma comment(lib, "Strmiids.lib")
  25. #endif
  27. using namespace std;
  29. void Convert(const char* strIn, char* strOut, int sourceCodepage, int targetCodepage)
  30. {
  31.     //LPCTSTR
  32.     LPCTSTR pStr = (LPCTSTR)strIn;
  33.     int len = lstrlen(pStr);
  34.     int unicodeLen = MultiByteToWideChar(sourceCodepage, 0, strIn, -1, NULL, 0);
  35.     wchar_t* pUnicode = NULL;
  36.     pUnicode = new wchar_t[unicodeLen + 1];
  37.     memset(pUnicode, 0, (unicodeLen + 1) * sizeof(wchar_t));
  38.     MultiByteToWideChar(sourceCodepage, 0, strIn, -1, (LPWSTR)pUnicode, unicodeLen);
  40.     BYTE* pTargetData = NULL;
  41.     int targetLen = WideCharToMultiByte(targetCodepage, 0, (LPWSTR)pUnicode, -1, (char*)pTargetData, 0, NULL, NULL);
  43.     pTargetData = new BYTE[targetLen + 1];
  44.     memset(pTargetData, 0, targetLen + 1);
  45.     WideCharToMultiByte(targetCodepage, 0, (LPWSTR)pUnicode, -1, (char*)pTargetData, targetLen, NULL, NULL);
  46.     lstrcpy((LPSTR)strOut, (LPCSTR)pTargetData);
  48.     delete pUnicode;
  49.     delete pTargetData;
  50. }
  52. void Get_Capture_Audio_Devices_Info(char* name)
  53. {
  55. #ifdef _MSC_VER
  56.     CoInitialize(NULL);
  57.     CComPtr<ICreateDevEnum> pCreateDevEnum;
  58.     HRESULT hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER, IID_ICreateDevEnum, (void**)&pCreateDevEnum);
  59.     CComPtr<IEnumMoniker> pEm;
  60.     hr = pCreateDevEnum->CreateClassEnumerator(CLSID_AudioInputDeviceCategory, &pEm, 0);
  61.     if (hr != NOERROR) {
  62.         return;
  63.     }
  64.     pEm->Reset();
  65.     ULONG cFetched;
  66.     IMoniker* pM = NULL;
  67.     while (hr = pEm->Next(1, &pM, &cFetched), hr == S_OK)
  68.     {
  69.         IPropertyBag* pBag = 0;
  70.         hr = pM->BindToStorage(0, 0, IID_IPropertyBag, (void**)&pBag);
  71.         if (SUCCEEDED(hr))
  72.         {
  73.             VARIANT var;
  74.             var.vt = VT_BSTR;
  75.             hr = pBag->Read(L"FriendlyName", &var, NULL); //还有其他属性,像描述信息等等...
  76.             if (hr == NOERROR)
  77.             {
  78.                 //获取设备名称
  79.                 WideCharToMultiByte(CP_ACP, 0, var.bstrVal, -1, name, 128, "", NULL);
  80.                 SysFreeString(var.bstrVal);
  81.             }
  82.             pBag->Release();
  83.         }
  84.         pM->Release();
  85.     }
  87.     pCreateDevEnum = NULL;
  88.     pEm = NULL;
  89. #else
  90.     memcpy(name, "default", strlen("default") + 1);
  91. #endif
  93. }
  95. // 判断编码器是否支持某个采样格式(采样大小)
  96. static int check_sample_fmt(const AVCodec* codec, enum AVSampleFormat sample_fmt)
  97. {
  98.     const enum AVSampleFormat* p = codec->sample_fmts;
  100.     while (*p != AV_SAMPLE_FMT_NONE) {
  101.         printf("*p :%s\n", av_get_sample_fmt_name(*p));
  102.         if (*p == sample_fmt)
  103.             return 1;
  104.         p++;
  105.     }
  106.     return 0;
  107. }
  109. // 从编码器中获取采样率(从编码器所支持的采样率中获取与44100最接近的采样率)
  110. static int select_sample_rate(const AVCodec* codec)
  111. {
  112.     const int* p;
  113.     int best_samplerate = 0;
  115.     if (!codec->supported_samplerates)
  116.         return 44100;
  118.     p = codec->supported_samplerates;
  119.     while (*p) {
  120.         if (!best_samplerate || abs(44100 - *p) < abs(44100 - best_samplerate))
  121.             best_samplerate = *p;
  122.         p++;
  123.     }
  124.     return best_samplerate;
  125. }
  127. /* select layout with the highest channel count */
  128. static int select_channel_layout(const AVCodec* codec)
  129. {
  130.     const uint64_t* p;
  131.     uint64_t best_ch_layout = 0;
  132.     int best_nb_channels = 0;
  134.     if (!codec->channel_layouts)
  135.         return AV_CH_LAYOUT_STEREO;
  137.     p = codec->channel_layouts;
  138.     while (*p) {
  139.         int nb_channels = av_get_channel_layout_nb_channels(*p);
  141.         if (nb_channels > best_nb_channels) {
  142.             best_ch_layout = *p;
  143.             best_nb_channels = nb_channels;
  144.         }
  145.         p++;
  146.     }
  147.     return (int)best_ch_layout;
  148. }
  150. int main()
  151. {
  152.     AVFormatContext* fmt_ctx = NULL;
  153.     AVDictionary* options = NULL;
  155.     int ret = 0;
  156.     char errors[1024] = { 0 };
  157.     char device_name[256] = {0};
  158.     char file_name[256] = "collection.aac";
  159.     char file_name_pcm[256] = "pltf_collection.pcm";
  160.     char name[128] = { 0 };
  161.     char name_utf8[128] = { 0 };
  162.     FILE* out_file = NULL;
  164.     /*音频重采样参数*/ //播放指令 ffplay -ar 44100 -f f32le -channels 2 -i collection.pcm
  165.     AVPacket* pkt = NULL;
  166.     int dst_rate = 44100, src_rate = 44100;
  167.     uint8_t** src_data = NULL, ** dst_data = NULL;
  168.     int64_t src_ch_layout = AV_CH_LAYOUT_STEREO, dst_ch_layout = AV_CH_LAYOUT_STEREO;
  169.     enum AVSampleFormat src_sample_fmt = AV_SAMPLE_FMT_S16, dst_sample_fmt = AV_SAMPLE_FMT_FLTP;
  170.     int src_nb_channels = 0, dst_nb_channels = 0;
  171.     int src_linesize, dst_linesize;
  172.     int src_nb_samples = 1024, dst_nb_samples, max_dst_nb_samples;
  173.     int dst_bufsize = 0;
  175.     /*音频编码参数*/
  176.     int got_output;
  177.     AVCodec* codec; // 编码器
  178.     AVCodecContext* codec_context = NULL; // 编码上下文环境
  179.     AVFrame* frame; // 原始帧
  180.     AVPacket enpkt;   // 编码后的包数据
  182.     av_register_all();
  183.     avdevice_register_all();
  185.     AVInputFormat* in_format = av_find_input_format("dshow");
  186.     if (in_format == NULL)
  187.     {
  188.         printf("av_find_input_format error\n");
  189.     }
  191.     //设置输入的字体，没有这部分会报错 //Immediate exit requested
  192.     Get_Capture_Audio_Devices_Info(name);
  193.     Convert(name, name_utf8, CP_ACP, CP_UTF8);
  194.     sprintf(device_name, "audio=%s", name_utf8);
  195.     printf("device_name:%s\n", device_name);
  197.     if ((ret = avformat_open_input(&fmt_ctx, device_name, in_format, NULL)) != 0)
  198.     {
  199.         av_strerror(ret, errors, 1024);
  200.         printf("Failed to open video device, [%s][%d]\n", errors, ret);
  201.         return -1;
  202.     }
  205.     pkt = av_packet_alloc(); //pkt存放采集的pcm数据
  206.     av_init_packet(pkt);
  208.     out_file = fopen(file_name, "wb+");
  211.    /*添加音频重采样----start----*/
  212.    SwrContext* swr_ctx = NULL;
  213.    //第一个参数，如果之前有设置好的重采样上下文可以传入，如果没有就传入NULL；
  214.    //2.输出的channel, nunber/layout(一种布局参数,就是把扬声器放置在哪个位置)
  215.    //3.输出的采样位数
  216.    //4.输出的采样频率
  217.    //5.输入的采样通道
  218.    //6.输入的采样位数
  219.    //7.输入的采样频率
  220.    //最后两个是个日志相关的，设成0和NULL就可以了
  221.    swr_ctx = swr_alloc_set_opts(NULL,
  222.        dst_ch_layout, dst_sample_fmt, dst_rate,
  223.        src_ch_layout, src_sample_fmt, src_rate,
  224.        0, NULL);
  225.    if (!swr_ctx)
  226.    {
  227.        return -1;
  228.    }
  230.    /* initialize the resampling context */
  231.    if ((ret = swr_init(swr_ctx)) < 0) 
  232.    {
  233.        fprintf(stderr, "Failed to initialize the resampling context\n");
  234.        return -1;
  235.    }
  237.    //创建输入缓冲区
  238.    src_nb_channels = av_get_channel_layout_nb_channels(src_ch_layout);
  239.    printf("src_nb_channels:%d\n", src_nb_channels);
  240.    ret = av_samples_alloc_array_and_samples(
  241.        &src_data, //输入缓冲区地址
  242.        &src_linesize, //缓冲区大小
  243.        src_nb_channels, //通道个数
  244.        src_nb_samples, //单通道采样个数 number of samples per channel
  245.        src_sample_fmt, //采样格式
  246.        0);
  247.    if (ret < 0) {
  248.        fprintf(stderr, "Could not allocate source samples\n");
  249.        return -1;
  250.    }
  251.    printf("src_linesize:%d\n", src_linesize);
  253.    //创建输出缓冲区
  254.    max_dst_nb_samples = dst_nb_samples = av_rescale_rnd(src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);
  255.    dst_nb_channels = av_get_channel_layout_nb_channels(dst_ch_layout);
  256.    printf("max_dst_nb_samples:%d  dst_nb_samples:%d\n", max_dst_nb_samples, dst_nb_samples);
  257.    ret = av_samples_alloc_array_and_samples(
  258.        &dst_data, //输出缓冲区地址
  259.        &dst_linesize, //缓冲区大小
  260.        dst_nb_channels, //通道个数
  261.        dst_nb_samples, //单通道采样个数 number of samples per channel
  262.        dst_sample_fmt, //采样格式
  263.        0);
  264.    if (ret < 0) 
  265.    {
  266.        fprintf(stderr, "Could not allocate destination samples\n");
  267.        return -1;
  268.    }
  269.    printf("src_linesize:%d dst_linesize:%d \n", src_linesize, dst_linesize);
  270.    /*添加音频重采样----end----*/
  272.     /*音频编码设置------start-----*/
  273.     //1、找到aac的编码器
  274.     codec = avcodec_find_encoder_by_name("aac");
  275.     if (!codec) 
  276.     {
  277.         fprintf(stderr, "Codec not found\n");
  278.         return -1;
  279.     }
  281.     //2、创建编码器的上下文
  282.     codec_context = avcodec_alloc_context3(codec);
  283.     if (!codec_context) 
  284.     {
  285.         fprintf(stderr, "Could not allocate audio codec context\n");
  286.         exit(1);
  287.     }
  289.     //3、设置上下文格式
  290.     codec_context->profile = FF_PROFILE_AAC_SSR;
  291.     codec_context->bit_rate = 128000;
  292.     codec_context->sample_fmt = dst_sample_fmt;
  293.     if (!check_sample_fmt(codec, codec_context->sample_fmt)) 
  294.     {
  295.         fprintf(stderr, "Encoder does not support sample format %s",
  296.             av_get_sample_fmt_name(codec_context->sample_fmt));
  297.         return -1;
  298.     }
  299.     // 设置采样率，这里通过函数获取，也可以直接写具体值
  300.     codec_context->sample_rate = dst_rate;//select_sample_rate(codec);
  301.     // channel_layout为各个通道存储顺序，可以据此算出声道数。设置声道数也可以直接写具体值
  302.     codec_context->channel_layout = select_channel_layout(codec);
  303.     codec_context->channels = av_get_channel_layout_nb_channels(codec_context->channel_layout);
  304.     //codec_context->frame_size = dst_nb_samples + 1024;
  305.     printf("codec_context->channels:%d \n", codec_context->channels);
  307.     //3、打开编码器
  308.     if (avcodec_open2(codec_context, codec, NULL) < 0)
  309.     {
  310.         fprintf(stderr, "Could not open codec\n");
  311.         exit(1);
  312.     }
  313.     int encode_nb_sample = codec_context->frame_size;
  315.     printf(" 1111  codec_context->frame_size:%d\n", codec_context->frame_size);
  317.     //4、 初始化原始帧
  318.     frame = av_frame_alloc();
  319.     if (!frame) 
  320.     {
  321.         fprintf(stderr, "Could not allocate audio frame\n");
  322.         exit(1);
  323.     }
  325.     //5、设置帧的参数
  326.     printf("codec_context->frame_size:%d\n", dst_nb_samples);
  327.     frame->nb_samples = encode_nb_sample;
  328.     // frame的格式和声道信息
  329.     printf("codec_context->sample_fmt:%s\n", av_get_sample_fmt_name(codec_context->sample_fmt));
  330.     frame->format = codec_context->sample_fmt;
  331.     printf("codec_context->channel_layout:%d\n", codec_context->channel_layout);
  332.     frame->channel_layout = codec_context->channel_layout;
  333.     frame->sample_rate = dst_rate;
  336.     /* allocate the data buffers */
  337.     ret = av_frame_get_buffer(frame, 0);
  338.     if (ret < 0) 
  339.     {
  340.         fprintf(stderr, "Could not allocate audio data buffers\n");
  341.         exit(1);
  342.     }
  343.     printf("frame->linesize[0]:%d\n", frame->linesize[0]);
  346.     //复制参数、写头信息
  347.     //AVStream* st = avformat_new_stream(fmt_ctx, codec);
  348.     //avcodec_parameters_from_context(st->codecpar, codec_context);
  349.     //vformat_write_header(fmt_ctx, NULL);
  351.     printf("frame->linesize[0]:%d \n", frame->linesize[0]);
  352.     /*音频编码设置------end------*/
  355.     av_dump_format(fmt_ctx, 0, device_name, 0);
  357.     while (!av_read_frame(fmt_ctx, pkt))
  358.     {
  359.         printf("%d\n", pkt->size);
  361.         /*音频重采样  start*/
  362.         /* compute destination number of samples */
  363.         dst_nb_samples = av_rescale_rnd(swr_get_delay(swr_ctx, src_rate) +
  364.             src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);
  366.         printf("------ src_nb_samples:%d \n", dst_nb_samples);
  367.         if (dst_nb_samples > max_dst_nb_samples)
  368.         {
  369.             av_freep(&dst_data[0]);
  370.             ret = av_samples_alloc(dst_data, &dst_linesize, dst_nb_channels,
  371.                 dst_nb_samples, dst_sample_fmt, 1);
  372.             if (ret < 0)
  373.                 break;
  374.             max_dst_nb_samples = dst_nb_samples;
  375.         }
  376.         printf("Size of collected data %d\n", pkt->size);
  378.         //src_data是一个缓冲区数组，只用到第一个缓冲区，所以用0
  381.         static int offset = 0;
  382.         int use_size = 0;
  383.         while (use_size < pkt->size)
  384.         {
  385.             if (offset)
  386.             {
  388.             }
  389.             if (use_size + src_linesize + offset > pkt->size)
  390.             {
  391.                 offset = pkt->size - use_size;
  392.                 memset(src_data[0], 0, src_linesize);
  393.                 memcpy(src_data[0], pkt->data + use_size, offset);
  394.                 break;
  395.             }
  396.             if (offset)
  397.             { 
  398.                 printf("=====================use_size:%d src_linesize-offset:%d pkt->size:%d", use_size, src_linesize - offset, pkt->size);
  400.                 memcpy(src_data[0]+offset, pkt->data + use_size, src_linesize-offset);
  401.                 use_size += (src_linesize - offset);
  402.                 offset = 0;
  403.             }
  404.             else
  405.             {
  406.                 memset(src_data[0], 0, src_linesize);
  407.                 printf("********************** use_size:%d pkt->size:%d src_linesize:%d\n\n", use_size, pkt->size, src_linesize);
  408.                 memcpy(src_data[0], pkt->data + use_size, src_linesize);
  409.                 use_size += src_linesize;
  410.             }
  412.             printf("ffffffffffff dst_nb_samples:%d src_nb_samples:%d\n", dst_nb_samples, src_nb_samples);
  413.             //ret = swr_convert(swr_ctx, dst_data, dst_nb_samples, (const uint8_t**)src_data, src_nb_samples);
  414.             ret = swr_convert(swr_ctx, frame->data, frame->nb_samples, (const uint8_t**)src_data, src_nb_samples);
  415.             if (ret < 0)
  416.             {
  417.                 fprintf(stderr, "Error while converting\n");
  418.                 return -1;
  419.             }
  421. //            dst_bufsize = av_samples_get_buffer_size(&dst_linesize, dst_nb_channels,
  422. //                ret, dst_sample_fmt, 0);
  423. //            if (dst_bufsize < 0)
  424. //            {
  425. //                fprintf(stderr, "Could not get sample buffer size\n")
  426. //                return -1;
  427. //            }
  429.             //fwrite(dst_data[0], 1, dst_bufsize, out_file);
  430.             //fwrite(dst_data[1], 1, dst_bufsize, out_file);
  431.             //fflush(out_file);
  432.             printf("ssss   dst_bufsize:%d frame->linesize[0]:%d\n", dst_bufsize, frame->linesize[0]);
  433.             /*音频重采样  end*/
  436.            av_init_packet(&enpkt);
  437.            enpkt.data = NULL;
  438.            enpkt.size = 0;
  439.            //memcpy(frame->data[0], dst_data[0], dst_bufsize/2);
  440.            //memcpy(frame->data[1], dst_data[0]+ dst_bufsize / 2, dst_bufsize / 2);
  441.            ret = avcodec_send_frame(codec_context, frame);
  442.            while (ret >= 0)
  443.            {
  444.                ret = avcodec_receive_packet(codec_context, &enpkt);
  445.                if (ret == -EAGAIN)
  446.                {
  447.                    continue;
  448.                }
  449.                else if (ret < 0)
  450.                {
  451.                    printf("avcodec_receive_packet error! [%d]\n", ret);
  452.                    return -1;
  453.                }
  454.                else
  455.                {
  456.                    printf("enpkt.size:%d\n", enpkt.size);
  457.                    unsigned char aac_buffer[7] = { 0 };
  458.                    printf("\n\n\ncodec_context->profile:%d\n", codec_context->profile);
  459.                    int profile = codec_context->profile; // AAC LC
  460.                    int freqIdx = 4; // 44100
  461.                    //int channels = 2;// 声道数
  462.                    int chanCfg = 1; // CPE
  464.                //   // fill in ADTS data
  465.                //   aac_buffer[0] = (byte)0xFF;
  466.                //   aac_buffer[1] = (byte)0xF0;
  467.                //   aac_buffer[2] = (byte)(((profile&0x3) << 6) + (freqIdx&0xf << 2) + (chanCfg >> 2));
  468.                //   aac_buffer[3] = (byte)(((chanCfg & 3) << 6) + (enpkt.size >> 11));
  469.                //   aac_buffer[4] = (byte)((enpkt.size & 0x7FF) >> 3);
  470.                //   aac_buffer[5] = (byte)(((enpkt.size & 7) << 5) + 0x1F);
  471.                //   aac_buffer[6] = (byte)0xFC;
  472.                    aac_buffer[0] = (byte)0xFF;
  473.                    aac_buffer[1] = (byte)0xF1;
  474.                    //aac_buffer[2] = (byte)(((profile - 1) << 6) + (freqIdx << 2) + (chanCfg >> 2));
  475.                    //aac_buffer[3] = (byte)(((chanCfg & 3) << 6) + (enpkt.size >> 11));
  476.                    aac_buffer[2] = 0x50;
  477.                    aac_buffer[3] = 0x80;
  478.                    aac_buffer[4] = (byte)((enpkt.size & 0x7FF) >> 3);
  479.                    aac_buffer[5] = (byte)(((enpkt.size & 7) << 5) + 0x1F);
  480.                    aac_buffer[6] = (byte)0xFC;
  482.                    fwrite(aac_buffer, 1, 7, out_file);
  484.                    fwrite(enpkt.data, 1, enpkt.size, out_file);
  485.                    fflush(out_file);
  486.                }
  487.            }
  489.         }
  491.         printf("dst_nb_samples:%d src_nb_samples:%d frame->nb_samples:%d\n", dst_nb_samples, src_nb_samples, frame->nb_samples);
  493. #if 0
  494.         ret = swr_convert(swr_ctx, dst_data, dst_nb_samples, (const uint8_t**)src_data, src_nb_samples);
  495.         if (ret < 0)
  496.         {
  497.             fprintf(stderr, "Error while converting\n");
  498.             return -1;
  499.         }
  501.         dst_bufsize = av_samples_get_buffer_size(&dst_linesize, dst_nb_channels,
  502.             ret, dst_sample_fmt, 1);
  503.         if (dst_bufsize < 0)
  504.         {
  505.             fprintf(stderr, "Could not get sample buffer size\n");
  506.             return -1;
  507.         }
  508.         /*音频重采样  end*/
  510.         /*音频编码 start*/
  511.         av_init_packet(&enpkt);
  512.         enpkt.data = NULL;
  513.         enpkt.size = 0;
  514.         ret = avcodec_send_frame();
  516.         while (ret >= 0)
  517.         {
  518.             ret = avcodec_receive_packet(codec_context, &enpkt);
  519.             if (ret < 0)
  520.             {
  521.                 printf("avcodec_receive_packet error!\n");
  522.                 return -1;
  523.             }
  525.             ret = av_write_frame(fmt_ctx, &enpkt);
  526.             av_packet_unref(&enpkt);
  527.         }
  528.         av_write_trailer(fmt_ctx);
  530.         /*音频编码 end*/
  532.         printf("enpkt.size:%d\n", enpkt.size);
  533.         //fwrite(dst_data[0], 1, dst_bufsize, out_file);
  534.         //fflush(out_file)
  535. #endif
  536.         ;  
  537.         av_packet_unref(pkt);
  538.     }
  540.     swr_free(&swr_ctx);
  541.     av_packet_free(&pkt);
  542.     avformat_close_input(&fmt_ctx);
  543.     fclose(out_file);
  545.     //avcodec_send_frame
  547.     // ffplay -video_size 640*480 -pixel_format yuyv422 -framerate 30 collection.yuv
  548.     return 0;
  549. }