service-maker/includes/buffer.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2024-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 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&&) noexcept;
 
  Buffer& operator=(const Buffer&);
 
  Buffer& operator=(Buffer&&) noexcept;
 
  virtual ~Buffer();
 
  operator bool() const;
 
  size_t size() const;
 
  uint64_t timestamp() const;
 
  int32_t chunkId(unsigned int batchId) 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();
 
  BatchMetadata getBatchMetadata();
 
  virtual Tensor* extract(unsigned int batchId);
 
  static void wrap(Tensor* );
 
 protected:
  OpaqueBuffer* buffer_;
  std::vector<int> chunk_ids_ = { 0 };
};
 
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_;
};
 
typedef struct _NvDsSourceMeta
{
  int chunk_id;
} NvDsSourceMeta;
 
} // namespace deepstream
 
#endif