bool Cpu::RunUnit()
{
unsigned char Cmd = ((*(vmem + this->rp)) & 0xF0) >> 4;
unsigned char Addr = 0, AddrSec = 0, Flag = 0, DataType = 0, CalType = 0;
unsigned int Argu = 0, ArguSec = 0, CmdLen = CmdLengthMap[Cmd];
switch(CmdLen)
{
case 1:
break;
case 5: // X[Addressing] [Argument]
Addr = (*(vmem + this->rp)) & 0x0F;
Argu = *(int*)(vmem + this->rp + 1);
break;
case 6: // X[Flag] [Addressing] [Argument]
Flag = (*(vmem + this->rp)) & 0x0F;
Addr = *(vmem + this->rp + 1);
Argu = *(int*)(vmem + this->rp + 2);
break;
case 10: // X[DataType|0] [0|CalType][Multi-Addressing] [Argument1] [Argument2]
DataType = (*(vmem + this->rp)) & 0x0F;
if (DataType > 4)
{
CoreCrash("Unknow data type:%d", DataType);
return false;
}
CalType = ((*(vmem + this->rp + 1)) & 0xF0) >> 4;
Addr = (*(vmem + this->rp + 1)) & 0x0F;
AddrSec = Addr & 0x03;
Addr >>= 2;
Argu = *(int*)(vmem + this->rp + 2);
ArguSec = *(int*)(vmem + this->rp + 6);
break;
}
// Log("%s\n", CmdName[Cmd]);
switch(Cmd)
{
case 0x0: // NOOP
this->rp += CmdLen;
break;
case 0x1: // LD
PutData(Addr, Argu, GetData(AddrSec, ArguSec), DataType);
this->rp += CmdLen;
break;
case 0x2: // PUSH
Push(GetData(Addr, Argu));
this->rp += CmdLen;
break;
case 0x3: // POP
PutData(Addr, Argu, Pop(), DataType);
this->rp += CmdLen;
break;
case 0x4: // IN
PutData(Addr, Argu, InPort(GetData(AddrSec, ArguSec)), DataType);
this->rp += CmdLen;
break;
case 0x5: // OUT
OutPort(GetData(Addr, Argu), GetData(AddrSec, ArguSec));
this->rp += CmdLen;
break;
case 0x6: // JMP
this->rp = GetData(Addr, Argu);
break;
case 0x7: // JPC
if (GetFlag(Flag) == true)
{
this->rp = GetData(Addr, Argu);
} else {
this->rp += CmdLen;
}
break;
case 0x8: // CALL
Push(this->rp + CmdLen);
this->rp = GetData(Addr, Argu);
break;
case 0x9: // RET
this->rp = Pop();
break;
case 0xA: // CMP
{
int op1 = (int)GetData(Addr, Argu), op2 = (int)GetData(AddrSec, ArguSec);
switch(DataType)
{
case BYTE:
op1 &= 0xFF; op2 &= 0xFF;
case WORD:
op1 &= 0xFFFF; op2 &= 0xFFFF;
case DWORD: case INT:
if (op1 == op2) {PutFlag(Z);}
else if (op1 < op2) {PutFlag(B);}
else if (op1 > op2) {PutFlag(A);}
break;
case FLOAT:
{
float opf1, opf2;
conv.i = op1; opf1 = conv.f;
conv.i = op2; opf2 = conv.f;
if (opf1 == opf2) {PutFlag(Z);}
else if (opf1 < opf2) {PutFlag(B);}
else if (opf1 > opf2) {PutFlag(A);}
}
break;
}
}
this->rp += CmdLen;
break;
case 0xB: // CAL
{
int op1 = (int)GetData(Addr, Argu), op2 = (int)GetData(AddrSec, ArguSec), result = 0;
switch(DataType)
{
case BYTE:
op1 &= 0xFF; op2 &= 0xFF;
case WORD:
op1 &= 0xFFFF; op2 &= 0xFFFF;
case DWORD: case INT:
switch(CalType)
{
case ADD: result = op1 + op2; break;
case SUB: result = op1 - op2; break;
case MUL: result = op1 * op2; break;
case DIV: result = op1 / op2; break;
case MOD: result = op1 % op2; break;
default:
CoreCrash("Unknow operator: %d", CalType);
}
break;
case FLOAT:
{
float opf1, opf2, resultf = 0.0f;
conv.i = op1; opf1 = conv.f;
conv.i = op2; opf2 = conv.f;
switch(CalType)
{
case ADD: resultf = opf1 + opf2; break;
case SUB: resultf = opf1 - opf2; break;
case MUL: resultf = opf1 * opf2; break;
case DIV: resultf = opf1 / opf2; break;
default:
CoreCrash("Unknow operator: %d", CalType);
}
conv.f = resultf;
result = conv.i;
}
break;
}
PutData(Addr, Argu, result, DataType);
}
this->rp += CmdLen;
break;
case 0xF: // EXIT
return false;
default:
CoreCrash("Unpredictable command on [0x%08X] :", rp);
CoreDump();
return false;
}
return true;
}
// Update =================================================================================
CStatus gStretchOp2_Update( CRef& in_ctxt )
{
OperatorContext ctxt( in_ctxt );
// User Datas ------------------------------------
CValue::siPtrType pUserData = ctxt.GetUserData();
OpUserData* pOpState = (OpUserData*)pUserData;
if ( pOpState == NULL || pOpState->index >= 4)
{
// First time called
pOpState = new OpUserData();
ctxt.PutUserData( (CValue::siPtrType)pOpState );
// Inputs ---------------------------------------
KinematicState kRoot(ctxt.GetInputValue(0));
KinematicState kCtrl(ctxt.GetInputValue(1));
CTransformation tRoot(kRoot.GetTransform());
CTransformation tCtrl(kCtrl.GetTransform());
CVector3 vRoot = tRoot.GetTranslation();
CVector3 vCtrl = tCtrl.GetTranslation();
CMatrix4 mRoot = tRoot.GetMatrix4();
CMatrix4 mRootNeg;
mRootNeg.Invert(mRoot);
double dRest0 = ctxt.GetParameterValue(L"rest0");
double dRest1 = ctxt.GetParameterValue(L"rest1");
double dPrefRot = ctxt.GetParameterValue(L"prefrot");
double dScale0 = ctxt.GetParameterValue(L"scale0");
double dScale1 = ctxt.GetParameterValue(L"scale1");
double dSoftness = ctxt.GetParameterValue(L"soft");
double dMaxStretch = ctxt.GetParameterValue(L"maxstretch");
double dSlide = ctxt.GetParameterValue(L"slide");
double dReverse = ctxt.GetParameterValue(L"reverse");
// Distance with MaxStretch ---------------------
double dRestLength = dRest0 * dScale0 + dRest1 * dScale1;
CVector3 vDistance;
vDistance.MulByMatrix4(vCtrl, mRootNeg);
double dDistance = vDistance.GetLength();
double dDistance2 = dDistance;
if (dDistance > (dRestLength * dMaxStretch))
{
vDistance.NormalizeInPlace();
vDistance.ScaleInPlace(dRestLength * dMaxStretch);
dDistance = dRestLength * dMaxStretch;
}
// Adapt Softness value to chain length --------
dSoftness *= dRestLength*.1;
// Stretch and softness ------------------------
/// We use the real distance from root to controler to calculate the softness
/// This way we have softness working even when there is no stretch
double dStretch = dDistance/dRestLength;
if (dStretch < 1)
dStretch = 1;
double da = dRestLength - dSoftness;
if (dSoftness > 0 && dDistance2 > da)
{
double newlen = dSoftness*(1.0 - exp(-(dDistance2 -da)/dSoftness)) + da;
dStretch = dDistance / newlen;
}
double dLength0 = dRest0 * dStretch * dScale0;
double dLength1 = dRest1 * dStretch * dScale1;
// Reverse -------------------------------------
double d = dDistance/(dLength0 + dLength1);
double dScale;
if (dReverse < 0.5)
dScale = 1-(dReverse*2 * (1-d));
else
dScale = 1-((1-dReverse)*2 * (1-d));
dLength0 *= dScale;
dLength1 *= dScale;
dPrefRot = -(dReverse-0.5) * 2 * dPrefRot;
// Slide ---------------------------------------
double dAdd;
if (dSlide < .5)
dAdd = (dLength0 * (dSlide*2)) - (dLength0);
else
dAdd = (dLength1 * (dSlide*2)) - (dLength1);
dLength0 += dAdd;
dLength1 -= dAdd;
// Effector Position ----------------------------
CTransformation t;
vDistance.MulByMatrix4(vDistance, mRoot);
t.SetTranslation(vDistance);
pOpState->index = 0;
pOpState->t = t;
pOpState->dLength0 = dLength0;
pOpState->dLength1 = dLength1;
pOpState->dPrefRot = dPrefRot;
}
// Outputs -------------------------------------
CRef outputPortRef=ctxt.GetOutputPort();
OutputPort OutPort(outputPortRef);
// Effector Transform
if (OutPort.GetIndex() == 2)
{
KinematicState kOut = ctxt.GetOutputTarget();
kOut.PutTransform(pOpState->t);
}
// Bone 0 Length
else if (OutPort.GetIndex() == 3)
{
OutPort.PutValue(pOpState->dLength0);
}
// Bone 1 Length
else if (OutPort.GetIndex() == 4)
{
OutPort.PutValue(pOpState->dLength1);
}
// Bone 1 PrefRot
else if (OutPort.GetIndex() == 5)
{
OutPort.PutValue(pOpState->dPrefRot);
}
pOpState->index += 1;
return CStatus::OK;
}
/*******************************************************************************
* Config CamIO Pipe /floria
********************************************************************************/
int
Ts_UT::
main_ts_IOPipe_ZSD(int count)
{
// int count = 1000; //enque, deque loop iterations
printf("[iopipetest] E\n");
//for Enqueue, raw buf
MUINT32 u4RawBufSize = (u4SensorWidth * u4SensorHeight * 2 + L1_CACHE_BYTES-1) & ~(L1_CACHE_BYTES-1);
//for buffer per frame
int BufIdx = BUF_NUM, nCt = BUF_NUM;
#ifdef USE_IMAGEBUF_HEAP
MUINT32 bufStridesInBytes[3] = {1600, 0, 0};
MINT32 bufBoundaryInBytes[3] = {0, 0, 0};
#endif
#if 0
ringbuffer* mpRingImgo = new ringbuffer(
2,//PASS1_FULLRAW
PORT_IMGO,
0//fakeResized ? PASS1_RESIZEDRAW : 0
);
#endif
MY_LOGD("+");
/*------------------------------
* (1) Create Instance
*-----------------------------*/
/* eScenarioID_VSS, eScenarioFmt_RAW */
MUINT mSensorIdx = 0;//0:MAIN
const char Name = '1';
MUINT mIspEnquePeriod = 1;
prepareSensor();//test IHalSensor
printf("[iopipetest] INormalPipe::createInstance\n");
mpCamIO = (INormalPipe*)INormalPipe::createInstance(mSensorIdx, &Name, mIspEnquePeriod);
#if 0//camera 3.0, should create INormalPipe_FrmB class instance
mpCamIO = (IHalCamIO*)INormalPipe_FrmB::createInstance(mSensorIdx, &Name, mIspEnquePeriod);
#endif
/*------------------------------
test 3A build pass
------------------------------*/
#if 0
MINT32 handle;
MBOOL fgRet = mpCamIO->sendCommand(NSImageio_FrmB::NSIspio_FrmB::EPIPECmd_GET_MODULE_HANDLE,
NSImageio_FrmB::NSIspio_FrmB::EModule_AF,
(MINT32)&handle,
(MINT32)(&("AFMgr::setFlkWinConfig()")));
MINT32 wintmp;
IOPIPE_SET_MODUL_REG(handle, CAM_AF_WINX01, wintmp);
#endif
/*------------------------------
* (2) init
*-----------------------------*/
printf("[iopipetest] mpCamIO->init\n");
if(!mpCamIO->init())
{
printf("[iopipetest] mpCamIO->init failed!!\n");
}
/*------------------------------
* (3). Config pipe + RAW10
*-----------------------------*/
MSize mDstSize;
mDstSize.w = u4SensorWidth;
mDstSize.h = u4SensorHeight;
//prepare sensor config
vector<IHalSensor::ConfigParam> vSensorCfg;
IHalSensor::ConfigParam sensorCfg =
{
mSensorIdx, /* index */
mDstSize, /* crop no reference in NormalPipe */
u4Scenario, /* scenarioId */
0, /* isBypassScenario */
1, /* isContinuous */
0, /* iHDROn */
0, /* framerate */
0, /* two pixel on */
0, /* debugmode */
};
vSensorCfg.push_back(sensorCfg);
printf("[iopipetest] sensor %dx%d, sce %d, bypass %d, con %d, hdr %d, fps %d, twopxl %d\n",
sensorCfg.crop.w,
sensorCfg.crop.h,
sensorCfg.scenarioId,
sensorCfg.isBypassScenario,
sensorCfg.isContinuous,
sensorCfg.HDRMode,
sensorCfg.framerate,
sensorCfg.twopixelOn);
//
vector<portInfo> vPortInfo;
//
portInfo OutPort(
PORT_IMGO,
eImgFmt_BAYER10,
mDstSize, //dst size
0, //pPortCfg->mCrop, //crop
u4SensorWidth, //pPortCfg->mStrideInByte[0],
0, //pPortCfg->mStrideInByte[1],
0, //pPortCfg->mStrideInByte[2],
0, // pureraw
MTRUE //packed
);
vPortInfo.push_back(OutPort);
printf("[iopipetest] config portID(0x%x), fmt(%u), size(%dx%d), crop(%u,%u,%u,%u)\n",
OutPort.mPortID, OutPort.mFmt, OutPort.mDstSize.w, OutPort.mDstSize.h,
OutPort.mCropRect.p.x, OutPort.mCropRect.p.y,
OutPort.mCropRect.s.w, OutPort.mCropRect.s.h);
printf("[iopipetest] stride(%u,%u,%u), pureRaw(%u), pack(%d)\n",
OutPort.mStride[0], OutPort.mStride[1], OutPort.mStride[2],
OutPort.mPureRaw, OutPort.mPureRawPak);
//
QInitParam halCamIOinitParam(
0,
u4Bitdepth,
vSensorCfg,
vPortInfo);
printf("[iopipetest] mpCamIO->configPipe\n");
if(!mpCamIO->configPipe(halCamIOinitParam, eScenarioID_VSS))
{
printf("[iopipetest] mpCamIO->configPipe failed!!\n");
goto TEST_EXIT;
}
/*------------------------------
* (4). Enqueue
* 4.1, raw buf
*-----------------------------*/
#ifdef _USE_THREAD_QUE_
if(vRawMem.size() > 0)
{
freeRawMem();
TS_Thread_UnInit();
}
nCt--;
#else
//
int nReplace;
printf("*****************************************\n");
printf("Buffer per frame(1:y; else:n)\n");
scanf("%d", &nReplace);
printf("*****************************************\n");
if(nReplace != 1)
{
nCt--;
}
#endif
/* * * * * * * * * * * *
* buffer per frame
* nReplace = 1
* size = BUF_NUM + 1
*(replace buffer)
* * * * * * * * * * * *
* sequential buffer
* nReplace != 1
* size = BUF_NUM
*(no replace buffer)
* * * * * * * * * * * */
printf("[iopipetest] allocMem: RawBuff\n");
for (int i = 0; i <= nCt; i++) //BUF_NUM=3
{
IMEM_BUF_INFO rBuf;
rBuf.size = u4RawBufSize;
allocMem(rBuf);
#ifdef USE_IMAGEBUF_HEAP
PortBufInfo_v1 portBufInfo = PortBufInfo_v1( rBuf.memID,rBuf.virtAddr,0,rBuf.bufSecu, rBuf.bufCohe);
IImageBufferAllocator::ImgParam imgParam = IImageBufferAllocator::ImgParam((eImgFmt_BAYER10),
MSize(1280, 720), bufStridesInBytes, bufBoundaryInBytes, 1);
sp<ImageBufferHeap> pHeap = ImageBufferHeap::create( LOG_TAG, imgParam,portBufInfo,MTRUE);
IImageBuffer* tempBuffer = pHeap->createImageBuffer();
tempBuffer->incStrong(tempBuffer);
tempBuffer->lockBuf(LOG_TAG,eBUFFER_USAGE_HW_CAMERA_READWRITE | eBUFFER_USAGE_SW_READ_OFTEN);
//
BufInfo rBufInfo;
rBufInfo.mPortID = PORT_IMGO;
rBufInfo.mBuffer = tempBuffer;
rBufInfo.FrameBased.mMagicNum_tuning = 0;
rBufInfo.FrameBased.mDstSize = mDstSize;
rBufInfo.FrameBased.mCropRect = MRect(MPoint(0, 0), mDstSize);//no crop
rRawBuf.mvOut.push_back(rBufInfo);
#endif
vRawMem.push_back(rBuf);
printf("[iopipetest] vRawMem(%d)PA(0x%x)VA(0x%x)\n", i, vRawMem.at(i).phyAddr,vRawMem.at(i).virtAddr);
}
//for deque
for (int i = 0; i <= 0; i++)
{
IMEM_BUF_INFO rBuf;
rBuf.size = u4RawBufSize;
allocMem(rBuf);
#ifdef USE_IMAGEBUF_HEAP
PortBufInfo_v1 portBufInfo = PortBufInfo_v1( rBuf.memID,rBuf.virtAddr,0,rBuf.bufSecu, rBuf.bufCohe);
IImageBufferAllocator::ImgParam imgParam = IImageBufferAllocator::ImgParam((eImgFmt_BAYER10),
MSize(1280, 720), bufStridesInBytes, bufBoundaryInBytes, 1);
sp<ImageBufferHeap> pHeap = ImageBufferHeap::create( LOG_TAG, imgParam,portBufInfo,MTRUE);
IImageBuffer* tempBuffer = pHeap->createImageBuffer();
tempBuffer->incStrong(tempBuffer);
tempBuffer->lockBuf(LOG_TAG,eBUFFER_USAGE_HW_CAMERA_READWRITE | eBUFFER_USAGE_SW_READ_OFTEN);
//
BufInfo rBufInfo;
rBufInfo.mPortID = PORT_IMGO;
rBufInfo.mBuffer = tempBuffer;
rDequeBuf.mvOut.push_back(rBufInfo);
#endif
vDequeMem.push_back(rBuf);
printf("[iopipetest] vDequeMem(%d)PA(0x%x)VA(0x%x)\n", i, vDequeMem.at(i).phyAddr, vDequeMem.at(i).virtAddr);
}
/* enque 3 buffers */
for (int i = 0; i < BUF_NUM; i++)
{
#if 1
QBufInfo rInBuf;
rInBuf.mvOut.clear();
#ifdef USE_IMAGEBUF_HEAP
BufInfo rBufInfo(PORT_IMGO, rRawBuf.mvOut.at(i).mBuffer, rRawBuf.mvOut.at(i).mSize, rRawBuf.mvOut.at(i).mVa, rRawBuf.mvOut.at(i).mPa);
#else
BufInfo rBufInfo(PORT_IMGO, NULL, vRawMem.at(i).size, vRawMem.at(i).virtAddr, vRawMem.at(i).phyAddr);
#endif
rInBuf.mvOut.push_back(rBufInfo);
rInBuf.mvOut.at(0).FrameBased.mMagicNum_tuning = 0;
rInBuf.mvOut.at(0).FrameBased.mDstSize = mDstSize;
rInBuf.mvOut.at(0).FrameBased.mCropRect = MRect(MPoint(0, 0), mDstSize);//no crop
#ifdef USE_IMAGEBUF_HEAP
printf("[iopipetest] enque.PA(0x%x)VA(0x%x)buf(0x%x)\n", rInBuf.mvOut.at(0).mBuffer->getBufPA(0), rInBuf.mvOut.at(0).mBuffer->getBufVA(0), rInBuf.mvOut.at(0).mBuffer);
#else
printf("[iopipetest] enque.PA(0x%x)VA(0x%x)\n", rInBuf.mvOut.at(0).mPa, rInBuf.mvOut.at(0).mVa);
#endif
printf("[iopipetest] enque(%d)\n", i);
if(!mpCamIO->enque(rInBuf))
{
printf("[iopipetest] enque failed!!\n");
goto TEST_EXIT;
}
#else
/* * * * * * * * * * * * * * * * * * * * * * * * * *
* test:
* if enque a buffer,and it's port is not IMGO,
* mpCamIO->enque(rRawBuf)will return MFALSE
* * * * * * * * * * * * * * * * * * * * * * * * * */
QBufInfo rInBuf;
rInBuf.mvOut.clear();
#ifdef USE_IMAGEBUF_HEAP
BufInfo rBufInfo2(PORT_IMGO, rRawBuf.mvOut.at(i).mBuffer, rRawBuf.mvOut.at(i).mSize, rRawBuf.mvOut.at(i).mVa, rRawBuf.mvOut.at(i).mPa);
#else
BufInfo rBufInfo2(PORT_IMG2O, NULL, vRawMem.at(i).size, vRawMem.at(i).virtAddr, vRawMem.at(i).phyAddr);
#endif
rInBuf.mvOut.push_back(rBufInfo2);
printf("[iopipetest] enque(%d)\n", i);
if(!mpCamIO->enque(rInBuf)){//try to enque IMGO port
printf("[iopipetest] enque(%d) again\n", i);
rInBuf.mvOut.clear();
BufInfo rBufInfo(PORT_IMGO, NULL, vRawMem.at(i).size, vRawMem.at(i).virtAddr, vRawMem.at(i).phyAddr);
rInBuf.mvOut.push_back(rBufInfo);
if(!mpCamIO->enque(rInBuf))
{
printf("[iopipetest] enque failed!!\n");
goto TEST_EXIT;
}
}
#endif
}
/*------------------------------
* (5). start
*-----------------------------*/
printf("[iopipetest] mpCamIO->start\n");
if(!mpCamIO->start())
{
printf("[iopipetest] mpCamIO->start failed!!\n");
goto TEST_EXIT;
}
#if 0//for debug
// test: wait VSYNC
printf("[iopipetest] mpCamIO->irq(VSYNC)\n");
if(!mpCamIO->wait(mSensorIdx, EPipeSignal_SOF))
{
printf("[iopipetest] wait VSYNC failed!!\n");
goto TEST_EXIT;
}
// test: wait pass1 done
printf("[iopipetest] mpCamIO->irq(p1done)\n");
if(!mpCamIO->wait(mSensorIdx, EPipeSignal_EOF))
{
printf("[iopipetest] wait p1done failed!!\n");
goto TEST_EXIT;
}
#endif
/*------------------------------
* (6). deque/enque loop
* --> dequeue
* --> enqueue
*-----------------------------*/
#ifdef _USE_THREAD_QUE_
TS_Thread_Init(count);
#else
do
{
printf("-------------------------------------------\n");
QBufInfo halCamIOOutQBuf;
QBufInfo rEnBuf;
//
halCamIOOutQBuf.mvOut.clear();
#ifdef USE_IMAGEBUF_HEAP
BufInfo rDeBufInfo(PORT_IMGO, rDequeBuf.mvOut.at(0).mBuffer, rDequeBuf.mvOut.at(0).mSize, rDequeBuf.mvOut.at(0).mVa, rDequeBuf.mvOut.at(0).mPa);
#else
BufInfo rDeBufInfo(PORT_IMGO, NULL, vDequeMem.at(0).size, vDequeMem.at(0).virtAddr, vDequeMem.at(0).phyAddr);
#endif
halCamIOOutQBuf.mvOut.push_back(rDeBufInfo);
#ifdef USE_IMAGEBUF_HEAP
//do nothing
#else
printf("[iopipetest] dequeBuf.PA(0x%x)VA(0x%x)size(%d)\n", halCamIOOutQBuf.mvOut.at(0).mPa, halCamIOOutQBuf.mvOut.at(0).mVa, halCamIOOutQBuf.mvOut.size());
#endif
//
printf("[iopipetest] dequeBuf count(%d)\n", count);
if(!mpCamIO->deque(halCamIOOutQBuf))
{
printf("[iopipetest] deque failed!!\n");
goto TEST_EXIT;
}
#ifdef USE_IMAGEBUF_HEAP
printf("[iopipetest] dequeBuf.PA(0x%x)VA(0x%x)buf(0x%x)\n", halCamIOOutQBuf.mvOut.at(0).mBuffer->getBufPA(0), halCamIOOutQBuf.mvOut.at(0).mBuffer->getBufVA(0), halCamIOOutQBuf.mvOut.at(0).mBuffer);
#else
printf("[iopipetest] dequeBuf.PA(0x%x)VA(0x%x)\n", halCamIOOutQBuf.mvOut.at(0).mPa, halCamIOOutQBuf.mvOut.at(0).mVa);
#endif
/* * * * * * * * * * * *
* get ResultMetadata
* * * * * * * * * * * */
ResultMetadata result = halCamIOOutQBuf.mvOut.at(0).mMetaData;
/* * * * * * * * * * * *
* check dummy frame
* * * * * * * * * * * */
if(halCamIOOutQBuf.mvOut.at(0).mMetaData.m_bDummyFrame == MTRUE)
{
printf("[iopipetest] this is a dummy frame\n");
}
/* * * * * * * * * * * *
* sequential buffer
*(no replace buffer)
* * * * * * * * * * * */
if(nReplace != 1)
{
rEnBuf.mvOut.clear();
BufInfo rBufInfo(PORT_IMGO,
#ifdef USE_IMAGEBUF_HEAP
halCamIOOutQBuf.mvOut.at(0).mBuffer,
#else
NULL,
#endif
halCamIOOutQBuf.mvOut.at(0).mSize,
halCamIOOutQBuf.mvOut.at(0).mVa,
halCamIOOutQBuf.mvOut.at(0).mPa);
rEnBuf.mvOut.push_back(rBufInfo);
}
/* * * * * * * * * * * *
* buffer per frame
*(replace buffer)
* * * * * * * * * * * */
else
{
rEnBuf.mvOut.clear();
#ifdef USE_IMAGEBUF_HEAP
BufInfo rBufInfo(PORT_IMGO, rRawBuf.mvOut.at(BufIdx).mBuffer, rRawBuf.mvOut.at(BufIdx).mSize, rRawBuf.mvOut.at(BufIdx).mVa, rRawBuf.mvOut.at(BufIdx).mPa);
#else
BufInfo rBufInfo(PORT_IMGO, NULL, vRawMem.at(BufIdx).size, vRawMem.at(BufIdx).virtAddr, vRawMem.at(BufIdx).phyAddr);
#endif
rEnBuf.mvOut.push_back(rBufInfo);
}
#ifdef USE_IMAGEBUF_HEAP
printf("[iopipetest] enqueBuf.PA(0x%x)VA(0x%x),BufId(%d)\n", rEnBuf.mvOut.at(0).mBuffer->getBufPA(0), rEnBuf.mvOut.at(0).mBuffer->getBufVA(0), BufIdx);
#else
printf("[iopipetest] enqueBuf.PA(0x%x)VA(0x%x),BufId(%d)\n", rEnBuf.mvOut.at(0).mPa, rEnBuf.mvOut.at(0).mVa, BufIdx);
#endif
/* * * * * * * * * * * *
* setting before enque
* * * * * * * * * * * */
rEnBuf.mvOut.at(0).FrameBased.mMagicNum_tuning = 0;
rEnBuf.mvOut.at(0).FrameBased.mDstSize = mDstSize;
rEnBuf.mvOut.at(0).FrameBased.mCropRect = MRect(MPoint(0, 0), mDstSize);//no crop
//
printf("[iopipetest] enque count(%d)\n", count);
if(!mpCamIO->enque(rEnBuf))
{
printf("[iopipetest] enque failed!!\n");
goto TEST_EXIT;
}
//
if(++BufIdx > BUF_NUM) BufIdx = 0;
//
} while(--count > 0);
#endif
/*------------------------------
* (7). Stop
*-----------------------------*/
printf("[iopipetest] mpCamIO->stop\n");
mpCamIO->stop();
TEST_EXIT:
/*------------------------------
* (8). uninit
*-----------------------------*/
printf("[iopipetest] mpCamIO->uninit\n");
if( !mpCamIO->uninit() )
{
MY_LOGE("uninit failed");
}
/*------------------------------
* (9). destory instance
*-----------------------------*/
printf("[iopipetest] mpCamIO->destroyInstance\n");
mpCamIO->destroyInstance(&Name);
mpCamIO = NULL;
printf("[iopipetest] X\n");
return 0;
}
// Update =============================================================================
CStatus gStretchOp2Multi_Update( CRef& in_ctxt )
{
OperatorContext ctxt( in_ctxt );
// User Datas ------------------------------------
CValue::siPtrType pUserData = ctxt.GetUserData();
OpUserData* pOpState = (OpUserData*)pUserData;
if ( pOpState == NULL || pOpState->index >= 2)
{
// First time called
pOpState = new OpUserData();
ctxt.PutUserData( (CValue::siPtrType)pOpState );
// Inputs ---------------------------------------
KinematicState kRoot(ctxt.GetInputValue(0));
KinematicState kCtrl(ctxt.GetInputValue(1));
CTransformation tRoot(kRoot.GetTransform());
CTransformation tCtrl(kCtrl.GetTransform());
CVector3 vRoot = tRoot.GetTranslation();
CVector3 vCtrl = tCtrl.GetTranslation();
CMatrix4 mRoot = tRoot.GetMatrix4();
CMatrix4 mRootNeg;
mRootNeg.Invert(mRoot);
double dRestLength = ctxt.GetParameterValue(L"restlength");
double dScale = ctxt.GetParameterValue(L"scale");
double dSoftness = ctxt.GetParameterValue(L"soft");
double dMaxStretch = ctxt.GetParameterValue(L"maxstretch");
// Distance with MaxStretch ---------------------
dRestLength = dRestLength * dScale - .00001;
CVector3 vDistance;
vDistance.MulByMatrix4(vCtrl, mRootNeg);
double dDistance = vDistance.GetLength();
double dDistance2 = dDistance;
if (dDistance > (dRestLength * dMaxStretch))
{
vDistance.NormalizeInPlace();
vDistance.ScaleInPlace(dRestLength * dMaxStretch);
dDistance = dRestLength * dMaxStretch;
}
Application app;
app.LogMessage(L"dist : "+CString(dDistance));
app.LogMessage(L"dist2 : "+CString(dDistance2));
// Adapt Softness value to chain length --------
dSoftness = dSoftness * dRestLength *.1;
// Stretch and softness ------------------------
/// We use the real distance from root to controler to calculate the softness
/// This way we have softness working even when there is no stretch
double dStretch = dDistance/dRestLength;
if (dStretch < 1)
dStretch = 1;
double da = dRestLength - dSoftness;
if (dSoftness > 0 && dDistance2 > da)
{
double newlen = dSoftness*(1.0 - exp(-(dDistance2 -da)/dSoftness)) + da;
dStretch = dDistance / newlen;
}
double dScaleX = dStretch * dScale;
app.LogMessage(L"scalex : "+CString(dScaleX));
// Effector Position ----------------------------
CTransformation t;
vDistance.MulByMatrix4(vDistance, mRoot);
t.SetTranslation(vDistance);
pOpState->index = 0;
pOpState->t = t;
pOpState->dLength0 = dScaleX;
}
// Outputs -------------------------------------
CRef outputPortRef=ctxt.GetOutputPort();
OutputPort OutPort(outputPortRef);
// Effector Transform
if (OutPort.GetIndex() == 2)
{
KinematicState kOut = ctxt.GetOutputTarget();
kOut.PutTransform(pOpState->t);
}
// Bone 0 Length
else if (OutPort.GetIndex() == 3)
{
OutPort.PutValue(pOpState->dLength0);
}
pOpState->index += 1;
return CStatus::OK;
}
