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 <101F7BF5_extra.rsg>

    21 #include "TestCodec.h"

    22 #include "TestPanic.h"

    23 #include "TestDecs.h"

    24 #include "TestUids.hrh"

    25 

    26 _LIT(KTestPanicCategory, "TestConvertPlugin");

    27 

    28 

    29 // Global panic function

    30 GLDEF_C void Panic(TInt aError)

    31 	{

    32 	User::Panic(KTestPanicCategory, aError);

    33 	}

    34 

    35 

    36 // decoder.

    37 CTestDecoder* CTestDecoder::NewL(TBool aLeaveCorrupt)

    38 	{

    39 	return new(ELeave) CTestDecoder(aLeaveCorrupt);

    40 	}

    41 

    42 CTestDecoder::CTestDecoder(TBool aLeaveCorrupt):

    43 	iLeaveCorrupt(aLeaveCorrupt)

    44 	{}

    45 

    46 CTestDecoder::~CTestDecoder()

    47 	{

    48 	CImageDecoderPlugin::Cleanup();

    49 	}

    50 

    51 void CTestDecoder::ImageType(TInt aFrameNumber, TUid& aImageType, TUid& aImageSubType) const

    52 	{

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

    54 	aImageType = KImageTypeTestUid;

    55 	aImageSubType = KImageSubTypeTestUid;

    56 	}

    57 

    58 void CTestDecoder::ScanDataL()

    59 	{

    60 	if(iLeaveCorrupt)

    61 		User::Leave(KErrCorrupt);

    62 

    63 	SetDataLength(10);

    64 	TFrameInfo newFrameInfo;

    65 	SetImageInfo(newFrameInfo);

    66 

    67 	CTestReadCodec* imageReadCodec = new (ELeave) CTestReadCodec(*this);

    68 	SetImageReadCodec(imageReadCodec); 

    69 	imageReadCodec->ConstructL();

    70 

    71 	ReadFrameHeadersL();

    72 

    73 	}

    74 

    75 CFrameInfoStrings* CTestDecoder::FrameInfoStringsL(RFs& aFs, TInt aFrameNumber)

    76 	{

    77 	if (aFrameNumber!=0)

    78 		User::Leave(KErrArgument);

    79 

    80 	const TUid testCodecDllUid = {KTestDecoderDllUidValue};

    81 

    82 	RResourceFile resourceFile;

    83 	OpenExtraResourceFileLC(aFs,testCodecDllUid,resourceFile);

    84 

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

    86 	TResourceReader resourceReader;

    87 	resourceReader.SetBuffer(resourceInfo);

    88 

    89 	TBuf<128> info;

    90 	TBuf<128> templte;

    91 

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

    93 

    94 	info = resourceReader.ReadTPtrC();

    95 	frameInfoStrings->SetDecoderL(info);

    96 

    97 	info = resourceReader.ReadTPtrC();

    98 	frameInfoStrings->SetFormatL(info);

    99 

   100 	templte = resourceReader.ReadTPtrC();

   101 	const TFrameInfo& frameInfo = FrameInfo(aFrameNumber);

   102 	const TSize& size = frameInfo.iOverallSizeInPixels;

   103 	info.Format(templte, size.iWidth, size.iHeight);

   104 	frameInfoStrings->SetDimensionsL(info);

   105 

   106 	templte = resourceReader.ReadTPtrC();

   107 	iMaxValue = 10;

   108 	info.Format(templte, iMaxValue);

   109 	frameInfoStrings->SetDepthL(info);

   110 

   111 	// leave details blank

   112 

   113 	CleanupStack::Pop(frameInfoStrings); 

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

   115 	return frameInfoStrings;

   116 	}

   117 

   118 void CTestDecoder::DoConvert()

   119 	{

   120 	while(!ShouldAbort())

   121 		/* Wait for Cancel() to be called */;

   122 	RequestComplete(KErrDied);

   123 	}

   124 

   125 TInt CTestDecoder::NumberOfImageComments() const

   126 	{

   127 	return 1;

   128 	}

   129 

   130 HBufC* CTestDecoder::ImageCommentL(TInt /*aCommentNumber*/) const

   131 	{

   132 	HBufC* imageComment = HBufC::NewL(20);

   133 	TPtr ptr(imageComment->Des());

   134 	ptr.Copy(_L("Test Image Comment 1"));

   135 	return imageComment;

   136 	}

   137 

   138 TInt CTestDecoder::NumberOfFrameComments(TInt /*aFrameNumber*/) const

   139 	{

   140 	return 1;

   141 	}

   142 

   143 HBufC* CTestDecoder::FrameCommentL(TInt /*aFrameNumber*/, TInt /*aCommentNumber*/) const

   144 	{

   145 	HBufC* frameComment = HBufC::NewL(20);

   146 	TPtr ptr(frameComment->Des());

   147 	ptr.Copy(_L("Test Frame Comment 1"));

   148 	return frameComment;

   149 	}

   150 

   151 // decoder.

   152 CTestEncoder* CTestEncoder::NewL()

   153 	{

   154 	CTestEncoder* self;

   155 	self = new (ELeave) CTestEncoder;

   156 	return self;

   157 	}

   158 

   159 CTestEncoder::CTestEncoder()

   160 	{

   161 	}

   162 

   163 CTestEncoder::~CTestEncoder()

   164 	{

   165 	}

   166 

   167 void CTestEncoder::DoConvert()

   168 	{

   169 	while(!ShouldAbort())

   170 		/* Wait for Cancel() to be called */;

   171 	RequestComplete(KErrDied);

   172 	}

   173 

   174 void CTestEncoder::PrepareEncoderL(const CFrameImageData* /*aFrameImageData*/)

   175 	{

   176 	CImageWriteCodec* imageWriteCodec = new (ELeave) CTestWriteCodec;

   177 	SetImageWriteCodec(imageWriteCodec);

   178 	}

   179 

   180 void CTestEncoder::UpdateHeaderL()

   181 	{

   182 	}

   183 

   184 

   185 CTestExtendedDecoder* CTestExtendedDecoder::NewL()

   186 	{

   187 	CTestExtendedDecoder* self;

   188 	self = new (ELeave) CTestExtendedDecoder;

   189 	return self;

   190 	}

   191 

   192 CTestExtendedDecoder::~CTestExtendedDecoder()

   193 	{

   194 	

   195 	}

   196 	

   197 CTestExtendedDecoder::CTestExtendedDecoder()

   198 	{

   199 	

   200 	}

   201 	

   202 void CTestExtendedDecoder::ScanDataL()

   203 	{

   204 //	if(iLeaveCorrupt)

   205 //		User::Leave(KErrCorrupt);

   206 

   207 	SetDataLength(10);

   208 	TFrameInfo newFrameInfo;

   209 	SetImageInfo(newFrameInfo);

   210 

   211 	CTestReadCodec* imageReadCodec = new (ELeave) CTestReadCodec(*this);

   212 	SetImageReadCodec(imageReadCodec); 

   213 	imageReadCodec->ConstructL();

   214 

   215 	ReadFrameHeadersL();

   216 	}

   217 

   218 

   219 CTestExtendedEncoder* CTestExtendedEncoder::NewL()

   220 	{

   221 	CTestExtendedEncoder* self;

   222 	self = new (ELeave) CTestExtendedEncoder;

   223 	return self;

   224 	}

   225 

   226 CTestExtendedEncoder::~CTestExtendedEncoder()

   227 	{

   228 	

   229 	}

   230 

   231 CTestExtendedEncoder::CTestExtendedEncoder()

   232 	{

   233 	

   234 	}

   235