294 lines
11 KiB
C++
294 lines
11 KiB
C++
/*
|
|
* Copyright (c) 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.
|
|
*/
|
|
|
|
/**
|
|
* @file
|
|
* <b>NVIDIA Multimedia API: Buffer API</b>
|
|
*
|
|
* @b Description: This file declares the NvBuffer APIs.
|
|
*/
|
|
|
|
#ifndef __NV_BUFFER_H__
|
|
#define __NV_BUFFER_H__
|
|
|
|
#include <linux/videodev2.h>
|
|
#include <pthread.h>
|
|
#include <stdint.h>
|
|
|
|
#include "v4l2_nv_extensions.h"
|
|
|
|
/**
|
|
*
|
|
* @defgroup l4t_mm_nvbuffer_group Buffer API
|
|
*
|
|
* The @c %NvBuffer API provides buffer functionality, including reference
|
|
* count functionality and convenience methods.
|
|
* @ingroup aa_framework_api_group
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* Specifies the maximum number of planes a buffer can contain.
|
|
*/
|
|
#define MAX_PLANES 3
|
|
|
|
/**
|
|
* @brief Class representing a buffer.
|
|
*
|
|
* The NvBuffer class is modeled on the basis of the @c v4l2_buffer
|
|
* structure. The buffer has @c buf_type @c v4l2_buf_type, @c
|
|
* memory_type @c v4l2_memory, and an index. It contains an
|
|
* NvBufferPlane array similar to the array of @c v4l2_plane
|
|
* structures in @c v4l2_buffer.m.planes. It also contains a
|
|
* corresponding NvBufferPlaneFormat array that describes the
|
|
* format of each of the planes.
|
|
*
|
|
* Even though @c %NvBuffer closely resembles v4l2 structures, it can
|
|
* be easily used with other non-v4l2 components. @c %NvBuffer
|
|
* contains data pointers, buffer length, file descriptor (FD) of
|
|
* buffer planes, buffer format (height, width, stride, etc.), and
|
|
* other members that are required by such components.
|
|
*
|
|
* This class also provides buffer reference count functionality. This
|
|
* is useful when the same buffer is being used by multiple elements.
|
|
*
|
|
* In the case of a V4L2 MMAP, this class provides convenience methods
|
|
* for mapping or unmapping the contents of the buffer to or from
|
|
* memory, allocating or deallocating software memory depending on its
|
|
* format.
|
|
*/
|
|
class NvBuffer
|
|
{
|
|
public:
|
|
/**
|
|
* Holds the buffer plane format.
|
|
*/
|
|
typedef struct
|
|
{
|
|
uint32_t width; /**< Holds the width of the plane in pixels. */
|
|
uint32_t height; /**< Holds the height of the plane in pixels. */
|
|
|
|
uint32_t bytesperpixel; /**< Holds the bytes used to represent one
|
|
pixel in the plane. */
|
|
uint32_t stride; /**< Holds the stride of the plane in bytes. */
|
|
uint32_t sizeimage; /**< Holds the size of the plane in bytes. */
|
|
} NvBufferPlaneFormat;
|
|
|
|
/**
|
|
* Holds the buffer plane parameters.
|
|
*/
|
|
typedef struct
|
|
{
|
|
NvBufferPlaneFormat fmt; /**< Holds the format of the plane. */
|
|
|
|
unsigned char *data; /**< Holds a pointer to the plane memory. */
|
|
uint32_t bytesused; /**< Holds the number of valid bytes in the plane. */
|
|
|
|
int fd; /**< Holds the file descriptor (FD) of the plane of the
|
|
exported buffer, in the case of V4L2 MMAP buffers. */
|
|
uint32_t mem_offset; /**< Holds the offset of the first valid byte
|
|
from the data pointer. */
|
|
uint32_t length; /**< Holds the size of the buffer in bytes. */
|
|
} NvBufferPlane;
|
|
|
|
/**
|
|
* Creates a new NvBuffer object.
|
|
*
|
|
* This convenience method for V4L2 elements creates a new buffer
|
|
* with the planes array memset to zero and the refcount
|
|
* initialized to zero.
|
|
*
|
|
|
|
* @param[in] buf_type Type of buffer, enumerated as @c
|
|
* v4l2_buf_type.
|
|
* @param[in] memory_type @c %NvBuffer memory, enumerated as an
|
|
* @c v4l2_memory enum.
|
|
* @param[in] n_planes Number of planes in the buffer.
|
|
* @param[in] fmt Specifies a pointer to the array of buffer plane formats.
|
|
* Should contain at least @a n_planes elements.
|
|
* @param[in] index Index of the buffer in the plane.
|
|
*/
|
|
NvBuffer(enum v4l2_buf_type buf_type, enum v4l2_memory memory_type,
|
|
uint32_t n_planes, NvBufferPlaneFormat *fmt, uint32_t index);
|
|
|
|
/**
|
|
* Creates a new NvBuffer for raw pixel formats.
|
|
*
|
|
* This convenience method for V4L2 elements is an @c %NvBuffer
|
|
* constructor for raw pixel formats only. It requires width,
|
|
* height, and pixel format to be specified.
|
|
*
|
|
* The planes array is memset to zero and the refcount is
|
|
* initialized to zero.
|
|
*
|
|
* @attention The memory must be allocated by the application
|
|
* by calling NvBuffer::allocateMemory.
|
|
*
|
|
* @param[in] pixfmt Pixel format of the buffer.
|
|
* @param[in] width Width of the buffer in pixels.
|
|
* @param[in] height Height of the buffer in pixels.
|
|
* @param[in] index Index/ID of the buffer.
|
|
*/
|
|
NvBuffer(uint32_t pixfmt, uint32_t width, uint32_t height, uint32_t index);
|
|
|
|
/**
|
|
* Creates a new NvBuffer object for non-raw pixel formats.
|
|
*
|
|
* This convenience method for V4L2 elements is an @c %NvBuffer
|
|
* constructor for non raw pixel formats. It requires size of the
|
|
* buffer to be supplied.
|
|
*
|
|
* The planes array is memset to zero and refcount initialized to
|
|
* zero.
|
|
*
|
|
* @attention The memory needs to be allocated by the application
|
|
* by calling NvBuffer::allocateMemory.
|
|
*
|
|
* @param[in] size Size of the buffer in bytes.
|
|
* @param[in] index Index/ID of the buffer.
|
|
*/
|
|
NvBuffer(uint32_t size, uint32_t index);
|
|
|
|
/**
|
|
* Destroys an NvBuffer object.
|
|
*
|
|
* This method cleans up class instances, unmapping any mapped
|
|
* planes.
|
|
*/
|
|
~NvBuffer();
|
|
|
|
/**
|
|
* Maps the contents of the buffer to memory.
|
|
*
|
|
* This method maps the file descriptor (FD) of the planes to
|
|
* a data pointer of @c planes. (MMAP buffers only.)
|
|
*
|
|
* @return 0 on success, -1 otherwise.
|
|
*/
|
|
int map();
|
|
/**
|
|
* Unmaps the contents of the buffer from memory. (MMAP buffers only.)
|
|
*
|
|
*/
|
|
void unmap();
|
|
|
|
/**
|
|
* Allocates software memory for the buffer.
|
|
*
|
|
* @warning This method works only for @c V4L2_MEMORY_USERPTR memory.
|
|
*
|
|
* This method allocates memory on the basis of the buffer format:
|
|
* @a height, @a width, @a bytesperpixel, and @a sizeimage.
|
|
*
|
|
* @return 0 for success, -1 otherwise.
|
|
*/
|
|
int allocateMemory();
|
|
/**
|
|
* Deallocates buffer memory.
|
|
*
|
|
* @warning This method works only for @c V4L2_MEMORY_USERPTR memory and if
|
|
* the memory was previously allocated using NvBuffer::allocateMemory.
|
|
*/
|
|
void deallocateMemory();
|
|
|
|
/**
|
|
* Increases the reference count of the buffer.
|
|
*
|
|
* This method is thread safe.
|
|
*
|
|
* @return Reference count of the buffer after the operation.
|
|
*/
|
|
int ref();
|
|
/**
|
|
* Decreases the reference count of the buffer.
|
|
*
|
|
* This thread-safe method decreases the buffer reference count if the
|
|
* buffer reference count is above 0.
|
|
*
|
|
* @return Reference count of the buffer after the operation.
|
|
*/
|
|
int unref();
|
|
|
|
const enum v4l2_buf_type buf_type; /**< Type of the buffer. */
|
|
const enum v4l2_memory memory_type; /**< Type of memory associated
|
|
with the buffer. */
|
|
|
|
const uint32_t index; /**< Holds the buffer index. */
|
|
|
|
uint32_t n_planes; /**< Holds the number of planes in the buffer. */
|
|
NvBufferPlane planes[MAX_PLANES]; /**< Holds the data pointer, plane file
|
|
descriptor (FD), plane format, etc. */
|
|
|
|
/**
|
|
* Fills the NvBuffer::NvBufferPlaneFormat array.
|
|
*
|
|
* This convenience method populates the
|
|
* @c %NvBuffer::NvBufferPlaneFormat array on the basis of @a width,
|
|
* @a height and pixel format (@a raw_pixfmt). It also returns the number of planes
|
|
* required for the pixel format in @a num_planes.
|
|
*
|
|
*
|
|
* @param[out] num_planes The number of planes. Must not be NULL.
|
|
* @param[in,out] planefmts Array of %NvBuffer::NvBufferPlaneFormat to
|
|
* fill. Must be at least \a num_planes in length. For best
|
|
* results, pass an array of length #MAX_PLANES.
|
|
* @param[in] width Width of the buffer in pixels.
|
|
* @param[in] height Height of the buffer in pixels.
|
|
* @param[in] raw_pixfmt Raw V4L2 pixel formats.
|
|
* @return 0 for success, -1 for an unsupported pixel format.
|
|
*/
|
|
static int fill_buffer_plane_format(uint32_t *num_planes,
|
|
NvBuffer::NvBufferPlaneFormat *planefmts,
|
|
uint32_t width, uint32_t height, uint32_t raw_pixfmt);
|
|
private:
|
|
uint32_t ref_count; /**< Holds the reference count of the buffer. */
|
|
pthread_mutex_t ref_lock; /**< Mutex to synchronize increment/
|
|
decrement operations of @c ref_count. */
|
|
|
|
bool mapped; /**< Indicates if the buffer is mapped to
|
|
memory. */
|
|
bool allocated; /**< Indicates if the buffer is allocated
|
|
memory. */
|
|
NvBuffer *shared_buffer; /**< If this is a DMABUF buffer, @c shared_buffer
|
|
points to the MMAP @c NvBuffer whose FD was
|
|
sent when this buffer was queued. */
|
|
|
|
/**
|
|
* Disallows copy constructor.
|
|
*/
|
|
NvBuffer(const NvBuffer& that);
|
|
/**
|
|
* Disallows assignment.
|
|
*/
|
|
void operator=(NvBuffer const&);
|
|
|
|
friend class NvV4l2ElementPlane;
|
|
};
|
|
/** @} */
|
|
#endif
|