diff -r 000000000000 -r 5752a19fdefe imaging/imagingfws/MediaClientImage/Source/Client/Image/MCLVID.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/imaging/imagingfws/MediaClientImage/Source/Client/Image/MCLVID.CPP Wed Aug 25 12:29:52 2010 +0300 @@ -0,0 +1,650 @@ +// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +#include +#include +#include "MdaImageConverter.inl" +#include +#include "CompatAids.h" + +#if defined(__ECOM_POWERDOWN_WORKAROUND) +// const TInt KWaitTimeMax = 8; // EABI warning removal +// const TInt KWaitTimeIncrement = 250000; // 0.25s // EABI warning removal +#endif // defined(__ECOM_POWERDOWN_WORKAROUND) + +GLREF_C void Panic (TInt aPanic); + +// +// CMdaImageUtility +// + +CMdaImageUtility::CMdaImageUtility() : CActive(CActive::EPriorityStandard) + { + } + +CMdaImageUtility::~CMdaImageUtility() + { + delete iProperties; + } + +/** +Closes the open file-based or descriptor-based image. + +Any conversion operation in progress is cancelled. +*/ +EXPORT_C void CMdaImageUtility::Close() + { + ASSERT(iProperties); + iProperties->Close(); + } + +void CMdaImageUtility::DoClose() + { + ASSERT(iProperties); + iProperties->DoClose(); + } + +void CMdaImageUtility::SelfComplete(TInt aError) + { + TRequestStatus *status = &iStatus; + SetActive(); + User::RequestComplete(status, aError); + } + +/** +Retrieves information about the specified frame. + +This function should only be called after an existing image has been +successfully opened or a new image successfully created. + +@param aFrame + The frame number. This value is relative to zero. The + value must be less than the total number of frames in + the image, otherwise the function raises a USER 0 + panic +@param aInfo + A reference to the frame information. +*/ +EXPORT_C void CMdaImageUtility::FrameInfo(TInt aFrame, TFrameInfo& aInfo) const + { + ASSERT(iProperties); + iProperties->FrameInfo(aFrame, aInfo); + } + +/** +Returns the number of frames in the image, counting from the first frame in the image, to the next frame to be decoded. + +Note: +The image conversion utilities do not scan all the image data on calling OpenL(), just the header. Therefore, if, as in +the case of an animated gif, there is no frame count in the header, then until all the frames in the image have been +decoded, the total frame count is unknown. Initially therefore, FrameCount() returns 1, but this increments as each frame +is decoded, and the utility reads the next frame's header. Once the last frame has been decoded, all frames are available +for access as the information about each frame is stored. + +@return The number of frames in the image +*/ +EXPORT_C TInt CMdaImageUtility::FrameCount() const + { + ASSERT(iProperties); + return iProperties->FrameCount(); + } + +void CMdaImageUtility::ImageUtil_Reserved1() + {} + +void CMdaImageUtility::ImageUtil_Reserved2() + {} + +void CMdaImageUtility::ImageUtil_Reserved3() + {} + +void CMdaImageUtility::ImageUtil_Reserved4() + {} + +void CMdaImageUtility::DoCancel() + { + iProperties->DoCancel(); + } + +void CMdaImageUtility::MoscoStateChangeEvent(CBase* /*aObject*/, TInt /*aPreviousState*/, + TInt /*aCurrentState*/, TInt /*aErrorCode*/) + { + __PANIC_COMPAT(Panic(EMDAImConvPanicNotImplemented)); + } + +// +// CMdaImageDataReadUtility +// + +/** +Default destructor. +*/ +CMdaImageDataReadUtility::~CMdaImageDataReadUtility() + { + } + +EXPORT_C void CMdaImageDataReadUtility::ConvertL(CFbsBitmap& aBitmap,TInt aFrameNumber) + { + ASSERT(Properties()); + Properties()->ConvertL(aBitmap, aFrameNumber); + } + +EXPORT_C void CMdaImageDataReadUtility::ConvertL(CFbsBitmap& aBitmap,CFbsBitmap& aMaskBitmap,TInt aFrameNumber) + { + ASSERT(Properties()); + Properties()->ConvertL(aBitmap, aMaskBitmap, aFrameNumber); + } + +EXPORT_C void CMdaImageDataReadUtility::CancelConvertL() + { + ASSERT(Properties()); + Properties()->CancelConvertL(); + } + +void CMdaImageDataReadUtility::RunL() + { + ASSERT(Properties()); + Properties()->RunL(); + } + +void CMdaImageDataReadUtility::DoCancel() + { + ASSERT(Properties()); + Properties()->DoCancel(); + } + +/** +Returns a particular comment attached to a given frame of the image +This function has been superceded by the parallel one in CImageDecoder, +as this assumes that each frame has a comment within it, which is not always the case. +@param aFrameNumber The Frame Number within the image from which to retrieve the specified comment +@return The specified comment +*/ + +EXPORT_C const TDesC& CMdaImageDataReadUtility::FrameCommentL(TInt aFrameNumber) + { + ASSERT(Properties()); + return Properties()->FrameCommentL(aFrameNumber); + } + +// Used to ensure ordinals in MediaClientImage.def file remain unchanged +// CMdaImageDataReadUtility::SourcePort() was removed from the public API +EXPORT_C void ImageReadUtilSourcePort_Reserved() + {Panic(EMDAImConvPanicNotImplemented);} + +void CMdaImageDataReadUtility::ImageReadUtil_Reserved2() + {} + +void CMdaImageDataReadUtility::ImageReadUtil_Reserved3() + {} + +void CMdaImageDataReadUtility::ImageReadUtil_Reserved4() + {} + +void CMdaImageDataReadUtility::DoClose() + { + ASSERT(Properties()); + Properties()->DoClose(); + } + +// +// CMdaImageDataWriteUtility +// + +CMdaImageDataWriteUtility::~CMdaImageDataWriteUtility() + { + } + +/** +@internalComponent +*/ +EXPORT_C void CMdaImageDataWriteUtility::ConvertL(CFbsBitmap& aBitmap,TInt aFrameNumber) + { + ASSERT(Properties()); + Properties()->ConvertL(aBitmap, aFrameNumber); + } +/** +@param aBitmap + Not used. +@param aSourceRect + Not used. +@param aFrameNumber + Not used. +*/ +EXPORT_C void CMdaImageDataWriteUtility::ConvertL(CFbsBitmap& /*aBitmap*/,const TRect& /*aSourceRect*/,TInt /*aFrameNumber*/) + { + User::Leave(KErrNotSupported); + } +/** +@see CMdaImageUtility::ConvertL(CFbsBitmap& aBitmap,CFbsBitmap& aMaskBitmap,TInt aFrameNumber) + +@param aBitmap + Not used. +@param aMaskBitmap + Not used. +@param aFrameNumber + Not used. +*/ +EXPORT_C void CMdaImageDataWriteUtility::ConvertL(CFbsBitmap& /*aBitmap*/,CFbsBitmap& /*aMaskBitmap*/,TInt /*aFrameNumber*/) + { + User::Leave(KErrNotSupported); + } + +EXPORT_C void CMdaImageDataWriteUtility::CancelConvertL() + { + ASSERT(Properties()); + Properties()->CancelConvertL(); + } + +void CMdaImageDataWriteUtility::RunL() + { + ASSERT(Properties()); + Properties()->RunL(); + } + +void CMdaImageDataWriteUtility::DoCancel() + { + ASSERT(Properties()); + Properties()->DoCancel(); + } + +CImageEncoder* CMdaImageDataWriteUtility::Encoder() const + { + ASSERT(Properties()); + return Properties()->Encoder(); + } + +void CMdaImageDataWriteUtility::ImageWriteUtil_Reserved1() + {} + +void CMdaImageDataWriteUtility::ImageWriteUtil_Reserved2() + {} + +void CMdaImageDataWriteUtility::ImageWriteUtil_Reserved3() + {} + +void CMdaImageDataWriteUtility::DoClose() + { + ASSERT(Properties()); + Properties()->DoClose(); + } + +// +// CMdaImageFileToBitmapUtility +// + +/** +Constructs a new instance of the file based image to bitmap conversion +utility object. + +The function leaves if this object cannot be created. + +@param aObserver + The image utility observer interface +@param aServer + A pointer to a server object. The default is NULL + which means that one is automatically constructed and + owned by this conversion utility object. If not NULL, + the client must construct, and be responsible for, the + server object. This option may be more efficient if a + number of conversion utility objects are to be + created. +@return A pointer to the new instance of the file based image to + bitmap conversion utility. +*/ +EXPORT_C CMdaImageFileToBitmapUtility* CMdaImageFileToBitmapUtility::NewL(MMdaImageUtilObserver& aObserver,CMdaServer* /*aServer*/) + { + CMdaImageFileToBitmapUtility* self = new(ELeave) CMdaImageFileToBitmapUtility(); + CleanupStack::PushL(self); + self->iProperties = CMdaImageFileToBitmapUtilityPriv::NewL(aObserver, self); + CleanupStack::Pop(); // self + return self; + } + +/** +Opens the existing file based image. + +The function is asynchronous. When the operation is complete, +successfully or otherwise, the callback function +MMdaImageUtilObserver::MiuoOpenComplete() is called.Open +must complete successfully before starting any conversion operation. +The function can complete with KErrUnderflow, if there is +insufficient information in the file. Typically, this occurs when +using the file as a cache. In this situation, open should be performed +repeatedly until the file has accumulated enough information for the +operation to complete with KErrNone.NotesThe optional +parameters can be used to force the Media Server to interpret the file +as being of a specific type. This is necessary for formats such as WAP +wireless bitmap where the supplied file does not contain a uniquely +recognisable signature. + +@param aFileName + The full path name of the file. +@param aFormat + The data format. This is optional. +@param aCodec + The codec to use. This is optional. +@param aExtra + Any additional information which the Media Server may need + to recognise the data format. This is optional. +*/ +EXPORT_C void CMdaImageFileToBitmapUtility::OpenL(const TDesC& aFileName,TMdaClipFormat* aFormat,TMdaPackage* aCodec,TMdaPackage* aExtra) + { + ASSERT(Properties()); + Properties()->OpenL(aFileName, aFormat, aCodec, aExtra); + } + + +// +// CMdaImageDescToBitmapUtility +// + +/** +Constructs a new instance of the descriptor-based image to bitmap +conversion utility object. + +The function leaves if this object cannot be created. + +@param aObserver + The image utility observer interface. +@param aServer + A pointer to a server object. The default is NULL + which means that one is automatically constructed and + owned by this conversion utility object. If not NULL, + the client must construct, and be responsible for, the + server object. This option may be more efficient if a + number of conversion utility objects are to be + created. +@return A pointer to the new instance of the descriptor-based + image to bitmap conversion utility +*/ +EXPORT_C CMdaImageDescToBitmapUtility* CMdaImageDescToBitmapUtility::NewL(MMdaImageUtilObserver& aObserver,CMdaServer* /*aServer*/) + { + CMdaImageDescToBitmapUtility* self = new(ELeave) CMdaImageDescToBitmapUtility(); + CleanupStack::PushL(self); + self->iProperties = CMdaImageDescToBitmapUtilityPriv::NewL(aObserver, self); + CleanupStack::Pop(); // self + return self; + } + +/** +Opens the descriptor-based image. + +The function is asynchronous. When the open operation is complete, +successfully or otherwise, the callback function +MMdaImageUtilObserver::MiuoOpenComplete() is called.Open +must complete successfully before starting any conversion operation. +The function can complete with KErrUnderflow, if there is +insufficient information in the descriptor. Typically, this occurs +when using the descriptor as a cache. In this situation, open should +be performed repeatedly until the descriptor has accumulated enough +information for the operation to complete with +KErrNone. + +Note: +The optional parameters can be used to +force the Media Server to interpret the descriptor-based data as being +of a specific type. This is necessary for formats such as WAP wireless +bitmap where the supplied descriptor does not contain a uniquely +recognisable signature. + +@param aDescriptor + A descriptor containing the image. +@param aFormat + The data format. This is optional. +@param aCodec + The codec to use. This is optional. +@param aExtra + Additional information which the Media Server may need + to recognise the data format. This is optional. +*/ +EXPORT_C void CMdaImageDescToBitmapUtility::OpenL(const TDesC8& aDescriptor,TMdaClipFormat* aFormat,TMdaPackage* aCodec,TMdaPackage* aExtra) + { + ASSERT(Properties()); + Properties()->OpenL(aDescriptor, aFormat, aCodec, aExtra); + } + +// +// CMdaImageBitmapToFileUtility +// + +/** +Constructs a new instance of the bitmap to file-based image conversion +utility. + +The function leaves if this object cannot be created. + +@param aObserver + The image utility observer interface +@param aServer + A pointer to a server object. The default is NULL + which means that one is automatically constructed and + owned by this conversion utility object. If not NULL, + the client must construct, and be responsible for, the + server object. This option may be more efficient if a + number of conversion utility objects are to be + created. +@return A pointer to the new instance of the bitmap to + file-based image conversion utility. +*/ +EXPORT_C CMdaImageBitmapToFileUtility* CMdaImageBitmapToFileUtility::NewL(MMdaImageUtilObserver& aObserver,CMdaServer* /*aServer*/) + { + CMdaImageBitmapToFileUtility* self = new(ELeave) CMdaImageBitmapToFileUtility(); + CleanupStack::PushL(self); + self->iProperties = CMdaImageBitmapToFileUtilityPriv::NewL(aObserver, self); + CleanupStack::Pop(); // self + return self; + } + +/** +Creates a new file to receive the file-based image. + +The function is asynchronous. When the operation is complete, +successfully or otherwise, the callback function +MMdaImageUtilObserver::MiuoCreateComplete() is called. The +file must be have been created before any conversion operation can +start. Note, however, that the file will expand to accommodate the +data i.e. image data is not truncated if the original size of the +file is too small. + +@param aFileName + The full path name of the file to be created. +@param aFormat + The data format. +@param aCodec + The codec to use. +@param aExtra + Any additional information which the Media Server may need + to recognise the data format. +*/ +EXPORT_C void CMdaImageBitmapToFileUtility::CreateL(const TDesC& aFileName,TMdaClipFormat* aFormat,TMdaPackage* aCodec,TMdaPackage* aExtra) + { + ASSERT(Properties()); + Properties()->CreateL(aFileName, aFormat, aCodec, aExtra); + } + +// +// CMdaImageBitmapToDescUtility +// + +/** +Constructs a new instance of the bitmap to descriptor-based image +conversion utility. + +The function leaves if this object cannot be created. + +@param aObserver + The image utility observer interface +@param aServer + A pointer to a server object. The default is NULL + which means that one is automatically constructed and + owned by this conversion utility object. If not NULL, + the client must construct, and be responsible for, the + server object. This option may be more efficient if a + number of conversion utility objects are to be + created. +@return A pointer to the new instance of the bitmap to + descriptor-based image conversion utility. +*/ +EXPORT_C CMdaImageBitmapToDescUtility* CMdaImageBitmapToDescUtility::NewL(MMdaImageUtilObserver& aObserver,CMdaServer* /*aServer*/) + { + CMdaImageBitmapToDescUtility* self = new(ELeave) CMdaImageBitmapToDescUtility(); + CleanupStack::PushL(self); + self->iProperties = CMdaImageBitmapToDescUtilityPriv::NewL(aObserver, self); + CleanupStack::Pop(); + return self; + } + +/** +Initialises the supplied descriptor to receive the descriptor-based +image. + +The function is asynchronous. When the operation is complete, +successfully or otherwise, the callback function +MMdaImageUtilObserver::MiuoCreateComplete() is called.The +descriptor must have been successfully initialised before any +conversion operation can start. + +@param aDescriptor + A descriptor to contain the image. +@param aFormat + The data format. This is optional. +@param aCodec + The codec to use. This is optional. +@param aExtra + Additional information which the Media Server may need + to recognise the data format. This is optional. +*/ +EXPORT_C void CMdaImageBitmapToDescUtility::CreateL(TDes8& aDescriptor,TMdaClipFormat* aFormat,TMdaPackage* aCodec,TMdaPackage* aExtra) + { + ASSERT(Properties()); + Properties()->CreateL(aDescriptor, aFormat, aCodec, aExtra); + } + +/** +Constructs and initialises a new instance of the bitmap converter. + +The function leaves if the bitmap converter object cannot be created. + +@param aObserver + The image utility observer interface. +@param aServer + A pointer to a server object. The default is NULL which means that one is automatically constructed + and owned by this conversion utility object. If not NULL, the client must construct, and be responsible + for, the server object. This option may be more efficient if a number of conversion utility objects + are to be created. + +@return A pointer to the new bitmap converter object. +*/ +EXPORT_C CMdaImageBitmapToBitmapUtility* CMdaImageBitmapToBitmapUtility::NewL(MMdaImageUtilObserver& aObserver, CMdaServer* /* aServer */) + { + CMdaImageBitmapToBitmapUtility* self = new(ELeave) CMdaImageBitmapToBitmapUtility(); + CleanupStack::PushL(self); + self->iProperties = CMdaImageBitmapToBitmapUtilityPriv::NewL(aObserver, self); + CleanupStack::Pop(); // self + return self; + } + +/** +Destructor. +*/ +EXPORT_C CMdaImageBitmapToBitmapUtility::~CMdaImageBitmapToBitmapUtility() + { + } + +/** +Opens the bitmap converter utility. + +The function is asynchronous. When the open operation is complete, successfully or otherwise, the callback +function MMdaImageUtilObserver::MiuoOpenComplete() is called. + +The source bitmap must be open before any conversion operation can start. + +@param aBitmap + The bitmap to be used as the source for subsequent conversions. +*/ +EXPORT_C void CMdaImageBitmapToBitmapUtility::OpenL(CFbsBitmap& aBitmap) + { + ASSERT(Properties()); + Properties()->OpenL(aBitmap); + } + +/** +Converts a bitmap. + +The operation is asynchronous. When the conversion operation is complete, successfully or +otherwise, the callback function MMdaImageUtilObserver::MiuoConvertComplete() is called. + +@param aBitmap + The destination bitmap. +@param aFrameNumber + The frame number. This value is relative to zero. +*/ +EXPORT_C void CMdaImageBitmapToBitmapUtility::ConvertL(CFbsBitmap& aBitmap, TInt aFrameNumber) + { + ASSERT(Properties()); + Properties()->ConvertL(aBitmap, aFrameNumber); + } + +/** +Converts a bitmap with a mask. Not supported + +@param aBitmap + A reference to the bitmap which is the target of the conversion operation. +@param aMaskBitmap + The overloaded variant which takes this argument is not supported for bitmap to bitmap + conversion. This variant leaves with KErrNotSupported. +@param aFrameNumber + The frame number. This value is relative to zero. + +@since Not supported +*/ +EXPORT_C void CMdaImageBitmapToBitmapUtility::ConvertL(CFbsBitmap& /* aBitmap */, CFbsBitmap& /* aMaskBitmap */, TInt /* aFrameNumber = 0 */) + { + User::Leave(KErrNotSupported); + } + +/** +Cancels any conversion in progress. + +The callback function MMdaImageUtilObserver::MiuoConvertComplete() is not called. +*/ +EXPORT_C void CMdaImageBitmapToBitmapUtility::CancelConvertL() + { + ASSERT(Properties()); + Properties()->CancelConvertL(); + } + +void CMdaImageBitmapToBitmapUtility::RunL() + { + ASSERT(Properties()); + Properties()->RunL(); + } + +/** +Implements cancellation of an outstanding request. +*/ +void CMdaImageBitmapToBitmapUtility::DoCancel() + { + ASSERT(Properties()); + Properties()->DoCancel(); + } + + +void CMdaImageBitmapToBitmapUtility::DoClose() + { + Properties()->DoClose(); + } +