ffmpeg获取运动矢量及显示

最近有个项目需要研究视频压缩域，主要对于运动矢量。获取运动矢量的各种算法比较复杂，发现ffmpeg可以直接获取，非常简便。

初学ffmpeg，雷霄骅大神的博客提供了非常大的帮助，http://blog.csdn.net/leixiaohua1020/article/details/15811977/。

下载ffmpeg源码，在doc/example下有extract_mvs.c文件 ，一个提取运动矢量简单例程。在vs2010编译，遇到一些麻烦，参考http://blog.csdn.net/leixiaohua1020/article/details/12747899，http://blog.csdn.net/leixiaohua1020/article/details/12029697。

关于运动矢量的显示，或者说原始帧数据的显示，雷神用的是SDL，这里使用的是opencv.

在源码基础上改的，图像bgr数据保存在pFrameRGB->data[0],这是关键。转为IplImage然后画出运动矢量，显示播放。

//#ifdef __cplusplus
//
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
using namespace std;

extern "C"
{
#include <libavutil/motion_vector.h>
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
#include "libswscale/swscale.h"

};
//#endif
//#pragma comment(lib,"avutil.lib")
//#pragma comment(lib,"avcodec.lib")
//#pragma comment(lib,"avformat.lib")

#include <cv.h>
#include <highgui.h>
using namespace std;

static AVFormatContext *fmt_ctx = NULL;
static AVCodecContext *video_dec_ctx = NULL;
static AVStream *video_stream = NULL;
static const char *src_filename = NULL;

static int video_stream_idx = -1;
static AVFrame *frame = NULL;
static AVFrame *pFrameRGB=NULL;
static AVPicture *pFrame=NULL;
static AVPacket pkt;
static int video_frame_count = 0;
static SwsContext *img_convert_ctx=NULL;
//FILE *output;
FILE *fp;
static IplImage *imgShow=NULL;
static IplImage *imgShow2=NULL;
static unsigned char* frameData=0;
typedef struct{
int mv_sx;
int mv_sy;
int mv_x;
int mv_y;
}MV_DATA;
const int K=3;

void uchar2IplImageBGR(unsigned char *inArrayCur, int img_w, int img_h,IplImage* pImg);

int img_w,img_h;
const int mbNum=131100;//1920*1080/16+1920/4*2+1080/4*2;

int num,nozero;
CvPoint p1,p2;
MV_DATA global_mv;
int j,k;
unsigned char *out_roi;
unsigned char *double_show1;
unsigned char *double_show2;
IplImage* roi_show=NULL;
IplImage* double_show =NULL;
unsigned char *gray_roi;
IplImage* ipl_gray_roi =NULL;

static int decode_packet(int *got_frame, int cached)
{
MV_DATA* mv_data=(MV_DATA*)malloc(mbNum*sizeof(MV_DATA));//读取运动矢量保存到mv_data中

num=0,nozero=0;
ave_x=0,ave_y=0;//平均值
out_roi=(unsigned char *)malloc(img_w*img_h);
roi_show=cvCreateImage(cvSize(img_w,img_h),IPL_DEPTH_8U,1);
double_show = cvCreateImage(cvSize(img_w*2,img_h),IPL_DEPTH_8U,3);
double_show1=(unsigned char *)malloc(img_w*img_h*3);
double_show2=(unsigned char *)malloc(img_w*img_h*3);
gray_roi=(unsigned char *)malloc(img_w*img_h);
ipl_gray_roi = cvCreateImage(cvSize(img_w,img_h),IPL_DEPTH_8U,1);

vector<MV_DATA> mv_datas;

for(int s=0;s<img_w*img_h;s++)
{
out_roi[s]=0;
}
int decoded = pkt.size;
*got_frame = 0;

if (pkt.stream_index == video_stream_idx) {
int ret = avcodec_decode_video2(video_dec_ctx, frame, got_frame, &pkt);
if (ret < 0) {
//fprintf(stderr, "Error decoding video frame (%s)\n", av_err2str(ret));
return ret;
}

if (*got_frame) {
int i;
AVFrameSideData *sd;

video_frame_count++;
sd = av_frame_get_side_data(frame, AV_FRAME_DATA_MOTION_VECTORS);
if (sd) {

img_convert_ctx = sws_getContext(video_dec_ctx->width, video_dec_ctx->height, video_dec_ctx->pix_fmt, video_dec_ctx->width, video_dec_ctx->height, AV_PIX_FMT_BGR24, SWS_BICUBIC, NULL, NULL, NULL);
sws_scale(img_convert_ctx, (const uint8_t* const*)frame->data, frame->linesize, 0, video_dec_ctx->height, pFrameRGB->data, pFrameRGB->linesize);
//fwrite(pFrameRGB->data[0],(video_dec_ctx->width)*(video_dec_ctx->height)*3,1,output);

//memcpy(frameData,pFrameRGB->data[0],video_dec_ctx->width*video_dec_ctx->height*3);
uchar2IplImageBGR(pFrameRGB->data[0],video_dec_ctx->width,video_dec_ctx->height,imgShow);
cvCopy(imgShow,imgShow2);
const AVMotionVector *mvs = (const AVMotionVector *)sd->data;

for (i = 0; i < sd->size / sizeof(*mvs); i++) {
const AVMotionVector *mv = &mvs[i];
//printf("%d,%2d,%2d,%2d,%4d,%4d,%4d,%4d,0x%"PRIx64"\n",
//video_frame_count, mv->source,
//mv->w, mv->h, mv->src_x, mv->src_y,

c159
//mv->dst_x, mv->dst_y);

p1.x=mv->src_x;
p1.y=mv->src_y;
p2.x=mv->dst_x;
p2.y=mv->dst_y;

cvLine(imgShow,p2,p2,cvScalar( 0,0,255 ),1,8,0);

}
cvShowImage("1",imgShow);
if(cvWaitKey(50)>=32)
cvWaitKey(0);
sws_freeContext(img_convert_ctx);
}
}
}
free(out_roi);
free(double_show1);
free(double_show2);
free(gray_roi);
cvReleaseImage(&roi_show);
cvReleaseImage(&double_show);
cvReleaseImage(&ipl_gray_roi);
free(mv_data);
mv_datas.clear();
return decoded;
}

