syswin.cpp

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

/* ////////////////////////////////////////////////////////////////////////
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//          Copyright(c) 2004-2005 Intel Corporation. All Rights Reserved.
//
//
//
*/

#if defined SYSWIN32 || defined SYSWIN64

#ifndef SYSWIN32
 #define WIN32
#endif

#ifdef SYSWIN64
 #define WIN64
#endif

#include <windows.h>
#include "syscross.h"

struct sSysFile
{
    HANDLE hande;
};

typedef struct sSysFile SSysFile;

static SysCallResult sysOwnCloseHandle(HANDLE *handle)
{
    BOOL sysres = 0;
    if(handle != NULL) sysres = CloseHandle(*handle);

    if(sysres)
    {
        handle = 0;
        return SYS_CALL_RESULT_OK;
    }

    return SYS_CALL_RESULT_FAIL_NON_SPECIFIC;
}

SysCallResult sysFileCreate(
    const char       *fileName,
    SysAccessRight    access,
    SysCreateOptions  createOptions,
    SysAccessType     accessOptimization,
    SysFile          *file
)
{
    SysCallResult result = SYS_CALL_RESULT_OK;

    DWORD dwAccess    = 0;
    DWORD dwCreation  = 0;
/*
    DWORD dwShareMode = 0;
*/
    DWORD dwFlags     = 0;


    *file = (SSysFile *)malloc(sizeof(SSysFile));

    if(!(*file))
    {
        result = SYS_CALL_RESULT_FAIL_NO_MEMORY;
        goto fail;
    }

    if(access & SYS_ACCESS_RIGHT_READ ) dwAccess |= GENERIC_READ;
    if(access & SYS_ACCESS_RIGHT_WRITE) dwAccess |= GENERIC_WRITE;

/* for linux behavior compatibility */
/*
    if(shareAccess & SYS_ACCESS_RIGHT_READ ) dwShareMode |= FILE_SHARE_READ;
    if(shareAccess & SYS_ACCESS_RIGHT_WRITE) dwShareMode |= FILE_SHARE_WRITE;
*/

    switch(createOptions)
    {
    case SYS_CREATE_OPTIONS_NEW_ONLY:               dwCreation = CREATE_NEW;        break;
    case SYS_CREATE_OPTIONS_EXISTING_ONLY_KEEP:     dwCreation = OPEN_EXISTING;     break;
    case SYS_CREATE_OPTIONS_EXISTING_ONLY_TRUNCATE: dwCreation = TRUNCATE_EXISTING; break;
    case SYS_CREATE_OPTIONS_ALWAYS_KEEP:            dwCreation = OPEN_ALWAYS;       break;
    case SYS_CREATE_OPTIONS_ALWAYS_TRUNCATE:        dwCreation = CREATE_ALWAYS;     break;
    default:
        result = SYS_CALL_RESULT_FAIL_BAD_OPTION;
        goto fail;
    }

    switch(accessOptimization)
    {
    case SYS_ACCESS_TYPE_RANDOM:     dwFlags |= FILE_FLAG_RANDOM_ACCESS;   break;
    case SYS_ACCESS_TYPE_SEQUENTIAL: dwFlags |= FILE_FLAG_SEQUENTIAL_SCAN; break;
    default:
        result = SYS_CALL_RESULT_FAIL_BAD_OPTION;
        goto fail;
    }

    (*file)->hande = CreateFile(fileName, dwAccess, /* dwShareMode */FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwCreation, dwFlags, NULL);

    if((*file)->hande == INVALID_HANDLE_VALUE)
    {
        result = SYS_CALL_RESULT_FAIL_NON_SPECIFIC;
        goto fail;
    }

    goto ok;

fail:
    if(*file) { free(*file); *file = 0; }
ok:
    return result;
}

SysCallResult sysFileClose (
    SysFile  file
)
{
    SysCallResult result = SYS_CALL_RESULT_OK;

    if(file)
    {
        result = sysOwnCloseHandle(&(file->hande));
        free(file);
    }

    return result;
}

SysCallResult sysFileGetSize (
    SysFile       file,
    unsigned int *size
)
{
    *size = GetFileSize(file->hande, NULL);

    if(INVALID_FILE_SIZE != *size)
        return SYS_CALL_RESULT_OK;

    return SYS_CALL_RESULT_FAIL_NON_SPECIFIC;
}

struct sSysMemoryMap
{
    HANDLE handle;
};

