+51 -51

Makefile.dep

reviewed

··· 365 365 src/devices/nvram.h \ 366 366 src/drivers/block/block.h \ 367 367 src/drivers/char/char.h \ 368 368 - src/drivers/pbit/pbit.h \ 368 368 + src/drivers/pri/pri.h \ 369 369 src/drivers/sound/filter.h \ 370 370 src/drivers/sound/sound.h \ 371 371 src/drivers/video/keys.h \ ··· 401 401 src/devices/nvram.h \ 402 402 src/drivers/block/block.h \ 403 403 src/drivers/char/char.h \ 404 404 - src/drivers/pbit/pbit.h \ 404 404 + src/drivers/pri/pri.h \ 405 405 src/drivers/sound/filter.h \ 406 406 src/drivers/sound/sound.h \ 407 407 src/drivers/video/keys.h \ ··· 436 436 src/devices/nvram.h \ 437 437 src/drivers/block/block.h \ 438 438 src/drivers/char/char.h \ 439 439 - src/drivers/pbit/pbit.h \ 439 439 + src/drivers/pri/pri.h \ 440 440 src/drivers/sound/filter.h \ 441 441 src/drivers/sound/sound.h \ 442 442 src/drivers/video/keys.h \ ··· 453 453 src/config.h \ 454 454 src/drivers/block/blkpsi.h \ 455 455 src/drivers/block/block.h \ 456 456 - src/drivers/pbit/gcr-mac.h \ 457 457 - src/drivers/pbit/pbit-io.h \ 458 458 - src/drivers/pbit/pbit.h \ 456 456 + src/drivers/pri/gcr-mac.h \ 457 457 + src/drivers/pri/pri-img.h \ 458 458 + src/drivers/pri/pri.h \ 459 459 src/drivers/psi/psi-img.h \ 460 460 src/drivers/psi/psi.h 461 461 ··· 465 465 src/arch/macplus/main.h \ 466 466 src/config.h \ 467 467 src/drivers/block/block.h \ 468 468 - src/drivers/pbit/pbit.h \ 468 468 + src/drivers/pri/pri.h \ 469 469 src/lib/console.h 470 470 471 471 src/arch/macplus/keyboard.o: src/arch/macplus/keyboard.c \ ··· 501 501 src/devices/nvram.h \ 502 502 src/drivers/block/block.h \ 503 503 src/drivers/char/char.h \ 504 504 - src/drivers/pbit/pbit.h \ 504 504 + src/drivers/pri/pri.h \ 505 505 src/drivers/sound/filter.h \ 506 506 src/drivers/sound/sound.h \ 507 507 src/drivers/video/keys.h \ ··· 540 540 src/devices/nvram.h \ 541 541 src/drivers/block/block.h \ 542 542 src/drivers/char/char.h \ 543 543 - src/drivers/pbit/pbit.h \ 543 543 + src/drivers/pri/pri.h \ 544 544 src/drivers/sound/filter.h \ 545 545 src/drivers/sound/sound.h \ 546 546 src/drivers/video/keys.h \ ··· 578 578 src/devices/nvram.h \ 579 579 src/drivers/block/block.h \ 580 580 src/drivers/char/char.h \ 581 581 - src/drivers/pbit/pbit.h \ 581 581 + src/drivers/pri/pri.h \ 582 582 src/drivers/sound/filter.h \ 583 583 src/drivers/sound/sound.h \ 584 584 src/drivers/video/keys.h \ ··· 610 610 src/devices/nvram.h \ 611 611 src/drivers/block/block.h \ 612 612 src/drivers/char/char.h \ 613 613 - src/drivers/pbit/pbit.h \ 613 613 + src/drivers/pri/pri.h \ 614 614 src/drivers/sound/filter.h \ 615 615 src/drivers/sound/sound.h \ 616 616 src/drivers/video/keys.h \ ··· 698 698 src/devices/memory.h \ 699 699 src/drivers/block/block.h \ 700 700 src/drivers/char/char.h \ 701 701 - src/drivers/pbit/pbit.h \ 701 701 + src/drivers/pri/pri.h \ 702 702 src/drivers/sound/filter.h \ 703 703 src/drivers/sound/sound.h \ 704 704 src/drivers/video/keys.h \ ··· 718 718 src/config.h \ 719 719 src/drivers/block/blkpsi.h \ 720 720 src/drivers/block/block.h \ 721 721 - src/drivers/pbit/mfm-ibm.h \ 722 722 - src/drivers/pbit/pbit-io.h \ 723 723 - src/drivers/pbit/pbit.h \ 721 721 + src/drivers/pri/mfm-ibm.h \ 722 722 + src/drivers/pri/pri-img.h \ 723 723 + src/drivers/pri/pri.h \ 724 724 src/drivers/psi/psi-img.h \ 725 725 src/drivers/psi/psi.h \ 726 726 src/lib/log.h \ ··· 759 759 src/devices/memory.h \ 760 760 src/drivers/block/block.h \ 761 761 src/drivers/char/char.h \ 762 762 - src/drivers/pbit/pbit.h \ 762 762 + src/drivers/pri/pri.h \ 763 763 src/drivers/sound/filter.h \ 764 764 src/drivers/sound/sound.h \ 765 765 src/drivers/video/keys.h \ ··· 796 796 src/devices/memory.h \ 797 797 src/drivers/block/block.h \ 798 798 src/drivers/char/char.h \ 799 799 - src/drivers/pbit/pbit.h \ 799 799 + src/drivers/pri/pri.h \ 800 800 src/drivers/sound/filter.h \ 801 801 src/drivers/sound/sound.h \ 802 802 src/drivers/video/keys.h \ ··· 847 847 src/devices/memory.h \ 848 848 src/drivers/block/block.h \ 849 849 src/drivers/char/char.h \ 850 850 - src/drivers/pbit/pbit.h \ 850 850 + src/drivers/pri/pri.h \ 851 851 src/drivers/sound/filter.h \ 852 852 src/drivers/sound/sound.h \ 853 853 src/drivers/video/keys.h \ ··· 1773 1773 src/config.h \ 1774 1774 src/drivers/options.h 1775 1775 1776 1776 - src/drivers/pbit/gcr-mac.o: src/drivers/pbit/gcr-mac.c \ 1777 1777 - src/drivers/pbit/gcr-mac.h \ 1778 1778 - src/drivers/pbit/pbit.h \ 1776 1776 + src/drivers/pri/gcr-mac.o: src/drivers/pri/gcr-mac.c \ 1777 1777 + src/drivers/pri/gcr-mac.h \ 1778 1778 + src/drivers/pri/pri.h \ 1779 1779 src/drivers/psi/psi.h 1780 1780 1781 1781 - src/drivers/pbit/mfm-ibm.o: src/drivers/pbit/mfm-ibm.c \ 1782 1782 - src/drivers/pbit/mfm-ibm.h \ 1783 1783 - src/drivers/pbit/pbit-io.h \ 1784 1784 - src/drivers/pbit/pbit.h \ 1781 1781 + src/drivers/pri/mfm-ibm.o: src/drivers/pri/mfm-ibm.c \ 1782 1782 + src/drivers/pri/mfm-ibm.h \ 1783 1783 + src/drivers/pri/pri-img.h \ 1784 1784 + src/drivers/pri/pri.h \ 1785 1785 src/drivers/psi/psi.h 1786 1786 1787 1787 - src/drivers/pbit/pbit-io-pbit.o: src/drivers/pbit/pbit-io-pbit.c \ 1788 1788 - src/drivers/pbit/pbit-io-pbit.h \ 1789 1789 - src/drivers/pbit/pbit-io.h \ 1790 1790 - src/drivers/pbit/pbit.h 1787 1787 + src/drivers/pri/pri-img-pbit.o: src/drivers/pri/pri-img-pbit.c \ 1788 1788 + src/drivers/pri/pri-img-pbit.h \ 1789 1789 + src/drivers/pri/pri-img.h \ 1790 1790 + src/drivers/pri/pri.h 1791 1791 1792 1792 - src/drivers/pbit/pbit-io-tc.o: src/drivers/pbit/pbit-io-tc.c \ 1793 1793 - src/drivers/pbit/pbit-io-tc.h \ 1794 1794 - src/drivers/pbit/pbit-io.h \ 1795 1795 - src/drivers/pbit/pbit.h 1792 1792 + src/drivers/pri/pri-img-tc.o: src/drivers/pri/pri-img-tc.c \ 1793 1793 + src/drivers/pri/pri-img-tc.h \ 1794 1794 + src/drivers/pri/pri-img.h \ 1795 1795 + src/drivers/pri/pri.h 1796 1796 1797 1797 - src/drivers/pbit/pbit-io.o: src/drivers/pbit/pbit-io.c \ 1798 1798 - src/drivers/pbit/pbit-io-pbit.h \ 1799 1799 - src/drivers/pbit/pbit-io-tc.h \ 1800 1800 - src/drivers/pbit/pbit-io.h \ 1801 1801 - src/drivers/pbit/pbit.h 1797 1797 + src/drivers/pri/pri-img.o: src/drivers/pri/pri-img.c \ 1798 1798 + src/drivers/pri/pri-img-pbit.h \ 1799 1799 + src/drivers/pri/pri-img-tc.h \ 1800 1800 + src/drivers/pri/pri-img.h \ 1801 1801 + src/drivers/pri/pri.h 1802 1802 1803 1803 - src/drivers/pbit/pbit.o: src/drivers/pbit/pbit.c \ 1804 1804 - src/drivers/pbit/pbit.h 1803 1803 + src/drivers/pri/pri.o: src/drivers/pri/pri.c \ 1804 1804 + src/drivers/pri/pri.h 1805 1805 1806 1806 src/drivers/psi/psi-img-ana.o: src/drivers/psi/psi-img-ana.c \ 1807 1807 src/drivers/psi/psi-img-ana.h \ ··· 2098 2098 src/config.h \ 2099 2099 src/libini/libini.h 2100 2100 2101 2101 - src/utils/pbit/pbit.o: src/utils/pbit/pbit.c \ 2102 2102 - src/config.h \ 2103 2103 - src/drivers/pbit/gcr-mac.h \ 2104 2104 - src/drivers/pbit/mfm-ibm.h \ 2105 2105 - src/drivers/pbit/pbit-io.h \ 2106 2106 - src/drivers/pbit/pbit.h \ 2107 2107 - src/drivers/psi/psi-img.h \ 2108 2108 - src/drivers/psi/psi.h \ 2109 2109 - src/lib/getopt.h \ 2110 2110 - src/utils/pbit/pbit.h 2111 2111 - 2112 2101 src/utils/pce-img/pce-img.o: src/utils/pce-img/pce-img.c \ 2113 2102 src/config.h \ 2114 2103 src/drivers/block/blkcow.h \ ··· 2122 2111 src/drivers/psi/psi.h \ 2123 2112 src/lib/getopt.h \ 2124 2113 src/utils/pce-img/pce-img.h 2114 2114 + 2115 2115 + src/utils/pri/main.o: src/utils/pri/main.c \ 2116 2116 + src/config.h \ 2117 2117 + src/drivers/pri/gcr-mac.h \ 2118 2118 + src/drivers/pri/mfm-ibm.h \ 2119 2119 + src/drivers/pri/pri-img.h \ 2120 2120 + src/drivers/pri/pri.h \ 2121 2121 + src/drivers/psi/psi-img.h \ 2122 2122 + src/drivers/psi/psi.h \ 2123 2123 + src/lib/getopt.h \ 2124 2124 + src/utils/pri/main.h 2125 2125 2126 2126 src/utils/psi/comment.o: src/utils/psi/comment.c \ 2127 2127 src/config.h \

+2 -2

Makefile.inc.in

reviewed

··· 140 140 include $(srcdir)/src/drivers/Makefile.inc 141 141 include $(srcdir)/src/drivers/block/Makefile.inc 142 142 include $(srcdir)/src/drivers/char/Makefile.inc 143 143 - include $(srcdir)/src/drivers/pbit/Makefile.inc 143 143 + include $(srcdir)/src/drivers/pri/Makefile.inc 144 144 include $(srcdir)/src/drivers/psi/Makefile.inc 145 145 include $(srcdir)/src/drivers/sound/Makefile.inc 146 146 include $(srcdir)/src/drivers/video/Makefile.inc ··· 156 156 include $(srcdir)/src/arch/simarm/Makefile.inc 157 157 include $(srcdir)/src/arch/sims32/Makefile.inc 158 158 include $(srcdir)/src/utils/Makefile.inc 159 159 - include $(srcdir)/src/utils/pbit/Makefile.inc 160 159 include $(srcdir)/src/utils/pce-img/Makefile.inc 160 160 + include $(srcdir)/src/utils/pri/Makefile.inc 161 161 include $(srcdir)/src/utils/psi/Makefile.inc 162 162 163 163 TARGETS += $(BIN) $(ETC) $(SHARE)

+1 -1

src/arch/macplus/Makefile.inc

reviewed

··· 73 73 src/devices/memory.o \ 74 74 src/drivers/block/block.a \ 75 75 src/drivers/char/char.a \ 76 76 - src/drivers/pbit/pbit.a \ 76 76 + src/drivers/pri/pri.a \ 77 77 src/drivers/psi/psi.a \ 78 78 src/drivers/sound/sound.a \ 79 79 src/drivers/options.o \

+18 -18

src/arch/macplus/iwm-io.c

reviewed

··· 33 33 34 34 #include <drivers/psi/psi.h> 35 35 36 36 - #include <drivers/pbit/pbit.h> 37 37 - #include <drivers/pbit/pbit-io.h> 38 38 - #include <drivers/pbit/gcr-mac.h> 36 36 + #include <drivers/pri/pri.h> 37 37 + #include <drivers/pri/pri-img.h> 38 38 + #include <drivers/pri/gcr-mac.h> 39 39 40 40 41 41 static ··· 109 109 } 110 110 111 111 static 112 112 - pbit_img_t *iwm_drv_load_disk (mac_iwm_drive_t *drv) 112 112 + pri_img_t *iwm_drv_load_disk (mac_iwm_drive_t *drv) 113 113 { 114 114 disk_t *dsk; 115 115 disk_psi_t *psi; 116 116 psi_img_t *img, *del; 117 117 - pbit_img_t *ret; 117 117 + pri_img_t *ret; 118 118 119 119 dsk = dsks_get_disk (drv->dsks, drv->diskid); 120 120 ··· 136 136 return (NULL); 137 137 } 138 138 139 139 - ret = pbit_encode_gcr (img); 139 139 + ret = pri_encode_gcr (img); 140 140 141 141 psi_img_del (del); 142 142 ··· 144 144 } 145 145 146 146 static 147 147 - pbit_img_t *iwm_drv_load_pbit (mac_iwm_drive_t *drv) 147 147 + pri_img_t *iwm_drv_load_pri (mac_iwm_drive_t *drv) 148 148 { 149 149 - pbit_img_t *ret; 149 149 + pri_img_t *ret; 150 150 151 151 if (drv->fname == NULL) { 152 152 return (NULL); 153 153 } 154 154 155 155 - ret = pbit_img_load (drv->fname, PBIT_FORMAT_NONE); 155 155 + ret = pri_img_load (drv->fname, PRI_FORMAT_NONE); 156 156 157 157 return (ret); 158 158 } 159 159 160 160 int iwm_drv_load (mac_iwm_drive_t *drv) 161 161 { 162 162 - pbit_img_t *img; 162 162 + pri_img_t *img; 163 163 164 164 img = NULL; 165 165 166 166 drv->use_fname = 0; 167 167 168 168 if (drv->fname != NULL) { 169 169 - img = iwm_drv_load_pbit (drv); 169 169 + img = iwm_drv_load_pri (drv); 170 170 171 171 if (img != NULL) { 172 172 drv->use_fname = 1; 173 173 - mac_log_deb ("iwm: loading drive %u (pbit)\n", drv->drive + 1); 173 173 + mac_log_deb ("iwm: loading drive %u (pri)\n", drv->drive + 1); 174 174 } 175 175 } 176 176 ··· 187 187 return (1); 188 188 } 189 189 190 190 - pbit_img_del (drv->img); 190 190 + pri_img_del (drv->img); 191 191 192 192 drv->img = img; 193 193 ··· 261 261 return (1); 262 262 } 263 263 264 264 - img = pbit_decode_gcr (drv->img); 264 264 + img = pri_decode_gcr (drv->img); 265 265 266 266 if (img == NULL) { 267 267 return (1); ··· 287 287 } 288 288 289 289 static 290 290 - int iwm_drv_save_pbit (mac_iwm_drive_t *drv) 290 290 + int iwm_drv_save_pri (mac_iwm_drive_t *drv) 291 291 { 292 292 if (drv->fname == NULL) { 293 293 return (1); 294 294 } 295 295 296 296 - if (pbit_img_save (drv->fname, drv->img, PBIT_FORMAT_NONE)) { 296 296 + if (pri_img_save (drv->fname, drv->img, PRI_FORMAT_NONE)) { 297 297 return (1); 298 298 } 299 299 ··· 309 309 mac_log_deb ("iwm: saving drive %u\n", drv->drive + 1); 310 310 311 311 if (drv->use_fname) { 312 312 - if (iwm_drv_save_pbit (drv)) { 313 313 - mac_log_deb ("iwm: saving drive %u failed (pbit)\n", 312 312 + if (iwm_drv_save_pri (drv)) { 313 313 + mac_log_deb ("iwm: saving drive %u failed (pri)\n", 314 314 drv->drive + 1 315 315 ); 316 316 return (1);

+8 -8

src/arch/macplus/iwm.c

reviewed

