cebix/cwcbm/readcbm.c

/*
 *  readcbm.c - Read CBM disk to image file with the Catweasel controller
 *
 *  Written in 2003-2004 by Christian Bauer <Christian.Bauer@uni-mainz.de>
 */

#include "catweasel.h"
#include "common.h"


/* Raw track buffer and buffer pointer */
#define RAW_SIZE (128*1024)
static unsigned char raw_buf[RAW_SIZE];
static int buf_ptr = 0;


/* Search for next header sync, returns 0 if not found */
static int search_header_sync(void)
{
        while (1) {

                // End of buffer reached? Then bail out
                if (raw_buf[buf_ptr] & 0x80)
                        return 0;
                if (buf_ptr > RAW_SIZE - 13)
                        return 0;

                // Header sync: 10 "1"-bits followed by GCR-encoded 0x08 (= 1111111112233)
                if (raw_buf[buf_ptr +  0] == 1 && raw_buf[buf_ptr +  1] == 1
                 && raw_buf[buf_ptr +  2] == 1 && raw_buf[buf_ptr +  3] == 1
                 && raw_buf[buf_ptr +  4] == 1 && raw_buf[buf_ptr +  5] == 1
                 && raw_buf[buf_ptr +  6] == 1 && raw_buf[buf_ptr +  7] == 1
                 && raw_buf[buf_ptr +  8] == 1 && raw_buf[buf_ptr +  9] == 2
                 && raw_buf[buf_ptr + 10] == 2 && raw_buf[buf_ptr + 11] == 3
                 && raw_buf[buf_ptr + 12] == 3) {

                        // Found, advance buffer pointer to header mark
                        buf_ptr += 9;
//                      fprintf(stderr, "Header found at %d\n", buf_ptr);
                        return 1;
                }

                // Advance buffer pointer
                buf_ptr++;
        }
}


/* Search for next data sync, returns 0 if not found */
static int search_data_sync(void)
{
        while (1) {

                // End of buffer reached? Then bail out
                if (raw_buf[buf_ptr] & 0x80)
                        return 0;
                if (buf_ptr > RAW_SIZE - 15)
                        return 0;

                // Data sync: 10 "1"-bits followed by GCR-encoded 0x07 (= 111111111222211)
                if (raw_buf[buf_ptr +  0] == 1 && raw_buf[buf_ptr +  1] == 1
                 && raw_buf[buf_ptr +  2] == 1 && raw_buf[buf_ptr +  3] == 1
                 && raw_buf[buf_ptr +  4] == 1 && raw_buf[buf_ptr +  5] == 1
                 && raw_buf[buf_ptr +  6] == 1 && raw_buf[buf_ptr +  7] == 1
                 && raw_buf[buf_ptr +  8] == 1 && raw_buf[buf_ptr +  9] == 2
                 && raw_buf[buf_ptr + 10] == 2 && raw_buf[buf_ptr + 11] == 2
                 && raw_buf[buf_ptr + 12] == 2 && raw_buf[buf_ptr + 13] == 1
                 && raw_buf[buf_ptr + 14] == 1) {

                        // Found, advance buffer pointer to data mark
                        buf_ptr += 9;
//                      fprintf(stderr, "Data found at %d\n", buf_ptr);
                        return 1;
                }

                // Advance buffer pointer
                buf_ptr++;
        }
}


static const unsigned int gcr2bin_table_hi[32] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0x80, 0x00, 0x10, 0xff, 0xc0, 0x40, 0x50,
        0xff, 0xff, 0x20, 0x30, 0xff, 0xf0, 0x60, 0x70,
        0xff, 0x90, 0xa0, 0xb0, 0xff, 0xd0, 0xe0, 0xff
};

static const unsigned int gcr2bin_table_lo[32] = {
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff, 0x08, 0x00, 0x01, 0xff, 0x0c, 0x04, 0x05,
        0xff, 0xff, 0x02, 0x03, 0xff, 0x0f, 0x06, 0x07,
        0xff, 0x09, 0x0a, 0x0b, 0xff, 0x0d, 0x0e, 0xff
};

