diff -r 39e5f73667ba -r c2ef9095503a hostsupport/hostopenvg/src/riUtils.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/hostsupport/hostopenvg/src/riUtils.cpp Wed Oct 06 17:59:01 2010 +0100 @@ -0,0 +1,240 @@ +/* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and /or associated documentation files + * (the "Materials "), to deal in the Materials without restriction, + * including without limitation the rights to use, copy, modify, merge, + * publish, distribute, sublicense, and/or sell copies of the Materials, + * and to permit persons to whom the Materials are furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Materials. + * + * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR + * THE USE OR OTHER DEALINGS IN THE MATERIALS. + */ + +#ifndef __RIUTILS_H_ +# include "riUtils.h" +#endif + +#include + +namespace OpenVGRI +{ + +/** + * \brief Sets mem areas to byte(s) in c. + * \param dst Destination pointer. + * \param c Data to set into dst. + * \param nElements Amount of elements to set. + * \param nBytesPerElement Amount of bytes for each element. + * \note This is moslty an image-settings support function. It is assumed that several + * bytes / elements can be set at once, especially in 3-byte case. + */ +void riMemSet32(void* dst, RIuint32 c, size_t nElements, size_t nBytesPerElement) +{ + // \todo This function should be called from a function that handles npot element sizes. + // \todo Investigate the status of (open) std::fill implementations. Some of that code + // did not _seem_ to bundle sets or use SSE, etc. + // \todo Use SSE instructions on Intel? + + RI_ASSERT(dst); + RI_ASSERT(nElements); + + switch(nBytesPerElement) + { + case 4: + { + RIuint32* ptr = (RIuint32*)dst; + do { + *ptr++ = c; + } while(--nElements); + break; + } + case 3: + { + // \todo Endianness. + RIuint8* ptr = (RIuint8*)dst; + RIuint8 b[3]; + b[0] = c & 0xff; + b[1] = (c >> 8)&0xff; + b[2] = (c >> 16)&0xff; + do { + *ptr++ = b[0]; + *ptr++ = b[1]; + *ptr++ = b[2]; + } while(--nElements); + break; + } + case 2: + { + size_t dws = nElements / 2; + if (dws) + { + RIuint32* ptr32 = (RIuint32*)dst; + dst = (void*)(((RIuint8*)dst + dws * 4)); + RIuint32 dw = c | (c<<16); + do { + *ptr32++ = dw; + } while(--dws); + nElements &= 0x01; + } + if (nElements) + { + RIuint16 *ptr16 = (RIuint16*)dst; + const RIuint16 w = (RIuint16)c; + do { + *ptr16++ = w; + } while(--nElements); + } + break; + } + default: + { + RI_ASSERT(nBytesPerElement == 1); + memset(dst, c, nElements); + break; + } + } + +} + +/** + * \brief Insert bits into an array of 32-bit integers. + * \param hashSize Size of array in bytes. + * \param bits Actual bits to insert. + * \param bitSize Amount of bits to insert (max 32). + * \param bitPtr Pointer to first bit to insert [0 .. (hashSize*8)-1] + */ +int riInsertBits32(RIuint32* hash, size_t hashSize, RIuint32 bits, RIuint32 bitSize, int bitPtr) +{ + RI_ASSERT(bitSize > 0 && bitSize <= 32); + RI_ASSERT(bits < (1u<> 5; + int ib = bitPtr - (idw << 5); + + if ((ib + bitSize) > 32) + { + int rb = ((ib + bitSize) - 32) + 1; + RI_ASSERT(rb > 0); + hash[idw] |= (bits << ib); + hash[idw] |= (bits >> rb); + } + else + { + int new_ib = (ib + bitSize) & 0x1f; + RI_ASSERT((ib + bitSize == 32) ? new_ib == 0 : true); + hash[idw] |= (bits << ib); + } + return bitPtr + bitSize; +} + +/** + * \brief Convert an image format to (internal) index. + */ +int riVGImageFormatToIndex(VGImageFormat format) +{ + switch(format) + { + /* RGB{A,X} channel ordering */ + case VG_sRGBX_8888: + return 0; + case VG_sRGBA_8888: + return 1; + case VG_sRGBA_8888_PRE: + return 2; + case VG_sRGB_565: + return 3; + case VG_sRGBA_5551: + return 4; + case VG_sRGBA_4444: + return 5; + case VG_sL_8: + return 6; + case VG_lRGBX_8888: + return 7; + case VG_lRGBA_8888: + return 8; + case VG_lRGBA_8888_PRE: + return 9; + case VG_lL_8: + return 10; + case VG_A_8: + return 11; + case VG_BW_1: + return 12; + case VG_A_1: + return 13; + case VG_A_4: + return 14; + + /* {A,X}RGB channel ordering */ + case VG_sXRGB_8888: + return 15; + case VG_sARGB_8888: + return 16; + case VG_sARGB_8888_PRE: + return 17; + case VG_sARGB_1555: + return 18; + case VG_sARGB_4444: + return 19; + case VG_lXRGB_8888: + return 20; + case VG_lARGB_8888: + return 21; + case VG_lARGB_8888_PRE: + return 22; + + /* BGR{A,X} channel ordering */ + case VG_sBGRX_8888: + return 23; + case VG_sBGRA_8888: + return 24; + case VG_sBGRA_8888_PRE: + return 25; + case VG_sBGR_565: + return 26; + case VG_sBGRA_5551: + return 27; + case VG_sBGRA_4444: + return 28; + case VG_lBGRX_8888: + return 29; + case VG_lBGRA_8888: + return 30; + case VG_lBGRA_8888_PRE: + return 31; + + /* {A,X}BGR channel ordering */ + case VG_sXBGR_8888: + return 32; + case VG_sABGR_8888: + return 33; + case VG_sABGR_8888_PRE: + return 34; + case VG_sABGR_1555: + return 35; + case VG_sABGR_4444: + return 36; + case VG_lXBGR_8888: + return 37; + case VG_lABGR_8888: + return 38; + default: + RI_ASSERT(format == VG_lABGR_8888_PRE); + return 39; + } +} + +} +