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

equal deleted inserted replaced

-:3993b8f65362
+:9ebf3284bc56
 CleanupDeletePushL( jp2kComment );
 jp2kComment->iComment = mainMarker.iCom[index]->iCcom;
 User::LeaveIfError( iFrameData->AppendImageData( jp2kComment ) );
-CleanupStack::Pop();
+CleanupStack::Pop(jp2kComment);
 // Transfer the ownership of the buffer from TMainMarker to framework
 User::LeaveIfError( iFrameData->AppendImageBuffer( jp2kComment->iComment ) );
 mainMarker.iCom[index]->iCcom = 0;
 }
 }
 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::PopAndDestroy(codMarker);
+CleanupStack::Pop(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(cocMarker);
-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::PopAndDestroy(qcdMarker);
+CleanupStack::Pop(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(qccMarker);
-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;
-CleanupStack::PushL( rgnMarker );
+CleanupDeletePushL( 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::PopAndDestroy(rgnMarker);
+CleanupStack::Pop(rgnMarker);
 // Any valid marker may come after RGN marker
 iFHState = EStateInUnknown;
 return EFrameComplete;
 CJ2kTileInfo& tile = CONST_CAST( CJ2kTileInfo&, iImageInfo->TileAt( iLastTileIndex ) );
 // Append POC to the current tile and decrement the tile length
 tile.AppendPOCL( pocMarker, markerLength + KMarkerSize );
 }
-CleanupStack::Pop(  );
+CleanupStack::Pop(pocMarker);
 // Any valid marker may come after POC marker
 iFHState = EStateInUnknown;
 return EFrameComplete;
 // Underflow, will keep reading
 isUnderflow = ETrue;
 }
 TPPMMarker *ppmMarker = new ( ELeave ) TPPMMarker;
-CleanupStack::PushL( ppmMarker );
+CleanupDeletePushL( 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(ppmMarker->iIppm);
 CleanupStack::Pop(ppmMarker);
 }
 else
 {
 if ( (TUint32)( iReader.iPtrEnd - iReader.iPtr ) < iPreviousPPM->iRemainder )
 if ( sp )
 {
 User::LeaveIfError( mainMarker.iTlm.Append( tlmMarker ) );
 }
-CleanupStack::Pop();
+CleanupStack::Pop(tlmMarker);
 // Any valid marker may come after TLM marker
 iFHState = EStateInUnknown;
 return EFrameComplete;
 iReader.iPtr -= KMarkerMinLength;
 return EFrameIncomplete;
 }
 TPLMMarker *plmMarker =  new ( ELeave ) TPLMMarker;
-CleanupStack::PushL( plmMarker );
+CleanupDeletePushL( 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(plmMarker->iIplm);
+CleanupStack::Pop(plmMarker);
-CleanupStack::PopAndDestroy(plmMarker);
 // Any valid marker may come after PLM marker
 iFHState = EStateInUnknown;
 return EFrameComplete;
 User::Leave( KErrCorrupt );
 }
 iImageInfo->AppendCRGL( crgMarker );
-CleanupStack::Pop(  );
+CleanupStack::Pop(crgMarker);
 // Any valid marker may come after CRG 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(comMarker->iCcom);
 CleanupStack::Pop(comMarker);
 }
 else
 {
 if ( ( iReader.iPtrEnd - iReader.iPtr ) < iPreviousCOM->iRemainder )
 else
 {
 // Underflow, stay in the same state
 if ( aMain )
 {
-iReader.UpdateMainHeader(  );
+iReader.UpdateMainHeader();
 }
 return EFrameIncomplete;
 }
 }
 }
 if ( iUseNewTile )
 {
 iImageInfo->Append( tile );
-CleanupStack::Pop();
+CleanupStack::Pop(tile);
 iUseNewTile = EFalse;
 }
 // Any valid marker may come after SOT marker
 iFHState = EStateInUnknown;
 iReader.iPtr -= KMarkerMinLength;
 return EFrameIncomplete;
 }
 TPPTMarker *pptMarker = new ( ELeave ) TPPTMarker;
-CleanupStack::PushL( pptMarker );
+CleanupDeletePushL(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(pptMarker->iIppt);
+CleanupStack::Pop(pptMarker);
-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 );
+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(pltMarker);
-CleanupStack::PopAndDestroy(pltMarker);
 // Any valid marker may come after PLT marker
 iFHState = EStateInUnknown;
 return EFrameComplete;

branch	RCL_3
changeset 8	9ebf3284bc56
parent 4	3993b8f65362