//
// Copyright (c) 2017 The Khronos Group Inc.
// 
// 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.
//
#ifndef _imageHelpers_h
#define _imageHelpers_h

#include "compat.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <vector>

#if !defined(_WIN32)
#include <unistd.h>
#endif

#include <time.h>

#include "errorHelpers.h"

#include "conversions.h"
#include "typeWrappers.h"
#include "kernelHelpers.h"
#include "errorHelpers.h"
#include "mt19937.h"
#include "rounding_mode.h"
#include "clImageHelper.h"

extern cl_device_type gDeviceType;
extern bool gTestRounding;

// Number of iterations per image format to test if not testing max images, rounding, or small images
#define NUM_IMAGE_ITERATIONS 3


// Definition for our own sampler type, to mirror the cl_sampler internals
#define MAX_sRGB_TO_lRGB_CONVERSION_ERROR 0.5
#define MAX_lRGB_TO_sRGB_CONVERSION_ERROR 0.6

// Definition for our own sampler type, to mirror the cl_sampler internals
typedef struct {
 cl_addressing_mode addressing_mode;
 cl_filter_mode     filter_mode;
 bool               normalized_coords;
} image_sampler_data;

int round_to_even( float v );

#define NORMALIZE( v, max ) ( v < 0 ? 0 : ( v > 1.f ? max : round_to_even( v * max ) ) )
#define NORMALIZE_UNROUNDED( v, max ) ( v < 0 ? 0 : ( v > 1.f ? max :  v * max ) )
#define NORMALIZE_SIGNED( v, min, max ) ( v  < -1.0f ? min : ( v > 1.f ? max : round_to_even( v * max ) ) )
#define NORMALIZE_SIGNED_UNROUNDED( v, min, max ) ( v  < -1.0f ? min : ( v > 1.f ? max : v * max ) )
#define CONVERT_INT( v, min, max, max_val)  ( v < min ? min : ( v > max ? max_val : round_to_even( v ) ) )
#define CONVERT_UINT( v, max, max_val)  ( v < 0 ? 0 : ( v > max ? max_val : round_to_even( v ) ) )

extern void print_read_header( cl_image_format *format, image_sampler_data *sampler, bool err = false, int t = 0 );
extern void print_write_header( cl_image_format *format, bool err);
extern void print_header( cl_image_format *format, bool err );
extern bool find_format( cl_image_format *formatList, unsigned int numFormats, cl_image_format *formatToFind );
extern bool is_image_format_required(cl_image_format format,
                                     cl_mem_flags flags,
                                     cl_mem_object_type image_type,
                                     cl_device_id device);
extern void build_required_image_formats(cl_mem_flags flags,
                                         cl_mem_object_type image_type,
                                         cl_device_id device,
                                         std::vector<cl_image_format>& formatsToSupport);

extern size_t get_format_type_size( const cl_image_format *format );
extern size_t get_channel_data_type_size( cl_channel_type channelType );
extern size_t get_format_channel_count( const cl_image_format *format );
extern size_t get_channel_order_channel_count( cl_channel_order order );
cl_channel_type  get_channel_type_from_name( const char *name );
cl_channel_order  get_channel_order_from_name( const char *name );
extern int    is_format_signed( const cl_image_format *format );
extern size_t get_pixel_size( cl_image_format *format );

/* Helper to get any ol image format as long as it is 8-bits-per-channel */
extern int get_8_bit_image_format( cl_context context, cl_mem_object_type objType, cl_mem_flags flags, size_t channelCount, cl_image_format *outFormat );

/* Helper to get any ol image format as long as it is 32-bits-per-channel */
extern int get_32_bit_image_format( cl_context context, cl_mem_object_type objType, cl_mem_flags flags, size_t channelCount, cl_image_format *outFormat );

int random_in_range( int minV, int maxV, MTdata d );
int random_log_in_range( int minV, int maxV, MTdata d );

