/*****************************************************************************
Copyright(c) 2005 Analog Devices, Inc.  All Rights Reserved. This software is 
proprietary and confidential to Analog Devices, Inc. and its licensors.
******************************************************************************

$RCSfile: JPEG_McuBuffer.c,v $
$Revision: 1.5 $
$Date: 2006/07/31 01:11:59 $

Project:	JPEG IMAGE CODEC
Title:		Example McuBuffer module
Author(s):	D.G, A.S, P.G
Revised by:

Description:
Mcu Data Buffer Managing Module

References:

******************************************************************************
Tab Setting:			4
Target Processor:		Blackfin
Target Tools Revision:	ccblkfn		C/C++ compiler					6.3.0.0
						easmblkfn	BlackFin assembler				2.2.4.1
						elfar		ELF Librarian/Archive Utility	4.4.1.2
						linker		Linker							2.8.8.2
******************************************************************************

Modification History:
====================
$Log: JPEG_McuBuffer.c,v $
Revision 1.5  2006/07/31 01:11:59  bmk
fixed a bug in 422


******************************************************************************/

#include <stdlib.h>				// NULL
#include <string.h>				// For memset()

#include "IMG_common.h"             // Common definitions
#include "JPEG_api_common.h"		//
#include "JPEG_UserTypeDefs.h"		// User defined typedefs
#include "JPEG_memalloc.h"
#define JPEGBUFFERVALIDATED
#if USE_DMA
#include "McuBufferDMA.h"		// DMA prototypes
#endif

#ifndef BLACKFIN_JPEG_ENC
#define BLACKFIN_JPEG_ENC
#endif

/****************************************************************************
 *		Local variables													    *
 ****************************************************************************/
/* MCU Constants: */
#define BLOCK_SIZE			64
#define BLOCK_WIDTH			8

// Output Side Macros
#define MAX_MCUBUFFERS	8			// Not necessarily multiple of 2

#define FREE			0
#define	BUSY			1
#ifndef JPEGBUFFERVALIDATED
static const int	MCU_SIZE_BASIC = 64;
#define LOG_BLOCK_SIZE		6
static const int	MCU_NO_OF_BUFFERS_SEQUENTIAL = 2;
static const int	MCU_NO_OF_BUFFERS_PROGRESSIVE = 2;
static const int	MCU_NO_OF_BUFFERS_LOSSLESS = 3;
#else
#define	MCU_SIZE_BASIC  64
#define LOG_BLOCK_SIZE		6
#define	MCU_NO_OF_BUFFERS_SEQUENTIAL  2
#define	MCU_NO_OF_BUFFERS_PROGRESSIVE  2
#define	MCU_NO_OF_BUFFERS_LOSSLESS  3
#endif
/****************************************************************************
 * 		Function Declarations												*
 ****************************************************************************/

/* Encoder functions: */
#ifdef BLACKFIN_JPEG_ENC
	extern void gFormMCU420JpegEnc_BLACKFIN(tMcuBuffer *, uint8 *mcuData);
	extern void gFormMCU422JpegEnc_BLACKFIN(tMcuBuffer *, uint8 *mcuData);
	extern void gFormMCU444JpegEnc_BLACKFIN(tMcuBuffer *, uint8 *mcuData);
	extern void gFormMCU400JpegEnc_BLACKFIN(tMcuBuffer *, uint8 *mcuData);
	extern void gFormRowLosslessJpegEnc_BLACKFIN(tMcuBuffer *, uint8 *mcuData);
#endif
#ifndef JPEGBUFFERVALIDATED
static void     sFormRowLossless(tMcuBuffer *mcuHandle, uint8 *mcuData);

static int32	JPEG_McuBuffer_Sequential_READ(tMcuBuffer *);
static int32	JPEG_McuBuffer_Progressive_READ(tMcuBuffer *);
static int32	JPEG_McuBuffer_Lossless_READ(tMcuBuffer *);
static void	    JPEG_McuBuffer_Progressive_NEXT(tMcuBuffer *);
static void	    JPEG_McuBuffer_Lossless_NEXT(tMcuBuffer *);

