summaryrefslogtreecommitdiffstatshomepage
path: root/src/lib/formats/ami_dsk.cpp
blob: eb96b01377db8b2ddd76df75bcbcd835d1833f0b (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
// license:BSD-3-Clause
// copyright-holders:Olivier Galibert
/*********************************************************************

    formats/ami_dsk.c

    Amiga disk images

*********************************************************************/

#include "formats/ami_dsk.h"

#include "ioprocs.h"


adf_format::adf_format() : floppy_image_format_t()
{
}

const char *adf_format::name() const
{
	return "adf";
}

const char *adf_format::description() const
{
	return "Amiga ADF floppy disk image";
}

const char *adf_format::extensions() const
{
	return "adf";
}

bool adf_format::supports_save() const
{
	return true;
}

int adf_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
	uint64_t size;
	if (io.length(size))
		return 0;

	if ((size == 901120) || (size == 912384) || (size == 1802240))
		return 50;

	return 0;
}

bool adf_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
	desc_s sectors[22];
	uint8_t sectdata[512*22];
	bool is_hd = false;
	int tracks = 80;

	for (int i=0; i<22; i++) {
		sectors[i].data = sectdata + 512*i;
		sectors[i].size = 512;
		sectors[i].sector_id = i;
	}

	uint64_t size;
	if (io.length(size))
		return false;

	if (size == 901120) {
		is_hd = false;
		tracks = 80;
	} else if (size == 912384) {
		is_hd = false;
		tracks = 81;
	} else {
		is_hd = true;
		tracks = 80;
	}

	if (!is_hd) {
		image->set_variant(floppy_image::DSDD);
		for (int track=0; track < tracks; track++) {
			for (int side=0; side < 2; side++) {
				size_t actual;
				io.read_at((track*2 + side)*512*11, sectdata, 512*11, actual);
				generate_track(amiga_11, track, side, sectors, 11, 100000, image);
			}
		}
	} else {
		image->set_variant(floppy_image::DSHD);
		for (int track=0; track < tracks; track++) {
			for (int side=0; side < 2; side++) {
				size_t actual;
				io.read_at((track*2 + side)*512*22, sectdata, 512*22, actual);
				generate_track(amiga_22, track, side, sectors, 22, 200000, image);
			}
		}
	}

	return true;
}

uint32_t adf_format::g32(const std::vector<bool> &trackbuf, uint32_t pos)
{
	uint32_t res = 0;
	for (int i=0; i != 32; i++) {
		if (trackbuf[pos])
			res |= 0x80000000 >> i;
		pos++;
		if (pos == trackbuf.size())
			pos = 0;
	}
	return res;
}

uint32_t adf_format::checksum(const std::vector<bool> &trackbuf, uint32_t pos, int long_count)
{
	uint32_t check = 0;
	for (int i=0; i<long_count; i++)
		check ^= g32(trackbuf, pos+32*i);
	return check & 0x55555555;
}

bool adf_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
	uint8_t sectdata[512*22];

	bool const hd = image->get_variant() == floppy_image::DSHD;

	int const data_track_size = hd ? 512*22 : 512*11;

	for (int track=0; track < 80; track++) {
		for (int side=0; side < 2; side++) {
			auto trackbuf = generate_bitstream_from_track(track, side, hd ? 1000 : 2000, image);

			for (uint32_t i=0; i<trackbuf.size(); i++)
				if (g32(trackbuf, i) == 0x44894489 &&
					(g32(trackbuf, i+384) & 0x55555555) == checksum(trackbuf, i+32, 10) &&
					(g32(trackbuf, i+448) & 0x55555555) == checksum(trackbuf, i+480, 256)) {
					uint32_t head = ((g32(trackbuf, i+32) & 0x55555555) << 1) | (g32(trackbuf, i+64) & 0x55555555);
					int sect = (head >> 8) & 0xff;
					if (sect > (hd ? 22 : 11))
						continue;

					uint8_t *dest = sectdata + 512*sect;
					for (int j=0; j<128; j++) {
						uint32_t val = ((g32(trackbuf, i+480+32*j) & 0x55555555) << 1) | (g32(trackbuf, i+4576+32*j) & 0x55555555);
						*dest++ = val >> 24;
						*dest++ = val >> 16;
						*dest++ = val >> 8;
						*dest++ = val;
					}

					size_t actual;
					io.write_at((track*2 + side) * data_track_size, sectdata, data_track_size, actual);
				}
		}
	}
	return true;
}

const floppy_format_type FLOPPY_ADF_FORMAT = &floppy_image_format_creator<adf_format>;