··· 5 5 /***************************************************************************** 6 6 * File name: src/arch/macplus/iwm.c * 7 7 * Created: 2007-11-25 by Hampa Hug <hampa@hampa.ch> * 8 8 - * Copyright: (C) 2007-2012 Hampa Hug <hampa@hampa.ch> * 8 8 + * Copyright: (C) 2007-2013 Hampa Hug <hampa@hampa.ch> * 9 9 *****************************************************************************/ 10 10 11 11 /***************************************************************************** ··· 115 115 iwm_drv_save (drv); 116 116 } 117 117 118 118 - pbit_img_del (drv->img); 118 118 + pri_img_del (drv->img); 119 119 } 120 120 121 121 /* ··· 147 147 { 148 148 if (drv->write_cnt > drv->cur_track_len) { 149 149 if (drv->auto_rotate) { 150 150 - pbit_trk_rotate (drv->cur_track, drv->cur_track_pos); 150 150 + pri_trk_rotate (drv->cur_track, drv->cur_track_pos); 151 151 drv->cur_track_pos = 0; 152 152 } 153 153 } ··· 158 158 static 159 159 void iwm_drv_select_track (mac_iwm_drive_t *drv, unsigned c, unsigned h) 160 160 { 161 161 - pbit_trk_t *trk; 161 161 + pri_trk_t *trk; 162 162 163 163 if ((c >= drv->cylinders) || (h >= drv->heads)) { 164 164 return; 165 165 } 166 166 167 167 if (drv->img == NULL) { 168 168 - drv->img = pbit_img_new(); 168 168 + drv->img = pri_img_new(); 169 169 } 170 170 171 171 - trk = pbit_img_get_track (drv->img, c, h, 1); 171 171 + trk = pri_img_get_track (drv->img, c, h, 1); 172 172 173 173 if (trk == NULL) { 174 174 return; 175 175 } 176 176 177 177 if (trk->size == 0) { 178 178 - if (pbit_trk_set_size (trk, iwm_drv_get_track_length (c))) { 178 178 + if (pri_trk_set_size (trk, iwm_drv_get_track_length (c))) { 179 179 return; 180 180 } 181 181 } 182 182 183 183 if (trk->clock == 0) { 184 184 - pbit_trk_set_clock (trk, 500000); 184 184 + pri_trk_set_clock (trk, 500000); 185 185 } 186 186 187 187 drv->cur_cyl = c;

+4 -4

src/arch/macplus/iwm.h

reviewed

··· 5 5 /***************************************************************************** 6 6 * File name: src/arch/macplus/iwm.h * 7 7 * Created: 2007-11-25 by Hampa Hug <hampa@hampa.ch> * 8 8 - * Copyright: (C) 2007-2012 Hampa Hug <hampa@hampa.ch> * 8 8 + * Copyright: (C) 2007-2013 Hampa Hug <hampa@hampa.ch> * 9 9 *****************************************************************************/ 10 10 11 11 /***************************************************************************** ··· 25 25 26 26 27 27 #include <drivers/block/block.h> 28 28 - #include <drivers/pbit/pbit.h> 28 28 + #include <drivers/pri/pri.h> 29 29 30 30 31 31 #define MAC_IWM_DRIVES 3 ··· 41 41 disks_t *dsks; 42 42 unsigned diskid; 43 43 44 44 - pbit_img_t *img; 44 44 + pri_img_t *img; 45 45 46 46 char use_fname; 47 47 char locked; ··· 59 59 unsigned cur_cyl; 60 60 unsigned cur_head; 61 61 62 62 - pbit_trk_t *cur_track; 62 62 + pri_trk_t *cur_track; 63 63 unsigned long cur_track_pos; 64 64 unsigned long cur_track_len; 65 65

+1 -1

src/arch/rc759/Makefile.inc

reviewed

··· 68 68 src/devices/memory.o \ 69 69 src/drivers/block/block.a \ 70 70 src/drivers/char/char.a \ 71 71 - src/drivers/pbit/pbit.a \ 71 71 + src/drivers/pri/pri.a \ 72 72 src/drivers/psi/psi.a \ 73 73 src/drivers/sound/sound.a \ 74 74 src/drivers/options.o \

+27 -27

src/arch/rc759/fdc.c

reviewed

··· 34 34 35 35 #include <drivers/psi/psi.h> 36 36 37 37 - #include <drivers/pbit/pbit.h> 38 38 - #include <drivers/pbit/pbit-io.h> 39 39 - #include <drivers/pbit/mfm-ibm.h> 37 37 + #include <drivers/pri/pri.h> 38 38 + #include <drivers/pri/pri-img.h> 39 39 + #include <drivers/pri/mfm-ibm.h> 40 40 41 41 #include <lib/log.h> 42 42 #include <lib/string.h> ··· 52 52 { 53 53 unsigned long cnt; 54 54 rc759_fdc_t *fdc; 55 55 - pbit_img_t *img; 56 56 - pbit_trk_t *trk; 55 55 + pri_img_t *img; 56 56 + pri_trk_t *trk; 57 57 58 58 fdc = ext; 59 59 ··· 63 63 return (1); 64 64 } 65 65 66 66 - trk = pbit_img_get_track (img, drv->c, drv->h, 0); 66 66 + trk = pri_img_get_track (img, drv->c, drv->h, 0); 67 67 68 68 if (trk == NULL) { 69 69 return (1); ··· 87 87 { 88 88 unsigned long cnt; 89 89 rc759_fdc_t *fdc; 90 90 - pbit_img_t *img; 91 91 - pbit_trk_t *trk; 90 90 + pri_img_t *img; 91 91 + pri_trk_t *trk; 92 92 93 93 fdc = ext; 94 94 ··· 100 100 101 101 fdc->modified[drv->d & 1] = 1; 102 102 103 103 - trk = pbit_img_get_track (img, drv->c, drv->h, 1); 103 103 + trk = pri_img_get_track (img, drv->c, drv->h, 1); 104 104 105 105 if (trk == NULL) { 106 106 return (1); 107 107 } 108 108 109 109 - if (pbit_trk_set_size (trk, drv->trkbuf_cnt)) { 109 109 + if (pri_trk_set_size (trk, drv->trkbuf_cnt)) { 110 110 return (1); 111 111 } 112 112 113 113 - pbit_trk_set_clock (trk, 1000000); 113 113 + pri_trk_set_clock (trk, 1000000); 114 114 115 115 cnt = (trk->size + 7) / 8; 116 116 ··· 151 151 for (i = 0; i < 2; i++) { 152 152 rc759_fdc_save (fdc, i); 153 153 154 154 - pbit_img_del (fdc->img[i]); 154 154 + pri_img_del (fdc->img[i]); 155 155 156 156 free (fdc->fname[i]); 157 157 } ··· 300 300 } 301 301 302 302 static 303 303 - pbit_img_t *rc759_fdc_load_pbit (rc759_fdc_t *fdc, unsigned drive) 303 303 + pri_img_t *rc759_fdc_load_pri (rc759_fdc_t *fdc, unsigned drive) 304 304 { 305 305 - pbit_img_t *img; 305 305 + pri_img_t *img; 306 306 307 307 if (fdc->fname[drive] == NULL) { 308 308 return (NULL); 309 309 } 310 310 311 311 - img = pbit_img_load (fdc->fname[drive], PBIT_FORMAT_PBIT); 311 311 + img = pri_img_load (fdc->fname[drive], PRI_FORMAT_PBIT); 312 312 313 313 return (img); 314 314 } ··· 362 362 } 363 363 364 364 static 365 365 - pbit_img_t *rc759_fdc_load_disk (rc759_fdc_t *fdc, unsigned drive) 365 365 + pri_img_t *rc759_fdc_load_disk (rc759_fdc_t *fdc, unsigned drive) 366 366 { 367 367 disk_t *dsk; 368 368 disk_psi_t *dskpsi; 369 369 psi_img_t *img, *del; 370 370 - pbit_img_t *ret; 370 370 + pri_img_t *ret; 371 371 372 372 dsk = dsks_get_disk (fdc->dsks, fdc->diskid[drive]); 373 373 ··· 389 389 return (NULL); 390 390 } 391 391 392 392 - ret = pbit_encode_mfm_hd_360 (img); 392 392 + ret = pri_encode_mfm_hd_360 (img); 393 393 394 394 psi_img_del (del); 395 395 ··· 398 398 399 399 int rc759_fdc_load (rc759_fdc_t *fdc, unsigned drive) 400 400 { 401 401 - pbit_img_t *img; 401 401 + pri_img_t *img; 402 402 403 403 wd179x_set_ready (&fdc->wd179x, drive, 0); 404 404 ··· 407 407 fdc->use_fname[drive] = 0; 408 408 409 409 if (fdc->fname[drive] != NULL) { 410 410 - img = rc759_fdc_load_pbit (fdc, drive); 410 410 + img = rc759_fdc_load_pri (fdc, drive); 411 411 412 412 if (img != NULL) { 413 413 fdc->use_fname[drive] = 1; 414 414 - sim_log_deb ("fdc: loading drive %u (pbit)\n", drive); 414 414 + sim_log_deb ("fdc: loading drive %u (pri)\n", drive); 415 415 } 416 416 } 417 417 ··· 428 428 return (1); 429 429 } 430 430 431 431 - pbit_img_del (fdc->img[drive]); 431 431 + pri_img_del (fdc->img[drive]); 432 432 433 433 fdc->img[drive] = img; 434 434 ··· 500 500 return (1); 501 501 } 502 502 503 503 - img = pbit_decode_mfm (fdc->img[drive]); 503 503 + img = pri_decode_mfm (fdc->img[drive]); 504 504 505 505 if (img == NULL) { 506 506 return (1); ··· 526 526 } 527 527 528 528 static 529 529 - int rc759_fdc_save_pbit (rc759_fdc_t *fdc, unsigned drive) 529 529 + int rc759_fdc_save_pri (rc759_fdc_t *fdc, unsigned drive) 530 530 { 531 531 if (fdc->fname[drive] == NULL) { 532 532 return (1); 533 533 } 534 534 535 535 - if (pbit_img_save (fdc->fname[drive], fdc->img[drive], PBIT_FORMAT_NONE)) { 535 535 + if (pri_img_save (fdc->fname[drive], fdc->img[drive], PRI_FORMAT_NONE)) { 536 536 return (1); 537 537 } 538 538 ··· 552 552 sim_log_deb ("fdc: saving drive %u\n", drive); 553 553 554 554 if (fdc->use_fname[drive]) { 555 555 - if (rc759_fdc_save_pbit (fdc, drive)) { 556 556 - sim_log_deb ("fdc: saving drive %u failed (pbit)\n", 555 555 + if (rc759_fdc_save_pri (fdc, drive)) { 556 556 + sim_log_deb ("fdc: saving drive %u failed (pri)\n", 557 557 drive 558 558 ); 559 559 return (1);

+3 -3

src/arch/rc759/fdc.h

reviewed

··· 5 5 /***************************************************************************** 6 6 * File name: src/arch/rc759/fdc.h * 7 7 * Created: 2012-07-05 by Hampa Hug <hampa@hampa.ch> * 8 8 - * Copyright: (C) 2012 Hampa Hug <hampa@hampa.ch> * 8 8 + * Copyright: (C) 2012-2013 Hampa Hug <hampa@hampa.ch> * 9 9 *****************************************************************************/ 10 10 11 11 /***************************************************************************** ··· 28 28 29 29 #include <drivers/block/block.h> 30 30 31 31 - #include <drivers/pbit/pbit.h> 31 31 + #include <drivers/pri/pri.h> 32 32 33 33 34 34 typedef struct { ··· 44 44 45 45 unsigned short diskid[2]; 46 46 47 47 - pbit_img_t *img[2]; 47 47 + pri_img_t *img[2]; 48 48 49 49 char modified[2]; 50 50 } rc759_fdc_t;

-31

src/drivers/pbit/Makefile.inc

reviewed

··· 1 1 - # src/drivers/pbit/Makefile.inc 2 2 - 3 3 - rel := src/drivers/pbit 4 4 - 5 5 - DIRS += $(rel) 6 6 - DIST += $(rel)/Makefile.inc 7 7 - 8 8 - DRV_PBIT_BAS := \ 9 9 - gcr-mac \ 10 10 - mfm-ibm \ 11 11 - pbit-io \ 12 12 - pbit-io-pbit \ 13 13 - pbit-io-tc \ 14 14 - pbit 15 15 - 16 16 - DRV_PBIT_SRC := $(foreach f,$(DRV_PBIT_BAS),$(rel)/$(f).c) 17 17 - DRV_PBIT_OBJ := $(foreach f,$(DRV_PBIT_BAS),$(rel)/$(f).o) 18 18 - DRV_PBIT_HDR := $(foreach f,$(DRV_PBIT_BAS),$(rel)/$(f).h) 19 19 - DRV_PBIT_ARC := $(rel)/pbit.a 20 20 - 21 21 - CLN += $(DRV_PBIT_ARC) $(DRV_PBIT_OBJ) 22 22 - DIST += $(DRV_PBIT_SRC) $(DRV_PBIT_HDR) 23 23 - 24 24 - $(rel)/gcr-mac.o: $(rel)/gcr-mac.c 25 25 - $(rel)/mfm-ibm.o: $(rel)/mfm-ibm.c 26 26 - $(rel)/pbit-io.o: $(rel)/pbit-io.c 27 27 - $(rel)/pbit-io-pbit.o: $(rel)/pbit-io-pbit.c 28 28 - $(rel)/pbit-io-tc.o: $(rel)/pbit-io-tc.c 29 29 - $(rel)/pbit.o: $(rel)/pbit.c 30 30 - 31 31 - $(rel)/pbit.a: $(DRV_PBIT_OBJ)

+58 -58

src/drivers/pbit/gcr-mac.c src/drivers/pri/gcr-mac.c

reviewed

··· 3 3 *****************************************************************************/ 4 4 5 5 /***************************************************************************** 6 6 - * File name: src/drivers/pbit/gcr-mac.c * 6 6 + * File name: src/drivers/pri/gcr-mac.c * 7 7 * Created: 2012-02-01 by Hampa Hug <hampa@hampa.ch> * 8 8 * Copyright: (C) 2012-2013 Hampa Hug <hampa@hampa.ch> * 9 9 *****************************************************************************/ ··· 26 26 27 27 #include <drivers/psi/psi.h> 28 28 29 29 - #include "pbit.h" 29 29 + #include "pri.h" 30 30 #include "gcr-mac.h" 31 31 32 32 ··· 105 105 } 106 106 107 107 static 108 108 - void gcr_fill_track (pbit_trk_t *trk) 108 108 + void gcr_fill_track (pri_trk_t *trk) 109 109 { 110 110 unsigned long cnt, n; 111 111 ··· 114 114 while (cnt > 0) { 115 115 n = (cnt < 10) ? cnt : 10; 116 116 117 117 - pbit_trk_set_bits (trk, 0xff >> (10 - n), n); 117 117 + pri_trk_set_bits (trk, 0xff >> (10 - n), n); 118 118 119 119 cnt -= n; 120 120 } ··· 174 174 } 175 175 176 176 static 177 177 - unsigned gcr_decode_byte (pbit_trk_t *trk, int xlat) 177 177 + unsigned gcr_decode_byte (pri_trk_t *trk, int xlat) 178 178 { 179 179 unsigned val, cnt; 180 180 unsigned long bit; 181 181 182 182 - pbit_trk_get_bits (trk, &bit, 8); 182 182 + pri_trk_get_bits (trk, &bit, 8); 183 183 184 184 val = bit; 185 185 cnt = 8; 186 186 187 187 while (((val & 0x80) == 0) && (cnt < 64)) { 188 188 - pbit_trk_get_bits (trk, &bit, 1); 188 188 + pri_trk_get_bits (trk, &bit, 1); 189 189 val = (val << 1) | (bit & 1); 190 190 cnt += 1; 191 191 } ··· 202 202 } 203 203 204 204 static 205 205 - int gcr_decode_data (pbit_trk_t *trk, unsigned char *dst) 205 205 + int gcr_decode_data (pri_trk_t *trk, unsigned char *dst) 206 206 { 207 207 unsigned i; 208 208 unsigned val; ··· 236 236 } 237 237 238 238 static 239 239 - psi_sct_t *pbit_decode_gcr_sct (pbit_trk_t *trk) 239 239 + psi_sct_t *pri_decode_gcr_sct (pri_trk_t *trk) 240 240 { 241 241 unsigned i; 242 242 unsigned lc, lh, ls, lm, ck; ··· 309 309 return (sct); 310 310 } 311 311 312 312 - psi_trk_t *pbit_decode_gcr_trk (pbit_trk_t *trk, unsigned h) 312 312 + psi_trk_t *pri_decode_gcr_trk (pri_trk_t *trk, unsigned h) 313 313 { 314 314 unsigned long pos; 315 315 char wrap; 316 316 unsigned char buf[3]; 317 317 - psi_sct_t *sct; 318 318 - psi_trk_t *dtrk; 317 317 + psi_sct_t *sct; 318 318 + psi_trk_t *dtrk; 319 319 320 320 dtrk = psi_trk_new (h); 321 321 ··· 323 323 return (NULL); 324 324 } 325 325 326 326 - pbit_trk_set_pos (trk, 0); 326 326 + pri_trk_set_pos (trk, 0); 327 327 328 328 buf[0] = 0; 329 329 buf[1] = 0; ··· 338 338 wrap = trk->wrap; 339 339 340 340 if ((buf[0] == 0xd5) && (buf[1] == 0xaa) && (buf[2] == 0x96)) { 341 341 - sct = pbit_decode_gcr_sct (trk); 341 341 + sct = pri_decode_gcr_sct (trk); 342 342 343 343 if (sct != NULL) { 344 344 psi_trk_add_sector (dtrk, sct); ··· 352 352 return (dtrk); 353 353 } 354 354 355 355 - psi_img_t *pbit_decode_gcr (pbit_img_t *img) 355 355 + psi_img_t *pri_decode_gcr (pri_img_t *img) 356 356 { 357 357 unsigned long c, h; 358 358 - pbit_cyl_t *cyl; 359 359 - pbit_trk_t *trk; 358 358 + pri_cyl_t *cyl; 359 359 + pri_trk_t *trk; 360 360 psi_img_t *dimg; 361 361 psi_trk_t *dtrk; 362 362 ··· 380 380 dtrk = psi_trk_new (h); 381 381 } 382 382 else { 383 383 - dtrk = pbit_decode_gcr_trk (trk, h); 383 383 + dtrk = pri_decode_gcr_trk (trk, h); 384 384 } 385 385 386 386 if ((dtrk->sct_cnt == 0) && ((h + 1) == cyl->trk_cnt)) { ··· 402 402 403 403 404 404 static 405 405 - void pbit_encode_gcr_sct (pbit_trk_t *trk, unsigned char *src, unsigned c, unsigned h, unsigned s, unsigned fmt) 405 405 + void pri_encode_gcr_sct (pri_trk_t *trk, unsigned char *src, unsigned c, unsigned h, unsigned s, unsigned fmt) 406 406 { 407 407 unsigned i, v; 408 408 unsigned char buf[527]; ··· 411 411 h = (h << 5) | ((c >> 6) & 0x1f); 412 412 413 413 for (i = 0; i < 38; i++) { 414 414 - pbit_trk_set_bits (trk, 0xff, 10); 414 414 + pri_trk_set_bits (trk, 0xff, 10); 415 415 } 416 416 417 417 - pbit_trk_set_bits (trk, 0xd5aa96, 24); 418 418 - pbit_trk_set_bits (trk, gcr_enc_tab[c & 0x3f], 8); 419 419 - pbit_trk_set_bits (trk, gcr_enc_tab[s & 0x3f], 8); 420 420 - pbit_trk_set_bits (trk, gcr_enc_tab[h & 0x3f], 8); 421 421 - pbit_trk_set_bits (trk, gcr_enc_tab[fmt & 0x3f], 8); 422 422 - pbit_trk_set_bits (trk, gcr_enc_tab[(c ^ h ^ s ^ fmt) & 0x3f], 8); 423 423 - pbit_trk_set_bits (trk, 0xdeaa, 16); 417 417 + pri_trk_set_bits (trk, 0xd5aa96, 24); 418 418 + pri_trk_set_bits (trk, gcr_enc_tab[c & 0x3f], 8); 419 419 + pri_trk_set_bits (trk, gcr_enc_tab[s & 0x3f], 8); 420 420 + pri_trk_set_bits (trk, gcr_enc_tab[h & 0x3f], 8); 421 421 + pri_trk_set_bits (trk, gcr_enc_tab[fmt & 0x3f], 8); 422 422 + pri_trk_set_bits (trk, gcr_enc_tab[(c ^ h ^ s ^ fmt) & 0x3f], 8); 423 423 + pri_trk_set_bits (trk, 0xdeaa, 16); 424 424 425 425 for (i = 0; i < 8; i++) { 426 426 - pbit_trk_set_bits (trk, 0xff, 10); 426 426 + pri_trk_set_bits (trk, 0xff, 10); 427 427 } 428 428 429 429 - pbit_trk_set_bits (trk, 0xd5aaad, 24); 430 430 - pbit_trk_set_bits (trk, gcr_enc_tab[s & 0x3f], 8); 429 429 + pri_trk_set_bits (trk, 0xd5aaad, 24); 430 430 + pri_trk_set_bits (trk, gcr_enc_tab[s & 0x3f], 8); 431 431 432 432 gcr_checksum (buf, src, 1); 433 433 ··· 436 436 for (i = 0; i < 522; i += 3) { 437 437 v = ((p[0] & 0xc0) >> 2) | ((p[1] & 0xc0) >> 4) | ((p[2] & 0xc0) >> 6); 438 438 439 439 - pbit_trk_set_bits (trk, gcr_enc_tab[v & 0x3f], 8); 440 440 - pbit_trk_set_bits (trk, gcr_enc_tab[p[0] & 0x3f], 8); 441 441 - pbit_trk_set_bits (trk, gcr_enc_tab[p[1] & 0x3f], 8); 442 442 - pbit_trk_set_bits (trk, gcr_enc_tab[p[2] & 0x3f], 8); 439 439 + pri_trk_set_bits (trk, gcr_enc_tab[v & 0x3f], 8); 440 440 + pri_trk_set_bits (trk, gcr_enc_tab[p[0] & 0x3f], 8); 441 441 + pri_trk_set_bits (trk, gcr_enc_tab[p[1] & 0x3f], 8); 442 442 + pri_trk_set_bits (trk, gcr_enc_tab[p[2] & 0x3f], 8); 443 443 444 444 p += 3; 445 445 } 446 446 447 447 v = ((p[0] & 0xc0) >> 2) | ((p[1] & 0xc0) >> 4); 448 448 - pbit_trk_set_bits (trk, gcr_enc_tab[v & 0x3f], 8); 449 449 - pbit_trk_set_bits (trk, gcr_enc_tab[p[0] & 0x3f], 8); 450 450 - pbit_trk_set_bits (trk, gcr_enc_tab[p[1] & 0x3f], 8); 448 448 + pri_trk_set_bits (trk, gcr_enc_tab[v & 0x3f], 8); 449 449 + pri_trk_set_bits (trk, gcr_enc_tab[p[0] & 0x3f], 8); 450 450 + pri_trk_set_bits (trk, gcr_enc_tab[p[1] & 0x3f], 8); 451 451 452 452 v = ((p[2] & 0xc0) >> 2) | ((p[3] & 0xc0) >> 4) | ((p[4] & 0xc0) >> 6); 453 453 - pbit_trk_set_bits (trk, gcr_enc_tab[v & 0x3f], 8); 454 454 - pbit_trk_set_bits (trk, gcr_enc_tab[p[2] & 0x3f], 8); 455 455 - pbit_trk_set_bits (trk, gcr_enc_tab[p[3] & 0x3f], 8); 456 456 - pbit_trk_set_bits (trk, gcr_enc_tab[p[4] & 0x3f], 8); 453 453 + pri_trk_set_bits (trk, gcr_enc_tab[v & 0x3f], 8); 454 454 + pri_trk_set_bits (trk, gcr_enc_tab[p[2] & 0x3f], 8); 455 455 + pri_trk_set_bits (trk, gcr_enc_tab[p[3] & 0x3f], 8); 456 456 + pri_trk_set_bits (trk, gcr_enc_tab[p[4] & 0x3f], 8); 457 457 458 458 - pbit_trk_set_bits (trk, 0xdeaa, 16); 458 458 + pri_trk_set_bits (trk, 0xdeaa, 16); 459 459 } 460 460 461 461 - int pbit_encode_gcr_trk (pbit_trk_t *dtrk, psi_trk_t *strk, unsigned fmt) 461 461 + int pri_encode_gcr_trk (pri_trk_t *dtrk, psi_trk_t *strk, unsigned fmt) 462 462 { 463 463 unsigned i, f; 464 464 unsigned char buf[524]; 465 465 - psi_sct_t *sct; 465 465 + psi_sct_t *sct; 466 466 467 467 - pbit_trk_set_pos (dtrk, 0); 467 467 + pri_trk_set_pos (dtrk, 0); 468 468 469 469 for (i = 0; i < 32; i++) { 470 470 - pbit_trk_set_bits (dtrk, 0xff, 10); 470 470 + pri_trk_set_bits (dtrk, 0xff, 10); 471 471 } 472 472 473 473 for (i = 0; i < strk->sct_cnt; i++) { ··· 488 488 489 489 psi_sct_get_tags (sct, buf, 12); 490 490 491 491 - pbit_encode_gcr_sct (dtrk, buf, sct->c, sct->h, sct->s, f); 491 491 + pri_encode_gcr_sct (dtrk, buf, sct->c, sct->h, sct->s, f); 492 492 } 493 493 494 494 if (dtrk->wrap) { ··· 500 500 return (0); 501 501 } 502 502 503 503 - int pbit_encode_gcr_img (pbit_img_t *dimg, psi_img_t *simg) 503 503 + int pri_encode_gcr_img (pri_img_t *dimg, psi_img_t *simg) 504 504 { 505 505 unsigned long c, h; 506 506 unsigned long size; 507 507 unsigned fmt; 508 508 psi_cyl_t *cyl; 509 509 psi_trk_t *trk; 510 510 - pbit_trk_t *dtrk; 510 510 + pri_trk_t *dtrk; 511 511 512 512 fmt = gcr_get_format (simg); 513 513 ··· 519 519 for (h = 0; h < cyl->trk_cnt; h++) { 520 520 trk = cyl->trk[h]; 521 521 522 522 - dtrk = pbit_img_get_track (dimg, c, h, 1); 522 522 + dtrk = pri_img_get_track (dimg, c, h, 1); 523 523 524 524 if (dtrk == NULL) { 525 525 return (1); 526 526 } 527 527 528 528 - if (pbit_trk_set_size (dtrk, size)) { 528 528 + if (pri_trk_set_size (dtrk, size)) { 529 529 return (1); 530 530 } 531 531 532 532 - pbit_trk_set_clock (dtrk, 500000); 532 532 + pri_trk_set_clock (dtrk, 500000); 533 533 534 534 - if (pbit_encode_gcr_trk (dtrk, trk, fmt)) { 534 534 + if (pri_encode_gcr_trk (dtrk, trk, fmt)) { 535 535 return (1); 536 536 } 537 537 } ··· 540 540 return (0); 541 541 } 542 542 543 543 - pbit_img_t *pbit_encode_gcr (psi_img_t *img) 543 543 + pri_img_t *pri_encode_gcr (psi_img_t *img) 544 544 { 545 545 - pbit_img_t *dimg; 545 545 + pri_img_t *dimg; 546 546 547 547 - dimg = pbit_img_new(); 547 547 + dimg = pri_img_new(); 548 548 549 549 if (dimg == NULL) { 550 550 return (NULL); 551 551 } 552 552 553 553 - if (pbit_encode_gcr_img (dimg, img)) { 554 554 - pbit_img_del (dimg); 553 553 + if (pri_encode_gcr_img (dimg, img)) { 554 554 + pri_img_del (dimg); 555 555 return (NULL); 556 556 } 557 557

+9 -9

src/drivers/pbit/gcr-mac.h src/drivers/pri/gcr-mac.h

reviewed

