fork of PCE focusing on macplus, supporting DaynaPort SCSI network emulation
pfi: Use the new CIFF implementation
+139
-297
+4
-2
Makefile.dep
+4
-2
Makefile.dep
···
2580
2580
src/drivers/pfi/track.h
2581
2581
2582
2582
src/drivers/pfi/pfi-pfi.o: src/drivers/pfi/pfi-pfi.c \
2583
-
src/drivers/pfi/pfi-io.h \
2583
+
src/config.h \
2584
2584
src/drivers/pfi/pfi-pfi.h \
2585
2585
src/drivers/pfi/pfi.h \
2586
-
src/drivers/pfi/track.h
2586
+
src/drivers/pfi/track.h \
2587
+
src/lib/ciff.h \
2588
+
src/lib/endian.h
2587
2589
2588
2590
src/drivers/pfi/pfi-scp.o: src/drivers/pfi/pfi-scp.c \
2589
2591
src/drivers/pfi/pfi-io.h \
+133
-295
src/drivers/pfi/pfi-pfi.c
+133
-295
src/drivers/pfi/pfi-pfi.c
···
5
5
/*****************************************************************************
6
6
* File name: src/drivers/pfi/pfi-pfi.c *
7
7
* Created: 2013-12-26 by Hampa Hug <hampa@hampa.ch> *
8
-
* Copyright: (C) 2013-2019 Hampa Hug <hampa@hampa.ch> *
8
+
* Copyright: (C) 2013-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
22
22
23
+
#include <config.h>
24
+
23
25
#include <stdint.h>
24
26
#include <stdlib.h>
25
27
#include <stdio.h>
26
28
#include <string.h>
27
29
28
30
#include "pfi.h"
29
-
#include "pfi-io.h"
30
31
#include "pfi-pfi.h"
31
32
33
+
#include <lib/ciff.h>
34
+
#include <lib/endian.h>
32
35
33
-
#define PFI_MAGIC_PFI 0x50464920
34
-
#define PFI_MAGIC_TEXT 0x54455854
35
-
#define PFI_MAGIC_TRAK 0x5452414b
36
-
#define PFI_MAGIC_INDX 0x494e4458
37
-
#define PFI_MAGIC_DATA 0x44415441
38
-
#define PFI_MAGIC_END 0x454e4420
39
36
40
-
#define PFI_CRC_POLY 0x1edc6f41
37
+
#define CKID_PFI 0x50464920
38
+
#define CKID_TEXT 0x54455854
39
+
#define CKID_TRAK 0x5452414b
40
+
#define CKID_INDX 0x494e4458
41
+
#define CKID_DATA 0x44415441
42
+
#define CKID_END 0x454e4420
41
43
42
44
43
45
typedef struct {
44
-
FILE *fp;
46
+
ciff_t ciff;
47
+
45
48
pfi_img_t *img;
46
49
pfi_trk_t *trk;
47
50
48
-
uint32_t crc;
49
-
50
-
char have_header;
51
-
52
51
unsigned long bufmax;
53
52
unsigned char *buf;
54
53
} pfi_load_t;
55
54
56
55
57
56
static
58
-
uint32_t pfi_crc (uint32_t crc, const void *buf, unsigned cnt)
59
-
{
60
-
unsigned i, j;
61
-
unsigned val;
62
-
uint32_t reg;
63
-
const unsigned char *src;
64
-
static int tab_ok = 0;
65
-
static uint32_t tab[256];
66
-
67
-
if (tab_ok == 0) {
68
-
for (i = 0; i < 256; i++) {
69
-
reg = (uint32_t) i << 24;
70
-
71
-
for (j = 0; j < 8; j++) {
72
-
if (reg & 0x80000000) {
73
-
reg = (reg << 1) ^ PFI_CRC_POLY;
74
-
}
75
-
else {
76
-
reg = reg << 1;
77
-
}
78
-
}
79
-
80
-
tab[i] = reg;
81
-
}
82
-
83
-
tab_ok = 1;
84
-
}
85
-
86
-
src = buf;
87
-
88
-
while (cnt > 0) {
89
-
val = (crc >> 24) ^ *(src++);
90
-
crc = (crc << 8) ^ tab[val & 0xff];
91
-
cnt -= 1;
92
-
}
93
-
94
-
return (crc & 0xffffffff);
95
-
}
96
-
97
-
static
98
-
int pfi_read_crc (pfi_load_t *pfi, void *buf, unsigned long cnt)
99
-
{
100
-
if (pfi_read (pfi->fp, buf, cnt)) {
101
-
return (1);
102
-
}
103
-
104
-
pfi->crc = pfi_crc (pfi->crc, buf, cnt);
105
-
106
-
return (0);
107
-
}
108
-
109
-
static
110
57
unsigned char *pfi_alloc (pfi_load_t *pfi, unsigned long size)
111
58
{
112
59
unsigned char *tmp;
···
133
80
}
134
81
135
82
static
136
-
int pfi_skip_chunk (pfi_load_t *pfi, unsigned long size)
137
-
{
138
-
unsigned cnt;
139
-
unsigned char *buf;
140
-
141
-
if ((buf = pfi_alloc (pfi, 4096)) == NULL) {
142
-
return (1);
143
-
}
144
-
145
-
while (size > 0) {
146
-
cnt = (size < 4096) ? size : 4096;
147
-
148
-
if (pfi_read_crc (pfi, buf, cnt)) {
149
-
return (1);
150
-
}
151
-
152
-
size -= cnt;
153
-
}
154
-
155
-
if (pfi_read (pfi->fp, buf, 4)) {
156
-
return (1);
157
-
}
158
-
159
-
if (pfi_get_uint32_be (buf, 0) != pfi->crc) {
160
-
fprintf (stderr, "pfi: crc error\n");
161
-
return (1);
162
-
}
163
-
164
-
return (0);
165
-
}
166
-
167
-
static
168
-
int pfi_load_header (pfi_load_t *pfi, unsigned long size)
83
+
int pfi_load_header (pfi_load_t *pfi)
169
84
{
170
85
unsigned char buf[4];
171
86
unsigned long vers;
172
87
173
-
if (size < 4) {
88
+
if (ciff_read (&pfi->ciff, buf, 4)) {
174
89
return (1);
175
90
}
176
91
177
-
if (pfi_read_crc (pfi, buf, 4)) {
178
-
return (1);
179
-
}
180
-
181
-
vers = pfi_get_uint32_be (buf, 0);
92
+
vers = get_uint32_be (buf, 0);
182
93
183
94
if (vers != 0) {
184
95
fprintf (stderr, "pfi: unknown version number (%lu)\n", vers);
185
96
return (1);
186
97
}
187
98
188
-
if (pfi_skip_chunk (pfi, size - 4)) {
189
-
return (1);
190
-
}
191
-
192
99
return (0);
193
100
}
194
101
195
102
static
196
-
int pfi_load_comment (pfi_load_t *pfi, unsigned size)
103
+
int pfi_load_comment (pfi_load_t *pfi)
197
104
{
198
105
unsigned i, j, k, d;
106
+
unsigned long size;
199
107
unsigned char *buf;
200
108
109
+
size = pfi->ciff.size;
110
+
201
111
if (size == 0) {
202
-
return (pfi_skip_chunk (pfi, size));
112
+
return (0);
203
113
}
204
114
205
115
if ((buf = pfi_alloc (pfi, size)) == NULL) {
206
116
return (1);
207
117
}
208
118
209
-
if (pfi_read_crc (pfi, buf, size)) {
119
+
if (ciff_read (&pfi->ciff, buf, size)) {
210
120
return (1);
211
121
}
212
122
···
238
148
}
239
149
240
150
if (i == j) {
241
-
return (pfi_skip_chunk (pfi, 0));
151
+
return (0);
242
152
}
243
153
244
154
k = i;
···
276
186
return (1);
277
187
}
278
188
279
-
if (pfi_skip_chunk (pfi, 0)) {
280
-
return (1);
281
-
}
282
-
283
189
return (0);
284
190
}
285
191
286
192
static
287
-
int pfi_load_track_header (pfi_load_t *pfi, unsigned long size)
193
+
int pfi_load_track_header (pfi_load_t *pfi)
288
194
{
289
195
unsigned char buf[12];
290
196
unsigned long c, h, clock;
291
197
292
-
if (size < 12) {
198
+
if (ciff_read (&pfi->ciff, buf, 12)) {
293
199
return (1);
294
200
}
295
201
296
-
if (pfi_read_crc (pfi, buf, 12)) {
297
-
return (1);
298
-
}
299
-
300
-
size -= 12;
301
-
302
-
c = pfi_get_uint32_be (buf, 0);
303
-
h = pfi_get_uint32_be (buf, 4);
304
-
clock = pfi_get_uint32_be (buf, 8);
202
+
c = get_uint32_be (buf, 0);
203
+
h = get_uint32_be (buf, 4);
204
+
clock = get_uint32_be (buf, 8);
305
205
306
206
pfi->trk = pfi_img_get_track (pfi->img, c, h, 1);
307
207
···
311
211
312
212
pfi_trk_set_clock (pfi->trk, clock);
313
213
314
-
if (pfi_skip_chunk (pfi, size)) {
315
-
return (1);
316
-
}
317
-
318
214
return (0);
319
215
}
320
216
321
217
static
322
-
int pfi_load_indx (pfi_load_t *pfi, unsigned long size)
218
+
int pfi_load_indx (pfi_load_t *pfi)
323
219
{
324
220
unsigned char buf[4];
325
221
326
-
while (size >= 4) {
327
-
if (pfi_read_crc (pfi, buf, 4)) {
222
+
while (pfi->ciff.size >= 4) {
223
+
if (ciff_read (&pfi->ciff, buf, 4)) {
328
224
return (1);
329
225
}
330
226
331
-
if (pfi_trk_add_index (pfi->trk, pfi_get_uint32_be (buf, 0))) {
227
+
if (pfi_trk_add_index (pfi->trk, get_uint32_be (buf, 0))) {
332
228
return (1);
333
229
}
334
-
335
-
size -= 4;
336
-
}
337
-
338
-
if (pfi_skip_chunk (pfi, size)) {
339
-
return (1);
340
230
}
341
231
342
232
return (0);
···
349
239
unsigned long pos;
350
240
uint32_t val;
351
241
352
-
if (pfi_read_crc (pfi, buf, size)) {
242
+
if (ciff_read (&pfi->ciff, buf, size)) {
353
243
return (1);
354
244
}
355
245
···
392
282
}
393
283
394
284
static
395
-
int pfi_load_track_data (pfi_load_t *pfi, unsigned long size)
285
+
int pfi_load_track_data (pfi_load_t *pfi)
396
286
{
287
+
unsigned long size;
397
288
unsigned char *buf;
289
+
290
+
size = pfi->ciff.size;
398
291
399
292
if ((buf = pfi_alloc (pfi, size)) == NULL) {
400
293
return (1);
···
404
297
return (1);
405
298
}
406
299
407
-
if (pfi_skip_chunk (pfi, 0)) {
408
-
return (1);
409
-
}
410
-
411
300
return (0);
412
301
}
413
302
414
303
static
415
304
int pfi_load_image (pfi_load_t *pfi)
416
305
{
417
-
unsigned long type, size;
418
-
unsigned char buf[8];
306
+
if (ciff_read_id (&pfi->ciff)) {
307
+
return (1);
308
+
}
419
309
420
-
pfi->have_header = 0;
421
-
pfi->trk = NULL;
310
+
if (pfi->ciff.ckid != CKID_PFI) {
311
+
return (1);
312
+
}
422
313
423
-
while (1) {
424
-
pfi->crc = 0;
425
-
426
-
if (pfi_read_crc (pfi, buf, 8)) {
427
-
return (1);
428
-
}
314
+
if (pfi_load_header (pfi)) {
315
+
return (1);
316
+
}
429
317
430
-
type = pfi_get_uint32_be (buf, 0);
431
-
size = pfi_get_uint32_be (buf, 4);
318
+
pfi->trk = NULL;
432
319
433
-
if (type == PFI_MAGIC_END) {
434
-
if (pfi_skip_chunk (pfi, size)) {
320
+
while (ciff_read_id (&pfi->ciff) == 0) {
321
+
switch (pfi->ciff.ckid) {
322
+
case CKID_END:
323
+
if (ciff_read_crc (&pfi->ciff)) {
435
324
return (1);
436
325
}
437
-
438
326
return (0);
439
-
}
440
-
else if (type == PFI_MAGIC_PFI) {
441
-
if (pfi->have_header) {
442
-
return (1);
443
-
}
444
327
445
-
if (pfi_load_header (pfi, size)) {
328
+
case CKID_TEXT:
329
+
if (pfi_load_comment (pfi)) {
446
330
return (1);
447
331
}
332
+
break;
448
333
449
-
pfi->have_header = 1;
450
-
}
451
-
else if (type == PFI_MAGIC_TEXT) {
452
-
if (pfi->have_header == 0) {
453
-
return (1);
454
-
}
455
334
456
-
if (pfi_load_comment (pfi, size)) {
335
+
case CKID_TRAK:
336
+
if (pfi_load_track_header (pfi)) {
457
337
return (1);
458
338
}
459
-
}
460
-
else if (type == PFI_MAGIC_TRAK) {
461
-
if (pfi->have_header == 0) {
462
-
return (1);
463
-
}
339
+
break;
464
340
465
-
if (pfi_load_track_header (pfi, size)) {
466
-
return (1);
467
-
}
468
-
}
469
-
else if (type == PFI_MAGIC_INDX) {
341
+
case CKID_INDX:
470
342
if (pfi->trk == NULL) {
471
343
return (1);
472
344
}
473
345
474
-
if (pfi_load_indx (pfi, size)) {
346
+
if (pfi_load_indx (pfi)) {
475
347
return (1);
476
348
}
477
-
}
478
-
else if (type == PFI_MAGIC_DATA) {
349
+
break;
350
+
351
+
case CKID_DATA:
479
352
if (pfi->trk == NULL) {
480
353
return (1);
481
354
}
482
355
483
-
if (pfi_load_track_data (pfi, size)) {
356
+
if (pfi_load_track_data (pfi)) {
484
357
return (1);
485
358
}
486
-
}
487
-
else {
488
-
if (pfi->have_header == 0) {
489
-
return (1);
490
-
}
491
-
492
-
if (pfi_skip_chunk (pfi, size)) {
493
-
return (1);
494
-
}
359
+
break;
495
360
}
496
361
}
497
362
···
503
368
int r;
504
369
pfi_load_t pfi;
505
370
506
-
pfi.fp = fp;
507
-
pfi.img = NULL;
371
+
if ((pfi.img = pfi_img_new()) == NULL) {
372
+
return (NULL);
373
+
}
374
+
375
+
ciff_init (&pfi.ciff, fp, 1);
376
+
508
377
pfi.trk = NULL;
509
378
pfi.buf = NULL;
510
379
pfi.bufmax = 0;
511
380
512
-
if ((pfi.img = pfi_img_new()) == NULL) {
513
-
return (NULL);
381
+
r = pfi_load_image (&pfi);
382
+
383
+
if (pfi.ciff.crc_error) {
384
+
fprintf (stderr, "pfi: crc error\n");
514
385
}
515
386
516
-
r = pfi_load_image (&pfi);
517
-
387
+
ciff_free (&pfi.ciff);
518
388
pfi_free (&pfi);
519
389
520
390
if (r) {
···
527
397
528
398
529
399
static
530
-
int pfi_save_header (FILE *fp, const pfi_img_t *img)
400
+
int pfi_save_header (ciff_t *ciff, const pfi_img_t *img)
531
401
{
532
-
unsigned char buf[16];
402
+
unsigned char buf[4];
533
403
534
-
pfi_set_uint32_be (buf, 0, PFI_MAGIC_PFI);
535
-
pfi_set_uint32_be (buf, 4, 4);
536
-
pfi_set_uint32_be (buf, 8, 0);
537
-
pfi_set_uint32_be (buf, 12, pfi_crc (0, buf, 12));
404
+
set_uint32_be (buf, 0, 0);
538
405
539
-
if (pfi_write (fp, buf, 16)) {
406
+
if (ciff_write_chunk (ciff, CKID_PFI, buf, 4)) {
540
407
return (1);
541
408
}
542
409
···
544
411
}
545
412
546
413
static
547
-
int pfi_save_end (FILE *fp, const pfi_img_t *img)
414
+
int pfi_save_end (ciff_t *ciff, const pfi_img_t *img)
548
415
{
549
-
unsigned char buf[16];
550
-
551
-
pfi_set_uint32_be (buf, 0, PFI_MAGIC_END);
552
-
pfi_set_uint32_be (buf, 4, 0);
553
-
pfi_set_uint32_be (buf, 8, pfi_crc (0, buf, 8));
554
-
555
-
if (pfi_write (fp, buf, 12)) {
416
+
if (ciff_write_chunk (ciff, CKID_END, NULL, 0)) {
556
417
return (1);
557
418
}
558
419
···
560
421
}
561
422
562
423
static
563
-
int pfi_save_comment (FILE *fp, const pfi_img_t *img)
424
+
int pfi_save_comment (ciff_t *ciff, const pfi_img_t *img)
564
425
{
426
+
int r;
565
427
unsigned long i, j;
566
-
unsigned long crc;
567
428
const unsigned char *src;
568
429
unsigned char *buf;
569
-
unsigned char hdr[8];
570
430
571
431
if (img->comment_size == 0) {
572
432
return (0);
573
433
}
574
434
575
-
buf = malloc (img->comment_size + 2);
576
-
577
-
if (buf == NULL) {
435
+
if ((buf = malloc (img->comment_size + 2)) == NULL) {
578
436
return (1);
579
437
}
580
438
···
623
481
}
624
482
625
483
if (j == 1) {
626
-
free (buf);
627
-
return (0);
628
-
}
629
-
630
-
buf[j++] = 0x0a;
631
-
632
-
pfi_set_uint32_be (hdr, 0, PFI_MAGIC_TEXT);
633
-
pfi_set_uint32_be (hdr, 4, j);
634
-
635
-
crc = pfi_crc (0, hdr, 8);
636
-
637
-
if (pfi_write (fp, hdr, 8)) {
638
-
return (1);
484
+
r = 0;
639
485
}
640
-
641
-
crc = pfi_crc (crc, buf, j);
486
+
else {
487
+
buf[j++] = 0x0a;
642
488
643
-
if (pfi_write (fp, buf, j)) {
644
-
return (1);
489
+
r = ciff_write_chunk (ciff, CKID_TEXT, buf, j);
645
490
}
646
491
647
-
pfi_set_uint32_be (hdr, 0, crc);
492
+
free (buf);
648
493
649
-
if (pfi_write (fp, hdr, 4)) {
650
-
return (1);
651
-
}
652
-
653
-
return (0);
494
+
return (r);
654
495
}
655
496
656
497
static
657
-
int pfi_save_track_header (FILE *fp, const pfi_trk_t *trk, unsigned long c, unsigned long h)
498
+
int pfi_save_track_header (ciff_t *ciff, const pfi_trk_t *trk, unsigned long c, unsigned long h)
658
499
{
659
-
unsigned char buf[32];
500
+
unsigned char buf[16];
660
501
661
-
pfi_set_uint32_be (buf, 0, PFI_MAGIC_TRAK);
662
-
pfi_set_uint32_be (buf, 4, 12);
663
-
pfi_set_uint32_be (buf, 8, c);
664
-
pfi_set_uint32_be (buf, 12, h);
665
-
pfi_set_uint32_be (buf, 16, trk->clock);
666
-
pfi_set_uint32_be (buf, 20, pfi_crc (0, buf, 20));
502
+
set_uint32_be (buf, 0, c);
503
+
set_uint32_be (buf, 4, h);
504
+
set_uint32_be (buf, 8, trk->clock);
667
505
668
-
if (pfi_write (fp, buf, 24)) {
506
+
if (ciff_write_chunk (ciff, CKID_TRAK, buf, 12)) {
669
507
return (1);
670
508
}
671
509
···
673
511
}
674
512
675
513
static
676
-
int pfi_save_indx (FILE *fp, const pfi_trk_t *trk)
514
+
int pfi_save_indx (ciff_t *ciff, const pfi_trk_t *trk)
677
515
{
678
516
unsigned i;
679
-
unsigned long crc;
680
-
unsigned char buf[8];
517
+
unsigned char buf[4];
681
518
682
519
if (trk->index_cnt == 0) {
683
520
return (0);
684
521
}
685
522
686
-
pfi_set_uint32_be (buf, 0, PFI_MAGIC_INDX);
687
-
pfi_set_uint32_be (buf, 4, 4 * trk->index_cnt);
688
-
689
-
crc = pfi_crc (0, buf, 8);
690
-
691
-
if (pfi_write (fp, buf, 8)) {
523
+
if (ciff_write_id (ciff, CKID_INDX, 4 * trk->index_cnt)) {
692
524
return (1);
693
525
}
694
526
695
527
for (i = 0; i < trk->index_cnt; i++) {
696
-
pfi_set_uint32_be (buf, 0, trk->index[i]);
697
-
698
-
crc = pfi_crc (crc, buf, 4);
528
+
set_uint32_be (buf, 0, trk->index[i]);
699
529
700
-
if (pfi_write (fp, buf, 4)) {
530
+
if (ciff_write (ciff, buf, 4)) {
701
531
return (1);
702
532
}
703
533
}
704
534
705
-
pfi_set_uint32_be (buf, 0, crc);
706
-
707
-
if (pfi_write (fp, buf, 4)) {
535
+
if (ciff_write_crc (ciff)) {
708
536
return (1);
709
537
}
710
538
···
712
540
}
713
541
714
542
static
715
-
int pfi_save_data (FILE *fp, const pfi_trk_t *trk)
543
+
int pfi_save_data (ciff_t *ciff, const pfi_trk_t *trk)
716
544
{
717
545
int r;
718
546
uint32_t val;
···
729
557
return (1);
730
558
}
731
559
732
-
pfi_set_uint32_be (buf, 0, PFI_MAGIC_DATA);
733
-
734
-
n = 8;
560
+
n = 0;
735
561
736
562
for (i = 0; i < trk->pulse_cnt; i++) {
737
563
val = trk->pulse[i];
···
740
566
continue;
741
567
}
742
568
743
-
if ((max - n) < 16) {
569
+
if ((max - n) < 8) {
744
570
max *= 2;
745
571
746
572
if ((tmp = realloc (buf, max)) == 0) {
···
782
608
}
783
609
}
784
610
785
-
pfi_set_uint32_be (buf, 4, n - 8);
786
-
pfi_set_uint32_be (buf, n, pfi_crc (0, buf, n));
787
-
788
-
r = pfi_write (fp, buf, n + 4);
611
+
r = ciff_write_chunk (ciff, CKID_DATA, buf, n);
789
612
790
613
free (buf);
791
614
···
793
616
}
794
617
795
618
static
796
-
int pfi_save_track (FILE *fp, const pfi_trk_t *trk, unsigned long c, unsigned long h)
619
+
int pfi_save_track (ciff_t *ciff, const pfi_trk_t *trk, unsigned long c, unsigned long h)
797
620
{
798
-
if (pfi_save_track_header (fp, trk, c, h)) {
621
+
if (pfi_save_track_header (ciff, trk, c, h)) {
799
622
return (1);
800
623
}
801
624
802
-
if (pfi_save_indx (fp, trk)) {
625
+
if (pfi_save_indx (ciff, trk)) {
803
626
return (1);
804
627
}
805
628
806
-
if (pfi_save_data (fp, trk)) {
629
+
if (pfi_save_data (ciff, trk)) {
807
630
return (1);
808
631
}
809
632
810
633
return (0);
811
634
}
812
635
813
-
int pfi_save_pfi (FILE *fp, const pfi_img_t *img)
636
+
static
637
+
int pfi_save_ciff (ciff_t *ciff, const pfi_img_t *img)
814
638
{
815
639
unsigned long c, h;
816
640
pfi_cyl_t *cyl;
817
641
pfi_trk_t *trk;
818
642
819
-
if (pfi_save_header (fp, img)) {
643
+
if (pfi_save_header (ciff, img)) {
820
644
return (1);
821
645
}
822
646
823
-
if (pfi_save_comment (fp, img)) {
647
+
if (pfi_save_comment (ciff, img)) {
824
648
return (1);
825
649
}
826
650
···
834
658
continue;
835
659
}
836
660
837
-
if (pfi_save_track (fp, trk, c, h)) {
661
+
if (pfi_save_track (ciff, trk, c, h)) {
838
662
return (1);
839
663
}
840
664
}
841
665
}
842
666
843
-
if (pfi_save_end (fp, img)) {
667
+
if (pfi_save_end (ciff, img)) {
844
668
return (1);
845
669
}
846
670
847
671
return (0);
848
672
}
849
673
674
+
int pfi_save_pfi (FILE *fp, const pfi_img_t *img)
675
+
{
676
+
int r;
677
+
ciff_t ciff;
678
+
679
+
ciff_init (&ciff, fp, 1);
680
+
681
+
r = pfi_save_ciff (&ciff, img);
682
+
683
+
ciff_free (&ciff);
684
+
685
+
return (r);
686
+
}
687
+
850
688
851
689
int pfi_probe_pfi_fp (FILE *fp)
852
690
{
853
691
unsigned char buf[4];
854
692
855
-
if (pfi_read (fp, buf, 4)) {
693
+
if (fread (buf, 1, 4, fp) != 4) {
856
694
return (0);
857
695
}
858
696
859
-
if (pfi_get_uint32_be (buf, 0) != PFI_MAGIC_PFI) {
697
+
if (get_uint32_be (buf, 0) != CKID_PFI) {
860
698
return (0);
861
699
}
862
700