FCL/sf/os/imagingext: comparison imagingmodules/jp2kcodec/Src/JP2KCodec.cpp

equal deleted inserted replaced

-:469c91dae73b
+:ac33adcbae0f
 const TSizMarker &sizMarker = iImageInfo->SizMarker();
 // To get the right output image size, we must compute the size tile by tile.
 // Compute the width of the output image
 TInt32 tileCompCanvasWidth = 0;
-TInt32 numHorTiles = iImageInfo->NumOfHorizTiles();
+TInt32 numHorTiles = iImageInfo->NumOfHorizTilesL();
 TInt32 tileStartCanvas;
 TInt32 tileEndCanvas;
 TInt32 tileCompStartCanvas;
 for(TUint16 indexX = 0; indexX < numHorTiles; ++indexX )
 {
 tileStartCanvas = Max( ( sizMarker.iXTOsiz + indexX * sizMarker.iXTsiz ), sizMarker.iXOsiz );
 tileEndCanvas = Min( ( sizMarker.iXTOsiz + ( indexX + 1 ) * sizMarker.iXTsiz ), sizMarker.iXsiz );
 // Add this tile's contribution to the total size
-tileCompStartCanvas = TJ2kUtils::Ceil( tileStartCanvas, sizMarker.iXRsiz[0] );
+tileCompStartCanvas = TJ2kUtils::CeilL( tileStartCanvas, sizMarker.iXRsiz[0] );
-tileCompCanvasWidth += TJ2kUtils::Ceil( tileEndCanvas, sizMarker.iXRsiz[0] ) - tileCompStartCanvas;
+tileCompCanvasWidth += TJ2kUtils::CeilL( tileEndCanvas, sizMarker.iXRsiz[0] ) - tileCompStartCanvas;
 }
 // Compute the height of the output image
 TInt32 tileCompCanvasHeight = 0;
-TInt32 numVerTiles = iImageInfo->NumOfVertTiles();
+TInt32 numVerTiles = iImageInfo->NumOfVertTilesL();
 for(TUint16 indexY = 0; indexY < numVerTiles; ++indexY )
 {
 tileStartCanvas = Max( ( sizMarker.iYTOsiz + indexY * sizMarker.iYTsiz ), sizMarker.iYOsiz );
 tileEndCanvas = Min( ( sizMarker.iYTOsiz + ( indexY + 1 ) * sizMarker.iYTsiz ), sizMarker.iYsiz );
 // Add this tile's contribution to the total size
-tileCompStartCanvas = TJ2kUtils::Ceil( tileStartCanvas, sizMarker.iYRsiz[0] );
+tileCompStartCanvas = TJ2kUtils::CeilL( tileStartCanvas, sizMarker.iYRsiz[0] );
-tileCompCanvasHeight += TJ2kUtils::Ceil( tileEndCanvas, sizMarker.iYRsiz[0] ) - tileCompStartCanvas;
+tileCompCanvasHeight += TJ2kUtils::CeilL( tileEndCanvas, sizMarker.iYRsiz[0] ) - tileCompStartCanvas;
 }
 iFrame->iOverallSizeInPixels = TSize( tileCompCanvasWidth, tileCompCanvasHeight );
 iFrame->iFrameCoordsInPixels.SetRect( TPoint( 0, 0 ), iFrame->iOverallSizeInPixels );
 iUseNewTile = ETrue;
 iReader.iNewDataStart = iFrame->FrameDataOffset();
 iStyleUsed = EUnknownDecoder;
 iProgressBar = EFalse;
