1 // Copyright (c) 1999-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include <barsc.h>

    17 #include <barsread.h>

    18 #include <bautils.h>

    19 #include <imageconversion.h>

    20 #include "icl/ImageCodec.h"

    21 #include "ImageClientMain.h"

    22 #include <101F45D6_extra.rsg>

    23 

    24 #include "JpegTypes.h"

    25 #include "jpegwritecodec.h"

    26 #include "JpegYuvDecoder.h"

    27 #include "icl/ICL_UIDS.hrh"

    28 #include <bitmaptransforms.h>

    29 #include "exifdecoder.h"

    30 #include "ExifEncoder.h"

    31 #include "exiftransform.h"

    32 #include "ImageUtils.h"

    33 

    34 #include "JPEGCodec.h"

    35 #include "JPEGConvert.h"

    36 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    37 #include <icl/icl_uids_const.hrh>

    38 #include <icl/icl_uids_def.hrh>

    39 #include <icl/imagecodecdef.h>

    40 #endif

    41 

    42 _LIT(KJPEGPanicCategory, "JPEGConvertPlugin");

    43 

    44 const TInt KBlockSignatureSearchSize = 256;

    45 const TInt KSizeOfBlockSignaturePlusBlockLength = sizeof(KJpgMarker) + sizeof(TUint16);

    46 

    47 //

    48 // this file doesn't contain much of performance-critical code so use thumb

    49 // instruction set to save on some ROM footprint

    50 //

    51 #if defined(__ARMCC__)

    52 #pragma thumb

    53 #endif

    54 

    55 // Global panic function

    56 GLDEF_C void Panic(TIclPanic aError)

    57 	{

    58 	User::Panic(KJPEGPanicCategory, aError);

    59 	}

    60 

    61 // Jpeg decoder.

    62 CJpegDecoder* CJpegDecoder::NewL()

    63 	{

    64 	return new(ELeave)CJpegDecoder();

    65 	}

    66 

    67 CJpegDecoder::CJpegDecoder()

    68  :	iImageType(CImageDecoder::EImageTypeMain)

    69 	{

    70 	}

    71 

    72 CJpegDecoder::~CJpegDecoder()

    73 	{

    74 	delete iExtensionManager;

    75 	delete iStreamedDecodeExt;

    76 		

    77 	delete iExifDecoder;

    78 	iComment.ResetAndDestroy();

    79 	Cleanup();

    80 	}

    81 

    82 void CJpegDecoder::ImageType(TInt aFrameNumber, TUid& aImageType, TUid& aImageSubType) const

    83 	{

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

    85 	aImageType = KImageTypeJPGUid;

    86 	aImageSubType = KNullUid;

    87 	}

    88 

    89 TInt CJpegDecoder::NumberOfFrameComments(TInt aFrameNumber) const

    90 	{

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

    92 	__ASSERT_ALWAYS((aFrameNumber >= 0) && (aFrameNumber < NumberOfFrames()), Panic(EFrameNumberOutOfRange));

    93 

    94 	const CFrameImageData& frameImageData = FrameData(aFrameNumber);

    95 	TInt frameCommentCount = 0;

    96 	// Because this is a single frame format, the comments are stored

    97 	// in the global rather than local comment block

    98 	TInt imageDataCount = frameImageData.ImageDataCount();

    99 	for (TInt count = 0; count < imageDataCount; count++)

   100 		{

   101 		const TImageDataBlock* imageData = frameImageData.GetImageData(count);

   102 		if (imageData->DataType() == KJPGCommentUid)

   103 			frameCommentCount++;

   104 		}

   105 

   106 	return frameCommentCount;

   107 	}

   108 

   109 HBufC* CJpegDecoder::FrameCommentL(TInt aFrameNumber, TInt aCommentNumber) const

   110 	{

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

   112 	__ASSERT_ALWAYS((aFrameNumber >= 0) && (aFrameNumber < NumberOfFrames()), Panic(EFrameNumberOutOfRange));

   113 	__ASSERT_ALWAYS((aCommentNumber >= 0) && (aCommentNumber < NumberOfFrameComments(aFrameNumber)), Panic(ECommentNumberOutOfRange));

   114 

   115 	const CFrameImageData& frameImageData = FrameData(aFrameNumber);

   116 	TInt commentCount = 0;

   117 	// Because this is a single frame format, the comments are stored

   118 	// in the global rather than local comment block

   119 	TInt imageDataCount = frameImageData.ImageDataCount();

   120 	const TImageDataBlock* imageData = NULL;

   121 	for (TInt count = 0; count < imageDataCount; count++)

   122 		{

   123 		imageData = frameImageData.GetImageData(count);

   124 		if (imageData->DataType() == KJPGCommentUid)

   125 			{

   126 			if (commentCount == aCommentNumber)

   127 				{

   128 				break;

   129 				}

   130 			commentCount++;

   131 			}

   132 		}

   133 

   134 	const TJpegComment* jpegComment = static_cast<const TJpegComment*>(imageData);

   135 	HBufC* comment = NULL;

   136 	if (jpegComment)

   137 		{

   138 		comment = HBufC::NewL(jpegComment->iComment->Length());

   139 		comment->Des().Copy(*(jpegComment->iComment)); // Create a 16 bit copy of the 8 bit original	

   140 		}

   141 	return comment;

   142 	}

   143 

   144 TInt CJpegDecoder::FrameHeaderBlockSize(TInt /*aFrameNumber*/) const

   145 	{

   146 	return KJfifHeaderBlockSizeInBytes;

   147 	}

   148 

   149 TInt CJpegDecoder::FrameBlockSize(TInt /*aFrameNumber*/) const

   150 	{

   151 	return KJfifDataBlockSizeInBytes;

   152 	}

   153 

   154 //

   155 //

   156 //

   157 TInt CJpegDecoder::GetDestinationSize(TSize& aSize, TInt aFrameNumber)

   158 	{

   159 	ASSERT(iExtensionManager);

   160 	const TFrameInfo frameInfo = FrameInfo(aFrameNumber);

   161 	TSize originalSize = frameInfo.iOverallSizeInPixels;

   162 	TInt err = iExtensionManager->GetDestinationSize(originalSize);

   163 	if(err == KErrNone)

   164 		{

   165 		aSize = originalSize;

   166 		}

   167 	return err;

   168 	}

   169 

   170 void CJpegDecoder::InitConvertL()

   171 	{

   172 	iState = EStateStart; //  when starting convert, always start from the top

   173 	CImageDecoderPlugin::InitConvertL();

   174 	}

   175 

   176 void CJpegDecoder::DoConvert()

   177 	{

   178 	switch(iState)

   179 		{

   180 		case EStateStart:

   181 			{

   182 			TRAPD(errCode, PrepareForProcessFrameL());

   183 			if (errCode!=KErrNone)

   184 				{

   185 				RequestComplete(errCode);

   186 				return;

   187 				}

   188 

   189 			iCodecState = EFrameIncomplete;

   190 

   191 			TBufPtr8& sourceData = SourceData();

   192 			TInt sourceLength = sourceData.Length();

   193 			if (sourceLength!=0)

   194 				{

   195 				TRAP(errCode, iCodecState = ImageReadCodec()->ProcessFrameL(sourceData));

   196 				}

   197 

   198 			if (errCode == KErrNone && (sourceData.Length() == sourceLength || iCodecState == EFrameComplete || iCodecState == EBlockComplete))

   199 				{

   200 				CJpgReadCodec* readCodec = static_cast<CJpgReadCodec*>(ImageReadCodec());

   201 				JPEG_ASSERT(readCodec);

   202 				readCodec->InitDrawFrame();

   203 				iState=EStateDrawFrame;

   204 				SelfComplete(KErrNone);

   205 				}

   206 			else

   207 				{

   208 				ASSERT(iState==EStateStart);

   209 				HandleProcessFrameResult(errCode,iCodecState);

   210 				}

   211 			}

   212 			break;

   213 		case EStateDrawFrame:

   214 			{

   215 			CJpgReadCodec* readCodec = static_cast<CJpgReadCodec*>(ImageReadCodec());

   216 			JPEG_ASSERT(readCodec);

   217 			TBool result = EFalse;

   218 			TRAPD(errCode, result = readCodec->DrawFrameL());

   219 			if (errCode != KErrNone)

   220 				{

   221 				HandleProcessFrameResult(errCode, iCodecState);

   222 				}

   223 			else if (result)

   224 				{

   225 				HandleProcessFrameResult(KErrNone, iCodecState);

   226 				iState = EStateStart;

   227 				}

   228 			else

   229 				{

   230 				ASSERT(iState==EStateDrawFrame);

   231 				SelfComplete(KErrNone);

   232 				}

   233 			}

   234 			break;

   235 		default:

   236 			ASSERT(EFalse);

   237 		}

   238 	}

   239 

   240 MExifMetadata* CJpegDecoder::ExifMetadata()

   241 	{

   242 	return iExifDecoder;

   243 	}

   244 

   245 // Scan header.

   246 // Validate that format is correct.

   247 // Create codec.

   248 // Fill in image info. (All frames)

   249 void CJpegDecoder::ScanDataL()

   250 	{

   251 	ReadFormatL();

   252 

   253 	ASSERT(ImageReadCodec() == NULL);

   254 

   255 	CJpgReadCodec* imageReadCodec = NULL;

   256 

   257 	if (iJpgFrameInfo.iProgressive)

   258 		{

   259 		imageReadCodec = CProgressiveJpgReadCodec::NewL(

   260 				iJpgFrameInfo,

   261 				iScanInfo,

   262 				iDCHuffmanTable,

   263 				iACHuffmanTable,

   264 				iQTable);

   265 		}

   266 	else if (iJpgFrameInfo.iNumberOfComponents == iScanInfo.iNumberOfComponents)

   267 		{

   268 		imageReadCodec = CSequentialJpgReadCodec::NewL(

   269 				iJpgFrameInfo,

   270 				iScanInfo,

   271 				iDCHuffmanTable,

   272 				iACHuffmanTable,

   273 				iQTable);

   274 		}

   275 	else

   276 		{

   277 		iJpgFrameInfo.iMultiScan = ETrue;

   278 		imageReadCodec = CMultiScanSequentialJpgReadCodec::NewL(

   279 				iJpgFrameInfo,

   280 				iScanInfo,

   281 				iDCHuffmanTable,

   282 				iACHuffmanTable,

   283 				iQTable);

   284 		}

   285 

   286 	CleanupStack::PushL(imageReadCodec);

   287 	

   288 	if (!iExtensionManager)

   289 		{

   290 		// Manager settings persist over all frames.

   291 		iExtensionManager = CPluginExtensionManager::NewL(imageReadCodec);

   292 		}

   293 	else

   294 		{

   295 		// Maintain manager settings, but reset the codec that it points to.

   296 		iExtensionManager->ResetCodecExtension(imageReadCodec);

   297 		}

   298 	

   299 

   300 	CleanupStack::Pop(); // imageReadCodec

   301 	

   302 	imageReadCodec->SetExtensionManager(iExtensionManager);

   303 	imageReadCodec->SetHighSpeedMode( (DecoderOptions() & CImageDecoder::EPreferFastDecode) == CImageDecoder::EPreferFastDecode );

   304 

   305 	// If this is the main image - pull the thumbnail out and give it to the

   306 	// framework

   307 	if (iImageType == CImageDecoder::EImageTypeMain)

   308 		{

   309 		if (iExifDecoder != NULL)

   310 			{

   311 			TInt err = 0;

   312 			TInt thumbDataOffset = 0;

   313 

   314 			HBufC8* thumbnailData = NULL;

   315 			// Hold the thumbnail data (extracted from the Exif object).

   316 

   317 			// Get both the offset of the thumbnail data and its length.

   318 			err = iExifDecoder->GetIntegerParam(KJPEGInterchangeFormat, 1, thumbDataOffset);

   319 			if(err == KErrNone)

   320 				{

   321 				TInt thumbDataLength = 0;

   322 				err = iExifDecoder->GetIntegerParam(KJPEGInterchangeFormatLength, 1, thumbDataLength);

   323 				if(err == KErrNone)

   324 					{

   325 					//get the thumbnail data.

   326 					thumbnailData = iExifDecoder->GetJpegThumbnailData();

   327 					// Pass the thumbnailData back to the framework (ownership remains here).

   328 					SetThumbnailData(thumbnailData);

   329 					}

   330 				}

   331 			}

   332 		}

   333 

   334 	imageReadCodec->SetAutoRotateFlag(iAutoRotateFlag);

   335 	

   336 	SetImageReadCodec(imageReadCodec);

   337 

   338 	ReadFrameHeadersL();

   339 	}

   340 

   341 void CJpegDecoder::NotifyImageTypeChangeL(TInt aImageType)

   342 	{

   343 	TInt prevImageType = iImageType;

   344 	iImageType = aImageType;

   345 	TRAPD(err, ScanDataL());

   346 	if (err != KErrNone)

   347 		{

   348 		iImageType = prevImageType;

   349 		JPEG_LEAVE(err, "ScanDataL");

   350 		}

   351 	}

   352 

   353 void CJpegDecoder::ReadFormatL()

   354 	{

   355 	iJpgFrameInfo.iProgressive = EFalse; // Reset

   356 

   357 	TPtrC8 bufferDes;

   358 	ReadDataL(0, bufferDes, KJfifInitialHeaderSize);

   359 

   360 	// Validate the header.

   361 	if (bufferDes.Length() < KJfifInitialHeaderSize)

   362 		{

   363 		JPEG_LEAVE(KErrUnderflow, "Not enough data for JFIF header");

   364 		}

   365 

   366 	iPtr = &bufferDes[0];

   367 	const TUint8* ptr = iPtr;

   368 	TInt startPosition = 6; // Move past SOISignature + first block sig/length.

   369 	TUint16 soiSig = ReadBigEndianUint16(ptr);

   370 	if (soiSig != CJpgReadCodec::EMarkerSOI)

   371 		{

   372 		JPEG_LEAVE(KErrCorrupt, "Expected SOI marker");

   373 		}

   374 

   375 	iJpgFrameInfo.iRestartInterval = KErrNotFound;

   376 	SetStartPosition(startPosition);

   377 

   378 	//delete all comments

   379 	iComment.ResetAndDestroy();

   380 

   381 	for (;;)

   382 		{

   383 		// Read the signature and length of the next block.

   384 		iBlockSignature = ReadBigEndianUint16(ptr);

   385 

   386 		// Skip until next block signature is valid

   387 		if ((iBlockSignature & KJpgMarkerMask) != KJpgMarker)

   388 			{

   389 			TInt blockIndex = KErrNotFound;

   390 			TChar jpgMarker = TChar(KJpgMarker >> 8);

   391 			for (;;)

   392 				{

   393 				// search in blocks of size KBlockSignatureSearchSize

   394 				// for occurrence of a jpeg marker (0xff)

   395 

   396 				ReadDataL(startPosition, bufferDes, KBlockSignatureSearchSize);

   397 				if (!bufferDes.Length())

   398 					{

   399 					// no marker found, no data left

   400 					JPEG_LEAVE(KErrCorrupt, "No marker, no data");

   401 					}

   402 				blockIndex = bufferDes.Locate(jpgMarker);

   403 				if (blockIndex != KErrNotFound)

   404 					{

   405 					startPosition += blockIndex;

   406 					break;

   407 					}

   408 				startPosition += bufferDes.Length();

   409 				}

   410 

   411 			if ((bufferDes.Length() - blockIndex) < KSizeOfBlockSignaturePlusBlockLength)

   412 				{

   413 				// ensure there are at least KSizeOfBlockSignaturePlusBlockLength bytes in bufferDes after the blockIndex

   414 				ReadDataL(startPosition, bufferDes, KSizeOfBlockSignaturePlusBlockLength);

   415 				if (bufferDes.Length() < KSizeOfBlockSignaturePlusBlockLength)

   416 					{

   417 					JPEG_LEAVE(KErrUnderflow, "Not enough data");	// Not enough data present

   418 					}

   419 				blockIndex = 0;

   420 				}

   421 			iPtr = &bufferDes[blockIndex];

   422 			ptr = iPtr;

   423 			iBlockSignature = ReadBigEndianUint16(ptr);

   424 			startPosition += KSizeOfBlockSignaturePlusBlockLength;

   425 			SetStartPosition(startPosition);

   426 			}

   427 

   428 		// Read the current block's length.

   429 		iBlockLength = ReadBigEndianUint16(ptr);

   430 

   431 		// Read the next block plus the signature and size of block to follow

   432 		ReadDataL(StartPosition(),bufferDes,iBlockLength+2);

   433 

   434 		if (bufferDes.Length() < iBlockLength+2)

   435 			{

   436 			JPEG_LEAVE(KErrUnderflow, "Not enough data");	// Not enough data present

   437 			}

   438 

   439 		iPtr = &bufferDes[0];

   440 		switch (iBlockSignature)

   441 			{

   442 			case CJpgReadCodec::EMarkerAPP0:

   443 				ProcessApp0L();

   444 				break;

   445 			

   446 			case CJpgReadCodec::EMarkerAPP1:

   447 				// Process the EXIF information

   448 				// Check if the flag to ignore is set. If yes, set the data to NULL.

   449 				if (DecoderOptions() & CImageDecoder::EOptionIgnoreExifMetaData)

   450 					{

   451 					delete iExifDecoder;

   452 					iExifDecoder = NULL;

   453 					}

   454 				else

   455 					{

   456 					TRAPD(err, ProcessApp1L());

   457 					if ((err != KErrCorrupt) && (err != KErrNotSupported))

   458 						{

   459 						JPEG_LEAVE_IF_ERROR(err, "ProcessApp1L");

   460 						}

   461 					}

   462 				break;

   463 				

   464 			case CJpgReadCodec::EMarkerAPP14:

   465 				ProcessAppEL();

   466 				break;

   467 				

   468 			case CJpgReadCodec::EMarkerDHT:

   469 				ProcessHuffmanTableL();

   470 				break;

   471 			

   472 			case CJpgReadCodec::EMarkerDQT:

   473 				ProcessQTableL();

   474 				break;

   475 			

   476 			case CJpgReadCodec::EMarkerSOF2:

   477 				iJpgFrameInfo.iProgressive = ETrue; // Fall through to ProcessStartOfFrameL()

   478 			case CJpgReadCodec::EMarkerSOF0:

   479 			case CJpgReadCodec::EMarkerSOF1:

   480 				ProcessStartOfFrameL();

   481 				break;

   482 			

   483 			case CJpgReadCodec::EMarkerSOF3:

   484 				User::Leave(KErrNotSupported);

   485 				break;

   486 			

   487 			case CJpgReadCodec::EMarkerSOS:

   488 				ProcessStartOfScanL();

   489 				FinishedProcessing();

   490 				// Fill in image data structures and give control to the codec.

   491 				InitialiseImageDataL();

   492 				return;

   493 			

   494 			case CJpgReadCodec::EMarkerDRI:

   495 				ProcessRestartInterval();

   496 				break;

   497 			

   498 			case CJpgReadCodec::EMarkerCOM:

   499 				CheckCommentBlockL();

   500 				ProcessCommentL();

   501 				break;

   502 			

   503 		default:

   504 			// ProcessOtherBlockL();

   505 			break;

   506 			}

   507 

   508 		ptr = iPtr + (iBlockLength - 2); // Advance past this block.

   509 		startPosition += iBlockLength + 2; // Advance past this block and the signature and length of the next block

   510 		SetStartPosition(startPosition);

   511 		}

   512 	}

   513 

   514 //

   515 // APP markers are reserved for application use. Different applications are

   516 // free to use the same APP marker for different purposes.

   517 // In our case, we look for the EXIF header and ignore it otherwise.

   518 //

   519 void CJpegDecoder::ProcessApp1L()

   520 	{

   521 	if (iBlockLength < KExifHeaderLength)

   522 		{

   523 		return;

   524 		}

   525 	TPtrC8 exifHeaderPtr(iPtr, KExifHeaderLength);

   526 	if ((KExifHeader().Compare(exifHeaderPtr) == KErrNone) && (iExifDecoder == NULL))

   527 		{

   528 		// This is the EXIF header block, so instantiate the EXIF decoder object

   529 		iExifDecoder = CExifDecoder::NewL(iBlockLength, iPtr);

   530 		}

   531 	}

   532 

   533 //

   534 // Check that length of comment block is correct, if not

   535 // calculate real size of comment block and adjust data read.

   536 //

   537 void CJpegDecoder::CheckCommentBlockL()

   538 	{

   539 	// INC076787 -

   540 	// Allow successful decoding of a JPEG file with incorrect comment block length.

   541 	TUint16 nextBlockSignature = PtrReadUtil::ReadBigEndianUint16(iPtr + iBlockLength - 2);

   542 	if ((nextBlockSignature & KJpgMarkerMask) != KJpgMarker)

   543 		{

   544 		// Block length is incorrect. Calculate real length of comment block

   545 		TPtrC8 commentBuffer;

   546 		TInt realLength = 0;

   547 

   548 		// First check whether the block is smaller than expected.

   549 		nextBlockSignature = PtrReadUtil::ReadBigEndianUint16(iPtr);

   550 		while (((nextBlockSignature & KJpgMarkerMask) != KJpgMarker) && (realLength <= (iBlockLength - 2)))

   551 			{

   552 			realLength++;

   553 			nextBlockSignature = PtrReadUtil::ReadBigEndianUint16(iPtr + realLength);

   554 			}

   555 		if (realLength <= (iBlockLength - 2))

   556 			{

   557 			// Correct block length

   558 			iBlockLength = realLength + 2; // Add the two bytes which contain length

   559 			}

   560 		else		// Otherwise check for more data

   561 			{

   562 			TInt offset = 1;

   563 			TInt startPos = StartPosition() + iBlockLength - 2;

   564 

   565 			ReadDataL(startPos + offset, commentBuffer, 2);

   566 			if (!commentBuffer.Length())

   567 				{

   568 				// Not enough data in the 'commentBuffer'

   569 				JPEG_LEAVE(KErrUnderflow, "Not enough data");	

   570 				}

   571 			nextBlockSignature = PtrReadUtil::ReadBigEndianUint16(&commentBuffer[0]);

   572 

   573 			while ((nextBlockSignature & KJpgMarkerMask) != KJpgMarker)

   574 				{

   575 				offset++;

   576 				ReadDataL(startPos + offset, commentBuffer, 2);

   577 				if (!commentBuffer.Length())

   578 					{

   579 					// Not enough data in the 'commentBuffer'

   580 					JPEG_LEAVE(KErrUnderflow, "Not enough data");

   581 					}

   582 				nextBlockSignature = PtrReadUtil::ReadBigEndianUint16(&commentBuffer[0]);

   583 				}

   584 			// Correct block length

   585 			iBlockLength += offset;

   586 			}

   587 

   588 		// Re-read the comment block again plus the signature and size of block which follows

   589 		ReadDataL(StartPosition(), commentBuffer, iBlockLength + 2);

   590 		iPtr = &commentBuffer[0];

   591 		}

   592 	}

   593 

   594 

   595 CFrameInfoStrings* CJpegDecoder::FrameInfoStringsL(RFs& aFs, TInt aFrameNumber)

   596 	{

   597 	const TUid KJpgCodecDllUid = {KJPGCodecDllUidValue};

   598 

   599 	RResourceFile resourceFile;

   600 	OpenExtraResourceFileLC(aFs, KJpgCodecDllUid, resourceFile);

   601 

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

   603 	TResourceReader resourceReader;

   604 	resourceReader.SetBuffer(resourceInfo);

   605 

   606 	TBuf<KCodecResourceStringMax> info;

   607 	TBuf<KCodecResourceStringMax> templte;

   608 

   609 	const TFrameInfo& frameInfo = FrameInfo(aFrameNumber);

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

   611 

   612 	info = resourceReader.ReadTPtrC();

   613 	frameInfoStrings->SetDecoderL(info);

   614 

   615 	info = resourceReader.ReadTPtrC();

   616 	frameInfoStrings->SetFormatL(info);

   617 

   618 	TInt width = frameInfo.iOverallSizeInPixels.iWidth;

   619 	TInt height = frameInfo.iOverallSizeInPixels.iHeight;

   620 	TInt depth = frameInfo.iBitsPerPixel;

   621 

   622 	templte = resourceReader.ReadTPtrC();

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

   624 	frameInfoStrings->SetDimensionsL(info);

   625 

   626 	CDesCArrayFlat* resourceArray = resourceReader.ReadDesCArrayL();

   627 	CleanupStack::PushL(resourceArray);

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

   629 	templte = (*resourceArray)[formatIndex];

   630 	CleanupStack::PopAndDestroy(resourceArray);

   631 	info.Format(templte, depth);

   632 	frameInfoStrings->SetDepthL(info);

   633 

   634 	resourceArray = resourceReader.ReadDesCArrayL();

   635 	CleanupStack::PushL(resourceArray);

   636 	formatIndex = (iJpgFrameInfo.iProgressive) ? 1 : 0;

   637 	info = (*resourceArray)[formatIndex];

   638 	CleanupStack::PopAndDestroy(resourceArray);

   639 	frameInfoStrings->SetDetailsL(info);

   640 

   641 	CleanupStack::Pop(frameInfoStrings);

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

   643 	return frameInfoStrings;

   644 	}

   645 

   646 void CJpegDecoder::InitialiseImageDataL()

   647 	{

   648 	// Fill in image data info.

   649 	TInt quality = 0;

   650 	TInt tables = 0;

   651 	TInt qTableIndex;

   652 	for (qTableIndex = 0; qTableIndex < KJpgMaxNumberOfTables; qTableIndex++)

   653 		{

   654 		if (iQTable[qTableIndex].QualityFactor() > 0)

   655 			{

   656 			quality += iQTable[qTableIndex].QualityFactor();

   657 			tables++;

   658 			}

   659 		}

   660 	if (tables > 0)

   661 		quality /= tables;

   662 

   663 	TJpegImageData* jpegImageData = new(ELeave) TJpegImageData;

   664 	CleanupStack::PushL(jpegImageData);

   665 

   666 	jpegImageData->iQualityFactor = quality;

   667 	if (iJpgFrameInfo.iNumberOfComponents == 1)

   668 		jpegImageData->iSampleScheme = TJpegImageData::EMonochrome;

   669 	else

   670 		{

   671 		if (iJpgFrameInfo.iMaxHorzSampleFactor == 1 && iJpgFrameInfo.iMaxVertSampleFactor == 1)

   672 			jpegImageData->iSampleScheme = TJpegImageData::EColor444;

   673 		else if (iJpgFrameInfo.iMaxHorzSampleFactor == 2 && iJpgFrameInfo.iMaxVertSampleFactor == 1)

   674 			jpegImageData->iSampleScheme = TJpegImageData::EColor422;

   675 		else

   676 			jpegImageData->iSampleScheme = TJpegImageData::EColor420;

   677 		}

   678 	

   679 	JPEG_LEAVE_IF_ERROR(AppendImageData(jpegImageData), "AppendImageData: jpegImageData");

   680 	CleanupStack::Pop(jpegImageData);

   681 

   682 	// Fill in QTable image data.

   683 	for (qTableIndex = 0 ; qTableIndex < KJpgMaxNumberOfTables ; qTableIndex++)

   684 		{

   685 		if (iQTable[qTableIndex].QualityFactor() > 0)

   686 			{

   687 			TJpegQTable* jpegQTable = new(ELeave) TJpegQTable;

   688 			CleanupStack::PushL(jpegQTable);

   689 

   690 			TQTable& qTable = iQTable[qTableIndex];

   691 			TUint8 values[2 * KJpgQTableEntries];

   692 

   693 			const TInt precisionBytes = qTable.Get(values) / KJpgQTableEntries;

   694 			const TUint8* zigZagPtr = KZigZagSequence.iZigZag;

   695 			TUint8* valuePtr = values;

   696 			const TUint8* valuePtrLimit = valuePtr + (KJpgQTableEntries * precisionBytes);

   697 

   698 			while (valuePtr < valuePtrLimit)

   699 				{

   700 				jpegQTable->iEntries[*zigZagPtr++] = valuePtr[0]; // Lose the low byte of 16 bit precision values

   701 				valuePtr += precisionBytes;

   702 				}

   703 

   704 			jpegQTable->iTableIndex = qTableIndex;

   705 			JPEG_LEAVE_IF_ERROR(AppendImageData(jpegQTable), "AppendImageData: jpegQTable");

   706 			CleanupStack::Pop();

   707 			}

   708 		}

   709 

   710 	// Add the comments

   711 	const TInt noOfComments = iComment.Count();

   712 	for(TInt commentNo=0; commentNo < noOfComments; commentNo++)

   713 		{

   714 		TJpegComment* jpegComment = new(ELeave) TJpegComment;

   715 		CleanupStack::PushL(jpegComment);

   716 

   717 		HBufC8* comment = iComment[0];

   718 		jpegComment->iComment = comment;

   719 

   720 		JPEG_LEAVE_IF_ERROR(AppendImageDataBuffer(comment), "AppendImageDataBuffer");

   721 		iComment.Remove(0);

   722 

   723 		JPEG_LEAVE_IF_ERROR(AppendImageData(jpegComment), "AppendImageData(jpegComment)");

   724 		CleanupStack::Pop(); // jpegComment

   725 		}

   726 	}

   727 

   728 void CJpegDecoder::ProcessApp0L()

   729 	{

   730 	// iBlockLength must specify at least the 2 byte

   731 	// length field itself for Application Data!

   732 	if (iBlockLength<2)

   733 		{

   734 		JPEG_LEAVE(KErrCorrupt, "Not enough data for App0");

   735 		}

   736 

   737 	const TUint8* ptr = iPtr;

   738 

   739 	TPtrC8 id(ptr, Min(KJpgApp0IdSize, iBlockLength-2));

   740 

   741 	if (id == KJfifId)

   742 		{

   743 		// We know jfif will always have a minimum of 14 bytes of

   744 		// data in addition to the 2 byte length field.

   745 		if (iBlockLength<16)

   746 			{

   747 			JPEG_LEAVE(KErrCorrupt, "Not enough data in App0");

   748 			}

   749 

   750 		ptr += KJpgApp0IdSize + 1;

   751 		TUint16 version = ReadBigEndianUint16(ptr);

   752 		if (version != KJfifVersion0100 &&

   753 			version != KJfifVersion0101 &&

   754 			version != KJfifVersion0102)

   755 			{

   756 			JPEG_LEAVE(KErrNotSupported, "Unsupported jfif version");

   757 			}

   758 

   759 		iJpgFrameInfo.iUnits = TJpgFrameInfo::TJpgImageUnits(*ptr++);

   760 		iJpgFrameInfo.iSizeInTwips.iWidth = ReadBigEndianUint16(ptr);

   761 		iJpgFrameInfo.iSizeInTwips.iHeight = ReadBigEndianUint16(ptr);

   762 		iJpgFrameInfo.iThumbnailSize.iWidth = *ptr++;

   763 		iJpgFrameInfo.iThumbnailSize.iHeight = *ptr;

   764 		

   765 		JPEG_DEBUG2("Frame units: %d", iJpgFrameInfo.iUnits);

   766 		JPEG_DEBUG2("Frame twips width: %d", iJpgFrameInfo.iSizeInTwips.iWidth);

   767 		JPEG_DEBUG2("Frame twips height: %d", iJpgFrameInfo.iSizeInTwips.iHeight);

   768 		JPEG_DEBUG2("Frame thumbnail width: %d", iJpgFrameInfo.iThumbnailSize.iWidth);

   769 		JPEG_DEBUG2("Frame twips width: %d", iJpgFrameInfo.iThumbnailSize.iHeight);

   770 

   771 		// skip over JFIF thumbnail data without storing it

   772 		// there are currently no client APIs for accessing it

   773 		ptr += iJpgFrameInfo.iThumbnailSize.iWidth * iJpgFrameInfo.iThumbnailSize.iHeight * 3;

   774 

   775 		iJFIFMarkerPresent = ETrue;

   776 		}

   777 	}

   778 

   779 void CJpegDecoder::ProcessAppEL()

   780 	{

   781 	const TUint8* ptr = iPtr;

   782 

   783 	TPtrC8 id(ptr,KJpgAppEIdSize);

   784 

   785 	if (id == KAdobeId)

   786 		{

   787 		iAdobeMarkerPresent = ETrue;

   788 		iAdobeTransform = ptr[11];

   789 		}

   790 	}

   791 

   792 void CJpegDecoder::ProcessHuffmanTableL()

   793 	{

   794 	const TUint8* dataPtr = iPtr;

   795 	const TUint8* dataPtrLimit = dataPtr + iBlockLength - 2;

   796 	THuffmanTableProcessor::ProcessHuffmanTableL(dataPtr, dataPtrLimit, iDCHuffmanTable, iACHuffmanTable);

   797 	}

   798 

   799 void CJpegDecoder::ProcessQTableL()

   800 	{

   801 	const TUint8* dataPtr = iPtr;

   802 	const TUint8* dataPtrLimit = dataPtr + iBlockLength - 2;

   803 

   804 	while (dataPtr < dataPtrLimit)

   805 		{

   806 		TInt index = *dataPtr++;

   807 		TBool sixteenBitPrecision = index & 0x10;

   808 		index &= 0x0f;

   809 		if (index >= KJpgMaxNumberOfTables)

   810 			{

   811 			JPEG_LEAVE(KErrCorrupt, "table index out of range");

   812 			}

   813 

   814 		dataPtr += iQTable[index].Set(dataPtr,sixteenBitPrecision);

   815 		}

   816 	}

   817 

   818 void CJpegDecoder::ProcessStartOfFrameL()

   819 	{

   820 	const TUint8* ptr = iPtr;

   821 

   822 	iJpgFrameInfo.iSamplePrecision = *ptr++;

   823 	if (iJpgFrameInfo.iSamplePrecision != 8)

   824 		{

   825 		JPEG_LEAVE(KErrNotSupported, "Unsupported sample precision");

   826 		}

   827 

   828 	iJpgFrameInfo.iSizeInPixels.iHeight = ReadBigEndianUint16(ptr);

   829 	iJpgFrameInfo.iSizeInPixels.iWidth = ReadBigEndianUint16(ptr);

   830 	

   831 	JPEG_DEBUG2("Frame pixel width: %d", iJpgFrameInfo.iSizeInPixels.iWidth);

   832 	JPEG_DEBUG2("Frame pixel height: %d", iJpgFrameInfo.iSizeInPixels.iHeight);

   833 	

   834 	if ((iJpgFrameInfo.iSizeInPixels.iHeight <= 0) || (iJpgFrameInfo.iSizeInPixels.iWidth <= 0))

   835 		{

   836 		JPEG_LEAVE(KErrCorrupt, "Invalid pixel height or width");		

   837 		}

   838 	

   839 	if (iJpgFrameInfo.iSizeInTwips.iWidth > 0 && iJpgFrameInfo.iSizeInTwips.iHeight > 0)

   840 		{

   841 		if (iJpgFrameInfo.iUnits == TJpgFrameInfo::EDotsPerInch)

   842 			{

   843 			iJpgFrameInfo.iSizeInTwips.iWidth = iJpgFrameInfo.iSizeInPixels.iWidth * KTwipsPerInch / iJpgFrameInfo.iSizeInTwips.iWidth;

   844 			iJpgFrameInfo.iSizeInTwips.iHeight = iJpgFrameInfo.iSizeInPixels.iHeight * KTwipsPerInch / iJpgFrameInfo.iSizeInTwips.iHeight;

   845 			}

   846 		else if (iJpgFrameInfo.iUnits == TJpgFrameInfo::EDotsPerCm)

   847 			{

   848 			iJpgFrameInfo.iSizeInTwips.iWidth = iJpgFrameInfo.iSizeInPixels.iWidth * KTwipsPerCm / iJpgFrameInfo.iSizeInTwips.iWidth;

   849 			iJpgFrameInfo.iSizeInTwips.iHeight = iJpgFrameInfo.iSizeInPixels.iHeight * KTwipsPerCm / iJpgFrameInfo.iSizeInTwips.iHeight;

   850 			}

   851 		else

   852 			iJpgFrameInfo.iSizeInTwips.SetSize(0,0);

   853 		}

   854 

   855 	iJpgFrameInfo.iMaxHorzSampleFactor = 0;

   856 	iJpgFrameInfo.iMaxVertSampleFactor = 0;

   857 	iJpgFrameInfo.iNumberOfComponents = *ptr++;

   858 	JPEG_DEBUG2("Frame number of components: %d", iJpgFrameInfo.iNumberOfComponents);

   859 	

   860 	//At least one component and not more than we can cope with

   861 	if(iJpgFrameInfo.iNumberOfComponents < KJpgMinNumberOfComponents)

   862 		{

   863 		JPEG_LEAVE(KErrCorrupt, "Not enough components");

   864 		}

   865 

   866 	if ((iJpgFrameInfo.iNumberOfComponents != KJpgMinNumberOfComponents) && (iJpgFrameInfo.iNumberOfComponents != KJpgNumberOfComponents))

   867 		{

   868 		JPEG_LEAVE(KErrNotSupported, "Bad number of components");

   869 		}

   870 

   871 	for (TInt count = 0; count < iJpgFrameInfo.iNumberOfComponents; count++)

   872 		{

   873 		TJpgFrameInfo::TComponentInfo& compInfo = iJpgFrameInfo.iComponent[count];

   874 		compInfo.iId = *ptr++;

   875 		TUint8 sampleFactor = *ptr++;

   876 

   877 		compInfo.iHorzSampleFactor = sampleFactor >> 4;

   878 		if(compInfo.iHorzSampleFactor < KJpgMinSampleFactor || compInfo.iHorzSampleFactor > KJpgMaxSampleFactor)

   879 			{

   880 			JPEG_LEAVE(KErrCorrupt, "Bad horizontal sample factor");

   881 			}

   882 

   883 		compInfo.iVertSampleFactor = sampleFactor & 0x0f;

   884 		if(compInfo.iVertSampleFactor < KJpgMinSampleFactor || compInfo.iVertSampleFactor > KJpgMaxSampleFactor)

   885 			{

   886 			JPEG_LEAVE(KErrCorrupt, "Bad vertical sample factor");

   887 			}

   888 

   889 		compInfo.iQTable = *ptr++;

   890 		

   891 		// Number of tables should be in range (0..3)

   892 		if ((compInfo.iQTable < 0) || (compInfo.iQTable > (KJpgMaxNumberOfTables - 1)))

   893 			{

   894 			JPEG_LEAVE(KErrCorrupt, "Bad QTable index");				

   895 			}

   896 			

   897 		iJpgFrameInfo.iMaxHorzSampleFactor = Max(iJpgFrameInfo.iMaxHorzSampleFactor,compInfo.iHorzSampleFactor);

   898 		iJpgFrameInfo.iMaxVertSampleFactor = Max(iJpgFrameInfo.iMaxVertSampleFactor,compInfo.iVertSampleFactor);

   899 		}

   900 

   901 	if (iJpgFrameInfo.iNumberOfComponents == 1)

   902 		{

   903 		iJpgFrameInfo.iComponent[0].iHorzSampleFactor = 1;

   904 		iJpgFrameInfo.iComponent[0].iVertSampleFactor = 1;

   905 		iJpgFrameInfo.iMaxHorzSampleFactor = 1;

   906 		iJpgFrameInfo.iMaxVertSampleFactor = 1;

   907 		}

   908 	else if (!iJFIFMarkerPresent)

   909 		{

   910 		if (iAdobeMarkerPresent && (iAdobeTransform != KAdobeColorTransformYCbCr))

   911 			{

   912 			JPEG_LEAVE(KErrNotSupported, "Unsupported Adobe transform");

   913 			}

   914 		else if (!iAdobeMarkerPresent)

   915 			{

   916 			// No markers present, so check for RGB and YCC, which are not supported.

   917 			if ((iJpgFrameInfo.iComponent[0].iId == 82) && (iJpgFrameInfo.iComponent[1].iId == 71) && (iJpgFrameInfo.iComponent[2].iId == 66))

   918 				{

   919 				JPEG_LEAVE(KErrNotSupported, "RGB and YCC not supported");

   920 				}

   921 

   922 			if ((iJpgFrameInfo.iComponent[0].iId == 89) && (iJpgFrameInfo.iComponent[1].iId == 67) && (iJpgFrameInfo.iComponent[2].iId == 99))

   923 				{

   924 				JPEG_LEAVE(KErrNotSupported, "RGB and YCC not supported");

   925 				}

   926 			}

   927 		}

   928 	

   929 	JPEG_DEBUG2("Frame max horiz sample factor: %d", iJpgFrameInfo.iMaxHorzSampleFactor);

   930 	JPEG_DEBUG2("Frame max vert sample factor: %d", iJpgFrameInfo.iMaxHorzSampleFactor);

   931 	}

   932 

   933 void CJpegDecoder::ProcessStartOfScanL()

   934 	{

   935 	const TUint8* ptr = iPtr;

   936 	iImageOffset = StartPosition() + iBlockLength - 2;

   937 	iScanInfo.iImageOffset = iImageOffset;

   938 	TJpgScanInfoProcessor::ProcessStartOfScanL(ptr, iJpgFrameInfo, iScanInfo, iDCHuffmanTable, iACHuffmanTable);

   939 	}

   940 

   941 void CJpegDecoder::ProcessRestartInterval()

   942 	{

   943 	const TUint8* ptr = iPtr;

   944 	iJpgFrameInfo.iRestartInterval = ReadBigEndianUint16(ptr);

   945 	JPEG_DEBUG2("Frame restart interval: %d", iJpgFrameInfo.iRestartInterval);

   946 	}

   947 

   948 void CJpegDecoder::ProcessCommentL()

   949 	{

   950 	if(iBlockLength < 2) // need at least 2 bytes for length field

   951 		{

   952 		JPEG_LEAVE(KErrCorrupt, "Not enough data for comment");

   953 		}

   954 

   955 	TPtrC8 commentDes(iPtr, iBlockLength - 2);

   956 	HBufC8* comment = commentDes.AllocLC();

   957 	JPEG_LEAVE_IF_ERROR(iComment.Append(comment), "Appending comment");

   958 	CleanupStack::Pop(comment);

   959 	}

   960 

   961 void CJpegDecoder::FinishedProcessing()

   962 	{

   963 	SetStartPosition(iImageOffset);

   964 	SetDataLength(KMaxTInt);

   965 

   966 	TFrameInfo imageInfo;

   967 	imageInfo = ImageInfo();

   968 	imageInfo.iFrameCoordsInPixels.SetRect(TPoint(0,0),iJpgFrameInfo.iSizeInPixels);

   969 	imageInfo.iOverallSizeInPixels = iJpgFrameInfo.iSizeInPixels;

   970 			

   971 	imageInfo.iFrameSizeInTwips = iJpgFrameInfo.iSizeInTwips;

   972 	imageInfo.iBitsPerPixel = 8 * iJpgFrameInfo.iNumberOfComponents;

   973 	imageInfo.iDelay = 0;

   974 	imageInfo.iFlags = TFrameInfo::ECanDither;

   975 	if (iJpgFrameInfo.iNumberOfComponents > 1)

   976 		imageInfo.iFlags |= TFrameInfo::EColor;

   977 

   978 	// Set display mode.

   979 	switch (imageInfo.iBitsPerPixel)

   980 		{

   981 	case 1:

   982 		imageInfo.iFrameDisplayMode = EGray2;

   983 		break;

   984 

   985 	case 2:

   986 		imageInfo.iFrameDisplayMode = EGray4;

   987 		break;

   988 

   989 	case 4:

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

   991 		break;

   992 

   993 	case 8:

   994 		imageInfo.iFrameDisplayMode = (imageInfo.iFlags & TFrameInfo::EColor) ? EColor256 : EGray256;

   995 		break;

   996 

   997 	case 12:

   998 		imageInfo.iFrameDisplayMode = EColor4K;

   999 		break;

  1000 

  1001 	case 16:

  1002 		imageInfo.iFrameDisplayMode = EColor64K;

  1003 		break;

  1004 

  1005 	case 24:

  1006 		imageInfo.iFrameDisplayMode = EColor16M;

  1007 		break;

  1008 		}

  1009 

  1010 	if ((DecoderOptions() & CImageDecoder::EOptionAutoRotate) && iExifDecoder) 

  1011 		{

  1012 		TUint16 orientation = 0;

  1013 		

  1014 		// if orientation tag is not found in the Ifd it is 0 

  1015 		if (iImageType == CImageDecoder::EImageTypeMain)

  1016 			{

  1017 			iExifDecoder->GetShortParam(0x0112, KExifIfdZero, orientation);

  1018 			}

  1019 		else if (iImageType == CImageDecoder::EImageTypeThumbnail)

  1020 			{

  1021 			iExifDecoder->GetShortParam(0x0112, KExifIfdOne, orientation);

  1022 			}

  1023 

  1024 		// check for corrupted orientation tag value

  1025 		if (orientation > 8)

  1026 			{

  1027 			orientation = 0;

  1028 			}

  1029 		

  1030 		if (orientation >= 4 && orientation <= 8) 

  1031 			{

  1032 			imageInfo.iOverallSizeInPixels.iWidth = iJpgFrameInfo.iSizeInPixels.iHeight;

  1033 			imageInfo.iOverallSizeInPixels.iHeight = iJpgFrameInfo.iSizeInPixels.iWidth;

  1034 			// not sure we need the lines below but just in case

  1035 			imageInfo.iFrameSizeInTwips.iWidth = iJpgFrameInfo.iSizeInTwips.iHeight;

  1036 			imageInfo.iFrameSizeInTwips.iHeight = iJpgFrameInfo.iSizeInTwips.iWidth;

  1037 			imageInfo.iFrameSizeInPixels.iWidth = iJpgFrameInfo.iSizeInPixels.iHeight;

  1038 			imageInfo.iFrameSizeInPixels.iHeight = iJpgFrameInfo.iSizeInPixels.iWidth;

  1039 			imageInfo.iFrameCoordsInPixels.SetRect(TPoint(0, 0), TPoint(iJpgFrameInfo.iSizeInPixels.iHeight, iJpgFrameInfo.iSizeInPixels.iWidth));

  1040 			}

  1041 

  1042 		iAutoRotateFlag = orientation;

  1043 		}

  1044 

  1045 	SetImageInfo(imageInfo);

  1046 	}

  1047 

  1048 void CJpegDecoder::InitCustomAsyncL(TInt aParam)

  1049 	{

  1050 	if (aParam == KOptionConvertFrameUidValue)

  1051 		{

  1052 		HandleConvertFrameL();

  1053 		}

  1054 	else if (aParam == KOptionContinueConvertFrameUidValue)

  1055 		{

  1056 		HandleContinueConvertFrameL();

  1057 		}

  1058 	}

  1059 

  1060 void CJpegDecoder::HandleConvertFrameL()

  1061 	{

  1062 	CImageDecoderPlugin::RequestInitL(FrameNumber());

  1063 

  1064 	CJpgReadCodec* jpgReadCodec = reinterpret_cast<CJpgReadCodec*>(ImageReadCodec());

  1065 	JPEG_ASSERT(jpgReadCodec);

  1066 	jpgReadCodec->InitFrameL(DstImageFrame());

  1067 	}

  1068 

  1069 void CJpegDecoder::HandleContinueConvertFrameL()

  1070 	{

  1071 	CJpgReadCodec* jpgReadCodec = reinterpret_cast<CJpgReadCodec*>(ImageReadCodec());

  1072 	JPEG_ASSERT(jpgReadCodec);

  1073 	CJpgImageFrameReadCodec* imageframeCodec = jpgReadCodec->ImageFrameCodec();

  1074 	if(imageframeCodec == NULL)

  1075 		{

  1076 		// ConvertFrame() should have been called to initiate the image frame processor

  1077 		// before calling ContinueConvertFrame()

  1078 		JPEG_LEAVE(KErrNotReady, "Continue called before Convert");

  1079 		}

  1080 	else

  1081 		{

  1082 		if (imageframeCodec->Destination() == NULL)

  1083 			{

  1084 			// ConvertFrame() should have been called to initiate the destination

  1085 			// before calling ContinueConvertFrame()

  1086 			JPEG_LEAVE(KErrNotReady, "Continue called before Convert");

  1087 			}

  1088 		}

  1089 	}

  1090 

  1091 void CJpegDecoder::HandleCustomSyncL(TInt aParam)

  1092 	{

  1093 	CJpgReadCodec* codec = reinterpret_cast<CJpgReadCodec*>(ImageReadCodec());

  1094 	JPEG_ASSERT(codec);

  1095 	

  1096 	if(aParam == CJpegYuvDecoder::EOptionYuvDecode)

  1097 		{

  1098 		codec->SetYuvDecode(ETrue);

  1099 		}

  1100 	else if(aParam == KOptionRecommendBufferSizeUidValue)

  1101 		{

  1102 		TUid formatCode = FormatCode();

  1103 		TInt bufferSize = codec->RecommendBufferSizeL(formatCode);

  1104 		SetRecommendedBufferSize(bufferSize);

  1105 		}

  1106 	else

  1107 		{

  1108 		JPEG_LEAVE(KErrNotSupported, "Unsupported custom sync");

  1109 		}

  1110 	}

  1111 

  1112 void CJpegDecoder::NotifyComplete()

  1113 	{

  1114 	iState = EStateStart; // ensure that however we exit one run, start at top of next DoConvert()

  1115 	CJpgReadCodec* jpgReadCodec = REINTERPRET_CAST(CJpgReadCodec*, ImageReadCodec());

  1116 	JPEG_ASSERT(jpgReadCodec);

  1117 	

  1118 	if (iCodecState == EFrameComplete)

  1119 		{

  1120 		// should be safe to clear buffers here

  1121 		jpgReadCodec->CleanupBuffers();

  1122 		}

  1123 

  1124 	jpgReadCodec->SetYuvDecode(EFalse);

  1125 	}

  1126 

  1127 // System Wide Define

  1128 #ifdef SYMBIAN_ENABLE_1630_JPEG_EXTENSIONS

  1129 void CJpegDecoder::SetClippingRectL(const TRect* aRect)

  1130 	{

  1131 	RPointerArray<TFrameInfo> frameInfo;

  1132 	CleanupClosePushL(frameInfo);

  1133 		

  1134 	// JPEG only has a single frame

  1135 	frameInfo.AppendL(&FrameInfo(0));