void find_camera_driver(void) { driver_t *driver = driver_get_ptr(); settings_t *settings = config_get_ptr(); int i = find_driver_index("camera_driver", settings->camera.driver); if (i >= 0) driver->camera = (const camera_driver_t*)camera_driver_find_handle(i); else { unsigned d; RARCH_ERR("Couldn't find any camera driver named \"%s\"\n", settings->camera.driver); RARCH_LOG_OUTPUT("Available camera drivers are:\n"); for (d = 0; camera_driver_find_handle(d); d++) RARCH_LOG_OUTPUT("\t%s\n", camera_driver_find_ident(d)); RARCH_WARN("Going to default to first camera driver...\n"); driver->camera = (const camera_driver_t*)camera_driver_find_handle(0); if (!driver->camera) retro_fail(1, "find_camera_driver()"); } }
/** * find_driver_nonempty: * @label : string of driver type to be found. * @i : index of driver. * @str : identifier name of the found driver * gets written to this string. * @len : size of @str. * * Find driver based on @label. * * Returns: NULL if no driver based on @label found, otherwise * pointer to driver. **/ static const void *find_driver_nonempty(const char *label, int i, char *s, size_t len) { const void *drv = NULL; uint32_t hash = msg_hash_calculate(label); switch (hash) { case HASH_CAMERA_DRIVER: drv = camera_driver_find_handle(i); if (drv) strlcpy(s, camera_driver_find_ident(i), len); break; case HASH_LOCATION_DRIVER: drv = location_driver_find_handle(i); if (drv) strlcpy(s, location_driver_find_ident(i), len); break; case HASH_MENU_DRIVER: #ifdef HAVE_MENU drv = menu_driver_find_handle(i); if (drv) strlcpy(s, menu_driver_find_ident(i), len); #endif break; case HASH_INPUT_DRIVER: drv = input_driver_find_handle(i); if (drv) strlcpy(s, input_driver_find_ident(i), len); break; case HASH_INPUT_JOYPAD_DRIVER: drv = joypad_driver_find_handle(i); if (drv) strlcpy(s, joypad_driver_find_ident(i), len); break; case HASH_VIDEO_DRIVER: drv = video_driver_find_handle(i); if (drv) strlcpy(s, video_driver_find_ident(i), len); break; case HASH_AUDIO_DRIVER: drv = audio_driver_find_handle(i); if (drv) strlcpy(s, audio_driver_find_ident(i), len); break; case HASH_RECORD_DRIVER: drv = record_driver_find_handle(i); if (drv) strlcpy(s, record_driver_find_ident(i), len); break; case HASH_AUDIO_RESAMPLER_DRIVER: drv = audio_resampler_driver_find_handle(i); if (drv) strlcpy(s, audio_resampler_driver_find_ident(i), len); break; } return drv; }
/** * config_get_camera_driver_options: * * Get an enumerated list of all camera driver names, * separated by '|'. * * Returns: string listing of all camera driver names, * separated by '|'. **/ const char* config_get_camera_driver_options(void) { union string_list_elem_attr attr; unsigned i; char *options = NULL; int options_len = 0; struct string_list *options_l = string_list_new(); attr.i = 0; if (!options_l) return NULL; for (i = 0; camera_driver_find_handle(i); i++) { const char *opt = camera_driver_find_ident(i); options_len += strlen(opt) + 1; string_list_append(options_l, opt, attr); } options = (char*)calloc(options_len, sizeof(char)); if (!options) { string_list_free(options_l); options_l = NULL; return NULL; } string_list_join_concat(options, options_len, options_l, "|"); string_list_free(options_l); options_l = NULL; return options; }
struct string_list *string_list_new_special(enum string_list_type type, void *data, unsigned *len, size_t *list_size) { union string_list_elem_attr attr; unsigned i; core_info_list_t *core_info_list = NULL; const core_info_t *core_info = NULL; struct string_list *s = string_list_new(); if (!s || !len) goto error; attr.i = 0; *len = 0; switch (type) { case STRING_LIST_MENU_DRIVERS: #ifdef HAVE_MENU for (i = 0; menu_driver_find_handle(i); i++) { const char *opt = menu_driver_find_ident(i); *len += strlen(opt) + 1; string_list_append(s, opt, attr); } break; #endif case STRING_LIST_CAMERA_DRIVERS: #ifdef HAVE_CAMERA for (i = 0; camera_driver_find_handle(i); i++) { const char *opt = camera_driver_find_ident(i); *len += strlen(opt) + 1; string_list_append(s, opt, attr); } break; #endif case STRING_LIST_LOCATION_DRIVERS: #ifdef HAVE_LOCATION for (i = 0; location_driver_find_handle(i); i++) { const char *opt = location_driver_find_ident(i); *len += strlen(opt) + 1; string_list_append(options_l, opt, attr); } break; #endif case STRING_LIST_AUDIO_DRIVERS: for (i = 0; audio_driver_find_handle(i); i++) { const char *opt = audio_driver_find_ident(i); *len += strlen(opt) + 1; string_list_append(s, opt, attr); } break; case STRING_LIST_AUDIO_RESAMPLER_DRIVERS: for (i = 0; audio_resampler_driver_find_handle(i); i++) { const char *opt = audio_resampler_driver_find_ident(i); *len += strlen(opt) + 1; string_list_append(s, opt, attr); } break; case STRING_LIST_VIDEO_DRIVERS: for (i = 0; video_driver_find_handle(i); i++) { const char *opt = video_driver_find_ident(i); *len += strlen(opt) + 1; string_list_append(s, opt, attr); } break; case STRING_LIST_INPUT_DRIVERS: for (i = 0; input_driver_find_handle(i); i++) { const char *opt = input_driver_find_ident(i); *len += strlen(opt) + 1; string_list_append(s, opt, attr); } break; case STRING_LIST_INPUT_HID_DRIVERS: for (i = 0; hid_driver_find_handle(i); i++) { const char *opt = hid_driver_find_ident(i); *len += strlen(opt) + 1; string_list_append(s, opt, attr); } break; case STRING_LIST_INPUT_JOYPAD_DRIVERS: for (i = 0; joypad_driver_find_handle(i); i++) { const char *opt = joypad_driver_find_ident(i); *len += strlen(opt) + 1; string_list_append(s, opt, attr); } break; case STRING_LIST_RECORD_DRIVERS: for (i = 0; record_driver_find_handle(i); i++) { const char *opt = record_driver_find_ident(i); *len += strlen(opt) + 1; string_list_append(s, opt, attr); } break; case STRING_LIST_SUPPORTED_CORES_PATHS: core_info_get_list(&core_info_list); core_info_list_get_supported_cores(core_info_list, (const char*)data, &core_info, list_size); if (!core_info) goto error; if (*list_size == 0) goto error; for (i = 0; i < *list_size; i++) { const core_info_t *info = (const core_info_t*)&core_info[i]; const char *opt = info->path; if (!opt) goto error; *len += strlen(opt) + 1; string_list_append(s, opt, attr); } break; case STRING_LIST_SUPPORTED_CORES_NAMES: core_info_get_list(&core_info_list); core_info_list_get_supported_cores(core_info_list, (const char*)data, &core_info, list_size); if (!core_info) goto error; if (*list_size == 0) goto error; for (i = 0; i < *list_size; i++) { const char *opt = NULL; core_info_t *info = (core_info_t*)&core_info[i]; if (!info) goto error; opt = info->display_name; if (!opt) goto error; *len += strlen(opt) + 1; string_list_append(s, opt, attr); } break; case STRING_LIST_NONE: default: goto error; } return s; error: string_list_free(s); s = NULL; return NULL; }
/** * find_driver_nonempty: * @label : string of driver type to be found. * @i : index of driver. * @str : identifier name of the found driver * gets written to this string. * @sizeof_str : size of @str. * * Find driver based on @label. * * Returns: NULL if no driver based on @label found, otherwise * pointer to driver. **/ static const void *find_driver_nonempty(const char *label, int i, char *str, size_t sizeof_str) { const void *drv = NULL; if (!strcmp(label, "camera_driver")) { drv = camera_driver_find_handle(i); if (drv) strlcpy(str, camera_driver_find_ident(i), sizeof_str); } else if (!strcmp(label, "location_driver")) { drv = location_driver_find_handle(i); if (drv) strlcpy(str, location_driver_find_ident(i), sizeof_str); } #ifdef HAVE_MENU else if (!strcmp(label, "menu_driver")) { drv = menu_driver_find_handle(i); if (drv) strlcpy(str, menu_driver_find_ident(i), sizeof_str); } #endif else if (!strcmp(label, "input_driver")) { drv = input_driver_find_handle(i); if (drv) strlcpy(str, input_driver_find_ident(i), sizeof_str); } else if (!strcmp(label, "input_joypad_driver")) { drv = joypad_driver_find_handle(i); if (drv) strlcpy(str, joypad_driver_find_ident(i), sizeof_str); } else if (!strcmp(label, "video_driver")) { drv = video_driver_find_handle(i); if (drv) strlcpy(str, video_driver_find_ident(i), sizeof_str); } else if (!strcmp(label, "audio_driver")) { drv = audio_driver_find_handle(i); if (drv) strlcpy(str, audio_driver_find_ident(i), sizeof_str); } else if (!strcmp(label, "record_driver")) { drv = record_driver_find_handle(i); if (drv) strlcpy(str, record_driver_find_ident(i), sizeof_str); } else if (!strcmp(label, "audio_resampler_driver")) { drv = audio_resampler_driver_find_handle(i); if (drv) strlcpy(str, audio_resampler_driver_find_ident(i), sizeof_str); } return drv; }
/** * find_driver_nonempty: * @label : string of driver type to be found. * @i : index of driver. * @str : identifier name of the found driver * gets written to this string. * @len : size of @str. * * Find driver based on @label. * * Returns: NULL if no driver based on @label found, otherwise * pointer to driver. **/ static const void *find_driver_nonempty(const char *label, int i, char *s, size_t len) { const void *drv = NULL; if (string_is_equal(label, "camera_driver")) { drv = camera_driver_find_handle(i); if (drv) strlcpy(s, camera_driver_find_ident(i), len); } else if (string_is_equal(label, "location_driver")) { drv = location_driver_find_handle(i); if (drv) strlcpy(s, location_driver_find_ident(i), len); } #ifdef HAVE_MENU else if (string_is_equal(label, "menu_driver")) { drv = menu_driver_find_handle(i); if (drv) strlcpy(s, menu_driver_find_ident(i), len); } #endif else if (string_is_equal(label, "input_driver")) { drv = input_driver_find_handle(i); if (drv) strlcpy(s, input_driver_find_ident(i), len); } else if (string_is_equal(label, "input_joypad_driver")) { drv = joypad_driver_find_handle(i); if (drv) strlcpy(s, joypad_driver_find_ident(i), len); } else if (string_is_equal(label, "video_driver")) { drv = video_driver_find_handle(i); if (drv) strlcpy(s, video_driver_find_ident(i), len); } else if (string_is_equal(label, "audio_driver")) { drv = audio_driver_find_handle(i); if (drv) strlcpy(s, audio_driver_find_ident(i), len); } else if (string_is_equal(label, "record_driver")) { drv = record_driver_find_handle(i); if (drv) strlcpy(s, record_driver_find_ident(i), len); } else if (string_is_equal(label, "midi_driver")) { drv = midi_driver_find_handle(i); if (drv) strlcpy(s, midi_driver_find_ident(i), len); } else if (string_is_equal(label, "audio_resampler_driver")) { drv = audio_resampler_driver_find_handle(i); if (drv) strlcpy(s, audio_resampler_driver_find_ident(i), len); } else if (string_is_equal(label, "wifi_driver")) { drv = wifi_driver_find_handle(i); if (drv) strlcpy(s, wifi_driver_find_ident(i), len); } return drv; }
bool camera_driver_ctl(enum rarch_camera_ctl_state state, void *data) { settings_t *settings = config_get_ptr(); static struct retro_camera_callback camera_cb; static const camera_driver_t *camera_driver = NULL; static void *camera_data = NULL; static bool camera_driver_active = false; static bool camera_driver_data_own = false; switch (state) { case RARCH_CAMERA_CTL_DESTROY: camera_driver_active = false; camera_driver_data_own = false; camera_driver = NULL; camera_data = NULL; break; case RARCH_CAMERA_CTL_SET_OWN_DRIVER: camera_driver_data_own = true; break; case RARCH_CAMERA_CTL_UNSET_OWN_DRIVER: camera_driver_data_own = false; break; case RARCH_CAMERA_CTL_OWNS_DRIVER: return camera_driver_data_own; case RARCH_CAMERA_CTL_SET_ACTIVE: camera_driver_active = true; break; case RARCH_CAMERA_CTL_FIND_DRIVER: { int i; driver_ctx_info_t drv; drv.label = "camera_driver"; drv.s = settings->camera.driver; driver_ctl(RARCH_DRIVER_CTL_FIND_INDEX, &drv); i = drv.len; if (i >= 0) camera_driver = (const camera_driver_t*)camera_driver_find_handle(i); else { unsigned d; RARCH_ERR("Couldn't find any camera driver named \"%s\"\n", settings->camera.driver); RARCH_LOG_OUTPUT("Available camera drivers are:\n"); for (d = 0; camera_driver_find_handle(d); d++) RARCH_LOG_OUTPUT("\t%s\n", camera_driver_find_ident(d)); RARCH_WARN("Going to default to first camera driver...\n"); camera_driver = (const camera_driver_t*)camera_driver_find_handle(0); if (!camera_driver) retro_fail(1, "find_camera_driver()"); } } break; case RARCH_CAMERA_CTL_UNSET_ACTIVE: camera_driver_active = false; break; case RARCH_CAMERA_CTL_IS_ACTIVE: return camera_driver_active; case RARCH_CAMERA_CTL_DEINIT: if (camera_data && camera_driver) { if (camera_cb.deinitialized) camera_cb.deinitialized(); if (camera_driver->free) camera_driver->free(camera_data); } camera_data = NULL; break; case RARCH_CAMERA_CTL_STOP: if ( camera_driver && camera_driver->stop && camera_data) camera_driver->stop(camera_data); break; case RARCH_CAMERA_CTL_START: if (camera_driver && camera_data && camera_driver->start) { if (settings->camera.allow) return camera_driver->start(camera_data); runloop_msg_queue_push( "Camera is explicitly disabled.\n", 1, 180, false); } return false; case RARCH_CAMERA_CTL_POLL: if (!camera_cb.caps) return false; if (!camera_driver || !camera_driver->poll || !camera_data) return false; camera_driver->poll(camera_data, camera_cb.frame_raw_framebuffer, camera_cb.frame_opengl_texture); break; case RARCH_CAMERA_CTL_SET_CB: { struct retro_camera_callback *cb = (struct retro_camera_callback*)data; camera_cb = *cb; } break; case RARCH_CAMERA_CTL_INIT: /* Resource leaks will follow if camera is initialized twice. */ if (camera_data) return false; camera_driver_ctl(RARCH_CAMERA_CTL_FIND_DRIVER, NULL); camera_data = camera_driver->init( *settings->camera.device ? settings->camera.device : NULL, camera_cb.caps, settings->camera.width ? settings->camera.width : camera_cb.width, settings->camera.height ? settings->camera.height : camera_cb.height); if (!camera_data) { RARCH_ERR("Failed to initialize camera driver. Will continue without camera.\n"); camera_driver_ctl(RARCH_CAMERA_CTL_UNSET_ACTIVE, NULL); } if (camera_cb.initialized) camera_cb.initialized(); break; default: break; } return false; }