tizen/src/hw/svcamera_win32.c

   1 /*
   2  * Virtual Camera device(PCI) for Windows host.
   3  *
   4  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   5  *
   6  * Contact:
   7  * JinHyung Jo <jinhyung.jo@samsung.com>
   8  * YeongKyoon Lee <yeongkyoon.lee@samsung.com>
   9  * DongKyun Yun <dk77.yun@samsung.com>
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public License
  13  * as published by the Free Software Foundation; either version 2
  14  * of the License, or (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  24  *
  25  * Contributors:
  26  * - S-Core Co., Ltd
  27  *
  28  */
  29
  30
  31 #include "qemu-common.h"
  32 #include "svcamera.h"
  33 #include "pci.h"
  34 #include "kvm.h"
  35 #include "tizen/src/debug_ch.h"
  36
  37 #include "windows.h"
  38 #include "basetyps.h"
  39 #include "mmsystem.h"
  40
  41 MULTI_DEBUG_CHANNEL(tizen, camera_win32);
  42
  43 // V4L2 defines copy from videodev2.h
  44 #define V4L2_CTRL_FLAG_SLIDER       0x0020
  45
  46 #define V4L2_CTRL_CLASS_USER        0x00980000
  47 #define V4L2_CID_BASE               (V4L2_CTRL_CLASS_USER | 0x900)
  48 #define V4L2_CID_BRIGHTNESS         (V4L2_CID_BASE+0)
  49 #define V4L2_CID_CONTRAST           (V4L2_CID_BASE+1)
  50 #define V4L2_CID_SATURATION         (V4L2_CID_BASE+2)
  51 #define V4L2_CID_SHARPNESS          (V4L2_CID_BASE+27)
  52
  53 #define V4L2_PIX_FMT_YUYV    MAKEFOURCC('Y', 'U', 'Y', 'V') /* 16  YUV 4:2:2     */
  54 #define V4L2_PIX_FMT_YUV420  MAKEFOURCC('Y', 'U', '1', '2') /* 12  YUV 4:2:0     */
  55 #define V4L2_PIX_FMT_YVU420  MAKEFOURCC('Y', 'V', '1', '2') /* 12  YVU 4:2:0     */
  56
  57 enum {
  58     HWC_OPEN,
  59     HWC_CLOSE,
  60     HWC_START,
  61     HWC_STOP,
  62     HWC_S_FPS,
  63     HWC_G_FPS,
  64     HWC_S_FMT,
  65     HWC_G_FMT,
  66     HWC_TRY_FMT,
  67     HWC_ENUM_FMT,
  68     HWC_QCTRL,
  69     HWC_S_CTRL,
  70     HWC_G_CTRL,
  71     HWC_ENUM_FSIZES,
  72     HWC_ENUM_INTERVALS
  73 };
  74
  75 typedef enum tagVideoProcAmpProperty {
  76   VideoProcAmp_Brightness,
  77   VideoProcAmp_Contrast,
  78   VideoProcAmp_Hue,
  79   VideoProcAmp_Saturation,
  80   VideoProcAmp_Sharpness,
  81   VideoProcAmp_Gamma,
  82   VideoProcAmp_ColorEnable,
  83   VideoProcAmp_WhiteBalance,
  84   VideoProcAmp_BacklightCompensation,
  85   VideoProcAmp_Gain
  86 } VideoProcAmpProperty;
  87
  88 typedef struct tagHWCParam {
  89     long val1;
  90     long val2;
  91     long val3;
  92     long val4;
  93     long val5;
  94 } HWCParam;
  95
  96 typedef struct tagSVCamConvertPixfmt {
  97     uint32_t fmt;   /* fourcc */
  98     uint32_t bpp;   /* bits per pixel, 0 for compressed formats */
  99     uint32_t needs_conversion;
 100 } SVCamConvertPixfmt;
 101
 102 static SVCamConvertPixfmt supported_dst_pixfmts[] = {
 103         { V4L2_PIX_FMT_YUYV, 16, 0 },
 104         { V4L2_PIX_FMT_YUV420, 12, 0 },
 105         { V4L2_PIX_FMT_YVU420, 12, 0 },
 106 };
 107
 108 typedef struct tagSVCamConvertFrameInfo {
 109     uint32_t width;
 110     uint32_t height;
 111 } SVCamConvertFrameInfo;
 112
 113 static SVCamConvertFrameInfo supported_dst_frames[] = {
 114         { 640, 480 },
 115         { 352, 288 },
 116         { 320, 240 },
 117         { 176, 144 },
 118         { 160, 120 },
 119 };
 120
 121 #define SVCAM_CTRL_VALUE_MAX        20
 122 #define SVCAM_CTRL_VALUE_MIN        1
 123 #define SVCAM_CTRL_VALUE_MID        10
 124 #define SVCAM_CTRL_VALUE_STEP       1
 125
 126 struct svcam_qctrl {
 127     uint32_t id;
 128     uint32_t hit;
 129     long min;
 130     long max;
 131     long step;
 132     long init_val;
 133 };
 134
 135 static struct svcam_qctrl qctrl_tbl[] = {
 136     { V4L2_CID_BRIGHTNESS, 0, },
 137     { V4L2_CID_CONTRAST, 0, },
 138     { V4L2_CID_SATURATION,0, },
 139     { V4L2_CID_SHARPNESS, 0, },
 140 };
 141
 142 typedef int (STDAPICALLTYPE *CallbackFn)(ULONG dwSize, BYTE *pBuffer);
 143 typedef HRESULT (STDAPICALLTYPE *CTRLFN)(UINT, UINT, LPVOID);
 144 typedef HRESULT (STDAPICALLTYPE *SETCALLBACKFN)(CallbackFn);
 145
 146
 147 static HINSTANCE g_hInst = NULL;
 148 static SVCamState *g_state = NULL;
 149
 150 static CTRLFN SVCamCtrl;
 151 static SETCALLBACKFN SVCamSetCallbackFn;
 152
 153 static uint32_t cur_fmt_idx = 0;
 154 static uint32_t cur_frame_idx = 0;
 155
 156 void v4lconvert_yuyv_to_yuv420(const unsigned char *src, unsigned char *dest,
 157         uint32_t width, uint32_t height, uint32_t yvu);
 158
 159
 160 static long value_convert_from_guest(long min, long max, long value)
 161 {
 162     double rate = 0.0;
 163     long dist = 0, ret = 0;
 164
 165     dist = max - min;
 166
 167     if (dist < SVCAM_CTRL_VALUE_MAX) {
 168         rate = (double)SVCAM_CTRL_VALUE_MAX / (double)dist;
 169         ret = min + (int32_t)(value / rate);
 170     } else {
 171         rate = (double)dist / (double)SVCAM_CTRL_VALUE_MAX;
 172         ret = min + (int32_t)(rate * value);
 173     }
 174     return ret;
 175 }
 176
 177 static long value_convert_to_guest(long min, long max, long value)
 178 {
 179     double rate  = 0.0;
 180     long dist = 0, ret = 0;
 181
 182     dist = max - min;
 183
 184     if (dist < SVCAM_CTRL_VALUE_MAX) {
 185         rate = (double)SVCAM_CTRL_VALUE_MAX / (double)dist;
 186         ret = (int32_t)((double)(value - min) * rate);
 187     } else {
 188         rate = (double)dist / (double)SVCAM_CTRL_VALUE_MAX;
 189         ret = (int32_t)((double)(value - min) / rate);
 190     }
 191
 192     return ret;
 193 }
 194
 195 static int STDAPICALLTYPE svcam_device_callbackfn(ULONG dwSize, BYTE *pBuffer)
 196 {
 197     static uint32_t index = 0;
 198     uint32_t width, height;
 199     width = supported_dst_frames[cur_frame_idx].width;
 200     height = supported_dst_frames[cur_frame_idx].height;
 201     void *buf = g_state->vaddr + (g_state->buf_size * index);
 202
 203     switch (supported_dst_pixfmts[cur_fmt_idx].fmt) {
 204     case V4L2_PIX_FMT_YUV420:
 205         v4lconvert_yuyv_to_yuv420(pBuffer, buf, width, height, 0);
 206         break;
 207     case V4L2_PIX_FMT_YVU420:
 208         v4lconvert_yuyv_to_yuv420(pBuffer, buf, width, height, 1);
 209         break;
 210     case V4L2_PIX_FMT_YUYV:
 211         memcpy(buf, (void*)pBuffer, dwSize);
 212         break;
 213     }
 214     index = !index;
 215
 216     if (g_state->req_frame) {
 217         qemu_irq_raise(g_state->dev.irq[2]);
 218         g_state->req_frame = 0;
 219     }
 220     return 1;
 221 }
 222
 223 // SVCAM_CMD_INIT
 224 void svcam_device_init(SVCamState* state)
 225 {
 226     SVCamThreadInfo *thread = state->thread;
 227
 228     pthread_cond_init(&thread->thread_cond, NULL);
 229     pthread_mutex_init(&thread->mutex_lock, NULL);
 230
 231     g_state = state;
 232 }
 233
 234 // SVCAM_CMD_OPEN
 235 void svcam_device_open(SVCamState* state)
 236 {
 237     HRESULT hr;
 238     SVCamParam *param = state->thread->param;
 239     param->top = 0;
 240
 241     g_hInst = LoadLibrary("hwcfilter.dll");
 242
 243     if (!g_hInst) {
 244         g_hInst = LoadLibrary("bin\\hwcfilter.dll");
 245         if (!g_hInst) {
 246             ERR("load library failed!!!!\n");
 247             param->errCode = EINVAL;
 248             return;
 249         }
 250     }
 251
 252     SVCamCtrl = (CTRLFN)GetProcAddress(g_hInst, "HWCCtrl");
 253     if (!SVCamCtrl) {
 254         ERR("HWCCtrl get failed!!!\n");
 255         FreeLibrary(g_hInst);
 256         param->errCode = EINVAL;
 257         return;
 258     }
 259
 260     SVCamSetCallbackFn = (SETCALLBACKFN)GetProcAddress(g_hInst, "HWCSetCallback");
 261     if (!SVCamSetCallbackFn) {
 262         ERR("HWCSetCallback get failed!!!\n");
 263         FreeLibrary(g_hInst);
 264         param->errCode = EINVAL;
 265         return;
 266     }
 267
 268     hr = SVCamCtrl(HWC_OPEN, 0, NULL);
 269     if (FAILED(hr)) {
 270         param->errCode = EINVAL;
 271         FreeLibrary(g_hInst);
 272         ERR("camera device open failed!!!, [HRESULT : 0x%x]\n", hr);
 273         return;
 274     }
 275     hr = SVCamSetCallbackFn((CallbackFn)svcam_device_callbackfn);
 276     if (FAILED(hr)) {
 277         param->errCode = EINVAL;
 278         SVCamCtrl(HWC_CLOSE, 0, NULL);
 279         FreeLibrary(g_hInst);
 280         ERR("call back function set failed!!!, [HRESULT : 0x%x]\n", hr);
 281     }
 282
 283     TRACE("camera device open success!!!, [HRESULT : 0x%x]\n", hr);
 284 }
 285
 286 // SVCAM_CMD_CLOSE
 287 void svcam_device_close(SVCamState* state)
 288 {
 289     HRESULT hr;
 290     SVCamParam *param = state->thread->param;
 291     param->top = 0;
 292     hr = SVCamCtrl(HWC_CLOSE, 0, NULL);
 293     if (FAILED(hr)) {
 294         param->errCode = EINVAL;
 295         ERR("camera device close failed!!!, [HRESULT : 0x%x]\n", hr);
 296     }
 297     FreeLibrary(g_hInst);
 298     TRACE("camera device close success!!!, [HRESULT : 0x%x]\n", hr);
 299 }
 300
 301 // SVCAM_CMD_START_PREVIEW
 302 void svcam_device_start_preview(SVCamState* state)
 303 {
 304     HRESULT hr;
 305     uint32_t width, height;
 306     SVCamParam *param = state->thread->param;
 307     TRACE("svcam_device_start_preview\n");
 308     param->top = 0;
 309     hr = SVCamCtrl(HWC_START, 0, NULL);
 310     if (FAILED(hr)) {
 311         param->errCode = EINVAL;
 312         ERR("start preview failed!!!, [HRESULT : 0x%x]\n", hr);
 313         return;
 314     }
 315     pthread_mutex_lock(&state->thread->mutex_lock);
 316     state->streamon = 1;
 317     pthread_mutex_unlock(&state->thread->mutex_lock);
 318
 319     width = supported_dst_frames[cur_frame_idx].width;
 320     height = supported_dst_frames[cur_frame_idx].height;
 321     state->buf_size = height * ((width * supported_dst_pixfmts[cur_fmt_idx].bpp) >> 3);
 322 }
 323
 324 // SVCAM_CMD_STOP_PREVIEW
 325 void svcam_device_stop_preview(SVCamState* state)
 326 {
 327     HRESULT hr;
 328     SVCamParam *param = state->thread->param;
 329     TRACE("svcam_device_stop_preview\n");
 330     param->top = 0;
 331     hr = SVCamCtrl(HWC_STOP, 0, NULL);
 332     if (FAILED(hr)) {
 333         param->errCode = EINVAL;
 334         ERR("stop preview failed!!!, [HRESULT : 0x%x]\n", hr);
 335     }
 336     pthread_mutex_lock(&state->thread->mutex_lock);
 337     state->streamon = 0;
 338     pthread_mutex_unlock(&state->thread->mutex_lock);
 339     state->buf_size = 0;
 340 }
 341
 342 // SVCAM_CMD_S_PARAM
 343 void svcam_device_s_param(SVCamState* state)
 344 {
 345     SVCamParam *param = state->thread->param;
 346
 347     param->top = 0;
 348     TRACE("setting fps : %d/%d\n", param->stack[0], param->stack[1]);
 349 }
 350
 351 // SVCAM_CMD_G_PARAM
 352 void svcam_device_g_param(SVCamState* state)
 353 {
 354     SVCamParam *param = state->thread->param;
 355
 356     param->top = 0;
 357     TRACE("getting fps : 30/1\n");
 358
 359     param->stack[0] = 0x1000; // V4L2_CAP_TIMEPERFRAME
 360     param->stack[1] = 1; // numerator;
 361     param->stack[2] = 30; // denominator;
 362 }
 363
 364 // SVCAM_CMD_S_FMT
 365 void svcam_device_s_fmt(SVCamState* state)
 366 {
 367     uint32_t width, height, pixfmt, pidx, fidx;
 368     SVCamParam *param = state->thread->param;
 369
 370     param->top = 0;
 371     width = param->stack[0];        // width
 372     height = param->stack[1];       // height
 373     pixfmt = param->stack[2];       // pixelformat
 374
 375     for (fidx = 0; fidx < ARRAY_SIZE(supported_dst_frames); fidx++) {
 376         if ((supported_dst_frames[fidx].width == width) &&
 377                 (supported_dst_frames[fidx].height == height)) {
 378             break;
 379         }
 380     }
 381     if (fidx == ARRAY_SIZE(supported_dst_frames)) {
 382         param->errCode = EINVAL;
 383         return;
 384     }
 385     for (pidx = 0; pidx < ARRAY_SIZE(supported_dst_pixfmts); pidx++) {
 386         if (supported_dst_pixfmts[pidx].fmt == pixfmt) {
 387             break;
 388         }
 389     }
 390     if (pidx == ARRAY_SIZE(supported_dst_pixfmts)) {
 391         param->errCode = EINVAL;
 392         return;
 393     }
 394
 395     if ((supported_dst_frames[cur_frame_idx].width != width) &&
 396             (supported_dst_frames[cur_frame_idx].height != height)) {
 397         HWCParam inParam = {0,};
 398         inParam.val1 = width;
 399         inParam.val2 = height;
 400         HRESULT hr = SVCamCtrl(HWC_S_FMT, sizeof(HWCParam), &inParam);
 401         if (FAILED(hr)) {
 402             param->errCode = EINVAL;
 403             return;
 404         }
 405     }
 406
 407     param->stack[0] = width;
 408     param->stack[1] = height;
 409     param->stack[2] = 1; // V4L2_FIELD_NONE
 410     param->stack[3] = pixfmt;
 411     // bytes per line = (width * bpp) / 8
 412     param->stack[4] = (width * supported_dst_pixfmts[pidx].bpp) >> 3;
 413     param->stack[5] = param->stack[4] * height; // height * bytesperline
 414     param->stack[6] = 0;
 415     param->stack[7] = 0;
 416
 417     cur_frame_idx = fidx;
 418     cur_fmt_idx = pidx;
 419 }
 420
 421 // SVCAM_CMD_G_FMT
 422 void svcam_device_g_fmt(SVCamState* state)
 423 {
 424     SVCamParam *param = state->thread->param;
 425
 426     param->top = 0;
 427
 428     param->stack[0] = supported_dst_frames[cur_frame_idx].width;    // width
 429     param->stack[1] = supported_dst_frames[cur_frame_idx].height;   // height
 430     param->stack[2] = 1; // V4L2_FIELD_NONE
 431     param->stack[3] = supported_dst_pixfmts[cur_fmt_idx].fmt;   // pixelformat
 432     // bytes per line = (width * bpp) / 8
 433     param->stack[4] = (param->stack[0] * supported_dst_pixfmts[cur_fmt_idx].bpp) >> 3;
 434     param->stack[5] = param->stack[1] * param->stack[4];    // height * bytesperline
 435     param->stack[6] = 0;
 436     param->stack[7] = 0;
 437 }
 438
 439 void svcam_device_try_fmt(SVCamState* state)
 440 {
 441     uint32_t width, height, pixfmt, i;
 442     SVCamParam *param = state->thread->param;
 443
 444     param->top = 0;
 445     width = param->stack[0];        // width
 446     height = param->stack[1];       // height
 447     pixfmt = param->stack[2];       // pixelformat
 448
 449     for (i = 0; i < ARRAY_SIZE(supported_dst_frames); i++) {
 450         if ((supported_dst_frames[i].width == width) &&
 451                 (supported_dst_frames[i].height == height)) {
 452             break;
 453         }
 454     }
 455     if (i == ARRAY_SIZE(supported_dst_frames)) {
 456         param->errCode = EINVAL;
 457         return;
 458     }
 459     for (i = 0; i < ARRAY_SIZE(supported_dst_pixfmts); i++) {
 460         if (supported_dst_pixfmts[i].fmt == pixfmt) {
 461             break;
 462         }
 463     }
 464     if (i == ARRAY_SIZE(supported_dst_pixfmts)) {
 465         param->errCode = EINVAL;
 466         return;
 467     }
 468
 469     param->stack[0] = width;
 470     param->stack[1] = height;
 471     param->stack[2] = 1; // V4L2_FIELD_NONE
 472     param->stack[3] = pixfmt;
 473     // bytes per line = (width * bpp) / 8
 474     param->stack[4] = (width * supported_dst_pixfmts[i].bpp) >> 3;
 475     param->stack[5] = param->stack[4] * height; // height * bytesperline
 476     param->stack[6] = 0;
 477     param->stack[7] = 0;
 478 }
 479
 480 void svcam_device_enum_fmt(SVCamState* state)
 481 {
 482     uint32_t index;
 483     SVCamParam *param = state->thread->param;
 484
 485     param->top = 0;
 486     index = param->stack[0];
 487
 488     if (index >= ARRAY_SIZE(supported_dst_pixfmts)) {
 489         param->errCode = EINVAL;
 490         return;
 491     }
 492     param->stack[1] = 0;                            // flags = NONE;
 493     param->stack[2] = supported_dst_pixfmts[index].fmt; // pixelformat;
 494     /* set description */
 495     switch (supported_dst_pixfmts[index].fmt) {
 496     case V4L2_PIX_FMT_YUYV:
 497         memcpy(&param->stack[3], "YUY2", 32);
 498         break;
 499     case V4L2_PIX_FMT_YUV420:
 500         memcpy(&param->stack[3], "YU12", 32);
 501         break;
 502     case V4L2_PIX_FMT_YVU420:
 503         memcpy(&param->stack[3], "YV12", 32);
 504         break;
 505     }
 506 }
 507
 508 void svcam_device_qctrl(SVCamState* state)
 509 {
 510     HRESULT hr;
 511     uint32_t id, i;
 512     HWCParam inParam = {0,};
 513     char name[32] = {0,};
 514     SVCamParam *param = state->thread->param;
 515
 516     param->top = 0;
 517     id = param->stack[0];
 518
 519     switch (id) {
 520     case V4L2_CID_BRIGHTNESS:
 521         TRACE("V4L2_CID_BRIGHTNESS\n");
 522         inParam.val1 = VideoProcAmp_Brightness;
 523         memcpy((void*)name, (void*)"brightness", 32);
 524         i = 0;
 525         break;
 526     case V4L2_CID_CONTRAST:
 527         TRACE("V4L2_CID_CONTRAST\n");
 528         inParam.val1 = VideoProcAmp_Contrast;
 529         memcpy((void*)name, (void*)"contrast", 32);
 530         i = 1;
 531         break;
 532     case V4L2_CID_SATURATION:
 533         TRACE("V4L2_CID_SATURATION\n");
 534         inParam.val1 = VideoProcAmp_Saturation;
 535         memcpy((void*)name, (void*)"saturation", 32);
 536         i = 2;
 537         break;
 538     case V4L2_CID_SHARPNESS:
 539         TRACE("V4L2_CID_SHARPNESS\n");
 540         inParam.val1 = VideoProcAmp_Sharpness;
 541         memcpy((void*)name, (void*)"sharpness", 32);
 542         i = 3;
 543         break;
 544     default:
 545         param->errCode = EINVAL;
 546         return;
 547     }
 548     hr = SVCamCtrl(HWC_QCTRL, sizeof(inParam), &inParam);
 549     if (FAILED(hr)) {
 550         param->errCode = EINVAL;
 551         ERR("failed to query video controls [HRESULT : 0x%x]\n", hr);
 552         return;
 553     } else {
 554         qctrl_tbl[i].hit = 1;
 555         qctrl_tbl[i].min = inParam.val2;
 556         qctrl_tbl[i].max = inParam.val3;
 557         qctrl_tbl[i].step = inParam.val4;
 558         qctrl_tbl[i].init_val = inParam.val5;
 559
 560         if ((qctrl_tbl[i].min + qctrl_tbl[i].max) == 0) {
 561             inParam.val2 = 0;
 562         } else {
 563             inParam.val2 = (qctrl_tbl[i].min + qctrl_tbl[i].max) / 2;
 564         }
 565         hr = SVCamCtrl(HWC_S_CTRL, sizeof(inParam), &inParam);
 566         if (FAILED(hr)) {
 567             param->errCode = EINVAL;
 568             ERR("failed to set video control value, [HRESULT : 0x%x]\n", hr);
 569             return;
 570         }
 571     }
 572
 573     param->stack[0] = id;
 574     param->stack[1] = SVCAM_CTRL_VALUE_MIN; // minimum
 575     param->stack[2] = SVCAM_CTRL_VALUE_MAX; // maximum
 576     param->stack[3] = SVCAM_CTRL_VALUE_STEP;// step
 577     param->stack[4] = SVCAM_CTRL_VALUE_MID; // default_value
 578     param->stack[5] = V4L2_CTRL_FLAG_SLIDER;
 579     /* name field setting */
 580     memcpy(&param->stack[6], (void*)name, sizeof(name)/sizeof(name[0]));
 581 }
 582
 583 void svcam_device_s_ctrl(SVCamState* state)
 584 {
 585     HRESULT hr;
 586     uint32_t i;
 587     HWCParam inParam = {0,};
 588     SVCamParam *param = state->thread->param;
 589
 590     param->top = 0;
 591
 592     switch (param->stack[0]) {
 593     case V4L2_CID_BRIGHTNESS:
 594         i = 0;
 595         inParam.val1 = VideoProcAmp_Brightness;
 596         break;
 597     case V4L2_CID_CONTRAST:
 598         i = 1;
 599         inParam.val1 = VideoProcAmp_Contrast;
 600         break;
 601     case V4L2_CID_SATURATION:
 602         i = 2;
 603         inParam.val1 = VideoProcAmp_Saturation;
 604         break;
 605     case V4L2_CID_SHARPNESS:
 606         i = 3;
 607         inParam.val1 = VideoProcAmp_Sharpness;
 608         break;
 609     default:
 610         param->errCode = EINVAL;
 611         return;
 612     }
 613     inParam.val2 = value_convert_from_guest(qctrl_tbl[i].min,
 614             qctrl_tbl[i].max, (long)param->stack[1]);
 615     hr = SVCamCtrl(HWC_S_CTRL, sizeof(inParam), &inParam);
 616     if (FAILED(hr)) {
 617         param->errCode = EINVAL;
 618         ERR("failed to set video control value, [HRESULT : 0x%x]\n", hr);
 619         return;
 620     }
 621 }
 622
 623 void svcam_device_g_ctrl(SVCamState* state)
 624 {
 625     HRESULT hr;
 626     uint32_t i;
 627     HWCParam inParam = {0,};
 628     SVCamParam *param = state->thread->param;
 629
 630     param->top = 0;
 631     switch (param->stack[0]) {
 632     case V4L2_CID_BRIGHTNESS:
 633         i = 0;
 634         inParam.val1 = VideoProcAmp_Brightness;
 635         break;
 636     case V4L2_CID_CONTRAST:
 637         i = 1;
 638         inParam.val1 = VideoProcAmp_Contrast;
 639         break;
 640     case V4L2_CID_SATURATION:
 641         i = 2;
 642         inParam.val1 = VideoProcAmp_Saturation;
 643         break;
 644     case V4L2_CID_SHARPNESS:
 645         i = 3;
 646         inParam.val1 = VideoProcAmp_Sharpness;
 647         break;
 648     default:
 649         param->errCode = EINVAL;
 650         return;
 651     }
 652
 653     hr = SVCamCtrl(HWC_G_CTRL, sizeof(inParam), &inParam);
 654     if (FAILED(hr)) {
 655         param->errCode = EINVAL;
 656         ERR("failed to get video control value!!!, [HRESULT : 0x%x]\n", hr);
 657         return;
 658     }
 659     param->stack[0] = (uint32_t)value_convert_to_guest(qctrl_tbl[i].min,
 660                 qctrl_tbl[i].max, inParam.val2);
 661 }
 662
 663 void svcam_device_enum_fsizes(SVCamState* state)
 664 {
 665     uint32_t index, pixfmt, i;
 666     SVCamParam *param = state->thread->param;
 667
 668     param->top = 0;
 669     index = param->stack[0];
 670     pixfmt = param->stack[1];
 671
 672     if (index >= ARRAY_SIZE(supported_dst_frames)) {
 673         param->errCode = EINVAL;
 674         return;
 675     }
 676     for (i = 0; i < ARRAY_SIZE(supported_dst_pixfmts); i++) {
 677         if (supported_dst_pixfmts[i].fmt == pixfmt)
 678             break;
 679     }
 680
 681     if (i == ARRAY_SIZE(supported_dst_pixfmts)) {
 682         param->errCode = EINVAL;
 683         return;
 684     }
 685
 686     param->stack[0] = supported_dst_frames[index].width;
 687     param->stack[1] = supported_dst_frames[index].height;
 688 }
 689
 690 void svcam_device_enum_fintv(SVCamState* state)
 691 {
 692     SVCamParam *param = state->thread->param;
 693
 694     param->top = 0;
 695
 696     // switch by index(param->stack[0])
 697     switch (param->stack[0]) {
 698     case 0:
 699         param->stack[1] = 30;   // denominator
 700         break;
 701     default:
 702         param->errCode = EINVAL;
 703         return;
 704     }
 705     param->stack[0] = 1;    // numerator
 706 }
 707
 708 void v4lconvert_yuyv_to_yuv420(const unsigned char *src, unsigned char *dest,
 709         uint32_t width, uint32_t height, uint32_t yvu)
 710 {
 711     uint32_t i, j;
 712     const unsigned char *src1;
 713     unsigned char *udest, *vdest;
 714
 715     /* copy the Y values */
 716     src1 = src;
 717     for (i = 0; i < height; i++) {
 718         for (j = 0; j < width; j += 2) {
 719             *dest++ = src1[0];
 720             *dest++ = src1[2];
 721             src1 += 4;
 722         }
 723     }
 724
 725     /* copy the U and V values */
 726     src++;              /* point to V */
 727     src1 = src + width * 2;     /* next line */
 728     if (yvu) {
 729         vdest = dest;
 730         udest = dest + width * height / 4;
 731     } else {
 732         udest = dest;
 733         vdest = dest + width * height / 4;
 734     }
 735     for (i = 0; i < height; i += 2) {
 736         for (j = 0; j < width; j += 2) {
 737             *udest++ = ((int) src[0] + src1[0]) / 2;    /* U */
 738             *vdest++ = ((int) src[2] + src1[2]) / 2;    /* V */
 739             src += 4;
 740             src1 += 4;
 741         }
 742         src = src1;
 743         src1 += width * 2;
 744     }
 745 }