// Copyright (c) 2005-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:

//

/**

 @file

 @internalTechnology 

*/

#include "jpgimageframeprocessor.h"

#include <imageframeformats.hrh>

#include <imageframe.h>

#include "JpegConsts.h"

#include "JPEGCodec.h"

const TInt KLayoutIndex0 = 0;

const TInt KLayoutIndex1 = 1;

const TInt KLayoutIndex2 = 2;

const TInt KErrValue	 = -1;

// these are symmetrical values

const TInt KYUVMonoSampleRatio[] = {1, -1};

const TInt KYUV422SampleRatio[] =  {1, -1};

const TInt KYUV420SampleRatio[] =  {1, 2, 2, -1};

CImageFrame& CJpgImageFrameProcessor::ImageFrame() const

	{

	return *iFrame;

	}

void CJpgImageFrameProcessor::GetCurrentPosition(TPoint& aPosition) const

	{

	aPosition = iCurrentPosition;

	}

void CJpgImageFrameProcessor::SetCurrentPosition(const TPoint& aPosition)

	{

	iCurrentPosition = aPosition;

	}

CJpgImageFrameProcessor::CJpgImageFrameProcessor(CImageFrame& aFrame) : iFrame(&aFrame),

																		iIndexY(KErrValue),

																		iIndexU(KErrValue),

																		iIndexV(KErrValue)

	{

	}

CJpgImageFrameProcessor::~CJpgImageFrameProcessor()

	{

	delete iLayout;

	}

void CJpgImageFrameProcessor::ConstructL(const TFrameLayoutBase& aLayout)

	{

	iLayout = static_cast<TFrameLayout*>(aLayout.DuplicateL());

	}

TBool CJpgImageFrameProcessor::MoreData()

	{

	TSize remain = iMaxPlaneSize - iCurrentPosition;

	return (remain.iHeight > 0 && remain.iWidth > 0);

	}

void CJpgImageFrameProcessor::CalculateCorrections()

	{

	iWCorrection = (iMaxPlaneSize.iWidth - (iCurrentPosition.iX + iBlockSize.iWidth));

	iHCorrection = (iMaxPlaneSize.iHeight - (iCurrentPosition.iY + iBlockSize.iHeight));

	//compensations are negative values

	if (iWCorrection > 0)

		{

		iWCorrection = 0;

		}

	if (iHCorrection > 0)

		{

		iHCorrection = 0;

		}

	}

void CJpgImageFrameProcessor::CalculateNextBlockStart(TInt aScanLine)

	{

	iCurrentPosition.iX += iBlockSize.iWidth;

	if (iCurrentPosition.iX >= aScanLine)

		{

		// move to the next row

		iCurrentPosition.iX = 0;

		iCurrentPosition.iY += iBlockSize.iHeight;

		}

	}

void CJpgImageFrameProcessor::ValidateCurrentBlockL()

	{	

	const TFrameLayout& layout = static_cast<const TFrameLayout&>(iFrame->FrameLayout());

	// for all indexes check 

	for (TInt index = 0; index < layout.Planes(); index++)

		{	

		// whether lengths are correct

		if ((layout.Length(index) < layout.CurrentLength(index)) || (layout.CurrentLength(index) < 0) )

			{

			User::Leave(KErrArgument);

			}

        // then calculate offsets from start 

		TInt scanLength = layout.ScanLength(index);

	    TInt offset = iCurrentPosition.iY / iVertSampleRatio[index] * scanLength + 

	    			  iCurrentPosition.iX / iHorzSampleRatio[index];  

	    // and check whether the starting point is within the proper range

		if (offset < layout.Length(index))

			{

			iOffsets[index] = offset;

			}

		else 		

			{

			// position is incorrect - exceeding the allocated memory size

			User::Leave(KErrOverflow);

			}

		}	

	CalculateCorrections();

	}

void CJpgImageFrameProcessor::DoWriteBlock(TUint8* aDest, const TDataUnit& aSrc, 

										   TInt aScanline, TInt aXComp, TInt aYComp)

	{

	for (TInt m = 0, rowStart = 0, i = 0; i < KJpgDCTBlockWidth + aYComp; i++, rowStart += aScanline)

		{

		for (TInt j = 0; j < KJpgDCTBlockWidth + aXComp; j++, m++)

			{

			*(aDest+rowStart+j) = Clip(aSrc.iCoeff[m]);

			}

		m -= aXComp; //compensations are negative values 

		}

	}