static void	    sFormMCU400(tMcuBuffer *mbdata, uint8 *mcudata);
static void	    sFormMCU420(tMcuBuffer *mbdata, uint8 *mcudata);
static void	    sFormMCU422(tMcuBuffer *mbdata, uint8 *mcudata);
static void	    sFormMCU444(tMcuBuffer *mbdata, uint8 *mcudata);

/* Decoder functions: */
static void     sStoreMcuBuffer(uint8 *currFrame, uint8 *outBuffer, int32 x,
							                         int32 y, int32 frameWidth);
static void     sStore420McuBuffer(tMcuBuffer *lDer);
static void     sStore422McuBuffer(tMcuBuffer *lDer);
static void     sStore444McuBuffer(tMcuBuffer *lDer);
static void     sStoreMonoMcuBuffer(tMcuBuffer *lDer);
static void     sStoreLosslessMcuBuffer(tMcuBuffer *lDer);
#else
int32	JPEG_McuBuffer_Sequential_READ(tMcuBuffer *);
int32	JPEG_McuBuffer_Progressive_READ(tMcuBuffer *);
int32	JPEG_McuBuffer_Lossless_READ(tMcuBuffer *);
void    JPEG_McuBuffer_Lossless_NEXT(tMcuBuffer *);
void     sStore420McuBuffer(tMcuBuffer *lDer);
void     sStore422McuBuffer(tMcuBuffer *lDer);
void     sStore444McuBuffer(tMcuBuffer *lDer);
void     sStoreMonoMcuBuffer(tMcuBuffer *lDer);
void     sStoreLosslessMcuBuffer(tMcuBuffer *lDer);
#endif

// Tempoary workaround to get the output buffer pointer updated.
void *mcu_ex;


/*
********************************************************************************
** Function:		JPEG_McuBuffer_NEW
**
** Description:		This function creates a new instance of MCU buffer object.
**					After calling this function, JPEG_McuBuffer_CONFIG is called
**					to set all fields to required values.
**
** Arguments:		None
**
** Outputs:
**
** Return value:	Handle to new MCU buffer instance. NULL upon failure.
********************************************************************************
*/
tMcuBuffer *JPEG_McuBuffer_NEW(void)
{
	tMcuBuffer *mcu;
	MemObjHandle	*MemObj;

	MemObj = JPEG_MemAlloc_NEW(1, sizeof(tMcuBuffer), MEM_TYPE_OBJECT);
	if (MemObj==NULL)
		return NULL;
	mcu = (tMcuBuffer *)JPEG_MemAlloc_ADDRESS(MemObj);

	// Reset the MCU buffer parameters
	memset (mcu, 0, sizeof(tMcuBuffer));

	// Save pointer to this memory object.
	mcu->ThisMemObj = MemObj;

	/* To be assigned (and tested against zero) in JPEG_McuBuffer_INIT() */
	mcu->mcubuffer = NULL;
	mcu->interLeaveFormat = 0;
	mcu->encodingMode = 0;
	
	mcu_ex = (void*)mcu;

	return mcu;
}

/*
********************************************************************************
** Function:		JPEG_McuBuffer_DELETE
**
** Description:		This function deletes the MCU buffer object, releasing its
**					memory.
**
** Arguments:
**	mcuHandle[IN]	Handle to the Mcu Buffer data access instance.
**
** Outputs:
**
** Return value:	None
********************************************************************************
*/
void JPEG_McuBuffer_DELETE(tMcuBuffer *mcu)
{
	// Deallocate buffer memory object
	JPEG_MemAlloc_DELETE(mcu->BufferMemObj);

	// Deallocate tMcuBuffer memory object itself
	JPEG_MemAlloc_DELETE(mcu->ThisMemObj);

	/* Decoder specific memory clean up */
	if ( !(mcu->is_encoder) )
	{
    	// Deallocate mcuFree memory object
    	JPEG_MemAlloc_DELETE(mcu->mcuFreeMemObj);
    }
}


