1 /*

     2 * Copyright (c) 2003-2006 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  CJp2kReadCodec class implements the ICL read codec interface.

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include <fbs.h>

    21 #include <JP2KImageData.h>

    22 #include "JP2KImageUtils.h"

    23 #include "JP2KFormat.h"

    24 #include "JP2KStreamReader.h"

    25 #include "JP2KTileInfo.h"

    26 #include "JP2KImageInfo.h"

    27 #include "JP2KCodec.h"

    28 #include "JP2KEntropyDecoder.h"

    29 #include "JP2KImageWriter.h"

    30 #include "JP2KSynthesis.h"

    31 

    32 // EXTERNAL DATA STRUCTURES

    33 

    34 // EXTERNAL FUNCTION PROTOTYPES  

    35 

    36 // CONSTANTS

    37 

    38 // MACROS

    39 

    40 // LOCAL CONSTANTS AND MACROS

    41 

    42 // MODULE DATA STRUCTURES

    43 

    44 // LOCAL FUNCTION PROTOTYPES

    45 

    46 // FORWARD DECLARATIONS

    47 

    48 // ============================= LOCAL FUNCTIONS ===============================

    49 

    50 // ============================ MEMBER FUNCTIONS ===============================

    51 

    52 // -----------------------------------------------------------------------------

    53 // CJp2kReadCodec::NewL

    54 // Two-phased constructor.

    55 // -----------------------------------------------------------------------------

    56 //

    57 CJp2kReadCodec* CJp2kReadCodec::NewL( const TJ2kInfo& aJ2kInfo )

    58     {

    59     CJp2kReadCodec* self = new ( ELeave ) CJp2kReadCodec( aJ2kInfo );

    60 

    61     CleanupStack::PushL( self );

    62     self->ConstructL();

    63     CleanupStack::Pop( self ); 

    64 

    65     return self;

    66     }

    67 

    68 // Destructor

    69 CJp2kReadCodec::~CJp2kReadCodec()

    70     {

    71     delete iImageInfo;

    72     iImageInfo = 0;

    73 

    74     delete iEntropy;

    75     iEntropy = 0;

    76 

    77     delete iImageWriter;

    78     iImageWriter = 0;

    79 

    80     delete iSynthesis;

    81     iSynthesis = 0;

    82     }

    83 

    84 // -----------------------------------------------------------------------------

    85 // CJp2kReadCodec::DecodeTileL

    86 // Decoding the current tile-part

    87 // (other items were commented in a header).

    88 // -----------------------------------------------------------------------------

    89 //

    90 TFrameState CJp2kReadCodec::DecodeTileL()

    91     {

    92     CJ2kTileInfo& tile = CONST_CAST( CJ2kTileInfo&, iImageInfo->TileAt( iLastTileIndex ) );

    93 

    94     // Decode and delete the tile

    95     DecodeAndDeleteTileL( tile );

    96 

    97     // reset the codec back to the parsing state

    98     iDecodeTile = EFalse;

    99     TFrameState retCode = EFrameIncomplete;

   100 

   101     // Start with new tile

   102     iUseNewTile = ETrue;

   103     if ( !iUseNextTile )

   104         {

   105         iFHState = EStateInUnknown;

   106         retCode = EFrameIncompleteRepositionRequest;

   107         }

   108     else

   109         {

   110         if ( !iSequential )

   111             {

   112             // Must be End of Codestream EOC

   113             iFHState = EStateInEOC;

   114             retCode = EFrameComplete;

   115             }

   116         else if ( iFHState == EStateInEOC )

   117             {

   118             retCode = EFrameComplete;

   119             }

   120         else

   121             {

   122             iFHState = EStateInUnknown;

   123             }

   124         }

   125     return retCode;

   126     }

   127 

   128 // -----------------------------------------------------------------------------

   129 // CJp2kReadCodec::IsDecodeTile

   130 // Is codec in the decoding state

   131 // (other items were commented in a header).

   132 // -----------------------------------------------------------------------------

   133 //

   134 TBool CJp2kReadCodec::IsDecodeTile() const

   135     {

   136     return iDecodeTile;

   137     }

   138 

   139 // -----------------------------------------------------------------------------

   140 // CJp2kReadCodec::InitFrameHeader

   141 // (other items were commented in a header).

   142 // -----------------------------------------------------------------------------

   143 //

   144 void CJp2kReadCodec::InitFrameHeader( TFrameInfo& aFrameInfo, CFrameImageData& aFrameData )

   145     {

   146     // Initialize internal data structure for holding frame header

   147     ASSERT( aFrameInfo.CurrentFrameState() == TFrameInfo::EFrameInfoUninitialised );

   148 

   149     iFrame = &aFrameInfo;

   150     iFrameData = &aFrameData;

   151     aFrameInfo.SetCurrentFrameState( TFrameInfo::EFrameInfoProcessingFrameHeader );

   152     }

   153 

   154 // -----------------------------------------------------------------------------

   155 // CJp2kReadCodec::ProcessFrameHeaderL

   156 // Collect the JP2 codestream Main Header information.

   157 // (other items were commented in a header).

   158 // -----------------------------------------------------------------------------

   159 //

   160 TFrameState CJp2kReadCodec::ProcessFrameHeaderL( TBufPtr8& aData )

   161     {

   162     // Read frame header and fill up internal data structure

   163     TFrameState retCode = EFrameIncomplete;

   164 

   165     iReader.iPtr = aData.Ptr();

   166     iReader.iPtrStart = CONST_CAST( TUint8*, iReader.iPtr );

   167     iReader.iPtrEnd   = iReader.iPtrStart + aData.Length();

   168 

   169     while ( iFHState != EStateInSOT )

   170         {

   171         iReader.iPtrStartMarker = CONST_CAST( TUint8*, iReader.iPtr );

   172         switch ( iFHState )

   173             {

   174             case EStateInSOC:

   175                 {

   176                 retCode = ReadSOCL();

   177                 break;

   178                 }

   179             case EStateInSIZ:

   180                 {

   181                 retCode = ReadSIZL();

   182                 break;

   183                 }

   184             case EStateInCOD:

   185                 {

   186                 retCode = ReadCODL();

   187                 break;

   188                 }

   189             case EStateInCOC:

   190                 {

   191                 retCode = ReadCOCL();

   192                 break;

   193                 }

   194             case EStateInQCD:

   195                 {

   196                 retCode = ReadQCDL();

   197                 break;

   198                 }

   199             case EStateInQCC:

   200                 {

   201                 retCode = ReadQCCL();

   202                 break;

   203                 }

   204             case EStateInRGN:

   205                 {

   206                 retCode = ReadRGNL();

   207                 break;

   208                 }

   209             case EStateInPOC:

   210                 {

   211                 retCode = ReadPOCL();

   212                 break;

   213                 }

   214             case EStateInPPM:

   215                 {

   216                 retCode = ReadPPML();

   217                 break;

   218                 }

   219             case EStateInTLM:

   220                 {

   221                 retCode = ReadTLML();

   222                 break;

   223                 }

   224             case EStateInPLM:

   225                 {

   226                 retCode = ReadPLML();

   227                 break;

   228                 }

   229             case EStateInCRG:

   230                 {

   231                 retCode = ReadCRGL();

   232                 break;

   233                 }

   234             case EStateInCOM:

   235                 {

   236                 retCode = ReadCOML();

   237                 break;

   238                 }

   239             case EStateInUnknown:

   240                 {

   241                 // Update the internal state based on the Marker

   242                 retCode = UpdateStateFromMarkerL(); 

   243                 break;

   244                 }

   245             default:

   246                 {

   247                 // Unrecognized marker

   248                 User::Leave( KErrCorrupt );

   249                 break;

   250                 }

   251             }

   252         // Check for underflow

   253         if ( retCode != EFrameComplete ) 

   254             {

   255             aData.Shift( iReader.iPtr - iReader.iPtrStart );

   256             return retCode;

   257             }

   258 

   259         // Update the internal counter for data processed

   260         iReader.UpdateMainHeader();

   261         }

   262 

   263     // Convert the MainHeader's COM marker to TJp2kComment

   264     // and let the framework managing the buffer.

   265     TMainMarker& mainMarker = CONST_CAST( TMainMarker&, iImageInfo->MainMarker() );

   266     for ( TInt index = 0; index < mainMarker.iCom.Count(); ++index )

   267         {

   268         TJp2kComment* jp2kComment = new ( ELeave ) TJp2kComment;

   269         CleanupDeletePushL( jp2kComment );

   270 

   271         jp2kComment->iComment = mainMarker.iCom[index]->iCcom;

   272 

   273         User::LeaveIfError( iFrameData->AppendImageData( jp2kComment ) );

   274         CleanupStack::Pop();

   275 

   276         // Transfer the ownership of the buffer from TMainMarker to framework

   277         User::LeaveIfError( iFrameData->AppendImageBuffer( jp2kComment->iComment ) );

   278         mainMarker.iCom[index]->iCcom = 0;

   279         }

   280 

   281     // Convert some metadata from file format to TImageDataBlock derived objects

   282     ConvertImageDataL();

   283 

   284     // Try to sort PPM and PLM if there is one

   285     iImageInfo->DoCompactMainHeaderL();

   286 

   287     aData.Shift( iReader.iPtr - iReader.iPtrStart );

   288 

   289     // Fill up the image related information if it is not

   290     // JP2 file format

   291     if ( !( iJ2kInfo.iOption & TJ2kInfo::EJP2file ) )

   292         {

   293         const TSizMarker &sizMarker = iImageInfo->SizMarker();

   294 

   295         // To get the right output image size, we must compute the size tile by tile.

   296         // Compute the width of the output image

   297         TInt32 tileCompCanvasWidth = 0;

   298         TInt32 numHorTiles = iImageInfo->NumOfHorizTiles(); 

   299         TInt32 tileStartCanvas;

   300         TInt32 tileEndCanvas;

   301         TInt32 tileCompStartCanvas;

   302         for(TUint16 indexX = 0; indexX < numHorTiles; ++indexX )  

   303             {

   304             tileStartCanvas = Max( ( sizMarker.iXTOsiz + indexX * sizMarker.iXTsiz ), sizMarker.iXOsiz );

   305             tileEndCanvas = Min( ( sizMarker.iXTOsiz + ( indexX + 1 ) * sizMarker.iXTsiz ), sizMarker.iXsiz );

   306 

   307             // Add this tile's contribution to the total size

   308             tileCompStartCanvas = TJ2kUtils::Ceil( tileStartCanvas, sizMarker.iXRsiz[0] );

   309             tileCompCanvasWidth += TJ2kUtils::Ceil( tileEndCanvas, sizMarker.iXRsiz[0] ) - tileCompStartCanvas;

   310             }

   311         

   312         // Compute the height of the output image

   313         TInt32 tileCompCanvasHeight = 0;

   314         TInt32 numVerTiles = iImageInfo->NumOfVertTiles(); 

   315         for(TUint16 indexY = 0; indexY < numVerTiles; ++indexY )  

   316             {

   317             tileStartCanvas = Max( ( sizMarker.iYTOsiz + indexY * sizMarker.iYTsiz ), sizMarker.iYOsiz );

   318             tileEndCanvas = Min( ( sizMarker.iYTOsiz + ( indexY + 1 ) * sizMarker.iYTsiz ), sizMarker.iYsiz );

   319 

   320             // Add this tile's contribution to the total size

   321             tileCompStartCanvas = TJ2kUtils::Ceil( tileStartCanvas, sizMarker.iYRsiz[0] );

   322             tileCompCanvasHeight += TJ2kUtils::Ceil( tileEndCanvas, sizMarker.iYRsiz[0] ) - tileCompStartCanvas;

   323             }

   324         

   325         iFrame->iOverallSizeInPixels = TSize( tileCompCanvasWidth, tileCompCanvasHeight );

   326 

   327         iFrame->iFrameCoordsInPixels.SetRect( TPoint( 0, 0 ), iFrame->iOverallSizeInPixels );

   328         iFrame->iFrameSizeInTwips.SetSize( 0, 0 );

   329 

   330         for ( TUint16 index = 0; index < sizMarker.iCsiz; ++index )  

   331             {

   332             iFrame->iBitsPerPixel += ( ( sizMarker.iSsiz[index] & 0x7f ) + 1 );

   333             }

   334 

   335         // We can dither.

   336         iFrame->iFlags |= TFrameInfo::ECanDither;

   337 

   338         // Decoder is able to handle scaleable resolution

   339         iFrame->iFlags |= TFrameInfo::EConstantAspectRatio;

   340 

   341         if ( sizMarker.iCsiz > 1 )

   342             {

   343             iFrame->iFlags |= TFrameInfo::EColor;

   344             }

   345 

   346         // Animation is not allowed

   347         iFrame->iDelay = 0;

   348 

   349         switch ( iFrame->iBitsPerPixel )

   350             {

   351             case 1:

   352                 {

   353                 iFrame->iFrameDisplayMode = EGray2;

   354                 break;

   355                 }

   356             case 2:

   357                 {

   358                 iFrame->iFrameDisplayMode = EGray4;

   359                 break;

   360                 }

   361             case 4:

   362                 {

   363                 iFrame->iFrameDisplayMode = ( iFrame->iFlags & TFrameInfo::EColor ) ? EColor16 : EGray16;

   364                 break;

   365                 }

   366             case 8:

   367                 {

   368                 iFrame->iFrameDisplayMode = ( iFrame->iFlags & TFrameInfo::EColor ) ? EColor16M : EGray256;

   369                 break;

   370                 }

   371             case 12:

   372                 {

   373                 iFrame->iFrameDisplayMode = ( iFrame->iFlags & TFrameInfo::EColor ) ? EColor4K : EGray256;

   374                 break;

   375                 }

   376             case 16:

   377                 {

   378                 iFrame->iFrameDisplayMode = EColor64K;

   379                 break;

   380                 }

   381             case 24:

   382                 {

   383                 iFrame->iFrameDisplayMode = EColor16M;

   384                 break;

   385                 }

   386             default:

   387                 {

   388                 iFrame->iFrameDisplayMode = EColor64K;

   389                 break;

   390                 }

   391             }

   392         }

   393 

   394     // It is the offset that ICL framework used to read in

   395     // more data from the image file.

   396     iFrame->SetFrameDataOffset( iReader.iStartSOT );

   397 

   398     // Frame header has been processed without error

   399     // the flag is used by the ICL framework to determine

   400     // whether it should continue processing or halt with error

   401     iFrame->SetCurrentFrameState( TFrameInfo::EFrameInfoProcessingComplete );

   402 

   403     return retCode;

   404     }

   405 

   406 // -----------------------------------------------------------------------------

   407 // CJp2kReadCodec::InitFrameL

   408 // Called from ICL framework to initialise frame.

   409 // (other items were commented in a header).

   410 // -----------------------------------------------------------------------------

   411 //

   412 void CJp2kReadCodec::InitFrameL( TFrameInfo& /*aFrameInfo*/, CFrameImageData& /*aFrameData*/, 

   413                                  TBool aDisableErrorDiffusion, CFbsBitmap& aDestination, 

   414                                  CFbsBitmap* /*aDestinationMask*/ )

   415     {

   416     // Always use ERgb mode unless specified in the JP2 file format

   417     TDisplayMode mode = ERgb;  

   418 

   419     TInt reductionFactor = ImageProcessorUtility::ReductionFactor( iFrame->iOverallSizeInPixels,

   420                                                                    aDestination.SizeInPixels() );

   421 

   422     iImageInfo->SetLevelDrop( (TUint8)reductionFactor );

   423 

   424     // If the codestream doesn't contain enough wavelet levels to do the resolution 

   425     // reduction required by the framework / calling application, "extraLevels" are 

   426     // assigned to perform the resolution reduction. The "extra" resolution drop is

   427     // performed at the output stage, i.e. all the samples are decoded, but only 

   428     // 1/4, 1/16, etc. are written to output.

   429     if(reductionFactor > iImageInfo->MainMarker().iCod.iNumOfLevels)

   430         {

   431         iImageInfo->SetExtraLevelDrop( (TUint8)(reductionFactor - iImageInfo->MainMarker().iCod.iNumOfLevels) );

   432         }

   433     else

   434         {

   435         iImageInfo->SetExtraLevelDrop( 0 );

   436         }

   437 

   438     CImageProcessor* imageProc = ImageProcessorUtility::NewImageProcessorL( aDestination, 

   439                                                                             0,

   440                                                                             mode,

   441                                                                             aDisableErrorDiffusion );

   442     TPoint startAt( iFrame->iFrameCoordsInPixels.iTl.iX,

   443                     iFrame->iFrameCoordsInPixels.iTl.iY );

   444 

   445     TRect imageSize( startAt, aDestination.SizeInPixels() );

   446 

   447     // Prepare the bitmap using the image size

   448     SetImageProcessor( imageProc );

   449     imageProc->PrepareL( aDestination, imageSize );

   450 

   451     // Clear bitmap so sensibly draw partial decodes

   452     ClearBitmapL(aDestination, KRgbWhite);

   453 

   454     iUseNewTile = ETrue;

   455     iReader.iNewDataStart = iFrame->FrameDataOffset();

   456     iStyleUsed = EUnknownDecoder;

   457 

   458     iProgressBar = EFalse;

   459     if ( ( iImageInfo->NumOfHorizTiles() == 1 ) &&

   460          ( iImageInfo->NumOfVertTiles() == 1 ) )

   461         {

   462         // To force a return immediately from ProcessFrameL()

   463         // on first entry to stimulate the occurrance of

   464         // the progress bar

   465         iProgressBar = ETrue;

   466         }

   467 

   468     if ( iFHState != EStateInSOT )

   469         {

   470         // We are in zoom in mode

   471         iUseNextTile = iSequential = EFalse;

   472         iFHState = EStateInSOT;

   473         iLastTileIndex = 0;

   474         iImageInfo->SetLastTilePartProcessed( (TUint16)0xffff );

   475         iImageWriter->SetNewImageProcessor( imageProc );

   476 

   477         if ( iJ2kInfo.iOption & TJ2kInfo::EJP2file )

   478             {

   479             iReader.iCSLength = iJ2kInfo.iCSBoxLength;

   480             

   481             // We have read in all header information, so skip it

   482             if ( iReader.iCSLength > iReader.iStartSOT )

   483                 {

   484                 iReader.iCSLength -= iReader.iStartSOT;

   485                 }

   486             iReader.iDataUsed = 0;

   487             }

   488         }

   489     }

   490 

   491 // -----------------------------------------------------------------------------

   492 // CJp2kReadCodec::ProcessFrameL

   493 // Collect the JP2 codestream Tile Part information.

   494 // (other items were commented in a header).

   495 // -----------------------------------------------------------------------------

   496 //

   497 TFrameState CJp2kReadCodec::ProcessFrameL(TBufPtr8& aSrc)

   498     {

   499     // Start decoding the compressed data stream

   500     TFrameState retCode = EFrameIncomplete;

   501 

   502     iReader.iPtr = aSrc.Ptr();

   503 

   504     iReader.iPtrStart = CONST_CAST( TUint8*, iReader.iPtr );

   505     iReader.iPtrEnd   = iReader.iPtrStart + aSrc.Length();

   506 

   507     while ( iFHState != EStateInEOC )

   508         {

   509         iReader.iPtrStartMarker = CONST_CAST( TUint8*, iReader.iPtr );

   510         switch ( iFHState )

   511             {

   512             case EStateInSOT:

   513                 {

   514                 retCode = ReadSOTL();

   515                 break;

   516                 }

   517             case EStateInSOD:

   518                 {

   519                 retCode = ReadSODL();

   520                 break;

   521                 }

   522             case EStateInBITSTREAM:

   523                 {

   524                 retCode = ReadBitStreamL();

   525                 break;

   526                 }

   527             case EStateInCOD:

   528                 {

   529                 retCode = ReadCODL( EFalse );

   530                 break;

   531                 }

   532             case EStateInCOC:

   533                 {

   534                 retCode = ReadCOCL( EFalse );

   535                 break;

   536                 }

   537             case EStateInQCD:

   538                 {

   539                 retCode = ReadQCDL( EFalse );

   540                 break;

   541                 }

   542             case EStateInQCC:

   543                 {

   544                 retCode = ReadQCCL( EFalse );

   545                 break;

   546                 }

   547             case EStateInRGN:

   548                 {

   549                 retCode = ReadRGNL( EFalse );

   550                 break;

   551                 }

   552             case EStateInPOC:

   553                 {

   554                 retCode = ReadPOCL( EFalse );

   555                 break;

   556                 }

   557             case EStateInPPT:

   558                 {

   559                 retCode = ReadPPTL();

   560                 break;

   561                 }

   562             case EStateInPLT:

   563                 {

   564                 retCode = ReadPLTL();

   565                 break;

   566                 }

   567             case EStateInCOM:

   568                 {

   569                 retCode = ReadCOML( EFalse );

   570                 break;

   571                 }

   572             case EStateInUnknown:

   573                 {

   574                 // Update the internal state based on the Marker

   575                 retCode = UpdateStateFromMarkerL();

   576                 break;

   577                 }

   578             case EStateInSkipTile:

   579                 {

   580                 retCode = ReadSkipTileL();

   581                 break;

   582                 }

   583             default:

   584                 {

   585                 // Unrecognized marker

   586                 User::Leave( KErrCorrupt );

   587                 break;

   588                 }

   589             }

   590         // Check for underflow

   591         if ( retCode != EFrameComplete ) 

   592             {

   593             // Request to jump to another section of the image file

   594             if ( retCode == EFrameIncompleteRepositionRequest )

   595                 {

   596                 // Update the internal counter for data processed

   597                 iReader.UpdateTileHeader();

   598                 }

   599 

   600             aSrc.Shift( iReader.iPtr - iReader.iPtrStart );

   601             return retCode;

   602             }

   603 

   604         if ( iFHState != EStateInSkipTile && iFHState != EStateInSOT )

   605             {

   606             // Update the internal counter for data processed

   607             // only for the current tile

   608             iReader.UpdateTileHeader();

   609             }

   610 

   611         if ( ( iProgressBar && iFHState != EStateInEOC ) || iDecodeTile )

   612             {

   613             iProgressBar = EFalse;

   614             aSrc.Shift( iReader.iPtr - iReader.iPtrStart );

   615             return EFrameIncomplete;

   616             }

   617         }

   618 

   619     if ( iDecodeTile == EFalse )

   620         {

   621         ImageProcessor()->FlushPixels();

   622         }

   623 

   624     return EFrameComplete;

   625     }

   626 

   627 // -----------------------------------------------------------------------------

   628 // CJp2kReadCodec::GetNewDataPosition

   629 // Get the new offset where data should be read from.

   630 // (other items were commented in a header).

   631 // -----------------------------------------------------------------------------

   632 //

   633 void CJp2kReadCodec::GetNewDataPosition( TInt& aPosition, TInt& /*aLength*/ )

   634     {

   635     // Set new offset position so that

   636     // ICL framework will read in more image data for processing

   637     aPosition = iReader.iNewDataStart + iJ2kInfo.iCSOffset;

   638     }

   639 

   640 // -----------------------------------------------------------------------------

   641 // CJp2kReadCodec::CJp2kReadCodec

   642 // C++ default constructor can NOT contain any code, that

   643 // might leave.

   644 // -----------------------------------------------------------------------------

   645 //

   646 CJp2kReadCodec::CJp2kReadCodec( const TJ2kInfo& aJ2kInfo ) :

   647     iJ2kInfo( aJ2kInfo )

   648     {

   649     }

   650 

   651 // -----------------------------------------------------------------------------

   652 // CJp2kReadCodec::ConstructL

   653 // Symbian 2nd phase constructor can leave.

   654 // -----------------------------------------------------------------------------

   655 //

   656 void CJp2kReadCodec::ConstructL()

   657     {

   658     iImageInfo = new ( ELeave ) CJ2kImageInfo;

   659 

   660     // Invoke base class 2nd phase constructor.

   661     CImageProcessorReadCodec::ConstructL();

   662     }

   663 

   664 // -----------------------------------------------------------------------------

   665 // CJp2kReadCodec::ReadSOCL

   666 // Verify and process Start of Codestream (SOC marker).

   667 // (other items were commented in a header).

   668 // -----------------------------------------------------------------------------

   669 //

   670 TFrameState CJp2kReadCodec::ReadSOCL()

   671     {    

   672     const TUint8* dataPtr = iReader.iPtr;

   673 

   674     if ( iJ2kInfo.iOption & TJ2kInfo::EJP2file )

   675         {

   676         // Codestream box in JP2 file format

   677         iReader.iCSLength = iJ2kInfo.iCSBoxLength;

   678         iReader.iPtr += KJ2kBoxTypeLength;

   679 

   680         if ( iReader.iCSLength == 1 )

   681             {

   682             // The XLBox shall exist and contains the actual length of the box

   683             // XLBox is 8 bytes width

   684             iReader.iCSLength = PtrReadUtil::ReadBigEndianUint32Inc( iReader.iPtr );

   685             iReader.iCSLength += PtrReadUtil::ReadBigEndianUint32Inc( iReader.iPtr );

   686 

   687             // Populate back to the iJ2kInfo

   688             CONST_CAST( TJ2kInfo&, iJ2kInfo ).iCSBoxLength = iReader.iCSLength;

   689             }

   690         }

   691 

   692     if ( ( iReader.iPtrEnd - iReader.iPtr ) < KMarkerSize )

   693         {

   694         // Underflow, backup the pointer to the beginning

   695         iReader.iPtr = dataPtr;

   696         return EFrameIncomplete;

   697         }

   698 

   699     if ( PtrReadUtil::ReadBigEndianUint16Inc( iReader.iPtr ) != KSOC )

   700         {

   701         // Unrecognized SOC marker

   702         User::Leave( KErrCorrupt );

   703         }

   704 

   705     // SIZ marker shall immediately follow the SOC marker

   706     iFHState = EStateInSIZ;

   707 

   708     return EFrameComplete;

   709     }

   710 

   711 // -----------------------------------------------------------------------------

   712 // CJp2kReadCodec::ReadSIZL

   713 // Verify and process Image and Tile Size (SIZ marker).

   714 // (other items were commented in a header).

   715 // -----------------------------------------------------------------------------

   716 //

   717 TFrameState CJp2kReadCodec::ReadSIZL()

   718     {

   719     if ( ( iReader.iPtrEnd - iReader.iPtr ) < KMarkerMinLength )

   720         {

   721         // Underflow

   722         return EFrameIncomplete;

   723         }

   724 

   725     if ( PtrReadUtil::ReadBigEndianUint16Inc( iReader.iPtr ) != KSIZ )

   726         {

   727         // Unrecognized SIZ marker

   728         User::Leave( KErrCorrupt );

   729         }

   730 

   731     TUint16 markerLength = PtrReadUtil::ReadBigEndianUint16Inc( iReader.iPtr );

   732 

   733     if ( ( iReader.iPtrEnd - iReader.iPtr ) < ( markerLength - KMarkerLength ) )

   734         {

   735         // Underflow, backup the iterator to the beginning of the marker

   736         iReader.iPtr -= KMarkerMinLength;

   737         return EFrameIncomplete;

   738         }

   739 

   740     TSizMarker& sizMarker = CONST_CAST( TSizMarker&, iImageInfo->SizMarker() );

   741 

   742     sizMarker.iRsiz   = PtrReadUtil::ReadBigEndianUint16Inc( iReader.iPtr );

   743     sizMarker.iXsiz   = PtrReadUtil::ReadBigEndianUint32Inc( iReader.iPtr );

   744     sizMarker.iYsiz   = PtrReadUtil::ReadBigEndianUint32Inc( iReader.iPtr );

   745     sizMarker.iXOsiz  = PtrReadUtil::ReadBigEndianUint32Inc( iReader.iPtr );

   746     sizMarker.iYOsiz  = PtrReadUtil::ReadBigEndianUint32Inc( iReader.iPtr );

   747     sizMarker.iXTsiz  = PtrReadUtil::ReadBigEndianUint32Inc( iReader.iPtr );

   748     sizMarker.iYTsiz  = PtrReadUtil::ReadBigEndianUint32Inc( iReader.iPtr );

   749     sizMarker.iXTOsiz = PtrReadUtil::ReadBigEndianUint32Inc( iReader.iPtr );

   750     sizMarker.iYTOsiz = PtrReadUtil::ReadBigEndianUint32Inc( iReader.iPtr );

   751     sizMarker.iCsiz   = PtrReadUtil::ReadBigEndianUint16Inc( iReader.iPtr );

   752     

   753     if(sizMarker.iXOsiz > sizMarker.iXsiz || sizMarker.iYOsiz > sizMarker.iYsiz)

   754         {

   755         // Image offset is larger than image size, exit

   756         User::Leave( KErrCorrupt );

   757         }

   758 

   759     if(sizMarker.iXTOsiz > sizMarker.iXsiz || sizMarker.iYTOsiz > sizMarker.iYsiz)

   760         {

   761         // Tile offset is larger than image size, exit

   762         User::Leave( KErrCorrupt );

   763         }

   764 

   765     for ( TUint16 index = 0; index < sizMarker.iCsiz; ++index )

   766         {

   767         // Component's information

   768         User::LeaveIfError( sizMarker.iSsiz.Append( *iReader.iPtr++ ) );

   769         User::LeaveIfError( sizMarker.iXRsiz.Append( *iReader.iPtr++ ) );

   770         User::LeaveIfError( sizMarker.iYRsiz.Append( *iReader.iPtr++ ) );

   771         

   772         if((( sizMarker.iSsiz[index] & 0x7f ) + 1) > KMaxBitdepth )

   773             {

   774             // Invalid bitdepth for this component, exit

   775             User::Leave( KErrCorrupt );

   776             }

   777         }

   778 

   779     if ( iJ2kInfo.iCMPList.Count() > sizMarker.iCsiz )

   780         {

   781         // Populate the remaining component Rsiz using component 0's Rsiz

   782         TUint16 indexi = (TUint16)( iJ2kInfo.iCMPList.Count() - sizMarker.iCsiz );

   783         while ( indexi )

   784             {

   785             User::LeaveIfError( sizMarker.iXRsiz.Append( sizMarker.iXRsiz[0] ) );

   786             User::LeaveIfError( sizMarker.iYRsiz.Append( sizMarker.iYRsiz[0] ) );

   787             --indexi;

   788             }

   789         }

   790 

   791     // Make sure we read all the data

   792     if ( ( iReader.iPtr - iReader.iPtrStartMarker ) != ( markerLength + KMarkerSize ) )

   793         {

   794         // We must be missing some data in the marker

   795         User::Leave( KErrCorrupt );

   796         }

   797 

   798     // Any valid marker may come after SIZ marker

   799     iFHState = EStateInUnknown;

   800 

   801     return EFrameComplete;

   802     }

   803 

   804 // -----------------------------------------------------------------------------

   805 // CJp2kReadCodec::ReadCODL

   806 // Verify and process Coding Style Default (COD marker).

   807 // (other items were commented in a header).

   808 // -----------------------------------------------------------------------------

   809 //

   810 TFrameState CJp2kReadCodec::ReadCODL( TBool aMain )

   811     {

   812     if ( ( iReader.iPtrEnd - iReader.iPtr ) < KMarkerMinLength )

   813         {

   814         // Underflow

   815         return EFrameIncomplete;

   816         }

   817 

   818     if ( PtrReadUtil::ReadBigEndianUint16Inc( iReader.iPtr ) != KCOD )

   819         {

   820         // Unrecognized COD marker

   821         User::Leave(KErrCorrupt);

   822         }

   823 

   824     TUint16 markerLength = PtrReadUtil::ReadBigEndianUint16Inc( iReader.iPtr );

   825 

   826     if ( ( iReader.iPtrEnd - iReader.iPtr ) < ( markerLength - KMarkerLength ) )

   827         {

   828         // Underflow, backup the iterator to the beginning of the marker

   829         iReader.iPtr -= KMarkerMinLength;

   830         return EFrameIncomplete;

   831         }

   832 

   833     TCODMarker *codMarker = NULL;

   834 

   835     if ( aMain )

   836         {

   837         TMainMarker& mainMarker = CONST_CAST( TMainMarker&, iImageInfo->MainMarker() );

   838         codMarker = &mainMarker.iCod;

   839         }

   840     else

   841         {

   842         // COD in Tile Part Header

   843         codMarker = new ( ELeave ) TCODMarker;        

   844         CleanupDeletePushL( codMarker );

   845         }

   846 

   847     codMarker->iScod = *iReader.iPtr++;

   848     codMarker->iProgressionOrder = *iReader.iPtr++;

   849     codMarker->iNumOfLayers = PtrReadUtil::ReadBigEndianUint16Inc( iReader.iPtr );

   850     codMarker->iColorTransformation = *iReader.iPtr++;

   851     codMarker->iNumOfLevels = *iReader.iPtr++;

   852 

   853     TUint8 tmp = (TUint8)( ( *iReader.iPtr++ ) + 2 );

   854     codMarker->iCodeBlockSiz.iWidth  = 1 << tmp;

   855 

   856     tmp = (TUint8)( ( *iReader.iPtr++ ) + 2 );

   857     codMarker->iCodeBlockSiz.iHeight = 1 << tmp;

   858 

   859     codMarker->iCodeBlockStyle = *iReader.iPtr++;

   860     codMarker->iWaveletTransformation = *iReader.iPtr++;

   861 

   862     if ( codMarker->iScod & 0x01 )

   863         {

   864         // Entropy coder with precincts defined below

   865         codMarker->iPrecinctSiz = HBufC8::NewL( codMarker->iNumOfLevels + 1 );

   866         for ( TUint8 index = 0; index < codMarker->iNumOfLevels + 1; ++index )

   867             {

   868             codMarker->iPrecinctSiz->Des().Append( *iReader.iPtr++ );

   869             }

   870         }

   871 

   872     // Make sure we read all the data

   873     if ( ( iReader.iPtr - iReader.iPtrStartMarker ) != ( markerLength + KMarkerSize ) )

   874         {

   875         // We must be missing some data in the marker

   876         User::Leave( KErrCorrupt );

   877         }

   878 

   879     if ( !aMain )

   880         {

   881         CJ2kTileInfo& tile = CONST_CAST( CJ2kTileInfo&, iImageInfo->TileAt( iLastTileIndex ) );

   882 

   883         // Append COD to the current tile and decrement the tile length

   884         tile.AppendCOD( codMarker, markerLength + KMarkerSize );

   885         CleanupStack::Pop();

   886         }

   887 

   888     // Any valid marker may come after COD marker

   889     iFHState = EStateInUnknown;

   890     return EFrameComplete;

   891     }

   892 

   893 // -----------------------------------------------------------------------------

   894 // CJp2kReadCodec::ReadCOCL

   895 // Verify and process Coding Style Component (COC marker).

   896 // (other items were commented in a header).

   897 // -----------------------------------------------------------------------------

   898 //

   899 TFrameState CJp2kReadCodec::ReadCOCL( TBool aMain )

   900     {

   901     if ( ( iReader.iPtrEnd - iReader.iPtr ) < KMarkerMinLength )

   902         {

   903         // Underflow

   904         return EFrameIncomplete;

   905         }

   906 

   907     if ( PtrReadUtil::ReadBigEndianUint16Inc( iReader.iPtr ) != KCOC )

   908         {

   909         // Unrecognized COC marker

   910         User::Leave( KErrCorrupt );

   911         }

   912 

   913     TUint16 markerLength = PtrReadUtil::ReadBigEndianUint16Inc( iReader.iPtr );

   914 

   915     if ( ( iReader.iPtrEnd - iReader.iPtr ) < ( markerLength - KMarkerLength ) )

   916         {

   917         // Underflow, backup the iterator to the beginning of the marker

   918         iReader.iPtr -= KMarkerMinLength;

   919         return EFrameIncomplete;

   920         }

   921 

   922     const TSizMarker& sizMarker = iImageInfo->SizMarker();

   923 

   924     TCOCMarker *cocMarker = new ( ELeave ) TCOCMarker;    

   925     CleanupDeletePushL(cocMarker);

   926 

   927     if ( sizMarker.iCsiz < 257 )

   928         {

   929         // 8 bits component

   930         cocMarker->iCcoc = *iReader.iPtr++;

   931         }

   932     else

   933         {

   934         // 16 bits component

   935         cocMarker->iCcoc = PtrReadUtil::ReadBigEndianUint16Inc( iReader.iPtr );

   936         }

   937 

   938     cocMarker->iScoc = *iReader.iPtr++;

   939     cocMarker->iNumOfLevels = *iReader.iPtr++;

   940 

   941     TUint8 tmp = (TUint8)( ( *iReader.iPtr++ ) + 2 );

   942     cocMarker->iCodeBlockSiz.iWidth  = 1 << tmp;

   943 

   944     tmp = (TUint8)( ( *iReader.iPtr++ ) + 2 );

   945     cocMarker->iCodeBlockSiz.iHeight = 1 << tmp;

   946 

   947     cocMarker->iCodeBlockStyle = *iReader.iPtr++;

   948     cocMarker->iWaveletTransformation = *iReader.iPtr++;

   949 

   950     if ( cocMarker->iScoc & 0x01 )

   951         {

   952         // Entropy coder with precincts defined below

   953         cocMarker->iPrecinctSiz = HBufC8::NewL( cocMarker->iNumOfLevels + 1 );

   954         for ( TUint8 index = 0; index < cocMarker->iNumOfLevels + 1; ++index )

   955             {

   956             cocMarker->iPrecinctSiz->Des().Append( *iReader.iPtr++ );

   957             }

   958         }

   959 

   960     // Make sure we read all the data

   961     if ( ( iReader.iPtr - iReader.iPtrStartMarker ) != ( markerLength + KMarkerSize ) )

   962         {

   963         // We must be missing some data in the marker

   964         User::Leave( KErrCorrupt );

   965         }

   966 

   967     if ( aMain )

   968         {

   969         iImageInfo->AppendCOCL( cocMarker );

   970         }

   971     else

   972         {

   973         CJ2kTileInfo& tile = CONST_CAST( CJ2kTileInfo&, iImageInfo->TileAt( iLastTileIndex ) );

   974 

   975         // Append COC to the current tile and decrement the tile length

   976         tile.AppendCOCL( cocMarker, markerLength + KMarkerSize );

   977         }

   978     CleanupStack::Pop();

   979 

   980     // Any valid marker may come after COC marker

   981     iFHState = EStateInUnknown;

   982 

   983     return EFrameComplete;

   984     }

   985 

   986 // -----------------------------------------------------------------------------

   987 // CJp2kReadCodec::ReadQCDL

   988 // Verify and process Quantization Default (QCD marker).

   989 // (other items were commented in a header).

   990 // -----------------------------------------------------------------------------

   991 //

   992 TFrameState CJp2kReadCodec::ReadQCDL( TBool aMain )

   993     {

   994     if ( ( iReader.iPtrEnd - iReader.iPtr ) < KMarkerMinLength )

   995         {   

   996         // Underflow

   997         return EFrameIncomplete;

   998         }

   999 

  1000     if ( PtrReadUtil::ReadBigEndianUint16Inc( iReader.iPtr ) != KQCD )

  1001         {

  1002         // Unrecognized QCD marker

  1003         User::Leave( KErrCorrupt );

  1004         }

  1005 

  1006     TUint16 markerLength = PtrReadUtil::ReadBigEndianUint16Inc( iReader.iPtr );

  1007     if ( ( iReader.iPtrEnd - iReader.iPtr ) < ( markerLength - KMarkerLength ) )

  1008         {

  1009         // Underflow, backup the iterator to the beginning of the marker

  1010         iReader.iPtr -= KMarkerMinLength;

  1011         return EFrameIncomplete;

  1012         }

  1013 

  1014     TQCDMarker *qcdMarker = NULL;

  1015 

  1016     if ( aMain )

  1017         {

  1018         TMainMarker& mainMarker = CONST_CAST( TMainMarker&, iImageInfo->MainMarker() );

  1019         qcdMarker = &mainMarker.iQcd;

  1020         }

  1021     else

  1022         {

  1023         // QCD in Tile Part Header

  1024         qcdMarker = new ( ELeave ) TQCDMarker;

  1025         

  1026         CleanupDeletePushL( qcdMarker );

  1027         }

  1028 

  1029     qcdMarker->iSqcd = *iReader.iPtr++;

  1030 

  1031     if ( qcdMarker->iSqcd & 0x01 )

  1032         {

  1033         // Scalar derived (values signalled for NLL subband only)

  1034         TUint16 tmp = PtrReadUtil::ReadBigEndianUint16Inc( iReader.iPtr );

  1035         qcdMarker->iExponent = HBufC8::NewL(1);

  1036         qcdMarker->iExponent->Des().Append( (TUint8)( (tmp >> 11) & 0x1f ) );

  1037         qcdMarker->iMantissa = HBufC16::NewL(1);

  1038         qcdMarker->iMantissa->Des().Append( (TUint16)( tmp & 0x07ff ) );

  1039         }

  1040     else

  1041         {

  1042         TInt entries = markerLength - ( iReader.iPtr - iReader.iPtrStartMarker ) + KMarkerSize;

  1043         if ( qcdMarker->iSqcd & 0x1f )

  1044             {

  1045             // Word oriented

  1046             TUint16 tmp;

  1047             qcdMarker->iExponent = HBufC8::NewL( entries / 2 );

  1048             qcdMarker->iMantissa = HBufC16::NewL( entries / 2 );

  1049 

  1050             while ( entries >= 2 )

  1051                 {

  1052                 tmp = PtrReadUtil::ReadBigEndianUint16Inc( iReader.iPtr );

  1053                 qcdMarker->iExponent->Des().Append((TUint8)( ( tmp >> 11) & 0x1f ) );

  1054                 qcdMarker->iMantissa->Des().Append((TUint16)( tmp & 0x07ff ) );

  1055                 entries -= 2;

  1056             }

  1057         }

  1058         else

  1059             {

  1060             // No quantization

  1061             qcdMarker->iExponent = HBufC8::NewL( entries );

  1062             while ( entries )

  1063                 {

  1064                 qcdMarker->iExponent->Des().Append( (TUint8)( ( *iReader.iPtr++ >> 3 ) & 0x1f ) );

  1065                 --entries;

  1066                 }

  1067             }

  1068         }

  1069 

  1070     // Make sure we read all the data

  1071     if ( ( iReader.iPtr - iReader.iPtrStartMarker ) != ( markerLength + KMarkerSize ) )

  1072         {

  1073         // We must be missing some data in the marker

  1074         User::Leave( KErrCorrupt );

  1075         }

  1076 

  1077     if ( !aMain )

  1078         {

  1079         CJ2kTileInfo& tile = CONST_CAST( CJ2kTileInfo&, iImageInfo->TileAt( iLastTileIndex ) );

  1080 

  1081         // Append QCD to the current tile and decrement the tile length

  1082         tile.AppendQCD( qcdMarker, markerLength + KMarkerSize );

  1083         CleanupStack::Pop();

  1084         }

  1085 

  1086     // Any valid marker may come after QCD marker

  1087     iFHState = EStateInUnknown;

  1088 

  1089     return EFrameComplete;

  1090     }

  1091 

  1092 // -----------------------------------------------------------------------------

  1093 // CJp2kReadCodec::ReadQCCL

  1094 // Verify and process Quantization Component (QCC marker).

  1095 // (other items were commented in a header).

  1096 // -----------------------------------------------------------------------------

  1097 //

  1098 TFrameState CJp2kReadCodec::ReadQCCL(TBool aMain)

  1099     {

  1100     if ( ( iReader.iPtrEnd - iReader.iPtr ) < KMarkerMinLength )

  1101         {

  1102         // Underflow

  1103         return EFrameIncomplete;

  1104         }

  1105 

  1106     if ( PtrReadUtil::ReadBigEndianUint16Inc( iReader.iPtr ) != KQCC )

  1107         {

  1108         // Unrecognized QCC marker

  1109         User::Leave( KErrCorrupt );

  1110         }

  1111 

  1112     TUint16 markerLength = PtrReadUtil::ReadBigEndianUint16Inc( iReader.iPtr );

  1113     if ( ( iReader.iPtrEnd - iReader.iPtr ) < (markerLength - KMarkerLength ) )

  1114         {

  1115         // Underflow, backup the iterator to the beginning of the marker

  1116         iReader.iPtr -= KMarkerMinLength;

  1117         return EFrameIncomplete;

  1118         }

  1119 

  1120     const TSizMarker& sizMarker = iImageInfo->SizMarker();

  1121 

  1122     TQCCMarker *qccMarker = new (ELeave) TQCCMarker;

  1123 

  1124     CleanupDeletePushL( qccMarker );

  1125 

  1126     if ( sizMarker.iCsiz < 257 )

  1127         {

  1128         // 8 bits component

  1129         qccMarker->iCqcc = *iReader.iPtr++;

  1130         }

  1131     else

  1132         {

  1133         // 16 bit component

  1134         qccMarker->iCqcc = PtrReadUtil::ReadBigEndianUint16Inc( iReader.iPtr );