// Copyright (c) 2001-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 <bitdev.h>

#include <bautils.h>

#include <barsc.h>

#include "ImageConversion.h"

#include "ImageClientMain.h"

#include "ImageConversionPriv.h"

#include "icl/ImagePlugin.h"

#include "icl/ImageConstruct.h"

#include "EnDecoderUtils.h"

/**

Constructor for this class.

*/

EXPORT_C CImageDecoderPlugin::CImageDecoderPlugin()

	{

	}

/**

Destructor for this class.

*/

EXPORT_C CImageDecoderPlugin::~CImageDecoderPlugin()

	{

	}

/**

Called when the plugin is destroyed or a decode is cancelled. This may be

overriden in derived classes.

Note:

Derived classes must call this version after performing any plugin

specific cleanup.

*/

EXPORT_C void CImageDecoderPlugin::Cleanup()

	{

	if(ValidProperties())

		iProperties->Cleanup();

	}

/**

Initialises data structures prior to decoding a frame.

This function may be overriden in derived classes. Any override should also

call this version after performing any plugin initialistion.

*/

EXPORT_C void CImageDecoderPlugin::InitConvertL()

	{

	ASSERT(ValidProperties());

	iProperties->InitConvertL();

	}

/**

Forces initialization of data structures prior to decoding a frame.

@param	aFrameNumber

        The frame in a multi-frame image to decode.

*/

EXPORT_C void CImageDecoderPlugin::RequestInitL(TInt aFrameNumber)

	{

	ASSERT(ValidProperties());

	iProperties->RequestInitL(aFrameNumber);

	}

/**

Performs a decode step. This effectively forms the RunL() call of the decoder.

This call may be overriden in derived classes. However, if this

the case, then if the custom decode is not performed and the derived class should

either ensure that this base class's version is called or should completely replace

the base class's version calling PrepareForProcessFrameL(), ProcessFrameL() and

HandleProcessFrameResult() as appropriate. Unlike the standard version, an override

instance may choose to spread these calls over several RunL() instances.

*/

EXPORT_C void CImageDecoderPlugin::DoConvert()

	{

	ASSERT(ValidProperties());

	iProperties->DoConvert();

	}

/**

Initialises system for ProcessFrameL(). This reads in a new buffer for ProcessFrameL().

*/

EXPORT_C void CImageDecoderPlugin::PrepareForProcessFrameL()

	{

	ASSERT(ValidProperties());

	iProperties->PrepareForProcessFrameL();

	}

/**

Deals with result from ProcessFrameL(). This function processes the results of the standard

ProcessFrameL() call, feeding in the resultant error code from its TRAP and the status result.

It will call RequestComplete() or SelfComplete() as appropriate.

Note that if no data was consumed by ProcessFrameL(), HandleProcessFrameResult() assumes that

it requires more data and calls RequestComplete(KErrUnderflow). If this is not appropriate, an

overloaded DoConvert() should be made to handle it.

@param  aErrCode

        The error result of TRAP arround ProcessFrameL().

@param  aCodecState

        The result of ProcessFrameL() itself.

*/

EXPORT_C void CImageDecoderPlugin::HandleProcessFrameResult(TInt aErrCode, TFrameState aCodecState)

	{

	ASSERT(ValidProperties());

	iProperties->HandleProcessFrameResult(aErrCode, aCodecState);

	}

/**

Value to be fed to CImageReadCodec::ProcessFrameL().

This value is setup by PrepareForProcessFrameL() - it returns the value that will be

fed to CImageReadCodec::ProcessFrameL(), and will be used by codecs that fully override

DoConvert().

*/

EXPORT_C TBufPtr8& CImageDecoderPlugin::SourceData()

	{

	ASSERT(ValidProperties());

	return iProperties->SourceData();

	}

/**

Returns the plugin's read codec.

@return Pointer to the plugin's read codec.

*/

EXPORT_C CImageReadCodec* CImageDecoderPlugin::ImageReadCodec() const

	{

	ASSERT(ValidProperties());

	return iProperties->ImageReadCodec();

	}

/**

Sets the plugin's read codec. Ownership of the codec is transferred to the plugin.

@param  aImageReadCodec

        Pointer to the codec.

*/

EXPORT_C void CImageDecoderPlugin::SetImageReadCodec(CImageReadCodec* aImageReadCodec)

	{

	ASSERT(ValidProperties());

	iProperties->SetImageReadCodec(aImageReadCodec);

	}

/**

Returns the maximum number of bytes of data that can be decoded.

@return The maximum number of bytes of data.

*/

EXPORT_C TInt CImageDecoderPlugin::DataLength() const

	{

	ASSERT(ValidProperties());

	return iProperties->DataLength();

	}

/**

Sets the maximum number of bytes of data that can be decoded.

@param  aDataLength

        The maximum number of bytes of data.

*/

EXPORT_C void CImageDecoderPlugin::SetDataLength(TInt aDataLength)

	{

	ASSERT(ValidProperties());

	iProperties->SetDataLength(aDataLength);

	}

