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

Abstract is for Java.

Browse Source
This commit is contained in:
David Given
2022-09-12 23:52:24 +02:00
parent 65a43b64ae
commit 1267191e8e
54 changed files with 217 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
arch/aeslanier/aeslanier.h
View File

@@ -5,6 +5,6 @@
#define AESLANIER_SECTOR_LENGTH 256
#define AESLANIER_RECORD_SIZE (AESLANIER_SECTOR_LENGTH + 5)
extern std::unique_ptr<AbstractDecoder> createAesLanierDecoder(const DecoderProto& config);
extern std::unique_ptr<Decoder> createAesLanierDecoder(const DecoderProto& config);
#endif

8
arch/aeslanier/decoder.cc
View File

@@ -23,11 +23,11 @@ static Bytes reverse_bits(const Bytes& input)
return output;
}
class AesLanierDecoder : public AbstractDecoder
class AesLanierDecoder : public Decoder
{
public:
AesLanierDecoder(const DecoderProto& config):
AbstractDecoder(config)
Decoder(config)
{}
nanoseconds_t advanceToNextRecord() override
@@ -68,9 +68,9 @@ public:
}
};
std::unique_ptr<AbstractDecoder> createAesLanierDecoder(const DecoderProto& config)
std::unique_ptr<Decoder> createAesLanierDecoder(const DecoderProto& config)
{
return std::unique_ptr<AbstractDecoder>(new AesLanierDecoder(config));
return std::unique_ptr<Decoder>(new AesLanierDecoder(config));
}

2
arch/agat/agat.h
View File

@@ -3,7 +3,7 @@
#define AGAT_SECTOR_SIZE 256
extern std::unique_ptr<AbstractDecoder> createAgatDecoder(const DecoderProto& config);
extern std::unique_ptr<Decoder> createAgatDecoder(const DecoderProto& config);
extern uint8_t agatChecksum(const Bytes& bytes);

8
arch/agat/decoder.cc
View File

@@ -44,11 +44,11 @@ static const FluxMatchers ALL_PATTERNS = {
&DATA_PATTERN
};
class AgatDecoder : public AbstractDecoder
class AgatDecoder : public Decoder
{
public:
AgatDecoder(const DecoderProto& config):
AbstractDecoder(config)
Decoder(config)
{}
nanoseconds_t advanceToNextRecord() override
@@ -88,9 +88,9 @@ public:
}
};
std::unique_ptr<AbstractDecoder> createAgatDecoder(const DecoderProto& config)
std::unique_ptr<Decoder> createAgatDecoder(const DecoderProto& config)
{
return std::unique_ptr<AbstractDecoder>(new AgatDecoder(config));
return std::unique_ptr<Decoder>(new AgatDecoder(config));
}

4
arch/amiga/amiga.h
View File

@@ -9,8 +9,8 @@
#define AMIGA_SECTORS_PER_TRACK 11
#define AMIGA_RECORD_SIZE 0x21c
extern std::unique_ptr<AbstractDecoder> createAmigaDecoder(const DecoderProto& config);
extern std::unique_ptr<AbstractEncoder> createAmigaEncoder(const EncoderProto& config);
extern std::unique_ptr<Decoder> createAmigaDecoder(const DecoderProto& config);
extern std::unique_ptr<Encoder> createAmigaEncoder(const EncoderProto& config);
extern uint32_t amigaChecksum(const Bytes& bytes);
extern Bytes amigaInterleave(const Bytes& input);

8
arch/amiga/decoder.cc
View File

@@ -21,11 +21,11 @@
static const FluxPattern SECTOR_PATTERN(48, AMIGA_SECTOR_RECORD);
class AmigaDecoder : public AbstractDecoder
class AmigaDecoder : public Decoder
{
public:
AmigaDecoder(const DecoderProto& config):
AbstractDecoder(config),
Decoder(config),
_config(config.amiga())
{}
@@ -79,8 +79,8 @@ private:
nanoseconds_t _clock;
};
std::unique_ptr<AbstractDecoder> createAmigaDecoder(const DecoderProto& config)
std::unique_ptr<Decoder> createAmigaDecoder(const DecoderProto& config)
{
return std::unique_ptr<AbstractDecoder>(new AmigaDecoder(config));
return std::unique_ptr<Decoder>(new AmigaDecoder(config));
}

8
arch/amiga/encoder.cc
View File

@@ -100,11 +100,11 @@ static void write_sector(std::vector<bool>& bits,
write_interleaved_bytes(data);
}
class AmigaEncoder : public AbstractEncoder
class AmigaEncoder : public Encoder
{
public:
AmigaEncoder(const EncoderProto& config):
AbstractEncoder(config),
Encoder(config),
_config(config.amiga())
{
}
@@ -164,7 +164,7 @@ private:
const AmigaEncoderProto& _config;
};
std::unique_ptr<AbstractEncoder> createAmigaEncoder(const EncoderProto& config)
std::unique_ptr<Encoder> createAmigaEncoder(const EncoderProto& config)
{
return std::unique_ptr<AbstractEncoder>(new AmigaEncoder(config));
return std::unique_ptr<Encoder>(new AmigaEncoder(config));
}

4
arch/apple2/apple2.h
View File

@@ -13,8 +13,8 @@
#define APPLE2_SECTORS 16
extern std::unique_ptr<AbstractDecoder> createApple2Decoder(const DecoderProto& config);
extern std::unique_ptr<AbstractEncoder> createApple2Encoder(const EncoderProto& config);
extern std::unique_ptr<Decoder> createApple2Decoder(const DecoderProto& config);
extern std::unique_ptr<Encoder> createApple2Encoder(const EncoderProto& config);
#endif

8
arch/apple2/decoder.cc
View File

@@ -64,11 +64,11 @@ static uint8_t combine(uint16_t word)
return word & (word >> 7);
}
class Apple2Decoder : public AbstractDecoder
class Apple2Decoder : public Decoder
{
public:
Apple2Decoder(const DecoderProto& config):
AbstractDecoder(config)
Decoder(config)
{}
nanoseconds_t advanceToNextRecord() override
@@ -154,9 +154,9 @@ public:
}
};
std::unique_ptr<AbstractDecoder> createApple2Decoder(const DecoderProto& config)
std::unique_ptr<Decoder> createApple2Decoder(const DecoderProto& config)
{
return std::unique_ptr<AbstractDecoder>(new Apple2Decoder(config));
return std::unique_ptr<Decoder>(new Apple2Decoder(config));
}

