/***********************************************************************
Filename   : rvtypes.h
Description: type definitions for all RADVISION modules
************************************************************************
        Copyright (c) 2001 RADVISION Inc. and RADVISION Ltd.
************************************************************************
NOTICE:
This document contains information that is confidential and proprietary
to RADVISION Inc. and RADVISION Ltd.. No part of this document may be
reproduced in any form whatsoever without written prior approval by
RADVISION Inc. or RADVISION Ltd..

RADVISION Inc. and RADVISION Ltd. reserve the right to revise this
publication and make changes without obligation to notify any person of
such revisions or changes.
***********************************************************************/
#ifndef RV_TYPES_H
#define RV_TYPES_H

#include <stddef.h>
#include "rvconfig.h"

/* A number of constants need to be defined in the configuration headers
   in order for this file to work properly. The values should be set
   properly for the architecture, os, compiler, memory model, etc. The
   definitions required are:

   RV_SIZET_TYPE          size_t type (should always be size_t)
   RV_PTRDIFFT_TYPE       ptrdiff_t type (should always be ptrdiff_t)
   RV_CHAR_TYPE           standard character type (for char and char * only)

   RV_VAR_INT_TYPE        standard variable (non-fixed) size signed variable
   RV_VAR_UINT_TYPE       standard variable (non-fixed) size unsigned variable
   RV_SIGNED_INT8_TYPE    8 bit signed variable
   RV_UNSIGNED_INT8_TYPE  8 bit unsigned variable
   RV_SIGNED_INT16_TYPE   16 bit signed variable
   RV_UNSIGNED_INT16_TYPE 16 bit unsigned variable
   RV_SIGNED_INT32_TYPE   32 bit signed variable
   RV_UNSIGNED_INT32_TYPE 32 bit unsigned variable
   RV_SIGNED_INT64_TYPE   64 bit signed variable
   RV_UNSIGNED_INT64_TYPE 64 bit unsigned variable

   RV_VAR_INT_SUFFIX(n)        standard variable (non-fixed) size signed constant suffix
   RV_VAR_UINT_SUFFIX(n)       standard variable (non-fixed) size unsigned constant suffix
   RV_SIGNED_INT8_SUFFIX(n)    8 bit signed constant suffix
   RV_UNSIGNED_INT8_SUFFIX(n)  8 bit ubsigned constant suffix
   RV_SIGNED_INT16_SUFFIX(n)   16 bit signed constant suffix
   RV_UNSIGNED_INT16_SUFFIX(n) 16 bit unsigned constant suffix
   RV_SIGNED_INT32_SUFFIX(n)   32 bit signed constant suffix
   RV_UNSIGNED_INT32_SUFFIX(n) 32 bit unsigned constant suffix
   RV_SIGNED_INT64_SUFFIX(n)   64 bit signed constant suffix
   RV_UNSIGNED_INT64_SUFFIX(n) 64 bit unsigned constant suffix

   RV_VAR_INT_MAX  maximum value of the standard variable (non-fixed) size signed variable
   RV_VAR_INT_MIN  minimum value of the standard variable (non-fixed) size signed variable
   RV_VAR_UINT_MAX maximum value of the standard variable (non-fixed) size unsigned variable
*/

