path: root/libscaler/libscaler-v4l2.cpp

/*
 * 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.cpp
 * \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
 */

#include <cstring>
#include <cstdlib>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/mman.h>

#include "libscaler-v4l2.h"
#include "libscaler-swscaler.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)

void CScalerV4L2::Initialize(int instance)
{
    snprintf(m_cszNode, SC_MAX_NODENAME, SC_DEV_NODE "%d", SC_NODE(instance));

    m_fdScaler = open(m_cszNode, O_RDWR);
    if (m_fdScaler < 0) {
        SC_LOGERR("Failed to open '%s'", m_cszNode);
        return;
    }

    m_fdValidate = -m_fdScaler;
}

CScalerV4L2::CScalerV4L2(int instance, int allow_drm)
{
    m_fdScaler = -1;
    m_iInstance = instance;
    m_nRotDegree = 0;
    m_fStatus = 0;
    m_filter = 0;

    memset(&m_frmSrc, 0, sizeof(m_frmSrc));
    memset(&m_frmDst, 0, sizeof(m_frmDst));

    m_frmSrc.fdAcquireFence = -1;
    m_frmDst.fdAcquireFence = -1;

    m_frmSrc.name = "output";
    m_frmDst.name = "capture";

    m_frmSrc.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
    m_frmDst.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;

    m_frameRate = 0;

    Initialize(instance);

    if(Valid()) {
        if (allow_drm)
            SetFlag(m_fStatus, SCF_ALLOW_DRM);
        SC_LOGD("Successfully opened '%s'; returned fd %d; drmmode %s",
                m_cszNode, m_fdScaler, allow_drm ? "enabled" : "disabled");
    }
}

CScalerV4L2::~CScalerV4L2()
{
    if (m_fdScaler >= 0)
        close(m_fdScaler);

    m_fdScaler = -1;
}

bool CScalerV4L2::Stop()
{
    if (!ResetDevice(m_frmSrc)) {
        SC_LOGE("Failed to stop Scaler for the output frame");
        return false;
    }

    if (!ResetDevice(m_frmDst)) {
        SC_LOGE("Failed to stop Scaler for the cature frame");
        return false;
    }

    return true;
}

bool CScalerV4L2::Run()
{
    if (LibScaler::UnderOne16thScaling(
                m_frmSrc.crop.width, m_frmSrc.crop.height,
                m_frmDst.crop.width, m_frmDst.crop.height,
                m_nRotDegree))
        return RunSWScaling();

    if (!DevSetCtrl())
        return false;

    if (!DevSetFormat())
        return false;

    if (!ReqBufs())
        return false;

    if (!StreamOn())
        return false;

    if (!QBuf()) {
        Stop();
        return false;
    }

    return DQBuf();
}

