xref: /external/neven/Embedded/common/src/b_ImageEm/UInt16BytePyrImage.c

/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* ---- includes ----------------------------------------------------------- */

#include "b_BasicEm/Math.h"
#include "b_BasicEm/Functions.h"
#include "b_ImageEm/Functions.h"
#include "b_ImageEm/UInt16BytePyrImage.h"

/* ------------------------------------------------------------------------- */

/* ========================================================================= */
/*                                                                           */
/* ---- \ghd{ auxiliary functions } ---------------------------------------- */
/*                                                                           */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */

/* ========================================================================= */
/*                                                                           */
/* ---- \ghd{ constructor / destructor } ----------------------------------- */
/*                                                                           */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */

void bim_UInt16BytePyrImage_init( struct bbs_Context* cpA,
								  struct bim_UInt16BytePyrImage* ptrA )
{
	bbs_UInt16Arr_init( cpA, &ptrA->arrE );
	ptrA->widthE = 0;
	ptrA->heightE = 0;
	ptrA->depthE = 0;
	ptrA->typeE = bim_UINT16_PYRAMIDAL_IMG;
}

/* ------------------------------------------------------------------------- */

void bim_UInt16BytePyrImage_exit( struct bbs_Context* cpA,
								  struct bim_UInt16BytePyrImage* ptrA )
{
	bbs_UInt16Arr_exit( cpA, &ptrA->arrE );
	ptrA->widthE = 0;
	ptrA->heightE = 0;
	ptrA->depthE = 0;
}

/* ------------------------------------------------------------------------- */

/* ========================================================================= */
/*                                                                           */
/* ---- \ghd{ operators } -------------------------------------------------- */
/*                                                                           */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */

void bim_UInt16BytePyrImage_copy( struct bbs_Context* cpA,
								  struct bim_UInt16BytePyrImage* ptrA,
								  const struct bim_UInt16BytePyrImage* srcPtrA )
{
#ifdef DEBUG1
	if( ptrA->arrE.allocatedSizeE < srcPtrA->arrE.allocatedSizeE )
	{
		bbs_ERROR0( "void bim_UInt16BytePyrImage_copy( ... ):\n"
				   "Unsufficient allocated memory in destination image" );
		return;
	}
#endif
	ptrA->widthE = srcPtrA->widthE;
	ptrA->heightE = srcPtrA->heightE;
	ptrA->depthE = srcPtrA->depthE;
	bbs_UInt16Arr_copy( cpA, &ptrA->arrE, &srcPtrA->arrE );
}

/* ------------------------------------------------------------------------- */

flag bim_UInt16BytePyrImage_equal( struct bbs_Context* cpA,
								   const struct bim_UInt16BytePyrImage* ptrA,
								   const struct bim_UInt16BytePyrImage* srcPtrA )
{
	if( ptrA->widthE != srcPtrA->widthE ) return FALSE;
	if( ptrA->heightE != srcPtrA->heightE ) return FALSE;
	if( ptrA->depthE != srcPtrA->depthE ) return FALSE;
	return bbs_UInt16Arr_equal( cpA, &ptrA->arrE, &srcPtrA->arrE );
}

/* ------------------------------------------------------------------------- */

/* ========================================================================= */
/*                                                                           */
/* ---- \ghd{ query functions } -------------------------------------------- */
/*                                                                           */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */

uint16* bim_UInt16BytePyrImage_arrPtr( struct bbs_Context* cpA,
									   const struct bim_UInt16BytePyrImage* ptrA,
										 uint32 levelA )
{
	uint32 iL;
	uint32 offsL = 0;
	uint32 baseSizeL = ( ptrA->widthE * ptrA->heightE ) >> 1;

#ifdef DEBUG2
	if( levelA >= ptrA->depthE )
	{
		bbs_ERROR2( "uint16* bim_UInt16BytePyrImage_arrPtr( struct bim_UInt16BytePyrImage*, uint32 levelA ):\n"
			       "levelA = %i out of range [0,%i]", levelA, ptrA->depthE - 1 );
		return NULL;
	}
#endif

	for( iL = 0; iL < levelA; iL++ )
	{
		offsL += ( baseSizeL >> ( iL * 2 ) );
	}
	return ptrA->arrE.arrPtrE + offsL;
}

