Apple-2-Tools
/
ciderpress
mirror of https://github.com/fadden/ciderpress.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Change tabs to spaces, use Linux EOL 

No substantative changes (unless the tabs-to-spaces messed
something up).
This commit is contained in:
Andy McFadden 2015-01-09 17:52:16 -08:00
parent 683eb05a82
commit 090797a76f
7 changed files with 3181 additions and 3181 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

982
linux/Convert.cpp
View File

@ -1,491 +1,491 @@
/*
* CiderPress
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
* See the file LICENSE for distribution terms.
*/
/*
* Convert from one image format to another.
*/
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <memory.h>
#include <assert.h>
#include "../diskimg/DiskImg.h"
#include "../nufxlib/NufxLib.h"
using namespace DiskImgLib;
#define nil NULL
#define ASSERT assert
#define NELEM(x) (sizeof(x) / sizeof((x)[0]))
FILE* gLog = nil;
pid_t gPid = getpid();
/*
* Handle a debug message from the DiskImg library.
*/
/*static*/ void
MsgHandler(const char* file, int line, const char* msg)
{
ASSERT(file != nil);
ASSERT(msg != nil);
fprintf(gLog, "%05u %s", gPid, msg);
}
/*
* Handle a global error message from the NufxLib library by shoving it
* through the DiskImgLib message function.
*/
NuResult
NufxErrorMsgHandler(NuArchive* /*pArchive*/, void* vErrorMessage)
{
const NuErrorMessage* pErrorMessage = (const NuErrorMessage*) vErrorMessage;
if (pErrorMessage->isDebug) {
Global::PrintDebugMsg(pErrorMessage->file, pErrorMessage->line,
"<nufxlib> [D] %s\n", pErrorMessage->message);
} else {
Global::PrintDebugMsg(pErrorMessage->file, pErrorMessage->line,
"<nufxlib> %s\n", pErrorMessage->message);
}
return kNuOK;
}
/*
* Convert one disk image to another.
*/
DIError
Convert(const char* infile, const char* outfile)
{
DIError dierr = kDIErrNone;
DiskImg srcImg, dstImg;
const char* storageName = nil;
printf("Converting in='%s' out='%s'\n", infile, outfile);
/*
* Prepare the source image.
*/
dierr = srcImg.OpenImage(infile, '/', true);
if (dierr != kDIErrNone) {
fprintf(stderr, "Unable to open disk image: %s.\n",
DiskImgLib::DIStrError(dierr));
goto bail;
}
dierr = srcImg.AnalyzeImage();
if (dierr != kDIErrNone) {
fprintf(stderr, "Unable to determine source image format.\n");
goto bail;
}
if (!srcImg.GetHasBlocks() && !srcImg.GetHasSectors()) {
/* add nibble tracks someday */
fprintf(stderr,
"Sorry, only block- or sector-addressable images allowed.\n");
dierr = kDIErrUnsupportedPhysicalFmt;
goto bail;
}
if (srcImg.GetHasBlocks()) {
assert(srcImg.GetNumBlocks() > 0);
} else {
assert(srcImg.GetNumTracks() > 0);
}
if (srcImg.GetSectorOrder() == DiskImg::kSectorOrderUnknown) {
fprintf(stderr, "(QUERY) don't know sector order\n");
dierr = kDIErrFilesystemNotFound;
goto bail;
}
storageName = "MyHappyDisk";
/* force the access to be ProDOS-ordered */
dierr = srcImg.OverrideFormat(srcImg.GetPhysicalFormat(),
DiskImg::kFormatGenericProDOSOrd, srcImg.GetSectorOrder());
if (dierr != kDIErrNone) {
fprintf(stderr, "Couldn't switch to generic ProDOS: %s.\n",
DiskImgLib::DIStrError(dierr));
goto bail;
}
/* transfer the DOS volume num, if one was set */
printf("DOS volume number set to %d\n", srcImg.GetDOSVolumeNum());
dstImg.SetDOSVolumeNum(srcImg.GetDOSVolumeNum());
const DiskImg::NibbleDescr* pNibbleDescr;
pNibbleDescr = nil;
/*
* Prepare the destination image.
*
* We *always* use DiskImg::kFormatGenericProDOSOrd here, because it
* must match up with what we selected above.
*
* We could enable "skipFormat" on all of these but the nibble images,
* but we go ahead and set it to "false" on all of them just for fun.
*/
switch (18) {
case 0:
/* 16-sector nibble image, by blocks */
pNibbleDescr= DiskImg::GetStdNibbleDescr(DiskImg::kNibbleDescrDOS33Std);
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatNib525_6656,
pNibbleDescr,
DiskImg::kSectorOrderPhysical,
DiskImg::kFormatGenericProDOSOrd,
srcImg.GetNumBlocks(),
false);
break;
case 1:
/* 16-sector nibble image, by tracks/sectors */
pNibbleDescr= DiskImg::GetStdNibbleDescr(DiskImg::kNibbleDescrDOS33Std);
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatNib525_6656,
pNibbleDescr,
DiskImg::kSectorOrderPhysical,
DiskImg::kFormatGenericProDOSOrd,
35, 16,
false);
break;
case 2:
/* 16-sector NB2 nibble image, by tracks/sectors */
pNibbleDescr= DiskImg::GetStdNibbleDescr(DiskImg::kNibbleDescrDOS33Std);
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatNib525_6384,
pNibbleDescr,
DiskImg::kSectorOrderPhysical,
DiskImg::kFormatGenericProDOSOrd,
35, 16,
false);
break;
case 3:
/* 13-sector nibble image, by tracks/sectors */
pNibbleDescr= DiskImg::GetStdNibbleDescr(DiskImg::kNibbleDescrDOS32Std);
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatNib525_6656,
pNibbleDescr,
DiskImg::kSectorOrderPhysical,
DiskImg::kFormatGenericProDOSOrd,
35, 13,
false);
break;
case 4:
/* 16-sector nb2 image, by tracks/sectors */
pNibbleDescr= DiskImg::GetStdNibbleDescr(DiskImg::kNibbleDescrDOS33Std);
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatNib525_6384,
pNibbleDescr,
DiskImg::kSectorOrderPhysical,
DiskImg::kFormatGenericProDOSOrd,
35, 16,
false);
break;
case 5:
/* sector image, by blocks, ProDOS order */
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderProDOS,
DiskImg::kFormatGenericProDOSOrd,
srcImg.GetNumBlocks(),
false);
break;
case 6:
/* sector image, by blocks, DOS order */
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderDOS,
DiskImg::kFormatGenericProDOSOrd,
srcImg.GetNumBlocks(),
false);
break;
case 7:
/* sector image, by blocks, ProDOS order, Sim2e */
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatSim2eHDV,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderProDOS,
DiskImg::kFormatGenericProDOSOrd,
srcImg.GetNumBlocks(),
false);
break;
case 8:
/* odd-length HUGE sector image, by blocks */
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderProDOS,
DiskImg::kFormatGenericProDOSOrd,
65535,
false);
break;
case 9:
/* sector image, by blocks, physical order, with gzip */
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatGzip,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderPhysical,
DiskImg::kFormatGenericProDOSOrd,
srcImg.GetNumBlocks(),
false);
break;
case 10:
/* sector image, by blocks, ProDOS order, with gzip */
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatGzip,
DiskImg::kFileFormatSim2eHDV,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderProDOS,
DiskImg::kFormatGenericProDOSOrd,
srcImg.GetNumBlocks(),
false);
break;
case 11:
/* sector image, by blocks, ProDOS order, 2MG */
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormat2MG,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderProDOS,
DiskImg::kFormatGenericProDOSOrd,
srcImg.GetNumBlocks(),
false);
break;
case 12:
/* 16-sector nibble image, by tracks/sectors, 2MG */
pNibbleDescr= DiskImg::GetStdNibbleDescr(DiskImg::kNibbleDescrDOS33Std);
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormat2MG,
DiskImg::kPhysicalFormatNib525_6656,
pNibbleDescr,
DiskImg::kSectorOrderPhysical,
DiskImg::kFormatGenericProDOSOrd,
35, 16,
false);
break;
case 13:
/* 16-sector nibble image, by tracks/sectors, 2MG, gzip */
pNibbleDescr= DiskImg::GetStdNibbleDescr(DiskImg::kNibbleDescrDOS33Std);
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatGzip,
DiskImg::kFileFormat2MG,
DiskImg::kPhysicalFormatNib525_6656,
pNibbleDescr,
DiskImg::kSectorOrderPhysical,
DiskImg::kFormatGenericProDOSOrd,
35, 16,
false);
break;
case 14:
/* sector image, by blocks, for DC42 (800K only) */
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatDiskCopy42,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderProDOS,
DiskImg::kFormatGenericProDOSOrd,
srcImg.GetNumBlocks(),
false);
break;
case 15:
/* sector image, by blocks, for NuFX */
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatNuFX,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderProDOS,
DiskImg::kFormatGenericProDOSOrd,
srcImg.GetNumBlocks(),
false);
break;
case 16:
/* sector image, by blocks, for DDD */
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatDDD,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderDOS,
DiskImg::kFormatGenericProDOSOrd,
srcImg.GetNumBlocks(),
false);
break;
case 17:
/* sector image, by blocks, ProDOS order, stored in ZIP (.po.zip) */
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatZip,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderProDOS,
DiskImg::kFormatGenericProDOSOrd,
srcImg.GetNumBlocks(),
false);
break;
case 18:
/* 13-sector nibble image, by tracks/sectors */
pNibbleDescr= DiskImg::GetStdNibbleDescr(DiskImg::kNibbleDescrDOS33Std);
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderProDOS,
DiskImg::kFormatGenericProDOSOrd,
35, 13,
false);
break;
default:
fprintf(stderr, "UNEXPECTED NUMBER\n");
abort();
}
if (dierr != kDIErrNone) {
fprintf(stderr, "Couldn't create new image file '%s': %s.\n",
outfile, DiskImgLib::DIStrError(dierr));
goto bail;
}
/*
* Copy blocks or sectors from source to destination.
*/
if (srcImg.GetHasBlocks()) {
int numBlocks;
numBlocks = srcImg.GetNumBlocks();
if (dstImg.GetNumBlocks() < srcImg.GetNumBlocks())
numBlocks = dstImg.GetNumBlocks();
printf("Copying %d blocks\n", numBlocks);
unsigned char blkBuf[512];
for (int block = 0; block < numBlocks; block++) {
dierr = srcImg.ReadBlock(block, blkBuf);
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: ReadBlock failed (err=%d)\n", dierr);
goto bail;
}
dierr = dstImg.WriteBlock(block, blkBuf);
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: WriteBlock failed (err=%d)\n", dierr);
goto bail;
}
}
} else {
int numTracks, numSectPerTrack;
numTracks = srcImg.GetNumTracks();
numSectPerTrack = srcImg.GetNumSectPerTrack();
if (dstImg.GetNumTracks() < srcImg.GetNumTracks())
numTracks = dstImg.GetNumTracks();
if (dstImg.GetNumSectPerTrack() < srcImg.GetNumSectPerTrack())
numSectPerTrack = dstImg.GetNumSectPerTrack();
printf("Copying %d tracks of %d sectors\n", numTracks, numSectPerTrack);
unsigned char sctBuf[256];
for (int track = 0; track < numTracks; track++) {
for (int sector = 0; sector < numSectPerTrack; sector++) {
dierr = srcImg.ReadTrackSector(track, sector, sctBuf);
if (dierr != kDIErrNone) {
fprintf(stderr,
"WARNING: ReadTrackSector failed on T=%d S=%d (err=%d)\n",
track, sector, dierr);
dierr = kDIErrNone; // allow bad blocks
memset(sctBuf, 0, sizeof(sctBuf));
}
dierr = dstImg.WriteTrackSector(track, sector, sctBuf);
if (dierr != kDIErrNone) {
fprintf(stderr,
"ERROR: WriteBlock failed on T=%d S=%d (err=%d)\n",
track, sector, dierr);
goto bail;
}
}
}
}
dierr = srcImg.CloseImage();
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: srcImg close failed?!\n");
goto bail;
}
dierr = dstImg.CloseImage();
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: dstImg close failed (err=%d)\n", dierr);
goto bail;
}
assert(dierr == kDIErrNone);
bail:
return dierr;
}
/*
* Process every argument.
*/
int
main(int argc, char** argv)
{
const char* kLogFile = "iconv-log.txt";
if (argc != 3) {
fprintf(stderr, "%s: infile outfile\n", argv[0]);
exit(2);
}
gLog = fopen(kLogFile, "w");
if (gLog == nil) {
fprintf(stderr, "ERROR: unable to open log file\n");
exit(1);
}
printf("Image Converter for Linux v1.0\n");
printf("Copyright (C) 2014 by faddenSoft. All rights reserved.\n");
int32_t major, minor, bug;
Global::GetVersion(&major, &minor, &bug);
printf("Linked against DiskImg library v%d.%d.%d\n",
major, minor, bug);
printf("Log file is '%s'\n", kLogFile);
printf("\n");
Global::SetDebugMsgHandler(MsgHandler);
Global::AppInit();
NuSetGlobalErrorMessageHandler(NufxErrorMsgHandler);
Convert(argv[1], argv[2]);
Global::AppCleanup();
fclose(gLog);
exit(0);
}
/*
* CiderPress
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
* See the file LICENSE for distribution terms.
*/
/*
* Convert from one image format to another.
*/
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <memory.h>
#include <assert.h>
#include "../diskimg/DiskImg.h"
#include "../nufxlib/NufxLib.h"
using namespace DiskImgLib;
#define nil NULL
#define ASSERT assert
#define NELEM(x) (sizeof(x) / sizeof((x)[0]))
FILE* gLog = nil;
pid_t gPid = getpid();
/*
* Handle a debug message from the DiskImg library.
*/
/*static*/ void
MsgHandler(const char* file, int line, const char* msg)
{
ASSERT(file != nil);
ASSERT(msg != nil);
fprintf(gLog, "%05u %s", gPid, msg);
}
/*
* Handle a global error message from the NufxLib library by shoving it
* through the DiskImgLib message function.
*/
NuResult
NufxErrorMsgHandler(NuArchive* /*pArchive*/, void* vErrorMessage)
{
const NuErrorMessage* pErrorMessage = (const NuErrorMessage*) vErrorMessage;
if (pErrorMessage->isDebug) {
Global::PrintDebugMsg(pErrorMessage->file, pErrorMessage->line,
"<nufxlib> [D] %s\n", pErrorMessage->message);
} else {
Global::PrintDebugMsg(pErrorMessage->file, pErrorMessage->line,
"<nufxlib> %s\n", pErrorMessage->message);
}
return kNuOK;
}
/*
* Convert one disk image to another.
*/
DIError
Convert(const char* infile, const char* outfile)
{
DIError dierr = kDIErrNone;
DiskImg srcImg, dstImg;
const char* storageName = nil;
printf("Converting in='%s' out='%s'\n", infile, outfile);
/*
* Prepare the source image.
*/
dierr = srcImg.OpenImage(infile, '/', true);
if (dierr != kDIErrNone) {
fprintf(stderr, "Unable to open disk image: %s.\n",
DiskImgLib::DIStrError(dierr));
goto bail;
}
dierr = srcImg.AnalyzeImage();
if (dierr != kDIErrNone) {
fprintf(stderr, "Unable to determine source image format.\n");
goto bail;
}
if (!srcImg.GetHasBlocks() && !srcImg.GetHasSectors()) {
/* add nibble tracks someday */
fprintf(stderr,
"Sorry, only block- or sector-addressable images allowed.\n");
dierr = kDIErrUnsupportedPhysicalFmt;
goto bail;
}
if (srcImg.GetHasBlocks()) {
assert(srcImg.GetNumBlocks() > 0);
} else {
assert(srcImg.GetNumTracks() > 0);
}
if (srcImg.GetSectorOrder() == DiskImg::kSectorOrderUnknown) {
fprintf(stderr, "(QUERY) don't know sector order\n");
dierr = kDIErrFilesystemNotFound;
goto bail;
}
storageName = "MyHappyDisk";
/* force the access to be ProDOS-ordered */
dierr = srcImg.OverrideFormat(srcImg.GetPhysicalFormat(),
DiskImg::kFormatGenericProDOSOrd, srcImg.GetSectorOrder());
if (dierr != kDIErrNone) {
fprintf(stderr, "Couldn't switch to generic ProDOS: %s.\n",
DiskImgLib::DIStrError(dierr));
goto bail;
}
/* transfer the DOS volume num, if one was set */
printf("DOS volume number set to %d\n", srcImg.GetDOSVolumeNum());
dstImg.SetDOSVolumeNum(srcImg.GetDOSVolumeNum());
const DiskImg::NibbleDescr* pNibbleDescr;
pNibbleDescr = nil;
/*
* Prepare the destination image.
*
* We *always* use DiskImg::kFormatGenericProDOSOrd here, because it
* must match up with what we selected above.
*
* We could enable "skipFormat" on all of these but the nibble images,
* but we go ahead and set it to "false" on all of them just for fun.
*/
switch (18) {
case 0:
/* 16-sector nibble image, by blocks */
pNibbleDescr= DiskImg::GetStdNibbleDescr(DiskImg::kNibbleDescrDOS33Std);
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatNib525_6656,
pNibbleDescr,
DiskImg::kSectorOrderPhysical,
DiskImg::kFormatGenericProDOSOrd,
srcImg.GetNumBlocks(),
false);
break;
case 1:
/* 16-sector nibble image, by tracks/sectors */
pNibbleDescr= DiskImg::GetStdNibbleDescr(DiskImg::kNibbleDescrDOS33Std);
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatNib525_6656,
pNibbleDescr,
DiskImg::kSectorOrderPhysical,
DiskImg::kFormatGenericProDOSOrd,
35, 16,
false);
break;
case 2:
/* 16-sector NB2 nibble image, by tracks/sectors */
pNibbleDescr= DiskImg::GetStdNibbleDescr(DiskImg::kNibbleDescrDOS33Std);
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatNib525_6384,
pNibbleDescr,
DiskImg::kSectorOrderPhysical,
DiskImg::kFormatGenericProDOSOrd,
35, 16,
false);
break;
case 3:
/* 13-sector nibble image, by tracks/sectors */
pNibbleDescr= DiskImg::GetStdNibbleDescr(DiskImg::kNibbleDescrDOS32Std);
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatNib525_6656,
pNibbleDescr,
DiskImg::kSectorOrderPhysical,
DiskImg::kFormatGenericProDOSOrd,
35, 13,
false);
break;
case 4:
/* 16-sector nb2 image, by tracks/sectors */
pNibbleDescr= DiskImg::GetStdNibbleDescr(DiskImg::kNibbleDescrDOS33Std);
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatNib525_6384,
pNibbleDescr,
DiskImg::kSectorOrderPhysical,
DiskImg::kFormatGenericProDOSOrd,
35, 16,
false);
break;
case 5:
/* sector image, by blocks, ProDOS order */
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderProDOS,
DiskImg::kFormatGenericProDOSOrd,
srcImg.GetNumBlocks(),
false);
break;
case 6:
/* sector image, by blocks, DOS order */
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderDOS,
DiskImg::kFormatGenericProDOSOrd,
srcImg.GetNumBlocks(),
false);
break;
case 7:
/* sector image, by blocks, ProDOS order, Sim2e */
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatSim2eHDV,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderProDOS,
DiskImg::kFormatGenericProDOSOrd,
srcImg.GetNumBlocks(),
false);
break;
case 8:
/* odd-length HUGE sector image, by blocks */
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderProDOS,
DiskImg::kFormatGenericProDOSOrd,
65535,
false);
break;
case 9:
/* sector image, by blocks, physical order, with gzip */
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatGzip,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderPhysical,
DiskImg::kFormatGenericProDOSOrd,
srcImg.GetNumBlocks(),
false);
break;
case 10:
/* sector image, by blocks, ProDOS order, with gzip */
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatGzip,
DiskImg::kFileFormatSim2eHDV,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderProDOS,
DiskImg::kFormatGenericProDOSOrd,
srcImg.GetNumBlocks(),
false);
break;
case 11:
/* sector image, by blocks, ProDOS order, 2MG */
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormat2MG,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderProDOS,
DiskImg::kFormatGenericProDOSOrd,
srcImg.GetNumBlocks(),
false);
break;
case 12:
/* 16-sector nibble image, by tracks/sectors, 2MG */
pNibbleDescr= DiskImg::GetStdNibbleDescr(DiskImg::kNibbleDescrDOS33Std);
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormat2MG,
DiskImg::kPhysicalFormatNib525_6656,
pNibbleDescr,
DiskImg::kSectorOrderPhysical,
DiskImg::kFormatGenericProDOSOrd,
35, 16,
false);
break;
case 13:
/* 16-sector nibble image, by tracks/sectors, 2MG, gzip */
pNibbleDescr= DiskImg::GetStdNibbleDescr(DiskImg::kNibbleDescrDOS33Std);
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatGzip,
DiskImg::kFileFormat2MG,
DiskImg::kPhysicalFormatNib525_6656,
pNibbleDescr,
DiskImg::kSectorOrderPhysical,
DiskImg::kFormatGenericProDOSOrd,
35, 16,
false);
break;
case 14:
/* sector image, by blocks, for DC42 (800K only) */
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatDiskCopy42,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderProDOS,
DiskImg::kFormatGenericProDOSOrd,
srcImg.GetNumBlocks(),
false);
break;
case 15:
/* sector image, by blocks, for NuFX */
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatNuFX,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderProDOS,
DiskImg::kFormatGenericProDOSOrd,
srcImg.GetNumBlocks(),
false);
break;
case 16:
/* sector image, by blocks, for DDD */
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatDDD,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderDOS,
DiskImg::kFormatGenericProDOSOrd,
srcImg.GetNumBlocks(),
false);
break;
case 17:
/* sector image, by blocks, ProDOS order, stored in ZIP (.po.zip) */
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatZip,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderProDOS,
DiskImg::kFormatGenericProDOSOrd,
srcImg.GetNumBlocks(),
false);
break;
case 18:
/* 13-sector nibble image, by tracks/sectors */
pNibbleDescr= DiskImg::GetStdNibbleDescr(DiskImg::kNibbleDescrDOS33Std);
dierr = dstImg.CreateImage(outfile, storageName,
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatSectors,
pNibbleDescr,
DiskImg::kSectorOrderProDOS,
DiskImg::kFormatGenericProDOSOrd,
35, 13,
false);
break;
default:
fprintf(stderr, "UNEXPECTED NUMBER\n");
abort();
}
if (dierr != kDIErrNone) {
fprintf(stderr, "Couldn't create new image file '%s': %s.\n",
outfile, DiskImgLib::DIStrError(dierr));
goto bail;
}
/*
* Copy blocks or sectors from source to destination.
*/
if (srcImg.GetHasBlocks()) {
int numBlocks;
numBlocks = srcImg.GetNumBlocks();
if (dstImg.GetNumBlocks() < srcImg.GetNumBlocks())
numBlocks = dstImg.GetNumBlocks();
printf("Copying %d blocks\n", numBlocks);
unsigned char blkBuf[512];
for (int block = 0; block < numBlocks; block++) {
dierr = srcImg.ReadBlock(block, blkBuf);
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: ReadBlock failed (err=%d)\n", dierr);
goto bail;
}
dierr = dstImg.WriteBlock(block, blkBuf);
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: WriteBlock failed (err=%d)\n", dierr);
goto bail;
}
}
} else {
int numTracks, numSectPerTrack;
numTracks = srcImg.GetNumTracks();
numSectPerTrack = srcImg.GetNumSectPerTrack();
if (dstImg.GetNumTracks() < srcImg.GetNumTracks())
numTracks = dstImg.GetNumTracks();
if (dstImg.GetNumSectPerTrack() < srcImg.GetNumSectPerTrack())
numSectPerTrack = dstImg.GetNumSectPerTrack();
printf("Copying %d tracks of %d sectors\n", numTracks, numSectPerTrack);
unsigned char sctBuf[256];
for (int track = 0; track < numTracks; track++) {
for (int sector = 0; sector < numSectPerTrack; sector++) {
dierr = srcImg.ReadTrackSector(track, sector, sctBuf);
if (dierr != kDIErrNone) {
fprintf(stderr,
"WARNING: ReadTrackSector failed on T=%d S=%d (err=%d)\n",
track, sector, dierr);
dierr = kDIErrNone; // allow bad blocks
memset(sctBuf, 0, sizeof(sctBuf));
}
dierr = dstImg.WriteTrackSector(track, sector, sctBuf);
if (dierr != kDIErrNone) {
fprintf(stderr,
"ERROR: WriteBlock failed on T=%d S=%d (err=%d)\n",
track, sector, dierr);
goto bail;
}
}
}
}
dierr = srcImg.CloseImage();
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: srcImg close failed?!\n");
goto bail;
}
dierr = dstImg.CloseImage();
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: dstImg close failed (err=%d)\n", dierr);
goto bail;
}
assert(dierr == kDIErrNone);
bail:
return dierr;
}
/*
* Process every argument.
*/
int
main(int argc, char** argv)
{
const char* kLogFile = "iconv-log.txt";
if (argc != 3) {
fprintf(stderr, "%s: infile outfile\n", argv[0]);
exit(2);
}
gLog = fopen(kLogFile, "w");
if (gLog == nil) {
fprintf(stderr, "ERROR: unable to open log file\n");
exit(1);
}
printf("Image Converter for Linux v1.0\n");
printf("Copyright (C) 2014 by faddenSoft. All rights reserved.\n");
int32_t major, minor, bug;
Global::GetVersion(&major, &minor, &bug);
printf("Linked against DiskImg library v%d.%d.%d\n",
major, minor, bug);
printf("Log file is '%s'\n", kLogFile);
printf("\n");
Global::SetDebugMsgHandler(MsgHandler);
Global::AppInit();
NuSetGlobalErrorMessageHandler(NufxErrorMsgHandler);
Convert(argv[1], argv[2]);
Global::AppCleanup();
fclose(gLog);
exit(0);
}

