// Copyright (c) 1999-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 <barsc.h>
#include <barsread.h>
#include <bautils.h>
#include <imageconversion.h>
#include <101F45F1_extra.rsg>
#include "PPM1Codec.h"
#include "PPM1Panic.h"
#include "PPMDecs.h"
#include "PPM1Uids.hrh"

_LIT(KPPM1PanicCategory, "PPM1ConvertPlugin");


// Global panic function
GLDEF_C void Panic(TInt aError)
	{
	User::Panic(KPPM1PanicCategory, aError);
	}


// decoder.
CPpmDecoder* CPpmDecoder::NewL()
	{
	return new (ELeave) CPpmDecoder;
	}

CPpmDecoder::CPpmDecoder()
	{}

CPpmDecoder::~CPpmDecoder()
	{
	delete iExtensionManager;
	Cleanup();
	}

void CPpmDecoder::ImageType(TInt aFrameNumber, TUid& aImageType, TUid& aImageSubType) const
	{
	__ASSERT_ALWAYS(aFrameNumber == 0, Panic(EFrameNumberOutOfRange));
	aImageType = KImageTypePpmUid;
	aImageSubType = KNullUid;
	}

// Scan header.
// Validate that format is correct.
// Create codec.
// Fill in image info. (All frames)
void CPpmDecoder::ScanDataL()
	{
	ReadFormatL();
	
	ASSERT(ImageReadCodec() == NULL);
	CPpmReadCodec* imageReadCodec = CPpmReadCodec::NewL(*this); 
	SetImageReadCodec(imageReadCodec);
	
	if (!iExtensionManager)
		{
		// Manager settings persist over all frames.
		iExtensionManager = CPluginExtensionManager::NewL(imageReadCodec);
		}
	else
		{
		// Maintain manager settings, but reset the codec that it points to.
		iExtensionManager->ResetCodecExtension(imageReadCodec);
		}
	
	imageReadCodec->SetExtensionManager(iExtensionManager);

	ReadFrameHeadersL();
	}

const TInt KPpmFileHeaderSize = 512; // use a high figure to get around possible comments - assumes high enough

void CPpmDecoder::ReadFormatL()
	{
	TPtrC8 bufferDes;

	ReadDataL(0, bufferDes, KPpmFileHeaderSize);

	TLex8 lex (bufferDes);
	TRAPD(error, InternalizeHeaderL(lex));

	if (error!=KErrNone)
		{
		if (error==KErrGeneral) // treat as if underflow - means expected integers were not present
			{
			error = KErrUnderflow;
			}			
		User::Leave(error);
		}
	}

void CPpmDecoder::InternalizeHeaderL(TLex8& aLex)
	{
	SetInComment(EFalse); // since we read from the top, always assume is clear

	// first check we have either P3 or P6 at top of file
	TChar char1 = aLex.Get();
	if (char1!='P')
		{
		User::Leave(KErrNotSupported);
		}		
	TChar char2 = aLex.Get();
	if (char2=='3')
		{
		SetCompressed(EFalse);
		}		
	else if (char2=='6')
		{
		SetCompressed(ETrue);
		}		
	else
		{
		User::Leave(KErrNotSupported);
		}		

	SkipCommentAndWhiteSpaceL(aLex);

	TInt width;
	User::LeaveIfError(aLex.Val(width));

	SkipCommentAndWhiteSpaceL(aLex);

	TInt height;
	User::LeaveIfError(aLex.Val(height));

	SkipCommentAndWhiteSpaceL(aLex);

	TInt maxValue;
	User::LeaveIfError(aLex.Val(maxValue));
	if (maxValue>255)
		{
		User::Leave(KErrNotSupported);
		}		

	TInt bitsPerPixel, power;
	for (bitsPerPixel=1, power=2; maxValue>power-1; power<<=1, bitsPerPixel+=1)
		/*loop*/;

	if (Compressed()) 
		{
		aLex.Inc(); // skip over just the end of line
		}		

	// we are now pointing at the data

	SetStartPosition(aLex.Offset());
	SetDataLength(KMaxTInt); // we don't know image size, so set big

	TSize size = TSize(width, height);
	iMaxValue = maxValue;

	TFrameInfo imageInfo = ImageInfo();
	imageInfo.iFrameCoordsInPixels.SetRect(TPoint(0, 0), size);
	imageInfo.iOverallSizeInPixels = size;
	imageInfo.iFrameSizeInTwips = TSize(0, 0);
	imageInfo.iBitsPerPixel = bitsPerPixel;
	imageInfo.iDelay = 0;
	imageInfo.iFlags = TFrameInfo::EColor|TFrameInfo::ECanDither;
	TDisplayMode mode;
	if (bitsPerPixel<=4) // we always have rgb values
		{
		mode=EColor4K;
		}		
	else
		{
		mode=EColor16M;
		}		
	imageInfo.iFrameDisplayMode = mode;
	SetImageInfo(imageInfo);

	iDataShift = 8 - bitsPerPixel; // correct everything to 0..255
	ASSERT(iDataShift>=0);
	}

