Previous 15994 Revisions Next

r5799 Saturday 19th September, 2009 at 11:34:36 UTC by Miodrag Milanović
Added Teledisk image file support, read-only, not support compressed format.
[src/mess]mess.mak
[src/mess/formats]flopimg.h td0_dsk.c* td0_dsk.h*
[src/mess/tools/imgtool]imgtool.mak

src/mess/tools/imgtool/imgtool.mak
r5798r5799
4343   $(MESS_FORMATS)/basicdsk.o         \
4444   $(MESS_FORMATS)/coco_dsk.o         \
4545   $(MESS_FORMATS)/coco_cas.o         \
46   $(MESS_FORMATS)/td0_dsk.o         \
4647   $(MESS_FORMATS)/pc_dsk.o         \
4748   $(MESS_FORMATS)/ap2_dsk.o         \
4849   $(MESS_FORMATS)/ap_dsk35.o         \
src/mess/mess.mak
r5798r5799
396396   $(MESS_DEVICES)/cartslot.o   \
397397   $(MESS_DEVICES)/cassette.o   \
398398   $(MESS_DEVICES)/chd_cd.o   \
399   $(MESS_FORMATS)/td0_dsk.o   \
399400   $(MESS_FORMATS)/dsk_dsk.o   \
400401   $(MESS_DEVICES)/flopdrv.o   \
401402   $(MESS_DEVICES)/harddriv.o   \
src/mess/formats/flopimg.h
r5798r5799
7878   const char *param_guidelines;
7979};
8080
81#define FLOPPY_IDENTIFY(name)   floperr_t name(floppy_image *floppy, const struct FloppyFormat *format, int *vote)
82#define FLOPPY_CONSTRUCT(name)   floperr_t name(floppy_image *floppy, const struct FloppyFormat *format, option_resolution *params)
8183
84FLOPPY_IDENTIFY(td0_dsk_identify);
85FLOPPY_CONSTRUCT(td0_dsk_construct);
86
8287#define FLOPPY_OPTIONS_NAME(name)   floppyoptions_##name
8388
8489#define FLOPPY_OPTIONS_START(name)                                    \
8590   const struct FloppyFormat floppyoptions_##name[] =                        \
8691   {                                                         \
8792
88#define FLOPPY_OPTIONS_END                                          \
89      { NULL }                                                \
90   };
9193
9294#define FLOPPY_OPTIONS_EXTERN(name)                                    \
9395   extern const struct FloppyFormat floppyoptions_##name[]                     \
r5798r5799
9597#define FLOPPY_OPTION(name, extensions_, description_, identify_, construct_, ranges_)\
9698   { #name, extensions_, description_, identify_, construct_, ranges_ },            \
9799
100#define FLOPPY_OPTIONS_END                                          \
101      FLOPPY_OPTION( td0, "td0", "TD0 floppy disk image",   td0_dsk_identify, td0_dsk_construct, NULL) \
102      { NULL }                                                \
103   };
98104
105
99106#define PARAM_END            '\0'
100107#define PARAM_HEADS            'H'
101108#define PARAM_TRACKS         'T'
r5798r5799
111118#define INTERLEAVE(range)      "I" #range
112119#define FIRST_SECTOR_ID(range)   "F" #range
113120
114#define FLOPPY_IDENTIFY(name)   floperr_t name(floppy_image *floppy, const struct FloppyFormat *format, int *vote)
115#define FLOPPY_CONSTRUCT(name)   floperr_t name(floppy_image *floppy, const struct FloppyFormat *format, option_resolution *params)
116121
117122/***************************************************************************
118123
src/mess/formats/td0_dsk.c
r0r5799
1/*********************************************************************
2
3   formats/td0_dsk.c
4
5   TD0 disk images
6
7*********************************************************************/
8
9#include <string.h>
10#include "driver.h"
11#include "formats/dsk_dsk.h"
12#include "devices/flopdrv.h"
13
14#define TD0_DSK_TAG   "td0tag"
15
16struct td0dsk_tag
17{
18   int heads;
19   int tracks;
20   int sector_size;
21   UINT64 track_offsets[84*2]; /* offset within data for each track */
22};
23
24
25static struct td0dsk_tag *get_tag(floppy_image *floppy)
26{
27   struct td0dsk_tag *tag;
28   tag = floppy_tag(floppy, TD0_DSK_TAG);
29   return tag;
30}
31
32
33
34FLOPPY_IDENTIFY( td0_dsk_identify )
35{
36   UINT8 header[2];
37
38   floppy_image_read(floppy, header, 0, 2);
39   if (header[0]=='T' && header[1]=='D') {
40      *vote = 100;
41   } else {
42      *vote = 0;
43   }
44   return FLOPPY_ERROR_SUCCESS;
45}
46
47static int td0_get_heads_per_disk(floppy_image *floppy)
48{
49   return get_tag(floppy)->heads;
50}
51
52static int td0_get_tracks_per_disk(floppy_image *floppy)
53{
54   return get_tag(floppy)->tracks;
55}
56
57static UINT64 td0_get_track_offset(floppy_image *floppy, int head, int track)
58{
59   return get_tag(floppy)->track_offsets[(track<<1) + head];
60}
61
62static floperr_t get_offset(floppy_image *floppy, int head, int track, int sector, int sector_is_index, UINT64 *offset)
63{
64   UINT64 offs;
65   UINT8 header[8];
66   UINT8 sectors_per_track;   
67   int i;
68
69   if ((head < 0) || (head >= get_tag(floppy)->heads) || (track < 0) || (track >= get_tag(floppy)->tracks)
70         || (sector < 0) )
71      return FLOPPY_ERROR_SEEKERROR;
72
73   // position on begining of track data
74   offs = td0_get_track_offset(floppy, head, track);
75
76   // read track header
77   floppy_image_read(floppy, header, offs - 4, 4);
78   
79   // take number of sectors per track
80   sectors_per_track = header[0];
81   
82   if (!sector_is_index) {
83      // when taking ID's return seek error if number is over counter
84      if (sector > sectors_per_track) {
85         return FLOPPY_ERROR_SEEKERROR;
86      }
87   }
88   
89   // move trought sectors
90   for(i=0;i < sector-1;i++) {
91      floppy_image_read(floppy, header, offs, 6);
92      offs+= 6;
93      floppy_image_read(floppy, header+6, offs, 2);
94      offs+= 2;     
95      offs+= header[6] + (header[7]<<8);           
96   }   
97   // read size of sector
98   floppy_image_read(floppy, header, offs, 6);
99   get_tag(floppy)->sector_size = 1 << (header[3] + 7);
100
101   if (offset)
102      *offset = offs;
103   return FLOPPY_ERROR_SUCCESS;
104}
105
106
107
108static floperr_t internal_td0_read_sector(floppy_image *floppy, int head, int track, int sector, int sector_is_index, void *buffer, size_t buflen)
109{
110   UINT64 offset;
111   floperr_t err;
112   UINT8 header[9];
113   int size,realsize,i;
114   int buff_pos;
115   int data_pos;
116   UINT8 *data;
117   UINT8 *buf;
118   
119   buf = (UINT8*)buffer;   
120   // take sector offset
121   err = get_offset(floppy, head, track, sector, sector_is_index, &offset);
122   if (err)
123      return err;
124     
125   // read sector header
126   floppy_image_read(floppy, header, offset, 6);
127   offset+=6;
128   floppy_image_read(floppy, header+6, offset, 3);
129   offset+=3;
130   // take data size
131   size = header[6] + (header[7]<<8)-1;
132   // take real sector size
133   realsize =  1 << (header[3] + 7);
134   
135   data = malloc(size);
136   // read sector data
137   floppy_image_read(floppy, data, offset, size);
138   
139   buff_pos = 0;
140   data_pos = 0;
141   
142   switch(header[8]) {
143      case 0:   
144            // encoding type 0
145            //  - plain data
146            memcpy(buffer,data,size);
147            break;     
148      case 1:
149            // encoding type 1
150            //   - 2 bytes size
151            //  - 2 bytes of data
152            //  data is reapeted specified number of times
153            while(buff_pos<realsize) {
154               for (i=0;i<data[data_pos]+(data[data_pos+1] << 8);i++) {
155                  buf[buff_pos] = data[data_pos+2];buff_pos++;
156                  buf[buff_pos] = data[data_pos+3];buff_pos++;
157               }
158               data_pos+=4;
159            }
160            break;
161      case 2:
162            // encoding type 2
163            //   - if first byte is zero next byte represent size of
164            //      plain data after it
165            //   - if different then zero when multiply by 2 represent
166            //      size of data that should be reapeted next byte times
167            while(buff_pos<realsize) {
168               if (data[data_pos]==0x00) {
169                  int size = data[data_pos+1];                 
170                  memcpy(buf+buff_pos,data + data_pos + 2,size);
171                  data_pos += 2 + size;
172                  buff_pos += size;
173               } else {
174                  int size   = 2*data[data_pos];
175                  int repeat = data[data_pos+1];
176                  data_pos+=2;
177                                   
178                  for (i=0;i<repeat;i++) {                     
179                     memcpy(buf + buff_pos,data + data_pos,size);
180                     buff_pos += size;
181                  }
182                  data_pos += size;
183               }
184            }
185            break;
186      default:
187            free(data);
188            return FLOPPY_ERROR_INTERNAL;
189            break;
190   }
191   free(data);
192   return FLOPPY_ERROR_SUCCESS;
193}
194
195
196static floperr_t td0_read_sector(floppy_image *floppy, int head, int track, int sector, void *buffer, size_t buflen)
197{
198   return internal_td0_read_sector(floppy, head, track, sector, FALSE, buffer, buflen);
199}
200
201static floperr_t td0_read_indexed_sector(floppy_image *floppy, int head, int track, int sector, void *buffer, size_t buflen)
202{
203   return internal_td0_read_sector(floppy, head, track, sector, TRUE, buffer, buflen);
204}
205
206static floperr_t td0_get_sector_length(floppy_image *floppy, int head, int track, int sector, UINT32 *sector_length)
207{
208   floperr_t err;
209   err = get_offset(floppy, head, track, sector, FALSE, NULL);
210   if (err)
211      return err;
212
213   if (sector_length) {     
214      *sector_length = get_tag(floppy)->sector_size;
215   }
216   return FLOPPY_ERROR_SUCCESS;
217}
218
219static floperr_t td0_get_indexed_sector_info(floppy_image *floppy, int head, int track, int sector_index, int *cylinder, int *side, int *sector, UINT32 *sector_length, unsigned long *flags)
220{
221   floperr_t retVal;
222   UINT64 offset;
223   UINT8 sector_info[9];
224
225   retVal = get_offset(floppy, head, track, sector_index, FALSE, &offset);
226
227   floppy_image_read(floppy, sector_info, offset, 9);
228   if (cylinder)
229      *cylinder = sector_info[0];
230   if (side)
231      *side = sector_info[1];
232   if (sector)
233      *sector = sector_info[2];
234   if (sector_length) {
235      *sector_length = 1 << (sector_info[3] + 7);
236   }
237   if (flags)
238      *flags = 0;
239   return retVal;
240}
241
242
243FLOPPY_CONSTRUCT( td0_dsk_construct )
244{
245   struct FloppyCallbacks *callbacks;
246   struct td0dsk_tag *tag;
247   UINT8 header[16];
248   int number_of_sectors;
249   int position;
250   int i;
251   int track;
252
253   floppy_image_read(floppy, header, 0, 16);
254
255   tag = (struct td0dsk_tag *) floppy_create_tag(floppy, TD0_DSK_TAG, sizeof(struct td0dsk_tag));
256   if (!tag)
257      return FLOPPY_ERROR_OUTOFMEMORY;
258
259   tag->heads   = header[9];
260   if (tag->heads > 1) {
261      tag->heads  = 2;
262   }
263   
264   //  header len + comment header + comment len
265   position = 12 + 10 + header[14] + (header[15]<<8);
266   tag->tracks = 0;
267   
268   do {
269      // read track header
270      floppy_image_read(floppy, header, position, 4);
271      track = header[1];
272      number_of_sectors = header[0];
273      if (number_of_sectors!=0xff){
274         position+=4;
275         tag->track_offsets[(track<<1) + header[2]] = position;
276         for(i=0;i<number_of_sectors;i++) {
277            // read sector header
278            floppy_image_read(floppy, header, position, 6);
279            position+=6;
280            // read sector size
281            floppy_image_read(floppy, header, position, 2);
282            position+=2;
283            // skip sector data
284            position+= header[0] + (header[1]<<8);
285         }
286         tag->tracks++;
287      }     
288   } while(number_of_sectors!=0xff);
289   tag->tracks++;
290
291   callbacks = floppy_callbacks(floppy);
292   callbacks->read_sector = td0_read_sector;
293   callbacks->read_indexed_sector = td0_read_indexed_sector;
294   callbacks->get_sector_length = td0_get_sector_length;
295   callbacks->get_heads_per_disk = td0_get_heads_per_disk;
296   callbacks->get_tracks_per_disk = td0_get_tracks_per_disk;
297   callbacks->get_indexed_sector_info = td0_get_indexed_sector_info;
298   return FLOPPY_ERROR_SUCCESS;
299}
300
src/mess/formats/td0_dsk.h
r0r5799
1/*********************************************************************
2
3   formats/td0_dsk.h
4
5   TD0 disk images
6
7*********************************************************************/
8
9#ifndef __TD0_DSK_H__
10#define __TD0_DSK_H__
11
12#include "formats/flopimg.h"
13
14#endif /* __TD0_DSK_H__ */

Previous 15994 Revisions Next


© 1998-2018 The MESS Team