-if ( ( iImageInfo->NumOfHorizTiles() == 1 ) &&
+if ( ( iImageInfo->NumOfHorizTilesL() == 1 ) &&
-( iImageInfo->NumOfVertTiles() == 1 ) )
+( iImageInfo->NumOfVertTilesL() == 1 ) )
 {
 // To force a return immediately from ProcessFrameL()
 // on first entry to stimulate the occurrance of
 // the progress bar
 iProgressBar = ETrue;
 }
 else
 {
 // COD in Tile Part Header
 codMarker = new ( ELeave ) TCODMarker;
-CleanupDeletePushL( codMarker );
+//CleanupDeletePushL( codMarker );
+CleanupStack::PushL(codMarker);
 }
 codMarker->iScod = *iReader.iPtr++;
 codMarker->iProgressionOrder = *iReader.iPtr++;
 codMarker->iNumOfLayers = PtrReadUtil::ReadBigEndianUint16Inc( iReader.iPtr );
 if ( codMarker->iScod & 0x01 )
 {
 // Entropy coder with precincts defined below
 codMarker->iPrecinctSiz = HBufC8::NewL( codMarker->iNumOfLevels + 1 );
+CleanupStack::PushL(codMarker->iPrecinctSiz);
 for ( TUint8 index = 0; index < codMarker->iNumOfLevels + 1; ++index )
 {
 codMarker->iPrecinctSiz->Des().Append( *iReader.iPtr++ );
 }
 }
 if ( ( iReader.iPtr - iReader.iPtrStartMarker ) != ( markerLength + KMarkerSize ) )
 {
 // We must be missing some data in the marker
 User::Leave( KErrCorrupt );
 }
+if ( codMarker->iScod & 0x01 )
+{
+CleanupStack::Pop(codMarker->iPrecinctSiz);
+}
 if ( !aMain )
 {
 CJ2kTileInfo& tile = CONST_CAST( CJ2kTileInfo&, iImageInfo->TileAt( iLastTileIndex ) );
 // Append COD to the current tile and decrement the tile length
 tile.AppendCOD( codMarker, markerLength + KMarkerSize );
-CleanupStack::Pop();
+CleanupStack::PopAndDestroy(codMarker);
 }
 // Any valid marker may come after COD marker
 iFHState = EStateInUnknown;
 return EFrameComplete;
 }
 const TSizMarker& sizMarker = iImageInfo->SizMarker();
 TCOCMarker *cocMarker = new ( ELeave ) TCOCMarker;
-CleanupDeletePushL(cocMarker);
+//CleanupDeletePushL(cocMarker);
+CleanupStack::PushL(cocMarker);
 if ( sizMarker.iCsiz < 257 )
 {
 // 8 bits component
 cocMarker->iCcoc = *iReader.iPtr++;
 if ( cocMarker->iScoc & 0x01 )
 {
 // Entropy coder with precincts defined below
 cocMarker->iPrecinctSiz = HBufC8::NewL( cocMarker->iNumOfLevels + 1 );
+CleanupStack::PushL(cocMarker->iPrecinctSiz);
 for ( TUint8 index = 0; index < cocMarker->iNumOfLevels + 1; ++index )
 {
 cocMarker->iPrecinctSiz->Des().Append( *iReader.iPtr++ );
 }
 }
 CJ2kTileInfo& tile = CONST_CAST( CJ2kTileInfo&, iImageInfo->TileAt( iLastTileIndex ) );
 // Append COC to the current tile and decrement the tile length
 tile.AppendCOCL( cocMarker, markerLength + KMarkerSize );
 }
-CleanupStack::Pop();
+if ( cocMarker->iScoc & 0x01 )
+{
+CleanupStack::Pop(cocMarker->iPrecinctSiz);
+}
+CleanupStack::PopAndDestroy(cocMarker);
 // Any valid marker may come after COC marker
 iFHState = EStateInUnknown;
 return EFrameComplete;
 else
 {
 // QCD in Tile Part Header
 qcdMarker = new ( ELeave ) TQCDMarker;
-CleanupDeletePushL( qcdMarker );
+//CleanupDeletePushL( qcdMarker );
+CleanupStack::PushL( qcdMarker );
 }
 qcdMarker->iSqcd = *iReader.iPtr++;
 if ( qcdMarker->iSqcd & 0x01 )
 qcdMarker->iExponent->Des().Append( (TUint8)( ( *iReader.iPtr++ >> 3 ) & 0x1f ) );
 --entries;
 }
 }
 }
