nvdspreprocess_impl.h

Go to the documentation of this file.

/*
 * Copyright (c) 2021, NVIDIA CORPORATION.  All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
 
#ifndef __NVDSPREPROCESS_IMPL_H__
#define __NVDSPREPROCESS_IMPL_H__
 
#include <stdarg.h>
#include <condition_variable>
#include <functional>
#include <list>
#include <memory>
#include <mutex>
#include <queue>
 
#include <cuda_runtime_api.h>
 
#include "nvdspreprocess_interface.h"
 
#include <stdio.h>
#include <assert.h>
 
#define _MAX_CHANNELS 4
 
#define DISABLE_CLASS_COPY(NoCopyClass)      \
  NoCopyClass(const NoCopyClass &) = delete; \
  void operator=(const NoCopyClass &) = delete
 
#define SIMPLE_MOVE_COPY(Cls) \
  Cls &operator=(Cls &&o)     \
  {                           \
    move_copy(std::move(o));  \
    return *this;             \
  }                           \
  Cls(Cls &&o) { move_copy(std::move(o)); }
 
inline const char *safeStr(const std::string &str)
{
  return str.c_str();
}
 
inline bool file_accessible(const char* path)
{
    assert(path);
    return (access(path, F_OK) != -1);
}
 
inline bool file_accessible(const std::string &path)
{
  return (!path.empty()) && file_accessible(path.c_str());
}
 
typedef struct
{
  std::string labelsFilePath;
 
  std::string meanImageFilePath;
 
  std::vector<float> offsets;
 
  float pixel_normalization_factor = 1.0;
 
  NvDsPreProcessNetworkSize networkSize;
} CustomMeanSubandNormParams;
 
class CudaStream
{
public:
    explicit CudaStream(uint flag = cudaStreamDefault, int priority = 0);
    ~CudaStream();
    operator cudaStream_t() { return m_Stream; }
    cudaStream_t& ptr() { return m_Stream; }
    SIMPLE_MOVE_COPY(CudaStream)
 
private:
    void move_copy(CudaStream&& o)
    {
        m_Stream = o.m_Stream;
        o.m_Stream = nullptr;
    }
    DISABLE_CLASS_COPY(CudaStream);
 
    cudaStream_t m_Stream = nullptr;
};
 
class CudaBuffer
{
public:
    virtual ~CudaBuffer() = default;
    size_t bytes() const { return m_Size; }
    template <typename T>
    T* ptr()
    {
        return (T*)m_Buf;
    }
    void* ptr() { return m_Buf; }
    SIMPLE_MOVE_COPY(CudaBuffer)
 
protected:
    explicit CudaBuffer(size_t s) : m_Size(s) {}
    void move_copy(CudaBuffer&& o)
    {
        m_Buf = o.m_Buf;
        o.m_Buf = nullptr;
        m_Size = o.m_Size;
        o.m_Size = 0;
    }
    DISABLE_CLASS_COPY(CudaBuffer);
    void* m_Buf = nullptr;
    size_t m_Size = 0;
};
 
class CudaDeviceBuffer : public CudaBuffer
{
public:
    explicit CudaDeviceBuffer(size_t size);
    ~CudaDeviceBuffer();
};
 
class NvDsPreProcessTensorImpl
{
public:
    NvDsPreProcessTensorImpl(const NvDsPreProcessNetworkSize& size, NvDsPreProcessFormat format,
        int id = 0);
    virtual ~NvDsPreProcessTensorImpl() = default;
 
    bool setScaleOffsets(float scale, const std::vector<float>& offsets = {});
    bool setMeanFile(const std::string& file);
    bool setInputOrder(const NvDsPreProcessNetworkInputOrder order);
    NvDsPreProcessStatus allocateResource();
    NvDsPreProcessStatus syncStream();
    NvDsPreProcessStatus prepare_tensor(NvDsPreProcessBatch* batch,
        void*& devBuf);
 
private:
    NvDsPreProcessStatus readMeanImageFile();
    DISABLE_CLASS_COPY(NvDsPreProcessTensorImpl);
 
private:
    int m_UniqueID = 0;
 
    /* Network input information. */
    NvDsPreProcessNetworkSize m_NetworkSize = {0};
    NvDsPreProcessFormat m_NetworkInputFormat = NvDsPreProcessFormat_RGB;
    NvDsPreProcessNetworkInputOrder m_InputOrder = NvDsPreProcessNetworkInputOrder_kNCHW;
 
    float m_Scale = 1.0f;
    std::vector<float> m_ChannelMeans; // same as channels
    std::string m_MeanFile;
 
    std::unique_ptr<CudaStream> m_PreProcessStream;
    std::unique_ptr<CudaDeviceBuffer> m_MeanDataBuffer;
};
 
extern "C"
NvDsPreProcessStatus
normalization_mean_subtraction_impl_initialize (CustomMeanSubandNormParams *custom_params,
    NvDsPreProcessTensorParams *tensor_params,
    std::unique_ptr<NvDsPreProcessTensorImpl> & m_Preprocessor, int unique_id);
 
#endif