/* ------------------------------------------------------------------------- */

uint32 bim_UInt16BytePyrImage_heapSize( struct bbs_Context* cpA,
									    const struct bim_UInt16BytePyrImage* ptrA,
										  uint32 widthA, uint32 heightA,
										  uint32 depthA )
{
	uint32 baseSizeL = ( widthA * heightA ) >> 1;
	uint32 sizeL = 0;
	uint32 iL;
	for( iL = 0; iL < depthA; iL++ )
	{
		sizeL += ( baseSizeL >> ( iL * 2 ) );
	}
	return 	bbs_UInt16Arr_heapSize( cpA, &ptrA->arrE, sizeL );
}

/* ------------------------------------------------------------------------- */

/* ========================================================================= */
/*                                                                           */
/* ---- \ghd{ modify functions } ------------------------------------------- */
/*                                                                           */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */

void bim_UInt16BytePyrImage_create( struct bbs_Context* cpA,
								    struct bim_UInt16BytePyrImage* ptrA,
									 uint32 widthA, uint32 heightA,
									 uint32 depthA,
								     struct bbs_MemSeg* mspA )
{
	uint32 baseSizeL = ( widthA * heightA ) >> 1;
	uint32 sizeL = 0;
	uint32 iL;

	if( bbs_Context_error( cpA ) ) return;
	if( ptrA->arrE.arrPtrE != 0 )
	{
		bim_UInt16BytePyrImage_size( cpA, ptrA, widthA, heightA, depthA );
		return;
	}

#ifdef DEBUG1
	{
		uint32 depthMaskL = ( ( int32 )1 << ( depthA - 1 ) ) - 1;
		if( depthA == 0 )
		{
			bbs_ERROR0( "void bim_UInt16BytePyrImage_create( struct bim_UInt16BytePyrImage* ptrA, uint32 widthA, uint32 heightA, uint32 depthA ):\n"
					   "depthA must be > 0" );
			return;
		}
		if( ( ( widthA & depthMaskL ) > 0 ) || ( ( heightA & depthMaskL ) > 0 ) )
		{
			bbs_ERROR1( "void bim_UInt16BytePyrImage_create( struct bim_UInt16BytePyrImage* ptrA, uint32 widthA, uint32 heightA, uint32 depthA ):\n"
					   "widthA and heightA must be divisible by %i", depthMaskL + 1 );
			return;
		}
	}
#endif

	ptrA->widthE  = widthA;
	ptrA->heightE = heightA;
	ptrA->depthE  = depthA;

	for( iL = 0; iL < depthA; iL++ )
	{
		sizeL += ( baseSizeL >> ( iL * 2 ) );
	}
	bbs_UInt16Arr_create( cpA, &ptrA->arrE, sizeL, mspA );
}

/* ------------------------------------------------------------------------- */

