Utility.hpp

Go to the documentation of this file.

/*
# Copyright (c) 2014-2016, NVIDIA CORPORATION. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#  * Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
#  * Redistributions 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.
#  * Neither the name of NVIDIA CORPORATION nor the names of its
#    contributors may be used to endorse or promote products derived
#    from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``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 COPYRIGHT OWNER 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.
*/

#ifndef NVXIO_UTILITY_HPP
#define NVXIO_UTILITY_HPP

#include <iostream>
#include <memory>
#include <sstream>
#include <stdexcept>
#include <utility>
#include <vector>
#include <string>

#ifdef __ANDROID__
#include <android/log.h>
#endif

#include <NVX/nvx.h>
#include <NVXIO/Export.hpp>

namespace nvxio
{

//
// NVXIO_LOG* macros
//

#ifdef __ANDROID__

#define NVXIO_LOGV(tag, ...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, tag, __VA_ARGS__))

#define NVXIO_LOGD(tag, ...) ((void)__android_log_print(ANDROID_LOG_DEBUG, tag, __VA_ARGS__))

#define NVXIO_LOGI(tag, ...) ((void)__android_log_print(ANDROID_LOG_INFO, tag, __VA_ARGS__))

#define NVXIO_LOGW(tag, ...) ((void)__android_log_print(ANDROID_LOG_WARN, tag, __VA_ARGS__))

#define NVXIO_LOGE(tag, ...) ((void)__android_log_print(ANDROID_LOG_ERROR, tag, __VA_ARGS__))

#endif

//
// Auxiliary macros
//

#define NVXIO_THROW_EXCEPTION(msg) \
    do { \
        std::ostringstream ostr_; \
        ostr_ << msg; \
        throw std::runtime_error(ostr_.str()); \
    } while(0)

#define NVXIO_SAFE_CALL(vxOp) \
    do \
    { \
        vx_status status = (vxOp); \
        if (status != VX_SUCCESS) \
        { \
            NVXIO_THROW_EXCEPTION(# vxOp << " failure [status = " << status << "]" << " in file " << __FILE__ << " line " << __LINE__); \
        } \
    } while (0)

#define NVXIO_ASSERT(cond) \
    do \
    { \
        if (!(cond)) \
        { \
            NVXIO_THROW_EXCEPTION(# cond << " failure in file " << __FILE__ << " line " << __LINE__); \
        } \
    } while (0)

#define NVXIO_CHECK_REFERENCE(ref) \
    NVXIO_ASSERT(ref != 0 && vxGetStatus((vx_reference)ref) == VX_SUCCESS)

#define NVXIO_CUDA_SAFE_CALL(cudaOp) \
    do \
    { \
        cudaError_t err = (cudaOp); \
        if (err != cudaSuccess) \
        { \
            std::ostringstream ostr; \
            ostr << "CUDA Error in " << # cudaOp << __FILE__ << " file " << __LINE__ << " line : " << cudaGetErrorString(err); \
            throw std::runtime_error(ostr.str()); \
        } \
    } while (0)

template <typename T, vx_size N>
vx_size dimOf(T (&)[N]) { return N; }

//
// Common constants
//

const vx_float64 PI = 3.1415926535897932;
const vx_float32 PI_F = 3.14159265f;

//
// Auxiliary functions
//

#ifdef __ANDROID__

NVXIO_EXPORT void VX_CALLBACK androidLogCallback(vx_context context, vx_reference ref, vx_status status, const vx_char string[]);
#else

NVXIO_EXPORT void VX_CALLBACK stdoutLogCallback(vx_context context, vx_reference ref, vx_status status, const vx_char string[]);
#endif

NVXIO_EXPORT void printPerf(vx_graph graph, const char* label);

NVXIO_EXPORT void printPerf(vx_node node, const char* label);

NVXIO_EXPORT void checkIfContextIsValid(vx_context context);

struct NVXIO_EXPORT ContextGuard
{
    ContextGuard() : context(vxCreateContext()) {
        checkIfContextIsValid(context);
    }
    ContextGuard(const ContextGuard &) = delete;
    ContextGuard &operator = (const ContextGuard &) = delete;
    ~ContextGuard() {
        vxReleaseContext(&context);
    }
    operator vx_context() { return context; }

private:
    vx_context context;
};

template <typename T, typename... Args>
std::unique_ptr<T> makeUP(Args &&... args)
{
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

#ifndef __ANDROID__

NVXIO_EXPORT std::vector<std::string> getSupportedFeatures();

#endif

} // namespace nvxio

#endif // NVXIO_UTILITY_HPP