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:  JPEG2000 image encoder/decoder plugin class.

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include "JP2KImageUtils.h"

    21 #include "JP2KFormat.h"

    22 #include "JP2KConvert.h"

    23 #include "JP2KStreamReader.h"

    24 #include "JP2KImageClientMain.h"

    25 #include "JP2KCodec.h"

    26 #include <barsc.h>

    27 #include <imageconversion.h>

    28 #include <barsread.h>

    29 #include <bautils.h>

    30 #include <e32math.h>

    31 #include <101F862D_extra.rsg>

    32 #include <icl/icl_uids.hrh>

    33 #include "JP2KUids.hrh"

    34 #include <JP2KImageData.h>

    35 

    36 // EXTERNAL DATA STRUCTURES

    37 

    38 // EXTERNAL FUNCTION PROTOTYPES  

    39 

    40 // CONSTANTS

    41 

    42 // MACROS

    43 

    44 // LOCAL CONSTANTS AND MACROS

    45 _LIT( KJ2KPanicCategory, "J2KConvertPlugin" );

    46 

    47 // MODULE DATA STRUCTURES

    48 

    49 // LOCAL FUNCTION PROTOTYPES

    50 

    51 // FORWARD DECLARATIONS

    52 

    53 // ============================ MEMBER FUNCTIONS ===============================

    54 

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

    56 // CJp2kDecoder::NewL

    57 // Two-phased constructor.

    58 // -----------------------------------------------------------------------------

    59 //

    60 CJp2kDecoder* CJp2kDecoder::NewL()

    61     {

    62     return new ( ELeave ) CJp2kDecoder;

    63     }

    64 

    65 // Destructor

    66 CJp2kDecoder::~CJp2kDecoder()

    67     {

    68     // Call base class Cleanup(), else there is a possibility

    69     // of memory leak

    70     CImageDecoderPlugin::Cleanup();

    71     }

    72 

    73 // -----------------------------------------------------------------------------

    74 // CJp2kDecoder::ImageType

    75 // Get the image type uid of this plugin.

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

    77 // -----------------------------------------------------------------------------

    78 //

    79 void CJp2kDecoder::ImageType( TInt aFrameNumber, TUid& aImageType, TUid& aImageSubType ) const

    80     {

    81     __ASSERT_ALWAYS( aFrameNumber == 0, Panic( EFrameNumberOutOfRange ) );

    82 

    83     TUid uid = {KImageTypeJ2KUid};

    84     aImageType = uid;

    85     aImageSubType = KNullUid;

    86     }

    87 

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

    89 // CJp2kDecoder::NumberOfImageComments

    90 // Get the number of image comment.

    91 // -----------------------------------------------------------------------------

    92 //

    93 TInt CJp2kDecoder::NumberOfImageComments() const

    94     {

    95     __ASSERT_ALWAYS( IsImageHeaderProcessingComplete(), Panic( EHeaderProcessingNotComplete ) );

    96 

    97     const TUid commentUid = { KJ2KCommentUid };

    98     const CFrameImageData& frameImageData = FrameData( 0 );

    99     const TInt imageDataCount = frameImageData.ImageDataCount();

   100     const TImageDataBlock *imageData = 0;

   101     TInt imageCommentCount = 0;

   102     for ( TInt index = 0; index < imageDataCount; ++index )

   103         {

   104         imageData = frameImageData.GetImageData( index );

   105         if ( imageData->DataType() == commentUid )

   106             {

   107             imageCommentCount++;

   108             }

   109         }

   110     return imageCommentCount;

   111     }

   112 

   113 // -----------------------------------------------------------------------------

   114 // CJp2kDecoder::ImageCommentL

   115 // Get the image comment.

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

   117 // -----------------------------------------------------------------------------

   118 //

   119 HBufC* CJp2kDecoder::ImageCommentL( TInt aCommentNumber ) const

   120     {

   121     __ASSERT_ALWAYS( IsImageHeaderProcessingComplete(), Panic( EHeaderProcessingNotComplete ) );

   122     __ASSERT_ALWAYS( ( aCommentNumber >= 0 ) && ( aCommentNumber < NumberOfImageComments() ), 

   123                      Panic( ECommentNumberOutOfRange ) );

   124     

   125     HBufC *comment = 0;

   126 

   127     if( FrameData( 0 ).ImageDataCount() > 0 )

   128         {

   129         const TUid commentUid = { KJ2KCommentUid };

   130         const CFrameImageData& frameImageData = FrameData( 0 );

   131         const TInt imageDataCount = frameImageData.ImageDataCount();

   132         const TImageDataBlock *imageData = 0;

   133         TInt commentCount = 0;

   134         for ( TInt index = 0; index < imageDataCount; ++index )

   135             {

   136             imageData = frameImageData.GetImageData( index );

   137             if ( imageData->DataType() == commentUid )

   138                 {

   139                 if ( commentCount == aCommentNumber )

   140                     {

   141                     index = imageDataCount; // Break from the for loop

   142                     }

   143                 else

   144                     {

   145                     commentCount++;

   146                     }

   147                 }

   148             }

   149 

   150         if( imageData != 0 )

   151             {

   152             const TJp2kComment *jp2kComment = STATIC_CAST( const TJp2kComment*, imageData );

   153             comment = HBufC::NewL( jp2kComment->iComment->Length() );

   154 

   155             // Create 16 bit copy of the 8 bit original

   156             comment->Des().Copy( *( jp2kComment->iComment ) );

   157             }

   158         }

   159     return comment;

   160     }

   161 

   162 // -----------------------------------------------------------------------------

   163 // CJp2kDecoder::NumberOfFrameComments

   164 // Get the number of frame comment.

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

   166 // -----------------------------------------------------------------------------

   167 //

   168 TInt CJp2kDecoder::NumberOfFrameComments( TInt aFrameNumber ) const

   169     {

   170     __ASSERT_ALWAYS( IsImageHeaderProcessingComplete(), Panic( EHeaderProcessingNotComplete ) );

   171     __ASSERT_ALWAYS( aFrameNumber == 0, Panic( EFrameNumberOutOfRange ) );

   172    

   173     return NumberOfImageComments();

   174     }

   175 

   176 // -----------------------------------------------------------------------------

   177 // CJp2kDecoder::FrameCommentL

   178 // Get the frame comment.

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

   180 // -----------------------------------------------------------------------------

   181 //

   182 HBufC* CJp2kDecoder::FrameCommentL( TInt aFrameNumber, TInt aCommentNumber ) const

   183     {

   184     __ASSERT_ALWAYS( IsImageHeaderProcessingComplete(), Panic( EHeaderProcessingNotComplete ) );

   185     __ASSERT_ALWAYS( aFrameNumber == 0, Panic( EFrameNumberOutOfRange ) );

   186 

   187     return ImageCommentL( aCommentNumber );

   188     }

   189 

   190 // -----------------------------------------------------------------------------

   191 // CJp2kDecoder::FrameInfoStringsL

   192 // Retrieve frame information and format it according to info stored in .rss file.

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

   194 // -----------------------------------------------------------------------------

   195 //

   196 CFrameInfoStrings* CJp2kDecoder::FrameInfoStringsL( RFs& aFs, TInt aFrameNumber )

   197     {

   198     const TUid KJp2kCodecDllUid = { KJ2KCodecDllUidValue };

   199 

   200     RResourceFile resourceFile;

   201     OpenExtraResourceFileLC( aFs, KJp2kCodecDllUid, resourceFile );

   202 

   203     HBufC8* resourceInfo = resourceFile.AllocReadLC( THEDECODERINFO );

   204     TResourceReader resourceReader;

   205     resourceReader.SetBuffer( resourceInfo );

   206 

   207     TBuf<KCodecResourceStringMax> info;

   208     TBuf<KCodecResourceStringMax> templte;

   209 

   210     const TFrameInfo& frameInfo = FrameInfo( aFrameNumber );

   211     CFrameInfoStrings* frameInfoStrings = CFrameInfoStrings::NewLC();

   212 

   213     info = resourceReader.ReadTPtrC();

   214     frameInfoStrings->SetDecoderL( info );

   215 

   216     info = resourceReader.ReadTPtrC();

   217     frameInfoStrings->SetFormatL( info );

   218 

   219     TInt width = frameInfo.iOverallSizeInPixels.iWidth;

   220     TInt height = frameInfo.iOverallSizeInPixels.iHeight;

   221     TInt depth = frameInfo.iBitsPerPixel;

   222 

   223     templte = resourceReader.ReadTPtrC();

   224     info.Format( templte, width, height );

   225     frameInfoStrings->SetDimensionsL( info );

   226 

   227     CDesCArrayFlat* resourceArray = resourceReader.ReadDesCArrayL();

   228     CleanupStack::PushL( resourceArray );

   229     TUint formatIndex = ( frameInfo.iFlags & TFrameInfo::EColor ) ? 1 : 0;

   230     templte = ( *resourceArray )[formatIndex];

   231     CleanupStack::PopAndDestroy( resourceArray );

   232     info.Format( templte, depth );

   233     frameInfoStrings->SetDepthL( info );

   234 

   235     resourceArray = resourceReader.ReadDesCArrayL();

   236     CleanupStack::PushL( resourceArray );

   237     formatIndex = 0;

   238     info = ( *resourceArray )[formatIndex];

   239     CleanupStack::PopAndDestroy( resourceArray );

   240     frameInfoStrings->SetDetailsL( info );

   241 

   242     CleanupStack::Pop( frameInfoStrings );

   243     CleanupStack::PopAndDestroy( 2 ); // resourceInfo + resourceFile

   244     return frameInfoStrings;

   245     }

   246 

   247 // -----------------------------------------------------------------------------

   248 // CJp2kDecoder::FrameHeaderBlockSize

   249 // Returns the frame header block size.

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

   251 // -----------------------------------------------------------------------------

   252 //

   253 TInt CJp2kDecoder::FrameHeaderBlockSize( TInt aFrameNumber ) const

   254     {

   255     __ASSERT_ALWAYS( aFrameNumber == 0, Panic( EFrameNumberOutOfRange ) );

   256 

   257     return KJ2kInputBufferSize;

   258     }

   259 

   260 // -----------------------------------------------------------------------------

   261 // CJp2kDecoder::FrameBlockSize

   262 // Returns the frame block size.

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

   264 // -----------------------------------------------------------------------------

   265 //

   266 TInt CJp2kDecoder::FrameBlockSize(TInt aFrameNumber) const

   267     {

   268     __ASSERT_ALWAYS( aFrameNumber == 0, Panic( EFrameNumberOutOfRange ) );

   269 

   270     return KJ2kInputBufferSize;

   271     }

   272 

   273 // -----------------------------------------------------------------------------

   274 // CJp2kDecoder::DoConvert

   275 // Override the default DoConvert to split out the parsing and decoding

   276 // process into multiple steps.

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

   278 // -----------------------------------------------------------------------------

   279 //

   280 void CJp2kDecoder::DoConvert()

   281     {

   282     TFrameState codecState = EFrameIncomplete;

   283     TInt errCode = KErrNone;

   284 

   285     CJp2kReadCodec *j2kCodec = static_cast<CJp2kReadCodec*>( ImageReadCodec() );

   286 

   287     if ( !j2kCodec->IsDecodeTile() )

   288         {

   289         // parsing of a tile-part

   290         TRAP( errCode, PrepareForProcessFrameL() );

   291         if ( errCode != KErrNone )

   292             {

   293             RequestComplete( errCode );

   294             return;

   295             }

   296 

   297         TBufPtr8& sourceData = SourceData();

   298         TInt sourceLength = sourceData.Length();

   299         if ( sourceLength != 0 )

   300             {

   301             TRAP( errCode, codecState = j2kCodec->ProcessFrameL( sourceData ) );

   302             

   303             if ( j2kCodec->IsDecodeTile() )

   304                 {

   305                 // tile-part contains all compressed data

   306                 // and proceed to the decoding

   307                 SelfComplete( KErrNone );

   308                 return;

   309                 }

   310             }

   311         // continue on parsing the tile-part

   312         HandleProcessFrameResult( errCode, codecState );

   313         }

   314     else

   315         {

   316         // decoding of the tile-part

   317         TRAP( errCode, codecState = j2kCodec->DecodeTileL() );

   318 

   319         if ( errCode == KErrNone )

   320             {

   321             if ( j2kCodec->IsDecodeTile() )

   322                 {

   323                 // continue on decoding the tile-part

   324                 // if we split the decoding into multiple steps

   325                 SelfComplete( KErrNone );

   326                 return;

   327                 }

   328             }

   329         // either continue on parsing the next tile-part

   330         // or done with the whole image

   331         HandleProcessFrameResult( errCode, codecState );

   332         }

   333     }

   334 

   335 // -----------------------------------------------------------------------------

   336 // CJp2kDecoder::CJp2kDecoder

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

   338 // might leave.

   339 // -----------------------------------------------------------------------------

   340 //

   341 CJp2kDecoder::CJp2kDecoder()

   342     {

   343     }  

   344 

   345 // -----------------------------------------------------------------------------

   346 // CJp2kDecoder::ReadFormatL

   347 // JP2 File Format detection state machine.

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

   349 // -----------------------------------------------------------------------------

   350 //

   351 void CJp2kDecoder::ReadFormatL()

   352     {

   353     // Verify the JP2 file format if it exist

   354     iCallFromFramework = ETrue;

   355 

   356     while ( iState != EStateInCodestreamBox )

   357         {

   358         switch ( iState )

   359             {

   360             case EStateInSignatureBox:

   361                 {

   362                 ReadSignatureBoxL();

   363                 break;

   364                 }

   365             case EStateInFileTypeBox:

   366                 {

   367                 ReadFileTypeBoxL();

   368                 break;

   369                 }

   370             case EStateInJP2SuperBox:

   371                 {

   372                 ReadJp2HeaderBoxL();

   373                 break;

   374                 }

   375             case EStateInIPRBox:

   376                 {

   377                 ReadIPRBoxL();

   378                 break;

   379                 }

   380             case EStateInXMLBox:

   381                 {

   382                 ReadXMLBoxL();

   383                 break;

   384                 }

   385             case EStateInUUIDBox:

   386                 {

   387                 ReadUUIDBoxL();

   388                 break;

   389                 }

   390             case EStateInUUIDInfoBox:

   391                 {

   392                 ReadUUIDInfoBoxL();

   393                 break;

   394                 }

   395             case EStateInUnknown:

   396                 {

   397                 if ( iCallFromFramework )

   398                     {

   399                     // Always read the length and type of the box

   400                     ReadDataL( iLastRead, iBufferDes, KJ2kBoxTypeLength );

   401 

   402                     if ( (TUint32)iBufferDes.Length() < KJ2kBoxTypeLength )

   403                         {

   404                         if ( ( iJ2kInfo.iCSOffset != 0 ) && 

   405                              ( (TUint32)iBufferDes.Length() == 0 ) )

   406                             {

   407                             // We have reach the end of file/stream and 

   408                             // CodeStream box has been recognized

   409                             iState = EStateInCodestreamBox;

   410                             }

   411                         else

   412                             {

   413                             // Need more data from the ICL framework

   414                             User::Leave( KErrUnderflow );

   415                             }

   416                         }

   417                     iPtr = iBufferDes.Ptr();

   418                     }

   419 

   420                 if ( iState != EStateInCodestreamBox )

   421                     {

   422                     // Length and Type of next box

   423                     iBoxLength = PtrReadUtil::ReadBigEndianUint32Inc( iPtr );

   424                     iBoxType = PtrReadUtil::ReadBigEndianUint32( iPtr );

   425 

   426                     // Update the internal state based on the iBoxType

   427                     UpdateStateFromBoxTypeL();

   428 

   429                     if ( iState != EStateInCodestreamBox )

   430                         {

   431                         // Corrupted box length

   432                         if ( ( (TInt32)iBoxLength ) < 0 )

   433                             {

   434                             User::Leave( KErrCorrupt );

   435                             }

   436                         }

   437                     }

   438                 break;

   439                 }

   440             default:

   441                 {

   442                 break;

   443                 }

   444             }

   445         iCallFromFramework = EFalse;

   446         }

   447 

   448     // When the code reach here, it means that we have found the 

   449     // codestream box in JP2 file format or the codestream SOC itself

   450     // in case of the JP2 file format, all the boxes after the

   451     // codestream box will not be read and parsed.

   452     

   453     // In JP2 file format, iLastRead points to codestream box

   454     // in JP2 codestream, iLastRead points to SOC marker

   455     // it is the offset that ICL framework used to read

   456     // in more data from the image file.

   457     SetStartPosition( iJ2kInfo.iCSOffset );

   458 

   459     // Always set the image data length to KMaxTInt32

   460     SetDataLength( KMaxTInt );

   461 

   462     // Fill up the image related information, if it is

   463     // in JP2 file format, else defer the setting of the

   464     // image info til SIZ marker in the codestream has

   465     // been processed.

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

   467         {

   468         TFrameInfo& imageInfo = CONST_CAST( TFrameInfo&, ImageInfo() );

   469         imageInfo.iOverallSizeInPixels = iJ2kInfo.iImageSize;

   470         imageInfo.iFrameCoordsInPixels.SetRect( TPoint( 0, 0 ), iJ2kInfo.iImageSize );

   471         imageInfo.iFrameSizeInTwips = iJ2kInfo.iImageSizeInTwips;

   472 

   473         if ( iJ2kInfo.iBPCList.Count() > 0 )

   474             {

   475             // Calculate based on the bitdepth per component

   476             for ( TUint16 index = 0; index < iJ2kInfo.iNC; ++index )

   477                 {

   478                 imageInfo.iBitsPerPixel += ( ( 0x7f & iJ2kInfo.iBPCList[index] ) + 1 );

   479                 }

   480             }

   481         else

   482             {            

   483             if ( iJ2kInfo.iBPC == KJ2kIsBPCBoxExist )

   484                 {

   485                 User::Leave( KErrCorrupt );

   486                 }

   487 

   488             // Has the same bitdepth on each component

   489             imageInfo.iBitsPerPixel = ( ( 0x7f & iJ2kInfo.iBPC ) + 1 ) * iJ2kInfo.iNC;

   490             }

   491         imageInfo.iFlags |= TFrameInfo::ECanDither;

   492 

   493         // Decoder is able to handle scaleable resolution

   494         imageInfo.iFlags |= TFrameInfo::EConstantAspectRatio;

   495 

   496         if ( iJ2kInfo.iEnumCS != KJ2kColourSpecGrayScale )

   497             {

   498             imageInfo.iFlags |= TFrameInfo::EColor;

   499             }

   500         

   501         // No animation.

   502         imageInfo.iDelay = 0;

   503 

   504         switch ( imageInfo.iBitsPerPixel )

   505             {

   506             case 1:

   507                 {

   508                 imageInfo.iFrameDisplayMode = EGray2;

   509                 break;

   510                 }

   511             case 2:

   512                 {

   513                 imageInfo.iFrameDisplayMode = EGray4;

   514                 break;

   515                 }

   516             case 4:

   517                 {

   518                 imageInfo.iFrameDisplayMode = ( imageInfo.iFlags & TFrameInfo::EColor ) ? EColor16 : EGray16;

   519                 break;

   520                 }

   521             case 8:

   522                 {

   523                 imageInfo.iFrameDisplayMode = ( imageInfo.iFlags & TFrameInfo::EColor ) ? EColor16M : EGray256;

   524                 break;

   525                 }

   526             case 12:

   527                 {

   528                 imageInfo.iFrameDisplayMode = ( imageInfo.iFlags & TFrameInfo::EColor ) ? EColor4K : EGray256;

   529                 break;

   530                 }

   531             case 16:

   532                 {

   533                 imageInfo.iFrameDisplayMode = EColor64K;

   534                 break;

   535                 }

   536             case 24:

   537                 {

   538                 imageInfo.iFrameDisplayMode = EColor16M;

   539                 break;

   540                 }

   541             default:

   542                 {

   543                 imageInfo.iFrameDisplayMode = EColor64K;

   544                 break;

   545                 }

   546             }

   547         }

   548     }

   549 

   550 // -----------------------------------------------------------------------------

   551 // CJp2kDecoder::ReadSignatureBoxL

   552 // Verify and process the Signature box.

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

   554 // -----------------------------------------------------------------------------

   555 //

   556 void CJp2kDecoder::ReadSignatureBoxL(  )

   557     {

   558     // Validate the Signature Box

   559     __ASSERT_ALWAYS( iLastRead == 0, Panic( EInvalidState ) );

   560 

   561     // Read the Signature box + the next box's Length and Type

   562     ReadDataL( iLastRead, iBufferDes, KJ2kFileInformationSize );

   563 

   564     if ( (TUint32)iBufferDes.Length() < KJ2kSigBoxLength )

   565         {

   566         // Need more data from the ICL framework

   567         User::Leave( KErrUnderflow );

   568         }

   569 

   570     iPtr = iBufferDes.Ptr();

   571 

   572     if ( ( PtrReadUtil::ReadBigEndianUint32Inc( iPtr ) != KJ2kSigBoxLength ) ||

   573          ( PtrReadUtil::ReadBigEndianUint32Inc( iPtr ) != KJ2kSigBoxType )   ||

   574          ( PtrReadUtil::ReadBigEndianUint32Inc( iPtr ) != KJ2kSigBoxContent ) )

   575         {

   576         // Unrecognized signature box

   577         User::Leave( KErrCorrupt );

   578         }

   579 

   580     // File Type box shall immediately follow the Signature box

   581     iLastRead = KJ2kSigBoxLength;

   582     iState = EStateInFileTypeBox;

   583 

   584     // JP2 file format

   585     iJ2kInfo.iOption |= TJ2kInfo::EJP2file;

   586 

   587     if ( iBufferDes.Length() < KJ2kFileInformationSize )

   588         {

   589         // Need more data from the ICL framework

   590         User::Leave( KErrUnderflow );

   591         }

   592     }

   593 

   594 // -----------------------------------------------------------------------------

   595 // CJp2kDecoder::ReadFileTypeBoxL

   596 // Verify and process the File Type box.

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

   598 // -----------------------------------------------------------------------------

   599 //

   600 void CJp2kDecoder::ReadFileTypeBoxL()

   601     {

   602     // Validate the File Type Box's Length and Type

   603     if ( iCallFromFramework )

   604         {

   605         __ASSERT_ALWAYS( iLastRead == KJ2kSigBoxLength, Panic( EInvalidState ) );

   606 

   607         ReadDataL( iLastRead, iBufferDes, KJ2kBoxTypeLength );

   608 

   609         if ( (TUint32)iBufferDes.Length() < KJ2kBoxTypeLength )

   610             {

   611             // Need more data from the ICL framework

   612             User::Leave( KErrUnderflow );

   613             }

   614 

   615         iPtr = iBufferDes.Ptr();

   616         }

   617 

   618     iBoxLength = PtrReadUtil::ReadBigEndianUint32Inc( iPtr );

   619     iBoxType = PtrReadUtil::ReadBigEndianUint32( iPtr );

   620 

   621     if ( ( (TInt32)iBoxLength ) <= 0 || iBoxType != KJ2kFileTypeBox || iBoxLength > KJ2kFileTypeBoxMaxLength )

   622         {

   623         // Unrecognized file type box or corrupted box length

   624         User::Leave( KErrCorrupt );

   625         }

   626 

   627     TUint8 xlBoxExist = 0;

   628     if ( iBoxLength == 1 )

   629         {

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

   631         // XLBox is 8 bytes width

   632         ReadDataL( iLastRead + KJ2kBoxTypeLength, iBufferDes, KJ2kBoxTypeLength );

   633 

   634         if ( (TUint32)iBufferDes.Length() < KJ2kBoxTypeLength )

   635             {

   636             // Need more data from the ICL framework

   637             User::Leave( KErrUnderflow );

   638             }

   639 

   640         iPtr = iBufferDes.Ptr();

   641         iBoxLength = PtrReadUtil::ReadBigEndianUint32Inc( iPtr );

   642         iBoxLength += PtrReadUtil::ReadBigEndianUint32( iPtr );

   643         xlBoxExist = 1;

   644         }

   645 

   646     if ( ( (TInt32)iBoxLength ) <= 0 || ( ( (TInt32)iBoxLength - 16 ) / 4 ) <= 0 )

   647         {

   648         // Must include at least one CL field in the Compatibility list

   649         User::Leave( KErrCorrupt );

   650         }

   651 

   652     // Read the File Type box + the next box's Length and Type

   653     ReadDataL( iLastRead + KJ2kBoxTypeLength, iBufferDes, iBoxLength );

   654 

   655     if ( (TUint32)iBufferDes.Length() < iBoxLength - KJ2kBoxTypeLength )

   656         {

   657         // Need more data from the ICL framework

   658         User::Leave( KErrUnderflow );

   659         }

   660 

   661     iPtr = iBufferDes.Ptr();

   662 

   663     // Substract next box's KJ2kBoxTypeLength

   664     const TUint8 *ptrLimit = iPtr + iBoxLength - KJ2kBoxTypeLength;

   665 

   666     // Advance the pointer by 8 bytes if XLBox exists

   667     iPtr += ( xlBoxExist * KJ2kBoxTypeLength );

   668 

   669     // Check Brand ( BR ) or Major Version

   670     if ( PtrReadUtil::ReadBigEndianUint32Inc( iPtr ) != KJ2kFileTypeBrand )

   671         {

   672         // It is ok at this point if Major Version does not match

   673         iPtr += 0;

   674         }

   675 

   676     // Check Minor Version ( MinV )

   677     if ( PtrReadUtil::ReadBigEndianUint32Inc( iPtr ) != KJ2kFileTypeMinV )

   678         {

   679         // It is ok at this point if Minor Version does not match

   680         iPtr += 0;

   681         }

   682 

   683     // Check Compatibility List ( CL )

   684     TBool clFound = EFalse;

   685     TUint32 clField = 0;

   686     while ( ( iPtr + 4 ) <= ptrLimit  )

   687         {

   688         clField = PtrReadUtil::ReadBigEndianUint32Inc( iPtr );

   689         if ( clField == KJ2kFileTypeBrand )

   690             {

   691             clFound = ETrue;

   692             }

   693         else if ( clField == KJ2kFileTypeProfile0 )

   694             {

   695             iJ2kInfo.iOption |= TJ2kInfo::EProfile0;

   696             }

   697         else if ( clField == KJ2kFileTypeProfile1 )

   698             {

   699             iJ2kInfo.iOption |= TJ2kInfo::EProfile1;

   700             }

   701         else

   702             {

   703             // other file types require no action

   704             }

   705         }

   706 

   707     if ( !clFound || iPtr != ptrLimit )

   708         {

   709         // Unrecognized compatibility list or data misaligned

   710         User::Leave( KErrCorrupt );

   711         }

   712 

   713     iLastRead += iBoxLength;

   714     iState = EStateInUnknown;

   715 

   716     if ( (TUint32)iBufferDes.Length() < iBoxLength )

   717         {

   718         // Need more data from the ICL framework

   719         User::Leave( KErrUnderflow );

   720         }

   721     }

   722 

   723 // -----------------------------------------------------------------------------

   724 // CJp2kDecoder::ReadJp2HeaderBoxL

   725 // Verify and process the JP2 Header box ( superbox ).

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

   727 // -----------------------------------------------------------------------------

   728 //

   729 void CJp2kDecoder::ReadJp2HeaderBoxL()

   730     {

   731     // Since we are getting data from ICL framework

   732     // we have no control of when will be the EOF

   733     if ( iBoxLength == 0 )

   734         {

   735         User::Leave( KErrCorrupt );

   736         }

   737 

   738     TUint8 xlBoxExist = 0;

   739     if ( iBoxLength == 1 )

   740         {

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

   742         // XLBox is 8 bytes width

   743         ReadDataL( iLastRead + KJ2kBoxTypeLength, iBufferDes, KJ2kBoxTypeLength );

   744 

   745         if ( (TUint32)iBufferDes.Length() < KJ2kBoxTypeLength )

   746             {

   747             // Need more data from the ICL framework

   748             User::Leave( KErrUnderflow );

   749             }

   750 

   751         iPtr = iBufferDes.Ptr();

   752         iBoxLength = PtrReadUtil::ReadBigEndianUint32Inc( iPtr );

   753         iBoxLength += PtrReadUtil::ReadBigEndianUint32( iPtr );

   754         xlBoxExist = 1;

   755         }

   756 

   757     // Corrupted box length

   758     if ( ( (TInt32)iBoxLength ) <= 0 )

   759         {

   760         User::Leave( KErrCorrupt );

   761         }

   762 

   763     // Validate the JP2 Header Super Box

   764     // Read the JP2 box + the next box's Length and Type

   765     ReadDataL( iLastRead + KJ2kBoxTypeLength, iBufferDes, iBoxLength );

   766 

   767     if ( (TUint32)iBufferDes.Length() < iBoxLength - KJ2kBoxTypeLength )

   768         {

   769         // Need more data from the ICL framework

   770         User::Leave( KErrUnderflow );

   771         }

   772 

   773     // Make sure that JP2 Header box contains enough data

   774     // for Image Header box

   775     if ( iBoxLength - KJ2kBoxTypeLength < KJ2kImageHeaderBoxLength )

   776         {

   777         // Missing Image Header box

   778         User::Leave( KErrCorrupt );

   779         }

   780 

   781     iPtr = iBufferDes.Ptr();

   782 

   783     // Advance the pointer by 8 bytes if XLBox exists

   784     iPtr += ( xlBoxExist * KJ2kBoxTypeLength );

   785 

   786     // Image Header box shall be the first box within JP2 Header box

   787     ReadImageHeaderBoxL();

   788 

   789     TUint32 subBoxLength = 0;

   790     TUint32 subBoxType = 0;

   791 

   792     // Substract next box's Length and Type

   793     const TUint8 *ptrLimit = iPtr + iBoxLength - KJ2kBoxTypeLength - KJ2kImageHeaderBoxLength;

   794     TInt32 length = ptrLimit - iPtr;

   795     TBool  csFound = EFalse;

   796 

   797     while ( length > 0 )

   798         {

   799         if ( ( ptrLimit - iPtr ) < 8  )

   800             {

   801             // Not enough room for box data

   802             User::Leave( KErrCorrupt );

   803             }

   804 

   805         subBoxLength = PtrReadUtil::ReadBigEndianUint32Inc( iPtr );

   806         subBoxType = PtrReadUtil::ReadBigEndianUint32Inc( iPtr );

   807 

   808         if ( subBoxLength == 1 )

   809             {

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

   811             // XLBox is 8 bytes width

   812             subBoxLength = PtrReadUtil::ReadBigEndianUint32Inc( iPtr );

   813             subBoxLength += PtrReadUtil::ReadBigEndianUint32Inc( iPtr );

   814             length -= KJ2kBoxTypeLength;

   815             subBoxLength -= KJ2kBoxTypeLength;

   816             }

   817 

   818         if ( ( (TInt32)subBoxLength ) < 0 || ( subBoxLength <= 8 ) || ( ( iPtr + subBoxLength - KJ2kBoxTypeLength ) > ptrLimit ) )

   819             {

   820             // Not enough room for subbox data or corrupted subbox length

   821             User::Leave( KErrCorrupt );

   822             }

   823 

   824         switch ( subBoxType )

   825             {

   826             case KJ2kColourSpecBoxType:

   827                 {

   828                 if ( !csFound )

   829                     {

   830                     // Colour Spec Box

   831                     ReadColorSpecBoxL( subBoxLength );

   832                     csFound = ETrue;

   833                     }

   834                 else

   835                     {

   836                     // Ignore the second Colour Spec Box,

   837                     // just advance the iterator pointer

   838                     iPtr += subBoxLength - KJ2kBoxTypeLength;

   839                     }

   840                 break;

   841                 }

   842             case KJ2kResolutionBoxType:

   843                 {

   844                 // Resolution box ( superbox )

   845                 ReadResolutionBoxL( ptrLimit, subBoxLength );

   846                 break;

   847                 }

   848             case KJ2kBitsPerCompBoxType:

   849                 {

   850                 // Bits Per Component Box

   851                 ReadBitsPerCompBoxL( subBoxLength );

   852                 break;

   853                 }

   854             case KJ2kPaletterBoxType:

   855                 {

   856                 // Palette Box

   857                 ReadPaletteBoxL();

   858                 break;

   859                 }

   860             case KJ2kComponentMapBoxType:

   861                 {

   862                 // Component Mapping Box

   863                 ReadComponentMapBoxL( subBoxLength );

   864                 break;

   865                 }

   866             case KJ2kChannelDefBoxType:

   867                 {

   868                 // Channel Definition Box

   869                 ReadChannelDefBoxL( subBoxLength );

   870                 break;

   871                 }

   872             default:

   873                 {

   874                 // Unrecognized Box

   875                 User::Leave( KErrCorrupt );

   876                 break;

   877                 }

   878             }

   879         length -= subBoxLength;

   880         }

   881 

   882     iLastRead += iBoxLength;

   883     iState = EStateInUnknown;

   884 

   885     // JP2 Header processed

   886     iJ2kInfo.iOption |= TJ2kInfo::EJP2Header;

   887 

   888     if ( (TUint32)iBufferDes.Length() < iBoxLength )

   889         {

   890         // Need more data from the ICL framework

   891         User::Leave( KErrUnderflow );

   892         }

   893     }

   894 

   895 // -----------------------------------------------------------------------------

   896 // CJp2kDecoder::ReadImageHeaderBoxL

   897 // Verify and process the Image Header box ( in JP2 Header box ).

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

   899 // -----------------------------------------------------------------------------

   900 //

   901 void CJp2kDecoder::ReadImageHeaderBoxL()

   902     {

   903     // Validate the Image Header Box

   904     if ( ( PtrReadUtil::ReadBigEndianUint32Inc( iPtr ) != KJ2kImageHeaderBoxLength ) ||

   905          ( PtrReadUtil::ReadBigEndianUint32Inc( iPtr ) != KJ2kImageHeaderBoxType ) )

   906         {

   907         // Unrecognized Image Header box

   908         User::Leave( KErrCorrupt );

   909         }

   910 

   911     iJ2kInfo.iImageSize.iHeight = (TInt)PtrReadUtil::ReadBigEndianUint32Inc( iPtr );

   912     iJ2kInfo.iImageSize.iWidth = (TInt)PtrReadUtil::ReadBigEndianUint32Inc( iPtr );

   913     iJ2kInfo.iNC  = PtrReadUtil::ReadBigEndianUint16Inc( iPtr );

   914     iJ2kInfo.iBPC = *iPtr++;

   915 

   916     if ( (iJ2kInfo.iImageSize.iHeight <= 0) || (iJ2kInfo.iImageSize.iWidth <= 0) ||

   917          (iJ2kInfo.iNC == 0) || (iJ2kInfo.iBPC == 0) )

   918         {

   919         // Corrupted image parameters

   920         User::Leave( KErrCorrupt );

   921         }

   922 

   923     if ( *iPtr++ != KJ2kImageHeaderCompressionType )

   924         {

   925         // Unrecognized compression type

   926         User::Leave( KErrCorrupt );

   927         }

   928 

   929     // Check color space - UnkC

   930     TUint8 value = *iPtr++;

   931     if ( value == 0 || value == 1 )

   932         {

   933         iJ2kInfo.iOption |= ( value == 0 ) ? TJ2kInfo::EColorSpec : 0;

   934         }

   935     else

   936         {

   937         // Unrecognized color space

   938         User::Leave( KErrCorrupt );

   939         }

   940 

   941     // Check intellectual property - IPR 

   942     value = *iPtr++;

   943     if ( value == 0 || value == 1 )

   944         {

   945         iJ2kInfo.iOption |= value;

   946         }

   947     else

   948         {

   949         // Unrecognized intellectual property

   950         User::Leave( KErrCorrupt );

   951         }

   952     }

   953 

   954 // -----------------------------------------------------------------------------

   955 // CJp2kDecoder::ReadColorSpecBoxL

   956 // Verify and process the Colour Specification box ( in JP2 Header box ).

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

   958 // -----------------------------------------------------------------------------

   959 //

   960 void CJp2kDecoder::ReadColorSpecBoxL( const TUint32 aBoxLength )

   961     {

   962     // Validate the Color Specification Box

   963     TUint8 method = *iPtr++;

   964 

   965     if ( method != 1 && method != 2 )

   966         {

   967         // Unrecognized method

   968         User::Leave( KErrCorrupt );

   969         }

   970 

   971     // Ignore the precedence

   972     iPtr++;

   973 

   974     // Ignore the approximation

   975     iPtr++;

   976 

   977     if ( method == 1 )

   978         {

   979         // Method must be 1 if we reach this point

   980         iJ2kInfo.iEnumCS = PtrReadUtil::ReadBigEndianUint32Inc( iPtr );

   981         switch ( iJ2kInfo.iEnumCS )

   982             {

   983             case 16:

   984             case 17:

   985             case 18:

   986             case 21:

   987             case 22:

   988                 {

   989                 break;

   990                 }

   991             default:

   992                 {

   993                 // Unrecognized colour specification

   994                 User::Leave( KErrNotSupported );

   995                 break;

   996                 }

   997             }

   998         }

   999     else

  1000         {

  1001         // ICC profile

  1002         TUint32 length = (TUint32)( aBoxLength - KJ2kBoxTypeLength - 3 );

  1003         iJ2kInfo.iICCProfile = HBufC8::NewL( length );

  1004         iJ2kInfo.iICCProfile->Des().Append( iPtr, length );

  1005         iPtr += length;

  1006         }

  1007     }

  1008 

  1009 // -----------------------------------------------------------------------------

  1010 // CJp2kDecoder::ReadBitsPerCompBoxL

  1011 // Verify and process the Bits Per Component box ( in JP2 Header box ).

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

  1013 // -----------------------------------------------------------------------------

  1014 //

  1015 void CJp2kDecoder::ReadBitsPerCompBoxL( TUint32 aBoxLength )

  1016     {

  1017     if ( iJ2kInfo.iBPC != KJ2kIsBPCBoxExist )

  1018         {

  1019         // Should not happen but we just advance 

  1020         // the iterator and ignore the whole box

  1021         iPtr += aBoxLength - KJ2kBoxTypeLength;

  1022         return;

  1023         }

  1024 

  1025     // Validate the Bits Per Component Box

  1026     if ( ( aBoxLength - KJ2kBoxTypeLength ) != iJ2kInfo.iNC  )

  1027         {

  1028         // Unrecognized number of components

  1029         User::Leave( KErrCorrupt );

  1030         }

  1031 

  1032     while ( aBoxLength > KJ2kBoxTypeLength )

  1033         {

  1034         User::LeaveIfError( iJ2kInfo.iBPCList.Append( *iPtr++ ) );

  1035 

  1036         --aBoxLength;

  1037         }

  1038     }

  1039 

  1040 // -----------------------------------------------------------------------------

  1041 // CJp2kDecoder::ReadResolutionBoxL

  1042 // Verify and process the Resolution box ( in JP2 Header box, 

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

  1044 // -----------------------------------------------------------------------------

  1045 //

  1046 void CJp2kDecoder::ReadResolutionBoxL( const TUint8 *aPtrLimit, TUint32 aBoxLength )

  1047     {

  1048     TUint32 subBoxLength = 0;

  1049     TUint32 subBoxType = 0;

  1050 

  1051     aBoxLength -= KJ2kBoxTypeLength;

  1052     while ( aBoxLength > 0 )

  1053         {

  1054         if ( (TUint32)( aPtrLimit - iPtr ) < KJ2kResSubBoxLength )

  1055             {

  1056             // Not enough room for subbox data

  1057             User::Leave( KErrCorrupt );

  1058             }

  1059 

  1060         subBoxLength = PtrReadUtil::ReadBigEndianUint32Inc( iPtr );

  1061         subBoxType = PtrReadUtil::ReadBigEndianUint32Inc( iPtr );

  1062 

  1063         if ( subBoxLength == 1 )

  1064             {

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

  1066             // XLBox is 8 bytes width

  1067             subBoxLength = PtrReadUtil::ReadBigEndianUint32Inc( iPtr );

  1068             subBoxLength += PtrReadUtil::ReadBigEndianUint32Inc( iPtr );

  1069             aBoxLength -= KJ2kBoxTypeLength;

  1070             subBoxLength -= KJ2kBoxTypeLength;

  1071             }

  1072 

  1073         if ( subBoxLength != KJ2kResSubBoxLength )

  1074             {

  1075             // Corrupted resolution box length, both sub boxes have length of 18

  1076             User::Leave( KErrCorrupt );

  1077             }

  1078 

  1079         if ( subBoxType == KJ2kCaptureResBoxType )

  1080             {

  1081             ReadCaptureResBoxL( subBoxLength );

  1082             }

  1083         else if ( subBoxType == KJ2kDisplayResBoxType )

  1084             {

  1085             ReadDisplayResBoxL(  );

  1086             }

  1087         else

  1088             {

  1089             // Unrecognized box in Resolution super box

  1090             User::Leave( KErrCorrupt );

  1091             }

  1092         aBoxLength -= subBoxLength;

  1093         }

  1094     }

  1095 

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

  1097 // CJp2kDecoder::ReadDisplayResBoxL

  1098 // Verify and process the Default Display Resolution box ( in Resolution box ).

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

  1100 // -----------------------------------------------------------------------------

  1101 //

  1102 void CJp2kDecoder::ReadDisplayResBoxL()

  1103     {

  1104     // Store default display resolution

  1105     TUint16 verNum = PtrReadUtil::ReadBigEndianUint16Inc( iPtr );

  1106     TUint16 verDen = PtrReadUtil::ReadBigEndianUint16Inc( iPtr );

  1107     TUint16 horNum = PtrReadUtil::ReadBigEndianUint16Inc( iPtr );

  1108     TUint16 horDen = PtrReadUtil::ReadBigEndianUint16Inc( iPtr );

  1109     TUint8  verExp = *iPtr++;

  1110     TUint8  horExp = *iPtr++;

  1111     TReal   tenPow = 0.0;

  1112 

  1113     // Check  the validity of the parameters

  1114     if((verNum == 0) || (verDen == 0) || (horNum == 0) || (horDen == 0))

  1115         {

  1116         // Values corrupted, do not try to compute the SizeInTwips

  1117         return;

  1118         }

  1119 

  1120     User::LeaveIfError( Math::Pow10( tenPow, verExp ) );

  1121 

  1122     TReal result = ( iJ2kInfo.iImageSize.iWidth / ( ( (TReal)verNum / verDen ) * tenPow ) ) / KJ2kTwipM;

  1123     iJ2kInfo.iImageSizeInTwips.iWidth = (TInt)result;

  1124 

  1125     User::LeaveIfError( Math::Pow10( tenPow,horExp ) );

  1126 

  1127     result = ( iJ2kInfo.iImageSize.iHeight / ( ( (TReal)horNum / horDen ) * tenPow ) ) / KJ2kTwipM;

  1128     iJ2kInfo.iImageSizeInTwips.iHeight = (TInt)result;

  1129     }

  1130 

  1131 // -----------------------------------------------------------------------------

  1132 // CJp2kDecoder::ReadCaptureResBoxL

  1133 // Verify and process the Capture Resolution box ( in Resolution box ).

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

  1135 // -----------------------------------------------------------------------------