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

The image writers now log to the logger.

Browse Source
This commit is contained in:
David Given
2022-02-27 00:27:44 +01:00
parent 23b9e9ef5f
commit d97e72edb6
8 changed files with 174 additions and 251 deletions
Download Patch File Download Diff File Expand all files Collapse all files

190
lib/imagereader/imagereader.cc
View File

@@ -12,149 +12,83 @@
std::unique_ptr<ImageReader> ImageReader::create(const ImageReaderProto& config)
{
switch (config.format_case())
{
case ImageReaderProto::kDim:
return ImageReader::createDimImageReader(config);
switch (config.format_case())
{
case ImageReaderProto::kDim:
return ImageReader::createDimImageReader(config);
case ImageReaderProto::kD88:
return ImageReader::createD88ImageReader(config);
case ImageReaderProto::kD88:
return ImageReader::createD88ImageReader(config);
case ImageReaderProto::kFdi:
return ImageReader::createFdiImageReader(config);
case ImageReaderProto::kFdi:
return ImageReader::createFdiImageReader(config);
case ImageReaderProto::kImd:
return ImageReader::createIMDImageReader(config);
case ImageReaderProto::kImd:
return ImageReader::createIMDImageReader(config);
case ImageReaderProto::kImg:
return ImageReader::createImgImageReader(config);
case ImageReaderProto::kImg:
return ImageReader::createImgImageReader(config);
case ImageReaderProto::kDiskcopy:
return ImageReader::createDiskCopyImageReader(config);
case ImageReaderProto::kDiskcopy:
return ImageReader::createDiskCopyImageReader(config);
case ImageReaderProto::kJv3:
return ImageReader::createJv3ImageReader(config);
case ImageReaderProto::kJv3:
return ImageReader::createJv3ImageReader(config);
case ImageReaderProto::kD64:
return ImageReader::createD64ImageReader(config);
case ImageReaderProto::kD64:
return ImageReader::createD64ImageReader(config);
case ImageReaderProto::kNfd:
return ImageReader::createNFDImageReader(config);
case ImageReaderProto::kNfd:
return ImageReader::createNFDImageReader(config);
case ImageReaderProto::kNsi:
return ImageReader::createNsiImageReader(config);
case ImageReaderProto::kNsi:
return ImageReader::createNsiImageReader(config);
case ImageReaderProto::kTd0:
return ImageReader::createTd0ImageReader(config);
case ImageReaderProto::kTd0:
return ImageReader::createTd0ImageReader(config);
default:
Error() << "bad input file config";
return std::unique_ptr<ImageReader>();
}
default:
Error() << "bad input file config";
return std::unique_ptr<ImageReader>();
}
}
void ImageReader::updateConfigForFilename(
ImageReaderProto* proto, const std::string& filename)
void ImageReader::updateConfigForFilename(ImageReaderProto* proto, const std::string& filename)
{
static const std::map<std::string, std::function<void(void)>> formats = {
{".adf",
[&]()
{
proto->mutable_img();
}},
{".d64",
[&]()
{
proto->mutable_d64();
}},
{".d81",
[&]()
{
proto->mutable_img();
}},
{".d88",
[&]()
{
proto->mutable_d88();
}},
{".dim",
[&]()
{
proto->mutable_dim();
}},
{".diskcopy",
[&]()
{
proto->mutable_diskcopy();
}},
{".dsk",
[&]()
{
proto->mutable_img();
}},
{".fdi",
[&]()
{
proto->mutable_fdi();
}},
{".imd",
[&]()
{
proto->mutable_imd();
}},
{".img",
[&]()
{
proto->mutable_img();
}},
{".jv3",
[&]()
{
proto->mutable_jv3();
}},
{".nfd",
[&]()
{
proto->mutable_nfd();
}},
{".nsi",
[&]()
{
proto->mutable_nsi();
}},
{".st",
[&]()
{
proto->mutable_img();
}},
{".td0",
[&]()
{
proto->mutable_td0();
}},
{".vgi",
[&]()
{
proto->mutable_img();
}},
{".xdf",
[&]()
{
proto->mutable_img();
}},
};
static const std::map<std::string, std::function<void(void)>> formats =
{
{".adf", [&]() { proto->mutable_img(); }},
{".d64", [&]() { proto->mutable_d64(); }},
{".d81", [&]() { proto->mutable_img(); }},
{".d88", [&]() { proto->mutable_d88(); }},
{".dim", [&]() { proto->mutable_dim(); }},
{".diskcopy", [&]() { proto->mutable_diskcopy(); }},
{".dsk", [&]() { proto->mutable_img(); }},
{".fdi", [&]() { proto->mutable_fdi(); }},
{".imd", [&]() { proto->mutable_imd(); }},
{".img", [&]() { proto->mutable_img(); }},
{".jv3", [&]() { proto->mutable_jv3(); }},
{".nfd", [&]() { proto->mutable_nfd(); }},
{".nsi", [&]() { proto->mutable_nsi(); }},
{".st", [&]() { proto->mutable_img(); }},
{".td0", [&]() { proto->mutable_td0(); }},
{".vgi", [&]() { proto->mutable_img(); }},
{".xdf", [&]() { proto->mutable_img(); }},
};
for (const auto& it : formats)
{
if (endsWith(filename, it.first))
{
it.second();
proto->set_filename(filename);
return;
}
}
for (const auto& it : formats)
{
if (endsWith(filename, it.first))
{
it.second();
proto->set_filename(filename);
return;
}
}
Error() << fmt::format("unrecognised image filename '{}'", filename);
Error() << fmt::format("unrecognised image filename '{}'", filename);
}
ImageReader::ImageReader(const ImageReaderProto& config): _config(config) {}
ImageReader::ImageReader(const ImageReaderProto& config):
_config(config)
{}

