LCPDataset::~LCPDataset()
{
FlushCache();
if( fpImage != NULL )
VSIFCloseL( fpImage );
CPLFree(pszProjection);
}
GTXDataset::~GTXDataset()
{
FlushCache();
if( fpImage != NULL )
VSIFCloseL( fpImage );
}
FujiBASDataset::~FujiBASDataset()
{
FlushCache();
if( fpImage != NULL )
VSIFClose( fpImage );
CSLDestroy( papszHeader );
}
WEBPDataset::~WEBPDataset()
{
FlushCache();
if (fpImage)
VSIFCloseL(fpImage);
VSIFree(pabyUncompressed);
}
RasdamanDataset::~RasdamanDataset()
{
if (transaction.get_status() == r_Transaction::active) {
transaction.commit();
}
database.close();
FlushCache();
}
GXFDataset::~GXFDataset()
{
FlushCache();
if( hGXF != NULL )
GXFClose( hGXF );
CPLFree( pszProjection );
}
int iop_heap_dma_upload(void *src,u32 dst,int size)
{
int i=0,len=0,size2;
u8 *pkt;
int ret=0;
int ret2=0;
int p=0;
int cont1=0;
while(size>0) // send data with src unaligned
{
if(size>512) size2=512; else size2=size;
CD_memcpy2(memsend,((unsigned char *) src)+p,size2);
do
{
FlushCache(0);
/* build packet */
pkt = send_buffer2;
PUSHDATA( u32, pkt, (u32)memsend, i);
pkt += i; len += i;
PUSHDATA( u32, pkt, dst, i);
pkt += i; len += i;
PUSHDATA( int, pkt, size2, i);
pkt += i; len += i;
PUSHDATA( int, pkt, 0, i);
pkt += i; len += i;
ret = SifSetDma((SifDmaTransfer_t*)send_buffer2,1);
if(ret==0) {nopdelay();cont1++;}
if(ret==0 && cont1>=3) {cont1=0;SifSetDChain();}
}while(ret==0); // modificado por Hermes
while((ret2 = SifDmaStat(ret))>=0);
FlushCache(0);
size-=size2;
p+=size2;
dst+=size2;
}
return (ret2 < -1);
}
/*
* Conversion to physical address
* Cache control required, but cache control by page cannot be
* provided without MMU, so not implemented.
*/
LOCAL INT _CnvPhysicalAddr( VP laddr, INT len, VP *paddr )
{
*paddr = toPhysicalAddress(laddr);
/* Cache off not possible, so cache flash only is performed. */
FlushCache(laddr, len);
return len;
}
PNMDataset::~PNMDataset()
{
FlushCache();
if( fpImage != nullptr && VSIFCloseL( fpImage ) != 0 )
{
CPLError(CE_Failure, CPLE_FileIO, "I/O error" );
}
}
USGSDEMDataset::~USGSDEMDataset()
{
FlushCache();
CPLFree( pszProjection );
if( fp != NULL )
VSIFClose( fp );
}
IDADataset::~IDADataset()
{
FlushCache();
if( fpRaw != NULL )
VSIFCloseL( fpRaw );
CPLFree( pszProjection );
}
MEMDataset::~MEMDataset()
{
FlushCache();
CPLFree( pszProjection );
GDALDeinitGCPs( nGCPCount, pasGCPs );
CPLFree( pasGCPs );
}
/**
* Writes a byte to the cached buffer
* @param aValue Byte to write
*/
void TCachedByteStreamWriter::WriteByte(TUint8 aValue)
{
if(iPos == iCacheSize)
{
FlushCache();
}
iCacheBuffer[iPos++] = aValue;
++iBytesWritten;
}
GDALArrayBandBlockCache::~GDALArrayBandBlockCache()
{
FlushCache();
if( !bSubBlockingActive )
CPLFree( u.papoBlocks );
else
CPLFree( u.papapoBlocks );
}
DOQ1Dataset::~DOQ1Dataset()
{
FlushCache();
CPLFree( pszProjection );
if( fpImage != NULL )
CPL_IGNORE_RET_VAL(VSIFCloseL( fpImage ));
}
HF2Dataset::~HF2Dataset()
{
FlushCache();
CPLFree(pszWKT);
CPLFree(panBlockOffset);
if (fp)
VSIFCloseL(fp);
}
RIKDataset::~RIKDataset()
{
FlushCache();
CPLFree( pOffsets );
if( fp != NULL )
VSIFCloseL( fp );
delete poColorTable;
}
GRIBDataset::~GRIBDataset()
{
FlushCache();
if( fp != NULL )
VSIFCloseL( fp );
CPLFree( pszProjection );
}
USGSDEMDataset::~USGSDEMDataset()
{
FlushCache();
CPLFree( pszProjection );
if( fp != nullptr )
CPL_IGNORE_RET_VAL(VSIFCloseL( fp ));
}
ARGDataset::~ARGDataset()
{
CPLFree(pszFilename);
FlushCache();
if( fpImage != nullptr )
VSIFCloseL( fpImage );
}
PDSDataset::~PDSDataset()
{
FlushCache();
if( fpImage != NULL )
VSIFCloseL( fpImage );
CloseDependentDatasets();
}
DTEDDataset::~DTEDDataset()
{
FlushCache();
CPLFree(pszFilename);
CPLFree( pszProjection );
if( psDTED != NULL )
DTEDClose( psDTED );
}
VRTWarpedDataset::~VRTWarpedDataset()
{
FlushCache();
/* -------------------------------------------------------------------- */
/* Cleanup overviews. */
/* -------------------------------------------------------------------- */
int iOverview;
for( iOverview = 0; iOverview < nOverviewCount; iOverview++ )
{
GDALDatasetH hDS = (GDALDatasetH) papoOverviews[iOverview];
if( GDALDereferenceDataset( hDS ) < 1 )
{
GDALReferenceDataset( hDS );
GDALClose( hDS );
}
}
CPLFree( papoOverviews );
/* -------------------------------------------------------------------- */
/* Cleanup warper if one is in effect. */
/* -------------------------------------------------------------------- */
if( poWarper != NULL )
{
const GDALWarpOptions *psWO = poWarper->GetOptions();
/* -------------------------------------------------------------------- */
/* We take care to only call GDALClose() on psWO->hSrcDS if the */
/* reference count drops to zero. This is makes it so that we */
/* can operate reference counting semantics more-or-less */
/* properly even if the dataset isn't open in shared mode, */
/* though we require that the caller also honour the reference */
/* counting semantics even though it isn't a shared dataset. */
/* -------------------------------------------------------------------- */
if( psWO->hSrcDS != NULL )
{
if( GDALDereferenceDataset( psWO->hSrcDS ) < 1 )
{
GDALReferenceDataset( psWO->hSrcDS );
GDALClose( psWO->hSrcDS );
}
}
/* -------------------------------------------------------------------- */
/* We are responsible for cleaning up the transformer outselves. */
/* -------------------------------------------------------------------- */
if( psWO->pTransformerArg != NULL )
GDALDestroyTransformer( psWO->pTransformerArg );
delete poWarper;
}
}
/*
* Copy statically linked IRX files to kernel RAM.
* They will be loaded by the debugger later...
*/
void install_modules(const config_t *config)
{
ramfile_t file_tab[IRX_NUM + 1];
ramfile_t *file_ptr = file_tab;
ramfile_t *ktab = NULL;
u32 addr = IRX_ADDR;
D_PRINTF("%s: addr=%08x\n", __FUNCTION__, addr);
/*
* build RAM file table
*/
#ifdef _SMS_MODULES
if (config_get_bool(config, SET_DEBUGGER_SMS_MODULES)) {
ramfile_set(file_ptr++, "ps2ip", _ps2ip_sms_irx_start, _ps2ip_sms_irx_size);
ramfile_set(file_ptr++, "ps2smap", _ps2smap_sms_irx_start, _ps2smap_sms_irx_size);
} else {
#endif
ramfile_set(file_ptr++, "ps2ip", _ps2ip_irx_start, _ps2ip_irx_size);
ramfile_set(file_ptr++, "ps2smap", _ps2smap_irx_start, _ps2smap_irx_size);
#ifdef _SMS_MODULES
}
#endif
ramfile_set(file_ptr++, "ps2dev9", _ps2dev9_irx_start, _ps2dev9_irx_size);
ramfile_set(file_ptr++, "debugger", _debugger_irx_start, _debugger_irx_size);
ramfile_set(file_ptr++, "memdisk", _memdisk_irx_start, _memdisk_irx_size);
ramfile_set(file_ptr++, "eesync", _eesync_irx_start, _eesync_irx_size);
ramfile_set(file_ptr, NULL, NULL, 0); /* terminator */
/*
* copy modules to kernel RAM
*
* memory structure at @addr:
* |RAM file table|IRX module #1|IRX module #2|etc.
*/
DI();
ee_kmode_enter();
ktab = (ramfile_t*)addr;
addr += sizeof(file_tab);
file_ptr = file_tab;
while (file_ptr->hash) {
memcpy((u8*)addr, file_ptr->addr, file_ptr->size);
file_ptr->addr = (u8*)addr;
addr += file_ptr->size;
file_ptr++;
}
memcpy(ktab, file_tab, sizeof(file_tab));
ee_kmode_exit();
EI();
FlushCache(0);
}
E00GRIDDataset::~E00GRIDDataset()
{
FlushCache();
if (fp)
VSIFCloseL(fp);
CSLDestroy(papszPrj);
E00ReadClose(e00ReadPtr);
CPLFree(panOffsets);
}
BAGDataset::~BAGDataset( )
{
FlushCache();
if( hHDF5 >= 0 )
H5Fclose( hHDF5 );
CPLFree( pszXMLMetadata );
CPLFree( pszProjection );
}
LevellerDataset::~LevellerDataset()
{
FlushCache();
CPLFree(m_pszProjection);
CPLFree(m_pszFilename);
if( m_fp != NULL )
VSIFCloseL( m_fp );
}
CPLErr MEMRasterBand::IRasterIO( GDALRWFlag eRWFlag,
int nXOff, int nYOff, int nXSize, int nYSize,
void * pData, int nBufXSize, int nBufYSize,
GDALDataType eBufType,
GSpacing nPixelSpaceBuf,
GSpacing nLineSpaceBuf,
GDALRasterIOExtraArg* psExtraArg )
{
if( nXSize != nBufXSize || nYSize != nBufYSize )
{
return GDALRasterBand::IRasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize,
pData, nBufXSize, nBufYSize,
eBufType,
static_cast<int>(nPixelSpaceBuf),
nLineSpaceBuf,
psExtraArg);
}
// In case block based I/O has been done before.
FlushCache();
if( eRWFlag == GF_Read )
{
for( int iLine=0; iLine < nYSize; iLine++ )
{
GDALCopyWords(
pabyData + nLineOffset*static_cast<size_t>(iLine + nYOff) +
nXOff*nPixelOffset,
eDataType,
static_cast<int>(nPixelOffset),
reinterpret_cast<GByte*>( pData ) +
nLineSpaceBuf * static_cast<size_t>(iLine),
eBufType,
static_cast<int>(nPixelSpaceBuf),
nXSize );
}
}
else
{
for( int iLine = 0; iLine < nYSize; iLine++ )
{
GDALCopyWords(
reinterpret_cast<GByte *>( pData ) +
nLineSpaceBuf*(size_t)iLine,
eBufType,
static_cast<int>(nPixelSpaceBuf),
pabyData + nLineOffset*static_cast<size_t>(iLine + nYOff) +
nXOff*nPixelOffset,
eDataType,
static_cast<int>(nPixelOffset),
nXSize );
}
}
return CE_None;
}
int SifIopReboot(const char* filename)
{
char param_str[RESET_ARG_MAX+1];
int param_size;
if ((filename != NULL) && (*filename != '\0'))
{
param_size = strlen( filename ) + 11;
if(param_size > RESET_ARG_MAX)
{
// printf("too long parameter '%s'\n", filename);
return -1;
}
}
SifInitRpc(0);
if ((filename != NULL) && (*filename != '\0'))
{
strncpy(param_str, "rom0:UDNL ", 10);
}
else
{
strncpy(param_str, "rom0:UDNL", 9);
}
if ((filename != NULL) && (*filename != '\0'))
{
strncpy(¶m_str[10], filename, strlen(filename));
}
SifIopReset(param_str, 0);
while(!SifIopSync());
SifInitRpc(0);
FlushCache(0);
FlushCache(2);
return 0;
}
ELASDataset::~ELASDataset()
{
FlushCache();
if( fp != NULL )
{
VSIFClose( fp );
fp = NULL;
}
}