vm_event_linux32.c

这是在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) 2003-2005 Intel Corporation. All Rights Reserved.
//
*/

#ifdef LINUX32

#include <sys/time.h>
#include <pthread.h>
#include <errno.h>
#include "vm_event.h"

/* Invalidate an event */
void vm_event_set_invalid(vm_event *event)
{
    /* check error(s) */
    if (NULL == event)
        return;

    event->state= -1;

} /* void vm_event_set_invalid(vm_event *event) */

/* Verify if an event is valid */
int vm_event_is_valid(vm_event *event)
{
    /* check error(s) */
    if (NULL == event)
        return 0;

    return event->state >= 0;

} /* int vm_event_is_valid(vm_event *event) */

/* Init an event. Event is created unset. return 1 if success */
vm_status vm_event_init(vm_event *event, int manual, int state)
{
    /* check error(s) */
    if (NULL == event)
        return VM_NULL_PTR;

    event->manual = manual;
    event->state = state ? 1:0;
    pthread_cond_init(&event->cond, 0);
    pthread_mutex_init(&event->mutex,0);

    return VM_OK;

} /* vm_status vm_event_init(vm_event *event, int manual, int state) */

/* Set the event to either HIGH (1) or LOW (0) state */
vm_status vm_event_signal(vm_event *event)
{
    vm_status umc_status = VM_NOT_INITIALIZED;

    /* check error(s) */
    if (NULL == event)
        return VM_NULL_PTR;

    if (0 <= event->state)
    {
        pthread_mutex_lock(&event->mutex);
        if (0 == event->state)
        {
            event->state = 1;
            if (event->manual)
                pthread_cond_broadcast(&event->cond);
            else
                pthread_cond_signal(&event->cond);
        }

        umc_status = VM_OK;
        pthread_mutex_unlock(&event->mutex);
    }

    return umc_status;

} /* vm_status vm_event_signal(vm_event *event) */

vm_status vm_event_reset(vm_event *event)
{
    vm_status umc_status = VM_NOT_INITIALIZED;

    /* check error(s) */
    if (NULL == event)
        return VM_NULL_PTR;

    if (0 <= event->state)
    {
        pthread_mutex_lock(&event->mutex);

        if (1 == event->state)
            event->state = 0;

        pthread_mutex_unlock(&event->mutex);
        umc_status = VM_OK;
    }

    return umc_status;

} /* vm_status vm_event_reset(vm_event *event) */

/* Pulse the event 0 -> 1 -> 0 */
vm_status vm_event_pulse(vm_event *event)
{
    vm_status umc_status = VM_NOT_INITIALIZED;

    /* check error(s) */
    if (NULL == event)
        return VM_NULL_PTR;

    if (0 <= event->state)
    {
        pthread_mutex_lock(&event->mutex);

        if (event->manual)
            pthread_cond_broadcast(&event->cond);
        else
            pthread_cond_signal(&event->cond);

        event->state = 0;
        pthread_mutex_unlock(&event->mutex);
        umc_status = VM_OK;
    }

    return umc_status;

} /* vm_status vm_event_pulse(vm_event *event) */

/* Wait for event to be high with blocking */
vm_status vm_event_wait(vm_event *event)
{
    vm_status umc_status = VM_NOT_INITIALIZED;

    /* check error(s) */
    if (NULL == event)
        return VM_NULL_PTR;

    if (0 <= event->state)
    {
        pthread_mutex_lock(&event->mutex);

        if (!event->state)
            pthread_cond_wait(&event->cond,&event->mutex);

        if (!event->manual)
            event->state = 0;

        pthread_mutex_unlock(&event->mutex);
        umc_status = VM_OK;
    }

    return umc_status;

} /* vm_status vm_event_wait(vm_event *event) */

/* Wait for event to be high without blocking, return 1 if successful */
vm_status vm_event_timed_wait(vm_event *event, unsigned int msec)
{
    vm_status umc_status = VM_NOT_INITIALIZED;

    /* check error(s) */
    if (NULL == event)
        return VM_NULL_PTR;

    if (0 <= event->state)
    {
        pthread_mutex_lock(&event->mutex);

        if (0 == event->state)
        {
            struct timeval tval;
            struct timespec tspec;
            int i_res;

            gettimeofday(&tval, NULL);
            msec = 1000 * msec + tval.tv_usec;
            tspec.tv_sec = tval.tv_sec + msec / 1000000;
            tspec.tv_nsec = (msec % 1000000) * 1000;
            i_res = pthread_cond_timedwait(&event->cond,
                                           &event->mutex,
                                           &tspec);
            if (0 == i_res)
                umc_status = VM_OK;
            else if (ETIMEDOUT == i_res)
                umc_status = VM_TIMEOUT;
            else
                umc_status = VM_OPERATION_FAILED;
        }
        else
            umc_status = VM_OK;

        if (!event->manual)
            event->state = 0;

        pthread_mutex_unlock(&event->mutex);
    }

    return umc_status;

} /* vm_status vm_event_timed_wait(vm_event *event, unsigned int msec) */

/* Destory the event */
void vm_event_destroy(vm_event *event)
{
    /* check error(s) */
    if (NULL == event)
        return;

    if (event->state >= 0)
    {
        pthread_cond_destroy(&event->cond);
        pthread_mutex_destroy(&event->mutex);
        event->state= -1;
    }

} /* void vm_event_destroy(vm_event *event) */

#endif /* LINUX32 */