191
lib/imagereader/imdimagereader.cc
View File

@@ -11,48 +11,46 @@
#include <iostream>
#include <fstream>
static unsigned getModulationandSpeed(uint8_t flags, bool* mfm)
static unsigned getModulationandSpeed(uint8_t flags, bool *mfm)
{
switch (flags)
{
case 0: /* 500 kbps FM */
// clockRateKhz.setDefaultValue(250);
*mfm = false;
return 500;
break;
{
case 0: /* 500 kbps FM */
//clockRateKhz.setDefaultValue(250);
*mfm = false;
return 500;
break;
case 1: /* 300 kbps FM */
*mfm = false;
return 300;
case 1: /* 300 kbps FM */
*mfm = false;
return 300;
break;
break;
case 2: /* 250 kbps FM */
*mfm = false;
return 250;
break;
case 2: /* 250 kbps FM */
*mfm = false;
return 250;
break;
case 3: /* 500 kbps MFM */
*mfm = true;
return 500;
break;
case 3: /* 500 kbps MFM */
*mfm = true;
return 500;
break;
case 4: /* 300 kbps MFM */
*mfm = true;
return 300;
break;
case 4: /* 300 kbps MFM */
*mfm = true;
return 300;
break;
case 5: /* 250 kbps MFM */
*mfm = true;
return 250;
break;
case 5: /* 250 kbps MFM */
*mfm = true;
return 250;
break;
default:
Error() << fmt::format(
"don't understand IMD disks with this modulation and speed {}",
flags);
throw 0;
}
default:
Error() << fmt::format("don't understand IMD disks with this modulation and speed {}", flags);
throw 0;
}
}
struct TrackHeader
@@ -68,33 +66,30 @@ static unsigned getSectorSize(uint8_t flags)
{
switch (flags)
{
case 0:
return 128;
case 1:
return 256;
case 2:
return 512;
case 3:
return 1024;
case 4:
return 2048;
case 5:
return 4096;
case 6:
return 8192;
case 0: return 128;
case 1: return 256;
case 2: return 512;
case 3: return 1024;
case 4: return 2048;
case 5: return 4096;
case 6: return 8192;
}
Error() << "not reachable";
}
#define SEC_CYL_MAP_FLAG 0x80
#define SEC_CYL_MAP_FLAG 0x80
#define SEC_HEAD_MAP_FLAG 0x40
#define HEAD_MASK 0x3F
#define END_OF_FILE 0x1A
#define HEAD_MASK 0x3F
#define END_OF_FILE 0x1A
class IMDImageReader : public ImageReader
{
public:
IMDImageReader(const ImageReaderProto& config): ImageReader(config) {}
IMDImageReader(const ImageReaderProto& config):
ImageReader(config)
{}
std::unique_ptr<Image> readImage()
/*
@@ -104,26 +99,26 @@ public:
Comment (ASCII only - unlimited size)
1A byte - ASCII EOF character
- For each track on the disk:
1 byte Mode value see getModulationspeed for
definition 1 byte Cylinder 1 byte Head 1 byte number of sectors in track 1
byte sector size see getsectorsize for definition
1 byte Mode value see getModulationspeed for definition
1 byte Cylinder
1 byte Head
1 byte number of sectors in track
1 byte sector size see getsectorsize for definition
sector numbering map
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 <End of
file>
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
<End of file>
*/
{
// Read File
std::ifstream inputFile(
_config.filename(), std::ios::in | std::ios::binary);
//Read File
std::ifstream inputFile(_config.filename(), std::ios::in | std::ios::binary);
if (!inputFile.is_open())
Error() << "cannot open input file";
// define some variables
bool mfm = false; // define coding just to show in comment for setting
// the right write parameters
//define some variables
bool mfm = false; //define coding just to show in comment for setting the right write parameters
inputFile.seekg(0, inputFile.end);
int inputFileSize = inputFile.tellg(); // determine filesize
int inputFileSize = inputFile.tellg(); // determine filesize
inputFile.seekg(0, inputFile.beg);
Bytes data;
data.writer() += inputFile;
@@ -137,23 +132,21 @@ public:
unsigned sectorSize = 0;
std::string sector_skew;
int b;
unsigned char
comment[8192]; // i choose a fixed value. dont know how to make
// dynamic arrays in C++. This should be enough
unsigned char comment[8192]; //i choose a fixed value. dont know how to make dynamic arrays in C++. This should be enough
// Read comment
while ((b = br.read_8()) != EOF && b != 0x1A)
{
comment[n++] = (unsigned char)b;
}
headerPtr = n; // set pointer to after comment
headerPtr = n; //set pointer to after comment
comment[n] = '\0'; // null-terminate the string
// write comment to screen
Logger() << fmt::format("IMD: comment: {}", comment);
//write comment to screen
Logger() << fmt::format("IMD: comment: {}", comment);
// first read header
//first read header
for (;;)
{
if (headerPtr >= inputFileSize - 1)
if (headerPtr >= inputFileSize-1)
{
break;
}
@@ -170,26 +163,25 @@ public:
headerPtr++;
sectorSize = getSectorSize(header.SectorSize);
// Read optional cylinder map To Do
//Read optional cylinder map To Do
// Read optional sector head map To Do
//Read optional sector head map To Do
// read sector numbering map
//read sector numbering map
std::vector<unsigned> sector_map(header.numSectors);
sector_skew.clear();
for (int b = 0; b < header.numSectors; b++)
for (int b = 0; b < header.numSectors; b++)
{
sector_map[b] = br.read_8();
headerPtr++;
}
// read the sectors
//read the sectors
for (int s = 0; s < header.numSectors; s++)
{
Bytes sectordata;
const auto& sector =
image->put(header.track, header.Head, sector_map[s]);
// read the status of the sector
const auto& sector = image->put(header.track, header.Head, sector_map[s]);
//read the status of the sector
unsigned int Status_Sector = br.read_8();
headerPtr++;
@@ -204,15 +196,14 @@ public:
sector->data.writer().append(sectordata);
break;
case 2: /* Compressed: All bytes in sector have same value
(xx) */
case 2: /* Compressed: All bytes in sector have same value (xx) */
sectordata = br.read(1);
headerPtr++;
sector->data.writer().append(sectordata);
for (int k = 1; k < sectorSize; k++)
{
// fill data till sector is full
//fill data till sector is full
sector->data.writer().append(sectordata);
}
break;
@@ -224,38 +215,32 @@ public:
case 7: /* Deleted data read with data error" */
case 8: /* Compressed, Deleted read with data error" */
default:
Error() << fmt::format(
"don't understand IMD disks with sector status {}",
Status_Sector);
Error() << fmt::format("don't understand IMD disks with sector status {}", Status_Sector);
}
sector->status = Sector::OK;
sector->logicalTrack = sector->physicalCylinder = header.track;
sector->logicalSide = sector->physicalHead = header.Head;
sector->logicalSector = (sector_map[s]);
}
}
// Write format detected in IMD image to screen to help user set the
// right write parameters
image->setGeometry({.numTracks = header.track,
}
//Write format detected in IMD image to screen to help user set the right write parameters
image->setGeometry({
.numTracks = header.track,
.numSides = header.Head + 1U,
.numSectors = header.numSectors,
.sectorSize = sectorSize});
.sectorSize = sectorSize
});
size_t headSize = header.numSectors * sectorSize;
size_t trackSize = headSize * (header.Head + 1);
Logger() << fmt::format(
"IMD: {} tracks, {} heads; {}; {} kbps; {} sectors; sectorsize {};"
" sectormap {}; {} kB total\n",
header.track,
header.Head + 1,
mfm ? "MFM" : "FM",
Modulation_Speed,
header.numSectors,
sectorSize,
sector_skew,
(header.track + 1) * trackSize / 1024);
Logger() << fmt::format("IMD: {} tracks, {} heads; {}; {} kbps; {} sectors; sectorsize {};"
" sectormap {}; {} kB total\n",
header.track, header.Head + 1,
mfm ? "MFM" : "FM",
Modulation_Speed, header.numSectors, sectorSize, sector_skew, (header.track+1) * trackSize / 1024);
return image;
}