8
arch/apple2/encoder.cc
View File

@@ -23,11 +23,11 @@ static int encode_data_gcr(uint8_t data)
return -1;
}
class Apple2Encoder : public AbstractEncoder
class Apple2Encoder : public Encoder
{
public:
Apple2Encoder(const EncoderProto& config):
AbstractEncoder(config),
Encoder(config),
_config(config.apple2())
{
}
@@ -203,7 +203,7 @@ private:
}
};
std::unique_ptr<AbstractEncoder> createApple2Encoder(const EncoderProto& config)
std::unique_ptr<Encoder> createApple2Encoder(const EncoderProto& config)
{
return std::unique_ptr<AbstractEncoder>(new Apple2Encoder(config));
return std::unique_ptr<Encoder>(new Apple2Encoder(config));
}

4
arch/brother/brother.h
View File

@@ -13,7 +13,7 @@
#define BROTHER_TRACKS_PER_120KB_DISK 39
#define BROTHER_SECTORS_PER_TRACK 12
extern std::unique_ptr<AbstractDecoder> createBrotherDecoder(const DecoderProto& config);
extern std::unique_ptr<AbstractEncoder> createBrotherEncoder(const EncoderProto& config);
extern std::unique_ptr<Decoder> createBrotherDecoder(const DecoderProto& config);
extern std::unique_ptr<Encoder> createBrotherEncoder(const EncoderProto& config);
#endif

8
arch/brother/decoder.cc
View File

@@ -52,11 +52,11 @@ static int decode_header_gcr(uint16_t word)
return -1;
}
class BrotherDecoder : public AbstractDecoder
class BrotherDecoder : public Decoder
{
public:
BrotherDecoder(const DecoderProto& config):
AbstractDecoder(config)
Decoder(config)
{}
nanoseconds_t advanceToNextRecord() override
@@ -111,9 +111,9 @@ public:
}
};
std::unique_ptr<AbstractDecoder> createBrotherDecoder(const DecoderProto& config)
std::unique_ptr<Decoder> createBrotherDecoder(const DecoderProto& config)
{
return std::unique_ptr<AbstractDecoder>(new BrotherDecoder(config));
return std::unique_ptr<Decoder>(new BrotherDecoder(config));
}

8
arch/brother/encoder.cc
View File

@@ -104,11 +104,11 @@ static int charToInt(char c)
return 10 + tolower(c) - 'a';
}
class BrotherEncoder : public AbstractEncoder
class BrotherEncoder : public Encoder
{
public:
BrotherEncoder(const EncoderProto& config):
AbstractEncoder(config),
Encoder(config),
_config(config.brother())
{
}
@@ -189,8 +189,8 @@ private:
const BrotherEncoderProto& _config;
};
std::unique_ptr<AbstractEncoder> createBrotherEncoder(
std::unique_ptr<Encoder> createBrotherEncoder(
const EncoderProto& config)
{
return std::unique_ptr<AbstractEncoder>(new BrotherEncoder(config));
return std::unique_ptr<Encoder>(new BrotherEncoder(config));
}

4
arch/c64/c64.h
View File

@@ -27,8 +27,8 @@
#define C64_TRACKS_PER_DISK 40
#define C64_BAM_TRACK 17
extern std::unique_ptr<AbstractDecoder> createCommodore64Decoder(const DecoderProto& config);
extern std::unique_ptr<AbstractEncoder> createCommodore64Encoder(const EncoderProto& config);
extern std::unique_ptr<Decoder> createCommodore64Decoder(const DecoderProto& config);
extern std::unique_ptr<Encoder> createCommodore64Encoder(const EncoderProto& config);
extern unsigned sectorsForC64Track(unsigned track);
extern nanoseconds_t clockPeriodForC64Track(unsigned track);

8
arch/c64/decoder.cc
View File

@@ -53,10 +53,10 @@ static Bytes decode(const std::vector<bool>& bits)
return output;
}
class Commodore64Decoder : public AbstractDecoder
class Commodore64Decoder : public Decoder
{
public:
Commodore64Decoder(const DecoderProto& config): AbstractDecoder(config) {}
Commodore64Decoder(const DecoderProto& config): Decoder(config) {}
nanoseconds_t advanceToNextRecord() override
{
@@ -105,8 +105,8 @@ public:
}
};
std::unique_ptr<AbstractDecoder> createCommodore64Decoder(
std::unique_ptr<Decoder> createCommodore64Decoder(
const DecoderProto& config)
{
return std::unique_ptr<AbstractDecoder>(new Commodore64Decoder(config));
return std::unique_ptr<Decoder>(new Commodore64Decoder(config));
}

8
arch/c64/encoder.cc
View File

@@ -162,11 +162,11 @@ static std::vector<bool> encode_data(uint8_t input)
return output;
}
class Commodore64Encoder : public AbstractEncoder
class Commodore64Encoder : public Encoder
{
public:
Commodore64Encoder(const EncoderProto& config):
AbstractEncoder(config),
Encoder(config),
_config(config.c64())
{}
@@ -327,9 +327,9 @@ private:
uint8_t _formatByte2;
};
std::unique_ptr<AbstractEncoder> createCommodore64Encoder(const EncoderProto& config)
std::unique_ptr<Encoder> createCommodore64Encoder(const EncoderProto& config)
{
return std::unique_ptr<AbstractEncoder>(new Commodore64Encoder(config));
return std::unique_ptr<Encoder>(new Commodore64Encoder(config));
}
// vim: sw=4 ts=4 et

8
arch/f85/decoder.cc
View File

@@ -51,11 +51,11 @@ static Bytes decode(const std::vector<bool>& bits)
return output;
}
class DurangoF85Decoder : public AbstractDecoder
class DurangoF85Decoder : public Decoder
{
public:
DurangoF85Decoder(const DecoderProto& config):
AbstractDecoder(config)
Decoder(config)
{}
nanoseconds_t advanceToNextRecord() override
@@ -102,8 +102,8 @@ public:
}
};
std::unique_ptr<AbstractDecoder> createDurangoF85Decoder(const DecoderProto& config)
std::unique_ptr<Decoder> createDurangoF85Decoder(const DecoderProto& config)
{
return std::unique_ptr<AbstractDecoder>(new DurangoF85Decoder(config));
return std::unique_ptr<Decoder>(new DurangoF85Decoder(config));
}

2
arch/f85/f85.h
View File

