salfter/fluxengine
1
0
Fork 0
mirror of https://github.com/davidgiven/fluxengine.git synced 2025-10-31 11:17:01 -07:00
Code Issues Packages Projects Releases Wiki Activity

Switch from Logger() to log().

Browse Source
This commit is contained in:
dg
2023-05-09 22:47:36 +00:00
parent baaeb0bca7
commit d4b55cd8f5
30 changed files with 192 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
lib/flags.cc
View File

@@ -49,7 +49,7 @@ void FlagGroup::applyOption(const OptionProto& option)
error("option '{}' has an option group inside it, which isn't allowed", error("option '{}' has an option group inside it, which isn't allowed",
option.name()); option.name());
Logger() << fmt::format("OPTION: {}", log("OPTION: {}",
option.has_message() ? option.message() : option.comment()); option.has_message() ? option.message() : option.comment());
config.MergeFrom(option.config()); config.MergeFrom(option.config());

5
lib/fluxsink/a2rfluxsink.cc
View File

@@ -36,8 +36,7 @@ namespace
_writer{_bytes.writer()} _writer{_bytes.writer()}
{ {
Logger() << fmt::format( log("A2R: writing A2R {} file containing {} tracks\n",
"A2R: writing A2R {} file containing {} tracks\n",
singlesided() ? "single sided" : "double sided", singlesided() ? "single sided" : "double sided",
config.tracks().end() - config.tracks().start() + 1); config.tracks().end() - config.tracks().start() + 1);
@@ -53,7 +52,7 @@ namespace
writeStream(); writeStream();
writeMeta(); writeMeta();
Logger() << "A2R: writing output file...\n"; log("A2R: writing output file...\n");
std::ofstream of( std::ofstream of(
_config.filename(), std::ios::out | std::ios::binary); _config.filename(), std::ios::out | std::ios::binary);
if (!of.is_open()) if (!of.is_open())

11
lib/fluxsink/scpfluxsink.cc
View File

@@ -10,6 +10,7 @@
#include "fluxmap.h" #include "fluxmap.h"
#include "layout.h" #include "layout.h"
#include "scp.h" #include "scp.h"
#include "lib/logger.h"
#include <fstream> #include <fstream>
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/types.h> #include <sys/types.h>
@@ -64,8 +65,7 @@ public:
else else
_fileheader.heads = 0; _fileheader.heads = 0;
std::cout << fmt::format( log("SCP: writing 96 tpi {} file containing {} tracks",
"SCP: writing 96 tpi {} file containing {} tracks\n",
(minSide == maxSide) ? "single sided" : "double sided", (minSide == maxSide) ? "single sided" : "double sided",
_fileheader.end_track - _fileheader.start_track + 1); _fileheader.end_track - _fileheader.start_track + 1);
} }
@@ -79,7 +79,7 @@ public:
appendChecksum(checksum, _trackdata); appendChecksum(checksum, _trackdata);
write_le32(_fileheader.checksum, checksum); write_le32(_fileheader.checksum, checksum);
std::cout << "SCP: writing output file...\n"; log("SCP: writing output file");
std::ofstream of(_config.filename(), std::ios::out | std::ios::binary); std::ofstream of(_config.filename(), std::ios::out | std::ios::binary);
if (!of.is_open()) if (!of.is_open())
error("cannot open output file"); error("cannot open output file");
@@ -97,9 +97,8 @@ public:
if (strack >= std::size(_fileheader.track)) if (strack >= std::size(_fileheader.track))
{ {
std::cout << fmt::format( log("SCP: cannot write track {} head {}, there are not not enough "
"SCP: cannot write track {} head {}, " "Track Data Headers.",
"there are not not enough Track Data Headers.\n",
track, track,
head); head);
return; return;

5
lib/fluxsource/scpfluxsource.cc
View File

@@ -6,6 +6,7 @@
#include "fluxsource/fluxsource.h" #include "fluxsource/fluxsource.h"
#include "scp.h" #include "scp.h"
#include "proto.h" #include "proto.h"
#include "lib/logger.h"
#include <fstream> #include <fstream>
static int trackno(int strack) static int trackno(int strack)
@@ -51,12 +52,12 @@ public:
if ((_header.cell_width != 0) && (_header.cell_width != 16)) if ((_header.cell_width != 0) && (_header.cell_width != 16))
error("currently only 16-bit cells in SCP files are supported"); error("currently only 16-bit cells in SCP files are supported");
std::cout << fmt::format("SCP tracks {}-{}, heads {}-{}\n", log("SCP tracks {}-{}, heads {}-{}",
trackno(_header.start_track), trackno(_header.start_track),
trackno(_header.end_track), trackno(_header.end_track),
startSide, startSide,
endSide); endSide);
std::cout << fmt::format("SCP sample resolution: {} ns\n", _resolution); log("SCP sample resolution: {} ns", _resolution);
} }
public: public:

3
lib/imagereader/d64imagereader.cc
View File

@@ -35,8 +35,7 @@ public:
unsigned numHeads = 1; unsigned numHeads = 1;
unsigned numSectors = 0; unsigned numSectors = 0;
Logger() << fmt::format( log("D64: reading image with {} tracks, {} heads", numTracks, numHeads);
"D64: reading image with {} tracks, {} heads", numTracks, numHeads);
uint32_t offset = 0; uint32_t offset = 0;

12
lib/imagereader/d88imagereader.cc
View File

