static void timer_start(uint8_t u8Timer, uint32_t u32Period, bool_t bRepeatMode) {
uint8_t u8Prescale = 4;
uint16_t u16Lo = 1000, u16Control;
float clockRateInKhz, periodInMiliSecs;
/* Maximum period supported by timer is 268 seconds with prescale value 16 */
MBED_ASSERT(u32Period < 268000000);
if(!bRepeatMode)
{
u8Prescale = prescale(u32Period);
clockRateInKhz = 16000000/(1<<u8Prescale);
clockRateInKhz = clockRateInKhz/1000;
periodInMiliSecs = u32Period;
periodInMiliSecs = periodInMiliSecs/1000;
u16Lo = (uint16_t)(clockRateInKhz*periodInMiliSecs);
}
/* Set pre scaler to correct value */
vREG_TimerWrite(u8Timer, REG_TMR_PRESC, u8Prescale);
u16Control = REG_TMR_CTRL_GDIS_MASK | REG_TMR_CTRL_EN_MASK | REG_TMR_CTRL_CTRRST_MASK;
if(!bRepeatMode)
{
u16Control |= REG_TMR_CTRL_SINGLE_MASK;
}
vREG_TimerWrite(u8Timer, REG_TMR_HI, (uint32_t)(u16Lo -1));
vREG_TimerWrite(u8Timer, REG_TMR_LO, (uint32_t)u16Lo);
vREG_TimerWrite(u8Timer, REG_TMR_CTRL, (uint32_t)u16Control);
}
texture_info * renderer_sdl2::texture_update(const render_primitive &prim)
{
quad_setup_data setup;
texture_info *texture;
auto win = assert_window();
setup.compute(prim, win->prescale());
texture = texture_find(prim, setup);
// if we didn't find one, create a new texture
if (texture == nullptr && prim.texture.base != nullptr)
{
texture = global_alloc(texture_info(this, prim.texture, setup, prim.flags));
/* add us to the texture list */
m_texlist.prepend(*texture);
}
if (texture != nullptr)
{
if (prim.texture.base != nullptr && texture->texinfo().seqid != prim.texture.seqid)
{
texture->texinfo().seqid = prim.texture.seqid;
// if we found it, but with a different seqid, copy the data
texture->set_data(prim.texture, prim.flags);
}
}
return texture;
}
void sdl_window_info::modify_prescale(int dir)
{
worker_param wp = worker_param(this);
int new_prescale = prescale();
if (dir > 0 && prescale() < 3)
new_prescale = prescale() + 1;
if (dir < 0 && prescale() > 1)
new_prescale = prescale() - 1;
if (new_prescale != prescale())
{
if (m_fullscreen && video_config.switchres)
{
execute_async_wait(&sdlwindow_video_window_destroy_wt, wp);
m_prescale = new_prescale;
execute_async_wait(&complete_create_wt, wp);
}
else
{
notify_changed();
m_prescale = new_prescale;
}
machine().ui().popup_time(1, "Prescale %d", prescale());
}
}
void sdl_window_info::modify_prescale(int dir)
{
int new_prescale = prescale();
if (dir > 0 && prescale() < 3)
new_prescale = prescale() + 1;
if (dir < 0 && prescale() > 1)
new_prescale = prescale() - 1;
if (new_prescale != prescale())
{
if (m_fullscreen && video_config.switchres)
{
complete_destroy();
m_prescale = new_prescale;
complete_create();
}
else
{
notify_changed();
m_prescale = new_prescale;
}
machine().ui().popup_time(1, "Prescale %d", prescale());
}
}
void sdl_window_info::modify_prescale(int dir)
{
int new_prescale = prescale();
if (dir > 0 && prescale() < 3)
new_prescale = prescale() + 1;
if (dir < 0 && prescale() > 1)
new_prescale = prescale() - 1;
if (new_prescale != prescale())
{
if (m_fullscreen && video_config.switchres)
{
auto wp = std::make_unique<worker_param>(std::static_pointer_cast<sdl_window_info>(shared_from_this()));
execute_async_wait(&sdlwindow_video_window_destroy_wt, std::move(wp));
m_prescale = new_prescale;
wp = std::make_unique<worker_param>(std::static_pointer_cast<sdl_window_info>(shared_from_this()));
execute_async_wait(&complete_create_wt, std::move(wp));
}
else
{
notify_changed();
m_prescale = new_prescale;
}
machine().ui().popup_time(1, "Prescale %d", prescale());
}
}
osd_dim sdl_window_info::pick_best_mode()
{
int minimum_width, minimum_height, target_width, target_height;
int i;
float size_score, best_score = 0.0f;
int best_width = 0, best_height = 0;
SDL_Rect **modes;
// check if we already have a best mode
modeline *mode = &this->machine().switchres.best_mode;
if (mode->hactive)
{
ret = osd_dim(mode->type & MODE_ROTATED? mode->vactive : mode->hactive, mode->type & MODE_ROTATED? mode->hactive : mode->vactive);
return ret;
}
// determine the minimum width/height for the selected target
m_target->compute_minimum_size(minimum_width, minimum_height);
// use those as the target for now
target_width = minimum_width * MAX(1, prescale());
target_height = minimum_height * MAX(1, prescale());
// if we're not stretching, allow some slop on the minimum since we can handle it
{
minimum_width -= 4;
minimum_height -= 4;
}
#if 1 // defined(SDLMAME_WIN32)
/*
* We need to do this here. If SDL_ListModes is
* called in init_monitors, the call will crash
* on win32
*/
modes = SDL_ListModes(NULL, SDL_FULLSCREEN | SDL_DOUBLEBUF);
#else
modes = window->m_monitor->modes;
#endif
if (modes == (SDL_Rect **)0)
{
osd_printf_error("SDL: No modes available?!\n");
exit(-1);
}
else if (modes == (SDL_Rect **)-1) // all modes are possible
{
return osd_dim(m_win_config.width, m_win_config.height);
}
else
{
for (i = 0; modes[i]; ++i)
{
// compute initial score based on difference between target and current
size_score = 1.0f / (1.0f + fabsf((INT32)modes[i]->w - target_width) + fabsf((INT32)modes[i]->h - target_height));
// if the mode is too small, give a big penalty
if (modes[i]->w < minimum_width || modes[i]->h < minimum_height)
size_score *= 0.01f;
// if mode is smaller than we'd like, it only scores up to 0.1
if (modes[i]->w < target_width || modes[i]->h < target_height)
size_score *= 0.1f;
// if we're looking for a particular mode, that's a winner
if (modes[i]->w == m_win_config.width && modes[i]->h == m_win_config.height)
size_score = 2.0f;
osd_printf_verbose("%4dx%4d -> %f\n", (int)modes[i]->w, (int)modes[i]->h, size_score);
// best so far?
if (size_score > best_score)
{
best_score = size_score;
best_width = modes[i]->w;
best_height = modes[i]->h;
}
}
}
return osd_dim(best_width, best_height);
}
osd_dim sdl_window_info::pick_best_mode()
{
int minimum_width, minimum_height, target_width, target_height;
int i;
int num;
float size_score, best_score = 0.0f;
osd_dim ret(0,0);
// check if we already have a best mode
modeline *mode = &this->machine().switchres.best_mode;
if (mode->hactive)
{
ret = osd_dim(mode->type & MODE_ROTATED? mode->vactive : mode->hactive, mode->type & MODE_ROTATED? mode->hactive : mode->vactive);
return ret;
}
// determine the minimum width/height for the selected target
m_target->compute_minimum_size(minimum_width, minimum_height);
// use those as the target for now
target_width = minimum_width * MAX(1, prescale());
target_height = minimum_height * MAX(1, prescale());
// if we're not stretching, allow some slop on the minimum since we can handle it
{
minimum_width -= 4;
minimum_height -= 4;
}
// FIXME: this should be provided by monitor !
num = SDL_GetNumDisplayModes(*((UINT64 *)m_monitor->oshandle()));
if (num == 0)
{
osd_printf_error("SDL: No modes available?!\n");
exit(-1);
}
else
{
for (i = 0; i < num; ++i)
{
SDL_DisplayMode mode;
SDL_GetDisplayMode(*((UINT64 *)m_monitor->oshandle()), i, &mode);
// compute initial score based on difference between target and current
size_score = 1.0f / (1.0f + abs((INT32)mode.w - target_width) + abs((INT32)mode.h - target_height));
// if the mode is too small, give a big penalty
if (mode.w < minimum_width || mode.h < minimum_height)
size_score *= 0.01f;
// if mode is smaller than we'd like, it only scores up to 0.1
if (mode.w < target_width || mode.h < target_height)
size_score *= 0.1f;
// if we're looking for a particular mode, that's a winner
if (mode.w == m_win_config.width && mode.h == m_win_config.height)
size_score = 2.0f;
// refresh adds some points
if (m_win_config.refresh)
size_score *= 1.0f / (1.0f + abs(m_win_config.refresh - mode.refresh_rate) / 10.0f);
osd_printf_verbose("%4dx%4d@%2d -> %f\n", (int)mode.w, (int)mode.h, (int) mode.refresh_rate, (double) size_score);
// best so far?
if (size_score > best_score)
{
best_score = size_score;
ret = osd_dim(mode.w, mode.h);
}
}
}
return ret;
}
