/* 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 <string.h>

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<<bitSize));

    RI_ASSERT((bitPtr + bitSize) < (hashSize * 32));

    int idw = bitPtr >> 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;

    }

}

}