3
lib/imagewriter/d64imagewriter.cc
View File

@@ -5,6 +5,7 @@
#include "fmt/format.h"
#include "image.h"
#include "ldbs.h"
#include "logger.h"
#include "lib/config.pb.h"
#include <algorithm>
#include <iostream>
@@ -30,7 +31,7 @@ public:
void writeImage(const Image& image)
{
std::cout << "writing D64 triangular image\n";
Logger() << "D64: writing triangular image";
std::ofstream outputFile(_config.filename(), std::ios::out | std::ios::binary);
if (!outputFile.is_open())

5
lib/imagewriter/diskcopyimagewriter.cc
View File

@@ -5,6 +5,7 @@
#include "fmt/format.h"
#include "ldbs.h"
#include "image.h"
#include "logger.h"
#include "lib/config.pb.h"
#include <algorithm>
#include <iostream>
@@ -52,8 +53,8 @@ public:
Error() << "this image is not compatible with the DiskCopy 4.2 format";
}
std::cout << "writing DiskCopy 4.2 image\n"
<< fmt::format("{} tracks, {} sides, {} sectors, {} bytes per sector; {}\n",
Logger() << "DC42: writing DiskCopy 4.2 image"
<< fmt::format("DC42: {} tracks, {} sides, {} sectors, {} bytes per sector; {}",
geometry.numTracks, geometry.numSides, geometry.numSectors, geometry.sectorSize,
mfm ? "MFM" : "GCR");

3
lib/imagewriter/imgimagewriter.cc
View File

@@ -6,6 +6,7 @@
#include "lib/config.pb.h"
#include "imginputoutpututils.h"
#include "fmt/format.h"
#include "logger.h"
#include <algorithm>
#include <iostream>
#include <fstream>
@@ -56,7 +57,7 @@ public:
}
}
std::cout << fmt::format("IMG: wrote {} tracks, {} sides, {} kB total\n",
Logger() << fmt::format("IMG: wrote {} tracks, {} sides, {} kB total",
tracks, sides,
outputFile.tellp() / 1024);
}