/* Decode GCR data to specified buffer */
static int decode_gcr(unsigned char *p, int num)
{
        unsigned int r = 0;
        int bit_count = 0;

        while (num > 0) {

                // Read clock value
                unsigned char x = raw_buf[buf_ptr];

                // End of buffer reached? Then bail out
                if (x & 0x80)
                        return 0;

                // Advance buffer pointer
                buf_ptr++;

                // Assemble bits
                r = (r << x) | 1;
                bit_count += x;

                // 10 bits (= one GCR-encoded byte) assembled?
                if (bit_count >= 10) {

                        // Yes, write decoded byte to buffer
                        unsigned int gcr = (r >> (bit_count - 10)) & 0x3ff;
                        unsigned char bin_hi = gcr2bin_table_hi[gcr >> 5],
                                      bin_lo = gcr2bin_table_lo[gcr & 0x1f];
                        *p++ = bin_hi | bin_lo;
                        num--;
                        bit_count -= 10;
                }
        }

        return 1;
}


/* Decode header and check for validity, returns 0 on error */
static int decode_header(int track, int *sector)
{
        unsigned char header[6];
        *sector = 0;

        // Decode header bytes
        if (!decode_gcr(header, 6)) {
                fprintf(stderr, "Track %d: buffer underrun reading header\n", track);
                return 0;
        }
//      printf("hdr: %02x %02x %02x %02x %02x %02x\n", header[0], header[1], header[2], header[3], header[4], header[5]);

        // Check for validity
        if (header[0] != 0x08) {
                fprintf(stderr, "Track %d: invalid header mark (shouldn't happen)\n", track);
                return 0;
        }
        if (header[1] ^ header[2] ^ header[3] ^ header[4] ^ header[5]) {
                fprintf(stderr, "Track %d: header checksum incorrect\n", track);
                // we'll try to continue anyways
        }
        if (header[2] >= num_sectors[track]) {
                fprintf(stderr, "Track %d: invalid sector number in header\n", track);
                return 0;
        }
        if (header[3] != track) {
                fprintf(stderr, "Track %d: invalid track number in header (seek error?)\n", track);
                return 0;
        }

        // Everything seems OK, return sector number
        *sector = header[2];
        return 1;
}


/* Decode sector data to buffer, returns 0 on error */
static int decode_data(int track, int sector, unsigned char *p)
{
        unsigned char tmp[SECTOR_SIZE + 2];
        unsigned char sum = 0;
        int i;

        // Decode data bytes
        if (!decode_gcr(tmp, SECTOR_SIZE + 2)) {
                fprintf(stderr, "Track %d sector %d: buffer underrun reading data\n", track, sector);
                return 0;
        }

        // Check for validity
        if (tmp[0] != 0x07) {
                fprintf(stderr, "Track %d sector %d: invalid data mark (shouldn't happen)\n", track, sector);
                return 0;
        }
        for (i = 1; i < SECTOR_SIZE+2; i++)
                sum ^= tmp[i];
        if (sum) {
                fprintf(stderr, "Track %d sector %d: data checksum incorrect\n", track, sector);
                // we'll try to continue anyways
        }

        // Copy data
        memcpy(p, tmp + 1, SECTOR_SIZE);
        return 1;
}


/* Decode sectors from raw_buf to track_buf */
static void decode_sectors(int track)
{
        int sector;

        // No sector read yet
        unsigned long sector_found = 0;
        unsigned long all_sectors = (1 << num_sectors[track]) - 1;

        // Reset buffer pointer
        buf_ptr = 0;

        // Process entire buffer
        while (1) {

                // Search for next header sync
                if (!search_header_sync())
                        break;

                // Decode sector header
                if (decode_header(track, &sector)) {

                        // Sector already read? Then don't do it again
                        if (sector_found & (1 << sector))
                                continue;

                        // Search for next data sync
                        if (!search_data_sync())
                                break;

                        // Decode sector data
                        if (decode_data(track, sector, track_buf + sector * SECTOR_SIZE)) {
                                sector_found |= 1 << sector;

                                // All sectors read? Then we are done
                                if (sector_found == all_sectors)
                                        break;
                        }
                }
        }

        // Check if all sectors of the track were found
        if (sector_found != all_sectors) {
                for (sector = 0; sector < num_sectors[track]; sector++)
                        if (!(sector_found & (1 << sector)))
                                fprintf(stderr, "Track %d: sector %d not found\n", track, sector);
        }
}


/* Read one track into track_buf, returns 0 on error */
static int read_track(int drive, int track)
{
        int i;

        // Seek to track, set speed zone
        seek_to(drive, track);

        // Clear buffer
        memset(track_buf, 0, num_sectors[track] * SECTOR_SIZE);

        // Read track (1 revolution + 10%)
        if (!catweasel_read(c.drives + drive, 0, 1, 1100 * 60 / drive_rpm)) {
                fprintf(stderr, "Error reading track %d\n", track);
                return 0;
        }

        // Copy track data to buffer, apply thresholds
        for (i = 0; i < RAW_SIZE; i++) {
                unsigned char x = inb(c.io_mem), y;
                if (x & 0x80) {
                        memset(raw_buf + i, 0x80, RAW_SIZE - i);
                        break;
                }
                if (x < thresh_table[0])
                        y = 0;
                else if (x < thresh_table[1])
                        y = 1;
                else if (x < thresh_table[2])
                        y = 2;
                else
                        y = 3;
                raw_buf[i] = y;
        }
        raw_buf[RAW_SIZE - 1] = 0x80;

        // Decode all sectors
        decode_sectors(track);

        return 1;
}


