static void compegps_data_write(void) { /* because of different file extensions we can only write one GPS data type at time */ gbfprintf(fout, "G WGS 84\n"); gbfprintf(fout, "U 1\n"); /* process options */ target_index = 1; if (option_index != NULL) target_index = atoi(option_index); snlen = 0; if (global_opts.synthesize_shortnames != 0) { if (option_snlen != NULL) snlen = atoi(option_snlen); else snlen = SHORT_NAME_LENGTH; is_fatal((snlen < 1), MYNAME "Invalid length for generated shortnames!"); setshort_whitespace_ok(sh, 0); setshort_length(sh, snlen); } radius = -1; if (option_radius != 0) { radius = atof(option_radius); is_fatal((radius <= 0.0), MYNAME "Invalid value for radius!"); } if (option_icon != NULL) { if (*option_icon == '\0') option_icon = NULL; else if (case_ignore_strcmp(option_icon, "deficon") == 0) option_icon = NULL; } switch(global_opts.objective) { case wptdata: curr_index = target_index = 0; write_waypoints(); break; case trkdata: write_track(); break; case rtedata: write_route(); break; case posndata: fatal(MYNAME ": Realtime positioning not supported.\n"); break; } }
bool UnformatImage (const std::string &path, Range range) { auto disk = std::make_shared<Disk>(); if (!ReadImage(path, disk)) return false; ValidateRange(range, MAX_TRACKS, MAX_SIDES, disk->cyls(), disk->heads()); range.each([&] (const CylHead &cylhead) { if (!g_fAbort) disk->write_track(cylhead, Track()); }); return WriteImage(path, disk); }
bool CreateImage (const std::string &path, Range range) { auto disk = std::make_shared<Disk>(); // Start with legacy default formats, with automatic gap 3 Format fmt = IsFileExt(path, "cpm") ? RegularFormat::ProDos : RegularFormat::MGT; fmt.gap3 = 0; // Allow everything about the format to be overridden, but check it fmt.Override(true); fmt.Validate(); ValidateRange(range, MAX_TRACKS, MAX_SIDES); // Set the disk label, if supplied if (!opt.label.empty()) disk->metadata["label"] = opt.label; // Extend or format the disk if (opt.noformat) disk->write_track(CylHead(range.cyl_end - 1, range.head_end - 1), Track()); else disk->format(fmt); // Write to the output disk image WriteImage(path, disk); // Report the new disk parameters, unless it's already been displayed (raw) if (!IsFileExt(path, "raw")) { auto cyls = disk->cyls(); auto heads = disk->heads(); if (opt.noformat) util::cout << util::fmt("Created %2u cyl%s, %u head%s, unformatted.\n", cyls, (cyls == 1) ? "" : "s", heads, (heads == 1) ? "" : "s"); else { util::cout << util::fmt("Created %2u cyl%s, %u head%s, %2u sector%s/track, %4u bytes/sector\n", cyls, (cyls == 1) ? "" : "s", heads, (heads == 1) ? "" : "s", fmt.sectors, (fmt.sectors == 1) ? "" : "s", fmt.sector_size()); } } return true; }
int main(int argc, char *argv[]) { int status; unsigned char *p; int k; TSTTITLE("TESTING WRITE MIDIFILE"); TSTSECTION("Buffer write function"); TSTGROUP("Buffer sizing"); status = chk_evt_buf(16); TST("Room allocated", (status == 0 && (evt_buf_sz - evt_buf_wm) >= 1024)); TSTGROUP("Buffer writing"); p=evt_buf; b_write8(0xAB); b_write7(0xCD); #if 0 b_write16(0xFEDA); /* 1111 1110 1101 1010*/ b_write14(0xFEDA); b_write32(0xFEEDBAC0); #endif TST("Write 8 bits",(p[0] == 0xAB)); TST("Write 7 bits",(p[1] == (0xCD & 0x7F))); #if 0 TST("Write 16 bits",(p[2] == 0xFE && p[3] == 0xDA)); /*1111 1110 1101 1010*/ TST("Write 14 bits",(p[4] == 0x7D && p[5] == 0x5A)); /*0111 1101 0101 1010*/ TSTONFAIL("Bytes written: %02x %02x",p[4],p[5]); #endif TSTGROUP("Raw write track"); h_writetrack = (t_writetrack) mywritetrack1; h_error = (t_error) mf_null_handler; status = write_track(1); TST("write_track() returned unsuccessfully",(status == 309)); TSTONFAIL("return code: %d\n",status); midi_file = fopen("test_file.mid","wb"); status = write_track(1); TST("write_track() returned successfully",(status == 0)); fclose(midi_file); midi_file = fopen("test_file.mid","rb"); TST("File reopened for read",(midi_file != NULL)); if (midi_file) { /* Now, if everything went well the file should contain: * MTrk 00 00 00 0C 00 90 3C 64 60 3E 64 83 60 FF 2F 00 */ TSTWRITE("#"); p = "MTrk\0\0\0\x0C\0\x90\x3C\x64\x60\x3E\x64\x83\x60\xFF\x2F\0"; for (k=0; k<20; k++) { if (p[k] != fgetc(midi_file)) break; TSTWRITE(" %02X",p[k]); } TSTWRITE("\n"); TST("File written correctly",(k == 20)); fclose(midi_file); midi_file = NULL; } h_writetrack = (t_writetrack) mywritetrack2; status = mf_write("test_file.mid",0,1,96); TST("mf_write succeeded",(status == 0)); TSTDONE(); if (midi_file) fclose(midi_file); return (0); }
bool ti99_floppy_format::save(io_generic *io, floppy_image *image) { int act_track_size = 0; UINT8 bitstream[500000/8]; UINT8 trackdata[9216]; // max size int cellsizes[] = { 2000, 4000, 1000, 2000 }; // Do we use double-stepping? // If our image was loaded into a 80-track drive, we will always write 80 tracks. int maxtrack, maxheads; image->get_maximal_geometry(maxtrack, maxheads); if (maxtrack > 80) maxtrack = 80; else { if (maxtrack > 35 && maxtrack < 80) maxtrack = 40; else maxtrack = 35; } int attempt = 0; int sector[36]; int maxsect = 18; bool write = true; // We expect a bitstream of length 50000 for FM and 100000 for MFM for(int head=0; head < 2; head++) { int track = 0; while (track < maxtrack) { int cell_size = cellsizes[attempt]; int encoding = get_encoding(cell_size); int track_size = get_track_size(cell_size, 36); // max number of sectors // Retrieve the cells from the flux sequence generate_bitstream_from_track(track, head, cell_size, bitstream, act_track_size, image); // Maybe the track has become longer due to moving splices if (act_track_size > 200000000/cell_size) act_track_size = 200000000/cell_size; int marks = decode_bitstream(bitstream, trackdata, sector, act_track_size, encoding, (encoding==floppy_image::FM)? 0xff:0x4e, track_size); if (track==0) { if (head==0) { // Find the highest sector in the track // This is only needed for the SDF format int i=35; while (i>=0 && sector[i]==-1) i--; if (i>18) maxsect = 36; else { if (i>16) maxsect = 18; else { if (i>9) maxsect = 16; else maxsect = 9; } } if (TRACE) osd_printf_info("ti99_dsk: Sectors/track: %d\n", maxsect); // We try different cell sizes until we find a fitting size. // If this fails, we fall back to a size of 2000 ns // The criterion for a successful decoding is that we find at least // 6 ID or data address marks on the track. It is highly unlikely // to find so many marks with a wrong cell size. if (marks < 6 && attempt < 4) { if (TRACE) osd_printf_verbose("ti99_dsk: Decoding with cell size %d failed.\n", cell_size); attempt++; write = false; } else write = true; } else { if (marks < 6) { if (min_heads()==1) { if (TRACE) osd_printf_info("ti99_dsk: We don't have a second side and the format allows for single-sided recording.\n"); return true; } else { osd_printf_warning("ti99_dsk: No second side, but this format requires two-sided recording. Saving empty tracks.\n"); } } } } if (write) { if (TRACE) { if (head == 0 && track == 0) { if (marks >=6) { if (TRACE) osd_printf_info("ti99_dsk: Decoding with cell size %d successful.\n", cell_size); } else osd_printf_info("ti99_dsk: No address marks found on track 0. Assuming MFM format.\n"); } } // Save to the file write_track(io, trackdata, sector, track, head, maxsect, maxtrack, track_size); track++; } } } return true; }