如何用FFmpeg API采集摄像头视频和麦克风音频，并实现录制文件的功能

电玩女神 2023-07-14 05:59 5阅读 0赞

[https://blog.csdn.net/zhoubotong2012/article/details/79338093][https_blog.csdn.net_zhoubotong2012_article_details_79338093]

之前一直用Directshow技术采集摄像头数据，但是觉得涉及的细节比较多，要开发者比较了解Directshow的框架知识，学习起来有一点点难度。最近发现很多人问怎么用FFmpeg采集摄像头图像，事实上FFmpeg很早就支持通过DShow获取采集设备（摄像头、麦克风）的数据了，只是网上提供的例子比较少。如果能用FFmpeg实现采集、编码和录制（或推流），那整个实现方案就简化很多，正因为这个原因，我想尝试做一个FFmpeg采集摄像头视频和麦克风音频的程序。经过一个星期的努力，终于做出来了。我打算把开发的心得和经验分享给大家。我分三部分来讲述：首先第一部分介绍如何用FFmpeg的官方工具（ffmpeg.exe）通过命令行来枚举DShow设备和采集摄像头图像，这部分是基础，能够快速让大家熟悉怎么用FFmpeg测试摄像头采集；第二部分介绍我写的采集程序的功能和用法；第三部分讲解各个模块包括采集、编码、封装和录制是如何实现的。

（该例子代码的下载地址：http://download.csdn.net/download/zhoubotong2012/10252187）

1.用命令行枚举采集设备和采集数据  
打开Cmd命令行控制台，进入FFmpeg的Bin目录，输入如下命令：

ffmpeg -list\_devices true -f dshow -i dummy

则在我的机器上显示如下结果：

在上面的命令行窗口中列出了两个设备，一个是视频采集设备，另外是一个音频采集设备。另外，我们发现：音频设备的名称有乱码，因为其中有中文名称，后面在讲到用API采集数据的时候会提到解决这个问题的方法。

接着我们输入另外一个命令行：

ffmpeg -list\_options true -f dshow -i video="USB 2861 Device"

这个命令行的作用是获取指定视频采集设备支持的分辨率、帧率和像素格式等属性，返回的是一个列表，结果如下：

这里我们看到采集设备支持的最大分辨率是720x576，输出像素格式是yuyv422，支持的帧率为29.97和25FPS。

下面我们执行另外一条命令，将摄像头的图像和麦克风的音频录制保存成一个文件。命令如下：

ffmpeg -f dshow -i video="USB 2861 Device" -f dshow -i audio="线路 (3- USB Audio Device)" -vcodec libx264 -acodec aac -strict -2 mycamera.mkv

上面的命令行用video=指定视频设备，用audio=指定音频设备，后面的参数是定义编码器的格式和属性，输出为一个名为mycamera.mkv的文件。

命令运行之后，控制台打印FFmpeg的运行日志，按“Q”键则中止命令。

这里有些读者可能会问：采集设备不是支持多个分辨率吗？怎么设置采集时用哪一种分辨率输出？答案是用“-s”参数设置，若在上面的命令行加上“-s 720x576”，则FFmpeg就会以720x576的分辨率进行采集，如果不设置，则以默认的分辨率输出。

注意：如果你运行上面命令ffmpeg报如下错误：Could not run filter

Video=XXX:Input/output error

则说明该版本的ffmpeg不支持该采集设备。这是由于旧版本的FFmpeg一个Bug引起的，不支持需要连接crossbar连接的视频采集设备（详情可参考这个帖子：https://ffmpeg.zeranoe.com/forum/viewtopic.php?t=722）。如果读者运行下面的Demo遇到打开视频采集设备失败,可能也是这个问题引起的. 新版本的FFmpeg（avdevice-58）修复了这个问题。所以如果你遇到这个问题，可以通过升级FFmpeg来解决。

好，关于命令行的内容就介绍完了。

2.采集程序的使用  
这个程序叫“AVCapture”，能从视频采集设备（摄像头，采集卡）获取图像，支持图像预览；还可以采集麦克风音频；支持对视频和音频编码，支持录制成文件。这是一个MFC开发的窗口程序，界面比较简洁，如下图：

开始采集前需要选择设备，点击文件菜单的“打开设备”，弹出一个设备选择对话框，如下图所示：

在对话框里选择任意一个视频设备和音频设备，如果想启用某种设备，必须勾选右边的“启用”选项，但如果只需要用其中一种采集设备，则可以把其中一个禁用掉。

按“确定”则开始采集数据了。视频和音频会编码后保存到一个文件中，这个文件的路径是在配置文件中设置的，打开程序目录下的Config.ini文件，则显示如下字段：

\[Client\]

file\_path = D:\\camera.mkv

File\_path就是录制文件的路径。

采集的图像默认显示到中间的窗口中，如果不想预览，可以在主菜单栏的“编辑”菜单中取消勾选“预览视频”。

3.功能模块实现  
该采集程序实现了枚举采集设备，采集控制、显示图像、视频/音频编码和录制的功能，其中输入（Input）、输出（Output）和显示（Paint）这三个模块分别用一个单独的类进行封装：CAVInputStream，CAVOutputStream，CImagePainter。CAVInputStream负责从采集设备获取数据，提供接口获取采集设备的属性，以及提供回调函数把数据传给上层。CAVOutputStream负责对采集的视频和音频流进行编码、封装，保存成一个文件。而CImagePainter则用来显示图像，使用了GDI绘图，把图像显示到主界面的窗口。

3.1 枚举采集设备

采集前我们需要先选择设备，把所有的设备名称列出来，其中一个方法可以用第一节介绍的运行ffmpeg命令行工具来列举，但是这样有两个问题：第一，假如设备名称带中文，则显示的名称有乱码，因此，我们不知道它真实的名称。第二，ffmpeg没有API返回系统中安装的采集设备列表，虽然FFmpeg提供了API把设备名称列举出来，但是是打印到控制台的，不是通过参数来返回，如下面这段代码只能打印输出结果到控制台。但是对于窗口界面程序，没有控制台，怎么获取命令行结果呢？

AVFormatContext \*pFmtCtx = avformat\_alloc\_context();  
AVDictionary\* options = NULL;  
av\_dict\_set(&options, "list\_devices", "true", 0);  
AVInputFormat \*iformat = av\_find\_input\_format("dshow");  
//printf("Device Info=============\\n");  
avformat\_open\_input(&pFmtCtx, "video=dummy", iformat, &options);  
//printf("========================\\n");  
我用了一种最传统的做法来解决，就是通过Directshow的COM接口来枚举设备，工程里面的EnumDevice接口就实现了枚举设备的功能，函数原型如下：

//枚举指定类型的所有采集设备的名称  
ENUMDEVICE\_API HRESULT EnumDevice(CAPTURE\_DEVICE\_TYPE type, char \* deviceList\[\], int nListLen, int & iNumCapDevices);  
当然，如果读者用的采集设备是固定一种，那么可以固定采集设备的名称，这样做可以省点事。

3.2 注册FFmpeg库

av\_register\_all();  
avdevice\_register\_all();  
这两个API可以在程序的构造函数和窗口初始化里面调用。

3.3 打开输入设备

首先需要指定采集设备的名称。如果是视频设备类型，则名称以“video=”开头；如果是音频设备类型，则名称以“audio=”开头。调用avformat\_open\_input接口打开设备，将设备名称作为参数传进去，注意这个设备名称需要转成UTF-8编码。然后调用avformat\_find\_stream\_info获取流的信息，得到视频流或音频流的索引号，之后会频繁用到这个索引号来定位视频和音频的Stream信息。接着，调用avcodec\_open2打开视频解码器或音频解码器，实际上，我们可以把设备也看成是一般的文件源，而文件一般采用某种封装格式，要播放出来需要进行解复用，分离成裸流，然后对单独的视频流、音频流进行解码。虽然采集出来的图像或音频都是未编码的，但是按照FFmpeg的常规处理流程，我们需要加上“解码”这个步骤。

int i;  
m\_pInputFormat = av\_find\_input\_format("dshow");  
ASSERT(m\_pInputFormat != NULL);  
  
if(!m\_video\_device.empty())  
\{  
int res = 0;  
  
string device\_name = "video=" + m\_video\_device;  
  
string device\_name\_utf8 = AnsiToUTF8(device\_name.c\_str(), device\_name.length()); //转成UTF-8，解决设备名称包含中文字符出现乱码的问题  
  
//Set own video device's name  
if ((res = avformat\_open\_input(&m\_pVidFmtCtx, device\_name\_utf8.c\_str(), m\_pInputFormat, &device\_param)) != 0)  
\{  
ATLTRACE("Couldn't open input video stream.（无法打开输入流）\\n");  
return false;  
\}  
//input video initialize  
if (avformat\_find\_stream\_info(m\_pVidFmtCtx, NULL) < 0)  
\{  
ATLTRACE("Couldn't find video stream information.（无法获取流信息）\\n");  
return false;  
\}  
m\_videoindex = -1;  
for (i = 0; i < m\_pVidFmtCtx->nb\_streams; i++)  
\{  
if (m\_pVidFmtCtx->streams\[i\]->codec->codec\_type == AVMEDIA\_TYPE\_VIDEO)  
\{  
m\_videoindex = i;  
break;  
\}  
\}  
  
if (m\_videoindex == -1)  
\{  
ATLTRACE("Couldn't find a video stream.（没有找到视频流）\\n");  
return false;  
\}  
if (avcodec\_open2(m\_pVidFmtCtx->streams\[m\_videoindex\]->codec, avcodec\_find\_decoder(m\_pVidFmtCtx->streams\[m\_videoindex\]->codec->codec\_id), NULL) < 0)  
\{  
ATLTRACE("Could not open video codec.（无法打开解码器）\\n");  
return false;  
\}  
\}  
  
//  
  
if(!m\_audio\_device.empty())  
\{  
string device\_name = "audio=" + m\_audio\_device;  
  
string device\_name\_utf8 = AnsiToUTF8(device\_name.c\_str(), device\_name.length()); //转成UTF-8，解决设备名称包含中文字符出现乱码的问题  
  
//Set own audio device's name  
if (avformat\_open\_input(&m\_pAudFmtCtx, device\_name\_utf8.c\_str(), m\_pInputFormat, &device\_param) != 0)\{  
  
ATLTRACE("Couldn't open input audio stream.（无法打开输入流）\\n");  
return false;  
\}  
  
//input audio initialize  
if (avformat\_find\_stream\_info(m\_pAudFmtCtx, NULL) < 0)  
\{  
ATLTRACE("Couldn't find audio stream information.（无法获取流信息）\\n");  
return false;  
\}  
m\_audioindex = -1;  
for (i = 0; i < m\_pAudFmtCtx->nb\_streams; i++)  
\{  
if (m\_pAudFmtCtx->streams\[i\]->codec->codec\_type == AVMEDIA\_TYPE\_AUDIO)  
\{  
m\_audioindex = i;  
break;  
\}  
\}  
if (m\_audioindex == -1)  
\{  
ATLTRACE("Couldn't find a audio stream.（没有找到音频流）\\n");  
return false;  
\}  
if (avcodec\_open2(m\_pAudFmtCtx->streams\[m\_audioindex\]->codec, avcodec\_find\_decoder(m\_pAudFmtCtx->streams\[m\_audioindex\]->codec->codec\_id), NULL) < 0)  
\{  
ATLTRACE("Could not open audio codec.（无法打开解码器）\\n");  
return false;  
\}  
\}  
3.4 初始化输出流

前面我们已经初始化了InputStream，现在需要对OutputStream进行初始化，而要初始化输出流需要知道视频采集的分辨率，帧率，输出像素格式等信息，还有音频采集设备的采样率，声道数，Sample格式，而这些信息可通过CAVInputStream类的接口来获取到。下面是初始化OutputStream的代码：

m\_InputStream.SetVideoCaptureCB(VideoCaptureCallback);  
m\_InputStream.SetAudioCaptureCB(AudioCaptureCallback);  
  
bool bRet;  
bRet = m\_InputStream.OpenInputStream(); //初始化采集设备  
if(!bRet)  
\{  
MessageBox(\_T("打开采集设备失败"), \_T("提示"), MB\_OK|MB\_ICONWARNING);  
return 1;  
\}  
  
int cx, cy, fps;  
AVPixelFormat pixel\_fmt;  
if(m\_InputStream.GetVideoInputInfo(cx, cy, fps, pixel\_fmt)) //获取视频采集源的信息  
\{  
m\_OutputStream.SetVideoCodecProp(AV\_CODEC\_ID\_H264, fps, 500000, 100, cx, cy); //设置视频编码器属性  
\}  
  
int sample\_rate = 0, channels = 0;  
AVSampleFormat sample\_fmt;  
if(m\_InputStream.GetAudioInputInfo(sample\_fmt, sample\_rate, channels)) //获取音频采集源的信息  
\{  
m\_OutputStream.SetAudioCodecProp(AV\_CODEC\_ID\_AAC, sample\_rate, channels, 32000); //设置音频编码器属性  
\}  
  
//从Config.INI文件中读取录制文件路径  
P\_GetProfileString(\_T("Client"), "file\_path", m\_szFilePath, sizeof(m\_szFilePath));  
  
bRet = m\_OutputStream.OpenOutputStream(m\_szFilePath); //设置输出路径  
if(!bRet)  
\{  
MessageBox(\_T("初始化输出失败"), \_T("提示"), MB\_OK|MB\_ICONWARNING);  
return 1;  
\}  
在上面的代码片段中，首先设置了视频和音频的数据回调函数。当采集开始时，视频和音频数据就会传递给相应的函数去处理，在该程序中，回调函数主要对图像或音频进行编码，然后封装成FFmpeg支持的容器（例如mkv/avi/mpg/ts/mp4）。另外，需要初始化OutputStream的VideoCodec和AudioCodec的属性，在我的程序中，视频编码器是H264，音频编码器用AAC，通过CAVInputStream对象获得输入流的信息之后再赋值给输出流相应的参数。最后调用m\_OutputStream对象的OpenOutputStream成员函数打开编码器和录制的容器，其中我们需要传入一个输出文件路径作为参数，这个为录制的文件路径，路径是在Config.ini文件里配置的。如果OpenOutputStream函数返回true，则表示初始化输出流成功。

3.5 读取采集数据

接着，我们就可以开始采集了。开始采集的函数实现如下：

bool CAVInputStream::StartCapture()  
\{  
if (m\_videoindex == -1 && m\_audioindex == -1)  
\{  
ATLTRACE("错误：你没有打开设备\\n");  
return false;  
\}  
  
m\_start\_time = av\_gettime();  
  
m\_exit\_thread = false;  
  
if(!m\_video\_device.empty())  
\{  
m\_hCapVideoThread = CreateThread(  
NULL, // default security attributes  
0, // use default stack size  
CaptureVideoThreadFunc, // thread function name  
this, // argument to thread function  
0, // use default creation flags  
NULL); // returns the thread identifier  
\}  
  
if(!m\_audio\_device.empty())  
\{  
m\_hCapAudioThread = CreateThread(  
NULL, // default security attributes  
0, // use default stack size  
CaptureAudioThreadFunc, // thread function name  
this, // argument to thread function  
0, // use default creation flags  
NULL); // returns the thread identifier  
\}  
  
return true;  
\}  
StartCapture函数分别建立了一个读取视频包和读取音频包的线程，两个线程各自独立工作，分别从视频采集设备，音频采集设备获取到数据，然后进行后续的处理。（注意：两个线程同时向一个文件写数据可能会有同步的问题，FFmpeg内部可能没有做多线程安全访问的处理，所以最好在自己线程里加一个锁进行互斥，从而保护临界区的安全）

其中，读取摄像头数据的线程的处理代码如下：

DWORD WINAPI CAVInputStream::CaptureVideoThreadFunc(LPVOID lParam)  
\{  
CAVInputStream \* pThis = (CAVInputStream\*)lParam;  
  
pThis->ReadVideoPackets();  
  
return 0;  
\}  
  
int CAVInputStream::ReadVideoPackets()  
\{  
if(dec\_pkt == NULL)  
\{  
prepare before decode and encode  
dec\_pkt = (AVPacket \*)av\_malloc(sizeof(AVPacket));  
\}  
  
int encode\_video = 1;  
int ret;  
  
//start decode and encode  
  
while (encode\_video)  
\{  
if (m\_exit\_thread)  
break;  
  
AVFrame \* pframe = NULL;  
if ((ret = av\_read\_frame(m\_pVidFmtCtx, dec\_pkt)) >= 0)  
\{  
pframe = av\_frame\_alloc();  
if (!pframe)  
\{  
ret = AVERROR(ENOMEM);  
return ret;  
\}  
int dec\_got\_frame = 0;  
ret = avcodec\_decode\_video2(m\_pVidFmtCtx->streams\[dec\_pkt->stream\_index\]->codec, pframe, &dec\_got\_frame, dec\_pkt);  
if (ret < 0)  
\{  
av\_frame\_free(&pframe);  
av\_log(NULL, AV\_LOG\_ERROR, "Decoding failed\\n");  
break;  
\}  
if (dec\_got\_frame)  
\{  
if(m\_pVideoCBFunc)  
\{  
CAutoLock lock(&m\_WriteLock);  
  
m\_pVideoCBFunc(m\_pVidFmtCtx->streams\[dec\_pkt->stream\_index\], m\_pVidFmtCtx->streams\[m\_videoindex\]->codec->pix\_fmt, pframe, av\_gettime() - m\_start\_time);  
\}  
  
av\_frame\_free(&pframe);  
\}  
else  
\{  
av\_frame\_free(&pframe);  
\}  
  
av\_free\_packet(dec\_pkt);  
\}  
else  
\{  
if (ret == AVERROR\_EOF)  
encode\_video = 0;  
else  
\{  
ATLTRACE("Could not read video frame\\n");  
break;  
\}  
\}  
\}  
  
return 0;  
\}  
在CAVInputStream::ReadVideoPackets()函数中不停地调用 av\_read\_frame读取采集到的图像帧，接着调用avcodec\_decode\_video2进行“解码”，这样获得了原始的图像，图像可能是RGB或YUV格式。解码后的图像通过m\_pVideoCBFunc指向的回调函数回调给上层处理，回调函数里可进行后续的一些操作，比如对视频帧编码或直接显示。

3.6 编码、封装成文件

CAVInputStream的工作线程里面读取到的视频帧和音频包通过回调函数传给CAVOuputStream类去处理。下面是两个回调函数的实现：

//采集到的视频图像回调  
LRESULT CALLBACK VideoCaptureCallback(AVStream \* input\_st, enum PixelFormat pix\_fmt, AVFrame \*pframe, INT64 lTimeStamp)  
\{  
if(gpMainFrame->IsPreview())  
\{  
gpMainFrame->m\_Painter.Play(input\_st, pframe);  
\}  
  
gpMainFrame->m\_OutputStream.write\_video\_frame(input\_st, pix\_fmt, pframe, lTimeStamp);  
return 0;  
\}  
  
//采集到的音频数据回调  
LRESULT CALLBACK AudioCaptureCallback(AVStream \* input\_st, AVFrame \*pframe, INT64 lTimeStamp)  
\{  
gpMainFrame->m\_OutputStream.write\_audio\_frame(input\_st, pframe, lTimeStamp);  
return 0;  
\}  
视频回调函数调用了CAVOutputStream的成员函数write\_video\_frame，这个函数对传入的图像帧进行编码（H264），并且写到指定的封装文件；而音频回调函数则调用了CAVOutputStream的另外一个成员函数write\_audio\_frame，这个函数负责对音频编码（AAC），然后输出到指定的封装文件。下面是Write\_video\_frame函数的实现代码：

//input\_st -- 输入流的信息  
//input\_frame -- 输入视频帧的信息  
//lTimeStamp -- 时间戳，时间单位为/1000000  
//  
int CAVOutputStream::write\_video\_frame(AVStream \* input\_st, enum PixelFormat pix\_fmt, AVFrame \*pframe, INT64 lTimeStamp)  
\{  
if(video\_st == NULL)  
return -1;  
  
//ATLTRACE("Video timestamp: %ld \\n", lTimeStamp);  
  
if(m\_first\_vid\_time1 == -1)  
\{  
TRACE("First Video timestamp: %ld \\n", lTimeStamp);  
m\_first\_vid\_time1 = lTimeStamp;  
\}  
  
AVRational time\_base\_q = \{ 1, AV\_TIME\_BASE \};  
  
if(img\_convert\_ctx == NULL)  
\{  
//camera data may has a pix fmt of RGB or sth else,convert it to YUV420  
img\_convert\_ctx = sws\_getContext(m\_width, m\_height,  
pix\_fmt, pCodecCtx->width, pCodecCtx->height, PIX\_FMT\_YUV420P, SWS\_BICUBIC, NULL, NULL, NULL);  
\}  
  
sws\_scale(img\_convert\_ctx, (const uint8\_t\* const\*)pframe->data, pframe->linesize, 0, pCodecCtx->height, pFrameYUV->data, pFrameYUV->linesize);  
pFrameYUV->width = pframe->width;  
pFrameYUV->height = pframe->height;  
pFrameYUV->format = PIX\_FMT\_YUV420P;  
  
enc\_pkt.data = NULL;  
enc\_pkt.size = 0;  
av\_init\_packet(&enc\_pkt);  
  
int ret;  
int enc\_got\_frame = 0;  
ret = avcodec\_encode\_video2(pCodecCtx, &enc\_pkt, pFrameYUV, &enc\_got\_frame);  
  
if (enc\_got\_frame == 1)  
\{  
//printf("Succeed to encode frame: %5d\\tsize:%5d\\n", framecnt, enc\_pkt.size);  
  
if(m\_first\_vid\_time2 == -1)  
\{  
m\_first\_vid\_time2 = lTimeStamp;  
\}  
  
enc\_pkt.stream\_index = video\_st->index;  
  
//enc\_pkt.pts= av\_rescale\_q(lTimeStamp, time\_base\_q, video\_st->time\_base);  
enc\_pkt.pts = (INT64)video\_st->time\_base.den \* lTimeStamp/AV\_TIME\_BASE;  
  
m\_vid\_framecnt++;  
  
ret = av\_interleaved\_write\_frame(ofmt\_ctx, &enc\_pkt);  
if(ret < 0)  
\{  
char tmpErrString\[128\] = \{0\};  
ATLTRACE("Could not write video frame, error: %s\\n", av\_make\_error\_string(tmpErrString, AV\_ERROR\_MAX\_STRING\_SIZE, ret));  
av\_packet\_unref(&enc\_pkt);  
return ret;  
\}  
  
av\_free\_packet(&enc\_pkt);  
\}  
else if(ret == 0)  
\{  
ATLTRACE("Buffer video frame, timestamp: %I64d.\\n", lTimeStamp); //编码器缓冲帧  
\}  
  
return 0;  
\}  
Write\_video\_frame和write\_audio\_frame是CAVOutputStream的两个很重要的函数，其中对音频包的处理略为复杂一些，主要是因为输入的音频和编码后的音频的frame\_size不一样，中间需要一个Fifo作缓冲队列。另外时间戳PTS的计算也是很关键的，弄得不好保存的文件播放视音频就不同步了，具体怎么实现你们看代码吧。

工程的代码下载地址：点击打开链接

（补充说明：有些网友下载了工程反映例子在Win7，Win10系统上运行不了，这是因为枚举设备列表的EnumDevice.dll没有编译成Release版造成的，可以从我的另外一个资源里下载这个库的代码或已编译生成的DLL。）

（如果你觉得本文章写得不错，请点赞一下！）

————————————————  
版权声明：本文为CSDN博主「zhoubotong2012」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。  
原文链接：https://blog.csdn.net/zhoubotong2012/article/details/79338093

[https_blog.csdn.net_zhoubotong2012_article_details_79338093]: https://blog.csdn.net/zhoubotong2012/article/details/79338093