void CJpgImageFrameProcessor::DoReadBlock(TDataUnit& aDest, const TUint8* aSrc, 

										  TInt aScanline, TInt aXComp, TInt aYComp)										  

	{

	TInt rowStart = 0;

	TInt i;

	TInt j;

	TInt m=0;

	for (i = 0; i < KJpgDCTBlockWidth + aYComp; i++, rowStart += aScanline)

		{

		for (j = 0; j < KJpgDCTBlockWidth + aXComp; j++, m++)

			{

			aDest.iCoeff[m]= *(aSrc+rowStart+j);

			}

		// need to repeat the last data if position falls outside of the image

		if (aXComp)

			{

			TInt16 data = aDest.iCoeff[m-1];

			for ( TInt k = j; k < KJpgDCTBlockWidth; k++, m++)

				{

				aDest.iCoeff[m] = data;

				}

			}

		}

	// if there a rows otside of the image, repeat the last row which falls in the image

	if (aYComp)

		{

		for (TInt k = i; k < KJpgDCTBlockWidth; k++)

			{

			Mem::Copy(&aDest.iCoeff[(k) * KJpgDCTBlockWidth], 

					  &aDest.iCoeff[(i-1) * KJpgDCTBlockWidth], 

					  KJpgDCTBlockWidth * sizeof(TInt16));	

			}

		}

	}

/*********************************Monochrome*******************************************/

CJpgImageFrameYUVMonoProcessor::CJpgImageFrameYUVMonoProcessor(CImageFrame& aFrame) : CJpgImageFrameProcessor(aFrame)

	{

	iIndexY = 0;

	iMaxHorzPlaneFactor = 1;

	iMaxVertPlaneFactor = 1;

	iHorzSampleRatio = KYUVMonoSampleRatio;

	iVertSampleRatio = KYUVMonoSampleRatio;

	iBlockSize.iWidth = KJpgDCTBlockWidth * iMaxHorzPlaneFactor;

	iBlockSize.iHeight = KJpgDCTBlockWidth * iMaxVertPlaneFactor;

	iMaxPlaneSize = TSize(iMaxHorzPlaneFactor * iFrame->FrameSizeInPixels().iWidth, 

						  iMaxVertPlaneFactor * iFrame->FrameSizeInPixels().iHeight);

	} 

TDataUnit* CJpgImageFrameYUVMonoProcessor::ReadBlockL()

	{

	ValidateCurrentBlockL();

	TUint8* p = &(iFrame->Data()[iLayout->Start(KLayoutIndex0) + iOffsets[KLayoutIndex0]]);

	// set the data to zero 

	Mem::FillZ(&iDataUnit, sizeof(TDataUnit));

	DoReadBlock(iDataUnit[0], p, iLayout->ScanLength(KLayoutIndex0), iWCorrection, iHCorrection);

	CalculateNextBlockStart(iLayout->ScanLength(KLayoutIndex0));

	return iDataUnit;

	}

void CJpgImageFrameYUVMonoProcessor::WriteBlockL(const RArray<const TDataUnit*>& aDataUnit)

	{

	ValidateCurrentBlockL();

	TUint8* p = &(iFrame->Data()[iLayout->Start(KLayoutIndex0) + iOffsets[KLayoutIndex0]]);

	DoWriteBlock(p, *aDataUnit[0], iLayout->ScanLength(KLayoutIndex0), 

				iWCorrection, iHCorrection);

	UpdateCurrentLengthL();

	CalculateNextBlockStart(iLayout->ScanLength(KLayoutIndex0));

	}

void CJpgImageFrameYUVMonoProcessor::UpdateCurrentLengthL()

	{

	TInt currentLength = iOffsets[KLayoutIndex0] + (iBlockSize.iHeight + iHCorrection - 1) * iLayout->ScanLength(KLayoutIndex0) + iBlockSize.iWidth + iWCorrection;

	iLayout->SetCurrentLength(KLayoutIndex0, currentLength);

    iFrame->SetFrameLayoutL(*iLayout);

	}

