fork of PCE focusing on macplus, supporting DaynaPort SCSI network emulation
pri: Add support for the new PRI format
+745
-4
+6
Makefile.dep
+6
Makefile.dep
···
1789
1789
src/drivers/pri/pri-img.h \
1790
1790
src/drivers/pri/pri.h
1791
1791
1792
+
src/drivers/pri/pri-img-pri.o: src/drivers/pri/pri-img-pri.c \
1793
+
src/drivers/pri/pri-img-pri.h \
1794
+
src/drivers/pri/pri-img.h \
1795
+
src/drivers/pri/pri.h
1796
+
1792
1797
src/drivers/pri/pri-img-tc.o: src/drivers/pri/pri-img-tc.c \
1793
1798
src/drivers/pri/pri-img-tc.h \
1794
1799
src/drivers/pri/pri-img.h \
···
1796
1801
1797
1802
src/drivers/pri/pri-img.o: src/drivers/pri/pri-img.c \
1798
1803
src/drivers/pri/pri-img-pbit.h \
1804
+
src/drivers/pri/pri-img-pri.h \
1799
1805
src/drivers/pri/pri-img-tc.h \
1800
1806
src/drivers/pri/pri-img.h \
1801
1807
src/drivers/pri/pri.h
+1
-1
Makefile.inc.in
+1
-1
Makefile.inc.in
···
112
112
113
113
DIST += doc/char-drivers.txt doc/keys.txt doc/messages.txt \
114
114
doc/monitor.txt doc/pce-ibmpc.txt doc/pce-macplus.txt \
115
-
doc/pbit-format.txt doc/pfdc-format.txt doc/psi-format.txt \
115
+
doc/pri-format doc/psi-format.txt \
116
116
doc/rc759-keymap.txt doc/sound-drivers.txt
117
117
118
118
# ----------------------------------------------------------------------
+110
doc/pri-format.txt
+110
doc/pri-format.txt
···
1
+
PRI File Format (2013-06-29)
2
+
========================================================================
3
+
4
+
File structure
5
+
------------------------------------------------------------------------
6
+
7
+
<file header chunk>
8
+
<chunk 0>
9
+
<chunk 1>
10
+
...
11
+
<chunk n>
12
+
<end chunk>
13
+
14
+
All integers are in big-endian format.
15
+
16
+
17
+
Chunk format
18
+
------------------------------------------------------------------------
19
+
20
+
offset size description
21
+
22
+
0 4 Chunk ID
23
+
4 4 Chunk size (n)
24
+
0 n Chunk data
25
+
n 4 Chunk CRC
26
+
27
+
- The size does not include the chunk ID, chunk size or chunk CRC
28
+
fields.
29
+
30
+
- The chunk CRC covers the chunk ID, chunk size and chunk data.
31
+
32
+
33
+
CHUNK "PRI ": File header chunk
34
+
------------------------------------------------------------------------
35
+
36
+
0 4 Magic ('PRI ')
37
+
4 4 Size (4)
38
+
0 2 Version (0)
39
+
2 2 Reserved
40
+
4 4 CRC
41
+
42
+
43
+
CHUNK "END ": End chunk
44
+
------------------------------------------------------------------------
45
+
46
+
0 4 Magic ('END ')
47
+
4 4 Size (0)
48
+
0 4 CRC (0x3d64af78)
49
+
50
+
51
+
CHUNK "TEXT": Comments
52
+
------------------------------------------------------------------------
53
+
54
+
0 4 Magic ('TEXT')
55
+
4 4 Size (n)
56
+
0 n Data
57
+
n 4 CRC
58
+
59
+
- Comments should be UTF-8, with lines separated by LF (0x0a).
60
+
61
+
62
+
CHUNK "TRAK": Track header
63
+
------------------------------------------------------------------------
64
+
65
+
0 4 Magic ('TRAK')
66
+
4 4 Size (16)
67
+
0 4 Cylinder
68
+
4 4 Head
69
+
8 4 Track length in bits
70
+
12 4 Bit clock rate
71
+
16 4 CRC
72
+
73
+
74
+
CHUNK "DATA": Track data
75
+
------------------------------------------------------------------------
76
+
77
+
0 4 Magic ('DATA')
78
+
4 4 Size (n)
79
+
0 n Track data
80
+
n 4 CRC
81
+
82
+
83
+
CRC
84
+
---
85
+
86
+
- The algorithm used is big-endian CRC-32 with generator
87
+
polynomial 0x1edc6f41. The CRC value is initialized to 0.
88
+
89
+
unsigned long pflux_crc (const unsigned char *buf, unsigned cnt)
90
+
{
91
+
unsigned i, j;
92
+
unsigned long crc;
93
+
94
+
crc = 0;
95
+
96
+
for (i = 0; i < cnt; i++) {
97
+
crc ^= (unsigned long) (buf[i] & 0xff) << 24;
98
+
99
+
for (j = 0; j < 8; j++) {
100
+
if (crc & 0x80000000) {
101
+
crc = (crc << 1) ^ 0x1edc6f41;
102
+
}
103
+
else {
104
+
crc = crc << 1;
105
+
}
106
+
}
107
+
}
108
+
109
+
return (crc & 0xffffffff);
110
+
}
+2
src/drivers/pri/Makefile.inc
+2
src/drivers/pri/Makefile.inc
···
9
9
gcr-mac \
10
10
mfm-ibm \
11
11
pri-img-pbit \
12
+
pri-img-pri \
12
13
pri-img-tc \
13
14
pri-img \
14
15
pri
···
24
25
$(rel)/gcr-mac.o: $(rel)/gcr-mac.c
25
26
$(rel)/mfm-ibm.o: $(rel)/mfm-ibm.c
26
27
$(rel)/pri-img-pbit.o: $(rel)/pri-img-pbit.c
28
+
$(rel)/pri-img-pri.o: $(rel)/pri-img-pri.c
27
29
$(rel)/pri-img-tc.o: $(rel)/pri-img-tc.c
28
30
$(rel)/pri-img.o: $(rel)/pri-img.c
29
31
$(rel)/pri.o: $(rel)/pri.c
+567
src/drivers/pri/pri-img-pri.c
+567
src/drivers/pri/pri-img-pri.c
···
1
+
/*****************************************************************************
2
+
* pce *
3
+
*****************************************************************************/
4
+
5
+
/*****************************************************************************
6
+
* File name: src/drivers/pri/pri-img-pri.c *
7
+
* Created: 2012-01-31 by Hampa Hug <hampa@hampa.ch> *
8
+
* Copyright: (C) 2012-2013 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 <stdlib.h>
24
+
#include <stdio.h>
25
+
#include <string.h>
26
+
27
+
#include "pri.h"
28
+
#include "pri-img.h"
29
+
#include "pri-img-pri.h"
30
+
31
+
32
+
#define PRI_CHUNK_PRI 0x50524920
33
+
#define PRI_CHUNK_TEXT 0x54455854
34
+
#define PRI_CHUNK_TRAK 0x5452414b
35
+
#define PRI_CHUNK_DATA 0x44415441
36
+
#define PRI_CHUNK_CLOK 0x434c4f4b
37
+
#define PRI_CHUNK_END 0x454e4420
38
+
39
+
#define PRI_CRC_POLY 0x1edc6f41
40
+
41
+
42
+
static
43
+
unsigned long pri_crc (unsigned long crc, const void *buf, unsigned cnt)
44
+
{
45
+
unsigned i, j;
46
+
unsigned val;
47
+
unsigned long reg;
48
+
const unsigned char *src;
49
+
static int tab_ok = 0;
50
+
static unsigned long tab[256];
51
+
52
+
if (tab_ok == 0) {
53
+
for (i = 0; i < 256; i++) {
54
+
reg = (unsigned long) i << 24;
55
+
56
+
for (j = 0; j < 8; j++) {
57
+
if (reg & 0x80000000) {
58
+
reg = (reg << 1) ^ PRI_CRC_POLY;
59
+
}
60
+
else {
61
+
reg = reg << 1;
62
+
}
63
+
}
64
+
65
+
tab[i] = reg;
66
+
}
67
+
68
+
tab_ok = 1;
69
+
}
70
+
71
+
src = buf;
72
+
73
+
while (cnt > 0) {
74
+
val = (crc >> 24) ^ *(src++);
75
+
crc = (crc << 8) ^ tab[val & 0xff];
76
+
cnt -= 1;
77
+
}
78
+
79
+
return (crc & 0xffffffff);
80
+
}
81
+
82
+
static
83
+
int pri_read_crc (FILE *fp, void *buf, unsigned cnt, unsigned long *crc)
84
+
{
85
+
if (pri_read (fp, buf, cnt)) {
86
+
return (1);
87
+
}
88
+
89
+
if (crc != NULL) {
90
+
*crc = pri_crc (*crc, buf, cnt);
91
+
}
92
+
93
+
return (0);
94
+
}
95
+
96
+
static
97
+
int pri_write_crc (FILE *fp, const void *buf, unsigned cnt, unsigned long *crc)
98
+
{
99
+
if (crc != NULL) {
100
+
*crc = pri_crc (*crc, buf, cnt);
101
+
}
102
+
103
+
if (pri_write (fp, buf, cnt)) {
104
+
return (1);
105
+
}
106
+
107
+
return (0);
108
+
}
109
+
110
+
static
111
+
int pri_skip_chunk (FILE *fp, unsigned long size, unsigned long crc)
112
+
{
113
+
unsigned cnt;
114
+
unsigned char buf[256];
115
+
116
+
while (size > 0) {
117
+
cnt = (size < 256) ? size : 256;
118
+
119
+
if (pri_read_crc (fp, buf, cnt, &crc)) {
120
+
return (1);
121
+
}
122
+
123
+
size -= cnt;
124
+
}
125
+
126
+
if (pri_read (fp, buf, 4)) {
127
+
return (1);
128
+
}
129
+
130
+
if (pri_get_uint32_be (buf, 0) != crc) {
131
+
fprintf (stderr, "pri: crc error\n");
132
+
return (1);
133
+
}
134
+
135
+
return (0);
136
+
}
137
+
138
+
static
139
+
int pri_load_header (FILE *fp, pri_img_t *img, unsigned long size, unsigned long crc)
140
+
{
141
+
unsigned char buf[4];
142
+
unsigned vers;
143
+
144
+
if (size < 4) {
145
+
return (1);
146
+
}
147
+
148
+
if (pri_read_crc (fp, buf, 4, &crc)) {
149
+
return (1);
150
+
}
151
+
152
+
vers = pri_get_uint16_be (buf, 0);
153
+
154
+
if (vers != 0) {
155
+
fprintf (stderr, "pri: unknown version number (%u)\n", vers);
156
+
return (1);
157
+
}
158
+
159
+
if (pri_skip_chunk (fp, size - 4, crc)) {
160
+
return (1);
161
+
}
162
+
163
+
return (0);
164
+
}
165
+
166
+
static
167
+
int pri_load_text (FILE *fp, pri_img_t *img, unsigned long size, unsigned long crc)
168
+
{
169
+
int r;
170
+
unsigned long i, n;
171
+
unsigned char *buf;
172
+
173
+
if (size == 0) {
174
+
return (pri_skip_chunk (fp, size, crc));
175
+
}
176
+
177
+
if ((buf = malloc (size)) == NULL) {
178
+
return (1);
179
+
}
180
+
181
+
if (pri_read_crc (fp, buf, size, &crc)) {
182
+
free (buf);
183
+
return (1);
184
+
}
185
+
186
+
i = 0;
187
+
n = size;
188
+
189
+
if (buf[0] == 0x0a) {
190
+
i = 1;
191
+
n -= 1;
192
+
}
193
+
194
+
if ((n > 0) && (buf[n - 1] == 0x0a)) {
195
+
n -= 1;
196
+
}
197
+
198
+
r = pri_img_add_comment (img, buf + i, n);
199
+
200
+
free (buf);
201
+
202
+
r |= pri_skip_chunk (fp, 0, crc);
203
+
204
+
return (r);
205
+
}
206
+
207
+
static
208
+
int pri_load_trak (FILE *fp, pri_img_t *img, pri_trk_t **trk, unsigned long size, unsigned long crc)
209
+
{
210
+
unsigned long c, h, n, clock;
211
+
unsigned char buf[16];
212
+
213
+
if (size < 16) {
214
+
return (1);
215
+
}
216
+
217
+
if (pri_read_crc (fp, buf, 16, &crc)) {
218
+
return (1);
219
+
}
220
+
221
+
c = pri_get_uint32_be (buf, 0);
222
+
h = pri_get_uint32_be (buf, 4);
223
+
n = pri_get_uint32_be (buf, 8);
224
+
clock = pri_get_uint32_be (buf, 12);
225
+
226
+
if ((*trk = pri_img_get_track (img, c, h, 1)) == NULL) {
227
+
return (1);
228
+
}
229
+
230
+
if (pri_trk_set_size (*trk, n)) {
231
+
return (1);
232
+
}
233
+
234
+
pri_trk_set_clock (*trk, clock);
235
+
236
+
if (pri_skip_chunk (fp, size - 16, crc)) {
237
+
return (1);
238
+
}
239
+
240
+
return (0);
241
+
}
242
+
243
+
static
244
+
int pri_load_data (FILE *fp, pri_img_t *img, pri_trk_t *trk, unsigned long size, unsigned long crc)
245
+
{
246
+
unsigned long cnt;
247
+
248
+
if (trk == NULL) {
249
+
return (1);
250
+
}
251
+
252
+
cnt = (trk->size + 7) / 8;
253
+
254
+
if (cnt > size) {
255
+
cnt = size;
256
+
}
257
+
258
+
if (pri_read_crc (fp, trk->data, cnt, &crc)) {
259
+
return (1);
260
+
}
261
+
262
+
if (pri_skip_chunk (fp, size - cnt, crc)) {
263
+
return (1);
264
+
}
265
+
266
+
return (0);
267
+
}
268
+
269
+
static
270
+
int pri_load_image (FILE *fp, pri_img_t *img)
271
+
{
272
+
unsigned long type, size;
273
+
unsigned long crc;
274
+
pri_trk_t *trk;
275
+
unsigned char buf[8];
276
+
277
+
crc = 0;
278
+
279
+
if (pri_read_crc (fp, buf, 4, &crc)) {
280
+
return (0);
281
+
}
282
+
283
+
type = pri_get_uint32_be (buf, 0);
284
+
285
+
if (type != PRI_CHUNK_PRI) {
286
+
return (1);
287
+
}
288
+
289
+
if (pri_read_crc (fp, buf + 4, 4, &crc)) {
290
+
return (1);
291
+
}
292
+
293
+
size = pri_get_uint32_be (buf, 4);
294
+
295
+
if (pri_load_header (fp, img, size, crc)) {
296
+
return (1);
297
+
}
298
+
299
+
trk = NULL;
300
+
301
+
while (1) {
302
+
crc = 0;
303
+
304
+
if (pri_read_crc (fp, buf, 8, &crc)) {
305
+
return (1);
306
+
}
307
+
308
+
type = pri_get_uint32_be (buf, 0);
309
+
size = pri_get_uint32_be (buf, 4);
310
+
311
+
switch (type) {
312
+
case PRI_CHUNK_END:
313
+
if (pri_skip_chunk (fp, size, crc)) {
314
+
return (1);
315
+
}
316
+
return (0);
317
+
318
+
case PRI_CHUNK_TEXT:
319
+
if (pri_load_text (fp, img, size, crc)) {
320
+
return (1);
321
+
}
322
+
break;
323
+
324
+
case PRI_CHUNK_TRAK:
325
+
if (pri_load_trak (fp, img, &trk, size, crc)) {
326
+
return (1);
327
+
}
328
+
break;
329
+
330
+
case PRI_CHUNK_DATA:
331
+
if (pri_load_data (fp, img, trk, size, crc)) {
332
+
return (1);
333
+
}
334
+
break;
335
+
336
+
default:
337
+
if (pri_skip_chunk (fp, size, crc)) {
338
+
return (1);
339
+
}
340
+
break;
341
+
}
342
+
}
343
+
344
+
return (1);
345
+
}
346
+
347
+
pri_img_t *pri_load_pri (FILE *fp)
348
+
{
349
+
pri_img_t *img;
350
+
351
+
if ((img = pri_img_new()) == NULL) {
352
+
return (NULL);
353
+
}
354
+
355
+
if (pri_load_image (fp, img)) {
356
+
pri_img_del (img);
357
+
return (NULL);
358
+
}
359
+
360
+
return (img);
361
+
}
362
+
363
+
364
+
static
365
+
int pri_save_chunk (FILE *fp, unsigned ckid, unsigned size, const void *data)
366
+
{
367
+
unsigned long crc;
368
+
unsigned char buf[8];
369
+
370
+
pri_set_uint32_be (buf, 0, ckid);
371
+
pri_set_uint32_be (buf, 4, size);
372
+
373
+
crc = 0;
374
+
375
+
if (pri_write_crc (fp, buf, 8, &crc)) {
376
+
return (1);
377
+
}
378
+
379
+
if (size > 0) {
380
+
if (pri_write_crc (fp, data, size, &crc)) {
381
+
return (1);
382
+
}
383
+
}
384
+
385
+
pri_set_uint32_be (buf, 0, crc);
386
+
387
+
if (pri_write_crc (fp, buf, 4, NULL)) {
388
+
return (1);
389
+
}
390
+
391
+
return (0);
392
+
}
393
+
394
+
static
395
+
int pri_save_header (FILE *fp, const pri_img_t *img)
396
+
{
397
+
unsigned char buf[4];
398
+
399
+
pri_set_uint32_be (buf, 0, 0);
400
+
401
+
if (pri_save_chunk (fp, PRI_CHUNK_PRI, 4, buf)) {
402
+
return (1);
403
+
}
404
+
405
+
return (0);
406
+
}
407
+
408
+
static
409
+
int pri_save_text (FILE *fp, const pri_img_t *img)
410
+
{
411
+
int r;
412
+
unsigned long crc;
413
+
unsigned char buf[16];
414
+
415
+
if (img->comment_size == 0) {
416
+
return (0);
417
+
}
418
+
419
+
pri_set_uint32_be (buf, 0, PRI_CHUNK_TEXT);
420
+
pri_set_uint32_be (buf, 4, img->comment_size + 2);
421
+
422
+
buf[8] = 0x0a;
423
+
424
+
crc = 0;
425
+
426
+
r = pri_write_crc (fp, buf, 9, &crc);
427
+
r |= pri_write_crc (fp, img->comment, img->comment_size, &crc);
428
+
r |= pri_write_crc (fp, buf + 8, 1, &crc);
429
+
pri_set_uint32_be (buf, 0, crc);
430
+
r |= pri_write (fp, buf, 4);
431
+
432
+
return (r);
433
+
}
434
+
435
+
static
436
+
int pri_save_trak (FILE *fp, const pri_trk_t *trk, unsigned long c, unsigned long h)
437
+
{
438
+
unsigned char buf[16];
439
+
440
+
pri_set_uint32_be (buf, 0, c);
441
+
pri_set_uint32_be (buf, 4, h);
442
+
pri_set_uint32_be (buf, 8, trk->size);
443
+
pri_set_uint32_be (buf, 12, trk->clock);
444
+
445
+
if (pri_save_chunk (fp, PRI_CHUNK_TRAK, 16, buf)) {
446
+
return (1);
447
+
}
448
+
449
+
return (0);
450
+
}
451
+
452
+
static
453
+
int pri_save_data (FILE *fp, const pri_trk_t *trk)
454
+
{
455
+
unsigned long cnt, crc;
456
+
unsigned char buf[8];
457
+
458
+
if (trk->size == 0) {
459
+
return (0);
460
+
}
461
+
462
+
crc = 0;
463
+
464
+
cnt = (trk->size + 7) / 8;
465
+
466
+
pri_set_uint32_be (buf, 0, PRI_CHUNK_DATA);
467
+
pri_set_uint32_be (buf, 4, cnt);
468
+
469
+
if (pri_write_crc (fp, buf, 8, &crc)) {
470
+
return (1);
471
+
}
472
+
473
+
if (pri_write_crc (fp, trk->data, cnt, &crc)) {
474
+
return (1);
475
+
}
476
+
477
+
pri_set_uint32_be (buf, 0, crc);
478
+
479
+
if (pri_write (fp, buf, 4)) {
480
+
return (1);
481
+
}
482
+
483
+
return (0);
484
+
}
485
+
486
+
static
487
+
int pri_save_track (FILE *fp, const pri_trk_t *trk, unsigned long c, unsigned long h)
488
+
{
489
+
if (pri_save_trak (fp, trk, c, h)) {
490
+
return (1);
491
+
}
492
+
493
+
if (pri_save_data (fp, trk)) {
494
+
return (1);
495
+
}
496
+
497
+
return (0);
498
+
}
499
+
500
+
int pri_save_pri (FILE *fp, const pri_img_t *img)
501
+
{
502
+
unsigned long c, h;
503
+
pri_cyl_t *cyl;
504
+
pri_trk_t *trk;
505
+
506
+
if (pri_save_header (fp, img)) {
507
+
return (1);
508
+
}
509
+
510
+
if (pri_save_text (fp, img)) {
511
+
return (1);
512
+
}
513
+
514
+
for (c = 0; c < img->cyl_cnt; c++) {
515
+
if ((cyl = img->cyl[c]) == NULL) {
516
+
continue;
517
+
}
518
+
519
+
for (h = 0; h < cyl->trk_cnt; h++) {
520
+
if ((trk = cyl->trk[h]) == NULL) {
521
+
continue;
522
+
}
523
+
524
+
if (pri_save_track (fp, trk, c, h)) {
525
+
return (1);
526
+
}
527
+
}
528
+
}
529
+
530
+
if (pri_save_chunk (fp, PRI_CHUNK_END, 0, NULL)) {
531
+
return (1);
532
+
}
533
+
534
+
return (0);
535
+
}
536
+
537
+
538
+
int pri_probe_pri_fp (FILE *fp)
539
+
{
540
+
unsigned char buf[4];
541
+
542
+
if (pri_read_ofs (fp, 0, buf, 4)) {
543
+
return (0);
544
+
}
545
+
546
+
if (pri_get_uint32_be (buf, 0) != PRI_CHUNK_PRI) {
547
+
return (0);
548
+
}
549
+
550
+
return (1);
551
+
}
552
+
553
+
int pri_probe_pri (const char *fname)
554
+
{
555
+
int r;
556
+
FILE *fp;
557
+
558
+
if ((fp = fopen (fname, "rb")) == NULL) {
559
+
return (0);
560
+
}
561
+
562
+
r = pri_probe_pri_fp (fp);
563
+
564
+
fclose (fp);
565
+
566
+
return (r);
567
+
}
+38
src/drivers/pri/pri-img-pri.h
+38
src/drivers/pri/pri-img-pri.h
···
1
+
/*****************************************************************************
2
+
* pce *
3
+
*****************************************************************************/
4
+
5
+
/*****************************************************************************
6
+
* File name: src/drivers/pri/pri-img-pri.h *
7
+
* Created: 2012-01-31 by Hampa Hug <hampa@hampa.ch> *
8
+
* Copyright: (C) 2012-2013 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_PRI_H
24
+
#define PCE_PRI_IMG_PRI_H 1
25
+
26
+
27
+
#include <drivers/pri/pri.h>
28
+
29
+
30
+
pri_img_t *pri_load_pri (FILE *fp);
31
+
32
+
int pri_save_pri (FILE *fp, const pri_img_t *img);
33
+
34
+
int pri_probe_pri_fp (FILE *fp);
35
+
int pri_probe_pfdc (const char *fname);
36
+
37
+
38
+
#endif
+12
-1
src/drivers/pri/pri-img.c
+12
-1
src/drivers/pri/pri-img.c
···
26
26
27
27
#include "pri-img.h"
28
28
#include "pri-img-pbit.h"
29
+
#include "pri-img-pri.h"
29
30
#include "pri-img-tc.h"
30
31
31
32
···
204
205
if (strcasecmp (ext, ".pbit") == 0) {
205
206
return (PRI_FORMAT_PBIT);
206
207
}
208
+
else if (strcasecmp (ext, ".pri") == 0) {
209
+
return (PRI_FORMAT_PRI);
210
+
}
207
211
else if (strcasecmp (ext, ".tc") == 0) {
208
212
return (PRI_FORMAT_TC);
209
213
}
210
214
211
-
return (PRI_FORMAT_PBIT);
215
+
return (PRI_FORMAT_PRI);
212
216
}
213
217
214
218
···
221
225
switch (type) {
222
226
case PRI_FORMAT_PBIT:
223
227
img = pri_load_pbit (fp);
228
+
break;
229
+
230
+
case PRI_FORMAT_PRI:
231
+
img = pri_load_pri (fp);
224
232
break;
225
233
226
234
case PRI_FORMAT_TC:
···
254
262
switch (type) {
255
263
case PRI_FORMAT_PBIT:
256
264
return (pri_save_pbit (fp, img));
265
+
266
+
case PRI_FORMAT_PRI:
267
+
return (pri_save_pri (fp, img));
257
268
258
269
case PRI_FORMAT_TC:
259
270
return (pri_save_tc (fp, img));
+2
-1
src/drivers/pri/pri-img.h
+2
-1
src/drivers/pri/pri-img.h
+3
src/utils/pri/main.c
+3
src/utils/pri/main.c
+4
-1
src/utils/pri/pri.1
+4
-1
src/utils/pri/pri.1