700 lines
19 KiB
C++
700 lines
19 KiB
C++
|
/*
|
||
|
|
********************************************************************************
|
||
|
|
* eyesee framework module
|
||
|
|
*
|
||
|
|
* (c) Copyright 2010-2018, Allwinner Microelectronic Co., Ltd.
|
||
|
|
* All Rights Reserved
|
||
|
|
*
|
||
|
|
* File : EyeseeMotion.cpp
|
||
|
|
* Version: V1.0
|
||
|
|
* By : zing huang
|
||
|
|
* Date : 2018-06-28
|
||
|
|
* Description:
|
||
|
|
********************************************************************************
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <string.h>
|
||
|
|
#include <sys/stat.h>
|
||
|
|
#include <sys/types.h>
|
||
|
|
#include <unistd.h>
|
||
|
|
#include <fcntl.h>
|
||
|
|
|
||
|
|
|
||
|
|
#include <plat_log.h>
|
||
|
|
#include <mpi_sys.h>
|
||
|
|
#include <mpi_demux.h>
|
||
|
|
#include <mpi_venc.h>
|
||
|
|
#include <mpi_vdec.h>
|
||
|
|
#include <mpi_clock.h>
|
||
|
|
#include <ion_memmanager.h>
|
||
|
|
#include <cvt_color.h>
|
||
|
|
#include <aw_ai_mt.h>
|
||
|
|
|
||
|
|
#include <Clock_Component.h>
|
||
|
|
#include <EyeseeMotion.h>
|
||
|
|
|
||
|
|
namespace EyeseeLinux {
|
||
|
|
|
||
|
|
EyeseeMotion::EyeseeMotion():
|
||
|
|
mMotionTrailRet(-1)
|
||
|
|
{
|
||
|
|
mMotionHandle = NULL;
|
||
|
|
memset(&mImageYUV, 0, sizeof mImageYUV);
|
||
|
|
memset(&mImageBGR, 0, sizeof mImageBGR);
|
||
|
|
|
||
|
|
ClearConfig();
|
||
|
|
}
|
||
|
|
|
||
|
|
EyeseeMotion::~EyeseeMotion()
|
||
|
|
{
|
||
|
|
reset();
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t EyeseeMotion::setVideoFileSource(const char * url)
|
||
|
|
{
|
||
|
|
status_t opStatus;
|
||
|
|
if(0 == access(url, F_OK))
|
||
|
|
{
|
||
|
|
int fd = open(url, O_RDONLY);
|
||
|
|
if(fd < 0)
|
||
|
|
{
|
||
|
|
aloge("Failed to open file %s(%s)", url, strerror(errno));
|
||
|
|
return UNKNOWN_ERROR;
|
||
|
|
}
|
||
|
|
opStatus = setVideoFileSource(fd, 0, 0x7ffffffffffffffL);
|
||
|
|
close(fd);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
aloge("fatal error! open file path[%s] fail!", url);
|
||
|
|
opStatus = INVALID_OPERATION;
|
||
|
|
}
|
||
|
|
return opStatus;
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t EyeseeMotion::setVideoFileSource(int fd, int64_t offset, int64_t length)
|
||
|
|
{
|
||
|
|
Mutex::Autolock _l(mLock);
|
||
|
|
if(!(mCurrentState & MEDIA_MOTION_IDLE || mCurrentState == MEDIA_MOTION_STATE_ERROR))
|
||
|
|
{
|
||
|
|
aloge("called in wrong state %d", mCurrentState);
|
||
|
|
return INVALID_OPERATION;
|
||
|
|
}
|
||
|
|
|
||
|
|
ERRORTYPE ret;
|
||
|
|
bool nSuccessFlag = false;
|
||
|
|
|
||
|
|
//mDmxChnAttr.mStreamType = STREAMTYPE_LOCALFILE;
|
||
|
|
mDmxChnAttr.mSourceType = SOURCETYPE_FD;
|
||
|
|
mDmxChnAttr.mSourceUrl = NULL;
|
||
|
|
mDmxChnAttr.mFd = dup(fd);
|
||
|
|
mDmxChnAttr.mDemuxDisableTrack |= DEMUX_DISABLE_AUDIO_TRACK;
|
||
|
|
mDmxChnAttr.mDemuxDisableTrack |= DEMUX_DISABLE_SUBTITLE_TRACK;
|
||
|
|
mDmxChn = 0;
|
||
|
|
|
||
|
|
while(mDmxChn < DEMUX_MAX_CHN_NUM)
|
||
|
|
{
|
||
|
|
ret = AW_MPI_DEMUX_CreateChn(mDmxChn, &mDmxChnAttr);
|
||
|
|
if(SUCCESS == ret)
|
||
|
|
{
|
||
|
|
nSuccessFlag = TRUE;
|
||
|
|
alogd("create demux channel[%d] success!", mDmxChn);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
else if(ERR_DEMUX_EXIST == ret)
|
||
|
|
{
|
||
|
|
alogd("demux channel[%d] is exist, find next!", mDmxChn);
|
||
|
|
mDmxChn++;
|
||
|
|
}
|
||
|
|
else if(ERR_DEMUX_FILE_EXCEPTION == ret)
|
||
|
|
{
|
||
|
|
aloge("demux detect media file exception!");
|
||
|
|
return BAD_FILE;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
alogd("create demux channel[%d] ret[0x%x]!", mDmxChn, ret);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(false == nSuccessFlag)
|
||
|
|
{
|
||
|
|
mDmxChn = MM_INVALID_CHN;
|
||
|
|
aloge("fatal error! create demux channel fail!");
|
||
|
|
return UNKNOWN_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
ret = AW_MPI_DEMUX_GetMediaInfo(mDmxChn, &mMediaInfo);
|
||
|
|
if(SUCCESS == ret)
|
||
|
|
{
|
||
|
|
if( (mMediaInfo.mVideoNum > 0 && mMediaInfo.mVideoIndex >= mMediaInfo.mVideoNum)
|
||
|
|
|| (mMediaInfo.mAudioNum > 0 && mMediaInfo.mAudioIndex >= mMediaInfo.mAudioNum)
|
||
|
|
|| (mMediaInfo.mSubtitleNum > 0 && mMediaInfo.mSubtitleIndex >= mMediaInfo.mSubtitleNum)
|
||
|
|
)
|
||
|
|
{
|
||
|
|
alogd("fatal error, trackIndex wrong! [%d][%d],[%d][%d],[%d][%d]",
|
||
|
|
mMediaInfo.mVideoNum, mMediaInfo.mVideoIndex, mMediaInfo.mAudioNum, mMediaInfo.mAudioIndex, mMediaInfo.mSubtitleNum, mMediaInfo.mSubtitleIndex);
|
||
|
|
return UNKNOWN_ERROR;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return UNKNOWN_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
mCurrentState = MEDIA_MOTION_INITIALIZED;
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
std::shared_ptr<CMediaMemory> EyeseeMotion::getMotionJpeg(const MotionPictureParam &jpegParam)
|
||
|
|
{
|
||
|
|
Mutex::Autolock _l(mLock);
|
||
|
|
if(mCurrentState != MEDIA_MOTION_INITIALIZED)
|
||
|
|
{
|
||
|
|
aloge("called in error state 0x%x", mCurrentState);
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
mPictureWidth = jpegParam.mPicWidth;
|
||
|
|
mPictureHeight = jpegParam.mPicHeight;
|
||
|
|
mStartTimeMs = jpegParam.mStartTimeUs / 1000;
|
||
|
|
mSourceFrameNums = jpegParam.mSourceFrameNums;
|
||
|
|
mSourceFrameStep = jpegParam.mSourceFrameStep;
|
||
|
|
mObjectNums = jpegParam.mObjectNums;
|
||
|
|
|
||
|
|
if(!(mPictureWidth > 0 && mPictureHeight > 0))
|
||
|
|
{
|
||
|
|
aloge("fatal error! picturesize[%d, %d]", mPictureWidth, mPictureHeight);
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(mStartTimeMs > static_cast<int>(mMediaInfo.mDuration) || mStartTimeMs < 0)
|
||
|
|
{
|
||
|
|
aloge("fatal error, starttime[%d] ms!", mStartTimeMs);
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(mSourceFrameNums < 1 || mSourceFrameStep < 0)
|
||
|
|
{
|
||
|
|
aloge("fatal error, SourceFrameNums[%d], SourceFrameStep[%d]", mSourceFrameNums, mSourceFrameStep);
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
if(jpegParam.mTempBMPFileBasePath.empty())
|
||
|
|
{
|
||
|
|
mTempBMPFileBasePath = "./tmp_picture/";
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
mTempBMPFileBasePath = jpegParam.mTempBMPFileBasePath;
|
||
|
|
if(jpegParam.mTempBMPFileBasePath[jpegParam.mTempBMPFileBasePath.size() - 1] != '/')
|
||
|
|
{
|
||
|
|
mTempBMPFileBasePath += "/";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
prepare();
|
||
|
|
|
||
|
|
seekTo();
|
||
|
|
|
||
|
|
start();
|
||
|
|
|
||
|
|
getMotionTrail();
|
||
|
|
|
||
|
|
stop();
|
||
|
|
|
||
|
|
cvtBGR2YUV(&mImageBGR, &mImageYUV, PIXEL_FORMAT_YUV_PLANAR_420);
|
||
|
|
|
||
|
|
return PictureAsJpeg(mImageYUV);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
std::shared_ptr<CMediaMemory> EyeseeMotion::getMotionBMP(const MotionPictureParam &jpegParam)
|
||
|
|
{
|
||
|
|
#if 0
|
||
|
|
Mutex::Autolock _l(mLock);
|
||
|
|
if(mCurrentState != MEDIA_MOTION_INITIALIZED)
|
||
|
|
{
|
||
|
|
aloge("called in error state 0x%x", mCurrentState);
|
||
|
|
return INVALID_OPERATION;
|
||
|
|
}
|
||
|
|
|
||
|
|
mPictureWidth = picWidth;
|
||
|
|
mPictureHeight = picHeight;
|
||
|
|
mStartTimeMs = startTimeUs / 1000;
|
||
|
|
mSourceFrameNums = sourceFrameNums;
|
||
|
|
mSourceFrameStep = sourceFrameStep;
|
||
|
|
|
||
|
|
if(!(mPictureWidth > 0 && mPictureHeight > 0))
|
||
|
|
{
|
||
|
|
aloge("fatal error! picturesize[%d, %d]", mPictureWidth, mPictureHeight);
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(mStartTimeMs > mMediaInfo.mDuration || mStartTimeMs < 0)
|
||
|
|
{
|
||
|
|
aloge("fatal error, starttime[%d] ms!", mStartTimeMs);
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(mSourceFrameNums < 1 || mSourceFrameStep < 0)
|
||
|
|
{
|
||
|
|
aloge("fatal error, SourceFrameNums[%d], SourceFrameStep[%d]", mSourceFrameNums, mSourceFrameStep);
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
prepare();
|
||
|
|
|
||
|
|
seekTo();
|
||
|
|
|
||
|
|
start();
|
||
|
|
|
||
|
|
getMotionTrail();
|
||
|
|
|
||
|
|
stop();
|
||
|
|
|
||
|
|
return PictureAsBMP(mImageBGR);
|
||
|
|
#else
|
||
|
|
aloge("sorry, this version no realize func!");
|
||
|
|
return NULL;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t EyeseeMotion::reset()
|
||
|
|
{
|
||
|
|
Mutex::Autolock _l(mLock);
|
||
|
|
|
||
|
|
status_t result = NO_ERROR;
|
||
|
|
if(mCurrentState == MEDIA_MOTION_INITIALIZED)
|
||
|
|
{
|
||
|
|
if(mDmxChn >= 0)
|
||
|
|
{
|
||
|
|
AW_MPI_DEMUX_DestroyChn(mDmxChn);
|
||
|
|
mDmxChn = MM_INVALID_CHN;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ClearConfig();
|
||
|
|
|
||
|
|
//mCurrentState = MEDIA_MOTION_IDLE;
|
||
|
|
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
void EyeseeMotion::ClearConfig()
|
||
|
|
{
|
||
|
|
memset(&mDmxChnAttr, 0, sizeof mDmxChnAttr);
|
||
|
|
memset(&mMediaInfo, 0, sizeof mMediaInfo);
|
||
|
|
memset(&mVdecChnAttr, 0, sizeof mVdecChnAttr);
|
||
|
|
memset(&mClockChnAttr, 0, sizeof mClockChnAttr);
|
||
|
|
|
||
|
|
mDmxChn = MM_INVALID_CHN;
|
||
|
|
mVdecChn = MM_INVALID_CHN;
|
||
|
|
mClockChn = MM_INVALID_CHN;
|
||
|
|
|
||
|
|
if(mMotionHandle)
|
||
|
|
{
|
||
|
|
AW_AI_MT_Reset(mMotionHandle);
|
||
|
|
AW_AI_MT_UnInit(mMotionHandle);
|
||
|
|
mMotionHandle = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
DestroyImage(&mImageYUV);
|
||
|
|
DestroyImage(&mImageBGR);
|
||
|
|
|
||
|
|
mPictureWidth = 0;
|
||
|
|
mPictureHeight = 0;
|
||
|
|
mStartTimeMs = 0;
|
||
|
|
mSourceFrameNums = 0;
|
||
|
|
mSourceFrameStep = 0;
|
||
|
|
mObjectNums = 0;
|
||
|
|
|
||
|
|
mCurrentState = MEDIA_MOTION_IDLE;
|
||
|
|
}
|
||
|
|
status_t EyeseeMotion::prepare()
|
||
|
|
{
|
||
|
|
status_t result = NO_ERROR;
|
||
|
|
|
||
|
|
ERRORTYPE ret;
|
||
|
|
|
||
|
|
//basepath
|
||
|
|
if(access(mTempBMPFileBasePath.c_str(), 0) != 0)
|
||
|
|
{
|
||
|
|
if(mkdir(mTempBMPFileBasePath.c_str(), 0) != 0)
|
||
|
|
{
|
||
|
|
aloge("fatal error, can not creat directory[%s], %s", mTempBMPFileBasePath.c_str(), strerror(errno));
|
||
|
|
return UNKNOWN_ERROR;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(mMediaInfo.mVideoNum > 0 && !(mDmxChnAttr.mDemuxDisableTrack & DEMUX_DISABLE_VIDEO_TRACK))
|
||
|
|
{
|
||
|
|
DEMUX_VIDEO_STREAM_INFO_S *pStreamInfo = &mMediaInfo.mVideoStreamInfo[mMediaInfo.mVideoIndex];
|
||
|
|
|
||
|
|
mVdecChnAttr.mType = pStreamInfo->mCodecType;
|
||
|
|
mVdecChnAttr.mPicWidth = mPictureWidth;
|
||
|
|
mVdecChnAttr.mPicHeight = mPictureHeight;
|
||
|
|
mVdecChnAttr.mInitRotation = (ROTATE_E)0;
|
||
|
|
mVdecChnAttr.mOutputPixelFormat = MM_PIXEL_FORMAT_YVU_PLANAR_420;
|
||
|
|
mVdecChnAttr.mVdecVideoAttr.mMode = VIDEO_MODE_FRAME;
|
||
|
|
mVdecChnAttr.mVdecVideoAttr.mSupportBFrame = 1;
|
||
|
|
|
||
|
|
bool bSuccessFlag = false;
|
||
|
|
mVdecChn = 0;
|
||
|
|
while(mVdecChn < VDEC_MAX_CHN_NUM)
|
||
|
|
{
|
||
|
|
ret = AW_MPI_VDEC_CreateChn(mVdecChn, &mVdecChnAttr);
|
||
|
|
if(SUCCESS == ret)
|
||
|
|
{
|
||
|
|
bSuccessFlag = true;
|
||
|
|
alogd("create vdec channel[%d] success!", mVdecChn);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
else if(ERR_VDEC_EXIST == ret)
|
||
|
|
{
|
||
|
|
alogd("vdec channel[%d] is exist, find next!", mVdecChn);
|
||
|
|
mVdecChn++;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
alogd("error, create vdec channel[%d] ret[0x%x]!", mVdecChn, ret);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
if(!bSuccessFlag)
|
||
|
|
{
|
||
|
|
mVdecChn = MM_INVALID_CHN;
|
||
|
|
aloge("fatal error! create vdec channel failed");
|
||
|
|
result = UNKNOWN_ERROR;
|
||
|
|
goto _err0;
|
||
|
|
}
|
||
|
|
|
||
|
|
MPP_CHN_S DmxChn{MOD_ID_DEMUX, 0, mDmxChn};
|
||
|
|
MPP_CHN_S VdecChn{MOD_ID_VDEC, 0, mVdecChn};
|
||
|
|
AW_MPI_SYS_Bind(&DmxChn, &VdecChn);
|
||
|
|
mClockChnAttr.nWaitMask |= 1<<CLOCK_PORT_INDEX_VIDEO;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(mDmxChn >= 0)
|
||
|
|
{
|
||
|
|
bool bSuccessFlag = false;
|
||
|
|
mClockChn = 0;
|
||
|
|
while(mClockChn < CLOCK_MAX_CHN_NUM)
|
||
|
|
{
|
||
|
|
ret = AW_MPI_CLOCK_CreateChn(mClockChn, &mClockChnAttr);
|
||
|
|
if(SUCCESS == ret)
|
||
|
|
{
|
||
|
|
bSuccessFlag = true;
|
||
|
|
alogd("creat clock channel[%d] success!", mClockChn);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
else if(ERR_CLOCK_EXIST == ret)
|
||
|
|
{
|
||
|
|
alogd("clock channel[%d] is exist, find next!", mClockChn);
|
||
|
|
++mClockChn;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
alogd("creat clock channel[%d] ret[0x%x]", mClockChn, ret);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(!bSuccessFlag)
|
||
|
|
{
|
||
|
|
mClockChn = MM_INVALID_CHN;
|
||
|
|
aloge("fatal error! create clock channel fail!");
|
||
|
|
result = UNKNOWN_ERROR;
|
||
|
|
goto _err0;
|
||
|
|
}
|
||
|
|
|
||
|
|
MPP_CHN_S ClockChn{MOD_ID_CLOCK, 0, mClockChn};
|
||
|
|
MPP_CHN_S DmxChn{MOD_ID_DEMUX, 0, mDmxChn};
|
||
|
|
AW_MPI_SYS_Bind(&ClockChn, &DmxChn);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
mLpMtParam.Width = mPictureWidth;
|
||
|
|
mLpMtParam.Height = mPictureHeight;
|
||
|
|
mLpMtParam.bAntishakeEnable = true;
|
||
|
|
mMotionHandle = AW_AI_MT_Init(&mLpMtParam);
|
||
|
|
if(!mMotionHandle)
|
||
|
|
{
|
||
|
|
aloge("init mt lib fail");
|
||
|
|
result = UNKNOWN_ERROR;
|
||
|
|
goto _err0;
|
||
|
|
}
|
||
|
|
|
||
|
|
CreateImage(&mImageYUV, mLpMtParam.Width, mLpMtParam.Height, 3, PIXEL_FORMAT_YVU_PLANAR_420);
|
||
|
|
CreateImage(&mImageBGR, mLpMtParam.Width, mLpMtParam.Height, 3, PIXEL_FORMAT_BGR_888);
|
||
|
|
|
||
|
|
mCurrentState = MEDIA_MOTION_PREPARED;
|
||
|
|
|
||
|
|
_err0:
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t EyeseeMotion::start()
|
||
|
|
{
|
||
|
|
status_t opStatus = NO_ERROR;
|
||
|
|
|
||
|
|
if(mVdecChn >= 0)
|
||
|
|
{
|
||
|
|
//VDEC_DECODE_FRAME_PARAM_S DecodeParam;
|
||
|
|
//DecodeParam.mDecodeFrameNum = (mSourceFrameNums -1) * mSourceFrameStep + mSourceFrameNums;
|
||
|
|
//AW_MPI_VDEC_StartRecvStreamEx(mVdecChn, &DecodeParam);
|
||
|
|
AW_MPI_VDEC_StartRecvStream(mVdecChn);
|
||
|
|
}
|
||
|
|
|
||
|
|
if(mDmxChn >= 0)
|
||
|
|
{
|
||
|
|
AW_MPI_DEMUX_Start(mDmxChn);
|
||
|
|
}
|
||
|
|
|
||
|
|
if(mClockChn >= 0)
|
||
|
|
{
|
||
|
|
AW_MPI_CLOCK_Start(mClockChn);
|
||
|
|
}
|
||
|
|
|
||
|
|
mCurrentState = MEDIA_MOTION_STARTED;
|
||
|
|
|
||
|
|
return opStatus;
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t EyeseeMotion::stop()
|
||
|
|
{
|
||
|
|
status_t opStatus = NO_ERROR;
|
||
|
|
|
||
|
|
if(mClockChn >= 0)
|
||
|
|
{
|
||
|
|
AW_MPI_CLOCK_Stop(mClockChn);
|
||
|
|
}
|
||
|
|
|
||
|
|
if(mDmxChn >= 0)
|
||
|
|
{
|
||
|
|
AW_MPI_DEMUX_Stop(mDmxChn);
|
||
|
|
}
|
||
|
|
|
||
|
|
if(mVdecChn >= 0)
|
||
|
|
{
|
||
|
|
AW_MPI_VDEC_StopRecvStream(mVdecChn);
|
||
|
|
}
|
||
|
|
|
||
|
|
if(mVdecChn >= 0)
|
||
|
|
{
|
||
|
|
AW_MPI_VDEC_DestroyChn(mVdecChn);
|
||
|
|
mVdecChn = MM_INVALID_CHN;
|
||
|
|
}
|
||
|
|
if(mDmxChn >= 0)
|
||
|
|
{
|
||
|
|
AW_MPI_DEMUX_DestroyChn(mDmxChn);
|
||
|
|
mDmxChn = MM_INVALID_CHN;
|
||
|
|
}
|
||
|
|
if(mClockChn >= 0)
|
||
|
|
{
|
||
|
|
AW_MPI_CLOCK_DestroyChn(mClockChn);
|
||
|
|
mClockChn = MM_INVALID_CHN;
|
||
|
|
}
|
||
|
|
|
||
|
|
mCurrentState = MEDIA_MOTION_STOPPED;
|
||
|
|
|
||
|
|
return opStatus;
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t EyeseeMotion::seekTo()
|
||
|
|
{
|
||
|
|
status_t opStatus = NO_ERROR;
|
||
|
|
|
||
|
|
if(mDmxChn >= 0 && mStartTimeMs > 0)
|
||
|
|
{
|
||
|
|
AW_MPI_DEMUX_Seek(mDmxChn, mStartTimeMs);
|
||
|
|
alogd("the demux had set %d ms!", mStartTimeMs);
|
||
|
|
}
|
||
|
|
return opStatus;
|
||
|
|
}
|
||
|
|
|
||
|
|
status_t EyeseeMotion::getMotionTrail()
|
||
|
|
{
|
||
|
|
mMotionTrailRet = -1;
|
||
|
|
VIDEO_FRAME_INFO_S tVideoFrameInfo;
|
||
|
|
const int nFramSum = (mSourceFrameNums -1) * mSourceFrameStep + mSourceFrameNums;
|
||
|
|
int nSendFrameCounts = 0;
|
||
|
|
if(nFramSum <= 20){
|
||
|
|
aloge("The voide is too short,video frame number nFramSum %d <= 20,",nFramSum);
|
||
|
|
mMotionTrailRet = -1;
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
for(int i = 0; i < nFramSum; i++)
|
||
|
|
{
|
||
|
|
ERRORTYPE ret = AW_MPI_VDEC_GetImage(mVdecChn, &tVideoFrameInfo, 500);
|
||
|
|
if(SUCCESS == ret)
|
||
|
|
{
|
||
|
|
if(i > nFramSum / 10 && i < (nFramSum - nFramSum / 10) )
|
||
|
|
{
|
||
|
|
if(0 == mSourceFrameStep || 0 == i % mSourceFrameStep)
|
||
|
|
{
|
||
|
|
assert(MM_PIXEL_FORMAT_YVU_PLANAR_420 == tVideoFrameInfo.VFrame.mPixelFormat);
|
||
|
|
const int size = mLpMtParam.Width * mLpMtParam.Height;
|
||
|
|
memcpy(mImageYUV.mpData, tVideoFrameInfo.VFrame.mpVirAddr[0], size);
|
||
|
|
memcpy(mImageYUV.mpData + size, tVideoFrameInfo.VFrame.mpVirAddr[1], size / 4);
|
||
|
|
memcpy(mImageYUV.mpData + size + size / 4, tVideoFrameInfo.VFrame.mpVirAddr[2], size / 4);
|
||
|
|
|
||
|
|
cvtYUV2BGR(&mImageYUV, &mImageBGR);
|
||
|
|
|
||
|
|
//AW_AI_MT_SendFrame(mMotionHandle, &mImageBGR);
|
||
|
|
char tmpFileName[32] = {0};
|
||
|
|
sprintf(tmpFileName, "%d.bmp", nSendFrameCounts++);
|
||
|
|
std::string TempFilePathName = mTempBMPFileBasePath + tmpFileName;
|
||
|
|
SaveBMP(&mImageBGR, const_cast<char*>(TempFilePathName.c_str()));
|
||
|
|
AW_AI_MT_SetFrame(mMotionHandle, TempFilePathName.c_str());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
AW_MPI_VDEC_ReleaseImage(mVdecChn, &tVideoFrameInfo);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
aloge("why not get frame from vdec, maybe EOF [0x%x]", ret);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
alogd("__send frame to MT, count[%d]", nSendFrameCounts);
|
||
|
|
|
||
|
|
mMotionTrailRet = AW_AI_MT_GenMotionTrail(mMotionHandle, &mImageBGR);
|
||
|
|
return NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
int EyeseeMotion::GetmMotionTrailRet()
|
||
|
|
{
|
||
|
|
return mMotionTrailRet;
|
||
|
|
}
|
||
|
|
|
||
|
|
std::shared_ptr<CMediaMemory> EyeseeMotion::PictureAsJpeg(IMAGE_DATA_I &ImageYUV)
|
||
|
|
{
|
||
|
|
VENC_CHN VecChn = 0;
|
||
|
|
VENC_CHN_ATTR_S VecChnAttr;
|
||
|
|
memset(&VecChnAttr, 0, sizeof VecChnAttr);
|
||
|
|
VecChnAttr.VeAttr.Type = PT_JPEG;
|
||
|
|
VecChnAttr.VeAttr.AttrJpeg.MaxPicWidth = 0;
|
||
|
|
VecChnAttr.VeAttr.AttrJpeg.MaxPicHeight = 0;
|
||
|
|
VecChnAttr.VeAttr.AttrJpeg.BufSize = ((((ImageYUV.mWidth * ImageYUV.mHeight * 3) >> 2) + 1023) >> 10) << 10;
|
||
|
|
VecChnAttr.VeAttr.AttrJpeg.bByFrame = TRUE;
|
||
|
|
VecChnAttr.VeAttr.AttrJpeg.PicWidth = ImageYUV.mWidth;
|
||
|
|
VecChnAttr.VeAttr.AttrJpeg.PicHeight = ImageYUV.mHeight;
|
||
|
|
VecChnAttr.VeAttr.AttrJpeg.bSupportDCF = FALSE;
|
||
|
|
VecChnAttr.VeAttr.MaxKeyInterval = 1;
|
||
|
|
VecChnAttr.VeAttr.SrcPicWidth = ImageYUV.mWidth;
|
||
|
|
VecChnAttr.VeAttr.SrcPicHeight = ImageYUV.mHeight;
|
||
|
|
VecChnAttr.VeAttr.Field = VIDEO_FIELD_FRAME;
|
||
|
|
VecChnAttr.VeAttr.PixelFormat = MM_PIXEL_FORMAT_YVU_SEMIPLANAR_420;
|
||
|
|
|
||
|
|
ERRORTYPE ret;
|
||
|
|
bool bSuccessFlag = false;
|
||
|
|
while(VecChn < VENC_MAX_CHN_NUM)
|
||
|
|
{
|
||
|
|
ret = AW_MPI_VENC_CreateChn(VecChn, &VecChnAttr);
|
||
|
|
if(SUCCESS == ret)
|
||
|
|
{
|
||
|
|
bSuccessFlag = true;
|
||
|
|
alogd("create venc channel[%d] success!", VecChn);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
else if(ERR_VENC_EXIST == ret)
|
||
|
|
{
|
||
|
|
alogd("venc channel[%d] is exist, find next!", VecChn);
|
||
|
|
VecChn++;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
alogd("create venc channel[%d] ret[0x%x], find next!", VecChn, ret);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(!bSuccessFlag)
|
||
|
|
{
|
||
|
|
aloge("fatal error! create venc channel fail!");
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
VIDEO_FRAME_INFO_S tVideoFrameInfo;
|
||
|
|
memset(&tVideoFrameInfo, 0, sizeof tVideoFrameInfo);
|
||
|
|
tVideoFrameInfo.mId = 0;
|
||
|
|
tVideoFrameInfo.VFrame.mWidth = ImageYUV.mWidth;
|
||
|
|
tVideoFrameInfo.VFrame.mHeight = ImageYUV.mHeight;
|
||
|
|
tVideoFrameInfo.VFrame.mPixelFormat = MM_PIXEL_FORMAT_YVU_SEMIPLANAR_420;
|
||
|
|
tVideoFrameInfo.VFrame.mOffsetLeft = 0;
|
||
|
|
tVideoFrameInfo.VFrame.mOffsetRight = ImageYUV.mWidth;
|
||
|
|
tVideoFrameInfo.VFrame.mOffsetTop = 0;
|
||
|
|
tVideoFrameInfo.VFrame.mOffsetBottom = ImageYUV.mHeight;
|
||
|
|
|
||
|
|
const int size = ImageYUV.mWidth * ImageYUV.mHeight;
|
||
|
|
for(int i =0 ; i < 2; i++)
|
||
|
|
{
|
||
|
|
tVideoFrameInfo.VFrame.mpVirAddr[i] = ion_allocMem(size);
|
||
|
|
tVideoFrameInfo.VFrame.mPhyAddr[i] = ion_getMemPhyAddr(tVideoFrameInfo.VFrame.mpVirAddr[i]);
|
||
|
|
}
|
||
|
|
memcpy(tVideoFrameInfo.VFrame.mpVirAddr[0], ImageYUV.mpData, size);
|
||
|
|
ion_flushCache(tVideoFrameInfo.VFrame.mpVirAddr[0], size);
|
||
|
|
|
||
|
|
unsigned char *ptr_uv = static_cast<unsigned char *>(tVideoFrameInfo.VFrame.mpVirAddr[1]);
|
||
|
|
unsigned char *ptr_u = ImageYUV.mpData + size;
|
||
|
|
unsigned char *ptr_v = ImageYUV.mpData + size + size / 4;
|
||
|
|
for(int i = 0; i < size / 4; i++)
|
||
|
|
{
|
||
|
|
*ptr_uv++ = *ptr_v++;
|
||
|
|
*ptr_uv++ = *ptr_u++;
|
||
|
|
}
|
||
|
|
ion_flushCache(tVideoFrameInfo.VFrame.mpVirAddr[1], size);
|
||
|
|
|
||
|
|
VENC_RECV_PIC_PARAM_S RecvParam;
|
||
|
|
RecvParam.mRecvPicNum = 1;
|
||
|
|
AW_MPI_VENC_StartRecvPicEx(VecChn, &RecvParam);
|
||
|
|
|
||
|
|
AW_MPI_VENC_SendFrame(VecChn, &tVideoFrameInfo, 500);
|
||
|
|
|
||
|
|
std::shared_ptr<CMediaMemory> spJpegBuf;
|
||
|
|
VENC_STREAM_S JpegStream;
|
||
|
|
VENC_PACK_S Jpeg_pack;
|
||
|
|
JpegStream.mPackCount = 1;
|
||
|
|
JpegStream.mpPack = &Jpeg_pack;
|
||
|
|
if(SUCCESS == AW_MPI_VENC_GetStream(VecChn, &JpegStream, 500))
|
||
|
|
{
|
||
|
|
const int JpegSize = JpegStream.mpPack[0].mLen0 + JpegStream.mpPack[0].mLen1;
|
||
|
|
spJpegBuf = std::make_shared<CMediaMemory>(JpegSize);
|
||
|
|
char *ptr = (char *)spJpegBuf->getPointer();
|
||
|
|
memcpy(ptr, JpegStream.mpPack[0].mpAddr0, JpegStream.mpPack[0].mLen0);
|
||
|
|
ptr += JpegStream.mpPack[0].mLen0;
|
||
|
|
memcpy(ptr, JpegStream.mpPack[0].mpAddr1, JpegStream.mpPack[0].mLen1);
|
||
|
|
|
||
|
|
if(AW_MPI_VENC_ReleaseStream(VecChn, &JpegStream) != SUCCESS)
|
||
|
|
{
|
||
|
|
aloge("jpeg stream data return fail!");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
aloge("get jpeg stream data fail!");
|
||
|
|
}
|
||
|
|
|
||
|
|
AW_MPI_VENC_StopRecvPic(VecChn);
|
||
|
|
|
||
|
|
for(int i = 0; i < 2; i++)
|
||
|
|
{
|
||
|
|
ion_freeMem(tVideoFrameInfo.VFrame.mpVirAddr[i]);
|
||
|
|
}
|
||
|
|
|
||
|
|
AW_MPI_VENC_DestroyChn(VecChn);
|
||
|
|
|
||
|
|
return spJpegBuf;
|
||
|
|
}
|
||
|
|
|
||
|
|
std::shared_ptr<CMediaMemory> EyeseeMotion::PictureAsBMP(IMAGE_DATA_I &ImageBGR)
|
||
|
|
{
|
||
|
|
aloge("sorry, this version no realize func!");
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
};
|
||
|
|
|