使用FFmpeg进行摄像头视频采集

之前用directshow做视频采集，虽然可以通过预览窗口进行视频预览，但是灵活性不好，无法对视频数据进行其他编码等（当时尝试过很多次，没成功

 ），现在使用FFmpeg进行采集视频，主要是可以对视频进行再编码，操作比较方便。下面附上主要部分的源代码：

 #include "video.h"

videoMgr::videoMgr()

{

m_url = "";

m_shortName = "";

CoInitialize(NULL);

}

videoMgr::~videoMgr()

{

clearVideoFrames(m_RGBFrames);

clearVideoFrames(m_YUVFrames);

CoUninitialize();

}

void videoMgr::VFWCapture(int nVideoID)

{

}

void videoMgr::dshowCapture(const char *videoName)

{

}

void videoMgr::dshowDeviceOption()

{

AVFormatContext *pFormatCtx = avformat_alloc_context();

AVDictionary* options = NULL;

av_dict_set(&options, "list_options", "true", 0);

AVInputFormat *iformat = av_find_input_format("dshow");

printf("\n=====Device Option Info=====\n");

avformat_open_input(&pFormatCtx, "video=Integrated Camera", iformat, &options);

}

void videoMgr::dshowDevice()

{

AVFormatContext *pFormatCtx = avformat_alloc_context();

AVDictionary* options = NULL;

av_dict_set(&options,"list_devices","true",0);

AVInputFormat *iformat = av_find_input_format("dshow");

printf("\n=====dshow Device Info======\n");

avformat_open_input(&pFormatCtx,"video=dummy", iformat, &options);

}

void videoMgr::VFWDevice()

{

AVFormatContext *pFormatCtx = avformat_alloc_context();

AVInputFormat *iformat = av_find_input_format("vfwcap");

printf("\n=====VFW Device Info========\n");

avformat_open_input(&pFormatCtx, "list", iformat, NULL);

}

int videoMgr::EnumDevices()

{

ICreateDevEnum *pDevEnum = NULL;

CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER, IID_ICreateDevEnum, (void **)&pDevEnum);

if(pDevEnum == NULL)

return 0;

ULONG cFetched = 0;

IMoniker *pMoniker = NULL;

IEnumMoniker *pClassEnum = NULL;

pDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory, &pClassEnum, 0);

if(pClassEnum == NULL)

return 0;

while(pClassEnum->Next(1, &pMoniker, &cFetched) == S_OK)     

{

IPropertyBag* pProp= NULL;

pMoniker->BindToStorage(0, 0, IID_IPropertyBag, (void**)&pProp);

if(pProp != NULL)

{

VARIANT varName;

varName.vt = VT_BSTR;

pProp->Read(L"FriendlyName", &varName, 0);

char name[MAX_PATH] = {0};

unicode_ansi(name, MAX_PATH, varName.bstrVal);

string str(name);

m_videoNames.push_back(str);

VariantClear(&varName);

pProp->Release();

}

pMoniker->Release();

pMoniker = NULL;

}

pClassEnum->Release();

pDevEnum->Release();

return m_videoNames.size();

}

void scaleCov(AVPicture* src, int srcFmt, int srcW, int srcH, AVPicture* dst, int dstFmt, int dstW, int dstH)

{

SwsContext* m_pSws = sws_getContext(srcW, srcH, (AVPixelFormat)srcFmt, dstW, dstH, (AVPixelFormat)dstFmt, SWS_BICUBIC, NULL, NULL, NULL);

int res = sws_scale(m_pSws, src->data, src->linesize, 0, srcH, dst->data, dst->linesize);

sws_freeContext(m_pSws);

}

DWORD WINAPI videoMgr::startCapping(void *param)

{

videoMgr *This = (videoMgr*)param;

AVFormatContext *pFormatCtx;

AVCodecContext  *pCodecCtx;

AVCodec         *pCodec;

av_register_all();

avformat_network_init();

pFormatCtx = avformat_alloc_context();

//Register Device

avdevice_register_all();

AVInputFormat *ifmt=av_find_input_format(This->m_shortName.c_str());

if(avformat_open_input(&pFormatCtx, This->m_url.c_str(), ifmt, NULL) != 0)

{

printf("Couldn't open input stream.\n");

return -1;

}

if(avformat_find_stream_info(pFormatCtx, NULL)<0)

{

printf("Couldn't find stream information.\n");

return -1;

}

int videoindex = -1;

for(int i=0; i<pFormatCtx->nb_streams; i++) 

{

if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO)

{

videoindex = i;

break;

}

}

if(videoindex == -1)

{

printf("Couldn't find a video stream.\n");

return -1;

}

pCodecCtx = pFormatCtx->streams[videoindex]->codec;

pCodec = avcodec_find_decoder(pCodecCtx->codec_id);

if(pCodec == NULL)

