int main(int /*argc*/, char** /*argv*/)
{
Ptex::String error;
PtexPtr<PtexCache> c(PtexCache::create());
c->setSearchPath("foo/bar:.");
PtexPtr<PtexTexture> r(c->get("test.ptx", error));
if (!r) {
std::cerr << error.c_str() << std::endl;
return 1;
}
std::cout << "meshType: " << Ptex::MeshTypeName(r->meshType()) << std::endl;
std::cout << "dataType: " << Ptex::DataTypeName(r->dataType()) << std::endl;
std::cout << "numChannels: " << r->numChannels() << std::endl;
std::cout << "alphaChannel: ";
if (r->alphaChannel() == -1) std::cout << "(none)" << std::endl;
else std::cout << r->alphaChannel() << std::endl;
std::cout << "numFaces: " << r->numFaces() << std::endl;
PtexMetaData* meta = r->getMetaData();
std::cout << "numMetaKeys: " << meta->numKeys() << std::endl;
if (meta->numKeys()) DumpMetaData(meta);
meta->release();
int nfaces = r->numFaces();
for (int i = 0; i < nfaces; i++) {
const Ptex::FaceInfo& f = r->getFaceInfo(i);
std::cout << "face " << i << ":\n"
<< " res: " << int(f.res.ulog2) << ' ' << int(f.res.vlog2) << "\n"
<< " adjface: "
<< f.adjfaces[0] << ' '
<< f.adjfaces[1] << ' '
<< f.adjfaces[2] << ' '
<< f.adjfaces[3] << "\n"
<< " adjedge: "
<< f.adjedge(0) << ' '
<< f.adjedge(1) << ' '
<< f.adjedge(2) << ' '
<< f.adjedge(3) << "\n"
<< " flags: " << int(f.flags) << "\n";
Ptex::Res res = f.res;
while (res.ulog2 > 0 || res.vlog2 > 0) {
PtexFaceData* dh = r->getData(i, res);
if (!dh) break;
DumpData(r->dataType(), r->numChannels(), dh, " ");
bool isconst = dh->isConstant();
dh->release();
if (isconst) break;
if (res.ulog2) res.ulog2--;
if (res.vlog2) res.vlog2--;
}
PtexFaceData* dh = r->getData(i, Ptex::Res(0,0));
DumpData(r->dataType(), r->numChannels(), dh, " ");
dh->release();
}
return 0;
}
void gf_ipmpx_dump_ByteArray(GF_IPMPX_ByteArray *_p, const char *attName, FILE *trace, u32 indent, Bool XMTDump)
{
if (_p && _p->data) {
if (XMTDump) {
StartElement(trace, attName ? attName : (char*)"ByteArray", indent, XMTDump);
indent++;
DumpData(trace, "array", _p->data, _p->length, indent, XMTDump);
indent--;
EndAttributes(trace, GF_TRUE, GF_FALSE);
} else {
DumpData(trace, attName ? attName : "ByteArray", _p->data, _p->length, indent, GF_FALSE);
}
}
}
void
MPICUDAStencil<T>::operator()( Matrix2D<T>& mtx, unsigned int nIters )
{
if( this->ParticipatingInProgram() )
{
// we need to do a halo exchange before our first push of
// data onto the device
if( dumpData )
{
this->DumpData( ofs, mtx, "before initial halo exchange" );
}
DoHaloExchange( mtx );
if( dumpData )
{
this->DumpData( ofs, mtx, "after initial halo exchange" );
}
// apply the operator
CUDAStencil<T>::operator()( mtx, nIters );
if( dumpData )
{
DumpData( ofs, mtx, "after all iterations" );
}
}
MPI_Barrier( MPI_COMM_WORLD );
}
void gf_ipmpx_dump_AUTH(GF_IPMPX_Authentication *ipa, FILE *trace, u32 indent, Bool XMTDump)
{
switch (ipa->tag) {
case GF_IPMPX_AUTH_KeyDescr_Tag:
{
GF_IPMPX_AUTH_KeyDescriptor *p = (GF_IPMPX_AUTH_KeyDescriptor *)ipa;
StartElement(trace, "IPMP_KeyDescriptor", indent, XMTDump);
DumpData(trace, "keyBody", p->keyBody, p->keyBodyLength, indent+1, XMTDump);
if (XMTDump) EndAttributes(trace, GF_TRUE, GF_FALSE);
else EndElement(trace, "", indent, GF_FALSE);
}
break;
case GF_IPMPX_AUTH_AlgorithmDescr_Tag:
{
GF_IPMPX_AUTH_AlgorithmDescriptor *p = (GF_IPMPX_AUTH_AlgorithmDescriptor *)ipa;
StartElement(trace, "IPMP_AlgorithmDescriptor", indent, XMTDump);
if (p->regAlgoID) {
DumpInt(trace, "regAlgoID", p->regAlgoID, indent+1, XMTDump);
} else {
gf_ipmpx_dump_ByteArray(p->specAlgoID, "specAlgoID", trace, indent+1, XMTDump);
}
EndAttributes(trace, XMTDump, GF_TRUE);
if (p->OpaqueData) gf_ipmpx_dump_ByteArray(p->OpaqueData, "OpaqueData", trace, indent+1, XMTDump);
EndElement(trace, "IPMP_AlgorithmDescriptor", indent, XMTDump);
}
break;
}
}
void MainWindow::on_Fetch_clicked()
{
QUrl url(ui->lineEdit->text());
WebWorker *w = new WebWorker(url);
connect(w,SIGNAL(WorkCompleted(QString)),this,SLOT(DumpData(QString)));
QThreadPool::globalInstance()->start(w);
}
/* Dumps data to a file. Uses recursion because of unknown number of dimensions. */
void DumpData(FILE * fd, int rank, int dimensions[], int dataType, void *data)
{
char *dataPtr;
int i, dimSize, dataSize, lineSize;
if (rank > 1) { /* Recursively call DumpData until rank = 1 */
for (i = 1, dimSize = 1; i < rank; i++) {
dimSize *= dimensions[i];
}
for (i = 0; i < dimensions[0]; i++) {
dataPtr =
(char *)data + i * dimSize * nxTypeSize(dataType);
DumpData(fd, rank - 1, &dimensions[1], dataType,
dataPtr);
}
return;
} else { /* Actually print the data */
dataSize = dimensions[0];
dataPtr = (char *)data;
while (dataSize > 0) {
if (dataSize > 10) {
lineSize = 10;
} else {
lineSize = dataSize;
}
WriteData(fd, dataPtr, dataType, lineSize);
fprintf(fd, "\n");
dataSize -= lineSize;
dataPtr += lineSize * nxTypeSize(dataType);
}
}
}
void CAISavLd::Save( void )
{
CFile *pFile;
CFileException* theException = new CFileException;
CString sStdExt, sHead, sSave;
sStdExt = ".std";
for( int i=TASK_DATA; i<=GOAL_DATA; ++i )
{
switch( i )
{
case GOAL_DATA:
sHead = "goals";
break;
case TASK_DATA:
sHead = "tasks";
break;
default:
return;
}
sSave = sHead + sStdExt;
CString sMsg;
// save the list of objects
TRY
{
pFile = OpenForDump( sSave );
ASSERT( pFile != NULL );
DumpData( pFile, i );
}
CATCH( CFileException, theException )
{
// "Save Error"
sMsg = "Save Error";
if( m_pParent != NULL )
m_pParent->MessageBox( sMsg, sSave,
MB_ICONEXCLAMATION | MB_SYSTEMMODAL | MB_OK );
sMsg.Empty();
//throw(ERR_CAI_BAD_FILE);
}
AND_CATCH( CArchiveException, theException )
{
pFile->Close();
delete pFile;
// "Archive Error"
sMsg = "Archive Error";
if( m_pParent != NULL )
m_pParent->MessageBox( sMsg, sSave,
MB_ICONEXCLAMATION | MB_SYSTEMMODAL | MB_OK );
sMsg.Empty();
//throw(ERR_CAI_BAD_FILE);
}
/* Dumps requested data */
int NXBdump(NXhandle fileId, NXname dataName, char *fileName)
{
int dataRank, dataDimensions[NX_MAXRANK], dataType, i;
FILE *fd = NULL;
void *dataBuffer;
/* Check the specified data item exists */
if (FindData(fileId, dataName) != NX_OK)
return NX_ERROR;
/* Open the data and obtain its type and rank details */
if (NXopendata(fileId, dataName) != NX_OK)
return NX_ERROR;
if (NXgetinfo(fileId, &dataRank, dataDimensions, &dataType) != NX_OK)
return NX_ERROR;
/* Open the file */
fd = fopen(fileName, "w");
if (!fd) {
printf("ERROR: failed to open--> %s <-- for writing\n",
fileName);
return NX_ERROR;
}
/* Allocate data space */
if (NXmalloc(&dataBuffer, dataRank, dataDimensions, dataType) != NX_OK)
return NX_ERROR;
/* Read the lot */
if (NXgetdata(fileId, dataBuffer) != NX_OK)
return NX_ERROR;
if (NXclosedata(fileId) != NX_OK)
return NX_ERROR;
/* Print a header */
fprintf(fd, "File : %s, DataSet: %s \n", nxFile, dataName);
for (i = 0; i < dataRank; i++) {
fprintf(fd, " %d ", dataDimensions[i]);
}
fprintf(fd, "\n");
/* Dump the data */
DumpData(fd, dataRank, dataDimensions, dataType, dataBuffer);
/* Clean up */
fclose(fd);
NXfree(&dataBuffer);
return NX_OK;
}
void DumpData(Ptex::DataType dt, int nchan, PtexFaceData* dh, std::string prefix)
{
void* dpixel = malloc(Ptex::DataSize(dt)*nchan);
float* pixel = (float*) malloc(sizeof(float)*nchan);
uint8_t* cpixel = (uint8_t*) malloc(sizeof(uint8_t)*nchan);
Ptex::Res res = dh->res();
printf("%sdata (%d x %d)", prefix.c_str(), res.u(), res.v());
if (dh->isTiled()) {
Ptex::Res tileres = dh->tileRes();
printf(", tiled (%d x %d):\n", tileres.u(), tileres.v());
int n = res.ntiles(tileres);
for (int i = 0; i < n; i++) {
PtexFaceData* t = dh->getTile(i);
std::cout << prefix << " tile " << i;
if (!t) {
std::cout << " NULL!" << std::endl;
} else {
DumpData(dt, nchan, t, prefix + " ");
t->release();
}
}
} else {
int ures, vres;
if (dh->isConstant()) { ures = vres = 1; std::cout << ", const: "; }
else { ures = res.u(); vres = res.v(); std::cout << ":\n"; }
int vimax = vres;// if (vimax > 16) vimax = 16;
for (int vi = 0; vi < vimax; vi++) {
if (vi == 8 && vres > 16) { vi = vres-8; std::cout << prefix << " ..." << std::endl; }
std::cout << prefix << " ";
int uimax = ures;// if (uimax > 16) uimax = 16;
for (int ui = 0; ui < uimax; ui++) {
if (ui == 8 && ures > 16) { ui = ures-8; std::cout << "... "; }
dh->getPixel(ui, vi, dpixel);
Ptex::ConvertToFloat(pixel, dpixel, dt, nchan);
Ptex::ConvertFromFloat(cpixel, pixel, Ptex::dt_uint8, nchan);
for (int c=0; c < nchan; c++) {
printf("%02x", cpixel[c]);
}
printf(" ");
}
if (uimax != ures) printf(" ...");
printf("\n");
}
if (vimax != vres) std::cout << prefix << " ..." << std::endl;
}
free(cpixel);
free(pixel);
free(dpixel);
}
GF_Err gf_ipmpx_dump_WatermarkingInit(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump)
{
GF_IPMPX_WatermarkingInit*p = (GF_IPMPX_WatermarkingInit*)_p;
StartElement(trace, (char*) ( (_p->tag==GF_IPMPX_AUDIO_WM_INIT_TAG) ? "IPMP_AudioWatermarkingInit" : "IPMP_VideoWatermarkingInit"), indent, XMTDump);
indent++;
DumpInt(trace, "inputFormat", p->inputFormat, indent, XMTDump);
DumpInt(trace, "requiredOp", p->requiredOp, indent, XMTDump);
if (p->inputFormat==0x01) {
if (_p->tag==GF_IPMPX_AUDIO_WM_INIT_TAG) {
DumpInt(trace, "nChannels", p->nChannels, indent, XMTDump);
DumpInt(trace, "bitPerSample", p->bitPerSample, indent, XMTDump);
DumpInt(trace, "frequency", p->frequency, indent, XMTDump);
} else {
DumpInt(trace, "frame_horizontal_size", p->frame_horizontal_size, indent, XMTDump);
DumpInt(trace, "frame_vertical_size", p->frame_vertical_size, indent, XMTDump);
DumpInt(trace, "chroma_format", p->chroma_format, indent, XMTDump);
}
}
switch (p->requiredOp) {
case GF_IPMPX_WM_INSERT:
case GF_IPMPX_WM_REMARK:
DumpData(trace, "wmPayload", p->wmPayload, p->wmPayloadLen, indent, XMTDump);
break;
case GF_IPMPX_WM_EXTRACT:
case GF_IPMPX_WM_DETECT_COMPRESSION:
DumpInt(trace, "wmRecipientId", p->wmRecipientId, indent, XMTDump);
break;
}
if (p->opaqueData) DumpData(trace, "opaqueData", p->opaqueData, p->opaqueDataSize, indent, XMTDump);
EndAttributes(trace, XMTDump, GF_TRUE);
gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);
indent--;
EndElement(trace, (char*) ( (_p->tag==GF_IPMPX_AUDIO_WM_INIT_TAG) ? "IPMP_AudioWatermarkingInit" : "IPMP_VideoWatermarkingInit"), indent, XMTDump);
return GF_OK;
}
int Wave::InputWave(const std::string filename) {
if (filename.compare(filename.size() - 4, 4, ".wav") == 0) {
ldata.clear();
rdata.clear();
monodata.clear();
wavename = filename;
WavHdrRead();
DumpData();
SetHeader();
flag = true;
} else {
std::cerr << "error .wav" << std::endl;
return -1;
}
return 0;
}
/* data callback routine that simply dumps the decoded data on the screen */
static void data_callback_proc( NM_PacketDir dir, void* user_data, u_char* pkt_payload,
uint32_t pkt_size, DSSL_Pkt* last_packet )
{
last_packet;
switch(dir)
{
case ePacketDirFromClient:
printf( "\nC->S:\n" );
break;
case ePacketDirFromServer:
printf( "\nS->C:\n" );
break;
default:
printf( "\nUnknown packet direction!" );
return;
}
DumpData( pkt_payload, pkt_size );
}
void uORB::KraitFastRpcChannel::fastrpc_recv_thread()
{
// sit in while loop.
int32_t rc = 0;
int32_t data_length = 0;
uint8_t *data = nullptr;
unsigned long rpc_min, rpc_max;
unsigned long orb_min, orb_max;
double rpc_avg, orb_avg;
unsigned long count = 0;
rpc_max = orb_max = 0;
rpc_min = orb_min = 0xFFFFFFFF;
rpc_avg = orb_avg = 0.0;
int32_t num_topics = 0;
hrt_abstime check_time = 0;
while (!_ThreadShouldExit) {
hrt_abstime t1, t2, t3;
t1 = hrt_absolute_time();
rc = _KraitWrapper.ReceiveBulkData(&data, &data_length, &num_topics);
t2 = hrt_absolute_time();
if (rc == 0) {
//PX4_DEBUG( "Num of topics Received: %d", num_topics );
int32_t bytes_processed = 0;
for (int i = 0; i < num_topics; ++i) {
uint8_t *new_pkt = &(data[bytes_processed]);
struct BulkTransferHeader *header = (struct BulkTransferHeader *)new_pkt;
char *messageName = (char *)(new_pkt + sizeof(struct BulkTransferHeader));
uint16_t check_msg_len = strlen(messageName);
if (header->_MsgNameLen != (check_msg_len + 1)) {
PX4_ERR("Error: Packing error. Sent Msg Len. of[%d] but strlen returned:[%d]", header->_MsgNameLen , check_msg_len);
PX4_ERR("Error: NumTopics: %d processing topic: %d msgLen[%d] dataLen[%d] data_len[%d] bytes processed: %d",
num_topics, i, header->_MsgNameLen, header->_DataLen , data_length, bytes_processed);
DumpData(data, data_length, num_topics);
break;
}
uint8_t *topic_data = (uint8_t *)(messageName + strlen(messageName) + 1);
if (_RxHandler != nullptr) {
_RxHandler->process_received_message(messageName,
header->_DataLen, topic_data);
//PX4_DEBUG( "Received topic data for control message for: [%s] len[%d]\n", name, data_length );
}
bytes_processed += header->_MsgNameLen + header->_DataLen + sizeof(struct BulkTransferHeader);
}
} else {
PX4_DEBUG("Error: Getting data over fastRPC channel\n");
break;
}
t3 = hrt_absolute_time();
count++;
if ((unsigned long)(t2 - t1) < rpc_min) {
rpc_min = (unsigned long)(t2 - t1);
}
if ((unsigned long)(t2 - t1) > rpc_max) {
rpc_max = (unsigned long)(t2 - t1);
}
if ((unsigned long)(t3 - t2) < orb_min) {
orb_min = (unsigned long)(t3 - t2);
}
if ((unsigned long)(t3 - t2) > orb_max) {
orb_max = (unsigned long)(t3 - t2);
}
rpc_avg = ((double)((rpc_avg * (count - 1)) + (unsigned long)(t2 - t1))) / (double)(count);
orb_avg = ((double)((orb_avg * (count - 1)) + (unsigned long)(t3 - t2))) / (double)(count);
if ((unsigned long)(t3 - check_time) >= 10000000) {
//PX4_DEBUG("Krait RPC Stats : rpc_min: %lu rpc_max: %lu rpc_avg: %f", rpc_min, rpc_max, rpc_avg);
//PX4_DEBUG("Krait RPC(orb) Stats: orb_min: %lu orb_max: %lu orb_avg: %f", orb_min, orb_max, orb_avg);
check_time = t3;
rpc_max = orb_max = 0;
rpc_min = orb_min = 0xFFFFFF;
orb_avg = 0;
rpc_avg = 0;
count = 0;
}
//PX4_DEBUG("MsgName: %30s, t1: %lu, t2: %lu, t3: %lu, dt1: %lu, dt2: %lu",name, (unsigned long) t1, (unsigned long) t2, (unsigned long) t3,
// (unsigned long) (t2-t1), (unsigned long) (t3-t2));
}
PX4_DEBUG("[uORB::KraitFastRpcChannel::fastrpc_recv_thread] Exiting fastrpc_recv_thread\n");
}
bool Logging::GraphZone(FILE* stream_file, time_t start, time_t end, GROUPING grouping)
{
if (start == 0)
start = nntpTimeServer.LocalNow();
end = max(start,end) + 24*3600; // add 1 day to end time.
grouping = max(NONE, min(grouping, MONTHLY));
char sSQL[200];
uint16_t bins = 0;
uint32_t bin_offset = 0;
uint32_t bin_scale = 1;
switch (grouping)
{
case HOURLY:
snprintf(sSQL, sizeof(sSQL),
"SELECT zone, strftime('%%H', date, 'unixepoch') as hour, SUM(duration)"
" FROM zonelog WHERE date BETWEEN %lu AND %lu"
" GROUP BY zone,hour ORDER BY zone,hour",
start, end);
bins = 24;
break;
case DAILY:
snprintf(sSQL, sizeof(sSQL),
"SELECT zone, strftime('%%w', date, 'unixepoch') as bucket, SUM(duration)"
" FROM zonelog WHERE date BETWEEN %lu AND %lu"
" GROUP BY zone,bucket ORDER BY zone,bucket",
start, end);
bins = 7;
break;
case MONTHLY:
snprintf(sSQL, sizeof(sSQL),
"SELECT zone, strftime('%%m', date, 'unixepoch') as bucket, SUM(duration)"
" FROM zonelog WHERE date BETWEEN %lu AND %lu"
" GROUP BY zone,bucket ORDER BY zone,bucket",
start, end);
bins = 12;
break;
case NONE:
bins = 100;
bin_offset = start;
bin_scale = (end-start)/bins;
snprintf(sSQL, sizeof(sSQL),
"SELECT zone, ((date-%lu)/%" PRIu32 ") as bucket, SUM(duration)"
" FROM zonelog WHERE date BETWEEN %lu AND %lu"
" GROUP BY zone,bucket ORDER BY zone,bucket",
start, bin_scale, start, end);
break;
}
// Make sure we've zero terminated this string.
sSQL[sizeof(sSQL)-1] = 0;
trace("%s\n", sSQL);
sqlite3_stmt * statement;
// Now determine if we're running V1.0 of the schema.
int res = sqlite3_prepare_v2(m_db, sSQL, -1, &statement, NULL);
if (res)
{
trace("Prepare Failure (%s)\n", sqlite3_errmsg(m_db));
return false;
}
int current_zone = -1;
bool bFirstZone = true;
uint32_t bin_data[bins];
memset(bin_data, 0, bins*sizeof(uint32_t));
while (sqlite3_step(statement) == SQLITE_ROW)
{
int zone = sqlite3_column_int(statement, 0);
if (current_zone != zone)
{
current_zone = zone;
if (!bFirstZone)
DumpData(stream_file, bin_data, bins, bin_scale, bin_offset, grouping == NONE);
fprintf(stream_file, "%s\t\"%d\" : [", bFirstZone?"":"],\n", zone);
memset(bin_data, 0, bins*sizeof(uint32_t));
bFirstZone = false;
}
uint32_t bin = sqlite3_column_int(statement, 1);
uint32_t value = sqlite3_column_int(statement, 2);
bin_data[bin] = value;
}
if (!bFirstZone)
{
DumpData(stream_file, bin_data, bins, bin_scale, bin_offset, grouping == NONE);
fprintf(stream_file, "]\n");
}
sqlite3_finalize(statement);
return true;
}
void mainloop(simulation_data *sim)
{
int blocking, visitstate, err = 0;
char Filename[256];
#ifdef VISIT_INSITU
if(sim->runMode == SIM_STOPPED)
simulate_one_timestep(sim);
do
{
blocking = (sim->runMode == SIM_RUNNING) ? 0 : 1;
// Get input from VisIt or timeout so the simulation can run.
if(sim->par_rank == 0)
visitstate = VisItDetectInput(blocking, -1);
MPI_Bcast(&visitstate, 1, MPI_INT, 0, sim->comm_cart);
// Do different things depending on the output from VisItDetectInput
switch(visitstate)
{
case 0:
// There was no input from VisIt, return control to sim
simulate_one_timestep(sim);
break;
case 1:
// VisIt is trying to connect to sim.
if(VisItAttemptToCompleteConnection() == VISIT_OKAY)
{
//fprintf(stderr, "VisIt connected\n");
VisItSetCommandCallback(ControlCommandCallback, (void*)sim);
VisItSetSlaveProcessCallback2(SlaveProcessCallback, (void*)sim);
VisItSetGetMetaData(SimGetMetaData, (void*)sim);
VisItSetGetMesh(SimGetMesh, (void*)sim);
VisItSetGetVariable(SimGetVariable, (void*)sim);
VisItSetGetDomainList(SimGetDomainList, (void*)sim);
}
else
{
char *err = VisItGetLastError();
fprintf(stderr, "VisIt did not connect: %s\n", err);
free(err);
}
break;
case 2:
// VisIt wants to tell the engine something
if(!ProcessVisItCommand(sim))
{
// Disconnect on an error or closed connection.
VisItDisconnect();
// Start running again if VisIt closes.
sim->runMode = SIM_RUNNING;
}
break;
default:
fprintf(stderr, "Can't recover from error %d!\n", visitstate);
err = 1;
break;
}
} while(!sim->done && err == 0);
#else
do
{
simulate_one_timestep(sim);
char postfix[4];
#ifdef ADIOS
strcpy(postfix, "bp");
DumpData(sim, sim->filename, sim->saveCounter++, postfix);
#elif NETCDF4
#ifdef PARIO
strcpy(postfix, "p.nc");
DumpData(sim, sim->filename, sim->saveCounter++, postfix);
#else
strcpy(postfix, "s.nc");
DumpData(sim, sim->filename, sim->saveCounter++, postfix);
#endif
#elif HDF5
strcpy(postfix, "h5");
DumpData(sim, sim->filename, sim->saveCounter++, postfix);
#elif BOV
strcpy(postfix, "bof");
char name[512];
char cmd[512];
int l0 = strlen(strrchr(sim->filename, '/'));
int l = 1+strlen(sim->filename) - l0;
strncpy(name, sim->filename, l);
sprintf(&name[l], "%05d/", sim->saveCounter);
sprintf(cmd, "mkdir %s", &name[0]);
if(!sim->par_rank){
system(cmd);
}
MPI_Barrier(sim->comm_cart);
strncpy(&name[l+6], &sim->filename[l], l0);
//fprintf(stderr, "creating a subdirectory %s %d\n",name, l0);
//fprintf(stderr, "creating a subdirectory %s %d\n",sim->filename, sim->saveCounter);
DumpData(sim, name, sim->saveCounter++, postfix);
#else
strcpy(postfix, "bin");
DumpData(sim, sim->filename, sim->saveCounter++, postfix);
#endif
//if(sim->par_rank == 0) printf("Saved file %s\n", Filename);
if(sim->cycle == NUMBER_OF_ITERATIONS)
{
sim->done = 1;
}
} while(!sim->done && err == 0);
#endif
}
int main(int argc, char **argv)
{
setlocale(LC_ALL, "C");
DisableDataExecution();
WStrVec argList;
ParseCmdLine(GetCommandLine(), argList);
if (argList.Count() < 2) {
Usage:
ErrOut("%s <filename> [-pwd <password>][-full][-alt][-render <path-%%d.tga>]\n",
path::GetBaseName(argList.At(0)));
return 0;
}
ScopedMem<WCHAR> filePath;
WIN32_FIND_DATA fdata;
HANDLE hfind = FindFirstFile(argList.At(1), &fdata);
if (INVALID_HANDLE_VALUE != hfind) {
ScopedMem<WCHAR> dir(path::GetDir(argList.At(1)));
filePath.Set(path::Join(dir, fdata.cFileName));
FindClose(hfind);
}
else {
// embedded documents are referred to by an invalid path
// containing more information after a colon (e.g. "C:\file.pdf:3:0")
filePath.Set(str::Dup(argList.At(1)));
}
bool fullDump = false;
WCHAR *password = NULL;
WCHAR *renderPath = NULL;
bool useAlternateHandlers = false;
bool loadOnly = false;
int breakAlloc = 0;
for (size_t i = 2; i < argList.Count(); i++) {
if (str::Eq(argList.At(i), L"-full"))
fullDump = true;
else if (str::Eq(argList.At(i), L"-pwd") && i + 1 < argList.Count())
password = argList.At(++i);
else if (str::Eq(argList.At(i), L"-render") && i + 1 < argList.Count())
renderPath = argList.At(++i);
else if (str::Eq(argList.At(i), L"-alt"))
useAlternateHandlers = true;
else if (str::Eq(argList.At(i), L"-loadonly"))
loadOnly = true;
#ifdef DEBUG
else if (str::Eq(argList.At(i), L"-breakalloc") && i + 1 < argList.Count())
breakAlloc = _wtoi(argList.At(++i));
#endif
else
goto Usage;
}
#ifdef DEBUG
if (breakAlloc) {
_CrtSetBreakAlloc(breakAlloc);
if (!IsDebuggerPresent())
MessageBox(NULL, L"Keep your debugger ready for the allocation breakpoint...", L"EngineDump", MB_ICONINFORMATION);
}
#endif
// optionally use GDI+ rendering for PDF/XPS and the original ChmEngine for CHM
DebugGdiPlusDevice(useAlternateHandlers);
DebugAlternateChmEngine(!useAlternateHandlers);
ScopedGdiPlus gdiPlus;
DocType engineType;
PasswordHolder pwdUI(password);
BaseEngine *engine = EngineManager::CreateEngine(true, filePath, &pwdUI, &engineType);
if (!engine) {
ErrOut("Error: Couldn't create an engine for %s!\n", path::GetBaseName(filePath));
return 1;
}
if (!loadOnly)
DumpData(engine, fullDump);
if (renderPath)
RenderDocument(engine, renderPath);
delete engine;
#ifdef DEBUG
// report memory leaks on stderr for engines that shouldn't leak
if (engineType != Engine_DjVu) {
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
}
#endif
return 0;
}
int main()
{
unsigned char buffer[INPUT_BUFFER];
unsigned char *TmRegArea,*I2CArea,*TEMAC0Area,*TEMAC1Area,*TEMAC2Area,*BdArea,*ptr,EthControllerState=0;;
int i,fd,Exit=0;
unsigned rc,Address,Data,Offset,I2C_slave_address,tmp1;
struct termios oldt, newt;
int ch;
tcgetattr( STDIN_FILENO, &oldt );
newt = oldt;
newt.c_cc[VMIN] = 0;
newt.c_cc[VTIME] = 1;
newt.c_lflag &= ~( ICANON | ECHO );
tcsetattr( STDIN_FILENO, TCSANOW, &newt );
fd = open("/dev/mem",O_RDWR|O_SYNC);
if(fd < 0){
printf("Can't open /dev/mem\n");
return 1;
}
TmRegArea = (unsigned char *) mmap(0, 0x10000, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0x44000000);
if(TmRegArea == NULL){
printf("Can't mmap\n");
return 1;
}
printf("\nTmRegArea %08X",TmRegArea); //edo
TEMAC0Area = (unsigned char *) mmap(0, 0x10000, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0x47000000);
if(TEMAC0Area == NULL){
printf("Can't mmap\n");
return 1;
}
printf("\nTEMAC0Area %08X",TEMAC0Area); //edo
TEMAC1Area = (unsigned char *) mmap(0, 0x10000, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0x48000000);
if(TEMAC1Area == NULL){
printf("Can't mmap\n");
return 1;
}
printf("\nTEMAC1Area %08X",TEMAC1Area); //edo
TEMAC2Area = (unsigned char *) mmap(0, 0x10000, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0x49000000);
if(TEMAC2Area == NULL){
printf("Can't mmap\n");
return 1;
}
printf("\nTEMAC2Area %08X",TEMAC2Area); //edo
BdArea = (unsigned char *) mmap(0, 0x20000, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0x45000000);
if(BdArea == NULL){
printf("Can't mmap\n");
return 1;
}
printf("\nBdArea %08X",BdArea); //edo
printf("Tm>\n");
i = 0;
do{
/*----------------------------------------------------------------------------*/
/* Ethernet Rx frame management. */
/*----------------------------------------------------------------------------*/
if (EthControllerState != 0)
Ethernet_GetRxFrameManagement();
buffer[i] = getchar();
if (buffer[i] != 0xFF){
printf("%c",buffer[i]);
if (buffer[i] == CHAR_LF){
printf("\n");
buffer[i] = 0;
rc = 0;
switch (buffer[0]){
/*----------------------------------------------------------------------------*/
/* I2C */
/*----------------------------------------------------------------------------*/
case 'c':
if (buffer[1]=='1')
{
*(unsigned *) (TEMAC0Area+0x0404) = 0xD0000000;
*(unsigned *) (TEMAC0Area+0x0408) = 0xD0000000;
*(unsigned *) (TEMAC0Area+0x0500) = 0x58;
*(unsigned *) (TEMAC0Area+0x0508) = 0x1140;
*(unsigned *) (TEMAC0Area+0x0504) = 0x4800;
delay(0x1000000);
while (( ((*(unsigned *) (TEMAC0Area+0x050C)) & 0x10000) != 0x10000));
*(unsigned *) (TEMAC0Area+0x0508) = 0x1340;
*(unsigned *) (TEMAC0Area+0x0504) = 0x4800;
delay(0x1000000);
while (( ((*(unsigned *) (TEMAC0Area+0x050C)) & 0x10000) != 0x10000));
*(unsigned *) (TEMAC0Area+0x0504) = 0x18800;
delay(0x1000000);
while (( ((*(unsigned *) (TEMAC0Area+0x050C)) & 0x10000) != 0x10000));
printf("\n\rStatus register: ");
printf("%08X",((*(unsigned *) (TEMAC0Area+0x050C)) & 0xFFFF));
*(unsigned *) (TEMAC0Area+0x0504) = 0x18800;
delay(0x1000000);
while (( ((*(unsigned *) (TEMAC0Area+0x050C)) & 0x10000) != 0x10000));
printf("\n\rStatus register: ");
printf("%08X",((*(unsigned *) (TEMAC0Area+0x050C)) & 0xFFFF));
*(unsigned *) (TmRegArea+0x1004) = 0x1;
*(unsigned *) (TmRegArea+0x1204) = 0x1;
*(unsigned *) (TmRegArea+0x1304) = 0x1;
*(unsigned *) (TmRegArea+0x0010) = 0x1;
*(unsigned *) (TmRegArea+0xC000) = 0x00010203;
*(unsigned *) (TmRegArea+0xC004) = 0x04060000;
*(unsigned *) (TmRegArea+0xC008) = 0xFFFFFFFF;
*(unsigned *) (TmRegArea+0xC00C) = 0xFFFF0000;
*(unsigned *) (TmRegArea+0xC010) = 0x15;
}
else if (buffer[1]=='2')
{
}
else if (buffer[1]=='3')
{
}
else
rc = ERROR_SYNTAX;
break;
/*----------------------------------------------------------------------------*/
/* Ethernet statistics command. */
/*----------------------------------------------------------------------------*/
case 'e':
break;
/*----------------------------------------------------------------------------*/
/* Ethernet controller initialization command. */
/*----------------------------------------------------------------------------*/
case 'E':
rc = EthernetControllerInit(TmRegArea,BdArea);
EthControllerState = 1;
break;
/*----------------------------------------------------------------------------*/
/* Help panel command. */
/*----------------------------------------------------------------------------*/
case 'h':
PrintHelpPanel();
rc = 0;
break;
/*----------------------------------------------------------------------------*/
/* Memory Dump. */
/*----------------------------------------------------------------------------*/
case 'm':
rc = 0;
if (buffer[1] == 'd'){
ptr = AsciiToHex(&buffer[2],&Address);
Data = 0x40;
if ((ptr != 0)&&(*ptr == ',')){
ptr = AsciiToHex(++ptr,&Data);
if (Data == 0)
Data = 0x40;
}
if ((Address & 0xFFF00000) == 0x83C00000){
Offset = Address - 0x83C00000;
DumpData(TmRegArea+Offset,Address,Data);
}
else if ((Address & 0xFF000000) == 0x84000000){
Offset = Address - 0x84000000;
DumpData(BdArea+Offset,Address,Data);
}
}
else if (buffer[1] == 'w'){
ptr = AsciiToHex(&buffer[2],&Address);
if ((ptr == 0)||(*ptr != ','))
rc = ERROR_SYNTAX;
else{
ptr = AsciiToHex(++ptr,&Data);
if ((Address & 0xFFF00000) == 0x83C00000){
Address = Address - 0x83C00000;
*(unsigned *)(TmRegArea+Address) = Data;
}
else if ((Address & 0xFF000000) == 0x84000000){
Address = Address - 0x84000000;
*(unsigned *)(BdArea+Address) = Data;
}
}
}
else
rc = ERROR_SYNTAX;
break;
/*----------------------------------------------------------------------------*/
/* Exit command. */
/*----------------------------------------------------------------------------*/
case 'q':
Exit = 1;
rc = 0;
break;
/*----------------------------------------------------------------------------*/
/* Error in case commands are not found. */
/*----------------------------------------------------------------------------*/
default:
rc = ERROR_SYNTAX;
printf("\n\rSyntax Error in last command");
break;
}
i = 0;
if (rc != 0)
printf("\n\rERROR: %08X",rc);
else
printf("\n\rOK\n\r");
printf("\n\rTm>");
}
else
if (buffer[i] == CHAR_BS){
if (i > 0)
i--;
}
else
if (++i > INPUT_BUFFER - 1)
i = INPUT_BUFFER - 1;
}
} while (Exit == 0);
tcsetattr( STDIN_FILENO, TCSANOW, &oldt );
}
void
MPICUDAStencil<T>::DoPreIterationWork( T* currBuf, // in device global memory
T* altBuf, // in device global memory
Matrix2D<T>& mtx,
unsigned int iter )
{
// do the halo exchange at desired frequency
// note that we *do not* do the halo exchange here before the
// first iteration, because we did it already (before we first
// pushed the data onto the device) in our operator() method.
unsigned int haloWidth = this->GetNumberIterationsPerHaloExchange();
if( (iter > 0) && (iter % haloWidth) == 0 )
{
unsigned int nRows = mtx.GetNumRows();
unsigned int nCols = mtx.GetNumColumns();
unsigned int nPaddedCols = mtx.GetNumPaddedColumns();
T* flatData = mtx.GetFlatData();
size_t nsDataItemCount = haloWidth * nPaddedCols;
size_t ewDataItemCount = haloWidth * nRows;
size_t nsDataSize = nsDataItemCount * sizeof(T);
size_t ewDataSize = ewDataItemCount * sizeof(T);
//
// read current data off device
// we only read halo, and only for sides where we have a neighbor
//
if( this->HaveNorthNeighbor() )
{
// north data is contiguous - copy directly into matrix
cudaMemcpy( flatData + (haloWidth * nPaddedCols), // dest
currBuf + (haloWidth * nPaddedCols), // src
nsDataSize, // amount to transfer
cudaMemcpyDeviceToHost ); // direction
}
if( this->HaveSouthNeighbor() )
{
// south data is contiguous - copy directly into matrix
cudaMemcpy( flatData + ((nRows - 2*haloWidth)*nPaddedCols), // dest
currBuf + ((nRows - 2*haloWidth)*nPaddedCols), // src
nsDataSize, // amount to transfer
cudaMemcpyDeviceToHost ); // direction
}
if( this->HaveEastNeighbor() )
{
// east data is non-contiguous - but CUDA has a strided read
cudaMemcpy2D( flatData + (nCols - 2*haloWidth), // dest
nPaddedCols * sizeof(T), // dest pitch
currBuf + (nCols - 2*haloWidth), // src
nPaddedCols * sizeof(T), // src pitch
haloWidth * sizeof(T), // width of data to transfer (bytes)
nRows, // height of data to transfer (rows)
cudaMemcpyDeviceToHost ); // transfer direction
}
if( this->HaveWestNeighbor() )
{
// west data is non-contiguous - but CUDA has a strided read
cudaMemcpy2D( flatData + haloWidth, // dest
nPaddedCols * sizeof(T), // dest pitch
currBuf + haloWidth, // src
nPaddedCols * sizeof(T), // src pitch
haloWidth * sizeof(T), // width of data to transfer (bytes)
nRows, // height of data to transfer (rows)
cudaMemcpyDeviceToHost ); // transfer direction
}
//
// do the actual halo exchange
//
if( dumpData )
{
DumpData( ofs, mtx, "before halo exchange" );
}
DoHaloExchange( mtx );
if( dumpData )
{
DumpData( ofs, mtx, "after halo exchange" );
}
//
// push updated data back onto device
// we only write halo, and only for sides where we have a neighbor
//
if( this->HaveNorthNeighbor() )
{
// north data is contiguous - copy directly from matrix
cudaMemcpy( currBuf, // dest
flatData, // src
nsDataSize, // amount to transfer
cudaMemcpyHostToDevice ); // direction
}
if( this->HaveSouthNeighbor() )
{
// south data is contiguous - copy directly from matrix
cudaMemcpy( currBuf + ((nRows - haloWidth)*nPaddedCols), // dest
flatData + ((nRows - haloWidth)*nPaddedCols), // src
nsDataSize, // amount to transfer
cudaMemcpyHostToDevice ); // direction
}
if( this->HaveEastNeighbor() )
{
// east data is non-contiguous - but CUDA has a strided write
cudaMemcpy2D( currBuf + (nCols - haloWidth), // dest
nPaddedCols * sizeof(T), // dest pitch
flatData + (nCols - haloWidth), // src
nPaddedCols * sizeof(T), // src pitch
haloWidth * sizeof(T), // width of data to transfer (bytes)
nRows, // height of data to transfer (rows)
cudaMemcpyHostToDevice ); // transfer direction
}
if( this->HaveWestNeighbor() )
{
// west data is non-contiguous - but CUDA has a strided write
cudaMemcpy2D( currBuf, // dest
nPaddedCols * sizeof(T), // dest pitch
flatData, // src
nPaddedCols * sizeof(T), // src pitch
haloWidth * sizeof(T), // width of data to transfer (bytes)
nRows, // height of data to transfer (rows)
cudaMemcpyHostToDevice ); // transfer direction
}
// we have changed the local halo values on the device
// we need to update the local 1-wide halo in the alt buffer
// note we only need to update the 1-wide halo here, even if
// our real halo width is larger
size_t rowExtent = mtx.GetNumPaddedColumns() * sizeof(T);
cudaMemcpy2D( altBuf, // destination
rowExtent, // destination pitch
currBuf, // source
rowExtent, // source pitch
rowExtent, // width of data to transfer (bytes)
1, // height of data to transfer (rows)
cudaMemcpyDeviceToDevice );
cudaMemcpy2D( altBuf + (mtx.GetNumRows() - 1) * mtx.GetNumPaddedColumns(), // destination
rowExtent, // destination pitch
currBuf + (mtx.GetNumRows() - 1) * mtx.GetNumPaddedColumns(), // source
rowExtent, // source pitch
rowExtent, // width of data to transfer (bytes)
1, // height of data to transfer (rows)
cudaMemcpyDeviceToDevice );
// copy the non-contiguous data
cudaMemcpy2D( altBuf, // destination
rowExtent, // destination pitch
currBuf, // source
rowExtent, // source pitch
sizeof(T), // width of data to transfer (bytes)
mtx.GetNumRows(), // height of data to transfer (rows)
cudaMemcpyDeviceToDevice );
cudaMemcpy2D( altBuf + (mtx.GetNumColumns() - 1), // destination
rowExtent, // destination pitch
currBuf + (mtx.GetNumColumns() - 1), // source
rowExtent, // source pitch
sizeof(T), // width of data to transfer (bytes)
mtx.GetNumRows(), // height of data to transfer (rows)
cudaMemcpyDeviceToDevice );
}
}
GF_Err gf_ipmpx_dump_MutualAuthentication(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump)
{
u32 i, count;
GF_IPMPX_MutualAuthentication *p = (GF_IPMPX_MutualAuthentication*)_p;
StartElement(trace, "IPMP_MutualAuthentication", indent, XMTDump);
indent++;
DumpBool(trace, "failedNegotiation", p->failedNegotiation, indent, XMTDump);
if (gf_list_count(p->certificates)) DumpInt(trace, "certType", p->certType, indent, XMTDump);
EndAttributes(trace, XMTDump, GF_TRUE);
gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);
StartList(trace, "candidateAlgorithms", indent, XMTDump);
count = gf_list_count(p->candidateAlgorithms);
indent++;
for (i=0; i<count; i++) {
GF_IPMPX_Authentication *ip_auth = (GF_IPMPX_Authentication *)gf_list_get(p->candidateAlgorithms, i);
gf_ipmpx_dump_AUTH(ip_auth, trace, indent, XMTDump);
}
indent--;
EndList(trace, "candidateAlgorithms", indent, XMTDump);
StartList(trace, "agreedAlgorithms", indent, XMTDump);
count = gf_list_count(p->agreedAlgorithms);
indent++;
for (i=0; i<count; i++) {
GF_IPMPX_Authentication *ip_auth = (GF_IPMPX_Authentication *)gf_list_get(p->agreedAlgorithms, i);
gf_ipmpx_dump_AUTH(ip_auth, trace, indent, XMTDump);
}
indent--;
EndList(trace, "agreedAlgorithms", indent, XMTDump);
if (p->AuthenticationData) gf_ipmpx_dump_ByteArray(p->AuthenticationData, "AuthenticationData", trace, indent, XMTDump);
count = gf_list_count(p->certificates);
if (count || p->opaque || p->publicKey) {
/*type 1*/
if (count) {
StartList(trace, "certificates", indent, XMTDump);
for (i=0; i<count; i++) {
GF_IPMPX_ByteArray *ipd = (GF_IPMPX_ByteArray *)gf_list_get(p->certificates, i);
if (XMTDump) {
gf_ipmpx_dump_ByteArray(ipd, NULL, trace, indent, XMTDump);
} else {
StartAttribute(trace, "", indent, GF_FALSE);
DumpData(trace, NULL, ipd->data, ipd->length, indent, GF_FALSE);
if (i+1<count) fprintf(trace, ",");
fprintf(trace, "\n");
}
}
EndList(trace, "certificates", indent, XMTDump);
}
/*type 2*/
else if (p->publicKey) {
gf_ipmpx_dump_AUTH((GF_IPMPX_Authentication *) p->publicKey, trace, indent, XMTDump);
}
/*type 0xFE*/
else if (p->opaque) {
gf_ipmpx_dump_ByteArray(p->opaque, "opaque", trace, indent, XMTDump);
}
if (!XMTDump) StartAttribute(trace, "trustData", indent, GF_FALSE);
else {
StartElement(trace, "trustData", indent, XMTDump);
EndAttributes(trace, XMTDump, GF_TRUE);
}
gf_ipmpx_dump_data((GF_IPMPX_Data *)p->trustData, trace, indent, XMTDump);
if (XMTDump) EndElement(trace, "trustData", indent, XMTDump);
gf_ipmpx_dump_ByteArray(p->authCodes, "authCodes", trace, indent, XMTDump);
}
indent--;
EndElement(trace, "IPMP_MutualAuthentication", indent, XMTDump);
return GF_OK;
}
void __cdecl main(int argc, char **argv)
{
RPC_STATUS status;
unsigned char * pbPicklingBuffer = NULL;
char * pszStyle = NULL;
char * pszFileName = "pickle.dat";
int i;
int fEncode = 1;
int fFixedStyle = 1;
/* allow the user to override settings with command line switches */
for (i = 1; i < argc; i++) {
if ((*argv[i] == '-') || (*argv[i] == '/')) {
switch (tolower(*(argv[i]+1))) {
case 'd':
fEncode = 0;
break;
case 'e':
fEncode = 1;
break;
case 'i':
fFixedStyle = 0;
break;
case 'f':
pszFileName = argv[i] + 2;
break;
case 'h':
case '?':
default:
Usage(argv[0]);
}
}
else
Usage(argv[0]);
}
/* Fixed buffer style: the buffer should be big enough. */
/* Please note that the buffer has to be aligned at 8. */
pbPicklingBuffer = (unsigned char *)
midl_user_allocate( BUFSIZE * sizeof(unsigned char));
if ( pbPicklingBuffer == NULL ) {
printf_s("Cannot allocate the pickling buffer\n");
exit(1);
}
else
memset( pbPicklingBuffer, 0xdd, BUFSIZE );
/*
Set the pickling handle that will be used for data serialization.
The global ImplicitPicHandle is used, but it has to be set up.
*/
if ( fEncode ) {
unsigned char * pszNameId;
OBJECT1 Object1;
OBJECT2 * pObject2;
unsigned long ulEncodedSize = 0;
printf_s("\nEncoding run: use -d for decoding\n\n");
if ( fFixedStyle ) {
printf_s("Creating a fixed buffer encoding handle\n");
status = MesEncodeFixedBufferHandleCreate( pbPicklingBuffer,
BUFSIZE,
& ulEncodedSize,
& ImplicitPicHandle );
printf_s("MesEncodeFixedBufferHandleCreate returned 0x%x\n", status);
if (status) {
exit(status);
}
}
else {
pUserState->LastSize = 0;
pUserState->pMemBuffer = (char *)pbPicklingBuffer;
pUserState->pBufferStart = (char *)pbPicklingBuffer;
printf_s("Creating an incremental encoding handle\n");
status = MesEncodeIncrementalHandleCreate( pUserState,
PicAlloc,
PicWrite,
& ImplicitPicHandle );
printf_s("MesEncodeIncrementalHandleCreate returned 0x%x\n", status);
if (status) {
exit(status);
}
}
/* Creating objects to manipulate */
pszNameId = "Procedure pickling sample";
for (i = 0; i < ARR_SIZE; i++)
Object1.al[i] = 0x37370000 + i;
Object1.s = 0x4646;
pObject2 = midl_user_allocate( sizeof(OBJECT2) + ARR_SIZE*sizeof(short) );
if (pObject2 == NULL ) {
printf_s("Out of memory for Object2\n");
exit(1);
}
pObject2->sSize = ARR_SIZE;
for (i = 0; i < ARR_SIZE; i++)
pObject2->as[i] = 0x7700 + i;
DumpData( "Data to be encoded", pszNameId, &Object1, pObject2 );
printf_s("\nEncoding all the arguments to the buffer\n\n");
ProcPickle( pszNameId, & Object1, pObject2 );
printf_s("Writing the data to the file: %s\n", pszFileName);
WriteDataToFile( pszFileName,
pbPicklingBuffer,
fFixedStyle ? ulEncodedSize
: pUserState->LastSize);
midl_user_free( pObject2 );
}
else {
char acNameBuffer[50];
OBJECT1 Object1;
OBJECT2 * pObject2;
printf_s("\nDecoding run: use -e for encoding\n\n");
printf_s("Reading the data from the file: %s\n\n", pszFileName );
ReadDataFromFile( pszFileName,
pbPicklingBuffer,
BUFSIZE );
if ( fFixedStyle ) {
printf_s("Creating a decoding handle\n");
status = MesDecodeBufferHandleCreate( pbPicklingBuffer,
BUFSIZE,
& ImplicitPicHandle );
printf_s("MesDecodeFixedBufferHandleCreate returned 0x%x\n", status);
if (status) {
exit(status);
}
}
else {
pUserState->LastSize = 0;
pUserState->pMemBuffer = (char *)pbPicklingBuffer;
pUserState->pBufferStart = (char *)pbPicklingBuffer;
printf_s("Creating an incremental decoding handle\n");
status = MesDecodeIncrementalHandleCreate( pUserState,
PicRead,
& ImplicitPicHandle );
printf_s("MesDecodeIncrementalHandleCreate returned 0x%x\n", status);
if (status) {
exit(status);
}
}
/* Creating objects to manipulate */
pObject2 = midl_user_allocate( sizeof(OBJECT2) + ARR_SIZE*sizeof(short));
if (pObject2 == NULL ) {
printf_s("Out of memory for Object2\n");
exit(1);
}
printf_s("\nDecoding all the arguments from the buffer\n");
ProcPickle( acNameBuffer, & Object1, pObject2 );
DumpData( "Decoded data", acNameBuffer, &Object1, pObject2 );
midl_user_free( pObject2 );
}
printf_s("\nData serialization done.\n");
midl_user_free( pbPicklingBuffer );
printf_s("\nFreeing the serialization handle.\n");
status = MesHandleFree( ImplicitPicHandle );
printf_s("MesHandleFree returned 0x%x\n", status);
exit(0);
} // end main()
int main(int argc, char **argv)
{
setlocale(LC_ALL, "C");
DisableDataExecution();
WStrVec argList;
ParseCmdLine(GetCommandLine(), argList);
if (argList.Count() < 2) {
Usage:
ErrOut("%s [-pwd <password>][-quick][-render <path-%%d.tga>] <filename>",
path::GetBaseName(argList.At(0)));
return 2;
}
ScopedMem<WCHAR> filePath;
WCHAR *password = NULL;
bool fullDump = true;
WCHAR *renderPath = NULL;
float renderZoom = 1.f;
bool useAlternateHandlers = false;
bool loadOnly = false, silent = false;
#ifdef DEBUG
int breakAlloc = 0;
#endif
for (size_t i = 1; i < argList.Count(); i++) {
if (str::Eq(argList.At(i), L"-pwd") && i + 1 < argList.Count() && !password)
password = argList.At(++i);
else if (str::Eq(argList.At(i), L"-quick"))
fullDump = false;
else if (str::Eq(argList.At(i), L"-render") && i + 1 < argList.Count() && !renderPath) {
// optional zoom argument (e.g. -render 50% file.pdf)
float zoom;
if (i + 2 < argList.Count() && str::Parse(argList.At(i + 1), L"%f%%%$", &zoom) && zoom > 0.f) {
renderZoom = zoom / 100.f;
i++;
}
renderPath = argList.At(++i);
}
// -alt is for debugging alternate rendering methods
else if (str::Eq(argList.At(i), L"-alt"))
useAlternateHandlers = true;
// -loadonly and -silent are only meant for profiling
else if (str::Eq(argList.At(i), L"-loadonly"))
loadOnly = true;
else if (str::Eq(argList.At(i), L"-silent"))
silent = true;
// -full is for backward compatibility
else if (str::Eq(argList.At(i), L"-full"))
fullDump = true;
#ifdef DEBUG
else if (str::Eq(argList.At(i), L"-breakalloc") && i + 1 < argList.Count())
breakAlloc = _wtoi(argList.At(++i));
#endif
else if (!filePath)
filePath.Set(str::Dup(argList.At(i)));
else
goto Usage;
}
if (!filePath)
goto Usage;
#ifdef DEBUG
if (breakAlloc) {
_CrtSetBreakAlloc(breakAlloc);
if (!IsDebuggerPresent())
MessageBox(NULL, L"Keep your debugger ready for the allocation breakpoint...", L"EngineDump", MB_ICONINFORMATION);
}
#endif
if (silent) {
FILE *nul;
freopen_s(&nul, "NUL", "w", stdout);
freopen_s(&nul, "NUL", "w", stderr);
}
// optionally use GDI+ rendering for PDF/XPS
DebugGdiPlusDevice(useAlternateHandlers);
ScopedGdiPlus gdiPlus;
ScopedMiniMui miniMui;
WIN32_FIND_DATA fdata;
HANDLE hfind = FindFirstFile(filePath, &fdata);
// embedded documents are referred to by an invalid path
// containing more information after a colon (e.g. "C:\file.pdf:3:0")
if (INVALID_HANDLE_VALUE != hfind) {
ScopedMem<WCHAR> dir(path::GetDir(filePath));
filePath.Set(path::Join(dir, fdata.cFileName));
FindClose(hfind);
}
EngineType engineType;
PasswordHolder pwdUI(password);
BaseEngine *engine = EngineManager::CreateEngine(filePath, &pwdUI, &engineType);
if (!engine) {
ErrOut("Error: Couldn't create an engine for %s!", path::GetBaseName(filePath));
return 1;
}
Vec<PageAnnotation> *userAnnots = LoadFileModifications(engine->FileName());
engine->UpdateUserAnnotations(userAnnots);
delete userAnnots;
if (!loadOnly)
DumpData(engine, fullDump);
if (renderPath)
RenderDocument(engine, renderPath, renderZoom, silent);
delete engine;
#ifdef DEBUG
// report memory leaks on stderr for engines that shouldn't leak
if (engineType != Engine_DjVu) {
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
}
#endif
return 0;
}
