unsigned int get_timer_ticks_per_draw() { if (get_refresh_rate() != 0) { const unsigned i = timer_ticks_per_second / get_refresh_rate(); if (i > 0) return i; else return 1; } else return 1; // was previously gloB->screen_vsync + 1; }
void screen_mode::SetTo(display_mode& mode) { width = mode.virtual_width; height = mode.virtual_height; space = (color_space)mode.space; refresh = get_refresh_rate(mode); }
static int compare_mode(const void* _mode1, const void* _mode2) { display_mode *mode1 = (display_mode *)_mode1; display_mode *mode2 = (display_mode *)_mode2; uint16 width1, width2, height1, height2; width1 = mode1->virtual_width; height1 = mode1->virtual_height; width2 = mode2->virtual_width; height2 = mode2->virtual_height; if (width1 != width2) return width1 - width2; if (height1 != height2) return height1 - height2; return (int)(10 * get_refresh_rate(*mode1) - 10 * get_refresh_rate(*mode2)); }
bool ScreenMode::GetDisplayMode(const screen_mode& mode, display_mode& displayMode) { uint16 virtualWidth, virtualHeight; int32 bestIndex = -1; float bestDiff = 999; virtualWidth = mode.width; virtualHeight = mode.height; // try to find mode in list provided by driver for (uint32 i = 0; i < fModeCount; i++) { if (fModeList[i].virtual_width != virtualWidth || fModeList[i].virtual_height != virtualHeight || (color_space)fModeList[i].space != mode.space) continue; float refresh = get_refresh_rate(fModeList[i]); if (refresh == mode.refresh) { // we have luck - we can use this mode directly displayMode = fModeList[i]; displayMode.h_display_start = 0; displayMode.v_display_start = 0; return true; } float diff = fabs(refresh - mode.refresh); if (diff < bestDiff) { bestDiff = diff; bestIndex = i; } } // we didn't find the exact mode, but something very similar? if (bestIndex == -1) return false; // now, we are better of using GMT formula, but // as we don't have it, we just tune the pixel // clock of the best mode. displayMode = fModeList[bestIndex]; displayMode.h_display_start = 0; displayMode.v_display_start = 0; // after some fiddling, it looks like this is the formula // used by the original panel (notice that / 10 happens before // multiplying with refresh rate - this leads to different // rounding) displayMode.timing.pixel_clock = ((uint32)displayMode.timing.h_total * displayMode.timing.v_total / 10 * int32(mode.refresh * 10)) / 1000; return true; }
boolean stw_init(const struct stw_winsys *stw_winsys) { static struct stw_device stw_dev_storage; struct pipe_screen *screen; debug_disable_error_message_boxes(); debug_printf("%s\n", __FUNCTION__); assert(!stw_dev); stw_tls_init(); stw_dev = &stw_dev_storage; memset(stw_dev, 0, sizeof(*stw_dev)); #ifdef DEBUG stw_dev->memdbg_no = debug_memory_begin(); #endif stw_dev->stw_winsys = stw_winsys; stw_dev->stapi = stw_st_create_api(); stw_dev->smapi = CALLOC_STRUCT(st_manager); if (!stw_dev->stapi || !stw_dev->smapi) goto error1; screen = stw_winsys->create_screen(); if (!screen) goto error1; if (stw_winsys->get_adapter_luid) stw_winsys->get_adapter_luid(screen, &stw_dev->AdapterLuid); stw_dev->smapi->screen = screen; stw_dev->smapi->get_param = stw_get_param; stw_dev->screen = screen; stw_dev->max_2d_levels = screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS); stw_dev->max_2d_length = 1 << (stw_dev->max_2d_levels - 1); InitializeCriticalSection(&stw_dev->ctx_mutex); InitializeCriticalSection(&stw_dev->fb_mutex); stw_dev->ctx_table = handle_table_create(); if (!stw_dev->ctx_table) { goto error1; } stw_pixelformat_init(); /* env var override for WGL_EXT_swap_control, useful for testing/debugging */ const char *s = os_get_option("WGL_SWAP_INTERVAL"); if (s) { stw_dev->swap_interval = atoi(s); } stw_dev->refresh_rate = get_refresh_rate(); stw_dev->initialized = true; return TRUE; error1: FREE(stw_dev->smapi); if (stw_dev->stapi) stw_dev->stapi->destroy(stw_dev->stapi); stw_dev = NULL; return FALSE; }
static bool init_sdl(const char * fileLoc) { if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0) { std::cerr << "Could not initialize SDL : " << SDL_GetError() << std::endl; return false; } /* START VIDEO */ //set window title char windowTitle[100]; strcpy(windowTitle, "XeNES: "); strcat(windowTitle, fileLoc); int outputHeight; if (REMOVE_OVERSCAN) { outputHeight = (NES_SCREEN_HEIGHT - 16); } else { outputHeight = NES_SCREEN_HEIGHT; } window = SDL_CreateWindow(windowTitle, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, NES_SCREEN_WIDTH * SCALE_FACTOR, outputHeight * SCALE_FACTOR, SDL_WINDOW_RESIZABLE); if (window == NULL) { std::cerr << "Could not create SDL window : " << SDL_GetError() << std::endl; SDL_Quit(); return false; } //SDL_RENDERER_PRESENTVSYNC if (get_refresh_rate(window) == 60) { renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_ACCELERATED); SDL_SetHint(SDL_HINT_RENDER_VSYNC, "1"); } else { renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED); SDL_SetHint(SDL_HINT_RENDER_VSYNC, "0"); } if (renderer == NULL) { std::cerr << "Could not create SDL renderer : " << SDL_GetError() << std::endl; SDL_DestroyWindow(window); SDL_Quit(); return false; } texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, NES_SCREEN_WIDTH, outputHeight); if (texture == NULL) { std::cerr << "Could not create SDL texture : " << SDL_GetError() << std::endl; SDL_DestroyRenderer(renderer); SDL_DestroyWindow(window); SDL_Quit(); return false; } SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, 0); /* END VIDEO */ /* START AUDIO */ SDL_AudioSpec want; SDL_memset(&want, 0, sizeof(want)); SDL_AudioSpec have; want.freq = samplingFrequency; want.format = format; //32-bit floating point samples in little-endian byte order want.channels = channels; want.samples = samplingFrequency * sampleBytes / 60; sdlAudioDevice = SDL_OpenAudioDevice(NULL, 0, &want, &have, 0); if (sdlAudioDevice == 0) { std::cerr << "Failed to open audio : " << SDL_GetError() << std::endl; SDL_DestroyTexture(texture); SDL_DestroyRenderer(renderer); SDL_DestroyWindow(window); SDL_Quit(); return false; } /* END AUDIO */ return true; }