··· 3 3 *****************************************************************************/ 4 4 5 5 /***************************************************************************** 6 6 - * File name: src/drivers/pbit/gcr-mac.h * 6 6 + * File name: src/drivers/pri/gcr-mac.h * 7 7 * Created: 2012-02-01 by Hampa Hug <hampa@hampa.ch> * 8 8 * Copyright: (C) 2012-2013 Hampa Hug <hampa@hampa.ch> * 9 9 *****************************************************************************/ ··· 20 20 *****************************************************************************/ 21 21 22 22 23 23 - #ifndef PCE_PBIT_GCR_MAC_H 24 24 - #define PCE_PBIT_GCR_MAC_H 1 23 23 + #ifndef PCE_PRI_GCR_MAC_H 24 24 + #define PCE_PRI_GCR_MAC_H 1 25 25 26 26 27 27 - #include <drivers/pbit/pbit.h> 27 27 + #include <drivers/pri/pri.h> 28 28 #include <drivers/psi/psi.h> 29 29 30 30 31 31 - psi_trk_t *pbit_decode_gcr_trk (pbit_trk_t *trk, unsigned h); 32 32 - psi_img_t *pbit_decode_gcr (pbit_img_t *img); 31 31 + psi_trk_t *pri_decode_gcr_trk (pri_trk_t *trk, unsigned h); 32 32 + psi_img_t *pri_decode_gcr (pri_img_t *img); 33 33 34 34 - int pbit_encode_gcr_trk (pbit_trk_t *dtrk, psi_trk_t *strk, unsigned fmt); 35 35 - int pbit_encode_gcr_img (pbit_img_t *dimg, psi_img_t *simg); 36 36 - pbit_img_t *pbit_encode_gcr (psi_img_t *img); 34 34 + int pri_encode_gcr_trk (pri_trk_t *dtrk, psi_trk_t *strk, unsigned fmt); 35 35 + int pri_encode_gcr_img (pri_img_t *dimg, psi_img_t *simg); 36 36 + pri_img_t *pri_encode_gcr (psi_img_t *img); 37 37 38 38 39 39 #endif

+39 -45

src/drivers/pbit/mfm-ibm.c src/drivers/pri/mfm-ibm.c

reviewed

··· 3 3 *****************************************************************************/ 4 4 5 5 /***************************************************************************** 6 6 - * File name: src/drivers/pbit/mfm-ibm.c * 6 6 + * File name: src/drivers/pri/mfm-ibm.c * 7 7 * Created: 2012-02-01 by Hampa Hug <hampa@hampa.ch> * 8 8 * Copyright: (C) 2012-2013 Hampa Hug <hampa@hampa.ch> * 9 9 *****************************************************************************/ ··· 26 26 27 27 #include <drivers/psi/psi.h> 28 28 29 29 - #include "pbit.h" 30 30 - #include "pbit-io.h" 29 29 + #include "pri.h" 30 30 + #include "pri-img.h" 31 31 #include "mfm-ibm.h" 32 32 33 33 34 34 typedef struct { 35 35 - pbit_trk_t *trk; 35 35 + pri_trk_t *trk; 36 36 37 37 char last; 38 38 char clock; ··· 74 74 { 75 75 unsigned long bit; 76 76 77 77 - pbit_trk_get_bits (mfm->trk, &bit, 1); 77 77 + pri_trk_get_bits (mfm->trk, &bit, 1); 78 78 79 79 mfm->clock = !mfm->clock; 80 80 ··· 185 185 186 186 mfm_read (mfm, buf, 6); 187 187 188 188 - crc = pbit_get_uint16_be (buf, 4); 188 188 + crc = pri_get_uint16_be (buf, 4); 189 189 190 190 mfm->crc = mfm_crc (mfm->crc, buf, 4); 191 191 ··· 227 227 psi_sct_set_flags (sct, PSI_FLAG_NO_DAM, 0); 228 228 psi_sct_set_flags (sct, PSI_FLAG_DEL_DAM, mark == 0xf8); 229 229 230 230 - crc = pbit_get_uint16_be (buf, 0); 230 230 + crc = pri_get_uint16_be (buf, 0); 231 231 232 232 mfm->crc = mfm_crc (mfm->crc, sct->data, sct->n); 233 233 ··· 244 244 unsigned char mark2; 245 245 char wrap; 246 246 unsigned long pos; 247 247 - psi_sct_t *sct; 247 247 + psi_sct_t *sct; 248 248 249 249 switch (mark) { 250 250 case 0xfe: /* ID address mark */ ··· 295 295 return (0); 296 296 } 297 297 298 298 - psi_trk_t *pbit_decode_mfm_trk (pbit_trk_t *trk, unsigned h) 298 298 + psi_trk_t *pri_decode_mfm_trk (pri_trk_t *trk, unsigned h) 299 299 { 300 300 unsigned char mark; 301 301 psi_trk_t *dtrk; ··· 310 310 mfm.trk = trk; 311 311 mfm.clock = 0; 312 312 313 313 - pbit_trk_set_pos (trk, 0); 313 313 + pri_trk_set_pos (trk, 0); 314 314 315 315 while (trk->wrap == 0) { 316 316 if (mfm_sync_mark (&mfm, &mark)) { ··· 330 330 return (dtrk); 331 331 } 332 332 333 333 - psi_img_t *pbit_decode_mfm (pbit_img_t *img) 333 333 + psi_img_t *pri_decode_mfm (pri_img_t *img) 334 334 { 335 335 unsigned long c, h; 336 336 - pbit_cyl_t *cyl; 337 337 - pbit_trk_t *trk; 336 336 + pri_cyl_t *cyl; 337 337 + pri_trk_t *trk; 338 338 psi_img_t *dimg; 339 339 psi_trk_t *dtrk; 340 340 ··· 358 358 dtrk = psi_trk_new (h); 359 359 } 360 360 else { 361 361 - dtrk = pbit_decode_mfm_trk (trk, h); 361 361 + dtrk = pri_decode_mfm_trk (trk, h); 362 362 } 363 363 364 364 if (dtrk == NULL) { ··· 400 400 max = 16; 401 401 } 402 402 403 403 - pbit_trk_set_bits (mfm->trk, buf >> (16 - max), max); 403 403 + pri_trk_set_bits (mfm->trk, buf >> (16 - max), max); 404 404 405 405 mfm->last = buf & 1; 406 406 } ··· 435 435 unsigned char buf[8]; 436 436 437 437 if (sct->position != 0xffffffff) { 438 438 - pbit_trk_set_pos (mfm->trk, 2 * sct->position); 438 438 + pri_trk_set_pos (mfm->trk, 2 * sct->position); 439 439 } 440 440 441 441 flags = sct->flags; ··· 494 494 } 495 495 } 496 496 497 497 - int pbit_encode_mfm_trk (pbit_trk_t *dtrk, psi_trk_t *strk, pbit_encode_mfm_t *par) 497 497 + int pri_encode_mfm_trk (pri_trk_t *dtrk, psi_trk_t *strk, pri_encode_mfm_t *par) 498 498 { 499 499 unsigned i; 500 500 psi_sct_t *sct; ··· 503 503 mfm.trk = dtrk; 504 504 mfm.last = 0; 505 505 506 506 - pbit_trk_set_pos (dtrk, 0); 506 506 + pri_trk_set_pos (dtrk, 0); 507 507 508 508 for (i = 0; i < 146; i++) { 509 509 mfm_encode_byte (&mfm, 0x4e, 0xffff); ··· 513 513 sct = strk->sct[i]; 514 514 515 515 mfm_encode_sector (&mfm, sct, par->gap3); 516 516 - } 517 517 - 518 518 - if (dtrk->wrap) { 519 519 - fprintf (stderr, "pbit: warning: track too long (%lu)\n", 520 520 - dtrk->idx 521 521 - ); 522 516 } 523 517 524 518 while (dtrk->wrap == 0) { ··· 528 522 return (0); 529 523 } 530 524 531 531 - int pbit_encode_mfm_img (pbit_img_t *dimg, psi_img_t *simg, pbit_encode_mfm_t *par) 525 525 + int pri_encode_mfm_img (pri_img_t *dimg, psi_img_t *simg, pri_encode_mfm_t *par) 532 526 { 533 527 unsigned long c, h; 534 528 psi_cyl_t *cyl; 535 529 psi_trk_t *trk; 536 536 - pbit_trk_t *dtrk; 530 530 + pri_trk_t *dtrk; 537 531 538 532 for (c = 0; c < simg->cyl_cnt; c++) { 539 533 cyl = simg->cyl[c]; ··· 541 535 for (h = 0; h < cyl->trk_cnt; h++) { 542 536 trk = cyl->trk[h]; 543 537 544 544 - dtrk = pbit_img_get_track (dimg, c, h, 1); 538 538 + dtrk = pri_img_get_track (dimg, c, h, 1); 545 539 546 540 if (dtrk == NULL) { 547 541 return (1); 548 542 } 549 543 550 550 - if (pbit_trk_set_size (dtrk, par->track_size)) { 544 544 + if (pri_trk_set_size (dtrk, par->track_size)) { 551 545 return (1); 552 546 } 553 547 554 554 - pbit_trk_set_clock (dtrk, par->clock); 555 555 - pbit_trk_clear_16 (dtrk, 0x9254); 548 548 + pri_trk_set_clock (dtrk, par->clock); 549 549 + pri_trk_clear_16 (dtrk, 0x9254); 556 550 557 557 - if (pbit_encode_mfm_trk (dtrk, trk, par)) { 551 551 + if (pri_encode_mfm_trk (dtrk, trk, par)) { 558 552 return (1); 559 553 } 560 554 } ··· 563 557 return (0); 564 558 } 565 559 566 566 - pbit_img_t *pbit_encode_mfm (psi_img_t *img, pbit_encode_mfm_t *par) 560 560 + pri_img_t *pri_encode_mfm (psi_img_t *img, pri_encode_mfm_t *par) 567 561 { 568 568 - pbit_img_t *dimg; 562 562 + pri_img_t *dimg; 569 563 570 570 - dimg = pbit_img_new(); 564 564 + dimg = pri_img_new(); 571 565 572 566 if (dimg == NULL) { 573 567 return (NULL); 574 568 } 575 569 576 576 - if (pbit_encode_mfm_img (dimg, img, par)) { 577 577 - pbit_img_del (dimg); 570 570 + if (pri_encode_mfm_img (dimg, img, par)) { 571 571 + pri_img_del (dimg); 578 572 return (NULL); 579 573 } 580 574 581 575 return (dimg); 582 576 } 583 577 584 584 - pbit_img_t *pbit_encode_mfm_dd_300 (psi_img_t *img) 578 578 + pri_img_t *pri_encode_mfm_dd_300 (psi_img_t *img) 585 579 { 586 586 - pbit_encode_mfm_t par; 580 580 + pri_encode_mfm_t par; 587 581 588 582 par.gap3 = 80; 589 583 par.clock = 500000; 590 584 par.track_size = 100000; 591 585 592 592 - return (pbit_encode_mfm (img, &par)); 586 586 + return (pri_encode_mfm (img, &par)); 593 587 } 594 588 595 595 - pbit_img_t *pbit_encode_mfm_hd_300 (psi_img_t *img) 589 589 + pri_img_t *pri_encode_mfm_hd_300 (psi_img_t *img) 596 590 { 597 597 - pbit_encode_mfm_t par; 591 591 + pri_encode_mfm_t par; 598 592 599 593 par.gap3 = 80; 600 594 par.clock = 1000000; 601 595 par.track_size = 200000; 602 596 603 603 - return (pbit_encode_mfm (img, &par)); 597 597 + return (pri_encode_mfm (img, &par)); 604 598 } 605 599 606 606 - pbit_img_t *pbit_encode_mfm_hd_360 (psi_img_t *img) 600 600 + pri_img_t *pri_encode_mfm_hd_360 (psi_img_t *img) 607 601 { 608 608 - pbit_encode_mfm_t par; 602 602 + pri_encode_mfm_t par; 609 603 610 604 par.gap3 = 80; 611 605 par.clock = 1000000; 612 606 par.track_size = 1000000 / 6; 613 607 614 614 - return (pbit_encode_mfm (img, &par)); 608 608 + return (pri_encode_mfm (img, &par)); 615 609 }

+13 -13

src/drivers/pbit/mfm-ibm.h src/drivers/pri/mfm-ibm.h

reviewed

··· 3 3 *****************************************************************************/ 4 4 5 5 /***************************************************************************** 6 6 - * File name: src/drivers/pbit/mfm-ibm.h * 6 6 + * File name: src/drivers/pri/mfm-ibm.h * 7 7 * Created: 2012-02-01 by Hampa Hug <hampa@hampa.ch> * 8 8 * Copyright: (C) 2012-2013 Hampa Hug <hampa@hampa.ch> * 9 9 *****************************************************************************/ ··· 20 20 *****************************************************************************/ 21 21 22 22 23 23 - #ifndef PCE_PBIT_MFM_IBM_H 24 24 - #define PCE_PBIT_MFM_IBM_H 1 23 23 + #ifndef PCE_PRI_MFM_IBM_H 24 24 + #define PCE_PRI_MFM_IBM_H 1 25 25 26 26 27 27 - #include <drivers/pbit/pbit.h> 27 27 + #include <drivers/pri/pri.h> 28 28 #include <drivers/psi/psi.h> 29 29 30 30 ··· 32 32 unsigned long clock; 33 33 unsigned long track_size; 34 34 unsigned gap3; 35 35 - } pbit_encode_mfm_t; 35 35 + } pri_encode_mfm_t; 36 36 37 37 38 38 - psi_trk_t *pbit_decode_mfm_trk (pbit_trk_t *trk, unsigned h); 39 39 - psi_img_t *pbit_decode_mfm (pbit_img_t *img); 38 38 + psi_trk_t *pri_decode_mfm_trk (pri_trk_t *trk, unsigned h); 39 39 + psi_img_t *pri_decode_mfm (pri_img_t *img); 40 40 41 41 - int pbit_encode_mfm_trk (pbit_trk_t *dtrk, psi_trk_t *strk, pbit_encode_mfm_t *par); 42 42 - int pbit_encode_mfm_img (pbit_img_t *dimg, psi_img_t *simg, pbit_encode_mfm_t *par); 43 43 - pbit_img_t *pbit_encode_mfm (psi_img_t *img, pbit_encode_mfm_t *par); 41 41 + int pri_encode_mfm_trk (pri_trk_t *dtrk, psi_trk_t *strk, pri_encode_mfm_t *par); 42 42 + int pri_encode_mfm_img (pri_img_t *dimg, psi_img_t *simg, pri_encode_mfm_t *par); 43 43 + pri_img_t *pri_encode_mfm (psi_img_t *img, pri_encode_mfm_t *par); 44 44 45 45 - pbit_img_t *pbit_encode_mfm_dd_300 (psi_img_t *img); 46 46 - pbit_img_t *pbit_encode_mfm_hd_300 (psi_img_t *img); 47 47 - pbit_img_t *pbit_encode_mfm_hd_360 (psi_img_t *img); 45 45 + pri_img_t *pri_encode_mfm_dd_300 (psi_img_t *img); 46 46 + pri_img_t *pri_encode_mfm_hd_300 (psi_img_t *img); 47 47 + pri_img_t *pri_encode_mfm_hd_360 (psi_img_t *img); 48 48 49 49 50 50 #endif

+85 -86

src/drivers/pbit/pbit-io-pbit.c src/drivers/pri/pri-img-pbit.c

reviewed