// looks for white space or comment, and will skip if found
void CPpmDecoder::SkipCommentAndWhiteSpaceL(TLex8& aLex)
	{
	if (InComment())
		{
		DoSkipCommentL(aLex);
		}		
	for (;;)
		{
		ASSERT(!InComment());
		TChar peek = aLex.Peek();
		if (peek==0) // overflowed end of descriptor
			{
			User::Leave(KErrUnderflow);
			}			
		else if (peek.IsSpace())
			{
			aLex.SkipSpace();
			}			
		else if (peek=='#') // comment - skip to end of line
			{
			DoSkipCommentL(aLex);
			}			
		else
			{
			break;
			}			
		}
	}

// we are in comment, so skip to end of line. If do not get there, register the fact
void CPpmDecoder::DoSkipCommentL(TLex8& aLex)
	{
	TChar ch;
	do
		{
		ch = aLex.Get();
		}
	while (ch != '\n');
	if (ch==0) // reached end of descriptor
		{
		SetInComment(ETrue);
		User::Leave(KErrUnderflow);
		}
	else
		{
		SetInComment(EFalse);
		}			
	}


CFrameInfoStrings* CPpmDecoder::FrameInfoStringsL(RFs& aFs, TInt aFrameNumber)
	{
	if (aFrameNumber!=0)
		{
		User::Leave(KErrArgument);
		}		

	const TUid ppmCodecDllUid = {KPpm1DecoderDllUidValue};

	RResourceFile resourceFile;
	OpenExtraResourceFileLC(aFs,ppmCodecDllUid,resourceFile);

	HBufC8* resourceInfo = resourceFile.AllocReadLC(THEDECODERINFO);
	TResourceReader resourceReader;
	resourceReader.SetBuffer(resourceInfo);

	TBuf<128> info;
	TBuf<128> templte;

	CFrameInfoStrings* frameInfoStrings = CFrameInfoStrings::NewLC();

	info = resourceReader.ReadTPtrC();
	frameInfoStrings->SetDecoderL(info);

	info = resourceReader.ReadTPtrC();
	frameInfoStrings->SetFormatL(info);

	templte = resourceReader.ReadTPtrC();
	const TFrameInfo& frameInfo = FrameInfo(aFrameNumber);
	const TSize& size = frameInfo.iOverallSizeInPixels;
	info.Format(templte, size.iWidth, size.iHeight);
	frameInfoStrings->SetDimensionsL(info);

	templte = resourceReader.ReadTPtrC();
	info.Format(templte, iMaxValue);
	frameInfoStrings->SetDepthL(info);

	CDesCArrayFlat* resourceArray = resourceReader.ReadDesCArrayL();
	CleanupStack::PushL(resourceArray);
	TUint formatIndex = Compressed() ? 1 : 0;
	info = (*resourceArray)[formatIndex];
	CleanupStack::PopAndDestroy(resourceArray);
	frameInfoStrings->SetDetailsL(info);
	
	CleanupStack::Pop(frameInfoStrings); 
	CleanupStack::PopAndDestroy(2); // resourceInfo + resourceFile
	return frameInfoStrings;
	}

void CPpmDecoder::GetExtensionL(TUid aExtUid, MImageConvExtension*& aExtPtr)
	{
	ASSERT(iExtensionManager);
	if(!Compressed())
		{
		User::Leave(KErrNotSupported);
		}
	iExtensionManager->GetExtensionL(aExtUid, aExtPtr);
	}

void CPpmDecoder::SetClippingRectL(const TRect* aClipRect)
	{
	if(!Compressed())
		{
		User::Leave(KErrNotSupported);
		}
	
	RPointerArray<TFrameInfo> frameInfo;
	CleanupClosePushL(frameInfo);
		
	// PPM only has a single frame
	frameInfo.AppendL(&FrameInfo(0));
	
	// The clipping operation is reset by passing a NULL rect pointer.
	ASSERT(iExtensionManager);
	iExtensionManager->SetClippingRectL(aClipRect, frameInfo);
	CleanupStack::PopAndDestroy(); // frameInfo
	}

TInt CPpmDecoder::GetDestinationSize(TSize& aSize, TInt aFrameNumber)
	{
	ASSERT(iExtensionManager);
	const TFrameInfo frameInfo = FrameInfo(aFrameNumber);
	TSize originalSize = frameInfo.iOverallSizeInPixels;
	TInt err = iExtensionManager->GetDestinationSize(originalSize);
	if(err == KErrNone)
		{
		aSize = originalSize;
		}
	return err;
	}

// PNG encoder
CPpmEncoder* CPpmEncoder::NewL()
	{
	return new(ELeave) CPpmEncoder;
	}

CPpmEncoder::CPpmEncoder()
	{
	}

CPpmEncoder::~CPpmEncoder()
	{
	CImageEncoderPlugin::Cleanup();
	}

void CPpmEncoder::PrepareEncoderL(const CFrameImageData* /*aFrameImageData*/)
	{
	CPpm1WriteCodec* codec = CPpm1WriteCodec::NewL();
	SetImageWriteCodec(codec);		// takes ownership of imageReadCodec
	}

void CPpmEncoder::UpdateHeaderL()
	{
	}

#ifndef EKA2

// DLL entry point
GLDEF_C TInt E32Dll(TDllReason /*aReason*/)
	{
	return KErrNone;
	}

#endif // EKA2