/********************************CJpgImageFrameYUV422InterleavedProcessor********************/

CJpgImageFrameYUV422InterleavedProcessor::CJpgImageFrameYUV422InterleavedProcessor(CImageFrame& aFrame) : CJpgImageFrameProcessor(aFrame)

	{

	iIndexY = 0;

	iIndexU = 2;

	iIndexV = 3;

	iHorzSampleRatio = KYUV422SampleRatio;

	iVertSampleRatio = KYUV422SampleRatio;

	iMaxHorzPlaneFactor = 2;

	iMaxVertPlaneFactor = 1;

	iBlockSize.iWidth = KJpgDCTBlockWidth * iMaxHorzPlaneFactor * 2;

	iBlockSize.iHeight = KJpgDCTBlockWidth * iMaxVertPlaneFactor;

	iMaxPlaneSize = TSize(iMaxHorzPlaneFactor * iFrame->FrameSizeInPixels().iWidth, 

						  iMaxVertPlaneFactor * iFrame->FrameSizeInPixels().iHeight);

	} 

TDataUnit* CJpgImageFrameYUV422InterleavedProcessor::ReadBlockL()

	{

	ValidateCurrentBlockL();

	TUint8* p = &(iFrame->Data()[iLayout->Start(KLayoutIndex0) + iOffsets[KLayoutIndex0]]);

	// set the data to zero 

	Mem::FillZ(&iDataUnit, KUnitsYCbCr422 * sizeof(TDataUnit));

	TInt rowStart = 0;

	TInt i;

	TInt j;

	TInt m=0;

	TInt l=0;

	for (i = 0; i < iBlockSize.iHeight + iHCorrection; i++, rowStart += iLayout->ScanLength(KLayoutIndex0))

		{

		iIndexY = 0;

		l = KJpgDCTBlockWidth * i;	

		for (j = 0; j < iBlockSize.iWidth + iWCorrection; j+=4, m++, l+=2)

			{	

			if (j == KJpgDCTBlockWidth * 2)

				{

				iIndexY = 1;

				l = KJpgDCTBlockWidth * i;

				}

			// U plane	

			iDataUnit[iIndexU].iCoeff[m]= *(p+rowStart+j);

			// Y plane

			iDataUnit[iIndexY].iCoeff[l]= *(p+rowStart+j+1);

			// V plane

			iDataUnit[iIndexV].iCoeff[m]= *(p+rowStart+j+2);	

			// Y1 plane

			iDataUnit[iIndexY].iCoeff[l+1]= *(p+rowStart+j+3);			 

			}

			if (iWCorrection)

				{

				TInt16 data = iDataUnit[iIndexY].iCoeff[l - 1];

				for (TInt k = j; k < iBlockSize.iWidth; k += 4, m++, l += 2)

					{

					if (k == KJpgDCTBlockWidth * 2)

						{

						iIndexY = 1;

						l = KJpgDCTBlockWidth * i;

						}

					// U plane	

					iDataUnit[iIndexU].iCoeff[m] = iDataUnit[iIndexU].iCoeff[m-1];

					// Y plane

					iDataUnit[iIndexY].iCoeff[l] = data;

					// V plane 

					iDataUnit[iIndexV].iCoeff[m] = iDataUnit[iIndexV].iCoeff[m-1];	

					// Y1 plane

					iDataUnit[iIndexY].iCoeff[l+1] = data; 

					}

				}

			}

	if (iHCorrection)

		{

		for (TInt k = i; k < iBlockSize.iHeight; k++)

			{

			for (TInt block = 0; block < KUnitsYCbCr422; block ++ )

				{

				Mem::Copy(&iDataUnit[block].iCoeff[(k) * KJpgDCTBlockWidth], 

						  &iDataUnit[block].iCoeff[(k-1) * KJpgDCTBlockWidth], 

						  KJpgDCTBlockWidth * sizeof(TInt16));		

				}

			}

		}

	CalculateNextBlockStart(iLayout->ScanLength(KLayoutIndex0));

	return iDataUnit;

	}