··· 3 3 *****************************************************************************/ 4 4 5 5 /***************************************************************************** 6 6 - * File name: src/drivers/pbit/pbit-io-pbit.c * 6 6 + * File name: src/drivers/pri/pri-img-pri.c * 7 7 * Created: 2012-01-31 by Hampa Hug <hampa@hampa.ch> * 8 8 - * Copyright: (C) 2012 Hampa Hug <hampa@hampa.ch> * 8 8 + * Copyright: (C) 2012-2013 Hampa Hug <hampa@hampa.ch> * 9 9 *****************************************************************************/ 10 10 11 11 /***************************************************************************** ··· 24 24 #include <stdio.h> 25 25 #include <string.h> 26 26 27 27 - #include "pbit.h" 28 28 - #include "pbit-io.h" 29 29 - #include "pbit-io-pbit.h" 27 27 + #include "pri.h" 28 28 + #include "pri-img.h" 29 29 + #include "pri-img-pbit.h" 30 30 31 31 32 32 #define PBIT_CHUNK_PBIT 0x50424954 ··· 87 87 while (size > 0) { 88 88 cnt = (size < 256) ? size : 256; 89 89 90 90 - if (pbit_read (fp, buf, cnt)) { 90 90 + if (pri_read (fp, buf, cnt)) { 91 91 return (1); 92 92 } 93 93 ··· 96 96 size -= cnt; 97 97 } 98 98 99 99 - if (pbit_read (fp, buf, 4)) { 99 99 + if (pri_read (fp, buf, 4)) { 100 100 return (1); 101 101 } 102 102 103 103 - if (pbit_get_uint32_be (buf, 0) != crc) { 104 104 - fprintf (stderr, "pbit: crc error\n"); 103 103 + if (pri_get_uint32_be (buf, 0) != crc) { 104 104 + fprintf (stderr, "pri: crc error\n"); 105 105 return (1); 106 106 } 107 107 ··· 109 109 } 110 110 111 111 static 112 112 - int pbit_load_header (FILE *fp, pbit_img_t *img, unsigned long size, unsigned long crc) 112 112 + int pbit_load_header (FILE *fp, pri_img_t *img, unsigned long size, unsigned long crc) 113 113 { 114 114 unsigned char buf[8]; 115 115 unsigned long vers; ··· 118 118 return (1); 119 119 } 120 120 121 121 - if (pbit_read (fp, buf, 8)) { 121 121 + if (pri_read (fp, buf, 8)) { 122 122 return (1); 123 123 } 124 124 125 125 crc = pbit_crc (crc, buf, 8); 126 126 127 127 - vers = pbit_get_uint32_be (buf, 0); 127 127 + vers = pri_get_uint32_be (buf, 0); 128 128 129 129 if (vers != 0) { 130 130 - fprintf (stderr, "pbit: unknown version number (%lu)\n", vers); 130 130 + fprintf (stderr, "pri: unknown version number (%lu)\n", vers); 131 131 return (1); 132 132 } 133 133 ··· 139 139 } 140 140 141 141 static 142 142 - int pbit_load_comment (FILE *fp, pbit_img_t *img, unsigned size, unsigned long crc) 142 142 + int pbit_load_comment (FILE *fp, pri_img_t *img, unsigned size, unsigned long crc) 143 143 { 144 144 unsigned i, j, k, d; 145 145 unsigned char *buf; ··· 154 154 return (1); 155 155 } 156 156 157 157 - if (pbit_read (fp, buf, size)) { 157 157 + if (pri_read (fp, buf, size)) { 158 158 free (buf); 159 159 return (1); 160 160 } ··· 218 218 219 219 c = 0x0a; 220 220 221 221 - if (pbit_img_add_comment (img, &c, 1)) { 221 221 + if (pri_img_add_comment (img, &c, 1)) { 222 222 return (1); 223 223 } 224 224 } 225 225 226 226 - if (pbit_img_add_comment (img, buf + i, j - i)) { 226 226 + if (pri_img_add_comment (img, buf + i, j - i)) { 227 227 free (buf); 228 228 return (1); 229 229 } ··· 238 238 } 239 239 240 240 static 241 241 - pbit_trk_t *pbit_load_track_header (FILE *fp, pbit_img_t *img, unsigned long size, unsigned long crc) 241 241 + pri_trk_t *pbit_load_track_header (FILE *fp, pri_img_t *img, unsigned long size, unsigned long crc) 242 242 { 243 243 unsigned char buf[20]; 244 244 unsigned long c, h, n, clock; 245 245 - pbit_trk_t *trk; 245 245 + pri_trk_t *trk; 246 246 247 247 if (size < 20) { 248 248 return (NULL); 249 249 } 250 250 251 251 - if (pbit_read (fp, buf, 20)) { 251 251 + if (pri_read (fp, buf, 20)) { 252 252 return (NULL); 253 253 } 254 254 ··· 256 256 257 257 size -= 20; 258 258 259 259 - c = pbit_get_uint32_be (buf, 0); 260 260 - h = pbit_get_uint32_be (buf, 4); 261 261 - n = pbit_get_uint32_be (buf, 8); 262 262 - clock = pbit_get_uint32_be (buf, 12); 263 263 - //flags = pbit_get_uint32_be (buf, 16); 259 259 + c = pri_get_uint32_be (buf, 0); 260 260 + h = pri_get_uint32_be (buf, 4); 261 261 + n = pri_get_uint32_be (buf, 8); 262 262 + clock = pri_get_uint32_be (buf, 12); 264 263 265 265 - trk = pbit_img_get_track (img, c, h, 1); 264 264 + trk = pri_img_get_track (img, c, h, 1); 266 265 267 266 if (trk == NULL) { 268 267 return (NULL); 269 268 } 270 269 271 271 - if (pbit_trk_set_size (trk, n)) { 270 270 + if (pri_trk_set_size (trk, n)) { 272 271 return (NULL); 273 272 } 274 273 275 275 - pbit_trk_set_clock (trk, clock); 274 274 + pri_trk_set_clock (trk, clock); 276 275 277 276 if (pbit_skip_chunk (fp, size, crc)) { 278 277 return (NULL); ··· 282 281 } 283 282 284 283 static 285 285 - int pbit_load_track_data (FILE *fp, pbit_img_t *img, pbit_trk_t *trk, unsigned long size, unsigned long crc) 284 284 + int pbit_load_track_data (FILE *fp, pri_img_t *img, pri_trk_t *trk, unsigned long size, unsigned long crc) 286 285 { 287 286 unsigned long cnt; 288 287 ··· 292 291 cnt = size; 293 292 } 294 293 295 295 - if (pbit_read (fp, trk->data, cnt)) { 294 294 + if (pri_read (fp, trk->data, cnt)) { 296 295 return (1); 297 296 } 298 297 ··· 306 305 } 307 306 308 307 static 309 309 - int pbit_load_image (FILE *fp, pbit_img_t *img) 308 308 + int pbit_load_image (FILE *fp, pri_img_t *img) 310 309 { 311 310 unsigned long type, size; 312 311 unsigned long crc; 313 313 - pbit_trk_t *trk; 312 312 + pri_trk_t *trk; 314 313 unsigned char buf[8]; 315 314 316 316 - if (pbit_read (fp, buf, 4)) { 315 315 + if (pri_read (fp, buf, 4)) { 317 316 return (0); 318 317 } 319 318 320 320 - type = pbit_get_uint32_be (buf, 0); 319 319 + type = pri_get_uint32_be (buf, 0); 321 320 322 321 if (type != PBIT_CHUNK_PBIT) { 323 322 return (1); 324 323 } 325 324 326 326 - if (pbit_read (fp, buf + 4, 4)) { 325 325 + if (pri_read (fp, buf + 4, 4)) { 327 326 return (1); 328 327 } 329 328 330 330 - size = pbit_get_uint32_be (buf, 4); 329 329 + size = pri_get_uint32_be (buf, 4); 331 330 332 331 crc = pbit_crc (0, buf, 8); 333 332 ··· 338 337 trk = NULL; 339 338 340 339 while (1) { 341 341 - if (pbit_read (fp, buf, 8)) { 340 340 + if (pri_read (fp, buf, 8)) { 342 341 return (1); 343 342 } 344 343 345 345 - type = pbit_get_uint32_be (buf, 0); 346 346 - size = pbit_get_uint32_be (buf, 4); 344 344 + type = pri_get_uint32_be (buf, 0); 345 345 + size = pri_get_uint32_be (buf, 4); 347 346 348 347 crc = pbit_crc (0, buf, 8); 349 348 ··· 385 384 return (1); 386 385 } 387 386 388 388 - pbit_img_t *pbit_load_pbit (FILE *fp) 387 387 + pri_img_t *pri_load_pbit (FILE *fp) 389 388 { 390 390 - pbit_img_t *img; 389 389 + pri_img_t *img; 391 390 392 392 - img = pbit_img_new(); 391 391 + img = pri_img_new(); 393 392 394 393 if (img == NULL) { 395 394 return (NULL); 396 395 } 397 396 398 397 if (pbit_load_image (fp, img)) { 399 399 - pbit_img_del (img); 398 398 + pri_img_del (img); 400 399 return (NULL); 401 400 } 402 401 ··· 405 404 406 405 407 406 static 408 408 - int pbit_save_header (FILE *fp, const pbit_img_t *img) 407 407 + int pbit_save_header (FILE *fp, const pri_img_t *img) 409 408 { 410 409 unsigned char buf[32]; 411 410 412 412 - pbit_set_uint32_be (buf, 0, PBIT_CHUNK_PBIT); 413 413 - pbit_set_uint32_be (buf, 4, 8); 414 414 - pbit_set_uint32_be (buf, 8, 0); 415 415 - pbit_set_uint32_be (buf, 12, 0); 416 416 - pbit_set_uint32_be (buf, 16, pbit_crc (0, buf, 16)); 411 411 + pri_set_uint32_be (buf, 0, PBIT_CHUNK_PBIT); 412 412 + pri_set_uint32_be (buf, 4, 8); 413 413 + pri_set_uint32_be (buf, 8, 0); 414 414 + pri_set_uint32_be (buf, 12, 0); 415 415 + pri_set_uint32_be (buf, 16, pbit_crc (0, buf, 16)); 417 416 418 418 - if (pbit_write (fp, buf, 20)) { 417 417 + if (pri_write (fp, buf, 20)) { 419 418 return (1); 420 419 } 421 420 ··· 423 422 } 424 423 425 424 static 426 426 - int pbit_save_end (FILE *fp, const pbit_img_t *img) 425 425 + int pbit_save_end (FILE *fp, const pri_img_t *img) 427 426 { 428 427 unsigned char buf[16]; 429 428 430 430 - pbit_set_uint32_be (buf, 0, PBIT_CHUNK_END); 431 431 - pbit_set_uint32_be (buf, 4, 0); 432 432 - pbit_set_uint32_be (buf, 8, pbit_crc (0, buf, 8)); 429 429 + pri_set_uint32_be (buf, 0, PBIT_CHUNK_END); 430 430 + pri_set_uint32_be (buf, 4, 0); 431 431 + pri_set_uint32_be (buf, 8, pbit_crc (0, buf, 8)); 433 432 434 434 - if (pbit_write (fp, buf, 12)) { 433 433 + if (pri_write (fp, buf, 12)) { 435 434 return (1); 436 435 } 437 436 ··· 439 438 } 440 439 441 440 static 442 442 - int pbit_save_comment (FILE *fp, const pbit_img_t *img) 441 441 + int pbit_save_comment (FILE *fp, const pri_img_t *img) 443 442 { 444 443 unsigned long i, j; 445 444 unsigned long crc; ··· 508 507 509 508 buf[j++] = 0x0a; 510 509 511 511 - pbit_set_uint32_be (hdr, 0, PBIT_CHUNK_TEXT); 512 512 - pbit_set_uint32_be (hdr, 4, j); 510 510 + pri_set_uint32_be (hdr, 0, PBIT_CHUNK_TEXT); 511 511 + pri_set_uint32_be (hdr, 4, j); 513 512 514 513 crc = pbit_crc (0, hdr, 8); 515 514 516 516 - if (pbit_write (fp, hdr, 8)) { 515 515 + if (pri_write (fp, hdr, 8)) { 517 516 return (1); 518 517 } 519 518 520 519 crc = pbit_crc (crc, buf, j); 521 520 522 522 - if (pbit_write (fp, buf, j)) { 521 521 + if (pri_write (fp, buf, j)) { 523 522 return (1); 524 523 } 525 524 526 526 - pbit_set_uint32_be (hdr, 0, crc); 525 525 + pri_set_uint32_be (hdr, 0, crc); 527 526 528 528 - if (pbit_write (fp, hdr, 4)) { 527 527 + if (pri_write (fp, hdr, 4)) { 529 528 return (1); 530 529 } 531 530 ··· 533 532 } 534 533 535 534 static 536 536 - int pbit_save_track (FILE *fp, const pbit_trk_t *trk, unsigned long c, unsigned long h) 535 535 + int pbit_save_track (FILE *fp, const pri_trk_t *trk, unsigned long c, unsigned long h) 537 536 { 538 537 unsigned long cnt; 539 538 unsigned char buf[32]; 540 539 unsigned long crc; 541 540 542 542 - pbit_set_uint32_be (buf, 0, PBIT_CHUNK_TRAK); 543 543 - pbit_set_uint32_be (buf, 4, 20); 544 544 - pbit_set_uint32_be (buf, 8, c); 545 545 - pbit_set_uint32_be (buf, 12, h); 546 546 - pbit_set_uint32_be (buf, 16, trk->size); 547 547 - pbit_set_uint32_be (buf, 20, trk->clock); 548 548 - pbit_set_uint32_be (buf, 24, 0); 549 549 - pbit_set_uint32_be (buf, 28, pbit_crc (0, buf, 28)); 541 541 + pri_set_uint32_be (buf, 0, PBIT_CHUNK_TRAK); 542 542 + pri_set_uint32_be (buf, 4, 20); 543 543 + pri_set_uint32_be (buf, 8, c); 544 544 + pri_set_uint32_be (buf, 12, h); 545 545 + pri_set_uint32_be (buf, 16, trk->size); 546 546 + pri_set_uint32_be (buf, 20, trk->clock); 547 547 + pri_set_uint32_be (buf, 24, 0); 548 548 + pri_set_uint32_be (buf, 28, pbit_crc (0, buf, 28)); 550 549 551 551 - if (pbit_write (fp, buf, 32)) { 550 550 + if (pri_write (fp, buf, 32)) { 552 551 return (1); 553 552 } 554 553 ··· 558 557 559 558 cnt = (trk->size + 7) / 8; 560 559 561 561 - pbit_set_uint32_be (buf, 0, PBIT_CHUNK_DATA); 562 562 - pbit_set_uint32_be (buf, 4, cnt); 560 560 + pri_set_uint32_be (buf, 0, PBIT_CHUNK_DATA); 561 561 + pri_set_uint32_be (buf, 4, cnt); 563 562 564 563 crc = pbit_crc (0, buf, 8); 565 564 566 566 - if (pbit_write (fp, buf, 8)) { 565 565 + if (pri_write (fp, buf, 8)) { 567 566 return (1); 568 567 } 569 568 570 569 crc = pbit_crc (crc, trk->data, cnt); 571 570 572 572 - if (pbit_write (fp, trk->data, cnt)) { 571 571 + if (pri_write (fp, trk->data, cnt)) { 573 572 return (1); 574 573 } 575 574 576 576 - pbit_set_uint32_be (buf, 0, crc); 575 575 + pri_set_uint32_be (buf, 0, crc); 577 576 578 578 - if (pbit_write (fp, buf, 4)) { 577 577 + if (pri_write (fp, buf, 4)) { 579 578 return (1); 580 579 } 581 580 582 581 return (0); 583 582 } 584 583 585 585 - int pbit_save_pbit (FILE *fp, const pbit_img_t *img) 584 584 + int pri_save_pbit (FILE *fp, const pri_img_t *img) 586 585 { 587 586 unsigned long c, h; 588 588 - pbit_cyl_t *cyl; 589 589 - pbit_trk_t *trk; 587 587 + pri_cyl_t *cyl; 588 588 + pri_trk_t *trk; 590 589 591 590 if (pbit_save_header (fp, img)) { 592 591 return (1); ··· 624 623 } 625 624 626 625 627 627 - int pbit_probe_pbit_fp (FILE *fp) 626 626 + int pri_probe_pbit_fp (FILE *fp) 628 627 { 629 628 unsigned char buf[4]; 630 629 631 631 - if (pbit_read (fp, buf, 4)) { 630 630 + if (pri_read (fp, buf, 4)) { 632 631 return (0); 633 632 } 634 633 635 635 - if (pbit_get_uint32_be (buf, 0) != PBIT_CHUNK_PBIT) { 634 634 + if (pri_get_uint32_be (buf, 0) != PBIT_CHUNK_PBIT) { 636 635 return (0); 637 636 } 638 637 639 638 return (1); 640 639 } 641 640 642 642 - int pbit_probe_pbit (const char *fname) 641 641 + int pri_probe_pbit (const char *fname) 643 642 { 644 643 int r; 645 644 FILE *fp; ··· 650 649 return (0); 651 650 } 652 651 653 653 - r = pbit_probe_pbit_fp (fp); 652 652 + r = pri_probe_pbit_fp (fp); 654 653 655 654 fclose (fp); 656 655

+9 -9

src/drivers/pbit/pbit-io-pbit.h src/drivers/pri/pri-img-pbit.h

reviewed

··· 3 3 *****************************************************************************/ 4 4 5 5 /***************************************************************************** 6 6 - * File name: src/drivers/pbit/pbit-io-pbit.h * 6 6 + * File name: src/drivers/pri/pri-img-pbit.h * 7 7 * Created: 2012-01-31 by Hampa Hug <hampa@hampa.ch> * 8 8 - * Copyright: (C) 2012 Hampa Hug <hampa@hampa.ch> * 8 8 + * Copyright: (C) 2012-2013 Hampa Hug <hampa@hampa.ch> * 9 9 *****************************************************************************/ 10 10 11 11 /***************************************************************************** ··· 20 20 *****************************************************************************/ 21 21 22 22 23 23 - #ifndef PCE_PBIT_IO_PBIT_H 24 24 - #define PCE_PBIT_IO_PBIT_H 1 23 23 + #ifndef PCE_PRI_IMG_PBIT_H 24 24 + #define PCE_PRI_IMG_PBIT_H 1 25 25 26 26 27 27 - #include <drivers/pbit/pbit.h> 27 27 + #include <drivers/pri/pri.h> 28 28 29 29 30 30 - pbit_img_t *pbit_load_pbit (FILE *fp); 30 30 + pri_img_t *pri_load_pbit (FILE *fp); 31 31 32 32 - int pbit_save_pbit (FILE *fp, const pbit_img_t *img); 32 32 + int pri_save_pbit (FILE *fp, const pri_img_t *img); 33 33 34 34 - int pbit_probe_pbit_fp (FILE *fp); 35 35 - int pbit_probe_pfdc (const char *fname); 34 34 + int pri_probe_pbit_fp (FILE *fp); 35 35 + int pri_probe_pfdc (const char *fname); 36 36 37 37 38 38 #endif

+30 -30

src/drivers/pbit/pbit-io-tc.c src/drivers/pri/pri-img-tc.c

reviewed

··· 3 3 *****************************************************************************/ 4 4 5 5 /***************************************************************************** 6 6 - * File name: src/drivers/pbit/pbit-io-tc.c * 6 6 + * File name: src/drivers/pri/pri-img-tc.c * 7 7 * Created: 2012-02-01 by Hampa Hug <hampa@hampa.ch> * 8 8 - * Copyright: (C) 2012 Hampa Hug <hampa@hampa.ch> * 8 8 + * Copyright: (C) 2012-2013 Hampa Hug <hampa@hampa.ch> * 9 9 *****************************************************************************/ 10 10 11 11 /***************************************************************************** ··· 24 24 #include <stdio.h> 25 25 #include <string.h> 26 26 27 27 - #include "pbit.h" 28 28 - #include "pbit-io.h" 29 29 - #include "pbit-io-tc.h" 27 27 + #include "pri.h" 28 28 + #include "pri-img.h" 29 29 + #include "pri-img-tc.h" 30 30 31 31 32 32 static 33 33 - int tc_load_header (FILE *fp, pbit_img_t *img, unsigned long *ofs, unsigned short *len, unsigned *c, unsigned *h) 33 33 + int tc_load_header (FILE *fp, pri_img_t *img, unsigned long *ofs, unsigned short *len, unsigned *c, unsigned *h) 34 34 { 35 35 unsigned i; 36 36 unsigned long val; 37 37 unsigned char buf[512]; 38 38 39 39 - if (pbit_read_ofs (fp, 0, buf, 512)) { 39 39 + if (pri_read_ofs (fp, 0, buf, 512)) { 40 40 return (1); 41 41 } 42 42 43 43 - if (pbit_get_uint16_be (buf, 0) != 0x5aa5) { 43 43 + if (pri_get_uint16_be (buf, 0) != 0x5aa5) { 44 44 return (1); 45 45 } 46 46 ··· 57 57 } 58 58 59 59 if (i > 2) { 60 60 - pbit_img_set_comment (img, buf + 2, i - 2); 60 60 + pri_img_set_comment (img, buf + 2, i - 2); 61 61 } 62 62 63 63 - if (pbit_read_ofs (fp, 0x0305, buf, 512)) { 63 63 + if (pri_read_ofs (fp, 0x0305, buf, 512)) { 64 64 return (1); 65 65 } 66 66 67 67 for (i = 0; i < 256; i++) { 68 68 - val = pbit_get_uint16_be (buf, 2 * i); 68 68 + val = pri_get_uint16_be (buf, 2 * i); 69 69 70 70 ofs[i] = val << 8; 71 71 } 72 72 73 73 - if (pbit_read_ofs (fp, 0x0505, buf, 512)) { 73 73 + if (pri_read_ofs (fp, 0x0505, buf, 512)) { 74 74 return (1); 75 75 } 76 76 77 77 for (i = 0; i < 256; i++) { 78 78 - val = pbit_get_uint16_le (buf, 2 * i); 78 78 + val = pri_get_uint16_le (buf, 2 * i); 79 79 80 80 len[i] = val; 81 81 } ··· 84 84 } 85 85 86 86 static 87 87 - int tc_load_track (FILE *fp, pbit_img_t *img, unsigned long c, unsigned long h, unsigned long ofs, unsigned len) 87 87 + int tc_load_track (FILE *fp, pri_img_t *img, unsigned long c, unsigned long h, unsigned long ofs, unsigned len) 88 88 { 89 89 unsigned long cnt; 90 90 - pbit_trk_t *trk; 90 90 + pri_trk_t *trk; 91 91 92 92 - trk = pbit_img_get_track (img, c, h, 1); 92 92 + trk = pri_img_get_track (img, c, h, 1); 93 93 94 94 if (trk == NULL) { 95 95 return (1); 96 96 } 97 97 98 98 - if (pbit_trk_set_size (trk, 8UL * len)) { 98 98 + if (pri_trk_set_size (trk, 8UL * len)) { 99 99 return (1); 100 100 } 101 101 102 102 - pbit_trk_set_clock (trk, (len < 8000) ? 250000 : 500000); 102 102 + pri_trk_set_clock (trk, (len < 8000) ? 250000 : 500000); 103 103 104 104 cnt = (trk->size + 7) / 8; 105 105 106 106 - if (pbit_read_ofs (fp, ofs, trk->data, cnt)) { 106 106 + if (pri_read_ofs (fp, ofs, trk->data, cnt)) { 107 107 return (1); 108 108 } 109 109 110 110 return (0); 111 111 } 112 112 113 113 - pbit_img_t *pbit_load_tc (FILE *fp) 113 113 + pri_img_t *pri_load_tc (FILE *fp) 114 114 { 115 115 unsigned c, h, nc, nh, t; 116 116 unsigned long ofs[256]; 117 117 unsigned short len[256]; 118 118 - pbit_img_t *img; 118 118 + pri_img_t *img; 119 119 120 120 - img = pbit_img_new(); 120 120 + img = pri_img_new(); 121 121 122 122 if (img == NULL) { 123 123 return (NULL); 124 124 } 125 125 126 126 if (tc_load_header (fp, img, ofs, len, &nc, &nh)) { 127 127 - pbit_img_del (img); 127 127 + pri_img_del (img); 128 128 return (NULL); 129 129 } 130 130 131 131 if ((nc > 99) || (nh > 2)) { 132 132 - pbit_img_del (img); 132 132 + pri_img_del (img); 133 133 return (NULL); 134 134 } 135 135 ··· 138 138 139 139 for (h = 0; h < nh; h++) { 140 140 if (t > 255) { 141 141 - pbit_img_del (img); 141 141 + pri_img_del (img); 142 142 return (NULL); 143 143 } 144 144 ··· 148 148 } 149 149 150 150 if (tc_load_track (fp, img, c, h, ofs[t], len[t])) { 151 151 - pbit_img_del (img); 151 151 + pri_img_del (img); 152 152 return (NULL); 153 153 } 154 154 ··· 160 160 } 161 161 162 162 163 163 - int pbit_save_tc (FILE *fp, const pbit_img_t *img) 163 163 + int pri_save_tc (FILE *fp, const pri_img_t *img) 164 164 { 165 165 return (1); 166 166 } 167 167 168 168 169 169 - int pbit_probe_tc_fp (FILE *fp) 169 169 + int pri_probe_tc_fp (FILE *fp) 170 170 { 171 171 return (0); 172 172 } 173 173 174 174 - int pbit_probe_tc (const char *fname) 174 174 + int pri_probe_tc (const char *fname) 175 175 { 176 176 int r; 177 177 FILE *fp; ··· 182 182 return (0); 183 183 } 184 184 185 185 - r = pbit_probe_tc_fp (fp); 185 185 + r = pri_probe_tc_fp (fp); 186 186 187 187 fclose (fp); 188 188

+9 -9

src/drivers/pbit/pbit-io-tc.h src/drivers/pri/pri-img-tc.h

reviewed

··· 3 3 *****************************************************************************/ 4 4 5 5 /***************************************************************************** 6 6 - * File name: src/drivers/pbit/pbit-io-tc.h * 6 6 + * File name: src/drivers/pri/pri-img-tc.h * 7 7 * Created: 2012-02-01 by Hampa Hug <hampa@hampa.ch> * 8 8 - * Copyright: (C) 2012 Hampa Hug <hampa@hampa.ch> * 8 8 + * Copyright: (C) 2012-2013 Hampa Hug <hampa@hampa.ch> * 9 9 *****************************************************************************/ 10 10 11 11 /***************************************************************************** ··· 20 20 *****************************************************************************/ 21 21 22 22 23 23 - #ifndef PCE_PBIT_IO_TC_H 24 24 - #define PCE_PBIT_IO_TC_H 1 23 23 + #ifndef PCE_PRI_IMG_TC_H 24 24 + #define PCE_PRI_IMG_TC_H 1 25 25 26 26 27 27 - #include <drivers/pbit/pbit.h> 27 27 + #include <drivers/pri/pri.h> 28 28 29 29 30 30 - pbit_img_t *pbit_load_tc (FILE *fp); 30 30 + pri_img_t *pri_load_tc (FILE *fp); 31 31 32 32 - int pbit_save_tc (FILE *fp, const pbit_img_t *img); 32 32 + int pri_save_tc (FILE *fp, const pri_img_t *img); 33 33 34 34 - int pbit_probe_tc_fp (FILE *fp); 35 35 - int pbit_probe_tc (const char *fname); 34 34 + int pri_probe_tc_fp (FILE *fp); 35 35 + int pri_probe_tc (const char *fname); 36 36 37 37 38 38 #endif

+44 -48

src/drivers/pbit/pbit-io.c src/drivers/pri/pri-img.c

reviewed

