/*M///////////////////////////////////////////////////////////////////////////////////////
//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                        Intel License Agreement
//                For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of Intel Corporation may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/


/****************************************************************************************/
/*                         Dynamic detection and loading of IPP modules                 */
/****************************************************************************************/

#include "_cxcore.h"

#if defined _MSC_VER && _MSC_VER >= 1200
#pragma warning( disable: 4115 )        /* type definition in () */
#endif

#if defined _MSC_VER && defined WIN64 && !defined EM64T
#pragma optimize( "", off )
#endif

#if defined WIN32 || defined WIN64
#include <windows.h>
#else
#include <dlfcn.h>
#include <sys/time.h>
#endif

#include <string.h>
#include <stdio.h>
#include <ctype.h>

#define CV_PROC_GENERIC             0
#define CV_PROC_SHIFT               10
#define CV_PROC_ARCH_MASK           ((1 << CV_PROC_SHIFT) - 1)
#define CV_PROC_IA32_GENERIC        1
#define CV_PROC_IA32_WITH_MMX       (CV_PROC_IA32_GENERIC|(2 << CV_PROC_SHIFT))
#define CV_PROC_IA32_WITH_SSE       (CV_PROC_IA32_GENERIC|(3 << CV_PROC_SHIFT))
#define CV_PROC_IA32_WITH_SSE2      (CV_PROC_IA32_GENERIC|(4 << CV_PROC_SHIFT))
#define CV_PROC_IA64                2
#define CV_PROC_EM64T               3
#define CV_GET_PROC_ARCH(model)     ((model) & CV_PROC_ARCH_MASK)

typedef struct CvProcessorInfo
{
    int model;
    int count;
    double frequency; // clocks per microsecond
}
CvProcessorInfo;

#undef MASM_INLINE_ASSEMBLY

#if defined WIN32 && !defined  WIN64

#if defined _MSC_VER
#define MASM_INLINE_ASSEMBLY 1
#elif defined __BORLANDC__

#if __BORLANDC__ >= 0x560
#define MASM_INLINE_ASSEMBLY 1
#endif

#endif

#endif

