From: jinhyung.jo Date: Thu, 2 Apr 2015 09:28:47 +0000 (+0900) Subject: maru-camera: Code refactoring for MacOS X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=dae5bfabe0b9061e1245ac339a53b7d142ff3f45;p=sdk%2Femulator%2Fqemu.git maru-camera: Code refactoring for MacOS Modified the MacOS module. - modified in accordance with a common module changes - TODO: translate to AVFoundation because of the QTKit is deprecated in OSX 10.9 Change-Id: I2db0db25c0889e428b411189caa47fb62c24d977 Signed-off-by: Jinhyung Jo --- diff --git a/tizen/src/hw/pci/maru_camera_darwin.m b/tizen/src/hw/pci/maru_camera_darwin.m index 26f29afb7a..337677d7b3 100644 --- a/tizen/src/hw/pci/maru_camera_darwin.m +++ b/tizen/src/hw/pci/maru_camera_darwin.m @@ -28,6 +28,11 @@ * */ +/*********************************************/ +/* Must Translate to AVFoundation */ +/*********************************************/ + + #import #import #import @@ -36,32 +41,24 @@ #include "qemu-common.h" #include "maru_camera.h" #include "maru_camera_convert.h" +#include "videodev2_min.h" #include "debug_ch.h" MULTI_DEBUG_CHANNEL(tizen, camera); -#define MARUCAM_THREAD_NAME "marucam_worker_thread" - -typedef struct tagMaruCamConvertPixfmt { - uint32_t fmt; /* fourcc */ - uint32_t bpp; /* bits per pixel, 0 for compressed formats */ - uint32_t needs_conversion; -} MaruCamConvertPixfmt; - - -static MaruCamConvertPixfmt supported_dst_pixfmts[] = { - { V4L2_PIX_FMT_YUYV, 16, 0 }, - { V4L2_PIX_FMT_UYVY, 16, 0 }, - { V4L2_PIX_FMT_YUV420, 12, 0 }, - { V4L2_PIX_FMT_YVU420, 12, 0 }, +static uint32_t support_fmts[] = { + V4L2_PIX_FMT_YUYV, + V4L2_PIX_FMT_UYVY, + V4L2_PIX_FMT_YUV420, + V4L2_PIX_FMT_YVU420, }; -typedef struct tagMaruCamConvertFrameInfo { +struct MCFrame { uint32_t width; uint32_t height; -} MaruCamConvertFrameInfo; +}; -static MaruCamConvertFrameInfo supported_dst_frames[] = { +static struct MCFrame support_frames[] = { { 640, 480 }, { 352, 288 }, { 320, 240 }, @@ -69,41 +66,6 @@ static MaruCamConvertFrameInfo supported_dst_frames[] = { { 160, 120 }, }; -#define MARUCAM_CTRL_VALUE_MAX 20 -#define MARUCAM_CTRL_VALUE_MIN 1 -#define MARUCAM_CTRL_VALUE_MID 10 -#define MARUCAM_CTRL_VALUE_STEP 1 - -enum { - _MC_THREAD_PAUSED, - _MC_THREAD_STREAMON, - _MC_THREAD_STREAMOFF, -}; - -#if 0 -struct marucam_qctrl { - uint32_t id; - uint32_t hit; - long min; - long max; - long step; - long init_val; -}; - -static struct marucam_qctrl qctrl_tbl[] = { - { V4L2_CID_BRIGHTNESS, 0, }, - { V4L2_CID_CONTRAST, 0, }, - { V4L2_CID_SATURATION, 0, }, - { V4L2_CID_SHARPNESS, 0, }, -}; -#endif - -static MaruCamState *g_state; - -static uint32_t ready_count; -static uint32_t cur_fmt_idx; -static uint32_t cur_frame_idx; - /*********************************** * Mac camera helper functions ***********************************/ @@ -148,19 +110,19 @@ static uint32_t corevideo_to_fourcc(uint32_t cv_pix_fmt) BOOL mCaptureIsStarted; } -- (MaruCameraDriver *)init; -- (int)startCapture:(int)width :(int)height; +- (id)init; +- (int)startCapture:(int)width setHeight:(int)height; - (void)stopCapture; - (int)readFrame:(void *)video_buf; -- (int)setCaptureFormat:(int)width :(int)height :(int)pix_format; -- (int)getCaptureFormat:(int)width :(int)height :(int)pix_format; +- (int)setCaptureFormat:(int)width setHeight:(int)height setFormat:(int)format; +- (int)getCaptureFormat:(int)width setHeight:(int)height setFormat:(int)format; - (BOOL)deviceStatus; @end @implementation MaruCameraDriver -- (MaruCameraDriver *)init +- (id)init { BOOL success = NO; NSError *error; @@ -217,16 +179,16 @@ static uint32_t corevideo_to_fourcc(uint32_t cv_pix_fmt) } } -- (int)startCapture:(int)width :(int)height +- (int)startCapture:(int)width setHeight:(int)height { int ret = -1; if (![mCaptureSession isRunning]) { /* Set width & height, using default pixel format to capture */ NSDictionary *attributes = [NSDictionary dictionaryWithObjectsAndKeys: - [NSNumber numberWithInt: width], (id)kCVPixelBufferWidthKey, - [NSNumber numberWithInt: height], (id)kCVPixelBufferHeightKey, - nil]; + [NSNumber numberWithInt:width], (id)kCVPixelBufferWidthKey, + [NSNumber numberWithInt:height], (id)kCVPixelBufferHeightKey, + nil]; [mCaptureVideoPreviewOutput setPixelBufferAttributes:attributes]; [mCaptureSession startRunning]; } else { @@ -235,9 +197,9 @@ static uint32_t corevideo_to_fourcc(uint32_t cv_pix_fmt) } if ([mCaptureSession isRunning]) { - while(!mCaptureIsStarted) { + while (!mCaptureIsStarted) { /* Wait Until Capture is started */ - [[NSRunLoop currentRunLoop] runUntilDate: [NSDate dateWithTimeIntervalSinceNow: 0.5]]; + [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.5]]; } ret = 0; } @@ -248,9 +210,9 @@ static uint32_t corevideo_to_fourcc(uint32_t cv_pix_fmt) { if ([mCaptureSession isRunning]) { [mCaptureSession stopRunning]; - while([mCaptureSession isRunning]) { + while ([mCaptureSession isRunning]) { /* Wait Until Capture is stopped */ - [[NSRunLoop currentRunLoop] runUntilDate: [NSDate dateWithTimeIntervalSinceNow: 0.1]]; + [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.1]]; } } @@ -294,7 +256,7 @@ static uint32_t corevideo_to_fourcc(uint32_t cv_pix_fmt) return -1; } -- (int)setCaptureFormat:(int)width :(int)height :(int)pix_format +- (int)setCaptureFormat:(int)width setHeight:(int)height setFormat:(int)format { int ret = -1; NSDictionary *attributes; @@ -306,17 +268,17 @@ static uint32_t corevideo_to_fourcc(uint32_t cv_pix_fmt) /* Set the pixel buffer attributes before running the capture session */ if (![mCaptureSession isRunning]) { - if (pix_format) { + if (format) { attributes = [NSDictionary dictionaryWithObjectsAndKeys: - [NSNumber numberWithInt: width], (id)kCVPixelBufferWidthKey, - [NSNumber numberWithInt: height], (id)kCVPixelBufferHeightKey, - [NSNumber numberWithInt: pix_format], (id)kCVPixelBufferPixelFormatTypeKey, - nil]; + [NSNumber numberWithInt:width], (id)kCVPixelBufferWidthKey, + [NSNumber numberWithInt:height], (id)kCVPixelBufferHeightKey, + [NSNumber numberWithInt:format], (id)kCVPixelBufferPixelFormatTypeKey, + nil]; } else { attributes = [NSDictionary dictionaryWithObjectsAndKeys: - [NSNumber numberWithInt: width], (id)kCVPixelBufferWidthKey, - [NSNumber numberWithInt: height], (id)kCVPixelBufferHeightKey, - nil]; + [NSNumber numberWithInt:width], (id)kCVPixelBufferWidthKey, + [NSNumber numberWithInt:height], (id)kCVPixelBufferHeightKey, + nil]; } [mCaptureVideoPreviewOutput setPixelBufferAttributes:attributes]; ret = 0; @@ -328,7 +290,7 @@ static uint32_t corevideo_to_fourcc(uint32_t cv_pix_fmt) return ret; } -- (int)getCaptureFormat:(int)width :(int)height :(int)pix_format +- (int)getCaptureFormat:(int)width setHeight:(int)height setFormat:(int)format { return 0; } @@ -371,104 +333,101 @@ static uint32_t corevideo_to_fourcc(uint32_t cv_pix_fmt) ** Maru Camera APIs *****************************************************************/ -typedef struct MaruCameraDevice MaruCameraDevice; -struct MaruCameraDevice { +typedef struct MCBackendMac { + MaruCamBackend base; + /* Maru camera device object. */ MaruCameraDriver *driver; -}; -/* Golbal representation of the Maru camera */ -MaruCameraDevice *mcd = NULL; + uint32_t src_fmt; + uint32_t dst_width; + uint32_t dst_height; + uint32_t dst_fmt; +} MCBackendMac; -static int is_streamon() +static int is_streamon(MaruCamState *state) { int st; - qemu_mutex_lock(&g_state->thread_mutex); - st = g_state->streamon; - qemu_mutex_unlock(&g_state->thread_mutex); + qemu_mutex_lock(&state->thread_mutex); + st = state->streamon; + qemu_mutex_unlock(&state->thread_mutex); return (st == _MC_THREAD_STREAMON); } -static void __raise_err_intr() +static void __raise_err_intr(MaruCamState *state) { - qemu_mutex_lock(&g_state->thread_mutex); - if (g_state->streamon == _MC_THREAD_STREAMON) { - g_state->req_frame = 0; /* clear request */ - g_state->isr = 0x08; /* set a error flag of rasing a interrupt */ - qemu_bh_schedule(g_state->tx_bh); + qemu_mutex_lock(&state->thread_mutex); + if (state->streamon == _MC_THREAD_STREAMON) { + state->req_frame = 0; /* clear request */ + state->isr = 0x08; /* set a error flag of rasing a interrupt */ + qemu_bh_schedule(state->tx_bh); } - qemu_mutex_unlock(&g_state->thread_mutex); + qemu_mutex_unlock(&state->thread_mutex); } -static int marucam_device_read_frame() +static int backend_mac_read_frame(MaruCamState *state) { int ret; void *tmp_buf; + MCBackendMac *backend = (MCBackendMac *)(state->backend); - qemu_mutex_lock(&g_state->thread_mutex); - if (g_state->streamon == _MC_THREAD_STREAMON) { -#if 0 - if (ready_count < MARUCAM_SKIPFRAMES) { - /* skip a frame cause first some frame are distorted */ - ++ready_count; - TRACE("Skip %d frame\n", ready_count); - qemu_mutex_unlock(&g_state->thread_mutex); - return 0; - } -#endif - if (g_state->req_frame == 0) { + qemu_mutex_lock(&state->thread_mutex); + if (state->streamon == _MC_THREAD_STREAMON) { + if (state->req_frame == 0) { TRACE("There is no request\n"); - qemu_mutex_unlock(&g_state->thread_mutex); + qemu_mutex_unlock(&state->thread_mutex); return 0; } /* Grab the camera frame into temp buffer */ - tmp_buf = g_state->vaddr + g_state->buf_size * (g_state->req_frame - 1); - ret = [mcd->driver readFrame: tmp_buf]; + tmp_buf = state->fb_ptr + state->buf_size * (state->req_frame - 1); + ret = [backend->driver readFrame: tmp_buf]; if (ret < 0) { ERR("%s, Capture error\n", __func__); - qemu_mutex_unlock(&g_state->thread_mutex); - __raise_err_intr(); + qemu_mutex_unlock(&state->thread_mutex); + __raise_err_intr(state); return -1; } else if (!ret) { - qemu_mutex_unlock(&g_state->thread_mutex); + qemu_mutex_unlock(&state->thread_mutex); return 0; } - g_state->req_frame = 0; /* clear request */ - g_state->isr |= 0x01; /* set a flag of rasing a interrupt */ - qemu_bh_schedule(g_state->tx_bh); + state->req_frame = 0; /* clear request */ + state->isr |= 0x01; /* set a flag of rasing a interrupt */ + qemu_bh_schedule(state->tx_bh); } else { - qemu_mutex_unlock(&g_state->thread_mutex); + qemu_mutex_unlock(&state->thread_mutex); return -1; } - qemu_mutex_unlock(&g_state->thread_mutex); + qemu_mutex_unlock(&state->thread_mutex); return 0; } /* Worker thread to grab frames to the preview window */ static void *marucam_worker_thread(void *thread_param) { + MaruCamState *state = (MaruCamState *)thread_param; + MCBackendMac *backend = (MCBackendMac *)(state->backend); + while (1) { - qemu_mutex_lock(&g_state->thread_mutex); - g_state->streamon = _MC_THREAD_PAUSED; - qemu_cond_wait(&g_state->thread_cond, &g_state->thread_mutex); - qemu_mutex_unlock(&g_state->thread_mutex); + qemu_mutex_lock(&state->thread_mutex); + state->streamon = _MC_THREAD_PAUSED; + qemu_cond_wait(&state->thread_cond, &state->thread_mutex); + qemu_mutex_unlock(&state->thread_mutex); - if (g_state->destroying) { + if (state->destroying) { break; } - ready_count = 0; - qemu_mutex_lock(&g_state->thread_mutex); - g_state->streamon = _MC_THREAD_STREAMON; - qemu_mutex_unlock(&g_state->thread_mutex); + qemu_mutex_lock(&state->thread_mutex); + state->streamon = _MC_THREAD_STREAMON; + qemu_mutex_unlock(&state->thread_mutex); INFO("Streaming on ......\n"); /* Loop: capture frame -> convert format -> render to screen */ while (1) { - if (is_streamon()) { - if (marucam_device_read_frame() < 0) { + if (is_streamon(state)) { + if (backend_mac_read_frame(state) < 0) { INFO("Streaming is off ...\n"); break; } else { @@ -485,28 +444,31 @@ static void *marucam_worker_thread(void *thread_param) return NULL; } -int marucam_device_check(int log_flag) +int marucam_device_check() { /* FIXME: check the device parameters */ - INFO("Checking camera device\n"); + INFO("[%s][Not Implemented] Checking camera device\n", __func__); return 1; } /********************************************** * MARU camera routines **********************************************/ -void marucam_device_init(MaruCamState *state) +static void backend_mac__init(MaruCamState *state) { - g_state = state; - g_state->destroying = false; + state->destroying = false; qemu_thread_create(&state->thread_id, MARUCAM_THREAD_NAME, marucam_worker_thread, - NULL, + (void *)state, QEMU_THREAD_JOINABLE); } -void marucam_device_exit(MaruCamState *state) +static void backend_mac_reset(MaruCamState *state) +{ +} + +static void backend_mac_exit(MaruCamState *state) { state->destroying = true; qemu_mutex_lock(&state->thread_mutex); @@ -515,257 +477,282 @@ void marucam_device_exit(MaruCamState *state) qemu_thread_join(&state->thread_id); } -/* MARUCAM_CMD_OPEN */ -void marucam_device_open(MaruCamState *state) +static void backend_mac_open(MaruCamState *state) { - MaruCamParam *param = state->param; - param->top = 0; + MCBackendMac *backend = (MCBackendMac *)(state->backend); - mcd = (MaruCameraDevice *)malloc(sizeof(MaruCameraDevice)); - if (mcd == NULL) { - ERR("%s: MaruCameraDevice allocate failed\n", __func__); - param->errCode = EINVAL; + backend->driver = [[MaruCameraDriver alloc] init]; + if (backend->driver == nil) { + ERR("Camera device open failed\n"); + [backend->driver dealloc]; + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } - memset(mcd, 0, sizeof(MaruCameraDevice)); - mcd->driver = [[MaruCameraDriver alloc] init]; - if (mcd->driver == nil) { - ERR("Camera device open failed\n"); - [mcd->driver dealloc]; - free(mcd); - param->errCode = EINVAL; + + /* Set default values, TODO: can be smart? */ + backend->dst_height = support_frames[0].height; + backend->dst_width = support_frames[0].width; + backend->dst_fmt = support_fmts[0]; + if ([backend->driver setCaptureFormat: backend->dst_width: backend->dst_height: 0] < 0) { + ERR("Set pixel format failed\n"); + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } - INFO("Camera opened!\n"); + + + INFO("Opend\n"); } -/* MARUCAM_CMD_CLOSE */ -void marucam_device_close(MaruCamState *state) +static void backend_mac_close(MaruCamState *state) { - MaruCamParam *param = state->param; - param->top = 0; + MCBackendMac *backend = (MCBackendMac *)(state->backend); - if (mcd != NULL) { - if (is_streamon()) { - marucam_device_stop_preview(state); - } - [mcd->driver dealloc]; - free(mcd); - mcd = NULL; + if (is_streamon(state)) { + state->backend->stream_off(state); + } + if (backend->driver != nil) { + [backend->driver dealloc]; } - /* marucam_reset_controls(); */ - INFO("Camera closed\n"); + INFO("Closed\n"); } -/* MARUCAM_CMD_START_PREVIEW */ -void marucam_device_start_preview(MaruCamState *state) +static void backend_mac_stream_on(MaruCamState *state) { - uint32_t width, height, pixfmt; - MaruCamParam *param = state->param; - param->top = 0; + MCBackendMac *backend = (MCBackendMac *)(state->backend); - width = supported_dst_frames[cur_frame_idx].width; - height = supported_dst_frames[cur_frame_idx].height; - pixfmt = supported_dst_pixfmts[cur_fmt_idx].fmt; - state->buf_size = get_sizeimage(pixfmt, width, height); + state->buf_size = get_sizeimage(backend->dst_fmt, + backend->dst_width, + backend->dst_height); - INFO("Pixfmt(%c%c%c%c), W:H(%d:%d), buf size(%u), frame idx(%d), fmt idx(%d)\n", + INFO("Pixfmt(%c%c%c%c), W:H(%u:%u), buf size(%u)\n", (char)(pixfmt), (char)(pixfmt >> 8), (char)(pixfmt >> 16), (char)(pixfmt >> 24), - width, height, state->buf_size, - cur_frame_idx, cur_fmt_idx); + backend->dst_width, backend->dst_height, state->buf_size); + INFO("Starting preview\n"); - if (mcd->driver == nil) { - ERR("%s: Start capture failed: vaild device", __func__); - param->errCode = EINVAL; + if (backend->driver == nil) { + ERR("%s: Start capture failed: invaild device", __func__); + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } - INFO("Starting preview ...\n"); - [mcd->driver startCapture: width: height]; + [backend->driver startCapture: width: height]; /* Enable the condition to capture frames now */ qemu_mutex_lock(&state->thread_mutex); qemu_cond_signal(&state->thread_cond); qemu_mutex_unlock(&state->thread_mutex); - while (!is_streamon()) { + while (!is_streamon(state)) { usleep(10000); } + + INFO("Streaming on ......\n"); } -/* MARUCAM_CMD_STOP_PREVIEW */ -void marucam_device_stop_preview(MaruCamState *state) +static void backend_mac_stream_off(MaruCamState *state) { - MaruCamParam *param = state->param; - param->top = 0; + MCBackendMac *backend = (MCBackendMac *)(state->backend); - if (is_streamon()) { + INFO("...... Streaming off\n"); + if (is_streamon(state)) { qemu_mutex_lock(&state->thread_mutex); state->streamon = _MC_THREAD_STREAMOFF; qemu_mutex_unlock(&state->thread_mutex); - while (is_streamon()) { + while (is_streamon(state)) { usleep(10000); } } - if (mcd->driver != nil) { - [mcd->driver stopCapture]; + if (backend->driver != nil) { + [backend->driver stopCapture]; } - state->buf_size = 0; - INFO("Stopping preview ...\n"); + + INFO("Stopping preview\n"); } -/* MARUCAM_CMD_S_PARAM */ -void marucam_device_s_param(MaruCamState *state) +static void backend_mac_s_parm(MaruCamState *state) { - MaruCamParam *param = state->param; - /* We use default FPS of the webcam */ - param->top = 0; } -/* MARUCAM_CMD_G_PARAM */ -void marucam_device_g_param(MaruCamState *state) +static void backend_mac_g_parm(MaruCamState *state) { - MaruCamParam *param = state->param; + struct v4l2_captureparm *cp = + (struct v4l2_captureparm *)state->io_ptr->data; /* We use default FPS of the webcam * return a fixed value on guest ini file (1/30). */ - param->top = 0; - param->stack[0] = 0x1000; /* V4L2_CAP_TIMEPERFRAME */ - param->stack[1] = 1; /* numerator */ - param->stack[2] = 30; /* denominator */ + cp->capability = V3L2_CAP_TIMEPERFRAME; + cp->timeperframe.numerator = 1; + cp->timeperframe.denominator = 30; } -/* MARUCAM_CMD_S_FMT */ -void marucam_device_s_fmt(MaruCamState *state) +static void backend_mac_s_fmt(MaruCamState *state) { - MaruCamParam *param = state->param; - uint32_t width, height, pixfmt, pidx, fidx; - - param->top = 0; - width = param->stack[0]; - height = param->stack[1]; - pixfmt = param->stack[2]; + uint32_t pidx, fidx; + struct v4l2_format *f = (struct v4l2_format *)state->io_ptr->data; + MCBackendMac *backend = (MCBackendMac *)(state->backend); - TRACE("Set format: width(%d), height(%d), pixfmt(%d, %.4s)\n", - width, height, pixfmt, (const char*)&pixfmt); + TRACE("Set format: w:h(%u:%u), pixfmt(%u, %.4s)\n", + f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.pixelformat, + (const char*)&(f->fmt.pix.pixelformat)); - for (fidx = 0; fidx < ARRAY_SIZE(supported_dst_frames); fidx++) { - if ((supported_dst_frames[fidx].width == width) && - (supported_dst_frames[fidx].height == height)) { + for (fidx = 0; fidx < ARRAY_SIZE(support_frames); fidx++) { + if ((support_frames[fidx].width == f->fmt.pix.width) && + (support_frames[fidx].height == f->fmt.pix.height)) { break; } } - if (fidx == ARRAY_SIZE(supported_dst_frames)) { - param->errCode = EINVAL; + if (fidx == ARRAY_SIZE(support_frames)) { + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } - - for (pidx = 0; pidx < ARRAY_SIZE(supported_dst_pixfmts); pidx++) { - if (supported_dst_pixfmts[pidx].fmt == pixfmt) { - TRACE("pixfmt index is match: %d\n", pidx); + for (pidx = 0; pidx < ARRAY_SIZE(support_fmts); pidx++) { + if (support_fmts[pidx] == f->fmt.pix.pixelformat) { + TRACE("pixfmt index is match: index(%u)\n", pidx); break; } } - if (pidx == ARRAY_SIZE(supported_dst_pixfmts)) { - param->errCode = EINVAL; + if (pidx == ARRAY_SIZE(support_fmts)) { + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } - if ((supported_dst_frames[cur_frame_idx].width != width) && - (supported_dst_frames[cur_frame_idx].height != height)) { - if (mcd->driver == nil || [mcd->driver setCaptureFormat: width: height: 0] < 0) { + if ((backend->dst_width != f->fmt.pix.width) && + (backend->dst_height != f->fmt.pix.height)) { + if ([backend->driver setCaptureFormat: f->fmt.pix.width: f->fmt.pix.height: 0] < 0) { ERR("Set pixel format failed\n"); - param->errCode = EINVAL; + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } - - TRACE("cur_frame_idx:%d, supported_dst_frames[cur_frame_idx].width:%d\n", - cur_frame_idx, supported_dst_frames[cur_frame_idx].width); } - cur_frame_idx = fidx; - cur_fmt_idx = pidx; - - pixfmt = supported_dst_pixfmts[cur_fmt_idx].fmt; - width = supported_dst_frames[cur_frame_idx].width; - height = supported_dst_frames[cur_frame_idx].height; + f->fmt.pix.width = backend->dst_width = support_frames[fidx].width; + f->fmt.pix.height = backend->dst_height = support_frames[fidx].height; + f->fmt.pix.pixelformat = backend->dst_fmt = support_fmts[pidx]; - param->stack[0] = width; - param->stack[1] = height; - param->stack[2] = 1; /* V4L2_FIELD_NONE */ - param->stack[3] = pixfmt; - param->stack[4] = get_bytesperline(pixfmt, width); - param->stack[5] = get_sizeimage(pixfmt, width, height); - param->stack[6] = 0; - param->stack[7] = 0; + f->fmt.pix.field = V4L2_FIELD_NONE; + f->fmt.pix.bytesperline = get_bytesperline(backend->dst_fmt, + backend->dst_width); + f->fmt.pix.sizeimage = get_sizeimage(backend->dst_fmt, + backend->dst_width, + backend->dst_height); + f->fmt.pix.colorspace = 0; + f->fmt.pix.priv = 0; - TRACE("Set device pixel format ...\n"); + TRACE("Set the format: w:h(%dx%d), fmt(0x%x), " + "bytesperline(%d), sizeimage(%d), colorspace(%d)\n", + f->fmt.pix.width, f->fmt.pix.height, + f->fmt.pix.pixelformat, f->fmt.pix.bytesperline, + f->fmt.pix.sizeimage, f->fmt.pix.colorspace); } -/* MARUCAM_CMD_G_FMT */ -void marucam_device_g_fmt(MaruCamState *state) +static void backend_mac_g_fmt(MaruCamState *state) { - uint32_t width, height, pixfmt; - MaruCamParam *param = state->param; + struct v4l2_format *f = (struct v4l2_format *)state->io_ptr->data; + MCBackendMac *backend = (MCBackendMac *)(state->backend); - param->top = 0; - pixfmt = supported_dst_pixfmts[cur_fmt_idx].fmt; - width = supported_dst_frames[cur_frame_idx].width; - height = supported_dst_frames[cur_frame_idx].height; + f->fmt.pix.width = backend->dst_width; + f->fmt.pix.height = backend->dst_height; + f->fmt.pix.pixelformat = backend->dst_fmt; + f->fmt.pix.field = V4L2_FIELD_NONE; + f->fmt.pix.bytesperline = get_bytesperline(backend->dst_fmt, + backend->dst_width); + f->fmt.pix.sizeimage = get_sizeimage(backend->dst_fmt, + backend->dst_width, + backend->dst_height); + f->fmt.pix.colorspace = 0; + f->fmt.pix.priv = 0; - param->stack[0] = width; - param->stack[1] = height; - param->stack[2] = 1; /* V4L2_FIELD_NONE */ - param->stack[3] = pixfmt; - param->stack[4] = get_bytesperline(pixfmt, width); - param->stack[5] = get_sizeimage(pixfmt, width, height); - param->stack[6] = 0; - param->stack[7] = 0; - - TRACE("Get device frame format ...\n"); + TRACE("Get the format: w:h(%dx%d), fmt(0x%x), " + "bytesperline(%d), sizeimage(%d), colorspace(%d)\n", + f->fmt.pix.width, f->fmt.pix.height, + f->fmt.pix.pixelformat, f->fmt.pix.bytesperline, + f->fmt.pix.sizeimage, f->fmt.pix.colorspace); } -void marucam_device_try_fmt(MaruCamState *state) +static void backend_mac_try_fmt(MaruCamState *state) { - TRACE("Try device frame format, use default setting ...\n"); + uint32_t i; + struct v4l2_format *f = (struct v4l2_format *)state->io_ptr->data; + + for (i = 0; i < ARRAY_SIZE(support_frames); i++) { + if ((support_frames[i].width == f->fmt.pix.width) && + (support_frames[i].height == f->fmt.pix.height)) { + break; + } + } + if (i == ARRAY_SIZE(support_frames)) { + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; + return; + } + for (i = 0; i < ARRAY_SIZE(support_fmts); i++) { + if (support_fmts[i] == f->fmt.pix.pixelformat) { + break; + } + } + if (i == ARRAY_SIZE(support_fmts)) { + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; + return; + } + + f->fmt.pix.field = V4L2_FIELD_NONE; + f->fmt.pix.bytesperline = get_bytesperline(f->fmt.pix.pixelformat, + f->fmt.pix.width); + f->fmt.pix.sizeimage = get_sizeimage(f->fmt.pix.pixelformat, + f->fmt.pix.width, + f->fmt.pix.height); + f->fmt.pix.colorspace = 0; + f->fmt.pix.priv = 0; + + TRACE("Check the format: w:h(%dx%d), pix_fmt(0x%x), " + "bytesperline(%d), sizeimage(%d), colorspace(%d)\n", + f->fmt.pix.width, f->fmt.pix.height, + f->fmt.pix.pixelformat, f->fmt.pix.bytesperline, + f->fmt.pix.sizeimage, f->fmt.pix.colorspace); } /* Get specific pixelformat description */ -void marucam_device_enum_fmt(MaruCamState *state) +static void backend_mac_enum_fmt(MaruCamState *state) { - uint32_t index; - MaruCamParam *param = state->param; - - param->top = 0; - index = param->stack[0]; + struct v4l2_fmtdesc *f = (struct v4l2_fmtdesc *)state->io_ptr->data; - if (index >= ARRAY_SIZE(supported_dst_pixfmts)) { - param->errCode = EINVAL; + if (f->index >= ARRAY_SIZE(support_fmts)) { + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } - param->stack[1] = 0; /* flags = NONE */ - param->stack[2] = supported_dst_pixfmts[index].fmt; /* pixelformat */ - switch (supported_dst_pixfmts[index].fmt) { + + f->flags = 0; /* flags = NONE */ + f->pixelformat = support_fmts[f->index]; + + /* set description */ + switch (support_fmts[f->index]) { case V4L2_PIX_FMT_YUYV: - memcpy(¶m->stack[3], "YUYV", 32); - break; - case V4L2_PIX_FMT_UYVY: - memcpy(¶m->stack[3], "UYVY", 32); + pstrcpy((char *)f->description, sizeof(f->description), "YUYV"); break; case V4L2_PIX_FMT_YUV420: - memcpy(¶m->stack[3], "YU12", 32); + pstrcpy((char *)f->description, sizeof(f->description), "YU12"); break; case V4L2_PIX_FMT_YVU420: - memcpy(¶m->stack[3], "YV12", 32); + pstrcpy((char *)f->description, sizeof(f->description), "YV12"); break; default: - param->errCode = EINVAL; + ERR("Invalid fixel format\n"); + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; break; } } @@ -773,104 +760,137 @@ void marucam_device_enum_fmt(MaruCamState *state) /* * QTKit don't support setting brightness, contrast, saturation & sharpness */ -void marucam_device_qctrl(MaruCamState *state) +static void backend_mac_query_ctrl(MaruCamState *state) { - uint32_t id, i; - /* long property, min, max, step, def_val, set_val; */ - char name[32] = {0,}; - MaruCamParam *param = state->param; - - param->top = 0; - id = param->stack[0]; + uint32_t i; + struct v4l2_queryctrl *qc = (struct v4l2_queryctrl *)state->io_ptr->data; + MCBackendMac *backend = (MCBackendMac *)(state->backend); - switch (id) { + /* NOTICE: Tizen MMFW hardcoded for control name + Do Not Modified the name + */ + switch (qc->id) { case V4L2_CID_BRIGHTNESS: - TRACE("V4L2_CID_BRIGHTNESS\n"); - memcpy((void *)name, (void *)"brightness", 32); + TRACE("Query : BRIGHTNESS\n"); + pstrcpy((char *)qc->name, sizeof(qc->name), "brightness"); i = 0; break; case V4L2_CID_CONTRAST: - TRACE("V4L2_CID_CONTRAST\n"); - memcpy((void *)name, (void *)"contrast", 32); + TRACE("Query : CONTRAST\n"); + pstrcpy((char *)qc->name, sizeof(qc->name), "contrast"); i = 1; break; case V4L2_CID_SATURATION: - TRACE("V4L2_CID_SATURATION\n"); - memcpy((void *)name, (void *)"saturation", 32); + TRACE("Query : SATURATION\n"); + pstrcpy((char *)qc->name, sizeof(qc->name), "saturation"); i = 2; break; case V4L2_CID_SHARPNESS: - TRACE("V4L2_CID_SHARPNESS\n"); - memcpy((void *)name, (void *)"sharpness", 32); + TRACE("Query : SHARPNESS\n"); + pstrcpy((char *)qc->name, sizeof(qc->name), "sharpness"); i = 3; break; default: - param->errCode = EINVAL; + ERR("Invalid control ID\n"); + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } - param->stack[0] = id; - param->stack[1] = MARUCAM_CTRL_VALUE_MIN; /* minimum */ - param->stack[2] = MARUCAM_CTRL_VALUE_MAX; /* maximum */ - param->stack[3] = MARUCAM_CTRL_VALUE_STEP; /* step */ - param->stack[4] = MARUCAM_CTRL_VALUE_MID; /* default_value */ - param->stack[5] = V4L2_CTRL_FLAG_SLIDER; - /* name field setting */ - memcpy(¶m->stack[6], (void *)name, sizeof(name)/sizeof(name[0])); + /* set fixed values by FW configuration file */ + qc->minimum = MARUCAM_CTRL_VALUE_MIN; /* minimum */ + qc->maximum = MARUCAM_CTRL_VALUE_MAX; /* maximum */ + qc->step = MARUCAM_CTRL_VALUE_STEP; /* step */ + qc->default_value = MARUCAM_CTRL_VALUE_MID; /* default_value */ + qc->flags = V4L2_CTRL_FLAG_SLIDER; } -void marucam_device_s_ctrl(MaruCamState *state) +static void backend_mac_s_ctrl(MaruCamState *state) { - INFO("Set control\n"); + INFO("[%s][Not Implemented] QTKit don't support setting " + " brightness, contrast, saturation & sharpness\n", __func__); } -void marucam_device_g_ctrl(MaruCamState *state) +static void backend_mac_g_ctrl(MaruCamState *state) { - INFO("Get control\n"); + INFO("[%s][Not Implemented] QTKit don't support getting " + " brightness, contrast, saturation & sharpness\n", __func__); } /* Get frame width & height */ -void marucam_device_enum_fsizes(MaruCamState *state) +static void backend_mac_enum_fsizes(MaruCamState *state) { - uint32_t index, pixfmt, i; - MaruCamParam *param = state->param; - - param->top = 0; - index = param->stack[0]; - pixfmt = param->stack[1]; + uint32_t i; + struct v4l2_frmsizeenum *fsize = + (struct v4l2_frmsizeenum *)state->io_ptr->data; - if (index >= ARRAY_SIZE(supported_dst_frames)) { - param->errCode = EINVAL; + if (fsize->index >= ARRAY_SIZE(support_frames)) { + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } - for (i = 0; i < ARRAY_SIZE(supported_dst_pixfmts); i++) { - if (supported_dst_pixfmts[i].fmt == pixfmt) { + for (i = 0; i < ARRAY_SIZE(support_fmts); i++) { + if (support_fmts[i] == fsize->pixel_format) { break; } } - if (i == ARRAY_SIZE(supported_dst_pixfmts)) { - param->errCode = EINVAL; + if (i == ARRAY_SIZE(support_fmts)) { + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } - param->stack[0] = supported_dst_frames[index].width; - param->stack[1] = supported_dst_frames[index].height; + fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE; + fsize->discrete.width = support_frames[fsize->index].width; + fsize->discrete.height = support_frames[fsize->index].height; } -void marucam_device_enum_fintv(MaruCamState *state) +static void backend_mac_enum_fintv(MaruCamState *state) { - MaruCamParam *param = state->param; - param->top = 0; + struct v4l2_frmivalenum *fival = + (struct v4l2_frmivalenum *)state->io_ptr->data; - /* switch by index(param->stack[0]) */ - switch (param->stack[0]) { + /* switch by index) */ + switch (fival->index) { case 0: - param->stack[1] = 30; /* denominator */ + /* we only use 1/30 frame interval */ + fival->type = V4L2_FRMIVAL_TYPE_DISCRETE; + fival->discrete.numerator = 1; + fival->discrete.denominator = 30; break; default: - param->errCode = EINVAL; + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } - param->stack[0] = 1; /* numerator */ +} + +MaruCamBackend *marucam_backend_create(MaruCamState *state) +{ + MCBackendMac *backend_mac; + + backend_mac = g_new0(MCBackendMac, 1); + + backend_mac->base.state = state; + backend_mac->base.init = backend_mac_init; + backend_mac->base.reset = backend_mac_reset; + backend_mac->base.release = backend_mac_release; + backend_mac->base.open = backend_mac_open; + backend_mac->base.close = backend_mac_close; + backend_mac->base.stream_on = backend_mac_stream_on; + backend_mac->base.stream_off = backend_mac_stream_off; + backend_mac->base.enum_fmt = backend_mac_enum_fmt; + backend_mac->base.try_fmt = backend_mac_try_fmt; + backend_mac->base.s_fmt = backend_mac_s_fmt; + backend_mac->base.g_fmt = backend_mac_g_fmt; + backend_mac->base.s_parm = backend_mac_s_parm; + backend_mac->base.g_parm = backend_mac_g_parm; + backend_mac->base.query_ctrl = backend_mac_query_ctrl; + backend_mac->base.s_ctrl = backend_mac_s_ctrl; + backend_mac->base.g_ctrl = backend_mac_g_ctrl; + backend_mac->base.enum_framesizes = backend_mac_enum_fsizes; + backend_mac->base.enum_frameintervals = backend_mac_enum_fintv; + + return &backend_mac->base; } diff --git a/tizen/src/hw/pci/maru_camera_win32.c b/tizen/src/hw/pci/maru_camera_win32.c index e5088b0a8b..60ce5580b3 100644 --- a/tizen/src/hw/pci/maru_camera_win32.c +++ b/tizen/src/hw/pci/maru_camera_win32.c @@ -1101,10 +1101,10 @@ typedef struct MCBackendWin { IGrabCallback *pCallback; uint32_t ready_count; - int32_t src_fmt; - int32_t dst_width; - int32_t dst_height; - int32_t dst_fmt; + uint32_t src_fmt; + uint32_t dst_width; + uint32_t dst_height; + uint32_t dst_fmt; void *buf; } MCBackendWin; @@ -1232,7 +1232,7 @@ static STDMETHODIMP_(void) DeleteMediaType(AM_MEDIA_TYPE *pmt) pmt->pbFormat = NULL; } if (pmt->pUnk != NULL) { - pmt->pUnk->lpVtbl->Release(pmt->pUnk); + IUnknown_Release(pmt->pUnk); pmt->pUnk = NULL; } @@ -2076,7 +2076,7 @@ static void backend_win_stream_on(MaruCamState *state) return; } - hr = backend->pMC->lpVtbl->Run(backend->pMC); + hr = IMediaControl_Run(backend->pMC); if (FAILED(hr)) { ERR("Failed to run media control. hr=0x%x\n", hr); state->io_ptr->err_code = EINVAL;