··· 3 3 *****************************************************************************/ 4 4 5 5 /***************************************************************************** 6 6 - * File name: src/drivers/pbit/pbit-io.c * 6 6 + * File name: src/drivers/pri/pri-io.c * 7 7 * Created: 2012-01-31 by Hampa Hug <hampa@hampa.ch> * 8 8 - * Copyright: (C) 2012 Hampa Hug <hampa@hampa.ch> * 8 8 + * Copyright: (C) 2012-2013 Hampa Hug <hampa@hampa.ch> * 9 9 *****************************************************************************/ 10 10 11 11 /***************************************************************************** ··· 24 24 #include <stdio.h> 25 25 #include <string.h> 26 26 27 27 - #include "pbit-io.h" 28 28 - #include "pbit-io-pbit.h" 29 29 - #include "pbit-io-tc.h" 27 27 + #include "pri-img.h" 28 28 + #include "pri-img-pbit.h" 29 29 + #include "pri-img-tc.h" 30 30 31 31 32 32 - unsigned pbit_get_uint16_be (const void *buf, unsigned idx) 32 32 + unsigned pri_get_uint16_be (const void *buf, unsigned idx) 33 33 { 34 34 unsigned val; 35 35 const unsigned char *tmp; ··· 42 42 return (val); 43 43 } 44 44 45 45 - unsigned pbit_get_uint16_le (const void *buf, unsigned idx) 45 45 + unsigned pri_get_uint16_le (const void *buf, unsigned idx) 46 46 { 47 47 unsigned val; 48 48 const unsigned char *tmp; ··· 55 55 return (val); 56 56 } 57 57 58 58 - unsigned long pbit_get_uint32_be (const void *buf, unsigned idx) 58 58 + unsigned long pri_get_uint32_be (const void *buf, unsigned idx) 59 59 { 60 60 unsigned long val; 61 61 const unsigned char *tmp; ··· 70 70 return (val); 71 71 } 72 72 73 73 - unsigned long pbit_get_uint32_le (const void *buf, unsigned idx) 73 73 + unsigned long pri_get_uint32_le (const void *buf, unsigned idx) 74 74 { 75 75 unsigned long val; 76 76 const unsigned char *tmp; ··· 85 85 return (val); 86 86 } 87 87 88 88 - void pbit_set_uint16_be (void *buf, unsigned idx, unsigned val) 88 88 + void pri_set_uint16_be (void *buf, unsigned idx, unsigned val) 89 89 { 90 90 unsigned char *tmp; 91 91 ··· 95 95 tmp[1] = val & 0xff; 96 96 } 97 97 98 98 - void pbit_set_uint16_le (void *buf, unsigned idx, unsigned val) 98 98 + void pri_set_uint16_le (void *buf, unsigned idx, unsigned val) 99 99 { 100 100 unsigned char *tmp; 101 101 ··· 105 105 tmp[1] = (val >> 8) & 0xff; 106 106 } 107 107 108 108 - void pbit_set_uint32_be (void *buf, unsigned idx, unsigned long val) 108 108 + void pri_set_uint32_be (void *buf, unsigned idx, unsigned long val) 109 109 { 110 110 unsigned char *tmp; 111 111 ··· 117 117 tmp[3] = val & 0xff; 118 118 } 119 119 120 120 - void pbit_set_uint32_le (void *buf, unsigned idx, unsigned long val) 120 120 + void pri_set_uint32_le (void *buf, unsigned idx, unsigned long val) 121 121 { 122 122 unsigned char *tmp; 123 123 ··· 130 130 } 131 131 132 132 133 133 - int pbit_read (FILE *fp, void *buf, unsigned long cnt) 133 133 + int pri_read (FILE *fp, void *buf, unsigned long cnt) 134 134 { 135 135 if (fread (buf, 1, cnt, fp) != cnt) { 136 136 return (1); ··· 139 139 return (0); 140 140 } 141 141 142 142 - int pbit_read_ofs (FILE *fp, unsigned long ofs, void *buf, unsigned long cnt) 142 142 + int pri_read_ofs (FILE *fp, unsigned long ofs, void *buf, unsigned long cnt) 143 143 { 144 144 if (fseek (fp, ofs, SEEK_SET)) { 145 145 return (1); ··· 152 152 return (0); 153 153 } 154 154 155 155 - int pbit_write (FILE *fp, const void *buf, unsigned long cnt) 155 155 + int pri_write (FILE *fp, const void *buf, unsigned long cnt) 156 156 { 157 157 if (fwrite (buf, 1, cnt, fp) != cnt) { 158 158 return (1); ··· 161 161 return (0); 162 162 } 163 163 164 164 - int pbit_skip (FILE *fp, unsigned long cnt) 164 164 + int pri_skip (FILE *fp, unsigned long cnt) 165 165 { 166 166 unsigned long n; 167 167 unsigned char buf[256]; ··· 169 169 while (cnt > 0) { 170 170 n = (cnt < 256) ? cnt : 256; 171 171 172 172 - if (pbit_read (fp, buf, n)) { 172 172 + if (pri_read (fp, buf, n)) { 173 173 return (1); 174 174 } 175 175 ··· 181 181 182 182 183 183 static 184 184 - unsigned pbit_get_type (unsigned type, const char *fname) 184 184 + unsigned pri_get_type (unsigned type, const char *fname) 185 185 { 186 186 unsigned i; 187 187 const char *ext; 188 188 189 189 - if (type != PBIT_FORMAT_NONE) { 189 189 + if (type != PRI_FORMAT_NONE) { 190 190 return (type); 191 191 } 192 192 ··· 202 202 } 203 203 204 204 if (strcasecmp (ext, ".pbit") == 0) { 205 205 - return (PBIT_FORMAT_PBIT); 205 205 + return (PRI_FORMAT_PBIT); 206 206 } 207 207 else if (strcasecmp (ext, ".tc") == 0) { 208 208 - return (PBIT_FORMAT_TC); 208 208 + return (PRI_FORMAT_TC); 209 209 } 210 210 211 211 - return (PBIT_FORMAT_PBIT); 211 211 + return (PRI_FORMAT_PBIT); 212 212 } 213 213 214 214 215 215 - pbit_img_t *pbit_img_load_fp (FILE *fp, unsigned type) 215 215 + pri_img_t *pri_img_load_fp (FILE *fp, unsigned type) 216 216 { 217 217 - pbit_img_t *img; 217 217 + pri_img_t *img; 218 218 219 219 img = NULL; 220 220 221 221 switch (type) { 222 222 - case PBIT_FORMAT_PBIT: 223 223 - img = pbit_load_pbit (fp); 222 222 + case PRI_FORMAT_PBIT: 223 223 + img = pri_load_pbit (fp); 224 224 break; 225 225 226 226 - case PBIT_FORMAT_TC: 227 227 - img = pbit_load_tc (fp); 226 226 + case PRI_FORMAT_TC: 227 227 + img = pri_load_tc (fp); 228 228 break; 229 229 } 230 230 231 231 return (img); 232 232 } 233 233 234 234 - pbit_img_t *pbit_img_load (const char *fname, unsigned type) 234 234 + pri_img_t *pri_img_load (const char *fname, unsigned type) 235 235 { 236 236 - FILE *fp; 237 237 - pbit_img_t *img; 236 236 + FILE *fp; 237 237 + pri_img_t *img; 238 238 239 239 - type = pbit_get_type (type, fname); 239 239 + type = pri_get_type (type, fname); 240 240 241 241 - fp = fopen (fname, "rb"); 242 242 - 243 243 - if (fp == NULL) { 241 241 + if ((fp = fopen (fname, "rb")) == NULL) { 244 242 return (NULL); 245 243 } 246 244 247 247 - img = pbit_img_load_fp (fp, type); 245 245 + img = pri_img_load_fp (fp, type); 248 246 249 247 fclose (fp); 250 248 251 249 return (img); 252 250 } 253 251 254 254 - int pbit_img_save_fp (FILE *fp, const pbit_img_t *img, unsigned type) 252 252 + int pri_img_save_fp (FILE *fp, const pri_img_t *img, unsigned type) 255 253 { 256 254 switch (type) { 257 257 - case PBIT_FORMAT_PBIT: 258 258 - return (pbit_save_pbit (fp, img)); 255 255 + case PRI_FORMAT_PBIT: 256 256 + return (pri_save_pbit (fp, img)); 259 257 260 260 - case PBIT_FORMAT_TC: 261 261 - return (pbit_save_tc (fp, img)); 258 258 + case PRI_FORMAT_TC: 259 259 + return (pri_save_tc (fp, img)); 262 260 } 263 261 264 262 return (1); 265 263 } 266 264 267 267 - int pbit_img_save (const char *fname, const pbit_img_t *img, unsigned type) 265 265 + int pri_img_save (const char *fname, const pri_img_t *img, unsigned type) 268 266 { 269 267 int r; 270 268 FILE *fp; 271 269 272 272 - type = pbit_get_type (type, fname); 270 270 + type = pri_get_type (type, fname); 273 271 274 274 - fp = fopen (fname, "wb"); 275 275 - 276 276 - if (fp == NULL) { 272 272 + if ((fp = fopen (fname, "wb")) == NULL) { 277 273 return (1); 278 274 } 279 275 280 280 - r = pbit_img_save_fp (fp, img, type); 276 276 + r = pri_img_save_fp (fp, img, type); 281 277 282 278 fclose (fp); 283 279

-61

src/drivers/pbit/pbit-io.h

reviewed

··· 1 1 - /***************************************************************************** 2 2 - * pce * 3 3 - *****************************************************************************/ 4 4 - 5 5 - /***************************************************************************** 6 6 - * File name: src/drivers/pbit/pbit-io.h * 7 7 - * Created: 2012-01-31 by Hampa Hug <hampa@hampa.ch> * 8 8 - * Copyright: (C) 2012 Hampa Hug <hampa@hampa.ch> * 9 9 - *****************************************************************************/ 10 10 - 11 11 - /***************************************************************************** 12 12 - * This program is free software. You can redistribute it and / or modify it * 13 13 - * under the terms of the GNU General Public License version 2 as published * 14 14 - * by the Free Software Foundation. * 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 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 23 - #ifndef PCE_PBIT_IO_H 24 24 - #define PCE_PBIT_IO_H 1 25 25 - 26 26 - 27 27 - #include <drivers/pbit/pbit.h> 28 28 - 29 29 - 30 30 - #define PBIT_FORMAT_NONE 0 31 31 - #define PBIT_FORMAT_PBIT 1 32 32 - #define PBIT_FORMAT_TC 2 33 33 - 34 34 - 35 35 - unsigned pbit_get_uint16_be (const void *buf, unsigned idx); 36 36 - unsigned pbit_get_uint16_le (const void *buf, unsigned idx); 37 37 - 38 38 - unsigned long pbit_get_uint32_be (const void *buf, unsigned idx); 39 39 - unsigned long pbit_get_uint32_le (const void *buf, unsigned idx); 40 40 - 41 41 - void pbit_set_uint16_be (void *buf, unsigned idx, unsigned val); 42 42 - void pbit_set_uint16_le (void *buf, unsigned idx, unsigned val); 43 43 - 44 44 - void pbit_set_uint32_be (void *buf, unsigned idx, unsigned long val); 45 45 - void pbit_set_uint32_le (void *buf, unsigned idx, unsigned long val); 46 46 - 47 47 - 48 48 - int pbit_read (FILE *fp, void *buf, unsigned long cnt); 49 49 - int pbit_read_ofs (FILE *fp, unsigned long ofs, void *buf, unsigned long cnt); 50 50 - int pbit_write (FILE *fp, const void *buf, unsigned long cnt); 51 51 - int pbit_skip (FILE *fp, unsigned long cnt); 52 52 - 53 53 - 54 54 - pbit_img_t *pbit_img_load_fp (FILE *fp, unsigned type); 55 55 - pbit_img_t *pbit_img_load (const char *fname, unsigned type); 56 56 - 57 57 - int pbit_img_save_fp (FILE *fp, const pbit_img_t *img, unsigned type); 58 58 - int pbit_img_save (const char *fname, const pbit_img_t *img, unsigned type); 59 59 - 60 60 - 61 61 - #endif

+83 -83

src/drivers/pbit/pbit.c src/drivers/pri/pri.c

reviewed

··· 3 3 *****************************************************************************/ 4 4 5 5 /***************************************************************************** 6 6 - * File name: src/drivers/pbit/pbit.c * 6 6 + * File name: src/drivers/pri/pri.c * 7 7 * Created: 2012-01-31 by Hampa Hug <hampa@hampa.ch> * 8 8 * Copyright: (C) 2012-2013 Hampa Hug <hampa@hampa.ch> * 9 9 *****************************************************************************/ ··· 24 24 #include <stdio.h> 25 25 #include <string.h> 26 26 27 27 - #include "pbit.h" 27 27 + #include "pri.h" 28 28 29 29 30 30 /***************************************************************************** 31 31 * Clear all bits in the range i1 < i <= i2 in buf 32 32 *****************************************************************************/ 33 33 static 34 34 - void pbit_clear_bits (unsigned char *buf, unsigned long i1, unsigned long i2) 34 34 + void pri_clear_bits (unsigned char *buf, unsigned long i1, unsigned long i2) 35 35 { 36 36 unsigned char m1, m2; 37 37 ··· 67 67 * 68 68 * @return The new track or NULL on error 69 69 *****************************************************************************/ 70 70 - pbit_trk_t *pbit_trk_new (unsigned long size, unsigned long clock) 70 70 + pri_trk_t *pri_trk_new (unsigned long size, unsigned long clock) 71 71 { 72 72 - pbit_trk_t *trk; 72 72 + pri_trk_t *trk; 73 73 74 74 - trk = malloc (sizeof (pbit_trk_t)); 74 74 + trk = malloc (sizeof (pri_trk_t)); 75 75 76 76 if (trk == NULL) { 77 77 return (NULL); ··· 99 99 /***************************************************************************** 100 100 * Delete a track 101 101 *****************************************************************************/ 102 102 - void pbit_trk_del (pbit_trk_t *trk) 102 102 + void pri_trk_del (pri_trk_t *trk) 103 103 { 104 104 if (trk != NULL) { 105 105 free (trk->data); ··· 110 110 /***************************************************************************** 111 111 * Create an exact copy of a track 112 112 *****************************************************************************/ 113 113 - pbit_trk_t *pbit_trk_clone (const pbit_trk_t *trk) 113 113 + pri_trk_t *pri_trk_clone (const pri_trk_t *trk) 114 114 { 115 115 - pbit_trk_t *ret; 115 115 + pri_trk_t *ret; 116 116 117 117 - ret = pbit_trk_new (trk->size, trk->clock); 117 117 + ret = pri_trk_new (trk->size, trk->clock); 118 118 119 119 if (ret == NULL) { 120 120 return (NULL); ··· 135 135 * 136 136 * @param val An 8 bit value that is used to initialize the track 137 137 *****************************************************************************/ 138 138 - void pbit_trk_clear (pbit_trk_t *trk, unsigned val) 138 138 + void pri_trk_clear (pri_trk_t *trk, unsigned val) 139 139 { 140 140 if (trk->size > 0) { 141 141 memset (trk->data, val, (trk->size + 7) / 8); 142 142 - pbit_clear_bits (trk->data, trk->size, (trk->size - 1) | 7); 142 142 + pri_clear_bits (trk->data, trk->size, (trk->size - 1) | 7); 143 143 } 144 144 } 145 145 ··· 148 148 * 149 149 * @param val A 16 bit value that is used to initialize the track 150 150 *****************************************************************************/ 151 151 - void pbit_trk_clear_16 (pbit_trk_t *trk, unsigned val) 151 151 + void pri_trk_clear_16 (pri_trk_t *trk, unsigned val) 152 152 { 153 153 unsigned long i, n; 154 154 unsigned char buf[2]; ··· 166 166 trk->data[i] = buf[i & 1]; 167 167 } 168 168 169 169 - pbit_clear_bits (trk->data, trk->size, (trk->size - 1) | 7); 169 169 + pri_clear_bits (trk->data, trk->size, (trk->size - 1) | 7); 170 170 } 171 171 172 172 /***************************************************************************** ··· 174 174 * 175 175 * @param clock The bit rate in Herz 176 176 *****************************************************************************/ 177 177 - void pbit_trk_set_clock (pbit_trk_t *trk, unsigned long clock) 177 177 + void pri_trk_set_clock (pri_trk_t *trk, unsigned long clock) 178 178 { 179 179 trk->clock = clock; 180 180 } ··· 184 184 * 185 185 * @return The bit rate in Herz 186 186 *****************************************************************************/ 187 187 - unsigned long pbit_trk_get_clock (const pbit_trk_t *trk) 187 187 + unsigned long pri_trk_get_clock (const pri_trk_t *trk) 188 188 { 189 189 return (trk->clock); 190 190 } ··· 194 194 * 195 195 * @return The track size in bits 196 196 *****************************************************************************/ 197 197 - unsigned long pbit_trk_get_size (const pbit_trk_t *trk) 197 197 + unsigned long pri_trk_get_size (const pri_trk_t *trk) 198 198 { 199 199 return (trk->size); 200 200 } ··· 207 207 * If the new size is greater than the old size, the new bits are 208 208 * initialized to 0. 209 209 *****************************************************************************/ 210 210 - int pbit_trk_set_size (pbit_trk_t *trk, unsigned long size) 210 210 + int pri_trk_set_size (pri_trk_t *trk, unsigned long size) 211 211 { 212 212 unsigned long i1; 213 213 unsigned char *tmp; ··· 234 234 235 235 if (size > 0) { 236 236 i1 = (size < trk->size) ? size : trk->size; 237 237 - pbit_clear_bits (tmp, i1, (size - 1) | 7); 237 237 + pri_clear_bits (tmp, i1, (size - 1) | 7); 238 238 } 239 239 240 240 trk->size = size; ··· 248 248 * 249 249 * @param pos The new track position in bits 250 250 *****************************************************************************/ 251 251 - void pbit_trk_set_pos (pbit_trk_t *trk, unsigned long pos) 251 251 + void pri_trk_set_pos (pri_trk_t *trk, unsigned long pos) 252 252 { 253 253 if (trk->size > 0) { 254 254 trk->idx = pos % trk->size; ··· 264 264 * 265 265 * @return Non-zero if the current position wrapped around 266 266 *****************************************************************************/ 267 267 - int pbit_trk_get_bits (pbit_trk_t *trk, unsigned long *val, unsigned cnt) 267 267 + int pri_trk_get_bits (pri_trk_t *trk, unsigned long *val, unsigned cnt) 268 268 { 269 269 unsigned long v; 270 270 unsigned char m; ··· 307 307 * 308 308 * @return Non-zero if the current position wrapped around 309 309 *****************************************************************************/ 310 310 - int pbit_trk_set_bits (pbit_trk_t *trk, unsigned long val, unsigned cnt) 310 310 + int pri_trk_set_bits (pri_trk_t *trk, unsigned long val, unsigned cnt) 311 311 { 312 312 unsigned char m; 313 313 unsigned char *p; ··· 343 343 return (trk->wrap); 344 344 } 345 345 346 346 - int pbit_trk_rotate (pbit_trk_t *trk, unsigned long idx) 346 346 + int pri_trk_rotate (pri_trk_t *trk, unsigned long idx) 347 347 { 348 348 unsigned long i; 349 349 unsigned char dm, sm; ··· 408 408 } 409 409 410 410 411 411 - pbit_cyl_t *pbit_cyl_new (void) 411 411 + pri_cyl_t *pri_cyl_new (void) 412 412 { 413 413 - pbit_cyl_t *cyl; 413 413 + pri_cyl_t *cyl; 414 414 415 415 - cyl = malloc (sizeof (pbit_cyl_t)); 415 415 + cyl = malloc (sizeof (pri_cyl_t)); 416 416 417 417 if (cyl == NULL) { 418 418 return (NULL); ··· 424 424 return (cyl); 425 425 } 426 426 427 427 - void pbit_cyl_del (pbit_cyl_t *cyl) 427 427 + void pri_cyl_del (pri_cyl_t *cyl) 428 428 { 429 429 unsigned long i; 430 430 431 431 if (cyl != NULL) { 432 432 for (i = 0; i < cyl->trk_cnt; i++) { 433 433 - pbit_trk_del (cyl->trk[i]); 433 433 + pri_trk_del (cyl->trk[i]); 434 434 } 435 435 436 436 free (cyl->trk); ··· 438 438 } 439 439 } 440 440 441 441 - unsigned long pbit_cyl_get_trk_cnt (const pbit_cyl_t *cyl) 441 441 + unsigned long pri_cyl_get_trk_cnt (const pri_cyl_t *cyl) 442 442 { 443 443 return (cyl->trk_cnt); 444 444 } 445 445 446 446 - pbit_trk_t *pbit_cyl_get_track (pbit_cyl_t *cyl, unsigned long h, int alloc) 446 446 + pri_trk_t *pri_cyl_get_track (pri_cyl_t *cyl, unsigned long h, int alloc) 447 447 { 448 448 - pbit_trk_t *trk; 448 448 + pri_trk_t *trk; 449 449 450 450 if ((h < cyl->trk_cnt) && (cyl->trk[h] != NULL)) { 451 451 return (cyl->trk[h]); ··· 455 455 return (NULL); 456 456 } 457 457 458 458 - trk = pbit_trk_new (0, 0); 458 458 + trk = pri_trk_new (0, 0); 459 459 460 460 if (trk == NULL) { 461 461 return (NULL); 462 462 } 463 463 464 464 - if (pbit_cyl_set_track (cyl, trk, h)) { 465 465 - pbit_trk_del (trk); 464 464 + if (pri_cyl_set_track (cyl, trk, h)) { 465 465 + pri_trk_del (trk); 466 466 return (NULL); 467 467 } 468 468 469 469 return (trk); 470 470 } 471 471 472 472 - int pbit_cyl_set_track (pbit_cyl_t *cyl, pbit_trk_t *trk, unsigned long h) 472 472 + int pri_cyl_set_track (pri_cyl_t *cyl, pri_trk_t *trk, unsigned long h) 473 473 { 474 474 unsigned long i; 475 475 - pbit_trk_t **tmp; 475 475 + pri_trk_t **tmp; 476 476 477 477 if (h < cyl->trk_cnt) { 478 478 - pbit_trk_del (cyl->trk[h]); 478 478 + pri_trk_del (cyl->trk[h]); 479 479 480 480 cyl->trk[h] = trk; 481 481 482 482 return (0); 483 483 } 484 484 485 485 - tmp = realloc (cyl->trk, (h + 1) * sizeof (pbit_trk_t *)); 485 485 + tmp = realloc (cyl->trk, (h + 1) * sizeof (pri_trk_t *)); 486 486 487 487 if (tmp == NULL) { 488 488 return (1); ··· 500 500 return (0); 501 501 } 502 502 503 503 - int pbit_cyl_add_track (pbit_cyl_t *cyl, pbit_trk_t *trk) 503 503 + int pri_cyl_add_track (pri_cyl_t *cyl, pri_trk_t *trk) 504 504 { 505 505 - return (pbit_cyl_set_track (cyl, trk, cyl->trk_cnt)); 505 505 + return (pri_cyl_set_track (cyl, trk, cyl->trk_cnt)); 506 506 } 507 507 508 508 - int pbit_cyl_del_track (pbit_cyl_t *cyl, unsigned long h) 508 508 + int pri_cyl_del_track (pri_cyl_t *cyl, unsigned long h) 509 509 { 510 510 if ((h >= cyl->trk_cnt) || (cyl->trk[h] == NULL)) { 511 511 return (1); 512 512 } 513 513 514 514 - pbit_trk_del (cyl->trk[h]); 514 514 + pri_trk_del (cyl->trk[h]); 515 515 516 516 cyl->trk[h] = NULL; 517 517 ··· 523 523 } 524 524 525 525 526 526 - pbit_img_t *pbit_img_new (void) 526 526 + pri_img_t *pri_img_new (void) 527 527 { 528 528 - pbit_img_t *img; 528 528 + pri_img_t *img; 529 529 530 530 - img = malloc (sizeof (pbit_img_t)); 530 530 + img = malloc (sizeof (pri_img_t)); 531 531 532 532 if (img == NULL) { 533 533 return (NULL); ··· 542 542 return (img); 543 543 } 544 544 545 545 - void pbit_img_del (pbit_img_t *img) 545 545 + void pri_img_del (pri_img_t *img) 546 546 { 547 547 unsigned long i; 548 548 549 549 if (img != NULL) { 550 550 for (i = 0; i < img->cyl_cnt; i++) { 551 551 - pbit_cyl_del (img->cyl[i]); 551 551 + pri_cyl_del (img->cyl[i]); 552 552 } 553 553 554 554 free (img->comment); ··· 557 557 } 558 558 } 559 559 560 560 - unsigned long pbit_img_get_cyl_cnt (const pbit_img_t *img) 560 560 + unsigned long pri_img_get_cyl_cnt (const pri_img_t *img) 561 561 { 562 562 return (img->cyl_cnt); 563 563 } 564 564 565 565 - unsigned long pbit_img_get_trk_cnt (const pbit_img_t *img, unsigned long c) 565 565 + unsigned long pri_img_get_trk_cnt (const pri_img_t *img, unsigned long c) 566 566 { 567 567 if ((c >= img->cyl_cnt) || (img->cyl[c] == NULL)) { 568 568 return (0); ··· 572 572 } 573 573 574 574 static 575 575 - void pbit_img_fix_cyl (pbit_img_t *img) 575 575 + void pri_img_fix_cyl (pri_img_t *img) 576 576 { 577 577 while ((img->cyl_cnt > 0) && (img->cyl[img->cyl_cnt - 1] == NULL)) { 578 578 img->cyl_cnt -= 1; 579 579 } 580 580 } 581 581 582 582 - pbit_cyl_t *pbit_img_get_cylinder (pbit_img_t *img, unsigned long c, int alloc) 582 582 + pri_cyl_t *pri_img_get_cylinder (pri_img_t *img, unsigned long c, int alloc) 583 583 { 584 584 - pbit_cyl_t *cyl; 584 584 + pri_cyl_t *cyl; 585 585 586 586 if ((c < img->cyl_cnt) && (img->cyl[c] != NULL)) { 587 587 return (img->cyl[c]); ··· 591 591 return (NULL); 592 592 } 593 593 594 594 - cyl = pbit_cyl_new(); 594 594 + cyl = pri_cyl_new(); 595 595 596 596 if (cyl == NULL) { 597 597 return (NULL); 598 598 } 599 599 600 600 - if (pbit_img_set_cylinder (img, cyl, img->cyl_cnt)) { 601 601 - pbit_cyl_del (cyl); 600 600 + if (pri_img_set_cylinder (img, cyl, c)) { 601 601 + pri_cyl_del (cyl); 602 602 return (NULL); 603 603 } 604 604 605 605 return (cyl); 606 606 } 607 607 608 608 - pbit_cyl_t *pbit_img_rmv_cylinder (pbit_img_t *img, unsigned long c) 608 608 + pri_cyl_t *pri_img_rmv_cylinder (pri_img_t *img, unsigned long c) 609 609 { 610 610 - pbit_cyl_t *cyl; 610 610 + pri_cyl_t *cyl; 611 611 612 612 if ((c >= img->cyl_cnt) || (img->cyl[c] == NULL)) { 613 613 return (NULL); ··· 617 617 618 618 img->cyl[c] = NULL; 619 619 620 620 - pbit_img_fix_cyl (img); 620 620 + pri_img_fix_cyl (img); 621 621 622 622 return (cyl); 623 623 } 624 624 625 625 - int pbit_img_set_cylinder (pbit_img_t *img, pbit_cyl_t *cyl, unsigned long c) 625 625 + int pri_img_set_cylinder (pri_img_t *img, pri_cyl_t *cyl, unsigned long c) 626 626 { 627 627 unsigned long i; 628 628 - pbit_cyl_t **tmp; 628 628 + pri_cyl_t **tmp; 629 629 630 630 if (c < img->cyl_cnt) { 631 631 - pbit_cyl_del (img->cyl[c]); 631 631 + pri_cyl_del (img->cyl[c]); 632 632 img->cyl[c] = cyl; 633 633 - pbit_img_fix_cyl (img); 633 633 + pri_img_fix_cyl (img); 634 634 635 635 return (0); 636 636 } 637 637 638 638 - tmp = realloc (img->cyl, (c + 1) * sizeof (pbit_cyl_t *)); 638 638 + tmp = realloc (img->cyl, (c + 1) * sizeof (pri_cyl_t *)); 639 639 640 640 if (tmp == NULL) { 641 641 return (1); ··· 650 650 img->cyl = tmp; 651 651 img->cyl_cnt = c + 1; 652 652 653 653 - pbit_img_fix_cyl (img); 653 653 + pri_img_fix_cyl (img); 654 654 655 655 return (0); 656 656 } 657 657 658 658 - int pbit_img_add_cylinder (pbit_img_t *img, pbit_cyl_t *cyl) 658 658 + int pri_img_add_cylinder (pri_img_t *img, pri_cyl_t *cyl) 659 659 { 660 660 - return (pbit_img_set_cylinder (img, cyl, img->cyl_cnt)); 660 660 + return (pri_img_set_cylinder (img, cyl, img->cyl_cnt)); 661 661 } 662 662 663 663 - int pbit_img_del_cylinder (pbit_img_t *img, unsigned long c) 663 663 + int pri_img_del_cylinder (pri_img_t *img, unsigned long c) 664 664 { 665 665 if ((c >= img->cyl_cnt) || (img->cyl[c] == NULL)) { 666 666 return (1); 667 667 } 668 668 669 669 - pbit_cyl_del (img->cyl[c]); 669 669 + pri_cyl_del (img->cyl[c]); 670 670 671 671 img->cyl[c] = NULL; 672 672 673 673 - pbit_img_fix_cyl (img); 673 673 + pri_img_fix_cyl (img); 674 674 675 675 return (0); 676 676 } 677 677 678 678 - pbit_trk_t *pbit_img_get_track (pbit_img_t *img, unsigned long c, unsigned long h, int alloc) 678 678 + pri_trk_t *pri_img_get_track (pri_img_t *img, unsigned long c, unsigned long h, int alloc) 679 679 { 680 680 - pbit_cyl_t *cyl; 681 681 - pbit_trk_t *trk; 680 680 + pri_cyl_t *cyl; 681 681 + pri_trk_t *trk; 682 682 683 683 - cyl = pbit_img_get_cylinder (img, c, alloc); 683 683 + cyl = pri_img_get_cylinder (img, c, alloc); 684 684 685 685 if (cyl == NULL) { 686 686 return (NULL); 687 687 } 688 688 689 689 - trk = pbit_cyl_get_track (cyl, h, alloc); 689 689 + trk = pri_cyl_get_track (cyl, h, alloc); 690 690 691 691 if (trk == NULL) { 692 692 return (NULL); ··· 695 695 return (trk); 696 696 } 697 697 698 698 - int pbit_img_set_track (pbit_img_t *img, pbit_trk_t *trk, unsigned long c, unsigned long h) 698 698 + int pri_img_set_track (pri_img_t *img, pri_trk_t *trk, unsigned long c, unsigned long h) 699 699 { 700 700 - pbit_cyl_t *cyl; 700 700 + pri_cyl_t *cyl; 701 701 702 702 - cyl = pbit_img_get_cylinder (img, c, 1); 702 702 + cyl = pri_img_get_cylinder (img, c, 1); 703 703 704 704 if (cyl == NULL) { 705 705 return (1); 706 706 } 707 707 708 708 - if (pbit_cyl_set_track (cyl, trk, h)) { 708 708 + if (pri_cyl_set_track (cyl, trk, h)) { 709 709 return (1); 710 710 } 711 711 712 712 return (0); 713 713 } 714 714 715 715 - int pbit_img_del_track (pbit_img_t *img, unsigned long c, unsigned long h) 715 715 + int pri_img_del_track (pri_img_t *img, unsigned long c, unsigned long h) 716 716 { 717 717 if ((c >= img->cyl_cnt) || (img->cyl[c] == NULL)) { 718 718 return (1); 719 719 } 720 720 721 721 - if (pbit_cyl_del_track (img->cyl[c], h)) { 721 721 + if (pri_cyl_del_track (img->cyl[c], h)) { 722 722 return (1); 723 723 } 724 724 725 725 return (0); 726 726 } 727 727 728 728 - int pbit_img_add_comment (pbit_img_t *img, const unsigned char *buf, unsigned cnt) 728 728 + int pri_img_add_comment (pri_img_t *img, const unsigned char *buf, unsigned cnt) 729 729 { 730 730 unsigned char *tmp; 731 731 ··· 743 743 return (0); 744 744 } 745 745 746 746 - int pbit_img_set_comment (pbit_img_t *img, const unsigned char *buf, unsigned cnt) 746 746 + int pri_img_set_comment (pri_img_t *img, const unsigned char *buf, unsigned cnt) 747 747 { 748 748 free (img->comment); 749 749 ··· 754 754 return (0); 755 755 } 756 756 757 757 - if (pbit_img_add_comment (img, buf, cnt)) { 757 757 + if (pri_img_add_comment (img, buf, cnt)) { 758 758 return (1); 759 759 } 760 760

