int
SharedMemoryUtils::commitSM()
{
//mark last msm: isLastNode=1
boost::interprocess::windows_shared_memory * lastMsm = &(msmList.back());
boost::interprocess::mapped_region region1(
*lastMsm,
boost::interprocess::read_write,
SMUCONST_MSM_HEADER_ISLAST_OFFSET,
SMUCONST_MSM_HEADER_ISLAST_SIZE
);
char* isLastNodePtr = static_cast<char*>(region1.get_address());
*isLastNodePtr = '1';
uint16_t recordNo = processCsmId - 1;
//set status to (W)orking
boost::interprocess::mapped_region region3(
*csm,
boost::interprocess::read_write,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_STATUS_RECOFFSET,
SMUCONST_CSM_RECORD_STATUS_SIZE
);
char* recordStatusPtr = static_cast<char*>(region3.get_address());
*recordStatusPtr = 'W';
return 0;
}
void draw(SkCanvas* canvas) {
auto debugster = [](const char* label, SkRegion& region) -> void {
auto r = region.getBounds();
SkDebugf("%14s: {%d,%d,%d,%d}\n", label, r.fLeft, r.fTop, r.fRight, r.fBottom);
};
SkRegion region1({1, 2, 3, 4});
SkRegion region2;
region1.swap(region2);
debugster("region1 bounds", region1);
debugster("region2 bounds", region2);
}
void
SharedMemoryUtils::refreshMsm_Edit(char type, uint64_t mirandaId, std::wstring& displayName)
{
logger->log_p(L"SharedMemoryUtils.refreshMsm_Edit type=[%c], mirandaId=[%I64u]", type, mirandaId);
boost::ptr_list<boost::interprocess::windows_shared_memory>::iterator msmListIter;
for (msmListIter = msmList.begin(); msmListIter != msmList.end(); msmListIter++){
for (int recordNo = 0; recordNo < SMUCONST_MSM_RECORDS_COUNT; recordNo++ ){
boost::interprocess::mapped_region region1(
*msmListIter,
boost::interprocess::read_only,
SMUCONST_MSM_HEADER_SIZE + (recordNo * SMUCONST_MSM_RECORD_SIZE) + SMUCONST_MSM_RECORD_TYPE_RECOFFSET,
SMUCONST_MSM_RECORD_TYPE_SIZE
);
char* recordTypePtr = static_cast<char*>(region1.get_address());
if (*recordTypePtr == type){
boost::interprocess::mapped_region region2(
*msmListIter,
boost::interprocess::read_only,
SMUCONST_MSM_HEADER_SIZE + (recordNo * SMUCONST_MSM_RECORD_SIZE) + SMUCONST_MSM_RECORD_HANDLE_RECOFFSET,
SMUCONST_MSM_RECORD_HANDLE_SIZE
);
uint64_t* agcHandlePtr = static_cast<uint64_t*>(region2.get_address());
if (*agcHandlePtr == mirandaId){
boost::interprocess::mapped_region region3(
*msmListIter,
boost::interprocess::read_write,
SMUCONST_MSM_HEADER_SIZE + (recordNo * SMUCONST_MSM_RECORD_SIZE) + SMUCONST_MSM_RECORD_DNAME_RECOFFSET,
SMUCONST_MSM_RECORD_DNAME_SIZE
);
wchar_t* recordValuePtr = static_cast<wchar_t*>(region3.get_address());
wcsncpy_s(recordValuePtr, SMUCONST_MSM_RECORD_DNAME_SIZEC, displayName.c_str(), _TRUNCATE);
logger->log(L"SharedMemoryUtils::refreshMsm_Edit record found and edited");
// unique record found and edited
return;
}
}
}
}
return;
}
void
SharedMemoryUtils::updateCsmTimestamp(boost::interprocess::windows_shared_memory& updateCsm, uint16_t processCsmId)
{
uint16_t recordNo = processCsmId - 1;
boost::interprocess::mapped_region region1(
updateCsm,
boost::interprocess::read_write,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_KAT_RECOFFSET,
SMUCONST_CSM_RECORD_KAT_SIZE
);
time_t* recordKatPtr = static_cast<time_t*>(region1.get_address());
*recordKatPtr = mfGetCurrentTimestamp();
}
QList<Task*> CustomPatternAnnotationTask::onSubTaskFinished(Task* subTask) {
QList<Task*> subTasks;
if (!taskFeatureNames.contains(subTask)) {
return subTasks;
}
SArrayBasedFindTask* task = static_cast<SArrayBasedFindTask*> (subTask);
const QList<int>& results = task->getResults();
PatternInfo info = taskFeatureNames.take(task);
qint64 seqLen = dnaObj.getSequenceLength();
foreach (int pos, results) {
if (pos > dnaObj.getSequenceLength()) {
continue;
}
int endPos = pos + task->getQuery().length() - 1;
SharedAnnotationData data(new AnnotationData);
data->name = info.name;
U2Strand strand = info.forwardStrand ? U2Strand::Direct : U2Strand::Complementary;
data->setStrand(strand);
if (dnaObj.isCircular() && endPos > seqLen) {
int outerLen = endPos - seqLen;
int innerLen = task->getQuery().length() - outerLen;
U2Region region1(pos - 1, innerLen);
U2Region region2(0, outerLen);
data->location->regions << region1 << region2;
data->setLocationOperator(U2LocationOperator_Join);
} else {
U2Region region(pos - 1, task->getQuery().length());
data->location->regions << region;
}
annotations.append(data);
}
if (taskFeatureNames.isEmpty() && annotations.size() > 0) {
subTasks.append(new CreateAnnotationsTask(aTableObj, annotations, featureStore->getName()));
}
return subTasks;
}
bool
SharedMemoryUtils::isAnyMirandaCsmRecordAvailable(std::wstring& forThisProfileName)
{
for (int recordNo = 0; recordNo < SMUCONST_CSM_RECORDS_COUNT; recordNo++ ){
boost::interprocess::mapped_region region1(
*csm,
boost::interprocess::read_only,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_STATUS_RECOFFSET,
SMUCONST_CSM_RECORD_STATUS_SIZE
);
char* recordStatusPtr = static_cast<char*>(region1.get_address());
if (*recordStatusPtr == 'W'){
boost::interprocess::mapped_region region2(
*csm,
boost::interprocess::read_only,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_TYPE_RECOFFSET,
SMUCONST_CSM_RECORD_TYPE_SIZE
);
char* recordTypePtr = static_cast<char*>(region2.get_address());
if (*recordTypePtr == 'M'){
boost::interprocess::mapped_region region3(
*csm,
boost::interprocess::read_only,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_VISABLETO_RECOFFSET,
SMUCONST_CSM_RECORD_VISABLETO_SIZE
);
wchar_t* recordVisabletoPtr = static_cast<wchar_t*>(region3.get_address());
std::wstring visableTo = recordVisabletoPtr;
if (isTokenOnList(forThisProfileName, visableTo)){
return true;
}
}//end if M
}//end if W
}//end for
return false;
}
void
SharedMemoryUtils::refreshMsm_Delete(char type, uint64_t mirandaId)
{
logger->log_p(L"SharedMemoryUtils.refreshMsm_Delete type=[%c], mirandaId=[%I64u]", type, mirandaId);
boost::ptr_list<boost::interprocess::windows_shared_memory>::iterator msmListIter;
for (msmListIter = msmList.begin(); msmListIter != msmList.end(); msmListIter++){
for (int recordNo = 0; recordNo < SMUCONST_MSM_RECORDS_COUNT; recordNo++ ){
boost::interprocess::mapped_region region1(
*msmListIter,
boost::interprocess::read_write,
SMUCONST_MSM_HEADER_SIZE + (recordNo * SMUCONST_MSM_RECORD_SIZE) + SMUCONST_MSM_RECORD_TYPE_RECOFFSET,
SMUCONST_MSM_RECORD_TYPE_SIZE
);
char* recordTypePtr = static_cast<char*>(region1.get_address());
if (*recordTypePtr == type){
boost::interprocess::mapped_region region2(
*msmListIter,
boost::interprocess::read_only,
SMUCONST_MSM_HEADER_SIZE + (recordNo * SMUCONST_MSM_RECORD_SIZE) + SMUCONST_MSM_RECORD_HANDLE_RECOFFSET,
SMUCONST_MSM_RECORD_HANDLE_SIZE
);
uint64_t* agcHandlePtr = static_cast<uint64_t*>(region2.get_address());
if (*agcHandlePtr == mirandaId){
*recordTypePtr = 'D'; //[D] deleted - will not be read by other sm clients (even older)
logger->log(L"SharedMemoryUtils::refreshMsm_Delete record found and deleted");
// unique record found and edited
return;
}
}
}
}
return;
}
void
SharedMemoryUtils::checkAnotherCsm(boost::interprocess::windows_shared_memory& checkedCsm, uint16_t processCsmId){
time_t currentTimestamp = mfGetCurrentTimestamp();
for (uint16_t recordNo = 0; recordNo < SMUCONST_CSM_RECORDS_COUNT; recordNo++ ){
if (recordNo == processCsmId - 1){ //do not check own record
continue;
}
boost::interprocess::mapped_region region1(
checkedCsm,
boost::interprocess::read_write,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_STATUS_RECOFFSET,
SMUCONST_CSM_RECORD_STATUS_SIZE
);
char* recordStatusPtr = static_cast<char*>(region1.get_address());
if (*recordStatusPtr == 'W'){
//for every record in status (W) Working
boost::interprocess::mapped_region region2(
checkedCsm,
boost::interprocess::read_write,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_KAT_RECOFFSET,
SMUCONST_CSM_RECORD_KAT_SIZE
);
time_t* recordKatPtr = static_cast<time_t*>(region2.get_address());
double timeDiff = /*std::*/difftime(currentTimestamp, *recordKatPtr);
logger->log_p(L"checkAnotherCsm: recordNo=%u (processCsmId=%u) status==W timeDiff=%f", recordNo, recordNo+1, timeDiff);
if (timeDiff > CSMTHREAD_RECORD_MAXAGE){
logger->log(L"checkAnotherCsm: free record in CSM");
freeCsmRecord(checkedCsm, recordNo);
}
}//end if
}//end for
}
Blob MomentCalculation2::getMomentsInaBlob(Mat boxImage, Mat cmaskImage, string blobId,string profileId){
cvtColor(boxImage, boxImage, CV_BGR2HSV);
//Average
HumanProportions prop;
int boxHeight = boxImage.rows;
double ratio = (double)boxHeight / (double)prop.height;
int region1Height = (int)(((double)prop.head) * ratio);
int region2Height = (int)(((double)prop.gait) * ratio);
int region3Height = (int)(((double)prop.leg) * ratio);
string placement = "Top";
Region region1(placement, 0, 0, region1Height, boxImage.cols);
MomentCalculation2 mcalc;
MomentAverage momentAverage1 = mcalc.getAverageColourInConvexRegion(boxImage, cmaskImage, ®ion1);
MomentStandardDeviation momentStandardDeviation1 = mcalc.getStandardDeviationInConvexRegion(boxImage, cmaskImage, ®ion1, &momentAverage1);
MomentSkewness momentSkewness1 = mcalc.getSkewnessnInConvexRegion(boxImage, cmaskImage, ®ion1, &momentAverage1);
region1.setMoments(&momentAverage1, &momentStandardDeviation1, &momentSkewness1);
placement = "Middle";
Region region2(placement, 0, 0, region2Height, boxImage.cols);
MomentAverage momentAverage2 = mcalc.getAverageColourInConvexRegion(boxImage, cmaskImage, ®ion2);
MomentStandardDeviation momentStandardDeviation2 = mcalc.getStandardDeviationInConvexRegion(boxImage, cmaskImage, ®ion2, &momentAverage2);
MomentSkewness momentSkewness2 = mcalc.getSkewnessnInConvexRegion(boxImage, cmaskImage, ®ion2, &momentAverage2);
region2.setMoments(&momentAverage2, &momentStandardDeviation2, &momentSkewness2);
placement = "Bottum";
Region region3(placement, 0, 0, region3Height, boxImage.cols);
MomentAverage momentAverage3 = mcalc.getAverageColourInConvexRegion(boxImage, cmaskImage, ®ion3);
MomentStandardDeviation momentStandardDeviation3 = mcalc.getStandardDeviationInConvexRegion(boxImage, cmaskImage, ®ion3, &momentAverage3);
MomentSkewness momentSkewness3 = mcalc.getSkewnessnInConvexRegion(boxImage, cmaskImage, ®ion3, &momentAverage3);
region3.setMoments(&momentAverage3, &momentStandardDeviation3, &momentSkewness3);
Blob blob(blobId, boxImage.rows, boxImage.cols);
blob.human_id_actual = profileId;
blob.addRegion(®ion1);
blob.addRegion(®ion2);
blob.addRegion(®ion3);
return blob;
}
double Evaluate(double *x) {
if (x[0] <= p[16]){
return region1(x[0],p);
}
else if (x[0] <= p[17]){
return region2(x[0]-p[16],p);
}
else if (x[0] <= p[18]){
return region3(x[0]-p[17],p);
}
else if (x[0] <= p[19]){
return region4(x[0]-p[18],p);
}
else {
return region5(x[0]-p[19],p);
}
}
void
SharedMemoryUtils::initCsm(boost::interprocess::windows_shared_memory& csm)
{
//save csm header version
boost::interprocess::mapped_region region1(
csm,
boost::interprocess::read_write,
SMUCONST_CSM_HEADER_VERSION_OFFSET,
SMUCONST_CSM_HEADER_VERSION_SIZE
);
uint32_t* versionPtr = static_cast<uint32_t*>(region1.get_address());
*versionPtr = SMUCONST_CSM_CURRENT_VERSION;
//prepare records
for (uint16_t recordNo = 0; recordNo < SMUCONST_CSM_RECORDS_COUNT; recordNo++ ){
//save scm record id (=recordNo)
boost::interprocess::mapped_region region2(
csm,
boost::interprocess::read_write,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_RECID_RECOFFSET,
SMUCONST_CSM_RECORD_RECID_SIZE
);
uint16_t* recordIdPtr = static_cast<uint16_t*>(region2.get_address());
*recordIdPtr = recordNo + 1;
//save scm record status (=E (Empty))
boost::interprocess::mapped_region region3(
csm,
boost::interprocess::read_write,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_STATUS_RECOFFSET,
SMUCONST_CSM_RECORD_STATUS_SIZE
);
char* recordStatusPtr = static_cast<char*>(region3.get_address());
*recordStatusPtr = 'E';
}
}
int
SharedMemoryUtils::checkCsmRecord(boost::interprocess::windows_shared_memory& checkedCsm, uint16_t processCsmId, std::wstring& displayNameProfile)
{
uint16_t recordNo = processCsmId - 1;
boost::interprocess::mapped_region region1(
checkedCsm,
boost::interprocess::read_write,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_STATUS_RECOFFSET,
SMUCONST_CSM_RECORD_STATUS_SIZE
);
char* recordStatusPtr = static_cast<char*>(region1.get_address());
if (*recordStatusPtr == 'W'){
boost::interprocess::mapped_region region2(
checkedCsm,
boost::interprocess::read_only,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_DNAME_RECOFFSET,
SMUCONST_CSM_RECORD_DNAME_SIZE
);
wchar_t* displayNamePtr = static_cast<wchar_t*>(region2.get_address());
std::wstring displayNameSM = displayNamePtr;
if (displayNameSM.compare(displayNameProfile) == 0){
return 0; //OK
} else {
logger->log_p(L"checkCsmRecord not ok for processCsmId = %u: displayNameProfile [%s] doesn't match displayNameSM [%s].", processCsmId, displayNameProfile.c_str(), displayNameSM.c_str());
return 1; //csm record data corrupted - displayName not match
}
} else {
logger->log_p(L"checkCsmRecord not ok for processCsmId = %u: recordStatus is [%c] expected [W].", processCsmId, *recordStatusPtr);
return 1; //csm record data corrupted - not in state W
}
}
int
MessageQueueUtils::createMessageQueue(std::string mqName)
{
try{
//TODO access to mqMirSm is not synchronied, i think it's not neccessery
mqMirSm = new boost::interprocess::windows_shared_memory(
boost::interprocess::open_or_create, //TODO what if sm exists
mqName.c_str(),
boost::interprocess::read_write,
getMqMirSmTotalSize()
);
logger->log(L"MessageQueueUtils::createMessageQueue created mq by sm");
} catch (const boost::interprocess::interprocess_exception& ex) {
logger->log_p(L"MessageQueueUtils::createMessageQueue interprocess_exception: [%S] native_error=[%d] error_code=[%d]", ex.what(), ex.get_native_error(), ex.get_error_code() );
return 1; //error
} catch (...){
logger->log(L"MessageQueueUtils::createMessageQueue EXCEPTION: unknown");
return 1; //error
}
//initialize
boost::interprocess::mapped_region region1(
*mqMirSm,
boost::interprocess::read_write,
MQCONST_MQMIRSM_STATUS_OFFSET,
MQCONST_MQMIRSM_STATUS_SIZE
);
char* statusPtr = static_cast<char*>(region1.get_address());
*statusPtr = 'E';
return 0; //ok
}
void
MessageQueueUtils::sendMessage(int clientRecordId, char menuItemType, char userActionType, char userButton, uint64_t targetHandle, std::wstring userActionSelection)
{
logger->log(L"MessageQueueUtils::sendMessage");
//if text to send is too long
if (userActionSelection.size() > MQCONST_MQSM_TEXT_SIZEC){
userActionSelection.resize(MQCONST_MQSM_TEXT_SIZEC - 3);
userActionSelection.append(TEXT("..."));
}
try{
boost::interprocess::windows_shared_memory* sm = new boost::interprocess::windows_shared_memory(
boost::interprocess::open_only,
getMqName(clientRecordId).c_str(),
boost::interprocess::read_write);
if (sm == NULL){
logger->log(L"MessageQueueUtils::sendMessage (sm mode) sm == NULL");
return; //error
}
int counter = 0;
const int MQ_WAIT_TIME = 200; //[ms]
const int MAX_MQ_WAIT_COUNTER = 10; //10 * 200ms = 2s
bool sentSuccess = false;
do {
counter++;
WaitForSingleObject(smMutex, INFINITE);
boost::interprocess::mapped_region region1(
*sm,
boost::interprocess::read_write,
MQCONST_MQMIRSM_STATUS_OFFSET,
MQCONST_MQMIRSM_STATUS_SIZE
);
char* mqmirsmStatusPtr = static_cast<char*>(region1.get_address());
if (*mqmirsmStatusPtr == 'E'){
boost::interprocess::mapped_region region2(
*sm,
boost::interprocess::read_write,
MQCONST_MQMIRSM_MENUITEMTYPE_OFFSET,
MQCONST_MQMIRSM_MENUITEMTYPE_SIZE
);
char* menuItemTypePtr = static_cast<char*>(region2.get_address());
*menuItemTypePtr = menuItemType;
boost::interprocess::mapped_region region3(
*sm,
boost::interprocess::read_write,
MQCONST_MQMIRSM_USERACTIONTYPE_OFFSET,
MQCONST_MQMIRSM_USERACTIONTYPE_SIZE
);
char* userActionTypePtr = static_cast<char*>(region3.get_address());
*userActionTypePtr = userActionType;
boost::interprocess::mapped_region region4(
*sm,
boost::interprocess::read_write,
MQCONST_MQMIRSM_USERBUTTON_OFFSET,
MQCONST_MQMIRSM_USERBUTTON_SIZE
);
char* userButtonPtr = static_cast<char*>(region4.get_address());
*userButtonPtr = userButton;
boost::interprocess::mapped_region region5(
*sm,
boost::interprocess::read_write,
MQCONST_MQMIRSM_TARGETHANDLE_OFFSET,
MQCONST_MQMIRSM_TARGETHANDLE_SIZE
);
uint64_t* targetHandlePtr = static_cast<uint64_t*>(region5.get_address());
*targetHandlePtr = targetHandle;
boost::interprocess::mapped_region region6(
*sm,
boost::interprocess::read_write,
MQCONST_MQMIRSM_TEXTARRAY_OFFSET,
MQCONST_MQMIRSM_TEXTARRAY_SIZE
);
wchar_t* userActionSelectionPtr = static_cast<wchar_t*>(region6.get_address());
memset(userActionSelectionPtr, 0, MQCONST_MQMIRSM_TEXTARRAY_SIZE);
memcpy(userActionSelectionPtr, userActionSelection.c_str(), userActionSelection.length() * sizeof(wchar_t));
//update shared memory status to Message
*mqmirsmStatusPtr = 'M';
sentSuccess = true;
}
// else wait and repeat try
ReleaseMutex(smMutex);
if (!sentSuccess){
SleepEx(MQ_WAIT_TIME, TRUE);
}
} while (sentSuccess == false && counter <= MAX_MQ_WAIT_COUNTER);
if (!sentSuccess){
logger->log(L"MessageQueueUtils::sendMessage (sm mode) - MAX_MQ_WAIT_COUNTER exceeded but still sentSuccess == false");
}
delete sm;
} catch (const boost::interprocess::interprocess_exception& ex) {
logger->log_p(L"MessageQueueUtils::sendMessage (sm mode) interprocess_exception: [%S] native_error=[%d] error_code=[%d]", ex.what(), ex.get_native_error(), ex.get_error_code() );
return; //error
} catch (...){
logger->log(L"MessageQueueUtils::sendMessage (sm mode) EXCEPTION: unknown");
return; //error
}
}
int main()
{
srand(time(NULL));
int WIDTH(750), HEIGHT(750);
sf::RenderWindow window(sf::VideoMode(WIDTH, HEIGHT), "RTest");
window.setFramerateLimit(60);
RegionMap world(100, 80);
Region *region1(nullptr), *region2(nullptr);
std::vector<Region*> path;
double offsetX = 0;
sf::Vector2i clicPos;
sf::Transform slide, loopSlide;
while (window.isOpen())
{
sf::Vector2i localPosition = sf::Mouse::getPosition(window);
sf::Event event;
while (window.pollEvent(event))
{
if (event.type == sf::Event::Closed)
{
window.close();
}
else if (event.type == sf::Event::MouseButtonPressed)
{
clicPos = localPosition;
}
}
if (sf::Mouse::isButtonPressed(sf::Mouse::Left))
{
region1 = world.getRegionAt(localPosition.x, localPosition.y);
int move = localPosition.x-clicPos.x;
offsetX += move;
slide.translate(sf::Vector2f(move, 0));
if (offsetX > 0)
loopSlide.translate(sf::Vector2f(move-WIDTH, 0));
else
loopSlide.translate(sf::Vector2f(move+WIDTH, 0));
clicPos = localPosition;
}
Region* newRegion2 = world.getRegionAt(localPosition.x, localPosition.y);
if (newRegion2 != region2 && newRegion2)
{
region2 = newRegion2;
path = world.getRoute(region1, region2);
}
sf::VertexArray routes(sf::Lines, 0);
if (path.size())
{
for (unsigned int i(0); i<path.size()-1; ++i)
{
unsigned int x = path[i]->capital()._x;
unsigned int y = path[i]->capital()._y;
sf::Vertex routePoint;
routePoint.position = sf::Vector2f(x, y);
routePoint.color = sf::Color::Red;
routes.append(routePoint);
routePoint.position = sf::Vector2f(path[i+1]->capital()._x, path[i+1]->capital()._y);
routePoint.color = sf::Color::Red;
routes.append(routePoint);
}
}
window.clear(sf::Color::White);
world.render(&window, slide);
window.draw(routes, slide);
window.draw(routes, loopSlide);
window.display();
}
return 0;
}
int
SharedMemoryUtils::addRecordToMsm(char type, uint64_t agcHandle, uint64_t accountHandle, uint64_t groupHandle, char status, std::wstring& value)
{
logger->log_p(L"addRecordToMsm: type=[%c], agcHandle=[%I64u], accountHandle=[%I64u], groupHandle=[%I64u], status=[%c], value=[%s], agcHandle=[%I64u]",
type, agcHandle, accountHandle, groupHandle, status==NULL?'-':status , value.c_str(), agcHandle);
//if there is not enought space in current msm - create new one
if (freeMsmRecordsCount == 0){
std::size_t msmTotalSize = getMsmTotalSize();
std::string msmName = getMsmName(processCsmId, nextMsmNumber);
logger->log_p(L"create new MSM msmName=[%S] " SCNuPTR L" Bytes (schould be 32768 B)", msmName.c_str(), msmTotalSize);
boost::interprocess::windows_shared_memory* msm;
msm = new boost::interprocess::windows_shared_memory(
boost::interprocess::open_or_create,
msmName.c_str(),
boost::interprocess::read_write,
msmTotalSize
); //TODO exception handling //TODO delete msm
//zero shared memory (neccessery if sm was opened(it is old wrong msm from deleted miranda msm record so it contains old bad data))
boost::interprocess::mapped_region regionToDel(
*msm,
boost::interprocess::read_write,
0,
msmTotalSize
);
memset(regionToDel.get_address(), 0, msmTotalSize);
//set isLastNodePtr initial value to 0 , will be update at commitCSM()
boost::interprocess::mapped_region region1(
*msm,
boost::interprocess::read_write,
SMUCONST_MSM_HEADER_ISLAST_OFFSET,
SMUCONST_MSM_HEADER_ISLAST_SIZE
);
char* isLastNodePtr = static_cast<char*>(region1.get_address());
*isLastNodePtr = '0';
//TODO - set all records to type 'E'Empty
msmList.push_back(msm);
nextMsmNumber++;
freeMsmRecordsCount = SMUCONST_MSM_RECORDS_COUNT;
}
boost::interprocess::windows_shared_memory * currentMsm = &(msmList.back());
//save data to record
int actualRecordOffset = SMUCONST_MSM_RECORDS_OFFSET + ((SMUCONST_MSM_RECORDS_COUNT - freeMsmRecordsCount) * SMUCONST_MSM_RECORD_SIZE);
//char type
boost::interprocess::mapped_region region1(
*currentMsm,
boost::interprocess::read_write,
actualRecordOffset + SMUCONST_MSM_RECORD_TYPE_RECOFFSET,
SMUCONST_MSM_RECORD_TYPE_SIZE
);
char* recordTypePtr = static_cast<char*>(region1.get_address());
*recordTypePtr = type;
//HANDLE agcHandle
boost::interprocess::mapped_region region2(
*currentMsm,
boost::interprocess::read_write,
actualRecordOffset + SMUCONST_MSM_RECORD_HANDLE_RECOFFSET,
SMUCONST_MSM_RECORD_HANDLE_SIZE
);
uint64_t* agcHandlePtr = static_cast<uint64_t*>(region2.get_address());
*agcHandlePtr = agcHandle;
//HANDLE accountHandle
boost::interprocess::mapped_region region3(
*currentMsm,
boost::interprocess::read_write,
actualRecordOffset + SMUCONST_MSM_RECORD_ACCOUNTH_RECOFFSET,
SMUCONST_MSM_RECORD_ACCOUNTH_SIZE
);
uint64_t* accountHandlePtr = static_cast<uint64_t*>(region3.get_address());
*accountHandlePtr = accountHandle;
//HANDLE groupHandle
boost::interprocess::mapped_region region4(
*currentMsm,
boost::interprocess::read_write,
actualRecordOffset + SMUCONST_MSM_RECORD_GROUPH_RECOFFSET,
SMUCONST_MSM_RECORD_GROUPH_SIZE
);
uint64_t* groupHandlePtr = static_cast<uint64_t*>(region4.get_address());
*groupHandlePtr = groupHandle;
//char status
boost::interprocess::mapped_region region5(
*currentMsm,
boost::interprocess::read_write,
actualRecordOffset + SMUCONST_MSM_RECORD_STATUS_RECOFFSET,
SMUCONST_MSM_RECORD_STATUS_SIZE
);
char* recordStatusPtr = static_cast<char*>(region5.get_address());
*recordStatusPtr = status;
//std::wstring& value
boost::interprocess::mapped_region region6(
*currentMsm,
boost::interprocess::read_write,
actualRecordOffset + SMUCONST_MSM_RECORD_DNAME_RECOFFSET,
SMUCONST_MSM_RECORD_DNAME_SIZE
);
wchar_t* recordValuePtr = static_cast<wchar_t*>(region6.get_address());
wcsncpy_s(recordValuePtr, SMUCONST_MSM_RECORD_DNAME_SIZEC, value.c_str(), _TRUNCATE);
freeMsmRecordsCount --;
return 0;
}
/**
* return true if message was received and variables are available
*/
bool
MessageQueueUtils::tryReceiveMessage(char& menuItemType, char& userActionType, char& userButton, uint64_t& targetHandle, wchar_t*& userActionSelection, size_t uasBuffCSize)
{
try{
WaitForSingleObject(smMutex, 100000);
boost::interprocess::mapped_region region1(
*mqMirSm,
boost::interprocess::read_write,
MQCONST_MQMIRSM_STATUS_OFFSET,
MQCONST_MQMIRSM_STATUS_SIZE
);
char* mqmirsmStatusPtr = static_cast<char*>(region1.get_address());
if (*mqmirsmStatusPtr != 'M'){
ReleaseMutex(smMutex);
return false;
}
//there is a new message in the queue (sm mode) *mqmirsmStatusPtr=='M'
//transfer data from shared memory to variables
boost::interprocess::mapped_region region2(
*mqMirSm,
boost::interprocess::read_only,
MQCONST_MQMIRSM_MENUITEMTYPE_OFFSET,
MQCONST_MQMIRSM_MENUITEMTYPE_SIZE
);
menuItemType = *(static_cast<char*>(region2.get_address()));
boost::interprocess::mapped_region region3(
*mqMirSm,
boost::interprocess::read_only,
MQCONST_MQMIRSM_USERACTIONTYPE_OFFSET,
MQCONST_MQMIRSM_USERACTIONTYPE_SIZE
);
userActionType = *(static_cast<char*>(region3.get_address()));
boost::interprocess::mapped_region region4(
*mqMirSm,
boost::interprocess::read_only,
MQCONST_MQMIRSM_USERBUTTON_OFFSET,
MQCONST_MQMIRSM_USERBUTTON_SIZE
);
userButton = *(static_cast<char*>(region4.get_address()));
boost::interprocess::mapped_region region5(
*mqMirSm,
boost::interprocess::read_only,
MQCONST_MQMIRSM_TARGETHANDLE_OFFSET,
MQCONST_MQMIRSM_TARGETHANDLE_SIZE
);
targetHandle = *(static_cast<uint64_t*>(region5.get_address()));
boost::interprocess::mapped_region region6(
*mqMirSm,
boost::interprocess::read_only,
MQCONST_MQMIRSM_TEXTARRAY_OFFSET,
MQCONST_MQMIRSM_TEXTARRAY_SIZE
);
wchar_t* userActionSelectionPtr = static_cast<wchar_t*>(region6.get_address());
wcsncpy_s(userActionSelection, uasBuffCSize, userActionSelectionPtr, MQCONST_MQMIRSM_TEXTARRAY_SIZEC);
//update shared memory status to Empty
*mqmirsmStatusPtr = 'E';
ReleaseMutex(smMutex);
} catch (const boost::interprocess::interprocess_exception& ex) {
logger->log_p(L"MessageQueueUtils::tryReceiveMessage interprocess_exception: [%S] native_error=[%d] error_code=[%d]", ex.what(), ex.get_native_error(), ex.get_error_code() );
return false;
} catch (...){
logger->log(L"MessageQueueUtils::tryReceiveMessage EXCEPTION: unknown");
return false;
}
logger->log_p(L"MessageQueueUtils::tryReceiveMessage (mq mode) RECEIVED DATA: menuItemType = [%c] userActionType = [%c] userButton = [%c] targetHandle = [%I64u]",
menuItemType, userActionType, userButton, targetHandle);
return true;
}
int
SharedMemoryUtils::getClientInstances(boost::ptr_list<ClientInstanceClass> * clientInstancesListPtr, std::wstring& forThisProfileName)
{
if (clientInstancesListPtr==NULL){
logger->log(L"SharedMemoryUtils::getClientInstances clientInstancesListPtr==NULL");
return -1;
}
int count = 0;
for (int recordNo = 0; recordNo < SMUCONST_CSM_RECORDS_COUNT; recordNo++ ){
boost::interprocess::mapped_region region1(
*csm,
boost::interprocess::read_only,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_STATUS_RECOFFSET,
SMUCONST_CSM_RECORD_STATUS_SIZE
);
char* recordStatusPtr = static_cast<char*>(region1.get_address());
if (*recordStatusPtr == 'W'){
boost::interprocess::mapped_region region2(
*csm,
boost::interprocess::read_only,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_TYPE_RECOFFSET,
SMUCONST_CSM_RECORD_TYPE_SIZE
);
char* recordTypePtr = static_cast<char*>(region2.get_address());
if (*recordTypePtr == 'M'){
boost::interprocess::mapped_region region3(
*csm,
boost::interprocess::read_only,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_VISABLETO_RECOFFSET,
SMUCONST_CSM_RECORD_VISABLETO_SIZE
);
wchar_t* recordVisabletoPtr = static_cast<wchar_t*>(region3.get_address());
std::wstring visableTo = recordVisabletoPtr;
if (isTokenOnList(forThisProfileName, visableTo)){
//this instance match all conditions
//get its name and id (recordNo)
ClientInstanceClass* clientInstance = new ClientInstanceClass();
boost::interprocess::mapped_region region4(
*csm,
boost::interprocess::read_write,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_RECID_RECOFFSET,
SMUCONST_CSM_RECORD_RECID_SIZE
);
uint16_t* recordIdPtr = static_cast<uint16_t*>(region4.get_address());
clientInstance->recordId = *recordIdPtr;
boost::interprocess::mapped_region region5(
*csm,
boost::interprocess::read_only,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_DNAME_RECOFFSET,
SMUCONST_CSM_RECORD_DNAME_SIZE
);
wchar_t* displayNamePtr = static_cast<wchar_t*>(region5.get_address());
clientInstance->displayName = displayNamePtr;
clientInstancesListPtr->push_back(clientInstance);
count++;
}
}//end if M
}//end if W
}//end for
logger->log_p(L"SharedMemoryUtils::getClientInstances return count = %d", count);
return count;
}
int
SharedMemoryUtils::getAccounts(boost::ptr_list<AccountClass> * accountsListPtr, unsigned short clientRecordNo)
{
if (accountsListPtr==NULL){
logger->log(L"SharedMemoryUtils::getAccounts contactsListPtr==NULL");
return -1;
}
bool isMsmAvailable = true;
int msmNumber = 1;
std::string msmName;
boost::interprocess::windows_shared_memory* msm;
int foundAccountsCount = 0;
do {
//get MSM to seek accounts
msmName = getMsmName(clientRecordNo, msmNumber);
msmNumber++;
try {
msm = new boost::interprocess::windows_shared_memory(
boost::interprocess::open_only,
msmName.c_str(),
boost::interprocess::read_only);
} catch (const boost::interprocess::interprocess_exception& ex) {
isMsmAvailable = false;
logger->log_p(L"SharedMemoryUtils::getAccounts (isMsmAvailable = false) interprocess_exception: [%S] native_error=[%d] error_code=[%d]", ex.what(), ex.get_native_error(), ex.get_error_code() );
} catch (...){
isMsmAvailable = false;
logger->log(L"SharedMemoryUtils::getAccounts (isMsmAvailable = false) EXCEPTION: unknown");
}
//TODO problems with this catch
if(isMsmAvailable){
for (int recordNo = 0; recordNo < SMUCONST_MSM_RECORDS_COUNT; recordNo++ ){
boost::interprocess::mapped_region region1(
*msm,
boost::interprocess::read_only,
SMUCONST_MSM_HEADER_SIZE + (recordNo * SMUCONST_MSM_RECORD_SIZE) + SMUCONST_MSM_RECORD_TYPE_RECOFFSET,
SMUCONST_MSM_RECORD_TYPE_SIZE
);
char* recordTypePtr = static_cast<char*>(region1.get_address());
if (*recordTypePtr == 'A'){ //Account
AccountClass* accountInstance = new AccountClass();
boost::interprocess::mapped_region region2(
*msm,
boost::interprocess::read_only,
SMUCONST_MSM_HEADER_SIZE + (recordNo * SMUCONST_MSM_RECORD_SIZE) + SMUCONST_MSM_RECORD_DNAME_RECOFFSET,
SMUCONST_MSM_RECORD_DNAME_SIZE
);
wchar_t* displayNamePtr = static_cast<wchar_t*>(region2.get_address());
accountInstance->displayName = displayNamePtr;
boost::interprocess::mapped_region region3(
*msm,
boost::interprocess::read_only,
SMUCONST_MSM_HEADER_SIZE + (recordNo * SMUCONST_MSM_RECORD_SIZE) + SMUCONST_MSM_RECORD_HANDLE_RECOFFSET,
SMUCONST_MSM_RECORD_HANDLE_SIZE
);
uint64_t* agcHandlePtr = static_cast<uint64_t*>(region3.get_address());
accountInstance->handle = *agcHandlePtr;
accountsListPtr->push_back(accountInstance);
foundAccountsCount++;
}
//TODO - set all records to type 'E'Empty - if E break for
} //end for
//check SMUCONST_MSM_HEADER_ISLAST_OFFSET
boost::interprocess::mapped_region region4(
*msm,
boost::interprocess::read_only,
SMUCONST_MSM_HEADER_ISLAST_OFFSET,
SMUCONST_MSM_HEADER_ISLAST_SIZE
);
char* isLastNodePtr = static_cast<char*>(region4.get_address());
if (*isLastNodePtr == '1'){
isMsmAvailable = false;
logger->log(L"SharedMemoryUtils::getAccounts - isLastNodePtr - isMsmAvailable = false");
}
}// end if
} while (isMsmAvailable);
logger->log_p(L"SharedMemoryUtils::getAccounts return foundAccountsCount = %d", foundAccountsCount);
return foundAccountsCount;
}
int GeometryClipmaps::updateLevel( GeometryClipmapLevel& level,
GeometryClipmapLevel* parentLevel,
const Pnt2i& newOrigin )
{
//todo: move this into the GeometryClipmapLevel class??
// how much samples do we have to update?
const Pnt2i oldOrigin = level.sampleOrigin;
const Pnt2i updateSampleCount = newOrigin - oldOrigin;
const bool forceFullUpdate = level.isSampleDataDirty;
if( !forceFullUpdate && oldOrigin == newOrigin )
{
// nothing to do:
return 0;
}
//SLOG << "Level " << level.index << " moved by " << updateSampleCount << " oldOrigin = " << oldOrigin << " newOrigin = " << newOrigin << "\n";
// whatever we need to do: the origin is now here:
level.sampleOrigin = newOrigin;
const int levelSampleCount = level.heightmap.size;
const int levelSampleSpacing = level.sampleSpacing;
const bool fullBlockUpdate = ( abs( updateSampleCount[ 0 ] ) >= levelSampleCount ) ||
( abs( updateSampleCount[ 1 ] ) >= levelSampleCount );
int updatedSampleCount = 0;
if( fullBlockUpdate || forceFullUpdate )
{
// full block update:
// reset the block origin:
level.blockOrigin.setValues( 0, 0 );
updatedSampleCount += updateLevelBlock( level,
parentLevel,
Rectangle2i( 0, 0, levelSampleCount, levelSampleCount ) );
}
else if( updateSampleCount[ 0 ] != 0 || updateSampleCount[ 1 ] != 0 )
{
Pnt2i levelSampleCount2d( levelSampleCount, levelSampleCount );
// adjust adressing..
Pnt2i blockDelta = componentDivide( updateSampleCount, levelSampleSpacing );
Pnt2i oldBlockOrigin( level.blockOrigin[ 0 ], level.blockOrigin[ 1 ] );
// update block origin:
Pnt2i newBlockOrigin = componentModulo( componentAdd( componentAdd( oldBlockOrigin, blockDelta ), levelSampleCount2d ), levelSampleCount2d );
assert( newBlockOrigin[ 0 ] >= 0 );
assert( newBlockOrigin[ 1 ] >= 0 );
assert( newBlockOrigin[ 0 ] < levelSampleCount );
assert( newBlockOrigin[ 1 ] < levelSampleCount );
level.blockOrigin = newBlockOrigin;
// update the dirty Rects:
// in general the update region is ? shaped: (we do 1 or 2 rectangular updates)
Rectangle2i region1( 0, 0, levelSampleCount, levelSampleCount );
Rectangle2i region2( 0, 0, levelSampleCount, levelSampleCount );
Rectangle2i region3( 0, 0, levelSampleCount, levelSampleCount );
if( blockDelta[ 0 ] > 0 )
{
region1._x0 = oldBlockOrigin[ 0 ];
region1._x1 = region1._x0 + blockDelta[ 0 ];
}
else if( blockDelta[ 0 ] < 0 )
{
region1._x0 = newBlockOrigin[ 0 ];
region1._x1 = region1._x0 - blockDelta[ 0 ];
}
else
{
// region 1 is empty:
region1.setValues( 0, 0, 0, 0 );
}
if( blockDelta[ 1 ] > 0 )
{
region2._y0 = oldBlockOrigin[ 1 ];
region2._y1 = region2._y0 + blockDelta[ 1 ];
}
else if( blockDelta[ 1 ] < 0 )
{
region2._y0 = newBlockOrigin[ 1 ];
region2._y1 = region2._y0 - blockDelta[ 1 ];
}
else
{
// region 1 is empty:
region2.setValues( 0, 0, 0, 0 );
}
updatedSampleCount += updateBigLevelBlock( level, parentLevel, region1 );
updatedSampleCount += updateBigLevelBlock( level, parentLevel, region2 );
}
// for debugging:
//checkLevelBlock( level, Rectangle2i( 0, 0, levelSampleCount, levelSampleCount ) );
cpuRenderer_.rebuildIndices( level );
if( parentLevel )
{
// todo: is this really needed every frame?
cpuRenderer_.rebuildIndices( *parentLevel );
}
// determine min/max sample:
level.heightmap.updateMinMaxSamples();
// activate this level:
level.isActive = true;
// we just updated the data:
level.isSampleDataDirty = false;
// todo: make this work:
return updatedSampleCount;
//return 0;
}
//recordNo === processCsmId -1
void
SharedMemoryUtils::freeCsmRecord(boost::interprocess::windows_shared_memory& csm, uint16_t recordNo)
{
logger->log_p(L"freeCsmRecord: recordNo = %u processCsmId = %u", recordNo, recordNo+1);
//zero type
boost::interprocess::mapped_region region1(
csm,
boost::interprocess::read_write,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_TYPE_RECOFFSET,
SMUCONST_CSM_RECORD_TYPE_SIZE
);
char* recordTypePtr = static_cast<char*>(region1.get_address());
*recordTypePtr = (char)0;
//zero keepalive timestamp
boost::interprocess::mapped_region region2(
csm,
boost::interprocess::read_write,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_KAT_RECOFFSET,
SMUCONST_CSM_RECORD_KAT_SIZE
);
time_t* recordKatPtr = static_cast<time_t*>(region2.get_address());
*recordKatPtr = (time_t)0;
//zero msm timestamp
boost::interprocess::mapped_region region3(
csm,
boost::interprocess::read_write,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_MSMT_RECOFFSET,
SMUCONST_CSM_RECORD_MSMT_SIZE
);
time_t* recordMsmtPtr = static_cast<time_t*>(region3.get_address());
*recordMsmtPtr = (time_t)0;
//zero displayname
boost::interprocess::mapped_region region4(
csm,
boost::interprocess::read_write,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_DNAME_RECOFFSET,
SMUCONST_CSM_RECORD_DNAME_SIZE
);
memset(region4.get_address(), 0, SMUCONST_CSM_RECORD_DNAME_SIZE);
//zero visableto
boost::interprocess::mapped_region region5(
csm,
boost::interprocess::read_write,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_VISABLETO_RECOFFSET,
SMUCONST_CSM_RECORD_VISABLETO_SIZE
);
memset(region5.get_address(), 0, SMUCONST_CSM_RECORD_VISABLETO_SIZE);
//status = E
boost::interprocess::mapped_region region6(
csm,
boost::interprocess::read_write,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_STATUS_RECOFFSET,
SMUCONST_CSM_RECORD_STATUS_SIZE
);
char* recordStatusPtr = static_cast<char*>(region6.get_address());
*recordStatusPtr = 'E';
}
/**
*
* return
* >0 - id of assigned record
* -1 - no empty record found
*/
uint16_t
SharedMemoryUtils::allocateRecordInCsm(boost::interprocess::windows_shared_memory& csm, char type, std::wstring& displayName, std::wstring& visableTo, bool doCommitSM)
{
//try to find first record with status E (Empty) in CSM
for (unsigned short recordNo = 0; recordNo < SMUCONST_CSM_RECORDS_COUNT; recordNo++ ){
boost::interprocess::mapped_region region1(
csm,
boost::interprocess::read_write,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_STATUS_RECOFFSET,
SMUCONST_CSM_RECORD_STATUS_SIZE
);
char* recordStatusPtr = static_cast<char*>(region1.get_address());
if (*recordStatusPtr == 'E'){
//save new status 'N' (New)
*recordStatusPtr = 'N';
//save type
boost::interprocess::mapped_region region2(
csm,
boost::interprocess::read_write,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_TYPE_RECOFFSET,
SMUCONST_CSM_RECORD_TYPE_SIZE
);
char* recordTypePtr = static_cast<char*>(region2.get_address());
*recordTypePtr = type;
//save first keep alive timestamp
boost::interprocess::mapped_region region3(
csm,
boost::interprocess::read_write,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_KAT_RECOFFSET,
SMUCONST_CSM_RECORD_KAT_SIZE
);
time_t* recordKatPtr = static_cast<time_t*>(region3.get_address());
*recordKatPtr = mfGetCurrentTimestamp();
//save version
boost::interprocess::mapped_region region4(
csm,
boost::interprocess::read_write,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_VERSION_RECOFFSET,
SMUCONST_CSM_RECORD_VERSION_SIZE
);
uint16_t* recordVersionPtr = static_cast<uint16_t*>(region4.get_address());
*recordVersionPtr = SMUCONST_CSM_CURRENT_RECORDVERSION;
//save display name
boost::interprocess::mapped_region region5(
csm,
boost::interprocess::read_write,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_DNAME_RECOFFSET,
SMUCONST_CSM_RECORD_DNAME_SIZE
);
wchar_t* recordDnamePtr = static_cast<wchar_t*>(region5.get_address());
wcsncpy_s(recordDnamePtr, SMUCONST_CSM_RECORD_DNAME_SIZEC, displayName.c_str(), _TRUNCATE);
//save visableTo
boost::interprocess::mapped_region region6(
csm,
boost::interprocess::read_write,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_VISABLETO_RECOFFSET,
SMUCONST_CSM_RECORD_VISABLETO_SIZE
);
wchar_t* recordVisabletoPtr = static_cast<wchar_t*>(region6.get_address());
wcsncpy_s(recordVisabletoPtr, SMUCONST_CSM_RECORD_VISABLETO_SIZEC, visableTo.c_str(), _TRUNCATE);
//get id
boost::interprocess::mapped_region region7(
csm,
boost::interprocess::read_write,
SMUCONST_CSM_HEADER_SIZE + (recordNo * SMUCONST_CSM_RECORD_SIZE) + SMUCONST_CSM_RECORD_RECID_RECOFFSET,
SMUCONST_CSM_RECORD_RECID_SIZE
);
uint16_t* recordIdPtr = static_cast<uint16_t*>(region7.get_address());
if (doCommitSM){
*recordStatusPtr = 'W';
}
logger->log_p(L"allocateRecordInCsm: allocated record with id (processCsmId): %u", *recordIdPtr);
return *recordIdPtr;
}//end if
}//end for
logger->log(L"allocateRecordInCsm: no empty records in CSM. return -1");
return -2;
}
double region2(double x, double *p){
return (p[5]*(x) + p[6]*x*x + region1(p[16],p) );
}
TEST_F(TestConcurrentCompositeStateNoArgs,MultipleRegions)
{
typedef TestConcurrentCompositeStateNoArgsMock
< TestStateMachineNoEventArgsMock
> ConcurrentCompositeStateMockType;
::testing::NiceMock<TestStateMachineNoEventArgsMock> stateMachine;
::testing::NiceMock
< ConcurrentCompositeStateMockType
> compositeState(&stateMachine);
::testing::NiceMock
< TestRegionNoArgsMock<ConcurrentCompositeStateMockType>
> region1(&compositeState);
::testing::NiceMock
< TestRegionNoArgsMock<ConcurrentCompositeStateMockType>
> region2(&compositeState);
stateMachine.autoFinalize(false);
compositeState.setRegion(0,®ion1);
compositeState.setRegion(1,®ion2);
stateMachine.initialState(&compositeState);
// Setup mock call expectations
//----------------------------------------------------------------------------
EXPECT_CALL(compositeState,entryImpl(&stateMachine))
.Times(1);
EXPECT_CALL(compositeState,startDoImpl(&stateMachine))
.Times(1);
EXPECT_CALL(compositeState,endDoImpl(&stateMachine))
.Times(1);
EXPECT_CALL(compositeState,exitImpl(&stateMachine))
.Times(1);
// Check region calls
EXPECT_CALL(region1,enterRegionImpl(&compositeState))
.Times(1);
EXPECT_CALL(region1,startingRegionThread())
.Times(1);
EXPECT_CALL(region1,initializeImpl(_))
.Times(1);
EXPECT_CALL(region1,handleEvent1(&compositeState,®ion1))
.Times(1);
EXPECT_CALL(region1,handleEvent2(&compositeState,®ion1))
.Times(1);
EXPECT_CALL(region1,handleEvent3(&compositeState,®ion1))
.Times(1);
EXPECT_CALL(region1,handleEvent4(&compositeState,®ion1))
.Times(1);
EXPECT_CALL(region1,finalizeImpl(_))
.Times(1);
EXPECT_CALL(region1,endingRegionThread())
.Times(1);
EXPECT_CALL(region1,exitRegionImpl(&compositeState))
.Times(1);
EXPECT_CALL(region2,enterRegionImpl(&compositeState))
.Times(1);
EXPECT_CALL(region2,startingRegionThread())
.Times(1);
EXPECT_CALL(region2,initializeImpl(_))
.Times(1);
EXPECT_CALL(region2,handleEvent1(&compositeState,®ion2))
.Times(1);
EXPECT_CALL(region2,handleEvent2(&compositeState,®ion2))
.Times(1);
EXPECT_CALL(region2,handleEvent3(&compositeState,®ion2))
.Times(1);
EXPECT_CALL(region2,handleEvent4(&compositeState,®ion2))
.Times(1);
EXPECT_CALL(region2,finalizeImpl(_))
.Times(1);
EXPECT_CALL(region2,endingRegionThread())
.Times(1);
EXPECT_CALL(region2,exitRegionImpl(&compositeState))
.Times(1);
// Run the state machine
//----------------------------------------------------------------------------
// STTCL_TEST_LOG_ALL();
// compositeState.enableLogging(true);
// innerState.enableLogging(true);
stateMachine.initialize();
// Give the region thread(s) a chance to run
sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100));
stateMachine.triggerEvent1();
// Give the region thread(s) a chance to run
sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100));
stateMachine.triggerEvent2();
// Give the region thread(s) a chance to run
sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100));
stateMachine.triggerEvent3();
// Give the region thread(s) a chance to run
sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100));
stateMachine.triggerEvent4();
// Give the region thread(s) a chance to run
sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100));
stateMachine.finalize();
// Give the region thread(s) a chance to run
sttcl::internal::SttclThread<>::sleep(sttcl::TimeDuration<>(0,0,0,100));
EXPECT_TRUE(region1.waitForDoActionExited(sttcl::TimeDuration<>(0,0,0,100),10));
// STTCL_TEST_LOG_END();
}
void CtrlImage::draw( OSGraphics &rImage, int xDest, int yDest, int w, int h )
{
const Position *pPos = getPosition();
if( !pPos )
return;
int width = pPos->getWidth();
int height = pPos->getHeight();
if( width <= 0 || height <= 0 )
return;
rect region( pPos->getLeft(), pPos->getTop(),
pPos->getWidth(), pPos->getHeight() );
rect clip( xDest, yDest, w, h );
rect inter;
if( !rect::intersect( region, clip, &inter ) )
return;
if( m_resizeMethod == kScale )
{
// Use scaling method
if( width != m_pImage->getWidth() ||
height != m_pImage->getHeight() )
{
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
// Rescale the image with the actual size of the control
ScaledBitmap bmp( getIntf(), *m_pBitmap, width, height );
delete m_pImage;
m_pImage = pOsFactory->createOSGraphics( width, height );
m_pImage->drawBitmap( bmp, 0, 0 );
}
rImage.drawGraphics( *m_pImage,
inter.x - pPos->getLeft(),
inter.y - pPos->getTop(),
inter.x, inter.y,
inter.width, inter.height );
}
else if( m_resizeMethod == kMosaic )
{
int xDest0 = pPos->getLeft();
int yDest0 = pPos->getTop();
// Use mosaic method
while( width > 0 )
{
int curWidth = __MIN( width, m_pImage->getWidth() );
height = pPos->getHeight();
int curYDest = yDest0;
while( height > 0 )
{
int curHeight = __MIN( height, m_pImage->getHeight() );
rect region1( xDest0, curYDest, curWidth, curHeight );
rect inter1;
if( rect::intersect( region1, clip, &inter1 ) )
{
rImage.drawGraphics( *m_pImage,
inter1.x - region1.x,
inter1.y - region1.y,
inter1.x, inter1.y,
inter1.width, inter1.height );
}
curYDest += curHeight;
height -= m_pImage->getHeight();
}
xDest0 += curWidth;
width -= m_pImage->getWidth();
}
}
else if( m_resizeMethod == kScaleAndRatioPreserved )
{
int w0 = m_pBitmap->getWidth();
int h0 = m_pBitmap->getHeight();
int scaled_height = width * h0 / w0;
int scaled_width = height * w0 / h0;
// new image scaled with aspect ratio preserved
// and centered inside the control boundaries
int w, h;
if( scaled_height > height )
{
w = scaled_width;
h = height;
m_x = ( width - w ) / 2;
m_y = 0;
}
else
{
w = width;
h = scaled_height;
m_x = 0;
m_y = ( height - h ) / 2;
}
// rescale the image if size changed
if( w != m_pImage->getWidth() ||
h != m_pImage->getHeight() )
{
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
ScaledBitmap bmp( getIntf(), *m_pBitmap, w, h );
delete m_pImage;
m_pImage = pOsFactory->createOSGraphics( w, h );
m_pImage->drawBitmap( bmp, 0, 0 );
}
// draw the scaled image at offset (m_x, m_y) from control origin
rect region1( pPos->getLeft() + m_x, pPos->getTop() + m_y, w, h );
rect inter1;
if( rect::intersect( region1, inter, &inter1 ) )
{
rImage.drawGraphics( *m_pImage,
inter1.x - pPos->getLeft() - m_x,
inter1.y - pPos->getTop() - m_y,
inter1.x, inter1.y,
inter1.width, inter1.height );
}
}
}
MVOID HalSensorList::querySensorDrvInfo()
{
MUINT i = 0, ret = 0;
MINT sensorDev;
SensorDrv *const pSensorDrv = SensorDrv::get();
#ifdef MTK_MAIN2_IMGSENSOR
for (sensorDev = SENSOR_MAIN; sensorDev <= SENSOR_MAIN_2; sensorDev <<= 1) {
#else
#ifdef MTK_SUB_IMGSENSOR
for (sensorDev = SENSOR_MAIN; sensorDev <= SENSOR_SUB; sensorDev <<= 1) {
#else
for (sensorDev = SENSOR_MAIN; sensorDev < SENSOR_SUB; sensorDev <<= 1) {
#endif
#endif
pSensorDrv->init((SENSOR_DEV_ENUM)sensorDev);
pSensorDrv->getInfo2((SENSOR_DEV_ENUM)sensorDev,&sensorDrvInfo[i]);
ret = getRawInfo((SENSOR_DEV_ENUM)sensorDev, &sensorRawInfo[i]);
i++;
pSensorDrv->uninit();
}
querySensorInfo();//to remap data
}
MUINT HalSensorList::getRawInfo(SENSOR_DEV_ENUM sensorDevId, SENSOR_HAL_RAW_INFO_STRUCT *pInfo)
{
MUINT32 ret = 0;
SensorDrv *const pSensorDrv = SensorDrv::get();
switch(sensorDevId) {
case SENSOR_MAIN:
pInfo->u1Order = sensorDrvInfo[0].SensorOutputDataFormat;
break;
case SENSOR_SUB:
pInfo->u1Order = sensorDrvInfo[1].SensorOutputDataFormat;
break;
case SENSOR_MAIN_2:
pInfo->u1Order = sensorDrvInfo[2].SensorOutputDataFormat;
break;
default:
break;
}
/* Modify getSensorType from getInfo Ioctl to directly compute sensorType from pInfo->u1Order
//sensorType = pSensorDrv->getCurrentSensorType(sensorDevId);
*/
// Compute sensorType from SensorOutputDataFormat
if (pInfo->u1Order >= SENSOR_OUTPUT_FORMAT_RAW_B &&
pInfo->u1Order <= SENSOR_OUTPUT_FORMAT_RAW_R) {
pInfo->sensorType = IMAGE_SENSOR_TYPE_RAW;
}
else if (pInfo->u1Order >= SENSOR_OUTPUT_FORMAT_RAW8_B &&
pInfo->u1Order <= SENSOR_OUTPUT_FORMAT_RAW8_R) {
pInfo->sensorType = IMAGE_SENSOR_TYPE_RAW8;
}
else if (pInfo->u1Order >= SENSOR_OUTPUT_FORMAT_UYVY &&
pInfo->u1Order <= SENSOR_OUTPUT_FORMAT_YVYU) {
pInfo->sensorType = IMAGE_SENSOR_TYPE_YUV;
}
else if (pInfo->u1Order >= SENSOR_OUTPUT_FORMAT_CbYCrY &&
pInfo->u1Order <= SENSOR_OUTPUT_FORMAT_YCrYCb) {
pInfo->sensorType = IMAGE_SENSOR_TYPE_YCBCR;
}
else {
MY_LOGE("Unsupport SensorOutputDataFormat \n");
}
MY_LOGD("SensorOutputDataFormat: %d, ImageSensor Type: %d\n", pInfo->u1Order, pInfo->sensorType);
switch (pInfo->sensorType) {
case IMAGE_SENSOR_TYPE_RAW:
pInfo->u4BitDepth = 10;
pInfo->u4IsPacked = 1;
break;
case IMAGE_SENSOR_TYPE_RAW8:
pInfo->u4BitDepth = 8;
pInfo->u4IsPacked = 1;
break;
case IMAGE_SENSOR_TYPE_RAW12:
pInfo->u4BitDepth = 12;
pInfo->u4IsPacked = 1;
break;
case IMAGE_SENSOR_TYPE_RAW14:
pInfo->u4BitDepth = 14;
pInfo->u4IsPacked = 1;
break;
case IMAGE_SENSOR_TYPE_YUV:
case IMAGE_SENSOR_TYPE_YCBCR:
pInfo->u4BitDepth = 8;
pInfo->u4IsPacked = 0;
break;
case IMAGE_SENSOR_TYPE_RGB565:
pInfo->u4BitDepth = 8;
pInfo->u4IsPacked = 0;
break;
default:
MY_LOGE("Unsupport Sensor Type \n");
break;
}
return ret;
}
MVOID HalSensorList::querySensorInfo()
{
MUINT idx;
//MUINT32 data1,data2;
MUINTPTR data1,data2;
SensorDrv *const pSensorDrv = SensorDrv::get();
#ifdef MTK_MAIN2_IMGSENSOR
for(idx=0; idx<3; idx++) {
#else
#ifdef MTK_SUB_IMGSENSOR
for(idx=0; idx<2; idx++) {
#else
for(idx=0; idx<1; idx++) {
#endif
#endif
switch (idx) {
case 0:
pSensorDrv->init(SENSOR_MAIN);
pSensorDrv->sendCommand(SENSOR_MAIN, CMD_SENSOR_GET_MCLK_CONNECTION, (MUINTPTR)&data1);
sensorPara[idx].mclkSrc = data1;
pSensorDrv->sendCommand(SENSOR_MAIN, CMD_SENSOR_GET_MIPI_SENSOR_PORT, (MUINTPTR)&data1);
sensorPara[idx].mipiPad = data1;
sensorStaticInfo[idx].sensorDevID = pSensorDrv->getMainSensorID();
pSensorDrv->sendCommand(SENSOR_MAIN, CMD_SENSOR_GET_SENSOR_ORIENTATION_ANGLE, (MUINTPTR)&data1);
sensorStaticInfo[idx].orientationAngle = data1;
pSensorDrv->sendCommand(SENSOR_MAIN, CMD_SENSOR_GET_SENSOR_FACING_DIRECTION, (MUINTPTR)&data1);
sensorStaticInfo[idx].facingDirection = data1;
pSensorDrv->sendCommand(SENSOR_MAIN, CMD_SENSOR_GET_FAKE_ORIENTATION, (MUINTPTR)&data1);
sensorStaticInfo[idx].fakeOrientation = data1;
pSensorDrv->sendCommand(SENSOR_MAIN, CMD_SENSOR_GET_SENSOR_VIEWANGLE, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].horizontalViewAngle =data1;
sensorStaticInfo[idx].verticalViewAngle = data2;
data1 = SENSOR_SCENARIO_ID_NORMAL_PREVIEW;
pSensorDrv->sendCommand(SENSOR_MAIN, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].previewFrameRate = data2;
data1 = SENSOR_SCENARIO_ID_NORMAL_CAPTURE;
pSensorDrv->sendCommand(SENSOR_MAIN, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].captureFrameRate = data2;
data1 = SENSOR_SCENARIO_ID_NORMAL_VIDEO;
pSensorDrv->sendCommand(SENSOR_MAIN, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].videoFrameRate = data2;
data1 = SENSOR_SCENARIO_ID_SLIM_VIDEO1;
pSensorDrv->sendCommand(SENSOR_MAIN, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].video1FrameRate = data2;
data1 = SENSOR_SCENARIO_ID_SLIM_VIDEO2;
pSensorDrv->sendCommand(SENSOR_MAIN, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].video2FrameRate = data2;
data1 = SENSOR_SCENARIO_ID_CUSTOM1;
pSensorDrv->sendCommand(SENSOR_MAIN, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].video2FrameRate = data2;
data1 = SENSOR_SCENARIO_ID_CUSTOM2;
pSensorDrv->sendCommand(SENSOR_MAIN, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].video2FrameRate = data2;
data1 = SENSOR_SCENARIO_ID_CUSTOM3;
pSensorDrv->sendCommand(SENSOR_MAIN, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].video2FrameRate = data2;
data1 = SENSOR_SCENARIO_ID_CUSTOM4;
pSensorDrv->sendCommand(SENSOR_MAIN, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].video2FrameRate = data2;
data1 = SENSOR_SCENARIO_ID_CUSTOM5;
pSensorDrv->sendCommand(SENSOR_MAIN, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].video2FrameRate = data2;
pSensorDrv->uninit();
break;
case 1:
pSensorDrv->init(SENSOR_SUB);
pSensorDrv->sendCommand(SENSOR_SUB, CMD_SENSOR_GET_MCLK_CONNECTION, (MUINTPTR)&data1);
sensorPara[idx].mclkSrc = data1;
pSensorDrv->sendCommand(SENSOR_SUB, CMD_SENSOR_GET_MIPI_SENSOR_PORT, (MUINTPTR)&data1);
sensorPara[idx].mipiPad = data1;
sensorStaticInfo[idx].sensorDevID = pSensorDrv->getSubSensorID();
pSensorDrv->sendCommand(SENSOR_SUB, CMD_SENSOR_GET_SENSOR_ORIENTATION_ANGLE, (MUINTPTR)&data1);
sensorStaticInfo[idx].orientationAngle = data1;
pSensorDrv->sendCommand(SENSOR_SUB, CMD_SENSOR_GET_SENSOR_FACING_DIRECTION, (MUINTPTR)&data1);
sensorStaticInfo[idx].facingDirection = data1;
pSensorDrv->sendCommand(SENSOR_SUB, CMD_SENSOR_GET_FAKE_ORIENTATION, (MUINTPTR)&data1);
sensorStaticInfo[idx].fakeOrientation = data1;
pSensorDrv->sendCommand(SENSOR_SUB, CMD_SENSOR_GET_SENSOR_VIEWANGLE, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].horizontalViewAngle =data1;
sensorStaticInfo[idx].verticalViewAngle = data2;
data1 = SENSOR_SCENARIO_ID_NORMAL_PREVIEW;
pSensorDrv->sendCommand(SENSOR_SUB, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].previewFrameRate = data2;
data1 = SENSOR_SCENARIO_ID_NORMAL_CAPTURE;
pSensorDrv->sendCommand(SENSOR_SUB, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].captureFrameRate = data2;
data1 = SENSOR_SCENARIO_ID_NORMAL_VIDEO;
pSensorDrv->sendCommand(SENSOR_SUB, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].videoFrameRate = data2;
data1 = SENSOR_SCENARIO_ID_SLIM_VIDEO1;
pSensorDrv->sendCommand(SENSOR_SUB, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].video1FrameRate = data2;
data1 = SENSOR_SCENARIO_ID_SLIM_VIDEO2;
pSensorDrv->sendCommand(SENSOR_SUB, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].video2FrameRate = data2;
data1 = SENSOR_SCENARIO_ID_CUSTOM1;
pSensorDrv->sendCommand(SENSOR_SUB, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].video2FrameRate = data2;
data1 = SENSOR_SCENARIO_ID_CUSTOM2;
pSensorDrv->sendCommand(SENSOR_SUB, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].video2FrameRate = data2;
data1 = SENSOR_SCENARIO_ID_CUSTOM3;
pSensorDrv->sendCommand(SENSOR_SUB, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].video2FrameRate = data2;
data1 = SENSOR_SCENARIO_ID_CUSTOM4;
pSensorDrv->sendCommand(SENSOR_SUB, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].video2FrameRate = data2;
data1 = SENSOR_SCENARIO_ID_CUSTOM5;
pSensorDrv->sendCommand(SENSOR_SUB, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].video2FrameRate = data2;
pSensorDrv->uninit();
break;
case 2:
pSensorDrv->init(SENSOR_MAIN_2);
pSensorDrv->sendCommand(SENSOR_MAIN_2, CMD_SENSOR_GET_MCLK_CONNECTION, (MUINTPTR)&data1);
sensorPara[idx].mclkSrc = data1;
pSensorDrv->sendCommand(SENSOR_MAIN_2, CMD_SENSOR_GET_MIPI_SENSOR_PORT, (MUINTPTR)&data1);
sensorPara[idx].mipiPad = data1;
sensorStaticInfo[idx].sensorDevID = pSensorDrv->getMain2SensorID();
pSensorDrv->sendCommand(SENSOR_MAIN_2, CMD_SENSOR_GET_SENSOR_ORIENTATION_ANGLE, (MUINTPTR)&data1);
sensorStaticInfo[idx].orientationAngle = data1;
pSensorDrv->sendCommand(SENSOR_MAIN_2, CMD_SENSOR_GET_SENSOR_FACING_DIRECTION, (MUINTPTR)&data1);
sensorStaticInfo[idx].facingDirection = data1;
pSensorDrv->sendCommand(SENSOR_MAIN_2, CMD_SENSOR_GET_FAKE_ORIENTATION, (MUINTPTR)&data1);
sensorStaticInfo[idx].fakeOrientation = data1;
pSensorDrv->sendCommand(SENSOR_MAIN_2, CMD_SENSOR_GET_SENSOR_VIEWANGLE, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].horizontalViewAngle =data1;
sensorStaticInfo[idx].verticalViewAngle = data2;
data1 = SENSOR_SCENARIO_ID_NORMAL_PREVIEW;
pSensorDrv->sendCommand(SENSOR_MAIN_2, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].previewFrameRate = data2;
data1 = SENSOR_SCENARIO_ID_NORMAL_CAPTURE;
pSensorDrv->sendCommand(SENSOR_MAIN_2, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].captureFrameRate = data2;
data1 = SENSOR_SCENARIO_ID_NORMAL_VIDEO;
pSensorDrv->sendCommand(SENSOR_MAIN_2, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].videoFrameRate = data2;
data1 = SENSOR_SCENARIO_ID_SLIM_VIDEO1;
pSensorDrv->sendCommand(SENSOR_MAIN_2, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].video1FrameRate = data2;
data1 = SENSOR_SCENARIO_ID_SLIM_VIDEO2;
pSensorDrv->sendCommand(SENSOR_MAIN_2, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].video2FrameRate = data2;
data1 = SENSOR_SCENARIO_ID_CUSTOM1;
pSensorDrv->sendCommand(SENSOR_MAIN_2, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].video2FrameRate = data2;
data1 = SENSOR_SCENARIO_ID_CUSTOM2;
pSensorDrv->sendCommand(SENSOR_MAIN_2, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].video2FrameRate = data2;
data1 = SENSOR_SCENARIO_ID_CUSTOM3;
pSensorDrv->sendCommand(SENSOR_MAIN_2, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].video2FrameRate = data2;
data1 = SENSOR_SCENARIO_ID_CUSTOM4;
pSensorDrv->sendCommand(SENSOR_MAIN_2, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].video2FrameRate = data2;
data1 = SENSOR_SCENARIO_ID_CUSTOM5;
pSensorDrv->sendCommand(SENSOR_MAIN_2, CMD_SENSOR_GET_DEFAULT_FRAME_RATE_BY_SCENARIO, (MUINTPTR)&data1, (MUINTPTR)&data2);
sensorStaticInfo[idx].video2FrameRate = data2;
pSensorDrv->uninit();
break;
default:
break;
}
switch (sensorRawInfo[idx].sensorType) {
case IMAGE_SENSOR_TYPE_RAW:
sensorStaticInfo[idx].sensorType = SENSOR_TYPE_RAW;
sensorStaticInfo[idx].rawSensorBit = RAW_SENSOR_10BIT;
break;
case IMAGE_SENSOR_TYPE_RAW8:
sensorStaticInfo[idx].sensorType = SENSOR_TYPE_RAW;
sensorStaticInfo[idx].rawSensorBit = RAW_SENSOR_8BIT;
break;
case IMAGE_SENSOR_TYPE_RAW12:
sensorStaticInfo[idx].sensorType = SENSOR_TYPE_RAW;
sensorStaticInfo[idx].rawSensorBit = RAW_SENSOR_12BIT;
break;
case IMAGE_SENSOR_TYPE_RAW14:
sensorStaticInfo[idx].sensorType = SENSOR_TYPE_RAW;
sensorStaticInfo[idx].rawSensorBit = RAW_SENSOR_14BIT;
break;
case IMAGE_SENSOR_TYPE_YUV:
case IMAGE_SENSOR_TYPE_YCBCR:
sensorStaticInfo[idx].sensorType = SENSOR_TYPE_YUV;
sensorStaticInfo[idx].rawSensorBit = RAW_SENSOR_ERROR;
break;
case IMAGE_SENSOR_TYPE_RGB565:
sensorStaticInfo[idx].sensorType = SENSOR_TYPE_RGB;
sensorStaticInfo[idx].rawSensorBit = RAW_SENSOR_ERROR;
break;
case IMAGE_SENSOR_TYPE_JPEG:
sensorStaticInfo[idx].sensorType = SENSOR_TYPE_JPEG;
sensorStaticInfo[idx].rawSensorBit = RAW_SENSOR_ERROR;
break;
default:
sensorStaticInfo[idx].sensorType = SENSOR_TYPE_UNKNOWN;
sensorStaticInfo[idx].rawSensorBit = RAW_SENSOR_ERROR;
break;
}
switch (sensorRawInfo[idx].u1Order) {
case SENSOR_OUTPUT_FORMAT_RAW_B:
case SENSOR_OUTPUT_FORMAT_RAW8_B:
sensorStaticInfo[idx].sensorFormatOrder = SENSOR_FORMAT_ORDER_RAW_B;
break;
case SENSOR_OUTPUT_FORMAT_RAW_Gb:
case SENSOR_OUTPUT_FORMAT_RAW8_Gb:
sensorStaticInfo[idx].sensorFormatOrder = SENSOR_FORMAT_ORDER_RAW_Gb;
break;
case SENSOR_OUTPUT_FORMAT_RAW_Gr:
case SENSOR_OUTPUT_FORMAT_RAW8_Gr:
sensorStaticInfo[idx].sensorFormatOrder = SENSOR_FORMAT_ORDER_RAW_Gr;
break;
case SENSOR_OUTPUT_FORMAT_RAW_R:
case SENSOR_OUTPUT_FORMAT_RAW8_R:
sensorStaticInfo[idx].sensorFormatOrder = SENSOR_FORMAT_ORDER_RAW_R;
break;
case SENSOR_OUTPUT_FORMAT_UYVY:
case SENSOR_OUTPUT_FORMAT_CbYCrY:
sensorStaticInfo[idx].sensorFormatOrder = SENSOR_FORMAT_ORDER_UYVY;
break;
case SENSOR_OUTPUT_FORMAT_VYUY:
case SENSOR_OUTPUT_FORMAT_CrYCbY:
sensorStaticInfo[idx].sensorFormatOrder = SENSOR_FORMAT_ORDER_VYUY;
break;
case SENSOR_OUTPUT_FORMAT_YUYV:
case SENSOR_OUTPUT_FORMAT_YCbYCr:
sensorStaticInfo[idx].sensorFormatOrder = SENSOR_FORMAT_ORDER_YUYV;
break;
case SENSOR_OUTPUT_FORMAT_YVYU:
case SENSOR_OUTPUT_FORMAT_YCrYCb:
sensorStaticInfo[idx].sensorFormatOrder = SENSOR_FORMAT_ORDER_YVYU;
break;
default:
sensorStaticInfo[idx].sensorFormatOrder = SENSOR_FORMAT_ORDER_NONE;
break;
}
sensorStaticInfo[idx].iHDRSupport = sensorDrvInfo[idx].iHDRSupport;
sensorStaticInfo[idx].PDAF_Support = sensorDrvInfo[idx].PDAF_Support;
sensorStaticInfo[idx].previewWidth = sensorDrvInfo[idx].SensorPreviewWidth;
sensorStaticInfo[idx].previewHeight = sensorDrvInfo[idx].SensorPreviewHeight;
sensorStaticInfo[idx].captureWidth = sensorDrvInfo[idx].SensorCapWidth;
sensorStaticInfo[idx].captureHeight = sensorDrvInfo[idx].SensorCapHeight;
sensorStaticInfo[idx].videoWidth = sensorDrvInfo[idx].SensorVideoWidth;
sensorStaticInfo[idx].videoHeight = sensorDrvInfo[idx].SensorVideoHeight;
sensorStaticInfo[idx].video1Width = sensorDrvInfo[idx].SensorVideo1Width;
sensorStaticInfo[idx].video1Height = sensorDrvInfo[idx].SensorVideo1Height;
sensorStaticInfo[idx].video2Width = sensorDrvInfo[idx].SensorVideo2Width;
sensorStaticInfo[idx].video2Height = sensorDrvInfo[idx].SensorVideo2Height;
sensorStaticInfo[idx].SensorCustom1Width = sensorDrvInfo[idx].SensorCustom1Width;
sensorStaticInfo[idx].SensorCustom1Height = sensorDrvInfo[idx].SensorCustom1Height;
sensorStaticInfo[idx].SensorCustom2Width = sensorDrvInfo[idx].SensorCustom2Width;
sensorStaticInfo[idx].SensorCustom2Height = sensorDrvInfo[idx].SensorCustom2Height;
sensorStaticInfo[idx].SensorCustom3Width = sensorDrvInfo[idx].SensorCustom3Width;
sensorStaticInfo[idx].SensorCustom3Height = sensorDrvInfo[idx].SensorCustom3Height;
sensorStaticInfo[idx].SensorCustom4Width = sensorDrvInfo[idx].SensorCustom4Width;
sensorStaticInfo[idx].SensorCustom4Height = sensorDrvInfo[idx].SensorCustom4Height;
sensorStaticInfo[idx].SensorCustom5Width = sensorDrvInfo[idx].SensorCustom5Width;
sensorStaticInfo[idx].SensorCustom5Height = sensorDrvInfo[idx].SensorCustom5Height;
sensorStaticInfo[idx].previewDelayFrame = sensorDrvInfo[idx].PreviewDelayFrame;
sensorStaticInfo[idx].captureDelayFrame = sensorDrvInfo[idx].CaptureDelayFrame;
sensorStaticInfo[idx].videoDelayFrame = sensorDrvInfo[idx].VideoDelayFrame;
sensorStaticInfo[idx].video1DelayFrame = sensorDrvInfo[idx].HighSpeedVideoDelayFrame;
sensorStaticInfo[idx].video2DelayFrame = sensorDrvInfo[idx].SlimVideoDelayFrame;
sensorStaticInfo[idx].Custom1DelayFrame = sensorDrvInfo[idx].Custom1DelayFrame;
sensorStaticInfo[idx].Custom2DelayFrame = sensorDrvInfo[idx].Custom2DelayFrame;
sensorStaticInfo[idx].Custom3DelayFrame = sensorDrvInfo[idx].Custom3DelayFrame;
sensorStaticInfo[idx].Custom4DelayFrame = sensorDrvInfo[idx].Custom4DelayFrame;
sensorStaticInfo[idx].Custom5DelayFrame = sensorDrvInfo[idx].Custom5DelayFrame;
sensorStaticInfo[idx].aeShutDelayFrame = sensorDrvInfo[idx].AEShutDelayFrame;
sensorStaticInfo[idx].aeSensorGainDelayFrame = sensorDrvInfo[idx].AESensorGainDelayFrame;
sensorStaticInfo[idx].aeISPGainDelayFrame = sensorDrvInfo[idx].AEISPGainDelayFrame;
sensorStaticInfo[idx].previewActiveWidth = sensorDrvInfo[idx].SensorEffectivePreviewWidth;//3d use onlyl?
sensorStaticInfo[idx].previewActiveHeight = sensorDrvInfo[idx].SensorEffectivePreviewHeight;//3d use onlyl?
sensorStaticInfo[idx].captureActiveWidth = sensorDrvInfo[idx].SensorEffectiveCapWidth;//3d use onlyl?
sensorStaticInfo[idx].captureActiveHeight = sensorDrvInfo[idx].SensorEffectiveCapHeight;//3d use onlyl?
sensorStaticInfo[idx].videoActiveWidth = sensorDrvInfo[idx].SensorEffectiveVideoWidth;//3d use onlyl?
sensorStaticInfo[idx].videowActiveHeight = sensorDrvInfo[idx].SensorEffectiveVideoHeight;//3d use onlyl?
sensorStaticInfo[idx].previewHoizontalOutputOffset = sensorDrvInfo[idx].SensorPreviewWidthOffset;//3d use onlyl?
sensorStaticInfo[idx].previewVerticalOutputOffset = sensorDrvInfo[idx].SensorPreviewHeightOffset; //3d use onlyl?
sensorStaticInfo[idx].captureHoizontalOutputOffset = sensorDrvInfo[idx].SensorCapWidthOffset;//3d use onlyl?
sensorStaticInfo[idx].captureVerticalOutputOffset = sensorDrvInfo[idx].SensorCapHeightOffset; //3d use onlyl?
sensorStaticInfo[idx].videoHoizontalOutputOffset = sensorDrvInfo[idx].SensorVideoWidthOffset;//3d use onlyl?
sensorStaticInfo[idx].videoVerticalOutputOffset = sensorDrvInfo[idx].SensorVideoHeightOffset; //3d use onlyl?
sensorStaticInfo[idx].virtualChannelSupport = sensorDrvInfo[idx].virtualChannelSupport;
sensorStaticInfo[idx].iHDR_First_IS_LE = sensorDrvInfo[idx].iHDR_First_IS_LE;
sensorStaticInfo[idx].SensorModeNum = sensorDrvInfo[idx].SensorModeNum;
}
MY_LOGD("MCLK Source: Main = %d, Sub = %d, Main_2 =%d\n",sensorPara[0].mclkSrc,sensorPara[1].mclkSrc,sensorPara[2].mclkSrc);
MY_LOGD("MIPI pad: Main = %d, Sub = %d, Main_2 =%d\n",sensorPara[0].mipiPad,sensorPara[1].mipiPad,sensorPara[2].mipiPad);
}
MVOID HalSensorList::buildSensorMetadata()
{
MINT idx;
MINT64 exposureTime1 = 0x4000;
MINT64 exposureTime2 = 0x4000;
MUINT8 u8Para = 0;
MINT32 s32Para = 0;
MY_LOGD("impBuildSensorInfo start!\n");
#ifdef MTK_MAIN2_IMGSENSOR
for(idx=0; idx<3; idx++) {
#else
#ifdef MTK_SUB_IMGSENSOR
for(idx=0; idx<2; idx++) {
#else
for(idx=0; idx<1; idx++) {
#endif
#endif
IMetadata& metadataA = gSensorMetadata[idx];
{
IMetadata::IEntry entryA(MTK_SENSOR_EXPOSURE_TIME);
entryA.push_back(exposureTime1, Type2Type<MINT64>());
entryA.push_back(exposureTime2, Type2Type<MINT64>());
metadataA.update(MTK_SENSOR_EXPOSURE_TIME, entryA);
}
{ //using full size?
IMetadata::IEntry entryA(MTK_SENSOR_INFO_ACTIVE_ARRAY_REGION);
MRect region1(MPoint(sensorStaticInfo[idx].captureHoizontalOutputOffset,sensorStaticInfo[idx].captureVerticalOutputOffset), MSize(sensorStaticInfo[idx].captureWidth,sensorStaticInfo[idx].captureHeight));
entryA.push_back(region1, Type2Type<MRect>());
metadataA.update(MTK_SENSOR_INFO_ACTIVE_ARRAY_REGION, entryA);
}
{
IMetadata::IEntry entryA(MTK_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT);
switch(sensorStaticInfo[idx].sensorFormatOrder) {
case SENSOR_FORMAT_ORDER_RAW_B:
u8Para = 0x3;//BGGR
break;
case SENSOR_FORMAT_ORDER_RAW_Gb:
u8Para = 0x2;//GBRG
break;
case SENSOR_FORMAT_ORDER_RAW_Gr:
u8Para = 0x1;//GRBG
break;
case SENSOR_FORMAT_ORDER_RAW_R:
u8Para = 0x0;//RGGB
break;
default:
u8Para = 0x4;//BGR not bayer
break;
}
entryA.push_back(u8Para, Type2Type<MUINT8>());
metadataA.update(MTK_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, entryA);
}
{ //need to add query from kernel
IMetadata::IEntry entryA(MTK_SENSOR_INFO_EXPOSURE_TIME_RANGE);
entryA.push_back(3000, Type2Type<MINT64>());
entryA.push_back(3000000000, Type2Type<MINT64>());
metadataA.update(MTK_SENSOR_INFO_EXPOSURE_TIME_RANGE, entryA);
}
{ //need to add query from kernel
IMetadata::IEntry entryA(MTK_SENSOR_INFO_MAX_FRAME_DURATION);
entryA.push_back(50000000000, Type2Type<MINT64>());
metadataA.update(MTK_SENSOR_INFO_MAX_FRAME_DURATION, entryA);
}
{ //need to add query from kernel
IMetadata::IEntry entryA(MTK_SENSOR_INFO_PHYSICAL_SIZE);
entryA.push_back(5.82, Type2Type<MFLOAT>());
entryA.push_back(4.76, Type2Type<MFLOAT>());
metadataA.update(MTK_SENSOR_INFO_PHYSICAL_SIZE, entryA);
}
{ //need to add query from kernel
IMetadata::IEntry entryA(MTK_SENSOR_INFO_PIXEL_ARRAY_SIZE);
MSize Size1(4000,3000);
entryA.push_back(Size1, Type2Type<MSize>());
metadataA.update(MTK_SENSOR_INFO_PIXEL_ARRAY_SIZE, entryA);
}
{ //need to add query from kernel
IMetadata::IEntry entryA(MTK_SENSOR_INFO_WHITE_LEVEL);
switch (sensorStaticInfo[idx].rawSensorBit) {
case RAW_SENSOR_8BIT:
s32Para = 256;
break;
case RAW_SENSOR_10BIT:
s32Para = 1024;
break;
case RAW_SENSOR_12BIT:
s32Para = 4096;
break;
case RAW_SENSOR_14BIT:
s32Para = 16384;
break;
default:
s32Para = 256;
break;
}
entryA.push_back(s32Para, Type2Type<MINT32>());
metadataA.update(MTK_SENSOR_INFO_WHITE_LEVEL, entryA);
}
{
IMetadata::IEntry entryA(MTK_SENSOR_INFO_ORIENTATION);
entryA.push_back((MINT32)sensorStaticInfo[idx].orientationAngle, Type2Type<MINT32>());
metadataA.update(MTK_SENSOR_INFO_ORIENTATION, entryA);
}
{
IMetadata::IEntry entryA(MTK_SENSOR_INFO_PACKAGE);
{
IMetadata metadataB;
{
IMetadata::IEntry entryB(MTK_SENSOR_INFO_SCENARIO_ID);
entryB.push_back((MINT32)SENSOR_SCENARIO_ID_NORMAL_PREVIEW,Type2Type<MINT32>());
metadataB.update(MTK_SENSOR_INFO_SCENARIO_ID, entryB);
}
{
IMetadata::IEntry entryB(MTK_SENSOR_INFO_FRAME_RATE);
entryB.push_back((MINT32)sensorStaticInfo[idx].previewFrameRate,Type2Type<MINT32>());
metadataB.update(MTK_SENSOR_INFO_FRAME_RATE, entryB);
}
{
IMetadata::IEntry entryB(MTK_SENSOR_INFO_REAL_OUTPUT_SIZE);
MSize size1(sensorStaticInfo[idx].previewWidth,sensorStaticInfo[idx].previewHeight);
entryB.push_back(size1,Type2Type<MSize>());
metadataB.update(MTK_SENSOR_INFO_REAL_OUTPUT_SIZE, entryB);
}
{
IMetadata::IEntry entryB(MTK_SENSOR_INFO_OUTPUT_REGION_ON_ACTIVE_ARRAY);
MRect region1(MPoint(0,0), MSize(sensorStaticInfo[idx].previewWidth,sensorStaticInfo[idx].previewHeight));
entryB.push_back(region1,Type2Type<MRect>());
metadataB.update(MTK_SENSOR_INFO_OUTPUT_REGION_ON_ACTIVE_ARRAY, entryB);
}
entryA.push_back(metadataB,Type2Type<IMetadata>());
}
{
IMetadata metadataB;
{
IMetadata::IEntry entryB(MTK_SENSOR_INFO_SCENARIO_ID);
entryB.push_back((MINT32)SENSOR_SCENARIO_ID_NORMAL_CAPTURE,Type2Type<MINT32>());
metadataB.update(MTK_SENSOR_INFO_SCENARIO_ID, entryB);
}
{
IMetadata::IEntry entryB(MTK_SENSOR_INFO_FRAME_RATE);
entryB.push_back((MINT32)sensorStaticInfo[idx].captureFrameRate,Type2Type<MINT32>());
metadataB.update(MTK_SENSOR_INFO_FRAME_RATE, entryB);
}
{
IMetadata::IEntry entryB(MTK_SENSOR_INFO_REAL_OUTPUT_SIZE);
MSize size1(sensorStaticInfo[idx].captureWidth,sensorStaticInfo[idx].captureHeight);
entryB.push_back(size1,Type2Type<MSize>());
metadataB.update(MTK_SENSOR_INFO_REAL_OUTPUT_SIZE, entryB);
}
{
IMetadata::IEntry entryB(MTK_SENSOR_INFO_OUTPUT_REGION_ON_ACTIVE_ARRAY);
MRect region1(MPoint(0,0), MSize(sensorStaticInfo[idx].captureWidth,sensorStaticInfo[idx].captureHeight));
entryB.push_back(region1,Type2Type<MRect>());
metadataB.update(MTK_SENSOR_INFO_OUTPUT_REGION_ON_ACTIVE_ARRAY, entryB);
}
entryA.push_back(metadataB,Type2Type<IMetadata>());
}
{
IMetadata metadataB;
{
IMetadata::IEntry entryB(MTK_SENSOR_INFO_SCENARIO_ID);
entryB.push_back((MINT32)SENSOR_SCENARIO_ID_NORMAL_VIDEO,Type2Type<MINT32>());
metadataB.update(MTK_SENSOR_INFO_SCENARIO_ID, entryB);
}
{
IMetadata::IEntry entryB(MTK_SENSOR_INFO_FRAME_RATE);
entryB.push_back((MINT32)sensorStaticInfo[idx].videoFrameRate,Type2Type<MINT32>());
metadataB.update(MTK_SENSOR_INFO_FRAME_RATE, entryB);
}
{
IMetadata::IEntry entryB(MTK_SENSOR_INFO_REAL_OUTPUT_SIZE);
MSize size1(sensorStaticInfo[idx].videoWidth,sensorStaticInfo[idx].videoHeight);
entryB.push_back(size1,Type2Type<MSize>());
metadataB.update(MTK_SENSOR_INFO_REAL_OUTPUT_SIZE, entryB);
}
{
IMetadata::IEntry entryB(MTK_SENSOR_INFO_OUTPUT_REGION_ON_ACTIVE_ARRAY);
MRect region1(MPoint(0,0), MSize(sensorStaticInfo[idx].videoWidth,sensorStaticInfo[idx].videoHeight));
entryB.push_back(region1,Type2Type<MRect>());
metadataB.update(MTK_SENSOR_INFO_OUTPUT_REGION_ON_ACTIVE_ARRAY, entryB);
}
entryA.push_back(metadataB,Type2Type<IMetadata>());
}
{
IMetadata metadataB;
{
IMetadata::IEntry entryB(MTK_SENSOR_INFO_SCENARIO_ID);
entryB.push_back((MINT32)SENSOR_SCENARIO_ID_SLIM_VIDEO1,Type2Type<MINT32>());
metadataB.update(MTK_SENSOR_INFO_SCENARIO_ID, entryB);
}
{
IMetadata::IEntry entryB(MTK_SENSOR_INFO_FRAME_RATE);
entryB.push_back((MINT32)sensorStaticInfo[idx].video1FrameRate,Type2Type<MINT32>());
metadataB.update(MTK_SENSOR_INFO_FRAME_RATE, entryB);
}
{
IMetadata::IEntry entryB(MTK_SENSOR_INFO_REAL_OUTPUT_SIZE);
MSize size1(sensorStaticInfo[idx].video1Width,sensorStaticInfo[idx].video1Height);
entryB.push_back(size1,Type2Type<MSize>());
metadataB.update(MTK_SENSOR_INFO_REAL_OUTPUT_SIZE, entryB);
}
{
IMetadata::IEntry entryB(MTK_SENSOR_INFO_OUTPUT_REGION_ON_ACTIVE_ARRAY);
MRect region1(MPoint(0,0), MSize(sensorStaticInfo[idx].video1Width,sensorStaticInfo[idx].video1Height));
entryB.push_back(region1,Type2Type<MRect>());
metadataB.update(MTK_SENSOR_INFO_OUTPUT_REGION_ON_ACTIVE_ARRAY, entryB);
}
entryA.push_back(metadataB,Type2Type<IMetadata>());
}
{
IMetadata metadataB;
{
IMetadata::IEntry entryB(MTK_SENSOR_INFO_SCENARIO_ID);
entryB.push_back((MINT32)SENSOR_SCENARIO_ID_SLIM_VIDEO2,Type2Type<MINT32>());
metadataB.update(MTK_SENSOR_INFO_SCENARIO_ID, entryB);
}
{
IMetadata::IEntry entryB(MTK_SENSOR_INFO_FRAME_RATE);
entryB.push_back((MINT32)sensorStaticInfo[idx].video2FrameRate,Type2Type<MINT32>());
metadataB.update(MTK_SENSOR_INFO_FRAME_RATE, entryB);
}
{
IMetadata::IEntry entryB(MTK_SENSOR_INFO_REAL_OUTPUT_SIZE);
MSize size1(sensorStaticInfo[idx].video2Width,sensorStaticInfo[idx].video2Height);
entryB.push_back(size1,Type2Type<MSize>());
metadataB.update(MTK_SENSOR_INFO_REAL_OUTPUT_SIZE, entryB);
}
{
IMetadata::IEntry entryB(MTK_SENSOR_INFO_OUTPUT_REGION_ON_ACTIVE_ARRAY);
MRect region1(MPoint(0,0), MSize(sensorStaticInfo[idx].video2Width,sensorStaticInfo[idx].video2Height));
entryB.push_back(region1,Type2Type<MRect>());
metadataB.update(MTK_SENSOR_INFO_OUTPUT_REGION_ON_ACTIVE_ARRAY, entryB);
}
entryA.push_back(metadataB,Type2Type<IMetadata>());
}
metadataA.update(MTK_SENSOR_INFO_PACKAGE, entryA);
}
metadataA.sort();
}
MY_LOGD("impBuildSensorInfo end!\n");
}
