| /* |
| * Copyright (C) 2014 The Android Open Source Project |
| * Copyright@ Samsung Electronics Co. LTD |
| * |
| * 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. |
| */ |
| |
| /*! |
| * \file libscaler-v4l2.h |
| * \brief source file for Scaler HAL |
| * \author Cho KyongHo <pullip.cho@samsung.com> |
| * \date 2014/05/12 |
| * |
| * <b>Revision History: </b> |
| * - 2014.05.12 : Cho KyongHo (pullip.cho@samsung.com) \n |
| * Create |
| */ |
| #ifndef _LIBSCALER_V4L2_H_ |
| #define _LIBSCALER_V4L2_H_ |
| |
| #include <fcntl.h> |
| |
| #include <exynos_scaler.h> |
| |
| #include "libscaler-common.h" |
| |
| #define V4L2_CID_EXYNOS_BASE (V4L2_CTRL_CLASS_USER | 0x2000) |
| #define V4L2_CID_CSC_EQ_MODE (V4L2_CID_EXYNOS_BASE + 100) |
| #define V4L2_CID_CSC_EQ (V4L2_CID_EXYNOS_BASE + 101) |
| #define V4L2_CID_CSC_RANGE (V4L2_CID_EXYNOS_BASE + 102) |
| #define V4L2_CID_CONTENT_PROTECTION (V4L2_CID_EXYNOS_BASE + 201) |
| |
| #define V4L2_PIX_FMT_NV12N v4l2_fourcc('N', 'N', '1', '2') |
| #define V4L2_PIX_FMT_NV12NT v4l2_fourcc('T', 'N', '1', '2') |
| #define V4L2_PIX_FMT_YUV420N v4l2_fourcc('Y', 'N', '1', '2') |
| #define V4L2_PIX_FMT_NV12N_10B v4l2_fourcc('B', 'N', '1', '2') |
| |
| #define V4L2_BUF_FLAG_USE_SYNC 0x00008000 |
| |
| class CScalerV4L2 { |
| public: |
| enum { SC_MAX_PLANES = SC_NUM_OF_PLANES }; |
| enum { SC_MAX_NODENAME = 14 }; |
| enum { SC_V4L2_FMT_PREMULTI_FLAG = 10 }; |
| |
| enum SC_FRAME_FLAG { |
| // frame status |
| SCFF_BUF_FRESH = 0, |
| // h/w setting |
| SCFF_CACHEABLE, |
| SCFF_PREMULTIPLIED, |
| // v4l2 status |
| SCFF_REQBUFS, |
| SCFF_QBUF, |
| SCFF_STREAMING, |
| }; |
| |
| enum SC_FLAG { |
| SCF_RESERVED = 0, |
| // session status |
| SCF_ROTATION_FRESH, |
| SCF_CSC_FRESH, |
| SCF_DRM_FRESH, |
| // h/w setting setting |
| SCF_HFLIP, |
| SCF_VFLIP, |
| SCF_DRM, |
| SCF_ALLOW_DRM, |
| SCF_CSC_WIDE, |
| SCF_SRC_BLEND, |
| SCF_FRAMERATE, |
| }; |
| |
| struct FrameInfo { |
| const char *name; |
| v4l2_buf_type type; |
| unsigned int width, height; |
| v4l2_rect crop; |
| unsigned int color_format; |
| void *addr[SC_MAX_PLANES]; |
| int fdAcquireFence; |
| enum v4l2_memory memory; |
| int out_num_planes; |
| unsigned long out_plane_size[SC_MAX_PLANES]; |
| unsigned long flags; // enum SC_FRAME_FLAG |
| }; |
| |
| private: |
| FrameInfo m_frmSrc; |
| FrameInfo m_frmDst; |
| |
| unsigned int m_nRotDegree; |
| unsigned int m_frameRate; |
| char m_cszNode[SC_MAX_NODENAME]; // /dev/videoXX |
| int m_iInstance; |
| |
| int m_fdValidate; |
| |
| unsigned int m_filter; |
| unsigned int m_colorspace; |
| |
| void Initialize(int instance); |
| bool ResetDevice(FrameInfo &frm); |
| |
| inline void SetRotDegree(int rot) { |
| rot = rot % 360; |
| if (rot < 0) |
| rot = 360 + rot; |
| |
| m_nRotDegree = rot; |
| SetFlag(m_fStatus, SCF_ROTATION_FRESH); |
| } |
| |
| bool DevSetFormat(FrameInfo &frm); |
| bool ReqBufs(FrameInfo &frm); |
| bool QBuf(FrameInfo &frm, int *pfdReleaseFence); |
| bool StreamOn(FrameInfo &frm); |
| bool DQBuf(FrameInfo &frm); |
| |
| inline bool SetFormat(FrameInfo &frm, unsigned int width, unsigned int height, |
| unsigned int v4l2_colorformat) { |
| frm.color_format = v4l2_colorformat; |
| frm.width = width; |
| frm.height = height; |
| SetFlag(frm.flags, SCFF_BUF_FRESH); |
| return true; |
| } |
| |
| inline bool SetCrop(FrameInfo &frm, unsigned int left, unsigned int top, |
| unsigned int width, unsigned int height) { |
| frm.crop.left = left; |
| frm.crop.top = top; |
| frm.crop.width = width; |
| frm.crop.height = height; |
| SetFlag(frm.flags, SCFF_BUF_FRESH); |
| return true; |
| } |
| |
| inline void SetPremultiplied(FrameInfo &frm, unsigned int premultiplied) { |
| if (premultiplied) |
| SetFlag(frm.flags, SCFF_PREMULTIPLIED); |
| else |
| ClearFlag(frm.flags, SCFF_PREMULTIPLIED); |
| } |
| |
| inline void SetCacheable(FrameInfo &frm, bool __UNUSED__ cacheable) { |
| SetFlag(frm.flags, SCFF_CACHEABLE); |
| } |
| |
| inline void SetAddr(FrameInfo &frm, void *addr[SC_NUM_OF_PLANES], int mem_type, int fence) |
| { |
| for (int i = 0; i < SC_MAX_PLANES; i++) |
| frm.addr[i] = addr[i]; |
| |
| frm.memory = static_cast<v4l2_memory>(mem_type); |
| frm.fdAcquireFence = fence; |
| } |
| |
| bool RunSWScaling(); |
| |
| protected: |
| unsigned long m_fStatus; // enum SC_FLAG |
| |
| int m_fdScaler; |
| |
| inline void SetFlag(unsigned long &flags, unsigned long flag) { |
| flags |= (1 << flag); |
| } |
| |
| inline void ClearFlag(unsigned long &flags, unsigned long flag) { |
| flags &= ~(1 << flag); |
| } |
| |
| inline bool TestFlag(unsigned long &flags, unsigned long flag) { |
| return (flags & (1 << flag)) != 0; |
| } |
| |
| |
| public: |
| inline bool Valid() { return (m_fdScaler >= 0) && (m_fdScaler == -m_fdValidate); } |
| |
| CScalerV4L2(int instance, int allow_drm = 0); |
| virtual ~CScalerV4L2(); |
| |
| bool SetCtrl(); |
| |
| inline bool IsDRMAllowed() { return TestFlag(m_fStatus, SCF_ALLOW_DRM); } |
| inline int GetScalerID() { return m_iInstance; } |
| |
| bool Stop(); |
| bool Run(); // Blocking mode |
| |
| // H/W Control |
| virtual bool DevSetCtrl(); |
| bool DevSetFormat(); |
| |
| inline bool ReqBufs() { |
| if (!ReqBufs(m_frmSrc)) |
| return false; |
| |
| return ReqBufs(m_frmDst); |
| } |
| |
| inline bool QBuf(int *pfdSrcReleaseFence = NULL, int *pfdDstReleaseFence = NULL) { |
| if (!QBuf(m_frmSrc, pfdSrcReleaseFence)) |
| return false; |
| |
| if (!QBuf(m_frmDst, pfdDstReleaseFence)) { |
| ClearFlag(m_frmSrc.flags, SCFF_QBUF); |
| return false; |
| } |
| return true; |
| } |
| |
| inline bool StreamOn() { |
| if (!StreamOn(m_frmSrc)) |
| return false; |
| |
| return StreamOn(m_frmDst); |
| } |
| |
| inline bool DQBuf() { |
| if (!DQBuf(m_frmSrc)) |
| return false; |
| |
| return DQBuf(m_frmDst); |
| } |
| |
| inline bool SetSrcFormat(unsigned int width, unsigned int height, |
| unsigned int v4l2_colorformat) { |
| return SetFormat(m_frmSrc, width, height, v4l2_colorformat); |
| } |
| |
| inline bool SetDstFormat(unsigned int width, unsigned int height, |
| unsigned int v4l2_colorformat) { |
| return SetFormat(m_frmDst, width, height, v4l2_colorformat); |
| } |
| |
| inline bool SetSrcCrop(unsigned int left, unsigned int top, |
| unsigned int width, unsigned int height) { |
| return SetCrop(m_frmSrc, left, top, width, height); |
| } |
| |
| inline bool SetDstCrop(unsigned int left, unsigned int top, |
| unsigned int width, unsigned int height) { |
| return SetCrop(m_frmDst, left, top, width, height); |
| } |
| |
| inline void SetDRM(bool drm) { |
| if (drm != TestFlag(m_fStatus, SCF_DRM)) { |
| if (drm) |
| SetFlag(m_fStatus, SCF_DRM); |
| else |
| ClearFlag(m_fStatus, SCF_DRM); |
| SetFlag(m_fStatus, SCF_DRM_FRESH); |
| } |
| } |
| |
| inline void SetCSCWide(bool wide) { |
| if (wide) |
| SetFlag(m_fStatus, SCF_CSC_WIDE); |
| else |
| ClearFlag(m_fStatus, SCF_CSC_WIDE); |
| |
| SetFlag(m_fStatus, SCF_CSC_FRESH); |
| } |
| |
| inline void SetCSCEq(unsigned int v4l2_colorspace) { |
| if (v4l2_colorspace == V4L2_COLORSPACE_SMPTE170M) |
| m_colorspace = V4L2_COLORSPACE_DEFAULT; |
| else |
| m_colorspace = v4l2_colorspace; |
| SetFlag(m_fStatus, SCF_CSC_FRESH); |
| } |
| |
| inline void SetFilter(unsigned int filter) { |
| m_filter = filter; |
| } |
| |
| inline void SetSrcCacheable(bool cacheable) { |
| return SetCacheable(m_frmSrc, cacheable); |
| } |
| |
| inline void SetDstCacheable(bool cacheable) { |
| return SetCacheable(m_frmDst, cacheable); |
| } |
| |
| inline void SetSrcPremultiplied(bool premultiplied) { |
| return SetPremultiplied(m_frmSrc, premultiplied); |
| } |
| |
| inline void SetDstPremultiplied(bool premultiplied) { |
| return SetPremultiplied(m_frmDst, premultiplied); |
| } |
| |
| // Parameter Extraction |
| bool SetRotate(int rot, int flip_h, int flip_v); |
| |
| inline bool SetSrcAddr(void *addr[SC_NUM_OF_PLANES], int mem_type, int fence = -1) { |
| SetAddr(m_frmSrc, addr, mem_type, fence); |
| return true; |
| } |
| |
| inline bool SetDstAddr(void *addr[SC_NUM_OF_PLANES], int mem_type, int fence = -1) { |
| SetAddr(m_frmDst, addr, mem_type, fence); |
| return true; |
| } |
| |
| inline void SetFrameRate(int framerate) { |
| m_frameRate = framerate; |
| SetFlag(m_fStatus, SCF_FRAMERATE); |
| } |
| }; |
| |
| #endif //_LIBSCALER_V4L2_H_ |