/**

Returns the starting position of the frame to be decoded.

@return The starting position.

*/

EXPORT_C TInt CImageDecoderPlugin::StartPosition() const

	{

	ASSERT(ValidProperties());

	return iProperties->StartPosition();

	}

/**

Sets the starting position of the frame to be decoded.

@param  aStartPosition

        The starting position in the data.

*/

EXPORT_C void CImageDecoderPlugin::SetStartPosition(TInt aStartPosition)

	{

	ASSERT(ValidProperties());

	iProperties->SetStartPosition(aStartPosition);

	}

/**

Returns the image data block for the specified index.

@param	aIndex

        The index of the image data block to return.

@return The image data block.

*/

EXPORT_C const TImageDataBlock* CImageDecoderPlugin::ImageData(TInt aIndex) const

	{

	ASSERT(ValidProperties());

	return iProperties->ImageData(aIndex);

	}

/**

Inserts an image data block into the internally held array at the specified position.

@param  aEntry

        Pointer to the image data block to be inserted.

@param  aPos

        The position within the arrary to insert the data block.

@return KErrNone if the insertion was successful, otherwise a system

        wide error code.

*/

EXPORT_C TInt CImageDecoderPlugin::InsertImageData(const TImageDataBlock* aEntry, TInt aPos)

	{

	ASSERT(ValidProperties());

	return iProperties->InsertImageData(aEntry, aPos);

	}

/**

Removes a specified image data block from the internally held array.

@param  aPos

        The index of the image data block to be removed.

*/

EXPORT_C void CImageDecoderPlugin::RemoveImageData(TInt aPos)

	{

	ASSERT(ValidProperties());

	iProperties->RemoveImageData(aPos);

	}

/**

Appends a new image data data block to the end of the internally held array.

@param  aEntry

        The image data block to be appended.

@return An error code indicating if the function call was successful. KErrNone on success, otherwise

        another of the system-wide error codes.

*/

EXPORT_C TInt CImageDecoderPlugin::AppendImageData(const TImageDataBlock* aEntry)

	{

	ASSERT(ValidProperties());

	return iProperties->AppendImageData(aEntry);

	}

/**

Returns the number of image data blocks present in the image data.

@return The number of blocks.

*/

EXPORT_C TInt CImageDecoderPlugin::ImageDataCount() const

	{

	ASSERT(ValidProperties());

	return iProperties->ImageDataCount();

	}

/**

Appends a new image data buffer to the end of the internally held array

@param  aImageBuffer

        The data buffer to append.

@return An error code indicating if the function call was successful. KErrNone on success, otherwise

        another of the system-wide error codes.

*/

EXPORT_C TInt CImageDecoderPlugin::AppendImageDataBuffer(const HBufC8* aImageBuffer)

	{

	ASSERT(ValidProperties());

	return iProperties->AppendImageDataBuffer(aImageBuffer);

	}

/**

Returns the number of frames to be decoded.

@return The number of frames.

*/

EXPORT_C TInt CImageDecoderPlugin::NumberOfFrames() const

	{

	ASSERT(ValidProperties());

	return iProperties->NumberOfFrames();

	}

/**

Returns the current position within the data.

@return The current position.

*/

EXPORT_C TInt CImageDecoderPlugin::Position() const

	{

	ASSERT(ValidProperties());

	return iProperties->Position();

	}

/**

Sets the current position in the data.

@param  aPosition

        The current position in the data.

*/

EXPORT_C void CImageDecoderPlugin::SetPosition(const TInt aPosition)

	{

	ASSERT(ValidProperties());

	iProperties->SetPosition(aPosition);

	}

/**

Must be called on completion of decoding the image data.

@param  aReason

        KErrNone should be returned if the decoding completes successfully. If the

		request fails an appropriate error code should be returned.

@see    CImageDecoderPlugin::SelfComplete(TInt aReason)

*/

EXPORT_C void CImageDecoderPlugin::RequestComplete(TInt aReason)

	{

	ASSERT(ValidProperties());

	iProperties->RequestComplete(aReason);

	}

/**

Must be called at the end of a slice of decoding.

If successful specify KErrNone that results in a repeat call to DoConvert().

@param  aReason

        The error code giving the reason for completion, or KErrNone

        if no error occurred.

@see    CImageDecoderPlugin::RequestComplete(TInt aReason)

*/

EXPORT_C void CImageDecoderPlugin::SelfComplete(TInt aReason)

	{

	ASSERT(ValidProperties());

	iProperties->SelfComplete(aReason);

	}

/**

May be called at the start of a slice of decoding if the decoding

is expected to complete asynchronously. This sets the AO in CImageDecoderPriv

to active, but does not complete the request.

When decoding of the slice is complete, there must be a call to SelfComplete().

@see    CImageDecoderPlugin::SelfComplete(TInt aReason)

*/

EXPORT_C void CImageDecoderPlugin::SetSelfPending(void)

	{

	ASSERT(ValidProperties());

	iProperties->SetSelfPending();

	}