{

printf("Codec not found.\n");

return -1;

}

if(avcodec_open2(pCodecCtx, pCodec,NULL)<0)

{

printf("Could not open codec.\n");

return -1;

}

int ret, got_picture;

av_dump_format(pFormatCtx,0,NULL,0);

#if OUTPUT_YUV420P

FILE *fp_yuv=fopen("output.yuv","wb+");

#endif

while(1) 

{

AVPacket packet;

av_init_packet(&packet);

if(av_read_frame(pFormatCtx, &packet)>=0)

{

if(packet.stream_index == videoindex)

{

AVFrame *m_pVideoFrame = av_frame_alloc();

ret = avcodec_decode_video2(pCodecCtx, m_pVideoFrame, &got_picture, &packet);

if(ret < 0)

{

printf("Decode Error.\n");

return -1;

}

if(got_picture)

{

MediaFrame forEncFrm = {0};

static AVRational time_base = {1, 1000};

if(m_pVideoFrame->pkt_pts == AV_NOPTS_VALUE)

m_pVideoFrame->pkt_pts = m_pVideoFrame->pkt_dts;

forEncFrm.pts = av_rescale_q(m_pVideoFrame->pkt_pts, pFormatCtx->streams[videoindex]->time_base, time_base);

forEncFrm.fmt = AV_PIX_FMT_BGR24;

forEncFrm.w = (m_pVideoFrame->width) & 0xFFFFFFF8;

forEncFrm.h = (m_pVideoFrame->height) & 0xFFFFFFF8;

AVFrame *YUVframe = av_frame_alloc();

if(m_pVideoFrame->format != AV_PIX_FMT_BGR24)

{

int numBytes = avpicture_get_size((AVPixelFormat)forEncFrm.fmt, forEncFrm.w, forEncFrm.h);

forEncFrm.buf.resize(numBytes*sizeof(char)); 

av_image_fill_arrays(YUVframe->data, YUVframe->linesize, (uint8_t*)forEncFrm.buf.data(), (AVPixelFormat)forEncFrm.fmt, forEncFrm.w, forEncFrm.h, 1);

scaleCov((AVPicture*)m_pVideoFrame, m_pVideoFrame->format, forEncFrm.w, forEncFrm.h, (AVPicture*)YUVframe, forEncFrm.fmt, forEncFrm.w, forEncFrm.h);

}else

{

forEncFrm.buf.append((char*)m_pVideoFrame->data[0]);

}

forEncFrm.size = forEncFrm.buf.size();

This->append2VideoBuf(forEncFrm, This->m_RGBFrames, This->m_uiFrmMutex);

av_frame_free(&YUVframe);

}

}

}

av_free_packet(&packet);

Sleep(40);

}

#if OUTPUT_YUV420P

fclose(fp_yuv);

#endif

avcodec_close(pCodecCtx);

avformat_close_input(&pFormatCtx);

return 0;

}

void videoMgr::showCurrentDevice(const string &curVideo)

{

if(m_videoNames.size() <= 0)

return;

bool bFind = false;

list<string>::iterator it = m_videoNames.begin();

for(; it != m_videoNames.end(); it++)

{

string &video = *it;

if(video.compare(curVideo) == 0)

{

string head = "video=";

m_url = head.append(video);

m_shortName = "dshow";

bFind = true;

break;

}

}

if(bFind)

{

startCapture();

}else

{

m_videoNames.clear();

EnumDevices();

showCurrentDevice(curVideo);

}

}

void videoMgr::append2VideoBuf(const MediaFrame &frm,  std::map<int64_t,MediaFrame> &buf, Mutex &mutex)

{

CLock locker(mutex);

buf[frm.pts] = frm;

}

bool videoMgr::getUIFrame(MediaFrame &frame)

{

if ( !getVideoData(frame, m_RGBFrames, m_uiFrmMutex) )

return false;

//实际界面显示的pts应为播放pts

m_playPTS = frame.pts;

return true;

}

void videoMgr::clearVideoFrames(std::map<int64_t, MediaFrame> &pkts)

{

if(pkts.size() <= 0)

return;

std::map<int64_t, MediaFrame>::iterator it=pkts.begin();

for(; it!=pkts.end();)

{

pkts.erase(it++);

}

pkts.clear();

}

bool videoMgr::getVideoData(MediaFrame &frame, std::map<int64_t,MediaFrame> &buf, Mutex &mutex)

{

frame.pts = -1;

CLock locker(mutex);

std::map<int64_t,MediaFrame>::iterator it; 

for(it=buf.begin(); it!=buf.end(); it++)

{

MediaFrame &itFrame = it->second;

frame = itFrame;

buf.erase(it++);

break;

}

return (frame.pts>=0);

}

int videoMgr::startCapture()

{

CreateThread(NULL, 0, startCapping, this, 0, NULL);

return 0;

}



附上效果截图：