@@ -5,6 +5,6 @@
#define F85_DATA_RECORD 0xffffcb /* 1111 1111 1111 1111 1100 1101 */
#define F85_SECTOR_LENGTH 512
extern std::unique_ptr<AbstractDecoder> createDurangoF85Decoder(const DecoderProto& config);
extern std::unique_ptr<Decoder> createDurangoF85Decoder(const DecoderProto& config);
#endif

8
arch/fb100/decoder.cc
View File

@@ -97,11 +97,11 @@ static uint16_t checksum(const Bytes& bytes)
return (crchi << 8) | crclo;
}
class Fb100Decoder : public AbstractDecoder
class Fb100Decoder : public Decoder
{
public:
Fb100Decoder(const DecoderProto& config):
AbstractDecoder(config)
Decoder(config)
{}
nanoseconds_t advanceToNextRecord() override
@@ -136,9 +136,9 @@ public:
}
};
std::unique_ptr<AbstractDecoder> createFb100Decoder(const DecoderProto& config)
std::unique_ptr<Decoder> createFb100Decoder(const DecoderProto& config)
{
return std::unique_ptr<AbstractDecoder>(new Fb100Decoder(config));
return std::unique_ptr<Decoder>(new Fb100Decoder(config));
}

2
arch/fb100/fb100.h
View File

@@ -5,7 +5,7 @@
#define FB100_ID_SIZE 17
#define FB100_PAYLOAD_SIZE 0x500
extern std::unique_ptr<AbstractDecoder> createFb100Decoder(const DecoderProto& config);
extern std::unique_ptr<Decoder> createFb100Decoder(const DecoderProto& config);
#endif

8
arch/ibm/decoder.cc
View File

@@ -89,11 +89,11 @@ const FluxMatchers ANY_RECORD_PATTERN({
&FM_TRS80DAM2_PATTERN,
});
class IbmDecoder : public AbstractDecoder
class IbmDecoder : public Decoder
{
public:
IbmDecoder(const DecoderProto& config):
AbstractDecoder(config),
Decoder(config),
_config(config.ibm())
{
}
@@ -238,7 +238,7 @@ private:
unsigned _currentHeaderLength;
};
std::unique_ptr<AbstractDecoder> createIbmDecoder(const DecoderProto& config)
std::unique_ptr<Decoder> createIbmDecoder(const DecoderProto& config)
{
return std::unique_ptr<AbstractDecoder>(new IbmDecoder(config));
return std::unique_ptr<Decoder>(new IbmDecoder(config));
}

10
arch/ibm/encoder.cc
View File

@@ -67,11 +67,11 @@ static uint8_t decodeUint16(uint16_t raw)
return decodeFmMfm(b.toBits())[0];
}
class IbmEncoder : public AbstractEncoder
class IbmEncoder : public Encoder
{
public:
IbmEncoder(const EncoderProto& config):
AbstractEncoder(config),
Encoder(config),
_config(config.ibm())
{
}
@@ -118,7 +118,7 @@ public:
Location newLocation = location;
newLocation.head ^= 1;
auto sector = std::make_shared<Sector>(
*AbstractEncoder::getSector(newLocation, image, sectorId));
*Encoder::getSector(newLocation, image, sectorId));
sector->logicalSide ^= 1;
return sector;
}
@@ -293,7 +293,7 @@ private:
bool _lastBit;
};
std::unique_ptr<AbstractEncoder> createIbmEncoder(const EncoderProto& config)
std::unique_ptr<Encoder> createIbmEncoder(const EncoderProto& config)
{
return std::unique_ptr<AbstractEncoder>(new IbmEncoder(config));
return std::unique_ptr<Encoder>(new IbmEncoder(config));
}

8
arch/ibm/ibm.h
View File

@@ -26,14 +26,14 @@ struct IbmIdam
uint8_t crc[2];
};
class AbstractEncoder;
class AbstractDecoder;
class Encoder;
class Decoder;
class DecoderProto;
class EncoderProto;
extern std::unique_ptr<AbstractDecoder> createIbmDecoder(
extern std::unique_ptr<Decoder> createIbmDecoder(
const DecoderProto& config);
extern std::unique_ptr<AbstractEncoder> createIbmEncoder(
extern std::unique_ptr<Encoder> createIbmEncoder(
const EncoderProto& config);
#endif

8
arch/macintosh/decoder.cc
View File

@@ -122,11 +122,11 @@ uint8_t decode_side(uint8_t side)
return !!(side & 0x20);
}
class MacintoshDecoder : public AbstractDecoder
class MacintoshDecoder : public Decoder
{
public:
MacintoshDecoder(const DecoderProto& config):
AbstractDecoder(config)
Decoder(config)
{}
nanoseconds_t advanceToNextRecord() override
@@ -206,8 +206,8 @@ public:
}
};
std::unique_ptr<AbstractDecoder> createMacintoshDecoder(const DecoderProto& config)
std::unique_ptr<Decoder> createMacintoshDecoder(const DecoderProto& config)
{
return std::unique_ptr<AbstractDecoder>(new MacintoshDecoder(config));
return std::unique_ptr<Decoder>(new MacintoshDecoder(config));
}

8
arch/macintosh/encoder.cc
View File