10
lib/imagewriter/ldbsimagewriter.cc
View File

@@ -5,6 +5,7 @@
#include "fmt/format.h"
#include "ldbs.h"
#include "image.h"
#include "logger.h"
#include "lib/config.pb.h"
#include <algorithm>
#include <iostream>
@@ -23,10 +24,9 @@ public:
const Geometry geometry = image.getGeometry();
std::cout << fmt::format("LDBS: writing {} tracks, {} sides, {} sectors, {} bytes per sector",
Logger() << fmt::format("LDBS: writing {} tracks, {} sides, {} sectors, {} bytes per sector",
geometry.numTracks, geometry.numSides, geometry.numSectors,
geometry.sectorSize)
<< std::endl;
geometry.sectorSize);
Bytes trackDirectory;
ByteWriter trackDirectoryWriter(trackDirectory);
@@ -39,14 +39,14 @@ public:
dataRate = (geometry.numSectors > 10) ? LDBSOutputProto::RATE_HD : LDBSOutputProto::RATE_DD;
if (geometry.sectorSize <= 256)
dataRate = LDBSOutputProto::RATE_SD;
std::cout << fmt::format("LDBS: guessing data rate as {}\n", LDBSOutputProto::DataRate_Name(dataRate));
Logger() << fmt::format("LDBS: guessing data rate as {}", LDBSOutputProto::DataRate_Name(dataRate));
}
LDBSOutputProto::RecordingMode recordingMode = _config.ldbs().recording_mode();
if (recordingMode == LDBSOutputProto::RECMODE_GUESS)
{
recordingMode = LDBSOutputProto::RECMODE_MFM;
std::cout << fmt::format("LDBS: guessing recording mode as {}\n", LDBSOutputProto::RecordingMode_Name(recordingMode));
Logger() << fmt::format("LDBS: guessing recording mode as {}", LDBSOutputProto::RecordingMode_Name(recordingMode));
}
for (int track = 0; track < geometry.numTracks; track++)