440
linux/GetFile.cpp
View File

@ -1,220 +1,220 @@
/*
* CiderPress
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
* See the file LICENSE for distribution terms.
*/
/*
* Get a file from a disk image.
*/
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include <assert.h>
#include "../diskimg/DiskImg.h"
using namespace DiskImgLib;
#define nil NULL
#define NELEM(x) (sizeof(x) / sizeof((x)[0]))
/*
* Globals.
*/
FILE* gLog = nil;
pid_t gPid = getpid();
/*
* Show usage info.
*/
void
Usage(const char* argv0)
{
fprintf(stderr, "Usage: %s image-filename file\n", argv0);
fprintf(stderr, "\n");
fprintf(stderr, "The file will be written to stdout.\n");
}
/*
* Copy a file from "src" to "dst".
*/
int
CopyFile(A2FileDescr* src, FILE* dst)
{
DIError dierr;
size_t actual;
char buf[4096];
while (1) {
dierr = src->Read(buf, sizeof(buf), &actual);
if (dierr != kDIErrNone) {
fprintf(stderr, "Error: read failed: %s\n", DIStrError(dierr));
return -1;
}
if (actual == 0) // EOF hit
break;
fwrite(buf, 1, actual, dst);
}
return 0;
}
/*
* Extract the named file from the specified image.
*/
int
Process(const char* imageName, const char* wantedFileName)
{
DIError dierr;
DiskImg diskImg;
DiskFS* pDiskFS = nil;
A2File* pFile = nil;
A2FileDescr* pDescr = nil;
int result = -1;
/* open read-only */
dierr = diskImg.OpenImage(imageName, '/', true);
if (dierr != kDIErrNone) {
fprintf(stderr, "Unable to open '%s': %s\n", imageName,
DIStrError(dierr));
goto bail;
}
/* figure out the format */
dierr = diskImg.AnalyzeImage();
if (dierr != kDIErrNone) {
fprintf(stderr, "Analysis of '%s' failed: %s\n", imageName,
DIStrError(dierr));
goto bail;
}
/* recognized? */
if (diskImg.GetFSFormat() == DiskImg::kFormatUnknown ||
diskImg.GetSectorOrder() == DiskImg::kSectorOrderUnknown)
{
fprintf(stderr, "Unable to identify filesystem on '%s'\n", imageName);
goto bail;
}
/* create an appropriate DiskFS object */
pDiskFS = diskImg.OpenAppropriateDiskFS();
if (pDiskFS == nil) {
/* unknown FS should've been caught above! */
assert(false);
fprintf(stderr, "Format of '%s' not recognized.\n", imageName);
goto bail;
}
/* go ahead and load up volumes mounted inside volumes */
pDiskFS->SetScanForSubVolumes(DiskFS::kScanSubEnabled);
/* do a full scan */
dierr = pDiskFS->Initialize(&diskImg, DiskFS::kInitFull);
if (dierr != kDIErrNone) {
fprintf(stderr, "Error reading list of files from disk: %s\n",
DIStrError(dierr));
goto bail;
}
/*
* Find the file. This comes out of a list of entries, so don't
* delete "pFile" when we're done.
*/
pFile = pDiskFS->GetFileByName(wantedFileName);
if (pFile == nil) {
fprintf(stderr, "File '%s' not found in '%s'\n", wantedFileName,
imageName);
goto bail;
}
/*
* Open the file read-only.
*/
dierr = pFile->Open(&pDescr, true);
if (dierr != kDIErrNone) {
fprintf(stderr, "Error opening '%s': %s\n", wantedFileName,
DIStrError(dierr));
goto bail;
}
/*
* Copy the file to stdout.
*/
result = CopyFile(pDescr, stdout);
bail:
if (pDescr != nil) {
pDescr->Close();
//delete pDescr; -- don't do this (double free)
}
delete pDiskFS;
return result;
}
/*
* Handle a debug message from the DiskImg library.
*/
/*static*/ void
MsgHandler(const char* file, int line, const char* msg)
{
assert(file != nil);
assert(msg != nil);
#ifdef _DEBUG
fprintf(gLog, "%05u %s", gPid, msg);
#endif
}
/*
* Process args.
*/
int
main(int argc, char** argv)
{
#ifdef _DEBUG
const char* kLogFile = "makedisk-log.txt";
gLog = fopen(kLogFile, "w");
if (gLog == nil) {
fprintf(stderr, "ERROR: unable to open log file\n");
exit(1);
}
#endif
#ifdef _DEBUG
fprintf(stderr, "Log file is '%s'\n", kLogFile);
#endif
Global::SetDebugMsgHandler(MsgHandler);
Global::AppInit();
if (argc != 3) {
Usage(argv[0]);
exit(2);
}
const char* imageName;
const char* getFileName;
argv++;
imageName = *argv++;
getFileName = *argv++;
argc -= 2;
if (Process(imageName, getFileName) == 0)
fprintf(stderr, "Success!\n");
else
fprintf(stderr, "Failed.\n");
Global::AppCleanup();
#ifdef _DEBUG
fclose(gLog);
#endif
exit(0);
}
/*
* CiderPress
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
* See the file LICENSE for distribution terms.
*/
/*
* Get a file from a disk image.
*/
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include <assert.h>
#include "../diskimg/DiskImg.h"
using namespace DiskImgLib;
#define nil NULL
#define NELEM(x) (sizeof(x) / sizeof((x)[0]))
/*
* Globals.
*/
FILE* gLog = nil;
pid_t gPid = getpid();
/*
* Show usage info.
*/
void
Usage(const char* argv0)
{
fprintf(stderr, "Usage: %s image-filename file\n", argv0);
fprintf(stderr, "\n");
fprintf(stderr, "The file will be written to stdout.\n");
}
/*
* Copy a file from "src" to "dst".
*/
int
CopyFile(A2FileDescr* src, FILE* dst)
{
DIError dierr;
size_t actual;
char buf[4096];
while (1) {
dierr = src->Read(buf, sizeof(buf), &actual);
if (dierr != kDIErrNone) {
fprintf(stderr, "Error: read failed: %s\n", DIStrError(dierr));
return -1;
}
if (actual == 0) // EOF hit
break;
fwrite(buf, 1, actual, dst);
}
return 0;
}
/*
* Extract the named file from the specified image.
*/
int
Process(const char* imageName, const char* wantedFileName)
{
DIError dierr;
DiskImg diskImg;
DiskFS* pDiskFS = nil;
A2File* pFile = nil;
A2FileDescr* pDescr = nil;
int result = -1;
/* open read-only */
dierr = diskImg.OpenImage(imageName, '/', true);
if (dierr != kDIErrNone) {
fprintf(stderr, "Unable to open '%s': %s\n", imageName,
DIStrError(dierr));
goto bail;
}
/* figure out the format */
dierr = diskImg.AnalyzeImage();
if (dierr != kDIErrNone) {
fprintf(stderr, "Analysis of '%s' failed: %s\n", imageName,
DIStrError(dierr));
goto bail;
}
/* recognized? */
if (diskImg.GetFSFormat() == DiskImg::kFormatUnknown ||
diskImg.GetSectorOrder() == DiskImg::kSectorOrderUnknown)
{
fprintf(stderr, "Unable to identify filesystem on '%s'\n", imageName);
goto bail;
}
/* create an appropriate DiskFS object */
pDiskFS = diskImg.OpenAppropriateDiskFS();
if (pDiskFS == nil) {
/* unknown FS should've been caught above! */
assert(false);
fprintf(stderr, "Format of '%s' not recognized.\n", imageName);
goto bail;
}
/* go ahead and load up volumes mounted inside volumes */
pDiskFS->SetScanForSubVolumes(DiskFS::kScanSubEnabled);
/* do a full scan */
dierr = pDiskFS->Initialize(&diskImg, DiskFS::kInitFull);
if (dierr != kDIErrNone) {
fprintf(stderr, "Error reading list of files from disk: %s\n",
DIStrError(dierr));
goto bail;
}
/*
* Find the file. This comes out of a list of entries, so don't
* delete "pFile" when we're done.
*/
pFile = pDiskFS->GetFileByName(wantedFileName);
if (pFile == nil) {
fprintf(stderr, "File '%s' not found in '%s'\n", wantedFileName,
imageName);
goto bail;
}
/*
* Open the file read-only.
*/
dierr = pFile->Open(&pDescr, true);
if (dierr != kDIErrNone) {
fprintf(stderr, "Error opening '%s': %s\n", wantedFileName,
DIStrError(dierr));
goto bail;
}
/*
* Copy the file to stdout.
*/
result = CopyFile(pDescr, stdout);
bail:
if (pDescr != nil) {
pDescr->Close();
//delete pDescr; -- don't do this (double free)
}
delete pDiskFS;
return result;
}
/*
* Handle a debug message from the DiskImg library.
*/
/*static*/ void
MsgHandler(const char* file, int line, const char* msg)
{
assert(file != nil);
assert(msg != nil);
#ifdef _DEBUG
fprintf(gLog, "%05u %s", gPid, msg);
#endif
}
/*
* Process args.
*/
int
main(int argc, char** argv)
{
#ifdef _DEBUG
const char* kLogFile = "makedisk-log.txt";
gLog = fopen(kLogFile, "w");
if (gLog == nil) {
fprintf(stderr, "ERROR: unable to open log file\n");
exit(1);
}
#endif
#ifdef _DEBUG
fprintf(stderr, "Log file is '%s'\n", kLogFile);
#endif
Global::SetDebugMsgHandler(MsgHandler);
Global::AppInit();
if (argc != 3) {
Usage(argv[0]);
exit(2);
}
const char* imageName;
const char* getFileName;
argv++;
imageName = *argv++;
getFileName = *argv++;
argc -= 2;
if (Process(imageName, getFileName) == 0)
fprintf(stderr, "Success!\n");
else
fprintf(stderr, "Failed.\n");
Global::AppCleanup();
#ifdef _DEBUG
fclose(gLog);
#endif
exit(0);
}