-95

src/drivers/pbit/pbit.h

reviewed

··· 1 1 - /***************************************************************************** 2 2 - * pce * 3 3 - *****************************************************************************/ 4 4 - 5 5 - /***************************************************************************** 6 6 - * File name: src/drivers/pbit/pbit.h * 7 7 - * Created: 2012-01-31 by Hampa Hug <hampa@hampa.ch> * 8 8 - * Copyright: (C) 2012-2013 Hampa Hug <hampa@hampa.ch> * 9 9 - *****************************************************************************/ 10 10 - 11 11 - /***************************************************************************** 12 12 - * This program is free software. You can redistribute it and / or modify it * 13 13 - * under the terms of the GNU General Public License version 2 as published * 14 14 - * by the Free Software Foundation. * 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 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 23 - #ifndef PCE_PBIT_H 24 24 - #define PCE_PBIT_H 1 25 25 - 26 26 - 27 27 - typedef struct { 28 28 - unsigned long clock; 29 29 - 30 30 - unsigned long size; 31 31 - unsigned char *data; 32 32 - 33 33 - unsigned long idx; 34 34 - char wrap; 35 35 - } pbit_trk_t; 36 36 - 37 37 - 38 38 - typedef struct { 39 39 - unsigned long trk_cnt; 40 40 - pbit_trk_t **trk; 41 41 - } pbit_cyl_t; 42 42 - 43 43 - 44 44 - typedef struct { 45 45 - unsigned long cyl_cnt; 46 46 - pbit_cyl_t **cyl; 47 47 - 48 48 - unsigned long comment_size; 49 49 - unsigned char *comment; 50 50 - } pbit_img_t; 51 51 - 52 52 - 53 53 - pbit_trk_t *pbit_trk_new (unsigned long size, unsigned long clock); 54 54 - void pbit_trk_del (pbit_trk_t *trk); 55 55 - pbit_trk_t *pbit_trk_clone (const pbit_trk_t *trk); 56 56 - void pbit_trk_clear (pbit_trk_t *trk, unsigned val); 57 57 - void pbit_trk_clear_16 (pbit_trk_t *trk, unsigned val); 58 58 - void pbit_trk_set_clock (pbit_trk_t *trk, unsigned long clock); 59 59 - unsigned long pbit_trk_get_clock (const pbit_trk_t *trk); 60 60 - unsigned long pbit_trk_get_size (const pbit_trk_t *trk); 61 61 - int pbit_trk_set_size (pbit_trk_t *trk, unsigned long size); 62 62 - 63 63 - void pbit_trk_set_pos (pbit_trk_t *trk, unsigned long pos); 64 64 - int pbit_trk_get_bits (pbit_trk_t *trk, unsigned long *val, unsigned cnt); 65 65 - int pbit_trk_set_bits (pbit_trk_t *trk, unsigned long val, unsigned cnt); 66 66 - int pbit_trk_rotate (pbit_trk_t *trk, unsigned long idx); 67 67 - 68 68 - pbit_cyl_t *pbit_cyl_new (void); 69 69 - void pbit_cyl_del (pbit_cyl_t *cyl); 70 70 - unsigned long pbit_cyl_get_trk_cnt (const pbit_cyl_t *cyl); 71 71 - pbit_trk_t *pbit_cyl_get_track (pbit_cyl_t *cyl, unsigned long idx, int alloc); 72 72 - int pbit_cyl_set_track (pbit_cyl_t *cyl, pbit_trk_t *trk, unsigned long h); 73 73 - int pbit_cyl_add_track (pbit_cyl_t *cyl, pbit_trk_t *trk); 74 74 - int pbit_cyl_del_track (pbit_cyl_t *cyl, unsigned long h); 75 75 - 76 76 - pbit_img_t *pbit_img_new (void); 77 77 - void pbit_img_del (pbit_img_t *img); 78 78 - unsigned long pbit_img_get_cyl_cnt (const pbit_img_t *img); 79 79 - unsigned long pbit_img_get_trk_cnt (const pbit_img_t *img, unsigned long c); 80 80 - 81 81 - pbit_cyl_t *pbit_img_get_cylinder (pbit_img_t *img, unsigned long c, int alloc); 82 82 - pbit_cyl_t *pbit_img_rmv_cylinder (pbit_img_t *img, unsigned long idx); 83 83 - int pbit_img_set_cylinder (pbit_img_t *img, pbit_cyl_t *cyl, unsigned long c); 84 84 - int pbit_img_add_cylinder (pbit_img_t *img, pbit_cyl_t *cyl); 85 85 - int pbit_img_del_cylinder (pbit_img_t *img, unsigned long c); 86 86 - 87 87 - pbit_trk_t *pbit_img_get_track (pbit_img_t *img, unsigned long c, unsigned long h, int alloc); 88 88 - int pbit_img_set_track (pbit_img_t *img, pbit_trk_t *trk, unsigned long c, unsigned long h); 89 89 - int pbit_img_del_track (pbit_img_t *img, unsigned long c, unsigned long h); 90 90 - 91 91 - int pbit_img_add_comment (pbit_img_t *img, const unsigned char *buf, unsigned cnt); 92 92 - int pbit_img_set_comment (pbit_img_t *img, const unsigned char *buf, unsigned cnt); 93 93 - 94 94 - 95 95 - #endif

+31

src/drivers/pri/Makefile.inc

reviewed

··· 1 1 + # src/drivers/pri/Makefile.inc 2 2 + 3 3 + rel := src/drivers/pri 4 4 + 5 5 + DIRS += $(rel) 6 6 + DIST += $(rel)/Makefile.inc 7 7 + 8 8 + DRV_PRI_BAS := \ 9 9 + gcr-mac \ 10 10 + mfm-ibm \ 11 11 + pri-img-pbit \ 12 12 + pri-img-tc \ 13 13 + pri-img \ 14 14 + pri 15 15 + 16 16 + DRV_PRI_SRC := $(foreach f,$(DRV_PRI_BAS),$(rel)/$(f).c) 17 17 + DRV_PRI_OBJ := $(foreach f,$(DRV_PRI_BAS),$(rel)/$(f).o) 18 18 + DRV_PRI_HDR := $(foreach f,$(DRV_PRI_BAS),$(rel)/$(f).h) 19 19 + DRV_PRI_ARC := $(rel)/pri.a 20 20 + 21 21 + CLN += $(DRV_PRI_ARC) $(DRV_PRI_OBJ) 22 22 + DIST += $(DRV_PRI_SRC) $(DRV_PRI_HDR) 23 23 + 24 24 + $(rel)/gcr-mac.o: $(rel)/gcr-mac.c 25 25 + $(rel)/mfm-ibm.o: $(rel)/mfm-ibm.c 26 26 + $(rel)/pri-img-pbit.o: $(rel)/pri-img-pbit.c 27 27 + $(rel)/pri-img-tc.o: $(rel)/pri-img-tc.c 28 28 + $(rel)/pri-img.o: $(rel)/pri-img.c 29 29 + $(rel)/pri.o: $(rel)/pri.c 30 30 + 31 31 + $(rel)/pri.a: $(DRV_PRI_OBJ)

+61

src/drivers/pri/pri-img.h

reviewed

··· 1 1 + /***************************************************************************** 2 2 + * pce * 3 3 + *****************************************************************************/ 4 4 + 5 5 + /***************************************************************************** 6 6 + * File name: src/drivers/pri/pri-io.h * 7 7 + * Created: 2012-01-31 by Hampa Hug <hampa@hampa.ch> * 8 8 + * Copyright: (C) 2012-2013 Hampa Hug <hampa@hampa.ch> * 9 9 + *****************************************************************************/ 10 10 + 11 11 + /***************************************************************************** 12 12 + * This program is free software. You can redistribute it and / or modify it * 13 13 + * under the terms of the GNU General Public License version 2 as published * 14 14 + * by the Free Software Foundation. * 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 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 23 + #ifndef PCE_PRI_IMG_H 24 24 + #define PCE_PRI_IMG_H 1 25 25 + 26 26 + 27 27 + #include <drivers/pri/pri.h> 28 28 + 29 29 + 30 30 + #define PRI_FORMAT_NONE 0 31 31 + #define PRI_FORMAT_PBIT 1 32 32 + #define PRI_FORMAT_TC 2 33 33 + 34 34 + 35 35 + unsigned pri_get_uint16_be (const void *buf, unsigned idx); 36 36 + unsigned pri_get_uint16_le (const void *buf, unsigned idx); 37 37 + 38 38 + unsigned long pri_get_uint32_be (const void *buf, unsigned idx); 39 39 + unsigned long pri_get_uint32_le (const void *buf, unsigned idx); 40 40 + 41 41 + void pri_set_uint16_be (void *buf, unsigned idx, unsigned val); 42 42 + void pri_set_uint16_le (void *buf, unsigned idx, unsigned val); 43 43 + 44 44 + void pri_set_uint32_be (void *buf, unsigned idx, unsigned long val); 45 45 + void pri_set_uint32_le (void *buf, unsigned idx, unsigned long val); 46 46 + 47 47 + 48 48 + int pri_read (FILE *fp, void *buf, unsigned long cnt); 49 49 + int pri_read_ofs (FILE *fp, unsigned long ofs, void *buf, unsigned long cnt); 50 50 + int pri_write (FILE *fp, const void *buf, unsigned long cnt); 51 51 + int pri_skip (FILE *fp, unsigned long cnt); 52 52 + 53 53 + 54 54 + pri_img_t *pri_img_load_fp (FILE *fp, unsigned type); 55 55 + pri_img_t *pri_img_load (const char *fname, unsigned type); 56 56 + 57 57 + int pri_img_save_fp (FILE *fp, const pri_img_t *img, unsigned type); 58 58 + int pri_img_save (const char *fname, const pri_img_t *img, unsigned type); 59 59 + 60 60 + 61 61 + #endif

+95

src/drivers/pri/pri.h

reviewed

··· 1 1 + /***************************************************************************** 2 2 + * pce * 3 3 + *****************************************************************************/ 4 4 + 5 5 + /***************************************************************************** 6 6 + * File name: src/drivers/pri/pri.h * 7 7 + * Created: 2012-01-31 by Hampa Hug <hampa@hampa.ch> * 8 8 + * Copyright: (C) 2012-2013 Hampa Hug <hampa@hampa.ch> * 9 9 + *****************************************************************************/ 10 10 + 11 11 + /***************************************************************************** 12 12 + * This program is free software. You can redistribute it and / or modify it * 13 13 + * under the terms of the GNU General Public License version 2 as published * 14 14 + * by the Free Software Foundation. * 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 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 23 + #ifndef PCE_PRI_H 24 24 + #define PCE_PRI_H 1 25 25 + 26 26 + 27 27 + typedef struct { 28 28 + unsigned long clock; 29 29 + 30 30 + unsigned long size; 31 31 + unsigned char *data; 32 32 + 33 33 + unsigned long idx; 34 34 + char wrap; 35 35 + } pri_trk_t; 36 36 + 37 37 + 38 38 + typedef struct { 39 39 + unsigned long trk_cnt; 40 40 + pri_trk_t **trk; 41 41 + } pri_cyl_t; 42 42 + 43 43 + 44 44 + typedef struct { 45 45 + unsigned long cyl_cnt; 46 46 + pri_cyl_t **cyl; 47 47 + 48 48 + unsigned long comment_size; 49 49 + unsigned char *comment; 50 50 + } pri_img_t; 51 51 + 52 52 + 53 53 + pri_trk_t *pri_trk_new (unsigned long size, unsigned long clock); 54 54 + void pri_trk_del (pri_trk_t *trk); 55 55 + pri_trk_t *pri_trk_clone (const pri_trk_t *trk); 56 56 + void pri_trk_clear (pri_trk_t *trk, unsigned val); 57 57 + void pri_trk_clear_16 (pri_trk_t *trk, unsigned val); 58 58 + void pri_trk_set_clock (pri_trk_t *trk, unsigned long clock); 59 59 + unsigned long pri_trk_get_clock (const pri_trk_t *trk); 60 60 + unsigned long pri_trk_get_size (const pri_trk_t *trk); 61 61 + int pri_trk_set_size (pri_trk_t *trk, unsigned long size); 62 62 + 63 63 + void pri_trk_set_pos (pri_trk_t *trk, unsigned long pos); 64 64 + int pri_trk_get_bits (pri_trk_t *trk, unsigned long *val, unsigned cnt); 65 65 + int pri_trk_set_bits (pri_trk_t *trk, unsigned long val, unsigned cnt); 66 66 + int pri_trk_rotate (pri_trk_t *trk, unsigned long idx); 67 67 + 68 68 + pri_cyl_t *pri_cyl_new (void); 69 69 + void pri_cyl_del (pri_cyl_t *cyl); 70 70 + unsigned long pri_cyl_get_trk_cnt (const pri_cyl_t *cyl); 71 71 + pri_trk_t *pri_cyl_get_track (pri_cyl_t *cyl, unsigned long idx, int alloc); 72 72 + int pri_cyl_set_track (pri_cyl_t *cyl, pri_trk_t *trk, unsigned long h); 73 73 + int pri_cyl_add_track (pri_cyl_t *cyl, pri_trk_t *trk); 74 74 + int pri_cyl_del_track (pri_cyl_t *cyl, unsigned long h); 75 75 + 76 76 + pri_img_t *pri_img_new (void); 77 77 + void pri_img_del (pri_img_t *img); 78 78 + unsigned long pri_img_get_cyl_cnt (const pri_img_t *img); 79 79 + unsigned long pri_img_get_trk_cnt (const pri_img_t *img, unsigned long c); 80 80 + 81 81 + pri_cyl_t *pri_img_get_cylinder (pri_img_t *img, unsigned long c, int alloc); 82 82 + pri_cyl_t *pri_img_rmv_cylinder (pri_img_t *img, unsigned long idx); 83 83 + int pri_img_set_cylinder (pri_img_t *img, pri_cyl_t *cyl, unsigned long c); 84 84 + int pri_img_add_cylinder (pri_img_t *img, pri_cyl_t *cyl); 85 85 + int pri_img_del_cylinder (pri_img_t *img, unsigned long c); 86 86 + 87 87 + pri_trk_t *pri_img_get_track (pri_img_t *img, unsigned long c, unsigned long h, int alloc); 88 88 + int pri_img_set_track (pri_img_t *img, pri_trk_t *trk, unsigned long c, unsigned long h); 89 89 + int pri_img_del_track (pri_img_t *img, unsigned long c, unsigned long h); 90 90 + 91 91 + int pri_img_add_comment (pri_img_t *img, const unsigned char *buf, unsigned cnt); 92 92 + int pri_img_set_comment (pri_img_t *img, const unsigned char *buf, unsigned cnt); 93 93 + 94 94 + 95 95 + #endif

-29

src/utils/pbit/Makefile.inc

reviewed

··· 1 1 - # src/utils/pbit/Makefile.inc 2 2 - 3 3 - rel := src/utils/pbit 4 4 - 5 5 - DIRS += $(rel) 6 6 - DIST += $(rel)/Makefile.inc 7 7 - 8 8 - PBIT_BAS := pbit 9 9 - PBIT_SRC := $(foreach f,$(PBIT_BAS),$(rel)/$(f).c) 10 10 - PBIT_OBJ := $(foreach f,$(PBIT_BAS),$(rel)/$(f).o) 11 11 - PBIT_HDR := $(foreach f,$(PBIT_BAS),$(rel)/$(f).h) 12 12 - PBIT_MAN1 := $(rel)/pbit.1 13 13 - PBIT_BIN := $(rel)/pbit$(EXEEXT) 14 14 - 15 15 - PBIT_OBJ_EXT := \ 16 16 - src/lib/getopt.o \ 17 17 - src/drivers/pbit/pbit.a \ 18 18 - src/drivers/psi/psi.a 19 19 - 20 20 - BIN += $(PBIT_BIN) 21 21 - MAN1 += $(PBIT_MAN1) 22 22 - CLN += $(PBIT_BIN) $(PBIT_OBJ) 23 23 - DIST += $(PBIT_SRC) $(PBIT_HDR) $(PBIT_MAN1) 24 24 - 25 25 - $(rel)/pbit.o: $(rel)/pbit.c 26 26 - 27 27 - $(rel)/pbit$(EXEEXT): $(PBIT_OBJ_EXT) $(PBIT_OBJ) 28 28 - $(QP)echo " LD $@" 29 29 - $(QR)$(LD) $(LDFLAGS_DEFAULT) -o $@ $(PBIT_OBJ) $(PBIT_OBJ_EXT)

+7 -7

src/utils/pbit/pbit.1 src/utils/pri/pri.1

reviewed

··· 1 1 - .TH PBIT 1 "2012-03-10" "HH" "pce" 1 1 + .TH PRI 1 "2013-06-09" "HH" "pce" 2 2 \ 3 3 .SH NAME 4 4 - pbit \- convert and modify PBIT image files 4 4 + pri \- convert and modify PCE raw image files 5 5 6 6 .SH SYNOPSIS 7 7 - .BI pbit " [options] [input-file] [options] [output-file]" 7 7 + .BI pri " [options] [input-file] [options] [output-file]" 8 8 9 9 .SH DESCRIPTION 10 10 - \fBpbit\fR(1) is used to modify and convert PBIT images 10 10 + \fBpri\fR(1) is used to modify and convert PCE raw image 11 11 files. 12 12 13 13 .SH OPTIONS ··· 101 101 Set the image comment to \fItext\fR. 102 102 .TP 103 103 .BI "decode " "type filename" 104 104 - Decode the image and save it as a pfdc sector image to \fIfilename\fR. 104 104 + Decode the image and save it as a pri sector image to \fIfilename\fR. 105 105 Valid decode types are: 106 106 .RS 107 107 .TP ··· 122 122 Remove even numbered tracks. 123 123 .TP 124 124 .BI "encode " "type filename" 125 125 - Load a pfdc sector image from \fIfilename\fR and encode it. 125 125 + Load a pri sector image from \fIfilename\fR and encode it. 126 126 Valid encode types are: 127 127 .RS 128 128 .TP ··· 173 173 .BR pce-ibmpc "(1)," 174 174 .BR pce-macplus "(1)," 175 175 .BR pce-img "(1)," 176 176 - .BR pfdc "(1)" 176 176 + .BR psi "(1)" 177 177 178 178 .SH AUTHOR 179 179 Hampa Hug <hampa@hampa.ch>

+171 -171

src/utils/pbit/pbit.c src/utils/pri/main.c

reviewed

··· 3 3 *****************************************************************************/ 4 4 5 5 /***************************************************************************** 6 6 - * File name: src/utils/pbit/pbit.c * 6 6 + * File name: src/utils/pri/pri.c * 7 7 * Created: 2012-01-31 by Hampa Hug <hampa@hampa.ch> * 8 8 * Copyright: (C) 2012-2013 Hampa Hug <hampa@hampa.ch> * 9 9 *****************************************************************************/ ··· 28 28 29 29 #include <lib/getopt.h> 30 30 31 31 - #include "pbit.h" 31 31 + #include "main.h" 32 32 33 33 #include <drivers/psi/psi-img.h> 34 34 #include <drivers/psi/psi.h> 35 35 36 36 - #include <drivers/pbit/pbit.h> 37 37 - #include <drivers/pbit/pbit-io.h> 38 38 - #include <drivers/pbit/gcr-mac.h> 39 39 - #include <drivers/pbit/mfm-ibm.h> 36 36 + #include <drivers/pri/pri.h> 37 37 + #include <drivers/pri/pri-img.h> 38 38 + #include <drivers/pri/gcr-mac.h> 39 39 + #include <drivers/pri/mfm-ibm.h> 40 40 41 41 42 42 static const char *arg0 = NULL; ··· 46 46 static int par_list = 0; 47 47 static int par_print_info = 0; 48 48 49 49 - static unsigned par_fmt_inp = PBIT_FORMAT_NONE; 50 50 - static unsigned par_fmt_out = PBIT_FORMAT_NONE; 49 49 + static unsigned par_fmt_inp = PRI_FORMAT_NONE; 50 50 + static unsigned par_fmt_out = PRI_FORMAT_NONE; 51 51 52 52 static int par_cyl_all = 1; 53 53 static unsigned long par_cyl[2]; ··· 83 83 void print_help (void) 84 84 { 85 85 pce_getopt_help ( 86 86 - "pbit: convert and modify PCE PBIT image files", 87 87 - "usage: pbit [options] [input] [options] [output]", 86 86 + "pri: convert and modify PCE raw image files", 87 87 + "usage: pri [options] [input] [options] [output]", 88 88 opts 89 89 ); 90 90 ··· 114 114 " gcr, mfm-dd-300, mfm-hd-300, mfm-hd-360\n" 115 115 "\n" 116 116 "file formats are:\n" 117 117 - " pbit, tc\n" 117 117 + " pri, tc\n" 118 118 "\n" 119 119 "track attributes are:\n" 120 120 " clock, data, size\n", ··· 128 128 void print_version (void) 129 129 { 130 130 fputs ( 131 131 - "pbit version " PCE_VERSION_STR 131 131 + "pri version " PCE_VERSION_STR 132 132 "\n\n" 133 133 - "Copyright (C) 2012 Hampa Hug <hampa@hampa.ch>\n", 133 133 + "Copyright (C) 2012-2013 Hampa Hug <hampa@hampa.ch>\n", 134 134 stdout 135 135 ); 136 136 ··· 139 139 140 140 141 141 static 142 142 - int pbit_parse_range (const char *str, unsigned long *v1, unsigned long *v2, int *all) 142 142 + int pri_parse_range (const char *str, unsigned long *v1, unsigned long *v2, int *all) 143 143 { 144 144 *v1 = 0; 145 145 *v2 = 0; ··· 181 181 182 182 183 183 static 184 184 - int pbit_sel_match_track (unsigned c, unsigned h) 184 184 + int pri_sel_match_track (unsigned c, unsigned h) 185 185 { 186 186 if (par_cyl_all == 0) { 187 187 if ((c < par_cyl[0]) || (c > par_cyl[1])) { ··· 198 198 return (1); 199 199 } 200 200 201 201 - int pbit_for_all_tracks (pbit_img_t *img, pbit_trk_cb fct, void *opaque) 201 201 + int pri_for_all_tracks (pri_img_t *img, pri_trk_cb fct, void *opaque) 202 202 { 203 203 unsigned long c, h; 204 204 - pbit_cyl_t *cyl; 205 205 - pbit_trk_t *trk; 204 204 + pri_cyl_t *cyl; 205 205 + pri_trk_t *trk; 206 206 207 207 for (c = 0; c < img->cyl_cnt; c++) { 208 208 cyl = img->cyl[c]; ··· 210 210 for (h = 0; h < cyl->trk_cnt; h++) { 211 211 trk = cyl->trk[h]; 212 212 213 213 - if (pbit_sel_match_track (c, h) == 0) { 213 213 + if (pri_sel_match_track (c, h) == 0) { 214 214 continue; 215 215 } 216 216 ··· 225 225 226 226 227 227 static 228 228 - int pbit_align_gcr_track_cb (pbit_img_t *img, pbit_trk_t *trk, unsigned long c, unsigned long h, void *opaque) 228 228 + int pri_align_gcr_track_cb (pri_img_t *img, pri_trk_t *trk, unsigned long c, unsigned long h, void *opaque) 229 229 { 230 230 unsigned val, run; 231 231 unsigned long bit; 232 232 unsigned long syn1, syn2, syn_cnt; 233 233 unsigned long max1, max2, max_cnt; 234 234 235 235 - pbit_trk_set_pos (trk, 0); 235 235 + pri_trk_set_pos (trk, 0); 236 236 237 237 syn1 = 0; 238 238 syn2 = 0; ··· 246 246 run = 0; 247 247 248 248 while (1) { 249 249 - pbit_trk_get_bits (trk, &bit, 1); 249 249 + pri_trk_get_bits (trk, &bit, 1); 250 250 251 251 val = (val << 1) | (bit & 1); 252 252 run += 1; ··· 275 275 276 276 max1 = (max1 + (max2 - max1) / 2) % trk->size; 277 277 278 278 - pbit_trk_rotate (trk, max1); 278 278 + pri_trk_rotate (trk, max1); 279 279 280 280 return (0); 281 281 } 282 282 283 283 static 284 284 - int pbit_align_gcr_tracks (pbit_img_t *img) 284 284 + int pri_align_gcr_tracks (pri_img_t *img) 285 285 { 286 286 - return (pbit_for_all_tracks (img, pbit_align_gcr_track_cb, NULL)); 286 286 + return (pri_for_all_tracks (img, pri_align_gcr_track_cb, NULL)); 287 287 } 288 288 289 289 290 290 static 291 291 - int pbit_comment_show (pbit_img_t *img) 291 291 + int pri_comment_show (pri_img_t *img) 292 292 { 293 293 unsigned i; 294 294 ··· 304 304 } 305 305 306 306 static 307 307 - int pbit_comment_add (pbit_img_t *img, const char *str) 307 307 + int pri_comment_add (pri_img_t *img, const char *str) 308 308 { 309 309 unsigned char c; 310 310 const unsigned char *tmp; ··· 312 312 if (img->comment_size > 0) { 313 313 c = 0x0a; 314 314 315 315 - if (pbit_img_add_comment (img, &c, 1)) { 315 315 + if (pri_img_add_comment (img, &c, 1)) { 316 316 return (1); 317 317 } 318 318 } 319 319 320 320 tmp = (const unsigned char *) str; 321 321 322 322 - if (pbit_img_add_comment (img, tmp, strlen (str))) { 322 322 + if (pri_img_add_comment (img, tmp, strlen (str))) { 323 323 return (1); 324 324 } 325 325 ··· 327 327 } 328 328 329 329 static 330 330 - int pbit_comment_set (pbit_img_t *img, const char *str) 330 330 + int pri_comment_set (pri_img_t *img, const char *str) 331 331 { 332 332 const unsigned char *tmp; 333 333 334 334 if ((str == NULL) || (*str == 0)) { 335 335 - pbit_img_set_comment (img, NULL, 0); 335 335 + pri_img_set_comment (img, NULL, 0); 336 336 return (0); 337 337 } 338 338 339 339 tmp = (const unsigned char *) str; 340 340 341 341 - if (pbit_img_set_comment (img, tmp, strlen (str))) { 341 341 + if (pri_img_set_comment (img, tmp, strlen (str))) { 342 342 return (1); 343 343 } 344 344 ··· 346 346 } 347 347 348 348 static 349 349 - int pbit_comment_save (pbit_img_t *img, const char *fname) 349 349 + int pri_comment_save (pri_img_t *img, const char *fname) 350 350 { 351 351 unsigned cnt; 352 352 FILE *fp; ··· 378 378 } 379 379 380 380 static 381 381 - int pbit_comment_load (pbit_img_t *img, const char *fname) 381 381 + int pri_comment_load (pri_img_t *img, const char *fname) 382 382 { 383 383 int c, cr; 384 384 unsigned i, nl; ··· 391 391 return (1); 392 392 } 393 393 394 394 - pbit_img_set_comment (img, NULL, 0); 394 394 + pri_img_set_comment (img, NULL, 0); 395 395 396 396 cr = 0; 397 397 nl = 0; ··· 426 426 nl -= 1; 427 427 428 428 if (i >= 256) { 429 429 - pbit_img_add_comment (img, buf, i); 429 429 + pri_img_add_comment (img, buf, i); 430 430 i = 0; 431 431 } 432 432 } ··· 438 438 buf[i++] = c; 439 439 440 440 if (i >= 256) { 441 441 - pbit_img_add_comment (img, buf, i); 441 441 + pri_img_add_comment (img, buf, i); 442 442 i = 0; 443 443 } 444 444 } 445 445 } 446 446 447 447 if (i > 0) { 448 448 - pbit_img_add_comment (img, buf, i); 448 448 + pri_img_add_comment (img, buf, i); 449 449 i = 0; 450 450 } 451 451 ··· 460 460 461 461 462 462 static 463 463 - int pbit_decode_raw_cb (pbit_img_t *img, pbit_trk_t *trk, unsigned long c, unsigned long h, void *opaque) 463 463 + int pri_decode_raw_cb (pri_img_t *img, pri_trk_t *trk, unsigned long c, unsigned long h, void *opaque) 464 464 { 465 465 FILE *fp; 466 466 ··· 473 473 return (0); 474 474 } 475 475 476 476 - int pbit_decode_raw (pbit_img_t *img, const char *fname) 476 476 + int pri_decode_raw (pri_img_t *img, const char *fname) 477 477 { 478 478 int r; 479 479 FILE *fp; ··· 484 484 return (1); 485 485 } 486 486 487 487 - r = pbit_for_all_tracks (img, pbit_decode_raw_cb, fp); 487 487 + r = pri_for_all_tracks (img, pri_decode_raw_cb, fp); 488 488 489 489 fclose (fp); 490 490 ··· 493 493 494 494 495 495 static 496 496 - int pbit_decode_mfm_raw_cb (pbit_img_t *img, pbit_trk_t *trk, unsigned long c, unsigned long h, void *opaque) 496 496 + int pri_decode_mfm_raw_cb (pri_img_t *img, pri_trk_t *trk, unsigned long c, unsigned long h, void *opaque) 497 497 { 498 498 FILE *fp; 499 499 unsigned outbuf, outcnt; ··· 508 508 outbuf = 0; 509 509 outcnt = 0; 510 510 511 511 - pbit_trk_set_pos (trk, 0); 511 511 + pri_trk_set_pos (trk, 0); 512 512 513 513 while (trk->wrap == 0) { 514 514 - pbit_trk_get_bits (trk, &bit, 1); 514 514 + pri_trk_get_bits (trk, &bit, 1); 515 515 516 516 val = (val << 1) | (bit & 1); 517 517 clk = (clk << 1) | ((clk ^ 1) & 1); ··· 541 541 return (0); 542 542 } 543 543 544 544 - int pbit_decode_mfm_raw (pbit_img_t *img, const char *fname) 544 544 + int pri_decode_mfm_raw (pri_img_t *img, const char *fname) 545 545 { 546 546 int r; 547 547 FILE *fp; ··· 552 552 return (1); 553 553 } 554 554 555 555 - r = pbit_for_all_tracks (img, pbit_decode_mfm_raw_cb, fp); 555 555 + r = pri_for_all_tracks (img, pri_decode_mfm_raw_cb, fp); 556 556 557 557 fclose (fp); 558 558 ··· 561 561 562 562 563 563 static 564 564 - int pbit_decode_gcr_raw_cb (pbit_img_t *img, pbit_trk_t *trk, unsigned long c, unsigned long h, void *opaque) 564 564 + int pri_decode_gcr_raw_cb (pri_img_t *img, pri_trk_t *trk, unsigned long c, unsigned long h, void *opaque) 565 565 { 566 566 FILE *fp; 567 567 unsigned val; ··· 569 569 570 570 fp = opaque; 571 571 572 572 - pbit_trk_set_pos (trk, 0); 572 572 + pri_trk_set_pos (trk, 0); 573 573 574 574 val = 0; 575 575 576 576 while (trk->wrap == 0) { 577 577 - pbit_trk_get_bits (trk, &bit, 1); 577 577 + pri_trk_get_bits (trk, &bit, 1); 578 578 579 579 val = (val << 1) | (bit & 1); 580 580 ··· 587 587 return (0); 588 588 } 589 589 590 590 - int pbit_decode_gcr_raw (pbit_img_t *img, const char *fname) 590 590 + int pri_decode_gcr_raw (pri_img_t *img, const char *fname) 591 591 { 592 592 int r; 593 593 FILE *fp; ··· 598 598 return (1); 599 599 } 600 600 601 601 - r = pbit_for_all_tracks (img, pbit_decode_gcr_raw_cb, fp); 601 601 + r = pri_for_all_tracks (img, pri_decode_gcr_raw_cb, fp); 602 602 603 603 fclose (fp); 604 604 ··· 607 607 608 608 609 609 static 610 610 - int pbit_decode (pbit_img_t *img, const char *type, const char *fname) 610 610 + int pri_decode (pri_img_t *img, const char *type, const char *fname) 611 611 { 612 612 - int r; 612 612 + int r; 613 613 psi_img_t *dimg; 614 614 615 615 if (strcmp (type, "gcr-raw") == 0) { 616 616 - return (pbit_decode_gcr_raw (img, fname)); 616 616 + return (pri_decode_gcr_raw (img, fname)); 617 617 } 618 618 else if (strcmp (type, "mfm-raw") == 0) { 619 619 - return (pbit_decode_mfm_raw (img, fname)); 619 619 + return (pri_decode_mfm_raw (img, fname)); 620 620 } 621 621 else if (strcmp (type, "raw") == 0) { 622 622 - return (pbit_decode_raw (img, fname)); 622 622 + return (pri_decode_raw (img, fname)); 623 623 } 624 624 625 625 if (strcmp (type, "gcr") == 0) { 626 626 - dimg = pbit_decode_gcr (img); 626 626 + dimg = pri_decode_gcr (img); 627 627 } 628 628 else if (strcmp (type, "mfm") == 0) { 629 629 - dimg = pbit_decode_mfm (img); 629 629 + dimg = pri_decode_mfm (img); 630 630 } 631 631 else { 632 632 dimg = NULL; ··· 645 645 646 646 647 647 static 648 648 - int pbit_delete_track_cb (pbit_img_t *img, pbit_trk_t *trk, unsigned long c, unsigned long h, void *opaque) 648 648 + int pri_delete_track_cb (pri_img_t *img, pri_trk_t *trk, unsigned long c, unsigned long h, void *opaque) 649 649 { 650 650 - pbit_img_del_track (img, c, h); 650 650 + pri_img_del_track (img, c, h); 651 651 652 652 return (0); 653 653 } 654 654 655 655 static 656 656 - int pbit_delete_tracks (pbit_img_t *img) 656 656 + int pri_delete_tracks (pri_img_t *img) 657 657 { 658 658 - return (pbit_for_all_tracks (img, pbit_delete_track_cb, NULL)); 658 658 + return (pri_for_all_tracks (img, pri_delete_track_cb, NULL)); 659 659 } 660 660 661 661 662 662 static 663 663 - int pbit_double_step (pbit_img_t *img, int even) 663 663 + int pri_double_step (pri_img_t *img, int even) 664 664 { 665 665 - unsigned c, cn; 666 666 - pbit_cyl_t *cyl; 665 665 + unsigned c, cn; 666 666 + pri_cyl_t *cyl; 667 667 668 668 - cn = pbit_img_get_cyl_cnt (img); 668 668 + cn = pri_img_get_cyl_cnt (img); 669 669 670 670 for (c = 0; c < cn; c++) { 671 671 - cyl = pbit_img_rmv_cylinder (img, c); 671 671 + cyl = pri_img_rmv_cylinder (img, c); 672 672 673 673 if (((c & 1) && even) || (((c & 1) == 0) && !even)) { 674 674 - pbit_cyl_del (cyl); 674 674 + pri_cyl_del (cyl); 675 675 } 676 676 else { 677 677 - pbit_img_set_cylinder (img, cyl, c / 2); 677 677 + pri_img_set_cylinder (img, cyl, c / 2); 678 678 } 679 679 } 680 680 ··· 683 683 684 684 685 685 static 686 686 - int pbit_encode (pbit_img_t **img, const char *type, const char *fname) 686 686 + int pri_encode (pri_img_t **img, const char *type, const char *fname) 687 687 { 688 688 - psi_img_t *simg; 689 689 - pbit_img_t *dimg; 688 688 + psi_img_t *simg; 689 689 + pri_img_t *dimg; 690 690 691 691 if ((simg = psi_load (fname, PSI_FORMAT_NONE)) == NULL) { 692 692 return (1); 693 693 } 694 694 695 695 if (strcmp (type, "gcr") == 0) { 696 696 - dimg = pbit_encode_gcr (simg); 696 696 + dimg = pri_encode_gcr (simg); 697 697 } 698 698 else if (strcmp (type, "mfm") == 0) { 699 699 - dimg = pbit_encode_mfm_dd_300 (simg); 699 699 + dimg = pri_encode_mfm_dd_300 (simg); 700 700 } 701 701 else if (strcmp (type, "mfm-dd-300") == 0) { 702 702 - dimg = pbit_encode_mfm_dd_300 (simg); 702 702 + dimg = pri_encode_mfm_dd_300 (simg); 703 703 } 704 704 else if (strcmp (type, "mfm-hd-300") == 0) { 705 705 - dimg = pbit_encode_mfm_hd_300 (simg); 705 705 + dimg = pri_encode_mfm_hd_300 (simg); 706 706 } 707 707 else if (strcmp (type, "mfm-hd-360") == 0) { 708 708 - dimg = pbit_encode_mfm_hd_360 (simg); 708 708 + dimg = pri_encode_mfm_hd_360 (simg); 709 709 } 710 710 else { 711 711 dimg = NULL; 712 712 } 713 713 714 714 if ((dimg != NULL) && (simg->comment_size > 0)) { 715 715 - pbit_img_set_comment (dimg, simg->comment, simg->comment_size); 715 715 + pri_img_set_comment (dimg, simg->comment, simg->comment_size); 716 716 } 717 717 718 718 psi_img_del (simg); ··· 721 721 return (1); 722 722 } 723 723 724 724 - pbit_img_del (*img); 724 724 + pri_img_del (*img); 725 725 726 726 *img = dimg; 727 727 ··· 730 730 731 731 732 732 static 733 733 - int pbit_list_track_cb (pbit_img_t *img, pbit_trk_t *trk, unsigned long c, unsigned long h, void *opaque) 733 733 + int pri_list_track_cb (pri_img_t *img, pri_trk_t *trk, unsigned long c, unsigned long h, void *opaque) 734 734 { 735 735 double rpm; 736 736 ··· 743 743 744 744 printf ("%2lu/%lu: CLK: %lu BITS: %lu RPM: %.4f\n", 745 745 c, h, 746 746 - pbit_trk_get_clock (trk), 747 747 - pbit_trk_get_size (trk), 746 746 + pri_trk_get_clock (trk), 747 747 + pri_trk_get_size (trk), 748 748 rpm 749 749 ); 750 750 ··· 752 752 } 753 753 754 754 static 755 755 - int pbit_list_tracks (pbit_img_t *img) 755 755 + int pri_list_tracks (pri_img_t *img) 756 756 { 757 757 - return (pbit_for_all_tracks (img, pbit_list_track_cb, NULL)); 757 757 + return (pri_for_all_tracks (img, pri_list_track_cb, NULL)); 758 758 } 759 759 760 760 761 761 static 762 762 - int pbit_new_tracks (pbit_img_t *img, pbit_cyl_t *cyl, unsigned c) 762 762 + int pri_new_tracks (pri_img_t *img, pri_cyl_t *cyl, unsigned c) 763 763 { 764 764 - unsigned h, h0, h1; 765 765 - pbit_trk_t *trk; 764 764 + unsigned h, h0, h1; 765 765 + pri_trk_t *trk; 766 766 767 767 if (par_trk_all) { 768 768 h0 = 0; ··· 774 774 } 775 775 776 776 for (h = h0; h < h1; h++) { 777 777 - trk = pbit_img_get_track (img, c, h, 0); 777 777 + trk = pri_img_get_track (img, c, h, 0); 778 778 779 779 if (trk != NULL) { 780 780 continue; 781 781 } 782 782 783 783 - trk = pbit_img_get_track (img, c, h, 1); 783 783 + trk = pri_img_get_track (img, c, h, 1); 784 784 785 785 if (trk == NULL) { 786 786 return (1); 787 787 } 788 788 789 789 - pbit_trk_set_clock (trk, par_data_rate); 789 789 + pri_trk_set_clock (trk, par_data_rate); 790 790 } 791 791 792 792 return (0); 793 793 } 794 794 795 795 static 796 796 - int pbit_new_cylinders (pbit_img_t *img) 796 796 + int pri_new_cylinders (pri_img_t *img) 797 797 { 798 798 - unsigned c, c0, c1; 799 799 - pbit_cyl_t *cyl; 798 798 + unsigned c, c0, c1; 799 799 + pri_cyl_t *cyl; 800 800 801 801 if (par_cyl_all) { 802 802 c0 = 0; ··· 808 808 } 809 809 810 810 for (c = c0; c < c1; c++) { 811 811 - cyl = pbit_img_get_cylinder (img, c, 1); 811 811 + cyl = pri_img_get_cylinder (img, c, 1); 812 812 813 813 if (cyl == NULL) { 814 814 return (1); 815 815 } 816 816 817 817 - if (pbit_new_tracks (img, cyl, c)) { 817 817 + if (pri_new_tracks (img, cyl, c)) { 818 818 return (1); 819 819 } 820 820 } ··· 823 823 } 824 824 825 825 static 826 826 - int pbit_new (pbit_img_t *img) 826 826 + int pri_new (pri_img_t *img) 827 827 { 828 828 - if (pbit_new_cylinders (img)) { 828 828 + if (pri_new_cylinders (img)) { 829 829 fprintf (stderr, "%s: creating failed\n", arg0); 830 830 } 831 831 ··· 834 834 835 835 836 836 static 837 837 - void pbit_print_range (const char *str1, unsigned long v1, unsigned long v2, const char *str2) 837 837 + void pri_print_range (const char *str1, unsigned long v1, unsigned long v2, const char *str2) 838 838 { 839 839 fputs (str1, stdout); 840 840 ··· 849 849 } 850 850 851 851 static 852 852 - void pbit_print_range_float (const char *str1, double v1, double v2, const char *str2) 852 852 + void pri_print_range_float (const char *str1, double v1, double v2, const char *str2) 853 853 { 854 854 fputs (str1, stdout); 855 855 ··· 864 864 } 865 865 866 866 static 867 867 - int pbit_print_info (pbit_img_t *img) 867 867 + int pri_print_info (pri_img_t *img) 868 868 { 869 869 unsigned long c, h, cn, hn, tn; 870 870 unsigned long h1, h2; 871 871 unsigned long len; 872 872 unsigned long clk, clk1, clk2; 873 873 double rpm, rpm1, rpm2; 874 874 - pbit_cyl_t *cyl; 875 875 - pbit_trk_t *trk; 874 874 + pri_cyl_t *cyl; 875 875 + pri_trk_t *trk; 876 876 877 877 - cn = pbit_img_get_cyl_cnt (img); 877 877 + cn = pri_img_get_cyl_cnt (img); 878 878 tn = 0; 879 879 880 880 h1 = 0; ··· 887 887 rpm2 = 0.0; 888 888 889 889 for (c = 0; c < cn; c++) { 890 890 - cyl = pbit_img_get_cylinder (img, c, 0); 890 890 + cyl = pri_img_get_cylinder (img, c, 0); 891 891 892 892 if (cyl == NULL) { 893 893 hn = 0; 894 894 } 895 895 else { 896 896 - hn = pbit_cyl_get_trk_cnt (cyl); 896 896 + hn = pri_cyl_get_trk_cnt (cyl); 897 897 } 898 898 899 899 h1 = ((c == 0) || (hn < h1)) ? hn : h1; ··· 904 904 } 905 905 906 906 for (h = 0; h < hn; h++) { 907 907 - trk = pbit_cyl_get_track (cyl, h, 0); 907 907 + trk = pri_cyl_get_track (cyl, h, 0); 908 908 909 909 if (trk == NULL) { 910 910 clk = 0; 911 911 len = 0; 912 912 } 913 913 else { 914 914 - clk = pbit_trk_get_clock (trk); 915 915 - len = pbit_trk_get_size (trk); 914 914 + clk = pri_trk_get_clock (trk); 915 915 + len = pri_trk_get_size (trk); 916 916 } 917 917 918 918 if (len > 0) { ··· 933 933 } 934 934 935 935 printf ("cylinders: %lu\n", cn); 936 936 - pbit_print_range ("heads: ", h1, h2, "\n"); 936 936 + pri_print_range ("heads: ", h1, h2, "\n"); 937 937 printf ("tracks: %lu\n", tn); 938 938 - pbit_print_range ("clock: ", clk1, clk2, "\n"); 939 939 - pbit_print_range_float ("rpm: ", rpm1, rpm2, "\n"); 938 938 + pri_print_range ("clock: ", clk1, clk2, "\n"); 939 939 + pri_print_range_float ("rpm: ", rpm1, rpm2, "\n"); 940 940 941 941 if (img->comment_size > 0) { 942 942 fputs ("\n", stdout); 943 943 - pbit_comment_show (img); 943 943 + pri_comment_show (img); 944 944 } 945 945 946 946 return (0); ··· 948 948 949 949 950 950 static 951 951 - int pbit_rotate_track_cb (pbit_img_t *img, pbit_trk_t *trk, unsigned long c, unsigned long h, void *opaque) 951 951 + int pri_rotate_track_cb (pri_img_t *img, pri_trk_t *trk, unsigned long c, unsigned long h, void *opaque) 952 952 { 953 953 unsigned long *idx; 954 954 955 955 idx = opaque; 956 956 957 957 - if (pbit_trk_rotate (trk, *idx)) { 957 957 + if (pri_trk_rotate (trk, *idx)) { 958 958 return (1); 959 959 } 960 960 ··· 962 962 } 963 963 964 964 static 965 965 - int pbit_rotate_tracks (pbit_img_t *img, unsigned long idx) 965 965 + int pri_rotate_tracks (pri_img_t *img, unsigned long idx) 966 966 { 967 967 - return (pbit_for_all_tracks (img, pbit_rotate_track_cb, &idx)); 967 967 + return (pri_for_all_tracks (img, pri_rotate_track_cb, &idx)); 968 968 } 969 969 970 970 971 971 static 972 972 - int pbit_edit_clock_cb (pbit_img_t *img, pbit_trk_t *trk, unsigned long c, unsigned long h, void *p) 972 972 + int pri_edit_clock_cb (pri_img_t *img, pri_trk_t *trk, unsigned long c, unsigned long h, void *p) 973 973 { 974 974 - pbit_trk_set_clock (trk, *(unsigned long *) p); 974 974 + pri_trk_set_clock (trk, *(unsigned long *) p); 975 975 return (0); 976 976 } 977 977 978 978 static 979 979 - int pbit_edit_data_cb (pbit_img_t *img, pbit_trk_t *trk, unsigned long c, unsigned long h, void *p) 979 979 + int pri_edit_data_cb (pri_img_t *img, pri_trk_t *trk, unsigned long c, unsigned long h, void *p) 980 980 { 981 981 - pbit_trk_clear (trk, *(unsigned long *) p); 981 981 + pri_trk_clear (trk, *(unsigned long *) p); 982 982 return (0); 983 983 } 984 984 985 985 static 986 986 - int pbit_edit_size_cb (pbit_img_t *img, pbit_trk_t *trk, unsigned long c, unsigned long h, void *p) 986 986 + int pri_edit_size_cb (pri_img_t *img, pri_trk_t *trk, unsigned long c, unsigned long h, void *p) 987 987 { 988 988 - pbit_trk_set_size (trk, *(unsigned long *) p); 988 988 + pri_trk_set_size (trk, *(unsigned long *) p); 989 989 return (0); 990 990 } 991 991 992 992 static 993 993 - int pbit_edit_tracks (pbit_img_t *img, const char *what, const char *val) 993 993 + int pri_edit_tracks (pri_img_t *img, const char *what, const char *val) 994 994 { 995 995 int r; 996 996 unsigned long v; 997 997 - pbit_trk_cb fct; 997 997 + pri_trk_cb fct; 998 998 999 999 v = strtoul (val, NULL, 0); 1000 1000 1001 1001 if (strcmp (what, "clock") == 0) { 1002 1002 - fct = pbit_edit_clock_cb; 1002 1002 + fct = pri_edit_clock_cb; 1003 1003 } 1004 1004 else if (strcmp (what, "data") == 0) { 1005 1005 - fct = pbit_edit_data_cb; 1005 1005 + fct = pri_edit_data_cb; 1006 1006 } 1007 1007 else if (strcmp (what, "size") == 0) { 1008 1008 - fct = pbit_edit_size_cb; 1008 1008 + fct = pri_edit_size_cb; 1009 1009 } 1010 1010 else { 1011 1011 fprintf (stderr, "%s: unknown field (%s)\n", arg0, what); 1012 1012 return (1); 1013 1013 } 1014 1014 1015 1015 - r = pbit_for_all_tracks (img, fct, &v); 1015 1015 + r = pri_for_all_tracks (img, fct, &v); 1016 1016 1017 1017 if (r) { 1018 1018 fprintf (stderr, "%s: editing failed (%s = %lu)\n", ··· 1025 1025 1026 1026 1027 1027 static 1028 1028 - int pbit_operation (pbit_img_t **img, const char *op, int argc, char **argv) 1028 1028 + int pri_operation (pri_img_t **img, const char *op, int argc, char **argv) 1029 1029 { 1030 1030 int r; 1031 1031 char **optarg1, **optarg2; 1032 1032 1033 1033 if (*img == NULL) { 1034 1034 - *img = pbit_img_new(); 1034 1034 + *img = pri_img_new(); 1035 1035 1036 1036 if (*img == NULL) { 1037 1037 return (1); ··· 1041 1041 r = 1; 1042 1042 1043 1043 if (strcmp (op, "auto-align-gcr") == 0) { 1044 1044 - r = pbit_align_gcr_tracks (*img); 1044 1044 + r = pri_align_gcr_tracks (*img); 1045 1045 } 1046 1046 else if (strcmp (op, "comment-add") == 0) { 1047 1047 if (pce_getopt (argc, argv, &optarg1, NULL) != 0) { 1048 1048 return (1); 1049 1049 } 1050 1050 1051 1051 - r = pbit_comment_add (*img, optarg1[0]); 1051 1051 + r = pri_comment_add (*img, optarg1[0]); 1052 1052 } 1053 1053 else if (strcmp (op, "comment-load") == 0) { 1054 1054 if (pce_getopt (argc, argv, &optarg1, NULL) != 0) { 1055 1055 return (1); 1056 1056 } 1057 1057 1058 1058 - r = pbit_comment_load (*img, optarg1[0]); 1058 1058 + r = pri_comment_load (*img, optarg1[0]); 1059 1059 } 1060 1060 else if (strcmp (op, "comment-print") == 0) { 1061 1061 - r = pbit_comment_show (*img); 1061 1061 + r = pri_comment_show (*img); 1062 1062 } 1063 1063 else if (strcmp (op, "comment-save") == 0) { 1064 1064 if (pce_getopt (argc, argv, &optarg1, NULL) != 0) { 1065 1065 return (1); 1066 1066 } 1067 1067 1068 1068 - r = pbit_comment_save (*img, optarg1[0]); 1068 1068 + r = pri_comment_save (*img, optarg1[0]); 1069 1069 } 1070 1070 else if (strcmp (op, "comment-set") == 0) { 1071 1071 if (pce_getopt (argc, argv, &optarg1, NULL) != 0) { 1072 1072 return (1); 1073 1073 } 1074 1074 1075 1075 - r = pbit_comment_set (*img, optarg1[0]); 1075 1075 + r = pri_comment_set (*img, optarg1[0]); 1076 1076 } 1077 1077 else if (strcmp (op, "decode") == 0) { 1078 1078 if (pce_getopt (argc, argv, &optarg1, NULL) != 0) { ··· 1085 1085 return (1); 1086 1086 } 1087 1087 1088 1088 - r = pbit_decode (*img, optarg1[0], optarg2[0]); 1088 1088 + r = pri_decode (*img, optarg1[0], optarg2[0]); 1089 1089 } 1090 1090 else if (strcmp (op, "delete") == 0) { 1091 1091 - r = pbit_delete_tracks (*img); 1091 1091 + r = pri_delete_tracks (*img); 1092 1092 } 1093 1093 else if (strcmp (op, "double-step") == 0) { 1094 1094 - r = pbit_double_step (*img, 1); 1094 1094 + r = pri_double_step (*img, 1); 1095 1095 } 1096 1096 else if (strcmp (op, "double-step-even") == 0) { 1097 1097 - r = pbit_double_step (*img, 0); 1097 1097 + r = pri_double_step (*img, 0); 1098 1098 } 1099 1099 else if (strcmp (op, "double-step-odd") == 0) { 1100 1100 - r = pbit_double_step (*img, 1); 1100 1100 + r = pri_double_step (*img, 1); 1101 1101 } 1102 1102 else if (strcmp (op, "encode") == 0) { 1103 1103 if (pce_getopt (argc, argv, &optarg1, NULL) != 0) { ··· 1110 1110 return (1); 1111 1111 } 1112 1112 1113 1113 - r = pbit_encode (img, optarg1[0], optarg2[0]); 1113 1113 + r = pri_encode (img, optarg1[0], optarg2[0]); 1114 1114 } 1115 1115 else if (strcmp (op, "info") == 0) { 1116 1116 - r = pbit_print_info (*img); 1116 1116 + r = pri_print_info (*img); 1117 1117 } 1118 1118 else if (strcmp (op, "new") == 0) { 1119 1119 - r = pbit_new (*img); 1119 1119 + r = pri_new (*img); 1120 1120 } 1121 1121 else if (strcmp (op, "rotate") == 0) { 1122 1122 unsigned long idx; ··· 1128 1128 1129 1129 idx = strtoul (optarg1[0], NULL, 0); 1130 1130 1131 1131 - r = pbit_rotate_tracks (*img, idx); 1131 1131 + r = pri_rotate_tracks (*img, idx); 1132 1132 } 1133 1133 else if (strcmp (op, "save") == 0) { 1134 1134 if (pce_getopt (argc, argv, &optarg1, NULL) != 0) { ··· 1136 1136 return (1); 1137 1137 } 1138 1138 1139 1139 - r = pbit_decode_raw (*img, optarg1[0]); 1139 1139 + r = pri_decode_raw (*img, optarg1[0]); 1140 1140 } 1141 1141 else { 1142 1142 fprintf (stderr, "%s: unknown operation (%s)\n", arg0, op); ··· 1152 1152 1153 1153 1154 1154 static 1155 1155 - pbit_img_t *pbit_load_image (const char *fname) 1155 1155 + pri_img_t *pri_load_image (const char *fname) 1156 1156 { 1157 1157 - pbit_img_t *img; 1157 1157 + pri_img_t *img; 1158 1158 1159 1159 if (par_verbose) { 1160 1160 fprintf (stderr, "%s: loading image from %s\n", arg0, fname); 1161 1161 } 1162 1162 1163 1163 - img = pbit_img_load (fname, par_fmt_inp); 1163 1163 + img = pri_img_load (fname, par_fmt_inp); 1164 1164 1165 1165 if (img == NULL) { 1166 1166 fprintf (stderr, "%s: loading failed (%s)\n", arg0, fname); ··· 1169 1169 1170 1170 if (par_list) { 1171 1171 par_list = 0; 1172 1172 - pbit_list_tracks (img); 1172 1172 + pri_list_tracks (img); 1173 1173 } 1174 1174 1175 1175 if (par_print_info) { 1176 1176 par_print_info = 0; 1177 1177 - pbit_print_info (img); 1177 1177 + pri_print_info (img); 1178 1178 } 1179 1179 1180 1180 return (img); 1181 1181 } 1182 1182 1183 1183 static 1184 1184 - int pbit_set_format (const char *name, unsigned *val) 1184 1184 + int pri_set_format (const char *name, unsigned *val) 1185 1185 { 1186 1186 if (strcmp (name, "pbit") == 0) { 1187 1187 - *val = PBIT_FORMAT_PBIT; 1187 1187 + *val = PRI_FORMAT_PBIT; 1188 1188 } 1189 1189 else if (strcmp (name, "tc") == 0) { 1190 1190 - *val = PBIT_FORMAT_TC; 1190 1190 + *val = PRI_FORMAT_TC; 1191 1191 } 1192 1192 else { 1193 1193 fprintf (stderr, "%s: unknown format (%s)\n", arg0, name); 1194 1194 - *val = PBIT_FORMAT_NONE; 1194 1194 + *val = PRI_FORMAT_NONE; 1195 1195 return (1); 1196 1196 } 1197 1197 ··· 1202 1202 { 1203 1203 int r; 1204 1204 char **optarg; 1205 1205 - pbit_img_t *img; 1205 1205 + pri_img_t *img; 1206 1206 const char *out; 1207 1207 1208 1208 arg0 = argv[0]; ··· 1231 1231 return (0); 1232 1232 1233 1233 case 'c': 1234 1234 - if (pbit_parse_range (optarg[0], &par_cyl[0], &par_cyl[1], &par_cyl_all)) { 1234 1234 + if (pri_parse_range (optarg[0], &par_cyl[0], &par_cyl[1], &par_cyl_all)) { 1235 1235 return (1); 1236 1236 } 1237 1237 break; 1238 1238 1239 1239 case 'e': 1240 1240 if (img != NULL) { 1241 1241 - if (pbit_edit_tracks (img, optarg[0], optarg[1])) { 1241 1241 + if (pri_edit_tracks (img, optarg[0], optarg[1])) { 1242 1242 return (1); 1243 1243 } 1244 1244 } ··· 1246 1246 1247 1247 case 'f': 1248 1248 if (img != NULL) { 1249 1249 - pbit_print_info (img); 1249 1249 + pri_print_info (img); 1250 1250 } 1251 1251 else { 1252 1252 par_print_info = 1; ··· 1254 1254 break; 1255 1255 1256 1256 case 'h': 1257 1257 - if (pbit_parse_range (optarg[0], &par_trk[0], &par_trk[1], &par_trk_all)) { 1257 1257 + if (pri_parse_range (optarg[0], &par_trk[0], &par_trk[1], &par_trk_all)) { 1258 1258 return (1); 1259 1259 } 1260 1260 break; 1261 1261 1262 1262 case 'i': 1263 1263 if (img != NULL) { 1264 1264 - pbit_img_del (img); 1264 1264 + pri_img_del (img); 1265 1265 } 1266 1266 1267 1267 - img = pbit_load_image (optarg[0]); 1267 1267 + img = pri_load_image (optarg[0]); 1268 1268 1269 1269 if (img == NULL) { 1270 1270 return (1); ··· 1272 1272 break; 1273 1273 1274 1274 case 'I': 1275 1275 - if (pbit_set_format (optarg[0], &par_fmt_inp)) { 1275 1275 + if (pri_set_format (optarg[0], &par_fmt_inp)) { 1276 1276 return (1); 1277 1277 } 1278 1278 break; 1279 1279 1280 1280 case 'l': 1281 1281 if (img != NULL) { 1282 1282 - pbit_list_tracks (img); 1282 1282 + pri_list_tracks (img); 1283 1283 } 1284 1284 else { 1285 1285 par_list = 1; ··· 1291 1291 break; 1292 1292 1293 1293 case 'O': 1294 1294 - if (pbit_set_format (optarg[0], &par_fmt_out)) { 1294 1294 + if (pri_set_format (optarg[0], &par_fmt_out)) { 1295 1295 return (1); 1296 1296 } 1297 1297 break; 1298 1298 1299 1299 case 'p': 1300 1300 - if (pbit_operation (&img, optarg[0], argc, argv)) { 1300 1300 + if (pri_operation (&img, optarg[0], argc, argv)) { 1301 1301 return (1); 1302 1302 } 1303 1303 break; ··· 1311 1311 break; 1312 1312 1313 1313 case 't': 1314 1314 - if (pbit_parse_range (optarg[0], &par_cyl[0], &par_cyl[1], &par_cyl_all)) { 1314 1314 + if (pri_parse_range (optarg[0], &par_cyl[0], &par_cyl[1], &par_cyl_all)) { 1315 1315 return (1); 1316 1316 } 1317 1317 - if (pbit_parse_range (optarg[1], &par_trk[0], &par_trk[1], &par_trk_all)) { 1317 1317 + if (pri_parse_range (optarg[1], &par_trk[0], &par_trk[1], &par_trk_all)) { 1318 1318 return (1); 1319 1319 } 1320 1320 break; ··· 1325 1325 1326 1326 case 0: 1327 1327 if (img == NULL) { 1328 1328 - img = pbit_load_image (optarg[0]); 1328 1328 + img = pri_load_image (optarg[0]); 1329 1329 1330 1330 if (img == NULL) { 1331 1331 return (1); ··· 1350 1350 1351 1351 if (out != NULL) { 1352 1352 if (img == NULL) { 1353 1353 - img = pbit_img_new(); 1353 1353 + img = pri_img_new(); 1354 1354 } 1355 1355 1356 1356 if (img == NULL) { ··· 1361 1361 fprintf (stderr, "%s: save image to %s\n", arg0, out); 1362 1362 } 1363 1363 1364 1364 - r = pbit_img_save (out, img, par_fmt_out); 1364 1364 + r = pri_img_save (out, img, par_fmt_out); 1365 1365 1366 1366 if (r) { 1367 1367 fprintf (stderr, "%s: saving failed (%s)\n",

