int InitVisionMemory(unsigned int res_x,unsigned int res_y)
{
int i=0;
if ( COLD_START == 1 )
{
// THIS MEANS THE WHOLE CORTEX JUST INITIALIZED , SO LETS CLEAN THE VIDEO REGISTERS
for ( i=0; i<REGISTERS_COUNT; i++) video_register[i].pixels = 0;
for ( i=0; i<LARGE_REGISTERS_COUNT; i++) l_video_register[i].pixels = 0;
}
COLD_START=0;
//INITIALIZE ALL IMAGE METRICS
metrics[RESOLUTION_X]=res_x;
metrics[RESOLUTION_Y]=res_y;
metrics[RESOLUTION_X_3_BYTE]=res_x * 3;
metrics[RESOLUTION_MEMORY_LIMIT_1BYTE]=res_x*res_y;
metrics[RESOLUTION_MEMORY_LIMIT_3BYTE]=metrics[RESOLUTION_MEMORY_LIMIT_1BYTE]*3;
metrics[RESOLUTION_DEPTH]=3;
metrics[CHANGES_LEFT]=0;
metrics[CHANGES_RIGHT]=0;
metrics[HORIZONTAL_BUFFER]=9; //20
metrics[VERTICAL_BUFFER]=9; //25
metrics[HORIZONTAL_BUFFER_LARGE]=15; //50
metrics[VERTICAL_BUFFER_LARGE]=15; //75
metrics[HORIZONTAL_BUFFER_EXTRALARGE]=21; //125
metrics[VERTICAL_BUFFER_EXTRALARGE]=21; // 188
metrics[GROUP_MOVEMENT_ARRAY_SIZE] = ( ((res_y+1)/metrics[VERTICAL_BUFFER])*((res_x+1)/metrics[HORIZONTAL_BUFFER]) ) + ((res_x+1)/metrics[HORIZONTAL_BUFFER]);
DefaultSettings(); //Settings must be set after metrics because they take them into account
fprintf(stderr,"Initializing %u Video Register with %u MB , %u MB ( large ) , %u MB ( xlarge ) s\n",REGISTERS_COUNT+LARGE_REGISTERS_COUNT
,(unsigned int) ( 3*res_x*res_y*REGISTERS_COUNT*sizeof(char)) / 1048576
,(unsigned int) ( 3*res_x*res_y*LARGE_REGISTERS_COUNT*sizeof(unsigned short)) / 1048576
,(unsigned int) ( 3*res_x*res_y*LARGE_REGISTERS_COUNT*sizeof(unsigned int)) / 1048576
);
for ( i=0; i<REGISTERS_COUNT; i++)
{
if ( InitRegister(i,res_x,res_y,3)!=0 ) { fprintf(stderr,"Error initializing Vision Memory"); return 1; }
}
for ( i=0; i<LARGE_REGISTERS_COUNT; i++)
{
if ( InitLargeRegister(i,res_x,res_y,3)!=0 ) { fprintf(stderr,"Error initializing Vision Memory"); return 1; }
}
for ( i=0; i<EXTRA_LARGE_REGISTERS_COUNT; i++)
{
if ( InitExtraLargeRegister(i,res_x,res_y,3)!=0 ) { fprintf(stderr,"Error initializing Vision Memory"); return 1; }
}
// unsigned int MEM3BIT = (res_x+1)*(res_y+1)*3;
unsigned int MEM1BIT = (res_x+1)*(res_y+1);
depth_data_array = ( struct DepthData * ) malloc ( sizeof(struct DepthData) * MEM1BIT );
if (depth_data_array==0) { fprintf(stderr,"Error allocating depth_data_array memory \n"); return 1; }
InitPrecalculations();
SetGuardBytes(); // Preferably after everything settings..!
return 0; // 0 Means Success!
}
void RunDataTableTest()
{
RecvTable *pRecvTable = &REFERENCE_RECV_TABLE(DT_DTTest);
SendTable *pSendTable = &REFERENCE_SEND_TABLE(DT_DTTest);
// Initialize the send and receive modules.
SendTable_Init( &pSendTable, 1 );
RecvTable_Init( &pRecvTable, 1 );
pSendTable->SetWriteFlag( false );
// Send DataTable info to the client.
unsigned char commBuf[8192];
bf_write bfWrite( "RunDataTableTest->commBuf", commBuf, sizeof(commBuf) );
if( !WriteSendTable_R( pSendTable, bfWrite, true ) )
{
Assert( !"RunDataTableTest: SendTable_SendInfo failed." );
}
bfWrite.WriteOneBit(0);
// Receive the SendTable's info.
bf_read bfRead( "RunDataTableTest->bfRead", commBuf, sizeof(commBuf));
while( bfRead.ReadOneBit() )
{
bool bNeedsDecoder = bfRead.ReadOneBit()!=0;
if( !RecvTable_RecvClassInfos( &bfRead, bNeedsDecoder ) )
{
Assert( !"RunDataTableTest: RecvTable_ReadInfos failed." );
continue;
}
}
// Register our receive table.
if( !RecvTable_CreateDecoders( NULL ) )
{
Assert(false);
}
// Setup the data with all zeros.
DTTestServer dtServer;
DTTestClient dtClient;
unsigned char prevEncoded[4096];
unsigned char fullEncoded[4096];
memset(&dtServer, 0, sizeof(dtServer));
memset(&dtClient, 0, sizeof(dtClient));
memset(prevEncoded, 0, sizeof(prevEncoded));
SetGuardBytes( &dtClient );
// Now loop around, changing the data a little bit each time and send/recv deltas.
int nIterations = 25;
for( int iIteration=0; iIteration < nIterations; iIteration++ )
{
// Change the server's data.
g_bSendSub = true;
if( (iIteration % 5) == 0 )
{
g_bSendSub = false; // every 8th time, don't send the subtable
}
if( (iIteration & 3) == 0 )
{
// Every once in a while, change ALL the properties.
for( int iChange=0; iChange < NUMVARTESTINFOS; iChange++ )
g_VarTestInfos[iChange].m_ChangeFn( &dtServer );
}
else
{
int nChanges = 3 + rand() % NUMVARTESTINFOS;
for( int iChange=0; iChange < nChanges; iChange++ )
{
int iInfo = rand() % NUMVARTESTINFOS;
g_VarTestInfos[iInfo].m_ChangeFn( &dtServer );
}
}
// Fully encode it.
bf_write bfFullEncoded( "RunDataTableTest->bfFullEncoded", fullEncoded, sizeof(fullEncoded) );
if( !SendTable_Encode( pSendTable, &dtServer, &bfFullEncoded, -1, NULL ) )
{
Assert(false);
}
unsigned char deltaEncoded[4096];
bf_write bfDeltaEncoded( "RunDataTableTest->bfDeltaEncoded", deltaEncoded, sizeof(deltaEncoded) );
if ( iIteration == 0 )
{
// On the first iteration, just write the whole state.
if( !SendTable_Encode( pSendTable, &dtServer, &bfDeltaEncoded, -1, NULL ) )
{
Assert( false );
}
}
else
{
// Figure out the delta between the newly encoded one and the previously encoded one.
int deltaProps[MAX_DATATABLE_PROPS];
bf_read fullEncodedRead( "RunDataTableTest->fullEncodedRead", fullEncoded, sizeof( fullEncoded ), bfFullEncoded.GetNumBitsWritten() );
bf_read prevEncodedRead( "RunDataTableTest->prevEncodedRead", prevEncoded, sizeof( prevEncoded ) );
int nDeltaProps = SendTable_CalcDelta(
pSendTable,
prevEncoded, sizeof( prevEncoded ) * 8,
fullEncoded, bfFullEncoded.GetNumBitsWritten(),
deltaProps,
ARRAYSIZE( deltaProps ),
-1 );
Assert( nDeltaProps != -1 ); // BAD: buffer overflow
// Reencode with just the delta. This is what is actually sent to the client.
SendTable_WritePropList(
pSendTable,
fullEncoded,
bfFullEncoded.GetNumBitsWritten(),
&bfDeltaEncoded,
-1111,
deltaProps,
nDeltaProps );
}
memcpy( prevEncoded, fullEncoded, sizeof( prevEncoded ) );
// This step isn't necessary to have the client decode the data but it's here to test
// RecvTable_CopyEncoding (and RecvTable_MergeDeltas). This call should just make an exact
// copy of the encoded data.
unsigned char copyEncoded[4096];
bf_read bfReadDeltaEncoded( "RunDataTableTest->bfReadDeltaEncoded", deltaEncoded, sizeof( deltaEncoded ) );
bf_write bfCopyEncoded( "RunDataTableTest->bfCopyEncoded", copyEncoded, sizeof(copyEncoded) );
RecvTable_CopyEncoding( pRecvTable, &bfReadDeltaEncoded, &bfCopyEncoded, -1 );
// Decode..
bf_read bfDecode( "RunDataTableTest->copyEncoded", copyEncoded, sizeof( copyEncoded ) );
if(!RecvTable_Decode(pRecvTable, &dtClient, &bfDecode, 1111))
{
Assert(false);
}
// Make sure it didn't go into memory it shouldn't have.
CheckGuardBytes( &dtClient );
// Verify that only the changed properties were sent and that they were received correctly.
CompareDTTest( &dtClient, &dtServer );
}
SendTable_Term();
RecvTable_Term();
}
