td02lif.h

Go to the documentation of this file.

 
#ifndef _TD02LIF_H_
#define _TD02LIF_H_
 
#define TD_HEADER_SIZE  12
#define TD_COMMENT_SIZE 10
#define TD_TRACK_SIZE   4
#define TD_SECTOR_SIZE  6
 
#define MAXSECTORS 255
 
#define MAXSIDES 2
 
#define MAXCYL 255
 
#define MAXTRACKS (MAXCYL * MAXSIDES)
 
typedef struct tm tm_t;
extern int debuglevel;
 
enum
{
    IBMFORMAT_SD,
    IBMFORMAT_DD
};
 
enum
{
    TD0_INIT,
    TD0_START,
    TD0_WAIT_DIRECTORY,
    TD0_DIRECTORY,
    TD0_WAIT_FILE,
    TD0_FILE,
    TD0_DONE
};
 
typedef struct
{
    uint8_t Header[2+1];                          // Teledisk header + room for EOS
    uint8_t VolNO;                                // Volume sequence number
    uint8_t ChkSig;                               // Check signature
// Used only for multi volume support
// All volumes must have the same value
    uint8_t TDVersion;                            // Teledisk version, (11 = v1.1)
    uint8_t Density;                              // Source disk density
// 0 = 250K
// 1 = 300K
// 2 = 500K
// 128 = single-density FM)
    uint8_t DriveType;                            // Source drive type
// 1 = 360K
// 2 = 1.2M
// 3 = 720K
// 4 = 1.44M
    uint8_t TrackDensity;                         // Track Density with respect to source density
// 0 = single sensity
// 1 = double density
// 2 = quad density)
// If bit 7 is set we have a comment block
    uint8_t DosMode;                              // DOS allocation information used ?
// !0 teledisk used DOS allocation info
// When creating image
    uint8_t Sides;                                // Disk sides stored in the image
    uint16_t CRC;                                 // 16-bit CRC for this header
} td_header_t;
 
typedef struct
{
    uint16_t CRC;                                 // Comment block CRC
    uint16_t Size;                                // Comment Length
    uint8_t Year;                                 // Year     -1900 offset
    uint8_t Month;                                // Month    0..11
    uint8_t Day;                                  // Day      1..31
    uint8_t Hour;                                 // Hour     0..23
    uint8_t Minute;                               // Minute   0..59
    uint8_t Second;                               // Second   0..59
} td_comment_t;
 
typedef struct
{
    uint8_t PSectors;                             // Physical sectors in this track
// 0xff implies end of TeleDisk image
    uint8_t PCyl;                                 // Physical (device) track
    uint8_t PSide;                                // PSide & 0x7f = Physical (device) side
// PSide & 0x80 = IBM format density
// 0x00 = IBM Double Desnity
// 0x80 = IBM Single Sensity
    uint8_t CRC;                                  // LSB of first 3 bytes of track header CRC16
} td_track_t;
 
typedef struct
{
    uint8_t Cyl;                                  // Logical Track number
    uint8_t Side;                                 // Logical Side
    uint8_t Sector;                               // Logical Sector number
    uint8_t SizeExp;                              // Size = 2 ** Slen
// We support 0=128,1=256,2=512,4=1024
    uint8_t Flags;                                // Sector bit flags
// 0x01 = Unsupported ?
// 0x02 = Unsupported use alternate crc
// 0x04 = Unsupported use altrenate data CRC
// 0x08 = Unsupported ?
// 0x10 = Unsupported ?
// 0x20 = Unsuported missing data address mark
// 0x40 = Unsupported ?
// 0x80 = Unsupported ?
    uint8_t CRC;                                  // LSB of sector data CRC16
} td_sector_t;
 
 
typedef struct
{
    int cylinder;                                 // Sectory ID Cylinder
    int side;                                     // Sector ID Side
    int sector;                                   // Sector ID Sector Number
    int size;                                     // Sector ID Sector Size  converted to Bytes
    uint8_t *data;                                // Sector Data
} sector_t;
 
typedef struct
{
    int Cyl;                                      // From TeleDisk Track Header Cylinder Number
    int Side;                                     // From TeleDisk Track Header Side Number
    int Sectors;                                  // TeleDisk count of Sectors on this track
    int First;
    int Last;
    int Size;                                     // Size of first sector
    sector_t sectors[MAXSECTORS];                 // Disk Sectors
} track_t;
 
typedef struct
{
    FILE            *fi;                          // TeleDisk image file handle
    char            *td0_name;                    // TeleDisk file name
    int             compressed;                   // TeleDIsk Image is compressed
    time_t          t;                            // LIF image date in epoch format
    td_header_t     td_header;                    // TeleDisk Header
    td_comment_t    td_comment;                   // Comment Header
    uint8_t         *comment;                     // Optional comment string if td_comment.Size != 0
    track_t         track[MAXTRACKS];             // Track and Sector Data
} disk_t;
 
typedef struct
{
// TD0 to LIF stae information
    int error;                                    // TD0 to LIF error state
    int state;                                    // TD0 to LIF process state machine
    long sectorindex;                             // Sector index reading LIF image inside TeleDisk image
    long writeindex;                              // Sector offset writting LIF image
 
    int             Sectors;                      // LIF image Sectors
    int             Size;                         // LIF image Sector Size
    int             Tracks;                       // LIF image Tracks
    int             Sides;                        // LIF image Sides
    int             Cylinders;                    // LIF image Cylinders
 
    struct
    {
        int first[2];                             // First - lowest sector number found in 30 tracks on each side
        int size[2];                              // Size - of First Sector on each side
        int last[2];                              // Last - highest sector number found (<100) in 30 tracks on each side
        int sectors[2];                           // Sectors - maximum number of sectors found per track in 30 tracks matching Size on each side
    } s;
 
    struct
    {
        int size;                                 // User size override, ONLY use this option if sector with the LOWEST number is does NOT have default SIZE
        int sides;                                // User sides overrride, you can specify LESS then found but not MORE then analise pass
        int tracks;                               // user Tracks override
    } u;
} liftel_t;
 
extern liftel_t liftel;
 
/* td02lif.c */
void td0_B2S ( uint8_t *B , int index , uint8_t *name , int size );
uint16_t td0_crc16 ( uint8_t *B , uint16_t crc , uint16_t poly , int size );
void td0_hexdump ( uint8_t *data , int size );
int td0_unpack_disk_header ( uint8_t *B , td_header_t *p );
int td0_unpack_comment_header ( uint8_t *B , td_comment_t *p );
int td0_unpack_track_header ( uint8_t *B , td_track_t *p );
int td0_unpack_sector_header ( uint8_t *B , td_sector_t *p );
void td0_compressed ( int flag );
int td0_read ( void *p , int osize , int size , FILE *fp );
int td0_rle ( uint8_t *dst , uint8_t *src , int max );
void td0_trackinfo ( disk_t *disk , int trackind , int index );
void td0_sectorinfo ( td_sector_t *P );
long td0_density2bitrate ( uint8_t density );
int td0_open ( disk_t *disk , char *name );
int td0_read_disk ( disk_t *disk );
int td0_analize_format ( disk_t *disk );
int td0_save_lif ( disk_t *disk , lif_t *LIF );
int td0_save_lif_sector ( disk_t *disk , uint8_t *data , int size , lif_t *LIF );
void td0_help ( int full );
void td0_init_liftel ( void );
void td0_init_sectors ( disk_t *disk );
int td02lif ( int argc , char *argv []);
#endif