+6 -6

src/utils/pbit/pbit.h src/utils/pri/main.h

reviewed

··· 3 3 *****************************************************************************/ 4 4 5 5 /***************************************************************************** 6 6 - * File name: src/utils/pbit/main.h * 6 6 + * File name: src/utils/pri/main.h * 7 7 * Created: 2012-01-31 by Hampa Hug <hampa@hampa.ch> * 8 8 * Copyright: (C) 2012-2013 Hampa Hug <hampa@hampa.ch> * 9 9 *****************************************************************************/ ··· 20 20 *****************************************************************************/ 21 21 22 22 23 23 - #ifndef PBIT_MAIN_H 24 24 - #define PBIT_MAIN_H 1 23 23 + #ifndef PRI_MAIN_H 24 24 + #define PRI_MAIN_H 1 25 25 26 26 27 27 - #include <drivers/pbit/pbit.h> 27 27 + #include <drivers/pri/pri.h> 28 28 #include <drivers/psi/psi.h> 29 29 30 30 31 31 - typedef int (*pbit_trk_cb) (pbit_img_t *img, pbit_trk_t *trk, 31 31 + typedef int (*pri_trk_cb) (pri_img_t *img, pri_trk_t *trk, 32 32 unsigned long c, unsigned long h, void *opaque 33 33 ); 34 34 35 35 36 36 - int pbit_for_all_tracks (pbit_img_t *img, pbit_trk_cb fct, void *opaque); 36 36 + int pri_for_all_tracks (pri_img_t *img, pri_trk_cb fct, void *opaque); 37 37 38 38 39 39 #endif