/*
   determine processor type
*/
static void
icvInitProcessorInfo( CvProcessorInfo* cpu_info )
{
    memset( cpu_info, 0, sizeof(*cpu_info) );
    cpu_info->model = CV_PROC_GENERIC;

#if defined WIN32 || defined WIN64

#ifndef PROCESSOR_ARCHITECTURE_AMD64
#define PROCESSOR_ARCHITECTURE_AMD64 9
#endif

#ifndef PROCESSOR_ARCHITECTURE_IA32_ON_WIN64
#define PROCESSOR_ARCHITECTURE_IA32_ON_WIN64 10
#endif

    SYSTEM_INFO sys;
    LARGE_INTEGER freq;

    GetSystemInfo( &sys );

    if( sys.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL &&
        sys.dwProcessorType == PROCESSOR_INTEL_PENTIUM && sys.wProcessorLevel >= 6 )
    {
        int version = 0, features = 0, family = 0;
        int id = 0;
        HKEY key = 0;

        cpu_info->count = (int)sys.dwNumberOfProcessors;
        unsigned long val = 0, sz = sizeof(val);

        if( RegOpenKeyEx( HKEY_LOCAL_MACHINE, "HARDWARE\\DESCRIPTION\\SYSTEM\\CentralProcessor\\0\\",
            0, KEY_QUERY_VALUE, &key ) >= 0 )
        {
            if( RegQueryValueEx( key, "~MHz", 0, 0, (uchar*)&val, &sz ) >= 0 )
                cpu_info->frequency = (double)val;
            RegCloseKey( key );
        }

#ifdef MASM_INLINE_ASSEMBLY
        __asm
        {
            /* use CPUID to determine the features supported */
            pushfd
            mov   eax, 1
            push  ebx
            push  esi
            push  edi
#ifdef __BORLANDC__
            db 0fh
            db 0a2h
#else
            _emit 0x0f
            _emit 0xa2
#endif
            pop   edi
            pop   esi
            pop   ebx
            mov   version, eax
            mov   features, edx
            popfd
        }
#elif defined WIN32 && __GNUC__ > 2
        asm volatile
        (
            "movl $1,%%eax\n\t"
            ".byte 0x0f; .byte 0xa2\n\t"
            "movl %%eax, %0\n\t"
            "movl %%edx, %1\n\t"
            : "=r"(version), "=r" (features)
            :
            : "%ebx", "%esi", "%edi"
        );
#else
        {
            static const char cpuid_code[] =
                "\x53\x56\x57\xb8\x01\x00\x00\x00\x0f\xa2\x5f\x5e\x5b\xc3";
            typedef int64 (CV_CDECL * func_ptr)(void);
            func_ptr cpuid = (func_ptr)(void*)cpuid_code;
            int64 cpuid_val = cpuid();
            version = (int)cpuid_val;
            features = (int)(cpuid_val >> 32);
        }
#endif

        #define ICV_CPUID_M6     ((1<<15)|(1<<23))  /* cmov + MMX */
        #define ICV_CPUID_A6     ((1<<25)|ICV_CPUID_M6) /* <all above> + SSE */
        #define ICV_CPUID_W7     ((1<<26)|ICV_CPUID_A6) /* <all above> + SSE2 */

        family = (version >> 8) & 15;
        if( family >= 6 && (features & ICV_CPUID_M6) != 0 ) /* Pentium II or higher */
            id = features & ICV_CPUID_W7;

        cpu_info->model = id == ICV_CPUID_W7 ? CV_PROC_IA32_WITH_SSE2 :
                          id == ICV_CPUID_A6 ? CV_PROC_IA32_WITH_SSE :
                          id == ICV_CPUID_M6 ? CV_PROC_IA32_WITH_MMX :
                          CV_PROC_IA32_GENERIC;
    }
    else
    {
#if defined EM64T
        if( sys.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64 )
            cpu_info->model = CV_PROC_EM64T;
#elif defined WIN64
        if( sys.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64 )
            cpu_info->model = CV_PROC_IA64;
#endif
        if( QueryPerformanceFrequency( &freq ) )
            cpu_info->frequency = (double)freq.QuadPart;
    }
#else
    cpu_info->frequency = 1;

#ifdef __x86_64__
    cpu_info->model = CV_PROC_EM64T;
#elif defined __ia64__
    cpu_info->model = CV_PROC_IA64;
#elif !defined __i386__
    cpu_info->model = CV_PROC_GENERIC;
#else
    cpu_info->model = CV_PROC_IA32_GENERIC;
    
    // reading /proc/cpuinfo file (proc file system must be supported)
    FILE *file = fopen( "/proc/cpuinfo", "r" );

    if( file )
    {
        char buffer[1024];
        int max_size = sizeof(buffer)-1;

        for(;;)
        {
            const char* ptr = fgets( buffer, max_size, file );
            if( !ptr )
                break;
            if( strncmp( buffer, "flags", 5 ) == 0 )
            {
                if( strstr( buffer, "mmx" ) && strstr( buffer, "cmov" ))
                {
                    cpu_info->model = CV_PROC_IA32_WITH_MMX;
                    if( strstr( buffer, "xmm" ) || strstr( buffer, "sse" ))
                    {
                        cpu_info->model = CV_PROC_IA32_WITH_SSE;
                        if( strstr( buffer, "emm" ))
                            cpu_info->model = CV_PROC_IA32_WITH_SSE2;
                    }
                }
            }
            else if( strncmp( buffer, "cpu MHz", 7 ) == 0 )
            {
                char* pos = strchr( buffer, ':' );
                if( pos )
                    cpu_info->frequency = strtod( pos + 1, &pos );
            }
        }

        fclose( file );
        if( CV_GET_PROC_ARCH(cpu_info->model) != CV_PROC_IA32_GENERIC )
            cpu_info->frequency = 1;
        else
            assert( cpu_info->frequency > 1 );
    }
#endif
#endif
}


CV_INLINE const CvProcessorInfo*
icvGetProcessorInfo()
{
    static CvProcessorInfo cpu_info;
    static int init_cpu_info = 0;
    if( !init_cpu_info )
    {
        icvInitProcessorInfo( &cpu_info );
        init_cpu_info = 1;
    }
    return &cpu_info;
}