typedef struct sSysMemoryMap SSysMemoryMap;

SysCallResult sysMemoryMapCreate    (
    SysFile             file,
    SysMemoryMapAccess  access,
    unsigned int        maxSize,
    SysMemoryMap       *memoryMap
)
{
    SysCallResult result = SYS_CALL_RESULT_OK;

    DWORD flProtect = 0;


    *memoryMap = (SSysMemoryMap *)malloc(sizeof(SSysMemoryMap));

    if(!(*memoryMap))
    {
        result = SYS_CALL_RESULT_FAIL_NO_MEMORY;
        goto fail;
    }

    switch(access)
    {
    case SYS_MEMORY_MAP_ACCESS_READ_WRITE_COPY: flProtect = PAGE_WRITECOPY; break;
    case SYS_MEMORY_MAP_ACCESS_READ_WRITE:      flProtect = PAGE_READWRITE; break;
    case SYS_MEMORY_MAP_ACCESS_READ_ONLY:       flProtect = PAGE_READONLY;  break;
    default:
        result = SYS_CALL_RESULT_FAIL_BAD_OPTION;
        goto fail;
    }

    (*memoryMap)->handle = CreateFileMapping(file->hande, NULL, flProtect, 0, maxSize, NULL);

    if(!(*memoryMap)->handle)
    {
        result = SYS_CALL_RESULT_FAIL_NON_SPECIFIC;
        goto fail;
    }

    goto ok;

fail:
    if(*memoryMap) { free(*memoryMap); *memoryMap = 0; }
ok:
    return result;
}

SysCallResult sysMemoryMapClose     (
    SysMemoryMap memoryMap
)
{
    SysCallResult result = SYS_CALL_RESULT_OK;

    if(memoryMap)
    {
        result = sysOwnCloseHandle(&(memoryMap->handle));
        free(memoryMap);
    }

    return result;
}


struct sSysMemoryMapView
{
    void *addr;
};

typedef struct sSysMemoryMapView SSysMemoryMapView;

SysCallResult sysMemoryMapViewCreate (
    SysMemoryMap        memoryMap,
    SysMemoryMapAccess  access,
    unsigned int        offset,
    unsigned int        size,
    SysMemoryMapView   *memoryMapView
)
{
    SysCallResult result = SYS_CALL_RESULT_OK;
    DWORD dwDesiredAccess = 0;

    *memoryMapView = (SSysMemoryMapView *)malloc(sizeof(SSysMemoryMapView));

    if(!(*memoryMapView))
    {
        result = SYS_CALL_RESULT_FAIL_NO_MEMORY;
        goto fail;
    }

    switch(access)
    {
    case SYS_MEMORY_MAP_ACCESS_READ_WRITE_COPY: dwDesiredAccess = FILE_MAP_COPY;  break;
    case SYS_MEMORY_MAP_ACCESS_READ_WRITE:      dwDesiredAccess = FILE_MAP_WRITE; break;
    case SYS_MEMORY_MAP_ACCESS_READ_ONLY:       dwDesiredAccess = FILE_MAP_READ;  break;
    default:
        result = SYS_CALL_RESULT_FAIL_BAD_OPTION;
        goto fail;
    }

    (*memoryMapView)->addr = MapViewOfFile(memoryMap->handle, dwDesiredAccess, 0, offset, size);

    if((*memoryMapView)->addr == NULL)
    {
        result = SYS_CALL_RESULT_FAIL_NON_SPECIFIC;
        goto fail;
    }

    goto ok;

fail:
    if(*memoryMapView) { free(*memoryMapView); *memoryMapView = 0; }
ok:
    return result;
}

SysCallResult sysMemoryMapViewClose (
    SysMemoryMapView memoryMapView
)
{
    BOOL sysres = 0;

    if(!memoryMapView) return SYS_CALL_RESULT_OK;

    sysres = UnmapViewOfFile(memoryMapView->addr);
    free(memoryMapView);

    if(sysres)
        return SYS_CALL_RESULT_OK;

    return SYS_CALL_RESULT_FAIL_NON_SPECIFIC;
}

SysCallResult sysMemoryMapViewGetAddr(
    SysMemoryMapView   memoryMapView,
    void             **addr
)
{
    *addr = memoryMapView->addr;

    if(*addr)
        return SYS_CALL_RESULT_OK;

    return SYS_CALL_RESULT_FAIL_NON_SPECIFIC;
}


#endif // defined SYSWIN32 || defined SYSWIN64