Changeset 13757

Show
Ignore:
Timestamp:
02/11/08 12:07:39 (5 months ago)
Author:
ilucena
Message:

Force min/max calculation on IWriteBlock
Adopts the safer memory allocation functions VSIMalloc2/3

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/gdal/frmts/idrisi/IdrisiDataset.cpp

    r13500 r13757  
    270270    char **papszCategories; 
    271271    char *pszUnitType; 
    272         bool bDirty; 
    273272 
    274273    CPLErr GeoReference2Wkt( const char *pszRefSystem, 
     
    279278        char **pszRefSystem,  
    280279        char **pszRefUnit ); 
    281  
    282         void CalculateMinMax(); 
    283280 
    284281protected: 
     
    348345    virtual const GDALRasterAttributeTable *GetDefaultRAT(); 
    349346    virtual CPLErr SetDefaultRAT( const GDALRasterAttributeTable * ); 
     347 
     348    float  dfMaximum; 
     349    float  dfMinimum; 
     350    bool   bFirstVal; 
    350351}; 
    351352 
     
    368369    papszCategories = NULL; 
    369370    pszUnitType = NULL; 
    370         bDirty = false; 
    371371 
    372372    adfGeoTransform[0] = 0.0; 
     
    388388    if( papszRDC != NULL ) 
    389389    { 
    390                if( eAccess == GA_Update ) 
     390        if( eAccess == GA_Update ) 
    391391        {        
    392                         if( bDirty ) 
    393                         { 
    394                                 CalculateMinMax(); 
    395                         } 
    396                         CSLSetNameValueSeparator( papszRDC, ": " ); 
     392            int i; 
     393 
     394            for( i = 0; i < nBands; i++ ) 
     395            { 
     396                IdrisiRasterBand *poBand = (IdrisiRasterBand*) GetRasterBand( i + 1 ); 
     397                poBand->SetStatistics( poBand->dfMinimum, poBand->dfMaximum, 0.0, 0.0 ); 
     398            } 
     399 
     400            CSLSetNameValueSeparator( papszRDC, ": " ); 
    397401            CSLSave( papszRDC, pszDocFilename ); 
     402 
    398403#ifndef WIN32         
    399404            FormatCRLF( pszDocFilename ); 
     
    415420    if( fp != NULL ) 
    416421        VSIFCloseL( fp ); 
    417 } 
    418  
    419 /************************************************************************/ 
    420 /*                           CalculateMinMax()                          */ 
    421 /************************************************************************/ 
    422  
    423 void IdrisiDataset::CalculateMinMax() 
    424 { 
    425         int iBand; 
    426         double dfMin  = 0.0; 
    427         double dfMax  = 0.0; 
    428  
    429     for( iBand = 0; iBand < nBands; iBand++ ) 
    430         { 
    431         IdrisiRasterBand *poBand = (IdrisiRasterBand*) GetRasterBand( iBand + 1 ); 
    432                 poBand->ComputeStatistics( true, &dfMin, &dfMax, NULL, NULL, NULL, NULL ); 
    433                 poBand->SetStatistics( dfMin, dfMax, 0.0, 0.0 ); 
    434         }        
    435422} 
    436423 
     
    10271014    poDS->GetRasterBand( 1 )->GetBlockSize( &nBlockXSize, &nBlockYSize ); 
    10281015 
     1016    void *pData = VSIMalloc3( nBlockXSize, nBlockYSize,  
     1017                              GDALGetDataTypeSize( eType ) / 8 ); 
     1018 
     1019    if( pData == NULL ) 
     1020    { 
     1021        CPLError( CE_Failure, CPLE_OutOfMemory, 
     1022                "IdrisiRasterBand::CreateCopy : Out of memory " ); 
     1023        delete poDS; 
     1024        return NULL; 
     1025    } 
     1026 
    10291027    for( int iBand = 1; iBand <= poSrcDS->GetRasterCount(); iBand++ ) 
    10301028    { 
     
    10331031 
    10341032        int    iYOffset, iXOffset; 
    1035         void *pData; 
    10361033        CPLErr eErr = CE_None; 
    1037  
    1038         pData = CPLMalloc( nBlockXSize * nBlockYSize * GDALGetDataTypeSize( eType ) / 8 ); 
    10391034 
    10401035        for( iYOffset = 0; iYOffset < nYSize; iYOffset += nBlockYSize ) 
     
    10681063            } 
    10691064        } 
    1070         CPLFree( pData ); 
    1071     } 
     1065    } 
     1066 
     1067    CPLFree( pData ); 
    10721068 
    10731069    // -------------------------------------------------------------------- 
     
    10761072 
    10771073    poDS->FlushCache(); 
    1078  
    1079         poDS->bDirty = ( ! ( bSuccessMin && bSuccessMax ) ); 
    10801074 
    10811075    return poDS; 
     
    12281222    this->eDataType = eDataType; 
    12291223    this->poDefaultRAT = NULL; 
     1224    this->dfMinimum = 0.0; 
     1225    this->dfMaximum = 0.0; 
     1226    this->bFirstVal = true; 
    12301227 
    12311228    // --------------------------------------------------------------------  
     
    12401237    // --------------------------------------------------------------------  
    12411238 
    1242     // FIXME : risk of overflow in multiplication 
    1243     nRecordSize = poDS->GetRasterXSize() * GDALGetDataTypeSize( eDataType ) / 8 * poDS->nBands; 
    1244     pabyScanLine = ( GByte * ) VSIMalloc( nRecordSize ); 
    1245     if (pabyScanLine == NULL) 
     1239    nRecordSize  = poDS->GetRasterXSize() * GDALGetDataTypeSize( eDataType ) / 8; 
     1240 
     1241    pabyScanLine = (GByte*) VSIMalloc2( nRecordSize, poDS->nBands ); 
     1242 
     1243    if( pabyScanLine == NULL ) 
    12461244    { 
    12471245        CPLError(CE_Failure, CPLE_OutOfMemory, 
     
    12491247                  poDS->GetRasterXSize()); 
    12501248    } 
     1249 
     1250    nRecordSize *= poDS->nBands; 
    12511251} 
    12521252 
     
    13171317 
    13181318CPLErr IdrisiRasterBand::IWriteBlock( int nBlockXOff,  
    1319                                      int nBlockYOff, 
    1320                                      void *pImage ) 
     1319                                      int nBlockYOff, 
     1320                                      void *pImage ) 
    13211321{ 
    13221322    IdrisiDataset *poGDS = (IdrisiDataset *) poDS; 
    1323  
    1324         poGDS->bDirty = true; 
    13251323 
    13261324#ifdef CPL_MSB     
     
    13641362    } 
    13651363 
     1364    // --------------------------------------------------------------------  
     1365    //      Store the first value as mimunm and maximum 
     1366    // --------------------------------------------------------------------  
     1367 
     1368    if( bFirstVal ) 
     1369    { 
     1370        switch( eDataType ) 
     1371        { 
     1372            case GDT_Float32: 
     1373                dfMinimum = dfMaximum = (double) ((float*) pabyScanLine)[0]; 
     1374                break; 
     1375            case GDT_Int16: 
     1376                dfMinimum = dfMaximum = (double) ((GInt16*) pabyScanLine)[0]; 
     1377                break; 
     1378            default: 
     1379                dfMinimum = dfMaximum = (double) ((GByte*) pabyScanLine)[  
     1380                    poGDS->nBands == 1 ? 0 : 3 - this->nBand ]; 
     1381        } 
     1382        bFirstVal = false; 
     1383    } 
     1384 
     1385    // --------------------------------------------------------------------  
     1386    //      Search for the minimum and maximum values 
     1387    // --------------------------------------------------------------------  
     1388 
     1389    int i, j; 
     1390 
     1391    if( eDataType == GDT_Float32 ) 
     1392    { 
     1393        for( i = 0; i < nBlockXSize; i++ ) 
     1394        { 
     1395            dfMinimum = MIN( dfMinimum, ((float*) pabyScanLine)[i] ); 
     1396            dfMaximum = MAX( dfMaximum, ((float*) pabyScanLine)[i] ); 
     1397        } 
     1398    } 
     1399    else if( eDataType == GDT_Int16 ) 
     1400    { 
     1401        for( i = 0; i < nBlockXSize; i++ ) 
     1402        { 
     1403            dfMinimum = MIN( dfMinimum, ((GInt16*) pabyScanLine)[i] ); 
     1404            dfMaximum = MAX( dfMaximum, ((GInt16*) pabyScanLine)[i] ); 
     1405        } 
     1406    } 
     1407    else if( poGDS->nBands == 1 ) 
     1408    { 
     1409        for( i = 0; i < nBlockXSize; i++ ) 
     1410        { 
     1411            dfMinimum = MIN( dfMinimum, ((GByte*) pabyScanLine)[i] ); 
     1412            dfMaximum = MAX( dfMaximum, ((GByte*) pabyScanLine)[i] ); 
     1413        } 
     1414    } 
     1415    else 
     1416    { 
     1417        for( i = 0, j = ( 3 - nBand ); i < nBlockXSize; i++, j += 3 ) 
     1418        { 
     1419            dfMinimum = MIN( dfMinimum, ((GByte*) pabyScanLine)[j] ); 
     1420            dfMaximum = MAX( dfMaximum, ((GByte*) pabyScanLine)[j] ); 
     1421        } 
     1422    } 
     1423 
    13661424    return CE_None; 
    13671425} 
     
    13811439    if( pbSuccess ) 
    13821440        { 
    1383         *pbSuccess = ( ! poGDS->bDirty )
     1441        *pbSuccess = true
    13841442        } 
    13851443 
     
    14011459    if( pbSuccess ) 
    14021460        { 
    1403         *pbSuccess = ( ! poGDS->bDirty )
     1461        *pbSuccess = true
    14041462        } 
    14051463