void ucon64_rom_nfo (const st_rominfo_t *rominfo) { unsigned int padded = ucon64_testpad (ucon64.rom), intro = ((ucon64.file_size - rominfo->buheader_len) > MBIT) ? ((ucon64.file_size - rominfo->buheader_len) % MBIT) : 0; int x, split = (UCON64_ISSET (ucon64.split)) ? ucon64.split : ucon64_testsplit (ucon64.rom); char buf[MAXBUFSIZE]; // backup unit header if (rominfo->buheader && rominfo->buheader_len && rominfo->buheader_len != UNKNOWN_HEADER_LEN) { dumper (stdout, rominfo->buheader, rominfo->buheader_len, rominfo->buheader_start, DUMPER_HEX); fputc ('\n', stdout); } else if (rominfo->buheader_len && ucon64.quiet < 0) { ucon64_dump (stdout, ucon64.rom, rominfo->buheader_start, rominfo->buheader_len, DUMPER_HEX); fputc ('\n', stdout); } // backup unit type? if (rominfo->copier_usage != NULL) { puts (rominfo->copier_usage); fputc ('\n', stdout); } // ROM header if (rominfo->header && rominfo->header_len) { dumper (stdout, rominfo->header, rominfo->header_len, rominfo->header_start + rominfo->buheader_len, DUMPER_HEX); fputc ('\n', stdout); } // console type if (rominfo->console_usage != NULL) puts (rominfo->console_usage); // name, maker, country and size strcpy (buf, NULL_TO_EMPTY (rominfo->name)); x = UCON64_ISSET (rominfo->data_size) ? rominfo->data_size : ucon64.file_size - rominfo->buheader_len; printf ("%s\n%s\n%s\n%d Bytes (%.4f Mb)\n\n", // some ROMs have a name with control chars in it -> replace control chars to_func (buf, strlen (buf), toprint), NULL_TO_EMPTY (rominfo->maker), NULL_TO_EMPTY (rominfo->country), x, TOMBIT_F (x)); // padded? if (!padded) puts ("Padded: No"); else printf ("Padded: Maybe, %d Bytes (%.4f Mb)\n", padded, TOMBIT_F (padded)); // intro, trainer? // nes.c determines itself whether or not there is a trainer if (intro && ucon64.console != UCON64_NES) printf ("Intro/Trainer: Maybe, %d Bytes\n", intro); // interleaved? if (rominfo->interleaved != UCON64_UNKNOWN) // printing this is handy for SNES, N64 & Genesis ROMs, but maybe // nonsense for others printf ("Interleaved/Swapped: %s\n", rominfo->interleaved ? (rominfo->interleaved > 1 ? "Yes (2)" : "Yes") : "No"); // backup unit header? if (rominfo->buheader_len) printf ("Backup unit/emulator header: Yes, %d Bytes\n", rominfo->buheader_len); else // for NoisyB: <read only mode ON> puts ("Backup unit/emulator header: No"); // printing No is handy for SNES ROMs // for NoisyB: <read only mode OFF> // split? if (split) { printf ("Split: Yes, %d part%s\n", split, (split != 1) ? "s" : ""); // nes.c calculates the correct checksum for split ROMs (=Pasofami // format), so there is no need to join the files if (ucon64.console != UCON64_NES) puts ("NOTE: To get the correct checksum the ROM parts must be joined"); } // miscellaneous info if (rominfo->misc[0]) { strcpy (buf, rominfo->misc); printf ("%s\n", to_func (buf, strlen (buf), toprint)); } // internal checksums? if (rominfo->has_internal_crc) { char *fstr; // the internal checksum of GBA ROMS stores only the checksum of the // internal header if (ucon64.console != UCON64_GBA) fstr = "Checksum: %%s, 0x%%0%dlx (calculated) %%c= 0x%%0%dlx (internal)\n"; else fstr = "Header checksum: %%s, 0x%%0%dlx (calculated) %%c= 0x%%0%dlx (internal)\n"; sprintf (buf, fstr, rominfo->internal_crc_len * 2, rominfo->internal_crc_len * 2); #ifdef USE_ANSI_COLOR printf (buf, ucon64.ansi_color ? ((rominfo->current_internal_crc == rominfo->internal_crc) ? "\x1b[01;32mOk\x1b[0m" : "\x1b[01;31mBad\x1b[0m") : ((rominfo->current_internal_crc == rominfo->internal_crc) ? "Ok" : "Bad"), rominfo->current_internal_crc, (rominfo->current_internal_crc == rominfo->internal_crc) ? '=' : '!', rominfo->internal_crc); #else printf (buf, (rominfo->current_internal_crc == rominfo->internal_crc) ? "Ok" : "Bad", rominfo->current_internal_crc, (rominfo->current_internal_crc == rominfo->internal_crc) ? '=' : '!', rominfo->internal_crc); #endif if (rominfo->internal_crc2[0]) printf ("%s\n", rominfo->internal_crc2); } fflush (stdout); }
int ucon64_rom_handling (void) { int no_rom = 0; static st_rominfo_t rominfo; struct stat fstate; ucon64_rom_flush (&rominfo); // a ROM (file)? if (!ucon64.rom) no_rom = 1; else if (!ucon64.rom[0]) no_rom = 1; else if (access (ucon64.rom, F_OK | R_OK) == -1 && (!(ucon64.flags & WF_NO_ROM))) { fprintf (stderr, "ERROR: Could not open %s\n", ucon64.rom); no_rom = 1; } else if (stat (ucon64.rom, &fstate) == -1) no_rom = 1; else if (S_ISREG (fstate.st_mode) != TRUE) no_rom = 1; #if 0 // printing the no_rom error message for files of 0 bytes only confuses people else if (!fstate.st_size) no_rom = 1; #endif if (no_rom) { if (!(ucon64.flags & WF_NO_ROM)) { fputs ("ERROR: This option requires a file argument (ROM/image/SRAM file/directory)\n", stderr); return -1; } return 0; } // The next statement is important and should be executed as soon as // possible (and sensible) in this function ucon64.file_size = fsizeof (ucon64.rom); // We have to do this here, because we don't know the file size until now if (ucon64.buheader_len > ucon64.file_size) { fprintf (stderr, "ERROR: A backup unit header length was specified that is larger than the file\n" " size (%d > %d)\n", ucon64.buheader_len, ucon64.file_size); return -1; } if (!(ucon64.flags & WF_INIT)) return 0; // "walk through" <console>_init() if (ucon64.flags & WF_PROBE) { if (ucon64.rominfo) { // Restore any overrides from st_ucon64_t // We have to do this *before* calling ucon64_probe(), *not* afterwards if (UCON64_ISSET (ucon64.buheader_len)) rominfo.buheader_len = ucon64.buheader_len; if (UCON64_ISSET (ucon64.interleaved)) rominfo.interleaved = ucon64.interleaved; // ucon64.rominfo = (st_rominfo_t *) &rominfo; } ucon64.rominfo = ucon64_probe (&rominfo); // determines console type #ifdef USE_DISCMAGE // check for disc image only if ucon64_probe() failed or --disc was used if (ucon64.discmage_enabled) // if (!ucon64.rominfo || ucon64.force_disc) if (ucon64.force_disc) ucon64.image = dm_reopen (ucon64.rom, 0, (dm_image_t *) ucon64.image); #endif } // end of WF_PROBE // Does the option allow split ROMs? if (ucon64.flags & WF_NO_SPLIT) /* Test for split files only if the console type knows about split files at all. However we only know the console type after probing. */ if (ucon64.console == UCON64_NES || ucon64.console == UCON64_SNES || ucon64.console == UCON64_GEN || ucon64.console == UCON64_NG) if ((UCON64_ISSET (ucon64.split)) ? ucon64.split : ucon64_testsplit (ucon64.rom)) { fprintf (stderr, "ERROR: %s seems to be split. You have to join it first\n", basename2 (ucon64.rom)); return -1; } /* CRC32 Calculating the CRC32 checksum for the ROM data of a UNIF file (NES) shouldn't be done with ucon64_fcrc32(). nes_init() uses crc32(). The CRC32 checksum is used to search in the DAT files, but at the time of this writing (Februari the 7th 2003) all DAT files contain checksums of files in only one format. This matters for SNES and Genesis ROMs in interleaved format and Nintendo 64 ROMs in non-interleaved format. The corresponding initialization functions calculate the CRC32 checksum of the data in the format of which the checksum is stored in the DAT files. For these "problematic" files, their "real" checksum is stored in ucon64.fcrc32. */ if (ucon64.crc32 == 0) if (!ucon64.force_disc) // NOT for disc images if (!(ucon64.flags & WF_NO_CRC32) && ucon64.file_size <= MAXROMSIZE) ucon64_chksum (NULL, NULL, &ucon64.crc32, ucon64.rom, ucon64.rominfo ? ucon64.rominfo->buheader_len : 0); // DATabase ucon64.dat = NULL; if (ucon64.crc32 != 0 && ucon64.dat_enabled) { ucon64.dat = ucon64_dat_search (ucon64.crc32, NULL); if (ucon64.dat) { // detected file size must match DAT file size int size = ucon64.rominfo ? UCON64_ISSET (ucon64.rominfo->data_size) ? ucon64.rominfo->data_size : ucon64.file_size - ucon64.rominfo->buheader_len : ucon64.file_size; if ((int) (((st_ucon64_dat_t *) ucon64.dat)->fsize) != size) ucon64.dat = NULL; } if (ucon64.dat) switch (ucon64.console) { case UCON64_SNES: case UCON64_GEN: case UCON64_GB: case UCON64_GBA: case UCON64_N64: // These ROMs have internal headers with name, country, maker, etc. break; default: // Use ucon64.dat instead of ucon64.dat_enabled in case the index // file could not be created/opened -> no segmentation fault if (ucon64.dat && ucon64.rominfo) { if (!ucon64.rominfo->name[0]) strcpy (ucon64.rominfo->name, NULL_TO_EMPTY (((st_ucon64_dat_t *) ucon64.dat)->name)); else if (ucon64.console == UCON64_NES) { // override the three-character FDS or FAM name int t = nes_get_file_type (); if (t == FDS || t == FAM) strcpy (ucon64.rominfo->name, NULL_TO_EMPTY (((st_ucon64_dat_t *) ucon64.dat)->name)); } if (!ucon64.rominfo->country) ucon64.rominfo->country = NULL_TO_EMPTY (((st_ucon64_dat_t *) ucon64.dat)->country); } break; } } // display info if ((ucon64.flags & WF_NFO || ucon64.flags & WF_NFO_AFTER) && ucon64.quiet < 1) ucon64_nfo (); return 0; }
void print_glxinfo(const char *display_name) { int screen; CtrlHandles *h; CtrlHandleTarget *t; ReturnStatus status = NvCtrlSuccess; char *direct_rendering = NULL; char *glx_extensions = NULL; char *server_vendor = NULL; char *server_version = NULL; char *server_extensions = NULL; char *client_vendor = NULL; char *client_version = NULL; char *client_extensions = NULL; char *opengl_vendor = NULL; char *opengl_renderer = NULL; char *opengl_version = NULL; char *opengl_extensions = NULL; GLXFBConfigAttr *fbconfig_attribs = NULL; char *formated_ext_str = NULL; h = nv_alloc_ctrl_handles(display_name); if ( h == NULL ) { return; } /* Print information for each screen */ for (screen = 0; screen < h->targets[X_SCREEN_TARGET].n; screen++) { t = &h->targets[X_SCREEN_TARGET].t[screen]; /* No screen, move on */ if ( !t->h ) continue; nv_msg(NULL, "GLX Information for %s:", t->name); /* Get GLX information */ status = NvCtrlGetStringAttribute(t->h, NV_CTRL_STRING_GLX_DIRECT_RENDERING, &direct_rendering); if ( status != NvCtrlSuccess && status != NvCtrlNoAttribute ) { goto finish; } status = NvCtrlGetStringAttribute(t->h, NV_CTRL_STRING_GLX_GLX_EXTENSIONS, &glx_extensions); if ( status != NvCtrlSuccess && status != NvCtrlNoAttribute ) { goto finish; } if ( glx_extensions != NULL ) { formated_ext_str = format_extension_list(glx_extensions); if ( formated_ext_str != NULL ) { free(glx_extensions); glx_extensions = formated_ext_str; } } /* Get server GLX information */ status = NvCtrlGetStringAttribute(t->h, NV_CTRL_STRING_GLX_SERVER_VENDOR, &server_vendor); if ( status != NvCtrlSuccess && status != NvCtrlNoAttribute ) { goto finish; } status = NvCtrlGetStringAttribute(t->h, NV_CTRL_STRING_GLX_SERVER_VERSION, &server_version); if ( status != NvCtrlSuccess && status != NvCtrlNoAttribute ) { goto finish; } status = NvCtrlGetStringAttribute(t->h, NV_CTRL_STRING_GLX_SERVER_EXTENSIONS, &server_extensions); if ( status != NvCtrlSuccess && status != NvCtrlNoAttribute ) { goto finish; } if ( server_extensions != NULL ) { formated_ext_str = format_extension_list(server_extensions); if ( formated_ext_str != NULL ) { free(server_extensions); server_extensions = formated_ext_str; } } /* Get client GLX information */ status = NvCtrlGetStringAttribute(t->h, NV_CTRL_STRING_GLX_CLIENT_VENDOR, &client_vendor); if ( status != NvCtrlSuccess && status != NvCtrlNoAttribute ) { goto finish; } status = NvCtrlGetStringAttribute(t->h, NV_CTRL_STRING_GLX_CLIENT_VERSION, &client_version); if ( status != NvCtrlSuccess && status != NvCtrlNoAttribute ) { goto finish; } status = NvCtrlGetStringAttribute(t->h, NV_CTRL_STRING_GLX_CLIENT_EXTENSIONS, &client_extensions); if ( status != NvCtrlSuccess && status != NvCtrlNoAttribute ) { goto finish; } if ( client_extensions != NULL ) { formated_ext_str = format_extension_list(client_extensions); if ( formated_ext_str != NULL ) { free(client_extensions); client_extensions = formated_ext_str; } } /* Get OpenGL information */ status = NvCtrlGetStringAttribute(t->h, NV_CTRL_STRING_GLX_OPENGL_VENDOR, &opengl_vendor); if ( status != NvCtrlSuccess && status != NvCtrlNoAttribute ) { goto finish; } status = NvCtrlGetStringAttribute(t->h, NV_CTRL_STRING_GLX_OPENGL_RENDERER, &opengl_renderer); if ( status != NvCtrlSuccess && status != NvCtrlNoAttribute ) { goto finish; } status = NvCtrlGetStringAttribute(t->h, NV_CTRL_STRING_GLX_OPENGL_VERSION, &opengl_version); if ( status != NvCtrlSuccess && status != NvCtrlNoAttribute ) { goto finish; } status = NvCtrlGetStringAttribute(t->h, NV_CTRL_STRING_GLX_OPENGL_EXTENSIONS, &opengl_extensions); if ( status != NvCtrlSuccess && status != NvCtrlNoAttribute ) { goto finish; } if ( opengl_extensions != NULL ) { formated_ext_str = format_extension_list(opengl_extensions); if ( formated_ext_str != NULL ) { free(opengl_extensions); opengl_extensions = formated_ext_str; } } /* Get FBConfig information */ status = NvCtrlGetVoidAttribute(t->h, NV_CTRL_ATTR_GLX_FBCONFIG_ATTRIBS, (void *)(&fbconfig_attribs)); if ( status != NvCtrlSuccess && status != NvCtrlNoAttribute ) { goto finish; } /* Print results */ nv_msg(TAB, "direct rendering: %s", NULL_TO_EMPTY(direct_rendering)); nv_msg(TAB, "GLX extensions:"); nv_msg(" ", NULL_TO_EMPTY(glx_extensions)); nv_msg(" ", "\n"); nv_msg(TAB, "server glx vendor string: %s", NULL_TO_EMPTY(server_vendor)); nv_msg(TAB, "server glx version string: %s", NULL_TO_EMPTY(server_version)); nv_msg(TAB, "server glx extensions:"); nv_msg(" ", NULL_TO_EMPTY(server_extensions)); nv_msg(" ", "\n"); nv_msg(TAB, "client glx vendor string: %s", NULL_TO_EMPTY(client_vendor)); nv_msg(TAB, "client glx version string: %s", NULL_TO_EMPTY(client_version)); nv_msg(TAB, "client glx extensions:"); nv_msg(" ", NULL_TO_EMPTY(client_extensions)); nv_msg(" ", "\n"); nv_msg(TAB, "OpenGL vendor string: %s", NULL_TO_EMPTY(opengl_vendor)); nv_msg(TAB, "OpenGL renderer string: %s", NULL_TO_EMPTY(opengl_renderer)); nv_msg(TAB, "OpenGL version string: %s", NULL_TO_EMPTY(opengl_version)); nv_msg(TAB, "OpenGL extensions:"); nv_msg(" ", NULL_TO_EMPTY(opengl_extensions)); #ifdef GLX_VERSION_1_3 if ( fbconfig_attribs != NULL ) { nv_msg(" ", "\n"); print_fbconfig_attribs(fbconfig_attribs); } #endif fflush(stdout); /* Free memory used */ SAFE_FREE(server_vendor); SAFE_FREE(server_version); SAFE_FREE(server_extensions); SAFE_FREE(client_vendor); SAFE_FREE(client_version); SAFE_FREE(client_extensions); SAFE_FREE(direct_rendering); SAFE_FREE(glx_extensions); SAFE_FREE(opengl_vendor); SAFE_FREE(opengl_renderer); SAFE_FREE(opengl_version); SAFE_FREE(opengl_extensions); SAFE_FREE(fbconfig_attribs); } /* Done looking at all screens */ /* Fall through */ finish: if ( status == NvCtrlError ) { nv_error_msg("Error fetching GLX Information: %s", NvCtrlAttributesStrError(status) ); } /* Free any leftover memory used */ SAFE_FREE(server_vendor); SAFE_FREE(server_version); SAFE_FREE(server_extensions); SAFE_FREE(client_vendor); SAFE_FREE(client_version); SAFE_FREE(client_extensions); SAFE_FREE(direct_rendering); SAFE_FREE(glx_extensions); SAFE_FREE(opengl_vendor); SAFE_FREE(opengl_renderer); SAFE_FREE(opengl_version); SAFE_FREE(opengl_extensions); SAFE_FREE(fbconfig_attribs); nv_free_ctrl_handles(h); } /* print_glxinfo() */