@@ -34,7 +34,7 @@ public:
std::string diskName = header.slice(0, 0x16); std::string diskName = header.slice(0, 0x16);
if (diskName[0]) if (diskName[0])
Logger() << fmt::format("D88: disk name: {}", diskName); log("D88: disk name: {}", diskName);
ByteReader headerReader(header); ByteReader headerReader(header);
@@ -46,7 +46,7 @@ public:
int diskSize = headerReader.seek(0x1c).read_le32(); int diskSize = headerReader.seek(0x1c).read_le32();
if (diskSize > fileSize) if (diskSize > fileSize)
Logger() << "D88: found multiple disk images. Only using first"; log("D88: found multiple disk images. Only using first");
int trackTableEnd = headerReader.seek(0x20).read_le32(); int trackTableEnd = headerReader.seek(0x20).read_le32();
int trackTableSize = trackTableEnd - 0x20; int trackTableSize = trackTableEnd - 0x20;
@@ -58,19 +58,19 @@ public:
if (config.encoder().format_case() != if (config.encoder().format_case() !=
EncoderProto::FormatCase::FORMAT_NOT_SET) EncoderProto::FormatCase::FORMAT_NOT_SET)
Logger() << "D88: overriding configured format"; log("D88: overriding configured format");
auto ibm = config.mutable_encoder()->mutable_ibm(); auto ibm = config.mutable_encoder()->mutable_ibm();
int clockRate = 500; int clockRate = 500;
if (mediaFlag == 0x20) if (mediaFlag == 0x20)
{ {
Logger() << "D88: forcing high density mode"; log("D88: forcing high density mode");
config.mutable_drive()->set_high_density(true); config.mutable_drive()->set_high_density(true);
config.set_tpi(96); config.set_tpi(96);
} }
else else
{ {
Logger() << "D88: forcing single/double density mode"; log("D88: forcing single/double density mode");
clockRate = 300; clockRate = 300;
config.mutable_drive()->set_high_density(false); config.mutable_drive()->set_high_density(false);
config.set_tpi(48); config.set_tpi(48);
@@ -216,7 +216,7 @@ public:
image->calculateSize(); image->calculateSize();
const Geometry& geometry = image->getGeometry(); const Geometry& geometry = image->getGeometry();
Logger() << fmt::format("D88: read {} tracks, {} sides", log("D88: read {} tracks, {} sides",
geometry.numTracks, geometry.numTracks,
geometry.numSides); geometry.numSides);

14
lib/imagereader/dimimagereader.cc
View File

@@ -104,23 +104,23 @@ public:
switch (mediaByte) switch (mediaByte)
{ {
case 0x00: case 0x00:
Logger() << "DIM: automatically setting format to 1.2MB " log("DIM: automatically setting format to 1.2MB "
"(1024 byte sectors)"; "(1024 byte sectors)");
trackdata->set_target_rotational_period_ms(167); trackdata->set_target_rotational_period_ms(167);
layoutdata->set_sector_size(1024); layoutdata->set_sector_size(1024);
for (int i = 0; i < 9; i++) for (int i = 0; i < 9; i++)
physical->add_sector(i); physical->add_sector(i);
break; break;
case 0x02: case 0x02:
Logger() << "DIM: automatically setting format to 1.2MB " log("DIM: automatically setting format to 1.2MB "
"(512 byte sectors)"; "(512 byte sectors)");
trackdata->set_target_rotational_period_ms(167); trackdata->set_target_rotational_period_ms(167);
layoutdata->set_sector_size(512); layoutdata->set_sector_size(512);
for (int i = 0; i < 15; i++) for (int i = 0; i < 15; i++)
physical->add_sector(i); physical->add_sector(i);
break; break;
case 0x03: case 0x03:
Logger() << "DIM: automatically setting format to 1.44MB"; log("DIM: automatically setting format to 1.44MB");
trackdata->set_target_rotational_period_ms(200); trackdata->set_target_rotational_period_ms(200);
layoutdata->set_sector_size(512); layoutdata->set_sector_size(512);
for (int i = 0; i < 18; i++) for (int i = 0; i < 18; i++)
@@ -128,7 +128,7 @@ public:
break; break;
default: default:
error( error(
"DIM: unknown media byte 0x%02x, could not determine " "DIM: unknown media byte 0x{:02x}, could not determine "
"write profile automatically", "write profile automatically",
mediaByte); mediaByte);
break; break;
@@ -139,7 +139,7 @@ public:
image->calculateSize(); image->calculateSize();
const Geometry& geometry = image->getGeometry(); const Geometry& geometry = image->getGeometry();
Logger() << fmt::format("DIM: read {} tracks, {} sides, {} kB total", log("DIM: read {} tracks, {} sides, {} kB total",
geometry.numTracks, geometry.numTracks,
geometry.numSides, geometry.numSides,
((int)inputFile.tellg() - 256) / 1024); ((int)inputFile.tellg() - 256) / 1024);

3
lib/imagereader/diskcopyimagereader.cc
View File

@@ -63,8 +63,7 @@ public:
error("don't understand DiskCopy disks of type {}", encoding); error("don't understand DiskCopy disks of type {}", encoding);
} }
Logger() << fmt::format( log("DC42: reading image with {} tracks, {} heads; {}; {}",
"DC42: reading image with {} tracks, {} heads; {}; {}",
numTracks, numTracks,
numHeads, numHeads,
mfm ? "MFM" : "GCR", mfm ? "MFM" : "GCR",

8
lib/imagereader/fdiimagereader.cc
View File

@@ -83,8 +83,8 @@ public:
switch (fddType) switch (fddType)
{ {
case 0x90: case 0x90:
Logger() << "FDI: automatically setting format to 1.2MB " log("FDI: automatically setting format to 1.2MB (1024 byte "
"(1024 byte sectors)"; "sectors)");
trackdata->set_target_rotational_period_ms(167); trackdata->set_target_rotational_period_ms(167);
layoutdata->set_sector_size(1024); layoutdata->set_sector_size(1024);
for (int i = 0; i < 9; i++) for (int i = 0; i < 9; i++)
@@ -92,7 +92,7 @@ public:
break; break;
case 0x30: case 0x30:
Logger() << "FDI: automatically setting format to 1.44MB"; log("FDI: automatically setting format to 1.44MB");
trackdata->set_target_rotational_period_ms(200); trackdata->set_target_rotational_period_ms(200);
layoutdata->set_sector_size(512); layoutdata->set_sector_size(512);
for (int i = 0; i < 18; i++) for (int i = 0; i < 18; i++)
@@ -110,7 +110,7 @@ public:
image->calculateSize(); image->calculateSize();
const Geometry& geometry = image->getGeometry(); const Geometry& geometry = image->getGeometry();
Logger() << fmt::format("FDI: read {} tracks, {} sides, {} kB total", log("FDI: read {} tracks, {} sides, {} kB total",
geometry.numTracks, geometry.numTracks,
geometry.numSides, geometry.numSides,
((int)inputFile.tellg() - headerSize) / 1024); ((int)inputFile.tellg() - headerSize) / 1024);

2
lib/imagereader/imagereader.cc
View File

@@ -102,7 +102,7 @@ std::unique_ptr<Image> ImageReader::readMappedImage()
if (!_config.filesystem_sector_order()) if (!_config.filesystem_sector_order())
return rawImage; return rawImage;
Logger() << "READER: converting from filesystem sector order to disk order"; log("READER: converting from filesystem sector order to disk order");
std::set<std::shared_ptr<const Sector>> sectors; std::set<std::shared_ptr<const Sector>> sectors;
for (const auto& e : *rawImage) for (const auto& e : *rawImage)
{ {

98
lib/imagereader/imdimagereader.cc
View File

@@ -106,21 +106,38 @@ class IMDImageReader : public ImageReader
public: public:
IMDImageReader(const ImageReaderProto& config): ImageReader(config) {} IMDImageReader(const ImageReaderProto& config): ImageReader(config) {}
std::unique_ptr<Image> readImage() // clang-format off
/* /*
IMAGE FILE FORMAT * IMAGE FILE FORMAT
The overall layout of an ImageDisk .IMD image file is: * The overall layout of an ImageDisk .IMD image file is:
IMD v.vv: dd/mm/yyyy hh:mm:ss * IMD v.vv: dd/mm/yyyy hh:mm:ss
Comment (ASCII only - unlimited size) * Comment (ASCII only - unlimited size)
1A byte - ASCII EOF character * 1A byte - ASCII EOF character
- For each track on the disk: * - For each track on the disk:
1 byte Mode value see getModulationspeed for * 1 byte Mode value (0-5) see getModulationspeed for definition
definition 1 byte Track 1 byte Head 1 byte number of sectors in track 1 byte * 1 byte Cylinder (0-n)
sector size see getsectorsize for definition sector * 1 byte Head (0-1)
numbering map sector track map (optional) definied in high byte * 1 byte number of sectors in track (1-n)
of head (since head is 0 or 1) sector head map (optional) definied in high * 1 byte sector size (0-6) see getsectorsize for definition
byte of head (since head is 0 or 1) sector data records <End of file> * sector numbering map IMD start numbering sectors with 1.
*/ * sector cylinder map (optional) definied in high byte of head (since head is 0 or 1)
* sector head map (optional) definied in high byte of head (since head is 0 or 1)
* sector data records For each data record:
* 1 byte Sector status
* 0: Sector data unavailable - could not be read
* 1: Normal data: (Sector Size) bytes follow
* 2: Compressed: All bytes in sector have same value (xx)
* 3: Normal data with "Deleted-Data address mark"
* 4: Compressed with "Deleted-Data address mark"
* 5: Normal data read with data error
* 6: Compressed read with data error"
* 7: Deleted data read with data error"
* 8: Compressed, Deleted read with data error"
* sector size of Sector data
* <End of file>
*/
// clang-format on
std::unique_ptr<Image> readImage()
{ {
// Read File // Read File
std::ifstream inputFile( std::ifstream inputFile(
@@ -161,7 +178,7 @@ public:
n++; n++;
} }
headerPtr = n; // set pointer to after comment headerPtr = n; // set pointer to after comment
Logger() << "Comment in IMD file:" << fmt::format("{}", comment); log("Comment in IMD file: {}", comment);
for (;;) for (;;)
{ {
@@ -284,22 +301,19 @@ public:
switch (Status_Sector) switch (Status_Sector)
{ {
/*fluxengine knows of a few sector statussen but not all // clang-format off
*of the statussen in IMD. /* fluxengine knows of a few sector statussen but not all of the statussen in IMD.
* // the statussen are in sector.h. Translation to * // the statussen are in sector.h. Translation to fluxengine is as follows:
*fluxengine is as follows: Statussen fluxengine * Statussen fluxengine | Status IMD
*| Status IMD *--------------------------------------------------------------------------------------------------------------------
*-------------------------------------------------------------------------------------------------------------------- * OK, | 1, 2 (Normal data: (Sector Size) of (compressed) bytes follow)
* OK, * BAD_CHECKSUM, | 5, 6, 7, 8
*| 1, 2 (Normal data: (Sector Size) of (compressed) * MISSING, sector not found | 0 (Sector data unavailable - could not be read)
*bytes follow) BAD_CHECKSUM, * DATA_MISSING, sector present but no data found | 3, 4
*| 5, 6, 7, 8 MISSING, sector not found * CONFLICT, |
*| 0 (Sector data unavailable - could not be read) * INTERNAL_ERROR |
* DATA_MISSING, sector present but no data found */
*| 3, 4 CONFLICT, // clang-format on
*| INTERNAL_ERROR
*|
*/
case 0: /* Sector data unavailable - could not be read */ case 0: /* Sector data unavailable - could not be read */
sector->status = Sector::MISSING; sector->status = Sector::MISSING;
@@ -431,24 +445,22 @@ public:
if (config.encoder().format_case() != if (config.encoder().format_case() !=
EncoderProto::FormatCase::FORMAT_NOT_SET) EncoderProto::FormatCase::FORMAT_NOT_SET)
Logger() << "IMD: overriding configured format"; log("IMD: overriding configured format");
image->calculateSize(); image->calculateSize();
const Geometry& geometry = image->getGeometry(); const Geometry& geometry = image->getGeometry();
size_t headSize = ((header.numSectors) * (sectorSize)); size_t headSize = ((header.numSectors) * (sectorSize));
size_t trackSize = (headSize * (header.Head + 1)); size_t trackSize = (headSize * (header.Head + 1));
Logger() << "IMD: read " log("IMD: read {} tracks, {} heads; {}; {} kbps; {} sectors; "
<< fmt::format( "sectorsize {}; {} kB total.",
"{} tracks, {} heads; {}; {} kbps; {} sectors; " header.track + 1,
"sectorsize {}; {} kB total.", header.Head + 1,
header.track + 1, fm ? "FM" : "MFM",
header.Head + 1, Modulation_Speed,
fm ? "FM" : "MFM", header.numSectors,
Modulation_Speed, sectorSize,
header.numSectors, (header.track + 1) * trackSize / 1024);
sectorSize,
(header.track + 1) * trackSize / 1024);
layout->set_tracks(geometry.numTracks); layout->set_tracks(geometry.numTracks);
layout->set_sides(geometry.numSides); layout->set_sides(geometry.numSides);

3
lib/imagereader/imgimagereader.cc
View File

@@ -53,8 +53,7 @@ public:
image->calculateSize(); image->calculateSize();
const Geometry& geometry = image->getGeometry(); const Geometry& geometry = image->getGeometry();
Logger() << fmt::format( log("IMG: read {} tracks, {} sides, {} kB total from {}",
"IMG: read {} tracks, {} sides, {} kB total from {}",
geometry.numTracks, geometry.numTracks,
geometry.numSides, geometry.numSides,
inputFile.tellg() / 1024, inputFile.tellg() / 1024,

8
lib/imagereader/nfdimagereader.cc
View File

@@ -51,12 +51,12 @@ public:
if (config.encoder().format_case() != if (config.encoder().format_case() !=
EncoderProto::FormatCase::FORMAT_NOT_SET) EncoderProto::FormatCase::FORMAT_NOT_SET)
Logger() << "NFD: overriding configured format"; log("NFD: overriding configured format");
auto ibm = config.mutable_encoder()->mutable_ibm(); auto ibm = config.mutable_encoder()->mutable_ibm();
auto layout = config.mutable_layout(); auto layout = config.mutable_layout();
Logger() << "NFD: HD 1.2MB mode"; log("NFD: HD 1.2MB mode");
Logger() << "NFD: forcing hign density mode"; log("NFD: forcing hign density mode");
config.mutable_drive()->set_high_density(true); config.mutable_drive()->set_high_density(true);
config.set_tpi(96); config.set_tpi(96);
@@ -156,7 +156,7 @@ public:
image->calculateSize(); image->calculateSize();
const Geometry& geometry = image->getGeometry(); const Geometry& geometry = image->getGeometry();
Logger() << fmt::format("NFD: read {} tracks, {} sides", log("NFD: read {} tracks, {} sides",
geometry.numTracks, geometry.numTracks,
geometry.numSides); geometry.numSides);
return image; return image;

6
lib/imagereader/nsiimagereader.cc
View File

@@ -28,8 +28,7 @@ public:
const auto end = inputFile.tellg(); const auto end = inputFile.tellg();
const auto fsize = (end - begin); const auto fsize = (end - begin);
Logger() << fmt::format( log("NSI: Autodetecting geometry based on file size: {}", fsize);
"NSI: Autodetecting geometry based on file size: {}", fsize);
unsigned numTracks = 35; unsigned numTracks = 35;
unsigned numSectors = 10; unsigned numSectors = 10;
@@ -59,8 +58,7 @@ public:
size_t trackSize = numSectors * sectorSize; size_t trackSize = numSectors * sectorSize;
Logger() << fmt::format( log("reading {} tracks, {} heads, {} sectors, {} bytes per sector, {} "
"reading {} tracks, {} heads, {} sectors, {} bytes per sector, {} "
"kB total", "kB total",
numTracks, numTracks,
numHeads, numHeads,

6
lib/imagereader/td0imagereader.cc
View File

@@ -97,8 +97,7 @@ public:
comment.erase(nl.base(), comment.end()); comment.erase(nl.base(), comment.end());
} }
Logger() << fmt::format( log("TD0: TeleDisk {}.{}: {}", version / 10, version % 10, comment);
"TD0: TeleDisk {}.{}: {}", version / 10, version % 10, comment);
unsigned totalSize = 0; unsigned totalSize = 0;
std::unique_ptr<Image> image(new Image); std::unique_ptr<Image> image(new Image);
@@ -193,8 +192,7 @@ public:
image->calculateSize(); image->calculateSize();
const Geometry& geometry = image->getGeometry(); const Geometry& geometry = image->getGeometry();
Logger() << fmt::format( log("TD0: found {} tracks, {} sides, {} sectors, {} bytes per sector, "
"TD0: found {} tracks, {} sides, {} sectors, {} bytes per sector, "
"{} kB total", "{} kB total",
geometry.numTracks, geometry.numTracks,
geometry.numSides, geometry.numSides,

2
lib/imagewriter/d64imagewriter.cc
View File

@@ -28,7 +28,7 @@ public:
void writeImage(const Image& image) void writeImage(const Image& image)
{ {
Logger() << "D64: writing triangular image"; log("D64: writing triangular image");
std::ofstream outputFile( std::ofstream outputFile(
_config.filename(), std::ios::out | std::ios::binary); _config.filename(), std::ios::out | std::ios::binary);

2
lib/imagewriter/d88imagewriter.cc
View File

@@ -126,7 +126,7 @@ public:
outputFile.seekp(0); outputFile.seekp(0);
header.writeTo(outputFile); header.writeTo(outputFile);
Logger() << fmt::format("D88: wrote {} tracks, {} sides, {} kB total", log("D88: wrote {} tracks, {} sides, {} kB total",
tracks, tracks,
sides, sides,
outputFile.tellp() / 1024); outputFile.tellp() / 1024);

16
lib/imagewriter/diskcopyimagewriter.cc
View File

@@ -53,15 +53,13 @@ public:
"format"); "format");
} }
Logger() << "DC42: writing DiskCopy 4.2 image" log("DC42: writing DiskCopy 4.2 image");
<< fmt::format( log("DC42: {} tracks, {} sides, {} sectors, {} bytes per sector; {}",
"DC42: {} tracks, {} sides, {} sectors, {} bytes per " geometry.numTracks,
"sector; {}", geometry.numSides,
geometry.numTracks, geometry.numSectors,
geometry.numSides, geometry.sectorSize,
geometry.numSectors, mfm ? "MFM" : "GCR");
geometry.sectorSize,
mfm ? "MFM" : "GCR");
auto sectors_per_track = [&](int track) -> int auto sectors_per_track = [&](int track) -> int
{ {

3
lib/imagewriter/imagewriter.cc
View File

@@ -206,8 +206,7 @@ void ImageWriter::writeMappedImage(const Image& image)
{ {
if (_config.filesystem_sector_order()) if (_config.filesystem_sector_order())
{ {
Logger() log("WRITER: converting from disk sector order to filesystem order");
<< "WRITER: converting from disk sector order to filesystem order";
std::set<std::shared_ptr<const Sector>> sectors; std::set<std::shared_ptr<const Sector>> sectors;
for (const auto& e : image) for (const auto& e : image)

12
lib/imagewriter/imdimagewriter.cc
View File

@@ -181,7 +181,7 @@ public:
: ImdOutputProto::RATE_DD; : ImdOutputProto::RATE_DD;
if (geometry.sectorSize <= 256) if (geometry.sectorSize <= 256)
dataRate = ImdOutputProto::RATE_SD; dataRate = ImdOutputProto::RATE_SD;
Logger() << fmt::format("IMD: guessing data rate as {}", log("IMD: guessing data rate as {}",
ImdOutputProto::DataRate_Name(dataRate)); ImdOutputProto::DataRate_Name(dataRate));
} }
@@ -190,7 +190,7 @@ public:
if (recordingMode == ImdOutputProto::RECMODE_GUESS) if (recordingMode == ImdOutputProto::RECMODE_GUESS)
{ {
recordingMode = ImdOutputProto::RECMODE_MFM; recordingMode = ImdOutputProto::RECMODE_MFM;
Logger() << fmt::format("IMD: guessing recording mode as {}", log("IMD: guessing recording mode as {}",
ImdOutputProto::RecordingMode_Name(recordingMode)); ImdOutputProto::RecordingMode_Name(recordingMode));
} }
@@ -238,8 +238,7 @@ public:
{ // sector 0 doesnt exist exit with error { // sector 0 doesnt exist exit with error
// this track, head has no sectors // this track, head has no sectors
Status_Sector = 0; Status_Sector = 0;
Logger() << fmt::format( log("IMD: sector {} not found on track {}, head {}\n",
"IMD: sector {} not found on track {}, head {}\n",
sectorId + 1, sectorId + 1,
track, track,
head); head);
@@ -394,7 +393,7 @@ public:
* 7: Deleted data read with data error" * 7: Deleted data read with data error"
* 8: Compressed, Deleted read with data error" * 8: Compressed, Deleted read with data error"
* sector size of Sector data * sector size of Sector data
*/ */
// clang-format on // clang-format on
// read sector // read sector
const auto& sector = image.get(track, head, sectorId + 1); const auto& sector = image.get(track, head, sectorId + 1);
@@ -516,8 +515,7 @@ public:
} }
} }
imagenew.writeTo(outputFile); imagenew.writeTo(outputFile);
Logger() << fmt::format( log("IMD: Written {} tracks, {} heads, {} sectors, {} bytes per "
"IMD: Written {} tracks, {} heads, {} sectors, {} bytes per "
"sector, {} kB total", "sector, {} kB total",
geometry.numTracks, geometry.numTracks,
numHeads, numHeads,

3
lib/imagewriter/imgimagewriter.cc
View File

@@ -47,8 +47,7 @@ public:
} }
} }
Logger() << fmt::format( log("IMG: wrote {} tracks, {} sides, {} kB total to {}",
"IMG: wrote {} tracks, {} sides, {} kB total to {}",
tracks, tracks,
sides, sides,
outputFile.tellp() / 1024, outputFile.tellp() / 1024,

7
lib/imagewriter/ldbsimagewriter.cc
View File

@@ -21,8 +21,7 @@ public:
const Geometry geometry = image.getGeometry(); const Geometry geometry = image.getGeometry();
Logger() << fmt::format( log("LDBS: writing {} tracks, {} sides, {} sectors, {} bytes per "
"LDBS: writing {} tracks, {} sides, {} sectors, {} bytes per "
"sector", "sector",
geometry.numTracks, geometry.numTracks,
geometry.numSides, geometry.numSides,
@@ -41,7 +40,7 @@ public:
: LDBSOutputProto::RATE_DD; : LDBSOutputProto::RATE_DD;
if (geometry.sectorSize <= 256) if (geometry.sectorSize <= 256)
dataRate = LDBSOutputProto::RATE_SD; dataRate = LDBSOutputProto::RATE_SD;
Logger() << fmt::format("LDBS: guessing data rate as {}", log("LDBS: guessing data rate as {}",
LDBSOutputProto::DataRate_Name(dataRate)); LDBSOutputProto::DataRate_Name(dataRate));
} }
@@ -50,7 +49,7 @@ public:
if (recordingMode == LDBSOutputProto::RECMODE_GUESS) if (recordingMode == LDBSOutputProto::RECMODE_GUESS)
{ {
recordingMode = LDBSOutputProto::RECMODE_MFM; recordingMode = LDBSOutputProto::RECMODE_MFM;
Logger() << fmt::format("LDBS: guessing recording mode as {}", log("LDBS: guessing recording mode as {}",
LDBSOutputProto::RecordingMode_Name(recordingMode)); LDBSOutputProto::RecordingMode_Name(recordingMode));
} }

10
lib/imagewriter/nsiimagewriter.cc
View File

@@ -25,13 +25,11 @@ public:
if (geometry.numTracks * trackSize == 0) if (geometry.numTracks * trackSize == 0)
{ {
Logger() log("No sectors in output; skipping .nsi image file generation.");
<< "No sectors in output; skipping .nsi image file generation.";
return; return;
} }
Logger() << fmt::format( log("Writing {} tracks, {} sides, {} sectors, {} ({} bytes/sector), {} "
"Writing {} tracks, {} sides, {} sectors, {} ({} bytes/sector), {} "
"kB total", "kB total",
geometry.numTracks, geometry.numTracks,
geometry.numSides, geometry.numSides,
@@ -91,8 +89,8 @@ public:
memset(fill, ' ', sizeof(fill)); memset(fill, ' ', sizeof(fill));
if (mixedDensity == false) if (mixedDensity == false)
{ {
Logger() << "Warning: Disk contains mixed " log("Warning: Disk contains mixed "
"single/double-density sectors."; "single/double-density sectors.");
} }
mixedDensity = true; mixedDensity = true;
sector->data.slice(0, 256).writeTo(outputFile); sector->data.slice(0, 256).writeTo(outputFile);

5
lib/imagewriter/rawimagewriter.cc
View File

@@ -24,12 +24,11 @@ public:
if (geometry.numTracks * trackSize == 0) if (geometry.numTracks * trackSize == 0)
{ {
Logger() log("RAW: no sectors in output; skipping image file generation.");
<< "RAW: no sectors in output; skipping image file generation.";
return; return;
} }
Logger() << fmt::format("RAW: writing {} tracks, {} sides", log("RAW: writing {} tracks, {} sides",
geometry.numTracks, geometry.numTracks,
geometry.numSides); geometry.numSides);

16
lib/logger.cc
View File

@@ -6,13 +6,16 @@
#include "logger.h" #include "logger.h"
static bool indented = false; static bool indented = false;
static std::function<void(std::shared_ptr<const AnyLogMessage>)> loggerImpl =
Logger::textLogger;
Logger& Logger::operator<<(std::shared_ptr<const AnyLogMessage> message) static std::function<void(std::shared_ptr<const AnyLogMessage>)> loggerImpl =
[](auto message)
{
std::cout << Logger::toString(*message) << std::flush;
};
void log(std::shared_ptr<const AnyLogMessage> message)
{ {
loggerImpl(message); loggerImpl(message);
return *this;
} }
void Logger::setLogger( void Logger::setLogger(
@@ -21,11 +24,6 @@ void Logger::setLogger(
loggerImpl = cb; loggerImpl = cb;
} }
void Logger::textLogger(std::shared_ptr<const AnyLogMessage> message)
{
std::cout << toString(*message) << std::flush;
}
std::string Logger::toString(const AnyLogMessage& message) std::string Logger::toString(const AnyLogMessage& message)
{ {
std::stringstream stream; std::stringstream stream;

28
lib/logger.h
View File

@@ -91,22 +91,26 @@ typedef std::variant<std::string,
OperationProgressLogMessage> OperationProgressLogMessage>
AnyLogMessage; AnyLogMessage;
class Logger template <class T>
inline void log(const T& message)
{ {
public: log(std::make_shared<const AnyLogMessage>(message));
Logger& operator<<(std::shared_ptr<const AnyLogMessage> message); }
template <class T> extern void log(std::shared_ptr<const AnyLogMessage> message);
Logger& operator<<(const T& message)
{
return *this << std::make_shared<const AnyLogMessage>(message);
}
static void setLogger( template <typename... Args>
inline void log(fmt::string_view fstr, const Args&... args)
{
log(fmt::format(fstr, args...));
}
namespace Logger
{
extern void setLogger(
std::function<void(std::shared_ptr<const AnyLogMessage>)> cb); std::function<void(std::shared_ptr<const AnyLogMessage>)> cb);
static std::string toString(const AnyLogMessage&); extern std::string toString(const AnyLogMessage&);
static void textLogger(std::shared_ptr<const AnyLogMessage>); }
};
#endif #endif

90
lib/readerwriter.cc
View File

@@ -58,7 +58,7 @@ private:
void measureDiskRotation( void measureDiskRotation(
nanoseconds_t& oneRevolution, nanoseconds_t& hardSectorThreshold) nanoseconds_t& oneRevolution, nanoseconds_t& hardSectorThreshold)
{ {
Logger() << BeginSpeedOperationLogMessage(); log(BeginSpeedOperationLogMessage());
int retries = 5; int retries = 5;
usbSetDrive(config.drive().drive(), usbSetDrive(config.drive().drive(),
@@ -73,8 +73,7 @@ void measureDiskRotation(
if (oneRevolution == 0) if (oneRevolution == 0)
{ {
Logger() << BeginOperationLogMessage{ log(BeginOperationLogMessage{"Measuring drive rotational speed"});
"Measuring drive rotational speed"};
do do
{ {
oneRevolution = oneRevolution =
@@ -86,13 +85,13 @@ void measureDiskRotation(
retries--; retries--;
} while ((oneRevolution == 0) && (retries > 0)); } while ((oneRevolution == 0) && (retries > 0));
config.mutable_drive()->set_rotational_period_ms(oneRevolution / 1e6); config.mutable_drive()->set_rotational_period_ms(oneRevolution / 1e6);
Logger() << EndOperationLogMessage{}; log(EndOperationLogMessage{});
} }
if (oneRevolution == 0) if (oneRevolution == 0)
error("Failed\nIs a disk in the drive?"); error("Failed\nIs a disk in the drive?");
Logger() << EndSpeedOperationLogMessage{oneRevolution}; log(EndSpeedOperationLogMessage{oneRevolution});
} }
/* Given a set of sectors, deduplicates them sensibly (e.g. if there is a good /* Given a set of sectors, deduplicates them sensibly (e.g. if there is a good
@@ -223,15 +222,15 @@ ReadResult readGroup(FluxSourceIteratorHolder& fluxSourceIteratorHolder,
if (!fluxSourceIterator.hasNext()) if (!fluxSourceIterator.hasNext())
continue; continue;
Logger() << BeginReadOperationLogMessage{ log(BeginReadOperationLogMessage{
trackInfo->physicalTrack + offset, trackInfo->physicalSide}; trackInfo->physicalTrack + offset, trackInfo->physicalSide});
std::shared_ptr<const Fluxmap> fluxmap = fluxSourceIterator.next(); std::shared_ptr<const Fluxmap> fluxmap = fluxSourceIterator.next();
// ->rescale( // ->rescale(
// 1.0 / config.flux_source().rescale()); // 1.0 / config.flux_source().rescale());
Logger() << EndReadOperationLogMessage() log(EndReadOperationLogMessage());
<< fmt::format("{0} ms in {1} bytes", log("{0} ms in {1} bytes",
(int)(fluxmap->duration() / 1e6), (int)(fluxmap->duration() / 1e6),
fluxmap->bytes()); fluxmap->bytes());
auto trackdataflux = decoder.decodeToSectors(fluxmap, trackInfo); auto trackdataflux = decoder.decodeToSectors(fluxmap, trackInfo);
trackFlux.trackDatas.push_back(trackdataflux); trackFlux.trackDatas.push_back(trackdataflux);
@@ -255,13 +254,13 @@ void writeTracks(FluxSink& fluxSink,
std::function<bool(std::shared_ptr<const TrackInfo>& trackInfo)> verifier, std::function<bool(std::shared_ptr<const TrackInfo>& trackInfo)> verifier,
std::vector<std::shared_ptr<const TrackInfo>>& trackInfos) std::vector<std::shared_ptr<const TrackInfo>>& trackInfos)
{ {
Logger() << BeginOperationLogMessage{"Encoding and writing to disk"}; log(BeginOperationLogMessage{"Encoding and writing to disk"});
int index = 0; int index = 0;
for (auto& trackInfo : trackInfos) for (auto& trackInfo : trackInfos)
{ {
Logger() << OperationProgressLogMessage{ log(OperationProgressLogMessage{
index * 100 / (unsigned)trackInfos.size()}; index * 100 / (unsigned)trackInfos.size()});
index++; index++;
testForEmergencyStop(); testForEmergencyStop();
@@ -274,8 +273,8 @@ void writeTracks(FluxSink& fluxSink,
{ {
unsigned physicalTrack = trackInfo->physicalTrack + offset; unsigned physicalTrack = trackInfo->physicalTrack + offset;
Logger() << BeginWriteOperationLogMessage{ log(BeginWriteOperationLogMessage{
physicalTrack, trackInfo->physicalSide}; physicalTrack, trackInfo->physicalSide});
if (offset == config.drive().group_offset()) if (offset == config.drive().group_offset())
{ {
@@ -285,7 +284,7 @@ void writeTracks(FluxSink& fluxSink,
fluxSink.writeFlux( fluxSink.writeFlux(
physicalTrack, trackInfo->physicalSide, *fluxmap); physicalTrack, trackInfo->physicalSide, *fluxmap);
Logger() << fmt::format("writing {0} ms in {1} bytes", log("writing {0} ms in {1} bytes",
int(fluxmap->duration() / 1e6), int(fluxmap->duration() / 1e6),
fluxmap->bytes()); fluxmap->bytes());
} }
@@ -297,10 +296,10 @@ void writeTracks(FluxSink& fluxSink,
Fluxmap blank; Fluxmap blank;
fluxSink.writeFlux( fluxSink.writeFlux(
physicalTrack, trackInfo->physicalSide, blank); physicalTrack, trackInfo->physicalSide, blank);
Logger() << "erased"; log("erased");
} }
Logger() << EndWriteOperationLogMessage(); log(EndWriteOperationLogMessage());
} }
if (verifier(trackInfo)) if (verifier(trackInfo))
@@ -309,13 +308,12 @@ void writeTracks(FluxSink& fluxSink,
if (retriesRemaining == 0) if (retriesRemaining == 0)
error("fatal error on write"); error("fatal error on write");
Logger() << fmt::format( log("retrying; {} retries remaining", retriesRemaining);
"retrying; {} retries remaining", retriesRemaining);
retriesRemaining--; retriesRemaining--;
} }
} }
Logger() << EndOperationLogMessage{"Write complete"}; log(EndOperationLogMessage{"Write complete"});
} }
void writeTracks(FluxSink& fluxSink, void writeTracks(FluxSink& fluxSink,
@@ -358,12 +356,12 @@ void writeTracksAndVerify(FluxSink& fluxSink,
FluxSourceIteratorHolder fluxSourceIteratorHolder(fluxSource); FluxSourceIteratorHolder fluxSourceIteratorHolder(fluxSource);
auto result = readGroup( auto result = readGroup(
fluxSourceIteratorHolder, trackInfo, *trackFlux, decoder); fluxSourceIteratorHolder, trackInfo, *trackFlux, decoder);
Logger() << TrackReadLogMessage{trackFlux}; log(TrackReadLogMessage{trackFlux});
if (result != GOOD_READ) if (result != GOOD_READ)
{ {
adjustTrackOnError(fluxSource, trackInfo->physicalTrack); adjustTrackOnError(fluxSource, trackInfo->physicalTrack);
Logger() << "bad read"; log("bad read");
return false; return false;
} }
@@ -382,12 +380,12 @@ void writeTracksAndVerify(FluxSink& fluxSink,
sector->logicalSector); sector->logicalSector);
if (!s) if (!s)
{ {
Logger() << "spurious sector on verify"; log("spurious sector on verify");
return false; return false;
} }
if (s->data != sector->data.slice(0, s->data.size())) if (s->data != sector->data.slice(0, s->data.size()))
{ {
Logger() << "data mismatch on verify"; log("data mismatch on verify");
return false; return false;
} }
wanted.erase(sector->logicalTrack, wanted.erase(sector->logicalTrack,
@@ -396,7 +394,7 @@ void writeTracksAndVerify(FluxSink& fluxSink,
} }
if (!wanted.empty()) if (!wanted.empty())
{ {
Logger() << "missing sector on verify"; log("missing sector on verify");
return false; return false;
} }
return true; return true;
@@ -463,21 +461,20 @@ std::shared_ptr<TrackFlux> readAndDecodeTrack(FluxSource& fluxSource,
break; break;
if (result == BAD_AND_CAN_NOT_RETRY) if (result == BAD_AND_CAN_NOT_RETRY)
{ {
Logger() << fmt::format("no more data; giving up"); log("no more data; giving up");
break; break;
} }
if (retriesRemaining == 0) if (retriesRemaining == 0)
{ {
Logger() << fmt::format("giving up"); log("giving up");
break; break;
} }
if (fluxSource.isHardware()) if (fluxSource.isHardware())
{ {
adjustTrackOnError(fluxSource, trackInfo->physicalTrack); adjustTrackOnError(fluxSource, trackInfo->physicalTrack);
Logger() << fmt::format( log("retrying; {} retries remaining", retriesRemaining);
"retrying; {} retries remaining", retriesRemaining);
retriesRemaining--; retriesRemaining--;
} }
} }
@@ -494,13 +491,13 @@ std::shared_ptr<const DiskFlux> readDiskCommand(
auto diskflux = std::make_shared<DiskFlux>(); auto diskflux = std::make_shared<DiskFlux>();
Logger() << BeginOperationLogMessage{"Reading and decoding disk"}; log(BeginOperationLogMessage{"Reading and decoding disk"});
auto locations = Layout::computeLocations(); auto locations = Layout::computeLocations();
unsigned index = 0; unsigned index = 0;
for (auto& trackInfo : locations) for (auto& trackInfo : locations)
{ {
Logger() << OperationProgressLogMessage{ log(OperationProgressLogMessage{
index * 100 / (unsigned)locations.size()}; index * 100 / (unsigned)locations.size()});
index++; index++;
testForEmergencyStop(); testForEmergencyStop();
@@ -573,7 +570,7 @@ std::shared_ptr<const DiskFlux> readDiskCommand(
} }
/* track can't be modified below this point. */ /* track can't be modified below this point. */
Logger() << TrackReadLogMessage{trackFlux}; log(TrackReadLogMessage{trackFlux});
} }
std::set<std::shared_ptr<const Sector>> all_sectors; std::set<std::shared_ptr<const Sector>> all_sectors;
@@ -584,8 +581,8 @@ std::shared_ptr<const DiskFlux> readDiskCommand(
diskflux->image = std::make_shared<Image>(all_sectors); diskflux->image = std::make_shared<Image>(all_sectors);
/* diskflux can't be modified below this point. */ /* diskflux can't be modified below this point. */
Logger() << DiskReadLogMessage{diskflux}; log(DiskReadLogMessage{diskflux});
Logger() << EndOperationLogMessage{"Read complete"}; log(EndOperationLogMessage{"Read complete"});
return diskflux; return diskflux;
} }
@@ -602,33 +599,32 @@ void readDiskCommand(
void rawReadDiskCommand(FluxSource& fluxsource, FluxSink& fluxsink) void rawReadDiskCommand(FluxSource& fluxsource, FluxSink& fluxsink)
{ {
Logger() << BeginOperationLogMessage{"Performing raw read of disk"}; log(BeginOperationLogMessage{"Performing raw read of disk"});
auto locations = Layout::computeLocations(); auto locations = Layout::computeLocations();
unsigned index = 0; unsigned index = 0;
for (auto& trackInfo : locations) for (auto& trackInfo : locations)
{ {
Logger() << OperationProgressLogMessage{ log(OperationProgressLogMessage{index * 100 / (int)locations.size()});
index * 100 / (int)locations.size()};
index++; index++;
testForEmergencyStop(); testForEmergencyStop();
auto fluxSourceIterator = fluxsource.readFlux( auto fluxSourceIterator = fluxsource.readFlux(
trackInfo->physicalTrack, trackInfo->physicalSide); trackInfo->physicalTrack, trackInfo->physicalSide);
Logger() << BeginReadOperationLogMessage{ log(BeginReadOperationLogMessage{
trackInfo->physicalTrack, trackInfo->physicalSide}; trackInfo->physicalTrack, trackInfo->physicalSide});
auto fluxmap = fluxSourceIterator->next(); auto fluxmap = fluxSourceIterator->next();
Logger() << EndReadOperationLogMessage() log(EndReadOperationLogMessage());
<< fmt::format("{0} ms in {1} bytes", log("{0} ms in {1} bytes",
(int)(fluxmap->duration() / 1e6), (int)(fluxmap->duration() / 1e6),
fluxmap->bytes()); fluxmap->bytes());
fluxsink.writeFlux( fluxsink.writeFlux(
trackInfo->physicalTrack, trackInfo->physicalSide, *fluxmap); trackInfo->physicalTrack, trackInfo->physicalSide, *fluxmap);
} }
Logger() << EndOperationLogMessage{"Raw read complete"}; log(EndOperationLogMessage{"Raw read complete"});
} }
void fillBitmapTo(std::vector<bool>& bitmap, void fillBitmapTo(std::vector<bool>& bitmap,

7
lib/usb/usb.cc
View File

@@ -67,8 +67,7 @@ USB* get_usb_impl()
config.usb().greaseweazle().has_port()) config.usb().greaseweazle().has_port())
{ {
const auto& conf = config.usb().greaseweazle(); const auto& conf = config.usb().greaseweazle();
Logger() << fmt::format( log("Using GreaseWeazle on serial port {}", conf.port());
"Using GreaseWeazle on serial port {}", conf.port());
return createGreaseWeazleUsb(conf.port(), conf); return createGreaseWeazleUsb(conf.port(), conf);
} }
@@ -78,11 +77,11 @@ USB* get_usb_impl()
switch (candidate->id) switch (candidate->id)
{ {
case FLUXENGINE_ID: case FLUXENGINE_ID:
Logger() << fmt::format("Using FluxEngine {}", candidate->serial); log("Using FluxEngine {}", candidate->serial);
return createFluxengineUsb(candidate->device); return createFluxengineUsb(candidate->device);
case GREASEWEAZLE_ID: case GREASEWEAZLE_ID:
Logger() << fmt::format("Using GreaseWeazle {} on {}", log("Using GreaseWeazle {} on {}",
candidate->serial, candidate->serial,
candidate->serialPort); candidate->serialPort);
return createGreaseWeazleUsb( return createGreaseWeazleUsb(

2
lib/vfs/amigaffs.cc
View File

@@ -419,7 +419,7 @@ private:
static void onAdfWarning(char* message) static void onAdfWarning(char* message)
{ {
Logger() << message; log(message);
} }
static void onAdfError(char* message) static void onAdfError(char* message)

4
src/gui/main.cc
View File

@@ -69,11 +69,11 @@ wxThread::ExitCode FluxEngineApp::Entry()
} }
catch (const ErrorException& e) catch (const ErrorException& e)
{ {
Logger() << ErrorLogMessage{e.message + '\n'}; log(ErrorLogMessage{e.message + '\n'});
} }
catch (const EmergencyStopException& e) catch (const EmergencyStopException& e)
{ {
Logger() << EmergencyStopMessage(); log(EmergencyStopMessage());
} }
postToUiThread( postToUiThread(