| /* |
| * Copyright (C) 2008 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 exynos_rotator.c |
| * \brief source file for exynos_rotator HAL |
| * \author Sunmi Lee (carrotsm.lee@samsung.com) |
| * \date 2012/03/05 |
| * |
| * <b>Revision History: </b> |
| * - 2012/03/05 : Sunmi Lee (carrotsm.lee@samsung.com) \n |
| * Create |
| * |
| */ |
| |
| //#define LOG_NDEBUG 0 |
| #define LOG_TAG "libexynosrotator" |
| #include <cutils/log.h> |
| |
| #include <sys/types.h> |
| #include <sys/ioctl.h> |
| #include <linux/videodev2.h> |
| #include <fcntl.h> |
| #include <stdbool.h> |
| #include <string.h> |
| #include <unistd.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <time.h> |
| |
| #include "exynos_rotator.h" |
| |
| #include "exynos_format.h" |
| #include "ExynosMutex.h" |
| #include "exynos_v4l2.h" |
| |
| #define NUM_OF_ROTATOR_PLANES (3) |
| #define NODE_NUM_ROTATOR (21) |
| #define PFX_NODE_ROTATOR "/dev/video" |
| |
| #define ROTATOR_MIN_W_SIZE (8) |
| #define ROTATOR_MIN_H_SIZE (8) |
| |
| #define MAX_ROTATOR_WAITING_TIME_FOR_TRYLOCK (16000) // 16msec |
| #define ROTATOR_WAITING_TIME_FOR_TRYLOCK (8000) // 8msec |
| |
| struct rotator_info { |
| unsigned int width; |
| unsigned int height; |
| unsigned int crop_left; |
| unsigned int crop_top; |
| unsigned int crop_width; |
| unsigned int crop_height; |
| unsigned int v4l2_colorformat; |
| unsigned int cacheable; |
| |
| int rotation; |
| |
| void *addr[NUM_OF_ROTATOR_PLANES]; |
| bool stream_on; |
| |
| enum v4l2_buf_type buf_type; |
| struct v4l2_format format; |
| struct v4l2_buffer buffer; |
| struct v4l2_plane planes[NUM_OF_ROTATOR_PLANES]; |
| struct v4l2_crop crop; |
| }; |
| |
| struct ROTATOR_HANDLE { |
| int rotator_fd; |
| struct rotator_info src; |
| struct rotator_info dst; |
| void *op_mutex; |
| void *obj_mutex; |
| void *cur_obj_mutex; |
| }; |
| |
| static unsigned int m_rotator_get_plane_count( |
| int v4l_pixel_format) |
| { |
| int plane_count = 0; |
| |
| switch (v4l_pixel_format) { |
| case V4L2_PIX_FMT_RGB32: |
| case V4L2_PIX_FMT_BGR32: |
| case V4L2_PIX_FMT_RGB24: |
| case V4L2_PIX_FMT_RGB565: |
| case V4L2_PIX_FMT_RGB555X: |
| case V4L2_PIX_FMT_RGB444: |
| plane_count = 1; |
| break; |
| case V4L2_PIX_FMT_NV12M: |
| case V4L2_PIX_FMT_NV12MT_16X16: |
| case V4L2_PIX_FMT_NV21: |
| case V4L2_PIX_FMT_NV16: |
| case V4L2_PIX_FMT_NV61: |
| plane_count = 2; |
| break; |
| case V4L2_PIX_FMT_YVU420M: |
| case V4L2_PIX_FMT_YUV422P: |
| case V4L2_PIX_FMT_YUYV: |
| case V4L2_PIX_FMT_UYVY: |
| plane_count = 3; |
| break; |
| default: |
| ALOGE("%s::unmatched v4l_pixel_format color_space(0x%x)", |
| __func__, v4l_pixel_format); |
| plane_count = -1; |
| break; |
| } |
| |
| return plane_count; |
| } |
| |
| static unsigned int m_rotator_get_plane_size( |
| unsigned int *plane_size, |
| unsigned int width, |
| unsigned int height, |
| int v4l_pixel_format) |
| { |
| switch (v4l_pixel_format) { |
| case V4L2_PIX_FMT_RGB32: |
| case V4L2_PIX_FMT_BGR32: |
| plane_size[0] = width * height * 4; |
| break; |
| case V4L2_PIX_FMT_RGB24: |
| plane_size[0] = width * height * 3; |
| break; |
| case V4L2_PIX_FMT_RGB565: |
| case V4L2_PIX_FMT_RGB555X: |
| case V4L2_PIX_FMT_RGB444: |
| plane_size[0] = width * height * 2; |
| break; |
| case V4L2_PIX_FMT_NV12M: |
| case V4L2_PIX_FMT_NV21: |
| case V4L2_PIX_FMT_NV16: |
| case V4L2_PIX_FMT_NV61: |
| plane_size[0] = width * height; |
| plane_size[1] = width * (height / 2); |
| break; |
| case V4L2_PIX_FMT_NV12MT_16X16: |
| plane_size[0] = ALIGN(width, 16) * ALIGN(height, 16); |
| plane_size[1] = ALIGN(width, 16) * ALIGN(height / 2, 8); |
| break; |
| case V4L2_PIX_FMT_YVU420M: |
| case V4L2_PIX_FMT_YUV422P: |
| case V4L2_PIX_FMT_YUYV: |
| case V4L2_PIX_FMT_UYVY: |
| plane_size[0] = width * height; |
| plane_size[1] = (width / 2) * (height / 2); |
| plane_size[2] = (width / 2) * (height / 2); |
| break; |
| default: |
| ALOGE("%s::unmatched v4l_pixel_format color_space(0x%x)", |
| __func__, v4l_pixel_format); |
| return -1; |
| break; |
| } |
| |
| return 0; |
| } |
| |
| static int m_exynos_rotator_multiple_of_n( |
| int number, int N) |
| { |
| int result = number; |
| switch (N) { |
| case 1: |
| case 2: |
| case 4: |
| case 8: |
| case 16: |
| case 32: |
| case 64: |
| case 128: |
| case 256: |
| result = (number - (number & (N-1))); |
| break; |
| default: |
| result = number - (number % N); |
| break; |
| } |
| return result; |
| } |
| |
| static bool m_exynos_rotator_check_src_size( |
| unsigned int *w, unsigned int *h, |
| unsigned int *crop_x, unsigned int *crop_y, |
| unsigned int *crop_w, unsigned int *crop_h, |
| int v4l2_colorformat) |
| { |
| if (*w < ROTATOR_MIN_W_SIZE || *h < ROTATOR_MIN_H_SIZE) { |
| ALOGE("%s::too small size (w : %d < %d) (h : %d < %d)", |
| __func__, ROTATOR_MIN_W_SIZE, *w, ROTATOR_MIN_H_SIZE, *h); |
| return false; |
| } |
| |
| if (*crop_w < ROTATOR_MIN_W_SIZE || *crop_h < ROTATOR_MIN_H_SIZE) { |
| ALOGE("%s::too small size (w : %d < %d) (h : %d < %d)", |
| __func__, ROTATOR_MIN_W_SIZE,* crop_w, ROTATOR_MIN_H_SIZE, *crop_h); |
| return false; |
| } |
| |
| switch (v4l2_colorformat) { |
| // YUV420 3p |
| case V4L2_PIX_FMT_YUV420M: |
| case V4L2_PIX_FMT_YVU420M: |
| *w = ALIGN(*w, 16); |
| *h = ALIGN(*h, 16); |
| break; |
| // YUV420 2p |
| case V4L2_PIX_FMT_NV12M: |
| case V4L2_PIX_FMT_NV12MT: |
| case V4L2_PIX_FMT_NV21M: |
| *w = ALIGN(*w, 8); |
| *h = ALIGN(*h, 8); |
| break; |
| // YUV422 |
| case V4L2_PIX_FMT_YUYV: |
| case V4L2_PIX_FMT_YUV422P: |
| case V4L2_PIX_FMT_UYVY: |
| case V4L2_PIX_FMT_NV21: |
| case V4L2_PIX_FMT_NV16: |
| case V4L2_PIX_FMT_YVYU: |
| case V4L2_PIX_FMT_VYUY: |
| // RGB |
| case V4L2_PIX_FMT_RGB32: |
| case V4L2_PIX_FMT_RGB24: |
| case V4L2_PIX_FMT_RGB565: |
| case V4L2_PIX_FMT_BGR32: |
| case V4L2_PIX_FMT_RGB555X: |
| case V4L2_PIX_FMT_RGB444: |
| default: |
| *w = ALIGN(*w, 4); |
| *h = ALIGN(*h, 4); |
| break; |
| } |
| *crop_w = m_exynos_rotator_multiple_of_n(*crop_w, 4); |
| *crop_h = m_exynos_rotator_multiple_of_n(*crop_h, 4); |
| |
| return true; |
| } |
| |
| static bool m_exynos_rotator_check_dst_size( |
| unsigned int *w, unsigned int *h, |
| unsigned int *crop_x, unsigned int *crop_y, |
| unsigned int *crop_w, unsigned int *crop_h, |
| int v4l2_colorformat, |
| int rotation) |
| { |
| unsigned int *new_w; |
| unsigned int *new_h; |
| unsigned int *new_crop_w; |
| unsigned int *new_crop_h; |
| |
| if (rotation == 90 || rotation == 270) { |
| new_w = h; |
| new_h = w; |
| new_crop_w = crop_h; |
| new_crop_h = crop_w; |
| } else { |
| new_w = w; |
| new_h = h; |
| new_crop_w = crop_w; |
| new_crop_h = crop_h; |
| } |
| |
| if (*w < ROTATOR_MIN_W_SIZE || *h < ROTATOR_MIN_H_SIZE) { |
| ALOGE("%s::too small size (w : %d < %d) (h : %d < %d)", |
| __func__, ROTATOR_MIN_W_SIZE, *w, ROTATOR_MIN_H_SIZE, *h); |
| return false; |
| } |
| |
| if (*crop_w < ROTATOR_MIN_W_SIZE || *crop_h < ROTATOR_MIN_H_SIZE) { |
| ALOGE("%s::too small size (w : %d < %d) (h : %d < %d)", |
| __func__, ROTATOR_MIN_W_SIZE,* crop_w, ROTATOR_MIN_H_SIZE, *crop_h); |
| return false; |
| } |
| |
| switch (v4l2_colorformat) { |
| // YUV420 3p |
| case V4L2_PIX_FMT_YUV420M: |
| case V4L2_PIX_FMT_YVU420M: |
| *new_w = ALIGN(*new_w, 16); |
| *new_h = ALIGN(*new_h, 16); |
| break; |
| // YUV420 2p |
| case V4L2_PIX_FMT_NV12M: |
| case V4L2_PIX_FMT_NV12MT: |
| case V4L2_PIX_FMT_NV21M: |
| *new_w = ALIGN(*new_w, 8); |
| *new_h = ALIGN(*new_h, 8); |
| break; |
| // YUV422 |
| case V4L2_PIX_FMT_YUYV: |
| case V4L2_PIX_FMT_YUV422P: |
| case V4L2_PIX_FMT_UYVY: |
| case V4L2_PIX_FMT_NV21: |
| case V4L2_PIX_FMT_NV16: |
| case V4L2_PIX_FMT_YVYU: |
| case V4L2_PIX_FMT_VYUY: |
| // RGB |
| case V4L2_PIX_FMT_RGB32: |
| case V4L2_PIX_FMT_RGB24: |
| case V4L2_PIX_FMT_RGB565: |
| case V4L2_PIX_FMT_BGR32: |
| case V4L2_PIX_FMT_RGB555X: |
| case V4L2_PIX_FMT_RGB444: |
| default: |
| *new_w = ALIGN(*new_w, 4); |
| *new_h = ALIGN(*new_h, 4); |
| break; |
| } |
| *new_crop_w = m_exynos_rotator_multiple_of_n(*new_crop_w, 4); |
| *new_crop_h = m_exynos_rotator_multiple_of_n(*new_crop_h, 4); |
| |
| return true; |
| } |
| |
| static int m_exynos_rotator_create(void) |
| { |
| int fd = 0; |
| unsigned int cap; |
| char node[32]; |
| |
| sprintf(node, "%s%d", PFX_NODE_ROTATOR, NODE_NUM_ROTATOR); |
| fd = exynos_v4l2_open(node, O_RDWR); |
| if (fd < 0) { |
| ALOGE("%s::exynos_v4l2_open(%s) fail", __func__, node); |
| return -1; |
| } |
| |
| cap = V4L2_CAP_STREAMING | |
| V4L2_CAP_VIDEO_OUTPUT_MPLANE | |
| V4L2_CAP_VIDEO_CAPTURE_MPLANE; |
| |
| if (exynos_v4l2_querycap(fd, cap) == false) { |
| ALOGE("%s::exynos_v4l2_querycap() fail", __func__); |
| if (0 < fd) |
| close(fd); |
| fd = 0; |
| return -1; |
| } |
| return fd; |
| } |
| |
| static bool m_exynos_rotator_destroy( |
| struct ROTATOR_HANDLE *rotator_handle) |
| { |
| if (rotator_handle->src.stream_on == true) { |
| if (exynos_v4l2_streamoff(rotator_handle->rotator_fd, rotator_handle->src.buf_type) < 0) |
| ALOGE("%s::exynos_v4l2_streamoff() fail", __func__); |
| |
| rotator_handle->src.stream_on = false; |
| } |
| |
| if (rotator_handle->dst.stream_on == true) { |
| if (exynos_v4l2_streamoff(rotator_handle->rotator_fd, rotator_handle->dst.buf_type) < 0) |
| ALOGE("%s::exynos_v4l2_streamoff() fail", __func__); |
| |
| rotator_handle->dst.stream_on = false; |
| } |
| |
| if (0 < rotator_handle->rotator_fd) |
| close(rotator_handle->rotator_fd); |
| rotator_handle->rotator_fd = 0; |
| |
| return true; |
| } |
| |
| bool m_exynos_rotator_find_and_trylock_and_create( |
| struct ROTATOR_HANDLE *rotator_handle) |
| { |
| int i = 0; |
| bool flag_find_new_rotator = false; |
| unsigned int total_sleep_time = 0; |
| |
| do { |
| if (exynos_mutex_trylock(rotator_handle->obj_mutex) == true) { |
| |
| // destroy old one. |
| m_exynos_rotator_destroy(rotator_handle); |
| |
| // create new one. |
| rotator_handle->rotator_fd = m_exynos_rotator_create(); |
| if (rotator_handle->rotator_fd < 0) { |
| rotator_handle->rotator_fd = 0; |
| exynos_mutex_unlock(rotator_handle->obj_mutex); |
| continue; |
| } |
| |
| if (rotator_handle->cur_obj_mutex) |
| exynos_mutex_unlock(rotator_handle->cur_obj_mutex); |
| |
| rotator_handle->cur_obj_mutex = rotator_handle->obj_mutex; |
| |
| flag_find_new_rotator = true; |
| break; |
| } |
| |
| // waiting for another process doesn't use rotator. |
| // we need to make decision how to do. |
| if (flag_find_new_rotator == false) { |
| usleep(ROTATOR_WAITING_TIME_FOR_TRYLOCK); |
| total_sleep_time += ROTATOR_WAITING_TIME_FOR_TRYLOCK; |
| ALOGV("%s::waiting for anthere process doens't use rotator", __func__); |
| } |
| |
| } while( flag_find_new_rotator == false |
| && total_sleep_time < MAX_ROTATOR_WAITING_TIME_FOR_TRYLOCK); |
| |
| if (flag_find_new_rotator == false) |
| ALOGE("%s::we don't have no available rotator.. fail", __func__); |
| |
| return flag_find_new_rotator; |
| } |
| |
| static bool m_exynos_rotator_set_format( |
| int fd, |
| struct rotator_info *info, |
| bool force) |
| { |
| struct v4l2_requestbuffers req_buf; |
| int plane_count; |
| |
| plane_count = m_rotator_get_plane_count(info->v4l2_colorformat); |
| if (plane_count < 0) { |
| ALOGE("%s::not supported v4l2_colorformat", __func__); |
| return false; |
| } |
| |
| if (force == false) { |
| // format |
| info->format.type = info->buf_type; |
| if (exynos_v4l2_g_fmt(fd, &info->format) < 0) { |
| ALOGE("%s::exynos_v4l2_g_fmt() fail type=%d", __func__, info->buf_type); |
| return false; |
| } |
| |
| if (info->width != info->format.fmt.pix_mp.width || |
| info->height != info->format.fmt.pix_mp.height || |
| info->v4l2_colorformat != info->format.fmt.pix_mp.pixelformat) { |
| ALOGV("%s::info is different..)", __func__); |
| goto set_hw; |
| } |
| |
| // crop |
| if (info->buf_type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { |
| info->crop.type = info->buf_type; |
| if (exynos_v4l2_g_crop(fd, &info->crop) < 0) { |
| ALOGE("%s::exynos_v4l2_g_crop() fail", __func__); |
| return false; |
| } |
| |
| if (info->crop_left != info->crop.c.left || |
| info->crop_top != info->crop.c.top || |
| info->crop_width != info->crop.c.width || |
| info->crop_height != info->crop.c.height) { |
| ALOGV("%s::crop is different..", __func__); |
| goto set_hw; |
| } |
| } |
| |
| // rotation value; |
| |
| int value = 0; |
| |
| if (exynos_v4l2_g_ctrl(fd, V4L2_CID_ROTATE, &value) < 0) { |
| ALOGE("%s::exynos_v4l2_g_ctrl(V4L2_CID_ROTATE) fail", __func__); |
| return false; |
| } |
| |
| if (info->rotation != value) { |
| ALOGV("%s::rotation is different..", __func__); |
| goto set_hw; |
| } |
| |
| // skip s_fmt |
| ALOGV("%s::fmt, crop is same with old-one, so skip s_fmt crop..", __func__); |
| return true; |
| } |
| |
| set_hw: |
| |
| if (info->stream_on == true) { |
| if (exynos_v4l2_streamoff(fd, info->buf_type) < 0) { |
| ALOGE("%s::exynos_v4l2_streamoff() fail", __func__); |
| return false; |
| } |
| info->stream_on = false; |
| } |
| |
| if (exynos_v4l2_s_ctrl(fd, V4L2_CID_ROTATE, info->rotation) < 0) { |
| ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_ROTATE) fail", __func__); |
| return false; |
| } |
| |
| info->format.fmt.pix_mp.width = info->width; |
| info->format.fmt.pix_mp.height = info->height; |
| info->format.fmt.pix_mp.pixelformat = info->v4l2_colorformat; |
| info->format.fmt.pix_mp.field = V4L2_FIELD_ANY; |
| info->format.fmt.pix_mp.num_planes = plane_count; |
| |
| if (exynos_v4l2_s_fmt(fd, &info->format) < 0) { |
| ALOGE("%s::exynos_v4l2_s_fmt() fail", __func__); |
| return false; |
| } |
| |
| if (info->buf_type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) { |
| info->crop.type = info->buf_type; |
| info->crop.c.left = info->crop_left; |
| info->crop.c.top = info->crop_top; |
| info->crop.c.width = info->crop_width; |
| info->crop.c.height = info->crop_height; |
| |
| if (exynos_v4l2_s_crop(fd, &info->crop) < 0) { |
| ALOGE("%s::exynos_v4l2_s_crop() fail", __func__); |
| return false; |
| } |
| } |
| |
| if (exynos_v4l2_s_ctrl(fd, V4L2_CID_CACHEABLE, info->cacheable) < 0) { |
| ALOGE("%s::exynos_v4l2_s_ctrl() fail", __func__); |
| return false; |
| } |
| |
| req_buf.count = 1; |
| req_buf.type = info->buf_type; |
| req_buf.memory = V4L2_MEMORY_USERPTR; |
| if (exynos_v4l2_reqbufs(fd, &req_buf) < 0) { |
| ALOGE("%s::exynos_v4l2_reqbufs() fail", __func__); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| static bool m_exynos_rotator_set_addr( |
| int fd, |
| struct rotator_info *info) |
| { |
| unsigned int i; |
| unsigned int plane_size[NUM_OF_ROTATOR_PLANES]; |
| |
| m_rotator_get_plane_size(plane_size, |
| info->width, |
| info->height, |
| info->v4l2_colorformat); |
| |
| info->buffer.index = 0; |
| info->buffer.type = info->buf_type; |
| info->buffer.memory = V4L2_MEMORY_USERPTR; |
| info->buffer.m.planes = info->planes; |
| info->buffer.length = info->format.fmt.pix_mp.num_planes; |
| |
| for (i = 0; i < info->format.fmt.pix_mp.num_planes; i++) { |
| info->buffer.m.planes[i].m.userptr = (unsigned long)info->addr[i]; |
| info->buffer.m.planes[i].length = plane_size[i]; |
| info->buffer.m.planes[i].bytesused = 0; |
| } |
| |
| if (exynos_v4l2_qbuf(fd, &info->buffer) < 0) { |
| ALOGE("%s::exynos_v4l2_qbuf() fail", __func__); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| void *exynos_rotator_create(void) |
| { |
| int i = 0; |
| int op_id = 0; |
| char mutex_name[32]; |
| |
| struct ROTATOR_HANDLE *rotator_handle = (struct ROTATOR_HANDLE *)malloc(sizeof(struct ROTATOR_HANDLE)); |
| if (rotator_handle == NULL) { |
| ALOGE("%s::malloc(struct ROTATOR_HANDLE) fail", __func__); |
| goto err; |
| } |
| |
| rotator_handle->rotator_fd = 0; |
| memset(&rotator_handle->src, 0, sizeof(struct rotator_info)); |
| memset(&rotator_handle->dst, 0, sizeof(struct rotator_info)); |
| |
| rotator_handle->src.buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; |
| rotator_handle->dst.buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; |
| |
| rotator_handle->op_mutex = NULL; |
| rotator_handle->obj_mutex = NULL; |
| rotator_handle->cur_obj_mutex = NULL; |
| |
| srand(time(NULL)); |
| op_id = rand() % 1000000; // just make random id |
| sprintf(mutex_name, "%sOp%d", LOG_TAG, op_id); |
| rotator_handle->op_mutex = exynos_mutex_create(EXYNOS_MUTEX_TYPE_PRIVATE, mutex_name); |
| if (rotator_handle->op_mutex == NULL) { |
| ALOGE("%s::exynos_mutex_create(%s) fail", __func__, mutex_name); |
| goto err; |
| } |
| |
| exynos_mutex_lock(rotator_handle->op_mutex); |
| |
| sprintf(mutex_name, "%sObject%d", LOG_TAG, i); |
| |
| rotator_handle->obj_mutex = exynos_mutex_create(EXYNOS_MUTEX_TYPE_SHARED, mutex_name); |
| if (rotator_handle->obj_mutex == NULL) { |
| ALOGE("%s::exynos_mutex_create(%s) fail", __func__, mutex_name); |
| goto err; |
| } |
| |
| if (m_exynos_rotator_find_and_trylock_and_create(rotator_handle) == false) { |
| ALOGE("%s::m_exynos_rotator_find_and_trylock_and_create() fail", __func__); |
| goto err; |
| } |
| |
| exynos_mutex_unlock(rotator_handle->cur_obj_mutex); |
| exynos_mutex_unlock(rotator_handle->op_mutex); |
| |
| return (void *)rotator_handle; |
| |
| err: |
| if (rotator_handle) { |
| m_exynos_rotator_destroy(rotator_handle); |
| |
| if (rotator_handle->cur_obj_mutex) |
| exynos_mutex_unlock(rotator_handle->cur_obj_mutex); |
| |
| if ((rotator_handle->obj_mutex != NULL) && |
| (exynos_mutex_get_created_status(rotator_handle->obj_mutex) == true)) { |
| if (exynos_mutex_destroy(rotator_handle->obj_mutex) == false) |
| ALOGE("%s::exynos_mutex_destroy() fail", __func__); |
| } |
| |
| if (rotator_handle->op_mutex) |
| exynos_mutex_unlock(rotator_handle->op_mutex); |
| |
| free(rotator_handle); |
| } |
| |
| return NULL; |
| } |
| |
| void exynos_rotator_destroy( |
| void *handle) |
| { |
| int i = 0; |
| struct ROTATOR_HANDLE *rotator_handle = (struct ROTATOR_HANDLE *)handle; |
| |
| if (handle == NULL) { |
| ALOGE("%s::handle == NULL() fail", __func__); |
| return; |
| } |
| |
| exynos_mutex_lock(rotator_handle->op_mutex); |
| exynos_mutex_lock(rotator_handle->cur_obj_mutex); |
| |
| m_exynos_rotator_destroy(rotator_handle); |
| |
| exynos_mutex_unlock(rotator_handle->cur_obj_mutex); |
| |
| if ((rotator_handle->obj_mutex != NULL) && |
| (exynos_mutex_get_created_status(rotator_handle->obj_mutex) == true)) { |
| if (exynos_mutex_destroy(rotator_handle->obj_mutex) == false) |
| ALOGE("%s::exynos_mutex_destroy() fail", __func__); |
| } |
| |
| exynos_mutex_unlock(rotator_handle->op_mutex); |
| |
| if (rotator_handle) |
| free(rotator_handle); |
| } |
| |
| int exynos_rotator_set_src_format( |
| void *handle, |
| unsigned int width, |
| unsigned int height, |
| unsigned int crop_left, |
| unsigned int crop_top, |
| unsigned int crop_width, |
| unsigned int crop_height, |
| unsigned int v4l2_colorformat, |
| unsigned int cacheable) |
| { |
| struct ROTATOR_HANDLE *rotator_handle; |
| rotator_handle = (struct ROTATOR_HANDLE *)handle; |
| |
| if (handle == NULL) { |
| ALOGE("%s::handle == NULL() fail", __func__); |
| return -1; |
| } |
| |
| exynos_mutex_lock(rotator_handle->op_mutex); |
| |
| rotator_handle->src.width = width; |
| rotator_handle->src.height = height; |
| rotator_handle->src.crop_left = crop_left; |
| rotator_handle->src.crop_top = crop_top; |
| rotator_handle->src.crop_width = crop_width; |
| rotator_handle->src.crop_height = crop_height; |
| rotator_handle->src.v4l2_colorformat = v4l2_colorformat; |
| rotator_handle->src.cacheable = cacheable; |
| |
| exynos_mutex_unlock(rotator_handle->op_mutex); |
| |
| return 0; |
| } |
| |
| int exynos_rotator_set_dst_format( |
| void *handle, |
| unsigned int width, |
| unsigned int height, |
| unsigned int crop_left, |
| unsigned int crop_top, |
| unsigned int v4l2_colorformat, |
| unsigned int cacheable) |
| { |
| struct ROTATOR_HANDLE *rotator_handle; |
| rotator_handle = (struct ROTATOR_HANDLE *)handle; |
| |
| if (handle == NULL) { |
| ALOGE("%s::handle == NULL() fail", __func__); |
| return -1; |
| } |
| |
| exynos_mutex_lock(rotator_handle->op_mutex); |
| |
| rotator_handle->dst.width = width; |
| rotator_handle->dst.height = height; |
| rotator_handle->dst.crop_left = crop_left; |
| rotator_handle->dst.crop_top = crop_top; |
| rotator_handle->dst.crop_width = rotator_handle->src.crop_width; |
| rotator_handle->dst.crop_height = rotator_handle->src.crop_height; |
| rotator_handle->dst.v4l2_colorformat = v4l2_colorformat; |
| rotator_handle->dst.cacheable = cacheable; |
| |
| exynos_mutex_unlock(rotator_handle->op_mutex); |
| |
| return 0; |
| } |
| |
| int exynos_rotator_set_rotation( |
| void *handle, |
| int rotation) |
| { |
| int ret = -1; |
| struct ROTATOR_HANDLE *rotator_handle; |
| rotator_handle = (struct ROTATOR_HANDLE *)handle; |
| |
| if (handle == NULL) { |
| ALOGE("%s::handle == NULL() fail", __func__); |
| return ret; |
| } |
| |
| exynos_mutex_lock(rotator_handle->op_mutex); |
| |
| int new_rotation = rotation % 360; |
| |
| if (new_rotation % 90 != 0) { |
| ALOGE("%s::rotation(%d) cannot be acceptable fail", __func__, rotation); |
| goto done; |
| } |
| |
| if(new_rotation < 0) |
| new_rotation = -new_rotation; |
| |
| rotator_handle->src.rotation = new_rotation; |
| rotator_handle->dst.rotation = new_rotation; |
| |
| ret = 0; |
| done: |
| exynos_mutex_unlock(rotator_handle->op_mutex); |
| |
| return ret; |
| } |
| |
| int exynos_rotator_set_src_addr( |
| void *handle, |
| void *addr[3]) |
| { |
| struct ROTATOR_HANDLE *rotator_handle; |
| rotator_handle = (struct ROTATOR_HANDLE *)handle; |
| |
| if (handle == NULL) { |
| ALOGE("%s::handle == NULL() fail", __func__); |
| return -1; |
| } |
| |
| exynos_mutex_lock(rotator_handle->op_mutex); |
| |
| rotator_handle->src.addr[0] = addr[0]; |
| rotator_handle->src.addr[1] = addr[1]; |
| rotator_handle->src.addr[2] = addr[2]; |
| |
| exynos_mutex_unlock(rotator_handle->op_mutex); |
| |
| return 0; |
| } |
| |
| int exynos_rotator_set_dst_addr( |
| void *handle, |
| void *addr[3]) |
| { |
| struct ROTATOR_HANDLE *rotator_handle; |
| rotator_handle = (struct ROTATOR_HANDLE *)handle; |
| |
| if (handle == NULL) { |
| ALOGE("%s::handle == NULL() fail", __func__); |
| return -1; |
| } |
| |
| exynos_mutex_lock(rotator_handle->op_mutex); |
| |
| rotator_handle->dst.addr[0] = addr[0]; |
| rotator_handle->dst.addr[1] = addr[1]; |
| rotator_handle->dst.addr[2] = addr[2]; |
| |
| exynos_mutex_unlock(rotator_handle->op_mutex); |
| |
| return 0; |
| } |
| |
| int exynos_rotator_convert( |
| void *handle) |
| { |
| struct ROTATOR_HANDLE *rotator_handle; |
| int ret = -1; |
| int i = 0; |
| rotator_handle = (struct ROTATOR_HANDLE *)handle; |
| |
| if (handle == NULL) { |
| ALOGE("%s::handle == NULL() fail", __func__); |
| return -1; |
| } |
| |
| char mutex_name[32]; |
| bool flag_new_rotator = false; |
| |
| exynos_mutex_lock(rotator_handle->op_mutex); |
| |
| if (exynos_mutex_trylock(rotator_handle->cur_obj_mutex) == false) { |
| if (m_exynos_rotator_find_and_trylock_and_create(rotator_handle) == false) { |
| ALOGE("%s::m_exynos_rotator_find_and_trylock_and_create() fail", __func__); |
| goto done; |
| } |
| flag_new_rotator = true; |
| } |
| |
| if (m_exynos_rotator_check_src_size(&rotator_handle->src.width, &rotator_handle->src.width, |
| &rotator_handle->src.crop_left, &rotator_handle->src.crop_top, |
| &rotator_handle->src.crop_width, &rotator_handle->src.crop_height, |
| rotator_handle->src.v4l2_colorformat) == false) { |
| ALOGE("%s::m_exynos_rotator_check_size(src) fail", __func__); |
| goto done; |
| } |
| |
| if (m_exynos_rotator_check_dst_size(&rotator_handle->dst.width, &rotator_handle->dst.height, |
| &rotator_handle->dst.crop_left, &rotator_handle->dst.crop_top, |
| &rotator_handle->dst.crop_width, &rotator_handle->dst.crop_height, |
| rotator_handle->dst.v4l2_colorformat, |
| rotator_handle->dst.rotation) == false) { |
| ALOGE("%s::m_exynos_rotator_check_size(dst) fail", __func__); |
| goto done; |
| } |
| |
| if (m_exynos_rotator_set_format(rotator_handle->rotator_fd, &rotator_handle->src, flag_new_rotator) == false) { |
| ALOGE("%s::m_exynos_rotator_set_format(src) fail", __func__); |
| goto done; |
| } |
| |
| if (m_exynos_rotator_set_format(rotator_handle->rotator_fd, &rotator_handle->dst, flag_new_rotator) == false) { |
| ALOGE("%s::m_exynos_rotator_set_format(dst) fail", __func__); |
| goto done; |
| } |
| |
| if (m_exynos_rotator_set_addr(rotator_handle->rotator_fd, &rotator_handle->src) == false) { |
| ALOGE("%s::m_exynos_rotator_set_addr(src) fail", __func__); |
| goto done; |
| } |
| |
| if (m_exynos_rotator_set_addr(rotator_handle->rotator_fd, &rotator_handle->dst) == false) { |
| ALOGE("%s::m_exynos_rotator_set_addr(dst) fail", __func__); |
| goto done; |
| } |
| |
| if (rotator_handle->src.stream_on == false) { |
| if (exynos_v4l2_streamon(rotator_handle->rotator_fd, rotator_handle->src.buf_type) < 0) { |
| ALOGE("%s::exynos_v4l2_streamon(src) fail", __func__); |
| goto done; |
| } |
| rotator_handle->src.stream_on = true; |
| } |
| |
| if (rotator_handle->dst.stream_on == false) { |
| if (exynos_v4l2_streamon(rotator_handle->rotator_fd, rotator_handle->dst.buf_type) < 0) { |
| ALOGE("%s::exynos_v4l2_streamon(dst) fail", __func__); |
| goto done; |
| } |
| rotator_handle->dst.stream_on = true; |
| } |
| |
| if (exynos_v4l2_dqbuf(rotator_handle->rotator_fd, &rotator_handle->src.buffer) < 0) { |
| ALOGE("%s::exynos_v4l2_dqbuf(src) fail", __func__); |
| goto done; |
| } |
| |
| if (exynos_v4l2_dqbuf(rotator_handle->rotator_fd, &rotator_handle->dst.buffer) < 0) { |
| ALOGE("%s::exynos_v4l2_dqbuf(dst) fail", __func__); |
| goto done; |
| } |
| |
| if (rotator_handle->src.stream_on == true) { |
| if (exynos_v4l2_streamoff(rotator_handle->rotator_fd, rotator_handle->src.buf_type) < 0) { |
| ALOGE("%s::exynos_v4l2_streamon(src) fail", __func__); |
| goto done; |
| } |
| rotator_handle->src.stream_on = false; |
| } |
| |
| if (rotator_handle->dst.stream_on == true) { |
| if (exynos_v4l2_streamoff(rotator_handle->rotator_fd, rotator_handle->dst.buf_type) < 0) { |
| ALOGE("%s::exynos_v4l2_streamon(dst) fail", __func__); |
| goto done; |
| } |
| rotator_handle->dst.stream_on = false; |
| } |
| |
| ret = 0; |
| |
| done: |
| exynos_mutex_unlock(rotator_handle->cur_obj_mutex); |
| exynos_mutex_unlock(rotator_handle->op_mutex); |
| |
| return ret; |
| } |
| |
| int exynos_rotator_connect( |
| void *handle, |
| void *hw) |
| { |
| struct ROTATOR_HANDLE *rotator_handle; |
| int ret = -1; |
| rotator_handle = (struct ROTATOR_HANDLE *)handle; |
| |
| if (handle == NULL) { |
| ALOGE("%s::handle == NULL() fail", __func__); |
| return -1; |
| } |
| |
| exynos_mutex_lock(rotator_handle->op_mutex); |
| |
| if (exynos_mutex_trylock(rotator_handle->cur_obj_mutex) == false) { |
| if (m_exynos_rotator_find_and_trylock_and_create(rotator_handle) == false) { |
| ALOGE("%s::m_exynos_rotator_find_and_trylock_and_create() fail", __func__); |
| goto done; |
| } |
| } |
| |
| ret = 0; |
| |
| done: |
| exynos_mutex_unlock(rotator_handle->op_mutex); |
| |
| return ret; |
| } |
| |
| int exynos_rotator_disconnect( |
| void *handle, |
| void *hw) |
| { |
| struct ROTATOR_HANDLE *rotator_handle; |
| rotator_handle = (struct ROTATOR_HANDLE *)handle; |
| |
| if (handle == NULL) { |
| ALOGE("%s::handle == NULL() fail", __func__); |
| return -1; |
| } |
| |
| exynos_mutex_lock(rotator_handle->op_mutex); |
| |
| exynos_mutex_unlock(rotator_handle->cur_obj_mutex); |
| exynos_mutex_unlock(rotator_handle->op_mutex); |
| |
| return 0; |
| } |