bool CScalerV4L2::SetCtrl()
{
    struct v4l2_control ctrl;

    if (TestFlag(m_fStatus, SCF_DRM_FRESH)) {
        if (!Stop())
            return false;

        ctrl.id = V4L2_CID_CONTENT_PROTECTION;
        ctrl.value = TestFlag(m_fStatus, SCF_DRM);
        if (ioctl(m_fdScaler, VIDIOC_S_CTRL, &ctrl) < 0) {
            SC_LOGERR("Failed configure V4L2_CID_CONTENT_PROTECTION to %d", TestFlag(m_fStatus, SCF_DRM));
            return false;
        }

        ClearFlag(m_fStatus, SCF_DRM_FRESH);
    } else {
        SC_LOGD("Skipping DRM configuration");
    }

    if (TestFlag(m_fStatus, SCF_ROTATION_FRESH)) {
        if (!Stop())
            return false;

        ctrl.id = V4L2_CID_ROTATE;
        ctrl.value = m_nRotDegree;
        if (ioctl(m_fdScaler, VIDIOC_S_CTRL, &ctrl) < 0) {
            SC_LOGERR("Failed V4L2_CID_ROTATE with degree %d", m_nRotDegree);
            return false;
        }

        ctrl.id = V4L2_CID_VFLIP;
        ctrl.value = TestFlag(m_fStatus, SCF_HFLIP);
        if (ioctl(m_fdScaler, VIDIOC_S_CTRL, &ctrl) < 0) {
            SC_LOGERR("Failed V4L2_CID_VFLIP - %d", TestFlag(m_fStatus, SCF_VFLIP));
            return false;
        }

        ctrl.id = V4L2_CID_HFLIP;
        ctrl.value = TestFlag(m_fStatus, SCF_VFLIP);
        if (ioctl(m_fdScaler, VIDIOC_S_CTRL, &ctrl) < 0) {
            SC_LOGERR("Failed V4L2_CID_HFLIP - %d", TestFlag(m_fStatus, SCF_HFLIP));
            return false;
        }

        SC_LOGD("Successfully set CID_ROTATE(%d), CID_VFLIP(%d) and CID_HFLIP(%d)",
                m_nRotDegree, TestFlag(m_fStatus, SCF_VFLIP), TestFlag(m_fStatus, SCF_HFLIP));
        ClearFlag(m_fStatus, SCF_ROTATION_FRESH);
    } else {
        SC_LOGD("Skipping rotation and flip setting due to no change");
    }

    if (m_filter > 0) {
        if (!Stop())
            return false;

        ctrl.id = LIBSC_V4L2_CID_DNOISE_FT;
        ctrl.value = m_filter;
        if (ioctl(m_fdScaler, VIDIOC_S_CTRL, &ctrl) < 0) {
            SC_LOGERR("Failed LIBSC_V4L2_CID_DNOISE_FT to %d", m_filter);
            return false;
        }
    }

    if (TestFlag(m_fStatus, SCF_CSC_FRESH)) {
        if (!Stop())
            return false;

        ctrl.id = V4L2_CID_CSC_RANGE;
        ctrl.value = TestFlag(m_fStatus, SCF_CSC_WIDE) ? 1 : 0;
        if (ioctl(m_fdScaler, VIDIOC_S_CTRL, &ctrl) < 0) {
            SC_LOGERR("Failed V4L2_CID_CSC_RANGE to %d", TestFlag(m_fStatus, SCF_CSC_WIDE));
            return false;
        }

        ctrl.id = V4L2_CID_CSC_EQ;
        ctrl.value = m_colorspace;
        if (ioctl(m_fdScaler, VIDIOC_S_CTRL, &ctrl) < 0) {
            SC_LOGERR("Failed V4L2_CID_CSC_EQ to %d", m_colorspace);
        }
        ClearFlag(m_fStatus, SCF_CSC_FRESH);
    }

    /* This is optional, so we don't return failure. */
    if (TestFlag(m_fStatus, SCF_FRAMERATE)) {
        if (!Stop())
            return false;

        ctrl.id = SC_CID_FRAMERATE;
        ctrl.value = m_frameRate;
        if (ioctl(m_fdScaler, VIDIOC_S_CTRL, &ctrl) < 0) {
            SC_LOGD("Failed SC_CID_FRAMERATE to %d", m_frameRate);
        }
        ClearFlag(m_fStatus, SCF_FRAMERATE);
    }

    return true;
}

bool CScalerV4L2::DevSetCtrl()
{
    return SetCtrl();
}

bool CScalerV4L2::ResetDevice(FrameInfo &frm)
{
    DQBuf(frm);

    if (TestFlag(frm.flags, SCFF_STREAMING)) {
        if (ioctl(m_fdScaler, VIDIOC_STREAMOFF, &frm.type) < 0) {
            SC_LOGERR("Failed STREAMOFF for the %s", frm.name);
        }
        ClearFlag(frm.flags, SCFF_STREAMING);
    }

    SC_LOGD("VIDIC_STREAMOFF is successful for the %s", frm.name);

    if (TestFlag(frm.flags, SCFF_REQBUFS)) {
        v4l2_requestbuffers reqbufs;
        memset(&reqbufs, 0, sizeof(reqbufs));
        reqbufs.type = frm.type;
        reqbufs.memory = frm.memory;
        if (ioctl(m_fdScaler, VIDIOC_REQBUFS, &reqbufs) < 0 ) {
            SC_LOGERR("Failed to REQBUFS(0) for the %s", frm.name);
        }

        ClearFlag(frm.flags, SCFF_REQBUFS);
    }

    SC_LOGD("VIDIC_REQBUFS(0) is successful for the %s", frm.name);

    return true;
}

