fork of PCE focusing on macplus, supporting DaynaPort SCSI network emulation
0
fork

Configure Feed

Select the types of activity you want to include in your feed.

pfi: Use the new CIFF implementation

+139 -297
+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
··· 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
+2
src/utils/pfi/Makefile.inc
··· 23 23 PFI_UTIL_BIN := $(rel)/pfi$(EXEEXT) 24 24 25 25 PFI_UTIL_OBJ_EXT := \ 26 + src/lib/ciff.o \ 27 + src/lib/endian.o \ 26 28 src/lib/getopt.o \ 27 29 $(DRV_PSI_OBJ) \ 28 30 $(DRV_PRI_OBJ) \