examples/Multimedia/ICL/ICLExample/icljpgtoolsandsqueezeexample.cpp

Go to the documentation of this file.
00001 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
00002 // All rights reserved.
00003 // This component and the accompanying materials are made available
00004 // under the terms of "Eclipse Public License v1.0"
00005 // which accompanies this distribution, and is available
00006 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
00007 //
00008 // Initial Contributors:
00009 // Nokia Corporation - initial contribution.
00010 //
00011 // Contributors:
00012 //
00013 // Description:
00014 // This code demonstrates various imagetransformations available in Jpeg Tools and Squeeze 
00015 // modules of ICL 
00016 // Note 1: For demonstration purposes we create a client side active object which can 
00017 // handle the asynchronous request to transform the image. In a standard application the asynchronous
00018 // call would be made passing in a TRequestStatus object associate with an active object
00019 // which is part of that application. We would return to the main UI processing thread in 
00020 // which an active scheduler is running and wait for the asynchronous request to complete. In 
00021 // this demonstration we need to manually start the active scheduler.
00022 // Note 2: Starts the active scheduler - this is for demonstration purposes. See Note 1:
00023 //
00024 
00025 
00026 
00027 
00028 
00033 #include "iclexample.h"
00034 
00035 #include <imagetransform.h>
00036 #include <icl/squeezetransformextension.h>
00037 #include <icl/orientationtransformextension.h>
00038 #include <icl/overlaytransformextension.h>
00039 #include <iclexifimageframe.h>
00040 #include <imageframe.h>
00041 #include <imageconversion.h>
00042         
00043 
00044 const TUid KImageFramePluginUid = {0x101F7C60};
00045 
00056 void CIclExample::SqueezeJpgFileToFileL(const TDesC& aSrcFileName, const TDesC& aDestFileName)
00057         {
00058         // Create CImageTransform object and push it on to the cleanup stack
00059         CImageTransform* imageTransform = CImageTransform::NewL(iFs);
00060         CleanupStack::PushL(imageTransform);
00061 
00062         imageTransform->SetSourceFilenameL(aSrcFileName);
00063         imageTransform->SetDestFilenameL(aDestFileName);
00064         imageTransform->SetTransformationsL(CImageTransform::ESqueeze);
00065         imageTransform->SetOptionsL(CImageTransform::EIgnoreExifMetadataProcessing);
00066         imageTransform->SetupL();
00067 
00068         TUid lSqUid = {KUidSqueezeTransformExtension    };
00069         TInt err = KErrNone;
00070         CSqueezeTransformExtension* lSqExt = static_cast<CSqueezeTransformExtension*>(imageTransform->Extension(lSqUid, err));
00071         if(!lSqExt)
00072                 {
00073                 User::Leave(err);
00074                 }
00075 
00076         // Squeeze by 20% of size in bytes
00077         TInt squeezeRate = 20;
00078         RFile file;
00079         User::LeaveIfError(file.Open(iFs, aSrcFileName, EFileRead));
00080         TInt filesize;
00081         User::LeaveIfError(file.Size(filesize));
00082         file.Close();
00083         TInt maxdestsize = filesize - ( (filesize * squeezeRate)/100 );
00084 
00085         // Set the desired max size of the squeezed file on the squeeze extension
00086         lSqExt->SetDestSizeInBytes(maxdestsize);
00087 
00088         // Call Transform() function of CImageTransform for image transform operation
00089         // See Note 1
00090         CActiveListener* activeListener = CreateAndInitializeActiveListenerLC();
00091 
00092         // Call Transform() function of CImageTransform for image transform operation
00093         imageTransform->Transform(activeListener->iStatus);
00094 
00095         // See Note 2
00096         CActiveScheduler::Start();
00097         User::LeaveIfError(activeListener->iStatus.Int());
00098 
00099 
00100         CleanupStack::PopAndDestroy(2); // activeListener, imageTransform 
00101         }
00102 
00103 
00114 void CIclExample::SqueezeJpgBufferToBufferL(const TDesC& aSrcFileName, const TDesC& aDestFileName)
00115         {
00116         TPtr8 imageFromFilePtr = LoadImageIntoMemoryLC(aSrcFileName);
00117         HBufC8* destData = NULL;
00118 
00119         // Create CImageTransform object and push it on to the cleanup stack
00120         CImageTransform* imageTransform = CImageTransform::NewL(iFs);
00121         CleanupStack::PushL(imageTransform);
00122 
00123         imageTransform->SetSourceDataL(imageFromFilePtr);
00124         imageTransform->SetDestDataL(destData);
00125         imageTransform->SetTransformationsL(CImageTransform::ESqueeze);
00126         imageTransform->SetupL();
00127 
00128         TUid lSqUid = {KUidSqueezeTransformExtension    };
00129         TInt err = KErrNone;
00130         CSqueezeTransformExtension* lSqExt = static_cast<CSqueezeTransformExtension*>(imageTransform->Extension(lSqUid, err));
00131         if(!lSqExt)
00132                 {
00133                 User::Leave(err);
00134                 }
00135 
00136         // Squeeze by 5% of size in bytes
00137         TInt squeezeRate = 5;
00138         RFile file;
00139         User::LeaveIfError(file.Open(iFs, aSrcFileName, EFileRead));
00140         TInt filesize;
00141         User::LeaveIfError(file.Size(filesize));
00142         file.Close();
00143         TInt maxdestsize = filesize - ( (filesize * squeezeRate)/100 );
00144 
00145         // Set the desired max size of the squeezed file on the squeeze extension
00146         lSqExt->SetDestSizeInBytes(maxdestsize);
00147 
00148         // Call Transform() function of CImageTransform for image transform operation
00149         // See Note 1
00150         CActiveListener* activeListener = CreateAndInitializeActiveListenerLC();
00151 
00152         // Call Transform() function of CImageTransform for image transform operation
00153         imageTransform->Transform(activeListener->iStatus);
00154 
00155         // See Note 2
00156         CActiveScheduler::Start();
00157         User::LeaveIfError(activeListener->iStatus.Int());
00158         
00159         // write the descriptor to the output file
00160         User::LeaveIfError(file.Replace(iFs, aDestFileName, EFileWrite));
00161         file.Write(*destData);
00162         file.Close();
00163         delete destData;
00164 
00165         CleanupStack::PopAndDestroy(3); // activeListener, imageTransform, image 
00166         }
00167 
00168 
00179 void CIclExample::AutoSqueezeJpgFileToFileL(const TDesC& aSrcFileName, const TDesC& aDestFileName)
00180         {
00181         // Create CImageTransform object and push it on to the cleanup stack
00182         CImageTransform* imageTransform = CImageTransform::NewL(iFs);
00183         CleanupStack::PushL(imageTransform);
00184 
00185         imageTransform->SetSourceFilenameL(aSrcFileName);
00186         imageTransform->SetDestFilenameL(aDestFileName);
00187         imageTransform->SetTransformationsL(CImageTransform::ESqueeze);
00188         imageTransform->SetupL();
00189 
00190         TUid lSqUid = {KUidSqueezeTransformExtension    };
00191         TInt err = KErrNone;
00192         CSqueezeTransformExtension* lSqExt = static_cast<CSqueezeTransformExtension*>(imageTransform->Extension(lSqUid, err));
00193         if(!lSqExt)
00194                 {
00195                 User::Leave(err);
00196                 }
00197 
00198         // Squeeze by 5% of size in bytes
00199         TInt squeezeRate = 5;
00200         RFile file;
00201         User::LeaveIfError(file.Open(iFs, aSrcFileName, EFileRead));
00202         TInt filesize;
00203         User::LeaveIfError(file.Size(filesize));
00204         file.Close();
00205         TInt maxdestsize = filesize - ( (filesize * squeezeRate)/100 );
00206 
00207         // Get the pixel size of the image
00208         CJPEGImageFrameDecoder *decoder = NULL;
00209         decoder= static_cast<CJPEGImageFrameDecoder*> (CImageDecoder::FileNewL(iFs, aSrcFileName, CImageDecoder::EOptionNone, KNullUid, KNullUid, KImageFramePluginUid));
00210         const TFrameInfo* frameInfo = &decoder->FrameInfo();;
00211         TSize imgSizeInPixels = frameInfo->iOverallSizeInPixels;
00212         delete decoder;
00213 
00214         // Max pixel size may be 10% of the original size
00215         TSize maxImageSizeInPixels;
00216         maxImageSizeInPixels.iWidth = imgSizeInPixels.iWidth - (imgSizeInPixels.iWidth *10) /100;
00217         maxImageSizeInPixels.iHeight = imgSizeInPixels.iHeight - (imgSizeInPixels.iHeight *10) /100;
00218 
00219         // Min pixel size may be 30% of the original size
00220         TSize minImageSizeInPixels;
00221         minImageSizeInPixels.iWidth = imgSizeInPixels.iWidth - (imgSizeInPixels.iWidth *30) /100;
00222         minImageSizeInPixels.iHeight = imgSizeInPixels.iHeight - (imgSizeInPixels.iHeight *30) /100;
00223 
00224         // Set the various desired parmas for the auto squeeze
00225         TAdvancedSqueezeParams  squeezeAutoResizeParams;
00226         squeezeAutoResizeParams.iMaxDestSizeInBytes = maxdestsize;
00227         squeezeAutoResizeParams.iResizeAction = TAdvancedSqueezeParams::EAutoResizeActionPrioritizeLargeImageSize;
00228         squeezeAutoResizeParams.iMinImageSize = minImageSizeInPixels;
00229         squeezeAutoResizeParams.iMaxImageSize = maxImageSizeInPixels;
00230         squeezeAutoResizeParams.iSamplingUid = KUidSamplingColor422;
00231         squeezeAutoResizeParams.iMinEncodingQuality = 0.8f;
00232         // Set the advance params to the squeeze extension
00233         lSqExt->SetAdvancedSqueezeModeL(&squeezeAutoResizeParams);
00234 
00235 
00236         // Call Transform() function of CImageTransform for image transform operation
00237         // See Note 1
00238         CActiveListener* activeListener = CreateAndInitializeActiveListenerLC();
00239 
00240         // Call Transform() function of CImageTransform for image transform operation
00241         imageTransform->Transform(activeListener->iStatus);
00242 
00243         // See Note 2
00244         CActiveScheduler::Start();
00245         User::LeaveIfError(activeListener->iStatus.Int());
00246 
00247 
00248         CleanupStack::PopAndDestroy(2); // activeListener, imageTransform 
00249         }
00250         
00261 void CIclExample::RotateJpgFileToFileL(const TDesC& aSrcFileName, const TDesC& aDestFileName)
00262         {
00263         // Create CImageTransform object and push it on to the cleanup stack
00264         CImageTransform* imageTransform = CImageTransform::NewL(iFs);
00265         CleanupStack::PushL(imageTransform);
00266 
00267         imageTransform->SetSourceFilenameL(aSrcFileName);
00268         imageTransform->SetDestFilenameL(aDestFileName);
00269         imageTransform->SetTransformationsL(CImageTransform::EOrientation);
00270         imageTransform->SetupL();
00271 
00272         TUid lRotateUid = {KUidOrientationTransformExtension    };
00273         TInt err = KErrNone;
00274         COrientationTransformExtension* lRotateExt = static_cast<COrientationTransformExtension*>(imageTransform->Extension(lRotateUid, err));
00275         if(!lRotateExt)
00276                 {
00277                 User::Leave(err);
00278                 }
00279         // Rotate by 90 degree of size in bytes
00280         lRotateExt->SetOrientationL(COrientationTransformExtension::ERotation90DegreesClockwise);
00281 
00282         // Call Transform() function of CImageTransform for image transform operation
00283         // See Note 1
00284         CActiveListener* activeListener = CreateAndInitializeActiveListenerLC();
00285 
00286         // Call Transform() function of CImageTransform for image transform operation
00287         imageTransform->Transform(activeListener->iStatus);
00288 
00289         // See Note 2
00290         CActiveScheduler::Start();
00291         User::LeaveIfError(activeListener->iStatus.Int());
00292 
00293 
00294         CleanupStack::PopAndDestroy(2); // activeListener, imageTransform 
00295         }
00296 
00297 
00309 void CIclExample::OverlayJpgDataToJpgFileToFileL(const TDesC& aSrcFileName, const TDesC& aOverlayFileName, const TDesC& aDestFileName)
00310         {
00311         // Create CImageTransform object and push it on to the cleanup stack
00312         CImageTransform* imageTransform = CImageTransform::NewL(iFs);
00313         CleanupStack::PushL(imageTransform);
00314 
00315         imageTransform->SetSourceFilenameL(aSrcFileName);
00316         imageTransform->SetDestFilenameL(aDestFileName);
00317         imageTransform->SetTransformationsL(CImageTransform::EOverlay);
00318         imageTransform->SetupL();
00319 
00320         TUid lRotateUid = {KUidOverlayTransformExtension        };
00321         TInt err = KErrNone;
00322         COverlayTransformExtension* lOverlayExt = static_cast<COverlayTransformExtension*>(imageTransform->Extension(lRotateUid, err));
00323         if(!lOverlayExt)
00324                 {
00325                 User::Leave(err);
00326                 }
00327         // Set the position
00328         TPoint position(0,0);
00329         lOverlayExt->SetPosition(position);
00330 
00331         // Set the overlay file
00332         TPtr8 imageFromFilePtr = LoadImageIntoMemoryLC(aOverlayFileName);
00333         lOverlayExt->SetOverlayDataL(imageFromFilePtr, KImageTypeJPGUid);
00334         
00335         // Call Transform() function of CImageTransform for image transform operation
00336         // See Note 1
00337         CActiveListener* activeListener = CreateAndInitializeActiveListenerLC();
00338 
00339         // Call Transform() function of CImageTransform for image transform operation
00340         imageTransform->Transform(activeListener->iStatus);
00341 
00342         // See Note 2
00343         CActiveScheduler::Start();
00344         User::LeaveIfError(activeListener->iStatus.Int());
00345 
00346 
00347         CleanupStack::PopAndDestroy(3); // activeListener, overlay image, imageTransform 
00348         }
00349 
00361 void CIclExample::OverlayPngFileToJpgFileToFileL(const TDesC& aSrcFileName, const TDesC& aOverlayFileName, const TDesC& aDestFileName)
00362         {
00363         // Create CImageTransform object and push it on to the cleanup stack
00364         CImageTransform* imageTransform = CImageTransform::NewL(iFs);
00365         CleanupStack::PushL(imageTransform);
00366 
00367         imageTransform->SetSourceFilenameL(aSrcFileName);
00368         imageTransform->SetDestFilenameL(aDestFileName);
00369         imageTransform->SetTransformationsL(CImageTransform::EOverlay);
00370         imageTransform->SetupL();
00371 
00372         TUid lOverlayUid = {KUidOverlayTransformExtension       };
00373         TInt err = KErrNone;
00374         COverlayTransformExtension* lOverlayExt = static_cast<COverlayTransformExtension*>(imageTransform->Extension(lOverlayUid, err));
00375         if(!lOverlayExt)
00376                 {
00377                 User::Leave(err);
00378                 }
00379         // Set the position
00380         TPoint position(0,0);
00381         lOverlayExt->SetPosition(position);
00382 
00383         // Set the overlay data
00384         TUid pngUid = KImageTypePNGUid;
00385         lOverlayExt->SetOverlayFileL(aOverlayFileName, pngUid);
00386 
00387         // Call Transform() function of CImageTransform for image transform operation
00388         // See Note 1
00389         CActiveListener* activeListener = CreateAndInitializeActiveListenerLC();
00390 
00391         // Call Transform() function of CImageTransform for image transform operation
00392         imageTransform->Transform(activeListener->iStatus);
00393 
00394         // See Note 2
00395         CActiveScheduler::Start();
00396         User::LeaveIfError(activeListener->iStatus.Int());
00397 
00398 
00399         CleanupStack::PopAndDestroy(2); // activeListener, overlay image, imageTransform 
00400         }
00401 
00402 
00414 void CIclExample::OverlayBmpDataToJpgFileToFileL(const TDesC& aSrcFileName, const TDesC& aOverlayFileName, const TDesC& aDestFileName)
00415         {
00416         // Create CImageTransform object and push it on to the cleanup stack
00417         CImageTransform* imageTransform = CImageTransform::NewL(iFs);
00418         CleanupStack::PushL(imageTransform);
00419 
00420         imageTransform->SetSourceFilenameL(aSrcFileName);
00421         imageTransform->SetDestFilenameL(aDestFileName);
00422         imageTransform->SetTransformationsL(CImageTransform::EOverlay);
00423         imageTransform->SetupL();
00424 
00425         TUid lRotateUid = {KUidOverlayTransformExtension        };
00426         TInt err = KErrNone;
00427         COverlayTransformExtension* lOverlayExt = static_cast<COverlayTransformExtension*>(imageTransform->Extension(lRotateUid, err));
00428         if(!lOverlayExt)
00429                 {
00430                 User::Leave(err);
00431                 }
00432         // Set the position
00433         TPoint position(0,0);
00434         lOverlayExt->SetPosition(position);
00435 
00436         // Set the overlay bitmap
00437         CFbsBitmap* overlayBitmap = new (ELeave) CFbsBitmap;
00438         CleanupStack::PushL(overlayBitmap);     
00439         User::LeaveIfError(overlayBitmap->Load(aOverlayFileName));
00440         lOverlayExt->SetOverlayImageL(*overlayBitmap);
00441 
00442         
00443         // Call Transform() function of CImageTransform for image transform operation
00444         // See Note 1
00445         CActiveListener* activeListener = CreateAndInitializeActiveListenerLC();
00446 
00447         // Call Transform() function of CImageTransform for image transform operation
00448         imageTransform->Transform(activeListener->iStatus);
00449 
00450         // See Note 2
00451         CActiveScheduler::Start();
00452         User::LeaveIfError(activeListener->iStatus.Int());
00453 
00454 
00455         CleanupStack::PopAndDestroy(3); // activeListener, overlay bitmap, imageTransform 
00456         }
00457 

Generated on Thu Jan 21 10:32:59 2010 for TB10.1 Example Applications by  doxygen 1.5.3