bool CScalerV4L2::DevSetFormat(FrameInfo &frm)
{

    if (!TestFlag(frm.flags, SCFF_BUF_FRESH)) {
        SC_LOGD("Skipping S_FMT for the %s since it is already done", frm.name);
        return true;
    }

    if (!ResetDevice(frm)) {
        SC_LOGE("Failed to VIDIOC_S_FMT for the %s", frm.name);
        return false;
    }

    v4l2_format fmt;
    memset(&fmt, 0, sizeof(fmt));
    fmt.type = frm.type;
    fmt.fmt.pix_mp.pixelformat = frm.color_format;
    fmt.fmt.pix_mp.width  = frm.width;
    fmt.fmt.pix_mp.height = frm.height;

    if (TestFlag(frm.flags, SCFF_PREMULTIPLIED)) {
#ifdef SCALER_USE_PREMUL_FMT
        fmt.fmt.pix_mp.flags = V4L2_PIX_FMT_FLAG_PREMUL_ALPHA;
#else
        fmt.fmt.pix_mp.reserved[1] = SC_V4L2_FMT_PREMULTI_FLAG;
#endif
    }

    if (ioctl(m_fdScaler, VIDIOC_S_FMT, &fmt) < 0) {
        SC_LOGERR("Failed S_FMT(fmt: %d, w:%d, h:%d) for the %s",
                fmt.fmt.pix_mp.pixelformat, fmt.fmt.pix_mp.width, fmt.fmt.pix_mp.height,
                frm.name);
        return false;
    }

    // returned fmt.fmt.pix_mp.num_planes and fmt.fmt.pix_mp.plane_fmt[i].sizeimage
    frm.out_num_planes = fmt.fmt.pix_mp.num_planes;

    for (int i = 0; i < frm.out_num_planes; i++)
        frm.out_plane_size[i] = fmt.fmt.pix_mp.plane_fmt[i].sizeimage;

    v4l2_crop crop;
    crop.type = frm.type;
    crop.c = frm.crop;

    if (ioctl(m_fdScaler, VIDIOC_S_CROP, &crop) < 0) {
        SC_LOGERR("Failed S_CROP(fmt: %d, l:%d, t:%d, w:%d, h:%d) for the %s",
                crop.type, crop.c.left, crop.c.top, crop.c.width, crop.c.height,
                frm.name);
        return false;
    }

    if (frm.out_num_planes > SC_MAX_PLANES) {
        SC_LOGE("Number of planes exceeds %d of %s", frm.out_num_planes, frm.name);
        return false;
    }

    ClearFlag(frm.flags, SCFF_BUF_FRESH);

    SC_LOGD("Successfully S_FMT and S_CROP for the %s", frm.name);

    return true;
}

bool CScalerV4L2::DevSetFormat()
{
    if (!DevSetFormat(m_frmSrc))
        return false;

    return DevSetFormat(m_frmDst);
}

bool CScalerV4L2::QBuf(FrameInfo &frm, int *pfdReleaseFence)
{
    v4l2_buffer buffer;
    v4l2_plane planes[SC_MAX_PLANES];

    if (!TestFlag(frm.flags, SCFF_REQBUFS)) {
        SC_LOGE("Trying to QBUF without REQBUFS for %s is not allowed",
                frm.name);
        return false;
    }

    if (!DQBuf(frm))
        return false;

    memset(&buffer, 0, sizeof(buffer));
    memset(&planes, 0, sizeof(planes));

    buffer.type   = frm.type;
    buffer.memory = frm.memory;
    buffer.index  = 0;
    buffer.length = frm.out_num_planes;

    if (pfdReleaseFence) {
        buffer.flags    = V4L2_BUF_FLAG_USE_SYNC;
        buffer.reserved = frm.fdAcquireFence;
    }

    buffer.m.planes = planes;
    for (unsigned long i = 0; i < buffer.length; i++) {
        planes[i].length = frm.out_plane_size[i];
        if (V4L2_TYPE_IS_OUTPUT(buffer.type))
            planes[i].bytesused = planes[i].length;
        if (buffer.memory == V4L2_MEMORY_DMABUF)
            planes[i].m.fd = static_cast<__s32>(reinterpret_cast<long>(frm.addr[i]));
        else
            planes[i].m.userptr = reinterpret_cast<unsigned long>(frm.addr[i]);
    }


    if (ioctl(m_fdScaler, VIDIOC_QBUF, &buffer) < 0) {
        SC_LOGERR("Failed to QBUF for the %s", frm.name);
        return false;
    }

    SetFlag(frm.flags, SCFF_QBUF);

    if (pfdReleaseFence) {
        if (frm.fdAcquireFence >= 0)
            close(frm.fdAcquireFence);
        frm.fdAcquireFence = -1;

        *pfdReleaseFence = static_cast<int>(buffer.reserved);
    }

    SC_LOGD("Successfully QBUF for the %s", frm.name);

    return true;
}