+29

src/utils/pri/Makefile.inc

reviewed

··· 1 1 + # src/utils/pri/Makefile.inc 2 2 + 3 3 + rel := src/utils/pri 4 4 + 5 5 + DIRS += $(rel) 6 6 + DIST += $(rel)/Makefile.inc 7 7 + 8 8 + PRI_BAS := main 9 9 + PRI_SRC := $(foreach f,$(PRI_BAS),$(rel)/$(f).c) 10 10 + PRI_OBJ := $(foreach f,$(PRI_BAS),$(rel)/$(f).o) 11 11 + PRI_HDR := $(foreach f,$(PRI_BAS),$(rel)/$(f).h) 12 12 + PRI_MAN1 := $(rel)/pri.1 13 13 + PRI_BIN := $(rel)/pri$(EXEEXT) 14 14 + 15 15 + PRI_OBJ_EXT := \ 16 16 + src/lib/getopt.o \ 17 17 + src/drivers/pri/pri.a \ 18 18 + src/drivers/psi/psi.a 19 19 + 20 20 + BIN += $(PRI_BIN) 21 21 + MAN1 += $(PRI_MAN1) 22 22 + CLN += $(PRI_BIN) $(PRI_OBJ) 23 23 + DIST += $(PRI_SRC) $(PRI_HDR) $(PRI_MAN1) 24 24 + 25 25 + $(rel)/main.o: $(rel)/main.c 26 26 + 27 27 + $(rel)/pri$(EXEEXT): $(PRI_OBJ_EXT) $(PRI_OBJ) 28 28 + $(QP)echo " LD $@" 29 29 + $(QR)$(LD) $(LDFLAGS_DEFAULT) -o $@ $(PRI_OBJ) $(PRI_OBJ_EXT)