void lua_engine::serve_lua()
{
osd_sleep(osd_ticks_per_second() / 1000 * 50);
printf("%s v%s - %s\n%s\n%s\n\n", emulator_info::get_applongname(),build_version,emulator_info::get_fulllongname(),emulator_info::get_copyright_info(),LUA_COPYRIGHT);
fflush(stdout);
char buff[LUA_MAXINPUT];
astring oldbuff;
const char *b = LUA_PROMPT;
do {
// Wait for input
fputs(b, stdout); fflush(stdout); /* show prompt */
fgets(buff, LUA_MAXINPUT, stdin);
// Create message
osd_lock_acquire(lock);
if (msg.ready == 0) {
msg.text = oldbuff;
if (oldbuff.len()!=0) msg.text.cat("\n");
msg.text.cat(buff);
msg.ready = 1;
msg.done = 0;
}
osd_lock_release(lock);
// Wait for response
int done = 0;
do {
osd_sleep(osd_ticks_per_second() / 1000);
osd_lock_acquire(lock);
done = msg.done;
osd_lock_release(lock);
} while (done==0);
// Do action on client side
osd_lock_acquire(lock);
if (msg.status == -1){
b = LUA_PROMPT2;
oldbuff = msg.response;
}
else {
b = LUA_PROMPT;
oldbuff = "";
}
msg.done = 0;
osd_lock_release(lock);
} while (1);
}
static void draw_video_contents(win_window_info *window, HDC dc, int update)
{
assert(GetCurrentThreadId() == window_threadid);
mtlog_add("draw_video_contents: begin");
mtlog_add("draw_video_contents: render lock acquire");
osd_lock_acquire(window->render_lock);
mtlog_add("draw_video_contents: render lock acquired");
// if we're iconic, don't bother
if (window->hwnd != NULL && !IsIconic(window->hwnd))
{
// if no bitmap, just fill
if (window->primlist == NULL)
{
RECT fill;
GetClientRect(window->hwnd, &fill);
FillRect(dc, &fill, (HBRUSH)GetStockObject(BLACK_BRUSH));
}
// otherwise, render with our drawing system
else
{
(*draw.window_draw)(window, dc, update);
mtlog_add("draw_video_contents: drawing finished");
}
}
osd_lock_release(window->render_lock);
mtlog_add("draw_video_contents: render lock released");
mtlog_add("draw_video_contents: end");
}
void osd_update(running_machine *machine, int skip_redraw){
nitroinput_update();
const render_primitive_list *primlist;
int minwidth, minheight;
// get the minimum width/height for the current layout
render_target_get_minimum_size(our_target, &minwidth, &minheight);
if(our_target){
// make that the size of our target
render_target_set_bounds(our_target, minwidth, minheight, 0);
// get the list of primitives for the target at the current size
primlist = render_target_get_primitives(our_target);
// lock them, and then render them
osd_lock_acquire(primlist->lock);
// do the drawing here
osd_lock_release(primlist->lock);
}
// after 5 seconds, exit
if (attotime_compare(timer_get_time(machine), attotime_make(5, 0)) > 0)
mame_schedule_exit(machine);
}
void lua_engine::periodic_check()
{
osd_lock_acquire(lock);
if (msg.ready == 1) {
lua_settop(m_lua_state, 0);
int status = luaL_loadbuffer(m_lua_state, msg.text.cstr(), strlen(msg.text.cstr()), "=stdin");
if (incomplete(status)==0) /* cannot try to add lines? */
{
if (status == LUA_OK) status = docall(0, LUA_MULTRET);
report(status);
if (status == LUA_OK && lua_gettop(m_lua_state) > 0) /* any result to print? */
{
luaL_checkstack(m_lua_state, LUA_MINSTACK, "too many results to print");
lua_getglobal(m_lua_state, "print");
lua_insert(m_lua_state, 1);
if (lua_pcall(m_lua_state, lua_gettop(m_lua_state) - 1, 0, 0) != LUA_OK)
luai_writestringerror("%s\n", lua_pushfstring(m_lua_state,
"error calling " LUA_QL("print") " (%s)",
lua_tostring(m_lua_state, -1)));
}
}
else
{
status = -1;
}
msg.status = status;
msg.response = msg.text;
msg.text = "";
msg.ready = 0;
msg.done = 1;
}
osd_lock_release(lock);
}
INT32 osd_scalable_lock_acquire(osd_scalable_lock *lock)
{
#if defined(WIN32)
EnterCriticalSection(&lock->critsect);
#else
osd_lock_acquire(lock->lock);
#endif
return 0;
}
void resource_pool::add(resource_pool_item &item)
{
osd_lock_acquire(m_listlock);
// insert into hash table
int hashval = reinterpret_cast<FPTR>(item.m_ptr) % m_hash_size;
item.m_next = m_hash[hashval];
m_hash[hashval] = &item;
// fetch the ID of this item's pointer; some implementations put hidden data
// before, so if we don't find it, check 4 bytes ahead
memory_entry *entry = memory_entry::find(item.m_ptr);
if (entry == NULL)
#ifdef USE_ARM_HACK
entry = memory_entry::find(reinterpret_cast<UINT8 *>(item.m_ptr) - 8);
#else
entry = memory_entry::find(reinterpret_cast<UINT8 *>(item.m_ptr) - sizeof(size_t));
#endif
assert(entry != NULL);
item.m_id = entry->m_id;
if (LOG_ALLOCS)
fprintf(stderr, "#%06d, add %d bytes (%s:%d)\n", (UINT32)entry->m_id, static_cast<UINT32>(entry->m_size), entry->m_file, (int)entry->m_line);
// find the entry to insert after
resource_pool_item *insert_after;
for (insert_after = m_ordered_tail; insert_after != NULL; insert_after = insert_after->m_ordered_prev)
if (insert_after->m_id < item.m_id)
break;
// insert into the appropriate spot
if (insert_after != NULL)
{
item.m_ordered_next = insert_after->m_ordered_next;
if (item.m_ordered_next != NULL)
item.m_ordered_next->m_ordered_prev = &item;
else
m_ordered_tail = &item;
item.m_ordered_prev = insert_after;
insert_after->m_ordered_next = &item;
}
else
{
item.m_ordered_next = m_ordered_head;
if (item.m_ordered_next != NULL)
item.m_ordered_next->m_ordered_prev = &item;
else
m_ordered_tail = &item;
item.m_ordered_prev = NULL;
m_ordered_head = &item;
}
osd_lock_release(m_listlock);
}
void resource_pool::clear()
{
osd_lock_acquire(m_listlock);
// important: delete from earliest to latest; this allows objects to clean up after
// themselves if they wish
while (m_ordered_head != NULL)
remove(m_ordered_head->m_ptr);
osd_lock_release(m_listlock);
}
void memory_entry::acquire_lock()
{
// allocate a lock on first usage
// note that osd_lock_alloc() may re-enter this path, so protect against recursion!
if (s_lock == NULL)
{
if (s_lock_alloc)
return;
s_lock_alloc = true;
s_lock = osd_lock_alloc();
s_lock_alloc = false;
}
osd_lock_acquire(s_lock);
}
void droid_video_thread()
{
UINT8 *surfptr;
INT32 pitch;
int bpp;
bpp = 2;
vofs = hofs = 0;
while (!thread_stopping)
{
pthread_mutex_lock( &cond_mutex );
while(currlist == NULL)
{
pthread_cond_wait( &condition_var, &cond_mutex );
}
if(curr_screen_width!= screen_width || curr_screen_height != screen_height)
{
screen_width = curr_screen_width;
screen_height = curr_screen_height;
myosd_set_video_mode(screen_width,screen_height);
}
pthread_mutex_unlock( &cond_mutex );
osd_lock_acquire(currlist->lock);
surfptr = (UINT8 *) myosd_screen15;
pitch = screen_width * 2;
surfptr += ((vofs * pitch) + (hofs * bpp));
drawsdl_rgb565_draw_primitives(currlist->head, surfptr, screen_width, screen_height, pitch / 2);
osd_lock_release(currlist->lock);
myosd_video_flip();
pthread_mutex_lock( &cond_mutex );
currlist = NULL;
pthread_mutex_unlock( &cond_mutex );
}
}
resource_pool_item *resource_pool::find(void *ptr)
{
// search for the item
osd_lock_acquire(m_listlock);
int hashval = reinterpret_cast<FPTR>(ptr) % m_hash_size;
resource_pool_item *item;
for (item = m_hash[hashval]; item != NULL; item = item->m_next)
if (item->m_ptr == ptr)
break;
osd_lock_release(m_listlock);
return item;
}
void resource_pool::add(resource_pool_item &item)
{
osd_lock_acquire(m_listlock);
// insert into hash table
int hashval = reinterpret_cast<FPTR>(item.m_ptr) % k_hash_prime;
item.m_next = m_hash[hashval];
m_hash[hashval] = &item;
// fetch the ID of this item's pointer; some implementations put hidden data
// before, so if we don't find it, check 4 bytes ahead
memory_entry *entry = memory_entry::find(item.m_ptr);
if (entry == NULL)
entry = memory_entry::find(reinterpret_cast<UINT8 *>(item.m_ptr) - sizeof(size_t));
assert(entry != NULL);
item.m_id = entry->m_id;
// find the entry to insert after
resource_pool_item *insert_after;
for (insert_after = m_ordered_tail; insert_after != NULL; insert_after = insert_after->m_ordered_prev)
if (insert_after->m_id < item.m_id)
break;
// insert into the appropriate spot
if (insert_after != NULL)
{
item.m_ordered_next = insert_after->m_ordered_next;
if (item.m_ordered_next != NULL)
item.m_ordered_next->m_ordered_prev = &item;
else
m_ordered_tail = &item;
item.m_ordered_prev = insert_after;
insert_after->m_ordered_next = &item;
}
else
{
item.m_ordered_next = m_ordered_head;
if (item.m_ordered_next != NULL)
item.m_ordered_next->m_ordered_prev = &item;
else
m_ordered_tail = &item;
item.m_ordered_prev = NULL;
m_ordered_head = &item;
}
osd_lock_release(m_listlock);
}
void resource_pool::add(resource_pool_item &item, size_t size, const char *type)
{
osd_lock_acquire(m_listlock);
// insert into hash table
int hashval = reinterpret_cast<FPTR>(item.m_ptr) % m_hash_size;
item.m_next = m_hash[hashval];
m_hash[hashval] = &item;
// fetch the ID of this item's pointer; some implementations put hidden data
// before, so if we don't find it, check 4 bytes ahead
item.m_id = ++s_id;
if (LOG_ALLOCS)
fprintf(stderr, "#%06d, add %s, %d bytes\n", (UINT32)item.m_id, type, UINT32(size));
// find the entry to insert after
resource_pool_item *insert_after;
for (insert_after = m_ordered_tail; insert_after != NULL; insert_after = insert_after->m_ordered_prev)
if (insert_after->m_id < item.m_id)
break;
// insert into the appropriate spot
if (insert_after != NULL)
{
item.m_ordered_next = insert_after->m_ordered_next;
if (item.m_ordered_next != NULL)
item.m_ordered_next->m_ordered_prev = &item;
else
m_ordered_tail = &item;
item.m_ordered_prev = insert_after;
insert_after->m_ordered_next = &item;
}
else
{
item.m_ordered_next = m_ordered_head;
if (item.m_ordered_next != NULL)
item.m_ordered_next->m_ordered_prev = &item;
else
m_ordered_tail = &item;
item.m_ordered_prev = NULL;
m_ordered_head = &item;
}
osd_lock_release(m_listlock);
}
static int drawgdi_window_draw(win_window_info *window, HDC dc, int update)
{
gdi_info *gdi = (gdi_info *)window->drawdata;
int width, height, pitch;
RECT bounds;
// we don't have any special resize behaviors
if (window->resize_state == RESIZE_STATE_PENDING)
window->resize_state = RESIZE_STATE_NORMAL;
// get the target bounds
GetClientRect(window->hwnd, &bounds);
// compute width/height/pitch of target
width = rect_width(&bounds);
height = rect_height(&bounds);
pitch = (width + 3) & ~3;
// make sure our temporary bitmap is big enough
if (pitch * height * 4 > gdi->bmsize)
{
gdi->bmsize = pitch * height * 4 * 2;
global_free(gdi->bmdata);
gdi->bmdata = global_alloc_array(UINT8, gdi->bmsize);
}
// draw the primitives to the bitmap
osd_lock_acquire(window->primlist->lock);
drawgdi_rgb888_draw_primitives(window->primlist->head, gdi->bmdata, width, height, pitch);
osd_lock_release(window->primlist->lock);
// fill in bitmap-specific info
gdi->bminfo.bmiHeader.biWidth = pitch;
gdi->bminfo.bmiHeader.biHeight = -height;
gdi->bminfo.bmiHeader.biBitCount = 32;
// blit to the screen
StretchDIBits(dc, 0, 0, width, height,
0, 0, width, height,
gdi->bmdata, &gdi->bminfo, DIB_RGB_COLORS, SRCCOPY);
return 0;
}
bool resource_pool::contains(void *_ptrstart, void *_ptrend)
{
UINT8 *ptrstart = reinterpret_cast<UINT8 *>(_ptrstart);
UINT8 *ptrend = reinterpret_cast<UINT8 *>(_ptrend);
// search for the item
osd_lock_acquire(m_listlock);
resource_pool_item *item = NULL;
for (item = m_ordered_head; item != NULL; item = item->m_ordered_next)
{
UINT8 *objstart = reinterpret_cast<UINT8 *>(item->m_ptr);
UINT8 *objend = objstart + item->m_size;
if (ptrstart >= objstart && ptrend <= objend)
goto found;
}
found:
osd_lock_release(m_listlock);
return (item != NULL);
}
void resource_pool::remove(void *ptr)
{
// ignore NULLs
if (ptr == NULL)
return;
// search for the item
osd_lock_acquire(m_listlock);
int hashval = reinterpret_cast<FPTR>(ptr) % m_hash_size;
for (resource_pool_item **scanptr = &m_hash[hashval]; *scanptr != NULL; scanptr = &(*scanptr)->m_next)
// must match the pointer
if ((*scanptr)->m_ptr == ptr)
{
// remove from hash table
resource_pool_item *deleteme = *scanptr;
*scanptr = deleteme->m_next;
// remove from ordered list
if (deleteme->m_ordered_prev != NULL)
deleteme->m_ordered_prev->m_ordered_next = deleteme->m_ordered_next;
else
m_ordered_head = deleteme->m_ordered_next;
if (deleteme->m_ordered_next != NULL)
deleteme->m_ordered_next->m_ordered_prev = deleteme->m_ordered_prev;
else
m_ordered_tail = deleteme->m_ordered_prev;
// delete the object and break
if (LOG_ALLOCS)
fprintf(stderr, "#%06d, delete %d bytes\n", (UINT32)deleteme->m_id, static_cast<UINT32>(deleteme->m_size));
delete deleteme;
break;
}
osd_lock_release(m_listlock);
}
static void save_frame_with(mame_file *fp, int scrnum, png_error (*write_handler)(mame_file *, mame_bitmap *))
{
const render_primitive_list *primlist;
INT32 width, height;
int error;
assert(scrnum >= 0 && scrnum < MAX_SCREENS);
/* if no screens, do nothing */
if (snap_target == NULL)
return;
/* select the appropriate view in our dummy target */
render_target_set_view(snap_target, scrnum);
/* get the minimum width/height and set it on the target */
render_target_get_minimum_size(snap_target, &width, &height);
render_target_set_bounds(snap_target, width, height, 0);
/* if we don't have a bitmap, or if it's not the right size, allocate a new one */
if (snap_bitmap == NULL || width != snap_bitmap->width || height != snap_bitmap->height)
{
if (snap_bitmap != NULL)
bitmap_free(snap_bitmap);
snap_bitmap = bitmap_alloc_format(width, height, BITMAP_FORMAT_RGB32);
assert(snap_bitmap != NULL);
}
/* render the screen there */
primlist = render_target_get_primitives(snap_target);
osd_lock_acquire(primlist->lock);
rgb888_draw_primitives(primlist->head, snap_bitmap->base, width, height, snap_bitmap->rowpixels);
osd_lock_release(primlist->lock);
/* now do the actual work */
error = (*write_handler)(fp, snap_bitmap);
}
void resource_pool::remove(void *ptr)
{
// ignore NULLs
if (ptr == NULL)
return;
// search for the item
osd_lock_acquire(m_listlock);
int hashval = reinterpret_cast<FPTR>(ptr) % m_hash_size;
for (resource_pool_item **scanptr = &m_hash[hashval]; *scanptr != NULL; scanptr = &(*scanptr)->m_next)
// must match the pointer
if ((*scanptr)->m_ptr == ptr)
{
// remove from hash table
resource_pool_item *deleteme = *scanptr;
*scanptr = deleteme->m_next;
// remove from ordered list
if (deleteme->m_ordered_prev != NULL)
deleteme->m_ordered_prev->m_ordered_next = deleteme->m_ordered_next;
else
m_ordered_head = deleteme->m_ordered_next;
if (deleteme->m_ordered_next != NULL)
deleteme->m_ordered_next->m_ordered_prev = deleteme->m_ordered_prev;
else
m_ordered_tail = deleteme->m_ordered_prev;
// delete the object and break
global_free(deleteme);
break;
}
osd_lock_release(m_listlock);
}
INT32 osd_scalable_lock_acquire(osd_scalable_lock *lock)
{
osd_lock_acquire(lock->lock);
return 0;
}
static int drawdd_window_draw(win_window_info *window, HDC dc, int update)
{
dd_info *dd = window->drawdata;
const render_primitive *prim;
int usemembuffer = FALSE;
HRESULT result;
// if we haven't been created, just punt
if (dd == NULL)
return 1;
// if we're updating, remember to erase the outer stuff
if (update)
update_outer_rects(dd);
// if we have a ddraw object, check the cooperative level
if (ddraw_test_cooperative(window))
return 1;
// get the size; if we're too small, delete the existing surfaces
if (dd->blitwidth > dd->blitdesc.dwWidth || dd->blitheight > dd->blitdesc.dwHeight)
ddraw_delete_surfaces(window);
// if we need to create surfaces, do it now
if (dd->blit == NULL && ddraw_create_surfaces(window) != 0)
return 1;
// select our surface and lock it
result = IDirectDrawSurface7_Lock(dd->blit, NULL, &dd->blitdesc, DDLOCK_WAIT, NULL);
if (result == DDERR_SURFACELOST)
{
mame_printf_verbose("DirectDraw: Lost surfaces; deleting and retrying next frame\n");
ddraw_delete_surfaces(window);
return 1;
}
if (result != DD_OK)
{
mame_printf_verbose("DirectDraw: Error %08X locking blit surface\n", (int)result);
return 1;
}
// render to it
osd_lock_acquire(window->primlist->lock);
// scan the list of primitives for tricky stuff
for (prim = window->primlist->head; prim != NULL; prim = prim->next)
if (PRIMFLAG_GET_BLENDMODE(prim->flags) != BLENDMODE_NONE ||
(prim->texture.base != NULL && PRIMFLAG_GET_TEXFORMAT(prim->flags) == TEXFORMAT_ARGB32))
{
usemembuffer = TRUE;
break;
}
// if we're using the memory buffer, draw offscreen first and then copy
if (usemembuffer)
{
int x, y;
// based on the target format, use one of our standard renderers
switch (dd->blitdesc.ddpfPixelFormat.dwRBitMask)
{
case 0x00ff0000: drawdd_rgb888_draw_primitives(window->primlist->head, dd->membuffer, dd->blitwidth, dd->blitheight, dd->blitwidth); break;
case 0x000000ff: drawdd_bgr888_draw_primitives(window->primlist->head, dd->membuffer, dd->blitwidth, dd->blitheight, dd->blitwidth); break;
case 0xf800: drawdd_rgb565_draw_primitives(window->primlist->head, dd->membuffer, dd->blitwidth, dd->blitheight, dd->blitwidth); break;
case 0x7c00: drawdd_rgb555_draw_primitives(window->primlist->head, dd->membuffer, dd->blitwidth, dd->blitheight, dd->blitwidth); break;
default:
mame_printf_verbose("DirectDraw: Unknown target mode: R=%08X G=%08X B=%08X\n", (int)dd->blitdesc.ddpfPixelFormat.dwRBitMask, (int)dd->blitdesc.ddpfPixelFormat.dwGBitMask, (int)dd->blitdesc.ddpfPixelFormat.dwBBitMask);
break;
}
// handle copying to both 16bpp and 32bpp destinations
for (y = 0; y < dd->blitheight; y++)
{
if (dd->blitdesc.ddpfPixelFormat.dwRGBBitCount == 32)
{
UINT32 *src = (UINT32 *)dd->membuffer + y * dd->blitwidth;
UINT32 *dst = (UINT32 *)((UINT8 *)dd->blitdesc.lpSurface + y * dd->blitdesc.lPitch);
for (x = 0; x < dd->blitwidth; x++)
*dst++ = *src++;
}
else if (dd->blitdesc.ddpfPixelFormat.dwRGBBitCount == 16)
{
UINT16 *src = (UINT16 *)dd->membuffer + y * dd->blitwidth;
UINT16 *dst = (UINT16 *)((UINT8 *)dd->blitdesc.lpSurface + y * dd->blitdesc.lPitch);
for (x = 0; x < dd->blitwidth; x++)
*dst++ = *src++;
}
}
}
// otherwise, draw directly
else
{
// based on the target format, use one of our standard renderers
switch (dd->blitdesc.ddpfPixelFormat.dwRBitMask)
{
case 0x00ff0000: drawdd_rgb888_nr_draw_primitives(window->primlist->head, dd->blitdesc.lpSurface, dd->blitwidth, dd->blitheight, dd->blitdesc.lPitch / 4); break;
case 0x000000ff: drawdd_bgr888_nr_draw_primitives(window->primlist->head, dd->blitdesc.lpSurface, dd->blitwidth, dd->blitheight, dd->blitdesc.lPitch / 4); break;
case 0xf800: drawdd_rgb565_nr_draw_primitives(window->primlist->head, dd->blitdesc.lpSurface, dd->blitwidth, dd->blitheight, dd->blitdesc.lPitch / 2); break;
case 0x7c00: drawdd_rgb555_nr_draw_primitives(window->primlist->head, dd->blitdesc.lpSurface, dd->blitwidth, dd->blitheight, dd->blitdesc.lPitch / 2); break;
default:
mame_printf_verbose("DirectDraw: Unknown target mode: R=%08X G=%08X B=%08X\n", (int)dd->blitdesc.ddpfPixelFormat.dwRBitMask, (int)dd->blitdesc.ddpfPixelFormat.dwGBitMask, (int)dd->blitdesc.ddpfPixelFormat.dwBBitMask);
break;
}
}
osd_lock_release(window->primlist->lock);
// unlock and blit
result = IDirectDrawSurface7_Unlock(dd->blit, NULL);
if (result != DD_OK) mame_printf_verbose("DirectDraw: Error %08X unlocking blit surface\n", (int)result);
// sync to VBLANK
if ((video_config.waitvsync || video_config.syncrefresh) && video_get_throttle() && (!window->fullscreen || dd->back == NULL))
{
result = IDirectDraw7_WaitForVerticalBlank(dd->ddraw, DDWAITVB_BLOCKBEGIN, NULL);
if (result != DD_OK) mame_printf_verbose("DirectDraw: Error %08X waiting for VBLANK\n", (int)result);
}
// complete the blitting
blit_to_primary(window, dd->blitwidth, dd->blitheight);
return 0;
}
void winwindow_video_window_update(win_window_info *window)
{
int targetview, targetorient, targetlayerconfig;
assert(GetCurrentThreadId() == main_threadid);
mtlog_add("winwindow_video_window_update: begin");
// see if the target has changed significantly in window mode
targetview = render_target_get_view(window->target);
targetorient = render_target_get_orientation(window->target);
targetlayerconfig = render_target_get_layer_config(window->target);
if (targetview != window->targetview || targetorient != window->targetorient || targetlayerconfig != window->targetlayerconfig)
{
window->targetview = targetview;
window->targetorient = targetorient;
window->targetlayerconfig = targetlayerconfig;
// in window mode, reminimize/maximize
if (!window->fullscreen)
{
if (window->isminimized)
SendMessage(window->hwnd, WM_USER_SET_MINSIZE, 0, 0);
if (window->ismaximized)
SendMessage(window->hwnd, WM_USER_SET_MAXSIZE, 0, 0);
}
}
// if we're visible and running and not in the middle of a resize, draw
if (window->hwnd != NULL && window->target != NULL)
{
int got_lock = TRUE;
mtlog_add("winwindow_video_window_update: try lock");
// only block if we're throttled
if (video_config.throttle || timeGetTime() - last_update_time > 250)
osd_lock_acquire(window->render_lock);
else
got_lock = osd_lock_try(window->render_lock);
// only render if we were able to get the lock
if (got_lock)
{
const render_primitive_list *primlist;
mtlog_add("winwindow_video_window_update: got lock");
// don't hold the lock; we just used it to see if rendering was still happening
osd_lock_release(window->render_lock);
// ensure the target bounds are up-to-date, and then get the primitives
primlist = (*draw.window_get_primitives)(window);
// post a redraw request with the primitive list as a parameter
last_update_time = timeGetTime();
mtlog_add("winwindow_video_window_update: PostMessage start");
if (multithreading_enabled)
PostMessage(window->hwnd, WM_USER_REDRAW, 0, (LPARAM)primlist);
else
SendMessage(window->hwnd, WM_USER_REDRAW, 0, (LPARAM)primlist);
mtlog_add("winwindow_video_window_update: PostMessage end");
}
}
mtlog_add("winwindow_video_window_update: end");
}
void droid_ios_video_draw()
{
UINT8 *surfptr;
INT32 pitch;
int bpp;
bpp = 2;
vofs = hofs = 0;
if(myosd_video_threaded)
{
pthread_mutex_lock( &cond_mutex );
while(currlist == NULL)
{
pthread_cond_wait( &condition_var, &cond_mutex );
}
}
if(curr_screen_width!= screen_width || curr_screen_height != screen_height ||
curr_vis_area_screen_width!= vis_area_screen_width || curr_vis_area_screen_height != vis_area_screen_height)
{
screen_width = curr_screen_width;
screen_height = curr_screen_height;
vis_area_screen_width = curr_vis_area_screen_width;
vis_area_screen_height = curr_vis_area_screen_height;
myosd_set_video_mode(screen_width,screen_height,vis_area_screen_width,vis_area_screen_height);
}
if(myosd_video_threaded)
pthread_mutex_unlock( &cond_mutex );
if(myosd_video_threaded)
osd_lock_acquire(currlist->lock);
surfptr = (UINT8 *) myosd_screen15;
pitch = screen_width * (myosd_rgb==1?4:2);
surfptr += ((vofs * pitch) + (hofs * bpp));
#ifdef ANDROID
if(!myosd_rgb)
draw_rgb565_draw_primitives(currlist->head, surfptr, screen_width, screen_height, pitch / 2);
else
draw_bgr888_draw_primitives(currlist->head, surfptr, screen_width, screen_height, pitch / 4);
#else
draw_rgb555_draw_primitives(currlist->head, surfptr, screen_width, screen_height, pitch / 2);
#endif
if(myosd_video_threaded)
osd_lock_release(currlist->lock);
myosd_video_flip();
if(myosd_video_threaded)
pthread_mutex_lock( &cond_mutex );
currlist = NULL;
if(myosd_video_threaded)
pthread_mutex_unlock( &cond_mutex );
}