bool CScalerV4L2::ReqBufs(FrameInfo &frm)
{
    v4l2_requestbuffers reqbufs;

    if (TestFlag(frm.flags, SCFF_REQBUFS)) {
        SC_LOGD("Skipping REQBUFS for the %s since it is already done", frm.name);
        return true;
    }

    memset(&reqbufs, 0, sizeof(reqbufs));

    reqbufs.type    = frm.type;
    reqbufs.memory  = frm.memory;
    reqbufs.count   = 1;

    if (ioctl(m_fdScaler, VIDIOC_REQBUFS, &reqbufs) < 0) {
        SC_LOGERR("Failed to REQBUFS for the %s", frm.name);
        return false;
    }

    SetFlag(frm.flags, SCFF_REQBUFS);

    SC_LOGD("Successfully REQBUFS for the %s", frm.name);

    return true;
}

bool CScalerV4L2::SetRotate(int rot, int flip_h, int flip_v)
{
    if ((rot % 90) != 0) {
        SC_LOGE("Rotation of %d degree is not supported", rot);
        return false;
    }

    SetRotDegree(rot);

    if (flip_h)
        SetFlag(m_fStatus, SCF_VFLIP);
    else
        ClearFlag(m_fStatus, SCF_VFLIP);

    if (flip_v)
        SetFlag(m_fStatus, SCF_HFLIP);
    else
        ClearFlag(m_fStatus, SCF_HFLIP);

    SetFlag(m_fStatus, SCF_ROTATION_FRESH);

    return true;
}

bool CScalerV4L2::StreamOn(FrameInfo &frm)
{
    if (!TestFlag(frm.flags, SCFF_REQBUFS)) {
        SC_LOGE("Trying to STREAMON without REQBUFS for %s is not allowed",
                frm.name);
        return false;
    }

    if (!TestFlag(frm.flags, SCFF_STREAMING)) {
        if (ioctl(m_fdScaler, VIDIOC_STREAMON, &frm.type) < 0 ) {
            SC_LOGERR("Failed StreamOn for the %s", frm.name);
            return false;
        }

        SetFlag(frm.flags, SCFF_STREAMING);

        SC_LOGD("Successfully VIDIOC_STREAMON for the %s", frm.name);
    }

    return true;
}

bool CScalerV4L2::DQBuf(FrameInfo &frm)
{
    if (!TestFlag(frm.flags, SCFF_QBUF))
        return true;

    v4l2_buffer buffer;
    v4l2_plane plane[SC_NUM_OF_PLANES];

    memset(&buffer, 0, sizeof(buffer));

    buffer.type = frm.type;
    buffer.memory = frm.memory;

    if (V4L2_TYPE_IS_MULTIPLANAR(buffer.type)) {
        memset(plane, 0, sizeof(plane));

        buffer.length = frm.out_num_planes;
        buffer.m.planes = plane;
    }

    ClearFlag(frm.flags, SCFF_QBUF);

    if (ioctl(m_fdScaler, VIDIOC_DQBUF, &buffer) < 0 ) {
        SC_LOGERR("Failed to DQBuf the %s", frm.name);
        return false;
    }

    if (buffer.flags & V4L2_BUF_FLAG_ERROR) {
        SC_LOGE("Error occurred while processing streaming data");
        return false;
    }

    SC_LOGD("Successfully VIDIOC_DQBUF for the %s", frm.name);

    return true;
}

static bool GetBuffer(CScalerV4L2::FrameInfo &frm, char *addr[])
{
    for (int i = 0; i < frm.out_num_planes; i++) {
        if (frm.memory == V4L2_MEMORY_DMABUF) {
            addr[i] = reinterpret_cast<char *>(mmap(NULL, frm.out_plane_size[i],
                        PROT_READ | PROT_WRITE, MAP_SHARED,
                        static_cast<int>(reinterpret_cast<long>(frm.addr[i])), 0));
            if (addr[i] == MAP_FAILED) {
                SC_LOGE("Failed to map FD %ld", reinterpret_cast<long>(frm.addr[i]));
                while (i-- > 0)
                    munmap(addr[i], frm.out_plane_size[i]);
                return false;
            }
        } else {
            addr[i] = reinterpret_cast<char *>(frm.addr[i]);
        }
    }

    return true;
}

