char* FindTapDir()
{
TYPE_File fp;
if ( _tapDirPtr != NULL )
return _tapDirPtr;
TAP_Hdd_ChangeDir("..");
TAP_Hdd_FindFirst( &fp );
// TAP_Print("Tapdir: fp.name = %s\r\n", fp.name);
if ( strcmp( fp.name, "__ROOT__" ) == 0 )
{
strcpy(_tapDir, "/ProgramFiles");
TAP_Hdd_ChangeDir("ProgramFiles");
} else {
strcpy(_tapDir, "/ProgramFiles/Auto Start");
TAP_Hdd_ChangeDir("Auto Start");
}
_tapDirPtr = _tapDir;
// TAP_Print("Tapdir: _tapDirPtr = %s\r\n", _tapDirPtr);
return _tapDirPtr;
}
//------------------------------ ChangeDirRoot --------------------------------------
//
void ChangeDirRoot()
{
TYPE_File fp;
int iNdx;
iNdx = 0;
TAP_Hdd_FindFirst( &fp );
// Loop until Root found allow maximum of 20 levels
while ( ( strcmp( fp.name, "__ROOT__" ) != 0 ) && ( iNdx < 20 ) )
{
TAP_Hdd_ChangeDir( ".." );
TAP_Hdd_FindFirst( &fp );
}
}
bool CurrentDirStartCluster (dword* cluster)
{
TYPE_File file;
// '.' should be the first entry, so find it
memset (&file, 0, sizeof (file));
if (TAP_Hdd_FindFirst (&file))
{
while (strcmp (file.name, ".") && TAP_Hdd_FindNext (&file)) {};
}
// return starting cluster of this directory
*cluster = file.startCluster;
return (strcmp (file.name, ".") == 0);
}
void schMoveService(void)
{
char logBuffer[LOG_BUFFER_SIZE];
char fileStr[200];
char folderStr[200];
static char schMoveActualFileName[128];
static char schMoveNewFileName[128];
int fileNumber = 0;
char fileNumberStr[10];
int totalFileCount = 0, i = 0;
TYPE_PlayInfo CurrentPlaybackInfo;
char playInfoOverRun[512];
TYPE_RecInfo CurrentRecordInfo0;
char rec0InfoOverRun[512];
TYPE_RecInfo CurrentRecordInfo1;
char rec1InfoOverRun[512];
char CurrentPlaybackFileName[TS_FILE_NAME_SIZE];
char CurrentRecord0FileName[SCH_REC_FILE_NAME_SIZE];
char CurrentRecord1FileName[SCH_REC_FILE_NAME_SIZE];
bool schFileFound = FALSE;
static TYPE_File tempFile;
static dword schMoveCurrentTime = 0;
static byte schMoveIndex = 0;
static bool schMoveExpired = FALSE;
static bool schMoveSuccessful = FALSE;
static bool moveFailed = FALSE;
int result = 0;
bool schMoveResult = FALSE;
dword moveStartTimeInMins = 0, fileStartTimeInMins = 0;
char buffer1[256];
switch(schMoveServiceSV)
{
/*--------------------------------------------------*/
case SCH_MOVE_SERVICE_INITIALISE:
if(schFileRetreiveMoveData() > 0)
{
}
else
{
}
schMoveServiceSV = SCH_MOVE_SERVICE_WAIT_TO_CHECK;
break;
/*--------------------------------------------------*/
case SCH_MOVE_SERVICE_WAIT_TO_CHECK:
if
(
(schTimeSec == 40)
&&
(schMainTotalValidMoves > 0)
&&
(schStartUpCounter > SCH_MAIN_DELAY_MOVE_ALARM)
&&
(schKeepServiceSV == SCH_KEEP_SERVICE_WAIT_TO_CHECK)
)
{
schMoveIndex = schMainTotalValidMoves - 1;
schMoveCurrentTime = (schTimeMjd << 16) + (schTimeHour << 8) + schTimeMin;
schMoveExpired = FALSE;
moveFailed = FALSE;
schMoveServiceSV = SCH_MOVE_SERVICE_CHECK_MOVE;
}
break;
/*--------------------------------------------------*/
case SCH_MOVE_SERVICE_CHECK_MOVE:
if (schMoveCurrentTime >= schMoveData[schMoveIndex].moveEndTime)
{
schMoveSuccessful = FALSE;
schMoveServiceSV = SCH_MOVE_SERVICE_CHECK_ARCHIVE;
}
else
{
schMoveServiceSV = SCH_MOVE_SERVICE_NEXT_MOVE;
}
break;
/*--------------------------------------------------*/
case SCH_MOVE_SERVICE_CHECK_ARCHIVE:
memset(schMoveActualFileName, 0 , sizeof(schMoveActualFileName));
if(GotoDataFiles() == TRUE)
{
moveStartTimeInMins = schMainConvertTimeToMins(schMoveData[schMoveIndex].moveStartTime);
totalFileCount = TAP_Hdd_FindFirst(&tempFile);
schFileFound = FALSE;
for ( i=1; ((i <= totalFileCount) && (schFileFound == FALSE)) ; i++ )
{
fileStartTimeInMins = (tempFile.mjd * 24 * 60) + (tempFile.hour * 60) + tempFile.min;
if
(
((moveStartTimeInMins - 1) <= fileStartTimeInMins)
&&
(tempFile.attr == ATTR_TS)
&&
(strlen(schMoveData[schMoveIndex].moveFileName) > 4)
&&
(strncmp(tempFile.name, schMoveData[schMoveIndex].moveFileName, (strlen(schMoveData[schMoveIndex].moveFileName) - 4)) == 0)
)
{
strcpy(schMoveActualFileName, tempFile.name);
schFileFound = TRUE;
}
else
{
TAP_Hdd_FindNext(&tempFile);
}
}
if(schFileFound == TRUE)
{
schMoveServiceSV = SCH_MOVE_SERVICE_CHECK_TARGET_FOLDER;
}
else
{
schMoveServiceSV = SCH_MOVE_SERVICE_MOVE_NOT_SUCCESSFUL;
}
}
else
{
schMoveServiceSV = SCH_MOVE_SERVICE_MOVE_NOT_SUCCESSFUL;
}
break;
/*--------------------------------------------------*/
case SCH_MOVE_SERVICE_CHECK_TARGET_FOLDER:
memset(schMoveNewFileName, 0 , sizeof(schMoveNewFileName));
sprintf( folderStr, "DataFiles/%s", schMoveData[schMoveIndex].moveFolder );
if(GotoPath(folderStr) == TRUE)
{
if (TAP_Hdd_Exist( schMoveActualFileName ) == FALSE)
{
schMoveServiceSV = SCH_MOVE_SERVICE_PERFORM_MOVE;
}
else
{
fileNumber = 2;
sprintf(fileNumberStr, "-%d", fileNumber);
if(strlen(schMoveActualFileName) > 4)
{
strncpy(schMoveNewFileName, schMoveActualFileName,(strlen(schMoveActualFileName) - 4));
strcat(schMoveNewFileName, fileNumberStr);
strcat(schMoveNewFileName, ".rec");
while
(
(TAP_Hdd_Exist( schMoveNewFileName ) == TRUE)
&&
(fileNumber < 100)
)
{
fileNumber++;
memset(fileNumberStr, 0 , sizeof(fileNumberStr));
sprintf(fileNumberStr, "-%d", fileNumber);
memset(schMoveNewFileName, 0 , sizeof(schMoveNewFileName));
strncpy(schMoveNewFileName, schMoveActualFileName,(strlen(schMoveActualFileName) - 4));
strcat(schMoveNewFileName, fileNumberStr);
strcat(schMoveNewFileName, ".rec");
}
}
else
{
fileNumber = 100;
}
if(fileNumber < 100)
{
schMoveServiceSV = SCH_MOVE_SERVICE_PERFORM_MOVE;
}
else
{
schMoveServiceSV = SCH_MOVE_SERVICE_MOVE_NOT_SUCCESSFUL;
}
}
}
else
{
schMoveServiceSV = SCH_MOVE_SERVICE_MOVE_NOT_SUCCESSFUL;
}
break;
/*--------------------------------------------------*/
case SCH_MOVE_SERVICE_PERFORM_MOVE:
schMoveSuccessful = FALSE;
if(GotoDataFiles() == TRUE)
{
TAP_Hdd_GetPlayInfo (&CurrentPlaybackInfo);
TAP_Hdd_GetRecInfo (0, &CurrentRecordInfo0);
TAP_Hdd_GetRecInfo (1, &CurrentRecordInfo1);
memset(CurrentPlaybackFileName,0,TS_FILE_NAME_SIZE);
if(CurrentPlaybackInfo.playMode == PLAYMODE_Playing)
{
strcpy(CurrentPlaybackFileName,CurrentPlaybackInfo.file->name);
}
memset(CurrentRecord0FileName,0,SCH_REC_FILE_NAME_SIZE);
if
(
(CurrentRecordInfo0.recType == RECTYPE_Normal)
&&
(schMoveData[schMoveIndex].moveStartTime == CurrentRecordInfo0.startTime)
)
{
strcpy(CurrentRecord0FileName,CurrentRecordInfo0.fileName);
}
memset(CurrentRecord1FileName,0,SCH_REC_FILE_NAME_SIZE);
if
(
(CurrentRecordInfo1.recType == RECTYPE_Normal)
&&
(schMoveData[schMoveIndex].moveStartTime == CurrentRecordInfo1.startTime)
)
{
strcpy(CurrentRecord1FileName,CurrentRecordInfo1.fileName);
}
if
(
(strcmp(CurrentPlaybackFileName, schMoveActualFileName) != 0)
&&
(strcmp(CurrentRecord0FileName, schMoveActualFileName) != 0)
&&
(strcmp(CurrentRecord1FileName, schMoveActualFileName) != 0)
)
{
if(strlen(schMoveNewFileName) > 0)
{
if(TAP_Hdd_Rename(schMoveActualFileName, schMoveNewFileName) == TRUE)
{
memset(schMoveActualFileName, 0 , sizeof(schMoveActualFileName));
strcpy(schMoveActualFileName, schMoveNewFileName);
}
}
sprintf( folderStr, "/DataFiles/%s", schMoveData[schMoveIndex].moveFolder );
#ifndef WIN32
if(schMainApiMoveAvailable == TRUE)
{
schMoveResult = TAP_Hdd_ApiMove( "/DataFiles", folderStr, schMoveActualFileName );
}
else if(schMainDebugMoveAvailable == TRUE)
{
sprintf( fileStr, "/DataFiles/%s", schMoveActualFileName );
schMoveResult = TAP_Hdd_DebugMove( fileStr, folderStr );
}
else
{
}
#else
schMoveResult = TRUE; // For the SDK
#endif
if(schMoveResult == TRUE)
{
schMoveSuccessful = TRUE;
schMoveData[schMoveIndex].moveEnabled = FALSE;
schMoveExpired = TRUE; // Delete this move when all moves checked
}
}
}
if(schMoveSuccessful == TRUE)
{
schMoveServiceSV = SCH_MOVE_SERVICE_NEXT_MOVE;
}
else
{
schMoveServiceSV = SCH_MOVE_SERVICE_MOVE_NOT_SUCCESSFUL;
}
break;
/*--------------------------------------------------*/
case SCH_MOVE_SERVICE_MOVE_NOT_SUCCESSFUL:
schMoveData[schMoveIndex].moveFailedCount++;
if(schMoveData[schMoveIndex].moveFailedCount >= 3)
{
schMoveData[schMoveIndex].moveEnabled = FALSE;
schMoveExpired = TRUE; // Delete this move when all moves checked
moveFailed = TRUE;
// memset(logBuffer,0,LOG_BUFFER_SIZE);
// sprintf( logBuffer, "Failed (Move to be deleted): %s Count: %d", schMoveData[schMoveIndex].moveFileName, schMoveData[schMoveIndex].moveFailedCount );
// logStoreEvent(logBuffer);
}
else
{
// memset(logBuffer,0,LOG_BUFFER_SIZE);
// sprintf( logBuffer, "Failed: %s Count: %d", schMoveData[schMoveIndex].moveFileName, schMoveData[schMoveIndex].moveFailedCount );
// logStoreEvent(logBuffer);
}
schMoveServiceSV = SCH_MOVE_SERVICE_NEXT_MOVE;
break;
/*--------------------------------------------------*/
case SCH_MOVE_SERVICE_NEXT_MOVE:
if(schMoveIndex > 0)
{
schMoveIndex--;
schMoveServiceSV = SCH_MOVE_SERVICE_CHECK_MOVE;
}
else
{
if(schMoveExpired == TRUE)
{
schMoveServiceSV = SCH_MOVE_SERVICE_DELETE_EXPIRED_MOVES;
}
else
{
schMoveServiceSV = SCH_MOVE_SERVICE_COMPLETE;
}
}
break;
/*--------------------------------------------------*/
case SCH_MOVE_SERVICE_DELETE_EXPIRED_MOVES:
schWriteMoveList();
// memset(logBuffer,0,LOG_BUFFER_SIZE);
// sprintf( logBuffer, "Move list updated" );
// logStoreEvent(logBuffer);
if (moveFailed == FALSE)
{
schMoveServiceSV = SCH_MOVE_SERVICE_COMPLETE;
}
else
{
schMoveServiceSV = SCH_MOVE_LOG_ARCHIVE;
}
break;
/*--------------------------------------------------*/
case SCH_MOVE_LOG_ARCHIVE:
logArchive();
schMoveServiceSV = SCH_MOVE_SERVICE_COMPLETE;
break;
/*--------------------------------------------------*/
case SCH_MOVE_SERVICE_COMPLETE:
if(schTimeSec != 40)
{
schMoveServiceSV = SCH_MOVE_SERVICE_WAIT_TO_CHECK;
}
break;
/*--------------------------------------------------*/
default:
break;
/*--------------------------------------------------*/
}
}
void AutoStartPage::Save()
{
if ( m_taps.size() == 0 )
{
MessageBox::Show( messageBoxTitle, "No TAPs are installed in Auto Start", "OK" );
return;
}
// Set current directory to ProgramFiles
if ( !TAP_Hdd_ChangeDir( programFilesPath ) )
{
MessageBox::Show( messageBoxTitle, "ProgramFiles directory could not be found", "OK" );
return;
}
// display a progress box
ProgressBox progress( "Please wait", "Reordering Auto Start TAPs" );
progress.OnOpen();
string errors;
string warnings;
bool reorder = false;
// Get the current filenames of each of the TAPs
if ( !TAP_Hdd_ChangeDir( autoStartPath ) )
{
progress.OnClose();
MessageBox::Show("Reorder TAPs", "Failed to find Auto Start folder", "OK");
return;
}
for ( unsigned int i = 0; i < m_taps.size(); ++i )
{
if ( m_taps[i].index != i )
reorder = true;
if ( !TAP_Hdd_Exist( (char*)m_taps[i].filename.c_str() ) )
{
int extOffset = m_taps[i].filename.size()-3;
if ( extOffset > 0)
{
m_taps[i].filename[extOffset] = m_taps[i].filename[extOffset] == 't' ? 'n' : 't';
}
}
}
if (reorder)
{
TAP_Hdd_ChangeDir("..");
// Create a temporary Auto Start and move all TAPs there
TAP_Hdd_Create( tempAutoStartName, ATTR_FOLDER );
if ( !TAP_Hdd_ChangeDir( tempAutoStartName ) )
{
progress.OnClose();
MessageBox::Show( messageBoxTitle, "Failed to create Temp Auto Start folder", "OK");
return;
}
// Move the TAPs to the Temporary Auto Start directory
short int stepSize = 50/m_taps.size();
for ( unsigned int i = 0; i < m_taps.size(); ++i )
{
TRACE1("Moving %s\n",(char*)m_taps[i].filename.c_str());
progress.StepProgress( stepSize, "Preparing " + m_taps[i].name );
HDD_Move( (char*)m_taps[i].filename.c_str(), "/ProgramFiles/Auto Start", "/ProgramFiles/Temp Auto Start" );
if ( !TAP_Hdd_Exist( (char*)m_taps[i].filename.c_str() ) )
{
// TAP wasn't moved, flag the failure and
if ( warnings.size() > 0 )
warnings += ", ";
warnings += m_taps[i].name;
m_taps[i].spare = false;
progress.StepProgress( stepSize );
}
else
m_taps[i].spare = true;
}
TRACE("Done moving\n");
// Now move them back into Auto Start in the order the user has requested
if ( !TAP_Hdd_ChangeDir( "/ProgramFiles/Auto Start" ) )
{
progress.OnClose();
MessageBox::Show("Reorder TAPs", "Failed to find Auto Start folder", "OK");
return;
}
int count = 0;
for ( unsigned int i = 0; i < m_taps.size(); ++i )
{
if ( m_taps[i].spare )
{
TRACE1("Moving TAP %s\n",(char*)m_taps[i].filename.c_str());
progress.StepProgress( stepSize, "Reordering " + m_taps[i].name );
HDD_Move((char*)m_taps[i].filename.c_str(), "/ProgramFiles/Temp Auto Start", "/ProgramFiles/Auto Start");
if ( !TAP_Hdd_Exist( (char*)m_taps[i].filename.c_str() ) )
{
if ( errors.size() > 0 )
errors += ", ";
errors += m_taps[i].name;
}
++count;
}
}
}
// Finally, deal with enabled and disabled
for ( unsigned int i = 0; i < m_taps.size(); ++i )
{
int extOffset = m_taps[i].filename.size()-3;
string tapName = m_taps[i].filename;
tapName[extOffset] = 't';
string napName = m_taps[i].filename;
napName[extOffset] = 'n';
if ( m_taps[i].enabled )
{
// ensure TAP is enabled
if ( TAP_Hdd_Exist( (char*)tapName.c_str() ) )
TAP_Hdd_Delete( (char*)napName.c_str() );
else
TAP_Hdd_Rename( (char*)napName.c_str(), (char*)tapName.c_str() );
}
else
{
// ensure TAP is disabled
if ( TAP_Hdd_Exist( (char*)tapName.c_str() ) )
{
TAP_Hdd_Delete( (char*)napName.c_str() );
TAP_Hdd_Rename( (char*)tapName.c_str(), (char*)napName.c_str() );
}
}
}
// Delete Temp Auto Start if the directory is empty
if ( TAP_Hdd_ChangeDir( "/ProgramFiles/Temp Auto Start" ) )
{
TYPE_File file;
dword totalEntry = TAP_Hdd_FindFirst( &file );
while ( totalEntry-- )
{
// ignore ., .. and deleted files
if ( file.attr != ATTR_PARENTFOLDER && file.attr != ATTR_THISFOLDER && file.attr != ATTR_DELETEDFILE )
break;
if ( totalEntry==0 || TAP_Hdd_FindNext( &file ) == 0 )
{
TAP_Hdd_ChangeDir("..");
TAP_Hdd_Delete( tempAutoStartName );
break;
}
}
}
progress.OnClose();
// report any errors
if ( errors.size() || warnings.size() )
{
if ( errors.size() > 0 )
MessageBox::Show("Reorder TAPs", "The following TAPs could not be reordered:\n" + errors + "Check the Temp Auto Start folder", "OK");
else if ( warnings.size() > 0 )
MessageBox::Show("Reorder TAPs", "The following TAPs could not be reordered:\n" + warnings, "OK");
}
else
{
if ( MessageBox::Show("Reorder TAPs", "Finished", HDD_isAnyRecording() ? "OK" : "OK\nReboot" ) == 2 )
Reboot(false);
}
}
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();
}
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();
}
char* GetCurrentDir(void)
{
dword cluster;
char* path;
TYPE_File file;
char* temp;
appendToLogfile("GetCurrentDir: started.");
path = TAP_MemAlloc (2);
if (path == NULL)
{
appendToLogfile("GetCurrentDir: TAP_MemAlloc (2) failed.");
return NULL;
}
appendToLogfile("GetCurrentDir: after memalloc.");
strcpy (path, "");
path[0]='\0';
// while we have a '.' entry we work up the tree matching starting clusters
while (CurrentDirStartCluster (&cluster))
{
// TYPE_File file;
// move into parent directory and look for a starting cluster match
TAP_Hdd_ChangeDir ("..");
memset (&file, 0, sizeof (file));
if (TAP_Hdd_FindFirst (&file))
{
while ((cluster != file.startCluster) && TAP_Hdd_FindNext (&file)) {};
}
// if we have a match prepend it to the path
if (cluster == file.startCluster)
{
// char* temp;
temp = TAP_MemAlloc (strlen (path) + strlen (file.name) + 2);
// no memory - back to starting directory and return NULL
if (temp == NULL)
{
appendToLogfile("GetCurrentDir: TAP_MemAlloc (strlen path) failed.");
TAP_Hdd_ChangeDir (file.name);
if (strlen (path)) TAP_Hdd_ChangeDir (&path[1]);
TAP_MemFree (path);
return NULL;
}
appendStringToLogfile("GetCurrentDir: Match on file=%s",file.name);
// There's an issue where we may find the "." directory entry instead of the subdir -
// so for now, let's ignore it. 5 Nov 2005
if (strcmp(file.name,".")!=0)
{
strcpy (temp, "/");
strcat (temp, file.name);
strcat (temp, path);
TAP_MemFree (path);
path = temp;
appendStringToLogfile("GetCurrentDir: Path now=%s",path);
}
}
else
{
// directory structure inconsistent, shouldn't get here
// problem - we can't get back to our starting directory
TAP_MemFree (path);
appendStringToLogfile("GetCurrentDir: Bombed out.",file.name);
return NULL;
}
}
if (strlen (path))
{
// finally we put ourselves back in our starting directory
//TAP_Hdd_ChangeDir (&path[1]);
appendToLogfile("GetCurrentDir: Found current directory.");
appendStringToLogfile("GetCurrentDir: It's %s.",path);
GotoPath(path);
}
else
{
// We're at the root
strcpy (path, "/");
appendStringToLogfile("GetCurrentDir: Found at ROOT.",file.name);
}
return (path);
}