void bim_UInt16BytePyrImage_size( struct bbs_Context* cpA,
								  struct bim_UInt16BytePyrImage* ptrA,
								  uint32 widthA,
								  uint32 heightA,
								  uint32 depthA )
{
	uint32 baseSizeL = ( widthA * heightA ) >> 1;
	uint32 sizeL = 0;
	uint32 iL;

#ifdef DEBUG1
	uint32 depthMaskL = ( 1 << ( depthA - 1 ) ) - 1;
	if( depthA == 0 )
	{
		bbs_ERROR0( "void bim_UInt16BytePyrImage_size( struct bim_UInt16BytePyrImage* ptrA, uint32 widthA, uint32 heightA, uint32 depthA ):\n"
			       "depthA must be > 0" );
		return;
	}

	if( ( ( widthA & depthMaskL ) > 0 ) || ( ( heightA & depthMaskL ) > 0 ) )
	{
		bbs_ERROR1( "void bim_UInt16BytePyrImage_size( struct bim_UInt16BytePyrImage* ptrA, uint32 widthA, uint32 heightA, uint32 depthA ):\n"
			       "widthA and heightA must be divisible by %i", depthMaskL + 1 );
		return;
	}
#endif

	ptrA->widthE  = widthA;
	ptrA->heightE = heightA;
	ptrA->depthE  = depthA;

	for( iL = 0; iL < depthA; iL++ )
	{
		sizeL += ( baseSizeL >> ( iL * 2 ) );
	}
#ifdef DEBUG1
	if( sizeL > ptrA->arrE.allocatedSizeE )
	{
		bbs_ERROR0( "void bim_UInt16BytePyrImage_size( struct bim_UInt16BytePyrImage* ptrA, uint32 widthA, uint32 heightA, uint32 depthA ):\n"
			       "Insufficient allocated memory." );
		return;
	}
#endif
	bbs_UInt16Arr_size( cpA, &ptrA->arrE, sizeL );
}

/* ------------------------------------------------------------------------- */

/* ========================================================================= */
/*                                                                           */
/* ---- \ghd{ I/O } -------------------------------------------------------- */
/*                                                                           */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */

uint32 bim_UInt16BytePyrImage_memSize( struct bbs_Context* cpA,
									   const struct bim_UInt16BytePyrImage* ptrA )
{
	return  bbs_SIZEOF16( uint32 )
		  + bbs_SIZEOF16( uint32 ) /* version */
		  + bbs_SIZEOF16( ptrA->widthE )
		  + bbs_SIZEOF16( ptrA->heightE )
		  + bbs_SIZEOF16( ptrA->depthE )
		  + bbs_UInt16Arr_memSize( cpA, &ptrA->arrE );
}

/* ------------------------------------------------------------------------- */

uint32 bim_UInt16BytePyrImage_memWrite( struct bbs_Context* cpA,
									    const struct bim_UInt16BytePyrImage* ptrA,
										uint16* memPtrA )
{
	uint32 memSizeL = bim_UInt16BytePyrImage_memSize( cpA, ptrA );
	memPtrA += bbs_memWrite32( &memSizeL, memPtrA );
	memPtrA += bbs_memWriteUInt32( bim_UINT16_PYRAMIDAL_IMAGE_VERSION, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->widthE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->heightE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->depthE, memPtrA );
	bbs_UInt16Arr_memWrite( cpA, &ptrA->arrE, memPtrA );
	return memSizeL;
}

/* ------------------------------------------------------------------------- */

uint32 bim_UInt16BytePyrImage_memRead( struct bbs_Context* cpA,
									   struct bim_UInt16BytePyrImage* ptrA,
									    const uint16* memPtrA,
 									    struct bbs_MemSeg* mspA )
{
	uint32 memSizeL, versionL, widthL, heightL, depthL;
	if( bbs_Context_error( cpA ) ) return 0;
	memPtrA += bbs_memRead32( &memSizeL, memPtrA );
	memPtrA += bbs_memReadVersion32( cpA, &versionL, bim_UINT16_PYRAMIDAL_IMAGE_VERSION, memPtrA );
	memPtrA += bbs_memRead32( &widthL, memPtrA );
	memPtrA += bbs_memRead32( &heightL, memPtrA );
	memPtrA += bbs_memRead32( &depthL, memPtrA );

	ptrA->widthE  = widthL;
	ptrA->heightE = heightL;
	ptrA->depthE  = depthL;
	bbs_UInt16Arr_memRead( cpA, &ptrA->arrE, memPtrA, mspA );

