v4l2m2mcodec.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_V4L2
#include <cstdint>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/error.h>
#include <promeki/result.h>
#include <promeki/list.h>
#include <promeki/buffer.h>
#include <promeki/size2d.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class V4l2M2mCodec {
        public:
                enum class Role {
                        Encoder, 
                        Decoder, 
                };
 
                enum class Memory {
                        Mmap,   
                        Dmabuf, 
                };
 
                struct OpenParams {
                                Role role = Role::Encoder; 
                                String    devPath;
                                uint32_t  outputFourcc = 0;  
                                uint32_t  captureFourcc = 0; 
                                Size2Du32 size;              
                                uint32_t  outputBufferCount = 6;  
                                uint32_t  captureBufferCount = 6; 
                                Memory    outputMemory = Memory::Mmap;
                                Memory    captureMemory = Memory::Mmap; 
                                uint32_t codedBufferSize = 0;
 
                                // Colorimetry applied to the raw queue's format
                                // (the encoder's OUTPUT) so the codec writes a
                                // matching VUI into the bitstream.  Zero =
                                // DEFAULT (leave to the driver).  See
                                // @ref v4l2ColorimetryFromH273.
                                uint32_t colorspace = 0;   
                                uint32_t ycbcrEnc = 0;     
                                uint32_t xferFunc = 0;     
                                uint32_t quantization = 0; 
                };
 
                struct OutPlane {
                                uint8_t *data = nullptr;   
                                size_t   capacity = 0;     
                                size_t   stride = 0;       
                };
 
                struct CapturePlane {
                                const uint8_t *data = nullptr; 
                                size_t         size = 0;       
                                size_t         stride = 0;     
                };
 
                V4l2M2mCodec();
                ~V4l2M2mCodec();
                V4l2M2mCodec(const V4l2M2mCodec &) = delete;
                V4l2M2mCodec &operator=(const V4l2M2mCodec &) = delete;
 
                static String findDevice(Role role, uint32_t outputFourcc, uint32_t captureFourcc);
 
                Error open(const OpenParams &params);
 
                void close();
 
                bool isOpen() const { return _fd >= 0; }
 
                int fd() const { return _fd; }
 
                const String &devPath() const { return _devPath; }
 
                const String &driverName() const { return _driver; }
 
                uint32_t negotiatedWidth() const { return _width; }
                uint32_t negotiatedHeight() const { return _height; } 
 
                uint32_t outputPlaneCount() const { return _outPlaneCount; }
 
                uint32_t outputStride(uint32_t plane) const;
 
                uint32_t negotiatedColorspace() const { return _colorspace; }
                uint32_t negotiatedYcbcrEnc() const { return _ycbcrEnc; }       
                uint32_t negotiatedXferFunc() const { return _xferFunc; }       
                uint32_t negotiatedQuantization() const { return _quantization; } 
 
                Error setControl(uint32_t id, int32_t value, bool optional = true);
 
                Error setControlCompound(uint32_t id, void *payload, uint32_t size, bool optional = true);
 
                Error start();
 
                Error stop();
 
                // ---- Staged decoder init (Role::Decoder) ----
                //
                // A stateful decoder is brought up in two phases: feed coded
                // data on the OUTPUT queue, wait for the driver to parse the
                // stream geometry (a SOURCE_CHANGE event), then configure and
                // stream the CAPTURE (raw) queue.
 
                Error startOutput();
 
                Error dequeueEvent(bool &sourceChange, bool &eos);
 
                Error setupCapture();
 
                bool captureConfigured() const { return _captureConfigured; }
 
                uint32_t captureWidth() const { return _capWidth; }
                uint32_t captureHeight() const { return _capHeight; }     
                uint32_t captureFourcc() const { return _capFourcc; }     
                uint32_t capturePlaneCount() const { return _capPlaneCount; } 
                uint32_t captureStride(uint32_t plane) const;
 
                Error dequeueRawFrame(List<CapturePlane> &planes, int &index, int64_t &ptsUsec,
                                      bool &endOfStream);
 
                Error requeueRawFrame(int index);
 
                Error acquireOutput(int &index, List<OutPlane> &planes);
 
                Error submitOutput(int index, const List<size_t> &bytesused, int64_t ptsUsec);
 
                Error queueOutputDmabuf(int fd, size_t bytesused, int64_t ptsUsec, bool &queued);
 
                Result<int> exportBuffer(bool capture, int index);
 
                Error dequeueCapture(Buffer &out, int64_t &ptsUsec, bool &keyframe, bool &endOfStream);
 
                Error poll(bool &outputWritable, bool &captureReadable, int timeoutMs);
 
                Error pollEvents(bool &outputWritable, bool &captureReadable, bool &eventPending, int timeoutMs);
 
                Error sendStop();
 
        private:
                struct MappedPlane {
                                void  *start = nullptr;
                                size_t length = 0;
                };
                struct MappedBuffer {
                                List<MappedPlane> planes;
                                bool              queued = false;
                };
 
                Error negotiateFormats(const OpenParams &p);
                Error allocQueue(uint32_t type, uint32_t memory, uint32_t count, List<MappedBuffer> &pool,
                                 uint32_t &planeCount);
                void  unmapQueue(List<MappedBuffer> &pool);
                Error queueAllCapture();
                void  reclaimOutput();
                Error subscribeEvents();
 
                int    _fd = -1;
                String _devPath;
                String _driver;
                Role   _role = Role::Encoder;
 
                // True for the multiplanar API (V4L2_CAP_VIDEO_M2M_MPLANE — the
                // Xilinx VCU and Raspberry Pi); false for single-planar
                // (V4L2_CAP_VIDEO_M2M — the kernel vicodec test driver and many
                // simpler codecs).  Selects the buffer types and the
                // v4l2_format / v4l2_buffer layout used throughout.
                bool _mplane = true;
 
                uint32_t _outputType = 0;  // V4L2_BUF_TYPE_VIDEO_OUTPUT[_MPLANE]
                uint32_t _captureType = 0; // V4L2_BUF_TYPE_VIDEO_CAPTURE[_MPLANE]
 
                uint32_t _outputMemory = 0;  // V4L2_MEMORY_MMAP | V4L2_MEMORY_DMABUF
                uint32_t _captureMemory = 0; // V4L2_MEMORY_MMAP | V4L2_MEMORY_DMABUF
 
                // Requested pool depths (OpenParams::outputBufferCount /
                // captureBufferCount); the driver may round these up.
                uint32_t _outputBufferCount = 6;
                uint32_t _captureBufferCount = 6;
 
                uint32_t _width = 0;
                uint32_t _height = 0;
                uint32_t _outPlaneCount = 1;
                uint32_t _capPlaneCount = 1;
                uint32_t _outStride[4] = {0, 0, 0, 0};
 
                // Negotiated CAPTURE (raw) geometry — filled by setupCapture on
                // the decoder path.
                uint32_t _capWidth = 0;
                uint32_t _capHeight = 0;
                uint32_t _capFourcc = 0;
                uint32_t _capStride[4] = {0, 0, 0, 0};
                uint32_t _rawFourccWanted = 0; // Desired CAPTURE raw FourCC (OpenParams::captureFourcc).
 
                // Colorimetry negotiated on the raw queue (encoder OUTPUT).
                uint32_t _colorspace = 0;
                uint32_t _ycbcrEnc = 0;
                uint32_t _xferFunc = 0;
                uint32_t _quantization = 0;
 
                List<MappedBuffer> _outputPool;
                List<MappedBuffer> _capturePool;
 
                bool _streaming = false;          // OUTPUT queue streaming.
                bool _captureConfigured = false;  // CAPTURE queue set up + streaming (decoder).
                bool _captureDrained = false;     // LAST buffer seen.
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_V4L2