static void PutBuffer(CScalerV4L2::FrameInfo &frm, char *addr[])
{
    for (int i = 0; i < frm.out_num_planes; i++) {
        if (frm.memory == V4L2_MEMORY_DMABUF) {
            munmap(addr[i], frm.out_plane_size[i]);
        }
    }
}

bool CScalerV4L2::RunSWScaling()
{
    if (m_frmSrc.color_format != m_frmDst.color_format) {
        SC_LOGE("Source and target image format must be the same");
        return false;
    }

    if (m_nRotDegree != 0) {
        SC_LOGE("Rotation is not allowed for S/W Scaling");
        return false;
    }

    SC_LOGI("Running S/W Scaler: %dx%d -> %dx%d",
            m_frmSrc.crop.width, m_frmSrc.crop.height,
            m_frmDst.crop.width, m_frmDst.crop.height);

    CScalerSW *swsc;
    char *src[3], *dst[3];

    switch (m_frmSrc.color_format) {
        case V4L2_PIX_FMT_YUYV:
        case V4L2_PIX_FMT_YVYU:
            m_frmSrc.out_num_planes = 1;
            m_frmSrc.out_plane_size[0] = m_frmSrc.width * m_frmSrc.height * 2;
            m_frmDst.out_num_planes = 1;
            m_frmDst.out_plane_size[0] = m_frmDst.width * m_frmDst.height * 2;

            if (!GetBuffer(m_frmSrc, src))
                return false;

            if (!GetBuffer(m_frmDst, dst)) {
                PutBuffer(m_frmSrc, src);
                return false;
            }

            swsc = new CScalerSW_YUYV(src[0], dst[0]);
            break;
        case V4L2_PIX_FMT_NV12M:
        case V4L2_PIX_FMT_NV21M:
            m_frmSrc.out_num_planes = 2;
            m_frmDst.out_num_planes = 2;
            m_frmSrc.out_plane_size[0] = m_frmSrc.width * m_frmSrc.height;
            m_frmDst.out_plane_size[0] = m_frmDst.width * m_frmDst.height;
            m_frmSrc.out_plane_size[1] = m_frmSrc.out_plane_size[0] / 2;
            m_frmDst.out_plane_size[1] = m_frmDst.out_plane_size[0] / 2;

            if (!GetBuffer(m_frmSrc, src))
                return false;

            if (!GetBuffer(m_frmDst, dst)) {
                PutBuffer(m_frmSrc, src);
                return false;
            }

            swsc = new CScalerSW_NV12(src[0], src[1], dst[0], dst[1]);
            break;
        case V4L2_PIX_FMT_NV12:
        case V4L2_PIX_FMT_NV21:
            m_frmSrc.out_num_planes = 1;
            m_frmDst.out_num_planes = 1;
            m_frmSrc.out_plane_size[0] = m_frmSrc.width * m_frmSrc.height;
            m_frmDst.out_plane_size[0] = m_frmDst.width * m_frmDst.height;
            m_frmSrc.out_plane_size[0] += m_frmSrc.out_plane_size[0] / 2;
            m_frmDst.out_plane_size[0] += m_frmDst.out_plane_size[0] / 2;

            if (!GetBuffer(m_frmSrc, src))
                return false;

            if (!GetBuffer(m_frmDst, dst)) {
                PutBuffer(m_frmSrc, src);
                return false;
            }

            src[1] = src[0] + m_frmSrc.width * m_frmSrc.height;
            dst[1] = dst[0] + m_frmDst.width * m_frmDst.height;

            swsc = new CScalerSW_NV12(src[0], src[1], dst[0], dst[1]);
            break;
        case V4L2_PIX_FMT_UYVY: // TODO: UYVY is not implemented yet.
        default:
            SC_LOGE("Format %x is not supported", m_frmSrc.color_format);
            return false;
    }

    if (swsc == NULL) {
        SC_LOGE("Failed to allocate SW Scaler");
        PutBuffer(m_frmSrc, src);
        PutBuffer(m_frmDst, dst);
        return false;
    }

    swsc->SetSrcRect(m_frmSrc.crop.left, m_frmSrc.crop.top,
            m_frmSrc.crop.width, m_frmSrc.crop.height, m_frmSrc.width);

    swsc->SetDstRect(m_frmDst.crop.left, m_frmDst.crop.top,
            m_frmDst.crop.width, m_frmDst.crop.height, m_frmDst.width);

    bool ret = swsc->Scale();

    delete swsc;

    PutBuffer(m_frmSrc, src);
    PutBuffer(m_frmDst, dst);

    return ret;
}