sources/gst-plugins/gst-nvdspreprocess/nvdspreprocess_lib/nvdspreprocess_impl.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#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,
        CustomTensorParams &tensorParam, 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