fork of PCE focusing on macplus, supporting DaynaPort SCSI network emulation
pri: Support MOOF version 1.0 files
Flux captures are not supported.
+907
-5
+7
Makefile.dep
+7
Makefile.dep
···
2617
2617
src/drivers/pri/pri.h \
2618
2618
src/drivers/psi/psi.h
2619
2619
2620
+
src/drivers/pri/pri-img-moof.o: src/drivers/pri/pri-img-moof.c \
2621
+
src/config.h \
2622
+
src/drivers/pri/pri-img-moof.h \
2623
+
src/drivers/pri/pri-img.h \
2624
+
src/drivers/pri/pri.h
2625
+
2620
2626
src/drivers/pri/pri-img-pbit.o: src/drivers/pri/pri-img-pbit.c \
2621
2627
src/drivers/pri/pri-img-pbit.h \
2622
2628
src/drivers/pri/pri-img.h \
···
2639
2645
src/drivers/pri/pri.h
2640
2646
2641
2647
src/drivers/pri/pri-img.o: src/drivers/pri/pri-img.c \
2648
+
src/drivers/pri/pri-img-moof.h \
2642
2649
src/drivers/pri/pri-img-pbit.h \
2643
2650
src/drivers/pri/pri-img-pri.h \
2644
2651
src/drivers/pri/pri-img-tc.h \
+2
src/drivers/pri/Makefile.inc
+2
src/drivers/pri/Makefile.inc
···
9
9
pri-enc-fm \
10
10
pri-enc-gcr \
11
11
pri-enc-mfm \
12
+
pri-img-moof \
12
13
pri-img-pbit \
13
14
pri-img-pri \
14
15
pri-img-tc \
···
27
28
$(rel)/pri-enc-fm.o: $(rel)/pri-enc-fm.c
28
29
$(rel)/pri-enc-gcr.o: $(rel)/pri-enc-gcr.c
29
30
$(rel)/pri-enc-mfm.o: $(rel)/pri-enc-mfm.c
31
+
$(rel)/pri-img-moof.o: $(rel)/pri-img-moof.c
30
32
$(rel)/pri-img-pbit.o: $(rel)/pri-img-pbit.c
31
33
$(rel)/pri-img-pri.o: $(rel)/pri-img-pri.c
32
34
$(rel)/pri-img-tc.o: $(rel)/pri-img-tc.c
+827
src/drivers/pri/pri-img-moof.c
+827
src/drivers/pri/pri-img-moof.c
···
1
+
/*****************************************************************************
2
+
* pce *
3
+
*****************************************************************************/
4
+
5
+
/*****************************************************************************
6
+
* File name: src/drivers/pri/pri-img-moof.c *
7
+
* Created: 2022-10-02 by Hampa Hug <hampa@hampa.ch> *
8
+
* Copyright: (C) 2022-2023 Hampa Hug <hampa@hampa.ch> *
9
+
*****************************************************************************/
10
+
11
+
/*****************************************************************************
12
+
* This program is free software. You can redistribute it and / or modify it *
13
+
* under the terms of the GNU General Public License version 2 as published *
14
+
* by the Free Software Foundation. *
15
+
* *
16
+
* This program is distributed in the hope that it will be useful, but *
17
+
* WITHOUT ANY WARRANTY, without even the implied warranty of *
18
+
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General *
19
+
* Public License for more details. *
20
+
*****************************************************************************/
21
+
22
+
23
+
#include <config.h>
24
+
25
+
#include <stdint.h>
26
+
#include <stdlib.h>
27
+
#include <stdio.h>
28
+
#include <string.h>
29
+
30
+
#include "pri.h"
31
+
#include "pri-img.h"
32
+
#include "pri-img-moof.h"
33
+
34
+
35
+
#ifndef DEBUG_MOOF
36
+
#define DEBUG_MOOF 0
37
+
#endif
38
+
39
+
#define MOOF_MAGIC_MOOF 0x464f4f4d
40
+
#define MOOF_MAGIC_2 0x0a0d0aff
41
+
#define MOOF_MAGIC_INFO 0x4f464e49
42
+
#define MOOF_MAGIC_TMAP 0x50414d54
43
+
#define MOOF_MAGIC_TRKS 0x534b5254
44
+
#define MOOF_MAGIC_META 0x4154454d
45
+
#define MOOF_MAGIC_FLUX 0x58554c46
46
+
47
+
48
+
typedef struct {
49
+
FILE *fp;
50
+
unsigned long ofs;
51
+
52
+
pri_img_t *img;
53
+
54
+
char have_info;
55
+
char have_tmap;
56
+
57
+
unsigned char info[64];
58
+
unsigned char tmap[160];
59
+
unsigned char trkh[8 * 160];
60
+
char creator[64];
61
+
62
+
unsigned short flux_block;
63
+
unsigned short flux_size;
64
+
65
+
unsigned long clock;
66
+
67
+
unsigned long crc;
68
+
} moof_load_t;
69
+
70
+
71
+
typedef struct {
72
+
FILE *fp;
73
+
const pri_img_t *img;
74
+
75
+
unsigned long ofs;
76
+
77
+
unsigned char disk_type;
78
+
unsigned char sides;
79
+
unsigned long clock;
80
+
unsigned long largest_track;
81
+
82
+
pri_trk_t *track[160];
83
+
unsigned long track_size[160];
84
+
} moof_save_t;
85
+
86
+
87
+
static
88
+
unsigned long moof_crc (unsigned long crc, const void *buf, unsigned cnt)
89
+
{
90
+
unsigned i;
91
+
const unsigned char *p;
92
+
93
+
p = buf;
94
+
95
+
while (cnt > 0) {
96
+
crc ^= *(p++);
97
+
98
+
for (i = 0; i < 8; i++) {
99
+
if (crc & 1) {
100
+
crc = (crc >> 1) ^ 0xedb88320;
101
+
}
102
+
else {
103
+
crc = crc >> 1;
104
+
}
105
+
}
106
+
107
+
cnt -= 1;
108
+
}
109
+
110
+
return (crc);
111
+
}
112
+
113
+
static
114
+
void moof_get_string (char *dst, const unsigned char *src, unsigned max)
115
+
{
116
+
unsigned i;
117
+
118
+
for (i = 0; i < max; i++) {
119
+
if ((dst[i] = src[i]) == 0) {
120
+
break;
121
+
}
122
+
}
123
+
124
+
while ((i > 0) && (dst[i - 1] == 0x20)) {
125
+
i -= 1;
126
+
}
127
+
128
+
dst[i] = 0;
129
+
}
130
+
131
+
static
132
+
int moof_set_pos (moof_load_t *moof, unsigned long ofs)
133
+
{
134
+
if (pri_set_ofs (moof->fp, ofs)) {
135
+
return (1);
136
+
}
137
+
138
+
moof->ofs = ofs;
139
+
140
+
return (0);
141
+
}
142
+
143
+
static
144
+
int moof_read (moof_load_t *moof, void *buf, unsigned long cnt)
145
+
{
146
+
if (pri_read (moof->fp, buf, cnt)) {
147
+
return (1);
148
+
}
149
+
150
+
moof->ofs += cnt;
151
+
152
+
return (0);
153
+
}
154
+
155
+
static
156
+
int moof_skip (moof_load_t *moof, unsigned long cnt)
157
+
{
158
+
if (pri_skip (moof->fp, cnt)) {
159
+
return (1);
160
+
}
161
+
162
+
moof->ofs += cnt;
163
+
164
+
return (0);
165
+
}
166
+
167
+
static
168
+
int moof_load_crc (moof_load_t *moof, unsigned long *val)
169
+
{
170
+
unsigned n;
171
+
unsigned long crc;
172
+
unsigned char buf[256];
173
+
174
+
crc = ~0UL & 0xffffffff;
175
+
176
+
while ((n = fread (buf, 1, 256, moof->fp)) > 0) {
177
+
crc = moof_crc (crc, buf, n);
178
+
}
179
+
180
+
*val = ~crc & 0xffffffff;
181
+
182
+
return (0);
183
+
}
184
+
185
+
static
186
+
int moof_load_header (moof_load_t *moof)
187
+
{
188
+
unsigned long crc;
189
+
unsigned char buf[12];
190
+
191
+
if (moof_read (moof, buf, 12)) {
192
+
return (1);
193
+
}
194
+
195
+
if (pri_get_uint32_le (buf, 0) != MOOF_MAGIC_MOOF) {
196
+
fprintf (stderr, "moof: bad magic 1\n");
197
+
return (1);
198
+
}
199
+
200
+
if (pri_get_uint32_le (buf, 4) != MOOF_MAGIC_2) {
201
+
fprintf (stderr, "moof: bad magic 2\n");
202
+
return (1);
203
+
}
204
+
205
+
moof->crc = pri_get_uint32_le (buf, 8);
206
+
207
+
if (moof->crc != 0) {
208
+
if (moof_load_crc (moof, &crc)) {
209
+
return (1);
210
+
}
211
+
212
+
if (moof->crc != crc) {
213
+
fprintf (stderr, "moof: crc error (%08lX / %08lX)\n", moof->crc, crc);
214
+
return (1);
215
+
}
216
+
}
217
+
218
+
if (moof_set_pos (moof, 12)) {
219
+
return (1);
220
+
}
221
+
222
+
return (0);
223
+
}
224
+
225
+
static
226
+
int moof_load_meta (moof_load_t *moof, unsigned long size)
227
+
{
228
+
unsigned n;
229
+
unsigned char buf[256];
230
+
231
+
while (size > 0) {
232
+
n = (size < 256) ? size : 256;
233
+
234
+
if (moof_read (moof, buf, n)) {
235
+
return (1);
236
+
}
237
+
238
+
if (pri_img_add_comment (moof->img, buf, n)) {
239
+
return (1);
240
+
}
241
+
242
+
size -= n;
243
+
}
244
+
245
+
return (0);
246
+
}
247
+
248
+
static
249
+
int moof_load_info (moof_load_t *moof, unsigned long size)
250
+
{
251
+
unsigned char *p;
252
+
253
+
if (size < 60) {
254
+
return (1);
255
+
}
256
+
257
+
if (moof_read (moof, moof->info, 60)) {
258
+
return (1);
259
+
}
260
+
261
+
p = moof->info;
262
+
263
+
if (p[0] != 1) {
264
+
fprintf (stderr, "moof: unsupported info version (%u)\n", p[0]);
265
+
return (1);
266
+
}
267
+
268
+
if (p[4] == 0) {
269
+
fprintf (stderr, "moof: bad bit clock (%u)\n", p[4]);
270
+
return (1);
271
+
}
272
+
273
+
moof->clock = 8000000 / p[4];
274
+
275
+
moof->img->readonly = (p[2] != 0);
276
+
moof->img->woz_track_sync = (p[3] != 0);
277
+
278
+
moof_get_string (moof->creator, p + 5, 32);
279
+
280
+
moof->flux_block = pri_get_uint16_le (p, 40);
281
+
moof->flux_size = pri_get_uint16_le (p, 44);
282
+
283
+
if (moof->flux_block != 0) {
284
+
fprintf (stderr, "moof: ignoring flux data\n");
285
+
}
286
+
287
+
#if DEBUG_MOOF >= 1
288
+
fprintf (stderr, "moof: disk type = %u\n", p[1]);
289
+
fprintf (stderr, "moof: write protected = %u\n", p[2]);
290
+
fprintf (stderr, "moof: synchronized = %u\n", p[3]);
291
+
fprintf (stderr, "moof: creator = '%s'\n", moof->creator);
292
+
fprintf (stderr, "moof: bit clock = %lu\n", moof->clock);
293
+
#endif
294
+
295
+
if (moof_skip (moof, size - 60)) {
296
+
return (1);
297
+
}
298
+
299
+
return (0);
300
+
}
301
+
302
+
static
303
+
int moof_load_tmap (moof_load_t *moof, unsigned long size)
304
+
{
305
+
if (size < 160) {
306
+
return (1);
307
+
}
308
+
309
+
if (moof_read (moof, moof->tmap, 160)) {
310
+
return (1);
311
+
}
312
+
313
+
if (moof_skip (moof, size - 160)) {
314
+
return (1);
315
+
}
316
+
317
+
return (0);
318
+
}
319
+
320
+
static
321
+
int moof_load_trks (moof_load_t *moof, unsigned long size)
322
+
{
323
+
unsigned i;
324
+
unsigned c, h;
325
+
unsigned idx;
326
+
unsigned long ofs, bit, cnt;
327
+
unsigned long next;
328
+
pri_trk_t *trk;
329
+
330
+
next = moof->ofs + size;
331
+
332
+
if (size < (8 * 160)) {
333
+
return (1);
334
+
}
335
+
336
+
if (moof_read (moof, moof->trkh, 8 * 160)) {
337
+
return (1);
338
+
}
339
+
340
+
for (i = 0; i < 160; i++) {
341
+
idx = moof->tmap[i];
342
+
343
+
if (idx == 0xff) {
344
+
continue;
345
+
}
346
+
else if (idx >= 160) {
347
+
return (1);
348
+
}
349
+
350
+
c = i >> 1;
351
+
h = i & 1;
352
+
353
+
ofs = pri_get_uint16_le (moof->trkh, 8 * idx);
354
+
bit = pri_get_uint32_le (moof->trkh, 8 * idx + 4);
355
+
356
+
ofs *= 512;
357
+
cnt = (bit + 7) / 8;
358
+
359
+
#if DEBUG_MOOF >= 2
360
+
fprintf (stderr, "moof: %u/%u %06lX+%04lX\n", c, h, ofs, cnt);
361
+
#endif
362
+
363
+
if ((trk = pri_img_get_track (moof->img, c, h, 1)) == NULL) {
364
+
return (1);
365
+
}
366
+
367
+
pri_trk_set_clock (trk, moof->clock);
368
+
369
+
if (pri_trk_set_size (trk, bit)) {
370
+
return (1);
371
+
}
372
+
373
+
if (pri_read_ofs (moof->fp, ofs, trk->data, cnt)) {
374
+
return (1);
375
+
}
376
+
}
377
+
378
+
if (moof_set_pos (moof, next)) {
379
+
return (1);
380
+
}
381
+
382
+
return (0);
383
+
}
384
+
385
+
static
386
+
int moof_load_img (moof_load_t *moof)
387
+
{
388
+
unsigned long type, size;
389
+
unsigned char buf[8];
390
+
391
+
if (moof_load_header (moof)) {
392
+
return (1);
393
+
}
394
+
395
+
while (moof_read (moof, buf, 8) == 0) {
396
+
type = pri_get_uint32_le (buf, 0);
397
+
size = pri_get_uint32_le (buf, 4);
398
+
399
+
#if DEBUG_MOOF >= 2
400
+
fprintf (stderr, "moof: %08lX: type=%08lX size=%08lX\n",
401
+
moof->ofs - 8, type, size
402
+
);
403
+
#endif
404
+
405
+
if (type == MOOF_MAGIC_INFO) {
406
+
if (moof_load_info (moof, size)) {
407
+
return (1);
408
+
}
409
+
410
+
moof->have_info = 1;
411
+
}
412
+
else if (type == MOOF_MAGIC_TMAP) {
413
+
if (moof_load_tmap (moof, size)) {
414
+
return (1);
415
+
}
416
+
417
+
moof->have_tmap = 1;
418
+
}
419
+
else if (type == MOOF_MAGIC_FLUX) {
420
+
fprintf (stderr, "moof: ignoring FLUX chunk\n");
421
+
422
+
if (moof_skip (moof, size)) {
423
+
return (1);
424
+
}
425
+
}
426
+
else if (type == MOOF_MAGIC_TRKS) {
427
+
if ((moof->have_info == 0) || (moof->have_tmap == 0)) {
428
+
return (1);
429
+
}
430
+
431
+
if (moof_load_trks (moof, size)) {
432
+
return (1);
433
+
}
434
+
}
435
+
else if (type == MOOF_MAGIC_META) {
436
+
if (moof_load_meta (moof, size)) {
437
+
return (1);
438
+
}
439
+
}
440
+
else if ((type == 0) && (size == 0)) {
441
+
break;
442
+
}
443
+
else {
444
+
fprintf (stderr,
445
+
"moof: unknown chunk type (%08lX / %08lX)\n",
446
+
type, size
447
+
);
448
+
449
+
if (moof_skip (moof, size)) {
450
+
return (1);
451
+
}
452
+
}
453
+
}
454
+
455
+
return (0);
456
+
}
457
+
458
+
pri_img_t *pri_load_moof (FILE *fp)
459
+
{
460
+
moof_load_t moof;
461
+
462
+
memset (&moof, 0, sizeof (moof_load_t));
463
+
464
+
moof.fp = fp;
465
+
466
+
if ((moof.img = pri_img_new()) == NULL) {
467
+
return (NULL);
468
+
}
469
+
470
+
if (moof_load_img (&moof)) {
471
+
pri_img_del (moof.img);
472
+
return (NULL);
473
+
}
474
+
475
+
return (moof.img);
476
+
}
477
+
478
+
479
+
static
480
+
int moof_set_string (unsigned char *dst, const char *src, unsigned max)
481
+
{
482
+
unsigned i;
483
+
484
+
for (i = 0; i < max; i++) {
485
+
if (*src == 0) {
486
+
dst[i] = 0x20;
487
+
}
488
+
else {
489
+
dst[i] = *(src++);
490
+
}
491
+
}
492
+
493
+
return (*src != 0);
494
+
}
495
+
496
+
static
497
+
int moof_save_init (moof_save_t *moof, FILE *fp, const pri_img_t *img)
498
+
{
499
+
unsigned i;
500
+
pri_trk_t *trk;
501
+
502
+
memset (moof, 0, sizeof (moof_save_t));
503
+
504
+
moof->fp = fp;
505
+
moof->img = img;
506
+
moof->sides = 1;
507
+
508
+
for (i = 0; i < 160; i++) {
509
+
trk = pri_img_get_track_const (moof->img, i >> 1, i & 1);
510
+
511
+
if (trk == NULL) {
512
+
continue;
513
+
}
514
+
515
+
moof->track[i] = trk;
516
+
moof->track_size[i] = trk->size;
517
+
518
+
if (i & 1) {
519
+
moof->sides = 2;
520
+
}
521
+
522
+
if (moof->track_size[i] > moof->largest_track) {
523
+
moof->largest_track = moof->track_size[i];
524
+
}
525
+
526
+
if (trk->clock > moof->clock) {
527
+
moof->clock = trk->clock;
528
+
}
529
+
}
530
+
531
+
if (moof->clock == 0) {
532
+
moof->clock = 500000;
533
+
}
534
+
535
+
if (moof->sides < 2) {
536
+
moof->disk_type = 1;
537
+
}
538
+
else if (moof->clock > 750000) {
539
+
moof->disk_type = 3;
540
+
}
541
+
else {
542
+
moof->disk_type = 2;
543
+
}
544
+
545
+
return (1);
546
+
}
547
+
548
+
static
549
+
int moof_save_header (moof_save_t *moof)
550
+
{
551
+
unsigned char buf[12];
552
+
553
+
pri_set_uint32_le (buf, 0, MOOF_MAGIC_MOOF);
554
+
pri_set_uint32_le (buf, 4, MOOF_MAGIC_2);
555
+
pri_set_uint32_le (buf, 8, 0);
556
+
557
+
if (pri_write_ofs (moof->fp, 0, buf, 12)) {
558
+
return (1);
559
+
}
560
+
561
+
moof->ofs = 12;
562
+
563
+
return (0);
564
+
}
565
+
566
+
static
567
+
int moof_save_crc (moof_save_t *moof)
568
+
{
569
+
unsigned n;
570
+
unsigned long crc;
571
+
unsigned long size;
572
+
unsigned char buf[256];
573
+
574
+
if (pri_read_ofs (moof->fp, 12, buf, 244)) {
575
+
return (1);
576
+
}
577
+
578
+
crc = moof_crc (~0UL, buf, 244);
579
+
580
+
size = moof->ofs - 256;
581
+
582
+
while (size > 0) {
583
+
n = (size < 256) ? size : 256;
584
+
585
+
if (pri_read (moof->fp, buf, n)) {
586
+
return (1);
587
+
}
588
+
589
+
crc = moof_crc (crc, buf, n);
590
+
591
+
size -= n;
592
+
}
593
+
594
+
pri_set_uint32_le (buf, 0, ~crc);
595
+
596
+
if (pri_write_ofs (moof->fp, 8, buf, 4)) {
597
+
return (1);
598
+
}
599
+
600
+
return (0);
601
+
}
602
+
603
+
static
604
+
int moof_save_info (moof_save_t *moof)
605
+
{
606
+
unsigned char buf[68];
607
+
char str[256];
608
+
609
+
memset (buf, 0, 68);
610
+
611
+
pri_set_uint32_le (buf, 0, MOOF_MAGIC_INFO);
612
+
pri_set_uint32_le (buf, 4, 60);
613
+
614
+
buf[8] = 1; /* version */
615
+
buf[9] = moof->disk_type;
616
+
buf[10] = (moof->img->readonly != 0);
617
+
buf[11] = (moof->img->woz_track_sync != 0);
618
+
buf[12] = 8000000 / moof->clock;
619
+
620
+
strcpy (str, "pce-" PCE_VERSION_STR);
621
+
622
+
moof_set_string (buf + 13, str, 32);
623
+
624
+
pri_set_uint16_le (buf, 46, (moof->largest_track + 4095) / 4096);
625
+
626
+
if (pri_write_ofs (moof->fp, moof->ofs, buf, 68)) {
627
+
return (1);
628
+
}
629
+
630
+
moof->ofs += 68;
631
+
632
+
return (0);
633
+
}
634
+
635
+
static
636
+
int moof_save_tmap (moof_save_t *moof)
637
+
{
638
+
unsigned i, n;
639
+
unsigned char buf[168];
640
+
641
+
pri_set_uint32_le (buf, 0, MOOF_MAGIC_TMAP);
642
+
pri_set_uint32_le (buf, 4, 160);
643
+
644
+
n = 0;
645
+
646
+
for (i = 0; i < 160; i++) {
647
+
if (moof->track_size[i] == 0) {
648
+
buf[i + 8] = 0xff;
649
+
}
650
+
else {
651
+
buf[i + 8] = n++;
652
+
}
653
+
}
654
+
655
+
if (pri_write_ofs (moof->fp, moof->ofs, buf, 168)) {
656
+
return (1);
657
+
}
658
+
659
+
moof->ofs += 168;
660
+
661
+
return (0);
662
+
}
663
+
664
+
static
665
+
int moof_save_trks (moof_save_t *moof)
666
+
{
667
+
unsigned i, n;
668
+
unsigned long bytes;
669
+
unsigned long ofs;
670
+
pri_trk_t *trk;
671
+
unsigned char buf[1288];
672
+
unsigned char zero[1];
673
+
674
+
memset (buf, 0, sizeof (buf));
675
+
676
+
pri_set_uint32_le (buf, 0, MOOF_MAGIC_TRKS);
677
+
678
+
ofs = (moof->ofs + 1288 + 511) & ~511UL;
679
+
680
+
n = 8;
681
+
682
+
for (i = 0; i < 160; i++) {
683
+
if (moof->track_size[i] == 0) {
684
+
continue;
685
+
}
686
+
687
+
trk = moof->track[i];
688
+
bytes = (trk->size + 7) / 8;
689
+
690
+
pri_set_uint16_le (buf, n + 0, (ofs + 511) / 512);
691
+
pri_set_uint16_le (buf, n + 2, (bytes + 511) / 512);
692
+
pri_set_uint32_le (buf, n + 4, trk->size);
693
+
694
+
n += 8;
695
+
696
+
if (pri_write_ofs (moof->fp, ofs, trk->data, bytes)) {
697
+
return (1);
698
+
}
699
+
700
+
ofs = (ofs + bytes + 511) & ~511UL;
701
+
702
+
if (bytes & 511) {
703
+
zero[0] = 0;
704
+
705
+
if (pri_write_ofs (moof->fp, ofs - 1, zero, 1)) {
706
+
return (1);
707
+
}
708
+
}
709
+
}
710
+
711
+
pri_set_uint32_le (buf, 4, ofs - moof->ofs - 8);
712
+
713
+
if (pri_write_ofs (moof->fp, moof->ofs, buf, 1288)) {
714
+
return (1);
715
+
}
716
+
717
+
moof->ofs = ofs;
718
+
719
+
return (0);
720
+
}
721
+
722
+
static
723
+
int moof_save_meta (moof_save_t *moof)
724
+
{
725
+
unsigned long size;
726
+
unsigned char buf[8];
727
+
728
+
size = moof->img->comment_size;
729
+
730
+
if (size == 0) {
731
+
return (0);
732
+
}
733
+
734
+
pri_set_uint32_le (buf, 0, MOOF_MAGIC_META);
735
+
pri_set_uint32_le (buf, 4, size);
736
+
737
+
if (pri_write_ofs (moof->fp, moof->ofs, buf, 8)) {
738
+
return (1);
739
+
}
740
+
741
+
if (pri_write (moof->fp, moof->img->comment, size)) {
742
+
return (1);
743
+
}
744
+
745
+
moof->ofs += 8 + size;
746
+
747
+
return (0);
748
+
}
749
+
750
+
static
751
+
int moof_save_img (moof_save_t *moof)
752
+
{
753
+
if (moof_save_header (moof)) {
754
+
return (1);
755
+
}
756
+
757
+
if (moof_save_info (moof)) {
758
+
return (1);
759
+
}
760
+
761
+
if (moof_save_tmap (moof)) {
762
+
return (1);
763
+
}
764
+
765
+
if (moof_save_trks (moof)) {
766
+
return (1);
767
+
}
768
+
769
+
if (moof_save_meta (moof)) {
770
+
return (1);
771
+
}
772
+
773
+
if (moof_save_crc (moof)) {
774
+
return (1);
775
+
}
776
+
777
+
return (0);
778
+
}
779
+
780
+
int pri_save_moof (FILE *fp, const pri_img_t *img)
781
+
{
782
+
moof_save_t moof;
783
+
784
+
moof_save_init (&moof, fp, img);
785
+
786
+
if (moof_save_img (&moof)) {
787
+
return (1);
788
+
}
789
+
790
+
return (0);
791
+
}
792
+
793
+
794
+
int pri_probe_moof_fp (FILE *fp)
795
+
{
796
+
unsigned char buf[8];
797
+
798
+
if (pri_read_ofs (fp, 0, buf, 8)) {
799
+
return (0);
800
+
}
801
+
802
+
if (pri_get_uint32_le (buf, 0) != MOOF_MAGIC_MOOF) {
803
+
return (0);
804
+
}
805
+
806
+
if (pri_get_uint32_le (buf, 4) != MOOF_MAGIC_2) {
807
+
return (0);
808
+
}
809
+
810
+
return (1);
811
+
}
812
+
813
+
int pri_probe_moof (const char *fname)
814
+
{
815
+
int r;
816
+
FILE *fp;
817
+
818
+
if ((fp = fopen (fname, "rb")) == NULL) {
819
+
return (0);
820
+
}
821
+
822
+
r = pri_probe_moof_fp (fp);
823
+
824
+
fclose (fp);
825
+
826
+
return (r);
827
+
}
+38
src/drivers/pri/pri-img-moof.h
+38
src/drivers/pri/pri-img-moof.h
···
1
+
/*****************************************************************************
2
+
* pce *
3
+
*****************************************************************************/
4
+
5
+
/*****************************************************************************
6
+
* File name: src/drivers/pri/pri-img-moof.h *
7
+
* Created: 2022-10-02 by Hampa Hug <hampa@hampa.ch> *
8
+
* Copyright: (C) 2022 Hampa Hug <hampa@hampa.ch> *
9
+
*****************************************************************************/
10
+
11
+
/*****************************************************************************
12
+
* This program is free software. You can redistribute it and / or modify it *
13
+
* under the terms of the GNU General Public License version 2 as published *
14
+
* by the Free Software Foundation. *
15
+
* *
16
+
* This program is distributed in the hope that it will be useful, but *
17
+
* WITHOUT ANY WARRANTY, without even the implied warranty of *
18
+
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General *
19
+
* Public License for more details. *
20
+
*****************************************************************************/
21
+
22
+
23
+
#ifndef PCE_PRI_IMG_MOOF_H
24
+
#define PCE_PRI_IMG_MOOF_H 1
25
+
26
+
27
+
#include <drivers/pri/pri.h>
28
+
29
+
30
+
pri_img_t *pri_load_moof (FILE *fp);
31
+
32
+
int pri_save_moof (FILE *fp, const pri_img_t *img);
33
+
34
+
int pri_probe_moof_fp (FILE *fp);
35
+
int pri_probe_moof (const char *fname);
36
+
37
+
38
+
#endif
+20
-2
src/drivers/pri/pri-img.c
+20
-2
src/drivers/pri/pri-img.c
···
5
5
/*****************************************************************************
6
6
* File name: src/drivers/pri/pri-img.c *
7
7
* Created: 2012-01-31 by Hampa Hug <hampa@hampa.ch> *
8
-
* Copyright: (C) 2012-2019 Hampa Hug <hampa@hampa.ch> *
8
+
* Copyright: (C) 2012-2022 Hampa Hug <hampa@hampa.ch> *
9
9
*****************************************************************************/
10
10
11
11
/*****************************************************************************
···
15
15
* *
16
16
* This program is distributed in the hope that it will be useful, but *
17
17
* WITHOUT ANY WARRANTY, without even the implied warranty of *
18
-
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General *
18
+
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General *
19
19
* Public License for more details. *
20
20
*****************************************************************************/
21
21
···
25
25
#include <string.h>
26
26
27
27
#include "pri-img.h"
28
+
#include "pri-img-moof.h"
28
29
#include "pri-img-pbit.h"
29
30
#include "pri-img-pri.h"
30
31
#include "pri-img-tc.h"
···
232
233
else if (strcasecmp (ext, ".woz") == 0) {
233
234
return (PRI_FORMAT_WOZ);
234
235
}
236
+
else if (strcasecmp (ext, ".moof") == 0) {
237
+
return (PRI_FORMAT_MOOF);
238
+
}
235
239
236
240
return (PRI_FORMAT_NONE);
237
241
}
···
269
273
else if (strcasecmp (ext, ".woz") == 0) {
270
274
return (PRI_FORMAT_WOZ);
271
275
}
276
+
else if (strcasecmp (ext, ".moof") == 0) {
277
+
return (PRI_FORMAT_MOOF);
278
+
}
272
279
273
280
return (PRI_FORMAT_PRI);
274
281
}
···
281
288
img = NULL;
282
289
283
290
switch (type) {
291
+
case PRI_FORMAT_MOOF:
292
+
img = pri_load_moof (fp);
293
+
break;
294
+
284
295
case PRI_FORMAT_PBIT:
285
296
img = pri_load_pbit (fp);
286
297
break;
···
322
333
int pri_img_save_fp (FILE *fp, const pri_img_t *img, unsigned type)
323
334
{
324
335
switch (type) {
336
+
case PRI_FORMAT_MOOF:
337
+
return (pri_save_moof (fp, img));
338
+
325
339
case PRI_FORMAT_PBIT:
326
340
return (pri_save_pbit (fp, img));
327
341
···
372
386
373
387
if (pri_probe_woz_fp (fp)) {
374
388
return (PRI_FORMAT_WOZ);
389
+
}
390
+
391
+
if (pri_probe_moof_fp (fp)) {
392
+
return (PRI_FORMAT_MOOF);
375
393
}
376
394
377
395
return (PRI_FORMAT_NONE);
+3
-2
src/drivers/pri/pri-img.h
+3
-2
src/drivers/pri/pri-img.h
···
5
5
/*****************************************************************************
6
6
* File name: src/drivers/pri/pri-img.h *
7
7
* Created: 2012-01-31 by Hampa Hug <hampa@hampa.ch> *
8
-
* Copyright: (C) 2012-2019 Hampa Hug <hampa@hampa.ch> *
8
+
* Copyright: (C) 2012-2022 Hampa Hug <hampa@hampa.ch> *
9
9
*****************************************************************************/
10
10
11
11
/*****************************************************************************
···
15
15
* *
16
16
* This program is distributed in the hope that it will be useful, but *
17
17
* WITHOUT ANY WARRANTY, without even the implied warranty of *
18
-
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General *
18
+
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General *
19
19
* Public License for more details. *
20
20
*****************************************************************************/
21
21
···
34
34
#define PRI_FORMAT_PRI 2
35
35
#define PRI_FORMAT_TC 3
36
36
#define PRI_FORMAT_WOZ 4
37
+
#define PRI_FORMAT_MOOF 5
37
38
38
39
39
40
unsigned pri_get_uint16_be (const void *buf, unsigned idx);
+7
-1
src/utils/pri/main.c
+7
-1
src/utils/pri/main.c
···
204
204
" ibm-mfm, ibm-mfm-dd-300, ibm-mfm-hd-300, ibm-mfm-hd-360\n"
205
205
"\n"
206
206
"file formats are:\n"
207
-
" pri, tc, woz\n"
207
+
" pri, tc, woz, moof\n"
208
208
"\n"
209
209
"image attributes are:\n"
210
210
" readonly, woz-cleaned, woz-track-sync\n"
···
804
804
}
805
805
else if (strcmp (name, "tc") == 0) {
806
806
*val = PRI_FORMAT_TC;
807
+
}
808
+
else if (strcmp (name, "woz") == 0) {
809
+
*val = PRI_FORMAT_WOZ;
810
+
}
811
+
else if (strcmp (name, "moof") == 0) {
812
+
*val = PRI_FORMAT_MOOF;
807
813
}
808
814
else {
809
815
fprintf (stderr, "%s: unknown format (%s)\n", arg0, name);