NvV4l2ElementPlane.h

Go to the documentation of this file.

/*
 * 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.
 */
 
#ifndef __NV_V4L2_ELELMENT_PLANE_H__
#define __NV_V4L2_ELELMENT_PLANE_H__
 
#include <pthread.h>
#include "NvElement.h"
#include "NvLogging.h"
#include "NvBuffer.h"
 
#define PLANE_DEBUG_MSG(str) COMP_DEBUG_MSG(plane_name << ":" << str);
 
#define PLANE_INFO_MSG(str) COMP_INFO_MSG(plane_name << ":" << str);
 
#define PLANE_WARN_MSG(str) COMP_WARN_MSG(plane_name << ":" << str);
 
#define PLANE_ERROR_MSG(str) COMP_ERROR_MSG(plane_name << ":" << str);
 
#define PLANE_SYS_ERROR_MSG(str) COMP_SYS_ERROR_MSG(plane_name << ":" << str);
 
class NvV4l2ElementPlane
{
 
public:
    int getFormat(struct v4l2_format & format);
    int setFormat(struct v4l2_format & format);
 
    int mapOutputBuffers(struct v4l2_buffer &v4l2_buf, int dmabuff_fd);
 
    int unmapOutputBuffers(int index, int dmabuff_fd);
 
    int getCrop(struct v4l2_crop & crop);
 
    int setSelection(uint32_t target, uint32_t flags, struct v4l2_rect & rect);
 
    int reqbufs(enum v4l2_memory mem_type, uint32_t num);
    int queryBuffer(uint32_t buf_index);
    int exportBuffer(uint32_t buf_index);
 
    int setStreamStatus(bool status);
 
    bool getStreamStatus();
 
    int setStreamParms(struct v4l2_streamparm & parm);
 
    int setupPlane(enum v4l2_memory mem_type, uint32_t num_buffers, bool map, bool allocate);
    void deinitPlane();
 
    inline enum v4l2_buf_type getBufType()
    {
        return buf_type;
    }
 
    NvBuffer *getNthBuffer(uint32_t n);
 
    int dqBuffer(struct v4l2_buffer &v4l2_buf, NvBuffer ** buffer,
                 NvBuffer ** shared_buffer, uint32_t num_retries);
    int qBuffer(struct v4l2_buffer &v4l2_buf, NvBuffer * shared_buffer);
 
    inline uint32_t getNumBuffers()
    {
        return num_buffers;
    }
 
    inline uint32_t getNumPlanes()
    {
        return n_planes;
    }
 
    void setBufferPlaneFormat(int n_planes, NvBuffer::NvBufferPlaneFormat * planefmts);
 
    inline uint32_t getNumQueuedBuffers()
    {
        return num_queued_buffers;
    }
 
    inline uint32_t getTotalDequeuedBuffers()
    {
        return total_dequeued_buffers;
    }
 
    inline uint32_t getTotalQueuedBuffers()
    {
        return total_queued_buffers;
    }
 
    int waitAllBuffersQueued(uint32_t max_wait_ms);
    int waitAllBuffersDequeued(uint32_t max_wait_ms);
 
    typedef bool(*dqThreadCallback) (struct v4l2_buffer * v4l2_buf,
            NvBuffer * buffer, NvBuffer * shared_buffer,
            void *data);
 
    bool setDQThreadCallback(dqThreadCallback callback);
    int startDQThread(void *data);
    int stopDQThread();
    int waitForDQThread(uint32_t max_wait_ms);
 
    pthread_mutex_t plane_lock; 
    pthread_cond_t plane_cond; 
private:
    int &fd;     
    const char *plane_name; 
    enum v4l2_buf_type buf_type; 
    bool blocking;  
    uint32_t num_buffers;   
    NvBuffer **buffers;     
    uint8_t n_planes;       
    NvBuffer::NvBufferPlaneFormat planefmts[MAX_PLANES];
    enum v4l2_memory memory_type; 
    uint32_t num_queued_buffers;  
    uint32_t total_queued_buffers;  
    uint32_t total_dequeued_buffers;  
    bool streamon;  
    bool dqthread_running;  
    bool stop_dqthread; 
    pthread_t dq_thread; 
    dqThreadCallback callback; 
    void *dqThread_data;    
    static void *dqThread(void *v4l2_element_plane);
 
    NvElementProfiler &v4l2elem_profiler; 
    inline int isInError()
    {
        return is_in_error;
    }
 
    NvV4l2ElementPlane(enum v4l2_buf_type buf_type, const char *device_name,
                     int &fd, bool blocking, NvElementProfiler &profiler);
 
    NvV4l2ElementPlane(const NvV4l2ElementPlane& that);
    void operator=(NvV4l2ElementPlane const&);
 
     ~NvV4l2ElementPlane();
 
    int is_in_error;        
    const char *comp_name;  
    friend class NvV4l2Element;
};
#endif