+CleanupStack::PushL( qcdMarker->iExponent );
+if ((qcdMarker->iSqcd & 0x1f) || (qcdMarker->iSqcd & 0x01))
+{
+CleanupStack::PushL( qcdMarker->iMantissa );
+}
 // Make sure we read all the data
 if ( ( iReader.iPtr - iReader.iPtrStartMarker ) != ( markerLength + KMarkerSize ) )
 {
 // We must be missing some data in the marker
 User::Leave( KErrCorrupt );
 }
+if ((qcdMarker->iSqcd & 0x1f) || (qcdMarker->iSqcd & 0x01))
+{
+CleanupStack::Pop( qcdMarker->iMantissa );
+}
+CleanupStack::Pop( qcdMarker->iExponent );
 if ( !aMain )
 {
 CJ2kTileInfo& tile = CONST_CAST( CJ2kTileInfo&, iImageInfo->TileAt( iLastTileIndex ) );
 // Append QCD to the current tile and decrement the tile length
 tile.AppendQCD( qcdMarker, markerLength + KMarkerSize );
-CleanupStack::Pop();
+//CleanupStack::PopAndDestroy(qcdMarker);
+CleanupStack::PopAndDestroy(qcdMarker);
 }
 // Any valid marker may come after QCD marker
 iFHState = EStateInUnknown;
 const TSizMarker& sizMarker = iImageInfo->SizMarker();
 TQCCMarker *qccMarker = new (ELeave) TQCCMarker;
-CleanupDeletePushL( qccMarker );
+//CleanupDeletePushL( qccMarker );
+CleanupStack::PushL( qccMarker );
 if ( sizMarker.iCsiz < 257 )
 {
 // 8 bits component
 qccMarker->iCqcc = *iReader.iPtr++;
 qccMarker->iExponent->Des().Append( (TUint8)( ( *iReader.iPtr++ >> 3 ) & 0x1f ) );
 --entries;
 }
 }
 }
+CleanupStack::PushL( qccMarker->iExponent );
+if( (qccMarker->iSqcc & 0x1f) || (qccMarker->iSqcc & 0x01) )
+{
+CleanupStack::PushL( qccMarker->iMantissa );
+}
 // Make sure we read all the data
 if ( ( iReader.iPtr - iReader.iPtrStartMarker ) != ( markerLength + KMarkerSize ) )
 {
 // We must be missing some data in the marker
 CJ2kTileInfo& tile = CONST_CAST( CJ2kTileInfo&, iImageInfo->TileAt( iLastTileIndex ) );
 // Append QCC to the current tile and decrement the tile length
 tile.AppendQCCL( qccMarker, markerLength + KMarkerSize );
 }
-CleanupStack::Pop();
+if( (qccMarker->iSqcc & 0x1f) || (qccMarker->iSqcc & 0x01) )
+{
+CleanupStack::Pop( qccMarker->iMantissa );
+}
+CleanupStack::Pop( qccMarker->iExponent );
+CleanupStack::PopAndDestroy(qccMarker);
 // Any valid marker may come after QCC marker
 iFHState = EStateInUnknown;
 return EFrameComplete;
 }
 const TSizMarker& sizMarker = iImageInfo->SizMarker();
 TRGNMarker *rgnMarker = new ( ELeave ) TRGNMarker;
-CleanupDeletePushL( rgnMarker );
+CleanupStack::PushL( rgnMarker );
 if ( sizMarker.iCsiz < 257 )
 {
 // 8 bits component
 rgnMarker->iCrgn = *iReader.iPtr++;
 CJ2kTileInfo& tile = CONST_CAST( CJ2kTileInfo&, iImageInfo->TileAt( iLastTileIndex ) );
 // Append RGN to the current tile and decrement the tile length
 tile.AppendRGNL( rgnMarker, markerLength + KMarkerSize );
 }
-CleanupStack::Pop();
+CleanupStack::PopAndDestroy(rgnMarker);
 // Any valid marker may come after RGN marker
 iFHState = EStateInUnknown;
 return EFrameComplete;
 // Underflow, will keep reading
 isUnderflow = ETrue;
 }
 TPPMMarker *ppmMarker = new ( ELeave ) TPPMMarker;
