static void draw_text_info(int x, int y, int dx, int dy, int pos) { char buffer[3][256]; adv_crtc* crtc = menu_pos(pos); if (crtc) { format_info(buffer[0], buffer[1], buffer[2], 256, crtc); } else { sncpy(buffer[0], sizeof(buffer[0]), ""); sncpy(buffer[1], sizeof(buffer[1]), ""); sncpy(buffer[2], sizeof(buffer[2]), ""); } draw_text_left(x, y+0, dx, buffer[0], COLOR_INFO_TITLE); draw_text_left(x, y+1, dx, buffer[1], COLOR_INFO_NORMAL); draw_text_left(x, y+2, dx, buffer[2], COLOR_INFO_NORMAL); if (crtc) { if (crtc_is_fake(crtc)) { draw_text_left(x+dx-8, y, 8, " SYSTEM ", COLOR_INFO_NORMAL); } else if (!crtc_clock_check(&the_monitor, crtc)) { draw_text_left(x+dx-14, y, 14, " OUT OF RANGE ", COLOR_ERROR); } else { draw_text_left(x+dx-14, y, 14, " PROGRAMMABLE ", COLOR_INFO_NORMAL); } } else { draw_text_fillrect(x, y, ' ', dx, dy, COLOR_INFO_NORMAL); } }
void soundb_alsa_default(void) { sncpy(alsa_option.device_buffer, sizeof(alsa_option.device_buffer), "default"); sncpy(alsa_option.mixer_buffer, sizeof(alsa_option.mixer_buffer), "channel"); alsa_option.initialized = 1; }
static void mouseb_setup(struct mouse_item_context* item) { unsigned i; struct button_entry { int code; const char* name; } button_map[] = { { MOUSE_LEFTBUTTON, "left" }, { MOUSE_RIGHTBUTTON, "right" }, { MOUSE_MIDDLEBUTTON, "middle" }, { MOUSE_FOURTHBUTTON, "button4" }, { MOUSE_FIFTHBUTTON, "button5" }, { MOUSE_SIXTHBUTTON, "button6" } }; struct axe_entry { int code; const char* name; } axe_map[] = { { MOUSE_XDIM, "x" }, { MOUSE_YDIM, "y" }, { MOUSE_ZDIM, "z" }, { MOUSE_RXDIM, "rx" }, { MOUSE_RYDIM, "ry" }, { MOUSE_RZDIM, "rz" } }; item->button_mac = 0; for (i = 0; i < sizeof(button_map) / sizeof(button_map[0]); ++i) { if ((item->context.info_button & button_map[i].code) != 0) { if (item->button_mac < RAW_MOUSE_BUTTON_MAX) { item->button_map[item->button_mac].code = button_map[i].code; item->button_map[item->button_mac].pvalue = &item->context.button; sncpy(item->button_map[item->button_mac].name, sizeof(item->button_map[item->button_mac].name), button_map[i].name); ++item->button_mac; } } } item->axe_mac = 0; for (i = 0; i < sizeof(axe_map) / sizeof(axe_map[0]); ++i) { if ((item->context.info_button & axe_map[i].code) != 0) { if (item->axe_mac < RAW_MOUSE_AXE_MAX) { item->axe_map[item->axe_mac].code = axe_map[i].code; switch (axe_map[i].code) { case MOUSE_XDIM: item->axe_map[item->axe_mac].pvalue = &item->context.x; break; case MOUSE_YDIM: item->axe_map[item->axe_mac].pvalue = &item->context.y; break; case MOUSE_ZDIM: item->axe_map[item->axe_mac].pvalue = &item->context.z; break; case MOUSE_RXDIM: item->axe_map[item->axe_mac].pvalue = &item->context.rx; break; case MOUSE_RYDIM: item->axe_map[item->axe_mac].pvalue = &item->context.ry; break; case MOUSE_RZDIM: item->axe_map[item->axe_mac].pvalue = &item->context.rz; break; } sncpy(item->axe_map[item->axe_mac].name, sizeof(item->axe_map[item->axe_mac].name), axe_map[i].name); ++item->axe_mac; } } } }
adv_error soundb_alsa_load(adv_conf* context) { sncpy(alsa_option.device_buffer, sizeof(alsa_option.device_buffer), conf_string_get_default(context, "device_alsa_device")); sncpy(alsa_option.mixer_buffer, sizeof(alsa_option.mixer_buffer), conf_string_get_default(context, "device_alsa_mixer")); alsa_option.initialized = 1; return 0; }
static adv_error cmd_modeline_create(int favourite_vtotal) { adv_crtc crtc; char buffer[80]; double freq = 0; unsigned x; unsigned y; adv_error res; sncpy(buffer, sizeof(buffer), ""); if (cmd_input_string(" Vertical clock [Hz] (example 60.0) : ", buffer, 10)!=0) return 0; freq = strtod(buffer, 0); if (freq < 10 || freq > 200) { error_set("Invalid vertical clock value, usually in the range 10 - 200.0 [Hz]"); return -1; } sncpy(buffer, sizeof(buffer), ""); if (cmd_input_string(" X resolution [pixel] : ", buffer, 10)!=0) return 0; x = atoi(buffer); if (x < 64 || x > 2048) { error_set("Invalid x resolution value"); return -1; } sncpy(buffer, sizeof(buffer), ""); if (cmd_input_string(" Y resolution [pixel] : ", buffer, 10)!=0) return 0; y = atoi(buffer); if (y < 64 || y > 2048) { error_set("Invalid y resolution value"); return -1; } res = generate_find_interpolate_multi(&crtc, x, y, x*2, y*2, x*3, y*3, x*4, y*4, freq, &the_monitor, &the_interpolate, VIDEO_DRIVER_FLAGS_PROGRAMMABLE_SINGLESCAN | VIDEO_DRIVER_FLAGS_PROGRAMMABLE_DOUBLESCAN | VIDEO_DRIVER_FLAGS_PROGRAMMABLE_INTERLACE | VIDEO_DRIVER_FLAGS_PROGRAMMABLE_CLOCK | VIDEO_DRIVER_FLAGS_PROGRAMMABLE_CRTC, GENERATE_ADJUST_EXACT); if (favourite_vtotal) { if (res != 0) res = generate_find_interpolate_multi(&crtc, x, y, x*2, y*2, x*3, y*3, x*4, y*4, freq, &the_monitor, &the_interpolate, VIDEO_DRIVER_FLAGS_PROGRAMMABLE_SINGLESCAN | VIDEO_DRIVER_FLAGS_PROGRAMMABLE_DOUBLESCAN | VIDEO_DRIVER_FLAGS_PROGRAMMABLE_INTERLACE | VIDEO_DRIVER_FLAGS_PROGRAMMABLE_CLOCK | VIDEO_DRIVER_FLAGS_PROGRAMMABLE_CRTC, GENERATE_ADJUST_VCLOCK); } else { if (res != 0) res = generate_find_interpolate_multi(&crtc, x, y, x*2, y*2, x*3, y*3, x*4, y*4, freq, &the_monitor, &the_interpolate, VIDEO_DRIVER_FLAGS_PROGRAMMABLE_SINGLESCAN | VIDEO_DRIVER_FLAGS_PROGRAMMABLE_DOUBLESCAN | VIDEO_DRIVER_FLAGS_PROGRAMMABLE_INTERLACE | VIDEO_DRIVER_FLAGS_PROGRAMMABLE_CLOCK | VIDEO_DRIVER_FLAGS_PROGRAMMABLE_CRTC, GENERATE_ADJUST_VTOTAL); } if (res != 0) res = generate_find_interpolate_multi(&crtc, x, y, x*2, y*2, x*3, y*3, x*4, y*4, freq, &the_monitor, &the_interpolate, VIDEO_DRIVER_FLAGS_PROGRAMMABLE_SINGLESCAN | VIDEO_DRIVER_FLAGS_PROGRAMMABLE_DOUBLESCAN | VIDEO_DRIVER_FLAGS_PROGRAMMABLE_INTERLACE | VIDEO_DRIVER_FLAGS_PROGRAMMABLE_CLOCK | VIDEO_DRIVER_FLAGS_PROGRAMMABLE_CRTC, GENERATE_ADJUST_VCLOCK | GENERATE_ADJUST_VTOTAL); if (res != 0) { error_set("Request out of your monitor range"); return -1; } menu_insert(&crtc); return 0; }
static void mouseb_setup(struct mouse_item_context* item, unsigned nbutton) { unsigned i; struct button_entry { int code; const char* name; } button_map[] = { { 0x1, "left" }, { 0x2, "right" }, { 0x4, "middle" }, { 0x8, "button4" }, { 0x10, "button5" } }; struct axe_entry { int code; const char* name; } axe_map[] = { { 0, "x" }, { 1, "y" }, { 2, "z" } }; item->button_mac = 0; for (i = 0; i < sizeof(button_map) / sizeof(button_map[0]); ++i) { if (i < nbutton) { if (item->button_mac < RAW_MOUSE_BUTTON_MAX) { item->button_map[item->button_mac].code = button_map[i].code; item->button_map[item->button_mac].pvalue = &item->context.button; sncpy(item->button_map[item->button_mac].name, sizeof(item->button_map[item->button_mac].name), button_map[i].name); ++item->button_mac; } } } item->axe_mac = 0; for (i = 0; i < sizeof(axe_map) / sizeof(axe_map[0]); ++i) { if (item->axe_mac < RAW_MOUSE_AXE_MAX) { item->axe_map[item->axe_mac].code = axe_map[i].code; switch (axe_map[i].code) { case 0: item->axe_map[item->axe_mac].pvalue = &item->context.x; break; case 1: item->axe_map[item->axe_mac].pvalue = &item->context.y; break; case 2: item->axe_map[item->axe_mac].pvalue = &item->context.z; break; } sncpy(item->axe_map[item->axe_mac].name, sizeof(item->axe_map[item->axe_mac].name), axe_map[i].name); ++item->axe_mac; } } }
unsigned advance_ui_menu_option_insert(struct ui_menu* menu, const char* text, const char* option) { struct ui_menu_entry* entry = &menu->map[menu->mac]; assert(menu->mac < menu->max); if (menu->mac == menu->max) return -1; entry->type = ui_menu_option; sncpy(entry->text_buffer, sizeof(entry->text_buffer), text); sncpy(entry->option_buffer, sizeof(entry->option_buffer), option); ++menu->mac; return ui_menu_select(menu) - 1; }
adv_error device_check(const char* option, const char* arg, const adv_driver** driver_map, unsigned driver_mac, const char* driver_ignore) { char buffer[DEVICE_NAME_MAX]; const char* tag_one; unsigned i, j; /* check the validity of every item on the argument */ sncpy(buffer, sizeof(buffer), arg); tag_one = strtok(buffer, " \t"); while (tag_one) { if (strcmp("auto", tag_one)!=0 && strstr(driver_ignore, tag_one)==0) { for(i=0;i<driver_mac;++i) { if (strcmp(driver_map[i]->name, tag_one)==0) break; for(j=0;driver_map[i]->device_map[j].name;++j) { char cat_buffer[DEVICE_NAME_MAX]; snprintf(cat_buffer, sizeof(cat_buffer), "%s/%s", driver_map[i]->name, driver_map[i]->device_map[j].name); if (strcmp(cat_buffer, tag_one)==0) break; } if (driver_map[i]->device_map[j].name) break; } if (i == driver_mac) { device_error(option, tag_one, driver_map, driver_mac); return -1; } } tag_one = strtok(NULL, " \t"); } return 0; }
int main(){ char s[10]="hello"; printf("%s: %d\n",s,slen(s)); //testing for slen char cpy[15]="aba"; printf("After scpy, %s became: ",cpy); scpy(cpy,s); printf("%s\n",cpy); char ncpy[15]="abalaba"; printf("After sncpy (n=3), %s became: ",ncpy); sncpy(ncpy,s,3); printf("%s\n",ncpy); char cat[15]="AddOn"; printf("After scat, %s became: ",cpy); scat(cpy,cat); printf("%s\n",cpy); char s2[18]="hello"; char s3[5]="po"; char s4[5]="bao"; printf("scmp %s and %s: %d\n",s,s2,scmp(s,s2)); printf("scmp %s and %s: %d\n",s,cpy,scmp(s,cpy)); printf("scmp %s and %s: %d\n",s,s3,scmp(s,s3)); printf("scmp %s and %s: %d\n",s,s4,scmp(s,s4)); printf("schr %s and %c: %s\n",s,'l',schr(s,'l')); printf("schr %s and %c: %s\n",s,'t',schr(s,'t')); char s5[5]="el"; printf("sstr %s and %s: %s\n",s,s5,sstr(s,s5)); printf("sstr %s and %s: %s\n",s,s3,sstr(s,s3)); return 0; }
adv_error mouseb_load(adv_conf* context) { unsigned i; int at_least_one; if (mouseb_state.driver_mac == 0) { error_set("No mouse driver was compiled in."); return -1; } mouseb_state.is_initialized_flag = 1; sncpy(mouseb_state.name, DEVICE_NAME_MAX, conf_string_get_default(context, "device_mouse")); /* load specific driver options */ at_least_one = 0; for (i = 0; i < mouseb_state.driver_mac; ++i) { const adv_device* dev; dev = device_match(mouseb_state.name, (adv_driver*)mouseb_state.driver_map[i], 0); if (dev) at_least_one = 1; if (mouseb_state.driver_map[i]->load(context) != 0) return -1; } if (!at_least_one) { device_error("device_mouse", mouseb_state.name, (const adv_driver**)mouseb_state.driver_map, mouseb_state.driver_mac); return -1; } return 0; }
static void draw_text_bar(int x, int by1, int by2, int dx) { char buffer[256]; unsigned i; snprintf(buffer, sizeof(buffer), " AdvanceVIDEO Config - " __DATE__); draw_text_left(x, by1, dx, buffer, COLOR_BAR); sncpy(buffer, sizeof(buffer), ""); for(i=0;i<video_driver_vector_max();++i) { if (video_driver_vector_pos(i) != 0) { if (*buffer) sncat(buffer, sizeof(buffer), "/"); sncat(buffer, sizeof(buffer), video_driver_vector_pos(i)->name); } } draw_text_left(x + dx - strlen(buffer), by1, strlen(buffer), buffer, COLOR_BAR); snprintf(buffer, sizeof(buffer), " # x y pclock hclock vclock name"); draw_text_left(x, by1+2, dx, buffer, COLOR_TITLE); snprintf(buffer, sizeof(buffer), " F1 Help F2 Save SPACE Select TAB Rename ENTER Test ESC Exit"); draw_text_left(x, by2, dx, buffer, COLOR_BAR); }
int osd_get_path_info(int pathtype, int pathindex, const char* filename) { struct fileio_item* i; char path_buffer[FILE_MAXPATH]; struct stat st; log_std(("osd: osd_get_path_info(pathtype:%d,pathindex:%d,filename:%s)\n", pathtype, pathindex, filename)); i = fileio_find(pathtype); if (!i) { log_std(("WARNING:fileio: file type %d unknown\n", pathtype)); return PATH_NOT_FOUND; } sncpy(path_buffer, sizeof(path_buffer), file_abs(i->dir_map[pathindex], filename)); log_std(("osd: osd_get_path_info() try %s\n", path_buffer)); if (stat(path_buffer, &st) != 0) { log_std(("osd: osd_get_path_info() -> failed\n")); return PATH_NOT_FOUND; } if (S_ISDIR(st.st_mode)) { log_std(("osd: osd_get_path_info() -> directory\n")); return PATH_IS_DIRECTORY; } if (S_ISREG(st.st_mode)) { log_std(("osd: osd_get_path_info() -> file\n")); return PATH_IS_FILE; } log_std(("osd: osd_get_path_info() -> failed\n")); return PATH_NOT_FOUND; }
adv_error vgaline_mode_import(adv_mode* mode, const vgaline_video_mode* vgaline_mode) { sncpy(mode->name, MODE_NAME_MAX, vgaline_mode->crtc.name); *DRIVER(mode) = *vgaline_mode; /* adjust the pixel clock to an acceptable value */ DRIVER(mode)->crtc.pixelclock = vga_pixelclock_nearest_get(DRIVER(mode)->crtc.pixelclock, DRIVER(mode)->is_text); mode->driver = &video_vgaline_driver; mode->flags = MODE_FLAGS_RETRACE_WAIT_SYNC | MODE_FLAGS_RETRACE_SET_ASYNC | (mode->flags & MODE_FLAGS_USER_MASK); if (DRIVER(mode)->is_text) { mode->flags |= MODE_FLAGS_INDEX_TEXT; } else { mode->flags |= MODE_FLAGS_INDEX_PALETTE8; if (DRIVER(mode)->crtc.vde * DRIVER(mode)->crtc.hde > 0x10000) return -1; } mode->size_x = DRIVER(mode)->crtc.hde; mode->size_y = DRIVER(mode)->crtc.vde; mode->vclock = crtc_vclock_get(&DRIVER(mode)->crtc); mode->hclock = crtc_hclock_get(&DRIVER(mode)->crtc); mode->scan = crtc_scan_get(&DRIVER(mode)->crtc); return 0; }
void advance_ui_osd(struct advance_ui_context* context, const char* text, int val, int def, int min, int max) { context->state.ui_osd_flag = 1; context->state.ui_osd_value = val; context->state.ui_osd_def = val; context->state.ui_osd_min = min; context->state.ui_osd_max = max; sncpy(context->state.ui_osd_buffer, sizeof(context->state.ui_osd_buffer), text); }
static adv_error cmd_mode_clock(void) { adv_crtc* crtc; char buffer[80]; double freq = 0; int i = menu_base + menu_rel; if (i >= menu_max) return 0; crtc = crtc_container_pos(&the_modes, i); sncpy(buffer, sizeof(buffer), ""); switch (cmd_input_key(" Set Vertical/Horizontal/Pixel clock ? ", "vhp")) { case 0 : if (cmd_input_string(" Vertical clock [Hz] (example 60.0) : ", buffer, 10)!=0) return 0; freq = strtod(buffer, 0); if (freq < 10 || freq > 200) { error_set("Invalid vertical clock value, usually in the range 10 - 200.0 [Hz]"); return -1; } crtc->pixelclock = freq * crtc->ht * crtc->vt; if (crtc_is_interlace(crtc)) crtc->pixelclock /= 2; if (crtc_is_doublescan(crtc)) crtc->pixelclock *= 2; break; case 1 : if (cmd_input_string(" Horizontal clock [kHz] (example 31.5) : ", buffer, 10)!=0) return 0; freq = strtod(buffer, 0) * 1E3; if (freq < 10*1E3 || freq > 100*1E3) { error_set("Invalid horizontal clock value, usually in the range 15.0 - 80.0 [kHz]"); return -1; } crtc->pixelclock = freq * crtc->ht; break; case 2 : if (cmd_input_string(" Pixel clock [MHz] (example 14.0) : ", buffer, 10)!=0) return 0; freq = strtod(buffer, 0) * 1E6; if (freq < 1*1E6 || freq > 300*1E6) { error_set("Invalid pixel clock value, usually in the range 1.0 - 300.0 [MHz]"); return -1; } crtc->pixelclock = freq; break; default: return 0; } menu_modify(); return 0; }
adv_error advance_ui_config_load(struct advance_ui_context* context, adv_conf* cfg_context, struct mame_option* option) { const char* s; char* e; context->config.ui_speedmark_flag = conf_bool_get_default(cfg_context, "debug_speedmark"); sncpy(context->config.help_image_buffer, sizeof(context->config.help_image_buffer), conf_string_get_default(cfg_context, "ui_helpimage")); sncpy(context->config.ui_font_buffer, sizeof(context->config.ui_font_buffer), conf_string_get_default(cfg_context, "ui_font")); context->config.ui_translucency = conf_float_get_default(cfg_context, "ui_translucency") * 255; if (context->config.ui_translucency > 255) context->config.ui_translucency = 255; s = conf_string_get_default(cfg_context, "ui_fontsize"); context->config.ui_font_sizey = strtol(s, &e, 10); while (*e && isspace(*e)) ++e; if (*e) { context->config.ui_font_sizex = strtol(e, &e, 10); } else { context->config.ui_font_sizex = 0; } context->config.ui_font_orientation = option->direct_orientation; if (ui_color_load(context, cfg_context, UI_COLOR_INTERFACE_F, UI_COLOR_INTERFACE_B, "ui_color[interface]") != 0 || ui_color_load(context, cfg_context, UI_COLOR_TAG_F, UI_COLOR_TAG_B, "ui_color[tag]") != 0 || ui_color_load(context, cfg_context, UI_COLOR_SELECT_F, UI_COLOR_SELECT_B, "ui_color[select]") != 0 || ui_color_load(context, cfg_context, -1, UI_COLOR_HELP_P1, "ui_color[help_p1]") != 0 || ui_color_load(context, cfg_context, -1, UI_COLOR_HELP_P2, "ui_color[help_p2]") != 0 || ui_color_load(context, cfg_context, -1, UI_COLOR_HELP_P3, "ui_color[help_p3]") != 0 || ui_color_load(context, cfg_context, -1, UI_COLOR_HELP_P4, "ui_color[help_p4]") != 0 || ui_color_load(context, cfg_context, -1, UI_COLOR_HELP_OTHER, "ui_color[help_other]") != 0) return -1; return 0; }
adv_error mouseb_raw_load(adv_conf* context) { unsigned i; for (i = 0; i < RAW_MOUSE_MAX; ++i) { char buf[64]; const char* s; snprintf(buf, sizeof(buf), "device_raw_mousetype[%d]", i); raw_state.map[i].context.type = conf_int_get_default(context, buf); snprintf(buf, sizeof(buf), "device_raw_mousedev[%d]", i); s = conf_string_get_default(context, buf); if (strcmp(s, "auto") == 0) { if (i == 0 && access("/dev/mouse", F_OK) == 0) { sncpy(raw_state.map[i].context.dev, sizeof(raw_state.map[i].context.dev), "/dev/mouse"); if (raw_state.map[i].context.type < 0) raw_state.map[i].context.type = MOUSE_PNP; } else { snprintf(raw_state.map[i].context.dev, sizeof(raw_state.map[i].context.dev), "/dev/input/mouse%d", i); switch (raw_state.map[i].context.type) { case MOUSE_PS2: case MOUSE_IMPS2: case MOUSE_EXPPS2: /* the /dev/input/mouse interfaces is compatible only with these three protocols */ break; default: raw_state.map[i].context.type = MOUSE_IMPS2; break; } } } else { sncpy(raw_state.map[i].context.dev, sizeof(raw_state.map[i].context.dev), s); if (raw_state.map[i].context.type < 0) raw_state.map[i].context.type = MOUSE_PNP; } } return 0; }
void advance_ui_menu_title_insert(struct ui_menu* menu, const char* title) { struct ui_menu_entry* entry = &menu->map[menu->mac]; assert(menu->mac < menu->max); if (menu->mac == menu->max) return; entry->type = ui_menu_title; sncpy(entry->text_buffer, sizeof(entry->text_buffer), title); ++menu->mac; }
int osd_dir_get_entry(void* void_h, char* name, int namelength, int* is_dir) { struct dirio_handle* h = (struct dirio_handle*)void_h; struct dirent* d; d = readdir(h->h); while (d) { char file_buffer[FILE_MAXPATH]; struct stat st; snprintf(file_buffer, sizeof(file_buffer), "%s/%s", h->dir, d->d_name); /* on any error ignore the file */ if (stat(file_buffer, &st) == 0) { if (S_ISDIR(st.st_mode)) { if (namelength >= strlen(d->d_name) + 1) { *is_dir = 1; sncpy(name, namelength, d->d_name); log_std(("osd: osd_dir_get_entry() -> %s\n", name)); return strlen(name); } } else if (match(d->d_name, h->pattern)) { if (namelength >= strlen(d->d_name) + 1) { *is_dir = 0; sncpy(name, namelength, d->d_name); log_std(("osd: osd_dir_get_entry() -> %s\n", name)); return strlen(name); } } } d = readdir(h->h); } return 0; }
static adv_error sound_start(struct advance_record_context* context, const char* file, double frequency, int stereo) { unsigned* f; if (context->state.sound_active_flag) return -1; /* adjust the frequency to match the MP3 standard */ f = SOUND_FREQUENCY_MAP; while (*f) { double v = *f; v /= frequency; if (v > 1) v = 1 / v; v = 1 - v; if (v<SOUND_FREQUENCY_ERROR) { context->state.sound_frequency = *f; break; } ++f; } if (!*f) context->state.sound_frequency = frequency; context->state.sound_stereo_flag = stereo; context->state.sound_sample_counter = 0; context->state.sound_sample_size = 2; if (stereo) context->state.sound_sample_size *= 2; context->state.sound_stopped_flag = 0; sncpy(context->state.sound_file_buffer, sizeof(context->state.sound_file_buffer), file); context->state.sound_f = fopen(context->state.sound_file_buffer, "wb"); if (!context->state.sound_f) { log_std(("ERROR: opening file %s\n", context->state.sound_file_buffer)); return -1; } if (wave_write(context->state.sound_f, context->state.sound_stereo_flag ? 2 : 1, 16, 0, context->state.sound_frequency) != 0) { log_std(("ERROR: writing file %s\n", context->state.sound_file_buffer)); fclose(context->state.sound_f); remove(context->state.sound_file_buffer); return -1; } context->state.sound_active_flag = 1; return 0; }
int joystickb_sdl_device_desc_get(unsigned joystick, char* desc) { #if SDL_MAJOR_VERSION == 1 const char* joy_name = SDL_JoystickName(joystick); if (!joy_name) return -1; log_std(("joystickb:sdl: desc:\"%s\"\n", joy_name)); sncpy(desc, DEVICE_NAME_MAX, joy_name); #else const char* joy_name = SDL_JoystickName(sdl_state.map[joystick]); if (!joy_name) return -1; log_std(("joystickb:sdl: desc:\"%s\"\n", joy_name)); sncpy(desc, DEVICE_NAME_MAX, joy_name); #endif return 0; }
/** * Check if a adv_device name match the user specification. * \param tag user specification. * \param drv adv_device to check. * \param allow_none if true allows the "none" driver also if it * isn't specified. Otherwise the "none" driver is used only if explictly * specified. It isn't used from "auto". */ const adv_device* device_match(const char* tag, const adv_driver* drv, adv_bool allow_none) { char buffer[DEVICE_NAME_MAX]; const char* tag_one; sncpy(buffer, sizeof(buffer), tag); tag_one = strtok(buffer, " \t"); while (tag_one) { const adv_device* dev = device_match_one(tag_one, drv, allow_none); if (dev) return dev; tag_one = strtok(NULL, " \t"); } return 0; }
static void cmd_rename(void) { adv_crtc* crtc; char buffer[128]; crtc = menu_current(); if (!crtc) return; sncpy(buffer, sizeof(buffer), ""); if (cmd_input_string(" Name : ", buffer, MODE_NAME_MAX)!=0) return; crtc_name_set(crtc, buffer); menu_modify(); }
adv_error fb_mode_import(adv_mode* mode, const fb_video_mode* fb_mode) { sncpy(mode->name, MODE_NAME_MAX, fb_mode->crtc.name); *DRIVER(mode) = *fb_mode; mode->driver = &video_fb_driver; mode->flags = MODE_FLAGS_RETRACE_WAIT_SYNC | MODE_FLAGS_RETRACE_SET_ASYNC | (mode->flags & MODE_FLAGS_USER_MASK) | fb_mode->index; mode->size_x = DRIVER(mode)->crtc.hde; mode->size_y = DRIVER(mode)->crtc.vde; mode->vclock = crtc_vclock_get(&DRIVER(mode)->crtc); mode->hclock = crtc_hclock_get(&DRIVER(mode)->crtc); mode->scan = crtc_scan_get(&DRIVER(mode)->crtc); return 0; }
adv_error advance_fileio_config_load(struct advance_fileio_context* context, adv_conf* cfg_context, struct mame_option* option) { struct fileio_item* i; for(i=FILEIO_CONFIG;i->type != FILETYPE_end;++i) { /* free a previously loaded value */ path_free(i->dir_map, i->dir_mac); i->dir_map = 0; i->dir_mac = 0; if (i->config) { unsigned j; const char* s = conf_string_get_default(cfg_context, i->config); const char* a; switch (i->mode) { case FILEIO_MODE_MULTI : a = file_config_list(s, file_config_dir_multidir, 0); break; case FILEIO_MODE_SINGLE : a = file_config_list(s, file_config_dir_singledir, 0); break; default: a = s; break; } log_std(("advance:fileio: %s %s\n", i->config, a)); path_allocate(&i->dir_map, &i->dir_mac, a); for(j=0;j<i->dir_mac;++j) dir_create(i->dir_map[j]); } else { /* add the standard directories search as default */ path_allocate(&i->dir_map, &i->dir_mac, file_config_dir_singlefile()); } } #ifdef MESS { const char* s = conf_string_get_default(cfg_context, "dir_crc"); const char* a = file_config_list(s, file_config_dir_singledir, 0); log_std(("advance:fileio: %s %s\n", "dir_crc", a)); sncpy(option->crc_dir_buffer, sizeof(option->crc_dir_buffer), a); } #endif return 0; }
static const adv_device* device_match_one(const char* tag, const adv_driver* drv, adv_bool allow_none) { char tag_driver[DEVICE_NAME_MAX]; char* tag_device; const adv_device* i; sncpy(tag_driver, DEVICE_NAME_MAX, tag); tag_device = strchr(tag_driver, '/'); if (tag_device) { *tag_device = 0; ++tag_device; } else { tag_device = "auto"; } if (strcmp(drv->name, "none")==0) { if (allow_none || strcmp(tag_driver, "none")==0) { assert(drv->device_map->name != 0); return drv->device_map; } else { return 0; /* "auto" never choose "none" */ } } if (strcmp(tag_driver, "auto")!=0 && strcmp(tag_driver, drv->name)!=0) return 0; i = drv->device_map; while (i->name) { if (strcmp(i->name, tag_device)==0) break; ++i; } if (!i->name) return 0; return i; }
static adv_error none_mode_import(adv_mode* mode, const none_video_mode* none_mode) { sncpy(mode->name, MODE_NAME_MAX, none_mode->crtc.name); *DRIVER(mode) = *none_mode; mode->driver = &video_none_driver; mode->flags = (mode->flags & MODE_FLAGS_USER_MASK) | none_mode->index; mode->size_x = DRIVER(mode)->crtc.hde; mode->size_y = DRIVER(mode)->crtc.vde; mode->vclock = crtc_vclock_get(&DRIVER(mode)->crtc); mode->hclock = crtc_hclock_get(&DRIVER(mode)->crtc); if (crtc_is_doublescan(&none_mode->crtc)) mode->scan = 1; else if (crtc_is_interlace(&none_mode->crtc)) mode->scan = -1; else mode->scan = 0; return 0; }
int osd_create_directory(int pathtype, int pathindex, const char *dirname) { struct fileio_item* i; char path_buffer[FILE_MAXPATH]; log_std(("osd: osd_create_directory(pathtype:%d,pathindex:%d,dirname:%s)\n", pathtype, pathindex, dirname)); i = fileio_find(pathtype); if (!i) { log_std(("WARNING:fileio: file type %d unknown\n", pathtype)); return -1; } sncpy(path_buffer, sizeof(path_buffer), file_abs(i->dir_map[pathindex], dirname)); log_std(("osd: osd_create_directory() -> %s\n", path_buffer)); if (file_dir_make(path_buffer) != 0) { log_std(("ERROR:fileio: mkdir(%s) failed\n", path_buffer)); return -1; } return 0; }
void advance_ui_direct_text(struct advance_ui_context* context, const char* text) { context->state.ui_direct_text_flag = 1; sncpy(context->state.ui_direct_buffer, sizeof(context->state.ui_direct_buffer), text); }
int osd2_audio_menu(int selected, unsigned input) { struct advance_video_context* video_context = &CONTEXT.video; struct advance_sound_context* sound_context = &CONTEXT.sound; struct advance_global_context* global_context = &CONTEXT.global; struct advance_ui_context* ui_context = &CONTEXT.ui; struct ui_menu menu; unsigned mac; int mode_index; int adjust_index; int volume_index; int normalize_index; int eql_index; int eqm_index; int eqh_index; int save_game_index; int pipeline_index; int exit_index; char buffer[128]; const char* text = 0; const char* option = 0; /* the menu data is not duplicated for the thread, so we have to wait for its completion */ advance_video_thread_wait(video_context); if (selected >= 1) selected = selected - 1; else selected = 0; if (sound_context->state.menu_sub_flag) { int ret = 0; switch (sound_context->state.menu_sub_flag) { case 1: ret = audio_pipeline_menu(sound_context, ui_context, sound_context->state.menu_sub_selected, input); break; } switch (ret) { case -1: return -1; /* hide interface */ case 0: sound_context->state.menu_sub_flag = 0; sound_context->state.menu_sub_selected = 1; break; /* close submenu */ default: sound_context->state.menu_sub_selected = ret; break; } return selected + 1; } advance_ui_menu_init(&menu); advance_ui_menu_title_insert(&menu, "Audio Menu"); switch (sound_context->state.output_mode) { case SOUND_MODE_MONO: text = "Mode [mono]"; break; case SOUND_MODE_STEREO: text = "Mode [stereo]"; break; case SOUND_MODE_SURROUND: text = "Mode [surround]"; break; } switch (sound_context->config.mode) { case SOUND_MODE_AUTO: option = "auto"; break; case SOUND_MODE_MONO: option = "mono"; break; case SOUND_MODE_STEREO: option = "stereo"; break; case SOUND_MODE_SURROUND: option = "surround"; break; } mode_index = advance_ui_menu_option_insert(&menu, text, option); if (sound_context->config.attenuation > -40) snprintf(buffer, sizeof(buffer), "%d", sound_context->config.attenuation); else sncpy(buffer, sizeof(buffer), "mute"); volume_index = advance_ui_menu_option_insert(&menu, "Attenuation (dB)", buffer); advance_ui_menu_title_insert(&menu, "Normalize"); if (sound_context->config.normalize_flag) option = "yes"; else option = "no"; normalize_index = advance_ui_menu_option_insert(&menu, "Auto normalize", option); snprintf(buffer, sizeof(buffer), "%d", sound_context->config.adjust); adjust_index = advance_ui_menu_option_insert(&menu, "Amplifier (dB)", buffer); advance_ui_menu_title_insert(&menu, "Equalizer"); if (sound_context->config.equalizer_low > -40) snprintf(buffer, sizeof(buffer), "%d", sound_context->config.equalizer_low); else sncpy(buffer, sizeof(buffer), "mute"); eql_index = advance_ui_menu_option_insert(&menu, "Low Freq (dB)", buffer); if (sound_context->config.equalizer_mid > -40) snprintf(buffer, sizeof(buffer), "%d", sound_context->config.equalizer_mid); else sncpy(buffer, sizeof(buffer), "mute"); eqm_index = advance_ui_menu_option_insert(&menu, "Mid Freq (dB)", buffer); if (sound_context->config.equalizer_high > -40) snprintf(buffer, sizeof(buffer), "%d", sound_context->config.equalizer_high); else sncpy(buffer, sizeof(buffer), "mute"); eqh_index = advance_ui_menu_option_insert(&menu, "High Freq (dB)", buffer); pipeline_index = advance_ui_menu_text_insert(&menu, "Details..."); if (global_context->state.is_config_writable) { save_game_index = advance_ui_menu_text_insert(&menu, "Save for this game"); } else { save_game_index = -1; } exit_index = advance_ui_menu_text_insert(&menu, "Return to Main Menu"); mac = advance_ui_menu_done(&menu, ui_context, selected); if (input == OSD_INPUT_DOWN) { selected = (selected + 1) % mac; } if (input == OSD_INPUT_UP) { selected = (selected + mac - 1) % mac; } if (input == OSD_INPUT_SELECT) { if (selected == exit_index) { selected = -1; } else if (selected == pipeline_index) { sound_context->state.menu_sub_flag = 1; } else if (selected == save_game_index) { advance_sound_config_save(sound_context, video_context->config.section_name_buffer); } } if (input == OSD_INPUT_RIGHT) { if (selected == volume_index) { struct advance_sound_config_context config = sound_context->config; config.attenuation = sound_context->config.attenuation + 1; advance_sound_reconfigure(sound_context, &config); } else if (selected == adjust_index) { struct advance_sound_config_context config = sound_context->config; config.adjust = sound_context->config.adjust + 1; advance_sound_reconfigure(sound_context, &config); } else if (selected == normalize_index) { struct advance_sound_config_context config = sound_context->config; config.normalize_flag = !sound_context->config.normalize_flag; advance_sound_reconfigure(sound_context, &config); } else if (selected == mode_index) { struct advance_sound_config_context config = sound_context->config; switch (config.mode) { case SOUND_MODE_AUTO: config.mode = SOUND_MODE_MONO; break; case SOUND_MODE_MONO: config.mode = SOUND_MODE_STEREO; break; case SOUND_MODE_STEREO: config.mode = SOUND_MODE_SURROUND; break; case SOUND_MODE_SURROUND: config.mode = SOUND_MODE_AUTO; break; } advance_sound_reconfigure(sound_context, &config); } else if (selected == eql_index) { struct advance_sound_config_context config = sound_context->config; config.equalizer_low = sound_context->config.equalizer_low + 2; advance_sound_reconfigure(sound_context, &config); } else if (selected == eqm_index) { struct advance_sound_config_context config = sound_context->config; config.equalizer_mid = sound_context->config.equalizer_mid + 2; advance_sound_reconfigure(sound_context, &config); } else if (selected == eqh_index) { struct advance_sound_config_context config = sound_context->config; config.equalizer_high = sound_context->config.equalizer_high + 2; advance_sound_reconfigure(sound_context, &config); } } if (input == OSD_INPUT_LEFT) { if (selected == volume_index) { struct advance_sound_config_context config = sound_context->config; config.attenuation = sound_context->config.attenuation - 1; advance_sound_reconfigure(sound_context, &config); } else if (selected == adjust_index) { struct advance_sound_config_context config = sound_context->config; config.adjust = sound_context->config.adjust - 1; advance_sound_reconfigure(sound_context, &config); } else if (selected == normalize_index) { struct advance_sound_config_context config = sound_context->config; config.normalize_flag = !sound_context->config.normalize_flag; advance_sound_reconfigure(sound_context, &config); } else if (selected == mode_index) { struct advance_sound_config_context config = sound_context->config; switch (config.mode) { case SOUND_MODE_AUTO: config.mode = SOUND_MODE_SURROUND; break; case SOUND_MODE_MONO: config.mode = SOUND_MODE_AUTO; break; case SOUND_MODE_STEREO: config.mode = SOUND_MODE_MONO; break; case SOUND_MODE_SURROUND: config.mode = SOUND_MODE_STEREO; break; } advance_sound_reconfigure(sound_context, &config); } else if (selected == eql_index) { struct advance_sound_config_context config = sound_context->config; config.equalizer_low = sound_context->config.equalizer_low - 2; advance_sound_reconfigure(sound_context, &config); } else if (selected == eqm_index) { struct advance_sound_config_context config = sound_context->config; config.equalizer_mid = sound_context->config.equalizer_mid - 2; advance_sound_reconfigure(sound_context, &config); } else if (selected == eqh_index) { struct advance_sound_config_context config = sound_context->config; config.equalizer_high = sound_context->config.equalizer_high - 2; advance_sound_reconfigure(sound_context, &config); } } if (input == OSD_INPUT_CANCEL) selected = -1; if (input == OSD_INPUT_CONFIGURE) selected = -2; return selected + 1; }