H264DecoderV4L2Helper.h

#pragma once
/*
 * Copyright (c) 2019, 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.
 */
#define DECODER_DEV "/dev/nvhost-nvdec"
#define MAX_BUFFERS 32
#define CHUNK_SIZE 4000000
#define MAX_PLANES 3
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#include "Frame.h"
#include <fstream>
#include <linux/videodev2.h>
#include <queue>

class Buffer
{
public:
    typedef struct
    {
        uint32_t width;  
        uint32_t height; 
 
        uint32_t bytesperpixel; 
        uint32_t stride;        
        uint32_t sizeimage;     
    } BufferPlaneFormat;

    typedef struct
    {
        BufferPlaneFormat fmt; 
 
        unsigned char *data; 
        uint32_t bytesused;  
 
        int fd;              
        uint32_t mem_offset; 
        uint32_t length;     
    } BufferPlane;
 
    Buffer() {}
 
    Buffer(enum v4l2_buf_type buf_type, enum v4l2_memory memory_type,
           uint32_t index);
 
    Buffer(enum v4l2_buf_type buf_type, enum v4l2_memory memory_type,
           uint32_t n_planes, BufferPlaneFormat *fmt, uint32_t index);
 
    ~Buffer();

    int map();
    void unmap();
 
    enum v4l2_buf_type buf_type;  
    enum v4l2_memory memory_type; 
 
    uint32_t index; 
 
    uint32_t n_planes;              
    BufferPlane planes[MAX_PLANES]; 

    int fill_buffer_plane_format(uint32_t *num_planes,
                                 Buffer::BufferPlaneFormat *planefmts,
                                 uint32_t width, uint32_t height, uint32_t raw_pixfmt);
 
private:
    bool mapped;
};
 
class h264DecoderV4L2Helper
{
public:
    h264DecoderV4L2Helper() {}
    ~h264DecoderV4L2Helper() {};
    typedef struct
    {
        uint32_t decode_pixfmt;
        uint32_t out_pixfmt;
        uint32_t display_width;
        uint32_t display_height;
        enum v4l2_memory op_mem_type;
        enum v4l2_memory cp_mem_type;
        enum v4l2_buf_type op_buf_type;
        enum v4l2_buf_type cp_buf_type;
        Buffer::BufferPlaneFormat op_planefmts[MAX_PLANES];
        Buffer::BufferPlaneFormat cp_planefmts[MAX_PLANES];
        uint32_t cp_num_planes;
        uint32_t op_num_planes;
        uint32_t cp_num_buffers;
        uint32_t op_num_buffers;
 
        uint32_t num_queued_op_buffers;
 
        Buffer **op_buffers;
        Buffer **cp_buffers;
 
        pthread_mutex_t queue_lock;
        pthread_cond_t queue_cond;
        pthread_t dec_capture_thread;
 
        bool in_error = false;
        bool eos;
        bool got_eos;
        bool op_streamon;
        bool cp_streamon;
        int fd;
        int dst_dma_fd;
        int dmabuff_fd[MAX_BUFFERS];
    } context_t;

    void read_input_chunk_frame_sp(void* inputFrameBuffer, size_t inputFrameSize, Buffer *buffer);

    int sendFrames(int dmaOutFrameFd, frame_sp outFrame);

    int set_capture_plane_format(context_t *ctx, uint32_t pixfmt,
                                 uint32_t width, uint32_t height);

    void query_set_capture(context_t *ctx);

 
    // static void* capture_wrapper(void* object);
 
    static void *capture_thread(void *arg);

    bool decode_process(context_t &ctx, void* inputFrameBuffer, size_t inputFrameSize);

    int dq_event(context_t *ctx, struct v4l2_event &event, uint32_t max_wait_ms);

    int dq_buffer(context_t *ctx, struct v4l2_buffer &v4l2_buf, Buffer **buffer,
                  enum v4l2_buf_type buf_type, enum v4l2_memory memory_type, uint32_t num_retries);

    int q_buffer(context_t *ctx, struct v4l2_buffer &v4l2_buf, Buffer *buffer,
                 enum v4l2_buf_type buf_type, enum v4l2_memory memory_type, int num_planes);

    int req_buffers_on_capture_plane(context_t *ctx, enum v4l2_buf_type buf_type,
                                     enum v4l2_memory mem_type, int num_buffers);

    int req_buffers_on_output_plane(context_t *ctx, enum v4l2_buf_type buf_type,
                                    enum v4l2_memory mem_type, int num_buffers);

    int set_output_plane_format(context_t &ctx, uint32_t pixfmt, uint32_t sizeimage);

    int set_ext_controls(int fd, uint32_t id, uint32_t value);

    int subscribe_event(int fd, uint32_t type, uint32_t id, uint32_t flags);
 
    int process(void* inputFrameBuffer, size_t inputFrameSize, uint64_t inputFrameTS);
 
    bool init(std::function<void(frame_sp &)> send, std::function<frame_sp()> makeFrame);
 
    bool initializeDecoder();
 
    void closeAllThreads(frame_sp eosFrame);
 
    void deQueAllBuffers();
protected:
    boost::shared_ptr<Buffer> mBuffer;
    context_t ctx;
    std::function<frame_sp()> makeFrame;
    std::function<void(frame_sp &)> send;
    int ret = 0;
    std::queue<uint64_t> framesTimestampEntry;
    std::mutex m;
};