void CJpgImageFrameYUV422InterleavedProcessor::WriteBlockL(const RArray<const TDataUnit*>& aDataUnit)

	{

	ValidateCurrentBlockL();

	TUint8* p = &(iFrame->Data()[iLayout->Start(KLayoutIndex0) + iOffsets[KLayoutIndex0]]);

	TInt rowStart = 0;

	TInt i;

	TInt j;

	TInt m = 0;

	TInt l = 0;

 	for (i = 0; i < iBlockSize.iHeight + iHCorrection; i++, rowStart += iLayout->ScanLength(KLayoutIndex0))

		{

		iIndexY = 0;

		l = KJpgDCTBlockWidth * i;	

		for (j = 0; j < iBlockSize.iWidth + iWCorrection; j += 4, m++, l += 2)

			{

			// switch between Y blocks using the current index as a guidance	

			if (j == KJpgDCTBlockWidth * 2)

				{

				iIndexY = 1;

				l = KJpgDCTBlockWidth * i;

				}

			// U plane	

			*(p+rowStart+j)	  = Clip(aDataUnit[iIndexU]->iCoeff[m]);

			// Y plane

			*(p+rowStart+j+1) =	Clip(aDataUnit[iIndexY]->iCoeff[l]);

			// V plane

			*(p+rowStart+j+2) =	Clip(aDataUnit[iIndexV]->iCoeff[m]);	

			// Y1 plane

			*(p+rowStart+j+3) =	Clip(aDataUnit[iIndexY]->iCoeff[l+1]);			 

			}

			m = l = KJpgDCTBlockWidth * (i + 1);

		}

	UpdateCurrentLengthL();

	// where is the update for the current frame

	CalculateNextBlockStart(iLayout->ScanLength(KLayoutIndex0));

	}

void CJpgImageFrameYUV422InterleavedProcessor::UpdateCurrentLengthL()

	{

	TInt currentLength = iOffsets[KLayoutIndex0] + (iBlockSize.iHeight + iHCorrection - 1) * iLayout->ScanLength(KLayoutIndex0) + iBlockSize.iWidth + iWCorrection;

	iLayout->SetCurrentLength(KLayoutIndex0, currentLength);

    iFrame->SetFrameLayoutL(*iLayout);

	}

/***********************CJpgImageFrameYUV420PlanarProcessor********************/

CJpgImageFrameYUV420PlanarProcessor::CJpgImageFrameYUV420PlanarProcessor(CImageFrame& aFrame) : CJpgImageFrameProcessor(aFrame)

	{	

	iIndexY = 0;

	if (static_cast<const TFrameFormat&>(aFrame.FrameFormat()).FormatCode() == KUidFormatYUV420Planar)

		{

		iIndexU = 4;

		iIndexV = 5;

		}

	else

		{

		iIndexU = 5;

		iIndexV = 4;

		}

	iMaxHorzPlaneFactor = 1;

	iMaxVertPlaneFactor = 1;

	iHorzSampleRatio = KYUV420SampleRatio;

	iVertSampleRatio = KYUV420SampleRatio;

	iBlockSize.iWidth = KJpgDCTBlockWidth * 2;

	iBlockSize.iHeight = KJpgDCTBlockWidth * 2;

	iMaxPlaneSize = TSize(iMaxHorzPlaneFactor * iFrame->FrameSizeInPixels().iWidth, iMaxVertPlaneFactor * iFrame->FrameSizeInPixels().iHeight);

	} 