/*
********************************************************************************
** Function:		JPEG_McuBuffer_CONFIG
**
** Description:		This function configures the instance of an image data access
**					object with the given configuration value.
**
** Arguments:
**	mcuHandle[IN]	Handle to the Mcu Buffer data access instance.
**	item [IN]		Item to configure.
**	value[IN]		Configuration value.
**
** Outputs:
**
** Return value:	E_TRUE or E_FALSE
********************************************************************************
*/
int JPEG_McuBuffer_CONFIG(tMcuBuffer *mcu, eMcu_config item, unsigned int value)
{
	int32 		lReturn = E_TRUE;

	switch(item)
	{
		case MCU_ENCODER:
			mcu->is_encoder = value;
			break;
		case MCU_POINTER_C1:
			mcu->frameCurrPos = (uint8 *) value;
			break;
		case MCU_POINTER_C2:
//			mcu->cbCurrPos = (uint8 *) value;
			break;
		case MCU_POINTER_C3:
//			mcu->crCurrPos = (uint8 *) value;
			break;
		case MCU_FRAME_WIDTH:
			mcu->frameWidth = value;
			break;
		case MCU_FRAME_HEIGHT:
			mcu->frameHeight = value;
			break;
		case MCU_ORIGINAL_FRAME_WIDTH:
			mcu->originalFramWidth = value;
			break;
		case MCU_ORIGINAL_FRAME_HEIGHT:
			mcu->originalFramHeight = value;
			break;
		case MCU_IMAGE_FORMAT:
			mcu->interLeaveFormat = value;
			break;
		case MCU_ENCODING_MODE:
			mcu->encodingMode = value;
			break;
//		case MCU_COMP_NUMBER:
//			mcu->componentNumber = value;
//			break;
		case MCU_COMP_FRAME:
			mcu->frameCurrPos = (uint8 *)value;
			break;

		default:
			lReturn = E_FALSE;
	}

	return lReturn;
}

/*
********************************************************************************
** Function:		JPEG_McuBuffer_INIT
**
** Description:		This function initialises the instance of an image data
**					access object, allocating any memory. JPEG_McuBuffer_CONFIG
*					must have been called before calling this function.
**
** Arguments:
**	mcuHandle[IN]	Handle to the Mcu Buffer data access instance.
**
** Outputs:
**
** Return value:	1 if successful; 0 otherwise
********************************************************************************
*/
int JPEG_McuBuffer_INIT(tMcuBuffer *mcu)
{
	int	            lReturn = 1;
	MemObjHandle    *MemObj;


	if(mcu->is_encoder)
	{
    	switch(mcu->encodingMode)
    	{
    		case SEQUENTIAL:
    			mcu->numberOfBuffers = MCU_NO_OF_BUFFERS_SEQUENTIAL;
    			switch(mcu->interLeaveFormat)
    			{
    				case YUV420:
    	 				mcu->mcuSize = (6 * MCU_SIZE_BASIC);
    	 				break;
    				case YUV422:
    	 				mcu->mcuSize = (4 * MCU_SIZE_BASIC);
    	 				break;
    				case YUV444:
    				case RGB:
    		 			mcu->mcuSize = (3 * MCU_SIZE_BASIC);
    		 			break;
    				case MONOCHROME:
    		 			mcu->mcuSize = MCU_SIZE_BASIC;
    		 			break;
    		 		default:
    		 			lReturn = 0;
    		 			break;
    			}
    			break;
    		case PROGRESSIVE:
    			mcu->numberOfBuffers = MCU_NO_OF_BUFFERS_PROGRESSIVE;
    			mcu->mcuSize = MCU_SIZE_BASIC;
    			break;
    		case LOSSLESS:
    			mcu->numberOfBuffers = MCU_NO_OF_BUFFERS_LOSSLESS;
    			mcu->mcuSize = mcu->frameWidth;
    			break;
    		default:
    			lReturn = 0;
    			break;
    	}
	}
	else
	{

    	/* Allocate memory for mcuFree: */
    	mcu->numberOfBuffers = MAX_MCUBUFFERS;
    	MemObj = JPEG_MemAlloc_NEW(1, mcu->numberOfBuffers * sizeof(int), MEM_TYPE_OBJECT);
    	if(MemObj==NULL)
    	{
    		return NULL;
    	}
    	mcu->mcuFree = (int *)JPEG_MemAlloc_ADDRESS(MemObj);
    	mcu->mcuFreeMemObj = MemObj;

		mcu->componentNumber = 3;

		if(mcu->interLeaveFormat == YUV444 || mcu->interLeaveFormat == RGB)
		{
			mcu->mcuSize = 3 * MCU_SIZE_BASIC;
		}
		else
		{
			if(mcu->interLeaveFormat == YUV422)
			{
				mcu->mcuSize = 8 * MCU_SIZE_BASIC;
			}
			else
			{
				if(mcu->interLeaveFormat == YUV420)
				{
					mcu->mcuSize = 6 * MCU_SIZE_BASIC;
				}
				else /* MONOCHROME */
				{
        			mcu->componentNumber = 1;
					mcu->mcuSize =  MCU_SIZE_BASIC;
				}
			}
		}
	}

	MemObj = JPEG_MemAlloc_NEW(1, mcu->mcuSize * sizeof(uint8) * mcu->numberOfBuffers, MEM_TYPE_DATA);
	if (MemObj==NULL)
		lReturn = E_FALSE;

	mcu->mcubuffer = (uint8 *)JPEG_MemAlloc_ADDRESS(MemObj);

	// Save pointer to this memory object.
	mcu->BufferMemObj = MemObj;

	return lReturn;
}


