| /* |
| * 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-m2m1shot.cpp |
| * \brief source file for Scaler HAL |
| * \author Cho KyongHo <pullip.cho@samsung.com> |
| * \date 2014/05/08 |
| * |
| * <b>Revision History: </b> |
| * - 2014.05.08 : Cho KyongHo (pullip.cho@samsung.com) \n |
| * Create |
| */ |
| #include <cstring> |
| #include <unistd.h> |
| #include <fcntl.h> |
| #include <sys/ioctl.h> |
| #include <sys/mman.h> |
| |
| #include <exynos_scaler.h> |
| |
| #include "libscaler-common.h" |
| #include "libscaler-m2m1shot.h" |
| #include "libscaler-swscaler.h" |
| |
| using namespace std; |
| |
| const char *dev_base_name[] = { |
| "/dev/m2m1shot_scaler0", |
| "/dev/m2m1shot_scaler1", |
| "/dev/m2m1shot_scaler2", |
| "/dev/m2m1shot_scaler3", |
| }; |
| |
| struct PixFormat { |
| unsigned int pixfmt; |
| char planes; |
| char bit_pp[3]; |
| }; |
| |
| const static PixFormat g_pixfmt_table[] = { |
| {V4L2_PIX_FMT_RGB32, 1, {32, 0, 0}, }, |
| {V4L2_PIX_FMT_BGR32, 1, {32, 0, 0}, }, |
| {V4L2_PIX_FMT_RGB565, 1, {16, 0, 0}, }, |
| {V4L2_PIX_FMT_RGB555X, 1, {16, 0, 0}, }, |
| {V4L2_PIX_FMT_RGB444, 1, {16, 0, 0}, }, |
| {V4L2_PIX_FMT_YUYV, 1, {16, 0, 0}, }, |
| {V4L2_PIX_FMT_YVYU, 1, {16, 0, 0}, }, |
| {V4L2_PIX_FMT_UYVY, 1, {16, 0, 0}, }, |
| {V4L2_PIX_FMT_NV16, 1, {16, 0, 0}, }, |
| {V4L2_PIX_FMT_NV61, 1, {16, 0, 0}, }, |
| {V4L2_PIX_FMT_YUV420, 1, {12, 0, 0}, }, |
| {V4L2_PIX_FMT_YVU420, 1, {12, 0, 0}, }, |
| {V4L2_PIX_FMT_NV12M, 2, {8, 4, 0}, }, |
| {V4L2_PIX_FMT_NV21M, 2, {8, 4, 0}, }, |
| {v4l2_fourcc('V', 'M', '1', '2'), 2, {8, 4, 0}, }, |
| {V4L2_PIX_FMT_NV12, 1, {12, 0, 0}, }, |
| {V4L2_PIX_FMT_NV21, 1, {12, 0, 0}, }, |
| {v4l2_fourcc('N', 'M', '2', '1'), 2, {8, 4, 0}, }, |
| {V4L2_PIX_FMT_YUV420M, 3, {8, 2, 2}, }, |
| {V4L2_PIX_FMT_YVU420M, 3, {8, 2, 2}, }, |
| {V4L2_PIX_FMT_NV12M_P010, 2, {16, 8, 0}, }, |
| {V4L2_PIX_FMT_NV24, 1, {24, 0, 0}, }, |
| {V4L2_PIX_FMT_NV42, 1, {24, 0, 0}, }, |
| }; |
| |
| |
| CScalerM2M1SHOT::CScalerM2M1SHOT(int devid, int __UNUSED__ drm) : m_iFD(-1) |
| { |
| memset(&m_task, 0, sizeof(m_task)); |
| |
| if ((devid < 0) || (devid > 3)) { // instance number must be between 0 ~ 3 |
| SC_LOGE("Invalid device instance ID %d", devid); |
| return; |
| } |
| |
| m_iFD = open(dev_base_name[devid], O_RDWR); |
| if (m_iFD < 0) { |
| SC_LOGERR("Failed to open '%s'", dev_base_name[devid]); |
| } else { |
| // default 3 planes not to miss any buffer address |
| m_task.buf_out.num_planes = 3; |
| m_task.buf_cap.num_planes = 3; |
| } |
| } |
| |
| CScalerM2M1SHOT::~CScalerM2M1SHOT() |
| { |
| if (m_iFD >= 0) |
| close(m_iFD); |
| } |
| |
| bool CScalerM2M1SHOT::Run() |
| { |
| int ret; |
| |
| if (LibScaler::UnderOne16thScaling( |
| m_task.fmt_out.crop.width, m_task.fmt_out.crop.height, |
| m_task.fmt_cap.crop.width, m_task.fmt_cap.crop.height, |
| m_task.op.rotate)) |
| return RunSWScaling(); |
| |
| ret = ioctl(m_iFD, M2M1SHOT_IOC_PROCESS, &m_task); |
| if (ret < 0) { |
| SC_LOGERR("Failed to process the given M2M1SHOT task"); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| #define SCALER_EXT_SIZE 512 |
| bool CScalerM2M1SHOT::SetFormat(m2m1shot_pix_format &fmt, m2m1shot_buffer &buf, |
| unsigned int width, unsigned int height, unsigned int v4l2_fmt) { |
| const PixFormat *pixfmt = NULL; |
| |
| fmt.width = width; |
| fmt.height = height; |
| fmt.fmt = v4l2_fmt; |
| |
| for (size_t i = 0; i < ARRSIZE(g_pixfmt_table); i++) { |
| if (g_pixfmt_table[i].pixfmt == v4l2_fmt) { |
| pixfmt = &g_pixfmt_table[i]; |
| break; |
| } |
| } |
| |
| if (!pixfmt) { |
| SC_LOGE("Format %#x is not supported", v4l2_fmt); |
| return false; |
| } |
| |
| for (int i = 0; i < pixfmt->planes; i++) { |
| if (((pixfmt->bit_pp[i] * width) % 8) != 0) { |
| SC_LOGE("Plane %d of format %#x must have even width", i, v4l2_fmt); |
| return false; |
| } |
| buf.plane[i].len = (pixfmt->bit_pp[i] * width * height) / 8; |
| } |
| |
| if (pixfmt->pixfmt == V4L2_PIX_FMT_YVU420) { |
| unsigned int y_size = width * height; |
| unsigned int c_span = ALIGN(width / 2, 16); |
| buf.plane[0].len = y_size + (c_span * height / 2) * 2; |
| } |
| |
| #ifdef SCALER_ALIGN_RESTRICTION |
| for (int i = 0; i < pixfmt->planes; i++) |
| buf.plane[i].len += (i == 0) ? SCALER_EXT_SIZE : SCALER_EXT_SIZE / 2; |
| #endif |
| |
| buf.num_planes = pixfmt->planes; |
| |
| return true; |
| } |
| |
| bool CScalerM2M1SHOT::SetCrop(m2m1shot_pix_format &fmt, |
| unsigned int l, unsigned int t, unsigned int w, unsigned int h) { |
| if (fmt.width <= l) { |
| SC_LOGE("crop left %d is larger than image width %d", l, fmt.width); |
| return false; |
| } |
| if (fmt.height <= t) { |
| SC_LOGE("crop top %d is larger than image height %d", t, fmt.height); |
| return false; |
| } |
| if (fmt.width < (l + w)) { |
| SC_LOGE("crop width %d@%d exceeds image width %d", w, l, fmt.width); |
| return false; |
| } |
| if (fmt.height < (t + h)) { |
| SC_LOGE("crop height %d@%d exceeds image height %d", h, t, fmt.height); |
| return false; |
| } |
| |
| fmt.crop.left = l; |
| fmt.crop.top = t; |
| fmt.crop.width = w; |
| fmt.crop.height = h; |
| |
| return true; |
| } |
| |
| bool CScalerM2M1SHOT::SetAddr( |
| m2m1shot_buffer &buf, void *addr[SC_NUM_OF_PLANES], int mem_type) { |
| if (mem_type == V4L2_MEMORY_DMABUF) { |
| buf.type = M2M1SHOT_BUFFER_DMABUF; |
| for (int i = 0; i < buf.num_planes; i++) |
| buf.plane[i].fd = static_cast<__s32>(reinterpret_cast<long>(addr[i])); |
| } else if (mem_type == V4L2_MEMORY_USERPTR) { |
| buf.type = M2M1SHOT_BUFFER_USERPTR; |
| for (int i = 0; i < buf.num_planes; i++) |
| buf.plane[i].userptr = reinterpret_cast<unsigned long>(addr[i]); |
| } else { |
| SC_LOGE("Unknown buffer type %d", mem_type); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool CScalerM2M1SHOT::SetRotate(int rot, int hflip, int vflip) { |
| if ((rot % 90) != 0) { |
| SC_LOGE("Rotation degree %d must be multiple of 90", rot); |
| return false; |
| } |
| |
| rot = rot % 360; |
| if (rot < 0) |
| rot = 360 + rot; |
| |
| m_task.op.rotate = rot; |
| m_task.op.op &= ~(M2M1SHOT_OP_FLIP_HORI | M2M1SHOT_OP_FLIP_VIRT); |
| if (hflip) |
| m_task.op.op |= M2M1SHOT_OP_FLIP_HORI; |
| if (vflip) |
| m_task.op.op |= M2M1SHOT_OP_FLIP_VIRT; |
| |
| return true; |
| } |
| |
| static bool GetBuffer(m2m1shot_buffer &buf, char *addr[]) |
| { |
| for (int i = 0; i < buf.num_planes; i++) { |
| if (buf.type == M2M1SHOT_BUFFER_DMABUF) { |
| addr[i] = reinterpret_cast<char *>(mmap(NULL, buf.plane[i].len, |
| PROT_READ | PROT_WRITE, MAP_SHARED, |
| buf.plane[i].fd, 0)); |
| if (addr[i] == MAP_FAILED) { |
| SC_LOGE("Failed to map FD %d", buf.plane[i].fd); |
| while (i-- > 0) |
| munmap(addr[i], buf.plane[i].len); |
| return false; |
| } |
| } else { |
| addr[i] = reinterpret_cast<char *>(buf.plane[i].userptr); |
| } |
| } |
| |
| return true; |
| } |
| |
| static void PutBuffer(m2m1shot_buffer &buf, char *addr[]) |
| { |
| for (int i = 0; i < buf.num_planes; i++) { |
| if (buf.type == M2M1SHOT_BUFFER_DMABUF) |
| munmap(addr[i], buf.plane[i].len); |
| } |
| } |
| |
| bool CScalerM2M1SHOT::RunSWScaling() |
| { |
| if (m_task.fmt_cap.fmt != m_task.fmt_out.fmt) { |
| SC_LOGE("Source and target image format must be the same"); |
| return false; |
| } |
| |
| if (m_task.op.rotate != 0) { |
| SC_LOGE("Rotation is not allowed for S/W Scaling"); |
| return false; |
| } |
| |
| SC_LOGI("Running S/W Scaler: %dx%d -> %dx%d", |
| m_task.fmt_out.crop.width, m_task.fmt_out.crop.height, |
| m_task.fmt_cap.crop.width, m_task.fmt_cap.crop.height); |
| |
| CScalerSW *swsc; |
| char *src[3], *dst[3]; |
| |
| switch (m_task.fmt_cap.fmt) { |
| case V4L2_PIX_FMT_YUYV: |
| case V4L2_PIX_FMT_YVYU: |
| if (!GetBuffer(m_task.buf_out, src)) |
| return false; |
| |
| if (!GetBuffer(m_task.buf_cap, dst)) { |
| PutBuffer(m_task.buf_out, src); |
| return false; |
| } |
| |
| swsc = new CScalerSW_YUYV(src[0], dst[0]); |
| break; |
| case V4L2_PIX_FMT_NV12M: |
| case V4L2_PIX_FMT_NV21M: |
| case V4L2_PIX_FMT_NV12: |
| case V4L2_PIX_FMT_NV21: |
| if (!GetBuffer(m_task.buf_out, src)) |
| return false; |
| |
| if (!GetBuffer(m_task.buf_cap, dst)) { |
| PutBuffer(m_task.buf_out, src); |
| return false; |
| } |
| |
| if (m_task.buf_out.num_planes == 1) |
| src[1] = src[0] + m_task.fmt_out.width * m_task.fmt_out.height; |
| |
| if (m_task.buf_cap.num_planes == 1) |
| dst[1] = dst[0] + m_task.fmt_cap.width * m_task.fmt_cap.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_task.fmt_out.fmt); |
| return false; |
| } |
| |
| if (swsc == NULL) { |
| SC_LOGE("Failed to allocate SW Scaler"); |
| PutBuffer(m_task.buf_out, src); |
| PutBuffer(m_task.buf_cap, dst); |
| return false; |
| } |
| |
| swsc->SetSrcRect(m_task.fmt_out.crop.left, m_task.fmt_out.crop.top, |
| m_task.fmt_out.crop.width, m_task.fmt_out.crop.height, |
| m_task.fmt_out.width); |
| |
| swsc->SetDstRect(m_task.fmt_cap.crop.left, m_task.fmt_cap.crop.top, |
| m_task.fmt_cap.crop.width, m_task.fmt_cap.crop.height, |
| m_task.fmt_cap.width); |
| |
| bool ret = swsc->Scale(); |
| |
| delete swsc; |
| |
| PutBuffer(m_task.buf_out, src); |
| PutBuffer(m_task.buf_cap, dst); |
| |
| return ret; |
| } |