_LIT(KResourcePath,"\\Resource\\ICL\\");

_LIT(KExtraResourceExtension,"_extra.rsc");

/**

Locates the extra resource file for the decoder aUid_extra.rsc, opens

the resource file and pushes it on the cleanup stack.

If the resource file is not found the method leaves with KErrNotFound.

If more than one resource file is found, only the first one is opened.

@param	aFs

      	A reference to the file server.

@param	aUid

      	The decoder's UID.

@param	aResourceFile

      	A reference to the opened resource file.

*/

EXPORT_C void CImageDecoderPlugin::OpenExtraResourceFileLC(RFs& aFs, const TUid aUid, RResourceFile& aResourceFile) const

	{

	// Build the extra resource file name from the uid

	TFileName fileName;

	TUid implementationUid = iProperties->ImplementationUid();

	CImplementationInformationType* implementationInformation = CImplementationInformationType::NewLC();

	ImageEnDecoderUtils::DoGetImplementationInformationL(KImageDecoderInterfaceUid, *implementationInformation, implementationUid);

	fileName.Copy(implementationInformation->Drive().Name());

	CleanupStack::PopAndDestroy(implementationInformation);

	fileName.Append(KResourcePath);

	fileName.AppendNum(aUid.iUid,EHex);

	fileName.Append(KExtraResourceExtension);

	// Get the locale specific file

	BaflUtils::NearestLanguageFile(aFs,fileName);

	aResourceFile.OpenL(aFs,fileName);

	CleanupClosePushL(aResourceFile);

	}

/**

Reads a block of data into an internal buffer.

A block of data of size aLength is read from the position specified by aPosition

to an internal data buffer. After a successful read, aReadBuffer is set to point to

the internal buffer.

If an attempt is made to read past the end of data, all available data is read and the

descriptors length will indicate the actual number of bytes read.

@param  aPosition

        The start position from where data will be read.

@param  aReadBuffer

        Upon completion of a successful call, points to the internal buffer containing

        the data read from the source.

@param  aLength

        The size in bytes of the block of data to be read.

*/

EXPORT_C void CImageDecoderPlugin::ReadDataL(TInt aPosition, TPtrC8& aReadBuffer, TInt aLength)

	{

	ASSERT(ValidProperties());

	iProperties->ReadDataL(aPosition, aReadBuffer, aLength);

	}

/**

Returns image information such as colour depth, scaling support etc.

@return Image information.

*/

EXPORT_C const TFrameInfo& CImageDecoderPlugin::ImageInfo() const

	{

	ASSERT(ValidProperties());

	return iProperties->ImageInfo();

	}

/**

Sets the image information.

@param  aImageInfo

        The image information.

*/

EXPORT_C void CImageDecoderPlugin::SetImageInfo(const TFrameInfo& aImageInfo)

	{

	ASSERT(ValidProperties());

	iProperties->SetImageInfo(aImageInfo);

	}

/**

Returns the number of comments attatched to the image.

Some image formats allow comments to be attached to the entire image, others allow

comments to be attached to individual frames within the image. Use this function to

retrieve the number of comments in the image. Use NumberOfFrameComments() for the

frame equivalent.

@return The number of comments attatched to the image.

*/

EXPORT_C TInt CImageDecoderPlugin::NumberOfImageComments() const

	{

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

	return 0;

	}

/**

Returns a particular comment attatched to the image.

Ownership of the returned buffer is transferred to the caller.

@param  aCommentNumber

        The comment number.

@return A buffer containing the specified comment.

*/

EXPORT_C HBufC* CImageDecoderPlugin::ImageCommentL(TInt /* aCommentNumber */) const

	{

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

	Panic(ECommentsNotSupported);

	return NULL;

	}

/**

Returns the number of comments attatched to a given frame of the image.

Use NumberOfImageComments() for the image equivalent.

@param  aFrameNumber

        The frame number.

@return The number of comments attatched to a given frame of the image.

*/

EXPORT_C TInt CImageDecoderPlugin::NumberOfFrameComments(TInt aFrameNumber) const

	{

	ASSERT(ValidProperties());

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

	__ASSERT_ALWAYS((aFrameNumber >= 0) && (aFrameNumber < iProperties->FrameCount()), Panic(EFrameNumberOutOfRange));

	return 0;

	}

/**

Returns a particular comment attatched to a given frame of the image.

Ownership of the returned buffer is transferred to the caller.

@param  aFrameNumber

        The index of the frame containing the comments.

@param  aCommentNumber

        The index of the comment to retrieve from the specified frame.

@return A buffer containing the specified comment.

*/

EXPORT_C HBufC* CImageDecoderPlugin::FrameCommentL(TInt aFrameNumber, TInt /*aCommentNumber*/) const

	{

	ASSERT(ValidProperties());

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

	__ASSERT_ALWAYS((aFrameNumber >= 0) && (aFrameNumber < iProperties->FrameCount()), Panic(EFrameNumberOutOfRange));