1780
linux/MDC.cpp
View File

File diff suppressed because it is too large Load Diff

776
linux/MakeDisk.cpp
View File

@ -1,388 +1,388 @@
/*
* CiderPress
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
* See the file LICENSE for distribution terms.
*/
/*
* Create a blank disk image, format it, and copy some files onto it.
*/
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include <assert.h>
#include "../diskimg/DiskImg.h"
using namespace DiskImgLib;
#define nil NULL
#define NELEM(x) (sizeof(x) / sizeof((x)[0]))
/*
* Globals.
*/
FILE* gLog = nil;
pid_t gPid = getpid();
/*
* Show usage info.
*/
void
Usage(const char* argv0)
{
fprintf(stderr,
"Usage: %s {dos|prodos|pascal} size image-filename.po input-file1 ...\n",
argv0);
fprintf(stderr, "\n");
fprintf(stderr, "Example: makedisk prodos 800k foo.po file1.txt file2.txt\n");
}
/*
* Create a ProDOS-ordered disk image.
*
* Returns a DiskImg pointer on success, or nil on failure.
*/
DiskImg*
CreateDisk(const char* fileName, long blockCount)
{
DIError dierr;
DiskImg* pDiskImg = nil;
pDiskImg = new DiskImg;
dierr = pDiskImg->CreateImage(
fileName,
nil, // storageName
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatSectors,
nil, // pNibbleDescr
DiskImg::kSectorOrderProDOS,
DiskImg::kFormatGenericProDOSOrd,
blockCount,
true); // no need to format the image
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: CreateImage failed: %s\n",
DIStrError(dierr));
delete pDiskImg;
pDiskImg = nil;
}
return pDiskImg;
}
/*
* Copy files to the disk.
*/
int
CopyFiles(DiskFS* pDiskFS, int argc, char** argv)
{
DIError dierr;
DiskFS::CreateParms parms;
A2File* pNewFile;
struct CreateParms {
const char* pathName; // full pathname
char fssep;
int storageType; // determines normal, subdir, or forked
long fileType;
long auxType;
int access;
time_t createWhen;
time_t modWhen;
};
while (argc--) {
printf("+++ Adding '%s'\n", *argv);
/*
* Use external pathname as internal pathname. This isn't quite
* right, since things like "../" will end up getting converted
* to something we don't want, but it'll do for now.
*/
parms.pathName = *argv;
parms.fssep = '/'; // UNIX fssep
parms.storageType = DiskFS::kStorageSeedling; // not forked, not dir
parms.fileType = 0; // NON
parms.auxType = 0; // $0000
parms.access = DiskFS::kFileAccessUnlocked;
parms.createWhen = time(nil);
parms.modWhen = time(nil);
/*
* Create a new, empty file. The "pNewFile" pointer does not belong
* to us, so we should not delete it later, or try to access it
* after the underlying file is deleted.
*/
dierr = pDiskFS->CreateFile(&parms, &pNewFile);
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: unable to create '%s': %s\n",
*argv, DIStrError(dierr));
return -1;
}
/*
* Load the input file into memory.
*/
FILE* fp;
char* buf;
long len;
fp = fopen(*argv, "r");
if (fp == nil) {
fprintf(stderr, "ERROR: unable to open input file '%s': %s\n",
*argv, strerror(errno));
return -1;
}
if (fseek(fp, 0, SEEK_END) != 0) {
fprintf(stderr, "ERROR: unable to seek input file '%s': %s\n",
*argv, strerror(errno));
fclose(fp);
return -1;
}
len = ftell(fp);
rewind(fp);
buf = new char[len];
if (buf == nil) {
fprintf(stderr, "ERROR: unable to alloc %ld bytes\n", len);
fclose(fp);
return -1;
}
if (fread(buf, len, 1, fp) != 1) {
fprintf(stderr, "ERROR: fread of %ld bytes from '%s' failed: %s\n",
len, *argv, strerror(errno));
fclose(fp);
delete[] buf;
return -1;
}
fclose(fp);
/*
* Write the buffer to the disk image.
*
* The A2FileDescr object is created by "Open" and deleted by
* "Close".
*/
A2FileDescr* pFD;
dierr = pNewFile->Open(&pFD, true);
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: unable to open new file '%s': %s\n",
pNewFile->GetPathName(), DIStrError(dierr));
delete[] buf;
return -1;
}
dierr = pFD->Write(buf, len);
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: failed writing to '%s': %s\n",
pNewFile->GetPathName(), DIStrError(dierr));
pFD->Close();
pDiskFS->DeleteFile(pNewFile);
delete[] buf;
return -1;
}
delete[] buf;
dierr = pFD->Close();
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: failed while closing '%s': %s\n",
pNewFile->GetPathName(), DIStrError(dierr));
return -1;
}
/*
* On to the next file.
*/
argv++;
}
return 0;
}
/*
* Process the request.
*
* Returns 0 on success, -1 on failure.
*/
int
Process(const char* formatName, const char* sizeStr,
const char* outputFileName, int argc, char** argv)
{
DiskImg::FSFormat format;
long blockCount;
if (strcasecmp(formatName, "dos") == 0)
format = DiskImg::kFormatDOS33;
else if (strcasecmp(formatName, "prodos") == 0)
format = DiskImg::kFormatProDOS;
else if (strcasecmp(formatName, "pascal") == 0)
format = DiskImg::kFormatPascal;
else {
fprintf(stderr, "ERROR: invalid format '%s'\n", formatName);
return -1;
}
if (strcasecmp(sizeStr, "140k") == 0)
blockCount = 280;
else if (strcasecmp(sizeStr, "800k") == 0)
blockCount = 1600;
else {
blockCount = atoi(sizeStr);
if (blockCount <= 0 || blockCount > 65536) {
fprintf(stderr, "ERROR: invalid size '%s'\n", sizeStr);
return -1;
}
}
if (access(outputFileName, F_OK) == 0) {
fprintf(stderr, "ERROR: output file '%s' already exists\n",
outputFileName);
return -1;
}
assert(argc >= 1);
assert(*argv != nil);
const char* volName;
DiskImg* pDiskImg;
DiskFS* pDiskFS;
DIError dierr;
/*
* Prepare the disk image file.
*/
pDiskImg = CreateDisk(outputFileName, blockCount);
if (pDiskImg == nil)
return -1;
if (format == DiskImg::kFormatDOS33)
volName = "DOS"; // put DOS 3.3 in tracks 0-2
else
volName = "TEST";
dierr = pDiskImg->FormatImage(format, volName);
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: unable to format disk: %s\n",
DIStrError(dierr));
delete pDiskImg;
return -1;
}
/*
* Prepare to access the image as a filesystem.
*/
pDiskFS = pDiskImg->OpenAppropriateDiskFS(false);
if (pDiskFS == nil) {
fprintf(stderr, "ERROR: unable to open appropriate DiskFS\n");
delete pDiskImg;
return -1;
}
dierr = pDiskFS->Initialize(pDiskImg, DiskFS::kInitFull);
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: unable to initialize DiskFS: %s\n",
DIStrError(dierr));
delete pDiskFS;
delete pDiskImg;
return -1;
}
/*
* Copy the files over.
*/
if (CopyFiles(pDiskFS, argc, argv) != 0) {
delete pDiskFS;
delete pDiskImg;
return -1;
}
/*
* Clean up. Note "CloseImage" isn't strictly necessary, but it gives
* us an opportunity to detect failures.
*/
delete pDiskFS;
if (pDiskImg->CloseImage() != 0) {
fprintf(stderr, "WARNING: CloseImage failed: %s\n",
DIStrError(dierr));
}
delete pDiskImg;
return 0;
}
/*
* Handle a debug message from the DiskImg library.
*/
/*static*/ void
MsgHandler(const char* file, int line, const char* msg)
{
assert(file != nil);
assert(msg != nil);
#ifdef _DEBUG
fprintf(gLog, "%05u %s", gPid, msg);
#endif
}
/*
* Process args.
*/
int
main(int argc, char** argv)
{
#ifdef _DEBUG
const char* kLogFile = "makedisk-log.txt";
gLog = fopen(kLogFile, "w");
if (gLog == nil) {
fprintf(stderr, "ERROR: unable to open log file\n");
exit(1);
}
#endif
#ifdef _DEBUG
printf("Log file is '%s'\n", kLogFile);
#endif
Global::SetDebugMsgHandler(MsgHandler);
Global::AppInit();
if (argc < 5) {
Usage(argv[0]);
exit(2);
}
const char* formatName;
const char* sizeStr;
const char* outputFileName;
argv++;
formatName = *argv++;
sizeStr = *argv++;
outputFileName = *argv++;
argc -= 4;
if (Process(formatName, sizeStr, outputFileName, argc, argv) == 0)
fprintf(stderr, "Success!\n");
else
fprintf(stderr, "Failed.\n");
Global::AppCleanup();
#ifdef _DEBUG
fclose(gLog);
#endif
exit(0);
}
/*
* CiderPress
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
* See the file LICENSE for distribution terms.
*/
/*
* Create a blank disk image, format it, and copy some files onto it.
*/
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include <assert.h>
#include "../diskimg/DiskImg.h"
using namespace DiskImgLib;
#define nil NULL
#define NELEM(x) (sizeof(x) / sizeof((x)[0]))
/*
* Globals.
*/
FILE* gLog = nil;
pid_t gPid = getpid();
/*
* Show usage info.
*/
void
Usage(const char* argv0)
{
fprintf(stderr,
"Usage: %s {dos|prodos|pascal} size image-filename.po input-file1 ...\n",
argv0);
fprintf(stderr, "\n");
fprintf(stderr, "Example: makedisk prodos 800k foo.po file1.txt file2.txt\n");
}
/*
* Create a ProDOS-ordered disk image.
*
* Returns a DiskImg pointer on success, or nil on failure.
*/
DiskImg*
CreateDisk(const char* fileName, long blockCount)
{
DIError dierr;
DiskImg* pDiskImg = nil;
pDiskImg = new DiskImg;
dierr = pDiskImg->CreateImage(
fileName,
nil, // storageName
DiskImg::kOuterFormatNone,
DiskImg::kFileFormatUnadorned,
DiskImg::kPhysicalFormatSectors,
nil, // pNibbleDescr
DiskImg::kSectorOrderProDOS,
DiskImg::kFormatGenericProDOSOrd,
blockCount,
true); // no need to format the image
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: CreateImage failed: %s\n",
DIStrError(dierr));
delete pDiskImg;
pDiskImg = nil;
}
return pDiskImg;
}
/*
* Copy files to the disk.
*/
int
CopyFiles(DiskFS* pDiskFS, int argc, char** argv)
{
DIError dierr;
DiskFS::CreateParms parms;
A2File* pNewFile;
struct CreateParms {
const char* pathName; // full pathname
char fssep;
int storageType; // determines normal, subdir, or forked
long fileType;
long auxType;
int access;
time_t createWhen;
time_t modWhen;
};
while (argc--) {
printf("+++ Adding '%s'\n", *argv);
/*
* Use external pathname as internal pathname. This isn't quite
* right, since things like "../" will end up getting converted
* to something we don't want, but it'll do for now.
*/
parms.pathName = *argv;
parms.fssep = '/'; // UNIX fssep
parms.storageType = DiskFS::kStorageSeedling; // not forked, not dir
parms.fileType = 0; // NON
parms.auxType = 0; // $0000
parms.access = DiskFS::kFileAccessUnlocked;
parms.createWhen = time(nil);
parms.modWhen = time(nil);
/*
* Create a new, empty file. The "pNewFile" pointer does not belong
* to us, so we should not delete it later, or try to access it
* after the underlying file is deleted.
*/
dierr = pDiskFS->CreateFile(&parms, &pNewFile);
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: unable to create '%s': %s\n",
*argv, DIStrError(dierr));
return -1;
}
/*
* Load the input file into memory.
*/
FILE* fp;
char* buf;
long len;
fp = fopen(*argv, "r");
if (fp == nil) {
fprintf(stderr, "ERROR: unable to open input file '%s': %s\n",
*argv, strerror(errno));
return -1;
}
if (fseek(fp, 0, SEEK_END) != 0) {
fprintf(stderr, "ERROR: unable to seek input file '%s': %s\n",
*argv, strerror(errno));
fclose(fp);
return -1;
}
len = ftell(fp);
rewind(fp);
buf = new char[len];
if (buf == nil) {
fprintf(stderr, "ERROR: unable to alloc %ld bytes\n", len);
fclose(fp);
return -1;
}
if (fread(buf, len, 1, fp) != 1) {
fprintf(stderr, "ERROR: fread of %ld bytes from '%s' failed: %s\n",
len, *argv, strerror(errno));
fclose(fp);
delete[] buf;
return -1;
}
fclose(fp);
/*
* Write the buffer to the disk image.
*
* The A2FileDescr object is created by "Open" and deleted by
* "Close".
*/
A2FileDescr* pFD;
dierr = pNewFile->Open(&pFD, true);
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: unable to open new file '%s': %s\n",
pNewFile->GetPathName(), DIStrError(dierr));
delete[] buf;
return -1;
}
dierr = pFD->Write(buf, len);
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: failed writing to '%s': %s\n",
pNewFile->GetPathName(), DIStrError(dierr));
pFD->Close();
pDiskFS->DeleteFile(pNewFile);
delete[] buf;
return -1;
}
delete[] buf;
dierr = pFD->Close();
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: failed while closing '%s': %s\n",
pNewFile->GetPathName(), DIStrError(dierr));
return -1;
}
/*
* On to the next file.
*/
argv++;
}
return 0;
}
/*
* Process the request.
*
* Returns 0 on success, -1 on failure.
*/
int
Process(const char* formatName, const char* sizeStr,
const char* outputFileName, int argc, char** argv)
{
DiskImg::FSFormat format;
long blockCount;
if (strcasecmp(formatName, "dos") == 0)
format = DiskImg::kFormatDOS33;
else if (strcasecmp(formatName, "prodos") == 0)
format = DiskImg::kFormatProDOS;
else if (strcasecmp(formatName, "pascal") == 0)
format = DiskImg::kFormatPascal;
else {
fprintf(stderr, "ERROR: invalid format '%s'\n", formatName);
return -1;
}
if (strcasecmp(sizeStr, "140k") == 0)
blockCount = 280;
else if (strcasecmp(sizeStr, "800k") == 0)
blockCount = 1600;
else {
blockCount = atoi(sizeStr);
if (blockCount <= 0 || blockCount > 65536) {
fprintf(stderr, "ERROR: invalid size '%s'\n", sizeStr);
return -1;
}
}
if (access(outputFileName, F_OK) == 0) {
fprintf(stderr, "ERROR: output file '%s' already exists\n",
outputFileName);
return -1;
}
assert(argc >= 1);
assert(*argv != nil);
const char* volName;
DiskImg* pDiskImg;
DiskFS* pDiskFS;
DIError dierr;
/*
* Prepare the disk image file.
*/
pDiskImg = CreateDisk(outputFileName, blockCount);
if (pDiskImg == nil)
return -1;
if (format == DiskImg::kFormatDOS33)
volName = "DOS"; // put DOS 3.3 in tracks 0-2
else
volName = "TEST";
dierr = pDiskImg->FormatImage(format, volName);
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: unable to format disk: %s\n",
DIStrError(dierr));
delete pDiskImg;
return -1;
}
/*
* Prepare to access the image as a filesystem.
*/
pDiskFS = pDiskImg->OpenAppropriateDiskFS(false);
if (pDiskFS == nil) {
fprintf(stderr, "ERROR: unable to open appropriate DiskFS\n");
delete pDiskImg;
return -1;
}
dierr = pDiskFS->Initialize(pDiskImg, DiskFS::kInitFull);
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: unable to initialize DiskFS: %s\n",
DIStrError(dierr));
delete pDiskFS;
delete pDiskImg;
return -1;
}
/*
* Copy the files over.
*/
if (CopyFiles(pDiskFS, argc, argv) != 0) {
delete pDiskFS;
delete pDiskImg;
return -1;
}
/*
* Clean up. Note "CloseImage" isn't strictly necessary, but it gives
* us an opportunity to detect failures.
*/
delete pDiskFS;
if (pDiskImg->CloseImage() != 0) {
fprintf(stderr, "WARNING: CloseImage failed: %s\n",
DIStrError(dierr));
}
delete pDiskImg;
return 0;
}
/*
* Handle a debug message from the DiskImg library.
*/
/*static*/ void
MsgHandler(const char* file, int line, const char* msg)
{
assert(file != nil);
assert(msg != nil);
#ifdef _DEBUG
fprintf(gLog, "%05u %s", gPid, msg);
#endif
}
/*
* Process args.
*/
int
main(int argc, char** argv)
{
#ifdef _DEBUG
const char* kLogFile = "makedisk-log.txt";
gLog = fopen(kLogFile, "w");
if (gLog == nil) {
fprintf(stderr, "ERROR: unable to open log file\n");
exit(1);
}
#endif
#ifdef _DEBUG
printf("Log file is '%s'\n", kLogFile);
#endif
Global::SetDebugMsgHandler(MsgHandler);
Global::AppInit();
if (argc < 5) {
Usage(argv[0]);
exit(2);
}
const char* formatName;
const char* sizeStr;
const char* outputFileName;
argv++;
formatName = *argv++;
sizeStr = *argv++;
outputFileName = *argv++;
argc -= 4;
if (Process(formatName, sizeStr, outputFileName, argc, argv) == 0)
fprintf(stderr, "Success!\n");
else
fprintf(stderr, "Failed.\n");
Global::AppCleanup();
#ifdef _DEBUG
fclose(gLog);
#endif
exit(0);
}

