extern "C" struct GXDisplayProperties GXGETDISPLAYPROPERTIES()
{
#ifndef _USE_GAPI_
RECT r;
GXDisplayProperties gxdp;
gxdp.cbyPitch = gx->GetFBModulo();
gxdp.cBPP = gx->GetFBBpp();
gxdp.cbxPitch = (gxdp.cBPP >> 3);
gx->GetScreenRect(&r);
gxdp.cxWidth = (r.right - r.left);
gxdp.cyHeight = (r.bottom - r.top);
if(gxdp.cBPP = 16)
gxdp.ffFormat = kfDirect565;
else if(gxdp.cBPP = 8)
gxdp.ffFormat = kfPalette;
return gxdp;
#else
return GXGetDisplayProperties();
#endif
}
static int Lock(picture_t *picture)
{
vout_display_t *vd = picture->p_sys->vd;
vout_display_sys_t *sys = vd->sys;
/* */
if (sys->rect_dest_clipped.right - sys->rect_dest_clipped.left != vd->fmt.i_width ||
sys->rect_dest_clipped.bottom - sys->rect_dest_clipped.top != vd->fmt.i_height)
return VLC_EGENERIC;
/* */
GXDisplayProperties gxdisplayprop = GXGetDisplayProperties();
uint8_t *p_pic_buffer = GXBeginDraw();
if (!p_pic_buffer) {
msg_Err(vd, "GXBeginDraw error %d ", GetLastError());
return VLC_EGENERIC;
}
p_pic_buffer += sys->rect_dest.top * gxdisplayprop.cbyPitch +
sys->rect_dest.left * gxdisplayprop.cbxPitch;
/* */
picture->p[0].i_pitch = gxdisplayprop.cbyPitch;
picture->p[0].p_pixels = p_pic_buffer;
return VLC_SUCCESS;
}
GF_Err GAPI_Setup(GF_VideoOutput *dr, void *os_handle, void *os_display, Bool noover)
{
struct GXDisplayProperties gx = GXGetDisplayProperties();
RECT rc;
GAPICTX(dr);
gctx->hWnd = (HWND) os_handle;
/*get keys in both 2D and 3D modes*/
gctx->keys = GXGetDefaultKeys(GX_NORMALKEYS);
#if 0
/*FIXME - not supported in rasterizer*/
if (gx.ffFormat & kfDirect444) {
gctx->pixel_format = GF_PIXEL_RGB_444;
gctx->BPP = 2;
gctx->bitsPP = 12;
}
else
#endif
if (gx.ffFormat & kfDirect555) {
gctx->pixel_format = GF_PIXEL_RGB_555;
gctx->BPP = 2;
gctx->bits_per_pixel = 15;
}
else if (gx.ffFormat & kfDirect565) {
gctx->pixel_format = GF_PIXEL_RGB_565;
gctx->BPP = 2;
gctx->bits_per_pixel = 16;
}
else if (gx.ffFormat & kfDirect888) {
gctx->pixel_format = GF_PIXEL_RGB_24;
gctx->BPP = 3;
gctx->bits_per_pixel = 24;
} else {
return GF_NOT_SUPPORTED;
}
GAPI_SetupWindow(dr);
if (!gctx->hWnd) return GF_IO_ERR;
/*setup GX*/
if (!GXOpenDisplay(gctx->hWnd, 0L)) {
MessageBox(NULL, _T("Cannot open display"), _T("GAPI Error"), MB_OK);
return GF_IO_ERR;
}
GetClientRect(gctx->hWnd, &rc);
gctx->backup_w = rc.right - rc.left;
gctx->backup_h = rc.bottom - rc.top;
return GAPI_InitBackBuffer(dr, gctx->backup_w, gctx->backup_h);
}
DWORD WINAPI CreateWinCEWindow(LPVOID lpParam) {
static MidpReentryData newSignal;
static MidpEvent newMidpEvent;
int screenSize = sizeof(gxj_pixel_type) * CHAM_WIDTH * CHAM_HEIGHT;
/* IMPL_NOTE: Need a better way to load the library */
#ifdef CVM_PRELOAD_LIB
instanceMain = LoadLibrary(TEXT("cvmi.dll"));
#else
#ifdef CVM_DEBUG
instanceMain = LoadLibrary(TEXT("libmidp_g.dll"));
#else
instanceMain = LoadLibrary(TEXT("libmidp.dll"));
#endif
#endif
gxj_system_screen_buffer.width = CHAM_WIDTH;
gxj_system_screen_buffer.height = CHAM_HEIGHT;
gxj_system_screen_buffer.alphaData = 0;
gxj_system_screen_buffer.pixelData = (gxj_pixel_type *)midpMalloc(screenSize);
memset(gxj_system_screen_buffer.pixelData, 0xff, screenSize);
if (!init_windows(GetModuleHandle(NULL), SW_SHOW)) {
REPORT_ERROR(LC_AMS, "init_gui() failed");
MessageBox(NULL, TEXT("Failed to start JWC"), TEXT("Bye"), MB_OK);
}
updateVisibleDesktop();
#if JWC_WINCE_USE_DIRECT_DRAW
init_DirectDraw();
#else
if (GXOpenDisplay(hwndMain, 0) == 0) {
REPORT_ERROR(LC_HIGHUI, "GXOpenDisplay() failed");
}
gxDispProps = GXGetDisplayProperties();
#endif
createEditors();
#ifdef ENABLE_JSR_184
engine_initialize();
#endif
MIDP_EVENT_INITIALIZE(newMidpEvent);
while (1) {
checkForSystemSignal(&newSignal, &newMidpEvent, 200);
}
}
static int Init(vout_display_t *vd,
video_format_t *fmt, int width, int height)
{
vout_display_sys_t *sys = vd->sys;
/* */
RECT *display = &sys->rect_display;
display->left = 0;
display->top = 0;
#ifdef MODULE_NAME_IS_wingapi
display->right = GXGetDisplayProperties().cxWidth;
display->bottom = GXGetDisplayProperties().cyHeight;
#else
display->right = GetSystemMetrics(SM_CXSCREEN);;
display->bottom = GetSystemMetrics(SM_CYSCREEN);;
#endif
/* Initialize an offscreen bitmap for direct buffer operations. */
/* */
HDC window_dc = GetDC(sys->hvideownd);
/* */
#ifdef MODULE_NAME_IS_wingapi
GXDisplayProperties gx_displayprop = GXGetDisplayProperties();
sys->i_depth = gx_displayprop.cBPP;
#else
sys->i_depth = GetDeviceCaps(window_dc, PLANES) *
GetDeviceCaps(window_dc, BITSPIXEL);
#endif
/* */
msg_Dbg(vd, "GDI depth is %i", sys->i_depth);
switch (sys->i_depth) {
case 8:
fmt->i_chroma = VLC_CODEC_RGB8;
break;
case 15:
fmt->i_chroma = VLC_CODEC_RGB15;
fmt->i_rmask = 0x7c00;
fmt->i_gmask = 0x03e0;
fmt->i_bmask = 0x001f;
break;
case 16:
fmt->i_chroma = VLC_CODEC_RGB16;
fmt->i_rmask = 0xf800;
fmt->i_gmask = 0x07e0;
fmt->i_bmask = 0x001f;
break;
case 24:
fmt->i_chroma = VLC_CODEC_RGB24;
fmt->i_rmask = 0x00ff0000;
fmt->i_gmask = 0x0000ff00;
fmt->i_bmask = 0x000000ff;
break;
case 32:
fmt->i_chroma = VLC_CODEC_RGB32;
fmt->i_rmask = 0x00ff0000;
fmt->i_gmask = 0x0000ff00;
fmt->i_bmask = 0x000000ff;
break;
default:
msg_Err(vd, "screen depth %i not supported", sys->i_depth);
return VLC_EGENERIC;
}
fmt->i_width = width;
fmt->i_height = height;
uint8_t *p_pic_buffer;
int i_pic_pitch;
#ifdef MODULE_NAME_IS_wingapi
GXOpenDisplay(sys->hvideownd, GX_FULLSCREEN);
EventThreadUpdateTitle(sys->event, VOUT_TITLE " (WinGAPI output)");
/* Filled by pool::lock() */
p_pic_buffer = NULL;
i_pic_pitch = 0;
#else
/* Initialize offscreen bitmap */
BITMAPINFO *bi = &sys->bitmapinfo;
memset(bi, 0, sizeof(BITMAPINFO) + 3 * sizeof(RGBQUAD));
if (sys->i_depth > 8) {
((DWORD*)bi->bmiColors)[0] = fmt->i_rmask;
((DWORD*)bi->bmiColors)[1] = fmt->i_gmask;
((DWORD*)bi->bmiColors)[2] = fmt->i_bmask;;
}
BITMAPINFOHEADER *bih = &sys->bitmapinfo.bmiHeader;
bih->biSize = sizeof(BITMAPINFOHEADER);
bih->biSizeImage = 0;
bih->biPlanes = 1;
bih->biCompression = (sys->i_depth == 15 ||
sys->i_depth == 16) ? BI_BITFIELDS : BI_RGB;
bih->biBitCount = sys->i_depth;
bih->biWidth = fmt->i_width;
bih->biHeight = -fmt->i_height;
bih->biClrImportant = 0;
bih->biClrUsed = 0;
bih->biXPelsPerMeter = 0;
bih->biYPelsPerMeter = 0;
i_pic_pitch = bih->biBitCount * bih->biWidth / 8;
sys->off_bitmap = CreateDIBSection(window_dc,
(BITMAPINFO *)bih,
DIB_RGB_COLORS,
&p_pic_buffer, NULL, 0);
sys->off_dc = CreateCompatibleDC(window_dc);
SelectObject(sys->off_dc, sys->off_bitmap);
ReleaseDC(sys->hvideownd, window_dc);
EventThreadUpdateTitle(sys->event, VOUT_TITLE " (WinGDI output)");
#endif
/* */
picture_resource_t rsc;
memset(&rsc, 0, sizeof(rsc));
#ifdef MODULE_NAME_IS_wingapi
rsc.p_sys = malloc(sizeof(*rsc.p_sys));
if (!rsc.p_sys)
return VLC_EGENERIC;
rsc.p_sys->vd = vd;
#endif
rsc.p[0].p_pixels = p_pic_buffer;
rsc.p[0].i_lines = fmt->i_height;
rsc.p[0].i_pitch = i_pic_pitch;;
picture_t *picture = picture_NewFromResource(fmt, &rsc);
if (picture) {
picture_pool_configuration_t cfg;
memset(&cfg, 0, sizeof(cfg));
cfg.picture_count = 1;
cfg.picture = &picture;
#ifdef MODULE_NAME_IS_wingapi
cfg.lock = Lock;
cfg.unlock = Unlock;
#endif
sys->pool = picture_pool_NewExtended(&cfg);
} else {
free(rsc.p_sys);
sys->pool = NULL;
}
UpdateRects(vd, NULL, NULL, true);
return VLC_SUCCESS;
}
static GF_Err GAPI_InitBackBuffer(GF_VideoOutput *dr, u32 VideoWidth, u32 VideoHeight)
{
u32 gx_mode;
GAPICTX(dr);
if (!gctx || !VideoWidth || !VideoHeight) return GF_BAD_PARAM;
gf_mx_p(gctx->mx);
GAPI_ReleaseObjects(gctx);
/*flip W&H in landscape mode*/
if (landscape) {
u32 t = VideoWidth;
VideoWidth = VideoHeight;
VideoHeight = t;
}
RECT rc;
GetWindowRect(gctx->hWnd, &rc);
gctx->off_x = rc.left;
gctx->off_y = rc.top;
gctx->erase_dest = 1;
const char *opt = gf_modules_get_option((GF_BaseInterface *)dr, "GAPI", "FBAccess");
if (!opt || !strcmp(opt, "raw")) gx_mode = 2;
else if (opt && !strcmp(opt, "gx")) gx_mode = 1;
else gx_mode = 0;
if ((gx_mode != gctx->gx_mode) || !gctx->screen_w) {
struct GXDisplayProperties gx = GXGetDisplayProperties();
gctx->x_pitch = gx.cbxPitch;
gctx->y_pitch = gx.cbyPitch;
gctx->gx_mode = gx_mode;
if (gctx->gx_mode==2) {
if (gapi_get_raw_fb(dr) == GF_EOS) {
gf_mx_v(gctx->mx);
return GF_OK;
}
} else if (check_resolution_switch(dr, gx.cxWidth, gx.cyHeight)) {
gf_mx_v(gctx->mx);
return GF_OK;
}
}
if (gctx->gx_mode==2) {
GF_Err e = gapi_get_raw_fb(dr);
if (e) {
gf_mx_v(gctx->mx);
if (e==GF_EOS) return GF_OK;
else return e;
}
}
gctx->bb_size = VideoWidth * VideoHeight * gctx->BPP;
gctx->bb_width = VideoWidth;
gctx->bb_height = VideoHeight;
gctx->bb_pitch = VideoWidth * gctx->BPP;
if (gctx->gx_mode) {
gctx->backbuffer = (char *) gf_malloc(sizeof(unsigned char) * gctx->bb_size);
gctx->contiguous_mem = ((gctx->x_pitch==gctx->BPP) && (gctx->y_pitch==gctx->screen_w*gctx->BPP)) ? 1 : 0;
} else {
createPixmap(gctx, 0);
}
gf_mx_v(gctx->mx);
return GF_OK;
}