typedef struct
{
    size_t width;
    size_t height;
    size_t depth;
    size_t rowPitch;
    size_t slicePitch;
    size_t arraySize;
    cl_image_format *format;
    cl_mem buffer;
    cl_mem_object_type type;
    cl_uint num_mip_levels;
} image_descriptor;

typedef struct
{
    float p[4];
}FloatPixel;

void get_max_sizes(size_t *numberOfSizes, const int maxNumberOfSizes,
                   size_t sizes[][3], size_t maxWidth, size_t maxHeight, size_t maxDepth, size_t maxArraySize,
                   const cl_ulong maxIndividualAllocSize, const cl_ulong maxTotalAllocSize, cl_mem_object_type image_type, cl_image_format *format, int usingMaxPixelSize=0);
extern size_t get_format_max_int( cl_image_format *format );

extern cl_ulong get_image_size( image_descriptor const *imageInfo );
extern cl_ulong get_image_size_mb( image_descriptor const *imageInfo );

extern char * generate_random_image_data( image_descriptor *imageInfo, BufferOwningPtr<char> &Owner, MTdata d );

extern int debug_find_vector_in_image( void *imagePtr, image_descriptor *imageInfo,
                                      void *vectorToFind, size_t vectorSize, int *outX, int *outY, int *outZ, size_t lod = 0 );

extern int debug_find_pixel_in_image( void *imagePtr, image_descriptor *imageInfo,
                                     unsigned int *valuesToFind, int *outX, int *outY, int *outZ, int lod = 0 );
extern int debug_find_pixel_in_image( void *imagePtr, image_descriptor *imageInfo,
                                     int *valuesToFind, int *outX, int *outY, int *outZ, int lod = 0 );
extern int debug_find_pixel_in_image( void *imagePtr, image_descriptor *imageInfo,
                                     float *valuesToFind, int *outX, int *outY, int *outZ, int lod = 0 );

extern void copy_image_data( image_descriptor *srcImageInfo, image_descriptor *dstImageInfo, void *imageValues, void *destImageValues,
                            const size_t sourcePos[], const size_t destPos[], const size_t regionSize[] );

int has_alpha(cl_image_format *format);

extern bool is_sRGBA_order(cl_channel_order image_channel_order);

inline float calculate_array_index( float coord, float extent );

cl_uint compute_max_mip_levels( size_t width, size_t height, size_t depth);
cl_ulong compute_mipmapped_image_size( image_descriptor imageInfo);
size_t compute_mip_level_offset( image_descriptor * imageInfo , size_t lod);

