void Picture::WriteToFile(const char* FileName) const
{
ofstream fout;
fout.open(FileName, ios_base::binary); //destroys the old file
WriteFileHeader(fout);
WriteInfoHeader(fout);
fout.seekp(fileHeader.bfOffBits); //should be 54
int i = 0;
for(unsigned int row = 0; row < infoHeader.biHeight; row++)
{
for(unsigned int column = 0; column < infoHeader.biWidth; column++, i ++)
{
fout.write((char*)&(pixels[i]), 3);
}
unsigned int b = infoHeader.biWidth * 3;
unsigned char junk = 0;
while(b%4 != 0)
{
fout.write((char*)&junk, 1);
b = b + 1;
}
}
fout.close();
}
/// <summary>
/// Stops the recording, writes the file header, and closes the file
/// </summary>
void WaveWriter::Stop()
{
// Come back and update the file-size information.
WriteFileHeader();
FlushFileBuffers(m_fileHandle);
CloseHandle(m_fileHandle);
}
CDemoRecorder::CDemoRecorder()
{
// We want this folder to exist
if (!filesystem.CreateDirectory("demos"))
return;
SetName("unnamed");
demoName = wantedName;
std::string filename = filesystem.LocateFile(demoName, FileSystem::WRITE);
recordDemo.open(filename.c_str(), std::ios::out | std::ios::binary);
memset(&fileHeader, 0, sizeof(DemoFileHeader));
strcpy(fileHeader.magic, DEMOFILE_MAGIC);
fileHeader.version = DEMOFILE_VERSION;
fileHeader.headerSize = sizeof(DemoFileHeader);
strcpy(fileHeader.versionString, SpringVersion::Get().c_str());
__time64_t currtime;
_time64(&currtime);
fileHeader.unixTime = currtime;
recordDemo.write((char*)&fileHeader, sizeof(fileHeader));
fileHeader.playerStatElemSize = sizeof(CPlayer::Statistics);
fileHeader.teamStatElemSize = sizeof(CTeam::Statistics);
fileHeader.teamStatPeriod = CTeam::statsPeriod;
fileHeader.winningAllyTeam = -1;
WriteFileHeader(false);
}
void DnarchFileWriter::FinishCompress()
{
ASSERT(metaStream != NULL);
ASSERT(dataStream != NULL);
// prepare header and write footer
//
fileHeader.footerOffset = metaStream->Position();
WriteFileFooter();
// fill header and write
//
fileHeader.footerSize = metaStream->Position() - fileHeader.footerOffset;
metaStream->SetPosition(0);
WriteFileHeader();
// cleanup exit
//
metaStream->Close();
delete metaStream;
metaStream = NULL;
dataStream->Close();
delete dataStream;
dataStream = NULL;
}
CDemoRecorder::~CDemoRecorder()
{
LOG("Writing demo: %s", GetName().c_str());
WriteWinnerList();
WritePlayerStats();
WriteTeamStats();
WriteFileHeader(true);
WriteDemoFile();
}
void
plD_init_plm(PLStream *pls)
{
PLmDev *dev;
U_CHAR c = (U_CHAR) INITIALIZE;
dbug_enter("plD_init_plm");
pls->color = 1; /* Is a color device */
pls->dev_fill0 = 1; /* Handle solid fills */
pls->dev_fill1 = 1; /* Handle pattern fills */
/* Initialize family file info */
plFamInit(pls);
/* Prompt for a file name if not already set */
plOpenFile(pls);
pls->pdfs = pdf_finit(pls->OutFile);
/* Allocate and initialize device-specific data */
pls->dev = calloc(1, (size_t) sizeof(PLmDev));
if (pls->dev == NULL)
plexit("plD_init_plm: Out of memory.");
dev = (PLmDev *) pls->dev;
dev->xold = PL_UNDEFINED;
dev->yold = PL_UNDEFINED;
dev->xmin = 0;
dev->xmax = PIXELS_X - 1;
dev->ymin = 0;
dev->ymax = PIXELS_Y - 1;
dev->pxlx = (double) PIXELS_X / (double) LPAGE_X;
dev->pxly = (double) PIXELS_Y / (double) LPAGE_Y;
plP_setpxl(dev->pxlx, dev->pxly);
plP_setphy(dev->xmin, dev->xmax, dev->ymin, dev->ymax);
/* Write Metafile header. */
WriteFileHeader(pls);
/* Write color map state info */
plD_state_plm(pls, PLSTATE_CMAP0);
plD_state_plm(pls, PLSTATE_CMAP1);
/* Write initialization command. */
DEBUG_PRINT_LOCATION("before init");
plm_wr( pdf_wr_1byte(pls->pdfs, c) );
}
void CDemoRecorder::SetFileHeader()
{
memset(&fileHeader, 0, sizeof(DemoFileHeader));
strcpy(fileHeader.magic, DEMOFILE_MAGIC);
fileHeader.version = DEMOFILE_VERSION;
fileHeader.headerSize = sizeof(DemoFileHeader);
STRNCPY(fileHeader.versionString, (SpringVersion::GetSync()).c_str(), sizeof(fileHeader.versionString) - 1);
fileHeader.unixTime = CTimeUtil::GetCurrentTime();
fileHeader.playerStatElemSize = sizeof(PlayerStatistics);
fileHeader.teamStatElemSize = sizeof(TeamStatistics);
fileHeader.teamStatPeriod = TeamStatistics::statsPeriod;
fileHeader.winningAllyTeamsSize = 0;
demoStream.seekp(WriteFileHeader(false) + sizeof(DemoFileHeader));
}
CDemoRecorder::~CDemoRecorder()
{
WritePlayerStats();
WriteTeamStats();
WriteFileHeader();
delete recordDemo;
if (demoName != wantedName) {
rename(demoName.c_str(), wantedName.c_str());
} else {
remove("demos/unnamed.sdf");
rename(demoName.c_str(), "demos/unnamed.sdf");
}
}
void DiMeshSerializerImpl::ExportMesh( const DiMesh* pMesh, DiDataStreamPtr stream )
{
mStream = stream;
WriteFileHeader();
DiMesh::ConstSubMeshIterator it = pMesh->GetSubMeshs();
while (it.HasMoreElements())
{
DiSubMesh* sm = it.GetNext();
WriteSubMesh(sm);
}
WriteBoundsInfo(pMesh);
}
void CObjectOStream::Write(const CConstObjectInfo& object)
{
// root writer
BEGIN_OBJECT_FRAME2(eFrameNamed, object.GetTypeInfo());
WriteFileHeader(object.GetTypeInfo());
WriteObject(object);
EndOfWrite();
END_OBJECT_FRAME();
if ( GetAutoSeparator() )
Separator(*this);
}
void CObjectOStream::Write(TConstObjectPtr object, TTypeInfo typeInfo)
{
// root writer
BEGIN_OBJECT_FRAME2(eFrameNamed, typeInfo);
WriteFileHeader(typeInfo);
WriteObject(object, typeInfo);
EndOfWrite();
END_OBJECT_FRAME();
if ( GetAutoSeparator() )
Separator(*this);
}
/* save to the file */
bool FH_SaveToFile(const DataToSave&data,const std::string& filename)
{
// try to open the file.
// if failed then return false.
HANDLE hFile;
if(INVALID_HANDLE_VALUE==(hFile=CreateFile(filename.c_str(),GENERIC_WRITE,FILE_SHARE_READ,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL)))
return false;
WriteFileHeader(data.nNumberOfQuestions,data.nTimeInSeconds,data.nMarks,hFile);
// write questions //
for(int i=0;i<data.questions.size();i++)
{
WriteQuestion(data.questions.at(i),hFile);
}
CloseHandle(hFile); // if no error occurred.
return true;
}
void DiMotionSerializerImpl::ExportMotion( const DiMotion* pMotion, DiDataStreamPtr stream )
{
mStream = stream;
WriteFileHeader();
if (pMotion->GetSkeleton())
{
WriteSkeleton(pMotion->GetSkeleton());
}
DiMotion::ConstAnimationListIterator i = pMotion->GetAnimations();
while (i.HasMoreElements())
{
WriteAnimation(i.GetNext());
}
}
CDemoRecorder::~CDemoRecorder()
{
WritePlayerStats();
WriteTeamStats();
WriteFileHeader();
recordDemo.close();
if (demoName != wantedName) {
if (rename(demoName.c_str(), wantedName.c_str()) != 0) {
logOutput << "Renaming demo " << demoName << " to " << wantedName << "\n";
logOutput << "failed: " << strerror(errno) << "\n";
}
} else {
// pointless?
//remove("demos/unnamed.sdf");
//rename(demoName.c_str(), "demos/unnamed.sdf");
}
}
void PointSearchTester::PerformSearches()
{
Rect rect;
Point *pPointsFound = new Point[NUM_POINTS_TO_FIND];
OpenResultsFile();
WriteFileHeader();
for (int i = 0; i < NUM_SEARCHES; i++)
{
const Rect searchRect = {rect.lx, rect.ly, rect.hx, rect.hy};
int numPointsFound;
numPointsFound = search(m_pSearchContext, searchRect, NUM_POINTS_TO_FIND, pPointsFound);
WriteSearchResults(i, &rect, numPointsFound, pPointsFound);
}
CloseResultsFile();
delete[] pPointsFound;
}
CDemoRecorder::CDemoRecorder()
{
// We want this folder to exist
if (!filesystem.CreateDirectory("demos"))
return;
wantedName = demoName = "demos/unnamed.sdf";
std::string filename = filesystem.LocateFile(demoName, FileSystem::WRITE);
recordDemo = SAFE_NEW std::ofstream(filename.c_str(), std::ios::out | std::ios::binary);
memset(&fileHeader, 0, sizeof(DemoFileHeader));
strcpy(fileHeader.magic, DEMOFILE_MAGIC);
fileHeader.version = DEMOFILE_VERSION;
fileHeader.headerSize = sizeof(DemoFileHeader);
strcpy(fileHeader.versionString, VERSION_STRING);
__time64_t currtime;
_time64(&currtime);
fileHeader.unixTime = currtime;
recordDemo->write((char*)&fileHeader, sizeof(fileHeader));
if (gameSetup) {
// strip trailing null termination characters
int length = gameSetup->gameSetupTextLength;
while (gameSetup->gameSetupText[length - 1] == '\0')
--length;
fileHeader.scriptSize = length;
recordDemo->write(gameSetup->gameSetupText, length);
}
fileHeader.playerStatElemSize = sizeof(CPlayer::Statistics);
fileHeader.teamStatElemSize = sizeof(CTeam::Statistics);
fileHeader.teamStatPeriod = CTeam::statsPeriod;
fileHeader.winningAllyTeam = -1;
WriteFileHeader();
}
bool Savegame::Save(BinaryFile& file)
{
// Versionszeug schreiben
WriteFileHeader(file);
// Timestamp der Aufzeichnung
unser_time_t tmpTime = libendian::ConvertEndianess<false>::fromNative(save_time);
file.WriteRawData(&tmpTime, sizeof(tmpTime));
// Mapname
file.WriteShortString(mapName);
WritePlayerData(file);
WriteGGS(file);
// Start-GF
file.WriteUnsignedInt(start_gf);
// Serialisiertes Spielzeug reinschreiben
sgd.WriteToFile(file);
return true;
}
static void WriteHeader(const char* fileID)
{
WriteFileHeader(fileID, 0, 0);
WriteInt(GetAppID());
WriteLine();
}
bool IO_UncertSimResults::AddUncertRun(const DC_UncertSimResults& resultHeader,
const UncertRunResults& results,
bool addExisting)
{
GenAppClearMsgs();
bool openExisting = addExisting && ConvFileC::CFfileExists(fileName);
DC_UncertSimResults currHeader;
if (openExisting)
{
if (!ReadFileHeader(currHeader, false))
{
GenAppErrorMsg("UncertSimResults", "File contents incompatible");
return false;
}
if ((currHeader.IsMultiple() && (!resultHeader.IsMultiple())) ||
((!currHeader.IsMultiple()) && resultHeader.IsMultiple()))
{
GenAppErrorMsg("UncertSimResults", "Cannot combine multiple & not multiple");
return false;
}
if (currHeader.IsMultiple())
{
if (currHeader.multipleRunVariableIDs.Size() != resultHeader.multipleRunVariableIDs.Size())
GenAppErrorMsg("UncertSimResults", "Multiple run results different size??");
}
}
try
{
SC_IntArray runStartRecs;
runStartRecs.SetResizable();
int nextRec, runIndexRecord;
if (openExisting)
{
ReadFileHeader(currHeader, true);
ReadNextRecord();
runIndexRecord = GetCurrentRec();
nextRec = ReadInt();
ReadIntArray(runStartRecs);
}
else
{
OpenFile(fileName, false);
// set up initial header info
nRuns = 0;
WriteFileHeader(resultHeader);
FlushBuffer(nextRec);
runIndexRecord = nextRec;
// initial header
BufferReset(nextRec);
WriteInt(0);
FlushBuffer(nextRec);
// backup and set nextRec
BufferReset(runIndexRecord);
WriteInt(nextRec);
// reflush
FlushBuffer();
}
int runStart = nextRec;
// set to next avail
BufferReset(nextRec);
// add the run to the end
WriteOneRun(results, nextRec);
nRuns++;
// update header
BufferReset(0);
WriteFileHeader(resultHeader);
FlushBuffer();
// update next avail record
BufferReset(runIndexRecord);
WriteInt(nextRec);
// update run start records
runStartRecs += runStart;
WriteIntArray(runStartRecs);
FlushBuffer();
CloseFile();
return true;
}
catch (BufFileC::BufferFileError& err) {
GenAppErrorMsg("WriteUncertResults", err.errMsg);
}
CloseFile();
return false;
}
void CDemoRecorder::SetGameID(const unsigned char* buf)
{
memcpy(&fileHeader.gameID, buf, sizeof(fileHeader.gameID));
WriteFileHeader(false);
}
static void WriteCFGHeader()
{
WriteFileHeader(fileID, majorVersionNum, 0);
WriteAppGlobals();
}
bool Md2::ConvertToMesh(const std::string &file, float scaleFactor)
{
FILE *fp = fopen(file.c_str(), "wb");
if (fp == NULL)
return false;
WriteFileHeader(fp);
KeyFramesChunk *keyFramesChunk = new KeyFramesChunk();
keyFramesChunk->numVertices = m_numVertices;
for (long i = 0; i < m_numFrames; ++i)
{
KeyFrame *frame = keyFramesChunk->AddFrame();
for (int j = 0; j < m_numVertices; ++j)
frame->vertices[j] = m_frames[i].vertices[j] * scaleFactor;
for (int j = 0; j < m_numVertices; ++j)
frame->normals[j] = m_frames[i].normals[j];
}
WriteChunk(keyFramesChunk, fp);
TexCoordsChunk *texCoordsChunk = new TexCoordsChunk();
for (long i = 0; i < m_numTexCoords; ++i)
texCoordsChunk->texCoords.push_back(m_texCoords[i]);
WriteChunk(texCoordsChunk, fp);
KeyFrameTrianglesChunk *trianglesChunk = new KeyFrameTrianglesChunk();
for (long i = 0; i < m_numPolys; ++i)
{
KeyFrameTriangle t;
t.vertices[0] = m_polys[i].vertex[0];
t.vertices[1] = m_polys[i].vertex[1];
t.vertices[2] = m_polys[i].vertex[2];
t.texCoords[0] = m_polys[i].texCoord[0];
t.texCoords[1] = m_polys[i].texCoord[1];
t.texCoords[2] = m_polys[i].texCoord[2];
trianglesChunk->triangles.push_back(t);
}
WriteChunk(trianglesChunk, fp);
if (m_animations.size() > 0)
{
AnimationsChunk *animationsChunk = new AnimationsChunk();
for (unsigned int i = 0; i < m_animations.size(); ++i)
{
AnimationSequence a;
a.name = m_animations[i].name;
a.start = m_animations[i].startFrame;
a.end = m_animations[i].endFrame;
animationsChunk->animations.push_back(a);
}
WriteChunk(animationsChunk, fp);
}
fclose(fp);
return true;
}
boolean PutFileHeader(FILE *dst, /* pointer to destination file*/
FileHeader_t *header, /* pointer to header struct */
long FileType, /* file type integer pointer */
long FormatType, /* format type binary/ascii */
long NHeaderRecord, /* number of header records */
long init_flag, /* initialization flag 0,1 */
char *ProdAgency, /* producer agency label */
char *ProdInstitution, /* producer institution label */
char *SoftwareVersion, /* software version label */
char *SoftwareLinkTime, /* software link time */
char *Documentation, /* documentation label */
char *SatName, /* satellite name label */
char *SensorName, /* sensor name label */
char *TimeEpoch, /* Time epoch label */
double TfirstObs, /* Time first observation */
double TlastObs, /* Time last observation */
long Nobs, /* number of observations */
char *TimeTag, /* time tag label FIRST,FINAL */
char *FileName, /* Filename */
char *ProcessLevel /* Processing level (1A or 1B)*/
)
/*----------------------------------------------------------------------------->
/ purpose: Take header arguments, update header struct FileHeader_t and
/ write header information to file src
/
/ coded by: Gerhard L.H. Kruizinga 09/12/2000
/
/ input: *src Pointer to data file
/ output: *record Pointer to header struct
/
/ return: 1 normal return
/ 0 End Of File reached before header could be read
/ notes:
/ if any labels are set to "NONE" then default values will be used
/ as specified in file HeaderFile.txt
/
<-----------------------------------------------------------------------------*/
{
char TimeTagUTC[HEADERMAXCHAR],FinalTime[HEADERMAXCHAR];
char StartTime[HEADERMAXCHAR],NobsChar[HEADERMAXCHAR];
char file_type[HEADERMAXCHAR],file_format[HEADERMAXCHAR];
char HeadNrecord[HEADERMAXCHAR],NrBytes[HEADERMAXCHAR];
char none[HEADERMAXCHAR];
int year,month,day,hour,minute,second;
double frac,secs;
GetUTCTimeTag(TimeTagUTC);
strcat(TimeTagUTC," by ");
strcat(TimeTagUTC,getenv("LOGNAME"));
header->filetype = FileType;
header->formattype = FormatType;
if ( header->nrecord < NRHEADERLABELS )
{
header->nrecord = NRHEADERLABELS;
header->NinputFileLabel = 0;
}
header->init_flag = init_flag;
sprintf(file_type, "%d",header->filetype);
sprintf(file_format,"%d",header->formattype);
sprintf(HeadNrecord,"%d",header->nrecord);
seccal(TfirstObs,&year,&month,&day,&hour,&minute,&second,&frac);
frac = (double) (long) (frac * 100);
frac /= 100;
secs = (double)second + frac;
sprintf(StartTime,"%f (%4d-%02d-%02d %02d:%02d:%05.2f)",TfirstObs,
year,month,day,hour,minute,secs);
seccal(TlastObs,&year,&month,&day,&hour,&minute,&second,&frac);
frac = (double) (long) (frac * 100);
frac /= 100;
secs = (double)second + frac;
sprintf(FinalTime,"%f (%4d-%02d-%02d %02d:%02d:%05.2f)",TlastObs,
year,month,day,hour,minute,secs);
sprintf(NobsChar,"%d",Nobs);
sprintf(NrBytes,"%d",ftell(dst));
strcpy(none,"NONE");
ModifyFileHeader(header,GetHeaderLabel("iphProducerAgency") , ProdAgency);
ModifyFileHeader(header,GetHeaderLabel("iphProducerInstitution") , ProdInstitution);
ModifyFileHeader(header,GetHeaderLabel("iphFileType") , file_type);
ModifyFileHeader(header,GetHeaderLabel("iphFileFormat") , file_format);
ModifyFileHeader(header,GetHeaderLabel("iphHeadNrecord") , HeadNrecord);
ModifyFileHeader(header,GetHeaderLabel("iphSoftwareVersion") , SoftwareVersion);
ModifyFileHeader(header,GetHeaderLabel("iphSoftwareLinkTime") , SoftwareLinkTime);
ModifyFileHeader(header,GetHeaderLabel("iphDocumentation") , Documentation);
ModifyFileHeader(header,GetHeaderLabel("iphSatelliteName") , SatName);
ModifyFileHeader(header,GetHeaderLabel("iphSensorName") , SensorName);
ModifyFileHeader(header,GetHeaderLabel("iphTimeEpoch") , TimeEpoch);
ModifyFileHeader(header,GetHeaderLabel("iphTimeFirstObs") , StartTime);
ModifyFileHeader(header,GetHeaderLabel("iphTimeLastObs") , FinalTime);
ModifyFileHeader(header,GetHeaderLabel("iphNumberObs") , NobsChar);
ModifyFileHeader(header,GetHeaderLabel("iphNumberBytes") , NrBytes);
ModifyFileHeader(header,GetHeaderLabel("iphFileName") , FileName);
ModifyFileHeader(header,GetHeaderLabel("iphProcessLevel") , ProcessLevel);
strcpy(header->ProducerAgency , ProdAgency);
strcpy(header->ProducerInstitution , ProdInstitution);
strcpy(header->SoftwareVersion , SoftwareVersion);
strcpy(header->Documentation , Documentation);
strcpy(header->SatelliteName , SatName);
strcpy(header->SensorName , SensorName);
strcpy(header->TimeEpoch , TimeEpoch);
header->TimeFirstObs = TfirstObs;
header->TimeLastObs = TlastObs;
header->NumberObs = Nobs;
sscanf("%ld",NrBytes,&header->NumberBytes);
strcpy(header->FileName , FileName);
strcpy(header->ProcessLevel , ProcessLevel);
if (strcmp(TimeTag,"FINAL") == 0)
{
ModifyFileHeader(header,GetHeaderLabel("iphProductCreateEndTime") , TimeTagUTC);
strcpy(header->ProductCreateEndTime, TimeTagUTC);
}
else
{
ModifyFileHeader(header,GetHeaderLabel("iphProductCreateStartTime"), TimeTagUTC);
ModifyFileHeader(header,GetHeaderLabel("iphProductCreateEndTime") , none);
strcpy(header->ProductCreateStartTime, TimeTagUTC);
strcpy(header->ProductCreateEndTime , none);
}
WriteFileHeader(dst,header);
return True;
}
main (int argc, char *argv[])
/*----------------------------------------------------------------------------->
/ purpose: Dump Contents of any Level 1 product
/
/ coded by: Gerhard L.H. Kruizinga 08/23/00
/
<-----------------------------------------------------------------------------*/
{
FILE *src,*dst;
FileHeader_t header;
double Acc1aZbias;
char BinFilename[HEADERMAXCHAR];
char AscFilename[HEADERMAXCHAR];
char TimeTag[HEADERMAXCHAR];
char file_format[HEADERMAXCHAR];
char NobsChar[HEADERMAXCHAR];
char FileTypeName[HEADERMAXCHAR];
char LinkTimeLabel[HEADERMAXCHAR];
char NrBytes[HEADERMAXCHAR];
long i,ShowHeader,arg_ndx,DumpNrec,AscFileDefined,HeaderOnly;
long MassTnk,MassThr,Ksnr;
long PresTnk,TempTnk,RegTnk,AdapTnk,TempRedTnk,ACC1A_count,AHK1A_vp;
long RmGdel,ACC1A_ang,ACC1A_lin;
long Ka_phase_only,K_phase_only;
/*----------------------------------------------------------------------------->
/ check usage
<-----------------------------------------------------------------------------*/
if (argc < 2)
{
fprintf(stderr,
"\n usage: %s -binfile Level1_Bin_File [-ascfile Level1_Asc_File] [-nohead] [-nrec] [-head_only]\n\n",
argv[0]);
fprintf(stderr," [-masstnk tnk_id (3=both tanks,0=none)] [-massthr tnk_id (3=both tanks,0=none)]\n");
fprintf(stderr," [-pres_tnk tnk_id] [-temp_tnk tnk_id]\n");
fprintf(stderr," [-reg_tnk tnk_id] [-adap_tnk tnk_id] [-tempred_tnk tnk_id]\n");
fprintf(stderr," [-tstart Tstart] [-tfinal Tfinal] [-acc1a_count] [-acc1a_ang] [-acc1a_lin] [-ahk1a_vp]\n");
fprintf(stderr," [-acc1a_zbias Acc1aZbias (def 0)] [-ksnr] [-ka] [-k] [-rm_gdel]\n");
fprintf(stderr," If -ascfile is not defined then output will go to standard out\n");
fprintf(stderr,"\n");
exit(1);
}
/*----------------------------------------------------------------------------->
/ Intialize Header information and other relevant info
<-----------------------------------------------------------------------------*/
InitializeHeaders();
LinkTime(LinkTimeLabel);
MassTnk = 4;
arg_ndx = FindOpt(argc,argv, "-masstnk");
if (arg_ndx != -1) MassTnk = GetLongArgv(argc,argv,"-masstnk");
MassThr = 4;
arg_ndx = FindOpt(argc,argv, "-massthr");
if (arg_ndx != -1) MassThr = GetLongArgv(argc,argv,"-massthr");
PresTnk = 0;
arg_ndx = FindOpt(argc,argv, "-pres_tnk");
if (arg_ndx != -1) PresTnk = GetLongArgv(argc,argv,"-pres_tnk");
TempTnk = 0;
arg_ndx = FindOpt(argc,argv, "-temp_tnk");
if (arg_ndx != -1) TempTnk = GetLongArgv(argc,argv,"-temp_tnk");
TempRedTnk = 0;
arg_ndx = FindOpt(argc,argv, "-tempred_tnk");
if (arg_ndx != -1) TempRedTnk = GetLongArgv(argc,argv,"-tempred_tnk");
RegTnk = 0;
arg_ndx = FindOpt(argc,argv, "-reg_tnk");
if (arg_ndx != -1) RegTnk = GetLongArgv(argc,argv,"-reg_tnk");
AdapTnk = 0;
arg_ndx = FindOpt(argc,argv, "-adap_tnk");
if (arg_ndx != -1) AdapTnk = GetLongArgv(argc,argv,"-adap_tnk");
ShowHeader = 1;
arg_ndx = FindOpt(argc,argv, "-nohead");
if (arg_ndx != -1) ShowHeader = 0;
Ksnr = 0;
arg_ndx = FindOpt(argc,argv, "-ksnr");
if (arg_ndx != -1) Ksnr = 1;
Ka_phase_only = 0;
arg_ndx = FindOpt(argc,argv, "-ka");
if (arg_ndx != -1) Ka_phase_only = 1;
K_phase_only = 0;
arg_ndx = FindOpt(argc,argv, "-k");
if (arg_ndx != -1) K_phase_only = 1;
RmGdel = 0;
arg_ndx = FindOpt(argc,argv, "-rm_gdel");
if (arg_ndx != -1) RmGdel = 1;
HeaderOnly = 0;
arg_ndx = FindOpt(argc,argv, "-head_only");
if (arg_ndx != -1) HeaderOnly = 1;
DumpNrec = DUMPALL;
arg_ndx = FindOpt(argc,argv, "-nrec");
if (arg_ndx != -1) DumpNrec = GetLongArgv(argc,argv,"-nrec");
Tstart = -1.0e32;
arg_ndx = FindOpt(argc,argv, "-tstart");
if (arg_ndx != -1) Tstart = GetDoubleArgv(argc,argv,"-tstart");
Tfinal = 1.0e32;
arg_ndx = FindOpt(argc,argv, "-tfinal");
if (arg_ndx != -1) Tfinal = GetDoubleArgv(argc,argv,"-tfinal");
Acc1aZbias = 0.0;
arg_ndx = FindOpt(argc,argv, "-acc1a_zbias");
if (arg_ndx != -1) Acc1aZbias = GetDoubleArgv(argc,argv,"-acc1a_zbias");
AscFileDefined = 0;
arg_ndx = FindOpt(argc,argv, "-ascfile");
if (arg_ndx != -1) AscFileDefined = 1;
ACC1A_count = 0;
arg_ndx = FindOpt(argc,argv, "-acc1a_count");
if (arg_ndx != -1) ACC1A_count = 1;
ACC1A_ang = 0;
arg_ndx = FindOpt(argc,argv, "-acc1a_ang");
if (arg_ndx != -1) ACC1A_ang = 1;
ACC1A_lin = 0;
arg_ndx = FindOpt(argc,argv, "-acc1a_lin");
if (arg_ndx != -1) ACC1A_lin = 1;
AHK1A_vp = 0;
arg_ndx = FindOpt(argc,argv, "-ahk1a_vp");
if (arg_ndx != -1) AHK1A_vp = 1;
/*----------------------------------------------------------------------------->
/ Open files
<-----------------------------------------------------------------------------*/
strcpy (BinFilename,GetStrArgv(argc,argv,"-binfile"));
src = fopen(BinFilename,"r");
if (src == NULL)
{
fprintf(stderr," Level 1 Product file %s cannot be opened !! \n",
BinFilename);
exit(1);
}
if (AscFileDefined == 1)
{
strcpy (AscFilename,GetStrArgv(argc,argv,"-ascfile"));
dst = fopen(AscFilename,"w");
if (dst == NULL)
{
fprintf(stderr," Level 1 Product file %s cannot be opened !! \n",
AscFilename);
exit(1);
}
}
else
{
strcpy(AscFilename,"Standard_Out");
dst = stdout;
}
/*----------------------------------------------------------------------------->
/ Read Header information and write updated header to Ascii file
<-----------------------------------------------------------------------------*/
if (ReadFileHeader(src,&header) == false)
{
fprintf(stderr,"\n Problem reading file header for file %s\n",BinFilename);
fprintf(stderr," See message above for problem\n\n");
exit(1);
}
GetUTCTimeTag(TimeTag);
strcat(TimeTag," by ");
strcat(TimeTag,getenv("LOGNAME"));
header.formattype = 1;
strcpy(NrBytes,"Not Determined because output is stdout");
if (!HeaderOnly)
{
sprintf(file_format,"%d",header.formattype);
ModifyFileHeader(&header,GetHeaderLabel("iphFileFormat"),file_format);
ModifyFileHeader(&header,GetHeaderLabel("iphFileName"),AscFilename);
ModifyFileHeader(&header,GetHeaderLabel("iphNumberBytes") , NrBytes);
}
if (ShowHeader != 0 ) WriteFileHeader(dst,&header);
if (HeaderOnly) exit(0);
/*----------------------------------------------------------------------------->
/ Based on header information Dump Records
<-----------------------------------------------------------------------------*/
if (header.filetype == GetFileType("ipGFD1XF"))
DumpGFD1XF(src,dst,DumpNrec,Ksnr,K_phase_only,Ka_phase_only);
else if (header.filetype == GetFileType("ipACC1AF"))
DumpACC1AF(src,dst,DumpNrec,ACC1A_count,AHK1A_vp,RmGdel,ACC1A_ang,ACC1A_lin,Acc1aZbias);
else if (header.filetype == GetFileType("ipACC1BF"))
DumpACC1BF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipGNV1AF"))
DumpGNV1AF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipGNV1BF"))
DumpGNV1BF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipKBR1BF"))
DumpKBR1BF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipSCA1AF"))
DumpSCA1AF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipSCA1BF"))
DumpSCA1BF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipPCI1AF"))
DumpPCI1AF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipXXXVOF"))
DumpXXXVOF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipIOA1BF"))
DumpIOA1BF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipOSCFQF"))
DumpOSCFQF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipMAG1XF"))
DumpMAG1XF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipHRT1XF"))
DumpHRT1XF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipTHR1XF"))
DumpTHR1XF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipIHK1XF"))
DumpIHK1XF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipCLK1BF"))
DumpCLK1BF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipTNK1XF"))
DumpTNK1XF(src,dst,DumpNrec, PresTnk,TempTnk,RegTnk,AdapTnk,TempRedTnk);
else if (header.filetype == GetFileType("ipMAS1XF"))
DumpMAS1XF(src,dst,DumpNrec,MassTnk,MassThr);
else if (header.filetype == GetFileType("ipILG1XF"))
DumpILG1XF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipTIM1XF"))
DumpTIM1XF(src,dst,DumpNrec);
else
{
GetFileTypeName(header.filetype,FileTypeName);
if (strcmp(FileTypeName,"NOT_DEFINED") != 0)
{
fprintf(stderr,"File Type %s can not be converted into ascii format!!\n\n",
FileTypeName);
}
else
{
fprintf(stderr," FileTypePointer = %d is not defined or filetype pointer refers to Level1A data!!\n",
header.filetype);
fprintf(stderr," Check Header of input File!\n\n");
exit(1);
}
}
if (DumpNrec != DUMPALL)
{
sprintf(NobsChar,"%d",DumpNrec);
ModifyFileHeader(&header,GetHeaderLabel("iphNumberObs"), NobsChar);
}
GetUTCTimeTag(TimeTag);
strcat(TimeTag," by ");
strcat(TimeTag,getenv("LOGNAME"));
sprintf(NrBytes,"%d",ftell(dst));
ModifyFileHeader(&header,GetHeaderLabel("iphNumberBytes") , NrBytes);
if (ShowHeader != 0 && dst != stdout) WriteFileHeader(dst,&header);
fclose(src);
fclose(dst);
exit(0);
}