1532
linux/PackDDD.cpp
View File

File diff suppressed because it is too large Load Diff

650
linux/SSTAsm.cpp
View File

@ -1,325 +1,325 @@
/*
* CiderPress
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
* See the file LICENSE for distribution terms.
*/
/*
* Reassemble SST disk images into a .NIB file.
*/
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include "../diskimg/DiskImg.h"
using namespace DiskImgLib;
#define nil NULL
#if 0
inline int
ConvOddEven(unsigned char val1, unsigned char val2)
{
return ((val1 & 0x55) << 1) | (val2 & 0x55);
}
#endif
const int kSSTNumTracks = 35;
const int kSSTTrackLen = 6656; // or 6384 for .NB2
/*
* Compute the destination file offset for a particular source track. The
* track number ranges from 0 to 69 inclusive. Sectors from two adjacent
* "cooked" tracks are combined into a single "raw nibbilized" track.
*
* The data is ordered like this:
* track 1 sector 15 --> track 1 sector 4 (12 sectors)
* track 0 sector 13 --> track 0 sector 0 (14 sectors)
*
* Total of 26 sectors, or $1a00 bytes.
*/
long
GetBufOffset(int track)
{
assert(track >= 0 && track < kSSTNumTracks*2);
long offset;
if (track & 0x01) {
/* odd, use start of data */
offset = (track / 2) * kSSTTrackLen;
} else {
/* even, start of data plus 12 sectors */
offset = (track / 2) * kSSTTrackLen + 12 * 256;
}
assert(offset >= 0 && offset < kSSTTrackLen * kSSTNumTracks);
return offset;
}
/*
* Copy 17.5 tracks of data from the SST image to a .NIB image.
*
* Data is stored in all 16 sectors of track 0, followed by the first
* 12 sectors of track 1, then on to track 2. Total of $1a00 bytes.
*/
int
LoadSSTData(DiskImg* pDiskImg, int seqNum, unsigned char* trackBuf)
{
DIError dierr;
char sctBuf[256];
int track, sector;
long bufOffset;
for (track = 0; track < kSSTNumTracks; track++) {
int virtualTrack = track + (seqNum * kSSTNumTracks);
bufOffset = GetBufOffset(virtualTrack);
//fprintf(stderr, "USING offset=%ld (track=%d / %d)\n",
// bufOffset, track, virtualTrack);
if (virtualTrack & 0x01) {
/* odd-numbered track, sectors 15-4 */
for (sector = 15; sector >= 4; sector--) {
dierr = pDiskImg->ReadTrackSector(track, sector, sctBuf);
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: on track=%d sector=%d\n",
track, sector);
return -1;
}
memcpy(trackBuf + bufOffset, sctBuf, 256);
bufOffset += 256;
}
} else {
for (sector = 13; sector >= 0; sector--) {
dierr = pDiskImg->ReadTrackSector(track, sector, sctBuf);
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: on track=%d sector=%d\n",
track, sector);
return -1;
}
memcpy(trackBuf + bufOffset, sctBuf, 256);
bufOffset += 256;
}
}
}
#if 0
int i;
for (i = 0; (size_t) i < sizeof(trackBuf)-10; i++) {
if ((trackBuf[i] | 0x80) == 0xd5 &&
(trackBuf[i+1] | 0x80) == 0xaa &&
(trackBuf[i+2] | 0x80) == 0x96)
{
fprintf(stderr, "off=%5d vol=%d trk=%d sct=%d chk=%d\n", i,
ConvOddEven(trackBuf[i+3], trackBuf[i+4]),
ConvOddEven(trackBuf[i+5], trackBuf[i+6]),
ConvOddEven(trackBuf[i+7], trackBuf[i+8]),
ConvOddEven(trackBuf[i+9], trackBuf[i+10]));
i += 10;
if ((size_t)i < sizeof(trackBuf)-3) {
fprintf(stderr, " 0x%02x 0x%02x 0x%02x\n",
trackBuf[i+1], trackBuf[i+2], trackBuf[i+3]);
}
}
}
#endif
return 0;
}
/*
* Copy sectors from a single image.
*/
int
HandleSSTImage(const char* fileName, int seqNum, unsigned char* trackBuf)
{
DIError dierr;
DiskImg diskImg;
int result = -1;
fprintf(stderr, "Handling '%s'\n", fileName);
dierr = diskImg.OpenImage(fileName, '/', true);
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: unable to open '%s'\n", fileName);
goto bail;
}
dierr = diskImg.AnalyzeImage();
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: image analysis failed\n");
goto bail;
}
if (diskImg.GetSectorOrder() == DiskImg::kSectorOrderUnknown) {
fprintf(stderr, "ERROR: sector order not set\n");
goto bail;
}
if (diskImg.GetFSFormat() != DiskImg::kFormatUnknown) {
fprintf(stderr, "WARNING: file format *was* recognized!\n");
goto bail;
}
if (diskImg.GetNumTracks() != kSSTNumTracks ||
diskImg.GetNumSectPerTrack() != 16)
{
fprintf(stderr, "ERROR: only 140K floppies can be SST inputs\n");
goto bail;
}
dierr = diskImg.OverrideFormat(diskImg.GetPhysicalFormat(),
DiskImg::kFormatGenericDOSOrd, diskImg.GetSectorOrder());
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: format override failed\n");
goto bail;
}
/*
* We have the image open successfully, now do something with it.
*/
result = LoadSSTData(&diskImg, seqNum, trackBuf);
bail:
return result;
}
/*
* Run through the data, adding 0x80 everywhere and re-aligning the
* tracks so that the big clump of sync bytes is at the end.
*/
int
ProcessTrackData(unsigned char* trackBuf)
{
unsigned char* trackPtr;
int track;
for (track = 0, trackPtr = trackBuf; track < kSSTNumTracks;
track++, trackPtr += kSSTTrackLen)
{
bool inRun;
int start = 0;
int longestStart = -1;
int count7f = 0;
int longest = -1;
int i;
inRun = false;
for (i = 0; i < kSSTTrackLen; i++) {
if (trackPtr[i] == 0x7f) {
if (inRun) {
count7f++;
} else {
count7f = 1;
start = i;
inRun = true;
}
} else {
if (inRun) {
if (count7f > longest) {
longest = count7f;
longestStart = start;
}
inRun = false;
} else {
/* do nothing */
}
}
trackPtr[i] |= 0x80;
}
if (longest == -1) {
fprintf(stderr, "HEY: couldn't find any 0x7f in track %d\n",
track);
} else {
fprintf(stderr, "Found run of %d at %d in track %d\n",
longest, longestStart, track);
int bkpt = longestStart + longest;
assert(bkpt < kSSTTrackLen);
char oneTrack[kSSTTrackLen];
memcpy(oneTrack, trackPtr, kSSTTrackLen);
/* copy it back so sync bytes are at end of track */
memcpy(trackPtr, oneTrack + bkpt, kSSTTrackLen - bkpt);
memcpy(trackPtr + (kSSTTrackLen - bkpt), oneTrack, bkpt);
}
}
return 0;
}
/*
* Read sectors from file1 and file2, and write them in the correct
* sequence to outfp.
*/
int
ReassembleSST(const char* file1, const char* file2, FILE* outfp)
{
unsigned char* trackBuf = nil;
int result;
trackBuf = new unsigned char[kSSTNumTracks * kSSTTrackLen];
if (trackBuf == nil) {
fprintf(stderr, "ERROR: malloc failed\n");
return -1;
}
result = HandleSSTImage(file1, 0, trackBuf);
if (result != 0)
return result;
result = HandleSSTImage(file2, 1, trackBuf);
if (result != 0)
return result;
result = ProcessTrackData(trackBuf);
fprintf(stderr, "Writing %d bytes\n", kSSTNumTracks * kSSTTrackLen);
fwrite(trackBuf, 1, kSSTNumTracks * kSSTTrackLen, outfp);
delete[] trackBuf;
return result;
}
/*
* Handle a debug message from the DiskImg library.
*/
/*static*/ void
MsgHandler(const char* file, int line, const char* msg)
{
assert(file != nil);
assert(msg != nil);
fprintf(stderr, "%s", msg);
}
/*
* Parse args, go.
*/
int
main(int argc, char** argv)
{
int result;
if (argc != 3) {
fprintf(stderr, "Usage: %s file1 file2 > outfile\n", argv[0]);
exit(2);
}
Global::SetDebugMsgHandler(MsgHandler);
Global::AppInit();
result = ReassembleSST(argv[1], argv[2], stdout);
Global::AppCleanup();
exit(result != 0);
}
/*
* CiderPress
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
* See the file LICENSE for distribution terms.
*/
/*
* Reassemble SST disk images into a .NIB file.
*/
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include "../diskimg/DiskImg.h"
using namespace DiskImgLib;
#define nil NULL
#if 0
inline int
ConvOddEven(unsigned char val1, unsigned char val2)
{
return ((val1 & 0x55) << 1) | (val2 & 0x55);
}
#endif
const int kSSTNumTracks = 35;
const int kSSTTrackLen = 6656; // or 6384 for .NB2
/*
* Compute the destination file offset for a particular source track. The
* track number ranges from 0 to 69 inclusive. Sectors from two adjacent
* "cooked" tracks are combined into a single "raw nibbilized" track.
*
* The data is ordered like this:
* track 1 sector 15 --> track 1 sector 4 (12 sectors)
* track 0 sector 13 --> track 0 sector 0 (14 sectors)
*
* Total of 26 sectors, or $1a00 bytes.
*/
long
GetBufOffset(int track)
{
assert(track >= 0 && track < kSSTNumTracks*2);
long offset;
if (track & 0x01) {
/* odd, use start of data */
offset = (track / 2) * kSSTTrackLen;
} else {
/* even, start of data plus 12 sectors */
offset = (track / 2) * kSSTTrackLen + 12 * 256;
}
assert(offset >= 0 && offset < kSSTTrackLen * kSSTNumTracks);
return offset;
}
/*
* Copy 17.5 tracks of data from the SST image to a .NIB image.
*
* Data is stored in all 16 sectors of track 0, followed by the first
* 12 sectors of track 1, then on to track 2. Total of $1a00 bytes.
*/
int
LoadSSTData(DiskImg* pDiskImg, int seqNum, unsigned char* trackBuf)
{
DIError dierr;
char sctBuf[256];
int track, sector;
long bufOffset;
for (track = 0; track < kSSTNumTracks; track++) {
int virtualTrack = track + (seqNum * kSSTNumTracks);
bufOffset = GetBufOffset(virtualTrack);
//fprintf(stderr, "USING offset=%ld (track=%d / %d)\n",
// bufOffset, track, virtualTrack);
if (virtualTrack & 0x01) {
/* odd-numbered track, sectors 15-4 */
for (sector = 15; sector >= 4; sector--) {
dierr = pDiskImg->ReadTrackSector(track, sector, sctBuf);
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: on track=%d sector=%d\n",
track, sector);
return -1;
}
memcpy(trackBuf + bufOffset, sctBuf, 256);
bufOffset += 256;
}
} else {
for (sector = 13; sector >= 0; sector--) {
dierr = pDiskImg->ReadTrackSector(track, sector, sctBuf);
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: on track=%d sector=%d\n",
track, sector);
return -1;
}
memcpy(trackBuf + bufOffset, sctBuf, 256);
bufOffset += 256;
}
}
}
#if 0
int i;
for (i = 0; (size_t) i < sizeof(trackBuf)-10; i++) {
if ((trackBuf[i] | 0x80) == 0xd5 &&
(trackBuf[i+1] | 0x80) == 0xaa &&
(trackBuf[i+2] | 0x80) == 0x96)
{
fprintf(stderr, "off=%5d vol=%d trk=%d sct=%d chk=%d\n", i,
ConvOddEven(trackBuf[i+3], trackBuf[i+4]),
ConvOddEven(trackBuf[i+5], trackBuf[i+6]),
ConvOddEven(trackBuf[i+7], trackBuf[i+8]),
ConvOddEven(trackBuf[i+9], trackBuf[i+10]));
i += 10;
if ((size_t)i < sizeof(trackBuf)-3) {
fprintf(stderr, " 0x%02x 0x%02x 0x%02x\n",
trackBuf[i+1], trackBuf[i+2], trackBuf[i+3]);
}
}
}
#endif
return 0;
}
/*
* Copy sectors from a single image.
*/
int
HandleSSTImage(const char* fileName, int seqNum, unsigned char* trackBuf)
{
DIError dierr;
DiskImg diskImg;
int result = -1;
fprintf(stderr, "Handling '%s'\n", fileName);
dierr = diskImg.OpenImage(fileName, '/', true);
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: unable to open '%s'\n", fileName);
goto bail;
}
dierr = diskImg.AnalyzeImage();
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: image analysis failed\n");
goto bail;
}
if (diskImg.GetSectorOrder() == DiskImg::kSectorOrderUnknown) {
fprintf(stderr, "ERROR: sector order not set\n");
goto bail;
}
if (diskImg.GetFSFormat() != DiskImg::kFormatUnknown) {
fprintf(stderr, "WARNING: file format *was* recognized!\n");
goto bail;
}
if (diskImg.GetNumTracks() != kSSTNumTracks ||
diskImg.GetNumSectPerTrack() != 16)
{
fprintf(stderr, "ERROR: only 140K floppies can be SST inputs\n");
goto bail;
}
dierr = diskImg.OverrideFormat(diskImg.GetPhysicalFormat(),
DiskImg::kFormatGenericDOSOrd, diskImg.GetSectorOrder());
if (dierr != kDIErrNone) {
fprintf(stderr, "ERROR: format override failed\n");
goto bail;
}
/*
* We have the image open successfully, now do something with it.
*/
result = LoadSSTData(&diskImg, seqNum, trackBuf);
bail:
return result;
}
/*
* Run through the data, adding 0x80 everywhere and re-aligning the
* tracks so that the big clump of sync bytes is at the end.
*/
int
ProcessTrackData(unsigned char* trackBuf)
{
unsigned char* trackPtr;
int track;
for (track = 0, trackPtr = trackBuf; track < kSSTNumTracks;
track++, trackPtr += kSSTTrackLen)
{
bool inRun;
int start = 0;
int longestStart = -1;
int count7f = 0;
int longest = -1;
int i;
inRun = false;
for (i = 0; i < kSSTTrackLen; i++) {
if (trackPtr[i] == 0x7f) {
if (inRun) {
count7f++;
} else {
count7f = 1;
start = i;
inRun = true;
}
} else {
if (inRun) {
if (count7f > longest) {
longest = count7f;
longestStart = start;
}
inRun = false;
} else {
/* do nothing */
}
}
trackPtr[i] |= 0x80;
}
if (longest == -1) {
fprintf(stderr, "HEY: couldn't find any 0x7f in track %d\n",
track);
} else {
fprintf(stderr, "Found run of %d at %d in track %d\n",
longest, longestStart, track);
int bkpt = longestStart + longest;
assert(bkpt < kSSTTrackLen);
char oneTrack[kSSTTrackLen];
memcpy(oneTrack, trackPtr, kSSTTrackLen);
/* copy it back so sync bytes are at end of track */
memcpy(trackPtr, oneTrack + bkpt, kSSTTrackLen - bkpt);
memcpy(trackPtr + (kSSTTrackLen - bkpt), oneTrack, bkpt);
}
}
return 0;
}
/*
* Read sectors from file1 and file2, and write them in the correct
* sequence to outfp.
*/
int
ReassembleSST(const char* file1, const char* file2, FILE* outfp)
{
unsigned char* trackBuf = nil;
int result;
trackBuf = new unsigned char[kSSTNumTracks * kSSTTrackLen];
if (trackBuf == nil) {
fprintf(stderr, "ERROR: malloc failed\n");
return -1;
}
result = HandleSSTImage(file1, 0, trackBuf);
if (result != 0)
return result;
result = HandleSSTImage(file2, 1, trackBuf);
if (result != 0)
return result;
result = ProcessTrackData(trackBuf);
fprintf(stderr, "Writing %d bytes\n", kSSTNumTracks * kSSTTrackLen);
fwrite(trackBuf, 1, kSSTNumTracks * kSSTTrackLen, outfp);
delete[] trackBuf;
return result;
}
/*
* Handle a debug message from the DiskImg library.
*/
/*static*/ void
MsgHandler(const char* file, int line, const char* msg)
{
assert(file != nil);
assert(msg != nil);
fprintf(stderr, "%s", msg);
}
/*
* Parse args, go.
*/
int
main(int argc, char** argv)
{
int result;
if (argc != 3) {
fprintf(stderr, "Usage: %s file1 file2 > outfile\n", argv[0]);
exit(2);
}
Global::SetDebugMsgHandler(MsgHandler);
Global::AppInit();
result = ReassembleSST(argv[1], argv[2], stdout);
Global::AppCleanup();
exit(result != 0);
}