#if defined(__cplusplus)
extern "C" {
#endif

/* Our types for size_t and ptrdiff_t, should never be anything */
/* different than ANSI standard but we define it just in case. */
typedef RV_SIZET_TYPE RvSize_t;
typedef RV_PTRDIFFT_TYPE RvPtrdiff_t;

/* Character type specifically for characters, not values */
typedef RV_CHAR_TYPE RvChar;

/* Variable size types, set to optimum variable size */
typedef RV_VAR_INT_TYPE RvInt;
#define RvIntConst(_n) (RV_VAR_INT_SUFFIX(_n))
#define RV_INT_MAX RV_VAR_INT_MAX
#define RV_INT_MIN RV_VAR_INT_MIN

typedef RV_VAR_UINT_TYPE RvUint;
#define RvUintConst(_n) (RV_VAR_UINT_SUFFIX(_n))
#define RV_UINT_MAX RV_VAR_UINT_MAX
#define RV_UINT_MIN RvUintConst(0)

/* Fixed size types */
typedef RV_SIGNED_INT8_TYPE RvInt8;
#define RvInt8Const(_n) (RV_SIGNED_INT8_SUFFIX(_n))
#define RV_INT8_MAX RvInt8Const(127)
#define RV_INT8_MIN (RvInt8Const(-127) - RvInt8Const(1))

typedef RV_UNSIGNED_INT8_TYPE RvUint8;
#define RvUint8Const(_n) (RV_UNSIGNED_INT8_SUFFIX(_n))
#define RV_UINT8_MAX RvUint8Const(255)
#define RV_UINT8_MIN RvUint8Const(0)

typedef RV_SIGNED_INT16_TYPE RvInt16;
#define RvInt16Const(_n) (RV_SIGNED_INT16_SUFFIX(_n))
#define RV_INT16_MAX RvInt16Const(32767)
#define RV_INT16_MIN (RvInt16Const(-32767) - RvInt16Const(1))

typedef RV_UNSIGNED_INT16_TYPE RvUint16;
#define RvUint16Const(_n) (RV_UNSIGNED_INT16_SUFFIX(_n))
#define RV_UINT16_MAX RvUint16Const(65535)
#define RV_UINT16_MIN RvUint16Const(0)

typedef RV_SIGNED_INT32_TYPE RvInt32;
#define RvInt32Const(_n) (RV_SIGNED_INT32_SUFFIX(_n))
#define RV_INT32_MAX RvInt32Const(2147483647)
#define RV_INT32_MIN (RvInt32Const(-2147483647) - RvInt32Const(-1))

typedef RV_UNSIGNED_INT32_TYPE RvUint32;
#define RvUint32Const(_n) (RV_UNSIGNED_INT32_SUFFIX(_n))
#define RV_UINT32_MAX RvUint32Const(4294967295)
#define RV_UINT32_MIN RvUint32Const(0)

typedef RV_SIGNED_INT64_TYPE RvInt64;
#define RvInt64Const(_n) (RV_SIGNED_INT64_SUFFIX(_n))
#define RV_INT64_MAX RvInt64Const(9223372036854775807)
#define RV_INT64_MIN (RvInt64Const(-9223372036854775807) - RvInt64Const(-1))

typedef RV_UNSIGNED_INT64_TYPE RvUint64;
#define RvUint64Const(_n) (RV_UNSIGNED_INT64_SUFFIX(_n))
#define RV_UINT64_MAX RvUint64Const(18446744073709551615)
#define RV_UINT64_MIN RvUint64Const(0)

/* Other standard types */
typedef RvUint RvBool;
#define RV_FALSE  RvUintConst(0)
#define RV_TRUE RvUintConst(1)

/* Misc Macros. Perhaps these should go elsewhere. */
#define RvMin(_a, _b) (((_a) < (_b)) ? (_a) : (_b))
#define RvMax(_a, _b)   (((_a) > (_b)) ? (_a) : (_b))

/* Alignment macros. Perhaps these should go elsewhere. */
struct RvAlign_s { /* used only for natural data alignment macro */
    char x;
    double y;
};

/* Not pretty, but allows numbytes to be any valid size_t value which is */
/* a power of 2 and works no matter what the relationship between pointer */
/* and data sizes. */
#define RvAlignTo(_ptr, _numbytes) ((RvInt8 *)(_ptr) + (((size_t)(_numbytes) - ((size_t)(_ptr) & (size_t)((_numbytes) - 1))) & (size_t)((_numbytes) - 1)))

/* Natural alignment sizes and macros */
#define RV_ALIGN_DATASIZE (offsetof(struct RvAlign_s, y))
#define RV_ALIGN_PTRSIZE (sizeof(void *))
#define RV_ALIGN_SIZE (RvMax(RV_ALIGN_DATASIZE, RV_ALIGN_PTRSIZE))
#define RvAlignPtr(_x) (RvAlignTo((_x), RV_ALIGN_PTRSIZE))
#define RvAlignData(_x) (RvAlignTo((_x), RV_ALIGN_DATASIZE))
#define RvAlign(_x) (RvAlignTo((_x), RV_ALIGN_SIZE))

/* Fixed width alignment macros */
#define RvAlign16(_x) (RvAlignTo((_x), 2))
#define RvAlign32(_x) (RvAlignTo((_x), 4))
#define RvAlign64(_x) (RvAlignTo((_x), 8))

/* Round up size_t size to a multiple of size_t numbytes (size must be > 0 and <= maxsize - numbytes) */
#define RvRoundToSize(_size, _numbytes) ((size_t)((_size) + (_numbytes) - 1 - (((_size) - 1) % (_numbytes))))


/*******************/
/* Unused arguments macro */
#define RV_UNUSED_ARG(_arg) if (_arg);


/* Some "empty" definitons that we can use for readability of the code */
#define IN
#define OUT
#define INOUT

/************************************************************************
 * RV_DECLARE_HANDLE
 * Definition used to create a general purpose handle. It is declared
 * in this weird way to allow better type checking with C compilers.
 ************************************************************************/
#define RV_DECLARE_HANDLE(_handleName) \
                                      typedef struct { int unused; } _handleName##__ ; \
                                      typedef const _handleName##__ * _handleName; \
                                      typedef _handleName*  LP##_handleName


/* Macro used to calculate the pointer position of a struct, given one of its
   internal fields */
#define RV_GET_STRUCT(_structTypedef, _fieldName, _fieldPtr) \
    ((_structTypedef *)( ((char *)(_fieldPtr)) - offsetof(_structTypedef, _fieldName) ))


/* Macros for conversion of byte ordering */
#if (RV_ARCH_ENDIAN == RV_ARCH_LITTLE_ENDIAN)

/* Always use these macros with a variable - never pass an argument or a function call as a
   parameter of these macros! */
#define RvConvertHostToNetwork32(_host) \
    ( (RvUint32) (                                          \
       ((RvUint32)(((RvUint8*)(&(_host)))[3])) |            \
      (((RvUint32)(((RvUint8*)(&(_host)))[2])) << 8) |      \
      (((RvUint32)(((RvUint8*)(&(_host)))[1])) << 16) |     \
      (((RvUint32)(((RvUint8*)(&(_host)))[0])) << 24)) )
#define RvConvertHostToNetwork16(_host) \
    ( (RvUint16) (                                          \
       ((RvUint16)(((RvUint8*)(&(_host)))[1])) |            \
      (((RvUint16)(((RvUint8*)(&(_host)))[0])) << 8)) )

#define RvConvertNetworkToHost32(_network) RvConvertHostToNetwork32(_network)
#define RvConvertNetworkToHost16(_network) RvConvertHostToNetwork16(_network)

#elif (RV_ARCH_ENDIAN == RV_ARCH_BIG_ENDIAN)

#define RvConvertHostToNetwork32(_host) (_host)
#define RvConvertNetworkToHost32(_network) (_network)
#define RvConvertHostToNetwork16(_host) (_host)
#define RvConvertNetworkToHost16(_network) (_network)

#endif


#if defined(__cplusplus)
}
#endif

#endif /* RV_TYPES_H */