10
lib/imagewriter/nsiimagewriter.cc
View File

@@ -5,6 +5,7 @@
#include "fmt/format.h"
#include "decoders/decoders.h"
#include "image.h"
#include "logger.h"
#include "arch/northstar/northstar.h"
#include "lib/imagewriter/imagewriter.pb.h"
#include <algorithm>
@@ -26,15 +27,14 @@ public:
size_t trackSize = geometry.numSectors * geometry.sectorSize;
if (geometry.numTracks * trackSize == 0) {
std::cout << "No sectors in output; skipping .nsi image file generation." << std::endl;
Logger() << "No sectors in output; skipping .nsi image file generation.";
return;
}
std::cout << fmt::format("Writing {} cylinders, {} sides, {} sectors, {} ({} bytes/sector), {} kB total",
Logger() << fmt::format("Writing {} cylinders, {} sides, {} sectors, {} ({} bytes/sector), {} kB total",
geometry.numTracks, geometry.numSides,
geometry.numSectors, geometry.sectorSize == 256 ? "SD" : "DD", geometry.sectorSize,
geometry.numTracks * geometry.numSides * geometry.numSectors * geometry.sectorSize / 1024)
<< std::endl;
geometry.numTracks * geometry.numSides * geometry.numSectors * geometry.sectorSize / 1024);
std::ofstream outputFile(_config.filename(), std::ios::out | std::ios::binary);
if (!outputFile.is_open())
@@ -69,7 +69,7 @@ public:
char fill[256];
memset(fill, ' ', sizeof(fill));
if (mixedDensity == false) {
std::cout << "Warning: Disk contains mixed single/double-density sectors." << std::endl;
Logger() << "Warning: Disk contains mixed single/double-density sectors.";
}
mixedDensity = true;
sector->data.slice(0, 256).writeTo(outputFile);

5
lib/imagewriter/rawimagewriter.cc
View File

@@ -5,6 +5,7 @@
#include "fmt/format.h"
#include "decoders/decoders.h"
#include "image.h"
#include "logger.h"
#include "arch/northstar/northstar.h"
#include "lib/imagewriter/imagewriter.pb.h"
#include <algorithm>
@@ -25,11 +26,11 @@ public:
size_t trackSize = geometry.numSectors * geometry.sectorSize;
if (geometry.numTracks * trackSize == 0) {
std::cout << "RAW: no sectors in output; skipping image file generation." << std::endl;
Logger() << "RAW: no sectors in output; skipping image file generation.";
return;
}
std::cout << fmt::format("RAW: writing {} cylinders, {} sides\n",
Logger() << fmt::format("RAW: writing {} cylinders, {} sides",
geometry.numTracks, geometry.numSides);
std::ofstream outputFile(_config.filename(), std::ios::out | std::ios::binary);