void openLogfile()
{
if (logFD != NULL)
{
TAP_Print("openLogfile: attempting to open file that's already open\r\n");
return;
}
logFD = TAP_Hdd_Fopen((char *)LOGFILENAME);
if (logFD == NULL)
{
//TAP_Print("File doesn't exist. Creating log file...\r\n");
TAP_Hdd_Create((char *)LOGFILENAME, ATTR_NORMAL);
logFD = TAP_Hdd_Fopen((char *)LOGFILENAME);
//write the header stuff identifying this machine/firmware
logByteCount = sizeof logByteCount;
//TAP_Hdd_Fwrite((void *)logByteCount, logByteCount, 1, logFD);
TAP_Hdd_Fwrite((void *)"4 ", logByteCount, 1, logFD);
//TAP_Print("File marker written...\r\n");
}
else
{
// goto the end of the file
//TAP_Hdd_Fseek(logFD, 0, SEEK_END);
}
}
//----------------
//
void WriteDatFile( TYPE_File *writeFile )
{
char* currentDir;
appendToLogfile("WriteDatFile: Started.", INFO);
appendToLogfile("WriteDatFile: GetCurrentDir called.", WARNING);
currentDir = GetCurrentDir(); // Store the current directory.
appendStringToLogfile("WriteDatFile: GetCurrentDir returned=%s.",currentDir, WARNING);
appendStringToLogfile("WriteDatFile: Moving to=%s.",TAPIniDir, WARNING);
GotoPath(TAPIniDir); // Go to the Project Directory.
if ( TAP_Hdd_Exist( PLAYDATA_FILENAME ) ) TAP_Hdd_Delete( PLAYDATA_FILENAME ); // Just delete any old copies
appendToLogfile("WriteDatFile: Creating DATA file.", ERR);
TAP_Hdd_Create( PLAYDATA_FILENAME, ATTR_PROGRAM ); // Create the file
appendToLogfile("WriteDatFile: Opening DATA file.", ERR);
writeFile = TAP_Hdd_Fopen( PLAYDATA_FILENAME );
if ( writeFile == NULL ) return; // Check we can open it
appendToLogfile("WriteDatFile: Writing to DATA file.", ERR);
TAP_Hdd_Fwrite( playDataBuffer_ini, PLAYBACKDATA_BUFFER_SIZE_ini, 1, writeFile ); // dump the whole buffer in one hit
appendToLogfile("WriteDatFile: Closing DATA file.", ERR);
TAP_Hdd_Fclose( writeFile );
appendStringToLogfile("WriteDatFile: Returning to=%s.",currentDir, WARNING);
GotoPath(currentDir); // Return to the original directory.
TAP_MemFree( currentDir ); // Free allocated memory.
appendToLogfile("WriteDatFile: Finished.", INFO);
}
void Settings_Save()
{
TYPE_File* fp;
TAP_Hdd_ChangeDir( ".." );
TAP_Hdd_ChangeDir( ".." );
TAP_Hdd_ChangeDir( "ProgramFiles" );
if ( !TAP_Hdd_Exist( "Settings" ) )
TAP_Hdd_Create( "Settings", ATTR_FOLDER );
TAP_Hdd_ChangeDir( "Settings" );
if ( !TAP_Hdd_Exist( settingsFile ) )
TAP_Hdd_Create( settingsFile, ATTR_NORMAL );
if ( fp = TAP_Hdd_Fopen(settingsFile) )
{
int version = INI_VERSION;
int zero[64];
memset( zero, 0, sizeof(zero) );
TAP_Hdd_Fwrite( &version, 1, sizeof(version), fp );
TAP_Hdd_Fwrite( &settings, 1, sizeof(settings), fp );
TAP_Hdd_Fwrite( zero, 1, sizeof(zero), fp );
TAP_Hdd_Fclose( fp );
}
}
void Settings_Load()
{
TYPE_File* fp;
bool validSettings = FALSE;
TAP_Hdd_ChangeDir( ".." );
TAP_Hdd_ChangeDir( ".." );
TAP_Hdd_ChangeDir( "ProgramFiles" );
TAP_Hdd_ChangeDir( "Settings" );
if ( fp = TAP_Hdd_Fopen(settingsFile) )
{
int version = 0;
TAP_Hdd_Fread( &version, 1, sizeof(version), fp );
if ( version == INI_VERSION )
{
TAP_Hdd_Fread( &settings, 1, sizeof(settings), fp );
validSettings = TRUE;
}
TAP_Hdd_Fclose( fp );
}
if ( !validSettings )
{
Settings_Reset();
Settings_Save();
}
}
int TAP_Main(void)
{
char* path = "fileTest.txt";
char line[512];
UFILE *fp;
TYPE_File *tf;
printf("Starting file tester...\r\n");
PrintMem();
initFile(_INFO);
PrintMem();
if (fp = fopen(path, "w"))
{
if (fputs("This is a test message1\n", fp) == EOF)
ShowError();
//TAP_Print("1. File is %d bytes\r\n", TAP_Hdd_Flen(fp->fd));
if (fputs("This is a test message2\n", fp) == EOF)
ShowError();
//TAP_Print("2. File is %d bytes\r\n", TAP_Hdd_Flen(fp->fd));
fclose(fp);
}
PrintMem();
tf = TAP_Hdd_Fopen("fileTest.txt");
TAP_Print("re-opened file is %d bytes\r\n", TAP_Hdd_Flen(tf));
TAP_Hdd_Fclose(tf);
printf("Ending file tester...\r\n");
return 0;
}
bool ReadConfigurationFile( void )
{
TYPE_File *readFile = NULL;
int i = 0;
dword fileLength = 0;
bool schSaveIniFile = FALSE;
GotoPath( SETTINGS_FOLDER );
if ( ! TAP_Hdd_Exist( OPTIONS_FILENAME ) )
{
GotoTapDir();
TAP_Hdd_ChangeDir( PROJECT_DIRECTORY );
if ( ! TAP_Hdd_Exist( OPTIONS_FILENAME ) ) return FALSE;
schSaveIniFile = TRUE;
}
readFile = TAP_Hdd_Fopen( OPTIONS_FILENAME );
if ( readFile == NULL ) return FALSE; // and we can open it ok
dataBuffer_ini = TAP_MemAlloc( DATA_BUFFER_SIZE_ini ); // Read the data in one hit (quicker), then process from RAM
memset( dataBuffer_ini, '\0', DATA_BUFFER_SIZE_ini ); // set the whole buffer to the string termination character (null)
dataBufferPtr_ini = 0;
fileLength = TAP_Hdd_Flen( readFile ); // how big is the file
if ( fileLength > DATA_BUFFER_SIZE_ini ) fileLength = DATA_BUFFER_SIZE_ini; // ensure we don't overflow the buffer
TAP_Hdd_Fread( dataBuffer_ini, fileLength, 1, readFile ); // grab all the data from the file
TAP_Hdd_Fclose( readFile );
if(SetConfigurationVariables() == FALSE)
{
TAP_MemFree( dataBuffer_ini ); // must return the memory back to the heap
SaveConfigurationToFile();
}
else
{
TAP_MemFree( dataBuffer_ini ); // must return the memory back to the heap
}
if(schSaveIniFile == TRUE)
{
SaveConfigurationToFile();
GotoTapDir();
TAP_Hdd_ChangeDir( PROJECT_DIRECTORY );
if ( TAP_Hdd_Exist( OPTIONS_FILENAME ) ) TAP_Hdd_Delete( OPTIONS_FILENAME );
}
return TRUE;
}
//
// Open the logfile.
//
void openLogfile()
{
logByteCount = 0;
// ChangeDirRoot();
// TAP_SystemProc();
// TAP_Hdd_ChangeDir("ProgramFiles");
logFD = TAP_Hdd_Fopen(LOGFILE_NAME);
if (logFD == NULL)
{
// No logfile, so create one.
TAP_Hdd_Create(LOGFILE_NAME, ATTR_NORMAL);
logFD = TAP_Hdd_Fopen(LOGFILE_NAME);
}
if (logFD != NULL)
{
// Go to the end of the file.
TAP_Hdd_Fseek(logFD, 0, 2);
}
}
TYPE_File *HDD_FappendOpen (char *filename)
{
TYPE_File *file;
char buffer[512];
dword pos, blks, i;
char *end;
InitTAPAPIFix();
if (!TAP_Hdd_Exist(filename)) TAP_Hdd_Create(filename, ATTR_NORMAL);
if ((file = TAP_Hdd_Fopen(filename)))
{
if (TAP_Hdd_Fseek(file, 0, SEEK_SET) != 0)
{
TAP_Hdd_Fclose(file);
file = NULL;
}
else
{
pos = 0;
do
{
memset(buffer, 0, sizeof(buffer));
blks = TAP_Hdd_Fread(&buffer, sizeof(buffer), 1, file);
for (i = 0, end = buffer; i < sizeof(buffer); i++)
if (buffer[i] == '\0')
{
end = buffer + i;
break;
}
if (i < sizeof(buffer)) break;
else pos += sizeof(buffer);
}
while (blks == 1);
pos += end - buffer;
if (TAP_Hdd_Fseek(file, pos, SEEK_SET) != pos)
{
TAP_Hdd_Fclose(file);
file = NULL;
}
}
}
return file;
}
//----------------
//
void WriteIniFile( TYPE_File *writeFile )
{
GotoPath(SETTINGS_FOLDER);
if ( TAP_Hdd_Exist( OPTIONS_FILENAME ) ) TAP_Hdd_Delete( OPTIONS_FILENAME ); // Just delete any old copies
TAP_Hdd_Create( OPTIONS_FILENAME, ATTR_PROGRAM ); // Create the file
writeFile = TAP_Hdd_Fopen( OPTIONS_FILENAME );
if ( writeFile == NULL ) return; // Check we can open it
TAP_Hdd_Fwrite( dataBuffer_ini, DATA_BUFFER_SIZE_ini, 1, writeFile ); // dump the whole buffer in one hit
TAP_Hdd_Fclose( writeFile );
}
void LogoManager_ProcessLILAdd(char *AddFileName)
{
TRACEENTER();
TYPE_File *f;
int fs;
char *Text, Line[80];
HDD_TAP_PushDir();
HDD_ChangeDir(LOGOROOT);
INIOpenFile(LILNAME, NULL);
f = TAP_Hdd_Fopen(AddFileName);
if(f)
{
fs = TAP_Hdd_Flen(f);
Text = TAP_MemAlloc(fs+1);
if(Text)
{
TAP_Hdd_Fread(Text, 1, fs, f);
Text[fs] = '\0';
while(*Text)
{
ExtractLine(Text, Line);
if(Line[0] == '0' && Line[1] == 'x' && Line[18] == '=')
{
LowerCase(Line);
Line[18] = '\0';
INISetString(&Line[2], &Line[19]);
}
}
TAP_MemFree(Text);
}
TAP_Hdd_Fclose(f);
}
INISaveFile(LILNAME, INILOCATION_AtCurrentDir, NULL);
INICloseFile();
HDD_TAP_PopDir();
TRACEEXIT();
}
// ------------------------------ SaveBitmap ------------------------------------
//
bool SaveBitmap (char *strName, int width, int height, byte* pBuffer )
{
TYPE_File *pFile;
if( !pBuffer || !strName ) return FALSE;
TAP_Hdd_Create( strName, ATTR_NORMAL );
pFile = TAP_Hdd_Fopen( strName );
if ( !pFile ) return FALSE;
// Write Header
BMP_WriteHeader( pFile, width, height );
// write bitmap data
TAP_Hdd_Fwrite (pBuffer, width*3, height, pFile);
HDD_TouchFile (pFile);
TAP_Hdd_Fclose (pFile);
return TRUE;
}
void tmLogEvent(void)
{
char tmBuffer[TM_EVENT_BUFFER_SIZE];
TYPE_File* fp;
memset (tmBuffer, 0, TM_EVENT_BUFFER_SIZE);
TAP_SPrint( tmBuffer, "%02u:%02u:%02u %02u/%02u/%04u, %3u, %3u, %3u %02u:%02u:%02u %02u/%02u/%04u, %3u, %3u, %3u\r\n", hourLast, minLast, secLast, dayLast, monthLast, yearLast, signalLevelLast, signalQualityLast, timersLast, hour, min, sec, day, month, year, signalLevel, signalQuality, timers);
if (fp = TAP_Hdd_Fopen (TM_FILENAME))
{
TAP_Hdd_Fseek (fp, tmBufferOffset, 0);
TAP_Hdd_Fwrite (tmBuffer, 1, strlen(tmBuffer), fp);
TAP_Hdd_Fclose (fp);
tmBufferOffset += strlen(tmBuffer);
tmNumberOfEvents++;
if (tmBufferOffset >= (TM_FILE_MAX_LENGTH - TM_EVENT_BUFFER_SIZE))
{
ShowMessageWin("Log File Full","Exiting!");
TAP_Exit();
return;
}
}
else
{
ShowMessageWin("Error! - Unable to open file","Exiting!");
TAP_Exit();
return;
}
}
bool ReadDatFile( void )
{
TYPE_File *readFile;
int i;
dword fileLength;
appendToLogfile("ReadDatFile: Started.", INFO);
GotoPath( TAPIniDir );
if ( ! TAP_Hdd_Exist( PLAYDATA_FILENAME ) )
{
appendToLogfile("ReadDatFile: no PLAYDATA file found.", ERR);
return FALSE; // check the ini file exits in the current directory
}
readFile = TAP_Hdd_Fopen( PLAYDATA_FILENAME );
if ( readFile == NULL ) return FALSE; // and we can open it ok
playDataBuffer_ini = TAP_MemAlloc( PLAYBACKDATA_BUFFER_SIZE_ini ); // Read the data in one hit (quicker), then process from RAM
memset( playDataBuffer_ini, '\0', PLAYBACKDATA_BUFFER_SIZE_ini ); // set the whole buffer to the string termination character (null)
playDataBufferPtr_ini = 0;
fileLength = TAP_Hdd_Flen( readFile ); // how big is the file
if ( fileLength > PLAYBACKDATA_BUFFER_SIZE_ini ) fileLength = PLAYBACKDATA_BUFFER_SIZE_ini; // ensure we don't overflow the buffer
TAP_Hdd_Fread( playDataBuffer_ini, fileLength, 1, readFile ); // grab all the data from the file
TAP_Hdd_Fclose( readFile );
SetDatVariables();
TAP_MemFree( playDataBuffer_ini ); // must return the memory back to the heap
appendToLogfile("ReadDatFile: Finished.", INFO);
return TRUE;
}
//------------
//
void ReadLogoFile()
{
TYPE_File *logoFile;
TYPE_logoArray *logoPointer;
dword dataSize;
byte *junkBuffer;
char channelName[CHANNEL_NAME_SIZE];
int i; //+++
// TAP_Hdd_ChangeDir("UK TAP Project");
GotoPath( TAPIniDir );
if ( ! TAP_Hdd_Exist( "logo.dat" ) ) return; // check our logo file exits in the current directory
logoFile = TAP_Hdd_Fopen( "logo.dat" );
if ( logoFile == NULL ) return; // and we can open it ok
junkBuffer = TAP_MemAlloc(LOGO_DATA_SIZE); // create a place to read in unwanted logos
while ( TAP_Hdd_Ftell( logoFile ) < TAP_Hdd_Flen( logoFile ) ) // Keep reading logos until we reach the end of file
{
TAP_Hdd_Fread( channelName, CHANNEL_NAME_SIZE, 1, logoFile ); // read the channel name
if ( findChannelPointer( channelName, &logoPointer ) ) // cross referece the array to find this entry
{ // if the channel exists ->
TAP_Hdd_Fread( logoPointer->logo, LOGO_DATA_SIZE, 1, logoFile ); // read the logo bitmap
logoPointer->processedFlag = TRUE; // mark this channel as having a logo in the cache
}
else
{ // else channel doesn't appear in service list ->
TAP_Hdd_Fread( junkBuffer, LOGO_DATA_SIZE, 1, logoFile ); // must read the logo, otherwise read pointer will get stuck
}
}
TAP_Hdd_Fclose( logoFile );
// TAP_Hdd_ChangeDir(".."); // return to original directory
TAP_MemFree( junkBuffer );
}
void LogEntryGeneric(char *ProgramName, bool Console, char *Text)
{
TRACEENTER();
char *s;
int l;
TYPE_File *File;
char TimeResult[40];
char CRLF[] = {'\r', '\n'};
byte Sec;
byte *ISOText;
#define FILENAME "TAPSystem.log"
if(!ProgramName || !Text)
{
TRACEEXIT();
return;
}
HDD_TAP_PushDir();
if(!HDD_ChangeDir("/ProgramFiles/Settings"))
{
HDD_ChangeDir("/ProgramFiles");
if(!TAP_Hdd_Exist("Settings")) TAP_Hdd_Create("Settings", ATTR_FOLDER);
HDD_ChangeDir("Settings");
}
l = strlen(ProgramName) + strlen(Text) + 4;
s = TAP_MemAlloc(l);
if(s)
{
memset(s, 0, l);
TAP_SPrint(s, "%s: %s", ProgramName, Text);
StrToISOAlloc(s, &ISOText);
if(ISOText)
{
TimeFormat(Now(&Sec), Sec, TIMESTAMP_YMDHMS, TimeResult);
strcat(TimeResult, " ");
if(!TAP_Hdd_Exist(FILENAME)) TAP_Hdd_Create(FILENAME, ATTR_NORMAL);
if((File = TAP_Hdd_Fopen(FILENAME)) != NULL)
{
TAP_Hdd_Fseek(File, 0, SEEK_END);
TAP_Hdd_Fwrite(TimeResult, strlen(TimeResult), 1, File);
TAP_Hdd_Fwrite(ISOText, strlen(ISOText), 1, File);
TAP_Hdd_Fwrite(CRLF, 2, 1, File);
TAP_Hdd_Fclose(File);
}
if(Console)
{
TAP_PrintNet("%s%s\n", TimeResult, ISOText);
}
TAP_MemFree(ISOText);
}
TAP_MemFree(s);
}
HDD_TAP_PopDir();
TRACEEXIT();
}
/*
returns a pointer to the open file. A null pointer value indicates an error
The character string mode specifies the type of access requested for the file, as follows:
"r"
Opens for reading. If the file does not exist or cannot be found, the fopen call fails.
"w"
Opens an empty file for writing. If the given file exists, its contents are destroyed.
*/
UFILE* fopen(char* name, char* mode)
{
#ifdef _WIN32
int fd;
#else
TYPE_File *fd;
#endif
UFILE *fp;
//printf("Opening file %s for %c\n", name, *mode);
//dumpBuffer();
if (*mode != 'r' && *mode != 'w' && *mode != 'a') {
return NULL;
}
for (fp = _iob; fp < _iob + OPEN_MAX; fp++)
if ((fp->flag & (_READ | _WRITE)) == 0)
break; /* found free slot */
if (fp >= _iob + OPEN_MAX) { /* no free slots */
return NULL;
}
#ifdef _WIN32
if (*mode == 'w')
fd = creat(name, 0666);
else if (*mode == 'a') {
if ((fd = open(name, O_WRONLY, 0)) == -1)
fd = creat(name, 0666);
lseek(fd, 0L, 2L);
} else
fd = open(name, O_RDONLY, 0);
if (fd == -1) {
return NULL;
}
#else
if (*mode == 'w')
TAP_Hdd_Create(name, ATTR_NORMAL); //TAP_Hdd_Delete(name);
else if (*mode == 'a')
if (!TAP_Hdd_Exist(name))
TAP_Hdd_Create(name, ATTR_NORMAL);
fd = TAP_Hdd_Fopen( name );
if (fd == 0) { /* couldn't access name */
return NULL;
}
if (*mode == 'a')
TAP_Hdd_Fseek(fd, 0L, 2L);
#endif
fp->fd = fd;
fp->cnt = 0;
fp->size = 0;
fp->base = NULL;
fp->flag = (*mode == 'r') ? _READ : _WRITE;
#ifdef _TAP
fp->size = TAP_Hdd_Flen(fd);
//TAP_Print("file size: %d\r\n", fp->size);
//fp->flag |= _UNBUF; //
#endif
//dumpBuffer();
return fp;
}
void LogoManager_LogoCacheRebuild(void)
{
TRACEENTER();
char ID[4];
dword Version;
TYPE_File *f, *fLogo;
int i, j, k, NrFiles;
TYPE_FolderEntry FolderEntry;
dword LogoIndex;
byte *PixelData, *TempBuffer;
dword BufferSize, CompressedSize;
TYPE_GrData *grData;
int LogosConverted;
char LogoPath[FBLIB_DIR_SIZE];
if(LogoManager_CB) LogoManager_CB(2, -1);
//Step 1: Kill the current cache
HDD_TAP_PushDir();
HDD_ChangeDir(LOGOROOT);
TAP_Hdd_Delete(LOGOCACHE);
//Step 2: iterate through all directories and count the number of logos
LogoManager_NrLogos = 0;
for(i = LGST_3pgstyle; i < LGST_NRITEMS; i++)
{
for(j = LGAR_43; j < LGAR_NRITEMS; j++)
{
if(HDD_ChangeDir(LogoManager_GetDirectory(i, j, LogoPath)))
{
NrFiles = TAP_Hdd_FindFirst(&FolderEntry, "qtl|qsl|ibl");
for(k = 0; k < NrFiles; k++)
{
if(FolderEntry.attr == ATTR_NORMAL)
{
FixInvalidFileName(FolderEntry.name);
LogoManager_NrLogos++;
}
TAP_Hdd_FindNext(&FolderEntry);
}
}
}
}
if(LogoManager_CB) LogoManager_CB(3, LogoManager_NrLogos);
//Step 3: build the basic cache file
LogosConverted = 0;
if(LogoManager_LogoData) TAP_MemFree(LogoManager_LogoData);
LogoManager_LogoData = TAP_MemAlloc(LogoManager_NrLogos * sizeof(tLogoData));
if(LogoManager_LogoData)
{
memset(LogoManager_LogoData, 0, LogoManager_NrLogos * sizeof(tLogoData));
HDD_ChangeDir(LOGOROOT);
if(!TAP_Hdd_Exist(LOGOCACHE)) TAP_Hdd_Create(LOGOCACHE, ATTR_NORMAL);
f = TAP_Hdd_Fopen(LOGOCACHE);
if(f)
{
strcpy(ID, LOGOCACHEID);
Version = LOGOCACHEVERSION;
TAP_Hdd_Fwrite(ID, 4, 1, f);
TAP_Hdd_Fwrite(&Version, sizeof(dword), 1, f);
TAP_Hdd_Fwrite(&LogoManager_NrLogos, sizeof(dword), 1, f);
TAP_Hdd_Fwrite(LogoManager_LogoData, sizeof(tLogoData), LogoManager_NrLogos, f);
//Step 4: iterate through all directories again, compress the data and save it to the cache
LogoIndex = 0;
for(i = LGST_3pgstyle; i < LGST_NRITEMS; i++)
{
for(j = LGAR_43; j < LGAR_NRITEMS; j++)
{
if(HDD_ChangeDir(LogoManager_GetDirectory(i, j, LogoPath)))
{
NrFiles = TAP_Hdd_FindFirst(&FolderEntry, "qtl|qsl|ibl");
for(k = 0; k < NrFiles; k++)
{
if(LogoManager_CB) LogoManager_CB(2, LogosConverted * 100 / LogoManager_NrLogos);
if(FolderEntry.attr == ATTR_NORMAL)
{
LogoManager_LogoData[LogoIndex].ChannelID = 0;
strncpy(LogoManager_LogoData[LogoIndex].LogoName, FolderEntry.name, MAXLOGONAME);
LogoManager_LogoData[LogoIndex].LogoName[MAXLOGONAME] = '\0';
LogoManager_LogoData[LogoIndex].LogoName[strlen(LogoManager_LogoData[LogoIndex].LogoName) - 4] = '\0';
LogoManager_LogoData[LogoIndex].Style = i;
if(StringEndsWith(FolderEntry.name, ".qtl")) LogoManager_LogoData[LogoIndex].Size = LGSZ_qtl;
if(StringEndsWith(FolderEntry.name, ".qsl")) LogoManager_LogoData[LogoIndex].Size = LGSZ_qsl;
if(StringEndsWith(FolderEntry.name, ".ibl")) LogoManager_LogoData[LogoIndex].Size = LGSZ_ibl;
LogoManager_LogoData[LogoIndex].Aspect = j;
LogoManager_LogoData[LogoIndex].grData = NULL;
fLogo = TAP_Hdd_Fopen(FolderEntry.name);
if(fLogo)
{
BufferSize = TAP_Hdd_Flen(fLogo) - 8;
PixelData = TAP_MemAlloc(BufferSize + 8);
TempBuffer = TAP_MemAlloc(sizeof(TYPE_GrData) + BufferSize);
if(PixelData && TempBuffer)
{
TAP_Hdd_Fread(PixelData, BufferSize + 8, 1, fLogo);
CompressedSize = CompressTFD(&PixelData[8], BufferSize, &TempBuffer[sizeof(TYPE_GrData)], 0x0001, 0xffff, NULL);
TAP_Put16bit(&TempBuffer[sizeof(TYPE_GrData) + 0x0e], 0xffff);
grData = (TYPE_GrData*)TempBuffer;
grData->version = 1;
grData->reserved = 0;
grData->dataFormat = OSD_1555;
grData->compessMethod = COMPRESS_Tfp;
grData->data = NULL;
grData->dataSize = BufferSize;
grData->width = TAP_Get32bit(&PixelData[0]);
grData->height = TAP_Get32bit(&PixelData[4]);
LogoManager_LogoData[LogoIndex].CachePosition = TAP_Hdd_Ftell(f);
LogoManager_LogoData[LogoIndex].grDataSize = sizeof(TYPE_GrData) + CompressedSize;
TAP_Hdd_Fwrite(grData, LogoManager_LogoData[LogoIndex].grDataSize, 1, f);
LogoIndex++;
}
if(PixelData) TAP_MemFree(PixelData);
if(TempBuffer) TAP_MemFree(TempBuffer);
TAP_Hdd_Fclose(fLogo);
}
else
{
if(LogoManager_CB) LogoManager_CB(-1, 2);
}
LogosConverted++;
}
TAP_Hdd_FindNext(&FolderEntry);
}
}
}
}
//Step 5: if the LIL exists, read and update the ChannelID of all Logos
//Step 6: rewrite the cache structure to update all pointers
TAP_Hdd_Fseek(f, sizeof(ID) + sizeof(dword) + sizeof(dword), SEEK_SET);
TAP_Hdd_Fwrite(LogoManager_LogoData, sizeof(tLogoData), LogoManager_NrLogos, f);
TAP_Hdd_Fclose(f);
}
}
HDD_TAP_PopDir();
if(LogoManager_CB) LogoManager_CB(4, 0);
TRACEEXIT();
}
void tmInitialise(void)
{
char tmBuffer[TM_FILE_BLOCK_SIZE];
char hddBuffer[1];
byte i;
TYPE_File* fp;
memset (tmBuffer, 0, TM_FILE_BLOCK_SIZE);
if (!TAP_Hdd_Exist (TM_FILENAME))
{
TAP_Hdd_Create (TM_FILENAME, ATTR_NORMAL);
if (fp = TAP_Hdd_Fopen (TM_FILENAME))
{
for (i = 0; i < TM_FILE_MAX_LENGTH / TM_FILE_BLOCK_SIZE; i++)
{
TAP_Hdd_Fwrite (tmBuffer, 1, TM_FILE_BLOCK_SIZE, fp);
}
TAP_Hdd_Fseek (fp, 0, 0);
TAP_Hdd_Fwrite (TM_INFO, 1, sizeof(TM_INFO), fp);
tmBufferOffset = sizeof(TM_INFO) - 1;
tmNumberOfEvents = 0;
TAP_Hdd_Fclose (fp);
}
}
else
{
if (fp = TAP_Hdd_Fopen (TM_FILENAME))
{
tmBufferOffset = 0;
tmExitFL = FALSE;
while
(
(tmExitFL == FALSE)
&&
(tmBufferOffset < TM_FILE_MAX_LENGTH)
)
{
TAP_Hdd_Fseek (fp, tmBufferOffset, 0);
TAP_Hdd_Fread (hddBuffer, 1, 1, fp);
if(hddBuffer[0] != 0)
{
tmBufferOffset++;
if(hddBuffer[0] == 0x0A)
{
tmNumberOfEvents++;
}
}
else
{
tmExitFL = TRUE;
}
}
tmNumberOfEvents -= 2;
TAP_Hdd_Fclose (fp);
if (tmBufferOffset >= (TM_FILE_MAX_LENGTH - TM_EVENT_BUFFER_SIZE))
{
ShowMessageWin("Log File Full","Exiting!");
TAP_Exit();
return;
}
}
}
ShowMessageWin("Time Monitor Tap v1.0","Started");
}
int LogoManager_UpdateLIL(void)
{
TRACEENTER();
typedef struct
{
ulong64 ChannelID;
char Name[MAXLOGONAME+1];
}tNewIDs;
int nTvSvc, nRadioSvc;
int i;
TYPE_TapChInfo chInfo;
char s[255], LogoName[MAX_SvcName + 1];
SYSTEM_TYPE SystemType;
tFlashSatTable SatInfo;
word SatPos;
ulong64 ChannelID;
tNewIDs *NewIDs;
int NewIDCount;
SystemType = GetSystemType();
HDD_TAP_PushDir();
HDD_ChangeDir(LOGOROOT);
TAP_Channel_GetTotalNum(&nTvSvc, &nRadioSvc);
NewIDs = TAP_MemAlloc((nTvSvc + nRadioSvc) * sizeof(tNewIDs));
NewIDCount = 0;
INIOpenFile(LILNAME, NULL);
for(i = 0; i < nTvSvc; i++)
{
TAP_Channel_GetInfo(SVC_TYPE_Tv, i, &chInfo);
FlashSatTablesGetInfo(chInfo.satIdx, &SatInfo);
switch(SystemType)
{
case ST_S:
case ST_TMSS:
{
SatPos = SatInfo.SatPosition;
break;
}
default:
SatPos = 0;
break;
}
ChannelID = LogoManager_CalculateChannelID(SatPos, chInfo.orgNetId, chInfo.tsId, chInfo.svcId);
TAP_SPrint(s, "%16.16llx", ChannelID);
if(!INIKeyExists(s))
{
NewIDs[NewIDCount].ChannelID = ChannelID;
strcpy(NewIDs[NewIDCount].Name, LogoManager_ChannelNameToLogoName(chInfo.chName, LogoName, sizeof(LogoName)));
if(NewIDs[NewIDCount].Name[0]) NewIDCount++;
}
}
for(i = 0; i < nRadioSvc; i++)
{
TAP_Channel_GetInfo(SVC_TYPE_Radio, i, &chInfo);
FlashSatTablesGetInfo(chInfo.satIdx, &SatInfo);
switch(SystemType)
{
case ST_S:
case ST_TMSS:
{
SatPos = SatInfo.SatPosition;
break;
}
default:
SatPos = 0;
break;
}
ChannelID = LogoManager_CalculateChannelID(SatPos, chInfo.orgNetId, chInfo.tsId, chInfo.svcId);
TAP_SPrint(s, "%16.16llx", ChannelID);
if(!INIKeyExists(s))
{
NewIDs[NewIDCount].ChannelID = ChannelID;
TAP_SPrint(NewIDs[NewIDCount].Name, "r_%s", LogoManager_ChannelNameToLogoName(chInfo.chName, LogoName, sizeof(LogoName)));
if(NewIDs[NewIDCount].Name[0]) NewIDCount++;
}
}
INICloseFile();
if(NewIDCount > 0)
{
TYPE_File *f;
word year;
byte month, day, weekDay;
if(!TAP_Hdd_Exist(LILNAME)) TAP_Hdd_Create(LILNAME, ATTR_NORMAL);
f = TAP_Hdd_Fopen(LILNAME);
if(!f)
{
HDD_TAP_PopDir();
if(LogoManager_CB) LogoManager_CB(-1, 3);
TRACEEXIT();
return -1;
}
TAP_Hdd_Fseek(f, 0, SEEK_END);
TAP_ExtractMjd(Now(NULL) >> 16, &year, &month, &day, &weekDay);
TAP_SPrint(s, "\n\n# Added %4.4d-%2.2d-%2.2d\n", year, month, day);
TAP_Hdd_Fwrite(s, 1, strlen(s), f);
for(i = 0; i < NewIDCount; i++)
{
TAP_SPrint(s, "%16.16llx=%s\n", NewIDs[i].ChannelID, NewIDs[i].Name);
TAP_Hdd_Fwrite(s, 1, strlen(s), f);
}
TAP_Hdd_Fclose(f);
if(LogoManager_CB) LogoManager_CB(5, NewIDCount);
}
void AutoStartPage::PopulateList()
{
m_taps.clear();
// Get a list of TAPs in the current Auto Start
TAP_Hdd_ChangeDir( autoStartPath );
TYPE_File file;
int index = 0;
for ( dword totalEntry = TAP_Hdd_FindFirst( &file ); totalEntry > 0; )
{
if ( file.attr == ATTR_NORMAL )
{
char* ext = strrchr(file.name, '.');
if ( ext )
{
// ensure we're only looking at .tap files
++ext;
bool enabled = stricmp( ext, "tap" ) == 0;
if ( enabled || stricmp( ext, "nap" ) == 0 )
{
// that we can open
TYPE_File* f = TAP_Hdd_Fopen( file.name );
if ( f )
{
// read the TAP header
tTAPHeader header;
memset( &header, 0, sizeof(header) );
TAP_Hdd_Fread( &header, sizeof(header), 1, f );
TAP_Hdd_Fclose( f );
// ensure that it's actually a TAP format file
if ( strncmp( header.Signature, "TFAPMIPS", 8 ) == 0 )
{
m_taps.push_back(AutoStartTAP());
AutoStartTAP& t = m_taps.back();
// store the filename with the extension .tap in the order array
*ext = 't';
t.index = index;
t.filename = file.name;
t.enabled = enabled;
t.id = header.TAPID;
t.name = header.Name;
// and generate the text that will be shown in the footer
t.footer.format( "%s\n%s\n%s\n", header.Description, header.AuthorName, header.EtcStr );
++index;
}
}
}
}
}
dword currentEntry = TAP_Hdd_FindNext( &file );
if ( totalEntry == currentEntry || currentEntry == 0 )
break;
}
// Remove the Loading message and redraw the window contents
DiscardItems();
for (unsigned int i=0; i < m_taps.size(); ++i)
AddItem(new TAPListItem(this, i));
AddItem(new FooterActionListItem(this, &Commit, "Press OK to save the new TAP order\nTAPs will be loaded in this order next time the unit wakes from standby", 0, "", "Save Changes"));
AddItem(new FooterActionListItem(this, &Backup, "Press OK to backup the TAP order and enabled state as listed above", 0, "", "Backup"));
AddItem(new FooterActionListItem(this, &Restore, "Press OK to restore the previous backup to the list above\nThis does not save changes to disk", 0, "", "Restore"));
Draw();
}
TYPE_File *HDD_FappendOpen(char *FileName)
{
TRACEENTER();
TYPE_File *file;
char buffer[512];
dword pos, blks, i;
char *end;
char TAPPath[FBLIB_DIR_SIZE], Name[FBLIB_DIR_SIZE];
if(!FileName || !*FileName)
{
TRACEEXIT();
return NULL;
}
ConvertPathType(FileName, TAPPath, PF_TAPPathOnly);
ConvertPathType(FileName, Name, PF_FileNameOnly);
HDD_TAP_PushDir();
if(*TAPPath) HDD_ChangeDir(TAPPath);
if(!TAP_Hdd_Exist(Name)) TAP_Hdd_Create(Name, ATTR_NORMAL);
if((file = TAP_Hdd_Fopen(Name)))
{
if(TAP_Hdd_Fseek(file, 0, SEEK_SET) != 0)
{
TAP_Hdd_Fclose(file);
file = NULL;
}
else
{
pos = 0;
do
{
memset(buffer, 0, sizeof(buffer));
blks = TAP_Hdd_Fread(&buffer, sizeof(buffer), 1, file);
for(i = 0, end = buffer; i < sizeof(buffer); i++)
if(buffer[i] == '\0')
{
end = buffer + i;
break;
}
if(i < sizeof(buffer)) break;
else pos += sizeof(buffer);
}
while(blks == 1);
pos += end - buffer;
if(TAP_Hdd_Fseek(file, pos, SEEK_SET) != pos)
{
TAP_Hdd_Fclose(file);
file = NULL;
}
}
}
HDD_TAP_PopDir();
TRACEEXIT();
return file;
}