@@ -209,11 +209,11 @@ static void write_sector(std::vector<bool>& bits,
write_bits(bits, cursor, 0xdeaaff, 3 * 8);
}
class MacintoshEncoder : public AbstractEncoder
class MacintoshEncoder : public Encoder
{
public:
MacintoshEncoder(const EncoderProto& config):
AbstractEncoder(config),
Encoder(config),
_config(config.macintosh())
{
}
@@ -273,8 +273,8 @@ private:
const MacintoshEncoderProto& _config;
};
std::unique_ptr<AbstractEncoder> createMacintoshEncoder(
std::unique_ptr<Encoder> createMacintoshEncoder(
const EncoderProto& config)
{
return std::unique_ptr<AbstractEncoder>(new MacintoshEncoder(config));
return std::unique_ptr<Encoder>(new MacintoshEncoder(config));
}

8
arch/macintosh/macintosh.h
View File

@@ -10,13 +10,13 @@
#define MAC_TRACKS_PER_DISK 80
class AbstractEncoder;
class AbstractDecoder;
class Encoder;
class Decoder;
class DecoderProto;
class EncoderProto;
extern std::unique_ptr<AbstractDecoder> createMacintoshDecoder(const DecoderProto& config);
extern std::unique_ptr<AbstractEncoder> createMacintoshEncoder(const EncoderProto& config);
extern std::unique_ptr<Decoder> createMacintoshDecoder(const DecoderProto& config);
extern std::unique_ptr<Encoder> createMacintoshEncoder(const EncoderProto& config);
#endif

8
arch/micropolis/decoder.cc
View File

@@ -54,11 +54,11 @@ uint8_t mzosChecksum(const Bytes& bytes) {
return checksum;
}
class MicropolisDecoder : public AbstractDecoder
class MicropolisDecoder : public Decoder
{
public:
MicropolisDecoder(const DecoderProto& config):
AbstractDecoder(config),
Decoder(config),
_config(config.micropolis())
{
_checksumType = _config.checksum_type();
@@ -184,8 +184,8 @@ private:
MicropolisDecoderProto_ChecksumType _checksumType; /* -1 = auto, 1 = Micropolis, 2=MZOS */
};
std::unique_ptr<AbstractDecoder> createMicropolisDecoder(const DecoderProto& config)
std::unique_ptr<Decoder> createMicropolisDecoder(const DecoderProto& config)
{
return std::unique_ptr<AbstractDecoder>(new MicropolisDecoder(config));
return std::unique_ptr<Decoder>(new MicropolisDecoder(config));
}

8
arch/micropolis/encoder.cc
View File

@@ -68,11 +68,11 @@ static void write_sector(std::vector<bool>& bits,
}
}
class MicropolisEncoder : public AbstractEncoder
class MicropolisEncoder : public Encoder
{
public:
MicropolisEncoder(const EncoderProto& config):
AbstractEncoder(config),
Encoder(config),
_config(config.micropolis())
{
}
@@ -124,8 +124,8 @@ private:
const MicropolisEncoderProto& _config;
};
std::unique_ptr<AbstractEncoder> createMicropolisEncoder(
std::unique_ptr<Encoder> createMicropolisEncoder(
const EncoderProto& config)
{
return std::unique_ptr<AbstractEncoder>(new MicropolisEncoder(config));
return std::unique_ptr<Encoder>(new MicropolisEncoder(config));
}

8
arch/micropolis/micropolis.h
View File

@@ -5,13 +5,13 @@
#define MICROPOLIS_HEADER_SIZE (1+2+10)
#define MICROPOLIS_ENCODED_SECTOR_SIZE (MICROPOLIS_HEADER_SIZE + MICROPOLIS_PAYLOAD_SIZE + 6)
class AbstractDecoder;
class AbstractEncoder;
class Decoder;
class Encoder;
class EncoderProto;
class DecoderProto;
extern std::unique_ptr<AbstractDecoder> createMicropolisDecoder(const DecoderProto& config);
extern std::unique_ptr<AbstractEncoder> createMicropolisEncoder(const EncoderProto& config);
extern std::unique_ptr<Decoder> createMicropolisDecoder(const DecoderProto& config);
extern std::unique_ptr<Encoder> createMicropolisEncoder(const EncoderProto& config);
extern uint8_t micropolisChecksum(const Bytes& bytes);

8
arch/mx/decoder.cc
View File

@@ -23,11 +23,11 @@ const int SECTOR_SIZE = 256;
*/
const FluxPattern ID_PATTERN(32, 0xaaaaffaf);
class MxDecoder : public AbstractDecoder
class MxDecoder : public Decoder
{
public:
MxDecoder(const DecoderProto& config):
AbstractDecoder(config)
Decoder(config)
{}
void beginTrack() override
@@ -78,9 +78,9 @@ private:
int _currentSector;
};
std::unique_ptr<AbstractDecoder> createMxDecoder(const DecoderProto& config)
std::unique_ptr<Decoder> createMxDecoder(const DecoderProto& config)
{
return std::unique_ptr<AbstractDecoder>(new MxDecoder(config));
return std::unique_ptr<Decoder>(new MxDecoder(config));
}

2
arch/mx/mx.h
View File

@@ -3,6 +3,6 @@
#include "decoders/decoders.h"
extern std::unique_ptr<AbstractDecoder> createMxDecoder(const DecoderProto& config);
extern std::unique_ptr<Decoder> createMxDecoder(const DecoderProto& config);
#endif

8
arch/northstar/decoder.cc
View File

@@ -67,11 +67,11 @@ uint8_t northstarChecksum(const Bytes& bytes) {
return checksum;
}
class NorthstarDecoder : public AbstractDecoder
class NorthstarDecoder : public Decoder
{
public:
NorthstarDecoder(const DecoderProto& config):
AbstractDecoder(config),
Decoder(config),
_config(config.northstar())
{}
@@ -175,8 +175,8 @@ private:
uint8_t _hardSectorId;
};
std::unique_ptr<AbstractDecoder> createNorthstarDecoder(const DecoderProto& config)
std::unique_ptr<Decoder> createNorthstarDecoder(const DecoderProto& config)
{
return std::unique_ptr<AbstractDecoder>(new NorthstarDecoder(config));
return std::unique_ptr<Decoder>(new NorthstarDecoder(config));
}

8
arch/northstar/encoder.cc
View File

@@ -119,11 +119,11 @@ static void write_sector(std::vector<bool>& bits,
}
}
class NorthstarEncoder : public AbstractEncoder
class NorthstarEncoder : public Encoder
{
public:
NorthstarEncoder(const EncoderProto& config):
AbstractEncoder(config),
Encoder(config),
_config(config.northstar())
{
}
@@ -180,8 +180,8 @@ private:
const NorthstarEncoderProto& _config;
};
std::unique_ptr<AbstractEncoder> createNorthstarEncoder(
std::unique_ptr<Encoder> createNorthstarEncoder(
const EncoderProto& config)
{
return std::unique_ptr<AbstractEncoder>(new NorthstarEncoder(config));
return std::unique_ptr<Encoder>(new NorthstarEncoder(config));
}

8
arch/northstar/northstar.h
View File

@@ -22,14 +22,14 @@
#define NORTHSTAR_ENCODED_SECTOR_SIZE_SD (NORTHSTAR_HEADER_SIZE_SD + NORTHSTAR_PAYLOAD_SIZE_SD + NORTHSTAR_CHECKSUM_SIZE)
#define NORTHSTAR_ENCODED_SECTOR_SIZE_DD (NORTHSTAR_HEADER_SIZE_DD + NORTHSTAR_PAYLOAD_SIZE_DD + NORTHSTAR_CHECKSUM_SIZE)
class AbstractDecoder;
class AbstractEncoder;
class Decoder;
class Encoder;
class EncoderProto;
class DecoderProto;
extern uint8_t northstarChecksum(const Bytes& bytes);
extern std::unique_ptr<AbstractDecoder> createNorthstarDecoder(const DecoderProto& config);
extern std::unique_ptr<AbstractEncoder> createNorthstarEncoder(const EncoderProto& config);
extern std::unique_ptr<Decoder> createNorthstarDecoder(const DecoderProto& config);
extern std::unique_ptr<Encoder> createNorthstarEncoder(const EncoderProto& config);
#endif /* NORTHSTAR */

8
arch/tids990/decoder.cc
View File

@@ -40,11 +40,11 @@ const FluxPattern DATA_RECORD_PATTERN(32, 0x11112245);
const FluxMatchers ANY_RECORD_PATTERN({ &SECTOR_RECORD_PATTERN, &DATA_RECORD_PATTERN });
class Tids990Decoder : public AbstractDecoder
class Tids990Decoder : public Decoder
{
public:
Tids990Decoder(const DecoderProto& config):
AbstractDecoder(config)
Decoder(config)
{}
nanoseconds_t advanceToNextRecord() override
@@ -91,8 +91,8 @@ public:
}
};
std::unique_ptr<AbstractDecoder> createTids990Decoder(const DecoderProto& config)
std::unique_ptr<Decoder> createTids990Decoder(const DecoderProto& config)
{
return std::unique_ptr<AbstractDecoder>(new Tids990Decoder(config));
return std::unique_ptr<Decoder>(new Tids990Decoder(config));
}

8
arch/tids990/encoder.cc
View File

@@ -24,11 +24,11 @@ static uint8_t decodeUint16(uint16_t raw)
return decodeFmMfm(b.toBits())[0];
}
class Tids990Encoder : public AbstractEncoder
class Tids990Encoder : public Encoder
{
public:
Tids990Encoder(const EncoderProto& config):
AbstractEncoder(config),
Encoder(config),
_config(config.tids990())
{
}
@@ -162,8 +162,8 @@ private:
bool _lastBit;
};
std::unique_ptr<AbstractEncoder> createTids990Encoder(
std::unique_ptr<Encoder> createTids990Encoder(
const EncoderProto& config)
{
return std::unique_ptr<AbstractEncoder>(new Tids990Encoder(config));
return std::unique_ptr<Encoder>(new Tids990Encoder(config));
}

8
arch/tids990/tids990.h
View File

@@ -5,13 +5,13 @@
#define TIDS990_SECTOR_RECORD_SIZE 10 /* bytes */
#define TIDS990_DATA_RECORD_SIZE (TIDS990_PAYLOAD_SIZE + 4) /* bytes */
class AbstractEncoder;
class AbstractDecoder;
class Encoder;
class Decoder;
class DecoderProto;
class EncoderProto;
extern std::unique_ptr<AbstractDecoder> createTids990Decoder(const DecoderProto& config);
extern std::unique_ptr<AbstractEncoder> createTids990Encoder(const EncoderProto& config);
extern std::unique_ptr<Decoder> createTids990Decoder(const DecoderProto& config);
extern std::unique_ptr<Encoder> createTids990Encoder(const EncoderProto& config);
#endif

8
arch/victor9k/decoder.cc
View File

@@ -52,11 +52,11 @@ static Bytes decode(const std::vector<bool>& bits)
return output;
}
class Victor9kDecoder : public AbstractDecoder
class Victor9kDecoder : public Decoder
{
public:
Victor9kDecoder(const DecoderProto& config):
AbstractDecoder(config)
Decoder(config)
{}
nanoseconds_t advanceToNextRecord() override
@@ -109,9 +109,9 @@ public:
}
};
std::unique_ptr<AbstractDecoder> createVictor9kDecoder(const DecoderProto& config)
std::unique_ptr<Decoder> createVictor9kDecoder(const DecoderProto& config)
{
return std::unique_ptr<AbstractDecoder>(new Victor9kDecoder(config));
return std::unique_ptr<Decoder>(new Victor9kDecoder(config));
}