	if( memSizeL != bim_UInt16BytePyrImage_memSize( cpA, ptrA ) )
	{
		bbs_ERR0( bbs_ERR_CORRUPT_DATA, "uint32 bim_UInt16BytePyrImage_memRead( const struct bim_UInt16BytePyrImage* ptrA, const void* memPtrA ):\n"
                   "size mismatch" );
		return 0;
	}

	return memSizeL;
}

/* ------------------------------------------------------------------------- */

/* ========================================================================= */
/*                                                                           */
/* ---- \ghd{ exec functions } --------------------------------------------- */
/*                                                                           */
/* ========================================================================= */

void bim_UInt16BytePyrImage_overlayUInt16( struct bbs_Context* cpA,
										   const struct bim_UInt16BytePyrImage* ptrA,
											 struct bim_UInt16ByteImage* uint16ImageA )
{
	uint16ImageA->widthE = ptrA->widthE;
	uint16ImageA->heightE = ptrA->heightE;
	uint16ImageA->arrE.sizeE = ptrA->widthE * ptrA->heightE;
	uint16ImageA->arrE.allocatedSizeE = ptrA->widthE * ptrA->heightE;
	uint16ImageA->arrE.arrPtrE = ptrA->arrE.arrPtrE;
	uint16ImageA->arrE.mspE = 0;
}

/* ------------------------------------------------------------------------- */

/** process remaining layers */
void bim_UInt16BytePyrImage_recompute( struct bbs_Context* cpA,
									   struct bim_UInt16BytePyrImage* dstPtrA )
{
	count_t iL, jL, layerL;
	uint16 tmpL;

	uint32 widthL = dstPtrA->widthE;
	uint32 halfWidthL = widthL >> 1;
	uint32 heightL = dstPtrA->heightE;

	uint16* srcL = dstPtrA->arrE.arrPtrE;
	uint16* dstL = srcL + ( heightL * halfWidthL );
	for( layerL = 1; layerL < dstPtrA->depthE; layerL++ )
	{
		for( jL = ( heightL >> 1 ); jL > 0; jL-- )
		{
			for( iL = ( halfWidthL >> 1 ); iL > 0; iL-- )
			{
				/* averaging with rounding */
					tmpL = ( ( *srcL & 0x0FF ) + ( *srcL >> 8 ) + ( *( srcL + halfWidthL ) & 0x0FF ) +
							 ( *( srcL + halfWidthL ) >> 8 ) + 2 ) >> 2;
				#ifdef HW_BIG_ENDIAN
					*dstL = tmpL << 8;
				#else
					*dstL = tmpL;
				#endif
				srcL++;

					tmpL = ( ( *srcL & 0x0FF ) + ( *srcL >> 8 ) + ( *( srcL + halfWidthL ) & 0x0FF ) +
							 ( *( srcL + halfWidthL ) >> 8 ) + 2 ) >> 2;
				#ifdef HW_BIG_ENDIAN
					*dstL |= tmpL;
				#else
					*dstL |= tmpL << 8;
				#endif
				srcL++;
				dstL++;
			}
			srcL += halfWidthL;
		}
		halfWidthL >>= 1;
		heightL >>= 1;
	}
}


/* ------------------------------------------------------------------------- */


void bim_UInt16BytePyrImage_importUInt16( struct bbs_Context* cpA,
										  struct bim_UInt16BytePyrImage* dstPtrA,
											const struct bim_UInt16ByteImage* srcPtrA,
											uint32 depthA )
{

	bim_UInt16BytePyrImage_size( cpA, dstPtrA, srcPtrA->widthE, srcPtrA->heightE, depthA );

	/* copy first layer */
	bbs_memcpy16( dstPtrA->arrE.arrPtrE, srcPtrA->arrE.arrPtrE, srcPtrA->arrE.sizeE );

	bim_UInt16BytePyrImage_recompute( cpA, dstPtrA );
}


/* ------------------------------------------------------------------------- */

/* ========================================================================= */