repos/blastem: render_sdl.c comparison

comparison render_sdl.c @ 2093:46ee354f29bd

Hack fix for audio deadlock issue

author	Michael Pavone <pavone@retrodev.com>
date	Sun, 06 Feb 2022 23:25:23 -0800
parents	0757da8ee702
children	f11f4399d64b

comparison

equal deleted inserted replaced

-:8665d8da0e1c
+:46ee354f29bd
 	if (current_system && sync_src == SYNC_AUDIO_THREAD) {
 		system_request_exit(current_system, 0);
 	}
 }
+uint8_t audio_deadlock_hack(void);
 void render_do_audio_ready(audio_source *src)
 {
 	if (sync_src == SYNC_AUDIO_THREAD) {
 		int16_t *tmp = src->front;
 		src->front = src->back;
 			//we've emulated far enough to fill the current buffer
 			system_request_exit(current_system, 0);
 		}
 	} else if (sync_src == SYNC_AUDIO) {
 		SDL_LockMutex(audio_mutex);
+			if (src->front_populated) {
+				if (audio_deadlock_hack()) {
+					SDL_CondSignal(audio_ready);
+				}
+			}
 			while (src->front_populated) {
 				SDL_CondWait(src->opaque, audio_mutex);
 			}
 			int16_t *tmp = src->front;
 			src->front = src->back;
 		fsize = fsize32;
 #ifndef __ANDROID__
 	}
 #endif
 	text[fsize] = 0;
 	if (strncmp(text, "#version", strlen("#version"))) {
 		GLchar *tmp = text;
 		text = alloc_concat(shader_prefix, tmp);
 		free(tmp);
 		fsize += strlen(shader_prefix);
 {
 	uint32_t flags = SDL_WINDOW_RESIZABLE;
 	if (is_fullscreen) {
 		flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
 	}
 	tern_val def = {.ptrval = "audio"};
 	if (external_sync) {
 		sync_src = SYNC_EXTERNAL;
 	} else {
 		char *sync_src_str = tern_find_path_default(config, "system\0sync_source\0", def, TVAL_PTR).ptrval;
 			sync_src = SYNC_AUDIO_THREAD;
 		} else {
 			sync_src = SYNC_VIDEO;
 		}
 	}
 	if (!num_buffers && (sync_src == SYNC_AUDIO_THREAD || sync_src == SYNC_EXTERNAL)) {
 		frame_mutex = SDL_CreateMutex();
 		free_buffer_mutex = SDL_CreateMutex();
 		frame_ready = SDL_CreateCond();
 		buffer_storage = 4;
 		frame_buffers = calloc(buffer_storage, sizeof(uint32_t*));
 		frame_buffers[0] = texture_buf;
 		num_buffers = 1;
 	}
 	const char *vsync;
 	if (sync_src == SYNC_AUDIO) {
 		def.ptrval = "off";
 		vsync = tern_find_path_default(config, "video\0vsync\0", def, TVAL_PTR).ptrval;
 	} else {
 		vsync = "on";
 	}
 	tern_node *video = tern_find_node(config, "video");
 	if (video)
 	{
 		for (int i = 0; i < NUM_VID_STD; i++)
 		{
 				}
 			}
 		}
 	}
 	render_gl = 0;
 #ifndef DISABLE_OPENGL
 	char *gl_enabled_str = tern_find_path_default(config, "video\0gl\0", def, TVAL_PTR).ptrval;
 	uint8_t gl_enabled = strcmp(gl_enabled_str, "off") != 0;
 	if (gl_enabled)
 	{
 		height = ((float)width / aspect) + 0.5f;
 	}
 	debug_message("width: %d, height: %d\n", width, height);
 	windowed_width = width;
 	windowed_height = height;
 	SDL_DisplayMode mode;
 	//TODO: Explicit multiple monitor support
 	SDL_GetCurrentDisplayMode(0, &mode);
 	display_hz = mode.refresh_rate;
 		height = mode.h;
 	}
 	main_width = width;
 	main_height = height;
 	is_fullscreen = fullscreen;
 	caption = title;
 	window_setup();
 	audio_mutex = SDL_CreateMutex();
 	audio_ready = SDL_CreateCond();
 	init_audio();
 	uint32_t db_size;
 	char *db_data = read_bundled_file("gamecontrollerdb.txt", &db_size);
 	if (db_data) {
 		int added = SDL_GameControllerAddMappingsFromRW(SDL_RWFromMem(db_data, db_size), 1);
 		free(db_data);
 		debug_message("Added %d game controller mappings from gamecontrollerdb.txt\n", added);
 	}
 	controller_add_mappings();
 	SDL_JoystickEventState(SDL_ENABLE);
 	render_set_video_standard(VID_NTSC);
 	atexit(render_quit);
 }
 #endif
 	in_toggle = 1;
 	SDL_DestroyWindow(main_window);
 	main_window = NULL;
 	drain_events();
 	char *config_width = tern_find_path(config, "video\0width\0", TVAL_PTR).ptrval;
 	if (config_width) {
 		windowed_width = atoi(config_width);
 	}
 	char *config_height = tern_find_path(config, "video\0height\0", TVAL_PTR).ptrval;
 		main_height = windowed_height;
 	}
 	if (on_ui_fb_resized) {
 		on_ui_fb_resized();
 	}
 	window_setup();
 	update_aspect();
 #ifndef DISABLE_OPENGL
 	//need to check render_gl again after window_setup as render option could have changed
 	if (render_gl && on_context_created) {
 	uint8_t was_paused = SDL_GetAudioStatus() == SDL_AUDIO_PAUSED;
 	render_close_audio();
 	quitting = 0;
 	init_audio();
 	render_set_video_standard(video_standard);
 	drain_events();
 	in_toggle = 0;
 	if (!was_paused) {
 		SDL_PauseAudio(0);
 	}
 		if (!extra_windows[i]) {
 			win_idx = i;
 			break;
 		}
 	}
 	if (win_idx == 0xFF) {
 		num_textures++;
 		sdl_textures = realloc(sdl_textures, num_textures * sizeof(*sdl_textures));
 		extra_windows = realloc(extra_windows, (num_textures - FRAMEBUFFER_USER_START) * sizeof(*extra_windows));
 		extra_renderers = realloc(extra_renderers, (num_textures - FRAMEBUFFER_USER_START) * sizeof(*extra_renderers));
 	if (!sdl_textures[texture_idx]) {
 		goto fail_texture;
 	}
 	close_handlers[win_idx] = close_handler;
 	return texture_idx;
 fail_texture:
 	SDL_DestroyRenderer(extra_renderers[win_idx]);
 fail_renderer:
 	SDL_DestroyWindow(extra_windows[win_idx]);
 fail_window:
 {
 	uint8_t win_idx = which - FRAMEBUFFER_USER_START;
 	//Destroying the renderers also frees the textures
 	SDL_DestroyRenderer(extra_renderers[win_idx]);
 	SDL_DestroyWindow(extra_windows[win_idx]);
 	extra_renderers[win_idx] = NULL;
 	extra_windows[win_idx] = NULL;
 }
 uint32_t *locked_pixels;
 		}
 		source_frame_count = frame_repeat[source_frame];
 		//TODO: Figure out what to do about SDL Render API texture locking
 		return;
 	}
 	last_width = width;
 	uint32_t height = which <= FRAMEBUFFER_EVEN
 		? (video_standard == VID_NTSC ? 243 : 294) - (overscan_top[video_standard] + overscan_bot[video_standard])
 		: 240;
 	FILE *screenshot_file = NULL;
 	uint32_t shot_height, shot_width;
 	char *ext;
 #ifndef DISABLE_OPENGL
 	if (render_gl && which <= FRAMEBUFFER_EVEN) {
 		SDL_GL_MakeCurrent(main_window, main_context);
 		glBindTexture(GL_TEXTURE_2D, textures[which]);
 		glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, LINEBUF_SIZE, height, SRC_FORMAT, GL_UNSIGNED_BYTE, buffer + overscan_left[video_standard] + LINEBUF_SIZE * overscan_top[video_standard]);
 		if (screenshot_file) {
 			//properly supporting interlaced modes here is non-trivial, so only save the odd field for now
 #ifndef DISABLE_ZLIB
 			if (!strcasecmp(ext, "png")) {
 				free(ext);
 			frames_to_problem < BUFFER_FRAMES_THRESHOLD
 			|| (average_change < 0 && local_cur_min < 3*min_buffered / 4)
 			|| (average_change >0 && local_cur_min > 5 * min_buffered / 4)
 			|| cur_min_buffered < 0
 		) {
 			if (cur_min_buffered < 0) {
 				adjust_ratio = max_adjust;
 				SDL_PauseAudio(1);
 				last_buffered = NO_LAST_BUFFERED;
 				cur_min_buffered = 0;
 			adjust_ratio = max_adjust;
 		}
 		if (adjust_ratio != 0.0f) {
 			average_change = 0;
 			render_audio_adjust_speed(adjust_ratio);
 		}
 		while (source_frame_count > 0)
 		{
 			render_update_display();
 			source_frame_count--;
 			}
 			if (SDL_GetAudioStatus() != SDL_AUDIO_PLAYING) {
 				break;
 			}
 		}
 	SDL_UnlockMutex(frame_mutex);
 }
 static ui_render_fun render_ui;
 void render_set_ui_render_fun(ui_render_fun fun)
 		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[1]);
 		glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_SHORT, (void *)0);
 		glDisableVertexAttribArray(at_pos);
 		if (render_ui) {
 			render_ui();
 		}
 		SDL_GL_SwapWindow(main_window);
 {
 	tern_node *button_lookup, *axis_lookup;
 	if (controller > MAX_JOYSTICKS || !joysticks[controller]) {
 		return RENDER_NOT_PLUGGED_IN;
 	}
 	if (!SDL_IsGameController(joystick_sdl_index[controller])) {
 		return RENDER_NOT_MAPPED;
 	}
 	SDL_GameController *control = SDL_GameControllerOpen(joystick_sdl_index[controller]);
 	if (!control) {
 		warning("Failed to open game controller %d: %s\n", controller, SDL_GetError());
 		return RENDER_NOT_PLUGGED_IN;
 	}
 	SDL_GameControllerButtonBind cbind;
 	int32_t is_positive = RENDER_AXIS_POS;
 	if (is_axis) {
 		int sdl_axis = render_lookup_axis(name);
 		if (sdl_axis == SDL_CONTROLLER_AXIS_INVALID) {
 			SDL_GameControllerClose(control);
 			return RENDER_INVALID_NAME;
 		}
 	//protect against event processing causing us to attempt to toggle while still toggling
 	if (in_toggle) {
 		return;
 	}
 	in_toggle = 1;
 	//toggling too fast seems to cause a deadlock
 	static uint32_t last_toggle;
 	uint32_t cur = SDL_GetTicks();
 	if (last_toggle && cur - last_toggle < TOGGLE_MIN_DELAY) {
 		in_toggle = 0;
 		return;
 	}
 	last_toggle = cur;
 	drain_events();
 	is_fullscreen = !is_fullscreen;
 	if (is_fullscreen) {
 		SDL_DisplayMode mode;
 		//TODO: Multiple monitor support
 		return FRAMEBUFFER_ODD;
 	}
 	for (int i = 0; i < num_textures - 2; i++)
 	{
 		if (extra_windows[i] && (SDL_GetWindowFlags(extra_windows[i]) & SDL_WINDOW_INPUT_FOCUS)) {
 			return FRAMEBUFFER_USER_START + i;
 		}
 	}
 	return 0xFF;
 }

Mercurial > repos > blastem

comparison render_sdl.c @ 2093:46ee354f29bd