8
arch/victor9k/encoder.cc
View File

@@ -134,11 +134,11 @@ static void write_sector(std::vector<bool>& bits,
write_gap(bits, cursor, trackdata.post_data_gap_bits());
}
class Victor9kEncoder : public AbstractEncoder
class Victor9kEncoder : public Encoder
{
public:
Victor9kEncoder(const EncoderProto& config):
AbstractEncoder(config),
Encoder(config),
_config(config.victor9k())
{
}
@@ -221,10 +221,10 @@ private:
const Victor9kEncoderProto& _config;
};
std::unique_ptr<AbstractEncoder> createVictor9kEncoder(
std::unique_ptr<Encoder> createVictor9kEncoder(
const EncoderProto& config)
{
return std::unique_ptr<AbstractEncoder>(new Victor9kEncoder(config));
return std::unique_ptr<Encoder>(new Victor9kEncoder(config));
}
// vim: sw=4 ts=4 et

8
arch/victor9k/victor9k.h
View File

@@ -1,8 +1,8 @@
#ifndef VICTOR9K_H
#define VICTOR9K_H
class AbstractEncoder;
class AbstractDecoder;
class Encoder;
class Decoder;
class EncoderProto;
class DecoderProto;
@@ -18,7 +18,7 @@ class DecoderProto;
#define VICTOR9K_SECTOR_LENGTH 512
extern std::unique_ptr<AbstractDecoder> createVictor9kDecoder(const DecoderProto& config);
extern std::unique_ptr<AbstractEncoder> createVictor9kEncoder(const EncoderProto& config);
extern std::unique_ptr<Decoder> createVictor9kDecoder(const DecoderProto& config);
extern std::unique_ptr<Encoder> createVictor9kEncoder(const EncoderProto& config);
#endif

8
arch/zilogmcz/decoder.cc
View File

@@ -13,11 +13,11 @@
static const FluxPattern SECTOR_START_PATTERN(16, 0xaaab);
class ZilogMczDecoder : public AbstractDecoder
class ZilogMczDecoder : public Decoder
{
public:
ZilogMczDecoder(const DecoderProto& config):
AbstractDecoder(config)
Decoder(config)
{}
nanoseconds_t advanceToNextRecord() override
@@ -50,8 +50,8 @@ public:
}
};
std::unique_ptr<AbstractDecoder> createZilogMczDecoder(const DecoderProto& config)
std::unique_ptr<Decoder> createZilogMczDecoder(const DecoderProto& config)
{
return std::unique_ptr<AbstractDecoder>(new ZilogMczDecoder(config));
return std::unique_ptr<Decoder>(new ZilogMczDecoder(config));
}