/****************************************************************************************/
/*                               Make functions descriptions                            */
/****************************************************************************************/

#undef IPCVAPI_EX
#define IPCVAPI_EX(type,func_name,names,modules,arg) \
    { (void**)&func_name##_p, (void*)(size_t)-1, names, modules, 0 },

#undef IPCVAPI_C_EX
#define IPCVAPI_C_EX(type,func_name,names,modules,arg) \
    { (void**)&func_name##_p, (void*)(size_t)-1, names, modules, 0 },

static CvPluginFuncInfo cxcore_ipp_tab[] =
{
#undef _CXCORE_IPP_H_
#include "_cxipp.h"
#undef _CXCORE_IPP_H_
    {0, 0, 0, 0, 0}
};


/*
   determine processor type, load appropriate dll and
   initialize all function pointers
*/
#if defined WIN32 || defined WIN64
#define DLL_PREFIX ""
#define DLL_SUFFIX ".dll"
#else
#define DLL_PREFIX "lib"
#define DLL_SUFFIX ".so"
#define LoadLibrary(name) dlopen(name, RTLD_LAZY)
#define FreeLibrary(name) dlclose(name)
#define GetProcAddress dlsym
typedef void* HMODULE;
#endif

#if 0 /*def _DEBUG*/
#define DLL_DEBUG_FLAG "d"
#else
#define DLL_DEBUG_FLAG ""
#endif

#define VERBOSE_LOADING 0

#if VERBOSE_LOADING
#define ICV_PRINTF(args)  printf args; fflush(stdout)
#else
#define ICV_PRINTF(args)
#endif

typedef struct CvPluginInfo
{
    const char* basename;
    HMODULE handle;
    char name[100];
}
CvPluginInfo;

static CvPluginInfo plugins[CV_PLUGIN_MAX];
static CvModuleInfo cxcore_info = { 0, "cxcore", CV_VERSION, cxcore_ipp_tab };

CvModuleInfo *CvModule::first = 0, *CvModule::last = 0;

CvModule::CvModule( CvModuleInfo* _info )
{
    cvRegisterModule( _info );
    info = last;
}

CvModule::~CvModule()
{
    if( info )
    {
        CvModuleInfo* p = first;
        for( ; p != 0 && p->next != info; p = p->next )
            ;
        if( p )
            p->next = info->next;
        if( first == info )
            first = info->next;
        if( last == info )
            last = p;
        cvFree( &info );
        info = 0;
    }
}

static int
icvUpdatePluginFuncTab( CvPluginFuncInfo* func_tab )
{
    int i, loaded_functions = 0;

    // 1. reset pointers
    for( i = 0; func_tab[i].func_addr != 0; i++ )
    {
        if( func_tab[i].default_func_addr == (void*)(size_t)-1 )
            func_tab[i].default_func_addr = *func_tab[i].func_addr;
        else
            *func_tab[i].func_addr = func_tab[i].default_func_addr;
        func_tab[i].loaded_from = 0;
    }

    // ippopencv substitutes all the other IPP modules
    if( plugins[CV_PLUGIN_OPTCV].handle != 0 )
    {
        for( i = 2; i < CV_PLUGIN_MKL; i++ )
        {
            assert( plugins[i].handle == 0 );
            plugins[i].handle = plugins[CV_PLUGIN_OPTCV].handle;
        }
    }

    // 2. try to find corresponding functions in ipp* and reassign pointers to them
    for( i = 0; func_tab[i].func_addr != 0; i++ )
    {
    #if defined _MSC_VER && _MSC_VER >= 1200
        #pragma warning( disable: 4054 4055 ) /* converting pointers to code<->data */
    #endif
        char name[100];
        int j = 0, idx = 0;

        assert( func_tab[i].loaded_from == 0 );

        if( func_tab[i].search_modules )
        {
            uchar* addr = 0;
            const char* name_ptr = func_tab[i].func_names;

            for( ; j < 10 && name_ptr; j++ )
            {
                const char* name_start = name_ptr;
                const char* name_end;
                while( !isalpha(name_start[0]) && name_start[0] != '\0' )
                    name_start++;
                if( !name_start[0] )
                    name_start = 0;
                name_end = name_start ? strchr( name_start, ',' ) : 0;
                idx = (func_tab[i].search_modules / (1<<j*4)) % CV_PLUGIN_MAX;

                if( plugins[idx].handle != 0 && name_start )
                {
                    if( name_end != 0 )
                    {
                        strncpy( name, name_start, name_end - name_start );
                        name[name_end - name_start] = '\0';
                    }
                    else
                        strcpy( name, name_start );

                    addr = (uchar*)GetProcAddress( plugins[idx].handle, name );
                    if( addr )
                        break;
                }
                name_ptr = name_end;
            }

            if( addr )
            {
            /*#ifdef WIN32
                while( *addr == 0xE9 )
                    addr += 5 + *((int*)(addr + 1));
            #endif*/
                *func_tab[i].func_addr = addr;
                func_tab[i].loaded_from = idx; // store index of the module
                                                   // that contain the loaded function
                loaded_functions++;
                ICV_PRINTF(("%s: \t%s\n", name, plugins[idx].name ));
            }

            #if defined _MSC_VER && _MSC_VER >= 1200
                #pragma warning( default: 4054 4055 )
            #endif
        }
    }

#if VERBOSE_LOADING
    {
    int not_loaded = 0;
    ICV_PRINTF(("\nTotal loaded: %d\n\n", loaded_functions ));
    printf( "***************************************************\nNot loaded ...\n\n" );
    for( i = 0; func_tab[i].func_addr != 0; i++ )
        if( !func_tab[i].loaded_from )
        {
            ICV_PRINTF(( "%s\n", func_tab[i].func_names ));
            not_loaded++;
        }

    ICV_PRINTF(("\nTotal: %d\n", not_loaded ));
    }
#endif

    if( plugins[CV_PLUGIN_OPTCV].handle != 0 )
    {
        for( i = 2; i < CV_PLUGIN_MKL; i++ )
            plugins[i].handle = 0;
    }

    return loaded_functions;
}


CV_IMPL int
cvRegisterModule( const CvModuleInfo* module )
{
    CvModuleInfo* module_copy = 0;

    CV_FUNCNAME( "cvRegisterModule" );

    __BEGIN__;

    size_t name_len, version_len;

    CV_ASSERT( module != 0 && module->name != 0 && module->version != 0 );

    name_len = strlen(module->name);
    version_len = strlen(module->version);

    CV_CALL( module_copy = (CvModuleInfo*)cvAlloc( sizeof(*module_copy) +
                                        name_len + 1 + version_len + 1 ));

    *module_copy = *module;
    module_copy->name = (char*)(module_copy + 1);
    module_copy->version = (char*)(module_copy + 1) + name_len + 1;

    memcpy( (void*)module_copy->name, module->name, name_len + 1 );
    memcpy( (void*)module_copy->version, module->version, version_len + 1 );
    module_copy->next = 0;

    if( CvModule::first == 0 )
        CvModule::first = module_copy;
    else
        CvModule::last->next = module_copy;
    CvModule::last = module_copy;

    if( CvModule::first == CvModule::last )
    {
        CV_CALL( cvUseOptimized(1));
    }
    else
    {
        CV_CALL( icvUpdatePluginFuncTab( module_copy->func_tab ));
    }

    __END__;

    if( cvGetErrStatus() < 0 && module_copy )
        cvFree( &module_copy );

    return module_copy ? 0 : -1;
}


CV_IMPL int
cvUseOptimized( int load_flag )
{
    int i, loaded_modules = 0, loaded_functions = 0;
    CvModuleInfo* module;
    const CvProcessorInfo* cpu_info = icvGetProcessorInfo();
    int arch = CV_GET_PROC_ARCH(cpu_info->model);
    
    // TODO: implement some more elegant way
    // to find the latest and the greatest IPP/MKL libraries
    static const char* opencv_sfx[] = { "100", "099", "097", 0 };
    static const char* ipp_sfx_ia32[] = { "-6.1", "-6.0", "-5.3", "-5.2", "-5.1", "", 0 };
    static const char* ipp_sfx_ia64[] = { "64-6.1", "64-6.0", "64-5.2", "64-5.1", "64", 0 };
    static const char* ipp_sfx_em64t[] = { "em64t-6.1", "em64t-6.0", "em64t-5.2", "em64t-5.1", "em64t", 0 };
    static const char* mkl_sfx_ia32[] = { "p4", "p3", "def", 0 };
    static const char* mkl_sfx_ia64[] = { "i2p", "itp", 0 };
    static const char* mkl_sfx_em64t[] = { "def", 0 };
    const char** ipp_suffix = arch == CV_PROC_IA64 ? ipp_sfx_ia64 :
                              arch == CV_PROC_EM64T ? ipp_sfx_em64t : ipp_sfx_ia32;
    const char** mkl_suffix = arch == CV_PROC_IA64 ? mkl_sfx_ia64 :
                              arch == CV_PROC_EM64T ? mkl_sfx_em64t : mkl_sfx_ia32;

    for( i = 0; i < CV_PLUGIN_MAX; i++ )
        plugins[i].basename = 0;
    plugins[CV_PLUGIN_NONE].basename = 0;
    plugins[CV_PLUGIN_NONE].name[0] = '\0';
    plugins[CV_PLUGIN_OPTCV].basename = "ippopencv";
    plugins[CV_PLUGIN_IPPCV].basename = "ippcv";
    plugins[CV_PLUGIN_IPPI].basename = "ippi";
    plugins[CV_PLUGIN_IPPS].basename = "ipps";
    plugins[CV_PLUGIN_IPPVM].basename = "ippvm";
    plugins[CV_PLUGIN_IPPCC].basename = "ippcc";
    plugins[CV_PLUGIN_MKL].basename = "mkl_";

    // try to load optimized dlls
    for( i = 1; i < CV_PLUGIN_MAX; i++ )
    {
        // unload previously loaded optimized modules
        if( plugins[i].handle )
        {
            FreeLibrary( plugins[i].handle );
            plugins[i].handle = 0;
        }

        // do not load regular IPP modules if the custom merged IPP module is already found.
        if( i < CV_PLUGIN_MKL && load_flag && plugins[CV_PLUGIN_OPTCV].handle != 0 )
            continue;

        if( load_flag && plugins[i].basename &&
            (arch == CV_PROC_IA32_GENERIC || arch == CV_PROC_IA64 || arch == CV_PROC_EM64T) )
        {
            const char** suffix = i == CV_PLUGIN_OPTCV ? opencv_sfx :
                            i < CV_PLUGIN_MKL ? ipp_suffix : mkl_suffix;
            if( suffix == mkl_sfx_ia32 )
            {
                if( !(cpu_info->model & CV_PROC_IA32_WITH_SSE2) )
                    suffix++;
                if( !(cpu_info->model & CV_PROC_IA32_WITH_SSE) )
                    suffix++;
            }

            for( ; *suffix != 0; suffix++ )
            {
                sprintf( plugins[i].name, DLL_PREFIX "%s%s" DLL_DEBUG_FLAG DLL_SUFFIX,
                    plugins[i].basename, *suffix );

                ICV_PRINTF(("loading %s...\n", plugins[i].name ));
                plugins[i].handle = LoadLibrary( plugins[i].name );
                if( plugins[i].handle != 0 )
                {
                    ICV_PRINTF(("%s loaded\n", plugins[i].name ));
                    loaded_modules++;
                    break;
                }
                #ifndef WIN32
                // temporary workaround for MacOSX 
                sprintf( plugins[i].name, DLL_PREFIX "%s%s" DLL_DEBUG_FLAG ".dylib",
                    plugins[i].basename, *suffix );

                ICV_PRINTF(("loading %s...\n", plugins[i].name ));
                plugins[i].handle = LoadLibrary( plugins[i].name );
                if( plugins[i].handle != 0 )
                {
                    ICV_PRINTF(("%s loaded\n", plugins[i].name ));
                    loaded_modules++;
                    break;
                }
                #endif
            }
        }
    }

    for( module = CvModule::first; module != 0; module = module->next )
        loaded_functions += icvUpdatePluginFuncTab( module->func_tab );

    return loaded_functions;
}

CvModule cxcore_module( &cxcore_info );

CV_IMPL void
cvGetModuleInfo( const char* name, const char **version, const char **plugin_list )
{
    static char joint_verinfo[1024] = "";
    static char plugin_list_buf[1024] = "";

    CV_FUNCNAME( "cvGetLibraryInfo" );

    if( version )
        *version = 0;

    if( plugin_list )
        *plugin_list = 0;

    __BEGIN__;

    CvModuleInfo* module;

    if( version )
    {
        if( name )
        {
            size_t i, name_len = strlen(name);

            for( module = CvModule::first; module != 0; module = module->next )
            {
                if( strlen(module->name) == name_len )
                {
                    for( i = 0; i < name_len; i++ )
                    {
                        int c0 = toupper(module->name[i]), c1 = toupper(name[i]);
                        if( c0 != c1 )
                            break;
                    }
                    if( i == name_len )
                        break;
                }
            }
            if( !module )
                CV_ERROR( CV_StsObjectNotFound, "The module is not found" );

            *version = module->version;
        }
        else
        {
            char* ptr = joint_verinfo;

            for( module = CvModule::first; module != 0; module = module->next )
            {
                sprintf( ptr, "%s: %s%s", module->name, module->version, module->next ? ", " : "" );
                ptr += strlen(ptr);
            }

            *version = joint_verinfo;
        }
    }

    if( plugin_list )
    {
        char* ptr = plugin_list_buf;
        int i;

        for( i = 0; i < CV_PLUGIN_MAX; i++ )
            if( plugins[i].handle != 0 )
            {
                sprintf( ptr, "%s, ", plugins[i].name );
                ptr += strlen(ptr);
            }

        if( ptr > plugin_list_buf )
        {
            ptr[-2] = '\0';
            *plugin_list = plugin_list_buf;
        }
        else
            *plugin_list = "";
    }

    __END__;
}


typedef int64 (CV_CDECL * rdtsc_func)(void);

/* helper functions for RNG initialization and accurate time measurement */
CV_IMPL  int64  cvGetTickCount( void )
{
    const CvProcessorInfo* cpu_info = icvGetProcessorInfo();

    if( cpu_info->frequency > 1 &&
        CV_GET_PROC_ARCH(cpu_info->model) == CV_PROC_IA32_GENERIC )
    {
#ifdef MASM_INLINE_ASSEMBLY
    #ifdef __BORLANDC__
        __asm db 0fh
        __asm db 31h
    #else
        __asm _emit 0x0f;
        __asm _emit 0x31;
    #endif
#elif (defined __GNUC__ || defined CV_ICC) && defined __i386__
        int64 t;
        asm volatile (".byte 0xf; .byte 0x31" /* "rdtsc" */ : "=A" (t));
        return t;
#else
        static const char code[] = "\x0f\x31\xc3";
        rdtsc_func func = (rdtsc_func)(void*)code;
        return func();
#endif
    }
    else
    {
#if defined WIN32 || defined WIN64
        LARGE_INTEGER counter;
        QueryPerformanceCounter( &counter );
        return (int64)counter.QuadPart;
#else
        struct timeval tv;
        struct timezone tz;
        gettimeofday( &tv, &tz );
        return (int64)tv.tv_sec*1000000 + tv.tv_usec;
#endif
    }
}

CV_IMPL  double  cvGetTickFrequency()
{
    return icvGetProcessorInfo()->frequency;
}


static int icvNumThreads = 0;
static int icvNumProcs = 0;

CV_IMPL int cvGetNumThreads(void)
{
    if( !icvNumProcs )
        cvSetNumThreads(0);
    return icvNumThreads;
}

CV_IMPL void cvSetNumThreads( int threads )
{
    if( !icvNumProcs )
    {
#ifdef _OPENMP
        icvNumProcs = omp_get_num_procs();
        icvNumProcs = MIN( icvNumProcs, CV_MAX_THREADS );
#else
        icvNumProcs = 1;
#endif
    }

#ifdef _OPENMP
    if( threads <= 0 )
        threads = icvNumProcs;
    //else
    //    threads = MIN( threads, icvNumProcs );

    icvNumThreads = threads;
#else
    icvNumThreads = 1;
#endif
}


CV_IMPL int cvGetThreadNum(void)
{
#ifdef _OPENMP
    return omp_get_thread_num();
#else
    return 0;
#endif
}


/* End of file. */
