From 2113f06914497a7fc28cf2bc97c0f6ea3efc9ff1 Mon Sep 17 00:00:00 2001 From: "jinhyung.jo" Date: Thu, 2 Apr 2015 10:50:12 +0900 Subject: [PATCH] maru-camera: Code refactoring Modified the Windows module. - modified in accordance with a common module changes - minimum declarations for v4l2 copied from videodev2.h - modified conversion code: bug fix, etc. Change-Id: I0d7d220aaab8d2e7ba7d1592aa042d697ea9e467 Signed-off-by: Jinhyung Jo --- tizen/src/hw/pci/Makefile.objs | 4 +- tizen/src/hw/pci/maru_camera_convert.c | 152 +--- tizen/src/hw/pci/maru_camera_convert.h | 86 +-- tizen/src/hw/pci/maru_camera_win32.c | 941 +++++++++++++------------ tizen/src/hw/pci/videodev2_min.h | 887 +++++++++++++++++++++++ 5 files changed, 1430 insertions(+), 640 deletions(-) create mode 100644 tizen/src/hw/pci/videodev2_min.h diff --git a/tizen/src/hw/pci/Makefile.objs b/tizen/src/hw/pci/Makefile.objs index 506305e758..0f16a9df72 100644 --- a/tizen/src/hw/pci/Makefile.objs +++ b/tizen/src/hw/pci/Makefile.objs @@ -14,11 +14,11 @@ obj-y += maru_camera_linux.o LIBS += -lv4l2 -lv4lconvert endif ifdef CONFIG_WIN32 -obj-y += maru_camera_win32.o maru_camera_util.o +obj-y += maru_camera_win32.o maru_camera_convert.o LIBS += -lole32 -loleaut32 -luuid -lstrmiids endif ifdef CONFIG_DARWIN -obj-y += maru_camera_darwin.o maru_camera_util.o +obj-y += maru_camera_darwin.o maru_camera_convert.o LIBS += -framework Foundation -framework SystemConfiguration LIBS += -framework Cocoa -framework QTKit -framework CoreVideo LIBS += -framework AppKit diff --git a/tizen/src/hw/pci/maru_camera_convert.c b/tizen/src/hw/pci/maru_camera_convert.c index 8be52ce9ba..f99a4f6b40 100644 --- a/tizen/src/hw/pci/maru_camera_convert.c +++ b/tizen/src/hw/pci/maru_camera_convert.c @@ -29,6 +29,7 @@ */ #include "qemu-common.h" +#include "videodev2_min.h" #include "maru_camera_convert.h" #include "debug_ch.h" @@ -38,9 +39,6 @@ static void UYVYToYUV420(unsigned char *bufsrc, unsigned char *bufdest, uint32_t width, uint32_t height); static void YVU420ToYUV420(unsigned char *bufsrc, unsigned char *bufdest, uint32_t width, uint32_t height); -static void YUYVToYUV420(unsigned char *bufsrc, unsigned char *bufdest, - uint32_t width, uint32_t height); - static void yuyv_to_yuv420(const unsigned char *src, unsigned char *dest, uint32_t width, uint32_t height, uint32_t yvu); static void rgb24_to_yuv420(const unsigned char *src, unsigned char *dest, @@ -52,6 +50,42 @@ static void yuv420_to_yvu420(unsigned char *src, unsigned char *dest, static void yuv420_to_yuyv(unsigned char *src, unsigned char *dest, uint32_t width, uint32_t height); +uint32_t get_bytesperline(uint32_t pixfmt, uint32_t width) +{ + uint32_t bytesperline; + + switch (pixfmt) { + case V4L2_PIX_FMT_YUV420: + case V4L2_PIX_FMT_YVU420: + bytesperline = width; + break; + case V4L2_PIX_FMT_YUYV: + default: + bytesperline = width * 2; + break; + } + + return bytesperline; +} + +uint32_t get_sizeimage(uint32_t pixfmt, uint32_t width, uint32_t height) +{ + uint32_t bytesperline; + + switch (pixfmt) { + case V4L2_PIX_FMT_YUV420: + case V4L2_PIX_FMT_YVU420: + bytesperline = (width * 12) >> 3; + break; + case V4L2_PIX_FMT_YUYV: + default: + bytesperline = width * 2; + break; + } + + return bytesperline * height; +} + /* Convert pixel format to YUV420 */ uint8_t convert_frame(uint32_t src_format, uint32_t dst_format, uint32_t width, uint32_t height, size_t frame_size, @@ -348,118 +382,6 @@ static void YVU420ToYUV420(unsigned char *bufsrc, unsigned char *bufdest, } -static void YUYVToYUV420(unsigned char *bufsrc, unsigned char *bufdest, - uint32_t width, uint32_t height) -{ - uint32_t i, j; - - /* Source*/ - unsigned char *ptrsrcy1, *ptrsrcy2; - unsigned char *ptrsrcy3, *ptrsrcy4; - unsigned char *ptrsrccb1; - unsigned char *ptrsrccb3; - unsigned char *ptrsrccr1; - unsigned char *ptrsrccr3; - uint32_t srcystride, srcccstride; - - ptrsrcy1 = bufsrc ; - ptrsrcy2 = bufsrc + (width << 1); - ptrsrcy3 = bufsrc + (width << 1) * 2; - ptrsrcy4 = bufsrc + (width << 1) * 3; - - ptrsrccb1 = bufsrc + 1; - ptrsrccb3 = bufsrc + (width << 1) * 2 + 1; - - ptrsrccr1 = bufsrc + 3; - ptrsrccr3 = bufsrc + (width << 1) * 2 + 3; - - srcystride = (width << 1) * 3; - srcccstride = (width << 1) * 3; - - /* Destination */ - unsigned char *ptrdesty1, *ptrdesty2; - unsigned char *ptrdesty3, *ptrdesty4; - unsigned char *ptrdestcb1, *ptrdestcb2; - unsigned char *ptrdestcr1, *ptrdestcr2; - uint32_t destystride, destccstride; - - ptrdesty1 = bufdest; - ptrdesty2 = bufdest + width; - ptrdesty3 = bufdest + width * 2; - ptrdesty4 = bufdest + width * 3; - - ptrdestcb1 = bufdest + width * height; - ptrdestcb2 = bufdest + width * height + (width >> 1); - - ptrdestcr1 = bufdest + width * height + ((width * height) >> 2); - ptrdestcr2 = bufdest + width * height + ((width * height) >> 2) - + (width >> 1); - - destystride = width * 3; - destccstride = (width >> 1); - - for (j = 0; j < (height / 4); j++) { - for (i = 0; i < (width / 2); i++) { - (*ptrdesty1++) = (*ptrsrcy1); - (*ptrdesty2++) = (*ptrsrcy2); - (*ptrdesty3++) = (*ptrsrcy3); - (*ptrdesty4++) = (*ptrsrcy4); - - ptrsrcy1 += 2; - ptrsrcy2 += 2; - ptrsrcy3 += 2; - ptrsrcy4 += 2; - - (*ptrdesty1++) = (*ptrsrcy1); - (*ptrdesty2++) = (*ptrsrcy2); - (*ptrdesty3++) = (*ptrsrcy3); - (*ptrdesty4++) = (*ptrsrcy4); - - ptrsrcy1 += 2; - ptrsrcy2 += 2; - ptrsrcy3 += 2; - ptrsrcy4 += 2; - - (*ptrdestcb1++) = (*ptrsrccb1); - (*ptrdestcb2++) = (*ptrsrccb3); - - ptrsrccb1 += 4; - ptrsrccb3 += 4; - - (*ptrdestcr1++) = (*ptrsrccr1); - (*ptrdestcr2++) = (*ptrsrccr3); - - ptrsrccr1 += 4; - ptrsrccr3 += 4; - - } - - /* Update src pointers */ - ptrsrcy1 += srcystride; - ptrsrcy2 += srcystride; - ptrsrcy3 += srcystride; - ptrsrcy4 += srcystride; - - ptrsrccb1 += srcccstride; - ptrsrccb3 += srcccstride; - - ptrsrccr1 += srcccstride; - ptrsrccr3 += srcccstride; - - /* Update dest pointers */ - ptrdesty1 += destystride; - ptrdesty2 += destystride; - ptrdesty3 += destystride; - ptrdesty4 += destystride; - - ptrdestcb1 += destccstride; - ptrdestcb2 += destccstride; - - ptrdestcr1 += destccstride; - ptrdestcr2 += destccstride; - } -} - static void yuyv_to_yuv420(const unsigned char *src, unsigned char *dest, uint32_t width, uint32_t height, uint32_t yvu) { diff --git a/tizen/src/hw/pci/maru_camera_convert.h b/tizen/src/hw/pci/maru_camera_convert.h index 8252d7db88..df73ef5283 100644 --- a/tizen/src/hw/pci/maru_camera_convert.h +++ b/tizen/src/hw/pci/maru_camera_convert.h @@ -31,92 +31,12 @@ #ifndef _MARU_CAMERA_CONVERT_H_ #define _MARU_CAMERA_CONVERT_H_ -#define MAKEFOURCC(a, b, c, d) \ - (((uint32_t)(a) << 0) | \ - ((uint32_t)(b) << 8) | \ - ((uint32_t)(c) << 16) | \ - ((uint32_t)(d) << 24)) +uint32_t get_bytesperline(uint32_t pixfmt, uint32_t width); -/* 16 RGB-5-5-5 */ -#define V4L2_PIX_FMT_RGB555 MAKEFOURCC('R', 'G', 'B', 'O') -/* 16 RGB-5-6-5 */ -#define V4L2_PIX_FMT_RGB565 MAKEFOURCC('R', 'G', 'B', 'P') -/* 16 RGB-5-5-5 BE */ -#define V4L2_PIX_FMT_RGB555X MAKEFOURCC('R', 'G', 'B', 'Q') -/* 16 RGB-5-6-5 BE */ -#define V4L2_PIX_FMT_RGB565X MAKEFOURCC('R', 'G', 'B', 'R') -/* 24 BGR-8-8-8 */ -#define V4L2_PIX_FMT_BGR24 MAKEFOURCC('B', 'G', 'R', '3') -/* 24 RGB-8-8-8 */ -#define V4L2_PIX_FMT_RGB24 MAKEFOURCC('R', 'G', 'B', '3') -/* 32 BGR-8-8-8-8 */ -#define V4L2_PIX_FMT_BGR32 MAKEFOURCC('B', 'G', 'R', '4') -/* 32 RGB-8-8-8-8 */ -#define V4L2_PIX_FMT_RGB32 MAKEFOURCC('R', 'G', 'B', '4') -/* 9 YVU 4:1:0 */ -#define V4L2_PIX_FMT_YVU410 MAKEFOURCC('Y', 'V', 'U', '9') -/* 12 YVU 4:2:0 */ -#define V4L2_PIX_FMT_YVU420 MAKEFOURCC('Y', 'V', '1', '2') -/* 16 YUV 4:2:2 */ -#define V4L2_PIX_FMT_YUYV MAKEFOURCC('Y', 'U', 'Y', 'V') -/* 16 YUV 4:2:2 */ -#define V4L2_PIX_FMT_UYVY MAKEFOURCC('U', 'Y', 'V', 'Y') -/* 16 YVU422 planar */ -#define V4L2_PIX_FMT_YUV422P MAKEFOURCC('4', '2', '2', 'P') -/* 16 YVU411 planar */ -#define V4L2_PIX_FMT_YUV411P MAKEFOURCC('4', '1', '1', 'P') -/* 12 YUV 4:1:1 */ -#define V4L2_PIX_FMT_Y41P MAKEFOURCC('Y', '4', '1', 'P') -/* 16 xxxxyyyy uuuuvvvv */ -#define V4L2_PIX_FMT_YUV444 MAKEFOURCC('Y', '4', '4', '4') -/* 16 YUV-5-5-5 */ -#define V4L2_PIX_FMT_YUV555 MAKEFOURCC('Y', 'U', 'V', 'O') -/* 16 YUV-5-6-5 */ -#define V4L2_PIX_FMT_YUV565 MAKEFOURCC('Y', 'U', 'V', 'P') -/* 32 YUV-8-8-8-8 */ -#define V4L2_PIX_FMT_YUV32 MAKEFOURCC('Y', 'U', 'V', '4') -/* 9 YUV 4:1:0 */ -#define V4L2_PIX_FMT_YUV410 MAKEFOURCC('Y', 'U', 'V', '9') -/* 12 YUV 4:2:0 */ -#define V4L2_PIX_FMT_YUV420 MAKEFOURCC('Y', 'U', '1', '2') -/* 16 YUV 4:2:2 */ -#define V4L2_PIX_FMT_YYUV MAKEFOURCC('Y', 'Y', 'U', 'V') - -/* V4L2 defines copy from videodev2.h */ -#define V4L2_CTRL_FLAG_SLIDER 0x0020 - -#define V4L2_CTRL_CLASS_USER 0x00980000 -#define V4L2_CID_BASE (V4L2_CTRL_CLASS_USER | 0x900) -#define V4L2_CID_BRIGHTNESS (V4L2_CID_BASE + 0) -#define V4L2_CID_CONTRAST (V4L2_CID_BASE + 1) -#define V4L2_CID_SATURATION (V4L2_CID_BASE + 2) -#define V4L2_CID_SHARPNESS (V4L2_CID_BASE + 27) - -inline uint32_t get_bytesperline(uint32_t pixfmt, uint32_t width) -{ - uint32_t bytesperline; - - switch (pixfmt) { - case V4L2_PIX_FMT_YUV420: - case V4L2_PIX_FMT_YVU420: - bytesperline = (width * 12) >> 3; - break; - case V4L2_PIX_FMT_YUYV: - default: - bytesperline = width * 2; - break; - } - - return bytesperline; -} - -inline uint32_t get_sizeimage(uint32_t pixfmt, uint32_t width, uint32_t height) -{ - return get_bytesperline(pixfmt, width) * height; -} +uint32_t get_sizeimage(uint32_t pixfmt, uint32_t width, uint32_t height); uint8_t convert_frame(uint32_t src_format, uint32_t dst_format, uint32_t width, uint32_t height, size_t frame_size, - void *src_buf, void *dst_buf) + void *src_buf, void *dst_buf); #endif /* _MARU_CAMERA_CONVERT_H_ */ diff --git a/tizen/src/hw/pci/maru_camera_win32.c b/tizen/src/hw/pci/maru_camera_win32.c index 337c371ae0..3e2e0b39ff 100644 --- a/tizen/src/hw/pci/maru_camera_win32.c +++ b/tizen/src/hw/pci/maru_camera_win32.c @@ -39,6 +39,8 @@ #include "errors.h" /* for VFW_E_XXXX */ #include "mmsystem.h" /* for MAKEFOURCC macro */ #include "maru_camera_win32.h" +#include "videodev2_min.h" +#include "maru_camera_convert.h" MULTI_DEBUG_CHANNEL(tizen, camera); @@ -55,7 +57,8 @@ MULTI_DEBUG_CHANNEL(tizen, camera); } \ } while (0) -typedef HRESULT (STDAPICALLTYPE *CallbackFn)(ULONG dwSize, BYTE *pBuffer); +typedef HRESULT (STDAPICALLTYPE *CallbackFn)(MaruCamState *pState, + ULONG dwSize, BYTE *pBuffer); /* * HWCGrabCallback @@ -64,8 +67,10 @@ typedef HRESULT (STDAPICALLTYPE *CallbackFn)(ULONG dwSize, BYTE *pBuffer); typedef struct HWCGrabCallback { IGrabCallback IGrabCallback_iface; long m_cRef; + MaruCamState *m_pState; CallbackFn m_pCallback; STDMETHODIMP (*SetCallback)(IGrabCallback *iface, CallbackFn pCallbackFn); + STDMETHODIMP (*SetState)(IGrabCallback *iface, MaruCamState *pState); } HWCGrabCallback; static inline HWCGrabCallback *impl_from_IGrabCallback(IGrabCallback *iface) @@ -102,6 +107,7 @@ static STDMETHODIMP_(ULONG) HWCGrabCallback_Release(IGrabCallback *iface) if (InterlockedDecrement(&This->m_cRef) == 0) { This->m_pCallback = NULL; + This->m_pState = NULL; g_free((void *)This); This = NULL; return 0; @@ -116,7 +122,7 @@ static STDMETHODIMP HWCGrabCallback_Grab(IGrabCallback *iface, HWCGrabCallback *This = impl_from_IGrabCallback(iface); if (This->m_pCallback) { - HRESULT hr = This->m_pCallback(dwSize, pBuffer); + HRESULT hr = This->m_pCallback(This->m_pState, dwSize, pBuffer); if (FAILED(hr)) { return E_FAIL; } else { @@ -136,6 +142,15 @@ static STDMETHODIMP HWCGrabCallback_SetCallback(IGrabCallback *iface, return S_OK; } +static STDMETHODIMP HWCGrabCallback_SetState(IGrabCallback *iface, + MaruCamState *pState) +{ + HWCGrabCallback *This = impl_from_IGrabCallback(iface); + + This->m_pState = pState; + return S_OK; +} + static IGrabCallbackVtbl HWCGrabCallback_Vtbl = { HWCGrabCallback_QueryInterface, HWCGrabCallback_AddRef, @@ -157,6 +172,7 @@ static STDMETHODIMP HWCGrabCallback_Construct(IGrabCallback **ppv) This->m_cRef = 1; This->m_pCallback = NULL; This->SetCallback = HWCGrabCallback_SetCallback; + This->SetState = HWCGrabCallback_SetState; *ppv = &This->IGrabCallback_iface; return S_OK; } @@ -174,7 +190,7 @@ typedef struct HWCInPin { IMemAllocator *m_pAllocator; BOOL m_bReadOnly; long m_cRef; - STDMETHODIMP (*SetGrabCallbackIF)(IPin *iface, IGrabCallback *pCaptureCB); + STDMETHODIMP (*SetGrabCb)(IPin *iface, IGrabCallback *pCaptureCB); } HWCInPin; static inline HWCInPin *impl_from_IPin(IPin *iface) @@ -650,7 +666,7 @@ static STDMETHODIMP HWCInPin_Construct(IBaseFilter *pFilter, IPin **ppv) This->m_pCallback = NULL; This->m_pAllocator = NULL; This->m_cRef = 1; - This->SetGrabCallbackIF = HWCPin_SetCallback; + This->SetGrabCb = HWCPin_SetCallback; *ppv = &This->IPin_iface; return S_OK; @@ -1038,52 +1054,26 @@ static STDMETHODIMP HWCFilter_Construct(IBaseFilter **ppv) * **********************************************************/ - -/* - * Declaration global variables for Win32 COM Interfaces - */ -IGraphBuilder *g_pGB ; -ICaptureGraphBuilder2 *g_pCGB; -IMediaControl *g_pMediaControl; - -IPin *g_pOutputPin; -IPin *g_pInputPin; -IBaseFilter *g_pDstFilter; -IBaseFilter *g_pSrcFilter; - -IGrabCallback *g_pCallback; - -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_YUV420, 12, 0 }, - { V4L2_PIX_FMT_YVU420, 12, 0 }, +static uint32_t support_fmts[] = { + V4L2_PIX_FMT_YUYV, + 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[] = { - { 640, 480 }, - { 352, 288 }, - { 320, 240 }, - { 176, 144 }, - { 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 +static struct MCFrame support_frames[] = { + { 640, 480 }, + { 352, 288 }, + { 320, 240 }, + { 176, 144 }, + { 160, 120 }, +}; -struct marucam_qctrl { +struct MCControls { uint32_t id; uint32_t hit; long min; @@ -1092,21 +1082,35 @@ struct marucam_qctrl { long init_val; }; -static struct marucam_qctrl qctrl_tbl[] = { +static struct MCControls ctrl_tbl[] = { { V4L2_CID_BRIGHTNESS, 0, }, { V4L2_CID_CONTRAST, 0, }, { V4L2_CID_SATURATION, 0, }, { V4L2_CID_SHARPNESS, 0, }, }; -static MaruCamState *g_state; - -static uint32_t ready_count; -static uint32_t cur_fmt_idx; -static uint32_t cur_frame_idx; -static void *grab_buf; -static uint32_t g_dwSrcFmt; +typedef struct MCBackendWin { + MaruCamBackend base; + /* + * Declaration variables for Win32 COM Interfaces + */ + IGraphBuilder *pGB ; + ICaptureGraphBuilder2 *pCGB; + IMediaControl *pMC; + IPin *pOutPin; + IPin *pInPin; + IBaseFilter *pDstFilter; + IBaseFilter *pSrcFilter; + IGrabCallback *pCallback; + + uint32_t ready_count; + int32_t src_fmt; + int32_t dst_width; + int32_t dst_height; + int32_t dst_fmt; + void *buf; +} MCBackendWin; /* * Helper functions - converting values @@ -1150,14 +1154,16 @@ static long value_convert_to_guest(long min, long max, long value) /* * Callback function for grab frames */ -static STDMETHODIMP marucam_device_callbackfn(ULONG dwSize, BYTE *pBuffer) +static STDMETHODIMP marucam_device_callbackfn(MaruCamState *state, + ULONG dwSize, BYTE *pBuffer) { void *tmp_buf; uint32_t width, height, fmt, imgsize; + MCBackendWin *backend = (MCBackendWin *)(state->backend); - width = supported_dst_frames[cur_frame_idx].width; - height = supported_dst_frames[cur_frame_idx].height; - fmt = supported_dst_pixfmts[cur_fmt_idx].fmt; + width = backend->dst_width; + height = backend->dst_height; + fmt = backend->dst_fmt; imgsize = get_sizeimage(fmt, width, height); if (imgsize > (uint32_t)dwSize) { @@ -1165,32 +1171,32 @@ static STDMETHODIMP marucam_device_callbackfn(ULONG dwSize, BYTE *pBuffer) return E_FAIL; } - if (convert_frame(g_dwSrcFmt, fmt, width, height, - (size_t)dwSize, pBuffer, grab_buf) > 0) { + if (convert_frame(backend->src_fmt, backend->dst_fmt, width, height, + (size_t)dwSize, pBuffer, backend->buf) > 0) { return E_FAIL; } - qemu_mutex_lock(&g_state->thread_mutex); - if (g_state->streamon) { - if (ready_count < MARUCAM_SKIPFRAMES) { + qemu_mutex_lock(&state->thread_mutex); + if (state->streamon) { + if (backend->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); + ++backend->ready_count; + TRACE("skip %d frame\n", backend->ready_count); + qemu_mutex_unlock(&state->thread_mutex); return S_OK; } - if (g_state->req_frame == 0) { + 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 S_OK; } - tmp_buf = g_state->vaddr + g_state->buf_size * (g_state->req_frame - 1); - memcpy(tmp_buf, grab_buf, g_state->buf_size); - 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); + tmp_buf = state->fb_ptr + state->buf_size * (state->req_frame - 1); + memcpy(tmp_buf, backend->buf, state->buf_size); + state->req_frame = 0; /* clear request */ + state->isr |= 0x01; /* set a flag of rasing a interrupt */ + qemu_bh_schedule(state->tx_bh); } - qemu_mutex_unlock(&g_state->thread_mutex); + qemu_mutex_unlock(&state->thread_mutex); return S_OK; } @@ -1198,24 +1204,24 @@ static STDMETHODIMP marucam_device_callbackfn(ULONG dwSize, BYTE *pBuffer) * Internal functions for manipulate interfaces */ -static STDMETHODIMP_(void) CloseInterfaces(void) +static STDMETHODIMP_(void) CloseInterfaces(MCBackendWin *backend) { - if (g_pMediaControl) { - g_pMediaControl->lpVtbl->Stop(g_pMediaControl); + if (backend->pMC) { + backend->pMC->lpVtbl->Stop(backend->pMC); } - if (g_pOutputPin) { - g_pOutputPin->lpVtbl->Disconnect(g_pOutputPin); + if (backend->pOutPin) { + backend->pOutPin->lpVtbl->Disconnect(backend->pOutPin); } - SAFE_RELEASE(g_pGB); - SAFE_RELEASE(g_pCGB); - SAFE_RELEASE(g_pMediaControl); - SAFE_RELEASE(g_pOutputPin); - SAFE_RELEASE(g_pInputPin); - SAFE_RELEASE(g_pDstFilter); - SAFE_RELEASE(g_pSrcFilter); - SAFE_RELEASE(g_pCallback); + SAFE_RELEASE(backend->pGB); + SAFE_RELEASE(backend->pCGB); + SAFE_RELEASE(backend->pMC); + SAFE_RELEASE(backend->pOutPin); + SAFE_RELEASE(backend->pInPin); + SAFE_RELEASE(backend->pDstFilter); + SAFE_RELEASE(backend->pSrcFilter); + SAFE_RELEASE(backend->pCallback); } static STDMETHODIMP_(void) DeleteMediaType(AM_MEDIA_TYPE *pmt) @@ -1273,49 +1279,52 @@ static STDMETHODIMP GetPin(IBaseFilter *pFilter, return S_FALSE; } -static STDMETHODIMP GraphBuilder_Init(void) +static STDMETHODIMP GraphBuilder_Init(MCBackendWin *backend) { HRESULT hr; hr = CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC, - &IID_IGraphBuilder, (void **)&g_pGB); + &IID_IGraphBuilder, (void **)&backend->pGB); if (FAILED(hr)) { ERR("Failed to create instance of GraphBuilder, 0x%x\n", hr); return hr; } hr = CoCreateInstance(&CLSID_CaptureGraphBuilder2, NULL, CLSCTX_INPROC, - &IID_ICaptureGraphBuilder2, (void **)&g_pCGB); + &IID_ICaptureGraphBuilder2, + (void **)&backend->pCGB); if (FAILED(hr)) { ERR("Failed to create instance of CaptureGraphBuilder2, 0x%x\n", hr); return hr; } - hr = g_pCGB->lpVtbl->SetFiltergraph(g_pCGB, g_pGB); + hr = backend->pCGB->lpVtbl->SetFiltergraph(backend->pCGB, backend->pGB); if (FAILED(hr)) { ERR("Failed to SetFiltergraph, 0x%x\n", hr); return hr; } - hr = g_pGB->lpVtbl->QueryInterface(g_pGB, &IID_IMediaControl, - (void **)&g_pMediaControl); + hr = backend->pGB->lpVtbl->QueryInterface(backend->pGB, &IID_IMediaControl, + (void **)&backend->pMC); if (FAILED(hr)) { ERR("Failed to QueryInterface for IMediaControl, 0x%x\n", hr); return hr; } - hr = HWCGrabCallback_Construct(&g_pCallback); - if (g_pCallback == NULL) { + hr = HWCGrabCallback_Construct(&backend->pCallback); + if (backend->pCallback == NULL) { hr = E_OUTOFMEMORY; } - hr = ((HWCGrabCallback *)g_pCallback)->SetCallback(g_pCallback, - (CallbackFn)marucam_device_callbackfn); + hr = ((HWCGrabCallback *)(backend->pCallback))->SetCallback( + backend->pCallback, (CallbackFn)marucam_device_callbackfn); + hr = ((HWCGrabCallback *)(backend->pCallback))->SetState( + backend->pCallback, backend->base.state); return hr; } -static STDMETHODIMP BindSourceFilter(void) +static STDMETHODIMP BindSourceFilter(MCBackendWin *backend) { HRESULT hr; ICreateDevEnum *pCreateDevEnum = NULL; @@ -1361,12 +1370,12 @@ static STDMETHODIMP BindSourceFilter(void) hr = pBag->lpVtbl->Read(pBag, L"FriendlyName", &var, NULL); if (hr == NOERROR) { hr = pMoniKer->lpVtbl->BindToObject(pMoniKer, NULL, NULL, - &IID_IBaseFilter, - (void **)&g_pSrcFilter); + &IID_IBaseFilter, + (void **)&backend->pSrcFilter); if (FAILED(hr)) { ERR("Counldn't bind moniker to filter object!!\n"); } else { - g_pSrcFilter->lpVtbl->AddRef(g_pSrcFilter); + backend->pSrcFilter->lpVtbl->AddRef(backend->pSrcFilter); } SysFreeString(var.bstrVal); } @@ -1376,10 +1385,12 @@ static STDMETHODIMP BindSourceFilter(void) } if (SUCCEEDED(hr)) { - hr = g_pGB->lpVtbl->AddFilter(g_pGB, g_pSrcFilter, L"Video Capture"); + hr = backend->pGB->lpVtbl->AddFilter(backend->pGB, + backend->pSrcFilter, + L"Video Capture"); if (hr != S_OK && hr != S_FALSE) { ERR("Counldn't add Video Capture filter to our graph!\n"); - SAFE_RELEASE(g_pSrcFilter); + SAFE_RELEASE(backend->pSrcFilter); } } SAFE_RELEASE(pEnumMK); @@ -1388,55 +1399,65 @@ static STDMETHODIMP BindSourceFilter(void) return hr; } -static STDMETHODIMP BindTargetFilter(void) +static STDMETHODIMP BindTargetFilter(MCBackendWin *backend) { HRESULT hr; - hr = HWCFilter_Construct(&g_pDstFilter); + hr = HWCFilter_Construct(&backend->pDstFilter); - if (SUCCEEDED(hr) && g_pDstFilter) { - hr = g_pGB->lpVtbl->AddFilter(g_pGB, g_pDstFilter, L"HWCFilter"); + if (SUCCEEDED(hr) && backend->pDstFilter) { + hr = backend->pGB->lpVtbl->AddFilter(backend->pGB, + backend->pDstFilter, + L"HWCFilter"); if (FAILED(hr)) { ERR("Counldn't add HWCFilterr to our graph!\n"); - SAFE_RELEASE(g_pDstFilter); + SAFE_RELEASE(backend->pDstFilter); } } return hr; } -static STDMETHODIMP ConnectFilters(void) +static STDMETHODIMP ConnectFilters(MCBackendWin *backend) { + IGraphBuilder *pGB = backend->pGB; + IBaseFilter *pSrc = backend->pSrcFilter; + IBaseFilter *pDst = backend->pDstFilter; + IPin *pOut = backend->pOutPin; + IPin *pIn = backend->pInPin; HRESULT hr; - hr = GetPin(g_pSrcFilter, PINDIR_OUTPUT , &g_pOutputPin); + hr = GetPin(pSrc, PINDIR_OUTPUT , &pOut); if (FAILED(hr)) { ERR("Failed to get output pin. 0x%x\n", hr); return hr; } - hr = GetPin(g_pDstFilter, PINDIR_INPUT , &g_pInputPin); + hr = GetPin(pDst, PINDIR_INPUT , &pIn); if (FAILED(hr)) { ERR("Failed to get input pin. 0x%x\n", hr); return hr; } - hr = g_pGB->lpVtbl->Connect(g_pGB, g_pOutputPin, g_pInputPin); + hr = pGB->lpVtbl->Connect(pGB, pOut, pIn); if (FAILED(hr)) { ERR("Failed to connect pins. 0x%x\n", hr); } return hr; } -static STDMETHODIMP DisconnectPins(void) +static STDMETHODIMP DisconnectPins(MCBackendWin *backend) { + IGraphBuilder *pGB = backend->pGB; + IPin *pOut = backend->pOutPin; + IPin *pIn = backend->pInPin; HRESULT hr; - hr = g_pGB->lpVtbl->Disconnect(g_pGB, g_pOutputPin); + hr = pGB->lpVtbl->Disconnect(pGB, pOut); if (FAILED(hr)) { ERR("Failed to disconnect output pin. 0x%x\n", hr); return hr; } - hr = g_pGB->lpVtbl->Disconnect(g_pGB, g_pInputPin); + hr = pGB->lpVtbl->Disconnect(pGB, pIn); if (FAILED(hr)) { ERR("Failed to disconnect input pin. 0x%x\n", hr); } @@ -1444,17 +1465,20 @@ static STDMETHODIMP DisconnectPins(void) return hr; } -static STDMETHODIMP RemoveFilters(void) +static STDMETHODIMP RemoveFilters(MCBackendWin *backend) { + IGraphBuilder *pGB = backend->pGB; + IBaseFilter *pSrc = backend->pSrcFilter; + IBaseFilter *pDst = backend->pDstFilter; HRESULT hr; - hr = g_pGB->lpVtbl->RemoveFilter(g_pGB, g_pSrcFilter); + hr = pGB->lpVtbl->RemoveFilter(pGB, pSrc); if (FAILED(hr)) { ERR("Failed to remove source filer. 0x%x\n", hr); return hr; } - hr = g_pGB->lpVtbl->RemoveFilter(g_pGB, g_pDstFilter); + hr = pGB->lpVtbl->RemoveFilter(pGB, pDst); if (FAILED(hr)) { ERR("Failed to remove destination filer. 0x%x\n", hr); } @@ -1465,8 +1489,8 @@ static STDMETHODIMP RemoveFilters(void) /* default fps is 15 */ #define MARUCAM_DEFAULT_FRAMEINTERVAL 666666 -static STDMETHODIMP SetFormat(uint32_t dwWidth, uint32_t dwHeight, - uint32_t dwDstFmt, uint32_t *dwSrcFmt) +static STDMETHODIMP SetFormat(MCBackendWin *backend, uint32_t dwWidth, + uint32_t dwHeight, uint32_t dwDstFmt) { HRESULT hr; IAMStreamConfig *pSConfig; @@ -1474,14 +1498,11 @@ static STDMETHODIMP SetFormat(uint32_t dwWidth, uint32_t dwHeight, DWORD dwYUY2 = MAKEFOURCC('Y', 'U', 'Y', '2'); DWORD dwI420 = MAKEFOURCC('I', '4', '2', '0'); - if (dwSrcFmt == NULL) { - ERR("invalid the source format pointer\n"); - return E_FAIL; - } - - hr = g_pCGB->lpVtbl->FindInterface(g_pCGB, &PIN_CATEGORY_CAPTURE, 0, - g_pSrcFilter, &IID_IAMStreamConfig, - (void **)&pSConfig); + hr = backend->pCGB->lpVtbl->FindInterface(backend->pCGB, + &PIN_CATEGORY_CAPTURE, 0, + backend->pSrcFilter, + &IID_IAMStreamConfig, + (void **)&pSConfig); if (FAILED(hr)) { ERR("failed to FindInterface method\n"); return hr; @@ -1509,12 +1530,12 @@ static STDMETHODIMP SetFormat(uint32_t dwWidth, uint32_t dwHeight, if ((pvi->bmiHeader.biWidth == (LONG)dwWidth) && (pvi->bmiHeader.biHeight == (LONG)dwHeight)) { if (pvi->bmiHeader.biCompression == dwYUY2) { - *dwSrcFmt = V4L2_PIX_FMT_YUYV; + backend->src_fmt = V4L2_PIX_FMT_YUYV; } else if ((pvi->bmiHeader.biCompression == BI_RGB) && (pvi->bmiHeader.biBitCount == 24)) { - *dwSrcFmt = V4L2_PIX_FMT_RGB24; + backend->src_fmt = V4L2_PIX_FMT_RGB24; } else if (pvi->bmiHeader.biCompression == dwI420) { - *dwSrcFmt = V4L2_PIX_FMT_YUV420; + backend->src_fmt = V4L2_PIX_FMT_YUV420; } else { /* not support format */ DeleteMediaType(pmtConfig); continue; @@ -1553,16 +1574,17 @@ static STDMETHODIMP SetFormat(uint32_t dwWidth, uint32_t dwHeight, return hr; } -static STDMETHODIMP QueryVideoProcAmp(long nProperty, long *pMin, long *pMax, +static STDMETHODIMP QueryVideoProcAmp(MCBackendWin *backend, long nProperty, + long *pMin, long *pMax, long *pStep, long *pDefault) { HRESULT hr; long Flags; IAMVideoProcAmp *pProcAmp = NULL; - hr = g_pSrcFilter->lpVtbl->QueryInterface(g_pSrcFilter, - &IID_IAMVideoProcAmp, - (void **)&pProcAmp); + hr = backend->pSrcFilter->lpVtbl->QueryInterface(backend->pSrcFilter, + &IID_IAMVideoProcAmp, + (void **)&pProcAmp); if (FAILED(hr)) { return hr; } @@ -1574,15 +1596,16 @@ static STDMETHODIMP QueryVideoProcAmp(long nProperty, long *pMin, long *pMax, return hr; } -static STDMETHODIMP GetVideoProcAmp(long nProperty, long *pValue) +static STDMETHODIMP GetVideoProcAmp(MCBackendWin *backend, + long nProperty, long *pValue) { HRESULT hr; long Flags; IAMVideoProcAmp *pProcAmp = NULL; - hr = g_pSrcFilter->lpVtbl->QueryInterface(g_pSrcFilter, - &IID_IAMVideoProcAmp, - (void **)&pProcAmp); + hr = backend->pSrcFilter->lpVtbl->QueryInterface(backend->pSrcFilter, + &IID_IAMVideoProcAmp, + (void **)&pProcAmp); if (FAILED(hr)) { return hr; } @@ -1596,14 +1619,15 @@ static STDMETHODIMP GetVideoProcAmp(long nProperty, long *pValue) return hr; } -static STDMETHODIMP SetVideoProcAmp(long nProperty, long value) +static STDMETHODIMP SetVideoProcAmp(MCBackendWin *backend, + long nProperty, long value) { HRESULT hr; IAMVideoProcAmp *pProcAmp = NULL; - hr = g_pSrcFilter->lpVtbl->QueryInterface(g_pSrcFilter, - &IID_IAMVideoProcAmp, - (void **)&pProcAmp); + hr = backend->pSrcFilter->lpVtbl->QueryInterface(backend->pSrcFilter, + &IID_IAMVideoProcAmp, + (void **)&pProcAmp); if (FAILED(hr)) { return hr; } @@ -1629,7 +1653,7 @@ static char *__wchar_to_char(const WCHAR *pwstr) return pstr; } -int marucam_device_check(int log_flag) +int marucam_device_check(void) { struct timeval t1, t2; int ret = 0; @@ -1770,20 +1794,6 @@ int marucam_device_check(int log_flag) hr = pBag->lpVtbl->Read(pBag, L"FriendlyName", &var, NULL); if (hr == S_OK) { ret = 1; - if (!log_flag) { - SysFreeString(var.bstrVal); - SAFE_RELEASE(pBag); - SAFE_RELEASE(pMoniKer); - SAFE_RELEASE(pEnumMK); - SAFE_RELEASE(pCreateDevEnum); - SAFE_RELEASE(pCGB); - SAFE_RELEASE(pGB); - CoUninitialize(); - gettimeofday(&t2, NULL); - ERR("Elapsed time : %lu.%06lu\n", - t2.tv_sec-t1.tv_sec, t2.tv_usec-t1.tv_usec); - return ret; - } device_name = __wchar_to_char(var.bstrVal); INFO("Device name : %s\n", device_name); g_free(device_name); @@ -1912,95 +1922,99 @@ int marucam_device_check(int log_flag) return ret; } -/* MARUCAM_CMD_INIT */ -void marucam_device_init(MaruCamState *state) +static void backend_win_init(MaruCamState *state) +{ +} + +static void backend_win_reset(MaruCamState *state) { - g_state = state; } -void marucam_device_exit(MaruCamState *state) +static void backend_win_release(MaruCamState *state) { } -/* MARUCAM_CMD_OPEN */ -void marucam_device_open(MaruCamState *state) +static void backend_win_open(MaruCamState *state) { HRESULT hr; - uint32_t dwHeight, dwWidth, dwDstFmt; - MaruCamParam *param = state->param; - param->top = 0; + MCBackendWin *backend = (MCBackendWin *)(state->backend); hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED); if (FAILED(hr)) { - ERR("CoInitailizeEx\n"); - ERR("camera device open failed!!!, [HRESULT : 0x%x]\n", hr); - param->errCode = EINVAL; + ERR("CoInitailizeEx failure\n"); + ERR("Device open failed: HRESULT(0x%x)\n", hr); + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } - hr = GraphBuilder_Init(); + hr = GraphBuilder_Init(backend); if (FAILED(hr)) { ERR("GraphBuilder_Init\n"); - DisconnectPins(); - RemoveFilters(); - CloseInterfaces(); + ERR("Device open failed: HRESULT(0x%x)\n", hr); + DisconnectPins(backend); + RemoveFilters(backend); + CloseInterfaces(backend); CoUninitialize(); - param->errCode = EINVAL; - ERR("camera device open failed!!!, [HRESULT : 0x%x]\n", hr); + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } - hr = BindSourceFilter(); + hr = BindSourceFilter(backend); if (FAILED(hr)) { ERR("BindSourceFilter\n"); - DisconnectPins(); - RemoveFilters(); - CloseInterfaces(); + ERR("Device open failed: HRESULT(0x%x)\n", hr); + DisconnectPins(backend); + RemoveFilters(backend); + CloseInterfaces(backend); CoUninitialize(); - param->errCode = EINVAL; - ERR("camera device open failed!!!, [HRESULT : 0x%x]\n", hr); + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } - hr = BindTargetFilter(); + hr = BindTargetFilter(backend); if (FAILED(hr)) { ERR("BindTargetFilter\n"); - DisconnectPins(); - RemoveFilters(); - CloseInterfaces(); + ERR("Device open failed: HRESULT(0x%x)\n", hr); + DisconnectPins(backend); + RemoveFilters(backend); + CloseInterfaces(backend); CoUninitialize(); - param->errCode = EINVAL; - ERR("camera device open failed!!!, [HRESULT : 0x%x]\n", hr); + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } - hr = ConnectFilters(); + hr = ConnectFilters(backend); if (FAILED(hr)) { ERR("ConnectFilters\n"); - DisconnectPins(); - RemoveFilters(); - CloseInterfaces(); + ERR("Device open failed: HRESULT(0x%x)\n", hr); + DisconnectPins(backend); + RemoveFilters(backend); + CloseInterfaces(backend); CoUninitialize(); - param->errCode = EINVAL; - ERR("camera device open failed!!!, [HRESULT : 0x%x]\n", hr); + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } - cur_frame_idx = 0; - cur_fmt_idx = 0; - - dwHeight = supported_dst_frames[cur_frame_idx].height; - dwWidth = supported_dst_frames[cur_frame_idx].width; - dwDstFmt = supported_dst_pixfmts[cur_fmt_idx].fmt; - hr = SetFormat(dwWidth, dwHeight, dwDstFmt, &g_dwSrcFmt); + /* 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]; + hr = SetFormat(backend, backend->dst_width, backend->dst_height, + backend->dst_fmt); if (hr != S_OK) { ERR("failed to Set default values\n"); - DisconnectPins(); - RemoveFilters(); - CloseInterfaces(); + ERR("Device open failed: HRESULT(0x%x)\n", hr); + DisconnectPins(backend); + RemoveFilters(backend); + CloseInterfaces(backend); CoUninitialize(); - param->errCode = EINVAL; - ERR("camera device open failed!!!, [HRESULT : 0x%x]\n", hr); + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } @@ -2008,41 +2022,37 @@ void marucam_device_open(MaruCamState *state) return; } -/* MARUCAM_CMD_CLOSE */ -void marucam_device_close(MaruCamState *state) +static void backend_win_close(MaruCamState *state) { - MaruCamParam *param = state->param; - int ret = 0; - param->top = 0; + uint32_t ret; + MCBackendWin *backend = (MCBackendWin *)(state->backend); qemu_mutex_lock(&state->thread_mutex); ret = state->streamon; qemu_mutex_unlock(&state->thread_mutex); if (ret) { - marucam_device_stop_preview(state); + state->backend->stream_off(state); } - if (g_pGB) { - DisconnectPins(); - RemoveFilters(); + if (backend->pGB) { + DisconnectPins(backend); + RemoveFilters(backend); } - CloseInterfaces(); + CloseInterfaces(backend); CoUninitialize(); INFO("Closed\n"); } -/* MARUCAM_CMD_START_PREVIEW */ -void marucam_device_start_preview(MaruCamState *state) +static void backend_win_stream_on(MaruCamState *state) { HRESULT hr; uint32_t pixfmt, width, height; - MaruCamParam *param = state->param; - param->top = 0; + MCBackendWin *backend = (MCBackendWin *)(state->backend); - ready_count = 0; - width = supported_dst_frames[cur_frame_idx].width; - height = supported_dst_frames[cur_frame_idx].height; - pixfmt = supported_dst_pixfmts[cur_fmt_idx].fmt; + backend->ready_count = 0; + width = backend->dst_width; + height = backend->dst_height; + pixfmt = backend->dst_fmt; state->buf_size = get_sizeimage(pixfmt, width, height); INFO("Pixfmt(%c%c%c%c), W:H(%d:%d), buf size(%u)\n", @@ -2051,29 +2061,32 @@ void marucam_device_start_preview(MaruCamState *state) width, height, state->buf_size); INFO("Starting preview\n"); - assert(g_pCallback != NULL); - hr = ((HWCInPin *)g_pInputPin)->SetGrabCallbackIF(g_pInputPin, - g_pCallback); + assert(backend->pCallback != NULL); + hr = ((HWCInPin *)backend->pInPin)->SetGrabCb(backend->pInPin, + backend->pCallback); if (FAILED(hr)) { ERR("Failed to set IGrabCallback interface.\n"); - param->errCode = EINVAL; + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } - if (grab_buf) { - g_free(grab_buf); - grab_buf = NULL; + if (backend->buf) { + g_free(backend->buf); + backend->buf = NULL; } - grab_buf = (void *)g_malloc0(state->buf_size); - if (grab_buf == NULL) { - param->errCode = ENOMEM; + backend->buf = (void *)g_malloc0(state->buf_size); + if (backend->buf == NULL) { + state->io_ptr->err_code = ENOMEM; + state->io_ptr->ret_val = -1; return; } - hr = g_pMediaControl->lpVtbl->Run(g_pMediaControl); + hr = backend->pMC->lpVtbl->Run(backend->pMC); if (FAILED(hr)) { ERR("Failed to run media control. hr=0x%x\n", hr); - param->errCode = EINVAL; + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } @@ -2084,416 +2097,464 @@ void marucam_device_start_preview(MaruCamState *state) INFO("Streaming on ......\n"); } -/* MARUCAM_CMD_STOP_PREVIEW */ -void marucam_device_stop_preview(MaruCamState *state) +static void backend_win_stream_off(MaruCamState *state) { HRESULT hr; - MaruCamParam *param = state->param; - param->top = 0; + MCBackendWin *backend = (MCBackendWin *)(state->backend); INFO("...... Streaming off\n"); qemu_mutex_lock(&state->thread_mutex); state->streamon = 0; qemu_mutex_unlock(&state->thread_mutex); - hr = ((HWCInPin *)g_pInputPin)->SetGrabCallbackIF(g_pInputPin, NULL); + hr = ((HWCInPin *)backend->pInPin)->SetGrabCb(backend->pInPin, NULL); if (FAILED(hr)) { ERR("Failed to set IGrabCallback interface.\n"); - param->errCode = EINVAL; + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } - hr = g_pMediaControl->lpVtbl->Stop(g_pMediaControl); + hr = backend->pMC->lpVtbl->Stop(backend->pMC); if (FAILED(hr)) { ERR("Failed to stop media control.\n"); - param->errCode = EINVAL; + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } - if (grab_buf) { - g_free(grab_buf); - grab_buf = NULL; + if (backend->buf) { + g_free(backend->buf); + backend->buf = NULL; } state->buf_size = 0; INFO("Stopping preview\n"); } -/* MARUCAM_CMD_S_PARAM */ -void marucam_device_s_param(MaruCamState *state) +static void backend_win_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_win_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 = V4L2_CAP_TIMEPERFRAME; + cp->timeperframe.numerator = 1; + cp->timeperframe.denominator = 30; } -/* MARUCAM_CMD_S_FMT */ -void marucam_device_s_fmt(MaruCamState *state) +static void backend_win_s_fmt(MaruCamState *state) { - uint32_t width, height, pixfmt, pidx, fidx; - MaruCamParam *param = state->param; - - 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; + MCBackendWin *backend = (MCBackendWin *)(state->backend); - 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) { + for (pidx = 0; pidx < ARRAY_SIZE(support_fmts); pidx++) { + if (support_fmts[pidx] == f->fmt.pix.pixelformat) { 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)) { - HRESULT hr = SetFormat(width, height, pixfmt, &g_dwSrcFmt); + if ((backend->dst_width != f->fmt.pix.width) && + (backend->dst_height != f->fmt.pix.height)) { + HRESULT hr = SetFormat(backend, f->fmt.pix.width, f->fmt.pix.height, + f->fmt.pix.pixelformat); if (FAILED(hr)) { - param->errCode = EINVAL; + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } } - cur_frame_idx = fidx; - cur_fmt_idx = pidx; + 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]; - 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.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("Set 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_win_g_fmt(MaruCamState *state) { - uint32_t width, height, pixfmt; - MaruCamParam *param = state->param; - - 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; + struct v4l2_format *f = (struct v4l2_format *)state->io_ptr->data; + MCBackendWin *backend = (MCBackendWin *)(state->backend); - 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.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; - TRACE("Get 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_win_try_fmt(MaruCamState *state) { - uint32_t width, height, pixfmt, i; - MaruCamParam *param = state->param; - - param->top = 0; - width = param->stack[0]; - height = param->stack[1]; - pixfmt = param->stack[2]; + uint32_t i; + struct v4l2_format *f = (struct v4l2_format *)state->io_ptr->data; - for (i = 0; i < ARRAY_SIZE(supported_dst_frames); i++) { - if ((supported_dst_frames[i].width == width) && - (supported_dst_frames[i].height == height)) { + 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(supported_dst_frames)) { - param->errCode = EINVAL; + 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(supported_dst_pixfmts); i++) { - if (supported_dst_pixfmts[i].fmt == pixfmt) { + for (i = 0; i < ARRAY_SIZE(support_fmts); i++) { + if (support_fmts[i] == f->fmt.pix.pixelformat) { 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] = 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(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); } -void marucam_device_enum_fmt(MaruCamState *state) +static void backend_win_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 */ + + f->flags = 0; /* flags = NONE */ + f->pixelformat = support_fmts[f->index]; + /* set description */ - switch (supported_dst_pixfmts[index].fmt) { + switch (support_fmts[f->index]) { case V4L2_PIX_FMT_YUYV: - memcpy(¶m->stack[3], "YUYV", 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: - ERR("Invalid pixel format\n"); - param->errCode = EINVAL; + ERR("Invalid fixel format\n"); + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; break; } } -void marucam_device_qctrl(MaruCamState *state) +static void backend_win_query_ctrl(MaruCamState *state) { HRESULT hr; - uint32_t id, i; + uint32_t 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]; + struct v4l2_queryctrl *qc = (struct v4l2_queryctrl *)state->io_ptr->data; + MCBackendWin *backend = (MCBackendWin *)(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"); - property = VideoProcAmp_Brightness; - memcpy((void *)name, (void *)"brightness", 32); + TRACE("Query : BRIGHTNESS\n"); + pstrcpy((char *)qc->name, sizeof(qc->name), "brightness"); i = 0; + property = VideoProcAmp_Brightness; break; case V4L2_CID_CONTRAST: - TRACE("V4L2_CID_CONTRAST\n"); - property = VideoProcAmp_Contrast; - memcpy((void *)name, (void *)"contrast", 32); + TRACE("Query : CONTRAST\n"); + pstrcpy((char *)qc->name, sizeof(qc->name), "contrast"); i = 1; + property = VideoProcAmp_Contrast; break; case V4L2_CID_SATURATION: - TRACE("V4L2_CID_SATURATION\n"); - property = VideoProcAmp_Saturation; - memcpy((void *)name, (void *)"saturation", 32); + TRACE("Query : SATURATION\n"); + pstrcpy((char *)qc->name, sizeof(qc->name), "saturation"); i = 2; + property = VideoProcAmp_Saturation; break; case V4L2_CID_SHARPNESS: - TRACE("V4L2_CID_SHARPNESS\n"); - property = VideoProcAmp_Sharpness; - memcpy((void *)name, (void *)"sharpness", 32); + TRACE("Query : SHARPNESS\n"); + pstrcpy((char *)qc->name, sizeof(qc->name), "sharpness"); i = 3; + property = VideoProcAmp_Sharpness; break; default: ERR("Invalid control ID\n"); - param->errCode = EINVAL; + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } - hr = QueryVideoProcAmp(property, &min, &max, &step, &def_val); + hr = QueryVideoProcAmp(backend, property, &min, &max, &step, &def_val); if (FAILED(hr)) { - param->errCode = EINVAL; - ERR("failed to query video controls [HRESULT : 0x%x]\n", hr); + ERR("Failed to query video controls: HRESULT(0x%x)\n", hr); + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } else { - qctrl_tbl[i].hit = 1; - qctrl_tbl[i].min = min; - qctrl_tbl[i].max = max; - qctrl_tbl[i].step = step; - qctrl_tbl[i].init_val = def_val; + ctrl_tbl[i].hit = 1; + ctrl_tbl[i].min = min; + ctrl_tbl[i].max = max; + ctrl_tbl[i].step = step; + ctrl_tbl[i].init_val = def_val; - if ((qctrl_tbl[i].min + qctrl_tbl[i].max) == 0) { + if ((ctrl_tbl[i].min + ctrl_tbl[i].max) == 0) { set_val = 0; } else { - set_val = (qctrl_tbl[i].min + qctrl_tbl[i].max) / 2; + set_val = (ctrl_tbl[i].min + ctrl_tbl[i].max) / 2; } - hr = SetVideoProcAmp(property, set_val); + hr = SetVideoProcAmp(backend, property, set_val); if (FAILED(hr)) { - param->errCode = EINVAL; - ERR("failed to set video control value, [HRESULT : 0x%x]\n", hr); + ERR("Failed to set video control value when query controls: " + "HRESULT(0x%x)\n", hr); + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } + INFO("Query Control: id(0x%x), name(%s), " + "min(%l), max(%l), step(%l), " + "def_value(%l), set_value(%l)\n", + qc->id, qc->name, min, max, + step, def_val, set_val); } - 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_win_s_ctrl(MaruCamState *state) { HRESULT hr; uint32_t i; long property, set_val; - MaruCamParam *param = state->param; - - param->top = 0; + struct v4l2_control *ctrl = (struct v4l2_control *)state->io_ptr->data; + MCBackendWin *backend = (MCBackendWin *)(state->backend); - switch (param->stack[0]) { + switch (ctrl->id) { case V4L2_CID_BRIGHTNESS: + TRACE("%d is set to the value of the BRIGHTNESS\n", ctrl->value); i = 0; property = VideoProcAmp_Brightness; break; case V4L2_CID_CONTRAST: + TRACE("%d is set to the value of the CONTRAST\n", ctrl->value); i = 1; property = VideoProcAmp_Contrast; break; case V4L2_CID_SATURATION: + TRACE("%d is set to the value of the SATURATION\n", ctrl->value); i = 2; property = VideoProcAmp_Saturation; break; case V4L2_CID_SHARPNESS: + TRACE("%d is set to the value of the SHARPNESS\n", ctrl->value); i = 3; property = VideoProcAmp_Sharpness; break; default: - param->errCode = EINVAL; + ERR("Our emulator does not support this control: 0x%x\n", ctrl->id); + state->io_ptr->err_code= EINVAL; + state->io_ptr->ret_val = -1; return; } - set_val = value_convert_from_guest(qctrl_tbl[i].min, - qctrl_tbl[i].max, (long)param->stack[1]); - hr = SetVideoProcAmp(property, set_val); + set_val = value_convert_from_guest(ctrl_tbl[i].min, + ctrl_tbl[i].max, (long)ctrl->value); + hr = SetVideoProcAmp(backend, property, set_val); if (FAILED(hr)) { - param->errCode = EINVAL; - ERR("failed to set video control value, [HRESULT : 0x%x]\n", hr); + ERR("Failed to set video control value: HRESULT(0x%x)\n", hr); + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } } -void marucam_device_g_ctrl(MaruCamState *state) +static void backend_win_g_ctrl(MaruCamState *state) { HRESULT hr; uint32_t i; long property, get_val; - MaruCamParam *param = state->param; + struct v4l2_control *ctrl = (struct v4l2_control *)state->io_ptr->data; + MCBackendWin *backend = (MCBackendWin *)(state->backend); - param->top = 0; - switch (param->stack[0]) { + switch (ctrl->id) { case V4L2_CID_BRIGHTNESS: + TRACE("To get a value of the BRIGHTNESS\n"); i = 0; property = VideoProcAmp_Brightness; break; case V4L2_CID_CONTRAST: + TRACE("To get a value of the CONTRAST\n"); i = 1; property = VideoProcAmp_Contrast; break; case V4L2_CID_SATURATION: + TRACE("To get a value of the SATURATION\n"); i = 2; property = VideoProcAmp_Saturation; break; case V4L2_CID_SHARPNESS: + TRACE("To get a value of the SHARPNESS\n"); i = 3; property = VideoProcAmp_Sharpness; break; default: - param->errCode = EINVAL; + ERR("Our emulator does not support this control: 0x%x\n", ctrl->id); + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } - hr = GetVideoProcAmp(property, &get_val); + hr = GetVideoProcAmp(backend, property, &get_val); if (FAILED(hr)) { - param->errCode = EINVAL; - ERR("failed to get video control value!!!, [HRESULT : 0x%x]\n", hr); + ERR("Failed to get video control value: HRESULT(0x%x)\n", hr); + state->io_ptr->err_code = EINVAL; + state->io_ptr->ret_val = -1; return; } - param->stack[0] = (uint32_t)value_convert_to_guest(qctrl_tbl[i].min, - qctrl_tbl[i].max, get_val); + + ctrl->value = (uint32_t)value_convert_to_guest(ctrl_tbl[i].min, + ctrl_tbl[i].max, get_val); + TRACE("Value: %u\n", ctrl->value); } -void marucam_device_enum_fsizes(MaruCamState *state) +static void backend_win_enum_fsizes(MaruCamState *state) { - uint32_t index, pixfmt, i; - MaruCamParam *param = state->param; - - param->top = 0; - index = param->stack[0]; - pixfmt = param->stack[1]; + struct v4l2_frmsizeenum *fsize = (struct v4l2_frmsizeenum *)state->io_ptr->data; + uint32_t i; - 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_win_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) +{ + MCBackendWin *backend_win; + + backend_win = g_new0(MCBackendWin, 1); + + backend_win->base.state = state; + backend_win->base.init = backend_win_init; + backend_win->base.reset = backend_win_reset; + backend_win->base.release = backend_win_release; + backend_win->base.open = backend_win_open; + backend_win->base.close = backend_win_close; + backend_win->base.stream_on = backend_win_stream_on; + backend_win->base.stream_off = backend_win_stream_off; + backend_win->base.enum_fmt = backend_win_enum_fmt; + backend_win->base.try_fmt = backend_win_try_fmt; + backend_win->base.s_fmt = backend_win_s_fmt; + backend_win->base.g_fmt = backend_win_g_fmt; + backend_win->base.s_parm = backend_win_s_parm; + backend_win->base.g_parm = backend_win_g_parm; + backend_win->base.query_ctrl = backend_win_query_ctrl; + backend_win->base.s_ctrl = backend_win_s_ctrl; + backend_win->base.g_ctrl = backend_win_g_ctrl; + backend_win->base.enum_framesizes = backend_win_enum_fsizes; + backend_win->base.enum_frameintervals = backend_win_enum_fintv; + + return &backend_win->base; } diff --git a/tizen/src/hw/pci/videodev2_min.h b/tizen/src/hw/pci/videodev2_min.h new file mode 100644 index 0000000000..03012d4165 --- /dev/null +++ b/tizen/src/hw/pci/videodev2_min.h @@ -0,0 +1,887 @@ +/* + * Video for Linux Two header file + * + * Copyright (C) 1999-2012 the contributors + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * Alternatively you can redistribute this file under the terms of the + * BSD license as stated below: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * 3. The names of its contributors may not be used to endorse or promote + * products derived from this software without specific prior written + * permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Header file for v4l or V4L2 drivers and applications + * with public API. + * All kernel-specific stuff were moved to media/v4l2-dev.h, so + * no #if __KERNEL tests are allowed here + * + * See http://linuxtv.org for more info + * + * Author: Bill Dirks + * Justin Schoeman + * Hans Verkuil + * et al. + */ + + /* This file has been modified from the videodev2.h for the Tizen emulator. */ +#ifndef __VIDEODEV2_MIN_H +#define __VIDEODEV2_MIN_H + +/* + * Common stuff for both V4L1 and V4L2 + * Moved from videodev.h + */ +#define VIDEO_MAX_FRAME 32 +#define VIDEO_MAX_PLANES 8 + +typedef signed char __s8; +typedef signed short __s16; +typedef signed int __s32; +typedef signed long long __s64; +typedef unsigned char __u8; +typedef unsigned short __u16; +typedef unsigned int __u32; +typedef unsigned long long __u64; + +/* + * M I S C E L L A N E O U S + */ + +/* V4L2 defines copy from videodev2.h */ +#define V4L2_CTRL_FLAG_SLIDER 0x0020 + +#define V4L2_CTRL_CLASS_USER 0x00980000 +#define V4L2_CID_BASE (V4L2_CTRL_CLASS_USER | 0x900) +#define V4L2_CID_BRIGHTNESS (V4L2_CID_BASE + 0) +#define V4L2_CID_CONTRAST (V4L2_CID_BASE + 1) +#define V4L2_CID_SATURATION (V4L2_CID_BASE + 2) +#define V4L2_CID_SHARPNESS (V4L2_CID_BASE + 27) + +/* Four-character-code (FOURCC) */ +#define v4l2_fourcc(a, b, c, d)\ + ((__u32)(a) | ((__u32)(b) << 8) | ((__u32)(c) << 16) | ((__u32)(d) << 24)) + +/* + * E N U M S + */ +enum v4l2_field { + V4L2_FIELD_ANY = 0, /* driver can choose from none, + top, bottom, interlaced + depending on whatever it thinks + is approximate ... */ + V4L2_FIELD_NONE = 1, /* this device has no fields ... */ + V4L2_FIELD_TOP = 2, /* top field only */ + V4L2_FIELD_BOTTOM = 3, /* bottom field only */ + V4L2_FIELD_INTERLACED = 4, /* both fields interlaced */ + V4L2_FIELD_SEQ_TB = 5, /* both fields sequential into one + buffer, top-bottom order */ + V4L2_FIELD_SEQ_BT = 6, /* same as above + bottom-top order */ + V4L2_FIELD_ALTERNATE = 7, /* both fields alternating into + separate buffers */ + V4L2_FIELD_INTERLACED_TB = 8, /* both fields interlaced, top field + first and the top field is + transmitted first */ + V4L2_FIELD_INTERLACED_BT = 9, /* both fields interlaced, top field + first and the bottom field is + transmitted first */ +}; +#define V4L2_FIELD_HAS_TOP(field) \ + ((field) == V4L2_FIELD_TOP ||\ + (field) == V4L2_FIELD_INTERLACED ||\ + (field) == V4L2_FIELD_INTERLACED_TB ||\ + (field) == V4L2_FIELD_INTERLACED_BT ||\ + (field) == V4L2_FIELD_SEQ_TB ||\ + (field) == V4L2_FIELD_SEQ_BT) +#define V4L2_FIELD_HAS_BOTTOM(field) \ + ((field) == V4L2_FIELD_BOTTOM ||\ + (field) == V4L2_FIELD_INTERLACED ||\ + (field) == V4L2_FIELD_INTERLACED_TB ||\ + (field) == V4L2_FIELD_INTERLACED_BT ||\ + (field) == V4L2_FIELD_SEQ_TB ||\ + (field) == V4L2_FIELD_SEQ_BT) +#define V4L2_FIELD_HAS_BOTH(field) \ + ((field) == V4L2_FIELD_INTERLACED ||\ + (field) == V4L2_FIELD_INTERLACED_TB ||\ + (field) == V4L2_FIELD_INTERLACED_BT ||\ + (field) == V4L2_FIELD_SEQ_TB ||\ + (field) == V4L2_FIELD_SEQ_BT) + +enum v4l2_buf_type { + V4L2_BUF_TYPE_VIDEO_CAPTURE = 1, + V4L2_BUF_TYPE_VIDEO_OUTPUT = 2, + V4L2_BUF_TYPE_VIDEO_OVERLAY = 3, + V4L2_BUF_TYPE_VBI_CAPTURE = 4, + V4L2_BUF_TYPE_VBI_OUTPUT = 5, + V4L2_BUF_TYPE_SLICED_VBI_CAPTURE = 6, + V4L2_BUF_TYPE_SLICED_VBI_OUTPUT = 7, +#if 1 + /* Experimental */ + V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = 8, +#endif + V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE = 9, + V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE = 10, + /* Deprecated, do not use */ + V4L2_BUF_TYPE_PRIVATE = 0x80, +}; + +#define V4L2_TYPE_IS_MULTIPLANAR(type) \ + ((type) == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE \ + || (type) == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) + +#define V4L2_TYPE_IS_OUTPUT(type) \ + ((type) == V4L2_BUF_TYPE_VIDEO_OUTPUT \ + || (type) == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE \ + || (type) == V4L2_BUF_TYPE_VIDEO_OVERLAY \ + || (type) == V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY \ + || (type) == V4L2_BUF_TYPE_VBI_OUTPUT \ + || (type) == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) + +enum v4l2_tuner_type { + V4L2_TUNER_RADIO = 1, + V4L2_TUNER_ANALOG_TV = 2, + V4L2_TUNER_DIGITAL_TV = 3, +}; + +enum v4l2_memory { + V4L2_MEMORY_MMAP = 1, + V4L2_MEMORY_USERPTR = 2, + V4L2_MEMORY_OVERLAY = 3, + V4L2_MEMORY_DMABUF = 4, +}; + +/* see also http://vektor.theorem.ca/graphics/ycbcr/ */ +enum v4l2_colorspace { + /* ITU-R 601 -- broadcast NTSC/PAL */ + V4L2_COLORSPACE_SMPTE170M = 1, + + /* 1125-Line (US) HDTV */ + V4L2_COLORSPACE_SMPTE240M = 2, + + /* HD and modern captures. */ + V4L2_COLORSPACE_REC709 = 3, + + /* broken BT878 extents (601, luma range 16-253 instead of 16-235) */ + V4L2_COLORSPACE_BT878 = 4, + + /* These should be useful. Assume 601 extents. */ + V4L2_COLORSPACE_470_SYSTEM_M = 5, + V4L2_COLORSPACE_470_SYSTEM_BG = 6, + + /* I know there will be cameras that send this. So, this is + * unspecified chromaticities and full 0-255 on each of the + * Y'CbCr components + */ + V4L2_COLORSPACE_JPEG = 7, + + /* For RGB colourspaces, this is probably a good start. */ + V4L2_COLORSPACE_SRGB = 8, +}; + +enum v4l2_priority { + V4L2_PRIORITY_UNSET = 0, /* not initialized */ + V4L2_PRIORITY_BACKGROUND = 1, + V4L2_PRIORITY_INTERACTIVE = 2, + V4L2_PRIORITY_RECORD = 3, + V4L2_PRIORITY_DEFAULT = V4L2_PRIORITY_INTERACTIVE, +}; + +struct v4l2_rect { + __s32 left; + __s32 top; + __s32 width; + __s32 height; +}; + +struct v4l2_fract { + __u32 numerator; + __u32 denominator; +}; + +/* + * V I D E O I M A G E F O R M A T + */ +struct v4l2_pix_format { + __u32 width; + __u32 height; + __u32 pixelformat; + __u32 field; /* enum v4l2_field */ + __u32 bytesperline; /* for padding, zero if unused */ + __u32 sizeimage; + __u32 colorspace; /* enum v4l2_colorspace */ + __u32 priv; /* private data, depends on pixelformat */ +}; + +/* Pixel format FOURCC depth Description */ + +/* RGB formats */ +#define V4L2_PIX_FMT_RGB332 v4l2_fourcc('R', 'G', 'B', '1') /* 8 RGB-3-3-2 */ +#define V4L2_PIX_FMT_RGB444 v4l2_fourcc('R', '4', '4', '4') /* 16 xxxxrrrr ggggbbbb */ +#define V4L2_PIX_FMT_RGB555 v4l2_fourcc('R', 'G', 'B', 'O') /* 16 RGB-5-5-5 */ +#define V4L2_PIX_FMT_RGB565 v4l2_fourcc('R', 'G', 'B', 'P') /* 16 RGB-5-6-5 */ +#define V4L2_PIX_FMT_RGB555X v4l2_fourcc('R', 'G', 'B', 'Q') /* 16 RGB-5-5-5 BE */ +#define V4L2_PIX_FMT_RGB565X v4l2_fourcc('R', 'G', 'B', 'R') /* 16 RGB-5-6-5 BE */ +#define V4L2_PIX_FMT_BGR666 v4l2_fourcc('B', 'G', 'R', 'H') /* 18 BGR-6-6-6 */ +#define V4L2_PIX_FMT_BGR24 v4l2_fourcc('B', 'G', 'R', '3') /* 24 BGR-8-8-8 */ +#define V4L2_PIX_FMT_RGB24 v4l2_fourcc('R', 'G', 'B', '3') /* 24 RGB-8-8-8 */ +#define V4L2_PIX_FMT_BGR32 v4l2_fourcc('B', 'G', 'R', '4') /* 32 BGR-8-8-8-8 */ +#define V4L2_PIX_FMT_RGB32 v4l2_fourcc('R', 'G', 'B', '4') /* 32 RGB-8-8-8-8 */ + +/* Grey formats */ +#define V4L2_PIX_FMT_GREY v4l2_fourcc('G', 'R', 'E', 'Y') /* 8 Greyscale */ +#define V4L2_PIX_FMT_Y4 v4l2_fourcc('Y', '0', '4', ' ') /* 4 Greyscale */ +#define V4L2_PIX_FMT_Y6 v4l2_fourcc('Y', '0', '6', ' ') /* 6 Greyscale */ +#define V4L2_PIX_FMT_Y10 v4l2_fourcc('Y', '1', '0', ' ') /* 10 Greyscale */ +#define V4L2_PIX_FMT_Y12 v4l2_fourcc('Y', '1', '2', ' ') /* 12 Greyscale */ +#define V4L2_PIX_FMT_Y16 v4l2_fourcc('Y', '1', '6', ' ') /* 16 Greyscale */ + +/* Grey bit-packed formats */ +#define V4L2_PIX_FMT_Y10BPACK v4l2_fourcc('Y', '1', '0', 'B') /* 10 Greyscale bit-packed */ + +/* Palette formats */ +#define V4L2_PIX_FMT_PAL8 v4l2_fourcc('P', 'A', 'L', '8') /* 8 8-bit palette */ + +/* Chrominance formats */ +#define V4L2_PIX_FMT_UV8 v4l2_fourcc('U', 'V', '8', ' ') /* 8 UV 4:4 */ + +/* Luminance+Chrominance formats */ +#define V4L2_PIX_FMT_YVU410 v4l2_fourcc('Y', 'V', 'U', '9') /* 9 YVU 4:1:0 */ +#define V4L2_PIX_FMT_YVU420 v4l2_fourcc('Y', 'V', '1', '2') /* 12 YVU 4:2:0 */ +#define V4L2_PIX_FMT_YUYV v4l2_fourcc('Y', 'U', 'Y', 'V') /* 16 YUV 4:2:2 */ +#define V4L2_PIX_FMT_YYUV v4l2_fourcc('Y', 'Y', 'U', 'V') /* 16 YUV 4:2:2 */ +#define V4L2_PIX_FMT_YVYU v4l2_fourcc('Y', 'V', 'Y', 'U') /* 16 YVU 4:2:2 */ +#define V4L2_PIX_FMT_UYVY v4l2_fourcc('U', 'Y', 'V', 'Y') /* 16 YUV 4:2:2 */ +#define V4L2_PIX_FMT_VYUY v4l2_fourcc('V', 'Y', 'U', 'Y') /* 16 YUV 4:2:2 */ +#define V4L2_PIX_FMT_YUV422P v4l2_fourcc('4', '2', '2', 'P') /* 16 YVU422 planar */ +#define V4L2_PIX_FMT_YUV411P v4l2_fourcc('4', '1', '1', 'P') /* 16 YVU411 planar */ +#define V4L2_PIX_FMT_Y41P v4l2_fourcc('Y', '4', '1', 'P') /* 12 YUV 4:1:1 */ +#define V4L2_PIX_FMT_YUV444 v4l2_fourcc('Y', '4', '4', '4') /* 16 xxxxyyyy uuuuvvvv */ +#define V4L2_PIX_FMT_YUV555 v4l2_fourcc('Y', 'U', 'V', 'O') /* 16 YUV-5-5-5 */ +#define V4L2_PIX_FMT_YUV565 v4l2_fourcc('Y', 'U', 'V', 'P') /* 16 YUV-5-6-5 */ +#define V4L2_PIX_FMT_YUV32 v4l2_fourcc('Y', 'U', 'V', '4') /* 32 YUV-8-8-8-8 */ +#define V4L2_PIX_FMT_YUV410 v4l2_fourcc('Y', 'U', 'V', '9') /* 9 YUV 4:1:0 */ +#define V4L2_PIX_FMT_YUV420 v4l2_fourcc('Y', 'U', '1', '2') /* 12 YUV 4:2:0 */ +#define V4L2_PIX_FMT_HI240 v4l2_fourcc('H', 'I', '2', '4') /* 8 8-bit color */ +#define V4L2_PIX_FMT_HM12 v4l2_fourcc('H', 'M', '1', '2') /* 8 YUV 4:2:0 16x16 macroblocks */ +#define V4L2_PIX_FMT_M420 v4l2_fourcc('M', '4', '2', '0') /* 12 YUV 4:2:0 2 lines y, 1 line uv interleaved */ + +/* two planes -- one Y, one Cr + Cb interleaved */ +#define V4L2_PIX_FMT_NV12 v4l2_fourcc('N', 'V', '1', '2') /* 12 Y/CbCr 4:2:0 */ +#define V4L2_PIX_FMT_NV21 v4l2_fourcc('N', 'V', '2', '1') /* 12 Y/CrCb 4:2:0 */ +#define V4L2_PIX_FMT_NV16 v4l2_fourcc('N', 'V', '1', '6') /* 16 Y/CbCr 4:2:2 */ +#define V4L2_PIX_FMT_NV61 v4l2_fourcc('N', 'V', '6', '1') /* 16 Y/CrCb 4:2:2 */ +#define V4L2_PIX_FMT_NV24 v4l2_fourcc('N', 'V', '2', '4') /* 24 Y/CbCr 4:4:4 */ +#define V4L2_PIX_FMT_NV42 v4l2_fourcc('N', 'V', '4', '2') /* 24 Y/CrCb 4:4:4 */ + +/* two non contiguous planes - one Y, one Cr + Cb interleaved */ +#define V4L2_PIX_FMT_NV12M v4l2_fourcc('N', 'M', '1', '2') /* 12 Y/CbCr 4:2:0 */ +#define V4L2_PIX_FMT_NV21M v4l2_fourcc('N', 'M', '2', '1') /* 21 Y/CrCb 4:2:0 */ +#define V4L2_PIX_FMT_NV16M v4l2_fourcc('N', 'M', '1', '6') /* 16 Y/CbCr 4:2:2 */ +#define V4L2_PIX_FMT_NV61M v4l2_fourcc('N', 'M', '6', '1') /* 16 Y/CrCb 4:2:2 */ +#define V4L2_PIX_FMT_NV12MT v4l2_fourcc('T', 'M', '1', '2') /* 12 Y/CbCr 4:2:0 64x32 macroblocks */ +#define V4L2_PIX_FMT_NV12MT_16X16 v4l2_fourcc('V', 'M', '1', '2') /* 12 Y/CbCr 4:2:0 16x16 macroblocks */ + +/* three non contiguous planes - Y, Cb, Cr */ +#define V4L2_PIX_FMT_YUV420M v4l2_fourcc('Y', 'M', '1', '2') /* 12 YUV420 planar */ +#define V4L2_PIX_FMT_YVU420M v4l2_fourcc('Y', 'M', '2', '1') /* 12 YVU420 planar */ + +/* Bayer formats - see http://www.siliconimaging.com/RGB%20Bayer.htm */ +#define V4L2_PIX_FMT_SBGGR8 v4l2_fourcc('B', 'A', '8', '1') /* 8 BGBG.. GRGR.. */ +#define V4L2_PIX_FMT_SGBRG8 v4l2_fourcc('G', 'B', 'R', 'G') /* 8 GBGB.. RGRG.. */ +#define V4L2_PIX_FMT_SGRBG8 v4l2_fourcc('G', 'R', 'B', 'G') /* 8 GRGR.. BGBG.. */ +#define V4L2_PIX_FMT_SRGGB8 v4l2_fourcc('R', 'G', 'G', 'B') /* 8 RGRG.. GBGB.. */ +#define V4L2_PIX_FMT_SBGGR10 v4l2_fourcc('B', 'G', '1', '0') /* 10 BGBG.. GRGR.. */ +#define V4L2_PIX_FMT_SGBRG10 v4l2_fourcc('G', 'B', '1', '0') /* 10 GBGB.. RGRG.. */ +#define V4L2_PIX_FMT_SGRBG10 v4l2_fourcc('B', 'A', '1', '0') /* 10 GRGR.. BGBG.. */ +#define V4L2_PIX_FMT_SRGGB10 v4l2_fourcc('R', 'G', '1', '0') /* 10 RGRG.. GBGB.. */ +#define V4L2_PIX_FMT_SBGGR12 v4l2_fourcc('B', 'G', '1', '2') /* 12 BGBG.. GRGR.. */ +#define V4L2_PIX_FMT_SGBRG12 v4l2_fourcc('G', 'B', '1', '2') /* 12 GBGB.. RGRG.. */ +#define V4L2_PIX_FMT_SGRBG12 v4l2_fourcc('B', 'A', '1', '2') /* 12 GRGR.. BGBG.. */ +#define V4L2_PIX_FMT_SRGGB12 v4l2_fourcc('R', 'G', '1', '2') /* 12 RGRG.. GBGB.. */ + /* 10bit raw bayer a-law compressed to 8 bits */ +#define V4L2_PIX_FMT_SBGGR10ALAW8 v4l2_fourcc('a', 'B', 'A', '8') +#define V4L2_PIX_FMT_SGBRG10ALAW8 v4l2_fourcc('a', 'G', 'A', '8') +#define V4L2_PIX_FMT_SGRBG10ALAW8 v4l2_fourcc('a', 'g', 'A', '8') +#define V4L2_PIX_FMT_SRGGB10ALAW8 v4l2_fourcc('a', 'R', 'A', '8') + /* 10bit raw bayer DPCM compressed to 8 bits */ +#define V4L2_PIX_FMT_SBGGR10DPCM8 v4l2_fourcc('b', 'B', 'A', '8') +#define V4L2_PIX_FMT_SGBRG10DPCM8 v4l2_fourcc('b', 'G', 'A', '8') +#define V4L2_PIX_FMT_SGRBG10DPCM8 v4l2_fourcc('B', 'D', '1', '0') +#define V4L2_PIX_FMT_SRGGB10DPCM8 v4l2_fourcc('b', 'R', 'A', '8') + /* + * 10bit raw bayer, expanded to 16 bits + * xxxxrrrrrrrrrrxxxxgggggggggg xxxxggggggggggxxxxbbbbbbbbbb... + */ +#define V4L2_PIX_FMT_SBGGR16 v4l2_fourcc('B', 'Y', 'R', '2') /* 16 BGBG.. GRGR.. */ + +/* compressed formats */ +#define V4L2_PIX_FMT_MJPEG v4l2_fourcc('M', 'J', 'P', 'G') /* Motion-JPEG */ +#define V4L2_PIX_FMT_JPEG v4l2_fourcc('J', 'P', 'E', 'G') /* JFIF JPEG */ +#define V4L2_PIX_FMT_DV v4l2_fourcc('d', 'v', 's', 'd') /* 1394 */ +#define V4L2_PIX_FMT_MPEG v4l2_fourcc('M', 'P', 'E', 'G') /* MPEG-1/2/4 Multiplexed */ +#define V4L2_PIX_FMT_H264 v4l2_fourcc('H', '2', '6', '4') /* H264 with start codes */ +#define V4L2_PIX_FMT_H264_NO_SC v4l2_fourcc('A', 'V', 'C', '1') /* H264 without start codes */ +#define V4L2_PIX_FMT_H264_MVC v4l2_fourcc('M', '2', '6', '4') /* H264 MVC */ +#define V4L2_PIX_FMT_H263 v4l2_fourcc('H', '2', '6', '3') /* H263 */ +#define V4L2_PIX_FMT_MPEG1 v4l2_fourcc('M', 'P', 'G', '1') /* MPEG-1 ES */ +#define V4L2_PIX_FMT_MPEG2 v4l2_fourcc('M', 'P', 'G', '2') /* MPEG-2 ES */ +#define V4L2_PIX_FMT_MPEG4 v4l2_fourcc('M', 'P', 'G', '4') /* MPEG-4 part 2 ES */ +#define V4L2_PIX_FMT_XVID v4l2_fourcc('X', 'V', 'I', 'D') /* Xvid */ +#define V4L2_PIX_FMT_VC1_ANNEX_G v4l2_fourcc('V', 'C', '1', 'G') /* SMPTE 421M Annex G compliant stream */ +#define V4L2_PIX_FMT_VC1_ANNEX_L v4l2_fourcc('V', 'C', '1', 'L') /* SMPTE 421M Annex L compliant stream */ +#define V4L2_PIX_FMT_VP8 v4l2_fourcc('V', 'P', '8', '0') /* VP8 */ + +/* Vendor-specific formats */ +#define V4L2_PIX_FMT_CPIA1 v4l2_fourcc('C', 'P', 'I', 'A') /* cpia1 YUV */ +#define V4L2_PIX_FMT_WNVA v4l2_fourcc('W', 'N', 'V', 'A') /* Winnov hw compress */ +#define V4L2_PIX_FMT_SN9C10X v4l2_fourcc('S', '9', '1', '0') /* SN9C10x compression */ +#define V4L2_PIX_FMT_SN9C20X_I420 v4l2_fourcc('S', '9', '2', '0') /* SN9C20x YUV 4:2:0 */ +#define V4L2_PIX_FMT_PWC1 v4l2_fourcc('P', 'W', 'C', '1') /* pwc older webcam */ +#define V4L2_PIX_FMT_PWC2 v4l2_fourcc('P', 'W', 'C', '2') /* pwc newer webcam */ +#define V4L2_PIX_FMT_ET61X251 v4l2_fourcc('E', '6', '2', '5') /* ET61X251 compression */ +#define V4L2_PIX_FMT_SPCA501 v4l2_fourcc('S', '5', '0', '1') /* YUYV per line */ +#define V4L2_PIX_FMT_SPCA505 v4l2_fourcc('S', '5', '0', '5') /* YYUV per line */ +#define V4L2_PIX_FMT_SPCA508 v4l2_fourcc('S', '5', '0', '8') /* YUVY per line */ +#define V4L2_PIX_FMT_SPCA561 v4l2_fourcc('S', '5', '6', '1') /* compressed GBRG bayer */ +#define V4L2_PIX_FMT_PAC207 v4l2_fourcc('P', '2', '0', '7') /* compressed BGGR bayer */ +#define V4L2_PIX_FMT_MR97310A v4l2_fourcc('M', '3', '1', '0') /* compressed BGGR bayer */ +#define V4L2_PIX_FMT_JL2005BCD v4l2_fourcc('J', 'L', '2', '0') /* compressed RGGB bayer */ +#define V4L2_PIX_FMT_SN9C2028 v4l2_fourcc('S', 'O', 'N', 'X') /* compressed GBRG bayer */ +#define V4L2_PIX_FMT_SQ905C v4l2_fourcc('9', '0', '5', 'C') /* compressed RGGB bayer */ +#define V4L2_PIX_FMT_PJPG v4l2_fourcc('P', 'J', 'P', 'G') /* Pixart 73xx JPEG */ +#define V4L2_PIX_FMT_OV511 v4l2_fourcc('O', '5', '1', '1') /* ov511 JPEG */ +#define V4L2_PIX_FMT_OV518 v4l2_fourcc('O', '5', '1', '8') /* ov518 JPEG */ +#define V4L2_PIX_FMT_STV0680 v4l2_fourcc('S', '6', '8', '0') /* stv0680 bayer */ +#define V4L2_PIX_FMT_TM6000 v4l2_fourcc('T', 'M', '6', '0') /* tm5600/tm60x0 */ +#define V4L2_PIX_FMT_CIT_YYVYUY v4l2_fourcc('C', 'I', 'T', 'V') /* one line of Y then 1 line of VYUY */ +#define V4L2_PIX_FMT_KONICA420 v4l2_fourcc('K', 'O', 'N', 'I') /* YUV420 planar in blocks of 256 pixels */ +#define V4L2_PIX_FMT_JPGL v4l2_fourcc('J', 'P', 'G', 'L') /* JPEG-Lite */ +#define V4L2_PIX_FMT_SE401 v4l2_fourcc('S', '4', '0', '1') /* se401 janggu compressed rgb */ +#define V4L2_PIX_FMT_S5C_UYVY_JPG v4l2_fourcc('S', '5', 'C', 'I') /* S5C73M3 interleaved UYVY/JPEG */ + +/* + * F O R M A T E N U M E R A T I O N + */ +struct v4l2_fmtdesc { + __u32 index; /* Format number */ + __u32 type; /* enum v4l2_buf_type */ + __u32 flags; + __u8 description[32]; /* Description string */ + __u32 pixelformat; /* Format fourcc */ + __u32 reserved[4]; +}; + +#define V4L2_FMT_FLAG_COMPRESSED 0x0001 +#define V4L2_FMT_FLAG_EMULATED 0x0002 + +#if 1 + /* Experimental Frame Size and frame rate enumeration */ +/* + * F R A M E S I Z E E N U M E R A T I O N + */ +enum v4l2_frmsizetypes { + V4L2_FRMSIZE_TYPE_DISCRETE = 1, + V4L2_FRMSIZE_TYPE_CONTINUOUS = 2, + V4L2_FRMSIZE_TYPE_STEPWISE = 3, +}; + +struct v4l2_frmsize_discrete { + __u32 width; /* Frame width [pixel] */ + __u32 height; /* Frame height [pixel] */ +}; + +struct v4l2_frmsize_stepwise { + __u32 min_width; /* Minimum frame width [pixel] */ + __u32 max_width; /* Maximum frame width [pixel] */ + __u32 step_width; /* Frame width step size [pixel] */ + __u32 min_height; /* Minimum frame height [pixel] */ + __u32 max_height; /* Maximum frame height [pixel] */ + __u32 step_height; /* Frame height step size [pixel] */ +}; + +struct v4l2_frmsizeenum { + __u32 index; /* Frame size number */ + __u32 pixel_format; /* Pixel format */ + __u32 type; /* Frame size type the device supports. */ + + union { /* Frame size */ + struct v4l2_frmsize_discrete discrete; + struct v4l2_frmsize_stepwise stepwise; + }; + + __u32 reserved[2]; /* Reserved space for future use */ +}; + +/* + * F R A M E R A T E E N U M E R A T I O N + */ +enum v4l2_frmivaltypes { + V4L2_FRMIVAL_TYPE_DISCRETE = 1, + V4L2_FRMIVAL_TYPE_CONTINUOUS = 2, + V4L2_FRMIVAL_TYPE_STEPWISE = 3, +}; + +struct v4l2_frmival_stepwise { + struct v4l2_fract min; /* Minimum frame interval [s] */ + struct v4l2_fract max; /* Maximum frame interval [s] */ + struct v4l2_fract step; /* Frame interval step size [s] */ +}; + +struct v4l2_frmivalenum { + __u32 index; /* Frame format index */ + __u32 pixel_format; /* Pixel format */ + __u32 width; /* Frame width */ + __u32 height; /* Frame height */ + __u32 type; /* Frame interval type the device supports. */ + + union { /* Frame interval */ + struct v4l2_fract discrete; + struct v4l2_frmival_stepwise stepwise; + }; + + __u32 reserved[2]; /* Reserved space for future use */ +}; +#endif + +/* + * T I M E C O D E + */ +struct v4l2_timecode { + __u32 type; + __u32 flags; + __u8 frames; + __u8 seconds; + __u8 minutes; + __u8 hours; + __u8 userbits[4]; +}; + +/* Type */ +#define V4L2_TC_TYPE_24FPS 1 +#define V4L2_TC_TYPE_25FPS 2 +#define V4L2_TC_TYPE_30FPS 3 +#define V4L2_TC_TYPE_50FPS 4 +#define V4L2_TC_TYPE_60FPS 5 + +/* Flags */ +#define V4L2_TC_FLAG_DROPFRAME 0x0001 /* "drop-frame" mode */ +#define V4L2_TC_FLAG_COLORFRAME 0x0002 +#define V4L2_TC_USERBITS_field 0x000C +#define V4L2_TC_USERBITS_USERDEFINED 0x0000 +#define V4L2_TC_USERBITS_8BITCHARS 0x0008 +/* The above is based on SMPTE timecodes */ + +/* + * M E M O R Y - M A P P I N G B U F F E R S + */ +struct v4l2_requestbuffers { + __u32 count; + __u32 type; /* enum v4l2_buf_type */ + __u32 memory; /* enum v4l2_memory */ + __u32 reserved[2]; +}; + +/** + * struct v4l2_plane - plane info for multi-planar buffers + * @bytesused: number of bytes occupied by data in the plane (payload) + * @length: size of this plane (NOT the payload) in bytes + * @mem_offset: when memory in the associated struct v4l2_buffer is + * V4L2_MEMORY_MMAP, equals the offset from the start of + * the device memory for this plane (or is a "cookie" that + * should be passed to mmap() called on the video node) + * @userptr: when memory is V4L2_MEMORY_USERPTR, a userspace pointer + * pointing to this plane + * @fd: when memory is V4L2_MEMORY_DMABUF, a userspace file + * descriptor associated with this plane + * @data_offset: offset in the plane to the start of data; usually 0, + * unless there is a header in front of the data + * + * Multi-planar buffers consist of one or more planes, e.g. an YCbCr buffer + * with two planes can have one plane for Y, and another for interleaved CbCr + * components. Each plane can reside in a separate memory buffer, or even in + * a completely separate memory node (e.g. in embedded devices). + */ +struct v4l2_plane { + __u32 bytesused; + __u32 length; + union { + __u32 mem_offset; + unsigned long userptr; + __s32 fd; + } m; + __u32 data_offset; + __u32 reserved[11]; +}; + +/** + * struct v4l2_buffer - video buffer info + * @index: id number of the buffer + * @type: enum v4l2_buf_type; buffer type (type == *_MPLANE for + * multiplanar buffers); + * @bytesused: number of bytes occupied by data in the buffer (payload); + * unused (set to 0) for multiplanar buffers + * @flags: buffer informational flags + * @field: enum v4l2_field; field order of the image in the buffer + * @timestamp: frame timestamp + * @timecode: frame timecode + * @sequence: sequence count of this frame + * @memory: enum v4l2_memory; the method, in which the actual video data is + * passed + * @offset: for non-multiplanar buffers with memory == V4L2_MEMORY_MMAP; + * offset from the start of the device memory for this plane, + * (or a "cookie" that should be passed to mmap() as offset) + * @userptr: for non-multiplanar buffers with memory == V4L2_MEMORY_USERPTR; + * a userspace pointer pointing to this buffer + * @fd: for non-multiplanar buffers with memory == V4L2_MEMORY_DMABUF; + * a userspace file descriptor associated with this buffer + * @planes: for multiplanar buffers; userspace pointer to the array of plane + * info structs for this buffer + * @length: size in bytes of the buffer (NOT its payload) for single-plane + * buffers (when type != *_MPLANE); number of elements in the + * planes array for multi-plane buffers + * @input: input number from which the video data has has been captured + * + * Contains data exchanged by application and driver using one of the Streaming + * I/O methods. + */ +struct v4l2_buffer { + __u32 index; + __u32 type; + __u32 bytesused; + __u32 flags; + __u32 field; + struct timeval timestamp; + struct v4l2_timecode timecode; + __u32 sequence; + + /* memory location */ + __u32 memory; + union { + __u32 offset; + unsigned long userptr; + struct v4l2_plane *planes; + __s32 fd; + } m; + __u32 length; + __u32 reserved2; + __u32 reserved; +}; + +/* Flags for 'flags' field */ +#define V4L2_BUF_FLAG_MAPPED 0x0001 /* Buffer is mapped (flag) */ +#define V4L2_BUF_FLAG_QUEUED 0x0002 /* Buffer is queued for processing */ +#define V4L2_BUF_FLAG_DONE 0x0004 /* Buffer is ready */ +#define V4L2_BUF_FLAG_KEYFRAME 0x0008 /* Image is a keyframe (I-frame) */ +#define V4L2_BUF_FLAG_PFRAME 0x0010 /* Image is a P-frame */ +#define V4L2_BUF_FLAG_BFRAME 0x0020 /* Image is a B-frame */ +/* Buffer is ready, but the data contained within is corrupted. */ +#define V4L2_BUF_FLAG_ERROR 0x0040 +#define V4L2_BUF_FLAG_TIMECODE 0x0100 /* timecode field is valid */ +#define V4L2_BUF_FLAG_PREPARED 0x0400 /* Buffer is prepared for queuing */ +/* Cache handling flags */ +#define V4L2_BUF_FLAG_NO_CACHE_INVALIDATE 0x0800 +#define V4L2_BUF_FLAG_NO_CACHE_CLEAN 0x1000 +/* Timestamp type */ +#define V4L2_BUF_FLAG_TIMESTAMP_MASK 0xe000 +#define V4L2_BUF_FLAG_TIMESTAMP_UNKNOWN 0x0000 +#define V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC 0x2000 +#define V4L2_BUF_FLAG_TIMESTAMP_COPY 0x4000 + +/** + * struct v4l2_exportbuffer - export of video buffer as DMABUF file descriptor + * + * @index: id number of the buffer + * @type: enum v4l2_buf_type; buffer type (type == *_MPLANE for + * multiplanar buffers); + * @plane: index of the plane to be exported, 0 for single plane queues + * @flags: flags for newly created file, currently only O_CLOEXEC is + * supported, refer to manual of open syscall for more details + * @fd: file descriptor associated with DMABUF (set by driver) + * + * Contains data used for exporting a video buffer as DMABUF file descriptor. + * The buffer is identified by a 'cookie' returned by VIDIOC_QUERYBUF + * (identical to the cookie used to mmap() the buffer to userspace). All + * reserved fields must be set to zero. The field reserved0 is expected to + * become a structure 'type' allowing an alternative layout of the structure + * content. Therefore this field should not be used for any other extensions. + */ +struct v4l2_exportbuffer { + __u32 type; /* enum v4l2_buf_type */ + __u32 index; + __u32 plane; + __u32 flags; + __s32 fd; + __u32 reserved[11]; +}; + +/* + * O V E R L A Y P R E V I E W + */ +struct v4l2_framebuffer { + __u32 capability; + __u32 flags; +/* FIXME: in theory we should pass something like PCI device + memory + * region + offset instead of some physical address */ + void *base; + struct v4l2_pix_format fmt; +}; +/* Flags for the 'capability' field. Read only */ +#define V4L2_FBUF_CAP_EXTERNOVERLAY 0x0001 +#define V4L2_FBUF_CAP_CHROMAKEY 0x0002 +#define V4L2_FBUF_CAP_LIST_CLIPPING 0x0004 +#define V4L2_FBUF_CAP_BITMAP_CLIPPING 0x0008 +#define V4L2_FBUF_CAP_LOCAL_ALPHA 0x0010 +#define V4L2_FBUF_CAP_GLOBAL_ALPHA 0x0020 +#define V4L2_FBUF_CAP_LOCAL_INV_ALPHA 0x0040 +#define V4L2_FBUF_CAP_SRC_CHROMAKEY 0x0080 +/* Flags for the 'flags' field. */ +#define V4L2_FBUF_FLAG_PRIMARY 0x0001 +#define V4L2_FBUF_FLAG_OVERLAY 0x0002 +#define V4L2_FBUF_FLAG_CHROMAKEY 0x0004 +#define V4L2_FBUF_FLAG_LOCAL_ALPHA 0x0008 +#define V4L2_FBUF_FLAG_GLOBAL_ALPHA 0x0010 +#define V4L2_FBUF_FLAG_LOCAL_INV_ALPHA 0x0020 +#define V4L2_FBUF_FLAG_SRC_CHROMAKEY 0x0040 + +struct v4l2_clip { + struct v4l2_rect c; + struct v4l2_clip *next; +}; + +struct v4l2_window { + struct v4l2_rect w; + __u32 field; /* enum v4l2_field */ + __u32 chromakey; + struct v4l2_clip *clips; + __u32 clipcount; + void *bitmap; + __u8 global_alpha; +}; + +/* + * C A P T U R E P A R A M E T E R S + */ +struct v4l2_captureparm { + __u32 capability; /* Supported modes */ + __u32 capturemode; /* Current mode */ + struct v4l2_fract timeperframe; /* Time per frame in seconds */ + __u32 extendedmode; /* Driver-specific extensions */ + __u32 readbuffers; /* # of buffers for read */ + __u32 reserved[4]; +}; + +/* Flags for 'capability' and 'capturemode' fields */ +#define V4L2_MODE_HIGHQUALITY 0x0001 /* High quality imaging mode */ +#define V4L2_CAP_TIMEPERFRAME 0x1000 /* timeperframe field is supported */ + +struct v4l2_outputparm { + __u32 capability; /* Supported modes */ + __u32 outputmode; /* Current mode */ + struct v4l2_fract timeperframe; /* Time per frame in seconds */ + __u32 extendedmode; /* Driver-specific extensions */ + __u32 writebuffers; /* # of buffers for write */ + __u32 reserved[4]; +}; + +/* + * C O N T R O L S + */ +struct v4l2_control { + __u32 id; + __s32 value; +}; + +struct v4l2_ext_control { + __u32 id; + __u32 size; + __u32 reserved2[1]; + union { + __s32 value; + __s64 value64; + char *string; + }; +} __attribute__ ((packed)); + +struct v4l2_ext_controls { + __u32 ctrl_class; + __u32 count; + __u32 error_idx; + __u32 reserved[2]; + struct v4l2_ext_control *controls; +}; + +#define V4L2_CTRL_ID_MASK (0x0fffffff) +#define V4L2_CTRL_ID2CLASS(id) ((id) & 0x0fff0000UL) +#define V4L2_CTRL_DRIVER_PRIV(id) (((id) & 0xffff) >= 0x1000) + +enum v4l2_ctrl_type { + V4L2_CTRL_TYPE_INTEGER = 1, + V4L2_CTRL_TYPE_BOOLEAN = 2, + V4L2_CTRL_TYPE_MENU = 3, + V4L2_CTRL_TYPE_BUTTON = 4, + V4L2_CTRL_TYPE_INTEGER64 = 5, + V4L2_CTRL_TYPE_CTRL_CLASS = 6, + V4L2_CTRL_TYPE_STRING = 7, + V4L2_CTRL_TYPE_BITMASK = 8, + V4L2_CTRL_TYPE_INTEGER_MENU = 9, +}; + +/* Used in the VIDIOC_QUERYCTRL ioctl for querying controls */ +struct v4l2_queryctrl { + __u32 id; + __u32 type; /* enum v4l2_ctrl_type */ + __u8 name[32]; /* Whatever */ + __s32 minimum; /* Note signedness */ + __s32 maximum; + __s32 step; + __s32 default_value; + __u32 flags; + __u32 reserved[2]; +}; + +/* Control flags */ +#define V4L2_CTRL_FLAG_DISABLED 0x0001 +#define V4L2_CTRL_FLAG_GRABBED 0x0002 +#define V4L2_CTRL_FLAG_READ_ONLY 0x0004 +#define V4L2_CTRL_FLAG_UPDATE 0x0008 +#define V4L2_CTRL_FLAG_INACTIVE 0x0010 +#define V4L2_CTRL_FLAG_SLIDER 0x0020 +#define V4L2_CTRL_FLAG_WRITE_ONLY 0x0040 +#define V4L2_CTRL_FLAG_VOLATILE 0x0080 + +/* Query flag, to be ORed with the control ID */ +#define V4L2_CTRL_FLAG_NEXT_CTRL 0x80000000 + +/* User-class control IDs defined by V4L2 */ +#define V4L2_CID_MAX_CTRLS 1024 +/* IDs reserved for driver specific controls */ +#define V4L2_CID_PRIVATE_BASE 0x08000000 + +/* + * D A T A S E R V I C E S ( V B I ) + * + * Data services API by Michael Schimek + */ + +/* Raw VBI */ +struct v4l2_vbi_format { + __u32 sampling_rate; /* in 1 Hz */ + __u32 offset; + __u32 samples_per_line; + __u32 sample_format; /* V4L2_PIX_FMT_* */ + __s32 start[2]; + __u32 count[2]; + __u32 flags; /* V4L2_VBI_* */ + __u32 reserved[2]; /* must be zero */ +}; + +/* Sliced VBI + * + * This implements is a proposal V4L2 API to allow SLICED VBI + * required for some hardware encoders. It should change without + * notice in the definitive implementation. + */ + +struct v4l2_sliced_vbi_format { + __u16 service_set; + /* service_lines[0][...] specifies lines 0-23 (1-23 used) of the first field + service_lines[1][...] specifies lines 0-23 (1-23 used) of the second field + (equals frame lines 313-336 for 625 line video + standards, 263-286 for 525 line standards) */ + __u16 service_lines[2][24]; + __u32 io_size; + __u32 reserved[2]; /* must be zero */ +}; + +/* + * A G G R E G A T E S T R U C T U R E S + */ + +/** + * struct v4l2_plane_pix_format - additional, per-plane format definition + * @sizeimage: maximum size in bytes required for data, for which + * this plane will be used + * @bytesperline: distance in bytes between the leftmost pixels in two + * adjacent lines + */ +struct v4l2_plane_pix_format { + __u32 sizeimage; + __u16 bytesperline; + __u16 reserved[7]; +} __attribute__ ((packed)); + +/** + * struct v4l2_pix_format_mplane - multiplanar format definition + * @width: image width in pixels + * @height: image height in pixels + * @pixelformat: little endian four character code (fourcc) + * @field: enum v4l2_field; field order (for interlaced video) + * @colorspace: enum v4l2_colorspace; supplemental to pixelformat + * @plane_fmt: per-plane information + * @num_planes: number of planes for this format + */ +struct v4l2_pix_format_mplane { + __u32 width; + __u32 height; + __u32 pixelformat; + __u32 field; + __u32 colorspace; + + struct v4l2_plane_pix_format plane_fmt[VIDEO_MAX_PLANES]; + __u8 num_planes; + __u8 reserved[11]; +} __attribute__ ((packed)); + +/** + * struct v4l2_format - stream data format + * @type: enum v4l2_buf_type; type of the data stream + * @pix: definition of an image format + * @pix_mp: definition of a multiplanar image format + * @win: definition of an overlaid image + * @vbi: raw VBI capture or output parameters + * @sliced: sliced VBI capture or output parameters + * @raw_data: placeholder for future extensions and custom formats + */ +struct v4l2_format { + __u32 type; + union { + struct v4l2_pix_format pix; /* V4L2_BUF_TYPE_VIDEO_CAPTURE */ + struct v4l2_pix_format_mplane pix_mp; /* V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE */ + struct v4l2_window win; /* V4L2_BUF_TYPE_VIDEO_OVERLAY */ + struct v4l2_vbi_format vbi; /* V4L2_BUF_TYPE_VBI_CAPTURE */ + struct v4l2_sliced_vbi_format sliced; /* V4L2_BUF_TYPE_SLICED_VBI_CAPTURE */ + __u8 raw_data[200]; /* user-defined */ + } fmt; +}; + +#endif /* __VIDEODEV2_MIN_H */ -- 2.34.1