buffer.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
 *
 * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
 * property and proprietary rights in and to this material, related
 * documentation and any modifications thereto. Any use, reproduction,
 * disclosure or distribution of this material and related documentation
 * without an express license agreement from NVIDIA CORPORATION or
 * its affiliates is strictly prohibited.
 */
 
#ifndef DEEPSTREAM_BUFFER_HPP
#define DEEPSTREAM_BUFFER_HPP
 
#include <vector>
#include <functional>
 
#include "object.hpp"
#include "metadata.hpp"
#include "nvbufsurface.h"
 
typedef struct _GstBuffer OpaqueBuffer;
 
namespace deepstream {
 
class Tensor;
 
class Buffer {
 public:
  typedef struct _Latency {
    unsigned int source_id;
    unsigned int frame_num;
    double latency;
  } Latency;
 
  using FreeFunction = void(*)(void*);
 
  Buffer();
 
  Buffer(size_t length, void* data=nullptr, FreeFunction=nullptr);
 
  Buffer(const std::vector<uint8_t>);
 
  Buffer(OpaqueBuffer* buffer);
 
  Buffer(const Buffer&);
 
  Buffer(Buffer&&);
 
  Buffer& operator=(const Buffer&);
 
  Buffer& operator=(Buffer&&);
 
  virtual ~Buffer();
 
  operator bool() const;
 
  size_t size() const;
 
  uint64_t timestamp() const;
 
  std::vector<Latency> measureLatency() const;
 
  virtual size_t read(std::function<size_t(const void* data, size_t len)> callable);
 
  virtual size_t write(std::function<size_t(void* data, size_t len)> callable);
 
  OpaqueBuffer* give();
 
  virtual size_t batchSize();
 
  virtual Tensor* extract(unsigned int batchId);
 
  static void wrap(Tensor* );
 
 protected:
  OpaqueBuffer* buffer_;
};
 
class VideoBuffer : public Buffer {
 public:
  // NvSurface Buffer
  VideoBuffer(size_t width, size_t height, NvBufSurfaceColorFormat video_format,
              NvBufSurfaceMemType memtype, void* mem=nullptr, int gpu_id=0);
 
  // cast from a Buffer Object
  VideoBuffer(const Buffer&);
 
  virtual size_t read(std::function<size_t(const void* data, size_t len)>);
 
  virtual size_t write(std::function<size_t(void* data, size_t len)>);
 
  BatchMetadata getBatchMetadata();
 
  size_t width() const { return width_; }
  size_t height() const { return height_; }
  const NvBufSurfaceColorFormat format() const { return format_; }
 
  VideoBuffer clone() const;
 
 protected:
   size_t width_ = 0;
   size_t height_ = 0;
   NvBufSurfaceColorFormat format_;
};
 
} // namespace deepstream
 
#endif