template <class T> void read_image_pixel( void *imageData, image_descriptor *imageInfo,
                                         int x, int y, int z, T *outData, int lod )
{
    float convert_half_to_float( unsigned short halfValue );
    size_t width_lod = imageInfo->width, height_lod = imageInfo->height, depth_lod = imageInfo->depth, slice_pitch_lod = 0/*imageInfo->slicePitch*/ , row_pitch_lod = 0/*imageInfo->rowPitch*/;
    width_lod = ( imageInfo->width >> lod) ?( imageInfo->width >> lod):1;

    if ( imageInfo->type  != CL_MEM_OBJECT_IMAGE1D_ARRAY && imageInfo->type != CL_MEM_OBJECT_IMAGE1D)
        height_lod = ( imageInfo->height >> lod) ?( imageInfo->height >> lod):1;

    if(imageInfo->type == CL_MEM_OBJECT_IMAGE3D)
       depth_lod = ( imageInfo->depth >> lod) ? ( imageInfo->depth >> lod) : 1;
    row_pitch_lod = (imageInfo->num_mip_levels > 0)? (width_lod * get_pixel_size( imageInfo->format )): imageInfo->rowPitch;
    slice_pitch_lod = (imageInfo->num_mip_levels > 0)? (row_pitch_lod * height_lod): imageInfo->slicePitch;

    // correct depth_lod and height_lod for array image types in order to avoid
    // return
    if (imageInfo->type == CL_MEM_OBJECT_IMAGE1D_ARRAY && height_lod == 1 && depth_lod == 1) {
    depth_lod = 0;
    height_lod = 0;

    }

    if (imageInfo->type == CL_MEM_OBJECT_IMAGE2D_ARRAY && depth_lod == 1) {
      depth_lod = 0;
    }

    if ( x < 0 || x >= (int)width_lod
               || ( height_lod != 0 && ( y < 0 || y >= (int)height_lod ) )
               || ( depth_lod != 0 && ( z < 0 || z >= (int)depth_lod ) )
               || ( imageInfo->arraySize != 0 && ( z < 0 || z >= (int)imageInfo->arraySize ) ) )
    {
        // Border color
        if (imageInfo->format->image_channel_order == CL_DEPTH)
        {
            outData[ 0 ] = 1;
        }
        else {
            outData[ 0 ] = outData[ 1 ] = outData[ 2 ] = outData[ 3 ] = 0;
            if (!has_alpha(imageInfo->format))
                outData[3] = 1;
        }
        return;
    }

    cl_image_format *format = imageInfo->format;

    unsigned int i;
    T tempData[ 4 ];

    // Advance to the right spot
    char *ptr = (char *)imageData;
    size_t pixelSize = get_pixel_size( format );

    ptr += z * slice_pitch_lod + y * row_pitch_lod + x * pixelSize;

    // OpenCL only supports reading floats from certain formats
    switch( format->image_channel_data_type )
    {
        case CL_SNORM_INT8:
        {
            cl_char *dPtr = (cl_char *)ptr;
            for( i = 0; i < get_format_channel_count( format ); i++ )
                tempData[ i ] = (T)dPtr[ i ];
            break;
        }

        case CL_UNORM_INT8:
        {
            cl_uchar *dPtr = (cl_uchar *)ptr;
            for( i = 0; i < get_format_channel_count( format ); i++ )
                tempData[ i ] = (T)dPtr[ i ];
            break;
        }

        case CL_SIGNED_INT8:
        {
            cl_char *dPtr = (cl_char *)ptr;
            for( i = 0; i < get_format_channel_count( format ); i++ )
                tempData[ i ] = (T)dPtr[ i ];
            break;
        }

        case CL_UNSIGNED_INT8:
        {
            cl_uchar *dPtr = (cl_uchar*)ptr;
            for( i = 0; i < get_format_channel_count( format ); i++ )
                tempData[ i ] = (T)dPtr[ i ];
            break;
        }

        case CL_SNORM_INT16:
        {
            cl_short *dPtr = (cl_short *)ptr;
            for( i = 0; i < get_format_channel_count( format ); i++ )
                tempData[ i ] = (T)dPtr[ i ];
            break;
        }

        case CL_UNORM_INT16:
        {
            cl_ushort *dPtr = (cl_ushort *)ptr;
            for( i = 0; i < get_format_channel_count( format ); i++ )
                tempData[ i ] = (T)dPtr[ i ];
            break;
        }

        case CL_SIGNED_INT16:
        {
            cl_short *dPtr = (cl_short *)ptr;
            for( i = 0; i < get_format_channel_count( format ); i++ )
                tempData[ i ] = (T)dPtr[ i ];
            break;
        }

        case CL_UNSIGNED_INT16:
        {
            cl_ushort *dPtr = (cl_ushort *)ptr;
            for( i = 0; i < get_format_channel_count( format ); i++ )
                tempData[ i ] = (T)dPtr[ i ];
            break;
        }

        case CL_HALF_FLOAT:
        {
            cl_ushort *dPtr = (cl_ushort *)ptr;
            for( i = 0; i < get_format_channel_count( format ); i++ )
                tempData[ i ] = (T)convert_half_to_float( dPtr[ i ] );
            break;
        }

        case CL_SIGNED_INT32:
        {
            cl_int *dPtr = (cl_int *)ptr;
            for( i = 0; i < get_format_channel_count( format ); i++ )
                tempData[ i ] = (T)dPtr[ i ];
            break;
        }

        case CL_UNSIGNED_INT32:
        {
            cl_uint *dPtr = (cl_uint *)ptr;
            for( i = 0; i < get_format_channel_count( format ); i++ )
                tempData[ i ] = (T)dPtr[ i ];
            break;
        }

        case CL_UNORM_SHORT_565:
        {
            cl_ushort *dPtr = (cl_ushort*)ptr;
            tempData[ 0 ] = (T)( dPtr[ 0 ] >> 11 );
            tempData[ 1 ] = (T)( ( dPtr[ 0 ] >> 5 ) & 63 );
            tempData[ 2 ] = (T)( dPtr[ 0 ] & 31 );
            break;
        }

#ifdef OBSOLETE_FORMAT
        case CL_UNORM_SHORT_565_REV:
        {
            unsigned short *dPtr = (unsigned short *)ptr;
            tempData[ 2 ] = (T)( dPtr[ 0 ] >> 11 );
            tempData[ 1 ] = (T)( ( dPtr[ 0 ] >> 5 ) & 63 );
            tempData[ 0 ] = (T)( dPtr[ 0 ] & 31 );
            break;
        }

        case CL_UNORM_SHORT_555_REV:
        {
            unsigned short *dPtr = (unsigned short *)ptr;
            tempData[ 2 ] = (T)( ( dPtr[ 0 ] >> 10 ) & 31 );
            tempData[ 1 ] = (T)( ( dPtr[ 0 ] >> 5 ) & 31 );
            tempData[ 0 ] = (T)( dPtr[ 0 ] & 31 );
            break;
        }

        case CL_UNORM_INT_8888:
        {
            unsigned int *dPtr = (unsigned int *)ptr;
            tempData[ 3 ] = (T)( dPtr[ 0 ] >> 24 );
            tempData[ 2 ] = (T)( ( dPtr[ 0 ] >> 16 ) & 0xff );
            tempData[ 1 ] = (T)( ( dPtr[ 0 ] >> 8 ) & 0xff );
            tempData[ 0 ] = (T)( dPtr[ 0 ] & 0xff );
            break;
        }
        case CL_UNORM_INT_8888_REV:
        {
            unsigned int *dPtr = (unsigned int *)ptr;
            tempData[ 0 ] = (T)( dPtr[ 0 ] >> 24 );
            tempData[ 1 ] = (T)( ( dPtr[ 0 ] >> 16 ) & 0xff );
            tempData[ 2 ] = (T)( ( dPtr[ 0 ] >> 8 ) & 0xff );
            tempData[ 3 ] = (T)( dPtr[ 0 ] & 0xff );
            break;
        }

        case CL_UNORM_INT_101010_REV:
        {
            unsigned int *dPtr = (unsigned int *)ptr;
            tempData[ 2 ] = (T)( ( dPtr[ 0 ] >> 20 ) & 0x3ff );
            tempData[ 1 ] = (T)( ( dPtr[ 0 ] >> 10 ) & 0x3ff );
            tempData[ 0 ] = (T)( dPtr[ 0 ] & 0x3ff );
            break;
        }
#endif
        case CL_UNORM_SHORT_555:
        {
            cl_ushort *dPtr = (cl_ushort *)ptr;
            tempData[ 0 ] = (T)( ( dPtr[ 0 ] >> 10 ) & 31 );
            tempData[ 1 ] = (T)( ( dPtr[ 0 ] >> 5 ) & 31 );
            tempData[ 2 ] = (T)( dPtr[ 0 ] & 31 );
            break;
        }

        case CL_UNORM_INT_101010:
        {
            cl_uint *dPtr = (cl_uint *)ptr;
            tempData[ 0 ] = (T)( ( dPtr[ 0 ] >> 20 ) & 0x3ff );
            tempData[ 1 ] = (T)( ( dPtr[ 0 ] >> 10 ) & 0x3ff );
            tempData[ 2 ] = (T)( dPtr[ 0 ] & 0x3ff );
            break;
        }

        case CL_FLOAT:
        {
            cl_float *dPtr = (cl_float *)ptr;
            for( i = 0; i < get_format_channel_count( format ); i++ )
                tempData[ i ] = (T)dPtr[ i ];
            break;
        }
#ifdef CL_SFIXED14_APPLE
        case CL_SFIXED14_APPLE:
        {
            cl_float *dPtr = (cl_float *)ptr;
            for( i = 0; i < get_format_channel_count( format ); i++ )
                tempData[ i ] = (T)dPtr[ i ] + 0x4000;
            break;
        }
#endif
    }


    outData[ 0 ] = outData[ 1 ] = outData[ 2 ] = 0;
    outData[ 3 ] = 1;

    if( format->image_channel_order == CL_A )
    {
        outData[ 3 ] = tempData[ 0 ];
    }
    else if( format->image_channel_order == CL_R   )
    {
        outData[ 0 ] = tempData[ 0 ];
    }
    else if( format->image_channel_order == CL_Rx   )
    {
        outData[ 0 ] = tempData[ 0 ];
    }
    else if( format->image_channel_order == CL_RA )
    {
        outData[ 0 ] = tempData[ 0 ];
        outData[ 3 ] = tempData[ 1 ];
    }
    else if( format->image_channel_order == CL_RG  )
    {
        outData[ 0 ] = tempData[ 0 ];
        outData[ 1 ] = tempData[ 1 ];
    }
    else if( format->image_channel_order == CL_RGx  )
    {
        outData[ 0 ] = tempData[ 0 ];
        outData[ 1 ] = tempData[ 1 ];
    }
    else if(( format->image_channel_order == CL_RGB  ) || ( format->image_channel_order == CL_sRGB  ))
    {
        outData[ 0 ] = tempData[ 0 ];
        outData[ 1 ] = tempData[ 1 ];
        outData[ 2 ] = tempData[ 2 ];
    }
    else if(( format->image_channel_order == CL_RGBx  ) || ( format->image_channel_order == CL_sRGBx  ))
    {
        outData[ 0 ] = tempData[ 0 ];
        outData[ 1 ] = tempData[ 1 ];
        outData[ 2 ] = tempData[ 2 ];
        outData[ 3 ] = 0;
    }
    else if(( format->image_channel_order == CL_RGBA ) || ( format->image_channel_order == CL_sRGBA ))
    {
        outData[ 0 ] = tempData[ 0 ];
        outData[ 1 ] = tempData[ 1 ];
        outData[ 2 ] = tempData[ 2 ];
        outData[ 3 ] = tempData[ 3 ];
    }
    else if( format->image_channel_order == CL_ARGB )
    {
        outData[ 0 ] = tempData[ 1 ];
        outData[ 1 ] = tempData[ 2 ];
        outData[ 2 ] = tempData[ 3 ];
        outData[ 3 ] = tempData[ 0 ];
    }
    else if(( format->image_channel_order == CL_BGRA ) || ( format->image_channel_order == CL_sBGRA ))
    {
        outData[ 0 ] = tempData[ 2 ];
        outData[ 1 ] = tempData[ 1 ];
        outData[ 2 ] = tempData[ 0 ];
        outData[ 3 ] = tempData[ 3 ];
    }
    else if( format->image_channel_order == CL_INTENSITY )
    {
        outData[ 1 ] = tempData[ 0 ];
        outData[ 2 ] = tempData[ 0 ];
        outData[ 3 ] = tempData[ 0 ];
    }
    else if( format->image_channel_order == CL_LUMINANCE )
    {
        outData[ 1 ] = tempData[ 0 ];
        outData[ 2 ] = tempData[ 0 ];
    }
    else if( format->image_channel_order == CL_DEPTH  )
    {
        outData[ 0 ] = tempData[ 0 ];
    }
#ifdef CL_1RGB_APPLE
    else if( format->image_channel_order == CL_1RGB_APPLE )
    {
        outData[ 0 ] = tempData[ 1 ];
        outData[ 1 ] = tempData[ 2 ];
        outData[ 2 ] = tempData[ 3 ];
        outData[ 3 ] = 0xff;
    }
#endif
#ifdef CL_BGR1_APPLE
    else if( format->image_channel_order == CL_BGR1_APPLE )
    {
        outData[ 0 ] = tempData[ 2 ];
        outData[ 1 ] = tempData[ 1 ];
        outData[ 2 ] = tempData[ 0 ];
        outData[ 3 ] = 0xff;
    }
#endif
    else
    {
        log_error("Invalid format:");
        print_header(format, true);
    }
}