static int open_codec_context(int *stream_idx,
AVFormatContext *fmt_ctx, enum AVMediaType type)
{
int ret;
AVStream *st;
AVCodecContext *dec_ctx = NULL;
AVCodec *dec = NULL;
AVDictionary *opts = NULL;

ret = av_find_best_stream(fmt_ctx, type, -1, -1, NULL, 0);
if (ret < 0) {
fprintf(stderr, "Could not find %s stream in input file '%s'\n",
av_get_media_type_string(type), src_filename);
return ret;
} else {
*stream_idx = ret;
st = fmt_ctx->streams[*stream_idx];

/* find decoder for the stream */
dec_ctx = st->codec;
dec = avcodec_find_decoder(dec_ctx->codec_id);
if (!dec) {
fprintf(stderr, "Failed to find %s codec\n",
av_get_media_type_string(type));
return AVERROR(EINVAL);
}

/* Init the video decoder */
av_dict_set(&opts, "flags2", "+export_mvs", 0);
if ((ret = avcodec_open2(dec_ctx, dec, &opts)) < 0) {
fprintf(stderr, "Failed to open %s codec\n",
av_get_media_type_string(type));
return ret;
}
}

return 0;
}

int main(int argc, char** argv)
{
int ret = 0, got_frame;
//string name;
//getline(cin,name,'\n');
src_filename = "1.mp4";
cvNamedWindow("1",0);
cvNamedWindow("2",0);

char motionname[] = "MV_Data.txt";
fp = fopen(motionname, "w");

av_register_all();

if (avformat_open_input(&fmt_ctx, src_filename, NULL, NULL) < 0) {
fprintf(stderr, "Could not open source file %s\n", src_filename);
exit(1);
}

if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
fprintf(stderr, "Could not find stream information\n");
exit(1);
}

if (open_codec_context(&video_stream_idx, fmt_ctx, AVMEDIA_TYPE_VIDEO) >= 0) {
video_stream = fmt_ctx->streams[video_stream_idx];
video_dec_ctx = video_stream->codec;
}

av_dump_format(fmt_ctx, 0, src_filename, 0);

if (!video_stream) {
fprintf(stderr, "Could not find video stream in the input, aborting\n");
ret = 1;
goto end;
}

frame = av_frame_alloc();
pFrameRGB=av_frame_alloc();

uint8_t *out_buffer;
out_buffer=new uint8_t[avpicture_get_size(AV_PIX_FMT_BGR24, video_dec_ctx->width, video_dec_ctx->height)];
avpicture_fill((AVPicture *)pFrameRGB, out_buffer, AV_PIX_FMT_BGR24, video_dec_ctx->width, video_dec_ctx->height);
imgShow = cvCreateImage(cvSize(video_dec_ctx->width,video_dec_ctx->height),IPL_DEPTH_8U,3);
imgShow2 = cvCreateImage(cvSize(video_dec_ctx->width,video_dec_ctx->height),IPL_DEPTH_8U,3);
frameData=(unsigned char *)malloc(video_dec_ctx->width*video_dec_ctx->height*3);
img_w=video_dec_ctx->width;
img_h=video_dec_ctx->height;

if (!frame) {
fprintf(stderr, "Could not allocate frame\n");
ret = AVERROR(ENOMEM);
goto end;
}

/* initialize packet, set data to NULL, let the demuxer fill it */
av_init_packet(&pkt);
pkt.data = NULL;
pkt.size = 0;

//output=fopen("out.rgb","wb+");
/* read frames from the file */
while (av_read_frame(fmt_ctx, &pkt) >= 0) {
AVPacket orig_pkt = pkt;
do {
ret = decode_packet(&got_frame, 0);
if (ret < 0)
break;
pkt.data += ret;
pkt.size -= ret;
} while (pkt.size > 0);
av_packet_unref(&orig_pkt);
}

/* flush cached frames */
pkt.data = NULL;
pkt.size = 0;
do {
decode_packet(&got_frame, 1);
} while (got_frame);

end:

//fclose(output);
fclose(fp);
avcodec_close(video_dec_ctx);
avformat_close_input(&fmt_ctx);
av_frame_free(&frame);
av_frame_free(&pFrameRGB);
cvReleaseImage(&imgShow);
free(frameData);
getchar();
return ret < 0;

}

void uchar2IplImageBGR(unsigned char *inArrayCur, int img_w, int img_h,IplImage* pImg)
{
int i,j;

for (i = 0; i < img_h; i++)
{
for (j = 0; j < img_w*3; j++)
{
*(pImg->imageData + i*pImg->widthStep+j)=inArrayCur[(i)*img_w*3+j] ;
}
}
}

后话：这是几个月前的东西，很多细节和遇到的问题都记不太清了。工作中很多知识没有总结，一段时间过后忘记了，跟没做过一样，没有任何进步，有时候想起来非常惋惜，这也是写博客的意义所在。不要找借口说工作太忙，其实就是懒！！