#define EXYNOS_FOURCC_STR(id) EXYNOS_C(id, 0), EXYNOS_C(id, 8), EXYNOS_C(id, 16), EXYNOS_C(id, 24)
#define MAX_ATTACH_BUFFER 4
-typedef struct _tdm_exynos_pp_buffer {
+typedef struct _tdm_exynos_pp_v4l2_buffer {
int index;
tbm_surface_h src;
tbm_surface_h dst;
struct list_head link;
-} tdm_exynos_pp_buffer;
+} tdm_exynos_pp_v4l2_buffer;
-typedef enum _tdm_exynos_pp_ctrl {
- IPP_STOP = 0,
- IPP_RUN = 1,
- IPP_PAUSE = 2
-} tdm_exynos_pp_ctrl;
+typedef enum _tdm_exynos_pp_v4l2_ctrl {
+ PP_STOP = 0,
+ PP_RUN = 1,
+ PP_PAUSE = 2
+} tdm_exynos_pp_v4l2_ctrl;
typedef enum _tdm_exynos_task_status {
TASK_WAITING,
} tdm_exynos_task_status;
typedef struct _tdm_exynos_prop_id {
- enum drm_exynos_ipp_ctrl status;
+ enum tdm_pp_ctrl status;
unsigned int prop_id;
struct list_head link;
} tdm_exynos_prop_id;
-typedef struct _tdm_exynos_pp_task {
+typedef struct _tdm_exynos_pp_v4l2_task {
int stamp;
unsigned int prop_id[PP_MAX_STEP];
- tdm_exynos_pp_buffer buffers[PP_MAX_STEP];
- tdm_exynos_pp_buffer *attach_buffer;
+ tdm_exynos_pp_v4l2_buffer buffers[PP_MAX_STEP];
+ tdm_exynos_pp_v4l2_buffer *attach_buffer;
unsigned int max_step;
unsigned int current_step;
int status;
tdm_pp_done_handler done_func;
void *done_user_data;
struct list_head link;
-} tdm_exynos_pp_task;
+} tdm_exynos_pp_v4l2_task;
-typedef struct _tdm_exynos_pp_roadmap {
+typedef struct _tdm_exynos_pp_v4l2_roadmap {
unsigned int prop_id[PP_MAX_STEP];
tdm_info_pp step_info[PP_MAX_STEP];
unsigned int max_step;
-} tdm_exynos_pp_roadmap;
+} tdm_exynos_pp_v4l2_roadmap;
-typedef struct _tdm_exynos_pp_data {
+typedef struct _tdm_exynos_pp_v4l2_data {
tdm_exynos_data *exynos_data;
int stamp;
int v4l2_fd[PP_MAX_STEP];
struct list_head pending_buffer_list;
struct list_head pending_tasks_list;
struct list_head prop_id_list;
- tdm_exynos_pp_roadmap roadmap;
- tdm_exynos_pp_roadmap new_roadmap;
- tdm_exynos_pp_task *current_task_p;
+ tdm_exynos_pp_v4l2_roadmap roadmap;
+ tdm_exynos_pp_v4l2_roadmap new_roadmap;
+ tdm_exynos_pp_v4l2_task *current_task_p;
tdm_pp_done_handler done_func;
void *done_user_data;
int roadmap_changed;
int ref_count;
unsigned int buffer_index_arr[MAX_ATTACH_BUFFER];
tdm_event_loop_source *event_source[PP_MAX_STEP];
-} tdm_exynos_pp_data;
+} tdm_exynos_pp_v4l2_data;
-static tbm_format pp_formats[] = {
+static tbm_format pp_v4l2_formats[] = {
TBM_FORMAT_XRGB8888,
TBM_FORMAT_ARGB8888,
TBM_FORMAT_RGB565,
TBM_FORMAT_YUV420,
TBM_FORMAT_YUV422,
};
-static int _tdm_exynos_pp_make_new_tasks(tdm_exynos_pp_data *pp_data);
+static int _tdm_exynos_pp_v4l2_make_new_tasks(tdm_exynos_pp_v4l2_data *pp_v4l2_data);
-#define NUM_PP_FORMAT (sizeof(pp_formats) / sizeof(pp_formats[0]))
+#define NUM_PP_FORMAT (sizeof(pp_v4l2_formats) / sizeof(pp_v4l2_formats[0]))
-static int pp_list_init = 0;
-static int pp_stamp = 1001;
+static int pp_v4l2_list_init = 0;
+static int pp_v4l2_stamp = 1001;
static int task_stamp = 10001;
-static struct list_head pp_list;
+static struct list_head pp_v4l2_list;
-int _find_buffer_index(tdm_exynos_pp_data *pp_data)
+int _find_buffer_index(tdm_exynos_pp_v4l2_data *pp_v4l2_data)
{
int i;
for (i = 0; i < MAX_ATTACH_BUFFER; i++) {
/* find buffer index which can use.*/
- if (!pp_data->buffer_index_arr[i])
+ if (!pp_v4l2_data->buffer_index_arr[i])
return i;
}
TDM_ERR("can't find buffer index for Qbuf");
return -1;
}
-void _reset_buffer_index(tdm_exynos_pp_data *pp_data, unsigned int idx, tbm_surface_h src, tbm_surface_h dst)
+void _reset_buffer_index(tdm_exynos_pp_v4l2_data *pp_v4l2_data, unsigned int idx, tbm_surface_h src, tbm_surface_h dst)
{
if (idx < MAX_ATTACH_BUFFER) {
- pp_data->buffer_index_arr[idx] = 0;
- TDM_DBG("DQbuf inx(%d) , value(%d), src(%p), dst(%p)", idx, pp_data->buffer_index_arr[idx], src, dst);
+ pp_v4l2_data->buffer_index_arr[idx] = 0;
+ TDM_DBG("DQbuf inx(%d) , value(%d), src(%p), dst(%p)", idx, pp_v4l2_data->buffer_index_arr[idx], src, dst);
} else
TDM_ERR("invalid index");
}
-void _set_buffer_index(tdm_exynos_pp_data *pp_data, unsigned int idx, tbm_surface_h src, tbm_surface_h dst)
+void _set_buffer_index(tdm_exynos_pp_v4l2_data *pp_v4l2_data, unsigned int idx, tbm_surface_h src, tbm_surface_h dst)
{
if (idx < MAX_ATTACH_BUFFER) {
- pp_data->buffer_index_arr[idx] = 1;
- TDM_DBG("Qbuf inx(%d) , value(%d), src(%p), dst(%p)", idx, pp_data->buffer_index_arr[idx], src, dst);
+ pp_v4l2_data->buffer_index_arr[idx] = 1;
+ TDM_DBG("Qbuf inx(%d) , value(%d), src(%p), dst(%p)", idx, pp_v4l2_data->buffer_index_arr[idx], src, dst);
} else
TDM_ERR("invalid index");
}
static tdm_exynos_prop_id *
-_find_prop_id(tdm_exynos_pp_data *pp_data, unsigned int prop_id)
+_find_prop_id(tdm_exynos_pp_v4l2_data *pp_v4l2_data, unsigned int prop_id)
{
tdm_exynos_prop_id *prop = NULL;
- LIST_FOR_EACH_ENTRY(prop, &pp_data->prop_id_list, link) {
+ LIST_FOR_EACH_ENTRY(prop, &pp_v4l2_data->prop_id_list, link) {
if (prop->prop_id == prop_id)
return prop;
}
return NULL;
}
-int _tdm_exynos_pp_check_struct(tdm_exynos_pp_data *pp_data)
+int _tdm_exynos_pp_v4l2_check_struct(tdm_exynos_pp_v4l2_data *pp_v4l2_data)
{
- RETURN_VAL_IF_FAIL(pp_list_init == 1, 0);
- if (pp_data == NULL) {
+ RETURN_VAL_IF_FAIL(pp_v4l2_list_init == 1, 0);
+ if (pp_v4l2_data == NULL) {
TDM_ERR("pp nil(0). Received NULL pointer");
return 0;
}
- tdm_exynos_pp_data * pp_next = NULL;
- LIST_FOR_EACH_ENTRY(pp_next, &pp_list, link) {
- if (pp_next->stamp == pp_data->stamp)
+ tdm_exynos_pp_v4l2_data * pp_v4l2_next = NULL;
+ LIST_FOR_EACH_ENTRY(pp_v4l2_next, &pp_v4l2_list, link) {
+ if (pp_v4l2_next->stamp == pp_v4l2_data->stamp)
return 1;
}
- TDM_ERR("pp %p(%d). Wrong ", pp_data, pp_data->stamp);
+ TDM_ERR("pp %p(%d). Wrong ", pp_v4l2_data, pp_v4l2_data->stamp);
return 0;
}
-void _tdm_exynos_pp_roadmap_print(tdm_exynos_pp_roadmap *roadmap)
+void _tdm_exynos_pp_v4l2_roadmap_print(tdm_exynos_pp_v4l2_roadmap *roadmap)
{
RETURN_VOID_IF_FAIL(roadmap);
int i;
TDM_DBG("-------------------------------------------------------------------");
}
-int _tdm_exynos_pp_roadmap_copy(tdm_exynos_pp_roadmap *to_roadmap, tdm_exynos_pp_roadmap *from_roadmap)
+int _tdm_exynos_pp_v4l2_roadmap_copy(tdm_exynos_pp_v4l2_roadmap *to_roadmap, tdm_exynos_pp_v4l2_roadmap *from_roadmap)
{
int i = 0;
for (i = 0; i < PP_MAX_STEP; i++)
}
static unsigned int
-_tdm_exynos_pp_set(tdm_exynos_pp_data *pp_data, tdm_info_pp *info,
+_tdm_exynos_pp_v4l2_set(tdm_exynos_pp_v4l2_data *pp_v4l2_data, tdm_info_pp *info,
unsigned int prop_id)
{
struct v4l2_requestbuffers reqBuf;
/* reqbufs(0) */
reqBuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
reqBuf.memory = V4L2_MEMORY_DMABUF;
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf)) {
TDM_ERR("ioctl error %d", errno);
return 0;
}
reqBuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf)) {
TDM_ERR("ioctl error %d", errno);
return 0;
}
format.fmt.pix_mp.height = info->src_config.size.v;
format.fmt.pix_mp.colorspace = V4L2_COLORSPACE_SRGB;
format.fmt.pix_mp.pixelformat = tdm_exynos_format_to_v4l2_format(info->src_config.format);
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_TRY_FMT, &format)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_TRY_FMT, &format)) {
TDM_ERR("ioctl error %d", errno);
return 0;
}
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_S_FMT, &format)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_S_FMT, &format)) {
TDM_ERR("ioctl error %d", errno);
return 0;
}
format.fmt.pix_mp.height = info->dst_config.size.v;
format.fmt.pix_mp.colorspace = V4L2_COLORSPACE_SRGB;
format.fmt.pix_mp.pixelformat = tdm_exynos_format_to_v4l2_format(info->dst_config.format);
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_TRY_FMT, &format)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_TRY_FMT, &format)) {
TDM_ERR("ioctl error %d", errno);
return 0;
}
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_S_FMT, &format)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_S_FMT, &format)) {
TDM_ERR("ioctl error %d", errno);
return 0;
}
crop.c.top = info->src_config.pos.y;
crop.c.width = info->src_config.pos.w;
crop.c.height = info->src_config.pos.h;
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_S_CROP, &crop)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_S_CROP, &crop)) {
TDM_ERR("ioctl error %d", errno);
return 0;
}
crop.c.top = info->dst_config.pos.y;
crop.c.width = info->dst_config.pos.w;
crop.c.height = info->dst_config.pos.h;
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_S_CROP, &crop)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_S_CROP, &crop)) {
TDM_ERR("ioctl error %d", errno);
return 0;
}
ctrl.id = V4L2_CID_ROTATE;
ctrl.value = (info->transform % 4) * 90;
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_S_CTRL, &ctrl)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_S_CTRL, &ctrl)) {
TDM_ERR("ioctl error %d", errno);
return 0;
}
ctrl.id = V4L2_CID_HFLIP;
ctrl.value = (info->transform > 3) ? 1 : 0;
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_S_CTRL, &ctrl)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_S_CTRL, &ctrl)) {
TDM_ERR("ioctl error %d", errno);
return 0;
}
reqBuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
reqBuf.memory = V4L2_MEMORY_DMABUF;
reqBuf.count = MAX_ATTACH_BUFFER;
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf)) {
TDM_ERR("ioctl error %d", errno);
return 0;
}
reqBuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf)) {
reqBuf.count = 0;
reqBuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- ioctl(pp_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf);
+ ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf);
return 0;
}
}
static tdm_error
-_tdm_exynos_pp_queue(tdm_exynos_pp_data *pp_data, unsigned int prop_id,
- tbm_surface_h src, tbm_surface_h dst, enum drm_exynos_ipp_buf_type type)
+_tdm_exynos_pp_v4l2_queue(tdm_exynos_pp_v4l2_data *pp_v4l2_data, unsigned int prop_id,
+ tbm_surface_h src, tbm_surface_h dst, enum tdm_pp_buf_type type)
{
int i, bo_num;
unsigned int idx = prop_id - 1;
struct v4l2_buffer qbuf;
- struct v4l2_plane plane[EXYNOS_DRM_PLANAR_MAX];
+ struct v4l2_plane plane[TDM_PLANAR_MAX];
tdm_error ret = TDM_ERROR_NONE;
struct v4l2_requestbuffers reqBuf;
int out_id = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
memset(&qbuf, 0, sizeof(qbuf));
memset(&plane, 0, sizeof(plane));
- if (type == IPP_BUF_ENQUEUE) {
+ if (type == PP_BUF_ENQUEUE) {
/* find valid buffer index */
- int buf_index = _find_buffer_index(pp_data);
+ int buf_index = _find_buffer_index(pp_v4l2_data);
/* invalid buffer index */
if (buf_index < 0)
qbuf.memory = V4L2_MEMORY_DMABUF;
qbuf.m.planes = plane;
bo_num = tbm_surface_internal_get_num_bos(src);
- for (i = 0; i < EXYNOS_DRM_PLANAR_MAX && i < bo_num; i++) {
+ for (i = 0; i < TDM_PLANAR_MAX && i < bo_num; i++) {
tbm_bo bo = tbm_surface_internal_get_bo(src, i);
qbuf.m.planes[i].length = tbm_bo_size(bo);
qbuf.m.planes[i].bytesused = tbm_bo_size(bo);
}
qbuf.length = bo_num;
- if (ioctl(pp_data->v4l2_fd[idx], VIDIOC_QBUF, &qbuf) < 0) {
+ if (ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_QBUF, &qbuf) < 0) {
/* handle an error */
TDM_ERR("error ioctl %d", errno);
}
qbuf.memory = V4L2_MEMORY_DMABUF;
qbuf.m.planes = plane;
bo_num = tbm_surface_internal_get_num_bos(dst);
- for (i = 0; i < EXYNOS_DRM_PLANAR_MAX && i < bo_num; i++) {
+ for (i = 0; i < TDM_PLANAR_MAX && i < bo_num; i++) {
tbm_bo bo = tbm_surface_internal_get_bo(dst, i);
qbuf.m.planes[i].length = tbm_bo_size(bo);
qbuf.m.planes[i].bytesused = 0;
qbuf.m.planes[i].m.fd = tbm_bo_get_handle(bo, TBM_DEVICE_MM).u32;
}
qbuf.length = bo_num;
- if (ioctl(pp_data->v4l2_fd[idx], VIDIOC_QBUF, &qbuf) < 0) {
- tdm_exynos_prop_id * found_prop = _find_prop_id(pp_data, prop_id);
+ if (ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_QBUF, &qbuf) < 0) {
+ tdm_exynos_prop_id * found_prop = _find_prop_id(pp_v4l2_data, prop_id);
TDM_ERR("error ioctl %d", errno);
if (found_prop == NULL) {
TDM_ERR("error caanot find prop %d", prop_id);
return TDM_ERROR_OPERATION_FAILED;
}
switch (found_prop->status) {
- case IPP_CTRL_PAUSE:
+ case PP_CTRL_PAUSE:
/* reqbufs(0) */
reqBuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
reqBuf.memory = V4L2_MEMORY_DMABUF;
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf)) {
TDM_ERR("ioctl error %d", errno);
return 0;
}
reqBuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf)) {
TDM_ERR("ioctl error %d", errno);
return 0;
}
reqBuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
reqBuf.memory = V4L2_MEMORY_DMABUF;
reqBuf.count = MAX_ATTACH_BUFFER;
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf)) {
TDM_ERR("ioctl error %d", errno);
return 0;
}
reqBuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf)) {
reqBuf.count = 0;
reqBuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- ioctl(pp_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf);
+ ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf);
return 0;
}
break;
- case IPP_CTRL_PLAY:
- case IPP_CTRL_RESUME:
+ case PP_CTRL_PLAY:
+ case PP_CTRL_RESUME:
/* streamoff */
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_STREAMOFF, &out_id)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_STREAMOFF, &out_id)) {
TDM_ERR("ioctl error : %d", errno);
return TDM_ERROR_BAD_REQUEST;
}
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_STREAMOFF, &cap_id)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_STREAMOFF, &cap_id)) {
TDM_ERR("ioctl error : %d", errno);
return TDM_ERROR_BAD_REQUEST;
}
/* streamon */
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_STREAMON, &out_id)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_STREAMON, &out_id)) {
TDM_ERR("ioctl error : %d", errno);
return TDM_ERROR_BAD_REQUEST;
}
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_STREAMON, &cap_id)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_STREAMON, &cap_id)) {
TDM_ERR("ioctl error : %d", errno);
/* out stream off -> return */
return TDM_ERROR_BAD_REQUEST;
}
/* set buffer index after qbuf */
- _set_buffer_index(pp_data, buf_index, src, dst);
+ _set_buffer_index(pp_v4l2_data, buf_index, src, dst);
/* event loop remove after qbuf*/
- if (!pp_data->sync && (!pp_data->event_source[0] && !pp_data->event_source[1])) {
- pp_data->event_source[0] = tdm_event_loop_add_fd_handler(pp_data->exynos_data->dpy, pp_data->v4l2_fd[0], TDM_EVENT_LOOP_READABLE, tdm_exynos_pp_task_done_handler, pp_data, &ret);
- pp_data->event_source[1] = tdm_event_loop_add_fd_handler(pp_data->exynos_data->dpy, pp_data->v4l2_fd[1], TDM_EVENT_LOOP_READABLE, tdm_exynos_pp_task_done_handler, pp_data, &ret);
+ if (!pp_v4l2_data->sync && (!pp_v4l2_data->event_source[0] && !pp_v4l2_data->event_source[1])) {
+ pp_v4l2_data->event_source[0] = tdm_event_loop_add_fd_handler(pp_v4l2_data->exynos_data->dpy, pp_v4l2_data->v4l2_fd[0], TDM_EVENT_LOOP_READABLE, tdm_exynos_pp_v4l2_task_done_handler, pp_v4l2_data, &ret);
+ pp_v4l2_data->event_source[1] = tdm_event_loop_add_fd_handler(pp_v4l2_data->exynos_data->dpy, pp_v4l2_data->v4l2_fd[1], TDM_EVENT_LOOP_READABLE, tdm_exynos_pp_v4l2_task_done_handler, pp_v4l2_data, &ret);
}
} else {
qbuf.memory = V4L2_MEMORY_DMABUF;
qbuf.m.planes = plane;
qbuf.length = tbm_surface_internal_get_num_bos(src);
- if (ioctl(pp_data->v4l2_fd[idx], VIDIOC_DQBUF, &qbuf) < 0) {
+ if (ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_DQBUF, &qbuf) < 0) {
if (errno == EINTR) {
- while (ioctl(pp_data->v4l2_fd[idx], VIDIOC_DQBUF, &qbuf) < 0) {
+ while (ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_DQBUF, &qbuf) < 0) {
if (errno != EINTR) {
TDM_ERR("ioctl error : %d", errno);
ret = TDM_ERROR_BAD_REQUEST;
qbuf.memory = V4L2_MEMORY_DMABUF;
qbuf.m.planes = plane;
qbuf.length = tbm_surface_internal_get_num_bos(dst);
- if (ioctl(pp_data->v4l2_fd[idx], VIDIOC_DQBUF, &qbuf) < 0) {
+ if (ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_DQBUF, &qbuf) < 0) {
if (errno == EINTR) {
- while (ioctl(pp_data->v4l2_fd[idx], VIDIOC_DQBUF, &qbuf) < 0) {
+ while (ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_DQBUF, &qbuf) < 0) {
if (errno != EINTR) {
TDM_ERR("ioctl error : %d", errno);
ret = TDM_ERROR_BAD_REQUEST;
return TDM_ERROR_BAD_REQUEST;
/* reset Dqbuf index */
- _reset_buffer_index(pp_data, qbuf.index, src, dst);
+ _reset_buffer_index(pp_v4l2_data, qbuf.index, src, dst);
}
return ret;
}
static tdm_error
-_tdm_exynos_pp_cmd(tdm_exynos_pp_data *pp_data, unsigned int prop_id,
- tdm_exynos_pp_ctrl cmd)
+_tdm_exynos_pp_v4l2_cmd(tdm_exynos_pp_v4l2_data *pp_v4l2_data, unsigned int prop_id,
+ tdm_exynos_pp_v4l2_ctrl cmd)
{
- struct drm_exynos_ipp_cmd_ctrl ctrl;
+ struct tdm_pp_cmd_ctrl ctrl;
int cap_id = 0, out_id = 0;
unsigned int idx = prop_id - 1;
struct v4l2_requestbuffers reqBuf;
- tdm_exynos_prop_id * found_prop = _find_prop_id(pp_data, prop_id);
+ tdm_exynos_prop_id * found_prop = _find_prop_id(pp_v4l2_data, prop_id);
memset(&reqBuf, 0, sizeof(reqBuf));
if (found_prop == NULL) {
if ((found_prop = calloc(1, sizeof(tdm_exynos_prop_id))) == NULL) {
- TDM_ERR("pp %p(%d). Out of memory", pp_data, pp_data->stamp);
+ TDM_ERR("pp %p(%d). Out of memory", pp_v4l2_data, pp_v4l2_data->stamp);
return TDM_ERROR_OUT_OF_MEMORY;
}
found_prop->prop_id = prop_id;
- found_prop->status = IPP_CTRL_STOP;
- LIST_ADDTAIL(&found_prop->link, &pp_data->prop_id_list);
+ found_prop->status = PP_CTRL_STOP;
+ LIST_ADDTAIL(&found_prop->link, &pp_v4l2_data->prop_id_list);
}
ctrl.prop_id = prop_id;
switch (cmd) {
- case IPP_RUN:
- if (found_prop->status == IPP_CTRL_STOP)
- ctrl.ctrl = IPP_CTRL_PLAY;
- else if (found_prop->status == IPP_CTRL_PAUSE)
- ctrl.ctrl = IPP_CTRL_RESUME;
- else if (found_prop->status == IPP_CTRL_PLAY ||
- found_prop->status == IPP_CTRL_RESUME)
+ case PP_RUN:
+ if (found_prop->status == PP_CTRL_STOP)
+ ctrl.ctrl = PP_CTRL_PLAY;
+ else if (found_prop->status == PP_CTRL_PAUSE)
+ ctrl.ctrl = PP_CTRL_RESUME;
+ else if (found_prop->status == PP_CTRL_PLAY ||
+ found_prop->status == PP_CTRL_RESUME)
return TDM_ERROR_NONE;
break;
- case IPP_PAUSE:
- if (found_prop->status == IPP_CTRL_PLAY ||
- found_prop->status == IPP_CTRL_RESUME)
- ctrl.ctrl = IPP_CTRL_PAUSE;
- else if (found_prop->status == IPP_CTRL_PAUSE ||
- found_prop->status == IPP_CTRL_STOP)
+ case PP_PAUSE:
+ if (found_prop->status == PP_CTRL_PLAY ||
+ found_prop->status == PP_CTRL_RESUME)
+ ctrl.ctrl = PP_CTRL_PAUSE;
+ else if (found_prop->status == PP_CTRL_PAUSE ||
+ found_prop->status == PP_CTRL_STOP)
return TDM_ERROR_NONE;
break;
- case IPP_STOP:
- if (found_prop->status == IPP_CTRL_STOP) {
+ case PP_STOP:
+ if (found_prop->status == PP_CTRL_STOP) {
LIST_DEL(&found_prop->link);
free(found_prop);
return TDM_ERROR_NONE;
}
LIST_DEL(&found_prop->link);
free(found_prop);
- ctrl.ctrl = IPP_CTRL_STOP;
+ ctrl.ctrl = PP_CTRL_STOP;
found_prop = NULL;
break;
default:
break;
}
- TDM_DBG("pp %p(%d). prop_id(%d) ctrl(%d). ", pp_data, pp_data->stamp, ctrl.prop_id, ctrl.ctrl);
+ TDM_DBG("pp %p(%d). prop_id(%d) ctrl(%d). ", pp_v4l2_data, pp_v4l2_data->stamp, ctrl.prop_id, ctrl.ctrl);
out_id = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
cap_id = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
switch (ctrl.ctrl) {
- case IPP_CTRL_PLAY:
- case IPP_CTRL_RESUME:
+ case PP_CTRL_PLAY:
+ case PP_CTRL_RESUME:
/* streamon */
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_STREAMON, &out_id)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_STREAMON, &out_id)) {
TDM_ERR("ioctl error : %d", errno);
return TDM_ERROR_BAD_REQUEST;
}
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_STREAMON, &cap_id)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_STREAMON, &cap_id)) {
TDM_ERR("ioctl error : %d", errno);
/* out stream off -> return */
return TDM_ERROR_BAD_REQUEST;
}
break;
- case IPP_CTRL_PAUSE:
+ case PP_CTRL_PAUSE:
/* streamoff */
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_STREAMOFF, &out_id)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_STREAMOFF, &out_id)) {
TDM_ERR("ioctl error : %d", errno);
return TDM_ERROR_BAD_REQUEST;
}
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_STREAMOFF, &cap_id)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_STREAMOFF, &cap_id)) {
TDM_ERR("ioctl error : %d", errno);
return TDM_ERROR_BAD_REQUEST;
}
break;
- case IPP_CTRL_STOP:
- if (ctrl.ctrl != IPP_CTRL_PAUSE) {
+ case PP_CTRL_STOP:
+ if (ctrl.ctrl != PP_CTRL_PAUSE) {
/* streamoff */
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_STREAMOFF, &out_id)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_STREAMOFF, &out_id)) {
TDM_ERR("ioctl error : %d", errno);
return TDM_ERROR_BAD_REQUEST;
}
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_STREAMOFF, &cap_id)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_STREAMOFF, &cap_id)) {
TDM_ERR("ioctl error : %d", errno);
return TDM_ERROR_BAD_REQUEST;
}
/* reqbufs(0) */
reqBuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
reqBuf.memory = V4L2_MEMORY_DMABUF;
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf)) {
TDM_ERR("ioctl error : %d", errno);
return TDM_ERROR_BAD_REQUEST;
}
reqBuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
- if (0 > ioctl(pp_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[idx], VIDIOC_REQBUFS, &reqBuf)) {
TDM_ERR("ioctl error : %d", errno);
return TDM_ERROR_BAD_REQUEST;
}
if (found_prop)
found_prop->status = ctrl.ctrl;
- TDM_DBG("pp %p(%d). Success. prop_id(%d) ", pp_data, pp_data->stamp, ctrl.prop_id);
+ TDM_DBG("pp %p(%d). Success. prop_id(%d) ", pp_v4l2_data, pp_v4l2_data->stamp, ctrl.prop_id);
return TDM_ERROR_NONE;
}
static void
-_tdm_exynos_pp_destroy_task(tdm_exynos_pp_data *pp_data, tdm_exynos_pp_task * task)
+_tdm_exynos_pp_v4l2_destroy_task(tdm_exynos_pp_v4l2_data *pp_v4l2_data, tdm_exynos_pp_v4l2_task * task)
{
int i;
for (i = 0; i < task->max_step; i++) {
if (task->buffers[i].dst)
tbm_surface_internal_unref(task->buffers[i].dst);
}
- TDM_DBG("pp %p(%d). Task %p(%d) released", pp_data, pp_data->stamp, task, task->stamp);
+ TDM_DBG("pp %p(%d). Task %p(%d) released", pp_v4l2_data, pp_v4l2_data->stamp, task, task->stamp);
if (task->attach_buffer)
free(task->attach_buffer);
}
static tdm_error
-_tdm_exynos_pp_worker(tdm_exynos_pp_data *pp_data)
+_tdm_exynos_pp_v4l2_worker(tdm_exynos_pp_v4l2_data *pp_v4l2_data)
{
- tdm_exynos_pp_task *next_task = NULL, *done_task = pp_data->current_task_p;
+ tdm_exynos_pp_v4l2_task *next_task = NULL, *done_task = pp_v4l2_data->current_task_p;
if (done_task && done_task->status == TASK_DONE) {
unsigned int next_step = done_task->current_step + 1;
/* double operation*/
if (next_step < done_task->max_step) {
TDM_DBG("pp %p(%d). Task %p(%d) setup next step %d of %d",
- pp_data, pp_data->stamp, done_task, done_task->stamp,
+ pp_v4l2_data, pp_v4l2_data->stamp, done_task, done_task->stamp,
next_step, done_task->max_step);
- if (_tdm_exynos_pp_queue(pp_data, done_task->prop_id[next_step],
+ if (_tdm_exynos_pp_v4l2_queue(pp_v4l2_data, done_task->prop_id[next_step],
done_task->buffers[next_step].src,
done_task->buffers[next_step].dst,
- IPP_BUF_ENQUEUE) != TDM_ERROR_NONE) {
+ PP_BUF_ENQUEUE) != TDM_ERROR_NONE) {
return TDM_ERROR_OPERATION_FAILED;
}
done_task->status = TASK_CONVERTING;
return TDM_ERROR_NONE;
}
- pp_data->current_task_p = NULL;
- if (done_task->done_func && !pp_data->roadmap.step_info[done_task->current_step].sync) {
+ pp_v4l2_data->current_task_p = NULL;
+ if (done_task->done_func && !pp_v4l2_data->roadmap.step_info[done_task->current_step].sync) {
TDM_DBG("done_task call, Return src %p dst %p",
done_task->buffers[0].src, done_task->buffers[done_task->max_step-1].dst);
- done_task->done_func(pp_data, done_task->buffers[0].src,
+ done_task->done_func(pp_v4l2_data, done_task->buffers[0].src,
done_task->buffers[done_task->max_step-1].dst,
done_task->done_user_data);
} else {
- TDM_WRN("pp %p(%d). No done func", pp_data, pp_data->stamp);
+ TDM_WRN("pp %p(%d). No done func", pp_v4l2_data, pp_v4l2_data->stamp);
}
- _tdm_exynos_pp_destroy_task(pp_data, done_task);
+ _tdm_exynos_pp_v4l2_destroy_task(pp_v4l2_data, done_task);
return TDM_ERROR_NONE;
}
- if (!LIST_IS_EMPTY(&pp_data->pending_tasks_list)) {
- next_task = (tdm_exynos_pp_task *)container_of(pp_data->pending_tasks_list.prev, next_task, link);
- if (pp_data->sync)
+ if (!LIST_IS_EMPTY(&pp_v4l2_data->pending_tasks_list)) {
+ next_task = (tdm_exynos_pp_v4l2_task *)container_of(pp_v4l2_data->pending_tasks_list.prev, next_task, link);
+ if (pp_v4l2_data->sync)
LIST_DEL(&next_task->link);
}
- if (next_task && pp_data->new_buffers) {
+ if (next_task && pp_v4l2_data->new_buffers) {
TDM_DBG("pp %p(%d). Task %p(%d) setup next step %d of %d",
- pp_data, pp_data->stamp, next_task, next_task->stamp,
+ pp_v4l2_data, pp_v4l2_data->stamp, next_task, next_task->stamp,
next_task->current_step+1, next_task->max_step);
- if (_tdm_exynos_pp_queue(pp_data, next_task->prop_id[next_task->current_step],
+ if (_tdm_exynos_pp_v4l2_queue(pp_v4l2_data, next_task->prop_id[next_task->current_step],
next_task->buffers[next_task->current_step].src,
next_task->buffers[next_task->current_step].dst,
- IPP_BUF_ENQUEUE) != TDM_ERROR_NONE) {
+ PP_BUF_ENQUEUE) != TDM_ERROR_NONE) {
return TDM_ERROR_OPERATION_FAILED;
}
next_task->status = TASK_CONVERTING;
- pp_data->current_task_p = next_task;
+ pp_v4l2_data->current_task_p = next_task;
} else {
- TDM_DBG("pp %p(%d). Nothing to do", pp_data, pp_data->stamp);
+ TDM_DBG("pp %p(%d). Nothing to do", pp_v4l2_data, pp_v4l2_data->stamp);
}
return TDM_ERROR_NONE;
}
-tdm_error tdm_exynos_pp_task_done_handler(int fd, tdm_event_loop_mask mask, void *user_data)
+tdm_error tdm_exynos_pp_v4l2_task_done_handler(int fd, tdm_event_loop_mask mask, void *user_data)
{
- tdm_exynos_pp_data *pp_data = (tdm_exynos_pp_data *)(unsigned long) user_data;
- tdm_exynos_pp_task *done_task = NULL, *next_task = NULL;
+ tdm_exynos_pp_v4l2_data *pp_v4l2_data = (tdm_exynos_pp_v4l2_data *)(unsigned long) user_data;
+ tdm_exynos_pp_v4l2_task *done_task = NULL, *next_task = NULL;
- if (!pp_data) {
- TDM_ERR("invalid params %p ", pp_data);
+ if (!pp_v4l2_data) {
+ TDM_ERR("invalid params %p ", pp_v4l2_data);
return TDM_ERROR_INVALID_PARAMETER;
}
- if (!LIST_IS_EMPTY(&pp_data->pending_tasks_list)) {
- next_task = (tdm_exynos_pp_task *)container_of(pp_data->pending_tasks_list.next, next_task, link);
- pp_data->current_task_p = next_task;
+ if (!LIST_IS_EMPTY(&pp_v4l2_data->pending_tasks_list)) {
+ next_task = (tdm_exynos_pp_v4l2_task *)container_of(pp_v4l2_data->pending_tasks_list.next, next_task, link);
+ pp_v4l2_data->current_task_p = next_task;
LIST_DEL(&next_task->link);
}
/* remove event loop */
- pp_data->ref_count--;
- if (pp_data->ref_count == 0) {
- if (!pp_data->sync && (pp_data->event_source[0] && pp_data->event_source[1])) {
- tdm_event_loop_source_remove(pp_data->event_source[0]);
- tdm_event_loop_source_remove(pp_data->event_source[1]);
- pp_data->event_source[0] = NULL;
- pp_data->event_source[1] = NULL;
+ pp_v4l2_data->ref_count--;
+ if (pp_v4l2_data->ref_count == 0) {
+ if (!pp_v4l2_data->sync && (pp_v4l2_data->event_source[0] && pp_v4l2_data->event_source[1])) {
+ tdm_event_loop_source_remove(pp_v4l2_data->event_source[0]);
+ tdm_event_loop_source_remove(pp_v4l2_data->event_source[1]);
+ pp_v4l2_data->event_source[0] = NULL;
+ pp_v4l2_data->event_source[1] = NULL;
}
}
- if (fd != pp_data->v4l2_fd[0] && fd != pp_data->v4l2_fd[1]) {
- TDM_ERR("fd : %d , fd[0] %d , fd[1] %d", fd, pp_data->v4l2_fd[0], pp_data->v4l2_fd[1]);
+ if (fd != pp_v4l2_data->v4l2_fd[0] && fd != pp_v4l2_data->v4l2_fd[1]) {
+ TDM_ERR("fd : %d , fd[0] %d , fd[1] %d", fd, pp_v4l2_data->v4l2_fd[0], pp_v4l2_data->v4l2_fd[1]);
return TDM_ERROR_INVALID_PARAMETER;
}
- if (!pp_data->first_event) {
- TDM_DBG("pp %p(%d) got a first event. ", pp_data, pp_data->stamp);
- pp_data->first_event = 1;
+ if (!pp_v4l2_data->first_event) {
+ TDM_DBG("pp %p(%d) got a first event. ", pp_v4l2_data, pp_v4l2_data->stamp);
+ pp_v4l2_data->first_event = 1;
}
- if ((done_task = pp_data->current_task_p) == NULL) {
- TDM_ERR("pp %p(%d) received wrong event", pp_data, pp_data->stamp);
+ if ((done_task = pp_v4l2_data->current_task_p) == NULL) {
+ TDM_ERR("pp %p(%d) received wrong event", pp_v4l2_data, pp_v4l2_data->stamp);
return TDM_ERROR_INVALID_PARAMETER;
}
done_task->status = TASK_DONE;
- TDM_DBG("pp %p(%d). Task %p(%d) done step %d of %d", pp_data, pp_data->stamp, done_task, done_task->stamp,
+ TDM_DBG("pp %p(%d). Task %p(%d) done step %d of %d", pp_v4l2_data, pp_v4l2_data->stamp, done_task, done_task->stamp,
done_task->current_step+1, done_task->max_step);
/* dequeue */
- if (done_task->buffers[pp_data->current_task_p->current_step].src &&
- done_task->buffers[pp_data->current_task_p->current_step].dst) {
- _tdm_exynos_pp_queue(pp_data, done_task->prop_id[done_task->current_step],
- done_task->buffers[pp_data->current_task_p->current_step].src,
- done_task->buffers[pp_data->current_task_p->current_step].dst, IPP_BUF_DEQUEUE);
+ if (done_task->buffers[pp_v4l2_data->current_task_p->current_step].src &&
+ done_task->buffers[pp_v4l2_data->current_task_p->current_step].dst) {
+ _tdm_exynos_pp_v4l2_queue(pp_v4l2_data, done_task->prop_id[done_task->current_step],
+ done_task->buffers[pp_v4l2_data->current_task_p->current_step].src,
+ done_task->buffers[pp_v4l2_data->current_task_p->current_step].dst, PP_BUF_DEQUEUE);
}
- if (_tdm_exynos_pp_worker(pp_data) != TDM_ERROR_NONE) {
- TDM_ERR("pp %p(%d) worker return ERROR", pp_data,
- pp_data->stamp);
+ if (_tdm_exynos_pp_v4l2_worker(pp_v4l2_data) != TDM_ERROR_NONE) {
+ TDM_ERR("pp %p(%d) worker return ERROR", pp_v4l2_data,
+ pp_v4l2_data->stamp);
}
return TDM_ERROR_NONE;
}
tdm_error
-tdm_exynos_pp_get_capability(tdm_exynos_data *exynos_data, tdm_caps_pp *caps)
+tdm_exynos_pp_v4l2_get_capability(tdm_exynos_data *exynos_data, tdm_caps_pp *caps)
{
int i;
caps->formats = NULL;
if (NUM_PP_FORMAT) {
/* will be freed in frontend */
- caps->formats = calloc(1, sizeof pp_formats);
+ caps->formats = calloc(1, sizeof pp_v4l2_formats);
if (!caps->formats) {
TDM_ERR("alloc failed");
return TDM_ERROR_OUT_OF_MEMORY;
}
for (i = 0; i < caps->format_count; i++)
- caps->formats[i] = pp_formats[i];
+ caps->formats[i] = pp_v4l2_formats[i];
}
caps->min_w = 16;
tdm_pp *
-tdm_exynos_pp_create(tdm_exynos_data *exynos_data, tdm_error *error)
+tdm_exynos_pp_v4l2_create(tdm_exynos_data *exynos_data, tdm_error *error)
{
- tdm_exynos_pp_data *pp_data = calloc(1, sizeof(tdm_exynos_pp_data));
+ tdm_exynos_pp_v4l2_data *pp_v4l2_data = calloc(1, sizeof(tdm_exynos_pp_v4l2_data));
- if (!pp_data) {
+ if (!pp_v4l2_data) {
TDM_ERR("alloc failed");
if (error)
*error = TDM_ERROR_OUT_OF_MEMORY;
return NULL;
}
- if ((pp_data->v4l2_fd[0] = open("/dev/video50", O_RDWR)) < 0) {
+ if ((pp_v4l2_data->v4l2_fd[0] = open("/dev/video50", O_RDWR)) < 0) {
TDM_ERR("open error : %d", errno);
if (error)
*error = TDM_ERROR_OPERATION_FAILED;
- free(pp_data);
+ free(pp_v4l2_data);
return NULL;
}
- if ((pp_data->v4l2_fd[1] = open("/dev/video50", O_RDWR)) < 0) {
+ if ((pp_v4l2_data->v4l2_fd[1] = open("/dev/video50", O_RDWR)) < 0) {
TDM_ERR("open error : %d", errno);
- close(pp_data->v4l2_fd[0]);
+ close(pp_v4l2_data->v4l2_fd[0]);
if (error)
*error = TDM_ERROR_OPERATION_FAILED;
- free(pp_data);
+ free(pp_v4l2_data);
return NULL;
}
- pp_data->exynos_data = exynos_data;
- pp_data->stamp = pp_stamp++;
- pp_data->ref_count = 0;
- if (!pp_list_init) {
- pp_list_init = 1;
- LIST_INITHEAD(&pp_list);
+ pp_v4l2_data->exynos_data = exynos_data;
+ pp_v4l2_data->stamp = pp_v4l2_stamp++;
+ pp_v4l2_data->ref_count = 0;
+ if (!pp_v4l2_list_init) {
+ pp_v4l2_list_init = 1;
+ LIST_INITHEAD(&pp_v4l2_list);
}
- LIST_INITHEAD(&pp_data->pending_buffer_list);
- LIST_INITHEAD(&pp_data->pending_tasks_list);
- LIST_INITHEAD(&pp_data->prop_id_list);
- LIST_ADDTAIL(&pp_data->link, &pp_list);
- TDM_DBG("pp %p(%d). Create", pp_data, pp_data->stamp);
- return pp_data;
+ LIST_INITHEAD(&pp_v4l2_data->pending_buffer_list);
+ LIST_INITHEAD(&pp_v4l2_data->pending_tasks_list);
+ LIST_INITHEAD(&pp_v4l2_data->prop_id_list);
+ LIST_ADDTAIL(&pp_v4l2_data->link, &pp_v4l2_list);
+ TDM_DBG("pp %p(%d). Create", pp_v4l2_data, pp_v4l2_data->stamp);
+ return pp_v4l2_data;
}
void
-exynos_pp_destroy(tdm_pp *pp)
+exynos_pp_v4l2_destroy(tdm_pp *pp)
{
- tdm_exynos_pp_data *pp_data = (tdm_exynos_pp_data *) pp;
- tdm_exynos_pp_buffer *b = NULL, *bb = NULL;
- tdm_exynos_pp_task *task = NULL, *next_task = NULL;
+ tdm_exynos_pp_v4l2_data *pp_v4l2_data = (tdm_exynos_pp_v4l2_data *) pp;
+ tdm_exynos_pp_v4l2_buffer *b = NULL, *bb = NULL;
+ tdm_exynos_pp_v4l2_task *task = NULL, *next_task = NULL;
tdm_exynos_prop_id *prop_id = NULL, *next_prop_id = NULL;
- RETURN_VOID_IF_FAIL(_tdm_exynos_pp_check_struct(pp_data));
- TDM_DBG("pp %p(%d). Destroy", pp_data, pp_data->stamp);
+ RETURN_VOID_IF_FAIL(_tdm_exynos_pp_v4l2_check_struct(pp_v4l2_data));
+ TDM_DBG("pp %p(%d). Destroy", pp_v4l2_data, pp_v4l2_data->stamp);
- if (!pp_data->sync && (pp_data->event_source[0] && pp_data->event_source[1])) {
- tdm_event_loop_source_remove(pp_data->event_source[0]);
- tdm_event_loop_source_remove(pp_data->event_source[1]);
- pp_data->event_source[0] = NULL;
- pp_data->event_source[1] = NULL;
+ if (!pp_v4l2_data->sync && (pp_v4l2_data->event_source[0] && pp_v4l2_data->event_source[1])) {
+ tdm_event_loop_source_remove(pp_v4l2_data->event_source[0]);
+ tdm_event_loop_source_remove(pp_v4l2_data->event_source[1]);
+ pp_v4l2_data->event_source[0] = NULL;
+ pp_v4l2_data->event_source[1] = NULL;
}
- if (pp_data->current_task_p && pp_data->current_task_p->status == TASK_CONVERTING) {
- _tdm_exynos_pp_queue(pp_data, pp_data->current_task_p->prop_id[pp_data->current_task_p->current_step],
- pp_data->current_task_p->buffers[pp_data->current_task_p->current_step].src,
- pp_data->current_task_p->buffers[pp_data->current_task_p->current_step].dst, IPP_BUF_DEQUEUE);
- _tdm_exynos_pp_destroy_task(pp_data, pp_data->current_task_p);
+ if (pp_v4l2_data->current_task_p && pp_v4l2_data->current_task_p->status == TASK_CONVERTING) {
+ _tdm_exynos_pp_v4l2_queue(pp_v4l2_data, pp_v4l2_data->current_task_p->prop_id[pp_v4l2_data->current_task_p->current_step],
+ pp_v4l2_data->current_task_p->buffers[pp_v4l2_data->current_task_p->current_step].src,
+ pp_v4l2_data->current_task_p->buffers[pp_v4l2_data->current_task_p->current_step].dst, PP_BUF_DEQUEUE);
+ _tdm_exynos_pp_v4l2_destroy_task(pp_v4l2_data, pp_v4l2_data->current_task_p);
}
- LIST_FOR_EACH_ENTRY_SAFE(task, next_task, &pp_data->pending_tasks_list, link) {
+ LIST_FOR_EACH_ENTRY_SAFE(task, next_task, &pp_v4l2_data->pending_tasks_list, link) {
LIST_DEL(&task->link);
- _tdm_exynos_pp_destroy_task(pp_data, task);
+ _tdm_exynos_pp_v4l2_destroy_task(pp_v4l2_data, task);
}
- LIST_FOR_EACH_ENTRY_SAFE(b, bb, &pp_data->pending_buffer_list, link) {
+ LIST_FOR_EACH_ENTRY_SAFE(b, bb, &pp_v4l2_data->pending_buffer_list, link) {
LIST_DEL(&b->link);
free(b);
}
- LIST_FOR_EACH_ENTRY_SAFE(prop_id, next_prop_id, &pp_data->prop_id_list, link) {
- _tdm_exynos_pp_cmd(pp_data, prop_id->prop_id, IPP_STOP);
+ LIST_FOR_EACH_ENTRY_SAFE(prop_id, next_prop_id, &pp_v4l2_data->prop_id_list, link) {
+ _tdm_exynos_pp_v4l2_cmd(pp_v4l2_data, prop_id->prop_id, PP_STOP);
}
- if (pp_data->v4l2_fd[1])
- close(pp_data->v4l2_fd[1]);
+ if (pp_v4l2_data->v4l2_fd[1])
+ close(pp_v4l2_data->v4l2_fd[1]);
- if (pp_data->v4l2_fd[0])
- close(pp_data->v4l2_fd[0]);
+ if (pp_v4l2_data->v4l2_fd[0])
+ close(pp_v4l2_data->v4l2_fd[0]);
- pp_data->exynos_data = NULL;
+ pp_v4l2_data->exynos_data = NULL;
- LIST_DEL(&pp_data->link);
- free(pp_data);
+ LIST_DEL(&pp_v4l2_data->link);
+ free(pp_v4l2_data);
}
static tdm_error
-_exynos_pp_get_scale_leap(unsigned int src, unsigned int dst,
+_exynos_pp_v4l2_get_scale_leap(unsigned int src, unsigned int dst,
unsigned int *leap_array, unsigned int *size)
{
unsigned int i = 0;
}
static tdm_error
-_exynos_pp_make_roadmap(tdm_exynos_pp_data *pp_data, tdm_info_pp *info)
+_exynos_pp_v4l2_make_roadmap(tdm_exynos_pp_v4l2_data *pp_v4l2_data, tdm_info_pp *info)
{
unsigned int height_leap[PP_MAX_STEP], width_leap[PP_MAX_STEP],
src_height = (info->transform % 2) ? info->src_config.pos.w : info->src_config.pos.h,
src_width = (info->transform % 2) ? info->src_config.pos.h : info->src_config.pos.w;
TDM_DBG("Height %u", info->src_config.pos.h);
- if (_exynos_pp_get_scale_leap(src_height,
+ if (_exynos_pp_v4l2_get_scale_leap(src_height,
info->dst_config.pos.h,
height_leap,
&height_leap_size) != TDM_ERROR_NONE) {
return TDM_ERROR_OPERATION_FAILED;
}
TDM_DBG("Width %u", info->src_config.pos.w);
- if (_exynos_pp_get_scale_leap(src_width,
+ if (_exynos_pp_v4l2_get_scale_leap(src_width,
info->dst_config.pos.w,
width_leap,
&width_leap_size) != TDM_ERROR_NONE) {
max_size = (width_leap_size > height_leap_size ? width_leap_size :
height_leap_size);
- memcpy(&pp_data->new_roadmap.step_info[0], info, sizeof(tdm_info_pp));
- pp_data->new_roadmap.step_info[0].dst_config.pos.h = height_leap[0];
- pp_data->new_roadmap.step_info[0].dst_config.pos.w = width_leap[0];
+ memcpy(&pp_v4l2_data->new_roadmap.step_info[0], info, sizeof(tdm_info_pp));
+ pp_v4l2_data->new_roadmap.step_info[0].dst_config.pos.h = height_leap[0];
+ pp_v4l2_data->new_roadmap.step_info[0].dst_config.pos.w = width_leap[0];
max_size = (width_leap_size > height_leap_size ? width_leap_size :
height_leap_size);
for (i = 1; i < max_size; i++) {
- pp_data->new_roadmap.step_info[i - 1].dst_config.pos.w =
+ pp_v4l2_data->new_roadmap.step_info[i - 1].dst_config.pos.w =
width_leap[(((i - 1) < width_leap_size) ? (i - 1) : (width_leap_size - 1))];
- pp_data->new_roadmap.step_info[i - 1].dst_config.pos.h =
+ pp_v4l2_data->new_roadmap.step_info[i - 1].dst_config.pos.h =
height_leap[(((i - 1) < height_leap_size) ? (i - 1) : (height_leap_size - 1))];
- pp_data->new_roadmap.step_info[i - 1].dst_config.size.h = pp_data->new_roadmap.step_info[i - 1].dst_config.pos.w;
- pp_data->new_roadmap.step_info[i - 1].dst_config.size.v = pp_data->new_roadmap.step_info[i - 1].dst_config.pos.h;
- pp_data->new_roadmap.step_info[i].transform = TDM_TRANSFORM_NORMAL;
- pp_data->new_roadmap.step_info[i].src_config = pp_data->new_roadmap.step_info[i - 1].dst_config;
- pp_data->new_roadmap.step_info[i].dst_config = pp_data->new_roadmap.step_info[i - 1].dst_config;
- pp_data->new_roadmap.step_info[i].src_config.pos.x = 0;
- pp_data->new_roadmap.step_info[i].src_config.pos.y = 0;
- pp_data->new_roadmap.step_info[i].dst_config.pos.x = 0;
- pp_data->new_roadmap.step_info[i].dst_config.pos.y = 0;
- pp_data->new_roadmap.step_info[i].sync = pp_data->new_roadmap.step_info[i - 1].sync;
- pp_data->new_roadmap.step_info[i].flags = pp_data->new_roadmap.step_info[i - 1].flags;
- }
- memcpy(&pp_data->new_roadmap.step_info[max_size - 1].dst_config, &info->dst_config, sizeof(tdm_info_config));
- pp_data->new_roadmap.max_step = max_size;
+ pp_v4l2_data->new_roadmap.step_info[i - 1].dst_config.size.h = pp_v4l2_data->new_roadmap.step_info[i - 1].dst_config.pos.w;
+ pp_v4l2_data->new_roadmap.step_info[i - 1].dst_config.size.v = pp_v4l2_data->new_roadmap.step_info[i - 1].dst_config.pos.h;
+ pp_v4l2_data->new_roadmap.step_info[i].transform = TDM_TRANSFORM_NORMAL;
+ pp_v4l2_data->new_roadmap.step_info[i].src_config = pp_v4l2_data->new_roadmap.step_info[i - 1].dst_config;
+ pp_v4l2_data->new_roadmap.step_info[i].dst_config = pp_v4l2_data->new_roadmap.step_info[i - 1].dst_config;
+ pp_v4l2_data->new_roadmap.step_info[i].src_config.pos.x = 0;
+ pp_v4l2_data->new_roadmap.step_info[i].src_config.pos.y = 0;
+ pp_v4l2_data->new_roadmap.step_info[i].dst_config.pos.x = 0;
+ pp_v4l2_data->new_roadmap.step_info[i].dst_config.pos.y = 0;
+ pp_v4l2_data->new_roadmap.step_info[i].sync = pp_v4l2_data->new_roadmap.step_info[i - 1].sync;
+ pp_v4l2_data->new_roadmap.step_info[i].flags = pp_v4l2_data->new_roadmap.step_info[i - 1].flags;
+ }
+ memcpy(&pp_v4l2_data->new_roadmap.step_info[max_size - 1].dst_config, &info->dst_config, sizeof(tdm_info_config));
+ pp_v4l2_data->new_roadmap.max_step = max_size;
return TDM_ERROR_NONE;
}
tdm_error
-exynos_pp_set_info(tdm_pp *pp, tdm_info_pp *info)
+exynos_pp_v4l2_set_info(tdm_pp *pp, tdm_info_pp *info)
{
- tdm_exynos_pp_data *pp_data = (tdm_exynos_pp_data *) pp;
+ tdm_exynos_pp_v4l2_data *pp_v4l2_data = (tdm_exynos_pp_v4l2_data *) pp;
tdm_error ret = TDM_ERROR_NONE;
int cap_id = 0, out_id = 0;
unsigned int i;
- tdm_exynos_pp_task *task = NULL, *next_task = NULL, *done_task = NULL;
+ tdm_exynos_pp_v4l2_task *task = NULL, *next_task = NULL, *done_task = NULL;
RETURN_VAL_IF_FAIL(info, TDM_ERROR_INVALID_PARAMETER);
- RETURN_VAL_IF_FAIL(_tdm_exynos_pp_check_struct(pp_data), TDM_ERROR_INVALID_PARAMETER);
- TDM_DBG("pp %p(%d). Set new info.", pp_data, pp_data->stamp);
+ RETURN_VAL_IF_FAIL(_tdm_exynos_pp_v4l2_check_struct(pp_v4l2_data), TDM_ERROR_INVALID_PARAMETER);
+ TDM_DBG("pp %p(%d). Set new info.", pp_v4l2_data, pp_v4l2_data->stamp);
- if (_exynos_pp_make_roadmap(pp_data, info) != TDM_ERROR_NONE) {
- TDM_ERR("pp %p(%d). Wrong convertation settings", pp_data, pp_data->stamp);
+ if (_exynos_pp_v4l2_make_roadmap(pp_v4l2_data, info) != TDM_ERROR_NONE) {
+ TDM_ERR("pp %p(%d). Wrong convertation settings", pp_v4l2_data, pp_v4l2_data->stamp);
return TDM_ERROR_INVALID_PARAMETER;
}
- pp_data->roadmap_changed = 1;
- pp_data->sync = info->sync;
+ pp_v4l2_data->roadmap_changed = 1;
+ pp_v4l2_data->sync = info->sync;
/* error case (set_info->attach->set_info) - remove previous attach buffer */
- if (pp_data->new_buffers == 1) {
- LIST_FOR_EACH_ENTRY_SAFE(task, next_task, &pp_data->pending_tasks_list, link) {
+ if (pp_v4l2_data->new_buffers == 1) {
+ LIST_FOR_EACH_ENTRY_SAFE(task, next_task, &pp_v4l2_data->pending_tasks_list, link) {
LIST_DEL(&task->link);
if (task->done_func) {
- task->done_func(pp_data, task->buffers[0].src,
+ task->done_func(pp_v4l2_data, task->buffers[0].src,
task->buffers[task->max_step-1].dst,
task->done_user_data);
}
- _tdm_exynos_pp_destroy_task(pp_data, task);
+ _tdm_exynos_pp_v4l2_destroy_task(pp_v4l2_data, task);
}
TDM_WRN("error case : set_info->attach->set_info");
- pp_data->new_buffers = 0;
+ pp_v4l2_data->new_buffers = 0;
}
/* reset ref_count */
- pp_data->ref_count = 0;
+ pp_v4l2_data->ref_count = 0;
/* copy roadmap*/
- if (pp_data->roadmap_changed) {
- _tdm_exynos_pp_roadmap_copy(&pp_data->roadmap, &pp_data->new_roadmap);
- pp_data->roadmap_changed = 0;
- _tdm_exynos_pp_roadmap_print(&pp_data->roadmap);
+ if (pp_v4l2_data->roadmap_changed) {
+ _tdm_exynos_pp_v4l2_roadmap_copy(&pp_v4l2_data->roadmap, &pp_v4l2_data->new_roadmap);
+ pp_v4l2_data->roadmap_changed = 0;
+ _tdm_exynos_pp_v4l2_roadmap_print(&pp_v4l2_data->roadmap);
}
/* event loop remove */
- if (!pp_data->sync && (pp_data->event_source[0] && pp_data->event_source[1])) {
- tdm_event_loop_source_remove(pp_data->event_source[0]);
- tdm_event_loop_source_remove(pp_data->event_source[1]);
- pp_data->event_source[0] = NULL;
- pp_data->event_source[1] = NULL;
+ if (!pp_v4l2_data->sync && (pp_v4l2_data->event_source[0] && pp_v4l2_data->event_source[1])) {
+ tdm_event_loop_source_remove(pp_v4l2_data->event_source[0]);
+ tdm_event_loop_source_remove(pp_v4l2_data->event_source[1]);
+ pp_v4l2_data->event_source[0] = NULL;
+ pp_v4l2_data->event_source[1] = NULL;
}
/* now converting buffer handling */
- if (pp_data->current_task_p && pp_data->current_task_p->status == TASK_CONVERTING) {
- tdm_exynos_pp_task *done_task = pp_data->current_task_p;
- _tdm_exynos_pp_queue(pp_data, done_task->prop_id[done_task->current_step],
+ if (pp_v4l2_data->current_task_p && pp_v4l2_data->current_task_p->status == TASK_CONVERTING) {
+ tdm_exynos_pp_v4l2_task *done_task = pp_v4l2_data->current_task_p;
+ _tdm_exynos_pp_v4l2_queue(pp_v4l2_data, done_task->prop_id[done_task->current_step],
done_task->buffers[done_task->current_step].src,
- done_task->buffers[done_task->current_step].dst, IPP_BUF_DEQUEUE);
- pp_data->current_task_p = NULL;
+ done_task->buffers[done_task->current_step].dst, PP_BUF_DEQUEUE);
+ pp_v4l2_data->current_task_p = NULL;
- if (!LIST_IS_EMPTY(&pp_data->pending_tasks_list)) {
- next_task = (tdm_exynos_pp_task *)container_of(pp_data->pending_tasks_list.next, next_task, link);
+ if (!LIST_IS_EMPTY(&pp_v4l2_data->pending_tasks_list)) {
+ next_task = (tdm_exynos_pp_v4l2_task *)container_of(pp_v4l2_data->pending_tasks_list.next, next_task, link);
LIST_DEL(&next_task->link);
}
if (done_task->done_func) {
- done_task->done_func(pp_data, done_task->buffers[0].src,
+ done_task->done_func(pp_v4l2_data, done_task->buffers[0].src,
done_task->buffers[done_task->max_step-1].dst,
done_task->done_user_data);
}
if (done_task)
- _tdm_exynos_pp_destroy_task(pp_data, done_task);
+ _tdm_exynos_pp_v4l2_destroy_task(pp_v4l2_data, done_task);
}
/* pending task list handling */
- while (!LIST_IS_EMPTY(&pp_data->pending_tasks_list)) {
+ while (!LIST_IS_EMPTY(&pp_v4l2_data->pending_tasks_list)) {
/*find pending list*/
- next_task = (tdm_exynos_pp_task *)container_of(pp_data->pending_tasks_list.next, next_task, link);
+ next_task = (tdm_exynos_pp_v4l2_task *)container_of(pp_v4l2_data->pending_tasks_list.next, next_task, link);
LIST_DEL(&next_task->link);
if (next_task) {
/* qbuf */
TDM_DBG("pp %p(%d). Task %p(%d) setup next step %d of %d",
- pp_data, pp_data->stamp, next_task, next_task->stamp,
+ pp_v4l2_data, pp_v4l2_data->stamp, next_task, next_task->stamp,
next_task->current_step+1, next_task->max_step);
- if (_tdm_exynos_pp_queue(pp_data, next_task->prop_id[next_task->current_step],
+ if (_tdm_exynos_pp_v4l2_queue(pp_v4l2_data, next_task->prop_id[next_task->current_step],
next_task->buffers[next_task->current_step].src,
next_task->buffers[next_task->current_step].dst,
- IPP_BUF_ENQUEUE) != TDM_ERROR_NONE) {
+ PP_BUF_ENQUEUE) != TDM_ERROR_NONE) {
return TDM_ERROR_OPERATION_FAILED;
}
next_task->status = TASK_CONVERTING;
- pp_data->current_task_p = next_task;
+ pp_v4l2_data->current_task_p = next_task;
/* dqbuf */
- done_task = pp_data->current_task_p;
+ done_task = pp_v4l2_data->current_task_p;
int prop_id = done_task->prop_id[done_task->current_step];
int idx = prop_id - 1;
- _tdm_exynos_pp_queue(pp_data, prop_id, done_task->buffers[idx].src, done_task->buffers[idx].dst, IPP_BUF_DEQUEUE);
- pp_data->current_task_p->status = TASK_DONE;
+ _tdm_exynos_pp_v4l2_queue(pp_v4l2_data, prop_id, done_task->buffers[idx].src, done_task->buffers[idx].dst, PP_BUF_DEQUEUE);
+ pp_v4l2_data->current_task_p->status = TASK_DONE;
/* double operation */
/* buffer release */
- pp_data->current_task_p = NULL;
+ pp_v4l2_data->current_task_p = NULL;
if (done_task->done_func) {
- done_task->done_func(pp_data, done_task->buffers[0].src,
+ done_task->done_func(pp_v4l2_data, done_task->buffers[0].src,
done_task->buffers[done_task->max_step-1].dst,
done_task->done_user_data);
}
if (done_task)
- _tdm_exynos_pp_destroy_task(pp_data, done_task);
+ _tdm_exynos_pp_v4l2_destroy_task(pp_v4l2_data, done_task);
}
}
/* Stream OFF */
out_id = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
cap_id = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
- if (0 > ioctl(pp_data->v4l2_fd[0], VIDIOC_STREAMOFF, &out_id)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[0], VIDIOC_STREAMOFF, &out_id)) {
TDM_ERR("ioctl error : %d", errno);
return TDM_ERROR_BAD_REQUEST;
}
- if (0 > ioctl(pp_data->v4l2_fd[0], VIDIOC_STREAMOFF, &cap_id)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[0], VIDIOC_STREAMOFF, &cap_id)) {
TDM_ERR("ioctl error : %d", errno);
return TDM_ERROR_BAD_REQUEST;
}
- /* pp_set call */
- for (i = 0; i < pp_data->roadmap.max_step; i++) {
- pp_data->roadmap.prop_id[i] = _tdm_exynos_pp_set(pp_data, &pp_data->roadmap.step_info[i], i + 1);
- if (pp_data->roadmap.prop_id[i] <= 0) {
- TDM_ERR("pp %p(%d). Can't setup converter", pp_data, pp_data->stamp);
+ /* pp_v4l2_set call */
+ for (i = 0; i < pp_v4l2_data->roadmap.max_step; i++) {
+ pp_v4l2_data->roadmap.prop_id[i] = _tdm_exynos_pp_v4l2_set(pp_v4l2_data, &pp_v4l2_data->roadmap.step_info[i], i + 1);
+ if (pp_v4l2_data->roadmap.prop_id[i] <= 0) {
+ TDM_ERR("pp %p(%d). Can't setup converter", pp_v4l2_data, pp_v4l2_data->stamp);
return TDM_ERROR_BAD_REQUEST;
}
}
/* stream ON */
- if (0 > ioctl(pp_data->v4l2_fd[0], VIDIOC_STREAMON, &out_id)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[0], VIDIOC_STREAMON, &out_id)) {
TDM_ERR("ioctl error : %d", errno);
return TDM_ERROR_BAD_REQUEST;
}
- if (0 > ioctl(pp_data->v4l2_fd[0], VIDIOC_STREAMON, &cap_id)) {
+ if (0 > ioctl(pp_v4l2_data->v4l2_fd[0], VIDIOC_STREAMON, &cap_id)) {
TDM_ERR("ioctl error : %d", errno);
/* out stream off -> return */
return TDM_ERROR_BAD_REQUEST;
}
tdm_error
-exynos_pp_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst)
+exynos_pp_v4l2_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst)
{
- tdm_exynos_pp_data *pp_data = (tdm_exynos_pp_data *) pp;
- tdm_exynos_pp_buffer *buffer;
+ tdm_exynos_pp_v4l2_data *pp_v4l2_data = (tdm_exynos_pp_v4l2_data *) pp;
+ tdm_exynos_pp_v4l2_buffer *buffer;
RETURN_VAL_IF_FAIL(src, TDM_ERROR_INVALID_PARAMETER);
RETURN_VAL_IF_FAIL(dst, TDM_ERROR_INVALID_PARAMETER);
- RETURN_VAL_IF_FAIL(_tdm_exynos_pp_check_struct(pp_data), TDM_ERROR_INVALID_PARAMETER);
+ RETURN_VAL_IF_FAIL(_tdm_exynos_pp_v4l2_check_struct(pp_v4l2_data), TDM_ERROR_INVALID_PARAMETER);
/* error case (attach -> attach) */
- if (pp_data->new_buffers == 1) {
+ if (pp_v4l2_data->new_buffers == 1) {
TDM_ERR("error case : attach -> attach");
return TDM_ERROR_NOT_IMPLEMENTED;
}
/* check max attach buffer count */
- pp_data->ref_count++;
- if (pp_data->ref_count > MAX_ATTACH_BUFFER) {
- pp_data->ref_count = 4;
+ pp_v4l2_data->ref_count++;
+ if (pp_v4l2_data->ref_count > MAX_ATTACH_BUFFER) {
+ pp_v4l2_data->ref_count = 4;
TDM_ERR("exceed maximum attach number 4");
return TDM_ERROR_NOT_IMPLEMENTED;
}
- buffer = calloc(1, sizeof(tdm_exynos_pp_buffer));
+ buffer = calloc(1, sizeof(tdm_exynos_pp_v4l2_buffer));
if (!buffer) {
- TDM_ERR("pp %p(%d). Alloc failed", pp_data, pp_data->stamp);
+ TDM_ERR("pp %p(%d). Alloc failed", pp_v4l2_data, pp_v4l2_data->stamp);
return TDM_ERROR_NONE;
}
buffer->index = 0;
buffer->src = src;
buffer->dst = dst;
- pp_data->new_buffers = 1;
+ pp_v4l2_data->new_buffers = 1;
- TDM_DBG("pp %p(%d). Attach src %p dst %p buffers", pp_data, pp_data->stamp, buffer->src, buffer->dst);
- LIST_ADDTAIL(&buffer->link, &pp_data->pending_buffer_list);
+ TDM_DBG("pp %p(%d). Attach src %p dst %p buffers", pp_v4l2_data, pp_v4l2_data->stamp, buffer->src, buffer->dst);
+ LIST_ADDTAIL(&buffer->link, &pp_v4l2_data->pending_buffer_list);
/* add pending_tasks_list */
- if (_tdm_exynos_pp_make_new_tasks(pp_data) < 0) {
- TDM_ERR("pp %p(%d). Can't create new task", pp_data, pp_data->stamp);
+ if (_tdm_exynos_pp_v4l2_make_new_tasks(pp_v4l2_data) < 0) {
+ TDM_ERR("pp %p(%d). Can't create new task", pp_v4l2_data, pp_v4l2_data->stamp);
return TDM_ERROR_BAD_REQUEST;
}
}
static int
-_tdm_exynos_pp_make_new_tasks(tdm_exynos_pp_data *pp_data)
+_tdm_exynos_pp_v4l2_make_new_tasks(tdm_exynos_pp_v4l2_data *pp_v4l2_data)
{
- tdm_exynos_pp_buffer *main_buffer = NULL, *b = NULL, *bb = NULL;
- tdm_exynos_pp_task *new_task = NULL;
+ tdm_exynos_pp_v4l2_buffer *main_buffer = NULL, *b = NULL, *bb = NULL;
+ tdm_exynos_pp_v4l2_task *new_task = NULL;
int i;
- LIST_FOR_EACH_ENTRY_SAFE(b, bb, &pp_data->pending_buffer_list, link) {
+ LIST_FOR_EACH_ENTRY_SAFE(b, bb, &pp_v4l2_data->pending_buffer_list, link) {
main_buffer = b;
- if ((new_task = calloc(1, sizeof(tdm_exynos_pp_task))) == NULL) {
+ if ((new_task = calloc(1, sizeof(tdm_exynos_pp_v4l2_task))) == NULL) {
TDM_ERR("Out of memory");
return -1;
}
- memcpy(new_task->prop_id, pp_data->roadmap.prop_id, sizeof(unsigned int)*PP_MAX_STEP);
+ memcpy(new_task->prop_id, pp_v4l2_data->roadmap.prop_id, sizeof(unsigned int)*PP_MAX_STEP);
new_task->stamp = task_stamp++;
- new_task->max_step = pp_data->roadmap.max_step;
+ new_task->max_step = pp_v4l2_data->roadmap.max_step;
new_task->current_step = 0;
- new_task->done_func = pp_data->done_func;
- new_task->done_user_data = pp_data->done_user_data;
+ new_task->done_func = pp_v4l2_data->done_func;
+ new_task->done_user_data = pp_v4l2_data->done_user_data;
tbm_surface_internal_ref(main_buffer->src);
new_task->buffers[0].src = main_buffer->src;
tbm_surface_internal_ref(main_buffer->dst);
LIST_DEL(&b->link);
for (i = 1; i < new_task->max_step; i++) {
- new_task->buffers[i-1].dst = tbm_surface_create(pp_data->roadmap.step_info[i-1].dst_config.size.h,
- pp_data->roadmap.step_info[i-1].dst_config.size.v,
- pp_data->roadmap.step_info[i-1].dst_config.format);
+ new_task->buffers[i-1].dst = tbm_surface_create(pp_v4l2_data->roadmap.step_info[i-1].dst_config.size.h,
+ pp_v4l2_data->roadmap.step_info[i-1].dst_config.size.v,
+ pp_v4l2_data->roadmap.step_info[i-1].dst_config.format);
tbm_surface_internal_ref(new_task->buffers[i-1].dst);
new_task->buffers[i].src = new_task->buffers[i-1].dst;
}
- LIST_ADDTAIL(&new_task->link, &pp_data->pending_tasks_list);
- TDM_DBG("pp %p(%d). Add new src %p dst %p buffer", pp_data, pp_data->stamp, main_buffer->src, main_buffer->dst);
+ LIST_ADDTAIL(&new_task->link, &pp_v4l2_data->pending_tasks_list);
+ TDM_DBG("pp %p(%d). Add new src %p dst %p buffer", pp_v4l2_data, pp_v4l2_data->stamp, main_buffer->src, main_buffer->dst);
TDM_DBG("To New task %p(%d)", new_task, new_task->stamp);
}
if (main_buffer == NULL) {
- TDM_WRN("pp %p(%d) buffer list is empty. Nothing to do", pp_data, pp_data->stamp);
+ TDM_WRN("pp %p(%d) buffer list is empty. Nothing to do", pp_v4l2_data, pp_v4l2_data->stamp);
return 0;
}
return 1;
}
tdm_error
-exynos_pp_commit(tdm_pp *pp)
+exynos_pp_v4l2_commit(tdm_pp *pp)
{
unsigned int prop_id, idx;
- tdm_exynos_pp_data *pp_data = (tdm_exynos_pp_data *) pp;
+ tdm_exynos_pp_v4l2_data *pp_v4l2_data = (tdm_exynos_pp_v4l2_data *) pp;
tdm_error ret = TDM_ERROR_NONE;
- tdm_exynos_pp_task *done_task = NULL;
+ tdm_exynos_pp_v4l2_task *done_task = NULL;
- RETURN_VAL_IF_FAIL(_tdm_exynos_pp_check_struct(pp_data), TDM_ERROR_INVALID_PARAMETER);
+ RETURN_VAL_IF_FAIL(_tdm_exynos_pp_v4l2_check_struct(pp_v4l2_data), TDM_ERROR_INVALID_PARAMETER);
- if (pp_data->new_buffers == 1) {
- /* call pp_worker for Qbuf */
- ret = _tdm_exynos_pp_worker(pp_data);
- pp_data->new_buffers = 0;
+ if (pp_v4l2_data->new_buffers == 1) {
+ /* call pp_v4l2_worker for Qbuf */
+ ret = _tdm_exynos_pp_v4l2_worker(pp_v4l2_data);
+ pp_v4l2_data->new_buffers = 0;
/* sync mode */
- if (pp_data->roadmap.step_info[pp_data->current_task_p->current_step].sync) {
- pp_data->current_task_p->status = TASK_CONVERTING;
- done_task = pp_data->current_task_p;
- prop_id = pp_data->current_task_p->prop_id[pp_data->current_task_p->current_step];
+ if (pp_v4l2_data->roadmap.step_info[pp_v4l2_data->current_task_p->current_step].sync) {
+ pp_v4l2_data->current_task_p->status = TASK_CONVERTING;
+ done_task = pp_v4l2_data->current_task_p;
+ prop_id = pp_v4l2_data->current_task_p->prop_id[pp_v4l2_data->current_task_p->current_step];
idx = prop_id - 1;
- _tdm_exynos_pp_queue(pp_data, prop_id, done_task->buffers[idx].src, done_task->buffers[idx].dst, IPP_BUF_DEQUEUE);
- pp_data->current_task_p->status = TASK_DONE;
+ _tdm_exynos_pp_v4l2_queue(pp_v4l2_data, prop_id, done_task->buffers[idx].src, done_task->buffers[idx].dst, PP_BUF_DEQUEUE);
+ pp_v4l2_data->current_task_p->status = TASK_DONE;
unsigned int next_step = done_task->current_step + 1;
/* double operation */
if (next_step < done_task->max_step) {
TDM_DBG("pp %p(%d). Task %p(%d) setup next step %d of %d",
- pp_data, pp_data->stamp, done_task, done_task->stamp,
+ pp_v4l2_data, pp_v4l2_data->stamp, done_task, done_task->stamp,
next_step, done_task->max_step);
- if (_tdm_exynos_pp_queue(pp_data, done_task->prop_id[next_step],
+ if (_tdm_exynos_pp_v4l2_queue(pp_v4l2_data, done_task->prop_id[next_step],
done_task->buffers[next_step].src,
done_task->buffers[next_step].dst,
- IPP_BUF_ENQUEUE) != TDM_ERROR_NONE) {
+ PP_BUF_ENQUEUE) != TDM_ERROR_NONE) {
return TDM_ERROR_OPERATION_FAILED;
}
done_task->status = TASK_CONVERTING;
- prop_id = pp_data->current_task_p->prop_id[next_step];
+ prop_id = pp_v4l2_data->current_task_p->prop_id[next_step];
idx = prop_id - 1;
- _tdm_exynos_pp_queue(pp_data, prop_id, done_task->buffers[idx].src, done_task->buffers[idx].dst, IPP_BUF_DEQUEUE);
- pp_data->current_task_p->status = TASK_DONE;
+ _tdm_exynos_pp_v4l2_queue(pp_v4l2_data, prop_id, done_task->buffers[idx].src, done_task->buffers[idx].dst, PP_BUF_DEQUEUE);
+ pp_v4l2_data->current_task_p->status = TASK_DONE;
++(done_task->current_step);
}
- pp_data->current_task_p = NULL;
+ pp_v4l2_data->current_task_p = NULL;
if (done_task->done_func) {
- done_task->done_func(pp_data, done_task->buffers[0].src,
+ done_task->done_func(pp_v4l2_data, done_task->buffers[0].src,
done_task->buffers[done_task->max_step-1].dst,
done_task->done_user_data);
}
if (done_task)
- _tdm_exynos_pp_destroy_task(pp_data, done_task);
+ _tdm_exynos_pp_v4l2_destroy_task(pp_v4l2_data, done_task);
}
} else {
/* error case (attach->commit->commit(error)) */
}
tdm_error
-exynos_pp_set_done_handler(tdm_pp *pp, tdm_pp_done_handler func, void *user_data)
+exynos_pp_v4l2_set_done_handler(tdm_pp *pp, tdm_pp_done_handler func, void *user_data)
{
- tdm_exynos_pp_data *pp_data = (tdm_exynos_pp_data *) pp;
+ tdm_exynos_pp_v4l2_data *pp_v4l2_data = (tdm_exynos_pp_v4l2_data *) pp;
RETURN_VAL_IF_FAIL(func, TDM_ERROR_INVALID_PARAMETER);
- RETURN_VAL_IF_FAIL(_tdm_exynos_pp_check_struct(pp_data), TDM_ERROR_INVALID_PARAMETER);
- TDM_DBG("pp %p(%d). Set done handler func %p", pp_data, pp_data->stamp, func);
- pp_data->done_func = func;
- pp_data->done_user_data = user_data;
+ RETURN_VAL_IF_FAIL(_tdm_exynos_pp_v4l2_check_struct(pp_v4l2_data), TDM_ERROR_INVALID_PARAMETER);
+ TDM_DBG("pp %p(%d). Set done handler func %p", pp_v4l2_data, pp_v4l2_data->stamp, func);
+ pp_v4l2_data->done_func = func;
+ pp_v4l2_data->done_user_data = user_data;
return TDM_ERROR_NONE;
}
projects / platform / adaptation / samsung_exynos / libtdm-exynos-deconfb.git / commitdiff