template <class T> void read_image_pixel( void *imageData, image_descriptor *imageInfo,
                                         int x, int y, int z, T *outData )
{
  read_image_pixel<T>( imageData, imageInfo, x, y, z, outData, 0);
}

// Stupid template rules
bool get_integer_coords( float x, float y, float z,
                        size_t width, size_t height, size_t depth,
                        image_sampler_data *imageSampler, image_descriptor *imageInfo,
                        int &outX, int &outY, int &outZ );
bool get_integer_coords_offset( float x, float y, float z,
                               float xAddressOffset, float yAddressOffset, float zAddressOffset,
                               size_t width, size_t height, size_t depth,
                               image_sampler_data *imageSampler, image_descriptor *imageInfo,
                               int &outX, int &outY, int &outZ );


template <class T> void sample_image_pixel_offset( void *imageData, image_descriptor *imageInfo,
                                                  float x, float y, float z, float xAddressOffset, float yAddressOffset, float zAddressOffset,
                                                  image_sampler_data *imageSampler, T *outData, int lod )
{
    int iX = 0, iY = 0, iZ = 0;

    float max_w = imageInfo->width;
    float max_h;
    float max_d;

    switch (imageInfo->type) {
        case CL_MEM_OBJECT_IMAGE1D_ARRAY:
            max_h = imageInfo->arraySize;
            max_d = 0;
            break;
        case CL_MEM_OBJECT_IMAGE2D_ARRAY:
            max_h = imageInfo->height;
            max_d = imageInfo->arraySize;
            break;
        default:
            max_h = imageInfo->height;
            max_d = imageInfo->depth;
            break;
    }

    if( /*gTestMipmaps*/ imageInfo->num_mip_levels > 1 )
    {
        switch (imageInfo->type) {
            case CL_MEM_OBJECT_IMAGE3D:
                max_d = (float)((imageInfo->depth >> lod) ? (imageInfo->depth >> lod) : 1);
            case CL_MEM_OBJECT_IMAGE2D:
            case CL_MEM_OBJECT_IMAGE2D_ARRAY:
                max_h = (float)((imageInfo->height >> lod) ? (imageInfo->height >> lod) : 1);
                break;
            default:
                ;

        }
        max_w = (float)((imageInfo->width >> lod) ? (imageInfo->width >> lod) : 1);
    }
    get_integer_coords_offset( x, y, z, xAddressOffset, yAddressOffset, zAddressOffset, max_w, max_h, max_d, imageSampler, imageInfo, iX, iY, iZ );

    read_image_pixel<T>( imageData, imageInfo, iX, iY, iZ, outData, lod );
}