TDataUnit* CJpgImageFrameYUV420PlanarProcessor::ReadBlockL()

	{

	ValidateCurrentBlockL();

	// set the data to zero 

	Mem::FillZ(&iDataUnit[0], KUnitsYCbCr420 * sizeof(TDataUnit));

	TUint8* p = &(iFrame->Data()[iLayout->Start(KLayoutIndex0) + iOffsets[KLayoutIndex0]]);

	// Y plane

	TInt i;

	TInt j;

	TInt l=0;	

	TInt rowStart = 0;

    // initially copy the the data from the image

    // however when MCU is partially outside the image the remaining elements are filled in

    // using replication, along rows and copying rows afterwards 

	for (i = 0; i < iBlockSize.iHeight + iHCorrection; i++, rowStart += iLayout->ScanLength(KLayoutIndex0))

		{

		iIndexY = (i < KJpgDCTBlockWidth)? 0: 2;

		l = (iIndexY == 0) ? (i * KJpgDCTBlockWidth):(i * KJpgDCTBlockWidth - KJpgDCTBlockSize);

		for (j = 0; j < iBlockSize.iWidth + iWCorrection; j++, l++)

			{

			if (j == KJpgDCTBlockWidth)

				{

				l = (iIndexY == 0)?(i * KJpgDCTBlockWidth) : (i * KJpgDCTBlockWidth - KJpgDCTBlockSize);

				iIndexY++;

				}

			iDataUnit[iIndexY].iCoeff[l] = *(p+rowStart+j);

			}	

		// need to repeat the last data

		if (iWCorrection)

			{

			TInt16 data = iDataUnit[iIndexY].iCoeff[l - 1];

			for ( TInt k = j; k < iBlockSize.iWidth; k++, l++)

				{

				if (k == KJpgDCTBlockWidth)

					{

					l = (iIndexY == 0)?(i * KJpgDCTBlockWidth):(i * KJpgDCTBlockWidth - KJpgDCTBlockSize);

					iIndexY++;

					}

				iDataUnit[iIndexY].iCoeff[l] = data;

				}

			}

		}

	// if there are rows outside the image, use the last row to fill them in

	if (iHCorrection)

		{

		TInt iIndexYO = 0;

		iIndexY = 0;

		TInt line;

		TInt origline = iBlockSize.iHeight + iHCorrection - 1;

		if (origline >= KJpgDCTBlockWidth)

				{

				iIndexYO = 2;

				origline -= KJpgDCTBlockWidth;

				}

		for (TInt k = iBlockSize.iHeight + iHCorrection; k < iBlockSize.iHeight; k++)

			{

			line = k;

			if (k>=KJpgDCTBlockWidth)

				{

				iIndexY = 2;

				line = k - KJpgDCTBlockWidth;

				}

			Mem::Copy(&iDataUnit[iIndexY].iCoeff[(line) * KJpgDCTBlockWidth], 

					  &iDataUnit[iIndexYO].iCoeff[origline * KJpgDCTBlockWidth], 

					  KJpgDCTBlockWidth * sizeof(TInt16));

			Mem::Copy(&iDataUnit[iIndexY+1].iCoeff[(line) * KJpgDCTBlockWidth], 

			          &iDataUnit[iIndexYO+1].iCoeff[origline * KJpgDCTBlockWidth], 

			          KJpgDCTBlockWidth * sizeof(TInt16));	

			}

		}

	// U plane 

	p = &(iFrame->Data()[iLayout->Start(KLayoutIndex1) + iOffsets[KLayoutIndex1]]);

	DoReadBlock(iDataUnit[iIndexU], p, iLayout->ScanLength(KLayoutIndex1), 

				iWCorrection / iHorzSampleRatio[KLayoutIndex1], 

				iHCorrection / iVertSampleRatio[KLayoutIndex1]);	

	// V plane

	p = &(iFrame->Data()[iLayout->Start(KLayoutIndex2) +  iOffsets[KLayoutIndex2]]);

	DoReadBlock(iDataUnit[iIndexV], p, iLayout->ScanLength(KLayoutIndex2), 

				iWCorrection / iHorzSampleRatio[KLayoutIndex2], 

				iHCorrection / iVertSampleRatio[KLayoutIndex2]);	

   	CalculateNextBlockStart(iLayout->ScanLength(KLayoutIndex0));

	return iDataUnit;

	}

void CJpgImageFrameYUV420PlanarProcessor::WriteBlockL(const RArray<const TDataUnit*>& aDataUnit)

	{

	ValidateCurrentBlockL();	

	TUint8* p = &(iFrame->Data()[iLayout->Start(KLayoutIndex0) + iOffsets[KLayoutIndex0]]);

	TInt l=0;

	TInt rowStart = 0;

    // Y plane - 4 blocks - iIndexY is used to select the correct data unit depending on the position

    // they are organised 0, 1

    //                    2, 3 

	for (TInt i = 0; i < iBlockSize.iHeight + iHCorrection; i++, rowStart += iLayout->ScanLength(KLayoutIndex0))

		{	

		iIndexY = (i < KJpgDCTBlockWidth) ? 0: 2;

		l = (iIndexY == 0) ? (i * KJpgDCTBlockWidth) : (i * KJpgDCTBlockWidth - KJpgDCTBlockSize);