int main(int argc, char **argv)
{
        int track;
        FILE *f;

        // Parse arguments
        parse_args(argc, argv);

        // Open output file
        f = fopen(file_name, "wb");
        if (f == NULL) {
                fprintf(stderr, "Can't open %s for writing: %s\n", file_name, strerror(errno));
                return 1;
        }

        // Obtain access to I/O ports
        ioport_access();

        // Init Catweasel
        catweasel_init_controller(&c);

        // Start drive
        start_drive(drive_num);

        // Read all tracks
        for (track = 1; track <= NUM_TRACKS; track++) {
                printf("Track %d...\n", track);
                if (!read_track(drive_num, track))
                        break;
                fwrite(track_buf, 256, num_sectors[track], f);
        }

        // Stop drive
        stop_drive(drive_num);

        // Free Catweasel
        catweasel_free_controller(&c);

        // Close output file
        fclose(f);

        return 0;
}
1	cebix	1.1	/*
2			* readcbm.c - Read CBM disk to image file with the Catweasel controller
3			*
4	cebix	1.2	* Written in 2003-2004 by Christian Bauer <Christian.Bauer@uni-mainz.de>
5	cebix	1.1	*/
6
7			#include "catweasel.h"
8			#include "common.h"
9
10
11			/* Raw track buffer and buffer pointer */
12			#define RAW_SIZE (128*1024)
13			static unsigned char raw_buf[RAW_SIZE];
14			static int buf_ptr = 0;
15
16
17			/* Search for next header sync, returns 0 if not found */
18			static int search_header_sync(void)
19			{
20			while (1) {
21
22			// End of buffer reached? Then bail out
23			if (raw_buf[buf_ptr] & 0x80)
24			return 0;
25			if (buf_ptr > RAW_SIZE - 13)
26			return 0;
27
28			// Header sync: 10 "1"-bits followed by GCR-encoded 0x08 (= 1111111112233)
29			if (raw_buf[buf_ptr + 0] == 1 && raw_buf[buf_ptr + 1] == 1
30			&& raw_buf[buf_ptr + 2] == 1 && raw_buf[buf_ptr + 3] == 1
31			&& raw_buf[buf_ptr + 4] == 1 && raw_buf[buf_ptr + 5] == 1
32			&& raw_buf[buf_ptr + 6] == 1 && raw_buf[buf_ptr + 7] == 1
33			&& raw_buf[buf_ptr + 8] == 1 && raw_buf[buf_ptr + 9] == 2
34			&& raw_buf[buf_ptr + 10] == 2 && raw_buf[buf_ptr + 11] == 3
35			&& raw_buf[buf_ptr + 12] == 3) {
36
37			// Found, advance buffer pointer to header mark
38			buf_ptr += 9;
39			// fprintf(stderr, "Header found at %d\n", buf_ptr);
40			return 1;
41			}
42
43			// Advance buffer pointer
44			buf_ptr++;
45			}
46			}
47
48
49			/* Search for next data sync, returns 0 if not found */
50			static int search_data_sync(void)
51			{
52			while (1) {
53
54			// End of buffer reached? Then bail out
55			if (raw_buf[buf_ptr] & 0x80)
56			return 0;
57			if (buf_ptr > RAW_SIZE - 15)
58			return 0;
59
60			// Data sync: 10 "1"-bits followed by GCR-encoded 0x07 (= 111111111222211)
61			if (raw_buf[buf_ptr + 0] == 1 && raw_buf[buf_ptr + 1] == 1
62			&& raw_buf[buf_ptr + 2] == 1 && raw_buf[buf_ptr + 3] == 1
63			&& raw_buf[buf_ptr + 4] == 1 && raw_buf[buf_ptr + 5] == 1
64			&& raw_buf[buf_ptr + 6] == 1 && raw_buf[buf_ptr + 7] == 1
65			&& raw_buf[buf_ptr + 8] == 1 && raw_buf[buf_ptr + 9] == 2
66			&& raw_buf[buf_ptr + 10] == 2 && raw_buf[buf_ptr + 11] == 2
67			&& raw_buf[buf_ptr + 12] == 2 && raw_buf[buf_ptr + 13] == 1
68			&& raw_buf[buf_ptr + 14] == 1) {
69
70			// Found, advance buffer pointer to data mark
71			buf_ptr += 9;
72			// fprintf(stderr, "Data found at %d\n", buf_ptr);
73			return 1;
74			}
75
76			// Advance buffer pointer
77			buf_ptr++;
78			}
79			}
80
81
82			static const unsigned int gcr2bin_table_hi[32] = {
83			0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
84			0xff, 0x80, 0x00, 0x10, 0xff, 0xc0, 0x40, 0x50,
85			0xff, 0xff, 0x20, 0x30, 0xff, 0xf0, 0x60, 0x70,
86			0xff, 0x90, 0xa0, 0xb0, 0xff, 0xd0, 0xe0, 0xff
87			};
88
89			static const unsigned int gcr2bin_table_lo[32] = {
90			0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
91			0xff, 0x08, 0x00, 0x01, 0xff, 0x0c, 0x04, 0x05,
92			0xff, 0xff, 0x02, 0x03, 0xff, 0x0f, 0x06, 0x07,
93			0xff, 0x09, 0x0a, 0x0b, 0xff, 0x0d, 0x0e, 0xff
94			};
95
96			/* Decode GCR data to specified buffer */
97			static int decode_gcr(unsigned char *p, int num)
98			{
99			unsigned int r = 0;
100			int bit_count = 0;
101
102			while (num > 0) {
103
104			// Read clock value
105			unsigned char x = raw_buf[buf_ptr];
106
107			// End of buffer reached? Then bail out
108			if (x & 0x80)
109			return 0;
110
111			// Advance buffer pointer
112			buf_ptr++;
113
114			// Assemble bits
115			r = (r << x) \| 1;
116			bit_count += x;
117
118			// 10 bits (= one GCR-encoded byte) assembled?
119			if (bit_count >= 10) {
120
121			// Yes, write decoded byte to buffer
122			unsigned int gcr = (r >> (bit_count - 10)) & 0x3ff;
123			unsigned char bin_hi = gcr2bin_table_hi[gcr >> 5],
124			bin_lo = gcr2bin_table_lo[gcr & 0x1f];
125			*p++ = bin_hi \| bin_lo;
126			num--;
127			bit_count -= 10;
128			}
129			}
130
131			return 1;
132			}
133
134
135			/* Decode header and check for validity, returns 0 on error */
136			static int decode_header(int track, int *sector)
137			{
138			unsigned char header[6];
139			*sector = 0;
140
141			// Decode header bytes
142			if (!decode_gcr(header, 6)) {
143			fprintf(stderr, "Track %d: buffer underrun reading header\n", track);
144			return 0;
145			}
146			// printf("hdr: %02x %02x %02x %02x %02x %02x\n", header[0], header[1], header[2], header[3], header[4], header[5]);
147
148			// Check for validity
149			if (header[0] != 0x08) {
150			fprintf(stderr, "Track %d: invalid header mark (shouldn't happen)\n", track);
151			return 0;
152			}
153			if (header[1] ^ header[2] ^ header[3] ^ header[4] ^ header[5]) {
154			fprintf(stderr, "Track %d: header checksum incorrect\n", track);
155			// we'll try to continue anyways
156			}
157			if (header[2] >= num_sectors[track]) {
158			fprintf(stderr, "Track %d: invalid sector number in header\n", track);
159			return 0;
160			}
161			if (header[3] != track) {
162			fprintf(stderr, "Track %d: invalid track number in header (seek error?)\n", track);
163			return 0;
164			}
165
166			// Everything seems OK, return sector number
167			*sector = header[2];
168			return 1;
169			}
170
171
172			/* Decode sector data to buffer, returns 0 on error */
173			static int decode_data(int track, int sector, unsigned char *p)
174			{
175			unsigned char tmp[SECTOR_SIZE + 2];
176			unsigned char sum = 0;
177			int i;
178
179			// Decode data bytes
180			if (!decode_gcr(tmp, SECTOR_SIZE + 2)) {
181			fprintf(stderr, "Track %d sector %d: buffer underrun reading data\n", track, sector);
182			return 0;
183			}
184
185			// Check for validity
186			if (tmp[0] != 0x07) {
187			fprintf(stderr, "Track %d sector %d: invalid data mark (shouldn't happen)\n", track, sector);
188			return 0;
189			}
190			for (i = 1; i < SECTOR_SIZE+2; i++)
191			sum ^= tmp[i];
192			if (sum) {
193			fprintf(stderr, "Track %d sector %d: data checksum incorrect\n", track, sector);
194			// we'll try to continue anyways
195			}
196
197			// Copy data
198			memcpy(p, tmp + 1, SECTOR_SIZE);
199			return 1;
200			}
201
202
203			/* Decode sectors from raw_buf to track_buf */
204			static void decode_sectors(int track)
205			{
206			int sector;
207
208			// No sector read yet
209			unsigned long sector_found = 0;
210			unsigned long all_sectors = (1 << num_sectors[track]) - 1;
211
212			// Reset buffer pointer
213			buf_ptr = 0;
214
215			// Process entire buffer
216			while (1) {
217
218			// Search for next header sync
219			if (!search_header_sync())
220			break;
221
222			// Decode sector header
223			if (decode_header(track, &sector)) {
224
225			// Sector already read? Then don't do it again
226			if (sector_found & (1 << sector))
227			continue;
228
229			// Search for next data sync
230			if (!search_data_sync())
231			break;
232
233			// Decode sector data
234			if (decode_data(track, sector, track_buf + sector * SECTOR_SIZE)) {
235			sector_found \|= 1 << sector;
236
237			// All sectors read? Then we are done
238			if (sector_found == all_sectors)
239			break;
240			}
241			}
242			}
243
244			// Check if all sectors of the track were found
245			if (sector_found != all_sectors) {
246			for (sector = 0; sector < num_sectors[track]; sector++)
247			if (!(sector_found & (1 << sector)))
248			fprintf(stderr, "Track %d: sector %d not found\n", track, sector);
249			}
250			}
251
252
253			/* Read one track into track_buf, returns 0 on error */
254			static int read_track(int drive, int track)
255			{
256			int i;
257
258	cebix	1.2	// Seek to track, set speed zone
259			seek_to(drive, track);
260	cebix	1.1
261			// Clear buffer
262			memset(track_buf, 0, num_sectors[track] * SECTOR_SIZE);
263
264			// Read track (1 revolution + 10%)
265			if (!catweasel_read(c.drives + drive, 0, 1, 1100 * 60 / drive_rpm)) {
266			fprintf(stderr, "Error reading track %d\n", track);
267			return 0;
268			}
269
270			// Copy track data to buffer, apply thresholds
271			for (i = 0; i < RAW_SIZE; i++) {
272			unsigned char x = inb(c.io_mem), y;
273			if (x & 0x80) {
274			memset(raw_buf + i, 0x80, RAW_SIZE - i);
275			break;
276			}
277			if (x < thresh_table[0])
278			y = 0;
279			else if (x < thresh_table[1])
280			y = 1;
281			else if (x < thresh_table[2])
282			y = 2;
283			else
284			y = 3;
285			raw_buf[i] = y;
286			}
287			raw_buf[RAW_SIZE - 1] = 0x80;
288
289			// Decode all sectors
290			decode_sectors(track);
291
292			return 1;
293			}
294
295
296			int main(int argc, char **argv)
297			{
298	cebix	1.2	int track;
299	cebix	1.1	FILE *f;
300
301			// Parse arguments
302	cebix	1.2	parse_args(argc, argv);
303	cebix	1.1
304			// Open output file
305	cebix	1.2	f = fopen(file_name, "wb");
306	cebix	1.1	if (f == NULL) {
307	cebix	1.2	fprintf(stderr, "Can't open %s for writing: %s\n", file_name, strerror(errno));
308	cebix	1.1	return 1;
309			}
310
311			// Obtain access to I/O ports
312	cebix	1.2	ioport_access();
313	cebix	1.1
314			// Init Catweasel
315			catweasel_init_controller(&c);
316
317			// Start drive
318	cebix	1.2	start_drive(drive_num);
319	cebix	1.1
320			// Read all tracks
321			for (track = 1; track <= NUM_TRACKS; track++) {
322			printf("Track %d...\n", track);
323	cebix	1.2	if (!read_track(drive_num, track))
324	cebix	1.1	break;
325			fwrite(track_buf, 256, num_sectors[track], f);
326			}
327
328			// Stop drive
329	cebix	1.2	stop_drive(drive_num);
330
331			// Free Catweasel
332	cebix	1.1	catweasel_free_controller(&c);
333
334			// Close output file
335			fclose(f);
336
337			return 0;
338			}
Christian Bauer">Christian Bauer	ViewVC Help
Powered by ViewVC 1.1.15