template <class T> void sample_image_pixel_offset( void *imageData, image_descriptor *imageInfo,
                                                  float x, float y, float z, float xAddressOffset, float yAddressOffset, float zAddressOffset,
                                                  image_sampler_data *imageSampler, T *outData)
{
  sample_image_pixel_offset<T>( imageData, imageInfo, x, y, z, xAddressOffset, yAddressOffset, zAddressOffset,
    imageSampler,  outData, 0);
}

template <class T> void sample_image_pixel( void *imageData, image_descriptor *imageInfo,
                                           float x, float y, float z, image_sampler_data *imageSampler, T *outData )
{
    return sample_image_pixel_offset<T>(imageData, imageInfo, x, y, z, 0.0f, 0.0f, 0.0f, imageSampler, outData);
}

FloatPixel sample_image_pixel_float( void *imageData, image_descriptor *imageInfo,
                                    float x, float y, float z, image_sampler_data *imageSampler, float *outData, int verbose, int *containsDenorms );

FloatPixel sample_image_pixel_float( void *imageData, image_descriptor *imageInfo,
                                    float x, float y, float z, image_sampler_data *imageSampler, float *outData, int verbose, int *containsDenorms, int lod );

FloatPixel sample_image_pixel_float_offset( void *imageData, image_descriptor *imageInfo,
                                           float x, float y, float z, float xAddressOffset, float yAddressOffset, float zAddressOffset,
                                           image_sampler_data *imageSampler, float *outData, int verbose, int *containsDenorms );