-CleanupDeletePushL( ppmMarker );
+CleanupStack::PushL( ppmMarker );
 ppmMarker->iZppm = *iReader.iPtr++;
 TUint32 entries = (TUint32)( markerLength - KMarkerSize - 1 );
 ppmMarker->iNppm = entries;
 ppmMarker->iIppm = HBufC8::NewL( entries );
+CleanupStack::PushL( ppmMarker->iIppm );
 if ( !isUnderflow )
 {
 ppmMarker->iIppm->Des(  ).Append( iReader.iPtr, entries );
 iReader.iPtr += entries;
 if ( tmp )
 {
 User::LeaveIfError( mainMarker.iPpm.Append( ppmMarker ) );
 }
-CleanupStack::Pop();
+CleanupStack::Pop(ppmMarker->iIppm);
+CleanupStack::Pop(ppmMarker);
 }
 else
 {
 if ( (TUint32)( iReader.iPtrEnd - iReader.iPtr ) < iPreviousPPM->iRemainder )
 {
 iReader.iPtr -= KMarkerMinLength;
 return EFrameIncomplete;
 }
 TPLMMarker *plmMarker =  new ( ELeave ) TPLMMarker;
-CleanupDeletePushL( plmMarker );
+CleanupStack::PushL( plmMarker );
 plmMarker->iZplm = *iReader.iPtr++;
 TUint32 entries = (TUint32)( markerLength - KMarkerSize - 1 );
 plmMarker->iNplm = (TUint8)entries;
 plmMarker->iIplm = HBufC8::NewL( entries );
+CleanupStack::PushL( plmMarker->iIplm );
 plmMarker->iIplm->Des().Append( iReader.iPtr, entries );
 iReader.iPtr += entries;
 // Make sure we read all the data
 if ( ( iReader.iPtr - iReader.iPtrStartMarker ) != ( markerLength + KMarkerSize ) )
 if ( tmp )
 {
 User::LeaveIfError( mainMarker.iPlm.Append( plmMarker ) );
 }
-CleanupStack::Pop();
+CleanupStack::Pop(plmMarker->iIplm);
+CleanupStack::PopAndDestroy(plmMarker);
 // Any valid marker may come after PLM marker
 iFHState = EStateInUnknown;
 return EFrameComplete;
 {
 // Underflow, will keep reading
 isUnderflow = ETrue;
 }
 TCOMMarker* comMarker = new ( ELeave ) TCOMMarker;
-CleanupDeletePushL( comMarker );
+//CleanupDeletePushL(comMarker);
+CleanupStack::PushL( comMarker );
 comMarker->iRcom = PtrReadUtil::ReadBigEndianUint16Inc( iReader.iPtr );
 TInt entries = markerLength - ( 2 * KMarkerSize );
 comMarker->iCcom = HBufC8::NewL( entries );
+//CleanupDeletePushL( comMarker->iCcom );
+CleanupStack::PushL(comMarker->iCcom);
 if ( !isUnderflow )
 {
 comMarker->iCcom->Des().Append( iReader.iPtr, entries );
 iReader.iPtr += entries;
 iPreviousCOM = 0;
 CJ2kTileInfo& tile = CONST_CAST( CJ2kTileInfo&, iImageInfo->TileAt( iLastTileIndex ) );
 // Append COM to the current tile and decrement the tile length
 tile.AppendCOML( comMarker, markerLength + KMarkerSize );
 }
-CleanupStack::Pop();
+CleanupStack::Pop(comMarker->iCcom);
+CleanupStack::Pop(comMarker);
 }
 else
 {
 if ( ( iReader.iPtrEnd - iReader.iPtr ) < iPreviousCOM->iRemainder )
 {
 sotMarker.iIsot = PtrReadUtil::ReadBigEndianUint16Inc( iReader.iPtr );
 sotMarker.iPsot = PtrReadUtil::ReadBigEndianUint32Inc( iReader.iPtr );
 sotMarker.iTPsot = *iReader.iPtr++;
 sotMarker.iTNsot = *iReader.iPtr++;
-if(sotMarker.iIsot >= ( iImageInfo->NumOfHorizTiles() * iImageInfo->NumOfVertTiles() ))
+if(sotMarker.iIsot >= ( iImageInfo->NumOfHorizTilesL() * iImageInfo->NumOfVertTilesL() ))
 {
 // Invalid tile index, exceeds the number of tiles, exit
 User::Leave( KErrCorrupt );
 }
 else
 {
 tile.SetPacketHeaderReader( &iReader );
 }
-if ( ( iImageInfo->NumOfHorizTiles() == 1 ) &&
+if ( ( iImageInfo->NumOfHorizTilesL() == 1 ) &&
-( iImageInfo->NumOfVertTiles() == 1 ) )
+( iImageInfo->NumOfVertTilesL() == 1 ) )
 {
 // To force a return immediately from ProcessFrameL()
 // on first entry to stimulate the occurrance of
 // the progress bar
 iProgressBar = ETrue;
 return EFrameIncomplete;
 }
 }
 }