2
arch/zilogmcz/zilogmcz.h
View File

@@ -1,7 +1,7 @@
#ifndef ZILOGMCZ_H
#define ZILOGMCZ_H
extern std::unique_ptr<AbstractDecoder> createZilogMczDecoder(const DecoderProto& config);
extern std::unique_ptr<Decoder> createZilogMczDecoder(const DecoderProto& config);
#endif

32
lib/decoders/decoders.cc
View File

@@ -30,10 +30,10 @@
#include "fmt/format.h"
#include <numeric>
std::unique_ptr<AbstractDecoder> AbstractDecoder::create(const DecoderProto& config)
std::unique_ptr<Decoder> Decoder::create(const DecoderProto& config)
{
static const std::map<int,
std::function<std::unique_ptr<AbstractDecoder>(const DecoderProto&)>> decoders =
std::function<std::unique_ptr<Decoder>(const DecoderProto&)>> decoders =
{
{ DecoderProto::kAgat, createAgatDecoder },
{ DecoderProto::kAeslanier, createAesLanierDecoder },
@@ -60,7 +60,7 @@ std::unique_ptr<AbstractDecoder> AbstractDecoder::create(const DecoderProto& con
return (decoder->second)(config);
}
std::shared_ptr<const TrackDataFlux> AbstractDecoder::decodeToSectors(
std::shared_ptr<const TrackDataFlux> Decoder::decodeToSectors(
std::shared_ptr<const Fluxmap> fluxmap, const Location& location)
{
_trackdata = std::make_shared<TrackDataFlux>();
@@ -142,7 +142,7 @@ std::shared_ptr<const TrackDataFlux> AbstractDecoder::decodeToSectors(
}
}
void AbstractDecoder::pushRecord(const Fluxmap::Position& start, const Fluxmap::Position& end)
void Decoder::pushRecord(const Fluxmap::Position& start, const Fluxmap::Position& end)
{
Fluxmap::Position here = _fmr->tell();
@@ -158,42 +158,42 @@ void AbstractDecoder::pushRecord(const Fluxmap::Position& start, const Fluxmap::
_recordBits.clear();
}
void AbstractDecoder::resetFluxDecoder()
void Decoder::resetFluxDecoder()
{
_decoder.reset(new FluxDecoder(_fmr, _sector->clock, _config));
}
nanoseconds_t AbstractDecoder::seekToPattern(const FluxMatcher& pattern)
nanoseconds_t Decoder::seekToPattern(const FluxMatcher& pattern)
{
nanoseconds_t clock = _fmr->seekToPattern(pattern);
_decoder.reset(new FluxDecoder(_fmr, clock, _config));
return clock;
}
void AbstractDecoder::seekToIndexMark()
void Decoder::seekToIndexMark()
{
_fmr->skipToEvent(F_BIT_PULSE);
_fmr->seekToIndexMark();
}
std::vector<bool> AbstractDecoder::readRawBits(unsigned count)
std::vector<bool> Decoder::readRawBits(unsigned count)
{
auto bits = _decoder->readBits(count);
_recordBits.insert(_recordBits.end(), bits.begin(), bits.end());
return bits;
}
uint8_t AbstractDecoder::readRaw8()
uint8_t Decoder::readRaw8()
{
return toBytes(readRawBits(8)).reader().read_8();
}
uint16_t AbstractDecoder::readRaw16()
uint16_t Decoder::readRaw16()
{
return toBytes(readRawBits(16)).reader().read_be16();
}
uint32_t AbstractDecoder::readRaw20()
uint32_t Decoder::readRaw20()
{
std::vector<bool> bits(4);
for (bool b : readRawBits(20))
@@ -202,28 +202,28 @@ uint32_t AbstractDecoder::readRaw20()
return toBytes(bits).reader().read_be24();
}
uint32_t AbstractDecoder::readRaw24()
uint32_t Decoder::readRaw24()
{
return toBytes(readRawBits(24)).reader().read_be24();
}
uint32_t AbstractDecoder::readRaw32()
uint32_t Decoder::readRaw32()
{
return toBytes(readRawBits(32)).reader().read_be32();
}
uint64_t AbstractDecoder::readRaw48()
uint64_t Decoder::readRaw48()
{
return toBytes(readRawBits(48)).reader().read_be48();
}
uint64_t AbstractDecoder::readRaw64()
uint64_t Decoder::readRaw64()
{
return toBytes(readRawBits(64)).reader().read_be64();
}
std::set<unsigned> AbstractDecoder::requiredSectors(const Location& location) const
std::set<unsigned> Decoder::requiredSectors(const Location& location) const
{
static std::set<unsigned> set;
return set;

8
lib/decoders/decoders.h
View File

@@ -31,14 +31,14 @@ static inline Bytes decodeFmMfm(const std::vector<bool> bits)
return decodeFmMfm(bits.begin(), bits.end());
}
class AbstractDecoder
class Decoder
{
public:
AbstractDecoder(const DecoderProto& config): _config(config) {}
Decoder(const DecoderProto& config): _config(config) {}
virtual ~AbstractDecoder() {}
virtual ~Decoder() {}
static std::unique_ptr<AbstractDecoder> create(const DecoderProto& config);
static std::unique_ptr<Decoder> create(const DecoderProto& config);
public:
enum RecordType

10
lib/encoders/encoders.cc
View File

@@ -18,11 +18,11 @@
#include "lib/image.h"
#include "protocol.h"
std::unique_ptr<AbstractEncoder> AbstractEncoder::create(
std::unique_ptr<Encoder> Encoder::create(
const EncoderProto& config)
{
static const std::map<int,
std::function<std::unique_ptr<AbstractEncoder>(const EncoderProto&)>>
std::function<std::unique_ptr<Encoder>(const EncoderProto&)>>
encoders = {
{EncoderProto::kAmiga, createAmigaEncoder },
{EncoderProto::kApple2, createApple2Encoder },
@@ -43,7 +43,7 @@ std::unique_ptr<AbstractEncoder> AbstractEncoder::create(
return (encoder->second)(config);
}
nanoseconds_t AbstractEncoder::calculatePhysicalClockPeriod(
nanoseconds_t Encoder::calculatePhysicalClockPeriod(
nanoseconds_t targetClockPeriod, nanoseconds_t targetRotationalPeriod)
{
nanoseconds_t currentRotationalPeriod =
@@ -56,13 +56,13 @@ nanoseconds_t AbstractEncoder::calculatePhysicalClockPeriod(
(currentRotationalPeriod / targetRotationalPeriod);
}
std::shared_ptr<const Sector> AbstractEncoder::getSector(
std::shared_ptr<const Sector> Encoder::getSector(
const Location& location, const Image& image, unsigned sectorId)
{
return image.get(location.logicalTrack, location.head, sectorId);
}
std::vector<std::shared_ptr<const Sector>> AbstractEncoder::collectSectors(
std::vector<std::shared_ptr<const Sector>> Encoder::collectSectors(
const Location& location, const Image& image)
{
std::vector<std::shared_ptr<const Sector>> sectors;

8
lib/encoders/encoders.h
View File

@@ -7,13 +7,13 @@ class Image;
class Location;
class Sector;
class AbstractEncoder
class Encoder
{
public:
AbstractEncoder(const EncoderProto& config) {}
virtual ~AbstractEncoder() {}
Encoder(const EncoderProto& config) {}
virtual ~Encoder() {}
static std::unique_ptr<AbstractEncoder> create(const EncoderProto& config);
static std::unique_ptr<Encoder> create(const EncoderProto& config);
public:
virtual std::shared_ptr<const Sector> getSector(

24
lib/readerwriter.cc
View File

@@ -155,7 +155,7 @@ static std::set<std::shared_ptr<const Sector>> collectSectors(
}
BadSectorsState combineRecordAndSectors(
TrackFlux& trackFlux, AbstractDecoder& decoder, const Location& location)
TrackFlux& trackFlux, Decoder& decoder, const Location& location)
{
std::set<std::shared_ptr<const Sector>> track_sectors;
@@ -184,7 +184,7 @@ BadSectorsState combineRecordAndSectors(
ReadResult readGroup(FluxSourceIteratorHolder& fluxSourceIteratorHolder,
const Location& location,
TrackFlux& trackFlux,
AbstractDecoder& decoder)
Decoder& decoder)
{
ReadResult result = BAD_AND_CAN_NOT_RETRY;
@@ -290,7 +290,7 @@ void writeTracks(FluxSink& fluxSink,
}
void writeTracks(FluxSink& fluxSink,
AbstractEncoder& encoder,
Encoder& encoder,
const Image& image,
const std::set<Location>& locations)
{
@@ -306,9 +306,9 @@ void writeTracks(FluxSink& fluxSink,
}
void writeTracksAndVerify(FluxSink& fluxSink,
AbstractEncoder& encoder,
Encoder& encoder,
FluxSource& fluxSource,
AbstractDecoder& decoder,
Decoder& decoder,
const Image& image,
const std::set<Location>& locations)
{
@@ -372,9 +372,9 @@ void writeTracksAndVerify(FluxSink& fluxSink,
}
void writeDiskCommand(const Image& image,
AbstractEncoder& encoder,
Encoder& encoder,
FluxSink& fluxSink,
AbstractDecoder* decoder,
Decoder* decoder,
FluxSource* fluxSource,
const std::set<Location>& locations)
{
@@ -386,9 +386,9 @@ void writeDiskCommand(const Image& image,
}
void writeDiskCommand(const Image& image,
AbstractEncoder& encoder,
Encoder& encoder,
FluxSink& fluxSink,
AbstractDecoder* decoder,
Decoder* decoder,
FluxSource* fluxSource)
{
auto locations = Layout::computeLocations();
@@ -409,7 +409,7 @@ void writeRawDiskCommand(FluxSource& fluxSource, FluxSink& fluxSink)
}
std::shared_ptr<TrackFlux> readAndDecodeTrack(
FluxSource& fluxSource, AbstractDecoder& decoder, const Location& location)
FluxSource& fluxSource, Decoder& decoder, const Location& location)
{
auto trackFlux = std::make_shared<TrackFlux>();
trackFlux->location = location;
@@ -443,7 +443,7 @@ std::shared_ptr<TrackFlux> readAndDecodeTrack(
}
std::shared_ptr<const DiskFlux> readDiskCommand(
FluxSource& fluxSource, AbstractDecoder& decoder)
FluxSource& fluxSource, Decoder& decoder)
{
std::unique_ptr<FluxSink> outputFluxSink;
if (config.decoder().has_copy_flux_to())
@@ -546,7 +546,7 @@ std::shared_ptr<const DiskFlux> readDiskCommand(
}
void readDiskCommand(
FluxSource& fluxsource, AbstractDecoder& decoder, ImageWriter& writer)
FluxSource& fluxsource, Decoder& decoder, ImageWriter& writer)
{
auto diskflux = readDiskCommand(fluxsource, decoder);

22
lib/readerwriter.h
View File

@@ -1,8 +1,8 @@
#ifndef WRITER_H
#define WRITER_H
class AbstractDecoder;
class AbstractEncoder;
class Decoder;
class Encoder;
class DiskFlux;
class FluxSink;
class FluxSource;
@@ -23,9 +23,9 @@ extern void writeTracks(FluxSink& fluxSink,
const std::set<Location>& locations);
extern void writeTracksAndVerify(FluxSink& fluxSink,
AbstractEncoder& encoder,
Encoder& encoder,
FluxSource& fluxSource,
AbstractDecoder& decoder,
Decoder& decoder,
const Image& image,
const std::set<Location>& locations);
@@ -35,27 +35,27 @@ extern void fillBitmapTo(std::vector<bool>& bitmap,
const std::vector<bool>& pattern);
extern void writeDiskCommand(const Image& image,
AbstractEncoder& encoder,
Encoder& encoder,
FluxSink& fluxSink,
AbstractDecoder* decoder,
Decoder* decoder,
FluxSource* fluxSource,
const std::set<Location>& locations);
extern void writeDiskCommand(const Image& image,
AbstractEncoder& encoder,
Encoder& encoder,
FluxSink& fluxSink,
AbstractDecoder* decoder = nullptr,
Decoder* decoder = nullptr,
FluxSource* fluxSource = nullptr);
extern void writeRawDiskCommand(FluxSource& fluxSource, FluxSink& fluxSink);
extern std::shared_ptr<TrackFlux> readAndDecodeTrack(
FluxSource& fluxSource, AbstractDecoder& decoder, const Location& location);
FluxSource& fluxSource, Decoder& decoder, const Location& location);
extern std::shared_ptr<const DiskFlux> readDiskCommand(
FluxSource& fluxsource, AbstractDecoder& decoder);
FluxSource& fluxsource, Decoder& decoder);
extern void readDiskCommand(
FluxSource& source, AbstractDecoder& decoder, ImageWriter& writer);
FluxSource& source, Decoder& decoder, ImageWriter& writer);
extern void rawReadDiskCommand(FluxSource& source, FluxSink& sink);
#endif

12
lib/vfs/fluxsectorinterface.cc
View File

@@ -12,8 +12,8 @@ class FluxSectorInterface : public SectorInterface
public:
FluxSectorInterface(std::shared_ptr<FluxSource> fluxSource,
std::shared_ptr<FluxSink> fluxSink,
std::shared_ptr<AbstractEncoder> encoder,
std::shared_ptr<AbstractDecoder> decoder):
std::shared_ptr<Encoder> encoder,
std::shared_ptr<Decoder> decoder):
_fluxSource(fluxSource),
_fluxSink(fluxSink),
_encoder(encoder),
@@ -138,8 +138,8 @@ private:
std::shared_ptr<FluxSource> _fluxSource;
std::shared_ptr<FluxSink> _fluxSink;
std::shared_ptr<AbstractEncoder> _encoder;
std::shared_ptr<AbstractDecoder> _decoder;
std::shared_ptr<Encoder> _encoder;
std::shared_ptr<Decoder> _decoder;
typedef std::pair<unsigned, unsigned> trackid_t;
Image _loadedSectors;
@@ -151,8 +151,8 @@ private:
std::unique_ptr<SectorInterface> SectorInterface::createFluxSectorInterface(
std::shared_ptr<FluxSource> fluxSource,
std::shared_ptr<FluxSink> fluxSink,
std::shared_ptr<AbstractEncoder> encoder,
std::shared_ptr<AbstractDecoder> decoder)
std::shared_ptr<Encoder> encoder,
std::shared_ptr<Decoder> decoder)
{
return std::make_unique<FluxSectorInterface>(
fluxSource, fluxSink, encoder, decoder);

8
lib/vfs/sectorinterface.h
View File

@@ -6,8 +6,8 @@ class ImageWriter;
class Sector;
class FluxSource;
class FluxSink;
class AbstractDecoder;
class AbstractEncoder;
class Decoder;
class Encoder;
class SectorInterface
{
@@ -38,8 +38,8 @@ public:
static std::unique_ptr<SectorInterface> createFluxSectorInterface(
std::shared_ptr<FluxSource> fluxSource,
std::shared_ptr<FluxSink> fluxSink,
std::shared_ptr<AbstractEncoder> encoder,
std::shared_ptr<AbstractDecoder> decoder);
std::shared_ptr<Encoder> encoder,
std::shared_ptr<Decoder> decoder);
};
#endif

8
lib/vfs/vfs.cc
View File

@@ -215,19 +215,19 @@ std::unique_ptr<Filesystem> Filesystem::createFilesystemFromConfig()
if (config.has_flux_source() || config.has_flux_sink())
{
std::shared_ptr<FluxSource> fluxSource;
std::shared_ptr<AbstractDecoder> decoder;
std::shared_ptr<Decoder> decoder;
std::shared_ptr<FluxSink> fluxSink;
std::shared_ptr<AbstractEncoder> encoder;
std::shared_ptr<Encoder> encoder;
if (config.flux_source().source_case() !=
FluxSourceProto::SOURCE_NOT_SET)
{
fluxSource = FluxSource::create(config.flux_source());
decoder = AbstractDecoder::create(config.decoder());
decoder = Decoder::create(config.decoder());
}
if (config.flux_sink().has_drive())
{
fluxSink = FluxSink::create(config.flux_sink());
encoder = AbstractEncoder::create(config.encoder());
encoder = Encoder::create(config.encoder());
}
sectorInterface = SectorInterface::createFluxSectorInterface(
fluxSource, fluxSink, encoder, decoder);

2
src/fe-read.cc
View File

@@ -74,7 +74,7 @@ int mainRead(int argc, const char* argv[])
Error() << "you cannot copy flux to a hardware device";
std::unique_ptr<FluxSource> fluxSource(FluxSource::create(config.flux_source()));
std::unique_ptr<AbstractDecoder> decoder(AbstractDecoder::create(config.decoder()));
std::unique_ptr<Decoder> decoder(Decoder::create(config.decoder()));
std::unique_ptr<ImageWriter> writer(ImageWriter::create(config.image_writer()));
readDiskCommand(*fluxSource, *decoder, *writer);

6
src/fe-write.cc
View File

@@ -75,12 +75,12 @@ int mainWrite(int argc, const char* argv[])
std::unique_ptr<ImageReader> reader(ImageReader::create(config.image_reader()));
std::shared_ptr<Image> image = reader->readMappedImage();
std::unique_ptr<AbstractEncoder> encoder(AbstractEncoder::create(config.encoder()));
std::unique_ptr<Encoder> encoder(Encoder::create(config.encoder()));
std::unique_ptr<FluxSink> fluxSink(FluxSink::create(config.flux_sink()));
std::unique_ptr<AbstractDecoder> decoder;
std::unique_ptr<Decoder> decoder;
if (config.has_decoder() && verify)
decoder = AbstractDecoder::create(config.decoder());
decoder = Decoder::create(config.decoder());
std::unique_ptr<FluxSource> fluxSource;
if (verify && config.has_flux_source() && config.flux_source().has_drive())

8
src/gui/mainwindow.cc
View File

@@ -264,7 +264,7 @@ public:
Environment::reset();
auto fluxSource = FluxSource::create(config.flux_source());
auto decoder = AbstractDecoder::create(config.decoder());
auto decoder = Decoder::create(config.decoder());
auto diskflux = readDiskCommand(*fluxSource, *decoder);
runOnUiThread(
@@ -321,14 +321,14 @@ public:
{
auto image = ImageReader::create(config.image_reader())
->readMappedImage();
auto encoder = AbstractEncoder::create(config.encoder());
auto encoder = Encoder::create(config.encoder());
auto fluxSink = FluxSink::create(config.flux_sink());
std::unique_ptr<AbstractDecoder> decoder;
std::unique_ptr<Decoder> decoder;
std::unique_ptr<FluxSource> fluxSource;
if (config.has_decoder())
{
decoder = AbstractDecoder::create(config.decoder());
decoder = Decoder::create(config.decoder());
fluxSource = FluxSource::create(config.flux_source());
}