FloatPixel sample_image_pixel_float_offset( void *imageData, image_descriptor *imageInfo,
                                           float x, float y, float z, float xAddressOffset, float yAddressOffset, float zAddressOffset,
                                           image_sampler_data *imageSampler, float *outData, int verbose, int *containsDenorms, int lod );


extern void pack_image_pixel( unsigned int *srcVector, const cl_image_format *imageFormat, void *outData );
extern void pack_image_pixel( int *srcVector, const cl_image_format *imageFormat, void *outData );
extern void pack_image_pixel( float *srcVector, const cl_image_format *imageFormat, void *outData );
extern void pack_image_pixel_error( const float *srcVector, const cl_image_format *imageFormat, const void *results,  float *errors );

extern char *create_random_image_data( ExplicitType dataType, image_descriptor *imageInfo, BufferOwningPtr<char> &P, MTdata d, bool image2DFromBuffer = false );

// deprecated
//extern bool clamp_image_coord( image_sampler_data *imageSampler, float value, size_t max, int &outValue );

extern void get_sampler_kernel_code( image_sampler_data *imageSampler, char *outLine );
extern float get_max_absolute_error( cl_image_format *format, image_sampler_data *sampler);
extern float get_max_relative_error( cl_image_format *format, image_sampler_data *sampler, int is3D, int isLinearFilter );