-if ( ( iImageInfo->NumOfHorizTiles() == 1 ) &&
+if ( ( iImageInfo->NumOfHorizTilesL() == 1 ) &&
-( iImageInfo->NumOfVertTiles() == 1 ) )
+( iImageInfo->NumOfVertTilesL() == 1 ) )
 {
 // To force a return immediately from ProcessFrameL()
 // on first entry to stimulate the occurrance of
 // the progress bar
 iProgressBar = ETrue;
 iReader.iPtr -= KMarkerMinLength;
 return EFrameIncomplete;
 }
 TPPTMarker *pptMarker = new ( ELeave ) TPPTMarker;
-CleanupDeletePushL( pptMarker );
+CleanupStack::PushL( pptMarker );
 TInt entries = markerLength - KMarkerSize - 1;
 pptMarker->iZppt = *iReader.iPtr++;
 pptMarker->iIppt = HBufC8::NewL( entries );
+CleanupStack::PushL( pptMarker->iIppt );
 pptMarker->iIppt->Des(  ).Append( iReader.iPtr, entries );
 iReader.iPtr += entries;
 // Make sure we read all the data
 if ( ( iReader.iPtr - iReader.iPtrStartMarker ) != ( markerLength + KMarkerSize ) )
 CJ2kTileInfo& tile = CONST_CAST( CJ2kTileInfo&, iImageInfo->TileAt( iLastTileIndex ) );
 // Append PPT to the current tile and decrement the tile length
 tile.AppendPPTL( pptMarker, markerLength + KMarkerSize );
-CleanupStack::Pop();
+CleanupStack::Pop(pptMarker->iIppt);
+CleanupStack::PopAndDestroy(pptMarker);
 // Any valid marker may come after PPT marker
 iFHState = EStateInUnknown;
 return EFrameComplete;
 iReader.iPtr -= KMarkerMinLength;
 return EFrameIncomplete;
 }
 TPLTMarker *pltMarker = new ( ELeave ) TPLTMarker;
-//CleanupStack::PushL( pltMarker );
+CleanupStack::PushL( pltMarker );
-CleanupDeletePushL( pltMarker );
+//CleanupDeletePushL( pltMarker );
 pltMarker->iZplt = *iReader.iPtr++;
 TInt entries = markerLength - KMarkerSize - 1;
 while ( entries )
 CJ2kTileInfo& tile = CONST_CAST( CJ2kTileInfo&, iImageInfo->TileAt( iLastTileIndex ) );
 // Append PLT to the current tile and decrement the tile length
 tile.AppendPLTL( pltMarker, markerLength + KMarkerSize );
-CleanupStack::Pop();
+//CleanupStack::Pop();
+CleanupStack::PopAndDestroy(pltMarker);
 // Any valid marker may come after PLT marker
 iFHState = EStateInUnknown;
 return EFrameComplete;

changeset 10	ac33adcbae0f
parent 0	469c91dae73b
child 8	9ebf3284bc56