/*
********************************************************************************
** Function:		JPEG_McuBuffer_RESET
**
** Description:		This function resets the instance of an image data access
**					object, but must NOT modify items set in JPEG_McuBuffer_CONFIG
**
** Arguments:
**	mcuHandle[IN]	Handle to the Mcu Buffer data access instance.
**
** Outputs:
**
** Return value:	E_TRUE or E_FALSE
********************************************************************************
*/
int32 JPEG_McuBuffer_RESET(tMcuBuffer *mcu)
{
    int32	 lFrameSize;

    /* common settings requiring reset between images */

    /* reset frame component pointers to top left hand corner */
	mcu->lumCurrPos = mcu->frameCurrPos;
	lFrameSize = mcu->frameWidth * mcu->frameHeight;
	mcu->cbCurrPos = mcu->frameCurrPos + lFrameSize;
	switch(mcu->interLeaveFormat)
	{
		case YUV420: //4:2:0
				lFrameSize = lFrameSize >> 2;
				break;
		case YUV422: //4:2:2
				lFrameSize = lFrameSize >> 1;
				break;
		case YUV444: //4:4:4
				break;
		case MONOCHROME:	//4:0:0
				lFrameSize = 0;
				break;
		case RGB: //RGB
				break;
	}
	mcu->crCurrPos = mcu->cbCurrPos + lFrameSize;

	mcu->x = 0;
	mcu->y = 0;

	if(mcu->is_encoder)
	{


    	mcu->mcuBufferIndex = 0;
    	mcu->processBufferIndex = 0;
    	mcu->numberOfEmptyBuffers = mcu->numberOfBuffers;

    	mcu->componentNumber = 0; // Used for PROGRESSIVE & LOSSLESS only

    	/* Starting values of progressive frame parameters */
    	if(mcu->encodingMode == PROGRESSIVE)
    	{
    		/* Frame width & height of each progressive-mode scan */
    		int	 progressiveFrameWidth = mcu->originalFramWidth;
    		int	 progressiveFrameHeight = mcu->originalFramHeight;


    		mcu->component_next = 0;

    		// Set counter for first component
    		// Counter is equal to number of MCUs per frame,
    		// rounded up to a multiple of the MCU width and height:
    	 	progressiveFrameWidth += BLOCK_WIDTH - 1;
    		progressiveFrameWidth /= BLOCK_WIDTH;
    		progressiveFrameWidth *= BLOCK_WIDTH;

    	 	progressiveFrameHeight += BLOCK_WIDTH - 1;
    		progressiveFrameHeight /= BLOCK_WIDTH;
    		progressiveFrameHeight *= BLOCK_WIDTH;

    		mcu->progressiveBlockCount = progressiveFrameWidth * progressiveFrameHeight;
    		mcu->progressiveBlockCount /= BLOCK_SIZE;
//    		mcu->progressiveBlockCount /= BLOCK_SIZE;

    		/* Adjust frame dimensions to be used for components after first: */
    		if(mcu->interLeaveFormat == YUV420)
    		{
    			progressiveFrameWidth >>= 1;
    			progressiveFrameHeight >>= 1;
    		}
    		else if(mcu->interLeaveFormat == YUV422)
    		{
    			progressiveFrameWidth >>= 1;
    		}

    		/* Round up to a multiple of the MCU width or height before dividing by it: */