#define errMax( _x , _y )       ( (_x) != (_x) ? (_x) : (_x) > (_y) ? (_x) : (_y) )

static inline cl_uint abs_diff_uint( cl_uint x, cl_uint y )
{
    return y > x ? y - x : x - y;
}

static inline cl_uint abs_diff_int( cl_int x, cl_int y )
{
    return (cl_uint) (y > x ? y - x : x - y);
}

static inline cl_float relative_error( float test, float expected )
{
    // 0-0/0 is 0 in this case, not NaN
    if( test == 0.0f && expected == 0.0f )
        return 0.0f;

    return (test - expected) / expected;
}

extern float random_float(float low, float high);

class CoordWalker
{
public:
    CoordWalker( void * coords, bool useFloats, size_t vecSize );
    ~CoordWalker();

    cl_float    Get( size_t idx, size_t el );

protected:
    cl_float * mFloatCoords;
    cl_int * mIntCoords;
    size_t    mVecSize;
};

extern int  DetectFloatToHalfRoundingMode( cl_command_queue );  // Returns CL_SUCCESS on success

// sign bit: don't care, exponent: maximum value, significand: non-zero
static int inline is_half_nan( cl_ushort half ){ return ( half & 0x7fff ) > 0x7c00; }

// sign bit: don't care, exponent: zero, significand: non-zero
static int inline is_half_denorm( cl_ushort half ){ return IsHalfSubnormal( half ); }

// sign bit: don't care, exponent: zero, significand: zero
static int inline is_half_zero( cl_ushort half ){ return ( half & 0x7fff ) == 0; }

cl_ushort convert_float_to_half( cl_float f );
cl_float  convert_half_to_float( cl_ushort h );

extern double sRGBmap(float fc);

#endif // _imageHelpers_h