202
linux/StringArray.h
View File

@ -1,101 +1,101 @@
/*
* CiderPress
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
* See the file LICENSE for distribution terms.
*/
/*
* An expandable array of strings.
*/
#ifndef __STRING_ARRAY__
#define __STRING_ARRAY__
#include <stdlib.h>
#include <string.h>
#include <memory.h>
//
// This is a simple container for an array of strings. You can add strings
// to the list and sort them.
//
class StringArray {
public:
StringArray()
: mMax(0), mCurrent(0), mArray(NULL)
{}
virtual ~StringArray()
{
for (int i = 0; i < mCurrent; i++)
delete[] mArray[i];
delete[] mArray;
}
//
// Add a string. A copy of the string is made.
//
bool Add(const char* str)
{
if (mCurrent >= mMax) {
char** tmp;
if (mMax == 0)
mMax = 16;
else
mMax *= 2;
tmp = new char*[mMax];
if (tmp == NULL)
return false;
memcpy(tmp, mArray, mCurrent * sizeof(char*));
delete[] mArray;
mArray = tmp;
}
int len = strlen(str);
mArray[mCurrent] = new char[len+1];
memcpy(mArray[mCurrent], str, len+1);
mCurrent++;
return true;
}
//
// Sort the array. Supply a sort function that takes two strings
// and returns <0, 0, or >0 if the first argument is less than,
// equal to, or greater than the second argument. (strcmp works.)
//
void Sort(int (*compare)(const void*, const void*))
{
qsort(mArray, mCurrent, sizeof(char*), compare);
}
//
// Use this as an argument to the sort routine.
//
static int CmpAscendingAlpha(const void* pstr1, const void* pstr2)
{
return strcmp(*(const char**)pstr1, *(const char**)pstr2);
}
//
// Get the #of items in the array.
//
inline int GetCount(void) const { return mCurrent; }
//
// Get entry N.
//
const char* GetEntry(int idx) const
{
if (idx < 0 || idx >= mCurrent)
return NULL;
return mArray[idx];
}
private:
int mMax;
int mCurrent;
char** mArray;
};
#endif /*__STRING_ARRAY__*/
/*
* CiderPress
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
* See the file LICENSE for distribution terms.
*/
/*
* An expandable array of strings.
*/
#ifndef __STRING_ARRAY__
#define __STRING_ARRAY__
#include <stdlib.h>
#include <string.h>
#include <memory.h>
//
// This is a simple container for an array of strings. You can add strings
// to the list and sort them.
//
class StringArray {
public:
StringArray()
: mMax(0), mCurrent(0), mArray(NULL)
{}
virtual ~StringArray()
{
for (int i = 0; i < mCurrent; i++)
delete[] mArray[i];
delete[] mArray;
}
//
// Add a string. A copy of the string is made.
//
bool Add(const char* str)
{
if (mCurrent >= mMax) {
char** tmp;
if (mMax == 0)
mMax = 16;
else
mMax *= 2;
tmp = new char*[mMax];
if (tmp == NULL)
return false;
memcpy(tmp, mArray, mCurrent * sizeof(char*));
delete[] mArray;
mArray = tmp;
}
int len = strlen(str);
mArray[mCurrent] = new char[len+1];
memcpy(mArray[mCurrent], str, len+1);
mCurrent++;
return true;
}
//
// Sort the array. Supply a sort function that takes two strings
// and returns <0, 0, or >0 if the first argument is less than,
// equal to, or greater than the second argument. (strcmp works.)
//
void Sort(int (*compare)(const void*, const void*))
{
qsort(mArray, mCurrent, sizeof(char*), compare);
}
//
// Use this as an argument to the sort routine.
//
static int CmpAscendingAlpha(const void* pstr1, const void* pstr2)
{
return strcmp(*(const char**)pstr1, *(const char**)pstr2);
}
//
// Get the #of items in the array.
//
inline int GetCount(void) const { return mCurrent; }
//
// Get entry N.
//
const char* GetEntry(int idx) const
{
if (idx < 0 || idx >= mCurrent)
return NULL;
return mArray[idx];
}
private:
int mMax;
int mCurrent;
char** mArray;
};
#endif /*__STRING_ARRAY__*/